USE sofia;
DROP TABLE IF EXISTS sofia.rift_vpl;
CREATE TABLE rift_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 rift_vpl WRITE;
INSERT INTO rift_vpl VALUES ("GN1_1","002_1_1","GEN","1","1","1","ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵉⵅⵍⴻⵇ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN1_2","002_1_2","GEN","1","2","2","ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵅⵍⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵃⵉⴷⵉ ⵃⴻⴷ ⵓ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵜⴰⴵⴻⵙⵜ, ⵓ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵃ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN1_3","002_1_3","GEN","1","3","3","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⴷ ⵜⵉⵍⵉ ⵜⴼⴰⵡⵜ”, ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵜⴼⴰⵡⵜ! ");
INSERT INTO rift_vpl VALUES ("GN1_4","002_1_4","GEN","1","4","4","ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵜⴰⴼⴰⵡⵜ ⵜⴻⵚⴱⴻⵃ ⵓⵛⴰ ⵉⴱⴹⴰ ⴰⵔⴻⴱⴱⵉ ⵊⴰⵔ ⵜⴼⴰⵡⵜ ⴷ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("GN1_5","002_1_5","GEN","1","5","5","ⵉⵍⴰⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵜⴰⴼⴰⵡⵜ ‘ⴰⵣⵉⵍ’ ⵓ ‘ⵜⴰⴵⴻⵙⵜ’ ⵉⵍⴰⵖⴰ ⴰⵙ ‘ⴵⵉⵍⴻⵜ’. ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⵚⵚⴱⴻⵃ: ⴷ ⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("GN1_6","002_1_6","GEN","1","6","6","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⴷ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵍⵇⵓⴱⴱⴻⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵜⴻⴱⴹⴰ ⴰⵎⴰⵏ ⵅ ⵡⴰⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN1_7","002_1_7","GEN","1","7","7","ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⴱⴹⴰ ⴰⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵍⵇⵓⴱⴱⴻⵜ ⵅ ⵡⴰⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵇⵓⴱⴱⴻⵜ. ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN1_8","002_1_8","GEN","1","8","8","ⵉⵍⴰⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⵇⵓⴱⴱⴻⵜ ‘ⴰⵊⴻⵏⵏⴰ’. ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⵚⵚⴱⴻⵃ: ⴷ ⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN1_9","002_1_9","GEN","1","9","9","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⴷ ⵎⵓⵏⴻⵏ ⵡⴰⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⵍⴱⴰⵔⵔ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN1_10","002_1_10","GEN","1","10","10","ⵉⵍⴰⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴱⴰⵔⵔ ‘ⵜⴰⵎⵎⵓⵔⵜ’ ⵓ ⴰⵎⵓⵏⵉ ⵏ ⵡⴰⵎⴰⵏ ⵉⵍⴰⵖⴰ ⴰⵙ ‘ⵍⴻⴱⵃⵓⵔ’. ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("GN1_11","002_1_11","GEN","1","11","11","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⴻⵖⵎⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ: ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ ⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵙ ⴼⵔⵓⵜⴰ ⵉ ⴷⴷ ⵉⵜⵜⵉⵛⴻⵏ ⴼⵔⵓⵜⴰⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏⵜ ⵙ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏⵜ ⴷⴰⵢⴻⵙ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN1_12","002_1_12","GEN","1","12","12","ⵜⴻⵙⵙⴻⵖⵎⵉ-ⴷⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ: ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ ⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵏⴻⵙ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉ ⴷⴷ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏⵜ ⵙ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏⵜ ⴷⴰⵢⴻⵙ. ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("GN1_13","002_1_13","GEN","1","13","13","ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⵚⵚⴱⴻⵃ: ⴷ ⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("GN1_14","002_1_14","GEN","1","14","14","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵜⴼⴰⵡⵉⵏ ⴷⵉ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⴱⴹⴰⵏⵜ ⵊⴰⵔ ⵡⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵍⵉⵎⴰⵔⴰⵜ, ⴷ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴷ ⵡⵓⵙⵙⴰⵏ, ⴷ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ");
INSERT INTO rift_vpl VALUES ("GN1_15","002_1_15","GEN","1","15","15","ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵜⵉⴼⴰⵡⵉⵏ ⴷⵉ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏⵜ ⵜⴰⴼⴰⵡⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN1_16","002_1_16","GEN","1","16","16","ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⴼⴰⵡⵉⵏ ⵎⵖⴰⵔⴻⵏⵜ, ⵜⴰⴼⴰⵡⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴽⴻⵎ ⵅ ⵓⵣⵉⵍ, ⵓ ⵜⴰⴼⴰⵡⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴽⴻⵎ ⵅ ⴵⵉⵍⴻⵜ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵜⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN1_17","002_1_17","GEN","1","17","17","ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏⵜ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏⵜ ⵜⴰⴼⴰⵡⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ");
INSERT INTO rift_vpl VALUES ("GN1_18","002_1_18","GEN","1","18","18","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵏⵜ ⵅ ⵡⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴱⴹⴰⵏⵜ ⵊⴰⵔ ⵜⴼⴰⵡⵜ ⴷ ⵜⴰⴵⴻⵙⵜ. ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("GN1_19","002_1_19","GEN","1","19","19","ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⵚⵚⴱⴻⵃ: ⴷ ⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GN1_20","002_1_20","GEN","1","20","20","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⴷ ⴷⴷ-ⵙⵙⴻⴼⵢⴻⵏ ⵡⴰⵎⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵉⴵⴰ ⴱⵓⵃⴱⴻⵍ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴹⵡⴻⵏ ⵉⵊⴹⴰⴹ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN1_21","002_1_21","GEN","1","21","21","ⵉⵅⵍⴻⵇ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓ ⵎⴰⵔⵔⴰ ⴱⵓⵃⴱⴻⵍ ⵉⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ, ⵉⵏⵏⵉ ⵣⵉ ⴷⴷ-ⵙⵙⴻⴼⵢⴻⵏ ⵡⴰⵎⴰⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏ. ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("GN1_22","002_1_22","GEN","1","22","22","ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⵊⵊⴻⵎ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⴽⵜⴰⵔⴻⵎ, ⵄⴻⵎⵎⴰⵔⴻⵎ ⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⵓⵔ ⵓⵛⴰ ⴰⴷ ⴽⵜⴰⵔⴻⵏ ⵉⵊⴹⴰⴹ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN1_23","002_1_23","GEN","1","23","23","ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⵚⵚⴱⴻⵃ: ⴷ ⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN1_24","002_1_24","GEN","1","24","24","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴻⵊⵊ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴱⵓⵃⴱⴻⵍ ⵉⴷⴷⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵏⴻⵙ: ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⴷ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN1_25","002_1_25","GEN","1","25","25","ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏ, ⵓ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵙⴻⵏ. ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("GN1_26","002_1_26","GEN","1","26","26","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⴰⴷⴰⵎ, ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵖ, ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏⵏⴻⵖ, ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵊⵊⴻⵀⴷ ⵅ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓ ⵅ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("GN1_27","002_1_27","GEN","1","27","27","ⵉⵅⵍⴻⵇ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⴰⴷⴰⵎ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵙ. ⵉⵅⵍⴻⵇ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵅⵍⴻⵇ ⵉ-ⵜⴻⵏ-ⴷⴷ ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ. ");
INSERT INTO rift_vpl VALUES ("GN1_28","002_1_28","GEN","1","28","28","ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ: “ⵊⵊⴻⵎ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⴽⵜⴰⵔⴻⵎ, ⵄⴻⵎⵎⴰⵔⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⵔⵔⴻⵎ ⵜⵜ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵡⴻⵎ, ⵃⴻⴽⵎⴻⵎ ⵅ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓ ⵅ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("GN1_29","002_1_29","GEN","1","29","29","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⵅⵣⴰⵔⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ ⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵅ ⵎⴰⵔⵔⴰ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵙ ⵍⵖⵉⴵⴻⵜ ⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ.    ");
INSERT INTO rift_vpl VALUES ("GN1_30","002_1_30","GEN","1","30","30","ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷⵉ ⵉⴵⴰ ⴱⵓⵃⴱⴻⵍ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵏⵉⵜⵏⵉ.” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN1_31","002_1_31","GEN","1","31","31","ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵓ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⵉⵚⴱⴻⵃ ⴰⵟⵟⴰⵙ. ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⵚⵚⴱⴻⵃ: ⴷ ⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("GN2_1","002_2_1","GEN","2","1","1","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵇⴰⵄ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN2_2","002_2_2","GEN","2","2","2","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵔⴻⴱⴱⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ ⵓⵛⴰ ⵢⴰⵔⴻⵢⵢⴻⵃ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("GN2_3","002_2_3","GEN","2","3","3","ⵉⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ ⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓⵛⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜ, ⵎⵉⵏⵣⵉ ⴷⴰⵢⴻⵙ ⵉ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ, ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⴰⵎⴻⵏⵏⵉ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵍⴰⵎⵉ ⴷⴷ-ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN2_4","002_2_4","GEN","2","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵉⵊⴻⵏⵡⴰⵏ ");
INSERT INTO rift_vpl VALUES ("GN2_5","002_2_5","GEN","2","5","5","- ⵇⴱⴻⵍ ⵜⵓⵖⵉ ⴷⵉⵏ ⵎⴰⵔⵔⴰ ⵛⴱⴰⵔⵇ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵇⴱⴻⵍ ⴷⴷ-ⵉⵖⵎⵉ ⵡⴻⴼⵙⵓ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⵏⵥⴰⵔ ⴰⴷ ⵉⵡⵡⴻⵜ ⵄⴰⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ - ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⴰⴷⴰⵎ ⵄⴰⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴷⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("GN2_6","002_2_6","GEN","2","6","6","ⵜⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵜⴰⵢⵢⵓⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵙⵙⵓ ⵎⴰⵔⵔⴰ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN2_7","002_2_7","GEN","2","7","7","ⵓⵛⴰ ⵉⴽⴻⵡⵡⴻⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷⴰⵎ ⵣⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵓⵛⴰⵍ ⵓⵛⴰ ⵉⵙⵓⴹ ⵍⴻⵄⵡⵉⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⴰⴷⴰⵎ ⴷ ⵉⵊⵊ ⵏ ⵏⵏⴻⴼⵙ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN2_8","002_2_8","GEN","2","8","8","ⵅⴻⵏⵏⵉ ⵉⵥⵥⵓ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵊⵊⴻⵏⵏⴻⵜ ⴷⵉ ⵄⴰⴷⵏ, ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵇ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴷⵉⵏ ⴰⴷⴰⵎ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("GN2_9","002_2_9","GEN","2","9","9","ⵓⵛⴰ ⵉⵙⵙⴻⵖⵎⵉ-ⴷⴷ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ, ⵜⴻⵛⵏⴰ ⵉ ⵍⵅⴻⵥⵔⴰⵜ ⵓ ⵜⵎⵉⵥⵉⴷⵜ ⵉ ⵎⴰⵛⵛⴰ, ⵓⵛⴰ ⵉⵙⵙⴻⵖⵎⵉ-ⴷⴷ ⵍⴰ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵊⵊⴻⵏⵏⴻⵜ ⵓⵍⴰ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵍⵅⴰⵔ ⴷ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN2_10","002_2_10","GEN","2","10","10","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵉⵖⵣⴰⵔ ⵣⵉ ⵄⴰⴷⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵓⵡ ⵊⵊⴻⵏⵏⴻⵜ ⵓ ⵙⵙⴻⵏⵏⵉ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉ ⵉⴳⴳⵉⵏ ⵜⵉⵙⴻⴵⵢⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN2_11","002_2_11","GEN","2","11","11","ⵉⵙⴻⵎ ⵏ ⵢⴻⵖⵣⴰⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⴼⵉⵛⵓⵏ. ⵏⴻⵜⵜⴰ ⵉ ⵉⵏⵏⴹⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵡⵉⵍⴰ ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN2_12","002_2_12","GEN","2","12","12","ⵓⵔⴻⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵚⴱⴻⵃ. ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⴻⵔⵖⴰⵖ ⴰⵛⴻⵎⵍⴰⵍ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴱᵉⴷⵓⵍⴰ’, ⴷ ⵡⴻⵥⵔⵓ ⵏ ‘ⵓⵏⵉⴽⵙ’. ");
INSERT INTO rift_vpl VALUES ("GN2_13","002_2_13","GEN","2","13","13","ⵉⵙⴻⵎ ⵏ ⵉⵖⵣⴰⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵊⵉⵃⵓⵏ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴹⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("GN2_14","002_2_14","GEN","2","14","14","ⵉⵙⴻⵎ ⵏ ⵉⵖⵣⴰⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷ ⵃⵉⴷⴷⴰⵇⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⴰⵛⵛⵓⵔ. ⵓ ⵉⵖⵣⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴷ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("GN2_15","002_2_15","GEN","2","15","15","ⵉⴽⵙⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷⴰⵎ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵄⴰⴷⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵅⴷⴻⵎ ⵓ ⴰⴷ ⵜⵜ ⵉⵃⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("GN2_16","002_2_16","GEN","2","16","16","ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵡⴻⵚⵚⴰ ⴰⴷⴰⵎ, ⵉⵏⵏⴰ: “ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵊⵊⴻⵏⵏⴻⵜ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵎⴰⵛⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("GN2_17","002_2_17","GEN","2","17","17","ⵎⴰⵛⴰ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵍⵅⴰⵔ ⴷ ⵍⵖⴰⵔ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⴷ ⵛⴰ ⵣⵣⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵜⴻⵛⵛⴻⴷ, ⵍⵎⴻⵡⵜ ⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("GN2_18","002_2_18","GEN","2","18","18","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵢⵉⵍⵉ ⴰⴷⴰⵎ ⵡⴻⵃⵃⴷⴻⵙ. ⴰⴷ ⴰⵙ ⴳⴳⴻⵖ ⵡⵉ ⵜ ⵖⴰ ⵉⵄⴰⵡⵏⴻⵏ, ⴰⵎ ⵏⴻⵜⵜⴰ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN2_19","002_2_19","GEN","2","19","19","ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵣⴻⴳ ⵓⵛⴰⵍ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵓ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴰⴷⴰⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵏ ⵖⴰ ⵉⵙⴻⵎⵎⴰ. ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵙⴻⵎⵎⴰ ⴰⴷⴰⵎ ⴽⵓⵍ ⵏⵏⴻⴼⵙ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN2_20","002_2_20","GEN","2","20","20","ⵉⴳⴳⴰ ⴰⴷⴰⵎ ⵉⵙⵎⴰⵡⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵢⴻⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ, ⵎⴰⵛⴰ ⵉ ⴰⴷⴰⵎ ⵡⴰⵔ ⵢⵓⴼⵉ ⵡⵉ ⵜ ⵖⴰ ⵉⵄⴰⵡⵏⴻⵏ ⴷ ⵡⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴰⵎ ⵏⴻⵜⵜⴰ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN2_21","002_2_21","GEN","2","21","21","ⵉⵙⵙⴻⵀⵡⴰ-ⴷⴷ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵊⵊ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ ⵅ ⴰⴷⴰⵎ ⵓⵛⴰ ⵉⵟⵟⴻⵚ. ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵖⴻⵣⴷⵉⵙⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⴰⵎⵛⴰⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵏⵏⵉ ⵙ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN2_22","002_2_22","GEN","2","22","22","ⵢⴰⵔⵔⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵖⴻⵣⴷⵉⵙⵜ ⵜⴻⵏⵏⵉ ⵉ ⵉⴽⵙⵉ ⵣⵉ ⴰⴷⴰⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⴰⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN2_23","002_2_23","GEN","2","23","23","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴷⴰⵎ: “ⵜⵡⴰⵍⴰ-ⵢⴰ ⵜⴰⵏⵉⵜⴰ ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵖⴻⵙ ⵣⴻⴳ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⴷ ⴰⵢⵙⵓⵎ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵉⵏⵓ. ⵜⴰⵏⵉⵜⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ‘ⵜⴰⵔⵢⴰⵣⵜ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵜⴰⵎⵖⴰⵔⵜ’, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵡⴰⴽⵙⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ.” ");
INSERT INTO rift_vpl VALUES ("GN2_24","002_2_24","GEN","2","24","24","ⵅ ⵓⵢⴰ ⴰⴷ ⵉⵙⵎⴻⵃ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⴷⴷⴰⵜ.    ");
INSERT INTO rift_vpl VALUES ("GN2_25","002_2_25","GEN","2","25","25","ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⵉⵄⴰⵔⵢⴰⵏⴻⵏ, ⴰⴷⴰⵎ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⴻⵃⵢⴰ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN3_1","002_3_1","GEN","3","1","1","ⵜⵓⵖⴰ ⴰⴼⵉⵖⴰⵔ ⴷ ⴰⵃⵔⴰⵢⵎⵉ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ. ⵉⵏⵏⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⵎⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: ‘ⵖⴰⵔⵡⴻⵎ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵊⵊⴻⵏⵏⴻⵜ’?” ");
INSERT INTO rift_vpl VALUES ("GN3_2","002_3_2","GEN","3","2","2","ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵓⴼⵉⵖⴰⵔ: “ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵊⵊⴻⵏⵏⴻⵜ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("GN3_3","002_3_3","GEN","3","3","3","ⵎⴰⵛⴰ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵊⵊⴻⵏⵏⴻⵜ, ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: ‘ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵎ, ⵡⴰⵔ ⵜⵜ ⵜⵜⵃⴰⴷⴰⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ.’” ");
INSERT INTO rift_vpl VALUES ("GN3_4","002_3_4","GEN","3","4","4","ⵉⵏⵏⴰ ⵓⴼⵉⵖⴰⵔ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ ⵙ ⵍⵎⴻⵡⵜ ⵇⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("GN3_5","002_3_5","GEN","3","5","5","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ, ⴰⴷ ⴰⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵍⵅⴰⵔ ⵣⵉ ⵍⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN3_6","002_3_6","GEN","3","6","6","ⵜⴻⵥⵔⴰ ⵜⴻⵎⵖⴰⵔⵜ ⴱⴻⵍⵍⵉ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵚⴱⴻⵃ ⵉ ⵎⴰⵛⵛⴰ ⵓⵛⴰ ⵜⴻⵄⵊⴻⴱ ⴰⵙⴻⵏⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⴰⵇⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⴳⴳⴰ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵉⵖⵉⵙⵜ. ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⵜⴻⵛⵛⴰ ⵓⵛⴰ ⵜⴻⵡⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN3_7","002_3_7","GEN","3","7","7","ⵏⵏⴰⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⴼⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵄⴰⵔⵢⴰⵏⴻⵏ. ⵅⴻⵏⵏⵉ ⵅⴻⵢⵢⴹⴻⵏ ⵜⵉⴼⵔⴰⵢ ⵏ ⵡⴰⵔⵜⵓ, ⵓⵛⴰ ⴳⴳⵉⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⵉⴱⴰⵏⵜⵉⵡⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN3_8","002_3_8","GEN","3","8","8","ⵅⴻⵏⵏⵉ ⵙⵍⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⵓⵔ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵖⴰⵔ ⵓⵡⴻⵟⵟⵓ ⵏ ⵜⵎⴻⴷⴷⵉⵜ, ⵓⵛⴰ ⵉⴼⴼⴰⵔ ⴰⴷⴰⵎ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵊⵊⴻⵏⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN3_9","002_3_9","GEN","3","9","9","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷⴰⵎ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏⵉ ⵜⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("GN3_10","002_3_10","GEN","3","10","10","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵖ ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⵅⴻⵏⵏⵉ ⴼⴼⴰⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN3_11","002_3_11","GEN","3","11","11","ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⵡⵉ ⴷ ⴰⵛ ⵉⵏⵏⴰⵏ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴷ ⴰⵄⴰⵔⵢⴰⵏ? ⵎⴰ ⵜⴻⵛⵛⵉⴷ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏⵏⵉ ⵅ ⵛⴻⴽ ⵡⴻⵚⵚⵉⵖ ‘ⴰⵇⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("GN3_12","002_3_12","GEN","3","12","12","ⵉⵏⵏⴰ ⴰⴷⴰⵎ: “ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵛⴰ ⴰⵢⵉ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵓⵛⴰ ⵛⵛⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN3_13","002_3_13","GEN","3","13","13","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⵎⴰⵏⴰⵡⵢⴰ ⵉ ⵜⴻⴳⴳⵉⴷ?” ⵜⴻⵏⵏⴰ ⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ: “ⵉⵖⴰⵔⵔⴰ ⴰⵢⵉ ⵓⴼⵉⵖⴰⵔ ⵓⵛⴰ ⵛⵛⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN3_14","002_3_14","GEN","3","14","14","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⵓⴼⵉⵖⴰⵔ: “ⵍⴰⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ, ⴰⵇⴰ ⴰⵛ ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⵅ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⴰⴷ ⵜⵎⵓⵔⴷⴻⴷ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵓⵛⴰⵍ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN3_15","002_3_15","GEN","3","15","15","ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵄⴷⴰⵡⴰⵜ ⵊⴰⵔ ⴰⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵜ, ⵊⴰⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ. ⴷ ⵜⴻⵏⵏⵉ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵍⴱⴻⵣ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ, ⵓ ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵜⵍⴻⴱⵣⴻⴷ ⴰⵏⵉⵔⵣ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN3_16","002_3_16","GEN","3","16","16","ⵉⵏⵏⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⴰⵟⵟⴰⵙ ⵉ ⵖⴰ ⴰⵔⵏⵉⵖ ⵍⴻⵃⵔⵉⵇ ⴷ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ. ⵙ ⵍⴻⵃⵔⵉⵇ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵡⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵓⵛⴰ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵎⵎⴻⵥⵔⴻⴷ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵎ ⵉⵃⴽⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN3_17","002_3_17","GEN","3","17","17","ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⴰⴷⴰⵎ: “ⵎⵉⵏⵣⵉ ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⵜⴻⵛⵛⵉⴷ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵅ ⵛⴻⴽ ⵡⴻⵚⵚⵉⵖ: ‘ⴰⵇⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⴷ!’, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ. ⵙ ⵜⴰⵎⴰⵔⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⴷ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN3_18","002_3_18","GEN","3","18","18","ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⵉ ⴷ ⴰⵛ ⴷⴷ ⵖⴰ ⵜⴻⵙⵙⴻⵖⵎⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⴼⵙⵓ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN3_19","002_3_19","GEN","3","19","19","ⵙ ⵜⵉⴷⵉ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵣⵉ ⵜⴻⵎⵎⴻⴽⵙⵉⴷ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⴰⵛⴰⵍ ⵓⵛⴰ ⵖⴰⵔ ⵓⵛⴰⵍ ⵉ ⵖⴰ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN3_20","002_3_20","GEN","3","20","20","ⵉⵍⴰⵖⴰ ⴰⴷⴰⵎ ⵉⵙⴻⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵃⴰⵡⵡⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN3_21","002_3_21","GEN","3","21","21","ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⴰⴷⴰⵎ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵔⵔⵓⴹ ⵙ ⵢⵉⵍⴻⵎ ⵓⵛⴰ ⵢⴰⵔⴹ ⴰⵙⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN3_22","002_3_22","GEN","3","22","22","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ: “ⵅⵣⴰⵔ, ⴰⴷⴰⵎ ⵡⴰ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ, ⵉⵙⵙⴻⵏ ⵍⵅⴰⵔ ⴷ ⵍⵖⴰⵔ. ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵉⵙⵙⵡⴰⵥⵥⴰⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⵙⵉ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵄⴰⵡⴻⴷ, ⴰⴷ ⵢⴻⵛⵛ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN3_23","002_3_23","GEN","3","23","23","ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵉ-ⵜ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵄⴰⴷⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴷⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴻⴽⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("GN3_24","002_3_24","GEN","3","24","24","ⵢⵓⵥⵥⴻⵍ ⵅ ⴰⴷⴰⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵛⵛⴰⵔⵇ ⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵄⴰⴷⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇ, ⵉⵜⵜⴻⵛⴹⵉⴹⵉⵃ ⵙⵙⴰ ⴷ ⵙⵙⴰ ⵉ ⵓⵄⴻⵙⵙⵉ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN4_1","002_4_1","GEN","4","1","1","ⵉⵙⵙⴻⵏ ⴰⴷⴰⵎ ⵃⴰⵡⵡⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⴻⵢⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵇⴰⵢⵉⵏ, ⵜⴻⵏⵏⴰ “ⵊⵊⵉⵖ-ⴷⴷ ⴰⵔⵢⴰⵣ, ⴷ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN4_2","002_4_2","GEN","4","2","2","ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵓⵎⴰⵙ ⵀⴰⴱⵉⵍ. ⵜⵓⵖⴰ ⵀⴰⴱⵉⵍ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵏ ⵡⵓⴵⵉ ⵓ ⵇⴰⵢⵉⵏ ⵉⵔⵓⵃ ⵉⵅⴻⴷⴷⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN4_3","002_4_3","GEN","4","3","3","ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵓⵙⵙⴰⵏ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵇⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN4_4","002_4_4","GEN","4","4","4","ⵉⵇⴻⴷⴷⴻⵎ ⵀⴰⴱⵉⵍ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵣⴻⴳ ⵉⵎⴻⵏⵣⴰ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ, ⵣⴻⴳ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴰⴷⵓⵏⵜ ⴰⵟⵟⴰⵙ. ⵉⵅⵣⴰⵔ ⵙⵉⴷⵉ ⵖⴰⵔ ⵀⴰⴱⵉⵍ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("GN4_5","002_4_5","GEN","4","5","5","ⵎⴰⵛⴰ ⵖⴰⵔ ⵇⴰⵢⵉⵏ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴰⵔⵔⵉ ⵛⴰ ⵜⴰⵢⵏⵉⵜ. ⵓⵛⴰ ⵉⵅⴻⵢⵢⴻⵇ ⵇⴰⵢⵉⵏ ⴰⵟⵟⴰⵙ, ⵉⵏⵏⴻⵇⵍⴻⴱ ⴰⵙ ⵓⵖⴻⵎⴱⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN4_6","002_4_6","GEN","4","6","6","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵇⴰⵢⵉⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵅⴻⵢⵢⵇⴻⴷ? ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵛ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⵖⴻⵎⴱⵓⴱ? ");
INSERT INTO rift_vpl VALUES ("GN4_7","002_4_7","GEN","4","7","7","ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ, ⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵓ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ, ⴷⴷⴻⵏⴱ ⴰⵇⴰ-ⵜ ⵉⵣⵣⴻⵍ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ? ⵎⴻⵥⵔⵉ ⵏⵏⴻⵙ ⵖⴰⵔⴻⴽ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⴰⴷ ⵅⴰⵙ ⵜⵙⴻⴵⴹⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN4_8","002_4_8","GEN","4","8","8","ⵉⵙⵙⵉⵡⴻⵍ ⵇⴰⵢⵉⵏ ⴰⴽ-ⴷ ⵀⴰⴱⵉⵍ ⵓⵎⴰⵙ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⴵⴰⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴱⴻⵍⵍⵉ ⵇⴰⵢⵉⵏ ⵉⴽⴽⴰⵔ ⵖⴰⵔ ⵓⵎⴰⵙ ⵀⴰⴱⵉⵍ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN4_9","002_4_9","GEN","4","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵇⴰⵢⵉⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵎⴰⵛ ⵀⴰⴱⵉⵍ?” ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ. ⵎⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵅ ⵓⵎⴰ?” ");
INSERT INTO rift_vpl VALUES ("GN4_10","002_4_10","GEN","4","10","10","ⵓⵛⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ? ⴰⵇⴰ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵎⴰⵛ ⵙⵖⵓⵢⵢⵓⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN4_11","002_4_11","GEN","4","11","11","ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵎⴻⵏⵄⵓⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⴱⴻⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵎⴰⵛ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN4_12","002_4_12","GEN","4","12","12","ⵅⵎⵉ ⵖⴰ ⵜⵅⴻⴷⵎⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵜⵜᵉⴷⵉⴽⴽⵯⵉⵍ ⴰⴷ ⴰⵛ ⵜⴻⵡⵛ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵏⵏⴻⵊⵔⵓ ⴷ ⴰⵎⴻⵜⵍⵓⵄ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN4_13","002_4_13","GEN","4","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵇⴰⵢⵉⵏ ⵉ ⵙⵉⴷⵉ: “ⵍⵄⵉⵇⴰⴱ ⵉⵏⵓ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵅ ⵜⵣⴻⵎⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN4_14","002_4_14","GEN","4","14","14","ⴰⵇⴰ ⵛⴻⴽ ⴰⵙⵙ-ⴰ ⵜⵓⵥⵥⵍⴻⴷ ⵅⴰⴼⵉ ⵣⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵓⵛⴰ ⵣⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⴼⴼⴰⵔⴻ. ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⴻⵏⵏⴻⵊⵔⵓ ⴷ ⴰⵎⴻⵜⵍⵓⵄ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⴰⴼⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN4_15","002_4_15","GEN","4","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵙ ⵓⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵖⴻⵏ ⵇⴰⵢⵉⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵅⴻⵍⴼⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ⵓⵛⴰ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵇⴰⵢⵉⵏ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵜ ⵖⴰ ⵢⴰⴼⴻⵏ ⵡⴰⵔ ⵜ ⵉⵏⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("GN4_16","002_4_16","GEN","4","16","16","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵇⴰⵢⵉⵏ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵏⵓⴷ, ⵛⵛⴰⵔⵇ ⵏ ⵄⴰⴷⵏ. ");
INSERT INTO rift_vpl VALUES ("GN4_17","002_4_17","GEN","4","17","17","ⵉⵙⵙⴻⵏ ⵇⴰⵢⵉⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵢⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵃⴰⵏⵓⵅ. ⵜⵓⵖⴰ ⵇⴰⵢⴻⵏ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵎ ⵢⵉⵙⴻⵎ ⵏ ⵎⵎⵉⵙ ⵃⴰⵏⵓⵅ. ");
INSERT INTO rift_vpl VALUES ("GN4_18","002_4_18","GEN","4","18","18","ⵃⴰⵏⵓⵅ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵉⵔⴰⴷ, ⵓ ⵄⵉⵔⴰⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵎⵉⵃⵓⵢⴰ’ⵉⵍ ⵓ ⵎⵉⵃⵓⵢⴰ’ⵉⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵜⵓⵛⴰ’ⵉⵍ ⵓ ⵎⴰⵜⵓⵛⴰ’ⵉⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵍⴰⵎⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("GN4_19","002_4_19","GEN","4","19","19","ⵉⵎⵍⴻⵛ ⵍⴰⵎⴰⴽ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵉⵛⵜⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⴰⴷⴰ, ⵜⴻⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵚⵉⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("GN4_20","002_4_20","GEN","4","20","20","ⵜⵓⵔⵓⵡ-ⴷⴷ ⵄⴰⴷⴰ ⵢⴰⴱⴰⵍ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵉⵇⵉⴹⴰⵏ ⵓ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN4_21","002_4_21","GEN","4","21","21","ⵉⵙⴻⵎ ⵏ ⵓⵎⴰⵙ ⵜⵓⵖⴰ ⴷ ⵢⵓⴱⴰⵍ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵉⵔⴰⵔⴻⵏ ⵍⴳⴰⵎⴱⵔⵉ ⴷ ⵜⴻⵎⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("GN4_22","002_4_22","GEN","4","22","22","ⵚⵉⵍⵍⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵜⵓⴱⴰⵍ-ⵇⴰⵢⵉⵏ, ⴰⵎⵣⵉⵍ ⵏ ⵉⵎⵣⵉⵍⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵙ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ. ⵓⵍⵜⵎⴰⵙ ⵏ ⵜⵓⴱⴰⵍ-ⵇⴰⵢⵉⵏ ⵜⵓⵖⴰ ⴷ ⵏⴰⵄⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("GN4_23","002_4_23","GEN","4","23","23","ⵉⵏⵏⴰ ⵍⴰⵎⴰⴽ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⵄⴰⴷⴰ ⴷ ⵚⵉⵍⵍⴰ: “ⵙⵍⴻⵏⵜ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⵍⴰⵎⴰⴽ! ⵙⵍⴻⵏⵜ ⵖⴰⵔ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ. ⴰⵇⴰ ⵏⵖⵉⵖ ⴰⵔⵢⴰⵣ ⵉ ⵓⵢⴻⵣⵣⵉⵎ ⵉⵏⵓ ⴷ ⵓⵃⴻⵏⵊⵉⵔ ⵉ ⵓⵢⴻⴷⴷⵉⵎ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("GN4_24","002_4_24","GEN","4","24","24","ⴰⵇⴰ ⴰⴷ ⵅⴻⵍⴼⴻⵏ ⵣⵉ ⵇⴰⵢⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵣⵉ ⵍⴰⵎⴰⴽ ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN4_25","002_4_25","GEN","4","25","25","ⵢⵓⴷⴻⴼ ⴰⴷⴰⵎ ⵄⴰⵡⴻⴷ ⵅ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵏⴻⵜⵜⴰⵜ ⴰⵃⴻⵏⵊⵉⵔ. ⵜⵍⴰⵖⴰ ⴰⵙ ⵛⵉⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵀⴰⴱⵉⵍ, ⵎⵉⵏⵣⵉ ⵇⴰⵢⵉⵏ ⵉⵏⵖⴰ ⵉ-ⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN4_26","002_4_26","GEN","4","26","26","ⵓⵍⴰ ⵉ ⵛⵉⵜ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵓⵙⴻⵢⵎⵉ, ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⴰⵏⵓⵛ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴷⴰ ⴱⵏⴰⴷⴻⵎ ⵙ ⵓⵍⴰⵖⵉ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵡⴰ ⴷ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN5_1","002_5_1","GEN","5","1","1","ⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷⴰⵎ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN5_2","002_5_2","GEN","5","2","2","ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ ⵉⵅⵍⴻⵇ ⵉ-ⵜⴻⵏ-ⴷⴷ. ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ‘ⴰⴷⴰⵎ’, ⴱⵏⴰⴷⴻⵎ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵅⵍⴻⵇ.    ");
INSERT INTO rift_vpl VALUES ("GN5_3","002_5_3","GEN","5","3","3","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⴰⴷⴰⵎ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵛⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_4","002_5_4","GEN","5","4","4","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵛⵉⵜ, ⵉⴷⴷⴰⵔ ⴰⴷⴰⵎ ⵄⴰⴷ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_5","002_5_5","GEN","5","5","5","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⴰⴷⴰⵎ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_6","002_5_6","GEN","5","6","6","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵛⵉⵜ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⴰⵏⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("GN5_7","002_5_7","GEN","5","7","7","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⴰⵏⵓⵛ, ⵉⴷⴷⴰⵔ ⵛⵉⵜ ⵄⴰⴷ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_8","002_5_8","GEN","5","8","8","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵛⵉⵜ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_9","002_5_9","GEN","5","9","9","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⴰⵏⵓⵛ ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵇⵉⵏⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("GN5_10","002_5_10","GEN","5","10","10","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵇⵉⵏⴰⵏ, ⵉⴷⴷⴰⵔ ⴰⵏⵓⵛ ⵄⴰⴷ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_11","002_5_11","GEN","5","11","11","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⴰⵏⵓⵛ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_12","002_5_12","GEN","5","12","12","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵇⵉⵏⴰⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN5_13","002_5_13","GEN","5","13","13","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ, ⵉⴷⴷⴰⵔ ⵇⵉⵏⴰⵏ ⵄⴰⴷ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_14","002_5_14","GEN","5","14","14","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵇⵉⵏⴰⵏ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_15","002_5_15","GEN","5","15","15","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN5_16","002_5_16","GEN","5","16","16","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵢⴰⵔⴰⴷ, ⵉⴷⴷⴰⵔ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ ⵄⴰⴷ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_17","002_5_17","GEN","5","17","17","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_18","002_5_18","GEN","5","18","18","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵢⴰⵔⴰⴷ ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵃⴰⵏⵓⵅ.    ");
INSERT INTO rift_vpl VALUES ("GN5_19","002_5_19","GEN","5","19","19","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵃⴰⵏⵓⵅ, ⵉⴷⴷⴰⵔ ⵢⴰⵔⴰⴷ ⵄⴰⴷ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_20","002_5_20","GEN","5","20","20","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵢⴰⵔⴰⴷ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_21","002_5_21","GEN","5","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵃⴰⵏⵓⵅ ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵜⵓⵛⴰⵍⴰⵃ.    ");
INSERT INTO rift_vpl VALUES ("GN5_22","002_5_22","GEN","5","22","22","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵎⴰⵜⵓⵛⴰⵍⴰⵃ, ⵢⵓⵢⵓⵔ ⵃⴰⵏⵓⵅ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_23","002_5_23","GEN","5","23","23","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵃⴰⵏⵓⵅ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN5_24","002_5_24","GEN","5","24","24","ⵢⵓⵢⵓⵔ ⵃⴰⵏⵓⵅ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵄⴰⴷ ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴽⵙⵉ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_25","002_5_25","GEN","5","25","25","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵎⴰⵜⵓⵛⴰⵍⴰⵃ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵍⴰⵎⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("GN5_26","002_5_26","GEN","5","26","26","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵍⴰⵎⴰⴽ, ⵉⴷⴷⴰⵔ ⵎⴰⵜⵓⵛⴰⵍⴰⵃ ⵄⴰⴷ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_27","002_5_27","GEN","5","27","27","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵎⴰⵜⵓⵛⴰⵍⴰⵃ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⴻⵙⵄⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_28","002_5_28","GEN","5","28","28","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵍⴰⵎⴰⴽ ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN5_29","002_5_29","GEN","5","29","29","ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵏⵓⵃ, ⵉⵏⵏⴰ: “ⵡⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵖ ⴷ ⵜⴰⵎⴰⵔⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵏⵄⴻⵍ ⵜⴰⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("GN5_30","002_5_30","GEN","5","30","30","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵏⵓⵃ, ⵉⴷⴷⴰⵔ ⵍⴰⵎⴰⴽ ⵄⴰⴷ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN5_31","002_5_31","GEN","5","31","31","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵍⴰⵎⴰⴽ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN5_32","002_5_32","GEN","5","32","32","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴷⴰⵔ ⵏⵓⵃ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵏⵓⵃ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵎ ⴷ ⵃⴰⵎ ⴷ ⵢⴰⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GN6_1","002_6_1","GEN","6","1","1","ⵍⴰⵎⵉ ⴱⴷⴰⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⴽⵜⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵓⵔⵡⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN6_2","002_6_2","GEN","6","2","2","ⴰⵇⴰ ⵥⵔⵉⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵛⵏⴰⵏⵜ, ⵓⵛⴰ ⴽⵙⵉⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ.    ");
INSERT INTO rift_vpl VALUES ("GN6_3","002_6_3","GEN","6","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵍⴻⴱⴷⴰ ⴷⵉ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴷⴷⴰⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵡⴻⴷⴷⴰⵔ ⵏⵏⴻⵙ. ⴰⴷ ⵉⵍⵉⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN6_4","002_6_4","GEN","6","4","4","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ‘ⵉⵏⵉⴼⵉⵍⵉⵎ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ’, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ, ⵓⵎⵉ ⴷⴷ-ⵓⴷⴼⴻⵏ ⴰⵔⵔⴰⵡ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⵡⴷⴰⵏ ⵓⵛⴰ ⵓⵔⵡⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ. ⵏⵉⵜⵏⵉ ⴷ ‘ⵊⵊⵡⴰⵀⴻⵍ’ ⵏ ⵣⵣⵎⴰⵏ ⵏⵏⵉ, ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵙ ⵢⵉⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN6_5","002_6_5","GEN","6","5","5","ⵉⵥⵔⴰ ⵙⵉⴷⵉ ⴱⴻⵍⵍⵉ ⵍⵖⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵟⵟⴰⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵡⴰⵢⴰⵍ ⵏ ⵓⵅⴰⵔⵔⴻⵚ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("GN6_6","002_6_6","GEN","6","6","6","ⵓⵛⴰ ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵓⵎⵉ ⵉⴳⴳⴰ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵇⵇⴻⵙ ⴰⵙ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN6_7","002_6_7","GEN","6","7","7","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴰⴷ ⵎⵃⵉⵖ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴱⵏⴰⴷⴻⵎ ⵉ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ, ⴱⵏⴰⴷⴻⵎ ⴰⴽ-ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⴷⵎⴻⵖ ⵓⵎⵉ ⵜⴻⵏ ⴳⴳⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN6_8","002_6_8","GEN","6","8","8","ⵎⴰⵛⴰ ⵏⵓⵃ ⵢⵓⴼⴰ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵏⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GN6_9","002_6_9","GEN","6","9","9","ⵜⵓⵖⴰ ⵏⵓⵃ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⴽⵎⴻⵍ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⵢⵓⵢⵓⵔ ⵏⵓⵃ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN6_10","002_6_10","GEN","6","10","10","ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵏⵓⵃ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ: ⵛⴰⵎ ⴷ ⵃⴰⵎ ⴷ ⵢⴰⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GN6_11","002_6_11","GEN","6","11","11","ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴰⵔⴱⴻⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("GN6_12","002_6_12","GEN","6","12","12","ⵉⵅⵣⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵜⵓⵖⴰ ⵅⴰⵔⵔⴱⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN6_13","002_6_13","GEN","6","13","13","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵓⵃ: “ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⴰⵇⴰ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵄⵓⵏⴼ ⵣⵣⴰⵢⵙⴻⵏ. ⴰⵇⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN6_14","002_6_14","GEN","6","14","14","ⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵎⴻⵔⵣⵉ ⵓⵛⴰ ⴻⴳⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ. ⵖⴻⴵⴻⴼ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵣⵉ ⴷⴰⵅⴻⵍ ⵓ ⵣⵉ ⴱⴰⵔⵔⴰ ⵙ ⵜⵉⵣⴻⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("GN6_15","002_6_15","GEN","6","15","15","ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ: ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN6_16","002_6_16","GEN","6","16","16","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⴱⵓⵔⵊⴻⵜ ⵉ ⵜⴼⴰⵡⵜ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ. ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵟⵟⴻⴱⵇⴻⵜ ⵏ ⵡⴰⴷⴷⴰⵢ ⴷ ⵟⵟⴻⴱⵇⴻⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⴷ ⵟⵟⴻⴱⵇⴻⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("GN6_17","002_6_17","GEN","6","17","17","ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵙⵙⴻⵃⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉ ⴷⵉ ⵉⴵⴰ ⴰⵔⵔⵓⵃ ⵏ ⵜⵓⴷⴰⵔⵜ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵉⴹⵍⴻⵇ ⵉ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN6_18","002_6_18","GEN","6","18","18","ⵎⴰⵛⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("GN6_19","002_6_19","GEN","6","19","19","ⵓⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵜⵢⵓⵢⴰ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⴰⴽⵉⴷⴻⴽ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ. ");
INSERT INTO rift_vpl VALUES ("GN6_20","002_6_20","GEN","6","20","20","ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵜⴰⵙ ⵜⵢⵓⵢⴰ ⵣⵉ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ: ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰⵜ ⵏⵙⴻⵏ, ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰⵜ ⵏⵙⴻⵏⵜ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN6_21","002_6_21","GEN","6","21","21","ⵓⵛⴰ ⵛⴻⴽ, ⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵛⵛⴰ ⵉ ⵉⵜⵜⵡⴰⵛⵛⴰⵏ ⵓⵛⴰ ⵙⵎⵓⵏ ⵉ-ⵜⵜ ⵖⴰⵔⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵓⵛⴰ ⵓⵍⴰ ⵉ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN6_22","002_6_22","GEN","6","22","22","ⵓⵛⴰ ⵉⴳⴳⴰ ⵏⵓⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵉ ⵅⴻⴼ ⵜ ⵉⵡⴻⵚⵚⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵎⵓ ⵉ ⵜ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("GN7_1","002_7_1","GEN","7","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵏⵓⵃ: “ⴰⴷⴻⴼ ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵎⵉⵏⵣⵉ ⵥⵔⵉⵖ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴷⵉ ⵊⵊⵉⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN7_2","002_7_2","GEN","7","2","2","ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵍⴻⵃⵍⴰⵍ ⴰⴷ ⵖⴰⵔⴻⴽ ⵜⴻⴽⵙⵉⴷ ⵙⴻⴱⵄⴰ, ⵙⴻⴱⵄⴰ, ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ ⵏⵏⴻⵙ, ⵓ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵍⴻⵃⵔⴰⵎ ⵜⵢⵓⵢⴰ, ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN7_3","002_7_3","GEN","7","3","3","ⵓⵍⴰ ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⵢⵓⵢⴰⵡⵉⵏ, ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("GN7_4","002_7_4","GEN","7","4","4","ⵎⵉⵏⵣⵉ ⵅⵎⵉ ⵖⴰ ⵄⴷⵓⵏ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⴻⵛⵛ ⴰⴷ ⵊⵊⴻⵖ ⴰⵏⵥⴰⵔ ⴰⴷ ⵉⵡⵡⴻⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ, ⴷ ⵎⵉⵏ ⴳⴳⵉⵖ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN7_5","002_7_5","GEN","7","5","5","ⵓⵛⴰ ⵉⴳⴳⴰ ⵏⵓⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⵓⵍⵛⵉ ⵉ ⵅⴻⴼ ⵜ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN7_6","002_7_6","GEN","7","6","6","ⵜⵓⵖⴰ ⵏⵓⵃ ⴷ ⵎⵎⵉⵙ ⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵙⵙⴻⵃⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN7_7","002_7_7","GEN","7","7","7","ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵏⵓⵃ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵙⵙⴻⵃⵍⴻⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN7_8","002_7_8","GEN","7","8","8","ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵍⴻⵃⵍⴰⵍ ⵓ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵍⴻⵃⵔⴰⵎ ⵓ ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ");
INSERT INTO rift_vpl VALUES ("GN7_9","002_7_9","GEN","7","9","9","ⵜⵓⴷⴻⴼ ⵜⵢⵓⵢⴰ ⵙ ⵜⵢⵓⵢⴰ ⵖⴰⵔ ⵏⵓⵃ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵡⴻⵚⵚⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GN7_10","002_7_10","GEN","7","10","10","ⴰⵡⴰⵔⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵎⴰⵏ ⵏ ⵙⵙⴻⵃⵍⴻⵜ ⵓⵙⵉⵏ-ⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN7_11","002_7_11","GEN","7","11","11","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⵏⵓⵃ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏⵏⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵏⵏⵉⵜ, ⵜⵓⵖⴰ ⵙⵙⴻⴼⵢⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏⵜ ⵜⴱⵓⵔⵊⴰⵜⵉⵏ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN7_12","002_7_12","GEN","7","12","12","ⵜⵓⵖⴰ ⴰⵏⵥⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵛⵛⴰⵜ ⵙ ⵊⵊⴻⵀⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("GN7_13","002_7_13","GEN","7","13","13","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ ⵜⵓⵖⴰ ⵏⵓⵃ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴰⴽ-ⴷ ⵛⴰⵎ ⴷ ⵃⴰⵎ ⴷ ⵢⴰⴼⴰⵜ, ⴰⵢⵜ ⵏ ⵏⵓⵃ, ⵓⵍⴰ ⴰⴽ-ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵏⵓⵃ ⵓ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN7_14","002_7_14","GEN","7","14","14","ⵏⵉⵜⵏⵉ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵉⵊⴹⴰⴹ, ⵎⴰⵔⵔⴰ ⴰⵊⴹⵉⴹ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔ ⵉⴵⴰ ⴰⴼⵔⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN7_15","002_7_15","GEN","7","15","15","ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉ ⴷⵉ ⵉⴵⴰ ⴰⵔⵔⵓⵃ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵜⵓⵙⴰ-ⴷⴷ ⵜⵢⵓⵢⴰ ⵙ ⵜⵢⵓⵢⴰ ⵖⴰⵔ ⵏⵓⵃ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("GN7_16","002_7_16","GEN","7","16","16","ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ, ⵢⵓⴷⴻⴼ ⵉⵊⵊ ⵏ ⵡⴻⵡⵜⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵜⴻⵎⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⵙⵉⴷⵉ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN7_17","002_7_17","GEN","7","17","17","ⵜⵓⵖⴰ ⵙⵙⴻⵃⵍⴻⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵖⴰⵔⵔⴰⴱⵓ ⴰⵍⴰⵎⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN7_18","002_7_18","GEN","7","18","18","ⴳⴻⵄⵄⴷⴻⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN7_19","002_7_19","GEN","7","19","19","ⴳⴻⵄⵄⴷⴻⵏ ⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ, ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵎⴰⵔⵔⴰ ⴰⵊⴻⵏⵏⴰ, ⴷⴻⵡⵍⴻⵏ ⴷⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN7_20","002_7_20","GEN","7","20","20","ⵓⵍⵢⴻⵏ ⵡⴰⵎⴰⵏ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⴷⵍⵉⵏ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN7_21","002_7_21","GEN","7","21","21","ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴹⵍⴻⵇ ⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵉⵊⴹⴰⴹ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ, ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ, ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN7_22","002_7_22","GEN","7","22","22","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵉⴵⴰ ⵍⴻⵄⵡⵉⵏ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⵜⵓⴷⴰⵔⵜ ⵖⴰⵔⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵉⴵⴰⵏ ⵅ ⵍⴱⴰⵔⵔ, ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN7_23","002_7_23","GEN","7","23","23","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵎⵃⴰ, ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⴰⵍ ⵍⵎⴰⵍ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ. ⵉⵏⴰ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⵓⵃ ⵡⴻⵃⵃⴷⴻⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴽⵉⴷⴻⵙ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("GN7_24","002_7_24","GEN","7","24","24","ⴳⴻⵄⵄⴷⴻⵏ ⵡⴰⵎⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN8_1","002_8_1","GEN","8","1","1","ⵓⵛⴰ ⵉⵅⴰⵔⵔⴻⵚ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵏⵓⵃ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ. ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵢⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍⴰⵎⵉ ⴰⵔⵙⴰⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN8_2","002_8_2","GEN","8","2","2","ⴱⴻⵍⵍⵄⴻⵏⵜ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴷ ⵜⴱⵓⵔⵊⴰⵜⵉⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵡⴻⵏⵥⴰⵔ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN8_3","002_8_3","GEN","8","3","3","ⵓⵛⴰ, ⴰⵎ ⴷⴷ-ⵜⵜⴰⵙⴻⵏ ⵜⵜⵔⴰⵃⴻⵏ, ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵡⴰⵎⴰⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵡⴰⵔⵏⵉ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⴻⵇⵚⴻⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN8_4","002_8_4","GEN","8","4","4","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏⵏⵉ, ⵢⴰⵔⵙⴰ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⴰⵔⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GN8_5","002_8_5","GEN","8","5","5","ⵇⵇⵉⵎⴻⵏ ⵡⴰⵎⴰⵏ ⵏⴻⵇⵇⵚⴻⵏ ⴰⵍ ⴰⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ. ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ, ⴹⵀⴰⵔⴻⵏⵜ-ⵉ-ⴷⴷ ⵜⵇⵉⵛⵛⴰⵜⵉⵏ ⵏ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN8_6","002_8_6","GEN","8","6","6","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵢⴰⵔⵣⴻⵎ ⵏⵓⵃ ⵜⴰⴱⵓⵔⵊⴻⵜ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵉⴳⴳⴰ, ");
INSERT INTO rift_vpl VALUES ("GN8_7","002_8_7","GEN","8","7","7","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴰⴱⴰⵖⴻⵍ. ⵡⴰⵏⵉⵜⴰ ⵉⴼⴼⴻⵖ, ⵉⵇⵇⵉⵎ ⵉⵜⵜⵔⴰⵃ ⵉⵜⵜⴰⵙ-ⴷⴷ ⴰⵍⴰⵎⵉ ⴱⴷⴰⵏ ⵡⴰⵎⴰⵏ ⵜⵜⴰⵥⵖⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN8_8","002_8_8","GEN","8","8","8","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵙⵙⴻⵏⵏⵉ ⵜⴰⴷⴱⵉⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ, ⵎⴰ ⴰⵎⴰⵏ ⵏⴻⵇⵚⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN8_9","002_8_9","GEN","8","9","9","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⴼⵉ ⵜⴻⴷⴱⵉⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵙⵙⴰⵔⵙ ⵜⴰⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵎⵉⵏⵣⵉ ⴰⵎⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵄⴰⴷ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵓⵛⴰ ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("GN8_10","002_8_10","GEN","8","10","10","ⵉⵔⴰⵊⴰ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵜⴰⴷⴱⵉⵔⵜ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("GN8_11","002_8_11","GEN","8","11","11","ⵓⵛⴰ ⵜⴰⴷⴱⵉⵔⵜ ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⴼⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⴼⵀⴻⵎ ⵏⵓⵃ ⴱⴻⵍⵍⵉ ⴰⵎⴰⵏ ⵏⴻⵇⵚⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN8_12","002_8_12","GEN","8","12","12","ⵉⵔⴰⵊⴰ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵜⴰⴷⴱⵉⵔⵜ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⴻⵄⵇⵉⴱ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN8_13","002_8_13","GEN","8","13","13","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵡⴰⵃⵉⵜ ⵏ ⵏⵓⵃ, ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵏⵏⵉ, ⵓⵥⵖⴻⵏ ⵡⴰⵎⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵉⴽⵙⵉ ⵏⵓⵃ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵓⵙⴻⵇⵇⴰⴼ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴰ ⵢⵓⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN8_14","002_8_14","GEN","8","14","14","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⵏⵏⵉ, ⵜⵓⵥⴻⵖ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN8_15","002_8_15","GEN","8","15","15","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵏⵓⵃ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("GN8_16","002_8_16","GEN","8","16","16","“ⴼⴼⴻⵖ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵛⴻⴽ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("GN8_17","002_8_17","GEN","8","17","17","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⴽ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵣⴻⴳ ⵉⵊⴹⴰⴹ, ⵣⵉ ⵍⵎⴰⵍ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⴽⵉⴷⴻⴽ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵎⵟⴰⵔⵔⴰⵛⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⴰⵔⵔⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN8_18","002_8_18","GEN","8","18","18","ⵉⴼⴼⴻⵖ ⵏⵓⵃ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN8_19","002_8_19","GEN","8","19","19","ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵄⵍⴰⵃⵚⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN8_20","002_8_20","GEN","8","20","20","ⵉⴱⵏⴰ ⵏⵓⵃ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴽⵙⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵃⵍⴰⵍ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵍⴻⵃⵍⴰⵍ ⵓⵛⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵓⵄⴰⵍⵟⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("GN8_21","002_8_21","GEN","8","21","21","ⵓⵛⴰ ⵉⵛⴻⵎⵎ ⵙⵉⴷⵉ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵓⵛⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵡⴰⵔ ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵖ ⵄⴰⴷ ⴰⴷ ⵏⴻⵄⵍⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵀⴰ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵖ ⵄⴰⴷ ⴰⴷ ⵡⵜⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("GN8_22","002_8_22","GEN","8","22","22","ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⴵⴰ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵢⴰⵔⵣⴰ ⴷ ⵜⵎⴻⵢⵔⴰ, ⵜⴻⵚⵎⴻⴹ ⴷ ⵍⴻⵃⵎⵓ, ⴰⵏⴻⴱⴷⵓ ⴷ ⵍⵎⴻⵛⵜⴰ ⵓⵛⴰ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ.”    ");
INSERT INTO rift_vpl VALUES ("GN9_1","002_9_1","GEN","9","1","1","ⵅⴻⵏⵏⵉ ⵉⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ ⵏⵓⵃ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵊⵊⴻⵎ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵔⴻⵏⵢⴻⵎ ⵓ ⵄⴻⵎⵎⴰⵔⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("GN9_2","002_9_2","GEN","9","2","2","ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵍⵄⵓⵔⵔⴻⵜ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵉⵍⵉⵏⵜ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⴻⵍⵎⴰⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ: ⴰⵇⴰ ⵎⵎⴻⵡⵛⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN9_3","002_9_3","GEN","9","3","3","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵜ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ, ⴰⵎ ⴷ ⴰⵡⴻⵎ ⵡⵛⵉⵖ ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ, ");
INSERT INTO rift_vpl VALUES ("GN9_4","002_9_4","GEN","9","4","4","ⵎⴰⵛⴰ ⴰⵢⵙⵓⵎ ⴰⴽ-ⴷ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵉ ⵉⴵⴰⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜᵉⵜⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN9_5","002_9_5","GEN","9","5","5","ⴷ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵡⴻⵎ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ, ⴰⴷ ⵜⴻⵏ ⵜⵜⴰⵔⴻⵖ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵓⵍⴰ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵎⴰⵙ ⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN9_6","002_9_6","GEN","9","6","6","ⵡⵉ ⵖⴰ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN9_7","002_9_7","GEN","9","7","7","ⵓ ⴽⴻⵏⵏⵉⵡ, ⵊⵊⴻⵎ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⴷⴻⵡⵍⴻⵎ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵎⵟⴰⵔⵔⵛⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵎ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵅⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN9_8","002_9_8","GEN","9","8","8","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵏⵓⵃ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("GN9_9","002_9_9","GEN","9","9","9","“ⵏⴻⵛⵛ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⴰⴽ-ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("GN9_10","002_9_10","GEN","9","10","10","ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴱⵓⵃⴱⴻⵍ ⵉⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⴽ-ⴷ ⵉⵊⴹⴰⴹ, ⴰⴽ-ⴷ ⵍⵎⴰⵍ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ, ⵡⴰⵀ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴰⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN9_11","002_9_11","GEN","9","11","11","ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵡⴰⵔ ⵜⵜⵡⴰⴽⴻⵙⵙⵉⵏ ⵄⴰⴷ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵙⵙⴻⵃⵍⴻⵜ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵙⵙⴻⵃⵍⴻⵜ ⵉ ⵖⴰ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN9_12","002_9_12","GEN","9","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⴷ ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⵄⴰⵀⴷ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ, ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵉ ⵍⴻⴱⴷⴰ: ");
INSERT INTO rift_vpl VALUES ("GN9_13","002_9_13","GEN","9","13","13","ⴰⴷ ⴳⴳⴻⵖ ⵍⵇⴻⵡⵙ ⵉⵏⵓ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN9_14","002_9_14","GEN","9","14","14","ⵅⵎⵉ ⵖⴰ ⴱⴹⵉⵖ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵍⵇⴻⵡⵙ-ⴰ ⴰⴷ ⴷⴷ-ⵉⴹⵀⴰⵔ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN9_15","002_9_15","GEN","9","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⴰⵔⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ. ⵡⴰⵔ ⴷⴷ-ⴷⴷⵉⴽⴽⵯⵉⵍⴻⵏ ⵡⴰⵎⴰⵏ ⴷ ⵙⵙⴻⵃⵍⴻⵜ ⵄⴰⵡⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵖⴰⵔⵇⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN9_16","002_9_16","GEN","9","16","16","ⴰⴷ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵍⵇⴻⵡⵙ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵥⴰⵔⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⴰⵔⴻⵖ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ ⵊⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN9_17","002_9_17","GEN","9","17","17","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵓⵃ: “ⴷ ⵜⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN9_18","002_9_18","GEN","9","18","18","ⵜⴰⵔⵡⴰ ⵏ ⵏⵓⵃ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⵎ ⴷ ⵃⴰⵎ ⴷ ⵢⴰⴼⴰⵜ. ⵃⴰⵎ ⵜⵓⵖⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⴽⴻⵏⵄⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("GN9_19","002_9_19","GEN","9","19","19","ⵉⵏⴰ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵏⵓⵃ. ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN9_20","002_9_20","GEN","9","20","20","ⵉⴱⴷⴰ ⵏⵓⵃ ⵉⵅⴻⴷⴷⴻⵎ ⴰⵎ ⵓⴼⴻⴵⴰⵃ, ⵉⵥⵥⵓ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN9_21","002_9_21","GEN","9","21","21","ⵓⵎⵉ ⵉⵙⵡⴰ ⴱⵉⵏⵓ, ⵉⵙⵛⴰⵔ ⵓⵛⴰ ⵉⵄⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN9_22","002_9_22","GEN","9","22","22","ⵉⵥⵔⴰ ⵃⴰⵎ, ⴱⴰⴱⴰⵙ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵜ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⴰⵢⵜⵎⴰⵙ ⴷⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN9_23","002_9_23","GEN","9","23","23","ⴽⵙⵉⵏ ⵛⴰⵎ ⴷ ⵢⴰⴼⴰⵜ ⵛⴰ ⵏ ⵡⴻⵔⵔⵓⴹ, ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴷⵍⵉⵏ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ. ⴰⵔⵔⵉⵏ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵡⴰⵔ ⵥⵔⵉⵏ ⵛⴰ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN9_24","002_9_24","GEN","9","24","24","ⵉⴼⴰⵇ-ⴷⴷ ⵏⵓⵃ ⵣⵉ ⵙⵙⴻⴽⵔⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵢⴰⵔⴳⴻⴱ ⵅ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ. ");
INSERT INTO rift_vpl VALUES ("GN9_25","002_9_25","GEN","9","25","25","ⵉⵏⵏⴰ: “ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵉ ⵢⴻⴵⴰ ⴽⴻⵏⵄⴰⵏ! ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵇⴰⵄ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴰⵢⵜⵎⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("GN9_26","002_9_26","GEN","9","26","26","ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵛⴰⵎ. ⴽⴻⵏⵄⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN9_27","002_9_27","GEN","9","27","27","ⵣⴻⵄⵎⴰ ⴰⴷ ⵉⵡⴻⵙⵙⴻⵄ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵢⴰⴼⴰⵜ, ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏ ⵛⴰⵎ, ⵓ ⴽⴻⵏⵄⴰⵏ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN9_28","002_9_28","GEN","9","28","28","ⴰⵡⴰⵔⵏⵉ ⵙⵙⴻⵃⵍⴻⵜ ⵉⴷⴷⴰⵔ ⵏⵓⵃ ⵄⴰⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN9_29","002_9_29","GEN","9","29","29","ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵔ ⵏⵓⵃ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵏⵓⵃ: ⵛⴰⵎ, ⵃⴰⵎ ⴷ ⵢⴰⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GN10_1","002_10_1","GEN","10","1","1","ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵙⴻⵃⵍⴻⵜ.   * ");
INSERT INTO rift_vpl VALUES ("GN10_2","002_10_2","GEN","10","2","2","ⴰⵢⵜ ⵏ ⵢⴰⴼⴰⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⵓⵎⴰⵔ, ⵎⴰⵊⵓⵊ, ⵎⴰⴷⴰⵢ, ⵢⴰⵡⴰⵏ, ⵜⵓⴱⴰⵍ, ⵎⴰⵛⵉⴽ ⴷ ⵜⵉⵔⴰⵙ.    ");
INSERT INTO rift_vpl VALUES ("GN10_3","002_10_3","GEN","10","3","3","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵊⵓⵎⴰⵔ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵛⴽⴰⵏⴰⵣ, ⵔⵉⴼⴰⵜ ⴷ ⵜⵓⵊⴰⵔⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("GN10_4","002_10_4","GEN","10","4","4","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵡⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵍⵉⵛⴰ, ⵜⴰⵔⵛⵉⵛ ⴷ ⵉⴽⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⴷⵓⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_5","002_10_5","GEN","10","5","5","ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵜⵜⵡⴰⴱⴹⴰⵏⵜ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵ ⵏⵙⴻⵏ ⵓ ⴷⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_6","002_10_6","GEN","10","6","6","ⴰⵢⵜ ⵏ ⵃⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴽⵓⵛ, ⵎⵉⵚⵔⴰⵢⵉⵎ, ⴼⵓⵟ ⴷ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_7","002_10_7","GEN","10","7","7","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴽⵓⵛ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵙⴻⴱⴰ, ⵃⴰⵡⵉⵍⴰ, ⵙⴰⴱⵜⴰ, ⵔⴰⵄⴰⵎⴰ ⴷ ⵙⴰⴱⵜⴰⴽⴰ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⴰⵄⴰⵎⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⴱⴰ ⴷ ⴷⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_8","002_10_8","GEN","10","8","8","ⴽⵓⵛ ⵉⵊⵊⴰ-ⴷⴷ ⵏⵉⵎⵔⵓⴷ. ⵡⴰⵏⵉⵜⴰ ⵉⴱⴷⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵊⵊⵉⵀⴻⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN10_9","002_10_9","GEN","10","9","9","ⵡⴰ ⵜⵓⵖⴰ ⴷ ⴰⵏⴻⴳⵎⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵏⴻⴳⵎⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⵏⵉⵎⵔⵓⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("GN10_10","002_10_10","GEN","10","10","10","ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵉⵔⵉⵅ ⴷ ⴰⴽⴽⴰⴷ ⴷ ⴽⴰⵍⵏⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵉⵏⵄⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN10_11","002_10_11","GEN","10","11","11","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴰⵛⵛⵓⵔ ⵓⵛⴰ ⵉⴱⵏⴰ ⴷⵉⵏ ⵏⵉⵏⵡⴰ, ⵔⵉⵃⵓⴱⵓⵜ-ⵄⵉⵔ ⴷ ⴽⴰⵍⴰⵃ ");
INSERT INTO rift_vpl VALUES ("GN10_12","002_10_12","GEN","10","12","12","ⴷ ⵔⵉⵙⵉⵏ ⵊⴰⵔ ⵏⵉⵏⵡⴰ ⴷ ⴽⴰⵍⴰⵃ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN10_13","002_10_13","GEN","10","13","13","ⵎⵉⵚⵔⴰⵢⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵍⵓⴷⵉⵢⵢⴻⵏ, ⵉⵄⴰⵏⴰⵎⵉⵢⵢⴻⵏ, ⵉⵍⴰⵀⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⴰⴼⵜⵓⵃⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN10_14","002_10_14","GEN","10","14","14","ⵉⴼⴰⵜⵔⵓⵙⵉⵢⵢⴻⵏ, ⵉⴽⴰⵙⵍⵓⵃⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵣⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⴷ ⵉⴽⴰⴼⵜⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_15","002_10_15","GEN","10","15","15","ⴽⴻⵏⵄⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵚⵉⴷⵓⵏ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⴷ ⵃⵉⵜ ");
INSERT INTO rift_vpl VALUES ("GN10_16","002_10_16","GEN","10","16","16","ⴷ ⵓⵢⴰⴱⵓⵙⵉ ⴷ ⵓⵎⵓⵔⵉ ⴷ ⵓⵊⵉⵔⵊⴰⵛⵉ ");
INSERT INTO rift_vpl VALUES ("GN10_17","002_10_17","GEN","10","17","17","ⴷ ⵓⵃⵉⵡⵉ ⴷ ⵓⵄⴰⵔⵇⵉ ⴷ ⵓⵙⵉⵏⵉ ");
INSERT INTO rift_vpl VALUES ("GN10_18","002_10_18","GEN","10","18","18","ⴷ ⵓⵔⵡⴰⴷⵉ ⴷ ⵓⵚⴰⵎⴰⵔⵉ ⴷ ⵓⵃⴰⵎⴰⵜⵉ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵎⴱⴻⵣⵣⵄⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_19","002_10_19","GEN","10","19","19","ⵜⵓⵖⴰ ⴰⵢⵎⵉⵔ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⵉ ⵚⵉⴷⵓⵏ ⵖⴰⵔ ⵅⵉⵔⴰⵔ ⴰⵍ ⵖⴰⵣⵣⴰ ⵓ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⴰⴷⵎⴰ ⴷ ⵚⴰⴱⵓⵢⵉⵎ ⴰⵍ ⵍⴰⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("GN10_20","002_10_20","GEN","10","20","20","ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵃⴰⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴷⵉ ⵜⵉⵎⵎⵓⵔⴰ ⵏⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_21","002_10_21","GEN","10","21","21","ⵉ ⵛⴰⵎ, ⵡⴻⵏⵏⵉ ⴷ ⵊⴻⴷⴷ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵄⴰⴱⵉⵔ, ⵓⵎⴰⵙ ⵏ ⵢⴰⴼⴰⵜ, ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_22","002_10_22","GEN","10","22","22","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵛⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵍⴰⵎ, ⴰⵛⵛⵓⵔ, ⴰⵔⴼⴰⴽⵛⴰⴷ, ⵍⵓⴷ ⴷ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN10_23","002_10_23","GEN","10","23","23","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵔⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵓⵚ ⴷ ⵃⵓⵍ ⴷ ⵊⴰⵜⵉⵔ ⴷ ⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN10_24","002_10_24","GEN","10","24","24","ⴰⵔⴼⴰⴽⵛⴰⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵍⴰⵃ ⵓ ⵛⴰⵍⴰⵃ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⴱⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN10_25","002_10_25","GEN","10","25","25","ⵜⵜⵡⴰⵔⵡⴻⵏ-ⴷⴷ ⵉ ⵄⴰⴱⵉⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ⵉⵊⵊⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴼⴰⵍⴰⵊ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⴼⴻⴵⴻⵇ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵓⵎⴰⵙ ⵢⵓⵇⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_26","002_10_26","GEN","10","26","26","ⵢⵓⵇⵟⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵍⵎⵓⴷⴰⴷ, ⵛⴰⵍⴰⴼ, ⵀⴰⴹⴰⵔⵎⴰⵡⵜ, ⵢⴰⵔⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("GN10_27","002_10_27","GEN","10","27","27","ⵀⴰⴷⵓⵔⴰⵎ, ⵓⵣⴰⵍ, ⴷⵉⵇⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("GN10_28","002_10_28","GEN","10","28","28","ⵄⵓⴱⴰⵍ, ⴰⴱⵉⵎⴰⵢⵉⵍ, ⵛⴰⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("GN10_29","002_10_29","GEN","10","29","29","ⵓⴼⵉⵔ, ⵃⴰⵡⵉⵍⴰ ⴷ ⵢⵓⴱⴰⴱ. ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵇⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_30","002_10_30","GEN","10","30","30","ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⵣⵉ ⵎⵉⵛⴰ ⴰⵍ ⵙⴰⴼⴰⵔ, ⴰⴷⵔⴰⵔ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("GN10_31","002_10_31","GEN","10","31","31","ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵛⴰⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN10_32","002_10_32","GEN","10","32","32","ⵜⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵏⵓⵃ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵅⴻⵍⵇⴻⵏ, ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵙⴻⵏ. ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵣⵉ ⵜⵜⵡⴰⴱⴹⴰⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵙⴻⵃⵍⴻⵜ. * ");
INSERT INTO rift_vpl VALUES ("GN11_1","002_11_1","GEN","11","1","1","ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵢⵉⵍⴻⵙ ⴷ ⵉⵊⵊⴻⵏ ⵓ ⵙ ⵍⵀⴰⵔⴷ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_2","002_11_2","GEN","11","2","2","ⵉⵎⵙⴰⵔ ⵍⴰⵎⵉ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵛⵛⴰⵔⵇ, ⵓⴼⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵡⴹⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵉⵏⵄⴰⵔ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN11_3","002_11_3","GEN","11","3","3","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⴰⵔⴰⵃⴻⵎ-ⴷⴷ, ⴰⴷ ⵏⴻⴳⴳ ⵉⵥⵔⴰ ⵣⵉ ⵜⵍⴰⵅⵜ, ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⴻⵃⵎⴰ!” ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⴷⵡⴻⵍ ⵜⵍⴰⵅⵜ ⴷ ⴰⵥⵔⵓ ⵓ ⴰⵛⴰⵔⵎⵓⴹ ⵉⴷⵡⴻⵍ ⵖⴰⵔⵙⴻⵏ ⴷ ⵜⴰⵔⵔⵉⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("GN11_4","002_11_4","GEN","11","4","4","ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵣⵉⴷ, ⴰⴷ ⵏⴻⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵉⵛⵜ ⵏ ⵚⵚⵓⵎⵄⴻⵜ, ⵜⴰⵇⵉⵛⵛⴰⵜ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴻⴹ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵓ ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏᵉⵜⵜⴻⵎⵙⴻⴱⴹⵉ ⵛⴰ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN11_5","002_11_5","GEN","11","5","5","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵚⵚⵓⵎⵄⴻⵜ ⵏⵏⵉ ⴱⵏⴰⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN11_6","002_11_6","GEN","11","6","6","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⴳⴻⵏⵙ ⴷ ⵉⵊⵊⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵖⴰⵔⵙⴻⵏ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ. ⵡⴰ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ. ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵏⵏⵉ ⵏⵡⴰⵏ ⴰⴷ ⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_7","002_11_7","GEN","11","7","7","ⴰⵔⴰⵃⴻⵎ-ⴷⴷ, ⴰⴷ ⵏⴻⵀⵡⴰ ⵓⵛⴰ ⴰⴷ ⵏⴻⵙⵙⵅⴰⵔⵡⴻⴹ ⵉⵍⴻⵙ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⴼⴻⵀⵀⴻⵎ ⵄⴰⴷ ⵉⵍⴻⵙ ⵏ ⵡⴻⵏⵏⵉ ⵜ ⵢⵓⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN11_8","002_11_8","GEN","11","8","8","ⴰⵎⵎⵓ ⵉ ⵜⴻⵏ ⵉⵣⵣⵓⵣⴰⵔ ⵙⵉⴷⵉ ⵙⵙⴻⵏⵏⵉ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN11_9","002_11_9","GEN","11","9","9","ⵅ ⵓⵢⴰ ⵉ ⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵙ ⵢⵉⵙⴻⵎ ⵏ ‘ⴱⴰⴱⵉⵍ’, ⵎⵉⵏⵣⵉ ⴷⵉⵏ ⵉⵙⵙⵅⴰⵔⵡⴻⴹ ⵙⵉⴷⵉ ⵉⵍⴻⵙ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵙⵙⴻⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵣⵣⵓⵣⴰⵔ ⵙⵉⴷⵉ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵛⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN11_10","002_11_10","GEN","11","10","10","ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵛⴰⵎ ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⴰⵔⴼⴰⴽⵛⴰⴷ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵙⴻⵃⵍⴻⵜ.    ");
INSERT INTO rift_vpl VALUES ("GN11_11","002_11_11","GEN","11","11","11","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⴰⵔⴼⴰⴽⵛⴰⴷ, ⵉⴷⴷⴰⵔ ⵛⴰⵎ ⵄⴰⴷ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_12","002_11_12","GEN","11","12","12","ⵉⴷⴷⴰⵔ ⴰⵔⴼⴰⴽⵛⴰⴷ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("GN11_13","002_11_13","GEN","11","13","13","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⴰⵔⴼⴰⴽⵛⴰⴷ ⵛⴰⵍⴰⵃ, ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_14","002_11_14","GEN","11","14","14","ⵉⴷⴷⴰⵔ ⵛⴰⵍⴰⵃ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⴱⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN11_15","002_11_15","GEN","11","15","15","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵛⴰⵍⴰⵃ ⵄⴰⴱⵉⵔ, ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_16","002_11_16","GEN","11","16","16","ⵉⴷⴷⴰⵔ ⵄⴰⴱⵉⵔ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⴼⴰⵍⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("GN11_17","002_11_17","GEN","11","17","17","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⴼⴰⵍⴰⵊ, ⵉⴷⴷⴰⵔ ⵄⴰⴱⵉⵔ ⵄⴰⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_18","002_11_18","GEN","11","18","18","ⵉⴷⴷⴰⵔ ⴼⴰⵍⴰⵊ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵔⴰⵄⵓⵡ.    ");
INSERT INTO rift_vpl VALUES ("GN11_19","002_11_19","GEN","11","19","19","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵔⴰⵄⵓⵡ, ⵉⴷⴷⴰⵔ ⴼⴰⵍⴰⵊ ⵄⴰⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⴻⵙⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_20","002_11_20","GEN","11","20","20","ⵉⴷⴷⴰⵔ ⵔⴰⵄⵓⵡ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵙⴰⵔⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("GN11_21","002_11_21","GEN","11","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵙⴰⵔⵓⵊ, ⵉⴷⴷⴰⵔ ⵔⴰⵄⵓⵡ ⵄⴰⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_22","002_11_22","GEN","11","22","22","ⵉⴷⴷⴰⵔ ⵙⴰⵔⵓⵊ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵏⴰⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("GN11_23","002_11_23","GEN","11","23","23","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵏⴰⵃⵓⵔ, ⵉⴷⴷⴰⵔ ⵙⴰⵔⵓⵊ ⵄⴰⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_24","002_11_24","GEN","11","24","24","ⵉⴷⴷⴰⵔ ⵏⴰⵃⵓⵔ ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵜⴰⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("GN11_25","002_11_25","GEN","11","25","25","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵊⵊⴰ ⵏⴰⵃⵓⵔ ⵜⴰⵔⴰⵃ, ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⵎⵢⴰ ⵓ-ⵜⴻⵙⵄⴰⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_26","002_11_26","GEN","11","26","26","ⵉⴷⴷⴰⵔ ⵜⴰⵔⴰⵃ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⴰⴱⵔⴰⵎ, ⵏⴰⵃⵓⵔ ⴷ ⵀⴰⵔⴰⵏ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵜⴰⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("GN11_27","002_11_27","GEN","11","27","27","ⵜⴰⵔⴰⵃ ⵉⵊⵊⴰ-ⴷⴷ ⴰⴱⵔⴰⵎ, ⵏⴰⵃⵓⵔ ⴷ ⵀⴰⵔⴰⵏ, ⵓ ⵀⴰⵔⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵍⵓⵟ. ");
INSERT INTO rift_vpl VALUES ("GN11_28","002_11_28","GEN","11","28","28","ⵉⵎⵎⵓⵜ ⵀⴰⵔⴰⵏ ⵣⵣⴰⵜ ⵉ ⴱⴰⴱⴰⵙ ⵜⴰⵔⴰⵃ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ ⵏⴻⵜⵜⴰ, ⴷⵉ ⵓⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN11_29","002_11_29","GEN","11","29","29","ⵓⵛⴰ ⴽⵙⵉⵏ ⴰⴱⵔⴰⵎ ⴷ ⵏⴰⵃⵓⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ. ⵉⵙⴻⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴰⴱⵔⴰⵎ ⵜⵓⵖⴰ-ⵜ ⴷ ⵙⴰⵔⴰⵢ ⵓ ⵉⵙⴻⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵏⴰⵃⵓⵔ ⴷ ⵎⵉⵍⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵀⴰⵔⴰⵏ, ⴱⴰⴱⴰⵙ ⵏ ⵎⵉⵍⴽⴰ ⴷ ⵢⵉⵙⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("GN11_30","002_11_30","GEN","11","30","30","ⵙⴰⵔⴰⵢ ⵜⵓⵖⴰ-ⵜⵜ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵔⵓⵡ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN11_31","002_11_31","GEN","11","31","31","ⵓⵛⴰ ⵉⴽⵙⵉ ⵜⴰⵔⴰⵃ ⴰⴱⵔⴰⵎ, ⵎⵎⵉⵙ, ⴷ ⵍⵓⵟ ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵎⵎⵉⵙ, ⴷ ⵙⴰⵔⴰⵢ, ⵜⴰⵙⵍⵉⵜ ⵏⵏⴻⵙ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵙ ⴰⴱⵔⴰⵎ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵊⵎⵉⵄ ⵣⵉ ⵓⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵃⴰⵔⴰⵏ ⵓⵛⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ.    ");
INSERT INTO rift_vpl VALUES ("GN11_32","002_11_32","GEN","11","32","32","ⵓⵎⵉ ⵜⴻⴳⴳⴰ ⵜⴰⵔⴰⵃ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵎⵎⵓⵜ ⵜⴰⵔⴰⵃ ⴷⵉ ⵃⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN12_1","002_12_1","GEN","12","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴰⴱⵔⴰⵎ: “ⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⴷⴷ-ⵜⵅⴻⵍⵇⴻⴷ ⵓ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ, ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⴻⵛⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN12_2","002_12_2","GEN","12","2","2","ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ, ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ ⵓ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⵉⵍⵉ ⴷ ⵛⴻⴽ ⵄⴰⵡⴻⴷ ⴷ ⵍⴱⴰⵔⴰⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("GN12_3","002_12_3","GEN","12","3","3","ⴰⴷ ⴱⴰⵔⴽⴻⵖ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⴱⴰⵔⴽⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵏⴻⵄⵍⴻⵏ, ⴰⴷ ⵜ ⵏⴻⵄⵍⴻⵖ. ⴷⴰⵢⴻⴽ ⵉ ⵖⴰ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.”   * ");
INSERT INTO rift_vpl VALUES ("GN12_4","002_12_4","GEN","12","4","4","ⵓⵛⴰ ⵉⵔⵓⵃ ⴰⴱⵔⴰⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵉⵔⵓⵃ ⵍⵓⵜ ⴰⴽⵉⴷⴻⵙ. ⵜⵓⵖⴰ ⴰⴱⵔⴰⵎ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵃⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN12_5","002_12_5","GEN","12","5","5","ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⴰⴱⵔⴰⵎ ⵙⴰⵔⴰⵢ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴷ ⵍⵓⵟ ⵎⵎⵉⵙ ⵏ ⵓⵎⴰⵙ, ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵉ ⵢⴰⵔⴻⴱⵃⴻⵏ, ⴷ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ ⵏⵏⵉ ⴷⴷ-ⴽⴻⵙⴱⴻⵏ ⴷⵉ ⵃⴰⵔⴰⵏ. ⴼⴼⵖⴻⵏ ⵣⵉ ⵃⴰⵔⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN12_6","002_12_6","GEN","12","6","6","ⵉⵥⵡⴰ ⴰⴱⵔⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵛⴰⴽⵉⵎ ⴰⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵏ ⵎⵓⵔⴰ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("GN12_7","002_12_7","GEN","12","7","7","ⵉⴱⴰⵏ-ⴷⴷ ⵙⵉⴷⵉ ⵉ ⴰⴱⵔⴰⵎ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵓⵎⵉ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ.” ⵓⵛⴰ ⵉⴱⵏⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⴰⵔⵙ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⴱⴰⵏⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("GN12_8","002_12_8","GEN","12","8","8","ⵅⴻⵏⵏⵉ ⵉⵄⴷⵓ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵉ ⵉⴵⴰⵏ ⵅ ⵛⵛⴰⵔⵇ ⵏ ⴱⴰⵢⵜ-ⵉⵍ ⵓⵛⴰ ⵉⵡⵜⴰ ⴷⵉⵏⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵉⵊⵊⴰ ⴱⴰⵢⵜ-ⵉⵍ ⵅ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵖⴰⵔⴱ ⵓ ⵄⴰⵢ ⵅ ⵛⵛⴰⵔⵇ. ⴷⵉⵏ ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN12_9","002_12_9","GEN","12","9","9","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⵙⵉ ⴰⴱⵔⴰⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵉⵎⵎⵓⵟⵟⵉ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN12_10","002_12_10","GEN","12","10","10","ⵉⴷⵡⴻⵍ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⴽⴻⵎⵎⴻⵍ ⴰⴱⵔⴰⵎ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵉⵀⵡⴰ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉⵏ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⵎⵖⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN12_11","002_12_11","GEN","12","11","11","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵓⵎⵉ ⵉ ⵖⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⴰ ⵉ ⵙⴰⵔⴰⵢ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵛⴻⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN12_12","002_12_12","GEN","12","12","12","ⵅⵎⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵜⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ!’, ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⵊⵊⴻⵏ ⴷⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN12_13","002_12_13","GEN","12","13","13","ⵉⵏⵉ, ⴰⵇⴰ ⵛⴻⵎ ⴷ ⵓⵞⵎⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵢⵉⵍⵉ ⵍⵅⵉⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⴷⴷⴰⵔ ⵉ ⵛⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN12_14","002_12_14","GEN","12","14","14","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⴰⴱⵔⴰⵎ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵥⵔⵉⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵚⴱⴻⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN12_15","002_12_15","GEN","12","15","15","ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ, ⵥⵔⵉⵏ ⵜⵜ ⵓⵛⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵜⵜ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN12_16","002_12_16","GEN","12","16","16","ⵓⵛⴰ ⵉⵎⵚⵓⵔⴻⴼ ⴼⵉⵔⵄⵓⵏ ⵎⵍⵉⵀ ⴰⴽ-ⴷ ⴰⴱⵔⴰⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵉⴽⵙⵉ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ ⴷ ⵜⴻⵖⵢⴰⵍ ⴷ ⵉⵍⴻⵖⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN12_17","002_12_17","GEN","12","17","17","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵜⴰ ⴼⵉⵔⵄⵓⵏ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵙ ⵊⵊⵔⴰⵢⴻⵃ ⵎⵖⴰⵔⴻⵏⵜ ⴷⵉ ⵍⴻⵙⴱⴰⴱ ⵏ ⵙⴰⵔⴰⵢ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴰⴱⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN12_18","002_12_18","GEN","12","18","18","ⵅⴻⵏⵏⵉ ⴼⵉⵔⵄⵓⵏ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⴰⴱⵔⴰⵎ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏⴰⵡⴰⵢⴰ ⵉ ⴷⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ? ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("GN12_19","002_12_19","GEN","12","19","19","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵜⵜⴰⵜ ⴷ ⵓⵞⵎⴰ!’, ⴰⵍⴰⵎⵉ ⵜⵜ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ? ⵍⴻⵅⵅⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵛ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ, ⴽⵙⵉ ⵜⵜ, ⵜⴱⴻⵄⵄⴷⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("GN12_20","002_12_20","GEN","12","20","20","ⵢⵓⵎⵓⵔ ⴼⵉⵔⵄⵓⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵅⴰⵙ ⵓⵛⴰ ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵜ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN13_1","002_13_1","GEN","13","1","1","ⴰⵎⵎⵓ ⵉ ⵢⵓⵢⵓⵔ ⴰⴱⵔⴰⵎ ⵣⵉ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⴷ ⵍⵓⵟ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN13_2","002_13_2","GEN","13","2","2","ⴰⴱⵔⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN13_3","002_13_3","GEN","13","3","3","ⵓⵛⴰ ⵉⵎⵎⵓⵟⵟⵉ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⴰⵍ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⵇⴱⴻⵍ, ⵊⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵄⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("GN13_4","002_13_4","GEN","13","4","4","ⴰⵍ ⴰⵎⵛⴰⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵇⴱⴻⵍ, ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⴰⵔⵙ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ, ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴰⴱⵔⴰⵎ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN13_5","002_13_5","GEN","13","5","5","ⵓⵛⴰ ⵍⵓⵟ, ⵡⴻⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⴰⴽ-ⴷ ⴰⴱⵔⴰⵎ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵉⵇⵉⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN13_6","002_13_6","GEN","13","6","6","ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵉⵔⵉⵡ ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵊⵎⵉⵄ, ⵎⵉⵏⵣⵉ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⴰⵍ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("GN13_7","002_13_7","GEN","13","7","7","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵊⴰⵔ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⴰⴱⵔⴰⵎ ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵍⵓⵟ. ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("GN13_8","002_13_8","GEN","13","8","8","ⵉⵏⵏⴰ ⴰⴱⵔⴰⵎ ⵉ ⵍⵓⵟ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⵊⴰⵔ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵉⵏⵓ ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵡⵎⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN13_9","002_13_9","GEN","13","9","9","ⵎⴰ ⵡⴰⵔ ⵜⴰⵔⵣⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜⴻⵛ? ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⴱⴹⵉⴹ, ⵎⴰ ⵅ ⵓⵣⴻⵍⵎⴰⴹ, ⵏⵉⵖ ⵅ ⵢⴻⴼⵓⵙ! ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵔⵓⵃⴻⴷ ⵅ ⵢⴻⴼⵓⵙ, ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵅ ⵓⵣⴻⵍⵎⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("GN13_10","002_13_10","GEN","13","10","10","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵍⵓⵟ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⴷⴻⵡⵡⴰⵔ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵡⴰ. ⵇⴱⴻⵍ ⴰⵔⴻⴷⴷⴻⴵ ⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴰⵎ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⵚⵓⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN13_11","002_13_11","GEN","13","11","11","ⵓⵛⴰ ⵉⵅⴹⴰⵔ ⵍⵓⵟ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⴰⴷⴻⵡⵡⴰⵔ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵉⴼⵙⵉ ⵍⵓⵟ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⴰⵎⵎⵓ ⵉ ⵎⵎⵙⴻⴱⴹⴰⵏ ⵏⵉⵜⵏⵉ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN13_12","002_13_12","GEN","13","12","12","ⴰⴱⵔⴰⵎ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵎⴰⵛⴰ ⵍⵓⵟ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⴰⵍ ⵙⴰⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN13_13","002_13_13","GEN","13","13","13","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵙⴰⴷⵓⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("GN13_14","002_13_14","GEN","13","14","14","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵅⴰⵙ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵍⵓⵟ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴰⴱⵔⴰⵎ: “ⵙⴰⵔⵔⴻⵃ ⵍⴻⵅⵅⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵜⴻⵅⵣⴰⵔⴻⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⴻⴵⵉⴷ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ");
INSERT INTO rift_vpl VALUES ("GN13_15","002_13_15","GEN","13","15","15","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ, ⴰⴷ ⴰⵛ ⵜⵜ ⵡⵛⴻⵖ, ⵉ ⵛⴻⴽ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("GN13_16","002_13_16","GEN","13","16","16","ⴰⴷ ⴳⴳⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ, ⵎⴰⵍⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵉⵃⵙⴻⴱ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵜⵣⴻⵎⵎⴰⵔ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("GN13_17","002_13_17","GEN","13","17","17","ⴽⴽⴰⵔ, ⵛⵓⵇ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉ ⵛⴻⴽ ⵓⵎⵉ ⵜⵜ ⵉ ⵖⴰ ⵡⵛⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN13_18","002_13_18","GEN","13","18","18","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴻⵙ ⴰⴱⵔⴰⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⴷ ⵉⵣⴷⴻⵖ ⵖⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⴳⴳ ⵏ ⵎⴰⵎⵔⵉ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵃⴰⴱⵔⵓⵏ. ⴷⵉⵏⵏⵉ ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN14_1","002_14_1","GEN","14","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⵎⵔⴰⴼⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵛⵉⵏⵄⴰⵔ, ⴷ ⴰⵔⵉⵢⵓⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵍⵍⴰⵙⴰⵔ, ⴷ ⴽⵉⴷⵓⵔⵍⴰⵄⵓⵎⴻⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⵉⵍⴰⵎ, ⴷ ⵜⵉⴷⴰⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ");
INSERT INTO rift_vpl VALUES ("GN14_2","002_14_2","GEN","14","2","2","ⵉⵏⴰ ⴳⴳⵉⵏ ⵍⴱⴰⵔⵓⴹ ⴰⴽ-ⴷ ⴱⵉⵔⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵙⴰⴷⵓⵎ ⵓ ⴰⴽ-ⴷ ⴱⵉⵔⵛⴰⵄ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵎⵓⵔⵔⴰ, ⵓ ⴰⴽ-ⴷ ⵛⵉⵏⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⴷⵎⴰ, ⵓ ⴰⴽ-ⴷ ⵛⵉⵎ’ⵉⴱⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⴰⴱⵓⵢⵉⵎ, ⵓ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⵉⵍⴰⵄ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵚⵓⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN14_3","002_14_3","GEN","14","3","3","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵎⵓⵏⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵙⵉⴷⴷⵉⵎ, ⴰⵇⴰ ⴷ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("GN14_4","002_14_4","GEN","14","4","4","ⵜⵓⵖⴰ ⵅⴻⴷⴷⵎⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴽⵉⴷⵓⵔⵍⴰⵄⵓⵎⵉⵔ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵖⴻⵡⵡⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN14_5","002_14_5","GEN","14","5","5","ⵓⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵢⵓⵙⴰ-ⴷⴷ ⴽⵉⴷⵓⵔⵍⴰⵄⵓⵎⵉⵔ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵢⴻⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ ⴷⵉ ⴰⵛⵜⵉⵔⵓⵜ-ⵇⴰⵔⵏⴰⵢⵎ, ⵅ ⵉⵣⵓⵣⵉⵢⵢⴻⵏ ⴷⵉ ⵀⴰⵎ, ⵅ ⵉⵎⵉⵜⵉⵢⵢⴻⵏ ⴷⵉ ⵛⴰⵡⴰ-ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ    ");
INSERT INTO rift_vpl VALUES ("GN14_6","002_14_6","GEN","14","6","6","ⵓ ⵅ ⵉⵅⵓⵔⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏⵙⴻⵏ ⵏ ⵙⴰⵄⵉⵔ ⴰⵍ ⴼⴰⵔⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("GN14_7","002_14_7","GEN","14","7","7","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵄⴰⵢⵏ-ⵎⵉⵛⴼⴰⵜ, ⵡⴻⵏⵏⵉ ⴷ ⵇⴰⴷⴰⵛ, ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅ ⵢⴻⵡⴷⴰⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵓ ⵄⴰⵡⴻⴷ ⵅ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵀⴰⵚⵚⵓⵏ-ⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN14_8","002_14_8","GEN","14","8","8","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⴷⵎⴰ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵚⴰⴱⵓⵢⵉⵎ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⵉⵍⴰⵄ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵚⵓⵖⴰⵔ. ⵔⵓⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵙⵉⴷⴷⵉⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ");
INSERT INTO rift_vpl VALUES ("GN14_9","002_14_9","GEN","14","9","9","ⴰⴽ-ⴷ ⴽⵉⴷⵓⵔⵍⴰⵄⵓⵎⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⵉⵍⴰⵎ ⴷ ⵜⵉⴷⵄⴰⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴷ ⴰⵎⵔⴰⴼⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵛⵉⵏⵄⴰⵔ, ⴷ ⴰⵔⵢⵓⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵍⵍⴰⵙⴰⵔ: ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴳⴳⵉⵏ ⵍⴱⴰⵔⵓⴹ ⴰⴽ-ⴷ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN14_10","002_14_10","GEN","14","10","10","ⵜⵓⵖⴰ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵙⵉⴷⴷⵉⵎ ⵜⴻⵛⵛⵓⵔ ⵙ ⵡⴰⵏⵓⵜⴻⵏ ⵏ ⵜⵉⵣⴻⴼⵜ. ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⵓⵛⴰ ⵡⴹⴰⵏ ⴷⴰⵢⵙⴻⵏ, ⵓ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN14_11","002_14_11","GEN","14","11","11","ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵛⵛⴰ ⵉ ⵅⴻⵣⵏⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN14_12","002_14_12","GEN","14","12","12","ⴽⵙⵉⵏ ⵄⴰⵡⴻⴷ ⵍⵓⵟ, ⵎⵎⵉⵙ ⵏ ⵓⵎⴰⵙ ⵏ ⴰⴱⵔⴰⵎ, ⴷ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵔⵓⵃⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵙⴰⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN14_13","002_14_13","GEN","14","13","13","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ, ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴰⴱⵔⴰⵎ, ⴰⵄⵉⴱⵔⴰⵏⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⴳⴳ ⵏ ⵎⴰⵎⵔⵉ, ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⵓⵔⵉⵢ, ⵓⵎⴰⵙ ⵏ ⴰⵛⴽⵓⵍ ⴷ ⵄⴰⵏⵉⵔ. ⵏⵉⵜⵏⵉ ⴷ ⴰⵔⴼⵉⵇⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵏ ⴰⴱⵔⴰⵎ.    ");
INSERT INTO rift_vpl VALUES ("GN14_14","002_14_14","GEN","14","14","14","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⴰⴱⵔⴰⵎ ⴱⴻⵍⵍⵉ ⵓⵎⴰⵙ ⵟⵟⴼⴻⵏ ⵜ ⴷ ⴰⵎⴻⵃⴱⵓⵙ, ⵢⵉⵡⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⴷⴰⵔⵔⴱⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴷⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵟⴰⵛ, ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ ⴰⵍ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN14_15","002_14_15","GEN","14","15","15","ⵙ ⴵⵉⵔⴻⵜ ⴱⴹⴰⵏ ⵅⴰⵙⴻⵏ ⵏⵉⵜⵏⵉ, ⴳⴳⵉⵏ ⵜⴻⵔⴼⵉⵇⵉⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵖⵍⴻⴱ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵃⵓⴱⴰ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("GN14_16","002_14_16","GEN","14","16","16","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵓⵍⴰ ⴷ ⵓⵎⴰⵙ ⵍⵓⵟ ⴷ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("GN14_17","002_14_17","GEN","14","17","17","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵖⵍⴻⴱ ⵏⴻⵜⵜⴰ ⵅ ⴽⵉⴷⵓⵔⵍⴰⵄⵓⵎⵉⵔ ⵓ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ, ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⴰⴷⵓⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵍⵇⴰ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵛⴰⵡⴰ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN14_18","002_14_18","GEN","14","18","18","ⵓ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵛⴰⵍⵉⵎ, ⵢⵉⵡⵉ-ⴷⴷ ⴰⵖⵔⵓⵎ ⴷ ⴱⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ.    ");
INSERT INTO rift_vpl VALUES ("GN14_19","002_14_19","GEN","14","19","19","ⵉⴱⴰⵔⴽ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⴱⵔⴰⵎ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN14_20","002_14_20","GEN","14","20","20","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⴻⵍⵍⵎⴻⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ!” ⵓⵛⴰ ⴰⴱⵔⴰⵎ ⵉⵡⵛⴰ ⴰⵙ ⵍⴻⵄⵛⵓⵔ ⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN14_21","002_14_21","GEN","14","21","21","ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⴰⴷⵓⵎ ⵉ ⴰⴱⵔⴰⵎ: “ⴻⵡⵛ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⴽⵙⵉ ⴰⴳⵍⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN14_22","002_14_22","GEN","14","22","22","ⵎⴰⵛⴰ ⴰⴱⵔⴰⵎ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⴰⴷⵓⵎ: “ⴰⵇⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵊⵊⵓⴵⴻⵖ ");
INSERT INTO rift_vpl VALUES ("GN14_23","002_14_23","GEN","14","23","23","ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵖ ⴰⴼⵉⵍⵓ ⵏⵉⵖ ⵜⴰⵃⴻⵣⵣⴻⵎⵜ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵓⵍⴰ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵏⴻⵛⵛ ⵙⵙⵜⴻⵊⵊⴰⵔⴻⵖ ⴰⴱⵔⴰⵎ!’ ");
INSERT INTO rift_vpl VALUES ("GN14_24","002_14_24","GEN","14","24","24","ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴰⵢⴻⵙ ⴱⵓ ⵜⴰⵙⵖⴰⵔⵜ! ⵎⵖⵉⵔ ⵎⵉⵏ ⵛⵛⵉⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵔⵓⵃⴻⵏ, ⴰⵏⵉⵔ ⴷ ⵉⵛⴽⵓⵍ ⴷ ⵎⴰⵎⵔⵉ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴽⵙⵉⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN15_1","002_15_1","GEN","15","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⴰⴱⵔⴰⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ. ⵉⵏⵏⴰ ⴰⵙ “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰⴱⵔⴰⵎ, ⵏⴻⵛⵛ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉ ⵛⴻⴽ, ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵛ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⴷ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN15_2","002_15_2","GEN","15","2","2","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⴱⵔⴰⵎ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⴻⵡⵛⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⵎⵎⵓ ⴱⵍⴰ ⵎⵎⵉ ⵓ ⴰⵍⵉⵄⴰⵣⵉⵔ ⵣⵉ ⴷⵉⵎⴰⵛⵇ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵎⵎⵉ ⵅ ⵡⴰⴳⵍⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("GN15_3","002_15_3","GEN","15","3","3","ⵉⵏⵏⴰ ⴰⴱⵔⴰⵎ ⵄⴰⵡⴻⴷ: “ⵅⵣⴰⵔ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ, ⵙ ⵓⵢⴻⵏⵏⵉ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵎⵎⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵡⵔⵉⵜ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN15_4","002_15_4","GEN","15","4","4","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵛⴻⴽ ⵉⵡⴰⵔⵔⴻⵜ ⵛⴰ ⵡⴰ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⴽ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵡⵔⵉⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN15_5","002_15_5","GEN","15","5","5","ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵜⵃⴻⵙⴱⴻⴷ ⵉⵜⵔⴰⵏ, ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵏ ⵜⵃⴻⵙⴱⴻⴷ!” ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN15_6","002_15_6","GEN","15","6","6","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵎⴻⵏ ⴷⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵃⵙⴻⴱ ⴰⵙ ⵜ-ⵉ-ⴷⴷ ⴷ ⵜⴰⵙⴻⴳⴷⴰ.    ");
INSERT INTO rift_vpl VALUES ("GN15_7","002_15_7","GEN","15","7","7","ⵉⵏⵏⴰ ⴰⵙ ⵄⴰⵡⴻⴷ: “ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵣⵉ ⵓⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN15_8","002_15_8","GEN","15","8","8","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵙ ⵎⵉⵏⵣⵉ ⵉ ⵖⴰ ⵙⵙⵏⴻⵖ, ⴱⴻⵍⵍⵉ ⴰⴷ ⵜⵜ ⵡⴰⵔⵜⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("GN15_9","002_15_9","GEN","15","9","9","ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⵊⵎⵉⵜ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵜⵍⴰⵜⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵏ ⵜⵍⴰⵜⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵊⵍⵉⵍⵍⴻⵃⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴷⴱⵉⵔ ⴷ ⴰⵎⴻⵥⵢⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN15_10","002_15_10","GEN","15","10","10","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⴱⴹⴰ ⵜⴻⵏ ⵅ ⵡⴻⵣⵢⴻⵏ ⵓ ⵉⴳⴳⴰ ⴽⵓⵍ ⴰⵣⵢⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴱⴹⵉ ⵛⴰ ⵉⵊⴹⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("GN15_11","002_15_11","GEN","15","11","11","ⵀⵡⴰⵏ-ⴷⴷ ⵉⵊⴹⴰⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵅ ⵉⵎⵓⵔⴹⴰⵙ, ⵎⴰⵛⴰ ⴰⴱⵔⴰⵎ ⵢⵓⵥⵥⴻⵍ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN15_12","002_15_12","GEN","15","12","12","ⵖⴰⵔ ⵓⵖⴻⴵⴰⵢ ⵏ ⵜⴼⵓⵛⵜ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⴰⴱⵔⴰⵎ ⵉⵊⵊ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⴵⴻⵙⵜ ⵉⵃⴻⴷⵇⴻⵏ ⵡⴹⴰⵏ-ⴷⴷ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN15_13","002_15_13","GEN","15","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⴰⴱⵔⴰⵎ: “ⵙⵙⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⴱⴰⵔⵔⴰⵏⴻⵛⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵅⴻⴷⵎⴻⵏ ⴰⵎ ⵉⵙⴻⵎⵖⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⴳⴳⴻⵏ ⴰⵖⵉⵍ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN15_14","002_15_14","GEN","15","14","14","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵓⵎⵉ ⵖⴰ ⵅⴻⴷⵎⴻⵏ ⴰⵎ ⵉⵙⴻⵎⵖⴰⵏ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴻⴽⵎⴻⵖ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⵙ ⵡⴰⴳⵍⴰ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN15_15","002_15_15","GEN","15","15","15","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⴷ ⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵙ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵏⴻⴹⵍⴻⵏ ⴰⵎ ⵓⵎⴻⵛⵛⴰⵢⴱⵓ ⵉⵡⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN15_16","002_15_16","GEN","15","16","16","ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴷⴰⵏⵉⵜⴰ, ⵎⵉⵏⵣⵉ ⵍⵇⴻⴷⴷ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵄⴰⴷ ⵡⴰⵔ ⵉⴽⴻⵎⵎⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("GN15_17","002_15_17","GEN","15","17","17","ⵍⴰⵎⵉ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴼⴰⵔⵔⴰⵏ ⵉⴷⴷⴻⵅⵅⵏⴻⵏ ⵓ ⵉⵄⴷⵓ ⵉⵊⵊ ⵏ ⵡⴻⵚⴼⴻⴹ ⵏ ⵜⵎⴻⵙⵙⵉ ⵊⴰⵔ ⵉⵣⴻⵢⵏⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN15_18","002_15_18","GEN","15","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⴱⵔⴰⵎ, ⵉⵏⵏⴰ: “ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵓⵎⵉ ⵡⵛⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍ ⵉⵖⵣⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ: ");
INSERT INTO rift_vpl VALUES ("GN15_19","002_15_19","GEN","15","19","19","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ, ⵉⵇⴻⵏⵉⵣⵉⵢⵢⴻⵏ, ⵉⵇⴰⴷⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN15_20","002_15_20","GEN","15","20","20","ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵉⴼⵉⵔⵣⵉⵢⵢⴻⵏ, ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN15_21","002_15_21","GEN","15","21","21","ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⴳⵉⵔⴳⴰⵛⵉⵢⵢⴻⵏ ⴷ ⵉⵢⵉⴱⵓⵙⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN16_1","002_16_1","GEN","16","1","1","ⵙⴰⵔⴰⵢ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴰⴱⵔⴰⵎ, ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⵜⵉⵔⵓⵡ ⵛⴰ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ ⵣⵉ ⵎⵉⵚⵔⴰ ⵇⵇⴰⵔⴻⵏⵜ ⴰⵙ ⵀⴰⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN16_2","002_16_2","GEN","16","2","2","ⵜⴻⵏⵏⴰ ⵙⴰⵔⴰⵢ ⵉ ⴰⴱⵔⴰⵎ: “ⴰⵇⴰ ⵜⴻⵥⵔⵉⴷ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵟⵟⴻⴼ ⵅⴰⴼⵉ ⵜⴰⵔⵡⴰ. ⴰⴷⴻⴼ ⵅ ⵜⴰⵢⵢⴰ ⵉⵏⵓ, ⴱⴰⵍⴰⴽ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴽⵙⵉⵖ ⵜⴰⵔⵡⴰ.” ⴰⴱⵔⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⵃⴻⵙⵙⴰ ⵖⴰⵔ ⵙⴰⵔⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("GN16_3","002_16_3","GEN","16","3","3","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵣⴷⴻⵖ ⴰⴱⵔⴰⵎ ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⵉⵡⵉ-ⴷⴷ ⵙⴰⵔⴰⵢ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴰⴱⵔⴰⵎ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵀⴰⵊⴰⵔ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵜⴻⵡⵛⴰ ⴰⵙ-ⴷⴷ ⵉ ⴰⴱⵔⴰⵎ, ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN16_4","002_16_4","GEN","16","4","4","ⵢⵓⴷⴻⴼ ⵅ ⵀⴰⵊⴰⵔ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ. ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ, ⵅⴻⵏⵏⵉ ⵜⴻⴷⵡⴻⵍ ⵍⴰⵍⵍⴰⵙ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN16_5","002_16_5","GEN","16","5","5","ⵜⴻⵏⵏⴰ ⵙⴰⵔⴰⵢ ⵉ ⴰⴱⵔⴰⵎ: “ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ ⴳⴳⵉⵏ ⴷⴰⵢⵉ ⵍⵎⵓⵏⴽⴰⵔ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⴰⵢⵢⴰ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵛ. ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ, ⴷⴻⵡⵍⴻⵖ ⴷ ⵜⴰⵎⴻⵃⴳⵓⵔⴻⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⴻⵊⵊ ⴰⴷ ⵉⵃⴽⴻⵎ ⵙⵉⴷⵉ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("GN16_6","002_16_6","GEN","16","6","6","ⵉⵏⵏⴰ ⴰⴱⵔⴰⵎ ⵉ ⵙⴰⵔⴰⵢ: “ⵅⵣⴰⵔ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵎ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ. ⴻⴳⴳ ⵣⵣⴰⵢⴻⵙ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⵎ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ.” ⵓⵛⴰ ⵙⴰⵔⴰⵢ ⵜⵇⴻⵎⵎⴻⵄ ⵉ-ⵜⵜ ⵓ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵡⴻⵍ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN16_7","002_16_7","GEN","16","7","7","ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵍⵇⴰ ⵉ-ⵜⵜ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵡⴰⵎⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵜⴰⵍⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("GN16_8","002_16_8","GEN","16","8","8","ⵉⵏⵏⴰ: “ⵀⴰⵊⴰⵔ, ⵜⴰⵢⵢⴰ ⵏ ⵙⴰⵔⴰⵢ, ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ?” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵜⵜⵔⴰⴽⴽⵡⴰⵍⴻⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵍⴰⵍⵍⴰ ⵙⴰⵔⴰⵢ!” ");
INSERT INTO rift_vpl VALUES ("GN16_9","002_16_9","GEN","16","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ: “ⴷⵡⴻⵍ ⵖⴰⵔ ⵍⴰⵍⵍⴰⵎ, ⵓⴹⴰⵔ ⵙⴰⴷⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN16_10","002_16_10","GEN","16","10","10","ⵉⵏⵏⴰ ⴰⵙ ⵄⴰⵡⴻⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ: “ⴰⴷ ⴽⴻⵜⵜⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵎ, ⴰⵍ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN16_11","002_16_11","GEN","16","11","11","ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ: “ⴰⵇⴰ ⵍⴻⵅⵅⵓ, ⵜⴻⴽⵙⵉⴷ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵡⴻⴷ ⴰⵙⴻⵢⵎⵉ. ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⴰⵎ ⴷⵉ ⵍⴻⵎⵃⴰⵢⴻⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN16_12","002_16_12","GEN","16","12","12","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵙⵏⵓⵙ ⵏ ⵍⴻⵅⵍⴰ. ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵎⴰⵔⵔⴰ, ⵓ ⴰⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵢⵉⵍⵉ ⵅⴰⵙ. ⴰⴷ ⵉⵣⴷⴻⵖ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN16_13","002_16_13","GEN","16","13","13","ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵍⴰⵖⴰ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵉⵙⵙⵉⵡⵍⴻⵏ, ⵜⴻⵏⵏⴰ: “ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ!”, ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴷⴰ ⵥⵔⵉⵖ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("GN16_14","002_16_14","GEN","16","14","14","ⵅ ⵓⵢⴰ ⵙⴻⵎⵎⴰⵏ ⴰⵏⵓ ⵏⵏⵉ: ⴰⵏⵓ ‘ⵍⴰⵃⴰⵢ-ⵔⵓ’ⵉ’. ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⵇⴰⴷⴰⵛ ⴷ ⴱⴰⵔⴰⴷ.    ");
INSERT INTO rift_vpl VALUES ("GN16_15","002_16_15","GEN","16","15","15","ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵀⴰⵊⴰⵔ ⵉ ⴰⴱⵔⴰⵎ ⴰⵙⴻⵢⵎⵉ. ⵉⴳⴳⴰ ⴰⵙ ⴰⴱⵔⴰⵎ ⵉⵙⴻⵎ ⵏ ⵎⵎⵉⵙ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵀⴰⵊⴰⵔ ‘ⵉⵙⵎⴰⵄⵉⵍ’. ");
INSERT INTO rift_vpl VALUES ("GN16_16","002_16_16","GEN","16","16","16","ⴰⴱⵔⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵀⴰⵊⴰⵔ ⵉⵙⵎⴰⵄⵉⵍ ⵉ ⴰⴱⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN17_1","002_17_1","GEN","17","1","1","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴰⴱⵔⴰⵎ ⵜⴻⵙⵄⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵙⵉⴷⵉ ⵉ ⴰⴱⵔⴰⵎ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ! ⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵓⵛⴰ ⵉⵍⵉ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉⴽⴻⵎⵎⵍⴻⵏ!    ");
INSERT INTO rift_vpl VALUES ("GN17_2","002_17_2","GEN","17","2","2","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⴽⴻⵜⵜⴰⵔⴻⵖ ⵙ ⵢⵉⵊⵊ ⵏ ⵛⵛⴽⴻⵍ ⵉⵎⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN17_3","002_17_3","GEN","17","3","3","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ ⴰⴱⵔⴰⵎ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("GN17_4","002_17_4","GEN","17","4","4","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("GN17_5","002_17_5","GEN","17","5","5","ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵄⴰⴷ ‘ⴰⴱⵔⴰⵎ’ ⵎⴰⵛⴰ ‘ⵉⴱⵔⴰⵀⵉⵎ’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("GN17_6","002_17_6","GEN","17","6","6","ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵖⵉⴵⴻⵜ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴷⴷ-ⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN17_7","002_17_7","GEN","17","7","7","ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN17_8","002_17_8","GEN","17","8","8","ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ, ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⴰⴳⵍⴰ ⵉ ⵍⴻⴱⴷⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN17_9","002_17_9","GEN","17","9","9","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⵛⴻⴽ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ, ⵛⴻⴽ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN17_10","002_17_10","GEN","17","10","10","ⴷ ⵡⴰ ⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵃⴹⴰⵎ ⵊⴰⵔ ⴰⵢⵉ-ⴷⴷ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵅⵜⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN17_11","002_17_11","GEN","17","11","11","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵅⴻⵜⵏⴻⵎ ⴰⵢⵙⵓⵎ ⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⴰⵢⵉ-ⴷⴷ ⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("GN17_12","002_17_12","GEN","17","12","12","ⵎⵎⵉⵙ ⵏ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵉⵅⵜⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵎⴽⵓⵍ ⴰⵡⵜⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⴰⵎ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵖⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵉ ⴽⵓⵍ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵓ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN17_13","002_17_13","GEN","17","13","13","ⴰⵎ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵜⴻⵙⵖⵉⴷ ⵙ ⵏⵏⵓⵇⴰⵔⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵅⵜⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵡⴻⵎ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("GN17_14","002_17_14","GEN","17","14","14","ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵅⵜⵉⵏⴻⵏ, ⵡⴻⵏⵏⵉ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜ ⵅⵜⵉⵏ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵇⴻⵙⵙⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵢⴰⵔⵥⴰ ⵍⵄⴰⵀⴷ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN17_15","002_17_15","GEN","17","15","15","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⵉ ⵙⴰⵔⴰⵢ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵍⵉⵖⵉⴷ ⵄⴰⴷ ‘ⵙⴰⵔⴰⵢ’, ⵎⴰⵛⴰ ‘ⵙⴰⵔⴰ’ ⴷ ⵡⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN17_16","002_17_16","GEN","17","16","16","ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⵜ ⴱⴰⵔⴽⴻⵖ ⵓ ⵣⵣⴰⵢⴻⵙ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵎⵎⵉⵛ. ⵡⴰⵀ, ⴰⴷ ⵜⵜ ⴱⴰⵔⴽⴻⵖ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⴻⴳⵏⵓⵙ ⵓ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN17_17","002_17_17","GEN","17","17","17","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴹⵃⴻⵛ, ⵉⵏⵏⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⴰⵔⵢⴰⵣ ⵏ ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⵍⴻⵇ ⵎⵎⵉⵙ? ⵓ ⵙⴰⵔⴰ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰ ⵄⴰⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ?” ");
INSERT INTO rift_vpl VALUES ("GN17_18","002_17_18","GEN","17","18","18","ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵎⵍⵉ ⵉⵙⵎⴰⵄⵉⵍ ⵉⴷⴷⴰⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN17_19","002_17_19","GEN","17","19","19","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ: “ⵍⵍⴰ, ⵄⴰⴷ ⵙⴰⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ, ⴷ ⵜⴻⵏⵏⵉ ⴷ ⴰⵛ ⴷⴷ ⵖⴰ ⵢⴰⵔⵡⴻⵏ ⴰⵙⴻⵢⵎⵉ, ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵜⵍⴰⵖⵉⴷ ⵉⵙⵃⴰⵇ. ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵙ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ.   ");
INSERT INTO rift_vpl VALUES ("GN17_20","002_17_20","GEN","17","20","20","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⴰⵇⴰ ⵙⴻⴵⴻⵖ ⴰⵛ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴱⴰⵔⴽⴻⵖ ⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⵉⵜⵜⴰⵔⵓⵡ ⵍⵖⵉⴵⴻⵜ ⵓ ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⴷ ⴰⵟⵟⴰⵙ. ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉ ⴷⴷ ⵖⴰ ⵢⴻⵊⵊ, ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN17_21","002_17_21","GEN","17","21","21","ⵎⴰⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵙⵃⴰⵇ, ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⴷⴷ ⵖⴰ ⵜⴰⵔⵓⵡ ⵙⴰⵔⴰ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN17_22","002_17_22","GEN","17","22","22","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ, ⵉⴳⴻⵄⵄⴻⴷ ⴰⵔⴻⴱⴱⵉ, ⵉⴳⴳⵯⴻⵊ ⵅ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN17_23","002_17_23","GEN","17","23","23","ⵉⴽⵙⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵎⵎⵉⵙ ⵉⵙⵎⴰⵄⵉⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⴻⵎⵖⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵎⵎⴻⵙⵖⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ ⵊⴰⵔ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⵉⵅⵜⴻⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN17_24","002_17_24","GEN","17","24","24","ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⵜⴻⵙⵄⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⵅⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN17_25","002_17_25","GEN","17","25","25","ⵉⴳⴳⴰ ⵎⵎⵉⵙ ⵉⵙⵎⴰⵄⵉⵍ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵜ ⵅⴻⵜⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN17_26","002_17_26","GEN","17","26","26","ⵉⵅⵜⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵎⵎⵉⵙ ⵉⵙⵎⴰⵄⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN17_27","002_17_27","GEN","17","27","27","ⵅⴻⵜⵏⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵎⵎⴻⵙⵖⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵣⴻⴳ ⵓⴱⴰⵔⵔⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN18_1","002_18_1","GEN","18","1","1","ⵓⵛⴰ ⵉⴹⵀⴰⵔ ⵙⵉⴷⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵖⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⴳⴳ ⵏ ⵎⴰⵎⵔⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN18_2","002_18_2","GEN","18","2","2","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ. ⵓⵎⵉ ⵜⴻⵏ ⵉⵥⵔⴰ, ⵉⴽⴽⴰⵔ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵖⴰⵔⵙⴻⵏ ⵣⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ. ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ,    ");
INSERT INTO rift_vpl VALUES ("GN18_3","002_18_3","GEN","18","3","3","ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵍⴻⵅⵅⵓ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ, ⵡⴰⵔ ⵄⴻⴷⴷⵓ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN18_4","002_18_4","GEN","18","4","4","ⴻⵊⵊ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵛⵡⴰⵢⵜ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵙⵉⵔⴷⴻⵎ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵣⵣⵍⴻⵎ ⵛⵡⴰⵢⵜ ⵙⴰⴷⵓ ⵜⵛⴻⵊⵊⴰⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN18_5","002_18_5","GEN","18","5","5","ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵖⵔⵓⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵏⴻⵄⵛⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵄⴷⵓⵎ. ⴰⵇⴰ ⵅ ⵓⵢⴰ ⵉ ⴷⴷ-ⵜⴻⴽⴽⵉⵎ ⵣⵣⴰⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ!” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴻⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN18_6","002_18_6","GEN","18","6","6","ⵉⵔⵓⵃ ⵉⴱⵔⴰⵀⵉⵎ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵖⴰⵔ ⵙⴰⵔⴰ, ⵉⵏⵏⴰ: “ⴷⴻⵖⵢⴰⵜ, ⴽⵙⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ, ⴻⴳⴳⵡ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⴻⴳⴳ ⵣⵣⴰⵢⴻⵙ ⵜⵉⴼⴹⵉⵔⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN18_7","002_18_7","GEN","18","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵣⵣⴻⵍ ⵉⴱⵔⴰⵀⵉⵎ ⵖⴰⵔ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵟⵟⴻⴼ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⵉⴳⵎⴰ ⴷ ⵍⴻⵎⵍⵉⵃ, ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⵓⴱⵍⵉⵖ, ⵓⵛⴰ ⵡⴰ ⵉⵇⴻⴵⴻⵇ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN18_8","002_18_8","GEN","18","8","8","ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵄⴰⵡⴻⴷ ⴷⴷⵀⴻⵏ ⴷ ⵓⵖⵉ ⴷ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏⵏⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵣⵣⴰⵜⵙⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ ⵙⴰⴷⵓ ⵜⵛⴻⵊⵊⴰⵔⵜ, ⵓⵛⴰ ⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN18_9","002_18_9","GEN","18","9","9","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵙⴰⵔⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⴰⵇⴰ-ⵜⵜ ⴷⵉⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN18_10","002_18_10","GEN","18","10","10","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵓ ⵅⵣⴰⵔ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵃⴻⵏⵊⵉⵔ ⵖⴰⵔ ⵙⴰⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ.” ⵓ ⵙⴰⵔⴰ ⵜⴻⵙⵍⴰ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN18_11","002_18_11","GEN","18","11","11","ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵙⴰⵔⴰ ⵜⵓⵖⴰ ⵡⵙⴰⵔⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ, ⵓⵛⴰ ⵙⴰⵔⴰ ⵜⵓⵖⴰ ⵜⴱⴻⴷⴷ ⴰⵙ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN18_12","002_18_12","GEN","18","12","12","ⵓⵛⴰ ⵜⴻⴹⵃⴻⵛ ⵙⴰⵔⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ: “ⴰⵡⴰⵔⵏⵉ ⵜⴻⵡⵙⴰⵔ ⵉⵏⵓ, ⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵍⵅⵉⵔ-ⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⵇⴰⵄ, ⴰⵎ ⵉⴵⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵡⵙⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("GN18_13","002_18_13","GEN","18","13","13","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⵎⴰⵖⴰⵔ ⵜⴻⴹⵃⴻⵛ ⵙⴰⵔⴰ, ⵜⴻⵏⵏⴰ: ‘ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵔⵡⴻⵖ ⴰⵎ ⵡⵙⴰⵔⴻⵖ ⵍⴻⵅⵅⵓ?’ ");
INSERT INTO rift_vpl VALUES ("GN18_14","002_18_14","GEN","18","14","14","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵅ ⵙⵉⴷⵉ ⵜⴻⵡⵄⴰⵔ? ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⵏⴻⴳⴳⴰ, ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵖⴰⵔ ⵙⴰⵔⴰ ⵎⵎⵉⵙ!” ");
INSERT INTO rift_vpl VALUES ("GN18_15","002_18_15","GEN","18","15","15","ⵙⴰⵔⴰ ⵜⴻⵏⴽⴰⵔ, ⵜⴻⵏⵏⴰ: “ⵡⴰⵔ ⴹⴻⵃⵛⴻⵖ ⵛⴰ!”, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵯⴻⴷ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵍⵍⴰ, ⴰⵇⴰ ⵛⴻⵎ ⵜⴹⴻⵃⵛⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("GN18_16","002_18_16","GEN","18","16","16","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙⵙⴻⵏⵏⵉ, ⵙⴻⵡⴹⴻⵏ ⵖⴰⵔ ⵙⴰⴷⵓⵎ, ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN18_17","002_18_17","GEN","18","17","17","ⵓⵛⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵎⴰ ⴰⴷ ⴼⴼⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵅ ⵉⴱⵔⴰⵀⵉⵎ ⵎⵉⵏ ⵉ ⵖⴰ ⴳⴳⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("GN18_18","002_18_18","GEN","18","18","18","ⴰⴷ ⵢⵉⵍⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵣⴻⵄⵎⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ ⵉⵊⵀⴻⴷ, ⴰⵇⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("GN18_19","002_18_19","GEN","18","19","19","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵇⵇⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ, ⵃⵉⵎⴰ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵎⵉⵏ ⵜⵓⵖⴰ ⵅⴰⵙ ⵉⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN18_20","002_18_20","GEN","18","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵓ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⴷⴻⵇⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN18_21","002_18_21","GEN","18","21","21","ⴰⴷ ⴷⴷ-ⵀⵡⵉⵖ, ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⴰ ⴳⴳⵉⵏ ⵏⵉⵛⴰⵏ ⴰⵎ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵙⴻⵏ ⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵏⵉⵖ ⵍⵍⴰ, ⴰⴷ ⵙⵙⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN18_22","002_18_22","GEN","18","22","22","ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵙⴰⴷⵓⵎ. ⵎⴰⵛⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN18_23","002_18_23","GEN","18","23","23","ⵓⵛⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵏⵏⴰ: “ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴰⵔⴻⴷⴵⴻⴷ ⵄⴰⵡⴻⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴽ-ⴷ ⵓⵄⴻⴼⴼⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("GN18_24","002_18_24","GEN","18","24","24","ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⴱⴰⵍⴰⴽ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⴻⴷⴵⴻⴷ, ⵓ ⵡⴰⵔ ⵜⵙⴻⵎⵎⵃⴻⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("GN18_25","002_18_25","GEN","18","25","25","ⵉⴳⴳⵯⴻⵊ ⵅⴰⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵢⴰ, ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴽ-ⴷ ⵓⵄⴻⴼⴼⴰⵏ, ⵡⴰⵀ, ⵉⴳⴳⵯⴻⵊ ⵅⴰⴽ ⴰⴷ ⵢⵉⵍⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵎⴻⵃⵙⵓⴱ ⴰⵎ ⵓⵄⴻⴼⴼⴰⵏ. ⴰⵇⴰ ⵍⵇⴰⴹⵉ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵙ ⵍⵃⴻⵇⵇ?” ");
INSERT INTO rift_vpl VALUES ("GN18_26","002_18_26","GEN","18","26","26","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⴷⵉ ⵙⴰⴷⵓⵎ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵙⴻⵎⵃⴻⵖ ⵉ ⵡⴻⵎⵛⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN18_27","002_18_27","GEN","18","27","27","ⵉⴱⵔⴰⵀⵉⵎ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ ⵍⴻⵅⵅⵓ, ⴱⴷⵉⵖ ⵣⴻⵄⵄⵎⴻⵖ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴷ ⵛⴰⵍ ⴷ ⵢⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("GN18_28","002_18_28","GEN","18","28","28","ⴰⴷ ⵜⴰⵖ ⵏⴻⵇⵚⴻⵏ ⵣⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵅⴻⵎⵙⴰ, ⵎⴰ ⴰⴷ ⵜⴰⵔⴻⴷⴵⴻⴷ ⵅ ⵅⴻⵎⵙⴰ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵏⴷⵉⵏⵜ?” ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜ ⵜⵜⴰⵔⴻⴷⴵⴻⵖ ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN18_29","002_18_29","GEN","18","29","29","ⵢⴰⵔⵏⵉ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵢⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴼ ⴷⵉⵏ ⴰⵔⴻⴱⵄⵉⵏ!” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ: “ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⴳⴳⴻⵖ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN18_30","002_18_30","GEN","18","30","30","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⵅⴻⵢⵢⵉⵇ ⵍⴻⵅⵅⵓ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵅⵎⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵄⴰⵡⴻⴷ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉⵏ ⵜⵍⴰⵜⵉⵏ!” ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵡⴰⵔ ⵜⵜ ⵜⵜⴰⵔⴻⴷⴵⴻⵖ ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⴷⵉⵏ ⵜⵍⴰⵜⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN18_31","002_18_31","GEN","18","31","31","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵅⵣⴰⵔ ⵍⴻⵅⵅⵓ, ⴱⴷⵉⵖ ⵣⴻⵄⵎⴻⵖ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉⵏ ⵎⵖⵉⵔ ⵄⵉⵛⵔⵉⵏ!” ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵡⴰⵔ ⵜⵜ ⵜⵜⴰⵔⴻⴷⴵⴻⵖ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN18_32","002_18_32","GEN","18","32","32","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⵅⴻⵢⵢⵉⵇ ⵍⴻⵅⵅⵓ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵅⵎⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵄⴰⵡⴻⴷ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉⵏ ⵎⵖⵉⵔ ⵄⴻⵛⵔⴰ!” ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵡⴰⵔ ⵜⵜ ⵜⵜⴰⵔⴻⴷⴵⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵄⴻⵛⵔⴰ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN18_33","002_18_33","GEN","18","33","33","ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵙⵉⴷⵉ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN19_1","002_19_1","GEN","19","1","1","ⵓⵛⴰ ⵉⵡⴹⴻⵏⵜ ⵅⴻⵏⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵖⴰⵔ ⵙⴰⴷⵓⵎ ⵙ ⴵⵉⵍⴻⵜ. ⵜⵓⵖⴰ ⵍⵓⵟ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵙⴰⴷⵓⵎ. ⵓⵎⵉ ⵜⴻⵏ ⵉⵥⵔⴰ ⵍⵓⵟ, ⵉⴽⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵍⵇⴰ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_2","002_19_2","GEN","19","2","2","ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰ ⵉⵙⵉⴷⵉⵜⴻⵏ ⵉⵏⵓ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⵙⵙⴻⵏⵙⴻⵎ, ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷⴻⵎ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴼⴰⵇⴻⵎ ⵣⵉⵛ, ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵡⴻⵎ.” ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵍⵍⴰ, ⴰⵇⴰ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⴰⴷ ⵏⴻⵙⵙⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN19_3","002_19_3","GEN","19","3","3","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⴻⵍⵍⴻⴼ ⵅⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⴰⴽⵉⴷⴻⵙ ⵔⵓⵃⴻⵏ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⴰⵎⴻⵏⵙⵉ, ⵉⴳⴳⵯⴰ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵛⴰ ⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN19_4","002_19_4","GEN","19","4","4","ⴰⵇⴰ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵟⵟⵚⴻⵏ, ⵇⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵙⴰⴷⵓⵎ, ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵡⴻⵙⵙⴰⵔ, ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵉⵟⵟⵓⵔⴼⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_5","002_19_5","GEN","19","5","5","ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ ⵉ ⵍⵓⵟ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴵⵉⵔⴻⵜ-ⴰ? ⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN19_6","002_19_6","GEN","19","6","6","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵍⵓⵟ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN19_7","002_19_7","GEN","19","7","7","ⵉⵏⵏⴰ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵇⴰⵄ ⵍⵖⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("GN19_8","002_19_8","GEN","19","8","8","ⵅⵣⴰⵔ, ⵖⴰⵔⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉ, ⵜⵉⵏⵏⵉ ⵄⴰⴷ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⴰⵔⵢⴰⵣ. ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵡⴻⵎ ⵜⴻⵏⵜ ⵉ-ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⴳⴳⴻⵎ ⴷⴰⵢⵙⴻⵏⵜ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ⵎⵖⵉⵔ ⵉ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵎ ⵡⴰⵍⵓ, ⴰⵇⴰ ⵅ ⵓⵢⴰ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵜⵉⵍⵉ ⵏ ⵜⵣⴻⵇⵇⴰ ⵉⵏⵓ ⵖⴰⵔ ⵜⵎⴻⵏⵙⵉⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN19_9","002_19_9","GEN","19","9","9","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⴳⴳⵯⴻⵊ ⴷⵉⵀⴰ!” ⵓⵛⴰ ⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ: “ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴷⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵓⵛⴰ ⵉⵅⵙ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⴽⴻⵎ ⴰⵎ ⵍⵇⴰⴹⵉ! ⵍⴻⵅⵅⵓ ⴰⴷ ⵛⴻⴽ ⵏⴹⴰⵔⵔ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ.” ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵓⵖⵉⵍ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵅ ⵍⵓⵟ, ⵓⵛⴰ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵥⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_10","002_19_10","GEN","19","10","10","ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴼⵓⵙ ⵏⵙⴻⵏ, ⵙⵙⵉⴷⴼⴻⵏ ⵍⵓⵟ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴱⴻⵍⵍⵄⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_11","002_19_11","GEN","19","11","11","ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵜⵓⴷⴷⴰⵔⵖⴻⵞ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⴰⵍⴰⵎⵉ ⵙⵙⵉⵀⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵅ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_12","002_19_12","GEN","19","12","12","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉ ⵍⵓⵟ: “ⵡⵉ ⵖⴰⵔⴻⴽ ⴷⴰ ⵄⴰⴷ? ⵎⴰ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵉⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵉⵖ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN19_13","002_19_13","GEN","19","13","13","ⴰⵇⴰ ⴰⴷ ⵏⴰⵔⴻⴷⴷⴻⴵ ⴰⵎⵛⴰⵏ-ⴰ, ⵎⵉⵏⵣⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵏⴻⵙ ⵜⴻⵎⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵏⴻⵖ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵏⴰⵔⴻⴷⴷⴻⴵ.” ");
INSERT INTO rift_vpl VALUES ("GN19_14","002_19_14","GEN","19","14","14","ⵉⴼⴼⴻⵖ ⵍⵓⵟ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⴹⴻⴳⴳⵯⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⴷ ⵎⴻⵍⵛⴻⵏ ⵢⴻⵙⵙⵉⵙ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔⴻⵎ, ⴼⴼⵖⴻⵎ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ.” ⵎⴰⵛⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵉⵜⵜⵇⴻⵚⵚⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴹⴻⴳⴳⵯⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN19_15","002_19_15","GEN","19","15","15","ⵓⵎⵉ ⵉⵚⴱⴻⵃ ⵍⵀⴰⵍ, ⵙⵙⵇⴻⴵⵇⴻⵏⵜ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵍⵓⵟ, ⵏⵏⴰⵏⵜ: “ⴽⴽⴰⵔ, ⵜⴻⴽⵙⵉⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵛ, ⵜⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵀⴻⵍⵍⵉⴽⴻⴷ ⵛⴰ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN19_16","002_19_16","GEN","19","16","16","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⵄⵉⵎ. ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷ ⵓⴼⵓⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵅⴰⵙ ⵉⵃⵉⵏⵏ. ⵏⵉⵜⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵏⴻⴷⵀⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_17","002_19_17","GEN","19","17","17","ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⴰⵔⵔⴰ, ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ! ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉ ⴷⵉ ⵊⵊⵉⵀⴻⵜ-ⴰ ⴰⵎ ⵜⴻⴽⵎⴻⵍ. ⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⵉⴷ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN19_18","002_19_18","GEN","19","18","18","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵍⵓⵟ: “ⵍⵍⴰ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("GN19_19","002_19_19","GEN","19","19","19","ⵅⵣⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵢⵓⴼⴰ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵡⴰⵀ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴻⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵜⴻⵏⵏⵉ ⴽⵉⴷⵉ ⵜⴻⴳⴳⵉⴷ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵊⵊⵉⴷ ⴷⴷⴰⵔⴻⵖ. ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵇⴱⴻⵍ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵟⵟⴻⴼ ⵍⵖⴰⵔ ⵓⵛⴰ ⴰⴷ ⵎⵎⵜⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("GN19_20","002_19_20","GEN","19","20","20","ⵅⵣⴰⵔ ⵍⴻⵅⵅⵓ, ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴰⵇⴰ ⵜⵓⴷⴻⵙ-ⴷⴷ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⵉⵏⵏⵉ ⴰⵔⴻⵡⵍⴻⵖ. ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⴻⵄⵏⴰⵏⵓⵛⵜ. ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵍⴻⵅⵅⵓ ⴷⵉⵏⵏⵉ. ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵜⴰⵎⴻⵄⵏⴰⵏⵓⵛⵜ? ⵅⴻⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴷⴷⴰⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN19_21","002_19_21","GEN","19","21","21","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵅⵣⴰⵔ, ⵜⵉⵡⴻⴹ ⴰⵢⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵜⵣⴰⵡⴻⴳⵜ ⵏⵏⴻⵛ ⵅ ⵓⵢⴰ, ⵡⴰⵔ ⵜⵜⴰⵔⴻⴷⴷⴵⴻⵖ ⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN19_22","002_19_22","GEN","19","22","22","ⵇⴻⴵⴻⵇ, ⴰⵔⵡⴻⵍ ⴷⵉⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵡⴰⵍⵓ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⴷⵉⵏⵏⵉ.” ⵅ ⵓⵢⴰ ⵙⴻⵎⵎⴰⵏ ⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵚⵓⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN19_23","002_19_23","GEN","19","23","23","ⴰⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵍⵓⵟ ⵖⴰⵔ ⵚⵓⵖⴰⵔ, ⵜⴻⵏⵇⴰⵔ-ⴷⴷ ⵜⴼⵓⵛⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_24","002_19_24","GEN","19","24","24","ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⵡⴻⵜ ⵡⴻⵏⵥⴰⵔ ⵅ ⵙⴰⴷⵓⵎ ⵓ ⵅ ⵄⴰⵎⵓⵔⵔⴰ, ⴷ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ ⴷ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵣⵉ ⵖⴰⵔ ⵙⵉⴷⵉ.    ");
INSERT INTO rift_vpl VALUES ("GN19_25","002_19_25","GEN","19","25","25","ⵢⴰⵔⴻⴷⴷⴻⴵ ⵏⴻⵜⵜⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⴷ ⵎⴰⵔⵔⴰ ⴰⴷⴻⵡⵡⴰⵔ ⵏⵏⵉ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵓⵍⴰ ⴷ ⴰⵖⴻⵎⵎⵓⵢ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_26","002_19_26","GEN","19","26","26","ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ, ⵜⴻⵅⵣⴰⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⴵⴰⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_27","002_19_27","GEN","19","27","27","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵉⴽⴽⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN19_28","002_19_28","GEN","19","28","28","ⵉⵙⵡⴻⴹ ⵖⴰⵔ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏⵏⵉ, ⵓⵛⴰ ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⴷⴷⴻⵅⵅⴰⵏ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⴼⵇⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_29","002_19_29","GEN","19","29","29","ⴰⵍⴰⵎⵉ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵔⴻⴱⴱⵉ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏⵏⵉ, ⵉⴼⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵍⵓⵟ ⴱⴰⵔⵔⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵛⴻⵍⵡⴰⵡ, ⵓⵎⵉ ⵉⵇⵍⴻⴱ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⴷⵉ ⵉⵣⴷⴻⵖ ⵍⵓⵟ. ");
INSERT INTO rift_vpl VALUES ("GN19_30","002_19_30","GEN","19","30","30","ⵉⴳⴻⵄⵄⴻⴷ ⵍⵓⵟ ⵣⵉ ⵚⵓⵖⴰⵔ ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵣⴷⴻⵖ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⴳⴳⵯⴻⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵚⵓⵖⴰⵔ. ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵉⴼⵔⵉ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN19_31","002_19_31","GEN","19","31","31","ⵜⴻⵏⵏⴰ ⵜⵎⴻⵏⵣⵓⵜ ⵉ ⵜⵎⴰⵥⵓⵥⵜ: “ⴱⴰⴱⴰⵜⵏⴻⵖ ⴷ ⴰⵡⴻⵙⵙⴰⵔ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵄⴻⵣⵔⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⴷⴻⴼ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵓⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_32","002_19_32","GEN","19","32","32","ⵣⵉⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⵛ ⴱⵉⵏⵓ ⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ ⴰⴷ ⵉⵙⵙⵓ ⵓⵛⴰ ⴰⴷ ⴽⵉⵙ ⵏⴻⵣⵣⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN19_33","002_19_33","GEN","19","33","33","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵡⵛⵉⵏⵜ ⴱⵉⵏⵓ ⵉ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ, ⵉⵙⵡⴰ. ⵅⴻⵏⵏⵉ ⵜⵓⴷⴻⴼ ⵜⵎⴻⵏⵣⵓⵜ, ⵜᵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵓⵛⵉ ⵛⴰ ⴱⴻⵍⵍⵉ ⵜⴻⵣⵣⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵏⵉⵖ ⵜⴻⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN19_34","002_19_34","GEN","19","34","34","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵜⴻⵏⵏⴰ ⵜⵎⴻⵏⵣⵓⵜ ⵉ ⵜⵎⴰⵥⵓⵥⵜ: “ⴰⵇⴰ ⵏⴻⵛⵛ ⵣⵣⵍⴻⵖ ⴵⵉⵔⴻⵜ ⵉⵄⴷⵓⵏ ⴰⴽ-ⴷ ⴱⴰⴱⴰ, ⴰⴷ ⴰⵙ ⵏⴻⵡⵛ ⴰⴷ ⵉⵙⵙⵓ ⴱⵉⵏⵓ ⵄⴰⵡⴻⴷ ⴵⵉⵔⴻⵜ-ⴰ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵛⴻⵎ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵣⵣⵍⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵏⴻⵊⵊ ⵊⵊⵉⵍ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵣⵉ ⵥⵥⴰⵔⵉⵄⴻⵜ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN19_35","002_19_35","GEN","19","35","35","ⵡⵛⵉⵏⵜ ⴱⵉⵏⵓ ⵉ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ ⵄⴰⵡⴻⴷ ⴷⵉ ⴵⵉⵔⴻⵜ ⵏⵏⵉ, ⵉⵙⵡⴰ. ⵅⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ ⵜⵎⴰⵥⵓⵥⵜ ⵓⵛⴰ ⵜᵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵙ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵓⵛⵉ ⵛⴰ ⴱⴻⵍⵍⵉ ⵜⴻⵣⵣⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵏⵉⵖ ⵜⴻⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN19_36","002_19_36","GEN","19","36","36","ⴰⵎⵎⵓ ⴽⵙⵉⵏⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵍⵓⵟ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵣⵉ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN19_37","002_19_37","GEN","19","37","37","ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵜⵎⴻⵏⵣⵓⵜ ⴰⵙⴻⵢⵎⵉ, ⵜⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵎⵓ’ⴰⴱ. ⵡⴰ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN19_38","002_19_38","GEN","19","38","38","ⵜⴰⵎⴰⵥⵓⵥⵜ ⵄⴰⵡⴻⴷ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵙⴻⵢⵎⵉ ⵓⵛⴰ ⵜⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴱⴻⵏ-ⵄⴰⵎⵎⵉ. ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵎⵎⵓⵏ ⵖⴰⵔ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN20_1","002_20_1","GEN","20","1","1","ⵙⵙⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. ⵉⵣⴷⴻⵖ ⵏⴻⵜⵜⴰ ⵊⴰⵔ ⵇⴰⴷⴰⵛ ⴷ ⵛⵓⵔ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵊⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN20_2","002_20_2","GEN","20","2","2","ⵓⵎⵉ ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵅ ⵙⴰⵔⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⵏⴻⵜⵜⴰⵜ ⴷ ⵓⵞⵎⴰ ⵉ ⵜⴻⴵⴰ!”, ⵉⵙⵙⴻⴽⴽ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⵉⵔⴰⵔ, ⵢⵉⵡⵉ ⴰⴽⵉⵙ ⵙⴰⵔⴰ.    ");
INSERT INTO rift_vpl VALUES ("GN20_3","002_20_3","GEN","20","3","3","ⵎⴰⵛⴰ ⵉⴹⵀⴰⵔ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵏ ⴵⵉⵔⴻⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⴻⵏⵏⵉ ⴷⴷ-ⵜⵉⵡⵢⴻⴷ ⴰⴽⵉⴷⴻⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ.” ");
INSERT INTO rift_vpl VALUES ("GN20_4","002_20_4","GEN","20","4","4","ⵎⴰⵛⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵡⴹⴻⴷ ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵙⴻⴳⴳⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("GN20_5","002_20_5","GEN","20","5","5","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵏⵏⵉ ⵏⴻⵜⵜⴰ: ‘ⵏⴻⵜⵜⴰⵜ ⴷ ⵓⵞⵎⴰ ⵉ ⵜⴻⴵⴰ!’, ⵓ ⵏⴻⵜⵜⴰⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴻⵏⵏⴰ ⵄⴰⵡⴻⴷ: ‘ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰ ⵉ ⵢⴻⴵⴰ!’ ⵙ ⵜⵉⴷⴻⵜⵜ ⵏ ⵡⵓⵍ ⵓ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵣⴷⵉⴳⴻⵏ ⵉ ⴳⴳⵉⵖ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN20_6","002_20_6","GEN","20","6","6","ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⴰⵔⵊⵉⵜ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵄⴰⴷ ⴱⴻⵍⵍⵉ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵏ ⵡⵓⵍ, ⵅ ⵓⵢⴰ ⵃⴹⵉⵖ ⵛⴻⴽ ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵅⴻⵟⵟⵉⴹ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵊⵊⵉⵖ ⴰⴷ ⵜⵜ ⵜⵃⴰⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN20_7","002_20_7","GEN","20","7","7","ⵍⴻⵅⵅⵓ, ⴰⵔⵔ ⵜⴰⵎⵖⴰⵔⵜ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵏⴰⴱⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⴽ ⵉⵥⵥⴰⴵ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜ ⵜⴰⵔⵔⵉⴷ ⵛⴰ, ⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN20_8","002_20_8","GEN","20","8","8","ⵉⴽⴽⴰⵔ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵣⵉⵛ ⵖⴰⵔ ⵚⵚⴱⴻⵃ. ⵉⵍⴰⵖⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN20_9","002_20_9","GEN","20","9","9","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵅ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴷ ⵎⵉⵏ ⴷⵉ ⵅⴹⵉⵖ ⴰⴽⵉⴷⴻⴽ ⵓⵎⵉ ⵜⵖⴻⴹⵔⴻⴷ ⵅⴰⴼⵉ ⵓ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⴷⴷⴻⵏⴱ ⴰⵎⴻⵇⵇⵔⴰⵏ? ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⴽⵉⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN20_10","002_20_10","GEN","20","10","10","ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⵎⵉⵏ ⵛⴻⴽ ⵢⴻⵊⵊⵉⵏ ⵍⴰⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("GN20_11","002_20_11","GEN","20","11","11","ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ: “ⵎⵉⵏⵣⵉ ⵏⵡⵉⵖ: ‘ⵏⵉⵛⴰⵏ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("GN20_12","002_20_12","GEN","20","12","12","ⵓⵛⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵜⵜⴰⵜ ⵄⴰⵡⴻⴷ ⴷ ⵓⵞⵎⴰ. ⵏⴻⵜⵜⴰⵜ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⵎⵎⴰ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN20_13","002_20_13","GEN","20","13","13","ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵜⵍⴻⵄ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ⵏⵏⵉⵖ ⴰⵙ: ‘ⴰⴷ ⵢⵉⵍⵉ ⵡⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵏⴻⵛⵛ, ⴰⵇⴰ ⴰⴷ ⵜⵉⵏⵉⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵏⴰⵡⴻⴹ: ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⴷ ⵓⵎⴰ!’” ");
INSERT INTO rift_vpl VALUES ("GN20_14","002_20_14","GEN","20","14","14","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⴰⴱⵉⵎⴰⵍⵉⴽⵉ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⵢⴰⵔⵔ ⴰⵙ ⵙⴰⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN20_15","002_20_15","GEN","20","15","15","ⵉⵏⵏⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ: “ⵅⵣⴰⵔ, ⵜⴰⵎⵎⵓⵔⵜ ⵉⵏⵓ ⴰⵇⴰ-ⵜⵜ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ. ⵣⴷⴻⵖ ⵎⴰⵏⵉ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN20_16","002_20_16","GEN","20","16","16","ⵉ ⵙⴰⵔⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵡⵛⵉⵖ ⴰⵍⴻⴼ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵓⵎⴰⵎ. ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⴰⵍⴻⵃⵃⴰⴼ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉ ⴽⵓⵍⵛⵉ ⵉⵏⵏⵉ ⴽⵉⴷⴻⵎ ⵉⴵⴰⵏ, ⵡⴰⵀ, ⵉ ⴽⵓⵍⵛⵉ ⵉⴷⵡⴻⵍ ⴰⵎ-ⴷⴷ ⴷ ⵜⵜⵉⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN20_17","002_20_17","GEN","20","17","17","ⵉⵥⵥⵓⴵ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵔⵡⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN20_18","002_20_18","GEN","20","18","18","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⵉⴱⴻⵍⵍⴻⵄ ⵇⴰⵄ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵍⴰⵡⴰⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⴰⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN21_1","002_21_1","GEN","21","1","1","ⵓⵛⴰ ⵢⴰⵔⵣⴻⴼ ⵙⵉⴷⵉ ⵖⴰⵔ ⵙⴰⵔⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵏⵏⴰ, ⵓⵛⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰ ⵉ ⵙⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN21_2","002_21_2","GEN","21","2","2","ⵜⴻⴽⵙⵉ ⵙⴰⵔⴰ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵎⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵅ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ, ⴷⵉ ⵍⵎⵉⵊⴰⵔ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN21_3","002_21_3","GEN","21","3","3","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵎⵎⵉⵙ ⴰⵙⴻⵢⵎⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵙⴰⵔⴰ, ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GN21_4","002_21_4","GEN","21","4","4","ⵉⴱⵔⴰⵀⵉⵎ ⵉⵅⵜⴻⵏ ⵉ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN21_5","002_21_5","GEN","21","5","5","ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵅⵍⴻⵇ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GN21_6","002_21_6","GEN","21","6","6","ⵜⴻⵏⵏⴰ ⵙⴰⵔⴰ: “ⵉⵙⵙⴻⴹⵃⴻⵛ ⴰⵢⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵍⴰⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵉⴹⵃⴻⵛ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN21_7","002_21_7","GEN","21","7","7","ⵜⴻⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵄⵎⴻⵏ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵇⴰ ⵙⴰⵔⴰ ⴰⴷ ⵜⴻⵙⵙⵓⵟⵟⴻⴹ ⵉⵙⴻⵢⵎⴰⵏ? ⴰⵇⴰ ⵓⵔⵡⴻⵖ ⴰⵙ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵅ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("GN21_8","002_21_8","GEN","21","8","8","ⵉⴳⵎⴰ ⵓⵙⴻⵢⵎⵉ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⴰⵙ ⵓⵟⵟⵓⴹ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷ ⴰⵙ ⴽⴽⵙⴻⵏ ⵓⵟⵟⵓⴹ ⵉ ⵉⵙⵃⴰⵇ, ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵜⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN21_9","002_21_9","GEN","21","9","9","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵙⴰⵔⴰ ⵎⵎⵉⵙ ⵏ ⵜⵎⵉⵚⵔⴻⵛⵜ ⵀⴰⵊⴰⵔ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵀⴰⵊⴰⵔ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵇⴻⵚⵚⴰⵔ ⵅⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("GN21_10","002_21_10","GEN","21","10","10","ⵜⴻⵏⵏⴰ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⴰⵥⵥⴻⵍ ⵅ ⵜⴰⵢⵢⴰ-ⵢⴰ ⴷ ⵎⵎⵉⵙ, ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ-ⵢⴰ ⵡⴰⵔ ⵉⵡⴰⵔⵔⴻⵜ ⵛⴰ ⴰⴽ-ⴷ ⵎⵎⵉ, ⴰⴽ-ⴷ ⵉⵙⵃⴰⵇ.” ");
INSERT INTO rift_vpl VALUES ("GN21_11","002_21_11","GEN","21","11","11","ⴰⵡⴰⵍ-ⴰ ⵉⴱⴰⵏ-ⴷⴷ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN21_12","002_21_12","GEN","21","12","12","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵜⵉⵙⵉⵏⴻⴼⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ⵙⴻⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵜⵉⵏⵉ ⵙⴰⵔⴰ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵉⵙⵃⴰⵇ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ.    ");
INSERT INTO rift_vpl VALUES ("GN21_13","002_21_13","GEN","21","13","13","ⴰⴷ ⴳⴳⴻⵖ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ-ⵢⴰ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN21_14","002_21_14","GEN","21","14","14","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵉⵛ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵢⴰⵔⵜ ⵏ ⵡⴰⵎⴰⵏ, ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵉ ⵀⴰⵊⴰⵔ, ⵉⵙⵙⴰⵔⵙ ⴰⵙ ⵜⴻⵏ ⵅ ⵜⴻⵖⵔⵓⴹⵜ. ⵉⵡⵛⴰ ⴰⵙ ⵄⴰⵡⴻⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵉ-ⵜⵜ. ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵔⵓⵃ, ⵜⴻⵏⵏⴻⵊⵔⵓ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GN21_15","002_21_15","GEN","21","15","15","ⵍⴰⵎⵉ ⵏⴻⵇⵚⴻⵏ ⵡⴰⵎⴰⵏ ⵣⵉ ⵜⴻⵛⵢⴰⵔⵜ, ⵜⴻⵏⴹⴰⵔ ⴰⵃⴻⵏⵊⵉⵔ ⵙⴰⴷⵓ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔⵇ, ");
INSERT INTO rift_vpl VALUES ("GN21_16","002_21_16","GEN","21","16","16","ⵓⵛⴰ ⵜⵔⵓⵃ ⵜⴻⵇⵇⵉⵎ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵍⴰⴳⴳⵯⴰⵊ ⵏ ⵜⴻⵛⵜⵉ ⵏ ⵍⵇⴻⵡⵙ, ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰ: “ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ ⵓⵃⴻⵏⵊⵉⵔ.” ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⵉⵎ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵜⴻⵙⵖⵓⵢⵢⵓ. ");
INSERT INTO rift_vpl VALUES ("GN21_17","002_21_17","GEN","21","17","17","ⵉⵙⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵍⴰⵖⴰ ⵉ ⵀⴰⵊⴰⵔ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ, ⵀⴰⵊⴰⵔ? ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵍⴰ ⵍⵃⴻⵙⵙ ⵏ ⵓⵃⴻⵏⵊⵉⵔ, ⴷⵉⵏ ⵎⴰⵏⵉ ⵉⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("GN21_18","002_21_18","GEN","21","18","18","ⴽⴽⴰⵔ, ⵙⴳⴻⵄⵄⴻⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵟⵟⴻⴼ ⴰⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN21_19","002_21_19","GEN","21","19","19","ⵓⵛⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵜⴻⵥⵔⴰ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ. ⵜⵔⵓⵃ, ⵜⵄⴻⵎⵎⴰⵔ ⵜⴰⵛⵢⴰⵔⵜ ⵙ ⵡⴰⵎⴰⵏ, ⵜⴻⵡⵛⴰ ⴰⵙ ⵉ ⵓⵃⴻⵏⵊⵉⵔ, ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN21_20","002_21_20","GEN","21","20","20","ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵓⵃⴻⵏⵊⵉⵔ, ⵉⵢⵎⴰ, ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵊⴻⴱⴱⴰⴷ ⵏ ⵍⵇⴻⵡⵙ. ");
INSERT INTO rift_vpl VALUES ("GN21_21","002_21_21","GEN","21","21","21","ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⴼⴰⵔⴰⵏ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⴰⵙ-ⴷⴷ ⵢⴻⵎⵎⴰⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN21_22","002_21_22","GEN","21","22","22","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵛⵜ ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴰⴽ-ⴷ ⴼⵉⴽⵓⵍ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⴽ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN21_23","002_21_23","GEN","21","23","23","ⵍⴻⵅⵅⵓ, ⵊⴰⴵ ⴰⵢⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵖⴻⵛⵛⵉⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⴰⵢⵢⴰⵡⴻⵏ ⵉⵏⵓ! ⵎⴰⵛⴰ ⵙ ⵎⵓⵅⴰⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⴽⵉⴽ ⴳⴳⵉⵖ ⵇⴱⴻⵍ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⵛⴻⴽ ⴰⴽⵉⴷⵉ ⵓ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN21_24","002_21_24","GEN","21","24","24","ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ: “ⵏⴻⵛⵛ ⴰⴷ ⵊⵊⴰⴵⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("GN21_25","002_21_25","GEN","21","25","25","ⵅⴰⵙ ⵓⵛⴰ ⵉⵄⴻⵢⵢⴻⴱ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵅ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵙ ⵓⵖⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN21_26","002_21_26","GEN","21","26","26","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵡⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜ ⵜⴻⵏⵏⵉⴷ ⵛⴰ ⵇⴱⴻⵍ. ⴰⵇⴰ ⴰⵍ ⵍⴻⵅⵅⵓ ⵉ ⵣⵣⴰⵢⴻⴽ ⵜ ⵙⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN21_27","002_21_27","GEN","21","27","27","ⵉⴽⵙⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵜⴻⵏ ⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN21_28","002_21_28","GEN","21","28","28","ⵎⴰⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉⴱⵔⴰⵀⵉⵎ ⵙⴻⴱⵄⴰ ⵏ ⵜⵅⴻⵙⵡⵉⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN21_29","002_21_29","GEN","21","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: “ⵎⵉⵏ ⵄⵏⴰⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵅⴻⵙⵡⵉⵏ ⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ?” ");
INSERT INTO rift_vpl VALUES ("GN21_30","002_21_30","GEN","21","30","30","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴽⵙⵉ ⵣⴻⵄⵎⴰ ⵙⴻⴱⵄⴰ ⴰⵢⴰ ⵏ ⵜⵅⴻⵙⵡⵉⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵉ ⵉⵖⵣⵉⵏ ⴰⵏⵓ-ⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN21_31","002_21_31","GEN","21","31","31","ⵅ ⵓⵢⴰ ⵙⴻⵎⵎⴰⵏ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵜⵓⵖⴰ ⵊⵊⵓⴵⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN21_32","002_21_32","GEN","21","32","32","ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵍⵄⴰⵀⴷ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴽⴽⴰⵔ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴰⴽ-ⴷ ⴼⵉⴽⵓⵍ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN21_33","002_21_33","GEN","21","33","33","ⵉⵥⵥⵓ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵎⴰⵔⵉⵙⵜ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴷⵉⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⴱⴷⴰ.    ");
INSERT INTO rift_vpl VALUES ("GN21_34","002_21_34","GEN","21","34","34","ⵉⵣⴷⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN22_1","002_22_1","GEN","22","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⴻⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵊⴰⵔⵔⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⴱⵔⴰⵀⵉⵎ!” ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN22_2","002_22_2","GEN","22","2","2","ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⴽⵙⵉ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵛ, ⵡⴻⵏⵏⵉ ⵜⴻⵅⵙⴻⴷ, ⵉⵙⵃⴰⵇ, ⵓⵛⴰ ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓⵔⵉⵢⴰ ⵓⵛⴰ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵜ ⴷⵉⵏ ⴷ ⵜⴰⵖⵔⴰⵚⵜ ⵅ ⵢⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵊⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN22_3","002_22_3","GEN","22","3","3","ⵉⴽⴽⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵉⵛ, ⵉⵃⴻⵣⵣⴻⵎ ⵉ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ. ⵉⵇⴻⵙⵙ ⴰⴽⴻⵛⵛⵓⴹ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ, ⵉⴽⴽⴰⵔ, ⵉⵔⵓⵃ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN22_4","002_22_4","GEN","22","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵎⵛⴰⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("GN22_5","002_22_5","GEN","22","5","5","ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵔⴰⵊⴰⵎ ⴷⴰ ⴰⴽ-ⴷ ⵡⴻⵖⵢⵓⵍ, ⵏⴻⵛⵛ ⴷ ⵓⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵏⵔⴰⵃ ⴷⵉⵀⴰ, ⴰⴷ ⵏⴻⵙⵊⴻⴷ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵏⴻⵄⵇⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("GN22_6","002_22_6","GEN","22","6","6","ⵉⴽⵙⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴽⴻⵛⵛⵓⴹ ⵉ ⵡⴻⵛⵎⴰⴹ ⵏ ⵜⵖⴰⵔⵚⵜ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ ⵓ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⴽⵙⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵜⵅⴻⴷⵎⴻⵛⵜ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵔⵓⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN22_7","002_22_7","GEN","22","7","7","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵙⵃⴰⵇ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ: “ⴱⴰⴱⴰ ⵉⵏⵓ!” ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⵎⵎⵉ!” ⵓⵛⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵓⴽⴻⵛⵛⵓⴹ, ⵎⴰⵛⴰ ⵎⴰⵏⵉ ⵉⴵⴰ ⵉⵣⵎⴰⵔ ⵉ ⵜⵖⴰⵔⵚⵜ?” ");
INSERT INTO rift_vpl VALUES ("GN22_8","002_22_8","GEN","22","8","8","ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ: “ⴰⵔⴻⴱⴱⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⴰⵔⵣⴻⵇ ⵙ ⵢⴻⵣⵎⴰⵔ ⵉ ⵜⵖⴰⵔⵚⵜ, ⴰ ⵎⵎⵉ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵔⵓⵃⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("GN22_9","002_22_9","GEN","22","9","9","ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ. ⴷⵉⵏ ⵉ ⵉⴱⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵄⴷⴻⵍ ⴰⴽⴻⵛⵛⵓⴹ, ⵉⵛⴰⵔⴼ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵅ ⵉⴽⴻⵛⵡⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("GN22_10","002_22_10","GEN","22","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴽⵙⵉ-ⴷⴷ ⵜⴰⵅⴻⴷⵎⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN22_11","002_22_11","GEN","22","11","11","ⵎⴰⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ ⴰⵙ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⴱⵔⴰⵀⵉⵎ, ⵉⴱⵔⴰⵀⵉⵎ!” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN22_12","002_22_12","GEN","22","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵙⵡⵉⵥⵥⵉⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵃⴻⵏⵊⵉⵔ. ⵡⴰⵔ ⴷ ⵜⵜⴻⴳⴳ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⵙⵙⵄⵉⵣⵣⴻⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN22_13","002_22_13","GEN","22","13","13","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵛⴱⴰⵔⵇ ⵣⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⵢⵓⵢⵓⵔ ⵉⴱⵔⴰⵀⵉⵎ ⴷⵉⵏⵏⵉ, ⵉⵟⵟⴻⴼ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵉⴳⴳⴰ-ⵉ-ⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN22_14","002_22_14","GEN","22","14","14","ⵉⵍⴰⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵙⴻⵎ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ: “ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴰⵔⵣⴻⵇ!” ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵇⵇⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⵍ ⴰⵙⵙ-ⴰ: “ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⵢⴰⵔⵣⴻⵇ!” ");
INSERT INTO rift_vpl VALUES ("GN22_15","002_22_15","GEN","22","15","15","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵡⵉⵙⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵉⴱⵔⴰⵀⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("GN22_16","002_22_16","GEN","22","16","16","ⵉⵏⵏⴰ: “ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜᵉⵟⵟⵉⴼⴻⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵛ, ⴰⴷ ⵊⵊⴰⴵⴻⵖ ⵅ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("GN22_17","002_22_17","GEN","22","17","17","ⴰⵇⴰ ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⴽⴻⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⵎ ⵢⵉⵊⴷⵉ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴷ ⵍⵡⴰⵔⵜ ");
INSERT INTO rift_vpl VALUES ("GN22_18","002_22_18","GEN","22","18","18","ⵓ ⴷⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN22_19","002_22_19","GEN","22","19","19","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⵊⵎⵉⵄ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GN22_20","002_22_20","GEN","22","20","20","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ, ⵄⴰⵡⴻⴷ ⵎⵉⵍⴽⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⵏⴰⵃⵓⵔ ⵓⵎⴰⵛ: ");
INSERT INTO rift_vpl VALUES ("GN22_21","002_22_21","GEN","22","21","21","ⵄⵓⵚ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⴷ ⴱⵓⵣ ⵓⵎⴰⵙ, ⴷ ⵇⴰⵎⵓⵡⵉⵍ ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⴰⵔⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("GN22_22","002_22_22","GEN","22","22","22","ⴷ ⴽⴰⵙⴰⴷ ⴷ ⵃⴰⵣⵓ ⴷ ⴼⵉⵍⴷⴰⵛ ⴷ ⵢⵉⴷⵍⴰⴼ ⴷ ⴱⵉⵜⵓⵡⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("GN22_23","002_22_23","GEN","22","23","23","ⴱⵉⵜⵓⵡⵉⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵔⵉⴼⵇⴰ. ⵜⵎⴻⵏⵢⴰ ⴰⵢⴰ ⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵎⵉⵍⴽⴰ ⵉ ⵏⴰⵃⵓⵔ, ⵓⵎⴰⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN22_24","002_22_24","GEN","22","24","24","ⵓ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵔⵉⵄⵓⵎⴰ, ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵟⴰⴱⴰⵃ ⴷ ⵊⴰⵃⴰⵎ ⴷ ⵜⴰⵃⴰⵛ ⴷ ⵎⴰⵄⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("GN23_1","002_23_1","GEN","23","1","1","ⵜⵓⵖⴰ ⵖⴰⵔ ⵙⴰⵔⴰ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⵎⵉⵊⴰⵍ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵙⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN23_2","002_23_2","GEN","23","2","2","ⵓⵛⴰ ⵜⴻⵎⵎⵓⵜ ⵙⴰⵔⴰ ⴷⵉ ⵇⴰⵔⵢⴰⵜ-ⴰⵔⴱⴰⵄ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵃⴰⴱⵔⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ, ⵉⵛⴹⴻⵏ ⵅ ⵙⴰⵔⴰ, ⵉⵙⵖⵓⵢ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN23_3","002_23_3","GEN","23","3","3","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⵟⵟⴰⵔⴼ ⵉ ⵓⵎⴻⵜⵜⵉⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("GN23_4","002_23_4","GEN","23","4","4","“ⵏⴻⵛⵛ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷ ⴰⵎⵄⴻⵣⵣⴻⴱ ⵖⴰⵔ ⴰⵡⴻⵎ. ⵡⵛⴻⵎ ⴰⵢⵉ ⵎⵖⵉⵔ ⴰⵏⴹⴻⵍ ⴷ ⴰⴳⵍⴰ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴹⵍⴻⵖ ⴰⵎⴻⵜⵜⵉⵏ ⵉⵏⵓ ⵣⵉ ⵣⵣⴰⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN23_5","002_23_5","GEN","23","5","5","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ ⵅ ⵉⴱⵔⴰⵀⵉⵎ, ⵏⵏⴰⵏ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("GN23_6","002_23_6","GEN","23","6","6","“ⵙⴻⵍ ⵖⴰⵔⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ! ⵛⴻⴽ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵊⴰⵔ ⴰⵏⴻⵖ. ⵏⴹⴻⵍ ⴰⵎⴻⵜⵜⵉⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵖ ⵉⵚⴻⴱⵃⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⴰⴷ ⵛⴻⴽ ⵉⵟⵟⴻⴼ ⵅ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵏⴻⴹⵍⴻⴷ ⴰⵎⴻⵜⵜⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN23_7","002_23_7","GEN","23","7","7","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵣⴰⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ ");
INSERT INTO rift_vpl VALUES ("GN23_8","002_23_8","GEN","23","8","8","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵙ ⴰⵔⵔⴰⵢ ⵏⵡⴻⵎ ⴰⴷ ⵏⴻⴹⵍⴻⵖ ⴰⵎⴻⵜⵜⵉⵏ ⵉⵏⵓ ⵣⵉ ⵣⵣⴰⵜ ⵉⵏⵓ, ⵙⵍⴻⵎ ⵖⴰⵔⵉ ⵓⵛⴰ ⵣⴰⵡⴳⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵖⴰⵔ ⵄⵉⴼⵔⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵣⵓⵀⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("GN23_9","002_23_9","GEN","23","9","9","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⵉⴼⵔⵉ ⵏ ⵎⴰⴽⴼⵉⵍⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵢⵉ ⵜ ⵉⵡⵛ ⵙ ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉⴽⵎⴻⵍ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵏⴹⴻⵍ ⵉⵏⵓ ⵉ ⵖⴰ ⵎⴻⵍⵍⴽⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN23_10","002_23_10","GEN","23","10","10","ⵄⵉⴼⵔⵓⵏ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵊⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ ⵓⵛⴰ ⵄⵉⴼⵔⵓⵏ, ⴰⵃⵉⵜⵜⵉ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵉⴱⵔⴰⵀⵉⵎ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("GN23_11","002_23_11","GEN","23","11","11","“ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ! ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵉⵢⵢⴰⵔ ⵓⵍⴰ ⴷ ⵉⴼⵔⵉ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⴰⵛ ⵜ ⵡⵛⴻⵖ, ⵏⴹⴻⵍ ⴰⵎⴻⵜⵜⵉⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN23_12","002_23_12","GEN","23","12","12","ⵅⴻⵏⵏⵉ ⵉⴱⴻⵏⴷⴻⵇ ⵉⴱⵔⴰⵀⵉⵎ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ");
INSERT INTO rift_vpl VALUES ("GN23_13","002_23_13","GEN","23","13","13","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵄⵉⴼⵔⵓⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴰ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ. ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵇⴱⴻⵍ ⵉ-ⵜⵜ ⵣⵣⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴻⴹⵍⴻⵖ ⴰⵎⴻⵜⵜⵉⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN23_14","002_23_14","GEN","23","14","14","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵄⵉⴼⵔⵓⵏ ⵅ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("GN23_15","002_23_15","GEN","23","15","15","“ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ! ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵢⵢⴰⵔ ⵉⵙⴻⴽⴽⵡⴰⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ? ⵏⴹⴻⵍ ⴰⵎⴻⵜⵜⵉⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN23_16","002_23_16","GEN","23","16","16","ⵉⵙⵍⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵄⵉⴼⵔⵓⵏ ⵓⵛⴰ ⵉⵡⵣⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵄⵉⴼⵔⵓⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ: ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⵎ ⵜⵜ ⵏⵏⵓⵎⴻⵏ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN23_17","002_23_17","GEN","23","17","17","ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵢⴻⵢⵢⴰⵔ ⵏ ⵄⵉⴼⵔⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⴽⴼⵉⵍⴰ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⴰⵎⵔⵉ, ⵉⵢⵢⴰⵔ ⴷ ⵉⴼⵔⵉ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵉⵏⵏⵉ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵖⴰⵔ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("GN23_18","002_23_18","GEN","23","18","18","ⴷ ⴰⴳⵍⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵣⴰⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN23_19","002_23_19","GEN","23","19","19","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵏⴹⴻⵍ ⵉⴱⵔⴰⵀⵉⵎ ⵙⴰⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵉⴼⵔⵉ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏ ⵎⴰⴽⴼⵉⵍⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵎⵔⵉ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵃⴰⴱⵔⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN23_20","002_23_20","GEN","23","20","20","ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵉⵢⵢⴰⵔ ⴰⴽ-ⴷ ⵢⴻⴼⵔⵉ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ ⵖⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⴰⵎ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN24_1","002_24_1","GEN","24","1","1","ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⵉⵡⵙⴰⵔ ⵓ ⵉⵎⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴱⴰⵔⴻⴽ ⵉⴱⵔⴰⵀⵉⵎ ⴷⵉ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("GN24_2","002_24_2","GEN","24","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴰⵡⴻⵙⵙⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵡⴽⵉⵍ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ: “ⴻⴳⴳ ⵍⴻⵅⵅⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵙⴰⴷⵓ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("GN24_3","002_24_3","GEN","24","3","3","ⴰⴷ ⴰⵛ ⵙⵙⵊⵊⴰⴵⴻⵖ ⵙ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵡⵢⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ ⵣⵉ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵖ ⵏⴻⵛⵛ ⵊⴰⵔ ⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN24_4","002_24_4","GEN","24","4","4","ⵎⴰⵛⴰ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵣⵉ ⴷⴷ-ⵓⵙⵉⵖ, ⵖⴰⵔ ⵔⴰⴵ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ ⵉⵙⵃⴰⵇ.” ");
INSERT INTO rift_vpl VALUES ("GN24_5","002_24_5","GEN","24","5","5","ⵉⵏⵏⴰ ⴰⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ: “ⴱⴰⵍⴰⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⴹⴼⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ. ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵔⵔⴻⵖ ⵎⵎⵉⵛ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("GN24_6","002_24_6","GEN","24","6","6","ⵉⵏⵏⴰ ⴰⵙ ⵉⴱⵔⴰⵀⵉⵎ: “ⵃⴹⴰⵜ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉ ⵛⴰ ⵎⵎⵉ ⴷⵉⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("GN24_7","002_24_7","GEN","24","7","7","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵟⵟⴼⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵔⴰⴵ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵖⴰⵔⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ, ⵉⵊⵊⵓⴵ ⴰⵢⵉ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ: ‘ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ!’, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵉⵙⵙⴻⴽⴽⴻⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵙⵙⴻⵏⵏⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("GN24_8","002_24_8","GEN","24","8","8","ⵎⴰⵍⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵜⴻⴹⴼⴰⵔ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⵍⴻⵍⵍⵉⴷ ⵣⵉ ⵜⵊⴰⴵⵉⵜ-ⴰ, ⵎⵖⵉⵔ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉ ⴷⵉⵏ ⵎⵎⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN24_9","002_24_9","GEN","24","9","9","ⵉⵙⵙⴰⵔⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏ ⵙⵉⴷⵉⵙ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵊⵊⵓⴵ ⴰⵙ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN24_10","002_24_10","GEN","24","10","10","ⵉⴽⵙⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵄⴻⵛⵔⴰ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⵣⴻⴳ ⵉⵍⴻⵖⵎⴰⵏ ⵏ ⵙⵉⴷⵉⵙ, ⵉⵔⵓⵃ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⴳⵍⴰ ⵉⵖⵍⴰⵏ ⵏ ⵙⵉⴷⵉⵙ. ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵔⴰⵎ-ⵏⴰⵀⵔⴰⵢⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵏⴰⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("GN24_11","002_24_11","GEN","24","11","11","ⵖⴰⵔ ⵓⵅⴻⵛⵛⵉ ⵏ ⵜⵎⴻⴷⴷⵉⵜ ⵉⵊⵊⴰ ⵉⵍⴻⵖⵎⴰⵏ ⴰⴷ ⵊⵊⵏⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵣⵣⴰⵜ ⵉ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ, ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⴷⴷ-ⴼⴼⵖⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵎⴻⵏⵜ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN24_12","002_24_12","GEN","24","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⵔⴰⵀⵉⵎ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⵄⴰⵡⵏⴻⴷ ⴰⵙⵙ-ⴰ ⵓⵛⴰ ⵙⵛⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN24_13","002_24_13","GEN","24","13","13","ⴰⵇⴰ ⴰⵢⵉ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵎⴻⵏⵜ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN24_14","002_24_14","GEN","24","14","14","ⴻⵊⵊ ⵜⴰⴱⵍⵉⵖⵜ ⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵉⵏⵉⵖ: ‘ⵙⴻⵀⵡⴰ-ⴷⴷ ⴰⵇⴱⵓⵛ ⵏⵏⴻⵎ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⴰⴷ ⵙⵡⴻⵖ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉ: ‘ⵙⵓ, ⴰⴷ ⵡⴰⵔⴷⴻⵖ ⵓⵍⴰ ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⴻⵛ!’, ⴰⵇⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⵉ ⵜⴻⴳⴳⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵙⵃⴰⵇ, ⵓ ⵙ ⵓⵢⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN24_15","002_24_15","GEN","24","15","15","ⵓⵛⴰ ⵄⴰⴷ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⴽⴻⵎⵎⴻⵔ ⴰⵡⴰⵍ, ⵉⵥⵔⴰ ⵔⵉⴼⵇⴰ, ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵉ ⴱⵉⵜⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵍⴽⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵏⴰⵃⵓⵔ ⵓⵎⴰⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵡⴻⵇⴱⵓⵛ ⵏⵏⴻⵙ ⵅ ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("GN24_16","002_24_16","GEN","24","16","16","ⵜⴰⴱⵍⵉⵖⵜ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ ⵉⵎⵖⴰⵔ, ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏ ⵡⴻⵔⵢⴰⵣ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ, ⵜⴻⵛⵛⵓⵔ ⴰⵇⴱⵓⵛ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴳⴻⵄⵄⴻⴷ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN24_17","002_24_17","GEN","24","17","17","ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔⴻⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ, ⵉⵏⵏⴰ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⴰⴷ ⵙⵡⴻⵖ ⵛⵡⴰⵢⵜ ⵏ ⵡⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴻⵇⴱⵓⵛ ⵏⵏⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("GN24_18","002_24_18","GEN","24","18","18","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵙⵓ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!” ⵜⵇⴻⴵⴻⵇ ⵜⴻⵙⵙⴻⵀⵡⴰ ⴰⵇⴱⵓⵛ ⵏⵏⴻⵙ ⵅ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵜⴻⵡⵛⴰ ⴰⵙ ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN24_19","002_24_19","GEN","24","19","19","ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵜⴻⵡⵛⴰ ⵉⵙⵡⴰ ⵎⵍⵉⵃ, ⵜⴻⵏⵏⴰ: “ⴰⴷ ⴰⵢⵎⴻⵖ ⴰⵎⴰⵏ ⵄⴰⵡⴻⴷ ⵉ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰⵔⵙⴻⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵙ ⵣⵣⵢⴰⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN24_20","002_24_20","GEN","24","20","20","ⵜⵇⴻⴵⴻⵇ ⵜᵉⵙⵙⴻⵅⵡⴰ ⴰⵇⴱⵓⵛ ⴷⵉ ⵜⴰⵔⵢⴰ, ⵜⵓⵣⵣⴻⵍ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵢⴻⵎ ⴰⵎⴰⵏ, ⵓⵛⴰ ⵜⵓⵢⴻⵎ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵎⴰⵏ ⵉ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN24_21","002_24_21","GEN","24","21","21","ⵡⴰⵅⵅⴰ ⵉⵜⴻⴱⵀⴻⵜ ⴷⴰⵢⴻⵙ ⵡⴻⵔⵢⴰⵣ, ⵉⵙⵇⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵀⵡⴻⵏ ⵅⴰⵙ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵏⵉⵖ ⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("GN24_22","002_24_22","GEN","24","22","22","ⵓⵎⵉ ⵊⵊⵉⵡⵏⴻⵏ ⵉⵍⴻⵖⵎⴰⵏ ⵜⵉⵙⴻⵙⵙⵉ, ⵉⴽⵙⵉ ⵡⴻⵔⵢⴰⵣ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵉⵛⵜ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ, ⵜⴻⵏⵏⵉ ⵉⵡⴻⵣⵏⴻⵏ ⴰⵣⵢⴻⵏ ⵛⵉⵇⵍⵓ, ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵎⴻⵇⵢⴰⵙⵉⵏ ⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⵉⵡⴻⵣⵏⴻⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("GN24_23","002_24_23","GEN","24","23","23","ⵉⵏⵏⴰ: “ⵉⵏⵉ ⴰⵢⵉ, ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴷ ⵢⴻⴵⵉⵙ? ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⴰⵎⵛⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵎ ⵎⴰⵏⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵏⵙ?” ");
INSERT INTO rift_vpl VALUES ("GN24_24","002_24_24","GEN","24","24","24","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴱⵉⵜⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵍⴽⴰ, ⵡⴻⵏⵏⵉ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵉ ⵏⴰⵃⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN24_25","002_24_25","GEN","24","25","25","ⵓⵛⴰ ⵜⴰⵔⵏⵉ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵓⵍⵓⵎ ⴷ ⵉⵖⴻⴵ, ⵓ ⵖⴰⵔⵏⴻⵖ ⵄⴰⵡⴻⴷ ⴰⵎⵛⴰⵏ ⵉ ⵜⵎⴻⵏⵙⵉⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN24_26","002_24_26","GEN","24","26","26","ⵓⵛⴰ ⵢⵓⴹⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("GN24_27","002_24_27","GEN","24","27","27","ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⵔⴰⵀⵉⵎ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴽⴽⵉⵙⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵓ. ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN24_28","002_24_28","GEN","24","28","28","ⵜⵓⵣⵣⴻⵍ ⵜⴻⴱⵍⵉⵖⵜ, ⵜⵄⴰⵡⴻⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⵢⴻⵎⵎⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN24_29","002_24_29","GEN","24","29","29","ⵓⵛⴰ ⵔⵉⴼⵇⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵓⵎⴰⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵍⴰⴱⴰⵏ, ⵓⵛⴰ ⵍⴰⴱⴰⵏ ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN24_30","002_24_30","GEN","24","30","30","ⵜⵓⵖⴰ ⵉⵥⵔⴰ ⵜⴰⵅⴰⴷⴻⵏⵜ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵎⴻⵇⵢⴰⵙⵉⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵞⵎⴰⵙ ⵓⵛⴰ ⵉⵙⵍⴰ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴰⵔ ⵓⵞⵎⴰⵙ ⵔⵉⴼⵇⴰ, ⵜⴻⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⴽⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ.” ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ. ⵅⵣⴰⵔ, ⵉⴱⴻⴷⴷ ⴷⵉⵀⴰ ⵣⵣⴰⵜ ⵉ ⵉⵍⴻⵖⵎⴰⵏ, ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN24_31","002_24_31","GEN","24","31","31","ⵉⵏⵏⴰ: “ⴰⵔⴰⵃ-ⴷⴷ, ⴰ ⵛⴻⴽ ⴷ ⴰⵎⵉⵎⵓⵏ ⵏ ⵙⵉⴷⵉ! ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴷⵉ ⴱⴰⵔⵔⴰ, ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵡⴻⵎⵛⴰⵏ ⵉ ⵉⵍⴻⵖⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN24_32","002_24_32","GEN","24","32","32","ⵉⵔⵓⵃ ⵡⴻⵔⵢⴰⵣ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵏⴻⵜⵜⴰ ⵉⴹⵍⴻⵇ ⵉ ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵉⵍⴻⵖⵎⴰⵏ. ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵍⵓⵎ ⴷ ⵎⴰⵛⵛⴰ, ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN24_33","002_24_33","GEN","24","33","33","ⵉⵙⵙⴰⵔⵙ ⵣⵣⴰⵜⴻⵙ ⵎⵉⵏ ⵖⴰ ⵢⴻⵛⵛ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵏⵉⵖ ⵜⴰⴱⵔⴰⵜ ⵉⵏⵓ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵉⵡⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("GN24_34","002_24_34","GEN","24","34","34","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN24_35","002_24_35","GEN","24","35","35","ⵙⵉⴷⵉ ⵉⴱⴰⵔⴽ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵛⵛⴰⵏ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ, ⵉⵍⴻⵖⵎⴰⵏ ⴷ ⵢⴻⵖⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("GN24_36","002_24_36","GEN","24","36","36","ⴷ ⵙⴰⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜⴻⵡⵙⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN24_37","002_24_37","GEN","24","37","37","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵊⵊⴰ ⴰⵢⵉ ⵊⵊⵓⴵⴻⵖ, ⵉⵏⵏⴰ: ‘ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ ⵣⵉ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵉⵏⵏⵉ ⵎⴰⵏⵉ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN24_38","002_24_38","GEN","24","38","38","ⵓⵛⵜ ⵅⴰⴽ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ⵖⴰⵔ ⵔⴰⴵ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ ⵙⵙⴻⵏⵏⵉ.’ ");
INSERT INTO rift_vpl VALUES ("GN24_39","002_24_39","GEN","24","39","39","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ‘ⴱⴰⵍⴰⴽ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴹⴻⴼⴼⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("GN24_40","002_24_40","GEN","24","40","40","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵙⵉⴷⵉ ⵉ ⵓⵎⵉ ⵓⵢⵓⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵉⵙⵙⴻⵀⵡⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴰⵡⵢⴻⴷ ⵉ ⵎⵎⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⵍⴰⴵ ⵉⵏⵓ ⵓ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("GN24_41","002_24_41","GEN","24","41","41","ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴼⴻⴽⴽⴻⴷ ⵣⵉ ⵜⵊⴰⴵⵉⵜ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵊⵊⵓⴵⴻⴷ, ⵅⵎⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵍⴰⴵ ⵉⵏⵓ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵛ ⵜⵜ ⵜⵜⵉⵛⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⵊⴰⴵⵉⵜ ⵏⵏⴻⵛ ⵉ ⵜⵓⵖⴰ ⵜⴻⵊⵊⵓⴵⴻⴷ.’ ");
INSERT INTO rift_vpl VALUES ("GN24_42","002_24_42","GEN","24","42","42","ⴰⵙⵙ-ⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ ⵓⵛⴰ ⵏⵏⵉⵖ: ‘ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⵔⴰⵀⵉⵎ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴰⴷ ⵜᵉⵙⵙⵀⴻⵡⵏⴻⴷ ⵍⴻⵅⵅⵓ ⴰⴱⵔⵉⴷ ⵉ ⴷⵉ ⴳⴳⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN24_43","002_24_43","GEN","24","43","43","ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ ⵣⵣⴰⵜ ⵉ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ. ⴻⵊⵊ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎⵎⵓ, ⴰⵇⴰ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵜⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵢⴻⵎ ⴰⵎⴰⵏ ⵓ ⵉ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵉⵏⵉⵖ: ⴻⵡⵛ ⴰⵢⵉ ⴰⴷ ⵙⵡⴻⵖ ⵛⵡⴰⵢⵜ ⵏ ⵡⴰⵎⴰⵏ ⵣⴻⴳ ⵓⵇⴱⵓⵛ ⵏⵏⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("GN24_44","002_24_44","GEN","24","44","44","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴰⵢⵉ ⵜⵉⵏⵉ: ⵙⵓ ⵛⴻⴽ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵢⵎⴻⵖ ⵄⴰⵡⴻⴷ ⵉ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⴻⵛ!, ⴷ ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵙⵉⴷⵉ ⵉ ⵎⵎⵉⵙ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("GN24_45","002_24_45","GEN","24","45","45","ⵓⵛⴰ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵖ ⵜⴰⵥⴰⴵⵉⵜ-ⴰ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ, ⵅⵣⴰⵔ, ⵔⵉⴼⵇⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵙ ⵓⵇⴱⵓⵛ ⵏⵏⴻⵙ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ, ⵜⴻⵀⵡⴰ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔ ⵓⵛⴰ ⵜⵓⵢⴻⵎ-ⴷⴷ ⴰⵎⴰⵏ. ⵏⵏⵉⵖ ⴰⵙ: ‘ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⴰⴷ ⵙⵡⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("GN24_46","002_24_46","GEN","24","46","46","ⴷⴻⵖⵢⴰ ⵜⴻⵙⵙⴻⵀⵡⴰ ⴰⵇⴱⵓⵛ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ: ‘ⵙⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵙⵡⴻⵖ ⵄⴰⵡⴻⴷ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⴻⵛ!’ ⵙⵡⵉⵖ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵉⵍⴻⵖⵎⴰⵏ ⴰⴷ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN24_47","002_24_47","GEN","24","47","47","ⵙⵙⴻⵇⵙⵉⵖ ⵜⵜ, ⵏⵏⵉⵖ: ‘ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴷ ⵢⴻⴵⵉⵙ?’ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ: ‘ⵏⴻⵛⵛ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴱⵉⵜⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⵓⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵎⵉⵍⴽⴰ.’ ⵅⴻⵏⵏⵉ ⴳⴳⵉⵖ ⴰⵙ ⵜⴰⵅⴰⴷⴻⵏⵜ ⴷⵉ ⵜⵉⵏⵣⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵇⵢⴰⵙⵉⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN24_48","002_24_48","GEN","24","48","48","ⵅⴰⵙ ⵓⵛⴰ ⵓⴹⴰⵔⴻⵖ, ⴱⴻⵏⴷⵇⴻⵖ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴱⴰⵔⴽⴻⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⵔⴰⵀⵉⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵏⴻⴷⵀⴻⵏ ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵉⴵⵉⵙ ⵏ ⵓⵎⴰⵙ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN24_49","002_24_49","GEN","24","49","49","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⵛⵏⴻⵎ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵉⵏⵉ ⴰⵢⵉ ⵜ, ⵎⴰⵍⴰ ⵍⵍⴰ, ⵉⵏⵉ ⴰⵢⵉ ⵜ ⵄⴰⵡⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴽⴻⵖ ⵢⴻⴼⵓⵙ ⵏⵉⵖ ⵓⵣⴻⵍⵎⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("GN24_50","002_24_50","GEN","24","50","50","ⵅⴻⵏⵏⵉ ⵍⴰⴱⴰⵏ ⴷ ⴱⵉⵜⵓⵡⵉⵍ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ: “ⵣⵉ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓⵢⴰ, ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴰⵢⴻⴽ ⵏⵉⵏⵉ ⵍⵖⴰⵔ ⵏⵉⵖ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN24_51","002_24_51","GEN","24","51","51","ⵅⵣⴰⵔ, ⵔⵉⴼⵇⴰ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ, ⴽⵙⵉ ⵜⵜ ⵓⵛⴰ ⵜⵔⵓⵃⴻⴷ. ⴰⴷ ⵜⵉⵍⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN24_52","002_24_52","GEN","24","52","52","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ, ⵉⴱⴻⵏⴷⴻⵇ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN24_53","002_24_53","GEN","24","53","53","ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵔⵔⵓⴹⴻⵏ, ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵉ ⵔⵉⴼⵇⴰ. ⵄⴰⵡⴻⴷ ⵉⵡⵛⴰ ⵜⵉⵔⵣⵉⴼⵉⵏ ⵉⵖⵍⴰⵏ ⵉ ⵓⵎⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN24_54","002_24_54","GEN","24","54","54","ⵛⵛⵉⵏ, ⵙⵡⵉⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⴽⵉⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ. ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉⵏ ⵓⵛⴰ ⴼⴰⵇⴻⵏ ⵖⴰⵔ ⵚⵚⴱⴻⵃ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵙⴰⵎⵃⴻⵎ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN24_55","002_24_55","GEN","24","55","55","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵓⵎⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ: “ⴻⵊⵊ ⵜⴰⴱⵍⵉⵖⵜ ⴰⴽⵉⴷⵏⴻⵖ ⵡⴰⵅⵅⴰ ⵎⵖⵉⵔ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN24_56","002_24_56","GEN","24","56","56","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵟⵟⵉⴼⴻⵎ ⵄⴰⴷ ⵓⵎⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵀⵡⴻⵏ ⴰⴱⵔⵉⴷ ⵉⵏⵓ! ⵎⵖⵉⵔ ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN24_57","002_24_57","GEN","24","57","57","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵍⴻⵅⴷⴻⵏⵏⵉ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵍⴰⵖⴰ ⵉ ⵜⴻⴱⵍⵉⵖⵜ, ⴰⴷ ⵏⵙⴻⵍ ⵉ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN24_58","002_24_58","GEN","24","58","58","ⵍⴰⵖⴰⵏ ⵉ ⵔⵉⴼⵇⴰ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵛⴻⵎ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ-ⴰ?” ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ: “ⵡⴰⵀ, ⴰⴷ ⵔⴰⵃⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN24_59","002_24_59","GEN","24","59","59","ⵅⴻⵏⵏⵉ ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵔⵉⴼⵇⴰ, ⵓⵞⵎⴰⵜⵙⴻⵏ, ⴰⴽ-ⴷ ⵜⵎⴻⵟⵟⴰⴹⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN24_60","002_24_60","GEN","24","60","60","ⵓⵛⴰ ⴱⴰⵔⴽⴻⵏ ⵔⵉⴼⵇⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵓⵞⵎⴰⵜⵏⴻⵖ, ⴰⴷ ⵜⴰⵡⴹⴻⴷ ⴰⴷ ⵜⴻⵎⵖⴰⵔⴻⴷ ⴷ ⵍⵓⵍⵓⴼ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵓⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵎ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵜⵜ ⵉⵛⴰⵔⵔⵀⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN24_61","002_24_61","GEN","24","61","61","ⵜⴻⴽⴽⴰⵔ ⵔⵉⴼⵇⴰ ⴷ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⵏⵢⵉⵏⵜ ⵅ ⵉⵍⴻⵖⵎⴰⵏ, ⴹⴼⴰⵔⴻⵏⵜ ⴰⵔⵢⴰⵣ. ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵢⵉⵡⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵔⵉⴼⵇⴰ ⵓⵛⴰ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GN24_62","002_24_62","GEN","24","62","62","ⴰⵇⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵙⵃⴰⵇ ⵣⴻⴳ ⵡⴰⵏⵓ ⵏ ⵍⴰⵃⴰⵢ-ⵔⵓ’ⵉ. ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN24_63","002_24_63","GEN","24","63","63","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵙⵃⴰⵇ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⵥⴰⴵ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵜⵓⵖⴰ-ⵜⵜ ⵖⴰⵔ ⵓⵡⴻⵟⵟⵓ ⵏ ⵜⵎⴻⴷⴷⵉⵜ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵇⵛⴻⵄ, ⵓ ⵅⵣⴰⵔ, ⵉⵍⴻⵖⵎⴰⵏ ⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ-ⴷⴷ! ");
INSERT INTO rift_vpl VALUES ("GN24_64","002_24_64","GEN","24","64","64","ⵔⵉⴼⵇⴰ ⵄⴰⵡⴻⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵜⴻⵥⵔⴰ ⵉⵙⵃⴰⵇ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵊⵊⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜⴹⴰⵔ ⴷⴻⵖⵢⴰ ⵅ ⵡⴻⵍⵖⴻⵎ ");
INSERT INTO rift_vpl VALUES ("GN24_65","002_24_65","GEN","24","65","65","ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵖⴰⵔⵏⴻⵖ?” ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ: “ⵡⴰ ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ!” ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵜⴰⴽⴻⵏⴱⵓⵛⵜ ⵓⵛⴰ ⵜⵍⴻⵃⵃⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("GN24_66","002_24_66","GEN","24","66","66","ⵓⵛⴰ ⵉⵄⴰⵡⴻⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉ ⵉⵙⵃⴰⵇ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("GN24_67","002_24_67","GEN","24","67","67","ⵉⴳⴻⵡⵡⴻⴷ ⵉ-ⵜⵜ ⵉⵙⵃⴰⵇ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵢⴻⵎⵎⴰⵙ ⵙⴰⵔⴰ, ⵢⵉⵡⵉ ⵔⵉⴼⵇⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜⵜ. ⴰⵎⵎⵓ ⵉ ⵉⴼⴻⵡⵡⴻⵊ ⵉⵙⵃⴰⵇ ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵡⵜ ⵏ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN25_1","002_25_1","GEN","25","1","1","ⵉⴽⵙⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵇⴰⵜⵓⵔⴰ.    ");
INSERT INTO rift_vpl VALUES ("GN25_2","002_25_2","GEN","25","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵣⵉⵎⵔⴰⵏ, ⵢⴰⵇⵛⴰⵏ, ⵎⵉⴷⵢⴰⵏ, ⵢⵉⵛⴱⴰⵇ ⴷ ⵛⵓⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("GN25_3","002_25_3","GEN","25","3","3","ⵢⵓⵇⵛⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⴱⴰ ⴷ ⴷⴰⴷⴰⵏ. ⵓⵛⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⴰⴷⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵛⵛⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵍⵉⵜⵓⵛⵉⵢⵢⴻⵏ ⴷ ⵉⵍⵉⵢⵓⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN25_4","002_25_4","GEN","25","4","4","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵢⴼⴰ, ⵄⵉⴼⴰⵔ, ⵃⴰⵏⵓⵅ, ⴰⴱⵉⴷⴰⵄ ⴷ ⴰⵍⴷⴰⵄⴰ. ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵇⴰⵟⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN25_5","002_25_5","GEN","25","5","5","ⵉⴱⵔⴰⵀⵉⵎ ⵉⵡⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GN25_6","002_25_6","GEN","25","6","6","ⵎⴰⵛⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⵉⵢⵢⴰ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴰⵔⵔⵉⵖⴰⵍⵓⵜ ⵓⵛⴰ, ⴰⵎ ⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⴷⴷⴰⵔ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵔⵇ, ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵉ-ⵜⴻⵏ ⵅ ⵉⵙⵃⴰⵇ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("GN25_7","002_25_7","GEN","25","7","7","ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⵉⴷⴷⴰⵔ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵡⴰ ⴷ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN25_8","002_25_8","GEN","25","8","8","ⵉⴹⵍⴻⵇ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴷⵉ ⵛⵛⵉⴱ ⵉⵙⴻⴳⴳⴻⴷ, ⴷⵉ ⵜⴻⵡⵙⴰⵔ ⴷ ⵜⵢⴰⵡⴰⵏⵜ. ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN25_9","002_25_9","GEN","25","9","9","ⵉⵙⵃⴰⵇ ⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵉⴼⵔⵉ ⵏ ⵎⴰⴽⴼⵉⵍⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵄⵉⴼⵔⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵃⴰⵔ, ⴰⵃⵉⵜⵜⵉ, ⵉⵢⵢⴰⵔ ⵉ ⵉⴵⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵎⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN25_10","002_25_10","GEN","25","10","10","ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵙⴰⵔⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⵉⵙⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("GN25_11","002_25_11","GEN","25","11","11","ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵉⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ. ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⵉⵙⵃⴰⵇ ⵣⵣⴰⵜ ⵉ ⵡⴰⵏⵓ ⵏ ⵍⴰⵃⴰⵢ-ⵔⵓ’ⵉ. ");
INSERT INTO rift_vpl VALUES ("GN25_12","002_25_12","GEN","25","12","12","ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵏⵏⵉ ⴷⴷ-ⵜⴻⵊⵊⴰ ⵀⴰⵊⴰⵔ, ⵜⴰⵢⵢⴰ ⵏ ⵙⴰⵔⴰ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵉ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN25_13","002_25_13","GEN","25","13","13","ⴷ ⵢⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵅⵍⴰⵇ ⵏⵙⴻⵏ. ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵎⴰⵄⵉⵍ ⵜⵓⵖⴰ-ⵜ ⴷ ⵏⴰⴱⴰⵢⵓⵜ, ⵅⴻⵏⵏⵉ ⵇⵉⴷⴰⵔ, ⴰⴷⴱⵉⵢⵉⵍ, ⵎⵉⴱⵙⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("GN25_14","002_25_14","GEN","25","14","14","ⵎⵉⵙⵎⴰ, ⴷⵓⵎⴰ, ⵎⴰⵙⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("GN25_15","002_25_15","GEN","25","15","15","ⵃⴰⴷⴰⵔ, ⵜⴰⵢⵎⴰ, ⵢⴰⵟⵓⵔ, ⵏⴰⴼⵉⵛ ⴷ ⵇⵉⴷⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("GN25_16","002_25_16","GEN","25","16","16","ⴷ ⵢⵉⵏⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵙⵎⴰⵄⵉⵍ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵙ ⴷⵛⵓⵔⴰⵜ ⵏⵙⴻⵏ ⴷ ⵍⵎⴰⵔⴰⴳⴻⵃ ⵏⵙⴻⵏ: ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵙ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN25_17","002_25_17","GEN","25","17","17","ⵜⵓⵖⴰ ⵉⴷⴷⴰⵔ ⵉⵙⵎⴰⵄⵉⵍ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵅⴻⵏⵏⵉ ⵉⴹⵍⴻⵇ ⵉⵙⵎⴰⵄⵉⵍ ⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN25_18","002_25_18","GEN","25","18","18","ⵏⵉⵜⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵣⵉ ⵃⴰⵡⵉⵍⴰ ⵖⴰⵔ ⵛⵓⵔ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵎ ⵜᵉⵟⵟⴼⴻⴷ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⴰⵛⵛⵓⵔ. ⵏⴻⵜⵜⴰ ⵉⵣⴷⴻⵖ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵉⵙⵃⴰⵇ, ⵎⵎⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN25_19","002_25_19","GEN","25","19","19","ⵉⴱⵔⴰⵀⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GN25_20","002_25_20","GEN","25","20","20","ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⵙⵃⴰⵇ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵢⵉⵡⵉ ⵔⵉⴼⵇⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ⵏⴻⵜⵜⴰⵜ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴱⵉⵜⵓⵡⵉⵍ, ⴰⵔⴰⵎⵉⵢⵓ ⵣⵉ ⴼⴰⴷⴷⴰⵏ-ⴰⵔⴰⵎ, ⵓⵞⵎⴰⵙ ⵏ ⵍⴰⴱⴰⵏ, ⴰⵔⴰⵎⵉⵢⵓ. ");
INSERT INTO rift_vpl VALUES ("GN25_21","002_25_21","GEN","25","21","21","ⵉⵃⴻⵛⵛⴻⵎ ⵉⵙⵃⴰⵇ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ ⵛⴰ, ⵓⵛⴰ ⵉⵙⵜⴰⵊⴻⴱ ⴰⵙ ⵙⵉⴷⵉ ⵙ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵢⵓⴵⵖⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⴻⴽⵙⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵔⵉⴼⵇⴰ, ⴷⴷⴻⵢⵙⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN25_22","002_25_22","GEN","25","22","22","ⵓⵛⴰ ⵎⵎⴷⴻⵃⵙⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ: “ⵎⴰⵏⴰⵡⵢⴰ ⵄⴰⵡⴻⴷ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵎⴰⵏ ⴰⵢⴰ?”, ⵓⵛⴰ ⵜⵔⵓⵃ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN25_23","002_25_23","GEN","25","23","23","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⴰⵇⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⴷⴷⴻⵢⵙⴻⵜ ⵏⵏⴻⵎ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵛⵛⵓⵄⵓⴱ ⴰⴷ ⵎⵎⵙⴻⴱⴹⴰⵏ ⵣⵉ ⴷⵡⴰⵅⴻⵍ ⵏⵏⴻⵎ. ⵉⵊⵊ ⵏ ⵛⵛⴻⵄⴱ ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵀⴻⴷ ⵅ ⵛⵛⴻⵄⴱ ⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵏⵣⵓ ⴰⴷ ⵉⵅⴷⴻⵎ ⵉ ⵓⵎⴰⵥⵓⵥ.” ");
INSERT INTO rift_vpl VALUES ("GN25_24","002_25_24","GEN","25","24","24","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴰⵔⵓ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⴰⵛⵏⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN25_25","002_25_25","GEN","25","25","25","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⴻⵣⵡⴰⵔ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ, ⵉⵛⴻⵄⵄⴰⵔ ⵇⴰⵄ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵀⵉⴹⵓⵔⵜ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴳⴳⵉⵏ ⴰⵙ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN25_26","002_25_26","GEN","25","26","26","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⴰⵙ. ⵉⵟⵟⴻⴼ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵏⵉⵔⵣ ⵏ ⵄⵉⵙⵓ. ⵙ ⵓⵢⴰ ⵙⴻⵎⵎⴰⵏ ⵜ ⵙ ⵢⵉⵙⴻⵎ ⵢⴰⵄⵇⵓⴱ. ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⵙⵃⴰⵇ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵖⴰⵔ ⵡⴻⵅⵍⴰⵇ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN25_27","002_25_27","GEN","25","27","27","ⵍⴰⵎⵉ ⴳⵎⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵉⴷⵡⴻⵍ ⵄⵉⵙⵓ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⵙⴻⵏ ⴰⵏⴻⵢⵎⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴱⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⴰⵔⵙⴰ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN25_28","002_25_28","GEN","25","28","28","ⵉⵙⵃⴰⵇ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵄⵉⵙⵓ, ⵎⵉⵏⵣⵉ ⵉⵄⵊⴻⴱ ⴰⵙ ⴰⴷ ⵢⴻⵛⵛ ⴰⵢⵙⵓⵎ ⵏ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ, ⵓ ⵔⵉⴼⵇⴰ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵅⵙ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN25_29","002_25_29","GEN","25","29","29","ⵓⵛⴰ ⵉⵙⵙⵏⴻⵏⵏⵉ ⵢⴰⵄⵇⵓⴱ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ, ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵄⵉⵙⵓ ⵣⵉ ⵍⴻⵅⵍⴰ, ⵢⵓⵃⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN25_30","002_25_30","GEN","25","30","30","ⵉⵏⵏⴰ ⵄⵉⵙⵓ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⴰⴷ ⵛⵛⴻⵖ ⵣⴻⴳ ⵓⵣⴻⴳⴳⵯⴰⵖ, ⴰⵣⴻⴳⴳⵯⴰⵖ ⵏⵏⵉ ⴷⵉⵀⴰ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴼⵏⵉⵖ ⵙ ⵓⴼⴰⴷⵉ.” ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵉⴷⵓⵎ’. ");
INSERT INTO rift_vpl VALUES ("GN25_31","002_25_31","GEN","25","31","31","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ: “ⵣⴻⵏⵣ ⴰⵢⵉ ⴰⵙⵙ-ⴰ ⵍⵃⴻⵇⵇ ⵏⵏⴻⵛ ⵏ ⵓⵎⴻⵏⵣⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN25_32","002_25_32","GEN","25","32","32","ⵉⵏⵏⴰ ⵄⵉⵙⵓ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵎⵎⵜⴻⵖ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵙ ⵍⵃⴻⵇⵇ ⵏ ⵓⵎⴻⵏⵣⵓ?” ");
INSERT INTO rift_vpl VALUES ("GN25_33","002_25_33","GEN","25","33","33","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ: “ⵊⴰⴵ ⴰⵢⵉ ⵍⴻⵅⵅⵓ!” ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⴰⵙ, ⵉⵣⵣⴻⵏⵣ ⵉ ⵢⴰⵄⵇⵓⴱ ⵍⵃⴻⵇⵇ ⵏ ⵓⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN25_34","002_25_34","GEN","25","34","34","ⵅⴰⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵄⵉⵙⵓ ⴰⵖⵔⵓⵎ ⴷ ⵓⵎⴻⵛⵍⵉ ⵏ ⵍⴻⵄⴷⴻⵙ, ⵓ ⵄⵉⵙⵓ ⵉⵛⵛⴰ, ⵉⵙⵡⴰ, ⵉⴽⴽⴰⵔ, ⵉⵔⵓⵃ. ⴰⵎⵎⵓ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵄⵉⵙⵓ ⵍⵃⴻⵇⵇ ⵏ ⵓⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN26_1","002_26_1","GEN","26","1","1","ⵜⵓⵖⴰ ⵉⴵⴰ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⵊ ⵏ ⵍⴰⵥ ⵏⵏⴻⵖⵏⵉ ⵅ ⵓⵎⴻⵣⵡⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ⵙ ⵓⵢⴰ ⵉⵔⵓⵃ ⵉⵙⵃⴰⵇ ⵖⴰⵔ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵊⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN26_2","002_26_2","GEN","26","2","2","ⴷⵉⵏⵏⵉ ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵀⴻⴽⴽⵡⵉ ⵛⴰ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("GN26_3","002_26_3","GEN","26","3","3","ⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⵉⵍⵉⵖ, ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ, ⵎⵉⵏⵣⵉ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵓⵎⵉ ⵖⴰ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ-ⵢⴰ ⵓⵛⴰ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵜⵊⴰⴵⵉⵜ ⵉ ⵊⵊⵓⴵⴻⵖ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴱⴰⴱⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN26_4","002_26_4","GEN","26","4","4","ⴰⴷ ⴽⴻⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ-ⵢⴰ. ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⴷⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("GN26_5","002_26_5","GEN","26","5","5","ⵎⵉⵏⵣⵉ ⵉⵙⵍⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵓⵛⴰ ⵉⵃⴹⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵡⵛⵉⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴹⴰ: ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ, ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN26_6","002_26_6","GEN","26","6","6","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵉⵙⵃⴰⵇ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵊⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN26_7","002_26_7","GEN","26","7","7","ⵍⴰⵎⵉ ⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵜⵜⴰⵜ ⴷ ⵓⵞⵎⴰ!”, ⵎⵉⵏⵣⵉ ⵉⴳⴳⵯⴻⴷ ⴰⴷ ⵢⵉⵏⵉ: “ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ!”. ⵎⴰⵖⴰⵔ ⵉⵏⵏⴰ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵏⵏⵉⵖ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵡⴻⵎⵛⴰⵏ-ⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵔⵉⴼⵇⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN26_8","002_26_8","GEN","26","8","8","ⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵣⴷⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵅⵣⴰⵔ-ⴷⴷ ⵣⵉ ⵍⴽⴰⵣⵉ, ⵉⵥⵔⴰ ⵉⵙⵃⴰⵇ ⵉⵜⵜⵄⴰⵜⴰⴱ ⵔⵉⴼⵇⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN26_9","002_26_9","GEN","26","9","9","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵅ ⵉⵙⵃⴰⵇ, ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵜⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ! ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵏⵏⵉⴷ ⴰⵏⴻⵖ ⴷ ⵓⵍⵜⵎⴰ?” ⵉⵙⵃⴰⵇ ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵎⵉⵏⵣⵉ ⵏⵏⵉⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ: ‘ⴰⵇⴰ ⵜⵉⵍⵉ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("GN26_10","002_26_10","GEN","26","10","10","ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉⵏⵏⴰ: “ⵎⴰⵖⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ? ⵅ ⴷⵔⵓⵙ ⴰⴷ ⵢⵉⵍⵉ ⵉⵟⵟⴻⵚ ⵛⴰ ⵏ ⵉⵊⵊ ⵣⵉ ⵍⴳⴻⵏⵙ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴳⴳⵉⴷ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵍⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN26_11","002_26_11","GEN","26","11","11","ⵢⵓⵎⵓⵔ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵔⵢⴰⵣ-ⴰ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN26_12","002_26_12","GEN","26","12","12","ⵉⵣⴰⵔⵄ ⵉⵙⵃⴰⵇ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⵎⵢⴰ ⵏ ⵉⵎⵓⵔⴻⵏ ⵏ ⵣⵣⵢⴰⴷⴰ, ⵎⵉⵏⵣⵉ ⵉⴱⴰⵔⴽ ⵉ-ⵜ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN26_13","002_26_13","GEN","26","13","13","ⵜⴻⵎⵎⴰⵔⵏⵉ ⵛⵛⴻⵏⵄⴻⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵎⴻⵇⵇⴰⵔ, ⴰⵍⴰⵎⵉ ⵜⴻⴷⵡⴻⵍ ⵛⵛⴻⵏⵄⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN26_14","002_26_14","GEN","26","14","14","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵓⴵⵉ ⵓ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⵎⵖⴰⵏ, ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵓⵙⵎⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN26_15","002_26_15","GEN","26","15","15","ⵎⴰⵔⵔⴰ ⴰⵏⵓⵜⴻⵏ ⵏⵏⵉ ⵖⵣⴰⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴱⴰⴱⴰⵙ, ⵏⴻⵜⵢⴻⵏ ⵜⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵛⵛⵓⵔⴻⵏ ⵜⴻⵏ ⵙ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("GN26_16","002_26_16","GEN","26","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉ ⵉⵙⵃⴰⵇ: “ⴱⴻⵄⵄⴻⴷ ⵅⴰⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴷⴻⵡⵍⴻⴷ ⵜⵊⴻⵀⴷⴻⴷ ⵅⴰⵏⴻⵖ ⵙ ⵡⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN26_17","002_26_17","GEN","26","17","17","ⵉⵙⵃⴰⵇ ⵉⵔⵓⵃ ⵙⵙⴻⵏⵏⵉ, ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵊⵉⵔⴰⵔ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN26_18","002_26_18","GEN","26","18","18","ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵙⵃⴰⵇ ⵉⵖⵣⴰ ⴰⵏⵓⵜⴻⵏ ⵏ ⵡⴰⵎⴰⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⵣⵉⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⵉ ⵏⴻⵜⵢⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ⵉⵙⴻⵎⵎⴰ ⵜⴻⵏ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵍⴰⵖⴰ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN26_19","002_26_19","GEN","26","19","19","ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵉⵙⵃⴰⵇ ⵖⵣⴰⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵓⴼⵉⵏ ⴷⵉⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN26_20","002_26_20","GEN","26","20","20","ⵅⴻⵏⵏⵉ ⵇⴰⵛⵃⴻⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵊⵉⵔⴰⵔ ⴰⴽ-ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵉⵙⵃⴰⵇ, ⵏⵏⴰⵏ: “ⴰⵎⴰⵏ ⵏⵏⴻⵖ!” ⵙ ⵓⵢⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵉⵙⴻⵎ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵏⵉ ‘ⵄⵉⵙⵉⵇ’, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⵜⵇⴰⵛⴰⵃⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN26_21","002_26_21","GEN","26","21","21","ⵅⴻⵏⵏⵉ ⵖⵣⴰⵏ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵎⵎⴻⵏⵏⵖⴻⵏ ⵅⴰⵙ ⵄⴰⵡⴻⴷ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵉⵙⴻⵎ ⵏ ‘ⵙⵉⵜⵏⴰ’. ");
INSERT INTO rift_vpl VALUES ("GN26_22","002_26_22","GEN","26","22","22","ⵓⵛⴰ ⵉⴱⴻⵄⵄⴻⴷ ⵙⵙⴻⵏⵏⵉ, ⵉⵖⵣⴰ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵅⴰⵙ ⵇⵉⵛⵃⴻⵏ ⵛⴰ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ‘ⵔⴰⵃⵓⴱⵓⵜ’, ⵉⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⵜⴰⵙⵉⵄ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵍⵉ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN26_23","002_26_23","GEN","26","23","23","ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GN26_24","002_26_24","GEN","26","24","24","ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵙⵉⴷⵉ ⴷⵉ ⴵⵉⵔⴻⵜ ⵏⵏⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴱⴰⴱⴰⵛ! ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ, ⴰⴷ ⴽⴻⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵉⴱⵔⴰⵀⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN26_25","002_26_25","GEN","26","25","25","ⵅⴻⵏⵏⵉ ⵉⴱⵏⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵎⵉⵏ ⵅⴻⴼ ⵉⴳⴳⴰ ⵜⴰⵖⴰⵔⵚⵜ, ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵉⵡⵜⴰ ⴷⵉⵏ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵖⵣⵉⵏ ⴷⵉⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵉⵙⵃⴰⵇ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN26_26","002_26_26","GEN","26","26","26","ⴰⴱⵉⵎⴰⵍⵉⴽ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵣⵉ ⵊⵉⵔⴰⵔ, ⴰⴽ-ⴷ ⴰⵃⵓⵣⵣⴰⵜ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⴷ ⴼⵉⴽⵓⵍ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN26_27","002_26_27","GEN","26","27","27","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵙⵃⴰⵇ: “ⵎⴰⵖⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵓⵙⵉⵎ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵛⴰⵔⵔⵀⴻⵎ ⴰⵢⵉ ⵓⵛⴰ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⴰⵢⵉ ⵅⴰⵡⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("GN26_28","002_26_28","GEN","26","28","28","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⴽ. ⵙ ⵓⵢⴰ ⵏⴻⵏⵏⴰ, ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⴻⵅⵅⵓ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵊⴰⵔⴰⵏⴻⵖ, ⵊⴰⵔⴰⵏⴻⵖ ⴷ ⵛⴻⴽ, ⵓⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⴽⵉⴽ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ");
INSERT INTO rift_vpl VALUES ("GN26_29","002_26_29","GEN","26","29","29","ⵃⵉⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵍⵖⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵛⴻⴽ ⵏⵃⵉⴷⵉ ⵛⴰ ⵓⵛⴰ ⴰⵇⴰ ⵏⴻⵎⵚⵓⵔⵔⴻⴼ ⴰⴽⵉⴷⴻⴽ ⵎⵍⵉⵃ ⵓⵛⴰ ⵏⴻⵙⵙⴻⴽⴽ ⵉ ⵛⴻⴽ ⴷⵉ ⵍⴰⵎⴰⵏ. ⴰⵇⴰ ⵛⴻⴽ ⵍⴻⵅⵅⵓ ⴷ ⴰⵎⵉⵎⵓⵏ ⵏ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN26_30","002_26_30","GEN","26","30","30","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵓⵛⴰ ⵛⵛⵉⵏ, ⵙⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN26_31","002_26_31","GEN","26","31","31","ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ ⵓⵛⴰ ⵊⵊⵓⴵⴻⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵉ-ⵜⴻⵏ ⵉⵙⵃⴰⵇ ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵖⴰⵔⴻⵙ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN26_32","002_26_32","GEN","26","32","32","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷ ⵉⵊⵊ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵉⵙⵃⴰⵇ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜ ⵅ ⵡⴰⵏⵓ ⵉ ⵉⵖⵣⴰⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: “ⴷ ⴰⵎⴰⵏ ⵉ ⵏⵓⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN26_33","002_26_33","GEN","26","33","33","ⵉⵙⴻⵎⵎⴰ ⴰⵏⵓ-ⵢⴰ ⵙⴻⴱⵄⴰ. ⵅ ⵓⵢⴰ ⵉ ⵉⴵⴰ ⵢⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN26_34","002_26_34","GEN","26","34","34","ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵄⵉⵙⵓ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵢⵉⵡⵉ ⵢⵓⴷⵉⵜ, ⵢⴻⴵⵉⵙ ⵏ ⴱⵉⵔⵉ, ⴰⵃⵉⵜⵜⵉ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵓⵍⴰ ⴷ ⴱⴰⵙⵎⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵍⵓⵏ, ⴰⵃⵉⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("GN26_35","002_26_35","GEN","26","35","35","ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⴰⵔⵣⵓⴳⵉ ⵏ ⵡⵓⵍ ⵉ ⵉⵙⵃⴰⵇ ⴷ ⵔⵉⴼⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("GN27_1","002_27_1","GEN","27","1","1","ⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵉⵙⵃⴰⵇ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵄⴻⵎⵛⴻⵏⵜ ⴰⵍⴰⵎⵉ ⵄⵍⴰⵃⴰⵍ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ, ⵉⵍⴰⵖⴰ ⵄⵉⵙⵓ, ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵎⵉ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN27_2","002_27_2","GEN","27","2","2","ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⵙⴰⵔⴻⵖ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴰⵙⵙ ⵉ ⴷⵉ ⵖⴰ ⵎⵎⵜⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN27_3","002_27_3","GEN","27","3","3","ⵍⴻⵅⵅⵓ, ⴽⵙⵉ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵛ ⴷ ⵡⴻⵇⵔⴰⴱ ⵏⵏⴻⵛ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⴷ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ, ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⴳⵎⴰⵔ ⴰⵢⵉ-ⴷⴷ ⵜⴰⵢⵎⴰⵔⵜ ⵉ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN27_4","002_27_4","GEN","27","4","4","ⵙⴻⵡⵊⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ ⵉⵛⵏⴰⵏ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵄⴻⵊⴱⴻⵏ ⵓⵛⴰ ⵜⴻⵡⵛⴻⴷ ⴰⵢⵉ ⵜⵜ-ⵉ-ⴷⴷ, ⴰⴷ ⵜⵜ ⵛⵛⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵎⵎⵜⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN27_5","002_27_5","GEN","27","5","5","ⵔⵉⴼⵇⴰ ⵜⵓⵖⴰ ⵜⴻⵙⵍⴰ ⵓⵎⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵙⵃⴰⵇ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵄⵉⵙⵓ. ⵓⵛⴰ ⵉⵔⵓⵃ ⵄⵉⵙⵓ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵢⵎⴰⵔ ⵜⵉⵎⴻⵢⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵢⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("GN27_6","002_27_6","GEN","27","6","6","ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵔⵉⴼⵇⴰ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ ⵎⵎⵉⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⴱⴰⴱⴰⵛ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵄⵉⵙⵓ ⵓⵎⴰⵛ, ⵉⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("GN27_7","002_27_7","GEN","27","7","7","‘ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵢⵎⴰⵔⵜ ⵓⵛⴰ ⵙⴻⵡⵊⴻⴷ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ ⵍⴻⵎⵍⵉⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵛⵛⴻⵖ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴱⴰⵔⴽⴻⵖ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵎⵎⵜⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("GN27_8","002_27_8","GEN","27","8","8","ⵍⴻⵅⵅⵓ, ⵎⵎⵉ, ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ ⵎⵉⵏ ⵣⵉ ⵛⴻⴽ ⵖⴰ ⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN27_9","002_27_9","GEN","27","9","9","ⵍⵓⵀ ⵖⴰⵔ ⵜⵃⵉⵎⴰⵔⵜ ⵓⵛⴰ ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ ⵉⵛⵏⴰⵏ ⵉ ⴱⴰⴱⴰⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵜⵜⴰⵄⵊⵉⴱ ");
INSERT INTO rift_vpl VALUES ("GN27_10","002_27_10","GEN","27","10","10","ⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⴰⴷ ⵜ ⵜⴰⵡⵢⴻⴷ ⵉ ⴱⴰⴱⴰⵛ, ⴰⴷ ⵢⴻⵛⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵇⴱⴻⵍ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN27_11","002_27_11","GEN","27","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵔⵉⴼⵇⴰ, ⵢⴻⵎⵎⴰⵙ: “ⵅⵣⴰⵔ, ⵄⵉⵙⵓ ⵓⵎⴰ ⴷ ⴰⵔⵢⴰⵣ ⴱⵓ-ⵛⵄⴰⵔ ⵓ ⵏⴻⵛⵛ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⴰⵍⴻⵇⵇⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("GN27_12","002_27_12","GEN","27","12","12","ⴱⴰⵍⴰⴽ ⴰⴷ ⴰⵢⵉ ⵉⵃⴰⴷⴰ ⴱⴰⴱⴰ ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵖ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵖⴻⵛⵛⴰⵛ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵙⵉⵖ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵅⴰⴼⵉ, ⵡⴰⵔ ⴽⴻⵙⵙⵉⵖ ⵍⴱⴰⵔⴰⴽⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN27_13","002_27_13","GEN","27","13","13","ⵢⴻⵎⵎⴰⵙ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⵅⴰⴼⵉ, ⴰ ⵎⵎⵉ! ⵟⴰⵄ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵡⴰⵀⴰ, ⴰⵡⵢⵉ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN27_14","002_27_14","GEN","27","14","14","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵔⵓⵃ, ⵉⴽⵙⵉ ⵜⴻⵏ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵉ ⵢⴻⵎⵎⴰⵙ. ⵓⵛⴰ ⵢⴻⵎⵎⴰⵙ ⵜⴻⴳⴳⴰ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ ⵉⵛⵏⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵜⵜⴰⵄⵊⵉⴱ ⵉ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN27_15","002_27_15","GEN","27","15","15","ⵜⴻⴽⵙⵉ ⵔⵉⴼⵇⴰ ⴰⵔⵔⵓⴹ ⵉⴼⴻⵛⵛⵃⴻⵏ ⴰⵟⵟⴰⵙ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵄⵉⵙⵓ, ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ, ⵓⵛⴰ ⵜⴰⵔⴹ ⵉ-ⵜ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ. ");
INSERT INTO rift_vpl VALUES ("GN27_16","002_27_16","GEN","27","16","16","ⵜⴻⴳⴳⴰ ⴰⵙ ⵉⵍⴻⵎ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ ⴰⵍⴻⵇⵇⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("GN27_17","002_27_17","GEN","27","17","17","ⵜⴻⵡⵛⴰ ⵎⴰⵛⵛⴰ-ⵢⴰ ⵉⵛⵏⴰⵏ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⵏⵏⵉ ⵜⴻⵏⴳⴳⵯⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⵎⵉⵙ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN27_18","002_27_18","GEN","27","18","18","ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ!” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ! ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰ ⵎⵎⵉ?” ");
INSERT INTO rift_vpl VALUES ("GN27_19","002_27_19","GEN","27","19","19","ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⴱⴰⴱⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵄⵉⵙⵓ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵛ. ⴳⴳⵉⵖ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ. ⴽⴽⴰⵔ ⵍⴻⵅⵅⵓ, ⵇⵇⵉⵎ, ⴻⵛⵛ ⵣⵉ ⵜⵎⴻⵢⵔⴰ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⴱⴰⵔⴻⴽ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN27_20","002_27_20","GEN","27","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵙⵃⴰⵇ ⵉ ⵎⵎⵉⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⵓⴼⵉⴷ ⵜⵜ ⴷⴻⵖⵢⴰ, ⴰ ⵎⵎⵉ?” ⵉⵏⵏⴰ: “ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN27_21","002_27_21","GEN","27","21","21","ⵉⵙⵃⴰⵇ ⵉⵏⵏⴰ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵍⴻⵅⵅⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵃⴰⴷⵉⵖ, ⴰ ⵎⵎⵉ, ⵎⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉ ⵄⵉⵙⵓ ⵏⵉⵖ ⵍⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN27_22","002_27_22","GEN","27","22","22","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⴱⴰⴱⴰⵙ ⵉⵙⵃⴰⵇ, ⵉⵃⴰⴷⴰ ⵜ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵜⵎⵉⵊⵊⴰ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵎⴰⵛⴰ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵄⵉⵙⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN27_23","002_27_23","GEN","27","23","23","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜ ⵉⵄⵇⵉⵍ, ⵎⵉⵏⵣⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵛⴻⵄⵄⴰⵔⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵄⵉⵙⵓ ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN27_24","002_27_24","GEN","27","24","24","ⵉⵏⵏⴰ: “ⵎⴰ ⴷ ⵛⴻⴽ ⴷ ⵎⵎⵉ ⵄⵉⵙⵓ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN27_25","002_27_25","GEN","27","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵙⵇⴰⵔⵔⴻⴱ ⴰⵢⵉ ⵜⵜ-ⵉ-ⴷⴷ ⵣⵣⴰⵜⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵖ ⵣⵉ ⵜⵎⴻⵢⵔⴰ ⵏ ⵎⵎⵉ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ.” ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ ⵣⵣⴰⵜⴻⵙ ⵓⵛⴰ ⵉⵛⵛⴰ. ⵢⵉⵡⵉ ⴰⵙ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴱⵉⵏⵓ ⵓⵛⴰ ⵉⵙⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("GN27_26","002_27_26","GEN","27","26","26","ⵉⵏⵏⴰ ⴰⵙ ⴱⴰⴱⴰⵙ ⵉⵙⵃⴰⵇ: “ⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵉ ⵍⴻⵅⵅⵓ, ⵙⵓⴷⴻⵎ ⴰⵢⵉ, ⴰ ⵎⵎⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN27_27","002_27_27","GEN","27","27","27","ⵓⵛⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ⵉⵛⴻⵎⵎ ⵉⵙⵃⴰⵇ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵎⵎⵉ ⴰⵎ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN27_28","002_27_28","GEN","27","28","28","ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵣⵉ ⵍⴻⵢⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN27_29","002_27_29","GEN","27","29","29","ⴰⴷ ⴰⵛ ⵅⴻⴷⵎⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵛⵛⵓⵄⵓⴱ ⴰⴷ ⴰⵛ ⴱⴻⵏⴷⵇⴻⵏ. ⵃⴽⴻⵎ ⵅ ⴰⵢⵜⵎⴰⵛ ⵓ ⴻⵊⵊ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴻⵎⵎⴰⵛ ⴰⴷ ⴰⵛ ⴱⴻⵏⴷⵇⴻⵏ! ⵉⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵏⴻⵄⵍⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏ, ⵓ ⵉⵏⵏⵉ ⵛⴻⴽ ⵖⴰ ⵉⴱⴰⵔⴽⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN27_30","002_27_30","GEN","27","30","30","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵉⵙⵃⴰⵇ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⴰⵎ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵢⴰⵄⵇⵓⴱ ⵄⴰⴷ ⵅ ⴱⴰⴱⴰⵙ ⵉⵙⵃⴰⵇ, ⵉⵄⵇⴻⴱ-ⴷⴷ ⵄⵉⵙⵓ, ⵓⵎⴰⵙ, ⵣⵉ ⵜⴻⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN27_31","002_27_31","GEN","27","31","31","ⵉⵙⵙⴻⵡⵊⴻⴷ ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ ⵉⵛⵏⴰⵏ ⵓⵛⴰ ⵉⴽⵙⵉ ⵜⵜ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴱⴰⴱⴰ, ⴽⴽⴰⵔ ⵜⴻⵛⵛⴻⴷ ⵣⵉ ⵜⴻⵢⵎⴰⵔⵜ ⵏ ⵎⵎⵉⵛ, ⵃⵉⵎⴰ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴱⴰⵔⴽⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN27_32","002_27_32","GEN","27","32","32","ⵉⵏⵏⴰ ⴰⵙ ⵉⵙⵃⴰⵇ, ⴱⴰⴱⴰⵙ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⵎⵎⵉⵛ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵛ, ⵄⵉⵙⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN27_33","002_27_33","GEN","27","33","33","ⵓⵛⴰ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵉⵙⵃⴰⵇ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⴰ, ⵉⵟⵟⴻⴼ ⵜⴰⵢⵎⴰⵔⵜ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⵢⵉ ⵜⵜ-ⵉ-ⴷⴷ? ⵛⵛⵉⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵇⴱⴻⵍ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵓⵛⴰ ⵏⴻⵛⵛ ⴱⴰⵔⴽⴻⵖ ⵜ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN27_34","002_27_34","GEN","27","34","34","ⵓⵎⵉ ⵉⵙⵍⴰ ⵄⵉⵙⵓ ⴰⵡⴰⵍⴻⵏ ⵏ ⴱⴰⴱⴰⵙ, ⵉⵙⵖⵓⵢ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⵢⴰⴷ ⵉⵊⵀⴻⴷ ⵢⴰⵔⵣⴻⴳ, ⵉⵏⵏⴰ ⵉ ⴱⴰⴱⴰⵙ: “ⴱⴰⵔⴻⴽ ⴰⵢⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⴰ ⴱⴰⴱⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN27_35","002_27_35","GEN","27","35","35","ⵉⵏⵏⴰ: “ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⴰⵛ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ, ⵉⴽⵙⵉ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN27_36","002_27_36","GEN","27","36","36","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵙ ⵍⵃⴻⵇⵇ ⵢⴰⵄⵇⵓⴱ? ⴰⵇⴰ ⵉⵛⵎⴻⵜ ⴰⵢⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ⵉⴽⵙⵉ ⵍⵃⴻⵇⵇ ⵏ ⵓⵎⴻⵏⵣⵓ ⵉⵏⵓ ⵓⵛⴰ ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵉⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵉⵏⵓ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜⴻⵇⵇⵉⵎ ⵛⴰ ⵏ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("GN27_37","002_27_37","GEN","27","37","37","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵙⵃⴰⵇ, ⵉⵏⵏⴰ ⵉ ⵄⵉⵙⵓ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅⴰⴽ ⵓⵛⴰ ⵡⵛⵉⵖ ⴰⵙ ⴰⵢⵜⵎⴰⵙ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵓⵍⴰ ⵙ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵄⴻⵡⵡⵍⴻⵖ ⵜ. ⵎⵉⵏ ⴷⵉⵏ ⵄⴰⴷ, ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵍⴻⵅⵅⵓ, ⴰ ⵎⵎⵉ?” ");
INSERT INTO rift_vpl VALUES ("GN27_38","002_27_38","GEN","27","38","38","ⵉⵏⵏⴰ ⵄⵉⵙⵓ ⵉ ⴱⴰⴱⴰⵙ: “ⵎⴰ ⵖⴰⵔⴻⴽ ⵎⵖⵉⵔ ⵍⴱⴰⵔⴰⴽⴰ-ⵢⴰ ⵡⴰⵀⴰ, ⴰ ⴱⴰⴱⴰ? ⴱⴰⵔⴻⴽ ⴰⵢⵉ ⵄⴰⵡⴻⴷ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⴰ ⴱⴰⴱⴰ!” ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵄⵉⵙⵓ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵉⵙⵖⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("GN27_39","002_27_39","GEN","27","39","39","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵙⵃⴰⵇ ⵅ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵉⴳⴳⵯⴻⵊⵊⴻⵏ ⵅ ⵍⴻⵢⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵅ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("GN27_40","002_27_40","GEN","27","40","40","ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵛ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ ⵓ ⴰⴷ ⵜⵅⴻⴷⵎⴻⴷ ⵉ ⵓⵎⴰⵛ. ⵎⴰⵛⴰ ⵅⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣⴻⴷ, ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⴷ ⵜⴰⵡⴹⴻⴷ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵣⴰⵢⵍⵓ ⵏⵏⴻⵙ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN27_41","002_27_41","GEN","27","41","41","ⵓⵛⴰ ⵉⵛⴰⵔⵀ ⵄⵉⵙⵓ ⵢⴰⵄⵇⵓⴱ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵣⵉ ⵜ ⵉⴱⴰⵔⴻⴽ ⴱⴰⴱⴰⵙ, ⵓⵛⴰ ⵉⵏⵏⴰ ⵄⵉⵙⵓ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⴰⴷ ⴰⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵄⴻⵣⵣⵉ ⵏ ⴱⴰⴱⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵖⴻⵖ ⵓⵎⴰ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("GN27_42","002_27_42","GEN","27","42","42","ⵓⵎⵉ ⵏⵏⴰⵏ ⵉ ⵔⵉⴼⵇⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵄⵉⵙⵓ, ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ, ⵜᵉⵙⵙⴻⴽⴽ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵄⵉⵙⵓ ⵓⵎⴰⵛ ⵢⴰⵔⴻⵣⵣⵓ ⵎⴰⵎⵎⴻⵛ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵉⵅⵍⴻⴼ, ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN27_43","002_27_43","GEN","27","43","43","ⵍⴻⵅⵅⵓ, ⴰ ⵎⵎⵉ, ⵟⴰⵄ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ. ⴽⴽⴰⵔ ⵓⵛⴰ ⵜⴰⵔⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵃⴰⵔⴰⵏ ⵖⴰⵔ ⵓⵎⴰ ⵍⴰⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN27_44","002_27_44","GEN","27","44","44","ⵣⴷⴻⵖ ⴰⴽⵉⴷⴻⵙ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍ ⵖⴰ ⵢⴰⵔⵙⴰ ⵡⴻⵙⵄⴰⵔ ⵏ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN27_45","002_27_45","GEN","27","45","45","ⵅⵎⵉ ⵖⴰ ⵉⵅⵙⵉ ⵓⵅⴻⵢⵢⴻⵇ ⵏ ⵓⵎⴰⵛ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵓ ⵎⵉⵏ ⴷ ⴰⵙ ⵜⴻⴳⴳⵉⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵢⴰⵡⵉ ⵙⵙⴻⵏⵏⵉ. ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵖⴰ ⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵖ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵡⴻⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ?” ");
INSERT INTO rift_vpl VALUES ("GN27_46","002_27_46","GEN","27","46","46","ⵜⴻⵏⵏⴰ ⵔⵉⴼⵇⴰ ⵉ ⵉⵙⵃⴰⵇ: “ⵛⴰⵔⵔⵀⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵃⵉⵜ. ⵎⴰⵍⴰ ⵢⴰⵄⵇⵓⴱ ⵢⵉⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵜⴻⴱⵍⵉⵖⵉⵏ ⵏ ⵃⵉⵜ, ⴰⵎ ⵜⵏⴰⵢⴻⵏ-ⴰ, ⵣⵉ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵎⴰⵏ ⵍⵇⵉⵎⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("GN28_1","002_28_1","GEN","28","1","1","ⵉⵍⴰⵖⴰ ⵉⵙⵃⴰⵇ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵜⵜⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN28_2","002_28_2","GEN","28","2","2","ⴽⴽⴰⵔ, ⵔⵓⵃ ⵖⴰⵔ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵉⵜⵓⵡⵉⵍ, ⴱⴰⴱⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵛ, ⵓⵛⴰ ⴰⵡⵉ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵛⴻⴽ ⵣⴻⴳ ⵢⴻⵙⵙⵉⵙ ⵏ ⵍⴰⴱⴰⵏ, ⵓⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN28_3","002_28_3","GEN","28","3","3","ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵓ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵉⴽⴻⵜⵜⴰⵔ ⴰⵍ ⵖⴰ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("GN28_4","002_28_4","GEN","28","4","4","ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵔⵜⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵜⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN28_5","002_28_5","GEN","28","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵙⵃⴰⵇ ⵢⴰⵄⵇⵓⴱ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵔⵓⵃ ⵖⴰⵔ ⴼⴰⴷⴷⴰⵏ-ⴰⵔⴰⵎ, ⵖⴰⵔ ⵍⴰⴱⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴱⵉⵜⵓⵡⵉⵍ, ⴰⵔⴰⵎⵉⵢⵓ, ⵓⵎⴰⵙ ⵏ ⵔⵉⴼⵇⴰ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN28_6","002_28_6","GEN","28","6","6","ⵓⵎⵉ ⵉⵥⵔⴰ ⵄⵉⵙⵓ ⴱⴻⵍⵍⵉ ⵉⵙⵃⴰⵇ ⵉⴱⴰⵔⴻⴽ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⴼⴰⴷⴷⴰⵏ-ⴰⵔⴰⵎ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵡⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵙⵙⴻⵏⵏⵉ, ⵓ ⵍⴰⵎⵉ ⵜ ⵉⴱⴰⵔⴻⴽ, ⵢⵓⵎⵓⵔ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⴽⴻⵙⵙⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵣⴻⴳ ⵢⴻⵙⵙⵉⵙ ⵏ ⴽⴻⵏⵄⴰⵏ!”, ");
INSERT INTO rift_vpl VALUES ("GN28_7","002_28_7","GEN","28","7","7","ⵓⵛⴰ ⵉⵥⵔⴰ ⵄⴰⵡⴻⴷ ⴱⴻⵍⵍⵉ ⵢⴰⵄⵇⵓⴱ ⵉⵟⴰⵄ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⵉⵔⵓⵃ ⵖⴰⵔ ⴼⴰⴷⴷⴰⵏ-ⴰⵔⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("GN28_8","002_28_8","GEN","28","8","8","ⵅⴻⵏⵏⵉ ⵉⵜⵡⴰⵍⴰ ⵄⵉⵙⵓ ⴱⴻⵍⵍⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴱⴰⴱⴰⵙ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GN28_9","002_28_9","GEN","28","9","9","ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵄⵉⵙⵓ ⵖⴰⵔ ⵉⵙⵎⴰⵄⵉⵍ ⵓⵛⴰ ⵢⵉⵡⵉ ⵎⴰⵃⴰⵍⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵢⴰⵔⵏⵉ ⵜⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵏⴰⴱⴰⵢⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN28_10","002_28_10","GEN","28","10","10","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵢⴰⵄⵇⵓⴱ ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵃⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN28_11","002_28_11","GEN","28","11","11","ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵢⴻⵏⵙⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴰⴼⵓⵛⵜ ⵜⴻⵖⵔⵉ. ⵉⴽⵙⵉ ⵣⴻⴳ ⵢⴻⵥⵔⴰ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⴹⴰ ⵉⵟⵟⴻⵚ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN28_12","002_28_12","GEN","28","12","12","ⵢⵓⵔⵊⴰ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⴷⴷⵔⵓⵊ ⵉⴱⴻⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵜⵜⵃⴰⴷⴰ ⵉⵅⴻⴼ ⵏ ⴷⴷⵔⵓⵊ ⴰⵊⴻⵏⵏⴰ, ⵓ ⵅⵣⴰⵔ, ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵜⴰⵍⵢⴻⵏⵜ ⵀⴻⴽⴽⵡⴰⵏⵜ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN28_13","002_28_13","GEN","28","13","13","ⵓ ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ ⵉⴱⵔⴰⵀⵉⵎ, ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ. ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵅⴻⴼ ⵜᵉⵟⵟⵚⴻⴷ ⴰⴷ ⴰⵛ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN28_14","002_28_14","GEN","28","14","14","ⴰⴷ ⵜⵉⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵎ ⵓⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵉⵔⵉⵡⴻⴷ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⴷ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴷ ⵍⵊⴰⵏⵓⴱ. ⴷⴰⵢⴻⴽ ⵓ ⴷⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN28_15","002_28_15","GEN","28","15","15","ⴰⵇⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵃⴹⵉⵖ ⵇⴰⵄ ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ, ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ ⴰⵍ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵖ ⵎⵉⵏ ⴷ ⴰⵛ ⵏⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN28_16","002_28_16","GEN","28","16","16","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴰⵇ ⵢⴰⵄⵇⵓⴱ ⵣⴻⴳ ⵢⵉⴹⴻⵚ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("GN28_17","002_28_17","GEN","28","17","17","ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ, ⵉⵏⵏⴰ: “ⵎⴻⵛⵃⴰⵍ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⵡⴻⵎⵛⴰⵏ-ⴰ! ⴰⵇⴰ ⵜⴰ ⵎⵖⵉⵔ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵜⴰⵏⵉⵜⴰ ⴷ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⵏⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN28_18","002_28_18","GEN","28","18","18","ⵉⴽⴽⴰⵔ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⵥⵔⵓ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵙ ⵙⴰⴷⵓ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵓⵛⴰ ⵉⴼⴰⵔⵔⴻⵖ ⵣⵣⴻⵛⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("GN28_19","002_28_19","GEN","28","19","19","ⵉⴳⴳⴰ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵎⴰⵛⴰ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⵉⵙⴻⵎ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵍⵓⵣ. ");
INSERT INTO rift_vpl VALUES ("GN28_20","002_28_20","GEN","28","20","20","ⵓⵛⴰ ⵉⵡⴰⵄⴷ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵉⵃⴹⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ, ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴰⵖⵔⵓⵎ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵖ, ⴷ ⵡⴰⵔⵔⵓⴹ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴹⴻⵖ ");
INSERT INTO rift_vpl VALUES ("GN28_21","002_28_21","GEN","28","21","21","ⵓ ⵎⴰⵍⴰ ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("GN28_22","002_28_22","GEN","28","22","22","ⵓⵛ ⴰⵥⵔⵓ-ⵢⴰ ⵉ ⴳⴳⵉⵖ ⴷ ⴰⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⴻⵡⵛⴻⴷ, ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵍⴻⵄⵛⵓⵔ!” ");
INSERT INTO rift_vpl VALUES ("GN29_1","002_29_1","GEN","29","1","1","ⵉⴽⵙⵉ ⵢⴰⵄⵇⵓⴱ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("GN29_2","002_29_2","GEN","29","2","2","ⵉⵅⵣⴰⵔ ⵓⵛⴰ ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵡⵓⴵⵉ ⵊⵏⵉⵏⵜ ⵣⵣⴰⵜⴻⵙ, ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵡⴰⵏⵓ ⵏⵏⵉ ⵡⴰⵔⵔⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN29_3","002_29_3","GEN","29","3","3","ⵙⵙⵎⵓⵏⴻⵏ ⴷⵉⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ. ⵅⴰⵙ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⴰⵥⵔⵓ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵏⵓ ⵓⵛⴰ ⵡⴰⵔⴷⴻⵏ ⵓⴵⵉ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⵔⵔⵉⵏ ⴰⵥⵔⵓ ⵄⴰⵡⴻⴷ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN29_4","002_29_4","GEN","29","4","4","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵄⵇⵓⴱ: “ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵎⴰⵏⵉⵙ ⴽⴻⵏⵏⵉⵡ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ: “ⵣⵉ ⵃⴰⵔⴰⵏ ⵉ ⵏⴻⴵⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN29_5","002_29_5","GEN","29","5","5","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵍⴰⴱⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⵓⵔ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ: “ⵡⴰⵀ, ⵏⴻⵙⵙⴻⵏ ⵉ-ⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN29_6","002_29_6","GEN","29","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵏⴻⵜⵜⴰ: “ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ?” ⴰⵔⵔⵉⵏ-ⴷⴷ: “ⴰⵇⴰ-ⵜ ⵎⵍⵉⵃ, ⴰⵇⴰ ⴷⴰ ⵢⴻⴵⵉⵙ ⵔⴰⵃⵉⵍ ⵜⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵡⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN29_7","002_29_7","GEN","29","7","7","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⴷⴰ ⴰⵣⵉⵍ ⵄⴰⴷ ⵉⵎⵖⴰⵔ, ⵡⴰⵔ ⵢⴻⴵⵉ ⴱⵓ ⵍⵡⴻⵇⵜ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵏⴷⴻⵀ ⵍⴻⴱⵀⴰⵢⴻⵎ. ⵡⴰⵔⴷⴻⵎ ⵓⴵⵉ ⵓⵛⴰ ⵔⵓⵃⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⴻⵡⵙⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN29_8","002_29_8","GEN","29","8","8","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ: “ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⴳⴳ ⴰⵍ ⴷⴷ ⵖⴰ ⵎⵓⵏⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⵃⵍⵓⴵⴷⴻⵏ ⴰⵥⵔⵓ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵡⴰⵔⴻⴷ ⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN29_9","002_29_9","GEN","29","9","9","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵜⵓⵙⴰ-ⴷⴷ ⵔⴰⵃⵉⵍ ⵙ ⵡⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵎⴻⴽⵙⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("GN29_10","002_29_10","GEN","29","10","10","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵄⵇⵓⴱ ⵔⴰⵃⵉⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵍⴰⴱⴰⵏ, ⵓⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⴰⴽ-ⴷ ⵡⵓⴵⵉ ⵏ ⵍⴰⴱⴰⵏ, ⵓⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵉⵅⴻⵛⵛ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⵙⵙⴻⵃⵍⵓⴵⴻⴷ ⴰⵥⵔⵓ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵏⵓ, ⵉⵡⴰⵔⴷ ⵓⴵⵉ ⵏ ⵍⴰⴱⴰⵏ, ⵓⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN29_11","002_29_11","GEN","29","11","11","ⵉⵙⵙⵓⴷⴻⵎ ⵢⴰⵄⵇⵓⴱ ⵔⴰⵃⵉⵍ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵖⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("GN29_12","002_29_12","GEN","29","12","12","ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵔⴰⵃⵉⵍ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⵍⴰⴵ ⵏ ⴱⴰⴱⴰⵙ ⵉ ⵉⴵⴰ, ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵔⵉⴼⵇⴰ. ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵣⵣⴻⵍ, ⵜⵅⴻⴱⴱⴰⵔ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN29_13","002_29_13","GEN","29","13","13","ⵓⵎⵉ ⵉⵙⵍⴰ ⵍⴰⴱⴰⵏ ⵍⴻⵅⴱⴰⵔ ⵅ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵓⵍⵜⵎⴰⵙ, ⵢⵓⵣⵣⴻⵍ ⴰⴷ ⵜ ⵉⵍⵇⴰ ⵓⵛⴰ ⵉⴷⴰⵔⵔⴻⵄ ⴰⵙ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ, ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⵍⴰⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN29_14","002_29_14","GEN","29","14","14","ⵉⵏⵏⴰ ⴰⵙ ⵍⴰⴱⴰⵏ: “ⴷ ⵜⵉⴷⴻⵜⵜ ⵛⴻⴽ ⴷ ⵉⵖⴻⵙ ⵉⵏⵓ ⴷ ⴰⵢⵙⵓⵎ ⵉⵏⵓ ⵉ ⵜⴻⴵⵉⴷ.” ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔⴻⵙ ⵍⵇⴻⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN29_15","002_29_15","GEN","29","15","15","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴰⴱⴰⵏ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵓⵎⵉ ⵛⴻⴽ ⴷ ⵓⵎⴰ ⵉ ⵜⴻⴵⵉⴷ, ⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵜⵅⴻⴷⵎⴻⴷ ⴱⴰⵟⴻⵍ? ⵉⵏⵉ ⴰⵢⵉ ⵎⵉⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("GN29_16","002_29_16","GEN","29","16","16","ⵍⴰⴱⴰⵏ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ. ⵉⵙⴻⵎ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⴷ ⵍⵉⵢⴰ ⵓ ⵉⵙⴻⵎ ⵏ ⵜⵎⴰⵥⵓⵥⵜ, ⵔⴰⵃⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN29_17","002_29_17","GEN","29","17","17","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⵉⵢⴰ ⵜⵓⵖⴰ ⴽⴻⵛⵄⴻⵏⵜ, ⵎⴰⵛⴰ ⵔⴰⵃⵉⵍ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵥⵍⵉ ⵏ ⵡⴰⴷⴷⵓⴷ ⵓ ⵏ ⵍⵅⴻⵣⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GN29_18","002_29_18","GEN","29","18","18","ⵢⴰⵄⵇⵓⴱ ⵉⵅⵙ ⵔⴰⵃⵉⵍ. ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⴽ ⵅⴻⴷⵎⴻⵖ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵔⴰⵃⵉⵍ ⵢⴻⴵⵉⵙ ⵜⵎⴰⵥⵓⵥⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN29_19","002_29_19","GEN","29","19","19","ⵍⴰⴱⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵅⴰⵔ ⴰⴷ ⴰⵛ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵛⴻⴽ ⵏⵉⵖ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ. ⵇⵇⵉⵎ ⴰⴽⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN29_20","002_29_20","GEN","29","20","20","ⴰⵎⵎⵓ ⵉ ⵉⵅⴷⴻⵎ ⵢⴰⵄⵇⵓⴱ ⵅ ⵔⴰⵃⵉⵍ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵎⴰⵛⴰ ⴹⵀⴰⵔⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("GN29_21","002_29_21","GEN","29","21","21","ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵍⴰⴱⴰⵏ: “ⴻⵡⵛ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵎⵉⵊⴰⵍ ⵉⵏⵓ, ⴰⵍⴰⵎⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN29_22","002_29_22","GEN","29","22","22","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⵍⴰⴱⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⵉⴳⴳⴰ ⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN29_23","002_29_23","GEN","29","23","23","ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵉⴽⵙⵉ ⵢⴻⴵⵉⵙ ⵍⵉⵢⴰ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵉ-ⵜⵜ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵅⴰⵙ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN29_24","002_29_24","GEN","29","24","24","ⵉⵡⵛⴰ ⵍⴰⴱⴰⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵣⵉⵍⴱⴰ ⵉ ⵢⴻⴵⵉⵙ ⵍⵉⵢⴰ ⴷ ⵜⴰⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN29_25","002_29_25","GEN","29","25","25","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵥⵔⴰ ⵢⴰⵄⵇⵓⴱ ⴱⴻⵍⵍⵉ ⴷ ⵍⵉⵢⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵍⴰⴱⴰⵏ: “ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ? ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵅⴷⵉⵎⴻⵖ ⵅ ⵔⴰⵃⵉⵍ? ⵎⴰⵖⴰⵔ ⴷ ⴰⵢⵉ ⵜⵛⴻⵎⵜⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("GN29_26","002_29_26","GEN","29","26","26","ⵍⴰⴱⴰⵏ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵢⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⵉⵣⵣⴰⵔ ⵜⴰⵎⴰⵥⵓⵥⵜ ⵅ ⵜⵎⴻⵏⵣⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN29_27","002_29_27","GEN","29","27","27","ⴽⴻⵎⵎⴻⵍ ⵙⵙⵉⵎⴰⵏⴰ-ⵢⴰ ⵏ ⵡⵓⵔⴰⵔ ⵏ ⵜⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵏⴻⵡⵛ ⵄⴰⵡⴻⴷ ⵜⵉⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵙⵙⴰ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴽⵉⴷⵉ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN29_28","002_29_28","GEN","29","28","28","ⵉⴳⴳⴰ ⵢⴰⵄⵇⵓⴱ ⴰⵎⴻⵏⵏⵉ, ⵉⴽⴻⵎⵎⴻⵍ ⵙⵙⵉⵎⴰⵏⴰ-ⵢⴰ ⵏ ⵡⵓⵔⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵙ ⵢⴻⴵⵉⵙ ⵔⴰⵃⵉⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ");
INSERT INTO rift_vpl VALUES ("GN29_29","002_29_29","GEN","29","29","29","ⵓⵛⴰ ⵉⵡⵛⴰ ⵍⴰⴱⴰⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⴱⵉⵍⵀⴰ ⵉ ⵢⴻⴵⵉⵙ ⵔⴰⵃⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN29_30","002_29_30","GEN","29","30","30","ⵢⵓⴷⴻⴼ ⵢⴰⵄⵇⵓⴱ ⵄⴰⵡⴻⴷ ⵅ ⵔⴰⵃⵉⵍ ⵓⵛⴰ ⵉⵅⵙ ⵔⴰⵃⵉⵍ ⵄⴰⴷ ⴽⵜⴰⵔ ⵅ ⵍⵉⵢⴰ. ⵓⵛⴰ ⵉⵙⴻⵅⵅⴰⵔ ⴰⵙ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN29_31","002_29_31","GEN","29","31","31","ⵓⵎⵉ ⵉⵥⵔⴰ ⵙⵉⴷⵉ ⴱⴻⵍⵍⵉ ⵍⵉⵢⴰ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ, ⵢⴰⵔⵣⴻⵎ ⵍⴻⵎⵍⴰⵡⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵔⴰⵃⵉⵍ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵔⵓⵡ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN29_32","002_29_32","GEN","29","32","32","ⵜⴻⴽⵙⵉ ⵍⵉⵢⴰ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵉⴳⴳⴰ ⴰⵙ ⵔⵓⴱⵉⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰ: “ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵉⵏⵓ. ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵢⵉ ⵉⵅⵙ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN29_33","002_29_33","GEN","29","33","33","ⵜⴻⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵜⴻⵏⵏⴰ: “ⵓⵎⵉ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵖ, ⵉⵡⵛⴰ ⴰⵢⵉ ⵄⴰⵡⴻⴷ ⵡⴰ.” ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN29_34","002_29_34","GEN","29","34","34","ⵜⴻⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵜⴻⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⵜⵡⴰⵍⴰ-ⵢⴰ ⴰⴷ ⵉⵎⵓⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵓ ⴰⴽⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵓⵔⵡⴻⵖ ⴰⵙ-ⴷⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ.” ⵅ ⵓⵢⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵙ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("GN29_35","002_29_35","GEN","29","35","35","ⵜⴻⴽⵙⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵜⴻⵏⵏⴰ: “ⵜⵡⴰⵍⴰ-ⵢⴰ ⴰⴷ ⵇⴰⴷⵉⵖ ⵙⵉⴷⵉ.” ⵅ ⵓⵢⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵢⴰⵀⵓⴷⴰ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⴻⵙⵙⴱⴻⴷⴷ ⵜⴰⵔⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("GN30_1","002_30_1","GEN","30","1","1","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵔⴰⵃⵉⵍ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵔⵓⵡ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵜⵓⵙⴻⵎ ⵣⴻⴳ ⵓⵍⵜⵎⴰⵙ, ⵜⴻⵏⵏⴰ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⴻⵡⵛ ⴰⵢⵉ ⵜⴰⵔⵡⴰ! ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵇⴱⵉⵍⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN30_2","002_30_2","GEN","30","2","2","ⵉⵅⴻⵢⵢⴻⵇ ⵢⴰⵄⵇⵓⴱ ⵅ ⵔⴰⵃⵉⵍ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⵇⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵅⴰⵎ ⵉⵟⵟⴼⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("GN30_3","002_30_3","GEN","30","3","3","ⵜⴻⵏⵏⴰ: “ⴰⵇⴰ ⴷⴰ ⵜⴰⵢⵢⴰ ⵉⵏⵓ ⴱⵉⵍⵀⴰ. ⴰⴷⴻⴼ ⵅⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵜⴰⵔⵔⴰⵡⵜ ⵣⵣⴰⵢⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN30_4","002_30_4","GEN","30","4","4","ⵜⴻⵡⵛⴰ ⴰⵙ ⴱⵉⵍⵀⴰ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵅⴰⵙ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_5","002_30_5","GEN","30","5","5","ⵜⴻⴽⵙⵉ ⴱⵉⵍⵀⴰ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_6","002_30_6","GEN","30","6","6","ⵜⴻⵏⵏⴰ ⵔⴰⵃⵉⵍ: “ⵉⵡⵛⴰ ⴰⵢⵉ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵓⵛⴰ ⵉⵙⵍⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔⵉ. ⵉⵡⵛⴰ ⴰⵢⵉ ⵎⵎⵉ.” ⵅ ⵓⵢⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_7","002_30_7","GEN","30","7","7","ⵜⴻⴽⵙⵉ ⴱⵉⵍⵀⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵔⴰⵃⵉⵍ, ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉ ⵢⴰⵄⵇⵓⴱ ⴰⵃⴻⵏⵊⵉⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_8","002_30_8","GEN","30","8","8","ⵜⴻⵏⵏⴰ ⵔⴰⵃⵉⵍ: “ⵙ ⵉⵎⴻⵏⵖⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⴻⵏⵖⴻⵖ ⴰⴽ-ⴷ ⵓⵍⵜⵎⴰ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵖ.” ⵜⴻⴳⴳⴰ ⴰⵙ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("GN30_9","002_30_9","GEN","30","9","9","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵍⵉⵢⴰ ⵜⴻⵙⵙⴱⴻⴷⴷ ⵜⴰⵔⵡⴰ, ⵜⴻⴽⵙⵉ ⵣⵉⵍⴱⴰ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵜⴻⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵢⴰⵄⵇⵓⴱ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("GN30_10","002_30_10","GEN","30","10","10","ⵓⵛⴰ ⵣⵉⵍⴱⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵍⵉⵢⴰ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_11","002_30_11","GEN","30","11","11","ⵜⴻⵏⵏⴰ ⵍⵉⵢⴰ: “ⵎⴰⵏⴰ ⵍⵅⵉⵔ-ⴰ!” ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN30_12","002_30_12","GEN","30","12","12","ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵣⵉⵍⴱⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵍⵉⵢⴰ, ⴰⵃⴻⵏⵊⵉⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_13","002_30_13","GEN","30","13","13","ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⵍⵉⵢⴰ: “ⴰ ⵙⵙⴻⵄⴷ ⵉⵏⵓ!”, ⵎⵉⵏⵣⵉ ⵜⵉⴱⵍⵉⵖⵉⵏ ⴰⴷ ⴰⵢⵉ ⵃⴻⵙⴱⴻⵏⵜ ⴷ ⵙⵙⴻⵄⴷ!” ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⴰⵛⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN30_14","002_30_14","GEN","30","14","14","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⵢⵔⴰ ⵏ ⵉⵔⴷⴻⵏ ⵉⴼⴼⴻⵖ ⵔⵓⴱⵉⵏ ⵓⵛⴰ ⵢⵓⴼⴰ ‘ⵜⵉⵜⴻⴼⴼⴰⵃⵉⵏ ⵏ ⵜⴰⵢⵔⵉ’ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢ ⵉ-ⵜⴻⵏⵜ ⵉ ⵍⵉⵢⴰ, ⵢⴻⵎⵎⴰⵙ. ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵔⴰⵃⵉⵍ ⵉ ⵍⵉⵢⴰ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⵣⵉ ‘ⵜⵜⴻⴼⴼⴰⵃⵉⵏ ⵏ ⵜⴰⵢⵔⵉ’ ⵏ ⵎⵎⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN30_15","002_30_15","GEN","30","15","15","ⵎⴰⵛⴰ ⵍⵉⵢⴰ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵔⵓⵙ ⴰⵍⴰⵎⵉ ⵜⵉⵡⵢⴻⴷ ⴰⵔⵢⴰⵣ ⵉⵏⵓ, ⵓⵎⵉ ⵜⴻⵅⵙⴻⴷ ⵄⴰⵡⴻⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ‘ⵜⵉⵜⴻⴼⴼⴰⵃⵉⵏ ⵏ ⵜⴰⵢⵔⵉ’ ⵏ ⵎⵎⵉ?” ⵜⴻⵏⵏⴰ ⵔⴰⵃⵉⵍ: “ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵎ ⴵⵉⵍⴻⵜ-ⴰ ⵅ ‘ⵜⵜⴻⴼⴼⴰⵃⵉⵏ ⵏ ⵜⴰⵢⵔⵉ’ ⵏ ⵎⵎⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN30_16","002_30_16","GEN","30","16","16","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵢⴰⵄⵇⵓⴱ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵙ ⵜⵎⴻⴷⴷⵉⵜ, ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵍⵉⵢⴰ ⵖⴰⵔⴻⵙ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⴷⴼⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⵉⵛⴰⵏ ⵛⵔⵉⵖ ⵛⴻⴽ ⵙ ‘ⵜⵜⴻⴼⴼⴰⵃⵉⵏ ⵏ ⵜⴰⵢⵔⵉ’ ⵏ ⵎⵎⵉ.” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ ⴵⵉⵔⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN30_17","002_30_17","GEN","30","17","17","ⵉⵙⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⵉⵢⴰ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_18","002_30_18","GEN","30","18","18","ⵜⴻⵏⵏⴰ ⵍⵉⵢⴰ: “ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ ⵅ ⵓⵎⵉ ⵡⵛⵉⵖ ⵜⴰⵢⵢⴰ ⵉⵏⵓ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵓ!” ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵉⵙⵙⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN30_19","002_30_19","GEN","30","19","19","ⵜⴻⴽⵙⵉ ⵍⵉⵢⴰ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_20","002_30_20","GEN","30","20","20","ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⵍⵉⵢⴰ: “ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ ⵜⴻⵛⵏⴰ. ⵍⴻⵅⵅⵓ ⴰⴷ ⴽⵉⴷⵉ ⵉⵣⴷⴻⵖ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵓⵔⵡⴻⵖ ⴰⵙ-ⴷⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ.” ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_21","002_30_21","GEN","30","21","21","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ. ⵜⴻⴳⴳⴰ ⴰⵙ ⴷⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN30_22","002_30_22","GEN","30","22","22","ⵅⴻⵏⵏⵉ ⵉⴷⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵔⴰⵃⵉⵍ ⵓⵛⴰ ⵉⵙⵍⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵢⴰⵔⵣⴻⵎ ⵍⴻⵎⵍⴰⵡⵍⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN30_23","002_30_23","GEN","30","23","23","ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵜⴻⵏⵏⴰ: “ⵉⴽⴽⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵍⵃⴻⴳⵔⴰ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN30_24","002_30_24","GEN","30","24","24","ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵢⵓⵙⵓⴼ, ⵜⴻⵏⵏⴰ: “ⴰⴷ ⴰⵢⵉ ⵢⴰⵔⵏⵉ ⵙⵉⴷⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN30_25","002_30_25","GEN","30","25","25","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵔⴰⵃⵉⵍ ⵢⵓⵙⵓⴼ, ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵍⴰⴱⴰⵏ: “ⵙⴻⴽⴽ ⴰⵢⵉ ⵓⵛⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴷⵛⴰⵔ ⵉⵏⵓ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN30_26","002_30_26","GEN","30","26","26","ⴻⵡⵛ ⴰⵢⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉⵏⵓ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵎⵉⵏ ⵣⵉ ⵖⴰⵔⴻⴽ ⵅⴻⴷⵎⴻⵖ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵖ. ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⴷ ⴰⵛ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN30_27","002_30_27","GEN","30","27","27","ⵉⵏⵏⴰ ⴰⵙ ⵍⴰⴱⴰⵏ: “ⵎⵍⵉ ⵓⴼⵉⵖ ⵍⴻⵅⵅⵓ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ⴰⵇⴰ ⵥⵔⵉⵖ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵄⵊⴻⴱ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⴱⴰⵔⴻⴽ ⴰⵢⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN30_28","002_30_28","GEN","30","28","28","ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ: “ⵉⵏⵉ ⴰⵢⵉ ⵣⴻⵄⵎⴰ ⵎⴰⵏ ⵍⵎⵓⵏⴻⵜ ⵉ ⵜⴻⵅⵙⴻⴷ, ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵜⵜ ⵡⵛⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN30_29","002_30_29","GEN","30","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵅⴻⴷⵎⴻⵖ ⴷ ⵎⴰⵎⵎⴻⵛ ⵓⵢⵓⵔⴻⵖ ⴰⴽ-ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴰⵎⵉ ⴽⵉⵛ ⴵⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("GN30_30","002_30_30","GEN","30","30","30","ⵎⵉⵏⵣⵉ ⴷⵔⵓⵙⵜ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⴽ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵇⴱⴻⵍ ⵉ ⴷⴷ-ⵓⵙⵉⵖ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⵉ ⵛⴻⴽ ⵙⵉⴷⵉ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴻⵍⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵅⴻⴷⵎⴻⵖ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("GN30_31","002_30_31","GEN","30","31","31","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵡⵛⴻⵖ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ: “ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵉⵛ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵙⴰⵎⵃ ⴰⵢⵉ ⴰⵢⴰ ⵡⴰⵀⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵖ ⵓⴵⵉ ⵏⵏⴻⵛ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵃⴹⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("GN30_32","002_30_32","GEN","30","32","32","ⴰⵙⵙ-ⴰ ⴰⴷ ⵄⴷⵓⵖ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ. ⴻⴳⴳ ⵛⴻⴽ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⵉⴱⴻⵇⵇⴹⴻⵏ ⴷ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ, ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⴰⴱⴰⵔⵛⴰⵏ ⵊⴰⵔ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵇⴰⵔⵇⴰⵛ ⵏⵉⵖ ⵙ ⵉⴱⴻⵇⵇⵉⴹⴻⵏ ⵊⴰⵔ ⵉⵖⴰⵢⴹⴻⵏ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN30_33","002_30_33","GEN","30","33","33","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵢⵉⵎⴰⵍ ⵎⴰⵃⴻⵏⵙ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ, ⴰⴷ ⵜⴱⴰⵏ ⵜⵙⴻⴳⴷⴰ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ: ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉⴱⴻⵇⵇⴻⴹ ⵏⵉⵖ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉⵇⵇⴰⵔⵇⴻⵛ ⵊⴰⵔ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵊⴰⵔ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵉⵜⵜⵡⴰⵛⴰⵔ ⵊⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN30_34","002_30_34","GEN","30","34","34","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴰⴱⴰⵏ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("GN30_35","002_30_35","GEN","30","35","35","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴼⴰⵔⵇ ⵉⵡⴻⵜⵎⴰⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵛⴰⵔⴹⴻⵏ ⴷ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵢⴹⵜⵉⵏ ⵉⴱⴻⵇⵇⴹⴻⵏ ⴷ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉ ⵜⴻⴵⴰ ⵜⴻⵎⵍⴻⵍ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵊⴰⵔ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN30_36","002_30_36","GEN","30","36","36","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⴱⵔⵉⴷ ⵊⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵢⴰⵄⵇⵓⴱ. ⵓⵛⴰ ⵢⴰⵔⵡⴻⵙ ⵢⴰⵄⵇⵓⴱ ⵓⴵⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴰⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_37","002_30_37","GEN","30","37","37","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵢⴰⵄⵇⵓⴱ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏ ⵚⵚⴻⴼⵚⴰⴼ ⵓ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴵⵓⵣ ⵓ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴷⵓⵍⴱ. ⵏⴻⵜⵜⴰ ⵉⵇⴻⵛⵛⴰⵔ ⵉ-ⵜⴻⵏⵜ ⴷ ⵉⵛⴻⵟⵟⵉⴹⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⵓⵎⵉ ⵉⵄⴰⵔⵔⴰ ⵅ ⵓⵛⴻⵎⵍⴰⵍ ⵏ ⵜⵙⴻⴹⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_38","002_30_38","GEN","30","38","38","ⵉⵙⵙⴰⵔⵙ ⵜⵉⵙⴻⴹⵡⵉⵏ-ⴰ ⵉⵇⴻⵛⵛⴰⵔⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⵓⴵⵉ ⴷⵉ ⵜⴰⵔⵢⵉⵡⵉⵏ ⴷ ⵍⴻⵇⵡⴰⵔⴻⴱ ⵎⴰⵏⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵡⵓⴵⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵡⴻⵏⵜ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵜⵡⴻⵃⵃⴰⵎⴻⵏⵜ ⵅⵎⵉ ⴷⴷ-ⵜⴰⵙⴻⵏⵜ ⴰⴷ ⵡⴰⵔⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN30_39","002_30_39","GEN","30","39","39","ⵅⵎⵉ ⵉ ⵖⴰ ⵉⵡⴻⵃⵃⴻⵎ ⵡⵓⴵⵉ ⵖⴰⵔ ⵜⵙⴻⴹⵡⵉⵏ, ⵓⵔⵡⴻⵏⵜ-ⵉ-ⴷⴷ ⵜⵖⴰⵔⵟⵉⵏ ⵎⵉⵏ ⵉⵛⴰⵔⴹⴻⵏ ⴷ ⵎⵉⵏ ⵉⴱⴻⵇⵇⴹⴻⵏ ⴷ ⵎⵉⵏ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_40","002_30_40","GEN","30","40","40","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵟⵟⴰ ⵢⴰⵄⵇⵓⴱ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵓⴵⵉ ⵙ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⵎⵉⵏ ⵉⵛⴰⵔⴹⴻⵏ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵊⴰⵔ ⵡⵓⴵⵉ ⵏ ⵍⴰⴱⴰⵏ. ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵉⴳⴳⵉ ⴰⴽ-ⴷ ⵡⵓⴵⵉ ⵏ ⵍⴰⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_41","002_30_41","GEN","30","41","41","ⴽⵓⵍ ⴰⵎⵓⵍ ⵅⵎⵉ ⵜⵜⵡⴻⵃⵃⴰⵎⴻⵏⵜ ⵜⵉⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵉⵜⵜⴻⴳⴳ ⵢⴰⵄⵇⵓⴱ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⵓⴵⵉ ⴷⵉ ⵜⴰⵔⵢⵉⵡⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵡⴻⵃⵃⵎⴻⵏⵜ ⵖⴰⵔ ⵜⵙⴻⴹⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN30_42","002_30_42","GEN","30","42","42","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵉⵙⵙⴰⵔⵙ ⵛⴰ ⴰⴽ-ⴷ ⵜⴻⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ ⵊⴰⵔ ⵡⵓⴵⵉ. ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵜⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ ⵉ ⵍⴰⴱⴰⵏ ⵓ ⵜⵉⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN30_43","002_30_43","GEN","30","43","43","ⵓⵛⴰ ⵉⵎⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏ ⵡⴻⵔⵢⴰⵣ-ⴰ ⴱⵍⴰ ⵇⴻⵟⵟⵓ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴵⵉ ⴷ ⵜⵉⵢⵢⴰ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⴷ ⵢⴻⵖⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("GN31_1","002_31_1","GEN","31","1","1","ⵓⵛⴰ ⵉⵙⵍⴰ ⵢⴰⵄⵇⵓⴱ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⴰⴱⴰⵏ, ⵏⵏⴰⵏ: “ⵢⴰⵄⵇⵓⴱ ⵉⴽⵙⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵓ ⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ ⴰⵇⴰ ⵉⴽⵙⴻⴱ ⵎⴰⵔⵔⴰ ⴰⵄⵓⴵⵉ-ⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN31_2","002_31_2","GEN","31","2","2","ⵉⵅⵣⴰⵔ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵍⴰⴱⴰⵏ. ⵅⵣⴰⵔ, ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵉⴵⵉ ⴰⵎ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("GN31_3","002_31_3","GEN","31","3","3","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔ ⵍⴰⴵ ⵏⵏⴻⵛ. ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽⵉⴷⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("GN31_4","002_31_4","GEN","31","4","4","ⵉⵙⴻⴽⴽ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵔⴰⵃⵉⵍ ⴷ ⵍⵉⵢⴰ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ, ⵖⴰⵔ ⵡⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN31_5","002_31_5","GEN","31","5","5","ⵉⵏⵏⴰ ⴰⵙⴻⵏⵜ: “ⵜⵜⵡⴰⵍⵉⵖ ⴱⴻⵍⵍⵉ ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⴱⴰⴱⴰⵜⴽⴻⵏⵜ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⴵⵉ ⴰⵎ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN31_6","002_31_6","GEN","31","6","6","ⴽⴻⵏⵏⵉⵏⵜ ⵜⴻⵙⵙⵏⴻⵏⵜ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵅⴻⴷⵎⴻⵖ ⵉ ⴱⴰⴱⴰⵜⴽⴻⵏⵜ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵉ ⴷ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("GN31_7","002_31_7","GEN","31","7","7","ⵎⴰⵛⴰ ⴱⴰⴱⴰⵜⴽⴻⵏⵜ ⵉⵖⴻⵛⵛ ⴰⵢⵉ, ⵉⴱⴻⴷⴷⴻⵍ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ ⵄⴻⵛⵔⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵙⴻⵎⵎⴻⵃ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN31_8","002_31_8","GEN","31","8","8","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵉⴱⴻⵇⵇⵉⴹⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵛ!’, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⵓⵔⵡⴻⵏⵜ-ⵉ-ⴷⴷ ⵓⴵⵉ ⵙ ⵉⴱⴻⵇⵇⵉⴹⴻⵏ, ⵎⴰⵍⴰ ⵉⵏⵏⴰ: ‘ⵉⵏⵏⵉ ⵙ ⵉⵛⴰⵔⵉⴹⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵛ!’, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⵓⵔⵡⴻⵏⵜ-ⵉ-ⴷⴷ ⵓⴵⵉ ⵙ ⵉⵛⴰⵔⵉⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_9","002_31_9","GEN","31","9","9","ⴰⵎⵎⵓ ⵉⴽⴽⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⴱⴰⴱⴰⵜⴽⴻⵏⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵢⵉ ⵜⴻⵏⵜ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("GN31_10","002_31_10","GEN","31","10","10","ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⵡⴻⵃⵃⵎⴻⵏⵜ ⵓⴵⵉ, ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⴰⵎⵓⵖⵍⵉ ⵉⵏⵓ ⵓⵛⴰ ⵥⵔⵉⵖ ⴷⵉ ⵜⴰⵔⵊⵉⵜ, ⴰⵇⴰ ⴷⴰ ⵉⵖⴰⵢⴹⴻⵏ ⵏⵏⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵅ ⵡⵓⴵⵉ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵉⵛⴰⵔⵉⴹⴻⵏ ⴷ ⵉⴱⴻⵇⵇⵉⴹⴻⵏ ⴷ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_11","002_31_11","GEN","31","11","11","ⵉⵏⵏⴰ ⴰⵢⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ‘ⵢⴰⵄⵇⵓⴱ!’ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ‘ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("GN31_12","002_31_12","GEN","31","12","12","ⵉⵏⵏⴰ: ‘ⵏⴹⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵉⵖⴰⵢⴹⴻⵏ, ⵉⵏⵏⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵅ ⵡⵓⴵⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⵉⵛⴰⵔⵉⴹⴻⵏ ⴷ ⵉⴱⴻⵇⵇⵉⴹⴻⵏ ⴷ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵜⵜⴻⴳⴳ ⵍⴰⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_13","002_31_13","GEN","31","13","13","ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⵢⵜ-ⵉⵍ, ⵎⴰⵏⵉ ⵜⴷⴻⵀⵏⴻⴷ ⴰⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵓ ⵎⴰⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⴰⵡⴰⵍ. ⴽⴽⴰⵔ ⵍⴻⵅⵅⵓ, ⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵅⴻⵍⵇⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("GN31_14","002_31_14","GEN","31","14","14","ⵅⴻⵏⵏⵉ ⴰⵔⵔⵉⵏⵜ-ⵉ-ⴷⴷ ⵔⴰⵃⵉⵍ ⴷ ⵍⵉⵢⴰ, ⵏⵏⴰⵏⵜ ⴰⵙ: “ⵎⴰ ⴷⵉⵏ ⵄⴰⴷ ⵛⴰ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵍⵡⴰⵔⵜ ⵉ ⵏⴻⵛⵛⵉⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("GN31_15","002_31_15","GEN","31","15","15","ⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⵉⵃⵙⵉⴱ ⴰⵎ ⵜⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ? ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵣⵣⴻⵏⵣ ⴰⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵇⴻⵟⵟⴰ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN31_16","002_31_16","GEN","31","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⵉ ⵉⴽⴽⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵏⵏⴻⵖ ⵉ ⵉⴵⴰ ⵓ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ. ⵍⴻⵅⵅⵓ ⵄⴰⴷ, ⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN31_17","002_31_17","GEN","31","17","17","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵅ ⵉⵍⴻⵖⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_18","002_31_18","GEN","31","18","18","ⵉⴳⴳⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⴷⴷ-ⵉⴽⵙⴻⴱ, ⴰⵇⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⵉ ⵉⵟⵟⴻⴼ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⴽⵙⴻⴱ ⴷⵉ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵉⵙⵃⴰⵇ, ⴱⴰⴱⴰⵙ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_19","002_31_19","GEN","31","19","19","ⵓⵎⵉ ⵉⵔⵓⵃ ⵍⴰⴱⴰⵏ ⵖⴰⵔ ⵜⵉⵍⵙⴰ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ, ⵜⵓⵛⴰⵔ ⵔⴰⵃⵉⵍ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN31_20","002_31_20","GEN","31","20","20","ⵢⴰⵄⵇⵓⴱ ⵉⵅⴷⴻⵄ ⵍⴰⴱⴰⵏ, ⴰⵔⴰⵎⵉⵢⵓ, ⵍⴰⵎⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵄⵍⵉⵎ ⴰⵇⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN31_21","002_31_21","GEN","31","21","21","ⵢⴰⵔⵡⴻⵍ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ⵉⴽⴽⴰⵔ, ⵉⵥⵡⴰ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN31_22","002_31_22","GEN","31","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵍⴰⴱⴰⵏ, ⴰⵇⴰ ⵢⴰⵔⵡⴻⵍ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN31_23","002_31_23","GEN","31","23","23","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⴰⵢⵜⵎⴰⵙ ⴰⴽⵉⴷⴻⵙ, ⵉⵔⵓⵃ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵉⵛⵍⵉ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵅⴻⵛⵛ ⵅⴰⵙ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN31_24","002_31_24","GEN","31","24","24","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵍⴰⴱⴰⵏ, ⴰⵔⴰⵎⵉⵢⵓ, ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⴷⵉ ⴵⵉⵔⴻⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵖⴰⵔⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵍⵅⴰⵔ ⵏⵉⵖ ⵙ ⵍⵖⴰⵔ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("GN31_25","002_31_25","GEN","31","25","25","ⵉⵔⴻⵃⵃⴻⴳ ⵅⴻⵏⵏⵉ ⵍⴰⴱⴰⵏ ⵅ ⵢⴰⵄⵇⵓⴱ. ⵢⴰⵄⵇⵓⴱ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ. ⵍⴰⴱⴰⵏ ⵄⴰⵡⴻⴷ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN31_26","002_31_26","GEN","31","26","26","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴰⴱⴰⵏ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ, ⵜⴻⵥⵡⵉⴷ ⴰⵢⵉ ⵓⵍ ⵓⵛⴰ ⵜⵉⵡⵢⵉⴷ-ⴷⴷ ⵢⴻⵙⵙⵉ ⴰⵎ ⵜⵎⴻⵃⴱⴰⵙ ⵏ ⴳⴰⵔⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("GN31_27","002_31_27","GEN","31","27","27","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴰⵔⴻⵡⵍⴻⴷ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵓ ⵜⵓⵛⴰⵔⴻⴷ ⴰⵢⵉ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵅⴻⴱⴱⴰⵔⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵇⴻⴱⴱⴹⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵙ ⵍⴻⵖⵏⵓⵊ, ⵙ ⵓⴱⴻⵏⴷⵉⵔ ⵓ ⵙ ⵍⴳⴰⵎⴱⵔⵉ? ");
INSERT INTO rift_vpl VALUES ("GN31_28","002_31_28","GEN","31","28","28","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⵙⵙⵓⴷⵎⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵉⵏⵓ. ⵍⴻⵅⵅⵓ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵉ ⵜⴻⴳⴳⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN31_29","002_31_29","GEN","31","29","29","ⵖⴰⵔⵉ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴹⴰⵔⵔⴻⵖ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⴵⵉⵔⴻⵜ-ⴰ, ⵉⵏⵏⴰ: ‘ⵖⴰⵔⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵍⵅⴰⵔ ⵏⵉⵖ ⵙ ⵍⵖⴰⵔ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ.’ ");
INSERT INTO rift_vpl VALUES ("GN31_30","002_31_30","GEN","31","30","30","ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵜⵓⵢⵓⵔⴻⴷ, ⵓⵎⵉ ⵣⴻⵄⵎⴰ ⵜⵡⴻⵃⵃⵛⴻⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ. ⵎⴰⵛⴰ ⵎⴰⵖⴰⵔ ⵉ ⴷ ⴰⵢⵉ ⵜⵓⵛⴰⵔⴻⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("GN31_31","002_31_31","GEN","31","31","31","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⴰ ⵉ ⵍⴰⴱⴰⵏ: “ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴳⴳⵯⴻⴷⴻⵖ, ⵏⵏⵉⵖ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴰⵢⵉ ⵜⴻⴽⴽⵙⴻⴷ ⵢⴻⵙⵙⵉⵛ ⵙ ⵓⵖⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("GN31_32","002_31_32","GEN","31","32","32","ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⴼⴻⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵛ, ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵄⴰⴷ! ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ ⴰⴷ ⵜⵎⴻⵢⵢⵣⴻⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ ⵊⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔⵉ ⵓⵛⴰ ⴰⵡⵢⵉ ⵜ ⴰⴽⵉⴷⴻⴽ.” ⵎⴰⵖⴰⵔ ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴱⴻⵍⵍⵉ ⵔⴰⵃⵉⵍ ⵉ ⵜⴻⵏ ⵢⵓⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_33","002_31_33","GEN","31","33","33","ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵍⴰⴱⴰⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵍⵉⵢⴰ, ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵢⵢⴰ ⵓⵛⴰ ⵡⴰⵔ ⵢⵓⴼⵉ ⵡⴰⵍⵓ. ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵍⵉⵢⴰ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵔⴰⵃⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN31_34","002_31_34","GEN","31","34","34","ⵎⴰⵛⴰ ⵜⴻⴽⵙⵉ ⵔⴰⵃⵉⵍ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵜⴻⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴷⴻⴳ ⵉⵖⴰⵢⵏⴻⵏ ⵏ ⵡⴻⵍⵖⴻⵎ ⵓⵛⴰ ⵜⴻⵇⵇⵉⵎ ⵅⴰⵙⴻⵏ. ⵢⴰⵔⵣⵓ ⵍⴰⴱⴰⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⴰⵎ ⵉⴽⵎⴻⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⵓⴼⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("GN31_35","002_31_35","GEN","31","35","35","ⵜⴻⵏⵏⴰ ⵉ ⴱⴰⴱⴰⵙ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵢⴰ ⴷ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵢⵉ ⵙ ⵜⵏⴰⵎⵉⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ.” ⵓⵛⴰ ⵢⴰⵔⵣⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⵓⴼⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN31_36","002_31_36","GEN","31","36","36","ⵅⴻⵏⵏⵉ ⵉⵅⴻⵢⵢⴻⵇ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⵎⵛⵓⴱⴱⴻⵛ ⴰⴽ-ⴷ ⵍⴰⴱⴰⵏ. ⵢⴰⵄⵇⵓⴱ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵍⴰⴱⴰⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵅⴻⵟⵟⵓ ⵉⵏⵓ? ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴷⴷⴻⵏⴱ ⵉⵏⵓ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⴹⴼⴰⵔⴻⴷ ⵙ ⵣⵣⵄⴰⴼ? ");
INSERT INTO rift_vpl VALUES ("GN31_37","002_31_37","GEN","31","37","37","ⵛⴻⴽ ⵜⴱⴻⵇⵛⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵛⵛ ⵉⵏⵓ. ⵎⵉⵏ ⵜⵓⴼⵉⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ? ⴻⴳⴳ ⵉ-ⵜ ⴷⴰ ⵣⵣⴰⵜ ⵏ ⵢⴰⵢⵜⵎⴰ ⴷ ⴰⵢⵜⵎⴰⵛ ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_38","002_31_38","GEN","31","38","38","ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴽⵉⴽ ⴽⴽⵉⵖ. ⵜⵉⵅⴻⵙⵡⵉⵏ ⵏⵏⴻⵛ ⴷ ⵜⵖⴰⵢⴹⵉⵏ ⵏⵏⴻⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵙⵙⵓⵜⵎⴻⵏⵜ ⵏⵉⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵛⵛⵉⵖ ⵉⵛⴰⵔⵔⵉⵢⴻⵏ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN31_39","002_31_39","GEN","31","39","39","ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵡⵢⴻⵖ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵎⴻⵣⵣⵇⴻⵏ, ⵎⴰⵛⴰ ⵅⴻⵟⵚⴻⵖ ⵜ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ. ⵎⵉⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⴻⵏ ⵣⵣⴰⵢⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵉⵖ ⴷⵉ ⴵⵉⵔⴻⵜ, ⴰⵇⴰ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN31_40","002_31_40","GEN","31","40","40","ⵙ ⵓⵣⵉⵍ ⵉⵜⵜⴻⵜⵜ ⴰⵢⵉ ⵍⴻⵃⵎⵓ ⵢⵓⵥⵖⴻⵏ ⵜⵉⵍⵎⴻⵛⵜ ⵓ ⵙ ⴵⵉⵔⴻⵜ ⵜⵜⴻⵊⵎⵉⴷⴻⵖ ⵣⵉ ⵙⵇⵉⵄ, ⴰⵍⴰⵎⵉ ⵢⴰⵔⵡⴻⵍ ⵉⴹⴻⵚ ⵣⵉ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN31_41","002_31_41","GEN","31","41","41","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵅⴻⴷⵎⴻⵖ ⵖⴰⵔⴻⴽ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵛ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵡⵓⴵⵉ ⵓⵛⴰ ⵜⴱⴻⴷⴷⵍⴻⴷ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ ⵄⴻⵛⵔⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN31_42","002_31_42","GEN","31","42","42","ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵉⵙⵃⴰⵇ, ⵉⵍⵉ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⴵⵉ, ⴷ ⵚⵚⴻⵃ ⵉⵍⵉ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴰⴷⴻⴷ ⵍⴻⵅⵅⵓ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ! ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵎⴰⵔⴰ ⴷ ⵜⵓⵎⴰⵔ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵓⵛⴰ ⵉⴷⴻⵇⵎⴰⵔ ⵉ ⵛⴻⴽ ⴵⵉⵍⴻⵜ ⵏ ⵉⴹⴻⵏⵏⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("GN31_43","002_31_43","GEN","31","43","43","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴰⴱⴰⵏ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ-ⴰ ⴷ ⵢⴻⵙⵙⵉ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ-ⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵓ ⵓⴵⵉ-ⵢⴰ ⴷ ⵓⴵⵉ ⵉⵏⵓ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⴰⵇⴰ ⵉⵏⵓ. ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵅⵅⵓ ⵙ ⵢⴻⵙⵙⵉ ⵏⵉⵖ ⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ ⵏⵏⵉ ⵓⵔⵡⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("GN31_44","002_31_44","GEN","31","44","44","ⵖⴰⵡⴻⵔ ⵄⴰⴷ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⵏⴻⵛⵛ ⴷ ⵛⴻⴽ, ⴰⴷ ⵢⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("GN31_45","002_31_45","GEN","31","45","45","ⵓⵛⴰ ⵉⴽⵙⵉ ⵢⴰⵄⵇⵓⴱ ⴰⵥⵔⵓ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜ ⴰⵎ ⵡⴻⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN31_46","002_31_46","GEN","31","46","46","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵙⵎⵓⵏⴻⵎ ⵉⵥⵔⴰ!” ⴽⵙⵉⵏ ⵉⵥⵔⴰ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜⴰⵄⵓⵔⵔⵉⵛⵜ ⵓⵛⴰ ⵛⵛⵉⵏ ⴷⵉⵏ ⵅ ⵜⵄⵓⵔⵔⵉⵛⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN31_47","002_31_47","GEN","31","47","47","ⵓⵛⴰ ⵉⴳⴳⴰ ⵍⴰⴱⴰⵏ ⵉ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵉⵥⵔⴰ ⵏⵏⵉ ‘ⵊⵉⴳⴰⵔ-ⵙⴰⵀⴰⴷⵓⵜⴰ’, ⵎⴰⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵉⴳⴳⴰ ⴰⵙ ‘ⵊⵉⵍⵄⴰⴷ’. ");
INSERT INTO rift_vpl VALUES ("GN31_48","002_31_48","GEN","31","48","48","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴰⴱⴰⵏ: “ⵜⴰⵄⵓⵔⵔⵉⵛⵜ-ⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⴰⵙⵙ-ⴰ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ!” ⵅ ⵓⵢⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵊⵉⵍⵄⴰⴷ ");
INSERT INTO rift_vpl VALUES ("GN31_49","002_31_49","GEN","31","49","49","ⴷ ⵎⵉⵚⴼⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵉⵍⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴹⴰ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⵅⵎⵉ ⵖⴰ ⵏⵉⵍⵉ ⴰⵎ ⵏᵉⵏⵓⴼⴼⴰⵔ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN31_50","002_31_50","GEN","31","50","50","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵢⴻⵙⵙⵉ ⵏⵉⵖ ⴰⴷ ⵜⵎⴻⵍⵛⴻⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵅ ⵢⴻⵙⵙⵉ, ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵃⴻⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("GN31_51","002_31_51","GEN","31","51","51","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵍⴰⴱⴰⵏ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵅⵣⴰⵔ, ⵜⴰⵄⵓⵔⵔⵉⵛⵜ-ⴰ ⵏ ⵢⴻⵥⵔⴰ, ⵅⵣⴰⵔ, ⴰⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("GN31_52","002_31_52","GEN","31","52","52","ⵜⴰⵄⵓⵔⵔⵉⵛⵜ-ⴰ ⵏ ⵢⴻⵥⵔⴰ ⴷ ⵡⴻⵥⵔⵓ-ⵢⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⴰⴷ ⵛⴻⵀⴷⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵥⴻⴽⴽⵯⵉⵖ ⵛⴰ ⵅ ⵜⵄⵓⵔⵔⵉⵛⵜ-ⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵥⴻⴽⴽⵯⵡⵉⴷ ⵛⴰ ⵉ ⵍⵖⴰⵔ ⵅ ⵜⵄⵓⵔⵔⵉⵛⵜ-ⴰ ⵓⵍⴰ ⵅ ⵡⴻⵥⵔⵓ-ⵢⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("GN31_53","002_31_53","GEN","31","53","53","ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵏⴰⵃⵓⵔ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵃⴽⴻⵎ ⵊⴰⵔ ⴰⵏⴻⵖ!” ⵎⴰⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵉⵊⵊⵓⴵ ⵙ ‘ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵉⵙⵃⴰⵇ ⴱⴰⴱⴰⵙ’. ");
INSERT INTO rift_vpl VALUES ("GN31_54","002_31_54","GEN","31","54","54","ⵅⴻⵏⵏⵉ ⵉⵖⴰⵔⵚ ⵢⴰⵄⵇⵓⴱ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ. ⵓⵛⴰ ⵛⵛⵉⵏ ⴰⵖⵔⵓⵎ, ⵙⴻⵏⵙⵙⴻⵏ ⴵⵉⵔⴻⵜ ⵏⵏⵉ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN32_1","002_32_1","GEN","32","1","1","ⵉⴽⴽⴰⵔ ⵍⴰⴱⴰⵏ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵚⵚⴱⴻⵃ, ⵉⵙⵙⵓⴷⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵢⴻⵙⵙⵉⵙ, ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵍⴰⴱⴰⵏ, ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN32_2","002_32_2","GEN","32","2","2","ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵢⴰⵄⵇⵓⴱ ⵄⴰⵡⴻⴷ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵍⵇⴰⵏⵜ ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("GN32_3","002_32_3","GEN","32","3","3","ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵓⵎⵉ ⵜⴻⵏ ⵉⵥⵔⴰ: “ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴰ!”, ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN32_4","002_32_4","GEN","32","4","4","ⵉⵙⵙⴻⴽⴽ ⵢⴰⵄⵇⵓⴱ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵖⴰⵔ ⵄⵉⵙⵓ ⵓⵎⴰⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⴰⵄⵉⵔ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN32_5","002_32_5","GEN","32","5","5","ⵓⵛⴰ ⵉⵡⴻⵚⵚⴰ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵄⵉⵙⵓ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵢⴰⵄⵇⵓⴱ: ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵖ ⴰⴽ-ⴷ ⵍⴰⴱⴰⵏ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵖ ⴷⵉⵏ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("GN32_6","002_32_6","GEN","32","6","6","ⵖⴰⵔⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⴷ ⵡⵓⴵⵉ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵏⵉⵖ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("GN32_7","002_32_7","GEN","32","7","7","ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵄⵇⵓⴱ, ⵏⵏⴰⵏ: “ⵏⵔⵓⵃ ⵖⴰⵔ ⵓⵎⴰⵛ ⵄⵉⵙⵓ, ⵓ ⵏⴻⵜⵜⴰ ⵄⴰⵡⴻⴷ ⵢⵓⵙⴰ-ⴷⴷ ⴰⴷ ⵛⴻⴽ ⵉⵍⵇⴰ ⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN32_8","002_32_8","GEN","32","8","8","ⵅⴻⵏⵏⵉ ⵢⴰⵄⵇⵓⴱ ⵜⵓⴷⴻⴼ ⵉ-ⵜ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ ⵓⵛⴰ ⵉⵙⵙⵇⴻⵏⴹ ⵉ-ⵜ ⵍⵃⴰⵍ. ⵏⴻⵜⵜⴰ ⵉⴱⴹⴰ ⵉⵡⴷⴰⵏ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⴷ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN32_9","002_32_9","GEN","32","9","9","ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵄⵉⵙⵓ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⴷ ⵅⴰⵙ ⵉⵖⵍⴻⴱ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵉⵇⵇⵉⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN32_10","002_32_10","GEN","32","10","10","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ: “ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰ ⵉⵙⵃⴰⵇ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰⵏ: ‘ⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷ ⵔⴰⴵ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⵛⵏⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("GN32_11","002_32_11","GEN","32","11","11","ⴰⵇⴰ ⴰⵢⵉ ⵇⴻⵍⵍ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴰⵎⴰⵏ ⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵥⵡⵉⵖ ⵍ’ⵓⵔⴷⵓⵏ ⵙ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵉⵏⵓ ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⴷⴻⵡⵍⴻⵖ-ⴷⴷ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN32_12","002_32_12","GEN","32","12","12","ⴼⴻⴽⴽ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵄⵉⵙⵓ ⵓⵎⴰ, ⵎⵉⵏⵣⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⴱⴰⵍⴰⴽ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵏⴻⵖ ⵓⵍⴰ ⴷ ⵜⵉⵢⴻⵎⵎⴰⵜⵉⵏ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("GN32_13","002_32_13","GEN","32","13","13","ⵓⵛⴰ ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⴳⴳⴻⵖ ⵎⵍⵉⵃ, ⴰⴷ ⴳⴳⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵊⴷⵉ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ!’” ");
INSERT INTO rift_vpl VALUES ("GN32_14","002_32_14","GEN","32","14","14","ⵉⵙⵙⴻⵏⵙ ⴷⵉⵏ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵓⵛⴰ ⵉⴽⵙⵉ ⵣⵉ ⵎⵉⵏ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⴳⵍⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵢⴻⵡⵛ ⴷ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵉ ⵓⵎⴰⵙ ⵄⵉⵙⵓ: ");
INSERT INTO rift_vpl VALUES ("GN32_15","002_32_15","GEN","32","15","15","ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵢⴹⵉⵏ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵓⵢⴰⵏ ⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵜⵅⴻⵙⵡⵉⵏ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ");
INSERT INTO rift_vpl VALUES ("GN32_16","002_32_16","GEN","32","16","16","ⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵍⴻⵖⵎⵉⵏ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏⵜ, ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴻⵖⵢⴰⵍ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵖⵢⴰⵍ ⵉⵎⴻⵥⵢⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN32_17","002_32_17","GEN","32","17","17","ⵉⵙⵙⴻⵄⴷⵓ ⵜⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴽⵓⵍ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵡⴻⵃⵃⴷⴻⵙ, ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵄⴷⵓⵎ ⴽⴻⵏⵏⵉⵡ ⵍⴻⵅⵅⵓ ⵣⵣⴰⵜ ⵉⵏⵓ, ⴳⴳⴻⵎ ⵜⵜⴰⵙⵉⵄ ⵊⴰⵔ ⵜⵃⵉⵎⴰⵔⵜ ⴷ ⵜⵃⵉⵎⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN32_18","002_32_18","GEN","32","18","18","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵓⵎⴻⵣⵡⴰⵔ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵄⵉⵙⵓ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⴰⵛ, ⵉⵏⵏⴰ: ‘ⵡⵉ ⵛⴻⴽ ⵢⵉⵍⴰⵏ ⴷ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ?’ ⵓ ‘ⵓⵎⵉ ⵜⵉⵏⴰ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜⴻⴽ?’, ");
INSERT INTO rift_vpl VALUES ("GN32_19","002_32_19","GEN","32","19","19","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴷ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵉ ⵢⴻⴵⴰ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵢⴰⵄⵇⵓⴱ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵄⵉⵙⵓ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵄⴰⵡⴻⴷ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵏⴻⵖ!’” ");
INSERT INTO rift_vpl VALUES ("GN32_20","002_32_20","GEN","32","20","20","ⵢⵓⵎⵓⵔ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ, ⵉⵏⵏⴰ: “ⵙⵉⵡⵍⴻⵎ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵄⵉⵙⵓ, ⵅⵎⵉ ⵜ ⵖⴰ ⵜⴻⵍⵇⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN32_21","002_32_21","GEN","32","21","21","ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵅⵣⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵢⴰⵄⵇⵓⴱ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵏⴻⵖ!’” ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⴰⴷ ⵜ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ ⵙ ⴰⵔⵔⵉⵖⴰⵍⵓ-ⵢⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵣⴰⵜ ⵉⵏⵓ. ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⴱⴰⵍⴰⴽ ⴰⴷ ⵉⵇⴱⴻⵍ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵣⵣⴰⵜⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN32_22","002_32_22","GEN","32","22","22","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵣⵣⴰⵔ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⴰⵎ ⵉⵙⵙⴻⵏⵙ ⵏⴻⵜⵜⴰ ⴵⵉⵔⴻⵜ ⵏⵏⵉ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN32_23","002_32_23","GEN","32","23","23","ⵉⴽⴽⴰⵔ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵓⵛⴰ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵙ ⴷ ⵃⵉⵟⴰⵛ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵥⵡⴰ ⴰⵎⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵢⴰⴱⴱⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("GN32_24","002_32_24","GEN","32","24","24","ⵢⵉⵡⵢⵉ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵥⵡⴰ ⵜⴻⵏ ⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉⵙⵙⴻⵄⴷⵓ ⵜ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("GN32_25","002_32_25","GEN","32","25","25","ⵎⴰⵛⴰ ⵉⵇⵇⵉⵎ ⵢⴰⵄⵇⵓⴱ ⵡⴻⵃⵃⴷⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵖⵣⴻⵍ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵍⵎⵉ ⴷ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⴻⴼⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN32_26","002_32_26","GEN","32","26","26","ⵓⵎⵉ ⵉⵥⵔⴰ ⵡⴰⵏⵉⵜⴰ ⴰⵇⴰ ⵡⴰⵔ ⵅⴰⵙ ⵉⵇⴻⴷⴷ ⵛⴰ, ⵉⵃⴰⴷⴰ ⵜ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⴻⵎⵇⵉⵇⵇⴻⵛⵜ ⵏ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴻⵏⵅⵓⵅⴻⵔ ⵜⴰⵎⵇⵉⵇⵇⴻⵛⵜ ⵏ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓⵎⵉ ⴽⵉⴷⴻⵙ ⵜⵓⵖⴰ ⵉⵜⵜⵎⵓⵖⵣⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("GN32_27","002_32_27","GEN","32","27","27","ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ, ⴰⵇⴰ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⴱⴰⵔⴽⴻⴷ ⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN32_28","002_32_28","GEN","32","28","28","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("GN32_29","002_32_29","GEN","32","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⴰⵛⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵡⴷⴰⵏ, ⵓⵛⴰ ⵛⴻⴽ ⵜⵖⴻⵍⴱⴻⴷ.”    ");
INSERT INTO rift_vpl VALUES ("GN32_30","002_32_30","GEN","32","30","30","ⵉⵙⵙⴻⵇⵙⴰ ⵢⴰⵄⵇⵓⴱ ⵅⴻⵏⵏⵉ, ⵉⵏⵏⴰ: “ⵉⵏⵉ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⵉⵙⴻⵎ ⵏⵏⴻⵛ!” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⵅ ⵢⵉⵙⴻⵎ ⵉⵏⵓ?” ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN32_31","002_32_31","GEN","32","31","31","ⵓⵛⴰ ⵉⵙⴻⵎⵎⴰ ⵢⴰⵄⵇⵓⴱ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⴼⴰⵏⵓⵡⵉⵍ, ⵉⵏⵏⴰ: “ⵎⵉⵏⵣⵉ ⵥⵔⵉⵖ ⴰⵔⴻⴱⴱⵉ ⴰⵖⴻⵎⴱⵓⴱ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵓⵛⴰ ⵉⵏⵊⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN32_32","002_32_32","GEN","32","32","32","ⵜⴻⵏⵇⴰⵔ-ⴷⴷ ⵅⴰⵙ ⵜⴼⵓⵛⵜ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵄⴷⵓ ⵅ ⴼⴰⵏⵓⵡⵉⵍ, ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵉⵜⵜⵣⴻⵃⵃⴻⴼ ⵣⵉ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN32_33","002_32_33","GEN","32","33","33","ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⴰⵙⵙ-ⴰ ⵣⴻⴳ ⵡⴻⵥⵡⴰⵔ ⵉⴳⴷⴰⵔⴻⵏ ⵉ ⵉⵜⵜⴻⴽⴽⴻⵏ ⵅ ⵜⴻⵎⵇⵉⵇⵇⴻⵛⵜ ⵏ ⵜⵎⴻⵚⵚⴰⴹⵜ, ⵎⵉⵏⵣⵉ ⵉⵃⴰⴷⴰ ⵜⴰⵎⴻⵚⵚⴰⴹⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵥⵡⴰⵔ ⵉⴳⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN33_1","002_33_1","GEN","33","1","1","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵢⴰⵄⵇⵓⴱ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵥⵔⴰ ⵄⵉⵙⵓ ⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵅⴻⵛⵛⴻⵏ-ⴷⴷ. ⵉⴼⴰⵔⵇ ⵢⴰⵄⵇⵓⴱ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵅ ⵍⵉⵢⴰ ⴷ ⵔⴰⵃⵉⵍ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN33_2","002_33_2","GEN","33","2","2","ⵉⴳⴳⴰ ⵜⵉⵢⵢⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏⵜ ⵖⴰⵔ ⵣⵣⴰⵜ, ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ ⵍⵉⵢⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓ ⵔⴰⵃⵉⵍ ⴷ ⵢⵓⵙⵓⴼ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN33_3","002_33_3","GEN","33","3","3","ⵓⵎⵉ ⵉⵄⴷⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵉⴱⴻⵏⴷⴻⵇ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN33_4","002_33_4","GEN","33","4","4","ⵄⵉⵙⵓ ⵢⵓⵣⵣⴻⵍ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵍⵇⴰ, ⵉⴷⴰⵔⵔⴻⵄ ⴰⵙ, ⵉⵏⴳⴻⵣ ⴰⵙ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ ⵓⵛⴰ ⵔⵓⵏ ⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN33_5","002_33_5","GEN","33","5","5","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵣⴻⴳ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN33_6","002_33_6","GEN","33","6","6","ⵓⵛⴰ ⵔⴻⵃⵃⴳⴻⵏⵜ-ⵉ-ⴷⴷ ⵜⵉⵢⵢⴰ, ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏⵜ, ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN33_7","002_33_7","GEN","33","7","7","ⵜⵔⴻⵃⵃⴻⴳ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵍⵉⵢⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵢⵓⵙⵓⴼ ⴷ ⵔⴰⵃⵉⵍ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN33_8","002_33_8","GEN","33","8","8","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴽ-ⴷ ⵓⴱⴰⵔⵔⵓ-ⵢⴰ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵍⵇⵉⵖ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ ⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN33_9","002_33_9","GEN","33","9","9","ⵉⵏⵏⴰ ⵄⵉⵙⵓ: “ⴰⵇⴰ ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ, ⵓⵎⴰ ⵉⵏⵓ! ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵛⴻⴽ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN33_10","002_33_10","GEN","33","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ: “ⵍⵍⴰ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ! ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⵍⴻⵅⵅⵓ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴽⵙⵉ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵉⵏⵓ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵥⵔⵉⵖ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⵅⵎⵉ ⵥⵔⵉⵖ ⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵇⴻⴱⵍⴻⴷ ⵅⴰⴼⵉ ⵙ ⵍⴻⵎⵍⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN33_11","002_33_11","GEN","33","11","11","ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⴽⵙⵉ ⵍⴱⴰⵔⴰⴽⴰ ⵉⵏⵓ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⵡⵢⴻⵖ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵚⵓⵔⵔⵓⴼ ⴰⴽⵉⴷⵉ ⵙ ⴰⵔⴹⴰ ⵓⵛⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴽⵓⵍⵛⵉ.” ⵉⴽⴻⵍⵍⴻⴼ ⵉ-ⵜ ⵓⵛⴰ ⵉⴽⵙⵉ ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN33_12","002_33_12","GEN","33","12","12","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴼⵙⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵖ, ⴰⴷ ⵏⵔⴰⵃ. ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵣⵣⴰⵜⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN33_13","002_33_13","GEN","33","13","13","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ-ⴰ ⴰⵔⴻⵀⴼⴻⵏ ⵓ ⴰⵇⴰ ⵖⴰⵔⵉ ⵓⴵⵉ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓⵔⵡⴻⵏⵜ ⵙⵙⵓⵟⵟⵓⴹⴻⵏⵜ. ⵎⴰⵍⴰ ⴱⵏⴰⴷⴻⵎ ⵉⵣⴻⵢⵢⴰⵔ ⵅⴰⵙⴻⵏⵜ ⴰⵟⵟⴰⵙ, ⵡⴰⵅⵅⴰ ⵎⵖⵉⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⴰⴷ ⵉⵎⵎⴻⵜ ⵡⵓⴵⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN33_14","002_33_14","GEN","33","14","14","ⴰⴷ ⵉⵄⴷⵓ ⵍⴻⵅⵅⵓ ⵙⵉⴷⵉ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵛⵡⴰⵢⵜ ⵛⵡⴰⵢⵜ ⴰⴽ-ⴷ ⵉⵚⵓⵔⴰⴼ ⵏ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜⵉ ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵚⵓⵔⴰⴼ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⴰⵍ ⴷⴷ ⵖⴰ ⴰⵡⴹⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷⵉ ⵙⴰⵄⵉⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN33_15","002_33_15","GEN","33","15","15","ⵉⵏⵏⴰ ⵄⵉⵙⵓ: “ⴰⴷ ⵊⵊⴻⵖ ⵍⴻⵅⵅⵓ ⴰⴽⵉⴷⴻⴽ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵉ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵓⵎⵉ ⴷⴷⴻⴳⴳⴰ? ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN33_16","002_33_16","GEN","33","16","16","ⵉⵄⵇⴻⴱ-ⴷⴷ ⵄⵉⵙⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵙⴰⵄⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN33_17","002_33_17","GEN","33","17","17","ⵓⵛⴰ ⵉⴼⵙⵉ ⵢⴰⵄⵇⵓⴱ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵙⵓⴽⴽⵓⵜ, ⵉⴱⵏⴰ ⴷⵉⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵏ ⵜⵙⴻⵟⵟⴰ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵙ. ⵅ ⵓⵢⴰ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵙⵓⴽⴽⵓⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵉⵄⵓⵛⵛⵓⵜⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("GN33_18","002_33_18","GEN","33","18","18","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵢⴰⵄⵇⵓⴱ ⵣⵉ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵛⴰⵍⵉⵎ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵛⴰⴽⵉⵎ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵓⵛⴰ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN33_19","002_33_19","GEN","33","19","19","ⵉⵙⵖⴰ ⵟⵟⴰⵔⴼ ⵏ ⵢⴻⵢⵢⴰⵔ ⵎⴰⵏⵉ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵃⴰⵎⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⴽⵉⵎ, ⵙ ⵎⵢⴰ ⵏ ⵉⵣⵉⵢⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵡⴻⵣⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN33_20","002_33_20","GEN","33","20","20","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵎⵎⴰⵔⵙ ⵜⵖⴰⵔⵚⵜ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ: ‘ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("GN34_1","002_34_1","GEN","34","1","1","ⴷⵉⵏⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵍⵉⵢⴰ, ⵜⴻⵏⵏⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵜⴻⴼⴼⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵍⵇⴰ ⴰⴽ-ⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN34_2","002_34_2","GEN","34","2","2","ⵛⴰⴽⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵎⵓⵔ ⴰⵃⵉⵡⵉ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ, ⵉⵥⵔⴰ ⵉ-ⵜⵜ, ⵉⴽⵙⵉ ⵜⵜ ⵓⵛⴰ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ, ⵉⵙⵙⴻⵅⵙⴰⵔ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("GN34_3","002_34_3","GEN","34","3","3","ⵉⵟⵟⴰⵔⴱⴻⵟ ⴷⵉ ⴷⵉⵏⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⵜⴰⴱⵍⵉⵖⵜ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⵜⴻⴱⵍⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("GN34_4","002_34_4","GEN","34","4","4","ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰⴽⵉⵎ ⵖⴰⵔ ⵃⴰⵎⵓⵔ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵡⵢⵉ ⴰⵢⵉ-ⴷⴷ ⵜⴰⴱⵍⵉⵖⵜ-ⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN34_5","002_34_5","GEN","34","5","5","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵄⵇⵓⴱ ⴱⴻⵍⵍⵉ ⵛⴰⴽⵉⵎ ⵉⴹⴻⵢⵢⴻⵄ ⵛⵛⴰⵔⴰⴼ ⵏ ⵢⴻⴵⵉⵙ ⴷⵉⵏⴰ, ⵜⵓⵖⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵉⵙⵙⵓⵙⴻⵎ ⵢⴰⵄⵇⵓⴱ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN34_6","002_34_6","GEN","34","6","6","ⵉⵔⵓⵃ ⵃⴰⵎⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⴽⵉⵎ ⵖⴰⵔ ⵢⴰⵄⵇⵓⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN34_7","002_34_7","GEN","34","7","7","ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⴰⵔⴻⴳⴳⴱⴻⵏ ⵅ ⵍⴻⵅⴱⴰⵔ. ⵅⴻⵢⵢⵇⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍ ⵓ ⴼⴼⵓⴳⵎⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵉⴳⴳⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ-ⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵄⵇⵓⴱ. ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵜ ⵢⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("GN34_8","002_34_8","GEN","34","8","8","ⵉⵙⵙⵉⵡⴻⵍ ⵃⴰⵎⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵍⴻⵄⵎⴰⵔ ⵏ ⵎⵎⵉ ⵛⴰⴽⵉⵎ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵢⴻⴵⵉⵜⵡⴻⵎ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ, ⴰⴷ ⴰⵙ ⵜⵜ ⵜⴻⵡⵛⴻⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("GN34_9","002_34_9","GEN","34","9","9","ⵓⵛⴰ ⴰⴷ ⵏⴻⵎⴹⴻⴳⴳⵡⴰⵍ. ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵛⴻⵎ ⵢⴻⴵⵉⵜⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN34_10","002_34_10","GEN","34","10","10","ⵣⴻⴷⵖⴻⵎ ⴰⴽⵉⴷⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ-ⵜⵜ ⵣⵣⴰⵜⵡⴻⵎ. ⵣⴻⴷⵖⴻⵎ ⵓ ⵓⵢⵓⵔⴻⵎ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵟⵟⴼⴻⵎ ⴷⴰⵢⴻⵙ ⴰⴳⵍⴰ ⵉ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("GN34_11","002_34_11","GEN","34","11","11","ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⴽⵉⵎ ⵄⴰⵡⴻⴷ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⵉⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN34_12","002_34_12","GEN","34","12","12","ⵡⴰⵅⵅⴰ ⴰⴷ ⵜⴻⵙⵙⴹⴻⵇⵍⴻⵎ ⵅⴰⴼⵉ ⵍⴻⵃⵎⴻⵍ ⴰⵟⵟⴰⵙ ⵏ ⵚⵚⴰⴷⴰⵇ ⴷ ⵙⵙⵓⵏⴰⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⵉⵏⵉⵎ. ⵡⵛⴻⵎ ⴰⵢⵉ ⵎⵖⵉⵔ ⵜⴰⴱⵍⵉⵖⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN34_13","002_34_13","GEN","34","13","13","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ ⵅ ⵛⴰⴽⵉⵎ ⴷ ⵃⴰⵎⵓⵔ, ⴱⴰⴱⴰⵙ, ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵙⵙⴻⵅⵙⴰⵔ ⴷⵉⵏⴰ, ⵓⵍⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN34_14","002_34_14","GEN","34","14","14","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⴳⴳ ⴰⵎⵎⵓ, ⴰⴷ ⵏⴻⵡⵛ ⵓⵍⵜⵎⴰⵜⵏⴻⵖ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵄⴰⴷ ⵙ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ. ⴷⴻⴳⴳⴰ ⴷ ⵍⵄⴰⵔ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN34_15","002_34_15","GEN","34","15","15","ⵎⵖⵉⵔ ⵙ ⵓⵎⵜⴰⵡⵉ-ⵢⴰ ⵡⴰⵀⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⵙⴻⵄⵄⴻⴼ, ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⵎ ⴰⵎ ⵏⴻⵛⵛⵉⵏ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN34_16","002_34_16","GEN","34","16","16","ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵏⴻⵡⵛ ⵢⴻⴵⵉⵜⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⴻⴽⵙⵉ ⵢⴻⵙⵙⵉⵜⵡⴻⵎ, ⴰⴷ ⴽⵉⴷⵡⴻⵏ ⵏⴻⵣⴷⴻⵖ, ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("GN34_17","002_34_17","GEN","34","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵍⵉⵎ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵡⴻⵅⵜⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⴽⵙⵉ ⵢⴻⴵⵉⵜⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⵓⵢⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN34_18","002_34_18","GEN","34","18","18","ⴱⴰⵏⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⵎⵍⵉⵃ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵃⴰⵎⵓⵔ ⵓ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⵛⴰⴽⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("GN34_19","002_34_19","GEN","34","19","19","ⴰⵄⴻⵣⵔⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵛⵇⵉ ⴰⴷ ⵉⴳⴳ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵟⵟⴰⵙ ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⵇⴰⵄ ⵎⵡⴻⵇⵇⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN34_20","002_34_20","GEN","34","20","20","ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵃⴰⵎⵓⵔ ⴷ ⵎⵎⵉⵙ ⵛⴰⴽⵉⵎ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("GN34_21","002_34_21","GEN","34","21","21","“ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⴷ ⵉⵎⵀⵓⴷⵏⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⴻⵊⵊ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵓⵢⵓⵔⴻⵏ. ⵅⵣⴰⵔ, ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵡⵙⴻⵄ ⵉ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴽⵙⵉ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⴰⴷ ⴰⵙⴻⵏ ⵏⴻⵡⵛ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN34_22","002_34_22","GEN","34","22","22","ⵎⴰⵛⴰ ⵙ ⵓⵎⵜⴰⵡⵉ-ⵢⴰ ⵡⴰⵀⴰ ⴰⴷ ⵙⴻⵄⵄⴼⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵣⴻⴷⵖⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⴽⵉⴷⵏⴻⵖ, ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⴰⴷ ⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN34_23","002_34_23","GEN","34","23","23","ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏⵙⴻⵏ, ⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵏⵏⴻⵖ? ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⵙⴻⵄⵄⴻⴼ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN34_24","002_34_24","GEN","34","24","24","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵙⵍⵉⵏ ⵉ ⵃⴰⵎⵓⵔ ⴷ ⵎⵎⵉⵙ ⵛⴰⴽⵉⵎ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN34_25","002_34_25","GEN","34","25","25","ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵍⴻⵀⵔⵉⵇ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵜⴻⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵛⵉⵎⵄⵓⵏ ⴷ ⵍⴰⵡⵉ, ⴰⵢⵜⵎⴰⵙ ⵏ ⴷⵉⵏⴰ, ⴰⵇⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴽⵙⵉ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN34_26","002_34_26","GEN","34","26","26","ⵏⵖⵉⵏ ⵃⴰⵎⵓⵔ ⴷ ⵎⵎⵉⵙ ⵛⴰⴽⵉⵎ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⴽⵙⵉⵏ ⴷⵉⵏⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⴽⵉⵎ, ⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN34_27","002_34_27","GEN","34","27","27","ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵓⵛⴰ ⴽⴻⵛⵛⴹⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵅⵙⴰⵔⴻⵏ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN34_28","002_34_28","GEN","34","28","28","ⴽⵙⵉⵏ ⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵙⴻⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN34_29","002_34_29","GEN","34","29","29","ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵓⵛⴰ ⵓⵛⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⵉ ⵜⵓⴷⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN34_30","002_34_30","GEN","34","30","30","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵛⵉⵎⵄⵓⵏ ⴷ ⵍⴰⵡⵉ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⴰⵢⵉ ⴷⴻⴳ ⵉⵎⵅⵓⵎⴱⴰⵔ ⴰⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴰⵔⵣⴳⴻⵎ ⵖⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ. ⴷ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵡⴰⵀⴰ. ⵎⴰⵍⴰ ⴰⴷ ⵎⵓⵏⴻⵏ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵉⵏⵓ, ⴰⴷ ⴰⵢⵉ ⵇⴻⵥⵥⵔⴻⵏ, ⴰⴷ ⵉⵍⵉⵖ ⴰⵔⴻⵢⵢⵜⴻⵖ, ⵏⴻⵛⵛ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN34_31","002_34_31","GEN","34","31","31","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵃⵙⴻⴱ ⵓⵍⵜⵎⴰⵜⵏⴻⵖ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵛⵜ ⵏ ⵍⴼⴰⵙⴷⴰ?” ");
INSERT INTO rift_vpl VALUES ("GN35_1","002_35_1","GEN","35","1","1","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⴽⴽⴰⵔ, ⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⵓⵛⴰ ⵇⵇⵉⵎ ⴷⵉⵏ. ⴻⴳⴳ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵎⵉⵏ ⵅⴻⴼ ⵉ ⵖⴰ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⴱⴰⵏⴻⵏ ⵓⵎⵉ ⴷⴷ-ⵜⴰⵔⴻⵡⵍⴻⴷ ⵣⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵎⴰⵛ ⵄⵉⵙⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN35_2","002_35_2","GEN","35","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵍⵡⴰⵛⵓⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ: “ⴽⴽⵙⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵙⵉⵣⴻⴷⴳⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⴱⴻⴷⴷⵍⴻⵎ ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN35_3","002_35_3","GEN","35","3","3","ⴰⴷ ⵏⴻⴽⴽⴰⵔ, ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵓⵢⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN35_4","002_35_4","GEN","35","4","4","ⵓⵛⴰ ⵡⵛⵉⵏ ⵉ ⵢⴰⵄⵇⵓⴱ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵓⵍⴰ ⴷ ⵜⵉⵅⵔⴰⵣⵉⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ ⵢⴰⵄⵇⵓⴱ ⵙⴰⴷⵓ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵜ ⵉ ⵛⴰⴽⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN35_5","002_35_5","GEN","35","5","5","ⵍⴰⵎⵉ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ, ⵓⵢⵓⵔⴻⵏ ⵙⵙⴻⵏⵏⵉ, ⵜⵓⵖⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN35_6","002_35_6","GEN","35","6","6","ⴰⵎⵎⵓ ⵉ ⵢⵉⵡⴻⴹ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⵍⵓⵣ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴱⴰⵢⵜ-ⵉⵍ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN35_7","002_35_7","GEN","35","7","7","ⵉⴱⵏⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉⵍ-ⴱⴰⵢⵜ-ⵉⵍ, ⵎⵉⵏⵣⵉ ⴷⵉⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⴹⵀⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵓⵎⵉ ⴷⴷ-ⵢⴰⵔⵡⴻⵍ ⵣⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN35_8","002_35_8","GEN","35","8","8","ⵜⴻⵎⵎⵓⵜ ⴷⵉⴱⵓⵔⴰ, ⵜⴰⵎⴻⵙⵙⴻⵟⵟⴰⴹⵜ ⵏ ⵔⵉⴼⵇⴰ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜⵜ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵙⴰⴷⵓ ⵜⴰⴱⴻⴵⵓⴹⵜ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ‘ⴰⵍⵍⵓⵏ-ⴱⴰⴽⵓⵜ’, ⴰⵇⴰ-ⵜⵜ ⴷ ‘ⵜⴰⴱⴻⴵⵓⴹⵜ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("GN35_9","002_35_9","GEN","35","9","9","ⵉⴹⵀⴰⵔ ⴰⵙ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⴰⵄⵇⵓⴱ ⵓⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵣⵉ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN35_10","002_35_10","GEN","35","10","10","ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ: “ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷ ⵢⴰⵄⵇⵓⴱ. ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵄⴰⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ‘ⵢⴰⵄⵇⵓⴱ’, ⵎⴰⵛⴰ ‘ⵉⵙⵔⴰⵉⵍ’, ⴷ ⵡⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ⵓⵛⴰ ⵉⵙⴻⵎⵎⴰ ⵜ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN35_11","002_35_11","GEN","35","11","11","ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ: “ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ! ⴻⴳⴳ ⵍⵖⵉⴵⴻⵜ, ⵎⵎⴰⵔⵏⵉⵢ! ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ, ⵡⴰⵀ, ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⴽ ⵓ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN35_12","002_35_12","GEN","35","12","12","ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵉ ⵡⵛⵉⵖ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ, ⵉ ⵛⴻⴽ ⵓⵎⵉ ⵜⵜ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵓⵛⴰ ⵓⵍⴰ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN35_13","002_35_13","GEN","35","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵙⴻⵏⵏⴻⵊ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN35_14","002_35_14","GEN","35","14","14","ⵢⴰⵄⵇⵓⴱ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⴽⵉⵙ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ. ⵉⵙⴻⵢⵢⴻⴱ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵓⵛⴰ ⵉⴼⴰⵔⵔⴻⵖ ⵣⵣⴻⵛⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN35_15","002_35_15","GEN","35","15","15","ⵉⴳⴳⴰ ⵢⴰⵄⵇⵓⴱ ⵉⵙⴻⵎ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ‘ⴱⴰⵢⵜ-ⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("GN35_16","002_35_16","GEN","35","16","16","ⴼⴻⵙⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵓⵛⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⵡⵉⵊⴻⵏ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵅ ⵉⴼⵔⴰⵜⴰ, ⵅⴻⵏⵏⵉ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵔⴰⵃⵉⵍ ⵓ ⵜⴻⵄⴷⵓ ⵅⴰⵙ ⵜⴰⵔⵡⴰ ⵜⴻⵇⵙⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("GN35_17","002_35_17","GEN","35","17","17","ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵜⴻⵖⵖⵓⴹⴻⴷ ⴷⵉ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ ⵍⵇⴰⴱⵍⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⴰⵇⴰ ⵡⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵎⵎⵉⵎ!” ");
INSERT INTO rift_vpl VALUES ("GN35_18","002_35_18","GEN","35","18","18","ⵍⴰⵎⵉ ⵜⴻⴹⵍⴻⵇ ⵉ ⴱⵓⵃⴱⴻⵍ ⴰⵎ ⵜⴻⵎⵎⵓⵜ ⴷⵉⵏ, ⴰⵇⴰ ⵜⵍⴰⵖⴰ ⴰⵙ ⴱⵉⵏ-ⵓⵏⵉ, ⵉⵙⴻⵎ-ⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵎⵎⵉⵙ ⵏ ⵍⴻⵃⵔⵉⵇ ⵉⵏⵓ’, ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⵉⵍⴰⵖⴰ ⴰⵙ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵎⵎⵉⵙ ⵏ ⵣⵣⵀⴰⵔ ⵉⵏⵓ’. ");
INSERT INTO rift_vpl VALUES ("GN35_19","002_35_19","GEN","35","19","19","ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵎⵓⵜ ⵔⴰⵃⵉⵍ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏⵜ ⵜⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵉⴼⵔⴰⵜⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("GN35_20","002_35_20","GEN","35","20","20","ⵓⵛⴰ ⵉⴳⴳⴰ ⵢⴰⵄⵇⵓⴱ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵅ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ. ⴷ ⵡⴰ ⴷ ⴰⵥⵔⵓ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⵔⴰⵃⵉⵍ ⵅ ⵡⴻⵏⴹⴻⵍ ⵏ ⵔⴰⵃⵉⵍ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN35_21","002_35_21","GEN","35","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⴼⵙⵉ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵓⵛⴰ ⵉⵡⵜⴰ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⵅ ⵓⵄⴻⴷⴷⵓ ⵏ ⵎⴰⵊⴷⴰⵍ-ⵄⵉⴷⵔ. ");
INSERT INTO rift_vpl VALUES ("GN35_22","002_35_22","GEN","35","22","22","ⵓⵎⵉ ⵉⵣⴷⴻⵖ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵔⵓⴱⵉⵏ ⵉⵔⵓⵃ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⴱⵉⵍⵀⴰ, ⵜⴰⵢⵢⴰ ⵏ ⴱⴰⴱⴰⵙ, ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⴰⴷ ⵜ ⵉⴼⵀⴻⵎ ⵉⵙⵔⴰⵉⵍ. ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵉⵡⴹⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵜⴻⵏⵄⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN35_23","002_35_23","GEN","35","23","23","ⵜⴰⵔⵡⴰ ⵏ ⵍⵉⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵔⵓⴱⵉⵏ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵛⵉⵎⵄⵓⵏ ⴷ ⵍⴰⵡⵉ ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵙⴰⴽⴰⵔ ⴷ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN35_24","002_35_24","GEN","35","24","24","ⵜⴰⵔⵡⴰ ⵏ ⵔⴰⵃⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵢⵓⵙⵓⴼ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN35_25","002_35_25","GEN","35","25","25","ⵜⴰⵔⵡⴰ ⵏ ⴱⵉⵍⵀⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵔⴰⵃⵉⵍ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⴷⴰⵏ ⴷ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("GN35_26","002_35_26","GEN","35","26","26","ⵜⴰⵔⵡⴰ ⵏ ⵣⵉⵍⴱⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵍⵉⵢⴰ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵊⴰⴷ ⴷ ⴰⵛⵉⵔ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN35_27","002_35_27","GEN","35","27","27","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⴱⴰⴱⴰⵙ ⵉⵙⵃⴰⵇ ⴷⵉ ⵎⴰⵎⵔⵉ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴱⴰⵄ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵃⴰⴱⵔⵓⵏ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵓⵛⴰ ⵉⵙⵃⴰⵇ ⴰⵎⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN35_28","002_35_28","GEN","35","28","28","ⵉⴷⴷⴰⵔ ⵉⵙⵃⴰⵇ ⵎⵢⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN35_29","002_35_29","GEN","35","29","29","ⵉⴹⵍⴻⵇ ⵉⵙⵃⴰⵇ ⵉ ⴱⵓⵃⴱⴻⵍ, ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵉⵡⵙⴰⵔ, ⵉⵊⵊⵉⵡⴻⵏ ⵣⵉ ⵜⵓⴷⴰⵔⵜ, ⵓⵛⴰ ⵄⵉⵙⵓ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⴻⴹⵍⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN36_1","002_36_1","GEN","36","1","1","ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵄⵉⵙⵓ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN36_2","002_36_2","GEN","36","2","2","ⵄⵉⵙⵓ ⵉⴽⵙⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵢⴻⵙⵙⵉⵙ ⵏ ⴽⴻⵏⵄⴰⵏ: ⵄⴰⴷⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵍⵓⵏ, ⴰⵃⵉⵜⵜⵉ, ⴷ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⵏⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵚⴰⴱⵄⵓⵏ, ⴰⵃⵉⵡⵉ, ");
INSERT INTO rift_vpl VALUES ("GN36_3","002_36_3","GEN","36","3","3","ⴷ ⴱⴰⵙⵎⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵏⴰⴱⴰⵢⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("GN36_4","002_36_4","GEN","36","4","4","ⵄⴰⴷⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵍⵉⴼⴰⵣ ⵉ ⵄⵉⵙⵓ ⵓⵛⴰ ⴱⴰⵙⵎⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵔⴰⵄⵓⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN36_5","002_36_5","GEN","36","5","5","ⴰⵀⵓⵍⵉⴱⴰⵎⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵢⴰⵄⵓⵙ ⴷ ⵢⴰⵄⵍⴰⵎ ⴷ ⵇⵓⵔⴰⵃ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⵉⵙⵓ, ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_6","002_36_6","GEN","36","6","6","ⵓⵛⴰ ⵉⴽⵙⵉ ⵄⵉⵙⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵢⴻⵙⵙⵉⵙ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴽⵙⴻⴱ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓⵛⴰ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖⵏⵉ ⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵎⴰⵙ ⵢⴰⵄⵇⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("GN36_7","002_36_7","GEN","36","7","7","ⵎⵉⵏⵣⵉ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵎⵖⴰⵔ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⵊⵎⵉⵄ, ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵎ ⵍⴱⴰⵔⵔⴰⵏⵉ, ⵡⴰⵔ ⵜⵇⴻⴷⴷ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_8","002_36_8","GEN","36","8","8","ⵅⴻⵏⵏⵉ ⵉⵣⴷⴻⵖ ⵄⵉⵙⵓ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ. ⵄⵉⵙⵓ, ⵏⴻⵜⵜⴰ ⴷ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN36_9","002_36_9","GEN","36","9","9","ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵄⵉⵙⵓ, ⴱⴰⴱⴰⵙ ⵏ ⵉⴷⵓⵎ, ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN36_10","002_36_10","GEN","36","10","10","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⵉⵙⵓ: ⵉⵍⵉⴼⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴷⴰ ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ, ⵔⴰⵄⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵙⵎⴰⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN36_11","002_36_11","GEN","36","11","11","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵍⵉⴼⴰⵣ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵜⴰⵢⵎⴰⵏ, ⵓⵎⴰⵔ, ⵚⴰⴼⵓ, ⵊⴰⵄⵜⴰⵎ ⴷ ⵇⴰⵏⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("GN36_12","002_36_12","GEN","36","12","12","ⵜⵉⵎⵏⴰⵄ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵢⵢⴰ ⵏ ⵉⵍⵉⴼⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵙⵓ, ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵄⴰⵎⴰⵍⵉⵇ ⵉ ⵉⵍⵉⴼⴰⵣ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⴷⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN36_13","002_36_13","GEN","36","13","13","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⴰⵄⵓⵡⵉⵍ: ⵏⴰⵃⴰⵜ, ⵣⴰⵔⴰⵃ, ⵛⴰⵎⵎⴰ ⴷ ⵎⵉⵣⵣⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⵙⵎⴰⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN36_14","002_36_14","GEN","36","14","14","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⵏⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵣⵉⴱⵢⵓⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵢⴰⵄⵓⵛ, ⵊⴰⵄⵍⴰⵎ ⴷ ⵇⵓⵔⴰⵃ ⵉ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN36_15","002_36_15","GEN","36","15","15","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵄⵉⵙⵓ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵍⵉⴼⴰⵣ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵄⵉⵙⵓ: ⴰⵎⵖⴰⵔ ⵜⵉⵎⴰⵏ ⴷ ⵓⵎⵖⴰⵔ ⵓⵎⴰⵔ ⴷ ⵓⵎⵖⴰⵔ ⵚⴰⴼⵓ ⴷ ⵓⵎⵖⴰⵔ ⵇⵉⵏⴰⵣ, ");
INSERT INTO rift_vpl VALUES ("GN36_16","002_36_16","GEN","36","16","16","ⴷ ⵓⵎⵖⴰⵔ ⵇⵓⵔⴰⵃ, ⴷ ⵓⵎⵖⴰⵔ ⴳⴰⵜⴰⵎ, ⴷ ⵓⵎⵖⴰⵔ ⵄⴰⵎⴰⵍⵉⵇ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵍⵉⴼⴰⵣ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ, ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("GN36_17","002_36_17","GEN","36","17","17","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⴰⵄⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵙⵓ: ⴰⵎⵖⴰⵔ ⵏⴰⵃⴰⵜ ⴷ ⵓⵎⵖⴰⵔ ⵣⴰⵔⴰⵃ ⴷ ⵓⵎⵖⴰⵔ ⵙⴰⵎⵎⴰ ⴷ ⵓⵎⵖⴰⵔ ⵎⵉⵣⵣⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵔⴰⵄⵓⵡⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ, ⴷ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⵙⵎⴰⵜ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("GN36_18","002_36_18","GEN","36","18","18","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ: ⴰⵎⵖⴰⵔ ⵢⴰⵄⵓⵛ ⴷ ⵓⵎⵖⴰⵔ ⵢⴰⵄⵍⴰⵎ ⴷ ⵓⵎⵖⴰⵔ ⵇⵓⵔⴰⵃ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⵉⵙⵓ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN36_19","002_36_19","GEN","36","19","19","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⵉⵙⵓ ⴷ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN36_20","002_36_20","GEN","36","20","20","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵙⴰⵄⵉⵔ, ⴰⵅⵓⵔⵉ, ⵉⵏⵏⵉ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ: ⵍⵓⵟⴰⵏ, ⵛⵓⴱⴰⵍ, ⵚⴰⴱⵄⵓⵏ, ⵄⴰⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("GN36_21","002_36_21","GEN","36","21","21","ⴷⵉⵛⵓⵏ, ⵉⵚⴰⵔ ⴷ ⴷⵉⵛⴰⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵅⵓⵔⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⵙⴰⵄⵉⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN36_22","002_36_22","GEN","36","22","22","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⵓⵟⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵅⵓⵔⵉ ⴷ ⵀⴰⵢⵎⴰⵎ ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⵉⵎⵏⴰⵄ ⴷ ⵓⵍⵜⵎⴰⵙ ⵏ ⵍⵓⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_23","002_36_23","GEN","36","23","23","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵛⵓⴱⴰⵍ: ⵄⴰⵍⵡⴰⵏ, ⵎⴰⵏⴰⵃⴰⵜ, ⵄⵉⴱⴰⵍ, ⵛⴰⴼⵓ ⴷ ⵓⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN36_24","002_36_24","GEN","36","24","24","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⴰⴱⵄⵓⵏ: ⴰⵢⴰ ⴷ ⵄⴰⵏⴰ. ⴷ ⵄⴰⵏⴰ ⵡⴰⵏⵉⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⵢⵓⴼⵉⵏ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵙ ⵡⴰⵎⴰⵏ ⵉⵃⵎⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵓⵎⵉ ⵢⴰⵔⵡⴻⵙ ⵉⵖⵢⴰⵍ ⵏ ⵣⵉⴱⵉⵢⵓⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN36_25","002_36_25","GEN","36","25","25","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵏⴰ: ⵎⵖⵉⵔ ⴷⵉⵛⵓⵏ, ⴷ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN36_26","002_36_26","GEN","36","26","26","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⵉⵛⴰⵏ: ⵃⴰⵎⴷⴰⵏ ⴷ ⴰⵀⴱⴰⵏ ⴷ ⵢⵉⵜⵔⴰⵏ ⴷ ⴽⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_27","002_36_27","GEN","36","27","27","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵚⴰⵔ: ⴱⵉⵍⵀⴰⵏ, ⵣⴰⵄⵡⴰⵏ ⴷ ⵄⴰⵇⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_28","002_36_28","GEN","36","28","28","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⵉⵛⴰⵏ: ⵄⵓⵚ ⴷ ⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_29","002_36_29","GEN","36","29","29","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵅⵓⵔⵉⵢⵢⴻⵏ: ⴰⵎⵖⴰⵔ ⵍⵓⵟⴰⵏ ⴷ ⵓⵎⵖⴰⵔ ⵛⵓⴱⴰⵍ ⴷ ⵓⵎⵖⴰⵔ ⵚⴰⴱⵄⵓⵏ ⴷ ⵓⵎⵖⴰⵔ ⵄⴰⵏⴰ ");
INSERT INTO rift_vpl VALUES ("GN36_30","002_36_30","GEN","36","30","30","ⴷ ⵓⵎⵖⴰⵔ ⴷⵉⵛⵓⵏ ⴷ ⵓⵎⵖⴰⵔ ⵉⵚⴰⵔ ⴷ ⵓⵎⵖⴰⵔ ⴷⵉⵛⴰⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵅⵓⵔⵉⵢⵢⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⴰⵄⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN36_31","002_36_31","GEN","36","31","31","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⵃⴻⴽⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵓⵊⴻⴵⵉⴷ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("GN36_32","002_36_32","GEN","36","32","32","ⴱⵉⵍⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⵉⵃⴽⴻⵎ ⴷⵉ ⵉⴷⵓⵎ ⵓⵛⴰ ⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷ ⴷⵉⵏⵀⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("GN36_33","002_36_33","GEN","36","33","33","ⵉⵎⵎⵓⵜ ⴱⵉⵍⴰⵄ ⵓⵛⴰ ⵢⵓⴱⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ ⵣⵉ ⴱⵓⵚⵔⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN36_34","002_36_34","GEN","36","34","34","ⵢⵓⴱⴰⴱ ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵃⵓⵛⴰⵎ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵜⴰⵢⵎⴰⵏⵉⵢⵢⴻⵏ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN36_35","002_36_35","GEN","36","35","35","ⵉⵎⵎⵓⵜ ⵃⵓⵛⴰⵎ ⵓⵛⴰ ⵀⴰⴷⴰⴷ, ⵎⵎⵉⵙ ⵏ ⴱⴰⴷⴰⴷ, ⵡⴻⵏⵏⵉ ⵉⵖⴻⵍⴱⴻⵏ ⵅ ⵎⵉⴷⵢⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵎⵓ’ⴰⴱ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⴰⵡⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("GN36_36","002_36_36","GEN","36","36","36","ⵉⵎⵎⵓⵜ ⵀⴰⴷⴰⴷ ⵓⵛⴰ ⵙⴰⵎⵍⴰ ⵣⵉ ⵎⴰⵙⵔⵉⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN36_37","002_36_37","GEN","36","37","37","ⵉⵎⵎⵓⵜ ⵙⴰⵎⵍⴰ ⵓⵛⴰ ⵛⴰⵡⵓⵍ, ⵣⵉ ⵔⴰⵃⵓⴱⵓⵜ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN36_38","002_36_38","GEN","36","38","38","ⵉⵎⵎⵓⵜ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⴱⴰⵄⵍ-ⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴽⴱⵓⵔ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN36_39","002_36_39","GEN","36","39","39","ⵉⵎⵎⵓⵜ ⴱⴰⵄⵍ-ⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴽⴱⵓⵔ, ⵓⵛⴰ ⵀⴰⴷⴰⵔ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴼⴰⵄⵓ ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵀⵉⵟⴰⴱ’ⵉⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵎⴰⵟⵔⵉⴷ, ⵢⴻⴵⵉⵙ ⵏ ⵎⴰ-ⴷⴰⵀⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("GN36_40","002_36_40","GEN","36","40","40","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵄⵉⵙⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⴷ ⵉⵎⵓⵛⴰⵏ ⵏⵙⴻⵏ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⴰⵎⵖⴰⵔ ⵜⵉⵎⵏⴰⵄ ⴷ ⵓⵎⵖⴰⵔ ⵄⴰⵍⵡⴰ ⴷ ⵓⵎⵖⴰⵔ ⵢⴰⵜⵉⵜ ");
INSERT INTO rift_vpl VALUES ("GN36_41","002_36_41","GEN","36","41","41","ⴷ ⵓⵎⵖⴰⵔ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ ⴷ ⵓⵎⵖⴰⵔ ⵉⵍⴰ ⴷ ⵓⵎⵖⴰⵔ ⴼⵉⵏⵓⵏ ");
INSERT INTO rift_vpl VALUES ("GN36_42","002_36_42","GEN","36","42","42","ⴷ ⵓⵎⵖⴰⵔ ⵇⴰⵏⴰⵣ ⴷ ⵓⵎⵖⴰⵔ ⵜⴰⵢⵎⴰⵏ ⴷ ⵓⵎⵖⴰⵔ ⵎⵉⴱⵚⴰⵔ ");
INSERT INTO rift_vpl VALUES ("GN36_43","002_36_43","GEN","36","43","43","ⴷ ⵓⵎⵖⴰⵔ ⵎⴰⵊⴷⵉⵢⵉⵍ ⴷ ⵓⵎⵖⴰⵔ ⵄⵉⵔⴰⵎ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⴷⵓⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵎⵓⵛⴰⵏ ⵏⵙⴻⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵎⴻⵍⴽ ⵏⵙⴻⵏ. ⵡⴰⵏⵉⵜⴰ ⴷ ⵉⴷⵓⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵉⴷⵓⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN36_44","002_36_44","GEN","36","44","44","ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⵢⴰⵄⵇⵓⴱ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴱⴰⴱⴰⵙ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ. ⵉⵏⴰ ⴷ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN37_1","002_37_1","GEN","37","1","1","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵢⵓⵙⵓⴼ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵢⴰⵔⵡⴻⵙ ⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ. ⵜⵓⵖⴰ ⵢⵓⵙⵓⴼ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⵉⵍⵀⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵣⵉⵍⴱⴰ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵢⵓⵙⵓⴼ ⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉ ⴱⴰⴱⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN37_2","002_37_2","GEN","37","2","2","ⵓⵛⴰ ⵉⵅⵙ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵙⵓⴼ ⵇⴰⵄ ⵅ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔⴻⵙ ⴷ ⵎⵎⵉⵙ ⵅ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⴰⵔⵔⵓⴹ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN37_3","002_37_3","GEN","37","3","3","ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜⵎⴰⵙ ⴱⴻⵍⵍⵉ ⴱⴰⴱⴰⵙ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⵇⴰⵄ ⵅⴰⵙⴻⵏ, ⵛⴰⵔⵀⴻⵏ ⵜ ⵓⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ ⵄⴰⴷ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN37_4","002_37_4","GEN","37","4","4","ⵓⵛⴰ ⵢⵓⵔⵊⴰ ⵢⵓⵙⵓⴼ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ, ⵉⵄⴰⵡⴷ ⵉ-ⵜⵜ ⵉ ⵢⴰⵢⵜⵎⴰⵙ. ⵙ ⵓⵢⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵛⴰⵔⵀⴻⵏ ⵜ ⵄⴰⴷ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN37_5","002_37_5","GEN","37","5","5","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ ⵍⴻⵅⵅⵓ ⵜⴰⵔⵊⵉⵜ-ⴰ ⵏⵏⵉ ⵓⵔⵊⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("GN37_6","002_37_6","GEN","37","6","6","ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⵏⴻⵜⵜⵛⴻⴷⴷⴰ ⵜⵉⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⴻⵢⵢⴰⵔ. ⵓ ⵅⵣⴰⵔ, ⵜⴰⵇⴻⴱⴱⵉⴹⵜ ⵉⵏⵓ ⵜⴱⴻⴷⴷ, ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⵓ ⵜⵉⵇⴻⴱⴱⵉⴹⵉⵏ ⵏⵡⴻⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏⵜ, ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵜⵇⴻⴱⴱⵉⴹⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN37_7","002_37_7","GEN","37","7","7","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ ⴰⵢⵜⵎⴰⵙ: “ⵎⴰ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⵣⴻⵄⵎⴰ ⵏⵉⵛⴰⵏ ⵅⴰⵏⴻⵖ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵏⵉⵖ ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⵙⴻⴵⴹⴻⴷ ⴷ ⴰⵙⴻⴵⴻⴹ?” ⵓⵛⴰ ⵛⴰⵔⵀⴻⵏ ⵜ ⵄⴰⴷ ⴽⵜⴰⵔ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⵔⵊⴰ ⵏⵏⴻⵙ ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN37_8","002_37_8","GEN","37","8","8","ⵓⵛⴰ ⵢⵓⵔⵊⴰ ⵄⴰⴷ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵖⵏⵉ, ⵉⵄⴰⵡⴷ ⵉ-ⵜⵜ ⵉ ⵢⴰⵢⵜⵎⴰⵙ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵔⵊⵉⵖ ⵄⴰⴷ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵖⵏⵉ. ⵅⵣⴰⵔ ⵜⴰⴼⵓⵛⵜ ⴷ ⵓⵢⵓⵔ ⴷ ⵃⵉⵟⴰⵛ ⵏ ⵉⵜⵔⴰⵏ ⴱⴻⵏⴷⵇⴻⵏ ⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN37_9","002_37_9","GEN","37","9","9","ⵉⵄⴰⵡⴻⴷ ⵉ-ⵜⵜ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏⴰ ⵜⴰⵔⵊⵉⵜ-ⴰ ⵉ ⵜⴰⵔⵊⵉⴷ? ⵎⴰ ⴰⴷ ⴷⴷ-ⵏⴰⵙ ⵊⵎⵉⵄ, ⵏⴻⵛⵛ ⴷ ⵢⴻⵎⵎⴰⵛ ⴷ ⴰⵢⵜⵎⴰⵛ, ⴰⴷ ⴰⵛ ⵏⴱⴻⵏⴷⴻⵇ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("GN37_10","002_37_10","GEN","37","10","10","ⴰⵢⵜⵎⴰⵙ ⵓⵙⵎⴻⵏ ⵣⵣⴰⵢⴻⵙ. ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⵉⵄⵇⴻⵍ ⵅ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN37_11","002_37_11","GEN","37","11","11","ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⴰⵢⵜⵎⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵖⴰⵔ ⵛⴰⴽⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN37_12","002_37_12","GEN","37","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵓⵙⵓⴼ: “ⵎⴰ ⵡⴰⵔ ⴰⵔⴻⵡⵙⴻⵏ ⴰⵢⵜⵎⴰⵛ ⵓⴵⵉ ⵖⴰⵔ ⵛⴰⴽⵉⵎ? ⵣⵉⴷ, ⴰⴷ ⵛⴻⴽ ⵖⴰⵔⵙⴻⵏ ⵙⵙⴻⴽⴽⴻⵖ.” ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN37_13","002_37_13","GEN","37","13","13","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ ⵛⴻⴽ, ⵅⵣⴰⵔ ⵎⵓⵅⴰⵙ ⴵⴰⵏ ⴰⵢⵜⵎⴰⵛ ⴷ ⵎⵓⵅⴰⵙ ⴵⴰⵏ ⵡⵓⴵⵉ ⵓⵛⴰ ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ ⵄⴰⵡⴻⴷ.” ⴰⵎⵎⵓ ⵉ-ⵜ ⵉⵙⵙⴻⴽⴽ ⵣⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵃⴰⴱⵔⵓⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵛⴰⴽⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN37_14","002_37_14","GEN","37","14","14","ⵢⵓⴼⴰ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵎⵉ ⵉⵡⴻⴷⴷⴰⵔ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵡⴻⵔⵢⴰⵣ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴰⵔⴻⵣⵣⵓⴷ?” ");
INSERT INTO rift_vpl VALUES ("GN37_15","002_37_15","GEN","37","15","15","ⵉⵏⵏⴰ: “ⴰⵔⴻⵣⵣⵓⵖ ⵅ ⴰⵢⵜⵎⴰ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵉⵏⵉ ⴰⵢⵉ ⵎⴰⵏⵉ ⴰⵔⴻⵡⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN37_16","002_37_16","GEN","37","16","16","ⴰⵔⵢⴰⵣ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴰⵇⴰ ⵎⵓⵟⵟⵉⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵙⵙⴰ, ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⴰⵙⴻⵏ ⵇⵇⴰⵔⴻⵏ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⴷⵓⵜⴰⵏ.’” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵢⵓⵙⵓⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⴷⵓⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN37_17","002_37_17","GEN","37","17","17","ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ, ⵎⵄⴰⵀⴰⴷⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("GN37_18","002_37_18","GEN","37","18","18","ⵏⵏⴰⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⴱⵓ-ⵜⵉⵔⵊⴰ ⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("GN37_19","002_37_19","GEN","37","19","19","ⵣⵉⴷ ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜ ⵏᵉⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜ ⵏⴻⵏⴹⴰⵔ ⴷⴻⴳ ⵡⴰⵏⵓ, ⴰⴷ ⵏⵉⵏⵉ: ‘ⵛⴰ ⵏ ⵍⵡⴻⵃⵛ ⵢⴻⵡⵄⴰⵔ ⵉⵛⵛⴰ ⵉ-ⵜ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵥⴰⵔ ⵎⵉⵏ ⵖⴰ ⵉⵍⵉⵏⵜ ⵜⵉⵔⵊⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN37_20","002_37_20","GEN","37","20","20","ⵉⵙⵍⴰ ⵔⵓⴱⵉⵏ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜ ⵏⵏⴻⵇⵇ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN37_21","002_37_21","GEN","37","21","21","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵔⵓⴱⵉⵏ: “ⵡⴰⵔ ⵙⵉⵣⵣⵉⵍⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ! ⵏⴹⴰⵔⴻⵎ ⵜ ⴷⴻⴳ ⵡⴰⵏⵓ-ⵢⴰ ⴷⴰ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⴻⴳⴳⴻⵎ ⴰⴼⵓⵙ!”. ⵉⵏⵏⴰ ⴰⵎⵎⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⵖⴰⵔ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN37_22","002_37_22","GEN","37","22","22","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵢⵓⵙⵓⴼ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵙ, ⴽⴽⵙⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵔⵔⵓⴹ ⵅ ⵢⵓⵙⵓⴼ, ⴰⵔⵔⵓⴹ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵏⵏⵉ ⵅⴰⵙ ⵜⵓⵖⴰ, ");
INSERT INTO rift_vpl VALUES ("GN37_23","002_37_23","GEN","37","23","23","ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜ, ⵏⴹⴰⵔⴻⵏ ⵜ ⴷⴻⴳ ⵡⴰⵏⵓ. ⵎⴰⵛⴰ ⴰⵏⵓ ⵜⵓⵖⴰ ⵉⵅⵡⴰ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵓⵖⵉ ⵛⴰ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN37_24","002_37_24","GEN","37","24","24","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵇⵇⵉⵎⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ, ⵓⵛⴰ ⵍⴰⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵣⵍⵉⵏ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⴰ$ⴰⵏ ⵏ ⵉⵙⵎⴰⵄⵉⵍⵉⵢⵢⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵊⵉⵍⵄⴰⴷ. ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⴰⵔⴱⵓⵏ ⵍⴻⵄⵟⵓⵔ ⴷ ⵍⴻⴼⵡⴰⵀ ⵏ ⴱⴰⵍⵙⴰⵎ ⴷ ⵎⵉⵔⵔⵓ, ⴳⴳⵓⵔⴻⵏ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN37_25","002_37_25","GEN","37","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵎⴰⵍⴰ ⵏⴻⵏⵖⴰ ⵓⵎⴰⵜⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⴻⴼⴼⴰⵔ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("GN37_26","002_37_26","GEN","37","26","26","ⵖⴰⵡⵔⴻⵎ, ⴰⴷ ⵜ ⵏⴻⵣⵣⴻⵏⵣ ⵉ ⵉⵙⵎⴰⵄⵉⵍⵉⵢⵢⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵖ ⵅⴰⵙ, ⴰⵇⴰ ⴷ ⵓⵎⴰⵜⵏⴻⵖ ⴷ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵖ.” ⵓⵛⴰ ⵙⵍⵉⵏ ⴰⵢⵜⵎⴰⵙ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN37_27","002_37_27","GEN","37","27","27","ⴰⵎ ⴷⴷ-ⵄⴷⵓⵏ ⵜⵓⵊⵊⴰⵔ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵢⵓⵙⵓⴼ ⵣⴻⴳ ⵡⴰⵏⵓ ⵓⵛⴰ ⵣⵣⴻⵏⵣⴻⵏ ⵜ ⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵉⵙⵎⴰⵄⵉⵍⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵢⵓⵙⵓⴼ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN37_28","002_37_28","GEN","37","28","28","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵔⵓⴱⵉⵏ ⵖⴰⵔ ⵡⴰⵏⵓ, ⵡⴰⵔ ⴷⵉⵏ ⵢⵓⴼⵉ ⵢⵓⵙⵓⴼ ⵄⴰⴷ ⴷⴻⴳ ⵡⴰⵏⵓ. ⵅⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN37_29","002_37_29","GEN","37","29","29","ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴰⵃⴻⵏⵊⵉⵔ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ. ⵉ ⵏⴻⵛⵛ, ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("GN37_30","002_37_30","GEN","37","30","30","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⴰⵔⵔⵓⴹ ⵏ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵖⴰⵔⵚⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵓⵛⴰ ⵎⴰⵔⵖⴻⵏ ⴰⵔⵔⵓⴹ ⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN37_31","002_37_31","GEN","37","31","31","ⵙⵙⴻⴽⴽⴻⵏ ⵉⵊⵊⴻⵏ ⵙ ⴰⵔⵔⵓⴹ ⴷ ⵍⴻⵎⵍⵉⵃ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ, ⵊⵊⵉⵏ ⵜ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴷ ⵡⴰ ⵉ ⵏⵓⴼⴰ. ⵅⵣⴰⵔ ⵍⴻⵅⵅⵓ, ⵎⴰ ⵡⴰⵀ ⵏⵉⵖ ⵍⵍⴰ ⴰⵔⵔⵓⴹ ⵏ ⵎⵎⵉⵛ?” ");
INSERT INTO rift_vpl VALUES ("GN37_32","002_37_32","GEN","37","32","32","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵄⴻⵇⵍ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⴰⵔⵔⵓⴹ ⵏ ⵎⵎⵉ ⵉ ⵢⴻⴵⴰ! ⵛⴰ ⵏ ⵍⵡⴻⵃⵛ ⵢⴻⵡⵄⴰⵔ ⵉⵛⵛⴰ ⵉ-ⵜ. ⵢⵓⵙⵓⴼ ⵙ ⵜⵉⴷⴻⵜⵜ ⴱⴻⵜⵜⵇⴻⵏ ⵜ!” ");
INSERT INTO rift_vpl VALUES ("GN37_33","002_37_33","GEN","37","33","33","ⵉⵛⴰⵔⵔⴻⴳ ⵢⴰⵄⵇⵓⴱ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⴹ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ, ⵉⵛⴹⴻⵏ ⵅ ⵎⵎⵉⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN37_34","002_37_34","GEN","37","34","34","ⴽⴽⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵄⴻⵣⵣⴰⵏ, ⵄⴰⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴻⵣⵣⴰ, ⵉⵏⵏⴰ: “ⵍⵍⴰ, ⴰⴷ ⴷⴷ-ⵀⵡⵉⵖ ⵏⵏⵓⵔⵢⴻⵖ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ.” ⵓⵛⴰ ⵉⵙⵖⵓⵢ ⵅⴰⵙ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN37_35","002_37_35","GEN","37","35","35","ⵉⵎⵉⴷⵉⵢⴰⵏⵉⵢⵢⴻⵏ ⵣⵣⴻⵏⵣⴻⵏ ⵜ ⴷⵉ ⵎⵉⵚⵔⴰ ⵉ ⴱⵓⵜⵉⴼⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN38_1","002_38_1","GEN","38","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⴷ ⵉⵛⵜ ⵉⵀⵡⴰ ⵢⴰⵀⵓⴷⴰ, ⵉⴼⴼⴻⵖ ⵅ ⴰⵢⵜⵎⴰⵙ, ⵓⵛⴰ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⴷⵓⵍⵍⴰⵎⵉⵜⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵃⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN38_2","002_38_2","GEN","38","2","2","ⵓⵛⴰ ⵉⵥⵔⴰ ⴷⵉⵏ ⵢⴰⵀⵓⴷⴰ ⵢⴻⴵⵉⵙ ⵏ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⴽⴻⵏⵄⴰⵏⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵛⵓⵄⴰ. ⵓⵛⴰ ⵢⴰⵀⵓⴷⴰ ⵢⵉⵡⵉ ⵢⴻⴵⵉⵙ ⵏ ⵛⵓⵄⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN38_3","002_38_3","GEN","38","3","3","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵢⴰⵀⵓⴷⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵄⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("GN38_4","002_38_4","GEN","38","4","4","ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵜⵍⴰⵖⴰ ⴰⵙ ⵓⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN38_5","002_38_5","GEN","38","5","5","ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵜⵍⴰⵖⴰ ⴰⵙ ⵛⴰⵢⵍⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⴽⴰⵣⵉⴱ ⵓⵎⵉ ⴷ ⴰⵙ ⵜ-ⵉ-ⴷⴷ-ⵜⵓⵔⵓⵡ. ");
INSERT INTO rift_vpl VALUES ("GN38_6","002_38_6","GEN","38","6","6","ⵢⴰⵀⵓⴷⴰ ⵉⴽⵙⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵄⵉⵔ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ. ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⵇⵇⴰⵔⴻⵏⵜ ⴰⵙ ⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN38_7","002_38_7","GEN","38","7","7","ⵄⵉⵔ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN38_8","002_38_8","GEN","38","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ ⵉ ⵓⵏⴰⵏ: “ⴰⴷⴻⴼ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵛ, ⵎⵍⴻⵛ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵎⴰⵛ, ⵜⴻⵊⵊⴻⴷ-ⴷⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵓⵎⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN38_9","002_38_9","GEN","38","9","9","ⵎⴰⵛⴰ ⵓⵏⴰⵏ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵏⵏⴻⵙ. ⵓⵛⴰ ⴰⵎⵎⵓ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵙ, ⵉⵏⵖⴻⵍ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN38_10","002_38_10","GEN","38","10","10","ⵎⵉⵏ ⵉⴳⴳⴰ ⵜⵓⵖⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("GN38_11","002_38_11","GEN","38","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ ⵉ ⵜⴰⵎⴰⵔ, ⵜⴰⵙⵍⵉⵜ ⵏⵏⴻⵙ: “ⵇⵇⵉⵎ ⴰⵎ ⵜⴰⵊⵊⴰⵍⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵎ, ⴰⵍ ⵖⴰ ⵉⵎⵖⴰⵔ ⵎⵎⵉ ⵛⴰⵢⵍⴰ!”, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵓⵍⴰ ⴷ ⵡⴰ ⴰⵎ ⵢⴰⵢⵜⵎⴰⵙ.” ⵓⵛⴰ ⵜⵔⵓⵃ ⵜⴰⵎⴰⵔ, ⵜⴻⵣⴷⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN38_12","002_38_12","GEN","38","12","12","ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵟⵟⴰⵙ, ⵅⴻⵏⵏⵉ ⵜⴻⵎⵎⵓⵜ ⵢⴻⴵⵉⵙ ⵏ ⵛⵓⵄⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵢⴰⵀⵓⴷⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴻⵣⵣⴰ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵉⵎⵏⴰⵜⴰ, ⵏⴻⵜⵜⴰ ⴷ ⵃⵉⵔⴰ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ ⵣⵉ ⴰⴷⵓⵍⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN38_13","002_38_13","GEN","38","13","13","ⵄⴻⵍⵎⴻⵏ ⵜ ⵉ ⵜⴰⵎⴰⵔ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵎ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⵉⵎⵏⴰⵜⴰ, ⴰⴷ ⵉⵍⵙ ⵓⴵⵉ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN38_14","002_38_14","GEN","38","14","14","ⵅⴻⵏⵏⵉ ⵜⴻⴽⴽⴻⵙ ⵅⴰⵙ ⴰⵔⵔⵓⴹ ⵏ ⵜⴰⵊⵊⴰⵍⵜ, ⵜⵍⴻⵃⵃⴻⴼ ⵙ ⵜⴽⴻⵏⴱⵓⵛⵜ, ⵜⴻⵙⵍⴻⵃⵀⴻⴼ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⴻⵙ, ⵓⵛⴰ ⵜⵔⵓⵃ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵄⴰⵢⵏⴰⵢⵉⵎ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⵉⵎⵏⴰⵜⴰ, ⵎⵉⵏⵣⵉ ⵜⴻⵥⵔⴰ ⵛⴰⵢⵍⴰ ⵉⵎⵖⴰⵔ, ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵎⵎⴻⵡⵛ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN38_15","002_38_15","GEN","38","15","15","ⵓⵛⴰ ⵉⵥⵔⴰ ⵉ-ⵜⵜ ⵢⴰⵀⵓⴷⴰ, ⵉⵃⴻⵙⴱ ⵉ-ⵜⵜ ⴷ ⵍⴼⴰⵙⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜⵜ ⵜⵍⴻⵃⵃⴻⴼ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN38_16","002_38_16","GEN","38","16","16","ⵓⵛⴰ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵅⴰⵎ ⴰⴷⴼⴻⵖ!”, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵙⵍⵉⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⴻⵡⵛⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⴷⴼⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("GN38_17","002_38_17","GEN","38","17","17","ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵎ-ⴷⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ, ⵣⴻⴳ ⵡⵓⴵⵉ.” ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⵖⵉⵔ ⴻⵡⵛ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴰⵔⵀⴰⵏ ⴰⵍ ⴷ ⴰⵢⵉ ⵜ-ⵉ-ⴷⴷ ⵜᵉⵙⵙⴻⴽⴽⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN38_18","002_38_18","GEN","38","18","18","ⵉⵏⵏⴰ: “ⵎⴰⵏ ⴰⴹⵎⴰⵏ ⵉ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵡⵛⴻⵖ?” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏⵏⴻⵛ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⴷ ⵜⵜⴻⵙⴱⵉⵃ ⵏⵏⴻⵛ ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵉ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵓⴼⵓⵙ.” ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵜⴻⵏ, ⵢⵓⴷⴻⴼ ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷⴻⵢⵙⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN38_19","002_38_19","GEN","38","19","19","ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ, ⵜⵔⵓⵃ, ⵜⴻⴽⴽⴻⵙ ⵅⴰⵙ ⵜⴰⴽⴻⵏⴱⵓⵛⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("GN38_20","002_38_20","GEN","38","20","20","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵢⴰⵀⵓⴷⴰ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵅ ⵓⴼⵓⵙ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ ⴰⴷⵓⵍⵍⴰⵎⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵄⴰⵡⴻⴷ ⴰⴹⵎⴰⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵢⵓⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("GN38_21","002_38_21","GEN","38","21","21","ⵉⵙⵙⴻⵇⵙⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵄⴰⵏⴰⵢⵉⵎ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵡⴰⵔ ⴷⴰ ⵜⵓⵖⵉ ⵇⴰⵄ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN38_22","002_38_22","GEN","38","22","22","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵖ ⵛⴰ, ⵓⵍⴰ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵏⵏⴰⵏ: ‘ⵡⴰⵔ ⴷⴰ ⵜⵓⵖⵉ ⵇⴰⵄ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ.’” ");
INSERT INTO rift_vpl VALUES ("GN38_23","002_38_23","GEN","38","23","23","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ: “ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⴰⴹⵎⴰⵏ ⵖⴰⵔⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵍⵉ ⴷ ⵍⵄⴰⵔ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵖⴰⵢⴹ-ⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⵜ ⵜⵓⴼⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN38_24","002_38_24","GEN","38","24","24","ⵄⵍⴰⵃⴰⵍ ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵜⴻⵎⵙⴰⵔ, ⴰⵇⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ, ⵏⵏⴰⵏ: “ⵜⴰⵎⴰⵔ, ⵜⴰⵙⵍⵉⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵏⴻⵜⵜⴰⵜ ⴰⵇⴰ-ⵜⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ: “ⵙⵓⴼⴼⵖⴻⵎ ⵜⵜ-ⵉ-ⴷⴷ, ⴰⴷ ⵜⴻⵛⵎⴻⴹ!” ");
INSERT INTO rift_vpl VALUES ("GN38_25","002_38_25","GEN","38","25","25","ⵓⵎⵉ ⵜⵜ-ⵉ-ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵜⴻⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵏⵉ: “ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⴻⵃⵡⴰⵢⴻⵊ-ⴰ, ⴰⵇⴰ ⴽⵙⵉⵖ ⵙ ⴷⴷⴻⵢⵙⴻⵜ.” ⵜⴻⵏⵏⴰ ⵄⴰⴷ: “ⴰⵔⵣⵓ ⵅⴻⵏⵏⵉ ⵡⵉ ⵉⵍⴰⵏ ⵜⴰⵅⴰⴷⴻⵏⵜ-ⴰ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⴷ ⵜⵜⴻⵙⴱⵉⵃⵉⵏ-ⴰ ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN38_26","002_38_26","GEN","38","26","26","ⵢⴰⵀⵓⴷⴰ ⵉⵄⴻⵇⵍ ⵉ-ⵜⴻⵏⵜ, ⵉⵏⵏⴰ: “ⴰⵇⴰ-ⵜⵜ ⴷ ⵏⵉⵛⴰⵏ ⵅⴰⴼⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵜ ⵡⵛⵉⵖ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵛⴰⵢⵍⴰ ⵎⵎⵉ.” ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵙⵙⴻⵏ ⵉ-ⵜⵜ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GN38_27","002_38_27","GEN","38","27","27","ⴷⵉ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ, ⴰⵇⴰ ⴷⴰ ⴰⵛⵏⵉⵡⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN38_28","002_38_28","GEN","38","28","28","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ, ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊⴻⵏ ⴰⴼⵓⵙ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵜ ⵍⵇⴰⴱⵍⴰ ⵓⵛⴰ ⵜⵛⴻⴷⴷ ⵉ-ⵜ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵙ ⵓⴼⵉⵍⵓ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ, ⵜⴻⵏⵏⴰ: “ⵡⴰ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("GN38_29","002_38_29","GEN","38","29","29","ⵍⴰⵎⵉ ⴷⴷ ⵢⴰⵔⵔⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⴱⴰⵏ-ⴷⴷ ⵓⵎⴰⵙ, ⵓⵛⴰ ⵜⴻⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⴰⵣⵣⵉⵜ. ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴱⵓ-ⵉⵜⵜⴰⵔⴻⵥⵥⴰⵏ!” ⵓⵛⴰ ⵙⴻⵎⵎⴰⵏ ⵜ ⴼⴰⵔⵉⵚ.    ");
INSERT INTO rift_vpl VALUES ("GN38_30","002_38_30","GEN","38","30","30","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⴰⵙ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⴼⵉⵍⵓ ⴰⵣⴻⴳⴳⵯⴰⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⴻⵎⵎⴰ ⵜ ⵣⴰⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("GN39_1","002_39_1","GEN","39","1","1","ⵏⴻⴷⵀⴻⵏ ⵅⴻⵏⵏⵉ ⵢⵓⵙⵓⴼ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⴱⵓⵜⵉⴼⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵉⵊⵊ ⵏ ⵓⵎⵉⵚⵔⵉ, ⵉⵙⵖⴰ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵎⴰⵄⵉⵍⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵜ ⵢⵉⵡⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN39_2","002_39_2","GEN","39","2","2","ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵢⵓⵙⵓⴼ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵢⴰⵣ ⵉⴼⵍⴻⵃ ⵓⵛⴰ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉⵙ, ⴰⵎⵉⵚⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN39_3","002_39_3","GEN","39","3","3","ⵉⵥⵔⴰ ⵙⵉⴷⵉⵙ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ ⵓ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽⵡⴰⴹ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("GN39_4","002_39_4","GEN","39","4","4","ⴰⵎⵎⵓ ⵉ ⵢⵓⴼⴰ ⵢⵓⵙⵓⴼ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵙⴻⵅⵅⴰⵔ ⴰⵙ. ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴱⵓⵜⵉⴼⴰⵔ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN39_5","002_39_5","GEN","39","5","5","ⵣⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵜ ⵉⴳⴳⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⵉⴱⴰⵔⴽ ⵙⵉⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵉⵚⵔⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵓⵙⵓⴼ. ⵜⵓⵖⴰ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⴰⵎ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵎ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN39_6","002_39_6","GEN","39","6","6","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⵉⵊⵊⴰ ⵉ-ⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵓⵙⵓⴼ, ⴰⵍ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵏⴻⵜⵜⴰ ⵛⴰ ⴽⵜⴰⵔ ⵎⵖⵉⵔ ⴰⵖⵔⵓⵎ ⵉ ⵉⵜⵜⴻⵜⵜ. ⵜⵓⵖⴰ ⵢⵓⵙⵓⴼ ⵉⵛⵏⴰ ⴷⴻⴳ ⵡⴰⴷⴷⵓⴷ ⵓ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN39_7","002_39_7","GEN","39","7","7","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵙⵉⴷⵉⵙ ⵜⴻⵏⴹⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷⵉ ⵢⵓⵙⵓⴼ, ⵜⴻⵏⵏⴰ: “ⵣⵉⴷ, ⵟⵟⴻⵚ ⴰⴽⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("GN39_8","002_39_8","GEN","39","8","8","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ, ⵉⵏⵏⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵙⵉⴷⴻⵙ: “ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵍⴰⵎⵉ ⴷⴰ ⴰⴽⵉⴷⴻⵙ ⴵⵉⵖ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN39_9","002_39_9","GEN","39","9","9","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙⴻⵏⵏⴻⵊ ⵉⵏⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵟⵟⵉⴼ ⵙ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵛⴻⵎ, ⵓⵎⵉ ⵜⴻⴵⵉⴷ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵍⵊⴰⵔⵉⵎⴰ-ⵢⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵎ ⵜⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⴷⴷⴻⵏⴱ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN39_10","002_39_10","GEN","39","10","10","ⵜⵓⵖⴰ ⵜⴻⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵢⵓⵙⵓⴼ ⴽⵓⵍ ⴰⵙⵙ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⴻⵙⵍⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⵚ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⴽⵉⴷⴻⵙ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("GN39_11","002_39_11","GEN","39","11","11","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵜⴻⵎⵙⴰⵔ, ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN39_12","002_39_12","GEN","39","12","12","ⵅⴻⵏⵏⵉ ⵜᵉⵟⵟⴻⴼⴼ ⵉ-ⵜ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ: “ⴰⵔⴰⵃ-ⴷⴷ ⵣⵣⴻⵍ ⴰⴽⵉⴷⵉ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵊⵊⴰ ⴰⵙ ⵏⴻⵜⵜⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ, ⵢⴰⵔⵡⴻⵍ, ⵉⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN39_13","002_39_13","GEN","39","13","13","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵉⵊⵊⴰ ⴰⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("GN39_14","002_39_14","GEN","39","14","14","ⵜⵍⴰⵖⴰ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢ ⴰⵏⴻⵖ-ⴷⴷ ⴰⵔⵢⴰⵣ ⴰⵄⵉⴱⵔⴰⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⴹⵃⴻⵛ. ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ, ⵃⵉⵎⴰ ⴰⴽⵉⴷⵉ ⵉⵟⵟⴻⵚ ⵓⵛⴰ ⵏⴻⵛⵛ ⵙⵖⵓⵢⴻⵖ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("GN39_15","002_39_15","GEN","39","15","15","ⵓⵎⵉ ⵉⵙⵍⴰ ⴱⴻⵍⵍⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵓⵛⴰ ⵙⵖⵓⵢⴻⵖ, ⵉⵊⵊⴰ ⵖⴰⵔⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵢⴰⵔⵡⴻⵍ, ⵉⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN39_16","002_39_16","GEN","39","16","16","ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵣⵣⴰⵜⴻⵙ, ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN39_17","002_39_17","GEN","39","17","17","ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ, ⵜⴻⵏⵏⴰ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⵉⴱⵔⴰⵏⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵜⵉⵡⵢⴻⴷ ⵖⴰⵔⵏⴻⵖ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵄⵓⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN39_18","002_39_18","GEN","39","18","18","ⵓⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵙⵖⵓⵢⴻⵖ, ⵉⵊⵊⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵖⴰⵔⵉ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⴱⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN39_19","002_39_19","GEN","39","19","19","ⵙⵉⴷⴻⵙ ⵉⵙⵍⴰ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ!”, ⵓⵛⴰ ⵉⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN39_20","002_39_20","GEN","39","20","20","ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵙⵉⴷⵉ ⵏ ⵢⵓⵙⵓⴼ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵎⴻⵃⴱⴰⵙ ⵏ ⵓⵊⴻⴵⵉⴷ. ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN39_21","002_39_21","GEN","39","21","21","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵖⴰⵔⴻⵙ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN39_22","002_39_22","GEN","39","22","22","ⵓⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⴻⵃⴱⴻⵙ ⵢⴰⵔⵔⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵢⵓⵙⵓⴼ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⴻⵏ ⴷⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴽⴽ ⵅ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN39_23","002_39_23","GEN","39","23","23","ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⴻⵃⴱⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵇⵇⵉⵎ ⵎⵉⵏ ⵅⴻⴼ ⵖⴰ ⵉⵏⵏⴻⵀⵡⴻⵍ ⵣⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⵢⵓⵙⵓⴼ. ⵎⵉⵏ ⵎⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵏⴻⵜⵜⴰ, ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽⵡⴰⴹ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN40_1","002_40_1","GEN","40","1","1","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴱⴻⵍⵍⵉ ⴰⵡⴰⵔⵔⴰⴷ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵓⵅⴻⴱⴱⴰⵣ ⴷⴻⵏⵏⴱⴻⵏ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉⵜⵙⴻⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN40_2","002_40_2","GEN","40","2","2","ⵉⴼⴼⵓⴳⴻⵎ ⴼⵉⵔⵄⵓⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏⵏⴻⵙ, ⵅ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵓ ⵅ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵅⴻⴱⴱⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN40_3","002_40_3","GEN","40","3","3","ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⵃⴻⵟⵟⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ, ⵎⴰⵏⵉ ⵉⵃⴻⴱⴱⴻⵙ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("GN40_4","002_40_4","GEN","40","4","4","ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⴳⴳⴰ ⵢⵓⵙⵓⴼ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵅⴰⵙⴻⵏ. ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵓⵙⵙⴰⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN40_5","002_40_5","GEN","40","5","5","ⵓⵔⵊⵉⵏ ⵜⴰⵔⵊⵉⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵏⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵢⵓⵔⵊⴰ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵙ ⵙ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ, ⴰⵎ ⵓⵡⴰⵔⵔⴰⴷ ⴰⵎ ⵓⵅⴻⴱⴱⴰⵣ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("GN40_6","002_40_6","GEN","40","6","6","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵓⵙⵓⴼ ⵅ ⵚⵚⴱⴻⵃ, ⵉⵅⵣⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵉⵥⵔⴰ ⵉ-ⵜⴻⵏ ⵜⵜⵇⴻⵍⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN40_7","002_40_7","GEN","40","7","7","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉⵙ, ⵉⵏⵏⴰ: “ⵎⴰⵖⴰⵔ ⴱⴰⵔⴻⵛⵏⴻⵏ ⵓⴷⵎⴰⵡⴻⵏ ⵏⵡⴻⵎ ⴰⵙⵙ-ⴰ ⵇⴰⵄ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("GN40_8","002_40_8","GEN","40","8","8","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⵓⵔⵊⴰ ⵜⴰⵔⵊⵉⵜ, ⵡⴰⵔ ⴷⴰ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ.” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ: “ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵉⴼⴻⵙⵙⴰⵔⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ? ⵉⵡⴰ, ⵄⴰⵡⴷⴻⵎ ⴰⵢⵉ ⵜⴻⵏⵜ ⵍⴻⵅⵅⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN40_9","002_40_9","GEN","40","9","9","ⵅⴻⵏⵏⵉ ⵉⵄⴰⵡⴻⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵙ ⵉ ⵢⵓⵙⵓⴼ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵉⵏⵓ ⵥⵔⵉⵖ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵣⵣⴰⵜⵉ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("GN40_10","002_40_10","GEN","40","10","10","ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⵙⴻⴹⵡⵉⵏ. ⵅⵎⵉ ⵜⴻⵙⵙⴻⵏⴷⵉⵢ, ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵏⵏⵓⵡⵡⴰⵔ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵉⵣⴻⴽⴽⵓⵏⴻⵏ ⵏⵏⴻⵙ ⵉⴱⴰⵏ-ⴷⴷ ⵍⵃⴻⴱⴱ ⵏ ⵓⴹⵉⵍ ⵢⵉⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("GN40_11","002_40_11","GEN","40","11","11","ⵓⵛⴰ ⵍⴽⴰⵙ ⵏ ⴼⵉⵔⵄⵓⵏ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵓⵛⴰ ⴽⵙⵉⵖ ⴰⴹⵉⵍ ⵏⵏⵉ ⵓⵛⴰ ⵄⴻⵙⵙⴰⵔⴻⵖ ⵜ ⴷⵉ ⵍⴽⴰⵙ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵙⵙⴻⵄⴷⵓⵖ ⵍⴽⴰⵙ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⴼⵉⵔⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN40_12","002_40_12","GEN","40","12","12","ⵉⵏⵏⴰ ⴰⵙ ⵢⵓⵙⵓⴼ: “ⴷ ⵡⴰ ⴷ ⴰⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ: ⵜⵍⴰⵜⴰ ⵏ ⵜⵉⵙⴻⴹⵡⵉⵏ, ⴰⵇⴰ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN40_13","002_40_13","GEN","40","13","13","ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴼⵉⵔⵄⵓⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⵖⴰⵔ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵙⵙⴻⵄⴷⵓⴷ ⵍⴽⴰⵙ ⵉ ⴼⵉⵔⵄⵓⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵣⵉⵛ ⵍⴰⵎⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⴷ ⴰⵡⴰⵔⵔⴰⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN40_14","002_40_14","GEN","40","14","14","ⵎⴰⵛⴰ ⵄⵇⴻⵍ ⵅⴰⴼⵉ ⵅⵎⵉ ⴷ ⴰⵛ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⵅⴰⵔ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⴳⴳⴻⴷ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓⵛⴰ ⴻⵊⵊ ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⵅⴰⴼⵉ ⵉⵄⵇⴻⵍ ⵓⵛⴰ ⴼⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GN40_15","002_40_15","GEN","40","15","15","ⵎⵉⵏⵣⵉ ⵓⵛⴰⵔⴻⵏ ⴰⵢⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵓ ⴷⴰ ⵡⴰⵔ ⴳⴳⵉⵖ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⴷⴰⵢⵉ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵉⵎⴻⵃⴱⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN40_16","002_40_16","GEN","40","16","16","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵅⴻⴱⴱⴰⵣⴻⵏ ⴱⴻⵍⵍⵉ ⵉⴼⴻⵙⵙⴰⵔ ⴰⵙ ⵎⵍⵉⵃ, ⵉⵏⵏⴰ ⵉ ⵢⵓⵙⵓⴼ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵉⵏⵓ ⵜⵍⴰⵜⴰ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN40_17","002_40_17","GEN","40","17","17","ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵏ ⵙⴻⵏⵏⴻⵊ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵎⴰⵛⵛⴰ ⵉ ⴼⵉⵔⵄⵓⵏ ⵉ ⵉⴳⴳⴰ ⵓⵅⴻⴱⴱⴰⵣ ⵓ ⵉⵊⴹⴰⴹ ⵜⵜᵉⵜⵜⴻⵏ ⵣⵉ ⵜⵙⵓⴵⴻⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN40_18","002_40_18","GEN","40","18","18","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⵓⵙⵓⴼ, ⵉⵏⵏⴰ: “ⴷ ⵡⴰ ⴷ ⴰⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ. ⵜⵍⴰⵜⴰ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN40_19","002_40_19","GEN","40","19","19","ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⴽ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴼⵉⵔⵄⵓⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⵊⵎⵉⵄ ⴰⴽⵉⴽ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵢⴰⵢⴻⵍ ⵅ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵓ ⵉⵊⴹⴰⴹ ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN40_20","002_40_20","GEN","40","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⴰⵙⵙ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵅⴻⴱⴱⴰⵣⴻⵏ ⵜⵓⵖⴰ-ⵜ ⵊⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN40_21","002_40_21","GEN","40","21","21","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵏ ⵓⵡⴰⵔⵔⴰⴷ, ⴰⵍⴰⵎⵉ ⵡⴰⵏⵉⵜⴰ ⵉⵡⵛⴰ ⵄⴰⵡⴻⴷ ⴰⵖⴰⵔⵔⴰⴼ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN40_22","002_40_22","GEN","40","22","22","ⵎⴰⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵅⴻⴱⴱⴰⵣⴻⵏ ⵢⵓⵢⴻⵍ ⵉ-ⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⴼⴻⵙⵙⴰⵔ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("GN40_23","002_40_23","GEN","40","23","23","ⵎⴰⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵡⴰⵔ ⵉⴼⴻⴽⴽⴰⵔ ⵛⴰ ⵄⴰⴷ ⴷⵉ ⵢⵓⵙⵓⴼ, ⵉⵜⵜⵓ ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_1","002_41_1","GEN","41","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵢⵓⵔⵊⴰ ⴼⵉⵔⵄⵓⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵣⴻⵄⵎⴰ ⵉⴱⴻⴷⴷ ⵅ ⵢⴻⵖⵣⴰⵔ ⵏ ⵏⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN41_2","002_41_2","GEN","41","2","2","ⵅⵣⴰⵔ, ⴳⴻⵄⵄⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵣⴻⴳ ⵉⵖⵣⴰⵔ, ⵚⴻⴱⵃⴻⵏⵜ ⵉ ⵍⵅⴻⵣⵔⴰⵜ ⵓ ⵄⴻⵎⵎⴰⵔⴻⵏⵜ ⵙ ⵡⴻⵢⵙⵓⵎ, ⵀⴻⴷⴷⴰⵏⵜ ⵊⴰⵔ ⵡⴻⵃⵜⵉⵛ ⵏ ⵓⵖⴰⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN41_3","002_41_3","GEN","41","3","3","ⵓ ⵅⵣⴰⵔ, ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵖⵏⵉ ⴳⴻⵄⵄⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ ⵣⴻⴳ ⵉⵖⵣⴰⵔ. ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⵃⵍⵉⵏⵜ ⵉ ⵍⵅⴻⵣⵔⴰⵜ, ⴰⵇⴰ ⴽⴽⵓⵛⵛⴹⴻⵏⵜ ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN41_4","002_41_4","GEN","41","4","4","ⵜⵉⴼⵓⵏⴰⵙⵉⵏ ⵉ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵉ ⵍⵅⴻⵥⵔⴰⵜ, ⵜⵉⵏⵏⵉ ⵉⴽⵓⵛⵛⴹⴻⵏ, ⵚⴰⵔⴹⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵉ ⵍⵅⴻⵣⵔⴰⵜ, ⵜⵉⵏⵏⵉ ⵉⵚⴻⵃⵃⴻⵏ. ⵓⵛⴰ ⵉⴼⴰⵇ-ⴷⴷ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_5","002_41_5","GEN","41","5","5","ⵉⵟⵟⴻⵚ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵢⵓⵔⵊⴰ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⵓ ⵅⵣⴰⵔ, ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴻⵟⵟⴰ ⴳⴻⵄⵄⴷⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵛⵛⵓⵔⴻⵏⵜ, ⵛⵏⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_6","002_41_6","GEN","41","6","6","ⵓ ⵅⵣⴰⵔ, ⵖⴻⵎⵢⴻⵏⵜ-ⵉ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵇⵇⵓⵙⴱⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ, ⵉⵙⵙⵛⴻⵎⴹ ⵉ-ⵜⴻⵏⵜ ⵓⵙⴻⵎⵎⵉⴹ ⴰⵛⴰⵔⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("GN41_7","002_41_7","GEN","41","7","7","ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵇⵇⵓⵙⴱⴰⵔⴻⵏⵜ ⵚⴰⵔⴹⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵉⵢⵎⴰⵏ ⴷ ⵉⵛⵛⵓⵔⴻⵏ. ⵓⵛⴰ ⵉⴼⴰⵇ-ⴷⴷ ⴼⵉⵔⵄⵓⵏ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵔⵊⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_8","002_41_8","GEN","41","8","8","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵉⴱⴰⵏ-ⴷⴷ ⴱⴻⵍⵍⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵉⵏⵏⴻⵀⵡⴻⵍ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵍⴰⵖⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ. ⵉⵄⴰⵡⴷ ⴰⵙⴻⵏ ⴼⵉⵔⵄⵓⵏ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵃⴻⴷ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⴼⴻⵙⵙⴰⵔ ⵉ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_9","002_41_9","GEN","41","9","9","ⵉⵙⵙⵉⵡⴻⵍ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⴰⴽ-ⴷ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵏⴰ: “ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵄⴻⵇⵍⴻⵖ ⵅ ⴷⴷⵏⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN41_10","002_41_10","GEN","41","10","10","ⵓⵎⵉ ⵉⴼⴼⵓⴳⴻⵎ ⴼⵉⵔⵄⵓⵏ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⴰⵢⵉ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⵎ ⵏⴻⵛⵛ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵅⴻⴱⴱⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_11","002_41_11","GEN","41","11","11","ⵏⴻⵛⵛ ⴷ ⵏⴻⵜⵜⴰ ⵏⵓⵔⵊⴰ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ ⴷⵉ ⴵⵉⵔⴻⵜ ⴷ ⵉⵛⵜ. ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⵢⵓⵔⵊⴰ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵙ ⵙ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN41_12","002_41_12","GEN","41","12","12","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⴱⵍⵉⵖ ⴷ ⴰⵄⵉⴱⵔⴰⵏⵉ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ⵏⵃⴰⵊⴰ ⴰⵙ ⵜⵉⵔⵊⴰ ⵏⵏⴻⵖ ⵓⵛⴰ ⵉⴼⴻⵙⵙⴰⵔ ⴰⵏⴻⵖ ⵜⴻⵏⵜ. ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴼⴻⵙⵙⴰⵔ ⴰⵙ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN41_13","002_41_13","GEN","41","13","13","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵜ ⵉⴼⴻⵙⵙⴰⵔ, ⴰⵎⴻⵏⵏⵉ ⵉ ⵉⵎⵙⴰⵔ. ⴰⵇⴰ ⴼⵉⵔⵄⵓⵏ ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵓ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵢⵓⵢⴻⵍ ⵉ-ⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN41_14","002_41_14","GEN","41","14","14","ⵉⵙⵙⴻⴽⴽ ⴼⵉⵔⵄⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵍⴰⵖⴰⵏ ⵅ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ-ⵉ-ⴷⴷ ⴷⴻⵖⵢⴰ ⵣⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵉⵎⴻⵃⴱⴰⵙ. ⵉⵃⴻⴼⴼ ⴰⵛⵓⵡⵡⴰⴼ, ⵉⴱⴻⴷⴷⴻⵍ ⴰⵔⵔⵓⴹ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_15","002_41_15","GEN","41","15","15","ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ: “ⵏⴻⵛⵛ ⵓⵔⵊⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⴼⴻⵙⵙⴰⵔⴻⵏ. ⵎⴰⵛⴰ ⴰⵇⴰ ⵙⵍⵉⵖ ⵅⴰⴽ ⴱⴻⵍⵍⵉ ⵛⴻⴽ, ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⴰⵔⵊⵉⵜ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵜ ⵜⴼⴻⵙⵙⴰⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN41_16","002_41_16","GEN","41","16","16","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⵓⵙⵓⴼ ⵅ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵣⴰⵢⵉ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵅ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⴷⵡⴻⵍ ⵓⵎⴻⴷⴷⵓⵔ ⵏ ⴼⵉⵔⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN41_17","002_41_17","GEN","41","17","17","ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ: “ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵉⵏⵓ ⵥⵔⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴱⴻⴷⴷⴻⵖ ⵅ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN41_18","002_41_18","GEN","41","18","18","ⴰⵇⴰ ⴳⴻⵄⵄⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵣⴻⴳ ⵉⵖⵣⴰⵔ, ⵚⴻⵃⵃⴻⵏⵜ ⵓ ⵚⴻⴱⵃⴻⵏⵜ ⵉ ⵍⵅⴻⵣⵔⴰⵜ, ⵀⴻⴷⴷⴰⵏⵜ ⵊⴰⵔ ⵡⴻⵃⵜⵉⵛ ⵏ ⵓⵖⴰⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN41_19","002_41_19","GEN","41","19","19","ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵖⵏⵉ ⴳⴻⵄⵄⴷⴻⵏⵜ-ⵉ-ⴷⴷ. ⵜⵓⵖⴰ ⴽⴽⵓⵛⵛⴹⴻⵏⵜ ⵓ ⵡⴰⵔ ⵃⵍⵉⵏⵜ ⴷⴻⴳ ⵡⵓⴷⴻⵎ, ⵓⵥⵖⴻⵏⵜ. ⴰⵎⵎⵓ ⵡⴰⵔ ⵃⵍⵉⵏⵜ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⵏⵜ ⵥⵔⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵎ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GN41_20","002_41_20","GEN","41","20","20","ⵜⵉⴼⵓⵏⴰⵙⵉⵏ ⵢⵓⵥⵖⴻⵏ, ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵙⴰⵔⴹⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵢⴻⵏⴷⵓⵣⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵉⵚⴻⵃⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_21","002_41_21","GEN","41","21","21","ⵓⵎⵉ ⵓⴷⴼⴻⵏⵜ ⵜⵉⵏⴰ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏⵜ, ⵄⴰⴷ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵃⴻⴷ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵓⴷⴼⴻⵏⵜ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏⵜ, ⴰⵇⴰ ⵇⵇⵉⵎⴻⵏⵜ ⵡⴰⵔ ⵃⵍⵉⵏⵜ ⵉ ⵍⵅⴻⵣⵔⴰⵜ ⴰⵎ ⵇⴱⴻⵍ. ⵅⴻⵏⵏⵉ ⴼⴰⵇⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN41_22","002_41_22","GEN","41","22","22","ⵄⴰⵡⴻⴷ ⵥⵔⵉⵖ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵉⵏⵓ, ⵅⵣⴰⵔ, ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴻⵟⵟⴰ ⴼⴼⵖⴻⵏⵜ-ⵉ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵛⵛⵓⵔⴻⵏⵜ ⵓ ⵛⵏⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_23","002_41_23","GEN","41","23","23","ⵅⵣⴰⵔ, ⵥⵔⵉⵖ, ⴳⴻⵄⵄⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵇⵇⵓⵙⴱⴰⵔⴻⵏⵜ, ⵓⵥⵖⴻⵏⵜ, ⵉⵙⵙⵛⴻⵎⴹ ⵉ-ⵜⴻⵏⵜ ⵓⵙⴻⵎⵎⵉⴹ ⴰⵛⴰⵔⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("GN41_24","002_41_24","GEN","41","24","24","ⵓ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵢⵓⵥⵖⴻⵏ, ⵚⴰⵔⴹⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵏⵏⵉ ⵉⵛⵏⴰⵏ. ⵏⵏⵉⵖ ⵜⴰⵔⵊⵉⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵃⴻⴷ ⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴼⴻⵙⵙⴰⵔ ⵜⴰⵔⵊⵉⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN41_25","002_41_25","GEN","41","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⴼⵉⵔⵄⵓⵏ: “ⵜⴰⵔⵊⵉⵜ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵛⵜ. ⴰⵔⴻⴱⴱⵉ ⵉⴱⴻⵢⵢⴻⵏ ⵉ ⴼⵉⵔⵄⵓⵏ ⵎⵉⵏ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_26","002_41_26","GEN","41","26","26","ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵛⵏⴰⵏⵜ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵓⵛⴰ ⵜⵉⴷⵔⵉⵏ ⵛⵏⴰⵏⵜ ⴰⵇⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⴷ ⵜⴰⵔⵊⵉⵜ ⴷ ⵉⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_27","002_41_27","GEN","41","27","27","ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓⵥⵖⴻⵏⵜ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵜⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵍⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ, ⴰⵇⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⴷⵔⵉⵏ ⵇⵇⵓⵙⴱⴰⵔⴻⵏⵜ, ⵜⵉⵏⵏⵉ ⵉⵙⵙⵛⴻⵎⴹ ⵓⵙⴻⵎⵎⵉⴹ ⴰⵛⴰⵔⵇⵉ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⵉ ⵖⴰ ⵢⵉⵍⵉ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("GN41_28","002_41_28","GEN","41","28","28","ⴷ ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵏⵏⵉⵖ ⵉ ⴼⵉⵔⵄⵓⵏ. ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵉⵙⵙⵛⴻⵏ ⵉ-ⵜ ⵉ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_29","002_41_29","GEN","41","29","29","ⵅⵣⴰⵔ, ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⴷ-ⵉⴳⴳⵓⵔⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⵢⴰⵡⴰⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_30","002_41_30","GEN","41","30","30","ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⵜⵜⵓⵏ ⵎⴰⵔⵔⴰ ⵜⵢⴰⵡⴰⵏⵜ ⵓⵛⴰ ⵍⴰⵥ ⴰⴷ ⵉⵜⴻⵃⵃⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_31","002_41_31","GEN","41","31","31","ⵓⵛⴰ ⵜⵢⴰⵡⴰⵏⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵄⴰⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴰⵥ ⵉ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵍⵃⴰⵍ ⴰⴷ ⵢⵉⵍⵉ ⵉⵇⵙⴻⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN41_32","002_41_32","GEN","41","32","32","ⵄⵍⴰⵃⵙⴰⴱ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏ ⵜⴰⵔⵊⵉⵜ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵎⵉⵏⵣⵉ ⵢⵓⵔⴰ ⵜⵜ ⴰⵔⴻⴱⴱⵉ ⵏⵉⵛⴰⵏ ⵓ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⴰⴷ ⵜⵜ ⵢⴻⴳⴳ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_33","002_41_33","GEN","41","33","33","ⴻⵊⵊ ⴼⵉⵔⵄⵓⵏ ⵍⴻⵅⵅⵓ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵜⵉⵖⵉⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴳⴳ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_34","002_41_34","GEN","41","34","34","ⴻⵊⵊ ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⵉⴳⴳ ⴰⵎⵎⵓ: ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴳⴳ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵙⵉⵏ ⵍⴻⵅⵎⵓⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵢⴰⵡⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_35","002_41_35","GEN","41","35","35","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵡⴻⵍⵜ ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵚⴻⴱⵃⴻⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴻⵎⵎⵍⴻⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵅⴻⵎⵎⵍⴻⵏ ⴷ ⵎⴰⵛⵛⴰ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN41_36","002_41_36","GEN","41","36","36","ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵅⵣⴻⵏ ⵏ ⵎⴰⵛⵛⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵡⴹⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ ⵙ ⵍⴰⵥ.” ");
INSERT INTO rift_vpl VALUES ("GN41_37","002_41_37","GEN","41","37","37","ⴰⵡⴰⵍⴻⵏ-ⴰ ⴱⴰⵏⴻⵏ-ⴷⴷ ⴷ ⵍⴻⵎⵍⵉⵃ ⵉ ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN41_38","002_41_38","GEN","41","38","38","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴼ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵡⴰ ⵉ ⴷⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("GN41_39","002_41_39","GEN","41","39","39","ⵓⵛⴰ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ: “ⵓⵎⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵎⴻⵍ ⴰⵛ-ⴷⴷ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⵅ ⵓⵢⴰ ⵡⴰⵔ ⴷⵉⵏ ⵢⴻⴵⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵜⵉⵖⵉⵜ ⴰⵎ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("GN41_40","002_41_40","GEN","41","40","40","ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⴰⴷ ⵉⵟⴰⵄ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⴰⵔⵔⴰ. ⵎⵖⵉⵔ ⵅ ⵍⵄⴰⵔⵛ ⵡⴰⵀⴰ ⴰⴷ ⵉⵍⵉⵖ ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("GN41_41","002_41_41","GEN","41","41","41","ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ: “ⵅⵣⴰⵔ, ⴳⴳⵉⵖ ⵛⴻⴽ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN41_42","002_41_42","GEN","41","42","42","ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⴼⵉⵔⵄⵓⵏ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵉⵙⵙⵢⴰⵔⴹ ⴰⵙ ⴰⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵜⴰⵙⴻⴷⴷⴻⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷⴻⴳ ⵢⵉⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN41_43","002_41_43","GEN","41","43","43","ⵉⵙⵙⴻⵏⵢⴰ ⵉ-ⵜ ⴷⵉ ⵜⴽⴰⵔⵔⵓⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵍⴰⵖⴰⵏ ⴰⵎ ⴳⴳⵓⵔⴻⵏ ⵣⵣⴰⵜⴻⵙ: “ⵇⴻⵡⵙ!” ⴰⵎⵎⵓ ⵉ ⵜ ⵉⴳⴳⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_44","002_41_44","GEN","41","44","44","ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ: “ⵏⴻⵛⵛ ⴷ ⴼⵉⵔⵄⵓⵏ, ⴱⵍⴰ ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⴹⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN41_45","002_41_45","GEN","41","45","45","ⵉⵍⴰⵖⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵚⴰⴼⵏⴰⵜ-ⴼⴰⵄⵏⵉⵃ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⵙⵏⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴼⵓⵜⵉ-ⴼⴰⵔⴰⵄ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵓⵏ. ⵓⵛⴰ ⵉⵊⵓⵍ ⵢⵓⵙⵓⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_46","002_41_46","GEN","41","46","46","ⵜⵓⵖⴰ ⵢⵓⵙⵓⴼ ⴷ ⵎⵎⵉⵙ ⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵍⴰⵎⵉ ⵉⴱⴻⴷⴷ ⵏⴻⵜⵜⴰ ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵢⵓⵙⵓⴼ ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵊⵓⵍ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_47","002_41_47","GEN","41","47","47","ⵓⵛⴰ ⵜⴻⵙⵙⴻⵖⵎⵉ-ⴷⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙ ⵜⵢⴰⵡⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_48","002_41_48","GEN","41","48","48","ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵛⵛⴰ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵢⴰⵡⴰⵏⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵉⵅⴻⵎⵎⴻⵍ ⵎⴰⵛⵛⴰ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ. ⵎⴰⵛⵛⴰ ⵏ ⵉⵢⵢⴰⵔⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ, ⵉⵅⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ ⴷⴰⵢⴻⵙ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN41_49","002_41_49","GEN","41","49","49","ⵢⵓⵙⵓⴼ ⵉⵅⴻⵎⵎⴻⵍ ⵍⵃⴻⴱⴱ ⵏ ⵉⵔⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⴷⵉ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("GN41_50","002_41_50","GEN","41","50","50","ⵇⴱⴻⵍ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵍⴰⵥ, ⵎⵎⴰⵔⴻⵏⵢⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵢⵓⵙⵓⴼ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵔⵓⵡ ⴰⵙⵏⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⴼⵓⵜⵉ-ⴼⴰⵔⴰⵄ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN41_51","002_41_51","GEN","41","51","51","ⵉⵙⴻⵎⵎⴰ ⵢⵓⵙⵓⴼ ⴰⵎⴻⵏⵣⵓ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵙⵙⴻⵜⵜⵓ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴰⵔⴰ ⵉⵏⵓ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN41_52","002_41_52","GEN","41","52","52","ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵙⴻⵎⵎⴰ ⵉ-ⵜ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⵙ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN41_53","002_41_53","GEN","41","53","53","ⵅⴻⵏⵏⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⵉ ⵉⴽⴽⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("GN41_54","002_41_54","GEN","41","54","54","ⵓⵛⴰ ⴱⴷⴰⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵢⵓⵙⵓⴼ. ⵜⵓⵖⴰ ⵍⴰⵥ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ, ⵎⴰⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵄⴰⴷ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GN41_55","002_41_55","GEN","41","55","55","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵍⴰⵥ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵙⵖⵓⵢ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵅ ⵡⴻⵖⵔⵓⵎ. ⵓⵛⴰ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⵢⵓⵙⵓⴼ, ⴳⴳⴻⵎ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵢⵉⵏⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN41_56","002_41_56","GEN","41","56","56","ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⵣⴻⴵⴻⵄ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵢⴰⵔⵣⴻⵎ ⵢⵓⵙⵓⴼ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵅⴻⵎⵎⴻⵍ, ⵓⵛⴰ ⵉⵣⵣⴻⵏⵣ ⵉ-ⵜ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⴷⵡⴻⵍ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN41_57","002_41_57","GEN","41","57","57","ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵡⴷⴰⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⵢⵓⵙⵓⴼ ⵃⵉⵎⴰ ⴰⴷ ⵙⵖⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN42_1","002_42_1","GEN","42","1","1","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵄⵇⵓⴱ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷⵉⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ “ⵎⴰⵖⴰⵔ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("GN42_2","002_42_2","GEN","42","2","2","ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⴱⴻⵍⵍⵉ ⴷⵉⵏ ⵉⵎⴻⵏⴷⵉ ⴷⵉ ⵎⵉⵚⵔⴰ. ⵔⵓⵃⴻⵎ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⵙⵖⴻⵎ ⴰⵏⴻⵖ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵍⵃⴻⴱⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏⴻⴷⴷⴰⵔ ⵓⵛⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN42_3","002_42_3","GEN","42","3","3","ⵀⵡⴰⵏ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏ ⵢⵓⵙⵓⴼ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵔⴰⵃⴻⵏ ⴰⴷ ⵙⵖⴻⵏ ⵉⵎⴻⵏⴷⵉ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN42_4","002_42_4","GEN","42","4","4","ⵎⴰⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⵉⵙⵙⴻⴽⴽ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓⵎⴰⵙ ⵏ ⵢⵓⵙⵓⴼ, ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN42_5","002_42_5","GEN","42","5","5","ⵊⴰⵔ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⵉⵏⵏⵉ, ⵓⵙⵉⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵖⴻⵏ ⵎⴰⵛⵛⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN42_6","002_42_6","GEN","42","6","6","ⵜⵓⵖⴰ ⵢⵓⵙⵓⴼ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵣⵣⴻⵏⵣ ⵉⵎⴻⵏⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⴰⵢⵜⵎⴰⵙ ⵏ ⵢⵓⵙⵓⴼ, ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN42_7","002_42_7","GEN","42","7","7","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⵓⵙⵓⴼ ⴰⵢⵜⵎⴰⵙ, ⵉⵄⵇⴻⵍ ⵉ-ⵜⴻⵏ, ⵎⴰⵛⴰ ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵉⵏ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⵉⵎ?” ⵏⵏⴰⵏ: “ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵙⴻⵖ ⵎⴰⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN42_8","002_42_8","GEN","42","8","8","ⵢⵓⵙⵓⴼ ⵉⵄⴻⵇⵍ ⴰⵢⵜⵎⴰⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜ ⵄⵇⵉⵍⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN42_9","002_42_9","GEN","42","9","9","ⵉⴼⴻⴽⴽⴰⵔ ⵢⵓⵙⵓⴼ ⴷⵉ ⵜⵉⵔⵊⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵢⵓⵔⵊⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ ⵉ ⵜⴻⴵⴰⵎ, ⵜⵓⵙⵉⵎ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵃⴹⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN42_10","002_42_10","GEN","42","10","10","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵄⴰⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵙⵉⵏ-ⴷⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵖⴻⵏ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN42_11","002_42_11","GEN","42","11","11","ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⴰⵇⴰ ⴰⵏⴻⵖ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN42_12","002_42_12","GEN","42","12","12","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵍⵍⴰ, ⴽⴻⵏⵏⵉⵡ ⵜⵓⵙⵉⵎ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN42_13","002_42_13","GEN","42","13","13","ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ: “ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵜⴰⵔⵡⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⴰⵇⴰ ⴰⵎⴰⵥⵓⵥ ⴰⵇⴰ-ⵜ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN42_14","002_42_14","GEN","42","14","14","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜ ⵏⵏⵉⵖ ⵓⵎⵉ ⵏⵏⵉⵖ: ‘ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("GN42_15","002_42_15","GEN","42","15","15","ⵙ ⵓⵢⴰ ⵜᵉⵜⵜⵡⴰⵇⴻⴵⴱⴻⵎ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵎ ⵙⵙⴰ, ⵎⵖⵉⵔ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵎⴰⵜⵡⴻⵎ ⴰⵎⴰⵥⵓⵥ ⴷⴰⵏⵉⵜⴰ! ");
INSERT INTO rift_vpl VALUES ("GN42_16","002_42_16","GEN","42","16","16","ⵙⴻⴽⴽⴻⵎ ⵉⵊⵊ ⵏ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵓⵎⴰⵜⵡⴻⵎ. ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵎ ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴵⴱⴻⵏ, ⵎⴰ ⴷⴰⵢⵡⴻⵎ ⵍⴰⵎⴰⵏ. ⵎⴰⵍⴰ ⵍⵍⴰ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN42_17","002_42_17","GEN","42","17","17","ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN42_18","002_42_18","GEN","42","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ: “ⴳⴳⴻⵎ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴻⴷⴷⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⵯⴷⴻⵖ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GN42_19","002_42_19","GEN","42","19","19","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ, ⵊⵊⴻⵎ ⵅⴻⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵎⴰⵜⵡⴻⵎ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵛⴰⵔⴼ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵎ, ⴽⵙⵉⵎ ⵉⵎⴻⵏⴷⵉ ⵉ ⵍⴰⵥ ⵏ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN42_20","002_42_20","GEN","42","20","20","ⴰⵡⵢⴻⵎ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵓⵎⴰⵜⵡⴻⵎ, ⴰⵎⴰⵥⵓⵥ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴵⴱⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ.” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN42_21","002_42_21","GEN","42","21","21","ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵏⴰⵔⵔ ⴷⴷⴻⵢⵢⴻⵜ ⵏ ⵓⵎⴰⵜⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⵍⵃⴻⵚⵔⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵓⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴰⵔ ⴰⵃⵉⵏⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵏⴻⵙⵍⵉ ⵛⴰ! ⵅ ⵓⵢⴰ ⴷⴷ-ⵢⵓⵙⴰ ⵍⵃⴻⵚⵔⴰⵏ-ⴰ ⵅⴰⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN42_22","002_42_22","GEN","42","22","22","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵔⵓⴱⵉⵏ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜ ⵏⵏⵉⵖ, ⵓⵎⵉ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵅⴻⵟⵟⵉⵎ ⵛⴰ ⴰⴽ-ⴷ ⵓⵃⴻⵏⵊⵉⵔ!’, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ. ⵅⵣⴰⵔ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵜⵜⴰⵔⴻⵏ ⵍⴻⵅⵅⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN42_23","002_42_23","GEN","42","23","23","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵉⴼⵀⴻⵎ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⵓⵔⵊⵎⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN42_24","002_42_24","GEN","42","24","24","ⵉⵏⵏⴻⵇⵍⴻⴱ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵖⵓⵢ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔⵙⴻⵏ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⴽⵙⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ ⵓⵛⴰ ⵉⵃⴻⴱⴱⴻⵙ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN42_25","002_42_25","GEN","42","25","25","ⵢⵓⵎⵓⵔ ⵢⵓⵙⵓⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏⵙⴻⵏ ⵙ ⵉⵎⴻⵏⴷⵉ ⵓ ⴰⴷ ⴳⴳⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⴽⵓⵍ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵎⴰⵛⵛⴰ ⵉ ⵡⴻⴱⵔⵉⴷ. ⵓ ⴰⵎⵎⵓ ⵉ ⴽⵉⴷⵙⴻⵏ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN42_26","002_42_26","GEN","42","26","26","ⵙⵙⴰⵔⴱⵓⵏ ⵉⵎⴻⵏⴷⵉ ⵏⵙⴻⵏ ⵅ ⵢⴻⵖⵢⴰⵍ ⵏⵙⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN42_27","002_42_27","GEN","42","27","27","ⵓⵎⵉ ⵢⴰⵔⵣⴻⵎ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵛⵛ ⴰⵖⵢⵓⵍ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⵙⴻⵏ, ⵉⵥⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⴰⵔⵣⴰⵎ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN42_28","002_42_28","GEN","42","28","28","ⵉⵏⵏⴰ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵏⵏⵓⵇⴰⵔⵜ ⵉⵏⵓ ⵜⴻⴷⵡⴻⵍ ⴰⵢⵉ-ⴷⴷ. ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜⵜ ⴷⴰ ⴷⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵉⵏⵓ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⴰⵙⴻⵏ ⵡⵓⵍ, ⴰⵔⵊⵉⵊⴻⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵎⴰⵏⴰⵡⵢⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⴳⴳ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("GN42_29","002_42_29","GEN","42","29","29","ⵓⵛⴰ ⵔⴻⵃⵃⴳⴻⵏ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵢⴰⵄⵇⵓⴱ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓⵛⴰ ⵄⴰⵡⴷⴻⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙⴻⵏ ⵉⴽⴽⵉⵏ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("GN42_30","002_42_30","GEN","42","30","30","“ⴰⵔⵢⴰⵣ, ⴱⴰⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵏⴻⵖ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ, ⵉⵃⴻⵙⴱ ⴰⵏⴻⵖ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN42_31","002_42_31","GEN","42","31","31","ⵎⴰⵛⴰ ⵏⴻⵏⵏⴰ ⴰⵙ: ‘ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵏⴻⴵⵉ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN42_32","002_42_32","GEN","42","32","32","ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ. ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵇⵇⵉⵎ, ⴰⵎⴰⵥⵓⵥ ⴰⵇⴰ-ⵜ ⴰⵙⵙ-ⴰ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("GN42_33","002_42_33","GEN","42","33","33","ⵓ ⴰⵔⵢⴰⵣ ⵏⵏⵉ, ⴱⴰⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴰ ⴰⵏⴻⵖ: ‘ⵙ ⵓⵢⴰ ⴰⴷ ⵙⵙⵏⴻⵖ, ⵎⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ. ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⵊⵊⴻⵎ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵎⴰⵛⵛⴰ ⵉ ⵍⴰⵥ ⵏⵏⵉ ⴷⵉⵏ ⵖⴰⵔ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN42_34","002_42_34","GEN","42","34","34","ⴰⵡⵢⴻⵎ-ⴷⴷ ⴷⴰ ⵓⵎⴰⵜⵡⴻⵎ, ⴰⵎⴰⵥⵓⵥ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵅⵓⵖ ⵉ ⵡⴰⵎⴰⵜⵡⴻⵎ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⴰⴷ ⵜⵊⵓⵍⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("GN42_35","002_42_35","GEN","42","35","35","ⵓⵎⵉ ⵙⵙⴻⵅⵡⴰⵏ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏⵙⴻⵏ, ⵃⴻⴽⴽⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⴷⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵜⴰⵛⵢⴰⵔⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵙ. ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵜⵉⵛⵢⴰⵔ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⵓⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("GN42_36","002_42_36","GEN","42","36","36","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵢⴰⵄⵇⵓⴱ: “ⴰⵇⴰ ⵜⵃⴰⵔⵔⵎⴻⵎ ⴰⵢⵉ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ! ⵢⵓⵙⵓⴼ ⵡⴰⵔ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵛⵉⵎⵄⵓⵏ, ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵏⴻⴷⵀⴻⵎ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⴻⵎⵙⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵄⴽⴻⵙ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN42_37","002_42_37","GEN","42","37","37","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵔⵓⴱⵉⵏ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ: “ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⵉⵖ. ⴻⵡⵛ ⴰⵢⵉ ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("GN42_38","002_42_38","GEN","42","38","38","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵔⵉⵃ ⵛⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵓⵎⴰⵙ ⵉⵎⵎⵓⵜ ⵓ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ ⵉ ⴷ ⴰⵢⵉ ⵉⵇⵇⵉⵎⴻⵏ. ⵎⴰⵍⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵛⴰ ⵏ ⵍⵖⴰⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⵎ, ⴰⴷ ⵜⴻⵙⵙⴻⵀⵡⴰⵎ ⵛⵛⵉⴱ ⵉⵏⵓ ⵙ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN43_1","002_43_1","GEN","43","1","1","ⵎⴰⵛⴰ ⵍⴰⵥ ⵜⵓⵖⴰ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN43_2","002_43_2","GEN","43","2","2","ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵛⵛⵉⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ ⵏⵏⵉ ⴽⵉⴷⵙⴻⵏ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ: “ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵙⵖⴻⵎ ⴰⵏⴻⵖ-ⴷⴷ ⵛⵡⴰⵢⵜ ⵏ ⵎⴰⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN43_3","002_43_3","GEN","43","3","3","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵏⴻⵖ ⵙ ⵓⵔⴻⴽⴽⴻⵣ: “ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ ⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⵉⵡⵢⴻⵎ-ⴷⴷ ⵓⵎⴰⵜⵡⴻⵎ ⴰⴽⵉⴷⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN43_4","002_43_4","GEN","43","4","4","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵓⵎⴰⵜⵏⴻⵖ ⴰⴽⵉⴷⵏⴻⵖ, ⴰⴷ ⵏⵔⴰⵃ ⴷⵉⵏ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⴷⴷ-ⵏⵙⴻⵖ ⵎⴰⵛⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("GN43_5","002_43_5","GEN","43","5","5","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜ ⵜᵉⵙⵙⴻⴽⴽⵉⴷ ⴰⴽⵉⴷⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵏⴻⵜⵜⵔⴰⵃ, ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵏⴻⵖ: ‘ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ ⵓⴷⴻⵎ ⵉⵏⵓ ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⴰⵜⵡⴻⵎ ⴰⴽⵉⴷⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("GN43_6","002_43_6","GEN","43","6","6","ⵉⵏⵏⴰ ⵉⵙⵔⴰⵉⵍ: “ⵎⴰⵖⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⵎ ⵍⵖⴰⵔ ⵓⵛⴰ ⵜⴻⵏⵏⴰⵎ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵖⴰⵔⵡⴻⵎ ⵄⴰⴷ ⵓⵎⴰⵜⵡⴻⵎ ⵏⵏⴻⵖⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("GN43_7","002_43_7","GEN","43","7","7","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵅⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵏⴻⵅⵍⴻⵇ, ⵉⵏⵏⴰ: ‘ⵎⴰ ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ? ⵎⴰ ⵖⴰⵔⵡⴻⵎ ⵛⴰ ⵏ ⵓⵎⴰⵜⵡⴻⵎ ⵏⵏⴻⵖⵏⵉ?’ ⵅⴻⵏⵏⵉ ⵏⵄⴰⵡⴻⴷ ⴰⵙ ⵜ. ⵎⴰ ⵏⵣⴻⵎⵎⴰⵔ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴷ ⴷⴷ-ⵏⴻⵊⴱⴻⴷ ⵉⵍⵍⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵣⴻⵄⵎⴰ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵡⵢⴻⵎ-ⴷⴷ ⵓⵎⴰⵜⵡⴻⵎ?’” ");
INSERT INTO rift_vpl VALUES ("GN43_8","002_43_8","GEN","43","8","8","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ ⵉ ⴱⴰⴱⴰⵙ ⵉⵙⵔⴰⵉⵍ: “ⵙⴻⴽⴽ ⴰⴽⵉⴷⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⴰⴷ ⵏⴻⴽⴽⴰⵔ ⴰⴷ ⵏⵔⴰⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵓ ⵡⴰⵔ ⵏᵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵛⴻⴽ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN43_9","002_43_9","GEN","43","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵉⵍⵉⵖ ⴷ ⴰⴹⵎⴰⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⴷ ⵜ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵄⴰⵡⴻⴷ. ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⵉⵖ, ⴰⴷ ⵜ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜⴻⴽ, ⴰⴷ ⵢⵉⵍⵉ ⵅⴹⵉⵖ ⴰⴽⵉⴷⴻⴽ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("GN43_10","002_43_10","GEN","43","10","10","ⵎⴻⵄⵍⵉⴽ ⵡⴰⵔ ⵏⴻⵇⵇⵉⵎ ⵏⴻⵜⵜⵔⴰⵊⴰ ⴰⵟⵟⴰⵙ, ⵜⵉⵍⵉ ⵍⴻⵅⵅⵓ ⵏⴻⴷⵡⴻⵍ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN43_11","002_43_11","GEN","43","11","11","ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵙⵔⴰⵉⵍ, ⴱⴰⴱⴰⵜⵙⴻⵏ: “ⵎⴰⵍⴰ ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵙ ⵜⵉⴷⴻⵜⵜ, ⴳⴳⴻⵎ ⴰⵎⵎⵓ ⵓⵛⴰ ⴽⵙⵉⵎ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏⵡⴻⵎ, ⵀⵡⴰⵎ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⵉⵡⵢⴻⵎ ⴷ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ: ⵛⵡⴰⵢⵜ ⵏ ⴱⴰⵍⵙⴰⵎ ⴷ ⵛⵡⴰⵢⵜ ⵏ ⵜⴰⵎⵎⴻⵏⵜ, ⵍⴻⵄⵟⵓⵔ ⴷ ⵎⵉⵔⵔⵓ ⴷ ⵜⴻⵖⵢⴰⵛⵜ ⵏ ⴱⵉⵙⵜⴰⵛ ⴷ ⴵⵓⵣ. ");
INSERT INTO rift_vpl VALUES ("GN43_12","002_43_12","GEN","43","12","12","ⴽⵙⵉⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵏ ⵜⴻⵏⵄⴰⵛⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⴰⵔⵔⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏⵡⴻⵎ. ⴰⴷ ⵜⴰⵖ ⵜⵓⵖⴰ ⴷ ⵛⴰ ⵏ ⵍⵖⴰⵍⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("GN43_13","002_43_13","GEN","43","13","13","ⴰⵡⵢⴻⵎ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵓⵎⴰⵜⵡⴻⵎ ⴰⴽⵉⴷⵡⴻⵎ, ⴽⴽⴰⵔⴻⵎ, ⵄⴻⵇⴱⴻⵎ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN43_14","002_43_14","GEN","43","14","14","ⵓⵛⴰ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵓⵎⴰⵜⵡⴻⵎ ⵏⵏⴻⵖⵏⵉ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵓ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏⴻⵛⵛ, ⵎⴰⵍⴰ ⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵖ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("GN43_15","002_43_15","GEN","43","15","15","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵓⵛⴰ ⴽⵙⵉⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵍⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ, ⵀⵡⴰⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("GN43_16","002_43_16","GEN","43","16","16","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⵓⵙⵓⴼ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ: “ⵙⵉⴷⴻⴼ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵜⵖⴰⵔⵚⵜ, ⵙⴻⵡⵊⴻⴷ ⵉ-ⵜⵜ, ⵎⵉⵏⵣⵉ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⴰⴷ ⴽⵉⴷⵉ ⵛⵛⴻⵏ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN43_17","002_43_17","GEN","43","17","17","ⵉⴳⴳⴰ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵢⵉⵡⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("GN43_18","002_43_18","GEN","43","18","18","ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⵉⴷⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵅ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⴷⴻⵡⵍⴻⵏ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏⵏⴻⵖ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉⵡⵢⴻⵏ ⴰⵏⴻⵖ-ⴷⴷ ⴷⴰ ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵄⴻⴼⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵄⴻⴷⴷⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵏⴻⵖ ⴽⵙⵉⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴰⴽ-ⴷ ⵢⴻⵖⵢⴰⵍ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN43_19","002_43_19","GEN","43","19","19","ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴳⴳⴰ ⵢⵓⵙⵓⴼ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("GN43_20","002_43_20","GEN","43","20","20","ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⵉⵛⴰⵏ ⵏⴻⵀⵡⴰ-ⴷⴷ ⴷ ⴰⵎⴻⵣⵡⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵙⴻⵖ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN43_21","002_43_21","GEN","43","21","21","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⴷⴷ-ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵓⵛⴰ ⵏⴰⵔⵣⴻⵎ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏⵏⴻⵖ, ⵏⴻⵥⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵔⵣⴰⵎ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵙ, ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵖ ⵙ ⵍⵎⵉⵣⴰⵏ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ. ⴰⵇⴰ ⵏⴰⵔⵔⴰ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN43_22","002_43_22","GEN","43","22","22","ⵄⴰⵡⴻⴷ ⵏⵉⵡⵉ-ⴷⴷ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⴻⵖ ⵎⴰⵛⵛⴰ. ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵡⵉ ⵉⴳⴳⵉⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN43_23","002_43_23","GEN","43","23","23","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵙⵍⴰⵎ ⵅⴰⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ! ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵉⵛⵜ ⵏ ⵜⵅⴰⴱⴻⵛⵜ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏⵡⴻⵎ. ⴰⵇⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵡⴻⵎ ⵟⵟⴼⴻⵖ ⵜⵜ.” ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN43_24","002_43_24","GEN","43","24","24","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⴷⴻⴼ ⵡⴻⵔⵢⴰⵣ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵎⴰⵏ ⵓⵛⴰ ⵙⵉⵔⴷⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ. ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵍⴻⵄⵍⴻⴼ ⵉ ⵢⴻⵖⵢⴰⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN43_25","002_43_25","GEN","43","25","25","ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵉ ⵢⵓⵙⵓⴼ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⴰⵇⴰ ⴰⴷ ⵛⵛⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN43_26","002_43_26","GEN","43","26","26","ⵍⴰⵎⵉ ⴷⴷ- ⵢⵓⴷⴻⴼ ⵢⵓⵙⵓⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵡⵛⵉⵏ ⴰⵙ-ⴷⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵔⵔⵉⵖⴰⵍⵓ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN43_27","002_43_27","GEN","43","27","27","ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⵅ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴱⴰⴱⴰⵜⵡⴻⵎ ⴰⵡⴻⵙⵙⴰⵔ ⵉ ⵅⴻⴼ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ? ⵎⴰ ⴰⵇⴰ ⵄⴰⴷ ⵉⴷⴷⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("GN43_28","002_43_28","GEN","43","28","28","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ: “ⵎⵍⵉⵀ ⵉ ⵢⴻⴵⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵏⴻⵜⵜⴰ ⵄⴰⴷ ⵉⴷⴷⴰⵔ.” ⵓⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴻⵏⴷⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("GN43_29","002_43_29","GEN","43","29","29","ⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵥⵔⴰ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓⵎⴰⵙ, ⵎⵎⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵉⵏⵏⴰ: “ⵎⴰ ⴷ ⵡⴰ ⴷ ⵓⵎⴰⵜⵡⴻⵎ, ⴰⵎⴰⵥⵓⵥ, ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ?” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⴰⴷ ⵅⴰⴽ ⵉⵃⵉⵏⵏ ⴰⵔⴻⴱⴱⵉ, ⴰ ⵎⵎⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN43_30","002_43_30","GEN","43","30","30","ⵢⵓⵙⵓⴼ ⵉⴼⴼⴻⵖ ⵅⴻⵏⵏⵉ ⴷⴻⵖⵢⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⵃⵏⵓⵏⴻⵛⵜ ⵏⵏⴻⵙ ⵅ ⵓⵎⴰⵙ ⵜⵓⵖⴰ ⵜⴻⵎⵖⴰⵔ. ⵢⴰⵔⵣⵓ ⵅ ⵎⴰⵏⵉ ⵖⴰ ⵉⵔⵓ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵓⵛⴰ ⵉⵔⵓ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN43_31","002_43_31","GEN","43","31","31","ⵉⵙⵙⵉⵔⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵇⴻⴷⵎⴻⵎ-ⴷⴷ ⵎⴰⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN43_32","002_43_32","GEN","43","32","32","ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵙ ⵉ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ ⵓ ⵉ ⵏⵉⵜⵏⵉ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⵓⵍⴰ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵛⵛⵉⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⴰⴽ-ⴷ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵖⴰⵔ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN43_33","002_43_33","GEN","43","33","33","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ: ⴰⵎⴻⵏⵣⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵎⴰⵥⵓⵥ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⵜⴱⴻⵀⴰⵜⴻⵏ, ⵅⴻⵣⵣⴰⵔⴻⵏ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN43_34","002_43_34","GEN","43","34","34","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵇⴻⴷⴷⴻⵎ ⴰⵙⴻⵏ-ⴷⴷ ⵣⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵣⵣⴰⵜⴻⵙ, ⵎⴰⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⵓⵖⴰ-ⵜⵜ ⵅⴻⵎⵙⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⴽⵜⴰⵔ ⵣⵉ ⵜⵙⴻⵇⵇⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ. ⵓⵛⴰ ⵙⵡⵉⵏ ⵏⵉⵜⵏⵉ, ⵙⵙⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴼⴰⵔⵃⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN44_1","002_44_1","GEN","44","1","1","ⵉⵙⵙⴻⴽⴽ ⵢⵓⵙⵓⴼ ⵖⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵄⴻⵎⵎⴰⵔ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙ ⵎⴰⵛⵛⴰ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⵙⵉⵏ. ⴻⴳⴳ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵡⴰⵔⵣⴰⵎ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN44_2","002_44_2","GEN","44","2","2","ⵙⴰⵔⵙ ⵍⴽⴰⵙ ⵉⵏⵓ, ⵍⴽⴰⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴷⴻⴳ ⵡⴰⵔⵣⴰⵎ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵓⵎⴰⵥⵓⵥ ⴰⴽ-ⴷ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵍⵃⴻⴱⴱ ⵏⵏⴻⵙ ⵏ ⵢⵉⵔⴷⴻⵏ.” ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("GN44_3","002_44_3","GEN","44","3","3","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵓⵎⵉ ⴷⴷ-ⵢⴻⴼⴼⵓ ⵍⵀⴰⵍ, ⵊⵊⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴽ-ⴷ ⵢⴻⵖⵢⴰⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN44_4","002_44_4","GEN","44","4","4","ⵓⵎⵉ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴳⴳⵯⵉⵊⴻⵏ ⵛⴰ, ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ: “ⴽⴽⴰⵔ, ⴹⴼⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵓⵛⴰ, ⵅⵎⵉ ⵅⴰⵙⴻⵏ ⵖⴰ ⵜⴻⵄⴷⵓⴷ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵎⴰⵖⴰⵔ ⴷⴷ-ⵜⴰⵔⵔⴰⵎ ⵍⵅⴰⵔ ⵙ ⵍⵖⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("GN44_5","002_44_5","GEN","44","5","5","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰ ⴷ ⵍⴽⴰⵙ ⵉ ⵣⵉ ⵉⵙⴻⵙⵙ ⵙⵉⴷⵉ ⵉⵏⵓ ⵓ ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵡⴰ ⵉ ⵣⵉ ⵖⴰ ⵉⴽⴰⵛⴻⴼ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⵜⵉⵡⴻⵛⵛⴰ? ⴰⵇⴰ ⵜⴻⴳⴳⵉⵎ ⵍⵖⴰⵔ ⵓⵎⵉ ⵜⴻⴳⴳⵉⵎ ⴰⵎⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("GN44_6","002_44_6","GEN","44","6","6","ⴰⵎ ⵜⴻⵏ ⵉⵄⴷⵓ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN44_7","002_44_7","GEN","44","7","7","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵡⴰⵍⴻⵏ-ⴰ? ⵉⴳⴳⵯⴻⵊ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN44_8","002_44_8","GEN","44","8","8","ⵅⵣⴰⵔ, ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵏⵓⴼⴰ ⴷⴻⴳ ⵡⴰⵔⵣⴰⵎ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵏⴰⵔⵔ ⴰⵛ ⵜⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵎⴰⵎⵎⴻⵛ ⵄⴰⴷ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⴰⴷ ⵏⴰⵛⴰⵔ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⵓⵔⴻⵖ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("GN44_9","002_44_9","GEN","44","9","9","ⵡⵉ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵉ ⵖⴰⵔ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼ ⵍⴽⴰⵙ, ⴰⴷ ⵉⵎⵎⴻⵜ, ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵄⴰⵡⴻⴷ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN44_10","002_44_10","GEN","44","10","10","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⴰⵎ ⴽⴻⵏⵏⵉⵡ. ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜ ⵖⴰ ⵏⴰⴼ, ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵙⵎⴻⵖ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⴼⵓⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN44_11","002_44_11","GEN","44","11","11","ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⴻⴵⴻⵇ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵢⴰⵔⵣⴻⵎ ⵜⴰⵅⴰⵏⵛⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN44_12","002_44_12","GEN","44","12","12","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴻⵜⵜⴻⵛ ⵉ-ⵜⴻⵏⵜ, ⵉⴱⴷⴰ ⵣⴻⴳ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉⴽⴻⵎⵎⴻⵍ ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ, ⵓⵛⴰ ⵓⴼⵉⵏ ⵍⴽⴰⵙ ⴷⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN44_13","002_44_13","GEN","44","13","13","ⵅⴻⵏⵏⵉ ⵛⴰⵔⵔⴳⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵉⵙⵙⴰⵔⴱⵓ ⵄⴰⵡⴻⴷ ⵅ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("GN44_14","002_44_14","GEN","44","14","14","ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵢⴰⵀⵓⴷⴰ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⴷ, ⵓⵛⴰ ⵡⴹⴰⵏ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN44_15","002_44_15","GEN","44","15","15","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ: “ⵎⴰⵏⴰ ⵛⵖⴻⵍ-ⴰ ⵉ ⵜⴻⴳⴳⵉⵎ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵏⴻⵛⵛ, ⵉⴳⴳⵓⵔ ⴰⴷ ⵅⴰⵙ ⵉⴽⴰⵛⴻⴼ ⵏⵉⵛⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("GN44_16","002_44_16","GEN","44","16","16","ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ: “ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵏⵉⵖ ⵙ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵏⵙⴻⴳⴳⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵖ? ⴰⵔⴻⴱⴱⵉ ⵉⵇⴻⴵⴻⴱ ⴷⴷⴻⵏⴱ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵡⵉ ⵖⴰⵔ ⵓⴼⵉⵏ ⵍⴽⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN44_17","002_44_17","GEN","44","17","17","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ: “ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⴰⴷ ⴳⴳⴻⵖ ⴰⵢⴰ! ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵖⴰⵔ ⵓⴼⵉⵏ ⵍⴽⴰⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵙⵎⴻⵖ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵔⵓⵃⴻⵎ ⴷⵉ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN44_18","002_44_18","GEN","44","18","18","ⵅⴻⵏⵏⵉ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴷⴻⴳ ⵓⵎⴻⵣⵣⵓⵖ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵢⴰⵔⴻⵇⵇ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵛ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵛⴻⴽ ⴰⵎ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN44_19","002_44_19","GEN","44","19","19","ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵙⵙⴻⵇⵙⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ‘ⵎⴰ ⵖⴰⵔⵡⴻⵎ ⵄⴰⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵏⵉⵖ ⵜⴰⵡⵎⴰⵜ?’ ");
INSERT INTO rift_vpl VALUES ("GN44_20","002_44_20","GEN","44","20","20","ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵔⴰ ⵅ ⵙⵉⴷⵉ ⵉⵏⵓ: ‘ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⴱⴰⴱⴰⵜⵏⴻⵖ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵅ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ, ⴷ ⴰⵎⴰⵥⵓⵥ ⵄⴰⴷ. ⵓⵎⴰⵙ ⵉⵎⵎⵓⵜ, ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵓ ⴱⴰⴱⴰⵙ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ.’ ");
INSERT INTO rift_vpl VALUES ("GN44_21","002_44_21","GEN","44","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵏⵏⵉⴷ ⵛⴻⴽ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ: ‘ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴷⴰ ⵖⴰⵔⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵥⴰⵔⴻⵖ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("GN44_22","002_44_22","GEN","44","22","22","ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵏⵏⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ‘ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵢⴻⵊⵊ ⴱⴰⴱⴰⵙ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵊⵊⴰ ⵉ-ⵜ, ⴱⴰⴱⴰⵙ ⴰⴷ ⵉⵎⵎⴻⵜ.’ ");
INSERT INTO rift_vpl VALUES ("GN44_23","002_44_23","GEN","44","23","23","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⵉⴷ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ: ‘ⵎⴰⵍⴰ ⵓⵎⴰⵜⵡⴻⵎ ⴰⵎⴰⵥⵓⵥ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⴰⴽⵉⴷⵡⴻⵎ, ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ ⵓⴷⴻⵎ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("GN44_24","002_44_24","GEN","44","24","24","ⵍⴰⵎⵉ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⴱⴰⴱⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵏⴻⵙⵙⴻⵄⴷⵓ ⴰⵙ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN44_25","002_44_25","GEN","44","25","25","ⵓⵛⴰ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵉⵏⵏⴰ: ‘ⵄⴻⵇⴱⴻⵎ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵖⴻⵎ ⵛⵡⴰⵢⵜ ⵏ ⵎⴰⵛⵛⴰ ⵉ ⵏⴻⵛⵛⵉⵏ.’ ");
INSERT INTO rift_vpl VALUES ("GN44_26","002_44_26","GEN","44","26","26","ⵅⴻⵏⵏⵉ ⵏⴰⵔⵔⴰ-ⴷⴷ: ‘ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵔⴰⵃ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵓⵎⴰⵜⵏⴻⵖ, ⴰⵎⴰⵥⵓⵥ, ⵉⵔⵓⵃ ⴰⴽⵉⴷⵏⴻⵖ, ⴰⴷ ⵏⵔⴰⵃ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵥⴰⵔ ⵓⴷⴻⵎ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⴰⵇⴰ ⴰⴽⵉⴷⵏⴻⵖ ⵓⵎⴰⵜⵏⴻⵖ ⴰⵎⴰⵥⵓⵥ.’ ");
INSERT INTO rift_vpl VALUES ("GN44_27","002_44_27","GEN","44","27","27","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵏⴻⵖ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰⵜⵏⴻⵖ: ‘ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN44_28","002_44_28","GEN","44","28","28","ⵉⴼⴼⴻⵖ ⵉⵊⵊⴻⵏ ⵣⵉ ⵖⴰⵔⵉ ⵓⵛⴰ ⵏⵏⵉⵖ: ⴰⵇⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵉⵜⵜⵡⴰⴱⴻⵜⵜⴻⵇ! ⵓ ⴰⵍ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵡⴰⵔ ⵜ ⵥⵔⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("GN44_29","002_44_29","GEN","44","29","29","ⵎⴰⵍⴰ ⵄⴰⵡⴻⴷ ⵜⴻⴽⴽⵙⴻⵎ ⴰⵢⵉ ⵡⴰ ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵛⴰ ⵏ ⵍⵖⴰⵔ, ⴰⴷ ⵜⴻⵙⵙⴻⵀⵡⴰⵎ ⵛⵛⵉⴱ ⵉⵏⵓ ⵙ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("GN44_30","002_44_30","GEN","44","30","30","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵔⵓⵃⴻⵖ ⵏⴻⵛⵛ ⵖⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ, ⵓⵛⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⴵⵉ - ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵍⵚⴻⵇ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⴰⴱⴰⵙ - ");
INSERT INTO rift_vpl VALUES ("GN44_31","002_44_31","GEN","44","31","31","ⴰⵇⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵅⵎⵉ ⵖⴰ ⵉⵥⴰⵔ ⴰⵃⴻⵏⵊⵉⵔ ⵡⴰⵔ ⵉⴵⵉ, ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵙⴻⵀⵡⴰⵏ ⵛⵛⵉⴱ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵙ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN44_32","002_44_32","GEN","44","32","32","ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ ⵖⴰⵔ ⴱⴰⴱⴰ ⵓⵎⵉ ⵉⵏⵏⴰ: ‘ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⵉⵖ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⴻⴷⵏⵓⴱ ⵉ ⴱⴰⴱⴰ ⵉ ⵍⴻⴱⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("GN44_33","002_44_33","GEN","44","33","33","ⵉⵡⴰ ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ ⴰⵎ ⵢⵉⵙⵎⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵓⵛⴰ ⴻⵊⵊ ⴰⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵉⵔⴰⵃ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ! ");
INSERT INTO rift_vpl VALUES ("GN44_34","002_44_34","GEN","44","34","34","ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ, ⴱⵍⴰ ⴰⵃⴻⵏⵊⵉⵔ-ⴰ ⴰⴽⵉⴷⵉ? ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵥⴰⵔⴻⵖ ⵍⴻⵎⵃⴰⵢⴻⵏ ⵉ ⴷⴷ ⵖⴰ ⵉⵡⴹⴰⵏ ⵅ ⴱⴰⴱⴰ?” ");
INSERT INTO rift_vpl VALUES ("GN45_1","002_45_1","GEN","45","1","1","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵄⴰⴷ ⵢⵓⵙⵓⴼ ⴰⴷ ⵉⵟⵟⴻⴼ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⵉⵍⴰⵖⴰ: “ⵙⵓⴼⴼⵖⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ ⴷⴰ!” ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵃⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵍⴰⵎⵉ ⵉⵙⵙⵛⴻⵏ ⵢⵓⵙⵓⴼ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⵎⵉⵏ ⵉⵄⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_2","002_45_2","GEN","45","2","2","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵔⵅⵓ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵙ ⵉⵖⵓⵢⵢⴰⵏ, ⴰⵍⴰⵎⵉ ⴷ ⴰⵙ ⵙⵍⵉⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ ⵜⴻⵙⵍⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_3","002_45_3","GEN","45","3","3","ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵢⵓⵙⵓⴼ! ⵎⴰ ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⴱⴰⴱⴰ?” ⴰⵢⵜⵎⴰⵙ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN45_4","002_45_4","GEN","45","4","4","ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⵍⴻⵅⵅⵓ ⵖⴰⵔⵉ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔⴻⵙ. ⵉⵏⵏⴰ ⵅⴻⵏⵏⵉ: “ⵏⴻⵛⵛ ⴷ ⵢⵓⵙⵓⴼ ⵓⵎⴰⵜⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵜⴻⵣⵣⴻⵏⵣⴻⵎ ⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_5","002_45_5","GEN","45","5","5","ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵙ ⵡⴻⵎⵏⵓⵙ ⵓ ⵡⴰⵔ ⵜ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵅⴻⵢⵢⴻⵇ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵣⵣⴻⵏⵣⴻⵎ ⴷⴰⵏⵉⵜⴰ ⵉ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵊⵊⴻⵖ ⵜⴻⴷⴷⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN45_6","002_45_6","GEN","45","6","6","ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵇⵇⵉⵎ ⵄⴰⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜⵉⵍⵉ ⵜⵢⴰⵔⵣⴰ ⵏⵉⵖ ⵜⴰⵎⴻⵢⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_7","002_45_7","GEN","45","7","7","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵣⵣⴰⵜⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⵉⵖ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN45_8","002_45_8","GEN","45","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⵛⴰ ⴷⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ ⴷ ⴱⴰⴱⴰⵙ ⵉ ⴼⵉⵔⵄⵓⵏ ⴷ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_9","002_45_9","GEN","45","9","9","ⵇⴻⴵⵇⴻⵎ ⴷⴻⵖⵢⴰ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⵖⴰⵔ ⴱⴰⴱⴰ, ⵉⵏⵉⵎ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵎⵎⵉⵛ ⵢⵓⵙⵓⴼ: ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⴷ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵚⵔⴰ. ⴰⵔⴰⵃ-ⴷⴷ ⵖⴰⵔⵉ, ⵡⴰⵔ ⵜⵜⴻⵄⴳⵉⵣ. ");
INSERT INTO rift_vpl VALUES ("GN45_10","002_45_10","GEN","45","10","10","ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵣⵣⴰⵜⵉ, ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⴷ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("GN45_11","002_45_11","GEN","45","11","11","ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⴰⵔⵣⴻⵇ ⴷⵉⵏ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵄⴰⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴹⵄⵉⴼⴻⴷ, ⵛⴻⴽ ⵍⵍⴰ, ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵍⵍⴰ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⵍⵍⴰ! ");
INSERT INTO rift_vpl VALUES ("GN45_12","002_45_12","GEN","45","12","12","ⵅⵣⴰⵔ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵥⵔⵉⵏⵜ, ⵓⵍⴰ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵎⴰ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN45_13","002_45_13","GEN","45","13","13","ⵄⴻⵍⵎⴻⵎ ⵉ ⴱⴰⴱⴰ ⵅ ⵎⴰⵔⵔⴰ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵥⵔⵉⵎ. ⵇⴻⴵⵇⴻⵎ ⴷⴻⵖⵢⴰ, ⵜⵉⵡⵢⴻⵎ-ⴷⴷ ⴱⴰⴱⴰ ⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN45_14","002_45_14","GEN","45","14","14","ⵓⵛⴰ ⵉⵏⴳⴻⵣ ⵅ ⵢⵉⵔⵉ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵎⴰⵙ, ⵉⵔⵓ, ⵓⵛⴰ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉⵔⵓ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN45_15","002_45_15","GEN","45","15","15","ⵉⵙⵙⵓⴷⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ, ⵉⵔⵓ ⵅⴰⵙⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN45_16","002_45_16","GEN","45","16","16","ⵍⴰⵎⵉ ⵜⴻⵙⵍⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ ⵍⴻⵅⴱⴰⵔ-ⴰ, ⵏⵏⴰⵏ: “ⴰⵢⵜⵎⴰⵙ ⵏ ⵢⵓⵙⵓⴼ ⵓⵙⵉⵏ-ⴷⴷ!”. ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN45_17","002_45_17","GEN","45","17","17","ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⵓⵙⵓⴼ: “ⵉⵏⵉ ⵉ ⴰⵢⵜⵎⴰⵛ: ‘ⴳⴳⴻⵎ ⴰⵢⴰ: ⵙⴰⵔⴱⵓⵎ ⵣⵡⴰⵢⴻⵍ ⵏⵡⴻⵎ ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵎ, ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN45_18","002_45_18","GEN","45","18","18","ⴽⵙⵉⵎ-ⴷⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⴷ ⵔⴰⴵ ⵏⵡⴻⵎ, ⵜⵓⵙⵉⵎ-ⴷⴷ ⵖⴰⵔⵉ. ⴰⵇⴰ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵍⴻⵎⵍⵉⵃ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵣⵉ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN45_19","002_45_19","GEN","45","19","19","ⴰⵇⴰ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⵉⵡⴻⵚⵚⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⴽ. ⴳⴳⴻⵎ ⴰⵢⴰ: ⴽⵙⵉⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵓ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ, ⴰⵡⵢⴻⵎ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵓⵛⴰ ⴰⵙⴻⵎ-ⴷⴷ ⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_20","002_45_20","GEN","45","20","20","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵙⵙⵃⵉⵙⵙⴼⴻⵏⵜ ⵉ ⵍⵇⴻⵛⵛ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵍⴻⵎⵍⵉⵃ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⵢⵉⵍⵉ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("GN45_21","002_45_21","GEN","45","21","21","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵎⴰⵛⵛⴰ ⵉ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN45_22","002_45_22","GEN","45","22","22","ⵉⵡⵛⴰ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴻⵃⵃⴷⴻⵙ ⴰⵔⵔⵓⴹ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵛⴰ ⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉⵡⵛⴰ ⴰⵙ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵡⴰⵔⵔⵓⴹ ⴷ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN45_23","002_45_23","GEN","45","23","23","ⵓ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⴽⴽ ⵉ ⴱⴰⴱⴰⵙ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵖⵢⴰⵍ ⵛⵛⵓⵔⴻⵏ ⵙ ⵎⵉⵏ ⵉⴼⴰⵔⵣⴻⵏ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⵄⴻⵛⵔⴰ ⵏ ⵜⴻⵖⵢⴰⵍ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵉⵎⴻⵏⴷⵉ ⴷ ⵡⴻⵖⵔⵓⵎ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⴱⴰⴱⴰⵙ ⵓⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("GN45_24","002_45_24","GEN","45","24","24","ⵉⵇⴻⴱⴱⴻⴹ ⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⵔⵓⵃⴻⵏ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵏⴻⵜⵜⴰ: “ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⵉⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN45_25","002_45_25","GEN","45","25","25","ⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵖⴰⵔ ⵢⴰⵄⵇⵓⴱ, ⴱⴰⴱⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN45_26","002_45_26","GEN","45","26","26","ⵡⵛⵉⵏ ⴰⵙ ⵍⴻⵅⴱⴰⵔ, ⵏⵏⴰⵏ: “ⵢⵓⵙⵓⴼ ⴰⵇⴰ ⵉⴷⴷⴰⵔ ⵄⴰⴷ, ⵡⴰⵀ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ!” ⵅⴻⵏⵏⵉ ⵉⵙⵅⴻⴼ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵏ ⵢⵓⵎⵉⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GN45_27","002_45_27","GEN","45","27","27","ⵓⵎⵉ ⴷ ⴰⵙ ⵄⴰⵡⴷⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵢⵓⵙⵓⴼ ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵓ ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵢⵓⵙⵓⴼ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ, ⵉⵄⵇⴻⴱ-ⴷⴷ ⴱⵓⵃⴱⴻⵍ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("GN45_28","002_45_28","GEN","45","28","28","ⵓⵛⴰ ⵉⵏⵏⴰ ⵉⵙⵔⴰⵉⵍ: “ⴽⴼⴰ! ⵢⵓⵙⵓⴼ ⵎⵎⵉ ⴰⵇⴰ ⵉⴷⴷⴰⵔ! ⴰⴷ ⵔⴰⵃⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜ ⵥⴰⵔⵖ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵎⵎⵜⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("GN46_1","002_46_1","GEN","46","1","1","ⵉⴼⵙⵉ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵙⵙⴻⵏⵏⵉ, ⵢⵓⵢⵓⵔ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ⵉⵇⴻⴷⴷⴻⵎ ⴷⵉⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵙ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GN46_2","002_46_2","GEN","46","2","2","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵉⵡⴻⵃⵃⴰⵏ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⴰ: “ⵢⴰⵄⵇⵓⴱ, ⵢⴰⵄⵇⵓⴱ!” ⵓⵛⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("GN46_3","002_46_3","GEN","46","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN46_4","002_46_4","GEN","46","4","4","ⴰⴷ ⴽⵉⴷⴻⴽ ⵀⵡⵉⵖ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵄⴰⵡⴻⴷ ⵓ ⵢⵓⵙⵓⴼ ⴰⴷ ⵅⴰⴽ ⵉⵙⵙⴰⵔⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GN46_5","002_46_5","GEN","46","5","5","ⵉⴽⴽⴰⵔ ⵢⴰⵄⵇⵓⴱ, ⵉⴼⴼⴻⵖ ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ⴽⵙⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴼⵉⵔⵄⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵢⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("GN46_6","002_46_6","GEN","46","6","6","ⴽⵙⵉⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴷ ⵡⴰⴳⵍⴰ ⵉ ⵢⴰⵔⴻⴱⵃⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵢⴰⵄⵇⵓⴱ ⴷ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("GN46_7","002_46_7","GEN","46","7","7","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵊⵎⵉⵄ ⴰⴽⵉⴷⴻⵙ, ⵓⵍⴰ ⴷ ⵢⴻⵙⵙⵉⵙ ⴷ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("GN46_8","002_46_8","GEN","46","8","8","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ: ⵢⴰⵄⵇⵓⴱ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⴰⵄⵇⵓⴱ: ⵔⵓⴱⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_9","002_46_9","GEN","46","9","9","ⵜⴰⵔⵡⴰ ⵏ ⵔⵓⴱⵉⵏ: ⵃⴰⵏⵓⴽ ⴷ ⴼⴰⵍⵍⵓ ⴷ ⵃⴰⵚⵔⵓⵏ ⴷ ⴽⴰⵔⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("GN46_10","002_46_10","GEN","46","10","10","ⵜⴰⵔⵡⴰ ⵏ ⵛⵉⵎⵄⵓⵏ: ⵢⴰⵎⵓⵢⵉⵍ ⴷ ⵢⴰⵎⵉⵏ ⴷ ⵓⵀⴰⴷ ⴷ ⵢⴰⴽⵉⵏ ⴷ ⵚⵓⵃⴰⵔ ⴷ ⵛⴰⵡⵓⵍ, ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴽⴻⵏⵄⴰⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("GN46_11","002_46_11","GEN","46","11","11","ⵜⴰⵔⵡⴰ ⵏ ⵍⴰⵡⵉ: ⵊⴰⵔⵛⵓⵏ ⴷ ⵇⴰⵀⴰⵜ ⴷ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN46_12","002_46_12","GEN","46","12","12","ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵀⵓⴷⴰ: ⵄⵉⵔ ⴷ ⵓⵏⴰⵏ ⴷ ⵛⴰⵢⵍⴰ ⴷ ⴼⴰⵔⵉⵚ ⴷ ⵣⴰⵔⴰⵃ. ⵎⴰⵛⴰ ⵄⵉⵔ ⴷ ⵓⵏⴰⵏ ⵎⵎⵓⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵜⴰⵔⵡⴰ ⵏ ⴼⴰⵔⵉⵚ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵃⴰⵚⵔⵓⵏ ⴷ ⵃⴰⵎⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("GN46_13","002_46_13","GEN","46","13","13","ⵜⴰⵔⵡⴰ ⵏ ⵉⵙⵙⴰⴽⴰⵔ: ⵜⵓⵍⴰⵄ ⴷ ⴼⴰⵡⵡⴰ ⴷ ⵢⵓⴱ ⴷ ⵛⵉⵎⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_14","002_46_14","GEN","46","14","14","ⵜⴰⵔⵡⴰ ⵏ ⵣⴰⴱⵓⵍⵓⵏ: ⵙⴰⵔⴰⴷ ⴷ ⵉⵍⵓⵏ ⴷ ⵢⴰⵃⵍⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN46_15","002_46_15","GEN","46","15","15","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⵉⵢⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵉ ⵢⴰⵄⵇⵓⴱ ⴷⵉ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵢⴻⴵⵉⵙ ⴷⵉⵏⴰ. ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_16","002_46_16","GEN","46","16","16","ⵜⴰⵔⵡⴰ ⵏ ⵊⴰⴷ: ⵚⵉⴼⵢⵓⵏ ⴷ ⵃⴰⵊⵊⵉ ⴷ ⵛⵓⵏⵉ ⴷ ⴰⵚⴱⵓⵏ ⴷ ⵄⵉⵔⵉ ⴷ ⴰⵔⵓⴷⵉ ⴷ ⴰⵔⵡⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("GN46_17","002_46_17","GEN","46","17","17","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵛⵉⵔ: ⵢⵉⵎⵏⴰ ⴷ ⵢⵉⵙⵡⵉ ⴷ ⴱⴰⵔⵉⵄⴰ ⴷ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ ⵛⴰⵔⴰⵃ. ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⵔⵉⵄⴰ: ⵃⴰⴱⵉⵔ ⴷ ⵎⴰⵍⴽⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN46_18","002_46_18","GEN","46","18","18","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵣⵉⵍⴱⴰ ⵜⴻⵏⵏⵉ ⵉⵡⵛⴰ ⵍⴰⴱⴰⵏ ⵉ ⵢⴻⴵⵉⵙ ⵍⵉⵢⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵏⴰ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⴰ ⵙⴻⵟⵟⴰⵛ ⴷ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GN46_19","002_46_19","GEN","46","19","19","ⵜⴰⵔⵡⴰ ⵏ ⵔⴰⵃⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ: ⵢⵓⵙⵓⴼ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_20","002_46_20","GEN","46","20","20","ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ-ⴷⴷ ⵉ ⵢⵓⵙⵓⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵔⵓⵡ ⴰⵙⵏⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⴼⵓⵟⵉ-ⴼⴰⵔⴰⵄ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_21","002_46_21","GEN","46","21","21","ⵜⴰⵔⵡⴰ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ: ⴱⵉⵍⴰⵄ ⴷ ⴱⴰⴽⵉⵔ ⴷ ⴰⵛⴱⵉⵍ ⴷ ⵊⵉⵔⴰ ⴷ ⵏⴰⵄⵎⴰⵏ ⴷ ⵉⵃⵉ ⴷ ⵔⵓⵛ ⴷ ⵎⵓⴼⴼⵉⵎ ⴷ ⵃⵓⴼⴼⵉⵎ ⴷ ⴰⵔⴷ. ");
INSERT INTO rift_vpl VALUES ("GN46_22","002_46_22","GEN","46","22","22","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⴰⵃⵉⵍ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵡⴰⵔⵡⴻⵏ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵎⴰⵔⵔⴰ ⴰⵔⴱⴻⵄⵟⴰⵛ ⴷ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GN46_23","002_46_23","GEN","46","23","23","ⵜⴰⵔⵡⴰ ⵏ ⴷⴰⵏ: ⵎⵖⵉⵔ ⵃⵓⵛⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN46_24","002_46_24","GEN","46","24","24","ⵜⴰⵔⵡⴰ ⵏ ⵏⴰⴼⵜⴰⵍⵉ: ⵢⴰⵃⴰⵚⵡⵉⵍ ⴷ ⵊⵓⵏⵉ ⴷ ⵢⵉⵚⵔⵓ ⴷ ⵛⵉⵍⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN46_25","002_46_25","GEN","46","25","25","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⵉⵍⵀⴰ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵍⴰⴱⴰⵏ ⵉ ⵔⴰⵃⵉⵍ ⵢⴻⴵⵉⵙ. ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵉⵏⴰ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙⴻⴱⵄⴰ ⴷ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GN46_26","002_46_26","GEN","46","26","26","ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ, ⴱⵍⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵍⴻⵄⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("GN46_27","002_46_27","GEN","46","27","27","ⵜⴰⵔⵡⴰ ⵏ ⵢⵓⵙⵓⴼ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵄⵎⵓⵔ. ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⵓⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_28","002_46_28","GEN","46","28","28","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵢⴰⵀⵓⴷⴰ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵢⵓⵙⵓⴼ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴰⴱⵔⵉⴷ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵊⵓⵛⴰⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN46_29","002_46_29","GEN","46","29","29","ⵉⵏⴷⴻⵀ ⵢⵓⵙⵓⴼ ⵄⴰⵡⴻⴷ ⴰⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵊⵓⵛⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵇⴰ ⵉⵙⵔⴰⵉⵍ, ⴱⴰⴱⴰⵙ. ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵏⴳⴻⵣ ⴰⵙ ⵅ ⵢⵉⵔⵉ, ⵉⵇⵇⵉⵎ ⵉⵜⵜⵔⵓ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN46_30","002_46_30","GEN","46","30","30","ⵉⵏⵏⴰ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵓⵙⵓⴼ: “ⵍⴻⵅⵅⵓ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⵎⵎⵜⴻⵖ, ⵍⴻⵅⵅⵓ ⵓⵎⵉ ⵥⵔⵉⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ, ⵣⴻⵄⵎⴰ ⴰⵇⴰ ⵄⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("GN46_31","002_46_31","GEN","46","31","31","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⵓ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ: “ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⴰⴷ ⵅⴻⴱⴱⴰⵔⴻⵖ ⴼⵉⵔⵄⵓⵏ, ⴰⴷ ⵉⵏⵉⵖ: ‘ⴰⵢⵜⵎⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GN46_32","002_46_32","GEN","46","32","32","ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵡⵓⴵⵉ, ⵜⵓⵖⴰ ⵛⴻⵖⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴽ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ. ⴰⵇⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("GN46_33","002_46_33","GEN","46","33","33","ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵍⴰⵖⴰ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵏⵉ: ‘ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ?’, ");
INSERT INTO rift_vpl VALUES ("GN46_34","002_46_34","GEN","46","34","34","ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵛⴻⵖⵍⴻⵏ ⴰⴽ-ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵙⴻⵏ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ, ⵏⴻⵛⵛⵉⵏ ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ!’, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ, ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⴰⵎⴻⴽⵙⴰⵡ ⵏ ⵡⵓⴵⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN47_1","002_47_1","GEN","47","1","1","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵢⵓⵙⵓⴼ, ⵉⵅⴻⴱⴱⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴱⴰⴱⴰ ⴷ ⴰⵢⵜⵎⴰ ⴷ ⵡⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ, ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN47_2","002_47_2","GEN","47","2","2","ⵓⵛⴰ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ ⵢⵉⵡⵉ ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵇⴻⴷⴷⴻⵎ ⴰⵙ ⵜⴻⵏ ⵉ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_3","002_47_3","GEN","47","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅ ⴼⵉⵔⵄⵓⵏ: “ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵡⵓⴵⵉ, ⴰⵎ ⵏⴻⵛⵛⵉⵏ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN47_4","002_47_4","GEN","47","4","4","ⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵉ ⴼⵉⵔⵄⵓⵏ: “ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⴰⵎ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉ ⴷⴷ-ⵏⵓⵙⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵢⴻⴵⵉ ⵡⴻⴼⵙⵓ ⵉ ⵡⵓⴵⵉ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵍⴰⵥ ⵉⵇⵙⴻⵃ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⴻⵜⵜⵣⴰⵡⴻⴳ ⵉ ⵛⴻⴽ, ⴻⵊⵊ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("GN47_5","002_47_5","GEN","47","5","5","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴼⵉⵔⵄⵓⵏ ⴰⴽ-ⴷ ⵢⵓⵙⵓⴼ, ⵉⵏⵏⴰ: “ⴱⴰⴱⴰⵛ ⴷ ⴰⵢⵜⵎⴰⵛ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("GN47_6","002_47_6","GEN","47","6","6","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵇⴰ-ⵜⵜ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ. ⴻⵊⵊ ⴱⴰⴱⴰⵛ ⴷ ⴰⵢⵜⵎⴰⵛ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⵃⴻⴽⴽⴰⵔⴻⴷ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵡⴻⵏⴳⵉⵜⴻⵏ, ⴳⴳⴻⵎ ⵜⴻⵏ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵅ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN47_7","002_47_7","GEN","47","7","7","ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⵢⵓⵙⵓⴼ ⴱⴰⴱⴰⵙ, ⵉⵇⴻⴷⴷⴻⵎ ⵉ-ⵜ ⵉ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵉⴱⴰⵔⴻⴽ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_8","002_47_8","GEN","47","8","8","ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵢⴰⵄⵇⵓⴱ: “ⵎⴻⵛⵀⴰⵍ ⵖⴰⵔⴻⴽ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ?” ");
INSERT INTO rift_vpl VALUES ("GN47_9","002_47_9","GEN","47","9","9","ⵢⴰⵄⵇⵓⴱ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⴼⵉⵔⵄⵓⵏ: “ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⴷⴰⵔⴻⵖ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ. ⵓⵙⵙⴰⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵢⵓⵇⵍⵉⵍⴻⵏ ⵓ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵖⴰⵔ. ⵡⴰⵔ ⵉⵡⵉⴹⴻⵏ ⵛⴰ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵖⵓⵔⴱⴰ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN47_10","002_47_10","GEN","47","10","10","ⵅⴻⵏⵏⵉ ⵢⴰⵄⵇⵓⴱ ⵉⴱⴰⵔⴽ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵙⵙⴻⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_11","002_47_11","GEN","47","11","11","ⵉⵙⵙⵛⴻⵏ ⵢⵓⵙⵓⴼ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵍⴻⵎⵍⵉⵃ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵔⴰⵄⴰⵎⵙⵉⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵡⴻⵚⵚⴰ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_12","002_47_12","GEN","47","12","12","ⵉⵄⴻⵡⵡⴻⵍ ⵢⵓⵙⵓⴼ ⴱⴰⴱⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ⵉⵄⴻⵡⵡⴻⵍ ⵓⵍⴰ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_13","002_47_13","GEN","47","13","13","ⴰⵖⵔⵓⵎ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⵎⵉⵏⵣⵉ ⵍⴰⵥ ⵜⵓⵖⴰ ⵉⵇⵙⴻⵃ ⴰⵟⵟⴰⵙ, ⴰⵍⴰⵎⵉ ⵜⵉⵡⴻⴹ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴼⴻⵏⵏⴰⵏⵜ ⵙ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("GN47_14","002_47_14","GEN","47","14","14","ⵅⴻⵏⵏⵉ ⵉⵢⵔⵓ ⵢⵓⵙⵓⴼ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷⴻⴳ ⵓⴱⴻⴷⴷⴻⵍ ⵏ ⵉⵎⴻⵏⴷⵉ ⵉ ⵉⵙⵖⵉⵏ. ⵉⴳⴳⴰ ⵢⵓⵙⵓⴼ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_15","002_47_15","GEN","47","15","15","ⵓⵎⵉ ⵜⴻⵇⴹⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵢⵓⵙⵓⴼ ⵏⵏⴰⵏ: “ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⵖⵔⵓⵎ, ⵎⴰⵖⴰⵔ ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵏⴻⵎⵎⴻⵜ ⵣⵣⴰⵜⴻⴽ? ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⵛⴰ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN47_16","002_47_16","GEN","47","16","16","ⵢⵓⵙⵓⴼ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴱⵓ ⵏⵏⵓⵇⴰⵔⵜ ⵄⴰⴷ, ⵡⵛⴻⵎ ⵅⴻⵏⵏⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵡⴻⵎ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵎⴰⵛⵛⴰ ⴷⴻⴳ ⵓⴱⴻⴷⴷⴻⵍ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN47_17","002_47_17","GEN","47","17","17","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ ⴰⵖⵔⵓⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵢⵙⴰⵏ ⴷ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵛ ⵉ-ⵜⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GN47_18","002_47_18","GEN","47","18","18","ⵓⵎⵉ ⵉⵄⴷⵓ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⵏᵉⵜⵜⴻⴼⴼⴰⵔ ⵛⴰ ⵅ ⵙⵉⴷⵉ ⵉⵏⵓ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵖ ⵜⴻⵇⴹⴰ ⵓⵛⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵖⵉⵔ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN47_19","002_47_19","GEN","47","19","19","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵏⴻⵎⵎⴻⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵓⵍⴰ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵖ? ⵙⴻⵖ ⴰⵏⴻⵖ, ⵜⴻⵙⵖⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⵉ ⵡⴻⵖⵔⵓⵎ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ. ⴻⵡⵛ ⴰⵏⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜᵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴷ ⴰⵎⴻⵙⵙⵓⵛⵉ!” ");
INSERT INTO rift_vpl VALUES ("GN47_20","002_47_20","GEN","47","20","20","ⵅⴻⵏⵏⵉ ⵉⵙⵖⴰ ⵢⵓⵙⵓⴼ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵉ ⴼⵉⵔⵄⵓⵏ, ⵎⵉⵏⵣⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵣⵣⴻⵏⵣⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵢⵢⴰⵔ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⵇⵙⴻⵃ ⵅⴰⵙⴻⵏ. ⵓ ⴰⵎⵎⵓ ⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⴳⵍⴰ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_21","002_47_21","GEN","47","21","21","ⵓⵛⴰ ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵡⴻⵢⵎⵉⵔ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏⵏⴻⵖⵏⵉ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GN47_22","002_47_22","GEN","47","22","22","ⵎⵖⵉⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵔ ⵜⵜ ⵉⵙⵖⵉ ⵛⴰ. ⴰⵇⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵉⵛⵜ ⵏ ⵍⵎⵓⵏⴻⵜ ⵣⵉ ⴼⵉⵔⵄⵓⵏ, ⵏⵉⵜⵏⵉ ⵜⵜᵉⵜⵜⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⴼⵉⵔⵄⵓⵏ. ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵣⵣⴻⵏⵣⴻⵏ ⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_23","002_47_23","GEN","47","23","23","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⵍⴳⴻⵏⵙ: “ⵅⵣⴰⵔ, ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵙⵖⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵉ ⴼⵉⵔⵄⵓⵏ. ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴷⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ. ⵣⴰⵔⵄⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("GN47_24","002_47_24","GEN","47","24","24","ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⵉ ⴼⵉⵔⵄⵓⵏ ⵓ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵢⴻⵢⵢⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⵛⵛⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴽ-ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ ⵓ ⵄⴰⵡⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵛⵛⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("GN47_25","002_47_25","GEN","47","25","25","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵛⴻⴽ ⵜⴻⵃⴹⵉⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⴼ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴼⵉⵔⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("GN47_26","002_47_26","GEN","47","26","26","ⵉⴳⴳⴰ ⵢⵓⵙⵓⴼ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴰⵍ ⴰⵙⵙ-ⴰ, ⴱⴻⵍⵍⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⴼⵉⵔⵄⵓⵏ. ⵎⵖⵉⵔ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵇⵇⵉⵎⴻⵏ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ, ⵡⴰⵔ ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵏ ⵛⴰ ⴷ ⴰⴳⵍⴰ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN47_27","002_47_27","GEN","47","27","27","ⴰⵎⵎⵓ ⵉ ⵉⵣⴷⴻⵖ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ, ⵎⴻⵍⵍⴽⴻⵏ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵡⵛⵉⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴽⵜⴰⵔⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵛⵛⴽⴻⵍ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN47_28","002_47_28","GEN","47","28","28","ⵉⴷⴷⴰⵔ ⵢⴰⵄⵇⵓⴱ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵜⵓⵖⴰ ⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN47_29","002_47_29","GEN","47","29","29","ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵢⵓⵙⵓⴼ ⵎⵎⵉⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵙⴰⴷⵓ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵉⵏⵓ ⵓⵛⴰ ⴻⴳⴳ ⴰⴽⵉⴷⵉ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵏⴻⵟⵟⴻⵍ ⵛⴰ ⴷⵉ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("GN47_30","002_47_30","GEN","47","30","30","ⵎⴰⵛⴰ ⵅⵎⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵖ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⵡⵉ ⴰⵢⵉ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⴹⴻⵍ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵙⴻⵏ. ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵜⴻⵏⵏⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("GN47_31","002_47_31","GEN","47","31","31","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵊⴰⴵ ⴰⵢⵉ!”, ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⴰⵙ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⴹⴰⵔ ⵉⵙⵔⴰⵉⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵇⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("GN48_1","002_48_1","GEN","48","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵢⵓⵙⵓⴼ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴱⴰⴱⴰⵛ ⵉⵃⵍⴻⵛ!” ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GN48_2","002_48_2","GEN","48","2","2","ⵅⴻⴱⴱⴰⵔⴻⵏ ⵢⴰⵄⵇⵓⴱ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵎⵎⵉⵛ ⵢⵓⵙⵓⴼ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ!” ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵍ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵉⵇⵇⵉⵎ ⵅ ⵇⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("GN48_3","002_48_3","GEN","48","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵢⵓⵙⵓⴼ: “ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵇⴰ ⵉⴱⴰⵏ ⴰⵢⵉ-ⴷⴷ ⴷⵉ ⵍⵓⵣ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵓ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴰⵔⴽ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("GN48_4","002_48_4","GEN","48","4","4","ⵓ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵅⵣⴰⵔ, ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴽⴻⵜⵜⴰⵔⴻⵖ, ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴷ ⴰⴳⵍⴰ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("GN48_5","002_48_5","GEN","48","5","5","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ, ⵉⵏⵏⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵇⴱⴻⵍ ⵉ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵓⵙⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵉⵏⵓ, ⴰⵎ ⵔⵓⴱⵉⵏ ⴷ ⵛⵉⵎⵄⵓⵏ ⵉ ⵉⴵⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GN48_6","002_48_6","GEN","48","6","6","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⴰⴷ ⵉⵍⵉⵏ ⵏⵏⴻⵛ. ⴰⴷ ⵜⵜⵡⴰⵙⴻⵎⵎⴰⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⴷⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN48_7","002_48_7","GEN","48","7","7","ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵣⵉ ⴼⴰⴷⴰⵏ-ⴰⵔⴰⵎ, ⵜⴻⵎⵎⵓⵜ ⵔⴰⵃⵉⵍ ⵣⵣⴰⵜⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜⵉⴳⴳⵯⵉⵊ ⵅ ⵉⴼⵔⴰⵜⴰ. ⵏⴻⴹⵍⴻⵖ ⵜⵜ ⴷⵉⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵉⴼⵔⴰⵜⴰ!”, ⴰⵇⴰ-ⵜⵜ ⴷ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("GN48_8","002_48_8","GEN","48","8","8","ⵉⵥⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵙⵓⴼ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("GN48_9","002_48_9","GEN","48","9","9","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⵓⵙⵓⴼ ⵅ ⴱⴰⴱⴰⵙ: “ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵏⵉⵜⴰ.” ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵇⴰⵔⵔⴱⴻⵎ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴱⴰⵔⴽⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("GN48_10","002_48_10","GEN","48","10","10","ⵜⵓⵖⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵥⵖⴻⵏⵜ ⵙ ⵜⴻⵡⵙⴰⵔ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵜⵜⵡⴰⵍⴰ. ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⴰⵙ ⵜⴻⵏ-ⴷⴷ, ⵅⴻⵏⵏⵉ ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜⴻⵏ, ⵉⴷⴰⵔⵔⴻⵄ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN48_11","002_48_11","GEN","48","11","11","ⵉⵏⵏⴰ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵓⵙⵓⴼ: “ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵖⵉⵍ ⴰⴷ ⵥⴰⵔⴻⵖ ⵄⴰⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⴰⴷ ⵥⴰⵔⴻⵖ ⵄⴰⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN48_12","002_48_12","GEN","48","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵢⵓⵙⵓⴼ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵙ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("GN48_13","002_48_13","GEN","48","13","13","ⵓⵛⴰ ⵉⴽⵙⵉ ⵉ-ⵜⴻⵏ ⵢⵓⵙⵓⴼ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ, ⵉⴼⵔⴰⵢⵉⵎ ⵙ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵓⵣⴻⵍⵎⴰⴹ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵎⴰⵏⴰⵙⵙⴰ ⵙ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵓⴼⵓⵙⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⴰⵙ ⵜⴻⵏ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("GN48_14","002_48_14","GEN","48","14","14","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⵙⵔⴰⵉⵍ ⵢⴻⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵥⵓⵥ, ⴷ ⴰⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ⵉⵙⵙⴰⵔⵙ ⴰⵎⵎⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⵖⵏⵉ ⵏⴻⵄⵎⴰⴷⴰ, ⵡⴰⵅⵅⴰ ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵏⵣⵓ. ");
INSERT INTO rift_vpl VALUES ("GN48_15","002_48_15","GEN","48","15","15","ⵉⵙⵔⴰⵉⵍ ⵉⴱⴰⵔⴽ ⵢⵓⵙⵓⴼ, ⵉⵏⵏⴰ: “ⴷ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ, ⵓⵢⵓⵔⴻⵏ ⵣⵣⴰⵜⴻⵙ, ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵉⵏⵓ ⵣⴻⴳ ⵡⴰⵎⵉ ⴵⵉⵖ ⴰⵍ ⴰⵙⵙ-ⴰ,    ");
INSERT INTO rift_vpl VALUES ("GN48_16","002_48_16","GEN","48","16","16","ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴼⴷⵉⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⴽ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ-ⴰ ⵓ ⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷⴰⵢⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵙⴻⵎ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ. ⵉⵍⵉ ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⴰⵍ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵎ ⵉⵙⴻⵍⵎⴰⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ!”    ");
INSERT INTO rift_vpl VALUES ("GN48_17","002_48_17","GEN","48","17","17","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⵓⵙⵓⴼ, ⴱⴻⵍⵍⵉ ⴱⴰⴱⴰⵙ ⵉⴳⴳⴰ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵡⴰⵔ ⵜⴻⵃⵃⵍⵉ ⵖⴰⵔⴻⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴰⴼⵓⵙ ⵏ ⴱⴰⴱⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴱⴻⴷⴷⴻⵍ ⵣⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN48_18","002_48_18","GEN","48","18","18","ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⴱⴰⴱⴰⵙ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⴰⵎⵎⵓ, ⴰ ⴱⴰⴱⴰ, ⵎⵉⵏⵣⵉ ⴷ ⵡⴰ ⴷ ⴰⵎⴻⵏⵣⵓ, ⴻⴳⴳ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN48_19","002_48_19","GEN","48","19","19","ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵉⵅⵙ ⵛⴰ, ⵉⵏⵏⴰ: “ⵙⵙⵏⴻⵖ, ⴰ ⵎⵎⵉ, ⵙⵙⵏⴻⵖ. ⵄⴰⵡⴻⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ, ⴰⴷ ⵉⵎⵖⴰⵔ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⵓⵎⴰⵙ ⴰⵎⴰⵥⵓⵥ ⴰⴷ ⵢⵉⵍⵉ ⴽⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ, ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵛⵓⵔⵔⴻⵜ ⵏ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("GN48_20","002_48_20","GEN","48","20","20","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵏ ⵉⴱⴰⵔⴻⴽ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵏⵏⴰ: “ⴷⴰⵢⴻⴽ, ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⴽ, ⴰ ⵢⵓⵙⵓⴼ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ!’” ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN48_21","002_48_21","GEN","48","21","21","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵏⵏⴰ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵓⵙⵓⴼ: “ⵅⵣⴰⵔ, ⴰⴷ ⵎⵎⵜⴻⵖ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN48_22","002_48_22","GEN","48","22","22","ⴰⵇⴰ ⵡⵛⵉⵖ ⴰⵛ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵅ ⵎⵉⵏ ⵡⵛⵉⵖ ⵉ ⵢⴰⵢⵜⵎⴰⵛ, ⵜⴻⵏⵏⵉ ⴽⵙⵉⵖ ⵏⴻⵛⵛ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⵇⴻⵡⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("GN49_1","002_49_1","GEN","49","1","1","ⵉⵍⴰⵖⴰ ⵢⴰⵄⵇⵓⴱ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵙⵎⵓⵏⴻⵎ-ⴷⴷ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN49_2","002_49_2","GEN","49","2","2","ⵙⵎⵓⵏⴻⵎ-ⴷⴷ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⵙⵍⴻⵎ, ⴰ ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵙⵍⴻⵎ ⵉ ⵉⵙⵔⴰⵉⵍ, ⴱⴰⴱⴰⵜⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GN49_3","002_49_3","GEN","49","3","3","ⵔⵓⴱⵉⵏ, ⵛⴻⴽ ⴷ ⴰⵎⴻⵏⵣⵓ ⵉⵏⵓ, ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵜⴻⵔⵢⴰⵙⵜ ⵉⵏⵓ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴹⴼⴰⵔ ⵉⵏⵓ ⴷⵉ ⵍⵓⵄⵍⴰ, ⴷ ⴰⵎⵙⴻⴹⴼⴰⵔ ⵉⵏⵓ ⴷⵉ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("GN49_4","002_49_4","GEN","49","4","4","ⵛⴻⴽ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵎⴰⵏ ⵉⵜⵜⵏⴻⵇⵍⴰⴱⴻⵏ, ⵡⴰⵔ ⴷⴷ ⴰⵢⵉ ⵜⴹⴻⴼⴼⴰⵔⴻⴷ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵖⴰⵔ ⵍⴻⵛⵜⵓ ⵏ ⵍⴻⵎⵍⴰⵛ ⵏ ⴱⴰⴱⴰⵛ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵙⵙⴼⴻⴹⵃⴻⴷ ⵜ, ⴰⵇⴰ ⵖⴰⵔ ⵍⴻⵛⵜⵓ ⵉⵏⵓ ⵉⴳⴻⵄⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GN49_5","002_49_5","GEN","49","5","5","ⵛⵉⵎⵄⵓⵏ ⴷ ⵍⴰⵡⵉ ⴷ ⴰⵡⵎⴰⵜⴻⵏ! ⵍⴻⵎⵡⴰⵙ ⵏⵙⴻⵏ ⴷ ⵍⴻⵙⵏⴰⵃ ⵏ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("GN49_6","002_49_6","GEN","49","6","6","ⴷⵉ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴻⴼ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵛⴰⵔⵔⴻⵛ ⵡⵓⵍ ⵉⵏⵓ. ⴰⵇⴰ ⴷⴻⴳ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵙⴻⵏ ⵏⵖⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵛⴰ ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⴰⴷ ⵇⴻⵙⵙⴻⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN49_7","002_49_7","GEN","49","7","7","ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴰⵅⴻⵢⵢⴻⵇ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵉⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ, ⵓⵍⴰ ⴷ ⴰⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵇⵙⴻⵃ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴱⴹⵉⵖ ⵅ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⵢⵓⵙⴻⵖ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN49_8","002_49_8","GEN","49","8","8","ⵢⴰⵀⵓⴷⴰ, ⴰⵢⵜⵎⴰⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ. ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵢⵉⵔⵉ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⴱⴰⵛ ⴰⴷ ⴰⵛ ⴱⴻⵏⴷⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN49_9","002_49_9","GEN","49","9","9","ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵡⴰⵢⵔⴰⴷ. ⵣⵉ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵜⵓⵍⵢⴻⴷ, ⴰ ⵎⵎⵉ. ⵉⵇⵡⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵢⵔⴰⴷ ⵓ ⴰⵎⴻⵛⵎⴰⵡ ⵜⴰⵢⵔⴰⴷⵜ. ⵡⵉ ⵉⵣⴻⵄⵄⴻⵎⴻⵏ ⴰⴷ ⵜ-ⴷⴷ-ⵉⵙⵙⴼⴰⵇ? ");
INSERT INTO rift_vpl VALUES ("GN49_10","002_49_10","GEN","49","10","10","ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⵍⵃⴰⴽⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵅ ⵢⴰⵀⵓⴷⴰ ⵓⵍⴰ ⴷ ⴰⵣⴻⴵⴰⴹ ⵏ ⵚⵚⵓⵍⵟⴰ ⵣⵉ ⵊⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵟⴰⵄⴻⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("GN49_11","002_49_11","GEN","49","11","11","ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵜⵣⴰⵢⴰⵔⵜ ⴰⵙⵏⵓⵙ ⵏⵏⴻⵙ ⴷ ⵎⵎⵉⵙ ⵏⵏⴻⵙ ⵏ ⵜⴻⵖⵢⵓⵍⵜ ⵖⴰⵔ ⵜⵣⴰⵢⴰⵔⵜ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷⵉ ⴱⵉⵏⵓ ⵓ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN49_12","002_49_12","GEN","49","12","12","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵉⴱⴰⵔⵛⴰⵏⵉⵏ ⵙ ⴱⵉⵏⵓ ⵓ ⵜⵉⵖⵎⴰⵙ ⵏⵏⴻⵙ ⴷ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ ⵙ ⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("GN49_13","002_49_13","GEN","49","13","13","ⵣⴰⴱⵓⵍⵓⵏ ⴰⴷ ⵉⵣⴷⴻⵖ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵎⵓⵢⵢⵉ ⵉ ⵉⵖⴰⵔⵔⵓⴱⴰ. ⴰⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵅ ⵚⵉⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN49_14","002_49_14","GEN","49","14","14","ⵉⵙⵙⴰⴽⴰⵔ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ ⵉⵇⵙⴻⵃ, ⵉⵣⵣⴻⵍ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵎⴻⴷⵡⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GN49_15","002_49_15","GEN","49","15","15","ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵔⵔⴰⵃⴻⵜ ⴷ ⵍⴻⵎⵍⵉⵃ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ ⵜⴰⵔⴻⵛⵛⴻⵇ, ⵉⵇⵡⴻⵙ, ⵉⴳⴳⴰ ⵜⵉⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴱⵓ ⴰⵔⵔⵎⴻⵃ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵙⴰⴷⵓ ⴰⵣⴰⵢⵍⵓ ⵏ ⵉⵙⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GN49_16","002_49_16","GEN","49","16","16","ⴷⴰⵏ ⴰⴷ ⵉⵃⴽⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵛⵜ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN49_17","002_49_17","GEN","49","17","17","ⴰⴷ ⵢⵉⵍⵉ ⴷⴰⵏ ⴷ ⴰⴼⵉⵖⴰⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵜⴰⵍⴻⴼⵙⴰ ⴷⴻⴳ ⵓⵎⴻⵙⵔⵓⵇ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⵄⵄⴼⴻⵏ ⴷⴻⴳ ⵉⵏⵉⵔⵣⴰⵡⴻⵏ ⵏ ⵓⵢⵉⵙ, ⴰⵍ ⵖⴰ ⵉⵡⴹⴰ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN49_18","002_49_18","GEN","49","18","18","ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ ⵉ ⵜⵜⵔⴰⵊⵉⵖ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("GN49_19","002_49_19","GEN","49","19","19","ⵊⴰⴷ, ⴰⴷ ⵅⴰⵙ ⵃⴻⵊⵎⴻⵏⵜ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴷⴰⵔⵔⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("GN49_20","002_49_20","GEN","49","20","20","ⴰⵛⵉⵔ, ⴰⵖⵔⵓⵎ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⵔⵓⵎ ⵉⵙⵎⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵎⴰⵛⵛⴰ ⵢⵉⵣⵉⴷⴻⵏ ⵉⴳⴻⵍⵍⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN49_21","002_49_21","GEN","49","21","21","ⵏⴰⴼⵜⴰⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⵓⴷⴰⴷⵜ ⵉⵜⵜⵡⴰⴹⴻⵍⵇⴻⵏ, ⵉⵙⵙⵓⴼⴼⵓⵖ ⴰⵡⴰⵍⴻⵏ ⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN49_22","002_49_22","GEN","49","22","22","ⵢⵓⵙⵓⴼ ⴷ ⵎⵎⵉⵙ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ, ⵎⵎⵉⵙ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵖⴰⵔ ⵜⴰⵍⴰ. ⵢⴻⵙⵙⵉⵙ ⴳⴳⵓⵔⴻⵏⵜ ⵅ ⵡⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN49_23","002_49_23","GEN","49","23","23","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⴻⵣⴳⴻⵏ ⵅⴰⵙ ⵜⵓⴷⴰⵔⵜ, ⵏⴻⵢⵢⵛⴻⵏ ⵅⴰⵙ, ⵡⴰⵀ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ ⴹⴼⴰⵔⴻⵏ ⵜ, ");
INSERT INTO rift_vpl VALUES ("GN49_24","002_49_24","GEN","49","24","24","ⵎⴰⵛⴰ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵎⵃⴻⴹ ⵓ ⵉⵖⴰⴵⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵇⵇⵉⵎⴻⵏ ⴰⵔⵅⵓⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵏ ⵢⴰⵄⵇⵓⴱ - ⵅ ⵓⵢⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ - ");
INSERT INTO rift_vpl VALUES ("GN49_25","002_49_25","GEN","49","25","25","ⵙ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵄⴰⵡⵏⴻⵏ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⴱⴰⵔⴽⴻⵏ ⵙ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵙⴻⵏⵏⴻⵊ, ⵙ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ, ⵙ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏ ⵜⵓⴱⴱⴻⵛⵜ ⴷ ⵍⴻⵎⵍⴰⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GN49_26","002_49_26","GEN","49","26","26","ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏ ⴱⴰⴱⴰⵛ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵓⵄⵍⴰⵏⵜ ⵅ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵢⴻⵊⵊⵉⵏ ⵓⵛⴰ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏⵜ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜⵉⵏ ⵏ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵏ ⵍⴻⴱⴷⴰ. ⴰⴷ ⵉⵍⵉⵏⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵙⵓⴼ, ⵅ ⵜⵓⵛⵛⴻⵏⵜ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵔ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN49_27","002_49_27","GEN","49","27","27","ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⵓⵛⵛⴻⵏ ⵉⵜⵜⵎⴻⵣⵣⴰⵇ. ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⴰⴷ ⵉⵙⴰⵔⴹ ⵣⵣⴰⵔⴷⴻⵜ ⵓ ⵙ ⴵⵉⵍⴻⵜ ⵉⴱⴻⵟⵟⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN49_28","002_49_28","GEN","49","28","28","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ, ⵡⴰⵀ, ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN49_29","002_49_29","GEN","49","29","29","ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵖ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵏⴻⴹⵍⴻⵎ ⴰⵢⵉ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ ⴷⴻⴳ ⵉⴼⵔⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵉⴼⵔⵓⵏ, ⴰⵃⵉⵜⵜⵉ, ");
INSERT INTO rift_vpl VALUES ("GN49_30","002_49_30","GEN","49","30","30","ⴷⴻⴳ ⵉⴼⵔⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵎⴰⴽⴼⵉⵍⴰ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵎⴰⵎⵔⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵙⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴽ-ⴷ ⵢⴻⵢⵢⴰⵔ ⵣⵉ ⵉⴼⵔⵓⵏ, ⴰⵃⵉⵜⵜⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵏⴹⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN49_31","002_49_31","GEN","49","31","31","ⴷⵉⵏⵏⵉ ⵉ ⵏⴻⴹⵍⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵙⴰⵔⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⴷⵉⵏⵏⵉ ⵉ ⵏⴻⴹⵍⴻⵏ ⵉⵙⵃⴰⵇ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵔⵉⴼⵇⴰ. ⵓ ⵏⴻⵛⵛ ⵏⴻⴹⵍⴻⵖ ⴷⵉⵏ ⵍⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GN49_32","002_49_32","GEN","49","32","32","ⵉⵢⵢⴰⵔ ⵙ ⵉⴼⵔⵉ ⵉ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵉⵎⵎⵙⴻⵖ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵃⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("GN49_33","002_49_33","GEN","49","33","33","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵉⵡⴻⵚⵚⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⴽⴻⵎⵎⴻⵛ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵇⴰⵎⴰ, ⵉⴼⴼⴻⵖ ⵉ-ⵜ ⴱⵓⵃⴱⴻⵍ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN50_1","002_50_1","GEN","50","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⴳⴻⵣ ⵢⵓⵙⵓⴼ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⴱⴰⴱⴰⵙ, ⵉⵔⵓ ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("GN50_2","002_50_2","GEN","50","2","2","ⵢⵓⵎⵓⵔ ⵢⵓⵙⵓⴼ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⴹⴱⵉⴱⴻⵏ, ⴰⴷ ⵃⴻⵏⵏⴹⴻⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⴹⴱⵉⴱⴻⵏ ⵃⴻⵏⵏⴹⴻⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("GN50_3","002_50_3","GEN","50","3","3","ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⴰⵢⴻⵙ ⴽⴽⵉⵏ, ⵎⵉⵏⵣⵉ ⵃⴷⴰⵊⴻⵏ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵏ ⴰⵃⴻⵏⵏⴻⵟ ⵓⵛⴰ ⵔⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN50_4","002_50_4","GEN","50","4","4","ⵓⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵄⵣⴰⵜ ⵅⴰⵙ, ⵉⵙⵙⵉⵡⴻⵍ ⵢⵓⵙⵓⴼ ⴰⴽ-ⴷ ⵢⴻⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⵍⴻⵅⵅⵓ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵉⵎ: ");
INSERT INTO rift_vpl VALUES ("GN50_5","002_50_5","GEN","50","5","5","“ⴱⴰⴱⴰ ⵉⵏⵓ ⵉⵊⵊⴰ ⴰⵢⵉ ⴰⴷ ⵊⵊⴰⴵⴻⵖ ⵓⵛⴰ ⵉⵏⵏⴰ: ‘ⴰⵇⴰ ⵜⵜⵎⴻⵜⵜⵉⵖ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵢⵉ ⵜⵏⴻⴹⵍⴻⴷ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⵉ ⵏⴻⵇⵛⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ!’ ⵅⴻⵏⵏⵉ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ ⵍⴻⵅⵅⵓ ⴰⴷ ⵏⴻⴹⵍⴻⵖ ⴱⴰⴱⴰ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("GN50_6","002_50_6","GEN","50","6","6","ⵓⵛⴰ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ: “ⵔⵓⵃ, ⵏⴹⴻⵍ ⴱⴰⴱⴰⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⴰⵔⵔⴰ ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵜⴻⵊⵊⵓⴵⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("GN50_7","002_50_7","GEN","50","7","7","ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵢⵓⵙⵓⴼ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⴹⴻⵍ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴰⴽⵉⴷⴻⵙ, ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("GN50_8","002_50_8","GEN","50","8","8","ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⴷ ⴰⵢⵜⵎⴰⵙ ⵏⵏⴻⵙ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ⵎⵖⵉⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵙⴻⵏ ⵊⵊⵉⵏ ⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN50_9","002_50_9","GEN","50","9","9","ⴳⴻⵄⵄⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵇⴰⵔⵔⵓ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GN50_10","002_50_10","GEN","50","10","10","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⴰⵜⴰⴷ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴻⵎⵖⴰⵔ, ⵜⴻⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵢⵓⵙⵓⴼ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⴱⴰⴱⴰⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN50_11","002_50_11","GEN","50","11","11","ⵥⵔⵉⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⵛⴹⴰⵏ ⴷⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⴰⵜⴰⴷ, ⵏⵏⴰⵏ: “ⵡⴰ ⴷ ⴰⵛⴹⴰⵏ ⵉⵎⵖⴰⵔ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ.” ⵅ ⵓⵢⴰ ⵍⴰⵖⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴱⴰⵍ-ⵎⵉⵚⵔⴰⵢⵉⵎ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("GN50_12","002_50_12","GEN","50","12","12","ⴳⴳⵉⵏ ⴰⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵉⵡⴻⵚⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("GN50_13","002_50_13","GEN","50","13","13","ⴰⵔⴱⵓⵏ ⵜ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵉⴼⵔⵉ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵎⴰⴽⴼⵉⵍⴰ ⵏⵏⵉ ⵉⵙⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⴰⴽ-ⴷ ⵢⴻⵢⵢⴰⵔ ⵣⵉ ⵉⴼⵔⵓⵏ, ⴰⵃⵉⵜⵜⵉ, ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⴰⵎⵔⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵏⴹⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GN50_14","002_50_14","GEN","50","14","14","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⴹⴻⵍ ⴱⴰⴱⴰⵙ, ⵉⵄⵇⴻⴱ ⵢⵓⵙⵓⴼ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵏⴻⵜⵜⴰ ⴷ ⵢⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴹⵍⴻⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GN50_15","002_50_15","GEN","50","15","15","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜⵎⴰⵙ ⵏ ⵢⵓⵙⵓⴼ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉⵎⵎⵓⵜ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵉⵛⴰⵔⵀ ⴰⵏⴻⵖ ⵢⵓⵙⵓⴼ, ⴰⴷ ⴰⵏⴻⵖ ⵉⵅⴻⴵⴻⵚ ⵏⵉⵛⴰⵏ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵏⴻⴳⴳⴰ.” ");
INSERT INTO rift_vpl VALUES ("GN50_16","002_50_16","GEN","50","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⴰⴷ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵢⵓⵙⵓⴼ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⴱⴰⴱⴰⵛ ⵉⵡⴻⵚⵚⴰ ⵇⴱⴻⵍ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("GN50_17","002_50_17","GEN","50","17","17","‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ ⵉ ⵢⵓⵙⵓⴼ: ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵖⴼⴰⵔ ⵍⴻⵅⵅⵓ ⴰⵅⴻⵟⵟⵓ ⵏ ⴰⵢⵜⵎⴰⵛ ⴷ ⴷⴷⴻⵏⴱ ⵏⵙⴻⵏ ⴷ ⵍⵖⴰⵔ ⵉ ⴷ ⴰⵛ ⴳⴳⵉⵏ. ⵖⴼⴰⵔ ⵍⴻⵅⵅⵓ ⴰⵅⴻⵟⵟⵓ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ!’” ⵓⵛⴰ ⵉⵙⵖⵓⵢ ⵢⵓⵙⵓⴼ ⴰⵎ ⴽⵉⵙ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("GN50_18","002_50_18","GEN","50","18","18","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵢⵜⵎⴰⵙ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵡⴹⴰⵏ ⴰⵙ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ-ⵏⴻⵖ ⴷⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("GN50_19","002_50_19","GEN","50","19","19","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵢⵓⵙⵓⴼ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ! ⵎⴰ ⴰⵇⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("GN50_20","002_50_20","GEN","50","20","20","ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵅⴰⵔⵔⵚⴻⵎ ⴷⴰⵢⵉ ⵙ ⵍⵖⴰⵔ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵡⴰ ⵣⵣⴰⵢⴻⵙ ⵍⵅⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ, ⴰⴷ ⵢⴻⵊⵊ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GN50_21","002_50_21","GEN","50","21","21","ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ! ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵄⴻⵡⵡⵍⴻⵖ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵡⴻⵎ.” ⴰⵎⵎⵓ ⵜⴻⵏ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GN50_22","002_50_22","GEN","50","22","22","ⵜⵓⵖⴰ ⵢⵓⵙⵓⴼ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵓⵛⴰ ⵉⴷⴷⴰⵔ ⵢⵓⵙⵓⴼ ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GN50_23","002_50_23","GEN","50","23","23","ⵉⵥⵔⴰ ⵢⵓⵙⵓⴼ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ⴰⵇⴰ ⵜⵜⵡⴰⵔⵡⴻⵏ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⴽⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵄⴰⵡⴻⴷ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("GN50_24","002_50_24","GEN","50","24","24","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⵓⵙⵓⴼ ⵉ ⵢⴰⵢⵜⵎⴰⵙ: “ⵏⴻⵛⵛ ⴰⴷ ⵎⵎⵜⴻⵖ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵣⴻⴼ ⵙ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵉⵡⴰⵄⴷ ⵙ ⵜⵊⴰⴵⵉⵜ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("GN50_25","002_50_25","GEN","50","25","25","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵊⵊⵓⴵ ⵢⵓⵙⵓⴼ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵣⴻⴼ ⵙ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵙⵙⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("GN50_26","002_50_26","GEN","50","26","26","ⵉⵎⵎⵓⵜ ⵢⵓⵙⵓⴼ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵃⴻⵏⵏⴹⴻⵏ ⵜ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⴷⵉ ⵍⵎⴻⵃⵎⴻⵍ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⴷⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX1_1","003_1_1","EXO","1","1","1","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⴷⴷ-ⵢⵉⵡⴹⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⵢⵓⵙⴰ-ⴷⴷ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ:    ");
INSERT INTO rift_vpl VALUES ("EX1_2","003_1_2","EXO","1","2","2","ⵔⵓⴱⵉⵏ, ⵛⵉⵎⵄⵓⵏ, ⵍⴰⵡⵉ ⴷ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("EX1_3","003_1_3","EXO","1","3","3","ⵉⵙⵙⴰⴽⴰⵔ, ⵣⴰⴱⵓⵍⵓⵏ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("EX1_4","003_1_4","EXO","1","4","4","ⴷⴰⵏ ⴷ ⵏⴰⴼⵜⴰⵍⵉ, ⵊⴰⴷ ⴷ ⴰⵛⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("EX1_5","003_1_5","EXO","1","5","5","ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⵉⵏ. ⵢⵓⵙⵓⴼ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX1_6","003_1_6","EXO","1","6","6","ⵉⵎⵎⵓⵜ ⵢⵓⵙⵓⴼ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ, ⴷ ⵊⵊⵉⵍ ⵏⵏⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX1_7","003_1_7","EXO","1","7","7","ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵊⵊⵉⵏ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵙⴼⵓⴼⴼⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵜⵜⵡⴰⴽⵜⴰⵔⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵊⴻⵀⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵜⴻⵛⵛⵓⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX1_8","003_1_8","EXO","1","8","8","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵊⴷⵉⴷ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵎⵉⵚⵔⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("EX1_9","003_1_9","EXO","1","9","9","ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔ, ⵍⴳⴻⵏⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵎⵖⴰⵔ ⵓ ⵉⵊⵀⴻⴷ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX1_10","003_1_10","EXO","1","10","10","ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴰⴷ ⵅⴰⵙ ⵏⴻⵃⴽⴻⵎ ⵙ ⵍⴻⵄⵇⴻⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴰⵔⵏⵉ ⵍⴳⴻⵏⵙ ⴽⵜⴰⵔ, ⵓⵛⴰ, ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⵉⴽⴽⴰⵔ ⵛⴰ ⵏ ⵍⴱⴰⵔⵓⴹ, ⴰⴷ ⵉⴷⵡⴻⵍ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ, ⴰⴷ ⵢⴻⴳⴳ ⵍⵃⴰⵔⴱ ⴰⴽⵉⴷⵏⴻⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX1_11","003_1_11","EXO","1","11","11","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵅⴰⵙⴻⵏ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵅ ⵡⴰⵔⴱⴰⵔ ⵏ ⵜⴻⵙⵎⵓⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴷⴻⴵⴻⵏ ⵍⴳⴻⵏⵙ ⵙ ⴷⴷⵇⵓⵍⴰⵜ ⵉ ⵅⴰⵙⴻⵏ ⵙⵙⴰⵔⴻⴱⴱⵓⵏ. ⴱⵏⴰⵏ ⵉ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ: ⴼⵉⵜⵓⵎ ⴷ ⵔⴰⵄⴰⵎⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EX1_12","003_1_12","EXO","1","12","12","ⵎⴰⵛⴰ ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⴷⴻⴵⴻⵏ ⵏⵉⵜⵏⵉ ⵍⴳⴻⵏⵙ, ⴰⵎⴻⵏⵏⵉ ⵉ ⵉⴳⵎⴰ ⵓ ⵉⴱⴻⵣⵣⴻⵄ ⵍⴳⴻⵏⵙ, ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴰⵔⵀⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX1_13","003_1_13","EXO","1","13","13","ⵓⵛⴰ ⴰⵔⵔⵉⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵙ ⵓⵖⵉⵍ ");
INSERT INTO rift_vpl VALUES ("EX1_14","003_1_14","EXO","1","14","14","ⵓⵛⴰ ⵙⵙⴰⵔⴻⵣⴳⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵙ ⵜⴻⵙⵎⵓⵖⵉ ⵉⵇⴻⵙⵃⴻⵏ ⴷⴻⴳ ⵓⴱⴻⴵⴰⵄ ⴷ ⵍⵍⴰⵊⵓⵔ ⵓⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴻⵙⵎⵓⵖⵉ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⴰⵙⵎⵓⵖⵉ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⵜⵜ ⵙ ⵓⵖⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX1_15","003_1_15","EXO","1","15","15","ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴹ ⵏ ⵎⵉⵚⵔⴰ ⴰⴽ-ⴷ ⵍⵇⴰⴱⵍⴰⵜ ⵜⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⵉⵏ, ⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵙⵉⴼⵔⴰ, ⵓ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴼⵓⵄⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX1_16","003_1_16","EXO","1","16","16","ⵉⵏⵏⴰ: “ⵅⵎⵉ ⵖⴰ ⵜⵄⴰⵡⵏⴻⵏⵜ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⵉⵏ ⴰⴷ ⴰⵔⵡⴻⵏⵜ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⵏⵜ ⵅⵎⵉ ⵜⵜⵖⵉⵎⴰⵏⵜ ⵅ ⵉⵥⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵡⴻⵏⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵏⵜ ⴰⴷ ⵏⵖⴻⵏⵜ ⴰⵃⴻⵏⵊⵉⵔ ⵎⴰⵍⴰ ⴷ ⵎⵎⵉⵙ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷ ⵢⴻⴵⵉⵙ, ⵊⵊⴻⵏⵜ ⵜⵜ ⴰⴷ ⵜⴻⴷⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("EX1_17","003_1_17","EXO","1","17","17","ⵎⴰⵛⴰ ⵍⵇⴰⴱⵍⴰⵜ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏⵜ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴳⴳⵉⵏⵜ ⵎⵓⵅⴰⵙ ⵜⴻⵏⵜ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵛⴰ ⵃⴹⴰⵏⵜ ⵜⵓⴷⴰⵔⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX1_18","003_1_18","EXO","1","18","18","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵉ ⵍⵇⴰⴱⵍⴰⵜ, ⵉⵏⵏⴰ ⴰⵙⴻⵏⵜ: “ⵎⴰⵖⴰⵔ ⵜⴻⴳⴳⵉⵏⵜ ⴰⵢⴰ, ⴰⵇⴰ ⵜⴻⵃⴹⴰⵏⵜ ⵜⵓⴷⴰⵔⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("EX1_19","003_1_19","EXO","1","19","19","ⵍⵇⴰⴱⵍⴰⵜ ⴰⵔⵔⵉⵏⵜ ⵅ ⴼⵉⵔⵄⵓⵏ: “ⵜⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⵉⵏ ⵡⴰⵔ ⴵⵉⵏⵜ ⴰⵎ ⵜⵉⵎⵉⵚⵔⵉⵢⵢⵉⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⵊⴻⵀⴷⴻⵏⵜ, ⵜⵜⴰⵔⵡⴻⵏⵜ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏⵜ ⴷⴷ-ⵜⴰⵙ ⵍⵇⴰⴱⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX1_20","003_1_20","EXO","1","20","20","ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵎⵍⵉⵃ ⵉ ⵍⵇⴰⴱⵍⴰⵜ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵍⴳⴻⵏⵙ, ⴷⴻⵡⵍⴻⵏ ⵊⴻⵀⴷⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX1_21","003_1_21","EXO","1","21","21","ⵎⵉⵏⵣⵉ ⵍⵇⴰⴱⵍⴰⵜ ⴳⴳⵯⴻⴷⴻⵏⵜ ⴰⵔⴻⴱⴱⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⴰⵔⵣⴻⵇ ⵉ-ⵜⴻⵏⵜ-ⵉ-ⴷⴷ ⵙ ⵜⵓⴷⵔⵉⵏ ⴰⴽ-ⴷ ⵍⵡⴰⵛⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX1_22","003_1_22","EXO","1","22","22","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴼⵉⵔⵄⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴽⵓⵍ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⴷⴷ ⵖⴰ ⵉⵅⴻⵍⵇⴻⵏ ⴰⴷ ⵜ ⵜⴻⵏⴹⴰⵔⴻⵎ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵓ ⵎⴰⵔⵔⴰ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵉ ⴷⴷ ⵖⴰ ⵉⵅⴻⵍⵇⴻⵏ ⴰⴷ ⵜⵜ ⵜⴻⵊⵊⴻⵎ ⴰⴷ ⵜⴻⴷⴷⴰⵔ.”   * ");
INSERT INTO rift_vpl VALUES ("EX2_1","003_2_1","EXO","2","1","1","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵔⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴰⵡⵉ, ⵢⵉⵡⵉ ⵉⵛⵜ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵏ ⵍⴰⵡⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX2_2","003_2_2","EXO","2","2","2","ⵜⴻⴽⵙⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ. ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵉⵚⴱⴻⵃ ⵓⵃⴻⵏⵊⵉⵔ, ⵜⴻⴼⴼⴰⵔ ⵉ-ⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("EX2_3","003_2_3","EXO","2","3","3","ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵣⵎⴰⵔ ⵄⴰⴷ ⴰⴷ ⵜ ⵜⴻⴼⴼⴰⵔ, ⵜⴻⴽⵙⵉ ⴰⵙ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⵏⴷⵓⵇⵜ ⵏ ⵓⵖⴰⵏⵉⵎ, ⵜⴻⴱⵔⴰ ⵉ-ⵜⵜ ⵙ ⵓⵛⴰⵔⵎⵓⴹ ⴷ ⵜⵉⵣⴻⴼⵜ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⵙ ⴷⴰⵢⴻⵙ ⴰⵃⴻⵏⵊⵉⵔ, ⵜⴻⴳⴳⴰ ⵜⴰⵙⴻⵏⴷⵓⵇⵜ ⵏⵏⵉ ⵊⴰⵔ ⵓⵖⴰⵏⵉⵎ ⵅ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX2_4","003_2_4","EXO","2","4","4","ⵜⴱⴻⴷⴷ ⵡⵓⵍⵜⵎⴰⵙ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵥⴰⵔ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX2_5","003_2_5","EXO","2","5","5","ⵓ ⵅⵣⴰⵔ, ⵜⴻⵀⵡⴰ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵖⵣⴰⵔ. ⵜⵓⵖⴰ ⵜⵉⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵜⵉⴱⵍⵉⵖⵉⵏ ⵏⵏⴻⵙ ⴳⴳⵓⵔⴻⵏⵜ ⵅ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵥⵔⴰ ⵜⴰⵙⴻⵏⴷⵓⵇⵜ ⴷⴻⴳ ⵓⵖⴰⵏⵉⵎ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴽⴽ ⵜⵉⵙⵎⴻⵖⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵜⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("EX2_6","003_2_6","EXO","2","6","6","ⴰⵍⴰⵎⵉ ⵜⵜ ⵜⴰⵔⵣⴻⵎ, ⵜⴻⵥⵔⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⵉ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵃⴻⵏⵊⵉⵔ ⵜⵓⵖⴰ ⵉⵜⵜⵔⵓ. ⵢⵓⴷⴻⴼ ⵉ-ⵜⵜ ⵓⵣⵉⴵⴻⵣ, ⵜⴻⵏⵏⴰ: “ⵡⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("EX2_7","003_2_7","EXO","2","7","7","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵓⵍⵜⵎⴰⵙ ⵉ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ: “ⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵙⵓⴹⴻⴹⵜ ⵣⵉ ⵜⵄⵉⴱⵔⴰⵏⵉⵢⵢⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵎ ⵜⴻⵙⵙⵓⵟⵟⴻⴹ ⴰⵃⴻⵏⵊⵉⵔ?” ");
INSERT INTO rift_vpl VALUES ("EX2_8","003_2_8","EXO","2","8","8","ⵜⴻⵏⵏⴰ ⴰⵙ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ: “ⵔⵓⵃ!” ⵜⵔⵓⵃ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ, ⵜⵍⴰⵖⴰ ⵉ ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("EX2_9","003_2_9","EXO","2","9","9","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⴰⵙ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ: “ⴰⵡⵉ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ-ⴰ, ⵜⴻⵙⵙⵓⵟⵟⴻⴹ ⵉ-ⵜ ⵉ ⵏⴻⵛⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⵅⴻⴵⵚⴻⵖ.” ⵜⴻⴽⵙⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵜⴻⵙⵙⵓⵟⵟⴻⴹ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("EX2_10","003_2_10","EXO","2","10","10","ⵓⵎⵉ ⵉⴳⵎⴰ ⵓⵃⴻⵏⵊⵉⵔ, ⵜⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵉⴷⵡⴻⵍ ⴰⵙ ⴰⵎ ⵎⵎⵉⵙ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵎⵓⵙⴰ, ⵜⴻⵏⵏⴰ: “ⴰⵇⴰ ⵊⴻⴱⴷⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX2_11","003_2_11","EXO","2","11","11","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵉⴳⵎⴰ ⵎⵓⵙⴰ, ⴰⵇⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵙ, ⵓⵛⴰ ⵉⵥⵔⴰ ⴷⴷⵇⵓⵍⴰⵜ ⵉ ⵅⴰⵙⴻⵏ ⵙⵙⴰⵔⴻⴱⴱⵓⵏ. ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵓⵎⵉⵚⵔⵉ ⵉⵛⵛⴰⵜ ⵉⵊⵊ ⵏ ⵓⵄⵉⴱⵔⴰⵏⵉ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX2_12","003_2_12","EXO","2","12","12","ⵉⵅⵣⴰⵔ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⵃⴻⴷ, ⵅⴻⵏⵏⵉ ⵉⵏⵖⴰ ⴰⵎⵉⵚⵔⵉ ⵏⵏⵉ ⵓⵛⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⴷⴻⴳ ⵉⵊⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX2_13","003_2_13","EXO","2","13","13","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵜⵜⵎⴻⵏⵖⴰⵏ. ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ: “ⵎⴰⵖⴰⵔ ⵜⴻⵛⵛⴰⵜⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("EX2_14","003_2_14","EXO","2","14","14","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵡⵉ ⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ ⴷ ⵍⵃⴰⴽⴻⵎ ⴷ ⵍⵇⴰⴹⵉ ⵅⴰⵏⴻⵖ? ⵎⴰ ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ ⴰⵢⴰ ⵓⵎⵉ ⵛⴻⴽ ⵜⴻⵏⵡⵉⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵖⵉⴷ ⴰⵎⵉⵚⵔⵉ?” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("EX2_15","003_2_15","EXO","2","15","15","ⵓⵎⵉ ⵉⵙⵍⴰ ⴼⵉⵔⵄⵓⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵢⴰⵔⵣⵓ ⴰⴷ ⵉⵏⴻⵖ ⵎⵓⵙⴰ. ⵎⴰⵛⴰ ⵎⵓⵙⴰ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⴷⵢⴰⵏ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX2_16","003_2_16","EXO","2","16","16","ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵎⵉⴷⵢⴰⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵙⵙⵉⵙ, ⵜⵉⵏⵏⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴷ ⴰⵢⵎⴻⵏⵜ ⴰⵎⴰⵏ ⴷⵉⵏ ⵓⵛⴰ ⵛⵛⵓⵔⴻⵏⵜ ⵙⵙⵡⴰⵔⴻⵊ, ⵃⵉⵎⴰ ⴰⴷ ⵡⴰⵔⴷⴻⵏⵜ ⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX2_17","003_2_17","EXO","2","17","17","ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵓⵛⴰ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙⴻⵏⵜ. ⵉⴽⴽⴰⵔ ⵎⵓⵙⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ, ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏⵜ, ⵉⵡⴰⵔⴷ ⵓⴵⵉ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX2_18","003_2_18","EXO","2","18","18","ⵓⵎⵉ ⴷⴻⵡⵍⴻⵏⵜ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵔⴰⵄⵓⵢⵉⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏⵜ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷⴷ-ⵜⵜⵄⴻⵇⴱⴻⵏⵜ ⴰⵙⵙ-ⴰ ⴷⴻⵖⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("EX2_19","003_2_19","EXO","2","19","19","ⵏⵉⵜⴻⵏⵜⵉ ⴰⵔⵔⵉⵏⵜ-ⵉ-ⴷⴷ ⵅⴰⵙ: “ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵚⵔⵉ ⵉⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵢⵓⵢⴻⵎ ⴰⵏⴻⵖ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵉⵡⴰⵔⴷ ⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX2_20","003_2_20","EXO","2","20","20","ⵉⵏⵏⴰ ⵉ ⵢⴻⵙⵙⵉⵙ: “ⵉ ⵎⴰⵏⵉ ⵢⴻⴵⴰ? ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵊⵊⵉⵏⵜ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴷⵉⵏ? ⵔⵓⵃⴻⵏⵜ ⵍⴰⵖⴰⵏⵜ-ⵉ-ⴷⴷ ⵅⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛ ⴰⵖⵔⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("EX2_21","003_2_21","EXO","2","21","21","ⵓⵛⴰ ⵉⵇⴱⴻⵍ ⵎⵓⵙⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵉ ⵎⵓⵙⴰ ⵢⴻⴵⵉⵙ ⵚⴰⴼⴼⵓⵔⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX2_22","003_2_22","EXO","2","22","22","ⵜⴻⵊⵊⴰ ⴰⵙ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵉⴳⴳⴰ ⴰⵙ ⵊⴰⵔⵛⵓⵎ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵖⵔⵉⴱ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⴰⵖⵔⵉⴱⵜ ⵅⴰⴼⵉ.”    ");
INSERT INTO rift_vpl VALUES ("EX2_23","003_2_23","EXO","2","23","23","ⵍⴰⵎⵉ ⵜⴻⵄⴷⵓ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ, ⵉⵎⵎⵓⵜ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵡⴻⵃⵡⴻⵃⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⴷⴷⴰⵔⴻⵏ, ⵙⵙⵖⵓⵢⴻⵏ ⵓⵛⴰ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX2_24","003_2_24","EXO","2","24","24","ⵓⵛⴰ ⵉⵙⵙⵃⴻⵙⵙ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵅⴰⵔⵔⴻⵚ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵓ ⴰⴽ-ⴷ ⵉⵙⵃⴰⵇ ⵓ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("EX2_25","003_2_25","EXO","2","25","25","ⵉⵅⵣⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵢⴰⵔⴳⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵅ ⵍⴻⵖⴱⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX3_1","003_3_1","EXO","3","1","1","ⵢⴰⵔⵡⴻⵙ ⵎⵓⵙⴰ ⵓⴵⵉ ⵏ ⵢⵉⵜⵔⵓ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵎⵉⴷⵢⴰⵏ. ⵉⵏⴷⴻⵀ ⵓⴵⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵢⵉⵡⵉⴹ-ⴷⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔ ⵃⵓⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("EX3_2","003_3_2","EXO","3","2","2","ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵛⴻⵄⵄⵓⵍ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵓ ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵜⵓⵖⴰ ⵜⴻⴽⴽⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵙⵙⵉ, ⵎⴰⵛⴰ ⵛⴱⴰⵔⵇ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵛⵎⴻⴹ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EX3_3","003_3_3","EXO","3","3","3","ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵇⴻⵡⵙⴻⵖ ⵛⵡⴰⵢⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵖ ⵜⴰⵎⴻⵥⵔⵉⵡⵜ ⵏⵏⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵡⴰⵔ ⵉⵛⴻⵎⵎⴻⴹ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX3_4","003_3_4","EXO","3","4","4","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵉⵊⵊⴰ ⴰⴱⵔⵉⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⴰⵔ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵓⵙⴰ, ⵎⵓⵙⴰ!” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ: “ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("EX3_5","003_3_5","EXO","3","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵡⴰⵔ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⴰⴱ ⵛⴰ ⴷⴰⵏⵉⵜⴰ! ⴽⴽⴻⵙ ⵜⵉⵙⵉⵍⴰ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵎⵛⴰⵏ ⵉ ⵅⴻⴼ ⵜⴱⴻⴷⴷⴻⴷ, ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵇⴻⴷⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX3_6","003_3_6","EXO","3","6","6","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵎⵓⵙⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⴳⴳⵯⴻⴷ ⴰⴷ ⵉⵙⵡⴻⴹ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX3_7","003_3_7","EXO","3","7","7","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴰⵇⴰ ⵥⵔⵉⵖ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⴷⵉ ⵉⴷⴷⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵜⴰⵎⴰⵔⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX3_8","003_3_8","EXO","3","8","8","ⵀⵡⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴼⴻⴽⴽⴻⵖ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⴰⴷ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵚⴱⴻⵃ ⴷ ⵜⵎⵉⵔⵉⵡⵜ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⵉⴱⵓⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX3_9","003_3_9","EXO","3","9","9","ⵅⵣⴰⵔ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵥⵔⵉⵖ ⴷⴷⴻⴵ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵜⴻⵏ ⴷⴻⴵⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX3_10","003_3_10","EXO","3","10","10","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵔⵓⵃ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵙⵓⴼⴼⵖⴻⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX3_11","003_3_11","EXO","3","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ ⴰⵍⴰⵎⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵙⵔⴰ?” ");
INSERT INTO rift_vpl VALUES ("EX3_12","003_3_12","EXO","3","12","12","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⵉⵍⵉⵖ ⵓ ⵜⴰⵏⵉⵜⴰ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵛⴻⴽ: ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵣⵉ ⵎⵉⵚⵔⴰ, ⴰⴷ ⵜⵄⴻⴱⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵅ ⵡⴻⴷⵔⴰⵔ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX3_13","003_3_13","EXO","3","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵅⵣⴰⵔ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴰⵡⴹⴻⵖ ⵏⴻⵛⵛ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵏⵉⵖ: ‘ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ!’, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ ⵙⵙⴻⵇⵙⴰⵏ: ‘ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ?’, ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵉⵏⵉⵖ ⵅⴻⵏⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("EX3_14","003_3_14","EXO","3","14","14","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵎⵓⵙⴰ: “ⵏⴻⵛⵛ ⴷ ⵏⴻⵛⵛ ⵉ ⴵⵉⵖ”. ⵓⵛⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵏⴻⵛⵛ ⴷ ⵏⴻⵛⵛ ⵉ ⴵⵉⵖ! ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX3_15","003_3_15","EXO","3","15","15","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⵉ ⵎⵓⵙⴰ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ. ⴷ ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵢⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴰⵢⵉ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("EX3_16","003_3_16","EXO","3","16","16","ⵔⵓⵃ, ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ ⵉⴱⴰⵏ ⴰⵢⵉ-ⴷⴷ, ⵉⵏⵏⴰ: ‘ⴰⵇⴰ ⵅⴰⵡⴻⵎ ⵃⵉⵏⵏⴻⵖ ⵓⵛⴰ ⵥⵔⵉⵖ ⵎⵉⵏ ⵅⴰⵡⴻⵎ ⵙⵙⴻⵄⴷⵓⵏ ⴷⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX3_17","003_3_17","EXO","3","17","17","ⵏⵏⵉⵖ: ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵍⵎⴻⵃⵏⴻⵜ ⴷⵉ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⵉⴱⵓⵙⵉⵢⵢⴻⵏ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ.’ ");
INSERT INTO rift_vpl VALUES ("EX3_18","003_3_18","EXO","3","18","18","ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⵔⴰⵃⴻⴷ, ⵛⴻⴽ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ, ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("EX3_19","003_3_19","EXO","3","19","19","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⵓⵍⴰ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX3_20","003_3_20","EXO","3","20","20","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ, ⴰⴷ ⵡⵜⴻⵖ ⵎⵉⵚⵔⴰ ⵙ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉⵏⵓ ⵉ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴻⵊⵊ ⴰⴷ ⵜⵔⴰⵃⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX3_21","003_3_21","EXO","3","21","21","ⴰⴷ ⵃⵉⵏⵏⴻⵖ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵅⵎⵉ ⵖⴰ ⵜⵔⴰⵃⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⴼⴼⵖⴻⵎ ⵛⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX3_22","003_3_22","EXO","3","22","22","ⴰⴷ ⵜᵉⵜⵜⴰⵔ ⴽⵓⵍ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵜⴰⵊⵊⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵣⵉ ⵜⴱⴰⵔⵔⴰⵏⵉⵜ ⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵔⵔⵓⴹ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⵎ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴽⴻⵛⵛⴹⴻⵎ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX4_1","003_4_1","EXO","4","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⵜⵉⵎⵏⴻⵏ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ ⵛⴰ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵛ ⴷⴷ-ⵉⴱⴰⵏ ⵛⴰ!’” ");
INSERT INTO rift_vpl VALUES ("EX4_2","003_4_2","EXO","4","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ?” ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX4_3","003_4_3","EXO","4","3","3","ⵉⵏⵏⴰ: “ⵏⴹⴰⵔ ⵉ-ⵜⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ⵉⵏⴹⴰⵔ ⵉ-ⵜⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵓⴼⵉⵖⴰⵔ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⵎⵓⵙⴰ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX4_4","003_4_4","EXO","4","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵣⴻⴳ ⵓⵏⴻⵡⵡⴰⵔ ⵏⵏⴻⵙ ...” - ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵎⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵄⴰⵡⴻⴷ ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ - ");
INSERT INTO rift_vpl VALUES ("EX4_5","003_4_5","EXO","4","5","5","“... ⵃⵉⵎⴰ ⴰⴷ ⴰⵎⵏⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⴱⴰⵏ ⴰⵛ-ⴷⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("EX4_6","003_4_6","EXO","4","6","6","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ: “ⵙⵉⴷⴻⴼ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵛ.” ⵓⵛⴰ ⵉⵙⵙⵉⴷⴻⴼ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵓⵛⴰ ⵓⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⴽⴽⴻⵙ, ⵅⵣⴰⵔ, ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⴱⴰⵔⵚ ⴰⵎ ⵡⴻⴷⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX4_7","003_4_7","EXO","4","7","7","ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴰⵔⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ!” ⵢⴰⵔⵔⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵡⴻⵃⵙⵉⵏ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⴷⵡⴻⵍ ⵄⴰⵡⴻⴷ ⴰⵎ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX4_8","003_4_8","EXO","4","8","8","“ⵎⴰⵍⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵓⵎⵉⵏⴻⵏ ⵛⴰ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵜⵜⴻⵙⵍⵉⵏ ⵉ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⵜⵉⵏⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵎⵏⴻⵏ ⴷⵉ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵜⵉⵏⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX4_9","003_4_9","EXO","4","9","9","ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⵛⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ-ⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵛ ⵙⵍⵉⵏ ⵛⴰ, ⵅⴻⵏⵏⵉ ⴽⵙⵉ ⴰⵎⴰⵏ ⵏ ⵉⵖⵣⴰⵔ ⵓⵛⴰ ⴼⴰⵔⵔⴻⵖ ⵉ-ⵜⴻⵏ ⵅ ⵍⴰⵥⴰⵖ ⵓ ⴰⵎⴰⵏ ⵏⵏⵉ ⵜⴻⴽⵙⵉⴷ ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵍⴰⵥⴰⵖ.” ");
INSERT INTO rift_vpl VALUES ("EX4_10","003_4_10","EXO","4","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!, ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⴱⵓ-ⵜⴰⵡⴰⵍⵉⵏ, ⵉⴹⴻⵏⵏⴰⴹ ⵍⵍⴰ, ⵓⵍⴰ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ ⵍⵍⴰ ⵓ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⴻⴱⴷⵉⴷ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵍⵍⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵉⴷⴻⵇⵍⴻⵏ ⴷ ⵉⵍⴻⵙ ⵉⴷⴻⵇⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX4_11","003_4_11","EXO","4","11","11","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵡⵉ ⵉⵡⵛⵉⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵉ ⴱⵏⴰⴷⴻⵎ? ⵏⵉⵖ ⵡⵉ ⵉⴳⴳⵉⵏ ⵃⴻⴷ ⴷ ⴰⵣⵉⵢⵏⵓⵏ ⵏⵉⵖ ⴷ ⴰⴷⴻⵀⵛⵓⵔ ⵏⵉⵖ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵏⵉⵖ ⴷ ⴰⴷⴰⵔⵖⴰⵍ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("EX4_12","003_4_12","EXO","4","12","12","ⵍⴻⵅⵅⵓ, ⵔⵓⵃ ⴷⵉⵏ, ⴰⴷ ⵉⵍⵉⵖ ⴰⴽ-ⴷ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵍⵉⵃ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("EX4_13","003_4_13","EXO","4","13","13","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⴻⴽⴽ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("EX4_14","003_4_14","EXO","4","14","14","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵀⴰⵔⵓⵏ, ⴰⵍⴰⵡⵉ, ⴷ ⵓⵎⴰⵛ? ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⴷ ⴽⵉⵛ ⵉⵎⵙⴰⴳⴰⵔ ⵓ ⵅⵎⵉ ⵛⴻⴽ ⵖⴰ ⵉⵥⴰⵔ, ⴰⴷ ⵉⴼⴰⵔⵃ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX4_15","003_4_15","EXO","4","15","15","ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⴽⵉⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵡⴰⵍⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⴳⴳⵓⵔ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽ-ⴷ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴷ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⵖⴰⵔⴻⵖ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EX4_16","003_4_16","EXO","4","16","16","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ. ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵎⵎⵓ: ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⵉ ⵏⴻⵜⵜⴰ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX4_17","003_4_17","EXO","4","17","17","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ-ⴰ ⵉ ⵣⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EX4_18","003_4_18","EXO","4","18","18","ⵉⵔⵓⵃ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ ⵢⵉⵜⵔⵓ, ⵉⵏⵏⴰ ⴰⵙ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ, ⴰⴷ ⵄⴻⵇⴱⴻⵖ ⵖⴰⵔ ⴰⵢⵜⵎⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ, ⵎⴰ ⵄⴰⴷ ⴷⴷⴰⵔⴻⵏ.” ⵉⵏⵏⴰ ⵢⵉⵜⵔⵓ ⵉ ⵎⵓⵙⴰ: “ⵔⵓⵃ ⴷⵉ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX4_19","003_4_19","EXO","4","19","19","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵉ ⵎⵓⵙⴰ ⴷⵉ ⵎⵉⴷⵢⴰⵏ: “ⵍⵓⵃ, ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵎⵎⵓⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EX4_20","003_4_20","EXO","4","20","20","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵢⴰ ⵉ-ⵜⴻⵏ ⵅ ⵡⴻⵖⵢⵓⵍ, ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX4_21","003_4_21","EXO","4","21","21","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵅⵎⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ, ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵅⵣⴰⵔ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉ ⴼⵉⵔⵄⵓⵏ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⴳⴳⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵇⴻⵙⵃⴻⵖ ⵓⵍ ⵏⵏⴻⵙ, ⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⴹⵍⴻⵇ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX4_22","003_4_22","EXO","4","22","22","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⴼⵉⵔⵄⵓⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵉⵙⵔⴰⵉⵍ ⴷ ⵎⵎⵉ ⴷ ⴰⵎⴻⵏⵣⵓ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX4_23","003_4_23","EXO","4","23","23","ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵛ: ⴻⵊⵊ ⴰⴷ ⵉⴼⴼⴻⵖ ⵎⵎⵉ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ! ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵓⴳⵉⴷ ⴰⴷ ⵜ ⵜⴻⵊⵊⴻⴷ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵏⵖⴻⵖ ⵎⵎⵉⵛ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("EX4_24","003_4_24","EXO","4","24","24","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⵙⴻⵏ, ⵉⵎⵎⴻⵍⵇⴰ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX4_25","003_4_25","EXO","4","25","25","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵚⴰⴼⴼⵓⵔⴰ ⵉⵛⵜ ⵏ ⵜⵅⴻⴷⵎⴻⵛⵜ ⵏ ⵡⴻⵥⵔⵓ, ⵜⴻⵅⵜⴻⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏ ⵎⵎⵉⵙ ⵓⵛⴰ ⵜⴻⵍⵇⴻⴼ ⴰⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵛⴻⴽ ⵜⴻⴵⵉⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵙⵍⵉ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵏⴻⵛⵛ” ");
INSERT INTO rift_vpl VALUES ("EX4_26","003_4_26","EXO","4","26","26","ⵉⵊⵊⴰ ⵉ-ⵜ ⵅⴻⵏⵏⵉ. ⵍⴻⵅⴹⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ: “ⵛⴻⴽ ⴷ ⵉⵙⵍⵉ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵜⴻⴵⵉⴷ!”, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵅⵜⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX4_27","003_4_27","EXO","4","27","27","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵀⴰⵔⵓⵏ: “ⵔⵓⵃ ⴰⴷ ⵜⴻⵍⵇⵉⴷ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ!” ⵓⵛⴰ ⵉⵔⵓⵃ, ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("EX4_28","003_4_28","EXO","4","28","28","ⵉⵅⴻⴱⴱⴰⵔ ⵎⵓⵙⴰ ⵀⴰⵔⵓⵏ ⵅ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵓⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⴰⴷ ⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("EX4_29","003_4_29","EXO","4","29","29","ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EX4_30","003_4_30","EXO","4","30","30","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵀⴰⵔⵓⵏ ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX4_31","003_4_31","EXO","4","31","31","ⵓⵛⴰ ⵢⵓⵎⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵍⴳⴻⵏⵙ, ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵣⵣⵉⴵⴻⵣ ⴰⵙ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵉⵥⵔⴰ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⴷⵉ ⴵⴰⵏ, ⵓⴹⴰⵔⴻⵏ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX5_1","003_5_1","EXO","5","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴻⵊⵊ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⴻⵢⵢⴻⴷ ⴷⵉ ⵍⴻⵅⵍⴰ!’” ");
INSERT INTO rift_vpl VALUES ("EX5_2","003_5_2","EXO","5","2","2","ⵎⴰⵛⴰ ⴼⵉⵔⵄⵓⵏ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵙⵉⴷⵉ ⵓⵎⵉ ⵖⴰ ⵙⵍⴻⵖ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵊⵊⴻⵖ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⴼⴼⴻⵖ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⴰⴷ ⵉⵔⴰⵃ ⵉⵙⵔⴰⵉⵍ.”    ");
INSERT INTO rift_vpl VALUES ("EX5_3","003_5_3","EXO","5","3","3","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ, ⴻⵊⵊ ⴰⵏⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵔⴰⵃ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵍⴻⵇⵇⴻⴼ ⵙ ⵟⵟⴰⵄⵓⵏ ⵏⵉⵖ ⵙ ⵙⵙⵉⴼ.” ");
INSERT INTO rift_vpl VALUES ("EX5_4","003_5_4","EXO","5","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ: “ⵎⴰⵢⴻⵎⵎⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵍⴳⴻⵏⵙ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ? ⵔⵓⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⴷⴷⵇⵓⵍⴰⵜ ⵉ ⵅⴰⵡⴻⵎ ⵉⴵⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("EX5_5","003_5_5","EXO","5","5","5","ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵟⵟⴰⵙ ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵅ ⵡⴰⵔⴱⴰⵔ ⵏ ⴷⴷⵇⵓⵍⴰⵜ ⵉ ⵅⴰⵙⴻⵏ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX5_6","003_5_6","EXO","5","6","6","ⵢⵓⵎⵓⵔ ⴼⵉⵔⵄⵓⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵉ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX5_7","003_5_7","EXO","5","7","7","“ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵜⵜⵉⵛⴻⵎ ⵄⴰⴷ ⵍⵓⵎ ⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⴻⵏ ⵍⵍⴰⵊⵓⵔ ⴰⵎ ⵢⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⴷ ⵢⵔⵓⵏ ⵍⵓⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX5_8","003_5_8","EXO","5","8","8","ⵍⵇⴻⴷⴷ ⵏ ⵍⵍⴰⵊⵓⵔ ⵉ ⴳⴳⵉⵏ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜ ⵜⴻⴳⴳⴻⵎ ⵄⴰⵡⴻⴷ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵙⵏⴻⵇⵇⵉⵙⴻⵎ ⵡⴰⵍⵓ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⴼⵉⵏⵢⴰⵏⴻⵏ. ⵅ ⵓⵢⴰ ⵙⵖⵓⵢⵢⵓⵏ ⴰⵎⵎⵓ, ⵇⵇⴰⵔⴻⵏ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("EX5_9","003_5_9","EXO","5","9","9","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵍⵅⴻⴷⵎⴻⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴷⵇⴻⵍ ⵅ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵍⵀⴰⵏ ⴰⵎⵎⵓ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵛⴻⵏ ⵄⴰⴷ ⵜⴰⵢⵏⵉⵜ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX5_10","003_5_10","EXO","5","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵏⵙⴻⵏ ⴳⴳⵯⴻⵊⴻⵏ ⵅ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴼⵉⵔⵄⵓⵏ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⵉⵛⴻⵖ ⵛⴰ ⵄⴰⴷ ⵍⵓⵎ.’ ");
INSERT INTO rift_vpl VALUES ("EX5_11","003_5_11","EXO","5","11","11","ⵔⵓⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵢⴰⵔⵡⴻⵎ ⵍⵓⵎ ⵎⴰⵏⵉ ⵜ ⵖⴰ ⵜⴰⴼⴻⵎ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵡⴰⵍⵓ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX5_12","003_5_12","EXO","5","12","12","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵎⴱⴻⵣⵣⴻⵄ ⵍⴳⴻⵏⵙ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵔⵓⵏ ⵉⵖⴻⴵ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("EX5_13","003_5_13","EXO","5","13","13","ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵣⵉⵢⵢⴰⵔⴻⵏ ⵅⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴽⴻⵎⵎⵍⴻⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵡⴻⵎ, ⴽⵓⵍ ⴰⵙⵙ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵉ ⴽⵓⵍ ⴰⵙⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵍⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX5_14","003_5_14","EXO","5","14","14","ⵜⵜⵡⴰⴼⴰⵔⵛⴻⵏ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⴳⴳⵉⵏ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵡⴻⵎ ⵏ ⵍⵍⴰⵊⵓⵔ ⴰⵎ ⵍⴻⴱⴷⴰ, ⵉⴹⴻⵏⵏⴰⴹ ⵍⵍⴰ ⵓ ⵄⴰⵡⴻⴷ ⴰⵙⵙ-ⴰ ⵍⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("EX5_15","003_5_15","EXO","5","15","15","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵖⵓⵢⴻⵏ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⵎⵎⵓ ⴰⴽ-ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("EX5_16","003_5_16","EXO","5","16","16","ⵡⴰⵔ ⵉⵜⵜⵎⴻⵡⵛⵉ ⴱⵓ ⵓⵍⵓⵎ ⵉ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵏⴻⵛ, ⵡⴰⵅⵅⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵏⴻⵖ: ‘ⴳⴳⴻⵎ ⵍⵍⴰⵊⵓⵔ!’ ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵏⴻⵛ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵄⵎⵓⴷ, ⵡⴰⵅⵅⴰ ⵍⵄⵉⴱ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("EX5_17","003_5_17","EXO","5","17","17","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴼⵉⵏⵢⴰⵏⴻⵏ, ⴷ ⵉⴼⵉⵏⵢⴰⵏⴻⵏ ⴰⵟⵟⴰⵙ. ⵅ ⵓⵢⴰ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("EX5_18","003_5_18","EXO","5","18","18","ⵔⵓⵃⴻⵎ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⵅⴻⴷⵎⴻⵎ. ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⵉⵛⴻⵏ ⵄⴰⴷ ⴰⵍⵓⵎ, ⵡⴰⵅⵅⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⵙⴻⴱⴱⵍⴻⵎ ⵍⴻⵄⴱⴰⵔ ⵏ ⵍⵍⴰⵊⵓⵔ!” ");
INSERT INTO rift_vpl VALUES ("EX5_19","003_5_19","EXO","5","19","19","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵥⵔⵉⵏ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ-ⵜⴻⵏ ⵃⴰⵍⴰ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵙⵙⵏⴻⵇⵚⴻⵎ ⵡⴰⵍⵓ ⵣⵉ ⵍⵍⴰⵊⵓⵔ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵉ ⴽⵓⵍ ⴰⵙⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX5_20","003_5_20","EXO","5","20","20","ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵅ ⴼⵉⵔⵄⵓⵏ, ⵎⵎⵚⴰⴷⴰⴼⴻⵏ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵔⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX5_21","003_5_21","EXO","5","21","21","ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⴷ ⵙⵉⴷⵉ, ⴷ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵡⴰⵍⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⴻⵙⵙⴰⵔⵣⴳⴻⵎ ⴰⵏⴻⵖ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⴳⴳⵉⵎ ⵙⵙⵉⴼ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵏⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX5_22","003_5_22","EXO","5","22","22","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵎⵓⵙⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⴳⴳⴻⴷ ⵍⵖⴰⵔ ⴷⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴰⴷⴻⴷ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("EX5_23","003_5_23","EXO","5","23","23","ⵣⴻⴳ ⵡⴰⵎⵉ ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵉⴷⴻⴵ ⴼⵉⵔⵄⵓⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⵛⴻⴽ ⵇⴰⵄ ⵡⴰⵔ ⵜⴼⴻⴽⴽⵉⴷ ⵛⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EX6_1","003_6_1","EXO","6","1","1","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵉ ⴼⵉⵔⵄⵓⵏ, ⵎⵉⵏⵣⵉ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴰⴷ ⵔⴰⵃⴻⵏ, ⵡⴰⵀ, ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⴰⵥⵥⴻⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX6_2","003_6_2","EXO","6","2","2","ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EX6_3","003_6_3","EXO","6","3","3","ⵏⴻⵛⵛ ⴱⴰⵏⴻⵖ-ⴷⴷ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ ⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵎⴰⵛⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ‘ⵙⵉⴷⵉ’, ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵜⵡⴰⵙⵙⵏⴻⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EX6_4","003_6_4","EXO","6","4","4","ⵄⴰⵡⴻⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵙⴻⵏ ⴰⵇⴰ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵓⵏⴻⵡⵊⵉ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_5","003_6_5","EXO","6","5","5","ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⴰⵏⵉⵅⵙⴻⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵣⴻⴳ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX6_6","003_6_6","EXO","6","6","6","ⵙ ⵓⵢⴰ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷ ⵙⵉⴷⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵙⴰⴷⵓ ⵣⴰⵢⵍⵓ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴼⴻⴽⴽⴻⵖ ⵣⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵏⵙⴻⵏ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴼⴷⵉⵖ ⵙ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴷ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_7","003_6_7","EXO","6","7","7","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⴱⵍⴻⵖ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵣⵉ ⵙⴰⴷⵓ ⵣⴰⵢⵍⵓ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_8","003_6_8","EXO","6","8","8","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⵉⵅⴻⴼ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵜⵜ ⵡⵛⴻⵖ ⴷ ⵍⵡⴰⵔⵜ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("EX6_9","003_6_9","EXO","6","9","9","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵖⴰⵔ ⵎⵓⵙⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ ⴷ ⵜⴰⵙⵎⵓⵖⵉ ⵉⵇⴻⵙⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_10","003_6_10","EXO","6","10","10","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX6_11","003_6_11","EXO","6","11","11","“ⴰⴷⴻⴼ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵜⵉⵏⵉⴷ ⴰⵙ ⴰⴷ ⵉⴹⵍⴻⵇ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX6_12","003_6_12","EXO","6","12","12","ⵎⴰⵛⴰ ⵎⵓⵙⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵙⵍⵉⵏ, ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⴻⵍ ⴼⵉⵔⵄⵓⵏ ⵓ ⵏⴻⵛⵛ ⴰⵇⴰ ⵖⴰⵔⵉ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX6_13","003_6_13","EXO","6","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX6_14","003_6_14","EXO","6","14","14","ⵉⵏⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⴰⴵⴰⵜ ⵣⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵉⵜⵏⵉ ⴷ ⵀⴰⵏⵓⴽ ⴷ ⴼⴰⵍⵍⵓ, ⵃⴰⵚⵔⵓⵏ ⴷ ⴽⴰⵔⵎⵉ. ⴷ ⵢⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵔⵓⴱⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_15","003_6_15","EXO","6","15","15","ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⵎⵓⵢⵉⵍ ⴷ ⵢⴰⵎⵉⵏ ⴷ ⵓⵀⴰⴷ ⴷ ⵢⴰⴽⵉⵏ ⴷ ⵚⵓⵃⴰⵔ ⴷ ⵛⴰⵡⵓⵍ, ⵎⵎⵉ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴽⴻⵏⵄⴰⵏⵉⵜ. ⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_16","003_6_16","EXO","6","16","16","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⴻⵜⵜⴻⴼ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏⵙⴻⵏ: ⵊⴰⵔⵛⵓⵎ ⴷ ⵇⴰⵀⴰⵜ ⴷ ⵎⴰⵔⴰⵔⵉ. ⵜⵓⵖⴰ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵍⴰⵡⵉ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX6_17","003_6_17","EXO","6","17","17","ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵍⵉⴱⵏⴰ ⴷ ⵛⵉⵎⵄⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_18","003_6_18","EXO","6","18","18","ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵎⵔⴰⵎ ⴷ ⵢⵉⵚⵀⴰⵔ ⴷ ⵃⴰⴱⵔⵓⵏ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ. ⵜⵓⵖⴰ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵇⴰⵀⴰⵜ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX6_19","003_6_19","EXO","6","19","19","ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵃⵍⵉ ⴷ ⵎⵓⵛⵉ. ⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵍⴰⵡⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⴻⵜⵜⴻⴼ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_20","003_6_20","EXO","6","20","20","ⵓⵛⴰ ⵄⴰⵎⵔⴰⵎ ⵉⴽⵙⵉ ⵢⵓⴽⴰⴱⴰⴷ, ⵄⴻⵏⵜⵉⵙ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⵓⵙⴰ. ⵜⵓⵖⴰ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵄⴰⵎⵔⴰⵎ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX6_21","003_6_21","EXO","6","21","21","ⴰⵢⵜ ⵏ ⵢⵉⵚⵀⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵇⵓⵔⴰⵃ ⴷ ⵏⴰⴼⴰⵊ ⴷ ⴷⵉⴽⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EX6_22","003_6_22","EXO","6","22","22","ⴰⵢⵜ ⵏ ⵄⵓⵣⵣⵉⵢⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⴰⵍⵚⴰⴼⴰⵏ ⴷ ⵙⵉⵜⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EX6_23","003_6_23","EXO","6","23","23","ⵓⵛⴰ ⵉⴽⵙⵉ ⵀⴰⵔⵓⵏ ⵉⵍⵉⵛⴰⴱⴰⵄ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵏⴰⵃⵛⵓⵏ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX6_24","003_6_24","EXO","6","24","24","ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵙⵙⵉⵔ ⴷ ⴰⵍⵇⴰⵏⴰ ⴷ ⴰⴱⵉⵢⴰⵙⴰⴼ. ⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵇⵓⵔⴰⵃⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_25","003_6_25","EXO","6","25","25","ⵓⵛⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⵙⵉ ⵉⵛⵜⴻⵏ ⵣⴻⴳ ⵢⴻⵙⵙⵉⵙ ⵏ ⴼⵓⵜⵉⵢⵉⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⴼⵉⵏⴰⵃⴰⵙ. ⵉⵏⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX6_26","003_6_26","EXO","6","26","26","ⴰⵇⴰ ⵡⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⵓⵙⴰ ⵉ ⵓⵎⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵙⵓⴼⴼⵖⴻⵎ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX6_27","003_6_27","EXO","6","27","27","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EX6_28","003_6_28","EXO","6","28","28","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("EX6_29","003_6_29","EXO","6","29","29","ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵉ ⴵⵉⵖ! ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵖ, ⵉⵏⵉ ⵜ ⵉ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX6_30","003_6_30","EXO","6","30","30","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ: “ⴰⵇⴰ ⵖⴰⵔⵉ ⵏⴻⵛⵛ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴻⴳⴳ ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵉ ⵉⵙⴻⴵ ⴼⵉⵔⵄⵓⵏ?”    ");
INSERT INTO rift_vpl VALUES ("EX7_1","003_7_1","EXO","7","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⴼⵉⵔⵄⵓⵏ ⴷ ⵓⵎⴰⵛ ⵀⴰⵔⵓⵏ ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⴷ ⴰⵏⴰⴱⵉ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("EX7_2","003_7_2","EXO","7","2","2","ⵛⴻⴽ ⴰⴷ ⵜⵉⵏⵉⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵛⴻⴽ ⵖⴰ ⵓⵎⵓⵔⴻⵖ ⵓⵛⴰ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ, ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴼⵉⵔⵄⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX7_3","003_7_3","EXO","7","3","3","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵇⴻⵙⵃⴻⵖ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⴰⴷ ⴽⴻⵜⵜⴰⵔⴻⵖ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉⵏⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX7_4","003_7_4","EXO","7","4","4","ⵎⴰⵛⴰ ⴼⵉⵔⵄⵓⵏ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ-ⴷⴷ ⵉⵙⵙⵃⴻⵙⵙⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵏⵓ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX7_5","003_7_5","EXO","7","5","5","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵉ ⴵⵉⵖ ⵅⵎⵉ ⵖⴰ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX7_6","003_7_6","EXO","7","6","6","ⵓⵛⴰ ⴳⴳⵉⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵡⴰⵀ, ⴰⵎⴻⵏⵏⵉ ⵉ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX7_7","003_7_7","EXO","7","7","7","ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓ ⵜⵓⵖⴰ ⵀⴰⵔⵓⵏ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵍⴰⵎⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX7_8","003_7_8","EXO","7","8","8","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX7_9","003_7_9","EXO","7","9","9","“ⵎⴰⵍⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵡⴻⵎ ⴼⵉⵔⵄⵓⵏ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵙⴻⵛⵏⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵛⵜ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵀⴰⵔⵓⵏ: ‘ⵟⵟⴻⴼ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴹⴰⵔ ⵉ-ⵜⵜ ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵀⴰⵢⵛⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX7_10","003_7_10","EXO","7","10","10","ⵓⴷⴼⴻⵏ ⵅⴻⵏⵏⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ⵉⵏⴹⴰⵔ ⵀⴰⵔⵓⵏ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵀⴰⵢⵛⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX7_11","003_7_11","EXO","7","11","11","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴼⵉⵔⵄⵓⵏ ⵅ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵉⵙⴻⵃⵃⴰⵔⴻⵏ, ⵓⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⴰⵎⴻⵏⵏⵉ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵙⵡⴰⴷⴷⴰⵢ ⴷ ⵉⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX7_12","003_7_12","EXO","7","12","12","ⵉⵏⴹⴰⵔ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵉⵖⵖⴰⵔⵢⴻⵏ ⵏⵏⵉ ⴷ ⵍⵀⴰⵢⵛⴰⵜ. ⵎⴰⵛⴰ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⵀⴰⵔⵓⵏ ⵜⵙⴰⵔⴹ ⵜⵉⵖⵖⴰⵔⵢⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX7_13","003_7_13","EXO","7","13","13","ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵉⴷⵡⴻⵍ ⵉⵇⵙⴻⵃ ⵓⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵍⵉ ⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX7_14","003_7_14","EXO","7","14","14","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵉⴷⵡⴻⵍ ⵉⵇⵙⴻⵃ. ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX7_15","003_7_15","EXO","7","15","15","ⵔⵓⵃ ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵡⴰⵎⴰⵏ. ⵛⴻⴽ ⵔⴰⵊⴰ ⴷⵉⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵢⵉⵖⵣⴰⵔ ⵓⵛⴰ ⴽⵙⵉ-ⴷⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴰⴼⵉⵖⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX7_16","003_7_16","EXO","7","16","16","ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵉⵏⵏⴰ: ⴻⵊⵊ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ ⴷⵉ ⵍⴻⵅⵍⴰ! ⵅⵣⴰⵔ, ⴰⵍ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵙⴻⴵⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX7_17","003_7_17","EXO","7","17","17","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!’ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵜⴻⵖ ⴰⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵙ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵉ ⵖⴰⵔⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX7_18","003_7_18","EXO","7","18","18","ⵉⵙⴻⵍⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⴰⴷ ⵎⵎⵜⴻⵏ ⴰⵍ ⵖⴰ ⵢⵓⵔⵚⵓⴹ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ, ⴰⴷ ⵄⵉⴼⴼⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⴰⵎⴰⵏ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("EX7_19","003_7_19","EXO","7","19","19","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵉ ⵎⵓⵙⴰ: “ⵉⵏⵉ ⵉ ⵀⴰⵔⵓⵏ: ‘ⴽⵙⵉ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ, ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵡⴰⵎⴰⵏ ⵏ ⵎⵉⵚⵔⴰ, ⵅ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵙⴻⵏ, ⵅ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏⵙⴻⵏ, ⵅ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ ⵏⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉⵙ ⵜⵜⵎⵓⵏⴰⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵍⴰ ⴷⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ.’” ");
INSERT INTO rift_vpl VALUES ("EX7_20","003_7_20","EXO","7","20","20","ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵀⴰⵔⵓⵏ ⵜⴰⵖⵖⴰⵔⵛⵜ, ⵉⵡⵜⴰ ⴰⵎⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX7_21","003_7_21","EXO","7","21","21","ⵎⵎⵓⵜⴻⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵓⵛⴰ ⵢⵓⵔⵚⵓⴹ ⵢⴻⵖⵣⴰⵔ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵡⴻⵏ ⴰⵎⴰⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵡⴰⵎⴰⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX7_22","003_7_22","EXO","7","22","22","ⵎⴰⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴳⴳⵉⵏ ⴰⵎⴻⵏⵏⵉ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵙⵡⴰⴷⴷⴰⵢ ⴰⵍⴰⵎⵉ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵉⴷⵡⴻⵍ ⵉⵇⵙⴻⵃ, ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵙⵃⴻⵙⵙ ⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX7_23","003_7_23","EXO","7","23","23","ⵉⵏⵏⴻⵇⵍⴻⴱ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵓⵍ ⵏⵏⴻⵙ ⵄⴰⴷ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EX7_24","003_7_24","EXO","7","24","24","ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵖⵣⴰⵏ ⵅ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴼⴻⵏ ⴰⵎⴰⵏ ⵏ ⵜⴻⵙⵙⵉⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⴰⵎⴰⵏ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX7_25","003_7_25","EXO","7","25","25","ⴰⵎⵎⵓ ⵉ ⵄⴷⵓⵏ ⵙⴻⴱⵄⴰ ⵓⵙⵙⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵡⵜⴰ ⵙⵉⴷⵉ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX7_26","003_7_26","EXO","7","26","26","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⴷⴻⴼ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵉ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴻⵊⵊ ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX7_27","003_7_27","EXO","7","27","27","ⵎⴰⵍⴰ ⵜⵓⴳⵉⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵔⴰⵃⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵡⵜⴻⵖ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵙ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EX7_28","003_7_28","EXO","7","28","28","ⵓⵛⴰ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ ⴰⴷ ⴷⴷ-ⵉⵙⴻⴼⴼⵉⵢ ⵅ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ-ⴷⴷ ⴳⴻⵄⵄⴷⴻⵏ, ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵛ ⵏ ⵢⵉⴹⴻⵚ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵅ ⵇⴰⵎⴰ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵓ ⵄⴰⴷ ⴷⴻⴳ ⵉⴼⴰⵔⵔⴰⵏⴻⵏ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵜⴱⴻⵇⵢⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX7_29","003_7_29","EXO","7","29","29","ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴳⴻⵄⵄⴷⴻⵏ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵓⵍⴰ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("EX8_1","003_8_1","EXO","8","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵉ ⵎⵓⵙⴰ: “ⵉⵏⵉ ⵉ ⵀⴰⵔⵓⵏ: ‘ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵙ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ ⵅ ⵉⵖⴻⵣⵔⴰⵏ, ⵅ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵓⵍⴰ ⵅ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EX8_2","003_8_2","EXO","8","2","2","ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵀⴰⵔⵓⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵡⴰⵎⴰⵏ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵓⵛⴰ ⴷⵍⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX8_3","003_8_3","EXO","8","3","3","ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴳⴳⵉⵏ ⴰⵎⴻⵏⵏⵉ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵙⵡⴰⴷⴷⴰⵢ ⴷ ⵉⵛⵜ, ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX8_4","003_8_4","EXO","8","4","4","ⵉⵍⴰⵖⴰ-ⴷⴷ ⴼⵉⵔⵄⵓⵏ ⵅ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵥⴰⴵⴻⵎ ⵙ ⵍⴰⴵⴰⵖ ⵉ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⴽⵙⵉ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵓ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵊⵊⴻⵖ ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX8_5","003_8_5","EXO","8","5","5","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⴼⵉⵔⵄⵓⵏ: “ⵟⵟⴻⴼ ⵅⴰⴼⵉ ⵍⵃⵓⵔⵎⴻⵜ ⵎⴻⵍⵎⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⴰⴷ ⵅⴰⴽ ⵥⵥⴰⴵⴻⵖ ⵓ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴽ ⵇⴻⴹⵄⴻⵖ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵓ ⵅ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX8_6","003_8_6","EXO","8","6","6","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵜⵉⵡⴻⵛⵛⴰ!” ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵃⴻⴷ ⴰⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX8_7","003_8_7","EXO","8","7","7","ⵓⵛⴰ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⴰⴷ ⵎⵎⴻⴽⵙⵉⵏ ⵅⴰⴽ ⵓ ⵅ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵛ ⵓⵍⴰ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX8_8","003_8_8","EXO","8","8","8","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵅ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵅ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX8_9","003_8_9","EXO","8","9","9","ⵓⵛⴰ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴰⵙ ⴰⴽ-ⴷ ⵡⴰⵡⴰⵍ ⵏ ⵎⵓⵙⴰ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵓⵛⴰ ⵡⴻⴷⴷⴰⵔⴻⵏ ⵣⵉ ⵜⵓⴷⵔⵉⵏ, ⵣⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵓ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX8_10","003_8_10","EXO","8","10","10","ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⵜⴻⵏ ⴷ ⵉⵄⵓⵔⵔⴰⵛ ⵓⵛⴰ ⵜⵓⵔⵚⵓⴹ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX8_11","003_8_11","EXO","8","11","11","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⴼⵉⵔⵄⵓⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴱⵏⴰⴷⴻⵎ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵔ ⵏⵏⴻⴼⵙ, ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵙⵃⴻⵙⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX8_12","003_8_12","EXO","8","12","12","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵉⵏⵉ ⵉ ⵀⴰⵔⵓⵏ: ‘ⵙⵡⵉⵥⵥⴻⴹ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ, ⵜⴻⵡⵜⴻⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵏⵏⴰⵎⵓⵙ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EX8_13","003_8_13","EXO","8","13","13","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ. ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵀⴰⵔⵓⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵙ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⵉ ⴷⴰⵢⴻⵙ, ⵉⵡⵜⴰ ⴰⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵏⵏⴰⵎⵓⵙ ⴰⵎ ⵅ ⵉⵡⴷⴰⵏ ⴰⵎ ⵅ ⵍⵎⴰⵍ. ⵎⴰⵔⵔⴰ ⴰⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴷⵡⴻⵍ ⴷ ⵏⵏⴰⵎⵓⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX8_14","003_8_14","EXO","8","14","14","ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴳⴳⵉⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵙⵡⴰⴷⴷⴰⵢ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵏⵏⴰⵎⵓⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ. ⵓⵛⴰ ⵜⵓⵖⴰ ⵏⵏⴰⵎⵓⵙ ⵅ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX8_15","003_8_15","EXO","8","15","15","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵉ ⴼⵉⵔⵄⵓⵏ: “ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⴹⴰⴹ ⵏ ⴰⵔⴻⴱⴱⵉ!” ⵎⴰⵛⴰ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵙⴻⴵ ⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX8_16","003_8_16","EXO","8","16","16","ⵓⵛⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵜⵉⵡⴻⵛⵛⴰ ⴽⴽⴰⵔ ⵣⵉⵛ, ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵡⴰⵎⴰⵏ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴻⵊⵊ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("EX8_17","003_8_17","EXO","8","17","17","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵊⵊⵉⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵉⵔⴰⵃ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵢⵍⴰⴼⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ, ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵅ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵏⵜ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵙ ⵉⵢⵍⴰⴼⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX8_18","003_8_18","EXO","8","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵙⵙⵃⵓⵣⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵜⵉⵍⵉⵏ ⵡⴻⵢⵍⴰⴼⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX8_19","003_8_19","EXO","8","19","19","ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵡⴻⵚⵍⴰⵃ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵡⴻⵏⵏⵉ ⵏⵏⴻⵛ. ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EX8_20","003_8_20","EXO","8","20","20","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ. ⵓⵙⵉⵏ-ⴷⴷ ⵉⵢⵍⴰⴼⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵅ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵢⵍⴰⴼⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("EX8_21","003_8_21","EXO","8","21","21","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵜⵇⴻⴷⴷⵎⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX8_22","003_8_22","EXO","8","22","22","ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⴰⴷ ⵏⴻⴳⴳ ⴰⵎⵎⵓ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵖⴰⵔ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵏⵇⴻⴷⴷⴻⵎ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵖⵉⵍ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴰⵔⴻⵊⵊⵎⴻⵏ ⵛⴰ? ");
INSERT INTO rift_vpl VALUES ("EX8_23","003_8_23","EXO","8","23","23","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX8_24","003_8_24","EXO","8","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴼⵉⵔⵄⵓⵏ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵊⵊⴻⵖ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷⵉ ⵍⴻⵅⵍⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵉⴳⴳⵯⵉⵊⴻⵎ ⴰⵟⵟⴰⵙ. ⵥⴰⴵⴻⵎ ⵓⵍⴰ ⵅⴰⴼⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX8_25","003_8_25","EXO","8","25","25","ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴰⴷ ⵅⴰⴽ ⴼⴼⵖⴻⵖ, ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⵉⵡⴻⵛⵛⴰ ⵉⵢⵍⴰⴼⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ ⵅ ⴼⵉⵔⵄⵓⵏ, ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴼⵉⵔⵄⵓⵏ ⵡⴰⵔ ⵉⵅⴻⴷⴷⴻⵄ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX8_26","003_8_26","EXO","8","26","26","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵎⵓⵙⴰ ⵅ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX8_27","003_8_27","EXO","8","27","27","ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⵉⵢⵍⴰⴼⴻⵏ ⵏ ⵉⴱⴻⵄⵄⴰⵛ ⵅ ⴼⵉⵔⵄⵓⵏ, ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴻⵄⵄⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("EX8_28","003_8_28","EXO","8","28","28","ⵎⴰⵛⴰ ⴼⵉⵔⵄⵓⵏ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏⵏⴻⵙ ⵜⵡⴰⵍⴰ-ⵢⴰ ⵄⴰⵡⴻⴷ, ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX9_1","003_9_1","EXO","9","1","1","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⴷⴻⴼ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵉⵏⵉ ⴰⵙ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵇⵇⴰⵔ ⴰⵎⵎⵓ: ⴻⵊⵊ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX9_2","003_9_2","EXO","9","2","2","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⴳⵉⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵔⴰⵃⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜᵉⵟⵟⴼⴻⴷ ⵄⴰⴷ ⴽⵜⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("EX9_3","003_9_3","EXO","9","3","3","ⵅⵣⴰⵔ, ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵍⵎⴰⵍ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵅ ⵉⵢⵙⴰⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⴷ ⵢⵉⵍⴻⵖⵎⴰⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓⵍⴰ ⵅ ⵡⵓⴵⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵟⵟⴰⵄⵓⵏ ⵉⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX9_4","003_9_4","EXO","9","4","4","ⴰⴷ ⵉⴼⴰⵔⵣ ⵙⵉⴷⵉ ⵊⴰⵔ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("EX9_5","003_9_5","EXO","9","5","5","ⵓⵛⴰ ⵉⵏⴻⵢⵢⴻⵛ ⵙⵉⴷⵉ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⵉⵏⵏⴰ: “ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⵙⵉⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX9_6","003_9_6","EXO","9","6","6","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⴷⴻⵇⵇ ⵏⵏⵉ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵛⴰ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜⴻⵎⵎⵓⵜ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX9_7","003_9_7","EXO","9","7","7","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴼⵉⵔⵄⵓⵏ ⵉⵊⵊⴻⵏ, ⵓⵛⴰ ⴰⵇⴰ ⴷⴰ, ⵡⴰⵔ ⵜⴻⵎⵎⵓⵜ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵛⴰ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵉⴷⵡⴻⵍ ⵉⵇⵙⴻⵃ ⵓⵛⴰ ⵡⴰⵔ ⵢⴻⵊⵊⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX9_8","003_9_8","EXO","9","8","8","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ: “ⵄⴻⵎⵎⴰⵔ ⵓⵔⵓ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵙ ⵉⵖⵖⴻⴹ ⵣⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵓⵛⴰ ⴻⵊⵊ ⵎⵓⵙⴰ ⴰⴷ ⵜ ⵉⵣⵣⵓⵣⴰⵔ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX9_9","003_9_9","EXO","9","9","9","ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵖⵖⴻⴹ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵉⴼⵙⵓⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵜⴰⵄⴻⵊⵊⴰⵛⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⵉⵃⴻⴱⴱⴰ ⵙ ⵍⴻⵡⵄⵉ ⵅ ⴱⵏⴰⴷⴻⵎ ⵓ ⵅ ⵍⵎⴰⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX9_10","003_9_10","EXO","9","10","10","ⵓⵛⴰ ⴽⵙⵉⵏ ⵉⵖⵖⴻⴹ ⵣⵉ ⵜⴻⴼⵇⵓⵏⵜ ⴰⵎ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵣⵣⵓⵣⴰⵔ ⵉ-ⵜ ⵎⵓⵙⴰ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷ ⵜⵉⵃⴻⴱⴱⴰ ⵙ ⵍⴻⵡⵄⵉ ⴰⵎ ⴷⴻⴳ ⵉⵡⴷⴰⵏ ⴰⵎ ⴷⵉ ⵍⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EX9_11","003_9_11","EXO","9","11","11","ⴰⵍⴰⵎⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵎⵓⵙⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵃⴻⴱⴱⴰ, ⵎⵉⵏⵣⵉ ⵜⵉⵃⴻⴱⴱⴰ ⵃⴻⴽⵎⴻⵏⵜ ⵉⵙⴻⵃⵃⴰⵔⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX9_12","003_9_12","EXO","9","12","12","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵙⴻⴵ ⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX9_13","003_9_13","EXO","9","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵜⵉⵡⴻⵛⵛⴰ ⴽⴽⴰⵔ ⵣⵉⵛ, ⵜⴱⴻⴷⴷⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ: ⴻⵊⵊ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX9_14","003_9_14","EXO","9","14","14","ⵎⵉⵏⵣⵉ ⵜⵡⴰⵍⴰ-ⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵍⴻⵇⴼⴻⵖ ⴷⴻⴳ ⵡⵓⵍ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⵔⴰⵢⴻⵃ ⵉⵏⵓ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵉⴵⵉ ⵃⴻⴷ ⴰⵎ ⵏⴻⵛⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX9_15","003_9_15","EXO","9","15","15","ⵎⵉⵏⵣⵉ ⵄⴰⴷ ⵍⴻⵅⵅⵓ ⵜⵓⵖⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵡⵜⴻⵖ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵟⵟⴰⵄⵓⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⵉⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX9_16","003_9_16","EXO","9","16","16","ⵎⴰⵛⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵛⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⴻⵄ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX9_17","003_9_17","EXO","9","17","17","ⵎⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵄⴰⴷ ⵜⵉⵄⵉⵏⴽⵔⵉⴼⵉⵏ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⵔⴰⵃⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("EX9_18","003_9_18","EXO","9","18","18","ⵅⵣⴰⵔ, ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ-ⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⴱⵔⵓⵔⵔⵉ ⵉⴷⴷⴻⵇⵍⴻⵏ ⴰⴷ ⵜⴻⵡⵡⴻⵜ, ⵜⴰⴱⵔⵓⵔⵔⵉ ⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⵄⴻⵎⵎⴰⵔⵚ ⴷⵉ ⵎⵉⵚⵔⴰ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("EX9_19","003_9_19","EXO","9","19","19","ⵅⴻⵏⵏⵉ ⵙⴻⴽⴽ ⵍⴻⵅⵅⵓ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⴷⴼⴻⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⴷ ⵍⵎⴰⵍ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵡⴰⵔ ⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EX9_20","003_9_20","EXO","9","20","20","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⴷⴻⵏ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵉⵊⵊⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⵓⴷⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX9_21","003_9_21","EXO","9","21","21","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵇⵇⴻⵏ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵊⵊⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX9_22","003_9_22","EXO","9","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵅ ⵉⵡⴷⴰⵏ, ⵅ ⵍⵎⴰⵍ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX9_23","003_9_23","EXO","9","23","23","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵎⵓⵙⴰ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵊⵊⴰⵊ ⴷ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵓⵛⴰ ⵜⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵜⵎⴻⵙⵙⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵡⵡⴻⵜ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX9_24","003_9_24","EXO","9","24","24","ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴰⴱⵔⵓⵔⵔⵉ ⴷ ⵜⵎⴻⵙⵙⵉ ⵉⵅⴻⴵⴹⴻⵏ ⴰⴽ-ⴷ ⵜⴻⴱⵔⵓⵔⵔⵉ. ⵜⵓⵖⴰ ⵜⴻⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⵜ ⵜⵓⵖⵉ ⵄⴻⵎⵎⴰⵔⵚ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX9_25","003_9_25","EXO","9","25","25","ⵓⵛⴰ ⵜⴻⵡⵜⴰ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵅ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ. ⵜⴻⵡⵜⴰ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵄⴰⵡⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵜⵜⵡⴰⵔⵥⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EX9_26","003_9_26","EXO","9","26","26","ⵎⵖⵉⵔ ⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ, ⵎⴰⵏⵉ ⴵⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵜⴻⵡⵜⵉ ⵜⴻⴱⵔⵓⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EX9_27","003_9_27","EXO","9","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⵜⵡⴰⵍⴰ-ⵢⴰ. ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵓⵛⴰ ⵏⴻⵛⵛ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EX9_28","003_9_28","EXO","9","28","28","ⵥⴰⴵⴻⵎ ⵙ ⵍⴰⴵⴰⵖ ⵉ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵛⴼⴰ, ⴰⵇⴰ ⴰⵊⵊⴰⵊⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵟⵟⴰⵙ ⵓⵍⴰ ⴷ ⵜⴰⴱⵔⵓⵔⵔⵉ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵊⵊⴻⵖ ⴰⴷ ⵜⵔⴰⵃⴻⵎ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜᵉⵟⵟⴼⴻⵖ ⵛⴰ ⵄⴰⴷ ⴷⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX9_29","003_9_29","EXO","9","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵎⵓⵙⴰ: “ⵎⴻⵍⵎⵉ ⵖⴰ ⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵜⴻⴱⵔⵓⵔⵔⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ-ⵜⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX9_30","003_9_30","EXO","9","30","30","ⵎⴰⵛⴰ ⵅⴰⴽ ⴷ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵎⴰⵣⴰⵍ ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ ⵣⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX9_31","003_9_31","EXO","9","31","31","ⵜⵉⴼⴼⴻⵙⵜ ⴷ ⵉⵎⴻⵏⴷⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵍⴻⵇⴼⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵎⴻⵏⴷⵉ ⵜⵓⵖⴰ-ⵜ ⵙ ⵜⵉⴷⵔⵉⵏ ⴷ ⵜⵉⴼⴼⴻⵙⵜ ⵜⵏⴻⵡⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX9_32","003_9_32","EXO","9","32","32","ⵎⴰⵛⴰ ⵉⵔⴷⴻⵏ ⴷ ⴽⴰⵔⵚⴰⵏⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵍⴻⵇⴼⴻⵏ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EX9_33","003_9_33","EXO","9","33","33","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵎⵓⵙⴰ ⵣⵉ ⴼⵉⵔⵄⵓⵏ, ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⴽⵙⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⵉⴷⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴷ ⵜⴻⴱⵔⵓⵔⵔⵉ ⵓⵍⴰ ⴷ ⵉⴱⵓⴷⴰ ⵏ ⵡⴻⵏⵥⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX9_34","003_9_34","EXO","9","34","34","ⵓⵎⵉ ⵉⵥⵔⴰ ⴼⵉⵔⵄⵓⵏ ⴱⴻⵍⵍⵉ ⴰⵏⵥⴰⵔ ⴷ ⵜⴻⴱⵔⵓⵔⵔⵉ ⴷ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴱⴻⴷⴷⴻⵏ, ⵉⵅⴹⴰ ⵄⴰⴷ ⴽⵜⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX9_35","003_9_35","EXO","9","35","35","ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵢⴰⵔⵏⵉ ⴷⵉ ⵍⴻⵇⵙⴰⵃⴻⵜ, ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵔⴰⵃ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX10_1","003_10_1","EXO","10","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⴷⴻⴼ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵇⴻⵙⵃⴻⵖ ⵓⵍ ⵏⵏⴻⵙ ⴷ ⵡⵓⵍ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EX10_2","003_10_2","EXO","10","2","2","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴰⵡⴷⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⵎⵉⵛ ⴷ ⵎⵎⵉⵙ ⵏ ⵎⵎⵉⵛ ⵎⵉⵏ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵎⵉⵚⵔⴰ, ⵓ ⴰⴷ ⵜⵄⴰⵡⴷⴻⴷ ⵅ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⴳⴳⵉⵖ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX10_3","003_10_3","EXO","10","3","3","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⴰ: ‘ⵎⴻⵛⵃⴰⵍ ⵖⴰ ⵜⴻⴽⴽⴻⴷ ⵜⵓⴳⵉⴷ ⴰⴷ ⵜⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵉⵏⵓ? ⴻⵊⵊ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX10_4","003_10_4","EXO","10","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⴳⵉⴷ ⴰⴷ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵉⵔⴰⵃ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵇⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵜⵉⵡⴻⵛⵛⴰ ⵜⵎⵓⵔⵖⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX10_5","003_10_5","EXO","10","5","5","ⴰⴷ ⴷⵍⴻⵏ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵉⵜⵡⴰⵍⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵄⴰⴷ ⵓⵛⴰ ⴰⴷ ⵛⵛⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⵉⵜⵜⵡⴰⵏⴻⵊⵎⴻⵏ, ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⴻⴱⵔⵓⵔⵔⵉ. ⴰⴷ ⵜⴻⵛⵛ ⵜⵎⵓⵖⵔⵉ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵖⴻⵎⵎⵢⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX10_6","003_10_6","EXO","10","6","6","ⵓⵛⴰ ⴰⴷ ⵛⵛⵓⵔⴻⵏⵜ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⵜ ⵥⵔⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵡⴰⵙⵙ-ⴰ.’” ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵏⴻⵜⵜⴰ, ⵉⵙⵎⴻⵃ ⴷⵉ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX10_7","003_10_7","EXO","10","7","7","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ: “ⴰⵍ ⵎⴻⵍⵎⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵢⵉⵍⵉ ⵡⴰⵏⵉⵜⴰ ⴷ ⵍⴼⴻⵅ? ⴻⵊⵊ ⴰⴷ ⵔⴰⵃⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ! ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵄⴰⴷ ⴱⴻⵍⵍⵉ ⵎⵉⵚⵔⴰ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ?” ");
INSERT INTO rift_vpl VALUES ("EX10_8","003_10_8","EXO","10","8","8","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⵙⵉⵡⴹⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵄⴻⴱⴷⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ⵉⵏⵉ ⴰⵢⵉ, ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("EX10_9","003_10_9","EXO","10","9","9","ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴰⴷ ⵏⵔⴰⵃ ⴰⴽ-ⴷ ⵉⵃⵔⴰⵎⴻⵏ ⵏⵏⴻⵖ ⴷ ⵉⵡⴻⵙⵙⵓⵔⴰ ⵏⵏⴻⵖ, ⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵖ, ⵙ ⵡⵓⴵⵉ ⵏⵏⴻⵖ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⵏⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX10_10","003_10_10","EXO","10","10","10","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⴰⵟⵟⴰⵚ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵍⴰ ⴰⴷ ⵊⵊⴻⵖ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵡⴻⵎ. ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⵡⵉⵎ ⵍⵖⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("EX10_11","003_10_11","EXO","10","11","11","ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵎⴻⵏⵏⵉ. ⵊⵊⴻⵎ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ.” ⵓⵛⴰ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙⴻⵏ ⵣⵉ ⵇⵉⴱⴰⵍⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX10_12","003_10_12","EXO","10","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⵜⴰⵎⵓⵔⵖⵉ ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵛⵛ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵅ ⵜⴻⴱⵔⵓⵔⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX10_13","003_10_13","EXO","10","13","13","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵎⵓⵙⴰ ⵖⴰⵔ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵓⴹ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵛⴰⵔⵇ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵙⵙ ⵏⵏⵉ ⴷ ⵎⴰⵔⵔⴰ ⴵⵉⵍⴻⵜ ⵏⵏⵉ. ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵢⵉⵡⵉ-ⴷⴷ ⵓⵙⴻⵎⵎⵉⴹ ⵜⴰⵎⵓⵔⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("EX10_14","003_10_14","EXO","10","14","14","ⵜⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵜⵎⵓⵔⵖⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵜⵚⴻⵢⵢⴻⵃ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵎⵉⵚⵔⴰ. ⴰⵇⴰ ⵜⵓⵖⴰ ⵍⵃⴰⵍ ⵢⴻⵡⵄⴰⵔ ⴰⵟⵟⴰⵙ. ⵜⴰⵎⵓⵔⵖⵉ ⴰⵎ ⵜⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵜⵜ ⵜⵓⵖⵉ ⵇⴱⴻⵍ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX10_15","003_10_15","EXO","10","15","15","ⴰⵇⴰ ⴷⵍⵉⵏⵜ ⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵍⴰⵎⵉ ⵜⴻⵙⵙⵓⵜⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⵉⵜⴻⵏⵜⵉ ⵛⵛⵉⵏⵜ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴻⴱⵔⵓⵔⵔⵉ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵣⵣⵉⵣⴻⵡⵜ ⴷⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏⵉⵖ ⴷⴻⴳ ⵡⴻⴼⵙⵓ ⵏ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX10_16","003_10_16","EXO","10","16","16","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴼⵉⵔⵄⵓⵏ ⴷⴻⵖⵢⴰ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵅⴹⵉⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵍⴰ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX10_17","003_10_17","EXO","10","17","17","ⵜⵜⵣⴰⵡⴳⴻⵖ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵢⵉ ⵜⵙⴰⵎⵃⴻⵎ ⵅ ⵓⵅⴻⵟⵟⵓ ⵉⵏⵓ ⵜⵡⴰⵍⴰ-ⵢⴰ. ⵥⴰⴵⴻⵎ ⵙ ⵍⴰⴵⴰⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⴽⴽⴻⵙ ⵍⵎⴻⵡⵜ-ⴰ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX10_18","003_10_18","EXO","10","18","18","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵅ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵙ ⵍⴰⴵⴰⵖ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX10_19","003_10_19","EXO","10","19","19","ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵓⵙⴻⵎⵎⵉⴹ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵛⴰⵔⵇ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⵉⵙⵙⵊⴻⵀⴷ ⵉ-ⵜ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵜⴰⵎⵓⵔⵖⵉ, ⵉⵏⴹⴰⵔ ⵉ-ⵜⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⵓⵔⵖⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX10_20","003_10_20","EXO","10","20","20","ⵎⴰⵛⴰ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵙⵉⴷⵉ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵎⵉ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵔⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX10_21","003_10_21","EXO","10","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⴵⴻⵙⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍ ⵖⴰ ⵜⴰⴼⴻⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵃⴰⴷⵉⴷ ⵜⴰⴵⴻⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX10_22","003_10_22","EXO","10","22","22","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵎⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵜⴻⵊⵀⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("EX10_23","003_10_23","EXO","10","23","23","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵡⵉⵍⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴽⴽⴰⵔ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵜⴰⴼⴰⵡⵜ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX10_24","003_10_24","EXO","10","24","24","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴼⵉⵔⵄⵓⵏ ⵉ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵔⵓⵃⴻⵎ, ⵜⵄⴻⴱⴷⴻⵎ ⵙⵉⴷⵉ! ⵊⵊⴻⵎ ⵡⴰⵀⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵡⵓⴵⵉ ⵏⵡⴻⵎ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵡⴻⵎ. ⵎⴰⵛⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX10_25","003_10_25","EXO","10","25","25","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵎⵓⵙⴰ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⵄⴰⵡⴻⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵛⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵓⵍⴰ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ. ⴰⴷ ⵜⴻⵏⵜ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ ⴷ ⵜⵖⴰⵔⵚⵟ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX10_26","003_10_26","EXO","10","26","26","ⵓⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵔⴰⵃⴻⵏⵜ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵛⴻⴽⵔⵓⴷ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉ ⵖⴰ ⵏⴻⴽⵙⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵄⴱⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵙ ⵎⵉⵏⵣⵉ ⵖⴰ ⵏⴻⵄⴱⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵍ ⴷⵉⵏ ⵖⴰ ⵏⴰⵡⴻⴹ.” ");
INSERT INTO rift_vpl VALUES ("EX10_27","003_10_27","EXO","10","27","27","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵢⵓⴳⵉ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴰⴷ ⵔⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX10_28","003_10_28","EXO","10","28","28","ⵉⵏⵏⴰ ⴰⵙ ⴼⵉⵔⵄⵓⵏ: “ⴰⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ! ⵃⴹⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⴷ ⵄⴰⴷ ⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ ⵉ ⴷⵉ ⵖⴰ ⵜⵥⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("EX10_29","003_10_29","EXO","10","29","29","ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵏⵏⵉⴷ: ⵡⴰⵔ ⵥⴰⵔⵔⴻⵖ ⵄⴰⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("EX11_1","003_11_1","EXO","11","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⴷ ⵍⴻⵇⴼⴻⵖ ⵄⴰⴷ ⵎⵖⵉⵔ ⵙ ⵢⵉⵛⵜⴻⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵅ ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⵉⵚⵔⴰ. ⴰⵡⴰⵔⵏⵉ ⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⴽⴽ ⵙⵙⴰ. ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵢⴻⵊⵊ ⴰⴷ ⵜⵔⵓⵃⴻⵎ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⴰⵥⵥⴻⵍ ⵙⵙⴰ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EX11_2","003_11_2","EXO","11","2","2","ⵙⵉⵡⴻⵍ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⴰⵔ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⴻⴳ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵜⴰⵊⵊⴰⵔⵜ ⵏⵏⴻⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EX11_3","003_11_3","EXO","11","3","3","ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙ ⵉ ⵍⴳⴻⵏⵙ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⴷ ⵉⵊⵊ ⵡⴻⵔⵢⴰⵣ ⵙ ⵛⵛⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX11_4","003_11_4","EXO","11","4","4","ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵏⴻⵛⵛ ⴰⴷ ⵄⴷⵓⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵎⵉⵚⵔⴰ ");
INSERT INTO rift_vpl VALUES ("EX11_5","003_11_5","EXO","11","5","5","ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⴻⴳ ⵓⵎⴻⵏⵣⵓ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ, ⴰⵍ ⴰⵎⴻⵏⵣⵓ ⵏ ⵜⴰⵢⵢⴰ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵙⵉⵔⵜ ⵜⵃⴰⵔⵔⵉ ⵉⵎⴻⵏⴷⵉ, ⵓⵍⴰ ⴷ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX11_6","003_11_6","EXO","11","6","6","ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵏⵉⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EX11_7","003_11_7","EXO","11","7","7","ⵎⴰⵛⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵉⵜⵜⵥⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵇⵣⵉⵏ ⵅ ⵉⵡⴷⴰⵏ ⵓⵍⴰ ⵅ ⵍⵎⴰⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵜⵜⴻⴳⴳ ⵍⴼⴰⵔⵣ ⵊⴰⵔ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵙⵔⴰⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("EX11_8","003_11_8","EXO","11","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵀⵡⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵢⵉ ⴱⴻⵏⴷⵇⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴼⴼⴻⵖ ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵛⴻⴽ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵛ!’ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⴼⴼⵖⴻⵖ.’” ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵅ ⴼⵉⵔⵄⵓⵏ, ⵜⴻⴽⴽⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵙⵙⵉ ⵙ ⵓⵅⴻⵢⵢⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("EX11_9","003_11_9","EXO","11","9","9","ⴰⵇⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴼⵉⵔⵄⵓⵏ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵖⴰⵔⴻⵏⵜ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉⵏⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX11_10","003_11_10","EXO","11","10","10","ⴰⵇⴰ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_1","003_12_1","EXO","12","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX12_2","003_12_2","EXO","12","2","2","“ⴰⵢⵓⵔ-ⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵢⵓⵔⴻⵏ. ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⵡⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_3","003_12_3","EXO","12","3","3","ⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⴰⴷ ⵉⴽⵙⵉ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⴻⴳ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ ⵅ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX12_4","003_12_4","EXO","12","4","4","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵔⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵓⵖⴰ ⵉⵎⵥⵉ ⵉ ⵢⴻⵣⵎⴰⵔ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⴽ-ⴷ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵢⵓⴷⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵡⴷⴰⵏ. ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⴻⵣⵎⴰⵔ ⴰⴷ ⵜⴻⵡⵜⴻⵎ ⵍⴻⵃⵙⴰⴱ ⵉ ⵎⵉⵏ ⵖⴰ ⵢⴻⵛⵛ ⴽⵓⵍ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_5","003_12_5","EXO","12","5","5","ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵣⵎⴰⵔ ⵉⵛⵏⴰⵏ ⵇⴰⵄ, ⴰⵡⵜⴻⵎ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⵎ ⵣⴻⴳ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_6","003_12_6","EXO","12","6","6","ⴰⴷ ⵜ ⵜⵅⴻⵎⵎⵍⴻⵎ ⴰⵍ ⴰⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵣⴻⴳ ⵓⵢⵓⵔ-ⴰ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EX12_7","003_12_7","EXO","12","7","7","ⴰⴷ ⴽⵙⵉⵏ ⵛⴰ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴹⵔⵓⴼ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⵓⴷⵔⵉⵏ ⵎⴰⵏⵉ ⵜ ⵖⴰ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_8","003_12_8","EXO","12","8","8","ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ, ⴰⵢⵙⵓⵎ ⵉⵛⴻⵏⵏⴼⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵙ ⵍⴻⴱⵣⴰⵔ ⵢⴰⵔⵣⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("EX12_9","003_12_9","EXO","12","9","9","ⵡⴰⵔ ⵜ ⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ ⴷ ⴰⵣⵉⵣⴰ ⵏⵉⵖ ⵢⴻⵏⵡⴰⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⴻⴼ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⴽ-ⴷ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵡⴰⴷⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_10","003_12_10","EXO","12","10","10","ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⵊⵊⵉⵎ ⵡⴰⵍⵓ ⵖⴰⵔ ⵚⵚⴱⴻⵃ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵚⵚⴱⴻⵃ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜ ⵜⵛⴻⵎⴹⴻⵎ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EX12_11","003_12_11","EXO","12","11","11","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⵛⵛⴻⵎ: ⵜⴰⵊⵄⵉⵏⵏⴰ ⵏⵡⴻⵎ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴱⵢⴻⵙ, ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵡⴻⵎ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵓ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵡⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴻⵛⵛⴻⵎ ⴷⴻⵖⵢⴰ. ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX12_12","003_12_12","EXO","12","12","12","ⵎⵉⵏⵣⵉ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵄⴷⵓⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⴷ ⵡⵜⴻⵖ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵎⵎⵓ ⴷⴻⴳ ⵉⵡⴷⴰⵏ ⵓⵍⴰ ⴷⵉ ⵍⵎⴰⵍ, ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵏⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵎⵉⵚⵔⴰ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("EX12_13","003_12_13","EXO","12","13","13","ⵓⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵅ ⵜⵓⴷⵔⵉⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ. ⵎⴰⵍⴰ ⵥⵔⵉⵖ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵄⴷⵓⵖ. ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵉⵏⴻⵇⵇⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵅⵎⵉ ⵖⴰ ⵡⵜⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX12_14","003_12_14","EXO","12","14","14","ⴰⵙⵙ-ⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵄⴻⵢⵢⴷⴻⵎ ⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵄⴻⵢⵢⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX12_15","003_12_15","EXO","12","15","15","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⴰⵏⵜⵓⵏ ⵣⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵛⴰ ⵙ ⵡⴻⵏⵜⵓⵏ, ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵍ ⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX12_16","003_12_16","EXO","12","16","16","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵛⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ⵎⵖⵉⵔ ⵎⵉⵏ ⵖⴰ ⵢⴻⵛⵛ ⴽⵓⵍ ⵉⵊⵊ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵀⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX12_17","003_12_17","EXO","12","17","17","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵇⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⴰⵙⵙ-ⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX12_18","003_12_18","EXO","12","18","18","ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ, ⴷⵉ ⴵⵉⵍⴻⵜ, ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴰⵍ ⴵⵉⵍⴻⵜ ⵏ ⵡⴰⵙⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵣⴻⴳ ⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EX12_19","003_12_19","EXO","12","19","19","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼⴼⵉ ⵡⴻⵏⵜⵓⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙ ⵡⴻⵏⵜⵓⵏ, ⵎⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵉⵖ ⴷ ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX12_20","003_12_20","EXO","12","20","20","ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵡⴰⵍⵓ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙ ⵡⴻⵏⵜⵓⵏ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⴷⴷⴰⵖ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EX12_21","003_12_21","EXO","12","21","21","ⵉⵍⴰⵖⴰ ⵎⵓⵙⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵟⵟⴼⴻⵎ, ⴽⵙⵉⵎ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵉ ⵍⴰⴵⴰⵜ ⵏⵡⴻⵎ ⵓ ⵖⴰⵔⵚⴻⵎ ⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("EX12_22","003_12_22","EXO","12","22","22","ⵟⵟⴼⴻⵎ ⵉⵛⵜ ⵏ ⵜⵇⴻⴱⴱⵉⴹⵜ ⵏ ⵜⵄⴻⵍⴵⴻⵜ, ⵙⵖⴻⴹⵙⴻⵎ ⵜⵜ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵟⵟⴻⴱⵚⵉ, ⵖⴻⵎⵙⴻⵏ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵟⵟⴻⴱⵚⵉ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵓ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ⴰⵍ ⵚⵚⴱⴻⵃ ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_23","003_12_23","EXO","12","23","23","ⵙⵉⴷⵉ ⴰⴷ ⵉⵥⵡⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵡⴻⵜ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵅⵎⵉ ⵖⴰ ⵉⵥⴰⵔ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵏⵏⴻⵊ ⵓ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵄⴷⵓ ⵙⵉⴷⵉ ⵜⴰⵡⵡⴰⵔⵜ ⵏⵏⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⵎⵜⴻⵃⵃⴰⵢ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX12_24","003_12_24","EXO","12","24","24","ⵃⴹⴰⵎ ⴰⵡⴰⵍ-ⴰ ⵉ ⵏⵏⵉⵖ, ⴰⵇⴰ ⴷ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX12_25","003_12_25","EXO","12","25","25","ⴰⴷ ⵢⵉⵍⵉ, ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵢⴻⵡⵛ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ, ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⴰⵄⴱⴰⴷ-ⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX12_26","003_12_26","EXO","12","26","26","ⵓⵛⴰ ⵅ ⵎⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵏⵉⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ: ‘ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵡⴻⵄⴱⴰⴷ-ⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴽⴻⵏⵏⵉⵡ?’, ");
INSERT INTO rift_vpl VALUES ("EX12_27","003_12_27","EXO","12","27","27","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⵄⴷⵓⵏ ⵅ ⵜⵓⴷⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵓⵎⵉ ⵉⵡⵜⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴼⴻⴽⴽ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ.’” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⴹⴰⵔ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX12_28","003_12_28","EXO","12","28","28","ⵔⵓⵃⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓ ⴰⵎⵎⵓ ⵉ ⵜⵜ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_29","003_12_29","EXO","12","29","29","ⵜⵓⵖⴰ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵓⵎⵉ ⵉⵡⵜⴰ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵍⵎⴻⵡⵜ, ⵣⴻⴳ ⵓⵎⴻⵏⵣⵓ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⴰⵍ ⴰⵎⴻⵏⵣⵓ ⵏ ⵓⵎⴻⵃⴱⵓⵙ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ.    ");
INSERT INTO rift_vpl VALUES ("EX12_30","003_12_30","EXO","12","30","30","ⵉⴽⴽⴰⵔ ⴼⵉⵔⵄⵓⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴻⵎⵖⴰⵔ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⵓⵎⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_31","003_12_31","EXO","12","31","31","ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵙ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔⴻⵎ, ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴽⴻⵏⵏⵉⵡ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵔⵓⵃⴻⵎ, ⵜⵄⴻⴱⴷⴻⵎ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⴰⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("EX12_32","003_12_32","EXO","12","32","32","ⴰⵡⵢⴻⵎ ⵓⴵⵉ ⵏⵡⴻⵎ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⴰⵎ. ⵔⵓⵃⴻⵎ, ⵎⴰⵛⴰ ⵜⵜⵣⴰⵡⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴱⴰⵔⴽⴻⵎ ⴰⵢⵉ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("EX12_33","003_12_33","EXO","12","33","33","ⵣⴻⵢⵢⴰⵔⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⵙ ⵓⵇⴻⴵⴻⵇ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⴻⵜⵜⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("EX12_34","003_12_34","EXO","12","34","34","ⵓⵛⴰ ⵢⵉⵡⵉ ⵍⴳⴻⵏⵙ ⴰⵔⴻⵛⵜⵉ ⵏⵏⴻⵙ ⵇⴱⴻⵍ ⵎⴰ ⵖⴰ ⵉⵏⴹⵓ ⵓⵛⴰ ⵜⵉⴱⴻⵇⵢⵉⵏ ⵏⵏⴹⴻⵏ ⵜⴻⵏⵜ ⵊⴰⵔ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵅ ⵟⵖⴰⵔⴹⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_35","003_12_35","EXO","12","35","35","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵎⵓⵙⴰ, ⵜⵜⴰⵔⴻⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵔⵔⵓⴹ ⵣⴻⴳ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_36","003_12_36","EXO","12","36","36","ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵍⴳⴻⵏⵙ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵎⵉⵏ ⵜⵜⴰⵔⴻⵏ, ⵓ ⴰⵎⵎⵓ ⵉ ⴽⴻⵛⵛⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_37","003_12_37","EXO","12","37","37","ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵔⴰⵄⴰⵎⵙⵉⵙ ⵖⴰⵔ ⵙⵓⴽⴽⵓⵜ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵄⵍⴰⵃⴰⵍ ⴷⵉ ⵙⴻⵜⵜⴰ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵡⴰⵀⴰ, ⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_38","003_12_38","EXO","12","38","38","ⵉⴳⴻⵄⵄⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵡⴷⴰⵏ, ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_39","003_12_39","EXO","12","39","39","ⵙ ⵡⴰⵔⴻⵛⵜⵉ ⵉ ⴽⵉⴷⵙⴻⵏ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⴳⴳⵯⵉⵏ ⵜⵉⴼⴹⵉⵔⵉⵏ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵉⵙⵎⵉⵎ, ⵎⵉⵏⵣⵉ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙⴻⵏ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ ⵓ ⵡⴰⵔ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵎⴰⵛⵛⴰ ⵉ ⵡⴻⴱⵔⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_40","003_12_40","EXO","12","40","40","ⵜⵓⵖⴰ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵍⵎⵉⵊⴰⵔ ⵉ ⴷⵉⵏ ⵉⵣⴻⴷⵖⴻⵏ, ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX12_41","003_12_41","EXO","12","41","41","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX12_42","003_12_42","EXO","12","42","42","ⵜⴰⵏⵉⵜⴰ ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⴵⵉⵔⴻⵜ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴹⴰ ⵉ ⵍⴻⵡⵇⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⴵⵉⵍⴻⵜ-ⴰ ⵜⴰⵏⵉⵜⴰ, ⴰⵇⴰ-ⵜⵜ ⵉ ⵙⵉⴷⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴷⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_43","003_12_43","EXO","12","43","43","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ: “ⴷ ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ: ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⵜⵜ ⵎⵎⵉⵙ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EX12_44","003_12_44","EXO","12","44","44","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵙⵎⴻⵖ ⵉⵎⵎⴻⵙⵖⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵏⵏⵓⵇⴰⵔⵜ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ, ⵎⴰⵍⴰ ⵜⵅⴻⵜⵏⴻⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_45","003_12_45","EXO","12","45","45","ⴰⵎⵄⴻⵣⵣⴻⴱ ⴷ ⵓⵛⴻⵡⵡⴰⵍ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EX12_46","003_12_46","EXO","12","46","46","ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵉⵛⵜ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵡⴰⵍⵓ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵢⵉⵖⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX12_47","003_12_47","EXO","12","47","47","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⴳⴳ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX12_48","003_12_48","EXO","12","48","48","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵉⵏⵏⴻⵡⵊⴻⵡ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵓⵛⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ, ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵅⵜⵉⵏⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("EX12_49","003_12_49","EXO","12","49","49","ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX12_50","003_12_50","EXO","12","50","50","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵜⵜ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX12_51","003_12_51","EXO","12","51","51","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵙⵉⴷⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX13_1","003_13_1","EXO","13","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX13_2","003_13_2","EXO","13","2","2","“ⵙⵇⴻⴷⴷⴻⵙ ⴰⵢⵉ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⵎ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⴰⵎ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ. ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("EX13_3","003_13_3","EXO","13","3","3","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵉⴷⴰⵔⴻⵎ ⴰⵙⵙ-ⴰ ⵎⵉⵏ ⴷⵉ ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵣⴰⵢⴻⵙ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵡⴰⵍⵓ ⵎⵉⵏ ⴷⵉ ⵉⴵⴰ ⵡⴻⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX13_4","003_13_4","EXO","13","4","4","ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⴰⴱⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("EX13_5","003_13_5","EXO","13","5","5","ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵉⴷⴻⴼ ⵉ ⵛⴻⴽ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵅ ⵜⴻⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⴷ ⴰⵛ ⵜⵜ ⵉⵡⵛ, ⵜⴰⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⴰⵄⴱⴰⴷ-ⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴻⴳ ⵓⵢⵓⵔ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("EX13_6","003_13_6","EXO","13","6","6","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX13_7","003_13_7","EXO","13","7","7","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵡⵉⴼⴼⵉ ⵎⵉⵏ ⵉⵅⴻⵎⵎⵔⴻⵏ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼⵉ ⵡⴻⵏⵜⵓⵏ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("EX13_8","003_13_8","EXO","13","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⵃⴰⵊⵉⴷ ⵉ ⵎⵎⵉⵛ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ: ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX13_9","003_13_9","EXO","13","9","9","ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵢⵢⴰⵔ ⵅ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX13_10","003_13_10","EXO","13","10","10","ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵜⴻⵃⴹⵉⴷ ⵜⴰⵡⵙⵉⵢⵢⴻⵜ-ⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX13_11","003_13_11","EXO","13","11","11","ⴰⴷ ⵢⵉⵍⵉ ⵅⵎⵉ ⵛⴻⴽ ⵖⴰ ⵉⵙⵙⵉⴷⴻⴼ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵉⵊⵊⵓⴵ ⵓⵍⴰ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵛ ⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("EX13_12","003_13_12","EXO","13","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⴻⵄⴷⵓⴷ ⵖⴰⵔ ⵙⵉⴷⵉ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵍⴰ ⴷ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ: ⵉⵡⴻⵜⵎⴰⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX13_13","003_13_13","EXO","13","13","13","ⵎⴰⵛⴰ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⵍⴻⵜ ⵏ ⵡⴻⵖⵢⵓⵍ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⴷ ⵜ ⵜⴻⴼⴷⵉⴷ ⵙ ⵢⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵜ ⵜⴻⴼⴷⵉⴷ, ⴰⴷ ⴰⵙ ⵜⴰⵔⵥⴻⴷ ⵉⵔⵉ. ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵜⴻⴼⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("EX13_14","003_13_14","EXO","13","14","14","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵅⵎⵉ ⵛⴻⴽ ⵖⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵎⵎⵉⵛ ⵜⵉⵡⴻⵛⵛⴰ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵏⴰⵡⵢⴰ?’, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ: ‘ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⵓⵖ ⴰⵏⴻⵖ-ⴷⴷ ⵙⵉⴷⵉ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("EX13_15","003_13_15","EXO","13","15","15","ⵍⴰⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⴱⴻⴷⴷ ⴼⵉⵔⵄⵓⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵡⵓⴼⴼⵓⵖ ⵏⵏⴻⵖ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⴻⴳ ⵓⵎⴻⵏⵣⵓ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵍ ⴰⵎⴻⵏⵣⵓ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ. ⵅ ⵓⵢⴰ ⵇⴻⴷⴷⵎⴻⵖ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵜⴰⵖⵔⴰⵚⵜ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵜ ⴼⴷⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("EX13_16","003_13_16","EXO","13","16","16","ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵢⵢⴰⵔ ⵅ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵓⵙⴻⴳⴳⴻⵎ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵏⴻⵖ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EX13_17","003_13_17","EXO","13","17","17","ⵓⵎⵉ ⵉⵊⵊⴰ ⴼⵉⵔⵄⵓⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵔⴰⵃ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⴷⵉⵀ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⴷⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ: “ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⴻⵏⴷⴻⵎⵎⵉ ⵍⴳⴻⵏⵙ ⵅⵎⵉ ⵖⴰ ⵉⵥⴰⵔ ⵍⴱⴰⵔⵓⴹ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX13_18","003_13_18","EXO","13","18","18","ⵉⵏⴷⴻⵀ ⴰⵔⴻⴱⴱⵉ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴽ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⵍⴰ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ ⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("EX13_19","003_13_19","EXO","13","19","19","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵖⵙⴰⵏ ⵏ ⵢⵓⵙⵓⴼ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵊⵓⴵ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵉⵛⵜ ⵏ ⵜⵥⴰⴵⵉⵜ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵢⴰⵔⵣⴻⴼ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵙⵙⴰ ⴰⴽⵉⴷⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("EX13_20","003_13_20","EXO","13","20","20","ⵓⵛⴰ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵙⵓⴽⴽⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵉⵜⴰⵎ, ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EX13_21","003_13_21","EXO","13","21","21","ⵙⵉⴷⵉ ⵉⵣⵡⴰⵔ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵥⵉⵍ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⴳⴻⵡⵡⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⴳⴳ ⵜⴰⴼⴰⵡⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴼ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX13_22","003_13_22","EXO","13","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⴰⵔ ⴷⴷ-ⵉⴽⴽⵉⵙ ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵍⴳⴻⵏⵙ ⵓⵍⴰ ⴷⵉ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⴷⴷ-ⵉⴽⴽⵉⵙ ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EX14_1","003_14_1","EXO","14","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX14_2","003_14_2","EXO","14","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⴼⵉ-ⵀⴰⵅⵉⵔⵓⵜ, ⵊⴰⵔ ⵎⵉⴳⴷⵓⵍ ⴷ ⵍⴻⴱⵃⴰⵔ, ⵇⵉⴱⴰⵍⵜ ⵉ ⴱⴰⵄⴰⵍ-ⵚⴰⴼⵓⵏ. ⴰⵔⴻⵏⴷⴰⴷ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵡⵜⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX14_3","003_14_3","EXO","14","3","3","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⴼⵉⵔⵄⵓⵏ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴻⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵍⴻⵅⵍⴰ ⵉⵃⵚⴰⵔ ⵉ-ⵜⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EX14_4","003_14_4","EXO","14","4","4","ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵇⴻⵙⵃⴻⵖ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⴹⴼⴰⵔ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⵉⵖ ⵅ ⴼⵉⵔⵄⵓⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⵜ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX14_5","003_14_5","EXO","14","5","5","ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴹ ⵏ ⵎⵉⵚⵔⴰ ⴱⴻⵍⵍⵉ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵡⴻⵍ. ⵅⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵍ ⵡⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵏⴻⴳⴳⴰ ⴰⵢⴰ, ⵏⴻⵙⵙⴻⴽⴽ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵉ ⵉⴳⴳⵉⵏ ⵉ ⵏⴻⵛⵛⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("EX14_6","003_14_6","EXO","14","6","6","ⵓⵛⴰ ⵉⵃⴻⵣⵣⴻⵎ ⴼⵉⵔⵄⵓⵏ ⴰⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ, ⵉⴽⵙⵉ ⴰⴽⵉⴷⴻⵙ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX14_7","003_14_7","EXO","14","7","7","ⵉⴽⵙⵉ ⴰⴽⵉⴷⴻⵙ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵛⴻⵡⵡⴰⵔ ⵏ ⵉⵏⴻⵖⵔⴰⴼⴻⵏ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_8","003_14_8","EXO","14","8","8","ⴰⵇⴰ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵙⵉⴷⵉ ⵓⵍ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵢⴰⵔⴷⴻⴼ ⵏⴻⵜⵜⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴼⴼⵖⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_9","003_14_9","EXO","14","9","9","ⴰⵔⴻⴷⴼⴻⵏ ⵜⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵖⴰⵔ ⴼⵉ-ⵀⴰⵅⴰⵔⵓⵜ, ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⴱⴰⵄⴰⵍ-ⵚⴰⴼⵓⵏ, ⵎⴰⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX14_10","003_14_10","EXO","14","10","10","ⵍⴰⵎⵉ ⵜⴻⵏ ⴷⴷ-ⵢⵓⴷⴻⵙ ⴼⵉⵔⵄⵓⵏ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵙⴻⵏ, ⵥⵔⵉⵏ ⴱⴻⵍⵍⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ-ⴷⴷ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ. ⵅⴻⵏⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX14_11","003_14_11","EXO","14","11","11","ⵏⵏⴰⵏ ⵉ ⵎⵓⵙⴰ: “ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵄⴰⴷ ⵉⵎⴻⴹⵍⴰⵏ ⴷⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵎⵎⴻⵜ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ? ⵎⴰⵖⴰⵔ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵎⵓ, ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵏⴻⵖ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("EX14_12","003_14_12","EXO","14","12","12","ⵎⴰ ⵡⴰⵔ ⴽⵉⴷⴻⴽ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵏⴻⵏⵏⴰ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵅⴷⴻⵎ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ’? ⵅⴰⵔ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵏⴻⵇⵇⵉⵎ ⵏⴻⵅⴷⴻⵎ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵅ ⵎⴰⵍⴰ ⵏⴻⵎⵎⵓⵜ ⴷⵉ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX14_13","003_14_13","EXO","14","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ, ⴱⴻⴷⴷⴻⵎ, ⵜⴻⵅⵣⴰⵔⴻⵎ ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵢⴻⵡⵛ ⴰⵙⵙ-ⴰ, ⵎⵉⵏⵣⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴰⵙⵙ-ⴰ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⴻⵏ ⵜⵥⴰⵔⴻⵎ ⵄⴰⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX14_14","003_14_14","EXO","14","14","14","ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵎⵎⵏⴻⵖ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵙⴻⵖⴷⴻⵎ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX14_15","003_14_15","EXO","14","15","15","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰⵔⵉ ⵜᵉⵜⵜⵍⴰⵖⵉⴷ? ⵉⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_16","003_14_16","EXO","14","16","16","ⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ, ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⴼⴰⵔⵇ ⵉ-ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵡⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵍⴱⴰⵔⵔ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX14_17","003_14_17","EXO","14","17","17","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵇⴻⵙⵃⴻⵖ ⵓⵍ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴼⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵄⵓⴵⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵙ ⴼⵉⵔⵄⵓⵏ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵏ ⵉⵢⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_18","003_14_18","EXO","14","18","18","ⴰⴷ ⵙⵙⵏⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⵉⵖ ⵙ ⴼⵉⵔⵄⵓⵏ, ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵏ ⵉⵢⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX14_19","003_14_19","EXO","14","19","19","ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵟⵟⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵙⴻⵏ: ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⵎⵎⵓⵟⵟⵉ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_20","003_14_20","EXO","14","20","20","ⵢⵓⴷⴻⴼ ⵓⵇⴻⵍⵍⵉⵊ ⵊⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵜⵓⵖⴰ ⴰⵙⴻⵢⵏⵓ ⴷ ⵜⴰⴵⴻⵙⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵉⵙⵙⵉⵖ ⵉ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵙ ⴵⵉⵍⴻⵜ ⵓ ⵡⴰⵔ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX14_21","003_14_21","EXO","14","21","21","ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵎⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⵄⴰⵔⵏ ⵙⵉⴷⵉ ⵅⴻⵏⵏⵉ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⴷ ⴰⵛⴰⵔⵇⵉ ⵉⵊⵀⴻⴷ, ⵎⴰⵔⵔⴰ ⴵⵉⵍⴻⵜ ⵏⵏⵉ, ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⵉⵊⴻⴼⴼⴻⴼ. ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⵎⵎⵙⴻⴱⴹⴰⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_22","003_14_22","EXO","14","22","22","ⵓⵢⵓⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵎⵉⵏ ⵢⵓⵥⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⴰⵎⴰⵏ ⴳⴳⵉⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵍⵃⵉⴹ ⵅ ⵢⴻⴼⵓⵙ ⵏⵙⴻⵏ ⴷ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_23","003_14_23","EXO","14","23","23","ⴰⵔⴻⴷⴼⴻⵏ ⵜⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵔⵓⵃⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ ⵙ ⵎⴰⵔⵔⴰ ⵉⵢⵙⴰⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵏ ⵢⵉⵢⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_24","003_14_24","EXO","14","24","24","ⵍⴰⵎⵉ ⴷ ⵢⴻⴼⴼⵓ ⵍⵃⴰⵍ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵚⵡⴻⴹ ⵖⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵅⴰⵔⵡⴻⴹ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX14_25","003_14_25","EXO","14","25","25","ⵉⵊⵊⴰ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴼⴻⵙⵅⴻⵏⵜ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵉⵡⵄⴰⵔ ⵅⴰⵙⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX14_26","003_14_26","EXO","14","26","26","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵍⴻⴱⵃⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵡⴰⵎⴰⵏ ⵅ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵅ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵓ ⵅ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵙⴻⵏ ⵏ ⵉⵢⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX14_27","003_14_27","EXO","14","27","27","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵎⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⴻⴱⵃⴰⵔ ⵓ ⵖⴰⵔ ⵍⴻⴼⵊⴰⵔ ⵏ ⵚⵚⴱⴻⵃ ⵉⴷⵡⴻⵍ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵏⵉⵛⴰⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵖⴹⴻⵍ ⵙⵉⴷⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX14_28","003_14_28","EXO","14","28","28","ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵏⴻⴹⵍⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴼⵉⵔⵄⵓⵏ ⵉ ⵜⵓⵖⴰ ⵢⵓⴷⴻⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_29","003_14_29","EXO","14","29","29","ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵢⵓⵔⴻⵏ ⵅ ⵎⵉⵏ ⵢⵓⵥⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓ ⴰⵎⴰⵏ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵍⵃⵉⴹ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏⵙⴻⵏ ⴷ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX14_30","003_14_30","EXO","14","30","30","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵙⵉⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵥⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX14_31","003_14_31","EXO","14","31","31","ⵉⵥⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴼⵓⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⴻⴳ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴳⴳⵯⴻⴷ ⵍⴳⴻⵏⵙ ⵣⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵓⵎⵏⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵙⵉⴷⵉ ⵓ ⴷⵉ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX15_1","003_15_1","EXO","15","1","1","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵣⴻⵀⵀⴻⴷ ⵎⵓⵙⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵀⵉⴷ-ⴰ ⵉ ⵙⵉⴷⵉ, ⵏⵏⴰⵏ: “ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⵓⵄⵍⴰ ⴷⵉ ⵍⵓⵄⵍⴰ! ⴰⵢⵉⵙ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵢⴻⵏⵢⵉⵏ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX15_2","003_15_2","EXO","15","2","2","ⵙⵉⴷⵉ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴷ ⴰⵣⴻⵀⵀⴻⴷ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ⵡⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⵄⵓⴵⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("EX15_3","003_15_3","EXO","15","3","3","ⵙⵉⴷⵉ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵙⵉⴷⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("EX15_4","003_15_4","EXO","15","4","4","ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓ ⴰⵛⴻⵡⵡⴰⵔ ⵏ ⵉⵏⴻⵖⵔⴰⴼⴻⵏ ⵏⵏⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔⵇⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("EX15_5","003_15_5","EXO","15","5","5","ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴷⵍⵉⵏ ⵉ-ⵜⴻⵏ. ⴰⵎⴻⵛⵏⴰⵡ ⴰⵥⵔⵓ, ⵀⵡⴰⵏ ⵖⴰⵔ ⵍⴰⴵⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("EX15_6","003_15_6","EXO","15","6","6","ⴰ ⵙⵉⴷⵉ, ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵄⴻⵣⵣ ⵙ ⵊⵊⴻⵀⴷ, ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵉⵍⴱⴻⵣ ⵍⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("EX15_7","003_15_7","EXO","15","7","7","ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ ⵜᵉⵜⴻⵃⵃⵉⴷ ⵉⵏⵏⵉ ⴽⵉⴽ ⵉⵜⵜⴻⵎⵄⴰⵍⴰⵏ. ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵏ ⵢⴻⵛⵛ ⵡⴰⵏⵉⵜⴰ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵖⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("EX15_8","003_15_8","EXO","15","8","8","ⵙ ⵓⵙⵓⴹⵉ ⵏ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵄⵓⵔⵔⵛⴻⵏ ⵡⴰⵎⴰⵏ, ⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⵙⴻⴵⵢⴰ ⴰⵎ ⵡⴻⵖⴱⴰⵔ, ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵊⴻⵎⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX15_9","003_15_9","EXO","15","9","9","ⵉⵏⵏⴰ ⵍⴻⵄⴷⵓ: ‘ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴼⴻⵖ, ⴰⴷ ⵜⴻⵏ ⵄⴷⵓⵖ, ⴰⴷ ⴱⴹⵉⵖ ⵍⵎⵓⵔ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵊⵊⵉⵡⴻⵏ, ⴰⴷ ⴷⴷ-ⵊⴻⴱⴷⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ, ⴰⴼⵓⵙ ⵉⵏⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴽⴽⴻⵙ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EX15_10","003_15_10","EXO","15","10","10","ⵜⵙⵓⴹⴻⴷ ⵙ ⵏⵏⴻⴼⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⵉⴷⴻⵍ ⵉ-ⵜⴻⵏ ⵍⴻⴱⵃⴰⵔ. ⵏⵉⵜⵏⵉ ⵀⵡⴰⵏ-ⴷⴷ ⴰⵎ ⵍⴻⵅⴼⵉⴼ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX15_11","003_15_11","EXO","15","11","11","ⴰ ⵙⵉⴷⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴰⵎ ⵛⴻⴽ ⵊⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ? ⵡⵉ ⵉⴵⴰⵏ ⴰⵎ ⵛⴻⴽ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵏ ⴷⵉ ⵜⵇⴻⴷⴷⴰⵙⵜ, ⴰⵎⵡⴻⵇⵇⴰⵔ ⴷⴻⴳ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴰⵎ ⵛⴻⴽ? ");
INSERT INTO rift_vpl VALUES ("EX15_12","003_15_12","EXO","15","12","12","ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ, ⵜⵙⴰⵔⴹ ⵉ-ⵜⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX15_13","003_15_13","EXO","15","13","13","ⵛⴻⴽ ⵜⴳⴻⵡⵡⴷⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ, ⴰⵇⴰ ⵜⴻⴼⴷⵉⴷ ⵜ, ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⵜⵏⴻⴷⵀⴻⴷ ⵜⴻⵏ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX15_14","003_15_14","EXO","15","14","14","ⵍⴻⴳⵏⵓⵙ ⵙⵍⵉⵏ ⵅ ⵓⵢⴰ ⵓⵛⴰ ⴰⵔⵊⵉⵊⴻⵏ. ⵜⴻⵟⵟⴻⴼ ⵜⴻⴳⴳⵯⵓⴷⵉ ⴷⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴼⵉⵍⵉⵛⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EX15_15","003_15_15","EXO","15","15","15","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⴷⵓⵎ ⵜⵜⴱⴻⵀⵜⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⴷⵉ ⵎⵓ’ⴰⴱ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴽⴻⵏⵄⴰⵏ ⴰⵇⴰ ⴼⴻⵙⵢⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EX15_16","003_15_16","EXO","15","16","16","ⵜⴻⵡⴹⴰ ⵅⴰⵙⴻⵏ ⵍⵄⵓⵔⵔⴻⵜ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ. ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵖⵉⵍ ⵏⵏⴻⵛ ⵙⴻⵖⴷⴻⵏ ⴰⵎ ⵡⴻⵥⵔⵓ, ⴰⵍⴰⵎⵉ ⵉⵥⵡⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⵍⴰⵎⵉ ⵉⵥⵡⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵉ ⵜⴽⴻⵙⴱⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX15_17","003_15_17","EXO","15","17","17","ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⵏⴻⴷⵀⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵥⵥⵓⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⵎⵛⴰⵏ ⵉ ⵜⴻⴳⴳⵉⴷ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX15_18","003_15_18","EXO","15","18","18","ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ! ");
INSERT INTO rift_vpl VALUES ("EX15_19","003_15_19","EXO","15","19","19","ⵎⵉⵏⵣⵉ ⴰⵢⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵇⵍⴻⴱ ⵅⴰⵙⴻⵏ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵥⵡⴰⵏ ⵅ ⵍⴰⵥⴰⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("EX15_20","003_15_20","EXO","15","20","20","ⵓ ⵎⴰⵔⵢⴰⵎ, ⵜⴰⵏⴰⴱⵉⵜ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵀⴰⵔⵓⵏ, ⵜⴻⴽⵙⵉ ⴰⴵⵓⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵟⵟⴰ ⴼⴼⵖⴻⵏⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵙ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ ⴷ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX15_21","003_15_21","EXO","15","21","21","ⵅⴻⵏⵏⵉ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵢⴰⵎ ⵙⵏⵏⵓⴱⴻⵜ ⵏⵏⴻⵙ: “ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵄⵍⴰⵏ ⴰⵟⵟⴰⵙ! ⵉⵏⴹⴰⵔ ⴰⵢⵉⵙ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵢⴻⵏⵢⵉⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("EX15_22","003_15_22","EXO","15","22","22","ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵎⵓⵙⴰ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⴼⵙⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ, ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵛⵓⵔ, ⵓⵢⵓⵔⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⴱⵍⴰ ⴰⴷ ⴰⴼⴻⵏ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX15_23","003_15_23","EXO","15","23","23","ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵎⴰⵔⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⴰⵎⴰⵏ ⵏ ⵎⴰⵔⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ⵅ ⵓⵢⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ‘ⵎⴰⵔⴰ’. ");
INSERT INTO rift_vpl VALUES ("EX15_24","003_15_24","EXO","15","24","24","ⵉⵏⵏⴻⴷⵇⴻⵎ ⵍⴳⴻⵏⵙ ⵅ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰ ⵏⵙⵓ?” ");
INSERT INTO rift_vpl VALUES ("EX15_25","003_15_25","EXO","15","25","25","ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵎⵎⴻⵍ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵡⴰⵎⴰⵏ ⴷ ⵉⵎⵉⵥⵉⴷⴻⵏ. ⴷⵉⵏ ⵉ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵉ ⵍⴳⴻⵏⵙ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⴼⴰⵔⵉⴹⴰ ⵓ ⴷⵉⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵇⴻⴵⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("EX15_26","003_15_26","EXO","15","26","26","ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⴷ ⵎⵍⵉⵃ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵍⵓⵎⴰⵔⴰⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ-ⴷⴷ ⵙⵙⴻⴽⴽⵉⵖ ⵍⴻⵀⵍⴰⵛ ⵉ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵅ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵎⴻⵙⴳⴻⵏⴼⵉ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("EX15_27","003_15_27","EXO","15","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵍⵉⵎ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ, ⴷ ⵙⴻⴱⵄⵉⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX16_1","003_16_1","EXO","16","1","1","ⵓⵛⴰ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵉⵍⵉⵎ, ⵓ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵡⴻⴹ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵉⵍⵉⵎ ⴷ ⵙⵉⵏⴰ. ⵜⵓⵖⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX16_2","003_16_2","EXO","16","2","2","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴻⵏⵏⴻⴷⵇⴻⵎ ⵣⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EX16_3","003_16_3","EXO","16","3","3","ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⵍⵉ ⵏⴻⵎⵎⵓⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴱⴰⵚⵉ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵏⴻⵛⵛⴰ ⴰⵖⵔⵓⵎ ⴰⵍⴰⵎⵉ ⵏⴻⵊⵊⵉⵡⴻⵏ! ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⴰⵏⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵅⵍⴰ-ⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵖⴻⵎ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⴰⵢⴰ ⵙ ⵍⴰⵥ.” ");
INSERT INTO rift_vpl VALUES ("EX16_4","003_16_4","EXO","16","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵅⵣⴰⵔ, ⴰⴷ ⵊⵊⴻⵖ ⴰⵖⵔⵓⵎ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵡⴹⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⵎ ⵡⴻⵏⵥⴰⵔ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ, ⴰⴷ ⴽⵙⵉⵏ ⵎⵉⵏ ⵃⴷⴰⵊⴻⵏ ⵉ ⵡⴰⵙⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵇⴻⴵⴱⴻⵖ, ⵎⴰ ⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ, ⵏⵉⵖ ⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EX16_5","003_16_5","EXO","16","5","5","ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵎⵉⵏ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵅ ⵎⵉⵏ ⵖⴰ ⵙⵙⵎⵓⵏⴻⵏ ⴽⵓⵍ ⴰⵙⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX16_6","003_16_6","EXO","16","6","6","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("EX16_7","003_16_7","EXO","16","7","7","ⵓ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⴰⵏⴻⴷⵇⴻⵎ ⵏⵡⴻⵎ ⵅ ⵙⵉⴷⵉ. ⵎⴰ ⵏⴻⵛⵛⵉⵏ, ⵎⵉⵏ ⵏⴻⵄⵏⴰ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⴻⵏⵏⴷⴻⵇⵎⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("EX16_8","003_16_8","EXO","16","8","8","ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⵍⴰⵎⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⴰⵢⵙⵓⵎ ⵉ ⵎⴰⵛⵛⴰ ⴷⴻⴳ ⵓⵄⴻⵛⵛⵉ ⵓ ⴰⵖⵔⵓⵎ ⴷⵉ ⵜⵢⴰⵡⴰⵏⵜ ⴷⵉ ⵚⵚⴱⴻⵃ, ⴰⵇⴰ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⴰⵏⴻⴷⵇⴻⵎ ⵏⵡⴻⵎ ⵉ ⵣⵉ ⵅⴰⵙ ⵜᵉⵜⵜⵏⴻⴷⵇⴰⵎⴻⵎ. ⵉ ⵏⴻⵛⵛⵉⵏ, ⵎⵉⵏ ⵏⴻⵄⵏⴰ? ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵜᵉⵜⵜⵏⴻⴷⵇⴰⵎⴻⵎ, ⵎⴰⵛⴰ ⵅ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX16_9","003_16_9","EXO","16","9","9","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⵉⵏⵉ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ: ‘ⵔⴻⵃⵃⴳⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵙⵍⴰ ⵉ ⵓⵏⴻⴷⵇⴻⵎ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("EX16_10","003_16_10","EXO","16","10","10","ⴰⵎ ⵉⵙⵙⵉⵡⴻⵍ ⵀⴰⵔⵓⵏ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ, ⵜⵓⵖⴰ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⴹⵀⴰⵔ-ⴷⴷ ⴷⴻⴳ ⵓⵙⴻⵢⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX16_11","003_16_11","EXO","16","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX16_12","003_16_12","EXO","16","12","12","“ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵓⵏⴻⴷⵇⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵉ: ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ, ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⴰⴷ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵙ ⵡⴻⵖⵔⵓⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX16_13","003_16_13","EXO","16","13","13","ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵓⵍⵢⴻⵏⵜ ⵉ-ⴷⴷ ⵉⵊⴹⴰⴹ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵜⵙⴰⵍⵡⴰ’ ⵓⵛⴰ ⴷⵍⵉⵏⵜ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵜⵓⵖⴰ ⵏⵏⴷⴰ ⵉⵏⵏⴻⴹ-ⴷⴷ ⵉ ⵍⵎⴰⵔⴳⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("EX16_14","003_16_14","EXO","16","14","14","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵏⵏⴷⴰ, ⴰⵇⴰ ⴷⴰ, ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵣⴷⴰⵜ ⴰⵎ ⵜⴻⵇⵛⵓⵔⵜ, ⴷ ⵜⴰⵣⴷⴰⵜ ⴰⵎ ⵏⵏⴷⴰ ⵉⴳⴰⵔⵙⴻⵏ, ⵜᵉⵜⵜⵡⴰⴼ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵅⵍⴰ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX16_15","003_16_15","EXO","16","15","15","ⵥⵔⵉⵏ ⵜⵜ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⴰⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵎⴰⵏⴰⵡⵢⴰ?”, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⵉⵏ ⵉⵄⵏⴰ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵎⵓⵙⴰ: “ⵡⴰ ⴷ ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX16_16","003_16_16","EXO","16","16","16","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ: ‘ⴻⵊⵊ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵃⴷⴰⵊ, ⵍⴻⵇⵢⴰⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵄⵓⵎⵉⵔ, ⵄⵍⴰⵃⴰⵍ ⵜⵏⴰⵢⴻⵏ ⵍⵉⵜⵔⵓ, ⵉ ⵉⵊⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ. ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⴽⵙⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵡⴷⴰⵏ ⵉ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EX16_17","003_16_17","EXO","16","17","17","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵢⵔⵓⵏ ⵣⵣⴰⵢⴻⵙ, ⵉⵊⵊⴻⵏ ⴰⵟⵟⴰⵙ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EX16_18","003_16_18","EXO","16","18","18","ⵡⴻⵣⵏⴻⵏ ⴰⵢⴰ ⵙ ⵍⴻⵇⵢⴰⵙ ⵏ ⵓⵄⵓⵎⵉⵔ. ⵡⴻⵏⵏⵉ ⵢⵔⵓⵏ ⴰⵟⵟⴰⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵣⵣⵢⴰⴷⴰ ⴷ ⵡⴻⵏⵏⵉ ⵢⵔⵓⵏ ⴷⵔⵓⵙ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵄⴰⴷ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵢⵔⵓ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵃⴷⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("EX16_19","003_16_19","EXO","16","19","19","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵎⵓⵙⴰ: “ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵊⵊ ⴰⵍ ⵚⵚⴱⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("EX16_20","003_16_20","EXO","16","20","20","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵉ ⵎⵓⵙⴰ ⵓ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅⴻⵎⵎⵍⴻⵏ ⵛⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵍ ⵚⵚⴱⴻⵃ. ⵅⴻⵏⵏⵉ ⵓⴷⴼⴻⵏ ⴷⴰⵢⴻⵙ ⵉⴽⴻⵛⵛⴰⵡⴻⵏ ⵓⵛⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⴳⴳ ⵛⵛⵓⵎ. ⵓⵛⴰ ⵉⴼⴼⵓⴳⴻⵎ ⵅⴰⵙⴻⵏ ⵎⵓⵙⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX16_21","003_16_21","EXO","16","21","21","ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⵢⵔⵓⵏ ⵜ, ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵛⵛ ⵏⴻⵜⵜⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⵃⵎⴰ ⵜⴼⵓⵛⵜ, ⵜⵓⵖⴰ ⵉⵜⵜⴼⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EX16_22","003_16_22","EXO","16","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵢⵔⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵍⴻⵇⵢⴰⵙ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⵓⵎⵉⵔⴻⵏ ⵉ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ. ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX16_23","003_16_23","EXO","16","23","23","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ: ‘ⵜⵉⵡⴻⵛⵛⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⴰⵔⵔⴰⵃⴻⵜ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ. ⵙⴻⵏⴳⵯⴻⵎ ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜᵉⵙⵙⴻⵏⴳⵯⴻⵎ, ⵙⵏⴻⵏⵏⴰⵎ ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜᵉⵙⵙⴻⵏⵏⴰⵎ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ, ⵅⴻⵎⵎⵍⴻⵎ ⵜ ⴰⵍ ⵚⵚⴱⴻⵃ.’” ");
INSERT INTO rift_vpl VALUES ("EX16_24","003_16_24","EXO","16","24","24","ⵏⵉⵜⵏⵉ ⵅⴻⵎⵎⵍⴻⵏ ⵜ ⴰⵍ ⵚⵚⴱⴻⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⵓⵛⴰ ⵡⴰⵔ ⵢⴰⵔⵚⵓⴹ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵓⵖⵉ ⵜⴽⴻⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EX16_25","003_16_25","EXO","16","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⵛⵛⴻⵎ ⴰⵢⴰ ⴰⵙⵙ-ⴰ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ-ⴰ ⴷ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵏ ⵙⵉⴷⵉ. ⴰⵙⵙ-ⴰ ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⵉⴼⴻⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX16_26","003_16_26","EXO","16","26","26","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵢⵔⵓⵎ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⵇⴰ ⴷ ⵙⵙⴻⴱⵜ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("EX16_27","003_16_27","EXO","16","27","27","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴼⴼⵖⴻⵏ ⵛⴰ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵔⵓⵏ ⵛⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⴼⵉⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("EX16_28","003_16_28","EXO","16","28","28","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵍ ⵎⴻⵍⵎⵉ ⵜⵓⴳⵉⵎ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("EX16_29","003_16_29","EXO","16","29","29","ⵅⵣⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵅ ⵓⵢⴰ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⴰⵖⵔⵓⵎ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ! ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("EX16_30","003_16_30","EXO","16","30","30","ⵓⵛⴰ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("EX16_31","003_16_31","EXO","16","31","31","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵍⴰⵖⴰ ⴰⵙ ‘ⵎⴰⵏⵏⴰ’. ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵛⴻⵎⵍⴰⵍⵜ ⴰⵎ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵍⵇⴻⵚⴱⵓⵔ ⵓⵛⴰ ⴰⵍⴻⴷⴷⵉ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵜⵉⴼⴹⵉⵔⵉⵏ ⵏ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX16_32","003_16_32","EXO","16","32","32","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴷⴷⴻⴳⴳⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵣⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ: ‘ⵛⵛⵓⵔⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵇⵢⴰⵙ ⵏ ⵢⵉⵊⵊ ⵏ ⵓⵄⵓⵎⵉⵔ ⵓⵛⴰ ⵅⴻⵎⵎⴻⵍ ⵉ-ⵜ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵖⵔⵓⵎ ⵎⵉⵏ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵛⵛⴻⵖ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX16_33","003_16_33","EXO","16","33","33","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⵏⴱⵉⵍ ⵓⵛⴰ ⵄⴻⵎⵎⴰⵔ ⵉ-ⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵄⵓⵎⵉⵔ ⵏ ‘ⵎⴰⵏⵏⴰ’ ⵓⵛⴰ ⴻⴳⴳ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⵎⵎⴻⵍ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX16_34","003_16_34","EXO","16","34","34","ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵀⴰⵔⵓⵏ ⵣⵣⴰⵜ ⵉ ⵛⵛⵀⴰⴷⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴻⵎⵎⴻⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX16_35","003_16_35","EXO","16","35","35","ⴰⵎⵎⵓ ⵉ ⵛⵛⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ‘ⵎⴰⵏⵏⴰ’ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ. ⵛⵛⵉⵏ ⵎⴰⵏⵏⴰ ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX16_36","003_16_36","EXO","16","36","36","ⵉⵊⵊ ⵏ ⵓⵄⵓⵎⵉⵔ ⴷ ⵄⴻⵛⵔⴰ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("EX17_1","003_17_1","EXO","17","1","1","ⵓⵛⴰ ⴼⴻⵙⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵔⴰⴼⵉⴷⵉⵎ. ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵓ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX17_2","003_17_2","EXO","17","2","2","ⵅⴻⵏⵏⵉ ⵉⵎⵛⵓⴱⴱⴻⵛ ⵍⴳⴻⵏⵙ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⵓ!” ⵎⵓⵙⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵎ? ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵇⴻⴵⴰⴱⴻⵎ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("EX17_3","003_17_3","EXO","17","3","3","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⴼⴼⵓⴷ ⴰⵟⵟⴰⵙ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵏⵏⴷⴻⵇⵎⴻⵏ ⵣⵉ ⵎⵓⵙⴰ, ⵏⵏⴰⵏ: “ⵎⴰⵖⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ? ⵎⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵀⴻⵍⵍⴽⴻⴷ ⵙ ⵓⴼⴰⴷⵉ ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵉⵏⵓ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("EX17_4","003_17_4","EXO","17","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵖⵓⵢ ⵎⵓⵙⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ-ⴰ? ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⴰⵔⴻⵊⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX17_5","003_17_5","EXO","17","5","5","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴻⴽⴽ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴽⵙⵉ ⴰⴽⵉⴷⴻⴽ ⵛⴰ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴽⵙⵉ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⵉ ⵣⵉ ⵜⴻⵡⵜⵉⴷ ⵉⵖⵣⴰⵔ ⵓⵛⴰ ⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("EX17_6","003_17_6","EXO","17","6","6","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⴷⵉⵏ ⵣⵣⴰⵜⴻⴽ ⵅ ⵜⴻⵚⴹⴰⵔⵜ ⵖⴰⵔ ⵃⵓⵔⵉⴱ, ⴰⴷ ⵜⴻⵡⵜⴻⴷ ⵜⴰⵚⴹⴰⵔⵜ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓ ⵍⴳⴻⵏⵙ.” ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⴰⵎⴻⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX17_7","003_17_7","EXO","17","7","7","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵎⴰⵙⵙⴰ ⴷ ⵎⴰⵔⵉⴱⴰ, ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵎⵛⵓⴱⴱⵛⴻⵏ ⴷⵉⵏ ⵓ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵇⴻⴵⴱⴻⵏ ⵙⵉⴷⵉ, ⵏⵏⴰⵏ: “ⵎⴰ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⵍⴻⵅⵅⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵖ ⵏⵉⵖ ⵍⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("EX17_8","003_17_8","EXO","17","8","8","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵄⴰⵎⴰⵍⵉⵇ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵔⴰⴼⵉⴷⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EX17_9","003_17_9","EXO","17","9","9","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵉⵅⴹⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⴰⴷ ⵏⴻⴼⴼⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵄⴰⵎⴰⵍⵉⵇ. ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⵙⴻⵏⵏⴻⵊ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵜⴻⵡⵔⵉⵔⵜ ⵓⵛⴰ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("EX17_10","003_17_10","EXO","17","10","10","ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵎⵓⵙⴰ, ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵄⴰⵎⴰⵍⵉⵇ, ⵎⴰⵛⴰ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵃⵓⵔ ⵓⵍⵢⴻⵏ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵜⴻⵡⵔⵉⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX17_11","003_17_11","EXO","17","11","11","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵍⴰⵎⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵖⴻⴵⴻⴱ, ⵎⴰⵛⴰ ⵅⵎⵉ ⵉⵜⵜⴻⵊⵊⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵉⵀⵡⴰ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵖⴻⴵⴱⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("EX17_12","003_17_12","EXO","17","12","12","ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⵓⵙⴰ ⴷⴻⵡⵍⴻⵏ ⴷⴷⴻⵇⵍⴻⵏ. ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜ ⵙⴰⴷⵓ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵅⴰⵙ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵃⵓⵔ ⵙⴻⵏⵏⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵉⵊⵊ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵍⴰⵎⵉ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX17_13","003_17_13","EXO","17","13","13","ⵓⵛⴰ ⵉⵖⵍⴻⴱ ⵢⴰⵛⵓⵡⴰ ⵅ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EX17_14","003_17_14","EXO","17","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵔⵉ ⴰⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⴻⴳⴳ ⵉ-ⵜ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⵢⴰⵛⵓⵡⴰ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵎⵃⵉⵖ ⵇⴰⵄ ⵍⵉⴷⴰⵔⴻⵜ ⴷⵉ ⵄⴰⵎⴰⵍⵉⵇ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX17_15","003_17_15","EXO","17","15","15","ⵉⴱⵏⴰ ⵎⵓⵙⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵙ ⵢⵉⵙⴻⵎ: “ⵙⵉⴷⵉ ⴷ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("EX17_16","003_17_16","EXO","17","16","16","ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴰⴼⵓⵙ ⵜⵓⵖⴰ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵙⵉⴷⵉ. ⵙⵉⴷⵉ ⴰⴷ ⵢⴻⴳⴳ ⴳⴰⵔⵔⴰ ⵅ ⵄⴰⵎⴰⵍⵉⵇ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EX18_1","003_18_1","EXO","18","1","1","ⵉⵙⵍⴰ ⵢⵉⵜⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵎⵉⴷⵢⴰⵏ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⵓ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵙⵉⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX18_2","003_18_2","EXO","18","2","2","ⵉⵟⵟⴻⴼ ⵢⵉⵜⵔⵓⵏ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ, ⵚⴰⴼⴼⵓⵔⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⵓⵙⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵜⵉⵔⵣⵉⴼⵉⵏ ⵏⵏⴻⵙ ⵏ ⵜⴻⵙⵍⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("EX18_3","003_18_3","EXO","18","3","3","ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵊⵊⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵊⴰⵔⵛⵓⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⴰⴱⴰⵔⵔⴰⵏⴻⵛⵜ!”, ");
INSERT INTO rift_vpl VALUES ("EX18_4","003_18_4","EXO","18","4","4","ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵍⵉⵄⴰⵣⵉⵔ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰ ⵉⵄⴰⵡⴻⵏ ⴰⵢⵉ ⵓⵛⴰ ⵉⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵙⵙⵉⴼ ⵏ ⴼⵉⵔⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX18_5","003_18_5","EXO","18","5","5","ⵢⵉⵜⵔⵓⵏ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ, ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵟⵟⵓⵜ ⵏⵏⴻⵙ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX18_6","003_18_6","EXO","18","6","6","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵎⵓⵙⴰ: “ⵏⴻⵛⵛ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵛ ⵢⵉⵜⵔⵓⵏ, ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵙ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX18_7","003_18_7","EXO","18","7","7","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵎⵓⵙⴰ ⴰⴷ ⵉⵍⵇⴰ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ, ⵉⴱⴻⵏⴷⴻⵇ ⵓⵛⴰ ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ⵉⵊⵊⴻⵏ ⵉⵙⵙⴻⵇⵙⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX18_8","003_18_8","EXO","18","8","8","ⵎⵓⵙⴰ ⵉⵃⴰⵊⴰ ⵉ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⴼⵉⵔⵄⵓⵏ ⵓ ⴰⴽ-ⴷ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴰⵔⴰ ⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⴽⴽⵉⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵉⴼⴻⴽⴽ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX18_9","003_18_9","EXO","18","9","9","ⵉⴼⴰⵔⵃ ⵢⵉⵜⵔⵓⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵅⵉⵔ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵓⵎⵉ ⵜ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX18_10","003_18_10","EXO","18","10","10","ⵉⵏⵏⴰ ⵢⵉⵜⵔⵓⵏ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EX18_11","003_18_11","EXO","18","11","11","ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⴰⵇⴰ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⴷⴻⵙⵙⴰⵔⴻⵏ ⵅⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX18_12","003_18_12","EXO","18","12","12","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵢⵉⵜⵔⵓⵏ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ, ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵀⴰⵔⵓⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵛⵛ ⴰⵖⵔⵓⵎ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX18_13","003_18_13","EXO","18","13","13","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵍⴽⵓⵔⵙⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴽⴻⵎ ⵍⴳⴻⵏⵙ. ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵎⵓⵙⴰ ⵣⵉ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⴰⵍ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX18_14","003_18_14","EXO","18","14","14","ⵉⵥⵔⴰ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵎⵓⵙⴰ ⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵎⴰⵏⴰⵡⴰⵢⴰ ⵉ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ ⵉ ⵍⴳⴻⵏⵙ? ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵖⵉⵎⵉⴷ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⴽ ⵣⵉ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⴰⵍ ⴵⵉⵍⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("EX18_15","003_18_15","EXO","18","15","15","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵅ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ: “ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵖⴰⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⴰⵔ ⵛⵛⵡⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX18_16","003_18_16","EXO","18","16","16","ⵅ ⵎⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜᵉⵜⵜⵉⵍⵉ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵖ ⵊⴰⵔ ⵉⵊⵊ ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵙⵙⴻⵛⴰⵏⴻⵖ ⴰⵙⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX18_17","003_18_17","EXO","18","17","17","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EX18_18","003_18_18","EXO","18","18","18","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴰⵃⵍⴻⴷ ⴰⵟⵟⴰⵙ, ⵛⴻⴽ ⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵉ ⴽⵉⴽ ⵉⴵⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴷⵇⴻⵍ ⵅⴰⴽ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⵡⴻⵃⵃⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("EX18_19","003_18_19","EXO","18","19","19","ⵙⴻⵍ ⵍⴻⵅⵅⵓ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵏⴻⵚⵃⴻⵖ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴽⵉⴽ ⵢⵉⵍⵉ. ⵉⵍⵉ ⵛⴻⴽ ⴷ ⴰⵡⴻⵚⵚⴰⵢ ⵅ ⵍⴳⴻⵏⵙ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵇⴻⴷⴷⴻⵎ ⴷⴷⵄⴰⵡⵉ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX18_20","003_18_20","EXO","18","20","20","ⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵓⵛⴰ ⵙⵛⴻⵏ ⴰⵙⴻⵏ ⴰⴱⵔⵉⴷ ⵉ ⵜⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵓ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜⵜ ⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX18_21","003_18_21","EXO","18","21","21","ⵄⴰⵡⴻⴷ ⵅⵣⴰⵔ ⵛⴻⴽ, ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵅ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵣⴻⵄⵄⴰⵎⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵚⴷⵉⵇⴻⵏ, ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵅ ⴰⵔⴱⴻⵃ. ⴻⴳⴳ ⵉ-ⵜⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ, ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵅⴻⵎⵙⵉⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵄⴻⵛⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX18_22","003_18_22","EXO","18","22","22","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵏ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵍⴻⴱⴷⴰ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵎⴰⵔⵔⴰ ⴷⴷⵄⴰⵡⵉ ⵉⵡⵄⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⴽ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⴷⴷⵄⴰⵡⵉ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⴰⴷ ⵅⴰⵙⴻⵏⵜ ⵛⴰⵔⵔⵄⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⴻⴳⴳ ⵉ-ⵜ ⵜⴻⴼⵙⵓⵙ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⵜ ⴰⵔⴱⵓⵏ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("EX18_23","003_18_23","EXO","18","23","23","ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ, ⵓ ⴰⵔⴻⴱⴱⵉ ⵉ ⵛⴻⴽ ⵢⵓⵎⵓⵔⴻⵏ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⵢⴰ ⴰⴷ ⵢⴰⵡⴻⴹ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("EX18_24","003_18_24","EXO","18","24","24","ⵉⵙⵍⴰ ⵎⵓⵙⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵏ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EX18_25","003_18_25","EXO","18","25","25","ⵉⵅⴹⴰⵔ ⵎⵓⵙⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵣⴻⵄⵄⴰⵎⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⴳⴻⵏⵙ: ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵅⴻⵎⵙⵉⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵄⴻⵛⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX18_26","003_18_26","EXO","18","26","26","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵛⴰⵔⵔⵄⴻⵏ ⵍⴳⴻⵏⵙ ⵍⴻⴱⴷⴰ ⵓⵛⴰ ⴷⴷⵄⴰⵡⵉ ⵉⵡⵄⴰⵔⴻⵏ ⵇⴻⴷⵎⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵎⵓⵙⴰ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⴷⴷⵄⴰⵡⵉ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵛⴰⵔⵔⵄⴻⵏ ⵜⴻⵏⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX18_27","003_18_27","EXO","18","27","27","ⵉⵇⴻⴱⴱⴻⴹ ⵎⵓⵙⴰ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX19_1","003_19_1","EXO","19","1","1","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⵓⴼⴼⵓⵖ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ, ⵉⵡⴹⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EX19_2","003_19_2","EXO","19","2","2","ⴰⵇⴰ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵔⴰⴼⵉⴷⵉⵎ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵉⵡⵜⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX19_3","003_19_3","EXO","19","3","3","ⵢⵓⵍⵉ ⵎⵓⵙⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ-ⴷⴷ ⵙⵉⴷⵉ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("EX19_4","003_19_4","EXO","19","4","4","‘ⴽⴻⵏⵏⵉⵡ ⵜⴻⵥⵔⵉⵎ ⵎⵉⵏ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓ ⵎⴰⵎⵎⴻⵛ ⴽⴻⵏⵏⵉⵡ ⴽⵙⵉⵖ ⵅ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵓⴳⵉⴷⴻⵔ ⵓⵛⴰ ⵉⵡⵢⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⵉ.    ");
INSERT INTO rift_vpl VALUES ("EX19_5","003_19_5","EXO","19","5","5","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵎⵍⵉⵃ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵍⵄⴰⵀⴷ ⵉⵏⵓ, ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵖⵍⴰⵎ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ-ⵜⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX19_6","003_19_6","EXO","19","6","6","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⵇⴻⴷⴷⴰⵙ.’ ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷ ⴰⵛ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜⴻⵏ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EX19_7","003_19_7","EXO","19","7","7","ⵉⵀⵡⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⴱⴰⵔⵔⴻⵃ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX19_8","003_19_8","EXO","19","8","8","ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⴰⴷ ⵜ ⵏⴻⴳⴳ!” ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵎⵓⵙⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵄⴰⵡⴻⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX19_9","003_19_9","EXO","19","9","9","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⴷ ⴰⴱⴰⵔⵛⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵍ ⵍⴳⴻⵏⵙ ⵅⵎⵉ ⵏⴻⵛⵛ ⴽⵉⴽ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴰⵎⵏⴻⵏ ⵉ ⵍⴻⴱⴷⴰ.” ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵉⵅⴻⴱⴱⴰⵔ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX19_10","003_19_10","EXO","19","10","10","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵎⵓⵙⴰ: “ⵔⵓⵃ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏ ⴰⵙⵙ-ⴰ ⴷ ⵜⵉⵡⴻⵛⵛⴰ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EX19_11","003_19_11","EXO","19","11","11","ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⵡⴻⵊⴷⴻⵏ ⵉ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX19_12","003_19_12","EXO","19","12","12","ⴻⴳⴳ ⵉⵢⵎⵉⵔⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵉⵏⵉ: ‘ⵖⴰⵔⵡⴻⵎ, ⵡⴰⵔ ⵜⵉⵍⵢⴻⵎ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏⵉⵖ ⴰⴷ ⵜⵃⴰⴷⴰⵎ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵙ. ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⴷⵔⴰⵔ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX19_13","003_19_13","EXO","19","13","13","ⵡⴰⵔ ⵜ ⵉⵜⵜⵃⵉⴷⵉ ⵃⴻⴷ ⵙ ⵓⴼⵓⵙ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵊⴻⵎ ⵏⵉⵖ ⴰⴷ ⵉⵜⵜⵡⴰⵡⵡⴻⵜ ⵏⵉⵛⴰⵏ ⵙ ⴼⵍⵉⵜⵛⴰⵜ ⵎⵉⵏ ⵎⴰ ⵉⵄⵏⴰ, ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵉⵖ ⴷ ⴱⵏⴰⴷⴻⵎ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴷⴷⴰⵔ. ⵎⴰⵍⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴷ ⴰⵣⵉⵔⴰⵔ, ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵍⵢⴻⵏ ⴰⴷⵔⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("EX19_14","003_19_14","EXO","19","14","14","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵖⴰⵔ ⵍⴳⴻⵏⵙ, ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵙⵙⵉⵔⴷⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX19_15","003_19_15","EXO","19","15","15","ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵉⵍⵉⵎ ⵜⵜⵡⴻⵊⴷⴻⵎ ⵉ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⴰⴱⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX19_16","003_19_16","EXO","19","16","16","ⴷⵉ ⵚⵚⴱⴻⵃ ⵏ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴷ ⵡⴰⵙⵙⴰⵎⴻⵏ. ⴰⵇⴰ ⵢⴰⵔⵙⴰ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴷⴷⴻⵇⵍⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵓ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵢⴰⵔⵊⵉⵊ. ");
INSERT INTO rift_vpl VALUES ("EX19_17","003_19_17","EXO","19","17","17","ⵎⵓⵙⴰ ⵉⵏⴷⴻⵀ ⵍⴳⴻⵏⵙ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX19_18","003_19_18","EXO","19","18","18","ⵎⴰⵔⵔⴰ ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵉⴷⴷⴻⵅⵅⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⴷⴷⴻⵅⵅⴰⵏ ⵏⵏⴻⵙ ⵢⵓⵍⵉ-ⴷⴷ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵓⴼⴰⵔⵔⴰⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴰⴷⵔⴰⵔ ⵉⵏⵀⴻⵣⵣ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX19_19","003_19_19","EXO","19","19","19","ⴰⵎ ⵉⴷⵡⴻⵍ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵉⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX19_20","003_19_20","EXO","19","20","20","ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX19_21","003_19_21","EXO","19","21","21","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵀⵡⴰ-ⴷⴷ, ⵄⵍⴻⵎ ⵉ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵛⵓⵇⵉⵏ ⴷⵉ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴱⴰⵍⴰⴽ ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX19_22","003_19_22","EXO","19","22","22","ⴻⵊⵊ ⵄⴰⵡⴻⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵙⴻⵄⵄⴰⵔ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX19_23","003_19_23","EXO","19","23","23","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ: “ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵄⴻⵍⵎⴻⴷ ⴰⵏⴻⵖ ⵜⴻⵏⵏⵉⴷ: ‘ⴻⴳⴳ ⵉⵢⵎⵉⵔⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EX19_24","003_19_24","EXO","19","24","24","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵔⵓⵃ, ⵀⵡⴰ! ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵛⴻⴽ ⴷ ⵀⴰⵔⵓⵏ ⴰⴽⵉⴷⴻⴽ, ⵎⴰⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⵓⵇⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵙⴻⵄⵄⴰⵔ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX19_25","003_19_25","EXO","19","25","25","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EX20_1","003_20_1","EXO","20","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX20_2","003_20_2","EXO","20","2","2","“ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("EX20_3","003_20_3","EXO","20","3","3","ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜⵜⵉⵍⵉⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX20_4","003_20_4","EXO","20","4","4","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏⵉⵖ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴰⵔⵡⴻⵙ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⴷⵉ ⵛⴰ ⴷⴰ ⵙⵡⴰⴷⴷⴰⵢ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⴷⵉ ⵛⴰ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX20_5","003_20_5","EXO","20","5","5","ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⴱⴻⵏⴷⵉⵇ ⵓⵍⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⴻⵣⴼⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴷⵉ ⵜⴰⵔⵡⴰ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX20_6","003_20_6","EXO","20","6","6","ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵛⴰⵏⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵍⵓⵍⵓⴼ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⵃⴻⵟⵟⴰⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX20_7","003_20_7","EXO","20","7","7","ⵡⴰⵔ ⵏⴻⵟⵟⴻⵇ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⵔⵉ ⵙⵉⴷⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⵟⵇⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX20_8","003_20_8","EXO","20","8","8","ⵉⴷⴰⵔ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX20_9","003_20_9","EXO","20","9","9","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵖⴰ ⵜⵅⴻⴷⵎⴻⴷ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX20_10","003_20_10","EXO","20","10","10","ⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴷ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵛⴻⴽ ⵍⵍⴰ, ⵓⵍⴰ ⴷ ⵎⵎⵉⵛ ⵍⵍⴰ, ⴷ ⵢⴻⴵⵉⵛ ⵍⵍⴰ, ⴷ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ ⵍⵍⴰ, ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵍⵍⴰ, ⴷ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵍⵍⴰ, ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EX20_11","003_20_11","EXO","20","11","11","ⵎⵉⵏⵣⵉ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵢⴰⵔⴻⵢⵢⴻⵃ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ⵅ ⵓⵢⴰ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓⵛⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("EX20_12","003_20_12","EXO","20","12","12","ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ, ⵎⴰⵃⴻⵏⴷ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵢⴻⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX20_13","003_20_13","EXO","20","13","13","ⵡⴰⵔ ⵏⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("EX20_14","003_20_14","EXO","20","14","14","ⵡⴰⵔ ⵣⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EX20_15","003_20_15","EXO","20","15","15","ⵡⴰⵔ ⵜⵜⴰⵛⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX20_16","003_20_16","EXO","20","16","16","ⵡⴰⵔ ⵛⴻⵀⵀⴻⴷ ⵙ ⵥⵓⵔ ⴹⵉⴷⴷ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX20_17","003_20_17","EXO","20","17","17","ⵡⴰⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵛⴰ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ. ⵡⴰⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵏⵉⵖ ⴷⴻⴳ ⵢⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⴻⴳ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⵉⴵⴰⵏ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EX20_18","003_20_18","EXO","20","18","18","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵥⵔⴰ ⵓ ⵉⵙⵍⴰ ⵉ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴷ ⵡⴰⵙⵙⴰⵎⴻⵏ ⴷ ⴷⴷⵔⵉⵣ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵡⴻⴷⵔⴰⵔ ⵉⴷⴷⵓⵅⵅⵓⵏⴻⵏ. ⵓⵎⵉ ⵉⵥⵔⴰ ⵍⴳⴻⵏⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵅⴻⵏⵏⵉ ⴰⵔⵊⵉⵊⴻⵏ ⵓⵛⴰ ⴱⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("EX20_19","003_20_19","EXO","20","19","19","ⵏⵏⴰⵏ ⵉ ⵎⵓⵙⴰ: “ⵙⵉⵡⴻⵍ ⵛⴻⴽ ⴰⴽⵉⴷⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⵙⴻⵍ. ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵉⵙⵙⵉⵡⵉⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵜⵜⵉ!” ");
INSERT INTO rift_vpl VALUES ("EX20_20","003_20_20","EXO","20","20","20","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴻⴵⴻⴱ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵅⴻⵟⵟⵉⵎ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX20_21","003_20_21","EXO","20","21","21","ⵉⴱⴻⴷⴷ ⵍⴳⴻⵏⵙ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵎⴰⵛⴰ ⵎⵓⵙⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⵙⴻⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX20_22","003_20_22","EXO","20","22","22","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴽⴻⵏⵏⵉⵡ ⵜⴻⵥⵔⵉⵎ ⴱⴻⵍⵍⵉ ⵙⵙⵉⵡⵍⴻⵖ-ⴷⴷ ⴰⴽⵉⴷⵡⴻⵎ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EX20_23","003_20_23","EXO","20","23","23","ⵡⴰⵔ ⴽⵉⴷⵉ ⵜⵜⴻⴳⴳⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX20_24","003_20_24","EXO","20","24","24","ⴻⴳⴳ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵙ ⵓⵛⴰⵍ, ⵇⴻⴷⴷⴻⵎ ⵅⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ ⵏ ⵍⴻⵀⵏⴰ, ⵓⴵⵉ ⵏⵏⴻⵛ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ. ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⴳⴳⴻⵖ ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⴱⴰⵔⴽⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX20_25","003_20_25","EXO","20","25","25","ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵉⵥⵔⴰ, ⵡⴰⵔ ⵜ ⵜⴱⴻⵏⵏⵉⴷ ⵙ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⴷⴷⵣⴻⴷ ⵙ ⵓⵍⴻⵢⵣⵉⵎ ⵏⵏⴻⵛ, ⵉⵍⵉ ⴰⴷ ⵜ ⵜⴻⵙⵙⵄⵉⴵⵜⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX20_26","003_20_26","EXO","20","26","26","ⵡⴰⵔ ⵜⵜⴳⵉⵄⵄⵉⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⴷⴷⵔⵓⵊ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴱⵉⵏ ⵓⵙⴻⴹⵃⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EX21_1","003_21_1","EXO","21","1","1","“ⵜⵉⵏⴰ ⵉ ⵉⴵⴰⵏ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX21_2","003_21_2","EXO","21","2","2","ⵎⴰⵍⴰ ⵜⴻⵙⵖⵉⴷ ⵉⵙⵎⴻⵖ ⴷ ⴰⵄⵉⴱⵔⴰⵏⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵉⵙⴻⵅⵅⴰⵔ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⴷ ⴰⵃⵓⵔⵔⵉ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX21_3","003_21_3","EXO","21","3","3","ⵎⴰⵍⴰ ⵢⵓⴷⴻⴼ ⵡⴻⵃⵃⴷⴻⵙ, ⵡⴻⵃⵃⴷⴻⵙ ⵉ ⵖⴰ ⵉⴼⴼⴻⵖ, ⵎⴰⵍⴰ ⵖⴰⵔⴻⵙ ⵜⴰⵎⵖⴰⵔⵜ, ⴰⴷ ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_4","003_21_4","EXO","21","4","4","ⵎⴰⵍⴰ ⵙⵉⴷⵉⵙ ⵉⵡⵛⴰ ⴰⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵊⵊⴰ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⵅⴻⵏⵏⵉ ⵜⴰⵎⵖⴰⵔⵜ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵏ ⵙⵉⴷⵉⵙ, ⵓ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵙ ⵉⵎⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_5","003_21_5","EXO","21","5","5","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵙⵎⴻⵖ ⵉⵏⵏⴰ ⵏⵉⵛⴰⵏ: ‘ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵏⵓ ⴷ ⵜⴰⵔⵡⴰ ⵉⵏⵓ, ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⴼⴼⵖⴻⵖ ⴷ ⴰⵃⵓⵔⵔⵉ!’, ");
INSERT INTO rift_vpl VALUES ("EX21_6","003_21_6","EXO","21","6","6","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⵉⴷⵉⵙ ⴰⴷ ⵜ ⵉⵙⵙⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵉⵖ ⵖⴰⵔ ⵜⴻⴼⵍⴰⵡⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⵙⵉⴷⵉⵙ ⴰⴷ ⴰⵙ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⴰⵎⴻⵊⵊⵓⵏ ⵏⵏⴻⵙ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⵙⵉⵏⴻⴼⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX21_7","003_21_7","EXO","21","7","7","ⵎⴰⵍⴰ ⵉⵣⵣⴻⵏⵣ ⵃⴻⴷ ⵢⴻⴵⵉⵙ ⴷ ⵜⴰⵢⵢⴰ, ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⵉⵖ ⴰⵎ ⵎⵓⵅⴰⵙ ⵜⵜⴻⴼⴼⵖⴻⵏ ⵉⵙⴻⵎⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_8","003_21_8","EXO","21","8","8","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵄⵊⵉⴱ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉⵙ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵅⴹⴻⴱ ⵉ-ⵜⵜ, ⴰⴷ ⵜⵜ ⵢⴻⵊⵊ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴷⵉ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⵣⵣⴻⵏⵣ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⴱⴰⵔⵔⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵖⴷⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵙ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("EX21_9","003_21_9","EXO","21","9","9","ⵎⴰⵍⴰ ⵉⵅⴹⴻⴱ ⵉ-ⵜⵜ ⵉ ⵎⵎⵉⵙ, ⴰⴷ ⴽⵉⴷⴻⵙ ⵢⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵣⵉ ⵊⵊⵀⴻⵜ ⵏ ⵢⴻⴵⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_10","003_21_10","EXO","21","10","10","ⵎⴰⵍⴰ ⵉⴽⵙⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵏⴻⵇⵇⴻⵚ ⵍⵄⵓⵍⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵍⵄⴰⵛⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_11","003_21_11","EXO","21","11","11","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⴳⴳⵉ ⵜⵍⴰⵜⴰ-ⵢⴰ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⴱⴰⵟⴻⵍ, ⴱⵍⴰ ⵍⴻⵅⵔⴰⵚ.” ");
INSERT INTO rift_vpl VALUES ("EX21_12","003_21_12","EXO","21","12","12","“ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⵃⴻⴷ ⴰⵍ ⵖⴰ ⵉⵎⵎⴻⵜ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_13","003_21_13","EXO","21","13","13","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⵏⴻⵄⵎⴰⴷⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵙ-ⴷⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX21_14","003_21_14","EXO","21","14","14","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵢⵓⴼⴼ ⵃⴻⴷ ⵅ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵙ ⵍⴻⵖⴷⴰⵔⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_15","003_21_15","EXO","21","15","15","ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_16","003_21_16","EXO","21","16","16","ⵡⴻⵏⵏⵉ ⵢⵓⵛⴰⵔⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⵉⵣⵣⴻⵏⵣ ⵉ-ⵜ, ⵏⵉⵖ ⵉⵜⵜⵡⴰⴼ ⵄⴰⴷ ⵖⴰⵔⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_17","003_21_17","EXO","21","17","17","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⵄⵍⴻⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_18","003_21_18","EXO","21","18","18","ⵎⴰⵍⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵎⵎⵛⵓⴱⴱⵛⴻⵏ ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵉⵡⵜⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵡⴻⵥⵔⵓ ⵏⵉⵖ ⵙ ⵍⴱⵓⵏⵉⵢⵢⴻⵜ, ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵎⵎⵓⵜ, ⵎⴰⵛⴰ ⵉⵡⴹⴰ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("EX21_19","003_21_19","EXO","21","19","19","ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵡⴰⵏⵉⵜⴰ ⵉⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵅ ⵜⴻⵖⵖⴰⵔⵛⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⵡⵜⵉⵏ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ⴰⴷ ⴰⵙ ⵉⵅⴻⴵⴻⵚ ⵎⵖⵉⵔ ⵎⵉⵏ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵓⵛⴰ ⴰⴷ ⵜ ⵢⴻⵊⵊ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EX21_20","003_21_20","EXO","21","20","20","ⵎⴰⵍⴰ ⵉⵡⵜⴰ ⵃⴻⴷ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ ⵏⵉⵖ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵙ ⵡⴻⵄⵎⵓⴷ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵢⴰⵖ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_21","003_21_21","EXO","21","21","21","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵉⵊⵊ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵡⴰⵔ ⴷ ⴰⵙ ⵢⵓⵖⵉ ⵜⴰⵙⵖⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("EX21_22","003_21_22","EXO","21","22","22","ⵎⴰⵍⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵎⵎⴻⵏⵖⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵉⵡⴹⴰ ⴰⵙ-ⴷⴷ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⴰⵢⴻⵣⵣⵉⵎ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵏⵉⵛⴰⵏ ⵉⵊⵊ ⵏ ⵎⵓⵍⵜⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵉⵜⵜⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵡⵛ ⵉ ⵍⵇⵓⴹⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX21_23","003_21_23","EXO","21","23","23","ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⵛⴰ ⵏ ⵓⵢⴻⵣⵣⵉⵎ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵙ ⵜⵓⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("EX21_24","003_21_24","EXO","21","24","24","ⵜⵉⵟⵟ ⵙ ⵜⵉⵟⵟ, ⵜⵉⵖⵎⴻⵙⵜ ⵙ ⵜⴻⵖⵎⴻⵙⵜ, ⴰⴼⵓⵙ ⵙ ⵓⴼⵓⵙ, ⴰⴹⴰⵔ ⵙ ⵓⴹⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("EX21_25","003_21_25","EXO","21","25","25","ⴰⵛⵎⴰⴹ ⵙ ⵡⴻⵛⵎⴰⴹ, ⴰⵢⴻⵣⵣⵉⵎ ⵙ ⵓⵢⴻⵣⵣⵉⵎ, ⵜⵉⵛⵜⵉ ⵙ ⵜⴻⵛⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EX21_26","003_21_26","EXO","21","26","26","ⵎⴰⵍⴰ ⵉⵍⵇⴻⴼ ⵃⴻⴷ ⵜⵉⵟⵟ ⵏ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ ⵏⵉⵖ ⵜⵉⵟⵟ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵉⴹⴻⵢⵢⴻⵄ ⵉ-ⵜⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵢⴻⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⵎⴻⵏⵏⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⵟⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_27","003_21_27","EXO","21","27","27","ⵎⴰⵍⴰ ⵙ ⵜⴻⵛⵜⵉ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵜⵉⵖⵎⴻⵙⵜ ⵏ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵜⵉⵖⵎⴻⵙⵜ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵢⴻⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⵎⴻⵏⵏⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴻⵖⵎⴻⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_28","003_21_28","EXO","21","28","28","ⵎⴰⵍⴰ ⴰⴼⵓⵏⴰⵙ ⵉⴱⴰⵔⵔⴻⵣ ⴰⵔⵢⴰⵣ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ, ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵎⵎⵓⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵔⵊⵎⴻⵏ ⴰⴼⵓⵏⴰⵙ ⵓ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵏ. ⴱⴰⴱ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴼⵓⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EX21_29","003_21_29","EXO","21","29","29","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴼⵓⵏⴰⵙ ⵜⵓⵖⴰ ⴷ ⴰⴱⴰⵔⵔⴻⵣ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ ⵓⵛⴰ ⴱⴰⴱ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵉⵃⴹⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⴰⵔⵢⴰⵣ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵔⵊⵎⴻⵏ ⴰⴼⵓⵏⴰⵙ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵏⵖⴻⵏ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_30","003_21_30","EXO","21","30","30","ⵎⴰⵍⴰ ⴳⴳⵉⵏ ⵅⴰⵙ ⴷⴷⴻⵢⵢⴻⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵉⵡⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⴳⴳⵉⵏ ⴷ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EX21_31","003_21_31","EXO","21","31","31","ⵏⵉⵖ ⵎⴰⵍⴰ ⴰⴼⵓⵏⴰⵙ ⵉⴱⴰⵔⵔⴻⵣ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵉⵖ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ. ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ-ⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EX21_32","003_21_32","EXO","21","32","32","ⵎⴰⵍⴰ ⴰⴼⵓⵏⴰⵙ ⵉⴱⴰⵔⵔⴻⵣ ⵉⵙⵎⴻⵖ ⵏⵉⵖ ⵜⴰⵢⵢⴰ, ⴰⴷ ⵡⵛⴻⵏ ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵙⵉⴷⵉⵙ, ⵓⵛⴰ ⴰⴼⵓⵏⴰⵙ ⴰⴷ ⵜ ⴰⵔⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_33","003_21_33","EXO","21","33","33","ⵎⴰⵍⴰ ⵢⴰⵔⵣⴻⵎ ⵃⴻⴷ ⴰⵏⵓ ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵖⵣⴰ ⵃⴻⴷ ⴰⵏⵓ ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵉⴷⵍⵉ, ⵓⵛⴰ ⵉⵡⴹⴰ ⴷⴰⵢⴻⵙ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⴰⵖⵢⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("EX21_34","003_21_34","EXO","21","34","34","ⵅⴻⵏⵏⵉ ⴱⴰⴱ ⵏ ⵡⴰⵏⵓ ⴰⴷ ⵉⵅⴻⴵⴻⵚ. ⴰⴷ ⵢⴰⵔⵔ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉⵎⵎⵓⵜⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_35","003_21_35","EXO","21","35","35","ⵎⴰⵍⴰ ⴰⴼⵓⵏⴰⵙ ⵉⵢⵣⴻⵎ ⴰⴼⵓⵏⴰⵙ ⵏ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴻⵏⵣⴻⵏ ⴰⴼⵓⵏⴰⵙ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⴷ ⴱⴹⴰⵏ ⵜⴰⵎⴻⵏⵢⴰⵜ-ⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴱⴹⴰⵏ ⵄⴰⵡⴻⴷ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX21_36","003_21_36","EXO","21","36","36","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴰⴼⵓⵏⴰⵙ ⵉⴱⴰⵔⵔⴻⵣ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ, ⵓⵛⴰ ⴱⴰⴱ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵉⵃⴹⵉ, ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴰⴼⵓⵏⴰⵙ ⵙ ⵓⴼⵓⵏⴰⵙ ⵓⵛⴰ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵜⵜⵉⵏ ⴰⴷ ⵢⵉⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX21_37","003_21_37","EXO","21","37","37","ⵎⴰⵍⴰ ⵢⵓⵛⴰⵔ ⵃⴻⴷ ⴰⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵓⵛⴰ ⵉⵖⴰⵔⵚ ⴰⵙ ⵏⵉⵖ ⵉⵣⵣⴻⵏⵣ ⵉ-ⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵅⴻⵎⵙⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵓ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⴵⵉ ⵅ ⵢⵉⵊⵊⴻⵏ ⵏ ⵡⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX22_1","003_22_1","EXO","22","1","1","“ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴼ ⵓⵛⴻⴼⴼⴰⵔ ⵄⴰⴷ ⴰⵎ ⵉⵜⵜⴰⵛⴰⵔ, ⵓⵛⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵎⵎⵓⵜ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵡⴻⵏⵏⵉ ⵜ ⵢⵓⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX22_2","003_22_2","EXO","22","2","2","ⵎⴰⵍⴰ ⵜⴻⵏⵇⴰⵔ-ⴷⴷ ⵅⴰⵙ ⵜⴼⵓⵛⵜ, ⴰⴷ ⵅⴰⵙ ⵉⵍⵉⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ. ⴰⴷ ⴰⵙ ⵉⵅⴻⴵⴻⵚ ⵓⵛⴻⴼⴼⴰⵔ ⵎⴰⵔⵔⴰ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵛⴰ, ⴰⴷ ⵉⵎⵎⴻⵏⵣ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵛⵛⴻⴼⴼⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX22_3","003_22_3","EXO","22","3","3","ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⴼ ⵜⵓⵛⵛⴻⴼⴼⴰⵔⵜ ⵜⴻⴷⴷⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰ ⴷ ⴰⴼⵓⵏⴰⵙ ⵉ ⵜⵜ ⵜⵓⵖⴰ ⵏⵉⵖ ⴷ ⴰⵖⵢⵓⵍ ⵏⵉⵖ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX22_4","003_22_4","EXO","22","4","4","ⵎⴰⵍⴰ ⵉⵊⵊⴰ ⵃⴻⴷ ⴰⴷ ⵀⴻⴷⴷⴰⵏ ⵍⵎⴰⵍ ⵉⵢⵢⴰⵔ ⵏⵉⵖ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴰⵢⴻⵙ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⴹⵍⴻⵇ ⴰⵍⴰⵎⵉ ⴰⴷ ⵀⴻⴷⴷⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵉⵅⴻⴵⴻⵚ ⵣⵉ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ ⵓ ⵣⵉ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX22_5","003_22_5","EXO","22","5","5","ⵎⴰⵍⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵜⴻⵍⵇⴻⴼ ⴰⵙⴻⵏⵏⴰⵏ ⵓⵛⴰ ⵜⴻⵛⵛⴰ ⵜⵉⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⵏⵉⵖ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵏⵉⵖ ⵉⵢⵢⴰⵔ, ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX22_6","003_22_6","EXO","22","6","6","ⵎⴰⵍⴰ ⵉⵃⴹⴰ ⵃⴻⴷ ⵉ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⵍⴻⵇⵛⵓⵄ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⵛⴰⵔ ⴰⵙ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⵛⴻⴼⴼⴰⵔ, ⵎⴰⵍⴰ ⵓⴼⵉⵏ ⵜ, ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX22_7","003_22_7","EXO","22","7","7","ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵓⵛⴻⴼⴼⴰⵔ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵇⴰⵔⵔⴱⴻⵏ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX22_8","003_22_8","EXO","22","8","8","ⴽⵓⵍ ⴰⵄⴻⴷⴷⵉ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵏ ⵡⴻⵖⵢⵓⵍ ⵏⵉⵖ ⵏ ⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ ⵏⵉⵖ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵉⵖ ⵏ ⵎⵉⵏ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵏⵏⴰ ⵃⴻⴷ: ‘ⴰⵇⴰ-ⵜ ⴷ ⵡⴰ!’, ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵇⵓⴹⴰⵜ ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵃⴻⴽⵎⴻⵏ ⵍⵇⵓⴹⴰⵜ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵉ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX22_9","003_22_9","EXO","22","9","9","ⵎⴰⵍⴰ ⵉⵡⵛⴰ ⵃⴻⴷ ⵉ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⴰⵖⵢⵓⵍ ⵏⵉⵖ ⴰⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵍⴻⴱⵀⵉⵎⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵃⴹⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⵏⵉⵖ ⵢⴰⵔⵔⴻⵥ ⵏⵉⵖ ⵓⵛⴰⵔⴻⵏ ⵜ, ⴰⵎ ⵡⴰⵔ ⵉⵥⵔⵉ ⵃⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("EX22_10","003_22_10","EXO","22","10","10","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵊⴰⴵⵉⵜ ⵖⴰⵔ ⵙⵉⴷⵉ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⴱⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⵉⵇⴱⴻⵍ ⵜⴰⵊⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴰⴼ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵜ ⵉⵜⵜⵅⴻⴵⴻⵚ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX22_11","003_22_11","EXO","22","11","11","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵛⴰⵔ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵢⴻⵙ, ⴷⵉ ⵍⵃⴰⵍⴰ-ⵢⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX22_12","003_22_12","EXO","22","12","12","ⵎⴰⵍⴰ ⵉⴱⴰⵏ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵎⴻⵣⵣⴻⵇ ⵏⵉⵛⴰⵏ, ⴰⴷ ⵜ ⵢⴰⵡⵉ ⴷ ⴱⵓⵔⵀⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⴵⵉⵚ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵎⴻⵣⵣⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX22_13","003_22_13","EXO","22","13","13","ⵎⴰⵍⴰ ⵢⴰⵔⴹⴻⵍ ⵃⴻⴷ ⵛⴰ ⵅ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴰⵔⵔⴻⵥ ⵏⵉⵖ ⵜⴻⵎⵎⵓⵜ ⴷⵉ ⵍⵖⴰⵢⴻⴱ ⵏ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵜⵜ ⵉⵅⴻⴵⴻⵚ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX22_14","003_22_14","EXO","22","14","14","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴱⴰⴱ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵃⴹⴰⵔ, ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵅⵉⴵⴰⵚ. ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵛⵔⴰ ⵜⵜ ⵅⴰⵙ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⵍⴻⵅⵍⴰⵚ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX22_15","003_22_15","EXO","22","15","15","“ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⴰⵔⴹⴻⵏ ⵃⴻⴷ ⵅ ⵛⴰ ⵏ ⵜⴻⵄⵣⴰⵍⴻⵛⵜ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⵜ ⵉⵅⴹⵉⴱ ⵃⴻⴷ ⵄⴰⴷ, ⵓⵛⴰ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵚⵚⴰⴷⴰⵇ ⵉⵎⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX22_16","003_22_16","EXO","22","16","16","ⵎⴰⵍⴰ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⴰⵙ ⵜⵜ ⵉⵡⵛ, ⴰⴷ ⴰⵙ ⵉⵡⵣⴻⵏ ⵄⴰⴷ ⵚⵚⴰⴷⴰⵇ ⵏ ⵜⴻⵄⵣⵓⵔⴰⵢ ⵙ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX22_17","003_22_17","EXO","22","17","17","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵜⴰⵙⴻⵃⵃⴰⵔⵜ ⴰⴷ ⵜⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX22_18","003_22_18","EXO","22","18","18","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX22_19","003_22_19","EXO","22","19","19","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⴻⵀⵀⴱⴻⵏ ⵛⴰ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵖⵉⵔ ⵉ ⵙⵉⴷⵉ ⵡⴰⵀⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⴻⵎ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("EX22_20","003_22_20","EXO","22","20","20","ⵡⴰⵔ ⴷⴷⴻⴵⴻⵎ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵣⴻⵢⵢⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX22_21","003_22_21","EXO","22","21","21","ⵡⴰⵔ ⵜⵜⴷⴻⴵⵉ ⵛⴰ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵢⵓⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX22_22","003_22_22","EXO","22","22","22","ⵎⴰⵍⴰ ⵜⵉⵡⴹⴻⴷ ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵖⵓⵢ-ⴷⴷ ⵖⴰⵔⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵙ ⵓⵖⵉⵍ ⴰⴷ ⵙⵍⴻⵖ ⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX22_23","003_22_23","EXO","22","23","23","ⴰⴷ ⵢⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⵖⴻⵖ ⵙ ⵙⵙⵉⴼ, ⵜⵉⵎⴻⵟⵟⴰ ⵏⵡⴻⵎ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⵉⵊⵊⴰⵍ ⴷ ⵜⴰⵔⵔⴰⵡⵜ ⵏⵡⴻⵎ ⴷ ⵉⵢⵓⵊⵉⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX22_24","003_22_24","EXO","22","24","24","ⵎⴰⵍⴰ ⵜⴰⵔⴻⴹⵍⴻⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵉ ⴷⵉⵏ ⵖⴰⵔⴻⴽ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵜⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵉⵜⵜⴻⴳⴳ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵡⴰⵙ: ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⴻⴳⴳ ⵛⴰ ⴰⵔⵔⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("EX22_25","003_22_25","EXO","22","25","25","ⵎⴰⵍⴰ ⵜⴻⴽⵙⵉⴷ ⴰⵔⵔⵓⴹ ⵏ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴷ ⴰⴹⵎⴰⵏ, ⴰⵔⵔ ⴰⵙ ⵜ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX22_26","003_22_26","EXO","22","26","26","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵎⵖⵉⵔ ⴰⵍⴻⵃⵃⴰⴼ ⵡⴰⵏⵉⵜⴰ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⵔⵓⴹ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵏⵏⴻⵙ. ⵎⵉⵏ ⴷⵉ ⵖⴰ ⵉⵟⵟⴻⵚ ⵅⴻⵏⵏⵉ? ⵅⵎⵉ ⵖⴰⵔⵉ ⴷⴷ ⵖⴰ ⵉⵙⵖⵓⵢ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵙⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵇⴰ ⴷ ⴰⵃⵏⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("EX22_27","003_22_27","EXO","22","27","27","ⵡⴰⵔ ⵜⵜⵛⴻⵇⵇⵉⴼ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵔ ⵜⵜⴻⴽⴽⵯⴰⵔ ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX22_28","003_22_28","EXO","22","28","28","ⵡⴰⵔ ⵙⵄⴻⵟⵟⴰⵍⴰ ⵜⴰⵛⵛⵓⵔⴻⵜ ⵏ ⵜⵎⴻⵢⵔⴰ ⵏⵏⴻⵛ ⵏⵉⵖ ⴰⵃⵍⴰⵢ ⵏ ⵜⴻⵢⵙⴰⵔⵜ ⵏⵏⴻⵛ. ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⵓⵍⴰ ⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX22_29","003_22_29","EXO","22","29","29","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵙ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴻⵛ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵛ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⴽ-ⴷ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵓⵛⴰ ⵖⴰⵔ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏ ⵜⴻⵡⵛⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX22_30","003_22_30","EXO","22","30","30","ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⴰⵢⵙⵓⵎ ⵉ ⵉⵜⵜⵡⴰⵎⴻⵣⵣⵇⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ. ⴰⴷ ⵜ ⵜⴻⵏⴹⴰⵔⴻⵎ ⵉ ⵢⵉⵟⴰⵏ.”    ");
INSERT INTO rift_vpl VALUES ("EX23_1","003_23_1","EXO","23","1","1","“ⵡⴰⵔ ⵙⵙⵓⴼⴼⵓⵖ ⵍⴻⵅⴱⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ⵡⴰⵔ ⵜⵜⵉⵛ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵏ ⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("EX23_2","003_23_2","EXO","23","2","2","ⵡⴰⵔ ⴰⵔⴻⴷⴷⴻⴼ ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵍⵖⴰⵔ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⴰⵍ ⵖⴰ ⵜⵎⴻⵢⵢⵍⴻⴷ ⵜⴻⴳⴳⵯⴻⵊⴻⴷ ⵅ ⵍⵃⴻⵇⵇ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵟⵟⴰⵙ, ⴰⴷ ⵜⴼⴰⵔⵖⴻⴷ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("EX23_3","003_23_3","EXO","23","3","3","ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵔⵉⵃ ⵛⴰ ⴰⴽ-ⴷ ⵍⵎⴻⵙⴽⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_4","003_23_4","EXO","23","4","4","ⵎⴰⵍⴰ ⵜⴻⵍⵇⵉⴷ ⴰⴼⵓⵏⴰⵙ ⵏⵉⵖ ⴰⵖⵢⵓⵍ ⵉⵡⴻⴷⴷⴰⵔ ⵏ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵜ ⵜⴰⵔⵔⴻⴷ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_5","003_23_5","EXO","23","5","5","ⵎⴰⵍⴰ ⵜⴻⵥⵔⵉⴷ ⴰⵖⵢⵓⵍ ⵏ ⵡⴻⵏⵏⵉ ⵜⵛⴰⵔⵔⵀⴻⴷ ⵉⵡⴹⴰ ⵙ ⴷⴷⵇⴻⵍ ⵏⵏⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵊⵊⴻⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴷ ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴷ ⵜⴼⴻⴽⴽⴻⵎ ⴰⵖⵢⵓⵍ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EX23_6","003_23_6","EXO","23","6","6","ⵡⴰⵔ ⵙⴼⴰⵔⵔⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵉ ⴷⵉⵏ ⵖⴰⵔⴻⴽ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX23_7","003_23_7","EXO","23","7","7","ⴱⴻⵄⵄⴻⴷ ⵅ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⵖⴻⵛⵛⴻⵏ. ⵡⴰⵔ ⵏⴻⵇⵇ ⴰⴼⵓⵔⵔⵉ ⵏⵉⵖ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴱⴰⵔⵔⵉⵖ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_8","003_23_8","EXO","23","8","8","ⵡⴰⵔ ⴽⴻⵙⵙⵉ ⵜⴰⵔⵣⴻⴼⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵔⵣⴻⴼⵜ ⵜⴻⵙⵙⴷⴰⵔⵖⴰⵍ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵓ ⵜⴻⵙⵙⴼⴰⵔⵔⴰⵖ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_9","003_23_9","EXO","23","9","9","ⵡⴰⵔ ⵜⵣⴻⵢⵢⴰⵔⴻⵎ ⵅ ⵓⴱⴰⵔⵔⴰⵏⵉ. ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵏⵏⴻⴼⵙ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX23_10","003_23_10","EXO","23","10","10","ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵜⵣⴰⵔⵄⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX23_11","003_23_11","EXO","23","11","11","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⵜ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⴰⵔⵅⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ⵓⵛⴰ ⵎⵉⵏ ⵖⴰ ⵊⵊⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵙ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏⵏⴻⵛ ⴷ ⵣⵣⵉⵜⵓⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX23_12","003_23_12","EXO","23","12","12","ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵛ ⴷ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵢⴰⵔⵔ ⵏⵏⴻⴼⵙ ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX23_13","003_23_13","EXO","23","13","13","ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ, ⵃⴹⴰⵎ ⵜ. ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔⴻⵎ ⵉⵙⴻⵎ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⵡⴰⵔ ⵜⵜⴻⵙⵍⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX23_14","003_23_14","EXO","23","14","14","ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴷ ⴰⵢⵉ ⵜⵄⴻⵢⵢⴷⴻⵎ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("EX23_15","003_23_15","EXO","23","15","15","ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴰⴷ ⵜ ⵜⴻⵃⴹⴰⵎ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵓⵔⴻⵖ ⵏⴻⵛⵛ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⴱⵉⴱ, ⵎⵉⵏⵣⵉ ⴷⴰⵢⴻⵙ ⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ⵡⴰⵔ ⴷⴷ-ⵜⵜⵓⵙⵉⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX23_16","003_23_16","EXO","23","16","16","ⵃⴹⴰⵎ ⵄⴰⵡⴻⴷ ⵍⵄⵉⴷ ⵏ ⵜⵎⴻⵢⵔⴰ, ⵍⵄⵉⴷ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⵉ ⵜⵣⴰⵔⵄⴻⴷ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵓ ⵍⵄⵉⴷ ⵏ ⵓⵙⵎⵓⵏⵉ ⵏ ⵚⵚⴰⴱⴻⵜ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX23_17","003_23_17","EXO","23","17","17","ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴷ ⴹⵀⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX23_18","003_23_18","EXO","23","18","18","ⵡⴰⵔ ⵜⵜⵇⴻⴷⴷⴰⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉⵏⵓ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵅⴻⵎⵎⴰⵔⴻⵏ, ⵓ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⵄⵉⴷ ⵉⵏⵓ ⵡⴰⵔ ⵜⵜⵏⵓⵙⵉ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ ⴰⵍ ⵚⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("EX23_19","003_23_19","EXO","23","19","19","ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜ ⵜⴰⵡⵢⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵙⵏⴻⵏⵏⵉ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵙ ⵓⵖⵉ ⵏ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX23_20","003_23_20","EXO","23","20","20","ⵅⵣⴰⵔ, ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵃⴹⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵢⴰⵡⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX23_21","003_23_21","EXO","23","21","21","ⵃⴹⴰ ⴰⵔⴻⵏⴷⴰⴷ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵅⴰⵙ ⵙⵙⴰⵔⵣⵉⴳ ⵛⴰ ⵍⴻⵄⵎⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵉⵙⴻⵎ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX23_22","003_23_22","EXO","23","22","22","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ, ⴰⴷ ⵉⵍⵉⵖ ⴷ ⵍⴻⵄⴷⵓ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵃⵚⴰⵔⴻⵖ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_23","003_23_23","EXO","23","23","23","ⵎⵉⵏⵣⵉ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ ⴰⴷ ⵢⵉⵍⵉ ⵣⵣⴰⵜⴻⴽ, ⴰⴷ ⵛⴻⴽ ⵙⵙⵉⴷⴼⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("EX23_24","003_23_24","EXO","23","24","24","ⵡⴰⵔ ⵜⵜⴱⴻⵏⴷⵉⵇ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⵏⵉⵖ ⴰⴷ ⵜⴻⵏ ⵜⵄⴻⴱⴷⴻⴷ ⵏⵉⵖ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜᵉⵜⴻⵃⵃⵉⴷ ⵇⴰⵄ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵥⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_25","003_23_25","EXO","23","25","25","ⴰⴷ ⵜⵄⴻⴱⴷⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵛ ⴷ ⵡⴰⵎⴰⵏ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX23_26","003_23_26","EXO","23","26","26","ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵓⵎⵉ ⵉⵡⴹⴰ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵉⵖ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX23_27","003_23_27","EXO","23","27","27","ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵏⴻⵅⵍⵉⵄ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ, ⴰⴷ ⵙⵙⵅⴰⵔⴻⵡⴹⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰ ⵜⴰⴼⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⴽ ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_28","003_23_28","EXO","23","28","28","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵔⴻⵣⵣⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵖⴰ ⵢⴰⵥⵥⵍⴻⵏ ⵅ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX23_29","003_23_29","EXO","23","29","29","ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⴰⵥⵥⵍⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵏⵡⴻⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵅⵍⴰ ⵓ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⵎⴰⵔⵏⵉⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX23_30","003_23_30","EXO","23","30","30","ⵙ ⵛⵡⴰⵢ ⵛⵡⴰⵢ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵥⵥⵍⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵏⴻⵛⵛ, ⴰⵍ ⵖⴰ ⵜⴻⵎⵎⴰⵔⴻⵏⵢⴻⴷ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX23_31","003_23_31","EXO","23","31","31","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵢⵎⵉⵔⴻⵏ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵍⴻⵅⵍⴰ ⴰⵍ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴰⵥⵥⵍⴻⴷ ⵣⵉ ⵣⵣⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX23_32","003_23_32","EXO","23","32","32","ⵡⴰⵔ ⴽⵉⴷⵙⴻⵏ ⵜⵜⴻⴳⴳ ⵍⵄⴰⵀⴷ ⵏⵉⵖ ⴰⴽ-ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX23_33","003_23_33","EXO","23","33","33","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴰⵔⵔⵉⵏ ⴰⴷ ⴰⴽⵉⴷⵉ ⵜⴻⵅⴹⵉⴷ. ⵎⴰⵍⴰ ⵜⵄⴻⴱⴷⴻⴷ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴼⴻⵅ ⵉ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("EX24_1","003_24_1","EXO","24","1","1","ⵓⵛⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵎⵓⵙⴰ: “ⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ, ⴷ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵎ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("EX24_2","003_24_2","EXO","24","2","2","ⵎⵓⵙⴰ ⵡⴻⵃⵃⴷⴻⵙ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵇⴰⵔⵔⴱⴻⵏ ⵏⵉⵜⵏⵉ. ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵉⵜⵜⴳⵉⵄⵄⵉⴷ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX24_3","003_24_3","EXO","24","3","3","ⵎⵓⵙⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵓⵛⴰ ⵉⵅⴻⴱⴱⴰⵔ ⵍⴳⴻⵏⵙ ⵅ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵏⵏⴰⵏ: “ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴻⴳⴳ.”    ");
INSERT INTO rift_vpl VALUES ("EX24_4","003_24_4","EXO","24","4","4","ⵎⵓⵙⴰ ⵢⵓⵔⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ. ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏ ⵡⴻⵥⵔⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX24_5","003_24_5","EXO","24","5","5","ⵉⵙⵙⴻⴽⴽ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⵉⵖⴰⵔⵚⵉ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⵉ ⵏ ⵍⴻⵀⵏⴰ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX24_6","003_24_6","EXO","24","6","6","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⴰⵣⵢⴻⵏ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵟⵟⴱⴰⵚⵉ ⵓⵛⴰ ⴰⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵣⴻⴵⴻⵄ ⵉ-ⵜⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX24_7","003_24_7","EXO","24","7","7","ⵉⴽⵙⵉ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵍⵄⴰⵀⴷ, ⵉⵖⵔⴰ ⵉ-ⵜ ⵅ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜ ⵏⴻⴳⴳ, ⴰⴷ ⵜ ⵏⵟⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("EX24_8","003_24_8","EXO","24","8","8","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⵔⵓⵛⵛ ⵉ-ⵜⴻⵏ ⵅ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⵏⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX24_9","003_24_9","EXO","24","9","9","ⵉⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ ⴷ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX24_10","003_24_10","EXO","24","10","10","ⵥⵔⵉⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵜⵓⵖⴰ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ, ⵉⵚⴼⴰ ⴰⵎ ⵓⵊⴻⵏⵏⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX24_11","003_24_11","EXO","24","11","11","ⵡⴰⵔ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵅⵣⴰⵔⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵛⵛⵉⵏ, ⵙⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX24_12","003_24_12","EXO","24","12","12","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵇⵇⵉⵎ ⴷⵉⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ, ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵍⵓⵎⴰⵔⴰⵜ ⵜⵉⵏⵏⵉ ⵓⵔⵉⵖ ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("EX24_13","003_24_13","EXO","24","13","13","ⵉⴽⴽⴰⵔ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX24_14","003_24_14","EXO","24","14","14","ⵉⵏⵏⴰ ⵉ ⵉⵎⵖⴰⵔⴻⵏ: “ⵔⴰⵊⴰⵎ ⴰⵏⴻⵖ ⴷⴰⵏⵉⵜⴰ ⴰⵍ ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵉ ⵖⴰ ⵏⴻⴷⵡⴻⵍ. ⵅⵣⴰⵔ, ⵀⴰⵔⵓⵏ ⴷ ⵃⵓⵔ ⴰⴽⵉⴷⵡⴻⵎ. ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵖⴰⵔⴻⵙ ⴷⴷⵄⴰⵡⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵔⴰⵃ.” ");
INSERT INTO rift_vpl VALUES ("EX24_15","003_24_15","EXO","24","15","15","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ, ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴷⵍⴰ ⴰⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX24_16","003_24_16","EXO","24","16","16","ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵓ ⴰⵙⴻⵢⵏⵓ ⵉⴷⵍⴰ ⵉ-ⵜ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵅ ⵎⵓⵙⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵙⴻⵢⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX24_17","003_24_17","EXO","24","17","17","ⴰⵙⵛⴰⵏ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX24_18","003_24_18","EXO","24","18","18","ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵓⵙⴻⵢⵏⵓ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴷⵔⴰⵔ. ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⵉⵇⵇⵉⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX25_1","003_25_1","EXO","25","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX25_2","003_25_2","EXO","25","2","2","“ⵉⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵙⵙⴳⴰⵄⵄⴷⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ. ⵣⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵄⴰⵔⵔⴻⵏ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⵙⵉⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴰⵄⵄⴻⴷ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("EX25_3","003_25_3","EXO","25","3","3","ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴽⵙⵉⴷ ⵣⵣⴰⵢⵙⴻⵏ: ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("EX25_4","003_25_4","EXO","25","4","4","ⴷ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵛⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX25_5","003_25_5","EXO","25","5","5","ⴷ ⵉⵍⵎⴰⵡⴻⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⴷ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ, ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("EX25_6","003_25_6","EXO","25","6","6","ⵣⵣⴻⵛⵜ ⵉ ⵜⴼⴰⵡⵜ ⵏ ⵍⵇⴻⵏⴷⵉⵍ, ⵍⴻⵄⵟⵓⵔ ⵉ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵓ ⵉ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX25_7","003_25_7","EXO","25","7","7","ⵉⵥⵔⴰ ⵏ ⵓⵏⵉⴽⵙ ⴷ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵏ ⵅ ⵓⴱⴰⵍⵟⵓ ⵓ ⵅ ⵜⴰⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX25_8","003_25_8","EXO","25","8","8","ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵉⵛⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_9","003_25_9","EXO","25","9","9","ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⴻⵛⵏⴻⵖ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵎⴻⴷⵢⴰ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵎⴻⴷⵢⴰ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_10","003_25_10","EXO","25","10","10","ⴰⴷ ⴳⴳⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ. ⴰⴷ ⵜⵉⵍⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_11","003_25_11","EXO","25","11","11","ⴰⴷ ⵜ ⵜⵜⵛⴻⵍⵍⴻⴷ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⵣⵉ ⴷⴰⵅⴻⵍ ⵓ ⵣⵉ ⴱⴰⵔⵔⴰ ⴰⴷ ⵜⵜ ⵜⵛⴻⵍⵍⴻⴷ, ⵓⵛⴰ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⴰⴷ ⴰⵙ ⵜⴻⵏⵏⴹⴻⴷ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX25_12","003_25_12","EXO","25","12","12","ⴰⴷ ⴰⵙ ⵜⴻⵙⵙⴼⴻⵙⵢⴻⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ. ⴰⴷ ⵜⴻⵏⵜ ⵜⵛⴻⴷⴷⴻⴷ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵉ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX25_13","003_25_13","EXO","25","13","13","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴷⵍⴻⴷ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX25_14","003_25_14","EXO","25","14","14","ⵙⵉⴷⴼⴻⵎ ⵉⵄⵓⵎⴰⴷ ⴷⵉ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⵜⴰⴱⵓⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX25_15","003_25_15","EXO","25","15","15","ⵉⵄⵓⵎⴰⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷⵉ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵜⵜⴰⴱⵓⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⵏ ⵜⵜⴻⴽⴽⵙⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EX25_16","003_25_16","EXO","25","16","16","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵛⵛⵀⴰⴷⴻⵜ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ, ⴷⵉ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX25_17","003_25_17","EXO","25","17","17","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("EX25_18","003_25_18","EXO","25","18","18","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉⵄⴷⴻⵍ ⵙ ⵡⴻⴼⴹⵉⵙ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⴼⴼⵖⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ.    ");
INSERT INTO rift_vpl VALUES ("EX25_19","003_25_19","EXO","25","19","19","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵢⵉⵅⴻⴼ ⵓ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX25_20","003_25_20","EXO","25","20","20","ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⵍⴻⵏ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ. ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉⵊⵊ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⵎⴰⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵖⴰⵔ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX25_21","003_25_21","EXO","25","21","21","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵅ ⵜⵜⴰⴱⵓⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ ⴷⵉ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX25_22","003_25_22","EXO","25","22","22","ⴷⵉⵏⵏⵉ ⵉ ⴽⵉⵛ ⵖⴰ ⵎⵎⴻⵍⵇⵉⵖ ⵓⵛⴰ ⴰⴷ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵖ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ, ⵣⵉ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵓⵎⵓⵔⴻⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX25_23","003_25_23","EXO","25","23","23","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⵣⴻⵡⴹⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵉⵊⵊⴻⵏ ⵓⵖⵉⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⵊⴻⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_24","003_25_24","EXO","25","24","24","ⴰⴷ ⵜⵜ ⵜⴻⴷⵍⴻⴷ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵜⵎⴰ ⵏⵏⴻⵙ ⵉⵊⵊ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX25_25","003_25_25","EXO","25","25","25","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⵎⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵏ ⵉⵊⵊⴻⵏ ⵛⴱⴰⵔ ⵏ ⵓⴼⵓⵙ ⵓ ⵖⴰⵔ ⵜⵎⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX25_26","003_25_26","EXO","25","26","26","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⵛⴻⴷⴷⴻⴷ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_27","003_25_27","EXO","25","27","27","ⵜⵉⵅⵔⴰⵣⵉⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵓⴷⵙⴻⵏⵜ ⵉ ⵜⵎⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵏ ⵜⵣⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EX25_28","003_25_28","EXO","25","28","28","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ, ⴰⴷ ⵜⴻⵏ ⵜⵖⴻⴵⴼⴻⴷ ⵙ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⵜⴰⵣⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EX25_29","003_25_29","EXO","25","29","29","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵟⵟⴱⴰⵚⵉ ⵏⵏⴻⵙ ⴷ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⵏⵏⴻⵙ ⴷ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴽⵉⵙⴰⵏ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵖⴰ ⴼⴰⵔⵔⵖⴻⵏ. ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_30","003_25_30","EXO","25","30","30","ⵅ ⵜⵣⴻⵡⴹⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX25_31","003_25_31","EXO","25","31","31","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵙ ⵡⴻⴼⴹⵉⵙ ⵏ ⵡⴻⵎⵣⵉⵍ. ⴰⴼⵓⴷ ⴰⴽ-ⴷ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴷ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵍⴽⵉⵙⴰⵏ ⵏⵏⴻⵙ ⴷ ⵜⵄⴻⴱⴱⵓⵣⵉⵏ ⵏⵏⴻⵙ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EX25_32","003_25_32","EXO","25","32","32","ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵇⴻⵏⴷⵉⵍ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX25_33","003_25_33","EXO","25","33","33","ⵜⵍⴰⵜⴰ ⵏ ⵍⴽⵉⵙⴰⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷⵉ ⴼⵓⵔⵎⴰ ⵏ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵏ ⴵⴻⵡⵣ ⴰⴽ-ⴷ ⵜⵄⴻⴱⴱⵓⵣⵜ ⴷ ⵏⵏⴻⵡⵡⴰⵛ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵖⵉⵍ ⵏⵏⴻⵖⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴽⵉⵙⴰⵏ ⴷⵉ ⴼⵓⵔⵎⴰ ⵏ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵏ ⴵⴻⵡⵣ ⴰⴽ-ⴷ ⵜⵄⴻⴱⴱⵓⵣⵜ ⴷ ⵏⵏⴻⵡⵡⴰⵛ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX25_34","003_25_34","EXO","25","34","34","ⵖⴰⵔ ⵍⵇⴻⵏⴷⵉⵍ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⴽⵉⵙⴰⵏ ⴷⵉ ⴼⵓⵔⵎⴰ ⵏ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵏ ⴵⴻⵡⵣ, ⴰⴽ-ⴷ ⵜⵄⴻⴱⴱⵓⵣⵉⵏ ⵏⵙⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_35","003_25_35","EXO","25","35","35","ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵙⴰⴷⵓ ⵜⵢⵓⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵓ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵙⴰⴷⵓ ⵜⵢⵓⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵓ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵙⴰⴷⵓ ⵜⵢⵓⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵉ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX25_36","003_25_36","EXO","25","36","36","ⵜⵉⵄⴻⴱⴱⵓⵣⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵖⴰⴵⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ-ⴷⴷ ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵜᵉⵜⵜⵡⴰⵄⴷⴻⵍ ⵙ ⵡⴻⴼⴹⵉⵙ ⵏ ⵡⴻⵎⵣⵉⵍ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_37","003_25_37","EXO","25","37","37","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵙⴻⵜⵜⴰ ⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ ⵅ ⵍⵇⴻⵏⴷⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵛⴻⵏⵜ ⵜⴼⴰⵡⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵓⵊⴻⵎⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("EX25_38","003_25_38","EXO","25","38","38","ⵜⵉⵊⴻⵇⵇⴰⴹⵉⵏ ⵏ ⵜⴻⴼⵜⵉⵍⵜ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX25_39","003_25_39","EXO","25","39","39","ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵍⵇⴻⵏⴷⵉⵍ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX25_40","003_25_40","EXO","25","40","40","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵓⵎⴻⴷⵢⴰ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵉⵜⵜⵡⴰⵎⵍⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ.”   * ");
INSERT INTO rift_vpl VALUES ("EX26_1","003_26_1","EXO","26","1","1","“ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⴰⴽ-ⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ. ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_2","003_26_2","EXO","26","2","2","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏⵜ ⵢⵉⵍⵉ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EX26_3","003_26_3","EXO","26","3","3","ⵅⴻⵎⵙⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⴰⴷ ⵜⴻⵏⵜ ⵙⵙⵎⵓⵏⴻⵏ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⴰⴷ ⵜⴻⵏⵜ ⵙⵙⵎⵓⵏⴻⵏ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_4","003_26_4","EXO","26","4","4","ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵎⴰⵏⵉ ⵜⵜ ⵖⴰ ⵙⵙⵎⵓⵏⴻⵏ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵙⴰⵔⴰⵡⵉⵏ ⵜⵉⴷⴻⵃⵎⴰⵏⵉⵏ. ⴰⵎⵎⵓ ⵉ ⵜⴻⵏⵜ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_5","003_26_5","EXO","26","5","5","ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵓ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⵜⵉⵙⴰⵔⴰⵡⵉⵏ ⴰⴷ ⵎⵎⴻⵍⵇⴰⵏⵜ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_6","003_26_6","EXO","26","6","6","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX26_7","003_26_7","EXO","26","7","7","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵉⵊⴰⵍⵜⵉⵍⵉⵏ ⵙ ⵛⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ. ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵃⵉⵟⴰⵛ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_8","003_26_8","EXO","26","8","8","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⴰⴷ ⵜⵉⵍⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵃⵉⵟⵄⴰⵛ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏⵜ ⵢⵉⵍⵉ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EX26_9","003_26_9","EXO","26","9","9","ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵅⴻⵎⵙⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵄⴰⵡⴻⴷ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ. ⵜⴰⵊⴰⵔⵜⵉⵍⵜ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵜⴹⴻⴼⵚⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_10","003_26_10","EXO","26","10","10","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵖⴰⵔ ⵓⵙⴻⵍⵇⵉ, ⵓⵛⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵅ ⵜⵎⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵖⴰⵔ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_11","003_26_11","EXO","26","11","11","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵏⵏⵃⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⴷⵉ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⴰⵇⵉⴹⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_12","003_26_12","EXO","26","12","12","ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵏ ⵓⵇⵉⴹⵓⵏ, ⴰⵣⵢⴻⵏ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵏⵏⵉ ⵉⵛⴻⵟⵟⴻⵏ ⴰⴷ ⵢⴰⵢⴻⵍ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX26_13","003_26_13","EXO","26","13","13","ⵣⵉ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ, ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴰⴷ ⵢⴰⵢⴻⵍ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ, ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵍⴻⵃⵃⴻⴼ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵉ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_14","003_26_14","EXO","26","14","14","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉ ⵓⵇⵉⴹⵓⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵛⵜ ⵏ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX26_15","003_26_15","EXO","26","15","15","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_16","003_26_16","EXO","26","16","16","ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴷⴰⵢⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⵉⵔⵓ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_17","003_26_17","EXO","26","17","17","ⵉ ⴽⵓⵍ ⵜⴰⴼⵍⴰⵡⵜ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵍⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵎⴻⵍⵇⴰⵏ ⵜⵡⴻⵍⵜⵎⴰⵜⵉⵏ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX26_18","003_26_18","EXO","26","18","18","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵜⵉⴼⴻⵍⵡⵉⵏ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EX26_19","003_26_19","EXO","26","19","19","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵙⴰⴷⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵜⴰⴼⵍⴰⵡⵜ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX26_20","003_26_20","EXO","26","20","20","ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵉ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EX26_21","003_26_21","EXO","26","21","21","ⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵉ ⴽⵓⵍ ⵜⴰⴼⵍⴰⵡⵜ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵜⴰⴼⵍⴰⵡⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_22","003_26_22","EXO","26","22","22","ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵙⴻⵜⵜⴰ ⵏ ⵜⴼⴻⵍⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_23","003_26_23","EXO","26","23","23","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵉ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX26_24","003_26_24","EXO","26","24","24","ⵣⵉ ⵙⵡⴰⴷⴷⴰⵢ ⴰⴷ ⵉⵍⵉⵏⵜ ⵚⵇⴻⵏⵜ ⴰⵎ ⵡⴰⵛⵏⵉⵡⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵍⵉⵏⵜ ⵏⵉⵛⴰⵏ ⴷ ⵉⵛⵜⴻⵏ ⴰⵍ ⵖⴰ ⴰⵡⴹⴻⵏⵜ ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵅⵔⴰⵣⵜ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX26_25","003_26_25","EXO","26","25","25","ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵜⵎⴻⵏⵢⴰ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⴰⴽ-ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ⵅⴻⵏⵏⵉ ⵙⴻⵟⵟⴰⵛ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵜⴰⴼⵍⴰⵡⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_26","003_26_26","EXO","26","26","26","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ, ⵉⵏⵏⵉ ⵖⴰ ⵉⵄⴷⵓⵏ ⵅ ⵜⴼⴻⵍⵡⵉⵏ, ⵅⴻⵎⵙⴰ ⵉ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ");
INSERT INTO rift_vpl VALUES ("EX26_27","003_26_27","EXO","26","27","27","ⵓ ⵅⴻⵎⵙⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵉ ⵜⴼⴻⵍⵡⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵓ ⵅⴻⵎⵙⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵉ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX26_28","003_26_28","EXO","26","28","28","ⵜⴰⵃⵏⴰⵛⵜ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⴷⵉ ⵍⵡⴻⵙⵟ ⴰⴷ ⵜⴻⵄⴷⵓ ⵅ ⵜⴼⴻⵍⵡⵉⵏ ⴷⵉ ⵍⵡⴻⵙⵟ, ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵢⵉⵅⴻⴼ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX26_29","003_26_29","EXO","26","29","29","ⴰⴷ ⵜⵖⴻⴵⴼⴻⴷ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵙ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵅⵔⴰⵣⵉⵏ ⵏⵙⴻⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ. ⴰⴷ ⵜⴻⴷⵍⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX26_30","003_26_30","EXO","26","30","30","ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵎⴻⴷⵢⴰ ⵏ ⵍⴻⴱⵏⵉ ⵏⵏⵉ ⴷ ⴰⵛ ⵉⵜⵜⵡⴰⵎⵍⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX26_31","003_26_31","EXO","26","31","31","ⴰⴷ ⵜⴻⴳⴳⴻⴹ ⵉⵊⵊ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⴼⴻⵏⵏⴰⵏ, ⵓⵛⴰ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴰⴷ ⵅⴰⵙ ⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX26_32","003_26_32","EXO","26","32","32","ⴰⴷ ⵜ ⵜⴰⵢⵍⴻⴷ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵉ ⵉⴷⵍⵉⵏ ⵙ ⵡⵓⵔⴻⵖ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX26_33","003_26_33","EXO","26","33","33","ⴰⴷ ⵜⴰⵢⵍⴻⴷ ⴰⵍⴻⵃⵃⴰⴼ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ ⵏ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴰⵅⴻⵍ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵓⵛⴰ ⴰⵍⴻⵃⵃⴰⴼ ⴰⴷ ⵉⴱⴹⴰ ⵊⴰⵔ ⵓⵇⴻⴷⴷⴰⵙ ⴷ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX26_34","003_26_34","EXO","26","34","34","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵅ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴻⴳ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX26_35","003_26_35","EXO","26","35","35","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵣⴻⵡⴹⴰ ⴱⴰⵔⵔⴰ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵣⴻⵡⴹⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵣⴻⵡⴹⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX26_36","003_26_36","EXO","26","36","36","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⵡⴰⵇ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ, ⴰⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵓⵅⴻⵢⵢⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("EX26_37","003_26_37","EXO","26","37","37","ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉ ⴰⵔⵡⴰⵇ ⵅⴻⵎⵙⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵛⴻⵍⵍⴻⴷ ⵙ ⵡⵓⵔⴻⵖ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵉ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵜⴼⴻⵙⵢⴻⴷ ⵅⴻⵎⵙⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵏⵏⵃⴰⵙ.” * ");
INSERT INTO rift_vpl VALUES ("EX27_1","003_27_1","EXO","27","1","1","“ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵉⵔⵓ. ⴰⴷ ⵢⵉⵍⵉ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_2","003_27_2","EXO","27","2","2","ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⵍⴻⵃⵃⴼⴻⴷ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_3","003_27_3","EXO","27","3","3","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵢⴷⵓⵔⵉⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵉⵖⵖⴻⴹ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵉⵖⴻⵏⵊⴰⵢⴻⵏ ⵏⵏⴻⵙ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵏⵏⴻⵙ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⴼⵓⵔⵛⴰⵢⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ ⵏⵏⴻⵙ. ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_4","003_27_4","EXO","27","4","4","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⵔⴰⵛⵛⴰ, ⵉⵛⵜ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵏⵏⵃⴰⵙ, ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵓⵎⵓⴷⵉ ⵏⵏⵉ, ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_5","003_27_5","EXO","27","5","5","ⴰⴷ ⵜ ⵜⵣⴻⵢⵢⴰⵔⴻⴷ ⵙⴰⴷⵓ ⵉ ⵜⵎⴰ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⵙⵡⴰⴷⴷⴰⵢ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵓⵎⵓⴷⵉ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX27_6","003_27_6","EXO","27","6","6","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵄⵓⵎⴰⴷ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵍⴻⵃⵃⴼⴻⴷ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_7","003_27_7","EXO","27","7","7","ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵉⴷⴼⴻⵏ ⴷⵉ ⵜⴻⵅⵔⴰⵣⵉⵏ. ⴰⴷ ⵉⵍⵉⵏ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵅⵎⵉ ⵜ ⵖⴰ ⴰⵔⴱⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_8","003_27_8","EXO","27","8","8","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵊⵊ ⵏ ⵍⵅⴰⵡⵉ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴼⴻⵍⵡⵉⵏ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵉⵎⵍⴰ ⵅ ⵡⴻⴷⵔⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵜ ⵖⴰ ⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX27_9","003_27_9","EXO","27","9","9","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⴻⵎⵔⴰⵃ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵉⵣⴰⵔⴰⵜ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⴽⵓⵍ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵏ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_10","003_27_10","EXO","27","10","10","ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⴰⴷ ⵉⵍⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX27_11","003_27_11","EXO","27","11","11","ⴰⵎⵎⵓ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵎⴰⵍ, ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ, ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵎⵢⴰ ⵉⵖⴰⴵⴻⵏ. ⴰⴷ ⵉⵍⵉⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⴰⴷ ⵉⵍⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX27_12","003_27_12","EXO","27","12","12","ⴷⵉ ⵜⵉⵔⵓ ⵏ ⵍⴻⵎⵔⴰⵀ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ, ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⴽ-ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_13","003_27_13","EXO","27","13","13","ⵜⵉⵔⵓ ⵏ ⵍⴻⵎⵔⴰⵃ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ, ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵎⵙⵉⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_14","003_27_14","EXO","27","14","14","ⵍⵉⵣⴰⵔⴰⵜ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⴰⴷ ⵉⵍⵉⵏⵜ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ, ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_15","003_27_15","EXO","27","15","15","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵄⴰⵡⴻⴷ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_16","003_27_16","EXO","27","16","16","ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⴰⵔⵡⴰⵇ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴳⴳⵉⵏ ⵜ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵓⵅⴻⵢⵢⴰⴹ, ⴰⴽ-ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX27_17","003_27_17","EXO","27","17","17","ⵎⴰⵔⵔⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍⴻⵎⵔⴰⵃ ⴰⴷ ⵉⵍⵉⵏ ⵙ ⵉⵇⴻⴹⴱⴰⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵓⵙⴻⵍⵇⵉ ⵓⵛⴰ ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_18","003_27_18","EXO","27","18","18","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⴰⴷ ⵜⵉⵍⵉ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵅⴻⵎⵙⵉⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵍⵓⵄⵍⴰ ⴰⴷ ⵢⵉⵍⵉ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵎⴰⵔⵔⴰ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ ⵓⵛⴰ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX27_19","003_27_19","EXO","27","19","19","ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵉⴵⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵜⴰⴷ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵜⴰⴷ ⵏ ⵍⴻⵎⵔⴰⵃ ⴰⴷ ⵉⵍⵉⵏ ⵏ ⵏⵏⵃⴰⵙ. * ");
INSERT INTO rift_vpl VALUES ("EX27_20","003_27_20","EXO","27","20","20","ⴰⴷ ⵜⵓⵎⵓⵔⴻⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵣⵣⴻⵛⵜ ⵜⴻⵚⴼⴰ ⵜⴻⴷⴷⴻⵣ ⵣⵉ ⵣⵣⵉⵜⵓⵏ ⵉ ⵜⴼⴰⵡⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⴻⵖ ⵜⴼⴰⵡⵜ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX27_21","003_27_21","EXO","27","21","21","ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵃⴹⴰⵏ ⵎⴰⵏ ⴰⵢⴰ ⵣⵉ ⴵⵉⵍⴻⵜ ⴰⵍ ⵚⵚⴱⴻⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵣⵣⴰⵜ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵛⵛⵀⴰⴷⴻⵜ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴹⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX28_1","003_28_1","EXO","28","1","1","“ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ, ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵄⴻⴱⴷⴻⵏ ⴰⵎ ⵢⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵀⴰⵔⵓⵏ, ⵏⴰⴷⴰⴱ, ⴰⴱⵉⵀⵓ, ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_2","003_28_2","EXO","28","2","2","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ, ⴰⴷ ⴰⵙ ⵢⵉⵍⵉ ⵉ ⵓⵄⵓⴵⵉ ⴷ ⵜⴻⵍⵡⵉⵣⵜ. ");
INSERT INTO rift_vpl VALUES ("EX28_3","003_28_3","EXO","28","3","3","ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⵡⵓⵍ, ⵉⵏⵏⵉ ⵛⵛⵓⵔⴻⵖ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⵖⵉⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⴰⵔⵔⵓⴹ ⵉ ⵀⴰⵔⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("EX28_4","003_28_4","EXO","28","4","4","ⵉⵏⴰ ⴷ ⴰⵔⵔⵓⴹ ⵉ ⵖⴰ ⴳⴳⴻⵏ: ⵉⵛⵜ ⵏ ⵜⴻⵊⵎⴻⵛⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⴷ ⵉⵛⵜ ⵜⵛⴰⵎⵉⵔ ⵉⵎⵓⴷⴻⵏ ⴰⵎ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵎ ⵏ ⵓⴼⴻⵏⵏⴰⵏ, ⴷ ⵉⵛⵜ ⵏ ⴰⵔⴻⵥⵥⴻⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵃⴻⵣⵣⴰⵎⵜ. ⴰⴷ ⴳⴳⴻⵏ ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ, ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_5","003_28_5","EXO","28","5","5","ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⵙⵉⵏ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⴰⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("EX28_6","003_28_6","EXO","28","6","6","ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⴱⴰⵍⵟⵓ ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_7","003_28_7","EXO","28","7","7","ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵔⴹⵉⵏ ⵉⵎⵎⵙⴻⵍⵙⴰⵇⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏ ⵓⴱⴰⵍⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("EX28_8","003_28_8","EXO","28","8","8","ⵜⴰⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⴱⴰⵍⵟⵓ ⵏⵏⴻⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷ ⵉⵛⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_9","003_28_9","EXO","28","9","9","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵥⵔⴰ ⵏ ⵓⵏⵉⴽⵙ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵏⴻⵇⵛⴻⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX28_10","003_28_10","EXO","28","10","10","ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵅ ⵢⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵥⵔⵓ ⵏⵏⴻⵖⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⴻⵜⵜⴻⴼ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_11","003_28_11","EXO","28","11","11","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵚⵚⴻⵏⵄⴻⵜ ⵏ ⵓⵏⴻⵇⵇⴰⵛ ⵏ ⵡⴻⵥⵔⵓ ⵉⵖⵍⴰⵏ. ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵜⵡⴰⵏⴻⵇⵛⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵥⵔⴰ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵛⵓⵢⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_12","003_28_12","EXO","28","12","12","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵥⵔⴰ ⵏⵏⵉ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵥⵔⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵀⴰⵔⵓⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵅ ⵜⵏⴰⵢⴻⵏ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX28_13","003_28_13","EXO","28","13","13","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵛⵓⵢⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ");
INSERT INTO rift_vpl VALUES ("EX28_14","003_28_14","EXO","28","14","14","ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴼⵉⵍⴰⵏ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⵓⴷⵉ. ⴰⴷ ⵜⵛⴻⴷⴷⴻⴷ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵎⵓⴷⴻⵏ ⵖⴰⵔ ⵜⵛⵓⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX28_15","003_28_15","EXO","28","15","15","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵊⵎⴻⵛⵜ ⵉ ⵍⴻⵃⴽⴰⵎ. ⴰⴷ ⵜⵜ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⴼⴻⵏⵏⴰⵏ, ⴰⵎ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ. ⴰⴷ ⵜⵜ ⵜⴻⴳⴳⴻⴷ ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_16","003_28_16","EXO","28","16","16","ⵜⴰⵊⵎⴻⵛⵜ ⴰⴷ ⵜⵉⵍⵉ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ, ⵜᵉⵜⵜⵡⴰⴹⴼⴻⵚ. ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ, ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX28_17","003_28_17","EXO","28","17","17","ⴰⴷ ⵅⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵉⵥⵔⴰ, ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⴻⵚⴼⵓⴼ ⵏ ⵉⵥⵔⴰ. ⵉⵊⵊ ⵏ ⵚⵚⴻⴼ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⵇⵉⵇ ⴷ ⴰⵣⴻⴳⴳⵡⴰⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⵢⴰⵇⵓⵜ ⴷ ⵉⵛⵜ ⵏ ⵙⵎⴰⵔⴰⵅⵜ. ⵡⴰ ⴷ ⵚⵚⴻⴼ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("EX28_18","003_28_18","EXO","28","18","18","ⵚⵚⴻⴼ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⴽⴰⵔⴱⵓⵏⴽⴻⵍ ⴷ ⵢⵉⵊⵊ ⵏ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ ⴷ ⵢⵉⵊⵊ ⵏ ⴷⵉⴰⵎⴰⵏⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EX28_19","003_28_19","EXO","28","19","19","ⵚⵚⴻⴼ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵢⴰⵙⵉⵏⵜⵓ ⴷ ⵢⵉⵊⵊ ⵏ ⴰⵅⴰⵜ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵎⴰⵜⵉⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EX28_20","003_28_20","EXO","28","20","20","ⵓ ⵚⵚⴻⴼ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵏⵉⴽⵙ ⴷ ⵢⵉⵊⵊ ⵏ ⵢⴰⵙⴱⵉⵙ. ⵉⵏⴰ ⴰⴷ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⵓⵔⴻⵖ ⴷⵉ ⵜⵛⵓⵢⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_21","003_28_21","EXO","28","21","21","ⵉⵥⵔⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵍⵉⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵥⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵙ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ, ⴽⵓⵍ ⴰⵏⴻⵇⵇⵉⵛ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ. ⴰⵇⴰ ⴰⵜⴻⵏ ⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX28_22","003_28_22","EXO","28","22","22","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵙⵙⵏⴰⵙⴻⵍ ⵅ ⵜⴻⵊⵎⴻⵛⵜ, ⵉⴼⵉⵍⴰⵏ ⵉⵎⵓⴷⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_23","003_28_23","EXO","28","23","23","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵊⵎⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵜⵛⴻⴷⴷⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⵔⵓⴼⴰ ⵏ ⵜⴻⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX28_24","003_28_24","EXO","28","24","24","ⴰⴷ ⵜⵛⴻⴷⴷⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵎⵓⴷⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵜⴻⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX28_25","003_28_25","EXO","28","25","25","ⴰⴷ ⵜⵛⴻⴷⴷⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵎⵓⴷⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵛⵓⵢⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⵛⴻⴷⴷⴻⴷ ⵖⴰⵔ ⵜⵖⴰⵔⴹⵉⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_26","003_28_26","EXO","28","26","26","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⴻⵊⵎⴻⵛⵜ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ, ⵅ ⵜⵎⴰ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⴱⴰⵍⵟⵓ, ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX28_27","003_28_27","EXO","28","27","27","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵜⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⵛⴻⴷⵏⴻⴷ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵔⴹⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ, ⵙⵡⴰⴷⴷⴰⵢ, ⵖⴰⵔ ⵣⵣⴰⵜ, ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵓⴱⴰⵍⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("EX28_28","003_28_28","EXO","28","28","28","ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵜⴰⵊⵎⴻⵛⵜ ⵙ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵉⵎⵓⴷⴻⵏ ⴰⴷⴻⵃⵎⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵊⵎⴻⵛⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵓⴱⴰⵍⵟⵓ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⵟⵟⵉ ⵜⴻⵊⵎⴻⵛⵜ ⵅ ⵓⴱⴰⵍⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("EX28_29","003_28_29","EXO","28","29","29","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴰⵡⵉ ⵀⴰⵔⵓⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵊⵎⴻⵛⵜ ⵏ ⵍⴻⵃⴽⴰⵎ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵇⴻⴷⴷⴰⵙ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX28_30","003_28_30","EXO","28","30","30","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵉⵥⵔⴰ ⵏ ‘ⵓⵔⵉⵎ’ ⴷ ‘ⵜⵓⵎⵎⵉⵎ’ ⴷⵉ ⵜⴻⵊⵎⴻⵛⵜ ⵏ ⵍⴻⵃⴽⴰⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵡⵓⵍ ⵏ ⵀⴰⵔⵓⵏ ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴰⵔⴱⵓ ⵀⴰⵔⵓⵏ ⵍⴻⴱⴷⴰ ⵍⴻⵃⴽⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX28_31","003_28_31","EXO","28","31","31","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵙⴻⵍⵀⴰⵎ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("EX28_32","003_28_32","EXO","28","32","32","ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵔⵣⴰⵎ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵡⴰⵔⵣⴰⵎ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⵎⴰ ⵉⵎⵓⴷⴻⵏ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴰⵎ ⵡⴰⵔⵣⴰⵎ ⵉ ⵢⵉⵔⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ, ⵡⴰⵔ ⵜᵉⵜⵜⵛⴰⵔⵔⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("EX28_33","003_28_33","EXO","28","33","33","ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵔⴻⵎⵎⴰⵏⵉⵏ ⵏ ⵉⴼⵉⵍⴰⵏ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵓ ⵊⴰⵔ ⴰⵙⴻⵏⵜ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵏⵏⵡⴰⵇⴻⵙ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_34","003_28_34","EXO","28","34","34","ⵉⵊⵊ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵏⵏⴰⵇⵓⵙ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⵔⴻⵎⵎⴰⵏⵜ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵏⵏⴰⵇⵓⵙ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⵔⴻⵎⵎⴰⵏⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵓ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX28_35","003_28_35","EXO","28","35","35","ⵀⴰⵔⵓⵏ ⴰⴷ ⵜ ⵢⴰⵔⴹ ⵅⵎⵉ ⵉⵜⵜⵙⵙⴻⵅⵅⴰⵔ ⵏⴻⵜⵜⴰ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⵍ ⴷⴷⵔⵉⵣ ⵏⵏⴻⵙ ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵅⵎⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EX28_36","003_28_36","EXO","28","36","36","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵍⵡⵉⵃⵜ ⵙ ⵏⵏⵓⵡⵡⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵜⵏⴻⵇⵛⴻⴷ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵇⵇⵛⴻⵏ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ: “ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX28_37","003_28_37","EXO","28","37","37","ⴰⴷ ⵜⵜ ⵜⵛⴻⴷⴷⴻⴷ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⵅ ⴰⵔⴻⵥⵥⴻⵜ. ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵍⵡⵉⵃⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵓⵔⴻⵥⵥⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX28_38","003_28_38","EXO","28","38","38","ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵍⵡⵉⵃⵜ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏ ⵀⴰⵔⵓⵏ, ⵃⵉⵎⴰ ⵀⴰⵔⵓⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⴱⴷⴰ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⴰⵔⴹⴰⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX28_39","003_28_39","EXO","28","39","39","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵛⴰⵎⵉⵔ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ. ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⴻⵥⵥⴻⵜ ⵄⴰⵡⴻⴷ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ. ⵜⴰⵃⴻⵣⵣⴰⵎⵜ ⴰⴷ ⵜⵜ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵓⵅⴻⵢⵢⴰⴹ.”* ");
INSERT INTO rift_vpl VALUES ("EX28_40","003_28_40","EXO","28","40","40","“ⵉ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵛⴰⵎⵉⵔ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵃⴻⵣⵣⴰⵎⵉⵏ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵛⵓⵛⵛⴰⵢ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵏ ⵉ ⵓⵄⵓⴵⵉ ⴷ ⵜⴻⵍⵡⵉⵣⵜ. ");
INSERT INTO rift_vpl VALUES ("EX28_41","003_28_41","EXO","28","41","41","ⴰⴷ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⴷ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ, ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴷⴻⵀⵏⴻⴷ, ⴰⴷ ⵜⴻⵏ ⵜⵍⴻⵇⵇⵎⴻⴷ ⵓ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵅⴻⴷⵎⴻⵏ ⴰⵎ ⵢⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_42","003_28_42","EXO","28","42","42","ⴻⴳⴳ ⴰⵙⴻⵏ ⵙⵙⵔⴰⵡⴻⵍ ⵏ ⵍⴻⵇⵟⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵍⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵓⵙⴻⴹⵃⵉ ⵏⵙⴻⵏ. ⴰⴷ ⵉⵍⵉⵏ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⴰⵡⴹⴻⵏ ⵖⴰⵔ ⵉⴼⴰⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX28_43","003_28_43","EXO","28","43","43","ⵙⵙⵍⴰⵡⴻⵍ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵏⵉⵖ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓⵛⴰ ⴰⴷ ⵎⵎⵜⴻⵏ. ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX29_1","003_29_1","EXO","29","1","1","“ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵛⵔⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵇⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("EX29_2","003_29_2","EXO","29","2","2","ⵓ ⵄⴰⵡⴻⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴷ ⵜⴻⵍⴼⴰⴼ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵜⵜⵡⴰⴷⴻⵀⵏⴻⵏⵜ ⵙ ⵣⵣⴻⵛⵜ, ⵜⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵏ ⵢⵉⵔⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_3","003_29_3","EXO","29","3","3","ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⵓⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴰⵡⵢⴻⴷ ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_4","003_29_4","EXO","29","4","4","ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_5","003_29_5","EXO","29","5","5","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⵔⵔⵓⴹ, ⴰⴷ ⵜⵢⴰⵔⴹⴻⴷ ⵀⴰⵔⵓⵏ ⵜⵛⴰⵎⵉⵔ ⴷ ⵓⵙⴻⵍⵃⴰⵎ ⵉ ⵓⴱⴰⵍⵟⵓ ⴷ ⵓⴱⴰⵍⵟⵓ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵊⵎⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⴱⴻⵢⵙⴻⴷ ⵙ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵓⴱⴰⵍⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("EX29_6","003_29_6","EXO","29","6","6","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴰⵔⴻⵥⵥⴻⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵅ ⴰⵔⴻⵥⵥⴻⵜ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵜⴰⵊ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵡⴻⵄⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX29_7","003_29_7","EXO","29","7","7","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⵣⴻⴵⵄⴻⴷ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴷⴻⵀⵏⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX29_8","003_29_8","EXO","29","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙⴻⵏ ⵜⵢⴰⵔⴹⴻⴷ ⵜⵛⴰⵎⵉⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX29_9","003_29_9","EXO","29","9","9","ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵢⵙⴻⴷ ⵙ ⵜⵃⴻⵣⵣⴰⵎⵜ, ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⴰⵔⴻⴽⴽⴱⴻⴷ ⵜⵉⵛⵓⵛⵛⴰⵢ. ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ⴰⴷ ⵜⴰⵍⴻⵇⵇⵎⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_10","003_29_10","EXO","29","10","10","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_11","003_29_11","EXO","29","11","11","ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX29_12","003_29_12","EXO","29","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵛ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴵⵄⴻⴷ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX29_13","003_29_13","EXO","29","13","13","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ, ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴻⴷ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX29_14","003_29_14","EXO","29","14","14","ⵎⴰⵛⴰ ⴰⵢⵙⵓⵎ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵢⵉⵍⴻⵎ ⵏⵏⴻⵙ ⴷ ⵓⵎⴻⵙⵙⴰⵍ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⵙ ⵜⵎⴻⵙⵙⵉ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("EX29_15","003_29_15","EXO","29","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵊⵊ ⵏ ⵓⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_16","003_29_16","EXO","29","16","16","ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵏ ⵜⵣⴻⴵⵄⴻⴷ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_17","003_29_17","EXO","29","17","17","ⴰⴷ ⵜⴻⴱⴹⵉⴷ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ, ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⴰⴷⴰⵏ ⵏⵏⴻⵙ ⴷ ⵉⵛⴻⴽⵔⴰⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵅ ⵉⵛⴻⴵⵉⵇⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_18","003_29_18","EXO","29","18","18","ⴰⴷ ⵜⴻⵙⵙⵉⵖⴻⴷ ⵉ ⵉⵛⴰⵔⵔⵉ ⴰⵎ ⵉⴽⵎⴻⵍ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_19","003_29_19","EXO","29","19","19","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵛⴰⵔⵔⵉ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_20","003_29_20","EXO","29","20","20","ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵀⴰⵔⵓⵏ ⵓ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓ ⵄⴰⵡⴻⴷ ⵅ ⵓⴹⴰⴹ ⵏ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵓⴹⴰⴹ ⵏ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴵⵄⴻⴷ ⵉⴹⴰⵎⵎⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵣⵉ ⴽⵓⵍ ⵊⵊⵉⵀⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX29_21","003_29_21","EXO","29","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵣⵉ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵔⵓⵛⵛⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵔⵓⵛⵛⴻⴷ ⵄⴰⵡⴻⴷ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴷ ⴰⵔⵔⵓⴹ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴷ ⴰⵔⵔⵓⴹ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_22","003_29_22","EXO","29","22","22","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⴰⴷⵓⵏⵜ ⵏ ⵉⵛⴰⵔⵔⵉ ⵍⴰ ⴷ ⵜⴰⴷⵓⵏⵜ ⵖⴰⵔ ⵓⵏⴻⵡⵡⴰⵔ ⵍⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ, ⵓⵍⴰ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⵙ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⴷ ⴰⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ, ⵎⵉⵏⵣⵉ ⵡⴰ ⴷ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_23","003_29_23","EXO","29","23","23","ⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵏⵉⴼⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵙⴻⵎⵎⴻⵏⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵍⴼⴻⴼⵜ ⵣⵉ ⵜⵙⵓⴵⴻⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_24","003_29_24","EXO","29","24","24","ⵙⴰⵔⵙ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⵓ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵏⵀⴻⵣⵣⴻⴷ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_25","003_29_25","EXO","29","25","25","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴻⴷ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_26","003_29_26","EXO","29","26","26","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜᵉⵙⵙⴻⵏⵀⴻⵣⵣⴻⴷ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵜⴰⵏⵉⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX29_27","003_29_27","EXO","29","27","27","ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵉ ⵉⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ, ⵓⵍⴰ ⴷ ⵓⵛⴻⴽⵔⵓⴷ ⵉ ⵉⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ. ⴰⵇⴰ-ⵜⴻⵏ ⵣⴻⴳ ⵉⵛⴰⵔⵔⵉ ⵏ ⵓⴷⴻⵛⵛⴻⵏ, ⴰⵎ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉ ⵢⴻⴵⴰⵏ ⵉ ⵀⴰⵔⵓⵏ ⴰⵎ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉ ⵢⴻⴵⴰⵏ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_28","003_29_28","EXO","29","28","28","ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵜⴻⴵⴰ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵖⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵏ ⵍⴻⵀⵏⴰ. ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_29","003_29_29","EXO","29","29","29","ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴷⴻⵀⵏⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⴰⵍⴻⵇⵎⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_30","003_29_30","EXO","29","30","30","ⵎⴰⵏ ⵡⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⴷ ⵜ ⵢⴰⵔⴹ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_31","003_29_31","EXO","29","31","31","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜᵉⵙⵙⴻⵏⴳⵡⴻⴷ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_32","003_29_32","EXO","29","32","32","ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵡⴻⵖⵔⵓⵎ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX29_33","003_29_33","EXO","29","33","33","ⴰⴷ ⵛⵛⴻⵏ ⵣⵉ ⵎⵉⵏ ⵣⵉ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵙⵍⴰⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵍⴻⵇⵇⵎⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EX29_34","003_29_34","EXO","29","34","34","ⵎⴰⵍⴰ ⵉⵛⴻⵟⵟ ⵛⴰ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵜⵖⴰⵔⵚⴰ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ ⴰⵍ ⵚⵚⴱⴻⵃ, ⴰⴷ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵜⵜ ⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("EX29_35","003_29_35","EXO","29","35","35","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵓ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵡⴻⵚⵚⵉⵖ. ⴰⴷ ⵜⴻⵏ ⵜⴰⵍⴻⵇⵇⵎⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_36","003_29_36","EXO","29","36","36","ⴽⵓⵍ ⴰⵙⵙ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵡⴻⵚⵍⴰⵃ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⴷⴷⴻⵏⴱ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵎⵉ ⵅⴰⵙ ⵖⴰ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⴰⵚⵍⴰⵃ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⴷⴻⵀⵏⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX29_37","003_29_37","EXO","29","37","37","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵚⵍⴰⵃ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ. ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵄⴰⵍⵟⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX29_38","003_29_38","EXO","29","38","38","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵅ ⵓⵄⴰⵍⵟⴰⵔ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⴽⵓⵍ ⴰⵙⵙ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX29_39","003_29_39","EXO","29","39","39","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ ⴷⵉ ⵚⵚⴱⴻⵃ ⵓ ⵉⵣⵎⴰⵔ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EX29_40","003_29_40","EXO","29","40","40","ⵉ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵄⴻⵛⵔⴰ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴷⴷⵣⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵣⵣⵉⵜⵓⵏ, ⵓ ⴰⵔⴻⴱⵄⴰ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⴱⵉⵏⵓ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("EX29_41","003_29_41","EXO","29","41","41","ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵢⴻⵣⵎⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ. ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⴰⵔⵏⵉⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⵉ ⵏ ⵚⵚⴱⴻⵃ ⵓ ⵄⴰⵡⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ⴰⵇⴰ ⴷ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ. ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX29_42","003_29_42","EXO","29","42","42","ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵍⴻⴱⴷⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⵎⵓⵏⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⴻⴽ ⵙⵙⵉⵡⵍⴻⵖ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_43","003_29_43","EXO","29","43","43","ⴰⴷ ⵎⵎⵙⴰⴳⴰⵔⴻⵖ ⴷⵉⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⴰⵇⵉⴹⵓⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵙ ⵓⵄⵓⴵⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX29_44","003_29_44","EXO","29","44","44","ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵄⴰⵡⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX29_45","003_29_45","EXO","29","45","45","ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ");
INSERT INTO rift_vpl VALUES ("EX29_46","003_29_46","EXO","29","46","46","ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX30_1","003_30_1","EXO","30","1","1","“ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ. ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EX30_2","003_30_2","EXO","30","2","2","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵊⵊⴻⵏ ⵓⵖⵉⵍ, ⵓ ⵜⵉⵔⵓ ⵄⴰⵡⴻⴷ ⴷ ⵉⵊⵊⴻⵏ ⵓⵖⵉⵍ. ⴰⴷ ⵢⵉⵍⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ. ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX30_3","003_30_3","EXO","30","3","3","ⴰⴷ ⵜ ⵜⵖⴻⴵⴼⴻⴷ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵏ ⵙⴻⵏⵏⴻⵊ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX30_4","003_30_4","EXO","30","4","4","ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵙⴰⴷⵓ ⵣⵣⵡⴰⵇ ⵏⵏⴻⵙ. ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ. ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵉⵄⵓⵎⴰⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EX30_5","003_30_5","EXO","30","5","5","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵖⴻⴵⴼⴻⴷ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX30_6","003_30_6","EXO","30","6","6","ⴰⴷ ⵜ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵣⵣⴰⵜ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵣⵣⴰⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵛⵛⵀⴰⴷⴻⵜ, ⵎⴰⵏⵉ ⴽⵉⴽ ⵉ ⵖⴰ ⵎⵎⵙⴰⴳⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX30_7","003_30_7","EXO","30","7","7","ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵀⴰⵔⵓⵏ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴽⵓⵍ ⵚⵚⴱⴻⵃ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵄⴷⴻⵍ ⵜⵉⴼⵜⵉⵍⵉⵏ, ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX30_8","003_30_8","EXO","30","8","8","ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵉⵙⵙⵉⵔⴻⵖ ⵀⴰⵔⵓⵏ ⵜⵉⴼⵜⵉⵍⵉⵏ ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⴷ ⵢⴻⵊⵊ ⵍⴻⴱⵅⵓⵔ ⴰⴷ ⵉⴱⴻⵅⵅⴰⵔ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX30_9","003_30_9","EXO","30","9","9","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⵙ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵛⴰ ⵍⴻⴱⵅⵓⵔ ⴷ ⴰⵖⵔⵉⴱ, ⵏⵉⵖ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵣⴻⴵⴰⵄⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("EX30_10","003_30_10","EXO","30","10","10","ⵀⴰⵔⵓⵏ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵡⴻⵚⵍⴰⵃ. ⴰⴷ ⵜ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX30_11","003_30_11","EXO","30","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX30_12","003_30_12","EXO","30","12","12","“ⵅⵎⵉ ⵖⴰ ⵜⴻⴽⵙⵉⴷ ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵅⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⵛⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵜⵜⴰⵎⴰⵏ ⵏ ⵡⴻⵚⵍⴰⵃ ⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵙⴻⴷⴷⵉ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵊⴰⵔ ⴰⵙⴻⵏ ⵅ ⵎⵉⵏⵏⵉ ⵜⴻⵏ ⵖⴰ ⵜⵃⴻⵙⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX30_13","003_30_13","EXO","30","13","13","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵡⵛⴻⵏ ⵏⵉⵜⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵖⴰ ⵉⵥⵡⴰⵏ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ: ⴰⵣⵢⴻⵏ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ - ⵛⵉⵇⵍⵓ-ⵢⴰ ⴷ ⵄⵉⵛⵔⵉⵏ ⵊⵉⵔⴰ - ⴰⵣⵢⴻⵏ ⵛⵉⵇⵍⵓ-ⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX30_14","003_30_14","EXO","30","14","14","ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵖⴰ ⵉⵥⵡⴰⵏ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX30_15","003_30_15","EXO","30","15","15","ⴱⵓ-ⵡⴰⴳⵍⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⴽⵜⴰⵔ ⵓ ⴰⵎⴻⵣⵍⵓⴹ ⵡⴰⵔ ⵉⵙⵙⴻⵏⵇⵉⵙ ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵛⵉⵇⵍⵓ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵙⵉⴷⵉ ⵉ ⵡⴻⵚⵍⴰⵃ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX30_16","003_30_16","EXO","30","16","16","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵡⴻⵚⵍⴰⵃ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴼⴰⵔⵣⴻⴷ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵡⴻⵚⵍⴰⵃ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX30_17","003_30_17","EXO","30","17","17","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX30_18","003_30_18","EXO","30","18","18","“ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵜⴱⴰⵏⵢⵓⵜ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵓⵙⵉⵔⴷ, ⴰⴽ-ⴷ ⵓⴹⴰⵔ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵅ ⵜⵜ ⵖⴰ ⵙⵙⴰⵔⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵊⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EX30_19","003_30_19","EXO","30","19","19","ⵎⴰⵃⴻⵏⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵉⵔⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX30_20","003_30_20","EXO","30","20","20","ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵏ ⵛⴰ, ⵓⵍⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵅⵎⵉ ⵖⴰ ⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX30_21","003_30_21","EXO","30","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵏ ⵛⴰ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ, ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX30_22","003_30_22","EXO","30","22","22","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX30_23","003_30_23","EXO","30","23","23","“ⵛⴻⴽ, ⴽⵙⵉ ⵍⴻⵅⵅⵓ ⵖⴰⵔⴻⴽ ⵍⴻⵄⵟⵓⵔ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ: ⵅⴻⵎⵙ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵎⵉⵔⵔⵓ ⵢⵓⵣⵣⵍⴻⵏ ⴰⴽ-ⴷ ⵍⵇⴻⴷⴷ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ ⵣⵉ ⵍⵇⴰⵔⴼⴰ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵓ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ ⵣⴻⴳ ⵓⵖⴰⵏⵉⵎ ⵓⵃⴻⵎⵎⵓⵎ ⵉⵜⵜⴼⵓⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX30_24","003_30_24","EXO","30","24","24","ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵇⴰⵙⵙⵉⵢⴰ ⵉⵡⴻⵣⵣⵏⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴷ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ ⵏ ⵣⵣⵉⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX30_25","003_30_25","EXO","30","25","25","ⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵜ ⵏ ⵣⵣⴻⵛⵜ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵉ ⵡⴻⴷⵀⴰⵏ, ⵉⵊⵊ ⵏ ⵍⴻⵄⵟⵓⵔ ⵉⵅⴻⴵⴹⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵚⵚⴻⵏⵄⴻⵜ ⵏ ⵓⵄⴻⵟⵟⴰⵔ. ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵣⵣⴻⵛⵜ ⵜⴰⵎⵇⴻⴷⴷⴻⵙⵜ ⵉ ⵡⴻⴷⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX30_26","003_30_26","EXO","30","26","26","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴷⴻⵀⵏⴻⴷ ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("EX30_27","003_30_27","EXO","30","27","27","ⵜⴰⵣⴻⵡⴹⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵍⵇⴻⵏⴷⵉⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("EX30_28","003_30_28","EXO","30","28","28","ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵜⴱⴰⵏⵢⵓⵜ ⴰⴽ-ⴷ ⵓⴹⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX30_29","003_30_29","EXO","30","29","29","ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX30_30","003_30_30","EXO","30","30","30","ⴰⴷ ⵜⴷⴻⵀⵏⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX30_31","003_30_31","EXO","30","31","31","ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵣⵣⴻⵛⵜ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵉ ⵏⴻⵛⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX30_32","003_30_32","EXO","30","32","32","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵜ ⴼⴰⵔⵔⵖⴻⵏ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⵜⵎⴰⵙ. ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵉ ⵜⴻⴵⴰ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("EX30_33","003_30_33","EXO","30","33","33","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵙ ⵍⴻⴱⵣⴰⵔ ⵉⵛⵜ ⵏ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⴰⵎ ⵜⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵎⴻⵙⵃⴻⴷ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("EX30_34","003_30_34","EXO","30","34","34","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵍⴻⴱⵣⴰⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ: ⵜⵓⴷⴷⵉⵎⵉⵏ ⵏ ⵓⵙⴻⵔⵖⴰⵖ ⴷ ⵡⴻⵇⵛⵓⵔ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵍⵇⴰⵔⴼⴰ ⴷ ⵖⴰⵍⴱⴰ, ⵍⴻⴱⵣⴰⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⵊⵊⴰⵡⵉ ⵉⵚⴼⴰⵏ. ⴰⴷ ⵢⵉⵍⵉ ⵍⵇⴻⴷⴷ ⵏⵏⴻⵙ ⴰⵎ ⵍⵇⴻⴷⴷ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX30_35","003_30_35","EXO","30","35","35","ⴻⴳⴳ ⵣⵣⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴻⵄⵟⵓⵔ, ⵉⵊⵊ ⵏ ⵓⵅⴻⴵⴻⴹ ⴰⵎ ⵜⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵄⴻⵟⵟⴰⵔ: ⵉⵜⵜⵡⴰⵎⴻⴵⴻⴷ, ⵉⵚⴼⴰ, ⵉⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX30_36","003_30_36","EXO","30","36","36","ⵃⵔⵉ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴰⵏⴻⵖⴷⴰ ⵜⴰⵣⴷⴰⴷⵜ ⵓⵛⴰ ⵙⴰⵔⵙ ⵛⴰ ⵣⵣⴰⵢⴻⵙ ⵣⵣⴰⵜ ⵉ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵎⴰⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵖⴰ ⵎⵙⴰⴳⴰⵔⴻⵖ. ⴰⴷ ⴰⵡⴻⵎ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EX30_37","003_30_37","EXO","30","37","37","ⵍⴻⵄⵜⵓⵔ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵓⵅⴻⴵⴻⴹ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵛⴻⴽ, ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX30_38","003_30_38","EXO","30","38","38","ⵡⴻⵏⵏⵉ ⵉ ⵉⴳⴳⵉⵏ ⵛⴰ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵛⴻⵎⵎ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX31_1","003_31_1","EXO","31","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX31_2","003_31_2","EXO","31","2","2","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅ ⴱⴰⵚⴰⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX31_3","003_31_3","EXO","31","3","3","ⵛⵛⵓⵔⴻⵖ ⵜ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵙ ⵜⵉⵖⵉⵜ, ⵙ ⵍⴻⵄⵇⴻⵍ, ⵙ ⵜⵓⵙⵙⵏⴰ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⵏ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⵚⵚⵏⴰⵢⴻⵄ, ");
INSERT INTO rift_vpl VALUES ("EX31_4","003_31_4","EXO","31","4","4","ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴻⵎⵎⴻⵎ ⵉⵔⴻⵇⵇⴰⵎⴻⵏ ⵙ ⵍⴼⴻⵏⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("EX31_5","003_31_5","EXO","31","5","5","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵇⵛⴻⵏ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵏ ⴷⵉ ⵜⵛⵓⵢⴰⵔ ⵏⵙⴻⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵇⵛⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ, ⵃⵉⵎⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX31_6","003_31_6","EXO","31","6","6","ⴰⵇⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⴽⵉⴷⴻⵙ ⴰⵀⵓⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵙⴰⵎⴰⴽ, ⵣⵉ ⵍⴰⴵ ⵏ ⴷⴰⵏ. ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵍ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴳⴳⵉⵖ ⵜⵉⵖⵉⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵡⴻⵚⵚⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("EX31_7","003_31_7","EXO","31","7","7","ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵏⵏⵉ ⵅⴰⵙ ⵉⴵⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⵇⵉⴹⵓⵏ: ");
INSERT INTO rift_vpl VALUES ("EX31_8","003_31_8","EXO","31","8","8","ⵜⴰⵣⴻⵡⴹⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ, ⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵉⵚⴼⴰⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("EX31_9","003_31_9","EXO","31","9","9","ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵜⴱⴰⵏⵢⵓⵜ ⵙ ⵓⴹⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EX31_10","003_31_10","EXO","31","10","10","ⴰⵔⵔⵓⴹ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷ ⵡⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ, ⴷ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EX31_11","003_31_11","EXO","31","11","11","ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ, ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX31_12","003_31_12","EXO","31","12","12","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX31_13","003_31_13","EXO","31","13","13","“ⵛⴻⴽ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵙⵙⴻⴱⵜ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX31_14","003_31_14","EXO","31","14","14","ⵃⴹⴰⵎ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵎⵉⵏⵣⵉ ⵉⵇⴻⴷⴷⴻⵙ ⵉ ⵉⴵⴰ ⵉ ⴽⴻⵏⵏⵉⵡ! ⵡⴻⵏⵏⵉ ⵜ ⵖⴰ ⵉⵙⵙⴼⴻⵙⴷⴻⵏ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⴰⵢⴻⵙ ⵖⴰ ⵉⴳⴳⴻⵏ ⵛⴰ ⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("EX31_15","003_31_15","EXO","31","15","15","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵙⵙⴻⴱⵜ, ⴰⵔⵔⴰⵃⴻⵜ ⵜⵎⵓⵏ, ⵜⵇⴻⴷⴷⴻⵙ ⵉ ⵜⴻⴵⴰ ⵉ ⵙⵉⴷⵉ! ⴽⵓⵍ ⵉⵊⵊ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵛⴰ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX31_16","003_31_16","EXO","31","16","16","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵃⴹⴰⵏ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵃⴹⴰⵏ ⵙⵙⴻⴱⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ ⴰⵎ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EX31_17","003_31_17","EXO","31","17","17","ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵢⴰⵔⴻⵢⵢⴻⵃ, ⵢⴰⵔⵔⴰ ⵏⵏⴻⴼⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX31_18","003_31_18","EXO","31","18","18","ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍ ⵉ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⵉⵡⵛⴰ ⵉ ⵎⵓⵙⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ. ⵜⵓⵖⴰ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏⵏⵉ ⵣⴻⴳ ⵡⴻⵥⵔⵓ, ⵜⵜⵡⴰⵔⵉⵏⵜ ⵙ ⵓⴹⴰⴹ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX32_1","003_32_1","EXO","32","1","1","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⴳⴻⵏⵙ ⴱⴻⵍⵍⵉ ⵎⵓⵙⴰ ⵉⵄⴻⵟⵟⴰⵍ, ⵡⴰⵔ ⴷⴷ-ⵉⵀⵡⵉ ⵄⴰⴷ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵉⵏⵏⴻⵢⵔⵓ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵀⴰⵔⵓⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴽⴽⴰⵔ, ⴻⴳⴳ ⴰⵏⴻⵖ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵓⵢⵓⵔⴻⵏ ⵣⵣⴰⵜⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⴰⵢⴰ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵎⵉⵏ ⵜ ⵢⵓⵖⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX32_2","003_32_2","EXO","32","2","2","ⵀⴰⵔⵓⵏ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵇⴻⵍⵄⴻⵎ ⵜⵉⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⵓ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵓⵍⴰ ⵏ ⵢⴻⵙⵙⵉⵜⵡⴻⵎ, ⴰⵡⵢⴻⵎ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX32_3","003_32_3","EXO","32","3","3","ⵉⴽⴽⴻⵙ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵜⵉⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴰⵙ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX32_4","003_32_4","EXO","32","4","4","ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵜⴻⵏⵜ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵛⴻⴽⴽⴻⵍ ⵉ-ⵜⴻⵏⵜ ⵙ ⵉⵎⴻⵢⴷⵉ, ⵉⴳⴳⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵏ ⵓⴼⴻⵙⵙⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⴰⵏ: “ⴰ ⵉⵙⵔⴰⵉⵍ, ⵡⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX32_5","003_32_5","EXO","32","5","5","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵀⴰⵔⵓⵏ ⴰⵢⴰ, ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵣⵣⴰⵜ ⵉ ⵓⵄⴻⵊⵎⵉ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: “ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⵉⴷ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EX32_6","003_32_6","EXO","32","6","6","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ ⵓⵛⴰ ⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⴰⴽⵉⴷⵙⴻⵏⵜ ⵄⴰⵡⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ⵅⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵍⴳⴻⵏⵙ, ⵉⵛⵛⴰ, ⵉⵙⵡⴰ, ⵉⴽⴽⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵍⴻⴼⵔⴰⵢⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("EX32_7","003_32_7","EXO","32","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ: “ⵓⵢⵓⵔ, ⵀⵡⴰ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX32_8","003_32_8","EXO","32","8","8","ⴰⵇⴰ ⴼⴼⵖⴻⵏ ⴷⴻⵖⵢⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵅ ⵜⴻⵏ ⵡⴻⵚⵚⵉⵖ. ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵏ ⵓⴼⴻⵙⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙ, ⵇⴻⴷⴷⵎⴻⵏ ⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵓⵛⴰ ⵏⵏⴰⵏ: ‘ⴰ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EX32_9","003_32_9","EXO","32","9","9","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵍⴳⴻⵏⵙ-ⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⵙⴻⵃ! ");
INSERT INTO rift_vpl VALUES ("EX32_10","003_32_10","EXO","32","10","10","ⵍⴻⵅⵅⵓ ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ, ⴰⴷ ⴰⵔⴻⵖ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("EX32_11","003_32_11","EXO","32","11","11","ⵎⴰⵛⴰ ⵎⵓⵙⴰ ⵉⵣⴰⵡⴳ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵢⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵊⵊⴻⵀⴷ ⵉⵎⵖⴰⵔ ⵓ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("EX32_12","003_32_12","EXO","32","12","12","ⵎⴰⵢⴻⵎⵎⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵙ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ?’ ⴷⵡⴻⵍ ⵅ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴷⴻⵎ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴰⵔⵔⴻⴷ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX32_13","003_32_13","EXO","32","13","13","ⴼⴻⴽⴽⴰⵔ ⴷⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵏⵉⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵉ ⵅⴻⴼ ⵙⵙⵉⵡⵍⴻⵖ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵡⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX32_14","003_32_14","EXO","32","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⴰⴷ ⵜⵜ ⵢⴻⴳⴳ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX32_15","003_32_15","EXO","32","15","15","ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵎⵓⵙⴰ, ⵉⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵜⵉⵍⵡⵉⵃⵉⵏ-ⴰ ⵜⵜⵡⴰⵔⵉⵏⵜ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵙⴻⵏⵜ: ⵜⵜⵡⴰⵔⵉⵏⵜ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX32_16","003_32_16","EXO","32","16","16","ⵜⵉⵍⵡⵉⵃⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵉⵔⴰ ⵏⵏⵉ ⵉⵏⴻⵇⵛⴻⵏ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⴷ ⵜⵉⵔⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EX32_17","003_32_17","EXO","32","17","17","ⵉⵙⵍⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵙⵖⵓⵢⵢⵓ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵎⵓⵙⴰ: “ⴰⵇⴰ ⴷⴰ, ⵍⵃⴻⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("EX32_18","003_32_18","EXO","32","18","18","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵍⴻⵡⵍⵉⵡ ⵖⴰⵔ ⵍⴻⵖⵍⴻⴱ ⵏⵉⵖ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵖⵓⵢⵢⵉ ⵖⴰⵔ ⵜⵅⴻⵙⵙⴰⵔⵜ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⵜⴻⵙⵍⵉⵖ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX32_19","003_32_19","EXO","32","19","19","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⴰⵎ ⴷⴷ-ⵉⵔⴻⵃⵃⴻⴳ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵄⴻⵊⵎⵉ ⴷ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵢⴰⵔⵥⴰ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX32_20","003_32_20","EXO","32","20","20","ⵉⵟⵟⴻⴼ ⵓⵄⴻⵊⵎⵉ ⵏⵏⵉ ⴳⴳⵉⵏ, ⵉⵙⵙⵛⴻⵎⴹ ⵉ-ⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⵉⵖⵖⴻⴹ ⵓⵛⴰ ⵉⵣⵣⵓⵣⴰⵔ ⵉ-ⵜ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX32_21","003_32_21","EXO","32","21","21","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉⴳⴳⴰ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵍⴰⵎⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵉⵡⵢⴻⴷ ⵉⵊⵊ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("EX32_22","003_32_22","EXO","32","22","22","ⵀⴰⵔⵓⵏ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵢⴰⵔⴻⵇⵇ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ! ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX32_23","003_32_23","EXO","32","23","23","ⵏⵏⴰⵏ ⴰⵢⵉ: ‘ⴻⴳⴳ ⴰⵏⴻⵖ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵖⴰ ⵢⵓⵢⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵡⴰⵏⵉⵜⴰ, ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵎⵉⵏ ⵜ ⵢⵓⵖⵉⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EX32_24","003_32_24","EXO","32","24","24","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: ‘ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵔⴻⵖ, ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⴽⴽⴻⵙ, ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵜ ⵢⴻⵡⵛ!’ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵖ ⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵄⴻⵊⵎⵉ-ⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX32_25","003_32_25","EXO","32","25","25","ⵓⵎⵉ ⵉⵥⵔⴰ ⵎⵓⵙⴰ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⴷⵡⴻⵍ ⴷ ⵉⵎⴼⴻⵍⵍⴻⵙ, ⵎⵉⵏⵣⵉ ⵀⴰⵔⵓⵏ ⵉⵊⵊⴰ ⴰⴼⴻⵍⵍⴻⵙ ⵏⵙⴻⵏ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⴹⴻⵃⵃⴰⵛⵜ ⵊⴰⵔ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX32_26","003_32_26","EXO","32","26","26","ⵉⴱⴻⴷⴷ ⵎⵓⵙⴰ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵙ-ⴷⴷ ⴷⴰ ⵖⴰⵔⵉ!” ⵓⵛⴰ ⵎⵓⵏⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("EX32_27","003_32_27","EXO","32","27","27","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ! ⵙⴰⵔⵙⴻⵎ ⴽⵓⵍ ⵉⵊⵊ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ, ⵄⴷⵓⵎ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵎ ⵅ ⵍⵎⴰⵔⴳⴻⵃ ⵣⴻⴳ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⵉⵏⴻⵖ ⴽⵓⵍ ⵉⵊⵊ ⵓⵎⴰⵙ ⴷ ⴽⵓⵍ ⵉⵊⵊ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ ⴷ ⴽⵓⵍ ⵉⵊⵊ ⵊⵊⴰⵔ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("EX32_28","003_32_28","EXO","32","28","28","ⵜⴰⵔⵡⴰ ⵏ ⵍⴰⵡⵉ ⴳⴳⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵎⵓⵙⴰ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴹⴰⵏ ⵄⵍⴰⵃⴰⵍ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EX32_29","003_32_29","EXO","32","29","29","ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⴽⵙⵉⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵎⵎⵉⵙ ⵓ ⵅ ⵓⵎⴰⵙ. ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵎⵎⵓ ⴰⵙⵙ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("EX32_30","003_32_30","EXO","32","30","30","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵉⵊⵊ ⵏ ⴷⴷⴻⵏⴱ ⵉⵎⵖⴰⵔ. ⵄⴰⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵍⵢⴻⵖ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴱⴰⵍⴰⴽ ⴰⴷ ⵓⴼⵉⵖ ⴰⵚⵍⴰⵃ ⵅ ⴷⴷⴻⵏⴱ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EX32_31","003_32_31","EXO","32","31","31","ⵉⴷⵡⴻⵍ-ⴷⴷ ⵎⵓⵙⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵢⵢⴰⵡ, ⵍⴳⴻⵏⵙ-ⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⴷⴷⴻⵏⴱ ⵉⵎⵖⴰⵔ, ⵎⵉⵏⵣⵉ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX32_32","003_32_32","EXO","32","32","32","ⵍⴻⵅⵅⵓ, ⵖⴼⴰⵔ ⴰⵙⴻⵏ ⵉ ⴷⴷⴻⵏⴱ ⵏⵙⴻⵏ! ⵏⵉⵖ ⵎⵃⴰ ⴰⵢⵉ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⵉ ⵜⵓⵔⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("EX32_33","003_32_33","EXO","32","33","33","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵡⴻⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵅⴹⴰⵏ, ⴷ ⵡⴰ ⵉ ⵖⴰ ⵎⵃⵉⵖ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX32_34","003_32_34","EXO","32","34","34","ⵔⵓⵃ ⵍⴻⵅⵅⵓ, ⴰⵡⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵖⴰⵔ ⵎⴰⵏⵉ ⴷ ⴰⵛ ⵏⵏⵉⵖ. ⴰⵇⴰ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ ⴰⴷ ⵉⵔⴰⵃ ⵣⵣⴰⵜ ⵏⵏⴻⵛ! ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵅⴻⴵⴻⵚ ⵉⵏⵓ ⴰⴷ ⴰⵙⴻⵏ ⵅⴻⴵⵚⴻⵖ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("EX32_35","003_32_35","EXO","32","35","35","ⴰⵎⵎⵓ ⵉ ⵉⵡⵜⴰ ⵙⵉⴷⵉ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⴳⴳⵉⵏ ⴰⵄⴻⵊⵎⵉ ⵏⵏⵉ ⵉⴳⴳⴰ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX33_1","003_33_1","EXO","33","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ: “ⵔⵓⵃ, ⴳⴻⵄⵄⴻⴷ ⵙⵙⴰ, ⵛⴻⴽ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵏⵏⵉⵖ: ‘ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("EX33_2","003_33_2","EXO","33","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⵍⵎⴰⵍⴰⴽ, ⵓⵛⴰ ⴰⴷ ⴰⵥⵥⵍⴻⵖ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⵉⴱⵓⵙⵉⵢⵢⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EX33_3","003_33_3","EXO","33","3","3","ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵡⴻⵎ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ⵏⴻⵛⵛ ⵙ ⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵡⴰⵔ ⵜⵜⴳⵉⵄⵄⵉⴷⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵃⵃⵉⵖ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⵙⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("EX33_4","003_33_4","EXO","33","4","4","ⵓⵎⵉ ⵉⵙⵍⴰ ⵍⴳⴻⵏⵙ ⴰⵡⴰⵍ-ⴰ ⴰⵄⴻⴼⴼⴰⵏ, ⵛⴻⴹⵏⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⴳⴳⴰ ⵄⴰⴷ ⵍⴻⵀⵣⵓⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX33_5","003_33_5","EXO","33","5","5","ⴰⵇⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵉⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⵙⴻⵃ. ⵎⴰⵍⴰ ⴳⴻⵄⵄⴷⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵎⴰⵛ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵃⵃⵉⵖ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴽⴽⵙⴻⵎ ⵍⴻⵀⵣⵓⵟ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⴳⴳⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EX33_6","003_33_6","EXO","33","6","6","ⴽⴽⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵍⴻⵀⵣⵓⵟ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("EX33_7","003_33_7","EXO","33","7","7","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⴰⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵉⵡⵜⴰ ⴰⵇⵉⴹⵓⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⴳⴳⵯⴻⵊ ⴰⵟⵟⴰⵙ ⵅ ⵍⵎⴰⵔⴳⴻⵃ, ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ‘ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ’. ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ, ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("EX33_8","003_33_8","EXO","33","8","8","ⵓⵎⵉ ⵉⴼⴼⴻⵖ ⵎⵓⵙⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ, ⵉⴽⴽⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⴱⴻⴷⴷⴻⵏ ⴱⴰⵔⵔⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵅⵣⴰⵔⴻⵏ ⵖⴰⵔⴻⵙ ⴰⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵎⵓⵙⴰ ⴰⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX33_9","003_33_9","EXO","33","9","9","ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ, ⴰⵇⴰ ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⵀⵡⴰ, ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX33_10","003_33_10","EXO","33","10","10","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵥⵔⴰ ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ, ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX33_11","003_33_11","EXO","33","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴰⵖⴻⵎⴱⵓⴱ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⴱⵏⴰⴷⴻⵎ ⴰⴽ-ⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵡⴻⵏⵏⵉ ⵄⴰⴷ ⴷ ⴰⵃⵓⴷⵔⵉ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴱⴻⵄⵄⴻⴷ ⵅ ⵍⵡⴻⵙⵟ ⵏ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EX33_12","003_33_12","EXO","33","12","12","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ: “ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ ⴰⵢⵉ: ‘ⵏⴷⴻⵀ ⵍⴳⴻⵏⵙ-ⴰ!’, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵡⵉ ⴽⵉⴷⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ. ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵛⴻⴽ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ!’ ⵓⵍⴰ: ‘ⵜⵓⴼⵉⴷ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("EX33_13","003_33_13","EXO","33","13","13","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⵛⵛⴻⵄⴱ-ⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("EX33_14","003_33_14","EXO","33","14","14","ⵉⵏⵏⴰ: “ⵍⵎⴰⵍⴰⴽ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⴽ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EX33_15","003_33_15","EXO","33","15","15","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⴰⵍⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵉⵜⵜⵔⵉⵃ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵙⵙⴰ! ");
INSERT INTO rift_vpl VALUES ("EX33_16","003_33_16","EXO","33","16","16","ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵔⵓⵃⴻⴷ ⴰⴽⵉⴷⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ, ⵏⴻⵛⵛ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵏⴼⴰⵔⵔⴻⵣ ⵅ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("EX33_17","003_33_17","EXO","33","17","17","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵄⴰⵡⴻⴷ ⴰⴷ ⴳⴳⴻⵖ ⴰⵡⴰⵍ-ⴰ ⵉ ⵜⴻⵏⵏⵉⴷ ⵓⵎⵉ ⵜⵓⴼⵉⴷ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵙⵙⵏⴻⵖ ⵛⴻⴽ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EX33_18","003_33_18","EXO","33","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵙⵛⴻⵏ ⴰⵢⵉ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("EX33_19","003_33_19","EXO","33","19","19","ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵖ ⵎⴰⵔⵔⴰ ⵜⵛⵓⵏⵉ ⵉⵏⵓ ⵣⵣⴰⵜⴻⴽ ⵓⵛⴰ ⴰⴷ ⵄⴻⵢⵢⴷⴻⵖ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵃⵉⵏⵏⴻⵖ ⵅ ⵡⵉ ⵖⴰ ⵃⵉⵏⵏⴻⵖ, ⴰⴷ ⴰⵔⴻⵃⵎⴻⵖ ⵅ ⵡⵉ ⵖⴰ ⴰⵔⴻⵃⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EX33_20","003_33_20","EXO","33","20","20","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵛⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵥⴰⵔⵔ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("EX33_21","003_33_21","EXO","33","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵅⵣⴰⵔ, ⵣⵣⴰⵜ ⵉⵏⵓ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵜⴱⴻⴷⴷⴻⴷ ⵅ ⵜⴻⵚⴹⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX33_22","003_33_22","EXO","33","22","22","ⵅⵎⵉ ⵖⴰ ⵉⵄⴷⵓ ⵓⵄⵓⴵⵉ ⵉⵏⵓ, ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⴼⴻⴵⵉⵇ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴷⵍⴻⵖ ⵙ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⵍ ⴷⴷ-ⵥⵡⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("EX33_23","003_33_23","EXO","33","23","23","ⵓ ⵅⵎⵉ ⵖⴰ ⴽⴽⵙⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵜⵥⴰⵔⴻⴷ ⵣⵉ ⴹⴻⴼⴼⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⴷ ⵓⴷⴻⵎ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("EX34_1","003_34_1","EXO","34","1","1","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵎⵓⵙⴰ: “ⵇⴻⵙⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⴰⵎ ⵜⵎⴻⵣⵡⵓⵔⴰ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵉⵖ ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏⵏⵉ ⴰⵡⴰⵍⴻⵏ ⴷ ⵉⵊⵊⴻⵏ ⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵉ ⵜⴰⵔⵥⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("EX34_2","003_34_2","EXO","34","2","2","ⵙⴻⵡⵊⴻⴷ ⵉ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⴳⴻⵄⵄⴻⴷ ⴷⵉ ⵚⵚⴱⴻⵃ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵓⵛⴰ ⴱⴻⴷⴷ ⴷⵉⵏ ⵣⵣⴰⵜⵉ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX34_3","003_34_3","EXO","34","3","3","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴽⵉⴷⴻⴽ, ⵏⵉⵖ ⴰⴷ ⵉⴱⴰⵏ ⵃⴻⴷ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⴰⵎ ⵉⴽⵎⴻⵍ. ⵓⵍⴰ ⴷ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵟⵟⴰⵔⴼ ⵉ ⵡⴻⴷⵔⴰⵔ.”    ");
INSERT INTO rift_vpl VALUES ("EX34_4","003_34_4","EXO","34","4","4","ⵅⴻⵏⵏⵉ ⵉⵇⴻⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⴰⵎ ⵜⵎⴻⵣⵡⵓⵔⴰ, ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵎⵓⵙⴰ ⴷⵉ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⴽⵉⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("EX34_5","003_34_5","EXO","34","5","5","ⵉⵀⵡⴰ-ⴷⴷ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵙⴻⵢⵏⵓ, ⵉⴱⴻⴷⴷ ⴰⴽⵉⴷⴻⵙ ⴷⵉⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏ ‘ⵙⵉⴷⵉ’. ");
INSERT INTO rift_vpl VALUES ("EX34_6","003_34_6","EXO","34","6","6","ⵉⵥⵡⴰ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵄⴻⵢⵢⴻⴷ: “ⵙⵉⴷⵉ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵜⴻⵃⵏⵓⵏⴻⵛⵜ, ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EX34_7","003_34_7","EXO","34","7","7","ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵍⵓⵍⵓⴼ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵖⴻⴼⴼⴰⵔⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷ ⵅⴻⵟⵟⵓ ⴷ ⴷⴷⵏⵓⴱ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⵔⵉⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⴻⵏⴱ, ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⴻⵣⴼⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴷⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⴷⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("EX34_8","003_34_8","EXO","34","8","8","ⵎⵓⵙⴰ ⵢⵓⴹⴰⵔ ⵙ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("EX34_9","003_34_9","EXO","34","9","9","ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⵅⴻⵏⵏⵉ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵢⵓⵢⵓⵔ ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵇⵙⴻⵃ. ⵖⴼⴰⵔ ⴰⵏⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵓ ⵇⴱⴻⵍ ⴰⵏⴻⵖ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("EX34_10","003_34_10","EXO","34","10","10","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ. ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⴽ, ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⴻⴵⵉⴷ, ⴰⴷ ⵉⵥⴰⵔ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⴰⴽⵉⴷⴻⴽ ⴰⴷ ⵉⵙⵙⴻⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX34_11","003_34_11","EXO","34","11","11","ⵃⴹⴰ ⵎⵉⵏ ⵅ ⵛⴻⴽ ⵡⴻⵚⵚⵉⵖ ⴰⵙⵙ-ⴰ! ⵅⵣⴰⵔ, ⴰⴷ ⴰⵥⵥⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⵅ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⵉⴱⵓⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX34_12","003_34_12","EXO","34","12","12","ⵖⴰⵔⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵓⵎⴻⵣⴷⵓⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⵉⵍⵉ ⴷ ⵍⴼⴻⵅ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX34_13","003_34_13","EXO","34","13","13","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⵖⴻⴹⵍⴻⵎ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵜⴰⵔⵥⴰⵎ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴰⴷ ⵜⵀⴻⴷⵎⴻⵎ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵛⵡⴰⵔⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EX34_14","003_34_14","EXO","34","14","14","ⵡⴰⵔ ⵜⵜⴱⴻⵏⴷⵉⵇ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵏⴻⵙⵙⴰⵎ’, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("EX34_15","003_34_15","EXO","34","15","15","ⵖⴰⵔⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵎⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵄⴰⵔⴹⴻⵏ ⵉ ⵎⴰⵛⵛⴰ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX34_16","003_34_16","EXO","34","16","16","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏⵜ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵓⵎⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⴰⵔⵔⴻⵏⵜ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX34_17","003_34_17","EXO","34","17","17","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵔⴻⴱⴱⵉⵜⵜⴻⵏ ⵏ ⵓⴼⴻⵙⵙⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("EX34_18","003_34_18","EXO","34","18","18","ⴰⴷ ⵜⴻⵃⴹⵉⴹ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ: ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⴱⵉⴱ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵡⴻⵚⵚⵉⵖ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⴱⵉⴱ ⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX34_19","003_34_19","EXO","34","19","19","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⴰⵔⴻⵣⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵉ ⵖⴰ ⵢⴰⵔⵣⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("EX34_20","003_34_20","EXO","34","20","20","ⵎⴰⵍⴰ ⴰⵎⴻⵏⵣⵓ ⵏ ⵡⴻⵖⵢⵓⵍ ⵢⴰⵔⵣⴻⵎ ⵍⴻⵎⵍⴰⵡⵔⴰⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⴷ ⵜ ⵜⴻⴼⴷⵉⴷ ⵙ ⵢⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵜ ⵜⴻⴼⴷⵉⴷ, ⴰⴷ ⴰⵙ ⵜⴰⵔⵥⴻⴷ ⵉⵔⵉ. ⴰⴷ ⵜⴻⴼⴷⵉⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴹⵀⴰⵔⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EX34_21","003_34_21","EXO","34","21","21","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵅⴻⴷⵎⴻⴷ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ. ⵓⵍⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵢⴰⵔⵣⴰ ⴷ ⵜⵎⴻⵢⵔⴰ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX34_22","003_34_22","EXO","34","22","22","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵄⵉⴷ ⵏ ⵙⵉⵎⴰⵏⴰⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵄⵉⴷ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵜⵎⴻⵢⵔⴰ ⵏ ⵢⵉⵔⴷⴻⵏ, ⵓⵍⴰ ⴷ ⵍⵄⵉⴷ ⵏ ⵓⵙⵎⵓⵏⵉ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX34_23","003_34_23","EXO","34","23","23","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EX34_24","003_34_24","EXO","34","24","24","ⵎⵉⵏⵣⵉ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵅ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⵙⵙⵡⴻⵙⵄⴻⵖ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵎⵎⴻⵥⵔⵉ ⴰⴷ ⵢⴰⵛⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵅⵎⵉ ⵖⴰ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴰⵏⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EX34_25","003_34_25","EXO","34","25","25","ⵡⴰⵔ ⵜⵜⵇⴻⴷⴷⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉⵏⵓ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵅⴻⵎⵎⴰⵔⴻⵏ. ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵡⴰⵔ ⵜⵜⵏⵓⵙⵉ ⴵⵉⵍⴻⵜ ⴰⵍ ⵚⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("EX34_26","003_34_26","EXO","34","26","26","ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵙⵏⴻⵏⵏⵉ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵙ ⵓⵖⵉ ⵏ ⵢⴻⵎⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("EX34_27","003_34_27","EXO","34","27","27","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵔⵉ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵇⵇⴰⵔⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ, ⴰⵇⴰ ⴳⴳⵉⵖ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⴻⴽ ⵓ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EX34_28","003_34_28","EXO","34","28","28","ⵓⵛⴰ ⵎⵓⵙⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ. ⵡⴰⵔ ⵉⵛⵛⵉ ⴰⵖⵔⵓⵎ ⵏⵉⵖ ⵉⵙⵡⴰ ⴰⵎⴰⵏ. ⵓⵛⴰ ⵢⵓⵔⴰ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ, ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX34_29","003_34_29","EXO","34","29","29","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵀⵡⴰ ⵎⵓⵙⴰ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⴰⵎ ⵜⵓⵖⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⵓⵙⴰ ⴰⵎ ⴷⴷ-ⵉⵀⵡⴰ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵓⵙⴰ ⴱⴻⵍⵍⵉ ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵜⴰⵔⴻⵇⵇ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵙⵙⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX34_30","003_34_30","EXO","34","30","30","ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵚⴻⵡⴹⴻⵏ ⵖⴰⵔ ⵎⵓⵙⴰ, ⵓ ⵅⵣⴰⵔ, ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜⴰⵔⴻⵇⵇ, ⴳⴳⵯⴻⴷⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX34_31","003_34_31","EXO","34","31","31","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX34_32","003_34_32","EXO","34","32","32","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EX34_33","003_34_33","EXO","34","33","33","ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⵓⵙⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⴳⴳⴰ ⴰⵍⴻⵃⵃⴰⴼ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX34_34","003_34_34","EXO","34","34","34","ⵅⵎⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⵓⵙⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⴽⴽⴻⵙ ⴰⵍⴻⵃⵃⴰⴼ, ⴰⵍ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ. ⵓ ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX34_35","003_34_35","EXO","34","35","35","ⵓⵛⴰ ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⵎⵓⵙⴰ, ⴰⵇⴰ ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵜⴰⵔⴻⵇⵇ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ ⵎⵓⵙⴰ ⴰⵍⴻⵃⵃⴰⴼ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰⵍ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵄⴰⵡⴻⴷ, ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX35_1","003_35_1","EXO","35","1","1","ⵎⵓⵙⴰ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EX35_2","003_35_2","EXO","35","2","2","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵓ ⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵇⴻⴷⴷⴻⵙ, ⴰⵇⴰ ⴷ ⵙⵙⴻⴱⵜ, ⴰⵔⵔⴰⵃⴻⵜ ⵜⵎⵓⵏ ⵉ ⵙⵉⴷⵉ. ⴽⵓⵍ ⵉⵊⵊ, ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⴳⴳⵉⵏ ⵛⴰ ⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX35_3","003_35_3","EXO","35","3","3","ⵡⴰⵔ ⵜⴻⵙⵙⵔⵓⵖⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("EX35_4","003_35_4","EXO","35","4","4","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴷ ⵡⴰ ⴷ ⵎⵉⵏ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX35_5","003_35_5","EXO","35","5","5","‘ⴽⵙⵉⵎ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ. ⴽⵓⵍ ⵉⵊⵊ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵢⴻⵏⵏⵓⵔⵣⴻⵎ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ: ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("EX35_6","003_35_6","EXO","35","6","6","ⴰⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵛⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX35_7","003_35_7","EXO","35","7","7","ⵉⵍⵎⴰⵡⴻⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("EX35_8","003_35_8","EXO","35","8","8","ⵣⵣⴻⵛⵜ ⵉ ⵜⴼⴰⵡⵜ, ⵍⴻⵄⵟⵓⵔ ⵉ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵓ ⵉ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX35_9","003_35_9","EXO","35","9","9","ⵉⵥⵔⴰ ⵏ ⵓⵏⵉⴽⵙ ⴷ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵏ ⵅ ⵓⴱⴰⵍⵟⵓ ⵓ ⵅ ⵜⴻⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX35_10","003_35_10","EXO","35","10","10","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵙ ⵡⵓⵍ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("EX35_11","003_35_11","EXO","35","11","11","ⵜⴰⵣⴻⴷⴷⵉⵖⵜ, ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⴼⴻⵍⵡⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵢⴰ ⵏⵏⴻⵙ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EX35_12","003_35_12","EXO","35","12","12","ⴷ ⵜⵜⴰⴱⵓⵜ ⴰⴽ-ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⴷ ⵓⵍⴻⵃⵃⴰⴼ ⵉ ⴷⴷⵓⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("EX35_13","003_35_13","EXO","35","13","13","ⴷ ⵜⵣⴻⵡⴹⴰ ⴰⴽ-ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EX35_14","003_35_14","EXO","35","14","14","ⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵉ ⵜⴼⴰⵡⵜ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵜⴻⴼⵜⵉⵍⵉⵏ ⵏⵏⴻⵙ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵜⴼⴰⵡⵜ ");
INSERT INTO rift_vpl VALUES ("EX35_15","003_35_15","EXO","35","15","15","ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ ⴰⴽ-ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⴰⵔⵡⴰⵇ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ");
INSERT INTO rift_vpl VALUES ("EX35_16","003_35_16","EXO","35","16","16","ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵜⴱⴰⵏⵢⵓⵜ ⵙ ⵓⴹⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EX35_17","003_35_17","EXO","35","17","17","ⴷ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ, ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⴰⵔⵡⴰⵇ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("EX35_18","003_35_18","EXO","35","18","18","ⴷ ⵍⴻⵡⵜⴰⴷ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵍⴻⵡⵜⴰⴷ ⵏ ⵍⴻⵎⵔⴰⵃ ⴷ ⵉⴼⵉⵍⴰⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EX35_19","003_35_19","EXO","35","19","19","ⴰⵔⵔⵓⴹ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ, ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴻⴷⵎⴻⵏ ⴰⵎ ⵢⵉⴽⴻⵀⵀⴰⵏⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EX35_20","003_35_20","EXO","35","20","20","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴳⴳⵯⴻⵊⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX35_21","003_35_21","EXO","35","21","21","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴽⵓⵍ ⵉⵊⵊ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵏⵀⴻⵣⵣ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵏⵏⵓⵔⵣⴻⵎ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵜⴻⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴷ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⴷⴰⵢⴻⵙ ⵓ ⵉ ⵡⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX35_22","003_35_22","EXO","35","22","22","ⴰⵎⵎⵓ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵏⵏⵓⵔⵣⴻⵎ ⵡⵓⵍ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⵉⵎⴻⵙⵙⴰⴽⵉⵏ ⴷ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴷ ⵜⵉⵏⵣⴰⵔ ⴷ ⵜⵅⵓⴷⴰⵏ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⴷ ⵜⵙⴻⴷⴷⵉⵢⵉⵏ ⵙ ⵡⴻⴷⵎⴰⵎ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ, ⵡⴰⵀ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵢⵉⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX35_23","003_35_23","EXO","35","23","23","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⵉⵜⵜⵡⴰⴼ ⴰⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵏⵉⵖ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵏⵉⵖ ⵛⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵏⵉⵖ ⵉⵍⵎⴰⵡⴻⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EX35_24","003_35_24","EXO","35","24","24","ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⵏ ⵏⵏⵃⴰⵙ, ⵉⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ-ⴰ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴷ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⵉⵜⵜⵡⴰⴼ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵉⵡⵢⴻⵏ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EX35_25","003_35_25","EXO","35","25","25","ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵙ ⵡⵓⵍ ⴰⵎⵉⵖⵉⵙ ⵜⵜⵇⴰⵔⴹⵛⴻⵏⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵉⵡⵢⴻⵏⵜ-ⵉ-ⴷⴷ ⵎⵉⵏ ⵇⴰⵔⴻⴹⵛⴻⵏⵜ: ⴰⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ.    ");
INSERT INTO rift_vpl VALUES ("EX35_26","003_35_26","EXO","35","26","26","ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵓⵎⵉ ⵉⵏⵀⴻⵣⵣ ⵡⵓⵍ ⵏⵙⴻⵏⵜ ⵙ ⵜⵉⵖⵉⵜ, ⵇⴰⵔⴻⴹⵛⴻⵏⵜ ⵛⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX35_27","003_35_27","EXO","35","27","27","ⵍⵃⵓⴽⴽⴰⵎ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵥⵔⴰ ⵏ ⵓⵏⵉⴽⵙ ⴷ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵏ ⵅ ⵓⴱⴰⵍⵟⵓ ⵓ ⵅ ⵜⴻⵊⵎⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("EX35_28","003_35_28","EXO","35","28","28","ⵍⴻⵄⵟⵓⵔ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵜⴼⴰⵡⵜ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵓ ⵉ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX35_29","003_35_29","EXO","35","29","29","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⵛⵉⵏ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵏⵀⴻⵣⵣ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵛⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX35_30","003_35_30","EXO","35","30","30","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵅⵣⴰⵔⴻⵎ, ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⴱⴰⵚⴰⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ, ⵣⵉ ⵍⴰⴵ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX35_31","003_35_31","EXO","35","31","31","ⵉⵛⵛⵓⵔ ⵉ-ⵜ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⵄⵇⴻⵍ ⴷ ⵜⵓⵙⵙⵏⴰ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⵏ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⵚⵚⵏⴰⵢⴻⵄ ");
INSERT INTO rift_vpl VALUES ("EX35_32","003_35_32","EXO","35","32","32","ⵉ ⵓⵅⴻⵎⵎⴻⵎ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵔⴻⵇⵇⴰⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵢⴻⴳⴳ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("EX35_33","003_35_33","EXO","35","33","33","ⵓ ⵉ ⵓⵏⴻⵇⵇⴰⵛ ⵏ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⴷ ⵓⵙⴰⵔⵙⵉ ⵏⵙⴻⵏ, ⵓ ⵉ ⵓⵏⴻⵇⵇⴰⵛ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵎⴰⵔⵔⴰ ⵉⵔⴻⵇⵇⴰⵎⴻⵏ ⵙ ⵍⴼⴻⵏⵏ. ");
INSERT INTO rift_vpl VALUES ("EX35_34","003_35_34","EXO","35","34","34","ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵜⴰⵡⴻⵏⴳⵉⵜ ⵉ ⵓⵙⴻⵍⵎⴻⴷ, ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⴰⵀⵓⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵙⴰⵎⴰⴽ, ⵣⵉ ⵍⴰⴵ ⵏ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX35_35","003_35_35","EXO","35","35","35","ⵉⵛⵛⵓⵔ ⵉ-ⵜⴻⵏ ⵙ ⵜⵉⵖⵉⵜ ⵏ ⵡⵓⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ: ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⴰⵏⴻⵇⵇⴰⵛⵜ ⴷ ⵡⴰⵔⵛⴰⵎ ⴷ ⵓⵎⵓⴷⵉ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵓⵍⴰ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵅⴻⵢⵢⴰⴹ.” ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴽⵓⵍ ⵍⵅⴻⴷⵎⴻⵜ ⵓ ⵜⵜⵙⴰⵇⴰⵔⴻⵏ ⴰⵔⵛⴰⵎⴻⵏ ⵙ ⵍⴼⴻⵏⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_1","003_36_1","EXO","36","1","1","ⴱⴰⵚⴰⵍⵉⵢⵉⵍ ⴷ ⴰⵀⵓⵍⵉⵢⴰⴱ ⴷ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵙ ⵡⵓⵍ ⴰⵎⵉⵖⵉⵙ ⵉ ⵓⵎⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⵄⵇⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EX36_2","003_36_2","EXO","36","2","2","ⵎⵓⵙⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⴱⴰⵚⴰⵍⵉⵢⵉⵍ ⴷ ⴰⵀⵓⵍⵉⵢⴰⴱ ⴷ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵙ ⵡⵓⵍ ⴰⵎⵉⵖⵉⵙ, ⵓⵎⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵜⵉⵖⵉⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵏⵀⴻⵣⵣ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("EX36_3","003_36_3","EXO","36","3","3","ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ. ⵓⵛⴰ ⴰⵇⴰ ⵄⴰⴷ ⴳⴳⵉⵏ ⴰⴷ ⴰⵙ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵙ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX36_4","003_36_4","EXO","36","4","4","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⴻⵖⵍⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵊⵊ ⵉⵊⵊ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EX36_5","003_36_5","EXO","36","5","5","ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵏⵏⴰⵏ: “ⵍⴳⴻⵏⵙ ⵢⵉⵡⵉ-ⴷⴷ ⴽⵜⴰⵔ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵏⴻⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("EX36_6","003_36_6","EXO","36","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⴷ ⵉⵏⵉⵏ: “ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵔⵢⴰⵣ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵄⴰⴷ ⴰⴷ ⵢⴻⴳⴳ ⵛⴰ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ!” ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵎⵓⵙⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⴰⵡⵉ ⵄⴰⴷ ⴽⵜⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("EX36_7","003_36_7","EXO","36","7","7","ⵎⵉⵏⵣⵉ ⵛⴼⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⴷ ⵉⵡⵢⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵖⴰ ⴳⴳⴻⵏ, ⴰⵇⴰ ⵜⵛⴻⵟⵟ ⵄⴰⴷ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX36_8","003_36_8","EXO","36","8","8","ⵊⴰⵔ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵜⵓⵖⴰ ⵍⵅⴻⴷⵎⴻⵜ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⵡⵓⵍ ⴳⴳⵉⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵣⵉ ⵄⴻⵛⵔⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴰⴽ-ⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵏⵏⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵔⵛⴰⵎ ⵏ ⵓⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_9","003_36_9","EXO","36","9","9","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⴻⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵜⵓⵖⴰ-ⵜ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵖⴰⵔⵙⴻⵏⵜ ⴷ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EX36_10","003_36_10","EXO","36","10","10","ⵉⵙⵙⵎⵓⵏ ⵅⴻⵎⵙⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵅⴻⵎⵙⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏⵜ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_11","003_36_11","EXO","36","11","11","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵜⵉⵙⴰⵔⴰⵡⵉⵏ ⵉⴷⴻⵃⵎⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⵎⴰ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵖⴰⵔ ⵓⵙⴻⵍⵇⵉ ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⵜⴻⵏⵜ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⵎⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ, ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX36_12","003_36_12","EXO","36","12","12","ⵉⴳⴳⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵅ ⵜⵎⴰ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵖⵏⵉ. ⵜⵉⵙⴰⵔⴰⵡⵉⵏ ⵟⵟⴼⴻⵏⵜ ⵏⵉⵛⴰⵏ ⵉⵛⵜ ⴷⵉ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_13","003_36_13","EXO","36","13","13","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵉⵛⵜ ⵉ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵜⴻⴷⵡⴻⵍ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵉⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_14","003_36_14","EXO","36","14","14","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵜⵉⵊⴰⵍⵜⵉⵍⵉⵏ ⵏ ⵛⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ, ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⴰⵇⵉⴹⵓⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ. ⵉⴳⴳⴰ ⵃⵉⵟⴰⵛ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_15","003_36_15","EXO","36","15","15","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵃⵉⵟⵄⴰⵛ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵖⴰⵔⵙⴻⵏⵜ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EX36_16","003_36_16","EXO","36","16","16","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ ⵅⴻⵎⵙⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ ⵓ ⵄⴰⵡⴻⴷ ⵙⴻⵜⵜⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_17","003_36_17","EXO","36","17","17","ⵉⴳⴳⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵅ ⵜⵎⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵓⵙⴻⵍⵇⵉ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴰⵔⴰⵡⵉⵏ ⵅ ⵜⵎⴰ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX36_18","003_36_18","EXO","36","18","18","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵏⵏⵃⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⴰⵇⵉⴹⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_19","003_36_19","EXO","36","19","19","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵉ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵛⵜ ⵏ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_20","003_36_20","EXO","36","20","20","ⵉⴳⴳⴰ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_21","003_36_21","EXO","36","21","21","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_22","003_36_22","EXO","36","22","22","ⴽⵓⵍ ⵜⴰⴼⵍⴻⵡⵜ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵎⴻⵍⵇⴰⵏ ⵉⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ ⴰⵎ ⵜⵡⴻⵍⵜⵎⴰⵜⵉⵏ ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_23","003_36_23","EXO","36","23","23","ⵉⴳⴳⴰ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EX36_24","003_36_24","EXO","36","24","24","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵙⴰⴷⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵜⴰⴼⵍⴰⵡⵜ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX36_25","003_36_25","EXO","36","25","25","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵉ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EX36_26","003_36_26","EXO","36","26","26","ⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⵜⴰⴼⵍⴰⵡⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX36_27","003_36_27","EXO","36","27","27","ⵉ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ, ⵉⴳⴳⴰ ⵙⴻⵜⵜⴰ ⵏ ⵜⴼⴻⵍⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX36_28","003_36_28","EXO","36","28","28","ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⴷ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵉ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX36_29","003_36_29","EXO","36","29","29","ⵣⵉ ⵙⵡⴰⴷⴷⴰⵢ ⵜⵓⵖⴰ ⵍⴻⵚⵇⴻⵏⵜ ⴰⵎ ⵡⴰⵛⵏⵉⵡⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵏⵜ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜⴻⵏ ⴰⵍ ⴷⴷ-ⴰⵡⴹⴻⵏⵜ ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵅⵔⴰⵣⵜ. ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX36_30","003_36_30","EXO","36","30","30","ⴰⵎⵎⵓ ⵉ ⴷⵉⵏ ⵜⵓⵖⴰ ⵜⵎⴻⵏⵢⴰ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵙ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵙⴻⵟⵟⴰⵛ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⴼⵍⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_31","003_36_31","EXO","36","31","31","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ, ⵅⴻⵎⵙⴰ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ");
INSERT INTO rift_vpl VALUES ("EX36_32","003_36_32","EXO","36","32","32","ⵓ ⵅⴻⵎⵙⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵉ ⵜⴼⴻⵍⵡⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵉ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⴹⴻⴼⴼⴰⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ. ");
INSERT INTO rift_vpl VALUES ("EX36_33","003_36_33","EXO","36","33","33","ⵜⴰⵃⵏⴰⵛⵜ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⴷⵉ ⵍⵡⴻⵙⵟ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜⴻⵥⵡⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵣⴻⴳ ⵉⵅⴻⴼ ⴰⵍ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX36_34","003_36_34","EXO","36","34","34","ⵉⵖⴻⴵⴻⴼ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵙ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵉⵅⵔⴰⵣⵉⵏ ⵏⵙⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵉⵛⴻⵍⵍⴻⵍ ⵉ-ⵜⴻⵏⵜ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX36_35","003_36_35","EXO","36","35","35","ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵔⵛⴰⵎ ⵏ ⵓⴼⴻⵏⵏⴰⵏ ⴰⴽ-ⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX36_36","003_36_36","EXO","36","36","36","ⵉⴳⴳⴰ ⴰⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ⵉⵙⵙⴻⴼⵙⵉ ⵉ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX36_37","003_36_37","EXO","36","37","37","ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⴰⵔⵡⴰⵇ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵓⵅⴻⵢⵢⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("EX36_38","003_36_38","EXO","36","38","38","ⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵏⴻⵙ. ⵉⵖⴻⴵⴻⴼ ⵜⵉⵣⴻⴵⵉⴼⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵙ ⵡⵓⵔⴻⵖ. ⵜⵉⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX37_1","003_37_1","EXO","37","1","1","ⵉⴳⴳⴰ ⴱⴰⵚⴰⵍⵉⵢⵉⵍ ⵜⵜⴰⴱⵓⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ. ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓⵛⴰ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_2","003_37_2","EXO","37","2","2","ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜ ⵣⵉ ⴷⴰⵅⴻⵍ ⴷ ⴱⴰⵔⵔⴰ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_3","003_37_3","EXO","37","3","3","ⵉⵙⵙⴻⴼⵙⵉ ⴰⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵙ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX37_4","003_37_4","EXO","37","4","4","ⵉⴳⴳⴰ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX37_5","003_37_5","EXO","37","5","5","ⵉⴳⴳⴰ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷⵉ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⵜⴰⴱⵓⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX37_6","003_37_6","EXO","37","6","6","ⵉⴳⴳⴰ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵙ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_7","003_37_7","EXO","37","7","7","ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵏ ⵡⵓⵔⴻⵖ. ⵉⵄⴷⴻⵍ ⵉ-ⵜⴻⵏ ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵡⴻⵎⵣⵉⵍ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX37_8","003_37_8","EXO","37","8","8","ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵉⵅⴻⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⴰⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ⵉⴳⴳⴰ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX37_9","003_37_9","EXO","37","9","9","ⵉⴽⵉⵔⵓⴱⴻⵏ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵓⵛⴰ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⴷⵍⵉⵏ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵊⵊⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⴷ ⵉⵛⵜⴻⵏ ⵜⵓⵖⴰ ⵉⵖⴻⵎⴱⴰⴱ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵖⴰⵔ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX37_10","003_37_10","EXO","37","10","10","ⵉⴳⴳⴰ ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ. ⵜⵓⵖⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_11","003_37_11","EXO","37","11","11","ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_12","003_37_12","EXO","37","12","12","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵎⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔ ⵏ ⵓⴼⵓⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ ⵖⴰⵔ ⵜⵎⴻⵡⵡⴰ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_13","003_37_13","EXO","37","13","13","ⵉⵙⵙⴻⴼⵙⵉ ⴰⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵉⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX37_14","003_37_14","EXO","37","14","14","ⵜⵓⵖⴰ ⵜⵉⵅⵔⴰⵣⵉⵏ ⵣⵣⴰⵜ ⵏ ⵜⵎⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⵜⴰⵣⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EX37_15","003_37_15","EXO","37","15","15","ⵉⴳⴳⴰ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⵜⴰⵣⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EX37_16","003_37_16","EXO","37","16","16","ⵉⴳⴳⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵅ ⵜⵣⴻⵡⴹⴰ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ: ⵟⵟⴱⴰⵚⵉ ⵏⵏⴻⵙ ⴷ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⵏⵏⴻⵙ ⴷ ⵍⴽⵉⵙⴰⵏ ⵏⵏⴻⵙ ⴷ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴽⴻⴱⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_17","003_37_17","EXO","37","17","17","ⵉⴳⴳⴰ ⵍⵇⴻⵏⴷⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ⵉⵄⴷⴻⵍ ⵍⵇⴻⵏⴷⵉⵍ ⵙ ⵡⴻⴼⴹⵉⵙ ⵏ ⵡⴻⵎⵣⵉⵍ: ⴰⴼⵓⴷ ⵅ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴷ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴽⵉⵙⴰⵏ ⵏⵏⴻⵙ ⴷ ⵜⵄⴻⴱⴱⵓⵣⵉⵏ ⵏⵏⴻⵙ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵡⴰⵔⴰⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_18","003_37_18","EXO","37","18","18","ⵣⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵇⴻⵏⴷⵉⵍ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵇⴻⵏⴷⵉⵍ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EX37_19","003_37_19","EXO","37","19","19","ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵍⴽⵉⵙⴰⵏ ⴰⵎ ⵏⵏⴻⵡⵡⴰⵛ ⵏ ⴵⴻⵡⵣ ⵙ ⵜⵄⴻⴱⴱⵓⵣⵜ ⴷ ⵏⵏⴻⵡⵡⴰⵛ ⵓⵛⴰ ⵅ ⵓⵖⵉⵍ ⵏⵏⴻⵖⵏⵉ ⵄⴰⵡⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵍⴽⵉⵙⴰⵏ ⴰⵎ ⵏⵏⴻⵡⵡⴰⵛ ⵏ ⴵⴻⵡⵣ ⵙ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵏⵏⴻⵡⵡⴰⵛ. ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰⵏ ⵎⴰⵔⵔⴰ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX37_20","003_37_20","EXO","37","20","20","ⵖⴰⵔ ⵍⵇⴻⵏⴷⵉⵍ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⴽⵉⵙⴰⵏ ⴰⵎ ⵏⵏⵓⵡⴰⵔⴰⵜ ⵏ ⴵⴻⵡⵣ ⴰⴽ-ⴷ ⵜⵄⴻⴱⴱⵓⵣⵉⵏ ⵏⵙⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵡⴰⵔⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_21","003_37_21","EXO","37","21","21","ⵙⴰⴷⵓ ⵜⵢⵓⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵙⴰⴷⵓ ⵜⵢⵓⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵜ ⵙⴰⴷⵓ ⵜⵢⵓⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ. ⵎⴰⵏ ⴰⵢⴰ ⵉⴵⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_22","003_37_22","EXO","37","22","22","ⵜⵓⵖⴰ ⵜⵉⵄⴻⴱⴱⵓⵣⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵖⴰⴵⴻⵏ ⵏⵙⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ. ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵡⴻⵎⵣⵉⵍ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_23","003_37_23","EXO","37","23","23","ⵉⴳⴳⴰ ⵙⴻⵜⵜⴰ ⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ ⵏ ⵜⴻⴼⵜⵉⵍⵜ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("EX37_24","003_37_24","EXO","37","24","24","ⵉⴳⴳⴰ ⵍⵇⴻⵏⴷⵉⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_25","003_37_25","EXO","37","25","25","ⵉⴳⴳⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵙ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵉⵊⵊ ⵓⵖⵉⵍ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ. ⵜⵓⵖⴰ-ⵜ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ. ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵣⵣⴰⵢⴻⵙ ⵜⵓⵖⴰ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⴰⴽⵉⴷⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("EX37_26","003_37_26","EXO","37","26","26","ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵏ ⵙⴻⵏⵏⴻⵊ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓ ⵄⴰⵡⴻⴷ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⵉⴳⴳⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵣⵣⵡⴰⵇ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX37_27","003_37_27","EXO","37","27","27","ⵉⴳⴳⴰ ⴰⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵙⴰⴷⵓ ⵣⵣⵡⴰⵇ ⵏⵏⴻⵙ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵉⵄⵓⵎⴰⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴱⵓⵏ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EX37_28","003_37_28","EXO","37","28","28","ⵉⴳⴳⴰ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX37_29","003_37_29","EXO","37","29","29","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵣⵣⴻⵛⵜ ⵜⴰⵎⵇⴻⴷⴷⴻⵙⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵚⴼⴰⵏ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵚⵚⴻⵏⵄⴻⵜ ⵏ ⵓⵄⴻⵟⵟⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX38_1","003_38_1","EXO","38","1","1","ⵉⴳⴳⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ. ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵜⵓⵖⴰ-ⵜ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ, ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_2","003_38_2","EXO","38","2","2","ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵉⴳⴳⴰ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜ ⵙ ⵏⵏⵃⴰⵙ.    ");
INSERT INTO rift_vpl VALUES ("EX38_3","003_38_3","EXO","38","3","3","ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵓⵄⴰⵍⵟⴰⵔ: ⵜⵉⵢⴷⵓⵔⵉⵏ ⴷ ⵉⵖⴻⵏⵊⴰⵢⴻⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⴼⵓⵔⵛⴰⵢⴰⵜ ⴷ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ, ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX38_4","003_38_4","EXO","38","4","4","ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵔⴰⵛⵛⴰ ⵉ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵏⵏⵃⴰⵙ ⵙⴰⴷⵓ ⵜⵎⴰ ⵏⵏⴻⵙ, ⵙⵡⴰⴷⴷⴰⵢ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX38_5","003_38_5","EXO","38","5","5","ⵉⵙⵙⴻⴼⵙⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⵔⴰⵛⵛⴰ ⵏ ⵏⵏⵃⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX38_6","003_38_6","EXO","38","6","6","ⵉⴳⴳⴰ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX38_7","003_38_7","EXO","38","7","7","ⵉⴳⴳⴰ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷⵉ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜ ⴰⵔⴱⵓⵏ. ⵉⴳⴳⴰ ⵉ-ⵜ ⵙ ⵜⴼⴻⵍⵡⵉⵏ ⴰⴽ-ⴷ ⵍⵅⴰⵡⵉ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EX38_8","003_38_8","EXO","38","8","8","ⵉⴳⴳⴰ ⵜⴰⴱⴰⵏⵢⵓⵜ ⵏ ⵏⵏⵃⴰⵙ ⵙ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⵏ ⵏⵏⵃⴰⵙ ⵣⵉ ⵜⵉⵙⵉⵜⵉⵏ ⵏ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵅⴻⴷⵎⴻⵏⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX38_9","003_38_9","EXO","38","9","9","ⵉⴳⴳⴰ ⵍⴻⵎⵔⴰⵃ. ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ, ⵜⵓⵖⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_10","003_38_10","EXO","38","10","10","ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX38_11","003_38_11","EXO","38","11","11","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⵉⵣⴰⵔⴰⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴰⴽ-ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⵓ ⴰⴽ-ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX38_12","003_38_12","EXO","38","12","12","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴰⴽ-ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX38_13","003_38_13","EXO","38","13","13","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵏⵇⴰⵔ ⵏ ⵜⴼⵓⵛⵜ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_14","003_38_14","EXO","38","14","14","ⵜⵓⵖⴰ ⵍⵉⵣⴰⵔⴰⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_15","003_38_15","EXO","38","15","15","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏⵏⴻⵖⵏⵉ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⴷ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⵉ, ⵜⵓⵖⴰ ⵍⵉⵣⴰⵔⴰⵜ ⴷⴰⵢⵙⴻⵏⵜ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ, ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_16","003_38_16","EXO","38","16","16","ⵎⴰⵔⵔⴰ ⵍⵉⵣⴰⵔⴰⵜ ⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍⴻⵎⵔⴰⵃ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_17","003_38_17","EXO","38","17","17","ⵜⵉⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⵜⴰⴽⵓⵔⵙⵉⵜ ⵅ ⵜⵣⴻⴵⵉⴼⵉⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⵣⵉ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵉⵇⴻⴹⴱⴰⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵓⵙⴻⵍⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("EX38_18","003_38_18","EXO","38","18","18","ⴰⵔⵡⴰⵇ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ ⴳⴳⵉⵏ ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵓⵅⴻⵢⵢⴰⴹ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵔⵓ ⵏ ⵍⴻⵎⵔⴰⵃ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴰⵎ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX38_19","003_38_19","EXO","38","19","19","ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵏⵏⵃⴰⵙ ⴷ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⵜⴰⴽⵓⵔⵙⵉⵜ ⵅ ⵜⵣⴻⴵⵉⴼⵉⵏ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵇⴻⴹⴱⴰⵏ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EX38_20","003_38_20","EXO","38","20","20","ⵎⴰⵔⵔⴰ ⵍⴻⵡⵜⴰⴷ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵍⴻⵎⵔⴰⵃ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EX38_21","003_38_21","EXO","38","21","21","ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵎⵉⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵓⵛⴰ ⵣⴻⵎⵎⴻⵏ ⵜ ⵙ ⵍⵓⵎⵓⵔ ⵏ ⵎⵓⵙⴰ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵜⴰⵎⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_22","003_38_22","EXO","38","22","22","ⴱⴰⵚⴰⵍⵉⵢⵉⵍ ⵎⵎⵉⵙ ⵏ ⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX38_23","003_38_23","EXO","38","23","23","ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⴰⵀⵓⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵙⴰⵎⴰⴽ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵏⴻⵇⵇⴰⵛ ⴷ ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ, ⴰⵅⴻⵢⵢⴰⴹ ⵏ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EX38_24","003_38_24","EXO","38","24","24","ⵎⴰⵔⵔⴰ ⵓⵔⴻⵖ ⵉ ⵙⵙⵅⴻⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⴳⴳⵉⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵓⵔⴻⵖ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ, ⵜⵓⵖⴰ: ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵓ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_25","003_38_25","EXO","38","25","25","ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⴷ ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_26","003_38_26","EXO","38","26","26","ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵣⵢⴻⵏ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵡⵉ ⵛⵉⵇⵍⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵄⴷⵓⵏ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX38_27","003_38_27","EXO","38","27","27","ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙⵙⴼⴻⵙⵢⴻⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵓⵍⴻⵃⵃⴰⴼ: ⵎⵢⴰ ⵏ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵣⵉ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵢⴰⵔⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX38_28","003_38_28","EXO","38","28","28","ⵣⴻⴳ ⵡⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ ⵉⴳⴳⴰ ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵉ ⵉⴱⵉⵍⴰⵔⴻⵏ. ⵉⵖⴻⴵⴻⴼ ⵜⵉⵣⴻⴵⵉⴼⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵛⴻⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵇⴻⴹⴱⴰⵏ ⵉ ⵓⵙⴻⵍⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("EX38_29","003_38_29","EXO","38","29","29","ⵏⵏⵃⴰⵙ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵜⵓⵖⴰ-ⵜ ⵙⴻⴱⵄⵉⵏ ⵜⴰⵍⵉⵏⵜ ⴷ ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("EX38_30","003_38_30","EXO","38","30","30","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉⴳⴳⴰ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ");
INSERT INTO rift_vpl VALUES ("EX38_31","003_38_31","EXO","38","31","31","ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵜⴰⴷ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵜⴰⴷ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍⴻⵎⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX39_1","003_39_1","EXO","39","1","1","ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⴰⵔⵔⵓⴹ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵙ ⵓⴼⵉⵍⵉ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵄⴰⵡⴻⴷ ⴳⴳⵉⵏ ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵀⴰⵔⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_2","003_39_2","EXO","39","2","2","ⵉⴳⴳⴰ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_3","003_39_3","EXO","39","3","3","ⵏⵉⵜⵏⵉ ⴱⴻⵣⵣⵄⴻⵏ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵇⴻⵙⵙⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴼⵉⵍⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵅⴻⵢⵢⴹⴻⵏ ⵊⴰⵔ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵊⴰⵔ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵎ ⵜⵜ ⵉⵜⵜⴻⴳⴳ ⵓⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_4","003_39_4","EXO","39","4","4","ⴳⴳⵉⵏ ⴰⵙ ⵜⵉⵖⴰⵔⴹⵉⵏ ⵉⵎⵙⴻⵍⵙⴰⵇⴻⵏ ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⴰⴱⴰⵍⵟⵓ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX39_5","003_39_5","EXO","39","5","5","ⵜⴰⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵓⴱⴰⵍⵟⵓ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⵜⴻⵍⵙⴻⵇ ⴷⴰⵢⴻⵙ, ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⴰⴽⵉⴷⴻⵙ. ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵙ ⵡⴻⴱⵔⵉⴷ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵓⴱⴰⵍⵟⵓ ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_6","003_39_6","EXO","39","6","6","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵥⵔⴰ ⵏ ⵓⵏⵉⴽⵙ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵛⵓⵢⴰⵔ ⵏ ⵡⵓⵔⴻⵖ, ⵏⴻⵇⵛⴻⵏ ⵜⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵏⵇⴰⵛ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EX39_7","003_39_7","EXO","39","7","7","ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ, ⴰⵎ ⵉⵥⵔⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_8","003_39_8","EXO","39","8","8","ⵉⴳⴳⴰ ⵜⴰⵊⵎⴻⵛⵜ, ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵎ ⵜⵜ ⵉⵜⵜⴻⴳⴳ ⵓⴼⴻⵏⵏⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴰⴱⴰⵍⵟⵓ, ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_9","003_39_9","EXO","39","9","9","ⵜⵓⵖⴰ-ⵜⵜ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ. ⴹⴻⴼⵙⴻⵏ ⵜⴰⵊⵎⴻⵛⵜ. ⵜⵓⵖⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ. ⵜⵓⵖⴰ ⵉⴹⴼⴻⵙ ⵅ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_10","003_39_10","EXO","39","10","10","ⵙⴻⵜⵜⴼⴻⵏ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⴻⵚⴼⵓⴼ ⵏ ⵢⴻⵥⵔⴰ: ⵉⵊⵊ ⵏ ⵚⵚⴻⴼ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⵇⵉⵇ ⴷ ⴰⵣⴻⴳⴳⵡⴰⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⵢⴰⵇⵓⵜ ⴷ ⵢⵉⵛⵜ ⵏ ⵙⵎⴰⵔⴰⵅⵜ. ⴷ ⵡⴰ ⴷ ⵚⵚⴻⴼ ⴰⵎⴻⵣⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX39_11","003_39_11","EXO","39","11","11","ⵚⵚⴻⴼ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⴽⴰⵔⴱⵓⵏⴽⴻⵍ ⴷ ⵢⵉⵊⵊ ⵏ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ ⴷ ⵢⵉⵊⵊ ⵏ ⴷⵉⴰⵎⴰⵏⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EX39_12","003_39_12","EXO","39","12","12","ⵚⵚⴻⴼ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵢⴰⵙⵉⵏⵜⵓ ⴷ ⵢⵉⵊⵊ ⵏ ⴰⵅⴰⵜ ⴷ ⵢⵉⵊⵊ ⵓⵎⴰⵜⵉⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EX39_13","003_39_13","EXO","39","13","13","ⵚⵚⴻⴼ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵏⵉⴽⵙ ⴷ ⵢⵉⵊⵊ ⵏ ⵢⴰⵙⴱⵉⵙ. ⵜⵓⵖⴰ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵛⵓⵢⴰⵔ ⵏⵙⴻⵏ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EX39_14","003_39_14","EXO","39","14","14","ⵉⵥⵔⴰ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵥⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵙ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵛⴻⵎⵎⵉⵄ, ⴽⵓⵍ ⴰⵏⴻⵇⵇⴰⵛ ⴰⴽ-ⴷ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ. ⴰⵇⴰ ⴰⵜⴻⵏ ⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EX39_15","003_39_15","EXO","39","15","15","ⵖⴰⵔ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⴻⵊⵎⴻⵛⵜ ⴳⴳⵉⵏ ⵜⵉⵙⴻⴷⴷⵢⵉⵏ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⵜⵉⵏⵏⵉ ⵉⵎⵓⴷⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("EX39_16","003_39_16","EXO","39","16","16","ⴳⴳⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵛⵓⵢⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵛⴻⴷⴷⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⴻⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX39_17","003_39_17","EXO","39","17","17","ⵛⴻⴷⴷⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵎⵓⴷⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵖⴰⵔ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵜⴻⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EX39_18","003_39_18","EXO","39","18","18","ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵎⵓⴷⴻⵏ, ⵛⴻⴷⴷⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵛⵓⵢⴰⵔ ⵓⵛⴰ ⵡⵛⵉⵏ ⵜⴻⵏ ⵅ ⵟⵖⴰⵔⴹⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ, ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX39_19","003_39_19","EXO","39","19","19","ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵛⴻⴷⴷⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵊⵎⴻⵛⵜ, ⴷⵉ ⵜⵎⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⴱⴰⵍⵟⵓ, ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EX39_20","003_39_20","EXO","39","20","20","ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵛⴻⴷⴷⴻⵏ ⵜⴻⵏⵜ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵔⴹⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ, ⵙⵡⴰⴷⴷⴰⵢ, ⵖⴰⵔ ⵣⵣⴰⵜ, ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵙⴻⵍⵇⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵓⴱⴰⵍⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("EX39_21","003_39_21","EXO","39","21","21","ⵓⵛⴰ ⵛⴻⴷⴷⴻⵏ ⵜⴰⵊⵎⴻⵛⵜ ⵙ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵓⴱⴰⵍⵟⵓ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴱⴻⵟⵟⵉ ⵜⴻⵊⵎⴻⵛⵜ ⵅ ⵓⴱⴰⵍⵟⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_22","003_39_22","EXO","39","22","22","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⴰⵙⴻⵍⵀⴰⵎ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵜⵜⴻⴳⴳ ⵓⵅⴻⵢⵢⴰⴹ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⴷⴻⵃⵎⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_23","003_39_23","EXO","39","23","23","ⴰⵔⵣⴰⵎ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⴰⵔⵣⴰⵎ ⵏ ⵢⵉⵔⵉ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ. ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵡⴰⵔⵣⴰⵎ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵛⴰⵔⵔⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("EX39_24","003_39_24","EXO","39","24","24","ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⴳⴳⵉⵏ ⵜⵉⵔⴻⵎⵎⴰⵏⵉⵏ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵣⴻⴳ ⵉⴼⵉⵍⴰⵏ ⵉⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_25","003_39_25","EXO","39","25","25","ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⵏⵏⵡⴰⵇⴻⵙ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵏⵏⵡⴰⵇⴻⵙ ⵏⵏⵉ ⵊⴰⵔ ⵜⵔⴻⵎⵎⴰⵏⵉⵏ ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵙⴻⵍⵀⴰⵎ, ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵊⴰⵔ ⵜⵔⴻⵎⵎⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_26","003_39_26","EXO","39","26","26","ⵉⵊⵊ ⵏ ⵏⵏⴰⵇⵓⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵔⴻⵎⵎⴰⵏⵜ, ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵏⵏⴰⵇⵓⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵔⴻⵎⵎⴰⵏⵜ ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⴳⴳⴻⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_27","003_39_27","EXO","39","27","27","ⴳⴳⵉⵏ ⵜⵛⴰⵎⵉⵔ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵜⵜⴻⴳⴳ ⵓⵅⴻⵢⵢⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("EX39_28","003_39_28","EXO","39","28","28","ⴰⵔⴻⵥⵥⴻⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵜⵛⵓⵛⵛⴰⵢ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵙⵙⵔⴰⵡⴻⵍ ⵏ ⵍⴻⵇⵟⴻⵏ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EX39_29","003_39_29","EXO","39","29","29","ⵓ ⵜⵓⵖⴰ ⵜⴰⵃⴻⵣⵣⴰⵎⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵎⵓⴷⴻⵏ ⵓ ⵏ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵏ ⵓⵅⴻⵢⵢⴰⴹ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_30","003_39_30","EXO","39","30","30","ⴳⴳⵉⵏ ⵜⴰⵍⵡⵉⵃⵜ ⵙ ⵏⵏⵓⵡⴰⵔ ⵏ ⵜⵜⴰⵊ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⵏⴻⵇⵛⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵔⴰ-ⵢⴰ: “ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ!”, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵇⵛⴻⵏ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("EX39_31","003_39_31","EXO","39","31","31","ⵓⵛⴰ ⵛⴻⴷⴷⴻⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵉⵎⵓⴷⴻⵏ ⴰⴷⴻⵃⵎⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴰⵢⵍⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⴰⵔⴻⵥⵥⴻⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_32","003_39_32","EXO","39","32","32","ⴰⵎⵎⵓ ⵉ ⵜⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵇⴰ ⴳⴳⵉⵏ ⵜⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⴰⵎⵎⵓ ⵉ ⵜⵜ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_33","003_39_33","EXO","39","33","33","ⴽⵙⵉⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵎⵓⵙⴰ, ⴰⵇⵉⴹⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⴼⴻⵍⵡⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵢⴰ ⵏⵏⴻⵙ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("EX39_34","003_39_34","EXO","39","34","34","ⴷ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⴷ ⵓⵍⴻⵃⵃⴰⴼ ⵉ ⴷⴷⵓⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("EX39_35","003_39_35","EXO","39","35","35","ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ");
INSERT INTO rift_vpl VALUES ("EX39_36","003_39_36","EXO","39","36","36","ⴷ ⵜⴰⵣⴻⵡⴹⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ");
INSERT INTO rift_vpl VALUES ("EX39_37","003_39_37","EXO","39","37","37","ⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ - ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏⵜ, ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵜⴼⴰⵡⵜ - ");
INSERT INTO rift_vpl VALUES ("EX39_38","003_39_38","EXO","39","38","38","ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⴰⵔⵡⴰⵇ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ");
INSERT INTO rift_vpl VALUES ("EX39_39","003_39_39","EXO","39","39","39","ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵙ ⵜⵔⴰⵛⵛⴰ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷ ⵜⴱⴰⵏⵢⵓⵜ ⴰⴽ-ⴷ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("EX39_40","003_39_40","EXO","39","40","40","ⴷ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⴰⴽ-ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⴰⵔⵡⴰⵇ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ ⴷ ⵉⴼⵉⵍⴰⵏ ⵏⵏⴻⵙ ⴷ ⵍⴻⵡⵜⴰⴷ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ");
INSERT INTO rift_vpl VALUES ("EX39_41","003_39_41","EXO","39","41","41","ⵓⵍⴰ ⴷ ⴰⵔⵔⵓⴹ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⴷ ⴰⵔⵔⵓⴹ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX39_42","003_39_42","EXO","39","42","42","ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX39_43","003_39_43","EXO","39","43","43","ⵉⵅⵣⴰⵔ ⵎⵓⵙⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵓⵛⴰ ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ-ⵜⵜ ⴳⴳⵉⵏ. ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_1","003_40_1","EXO","40","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EX40_2","003_40_2","EXO","40","2","2","“ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ, ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX40_3","003_40_3","EXO","40","3","3","ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⵍⴻⴷ ⵜⵜⴰⴱⵓⵜ ⵙ ⵓⵍⴻⵃⵃⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("EX40_4","003_40_4","EXO","40","4","4","ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵜⴰⵣⴻⵡⴹⴰ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⵙⴻⵜⵜⴼⴻⴷ ⴰⵙⴻⵜⵜⴻⴼ ⵏⵏⴻⵙ. ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵍⵇⴻⵏⴷⵉⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵖⴻⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX40_5","003_40_5","EXO","40","5","5","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵍⴻⴱⵅⵓⵔ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⵡⴰⵇ ⵏ ⵡⴰⴷⴰⴼ ⵣⵣⴰⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_6","003_40_6","EXO","40","6","6","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⵣⴰⵜ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EX40_7","003_40_7","EXO","40","7","7","ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⴰⴱⴰⵏⵢⵓⵜ ⵊⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX40_8","003_40_8","EXO","40","8","8","ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵍⴻⵎⵔⴰⵃ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴰⵢⵍⴻⴷ ⴰⵔⵡⴰⵇ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EX40_9","003_40_9","EXO","40","9","9","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴷⴻⵀⵏⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ. ⴰⴷ ⵜⵉⵍⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_10","003_40_10","EXO","40","10","10","ⴰⴷ ⵜⴷⴻⵀⵏⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ. ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ. ⴰⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EX40_11","003_40_11","EXO","40","11","11","ⴰⴷ ⵜⴷⴻⵀⵏⴻⴷ ⵜⴰⴱⴰⵏⵢⵓⵜ ⴷ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX40_12","003_40_12","EXO","40","12","12","ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX40_13","003_40_13","EXO","40","13","13","ⴰⴷ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⴷ ⵉ ⵀⴰⵔⵓⵏ ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴷⴻⵀⵏⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵢⵉⵍⵉ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("EX40_14","003_40_14","EXO","40","14","14","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵢⴰⵔⴹⴻⴷ ⵜⵛⴰⵎⵉⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_15","003_40_15","EXO","40","15","15","ⴰⴷ ⵜⴻⵏ ⵜⴷⴻⵀⵏⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴷⴻⵀⵏⴻⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵢⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⴷⵀⴰⵏ ⵏⵙⴻⵏ ⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EX40_16","003_40_16","EXO","40","16","16","ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⵜ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_17","003_40_17","EXO","40","17","17","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ, ⴰⵇⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_18","003_40_18","EXO","40","18","18","ⵎⵓⵙⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ, ⵉⵙⵙⴰⵔⵙ ⵜⵉⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵉⴼⴻⵍⵡⵉⵏ, ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏⵜ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵜⵉⵏⵏⵉ ⵅⴰⵙⴻⵏⵜ ⵉⵥⵡⴰⵏ, ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EX40_19","003_40_19","EXO","40","19","19","ⵉⴱⴻⵣⵣⴻⵄ ⴰⵇⵉⴹⵓⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⵜⴰⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_20","003_40_20","EXO","40","20","20","ⵉⴽⵙⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⵜⴰⴱⵓⵜ ⵓⵛⴰ ⵉⵛⴻⴷⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵅ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_21","003_40_21","EXO","40","21","21","ⵉⵙⵙⵉⴷⴻⴼ ⵜⵜⴰⴱⵓⵜ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵓⵛⴰ ⵢⵓⵢⴻⵍ ⴰⵍⴻⵃⵃⴰⴼ ⴰⵎ ⴷⴷⵓⵔⵉ ⵓⵛⴰ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_22","003_40_22","EXO","40","22","22","ⵉⵙⵙⴰⵔⵙ ⵜⴰⵣⴻⵡⴹⴰ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵓⵍⴻⵃⵃⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("EX40_23","003_40_23","EXO","40","23","23","ⵉⵙⴻⵜⵜⴻⴼ ⵅⴰⵙ ⴰⵖⵔⵓⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_24","003_40_24","EXO","40","24","24","ⵉⵙⵙⴰⵔⵙ ⵍⵇⴻⵏⴷⵉⵍ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵓⵔⴻⵏⴷⴰⴷ ⵏ ⵜⵣⴻⵡⴹⴰ, ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_25","003_40_25","EXO","40","25","25","ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⵜⵉⴼⵜⵉⵍⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_26","003_40_26","EXO","40","26","26","ⵉⵡⵛⴰ ⴰⵎⵛⴰⵏ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵣⵣⴰⵜ ⵉ ⵓⵍⴻⵃⵃⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("EX40_27","003_40_27","EXO","40","27","27","ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅⴰⵙ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_28","003_40_28","EXO","40","28","28","ⵢⵓⵢⴻⵍ ⴰⵔⵡⴰⵇ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_29","003_40_29","EXO","40","29","29","ⵉⵡⵛⴰ ⴰⵎⵛⴰⵏ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅⴰⵙ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_30","003_40_30","EXO","40","30","30","ⵉⵙⵙⴰⵔⵙ ⵜⴰⴱⴰⵏⵢⵓⵜ ⵊⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵓⵄⴰⵍⵟⴰⵔ. ⵉⴳⴳⴰ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵏ ⵉ ⵓⵙⵉⵔⴷ. ");
INSERT INTO rift_vpl VALUES ("EX40_31","003_40_31","EXO","40","31","31","ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵙⵙⵉⵔⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EX40_32","003_40_32","EXO","40","32","32","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵍⴰⵎⵉ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⵙⵙⵉⵔⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EX40_33","003_40_33","EXO","40","33","33","ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⴰⵙ-ⴷⴷ ⵍⴻⵎⵔⴰⵃ ⵓⵛⴰ ⵢⵓⵢⴻⵍ ⵏⴻⵜⵜⴰ ⴰⵔⵡⴰⵇ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ. ⴰⵎⵎⵓ ⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⵓⵙⴰ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_34","003_40_34","EXO","40","34","34","ⵅⴻⵏⵏⵉ ⵉⴷⵍⴰ ⵓⵙⴻⵢⵏⵓ ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⵛⵛⵓⵔ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_35","003_40_35","EXO","40","35","35","ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵎⵓⵙⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⵉⵏⵣⵉ ⴰⵙⴻⵢⵏⵓ ⵢⴰⵔⵙⴰ ⵅⴰⵙ ⵓ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⵛⵛⵓⵔ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("EX40_36","003_40_36","EXO","40","36","36","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵎⵓⵟⵟⵢⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EX40_37","003_40_37","EXO","40","37","37","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ, ⵡⴰⵔ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EX40_38","003_40_38","EXO","40","38","38","ⵎⵉⵏⵣⵉ ⴰⵙⴻⵢⵏⵓ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵙⴰ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵙ ⵓⵣⵉⵍ ⵓⵛⴰ ⴷⵉ ⴵⵉⵍⴻⵜ ⵜⵓⵖⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵉⵎⵓⵟⵟⵓⵢⴻⵏ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV1_1","004_1_1","LEV","1","1","1","ⵉⵍⴰⵖⴰ ⵉ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ ⵣⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV1_2","004_1_2","LEV","1","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵎⴰⵍⴰ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵣⴰⵢⵡⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵡⴻⵎ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ, ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵉⵖ ⵣⴻⴳ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("LV1_3","004_1_3","LEV","1","3","3","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉⵊⵊ ⵏ ⵓⵡⵜⴻⵎ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ⴰⴷ ⵜ ⵢⵉⵡⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴼ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV1_4","004_1_4","LEV","1","4","4","ⴰⴷ ⵢⴻⴳⴳ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵇⴱⴻⵍ ⵜⵖⴰⵔⵚⵜ ⵙ ⴰⵔⴹⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵡⴻⵚⵍⴰⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV1_5","004_1_5","LEV","1","5","5","ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⴷ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⴷ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV1_6","004_1_6","LEV","1","6","6","ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵉⴱⴹⴰ ⴰⴼⵓⵏⴰⵙ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV1_7","004_1_7","LEV","1","7","7","ⴰⵔⵔⴰⵡ ⵏ ⴰⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⵙⴻⵜⵜⴼⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ ⵅ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV1_8","004_1_8","LEV","1","8","8","ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⴷ ⵙⴻⵜⵜⴼⴻⵏ ⵉⵛⴻⴵⵉⵇⴻⵏ ⴷ ⵓⵣⴻⴵⵉⴼ ⴷ ⵜⴰⴷⵓⵏⵜ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴻⵙⵙⵉ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV1_9","004_1_9","LEV","1","9","9","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⴷⴰⵏ ⵏⵏⴻⵙ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV1_10","004_1_10","LEV","1","10","10","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵣⴻⴳ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⴰⵡⵜⴻⵎ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV1_11","004_1_11","LEV","1","11","11","ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⴷ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV1_12","004_1_12","LEV","1","12","12","ⴰⴷ ⵜ ⵉⴱⴹⴰ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ, ⴰⴽ-ⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⴻⵜⵜⴻⴼ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴻⵙⵙⵉ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV1_13","004_1_13","LEV","1","13","13","ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⴷⴰⵏ ⵏⵏⴻⵙ ⴷ ⵉⵛⴻⴽⵔⴰⴷⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵢⴰⵡⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵓ ⴰⴷ ⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV1_14","004_1_14","LEV","1","14","14","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵣⵉ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV1_15","004_1_15","LEV","1","15","15","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⴷ ⴰⵙ ⵉⴽⴽⴻⵙ ⴰⵣⴻⴵⵉⴼ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⴷ ⵉⵥⴻⵎⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ");
INSERT INTO rift_vpl VALUES ("LV1_16","004_1_16","LEV","1","16","16","ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⴽⴽⴻⵙ ⴰⵙⴻⵢⵔⵓ ⴰⴽ-ⴷ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⴰⴷ ⵉⵏⴹⴰⵔ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵖⵖⴻⴹ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ");
INSERT INTO rift_vpl VALUES ("LV1_17","004_1_17","LEV","1","17","17","ⴰⴷ ⵜ ⵉⵛⴰⵔⵔⴻⴳ ⵖⴰⵔ ⵡⴻⴼⵔⵉⵡⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⴱⴻⵟⵟⵉ ⵛⴰ ⵇⴰⵄ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴻⵙⵙⵉ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("LV2_1","004_2_1","LEV","2","1","1","“ⵎⴰⵍⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵃⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⴻⵢⵢⴻⴱ ⵣⵣⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⵊⵊⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_2","004_2_2","LEV","2","2","2","ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵉⵛⵛⵓⵔ ⵣⴻⴳ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵏⵏⵉ ⵓ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⴰⵡⵉ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⵉ, ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_3","004_2_3","LEV","2","3","3","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ⴰⵇⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_4","004_2_4","LEV","2","4","4","ⵎⴰⵍⴰ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⴰⵔⵃⴻⵏ ⵜⵜ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ, ⵓⵍⴰ ⴷ ⵜⵉⵍⴼⴰⴼ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵜⵜⵡⴰⴷⴻⵀⵏⴻⵏⵜ ⵙ ⵣⵣⴻⵛⵜ, ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LV2_5","004_2_5","LEV","2","5","5","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵛ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴳⴳⵯⵉⵏ ⵜⵜ ⵅ ⵡⴻⵅⴷⵉⵎ, ⴰⴷ ⵜⵉⵍⵉ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ, ⵡⴰⵔⴷⴰⵢⴻⵙ ⴱⵓ ⵡⴻⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LV2_6","004_2_6","LEV","2","6","6","ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵥⴻⴷ ⴷ ⵉⴼⴻⵜⵡⵉⵜⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵜⵙⴻⵢⵢⴱⴻⴷ ⵣⵣⴻⵛⵜ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV2_7","004_2_7","LEV","2","7","7","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵛ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴳⴳⵯⵉⵏ ⵜⵜ ⴷⵉ ⵟⵟⴰⵊⵊⵉⵏ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵊⴻⴷ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⴽ-ⴷ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV2_8","004_2_8","LEV","2","8","8","ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵡⴻⵊⴷⴻⵏ, ⴰⴷ ⵜⵜ ⵜⴰⵡⵢⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ. ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV2_9","004_2_9","LEV","2","9","9","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵛⵜ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴷ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_10","004_2_10","LEV","2","10","10","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_11","004_2_11","LEV","2","11","11","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵖⴰ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵊⴻⴷ ⵙ ⵡⴻⵏⵜⵓⵏ. ⵎⴰⵖⴰⵔ ⵣⵉ ⵎⵉⵏ ⵎⴰ ⵏ ⵡⴻⵏⵜⵓⵏ ⴷ ⵣⵉ ⵎⵉⵏ ⵎⴰ ⵜⴰⵎⵎⴻⵏⵜ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴰⵎ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_12","004_2_12","LEV","2","12","12","ⴰⴷ ⵜⵉⵡⵢⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⵓⴼⴼⴻⵖ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵚⵚⴰⴱⴻⵜ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ-ⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⴰⵎ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV2_13","004_2_13","LEV","2","13","13","ⴽⵓⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⴻⴵⵃⴻⴷ ⵙ ⵜⵎⴻⴵⴰⵃⵟ. ⵜⴰⵎⴻⴵⴰⵃⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏⵇⴻⵚ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ. ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵖⴰⵔ ⴽⵓⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV2_14","004_2_14","LEV","2","14","14","ⵎⴰⵍⴰ ⵜⵉⵡⵢⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ, ⴰⴷ ⵜⵉⵡⵢⴻⴷ ⵜⵉⴷⵔⵉⵏ ⵢⵉⵡⴹⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⴻⵏ ⵅ ⵜⵎⴻⵙⵙⵉ, ⴰⴽ-ⴷ ⵍⵃⴻⴱⴱ ⴰⵣⵉⵣⴰ ⵉⴱⴰⵔⵢⴻⵏ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⵉ ⵜⵎⴻⵏⵣⵓⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV2_15","004_2_15","LEV","2","15","15","ⴰⴷ ⵅⴰⵙ ⵜⵙⴻⵢⵢⴱⴻⴷ ⵣⵣⴻⵛⵜ ⵓ ⴰⴷ ⵅⴰⵙ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵊⵊⴰⵡⵉ, ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV2_16","004_2_16","LEV","2","16","16","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵣⵉ ⵍⵃⴻⴱⴱ ⵉⴱⴰⵔⵢⴻⵏ ⵓ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⴰⵡⵉ ⵏⵏⴻⵙ ⵉ ⵅⴰⵙ ⵉⴵⴰⵏ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ. ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV3_1","004_3_1","LEV","3","1","1","“ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ, ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⴰⵎⵓⴷⴷⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵡⵜⴻⵎ ⵏⵉⵖ ⴷ ⵜⴰⵡⵜⴻⵎⵜ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV3_2","004_3_2","LEV","3","2","2","ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⴷ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV3_3","004_3_3","LEV","3","3","3","ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV3_4","004_3_4","LEV","3","4","4","ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⵓ ⵢⴰⵔⵙⴰ ⵅ ⵜⵉⵥⵥⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LV3_5","004_3_5","LEV","3","5","5","ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵅ ⵜⵎⴻⵙⵙⵉ. ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV3_6","004_3_6","LEV","3","6","6","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵡⵜⴻⵎ ⵏⵉⵖ ⴷ ⵜⴰⵡⵜⴻⵎⵜ ⵏ ⵡⵓⴵⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴰⵔ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV3_7","004_3_7","LEV","3","7","7","ⵎⴰⵍⴰ ⴷ ⵓⵃⵓⵍⵉ ⵉ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⴷ ⵜⴰⵖⴰⵔⵚⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ-ⵉ-ⴷⴷ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV3_8","004_3_8","LEV","3","8","8","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV3_9","004_3_9","LEV","3","9","9","ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ: ⵎⴰⵔⵔⴰ ⵜⴰⵏⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⵓⵏⵜ ⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⴰⴱⴻⵄⵚⵓⵚ ⴰⴷ ⵜⵜ ⵉⴽⴽⴻⵙ, ⵓⵍⴰ ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⵏ ");
INSERT INTO rift_vpl VALUES ("LV3_10","004_3_10","LEV","3","10","10","ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⵓ ⵢⴰⵔⵙⴰ ⵅ ⵜⵉⵥⵥⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LV3_11","004_3_11","LEV","3","11","11","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵇⴰ ⴷ ⵎⴰⵛⵛⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV3_12","004_3_12","LEV","3","12","12","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷ ⵉⵖⴰⵢⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV3_13","004_3_13","LEV","3","13","13","ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵣⴻⴵⵄⴻⵏ ⵛⵡⴰⵢⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV3_14","004_3_14","LEV","3","14","14","ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⵏ, ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ ");
INSERT INTO rift_vpl VALUES ("LV3_15","004_3_15","LEV","3","15","15","ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⵓ ⵢⴰⵔⵙⴰ ⵅ ⵜⵉⵥⵥⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LV3_16","004_3_16","LEV","3","16","16","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⴷ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV3_17","004_3_17","LEV","3","17","17","ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵣⴻⴷⵖⴻⵎ: ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜᵉⵜⵜⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LV4_1","004_4_1","LEV","4","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV4_2","004_4_2","LEV","4","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵅⴹⴰ ⴰⵎ ⵉⵡⴻⴷⴷⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵅⴹⴰ ⴷⴻⴳ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴰⵎⵎⵓ: ");
INSERT INTO rift_vpl VALUES ("LV4_3","004_4_3","LEV","4","3","3","ⵎⴰⵍⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⴷⵀⵓⵏ ⵉⵅⴹⴰ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵍⴳⴻⵏⵙ ⵉⵅⴹⴰ, ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ. - ⴰⵎⴻⵥⵢⴰⵏ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("LV4_4","004_4_4","LEV","4","4","4","ⴰⴷ ⵢⴰⵡⵉ ⴰⴼⵓⵏⴰⵙ ⵏⵏⵉ ⴰⵎⴻⵥⵢⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵉ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV4_5","004_4_5","LEV","4","5","5","ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⴷⵀⵓⵏ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_6","004_4_6","LEV","4","6","6","ⴰⴷ ⵉⵙⵙⵓⴼ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴹⴰⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵔⵓⵛⵛ ⵛⴰ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV4_7","004_4_7","LEV","4","7","7","ⴰⴷ ⵉⴳⴳ ⵓⴽⴻⵀⵀⴰⵏ ⵛⵡⴰⵢⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("LV4_8","004_4_8","LEV","4","8","8","ⴰⴷ ⵉⴽⴽⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ: ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⵏ    ");
INSERT INTO rift_vpl VALUES ("LV4_9","004_4_9","LEV","4","9","9","ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⵓ ⵢⴰⵔⵙⴰ ⵅ ⵜⵉⵥⵥⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("LV4_10","004_4_10","LEV","4","10","10","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴽⴽⴻⵙ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⵓⴼⵓⵏⴰⵙ ⵏ ⵜⵖⴰⵔⵚⵉ ⵏ ⵍⴻⵀⵏⴰ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV4_11","004_4_11","LEV","4","11","11","ⵉⵍⴻⵎ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵓⵣⴻⴵⵉⴼ ⴷ ⵉⵛⴻⴽⵔⴰⴷ ⵏⵏⴻⵙ ⴷ ⵡⴰⴷⴰⵏ ⵏⵏⴻⵙ ⴷ ⵓⵎⴻⵙⵙⴰⵍ ⵏⵏⴻⵙ ⵉ ⴷⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV4_12","004_4_12","LEV","4","12","12","ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⴷ ⵜ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵚⴼⴰ ⵎⴰⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵖⵖⴻⴹ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⵅ ⵓⴽⴻⵛⵛⵓⴹ. ⴰⴷ ⵜ ⵛⴻⵎⴹⴻⵏ ⵎⴰⵏⵉ ⵣⴻⴵⵄⴻⵏ ⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("LV4_13","004_4_13","LEV","4","13","13","ⵎⴰⵍⴰ ⵜⴻⴼⴼⴻⵖ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵜⴻⴼⴼⴰⵔ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵢⴻⴳⴳ, ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷⴰⵢⵙⴻⵏ ⵓⵎⴰⵔⵡⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("LV4_14","004_4_14","LEV","4","14","14","ⵓⵛⴰ ⵉⴱⴰⵏ-ⴷⴷ ⴷⴷⴻⵏⴱ ⵉ ⵣⵉ ⵉⴼⴼⵖⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⵓⵎⵓⵔⴰⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⴷⴷⴻⵏⴱ, ⵓⵛⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_15","004_4_15","LEV","4","15","15","ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵉ ⵓⴼⵓⵏⴰⵙ ⵏⵏⵉ ⴰⵎⴻⵥⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV4_16","004_4_16","LEV","4","16","16","ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⴷⵀⵓⵏ ⴰⴷ ⵢⴰⵡⵉ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("LV4_17","004_4_17","LEV","4","17","17","ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓⴼ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴹⴰⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵔⵓⵛⵛ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵓⵍⴻⵃⵃⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("LV4_18","004_4_18","LEV","4","18","18","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴷ ⵉ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_19","004_4_19","LEV","4","19","19","ⴰⴷ ⵅⴰⵙ ⵉⴽⴽⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_20","004_4_20","LEV","4","20","20","ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵙ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵙ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_21","004_4_21","LEV","4","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵛⵎⴻⴹ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴻⵛⵎⴻⴹ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("LV4_22","004_4_22","LEV","4","22","22","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵉⵅⴹⴰ, ⵓⵛⴰ ⵙ ⵓⵡⴻⴷⴷⴰⵔ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵉ ⵡⴰⵔ ⵉⵜⵜⵛⵓⵡⵡⴰⵔⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ, ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷⴰⵢⴻⵙ ⵓⵎⴰⵔⵡⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("LV4_23","004_4_23","LEV","4","23","23","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⴰⵙ ⵓⵅⴻⵟⵟⵓ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ ⴹⵉⴷⴷ ⵉ ⵍⵓⵎⵓⵔ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⴻⵎ, ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ, ⵉⵊⵊ ⵏ ⵡⴻⵡⵜⴻⵎ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV4_24","004_4_24","LEV","4","24","24","ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵎⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("LV4_25","004_4_25","LEV","4","25","25","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⴳⴳ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV4_26","004_4_26","LEV","4","26","26","ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵉ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_27","004_4_27","LEV","4","27","27","ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵅⴹⴰ ⵙ ⵓⵡⴻⴷⴷⴰⵔ ⴰⵎ ⵉⴳⴳⴰ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵅ ⵉⵛⵜⴻⵏ ⵏ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ, ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷⴰⵢⴻⵙ ⵓⵎⴰⵔⵡⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("LV4_28","004_4_28","LEV","4","28","28","ⵏⵉⵖ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⴰⵙ ⵓⵅⴻⵟⵟⵓ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵢⴹⴻⵜ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵜⴻⵎⵜ ⵉⵛⵏⴰⵏ ⵇⴰⵄ, ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵅ ⴷⴷⴻⵏⴱ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("LV4_29","004_4_29","LEV","4","29","29","ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV4_30","004_4_30","LEV","4","30","30","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⴳⴳ ⵖⴰⵔ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_31","004_4_31","LEV","4","31","31","ⴰⴷ ⵅⴰⵙ ⵉⴽⴽⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⴽⵙⴻⵏ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_32","004_4_32","LEV","4","32","32","ⵎⴰⵍⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴰⵡⵜⴻⵎⵜ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV4_33","004_4_33","LEV","4","33","33","ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵖⴰⵔⵚ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV4_34","004_4_34","LEV","4","34","34","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⴳⴳ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵟⵟⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV4_35","004_4_35","LEV","4","35","35","ⴰⴷ ⵅⴰⵙ ⵉⴽⴽⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴽⴽⴻⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵓⵃⵓⵍⵉ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⵜ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵅ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⴷⴷⴻⵏⴱ ⵉ ⵉⴳⴳⴰ, ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("LV5_1","004_5_1","LEV","5","1","1","“ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵃⴻⴷ ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵀⴻⵊⵊⵉ ⵏ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵅⴰⵙ, ⵏⵉⵖ ⵉⵥⵔⴰ ⵉ-ⵜ ⵏⵉⵖ ⵉⵙⵙⴻⵏ ⵉ-ⵜ: ⵎⴰⵍⴰ ⵡⴰⵔ ⵅⴰⵙ ⵉⵇⵇⴰⵔ ⵡⴰⵍⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_2","004_5_2","LEV","5","2","2","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵃⴰⴷⴰ ⵃⴻⴷ ⵎⵉⵏ ⵎⴰ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⵅⴻⵎⵊⴻⵏ, ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵍⵎⴰⵍ ⵉⵅⵎⴻⵊ, ⵏⵉⵖ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉⵅⴻⵎⵊⴻⵏ, ⵏⵉⵖ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉⵅⵎⴻⵊ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵉⵅⵎⴻⵊ ⵓ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_3","004_5_3","LEV","5","3","3","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵃⴰⴷⴰ ⵛⴰ ⵏ ⵍⴻⵅⵎⴻⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏ ⵎⴰ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵉⵅⵎⴻⵊ, ⵎⴰⵍⴰ ⵜⴻⵏⵏⵓⴼⴼⴰⵔ ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵏ ⵉⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_4","004_5_4","LEV","5","4","4","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵥⵥⵓⴵ ⵃⴻⴷ ⵙ ⵜⵛⴰⵔⴼⴰⵢⴻⵃ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⵖⴰⵔ ⵏⵉⵖ ⴰⴷ ⵉⴳⴳ ⵍⵅⴰⵔ, ⵏⵉⵖ ⵎⵉⵏ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵏⵟⴻⵇ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⴰⵎ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏ, ⵎⴰⵛⴰ ⵉⵙⵙⴻⵏ ⵉ-ⵜ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵛⵜ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LV5_5","004_5_5","LEV","5","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴰⴷ ⵉⵏⵄⴻⵎ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LV5_6","004_5_6","LEV","5","6","6","ⵅ ⴷⴷⴻⵏⴱ ⵉ ⵉⴳⴳⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵜⴻⵎⵜ ⵏ ⵡⵓⴵⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⵉⵛⵜ ⵏ ⵜⴻⵅⵙⵉ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵖⴰⵢⴹⴻⵜ, ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_7","004_5_7","LEV","5","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵎⵉⵏ ⵉⵇⴻⴷⴷⴻⵏ ⵉ ⵢⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵡⵉ ⵉ ⵙⵉⴷⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵅ ⴷⴷⴻⵏⴱ ⵉ ⵉⴳⴳⴰ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉⵊⵊⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⵉⵊⵊⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV5_8","004_5_8","LEV","5","8","8","ⴰⴷ ⵜⴻⵏ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⴰⵊⵍⵉⵍⵍⵉⵃⵜ ⵏⵉⵖ ⴰⴹⴱⵉⵔ ⵉ ⵉⴵⴰⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵣⵉ ⵛⵡⴰⵢⵜ ⴰⵡⴰⵔⵏⵉ ⵢⵉⵔⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⴱⴻⵟⵟⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LV5_9","004_5_9","LEV","5","9","9","ⴰⴷ ⵉⵔⵓⵛⵛ ⵛⵡⴰⵢⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⴷ ⵜ ⵉⵥⴻⵎⵎ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("LV5_10","004_5_10","LEV","5","10","10","ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵎⴻⴷⴷⴰⵔ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵚⵍⴰⵃ ⵅ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV5_11","004_5_11","LEV","5","11","11","ⵎⴰⵍⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵎⵉⵏ ⵉⵇⴻⴷⴷⴻⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉⵅⴹⴰⵏ, ⴰⴷ ⵢⴰⵡⵉ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵜⴰⵄⵛⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴷⴷⴻⵏⴱ. ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⴻⴳⴳ ⵣⵣⴻⵛⵜ ⵓⵍⴰ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⵔⵓⵙⵉ ⵊⵊⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("LV5_12","004_5_12","LEV","5","12","12","ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵉⵛⵛⵓⵔ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⴰⵎ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴰⵢⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵅ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("LV5_13","004_5_13","LEV","5","13","13","ⴰⵎⵎⵓ ⵉ ⵅⴰⵙ ⵖⴰ ⵢⴻⴳⴳ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵚⵍⴰⵃ ⵅ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵢⴻⴵⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("LV5_14","004_5_14","LEV","5","14","14","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV5_15","004_5_15","LEV","5","15","15","“ⵎⴰⵍⴰ ⵉⴳⴳⴰ ⵃⴻⴷ ⵙ ⵍⴻⵖⴷⴰⵔ ⵓⵛⴰ ⵉⵅⴹⴰ ⵙ ⵓⵡⴻⴷⴷⴰⵔ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⴰⵡⵉ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⴻⴳ ⵡⵓⴵⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵙⵉⴷⵉ. ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⴷⴻⴳ ⵉⵛⵉⵇⵍⵓⵜⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_16","004_5_16","LEV","5","16","16","ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵢⴰⵔⵔ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵉⵅⴹⴰ ⵇⴱⴻⵍ, ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵍⴻⵅⵎⵓⵙ. ⵓⵛⴰ ⴰⴷ ⵉⵡⵛ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵙ ⵉⵛⴰⵔⵔⵉ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV5_17","004_5_17","LEV","5","17","17","ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵃⴻⴷ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ, ⴰⵎ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵣⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⵏⵓⴼⴼⴰⵔ ⵅⴰⵙ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵓⵎⴰⵔⵡⴰⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_18","004_5_18","LEV","5","18","18","ⴰⴷ ⵢⴰⵡⵉ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⴻⴳ ⵡⵓⴵⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵓⴽⴻⵀⵀⴰⵏ ⵅ ⵓⵡⴻⴷⴷⴰⵔ ⵏⵏⴻⵙ ⵉ ⴷⵉ ⵉⵡⴻⴷⴷⴰⵔ ⴰⵎ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV5_19","004_5_19","LEV","5","19","19","ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV5_20","004_5_20","LEV","5","20","20","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV5_21","004_5_21","LEV","5","21","21","“ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵃⴻⴷ ⵓⵛⴰ ⵉⵖⴷⴰⵔ ⵙⵉⴷⵉ ⴰⵎ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵅ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵅ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵃⴹⴰ, ⵏⵉⵖ ⵅ ⵎⵉⵏ ⵉⵊⵊⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵅ ⵎⵉⵏ ⵅⴰⵙ ⵢⵓⵛⴰⵔⴻⵏ, ⵏⵉⵖ ⵅ ⵛⴰ ⵏ ⵓⴱⴻⵄⵄⴻⵊ ⵉ ⵉⴳⴳⴰ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV5_22","004_5_22","LEV","5","22","22","ⵏⵉⵖ ⴰⵎ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵅ ⵛⴰ ⵎⵉⵏ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵓ ⵉⵜⵜⵡⴰⴼ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵊⵊⵓⴵ ⵥⵓⵔ, ⵡⴰⵀ, ⴰⵎ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵏⴻⵜⵜⴰ ⵅ ⵉⵛⵜⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳ ⴱⵏⴰⴷⴻⵎ ⴰⵍⴰⵎⵉ ⵉⵅⴻⵟⵟⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("LV5_23","004_5_23","LEV","5","23","23","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ, ⵓⵎⵉ ⵉⵅⴹⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷⴰⵢⴻⵙ ⵓⵎⴰⵔⵡⴰⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵜⵓⵛⴻⴼⴼⴰⵔⵜ ⵏⵏⵉ ⵢⵓⵛⴰⵔ, ⵏⵉⵖ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵏⵏⵉ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵙ ⵓⵖⵉⵍ, ⵏⵉⵖ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵃⴹⴰ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⵃⴹⴰ, ⵏⵉⵖ ⵎⵉⵏ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵢⵓⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("LV5_24","004_5_24","LEV","5","24","24","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵊⵊⵓⴵ ⵥⵓⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⵎⵓⵏ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵏⵉ ⵍⴻⵅⵎⵓⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵡⵛ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV5_25","004_5_25","LEV","5","25","25","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵡⴻⵏⵏⵉ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⵓⵛⴰ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV5_26","004_5_26","LEV","5","26","26","ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵙⵍⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵅ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰⵍⴰ ⵉⴷⵡⴻⵍ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("LV6_1","004_6_1","LEV","6","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV6_2","004_6_2","LEV","6","2","2","“ⵓⵎⵓⵔ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴰⵔⴻⵇⵇ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ ⴰⵍ ⵚⵚⴱⴻⵃ ⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴰⴷ ⵜⴻⵛⵎⴻⴹ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV6_3","004_6_3","LEV","6","3","3","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵢⴰⵔⴹ ⴰⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ ⵏ ⵍⴻⵇⵟⴻⵏ, ⴰⴷ ⵉⴱⵢⴻⵙ ⵙⵙⴰⵔⵡⴰⵍ ⵏⵏⴻⵙ ⵏ ⵍⴻⵇⵟⴻⵏ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⴽⵙⵉ ⵉⵖⵖⴻⴹ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵜⴻⵏⵏⵉ ⵜⴻⵛⵛⴰ ⵜⵎⴻⵙⵙⵉ, ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴰⵔⵙ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV6_4","004_6_4","LEV","6","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⴽⴻⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵢⴰⵡⵉ ⵉⵖⵖⴻⴹ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("LV6_5","004_6_5","LEV","6","5","5","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⵎⴻⵙⵙⵉ ⵜⴰⵔⴻⵇⵇ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⵅⴻⵙⵙⵉ ⵛⴰ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵖ ⴰⴽⴻⵛⵛⵓⴹ ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⴻⵜⵜⴻⴼ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LV6_6","004_6_6","LEV","6","6","6","ⵜⵉⵎⴻⵙⵙⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴰⵔⴻⵇⵇ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵜⵅⴻⵙⵙⵉ.’” ");
INSERT INTO rift_vpl VALUES ("LV6_7","004_6_7","LEV","6","7","7","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵜⵜ ⴰⵡⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV6_8","004_6_8","LEV","6","8","8","ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵣⴻⴳ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⴰⵡⵉ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⵉⵛⵜ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴰⵢⴻⵙ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV6_9","004_6_9","LEV","6","9","9","ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵛⵛⴻⵏ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵛⴻⵟⵟⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵛⵛⴻⵏ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ. ⴰⴷ ⵜ ⵛⵛⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV6_10","004_6_10","LEV","6","10","10","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜ ⴳⴳⵯⴻⵏ ⵙ ⵡⴻⵏⵜⵓⵏ. ⵜⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵙⴻⵏ ⵏⵏⵉ ⵡⵛⵉⵖ ⵏⴻⵛⵛ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵏⵓ ⵏ ⵜⵎⴻⵙⵙⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV6_11","004_6_11","LEV","6","11","11","ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⵃⴰⴷⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV6_12","004_6_12","LEV","6","12","12","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV6_13","004_6_13","LEV","6","13","13","“ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⴷⴷ ⵖⴰ ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴷⵀⴻⵏ ⵀⴰⵔⵓⵏ: ⵜⴰⵄⵛⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵣⵢⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵚⵚⴱⴻⵃ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LV6_14","004_6_14","LEV","6","14","14","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵅⴷⵉⵎ ⴰⴷ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⴰⵢⴰ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴰⵡⵢⴻⴷ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⴰⵡⴰⵔⵏⵉ ⵜ ⵜⵅⴻⴵⴹⴻⴷ. ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵜⵜⵡⴰⵔⵥⴰⵏ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⵎ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV6_15","004_6_15","LEV","6","15","15","ⴰⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵖⴰ ⴷⴻⵀⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ⵜⴰⵡⵀⵉⴱⵜ-ⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LV6_16","004_6_16","LEV","6","16","16","ⵎⴰⵔⵔⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴽⵎⴻⵍ. ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("LV6_17","004_6_17","LEV","6","17","17","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV6_18","004_6_18","LEV","6","18","18","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ: ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵄⴰⵡⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV6_19","004_6_19","LEV","6","19","19","ⴰⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵜⵜ ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV6_20","004_6_20","LEV","6","20","20","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ. ⵎⴰⵍⴰ ⵉⵏⴳⴻⵣ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵢⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵎⵉⵏ ⵅⴰⵙ ⵉⴱⴻⵇⵇⴹⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV6_21","004_6_21","LEV","6","21","21","ⵓⵛⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ ⵉ ⴷⵉ ⵜⵜ ⵙⵙⵏⴻⵏⵏⴰⵏ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⵥ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵙⵙⴻⵏⵡⴻⵏ ⵜⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵏⵏⵃⴰⵙ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵃⴻⴽⴽⴻⵏ ⵓ ⴰⴷ ⵙⵙⵍⵉⵍⴻⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV6_22","004_6_22","LEV","6","22","22","ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ ⵊⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV6_23","004_6_23","LEV","6","23","23","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵣⵉ ⵜⵜⵡⴰⵇⴻⴷⴷⵎⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵡⴻⵚⵍⴰⵃ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵛⵛ ⵛⴰ. ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ.’” ");
INSERT INTO rift_vpl VALUES ("LV7_1","004_7_1","LEV","7","1","1","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⵡⴰⵔⵡⴰⵙ. ⴰⵇⴰ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV7_2","004_7_2","LEV","7","2","2","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰⵔⵔⵚⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ⴰⴷ ⵉⵣⴻⴵⴻⵄ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_3","004_7_3","LEV","7","3","3","ⴰⴷ ⵢⴰⵡⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ: ⴰⵏⴻⵡⵡⴰⵔ ⵏ ⵜⴰⴷⵓⵏⵜ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏⵏⵉ ⵉⴷⵍⵉⵏ ⴰⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("LV7_4","004_7_4","LEV","7","4","4","ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ, ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⵓⵛⴰ ⵢⴰⵔⵙⴰ ⵅ ⵜⵉⵥⵥⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("LV7_5","004_7_5","LEV","7","5","5","ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_6","004_7_6","LEV","7","6","6","ⵎⴰⵔⵔⴰ ⴰⵡⵜⴻⵎ ⵊⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ. ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV7_7","004_7_7","LEV","7","7","7","ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ ⴰⵎ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴰⵎ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⵡⴰⵔⵡⴰⵙ. ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵢⵙⵓⵎ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV7_8","004_7_8","LEV","7","8","8","ⴰⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ, ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ ⴷⴷ-ⵉⵇⴻⴷⴷⴻⵎ, ⵜⵉⵍⵎⴻⵛⵜ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LV7_9","004_7_9","LEV","7","9","9","ⴽⵓⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⵉ ⴹⴰⵔⵔⵃⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⴷⵉ ⵟⵟⴰⵊⵊⵉⵏ ⵏⵉⵖ ⴷⴻⴳ ⵡⴻⵅⴷⵉⵎ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵜ ⵉⵇⴻⴷⴷⵎⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LV7_10","004_7_10","LEV","7","10","10","ⴽⵓⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵉⵜⵜⵡⴰⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⵏⵉⵖ ⵢⵓⵥⵖⴻⵏ, ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⴰⵎ ⵉ ⵢⵉⵊⵊ ⴰⵎ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV7_11","004_7_11","LEV","7","11","11","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⴻⵎ ⴱⵏⴰⴷⴻⵎ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV7_12","004_7_12","LEV","7","12","12","ⵎⴰⵍⴰ ⴰⴷ ⵜⵜ ⵉⵇⴻⴷⴷⴻⵎ ⵉ ⵓⵇⴰⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ ⵓⵍⴰ ⴷ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴷ ⵜⴻⵍⴼⴰⴼ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵜⵜⵡⴰⴷⴻⵀⵏⴻⵏⵜ ⵙ ⵣⵣⴻⵛⵜ ⴷ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵜⵜⵡⴰⵅⴻⴵⴹⴻⵏⵜ ⵙ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV7_13","004_7_13","LEV","7","13","13","ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵙ ⵡⴻⵏⵜⵓⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LV7_14","004_7_14","LEV","7","14","14","ⵣⵉ ⴽⵓⵍ ⴷⴷⴰⵔⴱ ⵏ ⵜⴰⵡⵀⵉⴱⵜ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ. ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LV7_15","004_7_15","LEV","7","15","15","ⴰⵢⵙⵓⵎ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵏ ⵍⴻⵀⵏⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵖⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵍⵓ ⴰⵍ ⵚⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("LV7_16","004_7_16","LEV","7","16","16","ⵎⴰⵍⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵜⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵏⵉⵖ ⵜⴻⴵⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵛⴻⵟⵟⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV7_17","004_7_17","LEV","7","17","17","ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵄⴰⴷ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵜⵖⴰⵔⵚⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LV7_18","004_7_18","LEV","7","18","18","ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵛⵛ ⵄⴰⴷ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵍⴻⵀⵏⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⵜᵉⵜⵜⵡⵉⵃⵙⵉⴱ ⵛⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_19","004_7_19","LEV","7","19","19","ⴰⵢⵙⵓⵎ ⵏⵏⵉ ⵉⵃⴰⴷⴰⵏ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⵅⴻⵎⵊⴻⵏ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵎ. ⴰⴷ ⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵣⵉ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV7_20","004_7_20","LEV","7","20","20","ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵎ ⵅⴰⵙ ⵢⴰⵔⵙⴰ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_21","004_7_21","LEV","7","21","21","ⵎⴰⵍⴰ ⵉⵃⴰⴷⴰ ⵃⴻⴷ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⵅⵎⴻⵊ, ⴰⵎⴻⵛⵏⴰⵡ ⵍⴻⵅⵎⴻⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⵍⴻⵅⵎⴻⵊ ⵏ ⵢⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉⵅⴻⵎⵊⴻⵏ ⵏⵉⵖ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵉⴵⴰⵏ ⴷ ⵏⵏⵄⵉ ⵏ ⵍⴻⵅⵎⴻⵊ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴻⵛⵛ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⵜⵖⴰⵔⵚⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV7_22","004_7_22","LEV","7","22","22","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV7_23","004_7_23","LEV","7","23","23","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ ⵇⴰⵄ ⵜⴰⴷⵓⵏⵜ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵏ ⵉⵣⵎⴰⵔ ⵏⵉⵖ ⵏ ⵉⵖⴰⵢⴹ. ");
INSERT INTO rift_vpl VALUES ("LV7_24","004_7_24","LEV","7","24","24","ⵜⴰⴷⵓⵏⵜ ⵏ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵎⴻⵣⵣⵇⴻⵏ ⵜ, ⵜⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵍⵅⴻⴷⵎⴻⵜ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵎ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("LV7_25","004_7_25","LEV","7","25","25","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵜⴰⴷⵓⵏⵜ ⵏ ⵢⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉ ⵣⵉ ⴷⴷ ⵖⴰ ⵙⵙⵇⴰⵔⵔⴱⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_26","004_7_26","LEV","7","26","26","ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵓⵍⴰ ⴷ ⵛⴰ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⵎ ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⴰⵎ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV7_27","004_7_27","LEV","7","27","27","ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵎⵖⵉⵔ ⵛⴰ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("LV7_28","004_7_28","LEV","7","28","28","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV7_29","004_7_29","LEV","7","29","29","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⵡⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵙⵙⵇⴰⵔⵔⴱⴻⵏ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⵙⵉⴷⵉ ⵣⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_30","004_7_30","LEV","7","30","30","ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵡⵉ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ⵜⴰⴷⵓⵏⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵉⴷⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⴰⴽ-ⴷ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV7_31","004_7_31","LEV","7","31","31","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⴷⵓⵏⵜ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⴰⵛⴰ ⵉⴷⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV7_32","004_7_32","LEV","7","32","32","ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵄⴰⵡⴻⴷ ⴰⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LV7_33","004_7_33","LEV","7","33","33","ⴰⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵉ ⵏ ⵍⴻⵀⵏⴰ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LV7_34","004_7_34","LEV","7","34","34","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⴷ ⵓⵛⴻⴽⵔⵓⴷ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵣⵉ ⵜⵖⴰⵔⵚⵉ ⵏ ⵍⴻⵀⵏⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵡⵛⵉⵖ ⵜⴻⵏ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⵍⴻⴱⴷⴰ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LV7_35","004_7_35","LEV","7","35","35","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵜⵜⵡⴰⵙⵙⴷⴻⵀⵏⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵉⵜⵜⵡⴰⵙⵙⴷⴻⵀⵏⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LV7_36","004_7_36","LEV","7","36","36","ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵜⴻⵏ ⵉⴷⵀⴻⵏ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("LV7_37","004_7_37","LEV","7","37","37","ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⴷ ⵜⵖⴰⵔⵚⴰ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("LV7_38","004_7_38","LEV","7","38","38","ⴰⵣⴻⵔⴼ ⵉ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉⵡⴻⵚⵚⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_1","004_8_1","LEV","8","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV8_2","004_8_2","LEV","8","2","2","“ⴽⵙⵉ ⵀⴰⵔⵓⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴷ ⵡⴰⵔⵔⵓⴹ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⴷ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵜⵙⵓⴵⴻⵜ ⵙ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("LV8_3","004_8_3","LEV","8","3","3","ⵓ ⵍⴰⵖⴰ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LV8_4","004_8_4","LEV","8","4","4","ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⵎⵓⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV8_5","004_8_5","LEV","8","5","5","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ: “ⵡⴰ ⴷ ⵎⵉⵏ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("LV8_6","004_8_6","LEV","8","6","6","ⵎⵓⵙⴰ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵔⴷ ⵉ-ⵜⴻⵏ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV8_7","004_8_7","LEV","8","7","7","ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⵜⵛⴰⵎⵉⵔ, ⵉⴱⵢⴻⵙ ⴰⵙ ⵙ ⵜⵃⴻⵣⵣⴰⵎⵜ, ⵉⵙⵙⵢⴰⵔⴹ ⴰⵙ ⴰⵙⴻⵍⵀⴰⵎ. ⵉⴳⴳⴰ ⵅⴰⵙ ⴰⴱⴰⵍⵟⵓ ⵓⵛⴰ ⵉⴱⵢⴻⵙ ⴰⵙ ⵙ ⵜⵃⴻⵣⵣⴰⵎⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵓⴱⴰⵍⵟⵓ ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⴰⵙ ⵣⵣⴰⵢⴻⵙ ⴰⴱⴰⵍⵜⵓ. ");
INSERT INTO rift_vpl VALUES ("LV8_8","004_8_8","LEV","8","8","8","ⵉⵙⵙⴻⵎⵜⴻⵏ ⵅⴰⵙ ⵜⴰⵊⵎⴻⵛⵜ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵥⵔⴰ ⵏ ‘ⵓⵔⵉⵎ’ ⴷ ‘ⵜⵓⵎⵉⵎ’ ⴷⵉ ⵜⴰⵊⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV8_9","004_8_9","LEV","8","9","9","ⵉⴳⴳⴰ ⴰⵔⴻⵥⵥⴻⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵖⴰⵔ ⵣⵣⴰⵜ ⵅ ⴰⵔⴻⵥⵥⴻⵜ ⵉⴳⴳⴰ ⵜⴰⵍⵡⵉⵃⵜ ⵙ ⵏⵏⵓⵡⵡⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵜⵜⴰⵊ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵡⴻⵄⵣⴰⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_10","004_8_10","LEV","8","10","10","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵓⵛⴰ ⵉⴷⵀⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵓⵛⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_11","004_8_11","LEV","8","11","11","ⵉⵔⵓⵛⵛ ⵣⵣⴰⵢⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓⵛⴰ ⵉⴷⵀⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⴰⴱⴰⵏⵢⵓⵜ ⴰⴽ-ⴷ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV8_12","004_8_12","LEV","8","12","12","ⵉⵙⴻⵢⵢⴻⴱ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵉⴷⵀⴻⵏ ⵉ-ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV8_13","004_8_13","LEV","8","13","13","ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵎⵓⵙⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵢⴰⵔⴹ ⴰⵙⴻⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵓⵛⴰ ⵉⴱⵢⴻⵙ ⴰⵙⴻⵏ ⵙ ⵜⵃⴻⵣⵣⴰⵎⵉⵏ ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⴰⵙⴻⵏ ⵜⵉⵛⵓⵛⵛⴰⵢ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_14","004_8_14","LEV","8","14","14","ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("LV8_15","004_8_15","LEV","8","15","15","ⵉⵖⴰⵔⵚ ⴰⵙ ⵓⵛⴰ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵣⴷⴻⴳ ⴰⵄⴰⵍⵟⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵙⴻⵢⵢⴻⴱ ⵉⴷⴰⵎⵎⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜ ⵉ ⵡⴻⵚⵍⴰⵃ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV8_16","004_8_16","LEV","8","16","16","ⵉⴽⵙⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⵏ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV8_17","004_8_17","LEV","8","17","17","ⵎⴰⵛⴰ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵢⵉⵍⴻⵎ ⵏⵏⴻⵙ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴷ ⴰⵎⴻⵙⵙⴰⵍ ⵏⵏⴻⵙ, ⵉⵙⵙⴰⵔⵖ ⵉ-ⵜⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_18","004_8_18","LEV","8","18","18","ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵎⵓⵙⴰ ⵉⵛⴰⵔⵔⵉ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_19","004_8_19","LEV","8","19","19","ⵉⵖⴰⵔⵚ ⵉ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵉⵣⴻⴵⴻⵄ ⵎⵓⵙⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV8_20","004_8_20","LEV","8","20","20","ⵉⴱⴹⴰ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵎⵓⵙⴰ ⴰⵣⴻⴵⵉⴼ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ ⴷ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LV8_21","004_8_21","LEV","8","21","21","ⵉⵙⵙⵉⵔⴷ ⴰⴷⴰⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⵉⵛⴰⵔⵔⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵙ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_22","004_8_22","LEV","8","22","22","ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵉ ⵏⵏⴻⵖⵏⵉ, ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⴷⴻⵛⵛⴻⵏ, ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_23","004_8_23","LEV","8","23","23","ⵓⵛⴰ ⵉⵖⴰⵔⵚ ⴰⵙ ⵓⵛⴰ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵀⴰⵔⵓⵏ ⵓ ⵅ ⵓⴹⴰⴹ ⵏ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵓⴹⴰⴹ ⵏ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_24","004_8_24","LEV","8","24","24","ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵓⴹⴰⴹ ⵏ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵓⴹⴰⴹ ⵏ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵓⵛⴰ ⵉⵣⴻⴵⴻⵄ ⵎⵓⵙⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV8_25","004_8_25","LEV","8","25","25","ⵉⴽⵙⵉ ⵜⴰⴷⵓⵏⵜ ⴷ ⵓⵏⴻⵡⵡⴰⵔ ⵙ ⵜⴰⴷⵓⵏⵜ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⵓⵏⵜ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⵏ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵥⵥⴰⵍ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵏⵙⴻⵏⵜ ⵓⵍⴰ ⴷ ⴰⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_26","004_8_26","LEV","8","26","26","ⵣⵉ ⵜⵙⵓⴵⴻⵜ ⵙ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵍⴻⵎⵙⴻⵎⵎⴻⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵙⴻⵎⵎⴻⵎⵜ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵍⴼⴻⴼⵜ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⵅ ⵜⴰⴷⵓⵏⵜ ⵓ ⵅ ⵓⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_27","004_8_27","LEV","8","27","27","ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⵓ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⴰⵢⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_28","004_8_28","LEV","8","28","28","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴽⵙⵉ ⵜⴻⵏ ⵎⵓⵙⴰ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵉ-ⵜⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ⴰⵇⴰ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵙ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_29","004_8_29","LEV","8","29","29","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵉⴷⵎⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵉ-ⵜⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵓⵛⴰⵔⵔⵉ ⵉ ⵓⴷⴻⵛⵛⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵎⵓⵙⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV8_30","004_8_30","LEV","8","30","30","ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵛⵡⴰⵢⵜ ⵏ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵓ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵔⵓⵛⵛ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⵀⴰⵔⵓⵏ ⵓ ⵅ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵅ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓ ⵅ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV8_31","004_8_31","LEV","8","31","31","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ: “ⵙⴻⵏⵡⴻⵎ ⴰⵢⵙⵓⵎ ⵏⵏⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⵜⴻⵛⵛⴻⵎ ⵜ ⴷⵉⵏⵏⵉ ⵙ ⵡⴻⵖⵔⵓⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵉ ⵓⴷⴻⵛⵛⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴻⵚⵚⵉⵖ ⵏⴻⵛⵛ, ⵏⵏⵉⵖ: ‘ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵛⵛⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LV8_32","004_8_32","LEV","8","32","32","ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵏ ⵡⴻⵢⵙⵓⵎ ⴷ ⵡⴻⵖⵔⵓⵎ, ⴰⴷ ⵜ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV8_33","004_8_33","LEV","8","33","33","ⵣⴻⴳ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵜᵉⵜⵜⴻⴼⴼⵖⴻⵎ ⵛⴰ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵍ ⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵍⴻⵇⵇⴻⵎ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV8_34","004_8_34","LEV","8","34","34","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⴳⴳ ⴰⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LV8_35","004_8_35","LEV","8","35","35","ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴰⵃⴻⵟⵟⵓ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵜ ⵜⵜⵡⴻⵚⵚⵉⵖ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("LV8_36","004_8_36","LEV","8","36","36","ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV9_1","004_9_1","LEV","9","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵎⵓⵙⴰ ⵉⵍⴰⵖⴰ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ");
INSERT INTO rift_vpl VALUES ("LV9_2","004_9_2","LEV","9","2","2","ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⴽⵙⵉ ⵖⴰⵔⴻⴽ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⵇⴰ ⴰⴷ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⵇⴰⵄ, ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.    ");
INSERT INTO rift_vpl VALUES ("LV9_3","004_9_3","LEV","9","3","3","ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ: “ⴽⵙⵉⵎ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⴷ ⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("LV9_4","004_9_4","LEV","9","4","4","ⵓⵛⴰ ⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵛⴰⵔⵔⵉ ⴰⵎ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵇⴻⴷⴷⵎⴻⵏ ⴷ ⴷⴷⴱⵉⵃⴻⵜ ⵉ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ-ⴰ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴱⴰⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV9_5","004_9_5","LEV","9","5","5","ⵅⴻⵏⵏⵉ ⴰⵡⵢⴻⵏ ⵎⵉⵏ ⵅⴻⴼ ⵉⵡⴻⵚⵚⴰ ⵎⵓⵙⴰ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV9_6","004_9_6","LEV","9","6","6","ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⵎ. ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴱⴰⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV9_7","004_9_7","LEV","9","7","7","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵛ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵛ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴻⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓ ⵅ ⵍⴳⴻⵏⵙ. ⵙⴻⵡⵊⴻⴷ ⵄⴰⵡⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴻⴳⴳ ⵅⴰⵙⴻⵏ ⴰⵚⵍⴰⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV9_8","004_9_8","LEV","9","8","8","ⵅⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵖⴰⵔⵚ ⵉ ⵓⵄⴻⵊⵎⵉ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵉⴵⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV9_9","004_9_9","LEV","9","9","9","ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼ ⴰⴹⴰⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵙⴻⵢⵢⴻⴱ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV9_10","004_9_10","LEV","9","10","10","ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⴷⵓⵏⵜ ⴷ ⵜⵉⵥⵥⴰⵍ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV9_11","004_9_11","LEV","9","11","11","ⵉⵙⵙⴻⵛⵎⴻⴹ ⴰⵢⵙⵓⵎ ⴷ ⵢⵉⵍⴻⵎ ⵙ ⵜⵎⴻⵙⵙⵉ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV9_12","004_9_12","LEV","9","12","12","ⵉⵖⴰⵔⵚ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵣⴻⴵⴻⵄ ⵉ-ⵜⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV9_13","004_9_13","LEV","9","13","13","ⵅⴻⵏⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵙ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵜⵜⵡⴰⴱⴹⴰⵏ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ, ⵓⵍⴰ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵉ-ⵜⵜ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV9_14","004_9_14","LEV","9","14","14","ⵉⵙⵙⵉⵔⴷ ⴰⴷⴰⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵉ-ⵜⴻⵏ ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV9_15","004_9_15","LEV","9","15","15","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⴳⴻⵏⵙ. ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⴰⵎⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵖⴰⵔⵚ ⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉ-ⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⴰⵔⵔⵉ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("LV9_16","004_9_16","LEV","9","16","16","ⵉⵙⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉ-ⵜⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LV9_17","004_9_17","LEV","9","17","17","ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⵉⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵉⵛⵛⵓⵔ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵣⵣⴰⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵚⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("LV9_18","004_9_18","LEV","9","18","18","ⵉⵖⴰⵔⵚ ⵄⴰⵡⴻⴷ ⵉ ⵓⴼⵓⵏⴰⵙ ⵓ ⵉ ⵢⵉⵛⴰⵔⵔⵉ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵉⵣⴻⴵⴻⵄ ⵉ-ⵜⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV9_19","004_9_19","LEV","9","19","19","ⵅ ⵜⴰⴷⵓⵏⵜ ⵏ ⵓⴼⵓⵏⴰⵙ ⵓ ⵏ ⵉⵛⴰⵔⵔⵉ: ⴰⵏⴻⵡⵡⴰⵔ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏⵏⴻⵙ ⴷ ⵎⵉⵏ ⵉⴷⵍⵉⵏ ⴰⴹⴰⵏ ⴷ ⵜⵉⵥⵥⴰⵍ ⴷ ⵎⵉⵏ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("LV9_20","004_9_20","LEV","9","20","20","ⴰⵇⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⴰⴷⵓⵏⵜ ⵏⵏⵉ ⵅ ⵉⴷⵎⴰⵔⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⴷⵓⵏⵜ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV9_21","004_9_21","LEV","9","21","21","ⵎⴰⵛⴰ ⵉⴷⵎⴰⵔⴻⵏ ⴷ ⵓⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵉ-ⵜⴻⵏ ⵀⴰⵔⵓⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵡⴻⵚⵚⴰ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV9_22","004_9_22","LEV","9","22","22","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵀⴰⵔⵓⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵀⵡⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LV9_23","004_9_23","LEV","9","23","23","ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴱⴰⵔⴽⴻⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⴱⴰⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ");
INSERT INTO rift_vpl VALUES ("LV9_24","004_9_24","LEV","9","24","24","ⵓⵛⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵛⵛⴰ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵍⴰ ⴷ ⵜⴰⴷⵓⵏⵜ. ⵓⵎⵉ ⵉⵥⵔⴰ ⵍⴳⴻⵏⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵙⵍⵉⵡⴻⵍⵡⴻⵏ ⵓⵛⴰ ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV10_1","004_10_1","LEV","10","1","1","ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ, ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⴽⵙⵉⵏ ⴽⵓⵍ ⵉⵊⵊ ⵍⵎⴻⵊⵎⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⴳⴳⵉⵏ ⴷⴰⵢⴻⵙ ⵍⴻⴱⵅⵓⵔ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵢⵉⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵖⵔⵉⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵡⴻⵚⵚⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LV10_2","004_10_2","LEV","10","2","2","ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵛⵛ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV10_3","004_10_3","LEV","10","3","3","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵓⵎⵉ ⵉⵏⵏⴰ: ‘ⵙ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰⵔⵉ ⴷⴷ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ ⵓⵛⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ.’” ⵓⵛⴰ ⵉⵙⵇⴰⵔ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LV10_4","004_10_4","LEV","10","4","4","ⵉⵍⴰⵖⴰ ⵎⵓⵙⴰ ⵉ ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⵉ ⵉⵍⵚⴰⴼⴰⵏ, ⴰⵔⵔⴰⵡ ⵏ ⵄⵓⵣⵣⵉⵢⵉⵍ, ⵄⴻⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ, ⵜⴰⵔⴱⵓⵎ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⵣⵉ ⵇⵉⴱⴰⵍⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵡⵢⵉ ⵜⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LV10_5","004_10_5","LEV","10","5","5","ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⴰⵔⴱⵓⵏ ⵜⴻⵏ ⴷⵉ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵏⵙⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵏⵏⴰ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV10_6","004_10_6","LEV","10","6","6","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ, ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ: “ⵡⴰⵔ ⴹⴻⴵⵇⴻⵎ ⵉ ⵓⵛⵓⵡⵡⴰⴼ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ ⵏⵉⵖ ⵜⵜⵛⴰⵔⵔⴳⴻⵎ ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ ⵉ ⵡⴻⵛⴹⴰⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ⵎⴰⵛⴰ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵔⵓⵏ ⵅ ⵜⵎⴻⵙⵙⵉ-ⵢⴰ, ⵜⴻⵏⵏⵉ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV10_7","004_10_7","LEV","10","7","7","ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵎ ⵛⴰ ⵣⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ ⵜⵜ ⵅⴰⵡⴻⵎ.” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵟⵟⴰⵄⴻⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV10_8","004_10_8","LEV","10","8","8","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV10_9","004_10_9","LEV","10","9","9","“ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵙⴻⵙⵙⴻⴷ ⴱⵉⵏⵓ ⵏⵉⵖ ⵛⵛⵔⴰⴱ ⵉⵊⴻⵀⴷⴻⵏ ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵛⴻⴽ ⵍⵍⴰ ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵍⵍⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV10_10","004_10_10","LEV","10","10","10","ⵃⵉⵎⴰ ⴰⴷ ⴰⴼ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴼⴰⵔⵣⴻⵎ ⵊⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵊⴰⵔ ⵎⵉⵏ ⵉⵚⴼⴰⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵚⴼⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LV10_11","004_10_11","LEV","10","11","11","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⵎ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("LV10_12","004_10_12","LEV","10","12","12","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵓ ⴰⴽ-ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ, ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ: “ⴽⵙⵉⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⵉ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵛⵛⴻⵎ ⵜⵜ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV10_13","004_10_13","LEV","10","13","13","ⴰⴷ ⵜⵜ ⵜⴻⵛⵛⴻⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵡⴻⵚⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("LV10_14","004_10_14","LEV","10","14","14","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵚⴼⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵄⴰⵡⴻⴷ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⴷ ⵓⵛⴻⴽⵔⵓⴷ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ, ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LV10_15","004_10_15","LEV","10","15","15","ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⵛⴻⴽⵔⵓⴷ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵓⵍⴰ ⴷ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵜⴰⴷⵓⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV10_16","004_10_16","LEV","10","16","16","ⵓⵛⴰ ⵎⵓⵙⴰ ⵢⴰⵔⵣⵓ ⵙ ⵛⴹⴰⵔⴻⵜ ⵅ ⵓⵎⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵉⵛⴻⵎⴹ. ⵅⴻⵏⵏⵉ ⵉⴼⴼⵓⴳⴻⵎ ⵅ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ, ⴰⵔⵔⴰⵡ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV10_17","004_10_17","LEV","10","17","17","“ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵛⵛⵉⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ? ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵜⵜ-ⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵔⴱⵓⵎ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴻⴳⴳⴻⵎ ⴰⵚⵍⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV10_18","004_10_18","LEV","10","18","18","ⵅⵣⴰⵔⴻⵎ, ⵃⴷⴰⵎ ⵡⴰⵔ ⵙⵙⵉⴷⴼⴻⵏ ⵡⴰⵍⵓ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⴷⴰⵅⴻⵍ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜ ⵜⴻⵛⵛⴻⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵡⴻⵎ ⵡⴻⵚⵚⵉⵖ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("LV10_19","004_10_19","LEV","10","19","19","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵀⴰⵔⵓⵏ ⴰⴽ-ⴷ ⵎⵓⵙⴰ: “ⵅⵣⴰⵔ, ⴰⵙⵙ-ⴰ ⴰⵇⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵍⴰ ⵏⴻⵛⵛ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵅⴰⴼⵉ ⴽⴽⴻⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴰⵇⴰ ⵛⵛⵉⵖ ⵣⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴰⵙⵙ-ⴰ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵛⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("LV10_20","004_10_20","LEV","10","20","20","ⵓⵎⵉ ⵉⵙⵍⴰ ⵎⵓⵙⴰ ⴰⵢⴰ, ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV11_1","004_11_1","LEV","11","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("LV11_2","004_11_2","LEV","11","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉⵎ: ‘ⵉⵏⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵎⴰⵍ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏⵏⵉ ⴷⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_3","004_11_3","LEV","11","3","3","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⴰⵇⴰ ⴼⴰⵔⵇⴰ ⵏ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵙⵙⴻⴱⴹⴰⵏ ⵇⴰⵄ, ⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵜⴰⵔⵔⴰⵏ ⵉⴼⴻⵥ. ");
INSERT INTO rift_vpl VALUES ("LV11_4","004_11_4","LEV","11","4","4","ⵎⴰⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⴼⴻⵥ ⴷ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵉⵏⴰ: ⴰⵍⵖⴻⵎ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴻⴼⴼⴻⵥ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵅⵎⴻⵊ ⵉ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("LV11_5","004_11_5","LEV","11","5","5","ⴰⴽⴰⵡⴽⴰ ⵏ ⵜⴻⵚⴹⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴰⵔⵔⴰ ⵉⴼⴻⵥ, ⵎⴰⵛⴰ ⵜⴰⵛⴹⴻⵛⵜ ⵡⴰⵔ ⵜⴻⵎⵎⵙⴻⴱⴹⵉ, ⵓ ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵅⵎⴻⵊ ⵉ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("LV11_6","004_11_6","LEV","11","6","6","ⴰⵎⴻⵏⵏⵉ ⴰⵢⴰⵔⵣⵉⵣ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴰⵔⵔⴰ ⵉⴼⴻⵥ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴰⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵅⵎⴻⵊ ⵉ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("LV11_7","004_11_7","LEV","11","7","7","ⵄⴰⵡⴻⴹ ⵉⵍⴻⴼ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⵙ ⵜⴰⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵓⵛⴰ ⴰⵇⴰ ⴼⴰⵔⵇⴰ ⵏ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵇⴰⵄ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⴰⵔⵔⵉ ⵉⴼⴻⵥ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵅⵎⴻⵊ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("LV11_8","004_11_8","LEV","11","8","8","ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵎ ⵏⵉⵖ ⴰⴷ ⵜⵃⴰⴷⴰⵎ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵅⴻⵎⵊⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ.’” ");
INSERT INTO rift_vpl VALUES ("LV11_9","004_11_9","LEV","11","9","9","“ⵉⵏⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ: ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴼⵔⵉⵡⴻⵏ ⴷ ⵜⴻⵇⵛⵓⵔⵜ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓ ⴷⵉ ⵍⴻⴱⵃⵓⵔ ⵓ ⴷⵉ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ, ⵉⵏⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV11_10","004_11_10","LEV","11","10","10","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⵉ ⵡⴰⵔ ⵖⴰⵔ ⵢⴻⴵⵉ ⵉⴼⵔⵉⵡⴻⵏ ⵏⵉⵖ ⵜⴰⵇⵛⵓⵔⵜ ⴷⵉ ⵍⴻⴱⵃⵓⵔ ⵓ ⴷⵉ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ, ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉ ⵣⵉ ⵙⵙⴻⴼⴼⵢⴻⵏ ⴰⵎⴰⵏ ⵓⵍⴰ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵏⵏⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("LV11_11","004_11_11","LEV","11","11","11","ⵡⴰⵀ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵏⵏⵄⵉ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ ⵓ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏⵜ ⴷ ⵏⵏⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("LV11_12","004_11_12","LEV","11","12","12","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⴱⵍⴰ ⵉⴼⵔⵉⵡⴻⵏ ⴷ ⵜⴻⵇⵛⵓⵔⵜ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵏⵏⵄⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV11_13","004_11_13","LEV","11","13","13","“ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏ ⵉⵏⴰ ⴷ ⵏⵏⵄⵉ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵏⵏⵄⵉ: ⴰⴳⵉⴷⴻⵔ, ⵉⵙⵖⵉ, ⴰⴳⵉⴷⴻⵔ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("LV11_14","004_11_14","LEV","11","14","14","ⴰⵛⴻⴼⴼⴰⵔ ⵉⵟⵟⴰⵡⴻⵏ ⵙ ⵜⴰⵣⵍⴰ, ⴰⵎⴻⵙⵙⵖⵓⵢ ⴰⵎⵓⵇⴹⵉⵄ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV11_15","004_11_15","LEV","11","15","15","ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵓⴱⴰⵖⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("LV11_16","004_11_16","LEV","11","16","16","ⵢⴻⴵⵉⵙ ⵏ ⵜⵖⵓⵢⵢⵉⵜ, ⴰⵄⴻⵏⵏⴰⴼ, ⴰⵊⴹⵉⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵍⴱⴰⵣ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV11_17","004_11_17","LEV","11","17","17","ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴽⴰⵙ, ⴱⵓ-ⵜⵛⴰⵔⴰⵔⵔⵓⵜ, ⴱⵓ-ⵓⵙⵓⴹⵉ ⵏ ⵍⵎⴻⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("LV11_18","004_11_18","LEV","11","18","18","ⴱⵓ-ⵢⵓⵏⵜⴰⵃ, ⴱⵓ-ⵓⵄⵓⵇⵇⵉ, ⴱⵓ-ⵓⵃⴰⵡⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("LV11_19","004_11_19","LEV","11","19","19","ⴰⴱⴻⵍⵍⴰⵔⵊ, ⴱⵓ-ⵓⵙⵓⴹⵉ ⵉⵄⴻⴼⴼⵏⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ⴷⵓⵏⴷⵓⵏ ⴷ ⵍⵡⴻⴹⵡⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("LV11_20","004_11_20","LEV","11","20","20","“ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴼⵔⵉⵡⴻⵏ ⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵓ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵏⵏⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("LV11_21","004_11_21","LEV","11","21","21","ⵎⴰⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⴰⵎ ⵖⴰⵔⵙⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵓ ⴳⴳⵓⵔⴻⵏ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ, ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⴹⴰⵔⴻⵏ ⵉ ⵡⴻⵏⴳⴰⵣ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵉ ⵜⴻⵛⵍⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴻⴳⵣⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_22","004_11_22","LEV","11","22","22","ⵉⵏⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵛⵛⴻⵎ: ⵜⴰⵎⵓⵔⵖⵉ ⵏ ⵡⴻⵢⵍⴰⴼ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ⵜⴰⵎⵓⵖⵔⵉ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ⵜⴰⵎⵓⵖⵔⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵎⵓⵖⵔⵉ ⵉⵍⴻⵃⵃⴼⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV11_23","004_11_23","LEV","11","23","23","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴼⵔⵉⵡⴻⵏ ⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵓ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵏⵏⵄⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV11_24","004_11_24","LEV","11","24","24","“ⵙ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ-ⴰ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵅⴻⵎⵊⴻⵎ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_25","004_11_25","LEV","11","25","25","ⵎⴰⵏⵡⴻⵏ ⵢⵉⵡⵢⴻⵏ ⵛⴰ ⵣⵉ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_26","004_11_26","LEV","11","26","26","ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵉ ⵣⵉ ⴼⴰⵔⵇⴰ ⵏ ⵜⴻⵛⴹⴻⵛⵜ ⵡⴰⵔ ⵜⴼⴰⵔⵇ ⵇⴰⵄ, ⵓⵍⴰ ⵡⴰⵔ ⵜⵜⴰⵔⵔⴰⵏ ⵉⴼⴻⵥ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV11_27","004_11_27","LEV","11","27","27","ⴽⵓⵍ ⴰⵎⵓⴷⴷⴰⵔ ⵊⴰⵔ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_28","004_11_28","LEV","11","28","28","ⵡⵉ ⵢⵉⵡⵢⴻⵏ ⵛⴰ ⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⵎⴻⴷⴷⵉⵜ. ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV11_29","004_11_29","LEV","11","29","29","“ⵣⵉ ⵊⴰⵔ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴷ ⵉⵏⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ: ⴰⵊⴰⵔⴱⵓⵄ, ⴰⵖⴻⵔⴷⴰ, ⵉⵛⴼⴰⵔ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV11_30","004_11_30","LEV","11","30","30","ⵉⵇⵇⵍⵉ, ⵜⴰⴽⵏⴰⴽⴰⵔⵜ, ⴰⵣⴻⵔⵎⵓⵎⵎⵓⵢ, ⴰⵃⴷⵉⴹ ⴷ ⵜⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LV11_31","004_11_31","LEV","11","31","31","ⵉⵏⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵡⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_32","004_11_32","LEV","11","32","32","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵡⴹⴰ ⵛⴰ ⵣⵉ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ, ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ, ⵏⵉⵖ ⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⵜⵉⵍⵎⴻⵛⵜ, ⵏⵉⵖ ⵜⴰⵅⴰⵏⵛⴻⵜ, ⵏⵉⵖ ⵎⵉⵏ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵅⴻⴼ ⵉⵡⴹⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV11_33","004_11_33","LEV","11","33","33","ⵎⴰⵔⵔⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ, ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⴷⵉ ⵉⵡⴹⴰ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⴻⵙ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵔⵥⴻⵎ ⵟⵟⴻⴱⵚⵉ. ");
INSERT INTO rift_vpl VALUES ("LV11_34","004_11_34","LEV","11","34","34","ⵎⴰⵔⵔⴰ ⵎⴰⵛⵛⴰ ⵏⵏⵉ ⵜⵜⵏⵓⵎⴰⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⵛⵛⴻⵏ, ⵜⴻⵏⵏⵉ ⵅ ⵡⴹⴰⵏ ⵡⴰⵎⴰⵏ ⵏⵏⵉ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ, ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵙⵙⵉⵜ ⵏⵏⵉ ⵜⵜⵏⵓⵎⴰⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⵙⵡⴻⵏ, ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⴷⵉ ⵜⴻⴵⴰ ⵎⴰⵛⵛⴰ ⵏⵉⵖ ⵜⵉⵙⵙⵉⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV11_35","004_11_35","LEV","11","35","35","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵡⴹⴰ ⵛⴰ ⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⴰⴼⴰⵔⵏⵓ ⴷ ⵜⵣⴻⵡⴹⴰ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ, ⴰⵇⴰ ⵅⴻⵎⵊⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV11_36","004_11_36","LEV","11","36","36","ⵎⴰⵛⴰ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵉⵖ ⴷ ⴰⵏⵓ ⵎⴰⵏⵉ ⵖⴰⵔ ⵙⵙⵉⵣⵣⵍⴻⵏ ⴰⵎⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⴻⴳ. ⵎⴰⵛⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV11_37","004_11_37","LEV","11","37","37","ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵡⴹⴰ ⵛⴰ ⵣⵉ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⵅ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵓⵣⴰⵔⵄ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⴷ ⴰⴷ ⵣⴰⵔⵄⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵉⵣⴷⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("LV11_38","004_11_38","LEV","11","38","38","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵙⴻⵢⵢⴱⴻⵏ ⴰⵎⴰⵏ ⵅ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵓⵛⴰ ⵉⵡⴹⴰ ⵅⴰⵙ ⵛⴰ ⵣⵉ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⵉ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV11_39","004_11_39","LEV","11","39","39","ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵉⵊⵊ ⵣⵉ ⵊⴰⵔ ⵍⵎⴰⵍ ⵏⵏⵉ ⵜⴻⵛⵛⵉⵎ, ⵅⴻⵏⵏⵉ ⵡⵉ ⵖⴰ ⵉⵃⴰⴹⴰⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_40","004_11_40","LEV","11","40","40","ⵡⴻⵏⵏⵉ ⵉⵛⵛⴻⵏ ⵣⵉ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ⵡⴻⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵛⴰ ⵣⵉ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_41","004_11_41","LEV","11","41","41","ⴽⵓⵍ ⴰⵎⵓⴷⴷⴰⵔ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("LV11_42","004_11_42","LEV","11","42","42","ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵉⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⴰⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴹⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵏⵏⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("LV11_43","004_11_43","LEV","11","43","43","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵏⵏⵄⵉ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⵍⴰⵎⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵅⴻⵎⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV11_44","004_11_44","LEV","11","44","44","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵇⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ. ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵎ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵉⵎⵎⵓⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV11_45","004_11_45","LEV","11","45","45","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV11_46","004_11_46","LEV","11","46","46","ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵅ ⵍⵎⴰⵍ, ⵅ ⵉⵊⴹⴰⴹ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴻⴼⵢⴻⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LV11_47","004_11_47","LEV","11","47","47","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ ⴷ ⵎⵉⵏ ⵉⵣⴷⵉⴳⴻⵏ ⵓ ⵊⴰⵔ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵉ ⵎⴰⵛⵛⴰ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵉ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LV12_1","004_12_1","LEV","12","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV12_2","004_12_2","LEV","12","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⵎⴰⵍⴰ ⵜⴻⴽⵙⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵅⵎⵉ ⵅⴰⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV12_3","004_12_3","LEV","12","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV12_4","004_12_4","LEV","12","4","4","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵜᵉⵜⵜⵃⵉⴷⵉ ⵡⴰⵍⵓ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⴻⵙ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵔⴰⵃ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵍ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV12_5","004_12_5","LEV","12","5","5","ⵎⴰⵍⴰ ⵜⵓⵔⵓⵡ ⴷ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ, ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV12_6","004_12_6","LEV","12","6","6","ⵅⵎⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏ ⵎⵎⵉⵙ ⵏⵉⵖ ⵏ ⵢⴻⴵⵉⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵡⵉ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⴷⴱⵉⵔ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵜ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV12_7","004_12_7","LEV","12","7","7","ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⵎⴰⵏ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵉⵣⴷⴻⴳ ⵣⵉ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ. ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵏ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵢⴻⴵⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("LV12_8","004_12_8","LEV","12","8","8","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵉⵡⵉⴹ ⴰⴷ ⵜⴰⵡⵉ ⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉⵊⵊ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵉⵊⵊ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵉⵣⴷⴻⴳ.’” ");
INSERT INTO rift_vpl VALUES ("LV13_1","004_13_1","LEV","13","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV13_2","004_13_2","LEV","13","2","2","“ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴰⵄⴻⴱⴱⵓⵣ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ, ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ, ⵏⵉⵖ ⵖⴰⵔ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_3","004_13_3","LEV","13","3","3","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵡⵓⴹⵓⵏ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵉⵥⵓⵟⵟⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⵓⴹⵓⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⵓⵛⴰ ⵉⴱⴰⵏ ⵡⵓⴹⵓⵏ ⵄⴰⴷ ⵢⵓⴵⴻⵖ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵅⴻⵏⵏⵉ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ. ⵅⵎⵉ ⵜ ⵖⴰ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("LV13_4","004_13_4","LEV","13","4","4","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵓ ⵡⴰⵔ ⵢⵓⴵⵉⵖ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵓ ⵉⵥⴻⵟⵟⴰⵏ ⵡⴰⵔ ⴷⵡⵉⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴱⴻⵍⵍⴻⵄ ⵓⴽⴻⵀⵀⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⴹⵓⵏ ⵏⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_5","004_13_5","LEV","13","5","5","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵓⴹⵓⵏ ⴰⵎⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ, ⵡⴰⵔ ⵉⵎⵖⵉⵔ ⵡⵓⴹⵓⵏ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵉⴱⴻⵍⵍⴻⵄ ⵓⴽⴻⵀⵀⴰⵏ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LV13_6","004_13_6","LEV","13","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⴱⴰⵏ ⴰⵇⴰ ⵓⴹⵓⵏ ⵢⴰⵔⵙⴰ ⵓⵛⴰ ⵡⴰⵔ ⵉⵎⵖⵉⵔ ⵄⴰⴷ ⴽⵜⴰⵔ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴼⵓⵔⵉⵢ. ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_7","004_13_7","LEV","13","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵖⴰⵔ ⵡⵓⴹⵓⵏ ⴰⵟⵟⴰⵙ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LV13_8","004_13_8","LEV","13","8","8","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⵇⴰ ⵍⴻⵀⵍⴰⵛ ⵉⵎⵖⴰⵔ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⴰⵇⴰ-ⵜ ⴷ ⵍⴻⵀⵍⴰⵛ ⵏ ⵍⴱⴰⵔⵚ ⵉ ⵉⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("LV13_9","004_13_9","LEV","13","9","9","ⵅⵎⵉ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_10","004_13_10","LEV","13","10","10","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⵇⴰ ⵉⴱⴰⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⴱⴱⵓⵣ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ, ⵓ ⵉⵥⴻⵟⵟⴰⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⵓ ⵉⴱⴰⵏ-ⴷⴷ ⵡⴻⵢⵙⵓⵎ ⵉⴷⴷⴰⵔ ⴷⴻⴳ ⵓⵄⴻⴱⴱⵓⵣ, ");
INSERT INTO rift_vpl VALUES ("LV13_11","004_13_11","LEV","13","11","11","ⴰⵇⴰ-ⵜ ⴷ ⵍⴱⴰⵔⵙ ⴰⵇⴷⵉⵎ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⴱⴻⵍⵍⵉⵄ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV13_12","004_13_12","LEV","13","12","12","ⵎⴰⵍⴰ ⵢⵓⵢⵓⵔ ⵍⴱⴰⵔⵚ ⵅ ⵜⵉⵍⵎⴻⵛⵜ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⵉⴷⵍⴰ ⵍⴱⴰⵔⵚ ⵎⴰⵔⵔⴰ ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⴹⵓⵏ ⵣⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵍ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵍ ⵎⴰⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV13_13","004_13_13","LEV","13","13","13","ⵓⵛⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⴽⴻⵀⵀⴰⵏ, ⵉⵥⵔⴰ ⵍⴱⴰⵔⵙ ⵉⴷⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵉ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⵓⴹⵓⵏ. ⵜⵉⵍⵎⴻⵛⵜ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵛⴻⵎⵍⴰⵍⵜ ⵇⴰⵄ. ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_14","004_13_14","LEV","13","14","14","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⴰⵏⵉ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⴷⴷ-ⵉⴱⴰⵏ ⵡⴻⵢⵙⵓⵎ ⵉⴷⴷⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV13_15","004_13_15","LEV","13","15","15","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵢⵙⵓⵎ ⵏⵏⵉ ⵉⴷⴷⴰⵔ, ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⴰⵢⵙⵓⵎ ⵉⴷⴷⴰⵔⴻⵏ ⵉⵅⵎⴻⵊ, ⴰⵇⴰ-ⵜ ⴷ ⵍⴻⵀⵍⴰⵛ ⵏ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("LV13_16","004_13_16","LEV","13","16","16","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵡⴻⵢⵙⵓⵎ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_17","004_13_17","LEV","13","17","17","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⵇⴰ ⴰⵎⵛⴰⵏ ⵏ ⵓⴹⵓⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵓⴽⴻⵀⵀⴰⵏ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴻⵀⵍⴰⵛ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_18","004_13_18","LEV","13","18","18","ⵎⴰⵍⴰ ⴷⵉⵏ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵓ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ ⵜⴰⵏⵉⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("LV13_19","004_13_19","LEV","13","19","19","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⴱⴱⵓⵣ ⵉⵎⵍⴻⵍ ⵏⵉⵖ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ, ⴰⵛⴻⵎⵍⴰⵍ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵣⵡⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LV13_20","004_13_20","LEV","13","20","20","ⵅⵎⵉ ⵖⴰⵔⴻⵙ ⵉ ⵖⴰ ⵉⵅⵣⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ-ⵜ ⵙⴰⴷⵓ ⵜⴻⵍⵎⴻⵛⵜ ⵓⵛⴰ ⵉⵥⴻⵟⵟⴰⵏ ⵏⵏⴻⵙ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ, ⴰⵇⴰ-ⵜ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⵡⴻⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⵙ ⵜⵃⴻⴱⴱⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV13_21","004_13_21","LEV","13","21","21","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⵓⴼⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵥⴻⵟⵟⵓ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵓⵛⴰ ⵡⴰⵔ ⵉⴷⵡⵉⵍ ⵢⵓⴵⴻⵖ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ⵎⴰⵛⴰ ⵉⴷⵡⴻⵍ ⵢⴰⵔⵙⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵉⴱⴻⵍⵍⴻⵄ ⵓⴽⴻⵀⵀⴰⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_22","004_13_22","LEV","13","22","22","ⵎⴰⵍⴰ ⵜⵓⵢⵓⵔ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵎⴰⵔⵔⴰ, ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⴰⵇⴰ-ⵜ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("LV13_23","004_13_23","LEV","13","23","23","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ ⵏ ⵜⴻⵍⵎⴻⵛⵜ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵎⵖⵉⵔ ⵛⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵛⵛⴰⵎⴻⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_24","004_13_24","LEV","13","24","24","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⴷⵡⴻⵍ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵊⵊ ⵏ ⵓⵢⴻⵣⵣⵉⵎ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⵢⵙⵓⵎ ⵉⴷⴷⴰⵔⴻⵏ ⵏ ⵓⵢⴻⵣⵣⵉⵎ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ, ⴰⵛⴻⵎⵍⴰⵍ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵣⵡⴻⵖ ⵏⵉⵖ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("LV13_25","004_13_25","LEV","13","25","25","ⵓⵛⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵥⴻⵟⵟⴰⵏ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ, ⵓⵛⴰ ⵉⴱⴰⵏ ⴰⵇⴰ ⴰⵎⵛⴰⵏ ⵏ ⵡⴻⵏⴳⴰⵣ ⵢⵓⴵⴻⵖ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵍⴱⴰⵔⵚ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵢⴻⵣⵣⵉⵎ ⵏ ⵡⴻⵛⵎⴰⴹ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⴰⵇⴰ-ⵜ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("LV13_26","004_13_26","LEV","13","26","26","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵉⵥⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵉⵥⴻⵟⵟⴰⵏ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⴷⴻⴳ ⵡⴻⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵏⴳⴰⵣ ⵡⴰⵔ ⵢⵓⴵⵉⵖ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵓⵛⴰ ⵢⴰⵔⵙⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵉⴱⴻⵍⵍⴻⵄ ⵓⴽⴻⵀⵀⴰⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_27","004_13_27","LEV","13","27","27","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵖⴰⵔ ⵡⴻⵏⴳⴰⵣ ⴽⵜⴰⵔ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⴰⵇⴰ-ⵜ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("LV13_28","004_13_28","LEV","13","28","28","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵎⵖⵉⵔ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⵓⵛⴰ ⵢⴰⵔⵙⴰ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵄⴻⴱⴱⵓⵣ ⵏ ⵡⴻⵛⵎⴰⴹ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵛⵛⴰⵎⴻⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV13_29","004_13_29","LEV","13","29","29","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷⴰⵢⴻⵙ ⵓⴹⵓⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵏⵉⵖ ⴷⵉ ⵜⵎⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LV13_30","004_13_30","LEV","13","30","30","ⵓⵛⴰ ⵉⵅⵣⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵓⴹⵓⵏ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⴱⴰⵏ ⵢⵓⴵⴻⵖ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵓⵛⴰ ⴷⴰⵢⴻⵙ ⵉⵥⴻⵟⵟⴰⵏ ⵉⵡⴰⵔⵖⴻⵏ ⴷ ⵉⵣⴷⴰⴷⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵍⴱⴰⵔⵚ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵉⵖ ⵏ ⵜⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV13_31","004_13_31","LEV","13","31","31","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵓⴹⵓⵏ ⵏ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ, ⵉⵥⵔⴰ ⴰⵇⴰ ⵡⴰⵔ ⵢⵓⴵⵉⵖ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵥⴻⵟⵟⴰⵏ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵉⴱⴻⵍⵍⴻⵄ ⵓⴽⴻⵀⵀⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⵓⴹⵓⵏ ⵏ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_32","004_13_32","LEV","13","32","32","ⴰⴷ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⴹⵓⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ, ⴰⵇⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵡⴰⵔ ⵜⴻⵎⵖⵉⵔ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⵓⴼⵉ ⵉⵥⴻⵟⵟⴰⵏ ⵉⵡⴰⵔⵖⴻⵏ ⵓⵛⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵡⴰⵔ ⵜⵓⴵⵉⵖ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("LV13_33","004_13_33","LEV","13","33","33","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴻⴼⴼ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵎⵛⴰⵏ ⵏ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵡⴰⵔ ⵜ ⵉⵜⵜⵃⴻⴼⴼⵉ ⵛⴰ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴱⴻⵍⵍⴻⵄ ⵅ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_34","004_13_34","LEV","13","34","34","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵉⵥⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵎⵛⴰⵏ ⵏ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ. ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵡⴰⵔ ⵜⴻⵎⵖⵉⵔ ⵛⴰ, ⵡⴰⵔ ⵜⵓⴵⵉⵖ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵀ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_35","004_13_35","LEV","13","35","35","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵅ ⵜⴻⵍⵎⴻⵛⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV13_36","004_13_36","LEV","13","36","36","ⵓⵛⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵉⵥⵔⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵜⴻⵎⵖⴰⵔ ⵅ ⵜⴻⵍⵎⴻⵛⵜ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⵓⴽⴻⵀⵀⴰⵏ ⵅ ⵉⵥⴻⵟⵟⴰⵏ ⵉⵡⴰⵔⵖⴻⵏ ⵄⴰⴷ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV13_37","004_13_37","LEV","13","37","37","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⴰⵇⴰ ⵜⴱⴰⵏ-ⴷⴷ ⵜⴱⴻⴷⴷ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵥⴻⵟⵟⴰⵏ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵜᵉⴳⴳⴻⵏⴼⴰ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵣⴷⴻⴳ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_38","004_13_38","LEV","13","38","38","ⵎⴰⵍⴰ ⴱⴰⵏⴻⵏ-ⴷⴷ ⵉⵎⵓⵛⴰⵏ ⵛⵛⴻⵎⵍⴻⵍⴻⵏ, ⵉⵛⵛⴻⵎⵍⴻⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ, ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LV13_39","004_13_39","LEV","13","39","39","ⵓⵛⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⴷⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴱⴰⵏⴻⵏ-ⴷⴷ ⵉⵎⵓⵛⴰⵏ ⴰⵔⵙⴰⵏ, ⵉⵛⴻⵎⵍⴰⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴼⵓⵔⵉ ⵏ ⵜⴻⵍⵎⴻⵛⵜ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵣⴷⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_40","004_13_40","LEV","13","40","40","ⵎⴰⵍⴰ ⵉⵡⴹⴰ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵇⴰ ⴷ ⴰⵇⴻⵛⵛⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_41","004_13_41","LEV","13","41","41","ⵎⴰⵍⴰ ⵜⴰⵏⵢⴰⵔⵜ ⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴰⵍⴻⵇⵇⴰⵖⵜ, ⴰⵇⴰ ⵜⴰⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵇⴻⵛⵛⴰⵔ ⵡⴰⵀⴰ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV13_42","004_13_42","LEV","13","42","42","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴹⵓⵏ ⵉⵎⵍⴻⵍ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵣⵡⴻⵖ ⵅ ⵓⵣⴻⴵⵉⴼ ⴰⵇⴻⵛⵛⴰⵔ ⵏⵉⵖ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵍⴱⴰⵔⵚ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵇⴻⵛⵛⴰⵔ ⵏⵉⵖ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV13_43","004_13_43","LEV","13","43","43","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⴰⵄⴻⴱⴱⵓⵣ ⵏ ⵡⵓⴹⵓⵏ ⵉⵎⵍⴻⵍ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵣⵡⴻⵖ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵇⴻⵛⵛⴰⵔ ⵏⵉⵖ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ, ⵉⴱⴰⵏ-ⴷⴷ ⴰⵎ ⵍⴱⴰⵔⵚ ⵏ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("LV13_44","004_13_44","LEV","13","44","44","ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⴷ ⴱⵓ-ⵍⴱⴰⵔⵚ ⵉ ⵉⴵⴰ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵅⵎⴻⵊ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵅⵎⵓⵊ, ⵓⴹⵓⵏ ⴰⵇⴰ-ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV13_45","004_13_45","LEV","13","45","45","“ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⴱⵓ-ⵍⴱⴰⵔⵚ ⵉ ⴷⵉ ⵉⴵⴰ ⵡⵓⴹⵓⵏ ⵓⵛⴰ ⴰⴷ ⵉⴹⵍⴻⵇ ⵉ ⵓⵛⵓⵡⵡⴰⴼ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵍⴻⵃⵃⴻⴼ ⴰⵛⵍⴰⵖⴻⵎ ⵖⴰⵔ ⵓⵢⴻⵏⵛⵉⵛ, ⴰⴷ ⵉⵍⴰⵖⴰ: ‘ⴰⵎⴻⵅⵎⵓⵊ! ⴰⵎⴻⵅⵎⵓⵊ!’ ");
INSERT INTO rift_vpl VALUES ("LV13_46","004_13_46","LEV","13","46","46","ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵡⵓⴹⵓⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⵡⴻⵃⵃⴷⴻⵙ ⵓⵛⴰ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LV13_47","004_13_47","LEV","13","47","47","“ⵎⴰⵍⴰ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵜⴰⴹⵓⴼⵜ ⵏⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LV13_48","004_13_48","LEV","13","48","48","ⵏⵉⵖ ⴷⴻⴳ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⴷⴻⴳ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⵏ ⵍⴻⵇⵟⴻⵏ ⵏⵉⵖ ⵏ ⵜⴰⴹⵓⴼⵜ, ⵏⵉⵖ ⵖⴰⵔ ⵢⵉⵍⴻⵎ, ⵏⵉⵖ ⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵢⵉⵍⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV13_49","004_13_49","LEV","13","49","49","ⵓ ⵜⵉⵛⵜⵉ ⵉⵜⵜⵡⴰⵡⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵉⵖ ⴷⴻⴳ ⵢⵉⵍⴻⵎ, ⵏⵉⵖ ⵖⴰⵔ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⵖⴰⵔ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⴷⵉ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ, ⵜⴻⵣⵣⵉⵣⵓ ⵏⵉⵖ ⵜⴻⵣⵡⴻⵖ, ⴰⵇⴰ-ⵜ ⴷ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ. ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵏ ⴰⵢⴰ ⵉ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_50","004_13_50","LEV","13","50","50","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⴹⵓⵏ ⵓⵛⴰ ⵎⵉⵏ ⵉⴹⵏⴻⵏ ⴰⴷ ⵜ ⵉⴱⴻⵍⵍⴻⵄ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_51","004_13_51","LEV","13","51","51","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵡⵓⴹⵓⵏ. ⵎⴰⵍⴰ ⵉⵎⵖⴰⵔ ⵓⴹⵓⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⵖⴰⵔ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⵖⴰⵔ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⴷⴻⴳ ⵢⵉⵍⴻⵎ ⵏ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ, ⴰⵇⴰ ⵓⴹⵓⵏ ⴷ ⵍⴱⴰⵔⵙ ⵉⵇⴻⵙⵃⴻⵏ ⵉ ⵢⴻⴵⴰ, ⴰⵇⴰ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV13_52","004_13_52","LEV","13","52","52","ⴰⴷ ⵉⵙⵙⴻⵛⵎⴻⴹ ⴰⵔⵔⵓⴹ ⵏⵉⵖ ⴰⴼⵉⵍⵓ ⴷ ⴰⵣⵉⵔⴰⵔ ⵏⵉⵖ ⴰⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⵏ ⵜⴰⴹⵓⴼⵜ ⵏⵉⵖ ⵏ ⵍⴻⵇⵟⴻⵏ ⵉ ⵉⴵⴰ, ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ ⵉ ⴷⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵓⴹⵓⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜ ⴷ ⵍⴱⴰⵔⵚ ⵉⵇⴻⵙⵃⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV13_53","004_13_53","LEV","13","53","53","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⵇⴰ ⵓⴹⵓⵏ ⵡⴰⵔ ⵉⵎⵖⵉⵔ ⵛⴰ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⴷⴻⴳ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⴷⴻⴳ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⴷⵉ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV13_54","004_13_54","LEV","13","54","54","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵓⵎⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵎⵉⵏ ⴷⵉ ⵢⴻⴵⴰ ⵡⵓⴹⵓⵏ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵅⴰⵙ ⵉⴱⴻⵍⵍⴻⵄ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵍⵇⴻⴷⴷ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_55","004_13_55","LEV","13","55","55","ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵓⴹⵓⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⵉⵔⴷ, ⵓⵛⴰ ⵉⵥⵔⴰ ⵓⴹⵓⵏ ⵡⴰⵔ ⵉⴱⴻⴷⴷⵉⵍ ⵛⴰ ⵓⵛⴰ ⵓⴹⵓⵏ ⵡⴰⵔ ⵉⵎⵖⵉⵔ, ⴰⵇⴰ ⴰⵔⵔⵓⴹ ⵏⵏⵉ ⵉⵅⵎⴻⵊ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⵛⵎⴻⴹⴻⴷ ⵙ ⵜⵎⴻⵙⵙⵉ. ⴰⵇⴰ ⵓⴹⵓⵏ ⵉⴷⵡⴻⵍ ⵢⵓⴵⴻⵖ ⵉⵜⵜᵉⵜⵜ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵉⵖ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("LV13_56","004_13_56","LEV","13","56","56","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵓⴹⵓⵏ ⵢⴰⵔⵙⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⵉⵔⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵉⵇⴻⵙⵙ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⵣⴻⴳ ⵢⵉⵍⴻⵎ, ⵏⵉⵖ ⵣⴻⴳ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_57","004_13_57","LEV","13","57","57","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⴱⴰⵏ ⵡⵓⴹⵓⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⵖⴰⵔ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⵖⴰⵔ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⴷⵉ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ, ⴰⵇⴰ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵍⴱⴰⵔⵚ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉ ⵉⴵⴰⵏ ⵓⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LV13_58","004_13_58","LEV","13","58","58","ⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⴰⴼⵉⵍⵓ ⴷ ⴰⵣⵉⵔⴰⵔ ⵏⵉⵖ ⴰⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ, ⵡⴻⵏⵏⵉ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵓⵛⴰ ⵉⵔⵓⵃ ⵅⴰⵙ ⵡⵓⴹⵓⵏ, ⴰⴷ ⵜ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ.” ");
INSERT INTO rift_vpl VALUES ("LV13_59","004_13_59","LEV","13","59","59","ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵏ ⵡⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵜⴰⴹⵓⴼⵜ ⵏⵉⵖ ⵏ ⵍⴻⵇⵟⴻⵏ, ⵏⵉⵖ ⵏ ⵡⴻⵛⴹⴰⴹ ⵉⵅⴻⵢⵢⴹⴻⵏ ⵏⵉⵖ ⵏ ⵓⴼⵉⵍⵓ ⵉⵎⵎⵓⴷⴻⵏ, ⵏⵉⵖ ⵏ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵢⵉⵍⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⴻⵣⴷⴻⴳ ⵏⵏⴻⵙ ⵏⵉⵖ ⵙ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV14_1","004_14_1","LEV","14","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV14_2","004_14_2","LEV","14","2","2","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵏ ⴱⵓ-ⵍⴱⴰⵔⵚ ⵉ ⵡⴰⵙⵙ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("LV14_3","004_14_3","LEV","14","3","3","ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵅⵎⵉ ⵖⴰⵔⴻⵙ ⵉ ⵖⴰ ⵉⵅⵣⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵉⴳⴳⴻⵏⴼⴰ ⵡⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⵏ ⴱⵓ-ⵍⴱⴰⵔⵚ, ");
INSERT INTO rift_vpl VALUES ("LV14_4","004_14_4","LEV","14","4","4","ⴰⴷ ⵢⵓⵎⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵙⵉⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴹⴰⴹ ⵉⴷⴷⴰⵔⴻⵏ ⵉⵣⴷⵉⴳⴻⵏ, ⵓⵍⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⴷ ⵜⵄⴻⵍⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_5","004_14_5","LEV","14","5","5","ⴰⴷ ⵢⵓⵎⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵎⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_6","004_14_6","LEV","14","6","6","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⴰⵊⴹⵉⴹ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵜⵄⴻⵍⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵓⴼ ⴰⴽ-ⴷ ⵡⴻⵊⴹⵉⴹ ⵉⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵡⴻⵊⴹⵉⴹ ⵉ ⵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵎⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_7","004_14_7","LEV","14","7","7","ⴰⴷ ⵉⵔⵓⵛⵛ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵣⵉ ⵍⴱⴰⵔⵚ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵡⴻⵊⴹⵉⴹ ⵉⴷⴷⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴹⴻⵡ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV14_8","004_14_8","LEV","14","8","8","ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵃⴻⴼⴼ ⵎⴰⵔⵔⴰ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⴻⴳ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴱⴰⵔⵔⴰ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_9","004_14_9","LEV","14","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵉⵃⴻⴼⴼ ⵎⴰⵔⵔⴰ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵜⵎⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵎⵉⵡⵉⵏ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴰⴷ ⵉⵃⴻⴼⴼ ⵎⴰⵔⵔⴰ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("LV14_10","004_14_10","LEV","14","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴽⴻⵎⵎⵍⴻⵏ ⴷ ⵉⵛⵜⴻⵏ ⵜⴻⵅⵙⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊⴻⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵣⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ, ⵓ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵓⵍⵓⵅ ⵏ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_11","004_14_11","LEV","14","11","11","ⴰⴽⴻⵀⵀⴰⵏ, ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⵉⵣⴻⴷⴳⴻⵏ, ⴰⴷ ⵢⴰⵔⵔ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV14_12","004_14_12","LEV","14","12","12","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵉⵣⵎⴰⵔ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⴰⴽ-ⴷ ⵓⵍⵓⵅ ⵏ ⵣⵣⴻⵛⵜ, ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_13","004_14_13","LEV","14","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵢⴻⵣⵎⴰⵔ ⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰⵔⵔⵚⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ. ⵎⵉⵏⵣⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵉ ⵜⴻⴵⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LV14_14","004_14_14","LEV","14","14","14","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⴻⵏ ⵉⴳⴳ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓⵍⴰ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_15","004_14_15","LEV","14","15","15","ⴰⵎⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵛⴰ ⵣⴻⴳ ⵓⵍⵓⵅ ⵏ ⵣⵣⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵏⵖⴻⵍ ⵅ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV14_16","004_14_16","LEV","14","16","16","ⴰⴷ ⵉⵙⵙⵓⴼ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴹⴰⴹ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵙ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵔⵓⵛⵛ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵛⵡⴰⵢⵜ ⵣⵉ ⵣⵣⴻⵛⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_17","004_14_17","LEV","14","17","17","ⵓⵛⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⴳⴳ ⵓⴽⴻⵀⵀⴰⵏ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ, ⵓⵍⴰ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ, ⵜⵉⵡⴰ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵅⴰⵙⴻⵏ ⵉⴳⴳⴰ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LV14_18","004_14_18","LEV","14","18","18","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴷⵉ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵉⵏⵖⴻⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜ ⵖⴰ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵓⴽⴻⵀⵀⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_19","004_14_19","LEV","14","19","19","ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵓⴽⴻⵀⵀⴰⵏ ⵅⴻⵏⵏⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV14_20","004_14_20","LEV","14","20","20","ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵜ ⵖⴰ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("LV14_21","004_14_21","LEV","14","21","21","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵥⵍⴻⴹ ⵓⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵡⴻⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵢⵉⵣⵎⴰⵔ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⴰⵎ ⵉⴳⴳⴰ ⵉⵣⵎⴰⵔ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ. ⴰⴷ ⵉⴽⵙⵉ ⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵍⵓⵅ ⵏ ⵣⵣⴻⵛⵜ ");
INSERT INTO rift_vpl VALUES ("LV14_22","004_14_22","LEV","14","22","22","ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⴰⵏⴻⵛⵜ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ. ⵉⵛⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⵜⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV14_23","004_14_23","LEV","14","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵡⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_24","004_14_24","LEV","14","24","24","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵉⵣⵎⴰⵔ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⴷ ⵓⵍⵓⵅ ⵏⵏⵉ ⵏ ⵣⵣⴻⵛⵜ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_25","004_14_25","LEV","14","25","25","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵉⵣⵎⴰⵔ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴽⵙⵉ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓⵍⴰ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_26","004_14_26","LEV","14","26","26","ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵓⴽⴻⵀⵀⴰⵏ ⵛⴰ ⵏ ⵣⵣⴻⵛⵜ ⵅ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴼⵓⵙ ⴰⵥⴻⵍⵎⴰⴹ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV14_27","004_14_27","LEV","14","27","27","ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⴰⴷ ⵉⵔⵓⵛⵛ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵥⴻⵍⵎⴰⴹ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_28","004_14_28","LEV","14","28","28","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴳⴳ ⵛⵡⴰⵢⵜ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵉⵖⴻⵙ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓⵍⴰ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓ ⵅ ⵢⵉⵎⴻⵣ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉⵜ ⵎⴰⵏⵉ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵟ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LV14_29","004_14_29","LEV","14","29","29","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵉⴳⴳ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_30","004_14_30","LEV","14","30","30","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴰⵏⴻⵛⵜ ⵓⵎⵉ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("LV14_31","004_14_31","LEV","14","31","31","ⵣⵉ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV14_32","004_14_32","LEV","14","32","32","ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⵓⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵉ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV14_33","004_14_33","LEV","14","33","33","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV14_34","004_14_34","LEV","14","34","34","“ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵖ ⴷ ⴰⴳⵍⴰ, ⵓⵛⴰ ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⵓⴹⵓⵏ ⵏ ⵍⴱⴰⵔⵚ ⵅ ⵛⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⴷ ⴰⴳⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("LV14_35","004_14_35","LEV","14","35","35","ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ, ⴰⴷ ⵉⵅⴻⴱⴱⴰⵔ ⴰⴽⴻⵀⵀⴰⵏ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ-ⴷⴷ ⴰⵅⵎⵉ ⴷⵉⵏ ⵛⴰ ⵏ ⵡⵓⴹⵓⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("LV14_36","004_14_36","LEV","14","36","36","ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴻⴽⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵅⵡⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⴽⴻⵀⵀⴰⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴻⵎⵎ ⵓⴹⵓⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⵉⵊ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⴽⴻⵀⵀⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⴻⵎⵎⴻⵎ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_37","004_14_37","LEV","14","37","37","ⵎⴰⵍⴰ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵓⴹⵓⵏ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵓⴹⵓⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴱⴰⵏⴻⵏ-ⴷⴷ ⴷⴰⵢⴻⵙ ⵉⵃⵓⴼⴰⵔ ⵣⵣⵉⵣⵡⴻⵏ ⵏⵉⵖ ⵣⴻⵡⵖⴻⵏ, ⵓⴵⵖⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵍⵃⵉⴹ, ");
INSERT INTO rift_vpl VALUES ("LV14_38","004_14_38","LEV","14","38","38","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵓⴽⴻⵀⵀⴰⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵣⵉ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_39","004_14_39","LEV","14","39","39","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵓⴹⵓⵏ ⵉⴱⴻⵣⵣⴻⵄ ⵅ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LV14_40","004_14_40","LEV","14","40","40","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵡⴻⵚⵚⴰ ⵓⴽⴻⵀⵀⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴽⵙⴻⵏ ⵉⵥⵔⴰ ⵎⴰⵏⵉ ⵉⵍⵙⴻⵇ ⵡⵓⴹⵓⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⴻⵎⵊⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_41","004_14_41","LEV","14","41","41","ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵇⴻⵛⵛⴰⵔⴻⵏ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵣⴻⴵⵄⴻⵏ ⴰⴱⴻⴵⴰⵄ ⵉ ⵇⴻⵛⵛⴰⵔⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("LV14_42","004_14_42","LEV","14","42","42","ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵙⵉⵏ ⵉⵥⵔⴰ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵥⵔⴰ ⵏⵏⵉ ⵉⵀⴻⵍⵛⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⵙⵉⵏ ⴰⴱⴻⴵⴰⵄ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵃⴻⵏⵏⵛⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_43","004_14_43","LEV","14","43","43","ⵎⴰⵍⴰ ⵓⴹⵓⵏ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵓⵛⴰ ⵉⵙⵙⴼⵓⴼⴼⵉ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⴽⵙⴻⵏ ⵉⵥⵔⴰ ⵓ ⵇⴻⵛⵛⴰⵔⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵜ ⵃⴻⵏⵏⵛⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LV14_44","004_14_44","LEV","14","44","44","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⵜ ⵉⵇⴻⴵⴻⴱ. ⵎⴰⵍⴰ ⵉⵥⵔⴰ, ⴰⵇⴰ ⵓⴹⵓⵏ ⵉⴱⴻⵣⵣⴻⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⵚ ⵉⵇⴻⵙⵃⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ⴰⵇⴰ-ⵜⵜ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV14_45","004_14_45","LEV","14","45","45","ⴰⴷ ⵀⴻⴷⵎⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵥⵔⴰ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵢⴰ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵔⵉⵙⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵢⴰ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⴷ ⴰⵎⴻⵅⵎⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("LV14_46","004_14_46","LEV","14","46","46","ⵡⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴱⴻⵍⵍⵄⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_47","004_14_47","LEV","14","47","47","ⵡⵉ ⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓ ⵡⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV14_48","004_14_48","LEV","14","48","48","ⵎⴰⵍⴰ ⵢⵓⴷⴻⴼ ⵓⴽⴻⵀⵀⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⵇⴻⴵⴻⴱ ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵇⴰ ⵓⴹⵓⵏ ⵡⴰⵔ ⵉⵎⵖⵉⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵃⴻⵏⵏⵛⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵓⴽⴻⵀⵀⴰⵏ ⴱⴻⵍⵍⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵣⴷⴻⴳ, ⵎⵉⵏⵣⵉ ⵓⴹⵓⵏ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("LV14_49","004_14_49","LEV","14","49","49","ⴰⴷ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴹⴰⴹ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵜⵄⴻⵍⴵⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴽⴽⴻⵙ ⴷⴷⴻⵏⴱ ⵅ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_50","004_14_50","LEV","14","50","50","ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_51","004_14_51","LEV","14","51","51","ⴰⴷ ⵉⴽⵙⵉ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵜⵄⴻⵍⴵⴻⵜ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓⵍⴰ ⴷ ⴰⵊⴹⵉⴹ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓⴼ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵡⴻⵊⴹⵉⴹ ⵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⵏ ⵓ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵔⵓⵛⵛ ⵜⴰⴷⴷⴰⵔⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_52","004_14_52","LEV","14","52","52","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴽⴽⴻⵙ ⴷⴷⴻⵏⴱ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵡⴻⵊⴹⵉⴹ, ⵙ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⵡⴻⵊⴹⵉⴹ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵜⵄⴻⵍⴵⴻⵜ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV14_53","004_14_53","LEV","14","53","53","ⴰⴷ ⵢⴻⵊⵊ ⴰⵊⴹⵉⴹ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵉⴹⵡⴰ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⵉⵣⴷⵉⴳ.” ");
INSERT INTO rift_vpl VALUES ("LV14_54","004_14_54","LEV","14","54","54","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵏ ⵍⴱⴰⵔⵚ ⵓ ⵅ ⵜⴼⵓⵔⵉ ⵏ ⵢⵉⵍⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV14_55","004_14_55","LEV","14","55","55","ⵅ ⵍⴱⴰⵔⵚ ⵏ ⴰⵔⵔⵓⴹ ⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LV14_56","004_14_56","LEV","14","56","56","ⵅ ⵉⵊⵊ ⵏ ⵓⵄⴻⴱⴱⵓⵣ, ⵅ ⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵓ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵏⴳⴰⵣ ⵉⵛⵛⴻⵎⵍⴻⵍ ⵏ ⵜⴻⵍⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV14_57","004_14_57","LEV","14","57","57","ⴰⵣⴻⵔⴼ-ⴰ ⴰⵇⴰ ⵉ ⵜⵖⵓⵔⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵖⴰ ⵢⵉⵍⵉ ⵃⴻⴷ ⵉⵅⵎⴻⵊ ⵏⵉⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵖⴰ ⵢⵉⵍⵉ ⵃⴻⴷ ⵉⵣⴷⴻⴳ. ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵏ ⵍⴱⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("LV15_1","004_15_1","LEV","15","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV15_2","004_15_2","LEV","15","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉⵎ ⴰⵙⴻⵏ: ‘ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵢⴻⵍ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⴻⵢⵢⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LV15_3","004_15_3","LEV","15","3","3","ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ: ⵎⴰⵍⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜᵉⵜⵜⴻⵊⵊⴰ ⴰⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵙⵙⴱⴻⴷⴷⴰ ⴰⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴷ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV15_4","004_15_4","LEV","15","4","4","ⴽⵓⵍ ⵇⴰⵎⴰ ⵎⵉⵏ ⵅⴻⴼ ⵖⴰ ⵉⵟⵟⴻⵚ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵓ ⴽⵓⵍ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵅⴻⴼ ⵖⴰ ⵉⵇⵇⵉⵎ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV15_5","004_15_5","LEV","15","5","5","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵇⴰⵎⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_6","004_15_6","LEV","15","6","6","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵛⴰ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_7","004_15_7","LEV","15","7","7","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵙ ⵡⴰⵎⴰⵏ, ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_8","004_15_8","LEV","15","8","8","ⵎⴰⵍⴰ ⵡⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ ⵉⵙⵙⵓⵙⴻⴼ ⵅ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⴰⴳ, ⴰⵇⴰ ⵡⴰ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_9","004_15_9","LEV","15","9","9","ⴽⵓⵍ ⵜⵔⵉⵛⵜ ⵎⵉⵏ ⵅⴻⴼ ⵉⵇⵇⵉⵎ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV15_10","004_15_10","LEV","15","10","10","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓⵛⴰ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⴽⵙⵉⵏ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_11","004_15_11","LEV","15","11","11","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵃⴰⴷⴰⵏ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵡⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_12","004_15_12","LEV","15","12","12","ⵟⵟⴻⴱⵚⵉ ⵏ ⵜⵍⴰⵅⵜ ⵏⵏⵉ ⵉⵃⴰⴷⴰ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴰⴷ ⵜⵜ ⵙⵉⵔⴷⴻⵏ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV15_13","004_15_13","LEV","15","13","13","ⵅⵎⵉ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵣⴻⴳ ⵓⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵃⵙⴻⴱ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("LV15_14","004_15_14","LEV","15","14","14","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⵉ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV15_15","004_15_15","LEV","15","15","15","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵅ ⵓⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("LV15_16","004_15_16","LEV","15","16","16","“ⵎⴰⵍⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵙⴻⵢⵢⴻⵍ ⵏ ⵡⴰⴵⵓ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_17","004_15_17","LEV","15","17","17","ⴽⵓⵍ ⴰⵔⵔⵓⴹ ⴷ ⴽⵓⵍ ⵉⵍⴻⵎ ⵉ ⵅⴻⴼ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ ⵏ ⵡⴰⴵⵓ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵙⵉⵔⴷⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_18","004_15_18","LEV","15","18","18","ⵎⴰⵍⴰ ⵉⵟⵟⴻⵚ ⵢⵉⵊⵊ ⵡⴻⵔⵢⴰⵣ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("LV15_19","004_15_19","LEV","15","19","19","“ⵎⴰⵍⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵜⵙⴻⵢⵢⴻⵍ, ⴰⵇⴰ ⵅⴰⵙ ⵉⴷⴰⵎⵎⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵄⵣⴻⵍ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_20","004_15_20","LEV","15","20","20","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜᵉⵟⵟⴻⵚ ⴷⴻⴳ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜⴻⵇⵇⵉⵎ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV15_21","004_15_21","LEV","15","21","21","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵇⴰⵎⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_22","004_15_22","LEV","15","22","22","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵛⴰ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵖⵉⵎⴰ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_23","004_15_23","LEV","15","23","23","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵇⵇⵉⵎ ⵅ ⵇⴰⵎⴰ ⵏⵉⵖ ⵅ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵏⴻⵜⵜⴰⵜ, ⵓⵎⵉ ⵉⵃⴰⴷⴰ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_24","004_15_24","LEV","15","24","24","ⵎⴰⵍⴰ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵅⴰⵙ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴽⵓⵍ ⵇⴰⵎⴰ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵟⵟⴻⵚ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV15_25","004_15_25","LEV","15","25","25","ⵎⴰⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⵉⵊⴰⵍ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ ⵏⵉⵖ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵙⴻⵢⵢⴻⵍ ⴽⵜⴰⵔ ⵅ ⵍⵎⵉⵊⴰⵍ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵓⵙⴻⵢⵢⴻⵍ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ, ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV15_26","004_15_26","LEV","15","26","26","ⴽⵓⵍ ⵇⴰⵎⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜᵉⵟⵟⴻⵚ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵓⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵜⵉⵍⵉ ⴰⵎ ⵇⴰⵎⴰ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵇⵇⵉⵎ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ ⴰⵎⴻⵛⵏⴰⵡ ⵍⴻⵅⵎⴻⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV15_27","004_15_27","LEV","15","27","27","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LV15_28","004_15_28","LEV","15","28","28","ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵣⴻⴳ ⵓⵙⴻⵢⵢⴻⵍ ⵏⵏⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵃⵙⴻⴱ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵣⴷⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("LV15_29","004_15_29","LEV","15","29","29","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵜⴻⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴰⵡⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV15_30","004_15_30","LEV","15","30","30","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵙⴻⵢⵢⴻⵍ ⵏ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV15_31","004_15_31","LEV","15","31","31","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵄⴻⵣⵍⴻⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵍⴻⵅⵎⴻⵊ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜᵉⵎⴻⵜⵜⵉⵏ ⴷⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵙⴻⵏ, ⵓⵎⵉ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉⵏⵓ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV15_32","004_15_32","LEV","15","32","32","ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ ⵓ ⵉ ⵡⴻⵏⵏⵉ ⵣⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵡⴰⴵⵓ ⵏⵏⴻⵙ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ");
INSERT INTO rift_vpl VALUES ("LV15_33","004_15_33","LEV","15","33","33","ⵓ ⵄⴰⵡⴻⴷ ⵉ ⵜⴻⵏⵏⵉ ⵎⵉⵏ ⵅⴻⴼ ⵉⴵⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵄⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵄⴰⵡⴻⴷ ⵉ ⵡⵉ ⴷⵉ ⵜⵓⵖⴰ ⴰⵙⴻⵢⵢⴻⵍ, ⵉ ⵡⴻⵔⵢⴰⵣ ⵓⵍⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ, ⵓ ⵄⴰⵡⴻⴷ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉ ⵜⵓⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("LV16_1","004_16_1","LEV","16","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV16_2","004_16_2","LEV","16","2","2","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵎⵓⵙⴰ: “ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴻⴼ ⵍⴻⴱⴷⴰ ⵖⴰⵔ ⵓⵇⴻⴷⴷⴰⵙ ⴷⴰⵅⴻⵍ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵣⵣⴰⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵜⴰⴱⵓⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵜⵜⴱⴰⵏⴻⵖ-ⴷⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LV16_3","004_16_3","LEV","16","3","3","ⵙ ⵓⵢⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵓⵇⴻⴷⴷⴰⵙ: ⵙ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV16_4","004_16_4","LEV","16","4","4","ⴰⴷ ⵢⴰⵔⴹ ⵜⵛⴰⵎⵉⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⵓⵛⴰ ⵙⵙⴰⵔⵡⴰⵍ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ⴰⴷ ⵉⴱⵢⴻⵙ ⵜⴰⵃⴻⵣⵣⴰⵎⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⴻⴽⴽⴻⴱ ⴰⵔⴻⵥⵥⴻⵜ ⵏ ⵍⴻⵇⵟⴻⵏ. ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴹ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("LV16_5","004_16_5","LEV","16","5","5","ⴰⴷ ⵉⴽⵙⵉ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵢⴰⵏⴻⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LV16_6","004_16_6","LEV","16","6","6","ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵀⴰⵔⵓⵏ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("LV16_7","004_16_7","LEV","16","7","7","ⴰⴷ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵢⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⴳⴳ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV16_8","004_16_8","LEV","16","8","8","ⴰⴷ ⵉⵏⴹⴰⵔ ⵀⴰⵔⵓⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵢⴰⵏⴻⵏ: ⵉⵛⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵙⵉⴷⵉ ⵓ ⵉⵛⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵉⵖⴰⵢⴹ ⵉⵏⵏⵓⴼⵙⵍⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵄⴰⵣⴰⵣⵉⵍ’. ");
INSERT INTO rift_vpl VALUES ("LV16_9","004_16_9","LEV","16","9","9","ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵀⴰⵔⵓⵏ ⴰⵎⵢⴰⵏ ⵏⵏⵉ ⵅ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("LV16_10","004_16_10","LEV","16","10","10","ⴰⵎⵢⴰⵏ ⵉ ⵅ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵏ ⵉⵖⴰⵢⴹ ⵉⵏⵏⵓⴼⵙⵍⴻⵏ, ⴰⴷ ⵜ ⵉⴳⴳ ⵉⴷⴷⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵉⵙⵙⴻⴽⴽ ⴰⵎ ⵢⵉⵖⴰⵢⴹ ⵉⵏⵏⵓⴼⵙⵍⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LV16_11","004_16_11","LEV","16","11","11","ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵀⴰⵔⵓⵏ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV16_12","004_16_12","LEV","16","12","12","ⴰⴷ ⵉⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵎⴻⵊⵎⴰⵔ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵛⵛⵓⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵙ ⵍⴻⴱⵅⵓⵔ ⴰⵣⴷⴰⴷ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵢⴰⵡⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴷⴰⵅⴻⵍ ⵉ ⵓⵍⴻⵃⵃⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("LV16_13","004_16_13","LEV","16","13","13","ⴰⴷ ⵉⴳⴳ ⵍⴻⴱⵅⵓⵔ ⵅ ⵜⵎⴻⵙⵙⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⵙⴻⵢⵏⵓ ⵏ ⵍⴻⴼⵡⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ ⴰⴷ ⵉⴷⴻⵍ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵉ ⵉⴵⴰⵏ ⵅ ⵛⵛⵀⴰⴷⴻⵜ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LV16_14","004_16_14","LEV","16","14","14","ⴰⴷ ⵉⴽⵙⵉ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵔⵓⵛⵛ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵉⵔⵓⵛⵛ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LV16_15","004_16_15","LEV","16","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵓⵎⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⵡⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ: ⴰⴷ ⵜⴻⵏ ⵉⵔⵓⵛⵛ ⵅ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵓ ⵣⵣⴰⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LV16_16","004_16_16","LEV","16","16","16","ⴰⵎⵎⵓ ⵉ ⵉ ⵖⴰ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵓⵇⴻⴷⴷⴰⵙ ⵉ ⵍⵃⴰⵊⵊⴰⵜ ⵉⵅⴻⵎⵊⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV16_17","004_16_17","LEV","16","17","17","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵄⴰⴷ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ ⴰⵍ ⵖⴰ ⵉⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LV16_18","004_16_18","LEV","16","18","18","ⴰⴷ ⵉⴼⴼⴻⵖ ⴰⵍ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⴰⵙⵍⴰⵃ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⴷ ⵉⴽⵙⵉ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵎⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⵢⴰ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV16_19","004_16_19","LEV","16","19","19","ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴰⴷ ⵅⴰⵙ ⵉⵔⵓⵛⵛ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵓ ⴰⴷ ⵜ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LV16_20","004_16_20","LEV","16","20","20","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵚⵍⴰⵃ ⵏ ⵓⵇⴻⴷⴷⴰⵙ ⴷ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵅⴻⵏⵏⵉ ⴰⵎⵢⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV16_21","004_16_21","LEV","16","21","21","ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⵀⴰⵔⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵎⵢⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵏⵄⴻⵎ ⵀⴰⵔⵓⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵎⵢⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴰⵔⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵎⵢⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⴷⴷⴻⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("LV16_22","004_16_22","LEV","16","22","22","ⵓⵛⴰ ⵉⵖⴰⵢⴹ ⴰⴷ ⵢⴰⵡⵉ ⴰⴽ-ⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵊⵊⵉⵀⴻⵜ ⵜⴻⵅⵍⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⴰⵎⵢⴰⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LV16_23","004_16_23","LEV","16","23","23","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⴷⴻⴼ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⴰⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴹ, ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵇⴻⴷⴷⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⵢⴻⵊⵊ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LV16_24","004_16_24","LEV","16","24","24","ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴼⴻⵖ, ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵏⴻⵙ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("LV16_25","004_16_25","LEV","16","25","25","ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV16_26","004_16_26","LEV","16","26","26","ⵡⵉ ⴷⴷ-ⵉⵙⴻⴽⴽⴻⵏ ⴰⵎⵢⴰⵏ ⴰⵎ ⵓⵎⵢⴰⵏ ⵉⵏⵏⵓⴼⵙⵍⴻⵏ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV16_27","004_16_27","LEV","16","27","27","ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵓⵎⵢⴰⵏ ⵏ ⵟⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵣⵉ ⵜⵜⵡⴰⵙⵙⵉⴷⴼⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ ⴰⵚⵍⴰⵃ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ, ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ ⴷ ⵓⵎⴻⵙⵙⴰⵍ ⵏⵙⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV16_28","004_16_28","LEV","16","28","28","ⵡⵉ ⵜⴻⵏ ⵖⴰ ⵉⵙⵙⵛⴻⵎⴹⴻⵏ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV16_29","004_16_29","LEV","16","29","29","ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ, ⴰⴷ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV16_30","004_16_30","LEV","16","30","30","ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV16_31","004_16_31","LEV","16","31","31","ⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⴰⵔⵔⴰⵃⴻⵜ ⵜⵎⵓⵏ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴰⴷ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LV16_32","004_16_32","LEV","16","32","32","ⴰⴽⴻⵀⵀⴰⵏ, ⵡⴻⵏⵏⵉ ⴷⴻⵀⵏⴻⵏ ⵓ ⵍⴻⵇⵇⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴽⴻⵀⵀⴰⵏ, ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ, ⴰⵔⵔⵓⴹ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV16_33","004_16_33","LEV","16","33","33","ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵅ ⵜⵇⵉⴹⵓⵏⵜ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵄⴰⵡⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵡⴻⴳⵔⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("LV16_34","004_16_34","LEV","16","34","34","ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵅ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ, ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ.” ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV17_1","004_17_1","LEV","17","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV17_2","004_17_2","LEV","17","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ, ⵉⵇⵇⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("LV17_3","004_17_3","LEV","17","3","3","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⵖⴰⵔⵚⴻⵏ ⵉ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉ ⵢⴻⵣⵎⴰⵔ ⵏⵉⵖ ⵉ ⵉⵖⴰⵢⴹ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵜ ⵉⵖⴰⵔⵚⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ, ");
INSERT INTO rift_vpl VALUES ("LV17_4","004_17_4","LEV","17","4","4","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵢⵉⵡⵉ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵖⴰⵔ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵉⴷⴰⵎⵎⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV17_5","004_17_5","LEV","17","5","5","ⵎⴰⵃⴻⵏⴷ, ⵅⵎⵉ ⵖⴰ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵏⵏⵓⵎⴻⵏ ⵖⴰⵔⵔⵚⴻⵏ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵇⴻⴷⴷⵎⴻⵏ ⴷⵉⵏ ⴰⵎ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV17_6","004_17_6","LEV","17","6","6","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵣⴻⴵⴻⵄ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⴷⵓⵏⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV17_7","004_17_7","LEV","17","7","7","ⵡⴰⵔ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵄⴰⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵉ ⵉⵎⵓⵢⴰⵏ ⵉⵊⴻⵏⵏⵉⵏ, ⵉⵏⵏⵉ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵎ ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵏⵉⵜⵏⵉ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LV17_8","004_17_8","LEV","17","8","8","ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ ⵄⴰⵡⴻⴷ: ‘ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵛⴰ ⵏ ⵟⴰⵖⴰⵔⵚⵜ ⵉ ⵖⴰⵔⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV17_9","004_17_9","LEV","17","9","9","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ-ⵉ-ⴷⴷ-ⵢⵉⵡⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("LV17_10","004_17_10","LEV","17","10","10","“ⴽⵓⵍ ⵉⵊⵊ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵉⵖ ⵣⴻⴳ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⴳⴳⵉⵏ, ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⵍⴱⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉⵛⵛⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵜ ⵇⴻⴹⵄⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV17_11","004_17_11","LEV","17","11","11","ⵎⵉⵏⵣⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵉⵏⴰ ⵉ ⵖⴰ ⵉⵡⵢⴻⵏ ⴰⵚⵍⴰⵃ ⵉ ⵍⴻⵄⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV17_12","004_17_12","LEV","17","12","12","ⵅ ⵓⵢⴰ ⴰⵇⴰ ⵏⵏⵉⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV17_13","004_17_13","LEV","17","13","13","ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵣⴻⴳ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵢⵎⴰⵔⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ, ⴰⴷ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵙ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LV17_14","004_17_14","LEV","17","14","14","ⵎⵉⵏⵣⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⴽⵓⵍ ⴰⵢⵙⵓⵎ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵉⴳⴳⴰ ⵡⴻⵢⵙⵓⵎ!’, ⵎⵉⵏⵣⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵙⵓⵎ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ. ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰ ⵉⵛⵛⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV17_15","004_17_15","LEV","17","15","15","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵉⵖ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉⵎⴻⵣⵣⵇⴻⵏ, ⵎⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("LV17_16","004_17_16","LEV","17","16","16","ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵓⴹ ⵓ ⵡⴰⵔ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV18_1","004_18_1","LEV","18","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV18_2","004_18_2","LEV","18","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV18_3","004_18_3","LEV","18","3","3","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⴳⴳⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⴳⴳⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵏⴻⴷⵀⴻⵖ, ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV18_4","004_18_4","LEV","18","4","4","ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜⵓⵢⵓⵔⴻⵎ: ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV18_5","004_18_5","LEV","18","5","5","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ: ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵜⴻⵏⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴷⴷⴰⵔ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV18_6","004_18_6","LEV","18","6","6","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵣⵉ ⵔⴰⴵ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵄⴰⵔⵔⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ: ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV18_7","004_18_7","LEV","18","7","7","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⴱⴰⴱⴰⵛ ⴷ ⵍⵄⴰⵔ ⵏ ⵢⴻⵎⵎⴰⵛ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵢⴻⵎⵎⴰⵛ, ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV18_8","004_18_8","LEV","18","8","8","ⵍⵄⴰⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⵡⴰⵔ ⵜ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ. ⴰⵇⴰ-ⵜ ⴷ ⵍⵄⴰⵔ ⵏ ⴱⴰⴱⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_9","004_18_9","LEV","18","9","9","ⵅ ⵍⵄⴰⵔ ⵏ ⵓⵍⵜⵎⴰⵛ, ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⴰⵛ ⵏⵉⵖ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵛ, ⵏⵉⵖ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵉⵖ ⴱⴰⵔⵔⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵇⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LV18_10","004_18_10","LEV","18","10","10","ⵅ ⵍⵄⴰⵔ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵎⵎⵉⵛ ⵏⵉⵖ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⴵⵉⵛ, ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏⵙⴻⵏ ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷ ⵍⵄⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_11","004_18_11","LEV","18","11","11","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ, ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵉ ⴱⴰⴱⴰⵛ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵓⵍⵜⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_12","004_18_12","LEV","18","12","12","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵓⵍⵜⵎⴰⵙ ⵏ ⴱⴰⴱⴰⵛ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵔⴰⴵ ⵏ ⴱⴰⴱⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_13","004_18_13","LEV","18","13","13","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵓⵍⵜⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵔⴰⴵ ⵏ ⵢⴻⵎⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_14","004_18_14","LEV","18","14","14","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵓⵎⴰⵙ ⵏ ⴱⴰⴱⴰⵛ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⴰⴱⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵄⴻⵏⵜⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_15","004_18_15","LEV","18","15","15","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵛ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵛ. ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV18_16","004_18_16","LEV","18","16","16","ⵡⴰⵔ ⵜⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵛ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵄⴰⵔ ⵏ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LV18_17","004_18_17","LEV","18","17","17","ⵡⴰⵔ ⵜⴻⵙⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵍⵄⴰⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵢⴻⴵⵉⵙ. ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵡⵉ ⵛⴰ ⵢⴻⴵⵉⵙ ⵏ ⵎⵎⵉⵙ ⵏⵉⵖ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⴵⵉⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵄⴰⵔⵔⵉⴷ ⵍⵄⴰⵔ ⵏⵏⴻⵙ. ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵔⴰⴵ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵉⴼⴻⵙⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV18_18","004_18_18","LEV","18","18","18","ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⴷ ⵜⴰⵛⵏⴰ ⴰⴽ-ⴷ ⵓⵍⵜⵎⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⵖⴻⵏⵏⴻⴷ ⴰⵎⵎⵓ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵄⴰⵔⵔⵉⴷ ⵍⵄⴰⵔ ⵏⵏⴻⵙ ⴰⵎ ⵄⴰⴷ ⵜⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV18_19","004_18_19","LEV","18","19","19","ⵡⴰⵔ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⴰⴱ ⵛⴰ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵅⵎⵉ ⵖⴰ ⵜⴻⵄⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵄⴰⵔⵔⵉⴷ ⵍⵄⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV18_20","004_18_20","LEV","18","20","20","ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴼⴻⵙⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV18_21","004_18_21","LEV","18","21","21","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵛ ⴰⴷ ⵥⵡⴰⵏ ⵖⴰⵔ ⵎⵓⵍⴰⴽ, ⵡⴰⵔ ⵙⵙⴻⵅⵙⴰⵔⴰ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV18_22","004_18_22","LEV","18","22","22","ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⵚ ⵛⴰ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵜᵉⵟⵟⴻⵚⴻⴷ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LV18_23","004_18_23","LEV","18","23","23","ⵡⴰⵔ ⴼⴻⵙⵙⴻⴷ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⴰⵎ ⵜⴼⴻⵃⵃⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⵙ, ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⵉ ⵣⵣⴰⵜ ⵉ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴼⴻⵙⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⴻⵙ. ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵅⴻⴵⴻⴹ ⵉⴼⴻⵙⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV18_24","004_18_24","LEV","18","24","24","ⵡⴰⵔ ⴼⴻⵙⵙⴷⴻⵎ ⵛⴰ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵎⵉⵏⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵡⴻⵎ, ⵜⵓⵖⴰ ⴼⴻⵙⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LV18_25","004_18_25","LEV","18","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⴼⵙⴻⴷ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵅⴻⴵⵚⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵜⵄⵓⵇⵇ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV18_26","004_18_26","LEV","18","26","26","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV18_27","004_18_27","LEV","18","27","27","ⵎⵉⵏⵣⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⵏⵡⴻⵎ, ⴰⵇⴰ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⴼⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LV18_28","004_18_28","LEV","18","28","28","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵄⵓⵇⵇ ⵓⵎⵉ ⵜⵜ ⵜⴼⴻⵙⵙⴷⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵄⵓⵇⵇ ⵜⴻⵎⵎⵓⵔⵜ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵇⴱⴻⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV18_29","004_18_29","LEV","18","29","29","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ, ⴰⵇⴰ ⵍⴻⵄⵎⵓⵔ ⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⴰⵎⵎⵓ, ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV18_30","004_18_30","LEV","18","30","30","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴹⴻⴼⴼⴰⵔⴻⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵢⵓⵔⵚⵓⴹⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⴳⴳⵉⵏ ⵍⴻⴳⵏⵓⵙ ⵇⴱⴻⵍ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴼⴻⵙⵙⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!’” ");
INSERT INTO rift_vpl VALUES ("LV19_1","004_19_1","LEV","19","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV19_2","004_19_2","LEV","19","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ! ");
INSERT INTO rift_vpl VALUES ("LV19_3","004_19_3","LEV","19","3","3","ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⵢⴻⵎⵎⴰⵙ ⴷ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⴹⴰⵎ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV19_4","004_19_4","LEV","19","4","4","ⵡⴰⵔ ⴷⴷⵉⴽⴽⵯⵉⵍⴻⵎ ⵖⴰⵔ ⵍ’ⴰⵚⵏⴰⵎ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV19_5","004_19_5","LEV","19","5","5","ⵅⵎⵉ ⵖⴰ ⵜⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉ ⵣⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵇⴻⴱⵍⴻⵎ ⵙ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LV19_6","004_19_6","LEV","19","6","6","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏⵡⴻⵎ ⵓⵍⴰ ⴷⵉ ⵜⵉⵡⴻⵛⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LV19_7","004_19_7","LEV","19","7","7","ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵛⵛ ⵄⴰⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵇⴻⴱⴱⴻⵍ ⵙ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LV19_8","004_19_8","LEV","19","8","8","ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⵅⵙⴰⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV19_9","004_19_9","LEV","19","9","9","ⵎⴰⵍⴰ ⵜⴻⵎⵊⴰⵔⴻⵎ ⵚⵚⴰⴱⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵎⴻⵊⵊⴰⵔ ⵛⴻⴽ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⴰⵍ ⴰⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵉⵖ ⴰⴷ ⵜⵊⴻⵎⵄⴻⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵜⴰⵎⴻⵢⵔⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV19_10","004_19_10","LEV","19","10","10","ⵡⴰⵔ ⵍⴻⵇⵇⴻⴹ ⵓⴹⵉⵍ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⵃⵔⵓⵡ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ. ⴰⴷ ⵜⴻⵊⵊⴻⴷ ⴰⵢⴰ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV19_11","004_19_11","LEV","19","11","11","ⵡⴰⵔ ⵜⵜⴰⵛⴰⵔ ⵓ ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵛⵎⴻⵜ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV19_12","004_19_12","LEV","19","12","12","ⵡⴰⵔ ⵜⵜⵊⴰⴵⴰⵎ ⵥⵓⵔ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ⵡⴰⵔ ⵙⵙⴻⵅⵙⴰⵔⴰ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV19_13","004_19_13","LEV","19","13","13","ⵡⴰⵔ ⵙⵙⵃⵉⵙⵙⵉⴼ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵏⵉⵖ ⴰⴷ ⵜ ⵜⴰⵛⴰⵔⴻⴷ. ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⴼ ⵍⵎⵓⵏⴻⵜ ⵏ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ ⵣⵉ ⴵⵉⵍⴻⵜ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ.    ");
INSERT INTO rift_vpl VALUES ("LV19_14","004_19_14","LEV","19","14","14","ⵡⴰⵔ ⵜⵜⴻⴽⴽⵯⴰⵔ ⴰⴷⴻⵀⵛⵓⵔ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵎⵉⵏ ⴷⵉ ⵖⴰ ⵉⵏⵇⴰⵔⴻⴹ ⵓⴷⴰⵔⵖⴰⵍ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV19_15","004_19_15","LEV","19","15","15","ⵖⴰⵔ ⵡⴻⵃⴽⴰⵎ ⵡⴰⵔ ⵜⵜⵖⴻⵛⵛⵉⵎ. ⵡⴰⵔ ⵙⵄⵉⵣⵣⵉ ⴰⵎⴻⵣⵍⵓⴹ ⵓ ⵡⴰⵔ ⵙⵄⴻⴷⴷⵓ ⵖⴰⵔ ⴱⵓ-ⵜⵅⵓⴱⴰ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵙ ⵓⵙⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LV19_16","004_19_16","LEV","19","16","16","ⵡⴰⵔ ⴳⴳⵓⵔ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵓⵏⴻⵎⵎⴻⵎ, ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV19_17","004_19_17","LEV","19","17","17","ⵡⴰⵔ ⵛⴰⵔⵔⴻⵀ ⵓⵎⴰⵛ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ⴰⴷ ⵜⵄⴻⵍⵎⴻⴷ ⴰⵄⵍⴰⵎ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜⴽⴻⵙⵙⵉⴷ ⴷⴷⴻⵏⴱ ⵅⴰⴽ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV19_18","004_19_18","LEV","19","18","18","ⵡⴰⵔ ⵜⵜⴻⵏⵜⵉⵇⵉⵎ ⵏⵉⵖ ⴰⴷ ⵜⵅⴻⵎⵎⵍⴻⴷ ⴰⵏⵜⴰⵇⴻⵎ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV19_19","004_19_19","LEV","19","19","19","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ. ⵡⴰⵔ ⵜⵜⵍⴻⵇⵇⴰⵎ ⵛⴰ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵎⴰⵔⴽⴰ ⵏⵏⴻⵖⵏⵉ. ⵡⴰⵔ ⵣⴰⵔⵔⴻⵄ ⵜⵏⴰⵢⴻⵏ ⵏ ⵎⴰⵔⴽⴰⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵢⴰⵔⵔⴻⴹ ⴰⵔⵔⵓⴹ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵎⴰⵔⴽⴰⵜ ⵏ ⵓⴽⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV19_20","004_19_20","LEV","19","20","20","ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ ⵉⵅⴹⴻⴱ ⵉ-ⵜⵜ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵄⴰⴷ ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏⵉⵖ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵜⵍⴻⵍⵍⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵃⵙⴰⴱ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵃⴰⵔ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LV19_21","004_19_21","LEV","19","21","21","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵙ ⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV19_22","004_19_22","LEV","19","22","22","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵅⴰⵙ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵙ ⵉⵛⴰⵔⵔⵉ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ ⵓⵛⴰ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV19_23","004_19_23","LEV","19","23","23","ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⴹⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵜⴻⵥⵥⵓⵎ ⵄⵍⴰⵎ ⴽⵓⵍ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⵛⵛⴻⵎ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵅⴻⵜⵜⵏⴻⵎ ‘ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏⵏⴻⵙ’, ⵜⴻⵏⵏⵉ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵅⴻⵜⵜⵏⴻⵎ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⵜⴻⵜⵜⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LV19_24","004_19_24","LEV","19","24","24","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷ ⵜⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵜⵇⴻⴷⴷⴻⵙ, ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV19_25","004_19_25","LEV","19","25","25","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⵜⴻⵡⵛⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV19_26","004_19_26","LEV","19","26","26","ⵡⴰⵔ ⵜⵜⴻⵜⵜⴻⵎ ⵛⴰ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴳⴻⵣⵣⵏⴻⵎ ⵏⵉⵖ ⴰⴷ ⵜⵛⴻⵖⵍⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵜⴱⴻⵣⴳⵉⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LV19_27","004_19_27","LEV","19","27","27","ⵡⴰⵔ ⵜⵜⵃⴻⴼⴼⵉⵎ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵜⵜⴹⴻⵢⵢⵉⵄⴻⵎ ⵛⴰ ⵜⵎⴰ ⵏ ⵜⵎⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV19_28","004_19_28","LEV","19","28","28","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵛⴰⵔⴹⴻⵎ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵏⵉⵖ ⴰⴷ ⵜⴰⵔⴻⵛⵎⴻⵎ ⵜⵉⴳⴳⴰⵣ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV19_29","004_19_29","LEV","19","29","29","ⵡⴰⵔ ⵙⴷⴻⴵⵉ ⵢⴻⴵⵉⵛ, ⴰⴷ ⵜⵜ ⵜⴰⵔⵔⴻⴷ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵡⴻⵟⵟⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵛⵛⵓⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV19_30","004_19_30","LEV","19","30","30","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ ⵓⵛⴰ ⴰⴷ ⵜⵡⴻⵇⵇⴰⵔⴻⵎ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV19_31","004_19_31","LEV","19","31","31","ⵡⴰⵔ ⵜⵜⴷⵉⴽⴽⵡⵉⵍⴻⵎ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⵓ ⵖⴰⵔ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴰⵔⴻⵣⵣⴼⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⵅⴻⵎⵊⴻⵎ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV19_32","004_19_32","LEV","19","32","32","ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵛⵓⵡⵡⴰⴼ ⵉⵛⴰⴱ ⵓⵛⴰ ⴰⴷ ⵜⵡⴻⵇⵇⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵏ ⵉⵡⴻⵙⵙⵓⵔⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV19_33","004_19_33","LEV","19","33","33","ⵅⵎⵉ ⴽⵉⴷⴻⴽ ⵖⴰ ⵉⵣⴷⴻⵖ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜ ⵜⵜⴹⴻⴵⵎⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV19_34","004_19_34","LEV","19","34","34","ⴰⴱⴰⵔⵔⴰⵏⵉ, ⵡⴻⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ⴰⴷ ⵜ ⵜⴻⵅⵙⴻⴷ ⴰⵎ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV19_35","004_19_35","LEV","19","35","35","ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉⵎ ⵖⴰⵔ ⵡⴻⵃⴽⴰⵎ ⵡⴰⵔ ⵜⵜⵖⴻⵛⵛⴻⵎ ⵛⴰ ⵙ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵉⵖ ⵏ ⴷⴷⵇⴻⵍ ⵏⵉⵖ ⵙ ⵍⴻⵄⴱⴰⵔ ⵏ ⵎⵉⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV19_36","004_19_36","LEV","19","36","36","ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⵎⵉⵣⴰⵏ ⵏⵉⵛⴰⵏ ⴷ ⵉⵥⵔⴰ ⵏ ⵍⵎⵉⵣⴰⵏ ⵏⵉⵛⴰⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏⵉⵛⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏⵉⵛⴰⵏ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LV19_37","004_19_37","LEV","19","37","37","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⵓⵎⵓⵔ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⵎ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!’” ");
INSERT INTO rift_vpl VALUES ("LV20_1","004_20_1","LEV","20","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV20_2","004_20_2","LEV","20","2","2","“ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵉⵖ ⵣⴻⴳ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵛⵉⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵎⵓⵍⴰⴽ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜ ⵢⴰⵔⵊⴻⵎ.    ");
INSERT INTO rift_vpl VALUES ("LV20_3","004_20_3","LEV","20","3","3","ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⵍⴱⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⵇⴻⴹⵄⴻⵖ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵡⵛⴰ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉ ⵎⵓⵍⴰⴽ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵉⵙⴻⵎ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LV20_4","004_20_4","LEV","20","4","4","ⵎⴰⵍⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵇⵇⵏⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵅⵎⵉ ⵖⴰ ⵉⵡⵛ ⵏⴻⵜⵜⴰ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉ ⵎⵓⵍⴰⴽ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜ ⵏⴻⵇⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LV20_5","004_20_5","LEV","20","5","5","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⵍⴱⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓ ⵅ ⵍⴰⴵ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⵇⴻⴹⵄⴻⵖ ⵣⵉ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵙⴻⴼⵙⴰⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⴷⴷⴻⴽⴽⵡⴰⵍⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵎⵓⵍⴰⴽ.’” ");
INSERT INTO rift_vpl VALUES ("LV20_6","004_20_6","LEV","20","6","6","“ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⵍⴱⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴰⵎ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⵍⴱⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⵇⴻⴹⵄⴻⵖ ⵣⵉ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.”   ");
INSERT INTO rift_vpl VALUES ("LV20_7","004_20_7","LEV","20","7","7","“ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV20_8","004_20_8","LEV","20","8","8","ⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⴻⵎ ⵣⵣⴰⵢⵙⴻⵏⵜ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV20_9","004_20_9","LEV","20","9","9","“ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⵄⵍⴻⵏ ⵅ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵅ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ⵉⵏⵄⴻⵍ ⵅ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵅ ⵢⴻⵎⵎⴰⵙ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV20_10","004_20_10","LEV","20","10","10","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵣⵏⴰ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⵏⵏⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⵣⵏⴰⵏ ⴷ ⵜⴻⵏⵏⵉ ⵉⵣⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV20_11","004_20_11","LEV","20","11","11","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵎ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⴰⵇⴰ ⵉⵙⵙⵄⵓⵔⵔⵉ ⵍⵄⴰⵔ ⵏ ⴱⴰⴱⴰⵙ, ⵅⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("LV20_12","004_20_12","LEV","20","12","12","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵙ, ⵅⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ⴰⵇⴰ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵅⴻⴵⴻⴹ ⵉⴼⴻⵙⴷⴻⵏ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("LV20_13","004_20_13","LEV","20","13","13","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴻⵟⵟⴻⵚ ⵡⴻⵔⵢⴰⵣ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵜⴻⵎⵖⴰⵔ. ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV20_14","004_20_14","LEV","20","14","14","ⵎⴰⵍⴰ ⵉⵎⴻⵍⵛ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵍⴰ ⴷ ⵢⴻⵎⵎⴰⵙ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ⴰⴷ ⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵏⴻⵜⵜⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ ⵙ ⵜⵏⴰⵢⴻⵏ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV20_15","004_20_15","LEV","20","15","15","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵚⵚⵓⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⴻⵏⵖⴻⵎ ⵍⴻⴱⵀⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV20_16","004_20_16","LEV","20","16","16","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵛⴰ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴼⴻⵃⵃⴻⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ ⴷ ⵍⴻⴱⵀⵉⵎⴻⵜ. ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV20_17","004_20_17","LEV","20","17","17","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵟⵟⴻⴼ ⵓⵍⵜⵎⴰⵙ, ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵓⵛⴰ ⵉⵥⵔⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵥⵔⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵙⴻⵏ. ⴰⵇⴰ ⵉⵙⵙⵄⵓⵔⵔⵉ ⵍⵄⴰⵔ ⵏ ⵓⵍⵜⵎⴰⵙ, ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV20_18","004_20_18","LEV","20","18","18","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵅ ⵉⴵⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⵇⴰ ⵉⵙⵙⵄⵓⵔⵔⵉ ⵍⵄⴰⵔ ⵏⵏⴻⵙ, ⵉⵙⵙⵄⵓⵔⵔⵉ ⴰⵏⵓ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⴻⵙⵙⵄⵓⵔⵔⵉ ⴰⵏⵓ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV20_19","004_20_19","LEV","20","19","19","ⵡⴰⵔ ⵙⵄⴰⵔⵔⵉ ⵛⴰ ⵓⵍⵜⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵛ ⵏⵉⵖ ⵓⵍⵜⵎⴰⵙ ⵏ ⴱⴰⴱⴰⵛ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⵉⵙⵙⴼⴻⵟⵟⴰⵃ ⴱⵏⴰⴷⴻⵎ ⵍⵄⴰⵔ ⵏ ⵔⴰⴵ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV20_20","004_20_20","LEV","20","20","20","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵡⴻⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵄⴻⵏⵜⵉⵙ, ⴰⵇⴰ ⵉⵙⵙⵄⵓⵔⵔⵉ ⵍⵄⴰⵔ ⵏ ⵄⴻⵎⵎⵉⵙ, ⴰⴷ ⴰⵔⴱⵓⵏ ⵏⵉⵜⵏⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ⴰⴷ ⵎⵎⵜⴻⵏ ⴱⵍⴰ ⵜⴰⵔⵡⴰ.    ");
INSERT INTO rift_vpl VALUES ("LV20_21","004_20_21","LEV","20","21","21","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵉⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵙ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵄⴻⴷⴷⵉ ⵅ ⵡⴻⵄⵣⴰⵍ ⵏ ⵜⴻⵎⵖⴰⵔⵜ. ⴰⵇⴰ ⵉⵙⵙⵄⵓⵔⵔⵉ ⵍⵄⴰⵔ ⵏ ⵓⵎⴰⵙ. ⴰⴷ ⵉⵍⵉⵏ ⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("LV20_22","004_20_22","LEV","20","22","22","“ⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⴻⵎ ⵜⴻⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵄⵓⵇⵇⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵏⴻⴷⵀⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV20_23","004_20_23","LEV","20","23","23","ⵡⴰⵔ ⴳⴳⵓⵔⴻⵎ ⵅ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵜⵡⴻⵚⵚⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵓ ⵙ ⵓⵢⴰ ⵛⴰⵔⵔⵀⴻⵖ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV20_24","004_20_24","LEV","20","24","24","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ: ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵡⴰⵔⵜⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵜ-ⵉ-ⴷⴷ ⵡⵛⴻⵖ ⴷ ⵍⵡⴰⵔⵜ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("LV20_25","004_20_25","LEV","20","25","25","ⵅ ⵓⵢⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵎⴻⵢⵢⵣⴻⵎ ⵊⴰⵔ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵍⴻⵃⵍⴰⵍ ⴷ ⵢⵉⵏⵏⵉ ⵉⵅⴻⵎⵊⴻⵏ ⵓ ⵊⴰⵔ ⵉⵊⴹⴰⴹ ⵉⵅⴻⵎⵊⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵏ ⵍⴻⵃⵍⴰⵍ. ⵡⴰⵔ ⵙⵙⴻⵅⵙⴰⵔⴰⵎ ⵍⴻⵄⵎⵓⵍ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵉⵖ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵡⴻⵊⴹⵉⴹ ⵏⵉⵖ ⴰⴽ-ⴷ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵃⴰⵔⵔⵎⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⵃⴻⵙⴱⴻⵎ ⴷ ⵍⴻⵅⵎⴻⵊ.” ");
INSERT INTO rift_vpl VALUES ("LV20_26","004_20_26","LEV","20","26","26","“ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵓⵛⴰ ⵏⴻⵛⵛ ⴼⴰⵔⵣⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LV20_27","004_20_27","LEV","20","27","27","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵖⴰⵔⴻⵙ ⴱⵓⵃⴱⴻⵍ ⵏ ⵓⵄⴻⵣⵣⴻⵎ ⵏ ⵉⵎⴻⵜⵜⴰⵏ ⵏⵉⵖ ⵏ ⵜⴳⴻⵣⵣⴰⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵏⵉⵛⴰⵏ. ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⵊⵎⴻⵏ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV21_1","004_21_1","LEV","21","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_2","004_21_2","LEV","21","2","2","ⵎⵖⵉⵔ ⵙ ⵔⴰⴵ ⵏⵏⴻⵙ ⵢⵓⴷⵙⴻⵏ, ⵙ ⵢⴻⵎⵎⴰⵙ ⵏⵉⵖ ⵙ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵙ ⵎⵎⵉⵙ ⵏⵉⵖ ⵙ ⵢⴻⴵⵉⵙ ⵏⵉⵖ ⵙ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_3","004_21_3","LEV","21","3","3","ⵓⵍⴰ ⵙ ⵓⵍⵜⵎⴰⵙ ⵏⵏⵉ ⴷ ⵜⴰⵄⵣⴰⵔⵛⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵍⴰⴵ ⵏⵏⴻⵙ ⵢⵓⴷⵙⴻⵏ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵡⴻⵔⵢⴰⵣ, ⴰⵇⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_4","004_21_4","LEV","21","4","4","ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵡⴰⵔ ⵉⵙⵙⵅⴻⵎⵎⴰⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴰ ⵉⵜⵜⵡⴰⴼ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV21_5","004_21_5","LEV","21","5","5","“ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵛⴰ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵇⵓⵛⵛⴰⵔ ⵅ ⵉⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ⵓ ⵡⴰⵔ ⵜⵜⵃⴻⴼⴼⵉⵏ ⵟⵟⴰⵔⴼ ⵏ ⵜⵎⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵛⴰⵔⵔⴹⴻⵏ ⴰⵛⴰⵔⵔⴻⴹ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV21_6","004_21_6","LEV","21","6","6","ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⴼⴻⵟⵟⵃⴻⵏ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷ ⵏⵉⵜⵏⵉ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵜⵉⵏⵏⵉ ⴷ ⵎⴰⵛⵛⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV21_7","004_21_7","LEV","21","7","7","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵍⴼⴰⵙⴷⴰ ⵏⵉⵖ ⵉⵛⵜⴻⵏ ⵜᵉⵜⵜⵡⴰⵖⵚⴻⴱ. ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴵⴼⴻⵏ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜ ⵜⵜⵉⵡⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_8","004_21_8","LEV","21","8","8","ⴰⴷ ⵜ ⵜⵃⴻⵙⴱⴻⴷ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵡⵉ ⵎⴰⵛⵛⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵛⴻⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV21_9","004_21_9","LEV","21","9","9","“ⵎⴰⵍⴰ ⵢⴻⴵⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵜⴻⵙⵙⴻⴼⴹⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵜⴻⵙⵙⴻⴼⴹⴻⵃ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV21_10","004_21_10","LEV","21","10","10","“ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ, ⵡⴻⵏⵏⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵓⴽⴻⵀⵀⴰⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴹⵍⴻⵇ ⵉ ⵓⵛⵓⵡⵡⴰⴼ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⴷ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_11","004_21_11","LEV","21","11","11","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⵄⴰⴷ ⵙ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_12","004_21_12","LEV","21","12","12","ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵙⵙⴻⵅⵙⴰⵔⴰ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⵅⴰⵙ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV21_13","004_21_13","LEV","21","13","13","ⴰⴷ ⵢⴰⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV21_14","004_21_14","LEV","21","14","14","ⵡⴰⵔ ⵉⵜⵜⵉⵡⵉ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵉⵖ ⵜⴰⵏⴻⴵⴰⴼⵜ ⵏⵉⵖ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴻⵚⴱⴻⵏ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵢⴰⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV21_15","004_21_15","LEV","21","15","15","ⵡⴰⵔ ⵉⵙⵙⴻⵅⵙⴰⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV21_16","004_21_16","LEV","21","16","16","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV21_17","004_21_17","LEV","21","17","17","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵉ: ‘ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ ⵉ ⴷⵉ ⵉⴵⴰ ⵛⴰ ⵏ ⵓⵏⴻⵄⴹⴰⴱ, ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵡⵉ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_18","004_21_18","LEV","21","18","18","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⵉⴱ ⵛⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⵉⴱ, ⵎⴰ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⵉ ⵉⴵⴰ ⵏⵉⵖ ⴷ ⴰⵇⵉⴷⴰⵔ ⵏⵉⵖ ⵙ ⵛⴰ ⵡⴰⵔ ⵉⵃⵍⵉ ⵏⵉⵖ ⵖⴰⵔⴻⵙ ⵚⵚⵉⴼⴻⵜ ⵜⴼⴰⵔⵖ ");
INSERT INTO rift_vpl VALUES ("LV21_19","004_21_19","LEV","21","19","19","ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⴰⵔⵥ ⴰⵙ ⵓⴹⴰⵔ ⵏⵉⵖ ⴰⴼⵓⵙ ");
INSERT INTO rift_vpl VALUES ("LV21_20","004_21_20","LEV","21","20","20","ⵏⵉⵖ ⴱⵓ-ⵜⴻⵄⵔⵓⵔⵜ ⵏⵉⵖ ⵃⴻⴷ ⵢⴰⵍⵡⴻⵙ ⴷⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊ ⵏ ⵜⵜⴻⵊⵊⴰⵍ ⵏⵉⵖ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵟⵟ ⵜⵓⴼⴼ ⵏⵉⵖ ⵙ ⵊⴷⴰⵎ ⵏⵉⵖ ⵙ ⵉⵛⵜ ⵏ ⵛⵛⴰⵎⴻⵜ ⵜⴻⵅⵙⴰⵔ ⵏⵉⵖ ⵙ ⵉⵇⴻⴵⴰⵍⴻⵏ ⵉⴷⴳⴻⴷⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV21_21","004_21_21","LEV","21","21","21","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵛⴰ ⵏ ⵍⵄⵉⴱ, ⴰⴷ ⵉⵔⴻⵃⵃⴻⴳ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⴰⵏⴻⵄⴹⴰⴱ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴼⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV21_22","004_21_22","LEV","21","22","22","ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ, ⴰⵎ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ ⴰⵎ ⵣⵉ ⵎⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV21_23","004_21_23","LEV","21","23","23","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵓⵍⴻⵃⵃⴰⴼ ⵓⵍⴰ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⵉⵏⵣⵉ ⴷⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵓⵏⴻⵄⴹⴰⴱ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵙⵙⴻⵅⵙⴰⵔⴰ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("LV21_24","004_21_24","LEV","21","24","24","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵓ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LV22_1","004_22_1","LEV","22","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV22_2","004_22_2","LEV","22","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵓ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ, ⵎⴰⵍⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ, ⵡⴰⵔ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⴻⵅⵙⴰⵔⴰⵏ ⵉⵙⴻⵎ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV22_3","004_22_3","LEV","22","3","3","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵎⴰⵔⵔⴰ ⴰⵔⵢⴰⵣ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵙⵉⴷⵉ, ⴰⵎ ⵉⵅⵎⴻⵊ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV22_4","004_22_4","LEV","22","4","4","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵀⴰⵔⵓⵏ ⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵍ ⵖⴰ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ. ⵡⴻⵏⵏⵉ ⵉⵃⴰⴷⴰⵏ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵙⵙⵅⴻⵎⵊⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵏⵉⵖ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⵙ ⵓⵙⴻⵢⵢⴻⵍ ⵏ ⵡⴰⴵⵓ, ");
INSERT INTO rift_vpl VALUES ("LV22_5","004_22_5","LEV","22","5","5","ⵏⵉⵖ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵃⴰⴷⴰⵏ ⵛⴰ ⵎⵉⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵉ ⵣⵉ ⵉⴷⵡⴻⵍ ⵉⵅⵎⴻⵊ, ⵏⵉⵖ ⵉⵃⴰⴷⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵣⵉ ⵉⴷⵡⴻⵍ ⵉⵅⵎⴻⵊ ⵙ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵜⴻⵅⵎⵓⵊⵉ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV22_6","004_22_6","LEV","22","6","6","ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉⵃⴰⴷⴰⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏⵉⵖ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⵖⵉⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV22_7","004_22_7","LEV","22","7","7","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴰⴷ ⵢⴻⵛⵛ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV22_8","004_22_8","LEV","22","8","8","ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵉⵖ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉⵎⴻⵣⵣⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV22_9","004_22_9","LEV","22","9","9","ⴰⴷ ⵃⴹⴰⵏ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵏ ⵡⴻⵚⵚⵉⵖ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⴰⵔⴻⴱⴱⵓⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴷⴻⵏⴱ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵎⵎⵜⴻⵏ, ⵅⵎⵉ ⵖⴰ ⵙⵙⵄⵉⴵⵜⴻⵏ ⴰⵢⴰ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV22_10","004_22_10","LEV","22","10","10","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⵎⵄⴻⵣⵣⴻⴱ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓⵍⴰ ⴷ ⴰⵛⴻⵡⵡⴰⵍ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV22_11","004_22_11","LEV","22","11","11","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵉⵙⵖⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵡⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵛⵛ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵉ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV22_12","004_22_12","LEV","22","12","12","ⵎⴰⵍⴰ ⵢⴻⴵⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵜⵜ ⵛⴰ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV22_13","004_22_13","LEV","22","13","13","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵢⴻⴵⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵉⵖ ⵜᵉⵜⵜⵡⴰⴵⴻⴼ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⴰⵎ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵛⵛ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("LV22_14","004_22_14","LEV","22","14","14","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵛⵛⴰ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵓⵡⴻⴷⴷⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⴰⵔⵏⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵔ ⵜⴰⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV22_15","004_22_15","LEV","22","15","15","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵙⵙⴻⵅⵙⴰⵔⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵉⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LV22_16","004_22_16","LEV","22","16","16","ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵙⵙⴰⵔⴱⵓⵏ ⴰⵎⴰⵔⵡⴰⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵢⵉⵍ, ⵓⵎⵉ ⵖⴰ ⵛⵛⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴷ ⵢⴰⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("LV22_17","004_22_17","LEV","22","17","17","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV22_18","004_22_18","LEV","22","18","18","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⴳⴳⵓⵔ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵄⵓⴷ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏⵏⵉ ⵡⵛⵉⵏ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵜⴻⵏⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV22_19","004_22_19","LEV","22","19","19","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⵇⴻⴱⴱⵍⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵡⵜⴻⵎ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⵣⵎⴰⵔⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV22_20","004_22_20","LEV","22","20","20","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵛⴰ ⵏ ⵍⵎⴰⵍ ⴷⴰⵢⴻⵙ ⴰⵏⴻⵄⴹⴰⴱ, ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⴼ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LV22_21","004_22_21","LEV","22","21","21","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵏⵉⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵖⴰⵔⵚⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵉⵖ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼ ⴰⵔⴹⴰ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("LV22_22","004_22_22","LEV","22","22","22","ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⵏⵉⵖ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵔⵥⴻⵏ ⵏⵉⵖ ⵎⵉⵏ ⴷⵉ ⵉⴵⴰⵏ ⵉⵊⵊ ⵏ ⵓⵢⴻⵣⵣⵉⵎ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵏⵉⵖ ⵎⵉⵏ ⴷⵉ ⴵⴰⵏⵜ ⵜⴼⵉⴹⵍⵉⵡⵉⵏ ⵏⵉⵖ ⵊⴷⴰⵎ ⵏⵉⵖ ⵛⵛⴰⵎⴻⵜ ⵜⴻⵅⵙⴰⵔ ⵡⴰⵔ ⵜ-ⵉ-ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴰⴱⴻⵎ ⵛⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵉⵡⵢⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV22_23","004_22_23","LEV","22","23","23","ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵉ ⵉⵇⴻⴱⵃⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵉⵖ ⵜⵓⵇⵓⴹⴻⴹⵜ ⴰⵟⵟⴰⵙ, ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼ ⴰⵔⴹⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("LV22_24","004_22_24","LEV","22","24","24","ⵎⵉⵏ ⵉⴷⴳⴻⴷⴷⴳⴻⵏ, ⵎⵉⵏ ⵉⵍⴻⴱⵣⴻⵏ, ⵎⵉⵏ ⵉⵎⴻⵣⵣⵇⴻⵏ, ⵎⵉⵏ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵡⴰⵔ ⵜ ⵜⵜⵉⵡⵢⴻⵎ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⴰⵢⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV22_25","004_22_25","LEV","22","25","25","ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵎⵉⵙ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵎ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⴷⴰⵢⴻⵙ ⵍⵖⴻⵛⵛ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⵏⵏⴻⵇⵚⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵇⴻⴱⴱⵉⵍ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("LV22_26","004_22_26","LEV","22","26","26","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV22_27","004_22_27","LEV","22","27","27","“ⵅⵎⵉ ⴷⴷ-ⵉⵅⴻⴵⴻⵇ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉⵣⵎⴰⵔ ⵏⵉⵖ ⵉⵖⴰⵢⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵙⴰⴷⵓ ⵃⴻⵟⵟⵓ ⵏ ⵢⴻⵎⵎⴰⵙ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵣⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵉⵚⵍⴻⵃ ⵉ ⵢⴰⵔⴹⴰ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV22_28","004_22_28","LEV","22","28","28","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("LV22_29","004_22_29","LEV","22","29","29","ⵅ ⵎⵉⵏⵏⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ ⵉ ⵙⵉⴷⵉ, ⵇⴻⴷⴷⴻⵎ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵉⵚⴻⵍⵃⴻⵏ ⵉ ⵢⴰⵔⴹⴰ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV22_30","004_22_30","LEV","22","30","30","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ. ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⵊⵊⵉⵎ ⵛⴰ ⴰⵍ ⵚⵚⴱⴻⵃ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV22_31","004_22_31","LEV","22","31","31","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("LV22_32","004_22_32","LEV","22","32","32","ⵡⴰⵔ ⵙⵙⴻⵅⵙⴰⵔⴰⵎ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LV22_33","004_22_33","LEV","22","33","33","ⴷ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⴻⵏⵏⵉⵡ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!’” ");
INSERT INTO rift_vpl VALUES ("LV23_1","004_23_1","LEV","23","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV23_2","004_23_2","LEV","23","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵅ ⵖⴰ ⵜⴱⴰⵔⵔⵃⴻⵎ, ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵓⵏⵉⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵏⵓ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_3","004_23_3","LEV","23","3","3","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵅⴻⴷⵎⴻⵎ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵙⵙⴻⴱⵜ, ⴰⵔⵔⴰⵃⴻⵜ ⵉⵎⵓⵏ, ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵅⴻⴷⴷⵎⴻⵎ. ⴰⵇⴰ ⴷ ⵙⵙⴻⴱⵜ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV23_4","004_23_4","LEV","23","4","4","ⴰⵇⴰ ⴷ ⵉⵏⴰ ⴷ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵓⵏⵉⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴱⴰⵔⵔⵃⴻⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_5","004_23_5","LEV","23","5","5","ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ, ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_6","004_23_6","LEV","23","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏⵏⵉⵜ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵉ ⵙⵉⴷⵉ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_7","004_23_7","LEV","23","7","7","ⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("LV23_8","004_23_8","LEV","23","8","8","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴽⴻⵎⵎⵍⴻⵏ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ.’” ");
INSERT INTO rift_vpl VALUES ("LV23_9","004_23_9","LEV","23","9","9","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV23_10","004_23_10","LEV","23","10","10","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵎⴰⵍⴰ ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵊⴰⵔⴻⵎ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵉⵛⵜ ⵏ ⵜⵇⴻⴱⴱⵉⴹⵜ ⵣⵉ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵏⵡⴻⵎ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_11","004_23_11","LEV","23","11","11","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵜⴰⵇⴻⴱⴱⵉⴹⵜ ⵏⵏⵉ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⴱⵍⴻⵎ ⵙ ⴰⵔⴹⴰ. ⴷⵉ ⵜⵓⴼⴼⵓⵜ ⴰⵡⴰⵔⵏⵉ ⵙⵙⴻⴱⵜ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_12","004_23_12","LEV","23","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⵏⵀⴻⵣⵣⴻⵎ ⵜⴰⵇⴻⴱⴱⵉⴹⵜ, ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_13","004_23_13","LEV","23","13","13","ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⴰⵢ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵓ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⴱⵉⵏⵓ, ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LV23_14","004_23_14","LEV","23","14","14","ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⴰⵖⵔⵓⵎ ⵓⵍⴰ ⴷ ⵜⵉⴷⵔⵉⵏ ⵢⵓⵔⴼⴻⵏ ⵏⵉⵖ ⵜⵉⵣⵉⵣⴰⵡⵉⵏ ⴰⵍ ⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⴷⴷ-ⵜⵉⵡⵢⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵡⴻⵎ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵎⴰⵏⵉ ⵎⴰ ⵜⵣⴻⴷⴷⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV23_15","004_23_15","LEV","23","15","15","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⵃⴻⵙⴱⴻⵎ ⵙ ⵍⵎⴻⵇⵍⵓⴱ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵉ ⵚⵚⴱⴻⵃ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵙⴻⴱⵜ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⴷⴷ-ⵜⵉⵡⵢⴻⵎ ⵜⴰⵇⴻⴱⴱⵉⴹⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵍⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⴽⴻⵎⵎⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_16","004_23_16","LEV","23","16","16","ⴰⴷ ⵜⵃⴻⵙⵙⴱⴻⵎ ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍ ⵜⵓⴼⴼⵓⵜ ⵏ ⵙⵙⴻⴱⵜ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵊⴷⵉⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_17","004_23_17","LEV","23","17","17","ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ. ⴰⴷ ⵉⵍⵉⵏⵜ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⴰⵢ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ, ⴳⴳⵡⵉⵏⵜ ⵙ ⵡⴻⵏⵜⵓⵏ. ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵎⴻⵏⵣⴰ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_18","004_23_18","LEV","23","18","18","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⵎ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ. ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_19","004_23_19","LEV","23","19","19","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LV23_20","004_23_20","LEV","23","20","20","ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⵏ ⵜⴰⵎⴻⵏⵣⵓⵜ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ. ⴰⴷ ⵉⵍⵉⵏ ⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵉ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_21","004_23_21","LEV","23","21","21","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉⵜ ⴰⴷ ⵜⴱⴰⵔⵔⵃⴻⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵣⴻⴷⵖⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV23_22","004_23_22","LEV","23","22","22","ⵅⵎⵉ ⵖⴰ ⵜⴻⵎⵊⴰⵔⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵎⴻⵊⵊⴰⵔ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵟⵟⴰⵔⴼ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵛ, ⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜ ⵜⴽⴻⵙⵙⴻⴷ ⵛⴰ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⵛⵡⴰⵢⵜ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!’” ");
INSERT INTO rift_vpl VALUES ("LV23_23","004_23_23","LEV","23","23","23","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV23_24","004_23_24","LEV","23","24","24","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵙⵙⴻⴱⵜ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⴰⴽ-ⴷ ⵓⵙⵓⴹⵉ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_25","004_23_25","LEV","23","25","25","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ⴰⴷ ⴷⴷ-ⵜⴻⵙⵇⴰⵔⵔⴱⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("LV23_26","004_23_26","LEV","23","26","26","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV23_27","004_23_27","LEV","23","27","27","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵙⵙ ⵏ ⵡⴻⵚⵍⴰⵃ. ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴰⴷ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_28","004_23_28","LEV","23","28","28","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⵙⵙ ⵏ ⵡⴻⵚⵍⴰⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⴽⴻⵏⵏⵉⵡ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV23_29","004_23_29","LEV","23","29","29","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵡⴰⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV23_30","004_23_30","LEV","23","30","30","ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵛⴰ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV23_31","004_23_31","LEV","23","31","31","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵣⴻⴷⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV23_32","004_23_32","LEV","23","32","32","ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵙⵙⴻⴱⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵜⵎⵓⵏ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴰⴷ ⵉⵍⵉⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵃⵚⴰⵔⴻⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵓⵢⵓⵔ, ⴷⵉ ⴵⵉⵍⴻⵜ, ⵣⴻⴳ ⵓⵄⴻⵛⵛⵉ ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ ⵏ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("LV23_33","004_23_33","LEV","23","33","33","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV23_34","004_23_34","LEV","23","34","34","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV23_35","004_23_35","LEV","23","35","35","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵢⵉⵍⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("LV23_36","004_23_36","LEV","23","36","36","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵖⴰⵔ ⵙⵉⴷⵉ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("LV23_37","004_23_37","LEV","23","37","37","ⵜⵉⵏⴰ ⴷ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵜⵉⵏⵏⵉ ⵣⵉ ⵖⴰ ⵜⴱⴰⵔⵔⵃⴻⵎ ⴷ ⵉⵎⵓⵏⵉⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⴽⵓⵍ ⴰⵙⵙ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵡⴰⵙⵙ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("LV23_38","004_23_38","LEV","23","38","38","ⴱⴰⵔⵔⴰ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵍⵡⵓⵄⵓⴷ ⵏⵡⴻⵎ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵉⵏⵏⵉ ⵜᵉⵜⵜⵏⵓⵎⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV23_39","004_23_39","LEV","23","39","39","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵎⵓⵏⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵄⴻⵢⵢⴷⴻⵎ ⵍⵄⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵢⵉⵍⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("LV23_40","004_23_40","LEV","23","40","40","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ: ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏ ⵜⵉⵏⵉ ⴷ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵙ ⵜⴻⴼⵔⴰⵢ ⴰⵟⵟⴰⵙ ⴷ ⵜⵙⴻⴹⵡⵉⵏ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵏⴻⵎⵍⴰⵍⵜ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV23_41","004_23_41","LEV","23","41","41","ⴰⴷ ⵜⵄⴻⵢⵢⴷⴻⵎ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ⴰⴷ ⵜ ⵜⵄⴻⵢⵢⴷⴻⵎ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("LV23_42","004_23_42","LEV","23","42","42","ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LV23_43","004_23_43","LEV","23","43","43","ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!’” ");
INSERT INTO rift_vpl VALUES ("LV23_44","004_23_44","LEV","23","44","44","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV24_1","004_24_1","LEV","24","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV24_2","004_24_2","LEV","24","2","2","“ⵓⵎⵓⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵉ ⵜⴼⴰⵡⵜ ⵣⵣⴻⵛⵜ ⵉⵚⴼⴰⵏ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵣⵣⵉⵜⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⵜⴰⴼⴰⵡⵜ ⵜⴰⵔⴻⵇⵇ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LV24_3","004_24_3","LEV","24","3","3","ⵀⴰⵔⵓⵏ ⴰⴷ ⵜⵜ ⵉⵙⴻⵜⵜⴻⴼ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⴵⵉⵍⴻⵜ ⴰⵍ ⵚⵚⴱⴻⵃ ⵣⵣⴰⵜ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV24_4","004_24_4","LEV","24","4","4","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵙⴻⵜⵜⴻⴼ ⵍⴻⴱⴷⴰ ⵜⵉⴼⵜⵉⵍⵉⵏ ⵏ ⵜⴼⴰⵡⵉⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵍⵇⴻⵏⴷⵉⵍ ⵉⵣⴷⵉⴳⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV24_5","004_24_5","LEV","24","5","5","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵙⵙⴻⵏⴳⴳⵯⴻⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ. ⵉⵛⵜ ⵏ ⵜⴻⵎⵙⴻⵎⵎⴻⵎⵜ ⴰⴷ ⵜⵉⵍⵉ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LV24_6","004_24_6","LEV","24","6","6","ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵜⵜⵉⴼⴻⵏ, ⵙⴻⵜⵜⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵜⵜⵉⴼ ⵅ ⵜⵣⴻⵡⴹⴰ ⵉⵣⴷⵉⴳⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV24_7","004_24_7","LEV","24","7","7","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵅ ⴽⵓⵍ ⴰⵙⴻⵜⵜⵉⴼ ⵊⵊⴰⵡⵉ ⵉⵚⴼⴰⵏ ⵏⵏⵉ ⵖⴰ ⵢⵉⵍⵉ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV24_8","004_24_8","LEV","24","8","8","ⴷⵉ ⴽⵓⵍ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⴷ ⵉⵙⴻⵜⵜⴻⴼ ⴰⵢⴰ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LV24_9","004_24_9","LEV","24","9","9","ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵖⵔⵓⵎ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜ ⵖⴰ ⵉⵛⵛⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ, ⵎⵉⵏⵣⵉ ⵉ ⵏⴻⵜⵜⴰ ⵉ ⵉⴵⴰ ⵓⵢⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("LV24_10","004_24_10","LEV","24","10","10","ⵎⵎⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵉⵙⵔⴰ’ⵉⵍⴻⵛⵜ ⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵚⵔⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⵜⵉⵙⵔⴰ’ⵉⵍⴻⵛⵜ ⵓ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⵔⴰⵢⵉⵍⵉ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV24_11","004_24_11","LEV","24","11","11","ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵉⵙⵔⴰ’ⵉⵍⴻⵛⵜ ⵉⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵓⵛⴰ ⵉⴽⴽⵯⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵎⵓⵙⴰ. ⵢⴻⵎⵎⴰⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵍⵓⵎⵉⵢⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴷⵉⴱⵔⵉ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV24_12","004_24_12","LEV","24","12","12","ⴳⴳⵉⵏ ⴰⴷ ⵅⴰⵙ ⵃⴹⴰⵏ ⴰⵍⴰⵎⵉ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵎⵎⴻⵍ ⵎⵉⵏ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV24_13","004_24_13","LEV","24","13","13","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV24_14","004_24_14","LEV","24","14","14","“ⵙⵓⴼⴼⴻⵖ ⵡⴻⵏⵏⵉ ⵉⵏⴻⵄⵍⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⴰⵔⵊⴻⵎ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⵎ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LV24_15","004_24_15","LEV","24","15","15","ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉ ⵖⴰ ⵉⵏⴻⵄⵍⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵢⴰⵔⴱⵓ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV24_16","004_24_16","LEV","24","16","16","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ!’ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵜ ⵜⴰⵔⵊⴻⵎ. ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵍⴰ ⵉⵜⵜⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵢⵉⵙⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LV24_17","004_24_17","LEV","24","17","17","“ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵖⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵛⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV24_18","004_24_18","LEV","24","18","18","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ, ⴰⴷ ⵢⴰⵔⵔ ⵍⴻⵄⵎⴰⵔ ⵙ ⵍⴻⵄⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV24_19","004_24_19","LEV","24","19","19","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⵙⵢⵉⵣⴻⵎ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ: ");
INSERT INTO rift_vpl VALUES ("LV24_20","004_24_20","LEV","24","20","20","ⵜⴰⵔⴻⵥⵥⵉⵜ ⵙ ⵜⴰⵔⴻⵥⵥⵉⵜ, ⵜⵉⵟⵟ ⵙ ⵜⵉⵟⵟ, ⵜⵉⵖⵎⴻⵙⵜ ⵙ ⵜⴻⵖⵎⴻⵙⵜ. ⴰⵏⴻⵛⵜ ⵉⵙⵙⵢⵉⵣⵣⴻⵎ ⵏⴻⵜⵜⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙ ⵖⴰ ⴳⴳⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LV24_21","004_24_21","LEV","24","21","21","ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ, ⴰⴷ ⵜⵜ ⵢⴰⵔⵔ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV24_22","004_24_22","LEV","24","22","22","ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⵎ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("LV24_23","004_24_23","LEV","24","23","23","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⴻⵄⵄⵍⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵔⴻⵊⵎⴻⵏ. ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV25_1","004_25_1","LEV","25","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV25_2","004_25_2","LEV","25","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⴹⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⴻⵢⵢⴻⵃ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⵊ ⵏ ⵡⴰⵔⴻⵢⵢⴻⵃ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV25_3","004_25_3","LEV","25","3","3","ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵜⵣⴰⵔⵄⴻⴷ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵜⴻⵣⴱⴰⵔⴻⴷ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV25_4","004_25_4","LEV","25","4","4","ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⵊ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵜⵣⴰⵔⵔⵄⴻⴷ ⵛⴰ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜⵣⴻⴱⴱⴰⵔⴻⴷ ⵛⴰ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV25_5","004_25_5","LEV","25","5","5","ⵎⵉⵏ ⴷⴷ-ⵉⵖⴻⵎⵎⵢⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵜ ⵎⴻⵊⵊⴰⵔⴻⵎ ⵓ ⴰⴹⵉⵍ ⵡⴰⵔ ⵜ ⵣⴻⴱⴱⴰⵔⴻⵎ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵛ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵃⵉⴷⵉⵏ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV25_6","004_25_6","LEV","25","6","6","ⵚⵚⴰⴱⴻⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏ ⵙⵙⴻⴱⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⴰⵡⴻⵎ ⵜⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ, ⵉ ⵛⴻⴽ, ⵉ ⵢⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ, ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵉ ⵓⵛⴻⵡⵡⴰⵍ ⵏⵏⴻⵛ ⵓⵍⴰ ⵉ ⵓⵎⵄⴻⵣⵣⴻⴱ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV25_7","004_25_7","LEV","25","7","7","ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵉ ⵍⵎⴰⵍ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("LV25_8","004_25_8","LEV","25","8","8","“ⴰⴷ ⵜⵃⴻⵙⵙⴱⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵙⴻⴱⵄⴰ ⵡⵡⴻⵜ ⵉ-ⵜⵜ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵙⵉⵎⴰⵏⴰⵜ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵎⵓⵏⴻⵏ ⵖⴰⵔ ⵜⴻⵙⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV25_9","004_25_9","LEV","25","9","9","ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ, ⴰⴷ ⵜⴻⵊⵊⴻⴷ ⴰⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴰⴷ ⵉⵜⵜⴻⴽⴽ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵚⵍⴰⵃ ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⴰⴷ ⵉⵜⵜⴻⴽⴽ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV25_10","004_25_10","LEV","25","10","10","ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⵉⵏ. ⴰⴷ ⵜⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵜⵍⴻⵍⵍⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵔⴰⴵ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_11","004_25_11","LEV","25","11","11","ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⵉⵏ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⵡⴰⵔ ⵜⵣⴰⵔⵔⵄⴻⵎ ⵓ ⵡⴰⵔ ⵜⵎⴻⵊⵊⴰⵔⴻⵎ ⵎⵉⵏ ⴷⴷ-ⵉⵖⴻⵎⵎⵢⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ, ⵓ ⵡⴰⵔ ⵜⵣⴻⴱⴱⴰⵔⴻⵎ ⵛⴰ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵃⵉⴷⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LV25_12","004_25_12","LEV","25","12","12","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ! ⴰⵇⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV25_13","004_25_13","LEV","25","13","13","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ-ⴰ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV25_14","004_25_14","LEV","25","14","14","“ⵎⴻⵍⵎⵉ ⵛⴻⴽ ⵖⴰ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ ⵛⴰ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵏⵉⵖ ⵎⴰⵍⴰ ⵜⴻⵙⵖⵉⴷ ⵛⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵖⴻⴱⴱⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LV25_15","004_25_15","LEV","25","15","15","ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⴵⴰ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴰⴷ ⵜⴻⵙⵖⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵣⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵚⵚⴰⴱⴻⵜ ⴰⴷ ⴽⵉⴽ ⵢⴻⴳⴳ ⵜⴰⵎⴻⵏⵣⵉⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LV25_16","004_25_16","LEV","25","16","16","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⵏⵉⴷ ⴷⵉ ⵜⵜⴰⵎⴰⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏⵏⴻⵙ ⵓ ⵎⴰⵍⴰ ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⵄⴰⴷ ⴷⵔⵓⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵇⵚⴻⵎ ⴷⵉ ⵜⵜⴰⵎⴰⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵜⵜ ⵉⵣⵣⴻⵏⵣ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵚⵚⴰⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV25_17","004_25_17","LEV","25","17","17","ⵡⴰⵔ ⵉⵜⵜⵖⴻⴱⴱⵉ ⵃⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("LV25_18","004_25_18","LEV","25","18","18","“ⴹⴼⴰⵔⴻⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵃⴹⴰⵎ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⴻⵎ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⵅⴻⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV25_19","004_25_19","LEV","25","19","19","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⵎ ⴰⵍ ⵖⴰ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV25_20","004_25_20","LEV","25","20","20","ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵏⵏⵉⵎ: ‘ⵎⵉⵏ ⵖⴰ ⵏⴻⵛⵛ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ? ⵅⵣⴰⵔ, ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵣⴰⵔⵔⴻⵄ ⵓ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵙⵙⵎⵓⵏⵉ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵖ!’, ");
INSERT INTO rift_vpl VALUES ("LV25_21","004_25_21","LEV","25","21","21","ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵍⴱⴰⵔⴰⴽⴰ ⵉⵏⵓ ⵃⵉⵎⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵡⵛ ⵔⵖⵉⴵⴻⵜ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV25_22","004_25_22","LEV","25","22","22","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵜⵣⴰⵔⵄⴻⵎ ⵄⴰⵡⴻⴷ. ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵣⵉ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵇⴷⵉⵎⵜ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ. ⴰⵍ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵏ ⵊⴷⵉⴷ, ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵄⴰⴷ ⵣⵉ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵇⴷⵉⵎⵜ.” ");
INSERT INTO rift_vpl VALUES ("LV25_23","004_25_23","LEV","25","23","23","“ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵏⵣⵉ ⵉ ⵍⴻⴱⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ-ⵜⵜ ⵉⵏⵓ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵅⴻⵏⵏⵉ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵄⵣⴰⴱ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LV25_24","004_25_24","LEV","25","24","24","ⵙ ⵓⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔⵡⴻⵎ ⵉⴵⴰⵏ ⴷ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LV25_25","004_25_25","LEV","25","25","25","ⵎⴰⵍⴰ ⵓⵎⴰⵛ ⵉⵥⵍⴻⴹ ⵓⵛⴰ ⵉⵣⵣⴻⵏⵣ ⵛⴰ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵎⴻⴼⴷⵉ ⵏⵏⴻⵙ, ⵍⴰⴵ ⵏⵏⴻⵙ ⵢⵓⴷⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴷⵉ ⵎⵉⵏ ⵉⵣⵣⴻⵏⵣ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_26","004_25_26","LEV","25","26","26","ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵓⵎⴻⴼⴷⵉ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴼ ⵎⵉⵏ ⵉⵛⴼⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴼⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LV25_27","004_25_27","LEV","25","27","27","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵃⵙⴻⴱ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵎⵎⴻⵏⵣ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⵡⴻⵔⵢⴰⵣ ⵓⵎⵉ ⵜⵜ ⵉⵣⵣⴻⵏⵣ ⵓⵛⴰ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_28","004_25_28","LEV","25","28","28","ⵎⴰⵍⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⵢⵓⴼⵉ ⵍⵇⴻⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⴷⴷ-ⵢⴰⵔⵔ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵣⵣⴻⵏⵣ, ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵣⵣⴻⵏⵣ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵖⵉⵏ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LV25_29","004_25_29","LEV","25","29","29","“ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵣⵣⴻⵏⵣ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵎⵉ ⴷⴷ-ⵏⵏⴹⴻⵏ ⵙ ⵡⴻⵖⴱⴰⵔ ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵢⵉⵍⵉ ⵓⴼⴻⴽⴽⵉ ⵏⵏⴻⵙ ⴰⵍ ⴷ ⵉⵄⴷⵓ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵉⴽⵎⴻⵍ ⵣⵉ ⵜⵎⴻⵏⵣⵉⵡⵜ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵜ ⵉⴼⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV25_30","004_25_30","LEV","25","30","30","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴼⴷⵉ ⴷⵉ ⵍⵎⵉⵊⴰⵍ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵅⴻⵏⵏⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵙ ⵡⴻⵖⴱⴰⵔ, ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⴱⴷⴰ ⵉ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵙⵖⵉⵏ, ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("LV25_31","004_25_31","LEV","25","31","31","ⵎⴰⵛⴰ ⵜⵓⴷⵔⵉⵏ ⵏⵏⵉ ⵏ ⵍⴻⴷⵛⵓⵔ ⵉ ⵓⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵏⵏⵉⴹ ⵍⴻⵖⴱⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴷⴰⵏⵉⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴻⵇⵇ ⵏ ⵓⴼⴻⴽⴽⵉ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵢⴻⵢⵢⴰⵔ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("LV25_32","004_25_32","LEV","25","32","32","ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵓⴷⵔⵉⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵍⵃⴻⵇⵇ ⵉ ⵍⴻⴱⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⴼⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LV25_33","004_25_33","LEV","25","33","33","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⴼⴷⴰ ⵉ-ⵜⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵉⵎⵎⴻⵏⵣⴻⵏ ⵉ ⵉⵊⵊⴻⵏ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵎⵉⵏⵣⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LV25_34","004_25_34","LEV","25","34","34","ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵏⵣⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("LV25_35","004_25_35","LEV","25","35","35","“ⵎⴰⵍⴰ ⵓⵎⴰⵛ ⵉⵥⵍⴻⴹ ⵓⵛⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴱⴷⴰⵏ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⴷⵉⵏ ⵖⴰⵔⴻⴽ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵜⵙⴻⵏⵏⴷⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⴻⴷⴷ, ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵉⵖ ⴷ ⴰⵎⵄⴻⵣⵣⴻⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV25_36","004_25_36","LEV","25","36","36","ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⴽⴻⵙⵙⵉⴷ ⴰⵔⵔⵉⴱⴰ ⵓⵍⴰ ⴷ ⴰⵔⴱⴻⵃ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵓⵎⴰⵛ ⵉ ⴷⵉⵏ ⵖⴰⵔⴻⴽ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("LV25_37","004_25_37","LEV","25","37","37","ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵙ ⴰⵔⵔⵉⴱⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛ ⵎⴰⵛⵛⴰ ⵙ ⵡⴰⵔⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("LV25_38","004_25_38","LEV","25","38","38","ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("LV25_39","004_25_39","LEV","25","39","39","“ⵎⴰⵍⴰ ⵓⵎⴰⵛ ⵉⵥⵍⴻⴹ ⴰⵎ ⴽⵉⴽ ⵉⴵⴰ ⵓⵛⴰ ⵉⵎⵎⴻⵏⵣ ⴰⵛ ⵉ ⵛⴻⴽ, ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⴰⴷ ⵉⵅⴷⴻⵎ ⴰⵎ ⵢⵉⵙⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LV25_40","004_25_40","LEV","25","40","40","ⴰⴷ ⴽⵉⴽ ⵉⵣⴷⴻⵖ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵛⴻⵡⵡⴰⵍ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵊⵊ ⵏ ⵓⵎⵄⴻⵣⵣⴻⴱ, ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵅⴷⴻⵎ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("LV25_41","004_25_41","LEV","25","41","41","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⴽ ⵉⴼⴼⴻⵖ, ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵍⴰⴵ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_42","004_25_42","LEV","25","42","42","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵙⴻⵅⴰⵔⵔⴻⵏ ⵉⵏⵓ ⵉⵏⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵏⴻⵛⵛ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵡⴰⵔ ⵜⵜⵎⴻⵏⵣⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵎⴻⵏⵣⴰ ⵉⵊⵊ ⵏ ⵉⵙⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LV25_43","004_25_43","LEV","25","43","43","ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵚⴻⴵⴻⴹ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV25_44","004_25_44","LEV","25","44","44","ⵅ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ ⵏⵉⵖ ⵅ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵖⴰ ⵢⵉⵍⵉⵏ, ⴰⴷ ⵉⵍⵉⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵜⴻⵙⵖⴻⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⴻⵢⵢⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LV25_45","004_25_45","LEV","25","45","45","ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵖⴻⵎ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵎⴻⵄⵣⴰⴱ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⴵⴰⵏ, ⵉⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵊⵊⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⴰⴳⵍⴰ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV25_46","004_25_46","LEV","25","46","46","ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵊⵊⴻⴷ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵡⴻⵎ. ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵔⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵅ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵜⵜⵚⴻⵍⵍⵟⴻⵎ ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("LV25_47","004_25_47","LEV","25","47","47","“ⵎⴰⵍⴰ ⵢⵉⵡⴻⴹ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵉⵖ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵄⴻⵣⵣⴻⴱ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵓⵛⴰ ⵓⵎⴰⵛ ⵉ ⵖⴰⵔⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵉⴷⵡⴻⵍ ⵉⵥⵍⴻⴹ ⵓⵛⴰ ⴰⴷ ⵉⵣⵣⴻⵏⵣ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔⴻⴽ ⵏⵉⵖ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⵉ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⵍⴰⴵ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("LV25_48","004_25_48","LEV","25","48","48","ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ, ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⵉⵣⵣⴻⵏⵣ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⴼⴷⵉ. ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ ⴰⴷ ⵜ ⵉⴼⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV25_49","004_25_49","LEV","25","49","49","ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵄⴻⵎⵎⵉⵙ ⵏⵉⵖ ⵉ ⵎⵎⵉⵙ ⵏ ⵄⴻⵎⵎⵉⵙ ⴰⴷ ⵜ ⵉⴼⴷⵉ ⵏⵉⵖ ⵉⵊⵊⴻⵏ ⵣⵉ ⵔⴰⴵ ⵏⵏⴻⵙ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵢⵓⴷⵙⴻⵏ, ⵣⵉ ⵍⵡⴰⵛⵓⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵉⴼⴷⵉ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵖⴰⵔⴻⵙ ⵙ ⵎⵉⵏ ⵣⵉ, ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⴼⴷⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_50","004_25_50","LEV","25","50","50","ⴰⴷ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵖⵉⵏ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵎⵉⵏ ⴷⵉ ⵉⵣⵣⴻⵏⵣ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵓ ⵜⵜⴰⵎⴰⵏ ⵏ ⵜⵎⴻⵏⵣⵉⵡⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴰⴷ ⵢⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵛⴻⵡⵡⴰⵍ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_51","004_25_51","LEV","25","51","51","ⵎⴰⵍⴰ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵖⴰⵔ ⵣⵣⴰⵜ, ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴷⵉ ⴰⵏⴻⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⵜⴰⵎⴰⵏ ⵙ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵣⵉ ⵉⵜⵜⵡⴰⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LV25_52","004_25_52","LEV","25","52","52","ⵎⴰⵍⴰ ⵄⴰⴷ ⴷⵔⵓⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⵙⴰⴱ ⵓⵛⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV25_53","004_25_53","LEV","25","53","53","ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵡⵡⴰⵍ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵅⴰⵙ ⵚⴻⵍⵍⵟⴻⵏ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LV25_54","004_25_54","LEV","25","54","54","ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴼⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴻⴽⴽ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV25_55","004_25_55","LEV","25","55","55","ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LV26_1","004_26_1","LEV","26","1","1","“ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵍ’ⴰⵚⵏⴰⵎ, ⵡⴰⵔ ⵙⴱⴻⴷⴷⴰⵎ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵍⴰ ⴷ ⵓⵎⴰⵢⴹⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵡⴰⵔ ⵙⵙⵔⵓⵙⴰⵎ ⵍⴻⵅⵢⴰⵍ ⵏ ⵡⴻⵥⵔⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⴱⴻⵏⴷⵇⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LV26_2","004_26_2","LEV","26","2","2","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵇⴰⵔⵔ ⵉⵊⵊ ⵏ ⵓⵡⴻⵇⵇⴰⵔ ⵢⵓⴵⵖⴻⵏ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("LV26_3","004_26_3","LEV","26","3","3","“ⵎⴰⵍⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV26_4","004_26_4","LEV","26","4","4","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⴰⵏⵥⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵉ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵡⵛⴻⵏⵜ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LV26_5","004_26_5","LEV","26","5","5","ⴰⴷ ⵢⵉⵍⵉ ⵓⵙⴰⵔⵡⴻⵜ ⴰⵍ ⴰⵍⵇⴰⴹ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⴰⵍⵇⴰⴹ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵓⵣⴰⵔⵔⴻⵄ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵍ ⵖⴰ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵍⴰⵎⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_6","004_26_6","LEV","26","6","6","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵀⵏⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵍⴰ ⵜᵉⵟⵟⵚⴻⵎ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵙⵙⵉⴳⴳⵯⴷⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵎⵃⵉⵖ ⵍⴻⵡⵃⵓⵛ ⵉⵡⵄⴰⵔⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⵙⵉⴼ ⵡⴰⵔ ⴷⴷ-ⵉⵥⴻⴽⴽⵯⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_7","004_26_7","LEV","26","7","7","ⴰⴷ ⵜⴻⴹⴼⴰⵔⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_8","004_26_8","LEV","26","8","8","ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵎⵢⴰ ⵓⵛⴰ ⵎⵢⴰ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵓⵛⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ.    ");
INSERT INTO rift_vpl VALUES ("LV26_9","004_26_9","LEV","26","9","9","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵊⵊⴻⵖ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⵏⵉⵖ ⵓⵛⴰ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_10","004_26_10","LEV","26","10","10","ⴰⵎ ⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⵄⴰⴷ ⵣⵉ ⵣⵣⴰⴷ ⵏⵏⵉ ⵜⵅⴻⵣⵏⴻⵎ, ⴰⴷ ⵜⴻⴽⴽⵙⴻⵎ ⴷⴻⵖⵢⴰ ⵣⵣⴰⴷ ⴰⵇⴷⵉⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⴰⵎⵛⴰⵏ ⵉ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("LV26_11","004_26_11","LEV","26","11","11","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⵄⵉⴼⴼⵉ ⵛⴰ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LV26_12","004_26_12","LEV","26","12","12","ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LV26_13","004_26_13","LEV","26","13","13","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⵎ ⵄⴰⴷ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⵔⵥⵉⵖ ⵉⵎⵇⴻⴵⴰⴹⴻⵏ ⵏ ⵓⵣⴰⵢⵍⵓ ⵏⵡⴻⵎ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵡⵓⴷⴻⵎ ⵢⵓⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV26_14","004_26_14","LEV","26","14","14","“ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵍⵉⵎ ⵏⵉⵖ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵉⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵚⵚⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("LV26_15","004_26_15","LEV","26","15","15","ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ ⴰⴷ ⵉⵄⵉⴼⴼ ⵣⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ⴰⵍ ⵖⴰ ⵜⴰⵡⴹⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵄⴰⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴰⵔⵥⴻⵎ ⵍⵄⴰⵀⴷ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("LV26_16","004_26_16","LEV","26","16","16","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⴰⵢⴰ: ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⴰⵔⵊⴻⴼ ⴷ ⴱⵓ-ⴷⴻⴵⵉⵙ ⴷ ⵜⵎⴻⵙⵙⵉ ⵏ ⴰⵔⵡⴰⵃ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⴻⵃⵃⴰⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵓⵛⴰ ⴰⴷ ⵄⴻⴷⴷⴱⴻⵏ ⵍⴻⵄⵎⴰⵔ. ⴰⴷ ⵜⵣⴰⵔⵄⴻⵎ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ ⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV26_17","004_26_17","LEV","26","17","17","ⴰⴷ ⴳⴳⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵡⴻⵎ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⴻⵅⵙⴰⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⴷ ⵅⴰⵡⴻⵎ ⵚⴻⵍⵍⵟⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ ⴱⵍⴰ ⴰⴷ ⵢⵉⵍⵉ ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵔⴰⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV26_18","004_26_18","LEV","26","18","18","“ⵓ ⵎⴰⵍⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⴷ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⵙⵍⵉⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⴰⵔⵏⵉⵖ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵡⴻⴱⴱⵅⴻⵖ ⵅ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_19","004_26_19","LEV","26","19","19","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵄⴻⴼⴼⴰⵔ ⵏ ⵊⵊⴻⵀⴷ ⵏⵡⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴰⵊⴻⵏⵏⴰ ⵏⵡⴻⵎ ⴰⵎ ⵡⵓⵣⵣⴰⵍ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⴰⵎ ⵏⵏⵃⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("LV26_20","004_26_20","LEV","26","20","20","ⴰⴷ ⵜⴹⴻⵢⵢⵄⴻⵎ ⵊⵊⴻⵀⴷ ⵏⵡⴻⵎ ⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵛ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵓ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⵜⵉⵛⴻⵏⵜ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV26_21","004_26_21","LEV","26","21","21","ⵎⴰⵍⴰ ⵜⴻⵎⵄⴰⵍⴰⵎ ⴽⵉⴷⵉ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵍⵉⵎ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ ⴰⵏⴻⵛⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_22","004_26_22","LEV","26","22","22","ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵅⴻⴹⴼⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ, ⴰⴷ ⵙⵙⵀⴻⵍⵍⴽⴻⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵇⵚⴻⵏ ⵍⵄⴰⴷⴰⴷ ⵏⵡⴻⵎ, ⴰⵍⴰⵎⵉ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⴷⴷⵎⴰⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV26_23","004_26_23","LEV","26","23","23","“ⵎⴰⵍⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵜⴻⵙⵍⵉⵎ, ⵎⴰⵛⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜⴻⵎⵄⴰⵍⴰⵎ ⴰⴽⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LV26_24","004_26_24","LEV","26","24","24","ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵜⵜⴻⵎⵄⴰⵍⴰⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ ⵅ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_25","004_26_25","LEV","26","25","25","ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⴰⵏⵜⴰⵇⴻⵎ ⵏ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵎ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵡⴻⵎ. ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵟⵟⴰⵄⵓⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍⵍⵎⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴻⵄⴷⵓ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_26","004_26_26","LEV","26","26","26","ⵅⵎⵉ ⵖⴰ ⴰⵔⵥⴻⵖ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵄⴻⵛⵔⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵙⵙⴻⵏⴳⴳⵯⴻⵏⵜ ⴰⵖⵔⵓⵎ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ ⴷ ⵉⵛⵜ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵖⴰ ⵡⴻⵣⵏⴻⵏⵜ ⴰⵖⵔⵓⵎ ⴰⴷ ⵜ ⵉ-ⴷⴷ-ⴰⵔⵔⴻⵏⵜ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜ ⵜⴻⵛⵛⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵊⵉⵡⵉⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_27","004_26_27","LEV","26","27","27","ⵎⴰⵍⴰ ⵄⴰⴷ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜᵉⵜⵜⴻⵙⵍⵉⵎ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴰⴷ ⵜⴻⵎⵄⴰⵍⴰⵎ ⴰⴽⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LV26_28","004_26_28","LEV","26","28","28","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵄⴰⵔⴻⵖ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⴱⵉⵖ, ⵡⴰⵀ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵓⵔⴻⵏ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⴱⵉⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_29","004_26_29","LEV","26","29","29","ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵓⵍⴰ ⴷ ⴰⵢⵙⵓⵎ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜ ⵜⴻⵛⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_30","004_26_30","LEV","26","30","30","ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵍⴻⴳⵄⵓⴷⵉ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴻⵀⵀⴰⴱⴻⵎ ⴷⴷⴱⴰⵢⴻⵃ ⵏⵡⴻⵎ, ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ, ⴰⴷ ⴰⵔⵔⴻⵖ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵡⴻⵎ ⵅ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵡⴻⵎ ⵓⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵄⵉⴼⴼ. ");
INSERT INTO rift_vpl VALUES ("LV26_31","004_26_31","LEV","26","31","31","ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵡⴻⵎ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵛⴻⵎⵎⴻⵖ ⵄⴰⴷ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LV26_32","004_26_32","LEV","26","32","32","ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⵏⵅⴻⵍⵄⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV26_33","004_26_33","LEV","26","33","33","“ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⴽⵙⴻⵖ ⵙⵙⵉⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵡⴻⵎ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵡⴻⵎ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵍⵅⴰⵔⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LV26_34","004_26_34","LEV","26","34","34","ⵅⴻⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵅⴰⵙ ⴰⵔⴹⴰⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵎⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⴻⵢⵢⴻⵃ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴰⴷ ⵜⴻⴳⴳ ⵜⵛⵓⵏⵉ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV26_35","004_26_35","LEV","26","35","35","ⵎⴰⵍⴰ ⵓⵙⵙⴰⵏ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵡⴰⵔⴻⵢⵢⴻⵃ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⴰⵔⴻⵢⵢⵉⵃ ⵛⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵏⵡⴻⵎ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴷⵉⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV26_36","004_26_36","LEV","26","36","36","“ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵍⵃⴻⵙⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴼⴰⵔⴻⵛⵜ ⵉ ⵢⵉⵡⵉ ⵓⵙⴻⵎⵎⵉⴹ ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⴰⵥⵥⴻⵍ ⵓ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴰⵔⴻⴽⴽⵡⴰⵍ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵙⵙⵉⴼ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵉⵥⵥⴻⵍ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LV26_37","004_26_37","LEV","26","37","37","ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵅⵎⵉ ⵥⵔⵉⵏ ⵍⴻⵇⴷⴻⵄ ⵏ ⵢⵉⵊⵊ ⵏ ⵙⵙⵉⴼ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵉⵥⵥⴻⵍ ⵃⴻⴷ. ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LV26_38","004_26_38","LEV","26","38","38","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("LV26_39","004_26_39","LEV","26","39","39","“ⵉⵏⵏⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵉⵙⵍⴰⵡⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ⵓⵍⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⵙⵍⴰⵡⴻⵏ ⵏⵉⵜⵏⵉ ⵊⵎⵉⵄ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV26_40","004_26_40","LEV","26","40","40","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵄⵎⴻⵏ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴷⴰⵔ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵖⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵎⵎⵄⴰⵍⴰⵏ ⴰⴽⵉⴷⵉ ");
INSERT INTO rift_vpl VALUES ("LV26_41","004_26_41","LEV","26","41","41","- ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵎⵎⵄⴰⵍⵉⵖ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⵉⵡⵢⴻⵖ ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵖ ⵓⵍ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵅⵜⵉⵏⴻⵏ ⴰⴷ ⵢⴰⴹⴰⵔ ⵓⵛⴰ ⴰⴷ ⵇⴻⴱⵍⴻⵏ ⵍⴻⵅⵍⴰⵚ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("LV26_42","004_26_42","LEV","26","42","42","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵙⵃⴰⵇ ⵓⵛⴰ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LV26_43","004_26_43","LEV","26","43","43","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⴰⵔⴹⴰⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵙ ⵓⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴰⵔⴱⴻⵜ ⵅⵎⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵣⴻⴷⴷⵖⴻⵏ ⵄⴰⴷ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⴰⴷ ⵇⴻⴱⵍⴻⵏ ⵍⵄⵉⵇⴰⴱ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴹⴰⵔⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓ ⵎⵉⵏⵣⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵉⵄⵉⴼⴼ ⵣⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("LV26_44","004_26_44","LEV","26","44","44","“ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵢⴰ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ: ⵎⴰⵍⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵄⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵟⵟⴰⵔⴻⵖ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵄⵉⴼⴼⵉⵖ ⴰⵍ ⵜⴻⵏ ⵖⴰ ⵜⴻⵃⵃⵉⵖ ⵓ ⴰⴷ ⵎⵃⵉⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵙⴻⵏ ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("LV26_45","004_26_45","LEV","26","45","45","ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⴰⴷ ⵄⴻⵇⵍⴻⵖ ⵅ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵉⵏⵏⵉ ⵏⴻⴷⵀⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵉⵜⵏⵉ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("LV26_46","004_26_46","LEV","26","46","46","ⵜⵉⵏⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵊⴰⵔ ⴰⵙ ⴷ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV27_1","004_27_1","LEV","27","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LV27_2","004_27_2","LEV","27","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ, ⴰⵇⴰ ⵎⴰⵍⴰ ⵉⵅⵙ ⵃⴻⴷ ⴰⴷ ⵉⴳⴳ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏ ⵍⴻⵄⵎⵓⵔ ⵉⵜⵜⵡⴰⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("LV27_3","004_27_3","LEV","27","3","3","ⵎⴰⵍⴰ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⴰⵇⴰ ⴷ ⵍⵇⴻⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⴰⵍ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LV27_4","004_27_4","LEV","27","4","4","ⵎⴰⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("LV27_5","004_27_5","LEV","27","5","5","“ⵓⵛⴰ ⵎⴰⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⵍⵉⵖ ⵣⵉ ⵅⴻⵎⵙⴰ ⴰⵍ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵄⵉⵛⵔⵉⵏ ⵛⵉⵇⵍⵓ ⵓ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("LV27_6","004_27_6","LEV","27","6","6","“ⵎⴰⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵣⴻⴳ ⵢⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⴰⵍ ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵅⴻⵎⵙⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵍⴰⵜⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("LV27_7","004_27_7","LEV","27","7","7","“ⵎⴰⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵙⴻⵜⵜⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵉⵖ ⵙⴻⵏⵏⴻⵊ, ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵢⴰⵣ, ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵛⵉⵇⵍⵓ ⵓ ⵎⴰⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵄⴻⵛⵔⴰ ⵏ ⵛⵉⵇⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("LV27_8","004_27_8","LEV","27","8","8","“ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵥⵍⴻⴹ ⴰⵟⵟⴰⵙ ⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵡⵛ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⴻⴷⴷⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ. ⴰⴷ ⵜ ⵉⵇⴻⴷⴷⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴰⵡⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵜ ⵖⴰ ⵉⵇⴻⴷⴷⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV27_9","004_27_9","LEV","27","9","9","“ⵎⴰⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉ ⵣⵉ ⵖⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰ ⵉⵡⵛ ⵏⴻⵜⵜⴰ ⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LV27_10","004_27_10","LEV","27","10","10","ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉⵍ ⵓ ⵡⴰⵔ ⵉⵅⴻⴵⴻⴼ ⴰⵎⵓⴷⴷⴰⵔ ⵉⵛⵏⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⵇⴻⴱⵃⴻⵏ ⵏⵉⵖ ⴰⵎⵓⴷⴷⴰⵔ ⵉⵇⴻⴱⵃⴻⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⵛⵏⴰⵏ. ⵎⴰⵍⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵜⴰ ⴷ ⵜⴻⵏⵏⵉ ⵉ ⵅ ⵜⵜ ⵉⴱⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵍⵉⵏⵜ ⵇⴻⴷⴷⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LV27_11","004_27_11","LEV","27","11","11","ⵎⴰⵍⴰ ⵜⴻⴵⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵜⴻⵅⵎⴻⵊ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵜ ⵇⴻⴷⴷⵎⴻⵏ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵏⵉ ⴰⴷ ⵜⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LV27_12","004_27_12","LEV","27","12","12","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵇⴻⴷⴷⴰⵔ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵊⴰⵔ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ⵓⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵜ ⵖⴰ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ, ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_13","004_27_13","LEV","27","13","13","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⵄⴰⴷ ⴰⴷ ⵜⵜ ⵉⴼⴷⵉ, ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⵏ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("LV27_14","004_27_14","LEV","27","14","14","“ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵜⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⴻⴷⴷⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵊⴰⵔ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⴷ ⵎⵉⵏ ⵉⵇⴻⴱⵃⴻⵏ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵇⴻⴷⴷⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_15","004_27_15","LEV","27","15","15","ⵎⴰⵍⴰ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⵙ ⴰⴷ ⵉⴼⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⵏ ⵍⵇⵉⵎⴻⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("LV27_16","004_27_16","LEV","27","16","16","“ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ ⵛⴰ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ. ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ ⵏ ⵉⵎⴻⵏⴷⵉ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("LV27_17","004_27_17","LEV","27","17","17","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵍⵇⵉⵎⴻⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵜⴱⴻⴷⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LV27_18","004_27_18","LEV","27","18","18","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⴰⵙ ⵉⵀⵚⴻⴱ ⵍⵇⵉⵎⴻⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵍⵇⵉⵎⴻⵜ ⵇⴻⵍⵍ ⵅ ⵍⵇⵉⵎⴻⵜ ⵜⵎⵓⵏ ⵉ ⵜⵓⵖⴰ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("LV27_19","004_27_19","LEV","27","19","19","ⵎⴰⵍⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵢⵢⴰⵔ, ⵉⵅⵙ ⴰⴷ ⵜ ⵉⴼⴷⵉ ⵏⵉⵛⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⴷⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵅ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("LV27_20","004_27_20","LEV","27","20","20","“ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⴼⴷⵉ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵣⵣⴻⵏⵣ ⵉⵢⵢⴰⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴷⵉ ⵄⴰⴷ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LV27_21","004_27_21","LEV","27","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵢⵢⴰⵔ ⵉⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵇⴰⵄ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴳⵍⴰ ⵏ ⵓⴽⴻⵀⵀⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV27_22","004_27_22","LEV","27","22","22","“ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⵉ ⵉⵙⵖⴰ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵢⴻⵢⵢⴰⵔ ⵏ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LV27_23","004_27_23","LEV","27","23","23","ⵅⴻⵏⵏⵉ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⴰⵙ ⵉⵃⵙⴻⴱ ⵜⵜⴰⵎⴰⵏ ⵏ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷ ⵉⵊⵊ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_24","004_27_24","LEV","27","24","24","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵢⴻⵢⵢⴰⵔ ⵄⴰⵡⴻⴷ ⵉ ⵡⴻⵏⵏⵉ ⵅ ⵜ ⵉⵙⵖⴰ, ⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LV27_25","004_27_25","LEV","27","25","25","ⴰⵇⴻⴷⴷⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⴷ ⵢⵉⵍⵉ ⵛⵉⵇⵍⵓ ⵄⵉⵛⵔⵉⵏ ⵊⵉⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("LV27_26","004_27_26","LEV","27","26","26","“ⵎⴰⵛⴰ ⴰⵎⴻⵏⵣⵓ, ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⵉ ⵙⵉⴷⵉ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴰⵎ ⵓⵎⴻⵏⵣⵓ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ, ⵏⵉⵖ ⴷ ⴰⴼⵓⵏⴰⵙ ⵉ ⵉⴵⴰ ⵏⵉⵖ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ, ⴰⵇⴰ-ⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_27","004_27_27","LEV","27","27","27","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ-ⵜ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉⵅⴻⵎⵊⴻⵏ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⴼⴷⵉ ⵄⵍⴰⵃⵚⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴼⴻⴷⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵣ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("LV27_28","004_27_28","LEV","27","28","28","“ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵙⵉⴷⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵉⵢⵢⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵣ ⵏⵉⵖ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴷⵉ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_29","004_27_29","LEV","27","29","29","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵇⴰⵄ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴷⵉ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LV27_30","004_27_30","LEV","27","30","30","“ⵎⴰⵔⵔⴰ ⵜⵉⵄⵛⵓⵔⴰⵢ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ, ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵇⴻⴷⴷⵙⴻⵏⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_31","004_27_31","LEV","27","31","31","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵅⵙ ⴰⴷ ⵉⴼⴷⵉ ⵛⴰ ⵣⵉ ⵍⴻⵄⵛⵓⵔ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("LV27_32","004_27_32","LEV","27","32","32","ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵄⵛⵓⵔⴰⵢ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵡⵓⴵⵉ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴽⴽⵉⵏ ⵙⴰⴷⵓ ⵓⵣⴻⴵⴰⴹ ⵏ ⵓⵎⴻⴽⵙⴰⵡ, ⴰⴷ ⵢⵉⵍⵉ ⵓⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵉⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LV27_33","004_27_33","LEV","27","33","33","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵢⴰⵔⵣⵓ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵛⵏⴰ ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵜⴻⵃⵍⵉ ⵉ ⵜⴻⴵⴰ, ⵓⵍⴰ ⵡⴰⵔ ⵜ ⵉⵜⵜⴱⴻⴷⴷⵉⵍ ⵛⴰ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵉ-ⵜ, ⵅⴻⵏⵏⵉ ⴰⵎⵓⴷⴷⴰⵔ ⵏⵏⵉ ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵜ ⵉ ⵖⴰ ⵉⴱⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵍⵉⵏ ⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LV27_34","004_27_34","LEV","27","34","34","ⴰⵇⴰ ⵜⵉⵏⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⵉ ⵉ ⵣⵉ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵓ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_1","005_1_1","NUM","1","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ, ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU1_2","005_1_2","NUM","1","2","2","“ⴽⵙⵉⵎ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU1_3","005_1_3","NUM","1","3","3","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⴷ ⵀⴰⵔⵓⵏ ⴰⴷ ⵜⵃⴻⵙⴱⴻⵎ ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU1_4","005_1_4","NUM","1","4","4","ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⴼⵓⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ, ⴰⵔⵢⴰⵣ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU1_5","005_1_5","NUM","1","5","5","ⴰⵇⴰ ⴷ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛⴻⵏ ⴰⴼⵓⵙ: ⵉ ⵔⵓⴱⵉⵏ, ⵉⵍⵉⵚⵓⵔ ⵎⵎⵉⵙ ⵏ ⵛⴰⴷⴰⵢⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_6","005_1_6","NUM","1","6","6","ⵉ ⵛⵉⵎⵄⵓⵏ, ⵛⴰⵍⵓⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵔⵉⵢⵛⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NU1_7","005_1_7","NUM","1","7","7","ⵉ ⵢⴰⵀⵓⴷⴰ, ⵏⴰⵃⵛⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("NU1_8","005_1_8","NUM","1","8","8","ⵉ ⵉⵙⵙⴰⴽⴰⵔ, ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU1_9","005_1_9","NUM","1","9","9","ⵉ ⵣⴰⴱⵓⵍⵓⵏ, ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("NU1_10","005_1_10","NUM","1","10","10","ⵉ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ: ⵉ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵎⵉⵀⵓⴷ, ⵉ ⵎⴰⵏⴰⵙⵙⴰ, ⵊⴰⵎⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵀⵚⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_11","005_1_11","NUM","1","11","11","ⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⴱⵉⴷⴰⵏ ⵎⵎⵉⵙ ⵏ ⵊⵉⴷⵄⵓⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("NU1_12","005_1_12","NUM","1","12","12","ⵉ ⴷⴰⵏ, ⴰⵅⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵛⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NU1_13","005_1_13","NUM","1","13","13","ⵉ ⴰⵛⵉⵔ, ⴼⴰⵊⵄⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴽⵔⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU1_14","005_1_14","NUM","1","14","14","ⵉ ⵊⴰⴷ, ⵉⵍⵉⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵄⵓⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("NU1_15","005_1_15","NUM","1","15","15","ⵉ ⵏⴰⴼⵜⴰⵍⵉ, ⴰⵅⵉⵔⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵏⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU1_16","005_1_16","NUM","1","16","16","ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵏⵉⵜⵏⵉ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU1_17","005_1_17","NUM","1","17","17","ⴽⵙⵉⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵔⴻⵛⵎⴻⵏ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("NU1_18","005_1_18","NUM","1","18","18","ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵊⵊⴷⵉⵔⴰ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("NU1_19","005_1_19","NUM","1","19","19","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⴰⵇⴰ ⵉⵃⵙⴻⴱ ⵉ-ⵜⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_20","005_1_20","NUM","1","20","20","ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_21","005_1_21","NUM","1","21","21","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_22","005_1_22","NUM","1","22","22","ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵄⴰⴷⴰⴷ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_23","005_1_23","NUM","1","23","23","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵙⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_24","005_1_24","NUM","1","24","24","ⴰⵢⵜ ⵏ ⵊⴰⴷ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_25","005_1_25","NUM","1","25","25","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU1_26","005_1_26","NUM","1","26","26","ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_27","005_1_27","NUM","1","27","27","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_28","005_1_28","NUM","1","28","28","ⴰⵢⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵚⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_29","005_1_29","NUM","1","29","29","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_30","005_1_30","NUM","1","30","30","ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_31","005_1_31","NUM","1","31","31","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_32","005_1_32","NUM","1","32","32","ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ: ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_33","005_1_33","NUM","1","33","33","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_34","005_1_34","NUM","1","34","34","ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_35","005_1_35","NUM","1","35","35","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU1_36","005_1_36","NUM","1","36","36","ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_37","005_1_37","NUM","1","37","37","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_38","005_1_38","NUM","1","38","38","ⴰⵢⵜ ⵏ ⴷⴰⵏ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_39","005_1_39","NUM","1","39","39","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ ⵜⵓⵖⴰ ⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_40","005_1_40","NUM","1","40","40","ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_41","005_1_41","NUM","1","41","41","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ ⵜⵓⵖⴰ ⵜⴻⵏ ⴷⵉ ⵡⴰⵃⵉⵜ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_42","005_1_42","NUM","1","42","42","ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ: ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ - ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_43","005_1_43","NUM","1","43","43","ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU1_44","005_1_44","NUM","1","44","44","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵉⵏⵏⵉ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵊⵊⴻⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU1_45","005_1_45","NUM","1","45","45","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ - ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ - ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU1_46","005_1_46","NUM","1","46","46","ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵟⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU1_47","005_1_47","NUM","1","47","47","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵛⴰⵔⵛⴻⵏ ⵛⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⴷⵉ ⵍⴻⵃⵙⴰⴱ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU1_48","005_1_48","NUM","1","48","48","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU1_49","005_1_49","NUM","1","49","49","“ⵎⵖⵉⵔ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ ⵡⴰⵔ ⵜⵜ ⵜⵜᵉⵃⵙⴻⴱ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜ ⵣⴻⵎⵎⵉ ⵛⴰ ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU1_50","005_1_50","NUM","1","50","50","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴰⴽ-ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵎⵉⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("NU1_51","005_1_51","NUM","1","51","51","ⵎⴰⵍⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⵙⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⴰⴷ ⵜⵜ ⵀⴻⴷⵎⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⵉⵡⴻⴹ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵀ ⴰⵏⴻⴹⴼⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵄⴰⵡⴻⴷ. ⵎⴰⵍⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵛⴰ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NU1_52","005_1_52","NUM","1","52","52","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⵄⴻⴵⴰⵏⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU1_53","005_1_53","NUM","1","53","53","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴽⵓⵍ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU1_54","005_1_54","NUM","1","54","54","ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ-ⵜ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_1","005_2_1","NUM","2","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU2_2","005_2_2","NUM","2","2","2","“ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⵄⴻⴵⴰⵏⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵛⵡⴰⵢⵜ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU2_3","005_2_3","NUM","2","3","3","ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵏ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ⵏⴰⵃⵛⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_4","005_2_4","NUM","2","4","4","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_5","005_2_5","NUM","2","5","5","ⵣⵣⴰⵜⴻⵙ ⴰⴷ ⵜⴻⵡⵡⴻⵜ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ. ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵖⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU2_6","005_2_6","NUM","2","6","6","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_7","005_2_7","NUM","2","7","7","ⵅⴻⵏⵏⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ. ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵀⵉⵍⵓⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_8","005_2_8","NUM","2","8","8","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_9","005_2_9","NUM","2","9","9","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⴷⵉ ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵜⵎⴰⵏⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("NU2_10","005_2_10","NUM","2","10","10","ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵜⵉⵍⵉ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵔⵓⴱⵉⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵉⵍⵉⵚⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴷⴰⵢⵢⵓⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_11","005_2_11","NUM","2","11","11","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_12","005_2_12","NUM","2","12","12","ⵣⵣⴰⵜⴻⵙ ⴰⴷ ⵜⴻⵡⵡⴻⵜ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ. ⵛⴰⵍⵓⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵔⵉⵢⵛⴰⴷⴷⴰⵢ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_13","005_2_13","NUM","2","13","13","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵙⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_14","005_2_14","NUM","2","14","14","ⵅⴻⵏⵏⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ. ⵉⵍⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵄⵓⵢⵉⵍ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU2_15","005_2_15","NUM","2","15","15","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_16","005_2_16","NUM","2","16","16","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵔⵓⴱⵉⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵎⵢⴰ ⵓ-ⵡⴰⵃⵉⵜ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_17","005_2_17","NUM","2","17","17","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴼⵙⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵎⵎⵓⵟⵟⵉⵢⴻⵏ ⵄⴰⵡⴻⴷ, ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵄⴻⴵⴰⵏⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_18","005_2_18","NUM","2","18","18","ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⴰⴷ ⵜⵉⵍⵉ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NU2_19","005_2_19","NUM","2","19","19","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_20","005_2_20","NUM","2","20","20","ⵣⵣⴰⵜⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ⵊⴰⵎⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵀⵚⵓⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_21","005_2_21","NUM","2","21","21","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_22","005_2_22","NUM","2","22","22","ⵅⴻⵏⵏⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⴰⴱⵉⴷⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵊⵉⴷⵄⵓⵏⵉ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴽⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_23","005_2_23","NUM","2","23","23","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵟⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_24","005_2_24","NUM","2","24","24","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ-ⴰⵍⴻⴼ ⵓ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_25","005_2_25","NUM","2","25","25","ⵖⴰⵔ ⵛⵛⵎⴰⵍ ⴰⴷ ⵜⵉⵍⵉ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴷⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⴰⵅⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵛⴰⴷⴷⴰⵢ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_26","005_2_26","NUM","2","26","26","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_27","005_2_27","NUM","2","27","27","ⵣⵣⴰⵜⴻⵙ ⴰⴷ ⵜⴻⵡⵡⴻⵜ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ. ⴼⴰⵊⵄⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴽⵔⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("NU2_28","005_2_28","NUM","2","28","28","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵡⴰⵃⵉⵜ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_29","005_2_29","NUM","2","29","29","ⵅⴻⵏⵏⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ⴰⵅⵉⵔⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵏⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("NU2_30","005_2_30","NUM","2","30","30","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_31","005_2_31","NUM","2","31","31","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴷⴰⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵄⴻⴵⴰⵏⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU2_32","005_2_32","NUM","2","32","32","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU2_33","005_2_33","NUM","2","33","33","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵛⴰ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU2_34","005_2_34","NUM","2","34","34","ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵙ ⵓⵙⴻⵜⵜⴻⴼ ⵖⴰⵔ ⵜⵄⴻⴵⴰⵏⵉⵏ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵄⴰⵡⴻⴷ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉⵜⵜⵡⴰⵙⴻⵜⵜⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU3_1","005_3_1","NUM","3","1","1","ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵎⵓⵙⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU3_2","005_3_2","NUM","3","2","2","ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ: ⵏⴰⴷⴰⴱ ⴷ ⴰⵎⴻⵏⵣⵓ, ⵅⴻⵏⵏⵉ ⴰⴱⵉⵀⵓ, ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU3_3","005_3_3","NUM","3","3","3","ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴷⴻⵀⵏⴻⵏ ⵓ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⴰⵎ ⵢⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_4","005_3_4","NUM","3","4","4","ⵎⴰⵛⴰ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ ⵎⵎⵓⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴰⵍⵖⵉⴱⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ. ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⴰⵡ. ⵙ ⵓⵢⴰ ⵜⵓⵖⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_5","005_3_5","NUM","3","5","5","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU3_6","005_3_6","NUM","3","6","6","“ⵙⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ ⵓⵛⴰ ⴻⴳⴳ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_7","005_3_7","NUM","3","7","7","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵍⵀⴰⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("NU3_8","005_3_8","NUM","3","8","8","ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵃⴻⵟⵟⵓ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("NU3_9","005_3_9","NUM","3","9","9","ⵛⴻⴽ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⴰⵇⴰ ⴷ ⵢⵉⵏⴰ ⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU3_10","005_3_10","NUM","3","10","10","ⴰⴷ ⵜⵍⴻⵇⵇⵎⴻⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ. ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU3_11","005_3_11","NUM","3","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU3_12","005_3_12","NUM","3","12","12","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵎⴻⵏⵣⴰ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("NU3_13","005_3_13","NUM","3","13","13","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⴰⵎⴻⵏⵣⵓ ⴰⵇⴰ ⵉⵏⵓ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵡⵜⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⴰⵍ ⵍⵎⴰⵍ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("NU3_14","005_3_14","NUM","3","14","14","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU3_15","005_3_15","NUM","3","15","15","“ⵃⵙⴻⴱ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⵙⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU3_16","005_3_16","NUM","3","16","16","ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵃⵙⴻⴱ ⵉ-ⵜⴻⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵡⴻⵚⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("NU3_17","005_3_17","NUM","3","17","17","ⵜⵓⵖⴰ ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴰⴽ-ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵊⴰⵔⵛⵓⵏ, ⴷ ⵇⴰⵀⴰⵜ ⴷ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_18","005_3_18","NUM","3","18","18","ⵜⵓⵖⴰ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵍⵉⴱⵏⵉ ⴷ ⵛⵉⵎⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_19","005_3_19","NUM","3","19","19","ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵄⴰⵎⵔⴰⵎ ⴷ ⵢⵉⵚⵀⴰⵔ ⴷ ⵃⴰⴱⵔⵓⵏ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU3_20","005_3_20","NUM","3","20","20","ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵎⴰⵃⵍⵉ ⴷ ⵎⵓⵛⵉ. ⵜⵓⵖⴰ ⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_21","005_3_21","NUM","3","21","21","ⵖⴰⵔ ⵊⴰⵔⵛⵓⵏ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵍⴰⴵ ⵏ ⵉⵍⵉⴱⵏⵉⵢⵢⴻⵏ ⴷ ⵍⴰⴵ ⵏ ⵉⵛⵉⵎⵄⵉⵢⵢⴻⵏ. ⵜⵓⵖⴰ ⵜⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵊⴰⵔⵛⵓⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_22","005_3_22","NUM","3","22","22","ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⴰⵇⴰ ⵍⵇⴻⴷⴷ ⵏⵏⵉ ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴷⵉ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU3_23","005_3_23","NUM","3","23","23","ⵡⵜⵉⵏⵜ ⵍⴰⴵⴰⵜ ⵏ ⵉⵊⴰⵔⵛⵓⵏⵉⵢⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⵍⵖⴰⵔⴱ. ");
INSERT INTO rift_vpl VALUES ("NU3_24","005_3_24","NUM","3","24","24","ⵜⵓⵖⴰ ⵉⵍⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵢⵉⵍ, ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵉⵊⴰⵔⵛⵓⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_25","005_3_25","NUM","3","25","25","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵃⴹⴰⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵅ ⵓⵇⵉⴹⵓⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵇⵇⴰⴼⵉⵏ ⵏⵏⴻⵙ, ⵅ ⵡⴰⵔⵡⴰⵇ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU3_26","005_3_26","NUM","3","26","26","ⵅ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⴷ ⵡⴰⵔⵡⴰⵇ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵏⵏⴻⴹ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵓⵄⴰⵍⵟⴰⵔ, ⵓ ⵅ ⵉⴼⵉⵍⴰⵏ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_27","005_3_27","NUM","3","27","27","ⵣⵉ ⵇⴰⵀⴰⵜ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔⵚ-ⴷⴷ ⵍⴰⴵ ⵏ ⵉⵄⴰⵎⵔⴰⵎⵉⵢⵢⴻⵏ ⴷ ⵍⴰⴵ ⵏ ⵉⵚⵀⴰⵔⵉⵢⵢⴻⵏ ⴷ ⵍⴰⴵ ⵏ ⵉⵃⵉⴱⵔⵓⵏⵉⵢⵢⴻⵏ ⴷ ⵍⴰⴵ ⵏ ⵉⵄⴰⵣⵉⵢⵉⵍⵉⵢⵢⴻⵏ. ⵜⵓⵖⴰ ⵜⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_28","005_3_28","NUM","3","28","28","ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ ⵜⴻⵎⵏ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ. ⵏⵉⵜⵏⵉ ⵃⴹⴰⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_29","005_3_29","NUM","3","29","29","ⵡⵜⵉⵏⵜ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("NU3_30","005_3_30","NUM","3","30","30","ⵉⵍⵉⵚⴰⴼⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉⵢⵉⵍ, ⵜⵓⵖⴰ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵇⵓⵀⴰⵜⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_31","005_3_31","NUM","3","31","31","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵃⴻⵟⵟⴰⵏ ⵅ ⵜⵜⴰⴱⵓⵜ ⴷ ⵜⵣⴻⵡⴹⴰ ⴷ ⵍⵇⴻⵏⴷⵉⵍ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵓ ⵅ ⵍⴻⵇⵛⵓⵄ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵙⵅⴻⴷⵎⴻⵏ ⵓ ⵅ ⵓⵍⴻⵃⵃⴰⴼ, ⵡⴰⵀ, ⵅ ⵎⴰⵔⵔⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_32","005_3_32","NUM","3","32","32","ⵜⵓⵖⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ, ⴷ ⵍⵃⴰⴽⴻⵎ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵇⴰⵄ ⵅ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴰⵡⵉ. ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_33","005_3_33","NUM","3","33","33","ⵣⵉ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵎⴰⵃⵍⵉⵢⵢⴻⵏ ⴷ ⵍⴰⴵ ⵏ ⵉⵎⵓⵛⵉⵢⵢⴻⵏ. ⵜⵓⵖⴰ ⵜⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_34","005_3_34","NUM","3","34","34","ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⴷⵉ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_35","005_3_35","NUM","3","35","35","ⵜⵓⵖⴰ ⵙⵓⵔⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵅⴰⵢⵉⵍ, ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵔⴰⵔⵉ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("NU3_36","005_3_36","NUM","3","36","36","ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⵜᵉⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵉ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ, ⵉ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ, ⵡⴰⵀ. ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("NU3_37","005_3_37","NUM","3","37","37","ⵓⵍⴰ ⵉ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍⴻⵎⵔⴰⵃ ⴰⴽ-ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⵡⵜⴰⴷ ⵏⵙⴻⵏ ⴷ ⵉⴼⵉⵍⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_38","005_3_38","NUM","3","38","38","ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ⵏⵉⵜⵏⵉ ⵃⴹⴰⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ, ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NU3_39","005_3_39","NUM","3","39","39","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵃⵙⴻⴱ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("NU3_40","005_3_40","NUM","3","40","40","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵃⵙⴻⴱ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⵡⴻⵜⵎⴰⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⵓⵛⴰ ⴽⵙⵉ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_41","005_3_41","NUM","3","41","41","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵏⴻⵛⵛ - ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ! - ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵊⴰⵔ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU3_42","005_3_42","NUM","3","42","42","ⵓⵛⴰ ⵉⵃⵙⴻⴱ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_43","005_3_43","NUM","3","43","43","ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_44","005_3_44","NUM","3","44","44","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU3_45","005_3_45","NUM","3","45","45","“ⴽⵙⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵓ. ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU3_46","005_3_46","NUM","3","46","46","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⵡⴰⴼⴷⵉⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏ ⵉⵎⴻⵏⵣⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("NU3_47","005_3_47","NUM","3","47","47","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵅⴻⵎⵙⴰ ⵛⵉⵇⵍⵓ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⵉⴼ. ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⴷ ⴰⵏⴻⵛⵜ ⵏ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵛⵉⵇⵍⵓ ⵡⴰⵏⵉⵜⴰ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵄⵉⵛⵔⵉⵏ ⵊⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU3_48","005_3_48","NUM","3","48","48","ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜⵜ ⵉ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵇⴻⴷⴷ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU3_49","005_3_49","NUM","3","49","49","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴷⵉⵏ ⵙ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_50","005_3_50","NUM","3","50","50","ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵣⴻⴳ ⵉⵎⴻⵏⵣⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU3_51","005_3_51","NUM","3","51","51","ⵓ ⵎⵓⵙⴰ ⵉⵡⵛⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU4_1","005_4_1","NUM","4","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU4_2","005_4_2","NUM","4","2","2","“ⵃⵙⴻⴱ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU4_3","005_4_3","NUM","4","3","3","ⵣⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ ⴰⵍ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU4_4","005_4_4","NUM","4","4","4","ⴷ ⵜⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ: ⴰⵃⴻⵟⵟⵓ ⵅ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU4_5","005_4_5","NUM","4","5","5","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴼⴻⵙⵢⴻⵏ ⵍⵎⴰⵔⴳⴻⵃ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵏ ⴰⵍⴻⵃⵃⴰⴼ ⵉ ⵉⴵⴰⵏ ⵉ ⴷⴷⵓⵔⵉ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵙⴷⵓⵔⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_6","005_4_6","NUM","4","6","6","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⴰⵙ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵎⴰⵔⵔⴰ ⴷ ⴰⴷⴻⵃⵎⵉ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_7","005_4_7","NUM","4","7","7","ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵟ ⵜⴰⴷⴻⵃⵎⵉⵜ ⵅ ⵜⵣⴻⵡⴹⴰ ⵉ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⴳⴳⴻⵏ ⵟⵟⴱⴰⵚⵉ, ⵜⵉⵖⴻⵏⵊⴰⵢⵉⵏ ⴷ ⵍⴽⵉⵙⴰⵏ ⴷ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵙ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⴽⴻⴱⴱⴻⵏ. ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⴰⵙ ⵢⵉⵍⵉ ⵡⴻⵖⵔⵓⵎ ⵏ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NU4_8","005_4_8","NUM","4","8","8","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⴰⴷ ⵅⴰⵙ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⴷⵍⴻⵏ ⵄⴰⵡⴻⴷ ⵙ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_9","005_4_9","NUM","4","9","9","ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵙⵉⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵜⴰⴷⴻⵃⵎⴰⵏⵉⵜ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⵍⴻⵏ ⵍⵇⴻⵏⴷⵉⵍ ⵉ ⵜⴼⴰⵡⵜ ⵓⵍⴰ ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ ⵏ ⵜⴻⴼⵜⵉⵍⵜ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵉ ⵣⵣⴻⵛⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU4_10","005_4_10","NUM","4","10","10","ⴰⴷ ⴳⴳⴻⵏ ⵍⵇⴻⵏⴷⵉⵍ-ⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵅ ⴵⵓⵃ ⵏ ⵜⴽⴻⵙⵙⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_11","005_4_11","NUM","4","11","11","ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⴰⴷⴻⵃⵎⴰⵏⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⴷⵍⴻⵏ ⵄⴰⵡⴻⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_12","005_4_12","NUM","4","12","12","ⵓⵛⴰ ⴰⴷ ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵙⵙⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⴰⴷⴻⵃⵎⴰⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⴷⵍⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵢⴰ ⵅ ⴵⵓⵃ ⵏ ⵜⴽⴻⵙⵙⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_13","005_4_13","NUM","4","13","13","ⴰⴷ ⴽⴽⵙⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵜⴰⵔⵊⵓⵡⴰⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_14","005_4_14","NUM","4","14","14","ⴰⴷ ⵅⴰⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵙⵙⵅⴻⴷⵎⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ: ⵜⵉⵎⴻⵊⵎⴰⵔⵉⵏ, ⴼⵓⵔⵛⴰⵢⴰⵜ, ⵉⵖⴻⵏⵊⴰⵢⴻⵏ, ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵣⴰⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⵜⵉⵡⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⵉ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_15","005_4_15","NUM","4","15","15","ⵅⵎⵉ ⵖⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴷⴷⵓⵔⵉ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅⵎⵉ ⵖⴰ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵇⵓⵀⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⵜⵃⵉⴷⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵍⵍⴰ ⴰⴷ ⵎⵎⵜⴻⵏ. ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵇⴰⵀⴰⵜ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU4_16","005_4_16","NUM","4","16","16","ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ, ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵣⵣⴻⵛⵜ ⵉ ⵜⴼⴰⵡⵜ ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⴱⴷⴰ ⴷ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ, ⵡⴰⵀ, ⵀⴰⵔⵓⵏ ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵎⴰⵔⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⵍⴰ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⵅ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU4_17","005_4_17","NUM","4","17","17","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU4_18","005_4_18","NUM","4","18","18","“ⵖⴰⵔⵡⴻⵎ ⴰⴷ ⵜⵇⴻⴹⵄⴻⵎ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_19","005_4_19","NUM","4","19","19","ⴳⴳⴻⵎ ⴽⵉⵙⴻⵏ ⴰⵎⵎⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵏ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⴷⴷⵇⴻⵍ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⴰⵔⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("NU4_20","005_4_20","NUM","4","20","20","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⴷⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⵖⵉⵔ ⵉ ⵢⵉⵛⵜ ⵏ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU4_21","005_4_21","NUM","4","21","21","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU4_22","005_4_22","NUM","4","22","22","“ⵃⵙⴻⴱ ⵄⴰⵡⴻⴷ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_23","005_4_23","NUM","4","23","23","ⴰⴷ ⵜⴻⵏ ⵜⵃⴻⵙⴱⴻⴷ ⵣⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵍ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU4_24","005_4_24","NUM","4","24","24","ⴷ ⵜⴰ ⴷ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷ ⵜⴰⵔⴻⴱⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU4_25","005_4_25","NUM","4","25","25","ⴰⴷ ⴰⵔⴱⵓⵏ ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ: ⵜⴰⵙⴻⵇⵇⴰⴼⵜ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⵇⵇⴰⴼⵜ ⵏⵏⴻⵙ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⴷⴷⴻⵏⴼⵉⵍⴰⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵜⵉⵡⵡⴰ ⵏⵏⴻⵙ, ⴷ ⵡⴰⵔⵡⴰⵇ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU4_26","005_4_26","NUM","4","26","26","ⴷ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⴷ ⴰⵔⵡⴰⵇ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵉⴼⵉⵍⴰⵏ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵚⴻⵏⵏⵄⴻⵏ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_27","005_4_27","NUM","4","27","27","ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵔⴻⴱⴱⵓⵜ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵜⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵛⵏⴻⵎ ⵙ ⵓⵃⴻⵟⵟⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵔⴱⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_28","005_4_28","NUM","4","28","28","ⵜⴰ ⴷ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⵙⵉⵏ ⴰⵎⵏⵓⵙ ⵉ ⵓⵢⴰ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵉⵜⴰⵎⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_29","005_4_29","NUM","4","29","29","ⴰⴷ ⵜⵃⴻⵙⴱⴻⴷ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_30","005_4_30","NUM","4","30","30","ⴰⴷ ⵜⴻⵏ ⵜⵃⴻⵙⴱⴻⴷ ⵣⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵍ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU4_31","005_4_31","NUM","4","31","31","ⴷ ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴷⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ: ⵜⵉⴼⴻⵍⵡⵉⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NU4_32","005_4_32","NUM","4","32","32","ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⴽ-ⴷ ⵜⵢⴰⵔⵙⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⵡⵜⴰⴷ ⵏⵙⴻⵏ ⴷ ⵉⵙⴻⵖⵡⴰⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴷ ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴷⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵙⴻⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ. ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⴱⵓⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏ ⵜⵣⴻⵎⵎⴻⴷ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_33","005_4_33","NUM","4","33","33","ⴷ ⵜⴰ ⴷ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵉⵜⴰⵎⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU4_34","005_4_34","NUM","4","34","34","ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵃⴻⵙⴱⴻⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU4_35","005_4_35","NUM","4","35","35","ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵍ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU4_36","005_4_36","NUM","4","36","36","ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_37","005_4_37","NUM","4","37","37","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵉⵏⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU4_38","005_4_38","NUM","4","38","38","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU4_39","005_4_39","NUM","4","39","39","ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵍ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU4_40","005_4_40","NUM","4","40","40","ⴰⵇⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NU4_41","005_4_41","NUM","4","41","41","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵉⵏⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU4_42","005_4_42","NUM","4","42","42","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU4_43","005_4_43","NUM","4","43","43","ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵍ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU4_44","005_4_44","NUM","4","44","44","ⴰⵇⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵎⵉⵜⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_45","005_4_45","NUM","4","45","45","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵉⵏⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU4_46","005_4_46","NUM","4","46","46","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵉⵏⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU4_47","005_4_47","NUM","4","47","47","ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ ⴰⵍ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵓ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵔⴻⴱⴱⵓⵜ ⵏ ⴷⴷⵇⵓⵍⴰⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU4_48","005_4_48","NUM","4","48","48","ⴰⵇⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵏ-ⴰⵍⴰⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU4_49","005_4_49","NUM","4","49","49","ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⴻⵎ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⴷⴷⵇⴻⵍ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU5_1","005_5_1","NUM","5","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU5_2","005_5_2","NUM","5","2","2","“ⵓⵎⵓⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⴱⴰⵔⵚ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵙⴻⵢⵢⴻⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵅⴻⵎⵊⴻⵏ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU5_3","005_5_3","NUM","5","3","3","ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ, ⴰⵎ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵖ ⵏⴻⵛⵛ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU5_4","005_5_4","NUM","5","4","4","ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵎⵎⵓ. ⵏⵉⵜⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU5_5","005_5_5","NUM","5","5","5","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU5_6","005_5_6","NUM","5","6","6","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵉⴳⴳⵉⵏ ⵛⴰ ⵏ ⴷⴷⴻⵏⴱ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵣⵉ ⵉⵖⴷⴰⵔ ⴷⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU5_7","005_5_7","NUM","5","7","7","ⴰⴷ ⵏⴻⵄⵎⴻⵏ ⵅ ⴷⴷⴻⵏⴱ ⵏⵙⴻⵏ ⵉ ⴳⴳⵉⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴰⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵓ ⴰⴷ ⴰⵙ ⵢⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵜⴻⵅⵎⵓⵙⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵉⵡⵛ ⴰⵢⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵉⵜⵜⵓⵔⵙ ⴰⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("NU5_8","005_5_8","NUM","5","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵎⴻⴼⴷⵉ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵅⴻⴵⴻⵚ ⴰⵎⴰⵔⵡⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵓⵎⴰⵔⵡⴰⵙ, ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵉ ⵙⵉⴷⵉ, ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⴽ-ⴷ ⴷ ⵉⵛⴰⵔⵔⵉ ⵏ ⵡⴻⵚⵍⴰⵃ ⵉ ⵣⵣⴰⵢⴻⵙ ⵜ ⵖⴰ ⵉⵙⵙⴻⵚⵍⴻⵃ.    ");
INSERT INTO rift_vpl VALUES ("NU5_9","005_5_9","NUM","5","9","9","ⴽⵓⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU5_10","005_5_10","NUM","5","10","10","ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵏⴻⵜⵜⴰ, ⵎⵉⵏ ⵎⴰ ⵉ ⵖⴰ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⴻⵜⵜⴰ.’” ");
INSERT INTO rift_vpl VALUES ("NU5_11","005_5_11","NUM","5","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU5_12","005_5_12","NUM","5","12","12","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵎⴰⵍⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵜⴻⴼⴼⴻⵖ ⵓ ⵜⴻⵖⴷⴰⵔ ⵉ-ⵜ, ");
INSERT INTO rift_vpl VALUES ("NU5_13","005_5_13","NUM","5","13","13","ⵓ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⵙⴻⵏ ⵉ-ⵜⵜ, ⵓⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⵓⵛⴰ ⴰⵎⵎⵓ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵅⴰⵙ ⵖⴰ ⵉⵛⴻⵀⴷⴻⵏ ⵓ ⵏⴻⵜⵜⴰⵜ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ, ");
INSERT INTO rift_vpl VALUES ("NU5_14","005_5_14","NUM","5","14","14","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵅⴰⵙ ⴱⵓⵃⴱⴻⵍ ⵏ ⵜⵓⵙⵎⵉ ⵓⵛⴰ ⵢⵓⵙⴻⵎ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ, ⵏⵉⵖ ⵢⵓⵙⴰ-ⴷⴷ ⵅⴰⵙ ⴱⵓⵃⴱⴻⵍ ⵏ ⵜⵓⵙⵎⵉ ⵓⵛⴰ ⵢⵓⵙⴻⵎ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⵉⵊ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("NU5_15","005_5_15","NUM","5","15","15","ⵅⴻⵏⵏⵉ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⵏⴻⵜⵜⴰⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵄⵛⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ⵡⴰⵔ ⵅⴰⵙ ⵉⴼⴰⵔⵔⴻⵖ ⵣⵣⴻⵛⵜ ⵏⵉⵖ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⵊⵊⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵙⵎⵉ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵍⵉⴷⴰⵔⴻⵜ, ⵜⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU5_16","005_5_16","NUM","5","16","16","ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴰⵔⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU5_17","005_5_17","NUM","5","17","17","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵎⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ ⵓⵛⴰ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ ⵣⴻⴳ ⵓⵛⴰⵍ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⴰⴷ ⵢⴻⴳⴳ ⴰⵢⴰ ⴷⴻⴳ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU5_18","005_5_18","NUM","5","18","18","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴼⴻⴽⴽ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵓⵙⵎⵉ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵎⴰⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵏⵏⴻⵄⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU5_19","005_5_19","NUM","5","19","19","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⵜ ⵢⴻⵊⵊ ⴰⴷ ⵜⴻⵊⵊⴰⴵ ⵓⵛⴰ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: ⵎⴰⵍⴰ ⵡⴰⵔ ⴽⵉⵎ ⵉⵟⵟⵉⵚ ⵃⴻⴷ ⵓ ⵡⴰⵔ ⵜⴻⵡⴹⵉⴷ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵎ ⴷⵉ ⵜⴻⵅⵎⵓⵊⵉ, ⴰⵇⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜᵉⵜⵜⵡⴰⵚⴼⵉⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ-ⴰ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵏⵏⴻⵄⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU5_20","005_5_20","NUM","5","20","20","ⵎⴰⵛⴰ ⵓⵛⵜ ⵅⴰⵎ, ⵎⴰⵍⴰ ⵜⴻⵡⴹⵉⴷ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵅⴻⵎⵊⴻⴷ ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵎⵖⵉⵔ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ ⵉⵟⵟⴻⵚ ⴰⴽⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("NU5_21","005_5_21","NUM","5","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴻⵊⵊ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⵊⵊⴰⴵ ⵜⴰⵊⴰⴵⵉⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ. ⴰⴷ ⵢⵉⵏⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⵎ ⵢⴰⵔⵔ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵏⵏⴻⵄⵍⴻⵜ-ⴰ ⴷ ⵜⵊⴰⴵⵉⵜ-ⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ, ⵅⵎⵉ ⵖⴰ ⵢⴻⵊⵊ ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⴹⴰ ⵓⵎⴻⵚⵚⴰⴹ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵔ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵎ ⵢⵓⴼⴼ, ");
INSERT INTO rift_vpl VALUES ("NU5_22","005_5_22","NUM","5","22","22","ⵓⵛⴰ ⴰⵎⴰⵏ-ⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵏⵏⴻⵄⵍⴻⵜ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⵏ ⵏⵏⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵓⴼⴼⴻⵏ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵙⵙⵖⴻⴹⵍⴻⵏ ⴰⵎⴻⵚⵚⴰⴹ ⵏⵏⴻⵎ! ⵓⵛⴰ ⴰⴷ ⵜⵉⵏⵉ ⵜⴻⵎⵖⴰⵔⵜ: ⴰⵎⵉⵏ ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("NU5_23","005_5_23","NUM","5","23","23","ⴰⴷ ⵢⴰⵔⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⵄⴰⵍⵉ-ⵢⴰ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵡⵔⵉⵇⵜ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏⵜ ⵉⵎⵃⴰ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU5_24","005_5_24","NUM","5","24","24","ⴰⴷ ⵉⵡⵛ ⴰⵎⴰⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⵙⵓ ⴰⵍⴰⵎⵉ ⴰⵎⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵏⵏⴻⵄⵍⴻⵜ ⴰⴷ ⴷⴰⵢⴻⵙ ⴰⴷⴼⴻⵏ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU5_25","005_5_25","NUM","5","25","25","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴽⵙⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵓⵙⵎⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU5_26","005_5_26","NUM","5","26","26","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵉⴷⴰⵔⴻⵜ, ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵢⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵡⵛ ⴰⵎⴰⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵜⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("NU5_27","005_5_27","NUM","5","27","27","ⵎⴰⵍⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⵎⴰⵏ ⴰⴷ ⵜⵙⵓ, ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵖⴷⴰⵔ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⴰⵎⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵏⵏⴻⵄⵍⴻⵜ ⴰⴷ ⴷⴰⵢⴻⵙ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ ⵓⵛⴰ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⴰⴷ ⵢⵓⴼⴼ ⵓⵛⴰ ⴰⵎⴻⵚⵚⴰⴹ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵖⴹⴻⵍ ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU5_28","005_5_28","NUM","5","28","28","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵅⵎⵉⵊ ⵛⴰ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵜⴻⵣⴷⴻⴳ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵡⴰⵔ ⵅⴰⵙ ⵛⴰ, ⴰⴷ ⵜⵉⵍⵉ ⵜᵉⵜⵜⴰⵔⵓ.’” ");
INSERT INTO rift_vpl VALUES ("NU5_29","005_5_29","NUM","5","29","29","ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵓⵙⵎⵉ, ⵅⵎⵉ ⵜⴻⵡⴹⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ");
INSERT INTO rift_vpl VALUES ("NU5_30","005_5_30","NUM","5","30","30","ⵏⵉⵖ ⵅⵎⵉ ⴷⴷ ⵢⵓⵙⴰ ⴱⵓⵃⴱⴻⵍ ⵏ ⵜⵓⵙⵎⵉ ⵅ ⵡⴻⵔⵢⴰⵣ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴻⵎ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔⴰ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⴰⵙ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵣⴻⵔⴼ-ⴰ ⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("NU5_31","005_5_31","NUM","5","31","31","ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⴰⴷ ⵜⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU6_1","005_6_1","NUM","6","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU6_2","005_6_2","NUM","6","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵉⵡⴻⵊⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⴰⵡⴰⵍ ⵏ ⵜⵜⴰⵊ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵍⵡⴰⵄⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵄⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵜⵜⴰⵊ ⵏⵏⵉ ⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("NU6_3","005_6_3","NUM","6","3","3","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳⵯⴻⵊ ⵅ ⴱⵉⵏⵓ ⴷ ⵛⵛⵔⴰⴱ. ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⵍⵅⴻⴵ ⵣⵉ ⴱⵉⵏⵓ ⵏⵉⵖ ⵍⵅⴻⴵ ⵣⵉ ⵛⵛⵔⴰⴱ ⵓ ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⴰⵎⴰⵏ ⵏ ⵓⴹⵉⵍ, ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵣⴻⴳ ⵓⴹⵉⵍ ⴰⵣⴻⵢⵣⴰ ⵏⵉⵖ ⵣⴻⴳ ⵓⴹⵉⵍ ⵢⵓⵥⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU6_4","005_6_4","NUM","6","4","4","ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵛⴰ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ, ⵣⴻⴳ ⵓⵄⴻⵇⵇⴰ ⵏⵏⴻⵙ ⴰⵍ ⵜⴰⵇⵛⵓⵔⵜ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("NU6_5","005_6_5","NUM","6","5","5","“ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⴷⴷ ⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽ ⵍⵎⵓⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵍ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵄⵣⴻⵍ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵇⴻⴷⴷⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⴻⵊⵊ ⵉⵄⴻⵢⵢⴰⵛⴻⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⴷ ⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU6_6","005_6_6","NUM","6","6","6","ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵉⵙⵙⵃⵓⵣⵣ ⵉ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⵉⴱ ⵛⴰ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU6_7","005_6_7","NUM","6","7","7","ⵡⴰⵔ ⵉⵙⵙⵅⴻⵎⵎⵉⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵅ ⵢⴻⵎⵎⴰⵙ ⵏⵉⵖ ⵅ ⵓⵎⴰⵙ ⵏⵉⵖ ⵅ ⵓⵍⵜⵎⴰⵙ ⵎⴰⵍⴰ ⴳⴳⵓⵔⴻⵏ ⴰⴷ ⵎⵎⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU6_8","005_6_8","NUM","6","8","8","“ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ ⴰⴷ ⵢⵉⵍⵉ ⵉⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU6_9","005_6_9","NUM","6","9","9","ⵎⴰⵍⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵎⴻⵜⵜⴰⵏ ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⴻⵖⵢⴰ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵙ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵃⴻⴼⴼ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵉⵃⴻⴼⴼ. ");
INSERT INTO rift_vpl VALUES ("NU6_10","005_6_10","NUM","6","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵊⵍⵉⵍⵍⵉⵃⵉⵏ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴱⵉⵔⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU6_11","005_6_11","NUM","6","11","11","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵉⵛⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵚⵍⴻⵃ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵅⴹⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵎⴻⵜⵜⵉⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ");
INSERT INTO rift_vpl VALUES ("NU6_12","005_6_12","NUM","6","12","12","ⵓⵛⴰ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵏⴻⵢⵢⴻⵛ ⵏⴻⵜⵜⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ⵓⵙⵙⴰⵏ ⵉⵄⴷⵓⵏ ⴰⴷ ⵉⵍⵉⵏ ⵡⴹⴰⵏ ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU6_13","005_6_13","NUM","6","13","13","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ: ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU6_14","005_6_14","NUM","6","14","14","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵅⵙⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ");
INSERT INTO rift_vpl VALUES ("NU6_15","005_6_15","NUM","6","15","15","ⴷ ⵉⵛⵜ ⵏ ⵜⵙⵓⴵⴻⵜ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷ ⵍⴻⵎⵙⴻⵎⵏⴰⵜ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴷ ⵜⴻⵍⴼⴰⴼ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵜⵜⵡⴰⴷⴻⵀⵏⴻⵏⵜ ⵙ ⵣⵣⴻⵛⵜ ⵓⵍⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU6_16","005_6_16","NUM","6","16","16","“ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵢⴰⵡⵉ ⵎⴰⵏ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("NU6_17","005_6_17","NUM","6","17","17","ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⴰⵔⵔⵉ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⵜⴰⵙⵓⴵⴻⵜ ⴰⴽ-ⴷ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵄⴰⵡⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU6_18","005_6_18","NUM","6","18","18","“ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⴰⴷ ⵉⵃⴻⴼⴼ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ ⵓⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⴰⵢⴰ ⵅ ⵜⵎⴻⵙⵙⵉ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU6_19","005_6_19","NUM","6","19","19","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴰⵎⴻⵚⵚⴰⴹⵜ ⵏ ⵣⵣⴰⵜ ⵢⴻⵏⴳⴳⵯⴰⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵙⴻⵎⵎⴻⵏⵜ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵣⵉ ⵜⵙⵓⴵⴻⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵍⴼⴻⴼⵜ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵉⵙⵙⴰⵔⵙ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⵉⵃⴻⴼⴼ ⵜⵜⴰⵊ ⵏⵏⴻⵙ ⵏ ⵡⴻⵄⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("NU6_20","005_6_20","NUM","6","20","20","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵜⴻⵏⵜ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⴽ-ⴷ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵓ ⴰⴽ-ⴷ ⵓⵛⴻⴽⵔⵓⴷ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵓ ⴱⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU6_21","005_6_21","NUM","6","21","21","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴰⵄⴷⴻⵏ ⵉ ⵙⵉⴷⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ, ⴱⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵄⴰⴷ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵢⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵉ ⵉⵡⵛⵉⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵣⴻⵔⴼ ⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU6_22","005_6_22","NUM","6","22","22","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU6_23","005_6_23","NUM","6","23","23","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⴰⴷ ⵜⴱⴰⵔⴽⴻⵎ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⵎ: ");
INSERT INTO rift_vpl VALUES ("NU6_24","005_6_24","NUM","6","24","24","ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵉⵃⴹⴰ! ");
INSERT INTO rift_vpl VALUES ("NU6_25","005_6_25","NUM","6","25","25","ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⴽ ⵢⴻⴳⴳ ⵜⴼⴰⵡⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵉⵃⵉⵏⵏ. ");
INSERT INTO rift_vpl VALUES ("NU6_26","005_6_26","NUM","6","26","26","ⵙⵉⴷⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵍⴻⵀⵏⴰ!’ ");
INSERT INTO rift_vpl VALUES ("NU6_27","005_6_27","NUM","6","27","27","ⴰⴷ ⵙⵙⵉⵡⴹⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴱⴰⵔⴽⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("NU7_1","005_7_1","NUM","7","1","1","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⵓⵙⴰ ⴰⵙⴱⴻⴷⴷⵉ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵉⴷⵀⴻⵏ ⵓ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⵜ ⴰⴽ-ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵄⴰⵍⵟⴰⵔ ⴰⴽ-ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵉⴷⵀⴻⵏ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_2","005_7_2","NUM","7","2","2","ⵅⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵇⴻⴱⴱⴰⵍ, ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_3","005_7_3","NUM","7","3","3","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ: ⵙⴻⵜⵜⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵇⵇⵉⴼⵜ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_4","005_7_4","NUM","7","4","4","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU7_5","005_7_5","NUM","7","5","5","“ⴽⵙⵉ ⴰⵢⴰ ⵣⵣⴰⵢⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵡⵛⴻⴷ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴰⵙ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU7_6","005_7_6","NUM","7","6","6","ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵟⵟⴻⴼ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_7","005_7_7","NUM","7","7","7","ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉ ⵉⵡⵛⴰ ⵉ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴰⵙ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU7_8","005_7_8","NUM","7","8","8","ⵓ ⵉ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴰⵙ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵉⵜⴰⵎⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_9","005_7_9","NUM","7","9","9","ⵉ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⵉ ⵡⴰⵍⵓ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⵔⴱⵓⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵅ ⵜⵖⴰⵔⵡⴰⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_10","005_7_10","NUM","7","10","10","ⵅⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉⵜⵜⵡⴰⴷⵀⴻⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⵉⵡⵢⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU7_11","005_7_11","NUM","7","11","11","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU7_12","005_7_12","NUM","7","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵇⴻⴷⴷⴻⵎ ⵏⴰⵃⵛⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_13","005_7_13","NUM","7","13","13","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_14","005_7_14","NUM","7","14","14","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_15","005_7_15","NUM","7","15","15","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_16","005_7_16","NUM","7","16","16","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_17","005_7_17","NUM","7","17","17","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵏⴰⵃⵛⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU7_18","005_7_18","NUM","7","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵇⴻⴷⴷⴻⵎ ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵖⴰⵔ, ⵡⴻⵏⵏⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_19","005_7_19","NUM","7","19","19","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_20","005_7_20","NUM","7","20","20","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_21","005_7_21","NUM","7","21","21","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_22","005_7_22","NUM","7","22","22","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_23","005_7_23","NUM","7","23","23","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU7_24","005_7_24","NUM","7","24","24","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵓⵏ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_25","005_7_25","NUM","7","25","25","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_26","005_7_26","NUM","7","26","26","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_27","005_7_27","NUM","7","27","27","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_28","005_7_28","NUM","7","28","28","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_29","005_7_29","NUM","7","29","29","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_30","005_7_30","NUM","7","30","30","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ, ⴰⵍⵉⵚⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴷⴰⵢⵢⵓⵔ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_31","005_7_31","NUM","7","31","31","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_32","005_7_32","NUM","7","32","32","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_33","005_7_33","NUM","7","33","33","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_34","005_7_34","NUM","7","34","34","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_35","005_7_35","NUM","7","35","35","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵍⵉⵚⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴷⴰⵢⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU7_36","005_7_36","NUM","7","36","36","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵛⴰⵍⵓⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵔⵉⵛⴰⴷⴷⴰⵢ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_37","005_7_37","NUM","7","37","37","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_38","005_7_38","NUM","7","38","38","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_39","005_7_39","NUM","7","39","39","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_40","005_7_40","NUM","7","40","40","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_41","005_7_41","NUM","7","41","41","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵛⴰⵍⵓⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵔⵉⵛⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("NU7_42","005_7_42","NUM","7","42","42","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⴷ, ⴰⵍⵉⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵄⵓⵢⵉⵍ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_43","005_7_43","NUM","7","43","43","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_44","005_7_44","NUM","7","44","44","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_45","005_7_45","NUM","7","45","45","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_46","005_7_46","NUM","7","46","46","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_47","005_7_47","NUM","7","47","47","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵍⵉⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵄⵓⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU7_48","005_7_48","NUM","7","48","48","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_49","005_7_49","NUM","7","49","49","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_50","005_7_50","NUM","7","50","50","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_51","005_7_51","NUM","7","51","51","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_52","005_7_52","NUM","7","52","52","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_53","005_7_53","NUM","7","53","53","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("NU7_54","005_7_54","NUM","7","54","54","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵊⴰⵎⴰⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵀⵚⵓⵔ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_55","005_7_55","NUM","7","55","55","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_56","005_7_56","NUM","7","56","56","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_57","005_7_57","NUM","7","57","57","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_58","005_7_58","NUM","7","58","58","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_59","005_7_59","NUM","7","59","59","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵊⴰⵎⴰⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵀⵚⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU7_60","005_7_60","NUM","7","60","60","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⴱⵉⴷⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵊⵉⴷⵄⵓⵏⵉ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_61","005_7_61","NUM","7","61","61","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_62","005_7_62","NUM","7","62","62","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_63","005_7_63","NUM","7","63","63","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_64","005_7_64","NUM","7","64","64","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_65","005_7_65","NUM","7","65","65","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⴱⵉⴷⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵊⵉⴷⵄⵓⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU7_66","005_7_66","NUM","7","66","66","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ, ⴰⵅⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵉⵛⴰⴷⴷⴰⵢ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_67","005_7_67","NUM","7","67","67","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_68","005_7_68","NUM","7","68","68","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_69","005_7_69","NUM","7","69","69","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_70","005_7_70","NUM","7","70","70","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_71","005_7_71","NUM","7","71","71","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵅⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵉⵛⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("NU7_72","005_7_72","NUM","7","72","72","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ, ⴼⴰⵊⵄⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴽⵔⴰⵏ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_73","005_7_73","NUM","7","73","73","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_74","005_7_74","NUM","7","74","74","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_75","005_7_75","NUM","7","75","75","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_76","005_7_76","NUM","7","76","76","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_77","005_7_77","NUM","7","77","77","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴼⴰⵊⵄⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴽⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_78","005_7_78","NUM","7","78","78","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵉⵇⴻⴷⴷⴻⵎ ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⴰⵅⵉⵔⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵢⵏⴰⵏ, ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU7_79","005_7_79","NUM","7","79","79","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ: ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⴷⴷⵇⴻⵍ, ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU7_80","005_7_80","NUM","7","80","80","ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵖⴻⵏⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU7_81","005_7_81","NUM","7","81","81","ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("NU7_82","005_7_82","NUM","7","82","82","ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ");
INSERT INTO rift_vpl VALUES ("NU7_83","005_7_83","NUM","7","83","83","ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵅⵉⵔⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵢⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_84","005_7_84","NUM","7","84","84","ⵜⵓⵖⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵜⵜⵡⴰⴷⵀⴻⵏ ⵓⵄⴰⵍⵟⴰⵔ: ⵜⴻⵏⵄⴰⵛ ⵏ ⵟⵟⴱⴰⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NU7_85","005_7_85","NUM","7","85","85","ⵉⵊⵊⴻⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵡⵣⴻⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵛⵉⵇⵍⵓ ⴷ ⵉⵛⵜⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵉ ⵓⵔⵓⵛⵛⵉ ⵉⵡⵣⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ. ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵍⴻⵇⵛⵓⵄ ⵏⵏⵉ ⵜⴻⵡⵣⴻⵏ ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_86","005_7_86","NUM","7","86","86","ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵍⴻⴱⵅⵓⵔ. ⴽⵓⵍ ⵜⴰⵖⴻⵏⵊⴰⵢⵜ ⵜⴻⵡⵣⴻⵏ ⵄⴻⵛⵔⴰ ⵛⵉⵇⵍⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵓⵔⴻⵖ ⵏ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⵉⵡⵣⴻⵏ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵛⵉⵇⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("NU7_87","005_7_87","NUM","7","87","87","ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏⵜ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ, ⵓ ⵜⴻⵏⵄⴰⵛ ⵉⵎⵢⴰⵏⴻⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("NU7_88","005_7_88","NUM","7","88","88","ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏⵜ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉⵜⵜⵡⴰⴷⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU7_89","005_7_89","NUM","7","89","89","ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵙⵍⴰ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵣⵉ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU8_1","005_8_1","NUM","8","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU8_2","005_8_2","NUM","8","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵉ ⴰⵙ: ‘ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⵉⴼⴰⵡⵉⵏ ⵅ ⵍⵇⴻⵏⴷⵉⵍ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵙⴻⴱⵄⴰ ⵏ ⵜⴼⴰⵡⵉⵏ ⴰⴷ ⵡⵛⴻⵏⵜ ⵜⴰⴼⴰⵡⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵍⵇⴻⵏⴷⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("NU8_3","005_8_3","NUM","8","3","3","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵀⴰⵔⵓⵏ. ⵉⵙⵙⴰⵔⵙ ⵜⵉⴼⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵍⵇⴻⵏⴷⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU8_4","005_8_4","NUM","8","4","4","ⵜⵓⵖⴰ ⵍⵇⴻⵏⴷⵉⵍ ⴷ ⵉⵛⵜ ⵏ ⵚⵚⴻⵏⵄⴻⵜ ⵏ ⵡⵓⵔⴻⵖ ⵢⴻⵄⴷⴻⵍ ⵙ ⵡⴻⴼⴹⵉⵙ. ⵣⴻⴳ ⵓⴼⵓⴹ ⵅ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⴰⵍ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵙ ⵡⴻⴼⴹⵉⵙ. ⵄⵍⴰⵃⵙⴰⴱ ⴰⵎⴻⴷⵢⴰ ⵉ ⴷ ⴰⵙ ⵉⵙⵛⵛⴻⵏ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵚⴻⵏⵏⴻⵄ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU8_5","005_8_5","NUM","8","5","5","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU8_6","005_8_6","NUM","8","6","6","“ⴽⵙⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵊⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵙⵉⵣⴷⴻⴳ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_7","005_8_7","NUM","8","7","7","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⵣⴻⴷⴳⴻⴷ: ⵔⵓⵛⵛ ⵉ-ⵜⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵃⴻⴼⴼⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_8","005_8_8","NUM","8","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵙⵉⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵓ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("NU8_9","005_8_9","NUM","8","9","9","ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU8_10","005_8_10","NUM","8","10","10","ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_11","005_8_11","NUM","8","11","11","ⴰⴷ ⵢⴻⵊⵊ ⵀⴰⵔⵓⵏ ⴰⴷ ⵀⴻⵣⵣⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU8_12","005_8_12","NUM","8","12","12","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵊⵊ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵢⵉⵊⵊ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_13","005_8_13","NUM","8","13","13","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵀⴰⵔⵓⵏ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵔⴻⴷ ⴰⴷ ⵀⴻⵣⵣⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU8_14","005_8_14","NUM","8","14","14","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵃⵓⵣⵣⴻⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("NU8_15","005_8_15","NUM","8","15","15","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⵣⴻⴷⴳⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵔⴻⴷ ⴰⴷ ⵀⴻⵣⵣⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ, ");
INSERT INTO rift_vpl VALUES ("NU8_16","005_8_16","NUM","8","16","16","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵎⵎⴻⵡⵛⴻⵏ ⴰⵢⵉ ⵏⵉⵛⴰⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵜⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵎⴻⵏⵣⵓ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU8_17","005_8_17","NUM","8","17","17","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵎⴻⵏⵣⵓ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵇⴰ-ⵜ ⵉⵏⵓ, ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⴰⵎⵎⵓ ⵣⵉ ⵍⵎⴰⵍ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵏⵖⵉⵖ ⵏⴻⵛⵛ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵜⴻⵏ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("NU8_18","005_8_18","NUM","8","18","18","ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU8_19","005_8_19","NUM","8","19","19","ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵀⴰⵔⵓⵏ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵔⵉⵖⴰⵍⵓ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵇⴰⵔⵔⴱⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU8_20","005_8_20","NUM","8","20","20","ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⴰⴽ-ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_21","005_8_21","NUM","8","21","21","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵙⵙⵉⵣⴷⵉⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⴷⴷⴻⵏⴱ ⵏⵙⴻⵏ ⵓⵛⴰ ⵚⴻⴱⴱⵏⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵏⵀⴻⵣⵣⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵉ-ⵜⴻⵏ ⵉ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_22","005_8_22","NUM","8","22","22","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵀⴰⵔⵓⵏ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵎⵎⵓ ⵉ ⴽⵉⴷⵙⴻⵏ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU8_23","005_8_23","NUM","8","23","23","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU8_24","005_8_24","NUM","8","24","24","“ⵜⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴽⵓⵍ ⵎⵎⵉⵙ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ");
INSERT INTO rift_vpl VALUES ("NU8_25","005_8_25","NUM","8","25","25","ⵓ ⵅⵎⵉ ⵉ ⵖⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵓ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵄⴰⴷ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU8_26","005_8_26","NUM","8","26","26","ⴰⴷ ⵉⵡⵛ ⴰⴼⵓⵙ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵃⴹⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴰⴽ-ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⵃⴻⵟⵟⵓ ⵉ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU9_1","005_9_1","NUM","9","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU9_2","005_9_2","NUM","9","2","2","“ⵊⵊⴻⵎ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_3","005_9_3","NUM","9","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ-ⴰ, ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU9_4","005_9_4","NUM","9","4","4","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("NU9_5","005_9_5","NUM","9","5","5","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ, ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⴰⵎⵎⵓ ⵉ ⵜⵜ ⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU9_6","005_9_6","NUM","9","6","6","ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵜⵜⵡⴰⵙⵙⵅⴻⵎⵊⴻⵏ ⵙ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵎⵎⵓⵜⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ⵅ ⵓⵢⴰ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵓⵙⴰ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵀⴰⵔⵓⵏ ");
INSERT INTO rift_vpl VALUES ("NU9_7","005_9_7","NUM","9","7","7","ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵎⴻⵊ ⵙ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵎⵎⵓⵜⴻⵏ. ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵏⴻⵙⵙⵇⴰⵔⵔⴻⴱ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("NU9_8","005_9_8","NUM","9","8","8","ⵎⵓⵙⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵇⵇⵉⵎⴻⵎ ⵜⴱⴻⴷⴷⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵖ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("NU9_9","005_9_9","NUM","9","9","9","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU9_10","005_9_10","NUM","9","10","10","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ: ‘ⵎⴰⵍⴰ ⵃⴻⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵏⵉⵖ ⵣⵉ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵣⵉ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷ ⴰⵣⵉⵔⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵄⴰⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU9_11","005_9_11","NUM","9","11","11","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ, ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⴷ ⵜⵜ ⵙⵙⵡⴻⵊⴷⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵛⵛⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓ ⴰⴽ-ⴷ ⵍⴻⴱⵣⴰⵔ ⵢⴰⵔⴻⵣⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_12","005_9_12","NUM","9","12","12","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵍⵓ ⴰⵍ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴰⵔⴻⵥⵥⴰⵏ ⵉⵖⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ.’” ");
INSERT INTO rift_vpl VALUES ("NU9_13","005_9_13","NUM","9","13","13","“ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵛⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵢⴰⵔⴱⵓ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU9_14","005_9_14","NUM","9","14","14","ⵎⴰⵍⴰ ⵉⵣⴷⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ. ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⵎⵎⵓ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU9_15","005_9_15","NUM","9","15","15","ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵉⴷⵍⴰ ⵓⵙⴻⵢⵏⵓ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴰⴽ-ⴷ ⵓⵇⵉⴹⵓⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⴰⵍ ⵚⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("NU9_16","005_9_16","NUM","9","16","16","ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵍⴻⴱⴷⴰ, ⴰⵙⴻⵢⵏⵓ ⵉⴷⵍⴰ ⵉ-ⵜⵜ ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⴹⵀⴰⵔ-ⴷⴷ ⴰⵎ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("NU9_17","005_9_17","NUM","9","17","17","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵓⵇⵉⴹⵓⵏ, ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴱⴻⴷⴷ ⵓⵙⴻⵢⵏⵓ, ⴷⵉⵏ ⵉ ⵡⵜⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_18","005_9_18","NUM","9","18","18","ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵜⵓⵖⴰ ⴰⵙⴻⵢⵏⵓ ⵉⵇⵇⵉⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_19","005_9_19","NUM","9","19","19","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴱⴻⴷⴷ ⵓⵙⴻⵢⵏⵓ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵃⴹⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⴰⵔ ⴼⴻⵙⵢⴻⵏ ⵛⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_20","005_9_20","NUM","9","20","20","ⵓⵎⵉ ⵉⵇⵇⵉⵎ ⵓⵙⴻⵢⵏⵓ ⵛⵡⴰⵢⵜ ⵏ ⵡⵓⵙⵙⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵅⴻⵏⵏⵉ ⵡⵜⵉⵏ ⵏⵉⵜⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵓ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("NU9_21","005_9_21","NUM","9","21","21","ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵙⴻⵢⵏⵓ ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵣⵉ ⴵⵉⵍⴻⵜ ⴰⵍ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ ⴷⵉ ⵚⵚⴱⴻⵃ, ⵅⴻⵏⵏⵉ ⴼⴻⵙⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ⵎⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵉⴵⴰ ⵏⵉⵖ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵅⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ, ⴼⴻⵙⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_22","005_9_22","NUM","9","22","22","ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵇⵇⵉⵎ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴻⴷⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ, ⵏⵉⵖ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵍⴰⵎⵉ ⵅⴰⵙ ⵖⴰ ⵢⴰⵔⵙⴰ, ⵅⴻⵏⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵅⴻⵢⵢⵎⴻⵏ ⴷⵉⵏⵏⵉ, ⵡⴰⵔ ⴼⴻⵙⵢⴻⵏ ⵛⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ⵎⴰⵍⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ, ⵅⴻⵏⵏⵉ ⴼⴻⵙⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU9_23","005_9_23","NUM","9","23","23","ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ⴰⵇⴰ ⵃⴹⴰⵏ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU10_1","005_10_1","NUM","10","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU10_2","005_10_2","NUM","10","2","2","“ⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴱⵡⴰⵇ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵙⵓ ⵙ ⵡⴻⴼⴹⵉⵙ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵓⴱⴰⵔⵔⴻⵃ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓ ⵉ ⵓⵙⵎⵓⵟⵟⵉ ⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU10_3","005_10_3","NUM","10","3","3","ⵅⵎⵉ ⴷⴰⵢⵙⴻⵏ ⵖⴰ ⵙⵓⴹⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⴽ ⵜⵎⵓⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU10_4","005_10_4","NUM","10","4","4","ⵅⵎⵉ ⵖⴰ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⵎⵖⵉⵔ ⵍⵃⵓⴽⴽⴰⵎ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵅⴰⴽ ⴷⴷ ⵖⴰ ⵉⵎⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_5","005_10_5","NUM","10","5","5","ⵅⵎⵉ ⵖⴰ ⵜⵙⵓⴹⴻⵎ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⵉ ⵍⴱⵓⵇ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵎⵎⵓⵟⵟⵉⵢⴻⵏⵜ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏⵏⵉ ⵉⵎⵎⴰⵔⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("NU10_6","005_10_6","NUM","10","6","6","ⵅⵎⵉ ⵖⴰ ⵜⵙⵓⴹⴻⵎ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⵉ ⵍⴱⵓⵇ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵎⵎⵓⵟⵟⵉⵢⴻⵏⵜ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏⵏⵉ ⵉⵎⵎⴰⵔⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ. ⴰⴷ ⵙⵓⴹⴻⵏ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⵓⵎⵉ ⵖⴰ ⵎⵓⵟⵟⵉⵢⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU10_7","005_10_7","NUM","10","7","7","ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵙⵓⴹⴻⵎ ⴷⵉ ⵍⴻⴱⵡⴰⵇ, ⵎⴰⵛⴰ ⴱⵍⴰ ⴰⵙⵔⵓⴷⴷⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("NU10_8","005_10_8","NUM","10","8","8","ⴰⴷ ⵙⵓⴹⴻⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴷⵉ ⵍⴻⴱⵡⴰⵇ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU10_9","005_10_9","NUM","10","9","9","“ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⴼⴼⵖⴻⵎ ⵖⴰⵔ ⴳⴰⵔⵔⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵎⴻⵏⵖⴻⵎ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵉⵎ ⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴻⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵙⵓⴹⴻⵎ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⵉ ⵍⴻⴱⵡⴰⵇ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⵉⴷⴰⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⵏⴻⵊⵎⴻⵎ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU10_10","005_10_10","NUM","10","10","10","ⴰⵎⵎⵓ ⴷⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⵙⵓⴹⴻⵎ ⴷⵉ ⵍⴻⴱⵡⴰⵇ ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⵢⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵡⴻⵎ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵓⵇⴰⴷⵉ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵍⵉⵏⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU10_11","005_10_11","NUM","10","11","11","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⵙⴻⵢⵏⵓ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU10_12","005_10_12","NUM","10","12","12","ⵓⵛⴰ ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵎⵎⵓⵟⵟⵉⵢⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ ⵓⵛⴰ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵓⵙⴻⵢⵏⵓ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⴼⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_13","005_10_13","NUM","10","13","13","ⴰⵎⵎⵓ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵅ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU10_14","005_10_14","NUM","10","14","14","ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵢⵓⵔⴻⵏ ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵏⴰⵃⵛⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU10_15","005_10_15","NUM","10","15","15","ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵖⴰⵔ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU10_16","005_10_16","NUM","10","16","16","ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵓⵏ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵣⵉⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_17","005_10_17","NUM","10","17","17","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵀⴻⴷⵎⴻⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵓⵛⴰ ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⴱⵓⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("NU10_18","005_10_18","NUM","10","18","18","ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵔⵓⴱⵉⵏ ⵓⵢⵓⵔⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵉⵍⵉⵚⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴷⴰⵢⵓⵔ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU10_19","005_10_19","NUM","10","19","19","ⵛⴰⵍⵓⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⵓⵔⵉⵛⴰⴷⴷⴰⵢ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_20","005_10_20","NUM","10","20","20","ⵉⵍⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵄⵓⵢⵉⵍ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU10_21","005_10_21","NUM","10","21","21","ⵅⴻⵏⵏⵉ ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴰⵔⴱⵓⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⴱⵏⴰⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵇⴱⴻⵍ ⵜⵡⴰⵙⵉⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_22","005_10_22","NUM","10","22","22","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵓⵢⵓⵔⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU10_23","005_10_23","NUM","10","23","23","ⵊⴰⵎⴰⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵀⵚⵓⵔ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU10_24","005_10_24","NUM","10","24","24","ⴰⴱⵉⴷⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵊⵉⴷⵄⵓⵏⵉ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_25","005_10_25","NUM","10","25","25","ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⵄⴻⴵⴰⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ, ⴰⵎ ⵓⵖⴻⵣⴷⵉⵙ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵔⴰⴳⴻⵃ, ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⴰⵅⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵛⴰⴷⴷⴰⵢ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU10_26","005_10_26","NUM","10","26","26","ⴼⴰⵊⵄⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴽⵔⴰⵏ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("NU10_27","005_10_27","NUM","10","27","27","ⴰⵅⵉⵔⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵏⴰⵏ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵣⵉⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_28","005_10_28","NUM","10","28","28","ⴰⵎⵎⵓ ⵉ ⵙⵙⵎⵓⵟⵟⵉⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⴼⴻⵙⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_29","005_10_29","NUM","10","29","29","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵃⵓⴱⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵄⵓⵢⵉⵍ, ⴰⵎⵉⴷⵢⴰⵏⵉ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ: “ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵎⵎⵓⵟⵟⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ ⵡⵛⴻⵖ!’ ⴰⵙ-ⴷⴷ ⴰⴽⵉⴷⵏⴻⵖ, ⴰⴷ ⴰⵛ ⵏⴻⴳⴳ ⵜⵛⵓⵏⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵉⵙⵔⴰⵉⵍ ⵙ ⵍⵅⵉⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU10_30","005_10_30","NUM","10","30","30","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵓ ⵖⴰⵔ ⵍⴰⴵ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU10_31","005_10_31","NUM","10","31","31","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵜⴻⵊⵊⵉ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵏⴻⵡⵡⴻⵜ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵖ. ⵛⴻⴽ ⴰⵇⴰ ⵜⴷⴻⵡⵍⴻⴷ ⴰⵏⴻⵖ - ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵇⵇⴰⵔ - ⴰⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU10_32","005_10_32","NUM","10","32","32","ⵅⵎⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⵙ ⵍⵅⵉⵔ ⵉ ⴷⴰⵢⵏⴻⵖ ⵖⴰ ⵉⴳⴳ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵛ ⵏⴻⴳⴳ ⵜⵛⵓⵏⵉ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("NU10_33","005_10_33","NUM","10","33","33","ⵓⵛⴰ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵜⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⴰⵔⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU10_34","005_10_34","NUM","10","34","34","ⴷⴻⴳ ⵓⵣⵉⵍ ⵜⵓⵖⴰ ⴰⵙⴻⵢⵏⵓ ⵏ ⵙⵉⴷⵉ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ ⵓⵎⵉ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU10_35","005_10_35","NUM","10","35","35","ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⵓⵟⵟⵉ ⵜⵜⴰⴱⵓⵜ, ⵜⴻⵎⵙⴰⵔ ⵍⴻⴱⴷⴰ ⴱⴻⵍⵍⵉ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵍⴻⵄⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵎⵎⵣⴻⴵⴰⵄⴻⵏ ⵓ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("NU10_36","005_10_36","NUM","10","36","36","ⵖⴰⵔ ⵓⴱⴻⴷⴷⵉ ⵏ ⵜⵜⴰⴱⵓⵜ, ⵉⵏⵏⴰ: “ⴷⵡⴻⵍ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("NU11_1","005_11_1","NUM","11","1","1","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵍⴳⴻⵏⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵉⵜⵜⵛⴻⵜⵛⴰⵏ, ⵜⵓⵖⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵃⵔⵉⵇ ⵉ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵙⵉⴷⵉ. ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⴰⵢⴰ, ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ ⵜⴰⵔⵖⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴻⵛⵛⴰ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU11_2","005_11_2","NUM","11","2","2","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵅ ⵎⵓⵙⴰ ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵥⵥⵓⴵ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⴻⵅⵙⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("NU11_3","005_11_3","NUM","11","3","3","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ‘ⵜⴰⴱⵄⵉⵔⴰ’, ⵎⵉⵏⵣⵉ ⵜⵉⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵜⴰⵔⵖⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU11_4","005_11_4","NUM","11","4","4","ⴰⴱⴰⵔⵔⵓ ⵉⵎⵅⴻⴵⴰⴹⴻⵏ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⵛⵓⵔⵔⴻⵏ ⵙ ⵓⵎⴻⵥⵔⵉ ⵓ ⴱⴷⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⴰⵡⴻⴷ ⴰⴷ ⵛⴻⵜⵜⵛⴰⵏ, ⵏⵏⴰⵏ: “ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛⵉⵏ ⴰⵢⵙⵓⵎ? ");
INSERT INTO rift_vpl VALUES ("NU11_5","005_11_5","NUM","11","5","5","ⵏⵄⴻⵇⵇⴻⵍ ⵄⴰⴷ ⵅ ⵉⵙⴻⵍⵎⴰⵏ ⵏⵏⵉ ⵏⴻⵛⵛⴰ ⴷⵉ ⵎⵉⵚⵔⴰ ⴱⴰⵟⴻⵍ ⵓ ⵅ ⵍⴻⵅⵢⴰⵔ ⴷ ⴷⴷⴻⵍⵍⴰⵄ ⴷ ⵍⴻⴱⵚⴻⵍ ⵢⵓⵥⵖⴻⵏ ⴷ ⵍⴻⴱⵚⴻⵍ ⴷ ⵜⵉⵛⵛⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU11_6","005_11_6","NUM","11","6","6","ⵍⴻⵅⵅⵓ ⵍⴻⵄⵎⵓⵔ ⵏⵏⴻⵖ ⵓⵥⵖⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ‘ⵎⴰⵏⵏⴰ’-ⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("NU11_7","005_11_7","NUM","11","7","7","ⵜⵓⵖⴰ ‘ⵎⴰⵏⵏⴰ’ ⵉⵜⵜⴻⵎⵛⴰⴱⴻⵀ ⴷⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵍⵇⴻⵚⴱⵓⵔ ⵓⵛⴰ ⵛⵛⵓⴼ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵛⵛⵓⴼ ⵏ ⵓⵙⴻⵔⵖⴰⵖ ⴰⵛⴻⵎⵍⴰⵍ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴱᵉⴷⵓⵍⴰ’. ");
INSERT INTO rift_vpl VALUES ("NU11_8","005_11_8","NUM","11","8","8","ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ, ⵉⵎⵎⵙⴻⴱⴹⴰ ⵓⵛⴰ ⵢⵔⵓⵏ ⵜⵜ ⵓⵛⴰ ⵃⴰⵔⵢⴻⵏ ⵜⵜ ⵙⴰⴷⵓ ⵜⵙⵉⵔⵜ ⵏⵉⵖ ⴷⴷⵣⴻⵏ ⵜⵜ ⵙ ⵡⴻⵣⴷⵓⵣ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵙⵙⴻⵏⴳⴳⵯⴻⵏ ⵜⵜ ⴷⵉ ⴰⵔⵡⴰ ⵓⵛⴰ ⴳⴳⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵜⵉⴼⴹⵉⵔⵉⵏ. ⵜⵓⵖⴰ ⴰⵍⴻⴷⴷⵉ ⵏⵏⴻⵙ ⴰⵎ ⵎⵉⵏ ⵉⵏⴳⴳⵯⴰⵏ ⵙ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("NU11_9","005_11_9","NUM","11","9","9","ⵅⵎⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰ ⵏⵏⴷⴰ ⵅ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵅⴻⵏⵏⵉ ⵜⵀⴻⴽⴽⵯⴰ-ⴷⴷ ⵅⴰⵙ ‘ⵎⴰⵏⵏⴰ’ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("NU11_10","005_11_10","NUM","11","10","10","ⵓⵛⴰ ⵉⵙⵍⴰ ⵎⵓⵙⴰ ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵖⵓⵢ, ⵍⴰⴵ ⴰⵡⴰⵔⵏⵉ ⵉⵏⵏⴻⵖⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵎⴰⵏ ⴰⵢⴰ ⵓⵍⴰ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU11_11","005_11_11","NUM","11","11","11","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵍⵖⴰⵔ ⴷⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵓⴼⵉⵖ ⵍⵅⴰⴹⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵓⵎⵉ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴷⴷⵇⴻⵍ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("NU11_12","005_11_12","NUM","11","12","12","ⵎⴰ ⵏⴻⵛⵛ ⴷⴻⵢⵙⴻⵖ ⴱⴰⵍⴰⴽ ⵙ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ? ⵏⵉⵖ ⵏⴻⵛⵛ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵢⵓⵔⵡⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⵉⵏⵉⴷ: ‘ⴰⵡⵢⵉ ⵜ ⴷⴻⴳ ⵡⴻⵛⵢⵓⵏ ⵏⵏⴻⵛ!’, ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ ⵢⴰⵔⴻⴱⴱⵓ ⴰⵙⴻⵢⵎⵉ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵛⴻⴽ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU11_13","005_11_13","NUM","11","13","13","ⵣⵉ ⵎⴰⵏⵉⵙ ⴷ ⴰⵙⴻⵏ-ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵖ ⴰⵢⵙⵓⵎ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ? ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⵢⵓⵏ-ⴷⴷ ⵖⴰⵔⵉ, ⵇⵇⴰⵔⴻⵏ: ‘ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⵢⵙⵓⵎ ⵉ ⵖⴰ ⵏⴻⵛⵛ!’ ");
INSERT INTO rift_vpl VALUES ("NU11_14","005_11_14","NUM","11","14","14","ⵏⴻⵛⵛ ⵡⴻⵃⵃⴷⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵔⴱⵓⵖ ⵍⴳⴻⵏⵙ-ⴰ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⴷⵇⴻⵍ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU11_15","005_11_15","NUM","11","15","15","ⵎⴰⵍⴰ ⴷⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵎⵓ, ⵏⴻⵛⵛ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⴷ ⵃⵙⴻⵏ, ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵥⴰⵔⵔⴻⵖ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⵄⴰⴷ ⴽⵜⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("NU11_16","005_11_16","NUM","11","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵎⵓⵏ ⴰⵢⵉ-ⴷⴷ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ. ⴰⵡⵢⵉ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴻⵊⵊ ⵉⵜⴻⵏ ⴰⴷ ⴷⵉⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("NU11_17","005_11_17","NUM","11","17","17","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵀⵡⵉⵖ ⵓⵛⴰ ⴰⴷ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵖ. ⴰⴷ ⴽⵙⵉⵖ ⵣⵉ ⴰⵔⵔⵓⵃ ⵉ ⵅⴰⴽ ⵉⴵⴰⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜ ⵙⵙⴰⵔⵙⴻⵖ. ⴰⵎⵎⵓ ⵉ ⴽⵉⴽ ⵖⴰ ⴰⵔⴱⵓⵏ ⴷⴷⵇⴻⵍ ⵏ ⵍⴳⴻⵏⵙ-ⴰ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜ ⵜⴰⵔⴻⴱⴱⵓⴷ ⵛⴰ ⵡⴻⵃⵃⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("NU11_18","005_11_18","NUM","11","18","18","ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵍⴳⴻⵏⵙ: ‘ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵜⵉⵡⴻⵛⵛⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵔⵓⵎ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵏⵏⴰⵎ: ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛⴻⵏ ⴰⴷ ⵏⴻⵛⵛ ⴰⵢⵙⵓⵎ? ⵜⵓⵖⴰ-ⵏⴻⵖ ⵎⵍⵉⵃ ⴷⵉ ⵎⵉⵚⵔⴰ! ⵙ ⵓⵢⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⴰⵢⵙⵓⵎ ⴰⴷ ⵜⴻⵛⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU11_19","005_11_19","NUM","11","19","19","ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵡⴰⵀⴰ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵏⵉⵖ ⵅⴻⵎⵙⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵏⵉⵖ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵏⵉⵖ ⵄⵉⵛⵔⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU11_20","005_11_20","NUM","11","20","20","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⴰⵍ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵄⵉⴼⴼⴻⵎ, ⵓⵎⵉ ⵜⴻⵏⴹⴰⵔⴻⵎ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵓⵛⴰ ⵜⵔⵓⵎ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰⵎ: ⵎⴰⵢⴻⵎⵎⵉ ⵄⴰⴷ ⴷⴷ-ⵏⴻⴼⴼⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ?’” ");
INSERT INTO rift_vpl VALUES ("NU11_21","005_11_21","NUM","11","21","21","ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⵍⴳⴻⵏⵙ-ⵢⴰ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵉ ⴵⵉⵖ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⴰⵢⵙⵓⵎ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵏ ⵉⴽⵎⴻⵍ!’ ");
INSERT INTO rift_vpl VALUES ("NU11_22","005_11_22","NUM","11","22","22","ⵎⴰⵍⴰ ⵖⴰⵔⵚⴻⵏ ⴰⵙⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵛⴼⴰ ⴰⵙⴻⵏ? ⵏⵉⵖ ⵎⴰⵍⴰ ⵙⵙⵎⵓⵏⴻⵏ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵛⴼⴰ ⴰⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("NU11_23","005_11_23","NUM","11","23","23","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵎⴰ ⵅⴻⵏⵏⵉ ⵢⴻⴱⵔⵉ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ? ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵎⴰ ⴰⴷ ⵉⵇⴼⴻⵍ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵏⵉⵖ ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU11_24","005_11_24","NUM","11","24","24","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ ⴰⵎ ⴷⴷ-ⵏⵏⴹⴻⵏ ⵉ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU11_25","005_11_25","NUM","11","25","25","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵙⴻⵢⵏⵓ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⴽⵙⵉ ⵣⵉ ⴰⵔⵔⵓⵃ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵅ ⵉⵎⵖⴰⵔⴻⵏ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⴰⵔⵔⵓⵃ, ⴱⴷⴰⵏ ⴰⴷ ⵏⴻⴱⴱⴰⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⴰ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU11_26","005_11_26","NUM","11","26","26","ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵊⵊⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⵍⴷⴰⴷ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⵉⴷⴰⴷ ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⵅⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵢⵓⵔⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⵜⵏⴻⴱⴱⴰⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU11_27","005_11_27","NUM","11","27","27","ⵢⵓⵣⵣⴻⵍ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵉⵅⴻⴱⴱⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵉⵍⴷⴰⴷ ⴷ ⵎⵉⴷⴰⴷ ⵜⵜⵏⴻⴱⴱⴰⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU11_28","005_11_28","NUM","11","28","28","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴱⵍⵉⵖⴻⵏ ⵉⵜⵜⴼⴰⵔⵣⴻⵏ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵓⵙⴰ, ⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU11_29","005_11_29","NUM","11","29","29","ⵉⵏⵏⴰ ⴰⵙ ⵎⵓⵙⴰ: “ⵎⴰ ⵛⴻⴽ ⵜⴻⵛⴹⴰⵔⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ? ⵎⵍⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⵎⴰⵔⵔⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵍⵉ ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵙⵉⴷⵉ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("NU11_30","005_11_30","NUM","11","30","30","ⵉⴷⵡⴻⵍ-ⴷⴷ ⵎⵓⵙⴰ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU11_31","005_11_31","NUM","11","31","31","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⵉⵙⵙⴻⴽⴽⴰⵔ ⵉ-ⵜ ⵙⵉⴷⵉ, ⵉⵏⴷⴻⵀ-ⴷⴷ ⵉⵊⴹⴰⴹ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵜⵙⴰⵍⵡⴰ’ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏⵜ ⵅ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵜⵉⵛⵍⵉ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵜⵎⴰ ⴷ ⵜⵉⵛⵍⵉ ⵏ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⵎⴰ ⵏⵏⴻⵖⵏⵉ, ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵍ ⵄⵍⴰⵢⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU11_32","005_11_32","NUM","11","32","32","ⵉⴽⴽⴰⵔ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⵙⵙ ⵏⵏⵉ ⵉⴽⵎⴻⵍ ⴷ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵜⴻⴽⵎⴻⵍ ⴷ ⵎⴰⵔⵔⴰ ⴰⵙⵙ ⵉ ⵜ-ⵉ-ⴷⴷ ⵉⴹⴼⴰⵔⴻⵏ ⵢⵔⵓⵏ ⵏⵉⵜⵏⵉ ⵉⵊⴹⴰⴹ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵜⵙⴰⵍⵡⴰ’. ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⵔⵓⵙ, ⵉⴽⵙⵉ ⵄⴻⵛⵔⴰ ⵉⵃⵓⵎⵉⵔⴻⵏ. ⴱⴻⵣⵣⵄⴻⵏ ⵜⴻⵏⵜ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ ⵅ ⵜⵉⵔⵓ ⵉ ⵉⵏⵏⴹⴻⵏ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU11_33","005_11_33","NUM","11","33","33","ⵎⵉⵏⵜⵔⴰ ⴰⵢⵙⵓⵎ ⵄⴰⴷ ⵊⴰⵔ ⵜⴻⵖⵎⴰⵙ ⵏⵙⴻⵏ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜ ⴼⴼⵥⴻⵏ, ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵜⴰ ⵍⴳⴻⵏⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU11_34","005_11_34","NUM","11","34","34","ⵉⵙⴻⵎⵎⴰ ⵎⵓⵙⴰ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ‘ⵇⴰⴱⴰⵔⵓⵜ-ⵀⴰⵜⴰ’ⴰⵡⴰⵜ’, ⵎⵉⵏⵣⵉ ⴷⵉⵏⵏⵉ ⵉ ⵏⴻⴹⵍⴻⵏ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⴻⵏ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("NU11_35","005_11_35","NUM","11","35","35","ⵣⵉ ⵇⴰⴱⴰⵔⵓⵜ-ⵀⴰⵜⴰ’ⴰⵡⴰⵜ ⵉⴼⵙⵉ ⵍⴳⴻⵏⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵃⴰⴹⴰⵢⵔⵓⵜ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵃⴰⴹⴰⵢⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU12_1","005_12_1","NUM","12","1","1","ⵜⴻⵙⵙⵉⵡⴻⵍ ⵎⴰⵔⵢⴰⵎ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵅ ⵎⵓⵙⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴽⵓⵛⵉⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵢⵉⵡⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴽⵓⵛⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU12_2","005_12_2","NUM","12","2","2","ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵎⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵣⵉ ⵎⵓⵙⴰ ⵡⴰⵀⴰ? ⵎⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵡⴻⴷ?” ⵓⵛⴰ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU12_3","005_12_3","NUM","12","3","3","ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⴷ ⴰⵔⵢⴰⵣ ⴰⵎⵡⴰⴹⴻⵄ ⴰⵟⵟⴰⵙ, ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU12_4","005_12_4","NUM","12","4","4","ⴷⴻⵖⵢⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵢⴰⵎ: “ⴼⴼⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⵍⴰⵜⴰ, ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ!” ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("NU12_5","005_12_5","NUM","12","5","5","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ, ⵉⵍⴰⵖⴰ ⵉ ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵢⴰⵎ. ⴼⴼⵖⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU12_6","005_12_6","NUM","12","6","6","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵏⴻⵜⵜⴰ: “ⵙⵍⴻⵎ ⵅⴻⵏⵏⵉ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ! ⵎⴰⵍⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ, ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙ ⵉⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵓⵛⴰ ⴰⴷ ⴽⵉⵙ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU12_7","005_12_7","NUM","12","7","7","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵎⴻⵏⵏⵉ ⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵎⵓⵙⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NU12_8","005_12_8","NUM","12","8","8","ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⴻⵙ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ. ⴰⵇⴰ ⵉⵥⵔⴰ ⴰⴷⴷⵓⴷ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⴳⴳⵯⵉⴷⴻⵎ ⵣⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴰⵎⵎⵓ ⵅ ⵎⵓⵙⴰ?” ");
INSERT INTO rift_vpl VALUES ("NU12_9","005_12_9","NUM","12","9","9","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵅⴰⵙⴻⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("NU12_10","005_12_10","NUM","12","10","10","ⵓⵛⴰ ⴰⵙⴻⵢⵏⵓ ⵉⴼⴼⴻⵖ ⵅ ⵓⵇⵉⴹⵓⵏ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵎⴰⵔⵢⴰⵎ ⴷⴰⵢⴻⵙ ⵍⴻⵀⵍⴰⵛ ⵏ ⵍⴱⴰⵔⵚ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵛⴻⵎⵍⴰⵍⵜ ⴰⵎ ⵡⴻⴷⴼⴻⵍ. ⵓⵛⴰ ⵀⴰⵔⵓⵏ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵢⴰⵎ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⴷⴰⵢⴻⵙ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("NU12_11","005_12_11","NUM","12","11","11","ⵓⵛⴰ ⵉⵏⵏⴰ ⵀⴰⵔⵓⵏ ⵉ ⵎⵓⵙⴰ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵙⵔⵓⵙⵙⵉ ⴷⴷⴻⵏⴱ ⵉ ⵏⴻⴳⴳⴰ ⵙ ⵜⴻⴼⵖⵓⵔⵉ ⵓⵎⵉ ⴷⴰⵢⴻⵙ ⵏⴻⵅⴹⴰ! ");
INSERT INTO rift_vpl VALUES ("NU12_12","005_12_12","NUM","12","12","12","ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵓⵎⴻⵜⵜⵉⵏ ⵉ ⵣⵉ ⵉⵜⵜⵡⴰⵛⵛ ⵡⴻⵣⵢⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴰⵎ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵍⴻⵎⵍⴰⵡⴻⵜ ⵏ ⵢⴻⵎⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU12_13","005_12_13","NUM","12","13","13","ⵉⵍⴰⵖⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴳⴻⵏⴼⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("NU12_14","005_12_14","NUM","12","14","14","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵎⴰ ⵎⴰⵍⴰ ⴱⴰⴱⴰⵙ ⴰⵇⴰ ⵉⵏⵅⴰⵔ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰ ⵡⴰⵔ ⵜᵉⵙⴻⴹⵃⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ? ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴱⴻⵍ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("NU12_15","005_12_15","NUM","12","15","15","ⵜᵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵢⴰⵎ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⴽⴽⵉⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵇⴱⴻⵍ ⵎⴰⵔⵢⴰⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("NU12_16","005_12_16","NUM","12","16","16","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⵙⵉ ⵍⴳⴻⵏⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ ⵣⵉ ⵃⴰⴹⴰⵢⵔⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⴼⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU13_1","005_13_1","NUM","13","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU13_2","005_13_2","NUM","13","2","2","“ⵙⴻⴽⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵜⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⴰⴷ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵊⴰⵔ ⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU13_3","005_13_3","NUM","13","3","3","ⵎⵓⵙⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⴼⴰⵔⴰⵏ, ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ. ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU13_4","005_13_4","NUM","13","4","4","ⴰⵇⴰ ⴷ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵛⴰⵎⵎⵓⵄ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴽⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NU13_5","005_13_5","NUM","13","5","5","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵛⴰⴼⴰⵜ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵓⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("NU13_6","005_13_6","NUM","13","6","6","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("NU13_7","005_13_7","NUM","13","7","7","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵢⵉⵊⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ");
INSERT INTO rift_vpl VALUES ("NU13_8","005_13_8","NUM","13","8","8","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("NU13_9","005_13_9","NUM","13","9","9","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴼⴰⵍⵟⵉ, ⵎⵎⵉⵙ ⵏ ⵔⴰⴼⵓ, ");
INSERT INTO rift_vpl VALUES ("NU13_10","005_13_10","NUM","13","10","10","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵊⴰⴷⴷⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵙⵓⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("NU13_11","005_13_11","NUM","13","11","11","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵊⴰⴷⴷⵉ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵙⵉ, ");
INSERT INTO rift_vpl VALUES ("NU13_12","005_13_12","NUM","13","12","12","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ, ⵄⴰⵎⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵎⴰⵍⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("NU13_13","005_13_13","NUM","13","13","13","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ, ⵙⴰⵜⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("NU13_14","005_13_14","NUM","13","14","14","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵏⴰⵃⴱⵉ, ⵎⵎⵉⵙ ⵏ ⵡⴰⴼⵙⵉ, ");
INSERT INTO rift_vpl VALUES ("NU13_15","005_13_15","NUM","13","15","15","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ, ⵊⴰ’ⵓⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵎⴰⴽⵉ. ");
INSERT INTO rift_vpl VALUES ("NU13_16","005_13_16","NUM","13","16","16","ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵍⴰⵖⴰ ⵉ ⵀⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵛⵓⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("NU13_17","005_13_17","NUM","13","17","17","ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵎⵓⵙⴰ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵍⵢⴻⵎ ⵙⵙⵉⵀⴰ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓⵛⴰ ⴰⵍⵢⴻⵎ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU13_18","005_13_18","NUM","13","18","18","ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵎⴰ ⵉⵊⵀⴻⴷ ⵏⵉⵖ ⵉⴹⵄⴻⴼ ⵉ ⵢⴻⴵⴰ, ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⴷⵔⵓⵙ ⵏⵉⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU13_19","005_13_19","NUM","13","19","19","ⵅⵣⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵍⴳⴻⵏⵙ, ⵎⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵏⵉⵖ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵉ ⵜⴻⴵⴰ, ⵓ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⴷⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵍⴳⴻⵏⵙ, ⵎⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵉⵖ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵙ ⵉⵖⴻⴱⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU13_20","005_13_20","NUM","13","20","20","ⵓ ⵄⴰⵡⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰ ⵜⴻⵙⵙⵖⴻⵎⵎⵉ ⵏⵉⵖ ⵜⵓⵥⴻⵖ, ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵉⵖ ⵍⵍⴰ. ⴳⴳⴻⵎ ⵜⴰⵔⵢⴰⵙⵜ ⵓⵛⴰ ⴽⵙⵉⵎ ⵛⴰ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵓⴹⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU13_21","005_13_21","NUM","13","21","21","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵓⵛⴰ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ ⴰⵍ ⵔⴰⵃⵓⴱ, ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NU13_22","005_13_22","NUM","13","22","22","ⴳⴻⵄⵄⴷⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ. ⴷⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴰⵅⵉⵎⴰⵏ, ⵛⵉⵛⴰⵢ ⴷ ⵜⴰⵍⵎⴰⵢ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵏⴰⵇ. ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵇⴱⴻⵍ ⵚⵓⵄⴰⵏ ⴷⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU13_23","005_13_23","NUM","13","23","23","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴻⵏ ⴰⵍ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⴰⵛⴽⵓⵍ ⵓⵛⴰ ⵙⵙⴻⵏⵏⵉ ⴽⴽⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵣⵔⴻⵎⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵣⴻⴽⴽⵓⵏ ⵏ ⵓⴹⵉⵍ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵣⴻⴵⴰⴹ ⵏ ⵜⵔⴻⴱⴱⵓⵜ. ⴽⴽⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⴰⵔⴻⵎⵎⴰⵎ ⵓ ⵣⵉ ⵜⴰⵣⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU13_24","005_13_24","NUM","13","24","24","ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵉⵛⴽⵓⵍ, ⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵓⵣⴻⴽⴽⵓⵏ’, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵣⴻⴽⴽⵓⵏ ⵏ ⵓⴹⵉⵍ ⵏⵏⵉ ⵇⴻⵙⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU13_25","005_13_25","NUM","13","25","25","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵓⴱⴻⵔⴳⴰⴳ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU13_26","005_13_26","NUM","13","26","26","ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⴼⴰⵔⴰⵏ, ⵖⴰⵔ ⵇⴰⴷⴰⵛ, ⵓⵛⴰ ⵡⵛⵉⵏ ⵍⴻⵅⴱⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵓⵛⴰ ⵙⵙⴻⵛⵏⴻⵏ ⴰⵙⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU13_27","005_13_27","NUM","13","27","27","ⵃⴰⵊⴰⵏ ⴰⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵎⴰⵏⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ. ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴼⴻⵢⵢⴻⴹ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵓ ⵜⴰⵏⵉⵜⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU13_28","005_13_28","NUM","13","28","28","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⵀⴻⴷ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵖⴰⵔⵙⴻⵏⵜ ⵉⵖⴻⴱⵔⴰⵡⴻⵏ ⵎⵖⴰⵔⴻⵏⵜ ⴰⵟⵟⴰⵙ, ⵓ ⵏⴻⵥⵔⴰ ⵄⴰⵡⴻⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵏⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("NU13_29","005_13_29","NUM","13","29","29","ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵓ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵓ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵓ ⵅ ⵜⵎⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU13_30","005_13_30","NUM","13","30","30","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵙⵇⴰⵔ ⴽⴰⵍⵉⴱ ⵍⴳⴻⵏⵙ ⵣⵣⴰⵜ ⵉ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵙ ⵊⵊⴻⵀⴷ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵏⴻⵟⵟⴻⴼ ⴷ ⵍⵡⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⵙ ⵏⴻⵛⵛⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU13_31","005_13_31","NUM","13","31","31","ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵊⵀⴻⴷ ⵅⴰⵏⴻⵖ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU13_32","005_13_32","NUM","13","32","32","ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵜⵜⴱⴻⵔⴳⴰⴳⴻⵏ, ⵏⵏⴰⵏ: “ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⵎⴰⵏⵉⵙ ⵏⴻⴽⴽⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵏⴱⴻⵔⴳⴻⴳ, ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵙⴰⵔⵔⴻⴹ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵏⴻⵥⵔⴰ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵡⴰⴷⴷⴰⴷ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU13_33","005_13_33","NUM","13","33","33","ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⴷⵉⵏ ‘ⵏⵉⴼⵉⵍⵉⵎ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵊⵊⵡⴰⵀⴻⵍ ⵉⵡⴹⴰⵏ’, ⴰⵢⵜ ⵏ ⵄⴰⵏⴰⵇ, ⴰⵔⵔⴰⵙⴰ ⵏ ⵊⵊⵡⴰⵀⴻⵍ ⵉⵡⴹⴰⵏ. ⵜⵓⵖⴰ ⵏⴻⵛⵛⵉⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⴰⵎⴻⵛⵏⴰⵡ ⵜⴰⵎⵓⵔⵖⵉ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴷⴷ ⴰⵙⴻⵏ ⵏⴻⵜⵜⴱⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU14_1","005_14_1","NUM","14","1","1","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵜⴻⴱⴷⴰ ⵜⴻⵙⵖⵓⵢⵢⵓ ⵙ ⵊⵊⴻⵀⴷ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵔⵓ ⵎⴰⵔⵔⴰ ⴵⵉⵍⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU14_2","005_14_2","NUM","14","2","2","ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵜⵜⵏⴻⴷⵇⴰⵎⴻⵏ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ ⵓ ⴹⵉⴷⴷ ⵉ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ: “ⵎⴻⵄⵍⵉⴽ ⵇⴰⵄ ⵏⴻⵎⵎⵓⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ!” ⵏⵉⵖ: “ⵎⴻⵄⵍⵉⴽ ⵇⴰⵄ ⵏⴻⵎⵎⵓⵜ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU14_3","005_14_3","NUM","14","3","3","“ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⵉⵡⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵡⴹⴰ ⵙ ⵙⵙⵉⴼ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵖ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ? ⵎⴰ ⵡⴰⵔ ⵢⴻⴵⵉ ⵃⵙⴻⵏ ⵣⴻⵄⵎⴰ ⴰⴷ ⵏⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵎⵉⵚⵔⴰ?” ");
INSERT INTO rift_vpl VALUES ("NU14_4","005_14_4","NUM","14","4","4","ⵓⵛⴰ ⵏⵏⴰⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅⴰⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵎⵉⵚⵔⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU14_5","005_14_5","NUM","14","5","5","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵡⴹⴰⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU14_6","005_14_6","NUM","14","6","6","ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴷ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴻⵔⴳⴰⴳⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵛⴰⵔⵔⴳⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU14_7","005_14_7","NUM","14","7","7","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⴰⵏ: “ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵏⴻⴽⴽⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵏⴱⴻⵔⴳⴻⴳ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU14_8","005_14_8","NUM","14","8","8","ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴼⴰⵔⵏⴻⵏ ⵖⴰⵔⵏⴻⵖ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⵡⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵓⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⵜ ⵉⵡⵛ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU14_9","005_14_9","NUM","14","9","9","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵖⴻⵡⵡⵖⴻⵏ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵖ. ⵜⵉⵍⵉ ⵏⵙⴻⵏ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴽⵉⴷⵏⴻⵖ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU14_10","005_14_10","NUM","14","10","10","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⵊⵎⴻⵏ, ⵉⴱⴰⵏ-ⴷⴷ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU14_11","005_14_11","NUM","14","11","11","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵍ ⵎⴻⵍⵎⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵄⴰⵔ ⵍⴳⴻⵏⵙ-ⴰ? ⴰⵍ ⵎⴻⵍⵎⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵉⵎⵏⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⵉ ⴳⴳⵉⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("NU14_12","005_14_12","NUM","14","12","12","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵡⵜⴻⵖ ⵙ ⵟⵟⴰⵄⵓⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⴽⴽⵙⴻⵖ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵊⵀⴻⴷ ⵅⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU14_13","005_14_13","NUM","14","13","13","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵙⵉⴷⵉ: “ⴰⴷ ⵙⵍⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU14_14","005_14_14","NUM","14","14","14","ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵏⵉⵏ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ-ⴰ, ⴱⴻⵍⵍⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵜⴱⴰⵏⴻⴷ-ⴷⴷ ⴰⵎⴻⵛⵏⴰⵡ ⵓⴷⴻⵎ ⴷⴻⴳ ⵡⵓⴷⴻⵎ, ⴱⴻⵍⵍⵉ ⴰⵙⴻⵢⵏⵓ ⵏⵏⴻⵛ ⵉⵜⵜⴱⴻⴷⴷⴰ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ ⵓ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⵜⴻⴳⴳⵓⵔⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵙ ⵓⵣⵉⵍ ⵓⵛⴰ ⵙ ⴵⵉⵍⴻⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⵙⵙⵉ.    ");
INSERT INTO rift_vpl VALUES ("NU14_15","005_14_15","NUM","14","15","15","ⵎⴰⵍⴰ ⵜⴻⵏⵖⵉⴷ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵅⴻⵏⵏⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵙⵍⵉⵏ ⵅ ⵓⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴷ ⵉⵏⵉⵏ: ");
INSERT INTO rift_vpl VALUES ("NU14_16","005_14_16","NUM","14","16","16","‘ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵉⴷⴻⴼ ⵍⴳⴻⵏⵙ-ⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⵊⵊⵓⴵ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵉⵡⵛ, ⴰⵇⴰ ⵙ ⵓⵢⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵖⴰⵔⵚ ⴷⵉ ⵍⴻⵅⵍⴰ!’ ");
INSERT INTO rift_vpl VALUES ("NU14_17","005_14_17","NUM","14","17","17","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵊⵊⴻⵀⴷ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵎⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⵜⴻⵏⵏⵉⴷ: ");
INSERT INTO rift_vpl VALUES ("NU14_18","005_14_18","NUM","14","18","18","‘ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ⴰⵇⴰ ⵢⴰⵔⴻⴱⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷ ⵓⵅⴻⵟⵟⵓ ⵏⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⵔⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⴻⵏⴱ ⵓ ⵉⵙⵙⴻⵄⵄⴷⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ.’ ");
INSERT INTO rift_vpl VALUES ("NU14_19","005_14_19","NUM","14","19","19","ⵖⴼⴰⵔ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵀⴻⵎⵍⴻⴷ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍ ⴷⴰⵏⵉⵜⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU14_20","005_14_20","NUM","14","20","20","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵏⴻⵛⵛ ⵖⴼⴰⵔⴻⵖ ⴰⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NU14_21","005_14_21","NUM","14","21","21","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("NU14_22","005_14_22","NUM","14","22","22","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵥⵔⵉⵏ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉⵏⵓ ⵉ ⴳⴳⵉⵖ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵇⴻⴵⴱⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵄⴰⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓ ⵡⴰⵔ ⵙⵍⵉⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("NU14_23","005_14_23","NUM","14","23","23","ⵡⴰⵔ ⵥⴰⵔⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵡⵛⴻⵖ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴷⴷⵓⵇⵇⵣⴻⵏ ⴰⵎⵎⵓ, ⵡⴰⵔ ⵜⵜ ⵥⴰⵔⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU14_24","005_14_24","NUM","14","24","24","ⵎⴰⵛⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴽⴰⵍⵉⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵢⵓⴷⴻⴼ ⵇⴱⴻⵍ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⴰⵢⵉ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU14_25","005_14_25","NUM","14","25","25","ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ ⵜⵉⵡⴻⵛⵛⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⵙⵙⴰ, ⴼⴼⵖⴻⵎ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵓⵢⵓⵔⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU14_26","005_14_26","NUM","14","26","26","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU14_27","005_14_27","NUM","14","27","27","“ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵜⵎⴻⵙⵎⵓⵏⵜ-ⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵜᵉⵜⵜⵏⴻⴷⵇⴰⵎ ⵅⴰⴼⵉ? ⴰⵏⴻⴷⵇⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵣⵉ ⵅⴰⴼⵉ ⵜⵜⵏⴻⴷⵇⴰⵎⴻⵏ, ⴰⵇⴰ ⵙⵍⵉⵖ ⵜ. ");
INSERT INTO rift_vpl VALUES ("NU14_28","005_14_28","NUM","14","28","28","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵡⴻⵎ ⵙⵍⵉⵖ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ ⵎⵉⵏ ⵜⴻⵏⵏⴰⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("NU14_29","005_14_29","NUM","14","29","29","ⵍⵅⴻⵛⴱⴰⵜ ⵏⵡⴻⵎ ⴰⴷ ⵡⴹⴰⵏⵜ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ, ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵎⴰⵔⵔⴰ ⵍⵇⴻⴷⴷ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵣⵉ ⵄⵉⵛⵍⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵓⵖⴰ ⵅⴰⴼⵉ ⵉⵜⵜⵏⴻⴷⵇⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU14_30","005_14_30","NUM","14","30","30","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⵛⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⵉⵏ ⵅⴻⴼ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵊⵊⴰⴵⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴳⴳⴻⵖ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⵖⴻⵎ, ⵎⵖⵉⵔ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU14_31","005_14_31","NUM","14","31","31","ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ ⵉ ⵅⴻⴼ ⵜⴻⵏⵏⴰⵎ: ‘ⴰⴷ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ!’, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⴷⴼⴻⵖ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵏⴹⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⵎⵎⵓ ⵙ ⵓⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU14_32","005_14_32","NUM","14","32","32","ⵎⴰⵛⴰ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵡⴻⵎ, ⵡⴰⵀ, ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ, ⴰⴷ ⵜⴻⵡⴹⴰⵎ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NU14_33","005_14_33","NUM","14","33","33","ⵓⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵍⵍⵄⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴽⵉⵡⴻⵎ ⵜⴰⵔⴱⵓⵎ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵡⴻⵎ ⴰⵍ ⵖⴰ ⴼⵏⴰⵏⵜ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵡⴻⵎ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU14_34","005_14_34","NUM","14","34","34","ⴰⵏⴻⵛⵜ ⵉ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴱⴻⵔⴳⴰⴳⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ, ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ - ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ - ⴰⴷ ⵜⴰⵔⴱⵓⵎ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ, ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ ⴱⴻⵄⵄⴷⴻⵖ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU14_35","005_14_35","NUM","14","35","35","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵙⵙⵉⵡⵍⴻⵖ: ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵎⵎⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ-ⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵜⴻⵏⵏⵉ ⵉⴽⴽⵙⴻⵏ ⴰⵡⴰⵍ ⵅⴰⴼⵉ: ⴰⴷ ⵎⵎⵜⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ, ⴰⴷ ⵎⵎⵜⴻⵏ ⴷⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU14_36","005_14_36","NUM","14","36","36","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵍⴰⵎⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ, ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⵎ ⵜⴻⴽⵎⴻⵍ ⵜⴻⴷⵡⴻⵍ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵍⵖⴰⵔ ⵅ ⵜⴰⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("NU14_37","005_14_37","NUM","14","37","37","ⴰⵇⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴱⴻⵀⴷⵍⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⵎⵓⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU14_38","005_14_38","NUM","14","38","38","ⵎⴰⵛⴰ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴷ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵊⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵔⵓⵃⴻⵏ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU14_39","005_14_39","NUM","14","39","39","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵃⵣⴻⵏ ⵅⴻⵏⵏⵉ ⵍⴳⴻⵏⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU14_40","005_14_40","NUM","14","40","40","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ ⵓⵛⴰ ⵓⵍⵢⴻⵏ ⴰⵍ ⵜⴰⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵏⵏⴰⵏ: “ⴰⵇⴰ-ⵏⴻⵖ ⴷⴰ ⵓⵛⴰ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⴻⵅⴹⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU14_41","005_14_41","NUM","14","41","41","ⵎⴰⵛⴰ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵄⴻⴷⴷⴰⵎ ⴰⵎⵎⵓ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ? ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵓ! ");
INSERT INTO rift_vpl VALUES ("NU14_42","005_14_42","NUM","14","42","42","ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⵉⴷⴻⵎ ⵛⴰ ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵅⵙⴰⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU14_43","005_14_43","NUM","14","43","43","ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉⵏ ⵣⵣⴰⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⴹⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵙⵙⵉⴼ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵉⴳⴳⵯⴻⵊⴻⵎ ⵅ ⵙⵉⴷⵉ. ⵙ ⵓⵢⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⵉⵜⵜⵉⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("NU14_44","005_14_44","NUM","14","44","44","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵓⴼⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵍⵢⴻⵏ ⴰⵍ ⵜⴰⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ⵎⴰⵛⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⴷ ⵎⵓⵙⴰ ⵡⴰⵔ ⴼⴼⵉⵖⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU14_45","005_14_45","NUM","14","45","45","ⵅⴻⵏⵏⵉ ⵀⵡⴰⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏⵏⵉ ⵓⵛⴰ ⴰⵔⴻⵏⵢⴻⵏ ⵜⴻⵏ ⵓ ⵍⴻⴱⵣⴻⵏ ⵜⴻⵏ ⴰⵍ ⵃⵓⵔⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("NU15_1","005_15_1","NUM","15","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU15_2","005_15_2","NUM","15","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⵣⴻⴷⴷⵖⴻⵎ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("NU15_3","005_15_3","NUM","15","3","3","ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵉ ⵓⴽⴻⵎⵎⴻⵍ ⵏ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏⵡⴻⵎ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵉⵖ ⵣⴻⴳ ⵡⵓⴵⵉ, ");
INSERT INTO rift_vpl VALUES ("NU15_4","005_15_4","NUM","15","4","4","ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵢⴰⵡⵉ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("NU15_5","005_15_5","NUM","15","5","5","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⴽ-ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⴱⵉⵏⵓ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵅ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵜⵖⴰⵔⵚⵜ, ");
INSERT INTO rift_vpl VALUES ("NU15_6","005_15_6","NUM","15","6","6","ⵏⵉⵖ, ⵎⴰⵍⴰ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⴰⵢ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("NU15_7","005_15_7","NUM","15","7","7","ⵓⵛⴰ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⴱⵉⵏⵓ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("NU15_8","005_15_8","NUM","15","8","8","“ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵓⴽⴻⵎⵎⴻⵍ ⵏ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵏⵉⵖ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("NU15_9","005_15_9","NUM","15","9","9","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⴷ ⴰⴽ-ⴷ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⴰⵢ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("NU15_10","005_15_10","NUM","15","10","10","ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⴰⵣⵢⴻⵏ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⴱⵉⵏⵓ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU15_11","005_15_11","NUM","15","11","11","ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴳⴳⴻⵏ ⵉ ⴽⵓⵍ ⴰⴼⵓⵏⴰⵙ, ⵏⵉⵖ ⵉ ⴽⵓⵍ ⵉⵛⴰⵔⵔⵉ, ⵏⵉⵖ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵣⴻⴳ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU15_12","005_15_12","NUM","15","12","12","ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵉ ⵖⴰ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵎⵎⵓ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU15_13","005_15_13","NUM","15","13","13","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵎⵎⵓ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU15_14","005_15_14","NUM","15","14","14","ⵅⵎⵉ ⵖⴰ ⵜⴰⴼⴻⴷ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ, ⵏⵉⵖ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("NU15_15","005_15_15","NUM","15","15","15","ⴰⵢ, ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ. ⴰⴷ ⵢⵉⵍⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU15_16","005_15_16","NUM","15","16","16","ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ ⴷ ⵉⵛⵜ ⵏ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU15_17","005_15_17","NUM","15","17","17","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU15_18","005_15_18","NUM","15","18","18","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵢⴰⵡⵢⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("NU15_19","005_15_19","NUM","15","19","19","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU15_20","005_15_20","NUM","15","20","20","ⵣⵉ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵡⴰⵔⴻⵛⵜⵉ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵎⵙⴻⵎⵎⴻⵏⵜ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ. ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵓⵏⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU15_21","005_15_21","NUM","15","21","21","ⵣⵉ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵡⴰⵔⴻⵛⵜⵉ ⵏⵡⴻⵎ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("NU15_22","005_15_22","NUM","15","22","22","“ⵎⴰⵍⴰ ⵜⵡⴻⴷⴷⴰⵔⴻⵎ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ-ⴰ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ");
INSERT INTO rift_vpl VALUES ("NU15_23","005_15_23","NUM","15","23","23","- ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⵣⵉ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵙⵙⴻⵏⵏⵉ ⴷ ⵜⵙⴰⵡⴻⵏⵜ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵔⴻⵊⵢⵓⵍ ⵏⵡⴻⵎ - ");
INSERT INTO rift_vpl VALUES ("NU15_24","005_15_24","NUM","15","24","24","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵙ ⵓⵡⴻⴷⴷⴰⵔ ⴱⴰⵔⵔⴰ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⴰⵇⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⵎ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵓ ⴰⴽ-ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("NU15_25","005_15_25","NUM","15","25","25","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵙⵍⴰⵃ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵙⴻⵏ ⵏ ⴷⴷⴻⵏⴱ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU15_26","005_15_26","NUM","15","26","26","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵖⴼⴰⵔ, ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵅ ⵓⵎⵉ ⵉⵎⵙⴰⵔ ⴰⵎ ⵉⵡⴻⴷⴷⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU15_27","005_15_27","NUM","15","27","27","“ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵅⴹⴰ ⴰⵎ ⵏⴻⵜⵜⴰ ⵉⵡⴻⴷⴷⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉⵛⵜ ⵏ ⵜⵖⴰⵢⴹⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ.    ");
INSERT INTO rift_vpl VALUES ("NU15_28","005_15_28","NUM","15","28","28","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵅ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴰⵔ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵅⴹⴰ ⵙ ⵓⵡⴻⴷⴷⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵅⴰⵙ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴰⵙⵍⴰⵃ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU15_29","005_15_29","NUM","15","29","29","ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ ⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵛⴰ ⵙ ⵓⵡⴻⴷⴷⴰⵔ, ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU15_30","005_15_30","NUM","15","30","30","“ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵛⴰ ⵙ ⵓⴼⵓⵙ ⵉⴳⴻⵄⵄⴷⴻⵏ, ⵎⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵛⴻⵇⵇⴻⴼ ⴷⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NU15_31","005_15_31","NUM","15","31","31","ⵓⵎⵉ ⵉⵙⵙⴻⵃⵇⴰⵔ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓ ⵢⴰⵔⵥⴰ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵙ. ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵇⴰⵄ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵅⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU15_32","005_15_32","NUM","15","32","32","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵓⴼⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵃⴰⵔⵡⴰⵛ ⴰⴽⴻⵛⵛⵓⴹ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("NU15_33","005_15_33","NUM","15","33","33","ⵉⵏⵏⵉ ⵜ ⵢⵓⴼⵉⵏ ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵃⴰⵔⵡⴰⵛ ⴰⴽⴻⵛⵛⵓⴹ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU15_34","005_15_34","NUM","15","34","34","ⴳⴳⵉⵏ ⵜ ⴷⵉ ⵜⵃⴻⵟⵟⵓⵜ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴱⵉⵏ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU15_35","005_15_35","NUM","15","35","35","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵜ ⵜⴰⵔⵊⴻⵎ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU15_36","005_15_36","NUM","15","36","36","ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵊⵎⴻⵏ ⵜ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU15_37","005_15_37","NUM","15","37","37","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU15_38","005_15_38","NUM","15","38","38","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ, ⴰⴷ ⴳⴳⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵜⵉⵛⴰⵔⵛⵉⴼⴰ ⵖⴰⵔ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⴷ ⴰⴷⴻⵃⵎⵉ ⵖⴰⵔ ⵜⵛⴰⵔⵛⵉⴼⴰ, ⵜⵉⵏⵏⵉ ⵖⴰⵔ ⵜⵖⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU15_39","005_15_39","NUM","15","39","39","ⴰⴷ ⵢⵉⵍⵉ ⵓⴼⵉⵍⵓ ⵖⴰⵔ ⵜⵛⴰⵔⵛⵉⴼⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵍⴰⵎ ⴰⴼⵉⵍⵓ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⵉⴷⴰⵔⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ ⵓ ⵡⴰⵔ ⵜⴹⴻⴼⴼⴰⵔⴻⵎ ⵛⵛⴻⵀⵡⴰⵜ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ ⵜⴻⵏⵏⵓⵎⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⴼⵙⴻⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("NU15_40","005_15_40","NUM","15","40","40","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵅⴰⵔⵔⵚⴻⵎ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵎ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU15_41","005_15_41","NUM","15","41","41","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("NU16_1","005_16_1","NUM","16","1","1","ⵇⵓⵔⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵢⵉⵚⵀⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵀⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ, ⴰⴽ-ⴷ ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵍⵉⵢⴰⴱ, ⴷ ⵓⵏ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵍⴰⵜ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⵓⴱⵉⵏ, ⵉⵡⵢⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU16_2","005_16_2","NUM","16","2","2","ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵓⵎⵓⵏⵉ, ⵉⵔⵢⴰⵣⴻⵏ ⵙ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_3","005_16_3","NUM","16","3","3","ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵛⴼⴰ ⴰⵡⴻⵎ ⴽⴻⵏⵏⵉⵡ! ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓⵛⴰ ⵙⵉⴷⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⵓⵄⵍⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("NU16_4","005_16_4","NUM","16","4","4","ⵓⵎⵉ ⵉⵙⵍⴰ ⵎⵓⵙⴰ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵡⴹⴰ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU16_5","005_16_5","NUM","16","5","5","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵇⵓⵔⴰⵃ ⴷ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ ⵖⴰ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ. ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣ ⵏⴻⵜⵜⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU16_6","005_16_6","NUM","16","6","6","ⴳⴳⴻⵎ ⴰⵢⴰ! ⴻⵊⵊ ⵇⵓⵔⴰⵃ ⴷ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⵉⵎⴻⵊⵎⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_7","005_16_7","NUM","16","7","7","ⵜⵉⵡⴻⵛⵛⴰ ⴳⴳⴻⵎ ⵅⴰⵙⴻⵏⵜ ⵍⴻⴼⵃⴻⵎ ⵉ ⵜⵎⴻⵙⵙⵉ, ⵙⴰⵔⵙⴻⵎ ⵅⴰⵙ ⵍⴻⴱⵅⵓⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ. ⴰⵇⴰ ⵜⵔⵓⵃⴻⵎ ⵜⵉⴳⴳⵯⵉⵊⴻⵎ, ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ!” ");
INSERT INTO rift_vpl VALUES ("NU16_8","005_16_8","NUM","16","8","8","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵇⵓⵔⴰⵃ: “ⵙⵍⴻⵎ ⵍⴻⵅⵅⵓ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ, ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ! ");
INSERT INTO rift_vpl VALUES ("NU16_9","005_16_9","NUM","16","9","9","ⵎⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵛⴼⵉ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴼⴰⵔⵣ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("NU16_10","005_16_10","NUM","16","10","10","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵉ ⵛⴻⴽ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵛ, ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵊⵎⵉⵄ ⴰⴽⵉⴷⴻⴽ. ⵎⴰ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵍⴻⵅⵅⵓ ⵄⴰⵡⴻⴷ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("NU16_11","005_16_11","NUM","16","11","11","ⵙ ⵓⵢⴰ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵎⵓⵏⴻⵎ ⴹⵉⴷⴷ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵄⵏⴰ ⵀⴰⵔⵓⵏ, ⵎⵉⵏ ⵉⵄⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⵏⵏⴻⴷⵇⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("NU16_12","005_16_12","NUM","16","12","12","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ ⴰⴷ ⵍⴰⵖⴰⵏ ⵅ ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵍⵉⵢⴰⴱ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵡⴰⵔ ⴷⴷ-ⵏⴻⵜⵜⵉⵙ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU16_13","005_16_13","NUM","16","13","13","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉⵛⴼⴰ ⴰⵡⴻⵎ ⵓⵎⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⵙⵙⵓⴼⴼⵖⴻⵎ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵀⴻⵍⵍⴻⴽⴻⴷ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅⴰⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("NU16_14","005_16_14","NUM","16","14","14","ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵛⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵛⵉⴷ ⵉⵢⵢⴰⵔⴻⵏ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴷ ⵍⵡⴰⵔⵜ. ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴷⴰⵖⵍⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ? ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴷⴷ-ⵏⴻⵜⵜⵉⵙ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU16_15","005_16_15","NUM","16","15","15","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵓⴼⵓⴳⴻⵎ ⵏ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ ⵉ ⵙⵉⴷⵉ: “ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ! ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⴽⴻⵙⵙⵉⵖ ⵇⴰⵄ ⵉⵊⵊ ⵏ ⵓⵖⵢⵓⵍ ⵓⵛⴰ ⵡⴰⵔ ⴳⴳⵉⵖ ⵍⵖⴰⵔ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU16_16","005_16_16","NUM","16","16","16","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵇⵓⵔⴰⵃ: “ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⴻⵛ, ⴰⵙⴻⵎ-ⴷⴷ ⵜⵉⵡⴻⵛⵛⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⵏⵉⵜⵏⵉ, ⴷ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_17","005_16_17","NUM","16","17","17","ⴽⵙⵉⵎ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵊⵊ ⵏ ⵍⵎⴻⵊⵎⴰⵔ, ⴳⴳⴻⵎ ⴷⴰⵢⴻⵙ ⵍⴻⴱⵅⵓⵔ ⵓⵛⴰ ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴽ-ⴷ ⵍⵎⴻⵊⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵛⴻⴽ ⴷ ⵀⴰⵔⵓⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴰⴽ-ⴷ ⵍⵎⴻⵊⵎⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU16_18","005_16_18","NUM","16","18","18","ⵉⴽⵙⵉ ⴽⵓⵍ ⵉⵊⵊ ⵍⵎⴻⵊⵎⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⴳⴳⵉⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵎⴻⵙⵙⵉ ⵓ ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵍⴻⴱⵅⵓⵔ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵓⵍⴰ ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_19","005_16_19","NUM","16","19","19","ⵇⵓⵔⴰⵃ ⵉⵖⴻⵡⵡⴻⵖ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴰⵏ-ⴷⴷ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU16_20","005_16_20","NUM","16","20","20","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU16_21","005_16_21","NUM","16","21","21","“ⵃⴻⵢⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵓⴱⴰⵔⵔⵓ-ⵢⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏ ⵀⴻⵍⵍⴽⴻⵖ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU16_22","005_16_22","NUM","16","22","22","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵎⴰⵔⵔⴰ ⴱⵓⵃⴱⴻⵍⴰⵜ ⵏ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ! ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("NU16_23","005_16_23","NUM","16","23","23","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU16_24","005_16_24","NUM","16","24","24","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵉⵏⵉ: ‘ⴱⴻⵄⵄⴷⴻⵎ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵇⵓⵔⴰⵃ ⴷ ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ ⴷ ⵎⵉⵏ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("NU16_25","005_16_25","NUM","16","25","25","ⵅⴻⵏⵏⵉ ⵎⵓⵙⴰ ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵔⵓⵃ ⵖⴰⵔ ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU16_26","005_16_26","NUM","16","26","26","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵉⵏⵏⴰ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴱⴻⵄⵄⴷⴻⵎ ⵅ ⵉⵇⵉⴹⴰⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ ⵉⵇⴻⵊⵃⴻⵏ ⵓ ⵡⴰⵔ ⵜⵜⵃⴰⴷⴰⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⵉⴽⴻⵎ ⵛⴰ ⵙ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU16_27","005_16_27","NUM","16","27","27","ⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⴱⴻⵄⵄⴷⴻⵏ ⵅ ⵉⵇⵉⴹⴰⵏ ⵏ ⵇⵓⵔⴰⵃ ⴷ ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ ⴷ ⵎⵉⵏ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ ⴼⴼⵖⴻⵏ-ⴷⴷ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_28","005_16_28","NUM","16","28","28","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ-ⵢⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏⵜ ⵛⴰ ⵣⴻⴳ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("NU16_29","005_16_29","NUM","16","29","29","ⵎⴰⵍⴰ ⵉⵏⴰ ⴰⴷ ⵎⵎⵜⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⵎⵓⵜⴻⵏ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵍⵇⴻⴼ ⵎⵉⵏ ⵉⵍⴻⵇⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("NU16_30","005_16_30","NUM","16","30","30","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵅⵍⴻⵇ-ⴷⴷ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵎⴰⵢⵏⵓⵜ ⵇⴰⵄ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵏ ⵜⵙⴰⵔⴹ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵀⵡⴰⵏ ⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⴰⵇⴰ ⵙⵙⴷⵓⵇⵇⵣⴻⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("NU16_31","005_16_31","NUM","16","31","31","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵜⴼⴻⴵⴻⵇ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_32","005_16_32","NUM","16","32","32","ⵜⴰⵔⵣⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵙⴰⵔⴹ ⵉ-ⵜⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏ ⵇⵓⵔⴰⵃ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU16_33","005_16_33","NUM","16","33","33","ⵀⵡⴰⵏ-ⴷⴷ ⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵙⵙⴷⵓⵔⵉⵢ ⵉ-ⵜⴻⵏ ⵓ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("NU16_34","005_16_34","NUM","16","34","34","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⴰⵔⴻⵡⵍⴻⵏ ⵓⵎⵉ ⵙⵍⵉⵏ ⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵏⴰⵏ: “ⵏⵉⵖ ⴰⴷ ⵜⴰⴼ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵏⴻⵖ ⵜⵚⴰⵔⴹ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU16_35","005_16_35","NUM","16","35","35","ⵓⵛⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵙⵉⴷⵉ, ⵜⴻⵛⵛⴰ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU17_1","005_17_1","NUM","17","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU17_2","005_17_2","NUM","17","2","2","“ⵉⵏⵉ ⵉ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ, ⴱⴻⵍⵍⵉ ⴰⴷ ⵉⴽⵙⵉ ⵜⵉⵎⴻⵊⵎⴰⵔⵉⵏ ⵣⴻⴳ ⵓⵃⴰⴷⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓⵢⴻⵙ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵉⵎⴻⵊⵎⴰⵔⵉⵏ ⵏⵏⵉ, ⵇⴻⴷⴷⵙⴻⵏⵜ ⵉ ⴵⴰⵏⵜ! ");
INSERT INTO rift_vpl VALUES ("NU17_3","005_17_3","NUM","17","3","3","ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵣⵉ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⴻⵟⵟⴰⵏ ⴹⵉⴷⴷ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵙⴻⵏ, ⵜⵉⵍⵡⵉⵃⵉⵏ ⴷ ⵜⵉⵣⵉⵔⴰⵔⵉⵏ ⵉ ⴷⴷⵓⵔⵉ ⵉ ⵓⵄⴰⵍⵟⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵙ ⵓⵢⴰ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏⵜ ⵜⵉⵏⴰ. ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵛⴻⵢⵢⴰⵔ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU17_4","005_17_4","NUM","17","4","4","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵜⵉⵎⴻⵊⵎⴰⵔⵉⵏ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ ⵉ ⵜⴻⵡⵀⵉⴱⵜ, ⵓⵛⴰ ⵜⴽⴻⵜⴽⴻⵏ ⵜⴻⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴷⵍⴻⵏⵜ ⴰⵄⴰⵍⵟⴰⵔ ");
INSERT INTO rift_vpl VALUES ("NU17_5","005_17_5","NUM","17","5","5","ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵀⴰⵔⵓⵏ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⵉⴱ ⵛⴰ ⴱⵍⴰ ⵜⵜⴻⵙⵔⵉⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵍⴻⴱⵅⵓⵔ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵍⵇⴻⴼ ⵎⵉⵏ ⵉⵍⴻⵇⴼⴻⵏ ⵇⵓⵔⴰⵃ ⴷ ⵓⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU17_6","005_17_6","NUM","17","6","6","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜᵉⵜⵜⵏⴻⴷⵇⴰⵎ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵏⵏⴰⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⵖⵉⵎ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("NU17_7","005_17_7","NUM","17","7","7","ⵓⵛⴰ ⵓⵎⵉ ⵜⵎⵓⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⴱⴷⴰⵏ ⵏⵉⵜⵏⵉ ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⴻⵢⵏⵓ ⵏⵏⵉ ⵜ ⵉⴷⵍⵉⵏ ⵓⵛⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU17_8","005_17_8","NUM","17","8","8","ⵢⵓⵙⴰ-ⴷⴷ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ, ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU17_9","005_17_9","NUM","17","9","9","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU17_10","005_17_10","NUM","17","10","10","“ⴽⴽⴰⵔⴻⵎ, ⴰⴳⴳⵯⴻⵊⴻⵎ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵎⵃⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ!” ⵅⴻⵏⵏⵉ ⵡⴹⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU17_11","005_17_11","NUM","17","11","11","ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵀⴰⵔⵓⵏ: “ⴽⵙⵉ ⴷⴻⵖⵢⴰ ⵉⵊⵊ ⵏ ⵍⵎⴻⵊⵎⴰⵔ, ⴻⴳⴳ ⵅⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵙⴰⵔⵙ ⵅⴰⵙ ⵍⴻⴱⵅⵓⵔ. ⴰⵣⵣⴻⵍ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓⵛⴰ ⴻⴳⴳ ⴰⵚⵍⴰⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ ⴷⴰ ⵊⵊⵔⵉⵃⴻⵛⵜ ⴰⵎ ⵜⴻⴱⴷⴰ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("NU17_12","005_17_12","NUM","17","12","12","ⵉⴽⵙⵉ ⵀⴰⵔⵓⵏ ⵍⵎⴻⵊⵎⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵎⵓⵙⴰ, ⵓⵛⴰ ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵊⵊⵔⵉⵃⴻⵛⵜ ⵜⵓⵖⴰ ⴰⵎ ⵜⴻⴱⴷⴰ ⵄⴰⴷ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⴷⴰⵢⴻⵙ ⵍⴻⴱⵅⵓⵔ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵚⵍⴰⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("NU17_13","005_17_13","NUM","17","13","13","ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵊⴰⵔ ⵉⵎⴻⵜⵜⴰⵏ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵊⵊⵔⵉⵃⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("NU17_14","005_17_14","NUM","17","14","14","ⵡⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵣⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴱⴻⵄⵟⴰⵛ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ, ⴱⵍⴰ ⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵇⵓⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("NU17_15","005_17_15","NUM","17","15","15","ⵉⴷⵡⴻⵍ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵎⵓⵙⴰ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵊⵊⵔⵉⵃⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("NU17_16","005_17_16","NUM","17","16","16","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU17_17","005_17_17","NUM","17","17","17","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴽⵙⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵉ ⴽⵓⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵄⴰⴷⴰⴷ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵜᵉⵖⵖⴰⵔⵢⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴰⵔⵉⴷ ⵉⵙⴻⵎ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵅ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU17_18","005_17_18","NUM","17","18","18","ⴰⴷ ⵜⴰⵔⵉⴷ ⵉⵙⴻⵎ ⵏ ⵀⴰⵔⵓⵏ ⵅ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏ ⵍⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU17_19","005_17_19","NUM","17","19","19","ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵣⵣⴰⵜ ⵉ ⵛⵛⵀⴰⴷⴻⵜ, ⵎⴰⵏⵉ ⴽⵉⴷⵡⴻⵎ ⵖⴰ ⵎⵙⴰⴳⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NU17_20","005_17_20","NUM","17","20","20","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵜⵏⵓⵡⵡⴰⵔ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵓⵛⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⴰⵏⴻⴷⵇⴻⵎ ⴹⵉⴷⴷ ⵉⵏⵓ ⵉ ⵣⵉ ⵅⴰⵡⴻⵎ ⵏⵏⴷⴻⵇⵎⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU17_21","005_17_21","NUM","17","21","21","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ ⵡⵛⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵉ ⵎⴽⵓⵍ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⴻⵖⵖⴰⵔⵢⴻⵏ. ⵓⵛⴰ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⵀⴰⵔⵓⵏ ⵜⵓⵖⴰ-ⵜ ⵊⴰⵔ ⵜᵉⵖⵖⴰⵔⵢⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU17_22","005_17_22","NUM","17","22","22","ⵎⵓⵙⴰ ⵉⵙⵙⴰⵔⵙ ⵜⵉⵖⵖⴰⵔⵢⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU17_23","005_17_23","NUM","17","23","23","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵢⵓⴷⴻⴼ ⵎⵓⵙⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⵀⴰⵔⵓⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴰⵡⵉ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵜⴰⵛⵍⴰⵍⵜ ⵓⵛⴰ ⵜⴰⵄⴻⴱⴱⵓⵣⵜ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵓⵛⴰ ⵏⵏⵓⵡⵡⴰⵔ ⵏⵏⴻⵙ ⵢⴰⵔⵣⴻⵎ ⵓⵛⴰ ⵢⵉⵡⵉ-ⴷⴷ ⴵⵓⵣ ⵢⵉⵡⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU17_24","005_17_24","NUM","17","24","24","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵖⴰⵔⵢⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵥⵔⵉⵏ ⴰⵢⴰ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU17_25","005_17_25","NUM","17","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴰⵔⵔ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⵀⴰⵔⵓⵏ ⵣⵣⴰⵜ ⵉ ⵛⵛⵀⴰⴷⴻⵜ, ⴰⴷ ⵜⵜ ⵜⴻⵃⴹⵉⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵢⵢⴰⵔ ⴹⵉⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⴰⵏⴻⴷⵇⴻⵎ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU17_26","005_17_26","NUM","17","26","26","ⵓⵛⴰ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("NU17_27","005_17_27","NUM","17","27","27","ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴰⴷ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴼⴼⴻⵖ ⴱⵓⵃⴱⴻⵍ, ⴰⴷ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ, ⴰⴷ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("NU17_28","005_17_28","NUM","17","28","28","ⵎⴰⵏ ⵡⴻⵏ ⵎⴰ ⵉ ⴷⴷ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵎⵎⴻⵜ. ⵎⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵜⴻⵃⵃⴰ ⴰⵍ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴼⴼⴻⵖ ⴱⵓⵃⴱⴻⵍ?” ");
INSERT INTO rift_vpl VALUES ("NU18_1","005_18_1","NUM","18","1","1","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵀⴰⵔⵓⵏ: “ⵛⴻⴽ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵛ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⴰⴽⵉⴷⴻⴽ, ⴰⴷ ⵜⴰⵔⴱⵓⵎ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵡⴻⵎ. ⵛⴻⴽ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU18_2","005_18_2","NUM","18","2","2","ⴰⴷ ⴷⴷ-ⵜⵉⵡⵢⴻⴷ ⴰⴽⵉⴷⴻⴽ ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵛ, ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ, ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴱⴰⴱⴰⵛ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵖⴰⵔⴻⴽ, ⴰⴷ ⴰⵛ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU18_3","005_18_3","NUM","18","3","3","ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⴰⵇⵉⴹⵓⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵍⴻⵇⵛⵓⵄ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜᵉⵜⵜⵎⴻⵜⵜⵉⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("NU18_4","005_18_4","NUM","18","4","4","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵖⴰⵔⴻⴽ ⵓⵛⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵅ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵜⵜⴻⵙⵔⵉⵃ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU18_5","005_18_5","NUM","18","5","5","ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴰⵛⴱⴰⵔ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵄⴰⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU18_6","005_18_6","NUM","18","6","6","ⵏⴻⵛⵛ, ⴰⵇⴰ ⴷⴰ ⵏⴻⵛⵛ, ⴽⵙⵉⵖ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵡⴻⵎ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵣⵉ ⵊⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵡⴻⵀⵀⴱⴻⵎ ⵉ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU18_7","005_18_7","NUM","18","7","7","ⵎⴰⵛⴰ ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏⵡⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵏⴻⵏ ⴰⴽ-ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵓⵛⴰ ⴰⵎⵎⵓ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ. ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU18_8","005_18_8","NUM","18","8","8","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ: “ⵏⴻⵛⵛ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⴰⵃⴻⵟⵟⵓ ⵅ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵏⴻⵛⵛ. ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵜⴻⵏⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵅ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⴷⵀⴰⵏ, ⵉ ⵛⴻⴽ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵛ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NU18_9","005_18_9","NUM","18","9","9","ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉⵣⵉⵢⵏⴰⵜ ⵉ ⵡⴰⵔ ⵢⵓⴷⵉⴼⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵉ ⵛⴻⴽ: ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⴰⵎ ⵜⴻⵅⵔⵉⵚⵜ. ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵇⴰⵄ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NU18_10","005_18_10","NUM","18","10","10","ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ. ⴽⵓⵍ ⴰⵡⵜⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ. ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("NU18_11","005_18_11","NUM","18","11","11","“ⵄⴰⵡⴻⴷ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵛⴻⴽ: ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵡⵛⵉⵖ ⵜⴻⵏⵜ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⴰⵔⵔⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⴽⵉⴷⴻⴽ ⵉⴵⴰⵏ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵢⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("NU18_12","005_18_12","NUM","18","12","12","“ⵎⵉⵏ ⵉⴵⴰⵏ ⵍⴻⵎⵅⴻⵢⵢⴰⵔ ⵏ ⵣⵣⴻⵛⵜ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵍⴻⵎⵅⴻⵢⵢⴰⵔ ⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵓ ⵣⴻⴳ ⵉⵔⴷⴻⵏ, ⴰⵇⴰ ⴷ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵡⵛⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵡⵛⵉⵖ ⴰⵛ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("NU18_13","005_18_13","NUM","18","13","13","ⵜⴰⵎⴻⵏⵣⵓⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵛⴻⴽ. ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("NU18_14","005_18_14","NUM","18","14","14","“ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵢⵉⵍⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NU18_15","005_18_15","NUM","18","15","15","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴰⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵙⵓⵎ ⵉ ⵖⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⵣⵉ ⵍⴻⴱⵀⵉⵎⴻⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵏⵏⴻⵛ. ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴼⴷⵉⴷ ⵇⴰⵄ ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵡⴷⴰⵏ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⴻⴼⴷⵉⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU18_16","005_18_16","NUM","18","16","16","ⵡⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰ ⵜⵜⵡⴰⴼⴷⵉⵏ ⵏⵉⵜⵏⵉ, ⴰⴷ ⵜⵜⵡⴰⴼⴷⵉⵏ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⵉⵎⴻⵜ ⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⴷⵉ ⵏⵏⵓⵇⴰⵔⵜ, ⵅⴻⵎⵙⴰ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵉⵇⵍⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵄⵉⵛⵔⵉⵏ ⵊⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU18_17","005_18_17","NUM","18","17","17","ⵎⴰⵛⴰ ⴰⵎⴻⵏⵣⵓ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷ ⵓⵎⴻⵏⵣⵓ ⵏ ⵓⵃⵓⵍⵉ ⴷ ⵓⵎⴻⵏⵣⵓ ⵏ ⵉⵖⴰⵢⴹ, ⵡⴰⵔ ⵜ ⵜⴼⴻⴷⴷⵉⵎ ⵛⴰ. ⴰⵇⴰ ⴰⵜⴻⵏ ⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴵⴰⵏ. ⴰⴷ ⵜⵣⴻⴵⵄⴻⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵜⴰⴷⵓⵏⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴻⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU18_18","005_18_18","NUM","18","18","18","ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵏⵏⴻⵛ, ⴰⵎ ⵢⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⴰⵎ ⵓⵛⴻⴽⵔⵓⴷ ⴰⴼⵓⵙⵉ ⴰⴷ ⵉⵍⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NU18_19","005_18_19","NUM","18","19","19","ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵖⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵙⵉⴷⵉ, ⵡⵛⵉⵖ ⵜⴻⵏⵜ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⴵⴰⵏ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵙ ⵍⴻⵎⵍⴰⵃⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⴵⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU18_20","005_18_20","NUM","18","20","20","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵀⴰⵔⵓⵏ: “ⵡⴰⵔ ⵜᵉⵜⵜᵉⵟⵟⴼⴻⴷ ⵍⵡⴰⵔⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜᵉⵜⵜⵉⵍⵉ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU18_21","005_18_21","NUM","18","21","21","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵉ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵛⵓⵔ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴷ ⵍⵡⴰⵔⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ, ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU18_22","005_18_22","NUM","18","22","22","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⵉⴱⴻⵏ ⵄⴰⴷ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵡⵢⴻⵏ ⴰⵎⵎⵓ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵎⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU18_23","005_18_23","NUM","18","23","23","ⵎⴰⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜᵉⵟⵟⴼⴻⵏ ⵍⵡⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("NU18_24","005_18_24","NUM","18","24","24","ⵎⵉⵏⵣⵉ ⵍⴻⵄⵛⵓⵔ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵙⵉⴷⵉ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵡⵛⵉⵖ ⵜⴻⵏ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⵅ ⵓⵢⴰ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: ⵡⴰⵔ ⵡⴰⵔⵔⵜⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("NU18_25","005_18_25","NUM","18","25","25","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU18_26","005_18_26","NUM","18","26","26","“ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⵅⵎⵉ ⵜⴻⴽⵙⵉⵎ ⵍⴻⵄⵛⵓⵔ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵡⵛⵉⵖ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⵡⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ, ⵍⴻⵄⵛⵓⵔ ⵣⵉ ⵍⴻⵄⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU18_27","005_18_27","NUM","18","27","27","ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⴰⵎ ⵢⵉⵔⴷⴻⵏ ⵏ ⵓⵏⴻⴷⵔⴰⵔ ⵓ ⴰⵎ ⵜⴻⵛⵛⵓⵔⴻⵜ ⵏ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU18_28","005_18_28","NUM","18","28","28","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵛⵓⵔ ⵏⵡⴻⵎ ⵏⵏⵉ ⵖⴰ ⵜⴻⴽⵙⵉⵎ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ, ⵜⴻⵏⵏⵉ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU18_29","005_18_29","NUM","18","29","29","ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵏ, ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵓⵏ ⵉ ⵙⵉⴷⵉ, ⵣⵉ ⵍⴻⵎⵅⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ, ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("NU18_30","005_18_30","NUM","18","30","30","ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⵎ: ‘ⵎⴰⵍⴰ ⵜⴻⴽⵙⵉⵎ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵎⵅⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴰⵢⴰ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵏⴻⴷⵔⴰⵔ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU18_31","005_18_31","NUM","18","31","31","ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⴰ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ, ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴰ ⴷ ⵍⵎⵓⵏⴻⵜ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵡⴻⵎ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU18_32","005_18_32","NUM","18","32","32","ⵎⴰⵍⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⵙⵉⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵃⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⴰⵔⴻⴱⴱⵓⵎ ⴷⴷⴻⵏⴱ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴼⴻⵙⴷⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("NU19_1","005_19_1","NUM","19","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU19_2","005_19_2","NUM","19","2","2","“ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵉⵏⵏⴰ: ‘ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ ⵜⴰⵣⴻⴳⴳⵯⴰⵖⵜ, ⵜⴻⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵓ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵓⵏⴻⵄⴹⴰⴱ ⵓⵛⴰ ⵡⴰⵔ ⵅⴰⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵄⴰⴷ ⴰⵣⴰⵢⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("NU19_3","005_19_3","NUM","19","3","3","ⴰⴷ ⵜⵜ ⵜⴻⵡⵛⴻⵎ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⴰⴷ ⴰⵙ ⵖⴰⵔⵚⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU19_4","005_19_4","NUM","19","4","4","ⴰⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴰⴷ ⵉⴽⵙⵉ ⵛⵡⴰⵢⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵔⵓⵛⵛ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵛⵡⴰⵢⵜ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU19_5","005_19_5","NUM","19","5","5","ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴰⴼⵓⵏⴰⵙⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵜⵉⵍⵎⴻⵛⵜ ⵏⵏⴻⵙ, ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵎⴻⵙⵙⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU19_6","005_19_6","NUM","19","6","6","ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵜⵄⴻⵍⴵⴻⵜ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵏⴹⴰⵔ ⴰⵢⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵛⵎⴻⴹ ⵜⴼⵓⵏⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("NU19_7","005_19_7","NUM","19","7","7","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ. ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU19_8","005_19_8","NUM","19","8","8","ⴷ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵙⵙⵛⴻⵎⴹⴻⵏ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU19_9","005_19_9","NUM","19","9","9","ⴰⵔⵢⴰⵣ ⴰⵎⴻⵣⴷⴰⴳ ⴰⴷ ⵉⵢⵔⵓ ⵉⵖⵖⴻⴹ ⵏ ⵜⴼⵓⵏⴰⵙⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⴳⴳ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵣⴷⵉⴳ. ⴰⵇⴰ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵃⴹⴰ ⵅ ⵡⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵉ ⵓⵙⵉⵣⴷⴻⴳ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("NU19_10","005_19_10","NUM","19","10","10","ⵡⴻⵏⵏⵉ ⵉⵢⵔⵓⵏ ⵉⵖⵖⴻⴹ ⵏ ⵜⴼⵓⵏⴰⵙⵜ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ⴰⵇⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("NU19_11","005_19_11","NUM","19","11","11","“ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⵛⴰ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵛⴰ ⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU19_12","005_19_12","NUM","19","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴽⴽⵉⵙ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⵣⴷⵉⴳ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("NU19_13","005_19_13","NUM","19","13","13","ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵃⴰⴷⴰⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵎⵎⵓⵜ, ⵓⵛⴰ ⵡⴰⵔ ⵉⴽⴽⵉⵙ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ. ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵅⴰⵙ ⵣⵣⵓⵣⴰⵔⴻⵏ ⵛⴰ ⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⵅⴰⵙ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("NU19_14","005_19_14","NUM","19","14","14","“ⵡⴰ ⴷ ⴰⵣⴻⵔⴼ ⵅ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⵉ ⵓ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU19_15","005_19_15","NUM","19","15","15","ⵄⴰⵡⴻⴷ ⴽⵓⵍ ⵍⵇⴻⵛⵄⴻⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵡⴰⵔ ⵅⴰⵙ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵜⴻⵇⵇⴻⵏ ⵙ ⵜⴻⵙⵖⵓⵏⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵅⵎⴻⵊ, ");
INSERT INTO rift_vpl VALUES ("NU19_16","005_19_16","NUM","19","16","16","ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵃⴰⴷⴰⵏ ⵃⴻⴷ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵏⵉⵖ ⵛⴰ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵏⵉⵖ ⵉⵖⵙⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⵏⴹⴻⵍ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU19_17","005_19_17","NUM","19","17","17","ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵅⵎⵓⵊ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵙⵉⵏ ⵛⵡⴰⵢⵜ ⵏ ⵉⵖⵖⴻⴹ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉⵛⴻⵎⴹⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵙⵙⴼⴰⵔⵔⵖⴻⵏ ⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NU19_18","005_19_18","NUM","19","18","18","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⴰⴷ ⵉⴽⵙⵉ ⵜⵄⴻⵍⴵⴻⵜ, ⴰⴷ ⵜⵜ ⵉⵙⵙⵓⴼ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵉⵔⵓⵛⵛ ⵅ ⵓⵇⵉⴹⵓⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵓ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵅ ⵡⵉ ⵉⵃⴰⴷⴰⵏ ⵉⵖⵙⴰⵏ ⵏⵉⵖ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵏⵉⵖ ⵛⴰ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵏⵉⵖ ⵛⴰ ⵏ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NU19_19","005_19_19","NUM","19","19","19","ⴰⵎⴻⵣⴷⴰⴳ ⴰⴷ ⵉⵔⵓⵛⵛ ⵅ ⵓⵎⴻⵅⵎⵓⵊ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵅⴰⵙ ⵉⵔⵓⵛⵛ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵅⴰⵙ ⵉⴽⴽⴻⵙ ⴷⴷⴻⵏⴱ. ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⴻⴳ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU19_20","005_19_20","NUM","19","20","20","ⴰⵔⵢⴰⵣ ⵉⵅⴻⵎⵊⴻⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉⵏ ⴰⴷ ⵉⴽⴽⴻⵙ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵅⴰⵙ ⵔⵓⵛⵛⴻⵏ ⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ, ⴰⵇⴰ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("NU19_21","005_19_21","NUM","19","21","21","ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵏⵉⵜⵏⵉ. ⵡⴻⵏⵏⵉ ⵉⵔⵓⵛⵛⴻⵏ ⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓ ⵡⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU19_22","005_19_22","NUM","19","22","22","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⴷⴰⵏ ⵣⴻⴳ ⵓⵎⴻⵅⵎⵓⵊ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ, ⵓⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU20_1","005_20_1","NUM","20","1","1","ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵉⵡⴻⴹ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ. ⵍⴳⴻⵏⵙ ⵉⵇⵇⵉⵎ ⴷⵉ ⵇⴰⴷⴰⵛ. ⴷⵉⵏ ⵉ ⵜⴻⵎⵎⵓⵜ ⵎⴰⵔⵢⴰⵎ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜⵜ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU20_2","005_20_2","NUM","20","2","2","ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⵛⴰ ⴰⵎⴰⵏ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ. ⵅⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU20_3","005_20_3","NUM","20","3","3","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⵎⵛⵓⴱⴱⴻⵛ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵏⵏⴰⵏ: “ⵎⵍⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴼⴼⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴼⴼⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("NU20_4","005_20_4","NUM","20","4","4","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵎⵜⴻⵏ ⴷⵉⵏ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("NU20_5","005_20_5","NUM","20","5","5","ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⴻⵙⵙⵉⵍⵢⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ ⴰⵄⴻⴼⴼⴰⵏ? ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵡⴰⵔ ⴷⵉⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵉⵖ ⵜⴰⵣⴰⵔⵜ ⵏⵉⵖ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵉⵖ ⴰⵔⴻⵎⵎⴰⵎ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU20_6","005_20_6","NUM","20","6","6","ⵅⴻⵏⵏⵉ ⵢⵉⵡⴻⴹ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵀⴰⵔⵓⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵛⴰ ⵡⴹⴰⵏ ⵅ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⴱⴰⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU20_7","005_20_7","NUM","20","7","7","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU20_8","005_20_8","NUM","20","8","8","“ⴽⵙⵉ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵓⵛⴰ ⵙⵎⵓⵏ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ, ⵛⴻⴽ ⴷ ⵀⴰⵔⵓⵏ, ⵓⵎⴰⵛ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴰⴽ-ⴷ ⵜⴻⵚⴹⴰⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵡⵛ ⴰⵎⴰⵏ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⴰⵎⴰⵏ ⵉ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵚⴹⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜᵉⵙⵙⴻⵙⵙⵓⴷ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU20_9","005_20_9","NUM","20","9","9","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("NU20_10","005_20_10","NUM","20","10","10","ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵚⴹⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ ⵍⴻⵅⵅⵓ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵏⴻⵙⵙⵓⴼⴼⴻⵖ ⴰⵎⴰⵏ ⵣⵉ ⵜⴻⵚⴹⴰⵔⵜ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("NU20_11","005_20_11","NUM","20","11","11","ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵜⴰ ⵜⴰⵚⴹⴰⵔⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵙ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵜⴻⵙⵡⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU20_12","005_20_12","NUM","20","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ: “ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴻⵛⵍⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵡⴻⵇⵇⴰⵔⴻⵎ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⴷⵉⴼⴻⵎ ⴰⴳⵔⴰⵡ-ⴰ ⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU20_13","005_20_13","NUM","20","13","13","ⵉⵏⴰ ⴰⵇⴰ ⴷ ⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ ⵎⵉⵏ ⵅⴻⴼ ⴰⵔⴻⵣⵣⵓⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵎⵛⵓⴱⴱⵛⴻⵏ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓ ⵎⴰⵏⵉ ⵏⴻⵜⵜⴰ ⵉⴱⴰⵏ-ⴷⴷ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU20_14","005_20_14","NUM","20","14","14","ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵣⵉ ⵇⴰⴷⴰⵛ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ, ⵏⵏⴰⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵉⵙⵔⴰⵉⵍ, ⵓⵎⴰⵛ: ‘ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴰⵔⴰ ⵏⵏⵉ ⵅⴰⵏⴻⵖ ⵉⴽⴽⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NU20_15","005_20_15","NUM","20","15","15","ⴰⵇⴰ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓ ⵜⵓⵖⴰ ⵏⵣⴻⴷⴷⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴳⴳⵉⵏ ⴷⴰⵢⵏⴻⵖ ⵓ ⴷⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU20_16","005_20_16","NUM","20","16","16","ⵏⵍⴰⵖⴰ ⵅ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵖ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵏⴻⵖ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⵉ ⵇⴰⴷⴰⵛ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵊⵊⵉⵀⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NU20_17","005_20_17","NUM","20","17","17","ⴻⵊⵊ ⴰⵏⴻⵖ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⴰⴷ ⵏⴻⵥⵡⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵏⵥⴻⴽⴽⵡⵉ ⵅ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵉⵖ ⵅ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ ⵓ ⵡⴰⵔ ⵏᵉⵙⴻⵙⵙ ⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵏⵓⵜⴻⵏ. ⵅ ⵡⴻⴱⵔⵉⴷ ⵉⴳⴻⵍⵍⴷⴻⵏ ⴰⴷ ⵏⴻⵄⴷⵓ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵏⵃⴻⵢⵢⴻⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⴰⵍ ⵖⴰ ⵏⴻⵄⴷⵓ ⵄⴰⵡⴻⴷ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("NU20_18","005_20_18","NUM","20","18","18","ⵉⵏⵏⴰ ⴰⵙ ⵉⴷⵓⵎ: “ⵡⴰⵔ ⵜⵜⵥⴻⴽⴽⵯⵉⴷ ⵅⴰⴼⵉ, ⵏⵉⵖ ⴰⴽ ⴽⵉⵛ ⵎⵎⵙⴰⴳⴰⵔⴻⵖ ⵙ ⵙⵙⵉⴼ ⴱⴰⵍⴰⴽ!” ");
INSERT INTO rift_vpl VALUES ("NU20_19","005_20_19","NUM","20","19","19","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴰⴷ ⵏⴻⴹⴼⴰⵔ ⴰⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵎⴰⵍⴰ ⴰⴷ ⵙⵡⴻⵖ ⴰⵎⴰⵏ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵜⴻⵏ ⵅⴻⴵⵚⴻⵖ. ⴰⴷ ⵥⵡⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⵉⴹⴰⵔⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU20_20","005_20_20","NUM","20","20","20","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵅⴰⵙ ⵜⵥⴻⴽⴽⵯⵉⴷ!” ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵉⴷⵓⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⵙ ⵉⵎⵙⴰⴳⴰⵔ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU20_21","005_20_21","NUM","20","21","21","ⴰⵎⵎⵓ ⵢⵓⴳⵉ ⵉⴷⵓⵎ ⴰⴷ ⵉⵡⵛ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⵡⴰ ⴰⵢⵎⵉⵔ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵉⵊⵊⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴱⵔⵉⴷ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU20_22","005_20_22","NUM","20","22","22","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵇⴰⴷⴰⵛ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵡⴹⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ, ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU20_23","005_20_23","NUM","20","23","23","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ, ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU20_24","005_20_24","NUM","20","24","24","“ⴰⴷ ⵉⵎⵎⴰⵔⵏⵉ ⵀⴰⵔⵓⵏ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵏⵏⴰⵏⴻⵎ ⵅ ⵍⵓⵎⵓⵔ ⵉⵏⵓ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("NU20_25","005_20_25","NUM","20","25","25","ⴽⵙⵉ ⵀⴰⵔⵓⵏ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ, ⵓⵛⴰ ⴰⵔⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU20_26","005_20_26","NUM","20","26","26","ⵄⴰⵔⵔⴰ ⵀⴰⵔⵓⵏ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵢⴰⵔⴹ ⵉ-ⵜ ⵉ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴽⵙⵉ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU20_27","005_20_27","NUM","20","27","27","ⵎⵓⵙⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ⵓⵍⵢⴻⵏ ⴰⴷⵔⴰⵔ ⵏ ⵀⵓⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU20_28","005_20_28","NUM","20","28","28","ⵎⵓⵙⴰ ⵉⵄⴰⵔⵔⴰ ⵀⴰⵔⵓⵏ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵢⴰⵔⴹ ⵉ-ⵜ ⵉ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ. ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⵀⴰⵔⵓⵏ ⴷⵉⵏ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⴰⴽ-ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU20_29","005_20_29","NUM","20","29","29","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵜⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵀⴰⵔⵓⵏ ⵉⴹⵍⴻⵇ ⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵔⵓⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵀⴰⵔⵓⵏ, ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU21_1","005_21_1","NUM","21","1","1","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⴽⴻⵏⵄⴰⵏⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵔⴰⴷ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵙⵔⴰⵉⵍ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ, ⵉⵎⵎⵏⴻⵖ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU21_2","005_21_2","NUM","21","2","2","ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵜⵄⴰⵔⵔⵏⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵃⴰⵔⵔⵎⴻⵖ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ.” ");
INSERT INTO rift_vpl VALUES ("NU21_3","005_21_3","NUM","21","3","3","ⵙⵉⴷⵉ ⵉⵙⵜⴰⵊⴻⴱ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⴰⵙ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵃⴰⵔⵔⵎⴻⵏ ⵉ-ⵜⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵃⵓⵔⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("NU21_4","005_21_4","NUM","21","4","4","ⵅⴻⵏⵏⵉ ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ, ⵔⵓⵃⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⵓⵛⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ. ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⵚⴱⵉⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("NU21_5","005_21_5","NUM","21","5","5","ⴰⵇⴰ ⵉⵇⴰⵛⴻⵃ ⵍⴳⴻⵏⵙ ⴹⵉⴷⴷ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵎⵓⵙⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵎⵎⴻⵜ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ? ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ ⵡⴻⵖⵔⵓⵎ ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ. ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⵉⵄⵉⴼⴼ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ-ⴰ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU21_6","005_21_6","NUM","21","6","6","ⵅⴻⵏⵏⵉ ⵉⴹⵍⴻⵇ ⵙⵉⴷⵉ ⵉⴼⵉⵖⵔⴰⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⵉ ⵉⵣⴻⵄⴼⴻⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU21_7","005_21_7","NUM","21","7","7","ⵢⵓⵙⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵎⵓⵙⴰ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⴻⵅⴹⴰ, ⵎⵉⵏⵣⵉ ⵏⵇⴰⵛⴻⵃ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓ ⴰⴽⵉⴷⴻⴽ. ⵥⴰⴵ ⵉ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⴽⴽⴻⵙ ⵉⴼⵉⵖⵔⴰⵏ-ⴰ.” ⵅⴻⵏⵏⵉ ⵉⵥⵓⴵ ⵎⵓⵙⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("NU21_8","005_21_8","NUM","21","8","8","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵓⴼⵉⵖⴰⵔ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵓⵛⴰ ⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵃⵏⴰⵛⵜ ⵓⵛⴰ ⵎⴰⵏ ⵡⴻⵏ ⵎⴰ ⵉⵜⵜⵡⴰⵣⴻⵄⴼⴻⵏ ⵓ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵅⵣⴰⵔ, ⴰⴷ ⵉⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU21_9","005_21_9","NUM","21","9","9","ⵓⵛⴰ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵉⵊⵊ ⵏ ⵓⴼⵉⵖⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵜⴻⵃⵏⴰⵛⵜ ⵓⵛⴰ ⵅⵎⵉ ⵉⵣⴻⵄⵄⴻⴼ ⵛⴰ ⵏ ⵓⴼⵉⵖⴰⵔ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵓⴼⵉⵖⴰⵔ ⵏ ⵏⵏⵃⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU21_10","005_21_10","NUM","21","10","10","ⵅⴻⵏⵏⵉ ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵓⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU21_11","005_21_11","NUM","21","11","11","ⵅⴻⵏⵏⵉ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵉ ⵓⴱⵓⵜ, ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⵔⵡⵉⵏⴰⵜ ⵏ ⵄⴰⴱⴰⵔⵉⵎ ⴷⵉ ⵍⴻⵅⵍⴰ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵓ’ⴰⴱ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("NU21_12","005_21_12","NUM","21","12","12","ⵙⵙⴻⵏⵏⵉ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵣⴰⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU21_13","005_21_13","NUM","21","13","13","ⵙⵙⴻⵏⵏⵉ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⴰⵔⵏⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵣⵍⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⴼⴼⴻⵖ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵔⵏⵓⵏ ⴷ ⴰⵢⵎⵉⵔ ⴰⴽ-ⴷ ⵎⵓ’ⴰⴱ, ⵊⴰⵔ ⵎⵓ’ⴰⴱ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_14","005_21_14","NUM","21","14","14","ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⴳⴰⵔⵔⴰⵜ ⵏ ⵙⵉⴷⵉ: “ⵡⴰⵀⵉⴱ ⴷⵉ ⵙⵓⴼⴰ ⴷ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⴰⵔⵏⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("NU21_15","005_21_15","NUM","21","15","15","ⵓ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ, ⴰⵍⴰⵎⵉ ⵎⴻⵢⵢⵍⴻⵏⵜ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵄⴰⵔ, ⴷ ⵜⴻⵏⵏⵉ ⵉⵙⴻⵏⵏⴷⴻⵏ ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵎⵓ’ⴰⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU21_16","005_21_16","NUM","21","16","16","ⵙⵙⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⴱⵉ’ⵔ, ‘ⴰⵏⵓ’. ⵡⴰ ⴰⵇⴰ ⴷ ⴰⵏⵓ ⵎⵉⵏ ⵅⴻⴼ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵙⵎⵓⵏ ⵍⴳⴻⵏⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU21_17","005_21_17","NUM","21","17","17","ⵅⴻⵏⵏⵉ ⵉⵖⴻⵏⵏⴻⵊ ⵉⵙⵔⴰⵉⵍ ⵉⵣⵍⵉ-ⵢⴰ: “ⵏⴳⴻⵣ, ⴰ ⴰⵏⵓ!” ⴰⵔⵔⵉⵎ-ⴷⴷ ⵅⴰⵙ ⵙ ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ: ");
INSERT INTO rift_vpl VALUES ("NU21_18","005_21_18","NUM","21","18","18","“ⵛⴻⴽ ⴰⵏⵓ, ⵡⴻⵏⵏⵉ ⵖⵣⵉⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵡⴻⵏⵏⵉ ⵉⵏⴻⵇⵛⴻⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⴰⴽ-ⴷ ⵓⵎⴳⴻⵡⵡⴰⴷ ⵏⵙⴻⵏ ⵙ ⵉⵣⴻⴵⴰⴹⴻⵏ ⵏⵙⴻⵏ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ.” ⵣⵉ ⵍⴻⵅⵍⴰ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵎⴰⵜⵜⴰⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("NU21_19","005_21_19","NUM","21","19","19","ⵓⵛⴰ ⵣⵉ ⵎⴰⵜⵜⴰⵏⴰ ⵖⴰⵔ ⵏⴰⵃⵍⵉⵢⵉⵍ, ⵣⵉ ⵏⴰⵃⵍⵉⵢⵉⵍ ⵖⴰⵔ ⴱⴰⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("NU21_20","005_21_20","NUM","21","20","20","ⵓⵛⴰ ⵣⵉ ⴱⴰⵎⵓⵜ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵎⵓ’ⴰⴱ, ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⴼⵉⵙⵊⴰ ⵏⵏⵉ ⵉⵜⵜⵙⵉⵊⵊⴰⵏ ⵖⴰⵔ ⵜⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("NU21_21","005_21_21","NUM","21","21","21","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵙⵔⴰⵉⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU21_22","005_21_22","NUM","21","22","22","“ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵛⵓⵇⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵢⵢⵉⵍ ⵛⴰ ⵖⴰⵔ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵉⵖ ⵖⴰⵔ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ ⵓ ⵡⴰⵔ ⵏⵙⴻⵙⵙ ⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵏⵓⵜⴻⵏ. ⴰⴷ ⵏⴻⵄⴷⵓ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⴰⵍ ⵖⴰ ⵏⴻⵄⴷⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("NU21_23","005_21_23","NUM","21","23","23","ⵎⴰⵛⴰ ⵙⵉⵃⵓⵏ ⵡⴰⵔ ⵢⴻⵊⵊⵉ ⴰⴷ ⵉⵥⵡⴰ ⵉⵙⵔⴰⵉⵍ ⵅ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵙ. ⵉⵙⵙⵎⵓⵏ ⵙⵉⵃⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉ ⵢⴰⵀⴰⵚ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU21_24","005_21_24","NUM","21","24","24","ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵡⵜⴰ ⵉ-ⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⴽⵙⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⵡⴰⵔⵜ, ⵣⵉ ⴰⵔⵏⵓⵏ ⴰⵍ ⵢⴰⴱⴱⵓⵇ, ⴰⵍ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵎⵉⵏⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_25","005_21_25","NUM","21","25","25","ⵉⴽⵙⵉ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⴷⵉ ⵃⴰⵛⴱⵓⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_26","005_21_26","NUM","21","26","26","ⵎⵉⵏⵣⵉ ⵃⴰⵛⴱⵓⵏ ⵜⵓⵖⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵣⵡⴰⵔⴻⵏ ⵏ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵉⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴰⵍ ⴰⵔⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_27","005_21_27","NUM","21","27","27","ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ: “ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵃⴰⵛⴱⵓⵏ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴷⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⵉⵃⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("NU21_28","005_21_28","NUM","21","28","28","ⵎⵉⵏⵣⵉ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵃⴰⵛⴱⵓⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵛⵛⴰⵍ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵛⴻⵄⵄⴰⵍ ⵏⵏⵉ ⵉⵛⵛⴰ ⵄⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵓⵄⵍⴰⵜ ⵏ ⴰⵔⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_29","005_21_29","NUM","21","29","29","ⵓⵛⵜ ⵅⴰⴽ, ⵎⵓ’ⴰⴱ! ⴰⵇⴰ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵍⴳⴻⵏⵙ ⵏ ⴽⴰⵎⵓⵛ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵉ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_30","005_21_30","NUM","21","30","30","ⴰⵇⴰ ⵏⴻⵡⵡⴻⵜ ⵉ-ⵜⴻⵏ ⵙ ⴼⵍⵉⵜⵛⴰⵜ. ⵃⴰⵛⴱⵓⵏ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⴰⵍ ⴷⵉⴱⵓⵏ. ⵏⴰⵔⴻⴷⴷⴻⴵ ⵉ-ⵜⴻⵏ ⴰⵍ ⵏⵓⴼⴰⵃ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵍ ⵎⵉⴷⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU21_31","005_21_31","NUM","21","31","31","ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_32","005_21_32","NUM","21","32","32","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ ⵖⴰⵔ ⵢⴰⵄⵣⵉⵔ ⵓⵛⴰ ⴽⵙⵉⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU21_33","005_21_33","NUM","21","33","33","ⵅⴻⵏⵏⵉ ⵎⴻⵢⵢⵍⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ, ⵓⵍⵢⴻⵏ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⴱⴰⵛⴰⵏ. ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵉⵎⵙⴰⴳⴰⵔ ⵉ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵉⴷⵔⴰⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("NU21_34","005_21_34","NUM","21","34","34","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵣⵉ ⵙⵉⵃⵓⵏ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU21_35","005_21_35","NUM","21","35","35","ⵓⵛⴰ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⵍ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵍⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⴽⵙⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU22_1","005_22_1","NUM","22","1","1","ⵅⴻⵏⵏⵉ ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU22_2","005_22_2","NUM","22","2","2","ⵓⵛⴰ ⵉⵥⵔⴰ ⴱⴰⵍⴰⵇ, ⵎⵎⵉⵙ ⵏ ⵚⵉⴼⴼⵓⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU22_3","005_22_3","NUM","22","3","3","ⵎⵓ’ⴰⴱ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⵎⵓ’ⴰⴱ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⵅⵍⴰⵄ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU22_4","005_22_4","NUM","22","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓ’ⴰⴱ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ: “ⵍⴻⵅⵅⵓ ⵍⵖⴰⵛⵉ-ⵢⴰ ⴰⴷ ⵉⵍⵙⴻⵃ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵍⴻⵙⵙⴻⵃ ⵓⴼⵓⵏⴰⵙ ⵜⴰⵣⵉⵢⵣⴰⵡⵜ ⵏ ⵢⴻⵢⵢⴰⵔ.” ⵜⵓⵖⴰ ⴱⴰⵍⴰⵇ, ⵎⵎⵉⵙ ⵏ ⵚⵉⴼⴼⵓⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU22_5","005_22_5","NUM","22","5","5","ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴼⴰⵜⵓⵔ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⴷⴷ-ⵍⴰⵖⴰⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⴷⵍⴰ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵏⵉⵛⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("NU22_6","005_22_6","NUM","22","6","6","ⴰⵙ-ⴷⴷ ⵍⴻⵅⵅⵓ, ⵏⵄⴻⵍ ⵍⴳⴻⵏⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵊⵀⴻⴷ ⵅⴰⴼⵉ. ⴰⴷ ⵜⴰⵖ ⵏⴻⵛⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⵖⴻⵍⴱⴻⵖ ⵏⵉⵖ ⴰⴷ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵡⵉ ⵖⴰ ⵜⴱⴰⵔⴽⴻⴷ ⵛⴻⴽ, ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵓ ⵡⵉ ⵖⴰ ⵜⵏⴻⵄⵍⴻⴷ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU22_7","005_22_7","NUM","22","7","7","ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ ⴰⴽ-ⴷ ⵍⵎⵓⵏⴻⵜ ⵏ ⵓⵄⴻⵣⵣⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴱⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("NU22_8","005_22_8","NUM","22","8","8","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⴻⵏⵙⴻⵎ ⴷⴰ ⴵⵉⵍⴻⵜ-ⴰ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵔⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰⵔⵉ ⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ.” ⵅⴻⵏⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NU22_9","005_22_9","NUM","22","9","9","ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("NU22_10","005_22_10","NUM","22","10","10","ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⴱⴰⵍⴰⴽ, ⵎⵎⵉⵙ ⵏ ⵚⵉⴼⴼⵓⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU22_11","005_22_11","NUM","22","11","11","‘ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⴰⵇⴰ ⵉⴷⵍⴰ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵙ-ⴷⴷ, ⵏⵄⴻⵍ ⵉ-ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ. ⴰⴷ ⵜⴰⵖ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵉⵙⴻⵏ ⵎⴻⵏⵖⴻⵖ ⵏⵉⵖ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("NU22_12","005_22_12","NUM","22","12","12","ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵡⴰⵔ ⵜⵜⵔⵉⵃ ⴽⵉⵙⴻⵏ ⵏⵉⵖ ⴰⴷ ⵜⵏⴻⵄⵍⴻⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⴰⵇⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("NU22_13","005_22_13","NUM","22","13","13","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴱⴰⵍⵄⴰⵎ ⴷⵉ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴱⴰⵍⴰⴽ: “ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵎⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU22_14","005_22_14","NUM","22","14","14","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵍⴰⴽ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⴱⴰⵍⵄⴰⵎ ⵢⵓⴳⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴽⵉⴷⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU22_15","005_22_15","NUM","22","15","15","ⵉⵙⵙⴻⴽⴽ ⴱⴰⵍⴰⴽ ⵄⴰⵡⴻⴷ ⵍⵃⵓⴽⴽⴰⵎ, ⵄⴰⴷ ⴽⵜⴰⵔ ⵓ ⵄⴰⴷ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴽⵜⴰⵔ ⵅ ⵢⵉⵏⴰ ⵉⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU22_16","005_22_16","NUM","22","16","16","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ, ⵏⵏⴰⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴱⴰⵍⴰⴽ, ⵎⵎⵉⵙ ⵏ ⵚⵉⴼⴼⵓⵔ: ‘ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵜⴰⵙⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("NU22_17","005_22_17","NUM","22","17","17","ⵎⵉⵏⵣⵉ ⴰⴷ ⵛⴻⴽ ⴽⴰⵔⵔⵎⴻⵖ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⵉⵏⵉⴷ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⴰⵙ-ⴷⴷ ⵓⵛⴰ ⵏⵄⴻⵍ ⵍⴳⴻⵏⵙ-ⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("NU22_18","005_22_18","NUM","22","18","18","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⵍⴰⴽ: “ⵡⴰⵅⵅⴰ ⴱⴰⵍⴰⴽ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵛⵛⵓⵔ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵄⴰⴷ ⵡⴰⵔ ⵣⵎⵉⵔⴻⵖ ⴰⴷ ⴼⴼⵖⴻⵖ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵏⵉⵖ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU22_19","005_22_19","NUM","22","19","19","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵇⵇⵉⵎⴻⵎ ⴷⴰⵏⵉⵜⴰ ⴵⵉⵍⴻⵜ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵏⵉ ⵙⵉⴷⵉ ⵄⴰⴷ ⴽⵜⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU22_20","005_22_20","NUM","22","20","20","ⴷⵉ ⴵⵉⵍⴻⵜ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵛ ⴷⴷ-ⵍⴰⵖⴰⵏ, ⴽⴽⴰⵔ ⵅⴻⵏⵏⵉ ⵓⵛⴰ ⵔⵓⵃ ⴰⴽⵉⴷⵙⴻⵏ. ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵎⵖⵉⵔ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU22_21","005_22_21","NUM","22","21","21","ⵉⴽⴽⴰⵔ ⴱⴰⵍⵄⴰⵎ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⵉⵃⴻⵣⵣⴻⵎ ⵉ ⵜⴻⵖⵢⵓⵍⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU22_22","005_22_22","NUM","22","22","22","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵔⵓⵃ ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⵎ ⵛⵛⵉⵟⴰⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵏⵢⴰ ⵅ ⵜⴻⵖⵢⵓⵍⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU22_23","005_22_23","NUM","22","23","23","ⵓⵛⴰ ⵜⴰⵖⵢⵓⵍⵜ ⵜⴻⵥⵔⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵊⴻⴱⴷⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴻⵍⵃⴻⵎ ⵜⴻⵖⵢⵓⵍⵜ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵜⵓⵢⵓⵔ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵡⵜⴰ ⴱⴰⵍⵄⴰⵎ ⵜⴰⵖⵢⵓⵍⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵢⴰⵔⵔ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("NU22_24","005_22_24","NUM","22","24","24","ⵎⴰⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⵉⴷⵜ ⵜⴻⵃⵚⴰⵔ ⵊⴰⵔ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU22_25","005_22_25","NUM","22","25","25","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵜⴻⵖⵢⵓⵍⵜ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵍⵚⴻⵇ ⵖⴰⵔ ⵡⴻⵖⴱⴰⵔ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ ⵓⴹⴰⵔ ⵏ ⴱⴰⵍⵄⴰⵎ ⴰⴽ-ⴷ ⵡⴻⵖⴱⴰⵔ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵛⵛⴰⵜ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("NU22_26","005_22_26","NUM","22","26","26","ⵓⵛⴰ ⵉⵔⵓⵃ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵣⵣⴰⵜ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵃⵚⴰⵔ ⴰⵟⵟⴰⵙ ⴰⵍ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵜⵜⴰⵙⵉⵄ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("NU22_27","005_22_27","NUM","22","27","27","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵜⴻⵖⵢⵓⵍⵜ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵜⴱⴰⵔⵛ ⵙⴰⴷⵓ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⴱⴰⵍⵄⴰⵎ ⵉⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⴼⴰⵔⵛ ⵜⴰⵖⵢⵓⵍⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("NU22_28","005_22_28","NUM","22","28","28","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⵙⵉⴷⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵖⵢⵓⵍⵜ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵎⵉⵏ ⴷ ⴰⵛ ⴳⴳⵉⵖ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⴼⴰⵔⵛⴻⴷ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("NU22_29","005_22_29","NUM","22","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵉ ⵜⴻⵖⵢⵓⵍⵜ: “ⵎⵉⵏⵣⵉ ⵛⴻⵎ ⵜⴱⵓⵚⴰⵔⴻⴷ ⵅⴰⴼⵉ. ⵎⵍⵉ ⵖⴰⵔⵉ ⵙⵙⵉⴼ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵏⵏⵉ ⵏⵖⵉⵖ ⵛⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("NU22_30","005_22_30","NUM","22","30","30","ⵜⴻⵏⵏⴰ ⵜⴻⵖⵢⵓⵍⵜ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵎⴰ ⵡⴰⵔ ⴵⵉⵖ ⵏⴻⵛⵛ ⵜⴰⵖⵢⵓⵍⵜ ⵏⵏⴻⵛ ⵉ ⵅⴻⴼ ⵜⴻⵏⵢⵉⴷ ⵣⴻⴳ ⵡⴰⵎⵉ ⵏⴻⵛⵛ ⵖⴰⵔⴻⴽ ⴵⵉⵖ ⴰⵍ ⴰⵙⵙ-ⴰ? ⵎⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⵏⵏⵓⵎⴻⵖ ⵜⵜⴻⴳⴳⴻⵖ ⴰⴽ ⴽⵉⴽ ⴰⵎⵎⵓ?” ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("NU22_31","005_22_31","NUM","22","31","31","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⵙⵉⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴱⴰⵍⵄⴰⵎ ⴰⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵊⴻⴱⴷⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵢⵓⴹⴰⵔ ⴱⴰⵍⵄⴰⵎ, ⵉⴱⴻⵏⴷⴻⵇ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU22_32","005_22_32","NUM","22","32","32","ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵡⵜⵉⴷ ⵜⴰⵖⵢⵓⵍⵜ ⵏⵏⴻⵛ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ? ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴼⴼⵖⴻⵖ-ⴷⴷ ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵉⵎ, ⵎⵉⵏⵣⵉ ⴰⴱⵔⵉⴷ-ⴰ ⵉⵜⵜⴹⴰⵔⵔⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU22_33","005_22_33","NUM","22","33","33","ⵜⴻⵥⵔⴰ ⴰⵢⵉ ⵜⴻⵖⵢⵓⵍⵜ ⵓⵛⴰ ⵜⴻⵍⵃⴻⵎ ⵅⴻⵏⵏⵉ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵍⵃⵉⵎ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵢⵉⵍⵉ ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵏⵖⵉⵖ ⵛⴻⴽ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⵜ ⵊⵊⴻⵖ ⴰⴷ ⵜⴻⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU22_34","005_22_34","NUM","22","34","34","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ: “ⴰⵇⴰ ⵏⴻⵛⵛ ⵅⴹⵉⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⵜⴱⴻⴷⴷⴻⴷ ⵣⵣⴰⵜⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ⵄⴰⴷ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⴰⵢⴰ ⴷ ⵍⵄⵉⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU22_35","005_22_35","NUM","22","35","35","ⵉⵏⵏⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵔⵓⵃ ⴰⴽ-ⴷ ⵉⵡⴷⴰⵏ-ⴰ, ⵎⴰⵛⴰ ⵙⵉⵡⴻⵍ ⵡⴰⵀⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ ⵏⴻⵛⵛ.” ⴰⵎⵎⵓ ⵉⵔⵓⵃ ⴱⴰⵍⵄⴰⵎ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴱⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("NU22_36","005_22_36","NUM","22","36","36","ⵓⵎⵉ ⴱⴰⵍⴰⴽ ⵉⵙⵍⴰ, ⴰⵇⴰ ⴱⴰⵍⵄⴰⵎ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⵔⵓⵃ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵎⵎⴻⵍⵇⴰ ⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵎⵓ’ⴰⴱ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⴰⵔⵏⵓⵏ, ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵢⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("NU22_37","005_22_37","NUM","22","37","37","ⵓⵛⴰ ⴱⴰⵍⴰⴽ ⵉⵏⵏⴰ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵎⴰ ⵡⴰⵔ ⵙⵙⴻⴽⴽⴻⵖ ⵏⴻⵛⵛ ⵉⵡⴷⴰⵏ ⴰⴷ ⴰⵛ ⴷⴷ-ⵍⴰⵖⴰⵏ? ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ? ⵎⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴽⴰⵔⵎⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("NU22_38","005_22_38","NUM","22","38","38","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⴰⵍⵄⴰⵎ ⵅ ⴱⴰⵍⴰⴽ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵎⴰⵛⴰ ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵍⴻⵅⵅⵓ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵛⴰ? ⴰⵡⴰⵍ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⴰⴷ ⵜ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU22_39","005_22_39","NUM","22","39","39","ⵓⵛⴰ ⵉⵔⵓⵃ ⴱⴰⵍⵄⴰⵎ ⴰⴽ-ⴷ ⴱⴰⵍⴰⴽ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵇⴰⵔⵢⴰⵜ-ⵃⴰⵚⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU22_40","005_22_40","NUM","22","40","40","ⵅⴻⵏⵏⵉ ⵉⵖⴰⵔⵚ ⴱⴰⵍⴰⴽ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵡⵓⴵⵉ, ⵉⵙⵙⴻⴽⴽ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔ ⴱⴰⵍⵄⴰⵎ ⵓ ⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU22_41","005_22_41","NUM","22","41","41","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴱⴰⵍⴰⴽ ⵢⵉⵡⵉ ⴰⴽⵉⵙ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵉⵙⵙⵉⵍⵉ ⵉ-ⵜ ⵅ ⵍⵓⵄⵍⴰⵜ ⵏ ⴱⴰⵄⵍ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵥⴰⵔ ⵍⴳⴻⵏⵙ ⴰⵍ ⵟⵟⴰⵔⴼ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("NU23_1","005_23_1","NUM","23","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵉ ⴱⴰⵍⴰⴽ: “ⴱⵏⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⴷⴰⵏⵉⵜⴰ ⵉ ⵏⴻⵛⵛ ⵓⵛⴰ ⵙⴻⵡⵊⴻⴷ ⴰⵢⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU23_2","005_23_2","NUM","23","2","2","ⴱⴰⵍⴰⴽ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⴱⴰⵍⴰⴽ ⴷ ⴱⴰⵍⵄⴰⵎ ⵇⴻⴷⴷⵎⴻⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU23_3","005_23_3","NUM","23","3","3","ⵅⴻⵏⵏⵉ ⴱⴰⵍⵄⴰⵎ ⵉⵏⵏⴰ ⵉ ⴱⴰⵍⴰⴽ: “ⴱⴻⴷⴷ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴽⵉⴷⵉ ⵉⵎⵙⴰⴳⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵉⴳⴳⴰ ⵡⴰⵡⴰⵍ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵙⵛⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⴰⵔⴳⴱⴻⵖ.” ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⴱⴰⵍⵄⴰⵎ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⴷ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU23_4","005_23_4","NUM","23","4","4","ⵓ ⵉⵎⵎⴻⵍⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵙⴻⴱⵄⴰ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵖ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU23_5","005_23_5","NUM","23","5","5","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴷⵡⴻⵍ ⵖⴰⵔ ⴱⴰⵍⴰⴽ ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⴰⵎⵎⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU23_6","005_23_6","NUM","23","6","6","ⵓⵛⴰ ⵓⵎⵉ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵉⴷⵡⴻⵍ, ⵅⵣⴰⵔ, ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵏⴻⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU23_7","005_23_7","NUM","23","7","7","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵉⵇⵇⴰⵔ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉⵡⴻⵣⵏⴻⵏ, ⵉⵏⵏⴰ: “ⵣⵉ ⴰⵔⴰⵎ ⵉⵏⴷⴻⵀ ⴰⵢⵉ-ⴷⴷ ⴱⴰⵍⴰⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵛⵛⴰⵔⵇ, ⵉⵏⵏⴰ: ‘ⴰⵙ-ⴷⴷ, ⵏⵄⴻⵍ ⴰⵢⵉ ⵢⴰⵄⵇⵓⴱ, ⴰⵙ-ⴷⴷ, ⵣⴰⵡⴰⵔ ⵉⵙⵔⴰⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("NU23_8","005_23_8","NUM","23","8","8","ⵎⴰⵛⴰ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵏⴻⵄⵍⴻⵖ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵣⴰⵡⴰⵔⴻⵖ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴰⵡⴰⵔ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("NU23_9","005_23_9","NUM","23","9","9","ⵎⵉⵏⵣⵉ ⵣⵉ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵜⵚⵓⴹⴰⵔ ⵜⵡⴰⵍⵉⵖ ⵜ, ⵓⵛⴰ ⵣⵉ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵅⴻⵣⵣⴰⵔⴻⵖ ⴷⴰⵢⴻⵙ. ⴰⵇⴰ ⵡⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵡⴻⵃⵃⴷⴻⵙ ⵓ ⵡⴰⵔ ⵉⵃⴻⵙⵙⴻⴱ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("NU23_10","005_23_10","NUM","23","10","10","ⵡⵉ ⵖⴰ ⵉⵃⴻⵙⴱⴻⵏ ⴰⵛⴰⵍ ⵏ ⵢⴰⵄⵇⵓⴱ ⵏⵉⵖ ⵡⵉ ⵉ ⵖⴰ ⵉⵃⴻⵙⴱⴻⵏ ⵍⵇⴻⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵣⵉ ⵉⵙⵔⴰⵉⵍ? ⴻⵊⵊ ⴰⴷ ⵉⵎⵎⴻⵜ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵍⵎⴻⵡⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵓ ⴻⵊⵊ ⵄⴰⵡⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⵉⵎⵇⵓⴷⴷⴰ ⴰⴽⵉⴷⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("NU23_11","005_23_11","NUM","23","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⴰⴽ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ? ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ ⵛⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⵜⵏⴻⵄⵍⴻⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⵉⵛⴰⵏ ⵜⴱⴰⵔⴽⴻⴷ ⵉ-ⵜⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("NU23_12","005_23_12","NUM","23","12","12","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵃⴹⵉⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("NU23_13","005_23_13","NUM","23","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⴰⴽ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⴰⴽⵉⴷⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵎⴰⵏⵉⵙ ⵖⴰ ⵜⵥⴰⵔⴻⴷ ⵍⴳⴻⵏⵙ ⵄⴰⵡⴻⴷ. ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵜ ⵜⵥⴰⵔⵔⴻⴷ ⵎⴰⵔⵔⴰ. ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⵏⴻⵄⵍⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("NU23_14","005_23_14","NUM","23","14","14","ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⵍⴻⵡⴹⴰ ⵏ ⵚⵓⴼⵉⵎ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⴼⵉⵙⵊⴰ ⵓⵛⴰ ⵉⴱⵏⴰ ⴷⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵓⵛⴰ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NU23_15","005_23_15","NUM","23","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⴱⴰⵍⴰⴽ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⴷⴰ ⵣⵣⴰⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵛ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⵙ ⵎⵎⵙⴰⴳⴰⵔⴻⵖ ⴷⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU23_16","005_23_16","NUM","23","16","16","ⵓⵛⴰ ⵉⵎⵙⴰⴳⴰⵔ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴷⵡⴻⵍ ⵖⴰⵔ ⴱⴰⵍⴰⴽ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙ ⴰⵎⵎⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU23_17","005_23_17","NUM","23","17","17","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵓ ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵓ’ⴰⴱ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⴻⵙ. ⵉⵏⵏⴰ ⴰⵙ ⴱⴰⵍⴰⴽ: “ⵎⵉⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("NU23_18","005_23_18","NUM","23","18","18","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉⵡⴻⵣⵏⴻⵏ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⴱⴰⵍⴰⴽ, ⵙⵃⴻⵙⵙ! ⵙⴻⵍ ⵖⴰⵔⵉ, ⵛⴻⴽ, ⵎⵎⵉⵙ ⵏ ⵚⵉⴼⴼⵓⵔ! ");
INSERT INTO rift_vpl VALUES ("NU23_19","005_23_19","NUM","23","19","19","ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵣⴻⵄⵎⴰ ⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ, ⵏⵉⵖ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⵣⴻⵄⵎⴰ ⴰⴷ ⵜ ⵉⵍⵇⴻⴼ ⵡⴻⵏⴷⴰⵎ. ⵎⴰ ⴰⴷ ⵢⵉⵏⵉ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⴻⴳⴳ, ⵏⵉⵖ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⴽⴻⵎⵎⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("NU23_20","005_23_20","NUM","23","20","20","ⵅⵣⴰⵔ, ⴰⵇⴰ ⵟⵟⴼⴻⵖ ⵍⵓⵎⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⴽⴻⵖ. ⵓⵎⵉ ⵉⴱⴰⵔⴻⴽ ⵏⴻⵜⵜⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU23_21","005_23_21","NUM","23","21","21","ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⵍⴻⵖⴱⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜ ⵉⵥⴰⵔ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⴰⵙⵓⴹⵉ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⵉ ⵍⴱⵓⵇ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ-ⵜ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU23_22","005_23_22","NUM","23","22","22","ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ⵏⴻⵜⵜⴰ ⵉ ⵏⵉⵜⵏⵉ ⴰⵎ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU23_23","005_23_23","NUM","23","23","23","ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⴰⵄⴻⵣⵣⴻⵎ ⴷⵉ ⵢⴰⵄⵇⵓⴱ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜⴰⴳⴻⵣⵣⴰⵏⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵜⴰ ⴷ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵏⵏⴰ ⵅ ⵢⴰⵄⵇⵓⴱ ⴷ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵇⴰ ⵅⵣⴰⵔ, ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ!’ ");
INSERT INTO rift_vpl VALUES ("NU23_24","005_23_24","NUM","23","24","24","ⴰⵇⴰ ⴷⴰ, ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⴽⴽⴰⵔ ⴰⵎ ⵜⴻⵢⵔⴰⴷⵜ ⵓ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵡⴻⵢⵔⴰⴷ. ⵡⴰⵔ ⵉⵙⵙⴻⵣⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵍ ⵖⴰ ⵢⴻⵛⵛ ⵜⴰⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵎⵉⵏ ⵉⵎⴻⵣⵣⴻⵇ.” ");
INSERT INTO rift_vpl VALUES ("NU23_25","005_23_25","NUM","23","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⴰⴽ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⵇⴰⵄ ⴰⴷ ⵜ ⵜⵏⴻⵄⵍⴻⴷ, ⵡⴰⵔ ⵜ ⵜⵜⴱⴰⵔⴰⴽ ⵛⴰ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("NU23_26","005_23_26","NUM","23","26","26","ⴱⴰⵍⵄⴰⵎ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⵉ ⴱⴰⵍⴰⴽ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵏⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵜ ⴳⴳⴻⵖ?’” ");
INSERT INTO rift_vpl VALUES ("NU23_27","005_23_27","NUM","23","27","27","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⴰⴽ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ, ⴰⴷ ⵛⴻⴽ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵢⵉⵍⵉ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵍⴰ ⴰⴷ ⵜ ⵜⵏⴻⵄⵍⴻⴷ ⵙⵙⴻⵏⵏⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU23_28","005_23_28","NUM","23","28","28","ⵓⵛⴰ ⴱⴰⵍⴰⴽ ⵉⵏⴷⴻⵀ ⴱⴰⵍⵄⴰⵎ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⴼⴰⵖⵓⵔ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("NU23_29","005_23_29","NUM","23","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵉ ⴱⴰⵍⴰⴽ: “ⴱⵏⴰ ⴷⴰⵏⵉⵜⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵓⵛⴰ ⵙⴻⵡⵊⴻⴷ ⴰⵢⵉ ⴷⴰⵏⵉⵜⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU23_30","005_23_30","NUM","23","30","30","ⴱⴰⵍⴰⴽ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵇⴻⴷⴷⴻⵎ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NU24_1","005_24_1","NUM","24","1","1","ⵉⵥⵔⴰ ⴱⴰⵍⵄⴰⵎ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵢⴰⵔⴹⴰ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵎⵉ ⵉⴱⴰⵔⴻⴽ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ, ⴰⵎ ⵓⵎⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵓⵎⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵄⴻⵣⵣⴻⵎ ⵙ ⵉⴼⵉⵖⵔⴰⵏ, ⵎⴰⵛⴰ ⵢⴰⵔⵔⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU24_2","005_24_2","NUM","24","2","2","ⵓⵎⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵣⴷⴻⵖ ⴷⵉⵏ, ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU24_3","005_24_3","NUM","24","3","3","ⵉⴱⴷⴰ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉⵡⴻⵣⵏⴻⵏ, ⵉⵏⵏⴰ: “ⴰⵡⴰⵍ ⵏ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⴰⵡⴰⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵇⵇⴻⵏ ⵜⵉⵟⵟ, ");
INSERT INTO rift_vpl VALUES ("NU24_4","005_24_4","NUM","24","4","4","ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵎ ⴷⴷ-ⵉⵡⴹⴰ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU24_5","005_24_5","NUM","24","5","5","ⴰ ⵢⴰⵄⵇⵓⴱ, ⵎⴻⵛⵃⴰⵍ ⵚⴻⴱⵃⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵛ, ⴷ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ!, ");
INSERT INTO rift_vpl VALUES ("NU24_6","005_24_6","NUM","24","6","6","ⴰⵇⴰ ⵙⵙⵡⵉⵥⵥⴰⴹⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵜⵉⵖⵣⵓⵔⵉⵏ, ⴰⵎⴻⵛⵏⴰⵡ ⴰⵖⴻⵎⵎⵓⵢ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵢⴻⵖⵣⴰⵔ, ⴰⵎⴻⵛⵏⴰⵡ ⴰⵛⴼⵉⵍ ⵏⵏⵉ ⵉⵥⵥⵓ ⵙⵉⴷⵉ, ⴰⵎⴻⵛⵏⴰⵡ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵣⵣⴰⵜ ⵉ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU24_7","005_24_7","NUM","24","7","7","ⵣⴻⴳ ⵉⴱⵓⵇⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵜⵓⴼⴼⴻⵜ. ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵅ ⴰⵊⴰⵊ ⵓ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU24_8","005_24_8","NUM","24","8","8","ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴰⵎ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ. ⴰⴷ ⵢⴻⵛⵛ ⵍⴻⴳⵏⵓⵙ, ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵍⴱⴻⵣ ⵉⵖⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵙ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU24_9","005_24_9","NUM","24","9","9","ⴰⵇⴰ ⵉⵖⵏⴻⵙ, ⵉⵙⵙⴻⵣⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵡⴻⵢⵔⴰⴷ, ⴰⵎ ⵜⴻⵢⵔⴰⴷⵜ. ⵡⵉ ⵜ ⵉ ⴷⴷ ⵖⴰ ⵉⵙⵙⴻⴽⴽⴰⵔⴻⵏ? ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴱⴰⵔⴽⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵓ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵏⴻⵄⵄⵍⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ!’” ");
INSERT INTO rift_vpl VALUES ("NU24_10","005_24_10","NUM","24","10","10","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏ ⴱⴰⵍⴰⴽ ⵅ ⴱⴰⵍⵄⴰⵎ. ⵉⵡⵜⴰ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴱⴰⵍⴰⴽ ⵉⵏⵏⴰ ⵉ ⴱⴰⵍⵄⴰⵎ: “ⴰⵇⴰ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵛⴻⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵏⴻⵄⵍⴻⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜⴱⴰⵔⴽⴻⴷ ⵉ-ⵜⴻⵏ ⵄⴰⴷ ⵏⵉⵛⴰⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("NU24_11","005_24_11","NUM","24","11","11","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ! ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵛ ⵜ, ⴰⴷ ⵛⴻⴽ ⵛⴻⵏⵄⴻⵖ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵎⵏⴻⵄ ⵅⴰⴽ ⵛⵛⴻⵏⵄⴻⵜ ⵏⵏⵉ!” ");
INSERT INTO rift_vpl VALUES ("NU24_12","005_24_12","NUM","24","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⵍⵄⴰⵎ ⵉ ⴱⴰⵍⴰⴽ: “ⵎⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜᵉⵙⵙⴻⴽⴽⴻⴷ ⵓⵛⴰ ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("NU24_13","005_24_13","NUM","24","13","13","‘ⵡⴰⵅⵅⴰ ⴱⴰⵍⴰⴽ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵛⵛⵓⵔ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵄⴰⴷ ⵡⴰⵔ ⵣⵎⵉⵔⴻⵖ ⴰⴷ ⵄⴻⴷⴷⵉⵖ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏ ⵍⵅⴰⵔ ⵏⵉⵖ ⵏ ⵍⵖⴰⵔ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⵓⵍ ⵉⵏⵓ. ⵎⵉⵏ ⵖⴰ ⵢⵉⵏⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵜ ⵉⵏⵉⵖ.’ ");
INSERT INTO rift_vpl VALUES ("NU24_14","005_24_14","NUM","24","14","14","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⴰⵙ-ⴷⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴻⴳⴱⴻⵖ ⵅ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵢⴻⴳⴳ ⵍⴳⴻⵏⵙ-ⴰ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU24_15","005_24_15","NUM","24","15","15","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰⵡⴰⵍ ⵏ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⴰⵡⴰⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵇⵇⴻⵏ ⵜⵉⵟⵟ! ");
INSERT INTO rift_vpl VALUES ("NU24_16","005_24_16","NUM","24","16","16","ⵜⴰⵡⴰⵍⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵣⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵎ ⴷⴷ-ⵉⵡⴹⴰ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU24_17","005_24_17","NUM","24","17","17","ⴰⴷ ⵜ ⵥⴰⵔⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵜ ⵜⵡⴰⵍⵉⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵍⴰⴷⴰⵙⴻⵜ. ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵉⵜⵔⵉ ⵣⵉ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵓⵣⴻⴵⴰⴹ ⵏ ⵍⵃⴰⴽⴻⵎ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵍⴻⴱⵣⴻⵏ ⵍⵃⴻⵏⴽⴰⵜ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⴰⴷ ⵉⵍⴱⴻⵣ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵙⵙⴷⴻⵄ ");
INSERT INTO rift_vpl VALUES ("NU24_18","005_24_18","NUM","24","18","18","ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵉⴷⵓⵎ ⴷ ⵍⵡⴰⵔⵜ ⵓ ⵙⴰⵄⵉⵔ, ⵡⴻⵏⵏⵉ ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵉⵙⵔⴰⵉⵍ ⵙ ⵜⴰⵔⵢⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("NU24_19","005_24_19","NUM","24","19","19","ⵓ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵉⵃⴽⴻⵎ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU24_20","005_24_20","NUM","24","20","20","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵥⵔⴰ ⵄⴰⵎⴰⵍⵉⵇ, ⵉⴱⴷⴰ ⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵛⴰ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵀⴻⵍⵍⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("NU24_21","005_24_21","NUM","24","21","21","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ, ⵉⴱⴷⴰ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵜⴻⵎⵜⴻⵏ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵛ ⴷⵉ ⵜⴻⵚⴹⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU24_22","005_24_22","NUM","24","22","22","ⵄⴰⴷ ⵇⴰⵢⵉⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ. ⴰⵍ ⵎⴻⵍⵎⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⵛⵛⵓⵔ ⴰⴷ ⴰⵛ ⴷⴷ-ⵢⴰⵡⵉ ⴷ ⴰⵎⴻⵃⴱⵓⵙ?” ");
INSERT INTO rift_vpl VALUES ("NU24_23","005_24_23","NUM","24","23","23","ⵓⵛⴰ ⵉⴱⴷⴰ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰⵢ, ⵡⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵅⵎⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("NU24_24","005_24_24","NUM","24","24","24","ⵉⵖⴰⵔⵔⵓⴱⴰ ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴽⵉⵜⵜⵉⵎ ⴰⴷ ⵖⴻⵣⵣⴰⵏ ⴰⵛⵛⵓⵔ ⵓⵛⴰ ⴰⴷ ⵖⴻⵣⵣⴰⵏ ⵄⴰⵡⴻⴷ ⵄⴰⴱⵉⵔ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU24_25","005_24_25","NUM","24","25","25","ⵉⴽⴽⴰⵔ ⴱⴰⵍⵄⴰⵎ, ⵢⵓⵢⵓⵔ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ⵓⵍⴰ ⴷ ⴱⴰⵍⴰⴽ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU25_1","005_25_1","NUM","25","1","1","ⵉⵣⴷⴻⵖ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵛⵉⵟⵟⵉⵎ ⵓⵛⴰ ⵉⴱⴷⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU25_2","005_25_2","NUM","25","2","2","ⵄⴰⵔⴹⴻⵏ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵜⵖⴰⵔⵚⵉ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵛⵛⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU25_3","005_25_3","NUM","25","3","3","ⴰⵎⵎⵓ ⵉⵎⵓⵏ ⵍⴳⴻⵏⵙ ⴰⴽ-ⴷ ⴱⴰⵄⵍ-ⴼⴰⵖⵓⵔ ⵓⵛⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU25_4","005_25_4","NUM","25","4","4","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴽⵙⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⵢⴻⵍ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵜⴼⵓⵛⵜ ⵉⵃⴰⵔⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳⵯⴻⵊ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU25_5","005_25_5","NUM","25","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ ⵉ ⵍⵇⵓⴹⴰⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵏⴻⵖ ⵉⵏⵏⵉ ⵣⵉ ⵊⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵉ ⵉⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⴱⴰⵄⵍ-ⴼⴰⵖⵓⵔ!” ");
INSERT INTO rift_vpl VALUES ("NU25_6","005_25_6","NUM","25","6","6","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵎⵉⴷⵉⵢⴰⵏⴻⵛⵜ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⵓⵙⴰ ⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵜⵜⵔⵓⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU25_7","005_25_7","NUM","25","7","7","ⵉⵥⵔⴰ ⵉ-ⵜ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ. ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵃⵔⵉⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("NU25_8","005_25_8","NUM","25","8","8","ⵓⵛⴰ ⵉⵔⵓⵃ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵙ ⵍⵇⵓⴱⴱⴻⵜ ⵓⵛⴰ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⵎ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵜⴱⴻⴷⴷ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU25_9","005_25_9","NUM","25","9","9","ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⴷⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU25_10","005_25_10","NUM","25","10","10","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU25_11","005_25_11","NUM","25","11","11","“ⴼⵉⵏⴻⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ, ⵉⵙⵙⴻⴳⴳⵡⴻⵊ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵎⵃⴻⴹ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵀⴷⵉⵊⴻⵖ ⵄⴰⴷ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU25_12","005_25_12","NUM","25","12","12","ⵙ ⵓⵢⴰ ⵉⵏⵉ: ‘ⵅⵥⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU25_13","005_25_13","NUM","25","13","13","ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⵍⵄⴰⵀⴷ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵎⵃⴻⴹ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵚⵍⴰⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("NU25_14","005_25_14","NUM","25","14","14","ⵉⵙⴻⵎ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵉⵏⵖⴰ ⴼⵉⵏⴻⵃⴰⵙ, ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⵎⵉⴷⵢⴰⵏⴻⵛⵜ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵣⵉⵎⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵙⴰⵍⵓ, ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵅ ⵉⵛⵉⵎⵄⵓⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU25_15","005_25_15","NUM","25","15","15","ⵉⵙⴻⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⵎⵉⴷⵢⴰⵏⵉⵛⵜ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⴽⵓⵣⴱⵉ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵓⵔ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⵉⴼ ⵅ ⵜⵇⴻⴱⴱⴰⵍⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵜⴱⴰⴱⴰⵜ ⵏ ⵉⵎⵉⴷⵢⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU25_16","005_25_16","NUM","25","16","16","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU25_17","005_25_17","NUM","25","17","17","“ⵃⵚⴰⵔⴻⵎ ⵅ ⵉⵎⵉⴷⵢⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵖⴻⵍⵍⴱⴻⵎ ⵅⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU25_18","005_25_18","NUM","25","18","18","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵃⵚⴰⵔⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ ⵙ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵣⴻⵍⵖⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴼⴰⵖⵓⵔ ⴷ ⴽⵓⵣⴱⵉ, ⵢⴻⴵⵉⵙ ⵏ ⵍⵃⴰⴽⴻⵎ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵓⵍⵜⵎⴰⵜⵙⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴼⴰⵖⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU25_19","005_25_19","NUM","25","19","19","ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵉⵎⵙⴰⵔ ⵎⵉⵏ ⴷⴷ-ⵉⴳⴳⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_1","005_26_1","NUM","26","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU26_2","005_26_2","NUM","26","2","2","“ⵃⴻⵙⴱⴻⵎ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ, ⵣⵉ ⵄⵉⵛⵍⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU26_3","005_26_3","NUM","26","3","3","ⵎⵓⵙⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⴽⴻⵀⵀⴰⵏ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ ⵓⵛⴰ ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("NU26_4","005_26_4","NUM","26","4","4","“ⵣⵉ ⵄⵉⵛⵍⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ!” ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("NU26_5","005_26_5","NUM","26","5","5","ⵔⵓⴱⵉⵏ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⵓⴱⵉⵏ: ⵣⵉ ⵃⴰⵏⵓⴽ ⵍⴰⴵ ⵏ ⵉⵃⴰⵏⵓⴽⵉⵢⵢⴻⵏ, ⵣⵉ ⴼⴰⵍⵍⵓ ⵍⴰⴵ ⵏ ⵉⴼⴰⵍⵍⵓⵡⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_6","005_26_6","NUM","26","6","6","ⵣⵉ ⵃⴰⵚⵔⵓⵏ ⵍⴰⴵ ⵏ ⵉⵃⴰⵚⵔⵓⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⴽⴰⵔⵎⵉ ⵍⴰⴵ ⵏ ⵉⴽⴰⵔⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_7","005_26_7","NUM","26","7","7","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_8","005_26_8","NUM","26","8","8","ⵜⴰⵔⵡⴰ ⵏ ⴼⴰⵍⵍⵓ ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵎⵖⵉⵔ ⵉⵍⵉⵢⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU26_9","005_26_9","NUM","26","9","9","ⵜⵓⵖⴰ ⴰⵔⵔⴰⵡ ⵏ ⵉⵍⵉⵢⴰⴱ: ⵏⵉⵎⵓⵢⵉⵍ, ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ. ⵉⵏⴰ, ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵍⴰⵖⴰⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ ⴹⵉⴷⴷ ⵉ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⴱⴰⵔⵔⵓ ⵏ ⵇⵓⵔⴰⵃ, ⵓⵎⵉ ⵖⴻⵡⵡⵖⴻⵏ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ.    ");
INSERT INTO rift_vpl VALUES ("NU26_10","005_26_10","NUM","26","10","10","ⵜⴰⵎⵎⵓⵔⵜ ⵜⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵙⴰⵔⴹ ⵉ-ⵜⴻⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵇⵓⵔⴰⵃ, ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵓⴱⴰⵔⵔⵓ ⵏⵏⵉ ⵓⵎⵉ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵛⵛⴰ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵄⵍⴰⵎ ⵉⵙⵙⵉⴳⴳⵡⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_11","005_26_11","NUM","26","11","11","ⵎⴰⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵇⵓⵔⴰⵃ ⵡⴰⵔ ⵎⵎⵓⵜⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("NU26_12","005_26_12","NUM","26","12","12","ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵏⵉⵎⵓⵢⵉⵍ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵏⵉⵎⵓⵢⵉⵍⵉⵢⵢⴻⵏ, ⵣⵉ ⵢⴰⵎⵉⵏ ⵍⴰⴵ ⵏ ⵉⵢⴰⵎⵉⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵢⴰⴽⵉⵏ ⵍⴰⴵ ⵏ ⵉⵢⴰⴽⵉⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_13","005_26_13","NUM","26","13","13","ⵣⵉ ⵣⴰⵔⴰⵃ ⵍⴰⴵ ⵏ ⵉⵣⴰⵔⴰⵃⵉⵢⵢⴻⵏ, ⵣⵉ ⵛⴰⵡⵓⵍ ⵍⴰⴵ ⵏ ⵉⵛⴰⵡⵓⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_14","005_26_14","NUM","26","14","14","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵛⵉⵎⵄⵓⵏⵉⵢⵢⴻⵏ: ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_15","005_26_15","NUM","26","15","15","ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵊⴰⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵚⵉⴼⵓⵏ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵚⵉⴼⵓⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵃⴰⵊⵊⵉ ⵍⴰⴵ ⵏ ⵉⵃⴰⵊⵊⵉⵡⵉⵢⵢⴻⵏ, ⵣⵉ ⵛⵓⵏⵉ ⵍⴰⴵ ⵏ ⵉⵛⵓⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_16","005_26_16","NUM","26","16","16","ⵣⵉ ⵓⵣⵏⵉ ⵍⴰⴵ ⵏ ⵉⵢⵓⵣⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵄⵉⵔⵉ ⵍⴰⴵ ⵏ ⵉⵄⵉⵔⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_17","005_26_17","NUM","26","17","17","ⵣⵉ ⴰⵔⵓⴷ ⵍⴰⴵ ⵏ ⵉⵔⵓⴷⵉⵢⵢⴻⵏ, ⵣⵉ ⴰⵔⵉⵢⵉⵍⵉ ⵍⴰⴵ ⵏ ⵉⵔⵉⵢⵉⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_18","005_26_18","NUM","26","18","18","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵊⴰⴷ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU26_19","005_26_19","NUM","26","19","19","ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵔ ⴷ ⵓⵏⴰⵏ. ⵎⴰⵛⴰ ⵎⵎⵓⵜⴻⵏ ⵄⵉⵔ ⴷ ⵓⵏⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_20","005_26_20","NUM","26","20","20","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵛⴰⵢⵍⴰ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵛⵉⵍⴰⵢⵢⴻⵏ, ⵣⵉ ⴼⴰⵔⵉⵚ ⵍⴰⴵ ⵏ ⵉⴼⴰⵔⴰⵚⵉⵢⵢⴻⵏ, ⵣⵉ ⵣⴰⵔⴰⵃ ⵍⴰⴵ ⵏ ⵉⵣⴰⵔⴰⵃⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_21","005_26_21","NUM","26","21","21","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴼⴰⵔⵉⵚ: ⵣⵉ ⵃⴰⵚⵔⵓⵏ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵃⴰⵚⵔⵓⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵃⴰⵎⵓⵍ ⵍⴰⴵ ⵏ ⵉⵃⴰⵎⵓⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_22","005_26_22","NUM","26","22","22","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_23","005_26_23","NUM","26","23","23","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵜⵓⵍⴰⵄ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵜⵓⵍⴰⵄⵉⵢⵢⴻⵏ, ⵣⵉ ⴱⵓⵡⴰ ⵍⴰⴵ ⵏ ⵉⴱⵓⵡⴰⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_24","005_26_24","NUM","26","24","24","ⵣⵉ ⵢⴰⵛⵓⴱ ⵍⴰⴵ ⵏ ⵉⵢⴰⵛⵓⴱⵉⵢⵢⴻⵏ, ⵣⵉ ⵛⵉⵎⵔⵓⵏ ⵍⴰⴵ ⵏ ⵉⵛⵉⵎⵔⵓⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_25","005_26_25","NUM","26","25","25","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_26","005_26_26","NUM","26","26","26","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵣⴰⴱⵓⵍⵓⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵙⴰⵔⵉⴷ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵙⴰⵔⵉⴷⵉⵢⵢⴻⵏ, ⵣⵉ ⵉⵍⵓⵏ ⵍⴰⴵ ⵏ ⵉⵍⵓⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵢⴰⵃⵍⵉⵢⵉⵍ ⵍⴰⴵ ⵏ ⵉⵢⴰⵃⵍⵉⵢⵉⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_27","005_26_27","NUM","26","27","27","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵣⴰⴱⵓⵍⵓⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_28","005_26_28","NUM","26","28","28","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵙⵓⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NU26_29","005_26_29","NUM","26","29","29","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: ⵣⵉ ⵎⴰⴽⵉⵔ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵎⴰⴽⵉⵔⵉⵢⵢⴻⵏ. ⵎⴰⴽⵉⵔ ⵢⴻⵊⵊ-ⴷⴷ ⵊⵉⵍⵄⴰⴷ. ⵣⵉ ⵊⵉⵍⵄⴰⴷ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵊⵉⵍⵄⴰⴷⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_30","005_26_30","NUM","26","30","30","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ: ⵣⵉ ⵉⵄⴰⵣⴰⵔ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵄⴰⵣⴰⵔⵉⵢⵢⴻⵏ, ⵣⵉ ⵃⴰⵍⴰⵇ ⵍⴰⴵ ⵏ ⵉⵃⴰⵍⴰⵇⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_31","005_26_31","NUM","26","31","31","ⵣⵉ ⴰⵙⵔⵉⵢⵉⵍ ⵍⴰⴵ ⵏ ⵉⵙⵔⵉⵢⵉⵍⵉⵢⵢⴻⵏ, ⵣⵉ ⵛⴰⴽⴰⵎ ⵍⴰⴵ ⵏ ⵉⵛⴰⴽⴰⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_32","005_26_32","NUM","26","32","32","ⵣⵉ ⵛⵉⵎⵉⴷⴰⵄ ⵍⴰⴵ ⵏ ⵉⵛⵉⵎⴷⴰⵄⵉⵢⵢⴻⵏ, ⵣⵉ ⵃⴰⴼⴰⵔ ⵍⴰⴵ ⵏ ⵉⵃⴰⴼⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_33","005_26_33","NUM","26","33","33","ⵚⴰⵍⵓⴼⵃⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴼⴰⵔ, ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⴻⵙ ⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⵖⵉⵔ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⴰⵍⵓⴼⵃⴰⴷ: ⵎⴰⵃⵍⴰ, ⵏⵓⵄⴰ, ⵃⵓⵊⵍⴰ, ⵎⵉⵍⴽⴰ ⴷ ⵜⵉⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("NU26_34","005_26_34","NUM","26","34","34","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_35","005_26_35","NUM","26","35","35","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵛⵓⵜⴰⵍⴰⵃ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵛⵓⵜⴰⵍⴰⵃⵉⵢⵢⴻⵏ, ⵣⵉ ⴱⴰⴽⴰⵔ ⵍⴰⴵ ⵏ ⵉⴱⴰⴽⴰⵔⵉⵢⵢⴻⵏ, ⵣⵉ ⵜⴰⵃⴰⵏ ⵍⴰⴵ ⵏ ⵉⵜⴰⵃⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_36","005_26_36","NUM","26","36","36","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵛⵓⵜⴰⵍⴰⵃ: ⵣⵉ ⵄⵉⵔⴰⵏ ⵍⴰⴵ ⵏ ⵉⵄⵉⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_37","005_26_37","NUM","26","37","37","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵙⵓⴼ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_38","005_26_38","NUM","26","38","38","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⴱⵉⵍⴰⵄ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⴱⵉⵍⴰⵄⵉⵢⵢⴻⵏ, ⵣⵉ ⴰⵛⴱⵉⵍ ⵍⴰⴵ ⵏ ⵉⵛⴱⵉⵍⵉⵢⵢⴻⵏ, ⵣⵉ ⴰⵃⵉⵔⴰⵎ ⵍⴰⴵ ⵏ ⵉⵃⵉⵔⴰⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_39","005_26_39","NUM","26","39","39","ⵣⵉ ⵛⴰⴼⵓⴼⴰⵎ ⵍⴰⴵ ⵏ ⵉⵛⴰⴼⵓⴼⴰⵎⵉⵢⵢⴻⵏ, ⵣⵉ ⵃⵓⴼⴰⵎ ⵍⴰⴵ ⵏ ⵉⵃⵓⴼⴰⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_40","005_26_40","NUM","26","40","40","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⵍⴰⵄ: ⴰⵔⴷ ⴷ ⵏⵓⵄⵎⴰⵏ. ⵣⵉ ⴰⵔⴷ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵔⴷⵉⵢⵢⴻⵏ, ⵣⵉ ⵏⵓⵄⵎⴰⵏ ⵍⴰⴵ ⵏ ⵉⵏⵓⵄⵎⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_41","005_26_41","NUM","26","41","41","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_42","005_26_42","NUM","26","42","42","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵛⵓⵃⴰⵎ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵛⵓⵃⴰⵎⵉⵢⵢⴻⵏ. ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⴷⴰⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_43","005_26_43","NUM","26","43","43","ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵉⵛⵓⵃⴰⵎⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_44","005_26_44","NUM","26","44","44","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵛⵉⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵢⵉⵎⵏⴰ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵢⵉⵎⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵢⵉⵛⵡⵉ ⵍⴰⴵ ⵏ ⵉⵢⵉⵛⵡⵉⵢⵢⴻⵏ, ⵣⵉ ⴱⴻⵔⵉⵄⴰ ⵍⴰⴵ ⵏ ⵉⴱⴰⵔⵉⵄⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_45","005_26_45","NUM","26","45","45","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴻⵔⵉⵄⴰ: ⵣⵉ ⵃⴰⴱⵉⵔ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵃⴰⴱⵉⵔⵉⵢⵢⴻⵏ, ⵣⵉ ⵎⴰⵍⴽⵉⵢⵉⵍ ⵍⴰⴵ ⵏ ⵉⵎⴰⵍⴽⵉⵢⵉⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_46","005_26_46","NUM","26","46","46","ⵉⵙⴻⵎ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⴰⵛⵉⵔ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵙⴰⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("NU26_47","005_26_47","NUM","26","47","47","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵛⵉⵔ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_48","005_26_48","NUM","26","48","48","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵢⴰⵃⴰⵙⵢⵉⵍ ⵉⵇⵇⴰⵔⵚ ⵍⴰⴵ ⵏ ⵉⵢⴰⵃⴰⵙⵍⵉⵢⵢⴻⵏ, ⵣⵉ ⵊⵓⵏⵉ ⵍⴰⴵ ⵏ ⵉⵊⵓⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU26_49","005_26_49","NUM","26","49","49","ⵣⵉ ⵢⴰⵚⵉⵔ ⵍⴰⴵ ⵏ ⵉⵢⴰⵚⵉⵔⵉⵢⵢⴻⵏ, ⵣⵉ ⵛⵉⵍⵍⵉⵎ ⵍⴰⴵ ⵏ ⵉⵛⵉⵍⵍⵉⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_50","005_26_50","NUM","26","50","50","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⴰⵍⴰⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_51","005_26_51","NUM","26","51","51","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵡⴰⵃⵉⵜ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_52","005_26_52","NUM","26","52","52","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU26_53","005_26_53","NUM","26","53","53","“ⵊⴰⵔ ⵉⵏⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴹⴰ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_54","005_26_54","NUM","26","54","54","ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ, ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⴽⵜⴰⵔ ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵉⵡⴷⴰⵏ, ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵇⴻⵍⵍ ⴷ ⵍⵡⴰⵔⵜ. ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⴷ ⴰⵙ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU26_55","005_26_55","NUM","26","55","55","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴹⴰ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_56","005_26_56","NUM","26","56","56","ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴹⴰ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⴷ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵔⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU26_57","005_26_57","NUM","26","57","57","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⵉ ⵍⴰⵡⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ: ⵣⵉ ⵊⴰⵔⵛⵓⵏ ⵍⴰⴵ ⵏ ⵉⵊⴰⵔⵛⵓⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵇⴰⵀⴰⵜ ⵍⴰⴵ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ, ⵣⵉ ⵎⴰⵔⴰⵔⵉ ⵍⴰⴵ ⵏ ⵉⵎⴰⵔⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU26_58","005_26_58","NUM","26","58","58","ⵜⵓⵖⴰ ⵜⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⵍⴰⴵ ⵏ ⵉⵍⵉⴱⵏⵉⵢⵢⴻⵏ, ⵍⴰⴵ ⵏ ⵉⵃⵉⴱⵔⵓⵏⵉⵢⵢⴻⵏ, ⵍⴰⴵ ⵏ ⵉⵎⴰⵀⵍⵉⵢⵢⴻⵏ, ⵍⴰⴵ ⵏ ⵉⵎⵓⵛⵉⵢⵢⴻⵏ, ⵍⴰⴵ ⵏ ⵉⵇⵓⵔⴰⵃⵉⵢⵢⴻⵏ. ⵓⵛⴰ ⵇⴰⵀⴰⵜ ⵢⴻⵊⵊ-ⴷⴷ ⵄⴰⵎⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NU26_59","005_26_59","NUM","26","59","59","ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵄⴰⵎⵔⴰⵎ ⵇⵇⴰⵔⴻⵏⵜ ⴰⵙ ⵊⵓⴽⴰⴱⴰⴷ, ⵢⴻⴵⵉⵙ ⵏ ⵍⴰⵡⵉ, ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⵉ ⵍⴰⵡⵉ ⴷⵉ ⵎⵉⵚⵔⴰ. ⴷ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⵓⵙⴰ ⴷ ⵎⴰⵔⵢⴰⵎ, ⵓⵍⵜⵎⴰⵜⵙⴻⵏ, ⵉ ⵄⴰⵎⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NU26_60","005_26_60","NUM","26","60","60","ⵉ ⵀⴰⵔⵓⵏ ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ, ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU26_61","005_26_61","NUM","26","61","61","ⵎⴰⵛⴰ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ ⵎⵎⵓⵜⴻⵏ, ⵓⵎⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴰⵖⵔⵉⴱⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU26_62","005_26_62","NUM","26","62","62","ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵙⴻⵏⵏⴻⵊ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ. ⵉⵏⴰ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵛⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵙⵖⴰⵔⵜ ⴷ ⵍⵡⴰⵔⵜ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU26_63","005_26_63","NUM","26","63","63","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⴽⴻⵀⵀⴰⵏ. ⵏⵉⵜⵏⵉ ⵃⴻⵙⴱⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("NU26_64","005_26_64","NUM","26","64","64","ⵡⴰⵔ ⵜⵓⵖⵉ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⴰⴽⴻⵀⵀⴰⵏ, ⵓⵎⵉ ⵃⴻⵙⴱⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU26_65","005_26_65","NUM","26","65","65","ⵎⵉⵏⵣⵉ ⵅⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⵖⵉⵔ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU27_1","005_27_1","NUM","27","1","1","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⴰⵍⵓⴼⵃⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴼⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵎⴰⴽⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ. ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ: ⵎⴰⵃⵍⴰ, ⵏⵓⵄⴰ, ⵃⵓⵊⵍⴰ, ⵎⵉⵍⴽⴰ ⴷ ⵜⵉⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("NU27_2","005_27_2","NUM","27","2","2","ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵓⵙⴰ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⴽⴻⵀⵀⴰⵏ, ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵏⵏⴰⵏⵜ: ");
INSERT INTO rift_vpl VALUES ("NU27_3","005_27_3","NUM","27","3","3","“ⴱⴰⴱⴰⵜⵏⴻⵖ ⵉⵎⵎⵓⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓ ⵡⴰⵔ ⵜ ⵜⵓⵖⵉ ⵊⴰⵔ ⵓⴱⴰⵔⵔⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵎⵓⵏⴻⵏ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵓⴱⴰⵔⵔⵓ ⵏ ⵇⵓⵔⴰⵃ ⵡⴰⵔ ⴷⵉⵏ ⵜ ⵜⵓⵖⵉ ⵏⴻⵜⵜⴰ, ⵎⵉⵏⵣⵉ ⵉⵎⵎⵓⵜ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("NU27_4","005_27_4","NUM","27","4","4","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⴽⴽⴻⵙ ⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵣⵉ ⵊⴰⵔ ⵍⴰⴵ ⵏⵏⴻⵙ, ⵎⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⴱⵓ ⵓⵃⴻⵏⵊⵉⵔ? ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⴳⵍⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜⵎⴰⵙ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU27_5","005_27_5","NUM","27","5","5","ⵎⵓⵙⴰ ⵢⵉⵡⵉ ⴷⴷⴻⵄⵡⴰ ⵏⵙⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU27_6","005_27_6","NUM","27","6","6","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU27_7","005_27_7","NUM","27","7","7","“ⴰⵇⴰ ⴰⵢⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵏⵏⴰⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⴰⵍⵓⴼⵃⴰⴷ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙⴻⵏⵜ ⵜⴻⵡⵛⴻⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⴷⵉ  ⵍⵡⴻⵙⵜ ⵏ ⴰⵢⵜⵎⴰⵙ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏⵜ ⵜⴻⵙⵙⴻⵄⴷⵓⴷ ⵍⵡⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU27_8","005_27_8","NUM","27","8","8","ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⵎⵎⵉⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⴻⵄⴷⵓⵎ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⴻⴵⵉⵙ, ");
INSERT INTO rift_vpl VALUES ("NU27_9","005_27_9","NUM","27","9","9","ⵓ ⵎⴰⵍⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵢⴻⴵⵉⵙ, ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵢⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU27_10","005_27_10","NUM","27","10","10","ⵎⴰⵍⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵢⵜⵎⴰⵙ ⵄⴰⵡⴻⴷ, ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU27_11","005_27_11","NUM","27","11","11","ⵎⴰⵍⴰ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵢⵜⵎⴰⵙ ⵄⴰⵡⴻⴷ, ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵔⴰⴵ ⵏⵏⴻⵙ, ⵉ ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⴷⵙⴻⵏ ⵣⵉ ⵍⴰⴵ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵡⴰⵔⵜ ⵏⴻⵜⵜⴰ.’ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵓⵣⴻⵔⴼ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU27_12","005_27_12","NUM","27","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴰⴷⵔⴰⵔ-ⴰ ⴰⴱⴰⵔⵉⵎ ⵓⵛⴰ ⵅⵣⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU27_13","005_27_13","NUM","27","13","13","ⵅⵎⵉ ⵜⵜ ⵖⴰ ⵜⵥⴰⵔⴻⴷ, ⴰⴷ ⵜᵉⵎⵎⴰⵔⵏⵉⴷ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵛⴻⴽ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵓⵎⴰⵛ ⵀⴰⵔⵓⵏ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NU27_14","005_27_14","NUM","27","14","14","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵍⵓⵎⵓⵔ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ, ⵍⴰⵎⵉ ⴷⵉⵏ ⵜⵓⵖⴰ ⴰⵎⵛⵓⴱⴱⴻⵛ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ. ⴰⵇⴰ ⴷ ⵉⵏⴰ ⴷ ⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ, ⵖⴰⵔ ⵇⴰⴷⴰⵛ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU27_15","005_27_15","NUM","27","15","15","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU27_16","005_27_16","NUM","27","16","16","“ⴰⴷ ⵉⴳⴳ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⵓⵃⴱⴻⵍⴰⵜ ⵏ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ, ⴰⵃⴻⵟⵟⵓ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ");
INSERT INTO rift_vpl VALUES ("NU27_17","005_27_17","NUM","27","17","17","ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵉⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⴰⵎ ⵡⵓⴵⵉ ⴱⵍⴰ ⴰⵎⴻⴽⵙⴰⵡ.”    ");
INSERT INTO rift_vpl VALUES ("NU27_18","005_27_18","NUM","27","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: “ⴽⵙⵉ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⴷⵉ ⵉⴵⴰ ⴰⵔⵔⵓⵃ, ⵓⵛⴰ ⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ");
INSERT INTO rift_vpl VALUES ("NU27_19","005_27_19","NUM","27","19","19","ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ, ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⴷ ⵍⵓⵎⵓⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU27_20","005_27_20","NUM","27","20","20","ⴻⵡⵛ ⴰⵙ ⵛⴰ ⵣⴻⴳ ⵓⵡⴻⵇⵇⴰⵔ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵙⴻⵍ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU27_21","005_27_21","NUM","27","21","21","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴰⵡⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵃⴽⴰⵎ ⵏ ⵓⵔⵉⵎ. ⵅ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓ ⵅ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵙ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU27_22","005_27_22","NUM","27","22","22","ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ⵢⵉⵡⵉ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU27_23","005_27_23","NUM","27","23","23","ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵄⴷⵓ ⴰⵙ ⵍⵓⵎⵓⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU28_1","005_28_1","NUM","28","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU28_2","005_28_2","NUM","28","2","2","“ⵓⵎⵓⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵅ ⵜⵖⴰⵔⵚⵟ ⵉⵏⵓ, ⵎⴰⵛⵛⴰ ⵉⵏⵓ ⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵏⵓ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵏⴻⵛⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵜ ⵜⵇⴻⴷⴷⵎⴻⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("NU28_3","005_28_3","NUM","28","3","3","ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NU28_4","005_28_4","NUM","28","4","4","ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⴰⴷ ⵜ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴷⵉ ⵚⵚⴱⴻⵃ ⵓⵛⴰ ⵉⵣⵎⴰⵔ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ ");
INSERT INTO rift_vpl VALUES ("NU28_5","005_28_5","NUM","28","5","5","ⵓⵛⴰ ⴰⴽ-ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ, ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵣⵣⵉⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU28_6","005_28_6","NUM","28","6","6","ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵟ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_7","005_28_7","NUM","28","7","7","ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ. ⵙⴻⵢⵢⴻⴱ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵏ ⵛⵛⵔⴰⴱ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_8","005_28_8","NUM","28","8","8","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵣⵎⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵊⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⴰⵍ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ. ⴰⴷ ⵜ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵚⵚⴱⴻⵃ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵏⵏⴻⵙ, ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("NU28_9","005_28_9","NUM","28","9","9","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU28_10","005_28_10","NUM","28","10","10","ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵟ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵎⴽⵓⵍ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵜⵜ ⵜⴰⵔⵏⵉⴷ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU28_11","005_28_11","NUM","28","11","11","“ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏⵡⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ - ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ");
INSERT INTO rift_vpl VALUES ("NU28_12","005_28_12","NUM","28","12","12","ⵓⵛⴰ ⴰⴽ-ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ");
INSERT INTO rift_vpl VALUES ("NU28_13","005_28_13","NUM","28","13","13","ⵓⵛⴰ ⴰⵔⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_14","005_28_14","NUM","28","14","14","ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⴱⵉⵏⵓ ⴰⴽ-ⴷ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵛⴰⵔⵔⵉ ⴷ ⵢⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵣⵎⴰⵔ. ⵜⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⴽⵓⵍ ⴰⵢⵓⵔ, ⵉ ⴽⵓⵍ ⴰⵢⵓⵔ ⵣⴻⴳ ⵉⵢⵓⵔⴻⵏ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU28_15","005_28_15","NUM","28","15","15","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵜ ⵜⴰⵔⵏⵉⴷ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU28_16","005_28_16","NUM","28","16","16","ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_17","005_28_17","NUM","28","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵙⵉⵎⴰⵏⵜ ⵏ ⵓⵢⵓⵔ ⴰⴷ ⵢⵉⵍⵉ ⵍⵄⵉⴷ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU28_18","005_28_18","NUM","28","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵍⵄⵉⴷ ⴰⴷ ⵢⵉⵍⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("NU28_19","005_28_19","NUM","28","19","19","ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("NU28_20","005_28_20","NUM","28","20","20","ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ. ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_21","005_28_21","NUM","28","21","21","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_22","005_28_22","NUM","28","22","22","ⵙⴻⵡⵊⴻⴷ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("NU28_23","005_28_23","NUM","28","23","23","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵡⴻⵛⵎⴰⴹ ⴷⵉ ⵚⵚⴱⴻⵃ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NU28_24","005_28_24","NUM","28","24","24","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵢⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴷⵉ ⴽⵓⵍ ⴰⵙⵙ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⵎ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ. ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU28_25","005_28_25","NUM","28","25","25","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("NU28_26","005_28_26","NUM","28","26","26","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵊⴷⵉⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("NU28_27","005_28_27","NUM","28","27","27","ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ");
INSERT INTO rift_vpl VALUES ("NU28_28","005_28_28","NUM","28","28","28","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ: ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ");
INSERT INTO rift_vpl VALUES ("NU28_29","005_28_29","NUM","28","29","29","ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⵉⵣⵎⴰⵔ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU28_30","005_28_30","NUM","28","30","30","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("NU28_31","005_28_31","NUM","28","31","31","ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ. ⴰⴷ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⵇⴰⵄ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU29_1","005_29_1","NUM","29","1","1","“ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NU29_2","005_29_2","NUM","29","2","2","ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ: ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ - ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⴷ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ");
INSERT INTO rift_vpl VALUES ("NU29_3","005_29_3","NUM","29","3","3","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⴻⴳ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ: ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵉⵛⴰⵔⵔⵉ ");
INSERT INTO rift_vpl VALUES ("NU29_4","005_29_4","NUM","29","4","4","ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⵉⵣⵎⴰⵔ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_5","005_29_5","NUM","29","5","5","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("NU29_6","005_29_6","NUM","29","6","6","ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵏⵙⴻⵏⵜ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU29_7","005_29_7","NUM","29","7","7","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("NU29_8","005_29_8","NUM","29","8","8","ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ: ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NU29_9","005_29_9","NUM","29","9","9","ⵄⴰⵡⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ: ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ");
INSERT INTO rift_vpl VALUES ("NU29_10","005_29_10","NUM","29","10","10","ⵓ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⵉⵣⵎⴰⵔ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_11","005_29_11","NUM","29","11","11","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_12","005_29_12","NUM","29","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵄⴻⵢⵢⴷⴻⵎ ⵍⵄⵉⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU29_13","005_29_13","NUM","29","13","13","ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴰⵎ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ: ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ - ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ - ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("NU29_14","005_29_14","NUM","29","14","14","ⵄⴰⵡⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵣⵣⴻⵛⵜ: ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ, ⵉ ⵎⴰⵔⵔⴰ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵛⵓⵔⵉⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵛⴰⵔⵔⵉ, ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ");
INSERT INTO rift_vpl VALUES ("NU29_15","005_29_15","NUM","29","15","15","ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⵉⵣⵎⴰⵔ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵎⴰⵔⵔⴰ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU29_16","005_29_16","NUM","29","16","16","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_17","005_29_17","NUM","29","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NU29_18","005_29_18","NUM","29","18","18","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_19","005_29_19","NUM","29","19","19","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_20","005_29_20","NUM","29","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ: ⵃⵉⵟⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵉⵛⴰⵏ ⵇⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("NU29_21","005_29_21","NUM","29","21","21","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_22","005_29_22","NUM","29","22","22","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_23","005_29_23","NUM","29","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ: ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NU29_24","005_29_24","NUM","29","24","24","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_25","005_29_25","NUM","29","25","25","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_26","005_29_26","NUM","29","26","26","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ: ⵜⴻⵙⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NU29_27","005_29_27","NUM","29","27","27","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_28","005_29_28","NUM","29","28","28","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_29","005_29_29","NUM","29","29","29","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ: ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NU29_30","005_29_30","NUM","29","30","30","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_31","005_29_31","NUM","29","31","31","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_32","005_29_32","NUM","29","32","32","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ: ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NU29_33","005_29_33","NUM","29","33","33","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_34","005_29_34","NUM","29","34","34","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_35","005_29_35","NUM","29","35","35","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("NU29_36","005_29_36","NUM","29","36","36","ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴰⵎ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵙⵉⴷⵉ: ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ");
INSERT INTO rift_vpl VALUES ("NU29_37","005_29_37","NUM","29","37","37","ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ, ⵉ ⵉⵛⴰⵔⵔⵉ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NU29_38","005_29_38","NUM","29","38","38","ⵙⵡⴻⵊⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("NU29_39","005_29_39","NUM","29","39","39","ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏⵡⴻⵎ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵡⵄⵓⴷ ⵏⵡⴻⵎ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵉⵜⵜⵔⴰⵃⴻⵏ ⴰⴽ-ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵡⴻⵎ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("NU30_1","005_30_1","NUM","30","1","1","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU30_2","005_30_2","NUM","30","2","2","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴷ ⵜⴰ ⵎⵉⵏ ⵅⴻⴼ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("NU30_3","005_30_3","NUM","30","3","3","‘ⵅⵎⵉ ⵖⴰ ⵜⴰⴼⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵡⵛⴰ ⴰⵡⴰⵍ ⵏⵉⵖ ⵉⵊⵊⵓⴵ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ ⴰⵡⴰⵍ ⵏⵏⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU30_4","005_30_4","NUM","30","4","4","ⵅⵎⵉ ⵖⴰ ⵜⴰⴼⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵡⵛⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NU30_5","005_30_5","NUM","30","5","5","ⵓⵛⴰ ⴱⴰⴱⴰⵙ ⵉⵙⵍⴰ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵙ ⴷ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴱⴰⴱⴰⵙ ⵉⵙⵇⴰⵔ ⵣⵣⴰⵜⴻⵙ, ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵚⴻⵍⵃⴻⵏ ⴷ ⴽⵓⵍ ⴰⵇⵇⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵉⵚⵍⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("NU30_6","005_30_6","NUM","30","6","6","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴱⴰⴱⴰⵙ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⵜ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵙⵍⴰ ⴰⵢⴰ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵇⵇⴰⵏ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵚⴻⴵⴻⵃ ⵛⴰ. ⵙⵉⴷⵉ ⴰⴷ ⴰⵙ ⵉⵖⴼⴰⵔ, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰⵙ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⵜ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NU30_7","005_30_7","NUM","30","7","7","ⵎⴰⵍⴰ ⵜⵓⵖⴰ-ⵜⵜ ⵜⴻⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵛⴰ ⵅⴰⵙ ⵍⵡⵓⵄⵓⴷ ⵏⵉⵖ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵙ ⵜⵛⴰⵔⴼⴰⵢⴻⵃ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NU30_8","005_30_8","NUM","30","8","8","ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵙⵍⴰ ⴰⵙ ⵓⵛⴰ ⵉⵙⵇⴰⵔ ⵣⵣⴰⵜⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉⵙⵍⴰ ⴰⵢⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⴻⵍⵃⴻⵏ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⴷ ⴽⵓⵍ ⴰⵇⵇⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵉⵚⵍⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("NU30_9","005_30_9","NUM","30","9","9","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵙⵍⴰ ⴰⵢⴰ, ⵉⵏⵀⴰⵔ ⵉ-ⵜⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴱⴹⴻⵍ ⵍⵡⴰⵄⴷ ⵏⵏⵉ ⵅⴰⵙ ⵓⵍⴰ ⴷ ⴰⵡⴰⵍ ⵙ ⵜⵛⴰⵔⴼⴰⵢⴻⵃ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙ ⵉⵖⴼⴰⵔ ⴰⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("NU30_10","005_30_10","NUM","30","10","10","“ⵅ ⵍⵡⴰⵄⴷ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵉⵖ ⵏ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴵⴼⴻⵏ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵚⴻⴵⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("NU30_11","005_30_11","NUM","30","11","11","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴻⵡⵛⴰ ⴰⵡⴰⵍ ⵏⵉⵖ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NU30_12","005_30_12","NUM","30","12","12","ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵙⵍⴰ ⵉ ⵓⵢⴰ ⵓⵛⴰ ⵉⵙⵇⴰⵔ ⵣⵣⴰⵜⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⴱⴻⴷⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵚⴻⵍⵃⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⴰⵇⵇⴰⵏ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵉⵚⵍⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("NU30_13","005_30_13","NUM","30","13","13","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵙⵙⴻⴱⴹⴻⵍ ⴰⵢⴰ ⵇⴰⵄ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉⵙⵍⴰ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⵚⴻⴵⴻⵃ ⵛⴰ ⵇⴰⵄ ⵣⵉ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵏ ⵍⵡⵓⵄⵓⴷ ⵏⵉⵖ ⵏ ⵡⴰⵇⵇⴰⵏ. ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵙⵙⴻⴱⴹⴻⵍ ⴰⵢⴰ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙ ⵉⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU30_14","005_30_14","NUM","30","14","14","ⴽⵓⵍ ⵍⵡⴰⵄⴷ ⴷ ⴽⵓⵍ ⴰⵇⵇⴰⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵉ ⵓⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵡⴰⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵏⵉⵖ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⴻⴱⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NU30_15","005_30_15","NUM","30","15","15","ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵙⵇⴰⵔ ⵇⴰⵄ ⵣⴻⴳ ⵡⴰⵙⵙ ⵅ ⵡⴰⵙⵙ, ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⵏⵉⵖ ⴽⵓⵍ ⴰⵇⵇⴰⵏ ⵏⵏⴻⵙ ⵉ ⵅⴰⵙ ⵉⴵⴰⵏ. ⴰⵇⴰ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ-ⵜⴻⵏ ⵎⵉⵏⵣⵉ ⵉⵙⵇⴰⵔ ⵣⵣⴰⵜⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜⴻⵏ ⵉⵙⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU30_16","005_30_16","NUM","30","16","16","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙⴻⵏ ⵉⵙⵍⴰ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⴱⴹⴻⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⴱⵓ ⵏⴻⵜⵜⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("NU30_17","005_30_17","NUM","30","17","17","ⴰⵇⴰ ⴷ ⵜⵉⵏⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉ ⵣⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴷ ⵜⴻⵎⵖⴰⵔⵜ, ⵊⴰⵔ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵙⵙⵉⵙ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU31_1","005_31_1","NUM","31","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU31_2","005_31_2","NUM","31","2","2","“ⵏⵜⴰⵇⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵉⵎⵉⴷⵢⴰⵏⵉⵢⵢⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜᵉⵎⵎⴰⵔⵏⵉⴷ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("NU31_3","005_31_3","NUM","31","3","3","ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵙⵡⴻⵊⴷⴻⵎ ⵣⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵉ ⵎⵉⴷⵢⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴹⵉⴷⴷ ⵉ ⵎⵉⴷⵢⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵏ ⵏⵏⴻⵇⵎⴻⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⵎⵉⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_4","005_31_4","NUM","31","4","4","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵣⵉ ⴽⵓⵍ ⵉⵛⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU31_5","005_31_5","NUM","31","5","5","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⵜⴻⵏⵄⴰⵛ-ⵏ-ⵍⵓⵍⵓⴼ ⵏ ⵢⴻⵔⴰⵣⴻⵏ ⵉⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_6","005_31_6","NUM","31","6","6","ⵎⵓⵙⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵓ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵍⴻⴱⵡⴰⵇ ⵉ ⵓⵙⵓⴹⵉ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⵉ ⵓⵎⴻⵏⵖⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("NU31_7","005_31_7","NUM","31","7","7","ⵓⵛⴰ ⵎⵎⴻⵏⵖⴻⵏ ⴹⵉⴷⴷ ⵉ ⵉⵎⵉⴷⵢⴰⵏⵉⵢⵢⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵓⵛⴰ ⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU31_8","005_31_8","NUM","31","8","8","ⵙⴻⵏⵏⴻⵊ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ, ⵏⵖⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ: ⵉⵡⵉ, ⵔⴰⵇⵉⵎ, ⵚⵓⵔ, ⵃⵓⵔ ⴷ ⵔⴰⴱⴰⵄ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵓⵍⴰ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⵏⵖⵉⵏ ⵜ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("NU31_9","005_31_9","NUM","31","9","9","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⴻⴱⴱⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⵎⵉⴷⵢⴰⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ, ⵓ ⴽⴻⵛⵛⴹⴻⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴷ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_10","005_31_10","NUM","31","10","10","ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_11","005_31_11","NUM","31","11","11","ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴽⴻⵛⵛⴹⴻⵏ, ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ");
INSERT INTO rift_vpl VALUES ("NU31_12","005_31_12","NUM","31","12","12","ⵓⵛⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵎⴻⵃⴱⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵖⴰⵔ ⵎⵓⵙⴰ ⵓ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("NU31_13","005_31_13","NUM","31","13","13","ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵎⵎⵙⴰⴳⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_14","005_31_14","NUM","31","14","14","ⵉⴼⴼⵓⴳⴻⵎ ⵎⵓⵙⴰ ⴰⵟⵟⴰⵙ ⵅ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵅ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⵅ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_15","005_31_15","NUM","31","15","15","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵎⵓⵙⴰ: “ⵎⴰ ⵜⴻⵊⵊⵉⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⴰⵡⵜⴻⵏⵜ ⵉⴷⴷⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("NU31_16","005_31_16","NUM","31","16","16","ⵅⵣⴰⵔ, ⵙ ⵡⴻⵙⵛⴰⵏ ⵏ ⴱⴰⵍⵄⴰⵎ, ⵜⵉⵎⵖⴰⵔⵉⵏ-ⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴻⵙⴱⴰⴱ ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴷⴰⵔⴻⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⴼⴰⵖⵓⵔ ⵓⵛⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_17","005_31_17","NUM","31","17","17","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵏⵖⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏⵏⵉ ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓⵛⴰ ⵏⵖⴻⵎ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵜᵉⵟⵟⴻⵚ ⵏⴻⵜⵜⴰⵜ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("NU31_18","005_31_18","NUM","31","18","18","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵊⴰⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⴰⴽⵉⴷⴻⵙ ⵟⵟⵚⴻⵏⵜ, ⵊⵊⴻⵎ ⵜⴻⵏⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⴷ ⴷⴷⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU31_19","005_31_19","NUM","31","19","19","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵡⵜⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴽⵓⵍ ⵉⵊⵊⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⴽⵓⵍ ⵉⵊⵊⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵃⴰⴷⴰⵏ ⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ, ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⴽⴽⵙⴻⵏ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙ ⵙⴻⴱⵄⴰ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU31_20","005_31_20","NUM","31","20","20","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⵎ ⴷⴷⴻⵏⴱ ⵄⴰⵡⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵓⴹ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵉⵍⵎⴰⵡⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵜⵀⵉⴹⵓⵔⵜ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⴽⴻⵛⵛⵓⴹ.” ");
INSERT INTO rift_vpl VALUES ("NU31_21","005_31_21","NUM","31","21","21","ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⴽⴻⵀⵀⴰⵏ, ⵉⵏⵏⴰ ⵉ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ: “ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ: ");
INSERT INTO rift_vpl VALUES ("NU31_22","005_31_22","NUM","31","22","22","ⵎⵖⵉⵔ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵓⵣⵣⴰⵍ ⴷ ⵉⵙⵜⴰⵏⵢⵓ ⴷ ⵍⴻⵅⴼⵉⴼ, ");
INSERT INTO rift_vpl VALUES ("NU31_23","005_31_23","NUM","31","23","23","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵉ ⵜⵎⴻⵙⵙⵉ, ⵅ ⵜⵎⴻⵙⵙⵉ ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⴽⵙⴻⵎ ⴷⴷⴻⵏⴱ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⵅ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_24","005_31_24","NUM","31","24","24","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⵚⴻⴱⴱⵏⴻⵎ ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NU31_25","005_31_25","NUM","31","25","25","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU31_26","005_31_26","NUM","31","26","26","“ⵟⵟⴻⴼ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵃⴻⴱⴱⴻⵙ, ⵛⴻⴽ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⴰⴽ-ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU31_27","005_31_27","NUM","31","27","27","ⴱⴹⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵅ ⵜⵏⴰⵢⴻⵏ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⵛⴰⵔⵛⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴷ ⵢⵉⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵊⵊⵉⵀⴻⵜ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("NU31_28","005_31_28","NUM","31","28","28","ⵙⴳⴻⵄⵄⴷⴻⵜ ⵉⵛⵜ ⵏ ⵚⵚⴻⴷⵇⴻⵜ ⵉ ⵙⵉⴷⵉ ⵣⴻⴳ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ: ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵣⵉ ⵅⴻⵎⵙⴰ ⵎⵢⴰ ⵏ ⵉⵡⴷⴰⵏ ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓ ⵣⴻⴳ ⵉⵖⵢⴰⵍ ⵓ ⵣⴻⴳ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_29","005_31_29","NUM","31","29","29","ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏⵙⴻⵏ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵚⵚⴻⴷⵇⴻⵜ-ⴰ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⵡⵛⴻⴷ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_30","005_31_30","NUM","31","30","30","ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵊⵊ ⵣⵉ ⴽⵓⵍ ⵅⴻⵎⵙⵉⵏ: ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵣⴻⴳ ⵉⵖⵢⴰⵍ ⵓ ⵣⴻⴳ ⵡⵓⴵⵉ, ⵡⴰⵀ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ. ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⴰⵢⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("NU31_31","005_31_31","NUM","31","31","31","ⵓⵛⴰ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU31_32","005_31_32","NUM","31","32","32","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⵉ ⵉⴽⴻⵛⵛⴻⴹ ⵍⴳⴻⵏⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_33","005_31_33","NUM","31","33","33","ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NU31_34","005_31_34","NUM","31","34","34","ⵡⴰⵃⵉⵜ ⵓ-ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵢⴰⵍ ");
INSERT INTO rift_vpl VALUES ("NU31_35","005_31_35","NUM","31","35","35","ⵓⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵣⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⵚⴻⵏ ⴷⵉ ⵇⴰⵎⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("NU31_36","005_31_36","NUM","31","36","36","ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ, ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("NU31_37","005_31_37","NUM","31","37","37","ⵚⵚⴻⴷⵇⴻⵜ ⵉ ⵙⵉⴷⵉ ⵏ ⵡⵓⴵⵉ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_38","005_31_38","NUM","31","38","38","ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓⵛⴰ ⵚⵚⴻⴷⵇⴻⵜ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_39","005_31_39","NUM","31","39","39","ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵢⴰⵍ ⵓⵛⴰ ⵚⵚⴻⴷⵇⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵡⴰⵃⵉⵜ ⵓ-ⵙⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_40","005_31_40","NUM","31","40","40","ⵓⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⵟⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓ ⴰⵚⴻⴷⴷⴻⵇ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉ ⵙⵉⴷⵉ ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_41","005_31_41","NUM","31","41","41","ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵚⵚⴻⴷⵇⴻⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ, ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU31_42","005_31_42","NUM","31","42","42","ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣ ⵎⵓⵙⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵏⵖⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU31_43","005_31_43","NUM","31","43","43","- ⴰⵣⵢⴻⵏ ⵏⵏⵉ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ ⵎⵢⴰ ⵏ ⵡⵓⴵⵉ, ");
INSERT INTO rift_vpl VALUES ("NU31_44","005_31_44","NUM","31","44","44","ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NU31_45","005_31_45","NUM","31","45","45","ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵖⵢⴰⵍ ");
INSERT INTO rift_vpl VALUES ("NU31_46","005_31_46","NUM","31","46","46","ⵓⵛⴰ ⵙⴻⵟⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵡⴷⴰⵏ - ");
INSERT INTO rift_vpl VALUES ("NU31_47","005_31_47","NUM","31","47","47","ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⴽⵙⵉ ⵎⵓⵙⴰ ⵉⵊⵊ ⵣⵉ ⴽⵓⵍ ⵅⴻⵎⵙⵉⵏ, ⴰⵎⵎⵓ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⴰⵎ ⵣⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ, ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵢⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU31_48","005_31_48","NUM","31","48","48","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵅ ⵍⵓⵍⵓⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵖⴰⵔ ⵎⵓⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("NU31_49","005_31_49","NUM","31","49","49","ⵏⵏⴰⵏ ⵉ ⵎⵓⵙⴰ: “ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵇⴰ ⵃⴻⵙⴱⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵖ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵔⵓⵃ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("NU31_50","005_31_50","NUM","31","50","50","ⵙ ⵓⵢⴰ ⵏⵉⵡⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵙⵉⴷⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵎⵉⵏ ⵢⵓⴼⴰ: ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⵓⵔⴻⵖ, ⵉⵛⵜ ⵏ ⵜⵅⴻⵍⵅⴰⵍⵜ, ⵉⵛⵜ ⵏ ⵜⵎⴻⵇⵢⴰⵙⵜ, ⵉⵛⵜ ⵏ ⵜⵅⴰⵜⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ, ⵉⵛⵜ ⵏ ⵜⴻⵅⵔⴰⵣⵜ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵙ ⵡⴻⴷⵎⴰⵎ ⵏ ⵡⵓⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("NU31_51","005_31_51","NUM","31","51","51","ⵎⵓⵙⴰ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴽⵙⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵔⴻⵖ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⴳⴳⵉⵏ ⵙ ⵍⴼⴻⵏⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_52","005_31_52","NUM","31","52","52","ⵎⴰⵔⵔⴰ ⵓⵔⴻⵖ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉ ⵙⵉⴷⵉ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⵜⵓⵖⴰ ⴷⵉ ⵙⴻⵟⵟⴰⵛ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("NU31_53","005_31_53","NUM","31","53","53","ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⵇⴰ ⴽⴻⵛⵛⴹⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⵉⵏ ⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU31_54","005_31_54","NUM","31","54","54","ⵎⵓⵙⴰ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵟⵟⴼⴻⵏ ⵓⵔⴻⵖ ⵏⵏⵉ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⵅ ⵎⵢⴰ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU32_1","005_32_1","NUM","32","1","1","ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵄⵣⵉⵔ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵊⵊⵉⵀⴻⵜ ⵏⵏⵉ ⵜⴻⵛⵏⴰ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU32_2","005_32_2","NUM","32","2","2","ⵓⵙⵉⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("NU32_3","005_32_3","NUM","32","3","3","“ⵄⴰⵟⴰⵔⵓⵜ, ⴷⵉⴱⵓⵏ, ⵢⴰⵄⵣⵉⵔ, ⵏⵉⵎⵔⴰ, ⵃⴰⵛⴱⵓⵏ, ⴰⵍⵉⵄⴰⵍⴰ, ⵛⴰⴱⴰⵎ, ⵏⴰⴱⵓ ⴷ ⴱⴰⵄⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("NU32_4","005_32_4","NUM","32","4","4","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⵖⵍⴻⴱ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵏⴰ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵏⴻⵛⵛⵉⵏ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU32_5","005_32_5","NUM","32","5","5","ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵏⵓⴼⴰ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰ ⵣⴻⵄⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⴷ ⴰⴳⵍⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵏⴻⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU32_6","005_32_6","NUM","32","6","6","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵅ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⵅ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ: “ⵎⴰⵍⴰ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴳⴰⵔⵔⴰ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("NU32_7","005_32_7","NUM","32","7","7","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵄⴻⴳⵣⴻⵎ ⵓⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵥⴻⴽⴽⵯⵉⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("NU32_8","005_32_8","NUM","32","8","8","ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⴻⴽⴽⴻⵖ ⵣⵉ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU32_9","005_32_9","NUM","32","9","9","ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵉⵛⴽⵓⵍ ⵓⵛⴰ ⵥⵔⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵇⴻⵍⴱⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵉⴷⴼⴻⵏ ⵛⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU32_10","005_32_10","NUM","32","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵊⵊⵓⴵ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU32_11","005_32_11","NUM","32","11","11","‘ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵡⴰⵔ ⵥⴰⵔⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴹⴼⴰⵔⴻⵏ ⵏⵉⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU32_12","005_32_12","NUM","32","12","12","ⵎⵖⵉⵔ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⴰⵇⵉⵏⵉⵣⵉ, ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("NU32_13","005_32_13","NUM","32","13","13","ⵓⵛⴰ ⴰⵎⵎⵓ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴷⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⴻⵍⵍⵄⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵍⴰⵎⵉ ⵉⴼⵏⴰ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("NU32_14","005_32_14","NUM","32","14","14","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵡⵡⵖⴻⵎ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴰⵔⵏⵉⵎ ⵄⴰⴷ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU32_15","005_32_15","NUM","32","15","15","ⵎⴰⵍⴰ ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴻⵊⵊ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⴻⵅⵍⴰ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵊⵊⴻⵎ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⵢⴰ ⴰⴷ ⵉⵀⴻⵍⵍⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("NU32_16","005_32_16","NUM","32","16","16","ⵅⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵏⵏⴰⵏ: “ⴰⴷ ⵏⴻⴱⵏⴰ ⴷⴰ ⵍⴽⵓⵔⵉⵢⵢⴰⵜ ⵉ ⵡⵓⴵⵉ ⵏⵏⴻⵖ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("NU32_17","005_32_17","NUM","32","17","17","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴷⴷ-ⵏⴻⴼⴼⴻⵖ ⵏⴻⵡⵊⴻⴷ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵖ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵏⴻⵙⵙⵉⵡⴻⴹ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU32_18","005_32_18","NUM","32","18","18","ⵡⴰⵔ ⵏᵉⴷⴷⴻⴽⴽⵡⵉⵍ ⵖⴰⵔ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ ⴰⵍ ⵉ ⵖⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU32_19","005_32_19","NUM","32","19","19","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⵜⴻⵟⵟⴻⴼ ⴷⵉ ⵍⵡⴰⵔⵜ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏⵏⴻⵖⵏⵉ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵍⴰ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔ ⵜⵎⴰ-ⵢⴰ ⵜⴰⵏⵉⵜⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ.” ");
INSERT INTO rift_vpl VALUES ("NU32_20","005_32_20","NUM","32","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵎⵓⵙⴰ: “ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⵎ ⴰⵎⵎⵓ, ⵎⴰⵍⴰ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("NU32_21","005_32_21","NUM","32","21","21","ⵓ ⴽⵓⵍ ⵉⵊⵊ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵏⵖⵉ, ⴰⴷ ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵍ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵏ ⵍⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("NU32_22","005_32_22","NUM","32","22","22","ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵅⴹⴻⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ ⵓ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵓ ⵣⵣⴰⵜ ⵉ ⵉⵙⵔⴰⵉⵍ ⴱⵍⴰ ⴰⵎⴰⵔⵡⴰⵙ ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⴷ ⴰⴳⵍⴰ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NU32_23","005_32_23","NUM","32","23","23","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴳⴳⵉⵎ ⴰⵎⵎⵓ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵜⴻⵅⴹⴰⵎ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴷⴷⴻⵏⴱ ⵏⵡⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("NU32_24","005_32_24","NUM","32","24","24","ⴱⵏⴰⵎ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵍⴽⵓⵔⵉⵢⵢⴰⵜ ⵉ ⵡⵓⴵⵉ ⵏⵡⴻⵎ ⵓⵛⴰ ⴳⴳⴻⵎ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NU32_25","005_32_25","NUM","32","25","25","ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵏⵏⴰⵏ: “ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("NU32_26","005_32_26","NUM","32","26","26","ⵜⴰⵔⵡⴰ ⵏⵏⴻⵖ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖ, ⵍⴻⴽⵙⵉⴱⴻⵜ ⵏⵏⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵊⵉⵍⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("NU32_27","005_32_27","NUM","32","27","27","ⵎⴰⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵥⵡⴰⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("NU32_28","005_32_28","NUM","32","28","28","ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵅⴰⵙⴻⵏ ⵎⵓⵙⴰ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵓ ⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("NU32_29","005_32_29","NUM","32","29","29","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵎⵓⵙⴰ: “ⵎⴰⵍⴰ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴰⴷ ⴽⵉⵡⴻⵎ ⵥⵡⴰⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵅⴹⴻⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⴰⴷ ⵜⴰⴼ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ ⴷ ⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU32_30","005_32_30","NUM","32","30","30","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⵥⴻⴽⴽⵯⵉⵎ ⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⴳⵍⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU32_31","005_32_31","NUM","32","31","31","ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("NU32_32","005_32_32","NUM","32","32","32","ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵡⵊⴻⴷ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵖ ⵏ ⵍⵡⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵖⴰⵔ ⵜⵎⴰ-ⵢⴰ ⵡⴰⵏⵉⵜⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU32_33","005_32_33","NUM","32","33","33","ⵓ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵎⵓⵙⴰ, ⵉ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⵉ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵓ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU32_34","005_32_34","NUM","32","34","34","ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴱⵏⴰⵏ ⴷⵉⴱⵓⵏ, ⵄⴰⵟⴰⵔⵓⵜ, ⵄⴰⵔⵓⵄⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("NU32_35","005_32_35","NUM","32","35","35","ⵄⴰⵟⵔⵓⵜ-ⵛⵓⴼⴰⵏ, ⵢⴰⵄⵣⵉⵔ, ⵢⵓⵊⴱⴰⵀⴰ, ");
INSERT INTO rift_vpl VALUES ("NU32_36","005_32_36","NUM","32","36","36","ⴱⴰⵢⵜ-ⵏⵉⵎⵔⴰ ⴷ ⴱⴰⵢⵜ-ⵀⴰⵔⴰⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷ ⵍⴽⵓⵔⵉⵢⵢⴰⵜ ⵉ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("NU32_37","005_32_37","NUM","32","37","37","ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴱⵏⴰⵏ ⵃⴰⵛⴱⵓⵏ, ⴰⵍⵉⵄⴰⵍⴰ, ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("NU32_38","005_32_38","NUM","32","38","38","ⵏⴰⴱⵓ, ⴱⴰⵄⵍ-ⵎⴰⵄⵓⵏ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵉⵜⵜⵡⴰⴱⴻⴷⴷⴻⵍ ⵉⵙⴻⵎ ⵏⵙⴻⵏ, ⴷ ⵙⵉⴱⵎⴰ, ⵓⵛⴰ ⵍⴰⵖⴰⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⴱⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU32_39","005_32_39","NUM","32","39","39","ⴰⵢⵜ ⵏ ⵎⴰⴽⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵊⵉⵍⵄⴰⴷ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜⵜ ⵓⵛⴰ ⵓⵥⵥⵍⴻⵏ ⵅ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU32_40","005_32_40","NUM","32","40","40","ⵓⵛⴰ ⵎⵓⵙⴰ ⵉⵡⵛⴰ ⵊⵉⵍⵄⴰⴷ ⵉ ⵎⴰⴽⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵓⵛⴰ ⵉⵔⵓⵃ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU32_41","005_32_41","NUM","32","41","41","ⵓⵛⴰ ⵢⴰ’ⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵉⵔⵓⵃ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙⴻⵏⵜ ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰ’ⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("NU32_42","005_32_42","NUM","32","42","42","ⴰⵎⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵏⵓⴱⴰⵃ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵇⵉⵏⴰⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓⵛⴰ ⵉⵙⴻⵎⵎⴰ ⴰⵙ ⵏⵓⴱⴰⵃ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU33_1","005_33_1","NUM","33","1","1","ⴰⵎⵎⵓ ⵉ ⵙⵙⵎⵎⵓⵟⵟⵉⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ, ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_2","005_33_2","NUM","33","2","2","ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵢⵓⵔⴰ ⵎⵓⵙⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵔⴻⵃⵃⴰⵍⴻⵏ ⵏⵙⴻⵏ. ⵉⵏⴰ ⴷ ⵉⵔⴻⵃⵃⴰⵍⴻⵏ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_3","005_33_3","NUM","33","3","3","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⴰⵄⴰⵎⵙⵉⵙ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ. ⴷⵉ ⵚⵚⴱⴻⵃ, ⴷⴻⵖⵢⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NU33_4","005_33_4","NUM","33","4","4","ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴻⵖⵍⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵏⴻⵟⵟⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵡⵜⴰ ⵙⵉⴷⵉ ⵙ ⵍⵎⴻⵡⵜ ⵊⴰⵔ ⴰⵙⴻⵏ. ⵄⴰⵡⴻⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵙⵉⴷⵉ ⵍⴻⵃⴽⴰⵎ ⵏⵏⴻⵙ ⵅ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_5","005_33_5","NUM","33","5","5","ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⴰⵄⴰⵎⵙⵉⵙ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵙⵓⴽⴽⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_6","005_33_6","NUM","33","6","6","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵓⴽⴽⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵉⵜⴰⵎ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_7","005_33_7","NUM","33","7","7","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵉⵜⴰⵎ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴱⵉ-ⵀⴰⵃⵉⵔⵓⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴱⴰⵄⵍ-ⵚⴰⴼⵓⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵊⴷⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("NU33_8","005_33_8","NUM","33","8","8","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴱⵉ-ⵀⴰⵃⵉⵔⵓⵜ ⵓⵛⴰ ⵛⵓⴽⴽⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵉⵜⴰⵎ, ⵅⴻⵏⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_9","005_33_9","NUM","33","9","9","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⴰⵔⴰ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵍⵉⵎ, ⵎⴰⵏⵉ ⵉⴵⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵖⴱⴰⵍⵓⵜⴻⵏ ⵏ ⵡⴰⵎⴰⵏ ⴷ ⵙⴻⴱⵄⵉⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_10","005_33_10","NUM","33","10","10","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵉⵍⵉⵎ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_11","005_33_11","NUM","33","11","11","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_12","005_33_12","NUM","33","12","12","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⴷⵓⴼⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_13","005_33_13","NUM","33","13","13","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴷⵓⴼⵇⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⴰⵍⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("NU33_14","005_33_14","NUM","33","14","14","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴰⵍⵓⵛ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵔⴰⴼⵉⴷⵉⵎ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵢⵓⴼⵉ ⴰⵎⴰⵏ ⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_15","005_33_15","NUM","33","15","15","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⴰⴼⵉⴷⵉⵎ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_16","005_33_16","NUM","33","16","16","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵙⵉⵏⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵇⴰⴱⴰⵔⵓⵜ-ⵀⴰⵜⴰ’ⴰⵡⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_17","005_33_17","NUM","33","17","17","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵇⴰⴱⴰⵔⵓⵜ-ⵀⴰⵜⴰ’ⴰⵡⴰⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵃⴰⴹⴰⵢⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_18","005_33_18","NUM","33","18","18","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵃⴰⴹⴰⵢⵔⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵔⵉⵜⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_19","005_33_19","NUM","33","19","19","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⵉⵜⵎⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵔⵉⵎⵎⵓⵏ-ⴼⴰⵔⵉⵚ. ");
INSERT INTO rift_vpl VALUES ("NU33_20","005_33_20","NUM","33","20","20","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⵉⵎⵎⵓⵏ-ⴼⴰⵔⵉⵚ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_21","005_33_21","NUM","33","21","21","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵉⴱⵏⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵔⵉⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_22","005_33_22","NUM","33","22","22","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⵉⵙⵙⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵇⵉⵀⴰⵢⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_23","005_33_23","NUM","33","23","23","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵇⵉⵀⴰⵢⵍⴰⵜⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵡⴻⴷⵔⴰⵔ ⵏ ⵛⴰⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU33_24","005_33_24","NUM","33","24","24","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵛⴰⴼⴰⵔ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵃⴰⵔⴰⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_25","005_33_25","NUM","33","25","25","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵃⴰⵔⴰⴷⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵇⵀⴰⵢⵍⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_26","005_33_26","NUM","33","26","26","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⴰⵇⵀⴰⵢⵍⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴰⵃⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_27","005_33_27","NUM","33","27","27","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴰⵃⴰⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴰⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("NU33_28","005_33_28","NUM","33","28","28","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴰⵔⴰⵃ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⵉⵜⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_29","005_33_29","NUM","33","29","29","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵜⵇⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵃⴰⵛⵎⵓⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_30","005_33_30","NUM","33","30","30","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵃⴰⵛⵎⵓⵏⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⵓⵙⵉⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_31","005_33_31","NUM","33","31","31","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵓⵙⵉⵔⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⴱⴰⵏⵉ-ⵢⴰⵄⵇⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_32","005_33_32","NUM","33","32","32","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴱⴰⵏⵉ-ⵢⴰⵄⵇⴰⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵃⵓⵔ-ⵊⵉⴷⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU33_33","005_33_33","NUM","33","33","33","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵉ ⵀⵓⵔ-ⵊⵉⴷⵊⴰⴷ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵢⵓⵜⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_34","005_33_34","NUM","33","34","34","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵉ ⵢⵓⵜⴱⴰⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵄⴰⴱⵔⵓⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_35","005_33_35","NUM","33","35","35","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵉ ⵄⴰⴱⵔⵓⵏⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU33_36","005_33_36","NUM","33","36","36","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵉ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⴰⵔ ⵓⵛⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ ⵏⵏⵉ ⵢⴻⴵⴰ ⵇⴰⴷⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("NU33_37","005_33_37","NUM","33","37","37","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵇⴰⴷⴰⵛ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ, ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("NU33_38","005_33_38","NUM","33","38","38","ⵢⵓⵍⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⴰⴷⵔⴰⵔ ⵏ ⵀⵓⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴷⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⵉⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⴼⴼⵓⵖ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU33_39","005_33_39","NUM","33","39","39","ⵜⵓⵖⴰ ⵀⴰⵔⵓⵏ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU33_40","005_33_40","NUM","33","40","40","ⵓⵛⴰ ⴰⴽⴻⵏⵄⴰⵏⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵔⴰⴷ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⵙⵍⴰ ⵙ ⵜⵡⴰⵙⵉⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NU33_41","005_33_41","NUM","33","41","41","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵚⴰⵍⵎⵓⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_42","005_33_42","NUM","33","42","42","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵚⴰⵍⵎⵓⵏⴰ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⴼⵓⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_43","005_33_43","NUM","33","43","43","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴼⵓⵏⵓⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵓⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("NU33_44","005_33_44","NUM","33","44","44","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵓⴱⵓⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵄⴰⴱⴰⵔⵉⵎ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵡⴻⵢⵎⵉⵔ ⴰⴽ-ⴷ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU33_45","005_33_45","NUM","33","45","45","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵄⴰⴱⴰⵔⵉⵎ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⴷⵉⴱⵓⵏ-ⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU33_46","005_33_46","NUM","33","46","46","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⴷⵉⴱⵓⵏ-ⵊⴰⴷ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵄⴰⵍⵎⵓⵏ-ⴷⵉⴱⵍⴰⵜⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NU33_47","005_33_47","NUM","33","47","47","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵄⴰⵍⵎⵓⵏ-ⴷⵉⴱⵍⴰⵜⴰⵢⵉⵎ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⴰⴱⴰⵔⵉⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵏⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("NU33_48","005_33_48","NUM","33","48","48","ⴼⴻⵙⵢⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⴰⴱⴰⵔⵉⵎ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵉ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_49","005_33_49","NUM","33","49","49","ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵉ ⴱⴰⵢⵜ-ⵢⴰⵛⵉⵎⵓⵜ ⴰⵍ ⴰⴱⴰⵍ-ⵛⵉⵟⵟⵉⵎ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("NU33_50","005_33_50","NUM","33","50","50","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU33_51","005_33_51","NUM","33","51","51","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU33_52","005_33_52","NUM","33","52","52","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵡⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⵜⴰⵔⴻⴷⴵⴻⵎ. ⵄⴰⵡⴻⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⴻⵃⵃⴰⵎ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU33_53","005_33_53","NUM","33","53","53","ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⵖⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU33_54","005_33_54","NUM","33","54","54","ⴰⴷ ⵜⴻⴱⴹⴰⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⴰⵎ ⵍⵡⴰⵔⵜ ⵅ ⵍⴰⴵⴰⵜ ⵏⵡⴻⵎ. ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⵟⵟⴰⵙ, ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⵎ ⴰⵟⵟⴰⵙ, ⵓ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴷⵔⵓⵙ, ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⵎ ⴷⵔⵓⵙ. ⵎⴰⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵙⴰ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵏⵏⴻⵙ. ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⴷ ⵜⵡⴰⵔⵜⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU33_55","005_33_55","NUM","33","55","55","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⵓⴼⴼⵓⵖⴻⵎ ⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵊⵊⴻⵎ ⴰⴷ ⵇⵇⵉⵎⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷ ⵉⵡⴻⵣⵡⵉⵣⴻⵏ ⴷⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵃⵚⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU33_56","005_33_56","NUM","33","56","56","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵅⴰⵔⵔⵚⴻⵖ ⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU34_1","005_34_1","NUM","34","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU34_2","005_34_2","NUM","34","2","2","“ⵓⵎⵓⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵅⴻⵏⵏⵉ ⵜⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵍⵡⴰⵔⵜ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴰⴽ-ⴷ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎⵎⵓ: ");
INSERT INTO rift_vpl VALUES ("NU34_3","005_34_3","NUM","34","3","3","ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵉⴷⵓⵎ ⵓⵛⴰ ⴰⵢⵎⵉⵔ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ ⴷⵉ ⵛⵛⴰⵔⵇ ");
INSERT INTO rift_vpl VALUES ("NU34_4","005_34_4","NUM","34","4","4","ⵓⵛⴰ ⴰⵢⵎⵉⵔ ⴰⴷ ⵉⵎⴻⵢⵢⴻⵍ ⵣⵉ ⵍⵊⴰⵏⵓⴱ ⵖⴰⵔ ⵜⵙⵓⵏⵜⴰ ⵏ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ ⵓⵛⴰ ⴰⴷ ⵉⵄⴷⵓ ⵖⴰⵔ ⵚⵉⵏ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⴰⵡⴹⴻⵏ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ ⵓⵛⴰ ⴰⴷ ⵉⵄⴷⵓ ⵖⴰⵔ ⵃⴰⵚⴰⵔ-ⴰⴷⴷⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵥⵡⴰ ⵖⴰⵔ ⴰⵚⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU34_5","005_34_5","NUM","34","5","5","ⴰⴷ ⵉⵏⵏⴻⴹ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⴰⵚⵎⵓⵏ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NU34_6","005_34_6","NUM","34","6","6","ⵓⵛⴰ ⴰⵢⵎⵉⵔ ⵏ ⵍⵖⴰⵔⴱ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵡⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵍⵖⴰⵔⴱ.” ");
INSERT INTO rift_vpl VALUES ("NU34_7","005_34_7","NUM","34","7","7","ⵡⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵛⵛⴰⵎⴰⵍ: ⴰⴷ ⵜ ⵜⴰⵔⵛⵎⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⴰⴷⵔⴰⵔ ⵏ ⵀⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("NU34_8","005_34_8","NUM","34","8","8","ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ ⴰⴷ ⵜ ⵜⴰⵔⵛⵎⴻⵎ ⴰⵍ ⵎⴰⵏⵉ ⵖⴰ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏ ⵡⴻⵢⵎⵉⵔ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⵍ ⵚⴰⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NU34_9","005_34_9","NUM","34","9","9","ⴰⴷ ⵢⴻⵄⴷⵓ ⵡⴻⵢⵎⵉⵔ ⴰⵍ ⵣⵉⴼⵔⵓⵏ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⵍ ⵃⴰⵚⴰⵔ-ⵄⵉⵏⴰⵏ. ⵡⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("NU34_10","005_34_10","NUM","34","10","10","ⴰⴷ ⵜⴰⵔⵛⵎⴻⵎ ⴰⵢⵎⵉⵔ ⵏⵡⴻⵎ ⵏ ⵛⵛⴰⵔⵇ ⵣⵉ ⵃⴰⵚⴰⵔ-ⵄⵉⵏⴰⵏ ⵖⴰⵔ ⵛⴰⴼⴰⵎ ");
INSERT INTO rift_vpl VALUES ("NU34_11","005_34_11","NUM","34","11","11","ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⵛⴼⴰⵎ ⴰⵍ ⵔⵉⴱⵍⴰ, ⵛⵛⴰⵔⵇ ⵏ ⵄⴰⵢⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵡⴻⵢⵎⵉⵔ ⵄⴰⴷ ⴽⵜⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵎⵓⵏ ⴰⴽ-ⴷ ⵜⵎⴰ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⴽⵉⵏⵏⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NU34_12","005_34_12","NUM","34","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ. ⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴽ-ⴷ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NU34_13","005_34_13","NUM","34","13","13","ⵓⵛⴰ ⵎⵓⵙⴰ ⵢⵓⵎⵓⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵜⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴱⴹⴰⵎ ⵊⴰⵔ ⴰⵡⴻⵎ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⵜⴻⵏⵏⵉ ⵅ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⵜⴻⵙⵄⴰ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵓ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU34_14","005_34_14","NUM","34","14","14","ⵎⵉⵏⵣⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵓ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴻⴼ ⵄⵍⴰⵃⵚⴰⴱ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵄⴰⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵓ ⴰⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜᵉⵟⵟⴻⴼ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU34_15","005_34_15","NUM","34","15","15","ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⴰⵇⴰ ⵟⵟⴼⴻⵏⵜ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⵉ ⴰⵔⵉⵃⴰ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("NU34_16","005_34_16","NUM","34","16","16","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU34_17","005_34_17","NUM","34","17","17","“ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⴱⴹⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵊⴰⵔ ⴰⵡⴻⵎ: ⴰⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NU34_18","005_34_18","NUM","34","18","18","ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴱⴹⴰⵎ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NU34_19","005_34_19","NUM","34","19","19","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ: ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ ");
INSERT INTO rift_vpl VALUES ("NU34_20","005_34_20","NUM","34","20","20","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵛⵉⵎⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("NU34_21","005_34_21","NUM","34","21","21","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵍⵉⴷⴰⴷ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵙⵍⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("NU34_22","005_34_22","NUM","34","22","22","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ, ⵍⵃⴰⴽⴻⵎ ⴱⵓⵇⵇⵉ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵊⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("NU34_23","005_34_23","NUM","34","23","23","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ: ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵍⵃⴰⴽⴻⵎ ⵃⴰⵏⵏⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵉⴼⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("NU34_24","005_34_24","NUM","34","24","24","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵍⵃⴰⴽⴻⵎ ⵇⵉⵎⵓⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⵉⴼⵟⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU34_25","005_34_25","NUM","34","25","25","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵍⵃⴰⴽⴻⵎ ⵉⵍⵉⵚⴰⴼⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵔⵏⴰⵅ, ");
INSERT INTO rift_vpl VALUES ("NU34_26","005_34_26","NUM","34","26","26","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵍⵃⴰⴽⴻⵎ ⴼⴰⵍⵟⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⵣⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU34_27","005_34_27","NUM","34","27","27","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ, ⵍⵃⴰⴽⴻⵎ ⴰⵅⵉⵀⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⵓⵎⵉ, ");
INSERT INTO rift_vpl VALUES ("NU34_28","005_34_28","NUM","34","28","28","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵍⵃⴰⴽⴻⵎ ⴼⴰⴷⴰⵀⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("NU34_29","005_34_29","NUM","34","29","29","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵅ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⴰⴷ ⴱⴹⴰⵏ ⵍⵡⴰⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_1","005_35_1","NUM","35","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ ⵓⵛⴰ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU35_2","005_35_2","NUM","35","2","2","“ⵓⵎⵓⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ, ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵉ ⵟⵟⴼⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵣⴻⴷⵖⴻⵏ. ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵄⴰⵡⴻⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NU35_3","005_35_3","NUM","35","3","3","ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵣⴻⴷⵖⴻⵏ, ⵓⵛⴰ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⵓ ⵉ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_4","005_35_4","NUM","35","4","4","ⵓⵛⴰ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵡⵛⴻⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⴷ ⵉⵍⵉⵏ ⵣⴻⴳ ⵡⴻⵖⴱⴰⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU35_5","005_35_5","NUM","35","5","5","ⴱⴰⵔⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⴰⴷ ⵜⵄⴻⴱⴱⴰⵔⴻⵎ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵟ. ⵉⵏⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵏ ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NU35_6","005_35_6","NUM","35","6","6","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰ ⵜⴻⵡⵛⴻⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵙⴻⵜⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ. ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵡⵛⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵢⴰⵔⵡⴻⵍ ⵓⵇⴻⵜⵜⴰⵍ. ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵡⵛⴻⵎ ⵄⴰⴷ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NU35_7","005_35_7","NUM","35","7","7","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰ ⵜⴻⵡⵛⴻⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ, ⵜⵉⵏⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏⵜ ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU35_8","005_35_8","NUM","35","8","8","ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰ ⵜⴻⵡⵛⴻⵎ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴽⵙⵉⵎ ⴽⵜⴰⵔ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⵟⵟⴰⵙ ⵓ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴷⵔⵓⵙ, ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴷⵔⵓⵙ. ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵡⵛ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵍⵡⴰⵔⵜ ⵉ ⵉⵟⵟⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("NU35_9","005_35_9","NUM","35","9","9","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("NU35_10","005_35_10","NUM","35","10","10","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NU35_11","005_35_11","NUM","35","11","11","ⴰⴷ ⵜⵏⴻⵢⵢⵛⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵍⵉⵏⵜ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ, ⵃⵉⵎⴰ ⴰⵇⴻⵜⵜⴰⵍ, ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵃⴻⴷ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NU35_12","005_35_12","NUM","35","12","12","ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏⵜ ⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵣⴻⴳ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵓⵇⴻⵜⵜⴰⵍ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("NU35_13","005_35_13","NUM","35","13","13","ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰ ⵜⴻⵡⵛⴻⵎ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⵍⵉⵏⵜ ⵙⴻⵜⵜⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("NU35_14","005_35_14","NUM","35","14","14","ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵡⵛⴻⵎ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵡⵛⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NU35_15","005_35_15","NUM","35","15","15","ⵙⴻⵜⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷ ⵓⵎⵄⴻⵣⵣⴻⴱ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵃⴻⴷ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NU35_16","005_35_16","NUM","35","16","16","ⵎⴰⵍⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⵙ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓⵛⴰ ⵉⵎⵎⵓⵜ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵇⴻⵜⵜⴰⵍ. ⴰⵇⴻⵜⵜⴰⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_17","005_35_17","NUM","35","17","17","ⵎⴰⵍⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉ ⵣⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵏⴻⵇⵇⴰⵎ. ⴰⵏⴻⵇⵇⴰⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_18","005_35_18","NUM","35","18","18","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⵙ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉ ⵣⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵇⴻⵜⵜⴰⵍ. ⴰⵇⴻⵜⵜⴰⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_19","005_35_19","NUM","35","19","19","ⴰⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴰⴷ ⵉⵏⴻⵖ ⴰⵇⴻⵜⵜⴰⵍ. ⵎⴰⵍⴰ ⴰⴷ ⵜ ⵉⵍⵇⴰ, ⴰⴷ ⵜ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NU35_20","005_35_20","NUM","35","20","20","ⵓ ⵎⴰⵍⴰ ⵉⵄⴰⵔⵏ ⵉ-ⵜ ⵙ ⵡⴻⵛⵔⴰⵀ, ⵏⵉⵖ ⵉⵏⴹⴰⵔ ⵖⴰⵔⴻⵙ ⵛⴰ ⵙ ⵏⴻⵄⵎⴰⴷⴰ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵎⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("NU35_21","005_35_21","NUM","35","21","21","ⵏⵉⵖ ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⵙ ⵍⴻⵄⴷⴰⵡⴻⵜ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵎⵎⵓⵜ, ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⵏⵖⵉⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ⴰⵇⴰ-ⵜ ⴷ ⴰⵇⴻⵜⵜⴰⵍ. ⴰⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴰⴷ ⵉⵏⴻⵖ ⴰⵇⴻⵜⵜⴰⵍ ⵅⵎⵉ ⵜ ⵖⴰ ⵉⵍⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("NU35_22","005_35_22","NUM","35","22","22","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵄⴰⵔⵔⴻⵏ ⵉ-ⵜ ⴰⵎⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⴱⵍⴰ ⵍⴻⵄⴷⴰⵡⴻⵜ, ⵏⵉⵖ ⵉⵏⴹⴰⵔ ⵖⴰⵔⴻⵙ ⵛⴰ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⴰⵎ ⵉⵡⴻⴷⴷⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU35_23","005_35_23","NUM","35","23","23","ⵏⵉⵖ ⴰⵎ ⵡⴰⵔ ⵜ ⵉⵥⵔⵉ, ⵉⴳⴳⴰ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵉⵡⴹⴰ ⵛⴰ ⵏ ⵡⴻⵥⵔⵓ ⵉ ⵣⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⴰⵎ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴰⵔⴻⵣⵣⵓ ⵍⵖⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NU35_24","005_35_24","NUM","35","24","24","ⵅⴻⵏⵏⵉ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵜⴻⵃⴽⴻⵎ ⵊⴰⵔ ⵓⵇⴻⵜⵜⴰⵍ ⴷ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NU35_25","005_35_25","NUM","35","25","25","ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵜⴼⴻⴽⴽ ⴰⵇⴻⵜⵜⴰⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵜⴻⵊⵊ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵍⴰ. ⴰⴷ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⴰⵍ ⵍⵎⴻⵡⵜ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵡⴻⵏⵏⵉ ⴷⴻⵀⵏⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵣⵣⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_26","005_35_26","NUM","35","26","26","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵇⴻⵜⵜⴰⵍ ⵉⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵏ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵎⴰⵏⵉ ⵢⴰⵔⵡⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("NU35_27","005_35_27","NUM","35","27","27","ⵓⵛⴰ ⴰⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵢⵓⴼⴰ ⵉ-ⵜ ⴱⴰⵔⵔⴰ ⵏ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵓⵛⴰ ⴰⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵖⴰ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ, ⵡⴰⵔ ⵅⴰⵙ ⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵅⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NU35_28","005_35_28","NUM","35","28","28","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴰⵍ ⵍⵎⴻⵡⵜ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵡⵜ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵄⵇⴻⴱ ⵓⵇⴻⵜⵜⴰⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU35_29","005_35_29","NUM","35","29","29","ⴰⵢⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵉⵍⵉ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵍⵃⴻⵇⵇ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍⴰⵜ ⵏⵡⴻⵎ ⵎⴰⵏⵉ ⵎⴰ ⵖⴰ ⵜⵣⴻⴷⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NU35_30","005_35_30","NUM","35","30","30","ⴽⵓⵍ ⵉⵊⵊ, ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵃⴻⴷ, ⴰⵇⴰ ⴰⵇⴻⵜⵜⴰⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵍⴻⵛⵀⵓⴷ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵛⵀⴻⴷ ⵅ ⵉⵛⵜ ⵏ ⵏⵏⴻⴼⵙ ⵙ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("NU35_31","005_35_31","NUM","35","31","31","ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⴷⴷⴻⵢⵢⴻⵜ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵇⴻⵜⵜⴰⵍ ⵏⵏⵉ ⵅ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵙ ⵍⵎⴻⵡⵜ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_32","005_35_32","NUM","35","32","32","ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⴷⴷⴻⵢⵢⴻⵜ ⵅ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴻⵄⵇⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵇⴱⴻⵍ ⵍⵎⴻⵡⵜ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_33","005_35_33","NUM","35","33","33","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵙⵙⴻⵅⵙⴰⵔⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⴻⴵⴰⵎ, ⵎⵉⵏⵣⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵙⵙⴻⵅⵙⴰⵔⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ, ⵎⵖⵉⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NU35_34","005_35_34","NUM","35","34","34","ⵡⴰⵔ ⵙⵅⴻⵎⵎⵉⵊⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⵣⴻⴷⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵉ ⵖⴰ ⵣⴻⴷⵖⴻⵖ ⵏⴻⵛⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NU36_1","005_36_1","NUM","36","1","1","ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵙⵓⴼ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵊⴰⵔ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵎⴰⴽⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵓⵙⴰ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ");
INSERT INTO rift_vpl VALUES ("NU36_2","005_36_2","NUM","36","2","2","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵍⵡⴰⵔⵜ. ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵉⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏ ⵓⵎⴰⵜⵏⴻⵖ ⵚⴰⵍⵓⴼⵃⴰⴷ ⵉ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("NU36_3","005_36_3","NUM","36","3","3","ⵎⴰⵍⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⵜⵉⵏⴻⵎⵍⴰⵍⵜ ⴰⴽ-ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵖⵏⵉ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ ⴷⵉ ⵍⵡⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⵏⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵎⵓⵏⴻⵏⵜ ⵓⵛⴰ ⴰⵎⵎⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵥⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵖ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("NU36_4","005_36_4","NUM","36","4","4","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⴰⵔⵏⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⴰⴽ-ⴷ ⵡⵉ ⵖⴰ ⵎⵓⵏⴻⵏⵜ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵅⴻⵏⵏⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ ⴷⵉ ⵍⵡⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NU36_5","005_36_5","NUM","36","5","5","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("NU36_6","005_36_6","NUM","36","6","6","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵣⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵅ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⴰⵍⵓⴼⵃⴰⴷ, ⵉⵇⵇⴰⵔ: ‘ⴻⵊⵊ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⵎⴻⵍⵛⴻⵏⵜ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏⵜ ⵢⴰⵔⴻⵛⵇⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵎⵖⵉⵔ ⴰⴷ ⵎⴻⵍⵛⴻⵏⵜ ⴷⵉ ⵍⴰⴵ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU36_7","005_36_7","NUM","36","7","7","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵔⴰⵃ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵖⴰⵔ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵟⵟⴻⴼ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU36_8","005_36_8","NUM","36","8","8","ⵢⴻⴵⵉⵙ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵜⴻⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴰⴵ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵡⴰⵔⵜ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NU36_9","005_36_9","NUM","36","9","9","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵔⴰⵃ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵖⴰⵔ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴽⵓⵍ ⵉⵛⵜ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵟⵟⴻⴼ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("NU36_10","005_36_10","NUM","36","10","10","ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⴰⵍⵓⴼⵃⴰⴷ ⴳⴳⵉⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NU36_11","005_36_11","NUM","36","11","11","ⵎⴰⵃⵍⴰ, ⵜⵉⵔⵚⴰ, ⵃⵓⵊⵍⴰ, ⵎⵉⵍⴽⴰ ⴷ ⵏⵓⵄⴰ, ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⴰⵍⵓⴼⵃⴰⴷ, ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⵉⵏⴻⵎⵍⴰⵍⵜ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴻⵎⵎⵉⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU36_12","005_36_12","NUM","36","12","12","ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⵉⵏⴻⵎⵍⴰⵍⵜ ⴷⵉ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ. ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ ⴷⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NU36_13","005_36_13","NUM","36","13","13","ⵜⵉⵏⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("DT1_1","006_1_1","DEU","1","1","1","ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⵉ ⵍⴻⵡⴹⴰ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵚⵓⴼ, ⵊⴰⵔ ⴼⴰⵔⴰⵏ ⴷ ⵜⵓⴼⴰⵍ ⴷ ⵍⴰⴱⴰⵏ ⴷ ⵃⴰⴹⴰⵢⵔⵓⵜ ⴷ ⴷⵉ-ⴷⴰⵀⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("DT1_2","006_1_2","DEU","1","2","2","ⵣⵉ ⵃⵓⵔⵉⴱ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⴰⵍ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵛⵜⵉ ⵏ ⵃⵉⵟⴰⵛ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT1_3","006_1_3","DEU","1","3","3","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⵉⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ, ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT1_4","006_1_4","DEU","1","4","4","ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵉⵖⵍⴻⴱ ⴷⵉ ⵉⴷⵔⴰⵄⵉ ⵅ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ, ⵓ ⵅ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵄⴰⵛⵜⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("DT1_5","006_1_5","DEU","1","5","5","ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵉⴱⴷⴰ ⵎⵓⵙⴰ ⴰⴷ ⵉⴼⴻⵙⵙⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT1_6","006_1_6","DEU","1","6","6","“ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵏⴻⵖ ⵖⴰⵔ ⵃⵓⵔⵉⴱ, ⵉⵏⵏⴰ: ‘ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⵉⵎⴻⵏ ⴰⵟⵟⴰⵙ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ-ⴰ, ⴰⵇⴰ ⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT1_7","006_1_7","DEU","1","7","7","ⴷⴻⵡⵍⴻⵎ, ⴽⴽⵙⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵢⵓⴷⵙⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴷ ⵍⵓⴱⵏⴰⵏ ⴰⵍ ⵉⵖⵣⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("DT1_8","006_1_8","DEU","1","8","8","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⴰⴷⴼⴻⵎ ⵖⴰⵔⴻⵙ, ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⴰⴷ ⵜⵜ ⵉⵡⵛ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_9","006_1_9","DEU","1","9","9","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ, ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵔⴱⵓⵖ ⴰⵎⵏⵓⵙ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("DT1_10","006_1_10","DEU","1","10","10","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉⴳⴳⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵍⴻⵅⵅⵓ ⴷ ⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DT1_11","006_1_11","DEU","1","11","11","ⴰⴷ ⵜⴰⴼ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵎⵎⴰⵔⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰⵎ ⵍⴻⵅⵅⵓ ⴰⵍⴻⴼ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴰⴼ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴱⴰⵔⴻⴽ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DT1_12","006_1_12","DEU","1","12","12","ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵡⴻⵃⵃⴷⵉ ⵡⴰⵀⴰ ⴰⴷ ⴰⵔⴱⵓⵖ ⵉⵙⵃⴻⵙⵙⵉⴼⴻⵏ ⵏⵡⴻⵎ ⴷ ⴷⴷⵇⵓⵍⴰⵜ ⵏⵡⴻⵎ ⴷ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("DT1_13","006_1_13","DEU","1","13","13","ⴽⵙⵉⵎ ⵣⵉ ⵊⴰⵔ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵡⴻⵎ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵉⴼⴻⵀⵀⵎⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵉⵛⵏⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅⴰⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_14","006_1_14","DEU","1","14","14","ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ-ⴷⴷ ⵅⴰⴼⵉ, ⵜⴻⵏⵏⴰⵎ ⴰⵢⵉ: ‘ⴰⵡⴰⵍ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⴰⵇⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵉⵛⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴻⴳⴳ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_15","006_1_15","DEU","1","15","15","ⵓⵛⴰ ⴽⵙⵉⵖ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵡⴻⵎ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵉⴼⴻⵀⵀⵎⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵉⵛⵏⴰⵏ, ⵓⵛⴰ ⴳⴳⵉⵖ ⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅⴰⵡⴻⵎ, ⴰⵎ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵅⴻⵎⵙⵉⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵄⴻⵛⵔⴰ, ⵓ ⴰⵎ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵅ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT1_16","006_1_16","DEU","1","16","16","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵓⵎⵓⵔⴻⵖ ⵉ ⵍⵇⵓⴹⴰⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⵏⵏⵉⵖ: ‘ⵙⵍⴻⵎ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⵓⵛⴰ ⵃⴻⴽⵎⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵊⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⵎⴰⵙ ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("DT1_17","006_1_17","DEU","1","17","17","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⴷⵉ ⵍⴻⵃⴽⴰⵎ. ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵖⴰⵔ ⵓⵎⴻⵥⵢⴰⵏ ⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ. ⵡⴰⵔ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⵎⵉⵏⵣⵉ ⵍⴻⵃⴽⴰⵎ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⵜⴻⵡⵄⴰⵔ ⵅⴰⵡⴻⵎ, ⴰⵡⵢⴻⵎ ⵜⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵉ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⵙⵍⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_18","006_1_18","DEU","1","18","18","ⴰⵎⵎⵓ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵓⵔⴻⵖ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵅⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT1_19","006_1_19","DEU","1","19","19","“ⵅⴻⵏⵏⵉ ⵏⴻⴼⵙⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵖ ⵓⵛⴰ ⵏⴻⴼⴼⴻⵖ ⵣⵉ ⵃⵓⵔⵉⴱ ⵓⵛⴰ ⵏⴻⵥⵡⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵍⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏⵏⵉ ⵜⴻⵥⵔⵉⵎ, ⵏⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓⵛⴰ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("DT1_20","006_1_20","DEU","1","20","20","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴰⵡⴻⵎ: ‘ⴰⵇⴰ ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT1_21","006_1_21","DEU","1","21","21","ⵅⵣⴰⵔ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⴳⴻⵄⵄⴻⴷ, ⵟⵟⴻⴼ ⵉ-ⵜⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰⵔⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵄⴳⴻⵣ ⵡⵓⵍ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_22","006_1_22","DEU","1","22","22","ⵜⵓⵙⵉⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ, ⵜⴻⵏⵏⴰⵎ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⴻⴽⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵅ ⵎⴰⵏ ⴰⴱⵔⵉⴷ ⵉ ⵣⵉ ⵖⴰ ⵏⴳⴻⵄⵄⴻⴷ ⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔ ⴷⴷ ⵖⴰ ⵏⴰⵙ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_23","006_1_23","DEU","1","23","23","ⵜⵓⵖⴰ ⴰⵡⴰⵍ-ⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⵉ ⵏⴻⵛⵛ ⵓⵛⴰ ⴽⵙⵉⵖ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏⵡⴻⵎ, ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("DT1_24","006_1_24","DEU","1","24","24","ⵏⵏⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵛⴽⵓⵍ ⵓⵛⴰ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT1_25","006_1_25","DEU","1","25","25","ⴽⵙⵉⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ. ⵉⵡⵢⴻⵏ ⴰⵏⴻⵖ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ, ⵏⵏⴰⵏ: ‘ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵜⴻⵚⴱⴻⵃ.’” ");
INSERT INTO rift_vpl VALUES ("DT1_26","006_1_26","DEU","1","26","26","“ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ, ⵡⴰⵔ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⵎ ⵓⵛⴰ ⵜⵖⴻⵡⵡⵖⴻⵎ ⴹⵉⴷⴷ ⵉ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT1_27","006_1_27","DEU","1","27","27","ⵓⵛⴰ ⵜⵏⴻⴷⵇⴻⵎ-ⴷⴷ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ, ⵜⴻⵏⵏⴰⵎ: ‘ⴷⴻⴳ ⵡⴻⵇⵍⴰⴱ ⵏⵏⴻⵙ ⵅⴰⵏⴻⵖ, ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵏⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⵔ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("DT1_28","006_1_28","DEU","1","28","28","ⵎⴰⵏⵉ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵏⴳⴻⵄⵄⴻⴷ? ⴰⵢⵜⵎⴰⵜⵏⴻⵖ ⵙⵙⴼⴻⵙⵙⵢⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ, ⵏⵏⴰⵏ: ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ ⵓⵛⴰ ⵣⵣⵓⴳⴰⵔⴻⵏ ⵅⴰⵏⴻⵖ. ⵜⵉⵏⴻⴷⴷⴰⵎ ⵎⵖⴰⵔⴻⵏⵜ ⵓⵛⴰ ⵜⵜⵡⴰⴼⴰⵔⵢⴻⵏⵜ ⴰⵍ ⴰⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵏⴻⵥⵔⴰ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵏⴰⵇ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_29","006_1_29","DEU","1","29","29","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ: ‘ⵡⴰⵔ ⵜⴰⵔⵊⵉⵊⴻⵎ ⵛⴰ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT1_30","006_1_30","DEU","1","30","30","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵣⵣⴰⵜⵡⴻⵎ, ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⴷⵉ ⵎⵉⵚⵔⴰ ");
INSERT INTO rift_vpl VALUES ("DT1_31","006_1_31","DEU","1","31","31","ⵓⵍⴰ ⴷⵉ ⵔⴻⵅⵍⴰ, ⵎⴰⵏⵉ ⵜⴻⵥⵔⵉⴷ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵛⴻⴽ ⵢⴰⵔⴻⴱⴱⵓ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵔⵔⴰ ⴰⴱⵔⵉⴷ ⵏⵏⵉ ⵜⵓⵢⵓⵔⴻⴷ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵎⵎⵉⵙ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_32","006_1_32","DEU","1","32","32","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ ⵛⴰ ⵙ ⵡⴰⵡⴰⵍ-ⴰ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT1_33","006_1_33","DEU","1","33","33","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⴰⵔⵣⵓ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵡⵜⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ, ⵓ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ, ⵙ ⴵⵉⵍⴻⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵛⴻⵏ ⴰⴱⵔⵉⴷ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ, ⵓ ⵙ ⵓⵣⵉⵍ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT1_34","006_1_34","DEU","1","34","34","ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ, ⵉⵊⵊⵓⴵ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT1_35","006_1_35","DEU","1","35","35","‘ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ ⵏ ⵊⵊⵉⵍ-ⴰ ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵉⵥⴰⵔⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT1_36","006_1_36","DEU","1","36","36","ⵎⵖⵉⵔ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⵥⴰⵔ ⵓⵛⴰ ⵉ ⵏⴻⵜⵜⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⴳⴳⴰ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴹⴻⴼⴼⴰⵔ ⵙⵉⴷⵉ ⵏⵉⵛⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_37","006_1_37","DEU","1","37","37","ⵉⵙⵄⴰⵔ ⵅⴰⴼⵉ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵡⴻⵎ, ⵉⵏⵏⴰ: ‘ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵜⵉⴷⴼⴻⴷ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("DT1_38","006_1_38","DEU","1","38","38","ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⴰⴷⴻⴼ. ⵙⵊⴻⵀⴷ ⵉ-ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵜⵜ ⵖⴰ ⵉⵡⵛⴻⵏ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT1_39","006_1_39","DEU","1","39","39","ⵓⵛⴰ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ ⵉ ⵅ ⵜⴻⵏⵏⴰⵎ: ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴻⵢⵎⴰⵔⵜ!, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵄⴰⴷ ⵍⵅⴰⵔ ⵏⵉⵖ ⵍⵖⴰⵔ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴰⴷⴼⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ-ⵡⵛⴻⵖ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⵡⴰⵔⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT1_40","006_1_40","DEU","1","40","40","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ, ⴰⴷ ⵜⴻⴽⴽⵙⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⵙⵙⴰ ⵓⵛⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_41","006_1_41","DEU","1","41","41","ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ-ⴷⴷ, ⵜⴻⵏⵏⴰⵎ ⴰⵢⵉ: ‘ⴰⵇⴰ ⵏⴻⵅⴹⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ. ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵓⵛⴰ ⴰⴷ ⵏⴻⵎⵎⵏⴻⵖ ⵇⴰⵄ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.’ ⵅⴻⵏⵏⵉ ⵜⴱⴻⵢⵙⴻⵎ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵏ ⴳⴰⵔⵔⴰ ⵓ ⴽⴻⵏⵏⵉⵡ ⵙ ⵣⵣⵄⴰⵎⴻⵜ ⵏⵡⴻⵎ ⵜⴱⴻⴷⴷⴻⵎ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⵎ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT1_42","006_1_42","DEU","1","42","42","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵉⵏⵉ ⴰⵙⴻⵏ: ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⴷⴻⵎ, ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⵉⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵅⴻⵚⵚⴰⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("DT1_43","006_1_43","DEU","1","43","43","ⴰⵎⵎⵓ ⵉ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵓⵛⴰ ⵜⵖⴻⵡⵡⵖⴻⵎ ⴹⵉⴷⴷ ⵉ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⴻⴳⴳⵉⵎ ⵙ ⵜⵓⴼⴼⴻⵜ, ⵜⴳⴻⵄⵄⴷⴻⵎ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT1_44","006_1_44","DEU","1","44","44","ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵡⴻⵎ, ⴰⵎ ⵜⵜⴻⴳⴳⴻⵏⵜ ⵜⵣⵉⵣⵡⴰ, ⵓⵛⴰ ⵍⴻⴱⵣⴻⵏ ⴽⴻⵏⵏⵉⵡ ⴷⵉ ⵚⴰⵄⵉⵔ ⴰⵍ ⵃⵓⵔⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("DT1_45","006_1_45","DEU","1","45","45","ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⵜⴻⵙⵙⵖⵓⵢⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵙⵍⵉ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵡⴻⵎ, ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉ ⴰⵎⴻⵣⵣⵓⵖ, ");
INSERT INTO rift_vpl VALUES ("DT1_46","006_1_46","DEU","1","46","46","ⵓⵛⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵇⴰⴷⴰⵛ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⴰⵣⵉⵔⴰⵔ, ⵓⵙⵙⴰⵏ ⴰⵟⵟⴰⵙ ⵉ ⴷⵉⵏⵏⵉ ⵜⴻⵇⵇⵉⵎⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT2_1","006_2_1","DEU","2","1","1","“ⵅⴻⵏⵏⵉ ⵏⴻⴷⵡⴻⵍ-ⴷⴷ ⵓⵛⴰ ⵏⴻⴼⵙⵉ ⵉⵇⵉⴹⴰⵏ ⵓⵛⴰ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⴻⵏⵏⴻⴹ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("DT2_2","006_2_2","DEU","2","2","2","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT2_3","006_2_3","DEU","2","3","3","‘ⴰⵟⵟⴰⵙ ⵉ ⵜⴻⵏⵏⴹⴻⵎ ⵉ ⵡⴻⴷⵔⴰⵔ-ⴰ, ⴰⵇⴰ ⵛⴼⴰ. ⴰⵔⵔⴻⵎ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ");
INSERT INTO rift_vpl VALUES ("DT2_4","006_2_4","DEU","2","4","4","ⵓⵛⴰ ⵓⵎⵓⵔ ⵍⴳⴻⵏⵙ, ⵉⵏⵉ: ⴰⴷ ⵜⴻⴽⴽⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⴰⵢⵜ ⵏ ⵄⵉⵙⵓ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵙⴰⵄⵉⵔ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴳⴳⵯⴻⴷⴻⵏ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT2_5","006_2_5","DEU","2","5","5","ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵜⵜⴻⵎⵄⴰⵍⴰⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⵉⵛⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵄⵉⵙⵓ.    ");
INSERT INTO rift_vpl VALUES ("DT2_6","006_2_6","DEU","2","6","6","ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴻⵙⵖⴻⵎ ⵍⴻⵄⵡⴻⵍⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵓ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴻⵙⵖⴻⵎ ⵄⴰⵡⴻⴷ ⴰⵎⴰⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT2_7","006_2_7","DEU","2","7","7","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⵓⵖⴰ ⵉⴱⴰⵔⴻⴽ ⵉ ⵛⴻⴽ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵜⵉⵛⵍⵉ ⵏⵏⴻⵛ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵎⴰⵔⵔⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ-ⵢⴰ ⵜⵓⵖⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ.’” ");
INSERT INTO rift_vpl VALUES ("DT2_8","006_2_8","DEU","2","8","8","“ⵓⵎⵉ ⵏⴻⴽⴽⴰ ⵅ ⵢⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⴰⵢⵜ ⵏ ⵄⵉⵙⵓ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵙⴰⵄⵉⵔ, ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵉⵍⴰⵜ ⴷ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⵉⵔ, ⵏⴻⴷⵡⴻⵍ-ⴷⴷ ⵓⵛⴰ ⵏⴻⴽⴽⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⵍⴰ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("DT2_9","006_2_9","DEU","2","9","9","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵙⵙⴰⴳⴳⵯⴰⴷ ⵎⵓ’ⴰⴱ ⵓ ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵜⵜⵎⴻⵏⵖⴰⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⵉⵛⴻⵖ ⵡⴰⵍⵓ ⴷ ⵍⵡⴰⵔⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵄⴰⵔ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⵍⵓⵟ.’ ");
INSERT INTO rift_vpl VALUES ("DT2_10","006_2_10","DEU","2","10","10","ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⵉⵎⵉⵢⵢⴻⵏ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⴰⵎ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT2_11","006_2_11","DEU","2","11","11","ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ ⴰⵎ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT2_12","006_2_12","DEU","2","12","12","ⵓⵍⴰ ⴷ ⵉⵅⵓⵔⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵇⴱⴻⵍ ⴷⵉ ⵙⴰⵄⵉⵔ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵄⵉⵙⵓ ⴽⵙⵉⵏ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴻⵃⵃⴰⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵉⵙⵔⴰⵉⵍ ⵙ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT2_13","006_2_13","DEU","2","13","13","‘ⴽⴽⴰⵔⴻⵎ ⵍⴻⵅⵅⵓ, ⵜⴻⵥⵡⴰⵎ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵣⴰⵔⴰⴷ!’ ⵓⵛⴰ ⵏⴻⵥⵡⴰ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵣⴰⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DT2_14","006_2_14","DEU","2","14","14","ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⵏⵓⵢⵓⵔ ⵣⵉ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ ⴰⵍⴰⵎⵉ ⵏⴻⵥⵡⴰ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵣⴰⵔⴰⴷ, ⴰⵍⴰⵎⵉ ⵉⵇⴹⴰ ⵊⵊⵉⵍ ⵏⵏⵉ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵎⴻⵏⵖⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT2_15","006_2_15","DEU","2","15","15","ⴰⵎⵎⵓ ⵉ ⵅⴰⵙⴻⵏ ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵍⴰⵎⵉ ⵇⴹⴰⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT2_16","006_2_16","DEU","2","16","16","ⵓⵎⵉ ⵇⴹⴰⵏ ⵓ ⵎⵎⵓⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵎⴻⵏⵖⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵎⵙⴰⵔ ");
INSERT INTO rift_vpl VALUES ("DT2_17","006_2_17","DEU","2","17","17","ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT2_18","006_2_18","DEU","2","18","18","‘ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⴻⵥⵡⵉⴷ ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵄⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT2_19","006_2_19","DEU","2","19","19","ⴰⴷ ⴷⴷ-ⵜⵇⴰⵔⵔⴱⴻⴷ ⵖⴰⵔ ⵓⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵙⵙⵉⴳⴳⵯⵉⴷ ⵛⴰ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⵄⴻⴷⴷⵉⴷ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⵉⵛⴻⵖ ⵍⵡⴰⵔⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵎⵉⵏⵣⵉ ⵡⵛⵉⵖ ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⵍⵓⵟ.’ ");
INSERT INTO rift_vpl VALUES ("DT2_20","006_2_20","DEU","2","20","20","ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵓⵍⴰ ⴷ ⵄⴰⵎⵎⵓⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ⵜⵓⵖⴰ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⵇⴱⴻⵍ ⵓ ⵉⵄⴰⵎⵓⵏⵉⵢⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙⴻⵏ ⵉⵣⴰⵎⵣⵓⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT2_21","006_2_21","DEU","2","21","21","ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⴷ ⴰⵣⵉⵔⴰⵔ ⵏ ⵡⴰⴷⴷⵓⴷ ⴰⵎ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ. ⵜⵓⵖⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT2_22","006_2_22","DEU","2","22","22","ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵉ ⴰⵢⵜ ⵏ ⵄⵉⵙⵓ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵙⴰⵄⵉⵔ, ⵎⴰⵖⴰⵔ ⵉⵜⴻⵃⵃⴰ ⵉⵅⵓⵔⵉⵢⵢⴻⵏ ⵣⵣⴰⵜⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT2_23","006_2_23","DEU","2","23","23","ⵓⵛⴰ ⵉⴽⴰⴼⵜⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⴽⴰⴼⵜⵓⵔ, ⵜⴻⵃⵃⴰⵏ ⵉⵄⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⴰⵍ ⵖⴰⵣⵣⴰ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT2_24","006_2_24","DEU","2","24","24","‘ⴽⴽⴰⵔⴻⵎ, ⴼⴻⵙⵢⴻⵎ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵥⵡⴰⵎ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ. ⵅⵣⴰⵔ, ⵡⵛⵉⵖ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ, ⴰⵎⵓⵔⵉ, ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ. ⴱⴷⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⵓⵛⴰ ⵜⴰⴷⴼⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⴳⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT2_25","006_2_25","DEU","2","25","25","ⴰⵙⵙ-ⴰ ⴰⴷ ⴱⴷⵉⵖ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵍⵄⵓⵔⵔⴻⵜ ⵣⵣⴰⵢⴻⴽ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵙⴰⴷⵓ ⴰⵊⴻⵏⵏⴰ ⵎⴰⵔⵔⴰ, ⵉⵏⵏⵉ ⵉ ⵅⴰⴽ ⵖⴰ ⵉⵙⵍⴻⵏ ⵍⴻⵅⴱⴰⵔ ⵓⵛⴰ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵓ ⴰⴷ ⵇⴷⵉⴷⴷⵙⴻⵏ ⵣⵣⴰⵜⴻⴽ.’ ");
INSERT INTO rift_vpl VALUES ("DT2_26","006_2_26","DEU","2","26","26","ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵏ ⵇⴰⴷⵉⵎⵓⵜ ⵖⴰⵔ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⴻⵀⵏⴰ, ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("DT2_27","006_2_27","DEU","2","27","27","‘ⴰⴷ ⴽⴽⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷ ⴰⴱⵔⵉⴷ, ⵅ ⵡⴻⴱⵔⵉⴷ ⴰⴷ ⵔⴰⵃⴻⵖ. ⵡⴰⵔ ⵀⴻⵢⵢⴹⴻⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("DT2_28","006_2_28","DEU","2","28","28","ⴰⴷ ⴰⵢⵉ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ ⵎⴰⵛⵛⴰ ⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵖ, ⴰⵎⴰⵏ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏ ⵜⴻⵡⵛⴻⴷ ⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵖ. ⴰⴷ ⵥⵡⵉⵖ ⵅ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵡⴰⵀⴰ ");
INSERT INTO rift_vpl VALUES ("DT2_29","006_2_29","DEU","2","29","29","- ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵙⴰⵔⵔⵃⴻⵏ ⴰⵢⵜ ⵏ ⵄⵉⵙⵓ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵙⴰⵄⵉⵔ ⴷ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵄⴰⵔ - ⴰⵍⴰⵎⵉ ⵖⴰ ⵥⵡⵉⵖ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("DT2_30","006_2_30","DEU","2","30","30","ⵎⴰⵛⴰ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⴰⵏⴻⵖ ⵢⴻⵊⵊ ⴰⴷ ⵜⵜ ⵏⴻⵥⵡⴰ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵙⵙⴻⵇⵙⴰⵃ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵓ ⵉⵙⵙⴻⵇⵙⴰⵃ ⵓⵍ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⴻⵍⵍⴻⵎ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT2_31","006_2_31","DEU","2","31","31","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴱⴷⵉⵖ ⴰⴷ ⵙⴻⵍⵍⵎⴻⵖ ⵙⵉⵃⵓⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔⴻⴽ. ⴱⴷⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵔⵜⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("DT2_32","006_2_32","DEU","2","32","32","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵙⵉⵃⵓⵏ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵉ ⴳⴰⵔⵔⴰ ⴷⵉ ⵢⴰⵀⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("DT2_33","006_2_33","DEU","2","33","33","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⴻⵍⵍⴻⵎ ⴰⵏⴻⵖ ⵜ ⵓⵛⴰ ⵏⴰⵔⵏⵉ ⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT2_34","006_2_34","DEU","2","34","34","ⵏⴻⴽⵙⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⵃⴰⵔⵔⴻⵎ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵡⴰⵔ ⵏⴻⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DT2_35","006_2_35","DEU","2","35","35","ⵎⵖⵉⵔ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⴰⵇⴰ ⵏⴻⴽⵙⵉ ⴰⵢⴰ ⴷ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT2_36","006_2_36","DEU","2","36","36","ⵣⵉ ⴰⵔⵓⵄⵉⵔ ⵏⵏⵉ ⵢⴻⴵⴰⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ, ⵓ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⴰⵍ ⵊⵉⵍⵄⴰⴷ, ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵓⵄⵍⴰ ⵅⴰⵏⴻⵖ ⵄⴰⴷ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⴻⵍⵍⴻⵎ ⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT2_37","006_2_37","DEU","2","37","37","ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷⴷ-ⵜⵇⴰⵔⵔⴱⴻⴷ ⵛⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵢⴰⴱⴱⵓⵇ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵇⴰⵔⵔⴱⴻⴷ ⵛⴰ ⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴰⵔⵔⴻⵎ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT3_1","006_3_1","DEU","3","1","1","“ⵅⴻⵏⵏⵉ ⵏⴻⴷⵡⴻⵍ-ⴷⴷ ⵓⵛⴰ ⵏⴳⴻⵄⵄⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⴱⴰⵛⴰⵏ. ⵉⴼⴼⴻⵖ-ⴷⴷ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵉ ⴳⴰⵔⵔⴰ ⴷⵉ ⵉⴷⵔⴰⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("DT3_2","006_3_2","DEU","3","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵙⴻⵍⵍⵎⴻⵖ ⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵙ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DT3_3","006_3_3","DEU","3","3","3","ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⴻⵍⵍⴻⵎ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⵓⵛⴰ ⵏⴰⵔⵏⵉⵢ ⵜ ⴰⵍ ⵎⴰⵏⵉ ⵡⴰⵔ ⵏⴻⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DT3_4","006_3_4","DEU","3","4","4","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵏⴻⵟⵟⴻⴼ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ. ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜ ⵏⴻⵟⵟⵉⴼ: ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵔⵊⵓⴱ, ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ ⴷⵉ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT3_5","006_3_5","DEU","3","5","5","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵜⵜⵡⴰⴼⴰⵔⵢⴻⵏⵜ ⵙ ⵍⴻⵃⵢⵓⴹ ⴷ ⵜⵉⵡⵡⵓⵔⴰ ⴷ ⵉⵣⴻⴽⵔⵓⵏⴻⵏ. ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵢⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT3_6","006_3_6","DEU","3","6","6","ⵓⵛⴰ ⵏⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏⵜ ⵉ ⵓⵜⴻⵃⵃⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⴳⴳⴰ ⵣⵉ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ. ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⴰⵇⴰ ⵏⵃⴰⵔⵔⴻⵎ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("DT3_7","006_3_7","DEU","3","7","7","ⵎⴰⵛⴰ ⵏⴻⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵣⵉ ⵜⵉⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("DT3_8","006_3_8","DEU","3","8","8","ⴰⵎⵎⵓ ⵉ ⵏⴻⵟⵟⴻⴼ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ ⴰⵍ ⴰⴷⵔⴰⵔ ⵏ ⵃⴰⵔⵎⵓⵏ ");
INSERT INTO rift_vpl VALUES ("DT3_9","006_3_9","DEU","3","9","9","- ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵉⵚⴰⵢⴷⵓⵏⵉⵢⵢⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵀⵉⵔⵎⵓⵏ ⵙⵉⵔⵢⵓⵏ ⵓ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵙⵉⵏⵉⵔ - ");
INSERT INTO rift_vpl VALUES ("DT3_10","006_3_10","DEU","3","10","10","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵊⵉⵍⵄⴰⴷ ⴷ ⵎⴰⵔⵔⴰ ⴱⴰⵛⴰⵏ ⴰⵍ ⵙⴰⵍⵅⴰ ⴷ ⵉⴷⵔⴰⵄⵉ, ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ ⴷⵉ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT3_11","006_3_11","DEU","3","11","11","ⵎⵉⵏⵣⵉ ⵎⵖⵉⵔ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵣⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ⵅⵣⴰⵔ, ⵇⴰⵎⴰ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵇⴰⵎⴰ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵔⴰⴱⴱⴰ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ? ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵙⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵄⴱⴰⵔⴻⵏ ⵜⵜ ⵙ ⵓⵖⵉⵍ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("DT3_12","006_3_12","DEU","3","12","12","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵏⴻⵟⵟⴻⴼ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴷ ⵍⵡⴰⵔⵜ, ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵄⴰⵔⵓⵄⵉⵔ, ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ, ⵓⵍⴰ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵡⵛⵉⵖ ⵜⵜ ⵉ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT3_13","006_3_13","DEU","3","13","13","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⴷ ⵎⴰⵔⵔⴰ ⴱⴰⵛⴰⵏ, ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ, ⵡⵛⵉⵖ ⵜⵜ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵔⵊⵓⴱ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴱⴰⵛⴰⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT3_14","006_3_14","DEU","3","14","14","ⵢⴰ’ⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵉⵟⵟⴻⴼ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵔⵊⵓⴱ ⴰⵍ ⵡⴻⵢⵎⵉⵔ ⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵉⵊⴰⵛⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴰⵄⴽⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⵉ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ: ⵊⵊⵉⵀⴻⵜ ⵏ ⴱⴰⵛⴰⵏ, ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰ’ⵉⵔ. ⴷ ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⴰⵍ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT3_15","006_3_15","DEU","3","15","15","“ⵉ ⵎⴰⴽⵉⵔ ⵡⵛⵉⵖ ⴰⵙ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DT3_16","006_3_16","DEU","3","16","16","ⵉ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⴰⵍ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ, ⴰⵍ ⵍⵡⴻⵙⵟ ⵏ ⵉⵖⵣⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵎⵉⵔ, ⴰⵍ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵢⴰⴱⴱⵓⵇ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵎⵉⵔ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("DT3_17","006_3_17","DEU","3","17","17","ⵄⴰⵡⴻⴷ ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⵍⴻⵡⴹⴰ ⴷ ⵍ’ⵓⵔⴷⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵎⵉⵔ ⵣⵉ ⴽⵉⵏⵏⴰⵔⴰⵜ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⴻⵡⴹⴰ, ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵀ, ⵡⴰⴷⴷⴰⵢ ⵏ ⵜⴻⵢⵙⴰⵔⵉⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⴼⵉⵙⵊⴰ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ.” ");
INSERT INTO rift_vpl VALUES ("DT3_18","006_3_18","DEU","3","18","18","“ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵡⴻⵚⵚⵉⵖ ⴽⴻⵏⵏⵉⵡ, ⵏⵏⵉⵖ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵥⵡⴰⵎ ⵜⵡⴻⵊⴷⴻⵎ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("DT3_19","006_3_19","DEU","3","19","19","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵡⴻⵎ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵡⵛⵉⵖ ⵏⴻⵛⵛ, ⵎⵖⵉⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵡⴻⵎ - ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵖⴰⵔⵡⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ - ");
INSERT INTO rift_vpl VALUES ("DT3_20","006_3_20","DEU","3","20","20","ⴰⵍ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⵙⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⵍⵡⴰⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵡⵛⵉⵖ ⵏⴻⵛⵛ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("DT3_21","006_3_21","DEU","3","21","21","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵡⴻⵚⵚⵉⵖ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵏⵏⵉⵖ: ‘ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵥⵔⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DT3_22","006_3_22","DEU","3","22","22","ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⴳⴳⵯⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("DT3_23","006_3_23","DEU","3","23","23","ⵓⵛⴰ ⵥⵓⴵⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("DT3_24","006_3_24","DEU","3","24","24","‘ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵛⴻⴽ ⵜⴻⴱⴷⵉⴷ ⴰⴷ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵛ ⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷⵉⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴻⴳⴳ ⵍⴻⵅⴷⴰⵢⴻⵎ ⴷ ⵊⵊⴻⵀⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵛⴻⴽ? ");
INSERT INTO rift_vpl VALUES ("DT3_25","006_3_25","DEU","3","25","25","ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵥⵡⵉⵖ, ⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵓⵛⴰ ⴰⴷ ⵥⴰⵔⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵇⴰ ⵉⴷⵓⵔⴰⵔ ⵏⵏⵉ ⵉⵛⵏⴰⵏ ⴷ ⵍⵓⴱⵏⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT3_26","006_3_26","DEU","3","26","26","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵚⵅⴻⴹ ⵅⴰⴼⵉ ⴰⴼⵓⴳⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵍⵉ. ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵛⴼⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴰⵔⴻⴷ, ⴰⵇⴰ ⴷ ⴰⵟⵟⴰⵙ. ⵡⴰⵔ ⴽⵉⴷⵉ ⵙⵙⵉⵡⵉⵍ ⵄⴰⴷ ⵅ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT3_27","006_3_27","DEU","3","27","27","ⴰⵍⵉ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⴼⵉⵙⵊⴰ ⵓⵛⴰ ⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵛ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵄⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵓ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓ ⵅⵣⴰⵔ ⵉ ⵜⵜ ⵙ ⵉⵅⴻⴼ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵥⴻⴽⴽⵯⵡⵉⴷ ⵛⴰ ⵍ’ⵓⵔⴷⵓⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT3_28","006_3_28","DEU","3","28","28","ⵙⴻⵍⵍⴻⵎ ⵍⵓⵎⵓⵔ ⵉ ⵢⴰⵛⵓⵡⴰ, ⴻⴳⴳ ⴷⴰⵢⴻⵙ ⵓⵍ ⵓ ⵙⴻⵊⵀⴻⴷ ⵉ-ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵥⵡⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵖⴰ ⵜⵥⴰⵔⴻⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⴼⵉⵙⵊⴰ.’ ");
INSERT INTO rift_vpl VALUES ("DT3_29","006_3_29","DEU","3","29","29","ⵓⵛⴰ ⵏⴻⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⴱⴰⵢⵜ-ⴼⴰⵖⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("DT4_1","006_4_1","DEU","4","1","1","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵙⴻⵍ ⵖⴰⵔ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵍⵎⴰⴷⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⵡⴰⵔⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT4_2","006_4_2","DEU","4","2","2","ⵡⴰⵔ ⴰⵔⴻⵏⵏⵢⴻⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵓⵎⵓⵔⴻⵖ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴽⴽⵙⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜᵉⵜⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵜⵉⵏⵏⵉ ⵣⵉ ⴷ ⴰⵡⴻⵎ ⵜⵜⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT4_3","006_4_3","DEU","4","3","3","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵥⵔⵉⵏⵜ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⴱⴰⵄⵍ-ⴼⴰⵖⵓⵔ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⴱⴰⵄⵍ-ⴼⴰⵖⵓⵔ, ⴰⵇⴰ ⵉⵜⴻⵃⵃⴰ ⵉ-ⵜ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT4_4","006_4_4","DEU","4","4","4","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵍⴻⵙⵙⵇⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵄⴰⴷ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_5","006_4_5","DEU","4","5","5","ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⵙⵙⵍⴻⵎⴷⴻⵖ ⴰⵡⴻⵎ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⵡⴰⵔⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT4_6","006_4_6","DEU","4","6","6","ⵟⵟⴼⴻⵎ ⴷⴰⵢⵙⴻⵏⵜ ⵓ ⴳⴳⴻⵎ ⵜⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⵉⵖⵉⵜ ⵏⵡⴻⵎ ⴷ ⵍⴻⵄⵇⴻⵍ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵏⵉⵜⵏⵉ: ‘ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵡⴰⵏⵉⵜⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⵉⵖⵉⵙ ⵓ ⵙ ⵍⴻⵄⵇⴻⵍ!’ ");
INSERT INTO rift_vpl VALUES ("DT4_7","006_4_7","DEU","4","7","7","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵉ ⴷⴰ ⵉⴵⴰⵏ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵢⵓⴷⵙⴻⵏ ⴰⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵍⴻⴱⴷⴰ ⵅⵎⵉ ⵅⴰⵙ ⵏⴻⵜⵜⵍⴰⵖⴰ? ");
INSERT INTO rift_vpl VALUES ("DT4_8","006_4_8","DEU","4","8","8","ⵓ ⵎⴰⵏ ⵍⴳⴻⵏⵙ ⴷⴰ ⵉⴵⴰⵏ ⵉⵎⵖⴰⵔ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵙⴻⴳⴳⵎⴻⵏ ⴰⵎ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵖ ⴰⵙⵙ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("DT4_9","006_4_9","DEU","4","9","9","ⵎⴰⵛⴰ ⵃⴹⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⵟⵟⴻⴼ ⵏⵉⵛⴰⵏ ⴰⵛⴱⴰⵔ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵓⴷ ⵎⵉⵏ ⵥⵔⵉⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓ ⵃⵉⵎⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴼⴼⵉⵖⴻⵏⵜ ⵛⴰ ⵣⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵛ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT4_10","006_4_10","DEU","4","10","10","ⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵜⴱⴻⴷⴷⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⵓⵔⵉⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵙⵎⵓⵏ ⵖⴰⵔⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⵙⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DT4_11","006_4_11","DEU","4","11","11","ⵅⴻⵏⵏⵉ ⵜⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵓⵛⴰ ⵜⴱⴻⴷⴷⴻⵎ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⴰⴷⵔⴰⵔ ⵢⴰⵔⵖⴰ ⴰⵍⴰⵎⵉ ⵜⵉⵎⴻⵙⵙⵉ ⵏⵏⴻⵙ ⵜⵉⵡⴻⴹ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⴵⴻⵙⵜ ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("DT4_12","006_4_12","DEU","4","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵡⴻⵎ ⵙⵉⴷⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵍⵉⵎ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵥⵔⵉⵎ ⵛⴰ ⴰⴷⴷⵓⴷ ⵏⵏⴻⵙ, ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵓⵎⵉ ⵜⴻⵙⵍⵉⵎ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_13","006_4_13","DEU","4","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴽⴻⵏⵏⵉⵡ ⵅ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⵎ, ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ. ⵢⵓⵔⴰ ⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("DT4_14","006_4_14","DEU","4","14","14","ⵉ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵍⴻⵎⴷⴻⵖ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⵡⴰⵔⵜⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT4_15","006_4_15","DEU","4","15","15","“ⵃⴹⴰⵎ ⵏⵉⵛⴰⵏ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵥⵔⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⵓⵔⵉⴱ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ! ");
INSERT INTO rift_vpl VALUES ("DT4_16","006_4_16","DEU","4","16","16","ⵡⴰⵔ ⵜⵜⴻⵙⵙⴻⴼⵙⴰⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵎⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ, ⴰⴷⴷⵓⴷ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵚⵚⴰⵏⴰⵎ, ⴰⴷⴷⵓⴷ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵡⵜⴻⵎ ⵏⵉⵖ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵜⴻⵎⵜ, ");
INSERT INTO rift_vpl VALUES ("DT4_17","006_4_17","DEU","4","17","17","ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⵙ ⵡⴻⴼⵔⵉⵡⴻⵏ ⵉ ⵉⵟⵟⴰⵡⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("DT4_18","006_4_18","DEU","4","18","18","ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵙⵍⴻⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT4_19","006_4_19","DEU","4","19","19","ⵖⴰⵔⴻⴽ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵜⴰⴼⵓⵛⵜ ⴷ ⵓⵢⵓⵔ ⴷ ⵉⵜⵔⴰⵏ, ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⴷ ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵏⴷⵇⴻⴷ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⴱⴷⴻⴷ ⵉ ⵏⵉⵜⵏⵉ, ⵉⵏⵏⵉ ⵉⴱⴹⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵙⴰⴷⵓ ⵎⴰⵔⵔⴰ ⴰⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_20","006_4_20","DEU","4","20","20","ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵇⴱⴻⵍ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ-ⴷⴷ ⵣⴻⴳ ⵓⴼⴰⵔⵔⴰⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵣⵉ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵉⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉ ⵉⵡⴰⵔⵜ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_21","006_4_21","DEU","4","21","21","ⵄⴰⵡⴻⴷ ⵉⵙⵄⴰⵔ ⵅⴰⴼⵉ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵥⴻⴽⴽⵯⵡⵉⵖ ⵛⴰ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵡⴰⵔ ⵜⵜⵉⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("DT4_22","006_4_22","DEU","4","22","22","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵎⵎⵜⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵡⴰⵔ ⵥⴻⴽⴽⵯⵉⵖ ⵛⴰ ⵍ’ⵓⵔⴷⵓⵏ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵥⵡⴰⵎ ⵓⵛⴰ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT4_23","006_4_23","DEU","4","23","23","ⵃⴹⴰⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵓⵎ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⵃⴹⴰⵎ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵣⵉ ⵛⴰ ⵏ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⴷ ⴰⵛ ⵉⵃⴰⵔⵔⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT4_24","006_4_24","DEU","4","24","24","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT4_25","006_4_25","DEU","4","25","25","ⵅⵎⵉ ⵖⴰ ⵜⴰⵔⵡⴻⵎ ⴰⵔⵔⴰⵡ ⴷ ⴰⵢⵢⴰⵡⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⵙⴰⵔⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴷⴻⴵⵎⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ, ⵚⵚⵉⴼⴼⴻⵜ ⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵓⵎⵉ ⵜ ⵖⴰ ⵜⴻⵙⵄⴰⵔⴻⵎ ⴰⵎⵎⵓ, ");
INSERT INTO rift_vpl VALUES ("DT4_26","006_4_26","DEU","4","26","26","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅⴰⵡⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⴷⴻⵖⵢⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵅ ⵍ’ⵓⵔⴷⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⵎ ⴷ ⵍⵡⴰⵔⵜ. ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⵖⵉⵎⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴽⵜⴰⵔ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⴰⵎ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("DT4_27","006_4_27","DEU","4","27","27","ⵙⵉⴷⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴱⴻⵣⵣⴻⵄ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵇⵇⵉⵎ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵡⴰⵀⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵉⵏⴷⴻⵀ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT4_28","006_4_28","DEU","4","28","28","ⴷⵉⵏ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵍⵉⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵓ ⵡⴰⵔ ⵉⵜⵜⵛⴻⵎⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT4_29","006_4_29","DEU","4","29","29","“ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⵙⵙⴻⵏⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓ ⵛⴻⴽ ⴰⴷ ⵜ ⵜⴰⴼⴻⴷ, ⵎⴰⵍⴰ ⵜⴰⵔⴻⵣⵣⵓⴷ ⵅⴰⵙ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT4_30","006_4_30","DEU","4","30","30","ⵎⴰⵍⴰ ⵛⴻⴽ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT4_31","006_4_31","DEU","4","31","31","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵢⴰⵔⴻⵃⵃⵎⴻⵏ, ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⴻⵊⵊⵉ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⴰⵔⴻⴷⴷⴻⴵ. ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜⵓ ⵍⵄⴰⵀⴷ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵊⵊⵓⴵ. ");
INSERT INTO rift_vpl VALUES ("DT4_32","006_4_32","DEU","4","32","32","ⵙⴻⵇⵙⴰ ⵅⴻⵏⵏⵉ ⵅ ⵡⵓⵙⵙⴰⵏ ⵉⵄⴷⵓⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵛⴻⴽ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴱⵏⴰⴷⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⴻⵇⵙⴰ ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵜⴻⵎⵙⴰⵔ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴻⵎⵖⴰⵔ ⴰⵏⴻⵛⵜ ⵏ ⵜⴰⵏⵉⵜⴰ ⵏⵉⵖ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵛⴰ ⴰⵎ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("DT4_33","006_4_33","DEU","4","33","33","ⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵉⵙⵍⴰ ⵛⴰ ⵏ ⵍⴳⴻⵏⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜⵜⴻⵙⵍⵉⴷ ⵛⴻⴽ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("DT4_34","006_4_34","DEU","4","34","34","ⵏⵉⵖ ⵎⴰ ⵉⵇⴻⴵⴻⴱ ⵄⴻⵎⵎⴰⵔⵚ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵙ ⵜⵊⴰⵔⵔⵉⴱⵉⵏ, ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ, ⵙ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵙ ⵓⵎⴻⵏⵖⵉ, ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵙ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵓ ⵙ ⵜⵎⴻⴳⴳⴰ ⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏⵜ ⵎⵖⴰⵔⴻⵏⵜ, ⴰⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵎⵉⵚⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("DT4_35","006_4_35","DEU","4","35","35","ⴰⵇⴰ ⵉ ⵛⴻⴽ ⵓⵎⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴱⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴵⴰ. ⵡⴰⵔ ⴷⵉⵏ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵎⵖⵉⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_36","006_4_36","DEU","4","36","36","ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉⴳⴳⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⴱⴱⴻⵀ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵛ ⵜⵉⵎⴻⵙⵙⵉ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⴰⵇⴰ ⵜⴻⵙⵍⵉⴷ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("DT4_37","006_4_37","DEU","4","37","37","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵓ ⵉⴼⴰⵔⵣ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ ⵛⴻⴽ-ⴷⴷ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔⴻⵏ ");
INSERT INTO rift_vpl VALUES ("DT4_38","006_4_38","DEU","4","38","38","ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵅ ⵍⴻⴳⵏⵓⵙ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵊⴻⵀⴷⴻⵏ ⵣⵉ ⵜⴻⵚⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵙⵙⵉⴷⴻⴼ ⵛⴻⴽ ⵓ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_39","006_4_39","DEU","4","39","39","ⵅⴻⵏⵏⵉ ⵙⵙⴻⵏ ⴰⵙⵙ-ⴰ ⵓⵛⴰ ⵅⴰⵔⵔⴻⵚ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⴻⴵⴰ, ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵙⵡⴰⴷⴷⴰⵢ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("DT4_40","006_4_40","DEU","4","40","40","ⵟⵟⴻⴼ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵓⵎⴻⴷⴷⵓⵔ ⵎⵍⵉⵃ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⵓⵛⴰ ⴰⴷ ⵣⵣⵓⴳⴰⵔⵜⴻⵏ ⵓⵙⵙⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT4_41","006_4_41","DEU","4","41","41","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵣ ⵎⵓⵙⴰ ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("DT4_42","006_4_42","DEU","4","42","42","ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵢⴰⵍⵡⴻⵔ ⵓⵇⴻⵜⵜⴰⵍ ⵏⵏⵉ ⵉⵏⵖⵉⵏ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ, ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵉⴹⴻⵏⵏⴰⴹ ⵓⵍⴰ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ⵡⴰⵏⵉⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵉⵛⵜ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⵍⴰⵎⵉ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_43","006_4_43","DEU","4","43","43","ⴱⴰⵚⵉⵔ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⵉ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ, ⵉ ⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ, ⵓ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵉ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⵓ ⵊⵓⵍⴰⵏ ⴷ ⴱⴰⵛⴰⵏ ⵉ ⵉⵎⴰⵏⴰⵙⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT4_44","006_4_44","DEU","4","44","44","ⵜⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⵉ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵣⵣⴰⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT4_45","006_4_45","DEU","4","45","45","ⵉⵏⴰ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_46","006_4_46","DEU","4","46","46","ⴰⵢⴰ ⵜⵓⵖⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴱⴰⵢⵜ-ⴼⴰⵖⵓⵔ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ, ⵡⴻⵏⵏⵉ ⵅ ⵉⵖⵍⴻⴱ ⵎⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT4_47","006_4_47","DEU","4","47","47","ⴰⵇⴰ ⴽⵙⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵍⵡⴰⵔⵜ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵜⵉⵎⵎⵓⵔⴰ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("DT4_48","006_4_48","DEU","4","48","48","ⵣⵉ ⵄⴰⵔⵓⵄⵉⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ ⴰⵍ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵢⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⵉⵔⵎⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("DT4_49","006_4_49","DEU","4","49","49","ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⴹⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⴻⵡⴹⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵡⴰⴷⴷⴰⵢ ⵏ ⵜⴻⵢⵙⴰⵔⵉⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⴼⵉⵙⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("DT5_1","006_5_1","DEU","5","1","1","ⵉⵍⴰⵖⴰ ⵎⵓⵙⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ, ⵜⵉⵏⵏⵉ ⵉ ⵅⴻⴼ ⵙⵙⵉⵡⵍⴻⵖ ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⵍⴻⵎⴷⴻⵎ ⵓ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT5_2","006_5_2","DEU","5","2","2","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵏⴻⵖ ⴷⵉ ⵃⵓⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("DT5_3","006_5_3","DEU","5","3","3","ⵡⴰⵔ ⵉⴵⵉ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵍⵄⴰⵀⴷ-ⴰ, ⵎⴰⵛⴰ ⴰⴽⵉⴷⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT5_4","006_5_4","DEU","5","4","4","ⵓⴷⴻⵎ ⴰⴽ-ⴷ ⵡⵓⴷⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵡⴻⵎ ⵙⵉⴷⵉ ⵅ ⵡⴻⴷⵔⴰⵔ, ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("DT5_5","006_5_5","DEU","5","5","5","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴱⴻⴷⴷⴻⵖ ⵊⴰⵔ ⵙⵉⴷⵉ ⴷ ⴽⴻⵏⵏⵉⵡ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴰⵔⴻⴳⴱⴻⵖ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵣⵉ ⵜⵎⴻⵙⵙⵉ ⵓ ⵡⴰⵔ ⵜⴳⴻⵄⵄⴰⴷⴻⵎ ⵛⴰ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT5_6","006_5_6","DEU","5","6","6","‘ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ-ⴷⴷ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("DT5_7","006_5_7","DEU","5","7","7","ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜⵜⵉⵍⵉⵏ ⵛⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT5_8","006_5_8","DEU","5","8","8","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏⵉⵖ ⵎⵉⵏ ⵎⴰ ⵍⴻⵅⵢⴰⵍ ⵏ ⵎⵉⵏ ⴷⵉⵏ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⵙⵡⴰⴷⴷⴰⵢ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT5_9","006_5_9","DEU","5","9","9","ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⴱⴻⵏⴷⴻⵇ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⴱⴷⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⴻⵣⴼⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴷⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT5_10","006_5_10","DEU","5","10","10","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵛⵏⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵍⵓⵍⵓⴼ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⵃⴻⵟⵟⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT5_11","006_5_11","DEU","5","11","11","ⵡⴰⵔ ⵏⴻⵟⵟⴻⵇ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⵔⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⵟⵇⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DT5_12","006_5_12","DEU","5","12","12","ⵃⴹⴰ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT5_13","006_5_13","DEU","5","13","13","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵅⴻⴷⵎⴻⴷ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT5_14","006_5_14","DEU","5","14","14","ⵎⴰⵛⴰ ⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴷ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵛⴻⴽ ⵍⵍⴰ ⵓⵍⴰ ⴷ ⵎⵎⵉⵛ ⴷ ⵢⴻⴵⵉⵛ ⴷ ⵢⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴷ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵛ ⴷ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵛ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⴰⴽⵉⴽ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵍⵍⴰ, ⵃⵉⵎⴰ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ ⴰⵎ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DT5_15","006_5_15","DEU","5","15","15","ⴰⴷ ⵜⵄⴻⵇⵍⴻⵎ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵙⵎⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ ⵛⴻⴽ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ. ⵅ ⵓⵢⴰ ⵢⵓⵎⵓⵔ ⵛⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("DT5_16","006_5_16","DEU","5","16","16","ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⴽ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵛ ⵎⵍⵉⵃ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT5_17","006_5_17","DEU","5","17","17","ⵡⴰⵔ ⵏⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("DT5_18","006_5_18","DEU","5","18","18","ⵡⴰⵔ ⵣⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DT5_19","006_5_19","DEU","5","19","19","ⵡⴰⵔ ⵜⵜⴰⵛⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT5_20","006_5_20","DEU","5","20","20","ⵡⴰⵔ ⵛⴻⵀⵀⴻⴷ ⵙ ⵥⵓⵔ ⴹⵉⴷⴷ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT5_21","006_5_21","DEU","5","21","21","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵎⴻⵥⵔⵉ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⴹⴻⵎⵎⴻⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵏⵉⵖ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⴻⴳ ⵢⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⴻⴳ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴷⵉ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵊⴰⵔ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("DT5_22","006_5_22","DEU","5","22","22","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏⵡⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ, ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵣⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵓ ⵣⴻⴳ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ ⵓ ⵡⴰⵔ ⵉⵎⵎⴰⵔⵏⵉ ⵛⴰ ⴽⵜⴰⵔ. ⵢⵓⵔⵉ ⵜⴻⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("DT5_23","006_5_23","DEU","5","23","23","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵜⴻⵙⵍⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵉ ⵜⵎⵉⵊⵊⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⴵⴻⵙⵜ ⵓⵛⴰ ⴰⴷⵔⴰⵔ ⵉⵛⴻⵎⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ, ⴰⵇⴰ ⵜⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵔⵔⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT5_24","006_5_24","DEU","5","24","24","ⵜⴻⵏⵏⴰⵎ ⴰⵢⵉ: ‘ⵅⵣⴰⵔ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⵙⵛⴻⵏ ⴰⵏⴻⵖ-ⴷⴷ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ. ⴰⵙⵙ-ⴰ ⵏⴻⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⵡⴰ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT5_25","006_5_25","DEU","5","25","25","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵏⴻⵎⵎⴻⵜ? ⵎⵉⵏⵣⵉ ⵜⵉⵎⴻⵙⵙⵉ-ⵢⴰ ⵉⵎⵖⴰⵔⴻⵏ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵛⵛ. ⵎⴰⵍⴰ ⵏⴻⵇⵇⵉⵎ ⵏᵉⵜⵜⴻⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⴷ ⵏⴻⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT5_26","006_5_26","DEU","5","26","26","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⵉⵏ ⵢⴻⴵⴰⵏ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴰⵔⵔⵉⵎⴻⵜ, ⵡⴻⵏⵏⵉ ⵉⵙⵍⴰⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵜⴻⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ ⴰⵎ ⵏⴻⵛⵛⵉⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵄⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("DT5_27","006_5_27","DEU","5","27","27","ⴰⴷ ⴷⴷ-ⵜⵇⴰⵔⵔⴱⴻⴷ ⵛⴻⴽ ⵓ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⵉⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵢⵉⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵙ ⵏⵙⴻⵍ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⴳⴳ.’ ");
INSERT INTO rift_vpl VALUES ("DT5_28","006_5_28","DEU","5","28","28","ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⵓⵎⵉ ⴽⵉⴷⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⴳⴻⵏⵙ-ⴰ, ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵏ. ⴰⵇⴰ ⵎⵍⵉⵃ, ⵎⴰⵔⵔⴰ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT5_29","006_5_29","DEU","5","29","29","ⵉⵍⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴻⵡⵛ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵓⵛⴰ ⴰⴷ ⵃⴹⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵇⴰⵄ ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵎⵍⵉⵃ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("DT5_30","006_5_30","DEU","5","30","30","ⵔⵓⵃ, ⵜⵉⵏⵉⴷ ⴰⵙⴻⵏ: ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("DT5_31","006_5_31","DEU","5","31","31","ⵓⵛⴰ ⵛⴻⴽ, ⴱⴻⴷⴷ ⴷⴰ ⴽⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴰⴽⵉⴷⴻⴽ ⵙⵙⵉⵡⵍⴻⵖ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴳⴳⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵡⵛⴻⵖ ⴷ ⵍⵡⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("DT5_32","006_5_32","DEU","5","32","32","ⵃⴹⴰⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⵃⴻⵢⵢⴷⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("DT5_33","006_5_33","DEU","5","33","33","ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵎⴰⵔⵔⴰ ⴰⴱⵔⵉⴷ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵎⵍⵉⵃ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴽⵙⵉⵎ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT6_1","006_6_1","DEU","6","1","1","“ⵜⵉⵏⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵜⴻⵏⵜ ⵙⵙⵍⴻⵎⴷⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⵎ ⴷ ⵍⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("DT6_2","006_6_2","DEU","6","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ, ⵛⴻⴽ ⴷ ⵎⵎⵉⵛ ⴷ ⵎⵎⵉⵙ ⵏ ⵎⵎⵉⵛ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT6_3","006_6_3","DEU","6","3","3","ⵙⴻⵍ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵃⴹⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ ⵓ ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵎⵎⴰⵔⵏⵉⵎ ⵙ ⵡⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT6_4","006_6_4","DEU","6","4","4","“ⵙⴻⵍ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵙⵉⴷⵉ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("DT6_5","006_6_5","DEU","6","5","5","ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT6_6","006_6_6","DEU","6","6","6","ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⴰⴷ ⵉⵍⵉⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT6_7","006_6_7","DEU","6","7","7","ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⴳⴳⵣⴻⴷ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏⵜ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵅⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⵅⵎⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓ ⵅⵎⵉ ⵖⴰ ⵜᵉⵟⵟⵚⴻⴷ ⵓ ⵅⵎⵉ ⵖⴰ ⵜⴻⴽⴽⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT6_8","006_6_8","DEU","6","8","8","ⴰⴷ ⵜⴻⵏ ⵜⴱⴻⵢⵙⴻⴷ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵍⵉⵏⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵓⵙⴻⴳⴳⴻⵎ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT6_9","006_6_9","DEU","6","9","9","ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵉⴷ ⵅ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT6_10","006_6_10","DEU","6","10","10","“ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵅⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵢⴰⵡⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵅ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵛ ⵜⵜ ⵉⵡⵛ, ⵙ ⵜⵏⴻⴷⴷⴰⵎ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ, ⵜⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⴱⵏⵉⴷ ⵛⴻⴽ ");
INSERT INTO rift_vpl VALUES ("DT6_11","006_6_11","DEU","6","11","11","ⵓ ⵙ ⵜⵓⴷⵔⵉⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⵣⵉ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵛⵛⵓⵔⴻⴷ ⵛⴻⴽ, ⵓ ⵙ ⵜⴻⵖⵣⵉⵏ ⵏⵏⵉ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵖⵣⵉⴷ, ⵓ ⵙ ⵜⵣⴰⵢⴰⵔⵉⵏ ⴷ ⵜⵣⴻⵎⵎⵓⵔⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵥⵥⵓⴷ ⵛⴻⴽ. ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⵜⴻⵛⵛⴻⴷ ⵓ ⴰⴷ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT6_12","006_6_12","DEU","6","12","12","ⵃⴹⴰ ⵅⴻⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("DT6_13","006_6_13","DEU","6","13","13","ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜ ⵜⵄⴻⴱⴷⴻⴷ ⵓ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵊⵊⴰⴵⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT6_14","006_6_14","DEU","6","14","14","ⵡⴰⵔ ⴳⴳⵓⵔⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ");
INSERT INTO rift_vpl VALUES ("DT6_15","006_6_15","DEU","6","15","15","- ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ - ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⴽ ⵢⴰⵔⴻⵇⵇ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵉⵜⴻⵃⵃⴰ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT6_16","006_6_16","DEU","6","16","16","ⵡⴰⵔ ⵜⵜⵇⴻⴵⴰⴱⴻⵎ ⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵇⴻⴵⴱⴻⵎ ⴷⵉ ⵎⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DT6_17","006_6_17","DEU","6","17","17","ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵏⵉⵛⴰⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵓⵍⴰ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("DT6_18","006_6_18","DEU","6","18","18","ⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴷ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ ⵉ ⵣⵉ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("DT6_19","006_6_19","DEU","6","19","19","ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵥⵥⵍⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT6_20","006_6_20","DEU","6","20","20","“ⵅⵎⵉ ⵛⴻⴽ ⵖⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵎⵎⵉⵛ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵛⵛⵀⴰⴷⴰⵜ ⴷ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ?’, ");
INSERT INTO rift_vpl VALUES ("DT6_21","006_6_21","DEU","6","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵎⵎⵉⵛ: ‘ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵏⴻⵖ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT6_22","006_6_22","DEU","6","22","22","ⵙⵉⴷⵉ ⵉⴳⴳⴰ, ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ, ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵉⵙⵙⵉⴳⴳⵯⴷⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT6_23","006_6_23","DEU","6","23","23","ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵏⴻⵖ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵉⴷⴻⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵢⴻⵡⵛ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ,ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("DT6_24","006_6_24","DEU","6","24","24","ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ, ⴰⴷ ⵏⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉ ⵍⴻⴱⴷⴰ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵉⵣⵉ ⵏⵏⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT6_25","006_6_25","DEU","6","25","25","ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵖ ⵅⵎⵉ ⵖⴰ ⵏⴻⵃⴹⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT7_1","006_7_1","DEU","7","1","1","“ⵅⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵉⴷⴻⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵣⵉ ⵣⵣⴰⵜⴻⴽ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ: ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵊⵉⵔⵊⴰⵛⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⵎⵖⴰⵔⴻⵏ ⵓ ⵊⴻⵀⴷⴻⵏ ⵅⴰⴽ ⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("DT7_2","006_7_2","DEU","7","2","2","ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵏ ⵉⵙⴻⵍⵍⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⵖⴻⵍⴱⴻⴷ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵜⵃⴰⵔⵔⵎⴻⴷ ⵇⴰⵄ ⵉ ⵓⵜⴻⵃⵃⵉ. ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵜⵜⴻⴳⴳ ⵍⵄⴰⵀⴷ ⵓ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵙⵙⵛⴻⵏ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT7_3","006_7_3","DEU","7","3","3","ⵡⴰⵔ ⵜⴻⴷⴷⵉⴽⴽⵡⵉⵍⴻⵎ ⴷ ⵉⴹⴻⴳⴳⵯⴰⵍⴻⵏ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ. ⵡⴰⵔ ⵜⵜⵉⵛ ⵢⴻⴵⵉⵛ ⵉ ⵎⵎⵉⵙ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵡⵉ ⵢⴻⴵⵉⵙ ⵉ ⵎⵎⵉⵛ, ");
INSERT INTO rift_vpl VALUES ("DT7_4","006_7_4","DEU","7","4","4","ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⴰⴷ ⵢⴰⵔⵔ ⵎⵎⵉⵛ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⵎⵎⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵜⴻⵃⵃⴰ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DT7_5","006_7_5","DEU","7","5","5","ⴰⵎⵎⵓ ⵎⴰⵛⴰ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⵙⴻⵏ ⵜⴻⴳⴳⴻⵎ: ⴰⴷ ⵜⵀⴻⴷⵎⴻⵎ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵜⴰⵔⵥⴰⵎ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴰⴷ ⵜⵀⴻⴷⵎⴻⵏ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⵎ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("DT7_6","006_7_6","DEU","7","6","6","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴼⴰⵔⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵉⵍⵉⴷ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵖⵍⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵢⴻⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT7_7","006_7_7","DEU","7","7","7","ⵙⵉⴷⵉ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵉⵇⵇⴻⵏ ⵓ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴹⴰⵔ ⵓⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵟⵟⴰⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵡⴰⵎ ⵇⴻⵍⵍ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("DT7_8","006_7_8","DEU","7","8","8","ⵎⴰⵛⴰ ⵜⴰⵢⵔⵉ ⵏ ⵙⵉⴷⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⵓⵃⴻⵟⵟⵓ ⵏⵏⴻⵙ ⵅ ⵜⵊⴰⴵⵉⵜ ⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵜⴰⵊⴰⴵⵉⵜ ⵉ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵉ ⵣⵉ ⵛⴻⴽ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ, ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT7_9","006_7_9","DEU","7","9","9","ⵙⵙⴻⵏ ⵅⴻⵏⵏⵉ, ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵜⵉⵇⵇⵉ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⵄⴰⵀⴷ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵛⴰ ⵃⴻⵟⵟⴰⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ, ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⴰⵍⴻⴼ, ");
INSERT INTO rift_vpl VALUES ("DT7_10","006_7_10","DEU","7","10","10","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜ ⵉⵅⵍⴻⴼ ⴰⵎ ⵜⴻⵏ ⵉ ⵖⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ. ⵡⴰⵔ ⵉⵜⵜⵔⵉⵊⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵡⴻⵏⵏⵉ ⵜ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT7_11","006_7_11","DEU","7","11","11","ⵃⴹⴰ ⵅⴻⵏⵏⵉ ⵍⵓⵎⵓⵔⴰⵜ ⴷ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT7_12","006_7_12","DEU","7","12","12","“ⴰⴷ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵜⴻⵙⵍⵉⵎ ⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ-ⴰ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵃⴹⴰⵎ ⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ, ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵉⴱⴻⴷⴷ ⵅ ⵍⵄⴰⵀⴷ ⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT7_13","006_7_13","DEU","7","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵅⵙ, ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵓ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵉⵔⴷⴻⵏ ⵏⵏⴻⵛ, ⴱⵉⵏⵓ ⵏⵏⴻⵛ ⵏ ⵊⴷⵉⴷ, ⵣⵣⴻⵛⵜ ⵏⵏⴻⵛ ⵏ ⵟⵟⵔⵉ, ⵜⴰⵔⵔⴰⵡⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⴽ ⴰⴷ ⴰⵛ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("DT7_14","006_7_14","DEU","7","14","14","ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ! ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵃⴻⴷ ⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⵊⵊⵉⵏ ⵓⵍⴰ ⴷ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵉⵡⴻⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT7_15","006_7_15","DEU","7","15","15","ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⴽⴽⴻⵙ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵉⵍⴻⵇⵇⴻⴼ ⵓⵍⴰ ⵙ ⵛⴰ ⵏ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏⵜ ⵉ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏⵜ ⵉⵙⵙⵉⵡⴻⴹ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT7_16","006_7_16","DEU","7","16","16","ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜᵉⵜⵜⵃⵉⵏⵏⵉ ⵓ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ, ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴼⴻⵅ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DT7_17","006_7_17","DEU","7","17","17","ⵎⴰⵍⴰ ⵜⴻⵏⵏⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ: ⵍⴻⴳⵏⵓⵙ-ⴰ ⵎⵖⴰⵔⴻⵏ ⵅⴰⴼⵉ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴽⴽⵙⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("DT7_18","006_7_18","DEU","7","18","18","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷ. ⵅⴰⵔⵔⴻⵚ ⵎⵍⵉⵃ ⴷⵉ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴽ-ⴷ ⴼⵉⵔⵄⵓⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT7_19","006_7_19","DEU","7","19","19","ⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵜⵇⴻⴵⴰⴱⵉⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⵜⵉⵏⵏⵉ ⵜⴻⵥⵔⵉⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴽ-ⴷ ⵡⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵣⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT7_20","006_7_20","DEU","7","20","20","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵣⵣⴰⵏ ⵉⴹⴰⵔⵖⴰⵍⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DT7_21","006_7_21","DEU","7","21","21","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT7_22","006_7_22","DEU","7","22","22","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵣⵣⴰⵜⴻⴽ ⵛⵡⴰⵢⵜ ⵛⵡⴰⵢⵜ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴻⵇⴹⵉⴷ ⴷⴻⵖⵢⴰ, ⵎⴰⵍⴰ ⵍⵍⴰ ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵍⴻⵡⵃⵓⵛ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴰⵟⵟⴰⵙ ⵅⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("DT7_23","006_7_23","DEU","7","23","23","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵏ ⵉⵙⴻⵍⵍⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵅⴰⵔⵡⴻⴹ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⵉⵎⵖⴰⵔ ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT7_24","006_7_24","DEU","7","24","24","ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵃⵉⴷ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵣⵉ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⵍ ⵜⴻⵏ ⵖⴰ ⵜᵉⵜⴻⵃⵃⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DT7_25","006_7_25","DEU","7","25","25","ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉ ⵅⴰⵙⴻⵏⵜ ⵉⴵⴰⵏ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵄⴻⵛⵛⴻⵇ ⵓ ⵡⴰⵔ ⵜ ⴽⴻⵙⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵅⴰⵔⵡⵉⴹⴻⴷ, ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT7_26","006_7_26","DEU","7","26","26","ⵡⴰⵔ ⵜⵜⵉⵡⵉ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⴰⵎ ⵜⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⵍⵍⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⴷ ⵉ ⵓⵜⴻⵃⵃⵉ ⴰⵎ ⵏⴻⵜⵜⴰ. ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵄⵉⴼⴼⴻⴷ ⴰⵟⵟⴰⵙ ⵓ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⴻⵏⵏⵄⵉⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵍⴻⵃⵔⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT8_1","006_8_1","DEU","8","1","1","“ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵉ ⵣⵉ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵓ ⴰⴷ ⵜⴻⵎⵎⴰⵔⴻⵏⵢⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⵎ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT8_2","006_8_2","DEU","8","2","2","ⴰⴷ ⵜⵉⴷⴰⵔⴻⴷ ⵎⴰⵔⵔⴰ ⴰⴱⵔⵉⴷ ⵅ ⵎⴰⵏⵉ ⵛⴻⴽ ⵉⴳⴻⵡⵡⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵓ ⴰⴷ ⵛⴻⴽ ⵉⵇⴻⴵⴻⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⴷⵉⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵏⵉⵖ ⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("DT8_3","006_8_3","DEU","8","3","3","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉ ⵛⴻⴽ ⵓ ⵉⵙⵙⵍⴰⵥ ⵉ ⵛⴻⴽ ⵓ ⵉⵡⵛⴰ ⴰⵛ ‘ⵎⴰⵏⵏⴰ’ ⴷ ⵎⴰⵛⵛⴰ, ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵜ ⵙⵙⵉⵏⴻⵏ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⵙⵙⵛⴻⵏ ⴱⴻⵍⵍⵉ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵙ ⵡⴻⵖⵔⵓⵎ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴱⵏⴰⴷⴻⵎ ⵉⴷⴷⴰⵔ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT8_4","006_8_4","DEU","8","4","4","ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵅⴰⴽ ⵉⵡⵙⴰⵔ ⵓⵍⴰ ⴷ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵢⵓⴼⴼ ⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ-ⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DT8_5","006_8_5","DEU","8","5","5","ⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵢⴰⵔⴻⴱⴱⴰ ⵉ ⵛⴻⴽ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⴰⵔⴻⴱⴱⴰ ⴰⵔⵢⴰⵣ ⵎⵎⵉⵙ ");
INSERT INTO rift_vpl VALUES ("DT8_6","006_8_6","DEU","8","6","6","ⵓⵛⴰ ⵃⴹⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵜⴻⴵⵉⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT8_7","006_8_7","DEU","8","7","7","“ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵉⴷⴻⴼ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⴷ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵢⵙⴰⵔⵜ ⴷ ⵡⴻⴷⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("DT8_8","006_8_8","DEU","8","8","8","ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵔⴷⴻⵏ ⴷ ⵉⵎⴻⵏⴷⵉ ⴷ ⵜⵣⴰⵢⴰⵔⵉⵏ ⴷ ⵡⴰⵔⵜⴰⵏ ⵏ ⵜⴰⵣⴰⵔⵜ ⴷ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵜⵣⵉⵜⵓⵏⵜ ⵓ ⵏ ⵜⴰⵎⵎⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("DT8_9","006_8_9","DEU","8","9","9","ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵍⴻⵅⵚⴻⵚ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵛⴰ ⴷⴰⵢⴻⵙ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵥⵔⴰ ⵏⵏⴻⵙ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⵓⵣⵣⴰⵍ ⵓ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵜⵏⴻⵇⵛⴻⴷ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT8_10","006_8_10","DEU","8","10","10","ⵎⴰⵍⴰ ⵜⴻⵛⵛⵉⴷ ⵓ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ, ⴰⴷ ⵜⴱⴰⵔⴽⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT8_11","006_8_11","DEU","8","11","11","“ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵓⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ, ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("DT8_12","006_8_12","DEU","8","12","12","ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ - ⵎⴰⵍⴰ ⵜⴻⵛⵛⵉⴷ ⵓ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ ⵓⵛⴰ ⴰⵇⴰ ⵜⴻⴱⵏⵉⴷ ⵜⵓⴷⵔⵉⵏ ⵉⵛⵏⴰⵏ, ⵜⵉⵏⵏⵉ ⵉ ⴷⵉ ⵜⴻⴳⴳⵉⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵣⴻⴷⵖⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT8_13","006_8_13","DEU","8","13","13","ⵓⵛⴰ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵎⵎⴰⵔⵏⵉⵏ ⵓ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵖⴰⵔⴻⴽ ⴰⵇⴰ ⵜⵜⵡⴰⵎⵎⴰⵔⵏⵉⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵎⵎⴰⵔⵏⵉ - ");
INSERT INTO rift_vpl VALUES ("DT8_14","006_8_14","DEU","8","14","14","ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵓⵍ ⵏⵏⴻⵛ, ⴰⴷ ⵜᵉⵜⵜⵓⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ ... ");
INSERT INTO rift_vpl VALUES ("DT8_15","006_8_15","DEU","8","15","15","ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴼⵉⵖⵔⴰⵏ ⵢⴰⵔⵖⵉⵏ ⴷ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ ⵓⵍⴰ ⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵜⵜⴼⴰⴷⴰⵏ ⴱⵍⴰ ⴰⵎⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴻⵥⵔⵓ ⵏ ⵙⵙⴻⴵⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("DT8_16","006_8_16","DEU","8","16","16","ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ‘ⵎⴰⵏⵏⴰ’ ⵉ ⵎⴰⵛⵛⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵎⴰⵏⵏⴰ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵇⴻⴵⴻⴱ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⴳⴳ ⵜⵛⵓⵏⵉ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("DT8_17","006_8_17","DEU","8","17","17","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ: ‘ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⵉⵏⵓ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⵓⴼⵓⵙ ⵉⵏⵓ ⵟⵟⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴽⵙⵉⴱⴻⵜ-ⴰ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("DT8_18","006_8_18","DEU","8","18","18","ⵉⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⵊⵊⴻⵀⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴽⴻⵙⴱⴻⴷ ⵉⵛⵜ ⵏ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵜⴻⵏ ⴰⵎⵎⵓ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT8_19","006_8_19","DEU","8","19","19","ⵎⴰⵍⴰ ⵜⵉⵡⴹⴻⴷ ⴰⴷ ⵜᵉⵜⵜⵓⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⴱⴷⴻⴷ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵏⴷⵇⴻⴷ, ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ ⴱⴰⵔⵔⵃⴻⵖ ⴰⵛ-ⴷⴷ, ⴰⵇⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⵙ ⵜⵜⵉⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT8_20","006_8_20","DEU","8","20","20","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⴰⵎ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵅ ⵢⵓⵥⵥⴻⵍ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT9_1","006_9_1","DEU","9","1","1","“ⵙⴻⵍ, ⵉⵙⵔⴰⵉⵍ, ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⴻⵥⵡⵉⴷ ⵍ’ⵓⵔⴷⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵡⴰⵔⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵣⴻⴳ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏⵏⵉ ⵜⵜⵡⴰⴼⴰⵔⵢⴻⵏⵜ ⴰⵍ ⴰⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("DT9_2","006_9_2","DEU","9","2","2","ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵡⴷⴰⵏ ⵉⵣⵣⵓⴳⴰⵔⵜⴻⵏ, ⴰⵢⵜ ⵏ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵙⵙⵏⴻⴷ ⵄⴰⴷ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵜⴻⵙⵍⵉⴷ ⵇⵇⴰⵔⴻⵏ: ‘ⵡⵉ ⵖⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("DT9_3","006_9_3","DEU","9","3","3","ⵙⵙⴻⵏ ⵅⴻⵏⵏⵉ, ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵣⵡⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵜⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⴻⴷⴵⴻⴷ ⴷⴻⵖⵢⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT9_4","006_9_4","DEU","9","4","4","ⵍⴰⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅⴰⵙⴻⵏ ⵢⵓⵥⵥⴻⵍ ⵣⵣⴰⵜⴻⴽ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵇⵇⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵙⵉⴷⵉ ⵉⵙⵙⵉⴷⴻⴼ ⴰⵢⵉ-ⴷⴷ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵙⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴷ ⵍⵡⴰⵔⵜ’. ⵎⵉⵏⵣⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵍⴻⴳⵏⵓⵙ-ⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴽⴽⴻⵙ ⵙⵉⴷⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT9_5","006_9_5","DEU","9","5","5","ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ, ⴰⴷ ⴷⵉⵏ ⵜⵔⴰⵃⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ, ⵎⴰⵛⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴹⴰ ⴰⵡⴰⵍ ⵏⵏⵉ ⵣⵉ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴽⴽⴻⵙ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT9_6","006_9_6","DEU","9","6","6","“ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⴷ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵉⵛⵏⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵖⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT9_7","006_9_7","DEU","9","7","7","ⵉⴷⴰⵔ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓ, ⴱⴻⵍⵍⵉ ⵜⴻⴳⴳⵉⴷ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵍⴻⵅⵍⴰ. ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⴷⴼⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵜⵓⵖⴰ ⵜⵖⴻⵡⵡⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT9_8","006_9_8","DEU","9","8","8","ⵎⵉⵏⵣⵉ ⴷⵉ ⵀⵓⵔⵉⴱ ⵜⴻⴳⴳⵉⵎ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ, ⴰⵍⴰⵎⵉ ⵅⴰⵡⴻⵎ ⵉⵙⵄⴰⵔ ⵙⵉⴷⵉ ⴰⵍⴰⵎⵉ ⵉⵅⵙ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("DT9_9","006_9_9","DEU","9","9","9","ⵍⴰⵎⵉ ⵓⵍⵢⴻⵖ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵖ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ, ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⵇⵇⵉⵎⴻⵖ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴵⵢⴰⵍⵉ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ. ⴰⵖⵔⵓⵎ ⵡⴰⵔ ⵜ ⵛⵛⵉⵖ, ⴰⵎⴰⵏ ⵡⴰⵔ ⵜⴻⵏ ⵙⵡⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("DT9_10","006_9_10","DEU","9","10","10","ⵉⵡⵛ ⴰⵢⵉ ⵙⵉⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⵓⵔⵉⵏⵜ ⵙ ⵓⴹⴰⴹ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⴰⵢⵙⴻⵏⵜ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴽⵉⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("DT9_11","006_9_11","DEU","9","11","11","ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵉⵢⴰⵍⵉ, ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ, ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵍⵄⴰⵀⴷ, ");
INSERT INTO rift_vpl VALUES ("DT9_12","006_9_12","DEU","9","12","12","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⴽⴽⴰⵔ, ⵀⵡⴰ ⴷⴻⵖⵢⴰ ⵙⵙⴰ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵜⵏⴻⴷⵀⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⵉⴹⴻⵢⵢⴻⵄ ⵉ-ⵜ. ⵡⴻⴷⴷⴰⵔⴻⵏ ⴷⴻⵖⵢⴰ ⴰⴱⵔⵉⴷ ⵏⵏⵉ ⵉ ⵅ ⵜⴻⵏ ⵡⴻⵚⵚⵉⵖ. ⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DT9_13","006_9_13","DEU","9","13","13","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ, ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵍⴳⴻⵏⵙ-ⴰ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⵙⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("DT9_14","006_9_14","DEU","9","14","14","ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ ⵓ ⴰⴷ ⵎⵃⵉⵖ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵣⵉ ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵉⵎⵖⴰⵔ ⵅ ⵡⴰⵏⵉⵜⴰ.’” ");
INSERT INTO rift_vpl VALUES ("DT9_15","006_9_15","DEU","9","15","15","“ⵓⵛⴰ ⴷⴻⵡⵍⴻⵖ-ⴷⴷ, ⵀⵡⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ. ⵜⵓⵖⴰ ⴰⴷⵔⴰⵔ ⵢⴰⵔⴻⵇⵇ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⵜⵓⵖⴰ ⵖⴰⵔⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵍⵄⴰⵀⴷ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT9_16","006_9_16","DEU","9","16","16","ⵥⵔⵉⵖ, ⴰⵇⴰ ⴷⴰ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⴹⴰⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵜⴻⴳⴳⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵉⴼⴻⵙⵢⴻⵏ. ⴽⴻⵏⵏⵉⵡ ⵜⵉⴳⴳⵯⴻⵊⴻⵎ ⴷⴻⵖⵢⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵅ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT9_17","006_9_17","DEU","9","17","17","ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ, ⵏⴹⴰⵔⴻⵖ ⵜⴻⵏⵜ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⴰⵔⵥⵉⵖ ⵜⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT9_18","006_9_18","DEU","9","18","18","ⵡⴹⵉⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵓⵎⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ ⵡⴰⵔ ⵛⵛⵉⵖ ⴰⵖⵔⵓⵎ ⵓ ⵡⴰⵔ ⵙⵡⵉⵖ ⴰⵎⴰⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵉ ⵜⴻⴳⴳⵉⵎ ⵓⵎⵉ ⵜⴻⴳⴳⵉⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵓⵎⵉ ⵜ ⵜⴻⵙⵄⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT9_19","006_9_19","DEU","9","19","19","ⵎⵉⵏⵣⵉ ⴳⴳⵯⴻⴷⴻⵖ ⵣⴻⴳ ⵡⴻⵖⴹⴰⴱ ⴷ ⵡⴻⵙⵄⴰⵔ ⵉ ⵣⵉ ⵅⴰⵡⴻⵎ ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⵉⴼⴼⵓⴳⴻⵎ ⵓ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵜⴻⵃⵃⴰ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⴰⵢⵉ ⵄⴰⴷ ⵜⵡⴰⵍⴰ-ⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DT9_20","006_9_20","DEU","9","20","20","ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵉⵙⵄⴰⵔ ⴰⵟⵟⴰⵙ ⵅ ⵀⴰⵔⵓⵏ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵜⴻⵃⵃⴰ. ⵥⵥⵓⴵⴻⵖ ⵄⴰⵡⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵀⴰⵔⵓⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT9_21","006_9_21","DEU","9","21","21","ⴷⴷⴻⵏⴱ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵄⴻⵊⵎⵉ ⵏⵏⵉ ⵜⴻⴳⴳⵉⵎ, ⴽⵙⵉⵖ ⵜ ⵓⵛⴰ ⵙⵙⵛⴻⵎⴹⴻⵖ ⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵛⴻⴵⵇⴻⵖ ⵜ, ⵀⴰⵔⵢⴻⵖ ⵜ ⵎⵍⵉⵃ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⵉⴼⵙⵓⵙ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵖ ⵜⴰⵄⴻⵊⵊⴰⵛⵜ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT9_22","006_9_22","DEU","9","22","22","ⵜⴰⵏⵢⴰ ⴷⵉ ⵜⴰⴱⵄⵉⵔⴰ, ⴷⵉ ⵎⴰⵙⵙⴰ ⵓ ⴷⵉ ⵇⴰⴱⴰⵔⵓⵜ-ⵀⴰⵜⴰ’ⴰⵡⴰⵜ ⵜⴻⵙⵙⴼⴼⵓⴳⵎⴻⵎ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT9_23","006_9_23","DEU","9","23","23","ⵓⵛⴰ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵣⵉ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ, ⵉⵏⵏⴰ: ‘ⴰⵍⵢⴻⵎ ⵓ ⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵡⵛⵉⵖ ⵏⴻⵛⵛ!’, ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵍⵓⵎⵓⵔ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ, ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT9_24","006_9_24","DEU","9","24","24","ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵙⵉⴷⵉ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT9_25","006_9_25","DEU","9","25","25","ⵖⴻⵏⵙⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ ⵏⵏⵉ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉⵏ ⵖⴻⵏⵙⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵏⴰ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("DT9_26","006_9_26","DEU","9","26","26","ⵥⵓⴵⴻⵖ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⵏⵉⵖ: ‘ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⵀⴻⵍⵍⴰⴽ ⵍⴳⴻⵏⵙ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵜⴼⴻⴽⴽⴻⴷ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵏⴻⴷⵀⴻⴷ ⵜⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT9_27","006_9_27","DEU","9","27","27","ⵉⴷⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵜⵖⴻⵏⵏⴰⵏⵜ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵓⵍⴰ ⵖⴰⵔ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⴷ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT9_28","006_9_28","DEU","9","28","28","ⵃⵉⵎⴰ, ⵉⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵣⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ: ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵉⴷⴻⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵅ ⵜⵓⵖⴰ ⴽⵉⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ, ⵓ ⵎⵉⵏⵣⵉ ⵉⵛⴰⵔⵀ ⵉ-ⵜⴻⵏ, ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("DT9_29","006_9_29","DEU","9","29","29","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵙ ⵓⵖⵉⵍ ⵏⵏⴻⵛ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("DT10_1","006_10_1","DEU","10","1","1","“ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵏⵇⴻⵛ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⴰⵎ ⵜⵉⵏⵏⵉ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵓⵛⴰ ⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⴻⴳⴳ ⵉ ⵛⴻⴽ ⵉⵛⵜ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("DT10_2","006_10_2","DEU","10","2","2","ⴰⴷ ⴰⵔⵉⵖ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵏⵏⵉ ⵜⴰⵔⵥⵉⴷ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴷⵉ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("DT10_3","006_10_3","DEU","10","3","3","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵛⵜ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⵓⵛⴰ ⵏⴻⵇⵛⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⴰⵎ ⵜⵎⴻⵣⵡⵓⵔⴰ. ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT10_4","006_10_4","DEU","10","4","4","ⵢⵓⵔⴰ ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ, ⴰⵏⴻⵛⵜ ⵏ ⵜⵉⵔⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵅ ⵡⴻⴷⵔⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⴰⵢⵉ-ⴷⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT10_5","006_10_5","DEU","10","5","5","ⴷⴻⵡⵍⴻⵖ-ⴷⴷ ⵓ ⵀⵡⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵖ ⵜⵉⵍⵡⵉⵃⵉⵏ ⴷⵉ ⵜⵜⴰⴱⵓⵜ ⵏⵏⵉ ⴳⴳⵉⵖ ⵓⵛⴰ ⴷⵉⵀⴰ ⵉ ⴵⴰⵏⵜ ⵄⴰⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT10_6","006_10_6","DEU","10","6","6","ⴼⴻⵙⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵉ ⴱⵉⵄⵔⵓⵜ-ⴱⴰⵏⵉ-ⵢⴰⵄⵇⴰⵏ, ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵎⵓⵙⵉⵔⴰ. ⴷⵉⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉⵏ. ⵎⵎⵉⵙ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵉⴷⵡⴻⵍ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT10_7","006_10_7","DEU","10","7","7","ⵙⵙⴻⵏⵏⵉ ⵎⵎⵓⵟⵟⵉⵢⴻⵏ ⵖⴰⵔ ⵊⵓⴷⵊⵓⴷ ⵓ ⵣⵉ ⵊⵓⴷⵊⵓⴷ ⵖⴰⵔ ⵢⵓⵟⴱⴰⵜⴰ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT10_8","006_10_8","DEU","10","8","8","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ ⵉⵃⵓⵣⵣ ⵙⵉⴷⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓ ⴰⴷ ⴱⴰⵔⴽⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT10_9","006_10_9","DEU","10","9","9","ⵅ ⵓⵢⴰ ⵍⴰⵡⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵛⴰ ⵏ ⵜⴻⵙⵖⴰⵔⵜ, ⵓⵍⴰ ⴷ ⵛⴰ ⵏ ⵍⵡⴰⵔⵜ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ. ⵙⵉⴷⵉ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT10_10","006_10_10","DEU","10","10","10","“ⵓⵛⴰ ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵅ ⵡⴻⴷⵔⴰⵔ, ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ ⵓⵛⴰ ⵉⵙⵍⴰ ⴰⵢⵉ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵜⵡⴰⵍⴰ-ⵢⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵅⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT10_11","006_10_11","DEU","10","11","11","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⴽⴽⴰⵔ, ⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵊⵊⵓⴵⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ-ⵡⵛⴻⵖ, ⴰⴷ ⵜⵜ ⴽⵙⵉⵏ ⴷ ⵍⵡⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("DT10_12","006_10_12","DEU","10","12","12","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴰ ⵉⵙⵔⴰⵉⵍ! ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵖⵉⵔ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵜ ⵜⴻⵅⵙⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵛ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT10_13","006_10_13","DEU","10","13","13","ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⵉ ⵏⴻⵛⵛ ⵅⴰⴽ ⵛⴰⵔⴹⴻⵖ ⴰⵙⵙ-ⴰ ⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT10_14","006_10_14","DEU","10","14","14","ⵅⵣⴰⵔ, ⴰⵊⴻⵏⵏⴰ ⴷ ⵓⵊⴻⵏⵏⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵉ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT10_15","006_10_15","DEU","10","15","15","ⵎⵖⵉⵔ ⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵡⴰⵀⴰ ⵉ ⵉⵇⵇⴻⵏ ⵙⵉⴷⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵅⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵅⴹⴰⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⴰⵇⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT10_16","006_10_16","DEU","10","16","16","ⵅⴻⵜⵏⴻⵎ ⵅⴻⵏⵏⵉ ⵉ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵏ ⵡⵓⵍ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵙⵇⴻⵙⵙⵉⵃⴻⵎ ⵛⴰ ⵄⴰⴷ ⴽⵜⴰⵔ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT10_17","006_10_17","DEU","10","17","17","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⴷ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵉⴷⵉⵜⴻⵏ, ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵖⴰⵔ ⴷ ⴰⵊⴻⴱⴱⴰⵔ ⴷ ⴰⵎⴻⴳⴳⵯⴻⴷ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴼⴰⵔⵣ ⴷⴻⴳ ⵉⵡⴷⴰⵏ ⵏⵉⵖ ⵉⴽⴻⵙⵙⵉ ⵛⵛⴰⵔⴹ, ");
INSERT INTO rift_vpl VALUES ("DT10_18","006_10_18","DEU","10","18","18","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵉ ⵓⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵓ ⵉⵡⵛⴰ ⴰⵙ ⴰⵖⵔⵓⵎ ⴷ ⴰⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("DT10_19","006_10_19","DEU","10","19","19","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT10_20","006_10_20","DEU","10","20","20","ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⵍⴻⵚⵇⴻⴷ ⵓ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵊⵊⴰⴵⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT10_21","006_10_21","DEU","10","21","21","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⴻⴱⴱⴰⵃ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵜⵉⵏⵏⵉ ⵥⵔⵉⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT10_22","006_10_22","DEU","10","22","22","ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵀⵡⴰⵏ-ⴷⴷ ⵙ ⵙⴻⴱⵄⵉⵏ ⵏ ⵍⴻⵄⵎⵓⵔ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵉⴳⴳⴰ ⵉ-ⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT11_1","006_11_1","DEU","11","1","1","“ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⵉⵏ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ, ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT11_2","006_11_2","DEU","11","2","2","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵙⵙ-ⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏⴻⵏ ⵓ ⵡⴰⵔ ⵥⵔⵉⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ");
INSERT INTO rift_vpl VALUES ("DT11_3","006_11_3","DEU","11","3","3","ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⵉⴳⴳⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT11_4","006_11_4","DEU","11","4","4","... ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵢⵙⴰⵏ ⵏⵙⴻⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵎⵎⴻⵛ ⴷ ⵢⴰⵔⵔⴰ ⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⴰⴷ ⴼⴻⵢⵢⴹⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⴹⴼⴰⵔⴻⵏ. ⴰⵇⴰ ⵉⵀⴻⵍⵍⴻⴽ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ, ⴰⵍ ⴰⵙⵙ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("DT11_5","006_11_5","DEU","11","5","5","... ⴷ ⵎⵉⵏ ⴰⴽⵉⴷⵡⴻⵎ ⵉⴳⴳⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵍⴰⵎⵉ ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("DT11_6","006_11_6","DEU","11","6","6","... ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⴷⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵔⴰⵎ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵓⴱⵉⵏ, ⵎⴰⵎⵎⴻⵛ ⵜⴰⵔⵣⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵙⴰⵔⴹ ⵉ-ⵜⴻⵏ ⴰⴽ-ⴷ ⵔⴰⴵ ⵏⵙⴻⵏ ⴷ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏⵙⴻⵏ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT11_7","006_11_7","DEU","11","7","7","ⴰⵇⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵥⵔⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT11_8","006_11_8","DEU","11","8","8","ⵅⴻⵏⵏⵉ ⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⵊⴻⵀⴷⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⴰⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("DT11_9","006_11_9","DEU","11","9","9","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⵓⴳⴰⵔⵜⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵡⵛ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DT11_10","006_11_10","DEU","11","10","10","ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵔⴰⵃⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵍⵡⴰⵔⵜ, ⵡⴰⵔ ⵜⴻⴵⵉ ⴰⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ, ⵎⴰⵏⵉ ⵜⵣⴰⵔⵄⴻⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵓ ⵜⴻⵏⵏⵉ ⵜⴻⵙⵙⵡⴻⴷ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵃⵡⵉⵛⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("DT11_11","006_11_11","DEU","11","11","11","ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵢⵙⴰⵔⵉⵏ, ⵜⴻⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⴰⵎⴰⵏ ⵏ ⵡⴻⵏⵥⴰⵔ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("DT11_12","006_11_12","DEU","11","12","12","ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵅ ⵉⵃⴻⵟⵟⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉ ⵅ ⴵⴰⵏⵜ ⵍⴻⴱⴷⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵣⵉ ⴱⴻⴷⴷⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT11_13","006_11_13","DEU","11","13","13","ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵏⵉⵛⴰⵏ ⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("DT11_14","006_11_14","DEU","11","14","14","ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⴰⵏⵥⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ, ⴰⵏⵥⴰⵔ ⵏ ⵣⵉⵛ ⴷ ⵓⵏⴻⴳⴳⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵉⵔⴷⴻⵏ ⵏⵏⴻⵛ ⴷ ⴱⵉⵏⵓ ⵏⵏⴻⵛ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵛ ⵏ ⵟⵟⵔⵉ ");
INSERT INTO rift_vpl VALUES ("DT11_15","006_11_15","DEU","11","15","15","ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⵔⴱⵉⵄ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵓ ⴰⴷ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT11_16","006_11_16","DEU","11","16","16","“ⵃⴹⴰⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵖⴻⴽⴽⵯⵉ ⵡⵓⵍ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⴷ ⵜⵄⴻⴱⴷⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵏⴷⵇⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT11_17","006_11_17","DEU","11","17","17","ⵉⵍⵉ ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵛⵛⵉⵜ ⵡⴻⵏⵥⴰⵔ ⵄⴰⴷ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵛ ⵜⴻⵎⵎⵓⵔⵜ ⵄⴰⴷ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵎ ⴷⴻⵖⵢⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT11_18","006_11_18","DEU","11","18","18","ⵙ ⵓⵢⴰ ⵃⴹⴰⵎ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉⵏⵓ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵓ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ ⵓ ⴰⴷ ⵜⴻⵏ ⵜⴱⴻⵢⵙⴻⵎ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵅ ⵓⴼⵓⵙ ⵏⵡⴻⵎ, ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⴼⵉⵍⴰⵏ ⵏ ⵓⵙⴻⴳⴳⴻⵎ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ");
INSERT INTO rift_vpl VALUES ("DT11_19","006_11_19","DEU","11","19","19","ⵓⵛⴰ ⵙⵍⴻⵎⴷⴻⵎ ⵜⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⵎ ⵅⴰⵙⴻⵏ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉⵎ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ ⵓ ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓ ⴷⴻⴳ ⵢⵉⴹⴻⵚ ⵏⵏⴻⵛ ⵓ ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉⴷ ⵜⴼⴰⵇⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT11_20","006_11_20","DEU","11","20","20","ⵓ ⴰⵔⵉⵎ ⵜⴻⵏ ⵅ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ");
INSERT INTO rift_vpl VALUES ("DT11_21","006_11_21","DEU","11","21","21","ⵃⵉⵎⴰ ⴰⴷ ⴽⵜⴰⵔⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⴷ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵎⵉⵏ ⵅⴻⴼ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵏ-ⵉ-ⴷⴷ-ⵉⵡⵛ, ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵇⵇⵉⵎⴻⵏ ⴽⵜⴰⵔⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT11_22","006_11_22","DEU","11","22","22","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⵃⴹⴰⵎ ⵏⵉⵛⴰⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴳⴳⴻⵎ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵓ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⵍⴻⵚⵇⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT11_23","006_11_23","DEU","11","23","23","ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵡⴰⵔⵜⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵉⵊⴻⵀⴷⴻⵏ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT11_24","006_11_24","DEU","11","24","24","ⵎⴰⵔⵔⴰ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵄⵊⴻⵏ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⵏⵡⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵏⵡⴻⵎ. ⵣⵉ ⵍⴻⵅⵍⴰ ⵓ ⵣⵉ ⵍⵓⴱⵏⴰⵏ, ⵓ ⵣⴻⴳ ⵉⵖⵣⴰⵔ, ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴷⵉ ⵍⵖⴰⵔⴱ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT11_25","006_11_25","DEU","11","25","25","ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵉⴳⴳ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵍⵄⵓⵔⵔⴻⵜ ⵣⵣⴰⵢⵡⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵅ ⵖⴰ ⵜⵄⴻⵊⵏⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("DT11_26","006_11_26","DEU","11","26","26","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵙⵙ-ⴰ ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("DT11_27","006_11_27","DEU","11","27","27","... ⵍⴱⴰⵔⴰⴽⴰ, ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵜⵉⵏⵏⵉ ⵅ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("DT11_28","006_11_28","DEU","11","28","28","... ⴷ ⵏⵏⴻⵄⵍⴻⵜ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴻⵊⴻⵎ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴹⴼⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("DT11_29","006_11_29","DEU","11","29","29","ⵅⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵉⴷⴻⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵍⵡⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⵉⵔⵉⵣⵉⵎ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵄⵉⴱⴰⵍ.    ");
INSERT INTO rift_vpl VALUES ("DT11_30","006_11_30","DEU","11","30","30","ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵉⴷⵓⵔⴰⵔ ⵏⵏⵉ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⴱⵔⵉⴷ, ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ, ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵊⵉⵍⵊⴰⵍ, ⵣⵣⴰⵜ ⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⴳⴳ ⵏ ⵎⵓⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("DT11_31","006_11_31","DEU","11","31","31","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⴰⴷⴼⴻⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴷ ⵍⵡⴰⵔⵜ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜ ⵜⵡⴰⵔⵜⴻⵎ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT11_32","006_11_32","DEU","11","32","32","ⵃⴹⴰⵎ ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT12_1","006_12_1","DEU","12","1","1","“ⴷ ⵜⵉⵏⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴷⴷⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT12_2","006_12_2","DEU","12","2","2","ⴰⴷ ⵜⴰⵔⴻⴷⴷⴵⴻⵎ ⵇⴰⵄ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ: ⵅ ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵓ ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ.    ");
INSERT INTO rift_vpl VALUES ("DT12_3","006_12_3","DEU","12","3","3","ⴰⴷ ⵜⴻⵏⴹⴰⵔⴻⵎ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵜⴰⵔⵥⴻⵎ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⵎ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⴷ ⵜⵀⴻⴷⵎⴻⵎ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵃⴰⵎ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT12_4","006_12_4","DEU","12","4","4","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⵄⴻⴱⴱⴷⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴰⵎ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT12_5","006_12_5","DEU","12","5","5","ⵎⴰⵛⴰ ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⴳⴳ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵉ ⵖⴰ ⵜⴰⵔⵣⵓⵎ ⵓ ⴷⵉⵏ ⵉ ⵖⴰ ⵜⴰⵡⴹⴻⵎ ");
INSERT INTO rift_vpl VALUES ("DT12_6","006_12_6","DEU","12","6","6","ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⵡⵢⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⴷ ⵍⴻⵄⵛⵓⵔ ⵏⵡⴻⵎ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵙ ⵍⵅⴰⴹⴰⵔ ⴷ ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵏⵣⴰ ⵏ ⵡⵓⴵⵉ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT12_7","006_12_7","DEU","12","7","7","ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴰⴵ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵓ ⵣⵉ ⵎⵉⵏ ⴷⵉ ⴽⴻⵏⵏⵉⵡ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT12_8","006_12_8","DEU","12","8","8","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵏᵉⵜⵜⴻⴳⴳ ⵏⴻⵛⵛⵉⵏ ⴷⴰ ⴰⵙⵙ-ⴰ: ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵍⴰ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT12_9","006_12_9","DEU","12","9","9","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵄⴰⴷ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵜⵓⴷⵉⴼⴻⵎ ⵛⴰ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵓ ⵖⴰⵔ ⵍⵡⴰⵔⵜ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT12_10","006_12_10","DEU","12","10","10","ⵅⵎⵉ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⵍⵡⴰⵔⵜ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⵔⵔⴰⵃⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT12_11","006_12_11","DEU","12","11","11","ⴷⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵣⴷⴻⵖ ⴷⵉⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⵡⵢⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ: ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵡⴻⵎ, ⵜⵉⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ, ⵍⴻⵄⵛⵓⵔ ⵏⵡⴻⵎ, ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵡⴰⵄⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⵡⴻⵄⴷⴻⵎ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT12_12","006_12_12","DEU","12","12","12","ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵡⴻⵎ ⴷ ⵜⵉⵢⵢⴰ ⵏⵡⴻⵎ ⴷ ⵓⵍⴰⵡⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵉⵖ ⵍⵡⴰⵔⵜ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT12_13","006_12_13","DEU","12","13","13","ⵃⴹⴰ ⵡⴰⵔ ⵙⵙⴱⴻⵅⵅⴰⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷⵉ ⵎⵉⵏ ⵎⴰ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⵜⵡⴰⵍⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("DT12_14","006_12_14","DEU","12","14","14","ⵎⴰⵛⴰ ⵡⴰⵀⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ⴷⴻⴳ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵛ, ⴷⵉⵏⵏⵉ ⵡⴰⵀⴰ ⵉ ⵖⴰ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT12_15","006_12_15","DEU","12","15","15","ⵙ ⵎⴰⵔⵔⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⵎⴻⵥⵔⵉ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ. ⴰⵎⴻⵅⵎⵓⵊ ⴷ ⵓⵎⴻⵣⴷⴰⴳ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ, ⴰⵅⵎⵉ ⵜⵜⴻⵜⵜⴻⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⵓ ⵣⴻⴳ ⵓⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DT12_16","006_12_16","DEU","12","16","16","ⵎⵖⵉⵔ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⴻⵜⵜⴻⴷ. ⴰⴷ ⵜⴻⵏ ⵜⵏⴻⵖⵍⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT12_17","006_12_17","DEU","12","17","17","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵣⵉ ⵍⴻⵄⵛⵓⵔ ⵏ ⵉⵔⴷⴻⵏ ⴷ ⴱⵉⵏⵓ ⵏⵏⴻⵛ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵛ ⵏ ⵟⵟⵔⵉ ⵓⵍⴰ ⵣⴻⴳ ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵛ ⵏⵉⵖ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵜⴻⵡⵛⵉⴷ ⵏⵉⵖ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵉⵖ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT12_18","006_12_18","DEU","12","18","18","ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵛⴻⴽ, ⵎⵎⵉⵛ, ⵢⴻⴵⵉⵛ, ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴷ ⵓⵍⴰⵡⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔ ⵖⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT12_19","006_12_19","DEU","12","19","19","ⵃⴹⴰ, ⵡⴰⵔ ⵙⴻⵎⵎⴻⵃ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵍⴰⵡⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT12_20","006_12_20","DEU","12","20","20","“ⵅⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵙⵙⵉⵢⵔⵓ ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵉⵏⵏⴰ, ⵓⵛⴰ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵅⵙⴻⵖ ⴰⴷ ⵛⵛⴻⵖ ⴰⵢⵙⵓⵎ’, ⵎⵉⵏⵣⵉ ⵉⵎⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵢⴻⵛⵛ ⴰⵢⵙⵓⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵢⵙⵓⵎ ⴰⵏⴻⵛⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ.    ");
INSERT INTO rift_vpl VALUES ("DT12_21","006_12_21","DEU","12","21","21","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵛⴻⴽ ⵜⵉⴳⴳⵯⴻⵊⴻⴷ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⵓ ⵣⴻⴳ ⵡⵓⴵⵉ ⵏⵏⴻⵛ ⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⴷ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⴰⵏⴻⵛⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵎⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT12_22","006_12_22","DEU","12","22","22","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵛⵛ ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⴷ ⵓⴷⴰⴷ, ⴰⵎⴻⵏⵏⵉ ⵉ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵜⴻⵛⵛⴻⴷ. ⴰⵎⴻⵅⵎⵓⵊ ⴷ ⵓⵎⴻⵣⴷⴰⴳ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT12_23","006_12_23","DEU","12","23","23","ⵎⵖⵉⵔ ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⵄⴻⵎⵎⴰⵔⵚ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵍⴻⵄⵎⴰⵔ. ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⵍⴻⵄⵎⴰⵔ ⴰⴽ-ⴷ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("DT12_24","006_12_24","DEU","12","24","24","ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜᵉⵜⵜⴻⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵏⴻⵖⵍⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT12_25","006_12_25","DEU","12","25","25","ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜᵉⵜⵜⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵛⴻⴽ ⵎⵍⵉⵃ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⵅⵎⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT12_26","006_12_26","DEU","12","26","26","ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵎⵖⵉⵔ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵇⴻⴷⴷⵙⴻⵏⵜ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⵙⴻⵏⵜ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ");
INSERT INTO rift_vpl VALUES ("DT12_27","006_12_27","DEU","12","27","27","ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⴰ ⴰⴷ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("DT12_28","006_12_28","DEU","12","28","28","ⵃⴹⴰ, ⵓ ⵙⴻⵍ ⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏⵏⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ, ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⵉ ⵍⴻⴱⴷⴰ, ⵓⵎⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⴷ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT12_29","006_12_29","DEU","12","29","29","“ⵅⵎⵉ ⵖⴰ ⵉⵜⴻⵃⵃⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT12_30","006_12_30","DEU","12","30","30","ⵃⴹⴰ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴹⴻⴼⴼⴰⵔⴻⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴷⵉ ⵍⴼⴻⵅ ⴷ ⵉⵛⵜ, ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⵅ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ.’ ");
INSERT INTO rift_vpl VALUES ("DT12_31","006_12_31","DEU","12","31","31","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴰⵎⴻⵏⵏⵉ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵙⵉⴷⵉ ⴷ ⵎⵉⵏ ⵉⵛⴰⵔⵔⴻⵀ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⴳⴳⵉⵏ ⵜ ⵏⵉⵜⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ. ⵄⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT13_1","006_13_1","DEU","13","1","1","“ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍ ⵏⵏⵉ ⵅ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵚⵚⵉⵖ, ⴰⴷ ⵜ ⵜⴻⵃⴹⴰⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⵎ. ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵔⴻⵏⵏⵉ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴽⴽⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT13_2","006_13_2","DEU","13","2","2","ⵎⴰⵍⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵎⴻⵔⵊⵉ ⵏ ⵜⵉⵔⵊⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ ⵓⵛⴰ ⵉⴳⴳⴰ ⵛⴰ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵉⵖ ⵙ ⵛⴰ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰ ⵖⴰⵔⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("DT13_3","006_13_3","DEU","13","3","3","ⵓⵛⴰ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⵉ ⵏⵉⵖ ⵍⵎⵓⵄⵊⵉⵣⴰ ⵏⵏⵉ ⵅ ⴷ ⴰⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵜⴻⵎⵙⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: ‘ⴻⵊⵊ ⴰⴷ ⵏⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ!’, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ, ⵓⵛⴰ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⴰⵙⴻⵏ ⵏⴻⵄⴱⴻⴷ!’, ");
INSERT INTO rift_vpl VALUES ("DT13_4","006_13_4","DEU","13","4","4","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵏⵏⵉ ⵏⵉⵖ ⵏ ⵓⵎⴻⵔⵊⵉ ⵏ ⵜⵉⵔⵊⴰ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉⵜⵜⵇⴻⴵⴰⴱ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT13_5","006_13_5","DEU","13","5","5","ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⵯⴷⴻⵎ, ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵍⴻⵚⵇⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT13_6","006_13_6","DEU","13","6","6","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵓⵏⴰⴱⵉ ⵏⵏⵉ ⵏⵉⵖ ⵓⵎⴻⵔⵊⵉ ⵏⵏⵉ ⵏ ⵜⵉⵔⵊⴰ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵍⴰⴳⴳⵯⴰⵊⴻⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ - ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴼⴷⵉⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ - ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵅ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵓⵢⵓⵔⴻⴷ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ.    ");
INSERT INTO rift_vpl VALUES ("DT13_7","006_13_7","DEU","13","7","7","ⵎⴰⵍⴰ ⵓⵎⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵛ, ⵏⵉⵖ ⵎⵎⵉⵛ ⵏⵉⵖ ⵢⴻⴵⵉⵛ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ ⵏⵉⵖ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉ ⵉⴵⴰⵏ ⴰⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵖⴰⵔ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ!’ ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT13_8","006_13_8","DEU","13","8","8","ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵛ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ, ⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⵏⵉⵖ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT13_9","006_13_9","DEU","13","9","9","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⴻⴳⴳ ⵛⴰ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵜⴻⵙⵍⵉ ⵛⴰ. ⵡⴰⵔ ⵜ ⴰⵔⴻⵃⵃⴻⵎ ⵛⴰ, ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵣⵣⵉⴵⵉⵣ ⵛⴰ ⵏⵉⵖ ⴰⴷ ⵜ ⵜⴻⴼⴼⴰⵔⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT13_10","006_13_10","DEU","13","10","10","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⵏⵖⴻⴷ ⵏⵉⵛⴰⵏ. ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⵙ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵏⵖⴻⴷ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT13_11","006_13_11","DEU","13","11","11","ⴰⴷ ⵜ ⵜⵃⴻⵊⵊⴰⵔⴻⵎ ⵙ ⵢⴻⵥⵔⴰ ⴰⵍ ⵖⴰ ⵉⵎⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("DT13_12","006_13_12","DEU","13","12","12","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵙⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴷ-ⴷⵉⴽⴽⵯⵉⵍⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⵖⴰⵔ-ⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT13_13","006_13_13","DEU","13","13","13","“ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⴷ ⴰⵇⴰ ⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵣⴻⴷⵖⴻⴷ: ");
INSERT INTO rift_vpl VALUES ("DT13_14","006_13_14","DEU","13","14","14","‘ⴰⵇⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵓⵛⴰ ⵙⵙⵖⴻⴽⴽⵡⴰⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵙⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ⴻⵊⵊ ⴰⴷ ⵏⵔⴰⵃ ⴰⴷ ⵏⴻⵄⴱⴻⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ!’, ");
INSERT INTO rift_vpl VALUES ("DT13_15","006_13_15","DEU","13","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⵓ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⵎⵍⵉⵃ, ⵓ ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵜⵓⴼⵉⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⵜⴱⴻⴷⴷ ⵅ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT13_16","006_13_16","DEU","13","16","16","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ⴰⴷ ⵜⵜ ⵜⵃⴰⵔⵔⵎⴻⴷ ⵉ ⵓⵜⴻⵃⵃⵉ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⵓⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵙ, ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("DT13_17","006_13_17","DEU","13","17","17","ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵡⴰⵣⵣⴰⵢ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⴷⴰⵢⴻⵙ, ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴰⵔⴱⴻⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT13_18","006_13_18","DEU","13","18","18","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵍⴻⵚⵚⴻⵇ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⴽ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵃⴻⵎ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT13_19","006_13_19","DEU","13","19","19","ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⵉ ⵅ ⴷ ⴰⵛ ⵡⴻⵚⵚⵉⵖ ⴰⵙⵙ-ⴰ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT14_1","006_14_1","DEU","14","1","1","“ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵅⴻⴱⴱⵛⴻⵎ ⵛⴰ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵇⴻⵛⵛⴰⵔⴻⵎ ⵛⴰ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DT14_2","006_14_2","DEU","14","2","2","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⴻⴷⴷⴻⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵛⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵉⵍⵉⴷ ⴷ ⵍⴳⴻⵏⵙ ⵉⵖⵍⴰⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT14_3","006_14_3","DEU","14","3","3","ⵡⴰⵔ ⵜⵜⴻⵜⵜ ⵣⵉ ⴽⵓⵍⵛⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DT14_4","006_14_4","DEU","14","4","4","ⴰⵇⴰ ⴷ ⵉⵏⴰ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ: ⴰⴼⵓⵏⴰⵙ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT14_5","006_14_5","DEU","14","5","5","ⵓⴷⴰⴷ, ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ, ⵉⵣⴻⵔⵣⴻⵔ, ⵉⵖⴰⵢⴹ ⴰⴽ-ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⴰⵎⴻⵍⵍⴰⵍ, ⴰⴼⵓⵏⴰⵙ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵉⵖⴰⵢⴹ ⵏ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT14_6","006_14_6","DEU","14","6","6","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵍⴻⵇⵇⴰ ⵏ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⵜⴰⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ, ⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵜⴰⵔⵔⴰⵏ ⵉⴼⴻⵥ ⵊⴰⵔ ⵍⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("DT14_7","006_14_7","DEU","14","7","7","ⵎⴰⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⴼⴻⵥ ⴷ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵇⴰⵄ ⵅ ⵜⵏⴰⵢⴻⵏ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵉⵏⴰ: ⴰⵍⵖⴻⵎ, ⴷ ⵓⵢⴰⵔⵣⵉⵣ ⴷ ⵓⴽⴰⵡⴽⴰ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵎⵉⵏⵣⵉ ⵜⵜⴻⴼⴼⵥⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT14_8","006_14_8","DEU","14","8","8","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵉⵍⴻⴼ, ⵡⴰⵅⵅⴰ ⵖⴰⵔⴻⵙ ⵜⴰⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ, ⵡⴰⵔ ⵉⵜⵜⴰⵔⵔⵉ ⵉⴼⴻⵥ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⵃⴰⴷⴰⵎ ⵛⴰ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT14_9","006_14_9","DEU","14","9","9","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵉⵏⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ: ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴼⵔⵉⵡⴻⵏ ⴷ ⵜⴻⵇⵛⵓⵔⵜ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT14_10","006_14_10","DEU","14","10","10","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⵖⴰⵔ ⴵⵉⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵉⵖ ⵜⴰⵇⵛⵓⵔⵜ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵍⵉⵏ ⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT14_11","006_14_11","DEU","14","11","11","ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵉⵣⴷⵉⴳⴻⵏ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT14_12","006_14_12","DEU","14","12","12","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵛⵛⴻⵎ ⵉⵏⴰ: ⴰⴳⵉⴷⴻⵔ, ⵉⵙⵖⵉ, ⴰⴳⵉⴷⴻⵔ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("DT14_13","006_14_13","DEU","14","13","13","ⴱⵓ-ⵍⵅⴻⵥⵔⴰⵜ ⴷ ⴰⵎⴻⵙⵖⵓⵢ ⴰⵎⵓⵇⴹⵉⵄ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷ ⴱⵓ-ⵓⵎⴻⵟⵟⴰⵡ ⵙ ⵜⴰⵣⵍⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT14_14","006_14_14","DEU","14","14","14","ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵓⴱⴰⵖⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("DT14_15","006_14_15","DEU","14","15","15","ⵢⴻⴵⵉⵙ ⵏ ⴱⵓⵀⴻⵢⵢⴰⴼ, ⴰⵄⴻⵏⵏⴰⴼ, ⴰⵊⴹⵉⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵍⴱⴰⵣ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT14_16","006_14_16","DEU","14","16","16","ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴽⴰⵙ, ⴱⵓ-ⵓⵙⵓⴹⵉ ⵏ ⵍⵎⴻⵡⵜ, ⴱⵓ-ⵢⵓⵏⵜⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("DT14_17","006_14_17","DEU","14","17","17","ⴱⵓ-ⵓⵄⵓⵇⵇⵉ, ⴱⵓ-ⵓⵃⴰⵡⴰⵍ, ⴱⵓ-ⵜⵛⴰⵔⴰⵔⵔⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("DT14_18","006_14_18","DEU","14","18","18","ⴰⴱⴻⵍⵍⴰⵔⵊ, ⴱⵓ-ⵓⵙⵓⴹⵉ ⵉⵄⴻⴼⴼⵏⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⴽⴰⵜ ⵏⵏⴻⵙ, ⴷⵓⵏⴷⵓⵏ ⴷ ⵍⵡⴻⴹⵡⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("DT14_19","006_14_19","DEU","14","19","19","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵅⵎⴻⵊ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵜⵡⴰⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT14_20","006_14_20","DEU","14","20","20","ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵉⵣⴷⵉⴳⴻⵏ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT14_21","006_14_21","DEU","14","21","21","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵓⵍⴰ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ. ⴰⴷ ⵜⵜ ⵜⴻⵡⵛⴻⴷ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ, ⵏⵉⵖ ⴰⴷ ⵜⵜ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” “ⵡⴰⵔ ⵙⵏⴻⵏⵏⵉ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷⴻⴳ ⵓⵖⵉ ⵏ ⵢⴻⵎⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("DT14_22","006_14_22","DEU","14","22","22","ⴰⴷ ⵜⵄⴻⵛⵛⴰⵔⴻⴷ ⵏⵉⵛⴰⵏ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⵉ ⵉⵜⵜⴻⵊⵊⴰ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT14_23","006_14_23","DEU","14","23","23","ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵍⴻⵄⵛⵓⵔ ⵏ ⵉⵔⴷⴻⵏ ⵏⵏⴻⵛ, ⵏ ⴱⵉⵏⵓ ⵏⵏⴻⵛ ⵏ ⵊⴷⵉⴷ, ⵏ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵛ ⵏ ⵟⵟⵔⵉ, ⵓⵍⴰ ⵏ ⵉⵎⴻⵏⵣⴰ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵓ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵉⵣⴻⵎⵎⴻⵎ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵍⴻⵎⴷⴻⴷ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("DT14_24","006_14_24","DEU","14","24","24","ⵎⴰⵍⴰ ⴰⴱⵔⵉⴷ ⵉⵣⵣⵓⴳⴳⴰⵔⵜ ⵅⴰⴽ ⴰⵟⵟⴰⵙ, ⴰⵍ ⵖⴰ ⵜⴰⴼⴻⴷ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵍⴻⵄⵛⵓⵔ ⴷⵉⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵣⴻⵎⵎ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵉⴵⴰⵏ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴽ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵉⴱⴰⵔⴻⴽ ⵉ ⵛⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("DT14_25","006_14_25","DEU","14","25","25","ⵇⵍⴻⴱ ⵉ-ⵜⴻⵏ ⵅⴻⵏⵏⵉ ⴷ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⵓⵢⵓⵔ ⵙ ⵜⴽⴻⵎⵎⵓⵙⵜ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT14_26","006_14_26","DEU","14","26","26","ⴰⴷ ⵜⵚⴰⵔⴼⴻⴷ ⵜⵎⴻⵏⵢⴰⵜ ⵏⵏⵉ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵉⵎⵎⴻⵥⵔⵉ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵅ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵅ ⵡⵓⴵⵉ, ⵅ ⴱⵉⵏⵓ, ⵅ ⵛⵛⵔⴰⴱ ⵏⵉⵖ ⵅ ⵎⵉⵏ ⵎⴰ ⵉⵅⵙ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ, ⵛⴻⴽ ⴷ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT14_27","006_14_27","DEU","14","27","27","“ⵡⴰⵔ ⵙⴻⵎⵎⴻⵃ ⵛⴰ ⴷⵉ ⴰⵍⴰⵡⵉ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵉⵖ ⵍⵡⴰⵔⵜ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DT14_28","006_14_28","DEU","14","28","28","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵛⵓⵔ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵅⴻⵣⵏⴻⴷ ⵊⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT14_29","006_14_29","DEU","14","29","29","ⵅⴻⵏⵏⵉ ⴰⵍⴰⵡⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴻⴵⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵉⵖ ⵍⵡⴰⵔⵜ ⴰⴽⵉⴷⴻⴽ, ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷ ⵓⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵛⵛⴻⵏ, ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT15_1","006_15_1","DEU","15","1","1","“ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵡⴻⵙⵎⴰⵃ ⵏ ⵉⵎⴻⵔⵡⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DT15_2","006_15_2","DEU","15","2","2","ⵜⴰ ⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⴼⴻⴽⴽⵉ ⵣⴻⴳ ⵉⵎⴻⵔⵡⵓⵙⴰ: ⴽⵓⵍ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴹⵍⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵉⵙⴻⵎⵃ ⵉ ⵓⵎⴰⵔⵡⴰⵙ. ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜⴰⵔ ⵛⴰ ⴰⵎⴰⵔⵡⴰⵙ ⵣⴻⴳ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵍⴰ ⵣⴻⴳ ⵓⵎⴰⵙ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵓⴼⴻⴽⴽⵉ ⵏ ⵉⵎⴻⵔⵡⵓⵙⴰ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT15_3","006_15_3","DEU","15","3","3","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵍⴰⵖⵉⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵅ ⵓⵎⴰⵔⵡⴰⵙ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵎⴰⵛ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵙⵎⴻⵃ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT15_4","006_15_4","DEU","15","4","4","ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵖⴰ ⵜⵡⴰⵔⵜⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT15_5","006_15_5","DEU","15","5","5","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵙⵍⵉⴷ ⵙ ⵜⴻⵢⵏⵉⵜ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ, ⵜⵉⵏⵏⵉ ⵅ ⴷ ⴰⵛ ⵡⴻⵚⵚⵉⵖ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT15_6","006_15_6","DEU","15","6","6","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵛ ⵉⵏⵏⴰ, ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵅⴰⴽ ⴰⵔⴹⵍⴻⵏ ⵙ ⵡⴻⴹⵎⴰⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴰⵔⴻⵟⵟⵍⴻⴷ ⵡⴰⵍⵓ ⵙ ⵡⴻⴹⵎⴰⵏ ⵅ ⵓⵍⴰ ⴷ ⵢⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ⵛⴻⴽ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴰⴽ ⵃⴻⴽⴽⵎⴻⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT15_7","006_15_7","DEU","15","7","7","“ⵅⵎⵉ ⴷⵉⵏ ⵖⴰⵔⴻⴽ ⵖⴰ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ, ⵉⵊⵊ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵛ, ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵢⵉⵛⵜ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵢⴻⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵙⵙⴻⵇⵙⴰⵃ ⵛⴰ ⵓⵍ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜⵜⵣⴻⵢⵢⴰⵔ ⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵓⵎⴰⵛ ⵏⵏⵉ ⵉⵣⴻⵍⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT15_8","006_15_8","DEU","15","8","8","ⵎⴰⵛⴰ ⴰⴷ ⴰⵙ ⵜⴰⵔⵣⵎⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵙ ⵡⴻⵛⵔⵉⵎ ⵓ ⴰⴷ ⴰⵙ ⵜⴰⵔⴻⴹⵍⴻⴷ ⵙ ⵡⴻⴹⵎⴰⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵃⵡⴰⵊ ⴷⴻⴳ ⵓⵣⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT15_9","006_15_9","DEU","15","9","9","ⵃⴹⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵔⵉⵚ ⴱⴰⵟⴻⵍ, ⵜⴻⵇⵇⴰⵔⴻⴷ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ: ‘ⴰⵇⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏ ⵉⵎⴻⵔⵡⵓⵙⴰ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵅⴻⵢⵢⵇⴻⵏ ⵅ ⵓⵎⴰⵛ ⵏⵏⵉ ⵉ ⴷⵉ ⵉⴵⴰ ⵣⵣⴻⵍⴹ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜᵉⵜⵜⵉⵛⴻⴷ ⵡⴰⵍⵓ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵛⴻⵜⵛⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵢⵉⵍⵉ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("DT15_10","006_15_10","DEU","15","10","10","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⴷ ⴷⴻⵖⵢⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵅⴻⵢⵢⴻⵇ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵅⵎⵉ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵜⴻⵡⵛⴻⴷ, ⵎⵉⵏⵣⵉ ⵅ ⵓⵢⴰ ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⵡⴻⴹ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT15_11","006_15_11","DEU","15","11","11","ⵎⵉⵏⵣⵉ ⴰⵎⴻⵥⵍⵓⴹ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵎⴻⵃⵃⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵅ ⵓⵢⴰ ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ, ⵇⵇⴰⵔⴻⵖ: ⴰⵔⵣⴻⵎ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⵍ ⵟⵟⴰⵔⴼ ⵉ ⵓⵎⴰⵛ, ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵓ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT15_12","006_15_12","DEU","15","12","12","“ⵎⴰⵍⴰ ⵓⵎⴰⵛ, ⵉⵊⵊ ⵏ ⵓⵄⵉⴱⵔⴰⵏⵉ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵄⵉⴱⵔⴰⵏⴻⵛⵜ, ⵉⵜⵜⵡⴰⵣⵣⴻⵏⵣ ⵖⴰⵔⴻⴽ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵉⵅⴷⴻⵎ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⴰⵙ ⵜⵙⴰⵔⵔⵃⴻⴷ ⴰⴷ ⴰⵙ ⵜⴰⵔⵅⵓⴷ ⵣⵉ ⵖⴰⵔⴻⴽ ⵙ ⵜⵍⴻⵍⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("DT15_13","006_15_13","DEU","15","13","13","ⵅⵎⵉ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵜⵙⴰⵔⵔⵃⴻⴷ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵔⴰⵃ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT15_14","006_15_14","DEU","15","14","14","ⴰⵅⵎⵉ ⴷ ⴰⵙ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵙⴻⴷⴷⴻⵛⵜ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵣⴻⴳ ⵡⵓⴵⵉ ⵓ ⵣⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ ⵓ ⵣⵉ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ. ⵙ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⴷ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DT15_15","006_15_15","DEU","15","15","15","ⴰⴷ ⵜⵉⴷⴰⵔⴻⴷ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵙⵎⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⴼⴷⵉ ⵅⴰⴽ. ⵅ ⵓⵢⴰ, ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ ⴰⵙⵙ-ⴰ.    ");
INSERT INTO rift_vpl VALUES ("DT15_16","006_15_16","DEU","15","16","16","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵛ: ‘ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⴰⴳⴳⵯⵊⴻⵖ!’, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴻⵅⵙ ⵉ ⵛⴻⴽ ⴷ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵎⵍⵉⵃ ⵖⴰⵔⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("DT15_17","006_15_17","DEU","15","17","17","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵊⵊ ⵏ ⵓⵙⵉⵢⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⵓⵇⵇⴻⴱ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⴷ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵙ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT15_18","006_15_18","DEU","15","18","18","ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴱⵉⵏ ⵉⵇⵙⴻⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⵎⵉ ⵜ ⵖⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴷⵉ ⵜⵍⴻⵍⵍⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵛⴻⴽ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵢⴰⵔⴻⴱⴱⴻⵃ ⵉ ⵛⴻⴽ ⵍⴻⵅⵍⴰⵚ ⵏ ⵉⵊⵊ ⵏ ⵓⵛⴻⵡⵡⴰⵍ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵛⴻⴽ ⵖⴰ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT15_19","006_15_19","DEU","15","19","19","“ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵊⴰⵔ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵙⵙⵅⴻⴷⵎⴻⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⵎⴻⵏⵣⵓ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜ ⵜⵜⴻⴵⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT15_20","006_15_20","DEU","15","20","20","ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛⴻⴷ, ⵛⴻⴽ ⴷ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT15_21","006_15_21","DEU","15","21","21","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⵄⵉⴱ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵇⵉⴷⴰⵔ ⵏⵉⵖ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⵏⵉⵖ ⵎⵉⵏ ⵎⴰ ⵍⵄⵉⴱ ⴰⵄⴻⴼⴼⴰⵏ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵡⴰⵔ ⴷ ⴰⵙ ⵖⴰⵔⵔⴻⵚ ⵛⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT15_22","006_15_22","DEU","15","22","22","ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⴷ, ⴰⵎ ⵓⵎⴻⵅⵎⵓⵊ ⴰⵎ ⵓⵎⴻⵣⴷⴰⴳ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜⴻⵛⵛⴻⴷ ⵣⴻⴳ ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⵓ ⵣⴻⴳ ⵓⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DT15_23","006_15_23","DEU","15","23","23","ⵎⵖⵉⵔ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜᵉⵜⵜ ⵛⴰ, ⴰⴷ ⵜⴻⵏ ⵜⴼⴰⵔⵔⵖⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT16_1","006_16_1","DEU","16","1","1","“ⵃⴹⴰ ⴰⵢⵓⵔ ⵏ ⴰⴱⵉⴱ, ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⴰⴱⵉⴱ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ ⵛⴻⴽ-ⴷⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT16_2","006_16_2","DEU","16","2","2","ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT16_3","006_16_3","DEU","16","3","3","ⵡⴰⵔ ⴽⵉⵙ ⵜⵜᵉⵜⵜ ⵛⴰ ⵙ ⵡⴻⵏⵜⵓⵏ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴽⵉⵙ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⴰⵖⵔⵓⵎ ⵏ ⵜⴰⵎⴰⵔⴰ, ⵎⵉⵏⵣⵉ ⴷⴻⵖⵢⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⵇⵍⴻⴷ ⵅ ⵡⴰⵙⵙ ⵉ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT16_4","006_16_4","DEU","16","4","4","ⵡⴰⵔ ⴽⵉⴽ ⵉⵜⵜⴻⵎⵥⴰⵔ ⵡⴻⵏⵜⵓⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵀⴻⵜ ⵏⵏⴻⵛ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⵉ ⵉ ⵜⵖⴰⵔⵚⴻⴷ ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵏ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵡⴰⵔ ⵉⵜⵜⵏⵓⵙⵉ ⵛⴰ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT16_5","006_16_5","DEU","16","5","5","ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵜⵖⴰⵔⵚⵟ ⵏ ⵓⵙⴻⵄⴷⵓ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵢⴻⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT16_6","006_16_6","DEU","16","6","6","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⵉⵣⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴷⵉⵏ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵅⵎⵉ ⵖⴰ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⴷⵉ ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT16_7","006_16_7","DEU","16","7","7","ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴻⵏⴳⵯⴻⴷ ⴰⴷ ⵜⵜ ⵜⴻⵛⵛⴻⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⵄⴻⵇⴱⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT16_8","006_16_8","DEU","16","8","8","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("DT16_9","006_16_9","DEU","16","9","9","“ⴰⴷ ⵜⵃⴻⵙⴱⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⵣⴻⴳ ⵡⴰⵎⵉ ⵉ ⵖⴰ ⵜⴻⴱⴷⵉⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎⵊⴰⵔ ⴷⴻⴳ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ, ⴰⴷ ⵜⴻⴱⴷⵉⴷ ⴰⴷ ⵜⵃⴻⵙⴱⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵙⵉⵎⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("DT16_10","006_16_10","DEU","16","10","10","ⵅⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵄⵉⴷ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵉⵛⵜ ⵏ ⵚⵚⴻⴷⵇⴻⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT16_11","006_16_11","DEU","16","11","11","ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵛⴻⴽ, ⵎⵎⵉⵛ, ⵢⴻⴵⵉⵛ, ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⴰⵍⴰⵡⵉ ⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴰⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT16_12","006_16_12","DEU","16","12","12","ⴰⴷ ⵜⵄⴻⵇⵍⴻⴷ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵙⵎⴻⵖ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT16_13","006_16_13","DEU","16","13","13","“ⴰⴷ ⵜⵄⴻⵢⵢⴷⴻⴷ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵅⵎⵉ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴰⵙⵎⵓⵏⵉ ⵏ ⵚⵚⴰⴱⴻⵜ ⵏ ⵓⵏⴻⴷⵔⴰⵔ ⵏⵏⴻⵛ ⴷ ⵓⵥⴻⵎⵎⵉ ⵏ ⵜⵙⵉⵔⵜ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT16_14","006_16_14","DEU","16","14","14","ⵓⵛⴰ ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⴷⵉ ⵍⵄⵉⴷ ⵏⵏⴻⵛ, ⵛⴻⴽ, ⵎⵎⵉⵛ, ⵢⴻⴵⵉⵛ, ⵉⵙⵎⴻⵖ ⵏⵏⴻⵛ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⴰⵍⴰⵡⵉ, ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴰⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT16_15","006_16_15","DEU","16","15","15","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵄⴻⵢⵢⴷⴻⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ!” ");
INSERT INTO rift_vpl VALUES ("DT16_16","006_16_16","DEU","16","16","16","“ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴷ ⴷⴷ-ⴱⴰⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ: ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ, ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ. ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴱⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT16_17","006_16_17","DEU","16","17","17","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⵡⵛ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⵏⴻⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT16_18","006_16_18","DEU","16","18","18","ⴰⴷ ⵜⴼⴰⵔⵏⴻⴷ ⵍⵇⵓⴹⴰⵜ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵛ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT16_19","006_16_19","DEU","16","19","19","ⵡⴰⵔ ⵜⵜⴻⴼⴼⴻⵖ ⵛⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵅⵎⵉ ⵖⴰ ⵜⵃⴻⴽⵎⴻⴷ. ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⴼ ⵛⴰ ⴰⵔⵔⴻⵛⵡⴻⵜ, ⵎⵉⵏⵣⵉ ⴰⵔⵔⴻⵛⵡⴻⵜ ⵜⴻⵙⵙⴷⴰⵔⵖⴰⵍ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵓ ⵜⴻⵙⵙⴼⴰⵔⵔⴰⵖ ⴰⵡⴰⵍⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("DT16_20","006_16_20","DEU","16","20","20","ⵜⴰⵙⴻⴳⴷⴰ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵜⴻⴹⴼⴰⵔⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵡⴰⵔⵜⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT16_21","006_16_21","DEU","16","21","21","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵣⵉ ⵛⴰ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT16_22","006_16_22","DEU","16","22","22","ⵡⴰⵔ ⵙⵙⴳⴻⵄⵄⴰⴷ ⴰⵎⴻⵢⴹⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵛⴰⵔⵔⴻⵀ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT17_1","006_17_1","DEU","17","1","1","“ⵡⴰⵔ ⵖⴰⵔⵔⴻⵚ ⵛⴰ ⵉ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵉ ⴷⵉ ⵉⴵⴰ ⵛⴰ ⵏ ⵍⵄⵉⴱ, ⵏⵉⵖ ⵛⴰ ⵏ ⵍⵎⴰⵍ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT17_2","006_17_2","DEU","17","2","2","ⵓⵎⵉ ⵢⵓⴼⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵉⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵄⴻⴷⴷⵓ ⵅ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT17_3","006_17_3","DEU","17","3","3","ⵓⵛⴰ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴰⴷ ⵉⵄⴱⴻⴷ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⴱⴻⵏⴷⴻⵇ, ⵉ ⵜⴼⵓⵛⵜ ⵏⵉⵖ ⵉ ⵢⵓⵢⵓⵔ ⵏⵉⵖ ⵉ ⵎⴰⵔⵔⴰ ⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⵉⵏ ⵡⴰⵔ ⵅⴻⴼ ⵓⵎⵓⵔⴻⵖ ⵏⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("DT17_4","006_17_4","DEU","17","4","4","ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵉ ⵛⴻⴽ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ ⵓⵛⴰ ⵜⴻⵙⵍⵉⴷ ⵜⵜ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜ ⵜⴰⵔⵣⵓⴷ ⵎⵍⵉⵃ, ⵓ ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵜⴱⴰⵏ ⴱⴻⵍⵍⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵜⴰⵏⵉⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("DT17_5","006_17_5","DEU","17","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉ ⵉⴳⴳⵉⵏ ⵍⵖⴰⵔ-ⴰ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵃⴻⵊⵊⴰⵔⴻⴷ ⵙ ⵉⵥⵔⴰ ⴰⵍ ⵖⴰ ⵎⵎⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT17_6","006_17_6","DEU","17","6","6","“ⵅ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵙ ⵍⵎⴻⵡⵜ. ⵅ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT17_7","006_17_7","DEU","17","7","7","ⴰⴼⵓⵙ ⵏ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵅⴰⵙ ⵡⴹⴰⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵅⴰⵙ ⵡⴹⴰⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT17_8","006_17_8","DEU","17","8","8","“ⵅⵎⵉ ⵅⴰⴽ ⵖⴰ ⵜⴻⵇⵙⴻⵃ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷⵉ ⵍⵃⵓⴽⵎ ⵊⴰⵔ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵊⴰⵔ ⴷⴷⴻⵄⵡⴻⵜ ⴷ ⴷⴷⴻⵄⵡⴻⵜ, ⵊⴰⵔ ⵜⵉⵛⵜⵉ ⴷ ⵜⴻⵛⵜⵉ, ⵏⵉⵖ ⴷⵉ ⵍⵃⵓⴽⵎ ⴷⴻⴳ ⵉⵎⵛⵓⴱⴱⴰⵛ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ, ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT17_9","006_17_9","DEU","17","9","9","ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵖⴰⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵍⵇⴰⴹⵉ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵅ ⵍⴻⵃⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("DT17_10","006_17_10","DEU","17","10","10","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵜⴻⵏⴼⵓⵍⵜ ⵏⵏⵉ ⵉ ⵛⴻⴽ ⵖⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⴻⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("DT17_11","006_17_11","DEU","17","11","11","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵙⴻⵛⵛⵏⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵃⴽⴰⵎ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵏ. ⵡⴰⵔ ⵜⵜⵃⴻⵢⵢⵉⴷ ⵅ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵏ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("DT17_12","006_17_12","DEU","17","12","12","ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵜⵓⴼⴼⴻⵜ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⴻⵅⵅⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵏⵉⵖ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵖⴰⵔ ⵍⵇⴰⴹⵉ, ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT17_13","006_17_13","DEU","17","13","13","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵓ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵓ ⵡⴰⵔ ⵜⵜⵓⴼⴼⴻⵏ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT17_14","006_17_14","DEU","17","14","14","“ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⵖⴻⴷ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⴷ ⵅⴰⴼⵉ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ!’, ");
INSERT INTO rift_vpl VALUES ("DT17_15","006_17_15","DEU","17","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⴽ ⵜⴻⴳⴳⴻⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜⵎⴰⵛ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅⴰⴽ, ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⴻⴳⴳ ⵛⴰ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⴷ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("DT17_16","006_17_16","DEU","17","16","16","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵢⴰⵔⵏⵉ ⵉⵢⵙⴰⵏ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵜⵜⴰⵔⵔⵉ ⵛⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵏⵉ ⵉⵢⵙⴰⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵡⴻⵎ: ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⴷⴷ-ⵜⵄⵉⵇⵇⵉⴱⴻⵎ ⵄⴻⵎⵎⴰⵔⵚ ⵅ ⵡⴻⴱⵔⵉⴷ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("DT17_17","006_17_17","DEU","17","17","17","ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵛⴰ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵖⴰⵔⵔⵉ ⵡⵓⵍ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵢⴰⵔⴻⵏⵏⵉ ⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⵓⵔⴻⵖ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT17_18","006_17_18","DEU","17","18","18","ⵅⵎⵉ ⵖⴰ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵓⵄⴰⵡⴻⴷ ⵏ ⵜⵉⵔⴰ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT17_19","006_17_19","DEU","17","19","19","ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵄⴰⵡⴻⴷ ⵏ ⵜⵉⵔⴰ-ⵢⴰ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵎⴻⴷ ⴰⴷ ⵉⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵃⴹⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⴷ ⵜⵡⴻⵚⵚⴰ-ⵢⴰ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴳⴳ, ");
INSERT INTO rift_vpl VALUES ("DT17_20","006_17_20","DEU","17","20","20","ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵍⵉⵢ ⵓⵍ ⵏⵏⴻⵙ ⵅ ⵢⴰⵢⵜⵎⴰⵙ ⵏⵉⵖ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⵣⵓⴳⴰⵔⵜ ⵓⵙⵙⴰⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("DT18_1","006_18_1","DEU","18","1","1","“ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵉⵖ ⵍⵡⴰⵔⵜ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ. ⴰⴷ ⵛⵛⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵜⴻⵚⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT18_2","006_18_2","DEU","18","2","2","ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⴷ ⵍⵡⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜⵎⴰⵙ. ⵙⵉⴷⵉ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DT18_3","006_18_3","DEU","18","3","3","ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵃⴻⵇⵇ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⴳⴻⵏⵙ, ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵚⴻⴷⴷⵇⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ, ⵎⴰ ⴷ ⴰⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ: ⴰⴷ ⵡⵛⴻⵏ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴰⵎⴻⵚⵚⴰⴹⵜ ⵏ ⵣⵣⴰⵜ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵙⵎⵉⵔⴻⵏ ⴷ ⵜⴻⴽⵔⵉⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DT18_4","006_18_4","DEU","18","4","4","ⴰⵙⵓⴼⴼⵓⵖ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵚⵚⴰⴱⴻⵜ ⵏ ⵉⵔⴷⴻⵏ ⵏⵏⴻⵛ ⵓ ⵣⵉ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵏⵏⴻⵛ ⵓ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵛ ⵏ ⵟⵟⵔⵉ ⵓ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵡⴰⴵⴰⵙ ⵣⵉ ⵜⴰⴹⵓⴼⵜ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT18_5","006_18_5","DEU","18","5","5","ⵎⵉⵏⵣⵉ ⵢⵉⵅⴹⴰⵔ ⵉ-ⵜ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴽⴰⵔ, ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT18_6","006_18_6","DEU","18","6","6","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵍⴰⵡⵉ ⵣⴻⴳ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵙ ⵎⴰⵔⵔⴰ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ");
INSERT INTO rift_vpl VALUES ("DT18_7","006_18_7","DEU","18","7","7","ⵓⵛⴰ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⵉⵏⵏⵉ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("DT18_8","006_18_8","DEU","18","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⵛⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵙⵖⴰⵔⵜ ⴰⵏⴻⵛⵜ ⵏ ⵡⴰⵢⴰⵡⵢⴰ, ⴱⴰⵔⵔⴰ ⵉ ⵜⵜⴰⵎⴰⵏ ⵏ ⵎⵉⵏ ⵉⵎⵎⴻⵏⵣⴻⵏ ⵣⴻⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵚⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵏⴻⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT18_9","006_18_9","DEU","18","9","9","“ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵢⴻⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵙⵙⴻⵍⵎⴰⴷ ⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⴳⵏⵓⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT18_10","006_18_10","DEU","18","10","10","ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼⴼⵉ ⵃⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵄⴷⵓⵏ ⵎⵎⵉⵙ ⵏⵉⵖ ⵢⴻⴵⵉⵙ ⵅ ⵜⵎⴻⵙⵙⵉ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⵣⵣⴻⵎ, ⵏⵉⵖ ⴰⴱⴻⵣⴳⴰⵡ, ⵏⵉⵖ ⴰⵎⴻⴳⵣⵓ, ⵏⵉⵖ ⴰⵙⴻⵃⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("DT18_11","006_18_11","DEU","18","11","11","ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵔⴰ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴳⴻⵣⵣⴰⵏ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵛⵛⵡⴰⵔ ⵣⴻⴳ ⵉⵎⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT18_12","006_18_12","DEU","18","12","12","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴽⴽⴻⵙ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT18_13","006_18_13","DEU","18","13","13","ⵎⴰⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⴷⴷⵓⴷ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT18_14","006_18_14","DEU","18","14","14","ⵎⵉⵏⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⵡⴰⵔⵜⴻⴷ ⵙ ⵓⵖⵉⵍ, ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵉⴱⴻⵣⴳⴰⵡⴻⵏ ⴷ ⵉⵄⴻⵣⵣⴰⵎⴻⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ, ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵙⴻⵎⵎⴻⵃ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT18_15","006_18_15","DEU","18","15","15","“ⴰⴷ ⴰⵛ ⵉⴳⴳ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⵣⴻⴳ ⴰⵢⵜⵎⴰⵛ, ⴰⵎ ⵏⴻⵛⵛ, ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT18_16","006_18_16","DEU","18","16","16","ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵃⵓⵔⵉⴱ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⴷⴷ-ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⵙⵍⴻⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓⵛⴰ ⵡⴰⵔ ⵥⴰⵔⵔⴻⵖ ⵏⴻⵛⵛ ⵄⴰⴷ ⵜⵉⵎⴻⵙⵙⵉ-ⵢⴰ ⵉⵎⵖⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵖ.’ ");
INSERT INTO rift_vpl VALUES ("DT18_17","006_18_17","DEU","18","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⴰⵇⴰ ⴳⴳⵉⵏ ⵎⵍⵉⵃ ⵓⵎⵉ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ.’ ");
INSERT INTO rift_vpl VALUES ("DT18_18","006_18_18","DEU","18","18","18","ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵎ ⵛⴻⴽ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵙ ⵡⴻⵚⵚⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("DT18_19","006_18_19","DEU","18","19","19","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵍⴻⵃⵙⴰⴱ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT18_20","006_18_20","DEU","18","20","20","ⵎⴰⵛⴰ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵓⴼⴼⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵓⵎⵓⵔⴻⵖ ⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT18_21","006_18_21","DEU","18","21","21","ⵎⴰⵍⴰ ⵜⴻⵇⵇⴰⵔⴻⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ: ‘ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵏⴻⴳⴳ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵡⴰⵍ ⵏⵏⵉ?’, ");
INSERT INTO rift_vpl VALUES ("DT18_22","006_18_22","DEU","18","22","22","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⵅⵎⵉ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵓ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ, ⴰⵇⴰ ⴰⵡⴰⵍ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵣⵉ ⵖⴰⵔ ⵙⵉⴷⵉ. ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵓⵄⴻⴼⴼⴰⵔ. ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT19_1","006_19_1","DEU","19","1","1","“ⵅⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵖⴰ ⵉⵜⴻⵃⵃⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT19_2","006_19_2","DEU","19","2","2","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⴰⴷ ⵜⵃⵓⵣⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT19_3","006_19_3","DEU","19","3","3","ⴰⴷ ⵜⵄⴻⴷⵍⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ, ⴰⴷ ⵜⵜ ⵜⴻⴱⴹⵉⴷ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴽⵓⵍ ⴰⵇⴻⵜⵜⴰⵍ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DT19_4","006_19_4","DEU","19","4","4","ⴷ ⵡⴰ ⴷ ⴰⵎⵜⴰⵡⵉ ⵉ ⵣⵉ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵇⴻⵜⵜⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵢⴰⵔⵡⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ: ⵎⴰⵍⴰ ⵉⵏⵖⴰ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ, ⵓ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜ ⵉⵛⴰⵔⵔⴻⵀ ⵛⴰ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("DT19_5","006_19_5","DEU","19","5","5","“ⵡⴻⵏⵏⵉ ⵉⵔⵓⵃⴻⵏ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⵙⵙ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵙ ⵛⵛⴰⵇⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴰⵔⵡⴻⵛ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⴰⵙ ⵡⵓⵣⵣⴰⵍ ⵏ ⵛⵛⴰⵇⵓⵔ ⵓⵛⴰ ⵉⵍⵇⴻⴼ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵎⵎⵓⵜ, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵉⵛⵜⴻⵏ ⵣⵉ ⵏ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT19_6","006_19_6","DEU","19","6","6","ⴰⵎⵎⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵅⵎⵉ ⵖⴰ ⵉⵖⴻⵍⵖⴻⵍ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴹⴼⴰⵔ ⴰⵇⴻⵜⵜⴰⵍ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵃⴰⵔⵜ, ⵎⴰⵍⴰ ⴰⴱⵔⵉⴷ ⴷ ⴰⵣⵉⵔⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵏⴻⵖ ⴰⵎ ⵡⴰⵔ ⵅⴰⵙ ⵉⴵⵉ ⵍⴻⵃⴽⴰⵎ ⵙ ⵍⵎⴻⵡⵜ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜ ⵉⵛⴰⵔⵔⴻⵀ, ⵡⴰⵔ ⵉⴵⵉ ⵉⴹⴻⵏⵏⴰⴹ ⵓⵍⴰ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("DT19_7","006_19_7","DEU","19","7","7","ⵅ ⵓⵢⴰ ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ, ⵇⵇⴰⵔⴻⵖ: ‘ⵃⵓⵣ ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("DT19_8","006_19_8","DEU","19","8","8","ⵓⵛⴰ ⵎⴰⵍⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴰⴷ ⵉⵡⴻⵙⵙⴻⵄ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵓ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵅ ⵉⵏⵏⴰ ⴰⴷ ⵜⵜ ⵉⵡⵛ ⵉ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT19_9","006_19_9","DEU","19","9","9","- ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ - ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⵏⵉⴷ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵖⴰⵔ ⵜⵍⴰⵜⴰ-ⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("DT19_10","006_19_10","DEU","19","10","10","ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵢⵉⵍⵉ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("DT19_11","006_19_11","DEU","19","11","11","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵛⴰⵔⵀ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵇⴰⴱⴻⵍ ⵉ-ⵜ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵖⴰⵔⴻⵙ ⵓ ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵓⵛⴰ ⵉⵎⵎⵓⵜ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT19_12","006_19_12","DEU","19","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⴽⵙⵉⵏ ⵜ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT19_13","006_19_13","DEU","19","13","13","ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵣⵣⵉⴵⵉⵣ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵎⵃⵉⴷ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴳⴳⵉⵏ ⴷⴷⴻⵏⴱ ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("DT19_14","006_19_14","DEU","19","14","14","“ⵡⴰⵔ ⵙⵎⵓⵟⵟⵉⵢ ⴰⵢⵎⵉⵔ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵏⴻⵢⵢⵛⴻⵏ ⵍⴻⵊⵢⵓⵍ ⵏ ⵇⴱⴻⵍ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⵡⴰⵔⵜⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT19_15","006_19_15","DEU","19","15","15","ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵡⴰⵀⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴽⴽⴰⵔ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵅ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵛⴰ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵉⵖ ⴷⵉ ⵛⴰ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ. ⵅ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵅ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵟⵔⴰⵜⴰ ⵏ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DT19_16","006_19_16","DEU","19","16","16","ⵅⵎⵉ ⵖⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⴰⵇⵟⴰⵟⵄⵉⵢ ⵅ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵛⴻⵜⵛⴰ ⵅ ⵛⴰ ⵏ ⴷⴷⴻⵏⴱ, ");
INSERT INTO rift_vpl VALUES ("DT19_17","006_19_17","DEU","19","17","17","ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⵎⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⵉ ⵉ ⴷⵉⵏ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT19_18","006_19_18","DEU","19","18","18","ⵓⵛⴰ ⵍⵇⵓⴹⴰⵜ ⴰⴷ ⴰⵔⵣⵓⵏ ⵎⵍⵉⵀ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⵓ ⴰⵇⴰ, ⵎⴰⵍⴰ ⴰⵛⴻⵀⵀⴰⴷ ⴷ ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⴷ ⵉⵛⵀⴻⴷ ⵙ ⵍⴱⴰⵟⴻⵍ ⵅ ⵓⵎⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("DT19_19","006_19_19","DEU","19","19","19","ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴰⴷ ⵉⴳⴳ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵓⵎⴰⵙ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT19_20","006_19_20","DEU","19","20","20","ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵙⵍⴻⵏ, ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ, ⵡⴰⵔ ⴷⴷⵉⴽⴽⵯⵉⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT19_21","006_19_21","DEU","19","21","21","ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵣⵣⵉⴵⵉⵣ: ⵍⴻⵄⵎⴰⵔ ⵙ ⵍⴻⵄⵎⴰⵔ, ⵜⵉⵟⵟ ⵙ ⵜⵉⵟⵟ, ⵜⵉⵖⵎⴻⵙⵜ ⵙ ⵜⴻⵖⵎⴻⵙⵜ, ⴰⴼⵓⵙ ⵙ ⵓⴼⵓⵙ, ⴰⴹⴰⵔ ⵙ ⵓⴹⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("DT20_1","006_20_1","DEU","20","1","1","“ⵎⴰⵍⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⴻⵥⵔⵉⴷ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴽⵜⴰⵔ ⵣⵣⴰⵢⴻⴽ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵙ ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DT20_2","006_20_2","DEU","20","2","2","ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⵙⴻⵎ ⵉ ⵓⵎⴻⵏⵖⵉ, ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("DT20_3","006_20_3","DEU","20","3","3","ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵏⵉ: ‘ⵙⴻⵍ, ⵉⵙⵔⴰⵉⵍ, ⴽⴻⵏⵏⵉⵡ ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵙⵙⴻⵎⵥⴰⵢⴻⵎ ⵓⵍ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵏⵉⵖ ⴰⴷ ⵜⴰⵔⵊⵉⵊⴻⵎ, ⵏⵉⵖ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⵇⴻⴼⵇⵉⴼⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT20_4","006_20_4","DEU","20","4","4","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵓⵢⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵎⵎⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵏⵊⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("DT20_5","006_20_5","DEU","20","5","5","ⵓⵛⴰ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵡⵉ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵊⴷⵉⴷ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴷⵉⵖ ⵄⴰⴷ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵣⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT20_6","006_20_6","DEU","20","6","6","ⵡⵉ ⵢⴻⵥⵥⵓⵏ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵖⴻⴱⴱⵉ ⵄⴰⴷ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵖⴻⴱⴱⴰ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT20_7","006_20_7","DEU","20","7","7","ⵡⵉ ⵉⵅⴻⴹⴱⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵓ ⵡⴰⵔ ⵜⵜ ⵉⵎⵍⵉⵛ ⵄⴰⴷ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT20_8","006_20_8","DEU","20","8","8","ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴰⴷ ⴰⵔⵏⵉⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵡⵉ ⵉⴵⴰⵏ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⴰⴳⴳⵯⴰⴷ ⵏⵉⵖ ⵉⵜⵜⵖⴰⵛⴰ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⵖⵏⵉⵙⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏ ⴰⵢⵜⵎⴰⵙ ⴰⵎ ⵡⵓⵍ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("DT20_9","006_20_9","DEU","20","9","9","ⵅⵎⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("DT20_10","006_20_10","DEU","20","10","10","“ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⵙⴻⴷ ⵛⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵜⵍⴰⵖⵉⴷ ⵉ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("DT20_11","006_20_11","DEU","20","11","11","ⵎⴰⵍⴰ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴽ ⵙ ⵡⴻⵚⵍⴰⵃ, ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼ, ⴰⴷ ⵛⴻⴽ ⵉⵙⴻⵅⵅⴰⵔ ⵙ ⵓⵖⵉⵍ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵉⵅⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT20_12","006_20_12","DEU","20","12","12","ⵎⴰⵍⴰ ⵡⴰⵔ ⴽⵉⴽ ⵜⴻⴳⴳⵉ ⵍⴻⵀⵏⴰ, ⵎⴰⵛⴰ ⴷ ⴰⵎⴻⵏⵖⵉ ⵉ ⵜⴰⵔⴻⵣⵣⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵜⴻⵏⵏⴹⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT20_13","006_20_13","DEU","20","13","13","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵜⵜ ⵉⵡⵛ ⵉ ⵛⴻⴽ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ ⴷⴰⵢⴻⵙ, ⴰⴷ ⵜ ⵜⴻⵡⵜⴻⴷ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("DT20_14","006_20_14","DEU","20","14","14","ⵎⵖⵉⵔ ⵜⵉⵎⴻⵟⵟⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT20_15","006_20_15","DEU","20","15","15","ⴰⵎⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵅⴰⴽ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ, ⵜⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT20_16","006_20_16","DEU","20","16","16","ⵎⴰⵛⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⵊⵊⵉⴷ ⵓⵍⴰ ⴷ ⵛⴰ ⵎⵉⵏ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵏⵏⴻⴼⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT20_17","006_20_17","DEU","20","17","17","ⴰⴷ ⵜⴻⵏⵜ ⵜⵃⴰⵔⵔⵎⴻⴷ ⵉ ⵓⵜⴻⵃⵃⵉ: ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ, ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT20_18","006_20_18","DEU","20","18","18","ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵙⵙⵍⴻⵎⵎⴰⴷⴻⵏ ⴰⴷ ⵜⴻⴹⴼⴰⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵅⴹⴰⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT20_19","006_20_19","DEU","20","19","19","ⵎⴰⵍⴰ ⵜⴻⵏⵏⴹⴻⴷ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵍⴰⵎⵉ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴰⵔⴻⴷⴷⴰⴵ ⵛⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵙ ⵜⴻⵢⵢⵉⵜⴰ ⵏ ⵛⵛⴰⵇⵓⵔ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⵛⵛⴻⴷ. ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵇⴻⵙⵙⵉⴷ, ⵎⵉⵏⵣⵉ ⵎⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⵎ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓⵎⵉ ⵜⴻⵃⵚⴰⵔⴻⴷ ⵜⴰⵏⴷⵉⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("DT20_20","006_20_20","DEU","20","20","20","ⵎⵖⵉⵔ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏⵏⵉ ⵜⴻⵙⵙⵏⴻⴷ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉ ⵣⵉ ⵖⴰ ⵜⴻⵛⵛⴻⴷ, ⴰⵇⴰ ⵜⴰⵏⵉⵜⴰ ⴰⴷ ⵜⵜ ⵜⴰⵔⴻⴷⴵⴻⴷ, ⴰⴷ ⵜⵜ ⵜⵇⴻⵙⵙⴻⴷ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴱⵏⵉⴷ ⵉⵊⵊ ⵏ ⵙⵙⵓⵔ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ, ⴰⵍ ⵖⴰ ⵜⵖⴻⴹⵍⴻⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT21_1","006_21_1","DEU","21","1","1","“ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴼ ⵃⴻⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵍⵡⴰⵔⵜ, ⵉⵣⵣⴻⵍ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵃⴻⴷ ⵡⵉ ⵜ ⵉⵏⵖⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("DT21_2","006_21_2","DEU","21","2","2","ⵅⴻⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵛ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⵙⵉⵏ ⵍⴻⵄⴱⴰⵔ ⴰⵍ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT21_3","006_21_3","DEU","21","3","3","ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴽⵙⵉⵏ ⵢⴻⵎⵖⴰⵔⴻⵏ ⵉⵛⵜ ⵏ ⵜⵄⴻⵊⵎⵉⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵛⵔⵉⵣⴻⵏ ⵛⴰ ⵓ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵊⴱⵉⴷⴻⵏ ⵄⴰⴷ ⴰⵣⴰⵢⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("DT21_4","006_21_4","DEU","21","4","4","ⵓⵛⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴰⴷ ⵙⵙⴻⵀⵡⴰⵏ ⵜⴰⵄⴻⵊⵎⵉⵜ ⵏⵏⵉ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵉⵜⵜⴰⵣⵍⴻⵏ ⵍⴻⴱⴷⴰ ⵙ ⵡⴰⵎⴰⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵣ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵥⵥⵓ ⵓⵛⴰ ⴰⴷ ⴰⵔⵥⴻⵏ ⵉⵔⵉ ⵏ ⵜⵄⴻⵊⵎⵉⵜ ⴷⵉⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT21_5","006_21_5","DEU","21","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵅⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⴽⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵙⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⴽⵓⵍ ⴰⵎⵛⵓⴱⴱⴻⵛ ⴷ ⴽⵓⵍ ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT21_6","006_21_6","DEU","21","6","6","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵄⴻⵊⵎⵉⵜ ⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵔⵥ ⵢⵉⵔⵉ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT21_7","006_21_7","DEU","21","7","7","ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⵡⴰⵔ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ-ⴰ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⵡⴰⵔ ⵜ ⵥⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DT21_8","006_21_8","DEU","21","8","8","ⴻⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵜⴻⴼⴷⵉⴷ, ⴰ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵡⴰⵔ ⵙⵙⵔⵓⵙⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ!’ ⵅⴻⵏⵏⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ ⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵍⴻⴼⴷⵉⵢⵢⴻⵜ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT21_9","006_21_9","DEU","21","9","9","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴽⴽⵙⴻⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT21_10","006_21_10","DEU","21","10","10","“ⵅⵎⵉ ⵖⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⴳⴳⴰ ⴰⵛ ⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⵉⵢⴻⴷ ⵜⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("DT21_11","006_21_11","DEU","21","11","11","ⵓⵛⴰ ⵜⴻⵥⵔⵉⴷ ⵊⴰⵔ ⵉⵎⴻⵃⴱⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⴻⵛⵏⴰ ⴷⴻⴳ ⵡⴰⴷⴷⵓⴷ, ⵓⵛⴰ ⵜⴻⵎⵎⴻⵥⵔⴻⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT21_12","006_21_12","DEU","21","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⵃⴻⴼⴼ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵇⴻⵙⵙⴻⴷ ⵉⵛⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT21_13","006_21_13","DEU","21","13","13","ⴰⴷ ⵜⴻⴽⴽⴻⵙ ⴰⵔⵔⵓⴹ ⵏ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵖⵓⵢ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵉⴽⵎⴻⵍ ⵓ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵅⴰⵙ ⵜⴰⴷⴼⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT21_14","006_21_14","DEU","21","14","14","ⵓⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜⴻⵄⵊⵉⴱ, ⴰⴷ ⵜⵜ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜ ⵣⵏⵓⵣⵉ ⵙ ⵏⵏⵓⵇⴰⵔⵜ. ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵅⵎⵉ ⵙⵙⴻⵍⵄⴻⵜ ⵉ ⵜⴻⴵⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT21_15","006_21_15","DEU","21","15","15","“ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵉⵛⵜⴻⵏ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜⵜ, ⵜⴻⵏⵏⴻⵖⵏⵉⵜ ⵉⵛⴰⵔⵔⴻⵀ ⵉ-ⵜⵜ, ⵓⵛⴰ ⵜⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴻⵀ ⴷ ⵜⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙ ⵓⵔⵡⴻⵏⵜ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⴰⵛⴰ ⴰⵎⴻⵏⵣⵓ ⵜⵓⵖⴰ-ⵜ ⵏ ⵜⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴻⵀ, ");
INSERT INTO rift_vpl VALUES ("DT21_16","006_21_16","DEU","21","16","16","ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉ ⴷⵉ ⵖⴰ ⵉⴱⴹⴰ ⵍⵡⴰⵔⵜ ⵏ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵓⵎⴻⵏⵣⵓ ⵉ ⵎⵎⵉⵙ ⵏ ⵜⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵉⵡⵛ ⵉ ⵎⵎⵉⵙ ⵏ ⵜⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴻⵀ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵏⵣⵓ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("DT21_17","006_21_17","DEU","21","17","17","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵏⵄⴻⵎ ⵙ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ ⵏ ⵜⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴻⵀ ⵓⵎⵉ ⴷ ⴰⵙ ⵖⴰ ⵉⵡⵛ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵜⴻⵔⵢⴰⵙⵜ ⵏⵏⴻⵙ ⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏⵏⴻⵙ ⵉ ⵜⴻⴵⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT21_18","006_21_18","DEU","21","18","18","“ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⵎⵎⵉⵙ ⴷ ⴰⵖⴻⵏⵏⴰⵏ ⴷ ⴰⵎⵖⴻⵡⵡⴻⵖ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏⵜ ⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⴻⵙⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("DT21_19","006_21_19","DEU","21","19","19","ⵅⴻⵏⵏⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⴰⴷ ⵜ ⴽⵙⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⴱⴰⵔⵔⴰ ⵣⵣⴰⵜ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT21_20","006_21_20","DEU","21","20","20","ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ: ‘ⵡⴰ ⴷ ⵎⵎⵉⵜⵏⴻⵖ ⴷ ⴰⵖⴻⵏⵏⴰⵏ ⴷ ⴰⵎⵖⴻⵡⵡⴻⵖ, ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵖ, ⴰⵇⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵏⵏⵓⵇⵇⴻⴱ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵙⴽⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("DT21_21","006_21_21","DEU","21","21","21","ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵜ ⴰⵔⴻⵊⵎⴻⵏ ⴰⵍ ⵖⴰ ⵉⵎⵎⴻⵜ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⵙⴻⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT21_22","006_21_22","DEU","21","22","22","“ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵅ ⵉⴵⴰ ⵍⵃⵓⴽⵎ ⵏ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵏⴻⵖ, ⵜⵓⵢⵍⴻⴷ ⵉ-ⵜ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵃⵏⴰⵛⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ");
INSERT INTO rift_vpl VALUES ("DT21_23","006_21_23","DEU","21","23","23","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵙⵙⴻⵏⵙ ⵅ ⵜⴻⵃⵏⴰⵛⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵜⵏⴻⴹⵍⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵢⵍⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⵡⴰⵔ ⵙⵅⴻⵎⵎⴰⵊ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT22_1","006_22_1","DEU","22","1","1","“ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵡⴰⵀⴰ ⴷⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏⵉⵖ ⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵏ ⵓⵎⴰⵛ, ⵏⵉⵖ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵇⴻⵍⴱⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵛ ⵜⴻⵏ-ⵉ-ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⵏⵉⵛⴰⵏ ⵉ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("DT22_2","006_22_2","DEU","22","2","2","ⵎⴰⵍⴰ ⵓⵎⴰⵛ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵢⵓⴷⴻⵙ ⵏⵉⵖ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ, ⴰⴷ ⵜ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵇⵇⵉⵎ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵎⴰⵛ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵣⵓ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵜ-ⵉ-ⴷⴷ ⵜⴰⵔⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT22_3","006_22_3","DEU","22","3","3","ⴰⵎⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵙ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ, ⴰⵎⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵎⴰⵛ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵓⴼⵉⴷ ⵜⵜ ⵛⴻⴽ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⵙ ⵜⴻⵏⵏⵓⴼⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT22_4","006_22_4","DEU","22","4","4","ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴻⵖⵢⵓⵍ ⵏ ⵓⵎⴰⵛ ⵏⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ ⴰⵎ ⵡⴹⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵇⴻⴵⴻⴱ ⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⴽⴽⴰⵔⴻⴷ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DT22_5","006_22_5","DEU","22","5","5","“ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜⵢⴰⵔⵔⴻⴹ ⵎⵉⵏ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵡⴻⵔⵢⴰⵣ, ⵏⵉⵖ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜⵜ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT22_6","006_22_6","DEU","22","6","6","ⵎⴰⵍⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵅ ⵡⴻⴱⵔⵉⴷ ⵛⴰ ⵏ ⵍⵄⵓⵛⵛ ⵏ ⵡⴻⵊⴹⵉⴹ, ⴷⵉ ⵛⴰ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏⵉⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵙ ⵉⵡⴰⵔⵔⵓⴷⴻⵏ ⵏⵉⵖ ⵙ ⵜⵎⴻⴵⴰⵍⵉⵏ, ⵓⵛⴰ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵜⴻⵙⵙⴷⴻⵍ ⵅ ⵉⵡⴰⵔⵔⵓⴷⴻⵏ ⵏⵉⵖ ⵅ ⵜⵎⴻⴵⴰⵍⵉⵏ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⴼ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⴰⴽ-ⴷ ⵉⵡⴰⵔⵔⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT22_7","006_22_7","DEU","22","7","7","ⴰⴷ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵜⵓⵢⵓⵔ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵡⴰⵔⵔⵓⴷⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ, ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT22_8","006_22_8","DEU","22","8","8","ⵅⵎⵉ ⵖⴰ ⵜⴻⴱⵏⵉⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵊⴷⵉⴷ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵄⵎⴰⴷⵜ ⵅ ⵜⵣⴻⵇⵇⴰ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⴽⴽⵯⵉⴹⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT22_9","006_22_9","DEU","22","9","9","ⵡⴰⵔ ⵣⴰⵔⵔⴻⵄ ⵛⴰ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏⵏⴻⵛ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵎⴰⵔⴽⴰⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵉⵜ ⵎⴰⵔⵔⴰ ⵚⵚⴰⴱⴻⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⵉ ⵜⵣⴰⵔⵄⴻⴷ ⵓⵍⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT22_10","006_22_10","DEU","22","10","10","ⵡⴰⵔ ⵛⴰⵔⵔⴻⵣ ⵛⴰ ⵙ ⵓⴼⵓⵏⴰⵙ ⴷ ⵡⴻⵖⵢⵓⵍ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("DT22_11","006_22_11","DEU","22","11","11","ⵡⴰⵔ ⵢⴰⵔⵔⴻⴹ ⵛⴰ ⴰⵔⵔⵓⴹ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵣⵉ ⵜⵅⴻⴵⴻⴹⵜ ⵏ ⵜⴰⴹⵓⴼⵜ ⴷ ⵍⴻⵇⵟⴻⵏ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("DT22_12","006_22_12","DEU","22","12","12","ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵛⴰⵔⵛⵉⴼⴰ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵛ ⵉ ⵣⵉ ⵜⵍⴻⵃⵃⴼⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT22_13","006_22_13","DEU","22","13","13","“ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵉⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵅⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵉⵛⴰⵔⵀ, ");
INSERT INTO rift_vpl VALUES ("DT22_14","006_22_14","DEU","22","14","14","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵅⴰⵙ ⴰⵡⴰⵍⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵉⵏⵏⴰ: ‘ⴰⵇⴰ ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⵉⵡⵢⴻⵖ ⵜⵜ, ⵓⵛⴰ ⵓⵎⵉ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵇⴰⵔⵔⴱⴻⵖ, ⵉⵡⴹⴻⵖ ⴰⴷ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ!’, ");
INSERT INTO rift_vpl VALUES ("DT22_15","006_22_15","DEU","22","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵏⵏⵉ ⴷ ⵢⴻⵎⵎⴰⵙ ⵍⴱⵓⵔⵀⴰⵏⴰⵜ ⵏ ⵜⵖⵓⵏⵉ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵉ ⵢⴻⵎⵖⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DT22_16","006_22_16","DEU","22","16","16","ⴰⴷ ⵢⵉⵏⵉ ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵏⵏⵉ ⵉ ⵢⴻⵎⵖⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵢⴻⴵⵉ ⵉ ⵡⴻⵔⵢⴰⵣ-ⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⵉⵛⴰⵔⵀ ⵉ-ⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("DT22_17","006_22_17","DEU","22","17","17","ⵓⵛⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵅⴰⵙ ⴰⵡⴰⵍⴻⵏ, ⵉⵏⵏⴰ: ⵡⴰⵔ ⵓⴼⵉⵖ ⵖⴰⵔ ⵢⴻⴵⵉⵛ ⵍⴱⵓⵔⵀⴰⵏⴰⵜ ⵏ ⵜⵖⵓⵏⵉ ⵏ ⵜⴻⴱⵍⵉⵖⵜ. ⴰⵇⴰ ⴰⵢⴰ ⴷ ⵍⴱⵓⵔⵀⴰⵏⴰⵜ ⵏ ⵜⵖⵓⵏⵉ ⵏ ⵢⴻⴵⵉ!’ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⴰⵍⴻⵃⵃⴰⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DT22_18","006_22_18","DEU","22","18","18","ⵅⴻⵏⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⴼⴰⵔⵛⴻⵏ ");
INSERT INTO rift_vpl VALUES ("DT22_19","006_22_19","DEU","22","19","19","ⵓⵛⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵎⵓⵍⵜⴰ ⵏ ⵎⵢⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵡⵛⵉⵏ ⵉ ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵉⵙⴻⵎ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⴰⵙ ⵉⴵⴻⴼ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT22_20","006_22_20","DEU","22","20","20","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⴼⴼⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵡⴰⵔ ⵓⴼⵉⵏ ⵍⴱⵓⵔⵀⴰⵏⴰⵜ ⵏ ⵜⵖⵓⵏⵉ ⵖⴰⵔ ⵜⴻⴱⵍⵉⵖⵜ, ");
INSERT INTO rift_vpl VALUES ("DT22_21","006_22_21","DEU","22","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴰⴱⵍⵉⵖⵜ ⵏⵏⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⴰⵔⴻⵊⵎⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⵍ ⵖⴰ ⵜⴻⵎⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵜⴻⵙⵙⴻⴼⴹⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT22_22","006_22_22","DEU","22","22","22","“ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵎⵉ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵄⴰⵡⴻⴷ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT22_23","006_22_23","DEU","22","23","23","ⵎⴰⵍⴰ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵜᵉⵜⵜⵡⴰⵅⴹⴻⴱ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜⵜ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT22_24","006_22_24","DEU","22","24","24","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⵎ ⴱⴰⵔⵔⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜⵜⵡⴰⵔⴻⵊⵎⴻⵏ ⴰⵍ ⵖⴰ ⵎⵎⵜⴻⵏ ⵏⵉⵜⵏⵉ: ⵜⴰⴱⵍⵉⵖⵜ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⴻⴽⴽⴰⵔ ⵛⴰ ⵜⵖⵓⵢⵢⵉⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⵔⵢⴰⵣ ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT22_25","006_22_25","DEU","22","25","25","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵓⴼⴰ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵉⵜⵜⵡⴰⵅⴻⴹⴱⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵉ-ⵜⵜ ⵡⴻⵔⵢⴰⵣ, ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵀⴰ, ⵡⴻⵏⵏⵉ ⴽⵉⵙ ⵉⵟⵟⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT22_26","006_22_26","DEU","22","26","26","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵡⴰⵍⵓ ⵉ ⵜⴻⴱⵍⵉⵖⵜ. ⵜⴰⴱⵍⵉⵖⵜ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⵛⴰ ⴷⴷⴻⵏⴱ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⴰⵎ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴽⴽⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ, ");
INSERT INTO rift_vpl VALUES ("DT22_27","006_22_27","DEU","22","27","27","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⵓⴼⵉ ⵜⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵜⴻⵙⵖⵓⵢ ⵜⴻⴱⵍⵉⵖⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⴹⴱⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT22_28","006_22_28","DEU","22","28","28","ⵅⵎⵉ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵓⴼⴰ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵡⴰⵔ ⵜⵜ ⵉⵅⴹⵉⴱ ⵃⴻⴷ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ, ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵜⵜⵡⴰⴼⴻⵏ ⵏⵉⵜⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT22_29","006_22_29","DEU","22","29","29","ⵅⴻⵏⵏⵉ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵟⵟⵚⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴰⴷ ⵉⵡⵛ ⵉ ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵅⴻⵎⵙⵉⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵜⵜ ⵉⵙⵙⴻⵃⵇⴰⵔ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⴵⴻⴼ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT22_30","006_22_30","DEU","22","30","30","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⴽⵙⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵓ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵙⵙⵄⴰⵔⵔⴰ ⵅ ⵡⴰⴼⵔⵉⵡ ⵉⵜⵜⵙⴰⵔⵔⴰⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⴱⴰⴱⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("DT23_1","006_23_1","DEU","23","1","1","“ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴻⵇⴼⴻⵏ, ⵓⵎⵉ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵉⵎⴻⴵⴰⵍⴻⵏ ⵏⵉⵖ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵉⵎⴻⵏⵢⴰⵔⴻⵏ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT23_2","006_23_2","DEU","23","2","2","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵎⵎⵉⵙ ⵏ ⵍⴻⵃⵔⴰⵎ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ. ⵄⴰⴷ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT23_3","006_23_3","DEU","23","3","3","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵢⵉⵊⵊⴻⵏ ⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵏⵉⵖ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱⵉ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ. ⵡⴰⵅⵅⴰ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏⵏⴻⵙ ⵄⴰⴷ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("DT23_4","006_23_4","DEU","23","4","4","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵎⵙⴰⴳⴰⵔⴻⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷ ⵡⴰⵎⴰⵏ ⵓⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵅⴰⴽ ⵉⵛⵔⴰ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⵣⵉ ⴼⴰⵜⵓⵔ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵔⴰⵎ-ⵏⴰⵀⵔⴰⵢⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵉⵏⵄⴻⵍ.    ");
INSERT INTO rift_vpl VALUES ("DT23_5","006_23_5","DEU","23","5","5","ⵎⴰⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⴱⴰⵍⵄⴰⵎ ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵢⴰⵔⵔⴰ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵍⴱⴰⵔⴰⴽⴰ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DT23_6","006_23_6","DEU","23","6","6","ⵡⴰⵔ ⵜⴰⵔⴻⵣⵣⵓ ⵅ ⵍⴻⵀⵏⴰ ⵏⵙⴻⵏ ⴷ ⵍⵅⴰⵔ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("DT23_7","006_23_7","DEU","23","7","7","ⵡⴰⵔ ⵛⴰⵔⵔⴻⵀ ⴰⴷⵓⵎⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰⵛ, ⵡⴰⵔ ⵛⴰⵔⵔⴻⵀ ⴰⵎⵉⵚⵔⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT23_8","006_23_8","DEU","23","8","8","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⵉⵄⴻⴷⴷⴻⵍ ⴰⵙⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT23_9","006_23_9","DEU","23","9","9","“ⵓⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵙ ⵍⵄⴻⵙⴽⴰⵔ ⴹⵉⴷⴷ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT23_10","006_23_10","DEU","23","10","10","ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴽⵉⴷⴻⴽ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵙ ⴵⵉⵍⴻⵜ, ⴰⴷ ⵉⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵍⵎⴰⵔⴳⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("DT23_11","006_23_11","DEU","23","11","11","ⵖⴰⵔ ⵓⵡⴻⵟⵟⵓ ⵏ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵖⴻⴵⴰⵢ ⵏ ⵜⴼⵓⵛⵜ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴷⴻⴼ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("DT23_12","006_23_12","DEU","23","12","12","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵡⴻⵎⵛⴰⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⴼⴼⵖⴻⴷ ⴷⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT23_13","006_23_13","DEU","23","13","13","ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ ⵊⴰⵔ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵓⵊⵉⵊ ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴱⴰⵔⵔⴰ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵅⴻⴱⵛⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵃⴼⵓⵔ, ⴰⴷ ⵜⴻⵏⵇⴻⵍⴱⴻⴷ ⵓ ⴰⴷ ⵜⵅⴻⵎⵎⵍⴻⴷ ⵉⵙⵓⴼⴼⵖⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT23_14","006_23_14","DEU","23","14","14","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⴳⴳⵓⵔ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏⵏⴻⵛ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⴼⴻⴽⴽ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⵙⴻⵍⵍⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵜⴰⵙⵇⵉⴼⵜ ⵏⵏⴻⵛ ⴰⵜ ⵜⵉⵍⵉ ⵜⵇⴻⴷⴷⴻⵙ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵡⵉⵍⵉ ⵛⴰ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵉⵏⵏⴻⵇⵍⴻⴱ ⴰⵡⴰⵔⵏⵉ ⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT23_15","006_23_15","DEU","23","15","15","“ⵉⵙⵎⴻⵖ ⵉ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜ ⵜⵙⴻⵍⵍⵎⴻⴷ ⵄⴰⵡⴻⴷ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT23_16","006_23_16","DEU","23","16","16","ⴰⴷ ⴽⵉⴽ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉ ⵢⵉⵛⵜ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⵎⴰⵏⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⵍⵉⵃ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜ ⵜⴹⴻⵍⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT23_17","006_23_17","DEU","23","17","17","ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵊⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵍⵉ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT23_18","006_23_18","DEU","23","18","18","ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵢⴻⴳⴳⴰ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵉ ⵓⵢⴰ ⵍⵎⵓⵏⴻⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵉⵖ ⵜⵜⴰⵎⴰⵏ ⵏ ⵡⴻⵇⵣⵉⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT23_19","006_23_19","DEU","23","19","19","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴰⵔⵔⵉⴱⴰ ⵅ ⵓⵎⴰⵛ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⵔⵉⴱⴰ ⵅ ⵏⵏⵓⵇⴰⵔⵜ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⵔⵉⴱⴰ ⵅ ⵎⴰⵛⵛⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⵔⵉⴱⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵉ ⴰⵔⵔⵉⴱⴰ.    ");
INSERT INTO rift_vpl VALUES ("DT23_20","006_23_20","DEU","23","20","20","ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⵔⵉⴱⴰ ⵅ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵔⵔⵉⴱⴰ ⵅ ⵓⵎⴰⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT23_21","006_23_21","DEU","23","21","21","ⵅⵎⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⴻⴷⴷⵉⴽⴽⵡⵉⵍⴻⴷ ⵛⴰ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴽⴻⵎⵎⵍⴻⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⴰⵔ ⴰⴷ ⵜ ⵜⴽⴻⵎⵎⵍⴻⴷ, ⵎⴰⵍⴰ ⵍⵍⴰ ⴰⴷ ⵅⴰⴽ ⵢⵉⵍⵉ ⴷ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("DT23_22","006_23_22","DEU","23","22","22","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴳⴳⵉⴷ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ, ⵡⴰⵔ ⵅⴰⴽ ⵉⵜⵜⵉⵍⵉ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("DT23_23","006_23_23","DEU","23","23","23","ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵊⴰⵔ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵍⵡⴰⵄⴷ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵏⵉ ⵣⵉ ⵜⵡⴰⵄⴷⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓ ⵡⴻⵏⵏⵉ ⵅ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT23_24","006_23_24","DEU","23","24","24","ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵓⵎⵇⴰⵔⵔⴰⴱ ⵏⵏⴻⵛ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⴹⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴻⵥⵔⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵡⴰⵍⵓ ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT23_25","006_23_25","DEU","23","25","25","ⵎⴰⵍⴰ ⵜⵓⴷⴼⴻⴷ ⵖⴰⵔ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⵉⴷⵔⵉⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵡⵜⴻⴷ ⴰⵎⵊⴰⵔ ⴷⴻⴳ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT24_1","006_24_1","DEU","24","1","1","“ⵅⵎⵉ ⵖⴰ ⵢⴰⵡⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵉⵎⵍⴻⵛ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵄⵊⵉⴱ ⵓⵎⵉ ⴷⴰⵢⴻⵙ ⵢⵓⴼⴰ ⵛⴰ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵢⴰⵔⵉ ⵜⴰⴱⵔⴰⵜ ⵏ ⵡⴻⴵⴰⴼ, ⴰⴷ ⴰⵙ ⵜⵜ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⵓⴼⴻⵖ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT24_2","006_24_2","DEU","24","2","2","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴻⴼⴼⴻⵖ ⵏⴻⵜⵜⴰⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⵔⵓⵃ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT24_3","006_24_3","DEU","24","3","3","ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵉⵛⴰⵔⵀ ⵉ-ⵜⵜ, ⴰⴷ ⴰⵙ ⵢⴰⵔⵉ ⵜⴰⴱⵔⴰⵜ ⵏ ⵡⴻⴵⴰⴼ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⵜ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⴽⴽ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴰⵔⵢⴰⵣ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏⵏⵉ ⵉ-ⵜⵜ ⵢⵉⵡⵢⴻⵏ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵎⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("DT24_4","006_24_4","DEU","24","4","4","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵟⴻⵍⵍⵇⴻⵏ, ⴰⴷ ⵜⵜ ⵢⴻⴳⴳ ⵄⴰⵡⴻⴷ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵏⴻⵜⵜⴰⵜ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵉⴹ ⴷⴷⴻⵏⴱ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT24_5","006_24_5","DEU","24","5","5","“ⵅⵎⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵜⵓⵖⴰ ⴰⵎ ⵉⵎⵍⴻⵛ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵛⴰ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵡⴰⵀⴰ ⵓ ⴰⴷ ⵉⵙⵙⴼⴰⵔⵃ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵢⵉⵡⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DT24_6","006_24_6","DEU","24","6","6","“ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵥⵔⴰ ⵏ ⵜⵙⵉⵔⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⴰⴹⵎⴰⵏ, ⵏⵉⵖ ⴰⵥⵔⵓ ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⵡⴰⵀⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⴷ ⴰⴹⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT24_7","006_24_7","DEU","24","7","7","“ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴼ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵓⵛⴰⵔ ⵛⴰ ⵏ ⵢⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵙ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⴷ ⵉⵙⵎⴻⵖ ⵓⵛⴰ ⵉⵣⵣⴻⵏⵣ ⵉ-ⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵛⴻⴼⴼⴰⵔ ⵏⵏⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵍⵖⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT24_8","006_24_8","DEU","24","8","8","“ⵅⵎⵉ ⴷⵉⵏ ⵜⴻⴵⴰ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵍⴱⴰⵔⵚ, ⵃⴹⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵏⵉⵛⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT24_9","006_24_9","DEU","24","9","9","ⵉⴷⴰⵔ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴽ-ⴷ ⵎⴰⵔⵢⴰⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT24_10","006_24_10","DEU","24","10","10","“ⵎⴰⵍⴰ ⵜⴰⵔⴹⵍⴻⴷ ⵛⴰ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵉⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⵙⵉⴷ ⵛⴰ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT24_11","006_24_11","DEU","24","11","11","ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵉ ⵓⵎⵉ ⵜⴰⵔⴹⵍⴻⴷ ⴰⴷ ⴰⵛ ⴷⴷ-ⵢⴰⵡⵉ ⴷⴷⵉⵢⵢⴻⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT24_12","006_24_12","DEU","24","12","12","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵣⵍⵓⴹ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜᵉⵜⵜⵏⵓⵙⵉ ⴷⴻⴳ ⵡⴻⵔⵀⴰⵏ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵉ ⵢⴻⴵⴰ ⴷ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT24_13","006_24_13","DEU","24","13","13","ⴰⴷ ⴰⵙ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⴷⴷⵉⵢⵢⴻⵜ ⵏⵏⵉ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵓⵖⴻⴵⵉ ⵏ ⵜⴼⵓⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⵚ ⴷⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT24_14","006_24_14","DEU","24","14","14","“ⵡⴰⵔ ⵙⵃⵉⵙⵙⴼⴻⵎ ⴰⵛⴻⵡⵡⴰⵍ ⴰⵎⴻⵃⴷⴰⵊ ⴰⵎⴻⵣⵍⵓⴹ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵛ ⵏⵉⵖ ⵣⴻⴳ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵓ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT24_15","006_24_15","DEU","24","15","15","ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⴽⵓⵍ ⴰⵙⵙ. ⵡⴰⵔ ⵅⴰⵙ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵓⵛⴰ ⵉⵎⵎⴻⵥⵔⵉ ⴷⴰⵢⴻⵙ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵖⵉ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵢⵉⵍⵉ ⴷⴷⴻⵏⴱ.” ");
INSERT INTO rift_vpl VALUES ("DT24_16","006_24_16","DEU","24","16","16","“ⵉⴱⴰⴱⴰⵜⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DT24_17","006_24_17","DEU","24","17","17","“ⵡⴰⵔ ⵙⴼⴰⵔⵔⴰⵖ ⵍⴻⵃⴽⴰⵎ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷ ⵓⵢⵓⵊⵉⵍ ⵏⵉⵖ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⵔⵔⵓⴹ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⴷ ⴰⴹⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT24_18","006_24_18","DEU","24","18","18","ⴰⴷ ⵜⵄⴻⵇⵍⴻⴷ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵙⵎⴻⵖ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⴼⴷⵉ ⵛⴻⴽ ⵙⵙⴻⵏⵏⵉ. ⵅ ⵓⵢⴰ ⵏⴻⵛⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DT24_19","006_24_19","DEU","24","19","19","ⵅⵎⵉ ⵜⵎⴻⵊⵊⴰⵔⴻⴷ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜᵉⵜⵜⵓⴷ ⵛⴰ ⵏ ⵜⵇⴻⴱⴱⵉⴹⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜᵉⴷⴷⵉⴽⴽⵯⵉⵍⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵉ ⵓⵢⵓⵊⵉⵍ ⵓ ⵉ ⵜⴰⵊⵊⴰⵍⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT24_20","006_24_20","DEU","24","20","20","ⵅⵎⵉ ⵖⴰ ⵜⵥⴻⵡⴹⴻⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏⵏⴻⵛ ⵏ ⵣⵣⵉⵜⵓⵏ, ⵡⴰⵔ ⵜⵜⵉⵛ ⵜⴰⵢⵏⵉⵜ ⵄⴰⴷ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵉ ⵓⵢⵓⵊⵉⵍ ⵓ ⵉ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("DT24_21","006_24_21","DEU","24","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵍⴻⵇⴹⴻⴷ ⴰⴹⵉⵍ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ, ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜⵍⴻⵇⴹⴻⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⵄⴰⵡⴻⴷ. ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵉ ⵓⵢⵓⵊⵉⵍ ⵓ ⵉ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("DT24_22","006_24_22","DEU","24","22","22","ⴰⴷ ⵜⵄⴻⵇⵍⴻⴷ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵙⵎⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵅ ⵓⵢⴰ ⵏⴻⵛⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT25_1","006_25_1","DEU","25","1","1","“ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵊⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵃⴽⴰⵎⴰ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴻⴽⵎⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵅ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⵃⴻⵇⵇ ⵓⵛⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵅ ⵓⵎⴻⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("DT25_2","006_25_2","DEU","25","2","2","ⵎⴰⵍⴰ ⴰⵎⴻⴷⵏⵓⴱ ⵉⵙⵙⴷⴰⵀⴻⴵ ⵜⵉⵢⵢⵉⵜⴰ, ⵅⴻⵏⵏⵉ ⵍⵇⴰⴹⵉ ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵜ ⵖⴻⴹⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⴼⴰⵔⵛⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴰⵏⴻⵛⵜ ⵉⵜⵜⵓⵔⵙ ⴷⵉ ⵍⴻⵃⵙⴰⴱ ⵏ ⵍⵖⴻⵛⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT25_3","006_25_3","DEU","25","3","3","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⴻⵢⵢⵉⵜⴰ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏⵜ ⵢⴰⵔⴻⵏⵏⵉ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴰⴷ ⵜ ⵉⴼⴰⵔⵛ ⵄⴰⴷ ⴽⵜⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵉⵢⵢⵉⵜⴰ-ⵢⴰ, ⴰⵇⴰ ⵓⵎⴰⵛ ⴰⴷ ⴰⵛ ⴷⴷ-ⵉⴱⴰⵏ ⴷ ⴰⵎⴻⵃⴳⵓⵔ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT25_4","006_25_4","DEU","25","4","4","“ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵜⴰⵛⵎⴰⵏⵜ ⵉ ⵓⴼⵓⵏⴰⵙ ⵅⵎⵉ ⵉⵙⵙⴰⵔⵡⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT25_5","006_25_5","DEU","25","5","5","“ⵅⵎⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ, ⵓⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵢⴻⵊⵊⵉ ⵛⴰ ⵎⵎⵉⵙ, ⵅⴻⵏⵏⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵡⴰⵔ ⵜⵎⴻⴵⴻⵛ ⵛⴰ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴱⴰⵔⵔⴰ ⴼⴰⵎⵉⵍⵉⵢⴰ ⵏⵏⴻⵙ. ⴰⴷ ⵅⴰⵙ ⵢⴰⴷⴻⴼ ⵡⴰⵍⴻⵡⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵢⴻⴳⴳ ⵅⴻⵏⵏⵉ ⵍⵡⴰⵊⵉⴱ ⵏ ⵡⴰⵍⴻⵡⵙ.    ");
INSERT INTO rift_vpl VALUES ("DT25_6","006_25_6","DEU","25","6","6","ⵓⵛⴰ ⴰⵎⴻⵏⵣⵓ ⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵓⵡ, ⴰⴷ ⵉⵅⵍⴻⴼ ⵉⵙⴻⵎ ⵏ ⵓⵎⴰⵙ ⵉⵎⵎⵓⵜⴻⵏ, ⵃⵉⵎⴰ ⵉⵙⴻⵎ ⵏ ⵡⴰ ⵡⴰⵔ ⵉⵎⴻⵃⵃⵉ ⵛⴰ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT25_7","006_25_7","DEU","25","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⴽⵙⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵙ, ⴰⴷ ⵜⵍⴰⵀ ⵅⴻⵏⵏⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵙ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⵖⴰⵔ ⵉⵎⵖⴰⵔⴻⵏ, ⴰⴷ ⵜⵉⵏⵉ: ‘ⴰⵍⴻⵡⵙ ⵉⵏⵓ ⵢⵓⴳⵉ ⴰⴷ ⵉⵅⵍⴻⴼ ⵉⵙⴻⵎ ⵏ ⵓⵎⴰⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⴳⴳ ⵍⵡⴰⵊⵉⴱ ⵏ ⵡⴰⵍⴻⵡⵙ.’ ");
INSERT INTO rift_vpl VALUES ("DT25_8","006_25_8","DEU","25","8","8","ⵅⴻⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴰⴷ ⴰⵙ ⴷⴷ-ⵍⴰⵖⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⴽⵉⴷⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵏⴻⵄ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵏⴰ: ‘ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⵜⵜ ⴰⵡⵢⴻⵖ!’, ");
INSERT INTO rift_vpl VALUES ("DT25_9","006_25_9","DEU","25","9","9","ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⵇⴰⵔⵔⴻⴱ ⵅⴻⵏⵏⵉ ⵜⴰⵍⴻⵡⵙⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⴰⴷ ⴰⵙ ⵜⴻⴽⴽⴻⵙ ⵙⴰⵏⴷⴰⵍⴰ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴹⴰⵔ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⵙⵙⵓⵙⴻⴼ ⵅ ⵓⵖⴻⵎⴱⵓⴱ, ⴰⴷ ⵜⴱⴰⵔⵔⴻⵃ, ⴰⴷ ⵜⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⴳⴳ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵙ!’ ");
INSERT INTO rift_vpl VALUES ("DT25_10","006_25_10","DEU","25","10","10","ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵙ ⵢⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ: ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵙⴰⵏⴷⴰⵍⴰ ⵏⵏⴻⵙ!’” ");
INSERT INTO rift_vpl VALUES ("DT25_11","006_25_11","DEU","25","11","11","“ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⵓⵛⴰ ⵜⵔⴻⵃⵃⴻⴳ-ⴷⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵃⵉⵎⴰ ⴰⴷ ⵜⴼⴻⴽⴽ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⵉ ⵜ ⵉⵛⵛⴰⵜⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜ ⵣⵉ ⵜⴼⵓⵍⵉⵏ ⵏ ⵓⵙⴻⴹⵃⵉ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT25_12","006_25_12","DEU","25","12","12","ⴰⴷ ⴰⵙ ⵜⵇⴻⵙⵙⴻⴷ ⵅⴻⵏⵏⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴷ ⴰⵎ ⵜⵜⴻⵣⵣⵉⴵⵉⵣ.” ");
INSERT INTO rift_vpl VALUES ("DT25_13","006_25_13","DEU","25","13","13","“ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵉⵍⵉ ⴷⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⴻⵡⵣⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT25_14","006_25_14","DEU","25","14","14","ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵉⵍⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵍⵎⵓⴷ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵉⴼⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DT25_15","006_25_15","DEU","25","15","15","ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⴻⵡⵣⴻⵏ ⵉⵡⴰⵟⴰ, ⵉⵙⴻⴳⴳⴻⵎ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊ ⵏ ⵍⵎⵓⴷ ⵏ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏⵉⵛⴰⵏ, ⵉⵡⴰⵟⴰ, ⵃⵉⵎⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT25_16","006_25_16","DEU","25","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵍⵖⴻⵛⵛ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵏⵏⵄⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT25_17","006_25_17","DEU","25","17","17","“ⵉⴷⴰⵔ ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉⴳⴳⴰ ⵄⴰⵎⴰⵍⵉⵇ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵓⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("DT25_18","006_25_18","DEU","25","18","18","ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⴽ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵉⵀⵊⴻⵎ ⵅⴰⴽ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵎⴰⵏⵉ ⴵⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ, ⵓⵎⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⵜⵓⵃⵍⴻⴷ, ⵜⴻⴼⵏⵉⴷ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵯⵉⴷ ⵛⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("DT25_19","006_25_19","DEU","25","19","19","ⴰⴷ ⵉⵎⵙⴰⵔ, ⵅⵎⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉ ⴷ ⴰⵛ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ, ⴰⵇⴰ ⴰⴷ ⵜⴻⵎⵃⵉⴷ ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵣⵉ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ. ⵡⴰⵔ ⵜ ⵜⵜᵉⵜⵜⵓ!” ");
INSERT INTO rift_vpl VALUES ("DT26_1","006_26_1","DEU","26","1","1","“ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵍⵡⴰⵔⵜ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⵖⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT26_2","006_26_2","DEU","26","2","2","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵣⵉ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⴽⵓⵍ ⵍⵖⵉⴵⴻⵜ ⵉ ⵖⴰ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT26_3","006_26_3","DEU","26","3","3","ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ, ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ: ‘ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⵜ ⵉⵡⵛ.’ ");
INSERT INTO rift_vpl VALUES ("DT26_4","006_26_4","DEU","26","4","4","ⵓⵛⴰ ⴰⴷ ⵉⴽⵙⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵜⴰⵙⵓⴵⴻⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴰⵔⵙ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT26_5","006_26_5","DEU","26","5","5","ⴰⴷ ⵜⴱⴰⵔⵔⵃⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵔⴰⵎⵉⵢⵓ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵄⵍⴰⵃⴰⵍ ⴰⴷ ⵉⴼⵏⴰ ⴰⵇⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴱⴰⴱⴰ. ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⵉⵏ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵡⴰⵀⴰ ⵓⵛⴰ ⵉⵢⵎⴰ, ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ, ⵉⵊⵀⴻⴷ ⵓ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT26_6","006_26_6","DEU","26","6","6","ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴹⴻⵍⵎⴻⵏ ⵓ ⵃⵚⴰⵔⴻⵏ ⴰⵏⴻⵖ ⵓ ⴳⴳⵉⵏ ⵅⴰⵏⴻⵖ ⵜⴰⵙⵎⵓⵖⵉ ⵜⴻⵇⵙⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("DT26_7","006_26_7","DEU","26","7","7","ⵓⵛⴰ ⵏⴻⵙⵖⵓⵢ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵓⵛⴰ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵖ ⵓ ⵉⵥⵔⴰ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⴷ ⵍⴻⵖⴱⴻⵏ ⵏⵏⴻⵖ ⴷ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT26_8","006_26_8","DEU","26","8","8","ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵏⴻⵖ-ⴷⴷ ⵙⵉⴷⵉ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵙ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ, ⵙ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ, ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵓ ⵙ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("DT26_9","006_26_9","DEU","26","9","9","ⵓⵛⴰ ⵉⵙⵙⵉⴷⴻⴼ ⴰⵏⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ, ⵜⴰⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DT26_10","006_26_10","DEU","26","10","10","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⵉⵡⵢⴻⵖ-ⴷⴷ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⴰ ⵙⵉⴷⵉ!’ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴱⴻⵏⴷⵇⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT26_11","006_26_11","DEU","26","11","11","ⴰⴷ ⵜⴼⴰⵔⵔⵃⴻⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵍ ⵉ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉ ⵛⴻⴽ ⵓ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ: ⵛⴻⴽ ⴷ ⵓⵍⴰⵡⵉ ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT26_12","006_26_12","DEU","26","12","12","“ⵅⵎⵉ ⵖⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵣⴻⴳ ⵓⵄⴻⵛⵛⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵛⵓⵔ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵍⴻⵄⵛⵓⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵡⵛⴻⴷ ⵉ ⵓⵍⴰⵡⵉ, ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵉ ⵓⵢⵓⵊⵉⵍ, ⵉ ⵜⴰⵊⵊⴰⵍⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT26_13","006_26_13","DEU","26","13","13","ⵓⵛⴰ ⴰⴷ ⵜⵉⵏⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ: ‘ⴰⵇⴰ ⴽⵙⵉⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵡⵛⵉⵖ ⵜ ⵉ ⵓⵍⴰⵡⵉ, ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵉ ⵓⵢⵓⵊⵉⵍ, ⵉ ⵜⴰⵊⵊⴰⵍⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉ ⴷ ⴰⵢⵉ ⵜⵡⴻⵚⵚⵉⴷ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵄⴻⴷⴷⵉⵖ ⵓⵍⴰ ⵅ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜⵜⵓⵖ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("DT26_14","006_26_14","DEU","26","14","14","ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵛⵛⵉⵖ ⴷⴻⴳ ⵡⴻⵛⴹⴰⵏ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴽⵙⵉⵖ ⵓⵎⵉ ⵅⴻⵎⵊⴻⵖ ⵓⵍⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵡⵛⵉⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ. ⴰⵇⴰ ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓ ⴳⴳⵉⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⵓⵎⵓⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT26_15","006_26_15","DEU","26","15","15","ⵅⵣⴰⵔ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵓⵛⴰ ⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵛⵉⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵜⵜⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ.’” ");
INSERT INTO rift_vpl VALUES ("DT26_16","006_26_16","DEU","26","16","16","“ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵢⵓⵎⵓⵔ ⵉ ⵛⴻⴽ ⴰⵙⵙ-ⴰ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ-ⴰ. ⵃⴹⴰ ⵜⴻⵏⵜ ⵓⵛⴰ ⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT26_17","006_26_17","DEU","26","17","17","ⴰⵙⵙ-ⴰ ⵜⴻⵏⵏⵉⴷ ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT26_18","006_26_18","DEU","26","18","18","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵛ ⴰⵙⵙ-ⴰ ⵉ ⵛⴻⴽ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉⴷ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵖⵍⴰ ⴰⵟⵟⴰⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵡⴻⵎ ⵉⵏⵏⴰ, ⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT26_19","006_26_19","DEU","26","19","19","ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵓⵄⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⴷ ⵢⵉⵙⴻⵎ ⴷ ⵍⵄⴻⵣⵣ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT27_1","006_27_1","DEU","27","1","1","ⵎⵓⵙⴰ, ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵢⵓⵎⵓⵔ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ-ⵢⴰ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT27_2","006_27_2","DEU","27","2","2","ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵉⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵉⵥⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵃⴻⵏⵏⵛⴻⴷ ⵙ ⵊⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT27_3","006_27_3","DEU","27","3","3","ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴰⵔⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵥⵡⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT27_4","006_27_4","DEU","27","4","4","ⵅⵎⵉ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵉⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵉⵥⵔⴰ, ⵉⵏⵏⵉ ⵅ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵄⵉⴱⴰⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵃⴻⵏⵏⵛⴻⴷ ⵙ ⵊⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT27_5","006_27_5","DEU","27","5","5","ⴰⴷ ⴷⵉⵏ ⵜⴻⴱⵏⵉⴷ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵢⴻⵥⵔⴰ. ⵡⴰⵔ ⵅⴰⵙ ⵜⴻⵙⵙⵉⵍⵉⵢⴻⴷ ⴷⴷⵓⵣⴰⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("DT27_6","006_27_6","DEU","27","6","6","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴱⵏⵉⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵢⴻⵥⵔⴰ ⴽⴻⵎⵍⴻⵏ ⵡⴰⵀⴰ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT27_7","006_27_7","DEU","27","7","7","ⵄⴰⵡⴻⴷ ⴰⴷ ⴰⵙ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵜⵉⵖⴰⵔⵚⵉ ⵏⵏⴻⵛ ⵏ ⵍⴻⵀⵏⴰ. ⴰⴷ ⴷⵉⵏ ⵜⴻⵛⵛⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT27_8","006_27_8","DEU","27","8","8","ⴰⴷ ⵜⴰⵔⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⴷⴻⴳ ⵢⴻⵥⵔⴰ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵏⵇⴰⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT27_9","006_27_9","DEU","27","9","9","ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵙⵇⴰⵔ, ⵙⵃⴻⵙⵙ, ⴰ ⵉⵙⵔⴰⵉⵍ! ⴰⵙⵙ-ⴰ ⵜⵉⵡⴹⴻⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT27_10","006_27_10","DEU","27","10","10","ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵣⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⵅ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT27_11","006_27_11","DEU","27","11","11","ⵉⵡⴻⵚⵚⴰ ⵎⵓⵙⴰ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT27_12","006_27_12","DEU","27","12","12","“ⵅⵎⵉ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴰⵢⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⵉⵔⵉⵣⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⴽⴻⵏ ⵍⴳⴻⵏⵙ: ⵛⵉⵎⵄⵓⵏ ⴷ ⵍⴰⵡⵉ ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵙⴰⴽⴰⵔ ⴷ ⵢⵓⵙⵓⴼ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT27_13","006_27_13","DEU","27","13","13","“ⵓⵛⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ-ⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵄⵉⴱⴰⵍ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵄⵍⴻⵏ: ⵔⵓⴱⵉⵏ, ⵊⴰⴷ ⴷ ⵄⴰⵛⵉⵔ ⴷ ⵣⴰⴱⵓⵍⵓⵏ, ⴷⴰⵏ ⴷ ⵏⴰⴼⵜⴰⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT27_14","006_27_14","DEU","27","14","14","“ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵏⵉⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("DT27_15","006_27_15","DEU","27","15","15","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏⵉⵖ ⵉⴼⴻⵙⵢⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵃⵔⴰⵢⴼⵉ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵙ ⵜⵏⵓⴼⴼⵔⴰ.’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_16","006_27_16","DEU","27","16","16","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_17","006_27_17","DEU","27","17","17","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵙⵙⵎⵓⵟⵟⵢⴻⵏ ⴰⵢⵎⵉⵔ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_18","006_27_18","DEU","27","18","18","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵙⵙⵡⴻⴷⴷⴰⵔⴻⵏ ⴰⴷⴰⵔⵖⴰⵍ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ!” ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_19","006_27_19","DEU","27","19","19","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵙⵙⴼⴰⵔⵔⵖⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵏ ⵓⵢⵓⵊⵉⵍ ⵓ ⵏ ⵜⴰⵊⵊⴰⵍⵜ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_20","006_27_20","DEU","27","20","20","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵄⴰⵔⵔⴰ ⴱⴰⴱⴰⵙ’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("DT27_21","006_27_21","DEU","27","21","21","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵓⵎⵓⴷⴷⴰⵔ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_22","006_27_22","DEU","27","22","22","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵓⵍⵜⵎⴰⵙ, ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_23","006_27_23","DEU","27","23","23","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵜⴰⴷⴻⴳⴳⵯⴰⵍⵜ ⵏⵏⴻⵙ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_24","006_27_24","DEU","27","24","24","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵏⵖⴻⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵙ ⵜⵏⵓⴼⴼⵔⴰ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_25","006_27_25","DEU","27","25","25","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⴰⵔⵔⴻⵛⵡⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⵖⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵀⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT27_26","006_27_26","DEU","27","26","26","‘ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵡⵉ ⵡⴰⵔ ⵉⵜⵜⵇⴰⵔⵔⴰⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵢⴻⴳⴳ!’ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ!’” ");
INSERT INTO rift_vpl VALUES ("DT28_1","006_28_1","DEU","28","1","1","“ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⴷ ⵎⵍⵉⵃ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵓⵄⵍⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_2","006_28_2","DEU","28","2","2","ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⴰⴽⴰⵜ-ⴰ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴰⵙⴻⵏⵜ, ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵡⴹⴻⵏⵜ, ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_3","006_28_3","DEU","28","3","3","ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT28_4","006_28_4","DEU","28","4","4","ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⴷ ⵜⵡⴰⵔⵓⵔⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_5","006_28_5","DEU","28","5","5","ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵜⵙⵓⴵⴻⵜ ⵏⵏⴻⵛ ⴷ ⵜⴻⴱⵇⴻⵛⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_6","006_28_6","DEU","28","6","6","ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏⵏⴻⵛ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⴷⴻⴳ ⵡⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT28_7","006_28_7","DEU","28","7","7","“ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵅⴰⴽ ⵖⴰ ⵉⴽⴽⴰⵔⴻⵏ ⴷ ⵉⴱⴰⵔⵃⴰⴹ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴼⴼⵖⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷ ⵉⵊⵊ ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵉⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT28_8","006_28_8","DEU","28","8","8","ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵙ ⵍⴱⴰⵔⴰⴽⴰ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵉⵏ ⵏⵏⴻⵛ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_9","006_28_9","DEU","28","9","9","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵉⵊⵊⵓⴵ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT28_10","006_28_10","DEU","28","10","10","ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵥⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⵡⴰⴷⴻⵏⵏⴰ ⵅⴰⴽ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT28_11","006_28_11","DEU","28","11","11","ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵍⵅⴰⵔ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⴷⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⴰⴷ ⴰⵛ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_12","006_28_12","DEU","28","12","12","ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵢⴰⵔⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵙ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉⵚⴻⵍⵃⴻⵏ, ⵉⵊⴻⵏⵡⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⴰⵏⵥⴰⵔ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴰⵔⴹⵍⴻⴷ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⴰⵔⴻⵟⵟⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_13","006_28_13","DEU","28","13","13","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵓⵏⴻⵡⵡⴰⵔ, ⵓⵛⴰ ⵛⴻⴽ ⵡⴰⵀⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵙⴻⵏⵏⴻⵊ, ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⵙⵡⴰⴷⴷⴰⵢ, ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵃⴹⵉⴷ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_14","006_28_14","DEU","28","14","14","ⵡⴰⵔ ⵜⵜⵃⴻⵢⵢⵉⴷ ⵛⴰ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵅ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⴻⴹⴼⴰⵔⴻⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_15","006_28_15","DEU","28","15","15","ⵎⴰⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵉ ⵅ ⴷ ⴰⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ, ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵍⵉ-ⵢⴰ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵀⵡⴰⵏⵜ ⵓ ⴰⴷ ⵛⴻⴽ ⵍⴻⵇⴼⴻⵏⵜ: ");
INSERT INTO rift_vpl VALUES ("DT28_16","006_28_16","DEU","28","16","16","ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT28_17","006_28_17","DEU","28","17","17","ⵜⴰⵙⵓⴵⴻⵜ ⵏⵏⴻⵛ ⴷ ⵜⴻⴱⵇⴻⵛⵜ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_18","006_28_18","DEU","28","18","18","ⴷ ⵜⴰⵎⴻⵏⵄⵓⵍⵜ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵓ ⵜⵡⴰⵔⵓⵔⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_19","006_28_19","DEU","28","19","19","ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴷⴻⴳ ⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT28_20","006_28_20","DEU","28","20","20","“ⴰⴷ ⴰⵛ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⵓⵀⴻⴷⴷⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⴰⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵎⵃⵉⴷ ⵓ ⴰⴷ ⵜⴻⴼⵏⵉⴷ ⴷⴻⵖⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵊⵊⵉⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("DT28_21","006_28_21","DEU","28","21","21","ⵙⵉⴷⵉ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⵙⵙⴻⵍⵚⴻⵇ ⵟⵟⴰⵄⵓⵏ ⴰⵍ ⵛⴻⴽ ⵖⴰ ⵉⵇⴹⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_22","006_28_22","DEU","28","22","22","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵡⵡⴻⵜ ⵙ ⴱⵓ-ⴷⴻⴵⵉⵙ, ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⴰⵔⵡⴰⵃ ⴷ ⵓⴳⴻⵢⵢⴻⵃ, ⵙ ⵍⴻⵃⵎⵓ ⴷ ⵍⴰⵥⴰⵖ, ⵙ ⵉⵎⴻⵏⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵍⴰ ⴷ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵡⴻⴼⵙⵓ. ⵉⵏⴰ ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵏ ⴰⵍ ⵖⴰ ⵜⵀⴻⵍⵍⴽⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_23","006_28_23","DEU","28","23","23","ⴰⵊⴻⵏⵏⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵜⵉⵡⴰ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵏⵏⵃⴰⵙ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵛ ⴷ ⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("DT28_24","006_28_24","DEU","28","24","24","ⴰⴷ ⵢⴰⵔⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵏⵥⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵏ ⵍⴻⵄⵊⴰⵊ ⴷ ⵉⴱⵇⵓⵇⴻⵏ ⵏ ⵍⴻⵄⵊⴰⵊ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵉⵀⵡⴰ ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_25","006_28_25","DEU","28","25","25","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⵜᵉⵜⵜⵡⴰⵖⴻⵍⴱⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ. ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⴹⵉⴷⴷ ⵉ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_26","006_28_26","DEU","28","26","26","ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_27","006_28_27","DEU","28","27","27","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵡⵡⴻⵜ ⵙ ⵜⵃⴻⴱⴱⴰ ⵏ ⵎⵉⵚⵔⴰ, ⵙ ⵉⵄⴻⴱⴱⵓⵣⴻⵏ, ⵙ ⵊⴷⴰⵎ, ⵙ ⵡⴰⵊⵊⵉⴹ ⴰⵍ ⵖⴰ ⵜⴰⴼ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_28","006_28_28","DEU","28","28","28","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵡⵡⴻⵜ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵙ ⵜⵓⴷⴷⴰⵔⵖⴻⵍⵜ ⵓ ⵙ ⴰⵔⵊⴻⴼ ⵏ ⵡⵓⵍ.” ");
INSERT INTO rift_vpl VALUES ("DT28_29","006_28_29","DEU","28","29","29","“ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵣⵉⵍ ⴰⴷ ⵜⵃⴰⴷⵉⴷ ⴰⵎ ⵓⵃⴰⴷⵉ ⵏ ⵓⴷⴰⵔⵖⴰⵍ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵚⴻⵍⵃⴻⵏ, ⵡⴰⵀ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⴷ ⵓ ⵜᵉⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⴷ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⵉ ⵛⴻⴽ ⵖⴰ ⵉⵙⵙⴻⵏⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT28_30","006_28_30","DEU","28","30","30","ⴰⴷ ⵜⵅⴻⴹⴱⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⵜ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ, ⴰⴷ ⵜⴻⴱⵏⵉⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⴷⵖⴻⴷ, ⴰⴷ ⵜⴻⴳⴳⵉⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⵥⵥⵓⴷ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⵙⵜⴻⵏⴼⵉⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_31","006_28_31","DEU","28","31","31","ⴰⴼⵓⵏⴰⵙ ⵏⵏⴻⵛ ⴰⴷ ⵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⴻⵜⵜⴻⴷ, ⴰⵖⵢⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵓⵛⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⴷⴷ-ⵉⵜⵜⵄⵉⵇⵇⵉⴱ. ⵓⴵⵉ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵡⵛⴻⵏ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵉⵍⵉ ⵡⵉ ⵖⴰ ⵉⵙⵙⴻⵏⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT28_32","006_28_32","DEU","28","32","32","ⴰⴷ ⵎⵎⴻⵡⵛⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵛ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵡⴰⵍⴰⵏⵜ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵎⵎⴻⵥⵔⴻⴷ ⴰⵙⵙ ⵉⴽⵎⴻⵍ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵊⵊⴻⵀⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_33","006_28_33","DEU","28","33","33","ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵉⵛⵛ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴻⵃⵚⴰⵔⴻⴷ ⵓ ⴰⴷ ⵜⵍⴻⴱⵣⴻⴷ ⵡⴰⵀⴰ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_34","006_28_34","DEU","28","34","34","ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵖⴰ ⵜⵥⴰⵔⴻⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT28_35","006_28_35","DEU","28","35","35","“ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵡⵡⴻⵜ ⵙ ⵜⵃⴻⴱⴱⴰ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵖⴰⵔ ⵉⴼⴰⴷⴷⴻⵏ ⵓ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵉ ⵣⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ, ⵣⵉ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵛ ⴰⵍ ⴰⵛⴻⵇⵇⵓⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_36","006_28_36","DEU","28","36","36","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ, ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴷⵉⵏ ⵉ ⵖⴰ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("DT28_37","006_28_37","DEU","28","37","37","ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵓⵙⵜⴻⵀⵣⵉ ⵉⵇⴻⵙⵃⴻⵏ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵛⴻⴽ ⵖⴰ ⵉⵏⴷⴻⵀ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT28_38","006_28_38","DEU","28","38","38","ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⵍⴻⵇⴹⴻⴷ ⴷⵔⵓⵙ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵓⵔⵖⵉ ⴰⴷ ⵜⵜ ⵜⴻⵃⵍⵓⵡ. ");
INSERT INTO rift_vpl VALUES ("DT28_39","006_28_39","DEU","28","39","39","ⴰⴷ ⵜⴻⴳⴳⵉⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵥⵥⵓⴷ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⵄⴰⵔⵔⵚⴻⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵙⴻⵙⵙⴻⴷ ⴱⵉⵏⵓ ⵓⵛⴰ ⵡⴰⵔ ⵜⵍⴻⵇⵇⴹⴻⴷ ⵡⴰⵍⵓ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⴻⵏⵜ ⵉⵛⵛ ⵓⴽⴻⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("DT28_40","006_28_40","DEU","28","40","40","ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵍⵉⵏ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴷⴻⵀⵀⵏⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵣⵣⴻⵛⵜ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⵡⴹⴰ ⵣⵣⵉⵜⵓⵏ ⵣⴻⴳ ⵓⵣⴻⵎⵎⵓⵔ ⵏⵏⴻⵛ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_41","006_28_41","DEU","28","41","41","ⴰⴷ ⴷⴷ-ⵜⴻⵊⵊⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵛⴰ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵔⵓⵃⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_42","006_28_42","DEU","28","42","42","ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵏⵜ ⵜᵉⵟⵟⴻⴼ ⵜⵎⵓⵔⵖⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT28_43","006_28_43","DEU","28","43","43","ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⴰⴷ ⵅⴰⴽ ⵉⵙⵙⵓⵄⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵙⴻⵏⵏⴻⵊ ⵓ ⵙⴻⵏⵏⴻⵊ ⵄⴰⴷ, ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⵡⴰⴷⴷⴰⵢ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("DT28_44","006_28_44","DEU","28","44","44","ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵢⴰⵔⴹⴻⵍ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴰⵔⴻⵟⵟⵍⴻⴷ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵏⴻⵡⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT28_45","006_28_45","DEU","28","45","45","ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵀⵡⴰⵏⵜ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵍⵉ-ⵢⴰ, ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵏⵜ, ⴰⴷ ⵛⴻⴽ ⵍⴻⵇⴼⴻⵏⵜ ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵎⵃⵉⴷ, ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DT28_46","006_28_46","DEU","28","46","46","ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⵉⴳⴳⵯⵉⴷ ⵢⴻⵡⵄⴰⵔⴻⵏ ⵉ ⵛⴻⴽ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("DT28_47","006_28_47","DEU","28","47","47","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵜⵛⵓⵏⵉ ⵏ ⵡⵓⵍ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵉⴵⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("DT28_48","006_28_48","DEU","28","48","48","ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵉ ⵍⵄⴻⴷⵢⴰⵏ, ⵉⵏⵏⵉ ⵉ ⵅⴰⴽ ⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ, ⵙ ⵍⴰⵥ ⴷ ⵓⴼⴰⴷⵉ, ⵙ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⴷ ⵍⴻⵅⵚⴻⵚ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⴰⵣⴰⵢⵍⵓ ⵏ ⵡⵓⵣⵣⴰⵍ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵛ, ⴰⵍ ⵛⴻⴽ ⵖⴰ ⵉⵎⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("DT28_49","006_28_49","DEU","28","49","49","ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⴳⴳⵯⴻⵊ, ⵣⴻⴳ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ ⵉⵟⵟⴰⵡⴻⵏ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵓⵎⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴼⴻⵀⵎⴻⴷ ⵉⵍⴻⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT28_50","006_28_50","DEU","28","50","50","ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵖⴰⵔⴻⵙ ⵓⴷⴻⵎ ⵉⵇⴹⴻⵄ, ⵡⴰⵔ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⴰⵡⴻⵙⵙⴰⵔ, ⵡⴰⵔ ⵢⴰⵔⴻⵃⵃⴻⵎ ⵅ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("DT28_51","006_28_51","DEU","28","51","51","ⴰⴷ ⵢⴻⵛⵛ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵎⵃⵉⴷ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⴻⵊⵊⵉ ⵉⵔⴷⴻⵏ, ⵏⵉⵖ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⵏⵉⵖ ⵣⵣⴻⵛⵜ ⵏ ⵟⵟⵔⵉ, ⵏⵉⵖ ⵜⵡⴰⵔⵓⵔⴰ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵛ ⵏⵉⵖ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ, ⴰⵍ ⵛⴻⴽ ⵉ ⵖⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("DT28_52","006_28_52","DEU","28","52","52","ⴰⴷ ⵛⴻⴽ ⵉⵃⵚⴰⵔ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰ ⵡⴹⴰⵏ ⵍⴻⵃⵢⵓⴹ ⵢⵓⵄⵍⴰⵏ ⵉⵎⴻⵜⵏⴻⵏ, ⵉⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ⴰⴷ ⵛⴻⴽ ⵉⵃⵚⴰⵔ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_53","006_28_53","DEU","28","53","53","ⵅⵎⵉ ⴷ ⴰⴽ-ⴷⴷ ⵖⴰ ⵉⵏⵏⴹⴻⵏ ⵓ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉ ⵣⵉ ⵛⴻⴽ ⵖⴰ ⵉⵃⵚⴰⵔⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_54","006_28_54","DEU","28","54","54","ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵢⴰⵔⴻⴹⴱⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉⴹⴻⴱⵄⴻⵏ ⴰⵟⵟⴰⵙ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵖⴰⵔ ⵓⵎⴰⵙ ⵓ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT28_55","006_28_55","DEU","28","55","55","ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵛⴰ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⵛⵛ ⵓⵎⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵇⵇⵉⵎ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⴷⵉ ⴹⴹⵉⵇⴰ ⵉ ⵣⵉ ⵅⴰⴽ ⵖⴰ ⵉⴱⴻⵣⵣⴻⵣ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_56","006_28_56","DEU","28","56","56","ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⴰⵔⴻⴹⴱⴻⵏ ⵓ ⵜⴻⵏⵏⵉ ⵉⴹⴻⴱⵄⴻⵏ ⴰⵟⵟⴰⵙ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵔⴹⴰⴱ ⵓ ⵏ ⵡⴻⴹⴱⴻⵄ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵎⵎⵉⵙ ⴷ ⵢⴻⴵⵉⵙ, ");
INSERT INTO rift_vpl VALUES ("DT28_57","006_28_57","DEU","28","57","57","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵍⵓⴼⴰⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵊⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵜⵓⵔⵓⵡ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⵚⴻⵚ ⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⴷⵉ ⴹⴹⵉⵇⴰ ⵉ ⵅⴰⴽ ⵖⴰ ⵉⴱⴻⵣⵣⴻⵣ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT28_58","006_28_58","DEU","28","58","58","“ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⵏⵏⵉ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵉⵙⴻⵎ-ⴰ ⵉⵄⵓⴵⴰⵏ, ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT28_59","006_28_59","DEU","28","59","59","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⵊⵊⵔⴰⵢⴻⵃ ⵏⵏⴻⵛ ⴷ ⵊⵊⵔⴰⵢⴻⵃ ⵊⴰⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⵊⴻⴼ ⴰⵍ ⵟⵟⴰⵔⴼ. ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵊⵊⵔⴰⵢⴻⵃ ⵎⵖⴰⵔⴻⵏⵜ, ⴰⴷ ⴷⵓⵎⴻⵏⵜ, ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵉⵄⴻⴼⴼⵏⴻⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_60","006_28_60","DEU","28","60","60","ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵔⵔ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵏ ⵎⵉⵚⵔⴰ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵯⴷⴻⴷ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵍⴻⵚⵇⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_61","006_28_61","DEU","28","61","61","ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛⴰⵜ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⵔⴰⵢⴻⵃ ⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ, ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵎⵃⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DT28_62","006_28_62","DEU","28","62","62","ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷⵉ ⵖⴰ ⵜⵉⵍⵉⵎ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_63","006_28_63","DEU","28","63","63","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵣⵣⴰⵢⵡⴻⵎ ⵉⴼⴰⵔⵃ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⴳⴳ ⵜⵛⵓⵏⵉ ⵓ ⴰⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵎⴰⵔⵏⵉ, ⴰⵎⵎⵓ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⴼⴰⵔⵃ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵀⴻⵍⵍⴻⴽ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵜⴻⵃⵃⴰ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⵍⵄⴻⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT28_64","006_28_64","DEU","28","64","64","ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⴱⴻⵣⵣⴻⵄ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵍ ⵓⵊⴻⵎⵎⴰⴹ ⵏⵏⴻⵖⵏⵉ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⴷⵉⵏ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴻⴽ ⵏⵉⵖ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_65","006_28_65","DEU","28","65","65","ⵡⴰⵔ ⵜᵉⵜⵜⵉⴼⴻⴷ ⵍⵀⵓⴷⵏⴻⵜ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵓⵛⴰ ⵜⴰⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴼ ⴰⵔⴻⵢⵢⴰⵃ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴷⵉⵏ ⵓⵍ ⵢⴰⵔⴻⵊⴼⴻⵏ ⴷ ⵜⵎⵓⵖⵍⵉ ⵜⵅⴻⵙⵙⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵙⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT28_66","006_28_66","DEU","28","66","66","ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴰⵎ ⵜⵓⵢⴻⵍ ⵣⵣⴰⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⴻⴹⵎⴰⵏ ⵅ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_67","006_28_67","DEU","28","67","67","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰ, ⵉⵍⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⴵⵉⵍⴻⵜ!’ ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰ, ⵉⵍⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵚⵚⴱⴻⵃ!’ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵉ ⴷ ⴰⵛ ⵉⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵖⴰ ⵜⵡⴰⵍⵉⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT28_68","006_28_68","DEU","28","68","68","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⴷⴻⴳ ⵉⵖⵓⵔⵔⵓⴱⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵜ ⵜⵥⴰⵔⵔⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ!’, ⵓⵛⴰ ⴷⵉⵏ ⴰⴷ ⵜⴻⵣⵣⴻⵏⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵙⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT28_69","006_28_69","DEU","28","69","69","ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴳⴳ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵄⴰⵀⴷ ⵉ ⴽⵉⴷⵙⴻⵏ ⵉⴳⴳⴰ ⵖⴰⵔ ⵃⵓⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("DT29_1","006_29_1","DEU","29","1","1","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⴻⵥⵔⵉⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT29_2","006_29_2","DEU","29","2","2","ⵜⵉⵇⴻⴵⵓⴱⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵜⵉⵏⵏⵉ ⵜⴻⵥⵔⵉⵎ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT29_3","006_29_3","DEU","29","3","3","ⴰⵍ ⴰⵙⵙ-ⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉ ⵓⵍ ⵃⵉⵎⴰ ⴰⴷ ⵜⴼⴻⵀⵎⴻⵎ ⵓⵍⴰ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT29_4","006_29_4","DEU","29","4","4","ⵙⵙⵏⴻⴷⵀⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ. ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⴷⵡⵉⵍ ⴷ ⵍⴱⴰⵍⵉ ⵓ ⵜⵉⵙⵉⵍⴰ ⵏⵡⴻⵎ ⵡⴰⵔ ⴷⴷⵓⵢⵙⴰⵔⴻⵏⵜ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT29_5","006_29_5","DEU","29","5","5","ⵡⴰⵔ ⵜⴻⵛⵛⵉⵎ ⴰⵖⵔⵓⵎ, ⵡⴰⵔ ⵜⴻⵙⵡⵉⵎ ⴱⵉⵏⵓ ⵓⵍⴰ ⴷ ⵛⵛⵔⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT29_6","006_29_6","DEU","29","6","6","“ⵍⴰⵎⵉ ⵜⵔⴻⵃⵃⴳⴻⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ, ⴰⴽ-ⴷ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵉⵎⵙⴰⴳⴰⵔ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⵏⴻⵖⵍⴻⴱ ⵉ-ⵜⴻⵏ ");
INSERT INTO rift_vpl VALUES ("DT29_7","006_29_7","DEU","29","7","7","ⵓⵛⴰ ⵏⴻⵟⵟⴻⴼ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⴻⵡⵛ ⵉ-ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⵓ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DT29_8","006_29_8","DEU","29","8","8","ⵃⴹⴰⵎ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ, ⵜⴻⴳⴳⴻⵎ ⵜⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵡⴹⴻⵎ ⵙ ⵍⴻⵄⵇⴻⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT29_9","006_29_9","DEU","29","9","9","ⴰⵙⵙ-ⴰ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ - ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("DT29_10","006_29_10","DEU","29","10","10","ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵡⴻⵎ, ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ, ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵡⴻⵎ, ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴻⵙⵙⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ ⴰⵍ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵢⵎⴻⵏ ⴰⵎⴰⵏ - ");
INSERT INTO rift_vpl VALUES ("DT29_11","006_29_11","DEU","29","11","11","ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵖⴰⵔ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴰⵙⵙ-ⴰ ⴰⴽⵉⴷⴻⴽ, ⵓ ⵖⴰⵔ ⵏⵏⴻⵄⵍⴻⵜ ⵉ ⵉⴵⴰⵏ ⴷ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT29_12","006_29_12","DEU","29","12","12","ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵢⴻⴳⴳ ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⴷ ⴰⵛ ⵉⵏⵏⴰ ⵓ ⴰⵎ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("DT29_13","006_29_13","DEU","29","13","13","ⵡⴰⵔ ⵉⴵⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵡⴰⵀⴰ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ-ⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ-ⴰ ⵉ ⵉⴵⴰⵏ ⴷ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DT29_14","006_29_14","DEU","29","14","14","ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴷⴰ ⵖⴰⵔⵏⴻⵖ ⵉⵃⴹⴰⵔⴻⵏ ⴰⵙⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⴷⴰ ⵖⴰⵔⵏⴻⵖ ⵉⴵⵉⵏ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT29_15","006_29_15","DEU","29","15","15","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵏⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵥⵡⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵅ ⴷⴷ-ⵜⴻⴽⴽⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("DT29_16","006_29_16","DEU","29","16","16","ⵓⵛⴰ ⵜⴻⵥⵔⵉⵎ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("DT29_17","006_29_17","DEU","29","17","17","“ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵔⵢⴰⵣ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵉⵖ ⵍⴰⴵ ⵏⵉⵖ ⵜⴰⵇⴱⵉⵍⵜ ⴰⴷ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⴰⵙⵙ-ⴰ ⵓⵍ ⵏⵏⴻⵙ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵥⵡⴰⵔ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⴰⵔⵡⴻⵏ ⴰⵔⵔⵀⴰⵊ ⵏⵉⵖ ⵛⵛⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("DT29_18","006_29_18","DEU","29","18","18","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵖⴰ ⵉⵙⴻⵍ ⴰⵡⴰⵍⴻⵏ ⵏ ⵏⵏⴻⵄⵍⴻⵜ-ⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⴳⴳⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ, ⵡⴰⵅⵅⴰ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵉⵏⵓ, ⴰⵍ ⵖⴰ ⵉⵀⴻⵍⵍⴻⴽ ⵎⵉⵏ ⵉⵙⵙⵓⵏ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⴼⴼⵓⴷⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DT29_19","006_29_19","DEU","29","19","19","ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵙⴻⵎⵎⴻⵃ, ⵎⴰⵛⴰ ⴰⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵓⵙⵎⵉ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⴷⴷⵓⵅⵅⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵓ ⵎⴰⵔⵔⴰ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴰⴷ ⵅⴰⵙ ⵜⵉⵍⵉ ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵎⵃⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵣⵉ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DT29_20","006_29_20","DEU","29","20","20","ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⵃⵓⵣ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⵖⴰⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵍⵉ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DT29_21","006_29_21","DEU","29","21","21","ⵅⴻⵏⵏⵉ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵡⴻⵎ, ⵓⵍⴰ ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⴰⵎⵎⵓ ⵅⵎⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⵊⵊⵔⴰⵢⴻⵃ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⴷ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵉ ⵣⵉ ⵉⵙⵙⴻⵀⵍⴻⵛ ⵙⵉⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ: ");
INSERT INTO rift_vpl VALUES ("DT29_22","006_29_22","DEU","29","22","22","‘ⵍⴻⵛⴱⴰⵔⵉⵢⵢⴻⵜ ⴷ ⵜⵎⴻⴵⴰⵃⵜ, ⴰⵇⴰ ⵜⴻⵛⵎⴻⴹ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵥⵥⵓ ⵏⵉⵖ ⵜⴻⵙⵙⵖⴻⵎⵎⵉ ⵄⴰⴷ ⵓ ⵡⴰⵔ ⵉⵙⵙⴳⴻⵄⵄⵉⴷ ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵏⴻⵇⵍⴻⴱ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⴰⴷⵎⴰ ⴷ ⵚⴰⴱⵓⵢⵉⵎ ⵏⵏⵉ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴷ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵙ!’, ");
INSERT INTO rift_vpl VALUES ("DT29_23","006_29_23","DEU","29","23","23","ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ? ⵎⴰⵏⴰ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ-ⴰ ⵉⵎⵖⴰⵔⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("DT29_24","006_29_24","DEU","29","24","24","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ: ‘ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵉⵇⵇⴻⵏ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵎⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DT29_25","006_29_25","DEU","29","25","25","ⵓⵢⵓⵔⴻⵏ ⵄⴻⴱⴷⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙⴻⵏ, ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵏⵉⵜⵏⵉ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ-ⵉⵡⵛⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DT29_26","006_29_26","DEU","29","26","26","ⴰⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵢⴰⵔⵖⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵏⴷⴻⵀ ⵎⴰⵔⵔⴰ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT29_27","006_29_27","DEU","29","27","27","ⵙⵉⴷⵉ ⵉⵇⵍⴻⵄ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⴷ ⵡⴻⵙⵄⴰⵔ ⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵎⵖⴰⵔ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ.’ ");
INSERT INTO rift_vpl VALUES ("DT29_28","006_29_28","DEU","29","28","28","ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴰⵇⴰ ⵜⴻⵏⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵜⵡⴰⵙⵙⴰⵔⴻⴳⴱⴻⵏⵜ ⴰⵇⴰ ⵜⴻⵏⵜ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴳⴳ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT30_1","006_30_1","DEU","30","1","1","“ⵅⵎⵉ ⵅⴰⴽ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⵉ ⴳⴳⵉⵖ ⵣⵣⴰⵜⴻⴽ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴰⵔⵔⴻⴷ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵛ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵎⴰⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅⴰⴽ ⵢⵓⵥⵥⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("DT30_2","006_30_2","DEU","30","2","2","ⵓⵛⴰ ⴰⴷ ⵜⵄⴻⵇⴱⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵛ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴰⵏⴻⵛⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ, ⵛⴻⴽ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT30_3","006_30_3","DEU","30","3","3","ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⴱⴹⴻⵍ ⴰⵃⴻⴱⴱⴻⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵢⴰⵔⵃⴻⵎ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵎⵓⵏ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵎⴰⵏⵉ ⵛⴻⴽ ⵉⴱⴻⵣⵣⴻⵄ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT30_4","006_30_4","DEU","30","4","4","ⵡⴰⵅⵅⴰ ⵉⵏⵏⵉ ⵅ ⵢⵓⵥⵥⵍⴻⵏ ⵣⵣⴰⵢⴻⴽ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵎⵓⵏ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵉⵏⴷⴻⵀ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT30_5","006_30_5","DEU","30","5","5","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵉⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⴰⵔⵜⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⵄⴰⵡⴻⴷ ⴷ ⵍⵡⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⴳⴳ ⵜⵛⵓⵏⵉ ⵓ ⴰⴷ ⴷⴰⵢⴻⴽ ⵢⴰⵔⵏⵉ ⵄⴰⴷ ⴽⵜⴰⵔ ⵣⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT30_6","006_30_6","DEU","30","6","6","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵅⵜⴻⵏ ⵓⵍ ⵏⵏⴻⵛ ⴷ ⵡⵓⵍ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT30_7","006_30_7","DEU","30","7","7","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵢⴰⵔⵔ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵍⵉ ⵏⵏⵉ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵉⵏⵏⵉ ⵅⴰⴽ ⴷⴷ-ⵉⴷⴰⵔⵔⵛⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DT30_8","006_30_8","DEU","30","8","8","ⴰⴷ ⵜⵄⴻⵇⴱⴻⴷ, ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⵉ ⵅⴻⴼ ⴰⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT30_9","006_30_9","DEU","30","9","9","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴰⴼⴻⵢⵢⴻⴹ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⴷⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ, ⴷⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⵄⵇⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⴼⴰⵔⵃ ⵉ ⵍⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴼⴰⵔⵃ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT30_10","006_30_10","DEU","30","10","10","ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DT30_11","006_30_11","DEU","30","11","11","“ⵎⵉⵏⵣⵉ ⵍⵓⵎⵓⵔ-ⴰ ⵉ ⵅ ⵛⴻⴽ ⵜⵜⵓⵎⵓⵔⴻⵖ ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵢⵓⵄⵍⴰ ⵅⴰⴽ ⵓ ⵡⴰⵔ ⵉⴳⴳⵯⵉⵊ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("DT30_12","006_30_12","DEU","30","12","12","ⵡⴰⵔ ⵉⴵⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵡⵉ ⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵡⵉ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵏⵙⴻⵍ, ⵃⵉⵎⴰ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⴳⴳ?’ ");
INSERT INTO rift_vpl VALUES ("DT30_13","006_30_13","DEU","30","13","13","ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵡⵉ ⵖⴰ ⵉⵥⵡⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵡⵉ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵏⵙⴻⵍ, ⵃⵉⵎⴰ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⴳⴳ?’, ");
INSERT INTO rift_vpl VALUES ("DT30_14","006_30_14","DEU","30","14","14","ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ-ⴰ ⵢⵓⴷⴻⵙ ⵉ ⵛⴻⴽ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DT30_15","006_30_15","DEU","30","15","15","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵣⵣⴰⵜⴻⴽ ⴰⵙⵙ-ⴰ ⵜⵓⴷⴰⵔⵜ ⴷ ⵍⵅⴰⵔ ⵓⵍⴰ ⴷ ⵍⵎⴻⵡⵜ ⴷ ⵍⵖⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("DT30_16","006_30_16","DEU","30","16","16","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵜⵜⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⵎⴰⵔⵏⵉⴷ, ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵉⴱⴰⵔⴻⴽ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT30_17","006_30_17","DEU","30","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵓⵍ ⵏⵏⴻⵛ ⵉⵜⵜⴰⴳⴳⵯⴻⵊ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉⴷ ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⴷ ⵜⴱⴻⵏⴷⵇⴻⴷ ⵣⵣⴰⵜ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⴱⴷⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("DT30_18","006_30_18","DEU","30","18","18","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⴰⵡⴻⵎ ⴰⵙⵙ-ⴰ ⴱⴻⵍⵍⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵎⵎⵜⴻⵎ. ⵡⴰⵔ ⵜⴰⵔⴻⵏⵏⵢⴻⴷ ⵛⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵥⵡⵉⴷ ⵍ’ⵓⵔⴷⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT30_19","006_30_19","DEU","30","19","19","ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⵅ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅⴰⵡⴻⵎ: ⴳⴳⵉⵖ ⵣⵣⴰⵜⴻⴽ ⵜⵓⴷⴰⵔⵜ ⴷ ⵍⵎⴻⵡⵜ, ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ! ⵉⵅⴹⴰⵔ ⵅⴻⵏⵏⵉ ⵜⵓⴷⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵛⴻⴽ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("DT30_20","006_30_20","DEU","30","20","20","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵜⵍⴻⵚⵇⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵜⵓⵣⵣⴻⴳⴰⵔⵜ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵡⵛ, ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("DT31_1","006_31_1","DEU","31","1","1","ⵉⵔⵓⵃ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("DT31_2","006_31_2","DEU","31","2","2","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵄⴰⴷ ⴰⴷ ⴼⴼⵖⴻⵖ ⵓⵍⴰ ⴰⴷ ⴰⴷⴼⴻⵖ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵡⴰⵔ ⵜⵥⴻⴽⴽⵯⵉⴷ ⵉⵖⵣⴰⵔ-ⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ!’ ");
INSERT INTO rift_vpl VALUES ("DT31_3","006_31_3","DEU","31","3","3","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵥⵡⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ⵢⴰⵛⵓⵡⴰ ⴰⴷ ⵉⵥⵡⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT31_4","006_31_4","DEU","31","4","4","ⵙⵉⴷⵉ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵙⵉⵃⵓⵏ ⴷ ⵄⵓⵊ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵏⴻⵜⵜⴰ ⵙ ⵜⵏⴰⵢⴻⵏ, ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT31_5","006_31_5","DEU","31","5","5","ⵅⵎⵉ ⵜⴻⵏ ⵖⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⴰⴷ ⴽⵉⵙⴻⵏ ⵜⴻⴳⴳⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏⵏⵉ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵚⵚⵉⵖ ");
INSERT INTO rift_vpl VALUES ("DT31_6","006_31_6","DEU","31","6","6","ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⵉⵍⵉⵎ ⵜⵎⴻⵃⴹⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ, ⵡⴰⵔ ⵜⵜⴰⵔⵊⵉⵊⴻⵎ ⵛⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⴳⴳⵓⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵙⴻⵎⵎⴻⵃ ⵏⵉⵖ ⵛⴻⴽ ⵉⵜⵜⴻⵊⵊⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT31_7","006_31_7","DEU","31","7","7","ⵉⵍⴰⵖⴰ ⵎⵓⵙⴰ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ ⴰⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ: “ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵡⵛ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⵊⵊⴻⴷ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DT31_8","006_31_8","DEU","31","8","8","ⵙⵉⴷⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴰⴽⵉⴷⴻⴽ, ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⴻⵜⵜⵓ ⵛⴰ ⵏⵉⵖ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⵙⵎⴻⵃ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵓ ⵡⴰⵔ ⵜⵜⴰⵔⵊⵉⵊⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT31_9","006_31_9","DEU","31","9","9","ⵢⵓⵔⴰ ⵎⵓⵙⴰ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT31_10","006_31_10","DEU","31","10","10","ⵎⵓⵙⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⴰⵡⴰⵔⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⴼⴻⴽⴽⵉ ⵏ ⵉⵎⴻⵔⵡⵓⵙⴻⵏ ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT31_11","006_31_11","DEU","31","11","11","ⵅⵎⵉ ⵖⴰ ⵉⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴹⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ, ⴰⴷ ⵜⵖⴰⵔⴻⴷ ⵙ ⵊⵊⴻⵀⴷ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT31_12","006_31_12","DEU","31","12","12","ⴻⵊⵊ ⴰⴷ ⵉⵎⵓⵏ ⵍⴳⴻⵏⵙ, ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵃⴹⴰⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ");
INSERT INTO rift_vpl VALUES ("DT31_13","006_31_13","DEU","31","13","13","ⵓ ⵃⵉⵎⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏⴻⵏ, ⴰⴷ ⵙⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⴰⵎ ⵅ ⵍ’ⵓⵔⴷⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT31_14","006_31_14","DEU","31","14","14","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵎⵓⵙⴰ: “ⴰⵇⴰ ⵉⵡⴹⴻⵏ-ⴷⴷ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⵉ ⴷⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ. ⵍⴰⵖⴰ ⵉ ⵢⴰⵛⵓⵡⴰ ⵓ ⵙⴱⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵓⵎⵓⵔⴻⵖ.” ⵎⵓⵙⴰ ⴷ ⵢⴰⵛⵓⵡⴰ ⵔⵓⵃⴻⵏ, ⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT31_15","006_31_15","DEU","31","15","15","ⵅⴻⵏⵏⵉ ⵉⴱⴰⵏ-ⴷⴷ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("DT31_16","006_31_16","DEU","31","16","16","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵎⵓⵙⴰ: “ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⴷ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵉⴽⴽⴰⵔ ⴰⴷ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵖⴰ ⵢⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵢⴰⴷⴻⴼ ⵍⴳⴻⵏⵙ ⴰⵍ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⴷⴰⵢⵉ ⵉⵙⵎⴻⵃ, ⴰⴷ ⵢⴰⵔⵥ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⴽⵉⴷⵙⴻⵏ ⴳⴳⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("DT31_17","006_31_17","DEU","31","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵅ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵊⵊⴻⵖ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴼⴼⴰⵔⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵚⴰⵔⴹ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵛⴻⵍⵡⴰⵡⴻⵏ ⴷ ⵍⴻⵃⵚⴰⵔⴰⵜ, ⴰⵍ ⵖⴰ ⵢⵉⵏⵉ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ: ‘ⵎⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵛⴻⵍⵡⴰⵡⴻⵏ-ⴰ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⴵⵉ?’ ");
INSERT INTO rift_vpl VALUES ("DT31_18","006_31_18","DEU","31","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴼⴼⴰⵔⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DT31_19","006_31_19","DEU","31","19","19","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴰⵔⵉ ⵜⵉⵣⵍⵉⵜ-ⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⵙⴻⵍⵎⴻⴷ ⵉ-ⵜⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴻⴳⴳ ⵉ-ⵜⵜ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵜⵉⵣⵍⵉⵜ-ⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("DT31_20","006_31_20","DEU","31","20","20","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⴷⴼⴻⵖ ⵍⴳⴻⵏⵙ-ⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵡⵛⴻⵖ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⵓⵛⴰ ⴰⴷ ⵛⵛⴻⵏ, ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵇⴱⵓⴱⴱⵣⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵙⵙⴷⵓⵇⵣⴻⵏ, ⴰⴷ ⴰⵔⵥⴻⵏ ⵍⵄⴰⵀⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT31_21","006_31_21","DEU","31","21","21","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⴷ ⴰⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵛⴻⵍⵡⴰⵡⴻⵏ ⴷ ⵍⴻⵃⵚⴰⵔⴰⵜ, ⴰⵇⴰ ⵅⴻⵏⵏⵉ ⵉⵣⵍⵉ-ⵢⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵜⵜⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵅⴰⵔⵔⴻⵚ ⵏⵏⵉ ⵉⵃⴻⵟⵟⴰ ⵄⴰⴷ ⴰⵙⵙ-ⴰ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜ ⵙⵙⵉⴷⴼⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵡⵛⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("DT31_22","006_31_22","DEU","31","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵢⵓⵔⴰ ⵎⵓⵙⴰ ⵜⵉⵣⵍⵉⵜ-ⴰ ⵓⵛⴰ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT31_23","006_31_23","DEU","31","23","23","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵉⵏⵏⴰ: “ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ, ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⴷ ⴰⵙⴻⵏ ⵊⵊⵓⴵⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵡⵛⴻⵖ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⴽⵉⴷⴻⴽ ⵉⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("DT31_24","006_31_24","DEU","31","24","24","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⵓⵙⴰ ⵜⵉⵔⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT31_25","006_31_25","DEU","31","25","25","ⴰⵇⴰ ⵎⵓⵙⴰ ⵢⵓⵎⵓⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT31_26","006_31_26","DEU","31","26","26","“ⴽⵙⵉⵎ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵛⴰ ⵜⴻⴳⴳⴻⵎ ⵜ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⴹⵉⴷⴷ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT31_27","006_31_27","DEU","31","27","27","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵖⴻⵡⵡⴻⵖ ⵏⵡⴻⵎ ⴷ ⵜⵖⴻⵏⵏⴰⵏⵜ ⵏⵡⴻⵎ. ⵅⵣⴰⵔ, ⵓⵎⵉ ⵏⴻⵛⵛ ⴷⴷⴰⵔⴻⵖ ⵄⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ ⴰⵙⵙ-ⴰ, ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵙⵉⴷⵉ, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⴽⵜⴰⵔ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("DT31_28","006_31_28","DEU","31","28","28","ⵙⵎⵓⵏⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵛⵀⵓⴷ ⴹⵉⴷⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT31_29","006_31_29","DEU","31","29","29","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵡⵜ ⵉⵏⵓ ⴰⴷ ⵜⴼⴻⵙⴷⴻⵎ ⴰⵍ ⵟⵟⴰⵔⴼ ⵓⵛⴰ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵅ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵓⵔⴻⵖ. ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⴰⵍ ⵖⴰ ⵜ ⵜⴻⵙⵄⴰⵔⴻⵎ ⵙ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜⴻⴳⴳⵉⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("DT31_30","006_31_30","DEU","31","30","30","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⵣⵍⵉⵜ-ⴰ ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵉⴽⴻⵎⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DT32_1","006_32_1","DEU","32","1","1","“ⵙⵍⴻⵎ, ⴰ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ! ⴻⵊⵊ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("DT32_2","006_32_2","DEU","32","2","2","ⴻⵊⵊ ⵜⴰⵖⵓⵔⵉ ⵉⵏⵓ ⴰⴷ ⵜⵓⴷⴻⵎ ⴰⵎ ⵡⴻⵏⵥⴰⵔ, ⴰⴷ ⵀⵡⴰⵏⵜ ⵜⵉⵡⴰⵍⵉⵏ ⵉⵏⵓ ⴰⵎ ⵏⵏⴷⴰ, ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵀⵉⴹⵓⵔⵜ ⵅ ⵓⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ ⵓ ⴰⵎ ⵜⵏⴻⵛⵏⴰⵛⵉⵏ ⵅ ⵡⴻⴼⵙⵓ, ");
INSERT INTO rift_vpl VALUES ("DT32_3","006_32_3","DEU","32","3","3","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⵔⴻⵎ-ⴷⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("DT32_4","006_32_4","DEU","32","4","4","ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ, ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ, ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴱⵍⴰ ⵍⵖⴻⵛⵛ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵏⵉⵛⴰⵏ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("DT32_5","006_32_5","DEU","32","5","5","ⵍⴳⴻⵏⵙ ⴰⵇⴰ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵉⴼⴰⵔⵖ, ⵉⵅⵏⵓⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_6","006_32_6","DEU","32","6","6","ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵢⴰ ⵉ ⵙⵉⴷⵉ, ⴰ ⵍⴳⴻⵏⵙ ⴰⴱⵓⵀⴰⵍⵉ ⴷ ⵡⴻⴼⵖⵓⵔ! ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱⴰⵛ ⵏⵏⵉ ⵛⴻⴽ ⵉⵙⵖⵉⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ ⵓ ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴽⴻⵡⵡⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("DT32_7","006_32_7","DEU","32","7","7","ⵉⴷⴰⵔⴻⵎ ⵓⵙⵙⴰⵏ ⵉⵄⴷⵓⵏ, ⵅⴻⵎⵎⴻⵎ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ, ⵙⴻⵇⵙⴰ ⴱⴰⴱⴰⵛ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵜ ⵉⵄⴰⵡⴻⴷ ⵙⴻⵇⵙⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵛ ⵜ ⵉⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DT32_8","006_32_8","DEU","32","8","8","ⵓⵎⵉ ⵉⵡⵛⴰ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵓⵎⵉ ⵉⴱⴹⴰ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT32_9","006_32_9","DEU","32","9","9","ⵎⵉⵏⵣⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵢⴰⵄⵇⵓⴱ ⴷ ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_10","006_32_10","DEU","32","10","10","ⵢⵓⴼⴰ ⵉ-ⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵅⵍⴰ, ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ ⵉⵅⵍⴰⵏ ⴰⴽ-ⴷ ⵍⴻⵡⵃⵓⵛ ⵉⵜⵜⵣⵓⵏ, ⵉⵙⵙⵖⵓⵢⵢⵓⵏ. ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ, ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜ, ⵉⵃⴹⴰ ⵉ-ⵜ ⴰⵎ ⵎⵓⵎⵎⵓ ⵏ ⵜⵉⵟⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_11","006_32_11","DEU","32","11","11","ⴰⵎ ⵓⴳⵉⴷⴻⵔ ⵏⵏⵉ ⵉⵙⵙⴼⴰⵇⴻⵏ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵙ, ⵉⵟⵟⴰⵡ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵔⵔⵓⴷ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ, ⵉⵜⵜⴱⴻⵣⵣⴻⵄ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ, ⵉⴽⵙⵉ ⵉ-ⵜ ⵓⵛⴰ ⵢⴰⵔⴻⴱⴱⵓ ⵜ ⵅ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT32_12","006_32_12","DEU","32","12","12","ⴰⵎⵎⵓ ⵉ ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⵙⵉⴷⵉ ⵡⴰⵀⴰ ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⴰⴽⵉⴷⴻⵙ ⵛⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵖⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("DT32_13","006_32_13","DEU","32","13","13","ⵉⵙⵙⴻⵏⵢⴰ ⵉ-ⵜ ⵅ ⵜⵄⵓⵍⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵛⵛⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵢⴻⵢⵢⴰⵔ. ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵉⵥⴻⵎⵎ ⵜⴰⵎⵎⴻⵏⵜ ⵣⵉ ⵊⵊⴰⵔⴼ, ⴷ ⵣⵣⴻⵛⵜ ⵣⴻⴳ ⵡⴻⵥⵔⵓ ⵏ ⵜⴻⵚⴹⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("DT32_14","006_32_14","DEU","32","14","14","ⴷ ⵜⵔⵓⵙⵙⵉ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵓⵖⵉ ⵏ ⵡⵓⴵⵉ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵜⴰⵔⵡⴰ ⵏ ⴱⴰⵛⴰⵏ, ⵓ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵉⵖⴰⵢⴹⴻⵏ, ⵙ ⵎⵓⵎⵎⵓ ⵏ ⵡⴰⵔⴻⵏ ⵏ ⵉⵔⴷⴻⵏ. ⵄⴰⵡⴻⴷ ⵛⴻⴽ ⵜⴻⵙⵡⵉⴷ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴹⵉⵍ, ⴰⴽ-ⴷ ⵓⴽⵓⴼⴼⵓ ⵏⵏⴻⵙ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_15","006_32_15","DEU","32","15","15","ⵉⴷⵡⴻⵍ ⵢⴰⵛⵓⵔⵓⵏ ⵉⵇⴱⵓⴱⴱⴻⵣ ⵓⵛⴰ ⵉⵥⵥⴻⵄⴱⴻⴹ - ‘ⴰⵇⴰ ⵜⵎⴻⵙⵍⴻⴷ ⵓ ⵜⴻⵇⴱⵓⴱⴱⵣⴻⴷ, ⵡⴰⵀ, ⵙ ⵜⴰⴷⵓⵏⵜ ⵜᵉⵜⵜⵡⴰⴷⵍⴻⴷ!’ - ⵓⵛⴰ ⵉⵙⵎⴻⵃ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉ-ⵜ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_16","006_32_16","DEU","32","16","16","ⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵓⵙⵎⵉ ⵏⵏⴻⵙ, ⵙ ⵊⵊⵄⴰⵢⴻⴼ ⵙⵄⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("DT32_17","006_32_17","DEU","32","17","17","ⵏⵉⵜⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵛⵛⵡⴰⵟⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵊⴷⵉⴷ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵄⴰⴷ ⵎⴰⵎⵎⴻⵛ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DT32_18","006_32_18","DEU","32","18","18","ⵜⴰⵚⴹⴰⵔⵜ ⵏⵏⵉ ⵉ ⵛⴻⴽ ⴷⴷ-ⵢⴻⵊⵊⵉⵏ, ⵜⵙⴻⵎⵃⴻⴷ ⴷⴰⵢⴻⵙ ⵓ ⵜᵉⵜⵜⵓⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉ ⵛⴻⴽ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵙ ⵍⴻⵡⵊⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("DT32_19","006_32_19","DEU","32","19","19","ⵉⵥⵔⴰ ⵙⵉⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⵙⵙⴻⵀⵇⴰⵔ ⵉ-ⵜⴻⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⴷⵓⵇⵇⴻⵣ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_20","006_32_20","DEU","32","20","20","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴼⴼⴰⵔⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵣⵣⵎⴰⵏ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵉⵜⵜⵏⴻⵇⵍⴰⴱ, ⴷ ⵜⴰⵔⵡⴰ ⵉ ⴷⵉ ⵡⴰⵔ ⵉⴵⵉ ⵍⵎⴰⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT32_21","006_32_21","DEU","32","21","21","ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵙ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵙⵄⴰⵔⴻⵏ ⴰⵢⵉ ⵙ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵉⴱⴻⵟⵟⵍⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵜⵓⵙⵎⵉ ⵏⵙⴻⵏ ⵙ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⵍⴳⴻⵏⵙ, ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⴰⴷ ⵜⴻⵏ ⵙⵄⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DT32_22","006_32_22","DEU","32","22","22","ⵎⵉⵏⵣⵉ ⵙ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵜⴻⴽⴽⴰⵔ ⵜⵎⴻⵙⵙⵉ, ⴰⴷ ⵜⴻⵛⵎⴻⴹ ⴰⵍ ⵍⴰⵅⴰⵔⵜ ⴷⵉⵏ ⵙⵡⴰⴷⴷⴰⵢ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⵓ ⴰⴷ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⵜⵉⵙⵉ ⵏ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT32_23","006_32_23","DEU","32","23","23","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⴰⵔⵏⵉⵖ ⵉⵛⴻⵍⵡⴰⵡⴻⵏ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵏⴻⵢⵢⵛⴻⵖ ⴼⵍⵉⵜⵛⴰⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT32_24","006_32_24","DEU","32","24","24","ⴰⴷ ⵜⵜⵡⴰⵀⴻⵢⵢⴼⴻⵏ ⵙ ⵍⴰⵥ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵚⴰⵔⴹⴻⵏ ⵙ ⵟⵟⴰⵄⵓⵏ ⵓ ⵙ ⵡⴰⵔⴻⴷⴷⴻⴵ ⴰⵎⴻⵔⵣⴰⴳ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵖⵎⴰⵙ ⵏ ⵍⵎⴰⵍ ⵙ ⵙⵙⴻⵎ ⵉⵏⴻⵇⵇⴻⵏ ⵏ ⵉⴼⵉⵖⵔⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵎⵓⴵⵓⵖⴻⵏ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ. ");
INSERT INTO rift_vpl VALUES ("DT32_25","006_32_25","DEU","32","25","25","ⵣⵉ ⴱⴰⵔⵔⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵙⵙⵉⴼ ⵜⴰⵔⵔⴰⵡⵜ, ⵓ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⴰⴷ ⵜⴻⵍⵇⴻⴼ ⵜⵉⴳⴳⵯⵓⴷⵉ: ⴰⵎ ⵓⴱⵍⵉⵖ ⴰⵎ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ, ⴰⵙⴻⵢⵎⵉ ⴰⴽ-ⴷ ⵓⵎⴻⵛⵛⴰⵢⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("DT32_26","006_32_26","DEU","32","26","26","ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵉⵏⵉⵖ: ‘ⴰⵎ ⵓⵙⴻⵎⵎⵉⴹ ⴰⴷ ⵜⴻⵏ ⴼⴰⵔⴻⵜⴽⴻⵖ, ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵉⴷⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵊⴰⵔ ⵉⵡⴷⴰⵏ!’, ");
INSERT INTO rift_vpl VALUES ("DT32_27","006_32_27","DEU","32","27","27","ⵎⵍⵉ ⵡⴰⵔ ⴵⵉⵖ ⵜⵜⴻⴳⴳⵯⵉⴷⴻⵖ ⵣⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵏ ⵍⴻⵄⴷⵓ, ⵃⵉⵎⴰ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜ ⵏⴻⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵎⵎⵓ ⵙ ⵊⵊⴻⵀⴷ, ⴳⴳⵉⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("DT32_28","006_32_28","DEU","32","28","28","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴱⵍⴰ ⴰⵔⵔⴰⵢ ⵓ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DT32_29","006_32_29","DEU","32","29","29","ⵎⵍⵉ ⴳⴳⵉⵏ ⵜⵉⵖⵉⵜ, ⵅⴻⵏⵏⵉ ⵉⴳⴳⵓⵔ ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⴰⵢⴰ ⵓ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ ⵉ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT32_30","006_32_30","DEU","32","30","30","ⵎⴰⵎⵎⴻⵛ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴹⴼⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵍⴻⴼ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⴰⵔⵔⴻⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵎⵎⴻⵏⵣ ⵜⴻⵚⴹⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵙⴻⵍⵍⴻⵎ ⵙⵉⴷⵉ ⵉ ⵏⵉⵜⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("DT32_31","006_32_31","DEU","32","31","31","ⵎⵉⵏⵣⵉ ⵜⴰⵚⴹⴰⵔⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⴻⴵⵉ ⴰⵎ ⵜⴰⵚⴹⴰⵔⵜ ⵏⵏⴻⵖ. ⴻⵊⵊ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ ⵙ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT32_32","006_32_32","DEU","32","32","32","ⵎⵉⵏⵣⵉ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏⵙⴻⵏ ⵜⴻⴵⴰ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵏ ⵙⴰⴷⵓⵎ ⵓ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵄⴰⵎⵓⵔⵔⴰ. ⴰⴹⵉⵍ ⵏⵙⴻⵏ ⴷ ⴰⴹⵉⵍ ⵏ ⵙⵙⴻⵎ, ⵖⴰⵔⵙⴻⵏ ⵉⵣⴻⴽⴽⵓⵏⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵜⴰⵔⵣⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("DT32_33","006_32_33","DEU","32","33","33","ⴱⵉⵏⵓ ⵏⵙⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵙⵓⴹⵉ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵍⵀⴰⵢⵛⴰⵜ, ⴰⵎⴻⵛⵏⴰⵡ ⵙⵙⴻⵎ ⵉⵏⴻⵇⵇⴻⵏ ⵏ ⵜⵍⴻⴼⵙⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DT32_34","006_32_34","DEU","32","34","34","ⵎⴰ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⵉⵜⵜⵡⴰⵅⵣⴻⵏ, ⵉⵜⵜⵡⴰⵛⴻⵎⵎⴻⵄ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("DT32_35","006_32_35","DEU","32","35","35","ⴷ ⵏⴻⵛⵛ ⵉ ⵢⴻⴵⴰⵏ ⵅ ⵏⵏⴻⵇⵎⴻⵜ ⴷ ⵍⴻⵅⵍⴰⵚ, ⵅⵎⵉ ⵖⴰ ⵉⵃⵍⵓⴵⴻⴹ ⵓⴹⴰⵔ ⵏⵙⴻⵏ. ⴰⵙⵙ ⵏ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵙⴻⵏ ⴰⵇⴰ ⵢⵓⴷⴻⵙ, ⵓⵛⴰ ⵎⵉⵏ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉ, ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DT32_36","006_32_36","DEU","32","36","36","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⴳⴳ ⵙ ⵍⵃⴻⵇⵇ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴻⵏⵏ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵅⵎⵉ ⵖⴰ ⵉⵥⴰⵔ ⴱⴻⵍⵍⵉ ⵊⵊⴻⵀⴷ ⵉⵎⵎⴻⴽⵙⵉ, ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵊⵊⵉⵏ.    ");
INSERT INTO rift_vpl VALUES ("DT32_37","006_32_37","DEU","32","37","37","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵏⵉ ⵜⴰⵚⴹⴰⵔⵜ ⵉ ⵖⴰⵔⴻⵙ ⵓⴼⵉⵏ ⴰⴷⵓⵔⵔⵉ? ");
INSERT INTO rift_vpl VALUES ("DT32_38","006_32_38","DEU","32","38","38","ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵣⵉ ⵛⵛⵉⵏ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵉ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵏⵙⴻⵏ? ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴽⴽⴰⵔⴻⵏ, ⴰⴷ ⵛⴻⴽ ⵄⴰⵡⵏⴻⵏ ⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵙⵙⴷⵓⵔⵉ.’ ");
INSERT INTO rift_vpl VALUES ("DT32_39","006_32_39","DEU","32","39","39","ⵅⵣⴰⵔⴻⵎ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴰⵀ ⴷ ⵏⴻⵛⵛ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⵉ. ⵏⴻⵛⵛ ⵏⴻⵇⵇⴻⵖ ⵓ ⵏⴻⵛⵛ ⵙⵙⴻⴷⴷⴰⵔⴻⵖ, ⵏⴻⵛⵛ ⵍⴻⴱⴱⵣⴻⵖ ⵓ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DT32_40","006_32_40","DEU","32","40","40","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵉⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⴰⵇⴰ ⴷⴷⴰⵔⴻⵖ ⵉ ⵍⴻⴱⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("DT32_41","006_32_41","DEU","32","41","41","ⵎⴰⵍⴰ ⵙⵙⵇⴻⴹⵄⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⵉⵜⵜⵡⴻⵙⵙⴳⴻⵏ ⵓⵛⴰ ⴰⴼⵓⵙ ⵉⵏⵓ ⴰⴷ ⵉⵟⵟⴻⴼ ⴷⵉ ⵍⵃⵓⴽⵎ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵏⵜⴰⵇⵎⴻⵖ ⵣⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ ⵓ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT32_42","006_32_42","DEU","32","42","42","ⴰⴷ ⵙⵙᵉⵙⵛⴰⵔⴻⵖ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵉⵏⵓ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵛⴰ ⵙⵙⵉⴼ ⵉⵏⵓ ⴰⴷ ⵉⵙⴰⵔⴹ ⴰⵢⵙⵓⵎ, ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵓ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴻⵄⴷⵓ ⴰⴽ-ⴷ ⵉⵊⴻⵟⵟⴰⵢⴻⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT32_43","006_32_43","DEU","32","43","43","ⵙⵍⵉⵡⵍⴻⵡⴻⵎ, ⴰ ⵍⴻⴳⵏⵓⵙ!, ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵏⵜⴰⵇⴻⵎ ⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵢⴰⵔⵔⴰ ⵏⵏⴻⵇⵎⴻⵜ ⵅ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.”    ");
INSERT INTO rift_vpl VALUES ("DT32_44","006_32_44","DEU","32","44","44","ⵢⵓⵙⴰ-ⴷⴷ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⵣⵍⵉⵜ-ⴰ ⵅ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵀⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("DT32_45","006_32_45","DEU","32","45","45","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵣⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("DT32_46","006_32_46","DEU","32","46","46","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵔⵔⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏⵏⵉ ⵅ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ ⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵡⵓⵍ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⵓⵎⵓⵔⴻⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DT32_47","006_32_47","DEU","32","47","47","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵡⴰⵍ ⵏ ⴱⴰⵟⴻⵍ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵛⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ. ⵙ ⵡⴰⵡⴰⵍ-ⴰ ⴰⴷ ⵜⴻⵣⵣⵓⴳⴳⴰⵔⵜⴻⵎ ⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵜⴻⵥⵡⵉⵎ ⵅ ⵍ’ⵓⵔⴷⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT32_48","006_32_48","DEU","32","48","48","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("DT32_49","006_32_49","DEU","32","49","49","“ⴳⴻⵄⵄⴻⴷ ⴰⴷⵔⴰⵔ ⵏ ⴰⴱⴰⵔⵉⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴰⴷⵔⴰⵔ ⵏ ⵏⴰⴱⵓ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ, ⵓⵛⴰ ⵅⵣⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("DT32_50","006_32_50","DEU","32","50","50","ⵓⵛⴰ ⵎⵎⴻⵜ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵜⴳⴻⵄⵄⴷⴻⴷ. ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴰⴷ ⵜᵉⵎⵎⴰⵔⵏⵉⴷ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵎⵓⵜ ⵓⵎⴰⵛ ⵀⴰⵔⵓⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT32_51","006_32_51","DEU","32","51","51","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵖⴷⴰⵍⴻⵎ ⵣⵣⴰⵢⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ-ⵇⴰⴷⴰⵛ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DT32_52","006_32_52","DEU","32","52","52","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⵟⵥⴰⵔⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵣⵣⴰⵜⴻⴽ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵉⴷⴼⴻⴷ ⵛⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("DT33_1","006_33_1","DEU","33","1","1","ⴷ ⵜⴰ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⵉ ⵣⵉ ⵉⴱⴰⵔⴻⴽ, ⵎⵓⵙⴰ, ⴰⵔⵢⴰⵣ ⵏ ⵙⵉⴷⵉ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵇⴱⴻⵍ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT33_2","006_33_2","DEU","33","2","2","ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵉⵜⵜⵡⴻⵙⵙⴻⴳ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵙⴻⵏ ⵣⵉ ⵙⴰⵄⵉⵔ, ⵜⵓⵖⴰ ⵉⵜⵜⵉⵙⵙⵉⵇ ⵓⵎⵉ ⴷⴷ-ⵉⴱⴰⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⴼⴰⵔⴰⵏ ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵊⴰⵔ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵉⵙⵙⴱⴻⵔⴱⵉⵛ ⵙ ⵡⴰⵙⵙⴰⵎⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DT33_3","006_33_3","DEU","33","3","3","ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵍⴻⴳⵏⵓⵙ! ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵡⴰⵀ, ⴰⴷ ⵉⴽⴽⴰⵔ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT33_4","006_33_4","DEU","33","4","4","ⵎⵓⵙⴰ ⵢⵓⵎⵓⵔ ⴰⵏⴻⵖ ⵅ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("DT33_5","006_33_5","DEU","33","5","5","ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵢⴰⵛⵓⵔⵓⵏ ⵓⵎⵉ ⵏⵢⴰⵔⵡⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("DT33_6","006_33_6","DEU","33","6","6","“ⵉⵍⵉ ⴰⴷ ⵉⴷⴷⴰⵔ ⵔⵓⴱⵉⵏ, ⵡⴰⵔ ⵉⵜⵎⴻⵜⵜⵉ, ⵓⵛⴰ ⵉⵍⵉ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵓⴷⵔⵓⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("DT33_7","006_33_7","DEU","33","7","7","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⵏⵏⴰ ⵅ ⵢⴰⵀⵓⴷⴰ: “ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵢⴰⵔⵔ ⵉ-ⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵍⵉ ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⴼⵓⵙ ⴹⵉⴷⴷ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("DT33_8","006_33_8","DEU","33","8","8","ⵓ ⵅ ⵍⴰⵡⵉ ⵉⵏⵏⴰ: “ⵜⵓⵎⵎⵉⵎ ⵏⵏⴻⵛ ⴷ ⵓⵔⵉⵎ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵡⴻⵏⵏⵉ ⵜⵇⴻⴵⴱⴻⴷ ⴷⵉ ⵎⴰⵙⵙⴰ, ⴰⴽ-ⴷ ⵡⵉ ⵜⵇⴰⵛⵃⴻⴷ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("DT33_9","006_33_9","DEU","33","9","9","ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ ⵅ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ: ‘ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵡⵉⵍⵉⵖ!’, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵄⵉⵣⵣ ⵅ ⵢⴰⵢⵜⵎⴰⵙ ⵏⵉⵖ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴷⵉ ⵎⵉⵏ ⵜⴻⵏⵏⵉⴷ ⵛⴻⴽ ⵓⵛⴰ ⵃⴹⴰⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT33_10","006_33_10","DEU","33","10","10","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵉ ⵢⴰⵄⵇⵓⴱ ⵓ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵉ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵙⵙⵓⵢⵓⵙⴻⵏ ⵍⴻⴱⵅⵓⵔ ⵣⵣⴰⵜ ⵉ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT33_11","006_33_11","DEU","33","11","11","ⴱⴰⵔⴻⴽ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵎⵉⵏ ⵉⴳⴳⴰ, ⴰ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵟⵟⴻⴼ ⴰⵔⴹⴰ ⵙ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵖⴹⴻⵍ ⵜⵉⵎⴻⵚⵚⴰⴹⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⴻⵎⵄⴰⵍⴰⵏ ⴷ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵃⵉⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵏ ⵄⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("DT33_12","006_33_12","DEU","33","12","12","ⵓ ⵅ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉⵏⵏⴰ: “ⴰⵎⵄⵉⵣⵣ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ, ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜ ⵉⴷⴻⵍ ⵓⵛⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⵊⴰⵔ ⵜⵉⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("DT33_13","006_33_13","DEU","33","13","13","ⵓ ⵅ ⵢⵓⵙⵓⴼ ⵉⵏⵏⴰ: “ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵖⵍⴰⵏ ⵇⴰⵄ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵙ ⵏⵏⴷⴰ, ⵓ ⵙ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("DT33_14","006_33_14","DEU","33","14","14","ⵓ ⵙ ⵍⵖⵉⴵⴻⵜ ⵉⵖⵍⴰⵏ ⵏ ⵜⴼⵓⵛⵜ ⵓ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵖⵍⴰⵏ ⵉ ⵉⵜⵜⵉⵛ ⵓⵢⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("DT33_15","006_33_15","DEU","33","15","15","ⵓ ⵙ ⵍⵇⵉⵎⴻⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵜⵉⵇⴷⵉⵎⵉⵏ ⵓ ⵙ ⵎⵉⵏ ⵉⵖⵍⴰⵏ ⵏ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵏ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("DT33_16","006_33_16","DEU","33","16","16","ⵓ ⵙ ⵎⵉⵏ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⵓ ⵙ ⵜⵛⵓⵏⵉ ⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ⵉⵍⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵙⵓⴼ ⵓ ⵅ ⵜⵓⵛⵛⴻⵏⵜ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DT33_17","006_33_17","DEU","33","17","17","ⴰⵎⴻⵏⵣⵓ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ ⴷ ⵓⵛⴻⵡⵡⴰⵔ ⵏⵏⴻⵙ ⵓ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵡⵡⴻⵜ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⴰⵍ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵉⵏⴰ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵉⵏⴰ ⴷ ⵍⵓⵍⵓⴼ ⵏ ⵎⴰⵏⴰⵙⵙⴰ!” ");
INSERT INTO rift_vpl VALUES ("DT33_18","006_33_18","DEU","33","18","18","ⵓ ⵅ ⵣⴰⴱⵓⵍⵓⵏ ⵉⵏⵏⴰ: “ⴼⴰⵔⵃ, ⴰ ⵣⴰⴱⵓⵍⵓⵏ, ⵙ ⵡⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ, ⵓ ⵛⴻⴽ, ⴰ ⵉⵙⵙⴰⴽⴰⵔ!, ⴼⴰⵔⵃ ⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DT33_19","006_33_19","DEU","33","19","19","ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ. ⴷⵉⵏ ⵉ ⵖⴰ ⵖⴰⵔⵚⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵥⴻⵎⵎⴻⵏ ⴰⴼⴻⵢⵢⴻⴹ ⵏ ⵍⴻⴱⵃⵓⵔ ⴷ ⵜⵅⵓⴱⴰⵢ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵊⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("DT33_20","006_33_20","DEU","33","20","20","ⵓ ⵅ ⵊⴰⴷ ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵜⴰⵙⵉⵄ ⵉ ⵊⴰⴷ! ⵏⴻⵜⵜⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉⵏ ⴰⵎ ⵜⴻⵢⵔⴰⴷⵜ ⵓⵛⴰ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵖⵉⵍ, ⵡⴰⵀ, ⵓⵍⴰ ⴷ ⴰⵛⴻⵇⵇⵓⴼ ⵏ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("DT33_21","006_33_21","DEU","33","21","21","ⵉⴽⵙⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵛⵏⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⵜᵉⵜⵜⵡⴰⵃⴹⴰ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵓⵎⴳⴻⵡⵡⴰⴷ ⵙ ⵡⴻⴹⵎⴰⵏ. ⵢⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⴽⴻⵎⵎⴻⵍ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("DT33_22","006_33_22","DEU","33","22","22","ⵓ ⵅ ⴷⴰⵏ ⵉⵏⵏⴰ: “ⴷⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵡⴰⵢⵔⴰⴷ ⵏⵏⵉ ⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵣⵉ ⴱⴰⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DT33_23","006_33_23","DEU","33","23","23","ⵓ ⵅ ⵏⴰⴼⵜⴰⵍⵉ ⵉⵏⵏⴰ: “ⴰ ⵏⴰⴼⵜⴰⵍⵉ, ⵉⵍⵉ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ ⵙ ⵜⵛⵓⵏⵉ ⵓ ⵜⴻⵛⵛⵓⵔⴻⴷ ⵙ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵙⵉⴷⵉ. ⴽⵙⵉ ⵍⵖⴰⵔⴱ ⴷ ⵍⵊⴰⵏⵓⴱ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("DT33_24","006_33_24","DEU","33","24","24","ⵓ ⵅ ⴰⵛⵉⵔ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⵛⵉⵔ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ⵉⵍⵉ ⴰⴷ ⵢⴰⴼ ⴰⵔⴹⴰ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓⵔ ⴰⴹⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DT33_25","006_33_25","DEU","33","25","25","ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵏⴻⵛ ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵡⵓⵣⵣⴰⵍ ⴷ ⵏⵏⵃⴰⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("DT33_26","006_33_26","DEU","33","26","26","“ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⴰ ⵢⴰⵛⵓⵔⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵢⴻⵏ ⵅ ⵓⵊⴻⵏⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴰⴼⵓⵙ, ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵢⴻⵏ ⵅ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵙ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DT33_27","006_33_27","DEU","33","27","27","ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⴱⴷⴰ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵓⴷⵓⵔⵔⵉ, ⵓ ⵙⵡⴰⴷⴷⴰⵢ ⵜⵜⵄⴰⵡⴰⵏⴻⵏ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⵏ ⵍⴻⴱⴷⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵍⴻⵄⴷⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵔⴻⴷⴻⴵ!’ ");
INSERT INTO rift_vpl VALUES ("DT33_28","006_33_28","DEU","33","28","28","ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵣⴷⴻⵖ ⵡⴻⵃⵃⴹⴻⵙ ⴷⵉ ⵍⴰⵎⴰⵏ. ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵏⵓ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵛⵓⵔⴻⵏ ⵏ ⵉⵔⴷⴻⵏ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⵡⴰⵀ, ⵉⵊⴻⵏⵡⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵓⴷⵎⴻⵏ ⵙ ⵏⵏⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("DT33_29","006_33_29","DEU","33","29","29","ⵙⵙⴻⵄⴷ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ! ⵡⵉ ⵉⴵⴰⵏ ⴰⵎ ⵛⴻⴽ? ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉ ⵓⵄⴰⵡⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵛ. ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⴰⴷ ⵙⵙⵡⴰⴹⵄⴻⵏ ⵉ ⵛⴻⴽ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⵄⴻⴼⵙⴻⴷ ⵅ ⵉⴷⴻⵎⵔⴰⵡⴻⵏ ⵏⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("DT34_1","006_34_1","DEU","34","1","1","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⵣⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵏⴰⴱⵓ, ⵖⴰⵔ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⴼⵉⵙⵊⴰ ⵏⵏⵉ ⵉⵡⴻⵊⵊⵀⴻⵏ ⴰⵔⵉⵃⴰ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵙ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵣⵉ ⵊⵉⵍⵄⴰⴷ ⴰⵍ ⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("DT34_2","006_34_2","DEU","34","2","2","ⵎⴰⵔⵔⴰ ⵏⴰⴼⵜⴰⵍⵉ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⵉⵏ ⴷⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("DT34_3","006_34_3","DEU","34","3","3","ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴷ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⴰⵔⵉⵃⴰ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⴰⵍ ⵚⵓⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DT34_4","006_34_4","DEU","34","4","4","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵜⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵏⵏⵉⵖ: ‘ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ!” ⵊⵊⵉⵖ ⵛⴻⴽ ⴰⴷ ⵜⵜ ⵜⵥⴰⵔⴻⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵥⴻⴽⴽⵯⵉⴷ ⵛⴰ ⴷⵉⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("DT34_5","006_34_5","DEU","34","5","5","ⴰⵎⵎⵓ ⵉ ⴷⵉⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("DT34_6","006_34_6","DEU","34","6","6","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴹⴻⵍ ⵉ-ⵜ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵇⵉⴱⴰⵍⵜ ⵉ ⴱⴰⵢⵜ-ⴼⴰⵖⵓⵔ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵙⵙⴻⵏ ⴰⵎⵛⴰⵏ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DT34_7","006_34_7","DEU","34","7","7","ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⵎⵎⵓⵜ. ⵜⵉⵟⵟ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⴻⵖⵔⵉ ⵛⴰ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵔⵓⵃ ⵍⴻⵎⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("DT34_8","006_34_8","DEU","34","8","8","ⵙⵖⵓⵢⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵓⵙⵙⴰⵏ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⴷ ⵡⴻⵛⴹⴰⵏ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DT34_9","006_34_9","DEU","34","9","9","ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵙ ⴱⵓⵃⴱⴻⵍ ⵏ ⵜⵉⵖⵉⵜ, ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⵍⵉⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DT34_10","006_34_10","DEU","34","10","10","ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴰⵏⴰⴱⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵎⵓⵙⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵏⴻⵏ ⵙⵉⴷⵉ ⵓⴷⴻⵎ ⵖⴰⵔ ⵡⵓⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("DT34_11","006_34_11","DEU","34","11","11","ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⵉ ⵣⵉ ⵜ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵉⴳⴳ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵣⴰⵜ ⵉ ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DT34_12","006_34_12","DEU","34","12","12","ⵓ ⵙ ⵎⴰⵔⵔⴰ ⴰⴼⵓⵙ ⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS1_1","007_1_1","JOS","1","1","1","ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS1_2","007_1_2","JOS","1","2","2","“ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵉⵎⵎⵓⵜ. ⵍⴻⵅⵅⵓ ⴽⴽⴰⵔ, ⴻⴽⴽ ⵅ ⵍ’ⵓⵔⴷⵓⵏ-ⴰ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵡⵛⴻⵖ ⵏⴻⵛⵛ, ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS1_3","007_1_3","JOS","1","3","3","ⴽⵓⵍ ⴰⵎⵛⴰⵏ ⵎⵉⵏ ⵅⴻⴼ ⵖⴰ ⵜⴻⵄⵊⴻⵏ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵏⴻⵛⵛ ⴰⴽ-ⴷ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS1_4","007_1_4","JOS","1","4","4","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⵉⵍⵉ ⵣⵉ ⵍⴻⵅⵍⴰ ⴰⵍ ⵍⵓⴱⵏⴰⵏ-ⴰ, ⴰⵍ ⵉⵖⵣⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JS1_5","007_1_5","JOS","1","5","5","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⴰⴷ ⵉⵍⵉⵖ ⵓⵍⴰ ⴰⴽⵉⴷⴻⴽ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵙⴻⵎⵎⵃⴻⵖ ⵏⵉⵖ ⴰⴷ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JS1_6","007_1_6","JOS","1","6","6","ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴰⴷ ⵜⴰⵔⵔⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵡⵛⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JS1_7","007_1_7","JOS","1","7","7","ⵉⵍⵉ ⵡⴰⵀⴰ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ. ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵃⴻⵢⵢⴻⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵙ ⵍⴻⵄⵇⴻⵍ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JS1_8","007_1_8","JOS","1","8","8","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵛⴰ ⴰⴷⵍⵉⵙ ⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⵢⴰ ⴰⴷ ⴰⵛ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵅ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵅⴰⵔⵔⴻⵚ ⴷⴰⵢⴻⵙ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵃⴹⵉⴹ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵜⵓⵔⴰ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴼⴻⵍⵃⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⴳⴳⴻⴷ ⵙ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS1_9","007_1_9","JOS","1","9","9","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ ⵏⵏⵉⵖ? ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵄⴳⴻⵣ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⴽ ⵇⴰⵄ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JS1_10","007_1_10","JOS","1","10","10","ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵢⴰⵛⵓⵡⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS1_11","007_1_11","JOS","1","11","11","“ⵓⵢⵓⵔⴻⵎ ⵅ ⵍⵡⴻⵙⵟ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵓⵎⵓⵔ ⵍⴳⴻⵏⵙ, ⵉⵏⵉⵎ ⴰⵙⴻⵏ: ‘ⵙⵡⴻⵊⴷⴻⵜ ⵍⴻⵄⵡⴻⵍⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⵍⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⵎ ⴷ ⵍⵡⴰⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("JS1_12","007_1_12","JOS","1","12","12","ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⵓ ⴰⴽ-ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS1_13","007_1_13","JOS","1","13","13","“ⵄⴻⵇⵍⴻⵜ ⵅ ⵡⴰⵡⴰⵍ ⵏⵏⵉ ⵅ ⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵉⵏⵏⴰ ⴰⵡⴻⵎ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⴰⵔⵔⴰⵃⴻⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS1_14","007_1_14","JOS","1","14","14","ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵡⴻⵎ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵥⵡⴰⵎ ⵜⵃⴻⵣⵣⵎⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⴻⵎ ⴰⴼⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("JS1_15","007_1_15","JOS","1","15","15","ⴰⵍ ⵖⴰ ⵢⴻⵡⵛ ⵙⵉⴷⵉ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⵍⵡⴰⵔⵜ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵏⵏⵉ ⴷ ⵍⵡⴰⵔⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵡⴰⵔⵜⴻⵎ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JS1_16","007_1_16","JOS","1","16","16","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅ ⵢⴰⵛⵓⵡⴰ, ⵏⵏⴰⵏ: “ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⵓⵎⵓⵔⴻⴷ, ⴰⴷ ⵜ ⵏⴻⴳⴳ ⵓ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ, ⴰⴷ ⵏⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JS1_17","007_1_17","JOS","1","17","17","ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵙⵍⴰ ⵖⴰⵔ ⵎⵓⵙⴰ, ⴰⴷ ⵖⴰⵔⴻⴽ ⵏⵙⴻⵍ. ⵎⵖⵉⵔ ⵉⵍⵉ ⴰⴷ ⴽⵉⴽ ⵢⵉⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴵⴰ ⴰⴽ-ⴷ ⵎⵓⵙⴰ! ");
INSERT INTO rift_vpl VALUES ("JS1_18","007_1_18","JOS","1","18","18","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵄⵚⴰⵏ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵜⵓⵎⵓⵔⴻⴷ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ⵉⵍⵉ ⵡⴰⵀⴰ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("JS2_1","007_2_1","JOS","2","1","1","ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵉⵙⵙⴻⴽⴽ ⵣⵉ ⵛⵉⵟⵟⵉⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔⴻⵎ, ⵅⵣⴰⵔⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⴰⵔⵉⵃⴰ!” ⴼⴼⵖⴻⵏ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵔⴰⵃⴰⴱ, ⵓⵛⴰ ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS2_2","007_2_2","JOS","2","2","2","ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⵉⵃⴰ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JS2_3","007_2_3","JOS","2","3","3","ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⵉⵃⴰ ⵖⴰⵔ ⵔⴰⵃⴰⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵏⵉⵏ: “ⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⴷⴷ ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵓⵙⵉⵏ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵙⵉⵏ ⵍⴻⵅⴱⴰⵔ ⵅ ⵎⵉⵏ ⵉⵜⵜⴻⵎⵙⴰⵔⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JS2_4","007_2_4","JOS","2","4","4","ⴰⵇⴰ ⵜⴻⵙⵙⵉⴷⴻⴼ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵓⵛⴰ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ. ⵜⴻⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⵔⵢⴰⵣⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵏⵉⵙ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JS2_5","007_2_5","JOS","2","5","5","ⵓⵎⵉ ⵜⵜⵡⴰⴱⴻⵍⵍⵄⴻⵏⵜ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵓⵡⴻⵟⵟⵓ ⵏ ⵜⴰⴵⴻⵙⵜ, ⴼⴼⵖⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ. ⴹⴼⴰⵔⴻⵎ ⵜⴻⵏ ⴷⴻⵖⵢⴰ, ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵃⴰⵔⵜⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS2_6","007_2_6","JOS","2","6","6","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⴻⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵓⵛⴰ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵉⵖⴻⴷⴷⵉⵡⴻⵏ ⵏ ⵜⵉⴼⴼⴻⵙⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⵙⴰⵔⵙⴻⵏ ⵉ ⵏⴻⵜⵜⴰⵜ ⵅ ⵜⵣⴻⵇⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("JS2_7","007_2_7","JOS","2","7","7","ⵜⵓⵖⴰ ⵜⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵍ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴼⴼⵖⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵏ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ, ⴱⴻⵍⵍⵄⴻⵏ ⵅⴰⵙⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS2_8","007_2_8","JOS","2","8","8","ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵟⵟⵚⴻⵏ, ⵜⴳⴻⵄⵄⴻⴷ ⵔⴰⵃⴰⴱ ⵖⴰⵔⵙⴻⵏ ⵖⴰⵔ ⵜⵣⴻⵇⵇⴰ, ");
INSERT INTO rift_vpl VALUES ("JS2_9","007_2_9","JOS","2","9","9","ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵓ ⴱⴻⵍⵍⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵏⴻⵖ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴼⴻⵙⵢⴻⵏ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS2_10","007_2_10","JOS","2","10","10","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ, ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵥⴻⵖ ⵙⵉⴷⵉ ⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵓⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵏⴻⵙⵍⴰ ⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵜⴻⴳⴳⵉⵎ ⴰⴽ-ⴷ ⵙⵉⵃⵓⵏ ⴷ ⵄⵓⵊ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵖⵉⵔⵉⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵏⵏⵉ ⵜⵃⴰⵔⵔⵎⴻⵎ ⵓ ⵜᵉⵜⵜⴻⵃⵃⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS2_11","007_2_11","JOS","2","11","11","ⵓⵎⵉ ⵏⴻⵙⵍⴰ ⴰⵢⴰ, ⵉⴼⵙⵉⵢ ⵡⵓⵍ ⵏⵏⴻⵖ, ⵓ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵛⴰ ⴱⵓⵃⴱⴻⵍ ⵉⴷⴷⴰⵔ ⴷⵉ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴷ ⴷⴰ ⵙⵡⴰⴷⴷⴰⵢ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS2_12","007_2_12","JOS","2","12","12","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵊⵊⴰⴵⴻⵎ ⴰⵢⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵣⵣⴰⵢⵡⴻⵎ ⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⵓ ⵡⵛⴻⵎ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴻⵄⵍⴰⵎ ⵏ ⵍⴰⵎⴰⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JS2_13","007_2_13","JOS","2","13","13","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⴱⴰⴱⴰ ⴷ ⵢⴻⵎⵎⴰ, ⴰⵢⵜⵎⴰ ⴷ ⵙⵓⵢᵉⵜⵎⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵙⴻⵏ, ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵓ ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴼⴻⴽⴽⴻⵎ ⵍⴻⵄⵎⵓⵔⴰⵜ ⵏⵏⴻⵖ ⵣⵉ ⵍⵎⴻⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("JS2_14","007_2_14","JOS","2","14","14","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴼⴹⵉⵃⴻⵎ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⴻⵖ, ⴰⴷ ⵉⵎⵎⴻⵜ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵡⴻⵎ. ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⵅⵎⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ, ⴰⴷ ⴰⵎ ⵏⴻⵙⵙⵛⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JS2_15","007_2_15","JOS","2","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵜⵙⴻⵢⵢⴻⴱ ⵉ-ⵜⴻⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵙⵖⵓⵏ ⵣⵉ ⵍⴽⴰⵣⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⴱⴰⵔⵔⴰ ⵏ ⵡⴻⵛⴱⴰⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵛⴱⴰⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. * ");
INSERT INTO rift_vpl VALUES ("JS2_16","007_2_16","JOS","2","16","16","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⴼⴼⵖⴻⵎ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⵉⵏⵏⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵃⴰⵔⵔⵜⴻⵏ ⵓ ⴼⴼⴰⵔⴻⵎ ⴷⵉⵏⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍ ⵖⴰ ⵄⴻⵇⴱⴻⵏ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵎⴻⵏⵄⴻⵎ ⴰⴱⵔⵉⴷ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS2_17","007_2_17","JOS","2","17","17","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵣⵉ ⵜⵊⴰⴵⵉⵜ-ⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴰⴷ ⵜⵜ ⵏⴻⵊⵊⴰⴵ, ");
INSERT INTO rift_vpl VALUES ("JS2_18","007_2_18","JOS","2","18","18","ⵉⵍⴰ ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎⵎⵓ: ⵅⵣⴰⵔ, ⵅⵎⵉ ⵉ ⵖⴰ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵙⵖⵓⵏ-ⴰ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵎⵓⴷⴻⵏ ⵉ ⵣⵉ ⴷ ⴰⵏⴻⵖ ⵜⵙⴻⵢⵢⴱⴻⴷ ⵖⴰⵔ ⵍⴽⴰⵣⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⴱⴰⴱⴰⵎ ⴷ ⵢⴻⵎⵎⴰⵎ ⴷ ⴰⵢⵜⵎⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴰⴵ ⵏ ⴱⴰⴱⴰⵎ ⵖⴰⵔⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS2_19","007_2_19","JOS","2","19","19","ⵎⴰⵛⴰ ⵇⴰⵄ ⵡⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵎ, ⴰⴷ ⵉⵍⵉⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⴰⵛⴰ ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⵎ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵖ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JS2_20","007_2_20","JOS","2","20","20","ⵎⴰⵍⴰ ⵛⴻⵎ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⵊⴰⴵⵉⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴰⴷ ⴰⵎ ⵏⴻⵊⵊⵓⴵ ⵉ ⵛⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS2_21","007_2_21","JOS","2","21","21","ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ!” ⵅⴻⵏⵏⵉ ⵜⴻⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵓⵛⴰ ⵜⵛⴻⴷⴷ ⴰⵙⵖⵓⵏ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵖⴰⵔ ⵍⴽⴰⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("JS2_22","007_2_22","JOS","2","22","22","ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵉⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ. ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⵙⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵓⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS2_23","007_2_23","JOS","2","23","23","ⵅⴻⵏⵏⵉ ⴰⵔⴻⴳⴳⵯⵃⴻⵏ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵀⵡⴰⵏ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵥⵡⴰⵏ-ⴷⴷ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵓ ⵃⴰⵊⴰⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS2_24","007_2_24","JOS","2","24","24","ⵏⵏⴰⵏ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵓ ⵄⴰⵡⴻⴷ ⴼⴻⵙⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JS3_1","007_3_1","JOS","3","1","1","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵣⵉⵛ, ⵉⴽⴽⴰⵔ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⴽⵙⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵉ ⵛⵉⵟⵟⵉⵎ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉⵏⵏⵉ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵥⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS3_2","007_3_2","JOS","3","2","2","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵇⴰ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵓⵢⵓⵔⴻⵏ ⵅ ⵍⵡⴻⵙⵟ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ");
INSERT INTO rift_vpl VALUES ("JS3_3","007_3_3","JOS","3","3","3","ⵓⵛⴰ ⵓⵎⵓⵔⴻⵏ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⵔⴱⵓⵏ ⵜⵜ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵎⵎⵓⵟⵟⵢⴻⵎ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵎ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵜ ⵜⴻⴹⴼⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS3_4","007_3_4","JOS","3","4","4","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵄⴻⴱⴱⴰⵔⴻⵎ ⵜⵜⴰⵙⵉⵄ ⵄⵍⴰⵃⴰⵍ ⵉ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷ ⵏⴻⵜⵜⴰ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴰⴷⵙⴻⵎ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⴱⵔⵉⴷ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⵎ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵣⵉⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⴽⴽⵉⵎ ⴰⴱⵔⵉⴷ-ⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵉⴹⴻⵏⵏⴰⴹ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("JS3_5","007_3_5","JOS","3","5","5","ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵉⴳⴳ ⵙⵉⴷⵉ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS3_6","007_3_6","JOS","3","6","6","ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵛⵓⵡⴰ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⴰ: “ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵓⵛⴰ ⵥⵡⴰⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ!” ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵓ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JS3_7","007_3_7","JOS","3","7","7","ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⴰⵙⵙ-ⴰ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⵉ ⴵⵉⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS3_8","007_3_8","JOS","3","8","8","ⵛⴻⴽ ⴰⴷ ⵜⵓⵎⵓⵔⴻⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⵡⴹⴻⵎ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⴷ ⴷⵉⵏ ⵜⴱⴻⴷⴷⴻⵎ ⴷⵉ ⵍ’ⵓⵔⴷⵓⵏ!’” ");
INSERT INTO rift_vpl VALUES ("JS3_9","007_3_9","JOS","3","9","9","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴰⵙⴻⵎ-ⴷⴷ ⴷⴰ ⵓ ⵜⴻⵙⵍⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS3_10","007_3_10","JOS","3","10","10","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ: “ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔ ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⴰⵡⴻⵎ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵊⵉⵔⵊⴰⵛⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS3_11","007_3_11","JOS","3","11","11","ⵅⵣⴰⵔⴻⵎ, ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵣⵡⴰⵔ ⴰⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⴷⵉ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS3_12","007_3_12","JOS","3","12","12","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴼⴰⵔⵏⴻⵎ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⵡⴻⵎ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("JS3_13","007_3_13","JOS","3","13","13","ⵅⵎⵉ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴰⴷ ⵏⵇⴻⴹⵄⴻⵏ, ⴰⵎⴰⵏ ⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ, ⵓⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JS3_14","007_3_14","JOS","3","14","14","ⵍⴰⵎⵉ ⵉⴽⴽⴻⵙ ⵍⴳⴻⵏⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵔⴱⵓⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JS3_15","007_3_15","JOS","3","15","15","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵉⵃⴻⵎⵎⴰⵍⴻⵏ ⵏ ⵜⵜⴰⴱⵓⵜ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵃⴰⴷⴰⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ, ⵅ ⵜⵎⴰ ⵏ ⵡⴰⵎⴰⵏ - ⵜⵓⵖⴰ ⵍ’ⵓⵔⴷⵓⵏ ⵉⵙⵙⴼⵉⵢ ⵅ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵡⵡⴰ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⵢⵔⴰ - ");
INSERT INTO rift_vpl VALUES ("JS3_16","007_3_16","JOS","3","16","16","ⴱⴻⴷⴷⴻⵏ ⵡⴰⵎⴰⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ⴰⵎⴰⵏ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵛⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⵉⴳⴳⵯⴻⵊ ⴰⵟⵟⴰⵙ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⴷⴰⵎ ⵜⴻⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵚⴰⵔⵜⴰⵏ. ⴰⵎⵎⵓ ⵉ ⴱⴻⴷⴷⴻⵏ ⵡⴰⵎⴰⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵯⴰⵏ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ, ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⴻⵡⴹⴰ, ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ, ⴰⵇⴰ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵇⴰⵄ. ⵅⴻⵏⵏⵉ ⵉⵥⵡⴰ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵓⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS3_17","007_3_17","JOS","3","17","17","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⵅ ⵍⴰⵥⴰⵖ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵎⵉ ⵉⵥⵡⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵅ ⵍⴰⵥⴰⵖ ⴰⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⵥⵡⵉ ⵅ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS4_1","007_4_1","JOS","4","1","1","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⵥⵡⵉ ⵅ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS4_2","007_4_2","JOS","4","2","2","“ⴼⴰⵔⵏⴻⵎ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵉⵊⵊⴻⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ, ");
INSERT INTO rift_vpl VALUES ("JS4_3","007_4_3","JOS","4","3","3","ⵓ ⵜⵓⵎⵓⵔⴻⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵉ: ‘ⴽⵙⵉⵎ ⵙⵙⴰ, ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵥⵔⴰ, ⴽⵙⵉⵎ ⵜⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ, ⵙⵙⴰⵔⵙⴻⵎ ⵜⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵙⵙⴻⵏⵙⴻⵎ ⴵⵉⵍⴻⵜ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JS4_4","007_4_4","JOS","4","4","4","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵢⴰⵛⵓⵡⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴼⴰⵔⵏ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ, ");
INSERT INTO rift_vpl VALUES ("JS4_5","007_4_5","JOS","4","5","5","ⵓⵛⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵢⵓⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⴰⴷ ⵉⴽⵙⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("JS4_6","007_4_6","JOS","4","6","6","ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵊⴰⵔ ⴰⵡⴻⵎ. ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵉⵏⵉⵏ ⵢⴻⵥⵔⴰ-ⵢⴰ ⵉ ⴽⴻⵏⵏⵉⵡ?’, ");
INSERT INTO rift_vpl VALUES ("JS4_7","007_4_7","JOS","4","7","7","ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⵎ: ‘ⴰⵇⴰ-ⵜⴻⵏ ⴷⵉⵏ ⵎⵉⵏⵣⵉ ⵏⵇⴻⴹⵄⴻⵏ ⵡⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ! ⵖⴰⵔ ⵓⵥⵡⵉ ⵅ ⵍ’ⵓⵔⴷⵓⵏ ⵏⵇⴻⴹⵄⴻⵏ ⵡⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵉⵥⵔⴰ-ⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JS4_8","007_4_8","JOS","4","8","8","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⴽⵙⵉⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵥⵔⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⴽⵙⵉⵏ ⵜⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ, ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴻⵏⵙⴻⵏ, ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS4_9","007_4_9","JOS","4","9","9","ⵉⵙⵙⴰⵔⵙ ⵢⴰⵛⵓⵡⴰ ⵄⴰⵡⴻⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵥⵔⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵎⵎⴰⵔⵙⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ, ⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⵄⴰⴷ ⴷⵉⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS4_10","007_4_10","JOS","4","10","10","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵢⵉⵏⵉ ⵉ ⵍⴳⴻⵏⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵓⵛⴰ ⵉⵇⴻⴵⴻⵇ ⵍⴳⴻⵏⵙ ⵙⵙⴻⵏⵏⵉ, ⵉⵥⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JS4_11","007_4_11","JOS","4","11","11","ⵓⵎⵉ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵥⵡⵉ, ⵜⴻⵥⵡⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JS4_12","007_4_12","JOS","4","12","12","ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵥⵡⴰⵏ ⵃⴻⵣⵣⵎⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS4_13","007_4_13","JOS","4","13","13","ⵜⵓⵖⴰ-ⵜⴻⵏ ⵄⵍⴰⵃⴰⵍ ⴷⵉ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵃⴻⵣⵣⵎⴻⵏ ⵎⴰⵔⵔⴰ ⵉ ⵓⵎⴻⵏⵖⵉ. ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵖⴰⵔ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵍⴻⵡⴹⴰⵜ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS4_14","007_4_14","JOS","4","14","14","ⵙⵉⴷⵉ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵉ ⵎⵓⵙⴰ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS4_15","007_4_15","JOS","4","15","15","ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS4_16","007_4_16","JOS","4","16","16","“ⵓⵎⵓⵔ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("JS4_17","007_4_17","JOS","4","17","17","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵢⴰⵛⵓⵡⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⴰ: “ⴳⴰⵄⵄⴷⴻⵎ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ!” ");
INSERT INTO rift_vpl VALUES ("JS4_18","007_4_18","JOS","4","18","18","ⵓⵎⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵜⵓⵖⴰ ⵜⵉⵙⵉ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⴰⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵙⵙⴼⴰⵢⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("JS4_19","007_4_19","JOS","4","19","19","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵊⵉⵍⵊⴰⵍ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS4_20","007_4_20","JOS","4","20","20","ⴷⵉ ⵊⵉⵍⵊⴰⵍ ⵉⵙⵙⴱⴻⴷⴷ ⵢⴰⵛⵓⵡⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵥⵔⴰ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ-ⴷⴷ ⵉⴽⵙⵉⵏ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS4_21","007_4_21","JOS","4","21","21","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵙⵙⴻⵇⵙⴰⵏ ⵜⵉⵡⴻⵛⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⵉⵏ ⵅⵙⴻⵏ ⴰⴷ ⵉⵏⵉⵏ ⵢⴻⵥⵔⴰ-ⵢⴰ?’ ");
INSERT INTO rift_vpl VALUES ("JS4_22","007_4_22","JOS","4","22","22","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵄⴻⵍⵎⴻⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴷⴰⵏⵉⵜⴰ ⵉⵥⵡⴰ ⵉⵙⵔⴰⵉⵍ ⵍ’ⵓⵔⴷⵓⵏ-ⴰ ⵅ ⵍⴰⵥⴰⵖ, ");
INSERT INTO rift_vpl VALUES ("JS4_23","007_4_23","JOS","4","23","23","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉⵙⵙⵉⵥⴻⵖ ⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⴰⵍⴰⵎⵉ ⵜⴻⵥⵡⴰⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⵏⵏⵉ ⵉⵙⵙⵉⵥⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ ⴰⵍⴰⵎⵉ ⴷⵉⵏ ⵏⴻⵥⵡⴰ, ");
INSERT INTO rift_vpl VALUES ("JS4_24","007_4_24","JOS","4","24","24","ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⵊⵀⴻⴷ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JS5_1","007_5_1","JOS","5","1","1","ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴰ ⵏ ⵍⵖⴰⵔⴱ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵙⵍⴰⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵥⴻⵖ ⴰⵎⴰⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ, ⵅⴻⵏⵏⵉ ⵉⴼⵙⵉⵢ ⵡⵓⵍ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵛⴰ ⴰⵔⵔⵓⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS5_2","007_5_2","JOS","5","2","2","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ: “ⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⴼⴰⵔⵔⵉⵛⴻⵏ ⵏ ⵡⴻⵥⵔⵓ ⵓⵛⴰ ⵅⵜⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("JS5_3","007_5_3","JOS","5","3","3","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ ⵉⴼⴰⵔⵔⵉⵛⴻⵏ ⵏ ⵡⴻⵥⵔⵓ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵅⵜⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵊⵉⴱⵄⴰ-ⵀⴰⵄⵔⴰⵍⵓⵜ, ⴰⵇⴰ ⴷ ‘ⵜⴰⵡⵔⵉⵔⵜ ⵏ ⵍⴻⵄⴷⴰⵍⴻⵢⵢⴰⵜ ⵏ ⵡⴻⵅⵜⴰⵏ’. ");
INSERT INTO rift_vpl VALUES ("JS5_4","007_5_4","JOS","5","4","4","ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵙⴱⴰⴱ ⵉ ⵣⵉ ⵉⵅⵜⴻⵏ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ: ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵎⴰⵔⵔⴰ ⵉⵡⴻⵜⵎⴰⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵎⵎⵓⵜⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⵓⴼⴼⵓⵖ ⵏⵙⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JS5_5","007_5_5","JOS","5","5","5","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ, ⵜⵓⵖⴰ-ⵜ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⴼⴼⵓⵖ ⵏⵙⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JS5_6","007_5_6","JOS","5","6","6","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴳⴳⵓⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ, ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵙⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⴷ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⴰⵙⴻⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⴻⵊⵊⵉ ⵛⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵉⵡⵛ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS5_7","007_5_7","JOS","5","7","7","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ, ⴷ ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵄⴰⴷ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵅⴻⵜⵏⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JS5_8","007_5_8","JOS","5","8","8","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⴰⴷ ⵅⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵍⴰⵎⵉ ⴳⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS5_9","007_5_9","JOS","5","9","9","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⴰⵙⵙ-ⴰ ⴰⵇⴰ ⴽⴽⵙⴻⵖ ⵅⴰⵡⴻⵎ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵎⵉⵚⵔⴰ.” ⵅ ⵓⵢⴻⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵊⵉⵍⵊⴰⵍ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS5_10","007_5_10","JOS","5","10","10","ⵡⵜⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵊⵉⵍⵊⴰⵍ ⵓⵛⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏⵏⵉ, ⴷⵉ ⴵⵉⵍⴻⵜ, ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS5_11","007_5_11","JOS","5","11","11","ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷ ⵜⴻⵖⵡⴰⵡⵉⵏ ⵉⵛⴻⵏⵏⴼⴻⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵉ ⵜⵉⵡⴻⵛⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS5_12","007_5_12","JOS","5","12","12","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵛⵛⵉⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴻⵇⴹⴻⵄ ⵎⴰⵏⵏⴰ. ⵙⵙⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ‘ⵎⴰⵏⵏⴰ’ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⵛⵛⵉⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS5_13","007_5_13","JOS","5","13","13","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⵢⴰⵛⵓⵡⴰ ⵣⵣⴰⵜ ⵉ ⴰⵔⵉⵃⴰ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⵙ, ⵖⴰⵔⴻⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵢⴰⵛⵓⵡⴰ ⵉⵔⵓⵃ ⵖⴰⵔⴻⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵎⴰ ⵣⵣⴰⵢⵏⴻⵖ ⵏⵉⵖ ⵣⴻⴳ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("JS5_14","007_5_14","JOS","5","14","14","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵍⵍⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵍⴻⵅⵅⵓ ⵉ ⴷⴷ-ⵓⵙⵉⵖ!” ⵓⵛⴰ ⵉⵡⴹⴰ ⵢⴰⵛⵓⵡⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵢⵓⴹⴰⵔ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("JS5_15","007_5_15","JOS","5","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⴽⴽⴻⵙ ⵜⵉⵙⵉⵍⴰ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵎⵛⴰⵏ ⵉ ⵅⴻⴼ ⵜⴱⴻⴷⴷⴻⴷ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵉⴵⴰ.” ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JS6_1","007_6_1","JOS","6","1","1","ⴰⵔⵉⵃⴰ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴻⵏ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴼⴻⵖ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⴰⴷⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("JS6_2","007_6_2","JOS","6","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵛ ⴰⵔⵉⵃⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JS6_3","007_6_3","JOS","6","3","3","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏⵏⴹⴻⵎ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ. ⴰⵎⵢⴰ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS6_4","007_6_4","JOS","6","4","4","ⵙⴻⴱⵄⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵉⵣⵡⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⴰⴷ ⴰⵔⴱⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⴷ ⵜⴻⵏⵏⴹⴻⵎ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵓⴹⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JS6_5","007_6_5","JOS","6","5","5","ⵅⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵙⵓⴹⵉ ⴷ ⴰⵣⵉⵔⴰⵔ ⴷⴻⴳ ⵢⵉⵛⵛ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵍⵃⴻⵙⵙ-ⴰ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔⴻⵥ ⵍⴳⴻⵏⵙ ⵉⵎⵓⵏ ⵙ ⵜⵖⵓⵢⵢⵉⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵅⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵡⴹⴰ ⵍⵃⵉⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵥⵡⴰ ⵍⴳⴻⵏⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵢⵓⵢⵓⵔ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("JS6_6","007_6_6","JOS","6","6","6","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵅ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⵙⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵓ ⵜⵜⴻⵊⵊⴻⵎ ⵙⴻⴱⵄⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⵙⵍⵉⵡⵍⴻⵡ.” ");
INSERT INTO rift_vpl VALUES ("JS6_7","007_6_7","JOS","6","7","7","ⵏⵏⴰⵏ ⵉ ⵍⴳⴻⵏⵙ: “ⵥⵡⴰⵎ ⵓ ⵜⴻⵏⵏⴹⴻⵎ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵊⵊⴻⵎ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⴰⴷ ⵥⵡⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS6_8","007_6_8","JOS","6","8","8","ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵍⴳⴻⵏⵙ. ⵙⴻⴱⵄⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵓⵛⴰ ⵥⵡⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵜⴻⴳⴳⵓⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS6_9","007_6_9","JOS","6","9","9","ⵉⵔⵢⴰⵣⴻⵏ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⵉⵣⵡⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵅ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵜⴰⴱⵓⵜ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⴳⴳⵓⵔⴻⵏ, ⵜⵜⵙⵓⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JS6_10","007_6_10","JOS","6","10","10","ⵢⴰⵛⵓⵡⴰ ⴰⵇⴰ ⵢⵓⵎⵓⵔ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ “ⵡⴰⵔ ⵜⵜⴻⵙⵖⵓⵢⵢⵓⵎ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵜⵎⵉⵊⵊⴰ ⵏⵡⴻⵎ ⴰⴷ ⴰⵙ ⵉⵙⴻⵍ ⵃⴻⴷ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ ⴰⵍ ⴰⵙⵙ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵏⵉⵖ: ‘ⵙⵖⵓⵢⵢⴻⵎ!’ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵖⵓⵢⵢⴻⵎ ⵉ ⵓⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS6_11","007_6_11","JOS","6","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵢⴻⵊⵊⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏⵏⴻⴹ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵜⴻⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ. ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("JS6_12","007_6_12","JOS","6","12","12","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵣⵉⵛ ⵉⴽⴽⴰⵔ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⴰⵔⴱⵓⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS6_13","007_6_13","JOS","6","13","13","ⵙⴻⴱⵄⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵇⵇⵉⵎⴻⵏ ⴳⴳⵓⵔⴻⵏ, ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵓ ⵅ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵉⴹⴼⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵇⵇⵉⵎⴻⵏ ⴳⴳⵓⵔⴻⵏ ⴰⵎ ⵜⵜⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JS6_14","007_6_14","JOS","6","14","14","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴹⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS6_15","007_6_15","JOS","6","15","15","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ, ⵓⵎⵉ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ, ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⴰⵎⵎⵓ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵀⴰ ⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS6_16","007_6_16","JOS","6","16","16","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓⵎⵉ ⵙⵓⴹⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴰⵇⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵙⵖⵓⵢⵢⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵡⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("JS6_17","007_6_17","JOS","6","17","17","ⵜⴰⵏⴷⵉⵏⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴰⵔⵔⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ. ⵎⵖⵉⵔ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵔⴰⵃⴰⴱ ⵡⴰⵀⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵏⴻⵙⵙⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("JS6_18","007_6_18","JOS","6","18","18","ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴷⴷⵉⴽⴽⵡⵉⵍⴻⵎ ⴷ ⴰⵢⵜ ⵏ ⵍⴻⵃⵔⴰⵎ ⴰⵎ ⵜⴻⴽⵙⵉⵎ ⵛⴰ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵃⵔⴰⵎ ⵓ ⴰⴷ ⵜⴰⵔⵔⴻⵎ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵍⴻⵃⵔⴰⵎ ⵓ ⴰⴷ ⵜ ⵜⵖⴻⴹⵍⴻⵎ ⴷ ⴰⵔⵔⵥⵉⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JS6_19","007_6_19","JOS","6","19","19","ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS6_20","007_6_20","JOS","6","20","20","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵖⵓⵢ ⵍⴳⴻⵏⵙ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵉⵙⵍⴰ ⵍⴳⴻⵏⵙ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵔⴻⵥ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵍⵃⵉⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵀⴷⴻⵎ ⵓ ⵍⴳⴻⵏⵙ ⵉⴳⴻⵄⵄⴻⴷ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵓⵢⵓⵔ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS6_21","007_6_21","JOS","6","21","21","ⵃⴰⵔⵔⵎⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵍⵃⵓⴽⵎ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵍ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵣⴻⴳ ⵉⵃⵔⴰⵎⴻⵏ ⴰⵍ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⴰⵍ ⴰⴼⵓⵏⴰⵙ, ⵓⴵⵉ ⴷ ⵡⴻⵖⵢⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("JS6_22","007_6_22","JOS","6","22","22","ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ: “ⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵓ ⵙⵙⵓⴼⴼⵖⴻⵎ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷ ⴰⵙ ⵜⴻⵊⵊⵓⴵⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS6_23","007_6_23","JOS","6","23","23","ⵅⴻⵏⵏⵉ ⵓⴷⴼⴻⵏ ⵉⴱⵍⵉⵖⴻⵏ, ⵉⴱⴻⵔⴳⴰⴳⴻⵏ, ⵓⵛⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ-ⴷⴷ ⵔⴰⵃⴰⴱ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ. ⵙⵙⵓⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴰⴵ ⵏⵏⴻⵙ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵙⴻⵏ ⵎⴰⵏⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS6_24","007_6_24","JOS","6","24","24","ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵎⵖⵉⵔ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ, ⵙⵙⵉⴷⴼⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS6_25","007_6_25","JOS","6","25","25","ⵔⴰⵃⴰⴱ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ. ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⴰⵙⵙ-ⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵢⴰⵛⵓⵡⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS6_26","007_6_26","JOS","6","26","26","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ: “ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵔⵉⵃⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⴷ ⴰⵙ ⵢⴻⴳⴳ ⴷⵙⴰⵙ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵓⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ.” ");
INSERT INTO rift_vpl VALUES ("JS6_27","007_6_27","JOS","6","27","27","ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⵓⵛⴰ ⵍⴻⵅⴱⴰⵔ ⵉⴽⴽⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS7_1","007_7_1","JOS","7","1","1","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴻⵛⵛⴻⵏ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ⵄⴰⵅⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵔⵎⵉ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴽⵙⵉ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS7_2","007_7_2","JOS","7","2","2","ⵢⴰⵛⵓⵡⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴰⵔⵉⵃⴰ ⵖⴰⵔ ⵄⴰⵢ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⴰⵡⵉⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⴱⴰⵢⵜ-ⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⴳⴰⵄⵄⴷⴻⵎ, ⴱⴻⵔⴳⴰⴳⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ!” ⵉⵔⵢⴰⵣⴻⵏ ⴼⴼⵖⴻⵏ ⵓ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵅ ⵄⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS7_3","007_7_3","JOS","7","3","3","ⵓⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⵏⵀⵍⴰ ⵎⴰ ⵉⴳⴻⵄⵄⴻⴷ ⴷⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ⴻⵊⵊ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⴷⵉⵏ ⵄⵍⴰⵃⴰⵍ ⴰⵍⴼⴰⵢⴻⵏ ⵏⵉⵖ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵖⴻⵍⴱⴻⵏ ⵅ ⵄⴰⵢ. ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵡⵢⴻⴷ ⵛⴰ ⴷⵉⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⴷⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JS7_4","007_7_4","JOS","7","4","4","ⴰⵎⵎⵓ ⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵄⵍⴰⵃⴰⵍ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS7_5","007_7_5","JOS","7","5","5","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵢ ⵏⵖⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴰⵍ ⵛⴰⴱⴰⵔⵉⵎ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅⴰⵙⴻⵏ ⴷⴻⴳ ⵓⵀⴻⴽⴽⵡⵓ. ⵅⴻⵏⵏⵉ ⵉⴼⵙⵉⵢ ⵡⵓⵍ ⵏ ⵍⴳⴻⵏⵙ, ⵉⴷⵡⴻⵍ ⴰⵎ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS7_6","007_7_6","JOS","7","6","6","ⵢⴰⵛⵓⵡⴰ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵡⴹⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵍ ⴵⵉⵍⴻⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵓⵢⵓⵙⴻⵏ ⵓⵛⴰⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS7_7","007_7_7","JOS","7","7","7","ⵢⴰⵛⵓⵡⴰ ⵉⵏⵏⴰ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵊⵊⵉⴷ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ? ⵎⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵃⵃⴰⵏ? ⵉⵍⵉ, ⵏⴻⴳⴳⴰ ⴰⴷ ⵏⴻⵇⴱⴻⵍ ⴰⴷ ⵏⴻⵣⴷⴻⵖ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("JS7_8","007_7_8","JOS","7","8","8","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⵄⵔⵓⵔ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵡⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("JS7_9","007_7_9","JOS","7","9","9","ⵎⴰⵍⴰ ⴰⴷ ⵜ ⵙⵍⴻⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⴰⵏⴻⵖ ⵇⴻⵡⵡⴰⵔⴻⵏ, ⴰⴷ ⵇⴻⴹⵄⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵖ ⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ. ⵎⵉⵏ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵏⵏⵉ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("JS7_10","007_7_10","JOS","7","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⴽⴽⴰⵔ, ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰ ⵜⵎⴻⴷⴷⴻⴷ ⴰⵎⵎⵓ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JS7_11","007_7_11","JOS","7","11","11","ⴰⵇⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵅⴹⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⴰⵏ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵏⵏⵉ ⵅ ⴷ ⴰⵙⴻⵏ ⵓⵎⵓⵔⴻⵖ. ⴽⵙⵉⵏ ⵄⴰⵡⴻⴷ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵓⵛⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ, ⵙⵙⵅⴰⵔⵔⵇⴻⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵍⴻⵇⵛⵓⵄ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS7_12","007_7_12","JOS","7","12","12","ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ⴰⴷ ⴰⵔⵔⵉⵏ ⴰⵄⵔⵓⵔ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵇⴰⵄ ⵉ ⵍⵃⵓⴽⵎ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⵜⵜⵉⵍⵉⵖ ⵄⴰⴷ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴽⴽⵙⴻⵎ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("JS7_13","007_7_13","JOS","7","13","13","ⴽⴽⴰⵔ, ⵙⵇⴻⴷⴷⴻⵙ ⵍⴳⴻⵏⵙ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵜⵉⵡⴻⵛⵛⴰ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵉⵙⵔⴰⵉⵍ! ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰ ⵜⴻⴽⴽⵙⴻⵎ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("JS7_14","007_7_14","JOS","7","14","14","ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⴷⴷ-ⵜⵇⴰⵔⵔⴱⴻⵎ, ⴰⴷ ⵜⵉⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⵇⴰⵔⵔⴻⴱ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵏⵉ ⵉⵄⴻⴵⴻⵎ ⵙⵉⴷⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵏⴻⵙ ⵓ ⵍⴰⴵ ⵉ ⵖⴰ ⵉⵄⴻⴵⴻⵎ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵄⴻⴵⴻⵎ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵔⵢⴰⵣⴻⵏ ⵉⴱⵍⵉⵖⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS7_15","007_7_15","JOS","7","15","15","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵄⴻⴷⴷⴰ ⵅ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵓ ⵉⴳⴳⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("JS7_16","007_7_16","JOS","7","16","16","ⵉⴽⴽⴰⵔ ⵢⴰⵛⵓⵡⴰ ⵣⵉⵛ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⵉⵙⵇⴰⵔⵔⴻⴱ ⵉⵙⵔⴰⵉⵍ ⵜⴰⵇⴱⵉⵍⵜ ⵜⴰⵇⴱⵉⵍⵜ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵄⴻⴵⴻⵎ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS7_17","007_7_17","JOS","7","17","17","ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⵜⵇⴰⵔⵔⴻⴱ ⵍⴰⴵ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵄⴻⴵⴻⵎ ⵍⴰⴵ ⵏ ⵉⵣⴰⵔⴰⵃⵉⵢⵢⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⵜⵇⴰⵔⵔⴻⴱ ⵍⴰⴵ ⵏ ⵉⵣⴰⵔⴰⵃⵉⵢⵢⴻⵏ, ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵔⵢⴰⵣⴻⵏ ⵉⴱⵍⵉⵖⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵄⴻⴵⴻⵎ ⵣⴰⴱⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS7_18","007_7_18","JOS","7","18","18","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵔⵢⴰⵣⴻⵏ ⵉⴱⵍⵉⵖⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵄⴻⴵⴻⵎ ⵄⴰⵅⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵔⵎⵉ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS7_19","007_7_19","JOS","7","19","19","ⵢⴰⵛⵓⵡⴰ ⵉⵏⵏⴰ ⵉ ⵄⴰⵅⴰⵏ: “ⴰ ⵎⵎⵉ, ⴻⵡⵛ ⵍⵄⴻⵣⵣ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵇⴰⴷⴰ ⵉ-ⵜ! ⵉⵏⵉ ⴰⵢⵉ, ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵙⵏⵓⴼⴼⴰⵔ ⵛⴰ” ");
INSERT INTO rift_vpl VALUES ("JS7_20","007_7_20","JOS","7","20","20","ⵄⴰⵅⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⴰ ⴷ ⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JS7_21","007_7_21","JOS","7","21","21","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵊⴰⵔ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵣⵉ ⵛⵉⵏⴰⵔ ⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴱⴰⵔⵔⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⵜⴻⵡⵣⴻⵏ ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ. ⵏⴻⵛⵛ ⵎⴻⵥⵔⴻⵖ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵖ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵇⵉⴹⵓⵏ ⵉⵏⵓ, ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("JS7_22","007_7_22","JOS","7","22","22","ⵢⴰⵛⵓⵡⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ, ⵅⵣⴰⵔ, ⵍⴻⵃⵡⴰⵢⴻⵊ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ, ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS7_23","007_7_23","JOS","7","23","23","ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏⵏⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS7_24","007_7_24","JOS","7","24","24","ⵢⴰⵛⵓⵡⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ, ⵉⴽⵙⵉ ⵄⴰⵅⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ, ⵓⵍⴰ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵉⵣⴻⵡⵡⵇⴻⵏ ⴷ ⵜⴱⴰⵔⵔⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵢⴻⵙⵙⵉⵙ ⵏⵏⴻⵙ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵖⵢⴰⵍ ⵏⵏⴻⵙ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵙ ⴷ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⴰⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JS7_25","007_7_25","JOS","7","25","25","ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴷⵉ ⴰⵔⵔⵥⵉⵢⴻⵜ? ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴻⴳⴳ ⴷⵉ ⴰⵔⵔⵥⵉⵢⴻⵜ ⴰⵙⵙ-ⴰ!” ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⵊⴻⵎ ⵉ-ⵜ ⵙ ⵉⵥⵔⴰ ⵓⵛⴰ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵅⴰⵙⴻⵏ ⵉⵥⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JS7_26","007_7_26","JOS","7","26","26","ⵙⵙⴱⴻⴷⴷⴻⵏ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵥⵔⴰ ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ: ‘ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⴰⵅⵓⵔ’ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_1","007_8_1","JOS","8","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵄⴳⴻⵣ ⵡⵓⵍ ⵏⵏⴻⵛ. ⴽⵙⵉ ⴰⴽⵉⴷⴻⴽ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴽⴽⴰⵔ, ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⵄⴰⵢ! ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵢ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JS8_2","007_8_2","JOS","8","2","2","ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⴽ-ⴷ ⵄⴰⵢ ⵓ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⴰⴽ-ⴷ ⴰⵔⵉⵃⴰ ⵓ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵎⵖⵉⵔ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵡⴰⵀⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⴻⴳⴳ ⴷⴻⴳ ⵡⴻⵄⵔⵓⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵊⵏ ⵏ ⵍⴼⴻⵅ.”   * ");
INSERT INTO rift_vpl VALUES ("JS8_3","007_8_3","JOS","8","3","3","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵄⴰⵢ. ⵉⵅⴹⴰⵔ ⵢⴰⵛⵓⵡⴰ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵙ ⴵⵉⵍⴻⵜ ");
INSERT INTO rift_vpl VALUES ("JS8_4","007_8_4","JOS","8","4","4","ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔⴻⵎ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵍⴼⴻⵅ ⵖⴰⵔ ⵡⴻⵄⵍⵓⵍ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵡⴰⵔ ⵜⵉⴳⴳⵯⴻⵊⴻⵎ ⴰⵟⵟⴰⵙ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵉⵍⵉⵎ ⵜⵃⴻⵣⵣⵎⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS8_5","007_8_5","JOS","8","5","5","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵖ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ⴰⴷ ⵉⵎⵙⴰⵔ ⵎⴰⵍⴰ ⴼⴼⵖⴻⵏ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ ⴰⵎ ⵜⵡⴰⵍⴰⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴰⵔⵡⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS8_6","007_8_6","JOS","8","6","6","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⴹⴼⴰⵔⴻⵏ ⴰⵍ ⵜⴻⵏ ⴷⴷ-ⵏⴻⵙⵙⵉⴳⴳⵯⴻⵊ ⵅ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ ⴰⵎ ⵜⵡⴰⵍⴰⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ.’ ⵅⵎⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰ ⵏⴰⵔⵡⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS8_7","007_8_7","JOS","8","7","7","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⵎ ⵣⴻⴳ ⵡⴻⵛⴱⴰⵔ, ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵜ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS8_8","007_8_8","JOS","8","8","8","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ, ⴰⴷ ⵜⴻⵙⵙⴰⵔⵖⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⵇⴰ ⵓⵎⵓⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("JS8_9","007_8_9","JOS","8","9","9","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵍⴼⴻⵅ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵊⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵄⴰⵢ, ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵅ ⵄⴰⵢ. ⵢⴰⵛⵓⵡⴰ ⵉⵙⵙⴻⵏⵙ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JS8_10","007_8_10","JOS","8","10","10","ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ ⵉⴽⴽⴰⵔ ⵢⴰⵛⵓⵡⴰ. ⵉⵃⵙⴻⴱ ⵍⴳⴻⵏⵙ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵄⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS8_11","007_8_11","JOS","8","11","11","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵏⵏⵉ ⴽⵉⵙ ⵉⴵⴰⵏ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⴰⵍ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵏ ⵄⴰⵢ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵊⴰⵔ ⴰⵙ-ⴷⴷ ⴷ ⵄⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS8_12","007_8_12","JOS","8","12","12","ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵄⵍⴰⵃⴰⵍ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵍⴼⴻⵅ ⵊⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵄⴰⵢ, ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS8_13","007_8_13","JOS","8","13","13","ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴳⴻⵏⵙ, ⵣⴻⵄⵎⴰ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵛⴰ ⴰⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵢⴰⵛⵓⵡⴰ ⵉⵔⵓⵃ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS8_14","007_8_14","JOS","8","14","14","ⵓⵎⵉ ⵉⵥⵔⴰ-ⵢⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵢ, ⵇⴻⴵⵇⴻⵏ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ. ⴼⴼⵖⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵓⵎⴻⵏⵖⵉ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵡⴹⴰ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵖⴰⵔ ⵡⴻⵄⵔⵓⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS8_15","007_8_15","JOS","8","15","15","ⵢⴰⵛⵓⵡⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⴰⵅⵎⵉ ⵊⵊⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵡⵜⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_16","007_8_16","JOS","8","16","16","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵍⴰⵖⴰⵏ ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴹⴼⴰⵔⴻⵏ. ⴹⴼⴰⵔⴻⵏ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS8_17","007_8_17","JOS","8","17","17","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⴷⵉ ⵄⴰⵢ ⵏⵉⵖ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖⴻⵏ ⵛⴰ ⵉ ⵡⴻⴹⴼⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵔⵣⴻⵎ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS8_18","007_8_18","JOS","8","18","18","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⵃⵔⵉⵛ ⵏⵏⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵄⴰⵢ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.” ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵢⴰⵛⵓⵡⴰ ⴰⵃⵔⵉⵛ ⵏⵏⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS8_19","007_8_19","JOS","8","19","19","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⴻⵖⵢⴰ ⵓⵛⴰ ⵓⵎⵉ ⵉⵙⴰⵔⵔⴻⵃ ⵢⴰⵛⵓⵄⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⴱⴷⴰⵏ ⴰⴷ ⴰⵣⵣⵍⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜⵜ. ⴳⴳⵉⵏ ⵜ ⵙ ⵜⴰⵣⵍⴰ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS8_20","007_8_20","JOS","8","20","20","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵢ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵓⵛⴰ ⵥⵔⵉⵏ ⴷⴷⴻⵅⵅⴰⵏ ⵢⵓⵍⵉ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴷⴰ ⵓⵍⴰ ⵖⴰⵔ ⴷⵉⵏ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵉ ⵓⵎⴻⵏⵖⵉ ⵅ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS8_21","007_8_21","JOS","8","21","21","ⵓⵎⵉ ⵉⵥⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵔⴰⵊⴰⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⵟⵟⴼⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵢⵓⵍⵉ ⴷⴷⴻⵅⵅⴰⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS8_22","007_8_22","JOS","8","22","22","ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵔⵓⵃⴻⵏ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵢ ⴷⴻⵡⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ, ⵉⵏⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⴷ ⵉⵏⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵖⴻⵍⴱⴻⵏ ⵅⴰⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵏⵉⵖ ⴰⴷ ⵉⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS8_23","007_8_23","JOS","8","23","23","ⵎⴻⵏⵄⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵢ ⴰⵎ ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⵓ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_24","007_8_24","JOS","8","24","24","ⵓⵎⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴽⴻⵎⵎⵍⴻⵏ ⴰⴷ ⵏⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵄⴰⵢ, ⴰⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴰⵎ ⴷⵉ ⵍⴻⵅⵍⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵏ ⴷⴷ-ⴹⴼⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵄⴰⵢ ⵓⵛⴰ ⵡⵜⵉⵏ ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JS8_25","007_8_25","JOS","8","25","25","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴰⴼ, ⴷⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS8_26","007_8_26","JOS","8","26","26","ⵢⴰⵛⵓⵡⴰ ⵡⴰⵔ ⵉⵙⵙⴻⵀⵡⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵙ ⵓⵃⵔⵉⵛ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵃⴰⵔⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵄⴰⵢ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("JS8_27","007_8_27","JOS","8","27","27","ⴽⵙⵉⵏ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ ⵎⵖⵉⵔ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴷ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵡⴰⵍ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵉ ⵢⴰⵛⵓⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_28","007_8_28","JOS","8","28","28","ⵉⵙⵙⴻⵛⵎⴻⴹ ⵢⴰⵛⵓⵡⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵄⴰⵢ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⵉⵔⴱⴻⵜ ⵉ ⵍⴻⴱⴷⴰ, ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵅⵍⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_29","007_8_29","JOS","8","29","29","ⵏⴻⵜⵜⴰ ⵢⵓⵢⴻⵍ ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵢ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵃⵏⴰⵛⵜ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵓⵎⵉ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ, ⵢⵓⵎⵓⵔ ⵢⴰⵛⵓⵡⴰ ⴰⴷ ⴽⴽⵙⴻⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ ⵣⵉ ⵜⴻⵃⵏⴰⵛⵜ. ⵏⴹⴰⵔⴻⵏ ⵜⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵢⴻⵥⵔⴰ, ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵄⴰⴷ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_30","007_8_30","JOS","8","30","30","ⵅⴻⵏⵏⵉ ⵉⴱⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵄⵉⴱⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("JS8_31","007_8_31","JOS","8","31","31","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ: ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵥⵔⵓ ⵇⴰⵄ, ⵡⴰⵔ ⵅⴰⵙ ⵎⴻⵢⵢⵍⴻⵏ ⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴷⴷⵓⵣⴰⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ. ⵏⵉⵜⵏⵉ ⴱⴻⵅⵅⴰⵔⴻⵏ ⵅⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵙⵉⴷⵉ. ⵖⴰⵔⵚⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_32","007_8_32","JOS","8","32","32","ⵅ ⵢⴻⵥⵔⴰ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵜ ⵏ ⵜⵉⵍⴻⵎⵜ ⵏ ⵜⵉⵔⴰ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵜⴻⵏⵏⵉ ⵢⵓⵔⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS8_33","007_8_33","JOS","8","33","33","ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵜⴰⴱⵓⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⵉ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⵎ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵣⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⵣⵣⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⵉⵔⵉⵣⵉⵎ ⵓ ⴰⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵄⵉⴱⴰⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ ⵣⵉⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⴽⴻⵏ ⴰⵎⵎⵓ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS8_34","007_8_34","JOS","8","34","34","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵖⵔⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JS8_35","007_8_35","JOS","8","35","35","ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵡⴰⵔ ⵜ ⵉⵖⵔⵉ ⵢⴰⵛⵓⵡⴰ ⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵔⵓⵃⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS9_1","007_9_1","JOS","9","1","1","ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵉⵏⵏⵉ ⵢⴻⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵚⵔⵉⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ - ⵉⵊⴻⴵⵉⴷⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ: ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⴼⴰⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("JS9_2","007_9_2","JOS","9","2","2","ⵎⵓⵏⴻⵏ ⵏⵉⵜⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ ⵓ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⵅ ⵉⵊⵊ ⵏ ⴰⵔⵔⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS9_3","007_9_3","JOS","9","3","3","ⵓⵎⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⴱⵄⵓⵏ ⵙⵍⵉⵏ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⴰⵔⵉⵃⴰ ⴷ ⵄⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("JS9_4","007_9_4","JOS","9","4","4","ⴳⴳⵉⵏ ⵜ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ. ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵎⵙⴻⴽⴽⴰⵏ. ⵉⵡⵢⴻⵏ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵜⵉⴱⵓⵍⴰⵢ ⵅ ⵉⵖⵢⴰⵍ ⵏⵙⴻⵏ, ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏ ⵢⵉⵍⴻⵎ ⵜⵉⴱⵓⵍⴰⵢ ⵜⵜⵡⴰⵛⴰⵔⵔⴳⴻⵏⵜ ⵓ ⵜⵡⴰⵅⴻⵢⵢⴹⴻⵏⵜ ⵄⴰⵡⴻⴷ ⵉ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JS9_5","007_9_5","JOS","9","5","5","ⵇⵇⵏⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵙⵉⵍⴰ ⴷ ⵍⴱⴰⵔⵉ, ⵉⵜⵜⵡⴰⴹⴰⵔⵔⴼⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴰⴱⵓⵍⴰⵢ, ⵓ ⵎⴰⵔⵔⴰ ⴰⵖⵔⵓⵎ ⵏ ⵍⴻⵄⵡⴻⵍⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵢⵓⵥⴻⵖ ⵉⵜⵜⴼⵔⵓⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("JS9_6","007_9_6","JOS","9","6","6","ⵓⵢⵓⵔⴻⵏ ⴰⵎⵎⵓ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵊⵉⵍⵊⴰⵍ, ⵏⵏⴰⵏ ⴰⵙ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵏⴻⵛⵛⵉⵏ ⵏⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ. ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JS9_7","007_9_7","JOS","9","7","7","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ: “ⴰⴷ ⵜⴰⵖ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⴷⴷⵖⴻⵎ ⵊⴰⵔ ⴰⵏⴻⵖ. ⵎⴰⵎⵎⴻⵛ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ?” ");
INSERT INTO rift_vpl VALUES ("JS9_8","007_9_8","JOS","9","8","8","ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵏⵏⴰⵏ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵛⵓⵡⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⴰⵎ ⴽⴻⵏⵏⵉⵡ ⴷ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⵎ?” ");
INSERT INTO rift_vpl VALUES ("JS9_9","007_9_9","JOS","9","9","9","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ ⴰⵟⵟⴰⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵅⴰⵙ ⵍⴻⵅⴱⴰⵔ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⵉ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("JS9_10","007_9_10","JOS","9","10","10","ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵢⴻⴵⴰⵏ ⴰⵖⵉⵔⵉⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ, ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ, ⴷ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵄⴰⵛⵜⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JS9_11","007_9_11","JOS","9","11","11","ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵏⴰⵏ: ‘ⵟⵟⴼⴻⵎ ⵍⴻⵄⵡⴻⵍⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵉ ⵡⴻⴱⵔⵉⴷ, ⵓⵢⵓⵔⴻⵎ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⵎ: ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵡⴻⵎ.’ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴳⴳⴻⵎ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("JS9_12","007_9_12","JOS","9","12","12","ⴰⵖⵔⵓⵎ-ⴰ ⵏⵏⴻⵖ ⴷⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵃⵎⴰ ⵓⵎⵉ ⵜ-ⵉ-ⴷⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵏⴻⴽⵙⵉ ⵣⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⵍⴻⵄⵡⴻⵍⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵍⴰⵎⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵏⴻⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ. ⵍⴻⵅⵅⵓ ⴰⵇⴰ-ⵜ ⵢⵓⵥⴻⵖ ⵉⴷⵡⴻⵍ ⵉⵜⵜⴼⵔⵓⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("JS9_13","007_9_13","JOS","9","13","13","ⵓⵍⴰ ⴷ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏ ⵢⵉⵍⴻⵎ ⵏ ⴱⵉⵏⵓ ⵏⵏⵉ ⵏⴻⵛⵛⵓⵔ, ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵛⴰ ⵅⵣⴰⵔⴻⵎ, ⵍⴻⵅⵅⵓ ⴼⴻⴵⵇⴻⵏⵜ. ⴰⵇⴰ ⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵖ ⴷ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵖ ⵃⴼⴰⵏⵜ ⵙ ⵡⴻⴱⵔⵉⴷ ⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("JS9_14","007_9_14","JOS","9","14","14","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⴻⵄⵡⴻⵍⵜ. ⵡⴰⵔ ⴽⵙⵉⵏ ⵛⵛⵡⴰⵔ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS9_15","007_9_15","JOS","9","15","15","ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵍⴻⵀⵏⴰ ⵓ ⵉⴳⴳⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵊⵊⵓⴵⴻⵏ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS9_16","007_9_16","JOS","9","16","16","ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵏ ⵍⵄⴰⵀⴷ, ⵙⵍⴰⵏ ⵏⵉⵜⵏⵉ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷ ⵊⵊⵉⵔⴰⵏ ⵏⵙⴻⵏ, ⵓ ⴰⵇⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS9_17","007_9_17","JOS","9","17","17","ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ⵜⵓⵖⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵊⵉⴱⵄⵓⵏ ⴷ ⴽⴰⴼⵉⵔⴰ ⴷ ⴱⵉⵄⵔⵓⵜ ⴷ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JS9_18","007_9_18","JOS","9","18","18","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜⴻⵏ ⵏⵖⵉⵏ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⵓⵖⴰ ⵊⵊⵓⴵⴻⵏ ⴰⵙⴻⵏ ⴰⵢⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵜⴻⵇⵇⵉⵎ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⵎⵓⵖⵎⵓⵖ ⵅ ⵍⵃⵓⴽⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS9_19","007_9_19","JOS","9","19","19","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵊⵊⵓⴵ ⴰⵙⴻⵏ ⴰⵢⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵏⵃⴰⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS9_20","007_9_20","JOS","9","20","20","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴽⴻⵎⵎⴻⵍ ⵜⴰⵊⴰⴵⵉⵜ-ⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵏⴻⵊⵊ ⴰⴷ ⴷⴷⴰⵔⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⵡⴻⵟⵟⵉ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵏⴻⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("JS9_21","007_9_21","JOS","9","21","21","ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵏⴻⵣⴷⴰⵎⴻⵏ ⴷ ⵉⵏⵓⵢⴰⵎ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵜ ⵏⵏⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS9_22","007_9_22","JOS","9","22","22","ⵉⵍⴰⵖⴰ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⵏⴻⵖ ⵜⵛⴻⵎⵜⴻⵎ, ⵜⴻⵏⵏⴰⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⵣⴻⴷⴷⴻⵖ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵙ ⵡⴰⵟⵟⴰⵙ ⵅⴰⵡⴻⵎ!’, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JS9_23","007_9_23","JOS","9","23","23","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵏⴻⵄⵍⴻⵎ. ⵡⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵉⵏⴻⵣⴷⴰⵎⴻⵏ ⴷ ⵉⵏⵓⵢⴰⵎ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JS9_24","007_9_24","JOS","9","24","24","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅ ⵢⴰⵛⵓⵡⴰ, ⵏⵏⴰⵏ: “ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵏⵉⵛⴰⵏ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵢⵓⵎⵓⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵎⵓⵙⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⵀⴻⵍⵍⴻⴽ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ⵙ ⵓⵢⴰ ⵜⵓⵖⴰ ⵏⴻⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ ⵅ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵏⴻⴳⴳⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵢⴰ.    ");
INSERT INTO rift_vpl VALUES ("JS9_25","007_9_25","JOS","9","25","25","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⴻⴳⴳ ⴰⴽⵉⴷⵏⴻⵖ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⵍⵉⵃ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵏⴻⵖ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JS9_26","007_9_26","JOS","9","26","26","ⴰⵎⵎⵓ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⴻⵏ ⵏⵖⵉⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JS9_27","007_9_27","JOS","9","27","27","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ ⴷ ⵉⵏⴻⵣⴷⴰⵎⴻⵏ ⴷ ⵉⵏⵓⵢⴰⵎ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵍ ⴰⵙⵙ-ⴰ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_1","007_10_1","JOS","10","1","1","ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⴰⴷⵓⵏⵉ-ⵚⴰⴷⴰⵇ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵙⵍⴰ, ⴰⵇⴰ ⵢⴰⵛⵓⵡⴰ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵄⴰⵢ, ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⵜ ⵇⴰⵄ ⵓⵛⴰ ⴰⵇⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵄⴰⵢ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴰⵎ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⴰⵔⵉⵃⴰ ⵓ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⵓ ⴰⵇⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⴱⵄⵓⵏ ⴳⴳⵉⵏ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS10_2","007_10_2","JOS","10","2","2","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵊⵉⴱⵄⵓⵏ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴻⵎⵖⴰⵔ, ⵓⵎⵉ ⵜⵜ ⵜⵓⵖⴰ ⴰⵎ ⵢⵉⵛⵜⴻⵏ ⵣⵉ ⵊⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴳⴻⵍⴷⵉⵜ. ⵜⵓⵖⴰ-ⵜⵜ ⵜⴻⵎⵖⴰⵔ ⵅ ⵄⴰⵢ ⵓ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JS10_3","007_10_3","JOS","10","3","3","ⵉⵙⵙⴻⴽⴽ ⴰⴷⵓⵏⵉ-ⵣⴻⴷⴻⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵎⵙⴻⴽⴽⴰⵏ ⵖⴰⵔ ⵀⵓⵀⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⴱⵔⵓⵏ, ⵖⴰⵔ ⴼⵉⵔ’ⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵔⵎⵓⵜ, ⵖⴰⵔ ⵢⴰⴼⵉⵄ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴰⵅⵉⵛ ⵓ ⵖⴰⵔ ⴷⴰⴱⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵊⵍⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS10_4","007_10_4","JOS","10","4","4","“ⴳⴻⵄⵄⴷⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵓ ⵜⴻⵡⵛⴻⵎ ⴰⵢⵉ ⴰⴼⵓⵙ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⵡⴻⵜ ⵊⵉⴱⵄⵓⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⴰ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ ⵓ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JS10_5","007_10_5","JOS","10","5","5","ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ: ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⴱⵔⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵔⵎⵓⵜ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵊⵍⵓⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⵉ ⵊⵉⴱⵄⵓⵏ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS10_6","007_10_6","JOS","10","6","6","ⵙⵙⴻⴽⴽⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵊⵉⴱⵄⵓⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵊⵉⵍⵊⴰⵍ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵙⴻⵎⵎⴻⵃ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵙ-ⴷⴷ ⴷⴻⵖⵢⴰ ⵖⴰⵔⵏⴻⵖ. ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ⴷ ⵜⴻⵡⵛⴻⴷ ⴰⵏⴻⵖ ⴰⴼⵓⵙ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ, ⴰⵇⴰ ⵎⵓⵏⴻⵏ ⵅⴰⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JS10_7","007_10_7","JOS","10","7","7","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵢⴰⵛⵓⵡⴰ ⵣⵉ ⵊⵉⵍⵊⴰⵍ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⴽⵉⴷⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS10_8","007_10_8","JOS","10","8","8","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵢⴰⵛⵓⵡⴰ “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⵛⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JS10_9","007_10_9","JOS","10","9","9","ⵢⴰⵛⵓⵡⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵙ ⵍⵖⴻⴼⵍⴻⵜ. ⵉⴳⴻⵄⵄⴰⴷⴻⵏ-ⴷⴷ ⵣⵉ ⵊⵉⵍⵊⴰⵍ ⴵⵉⵍⴻⵜ ⴰⵎ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_10","007_10_10","JOS","10","10","10","ⵙⵉⴷⵉ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵖⴹⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵓⵛⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏ ⵄⴰⵣⵉⵇⵇⴰ ⴷ ⵎⴰⵇⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_11","007_10_11","JOS","10","11","11","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵓⵀⴻⴽⴽⵡⵓ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⴹⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵥⵔⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⵍ ⵄⴰⵣⵉⵇⵇⴰ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ. ⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵙ ⵉⴱⵇⵓⵇⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_12","007_10_12","JOS","10","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵉⵙⴻⵍⵍⴻⵎ ⵙⵉⴷⵉ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ: “ⴰ ⵜⴰⴼⵓⵛⵜ, ⴱⴻⴷⴷ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ, ⵉ ⵛⴻⴽ ⴰ, ⴰⵢⵓⵔ, ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⴰⵢⴰⵍⵓⵏ” ");
INSERT INTO rift_vpl VALUES ("JS10_13","007_10_13","JOS","10","13","13","ⵓⵛⴰ ⵜⴰⴼⵓⵛⵜ ⵜⴱⴻⴷⴷ ⴷ ⵓⵢⵓⵔ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⴰⵍⴰⵎⵉ ⵢⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵜⴰⵙⵖⴰⵔⵜ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ. ⵎⴰ ⵡⴰⵔ ⵢⵓⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ? ⵜⴰⴼⵓⵛⵜ ⵜⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵡⴰⵔ ⵜⵇⴻⴵⴻⵇ ⴰⴷ ⵜⵖⴻⴵⵉ, ⵄⵍⴰⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_14","007_10_14","JOS","10","14","14","ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴰⵎ ⵡⴰⵏⵉⵜⴰ, ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵣⵉⵛ ⵓⵍⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎⵎⵓ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_15","007_10_15","JOS","10","15","15","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵢⴰⵛⵓⵡⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ, ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵊⵉⵍⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_16","007_10_16","JOS","10","16","16","ⵅⴻⵎⵙⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵓⵛⴰ ⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⴼⵔⵉ ⵖⴰⵔ ⵎⴰⵇⵇⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_17","007_10_17","JOS","10","17","17","ⵉⵜⵜⵡⴰⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵜⵜⵡⴰⴼⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ⵏⵉⵜⵏⵉ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⴼⵔⵉ ⵖⴰⵔ ⵎⴰⵇⵇⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_18","007_10_18","JOS","10","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ: “ⵙⴻⵇⵏⵓⵏⵏⵉⵢⴻⵎ ⵜⵉⵚⵓⴹⴰⵔ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴼⵔⵉ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵎ ⵉⵔⵢⴰⵣⴻⵏ ⵅⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵄⴻⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS10_19","007_10_19","JOS","10","19","19","ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⴰⵎ ⵜⴱⴻⴷⴷⴻⵎ. ⴹⴼⴰⵔⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ⵡⵜⴻⵎ ⴰⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏⵙⴻⵏ. ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉⴳⴳⴰ ⴰⵡⴻⵎ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS10_20","007_10_20","JOS","10","20","20","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵍⴰⵎⵉ ⵜⵜⵡⴰⵇⴹⴰⵏ ⵏⵉⵜⵏⵉ, ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵎⵖⵉⵔ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS10_21","007_10_21","JOS","10","21","21","ⴰⵇⴰ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵎⴰⵇⵇⵉⴷⴰ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⵄⵉⵎ ⴰⴷ ⵉⵙⵙⴻⵏⵀⴻⵣ ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_22","007_10_22","JOS","10","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ: “ⴰⵔⵣⵎⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴼⵔⵉ ⵓⵛⴰ ⴰⵡⵢⴻⵎ-ⴷⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵣⴻⴳ ⵉⴼⵔⵉ ⵖⴰⵔⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("JS10_23","007_10_23","JOS","10","23","23","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜ ⴰⵎⵎⵓ, ⵙⵙⵓⴼⴼⵖⴻⵏ-ⴷⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵣⴻⴳ ⵉⴼⵔⵉ ⵖⴰⵔⴻⵙ: ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⴱⵔⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵔⵎⵓⵜ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴰⵅⵉⵛ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵊⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS10_24","007_10_24","JOS","10","24","24","ⵓⵎⵉ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ, ⵉⵍⴰⵖⴰ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵅ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵔⵓⵃⴻⵏ: “ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⵓⵛⴰ ⵙⴰⵔⵙⴻⵎ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵅ ⵜⵎⴻⵊⵊⴰⵔⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ.” ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵅ ⵜⵉⵎⴻⵊⵊⴰⵔⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS10_25","007_10_25","JOS","10","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵛⵓⵡⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵉⵄⵇⴻⵣ ⵡⵓⵍ ⵏⵡⴻⵎ, ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⵉⵍⵉⵎ ⵜⵎⴻⵃⴹⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴳⴳ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⴰⴽ-ⴷ ⵜᵉⵜⵜⵎⴻⵏⵖⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS10_26","007_10_26","JOS","10","26","26","ⵅⴻⵏⵏⵉ ⵉⵡⵡⴻⵜ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ. ⵢⴰⵢⴻⵍ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵅⴻⵎⵙⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴰⵢⵍⴻⵏ ⵖⴰⵔ ⵜⵃⴻⵏⵢⴰ ⴰⵍⴰⵎⵉ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JS10_27","007_10_27","JOS","10","27","27","ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵓⵖⴻⴵⴰⵢ ⵏ ⵜⴼⵓⵛⵜ, ⵉⵙⵙⴻⴽⴽ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ-ⵉ-ⴷⴷ-ⴽⴽⵙⴻⵏ ⵣⵉ ⵜⵃⴻⵏⵢⴰ, ⴰⴷ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵏ ⴷⴻⴳ ⵉⴼⵔⵉ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ⵅⴻⵏⵏⵉ ⴳⴳⵉⵏ ⵜⵉⵚⵓⴹⴰⵔ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴼⵔⵉ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_28","007_10_28","JOS","10","28","28","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵇⵇⵉⴷⴰ ⵓⵛⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ, ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ. ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⴰⵇⵇⵉⴷⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_29","007_10_29","JOS","10","29","29","ⵅⴻⵏⵏⵉ ⵉⵥⵡⴰ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⴰⵇⵇⵉⴷⴰ ⵖⴰⵔ ⵍⵉⴱⵏⴰ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_30","007_10_30","JOS","10","30","30","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ. ⵉⵡⵡⴻⵜ ⵉ-ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ, ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ, ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_31","007_10_31","JOS","10","31","31","ⵅⴻⵏⵏⵉ ⵉⵥⵡⴰ ⵢⴰⵛⵓⵡⴰ ⵣⵉ ⵍⵉⴱⵏⴰ ⵖⴰⵔ ⵍⴰⵅⵉⵛ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS10_32","007_10_32","JOS","10","32","32","ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵍⴰⵅⵉⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ, ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ-ⵜⵜ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_33","007_10_33","JOS","10","33","33","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵀⵓⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵣⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵄⴰⵡⴻⵏ ⵍⴰⵅⵉⵛ, ⵎⴰⵛⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_34","007_10_34","JOS","10","34","34","ⵢⴰⵛⵓⵡⴰ ⵉⵥⵡⴰ ⵣⵉ ⵍⴰⵅⵉⵛ ⵖⴰⵔ ⵄⴰⵊⵍⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵓⵛⴰ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS10_35","007_10_35","JOS","10","35","35","ⵟⵟⴼⴻⵏ ⵜⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓⵛⴰ ⵡⵜⵉⵏ ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵃⴰⵔⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ, ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵍⴰⵅⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("JS10_36","007_10_36","JOS","10","36","36","ⵉⵥⵡⴰ ⵢⴰⵛⵓⵡⴰ ⵣⵉ ⵄⴰⵊⵍⵓⵏ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ, ⵓⵛⴰ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS10_37","007_10_37","JOS","10","37","37","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜⵜ ⵓⵛⴰ ⵡⵜⵉⵏ ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ, ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵄⴰⵊⵍⵓⵏ. ⵏⴻⵜⵜⴰ ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS10_38","007_10_38","JOS","10","38","38","ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵢⴰⵛⵓⵡⴰ ⵖⴰⵔ ⴷⴰⴱⵉⵔ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS10_39","007_10_39","JOS","10","39","39","ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵓ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵃⴰⵔⵔⵎⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵃⴰⴱⵔⵓⵏ, ⴰⵎⵎⵓ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⴷⴰⴱⵉⵔ ⵓ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JS10_40","007_10_40","JOS","10","40","40","ⴰⵎⵎⵓ ⵉ ⵉⵖⵍⴻⴱ ⵢⴰⵛⵓⵡⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ: ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ. ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵏⵏⴻⴼⵙ, ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜ ⵉ ⵓⵜⴻⵃⵃⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_41","007_10_41","JOS","10","41","41","ⵢⴰⵛⵓⵡⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜⴻⵏ ⵣⵉ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ ⴰⵍ ⵖⴰⵣⵣⴰ ⵓ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ, ⴰⵍ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS10_42","007_10_42","JOS","10","42","42","ⵉⵟⵟⴻⴼ ⵢⴰⵛⵓⵡⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS10_43","007_10_43","JOS","10","43","43","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵢⴰⵛⵓⵡⴰ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵊⵉⵍⵊⴰⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS11_1","007_11_1","JOS","11","1","1","ⵓⵎⵉ ⵢⴰⴱⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵚⵓⵔ, ⵉⵙⵍⴰ ⴰⵢⴰ, ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵢⵓⴱⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⴰⴷⵓⵏ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵉⵎⵔⵓⵏ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⴽⵛⴰⴼ, ");
INSERT INTO rift_vpl VALUES ("JS11_2","007_11_2","JOS","11","2","2","ⵓ ⵖⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⴷⵉ ⵍⴻⵡⴹⴰ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵣⵉ ⴽⵉⵏⵏⴰⵔⵓⵜ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⵓ ⵅ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵏ ⴷⵓⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ");
INSERT INTO rift_vpl VALUES ("JS11_3","007_11_3","JOS","11","3","3","ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵇ ⴷ ⵍⵖⴰⵔⴱ, ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ, ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵓⴹⴰⵔ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵉⵔⵎⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JS11_4","007_11_4","JOS","11","4","4","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⴳⴻⵏⵙ, ⴰⵎ ⵢⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵏⴻⵛⵜ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⴰⵔⵏⵉ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS11_5","007_11_5","JOS","11","5","5","ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ, ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵊⵎⵉⵄ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵢⵔⵓⵎ ⵉ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ.* ");
INSERT INTO rift_vpl VALUES ("JS11_6","007_11_6","JOS","11","6","6","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵎⵉⵏⵣⵉ ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⴰⵎⵎⵓ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⵜⵜⵡⴰⵖⴻⵍⴱⴻⵏ ⵎⴰⵔⵔⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵛⴻⴽ ⴰⴷ ⵜⵇⴻⵙⵙⴻⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS11_7","007_11_7","JOS","11","7","7","ⵢⴰⵛⵓⵡⴰ ⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⴰⴽⵉⴷⴻⵙ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵍⵖⴻⴼⵍⴻⵜ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵢⵔⵓⵎ ⵓⵛⴰ ⵡⴹⴰⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS11_8","007_11_8","JOS","11","8","8","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵜⴻⵏ, ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⴰⵍ ⵚⵉⴷⵓⵏ-ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵎⵉⵙⵔⴰⴼⵓⵜ-ⵎⴰⵢⵉⵎ, ⵓ ⴰⵍ ⵜⴰⵢⵙⴰⵔⵜ ⵏ ⵎⵉⵚⴼⴰ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵏⵉⵜⵏⵉ ⵇⴹⴰⵏ ⵜⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵊⵊⵉⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS11_9","007_11_9","JOS","11","9","9","ⵢⴰⵛⵓⵡⴰ ⵉⴳⴳⴰ ⴰⴽⵉⴷⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⵇⴻⵙⵙ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JS11_10","007_11_10","JOS","11","10","10","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵃⴰⵚⵓⵔ ⵓⵛⴰ ⵉⵡⵜⴰ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵎⵉⵏⵣⵉ ⵃⴰⵚⵓⵔ ⵜⵓⵖⴰ-ⵜ ⵇⴱⴻⵍ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS11_11","007_11_11","JOS","11","11","11","ⵡⵜⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵃⴰⵔⵔⵎⴻⵏ ⵜⴻⵏ ⵓ ⵏⵖⵉⵏ ⵜⴻⵏ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵏⵏⴻⴼⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵃⴰⵚⵓⵔ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JS11_12","007_11_12","JOS","11","12","12","ⵉⵟⵟⴻⴼ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ ⵙ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS11_13","007_11_13","JOS","11","13","13","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵡⴰⵔ ⵜⴻⵏⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵎⵖⵉⵔ ⵃⴰⵚⵓⵔ ⵓⵎⵉ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵢⴰⵛⵓⵡⴰ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JS11_14","007_11_14","JOS","11","14","14","ⴽⴻⵛⵛⴹⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵜⴻⵃⵃⴰⵏ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴰⵔⴰⵏ ⵏⵏⴻⴼⵙ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵊⵊⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS11_15","007_11_15","JOS","11","15","15","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵎⵓⵙⴰ, ⴰⵎⵎⵓ ⵉ ⵜ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵅ ⵢⴰⵛⵓⵡⴰ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ-ⵜ ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵎⵉⵃ ⵓⵍⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("JS11_16","007_11_16","JOS","11","16","16","ⴰⵎⵎⵓ ⵉⵟⵟⴻⴼ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ: ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵓⵛⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⴷ ⵍⴻⵡⴹⴰ ⴷ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵍⵡⴰⵟⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JS11_17","007_11_17","JOS","11","17","17","ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⴷ ⴰⵇⴻⵛⵛⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⵙⴰⵄⵉⵔ ⴰⵍ ⴱⴰⵄⵍ-ⵊⴰⴷ, ⴷⵉ ⵜⴻⵢⵙⴰⵔⵜ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⵉⵔⵎⵓⵏ. ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵉⵃⴻⴱⴱⴻⵙ ⵉ-ⵜⴻⵏ, ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS11_18","007_11_18","JOS","11","18","18","ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵉⵎⵎⵏⴻⵖ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS11_19","007_11_19","JOS","11","19","19","ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵉⴳⴳⵉⵏ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵖⵉⵔ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵊⵉⴱⵄⵓⵏ. ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵙ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JS11_20","007_11_20","JOS","11","20","20","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏⵙⴻⵏ ⴰⵍ ⴷⴷ ⵖⴰ ⴼⴼⵖⴻⵏ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵃⴰⵔⵔⴻⵎ ⵓⵛⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵢⴰⵔⴻⵃⵃⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵇⴹⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS11_21","007_11_21","JOS","11","21","21","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⵉⵜⴻⵃⵃⴰ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵣⵉ ⵃⴰⴱⵔⵓⵏ, ⵣⵉ ⴷⴰⴱⵉⵔ, ⵣⵉ ⵄⴰⵏⴰⴱ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵢⴰⵛⵓⵡⴰ ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("JS11_22","007_11_22","JOS","11","22","22","ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ. ⵇⵇⵉⵎⴻⵏ ⵎⵖⵉⵔ ⴷⵉ ⵖⴰⵣⵣⴰ, ⵊⴰⵜ ⴷ ⴰⵛⴷⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("JS11_23","007_11_23","JOS","11","23","23","ⵉⵟⵟⴻⴼ ⵢⴰⵛⵓⵡⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⵓⵙⴰ, ⵓⵛⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴰⵔⴻⵢⵢⴻⵃ ⵣⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JS12_1","007_12_1","JOS","12","1","1","ⵉⵏⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵅ ⵖⴻⵍⴱⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵖⵉⵔⵉⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⵉ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ ⴰⵍ ⵉⴷⵓⵔⴰⵔ ⵏ ⵃⵉⵔⵎⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵡⴹⴰ ⴷⵉ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("JS12_2","007_12_2","JOS","12","2","2","ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏⵙⴻⵏ, ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ, ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅ ⵊⵊⵡⴰⵢⴻⵀ ⵣⵉ ⵄⴰⵔⵓⵄⵉⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ, ⴰⵍ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵖⵣⴰⵔⵜ, ⵓ ⵅ ⵡⴻⵣⵢⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⴰⵍ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵢⴰⴱⴱⵓⵇ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("JS12_3","007_12_3","JOS","12","3","3","ⵓ ⵅ ⵍⴻⵡⴹⴰ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⴽⵉⵏⵏⴰⵔⵓⵜ ⴷⵉ ⵛⵛⴰⵔⵇ ⵓ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⴻⵡⴹⴰ, ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ, ⴷⵉ ⵛⵛⴰⵔⵇ, ⴰⴱⵔⵉⴷ ⵏ ⴱⴰⵢⵜ-ⵢⴰⵛⵉⵎⵓⵜ, ⵓ ⵣⵉ ⵍⵊⴰⵏⵓⴱ ⴰⵍ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵜⴻⵢⵙⴰⵔⵉⵏ ⵏ ⴼⵉⵙⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("JS12_4","007_12_4","JOS","12","4","4","ⵅⴻⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ, ⵊⵡⴰⵀⴻⵍ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵄⴰⵛⵜⴰⵔⵓⵜ ⴷ ⵉⴷⵔⴰⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("JS12_5","007_12_5","JOS","12","5","5","ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵃⵉⵔⵎⵓⵏ, ⵅ ⵙⴰⵍⵅⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⴱⴰⵛⴰⵏ ⴰⵍ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⵊⴰⵛⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴰⵄⴽⵉⵢⵢⴻⵏ ⵓ ⵅ ⵡⴻⵣⵢⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS12_6","007_12_6","JOS","12","6","6","ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⵜⵉⵏ ⵜⴻⵏ ⵓ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⵓ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS12_7","007_12_7","JOS","12","7","7","ⵉⵏⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵏⵉ ⵅ ⵉⵖⵍⴻⴱ ⵢⴰⵛⵓⵡⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷⵉ ⵍⵖⴰⵔⴱ, ⵣⵉ ⴱⴰⵄⵍ-ⵊⴰⴷ ⴷⵉ ⵜⴻⵢⵙⴰⵔⵜ ⵏ ⵍⵓⴱⵏⴰⵏ ⴰⵍ ⴰⴷⵔⴰⵔ ⴰⵇⴻⵛⵛⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵙⴰⵄⵉⵔ. ⵓⵛⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS12_8","007_12_8","JOS","12","8","8","ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⵓ ⴷⵉ ⵍⴻⵡⴹⴰ ⵓ ⴷⵉ ⵜⴻⵢⵙⴰⵔⵉⵏ ⵓ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ: ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⴼⴰⵔⵉⵣⵉⵢⵢⴻⵏ, ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS12_9","007_12_9","JOS","12","9","9","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⵉⵃⴰ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵢ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴱⴰⵢⵜ-ⵉⵍ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_10","007_12_10","JOS","12","10","10","ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵔⵛⴰⵍⵉⵎ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⴱⵔⵓⵏ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_11","007_12_11","JOS","12","11","11","ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵔⵎⵓⵜ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴰⵅⵉⵛ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_12","007_12_12","JOS","12","12","12","ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵊⵍⵓⵏ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵣⴰⵔ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_13","007_12_13","JOS","12","13","13","ⴰⵊⴻⴵⵉⴷ ⵏ ⴷⴰⴱⵉⵔ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⴷⴰⵔ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_14","007_12_14","JOS","12","14","14","ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⵓⵔⵎⴰ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵔⴰⴷ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_15","007_12_15","JOS","12","15","15","ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⵉⴱⵏⴰ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⴷⵓⵍⵍⴰⵎ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_16","007_12_16","JOS","12","16","16","ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⴰⵇⵇⵉⴷⴰ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵢⵜ-ⵉⵍ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_17","007_12_17","JOS","12","17","17","ⴰⵊⴻⴵⵉⴷ ⵏ ⵜⴰⴼⴼⵓⵃ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⴼⴰⵔ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_18","007_12_18","JOS","12","18","18","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⴼⵉⵇ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴰⵛⵛⴰⵔⵓⵏ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_19","007_12_19","JOS","12","19","19","ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⴰⴷⵓⵏ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵚⵓⵔ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_20","007_12_20","JOS","12","20","20","ⴰⵊⴻⴵⵉⴷ ⵏ ⵛⵉⵎⵔⵓⵏ-ⵎⴰⵔⴰ’ⵓⵏ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⴽⵛⴰⴼ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_21","007_12_21","JOS","12","21","21","ⴰⵊⴻⴵⵉⴷ ⵏ ⵜⴰⵄⵏⴰⴽ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⴰⵊⵉⴷⴷⵓ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_22","007_12_22","JOS","12","22","22","ⴰⵊⴻⴵⵉⴷ ⵏ ⵇⴰⴷⴰⵛ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⵓⵇⵏⴰⵄⴰⵎ ⵖⴰⵔ ⴽⴰⵔⵎⴰⵍ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_23","007_12_23","JOS","12","23","23","ⴰⵊⴻⴵⵉⴷ ⵏ ⴷⵓⵔ ⵅ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵖⴰⵔ ⴷⵓⵔ: ⴷ ⵉⵊⵊ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⵓⵢⵉⵎ ⴷⵉ ⵊⵉⵍⵊⴰⵍ: ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JS12_24","007_12_24","JOS","12","24","24","ⴰⵊⴻⴵⵉⴷ ⵏ ⵜⵉⵔⵚⴰ: ⴷ ⵉⵊⵊ. ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵡⴰⵃⵉⵜ ⵓ-ⵜⵍⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_1","007_13_1","JOS","13","1","1","ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵛⵓⵡⴰ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⵓⵛⴰ ⵉⵎⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵛⴻⴽ ⵜⴻⵡⵙⴰⵔⴻⴷ ⵓ ⵜⴻⵎⵖⴰⵔⴻⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⵄⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS13_2","007_13_2","JOS","13","2","2","ⵜⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵇⵇⵉⵎⴻⵏ: ⵎⴰⵔⵔⴰ ⵉⴷⵓⵡⵡⴰⵔⴻⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵉⵊⴰⵛⵓⵔⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS13_3","007_13_3","JOS","13","3","3","ⵣⴻⴳ ⵢⴻⵖⵣⴰⵔ ⵏ ⵛⵉⵃⵓⵔ ⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵄⵉⵇⵔⵓⵏ ⴷⵉ ⵛⵛⴰⵎⴰⵍ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ-ⴷⴷ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴷⴰⵢⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵖⴰⵣⵉ ⴷ ⴰⵛⴷⵓⴷⵉ ⴷ ⴰⵛⵇⴰⵍⵓⵏⵉ, ⴰⵊⵉⵜⵜⵉ, ⴷ ⴰⵄⴰⵇⵔⵓⵏⵉ, ⴷ ⵉⵄⴰⵡⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS13_4","007_13_4","JOS","13","4","4","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵣⵉ ⵍⵊⴰⵏⵓⴱ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵎⵓⵖⴰⵔⴰ ⵜⴻⵏⵏⵉ ⵏ ⵉⵚⵉⴷⵓⵏⵉⵢⵢⴻⵏ, ⴰⵍ ⴰⴼⵉⵇ ⵓ ⴰⵍ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JS13_5","007_13_5","JOS","13","5","5","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵊⵉⴱⵍⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵓⴱⵏⴰⵏ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵣⵉ ⴱⴰⵄⵍ-ⵊⴰⴷ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⵉⵔⵎⵓⵏ ⴰⵍ ⵎⴰⵏⵉ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔ ⵃⴰⵎⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("JS13_6","007_13_6","JOS","13","6","6","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⴰⵍ ⵎⵉⵙⵔⴰⴼⵓⵜ-ⵎⴰⵢⵉⵎ, ⵎⴰⵔⵔⴰ ⵉⵚⵉⴷⵓⵏⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵥⵥⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴻⴳⴳ ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵀⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ.” * ");
INSERT INTO rift_vpl VALUES ("JS13_7","007_13_7","JOS","13","7","7","“ⴱⴹⴰ ⵍⴻⵅⵅⵓ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴷ ⵍⵡⴰⵔⵜ ⵊⴰⵔ ⵜⴻⵙⵄⴰ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS13_8","007_13_8","JOS","13","8","8","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵏⵏⵉ ⵉⴽⵙⵉⵏ ⴰⴽ-ⴷ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷⵉ ⵛⵛⴰⵔⵇ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵜⵜ ⵉⵡⵛⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("JS13_9","007_13_9","JOS","13","9","9","ⵣⵉ ⴰⵔⵓⵄⵉⵔ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴰ ⵏ ⴰⵔⵏⵓⵏ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ ⵣⵉ ⵎⵉⵢⴷⴰⴱⴰ ⴰⵍ ⴷⵉⴱⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("JS13_10","007_13_10","JOS","13","10","10","ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ, ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ");
INSERT INTO rift_vpl VALUES ("JS13_11","007_13_11","JOS","13","11","11","ⵓⵍⴰ ⴷ ⵊⵉⵍⵄⴰⴷ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵊⴰⵛⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴰⵄⴽⵉⵢⵢⴻⵏ ⴷ ⵇⴰⵄ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⵉⵔⵎⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⴱⴰⵛⴰⵏ ⴰⵍ ⵙⴰⵍⵅⴰ, ");
INSERT INTO rift_vpl VALUES ("JS13_12","007_13_12","JOS","13","12","12","ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ, ⴷⵉ ⴱⴰⵛⴰⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷⵉ ⵄⴰⵛⵜⴰⵔⵓⵜ ⴷ ⵉⴷⵔⴰⵄⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵣⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⵎⵓⵙⴰ ⵓⵛⴰ ⵢⵓⵥⵥⴻⵍ ⵅⴰⵙⴻⵏ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_13","007_13_13","JOS","13","13","13","ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵓⵥⵥⵍⴻⵏ ⵅ ⴰⵢⵜ ⵏ ⵉⵊⴰⵛⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴰⵄⴽⵉⵢⵢⴻⵏ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ⵊⴰⵛⵓⵔ ⴷ ⵎⴰⵄⴽⴰⵜ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS13_14","007_13_14","JOS","13","14","14","ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ ⵡⴰⵀⴰ ⵓⵎⵉ ⵉ ⵡⴰⵔ ⵉⵡⵛⵉ ⵜⴰⵙⵖⴰⵔⵜ. ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JS13_15","007_13_15","JOS","13","15","15","ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_16","007_13_16","JOS","13","16","16","ⵉ ⵏⵉⵜⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵜⴻⴽⴽⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵔⵓⵄⵉⵔ, ⵜⴻⵏⵏⵉ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ ⴰⵍ ⵎⵉⴷⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JS13_17","007_13_17","JOS","13","17","17","ⵃⴰⵛⴱⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ: ⴷⵉⴱⵓⵏ, ⴱⴰⵎⵓⵜ-ⴱⴰⵄⵍ ⴷ ⴱⴰⵢⵜ-ⴱⴰⵄⵍ-ⵎⴰⵄⵓⵏ ");
INSERT INTO rift_vpl VALUES ("JS13_18","007_13_18","JOS","13","18","18","ⴷ ⵢⴰⵀⵚⴰ ⴷ ⵇⴰⴷⵉⵎⵓⵜ ⴷ ⵎⴰⵢⴼⴰⵄⴰ ");
INSERT INTO rift_vpl VALUES ("JS13_19","007_13_19","JOS","13","19","19","ⴷ ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ ⴷ ⵙⵉⴱⵎⴰ ⴷ ⵚⴰⵔⴰⵜ-ⵀⴰ-ⵛⴰⵃⴰⵔ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("JS13_20","007_13_20","JOS","13","20","20","ⴷ ⴱⴰⵢⵜ-ⴼⴰⵖⵓⵔ ⴷ ⵜⵉⵙⴰⵡⵏⵉⵏ ⵏ ⴼⵉⵙⵊⴰ ⴷ ⴱⴰⵢⵜ-ⵢⴰⵛⵉⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("JS13_21","007_13_21","JOS","13","21","21","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵅ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷⵉ ⵃⴰⵛⴱⵓⵏ, ⵉ ⵅ ⵉⵖⵍⴻⴱ ⵎⵓⵙⴰ, ⴰⵎ ⵉⵖⵍⴻⴱ ⵓⵍⴰ ⵅ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵉⴷⵢⴰⵏ: ⴰⵡⵉ ⴷ ⵔⴰⵇⴰⵎ ⴷ ⵚⵓⵔ ⴷ ⵃⵓⵔ ⴷ ⵔⴰⴱⴰⵄ, ⵉⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵚⵉⵀⵓⵏ ⵊⵊⴻⵀⴷ ⴰⴽⵉⴷⴻⵙ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS13_22","007_13_22","JOS","13","22","22","ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴷⵉ ⴳⴰⵔⵔⴰ, ⵏⵖⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⴰⵡⴻⴷ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⴰⴳⴻⵣⵣⴰⵏ, ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JS13_23","007_13_23","JOS","13","23","23","ⵜⵓⵖⴰ ⵍ’ⵓⵔⴷⵓⵏ ⴰⴽ-ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵙ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵜⵎⴰ ⵏⵏⴻⵙ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_24","007_13_24","JOS","13","24","24","ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ, ⵉ ⴰⵢⵜ ⵏ ⵊⴰⴷ, ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_25","007_13_25","JOS","13","25","25","ⵉ ⵏⵉⵜⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵜⴻⴽⴽⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵄⴰⵣⵉⵔ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵊⵉⵍⵄⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴰⵍ ⴰⵔⵓⵄⵉⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵔⴰⴱⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("JS13_26","007_13_26","JOS","13","26","26","ⵣⵉ ⵃⴰⵛⴱⵓⵏ ⴰⵍ ⵔⴰⵎⴰⵜ-ⵎⵉⵚⴼⴰ ⴷ ⴱⵓⵟⵓⵏⵉⵎ, ⵓ ⵣⵉ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⴷⴰⴱⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("JS13_27","007_13_27","JOS","13","27","27","ⵓ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ: ⴱⴰⵢⵜ-ⵀⴰⵔⴰⵎ ⴷ ⴱⴰⵢⵜ-ⵏⵉⵎⵔⴰ ⴷ ⵙⵓⴽⴽⵓⵜ ⴷ ⵚⴰⴼⵓⵏ ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ, ⵍ’ⵓⵔⴷⵓⵏ ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵙ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⴽⵉⵏⵏⴰⵔⴰⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("JS13_28","007_13_28","JOS","13","28","28","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⴷ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS13_29","007_13_29","JOS","13","29","29","ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_30","007_13_30","JOS","13","30","30","ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ: ⵎⴰⵔⵔⴰ ⴱⴰⵛⴰⵏ, ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⴷ ⵎⴰⵔⵔⴰ ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰ’ⵉⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⵛⴰⵏ, ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS13_31","007_13_31","JOS","13","31","31","ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⴷ ⵄⴰⵛⵜⴰⵔⵓⵜ ⴷ ⵉⴷⵔⵉⵄⵉ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵄⵓⵊ ⴷⵉ ⴱⴰⵛⴰⵏ, ⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⵅⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⴰⵇⴰ ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⵅⵉⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS13_32","007_13_32","JOS","13","32","32","ⵜⵉⵏⴰ ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⵜⵓⵖⴰ ⵉⴱⴹⴰ ⵎⵓⵙⴰ ⴷ ⵍⵡⴰⵔⵜ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⴰⵔⵉⵃⴰ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("JS13_33","007_13_33","JOS","13","33","33","ⵎⴰⵛⴰ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵡⵛⵉ ⵎⵓⵙⴰ ⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS14_1","007_14_1","JOS","14","1","1","ⵜⵉⵏⴰ ⴷ ⵜⵙⴻⵇⵇⴰⵔ ⵉ ⵟⵟⴼⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⵉⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⴱⴹⴰ ⴷ ⵍⵡⴰⵔⵜ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS14_2","007_14_2","JOS","14","2","2","ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵟⵟⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴻⵙⵄⴰ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("JS14_3","007_14_3","JOS","14","3","3","ⵎⴰⵖⴰⵔ ⵎⵓⵙⴰ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴰⵖⵉⵔⵉⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ, ⵎⴰⵛⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⵉ ⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS14_4","007_14_4","JOS","14","4","4","ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ ⴳⴳⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ, ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ, ⵓ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵡⵛⵉⵏ ⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜⵙⴻⵏⵜ ⵏ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵉ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS14_5","007_14_5","JOS","14","5","5","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵍⴰⵎⵉ ⴱⴹⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS14_6","007_14_6","JOS","14","6","6","ⵅⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴷⵉ ⵊⵉⵍⵊⴰⵍ. ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⴰⵇⵉⵏⵉⵣⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵉⵏ ⵅⴰⴼⵉ ⴷ ⵅⴰⴽ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷⵉ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JS14_7","007_14_7","JOS","14","7","7","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉ ⴷⴷ ⴰⵢⵉ ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵏⴻⵛⵛ ⵄⴻⵇⴱⴻⵖ ⵖⴰⵔⴻⵙ, ⵅⴻⴱⴱⴰⵔⴻⵖ ⴰⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JS14_8","007_14_8","JOS","14","8","8","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⵢⵜⵎⴰ, ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⵉⴳⴻⵄⵄⴷⴻⵏ, ⵙⵙⴼⴻⵙⵙⵢⴻⵏ ⵓⵍ ⵏ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵍⴻⴱⴷⴰ ⴹⴻⴼⴼⴰⵔⴻⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JS14_9","007_14_9","JOS","14","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵎⵓⵙⴰ, ⵉⵏⵏⴰ: “ⵡⴰⵢⵢⴰⵡ, ⵎⴰⵍⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷⵉ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴰⴹⴰⵔ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵉ ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⵍⴻⴱⴷⴰ ⵜⴹⴻⴼⴼⴰⵔⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("JS14_10","007_14_10","JOS","14","10","10","ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵊⵊⴰ ⴰⵢⵉ ⴷⴷⴰⵔⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ. ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⵓⵙⴰ ⴰⵡⴰⵍ-ⴰ, ⵓⵎⵉ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴷⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ, ⵖⴰⵔⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS14_11","007_14_11","JOS","14","11","11","ⵏⴻⵛⵛ ⵄⴰⴷ ⵎⴻⵃⴹⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴻⵃⴹⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓⵎⵉ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵎⵓⵙⴰ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵊⴻⵀⵀⴷⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵊⴻⵀⵀⴷⴻⵖ ⵄⴰⵡⴻⴷ ⵉⴹⴰ ⵉ ⵓⵎⴻⵏⵖⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴼⵖⴻⵖ ⵓ ⴰⴷ ⴰⵔⴻⴳⴳⵯⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JS14_12","007_14_12","JOS","14","12","12","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴻⵡⵛ ⴰⵢⵉ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵏ ⵉⴷⵓⵔⴰⵔ ⵉ ⵅ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉⵏⵏⵉ ⵓⵍⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵎⵖⴰⵔⴻⵏⵜ ⵓ ⴼⴰⵔⵢⴻⵏⵜ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴽⵉⴷⵉ ⵢⵉⵍⵉ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵡⴹⴻⵖ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵥⵥⵍⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS14_13","007_14_13","JOS","14","13","13","ⵅⴻⵏⵏⵉ ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ ⵢⴰⵛⵓⵡⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⵃⴰⴱⵔⵓⵏ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JS14_14","007_14_14","JOS","14","14","14","ⵅ ⵓⵢⴰ ⵜⴻⴵⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵃⴰⴱⵔⵓⵏ ⴷ ⵍⵡⴰⵔⵜ ⵏ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⴰⵇⵉⵏⵉⵣⵉ, ⴰⵍ ⴰⵙⵙ-ⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵍⴻⴱⴷⴰ ⵉⴹⴻⴼⴼⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS14_15","007_14_15","JOS","14","15","15","ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵣⵉⵛ ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴱⴰⵄ’. ⵜⵓⵖⴰ ⴰⵔⴱⴰⵄ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⴻⴳ ⴰⵢⵜ ⵏ ⵉⵄⴰⵏⴰⵇⵉⵢⵢⴻⵏ. ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⵀⵓⴷⵏⴻⵜ ⵣⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JS15_1","007_15_1","JOS","15","1","1","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⴻⴽⴽⴰⵔ-ⴰⵙⴻⵏⵜ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⴷⵓⵎ, ⵍⴻⵅⵍⴰ ⵏ ⵚⵉⵏ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⴰⵍ ⵍⵊⴰⵏⵓⴱ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JS15_2","007_15_2","JOS","15","2","2","ⴰⵢⵎⵉⵔ ⵏ ⵍⵊⴰⵏⵓⴱ ⵜⵓⵖⴰ-ⵜ ⵉ ⵏⵉⵜⵏⵉ ⵣⵉ ⵎⴰⵏⵉⵙ ⵉⵇⴻⵟⵟⴰ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ, ⵣⴻⴳ ⵢⵉⵍⴻⵙ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("JS15_3","007_15_3","JOS","15","3","3","ⵓⵛⴰ ⵉⵄⴻⴷⴷⵓ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⵙⵓⵏⵜⴰ ⵏ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ ⵓⵛⴰ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵚⵉⵏ ⵓⵛⴰ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵍⵊⴰⵏⵓⴱ ⵏ ⵇⴰⴷⴰⵛ-ⴱⴰⵔⵏⵉⵄ, ⵉⵜⵜⴻⴽⴽ ⵅ ⵃⴰⵚⵔⵓⵏ ⵓ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵖⴰⵔ ⴰⴷⴷⴰⵔ ⵓⵛⴰ ⵉⴷⴻⴽⴽⵡⴰⵍ ⵖⴰⵔ ⵇⴰⵔⵇⴰⵄ ");
INSERT INTO rift_vpl VALUES ("JS15_4","007_15_4","JOS","15","4","4","ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴻⴽⴽ ⵅ ⵄⴰⵚⵎⵓⵏ ⵓ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏ ⵡⴻⵢⵎⵉⵔ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ. ⵡⴰ ⴰⵇⴰ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵍⵊⴰⵏⵓⴱ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JS15_5","007_15_5","JOS","15","5","5","ⴰⵢⵎⵉⵔ ⵏ ⵛⵛⴰⵔⵇ ⴰⵇⴰ-ⵜ ⴷ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ ⵖⴰⵔ ⵇⴻⵟⵟⵓ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⴰⵢⵎⵉⵔ ⵏ ⵛⵛⴰⵎⴰⵍ ⵣⴻⴳ ⵢⵉⵍⴻⵙ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵣⵉ ⵎⴰⵏⵉⵙ ⵉⵇⴻⵟⵟⴰ ⵍ’ⵓⵔⴷⵓⵏ ");
INSERT INTO rift_vpl VALUES ("JS15_6","007_15_6","JOS","15","6","6","ⵓ ⵙⵙⴻⵏⵏⵉ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵃⵓⵊⵍⴰ ⵓⵛⴰ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵏ ⴱⴰⵢⵜ-ⵄⴰⵔⴰⴱⴰ ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⴰⵍ ⵡⴻⵥⵔⵓ ⵏ ⴱⵓⵀⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵔⵓⴱⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("JS15_7","007_15_7","JOS","15","7","7","ⵓⵛⴰ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⴷⴰⴱⵉⵔ ⵣⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⴰⵅⵓⵔ ⵓ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⴰⴷⵓⵎⵎⵉⵎ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵓ ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵄⴰⵢⵏ-ⵛⴰⵎⵛ ⵓⵛⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵄⴰⵢⵏ-ⵔⵓⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JS15_8","007_15_8","JOS","15","8","8","ⵣⵉ ⵙⵙⴰ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵏ ⵓⵢⴰⴱⵓⵙⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵓ ⴰⵢⵎⵉⵔ ⵢⴰⵔⴻⵏⵏⵉ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS15_9","007_15_9","JOS","15","9","9","ⵣⵉ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵉⵎⵎⴰⵔⵙ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵏⴻⴼⵜⵓⵃⴰ ⵓ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⵓⵏ ⵓ ⵅⴻⵏⵏⵉ ⵉⵎⵎⴰⵔⵙ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⴱⴰⵄⴰⵍⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JS15_10","007_15_10","JOS","15","10","10","ⵣⵉ ⴱⴰⵄⴰⵍⴰ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⵓⵛⴰ ⵉⵄⴻⴷⴷⵓ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵢⴰⵄⴰⵔⵉⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴽⴰⵙⴰⵍⵓⵏ, ⵓⵛⴰ ⵉⵀⴻⴽⴽⵡⴰ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵓ ⵉⵜⵜⴻⴽⴽ ⵅ ⵜⵉⵎⵏⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("JS15_11","007_15_11","JOS","15","11","11","ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵄⴰⵇⵔⵓⵏ. ⵅⴻⵏⵏⵉ ⵉⵎⵎⴰⵔⵙ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵛⴰⴽⵔⵓⵏ ⵓ ⵉⵜⵜⴻⴽⴽ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⴱⴰⵄⵍⴰ ⵓ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵢⴰⴱⵏⵉⵢⵉⵍ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏ ⵡⴻⵢⵎⵉⵔ ⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS15_12","007_15_12","JOS","15","12","12","ⴰⵢⵎⵉⵔ ⵏ ⵍⵖⴰⵔⴱ ⵉⵄⴻⴷⴷⵓ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵡⴰ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS15_13","007_15_13","JOS","15","13","13","ⵎⴰⵛⴰ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⵉⵡⵛⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵢⴰⵛⵓⵡⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴱⴰⵄ. ⴰⵔⴱⴰⵄ ⵜⵓⵖⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵄⴰⵏⴰⵇ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS15_14","007_15_14","JOS","15","14","14","ⵢⵓⵥⵥⴻⵍ ⴽⴰⵍⵉⴱ ⵙⵙⴻⵏⵏⵉ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵏⴰⵇ: ⵛⵉⵛⴰⵢ, ⴰⵅⵉⵎⴰⵏ ⵓ ⵜⴰⵍⵎⴰⵢ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵉ ⵄⴰⵏⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("JS15_15","007_15_15","JOS","15","15","15","ⵙⵙⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴰⴱⵉⵔ. ⴷⴰⴱⵉⵔ ⵜⵓⵖⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵣⵉⵛ: ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵙⵉⴼⵔ. ");
INSERT INTO rift_vpl VALUES ("JS15_16","007_15_16","JOS","15","16","16","ⵉⵏⵏⴰ ⴽⴰⵍⵉⴱ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵙⵉⴼⵔ ⴰⴷ ⵜⵜ ⵉⵟⵟⴻⴼ, ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵢⴻⴵⵉ ⴰⵅⵙⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("JS15_17","007_15_17","JOS","15","17","17","ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵏⴰⵣ, ⵓⵎⴰⵙ ⵏ ⴽⴰⵍⵉⴱ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵓ ⴽⴰⵍⵉⴱ ⵉⵡⵛⴰ ⴰⵙ ⵢⴻⴵⵉⵙ ⴰⵅⵙⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_18","007_15_18","JOS","15","18","18","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵜⴰⵔⵔⴰ ⵉ-ⵜ ⴰⴷ ⵉⵜⵜⴰⵔ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵅ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵜⴻⴹⵔⴰ ⵅ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ. ⴽⴰⵍⵉⴱ ⵉⵙⵙⴻⵇⵙⴰ ⵜⵜ: “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ?”    ");
INSERT INTO rift_vpl VALUES ("JS15_19","007_15_19","JOS","15","19","19","ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ: “ⴻⵡⵛ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵓⵥⴻⵖ, ⵅⴻⵏⵏⵉ ⴻⵡⵛ ⴰⵢⵉ ⵓⵍⴰ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ!” ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵏⵏⴻⵊ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS15_20","007_15_20","JOS","15","20","20","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS15_21","007_15_21","JOS","15","21","21","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⴰⴽ-ⴷ ⵉⴷⵓⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ: ⵇⴰⴱⵚⵉⵢⵉⵍ ⴷ ⵄⵉⴷⴰⵔ ⴷ ⵢⴰⵊⵓⵔ ");
INSERT INTO rift_vpl VALUES ("JS15_22","007_15_22","JOS","15","22","22","ⴷ ⵇⵉⵏⴰ ⴷ ⴷⵉⵎⵓⵏⴰ ⴷ ⵄⴰⴷⴰⴷⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_23","007_15_23","JOS","15","23","23","ⴷ ⵇⴰⴷⴰⵛ ⴷ ⵃⴰⵚⵓⵔ ⴷ ⵢⵉⵜⵏⴰⵏ ");
INSERT INTO rift_vpl VALUES ("JS15_24","007_15_24","JOS","15","24","24","ⴷ ⵣⵉⴼ ⴷ ⵟⴰⵍⴰⵎ ⴷ ⴱⴰⵄⵍⵓⵜ ");
INSERT INTO rift_vpl VALUES ("JS15_25","007_15_25","JOS","15","25","25","ⴷ ⵃⴰⵚⵓⵔ-ⵅⴰⴷⴰⵜⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵃⴰⵚⵔⵓⵏ, ⵜⴰ ⴷ ⵃⴰⵚⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JS15_26","007_15_26","JOS","15","26","26","ⵅⴻⵏⵏⵉ ⴰⵎⴰⵎ ⴷ ⵛⴰⵎⴰⵄ ⴷ ⵎⵓⵍⴰⴷⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_27","007_15_27","JOS","15","27","27","ⴷ ⵃⴰⵚⴰ-ⵊⴰⴷⴷⴰ ⴷ ⵃⴰⵛⵎⵓⵏ ⴷ ⴱⴰⵢⵜ-ⴼⴰⵍⴰⵟ ");
INSERT INTO rift_vpl VALUES ("JS15_28","007_15_28","JOS","15","28","28","ⴷ ⵃⴰⵚⴰⵔ-ⵛⵓⵄⴰⵍ ⴷ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⴷ ⴱⵉⵣⵢⵓⵜⵉⵢⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_29","007_15_29","JOS","15","29","29","ⴷ ⴱⴰⵄⵍⴰ ⴷ ⵄⴰⵢⵢⵉⵎ ⴷ ⵄⴰⵣⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("JS15_30","007_15_30","JOS","15","30","30","ⴷ ⴰⵍⵜⵓⵍⴰⴷ ⴷ ⴽⵉⵙⵉⵍ ⴷ ⵃⵓⵔⵎⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_31","007_15_31","JOS","15","31","31","ⴷ ⵚⵉⵇⵍⴰⵖ ⴷ ⵎⴰⴷⵎⴰⵏⵏⴰ ⴷ ⵙⴰⵏⵙⴰⵏⵏⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_32","007_15_32","JOS","15","32","32","ⴷ ⵍⴰⴱⴰⵢⵓⵜ ⴷ ⵛⵉⵍⵃⵉⵎ ⴷ ⵄⴰⵢⵏ ⴷ ⵔⵉⵎⵎⵓⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_33","007_15_33","JOS","15","33","33","ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ: ⵉⵛⵜⴰ’ⵓⵍ ⴷ ⵚⵓⵔⵄⴰ ⴷ ⴰⵛⵏⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_34","007_15_34","JOS","15","34","34","ⴷ ⵣⴰⵏⵓⵅ ⴷ ⵄⴰⵢⵏ-ⵊⴰⵏⵏⵉⵎ ⴷ ⵜⴰⴼⴼⵓⵃ ⴷ ⵄⴰⵢⵏⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("JS15_35","007_15_35","JOS","15","35","35","ⴷ ⵢⴰⵔⵎⵓⵜ ⴷ ⴰⴷⵓⵍⵍⴰⵎ ⴷ ⵙⵓⴽⵓ ⴷ ⴰⵣⵉⵇⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_36","007_15_36","JOS","15","36","36","ⴷ ⵛⴰⵄⴰⵔⴰⵢⵉⵎ ⴷ ⵄⴰⴷⵉⵜⴰⵢⵉⵎ ⴷ ⵊⵓⴷⴰⵢⵔⴰ ⴷ ⵊⵓⴷⴰⵢⵔⴰⵜⴰⵢⵉⵎ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_37","007_15_37","JOS","15","37","37","ⵚⴰⵏⴰⵏ ⴷ ⵃⴰⴷⴰⵛⴰ ⴷ ⵎⵉⵊⴷⴰⵍ-ⵊⴰⴷ ");
INSERT INTO rift_vpl VALUES ("JS15_38","007_15_38","JOS","15","38","38","ⴷ ⴷⵉⵍⴰⵏ ⴷ ⵎⵉⵚⴼⴰ ⴷ ⵢⴰⵇⵜⵉⵢⵉⵍ ");
INSERT INTO rift_vpl VALUES ("JS15_39","007_15_39","JOS","15","39","39","ⴷ ⵍⴰⵅⵉⵛ ⴷ ⴱⵓⵚⵇⴰⵜ ⴷ ⵄⴰⵊⵍⵓⵏ ");
INSERT INTO rift_vpl VALUES ("JS15_40","007_15_40","JOS","15","40","40","ⴷ ⴽⴰⴱⴱⵓⵏ ⴷ ⵍⴰⵃⵎⴰⵙ ⴷ ⴽⵉⵜⵍⵉⵛ ");
INSERT INTO rift_vpl VALUES ("JS15_41","007_15_41","JOS","15","41","41","ⴷ ⵊⵓⴷⴰⵢⵔⵓⵜ ⴷ ⴱⴰⵢⵜ-ⴷⴰⵊⵓⵏ ⴷ ⵏⴰⵄⴰⵎⴰ ⴷ ⵎⴰⵇⵇⴰⴷⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵙⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_42","007_15_42","JOS","15","42","42","ⵍⵉⴱⵏⴰ ⴷ ⵄⴰⵜⵉⵔ ⴷ ⵄⴰⵛⴰⵏ ");
INSERT INTO rift_vpl VALUES ("JS15_43","007_15_43","JOS","15","43","43","ⴷ ⵢⴰⴼⵜⴰⵃ ⴷ ⴰⵛⵏⴰ ⴷ ⵏⴰⵚⵉⴱ ");
INSERT INTO rift_vpl VALUES ("JS15_44","007_15_44","JOS","15","44","44","ⴷ ⵇⴰⵄⵉⵍⴰ ⴷ ⴰⴽⵙⵉⴱ ⴷ ⵎⴰⵔⵉⵛⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵙⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_45","007_15_45","JOS","15","45","45","ⵄⴰⵇⵔⵓⵏ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS15_46","007_15_46","JOS","15","46","46","ⵣⵉ ⵄⴰⵇⵔⵓⵏ ⴰⵍ ⵔⴻⴱⵃⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴰⵛⴷⵓⴷ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS15_47","007_15_47","JOS","15","47","47","ⴰⵛⴷⵓⴷ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵏⴻⵙ, ⵖⴰⵣⵣⴰ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵏⴻⵙ ⴰⵍ ⵜⴰⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS15_48","007_15_48","JOS","15","48","48","ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ: ⵛⴰⵎⵉⵔ ⴷ ⵢⴰⵜⵜⵉⵔ ⴷ ⵙⵓⴽⵓ ");
INSERT INTO rift_vpl VALUES ("JS15_49","007_15_49","JOS","15","49","49","ⴷ ⴷⴰⵏⵏⴰ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴰⵏⵏⴰ, ⵜⴰ ⴷ ⴷⴰⴱⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("JS15_50","007_15_50","JOS","15","50","50","ⴷ ⵄⴰⵏⴰⴱ ⴷ ⴰⵛⵜⵉⵎⵓ ⴷ ⵄⴰⵏⵉⵎ ");
INSERT INTO rift_vpl VALUES ("JS15_51","007_15_51","JOS","15","51","51","ⴷ ⵊⵓⵛⴰⵏ ⴷ ⵃⵓⵍⵓⵏ ⴷ ⵊⵉⵍⵓ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵃⵉⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_52","007_15_52","JOS","15","52","52","ⴰⵔⴰⴱ ⴷ ⴷⵓⵎⴰ ⴷ ⴰⵛⵄⴰⵏ ");
INSERT INTO rift_vpl VALUES ("JS15_53","007_15_53","JOS","15","53","53","ⴷ ⵢⴰⵏⵓⵎ ⴷ ⴱⴰⵢⵜ-ⵜⴰⴼⴼⵓⵃ ⴷ ⴰⴼⵉⵇⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_54","007_15_54","JOS","15","54","54","ⴷ ⵃⵓⵎⵟⴰ ⴷ ⵇⴰⵔⵢⴰⵜ-ⴰⵔⴱⴰⵄ, ⵜⴻⵏⵏⵉ ⴷ ⵃⴰⴱⵔⵓⵏ, ⴷ ⵚⴰⵄⵓⵔ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵙⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_55","007_15_55","JOS","15","55","55","ⵎⴰⵄⵓⵏ ⴷ ⴽⴰⵔⵎⴰⵍ ⴷ ⵣⵉⴼ ⴷ ⵢⵓⵟⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_56","007_15_56","JOS","15","56","56","ⴷ ⵢⵉⵣⵔⴰⵄⵉⵍ ⴷ ⵢⵓⵇⴷⴰⵄⴰⵎ ⴷ ⵣⴰⵏⵓⵃ ");
INSERT INTO rift_vpl VALUES ("JS15_57","007_15_57","JOS","15","57","57","ⴷ ⵇⴰⵢⵉⵏ ⴷ ⵊⵉⴱⵄⴰ ⴷ ⵜⵉⵎⵏⴰⵀ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵄⴻⵛⵔⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_58","007_15_58","JOS","15","58","58","ⵃⴰⵍⵃⵓⵍ ⴷ ⴱⴰⵢⵜ-ⵚⵓⵔ ⴷ ⵊⴰⴷⵓⵔ ");
INSERT INTO rift_vpl VALUES ("JS15_59","007_15_59","JOS","15","59","59","ⴷ ⵎⴰⵄⴰⵔⴰⵜ ⴷ ⴱⴰⵢⵜ-ⵄⴰⵏⵓⵜ ⴷ ⵉⵍⵜⴰⵇⵓⵏ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_60","007_15_60","JOS","15","60","60","ⵇⴰⵔⵢⴰⵜ-ⴱⴰⵄⵍ, ⴰⵇⴰ-ⵜ ⴷ ⵇⴰⵔⵢⴰⵜ-ⵢⵉⵄⴰⵔⵉⵎ ⴷ ⵔⴰⴱⴱⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_61","007_15_61","JOS","15","61","61","ⴷⵉ ⵍⴻⵅⵍⴰ ⴱⴰⵢⵜ-ⵄⴰⵔⴰⴱⴰ ⴷ ⵎⵉⴷⴷⵉⵏ ⴷ ⵙⴰⴽⴰⴽⴰ ");
INSERT INTO rift_vpl VALUES ("JS15_62","007_15_62","JOS","15","62","62","ⴷ ⵏⵉⴱⵛⴰⵏ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵎⴻⴵⴰⵃ ⴷ ⵄⴰⵢⵏ-ⵊⴰⴷⵉ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS15_63","007_15_63","JOS","15","63","63","ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵥⵥⵍⴻⵏ ⵅ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⵅ ⵓⵢⴻⵏⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵄⴰⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS16_1","007_16_1","JOS","16","1","1","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⴰⵔⵉⵃⴰ, ⵓⵛⴰ ⴰⵢⵎⵉⵔ ⵉⵜⵜⴻⴽⴽ ⵅ ⵜⵎⴰ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⴰⵔⵉⵃⴰ, ⵅ ⵍⴻⵅⵍⴰ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵣⵉ ⴰⵔⵉⵃⴰ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⴱⴰⵢⵜ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS16_2","007_16_2","JOS","16","2","2","ⵓ ⵣⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵍⵓⵣ, ⵉⵜⵜⴻⴽⴽ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴰⵔⴽⵉⵜ ⵖⴰⵔ ⵄⴰⵟⴰⵔⵓⵜ ");
INSERT INTO rift_vpl VALUES ("JS16_3","007_16_3","JOS","16","3","3","ⵓⵛⴰ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⴰⵍⴰⵟⵉⵢⵢⴻⵏ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵡⴰⴷⴷⴰⵢ ⵓ ⴰⵍ ⵊⴰⵣⴰⵔ ⵓ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS16_4","007_16_4","JOS","16","4","4","ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ, ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS16_5","007_16_5","JOS","16","5","5","ⴰⵢⵎⵉⵔ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⴷ ⵡⴰ. ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵉⴱⴻⴷⴷⴰ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⵄⴰⵟⴰⵔⵓⵜ-ⴰⴷⴰⵔ ⵓⵛⴰ ⵉⴳⴳⵓⵔ ⴰⵍ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵏⵏⴻⵊ, ");
INSERT INTO rift_vpl VALUES ("JS16_6","007_16_6","JOS","16","6","6","ⵓⵛⴰ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵎⵉⴽⵎⴰⵜⴰ ⵓⵛⴰ ⵉⵜⵜⴻⴼⵔⵉⵖ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵖⴰⵔ ⵜⴰ’ⴰⵏⴰⵜ-ⵛⵉⵍⵓ ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴻⴽⴽ ⵅⴰⵙ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵏ ⵛⵛⴰⵔⵇ ⵖⴰⵔ ⵢⴰⵏⵓⵃⴰ, ");
INSERT INTO rift_vpl VALUES ("JS16_7","007_16_7","JOS","16","7","7","ⵓ ⵣⵉ ⵢⴰⵏⵓⵃⴰ ⵉⵀⴻⴽⴽⵡⴰ ⵖⴰⵔ ⵄⴰⵟⴰⵔⵓⵜ ⴷ ⵏⴰⵄⴰⵔⴰⵜⴰ ⵓⵛⴰ ⵄⵍⴰⵢⴻⵏ ⵉⵏⴻⵃⵃⴻⴷ ⴰⵔⵉⵃⴰ ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS16_8","007_16_8","JOS","16","8","8","ⵣⵉ ⵜⴰⴼⴼⵓⵃ ⵉⵄⴻⴷⴷⵓ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵇⴰⵏⴰ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS16_9","007_16_9","JOS","16","9","9","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵉⵜⵜⵡⴰⵃⵓⵣⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS16_10","007_16_10","JOS","16","10","10","ⵡⴰⵔ ⵓⵥⵥⵉⵍⴻⵏ ⵛⴰ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵊⴰⵣⴰⵔ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ⴰⵎⵎⵓ ⵣⴻⴷⴷⵖⴻⵏ ⵉⴽⴻⵏⵄⴰⵏⵉⵢⵢⴻⵏ ⵄⴰⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵜᵉⵜⵜⵡⴰⴳⴳ ⵅⴰⵙⴻⵏ ⵎⴰⵛⴰ ⵍⵊⵉⵣⵢⴰ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS17_1","007_17_1","JOS","17","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⵓⵙⵓⴼ, ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵎⴰⴽⵉⵔ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵊⵉⵍⵄⴰⴷ ⴷ ⴱⴰⵛⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS17_2","007_17_2","JOS","17","2","2","ⵜⴻⴽⴽⴰⵔ ⴰⵙⴻⵏ-ⴷⴷ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⴰⵢⵜ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵉ ⴰⵢⵜ ⵏ ⴰⴱⵉⵄⴰⵣⴰⵔ ⴷ ⴰⵢⵜ ⵏ ⵃⴰⵍⴰⵇ ⴷ ⴰⵢⵜ ⵏ ⴰⵙⵔⵉⵢⵉⵍ ⴷ ⴰⵢⵜ ⵏ ⵛⴰⴽⴰⵎ ⴷ ⴰⵢⵜ ⵏ ⵃⴰⴼⴰⵔ ⴷ ⴰⵢⵜ ⵏ ⵛⴰⵎⵉⴷⴰⵄ. ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS17_3","007_17_3","JOS","17","3","3","ⵓ ⵣⴻⵍⵓⵃⴼⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴼⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵎⴰⴽⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵢⴻⵙⵙⵉⵙ. ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ: ⵎⴰⵃⵍⴰ ⴷ ⵏⵓⵄⴰ, ⵃⵓⵊⵍⴰ, ⵎⵉⵍⴽⴰ ⴷ ⵜⵉⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("JS17_4","007_17_4","JOS","17","4","4","ⵏⵉⵜⴻⵏⵜⵉ ⵇⴰⵔⵔⴱⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵏⵏⴰⵏⵜ: “ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⴷ ⴰⵏⴻⵖ ⵉⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ.” ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵊⴰⵔ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS17_5","007_17_5","JOS","17","5","5","ⴰⵎⵎⵓ ⵉ ⵉⵡⴹⴰⵏ ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⴻⵄⴱⴰⵔ ⵄⴻⵛⵔⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉ ⵎⴰⵏⴰⵙⵙⴰ, ⴱⵍⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ ⴷ ⴱⴰⵛⴰⵏ ⵉ ⵉⴵⴰⵏ ⴰⵖⵉⵔⵉⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS17_6","007_17_6","JOS","17","6","6","ⵎⴰⵖⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵟⵟⴼⴻⵏⵜ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ ⵜⵓⵖⴰ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵉ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS17_7","007_17_7","JOS","17","7","7","ⴰⵢⵎⵉⵔ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵣⵉ ⴰⵛⵉⵔ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵎⵉⴽⵎⴰⵜⴰ ⵉ ⵉⴵⴰⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵛⴰⴽⵉⵎ ⵓ ⴰⵢⵎⵉⵔ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵖⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵄⴰⵢⵏ-ⵜⴰⴼⴼⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("JS17_8","007_17_8","JOS","17","8","8","ⵎⴰⵏⴰⵙⵙⴰ ⵖⴰⵔⴻⵙ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵜⴰⴼⴼⵓⵃ, ⵎⴰⵛⴰ ⵜⴰⴼⴼⵓⵃ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⴻⵢⵎⵉⵔ ⴰⴽ-ⴷ ⵎⴰⵏⴰⵙⵙⴰ, ⵜⵓⵖⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JS17_9","007_17_9","JOS","17","9","9","ⵅⴻⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⴰⵏⴰ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⴻⵖⵣⴰⵔⵜ. ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵇⴰ-ⵜⴻⵏⵜ ⴷⵉⵏ ⵊⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⴻⴵⴰ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵉⵖⵣⴰⵔ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS17_10","007_17_10","JOS","17","10","10","ⵍⵊⴰⵏⵓⴱ ⴰⵇⴰ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵛⵛⴰⵎⴰⵍ ⴰⵇⴰ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵓ ⵍⴻⴱⵃⴰⵔ ⴷ ⴰⵢⵎⵉⵔ ⵏⵏⴻⵙ. ⴷⵉ ⵛⵛⴰⵎⴰⵍ ⵜⵜⴻⵏⵃⴰⴷⴰⵏ ⵅ ⴰⵛⵉⵔ ⵓ ⴷⵉ ⵛⵛⴰⵔⵇ ⵅ ⵉⵙⵙⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS17_11","007_17_11","JOS","17","11","11","ⴷⵉ ⵉⵙⵙⴰⴽⴰⵔ ⵓ ⴷⵉ ⴰⵛⵉⵔ ⴷⴻⵡⵍⴻⵏ ⵉⵏⴰ ⵖⴰⵔ ⵎⴰⵏⴰⵙⵙⴰ: ⴱⴰⵢⵜ-ⵛⴰⵏ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⵢⴰⴱⵍⴰⵄⴰⵎ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⵓⵔ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵄⴰⵢⵏ-ⴷⵓⵔ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴰⵄⵏⴰⴽ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵎⴰⵊⵉⴷⴷⵓ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ, ⵜⵍⴰⵜⴰ ⵏ ⵜⵔⴻⵇⵇⵉⵄⵉⵏ ⵓⵢⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS17_12","007_17_12","JOS","17","12","12","ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵟⵟⴼⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴳⴳⵉⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS17_13","007_17_13","JOS","17","13","13","ⵓⵎⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⵡⵍⴻⵏ ⵊⴻⵀⴷⴻⵏ, ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵍⵊⵉⵣⵢⴰ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵓⵥⵥⵍⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JS17_14","007_17_14","JOS","17","14","14","ⵙⵙⵉⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⵏⵏⴰⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵍⴱⴰⵔⴰⴽⴰ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("JS17_15","007_17_15","JOS","17","15","15","ⵢⴰⵛⵓⵡⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴳⴻⵄⵄⴻⴷ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵓⵛⴰ ⵣⴷⴻⵎ ⴷⵉⵏⵏⵉ ⵜⵜⴰⵙⵉⵄ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ, ⵎⴰⵍⴰ ⵃⵚⴰⵔⴻⵏ ⵅⴰⴽ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS17_16","007_17_16","JOS","17","16","16","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ: “ⵉⴷⵓⵔⴰⵔ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵜⵇⵉⴷⴷⵉⵏ. ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵖⴰⵔⵙⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏ ⵡⵓⵣⵣⴰⵍ, ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵛⴰⵏ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴰⵎ ⵢⵉⵏⵏⵉ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JS17_17","007_17_17","JOS","17","17","17","ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵛⵓⵡⴰ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ, ⴰⴽ-ⴷ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ, ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵖⴰⵔⵡⴻⵎ ⵊⵊⴻⵀⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵟⵟⴼⴻⵎ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ, ");
INSERT INTO rift_vpl VALUES ("JS17_18","007_17_18","JOS","17","18","18","ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵉⵍⵉⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵓⵎⵉ ⵜⴻⴵⴰ ⴷ ⴰⵣⵖⴰⵔ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵣⴻⴷⵎⴻⵎ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴰⵥⵥⵍⴻⵎ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵡⴰⵅⵅⴰ ⵖⴰⵔⵙⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓ ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵊⴻⵀⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JS18_1","007_18_1","JOS","18","1","1","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵎⵓⵏ ⴷⵉ ⵛⵉⵍⵓ ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉ ⵡⵜⵉⵏ ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵙⵙⵡⴰⴹⵄⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS18_2","007_18_2","JOS","18","2","2","ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏⵜ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⴻⴱⵄⴰ ⵏ ⵜⵇⴻⴱⴱⴰⵍ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏⵜ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵄⴰⴷ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS18_3","007_18_3","JOS","18","3","3","ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴰⵍ ⵎⴻⵍⵎⵉ ⵜⵜⵔⴰⵊⴰⵎ ⵄⴰⴷ ⴰⵍ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴷ ⵍⵡⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JS18_4","007_18_4","JOS","18","4","4","ⴽⵙⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⴽⴽⴻⵖ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⴽⴽⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵣⴻⵎⵎⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS18_5","007_18_5","JOS","18","5","5","ⴰⴷ ⵜⵜ ⴱⴹⴰⵏ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⵊⴰⵏⵓⴱ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JS18_6","007_18_6","JOS","18","6","6","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵣⴻⵎⵎⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵓⵛⴰ ⵉⵣⴻⵎⵎⴰⵏⴻⵏ ⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⴷⴰⵏⵉⵜⴰ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵏⴹⴰⵔⴻⵖ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JS18_7","007_18_7","JOS","18","7","7","ⵎⵉⵏⵣⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ⵊⴰⴷ ⴷ ⵔⵓⴱⵉⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵟⵟⴼⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS18_8","007_18_8","JOS","18","8","8","ⴽⴽⴰⵔⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ. ⵢⵓⵎⵓⵔ ⵢⴰⵛⵓⵡⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⴻⵎⵎⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵜⵉⵔⴰ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔⴻⵎ, ⵜⵜⴻⴽⴽⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵣⴻⵎⵎⴻⵎⴻⵎ ⵜⵜ. ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵜⵜⵉⵡ-ⴷⴷ ⵖⴰⵔⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴷⴰ ⵏⴹⴰⵔⴻⵖ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⴷⵉ ⵛⵉⵍⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS18_9","007_18_9","JOS","18","9","9","ⵉⵔⵢⴰⵣⴻⵏ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ, ⵛⵓⵇⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵣⴻⵎⵎⴻⵏ ⵜⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵙⴻⵜⵜⴼⴻⵏ ⵜⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵏⴻⴷⴷⴰⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵢⴰⵛⵓⵡⴰ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵛⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JS18_10","007_18_10","JOS","18","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⴹⴰⵔ ⵢⴰⵛⵓⵡⴰ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴷⵉⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⴱⴹⴰ ⵢⴰⵛⵓⵡⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS18_11","007_18_11","JOS","18","11","11","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⴻⴹⵀⴰⵔ-ⴷⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵏⵙⴻⵏ ⵜⵓⵙⴰ-ⴷⴷ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("JS18_12","007_18_12","JOS","18","12","12","ⵉⵜⵜⴻⴼⴼⴻⵖ ⵡⴻⵢⵎⵉⵔ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵖⴰⵔ ⵡⴻⵄⵔⵓⵔ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⴰⵔⵉⵃⴰ, ⵉⵄⴻⴷⴷⵓ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵉⵜⵜⴻⴽⴽ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⵅⵍⴰ ⵏ ⴱⴰⵢⵜ-ⴰⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS18_13","007_18_13","JOS","18","13","13","ⵙⵙⴻⵏⵏⵉ ⵉⵥⴻⴽⴽⵡⴰ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵍⵓⵣ ⵅ ⵡⴻⵄⵔⵓⵔ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵍⵓⵣ, ⵡⴰ ⴷ ⴱⴰⵢⵜ-ⵉⵍ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵄⴰⵟⴰⵔⵓⵜ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JS18_14","007_18_14","JOS","18","14","14","ⴰⵢⵎⵉⵔ ⵉⵄⴻⴷⴷⵓ ⵓⵛⴰ ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵖⴰⵔⴱ, ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵉ ⵉⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⵏⵏⵉ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵇⴰⵔⵢⴰⵜ-ⴱⴰⵄⵍⴰ, ⵜⴰ ⴷ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵡⴰ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ. ");
INSERT INTO rift_vpl VALUES ("JS18_15","007_18_15","JOS","18","15","15","ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ. ⵉⴱⴻⴷⴷⴰ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⵍⵖⴰⵔⴱ ⵓ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵏⴰⴼⵜⵓⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JS18_16","007_18_16","JOS","18","16","16","ⵅⴻⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵡⴻⴷⵔⴰⵔ ⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵅ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵀⵉⵏⵏⵓⵎ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵔⵓⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS18_17","007_18_17","JOS","18","17","17","ⵓⵛⴰ ⵉⵜⵜⴻⴽⴽ ⵅ ⵛⵛⴰⵎⴰⵍ ⵓⵛⴰ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵖⴰⵔ ⵄⴰⵢⵏ-ⵛⴰⵎⵛ ⵓⵛⴰ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵊⴰⵍⵉⵍⵓⵜ, ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⴰⴷⵓⵎⵎⵉⵎ ⵓⵛⴰ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵥⵔⵓ ⵏ ⴱⵓⵀⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵔⵓⴱⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("JS18_18","007_18_18","JOS","18","18","18","ⵓ ⵉⵥⴻⴽⴽⵡⴰ ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵍⴻⵡⴹⴰ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰ ⴷⵉ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JS18_19","007_18_19","JOS","18","19","19","ⵅⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏ ⴱⴰⵢⵜ-ⵃⵓⵊⵍⴰ ⵓ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵉⵍⴻⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⴵⴰⵃ, ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷⵉ ⵍⵊⴰⵏⵓⴱ. ⵡⴰ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JS18_20","007_18_20","JOS","18","20","20","ⵍ’ⵓⵔⴷⵓⵏ ⵜⵓⵖⴰ ⴷ ⴰⵢⵎⵉⵔ ⵏⵏⴻⵙ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⵉⵇⵓⵡⵡⴰⵔⴻⵏ, ⵄⵍⴰⵃⴰⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS18_21","007_18_21","JOS","18","21","21","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⴷ ⵜⵉⵏⴰ: ⴰⵔⵉⵃⴰ ⴷ ⴱⴰⵢⵜ-ⵃⵓⵊⵍⴰ ⴷ ⵄⵉⵎⴰⵇ-ⵇⵉⵚⵉⵚ ");
INSERT INTO rift_vpl VALUES ("JS18_22","007_18_22","JOS","18","22","22","ⴷ ⴱⴰⵢⵜ-ⵄⴰⵔⴰⴱⴰ ⴷ ⵚⴰⵎⴰⵔⴰⵢⵉⵎ ⴷ ⴱⴰⵢⵜ-ⵉⵍ ");
INSERT INTO rift_vpl VALUES ("JS18_23","007_18_23","JOS","18","23","23","ⴷ ⵉⵄⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵀⴰ-ⴼⴰⵔⴰ ⴷ ⵄⵓⴼⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("JS18_24","007_18_24","JOS","18","24","24","ⴷ ⴽⴰⴼⴰⵔ-ⵄⴰⵎⵎⵓⵏⵉ ⴷ ⵀⴰ-ⵄⵓⴼⵏⵉ ⴷ ⵊⴰⴱⴰⵄ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS18_25","007_18_25","JOS","18","25","25","ⵊⵉⴱⵄⵓⵏ ⴷ ⵔⴰⵎⴰ ⴷ ⴱⵉⵄⵔⵓⵜ ");
INSERT INTO rift_vpl VALUES ("JS18_26","007_18_26","JOS","18","26","26","ⴷ ⵎⵉⵚⴼⴰ ⴷ ⴽⴰⴼⵉⵔⴰ ⴷ ⵎⵓⵚⴰ ");
INSERT INTO rift_vpl VALUES ("JS18_27","007_18_27","JOS","18","27","27","ⴷ ⵔⴰⵇⴰⵎ ⴷ ⵢⴰⵔⴰⴼⵡⵉⵍ ⴷ ⵜⴰⵔⴰⵍⴰ ");
INSERT INTO rift_vpl VALUES ("JS18_28","007_18_28","JOS","18","28","28","ⴷ ⵚⴰⵍⴰⵄ ⴷ ⴰⵍⴰⴼ ⴷ ⴰⵢⴰⴱⵓⵙⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⴷ ⵊⵉⴱⵄⴰ ⴷ ⵇⴰⵔⵢⴰⵜ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_1","007_19_1","JOS","19","1","1","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵛⵉⵎⵄⵓⵏ, ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵜⴻⴵⴰ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS19_2","007_19_2","JOS","19","2","2","ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏⵜ ⵖⴰⵔⵙⴻⵏ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ: ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⴷ ⵛⴰⴱⵄⴰ ⴷ ⵎⵓⵍⴰⴷⴰ ");
INSERT INTO rift_vpl VALUES ("JS19_3","007_19_3","JOS","19","3","3","ⴷ ⵃⴰⵚⴰⵔ-ⵛⵓⵄⴰⵍ ⴷ ⴱⴰⵄⵍⴰ ⴷ ⵄⴰⵚⴰⵎ ");
INSERT INTO rift_vpl VALUES ("JS19_4","007_19_4","JOS","19","4","4","ⴷ ⵉⵍⵜⵓⵍⴰⴷ ⴷ ⴱⴰⵜⵓⵍ ⴷ ⵃⵓⵔⵎⴰ ");
INSERT INTO rift_vpl VALUES ("JS19_5","007_19_5","JOS","19","5","5","ⴷ ⵚⵉⵇⵍⴰⵖ ⴷ ⴱⴰⵢⵜ-ⵎⴰⵔⴽⴰⴱⵓⵜ ⴷ ⵃⴰⵚⴰⵔ-ⵙⵓⵙⴰ ");
INSERT INTO rift_vpl VALUES ("JS19_6","007_19_6","JOS","19","6","6","ⴷ ⴱⴰⵢⵜ-ⵍⴰⴱⴰⵡⵓⵜ ⴷ ⵛⴰⵔⵓⵃⴰⵢⵏ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_7","007_19_7","JOS","19","7","7","ⵅⴻⵏⵏⵉ ⵄⴰⵢⵏ ⴷ ⵔⵉⵎⵎⵓⵏ ⴷ ⵄⴰⵜⴰⵔ ⴷ ⵄⴰⵛⴰⵏ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("JS19_8","007_19_8","JOS","19","8","8","ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴷⵛⵓⵔ ⵉ ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⵉ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⵍ ⴱⴰⵄⵍⴰⵜ-ⴱⵉ’ⵔ, ⵜⴻⵏⵏⵉ ⴷ ⵔⴰⵎⴰ ⵏ ⵍⵊⴰⵏⵓⴱ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_9","007_19_9","JOS","19","9","9","ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⴽⵙⵉ ⵣⵉ ⵎⵉⵏ ⵄⴻⴱⴱⴰⵔⴻⵏ ⵙ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵉ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ-ⵜⵜ ⵉ ⵉⵏⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ⵅ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔⵜⴻⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_10","007_19_10","JOS","19","10","10","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵜⴻⴹⵀⴰⵔ-ⴷⴷ ⵉ ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵉⵄⴻⴷⴷⵓ ⴰⵍ ⵙⴰⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JS19_11","007_19_11","JOS","19","11","11","ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵡⴻⵢⵎⵉⵔ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵓ ⵖⴰⵔ ⵎⴰⵔⵄⴰⵍⴰ ⵓⵛⴰ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⴷⴰⴱⴱⴰⵛⴰ ⵓ ⴰⵍ ⵜⵉⵖⵣⴰⵔⵜ ⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵢⵓⴽⵏⴰⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS19_12","007_19_12","JOS","19","12","12","ⵣⵉ ⵙⴰⵔⵉⴷ ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⴰⵍ ⵡⴻⵢⵎⵉⵔ ⵏ ⴽⵉⵙⵍⵓⵜ-ⵜⴰⴱⵓⵔ ⵓⵛⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴷⵓⴱⵔⴰ ⵓ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵢⴰⴼⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JS19_13","007_19_13","JOS","19","13","13","ⵙⵙⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵖⴰⵔ ⵊⴰⵜ-ⵃⴰⴼⴰⵔ ⵓ ⵖⴰⵔ ⵄⵉⵜ-ⵇⴰⵚⵉⵏ ⵓ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵔⵉⵎⵎⵓⵏ, ⵉⵜⵜⴻⴼⵔⵉⵖ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵏⴰⵢⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JS19_14","007_19_14","JOS","19","14","14","ⵉⵜⵜⴻⴼⵔⵉⵖ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵃⴰⵏⵏⴰⵜⵓⵏ ⵓ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵊⵉⴼⵜⴰⵃ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS19_15","007_19_15","JOS","19","15","15","ⵅⴻⵏⵏⵉ ⵇⴰⵟⵟⴰ ⴷ ⵏⴰⵀⵍⴰⵍ ⴷ ⵛⵉⵎⵔⵓⵏ ⴷ ⵢⴰⴷⴰⵍⴰ ⴷ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_16","007_19_16","JOS","19","16","16","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_17","007_19_17","JOS","19","17","17","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵉⵙⵙⴰⴽⴰⵔ, ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_18","007_19_18","JOS","19","18","18","ⵉⵄⴻⴷⴷⵓ ⵡⴻⵢⵎⵉⵔ ⵏⵙⴻⵏ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ ⴷ ⴽⵉⵙⵍⵓⵜ ⴷ ⵛⵓⵏⴰⵎ ");
INSERT INTO rift_vpl VALUES ("JS19_19","007_19_19","JOS","19","19","19","ⴷ ⵃⴰⴼⴰⵔⴰⵢⵉⵎ ⴷ ⵛⵉⵢⵓⵏ ⴷ ⴰⵏⴰⵃⴰⵔⴰ ");
INSERT INTO rift_vpl VALUES ("JS19_20","007_19_20","JOS","19","20","20","ⴷ ⵔⴰⴱⴱⵉⵜ ⴷ ⵇⵉⵛⵢⵓⵏ ⴷ ⴰⴱⴰⵚ ");
INSERT INTO rift_vpl VALUES ("JS19_21","007_19_21","JOS","19","21","21","ⴷ ⵔⴰⵎⴰ ⴷ ⵄⴰⵢⵏ-ⵊⴰⵏⵏⵉⵎ ⴷ ⵄⴰⵢⵏ-ⵃⴰⴷⴷⴰ ⴷ ⴱⴰⵢⵜ-ⵇⴰⵚⵚⴰⵢⵙ. ");
INSERT INTO rift_vpl VALUES ("JS19_22","007_19_22","JOS","19","22","22","ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵡⴻⵢⵎⵉⵔ ⴰⵍ ⵜⴰⴱⵓⵔ ⴷ ⵛⴰⵃⵚⵉⵎⴰ ⴷ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵓ ⵟⵟⵔⵓⴼⴰ ⵏ ⵡⴻⵢⵎⵉⵔ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍ’ⵓⵔⴷⵓⵏ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵙⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_23","007_19_23","JOS","19","23","23","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_24","007_19_24","JOS","19","24","24","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_25","007_19_25","JOS","19","25","25","ⴰⵢⵎⵉⵔ ⵏⵙⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵃⴰⵍⵇⴰ ⴷ ⵃⴰⵍⵉ ⴷ ⴱⴰⵟⴰⵏ ⴷ ⴰⴽⵛⴰⴼ ");
INSERT INTO rift_vpl VALUES ("JS19_26","007_19_26","JOS","19","26","26","ⴷ ⴰⵍⵍⴰⵎⵎⴰⵍⴰⴽ ⴷ ⴰⵎⵄⴰⴷ ⴷ ⵎⵉⵛ-ⴰⵍ, ⵓⵛⴰ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ ⴷⵉ ⵍⵖⴰⵔⴱ ⵓ ⴰⵍ ⵛⵉⵅⵓⵔ-ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JS19_27","007_19_27","JOS","19","27","27","ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵖⴰⵔ ⴱⴰⵢⵜ-ⴷⴰⵊⵓⵏ ⵓⵛⴰ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⵣⴰⴱⵓⵍⵓⵏ ⴷ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵢⵉⴼⵜⴰⵃ-ⵉⵍ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵅⴻⵏⵏⵉ ⴰⵍ ⴱⴰⵢⵜ-ⵄⴰⵎⵉⵇ ⴷ ⵏⴰⵄⵉⵢⵉⵍ, ⵓⵛⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏ ⴽⴰⴱⵓⵍ ");
INSERT INTO rift_vpl VALUES ("JS19_28","007_19_28","JOS","19","28","28","ⵓⵛⴰ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵄⴰⴱⵔⵓⵏ ⴷ ⵔⴰⵃⵓⴱ ⴷ ⵃⴰⵎⵎⵓⵏ ⴷ ⵇⴰⵏⴰ ⴰⵍ ⵚⵉⴷⵓⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_29","007_19_29","JOS","19","29","29","ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵔⴰⵎⴰ ⵉⴳⴳⵓⵔ ⴰⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⵉ ⵉⴼⴰⵔⵢⴻⵏ ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵃⵓⵚⴰ ⵓ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ, ⵣⵉ ⵃⵉⴱⵍ ⴰⵍ ⴰⴽⵣⵉⴱ ");
INSERT INTO rift_vpl VALUES ("JS19_30","007_19_30","JOS","19","30","30","ⴷ ⵄⵓⵎⵎⴰ ⴷ ⴰⴼⵉⵇ ⴷ ⵔⴰⵃⵓⴱ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_31","007_19_31","JOS","19","31","31","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵉⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_32","007_19_32","JOS","19","32","32","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵉ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_33","007_19_33","JOS","19","33","33","ⵉⵄⴻⴷⴷⵓ ⵡⴻⵢⵎⵉⵔ ⵏⵙⴻⵏ ⵣⵉ ⵃⴰⵍⴰⴼ, ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⴷⵉ ⵚⴰⵄⴰⵏⴰⵢⵉⵎ, ⴷ ⴰⴷⴰⵎⵉ-ⵏⴰⵇⵉⴱ ⴷ ⵢⴰⴱⵏⵉⵢⵉⵍ ⴰⵍ ⵍⴰⵇⵇⵓⵎ ⵓⵛⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_34","007_19_34","JOS","19","34","34","ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⴰⵣⵏⵓⵜ-ⵜⴰⴱⵓⵔ ⵓ ⵙⵙⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓ ⵖⴰⵔ ⵃⵓⵇⵓⵇ ⵓ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⵣⴰⴱⵓⵍⵓⵏ ⴷⵉ ⵍⵊⴰⵏⵓⴱ ⵓ ⴷⵉ ⵍⵖⴰⵔⴱ ⵉⵙⵙⵓⴼⴼⵓⵖ ⴰⵍ ⴰⵛⵉⵔ ⵓ ⴷⵉ ⵛⵛⴰⵔⵇ ⴰⵍ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_35","007_19_35","JOS","19","35","35","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵚⵉⴷⴷⵉⵎ ⴷ ⵚⴰⵢⵔ ⴷ ⵃⴰⵎⵎⴰⵜ ⴷ ⵔⴰⵇⵇⴰⵜ ⴷ ⴽⵉⵏⵏⴰⵔⴰⵜ ");
INSERT INTO rift_vpl VALUES ("JS19_36","007_19_36","JOS","19","36","36","ⴷ ⴰⴷⴰⵎⴰ ⴷ ⵔⴰⵎⴰ ⴷ ⵃⴰⵚⵓⵔ ");
INSERT INTO rift_vpl VALUES ("JS19_37","007_19_37","JOS","19","37","37","ⴷ ⵇⴰⴷⴰⵛ ⴷ ⵉⴷⵍⴰⵄⵉ ⴷ ⵄⴰⵢⵏ-ⵃⴰⵚⵓⵔ ");
INSERT INTO rift_vpl VALUES ("JS19_38","007_19_38","JOS","19","38","38","ⴷ ⵢⵉⵔⵓⵏ ⴷ ⵎⵉⵊⴷⴰⵍ-ⵉⵍ ⴷ ⵃⵓⵔⵉⵎ ⴷ ⴱⴰⵢⵜ-ⵄⴰⵏⴰⵜ ⴷ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵙⴻⵄⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_39","007_19_39","JOS","19","39","39","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_40","007_19_40","JOS","19","40","40","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_41","007_19_41","JOS","19","41","41","ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵚⵓⵔⵄⴰ ⴷ ⵉⵛⵜⴰ’ⵓⵍ ⴷ ⵄⵉⵔ-ⵛⴰⵎⵛ ");
INSERT INTO rift_vpl VALUES ("JS19_42","007_19_42","JOS","19","42","42","ⴷ ⵛⴰⵄⴰⵍⴱⵉⵎ ⴷ ⴰⵢⴰⵍⵓⵏ ⴷ ⵢⵉⵜⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("JS19_43","007_19_43","JOS","19","43","43","ⴷ ⵉⵢⵍⵓⵏ ⴷ ⵜⵉⵎⵏⴰⵜⴰ ⴷ ⵄⴰⵇⵔⵓⵏ ");
INSERT INTO rift_vpl VALUES ("JS19_44","007_19_44","JOS","19","44","44","ⴷ ⵉⵍⵜⴰⵇⴰⵢ ⴷ ⵊⵉⴱⴱⴰⵜⵓⵏ ⴷ ⴱⴰⵄⵍⴰⵜ ");
INSERT INTO rift_vpl VALUES ("JS19_45","007_19_45","JOS","19","45","45","ⴷ ⵢⴰⵀⵓⴷ ⴷ ⴱⴰⵏⵉ-ⴱⴰⵔⴰⵇ ⴷ ⵊⴰⵜ-ⵔⵉⵎⵎⵓⵏ ");
INSERT INTO rift_vpl VALUES ("JS19_46","007_19_46","JOS","19","46","46","ⴷ ⵎⵉⵢⴰⵀ-ⵢⴰⵔⵇⵓⵏ ⴷ ⵔⴰⵇⵇⵓⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⴰⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JS19_47","007_19_47","JOS","19","47","47","ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵜⴻⵃⵙⴰⵔ ⵉ ⵏⵉⵜⵏⵉ. ⵅⴻⵏⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵖⴰⵔ ⵍⴰⵛⴰⵎ, ⴰⵔⵣⵎⴻⵏ ⴰⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⴰⵛⴰⵎ, ⵍⴻⵖⴱⴻⵏ ⵜⵜ, ⵡⵜⵉⵏ ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜⵜ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⵙ ⵉ ⵍⴰⵛⴰⵎ ⵉⵙⴻⵎ ⴷⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_48","007_19_48","JOS","19","48","48","ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS19_49","007_19_49","JOS","19","49","49","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴱⴻⵟⵟⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵜⵙⴻⵇⵇⴰⵔ ⵏ ⵍⵡⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵡⵛⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⵉ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS19_50","007_19_50","JOS","19","50","50","ⵡⵛⵉⵏ ⴰⵙ, ⵙ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔ, ⵜⵉⵎⵏⴰⵜ-ⵙⴰⵔⴰⵃ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵣⴷⴻⵖ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JS19_51","007_19_51","JOS","19","51","51","ⵜⵉⵏⴰ ⴷ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴹⴰⵏ ⴷ ⵍⵡⴰⵔⵜ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵛⵉⵍⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ. ⴰⵎⵎⵓ ⴽⴻⵎⵎⵍⴻⵏ ⴰⴱⴻⵟⵟⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JS20_1","007_20_1","JOS","20","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JS20_2","007_20_2","JOS","20","2","2","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⴰⴷ ⵜⴼⴰⵔⵣⴻⵎ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ,    ");
INSERT INTO rift_vpl VALUES ("JS20_3","007_20_3","JOS","20","3","3","ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⴷⵉⵏ ⵓⵇⴻⵜⵜⴰⵍ ⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ. ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵜⴰⵔⴻⵡⵍⴻⵎ ⵣⴻⴳ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS20_4","007_20_4","JOS","20","4","4","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ, ⴰⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴰⴷ ⵉⵃⴰⵊⴰ ⵜⴰⵎⵙⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵙⵙⵉⴷⴼⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵣⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JS20_5","007_20_5","JOS","20","5","5","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵓⵏⴻⵇⵇⴰⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛⴻⵏ ⴰⵇⴻⵜⵜⴰⵍ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵜ ⵉⵛⴰⵔⵔⴻⵀ ⵛⴰ ⵉⴹⴻⵏⵏⴰⴹ ⵏⵉⵖ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("JS20_6","007_20_6","JOS","20","6","6","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⴰⵍ ⵖⴰ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⵃⴽⴰⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⵍ ⵖⴰ ⵉⵎⵎⴻⵜ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵇⴻⵜⵜⴰⵍ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵣⵉ ⴷⴷ-ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS20_7","007_20_7","JOS","20","7","7","ⵅⴻⵏⵏⵉ ⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⴷⴰⵛ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⴷⵉ ⵍⵊⴰⵍⵉⵍ ⵓ ⵛⴰⴽⵉⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵇⴰⵔⵢⴰⵜ-ⴰⵔⴱⴰⵄ, ⵜⴻⵏⵏⵉ ⴷ ⵃⴰⴱⵔⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JS20_8","007_20_8","JOS","20","8","8","ⴰⵖⵉⵔⵉⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵇ ⵣⵉ ⴰⵔⵉⵃⴰ, ⵡⵛⵉⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ ⴱⴰⵚⴰⵔ ⴷⵉ ⵍⴻⵅⵍⴰ ⵅ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⵡⵛⵉⵏ ⵏⵉⵜⵏⵉ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵊⵓⵍⴰⵏ ⴷⵉ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS20_9","007_20_9","JOS","20","9","9","ⵜⵉⵏⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵓⵡⴻⴷⴷⴰⵔ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⴰⵔⵡⴻⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴻⵇⵇⴰⵎⴻⵏ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴰⵍ ⵖⴰ ⵉⴱⴻⴷⴷ ⵉ ⵍⵃⵓⴽⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JS21_1","007_21_1","JOS","21","1","1","ⵅⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵓ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS21_2","007_21_2","JOS","21","2","2","ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵛⵉⵍⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵏⵏⴰⵏ: “ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ, ⴰⴷ ⴰⵏⴻⵖ ⵎⵎⴻⵡⵛⴻⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵏⴻⵣⴷⴻⵖ, ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JS21_3","007_21_3","JOS","21","3","3","ⵅⴻⵏⵏⵉ ⵡⵛⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_4","007_21_4","JOS","21","4","4","ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙⴻⵏⵜ-ⴷⴷ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵇⴰⵀⴰⵜ. ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_5","007_21_5","JOS","21","5","5","ⵉ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵄⴻⵛⵔⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ ⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_6","007_21_6","JOS","21","6","6","ⵉ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵓ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_7","007_21_7","JOS","21","7","7","ⵉ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⵓ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_8","007_21_8","JOS","21","8","8","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⵛⵉⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_9","007_21_9","JOS","21","9","9","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵢⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⵉ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵙⴻⵏⵜ ");
INSERT INTO rift_vpl VALUES ("JS21_10","007_21_10","JOS","21","10","10","ⵓ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⴽⴽⴰⵔ ⴰⵙⴻⵏ-ⴷⴷ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵜⴻⵡⴹⴰ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_11","007_21_11","JOS","21","11","11","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴱⴰⵄ, ⴱⴰⴱⴰⵙ ⵏ ⵄⴰⵏⴰⵇ, ⵜⴻⵏⵏⵉ ⴷ ⵃⴰⴱⵔⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_12","007_21_12","JOS","21","12","12","ⵎⴰⵛⴰ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵏⴻⵙ ⵡⵛⵉⵏ ⵜⴻⵏ ⴷ ⴰⴳⵍⴰ ⵉ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JS21_13","007_21_13","JOS","21","13","13","ⵉ ⴰⵢⵜ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵀⴰⵔⵓⵏ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵓⵇⴻⵜⵜⴰⵍ: ⵃⴰⴱⵔⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵍⵉⴱⵏⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_14","007_21_14","JOS","21","14","14","ⴷ ⵢⴰⵜⵜⵉⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵉⵛⵜⵓⵎⴰⵄ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_15","007_21_15","JOS","21","15","15","ⴷ ⵃⵓⵍⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⴷⴰⴱⵉⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_16","007_21_16","JOS","21","16","16","ⴷ ⵄⴰⵢⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵢⵓⵟⵟⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵙⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_17","007_21_17","JOS","21","17","17","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵊⵉⴱⵄⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵊⵉⴱⵄⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_18","007_21_18","JOS","21","18","18","ⵄⴰⵏⴰⵜⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵄⴰⵍⵎⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_19","007_21_19","JOS","21","19","19","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_20","007_21_20","JOS","21","20","20","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_21","007_21_21","JOS","21","21","21","ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵓⵇⴻⵜⵜⴰⵍ: ⵛⴰⴽⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⴷ ⵊⴰⵣⴰⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_22","007_21_22","JOS","21","22","22","ⴷ ⵇⵉⴱⵚⴰⵢⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_23","007_21_23","JOS","21","23","23","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ: ⵉⵍⵜⴰⵇⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵊⵉⴱⴱⴰⵜⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_24","007_21_24","JOS","21","24","24","ⴰⵢⴰⵍⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵊⴰⴷ-ⵔⵉⵎⵎⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_25","007_21_25","JOS","21","25","25","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵜⴰⵄⵏⴰⴽ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵊⴰⴷ-ⵔⵉⵎⵎⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_26","007_21_26","JOS","21","26","26","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵇⴰⵀⴰⵜ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵄⴻⵛⵔⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_27","007_21_27","JOS","21","27","27","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ ⵉ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ, ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵓⵇⴻⵜⵜⴰⵍ: ⵊⵓⵍⴰⵏ ⴷⵉ ⴱⴰⵛⴰⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⴱⴰⵄⴰⵛⵜⴰⵔⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_28","007_21_28","JOS","21","28","28","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ: ⵇⵉⵛⵢⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⴷⴰⴱⵔⴰⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_29","007_21_29","JOS","21","29","29","ⵢⴰⵔⵎⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵄⴰⵢⵏ-ⵊⴰⵏⵏⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_30","007_21_30","JOS","21","30","30","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ: ⵎⵉⵛ-ⴰⵍ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵄⴰⴱⴷⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_31","007_21_31","JOS","21","31","31","ⴷ ⵃⴰⵍⵇⴰⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵔⴰⵃⵓⴱ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_32","007_21_32","JOS","21","32","32","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵓⵇⴻⵜⵜⴰⵍ: ⵇⴰⴷⴰⵛ ⴷⵉ ⵍⵊⴰⵍⵉⵍ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵃⴰⵎⵎⵓⵜ-ⴷⵓⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵇⴰⵔⵜⴰⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_33","007_21_33","JOS","21","33","33","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵊⴰⵔⵛⵓⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_34","007_21_34","JOS","21","34","34","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵎⵎⴻⵡⵛⴻⵏⵜ ⴰⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵊⵓⵇⵏⴰⵄⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵇⴰⵔⵜⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_35","007_21_35","JOS","21","35","35","ⴷⵉⵎⵏⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵏⴰⵀⴰⵍⴰⵍ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_36","007_21_36","JOS","21","36","36","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⴱⴰⵚⴰⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵢⴰⵀⵚⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_37","007_21_37","JOS","21","37","37","ⵇⴰⴷⵉⵎⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵎⴰⴼⴰⵄⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_38","007_21_38","JOS","21","38","38","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵓⵇⴻⵜⵜⴰⵍ: ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS21_39","007_21_39","JOS","21","39","39","ⵃⴰⵛⴱⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷ ⵢⴰⵄⵣⵉⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_40","007_21_40","JOS","21","40","40","ⵜⵓⵖⴰ ⵜⵉⵏⴰ ⵎⴰⵔⵔⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵉⵏⵏⵉ ⵅ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JS21_41","007_21_41","JOS","21","41","41","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵡⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_42","007_21_42","JOS","21","42","42","ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵎⴰⵔⵔⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⴷ ⴰⵙⴻⵏⵜ ⵉⵏⵏⴹⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS21_43","007_21_43","JOS","21","43","43","ⴰⵎⵎⵓ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵉ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⴰⴷ ⵜⵜ ⵉⵡⵛ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔⵜⴻⵏ ⵜⵜ ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS21_44","007_21_44","JOS","21","44","44","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵍⵀⵓⴷⵏⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS21_45","007_21_45","JOS","21","45","45","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵛⵏⴰⵏ ⵉ ⵣⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵡⴹⴰ. ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS22_1","007_22_1","JOS","22","1","1","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵢⴰⵛⵓⵡⴰ ⵉ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JS22_2","007_22_2","JOS","22","2","2","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵍⴰⵎ ⵄⴰⵡⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵡⴻⵎ ⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JS22_3","007_22_3","JOS","22","3","3","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵎⵉⵃⴻⵎ ⵛⴰ ⴷⴻⴳ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍ ⴰⵙⵙ-ⴰ ⵓ ⵜⴻⵃⴹⴰⵎ ⴰⵃⴻⵟⵟⵓ ⵏ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS22_4","007_22_4","JOS","22","4","4","ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴰⵔⵔⴰⵃⴻⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵜⵜ ⵉⵡⴰⵄⴷ. ⵄⴻⵇⴱⴻⵎ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵡⴻⵎ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JS22_5","007_22_5","JOS","22","5","5","ⵎⴰⵛⴰ ⵃⴹⴰⵎ ⵎⵍⵉⵃ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵍⵓⵎⵓⵔ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵍⴻⵚⵇⴻⵎ ⵓ ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS22_6","007_22_6","JOS","22","6","6","ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜⴻⵏ ⵢⴰⵛⵓⵡⴰ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⴳⴳⵯⵃⴻⵏ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS22_7","007_22_7","JOS","22","7","7","ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵎⵓⵙⴰ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⴱⴰⵛⴰⵏ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵡⵛⴰ ⴰⵙ ⵢⴰⵛⵓⵡⴰ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ. ⵓⵎⵉ ⵜⴻⵏ ⵉⵙⵙⴻⴽⴽ ⵢⴰⵛⵓⵡⴰ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JS22_8","007_22_8","JOS","22","8","8","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵙ ⵡⴰⴳⵍⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵜⵄⴻⵇⴱⴻⵎ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ, ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ ⵓ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵔⵔⵓⴹ. ⴱⴹⴰⵎ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS22_9","007_22_9","JOS","22","9","9","ⵄⴻⵇⴱⴻⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴳⴳⵯⴻⵊⵊⴻⵏ ⵅ ⵛⵉⵍⵓ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵎⵓⵍⴽ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴷ ⴰⴳⵍⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS22_10","007_22_10","JOS","22","10","10","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵄⴰⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴱⵏⴰⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JS22_11","007_22_11","JOS","22","11","11","ⵓⵛⴰ ⵙⵍⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵇⴰ ⵇⵇⴰⵔⴻⵏ: “ⵅⵣⴰⵔⴻⵎ, ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴱⵏⴰⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵅ ⵜⵎⵓⵡⵡⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JS22_12","007_22_12","JOS","22","12","12","ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵢⴰ, ⵜⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵛⵉⵍⵓ ⵃⵉⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS22_13","007_22_13","JOS","22","13","13","ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵓ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉ ⵊⵉⵍⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("JS22_14","007_22_14","JOS","22","14","14","ⵓ ⵙⵙⴻⴽⴽⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵣⵉ ⴽⵓⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵉ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS22_15","007_22_15","JOS","22","15","15","ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵓ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("JS22_16","007_22_16","JOS","22","16","16","“ⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⵉⴷⵉ: ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵍⴻⵖⴷⴰⵔ-ⴰ ⵉ ⵣⵉ ⵜⴻⵖⴷⴰⵔⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵜⵃⴻⵢⵢⴷⴻⵎ ⴰⵙⵙ-ⴰ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵜⴻⴱⵏⴰⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵙⵉⴷⵉ ⴰⵙⵙ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("JS22_17","007_22_17","JOS","22","17","17","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴼⴰ ⴰⵏⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⴼⴰⵖⵓⵔ, ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉ ⵣⵉ ⵖⴰⵔ ⴰⵙⵙ-ⴰ ⵄⴰⴷ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵓ ⵣⵣⴰⵢⴻⵙ ⵉ ⵜⴻⵡⴹⴰ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("JS22_18","007_22_18","JOS","22","18","18","ⵎⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴰⵙⵙ-ⴰ ⵜⴻⵡⵛⵉⵎ ⵙ ⵡⴻⵄⵔⵓⵔ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⵅⴻⵏⵏⵉ, ⵓⵎⵉ ⵖⴰ ⵜⵖⴻⵡⵡⵖⴻⵎ ⴰⵙⵙ-ⴰ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴼⴼⵓⴳⴻⵎ ⵏⴻⵜⵜⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("JS22_19","007_22_19","JOS","22","19","19","ⵎⴰⵍⴰ ⵣⴻⵄⵎⴰ ⵜⴻⵅⵎⴻⵊ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⴳⵍⴰ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵄⴷⵓⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⴳⵍⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴽⵙⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵛⴰ ⵅ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵛⴰ ⵅⴰⵏⴻⵖ ⵓⵎⵉ ⵖⴰ ⵜⴻⴱⵏⴰⵎ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵖⵉⵔ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JS22_20","007_22_20","JOS","22","20","20","ⵎⴰ ⵜⵓⵖⴰ ⵄⴰⵅⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ, ⵡⴰⵔ ⵉⵖⴷⴰⵔ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ ⵓ ⵅⴻⵏⵏⵉ ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵉⵎⵎⵓⵜ ⵡⴻⵃⵃⴹⴻⵙ ⵡⴰⵀⴰ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JS22_21","007_22_21","JOS","22","21","21","ⵅⴻⵏⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("JS22_22","007_22_22","JOS","22","22","22","“ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵙⵙⴻⵏ ⵉ-ⵜ ⵓ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏ ⵄⴰⵡⴻⴷ! ⵎⴰⵍⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⴰⵢⴰ ⵣⴻⴳ ⵓⵖⴻⵡⵡⴻⵖ ⵏⵉⵖ ⵣⵉ ⵍⴻⵖⴷⴰⵔ ⵅ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵜⵛⴻⵟⵟⴰⵔ ⵛⴰ ⴰⵙⵙ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JS22_23","007_22_23","JOS","22","23","23","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴱⵏⴰ ⵉ ⵏⴻⵛⵛⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵡⵛ ⵙ ⵡⴻⵄⵔⵓⵔ ⵉ ⵙⵉⴷⵉ ⵏⵉⵖ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵃⵉⵎⴰ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵉⵖ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ, ⴻⵊⵊ ⵙⵉⴷⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵉⴱⴻⵇⵇⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JS22_24","007_22_24","JOS","22","24","24","ⵓⵛⵜ ⵅⴰⵏⴻⵖ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵏⴻⴳⴳⵉ ⴰⵢⴰ ⵣⴻⴳ ⵡⴻⵎⵏⵓⵙ ⵓⵎⵉ ⵏⴻⵇⵇⴰⵔ: ‘ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⵜⵉⵡⴻⵛⵛⴰ: ⵎⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ-ⴷⴷ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("JS22_25","007_22_25","JOS","22","25","25","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵍ’ⵓⵔⴷⵓⵏ ⴷ ⴰⵢⵎⵉⵔ ⵊⴰⵔ ⴰⵏⴻⵖ ⴷ ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ! ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵙⵉⴷⵉ!’ ⴰⵎⵎⵓ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⵅ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS22_26","007_22_26","JOS","22","26","26","ⵅ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵏⵏⴰ: ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴱⵏⴰ ⴰⵄⴰⵍⵟⴰⵔ-ⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵍⴰ ⵉ ⵜⵖⴰⵔⵚⵜ, ");
INSERT INTO rift_vpl VALUES ("JS22_27","007_22_27","JOS","22","27","27","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵊⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴷ ⴽⴻⵏⵏⵉⵡ ⵓ ⵊⴰⵔ ⵊⵊⵉⵍⴰⵜ ⵏⵏⴻⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵙ ⵜⵖⴰⵔⵚⵉ ⵏⵏⴻⵖ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵉ ⵏⵏⴻⵖ ⵏⵏⴻⵖⵏⵉ ⴷ ⵜⵖⴰⵔⵚⵉ ⵏⵏⴻⵖ ⵏ ⵍⴻⵀⵏⴰ ⵓ ⵃⵉⵎⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ: ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS22_28","007_22_28","JOS","22","28","28","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵏⵏⴰ: ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵉⵏⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵢⴰ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓ ⵉ ⵊⵊⵉⵍⴰⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵉⵏⵉ: ‘ⵅⵣⴰⵔⴻⵎ, ⴰⵎⴻⴷⵢⴰ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵓⵄⴰⵍⵟⴰⵔ-ⴰ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵊⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴷ ⴽⴻⵏⵏⵉⵡ.’ ");
INSERT INTO rift_vpl VALUES ("JS22_29","007_22_29","JOS","22","29","29","ⵉⴳⴳⵯⴻⵊ ⵅⴰⵏⴻⵖ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵖⴻⵡⵡⴻⵖ ⵅ ⵙⵉⴷⵉ ⵏⵉⵖ ⴰⵙⵙ-ⴰ ⴰⴷ ⵏⴻⵡⵛ ⵙ ⵡⴻⵄⵔⵓⵔ ⵉ ⵙⵉⴷⵉ ⵓⵎⵉ ⵖⴰ ⵏⴻⴱⵏⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵉⵖ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵖⵏⵉ, ⵉⵍⵍⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JS22_30","007_22_30","JOS","22","30","30","ⴰⴽⴻⵀⵀⴰⵏ ⴼⵉⵏⴰⵃⴰⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⵓⵍⵓⴼ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⵙⵍⵉⵏ ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵓ ⵜⵓⵖⴰ ⴰⵢⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS22_31","007_22_31","JOS","22","31","31","ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵉⵏⵏⴰ ⵉ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⵓ ⵉ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⵉ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: “ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵖ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵖⴷⴰⵔⴻⵎ ⵛⴰ ⵙⵉⴷⵉ. ⵙ ⵓⵢⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴼⴻⴽⴽⴻⵎ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS22_32","007_22_32","JOS","22","32","32","ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵓⴽⴻⵀⵀⴰⵏ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴷⴰⵢⵙⴻⵏ ⵍⴻⵅⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JS22_33","007_22_33","JOS","22","33","33","ⵜⵓⵖⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵃⴻⵎⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵏⵏⴰⵏ ⵄⴰⴷ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JS22_34","007_22_34","JOS","22","34","34","ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵍⴰⵖⴰⵏ ⴰⵙ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ: “ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵊⴰⵔ ⴰⵏⴻⵖ ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS23_1","007_23_1","JOS","23","1","1","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵄⴷⵓⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ ⵉⵙⵔⴰⵉⵍ ⵍⵀⵓⴷⵏⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓ ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵡⵙⴰⵔ, ⵉⵎⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JS23_2","007_23_2","JOS","23","2","2","ⴰⵇⴰ ⵉⵍⴰⵖⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵡⵙⴰⵔⴻⵖ ⵓ ⵎⵖⴰⵔⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ");
INSERT INTO rift_vpl VALUES ("JS23_3","007_23_3","JOS","23","3","3","ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵥⵔⵉⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_4","007_23_4","JOS","23","4","4","ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⴱⴹⵉⵖ ⴰⵡⴻⵎ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⴰⵎ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵜⴻⵃⵃⵉⵖ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JS23_5","007_23_5","JOS","23","5","5","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴱⴰⵔⵔⴻⵣ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵓ ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⴰⵥⵥⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_6","007_23_6","JOS","23","6","6","ⵃⴹⴰⵎ ⴰⵟⵟⴰⵙ ⵙ ⵊⵊⴻⵀⴷ ⵓ ⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙ ⵜⵃⴻⵢⵢⵉⴷⴻⵎ ⵓⵍⴰ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("JS23_7","007_23_7","JOS","23","7","7","ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜⵚⵓⵔⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵉⵏⵏⵉ ⵄⴰⴷ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔⵡⴻⵎ, ⵓ ⵡⴰⵔ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵎ ⵄⴰⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⵊⴰⴵⴰⵎ ⵓ ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵄⴻⴱⴱⴷⴻⵎ ⵓ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⴱⴻⵏⴷⵇⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_8","007_23_8","JOS","23","8","8","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵍⴻⵚⵇⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜ ⵜⴻⴳⴳⵉⵎ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JS23_9","007_23_9","JOS","23","9","9","ⵙⵉⴷⵉ ⵢⵓⵥⵥⴻⵍ ⵅ ⵍⴻⴳⵏⵓⵙ ⵎⵖⴰⵔⴻⵏ ⵓ ⵊⵊⴻⵀⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⵓ ⵅⴰⵡⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⵍ ⴰⵙⵙ-ⴰ ⵡⴰⵔ ⴷⵉⵏ ⵃⴻⴷ ⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_10","007_23_10","JOS","23","10","10","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵡⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS23_11","007_23_11","JOS","23","11","11","ⵃⴹⴰⵎ ⵅⴻⵏⵏⵉ ⴰⵍ ⵟⵟⴰⵔⴼ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_12","007_23_12","JOS","23","12","12","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅⴰⵙ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵓⵔⵔⴻⵜ ⵡⴰⵀⴰ, ⵓⵛⴰ ⴰⴷ ⵜⵍⴻⵚⵇⴻⵎ ⵉ ⵎⵉⵏ ⴽⵉⴷⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵉ ⵢⵉⵏⵏⵉ ⴽⵉⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⴹⴻⴳⴳⵯⴰⵍⴻⵏ ⵓ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⴰⴷⴼⴻⵎ ⵓ ⵏⵉⵜⵏⵉ ⴰⵎ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("JS23_13","007_23_13","JOS","23","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵉⵜⵜⵉⵥⵥⴻⵍ ⵄⴰⴷ ⵅ ⵍⴻⴳⵏⵓⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴼⴻⵅ ⴷ ⵜⵔⴰⵛⵛⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴷ ⵜⵉⵢⵢⵉⵜⴰ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⵅ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_14","007_23_14","JOS","23","14","14","ⵅⵣⴰⵔ, ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴰⴱⵔⵉⴷ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵅⴰⵡⴻⵎ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ. ⵎⴰⵔⵔⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵅⴰⵡⴻⵎ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JS23_15","007_23_15","JOS","23","15","15","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵢⵓⵙⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍ ⵉⵛⵏⴰⵏ ⵉ ⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⴼⴻⵍ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⴽⵓⵍ ⴰⵡⴰⵍ ⵉⵄⴻⴼⴼⵏⴻⵏ ⴰⵍ ⵏⴻⵜⵜⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵜⴻⵃⵃⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS23_16","007_23_16","JOS","23","16","16","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⴷⴷⴰⵎ ⵅ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵅ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⴷ ⵜⵄⴻⴱⴷⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵓⴹⴰⵔⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⴰⵎ ⴷⴻⵖⵢⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JS24_1","007_24_1","JOS","24","1","1","ⵢⴰⵛⵓⵡⴰ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵛⴰⴽⵉⵎ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵙⴻⵏ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JS24_2","007_24_2","JOS","24","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵣⴻⴷⴷⵖⴻⵏ ⵣⵉ ⵛⵃⴰⵍ ⵓⵢⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵢⴻⵖⵥⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵜⴰⵔⴰⵃ, ⴱⴰⴱⴰⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵏⴰⵃⵓⵔ, ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JS24_3","007_24_3","JOS","24","3","3","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵖ-ⴷⴷ ⵊⴻⴷⴷⵉⵜⵡⴻⵎ ⵉⴱⵔⴰⵀⵉⵎ ⵣⴻⴳ ⵓⵖⵉⵔⵉⵏ ⵉ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓ ⵊⵊⵉⵖ ⵜ ⵢⵓⵢⵓⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵏⴻⵛⵛ ⴰⵔⵏⵉⵖ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵓ ⵡⵛⵉⵖ ⴰⵙ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("JS24_4","007_24_4","JOS","24","4","4","ⵉ ⵉⵙⵃⴰⵇ ⵡⵛⵉⵖ ⵢⴰⵄⵇⵓⴱ ⴷ ⵄⵉⵙⵓ, ⵓ ⵉ ⵄⵉⵙⵓ ⵡⵛⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵢⴰⵄⵇⵓⴱ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵀⵡⴰⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JS24_5","007_24_5","JOS","24","5","5","ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓⵛⴰ ⵡⵜⵉⵖ ⵎⵉⵚⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⴳⴳⵉⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JS24_6","007_24_6","JOS","24","6","6","ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⴹⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵓ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴹⴼⴰⵔⴻⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵡⴻⵎ ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("JS24_7","007_24_7","JOS","24","7","7","ⵓⵛⴰ ⵙⵖⵓⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⴵⴻⵙⵜ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵊⵊⴰ ⵍⴻⴱⵃⴰⵔ ⵉⵙⵙⴼⴻⵢⵢⴻⴹ ⵅⴰⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵉⴷⵍⴰ. ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵜⴻⵥⵔⵉⵎ ⵎⵉⵏ ⴳⴳⵉⵖ ⴷⵉ ⵎⵉⵚⵔⴰ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵜⵓⵖⴰ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JS24_8","007_24_8","JOS","24","8","8","ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴰⵖⵉⵔⵉⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ. ⵏⵉⵜⵏⵉ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⵇⴹⵉⵖ ⵅⴰⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS24_9","007_24_9","JOS","24","9","9","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴱⴰⵍⴰⴽ, ⵎⵎⵉⵙ ⵏ ⵙⴰⴼⴼⵓⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵃⵉⵎⴰ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⴱⵉⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵄⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JS24_10","007_24_10","JOS","24","10","10","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵙⵍⴻⵖ ⵉ ⴱⴰⵍⵄⴰⵎ. ⵙ ⵓⵢⴰ ⵉⴱⴰⵔⴻⴽ ⵏⴻⵜⵜⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵟⵟⴰⵙ ⵓ ⵏⴻⵛⵛ ⴼⴻⴽⴽⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS24_11","007_24_11","JOS","24","11","11","ⵅⴻⵏⵏⵉ ⵜⴻⵥⵡⴰⵎ ⵍ’ⵓⵔⴷⵓⵏ, ⵜⵓⵙⵉⵎ-ⴷⴷ ⵖⴰⵔ ⴰⵔⵉⵃⴰ. ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴰⵔⵉⵃⴰ, ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ, ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵊⵉⵔⵊⴰⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS24_12","007_24_12","JOS","24","12","12","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵔⴻⵣⵣⴰⵏ ⵉⴹⴰⵔⵖⴰⵍⴻⵏ ⵓⵛⴰ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙⴻⵏ ⵣⵣⴰⵜⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⵥⵥⵍⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵙⵙⵉⴼ ⵏⵡⴻⵎ ⵓⵍⴰ ⵙ ⵍⵇⴻⵡⵙ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS24_13","007_24_13","JOS","24","13","13","ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵅ ⵡⴰⵔ ⵜⴰⵔⴻⴱⵔⴻⵎ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⴱⵏⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴷⴰⵢⵙⴻⵏⵜ. ⵓⵛⴰ ⵜⴻⵛⵛⵉⵎ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵉⵏ ⴷ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⴻⵥⵥⵓⵎ.’ ");
INSERT INTO rift_vpl VALUES ("JS24_14","007_24_14","JOS","24","14","14","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴳⴳⵯⴻⴷⴻⵎ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⴰⵙ ⵙ ⵍⴻⴽⵎⴰⵔⴻⵜ ⴷ ⵍⴰⵎⴰⵏ. ⵏⴹⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵓⵎⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⵖⵉⵔⵉⵏ ⵉ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS24_15","007_24_15","JOS","24","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵎ ⴰⵙⵙ-ⴰ ⵉ ⵎⴰⵏ ⵡⴻⵏ ⵓⵎⵉ ⵉ ⵖⴰ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ, ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵓⵎⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⵖⵉⵔⵉⵏ ⵉ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵏⵉⵖ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⵣⴻⴷⴷⵖⴻⵎ. ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("JS24_16","007_24_16","JOS","24","16","16","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ: “ⵎⴰⵏ ⴰⵢⴰ ⵉⴳⴳⵯⴻⵊ ⴰⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵊⵊ ⵙⵉⴷⵉ ⴰⴷ ⵏⴻⵅⴷⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JS24_17","007_24_17","JOS","24","17","17","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵍⴻⵇⵇⴰ ⵅⴰⵏⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⴱⵔⵉⴷ ⵉ ⵏⵓⵢⵓⵔ ⵓ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵓⵎⵉ ⵏⵛⵓⵇ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JS24_18","007_24_18","JOS","24","18","18","ⵙⵉⴷⵉ ⵢⵓⵥⵥⴻⵍ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ, ⵓⵍⴰ ⵅ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JS24_19","007_24_19","JOS","24","19","19","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵇⴻⴷⴷⴻⵙ ⴰⵟⵟⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵖⴻⴼⴼⴰⵔ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵡⴻⵎ ⴷ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JS24_20","007_24_20","JOS","24","20","20","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵊⵊⵉⵎ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵏⵏⴻⵇⵍⴻⴱ, ⴰⴷ ⴷ ⴰⵡⴻⵎ ⵉⴳⴳ ⵍⵖⴰⵔ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴹⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵇⴱⴻⵍ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JS24_21","007_24_21","JOS","24","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴳⴻⵏⵙ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵍⵍⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JS24_22","007_24_22","JOS","24","22","22","ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴼⴰⵔⵣⴻⵎ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ.” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ “ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵛⵀⵓⴷ!” ");
INSERT INTO rift_vpl VALUES ("JS24_23","007_24_23","JOS","24","23","23","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⴹⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵓ ⵜⴰⵔⵔⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("JS24_24","007_24_24","JOS","24","24","24","ⵉⵏⵏⴰ ⵍⴳⴻⵏⵙ ⵉ ⵢⴰⵛⵓⵡⴰ: “ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓⵛⴰ ⴰⴷ ⵏⵙⴻⵍ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JS24_25","007_24_25","JOS","24","25","25","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴳⴳⴰ ⵢⴰⵛⵓⵡⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⴷⵉ ⵛⴰⴽⵉⵎ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⴷ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JS24_26","007_24_26","JOS","24","26","26","ⵢⵓⵔⴰ ⵢⴰⵛⵓⵡⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⵛⴰⴽⵉⵎ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JS24_27","007_24_27","JOS","24","27","27","ⵉⵏⵏⴰ ⵢⴰⵛⵓⵡⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⵅⵣⴰⵔⴻⵎ, ⴰⵥⵔⵓ-ⵢⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⴽⵉⴷⵏⴻⵖ ⵉⵙⵙⵉⵡⴻⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵉ ⴽⴻⵏⵏⵉⵡ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵖⴻⵛⵛⴰⵎ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JS24_28","007_24_28","JOS","24","28","28","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵅⵓ ⵢⴰⵛⵓⵡⴰ ⵉ ⵍⴳⴻⵏⵙ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JS24_29","007_24_29","JOS","24","29","29","ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵎⵓⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JS24_30","007_24_30","JOS","24","30","30","ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵜⵉⵎⵏⴰⵜ-ⵙⴰⵔⴰⵃ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⴰⵄⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JS24_31","007_24_31","JOS","24","31","31","ⵉⵙⵔⴰⵉⵍ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵛⵓⵡⴰ ⴷ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⴰⵣⵉⵔⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⴰⵛⵓⵡⴰ ⵓ ⵙⵙⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JS24_32","007_24_32","JOS","24","32","32","ⵉⵅⵙⴰⵏ ⵏ ⵢⵓⵙⵓⴼ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵡⵢⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵏⴻⴹⵍⴻⵏ ⵜⴻⵏ ⴷⵉ ⵛⴰⴽⵉⵎ ⴷⵉ ⵜⴽⵉⵔⴰⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⵙⵖⴰ ⵢⴰⵄⵇⵓⴱ ⵅ ⴰⵢⵜ ⵏ ⵃⴰⵎⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⴽⵉⵎ, ⵙ ⵎⵢⴰ ⵏ ⵉⵣⵉⵢⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵡⴻⵣⵏⴻⵏ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("JS24_33","007_24_33","JOS","24","33","33","ⵓⵍⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴼⵉⵏⴰⵃⴰⵙ, ⵜⴰⵡⵔⵉⵔⵜ ⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉ ⴼⵉⵏⴰⵃⴰⵙ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG1_1","008_1_1","JDG","1","1","1","ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵢⴰⵛⵓⵡⴰ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⵙⴻⵇⵙⴰⵏ ⵙⵉⴷⵉ, ⵏⵏⴰⵏ: “ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉ ⵖⴰ ⵉⴽⴽⴰⵔⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("JG1_2","008_1_2","JDG","1","2","2","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙⵉⴷⵉ: “ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵙ ⵜⴰⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG1_3","008_1_3","JDG","1","3","3","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ ⵉ ⵓⵎⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⴳⴻⵄⵄⴻⴷ ⴰⴽⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵏ ⵍⴻⵄⴱⴰⵔ ⵉⵏⵓ ⵓⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⴳⴻⵄⵄⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵏⵏⴻⵛ.” ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG1_4","008_1_4","JDG","1","4","4","ⵉⴳⴻⵄⵄⴻⴷ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵄⴰⵔⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅⴰⵙⴻⵏ ⵖⴰⵔ ⴱⴰⵣⴰⵇ, ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⵉⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG1_5","008_1_5","JDG","1","5","5","ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⴰⴷⵓⵏⵉ-ⴱⴰⵣⴰⵇ ⴷⵉ ⴱⴰⵣⴰⵇ ⵓⵛⴰ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⵖⴻⵍⴱⴻⵏ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓ ⵅ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG1_6","008_1_6","JDG","1","6","6","ⵎⴰⵛⴰ ⴰⴷⵓⵏⵉ-ⴱⴰⵣⴰⵇ ⵢⴰⵔⵡⴻⵍ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵜ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜ ⵓⵛⴰ ⵇⴻⵙⵙⴻⵏ ⴰⵙ ⵉⵎⵣⴰⵡⴻⵏ ⴷ ⵜⴼⴻⴷⵏⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG1_7","008_1_7","JDG","1","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴷⵓⵏⵉ-ⴱⴰⵣⴰⵇ: “ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⴰⵙⴻⵏ ⵉⵎⵣⴰⵡⴻⵏ ⴷ ⵜⴼⴻⴷⵏⵉⵏ, ⵜⵓⵖⴰ ⵍⴻⵇⵇⴹⴻⵏ ⵉⵍⴻⵇⵇⵯⴰⵣ ⵙⴰⴷⵓ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ. ⵎⴰⵎⵎⴻⵛ ⵉ ⴽⵉⴷⵙⴻⵏ ⴳⴳⵉⵖ, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵅⴻⴵⴻⵚ ⴰⵔⴻⴱⴱⵉ!” ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG1_8","008_1_8","JDG","1","8","8","ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜⵜ, ⵡⵜⵉⵏ ⵜⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵇⵇⴻⴷⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JG1_9","008_1_9","JDG","1","9","9","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵀⵡⴰⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG1_10","008_1_10","JDG","1","10","10","ⵉⴼⴼⴻⵖ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵃⴰⴱⵔⵓⵏ. ⵉⵙⴻⵎ ⵏ ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⵣⵉⵛ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵇⴰⵔⵢⴰⵜ-ⴰⵔⴱⴰⵄ. ⵏⵉⵜⵏⵉ ⵖⴻⵍⴱⴻⵏ ⵅ ⵛⵉⵛⴰⵢ ⴷ ⴰⵅⵉⵎⴰⵏ ⴷ ⵜⴰⵍⵎⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JG1_11","008_1_11","JDG","1","11","11","ⵙⵙⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴰⴱⵉⵔ. ⵉⵙⴻⵎ ⵏ ⴷⴰⴱⵉⵔ ⵜⵓⵖⴰ ⵣⵉⵛ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵇⴰⵔⵢⴰⵜ-ⵙⴰⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG1_12","008_1_12","JDG","1","12","12","ⵉⵏⵏⴰ ⴽⴰⵍⵉⴱ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⵇⴰⵔⵢⴰⵜ-ⵙⴰⴼⴰⵔ ⴰⴷ ⵜⵜ ⵉⵟⵟⴻⴼ, ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵢⴻⴵⵉ ⴰⵅⵙⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JG1_13","008_1_13","JDG","1","13","13","ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵇⵉⵏⴰⵣ, ⵓⵎⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⴽⴰⵍⵉⴱ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ. ⵓⵛⴰ ⴽⴰⵍⵉⴱ ⵉⵡⵛⴰ ⴰⵙ ⵢⴻⴵⵉⵙ ⴰⵅⵙⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG1_14","008_1_14","JDG","1","14","14","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⵓⵙⴰ ⵏⴻⵜⵜⴰⵜ, ⵜⵄⴰⵔⵏ ⵉ-ⵜ ⵙ ⵜⵓⵜⵔⴰ ⵅ ⵢⴻⵢⵢⴰⵔ ⵏ ⴱⴰⴱⴰⵙ. ⵓⵛⴰ ⵜⴻⴹⵔⴰ ⵅ ⵡⴻⵖⵢⵓⵍ. ⵉⵙⵙⴻⵇⵙⴰ ⵜⵜ ⴽⴰⵍⵉⴱ: “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("JG1_15","008_1_15","JDG","1","15","15","ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴻⵡⵛ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ, ⵎⵉⵏⵣⵉ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⵔⴻⵇⵇⵉⵄⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴻⵡⵛ ⴰⵢⵉ ⵓⵍⴰ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ!” ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⴽⴰⵍⵉⴱ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵏⴻⵊ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JG1_16","008_1_16","JDG","1","16","16","ⴳⴻⵄⵄⴷⴻⵏ ⴰⵔⵔⴰⵡ ⵏ ⵓⵇⵉⵏⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⴹⴻⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ, ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵖⴰⵔ ⵄⴰⵔⴰⴷ. ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ, ⵣⴻⴷⴷⵖⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JG1_17","008_1_17","JDG","1","17","17","ⵉⵔⵓⵃ ⵢⴰⵀⵓⴷⴰ ⴰⴽ-ⴷ ⵓⵎⴰⵙ ⵛⵉⵎⵄⵓⵏ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵚⴰⴼⴰⵜ, ⵃⴰⵔⵔⵎⴻⵏ ⵜⴻⵏ ⵇⴰⵄ ⵓⵛⴰ ⵜⴻⵃⵃⴰⵏ ⵜⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵃⵓⵔⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("JG1_18","008_1_18","JDG","1","18","18","ⵉⵟⵟⴻⴼ ⵢⴰⵀⵓⴷⴰ ⵓⵍⴰ ⴷ ⵖⴰⵣⵣⴰ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⴰⵛⵇⴰⵍⵓⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⵄⴰⵇⵔⵓⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG1_19","008_1_19","JDG","1","19","19","ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ ⴰⵍⴰⵎⵉ ⵢⵓⵥⵥⴻⵍ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵎⴰⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴻⵡⴷⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⴰⵥⵥⴻⵍ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JG1_20","008_1_20","JDG","1","20","20","ⵉ ⴽⴰⵍⵉⴱ ⵡⵛⵉⵏ ⴰⵙ ⵃⴰⴱⵔⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵎⵓⵙⴰ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵥⵥⴻⵍ ⵙⵙⴻⵏⵏⵉ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵏⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("JG1_21","008_1_21","JDG","1","21","21","ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵥⵥⵍⴻⵏ ⵅ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⵎⵎⵓ ⵉ ⵇⵇⵉⵎⴻⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JG1_22","008_1_22","JDG","1","22","22","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⵜⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⵓⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG1_23","008_1_23","JDG","1","23","23","ⵜⵓⵢⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⵔⴳⴰⴳ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵣⵉⵛ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵍⵓⵣ. ");
INSERT INTO rift_vpl VALUES ("JG1_24","008_1_24","JDG","1","24","24","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵍⴻⴱⵜⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵥⵔⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⵙⵛⴻⵏ ⴰⵏⴻⵖ ⵎⴰⵏⵉⵙ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴽⵉⴽ ⵏⴻⴳⴳ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG1_25","008_1_25","JDG","1","25","25","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵔⴰⴵ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG1_26","008_1_26","JDG","1","26","26","ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⴳⴳⴰ ⴰⵙ ⵉⵙⴻⵎ ⵍⵓⵣ. ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JG1_27","008_1_27","JDG","1","27","27","ⵎⴰⵏⴰⵙⵙⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵏ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵍⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴰⵄⵏⴰⴽ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵍⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⵓⵔ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵍⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⵉⴱⵍⴰⵄⴰⵎ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵓⵍⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵎⴰⵊⵉⴷⴷⵓ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵄⴻⵡⵡⵍⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG1_28","008_1_28","JDG","1","28","28","ⵜⵓⵖⴰ ⵉⵙⵔⴰⵉⵍ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵍⵊⵉⵣⵢⴰ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵥⵥⵍⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JG1_29","008_1_29","JDG","1","29","29","ⵓⵍⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵊⴰⵣⴰⵔ ⵓ ⵇⵇⵉⵎⴻⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⴷⵉ ⵊⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG1_30","008_1_30","JDG","1","30","30","ⵣⴰⴱⵓⵍⵓⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵇⵉⵟⵔⵓⵏ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵏⴰⵀⴰⵍⵓⵍ ⵓ ⵇⵇⵉⵎⴻⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵅⴰⵙⴻⵏ ⵍⵊⵉⵣⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JG1_31","008_1_31","JDG","1","31","31","ⴰⵛⵉⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵄⴰⴽⴽⵓ ⵓⵍⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵚⵉⴷⵓⵏ ⴷ ⴰⵃⵍⴰⴱ ⴷ ⴰⴽⵣⵉⴱ ⴷ ⵀⴰⵍⴱⴰ ⴷ ⴰⴼⵉⵇ ⴷ ⵔⴰⵃⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JG1_32","008_1_32","JDG","1","32","32","ⵉⵛⵉⵔⵉⵢⵢⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⵏⵏⵉ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵥⵥⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG1_33","008_1_33","JDG","1","33","33","ⵏⴰⴼⵜⴰⵍⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⵢⵜ-ⵄⴰⵏⴰⵜ. ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵉⵏⵏⵉ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵜᵉⵜⵜⵡⴰⴳⴳ ⵅⴰⵙⴻⵏ ⵍⵊⵉⵣⵢⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⴷ ⴱⴰⵢⵜ-ⵄⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG1_34","008_1_34","JDG","1","34","34","ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵃⵚⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵏ ⵊⵊⵉⵏ ⴰⴷ ⵀⵡⴰⵏ ⵖⴰⵔ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG1_35","008_1_35","JDG","1","35","35","ⵜⵓⵖⴰ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵄⴻⵡⵡⵍⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵃⴰⵔⴰⵙ, ⴷⵉ ⴰⵢⴰⵍⵓⵏ ⵓ ⴷⵉ ⵛⴰⵄⴰⵍⴱⵉⵎ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⵜⵓⵖⴰ ⵉⵣⴻⵢⵢⴰⵔ ⵅⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⵅⴰⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵍⵊⵉⵣⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JG1_36","008_1_36","JDG","1","36","36","ⵜⵓⵖⴰ ⴰⵢⵎⵉⵔ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵣⵉ ⵜⵙⵓⵏⵜⴰ ⵏ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ, ⵣⵉ ⵊⵊⴰⵔⴼ ⵓⵛⴰ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JG2_1","008_2_1","JDG","2","1","1","ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵊⵉⵍⵊⴰⵍ ⵖⴰⵔ ⴱⵓⴽⵉⵎ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⵡⵢⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵊⵊⵓⴵⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜⴰⵔⴻⵥⵥⵉⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵡⴻⵎ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JG2_2","008_2_2","JDG","2","2","2","ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⵖⴻⴹⵍⴻⵎ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ!’ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⴳⴳⵉⵎ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("JG2_3","008_2_3","JDG","2","3","3","ⵓ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵄⴰⵡⴻⴷ: ‘ⴰⵇⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⴰⵥⵥⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴰⵡⴻⵎ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴼⴻⵅ.’” ");
INSERT INTO rift_vpl VALUES ("JG2_4","008_2_4","JDG","2","4","4","ⵓⵎⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵔⵓⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG2_5","008_2_5","JDG","2","5","5","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ‘ⴱⵓⴽⵉⵎ’ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⴷⵉⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG2_6","008_2_6","JDG","2","6","6","ⵓⵎⵉ ⵉⵙⵙⴻⴽⴽ ⵢⴰⵛⵓⵡⴰ ⵍⴳⴻⵏⵙ, ⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵖⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG2_7","008_2_7","JDG","2","7","7","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵛⵓⵡⴰ ⴷ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵄⴰⴷ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⴰⵛⵓⵡⴰ ⵓ ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵜⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG2_8","008_2_8","JDG","2","8","8","ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵎⵓⵜ ⴰⵎ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴱⴰⴱ ⵏ ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG2_9","008_2_9","JDG","2","9","9","ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴰⵅⴻⵍ ⵉ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵜⵉⵎⵏⴰⵜ-ⵃⴰⵔⴰⵙ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⴰⵄⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JG2_10","008_2_10","JDG","2","10","10","ⵓ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵍ ⵏⵏⵉ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏ ⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵏⵏⴻⵖⵏⵉ, ⵊⵊⵉⵍ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵛⴰ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵛⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG2_11","008_2_11","JDG","2","11","11","ⵅⴻⵏⵏⵉ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ");
INSERT INTO rift_vpl VALUES ("JG2_12","008_2_12","JDG","2","12","12","ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙⴻⵏ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ, ⵓⵛⴰ ⵓⴹⴰⵔⴻⵏ ⴰⵙⴻⵏ ⵓ ⴰⵎⵎⵓ ⵉ ⵙⵄⴰⵔⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG2_13","008_2_13","JDG","2","13","13","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴱⴰⵄⴰⵍ ⵓ ⵉ ‘ⵄⴰⵛⵜⴰⵔⵓⵜⵉⵏ’. ");
INSERT INTO rift_vpl VALUES ("JG2_14","008_2_14","JDG","2","14","14","ⵅ ⵓⵢⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ ⵉ ⵜⴻⵏ ⵉⴽⴻⵛⵛⴹⴻⵏ ⵓ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG2_15","008_2_15","JDG","2","15","15","ⵎⴰⵏⵉ ⵎⴰ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ, ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵉ ⵍⵖⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ. ⴰⵇⴰ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG2_16","008_2_16","JDG","2","16","16","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵍⵇⵓⴹⴰⵜ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⴽⴻⵛⵛⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG2_17","008_2_17","JDG","2","17","17","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵓⵍⴰ ⵖⴰⵔ ⵍⵇⵓⴹⴰⵜ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵎⵉ ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵓⴹⴰⵔⴻⵏ ⴰⵙⴻⵏ. ⴷⴻⵖⵢⴰ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵉ ⴷⵉ ⵓⵢⵓⵔⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵍⵉⵏ ⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⴳⴳⵉⵏ ⴰⵎⴻⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("JG2_18","008_2_18","JDG","2","18","18","ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴰⵔ ⵙⵉⴷⵉ ⵍⵇⵓⴹⴰⵜ, ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵍⵇⴰⴹⵉ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵍⵇⴰⴹⵉ ⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵏⴷⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⵚⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉ ⵅⴰⵙⴻⵏ ⵉⵜⵜⴰⵥⵥⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG2_19","008_2_19","JDG","2","19","19","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⵍⵇⴰⴹⵉ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵄⴻⴼⴼⵏⴻⵏ ⴽⵜⴰⵔ ⵣⴻⴳ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓⵎⵉ ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵙⴻⵏ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵊⵊⵉⵏ ⵣⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵓ ⵣⵉ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵉ ⵜⵓⵖⴰ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵙ ⵜⵖⴻⵏⵏⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG2_20","008_2_20","JDG","2","20","20","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵉⵄⴻⴷⴷⴰ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵎⵉⵏ ⵅⴻⴼ ⵡⴻⵚⵚⵉⵖ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵙⵍⵉⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JG2_21","008_2_21","JDG","2","21","21","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵖ ⵄⴰⴷ ⴰⴷ ⴰⵥⵥⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵊⵊⴰ ⵢⴰⵛⵓⵡⴰ, ⵓⵎⵉ ⵉⵎⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("JG2_22","008_2_22","JDG","2","22","22","ⴰⵍⴰⵎⵉ ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵇⴻⴵⴱⴻⵖ ⵉⵙⵔⴰⵉⵍ, ⵎⴰ ⴰⴷ ⵃⴹⴰⵏ ⵏⵉⵜⵏⵉ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵓⵢⵓⵔⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵃⴹⴰⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵏⵉⵖ ⵍⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG2_23","008_2_23","JDG","2","23","23","ⵓⵛⴰ ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⵍⴻⴳⵏⵓⵙ-ⴰ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵢⵓⵥⵥⵉⵍ ⴷⴻⵖⵢⴰ ⵓ ⵄⴰⵡⴻⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⴳⴳⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⴰⵛⵓⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JG3_1","008_3_1","JDG","3","1","1","ⵉⵏⴰ ⴷ ⵍⴻⴳⵏⵓⵙ ⵉ ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⴻⴵⴻⴱ ⵉⵙⵔⴰⵉⵍ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵄⴰⴷ ⵅ ⵎⴰⵔⵔⴰ ⴳⴰⵔⵔⴰⵜ ⴰⴽ-ⴷ ⴽⴻⵏⵄⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JG3_2","008_3_2","JDG","3","2","2","ⵎⵖⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵊⵊⵉⵍⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ, ⵎⵖⵉⵔ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴰⵎⴻⵏⵖⵉ: ");
INSERT INTO rift_vpl VALUES ("JG3_3","008_3_3","JDG","3","3","3","ⵅⴻⵎⵙⴰ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵚⵉⴷⵓⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⴱⴰⵄⵍ-ⵀⵉⵔⵎⵓⵏ ⴰⵍ ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG3_4","008_3_4","JDG","3","4","4","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵇⴻⴵⴻⴱ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⵜⵉⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG3_5","008_3_5","JDG","3","5","5","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ: ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG3_6","008_3_6","JDG","3","6","6","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⵡⵛⵉⵏ ⵜⴻⵏⵜ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ. * ");
INSERT INTO rift_vpl VALUES ("JG3_7","008_3_7","JDG","3","7","7","ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵜⵜⵓⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⴷ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵛⵡⴰⵔⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("JG3_8","008_3_8","JDG","3","8","8","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴽⵓⵛⴰⵏ-ⵔⵉⵛⴰⵄⵜⴰⵢⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ-ⵏⴰⵀⵔⴰⵢⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ. ⵅⴻⵏⵏⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴽⵓⵛⴰⵏ-ⵔⵉⵛⴰⵄⵜⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG3_9","008_3_9","JDG","3","9","9","ⵙⵖⵓⵢⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⴷ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵏⵊⴻⵎ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⴼⴻⴽⴽⴻⵏ, ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵏⴰⵣ, ⵓⵎⴰⵙ ⵏ ⴽⴰⵍⵉⴱ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG3_10","008_3_10","JDG","3","10","10","ⵜⵓⵖⴰ ⵅⴰⵙ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ⵉⵡⵛⴰ ⴰⵙ ⵙⵉⴷⵉ ⴽⵓⵛⴰⵏ-ⵔⵉⵛⴰⵄⵜⴰⵢⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵖⵍⴻⴱ ⵏⴻⵜⵜⴰ ⵅ ⴽⵓⵛⴰⵏ-ⵔⵉⵛⴰⵄⵜⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG3_11","008_3_11","JDG","3","11","11","ⵜⴰⵔⴻⵢⵢⴻⵃ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵏⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("JG3_12","008_3_12","JDG","3","12","12","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⵏⵉⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵊⵊⴻⵀⴷ ⴷⵉ ⵄⵉⵊⵍⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG3_13","008_3_13","JDG","3","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ ⵖⴰⵔⴻⵙ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵓⵛⴰ ⵉⴼⴼⴻⵖ, ⵉⵖⵍⴻⴱ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG3_14","008_3_14","JDG","3","14","14","ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵄⵉⵊⵍⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JG3_15","008_3_15","JDG","3","15","15","ⵅⴻⵏⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵏⵊⴻⵎ, ⵉⵀⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵔⴰ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴷⴰⵔⵔⴻⴱ ⵎⵍⵉⵃ ⵙ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ. ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⵙⴻⴽⴽⴻⵏ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ ⵉ ⵄⵉⵊⵍⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG3_16","008_3_16","JDG","3","16","16","ⵉⵀⵓⴷ ⵉⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⴷⵓⵄ, ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ, ⵉⵇⵇⴻⵏ ⵉ-ⵜ ⵙⴰⴷⵓ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ ⵜⴰⴼⵓⵙⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JG3_17","008_3_17","JDG","3","17","17","ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵙ ⵜⴻⵔⵣⴻⴼⵜ ⵖⴰⵔ ⵄⵉⵊⵍⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵄⵉⵊⵍⵓⵏ ⵜⵓⵖⴰ ⴷ ⴰⵔⵢⴰⵣ ⵉⵚⴻⵃⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG3_18","008_3_18","JDG","3","18","18","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵀⵓⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵜⵉⵎⴻⵡⵛⴰ ⵏ ⵜⴰⵔⵣⴻⴼⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵉⵡⴷⴰⵏ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ");
INSERT INTO rift_vpl VALUES ("JG3_19","008_3_19","JDG","3","19","19","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵄⵇⴻⴱ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵣⵉ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵊⵉⵍⵊⴰⵍ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵙⵙⵉⵔ ⵅⴰⴽ, ⴰⵊⴻⴵⵉⴷ!” ⵓⵛⴰ ⵡⴰ ⵉⵏⵏⴰ: “ⵙⵇⴰⵔⴻⵎ!” ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔⴻⵙ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JG3_20","008_3_20","JDG","3","20","20","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵀⵓⴷ ⵓⵎⵉ ⵄⵉⵊⵍⵓⵏ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ ⴰⵙⴻⵎⵎⴰⴹ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵀⵓⴷ: “ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵛⴻⴽ.” ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵣⵉ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⵉⴳⴻⵍⵍⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG3_21","008_3_21","JDG","3","21","21","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⵀⵓⴷ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ, ⵉⵊⴱⴻⴷ-ⴷⴷ ⵙⵙⵉⴼ ⵏⵏⵉ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ ⵜⴰⴼⵓⵙⴻⵛⵜ, ⵉⵛⵓⴽⴽ ⵉ-ⵜ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JG3_22","008_3_22","JDG","3","22","22","ⴰⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵙ ⵓⴼⵓⵙ ⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⵓⵙ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⵜⴰⴷⵓⵏⵜ ⵜⴱⴻⵍⵍⴻⵄ-ⴷⴷ ⵅ ⵍⵎⵓⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴽⴽⵉⵙ ⵙⵙⵉⴼ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ. ⵅⴰⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵢⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("JG3_23","008_3_23","JDG","3","23","23","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵉⵀⵓⴷ ⵣⴻⴳ ⵡⵓⴼⴼⵓⵖ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵡⴻⵙⵇⵉⴼ. ⵉⴱⴻⵍⵍⴻⵄ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓ ⵢⴰⵔⵔⴰ ⵣⵣⴻⴽⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG3_24","008_3_24","JDG","3","24","24","ⵓⵎⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ, ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵇⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ ⵜⵜⵡⴰⴱⴻⵍⵍⵄⴻⵏⵜ ⵙ ⵣⵣⴻⴽⵔⵓⵏ, ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⴷⵍⴰ ⵡⴰⵀⴰ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⴰⵙⴻⵎⵎⴰⴹ ⵏ ⴷⴰⵅⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("JG3_25","008_3_25","JDG","3","25","25","ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵔⴰⵊⴰⵏ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵙⵙⴻⵚⵃⴰⵏ, ⵓ ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⴰⵔⵣⵉⵎ ⵛⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ. ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵙⵙⴰⵔⵓⵜ, ⴰⵔⵣⵎⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵎⵎⴻⵏⴹⴰⵔ ⵙⵉⴷⵉⵜⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JG3_26","008_3_26","JDG","3","26","26","ⵉⵀⵓⴷ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ, ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵔⴰⵊⴰⵏ ⵏⵉⵜⵏⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴽⴽⴰ ⵅ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵙⵉⵄⵉⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG3_27","008_3_27","JDG","3","27","27","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ ⴷⵉⵏⵏⵉ, ⵉⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ⵅⴻⵏⵏⵉ ⵀⵡⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵢⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG3_28","008_3_28","JDG","3","28","28","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴹⴼⴰⵔⴻⵎ ⴰⵢⵉ-ⴷⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ.” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵜ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵡⴰⵔ ⵊⵊⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵥⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JG3_29","008_3_29","JDG","3","29","29","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵡⵜⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵄⵍⴰⵃⴰⵍ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵊⴻⵀⴷⴻⵏ, ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵏⵊⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG3_30","008_3_30","JDG","3","30","30","ⴰⵎⵎⵓ ⵉⵜⵜⵡⴰⵙⵙⴷⴻⴵ ⵎⵓ’ⴰⴱ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵜⴰⵔⴻⵢⵢⴻⵃ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG3_31","008_3_31","JDG","3","31","31","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵓⵙⴰ-ⴷⴷ ⵛⴰⵎⵊⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵏⴰⵜ, ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵛⴰⵎ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ⴰⵎⵎⵓ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG4_1","008_4_1","JDG","4","1","1","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵀⵓⴷ ⵉⵎⵎⵓⵜ, ⴰⵔⵏⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG4_2","008_4_2","JDG","4","2","2","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⴰⴱⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⴻⵎ ⴷⵉ ⵃⴰⵚⵓⵔ. ⵜⵓⵖⴰ ⵙⵉⵙⴰⵔⴰ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ⵡⴰ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵀⴰⵔⵓⵛⵉⵜ-ⵀⴰ-ⵅⵓⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG4_3","008_4_3","JDG","4","3","3","ⵅⴻⵏⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵙⵉⵙⴰⵔⴰ ⵖⴰⵔⴻⵙ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵣⵣⴰⵍ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴷⴻⴵ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵍⵄⵓⵏⴼ ⵍⵎⵉⵊⴰⵍ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG4_4","008_4_4","JDG","4","4","4","ⵜⵓⵖⴰ ⴷⴰⴱⵓⵔⴰ, ⵜⴰⵏⴰⴱⵉⵜ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⴰⵔⵔⵓⵃ ⴰⵎ ⵜⵎⴻⵙⵙⵉ, ⵜⴻⵃⴽⴻⵎ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG4_5","008_4_5","JDG","4","5","5","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜᵉⵇⵇⵉⵎ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⵃⵓⴽⵎ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ ⵏ ⴷⴰⴱⵓⵔⴰ, ⵊⴰⵔ ⵔⴰⵎⴰ ⴷ ⴱⴰⵢⵜ-ⵉⵍ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⴰⵡⵢⴻⵏ ⴷⴷⴻⵄⵡⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG4_6","008_4_6","JDG","4","6","6","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⴽⴽ, ⵜⵍⴰⵖⴰ ⵉ ⴱⴰⵔⴰⵇ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵏⵓⵄⴰⵎ ⵣⵉ ⵇⴰⴷⴰⵛ ⴷⵉ ⵏⴰⴼⵜⴰⵍⵉ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵓⵢⵓⵔ, ⴼⴼⴻⵖ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴱⵓⵔ ⵓ ⵜⴰⵡⵢⴻⴷ ⴰⴽⵉⴷⴻⴽ ⵄⴻⵛⵔⴰ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("JG4_7","008_4_7","JDG","4","7","7","ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⵛⵓⵏ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⴽ ⵏⴻⴷⵀⴻⵖ ⵙⵉⵙⴰⵔⴰ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵢⴰⴱⵉⵏ, ⴰⴽ-ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵓⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⵡⵛⴻⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ!’” ");
INSERT INTO rift_vpl VALUES ("JG4_8","008_4_8","JDG","4","8","8","ⴱⴰⵔⴰⵇ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⵎ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴽⵉⴷⵉ, ⴰⴷ ⵓⵢⵓⵔⴻⵖ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴻⵎ ⵡⴰⵔ ⴽⵉⴷⵉ ⵜⵓⵢⵓⵔⴻⴷ, ⵡⴰⵔ ⴳⴳⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG4_9","008_4_9","JDG","4","9","9","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⵓⵢⵓⵔⴻⵖ ⵏⵉⵛⴰⵏ, ⵎⵖⵉⵔ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⵉⵍⵉ ⵛⵛⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⵣⵣⴻⵏⵣ ⵙⵉⵙⴰⵔⴰ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵉⵛⵜ ⵜⴻⵎⵖⴰⵔⵜ.” ⵅⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ ⴷⴰⴱⵓⵔⴰ ⵓⵛⴰ ⵜⵓⵢⵓⵔ ⴰⴽ-ⴷ ⴱⴰⵔⴰⵇ ⵖⴰⵔ ⵇⴰⴷⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JG4_10","008_4_10","JDG","4","10","10","ⵅⴻⵏⵏⵉ ⴱⴰⵔⴰⵇ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵣⴰⴱⵓⵍⵓⵏ ⴷ ⵏⴰⴼⵜⴰⵍⵉ ⵖⴰⵔ ⵇⴰⴷⴰⵛ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵅ ⵉⴹⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴷⴰⴱⵓⵔⴰ ⵜⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG4_11","008_4_11","JDG","4","11","11","ⵃⴰⴱⵉⵔ, ⴰⵇⵉⵏⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⵊⵍⴰ ⵅ ⵇⴰⵢⵉⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵃⵓⴱⴰⴱ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵎⵓⵙⴰ. ⴰⵇⴰ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⴷⵉ ⵚⴰⵄⴰⵏⴰⵢⵉⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵇⴰⴷⴰⵛ.   * ");
INSERT INTO rift_vpl VALUES ("JG4_12","008_4_12","JDG","4","12","12","ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉ ⵙⵉⵙⴰⵔⴰ, ⴰⵇⴰ ⴱⴰⵔⴰⵇ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵏⵓⵄⴰⵎ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴱⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JG4_13","008_4_13","JDG","4","13","13","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⵙⵉⵙⴰⵔⴰ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ, ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵣⵉ ⵃⴰⵔⵓⵛⴰⵜ-ⵀⴰ-ⵅⵓⵢⵉⵎ ⴰⵍ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⵛⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG4_14","008_4_14","JDG","4","14","14","ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⴷⴰⴱⵓⵔⴰ ⵉ ⴱⴰⵔⴰⵇ: “ⴽⴽⴰⵔ, ⵎⵉⵏⵣⵉ ⵡⴰ ⴷ ⴰⵙⵙ ⵉ ⴷⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵙⵉⵙⴰⵔⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵛⴻⴽ!” ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⴱⴰⵔⴰⵇ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴱⵓⵔ ⵓ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("JG4_15","008_4_15","JDG","4","15","15","ⵙⵉⴷⵉ ⵢⴰⵥⵥⴻⵍ ⵅ ⵙⵉⵙⴰⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⵔⴰⵇ, ⴰⵍⴰⵎⵉ ⵉⴹⵔⴰ ⵅ ⵓⴽⴰⵔⵔⵓ, ⵢⴰⵔⵡⴻⵍ ⵅ ⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG4_16","008_4_16","JDG","4","16","16","ⵓⵛⴰ ⴱⴰⵔⴰⵇ ⵉⴹⴼⴰⵔ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵍ ⵃⴰⵔⵓⵛⴰⵜ-ⵀⴰ-ⵅⵓⵢⵉⵎ. ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⵉⵙⴰⵔⴰ ⵉⵡⴹⴰ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JG4_17","008_4_17","JDG","4","17","17","ⵙⵉⵙⴰⵔⴰ ⵢⴰⵔⵡⴻⵍ ⵅ ⵉⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵢⴰⵄⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵃⴰⴱⵉⵔ, ⴰⵇⵉⵏⵉ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵍⴻⵀⵏⴰ ⵊⴰⵔ ⵢⴰⴱⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵚⵓⵔ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵃⴰⴱⵉⵔ, ⴰⵇⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG4_18","008_4_18","JDG","4","18","18","ⵢⴰⵄⵉⵍ ⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵙⵉⵙⴰⵔⴰ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴻⵊⵊ ⴰⴱⵔⵉⴷ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⴱⵔⵉⴷ ⵖⴰⵔⵉ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵢⵓⵢⵓⵔ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵍⴰ ⵉ-ⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⴰⵍⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG4_19","008_4_19","JDG","4","19","19","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴰⵏ ⴰⴷ ⵙⵡⴻⵖ, ⵏⴻⵛⵛ ⴷⴰⵢⵉ ⴰⴼⴰⴷⵉ!” ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵣⴻⵎ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵓⵖⵉ ⵓ ⵜⴻⵡⵛⴰ ⴰⵙ ⴰⴷ ⵉⵙⵓ, ⵅⴻⵏⵏⵉ ⵜⴻⴷⵍⴰ ⵉ-ⵜ ⵜⵡⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JG4_20","008_4_20","JDG","4","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵄⴰⵡⴻⴷ: “ⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵉⵙⵙⴻⵇⵙⴰ ⵛⴻⵎ, ⵉⵇⵇⴰⵔ: ‘ⵎⴰ ⴷⴰ ⵛⴰ ⵏ ⵉⵊⵊ?’, ⵅⴻⵏⵏⵉ ⴰⵔⵔ ⵅⴰⵙ: ‘ⵓⵍⴰ ⴷ ⵉⵊⵊ!’” ");
INSERT INTO rift_vpl VALUES ("JG4_21","008_4_21","JDG","4","21","21","ⵜⴻⵟⵟⴻⴼ ⵢⴰⵄⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵃⴰⴱⵉⵔ, ⵉⵊⵊ ⵏ ⵍⴻⵡⵜⴻⴷ ⵏ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⴼⴹⵉⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⴷⴻⴼ ⵖⴰⵔⴻⵙ ⵏⵀⵍⴰ ⵍⵃⴻⵙⵙ ⵓⵛⴰ ⵜⴻⵡⵜⴰ ⴰⵙ ⵍⴻⵡⵜⴻⴷ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵍⴻⵡⵜⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴵⴻⵖ ⴷⴻⴳ ⵢⵉⴹⴻⵚ ⵙ ⵍⵡⴻⵃⵍⴰⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JG4_22","008_4_22","JDG","4","22","22","ⵓ ⵅⵣⴰⵔ, ⴱⴰⵔⴰⵇ ⵜⵓⵖⴰ ⵉⴹⴻⴼⴼⴰⵔ ⵙⵉⵙⴰⵔⴰ ⵓⵛⴰ ⵜⴻⴼⴼⴻⵖ ⵢⴰⵄⵉⵍ, ⵜⵔⵓⵃ ⴰⴷ ⴽⵉⵙ ⵜⴻⵎⵎⴻⵍⵇⴰ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰⵙ-ⴷⴷ, ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵅ ⵜⴰⵔⴻⵣⵣⵓⴷ!” ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⴰⵇⴰ ⵙⵉⵙⴰⵔⴰ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵍⴻⵡⵜⴻⴷ ⴷⵉ ⵍⵃⴻⵏⴽ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG4_23","008_4_23","JDG","4","23","23","ⴰⵎⵎⵓ ⵉ ⵉⴷⴻⴵ ⵙⵉⴷⵉ ⵢⴰⴱⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG4_24","008_4_24","JDG","4","24","24","ⴰⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⴻⵏⵏⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⵓⵛⴰ ⵉⴷⵇⴻⵍ ⴰⵟⵟⴰⵙ ⵅ ⵢⴰⴱⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⴻⵃⵃⴰⵏ ⵢⴰⴱⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_1","008_5_1","JDG","5","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵖⴻⵏⵏⵊⴻⵏ ⴷⴰⴱⵓⵔⴰ ⴷ ⴱⴰⵔⴰⵇ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵏⵓⵄⴰⵎ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("JG5_2","008_5_2","JDG","5","2","2","“ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ ⵉ ⵉⵊⴻⵟⵟⴰⵢⴻⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵉⵜⵜⵡⴰⴼⴻⵙⵙⵢⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵓⵟⴻⵡⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵍⵅⴰⴹⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("JG5_3","008_5_3","JDG","5","3","3","ⵙⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵙⵃⴻⵙⵙⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ! ⵏⴻⵛⵛ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵉⵣⵍⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG5_4","008_5_4","JDG","5","4","4","ⴰ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵛⴻⴽ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵙⴰⵄⵉⵔ, ⵓⵎⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵓⵔⴻⴷ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵉⴷⵓⵎ, ⵜⴻⵏⵀⴻⵣⵣ ⵜⴻⵎⵎⵓⵔⵜ, ⵢⴰⵔⵊⵉⵊ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⵓⵍⴰ ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴼⴰⵔⵔⵖⴻⵏ-ⴷⴷ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_5","008_5_5","JDG","5","5","5","ⵉⴷⵓⵔⴰⵔ ⴼⴻⵙⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⴷⵔⴰⵔ ⵏⵏⵉ ⵏ ⵙⵉⵏⴰ, ⵉⴼⵙⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG5_6","008_5_6","JDG","5","6","6","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵛⴰⵎⵊⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵏⴰⵜ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵄⵉⵍ, ⵇⵇⵉⵎⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵅⵍⴰⵏ, ⵓ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵜⴻⴱⵔⵉⴷⵉⵏ, ⵜⵜⴻⴽⴽⴻⵏ ⵉⵎⴻⵙⵔⴰⵇ ⵉⵄⴰⵔⵔⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_7","008_5_7","JDG","5","7","7","ⵉⵎⵊⴰⵀⴻⴷⴻⵏ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ, ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⴽⴽⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴷⴰⴱⵓⵔⴰ, ⴰⵍⴰⵎⵉ ⴽⴽⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG5_8","008_5_8","JDG","5","8","8","ⵓⵎⵉ ⵉⴼⴰⵔⵣ ⵍⴳⴻⵏⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉⵏⴻⵇⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ. ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔ ⴷ ⵓⵃⵔⵉⵛ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵥⵔⵉ ⵄⴰⴷ ⵊⴰⵔ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⴷⵉ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JG5_9","008_5_9","JDG","5","9","9","ⵓⵍ ⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵟⴻⵡⵡⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("JG5_10","008_5_10","JDG","5","10","10","ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵏⵏⴰⵢⴻⵏ ⵅ ⵜⴻⵖⵢⴰⵍ ⴷ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵅ ⵜⵣⴰⵔⴱⵉⵢⵢⵉⵏ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵙⵉⵡⵍⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("JG5_11","008_5_11","JDG","5","11","11","ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ ⵉ ⴷⵉⵏ ⵊⴰⵔ ⵡⴰⵏⵓⵜⴻⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵡⴰⵡⴰⵍ ⵅ ⵜⵎⴻⴳⴳⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵜⵉⵎⴻⴳⴳⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵓⵎⵊⴰⵀⴰⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG5_12","008_5_12","JDG","5","12","12","ⵃⴹⴰⵜ, ⵃⴹⴰⵜ, ⴷⴰⴱⵓⵔⴰ, ⵃⴹⴰⵜ, ⵃⴹⴰⵜ, ⵙⵉⵡⴻⵍ ⵙ ⵢⵉⵊⵊ ⵏ ⵉⵣⵍⵉ! ⴽⴽⴰⵔ, ⴱⴰⵔⴰⵇ, ⴰⵡⵉ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⴻⵛ, ⴰ ⵛⴻⴽ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵏⵓⵄⴰⵎ! ");
INSERT INTO rift_vpl VALUES ("JG5_13","008_5_13","JDG","5","13","13","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ ⴽⵓⵍ ⵡⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏ ⵍⴳⴻⵏⵙ, ⵙⵉⴷⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JG5_14","008_5_14","JDG","5","14","14","ⵣⴻⴳ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵏⵏⵉ ⴰⵥⵡⴰⵔ ⵏⵙⴻⵏ ⴷⵉ ⵄⴰⵎⴰⵍⵉⵇ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⵢⵓⵢⵓⵔ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵊⴰⵔ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵢⴻⵡⴷⴰⵏ ⵏⵏⴻⵛ. ⵣⵉ ⵎⴰⵅⵉⵔ ⵀⵡⴰⵏ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ, ⵓ ⵣⵉ ⵣⴰⴱⵓⵍⵓⵏ ⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⵄⴻⴽⴽⴰⵣ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵙⵙⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_15","008_5_15","JDG","5","15","15","ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵀⵡⴰⵏ-ⴷⴷ ⴰⴽ-ⴷ ⴷⴰⴱⵓⵔⴰ, ⵓⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵉⵙⵙⴰⵅⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵓⵍⴰ ⴷ ⴱⴰⵔⴰⵇ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ⴷⵉ ⵍⴻⵚⴼⵓⴼ ⵏ ⵔⵓⴱⵉⵏ ⵜⵓⵖⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ ⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG5_16","008_5_16","JDG","5","16","16","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵊⴰⵔ ⵉⵖⴻⵏⴷⵉⴼⴻⵏ, ⵜⴻⵙⵙⵃⴻⵙⵙⴻⴷ ⵖⴰⵔ ⵡⴻⵙⴱⵓⵄⵔⵉⵢ ⵏ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ? ⴷⵉ ⵍⴻⵚⴼⵓⴼ ⵏ ⵔⵓⴱⵉⵏ ⴳⴳⵉⵏ ⴰⴷ ⴱⴻⵇⵇⵛⴻⵏⴷⴻⴳ ⵡⵓⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG5_17","008_5_17","JDG","5","17","17","ⵊⵉⵍⵄⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵉⵇⵇⵉⵎ ⴷⴰⵏ ⵖⴰⵔ ⵜⵖⴰⵔⵔⵓⴱⴰ? ⴰⵛⵉⵔ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵣⴷⴻⵖ ⵖⴰⵔ ⵉⴼⵜⴰⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG5_18","008_5_18","JDG","5","18","18","ⵣⴰⴱⵓⵍⵓⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵙⴻⴱⴱⴻⵍ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵍ ⵍⵎⴻⵡⵜ, ⴰⵎ ⵜ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵏⴰⴼⵜⴰⵍⵉ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JG5_19","008_5_19","JDG","5","19","19","ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ, ⵎⵎⴻⵏⵖⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵎⴻⵏⵖⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷⵉ ⵜⴰⵄⵏⴰⴽ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵊⵉⴷⴷⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴽⵙⵉⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG5_20","008_5_20","JDG","5","20","20","ⵎⵉⵏⵣⵉ ⵉⵜⵔⴰⵏ ⵎⵎⴻⵏⵖⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵙⵉⵙⴰⵔⴰ ⵣⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_21","008_5_21","JDG","5","21","21","ⵉⵖⵣⴰⵔ ⵏ ⵇⵉⵛⵓⵏ ⵉⵡⵢⵉ ⵉ-ⵜⴻⵏ, ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵇⵉⵛⵓⵏ! ⵓⵢⵓⵔ ⵙ ⵊⵊⴻⵀⴷ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JG5_22","008_5_22","JDG","5","22","22","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⵅⵓⵅⵍⴻⵏⵜ ⵜⵉⵛⴻⴹⵢⵉⵏ ⵏ ⵉⵢⵙⴰⵏ ⵣⴻⴳ ⵓⵔⴰⴱⴻⵄ ⴱⵍⴰ ⵓⵇⴻⵟⵟⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG5_23","008_5_23","JDG","5","23","23","ⵏⴻⵄⵍⴻⵎ ⵎⵉⵔⵓⵣ, ⵉⵏⵏⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵄⵍⴻⵎ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵉ ⵙⵉⴷⵉ ⵙ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_24","008_5_24","JDG","5","24","24","ⵜⴻⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵢⴰⵄⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵃⴰⴱⵉⵔ, ⴰⵇⵉⵏⵉ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ. ⵜⴻⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵏⴻⵜⵜⴰⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG5_25","008_5_25","JDG","5","25","25","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵔ ⴰⵎⴰⵏ, ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵛⴰ ⴰⵙ ⴰⵖⵉ, ⵜⵉⵡⵉ ⴰⵙ-ⴷⴷ ⵜⵔⵓⵙⵙⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵟⵟⴻⴱⵚⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG5_26","008_5_26","JDG","5","26","26","ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵜⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵖⴰⵔ ⵍⴻⵡⵜⴻⴷ, ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴻⴼⴹⵉⵙ ⵏ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵜⴰ ⵙⵉⵙⴰⵔⴰ, ⵜⴻⵅⴱⴻⴹ ⴰⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵜⴻⵍⴱⴻⵣ ⵓⵛⴰ ⵜⴻⵙⵙⵏⵓⵇⵇⴻⴱ ⴰⵙ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG5_27","008_5_27","JDG","5","27","27","ⵉⴽⵎⵓⵎⵎⴻⵛ ⵊⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⴱⴱⵓⵣⵣⴻⵍ, ⴰⵇⴰ ⵉⵣⵣⴻⵍ ⴷⵉⵏ. ⴰⵇⴰ ⵉⴽⵎⵓⵎⵎⴻⵛ ⵊⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⴱⴱⵓⵣⵣⴻⵍ. ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴽⵎⵓⵎⵎⵓⵛ, ⵉⵡⴹⴰ ⴷⵉⵏ, ⵓⵛⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵉⵍⴻⵇⵇⴻⴼ! ");
INSERT INTO rift_vpl VALUES ("JG5_28","008_5_28","JDG","5","28","28","ⵣⵉ ⵍⴽⴰⵣⵉ ⵏⵏⴻⵙ ⵜⴻⵅⵣⴰⵔ-ⴷⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⵙⵉⵙⴰⵔⴰ ⵓⵛⴰ ⵜⴻⵙⵖⵓⵢ ⵊⴰⵔ ⵉⵇⴹⵉⴱⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉⵄⴻⵟⵟⴰⵍ ⵓⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵏ ⵓⵎⴻⵏⵖⵉ ⴰⵎⵎⵓ ⴰⵟⵟⴰⵙ? ⵎⴰⵢⴻⵎⵎⵉ ⵉⵄⴻⵟⵟⴰⵍ ⴷⴷⵔⵉⵣ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ’ ");
INSERT INTO rift_vpl VALUES ("JG5_29","008_5_29","JDG","5","29","29","ⵉⵏⵏⵉ ⴷ ⵜⵉⵖⵎⵉⵙⵉⵏ ⴰⵟⵟⴰⵙ ⵊⴰⵔ ⵜⵊⴻⴵⵉⴷⵉⵏ ⵏⵏⴻⵙ ⴰⵔⵔⵉⵏⵜ-ⵉ-ⴷⴷ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵎⵉⵏ ⵜⴻⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JG5_30","008_5_30","JDG","5","30","30","‘ⵎⴰ ⵅⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵡⴰⵍⵓ ⵓⵛⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⵡⴰⵔ ⴱⴻⵟⵟⵉⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ? ⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ? ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵉⴽⴻⵜⵜⴰⵏⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵇⴰⵔⴻⵇⵛⴻⵏ ⵉ ⵙⵉⵙⴰⵔⴰ, ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵉⴽⴻⵜⵜⴰⵏⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵇⴰⵔⴻⵇⵛⴻⵏ, ⴰⴱⵓⵔⴹⴰ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⵓⴷⵉ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵣⴻⴳ ⵓⴽⴻⵜⵜⴰⵏ ⵉⵜⵜⵡⴰⵙⵙⵇⴰⵔⴻⵇⵛⴻⵏ ⵉ ⵉⵔⴰⵡⴻⵏ, ⴰⵎ ⵜⴽⴻⵛⵛⴰⴹⵜ?’ ");
INSERT INTO rift_vpl VALUES ("JG5_31","008_5_31","JDG","5","31","31","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵀⴻⵍⵍⴽⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵜⴼⵓⵛⵜ ⵉ ⴷⴷ-ⵉⵏⴻⵇⵇⴰⵔⴻⵏ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ.” ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵜⴰⵔⴻⵢⵢⴻⵃ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG6_1","008_6_1","JDG","6","1","1","ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG6_2","008_6_2","JDG","6","2","2","ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵎⵉⴷⵢⴰⵏ ⵉⵊⵀⴻⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉⴼⵔⴰⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⴷ ⵉⵅⴻⵔⴷⵓⵙⴻⵏ ⴷ ⵍⵇⴻⵍⵄⴰⵜ ⴹⵉⴷⴷ ⵉ ⵎⵉⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_3","008_6_3","JDG","6","3","3","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵣⴰⵔⵔⵄⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵜⴳⴻⵄⵄⴻⴷ ⵎⵉⴷⵢⴰⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ ⵜⵜⴳⴻⵄⵄⴷⴻⵏ ⴹⵉⴷⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_4","008_6_4","JDG","6","4","4","ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵖⴰⵣⵣⴰ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵊⵊⵉⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵉ ⵣⵉ ⵖⴰ ⵉⴷⴷⴰⵔ ⴱⵏⴰⴷⴻⵎ, ⵍⴰ ⴷ ⵓⴵⵉ, ⵍⴰ ⴷ ⴰⴼⵓⵏⴰⵙ ⵓⵍⴰ ⴷ ⴰⵖⵢⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("JG6_5","008_6_5","JDG","6","5","5","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵙ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵢⵍⴰⴼ ⵏ ⵜⵎⵓⵔⵖⵉ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⴽ-ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_6","008_6_6","JDG","6","6","6","ⴰⵎⵎⵓ ⵉⵥⵍⴻⴹ ⵉⵙⵔⴰⵉⵍ ⴰⵟⵟⴰⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⴷⵢⴰⵏ. ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG6_7","008_6_7","JDG","6","7","7","ⵅⵎⵉ ⵙⵖⵓⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("JG6_8","008_6_8","JDG","6","8","8","ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ, ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JG6_9","008_6_9","JDG","6","9","9","ⵏⴻⵛⵛ ⴼⴻⴽⴽⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵃⵚⴰⵔⴻⵏ. ⵏⴻⵛⵛ ⵓⵥⵥⵍⴻⵖ ⵅⴰⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵓ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_10","008_6_10","JDG","6","10","10","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ: ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⵄⴻⴱⴱⴷⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⵣⴻⴷⴷⵖⴻⵎ!’ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JG6_11","008_6_11","JDG","6","11","11","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵙⴰⴷⵓ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⴳⴳ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵄⴰⴼⵔⴰ, ⵜⴻⵏⵏⵉ ⵏ ⵢⵓⵡⴰⵛ, ⴰⴱⵉⵄⴰⵣⴰⵔⵉ. ⵎⵎⵉⵙ ⵊⵉⴷⵄⵓⵏ ⵜⵓⵖⴰ-ⵜ ⴷⵉⵏ ⵉⵙⵙⴰⵔⵡⴰⵜ ⵉⵔⴷⴻⵏ ⴷⵉ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⴰⵔⵡⴻⵍ ⴰⵎⵎⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵉⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_12","008_6_12","JDG","6","12","12","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⴽ, ⴰ ⵛⴻⴽ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("JG6_13","008_6_13","JDG","6","13","13","ⵊⵉⴷⵄⵓⵏ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵍⵇⴻⴼ ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵓⵢⴰ ⵓ ⵎⴰⵏⵉ ⴵⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉ ⵅ ⴷ ⴰⵏⴻⵖ ⵙⵙⵉⵡⵍⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: ‘ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵎⵉⵚⵔⴰ?’ ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵏⴹⴰⵔ ⴰⵏⴻⵖ ⵙⵉⴷⵉ, ⵉⵙⴻⵍⵍⴻⵎ ⴰⵏⴻⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG6_14","008_6_14","JDG","6","14","14","ⵔⴻⵅⴷⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⵡⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴰⴷ ⵜⴼⴻⴽⴽⴻⴷ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵉⴷⵢⴰⵏ. ⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ-ⴷⴷ ⵙⵙⴻⴽⴽⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("JG6_15","008_6_15","JDG","6","15","15","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙ ⵎⵉⵏⵣⵉ ⵉ ⵖⴰ ⴼⴻⴽⴽⴻⵖ ⵉⵙⵔⴰⵉⵍ? ⵅⵣⴰⵔ ⵍⵡⴰⵛⵓⵏ ⵉⵏⵓ ⴷ ⵜⴰⵎⴻⵣⵍⵓⴹⵜ ⵇⴰⵄ ⴷⵉ ⵎⴰⵏⴰⵙⵙⴰ ⵓ ⵏⴻⵛⵛ ⴷ ⴰⵎⵓⴷⵔⵓⵙ ⵇⴰⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG6_16","008_6_16","JDG","6","16","16","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽⵉⴷⴻⴽ, ⴰⴷ ⵜⵖⴻⵍⴱⴻⴷ ⵎⵉⴷⵢⴰⵏ, ⴰⵅⵎⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG6_17","008_6_17","JDG","6","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⴰⵇⴰ ⴷ ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_18","008_6_18","JDG","6","18","18","ⵡⴰⵔ ⵙⵙⴰ ⵜⵜⵔⴰⵃ ⵛⴰ, ⴰⵍ ⵖⴰⵔⴻⴽ ⴷⴷ ⵖⴰ ⵄⴻⵇⴱⴻⵖ ⴰⴷ ⵜⵉⵍⵉ ⵉⵡⵢⴻⵖ-ⴷⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵙⵙⴰⵔⵙⴻⵖ ⵣⵣⴰⵜⴻⴽ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⵄⴻⵇⴱⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG6_19","008_6_19","JDG","6","19","19","ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵊⵉⴷⵄⵓⵏ, ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵉⵖⵔⵓⵎⴻⵏ ⴱⵍⴰ ⴰⵖⵔⵓⵎ ⵣⴻⴳ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵢⵙⵓⵎ ⴷⵉ ⵜⵚⵓⴵⴻⵜ, ⵉⴳⴳⴰ ⴰⵔⵔⵡⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵢⴷⵓⵔⵜ ⵓⵛⴰ ⵢⵉⵡⵉ ⵎⴰⵏ ⴰⵢⴰ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵙ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JG6_20","008_6_20","JDG","6","20","20","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ: “ⴽⵙⵉ ⴰⵢⵙⵓⵎ ⴷ ⵉⵖⵔⵓⵎⴻⵏ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⴻⵏ ⴷⴰ ⵅ ⵜⴻⵚⴹⴰⵔⵜ ⵓⵛⴰ ⵣⴻⴵⴻⵄ ⵅⴰⵙ ⴰⵔⵔⵡⴰ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("JG6_21","008_6_21","JDG","6","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⴰⵔⵔⴻⵃ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵜⵉⵅⴻⴼⵜ ⵏ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ, ⵉⵃⴰⴷⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵢⵙⵓⵎ ⴷ ⵉⵖⵔⵓⵎⴻⵏ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴳⴻⵄⵄⴻⴷ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵜⴻⵚⴹⴰⵔⵜ, ⵜⴻⵛⵛⴰ ⴰⵢⵙⵓⵎ ⴷ ⵉⵖⵔⵓⵎⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⵓⴼⵙⴻⵍ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵊⵉⴷⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_22","008_6_22","JDG","6","22","22","ⵓⵎⵉ ⵊⵉⴷⵄⵓⵏ ⵉⵥⵔⴰ, ⴰⵇⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ ⵊⵉⴷⵄⵓⵏ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴰⵖⴻⵎⴱⵓⴱ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("JG6_23","008_6_23","JDG","6","23","23","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵛⴻⴽ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG6_24","008_6_24","JDG","6","24","24","ⵓⵛⴰ ⵊⵉⴷⵄⵓⵏ ⵉⴱⵏⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵉⴳⴳⴰ ⴰⵙ: “ⵙⵉⴷⵉ ⴷ ⵍⴻⵀⵏⴰ!” ⴰⵇⴰ-ⵜ ⴷⵉ ⵄⴰⴼⵔⴰ ⵏ ⴰⵢⵜ ⵏ ⴰⴱⵉⵄⴰⵣⴰⵔⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JG6_25","008_6_25","JDG","6","25","25","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉ ⵉⴵⴰⵏ ⵏ ⴱⴰⴱⴰⵛ, ⴰⵇⴰ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⵖⴹⴻⵍ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⴱⴰⵄⵍ ⵉ ⵉⴵⴰⵏ ⵏ ⴱⴰⴱⴰⵛ ⵓ ⵣⴷⴻⵎ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵏⵏⵉ ⵣⵣⴰⵜⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("JG6_26","008_6_26","JDG","6","26","26","ⴱⵏⴰ ⵅⴻⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵍⵇⴻⵍⵄⴰ-ⵢⴰ, ⵙⴻⵡⵊⴻⴷ ⵉ-ⵜ, ⵓⵛⴰ ⴽⵙⵉ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⴰⵡⵢⵉ ⵜ-ⵉ-ⴷⴷ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵣⴻⴷⵎⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG6_27","008_6_27","JDG","6","27","27","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵊⵉⴷⵄⵓⵏ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ⵎⴰⵛⴰ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⵯⴻⴷ ⵣⵉ ⵍⵡⴰⵛⵓⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵓ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵜ ⵉⴳⴳ ⵙ ⵡⴰⵙⵙ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JG6_28","008_6_28","JDG","6","28","28","ⵓⵎⵉ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ, ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⴱⴰⵄⵍ ⵉⵜⵜⵡⴰⵀⴷⴻⵎ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵣⴷⴻⵎ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵏⵏⵉ ⵣⵣⴰⵜⴻⵙ ⵓ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵜⵜⵡⴰⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⴷⵉⵏ ⵉⵜⵜⵡⴰⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_29","008_6_29","JDG","6","29","29","ⵓⵛⴰ ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⴳⴳⵉⵏ ⴰⵢⴰ?” ⵏⵉⵜⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ, ⴰⵔⵣⵓⵏ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵊⵉⴷⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⵉ-ⵜ ⵉⴳⴳⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG6_30","008_6_30","JDG","6","30","30","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵢⵓⵡⴰⵛ: “ⵙⵓⴼⴻⵖ-ⴷⴷ ⵎⵎⵉⵛ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵖⴹⴻⵔ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⴱⴰⵄⵍ ⵓ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵣⴷⴻⵎ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵉ ⵣⵣⴰⵜⴻⵙ ⵉⴵⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG6_31","008_6_31","JDG","6","31","31","ⵢⵓⵡⴰⵛ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⴱⴻⴷⴷⴻⵏ: “ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵎⴻⵏⵖⴻⵎ ⵉ ⴱⴰⵄⵍ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⵎ? ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉ ⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⴷⵉ ⵚⵚⴱⴻⵃ-ⴰ ⵡⴰⵏⵉⵜⴰ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵏⵏⵉⵜ, ⵎⵉⵏⵣⵉ ⵖⴻⴹⵍⴻⵏ ⴰⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG6_32","008_6_32","JDG","6","32","32","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴰⵙ-ⴷⴷ ⵉ ⵊⵉⴷⵄⵓⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: “ⴱⴰⵄⵍ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵖⴹⴻⵍ ⴰⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG6_33","008_6_33","JDG","6","33","33","ⵎⴰⵔⵔⴰ ⵎⵉⴷⵢⴰⵏ ⴷ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ ⵎⵓⵏⴻⵏ ⵓⵛⴰ ⵥⵡⴰⵏ-ⴷⴷ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG6_34","008_6_34","JDG","6","34","34","ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⵢⴰⵔⴹ ⵉ ⵊⵉⴷⵄⵓⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⴰⵢⵜ ⵏ ⴰⴱⵉⵄⴰⵣⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG6_35","008_6_35","JDG","6","35","35","ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵎⴰⵏⴰⵙⵙⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴰⵛⵉⵔ ⵓ ⵖⴰⵔ ⵣⴰⴱⵓⵍⵓⵏ ⵓ ⵖⴰⵔ ⵏⴰⴼⵜⴰⵍⵉ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵎⵎⴻⵍⵇⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_36","008_6_36","JDG","6","36","36","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵊⵉⴷⵄⵓⵏ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴼⴻⴽⴽⴻⴷ ⵉⵙⵔⴰⵉⵍ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("JG6_37","008_6_37","JDG","6","37","37","ⵅⵣⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⵜⴰⵀⵉⴹⵓⵔⵜ ⵏ ⵜⴰⴹⵓⴼⵜ ⵅ ⵓⵏⴻⴷⵔⴰⵔ. ⵎⴰⵍⴰ ⵉⵡⴹⴰ ⵏⵏⴷⴰ ⵎⵖⵉⵔ ⵅ ⵜⴰⴹⵓⴼⵜ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ ⵜⴻⵇⵇⵉⵎ ⵜⵓⵥⴻⵖ, ⵅⴻⵏⵏⵉ ⵙⵙⵏⴻⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵉⵙⵔⴰⵉⵍ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG6_38","008_6_38","JDG","6","38","38","ⵓ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⴽⴽⴰⵔ ⵣⵉⵛ ⵓⵛⴰ ⵉⵣⵍⵉ ⵜⴰⵀⵉⴹⵓⵔⵜ ⵓⵛⴰ ⵉⵥⴻⵎⵎ-ⴷⴷ ⵏⵏⴷⴰ ⵣⵉ ⵜⵀⵉⴹⵓⵔⵜ, ⵉⵛⵜ ⵏ ⵟⵟⴰⵡⵢⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG6_39","008_6_39","JDG","6","39","39","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵊⵉⴷⵄⵓⵏ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵡⴰⵔ ⵅⴰⴼⵉ ⵢⴰⵔⴻⵇⵇ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ. ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵇⴻⴵⴱⴻⵖ ⵙ ⵜⵀⵉⴹⵓⵔⵜ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵡⴰⵀⴰ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⵀⵉⴹⵓⵔⵜ ⵜⵓⵥⴻⵖ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵏⵏⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG6_40","008_6_40","JDG","6","40","40","ⵓⵛⴰ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⵙⵉⴷⵉ ⴰⵎⵎⵓ: ⵜⴰⵀⵉⴹⵓⵔⵜ ⵡⴰⵀⴰ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵜⵓⵥⴻⵖ ⵓ ⵜⵓⵖⴰ ⵏⵏⴷⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG7_1","008_7_1","JDG","7","1","1","ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵡⴰ ⴷ ⵊⵉⴷⵄⵓⵏ, ⵉⴽⴽⴰⵔ ⵣⵉⵛ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵏⵉⵜⵏⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵃⴰⵔⵓⴷ. ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵎⵉⴷⵢⴰⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵣⵉ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵎⵓⵔⴰ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG7_2","008_7_2","JDG","7","2","2","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵊⵉⴷⵄⵓⵏ: “ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⴽ ⵉⴵⴰⵏ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⴰⵎⵎⵓ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵖ ⵎⵉⴷⵢⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵏⵉⵖ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵅⴰⴼⵉ ⵉⴼⴻⵢⵢⴻⵛ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⴼⵓⵙ ⵉⵏⵓ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JG7_3","008_7_3","JDG","7","3","3","ⵙ ⵓⵢⴰ, ⵍⴰⵖⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵉ: ‘ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⴰⴷ ⵉⵄⵇⴻⴱ ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⴷⴻⵖⵢⴰ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ!’” ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔⴻⵙ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("JG7_4","008_7_4","JDG","7","4","4","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵊⵉⴷⵄⵓⵏ: “ⵍⴳⴻⵏⵙ ⴰⵇⴰ-ⵜ ⵄⴰⴷ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⵙⴻⵀⵡⴰ ⵜⴻⵏ ⵖⴰⵔ ⵡⴰⵎⴰⵏ, ⴷⵉⵏⵏⵉ ⴰⴷ ⵜⴻⵏ ⴷⴷⵣⴻⵖ ⵉ ⵛⴻⴽ. ⴰⴷ ⵉⵎⵙⴰⵔ ⵅ ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ: ‘ⵡⴰ ⴰⴷ ⴽⵉⴽ ⵉⵔⴰⵃ!’, ⵡⵉⵏ ⴰⴷ ⴽⵉⴽ ⵉⵔⴰⵃ, ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵅ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ: ‘ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⴽⵉⴽ ⵉⵜⵜⵔⵉⵃ!’, ⵡⵉⵏ ⵡⴰⵔ ⴽⵉⴽ ⵉⵜⵜⵔⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("JG7_5","008_7_5","JDG","7","5","5","ⵉⵙⵙⴻⵀⵡⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵡⴰⵎⴰⵏ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵍⴻⵙⵃⴻⵏ ⴰⵎⴰⵏ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵏ ⵉⵍⴻⵙⵙⴻⵃ ⵡⴻⵇⵣⵉⵏ, ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ. ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴹⴰⵔⴻⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG7_6","008_7_6","JDG","7","6","6","ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵎⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵍⴻⵙⵃⴻⵏ ⴰⵎⴰⵏ ⵙ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵓⴹⴰⵔⴻⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵏ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG7_7","008_7_7","JDG","7","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵊⵉⴷⵄⵓⵏ: “ⵙ ⵓⴼⵓⵙ ⵏ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ, ⵉⵏⵏⵉ ⵉⵍⴻⵙⵃⴻⵏ ⴰⵎⴰⵏ ⵙ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⴷⵢⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG7_8","008_7_8","JDG","7","8","8","ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⴻⴳ ⵓⴼⵓⵙ, ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⵖⴰⵔⴻⵙ. ⵜⵓⵖⴰ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵎⵉⴷⵢⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG7_9","008_7_9","JDG","7","9","9","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵜⴻⵎⵙⴰⵔ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ ⴱⴻⴷⴷ, ⵀⵡⴰ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵛ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JG7_10","008_7_10","JDG","7","10","10","ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⵇⴰ ⵜⴻⴳⴳⵯⴷⴻⴷ ⵄⴰⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⵉⴷ, ⵀⵡⴰ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⴽ-ⴷ ⴼⵓⵔⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JG7_11","008_7_11","JDG","7","11","11","ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵎⵉⵏ ⵅⴻⴼ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵉⵎⵎⴻⵡⵛ ⵊⵊⴻⵀⴷ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⵣⴻⵎⵄⴻⴷ ⴰⴷ ⵜⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⴼⵓⵔⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⴰⵍ ⵣⵣⴰⵜ ⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("JG7_12","008_7_12","JDG","7","12","12","ⵓⵛⴰ ⵎⵉⴷⵢⴰⵏ ⴷ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ ⵜⵓⵖⴰ ⵙⵙⵓⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵢⵍⴰⴼ ⵏ ⵜⵎⵓⵔⵖⵉ ⵓ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG7_13","008_7_13","JDG","7","13","13","ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵊⵉⴷⵄⵓⵏ ⴷⵉⵏ, ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵜⵓⵖⴰ ⵉⵜⵜⵃⴰⵊⴰ ⵉ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ ⵓⵛⴰ ⵥⵔⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵉⵎⴻⵏⴷⵉ ⵉ ⵉⵡⴹⴰⵏ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵉⵇⵏⵓⵏⵏⵉ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵎⵉⴷⵢⴰⵏ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⴰⵍ ⴰⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⴰⵍⴰⵎⵉ ⵉⵡⴹⴰ ⵓ ⵉⴷⵡⴻⵍ ⵅ ⵓⵣⴻⴵⵉⴼ. ⴰⵇⴰ ⴰⵎⵎⵓ ⵉ ⵉⵡⴹⴰ ⵓⵇⵉⴹⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG7_14","008_7_14","JDG","7","14","14","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰⵢⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⵖⵉⵔ ⵙⵙⵉⴼ ⵏ ⵊⵉⴷⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵔⵢⴰⵣ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⵎⵉⴷⵢⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG7_15","008_7_15","JDG","7","15","15","ⵓⵎⵉ ⵉⵙⵍⴰ ⵊⵉⴷⵄⵓⵏ ⵜⴰⵔⵊⵉⵜ-ⴰ ⴷ ⵎⵉⵏ ⵜⴻⵅⵙ ⴰⴷ ⵜⵉⵏⵉ, ⵢⵓⴹⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔⴻⵎ, ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵎⵉⴷⵢⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JG7_16","008_7_16","JDG","7","16","16","ⵊⵉⴷⵄⵓⵏ ⵉⴱⴹⴰ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵇⴹⵓⵃ ⵉⵅⵡⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵚⴻⴼⴹⴰⵡ ⴷⴻⴳ ⵡⴻⵇⴹⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("JG7_17","008_7_17","JDG","7","17","17","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵓⵛⴰ ⴳⴳⴻⵎ ⴰⵎⴻⵏⵏⵉ. ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JG7_18","008_7_18","JDG","7","18","18","ⵅⵎⵉ ⵖⴰ ⵙⵓⴹⴻⵖ ⵏⴻⵛⵛ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵉ ⵉⴵⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵙⵓⴹⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⵎⴰⵔⴳⴻⵃ, ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵉ ⵙⵉⴷⵉ ⵓ ⵉ ⵊⵉⴷⵄⵓⵏ!’” ");
INSERT INTO rift_vpl VALUES ("JG7_19","008_7_19","JDG","7","19","19","ⵓⵛⴰ ⵊⵉⴷⵄⵓⵏ ⴷ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ, ⵉⵡⴹⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵓⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵄⴰⴷ ⴳⴳⵓⵔ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵓⵛⴰ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ, ⴰⵔⵥⵉⵏ ⵉⵇⴹⵓⵃⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG7_20","008_7_20","JDG","7","20","20","ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⴰⵔⵥⵉⵏ ⵉⵇⴹⵓⵃⴻⵏ ⵓ ⵙ ⵓⴼⵓⵙ ⴰⵥⴻⵍⵎⴰⴹ ⵟⵟⴼⴻⵏ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⵓ ⵙ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵙⵓⴹⴻⵏ ⵓⵛⴰ ⵙⵖⵓⵢⴻⵏ: “ⵙⵙⵉⴼ ⵏ ⵙⵉⴷⵉ ⴷ ⵊⵉⴷⵄⵓⵏ!” ");
INSERT INTO rift_vpl VALUES ("JG7_21","008_7_21","JDG","7","21","21","ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⴰⵥⵥⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ, ⵙⵖⵓⵢⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG7_22","008_7_22","JDG","7","22","22","ⵓⵎⵉ ⵙⵓⴹⴻⵏ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵉⵙⵙⴻⴽⴽⴰⵔ ⵙⵉⴷⵉ ⵙⵙⵉⴼ ⵏ ⵉⵊⵊⴻⵏ ⴹⵉⴷⴷ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵔⴳⴻⵃ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵍ ⴱⴰⵢⵜ-ⵛⵉⵟⵟⴰ, ⵊⵊⵉⵀⴻⵜ ⵏ ⵣⴰⵔⴰⵔⴰ ⴰⵍ ⵜⵎⴰ ⵏ ⵢⴻⵖⵣⴰⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⴱⵉⵍ-ⵎⴰⵃⵓⵍⴰ ⵖⴰⵔ ⵟⴰⴱⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG7_23","008_7_23","JDG","7","23","23","ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵏⴰⴼⵜⴰⵍⵉ ⵓ ⵣⵉ ⴰⵛⵉⵔ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵢⵜ ⵏ ⵎⵉⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG7_24","008_7_24","JDG","7","24","24","ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⴽⴽ ⵊⵉⴷⵄⵓⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵏⵏⴰ: “ⵀⵡⴰⵎ, ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵎⵉⴷⵢⴰⵏ ⵓ ⵜⴻⴽⴽⵙⴻⵎ ⴰⵙ ⵉⵖⴻⵣⵔⴰⵏ ⴰⵍ ⴱⴰⵢⵜ-ⴱⴰⵔⴰ ⵓⵍⴰ ⴷ ⵍ’ⵓⵔⴷⵓⵏ.” ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵉⵖⴻⵣⵔⴰⵏ ⴰⵍ ⴱⴰⵢⵜ-ⴱⴰⵔⴰ ⴷ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG7_25","008_7_25","JDG","7","25","25","ⵏⵉⵜⵏⵉ ⵃⴻⴱⴱⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵖⵓⵔⴰⴱ ⴷ ⴷⵉ’ⴰⴱ, ⵓⵛⴰ ⵏⵖⵉⵏ ⵖⵓⵔⴰⴱ ⵅ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵖⵓⵔⴰⴱ ⵓ ⴷⵉ’ⴰⴱ ⵏⵖⵉⵏ ⵜ ⵅ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⵏ ⴷⵉ’ⴰⴱ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵄⴻⵔⴼⴻⵏ ⵅ ⵉⵎⵉⴷⵢⴰⵏⵉⵢⵢⴻⵏ. ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵖⵓⵔⴰⴱ ⴷ ⴷⵉ’ⴰⴱ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵊⵉⴷⵄⵓⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_1","008_8_1","JDG","8","1","1","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ: “ⵎⴰⵏⴰⵡⵢⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴰ ⵜⴻⴳⴳⵉⴷ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵉ ⴷ ⵅⴰⵏⴻⵖ ⵜⵍⵉⵖⵉⴷ ⵓⵎⵉ ⵜⴻⴼⴼⵖⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⴽ-ⴷ ⵎⵉⴷⵢⴰⵏ?” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵎⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG8_2","008_8_2","JDG","8","2","2","ⵊⵉⴷⵄⵓⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵎⴰⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵎⵉⵏ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵎⵉⵏ ⵜⴻⴳⴳⵉⵎ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵍⵇⴰⴹ ⵏ ⵎⵉⵏ ⵉⵢⵓⵔⴰⵏ ⵏ ⵓⴹⵉⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵅⴰⵔ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⴱⵉⵏⵓ ⵏ ⴰⵢⵜ ⵏ ⴰⴱⵉⵄⴰⵣⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JG8_3","008_8_3","JDG","8","3","3","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵖⵓⵔⴰⴱ ⴷ ⴷⵉ’ⴰⴱ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⵉⴷⵢⴰⵏ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ. ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⴰⴷ ⵜ ⵙⵙⴻⵎⵇⵓⴷⴷⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ?” ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵡⴰⵍ-ⴰ ⵢⴰⵔⵙⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_4","008_8_4","JDG","8","4","4","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵊⵉⴷⵄⵓⵏ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵥⵡⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ⵏⵉⵜⵏⵉ ⴼⵏⴰⵏ ⵍⴰⵎⵉ ⵜⴻⵏ ⵇⵇⵉⵎⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵎⵉⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_5","008_8_5","JDG","8","5","5","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵙⵓⴽⴽⵓⵜ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⵡⵛⴻⵎ ⵉ ⵍⴳⴻⵏⵙ ⵉ ⴷⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵜⵉⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴼⵏⴰⵏ ⵓ ⵏⴻⵛⵛ ⴰⵇⴰ ⴹⴻⴼⴼⴰⵔⴻⵖ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG8_6","008_8_6","JDG","8","6","6","ⵎⴰⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵙⵓⴽⴽⵓⵜ ⵏⵏⴰⵏ: “ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ, ⵎⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵡⵛ ⴰⵖⵔⵓⵎ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JG8_7","008_8_7","JDG","8","7","7","ⵙ ⵓⵢⴰ ⵉⵏⵏⴰ ⵊⵉⴷⵄⵓⵏ: “ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵅⵎⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴳⴳ ⵙⵉⴷⵉ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴰⵔⴻⵡⵜⴻⵖ ⴰⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵢⴻⵥⵔⴰ ⵏ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG8_8","008_8_8","JDG","8","8","8","ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⴼⴰⵏⵓⵡⵉⵍ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵎⴻⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ. ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴼⴰⵏⵓⵡⵉⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ-ⴰⵔⵔⵉⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵙⵓⴽⴽⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JG8_9","008_8_9","JDG","8","9","9","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴼⴰⵏⵓⵡⵉⵍ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵄⴻⵇⴱⴻⵖ-ⴷⴷ ⴷⵉ ⵍⴻⵀⵏⴰ, ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵚⵚⵓⵎⵄⴻⵜ-ⴰ ⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG8_10","008_8_10","JDG","8","10","10","ⵜⵓⵖⴰ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⴷⵉ ⴽⴰⵔⴽⵓⵔ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵄⵍⴰⵃⴰⵍ ⴷⵉ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ. ⴰⵇⴰ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG8_11","008_8_11","JDG","8","11","11","ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵊⵉⴷⵄⵓⵏ ⴰⴽ-ⴷ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⵏⵓⴱⴰⵃ ⴷ ⵢⵓⵊⴱⴰⵀⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ, ⵓⵎⵉ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_12","008_8_12","JDG","8","12","12","ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ ⴰⵔⴻⵡⵍⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ. ⵉⵟⵟⴻⴼ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ, ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG8_13","008_8_13","JDG","8","13","13","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵊⵉⴷⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⵣⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⵉⴽⴽⴰ ⵅ ⵜⵙⵓⵏⵜⴰ ⵏ ⵃⴰⵔⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("JG8_14","008_8_14","JDG","8","14","14","ⵉⵟⵟⴻⴼ ⵉⵊⵊ ⵏ ⵡⴻⴱⵍⵉⵖ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵙⵓⴽⴽⵓⵜ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜ. ⵡⴰⵏⵉⵜⴰ ⵢⵓⵔⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵙⵓⴽⴽⵓⵜ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_15","008_8_15","JDG","8","15","15","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵙⵓⴽⴽⵓⵜ, ⵉⵏⵏⴰ: “ⵉⵏⴰ ⴷ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ, ⵉⵏⵏⵉ ⵣⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴱⴰⵔⵔⵇⴻⵎ ⵓⵎⵉ ⵜⴻⵏⵏⴰⵎ: ‘ⵎⴰ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⵍ ⵖⴰ ⵏⴻⵡⵛ ⴰⵖⵔⵓⵎ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⵢⵓⵃⵍⴻⵏ?’” ");
INSERT INTO rift_vpl VALUES ("JG8_16","008_8_16","JDG","8","16","16","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵉⵥⵔⴰ ⵏ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵙⵓⴽⴽⵓⵜ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_17","008_8_17","JDG","8","17","17","ⵍⴱⵓⵔⵊ ⵏ ⴼⴰⵏⵓⵡⵉⵍ ⵉⵀⴷⴻⵎ ⵉ-ⵜ ⵓ ⵉⵏⵖⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG8_18","008_8_18","JDG","8","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ: “ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⴻⵏⵖⵉⵎ ⴷⵉ ⵜⴰⴱⵓⵔ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵎ ⵛⴻⴽ, ⵖⴰⵔⵙⴻⵏ ⴰⴷⴷⵓⴷ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG8_19","008_8_19","JDG","8","19","19","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵢⵜⵎⴰ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴻⵎⵎⴰ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵎⵍⵉ ⵜⴻⵏ ⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴷⴷⴰⵔⴻⵏ, ⵉⵍⵉ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵏⴻⵇⵇⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("JG8_20","008_8_20","JDG","8","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵢⴰⵜⴰⵔ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ: “ⴽⴽⴰⵔ, ⵏⴻⵖ ⵉ-ⵜⴻⵏ!” ⵎⴰⵛⴰ ⴰⴱⵍⵉⵖ ⵡⴰⵔ ⴷⴷ-ⵉⴽⴽⵉⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⵯⴻⴷ ⵓⵎⵉ ⵄⴰⴷ ⴷ ⴰⴱⵍⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JG8_21","008_8_21","JDG","8","21","21","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ: “ⴽⴽⴰⵔ ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴻⵖ ⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⴰⵔⵢⴰⵣ, ⴰⵎⵎⵓ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ.” ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵊⵉⴷⵄⵓⵏ, ⵉⵏⵖⴰ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ ⵓⵛⴰ ⵉⴽⵙⵉ ⵜⵉⵣⵉⵔⵉⵡⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵉ ⴷ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵉⵔⴰⵡⴻⵏ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_22","008_8_22","JDG","8","22","22","ⵓⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⴰⵏ ⵉ ⵊⵉⴷⵄⵓⵏ: “ⵃⴻⴽⵎⴻⵜ ⵅⴰⵏⴻⵖ, ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵎⵎⵉⵛ ⴷ ⵡⴰⵢⵢⴰⵡ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵉⴷⵢⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG8_23","008_8_23","JDG","8","23","23","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵊⵉⴷⵄⵓⵏ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵃⴻⴽⴽⵎⴻⵖ ⵓⵍⴰ ⴷ ⵎⵎⵉ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵃⴻⴽⴽⴻⵎ. ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG8_24","008_8_24","JDG","8","24","24","ⵊⵉⴷⵄⵓⵏ ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵜⵜⴰⵔⴻⵖ ⵛⴰ. ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵛⵜ ⵏ ⵜⴻⵅⵔⴰⵣⵜ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵙ!”, ⵎⵉⵏⵣⵉ ⵜⵜⵡⴰⴼⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵎⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG8_25","008_8_25","JDG","8","25","25","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵛ ⵜⴻⵏⵜ ⵏⴻⵡⵛ ⵙ ⵍⵅⴰⴹⴰⵔ!” ⵏⵉⵜⵏⵉ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵔⵓⴹ ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵏⴹⴰⵔ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵅⵔⴰⵣⵜ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG8_26","008_8_26","JDG","8","26","26","ⵜⵉⵅⵔⴰⵣⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⵜⵜⴰⵔ ⵡⴻⵣⵏⴻⵏⵜ ⵙⴱⴻⵄⵟⴰⵛ-ⵎⵢⴰ ⵏ ⵛⵉⵇⵍⵓ ⵡⵓⵔⴻⵖ, ⵏⵀⵍⴰ ⵜⵉⵣⵉⵔⵉⵡⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⴷ ⵜⴻⵅⵔⴰⵣⵉⵏ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵜⵓⴷⴷⵉⵎⵉⵏ ⴷ ⵡⴻⵔⵔⵓⴹ ⴰⵔⵊⵓⵡⴰⵏⵉ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴹⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ, ⵏⵀⵍⴰ ⵜⵉⵙⴻⴷⴷⵢⵉⵏ ⵉ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵉⵔⴰⵡⴻⵏ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_27","008_8_27","JDG","8","27","27","ⵊⵉⴷⵄⵓⵏ ⵉⴳⴳⴰ ⵣⵣⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⴷⵉ ⵄⴰⴼⵔⴰ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⴰⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⵍⴼⴻⵅ ⵉ ⵊⵉⴷⵄⵓⵏ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG8_28","008_8_28","JDG","8","28","28","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵉⵏⵏⴱⴻⵀⴷⴻⵍ ⵎⵉⴷⵢⴰⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵄⴰⴷ. ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴰⵔⴻⵢⵢⴻⵃ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵊⵉⴷⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_29","008_8_29","JDG","8","29","29","ⵓⵛⴰ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⵢⵓⵢⵓⵔ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG8_30","008_8_30","JDG","8","30","30","ⵊⵉⴷⵄⵓⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_31","008_8_31","JDG","8","31","31","ⵓⵍⴰ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵛⴰⴽⵉⵎ, ⵜⴻⵊⵊⴰ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵙ ⴰⴱⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("JG8_32","008_8_32","JDG","8","32","32","ⵊⵉⴷⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⵉⵎⵎⵓⵜ ⵓⵎⵉ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵛⴰⴱ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵏⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⴱⴰⴱⴰⵙ ⵢⵓⵡⴰⵛ, ⴷⵉ ⵄⴰⴼⵔⴰ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⴱⵉⵄⴰⵣⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JG8_33","008_8_33","JDG","8","33","33","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵊⵉⴷⵄⵓⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵓⵛⴰ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⵓⵛⴰ ⴳⴳⵉⵏ ⴱⴰⵄⵍ-ⴱⴰⵔⵉⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG8_34","008_8_34","JDG","8","34","34","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴼⴻⴽⴽⴰⵔⴻⵏ ⵄⴰⴷ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JG8_35","008_8_35","JDG","8","35","35","ⵓⵛⴰ ⵡⴰⵔ ⵙⵙⴻⵛⵏⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⴷ ⵜⴻⵏⵏⵉ ⵏ ⵊⵉⴷⵄⵓⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⵉⴳⴳⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG9_1","008_9_1","JDG","9","1","1","ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵖⴰⵔ ⴰⵢⵜⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵡⴰⵛⵓⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JG9_2","008_9_2","JDG","9","2","2","“ⵙⵉⵡⵍⴻⵎ ⵎⴰⵛⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ: ‘ⵎⵉⵏ ⵉⴵⴰⵏ ⵎⵍⵉⵃ ⵉ ⴽⴻⵏⵏⵉⵡ: ⵎⴰⵍⴰ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵀⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵃⴽⴻⵎ? ⵄⴻⵇⵍⴻⵎ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵉⵖⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⴷ ⴰⵢⵙⵓⵎ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JG9_3","008_9_3","JDG","9","3","3","ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵢⵜⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⴰⵍⴰⵎⵉ ⵓⵍ ⵏⵙⴻⵏ ⵉⵎⴻⵢⵢⴻⵍ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴽ-ⴷ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰⵜⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG9_4","008_9_4","JDG","9","4","4","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵙ ⵙⴻⴱⵄⵉⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⵍ-ⴱⴰⵔⵉⵜ. ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⵛⵔⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵅⵡⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵟⴰⵔⵔⵛⴻⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JG9_5","008_9_5","JDG","9","5","5","ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⵉ ⵄⴰⴼⵔⴰ ⵓ ⵉⵏⵖⴰ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴰⵢⵜⵎⴰⵙ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵎⵖⵉⵔ ⵢⵓⵜⴰⵎ, ⴰⵃⴻⵏⵊⵉⵔ ⴰⵎⴰⵥⵓⵥ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ ⵉⵇⵇⵉⵎ ⵡⴻⵃⵃⴷⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG9_6","008_9_6","JDG","9","6","6","ⵓⵛⴰ ⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⴳⴳⵉⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵖⴰⵔ ⵛⴰⴽⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG9_7","008_9_7","JDG","9","7","7","ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⵢⵓⵜⴰⵎ, ⵉⴽⴽⴰⵔ ⵉⴱⴻⴷⴷ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⴰⵔⵉⵣⵉⵎ. ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ ⵖⴰⵔⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵙⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("JG9_8","008_9_8","JDG","9","8","8","“ⴰⵛⵃⴰⵍ ⵓⵢⴰ ⴽⴽⴰⵔⴻⵏⵜ ⵜⵛⴻⵊⵊⵓⵔⴰ, ⴼⴼⵖⴻⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵀⵏⴻⵏⵜ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⵏⵏⴰⵏⵜ ⵉ ⵓⵣⴻⵎⵎⵓⵔ: ‘ⵉⵍⵉ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JG9_9","008_9_9","JDG","9","9","9","ⴰⵣⴻⵎⵎⵓⵔ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⵎⴰ ⴰⴷ ⵙⴻⵎⵃⴻⵖ ⴷⵉ ⵜⴰⴷⵓⵏⵜ ⵏ ⵣⵣⴻⵛⵜ ⵉⵏⵓ ⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵎⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵡⴷⴰⵏ? ⵎⴰ ⴰⴷ ⴹⵡⴻⵖ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵖⵏⵉ?’ ");
INSERT INTO rift_vpl VALUES ("JG9_10","008_9_10","JDG","9","10","10","ⵓⵛⴰ ⵏⵏⴰⵏⵜ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉ ⵡⴰⵔⵜⵓ: ‘ⴰⵙ-ⴷⴷ, ⵉⵍⵉ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JG9_11","008_9_11","JDG","9","11","11","ⵓⵔⵜⵓ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⵎⴰ ⴰⴷ ⵙⴻⵎⵃⴻⵖ ⴷⵉ ⵜⴰⵥⵢⵓⴷⵉ ⵉⵏⵓ ⴷ ⵍⵖⵉⴵⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵉⵏⵓ? ⵎⴰ ⴰⴷ ⴹⵡⴻⵖ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵖⵏⵉ?’ ");
INSERT INTO rift_vpl VALUES ("JG9_12","008_9_12","JDG","9","12","12","ⵓⵛⴰ ⵏⵏⴰⵏⵜ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉ ⵜⵣⴰⵢⴰⵔⵜ: ‘ⴰⵙ-ⴷⴷ, ⵉⵍⵉ ⵛⴻⵎ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JG9_13","008_9_13","JDG","9","13","13","ⵎⴰⵛⴰ ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ ⵜⵣⴰⵢⴰⵔⵜ: ‘ⵎⴰ ⴰⴷ ⵙⴻⵎⵃⴻⵖ ⴷⵉ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵉⵏⵓ ⵏⵏⵉ ⵉⵙⵙⴻⴼⵔⴰⵃⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵡⴷⴰⵏ? ⵎⴰ ⴰⴷ ⴹⵡⴻⵖ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵖⵏⵉ?’ ");
INSERT INTO rift_vpl VALUES ("JG9_14","008_9_14","JDG","9","14","14","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ: ‘ⴰⵙ-ⴷⴷ, ⵉⵍⵉ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JG9_15","008_9_15","JDG","9","15","15","ⵓⵛⴰ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵉⵏⵏⴰ ⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ: ‘ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵏⵜ ⴽⴻⵏⵏⵉⵏⵜ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴰⵢⵉ ⵜⴷⴻⵀⵏⴻⵏⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⴽⴻⵏⵜ, ⴰⵙⴻⵏⵜ-ⴷⴷ ⵅⴻⵏⵏⵉ, ⴰⴼⴻⵏⵜ ⴰⴷⵓⵔⵔⵉ ⴷⵉ ⵜⵉⵍⵉ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵍⵍⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⴰⴷ ⵜⴻⵛⵛ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵏ ⵍⵓⴱⵏⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JG9_16","008_9_16","JDG","9","16","16","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴽⴻⵏⵏⵉⵡ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ, ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵓⵎⵉ ⵜⴻⴳⴳⵉⵎ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵓ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵎⵍⵉⵃ ⴷⵉ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⴷⴰⵢⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴷⴰⵀⴻⴵ, ");
INSERT INTO rift_vpl VALUES ("JG9_17","008_9_17","JDG","9","17","17","- ⴰⵇⴰ ⴱⴰⴱⴰ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵓⵛⴰ ⵉⵙⴻⴱⴱⴻⵍ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴼⴻⴽⴽ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵉⴷⵢⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JG9_18","008_9_18","JDG","9","18","18","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵡⵡⵖⴻⵎ ⴰⵙⵙ-ⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⵓ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴰⵇⴰ ⵜⴻⵏⵖⵉⵎ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ, ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵓ ⵜⴻⴳⴳⵉⵎ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰⵜⵡⴻⵎ - ");
INSERT INTO rift_vpl VALUES ("JG9_19","008_9_19","JDG","9","19","19","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⴰⵙⵙ-ⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵍⴻⵚⴼⴰⵢⴻⵜ ⴷⵉ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ ⴷⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴰⵔⵃ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JG9_20","008_9_20","JDG","9","20","20","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵣⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴰⴷ ⵜⴻⵛⵛ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵛⴰⴽⵉⵎ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⵇⴻⵍⵄⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉ ⵍⵇⴻⵍⵄⴰ, ⴰⴷ ⵜⴻⵛⵛ ⴰⴱⵉⵎⴰⵍⵉⴽ!’” ");
INSERT INTO rift_vpl VALUES ("JG9_21","008_9_21","JDG","9","21","21","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵢⵓⵜⴰⵎ, ⵢⴰⵔⵡⴻⵍ, ⵉⵔⵓⵃ ⵖⴰⵔ ⴱⵉ’ⵔ. ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉⵏ, ⵉⴳⴳⵯⴻⵊ ⵅ ⵓⵎⴰⵙ ⴰⴱⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("JG9_22","008_9_22","JDG","9","22","22","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⴻⵎ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵅ ⵉⵙⵔⴰⵉⵍ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("JG9_23","008_9_23","JDG","9","23","23","ⵉⵙⵙⴻⴽⴽ ⴰⵔⴻⴱⴱⵉ ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵊⴰⵔ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ. ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⵖⴷⴰⵔⴻⵏ ⵣⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ, ");
INSERT INTO rift_vpl VALUES ("JG9_24","008_9_24","JDG","9","24","24","ⵃⵉⵎⴰ ⴰⵖⴻⵚⵚⴻⴱ, ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵅ ⵓⵎⴰⵜⵙⴻⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵏⵖⵉⵏ, ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵊⴻⵀⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵖⴻⵏ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG9_25","008_9_25","JDG","9","25","25","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⵡⴻⵊⴷⴻⵏ ⴰⵙ ⵍⴻⴼⵅⵓⵅ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⵏⵉⵜⵏⵉ ⴽⴻⵛⵛⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⴽⴽⴻⵏ ⴷ ⴰⴱⵔⵉⴷ. ⴰⵢⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("JG9_26","008_9_26","JDG","9","26","26","ⵊⴰⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⵉⴷ, ⵢⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵛⴰⴽⵉⵎ ⵓ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⵜⵜⵉⵇⵇⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG9_27","008_9_27","JDG","9","27","27","ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵉⵢⵢⴰⵔⴻⵏ, ⵍⴻⵇⴹⴻⵏ ⵓⴹⵉⵍ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵙⴻⵏ, ⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵓⴹⵉⵍ ⵓⵛⴰ ⵖⴻⵏⵏⵊⴻⵏ ⵉⵣⵍⴰⵏ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵛⵛⵉⵏ ⵙⵡⵉⵏ ⵓⵛⴰ ⵏⴻⵄⵍⴻⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("JG9_28","008_9_28","JDG","9","28","28","ⵓⵛⴰ ⵊⴰⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⵉⴷ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵛⴰⴽⵉⵎ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵙ ⵏⴰⴹⴰⵔ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ? ⵓ ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⴰⴱⵓⵍ ⴷ ⵍⵡⴰⵍⵉ ⵏⵏⴻⵙ? ⵙⴻⵅⵅⴰⵔⴻⵎ ⵅⴻⵏⵏⵉ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵃⴰⵎⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⴽⵉⵎ, ⵎⵉⵏⵣⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵏⵙⴻⵅⵅⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JG9_29","008_9_29","JDG","9","29","29","ⵎⵍⵉ ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⴰⵥⵥⵍⴻⵖ ⵅ ⴰⴱⵉⵎⴰⵍⵉⴽ.” ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ: “ⴰⵔⵏⵉ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ!” ");
INSERT INTO rift_vpl VALUES ("JG9_30","008_9_30","JDG","9","30","30","ⵓⵎⵉ ⵣⴰⴱⵓⵍ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵙⵍⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵊⴰⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⵉⴷ, ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG9_31","008_9_31","JDG","9","31","31","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⵊⴰⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⵉⴷ, ⴷ ⴰⵢⵜⵎⴰⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵙⵙⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⴽ ⵜⴰⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG9_32","008_9_32","JDG","9","32","32","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴽⴽⴰⵔ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⵛⴻⴽ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵉⴵⴰⵏ, ⵓⵛⴰ ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG9_33","008_9_33","JDG","9","33","33","ⵓ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵖⴰⵔ ⵡⴻⵏⵇⴰⵔ ⵏ ⵜⴼⵓⵛⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⵣⵉⵛ ⵓⵛⴰ ⵄⵔⴻⴼ ⵅ ⵜⴻⵏⴷⵉⵏⵜ. ⵓ ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵉⴼⴼⴻⵖ, ⴻⴳⴳ ⵅⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵎⵉⵏ ⵅⴻⴼ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⵉⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("JG9_34","008_9_34","JDG","9","34","34","ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵅ ⵛⴰⴽⵉⵎ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG9_35","008_9_35","JDG","9","35","35","ⵓ ⵊⴰⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⵉⴷ, ⵉⴼⴼⴻⵖ-ⴷⴷ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ, ⵉⴽⴽⴰⵔ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG9_36","008_9_36","JDG","9","36","36","ⵓⵎⵉ ⵊⴰⵄⴰⵍ ⵉⵥⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ ⵉ ⵣⴰⴱⵓⵍ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵡⴷⴰⵏ ⵀⴻⴽⴽⵡⴰⵏ-ⴷⴷ ⵣⵉ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵉⴷⵓⵔⴰⵔ.” ⵣⴰⴱⵓⵍ ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵜⵡⴰⵍⵉⴷ ⵜⵉⵍⵉ ⵏ ⵉⴷⵓⵔⴰⵔ ⴷ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG9_37","008_9_37","JDG","9","37","37","ⵊⴰⵄⴰⵍ ⵢⴰⵔⵏⵉ ⵉⵙⵙⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴳⴻⵏⵙ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵣⵉ ⵜⵄⴻⴱⴱⵓⴹⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵉⵛⵜ ⵏ ⵍⴽⵓⵎⴱⴰⵏⵉⵢⵢⴻⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵏ ⵉⴱⴻⵣⴳⴰⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG9_38","008_9_38","JDG","9","38","38","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵣⴰⴱⵓⵍ: “ⵎⴰⵏⵉ ⵉ ⴵⴰⵏ ⵍⴻⵅⵅⵓ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵉ ⵣⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵎⵉⵏ ⵉⵄⵏⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵙ ⵏⵙⴻⵅⵅⴰⵔ? ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵉⵏⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵛⴻⴽ? ⴼⴼⴻⵖ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵓ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⴽⵉⴷⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("JG9_39","008_9_39","JDG","9","39","39","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵊⴰⵄⴰⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵛⴰⴽⵉⵎ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⴱⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("JG9_40","008_9_40","JDG","9","40","40","ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ ⵡⴹⴰⵏ ⴰⵍ ⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG9_41","008_9_41","JDG","9","41","41","ⵉⵇⵇⵉⵎ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷⵉ ⴰⵔⵓⵎⴰ ⵓ ⵣⴰⴱⵓⵍ ⵢⵓⵥⵥⴻⵍ ⵅ ⵊⴰⵄⴰⵍ ⴷ ⴰⵢⵜⵎⴰⵙ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴷⵉ ⵛⴰⴽⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG9_42","008_9_42","JDG","9","42","42","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ, ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵉⵢⵢⴰⵔ. ⴰⵢⴰ ⵄⴰⵡⴷⴻⵏ ⵜ ⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("JG9_43","008_9_43","JDG","9","43","43","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵍⴳⴻⵏⵙ, ⵉⴱⴹⴰ ⵜ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵅⴻⵣⵣⴰⵔ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵖⵍⴻⴱ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG9_44","008_9_44","JDG","9","44","44","ⵎⵉⵏⵣⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴷ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ ⵉ ⵖⴰⵔⴻⵙ, ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ ⵏⵏⴻⵖⵏⵉⵜ ⵓⴷⴼⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵇⴹⴰⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG9_45","008_9_45","JDG","9","45","45","ⴰⵙⵙ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ. ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ, ⵉⵏⵖⴰ ⵍⴳⴻⵏⵙ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ⵅⴻⵏⵏⵉ ⵉⵀⴷⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵙⵙⵓⵢⴻⵙ ⵅⴰⵙ ⵜⴰⵎⴻⴵⴰⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("JG9_46","008_9_46","JDG","9","46","46","ⵓⵎⵉ ⵜ ⵙⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴱⵓⵔⵊ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⴰⵎⵛⴰⵏ ⵏ ⵡⴰⵔⵡⴰⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⴱⴰⵔⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JG9_47","008_9_47","JDG","9","47","47","ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴱⵓⵔⵊ ⵏ ⵛⴰⴽⵉⵎ ⴳⴳⵉⵏ ⴰⴷ ⵎⵓⵏⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG9_48","008_9_48","JDG","9","48","48","ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴱⵉⵎⴰⵍⵉⴽ ⴰⴷⵔⴰⵔ ⵏ ⵚⴰⵍⵎⵓⵏ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵓ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉⵟⵟⴻⴼ ⵛⵛⴰⵇⵓⵔ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵓⵛⴰ ⵉⵇⵍⴻⵄ ⵉⵛⵜ ⵏ ⵜⵚⴻⵟⵟⴰ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ, ⵉⴽⵙⵉ ⵜⵜ ⵓ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ: “ⵎⵉⵏ ⵜⴻⵥⵔⵉⵎ ⴳⴳⵉⵖ ⵏⴻⵛⵛ, ⵇⴻⴵⵇⴻⵎ, ⴳⴳⴻⵎ ⵜ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("JG9_49","008_9_49","JDG","9","49","49","ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ, ⵉⵇⵍⴻⵄ ⵜⴰⵚⴻⵟⵟⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵓ ⵙⵙⴰⵔⵙⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴰⵔⵡⴰⵍ ⵓⵛⴰ ⵇⵇⴻⴷⵎⴻⵏ ⴰⵙⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴰⵔⵡⴰⵍ ⴰⵍⴰⵎⵉ ⵎⵎⵓⵜⴻⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴱⵓⵔⵊ ⵏ ⵛⴰⴽⵉⵎ, ⵄⵍⴰⵃⴰⵍ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG9_50","008_9_50","JDG","9","50","50","ⵉⵔⵓⵃ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴱⴰⵚ, ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴰⴱⴰⵚ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JG9_51","008_9_51","JDG","9","51","51","ⵜⵓⵖⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵉⵎⴻⵜⵜⵏⴻⵏ ⵓ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴻⵍⵍⵄⴻⵏ ⵅⴰⵙⴻⵏ, ⵏⵢⵉⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵏ ⵍⴱⵓⵔⵊ. ");
INSERT INTO rift_vpl VALUES ("JG9_52","008_9_52","JDG","9","52","52","ⵢⵉⵡⴻⴹ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵖⴰⵔ ⵍⴱⵓⵔⵊ ⵓ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ, ⵎⴰⵛⴰ ⵅⵎⵉ ⵏⴻⵜⵜⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴱⵓⵔⵊ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵇⵇⴻⴷ ⵜⵉⵎⴻⵙⵙⵉ, ");
INSERT INTO rift_vpl VALUES ("JG9_53","008_9_53","JDG","9","53","53","ⵜⴻⵏⴹⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵛⵜ ⵏ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵜⵙⵉⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵓⵛⴰ ⵜⴻⵍⴱⴻⵣ ⴰⵙ ⴰⵛⴻⵇⵇⵓⴼ ⵏ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JG9_54","008_9_54","JDG","9","54","54","ⴷⴻⵖⵢⴰ ⵉⵍⴰⵖⴰ ⵏⴻⵜⵜⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵙⵏⴰⵃ, ⵉⵏⵏⴰ ⴰⵙ: “ⵊⴱⴻⴷⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴻⵖ ⴰⵢⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵉⵛⵜ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵖⴰ ⵉ-ⵜ’.” ⵓⵛⴰ ⴰⵃⵓⴷⵔⵉ ⵏⵏⴻⵙ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JG9_55","008_9_55","JDG","9","55","55","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉⵎⵎⵓⵜ, ⴼⴼⵖⴻⵏ-ⴷⴷ, ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG9_56","008_9_56","JDG","9","56","56","ⴰⵎⵎⵓ ⵉ ⵉⵅⴻⴵⴻⵚ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵏⵏⵉ ⵉⴳⴳⴰ ⵉ ⴱⴰⴱⴰⵙ ⵓⵎⵉ ⵉⵏⵖⴰ ⵙⴻⴱⵄⵉⵏ ⵏ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG9_57","008_9_57","JDG","9","57","57","ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵉⴳⴳⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵛⴰⴽⵉⵎ ⵢⴰⵔⵔ ⵉ-ⵜⵜ ⴰⵔⴻⴱⴱⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵓ ⵏⵏⴻⵄⵍⴻⵜ ⵏ ⵢⵓⵜⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ, ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG10_1","008_10_1","JDG","10","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⴱⵉⵎⴰⵍⵉⴽ ⵉⴽⴽⴰⵔ ⵜⵓⵍⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴼⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⴷⵓⴷⵓ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵛⴰⵎⵉⵔ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JG10_2","008_10_2","JDG","10","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ, ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵛⴰⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("JG10_3","008_10_3","JDG","10","3","3","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴽⴽⴰⵔ ⵢⴰ’ⵉⵔ, ⴰⵊⵉⵍⵄⴰⴷⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG10_4","008_10_4","JDG","10","4","4","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵉⵏⵏⵉ ⵉⵏⵏⴰⵢⴻⵏ ⵅ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⵢⴰⵍ ⵓ ⵖⴰⵔⵙⴻⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ, ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙⴻⵏⵜ ‘ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰ’ⵉⵔ’ ⴰⵍ ⴰⵙⵙ-ⴰ. ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG10_5","008_10_5","JDG","10","5","5","ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⵢⴰ’ⵉⵔ, ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵇⴰⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG10_6","008_10_6","JDG","10","6","6","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⵏⵉⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⴷ ‘ⵄⴰⵛⵜⴰⵔⵓⵜⵉⵏ’ ⵓⵍⴰ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⴰⵔⴰⵎ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵚⵉⴷⵓⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG10_7","008_10_7","JDG","10","7","7","ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG10_8","008_10_8","JDG","10","8","8","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⵍⴻⴱⵣⴻⵏ ⵓ ⴰⵔⵥⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⵉ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG10_9","008_10_9","JDG","10","9","9","ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵥⵡⴰⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⵓⵍⴰ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵃⵙⴰⵔ ⵉⵙⵔⴰⵉⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG10_10","008_10_10","JDG","10","10","10","ⵅⴻⵏⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⴰⴽⵉⴷⴻⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵎⴻⵃ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵏⵙⴻⵅⵅⴰⵔ ‘ⵉⴱⴰⵄⵍⴻⵏ’.” ");
INSERT INTO rift_vpl VALUES ("JG10_11","008_10_11","JDG","10","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JG10_12","008_10_12","JDG","10","12","12","ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⴷ ⵉⵎⴰⵄⵓⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵃⵚⴰⵔⴻⵏ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷ ⵖⴰⵔⵉ ⵜⴻⵙⵖⵓⵢⴻⵎ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵏⴻⵊⵎⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JG10_13","008_10_13","JDG","10","13","13","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵙⴻⵎⵃⴻⵎ ⴷⴰⵢⵉ ⵓ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⵙ ⵓⵢⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵏⵊⵉⵎⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG10_14","008_10_14","JDG","10","14","14","ⵓⵢⵓⵔⴻⵎ, ⵜⴻⵙⵖⵓⵢⴻⵎ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵜⴰⵔⴻⵛⵛⵃⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JG10_15","008_10_15","JDG","10","15","15","ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⴰⵏ ⵉ ⵙⵉⴷⵉ: “ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⴻⵅⴹⴰ. ⴻⴳⴳ ⵛⴻⴽ ⴰⴽⵉⴷⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵉⵄⴻⵊⴱⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⵖⵉⵔ ⴼⴻⴽⴽ ⴰⵏⴻⵖ ⴰⵙⵙ-ⴰ ⵡⴰⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("JG10_16","008_10_16","JDG","10","16","16","ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵜⴰⵔⴱⵓ ⵄⴰⴷ ⵍⴻⵖⴱⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG10_17","008_10_17","JDG","10","17","17","ⵜⵜⵡⴰⵙⵎⵓⵏⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵓⵏⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JG10_18","008_10_18","JDG","10","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴳⴻⵏⵙ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵎⴰⵏ ⴰⵔⵢⴰⵣ ⵉ ⵖⴰ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ? ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⵍⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG11_1","008_11_1","JDG","11","1","1","ⵢⴰⴼⵜⴰⵃ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⵊⵉⵍⵄⴰⴷ ⴰⵇⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⴼⵜⴰⵃ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG11_2","008_11_2","JDG","11","2","2","ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ⵓⵎⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⵎⵖⴰⵔⴻⵏ, ⵓⵥⵥⵍⴻⵏ ⵅ ⵢⴰⴼⵜⴰⵃ, ⵏⵏⴰⵏ ⴰⵙ: “ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵟⵟⵉⴼⴻⴷ ⵛⴰ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵖⵏⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("JG11_3","008_11_3","JDG","11","3","3","ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⵢⴰⴼⵜⴰⵃ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜⵎⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵟⵓⴱ. ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵡⵔⴰⵡⵜ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅⵡⴰⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⴼⵜⴰⵃ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG11_4","008_11_4","JDG","11","4","4","ⴰⵡⴰⵔⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵎⵙⴰⵔ, ⴽⴽⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG11_5","008_11_5","JDG","11","5","5","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵢⴰⴼⵜⴰⵃ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵟⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JG11_6","008_11_6","JDG","11","6","6","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉ ⵢⴰⴼⵜⴰⵃ: “ⴰⵙ-ⴷⴷ, ⵉⵍⵉ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏⵏⴻⵖ ⵓ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG11_7","008_11_7","JDG","11","7","7","ⵢⴰⴼⵜⴰⵃ ⵉⵏⵏⴰ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵄⵉⴼⴼⴻⵎ ⵓ ⵜⵓⵥⵥⵍⴻⵎ ⵅⴰⴼⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ? ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ ⵖⴰⵔⵉ ⵜⵓⵙⵉⵎ ⵍⴻⵅⵅⵓ, ⵍⴻⵅⵅⵓ ⵓⵎⵉ ⵜⴻⴵⴰⵎ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("JG11_8","008_11_8","JDG","11","8","8","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⵅ ⵢⴰⴼⵜⴰⵃ: “ⵙ ⵓⵢⴰ ⵉ ⴷⴷ ⵖⴰⵔⴻⴽ ⵏⵓⵙⴰ ⵍⴻⵅⵅⵓ, ⵃⵉⵎⴰ ⵛⴻⴽ ⴰⴽⵉⴷⵏⴻⵖ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵛⴻⴽ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵍⵉⴷ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⵍⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG11_9","008_11_9","JDG","11","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⴼⵜⴰⵃ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ ⴰⵢⵉ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵙⵉⴷⵉ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("JG11_10","008_11_10","JDG","11","10","10","ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⵏⵏⴰⵏ ⵉ ⵢⴰⴼⵜⴰⵃ: “ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵊⴰⵔ ⴰⵏⴻⵖ. ⵓⵛⵜ ⵅⴰⵏⴻⵖ ⵎⴰⵍⴰ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG11_11","008_11_11","JDG","11","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵢⴰⴼⵜⴰⵃ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⵓ ⵍⴳⴻⵏⵙ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⴼⵜⴰⵃ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JG11_12","008_11_12","JDG","11","12","12","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵢⴰⴼⵜⴰⵃ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴼⴼⵖⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("JG11_13","008_11_13","JDG","11","13","13","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵢⴰⴼⵜⴰⵃ: “ⵎⵉⵏⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵣⴻⴳ ⴰⵔⵏⵓⵏ ⴰⵍ ⵢⴰⴱⴱⵓⵇ ⵓ ⴰⵍ ⵍ’ⵓⵔⴷⵓⵏ, ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ. ⴰⵔⵔ ⴰⵢⵉ-ⵜⵜ ⵍⴻⵅⵅⵓ ⵙ ⵍⴻⵀⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("JG11_14","008_11_14","JDG","11","14","14","ⵉⵙⵙⴻⴽⴽ ⵢⴰⴼⵜⴰⵃ ⵄⴰⵡⴻⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG11_15","008_11_15","JDG","11","15","15","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵢⴰⴼⵜⴰⵃ: ‘ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⵟⵟⵉⴼ ⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("JG11_16","008_11_16","JDG","11","16","16","ⵎⵉⵏⵣⵉ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵢⵓⵢⵓⵔ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⵓⵛⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵇⴰⴷⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JG11_17","008_11_17","JDG","11","17","17","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵙⵔⴰⵉⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ, ⵉⵏⵏⴰ: ‘ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵛⵓⵇⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ!’ ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ ⵡⴰⵔ ⵉⵙⵍⵉ ⵛⴰ. ⵉⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵡⵛ ⵜⵜⴻⵙⵔⵉⵃ. ⴰⵎⵎⵓ ⵉⵇⵇⵉⵎ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵇⴰⴷⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JG11_18","008_11_18","JDG","11","18","18","ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⵏⵏⴻⴹ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵎⵎⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴰⵖⵉⵔⵉⵏ ⵉ ⴰⵔⵏⵓⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⴷⴰⵅⴻⵍ ⵉ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵎⴰⵖⴰⵔ ⴰⵔⵏⵓⵏ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JG11_19","008_11_19","JDG","11","19","19","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵙⵔⴰⵉⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵉⵙⵔⴰⵉⵍ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵛⵓⵇ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴰⵍ ⴰⵎⵛⴰⵏ ⵉ ⵖⴰⵔ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("JG11_20","008_11_20","JDG","11","20","20","ⵎⴰⵛⴰ ⵙⵉⵃⵓⵏ ⵡⴰⵔ ⵉⵜⵜⵉⵇⵇ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⵉ ⵖⴰ ⵉⵛⵓⵇ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵡⴰⵀⴰ. ⵓ ⵙⵉⵃⵓⵏ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵊⴰⵀⴰⵚ. ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵎⵎⵏⴻⵖ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG11_21","008_11_21","JDG","11","21","21","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴳⴳⴰ ⵅⴻⵏⵏⵉ ⵙⵉⵃⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅⴰⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵉⵙⵔⴰⵉⵍ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG11_22","008_11_22","JDG","11","22","22","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵣⴻⴳ ⴰⵔⵏⵓⵏ ⴰⵍ ⵢⴰⴱⴱⵓⵇ ⵓ ⵣⵉ ⵍⴻⵅⵍⴰ ⴰⵍ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG11_23","008_11_23","JDG","11","23","23","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵢⵓⵥⵥⴻⵍ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⵎⴰ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⴷ ⴷ ⵜⴰⵙⵖⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JG11_24","008_11_24","JDG","11","24","24","ⵎⴰ ⵡⴰⵔ ⵜᵉⵟⵟⵉⴼⴻⴷ ⵛⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴽⴰⵎⵓⵛ ⴷ ⵍⵡⴰⵔⵜ? ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⴻⵟⵟⴻⴼ ⵎⴰⵔⵔⴰ ⴷ ⵍⵡⴰⵔⵜ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG11_25","008_11_25","JDG","11","25","25","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰ ⵛⴻⴽ ⵅⴰⵔ ⵙ ⵡⴰⵟⵟⴰⵙ ⵅ ⴱⴰⵍⴰⴽ, ⵎⵎⵉⵙ ⵏ ⵚⵉⴼⴼⵓⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ? ⵎⴰ ⵏⴻⵜⵜⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵎⴰ ⵉⵎⵛⵓⴱⴱⴻⵛ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ? ⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵎⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JG11_26","008_11_26","JDG","11","26","26","ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵣⴷⴻⵖ ⵄⴰⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵃⴰⵛⴱⵓⵏ ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴷⵉ ⵄⴰⵔⵓⵄⵉⵔ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⴰⵔⵏⵓⵏ. ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴼⴻⴽⴽⴻⵎ ⵅⴻⵏⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵡⴻⵇⵜ ⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JG11_27","008_11_27","JDG","11","27","27","ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⴽ ⵅⴹⵉⵖ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⴳⴳⴻⴷ ⴰⵢⵉ ⵍⵖⴰⵔ ⵓⵎⵉ ⴰⴽⵉⴷⵉ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ. ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵍⵇⴰⴹⵉ, ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵙⵙ-ⴰ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ!” ");
INSERT INTO rift_vpl VALUES ("JG11_28","008_11_28","JDG","11","28","28","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵡⴰⵔ ⵉⵙⵍⵉ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵢⴰⴼⵜⴰⵃ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG11_29","008_11_29","JDG","11","29","29","ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵅ ⵢⴰⴼⵜⴰⵃ ⵓ ⵏⴻⵜⵜⴰ ⵉⵥⵡⴰ ⵊⵉⵍⵄⴰⴷ ⴷ ⵎⴰⵏⴰⵙⵙⴰ. ⵏⴻⵜⵜⴰ ⵉⵥⵡⴰ ⵄⴰⵡⴻⴷ ⵅ ⵎⵉⵚⴼⴰ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵓⵛⴰ ⵉⵥⵡⴰ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG11_30","008_11_30","JDG","11","30","30","ⵓⵛⴰ ⵉⵡⴰⵄⴷ ⵢⴰⴼⵜⴰⵃ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵇⴰⵄ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JG11_31","008_11_31","JDG","11","31","31","ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵄⴻⵇⴱⴻⵖ-ⴷⴷ ⴷⵉ ⵍⴻⵀⵏⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵉ ⵉⵎⵎⴻⵍⵇⴰ, ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵙⵉⴷⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵜ ⵇⴻⴷⴷⵎⴻⵖ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵡⴻⵛⵎⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("JG11_32","008_11_32","JDG","11","32","32","ⵅⴰⵙ ⵓⵛⴰ ⵉⵥⵡⴰ ⵢⴰⴼⵜⴰⵃ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⵎⵎⵏⴻⵖ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG11_33","008_11_33","JDG","11","33","33","ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅⴰⵙⴻⵏ ⵣⵉ ⵄⴰⵔⵓⵄⵉⵔ ⴰⵍ ⵎⴰⵏⵉ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵎⵉⵏⵏⵉⵜ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ, ⴰⵍ ⴰⴱⴰⵍ-ⴽⵓⵔⵓⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG11_34","008_11_34","JDG","11","34","34","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵢⴰⴼⵜⴰⵃ ⵖⴰⵔ ⵎⵉⵚⴼⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵢⴻⴵⵉⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ ⵜⴻⵍⵇⴰ ⴱⴰⵔⵔⴰ ⵙ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ ⴷ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⴷ ⴰⵢⴻⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵏ ⵢⴻⴵⵉⵙ, ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵍⴰ ⴷ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JG11_35","008_11_35","JDG","11","35","35","ⵓⵎⵉ ⵜⵜ ⵉⵥⵔⴰ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⵡⴰⵢⵢⴰⵡ, ⵢⴻⴵⵉ, ⵛⴻⵎ ⵜⴻⵙⵙⴻⵀⵡⵉⴷ ⴰⵢⵉ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵓ ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵃⵍⵉⵇ ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵉ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG11_36","008_11_36","JDG","11","36","36","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴱⴰⴱⴰ ⵉⵏⵓ! ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴰⵔⵣⵎⴻⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴻⴳⴳ ⴽⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵉⵏⵜⴰⵇⴻⵎ ⵙⵉⴷⵉ ⵇⴰⵄ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG11_37","008_11_37","JDG","11","37","37","ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵉ ⴱⴰⴱⴰⵙ: “ⵉⵍⵉ ⴰⴷ ⴽⵉⴷⵉ ⵉⵜⵜⵡⴰⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ-ⴰ. ⴻⵊⵊ ⴰⵢⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵖ, ⴰⴷ ⴷⴷ-ⵀⵡⵉⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵔⵓⵖ ⵅ ⵉⴷⵓⵔⴰⵔ ⵅ ⵜⵓⵄⴻⵣⵔⵉⵢⴰ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴽ-ⴷ ⵜⵎⴻⴷⴷⵓⴽⴰⵍ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JG11_38","008_11_38","JDG","11","38","38","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵓⵢⵓⵔ!” ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜⵔⴰⵃ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵓⵔⴻⵏ. ⵏⴻⵜⵜⴰⵜ ⵎⴰⵛⴰ ⵜᵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⴰⴽ-ⴷ ⵜⵎⴻⴷⴷⵓⴽⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵔⵓ ⵅ ⵜⵓⵄⴻⵣⵔⵉⵢⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG11_39","008_11_39","JDG","11","39","39","ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵇⴻⴼⵍⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵜⴰⵔⴻⴳⴳⵯⵡⴻⵃ-ⴷⴷ ⵖⴰⵔ ⴱⴰⴱⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵇⴼⴻⵍ ⵍⵡⴰⵄⴷ ⵉ ⵉⵡⴰⵄⴷ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⴰⵎⵎⵓ ⵉⴷⵡⴻⵍ ⴷ ⵍⵄⴰⴷⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("JG11_40","008_11_40","JDG","11","40","40","ⴰⵇⴰ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵟⵟⴼⴻⵏⵜ ⴰⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⴰⵔⴻⵏⵜ ⵉ ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⴼⵜⴰⵃ, ⴰⵊⵉⵍⵄⴰⴷⵉ, ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG12_1","008_12_1","JDG","12","1","1","ⵅⴻⵏⵏⵉ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓ ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵖⴰⵔ ⵣⴰⴼⵓⵏ. ⵏⵏⴰⵏ ⵉ ⵢⴰⴼⵜⴰⵃ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵥⵡⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵍⵉⵖⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵏⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⴽ? ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵛ ⵏⴻⵇⵇⴻⴷ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⴷ ⵛⴻⴽ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG12_2","008_12_2","JDG","12","2","2","ⵢⴰⴼⵜⴰⵃ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴼⴻⴽⴽⴻⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG12_3","008_12_3","JDG","12","3","3","ⵓⵎⵉ ⵥⵔⵉⵖ, ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉⵎ ⵉ ⵓⵙⴻⵏⵊⴻⵎ, ⵙⴻⴱⴱⵍⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵓⵛⴰ ⵥⵡⵉⵖ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ. ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ ⵖⴰⵔⵉ ⵜⴳⴻⵄⵄⴷⴻⵎ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴽⵉⴷⵉ ⵜⴻⵎⵎⴻⵏⵖⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JG12_4","008_12_4","JDG","12","4","4","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵢⴰⴼⵜⴰⵃ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵊⵉⵍⵄⴰⴷ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ ⵖⴻⵍⴱⴻⵏ ⵅ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⵉⵏⵣⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵏⵏⴰⵏ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵉⴼⵔⴰⵢⵉⵎ!”, ⴰⵇⴰ ⵊⵉⵍⵄⴰⴷ ⵢⵓⵙⴰ-ⴷⴷ ⵊⴰⵔ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG12_5","008_12_5","JDG","12","5","5","ⵊⵉⵍⵄⴰⴷ ⵉⵃⴻⵡⵡⴻⵙ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵏⵏⴰⵏ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵥⵡⵉⵖ”, ⵅⴻⵏⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵊⵉⵍⵄⴰⴷ: “ⵎⴰ ⵛⴻⴽ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ?” ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵍⵍⴰ!”, ");
INSERT INTO rift_vpl VALUES ("JG12_6","008_12_6","JDG","12","6","6","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵉⵏⵉ ‘ⵛⵉⴱⴱⵓⵍⵉⵜ!’” ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵅⴻⵏⵏⵉ: ‘ⵙⵉⴱⴱⵓⵍⵉⵜ!’ ⵓ ⵉⴱⴰⵏ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⵎⵉⵔ ⴰⴷ ⵜ ⵉⵏⵟⴻⵇ ⵎⵍⵉⵃ, ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵜ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ ⵖⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ⴰⵎⵎⵓ ⵉ ⵡⴹⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG12_7","008_12_7","JDG","12","7","7","ⵜⵓⵖⴰ ⵢⴰⴼⵜⴰⵃ ⵉⵃⴻⴽⴽⴻⵎ ⵉⵙⵔⴰⵉⵍ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵢⴰⴼⵜⴰⵃ, ⴰⵊⵉⵍⵄⴰⴷⵉ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⴻⴳ ⵉⵛⵜ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG12_8","008_12_8","JDG","12","8","8","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⴱⵚⴰⵏ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG12_9","008_12_9","JDG","12","9","9","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⵉⵙⵙⵎⴻⴵⴻⵛ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵙⵙⵉⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓ ⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵙⵙⵉⵙ ⵣⵉ ⴱⴰⵔⵔⴰ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG12_10","008_12_10","JDG","12","10","10","ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵉⴱⵚⴰⵏ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("JG12_11","008_12_11","JDG","12","11","11","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵍⵓⵏ, ⴰⵣⴰⴱⵓⵍⵓⵏⵉ, ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG12_12","008_12_12","JDG","12","12","12","ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵉⵍⵓⵏ, ⴰⵣⴰⴱⵓⵍⵓⵏⵉ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⴰⵢⴰⵍⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG12_13","008_12_13","JDG","12","13","13","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵄⴰⴱⴷⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵀⵉⵍⵍⴰⵍ, ⵣⵉ ⴼⵉⵔⵄⴰⵜⵓⵏ, ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG12_14","008_12_14","JDG","12","14","14","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⴰⵢⵢⴰⵡⴻⵏ, ⵉⵏⵏⵉ ⵉⵏⵏⴰⵢⴻⵏ ⵅ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵖⵢⴰⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG12_15","008_12_15","JDG","12","15","15","ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵄⴰⴱⴷⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵀⵉⵍⵍⴻⵍ, ⵣⵉ ⴼⵉⵔⵄⴰⵜⵓⵏ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⴼⵉⵔⵄⴰⵜⵓⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⴰⵎⴰⵍⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("JG13_1","008_13_1","JDG","13","1","1","ⵅⴻⵏⵏⵉ ⴰⵔⵏⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG13_2","008_13_2","JDG","13","2","2","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵚⵓⵔⵄⴰ, ⵣⵉ ⵍⵡⴰⵛⵓⵏ ⵏ ⴷⴰⵏ. ⵜⵓⵖⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵏⵓⵃ. ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⴰⵔⵡⴰ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵔⵓⵡ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JG13_3","008_13_3","JDG","13","3","3","ⵉⴱⴰⵏ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵡⴰⵔ ⵖⴰⵔⴻⵎ ⴱⵓ ⵜⴰⵔⵡⴰ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵔⵡⵓⴷ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴷⴷⴻⵢⵙⴻⵜ, ⴰⴷ ⵜⴰⵔⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("JG13_4","008_13_4","JDG","13","4","4","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵎ! ⵡⴰⵔ ⵙⴻⵙⵙ ⴱⵉⵏⵓ ⵓⵍⴰ ⴷ ⵛⵛⵔⴰⴱ ⵓ ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⴻⴳⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JG13_5","008_13_5","JDG","13","5","5","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵛⴻⵎ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⴰⴷ ⵜⴰⵔⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⴻⴽⴽ ⵍⵎⵓⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG13_6","008_13_6","JDG","13","6","6","ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⴷⴻⴼ ⵓ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ. ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵙⵙⴻⵇⵙⵉⵖ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵢⵓⵙⴰ, ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG13_7","008_13_7","JDG","13","7","7","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵅⵣⴰⵔ, ⵛⴻⵎ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⴰⴷ ⵜⴰⵔⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵡⴰⵔ ⵙⴻⵙⵙ ⴱⵉⵏⵓ ⵓⵍⴰ ⴷ ⵛⵛⵔⴰⴱ ⵓ ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⵡⴰⵍⵓ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("JG13_8","008_13_8","JDG","13","8","8","ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵎⴰⵏⵓⵃ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ, ⴻⵊⵊ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷⴷ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ, ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵢⴰⵙ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵛⴻⵏ ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⴰⴽ-ⴷ ⵓⵃⴻⵏⵊⵉⵔ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵅⴻⵍⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG13_9","008_13_9","JDG","13","9","9","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵖⴰⵔ ⵎⴰⵏⵓⵃ ⵓ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⵇⵉⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵎⴰⵏⵓⵃ ⵜⵓⵖⴰ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵉⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("JG13_10","008_13_10","JDG","13","10","10","ⵏⴻⵜⵜⴰⵜ ⵜⵇⴻⴵⴻⵇ ⵓ ⵜⴻⵄⵍⴻⴼ, ⵜⵄⴰⵡⴻⴷ ⴰⵢⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴷⴷ ⵖⴰⵔⵉ ⵢⵓⵙⵉⵏ, ⵉⴱⴰⵏ ⴰⵢⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG13_11","008_13_11","JDG","13","11","11","ⵉⴽⴽⴰⵔ ⵎⴰⵏⵓⵃ, ⵉⴹⴼⴰⵔ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵏⵓ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵡⴰⵀ, ⴷ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG13_12","008_13_12","JDG","13","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⴰⵏⵓⵃ: “ⵎⴰⵍⴰ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵅⴻⵏⵏⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵍⴻⵅⵅⵓ, ⵎⵉⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⵇⴰⵄⵉⴷⴰ ⵉ ⵣⵉ ⵖⴰ ⵏⵓⵢⵓⵔ ⴰⴽ-ⴷ ⵓⵃⴻⵏⵊⵉⵔ ⵓ ⵎⵉⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("JG13_13","008_13_13","JDG","13","13","13","ⵉⵏⵏⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⵎⴰⵏⵓⵃ: “ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵏⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JG13_14","008_13_14","JDG","13","14","14","ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵓⵛⴰ ⵡⴰⵔ ⵜⵙⴻⵙⵙ ⴱⵉⵏⵓ ⵓⵍⴰ ⴷ ⵛⵛⵔⴰⴱ ⵓ ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⴻⴳⵙⴻⵏ. ⴰⴷ ⵜⴻⵃⴹⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵓⵎⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG13_15","008_13_15","JDG","13","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⴰⵏⵓⵃ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵛⴻⴽ ⵏⴻⵎⵏⴻⵄ ⵖⴰⵔⵏⴻⵖ ⵛⵡⴰⵢⵜ ⴷⴰⵏⵉⵜⴰ ⵓ ⴰⴷ ⴰⵛ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG13_16","008_13_16","JDG","13","16","16","ⵎⴰⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵎⴰⵏⵓⵃ: “ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⵎⴻⵏⵄⴻⴷ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵛ ⵓ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜ ⵜⵇⴻⴷⵎⴻⴷ ⵉ ⵙⵉⴷⵉ.” ⵎⵉⵏⵣⵉ ⵎⴰⵏⵓⵃ ⵡⴰⵔ ⵉⵙⵙⵉⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG13_17","008_13_17","JDG","13","17","17","ⵓⵛⴰ ⵉⵏⵏⴰ ⵎⴰⵏⵓⵃ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵏⴻⴳⴳ ⵛⵛⴰⵏ, ⵅⵎⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG13_18","008_13_18","JDG","13","18","18","ⵉⵏⵏⴰ ⴰⵙ ⵎⴰⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⵅ ⵢⵉⵙⴻⵎ ⵉⵏⵓ? ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⴷ ⵍⴻⵄⵊⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("JG13_19","008_13_19","JDG","13","19","19","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵎⴰⵏⵓⵃ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⵉⵇⴻⴷⴷⴻⵎ ⴰⵢⴰ ⵅ ⵜⴻⵚⴹⴰⵔⵜ ⵉ ⵙⵉⴷⵉ. ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵊ ⵏ ⵍⴻⵄⵊⴻⴱ ⵓⵎⵉ ⵎⴰⵏⵓⵃ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵅⴻⵣⵣⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG13_20","008_13_20","JDG","13","20","20","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵛⴻⵄⵄⴰⵍ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉⴳⴻⵄⵄⴻⴷ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵓⵍⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴳⴻⵄⵄⴻⴷ ⴷⴻⴳ ⵓⵛⴻⵄⵄⴰⵍ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⵎⴰⵏⵓⵃ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵥⵔⵉⵏ ⴰⵢⴰ, ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG13_21","008_13_21","JDG","13","21","21","ⵙⵙⴻⵏⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴱⵉⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵄⴰⴷ ⵖⴰⵔ ⵎⴰⵏⵓⵃ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵏ ⵎⴰⵏⵓⵃ, ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG13_22","008_13_22","JDG","13","22","22","ⵉⵏⵏⴰ ⵎⴰⵏⵓⵃ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵎⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JG13_23","008_13_23","JDG","13","23","23","ⵜⴻⵏⵏⴰ ⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵅⵙ ⴰⴷ ⴰⵏⴻⵖ ⵉⵏⴻⵖ, ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴽⵙⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵖ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵡⴰⵔ ⴷⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵏⵥⴰⵔ ⴰⴷ ⵏⵙⴻⵍ ⵇⴰⵄ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG13_24","008_13_24","JDG","13","24","24","ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ, ⵜⴻⴳⴳⴰ ⴰⵙ ⵛⴰⵎⵛⵓⵏ. ⴰⵃⴻⵏⵊⵉⵔ ⵉⵎⵖⴰⵔ ⵓ ⵙⵉⴷⵉ ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ.    ");
INSERT INTO rift_vpl VALUES ("JG13_25","008_13_25","JDG","13","25","25","ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵉⴱⴷⴰ ⴰⴷ ⵜ ⵉⵏⴷⴻⵀ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴷⴰⵏ ⵊⴰⵔ ⵚⵓⵔⵄⴰ ⴷ ⵉⵛⵜⴰ’ⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("JG14_1","008_14_1","JDG","14","1","1","ⵛⴰⵎⵛⵓⵏ ⵉⵀⵡⴰ ⵖⴰⵔ ⵜⵉⵎⵏⴰⵜⴰ. ⴷⵉ ⵜⵉⵎⵏⴰⵜⴰ ⵉⵥⵔⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵊⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG14_2","008_14_2","JDG","14","2","2","ⵓⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵄⴰⵡⴻⴷ, ⵉⵃⴰⵊⴰ ⵜ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴷⵉ ⵜⵉⵎⵏⴰⵜⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵊⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵡⵢⴻⵎ ⴰⵢⵉ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("JG14_3","008_14_3","JDG","14","3","3","ⵉⵏⵏⴰ ⴰⵙ ⴱⴰⴱⴰⵙ ⵓⵍⴰ ⴷ ⵢⴻⵎⵎⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵊⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⴰⵢⵜⵎⴰⵛ ⵓ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵎⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ?” ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⵎⵛⵓⵏ ⵉ ⴱⴰⴱⴰⵙ: “ⴰⵡⵉ ⴰⵢⵉ ⵉ-ⵜⵜ ⵉ ⵏⴻⵛⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵛⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JG14_4","008_14_4","JDG","14","4","4","ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ-ⵜ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵙⵙⵉⴱⴱⴻⵜ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG14_5","008_14_5","JDG","14","5","5","ⵉⵀⵡⴰ-ⴷⴷ ⵛⴰⵎⵛⵓⵏ ⵖⴰⵔ ⵜⵉⵎⵏⴰⵜⴰ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ. ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵏ ⵜⵉⵎⵏⴰⵜⴰ, ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵣⴻⵀⵀⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG14_6","008_14_6","JDG","14","6","6","ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⴰⵍⴰⵎⵉ ⵜ ⵉⵎⴻⵣⵣⴻⵇ ⴰⵅⵎⵉ ⵉⵜⵜⵡⴰⵎⴻⵣⵣⴻⵇ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵓⵛⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵄⴰⵡⴻⴷ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("JG14_7","008_14_7","JDG","14","7","7","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⵎⴻⵟⵟⵓⵜ. ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵛⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵛⴰⵎⵛⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG14_8","008_14_8","JDG","14","8","8","ⴰⵡⴰⵔⵏⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⴷⵉⵏ ⵄⴰⵡⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⵣⴰⵔ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵡⴻⵢⵔⴰⴷ, ⵓ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵢⵍⴰⴼ ⵏ ⵜⵣⵉⵣⵡⴰ ⴷⵉ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵡⴻⵢⵔⴰⴷ, ⴰⴽ-ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG14_9","008_14_9","JDG","14","9","9","ⵏⴻⵜⵜⴰ ⵉⵢⵔⵓ ⵜⴰⵎⵎⴻⵏⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ, ⵉⵔⵓⵃ ⵓⵛⴰ ⵉⵜⵜⴻⵜⵜ ⵣⵣⴰⵢⴻⵙ ⴰⵎ ⵉⴳⴳⵓⵔ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵏⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴽⴽⴻⵙ-ⴷⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵣⵉ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵡⴻⵢⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG14_10","008_14_10","JDG","14","10","10","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ ⴱⴰⴱⴰⵙ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵓ ⵛⴰⵎⵛⵓⵏ ⵉⴳⴳⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵡⵓⵔⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵓⵎⴻⵏ ⴰⴷ ⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG14_11","008_14_11","JDG","14","11","11","ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ, ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⵉⵡⵢⴻⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG14_12","008_14_12","JDG","14","12","12","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵛⴰⵎⵛⵓⵏ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ. ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵜⵜ ⵜⵛⴰⵔⵔⵃⴻⵎ ⵓ ⴰⴷ ⵅⴰⵙ ⵜⴻⴼⴼⵖⴻⵎ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⵓⵔⴰⵔ-ⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵉⴽⴽⴰⵙ ⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG14_13","008_14_13","JDG","14","13","13","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⵜ ⵜⵛⴰⵔⵔⵃⴻⵎ, ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⵎ ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵉⴽⴽⴰⵙ ⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ.” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵉⵏⵉ ⴰⵏⴻⵖ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵏⵏⴻⵛ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵜⵜ ⵏⵙⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("JG14_14","008_14_14","JDG","14","14","14","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵛⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵓ ⵜⴰⵥⵢⵓⴷⵉ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ.” ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴰⵔⵔⵃⴻⵏ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JG14_15","008_14_15","JDG","14","15","15","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⵏⴰⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵛⴰⵎⵛⵓⵏ: “ⵖⵡⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⵙⵙⴰⵔ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵏⵉⵖ ⴰⴷ ⴰⵎ ⵏⴻⵇⵇⴻⴷ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵎ. ⵎⴰ ⵜⵄⴰⵔⴹⴻⵎ ⴰⵏⴻⵖ ⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⴽⴽⵙⴻⵎ ⴰⴳⵍⴰ ⵏⵏⴻⵖ ⵏⵉⵖ ⵍⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("JG14_16","008_14_16","JDG","14","16","16","ⵓⵛⴰ ⵜⵔⵓ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵛⴰⵎⵛⵓⵏ ⵣⵣⴰⵜⴻⵙ, ⵜⴻⵏⵏⴰ: “ⵛⴻⴽ ⴰⵇⴰ ⵜⵛⴰⵔⵔⵀⴻⴷ ⴰⵢⵉ ⵡⴰⵀⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ. ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵛⵜ ⵏ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜ ⵜⴼⴻⵙⵙⴰⵔⴻⴷ.” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵅⵣⴰⵔ, ⵡⴰⵔ ⵜⵜ ⵏⵏⵉⵖ ⵄⴰⴷ ⵓⵍⴰ ⵉ ⴱⴰⴱⴰ ⵓⵍⴰ ⵉ ⵢⴻⵎⵎⴰ. ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵎ ⵜⵜ ⵉ ⵖⴰ ⵉⵏⵉⵖ ⵉ ⵛⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JG14_17","008_14_17","JDG","14","17","17","ⵏⴻⵜⵜⴰⵜ ⵎⴰⵛⴰ ⵜⵔⵓ ⵣⵣⴰⵜⴻⵙ ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⴳⴳⵉⵏ ⵓⵔⴰⵔ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵎⵙⴰⵔ ⴰⵍⴰⵎⵉ ⵉ ⴷ ⴰⵙ ⵜⵜ ⵉⵏⵏⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵀⵡⴻⵍ ⵉ-ⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵛⴰⵔⵔⴻⵃ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG14_18","008_14_18","JDG","14","18","18","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ: “ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⵉⵥⵉⴷ ⵅ ⵜⴰⵎⵎⴻⵏⵜ ⴷ ⵎⵉⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵅ ⵡⴻⵢⵔⴰⴷ?” ⵅ ⵓⵢⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵛⵔⵉⵣⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⵄⴻⵊⵎⵉⵜ ⵉⵏⵓ, ⵉⵍⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴼⴼⵉⵖⴻⵎ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JG14_19","008_14_19","JDG","14","19","19","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵀⵡⴰ ⵖⴰⵔ ⴰⵛⵇⴰⵍⵓⵏ ⵓⵛⴰ ⵉⵏⵖⴰ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓ ⵉⴽⵙⵉ ⵜⴰⴽⴻⵛⵛⴰⴷⵟ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴼⴻⵀⵎⴻⵏ ⵜⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ. ⴰⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵇⵇ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG14_20","008_14_20","JDG","14","20","20","ⵙ ⵓⵢⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ-ⵜ ⵉⵄⴰⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG15_1","008_15_1","JDG","15","1","1","ⴰⵡⴰⵔⵏⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⵢⵔⴰ ⵏ ⵉⵔⴷⴻⵏ, ⵉⵎⵙⴰⵔ, ⵉⵙⵙⵉⵊⵊⵉ ⵛⴰⵎⵛⵓⵏ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ, ⵉⵏⵏⴰ ⵉ ⴱⴰⴱⴰⵙ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ!” ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵜ ⵉⵊⵊⵉ ⴰⴷ ⵢⴰⴷⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("JG15_2","008_15_2","JDG","15","2","2","ⵉⵏⵏⴰ ⴱⴰⴱⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵛⴻⴽ ⵜⵄⵉⴼⴼⴻⴷ ⵜⵜ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⵛⵉⵖ ⵜⵜ ⵉ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵛ. ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵓⵍⵜⵎⴰⵙ ⵜⴰⵎⴰⵥⵓⵥⵜ ⵄⴰⴷ ⵜⴻⵛⵏⴰ ⵅⴰⵙ? ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵖⴰⵔⴻⴽ ⵜⵉⵍⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG15_3","008_15_3","JDG","15","3","3","ⵎⴰⵛⴰ ⵛⴰⵎⵛⵓⵏ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵜⵡⴰⵍⴰⵜ-ⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵛⴻⵎⵔⴰⵍ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⴷⴰⵢⵙⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG15_4","008_15_4","JDG","15","4","4","ⵓ ⵛⴰⵎⵛⵓⵎ ⵢⵓⵢⵓⵔ, ⵉⵢⵎⴰⵔ-ⴷⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵉⵛⴻⵄⴱⴰⵡⴻⵏ. ⵉⴽⵙⵉ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵉ-ⵜⴻⵏ ⵉⵊⵊ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵉⴽⴻⵏⵏⴰⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴷⵉ ⵍⵡⴻⵙⵟ, ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⴻⵏⵏⴰⵙⴻⵏ, ⵉⵛⴻⴷⴷ ⵉⵊⵊ ⵏ ⵓⵚⴻⴼⴹⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("JG15_5","008_15_5","JDG","15","5","5","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵖ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⵓⵛⴰ ⵉⵊⵊⴰ ⵉⵛⴻⵄⴱⴰⵡⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⴰⵎⵎⵓ ⵉⵙⵙⴰⵔⵖ ⵉⵛⵓⵡⵡⴰⴼⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵓⵣⴻⵎⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JG15_6","008_15_6","JDG","15","6","6","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ: “ⵡⵉ ⵉⴳⴳⵉⵏ ⴰⵢⴰ?” ⵏⵏⴰⵏ; “ⴰⵇⴰ ⴷ ⵛⴰⵎⵛⵓⵏ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵡⴻⵔⵢⴰⵣ. ⵣⵉ ⵜⵉⵎⵏⴰⵜⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵢⵉⵡⵉ ⴰⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵙ.” ⵅⴻⵏⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵇⵇⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JG15_7","008_15_7","JDG","15","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵛⴰⵎⵛⵓⵏ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⴰⵎⵎⵓ, ⵅⴻⵏⵏⵉ ⵃⵙⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵏⵜⴰⵇⵎⴻⵖ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵡⴰⵀⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⴰⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("JG15_8","008_15_8","JDG","15","8","8","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵥⴰ ⴰⵙⴻⵏ ⵉⵖⵙⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ, ⴰⵇⴰ ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ, ⵢⵓⵢⵓⵔ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵉⴼⵔⵉ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵄⵉⵟⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JG15_9","008_15_9","JDG","15","9","9","ⵅⴻⵏⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⴰⵔⴻⵢⵢⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵍ ⵍⴰⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("JG15_10","008_15_10","JDG","15","10","10","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⴰⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ ⵅⴰⵏⴻⵖ ⵜⴳⴻⵄⵄⴷⴻⵎ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴳⴻⵄⵄⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵛⴰⵔⴼ ⵛⴰⵎⵛⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⴻⵙ ⵏⴻⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴽⵉⴷⵏⴻⵖ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG15_11","008_15_11","JDG","15","11","11","ⵓⵛⴰ ⵀⵡⴰⵏ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵉⴼⵔⵉ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵄⵉⵟⴰⵎ, ⵏⵏⴰⵏ ⵉ ⵛⴰⵎⵛⵓⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴻⴽ, ⴰⵇⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵃⴻⴽⴽⵎⴻⵏ ⵅⴰⵏⴻⵖ? ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⴽⵉⴷⵉ ⴳⴳⵉⵏ, ⴰⵎⵎⵓ ⴰⴽⵉⴷⵙⴻⵏ ⵉ ⵖⴰ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG15_12","008_15_12","JDG","15","12","12","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵀⵡⴰ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵏⵛⴰⵔⴼ ⵓ ⴰⴷ ⵛⴻⴽ ⵏⴻⴳⴳ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵛⵓⵏ: “ⵊⴰⴵⴻⵎ ⴰⵢⵉ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵀⴻⵊⵊⵎⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JG15_13","008_15_13","JDG","15","13","13","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵛⴻⴽ ⵏⵛⴰⵔⴼ ⵓ ⴰⴷ ⵛⴻⴽ ⵏⴻⴳⴳ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⵏⴻⵇⵇ.” ⵓⵛⴰ ⵛⴰⵔⴼⴻⵏ ⵜ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵖⵡⵉⵏ ⴷ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵜ ⵣⴻⴳ ⵉⴼⵔⵉ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JG15_14","008_15_14","JDG","15","14","14","ⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵍⴰⵃⵉ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⵉⵙⴻⵖⵡⵉⵏ ⵏⵏⵉ ⵖⴰⵔ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏⵜ ⴰⵎ ⵜⵉⴼⴼⴻⵙⵜ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴼⴻⵙⵢⴻⵏ ⵣⴻⴳ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG15_15","008_15_15","JDG","15","15","15","ⵏⴻⵜⵜⴰ ⵢⵓⴼⴰ ⵉⵊⵊ ⵏ ⵢⵉⵖⴻⵙ ⵏ ⵓⵇⴰⴱⵙⵉ ⴷ ⵟⵟⵔⵉ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵃⴰⵔⵜ ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵖⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG15_16","008_15_16","JDG","15","16","16","ⵉⵏⵏⴰ ⵛⴰⵎⵛⵓⵏ: “ⵙ ⵢⵉⵊⵊ ⵏ ⵢⵉⵖⴻⵙ ⵏ ⵓⵇⴰⴱⵙⵉ ⵏ ⵡⴻⵖⵢⵓⵍ, ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⵓⵔⵔⵉⵛⴻⵏ, ⴰⵇⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵉⵖⴻⵙ ⵏ ⵓⵇⴰⴱⵙⵉ ⵏ ⵜⴻⵖⵢⵓⵍⵜ ⵏⵖⵉⵖ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG15_17","008_15_17","JDG","15","17","17","ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⴹⴰⵔ ⵉⵖⴻⵙ ⵏ ⵓⵇⴰⴱⵙⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵔⴰⵎⴰⵜ-ⵍⴰⵃⵉ, ‘ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏ ⵢⵉⵖⴻⵙ ⵏ ⵓⵇⴰⴱⵙⵉ’. ");
INSERT INTO rift_vpl VALUES ("JG15_18","008_15_18","JDG","15","18","18","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⴼⴰⴷⵉ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵙⴻⵏⵊⴻⵎ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵎⴰ ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵎⵎⵜⴻⵖ ⵙ ⵓⴼⴰⴷⵉ, ⴰⴷ ⵡⴹⵉⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵏⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵅⴻⵜⵏⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JG15_19","008_15_19","JDG","15","19","19","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴼⴻⴵⴻⵇ ⴰⵔⴻⴱⴱⵉ ⴰⵃⴼⵓⵔ ⵏ ⵍⴰⵃⵉ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵎⴰⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵓ ⵓⵛⴰ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ. ⵅ ⵓⵢⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉ ⵜⴰⵍⴰ ⵏⵏⵉ ‘ⵄⴰⵢⵏ-ⵀⴰⵇⵓⵔⴻⵢ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵜⴰⵍⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ’. ⵜⴰⵏⵉⵜⴰ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵍⴰⵃⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JG15_20","008_15_20","JDG","15","20","20","ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG16_1","008_16_1","JDG","16","1","1","ⵓⵎⵉ ⵉⵟⵟⴻⴼ ⵛⴰⵎⵛⵓⵏ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵖⴰⵣⵣⴰ, ⵉⵥⵔⴰ ⴷⵉⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG16_2","008_16_2","JDG","16","2","2","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⴰⵢⵜ ⵏ ⵖⴰⵣⵣⴰ: “ⵛⴰⵎⵛⵓⵏ ⴰⵇⴰ-ⵜ ⴷⴰ!” ⵉⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵓⵛⴰ ⵃⴹⴰⵏ ⴵⵉⵍⴻⵜ ⵜⵎⵓⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⴵⵉⵍⴻⵜ ⵜⵎⵓⵏ ⵙⵙⵇⴰⵔⴻⵏ, ⵏⵏⴰⵏ: “ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵡⴰⵙⵙ ⴰⴷ ⵜ ⵏⴻⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG16_3","008_16_3","JDG","16","3","3","ⵛⴰⵎⵛⵓⵏ ⵎⴰⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵣⵣⴻⵍ ⵉⵟⵟⴻⵚ ⴰⵍ ⴰⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ. ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ-ⴷⴷ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵉⵟⵟⴻⴼ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴽ-ⴷ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵉⵇⵍⴻⵄ ⵉ ⵜⴻⵏⵜ ⵉ-ⴷⴷ ⵙ ⵣⵣⴻⴽⵔⵓⵏ, ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⴱⵓ ⵜⴻⵏⵜ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG16_4","008_16_4","JDG","16","4","4","ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵉⵎⵙⴰⵔ ⵉⵄⵛⴻⵇ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵙⵓⵔⴰⵇ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴷⴰⵍⵉⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JG16_5","008_16_5","JDG","16","5","5","ⵓⵛⴰ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵖⵡⴰ ⵉ-ⵜ, ⵓ ⵅⵣⴰⵔ ⴰⴷ ⵜⴰⴼⴻⴷ ⵣⵉ ⵎⴰⵏⵉⵙ ⵖⴰⵔⴻⵙ ⵊⵊⴻⵀⴷ-ⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵉ ⵖⴰ ⵏⵣⴻⵎⵎⴰⵔ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵏⵛⴰⵔⴼ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴻⵟⵟⴻⴼ. ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵎ ⵏⴻⵡⵛ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⴰⵍⴻⴼ ⵓ-ⵎⵢⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JG16_6","008_16_6","JDG","16","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⴷⴰⵍⵉⵍⴰ ⵉ ⵛⴰⵎⵛⵓⵏ: “ⵉⵏⵉ ⴰⵢⵉ ⵎⴰⵛⴰ, ⵣⵉ ⵎⴰⵏⵉⵙ ⵖⴰⵔⴻⴽ ⵊⵊⴻⵀⴷ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⵛⴰⵔⴼⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵟⵟⴼⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JG16_7","008_16_7","JDG","16","7","7","ⵉⵏⵏⴰ ⴰⵙ ⵛⴰⵎⵛⵓⵏ: “ⵎⴰⵍⴰ ⵛⴰⵔⴼⴻⵏ ⴰⵢⵉ ⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵟⵟⵔⵉ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵥⵉⵖⴻⵏ ⵄⴰⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴰⵔⵅⵓⵖ ⴰⵎ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JG16_8","008_16_8","JDG","16","8","8","ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵥⴻⵡⵔⴰⵏ ⴷ ⵟⵟⵔⵉ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵥⵉⵖⴻⵏ ⵄⴰⴷ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵛⴰⵔⴼ ⵉ-ⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG16_9","008_16_9","JDG","16","9","9","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵃⴻⴷ ⴷⵉ ⵜⴻⵅⵅⴰⵎⵜ ⵏ ⴷⴰⵅⴻⵍ ⵉⵟⵟⴻⴼ ⴰⵃⴻⵟⵟⵓ. ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⴰⵎⵛⵓⵏ, ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵅⴰⴽ!” ⵅⴻⵏⵏⵉ ⵉⵇⴹⵓⵡ ⵉⵥⴻⵡⵔⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵇⴻⵟⵟⴰⵙ ⴱⵏⴰⴷⴻⵎ ⴰⴼⵉⵍⵓ ⵏ ⵜⵉⴼⴼⴻⵙⵜ ⴰⵅⵎⵉ ⵜⵜ ⵜⴻⵍⵇⴻⴼ ⵜⵎⴻⵙⵙⵉ. ⵓⵛⴰ ⵙⵙⵉⵔ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⴷⵡⵉⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG16_10","008_16_10","JDG","16","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⴷⴰⵍⵉⵍⴰ ⵉ ⵛⴰⵎⵛⵓⵏ: “ⵅⵣⴰⵔ, ⵜⵛⴻⵎⵜⴻⴷ ⴰⵢⵉ ⵓ ⵜⴻⵙⵙⵅⴰⵔⵔⵇⴻⴷ ⵅⴰⴼⵉ. ⵉⵏⵉ ⴰⵢⵉ ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵙ ⵎⵉⵏ ⵣⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⵛⴰⵔⴼⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG16_11","008_16_11","JDG","16","11","11","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴰⵔⴼⴻⵏ ⴰⵢⵉ ⵙ ⵜⵙⴻⵖⵡⵉⵏ ⵏ ⵊⴷⵉⴷ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵅⴻⴷⵎⴻⵏⵜ ⵄⴻⵎⵎⴰⵔⵚ, ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴰⵔⵅⵓⵖ ⴰⵎ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JG16_12","008_16_12","JDG","16","12","12","ⵓⵛⴰ ⴷⴰⵍⵉⵍⴰ ⵜⴻⴽⵙⵉ ⵜⵉⵙⴻⵖⵡⵉⵏ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ ⵜⵛⴰⵔⴼ ⵉ-ⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵓ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⴰⵎⵛⵓⵏ, ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵅⴰⴽ!”, ⴷⴻⴳ ⵓⵎⵓⵔ ⴷ ⵉⵊⵊⴻⵏ ⵜⵓⵖⴰ ⵃⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵅⵅⴰⵎⵜ ⵏ ⴷⴰⵅⴻⵍ ⵉⵟⵟⴻⴼ ⴰⵃⴻⵟⵟⵓ. ⵅⴻⵏⵏⵉ ⵉⵇⴻⵟⵟⴻⵙ ⵜⵉⵙⴻⵖⵡⵉⵏ ⵣⴻⴳ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JG16_13","008_16_13","JDG","16","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⴷⴰⵍⵉⵍⴰ ⵉ ⵛⴰⵎⵛⵓⵏ: “ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⵛⴻⵎⵜⴻⴷ ⴰⵢⵉ ⵓ ⵜⴻⵙⵙⵅⴰⵔⵔⵇⴻⴷ ⵅⴰⴼⵉ. ⵉⵏⵉ ⴰⵢⵉ ⵎⴰⵛⴰ, ⵙ ⵎⵉⵏ ⵣⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⵛⴰⵔⴼⴻⵏ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⵎ ⵜⵎⵓⴷⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵎⵓⵣⴰⵔⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⴰⴽ-ⴷ ⵡⴻⵅⵎⴰⵔ ⵏ ⴷⴷⴻⴱⴱⵓⵣ ⵏ ⵜⵅⴻⵢⵢⴰⴹⵜ!” ");
INSERT INTO rift_vpl VALUES ("JG16_14","008_16_14","JDG","16","14","14","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⵎⵜⴻⴷ ⵜⴻⵏⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵎⵉⵔ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⴰⵎⵛⵓⵏ, ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵅⴰⴽ!” ⵅⴻⵏⵏⵉ ⵉⴼⴰⵇ-ⴷⴷ ⵣⴻⴳ ⵢⵉⴹⴻⵚ ⵏⵏⴻⵙ, ⵉⴽⴽⴻⵙ-ⴷⴷ ⴷⴷⴻⴱⴱⵓⵣ ⵏ ⵜⵅⴻⵢⵢⴰⴹⵜ ⴷ ⵓⴼⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JG16_15","008_16_15","JDG","16","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⵎ!’, ⵎⴰⵍⴰ ⵓⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵖⴰⵔⵉ ⵉⴵⵉ? ⵍⴻⵅⵅⵓ ⵜⵛⴻⵎⵜⴻⴷ ⴰⵢⵉ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ ⵣⵉ ⵎⴰⵏⵉⵙ ⵖⴰⵔⴻⴽ ⵊⵊⴻⵀⴷ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG16_16","008_16_16","JDG","16","16","16","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵅⴰⵙ ⴰⵖⵉⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵓ ⵜⴻⵀⵡⴻⵍ ⵉ-ⵜ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ, ⵉⴷⵡⴻⵍ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵍ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JG16_17","008_16_17","JDG","16","17","17","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ-ⵜⵜ ⵎⴰⵔⵔⴰ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵊⵊ ⵏ ⵍⵎⵓⵙ ⵉ ⵓⵃⴻⴼⴼⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵢⵓⵙⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵔⴻⴱⴱⵓⵖ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ. ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵃⴻⴼⴼ ⵓⵛⵓⵡⵡⴰⴼ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⴼⴼⴻⵖ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴰⵔⵅⵓⵖ ⴰⵎ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JG16_18","008_16_18","JDG","16","18","18","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴷⴰⵍⵉⵍⴰ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ-ⵜⵜ ⵎⴰⵔⵔⴰ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⴰ: “ⴰⵙⴻⵎ-ⴷⴷ ⵜⵡⴰⵍⴰ-ⵢⴰ ⴷⴰ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵙⵉⵔⵔ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ.” ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG16_19","008_16_19","JDG","16","19","19","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵊⵊⴰ ⵛⴰⵎⵛⵓⵏ ⴰⴷ ⵉⵟⵟⴻⵚ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ, ⵜⵍⴰⵖⴰ ⵉ ⵡⴻⵔⵢⴰⵣ, ⵜⵇⴻⵙⵙ ⴰⵙ ⵙⴻⴱⵄⴰ ⵏ ⵜⵎⵓⵣⴰⵔⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴱⴷⴰ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG16_20","008_16_20","JDG","16","20","20","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ: “ⴰ ⵛⴰⵎⵛⵓⵏ, ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵅⴰⴽ!” ⵏⴻⵜⵜⴰ ⵉⴼⴰⵇ-ⴷⴷ ⵣⴻⴳ ⵢⵉⴹⴻⵚ, ⵉⵏⵏⴰ: “ⵜⵡⴰⵍⴰ-ⵢⴰ ⴰⴷ ⴰⵔⵅⵓⵖ, ⴰⴷ ⵙⵙⴼⴻⴽⴽⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ”, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵎⴻⵃ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG16_21","008_16_21","JDG","16","21","21","ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵜ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵇⴻⵍⵄⴻⵏ ⴰⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵖⴰⵣⵣⴰ, ⵛⴰⵔⴼⴻⵏ ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵃⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⵉⵙⵙⵓⵏⵏⵓⴹ ⵜⴰⵙⵉⵔⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG16_22","008_16_22","JDG","16","22","22","ⵎⴰⵛⴰ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⵉⵎⴻⵇⵇⴰⵔ ⴷⴻⵖⵢⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⴷ ⴰⵙ ⵃⴻⴼⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG16_23","008_16_23","JDG","16","23","23","ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⵓⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⴷⴰⵊⵓⵏ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵍⴰ ⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵓⵛⴰ ⵏⵏⴰⵏ: “ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵛⴰⵎⵛⵓⵏ, ⵍⴻⵄⴷⵓ ⵏⵏⴻⵖ, ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG16_24","008_16_24","JDG","16","24","24","ⵓⵎⵉ ⵜ ⵉⵥⵔⴰ ⵍⴳⴻⵏⵙ, ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵏⴰⵏ: “ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵉⴳⴳⴰ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵖ: ⵏⴻⵜⵜⴰ, ⵡⴻⵏⵏⵉ ⵉⵅⵍⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵣⵣⴰⵢⵏⴻⵖ ⴰⵟⵟⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("JG16_25","008_16_25","JDG","16","25","25","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵓⵍ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⴼⴰⵔⵃ, ⵏⵏⴰⵏ: “ⵍⴰⵖⴰⵎ ⵉ ⵛⴰⵎⵛⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴼⴰⵔⵃ.” ⵓⵛⴰ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅ ⵛⴰⵎⵛⵓⵏ ⵣⵉ ⵍⴻⵃⴱⴻⵙ ⵓⵛⴰ ⵙⵙⵜⴻⵀⵣⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⵊⵊⵉⵏ ⵜ ⴰⴷ ⵉⴱⴻⴷⴷ ⵊⴰⵔ ⵉⴱⵉⵍⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG16_26","008_16_26","JDG","16","26","26","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵛⵓⵏ ⵉ ⵓⵃⴻⵏⵊⵉⵔ ⵡⴻⵏⵏⵉ ⵜ ⵉⵏⴻⴷⵀⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ: “ⴻⵡⵛ ⴰⵢⵉ ⵛⵡⴰⵢⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ. ⵅⵙⴻⵖ ⴰⴷ ⵃⴰⴷⵉⵖ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⴻⵏⵏⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG16_27","008_16_27","JDG","16","27","27","ⵜⴰⴷⴷⴰⵔⵜ ⵜⵓⵖⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵅ ⵜⵣⴻⵇⵇⴰ ⵉⵡⴰⵟⴰⵏ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵓⵎⵉ ⵉⵜⵜⵖⴻⵏⵏⴻⵏ ⵛⴰⵎⵛⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG16_28","008_16_28","JDG","16","28","28","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵛⴰⵎⵛⵓⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⴰⵔⵔⴻⵚ ⴷⴰⵢⵉ. ⴻⵡⵛ ⴰⵢⵉ ⵎⵖⵉⵔ ⵜⵡⴰⵍⴰ-ⵢⴰ ⵡⴰⵀⴰ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵜⴰⵇⵎⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG16_29","008_16_29","JDG","16","29","29","ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵛⴰⵎⵛⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵉ ⵢⴰⵔⴱⵓⵏ ⵓ ⵎⵉⵏ ⵅⴻⴼ ⵜⵙⴻⵏⵏⴻⴷ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵟⵟⴻⴼ ⵉⵊⵊ ⵏ ⵓⴱⵉⵍⴰⵔ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("JG16_30","008_16_30","JDG","16","30","30","ⵅⴰⵙ ⵓⵛⴰ ⵛⴰⵎⵛⵓⵏ ⵉⵏⵏⴰ: “ⴻⵊⵊ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⵎⵎⴻⵜ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ!”, ⵓ ⵏⴻⵜⵜⴰ ⵉⵖⵏⴻⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵣⵣⴰⵜ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵡⴹⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵅ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⴷⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵉⴵⴰⵏ. ⵜⵓⵖⴰ ⵇⴻⴷⴷⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵉⵏⵖⴰ ⵙ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵖⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JG16_31","008_16_31","JDG","16","31","31","ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵀⵡⴰⵏ-ⴷⴷ ⵓ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜ, ⵉⵡⵢⴻⵏ ⵜ ⵓ ⵏⴻⴹⵍⴻⵏ ⵜ ⵊⴰⵔ ⵚⵓⵔⵄⴰ ⴷ ⵉⵛⵜⴰ’ⵓⵍ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⴱⴰⴱⴰⵙ ⵎⴰⵏⵓⵃ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JG17_1","008_17_1","JDG","17","1","1","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ. ");
INSERT INTO rift_vpl VALUES ("JG17_2","008_17_2","JDG","17","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵢⴻⵎⵎⴰⵙ: “ⴰⵍⴻⴼ ⵓ-ⵎⵢⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷ ⴰⵎ ⵉⵜⵜⵡⴰⴽⴽⵙⴻⵏ, ⵉ ⵅⴰⵙⴻⵏⵜ ⵜⴻⵏⵏⵉⴷ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵉ ⵣⵉ ⵜⵏⴻⵟⵇⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⵅⵣⴰⵔ, ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔⵉ, ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵜⵜ.” ⵢⴻⵎⵎⴰⵙ ⵜⴻⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵎⵎⵉ ⵣⵉ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("JG17_3","008_17_3","JDG","17","3","3","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵍⴻⴼ ⵓ-ⵎⵢⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵢⴻⵎⵎⴰⵙ ⵓⵛⴰ ⵢⴻⵎⵎⴰⵙ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵏⵏⵓⵇⴰⵔⵜ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵜⵜ ⵉ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵉ ⵎⵎⵉ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵛ ⵜⵜ ⴰⵔⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JG17_4","008_17_4","JDG","17","4","4","ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵢⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵄⴰⵡⴻⴷ ⵉ ⵢⴻⵎⵎⴰⵙ. ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵢⴻⵎⵎⴰⵙ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵜⴻⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ, ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ. ");
INSERT INTO rift_vpl VALUES ("JG17_5","008_17_5","JDG","17","5","5","ⵜⵓⵖⴰ ⵎⵉⵅⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓⵛⴰ ⵉⵍⴻⵇⵇⴻⵎ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⴷ ⴰⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG17_6","008_17_6","JDG","17","6","6","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG17_7","008_17_7","JDG","17","7","7","ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⴱⵍⵉⵖ ⵣⵉ ⵍⵡⴰⵛⵓⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵍⴰⵡⵉ, ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉⵏⵏⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG17_8","008_17_8","JDG","17","8","8","ⴰⵔⵢⴰⵣ-ⴰ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵎⴰⵏⵉ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴼ ⴰⵎⵛⴰⵏ. ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ. ");
INSERT INTO rift_vpl VALUES ("JG17_9","008_17_9","JDG","17","9","9","ⵎⵉⵅⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜ: “ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵛⴻⴽ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⴰⵍⴰⵡⵉ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵢⴰⴼⴻⵖ ⴰⵎⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG17_10","008_17_10","JDG","17","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵎⵉⵅⴰ: “ⵇⵇⵉⵎ ⵖⴰⵔⵉ ⵓⵛⴰ ⵜⵉⵍⵉⴷ ⴰⵢⵉ ⴷ ⴱⴰⴱⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ! ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵄⴻⵛⵔⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵛⴰ ⵏ ⵡⴻⵔⵔⵓⴹ ⴷ ⵍⴻⵄⵡⴻⵍⵜ.” ⵓⵛⴰ ⴰⵍⴰⵡⵉ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG17_11","008_17_11","JDG","17","11","11","ⴰⵍⴰⵡⵉ ⵢⴰⵔⴹⴰ ⵅⴰⵙ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵓ ⴰⴱⵍⵉⵖ ⵜⵓⵖⴰ ⵉ ⵎⵉⵅⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG17_12","008_17_12","JDG","17","12","12","ⵎⵉⵅⴰ ⵉⵛⵛⵓⵔ ⴰⵍⴰⵡⵉ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵡⴻⴱⵍⵉⵖ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ. ");
INSERT INTO rift_vpl VALUES ("JG17_13","008_17_13","JDG","17","13","13","ⵓⵛⴰ ⵉⵏⵏⴰ ⵎⵉⵅⴰ: “ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵍⵅⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴰⵍⴰⵡⵉ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG18_1","008_18_1","JDG","18","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ ⵜⴰⵔⴻⵣⵣⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⵣⴷⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⵜⴻⴽⴽⴰⵔ ⵄⴰⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵊⴰⵔ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG18_2","008_18_2","JDG","18","2","2","ⵙⵙⴻⴽⴽⴻⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵣⵉ ⵍⵡⴰⵛⵓⵏ ⵏⵙⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵟⵟⵔⵓⴼⴰ ⵏⵙⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵚⵓⵔⵄⴰ ⴷ ⵉⵛⵜⴰ’ⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵍⴻⵅⴱⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵣⵓⵏ. ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵓⵢⵓⵔⴻⵎ, ⴰⵔⵣⵓⵎ ⵜⴰⵎⵎⵓⵔⵜ!” ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ ⵓⵛⴰ ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG18_3","008_18_3","JDG","18","3","3","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ, ⵄⴻⵇⵍⴻⵏ ⵅ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⴱⵍⵉⵖ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵛⴻⴽ ⵉ ⴷⴰ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵓ ⵎⵉⵏ ⵉ ⴷⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵓ ⵎⵉⵏ ⵉ ⴷⴰ ⵜⴰⵔⴻⵣⵣⵓⴷ ⵛⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("JG18_4","008_18_4","JDG","18","4","4","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵜⴰ ⴷ ⵜⴰ ⵉ ⵉⴳⴳⴰ ⵎⵉⵅⴰ ⴰⴽⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⵛⵔⴰ ⴰⵢⵉ ⵓ ⴰⵎⵎⵓ ⵉ ⴷⴻⵡⵍⴻⵖ ⵏⴻⵛⵛ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG18_5","008_18_5","JDG","18","5","5","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵙⴻⵇⵙⴰ ⴰⵏⴻⵖ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵙⵙⴻⵏ, ⵎⴰ ⴰⴱⵔⵉⴷ ⵉ ⵖⴰ ⵏⵓⵢⵓⵔ, ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("JG18_6","008_18_6","JDG","18","6","6","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵓⴽⴻⵀⵀⴰⵏ: “ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵍⴻⵀⵏⴰ! ⴰⴱⵔⵉⴷ ⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜ ⵜⴻⴽⴽⴻⵎ, ⴰⵇⴰ-ⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JG18_7","008_18_7","JDG","18","7","7","ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴰⵢⵉⵛ. ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⵣⴷⴻⵖ ⴷⴰⵢⴻⵙ ⴷⵉ ⵍⴰⵎⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⵄⵉⴷⴰ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ, ⵙ ⵍⵀⵓⴷⵏⴻⵜ ⵓ ⴷⵉ ⵍⴰⵎⴰⵏ. ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴻⵏⵏⵉ ⵉⵃⵚⴰⵔⴻⵏ ⵅ ⵢⵉⵊⵊⴻⵏ ⴷⵉ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵉⵖ ⵉⵟⵟⴻⴼ ⵛⴰ ⵙ ⵍⴻⵅⵛⵓⵏⴻⵜ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ ⵓ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵓⵖⵉ ⵡⴰⵍⵓ ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JG18_8","008_18_8","JDG","18","8","8","ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⴷⵉ ⵚⵓⵔⵄⴰ ⴷ ⵉⵛⵜⴰ’ⵓⵍ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ: “ⵎⴰⵏ ⴰⵡⴰⵍ ⵉ ⵖⴰⵔⵡⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JG18_9","008_18_9","JDG","18","9","9","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⴽⴽⴰⵔⴻⵎ, ⵊⵊⴻⵎ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵥⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜⵜ ⵜⴻⵛⵏⴰ ⴰⵟⵟⴰⵙ. ⵎⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜⴰⵔⵙⴰⵎ ⴰⵎⵎⵓ? ⵡⴰⵔ ⵜⵜⴻⵄⴳⵉⵣⴻⵎ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG18_10","008_18_10","JDG","18","10","10","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵡⴹⴻⵎ ⴷⵉⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼⴻⵎ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵡⵙⴻⵄ ⴰⵟⵟⴰⵙ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵡⴻⵎ ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JG18_11","008_18_11","JDG","18","11","11","ⵅⴰⵙ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵙⵙⴻⵏⵏⵉ, ⵣⵉ ⵍⴰⴵ ⵏ ⴷⴰⵏ ⵣⵉ ⵚⵓⵔⵄⴰ ⴷ ⵉⵛⵜⴰ’ⵓⵍ, ⵙⴻⵜⵜⴰ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("JG18_12","008_18_12","JDG","18","12","12","ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ‘ⵎⴰⵅⴰⵏ-ⴷⴰⵏ’ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ.    ");
INSERT INTO rift_vpl VALUES ("JG18_13","008_18_13","JDG","18","13","13","ⵙⵙⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ, ⵄⴷⵓⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ. ");
INSERT INTO rift_vpl VALUES ("JG18_14","008_18_14","JDG","18","14","14","ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⴰⵢⵉⵛ, ⵏⵏⴰⵏ ⵉ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵏⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ? ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵜⴻⵙⵙⵏⴻⵎ ⵎⵉⵏ ⵅⴰⵡⴻⵎ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JG18_15","008_18_15","JDG","18","15","15","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⴱⵍⵉⵖ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ, ⵓⵛⴰ ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("JG18_16","008_18_16","JDG","18","16","16","ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵉ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵙⴻⵏ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JG18_17","008_18_17","JDG","18","17","17","ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵔⴳⴰⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⴳⴻⵄⵄⴷⴻⵏ, ⵓⴷⴼⴻⵏ ⵓ ⵉⵡⵢⴻⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ. ⴰⴽⴻⵀⵀⴰⵏ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴰⴽ-ⴷ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("JG18_18","008_18_18","JDG","18","18","18","ⵅⴻⵎⵙⴰ ⵉⵏⴰ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ, ⴽⴽⵙⴻⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⴽⴻⵀⵀⴰⵏ: “ⵎⵉⵏ ⴷⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JG18_19","008_18_19","JDG","18","19","19","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵙⵓⵙⴻⵎ, ⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵓⵢⵓⵔ ⴰⴽⵉⴷⵏⴻⵖ ⵓ ⴷⵡⴻⵍ ⴷ ⴱⴰⴱⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵏⵏⴻⵖ! ⵎⵉⵏ ⵉⵃⵍⴰⵏ, ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵀⴰ ⵏⵉⵖ ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⴷ ⵢⵉⵊⵊ ⵏ ⵍⴰⴵ ⴷⵉ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("JG18_20","008_18_20","JDG","18","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴰⵔⵃ ⵡⵓⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵊⴰⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JG18_21","008_18_21","JDG","18","21","21","ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ, ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵍⵎⴰⵍ ⴷ ⴷⴷⵇⵓⵍⴰⵜ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG18_22","008_18_22","JDG","18","22","22","ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ, ⵍⴰⵖⴰⵏ-ⴷⴷ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵢⵓⴷⵙⴻⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⵉⵅⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵓⵏⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵅⴻⵛⵛⴻⵏ ⵅ ⴰⵢⵜ ⵏ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG18_23","008_18_23","JDG","18","23","23","ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⴷⴰⵏ, ⵎⴰⵛⴰ ⵉⵏⴰ ⵏⵏⵇⴻⵍⴱⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ ⵉ ⵎⵉⵅⴰ: “ⵎⵉⵏ ⵛⴻⴽ ⵢⵓⵖⵉⵏ? ⵎⴰⵢⴻⵎⵎⵉ ⵜⵍⴰⵖⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ?” ");
INSERT INTO rift_vpl VALUES ("JG18_24","008_18_24","JDG","18","24","24","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⴽⵙⴻⵎ ⵅⴰⴼⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵓ ⵉ ⴳⴳⵉⵖ ⵓⵍⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⵜⵓⵢⵓⵔⴻⵎ. ⵎⵉⵏ ⵖⴰⵔⵉ ⵍⴻⵅⵅⵓ ⵄⴰⴷ? ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⵎ ⵄⴰⴷ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴰⵢⵉ: ‘ⵎⵉⵏ ⵛⴻⴽ ⵢⵓⵖⵉⵏ?’” ");
INSERT INTO rift_vpl VALUES ("JG18_25","008_18_25","JDG","18","25","25","ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵏⵏⴰⵏ ⴰⵙ: “ⵖⴰⵔⴻⴽ ⴰⴷ ⵏⵙⴻⵍ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵖⴰⵔⵏⴻⵖ ⵏⵉⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵡⴻⵎ ⵡⴹⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵢⴻⵡⵄⴰⵔⴻⵏ ⵓ ⵉⵍⵉ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⵓⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG18_26","008_18_26","JDG","18","26","26","ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⵢⵜ ⵏ ⴷⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⵎⵉ ⵉⵥⵔⴰ ⵎⵉⵅⴰ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵊⴻⵀⴷⴻⵏ ⵅⴰⵙ, ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG18_27","008_18_27","JDG","18","27","27","ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵉⵡⵢⴻⵏ ⵎⵉⵏ ⵉⴳⴳⵉⵏ ⵎⵉⵅⴰ ⵓⵍⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴰⵢⵉⵛ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⴷ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜⴻⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JG18_28","008_18_28","JDG","18","28","28","ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴻⴽⴽ, ⵎⵉⵏⵣⵉ ⵍⴰⵢⵉⵛ ⵜⵓⵖⴰ ⵜⵉⴳⴳⵯⵡⴻⵊ ⴰⵟⵟⴰⵙ ⵅ ⵚⵉⴷⵓⵏ ⵓ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⵡⴰⵍⵓ ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵔⴰⵃⵓⴱ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⴱⵏⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG18_29","008_18_29","JDG","18","29","29","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ‘ⴷⴰⵏ’, ⵅ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⴷⴰⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⵉ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵛⴰ ⵣⵉⵛ ⵜⴰⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵍⴰⵢⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("JG18_30","008_18_30","JDG","18","30","30","ⴰⵢⵜ ⵏ ⴷⴰⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵓⵛⴰ ⵢⴰⵀⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵔⵛⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵎⵓⵙⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴷⴰⵏ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JG18_31","008_18_31","JDG","18","31","31","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵎⵉⵅⴰ, ⵜⴻⵏⵏⵉ ⵉⴳⴳⴰ, ⵣⵣⴰⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵎⵉⵏ ⵜⴻⴽⴽⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⴵⴰ ⴷⵉ ⵛⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JG19_1","008_19_1","JDG","19","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵍⴰⵡⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵜⴰⵢⵢⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JG19_2","008_19_2","JDG","19","2","2","ⵎⴰⵛⴰ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵙⵙⴻⴼⴹⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⵜⵜ ⵜⵓⵖⴰ ⵓⵛⴰ ⵜⴻⵙⵎⴻⵃ ⴷⴰⵢⴻⵙ, ⵜⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ⴷⵉⵏⵏⵉ ⵜⴻⵇⵇⵉⵎ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG19_3","008_19_3","JDG","19","3","3","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵡⴻⵔⵢⴰⵣ, ⵉⴹⴼⴰⵔ ⵉ-ⵜⵜ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵡⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴰⵔⴻⴳⴳⵯⴻⵃ. ⵜⵓⵖⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⴽⵉⴷⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵢⵓⵢⴰ ⵏ ⵢⴻⵖⵢⴰⵍ. ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ⵓⵎⵉ ⵜ ⵉⵥⵔⴰ ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵉⴼⴰⵔⵃ ⵍⴰⵎⵉ ⴽⵉⴷⴻⵙ ⵉ ⵖⴰ ⵉⵎⵎⴻⵍⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("JG19_4","008_19_4","JDG","19","4","4","ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ, ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ, ⵉⴳⴳⴰ ⵅⴰⵙ ⴰⵟⵟⴰⵙ ⴰⵖⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴽⵉⴷⴻⵙ ⵉⵇⵇⵉⵎ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ, ⵙⵡⵉⵏ ⵓ ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG19_5","008_19_5","JDG","19","5","5","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴼⴰⵇⴻⵏ ⵣⵉⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⵓⵢⵓⵔ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵉ ⵡⴻⵙⵍⵉ ⵏⵏⴻⵙ: “ⵙⴻⵎⵃⴻⴹ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JG19_6","008_19_6","JDG","19","6","6","ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ, ⵛⵛⵉⵏ, ⵙⵡⵉⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵉ ⵡⴻⵔⵢⴰⵣ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⵇⵇⵉⵎ ⴷⴰ, ⴰⴷ ⵜⴻⵙⵙⴻⵏⵙⴻⴷ ⵓⵛⴰ ⴰⴷ ⵉⴼⴰⵔⵃ ⵡⵓⵍ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG19_7","008_19_7","JDG","19","7","7","ⴰⵔⵢⴰⵣ ⵉⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵢⵓⵢⵓⵔ, ⵎⴰⵛⴰ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ ⵉⴽⴻⵍⵍⴻⴼ ⵅⴰⵙ, ⵉⴳⴳⴰ ⵅⴰⵙ ⴰⵖⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵙⵙⴻⵏⵙ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JG19_8","008_19_8","JDG","19","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵉⴽⴽⴰⵔ ⵣⵉⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵃⵉⵎⴰ ⴰⴷ ⵢⵓⵢⵓⵔ. ⵉⵏⵏⴰ ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ: “ⴰⵔⵏⵉ ⵙⴻⵎⵃⴻⴹ ⵓⵍ ⵏⵏⴻⵛ!” ⵓ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵔⴰⵊⴰⵏ ⴰⵍ ⵖⴰ ⵉⵄⴷⵓ ⵡⴰⵙⵙ ⵓⵛⴰ ⵛⵛⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵎⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG19_9","008_19_9","JDG","19","9","9","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵃⵉⵎⴰ ⴰⴷ ⵢⵓⵢⵓⵔ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ. ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏⵏⴻⵙ, ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵙⵙ ⴳⴳⵓⵔ ⴰⴷ ⵉⵄⴷⵓ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵎⴻⴷⴷⵉⵜ, ⵜⵜⵣⴰⵡⴳⴻⵖ ⵙⴻⵏⵙⴻⵎ ⴷⴰ. ⵅⵣⴰⵔ, ⵙⴼⴰⵔⵃ ⵓⵍ ⵏⵏⴻⵛ ⵓ ⴽⴽⴰⵔⴻⵎ ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵜⵇⵉⴹⵓⵏⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG19_10","008_19_10","JDG","19","10","10","ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵅⵙ ⵛⴰ ⵄⴰⴷ ⴰⴷ ⵉⵙⵙⴻⵏⵙ. ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵢⵓⵢⵓⵔ, ⵢⵉⵡⴻⴹ ⴰⵍ ⵇⵉⴱⴰⵍⵜ ⵢⴰⴱⵓⵙ, ⵜⴻⵏⵏⵉ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵓ ⵜⵓⵖⴰ ⵉⵛⵜ ⵏ ⵜⵢⵓⵢⴰ ⵏ ⵢⴻⵖⵢⴰⵍ ⴱⴰⵔⴷⵄⴻⵏ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG19_11","008_19_11","JDG","19","11","11","ⵓⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵢⴰⴱⵓⵙ, ⵜⵓⵖⴰ ⴰⵙⵙ ⴰⴷ ⵉⵄⴷⵓ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ: “ⵓⵢⵓⵔ, ⴰⴷ ⴷⴰ ⵏⴹⴰⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴻⵙⵙⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("JG19_12","008_19_12","JDG","19","12","12","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵏⵏⴻⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵢⵢⵉⵍ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵖⵔⵉⴱⵜ, ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⴰⴷ ⵏⴰⵔⵏⵉ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵊⵉⴱⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG19_13","008_19_13","JDG","19","13","13","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⵣⵓ ⴰⴷ ⵏⴰⵡⴻⴹ ⵖⴰⵔ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏⵏⵉ, ⴰⴷ ⵏⴻⵙⵙⴻⵏⵙ ⴷⵉ ⵊⵉⴱⵄⴰ ⵏⵉⵖ ⴷⵉ ⵔⴰⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG19_14","008_19_14","JDG","19","14","14","ⵏⵉⵜⵏⵉ ⴰⵔⵏⵉⵏ ⵓⵢⵓⵔⴻⵏ ⵓ ⵜⴻⵖⵍⵉ ⵅⴰⵙⴻⵏ ⵜⴼⵓⵛⵜ ⵓⵎⵉ ⵜⴻⵏ-ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵊⵉⴱⵄⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG19_15","008_19_15","JDG","19","15","15","ⵓⵛⴰ ⵙⵙⴼⴰⵔⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⴷⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉ ⵊⵉⴱⵄⴰ. ⵓⵎⵉ ⵖⴰⵔ ⴷⵉⵏ ⵢⵓⴷⴻⴼ, ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵉⴷⴻⴼ ⵃⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG19_16","008_19_16","JDG","19","16","16","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵢⵉⵊⵊ ⵏ ⵓⵡⴻⵙⵙⴰⵔ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵢⵢⴰⵔ. ⵜⵓⵖⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⴰⵛⴰ ⵉⵣⴷⴻⵖ ⴰⵎ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵊⵉⴱⵄⴰ, ⵎⴰⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG19_17","008_19_17","JDG","19","17","17","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵏⴻⵜⵜⴰ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵅⵣⴰⵔ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴽⴽⵉⵏ ⴷ ⴰⴱⵔⵉⴷ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵡⴻⵙⵙⴰⵔ ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵓ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("JG19_18","008_19_18","JDG","19","18","18","ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴰⵍ ⵟⵟⴰⵔⴼ ⵇⴰⵄ ⴹⴻⴼⴼⴰⵔ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵙⵙⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵓⵙⵉⵖ. ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⴳⴳⵓⵔⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵉⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JG19_19","008_19_19","JDG","19","19","19","ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵍⵓⵎ ⴷ ⵍⴻⵄⵍⴻⴼ ⵉ ⵢⴻⵖⵢⴰⵍ ⵏⵏⴻⵖ ⵓⵍⴰ ⴷ ⴰⵖⵔⵓⵎ ⴷ ⴱⵉⵏⵓ ⵉ ⵏⴻⵛⵛ, ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵓ ⵉ ⵓⵃⵓⴷⵔⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ. ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵅⴻⵚⵚ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("JG19_20","008_19_20","JDG","19","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵡⴻⵙⵙⴰⵔ: “ⴰⴷ ⴽⵉⴽ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ! ⵎⴰⵛⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⵇⴰ-ⵜ ⵖⴰⵔⵉ, ⵎⵖⵉⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵏⵓⵙⵉⴷ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("JG19_21","008_19_21","JDG","19","21","21","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⵍⴻⵄⵍⴻⴼ ⵉ ⵉⵖⵢⴰⵍ ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵔⴷⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⵛⵛⵉⵏ ⵙⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG19_22","008_19_22","JDG","19","22","22","ⴷⵉ ⵍⵡⴻⵇⵜ ⴷ ⵉⵛⵜ ⵍⴰⵎⵉ ⵉⴼⴰⵔⵃ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵅⵣⴰⵔ, ⴷⴻⵖⵢⴰ ⵏⵏⴹⴻⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ - ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷ ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ - ⵓⵛⴰ ⵙⵙⵇⴰⵔⵇⴱⴻⵏ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ. ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⴰⵡⴻⵙⵙⴰⵔ, ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⵏⴰⵏ: “ⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⴰⵔⵢⴰⵣ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴽⵉⴷⴻⵙ ⵏⴻⵡⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG19_23","008_19_23","JDG","19","23","23","ⴰⵔⵢⴰⵣ, ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵍⵍⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵛⴰ ⵜⵓⵄⵄⴻⴼⵏⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵖⴰⵔⵡⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴰⵎ ⵜⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JG19_24","008_19_24","JDG","19","24","24","ⵅⵣⴰⵔ, ⵢⴻⴵⵉ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⴻⵏⵜ ⵙⵙⵓⴼⴼⵖⴻⵖ. ⵙⴻⵀⵡⴰⵎ ⵜⴻⵏⵜ ⵓ ⴳⴳⴻⵎ ⴰⴽⵉⴷⵙⴻⵏⵜ ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴰⵎ ⵜⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG19_25","008_19_25","JDG","19","25","25","ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵙⵍⴰⵏ. ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⴰⵔⵢⴰⵣ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⵜ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ⵏⵉⵜⵏⵉ ⵓⵍⵢⴻⵏ ⵅⴰⵙ, ⵊⴻⵢⵢⵃⴻⵏ ⵜⵜ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ ⴰⵍ ⵜⵓⴼⴼⵓⵜ ⵓ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵜⵜ ⴰⴷ ⵜⵓⵢⵓⵔ ⴰⵍⴰⵎⵉ ⵉⵙⴱⴻⵃ ⵍⵃⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JG19_26","008_19_26","JDG","19","26","26","ⵓⵎⵉ ⴷ ⵜⴰⵔⵔⴻⵥ ⵜⵓⴼⴼⵓⵜ, ⵜⵓⵙⴰ-ⴷⴷ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⵓⵛⴰ ⵜⴻⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ, ⵜⴻⵇⵇⵉⵎ ⴷⵉⵏ ⴰⵍⴰⵎⵉ ⵉ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JG19_27","008_19_27","JDG","19","27","27","ⵓⵎⵉ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵙⵉⴷⵉⵙ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵢⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⴷⵉⵏ ⵉ ⵜⴻⵡⴹⴰ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵅ ⵜⵏⴻⴱⴷⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JG19_28","008_19_28","JDG","19","28","28","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ ⴱⴻⴷⴷ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵏⵓⵢⵓⵔ!” ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵡⴻⵖⵢⵓⵍ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG19_29","008_19_29","JDG","19","29","29","ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵍⵎⵓⵙ, ⵉⵟⵟⴻⴼ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵉⵇⴻⵙⵙ ⵉ-ⵜⵜ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG19_30","008_19_30","JDG","19","30","30","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵉⵥⵔⵉⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⴰⵢⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵓⵍⴰ ⵡⴰⵔ ⵜ ⵏⴻⵥⵔⵉ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵅⴻⵎⵎⴻⵎ ⴷⴰⵢⴻⵙ, ⵎⵛⴰⵡⴰⵔⴻⵎ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵓⵛⴰ ⵉⵏⵉⵎ ⵍⴻⵃⴽⴰⵎ!” ");
INSERT INTO rift_vpl VALUES ("JG20_1","008_20_1","JDG","20","1","1","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵜⵎⵓⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵎⵉⵚⴼⴰ, ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG20_2","008_20_2","JDG","20","2","2","ⵉⵎⴷⴻⴱⴱⴰⵔⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JG20_3","008_20_3","JDG","20","3","3","ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵙⵍⵉⵏ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵎⵉⵚⴼⴰ. ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⴰⵏ: “ⵙⵉⵡⵍⴻⵎ, ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵎⵙⴰⵔ ⵜⵓⵄⴻⴼⴼⵏⴰ-ⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("JG20_4","008_20_4","JDG","20","4","4","ⴰⵔⵢⴰⵣ ⴰⵍⴰⵡⵉ, ⴰⵔⵢⴰⵣ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⴰⴽ-ⴷ ⵜⴰⵢⵢⴰ ⵉⵏⵓ ⵣⵉ ⵊⵉⴱⵄⴰ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵏⵙⴻⵖ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_5","008_20_5","JDG","20","5","5","ⵓⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⴱⵄⴰ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵅⴰⴼⵉ, ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ ⴷⵉ ⴵⵉⵍⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⵡⴰⵏ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ ⵓ ⵖⴻⵚⴱⴻⵏ ⵜⴰⵢⵢⴰ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵜⴻⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JG20_6","008_20_6","JDG","20","6","6","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵖ ⵜⴰⵢⵢⴰ ⵉⵏⵓ, ⴱⴹⵉⵖ ⵜⵜ ⴷ ⵜⵉⵙⴻⵇⵇⴰⵔ, ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG20_7","008_20_7","JDG","20","7","7","ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵔⵔⴻⵎ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵡⴰⵡⴰⵍ ⴷ ⵛⵛⵡⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("JG20_8","008_20_8","JDG","20","8","8","ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵍⴳⴻⵏⵙ ⵉⵎⵓⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵏⵏⴰ: “ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵡⴰⵔ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵜⵇⵉⴹⵓⵏⵜ ⵏⵏⴻⵙ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵡⴰⵔ ⵉⵜⵜⵄⵉⵇⵇⵉⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG20_9","008_20_9","JDG","20","9","9","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⴽ-ⴷ ⵊⵉⴱⵄⴰ: ‘ⴰⴷ ⵅⴰⵙ ⵏⴻⴼⴼⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ! ");
INSERT INTO rift_vpl VALUES ("JG20_10","008_20_10","JDG","20","10","10","ⴰⴷ ⵏⴰⵔⴻⵛⵛⴻⵃ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵎⵢⴰ ⵓ ⵎⵢⴰ ⵣⴻⴳ ⵡⴰⵍⴻⴼ ⵓ ⴰⵍⴻⴼ ⵣⵉ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵍⴻⵄⵡⴻⵍⵜ ⵉ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵖⴰⵔ ⵊⵉⴱⵄⴰ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⴷ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⵉ ⵉⴳⴳⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JG20_11","008_20_11","JDG","20","11","11","ⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("JG20_12","008_20_12","JDG","20","12","12","ⵓⵛⴰ ⵙⴻⴽⴽⴻⵏⵜ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵏⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ-ⴰ ⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵎⵙⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JG20_13","008_20_13","JDG","20","13","13","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵡⵛⴻⵎ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ, ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵊⵉⴱⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵃⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ.” ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("JG20_14","008_20_14","JDG","20","14","14","ⵓⵙⵉⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵊⵉⴱⵄⴰ ⵎⵓⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG20_15","008_20_15","JDG","20","15","15","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ, ⵙⴻⵜⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵉ ⵙⵙⵉⴼ, ⴱⵍⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⴱⵄⴰ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵄⴰⴷ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_16","008_20_16","JDG","20","16","16","ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵇⴰ ⴷⵉⵏ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵉ ⵡⴰⵔ ⵜⵜⵡⴰⴷⴰⵔⵔⴱⴻⵏ ⵎⵍⵉⵃ ⵙ ⵓⴼⵓⵙⵉ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ. ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵃⴰⴽⴰ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ ⵙ ⵢⴻⴵⵉⵢ ⵙ ⵓⴼⵓⵙ ⵓⵣⴻⵍⵎⴰⴹ, ⵡⴰⵔ ⵅⴻⵟⵟⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_17","008_20_17","JDG","20","17","17","ⵓⵍⴰ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⵙⴻⴷⴷⴻⵏ. ⵏⵀⵍⴰ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_18","008_20_18","JDG","20","18","18","ⴽⴽⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ⵙⵙⴻⵇⵙⴰⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵏⴰⵏ: “ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴷ ⴰⵎⵣⵡⴰⵔⵓ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ?” ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴰⵎⴻⵣⵡⴰⵔⵓ ⵢⴰⵀⵓⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG20_19","008_20_19","JDG","20","19","19","ⴽⴽⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵊⵉⴱⵄⴰ ");
INSERT INTO rift_vpl VALUES ("JG20_20","008_20_20","JDG","20","20","20","ⴼⴼⵖⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵛⴰ ⵙⴻⴷⴷⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵊⵉⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JG20_21","008_20_21","JDG","20","21","21","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⵉ ⵊⵉⴱⵄⴰ ⵓⵛⴰ ⵖⴻⴹⵍⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_22","008_20_22","JDG","20","22","22","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴳⴳⵉⵏ ⵜⴰⵔⵢⴰⵙⵜ, ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JG20_23","008_20_23","JDG","20","23","23","ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴳⴻⵄⵄⴷⴻⵏ, ⵔⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ, ⵙⵙⴻⵇⵙⴰⵏ: “ⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵎⴰ ⴱⵉⵏⵢⴰⵎⵉⵏ?” ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴳⴰⵄⵄⴷⴻⵎ ⴹⵉⴷⴷ ⵉ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵏⵖⵉ!” ");
INSERT INTO rift_vpl VALUES ("JG20_24","008_20_24","JDG","20","24","24","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("JG20_25","008_20_25","JDG","20","25","25","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵣⵉ ⵊⵉⴱⵄⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵉⵎⵎⴻⵍⵇⴰ. ⵖⴻⴹⵍⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JG20_26","008_20_26","JDG","20","26","26","ⵅⴰⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵉⵙⵔⴰⵉⵍ, ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ, ⵔⵓⵏ. ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵥⵓⵎⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JG20_27","008_20_27","JDG","20","27","27","ⵅⴻⵏⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JG20_28","008_20_28","JDG","20","28","28","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵎⴰ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵎⴰ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵏⵉⵖ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴻⵙⵎⴻⵃ?” ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴼⴼⵖⴻⵎ, ⵎⴰⵖⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JG20_29","008_20_29","JDG","20","29","29","ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵙⵔⴰⵉⵍ ⵍⴻⴼⵅⵓⵅ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵊⵉⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JG20_30","008_20_30","JDG","20","30","30","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴹⵉⴷⴷ ⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵊⵉⴱⵄⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⴳⴳⵉⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_31","008_20_31","JDG","20","31","31","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵜⵜⵡⴰⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⵄⴷⵓⵏ, ⴱⴷⴰⵏ ⴰⴷ ⵏⵖⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵊⵉⴱⵄⴰ, ⵏⵖⵉⵏ ⵄⵍⴰⵃⴰⵍ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG20_32","008_20_32","JDG","20","32","32","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ: “ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵖⴻⵍⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ, ⴰⵎ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ.” ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⵡⴻⵍ, ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⵉⴳⴳⵯⴻⵊ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG20_33","008_20_33","JDG","20","33","33","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵓ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⴱⴰⵄⵍ-ⵜⴰⵎⴰⵔ. ⴷⵉ ⵍⵡⴻⵇⵜ ⴷ ⵉⵛⵜ ⴼⴼⵖⴻⵏ ⵉⵏⵏⵉ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⵣⴻⴳ ⵢⴻⴼⵔⵉ ⵏ ⵊⵉⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JG20_34","008_20_34","JDG","20","34","34","ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵓⵔⴻⵏⴷⴰⴷ ⵏ ⵊⵉⴱⵄⴰ ⵓ ⴰⵎⴻⵏⵖⵉ ⵉⴷⵡⴻⵍ ⵉⵡⵄⴰⵔ. ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⴰⵇⴰ ⵜⵉⵛⵜⵉ ⵜⵃⴰⵔⵜ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_35","008_20_35","JDG","20","35","35","ⵙⵉⴷⵉ ⵉⵡⵜⴰ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵖⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵅ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JG20_36","008_20_36","JDG","20","36","36","ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵡⵜⴻⵏ. ⵅⴻⵏⵏⵉ ⵡⵛⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⴰⵙⵉⵄ ⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⴻⵛⵍⴻⵏ ⵅ ⵍⴼⴻⵅ ⵏⵏⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴹⵉⴷⴷ ⵉ ⵊⵉⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JG20_37","008_20_37","JDG","20","37","37","ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵇⴻⴵⵇⴻⵏ ⴰⴷ ⵃⴻⵊⵎⴻⵏ ⵅ ⵊⵉⴱⵄⴰ. ⴰⵎⵎⵓ ⵉ ⵃⴻⵊⵎⴻⵏ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JG20_38","008_20_38","JDG","20","38","38","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵊⵊⴻⵏ ⴰⵙⴻⵢⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴷⴷⴻⵅⵅⴰⵏ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("JG20_39","008_20_39","JDG","20","39","39","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⵏⴻⵖ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵄⵍⴰⵃⴰⵍ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⴰⵇⴰ ⵏⵏⴰⵏ: “ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵡⵜⴻⵏ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ ⴰⵎ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⵎⴻⵣⵡⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("JG20_40","008_20_40","JDG","20","40","40","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵉⴱⴷⴰ ⵓⵙⴻⵢⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⴷⴷⴻⵅⵅⴰⵏ. ⵓⵎⵉ ⵉⵅⵣⴰⵔ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JG20_41","008_20_41","JDG","20","41","41","ⵅⴻⵏⵏⵉ ⵏⵏⵇⴻⵍⴱⴻⵏ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⴰⵇⴰ ⵜⵉⵛⵜⵉ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵜⵓⵖⴰ ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_42","008_20_42","JDG","20","42","42","ⵏⵉⵜⵏⵉ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵎⴻⵏⵖⵉ ⵎⴰⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⴰⵇⴰ ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_43","008_20_43","JDG","20","43","43","ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵄⴻⴼⵙⴻⵏ ⵅⴰⵙⴻⵏ ⴰⵍ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵇⵉⴱⴰⵍⵜ ⵏ ⵊⵉⴱⵄⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JG20_44","008_20_44","JDG","20","44","44","ⵡⴹⴰⵏ ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_45","008_20_45","JDG","20","45","45","ⵅⴻⵏⵏⵉ ⵏⵏⵇⴻⵍⴱⴻⵏ, ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵔⵉⵎⵎⵓⵏ. ⵓ ⵅ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵇⴹⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵅ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⴰⵍ ⵊⵉⴷⵄⵓⵎ, ⵡⵜⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JG20_46","008_20_46","JDG","20","46","46","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_47","008_20_47","JDG","20","47","47","ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵎⴰⵛⴰ ⵏⵏⵇⴻⵍⴱⴻⵏ, ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵔⵉⵎⵎⵓⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵔⵉⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JG20_48","008_20_48","JDG","20","48","48","ⵄⴻⵇⴱⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵍ ⵍⵎⴰⵍ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵓⴼⵉⵏ. ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵙⵙⴰⵔⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵓⴼⵉⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JG21_1","008_21_1","JDG","21","1","1","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵊⵊⵓⴵⴻⵏ ⴷⵉ ⵎⵉⵚⴼⴰ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⵢⴻⴵⵉⵙ ⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JG21_2","008_21_2","JDG","21","2","2","ⵢⵓⵙⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵓⵛⴰ ⵔⵓⵏ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG21_3","008_21_3","JDG","21","3","3","ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵢⴻⵎⵎⵉ ⵉⵎⵙⴰⵔ ⵓⵢⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵜⴻⵇⵇⵉⵎ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜⴱⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("JG21_4","008_21_4","JDG","21","4","4","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⴽⴽⴰⵔ ⵣⵉⵛ. ⵏⵉⵜⵏⵉ ⴱⵏⴰⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⵇⴻⴷⴷⵎⴻⵏ ⵅⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JG21_5","008_21_5","JDG","21","5","5","ⵏⵏⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ?” ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵖⴰⵔ ⵎⵉⵚⴼⴰ, ⵏⵏⴰⵏ: “ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("JG21_6","008_21_6","JDG","21","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵏⴻⴷⵎⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵓⵎⴰⵜⵙⴻⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵏⵏⴰⵏ: “ⴰⵙⵙ-ⴰ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG21_7","008_21_7","JDG","21","7","7","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ? ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵊⵊⵓⴵ ⵖⴰⵔ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵏⴻⵜⵜⵉⵛ ⵛⴰ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JG21_8","008_21_8","JDG","21","8","8","ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵎⵉⵚⴼⴰ?” ⵅⵣⴰⵔ, ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("JG21_9","008_21_9","JDG","21","9","9","ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ, ⵓ ⵅⵣⴰⵔ, ⵣⵉ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG21_10","008_21_10","JDG","21","10","10","ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⴻⴽⴽ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ ⵇⴰⵄ ⵓⵛⴰ ⵓⵎⵓⵔⴻⵏ ⵜⴻⵏ, ⵏⵏⴰⵏ: “ⴳⴰⵄⵄⴷⴻⵎ, ⵡⵜⴻⵎ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JG21_11","008_21_11","JDG","21","11","11","ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ, ⴰⴷ ⵜⴻⵏ ⵜⵃⴰⵔⵔⵎⴻⵎ ⵉ ⵓⵜⴻⵃⵃⵉ!” ");
INSERT INTO rift_vpl VALUES ("JG21_12","008_21_12","JDG","21","12","12","ⵓⴼⵉⵏ ⵊⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵜⴻⴱⵍⵉⵖⵉⵏ ⵜⵉⵏⵏⵉ ⴷ ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵟⵟⵉⵚⴻⵏⵜ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵛⵉⵍⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JG21_13","008_21_13","JDG","21","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴽⴽ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⵎⵓⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵔⵉⵎⵎⵓⵏ, ⴱⴰⵔⵔⵃⴻⵏ ⴰⵙⴻⵏ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JG21_14","008_21_14","JDG","21","14","14","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵊⵊⵉⵏ ⴷⴷⴰⵔⴻⵏⵜ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵇⴻⴷⴷⵉⵏⵜ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JG21_15","008_21_15","JDG","21","15","15","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⵣⵣⵉⴵⴻⵣ ⴰⵙ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵜⴰⵣⵣⵉⵜ ⴷⴻⴳ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG21_16","008_21_16","JDG","21","16","16","ⵓⵛⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏⵜ ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JG21_17","008_21_17","JDG","21","17","17","ⵓ ⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ: “ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⴰⵇⴰ-ⵜⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⵎⴻⵃⵃⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG21_18","008_21_18","JDG","21","18","18","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙⴻⵏ ⵏⴻⵡⵛ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵣⵉ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⵊⵓⴵⴻⵏ, ⵏⵏⴰⵏ: “ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("JG21_19","008_21_19","JDG","21","19","19","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ: “ⵅⵣⴰⵔ, ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵇⴰ ⴷⵉⵏ ⵍⵄⵉⴷ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵛⵉⵍⵓ. ⵍⵄⵉⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵙⴻⵏⵏⴻⵊ ⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵣⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵍⴻⴱⵓⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("JG21_20","008_21_20","JDG","21","20","20","ⵓ ⵏⵉⵜⵏⵉ ⵄⴻⵍⵎⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵏⵏⴰⵏ: “ⵓⵢⵓⵔⴻⵎ ⴷⵉⵏ ⵓⵛⴰ ⵡⴹⴰⵎ ⵓ ⵃⴹⴰⵎ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JG21_21","008_21_21","JDG","21","21","21","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⵓ ⵜⴻⵥⵔⵉⵎ ⵅⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⴼⴼⵖⴻⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵛⵉⵍⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴹⵃⴻⵏⵜ, ⴼⴼⵖⴻⵎ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵣⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⴻⵊⵊ ⴰⴷ ⵉⵟⵟⴻⴼ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⵛⵉⵍⵓ, ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("JG21_22","008_21_22","JDG","21","22","22","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ ⵏⵉⵖ ⴰⵢⵜⵎⴰⵜⵙⴻⵏⵜ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵛⴻⵜⵛⴰⵏ, ⴰⴷ ⴰⵙⴻⵏ ⵏⵉⵏⵉ: ‘ⵙⴰⵎⵃⴻⵎ ⴰⵏⴻⵖ, ⵊⵊⴻⵎ ⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵢⴰⴱⵉⵛ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴰⵡⵉ ⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵜⴰⵎⵖⴰⵔⵜ, ⵓ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵏⵜ ⵜⴻⵡⵛⵉⵎ, ⵏⵉⵖ ⵉⵍⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵢⵉⵍⵉ ⴷ ⴰⵎⴰⵔⵡⴰⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JG21_23","008_21_23","JDG","21","23","23","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵣⵉ ⵜⴻⵄⵣⴰⵔⵢⵉⵏ ⵉⵛⴻⵟⵟⵃⴻⵏ ⵙ ⵏⵏⵓⴱⵜⴰⵜ ⵜⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ, ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⴳⴳⵉⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JG21_24","008_21_24","JDG","21","24","24","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⵉⵊⵊ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵍⴰⴵ ⵏⵏⴻⵙ. ⴼⴼⵖⴻⵏ ⵙⵙⴻⵏⵏⵉ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JG21_25","008_21_25","JDG","21","25","25","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT1_1","009_1_1","RUT","1","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵇⴻⵟⵟⴰⵏ ⵍⵇⵓⴹⴰⵜ ⵍⴻⵃⴽⴰⵎⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵎⵓ’ⴰⴱ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT1_2","009_1_2","RUT","1","2","2","ⴰⵔⵢⴰⵣ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⴰⵍⵉⵎⴰⵍⵉⴽ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵏⴰⵄⵓⵎⵉ, ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙⴻⵏ ⵎⴰⵃⵍⵓⵏ ⴷ ⴽⵉⵍⵢⵓⵏ, ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵜⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ. ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵎⵓ’ⴰⴱ, ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RT1_3","009_1_3","RUT","1","3","3","ⴰⵍⵉⵎⴰⵍⵉⴽ, ⴰⵔⵢⴰⵣ ⵏ ⵏⴰⵄⵓⵎⵉ, ⵉⵎⵎⵓⵜ. ⵜⴻⵇⵇⵉⵎ ⵏⴻⵜⵜⴰⵜ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT1_4","009_1_4","RUT","1","4","4","ⵉⵏⴰ ⵉⵡⵢⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⵎⵓ’ⴰⴱ, ⵉⵙⴻⵎ ⵏ ⵉⵛⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⵓⵔⴼⴰ ⵓ ⵉⵙⴻⵎ ⵏ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵔⴰⵄⵓⵜ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏⵜ ⴷⵉⵏⵏⵉ ⵍⵇⴻⴷⴷ ⵏ ⵄⵍⴰⵃⴰⵍ ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("RT1_5","009_1_5","RUT","1","5","5","ⵓ ⵎⵎⵓⵜⴻⵏ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ: ⵎⴰⵃⵍⵓⵏ ⴷ ⴽⵉⵍⵢⵓⵏ. ⵜⴻⵇⵇⵉⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵡⴻⵃⵃⴷⴻⵙ, ⴱⵍⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⵓ ⴱⵍⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT1_6","009_1_6","RUT","1","6","6","ⵓⵛⴰ ⵜⴻⵄⴷⴻⵍ ⵏⴰⵄⵓⵎⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵜⴻⵙⵍⴰⵜⵉⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵎⵓ’ⴰⴱ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵜⴻⵙⵍⴰ ⴰⵇⴰ ⵙⵉⴷⵉ ⵢⴰⵔⵣⴻⴼ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("RT1_7","009_1_7","RUT","1","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴻⴼⴼⴻⵖ ⵏⴻⵜⵜⴰⵜ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵙⵍⴰⵜⵉⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵎⴰⵔⵔⴰ ⵍⵡⴻⵇⵜ ⵏⵏⵉ. ⵏⵉⵜⴻⵏⵜⵉ ⵔⵓⵃⴻⵏⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⴳⴳⵯⵃⴻⵏⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("RT1_8","009_1_8","RUT","1","8","8","ⵜⴻⵏⵏⴰ ⵏⴰⵄⵓⵎⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵙⵍⴰⵜⵉⵏ ⵏⵏⴻⵙ: “ⴰⵔⴻⴳⴳⵯⵃⴻⵏⵜ-ⵉ-ⴷⴷ, ⴷⴻⵡⵍⴻⵏⵜ-ⵉ-ⴷⴷ, ⴽⵓⵍ ⵉⵛⵜⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴻⵎⵎⴰⵙ! ⵙⵉⴷⵉ ⴰⴷ ⴰⴽⴻⵏⵜ ⵉⵡⵛ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜⴻⴳⴳⵉⵏⵜ ⴷⴻⴳ ⵉⵎⴻⵜⵜⴰⵏ ⵓ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("RT1_9","009_1_9","RUT","1","9","9","ⵙⵉⴷⵉ ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵜⴰⴼⴻⵏⵜ ⴰⵔⵔⴰⵃⴻⵜ, ⴽⵓⵍ ⵉⵛⵜⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ!” ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⵓⴷⴻⵎ ⵉ-ⵜⴻⵏⵜ ⵓⵛⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏⵜ, ⵙⵖⵓⵢⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("RT1_10","009_1_10","RUT","1","10","10","ⵏⵏⴰⵏⵜ ⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴷⴷ-ⵏⴻⴷⵡⴻⵍ ⵏⵉⵛⴰⵏ ⴰⴽⵉⴷⴻⵎ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("RT1_11","009_1_11","RUT","1","11","11","ⵏⴰⵄⵓⵎⵉ ⵜⴻⵏⵏⴰ: “ⵄⴻⵇⴱⴻⵏⵜ-ⵉ-ⴷⴷ, ⴰ ⵢⴻⵙⵙⵉ! ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⵏⵜ ⴰⴽⵉⴷⵉ ⵜⵔⴰⵃⴻⵏⵜ? ⵎⴰ ⵖⴰⵔⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ ⵄⴰⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("RT1_12","009_1_12","RUT","1","12","12","ⵄⴻⵇⴱⴻⵏⵜ-ⵉ-ⴷⴷ, ⴰ ⵢⴻⵙⵙⵉ ⵉⵏⵓ! ⵔⵓⵃⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵇⴰ ⵡⵙⴰⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵄⴰⴷ ⵡⴻⵔⵢⴰⵣ. ⵡⴰⵅⵅⴰ ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵄⴰⴷ ⴰⵙⵉⵜⴻⵎ!’, ⵡⴰⵀ, ⵉⵍⵉ ⴵⵉⵍⴻⵜ-ⴰ ⴰⴷ ⵉⵍⵉⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵡⴰⵀ, ⴰⴷ ⴰⵔⵡⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RT1_13","009_1_13","RUT","1","13","13","ⵎⴰ ⵜⴻⵅⵙⴻⵏⵜ ⴰⴷ ⵜⵔⴰⵊⴰⵏⵜ ⴰⵍ ⵖⴰ ⵎⵖⴰⵔⴻⵏ, ⵎⴰ ⵜⴻⵅⵙⴻⵏⵜ ⴰⴷ ⵜⵎⴻⵏⵄⴻⵏⵜ ⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵏⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ? ⵍⵍⴰ, ⴰ ⵢⴻⵙⵙⵉ! ⴰⵇⴰ ⴰⵎⴻⴷⴷⵓⵔ ⵉⵏⵓ ⵉⴼⴼⴻⵖ ⴷ ⴰⵎⴻⵔⵣⴰⴳ ⵅⴰⴽⴻⵏⵜ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴹⵉⴷⴷ ⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("RT1_14","009_1_14","RUT","1","14","14","ⵅⴻⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵜⵉⵎⵉⵊⵊⴰⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⴰⵔⵏⵉⵏⵜ ⵄⴰⴷ ⴷⴻⴳ ⵉⵖⵓⵢⵢⴰⵏ ⵓⵛⴰ ⵄⵓⵔⴼⴰ ⵜⴻⵙⵙⵓⴷⴻⵎ ⵍⴰⵍⵍⴰⵙ, ⵎⴰⵛⴰ ⵔⴰⵄⵓⵜ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵍⵚⴻⵇ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT1_15","009_1_15","RUT","1","15","15","ⵜⴻⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵜⴰⵏⵓⵟ ⵏⵏⴻⵎ ⴰⵇⴰ ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵙ. ⴷⵡⴻⵍ, ⵜⴻⴹⴼⴰⵔⴻⴷ ⵜⴰⵏⵓⵟ ⵏⵏⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("RT1_16","009_1_16","RUT","1","16","16","ⵔⴰⵄⵓⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⵣⵉⵢⵢⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵎ ⵙⴻⵎⵃⴻⵖ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵛⴻⵎ, ⴷⵉⵏ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⵓ ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⴻⵏⵙⴻⴷ ⵛⴻⵎ, ⴷⵉⵏ ⵉ ⵖⴰ ⵙⵙⴻⵏⵙⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RT1_17","009_1_17","RUT","1","17","17","ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ, ⴷⵉⵏ ⵉ ⵖⴰ ⵎⵎⵜⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵓ ⴷⵉⵏ ⵉ ⵖⴰ ⵜⵜⵡⴰⵏⴻⴹⵍⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ. ⴻⵊⵊ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵙⵉⴷⵉ ⵜⴰ ⴷ ⵜⴰ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⵎⵖⵉⵔ ⵍⵎⴻⵡⵜ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴱⴹⴰⵏ ⵅⴰⵎ!” ");
INSERT INTO rift_vpl VALUES ("RT1_18","009_1_18","RUT","1","18","18","ⴰⵍⴰⵎⵉ ⵜⴻⵥⵔⴰ ⵏⴰⵄⵓⵎⵉ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵅ ⵜⴻⵛⵍⵉ, ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT1_19","009_1_19","RUT","1","19","19","ⴰⵎⵎⵓ ⵉ ⵢⵓⵢⵓⵔⴻⵏⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏⵜ ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏⵜ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ⵓⵎⵉ ⵉⵡⴹⴻⵏⵜ ⵖⴰⵔ ⴱⴰⵢⵜⵍⴰⵃⵎ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴻⵏⵏⴻⵃⵡⴻⵍ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⵏⵏⴰⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ: “ⵎⴰ ⴷ ⵜⴰ ⴷ ⵏⴰⵄⵓⵎⵉ?” ");
INSERT INTO rift_vpl VALUES ("RT1_20","009_1_20","RUT","1","20","20","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵜⴻⵏⵏⴰ: “ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵍⴰⵖⴰⵏⵜ ‘ⵏⴰⵄⵓⵎⵉ’ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ, ⵎⴰⵛⴰ ⵍⴰⵖⴰⵏⵜ ⴰⵢⵉ: ‘ⵎⴰⵔⴰ’, ⵎⴰⵖⴰⵔ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⴳⴳⴰ ⴷⴰⵢⵉ ⵜⴰⵔⵣⵓⴳⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("RT1_21","009_1_21","RUT","1","21","21","ⴼⴼⵖⴻⵖ ⵛⵛⵓⵔⴻⵖ ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵊⵊⴰ ⴰⵢⵉ ⴰⴷ ⴷⴷ-ⴰⵔⴻⴳⴳⵯⵃⴻⵖ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ. ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⵜⵍⴰⵖⴰⵏⵜ ⵄⴰⴷ ‘ⵏⴰⵄⵓⵎⵉ’ ⵓⵎⵉ ⵅⴰⴼⵉ ⵉⵛⵀⴻⴷ ⵙⵉⴷⵉ ⵓ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("RT1_22","009_1_22","RUT","1","22","22","ⴰⵎⵎⵓ ⵉ ⵜⴰⵔⴻⴳⴳⵯⴻⵃ ⵏⴰⵄⵓⵎⵉ ⴰⴽ-ⴷ ⵔⴰⵄⵓⵜ, ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ, ⵜⴰⵙⵍⵉⴼⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⴷⴷ-ⵉⴷⴻⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵎⵓ’ⴰⴱ. ⵉⵡⴹⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⵖⴰⵔ ⴱⴰⵢⵜⵍ-ⵍⴰⵃⵎ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⵎⴻⵢⵔⴰ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("RT2_1","009_2_1","RUT","2","1","1","ⵏⴰⵄⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⴰⴵ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ, ⵣⵉ ⵍⴰⴵ ⵏ ⴰⵍⵉⵎⴰⵍⵉⴽ, ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⴱⵓⵄⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("RT2_2","009_2_2","RUT","2","2","2","ⵜⴻⵏⵏⴰ ⵔⴰⵄⵓⵜ ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ ⵉ ⵏⴰⵄⵓⵎⵉ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵉⵢⵢⴰⵔ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵜⵉⴷⵔⵉⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.” ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵓⵢⵓⵔ, ⵢⴻⴵⵉ!” ");
INSERT INTO rift_vpl VALUES ("RT2_3","009_2_3","RUT","2","3","3","ⵔⴰⵄⵓⵜ ⵜⵓⵢⵓⵔ ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⴷⵉⵏ, ⵜⴻⵙⵙⵎⵓⵏⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵜⴻⵡⴹⴰ ⴰⵙ-ⴷⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏ ⴱⵓⵄⴰⵣ ⵡⴻⵏⵏⵉ ⵣⵉ ⵍⴰⴵ ⵏ ⴰⵍⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("RT2_4","009_2_4","RUT","2","4","4","ⵓ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⴱⵓⵄⴰⵣ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵉⵏⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ: “ⵙⵉⴷⵉ ⴰⴽⵉⴷⵡⴻⵎ!” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("RT2_5","009_2_5","RUT","2","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⵓⵄⴰⵣ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ: “ⵓⵎⵉ ⵜⴻⴳⴳⴰ ⵢⴻⴵⵉⵙ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵏⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("RT2_6","009_2_6","RUT","2","6","6","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵏⴰⵄⵓⵎⵉ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("RT2_7","009_2_7","RUT","2","7","7","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: ‘ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵜⵉⴷⵔⵉⵏ ⵓ ⴰⴷ ⵢⴰⵔⵡⴻⵖ ⵜⵉⴷⵔⵉⵏ ⵖⴰⵔ ⵉⵛⵓⵡⵡⴰⴼⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ!’ ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵓⵛⴰ ⵜⴻⵇⵇⵉⵎ ⵣⴻⴳ ⵓⵜⴻⴼⴼⵓ ⵏ ⵍⵃⴰⵍ ⴰⵍ ⵍⴻⵅⵅⵓ. ⴷⵔⵓⵙ ⵡⴰⵀⴰ ⵉ ⵜⴻⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RT2_8","009_2_8","RUT","2","8","8","ⴱⵓⵄⴰⵣ ⵉⵏⵏⴰ ⵉ ⵔⴰⵄⵓⵜ: “ⵙⵃⴻⵙ ⵖⴰⵔⵉ, ⴰ ⵢⴻⴵⵉ! ⵡⴰⵔ ⵜⵍⴻⵇⵇⴹⴻⴷ ⵓⵍⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵜⵜⴰⴳⴳⵯⴻⵊ ⵣⵉ ⵙⵙⴰ, ⵎⴰⵛⴰ ⵇⵇⵉⵎ ⵜⵓⴷⵙⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RT2_9","009_2_9","RUT","2","9","9","ⵜⴻⴱⴱⴻⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴰⵢⴰ ⵎⴰⵏⵉ ⵎⴻⵊⵊⴰⵔⴻⵏ, ⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ. ⵏⴻⵛⵛ ⵄⴻⵍⵎⴻⵖ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⵃⵉⴷⵉⵏ. ⵎⴰⵍⴰ ⵜⴻⴼⴼⵓⴷⴻⴷ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⵉⵇⵓⴱⴰⵛ ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⵣⵉ ⵎⵉⵏ ⴷ ⵢⵓⵢⵎⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RT2_10","009_2_10","RUT","2","10","10","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⴹⴰ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⴹⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴱⴻⴷⴷⴻⴷ ⴰⴽⵉⴷⵉ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴷ ⵜⴰⴱⴰⵔⵔⴰⵏⵉⵜ?” ");
INSERT INTO rift_vpl VALUES ("RT2_11","009_2_11","RUT","2","11","11","ⴱⵓⵄⴰⵣ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵏⵏⴰⵏ ⴰⵢⵉ ⵏⵉⵛⴰⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵉ ⵍⴰⵍⵍⴰⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵎ, ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⵙⴻⵎⵃⴻⴷ ⴷⵉ ⴱⴰⴱⴰⵎ ⴷ ⵢⴻⵎⵎⴰⵎ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ⵎⴰⵏⵉ ⵜⵅⴻⵍⵇⴻⴷ ⵓⵛⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("RT2_12","009_2_12","RUT","2","12","12","ⴰⴷ ⵛⴻⵎ ⵉⵅⴻⴵⴻⵚ ⵙⵉⴷⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵎ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⵜⴻⴳⴳⵉⴷ ⵓⵛⴰ ⴰⴷ ⴰⵎ ⴷⴷ-ⵜⴰⵙ ⵍⵎⵓⵏⴻⵜ ⵜⴻⵛⵛⵓⵔ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⴰⴷⵓ ⵉⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⴻⴷⴷⵓⵔⵢⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("RT2_13","009_2_13","RUT","2","13","13","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⴼⴻⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴼⴻⵡⵡⵊⴻⴷ ⵅⴰⴼⵉ, ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴰⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵣⵉ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("RT2_14","009_2_14","RUT","2","14","14","ⵖⴰⵔ ⵍⵃⴰⵍ ⵏ ⵎⴰⵛⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⴱⵓⵄⴰⵣ: “ⴰⵙ-ⴷⴷ ⴷⴰ ⵓⵛⴰ ⴻⵛⵛ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ, ⵙⵉⵙⴻⵏ ⴰⵍⴻⵇⵇⵓⵣ ⵏⵏⴻⵎ ⴷⵉ ⵍⵅⴻⴵ!” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⵇⵉⵎ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵏⴻⵜⵜⴰ ⵜⵉⵖⵡⴰⵡⵉⵏ, ⵜⴻⵛⵛⴰ ⵜⴻⵊⵊⵉⵡⴻⵏ, ⵉⵛⴻⵟⵟ ⵅⴰⵙ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("RT2_15","009_2_15","RUT","2","15","15","ⴰⵍⴰⵎⵉ ⵜⴻⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏ ⵜⵉⴷⵔⵉⵏ, ⵉⵄⵍⴻⵎ ⴱⵓⵄⴰⵣ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏ ⵊⴰⵔ ⵉⵛⵓⵡⵡⴰⴼⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⵓ ⵡⴰⵔ ⵜⵜ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴰⵎ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("RT2_16","009_2_16","RUT","2","16","16","ⵖⴻⴹⵍⴻⵎ ⴰⵙ-ⴷⴷ ⵛⵡⴰⵢⵜ ⵛⵡⴰⵢⵜ ⵣⵉ ⵜⵇⴻⴱⴱⵉⴹⵉⵏ ⵓⵛⴰ ⵊⵊⴻⵎ ⵜⵜ ⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵊⵊⴻⵎ ⵜⵜ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵜⵜ ⵜⵣⴰⵡⴰⵔⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("RT2_17","009_2_17","RUT","2","17","17","ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⵍⴻⵇⵇⴻⴹ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ⵅⴻⵏⵏⵉ ⵜⵚⴻⴼⴼⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⵍⵇⴻⴹ. ⵜⵓⵖⴰ ⵄⵍⴰⵃⴰⵍ ⵍⵇⴻⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("RT2_18","009_2_18","RUT","2","18","18","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵎⵓⵏ ⵉ-ⵜ, ⵜⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵜⴻⵥⵔⴰ ⵍⴰⵍⵍⴰⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⵍⵇⴻⴹ. ⵜⴻⵊⴱⴻⴷ ⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵜⴻⵡⵛⴰ ⴰⵙ ⵜ. ");
INSERT INTO rift_vpl VALUES ("RT2_19","009_2_19","RUT","2","19","19","ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⴻⵇⵙⴰ ⵍⴰⵍⵍⴰⵙ: “ⵎⴰⵏⵉ ⵜⵍⴻⵇⴹⴻⴷ ⴰⵙⵙ-ⴰ ⵓ ⵎⴰⵏⵉ ⵜⵅⴻⴷⵎⴻⴷ? ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵎ ⵉⴱⴻⴷⴷⴻⵏ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵃⴰⵊⴰ ⴰⵙ ⵉ ⵍⴰⵍⵍⴰⵙ ⵡⵉ ⵉ ⵖⴰⵔ ⵜⵓⵖⴰ ⵜⴻⵅⴷⴻⵎ, ⵜⴻⵏⵏⴰ: “ⴰⵔⵢⴰⵣ ⵉ ⵖⴰⵔ ⵅⴻⴷⵎⴻⵖ ⴰⵙⵙ-ⴰ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⴱⵓⵄⴰⵣ.” ");
INSERT INTO rift_vpl VALUES ("RT2_20","009_2_20","RUT","2","20","20","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵏⴰⵄⵓⵎⵉ ⵉ ⵜⴻⵙⵍⵉⴼⵜ ⵏⵏⴻⵙ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴽⴽⵉⵙⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ!” ⵜⴻⵏⵏⴰ ⴰⵙ ⵏⴰⵄⵓⵎⵉ ⵄⴰⵡⴻⴷ: “ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵣⵣⴰⵢⵏⴻⵖ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⴻⴼⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵖ ⵉⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵖⴻⵏ ⴰⴼⴻⴷⴷⴰⵢ.”    ");
INSERT INTO rift_vpl VALUES ("RT2_21","009_2_21","RUT","2","21","21","ⵔⴰⵄⵓⵜ, ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ, ⵜⴻⵏⵏⴰ: “ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵄⴰⴷ: ‘ⵇⵇⵉⵎ ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵉ ⵉⴵⴰⵏ, ⴰⵍ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⴳⵔⴰ ⵏⵏⵉ ⵖⴰⵔⵉ ⵉⴵⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RT2_22","009_2_22","RUT","2","22","22","ⵜⴻⵏⵏⴰ ⵏⴰⵄⵓⵎⵉ ⵉ ⵜⴻⵙⵍⵉⴼⵜ ⵏⵏⴻⵙ ⵔⴰⵄⵓⵜ: “ⵎⵍⵉⵃ, ⴰ ⵢⴻⴵⵉ, ⵎⴰⵍⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵛⴻⵎ ⴰⴽ-ⴷ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⵡⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵉⵀⴻⵡⵍⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("RT2_23","009_2_23","RUT","2","23","23","ⵔⴰⵄⵓⵜ ⵜⴻⵇⵇⵉⵎ ⵜⵓⴷⴻⵙ ⵉ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏ ⴱⵓⵄⴰⵣ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏ ⵜⵉⴷⵔⵉⵏ, ⴰⵍⴰⵎⵉ ⵜⴻⵇⴹⴰ ⵜⵎⴻⵢⵔⴰ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⵜⵎⴻⵢⵔⴰ ⵏ ⵉⵔⴷⴻⵏ ⵓⵛⴰ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵣⴷⴻⵖ ⵖⴰⵔ ⵍⴰⵍⵍⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("RT3_1","009_3_1","RUT","3","1","1","ⵓⵛⴰ ⵍⴰⵍⵍⴰⵙ ⵏⴰⵄⵓⵎⵉ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵢⴻⴵⵉ, ⵎⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⴰⵎ ⴰⴼⴻⵖ ⴰⵎⵛⴰⵏ ⵏ ⵍⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ? ");
INSERT INTO rift_vpl VALUES ("RT3_2","009_3_2","RUT","3","2","2","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴱⵓⵄⴰⵣ, ⵉ ⵖⴰⵔ ⵜⵓⵖⴰ ⵛⴻⵎ ⵊⴰⵔ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵔⴰⴵ ⵏⵏⴻⵖ? ⵅⵣⴰⵔ, ⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⴷ ⵉⵣⵣⵓⵣⴰⵔ ⵉⵎⴻⵏⴷⵉ ⴷⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RT3_3","009_3_3","RUT","3","3","3","ⵙⵉⵔⴷ, ⴷⵀⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓⵛⴰ ⵢⴰⵔⴹ ⵜⴰⵇⴻⵏⴷⵓⵔⵜ ⵏⵏⴻⵎ, ⵅⴻⵏⵏⵉ ⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ! ⵡⴰⵔ ⵙⴻⵛⵛⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵉ ⵡⴻⵔⵢⴰⵣ ⴰⵍ ⵖⴰ ⵢⵉⵍⵉ ⵉⵛⵛⴰ ⵉⵙⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("RT3_4","009_3_4","RUT","3","4","4","ⵎⴰⵍⴰ ⵉⵔⴰⵃ ⴰⴷ ⵉⵟⵟⴻⵚ, ⴰⴷ ⵜⵉⵍⵉ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⵣⴻⵍ. ⴰⴷⴻⴼ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⴷⵉⵏ, ⵜⵄⴰⵔⵔⵉⴷ ⵅ ⴷⴷⵓⵔⵉ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵣⵣⴻⵍ ⴷⵉⵏⵏⵉ! ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵎ ⵢⵉⵏⵉ ⵅⴻⵏⵏⵉ, ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("RT3_5","009_3_5","RUT","3","5","5","ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⵇⵇⴰⵔⴻⴷ, ⴰⴷ ⵜ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("RT3_6","009_3_6","RUT","3","6","6","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵀⵡⴰ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵎⴻⵏⵏⵉ ⵇⴰⵄ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵜⴻⵏⵏⴰ ⵍⴰⵍⵍⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("RT3_7","009_3_7","RUT","3","7","7","ⵍⴰⵎⵉ ⵉⵛⵛⴰ ⵉⵙⵡⴰ ⴱⵓⵄⴰⵣ, ⵉⴼⴰⵔⵃ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⴽⴽⴰⵔ ⵢⵓⵢⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⵣⴻⵍ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵜⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ⵅⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⴱⵍⴰ ⵍⵃⴻⵙⵙ, ⵜⵄⴰⵔⵔⴰ ⵅ ⴷⴷⵓⵔⵉ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵣⵣⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("RT3_8","009_3_8","RUT","3","8","8","ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵓⵖⴰ ⵜⴻⵣⵣⴻⵍ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT3_9","009_3_9","RUT","3","9","9","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⵎ?” ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵔⴰⵄⵓⵜ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ. ⴻⴳⴳ ⵎⴰⵛⴰ ⴰⴼⵔⵉⵡ ⵏⵏⴻⵛ ⵅ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⴼⴷⵉ.”    ");
INSERT INTO rift_vpl VALUES ("RT3_10","009_3_10","RUT","3","10","10","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵜⴻⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵛⴻⵎ ⵣⵉ ⵙⵉⴷⵉ, ⴰ ⵢⴻⴵⵉ! ⵍⴻⵅⵅⵓ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵜⴻⴳⴳⵉⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵎ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵎⴰⵀⵓ ⵙ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵖⴰⵔ ⵛⴻⵎ ⵡⴰⵔ ⵜⵓⵣⵣⵉⵍⴻⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵄⴻⵣⵔⵉⵢⵢⴻⵏ, ⵉⵎⴻⵣⵍⴰⴹ ⵏⵉⵖ ⴰⵢⵜ ⵏ ⴱⵓ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("RT3_11","009_3_11","RUT","3","11","11","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵢⴻⴵⵉ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ! ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⴷ, ⴰⴷ ⴰⵎ ⵜ ⴳⴳⴻⵖ, ⵎⴰⵖⴰⵔ ⵇⴰⵄ ⵡⵉ ⴷⴰ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵛⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵎⵃⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("RT3_12","009_3_12","RUT","3","12","12","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴷ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴼⴷⵉ, ⵎⴰⵛⴰ ⴷⵉⵏ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴼⴷⵉ ⵏⵏⴻⵖⵏⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎ ⵉⵜⵜⴻⵄⵏⴰⵏ ⴽⵜⴰⵔ ⵅⴰⴼⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("RT3_13","009_3_13","RUT","3","13","13","ⵙⴻⵄⴷⵓ ⴵⵉⵍⴻⵜ-ⴰ ⴷⴰ. ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ ⴷⵉ ⵚⵚⴱⴻⵃ, ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴷ ⵅⴰⵎ ⵉⴼⴷⵉ, ⵎⵍⵉⵃ, ⵅⴻⵏⵏⵉ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴼⴷⵉ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵛⴻⵎ ⵉⴼⴷⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵎ ⴼⴷⵉⵖ, ⵙ ⵜⵉⴷⴻⵜⵜ ⵅⴻⵏⵏⵉ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ. ⵇⵇⵉⵎ ⵣⵣⴻⵍ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("RT3_14","009_3_14","RUT","3","14","14","ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵣⵣⴻⵍ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ ⵓⵛⴰ ⵇⴱⴻⵍ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⴰⴷ ⵉⵥⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵜⴻⴽⴽⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵓⵖⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ” ");
INSERT INTO rift_vpl VALUES ("RT3_15","009_3_15","RUT","3","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⴽⵙⵉ ⵜⴰⵛⴹⴰⴹⵜ ⵉ ⵣⵉ ⵜⵍⴻⵃⵃⴼⴻⴷ, ⵟⵟⴻⴼ ⵉ-ⵜⵜ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵛⵓⵔ ⵉ-ⵜⵜ ⵙ ⵙⴻⵜⵜⴰ ⵏ ⵍⴻⵇⵢⴰⵙⴰⵜ ⵏ ⵉⵎⴻⵏⴷⵉ ⵓⵛⴰ ⵉⵙⵙⴰⵔⴱⵓ ⵜⵜ ⵅⴰⵙ. ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("RT3_16","009_3_16","RUT","3","16","16","ⵜⵓⵙⴰ-ⴷⴷ ⵏⴻⵜⵜⴰⵜ ⵖⴰⵔ ⵍⴰⵍⵍⴰⵙ ⵓ ⵜⴰⵏⵉⵜⴰ ⵜⴻⵙⵙⴻⵇⵙⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⵎ, ⴰ ⵢⴻⴵⵉ?” ⵏⴻⵜⵜⴰⵜ ⵜⵃⴰⵊⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴽⵉⵙ ⵉⴳⴳⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RT3_17","009_3_17","RUT","3","17","17","ⵜⴻⵏⵏⴰ: “ⵙⴻⵜⵜⴰ ⵏ ⵍⵎⵓⴷⴰⵜ-ⴰ ⵏ ⵉⵎⴻⵏⴷⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵛⴻⵎ ⵡⴰⵔ ⵜⴻⴳⴳⵓⵔⴻⴷ ⵛⴰ ⵖⴰⵔ ⵍⴰⵍⵍⴰⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵅⵡⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RT3_18","009_3_18","RUT","3","18","18","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵏⴰⵄⵓⵎⵉ: “ⵔⴰⵊⴰ, ⴰ ⵢⴻⴵⵉ, ⵇⵇⵉⵎ ⴷⴰ ⴰⵍ ⵖⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴼⴼⴻⵖ ⵜⵎⴻⵙⵍⴰⵛⵜ. ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵢⵢⵉⵃ ⵛⴰ ⴰⵍ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵄⴰⴷ ⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RT4_1","009_4_1","RUT","4","1","1","ⴱⵓⵄⴰⵣ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ. ⵓ ⵅⵣⴰⵔ, ⵉⵄⴷⵓ-ⴷⴷ ⵓⵎⴻⴼⴷⵉ, ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴱⵓⵄⴰⵣ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⴻⴽ, ⴷⵉⵀⴰ, ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵡⴻⴱⵔⵉⴷ ⵓ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴷⴰⵏⵉⵜⴰ!” ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵉⵇⵇⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("RT4_2","009_4_2","RUT","4","2","2","ⵢⵉⵡⵉ-ⴷⴷ ⴱⵓⵄⴰⵣ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵏⵏⴰ: “ⵇⵉⵎⴻⵎ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ!”, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RT4_3","009_4_3","RUT","4","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵓⵎⴻⴼⴷⵉ: “ⵏⴰⵄⵓⵎⵉ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵜⴻⵅⵙ ⴰⴷ ⵜⴻⵣⵣⴻⵏⵣ ⵜⴰⴽⵉⵔⴰⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵓⵎⴰⵜⵏⴻⵖ ⴰⵍⵉⵎⴰⵍⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("RT4_4","009_4_4","RUT","4","4","4","ⵏⴻⵛⵛ ⵅⴻⵎⵎⴻⵖ, ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵅⴰⵙ ⵅⴻⴱⴱⴰⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⵙⴻⵖ ⵉ-ⵜⵜ ⵣⵣⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴷⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⵣⵣⴰⵜ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵜ ⵜⴻⴼⴷⵉⴷ, ⴼⴷⵉ ⵜⵜ ⵓ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵜ ⵜⴻⴼⴷⵉⴷ, ⵉⵏⵉ ⴰⵢⵉ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴰ ⵃⴻⴷ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⴼⴷⵉ ⵎⵖⵉⵔ ⵛⴻⴽ ⵏⵉⵖ ⴷ ⵏⴻⵛⵛ, ⵓ ⵏⴻⵛⵛ ⵉ ⵉⴵⴰⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵛ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⴼⴷⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("RT4_5","009_4_5","RUT","4","5","5","ⴱⵓⵄⴰⵣ ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ: “ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⵙⵖⴻⴷ ⵉⵢⵢⴰⵔ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⵄⵓⵎⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵖⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵓⵍⴰ ⴷ ⵔⴰⵄⵓⵜ, ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵉⵙⴻⵎ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RT4_6","009_4_6","RUT","4","6","6","ⵉⵏⵏⴰ ⵓⵎⴻⴼⴷⵉ: “ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⴼⴷⵉⵖ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴹⵉⵢⵢⵄⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ. ⴼⴷⵉ ⵜ ⵛⴻⴽ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵎⵉⵏ ⵅⴰⴼⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴼⴷⵉⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⴼⴷⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("RT4_7","009_4_7","RUT","4","7","7","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵏⵏⵉ ⵏ ⵣⵣⵎⴰⵏ ⵓⵎⵉ ⴳⴳⵉⵏ ⴰⴷ ⴱⴻⴷⴷⵍⴻⵏ ⵉⵢⵢⴰⵔ ⵊⴰⵔ ⴰⵙⴻⵏ ⵏⵉⵖ ⵓⵎⵉ ⵜ ⴼⴷⵉⵏ, ⴰⵇⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵙⴰⵏⴷⴰⵍⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⵉⵛ ⵉ-ⵜⵜ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("RT4_8","009_4_8","RUT","4","8","8","ⴰⵎⴻⴼⴷⵉ ⵉⵏⵏⴰ ⵉ ⴱⵓⵄⴰⵣ: “ⵙⴻⵖ ⵉ-ⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵙⴰⵏⴷⴰⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RT4_9","009_4_9","RUT","4","9","9","ⵅⴻⵏⵏⵉ ⴱⵓⵄⴰⵣ ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ, ⴰⵇⴰ ⵏⴻⵛⵛ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵍⵉⵎⴰⵍⵉⴽ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴽⵉⵍⵢⵓⵏ ⵓ ⵏ ⵎⴰⵃⵍⵓⵏ, ⵙⵖⵉⵖ ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⵄⵓⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("RT4_10","009_4_10","RUT","4","10","10","ⵓⵍⴰ ⴷ ⵔⴰⵄⵓⵜ, ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⴰⵃⵍⵓⵏ, ⵉⵡⵢⴻⵖ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵙⴻⵎ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵉⵙⴻⵎ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵛ ⵓ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ.” * ");
INSERT INTO rift_vpl VALUES ("RT4_11","009_4_11","RUT","4","11","11","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵛⵀⵓⴷ! ⵉⵍⵉ ⵙⵉⴷⵉ ⴰⴷ ⵢⴻⴳⴳ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵎ ⵔⴰⵃⵉⵍ ⴷ ⵍⵉⵢⴰ, ⵜⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⴻⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴻⴳⴳ ⵙ ⵛⴹⴰⵔⴻⵜ ⴷⵉ ⵉⴼⵔⴰⵜⴰ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ!    ");
INSERT INTO rift_vpl VALUES ("RT4_12","009_4_12","RUT","4","12","12","ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵜⴻⴳⴳⴰ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⴰⵔⵉⵚ, ⵡⴻⵏⵏⵉ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵜⴰⵎⴰⵔ ⵉ ⵢⴰⵀⵓⴷⴰ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⴱⵍⵉⵖⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("RT4_13","009_4_13","RUT","4","13","13","ⴱⵓⵄⴰⵣ ⵢⵉⵡⵉ ⵔⴰⵄⵓⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵅⴰⵙ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙ ⴰⴷ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("RT4_14","009_4_14","RUT","4","14","14","ⵓⵛⴰ ⵏⵏⴰⵏⵜ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵏⴰⵄⵓⵎⵉ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵛⴻⵎ ⵉⵊⵊⵉⵏ ⴰⵙⵙ-ⴰ ⵏⵀⵍⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⴼⴷⵉ. ⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("RT4_15","009_4_15","RUT","4","15","15","ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵎ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴼⴰⵇⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⵉⵚⵓⵏ ⵅ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵎ, ⵎⴰⵖⴰⵔ ⵜⴰⵙⵍⵉⴼⵜ ⵏⵏⴻⵎ, ⵜⴻⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵜⵓⵔⵓⵡ ⵉ-ⵜ-ⵉ-ⴷⴷ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵃⵍⴰ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RT4_16","009_4_16","RUT","4","16","16","ⵏⴰⵄⵓⵎⵉ ⵜⴻⴽⵙⵉ ⴰⵃⴻⵏⵊⵉⵔ, ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵙⵙⵢⴰⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("RT4_17","009_4_17","RUT","4","17","17","ⵜⴰⵊⵊⴰⵔⵉⵏ ⵡⵛⵉⵏⵜ ⴰⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ, ⵏⵏⴰⵏⵜ: “ⵉ ⵏⴰⵄⵓⵎⵉ ⵉⵜⵜⵡⴰⵔⵡⵓⵡ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ!”, ⵓ ⴳⴳⵉⵏ ⴰⵙ ⵄⵓⴱⵉⴷ. ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵢⴰⵙⵙⴰ, ⴱⴰⴱⴰⵙ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("RT4_18","009_4_18","RUT","4","18","18","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⵣⵉ ⴼⴰⵔⵉⵚ: ⴼⴰⵔⵉⵚ ⵉⵊⵊⴰ-ⴷⴷ ⵃⴰⵚⵔⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("RT4_19","009_4_19","RUT","4","19","19","ⵃⴰⵚⵔⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵔⴰⵎ, ⵔⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("RT4_20","009_4_20","RUT","4","20","20","ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵏⴰⵃⵛⵓⵏ, ⵏⴰⵃⵛⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵙⴰⵍⵎⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("RT4_21","009_4_21","RUT","4","21","21","ⵙⴰⵍⵎⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵓⵄⴰⵣ, ⴱⵓⵄⴰⵣ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⴱⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("RT4_22","009_4_22","RUT","4","22","22","ⵄⵓⴱⵉⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵙⵙⴰ ⴷ ⵢⴰⵙⵙⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S11_1","010_1_1","1SA","1","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵔⴰⵎⴰⵜⴰⵢⵉⵎ-ⵚⵓⴼⵉⵎ, ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⵍⵇⴰⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵜⵓⵃⵓ, ⵎⵎⵉⵙ ⵏ ⵚⵓⴼ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S11_2","010_1_2","1SA","1","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵉⵛⵜⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵃⴰⵏⵏⴰ ⵓ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴼⴰⵏⵉⵏⵏⴰ. ⴼⴰⵏⵉⵏⵏⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⴰⵛⴰ ⵃⴰⵏⵏⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⴱⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S11_3","010_1_3","1SA","1","3","3","ⴰⵔⵢⴰⵣ-ⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵅ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵊⴻⴷ ⵓ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵛⵉⵍⵓ. ⴷⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵍⵉ, ⵃⵓⴼⵏⵉ ⴷ ⴼⵉⵏⴰⵃⴰⵙ. ⵏⵉⵜⵏⵉ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S11_4","010_1_4","1SA","1","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⵉ ⵉⵍⵇⴰⵏⴰ ⵜⴰⵖⴰⵔⵚⵜ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵡⵛⴰ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴼⴰⵏⵉⵏⵏⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("S11_5","010_1_5","1SA","1","5","5","ⵎⴰⵛⴰ ⵉ ⵃⴰⵏⵏⴰ ⵉⵡⵛⴰ ⴰⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵃⴰⵏⵏⴰ, ⵡⴰⵅⵅⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵙ ⵍⴻⵎⵍⴰⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S11_6","010_1_6","1SA","1","6","6","ⵜⴰⵖⵔⵉⵎⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜⵙⴻⵄⵄⴰⵔ ⵉ-ⵜⵜ ⴰⵟⵟⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴼⵓⴳⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵙ ⵍⴻⵎⵍⴰⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S11_7","010_1_7","1SA","1","7","7","ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵉⵍⵇⴰⵏⴰ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵅ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵓⵛⴰ ⵎⴻⵍⵎⵉ ⵎⴰ ⵜᵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵃⴰⵏⵏⴰ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵜⵙⴻⵄⵄⴰⵔ ⵉ-ⵜⵜ ⴼⴰⵏⵉⵏⵏⴰ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵔⵓ, ⵡⴰⵔ ⵜⴻⵛⵛⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("S11_8","010_1_8","1SA","1","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵍⵇⴰⵏⴰ: “ⵃⴰⵏⵏⴰ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵔⵓⴷ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⴻⴷ ⵛⴰ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵓⵍ ⵏⵏⴻⵎ ⵉⵛⴹⴻⵏ? ⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵎ ⵛⵏⵉⵖ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S11_9","010_1_9","1SA","1","9","9","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜⴻⵛⵛⴰ ⵓ ⵜⴻⵙⵡⴰ ⴷⵉ ⵛⵉⵍⵓ, ⵜⴻⴽⴽⴰⵔ ⵃⴰⵏⵏⴰ. ⵜⵓⵖⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵄⴰⵍⵉ ⵉⵇⵇⵉⵎ ⵅ ⵍⴽⵓⵔⵙⵉ ⵖⴰⵔ ⵜⴻⴼⵍⴰⵡⵜ ⵏ ⵓⵖⴻⵣⴹⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S11_10","010_1_10","1SA","1","10","10","ⵜⵓⵖⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵃⴰⵏⵏⴰ ⵢⴰⵔⵣⴻⴳ, ⵜᵉⵥⵥⵓⴵ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵜⵔⵓ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S11_11","010_1_11","1SA","1","11","11","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ, ⵜⴻⵏⵏⴰ: “ⴰ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⵖⴰⵔ ⵍⴻⵎⵃⴰⵢⴻⵏ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵓ ⵜⵅⴰⵔⵔⵚⴻⴷ ⴷⴰⵢⵉ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⵓⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴷ ⴰⵡⵜⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵡⵛⴻⵖ ⵉ ⵙⵉⴷⵉ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵉⴷⴷⴰⵔ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵎⵓⵙ ⵡⴰⵔ ⵉⵜⵜⵃⴻⴼⴼⵉ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ.”    ");
INSERT INTO rift_vpl VALUES ("S11_12","010_1_12","1SA","1","12","12","ⵓⵎⵉ ⵜⴻⴽⴽⴰ ⴰⵟⵟⴰⵙ ⵜᵉⵜⵜⵥⴰⴵⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵄⴰⵍⵉ ⵉⵃⴹⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S11_13","010_1_13","1SA","1","13","13","ⵜⵓⵖⴰ ⵃⴰⵏⵏⴰ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ. ⵄⴰⵍⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵜⴻⵙⵛⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S11_14","010_1_14","1SA","1","14","14","ⵉⵏⵏⴰ ⴰⵙ ⵄⴰⵍⵉ: “ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴻⵙⵛⴰⵔⴻⴷ? ⴽⴽⴻⵙ ⵅⴰⵎ ⵙⵙⴻⴽⵔⴰ ⵏⵏⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("S11_15","010_1_15","1SA","1","15","15","ⵃⴰⵏⵏⴰ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵜⴻⵏⵏⴰ: “ⵍⵍⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⴱⵓⵃⴱⴻⵍ ⵉⵛⴹⴻⵏ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵡⵉⵖ ⴱⵉⵏⵓ ⵓⵍⴰ ⴷ ⵛⵛⵔⴰⴱ, ⵎⴰⵛⴰ ⴼⴰⵔⵔⵖⴻⵖ ⵓⵍ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S11_16","010_1_16","1SA","1","16","16","ⵡⴰⵔ ⵃⴻⵙⵙⴻⴱ ⵛⴰ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴷ ⵉⵛⵜ ⵏ ⵜⵢⴻⴵⵉⵜ ⵉ ⵡⴰⵔ ⵜⵙⴻⴽⴽⵯⵉ, ⵎⴰⵖⴰⵔ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ ⵙⵙⵉⵡⵍⴻⵖ ⵡⴰⵀⴰ ⵣⵉ ⵍⵀⴻⵎⵎ ⵉⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵣⵉ ⵜⵉⵇⵇⴻⵙⵜ ⵏ ⵡⵓⵍ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("S11_17","010_1_17","1SA","1","17","17","ⵄⴰⵍⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴰⵎ ⵉⵡⵛ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⴰⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("S11_18","010_1_18","1SA","1","18","18","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵉⵍⵉ ⴰⴷ ⵜⴰⴼ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴷ ⴰⵃⵉⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ!” ⵅⴻⵏⵏⵉ ⵜⵓⵢⵓⵔ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵜⴻⵛⵛⴰ ⵓ ⵜⵓⵖⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵛⴹⵉⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("S11_19","010_1_19","1SA","1","19","19","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵚⵚⴱⴻⵃ ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ, ⴱⴻⵏⴷⵇⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⴷⵉ ⵔⴰⵎⴰ. ⵜⵓⵖⴰ ⵉⵍⵇⴰⵏⴰ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵃⴰⵏⵏⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵅⴰⵔⵔⴻⵚ ⴷⴰⵢⴻⵙ, ⴷⵉ ⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S11_20","010_1_20","1SA","1","20","20","ⵓⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⴽⵙⵉ ⵃⴰⵏⵏⴰ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵜⴻⴳⴳⴰ ⴰⵙ ⵛⴰⵎⵡⵉⵍ, ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵜⴰⵔⴻⵖ ⵜ ⵣⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S11_21","010_1_21","1SA","1","21","21","ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ, ⵉⵍⵇⴰⵏⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵍⵡⴰⵄⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S11_22","010_1_22","1SA","1","22","22","ⵎⴰⵛⴰ ⵃⴰⵏⵏⴰ ⵡⴰⵔ ⴽⵉⴷⵙⴻⵏ ⵜⴳⵉⵄⵄⵉⴷ ⵛⴰ, ⵎⴰⵛⴰ ⵜⴻⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ: “ⵅⵎⵉ ⴷ ⴰⵙ ⵖⴰ ⴽⴽⵙⴻⵖ ⵓⵟⵟⵓⴹ ⵉ ⵓⵙⴻⵢⵎⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵖ ⴷⵉⵏ, ⵓⵛⴰ ⴰⴷ ⵉⴹⵀⴰⵔ ⵓⵃⴻⵏⵊⵉⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("S11_23","010_1_23","1SA","1","23","23","ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵉⵍⵇⴰⵏⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴻⴳⴳ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ. ⵇⵇⵉⵎ ⴷⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵍ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵜⴻⴽⴽⵙⴻⴷ ⵓⵟⵟⵓⴹ. ⴰⴷ ⵉⵇⴼⴻⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍ ⵏⵏⴻⵙ!” ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵎⵖⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵜⴻⵙⵙⵓⵟⵟⵓⴹ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉ ⴷ ⴰⵙ ⵜⴻⴽⴽⴻⵙ ⵓⵟⵟⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("S11_24","010_1_24","1SA","1","24","24","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⴷ ⴰⵙ ⵜⴻⴽⴽⴻⵙ ⵓⵟⵟⵓⴹ, ⵜⵉⵡⵢⵉ ⵜ ⴰⴽⵉⴷⴻⵙ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵡⴰⵔⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⴱⵉⵏⵓ. ⵏⴻⵜⵜⴰⵜ ⵜⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵛⵉⵍⵓ. ⵜⵓⵖⴰ-ⵜ ⴰⵃⴻⵏⵊⵉⵔ ⵄⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S11_25","010_1_25","1SA","1","25","25","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵉ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴰⵃⴻⵏⵊⵉⵔ ⵖⴰⵔ ⵄⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("S11_26","010_1_26","1SA","1","26","26","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S11_27","010_1_27","1SA","1","27","27","ⵏⴻⵛⵛ ⵜⵜⴰⵔⴻⵖ ⴰⵃⴻⵏⵊⵉⵔ-ⴰ ⵓ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵉ ⵜⵓⵜⵔⴰ ⵉⵏⵓ ⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S11_28","010_1_28","1SA","1","28","28","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵙⴻⵍⵍⵎⴻⵖ ⵜ ⵉ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵉⴷⴷⴰⵔ. ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⵉ ⵙⵉⴷⵉ.” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴻⵏⴷⴻⵇ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S12_1","010_2_1","1SA","2","1","1","ⵅⴻⵏⵏⵉ ⵜⴻⵥⵥⵓⴵ ⵃⴰⵏⵏⴰ, ⵜⴻⵏⵏⴰ: “ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⴻⵙⵍⵉⵡⵍⵉⵡ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⵉ ⵙⵉⴷⵉ. ⵉⵛⵛ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⵉ ⵙⵉⴷⵉ. ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵢⴰⵔⵣⴻⵎ ⴷ ⴰⵔⵣⴰⵎ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴼⴰⵔⵃⴻⵖ ⵅ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S12_2","010_2_2","1SA","2","2","2","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵃⴻⴷ ⵎⵖⵉⵔ ⵛⴻⴽ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵜⴻⵚⴹⴰⵔⵜ ⴰⵎ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("S12_3","010_2_3","1SA","2","3","3","ⵡⴰⵔ ⵜⴰⵔⴻⵏⵏⵉⵎ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ ⴰⵎⵎⵓ ⵙ ⵏⵏⴼⴰⵅⴻⵜ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴼⴼⵉⵖ ⵓⵍⴰ ⴷ ⵛⴰ ⵏ ⵜⵓⴼⴼⴻⵜ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ, ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵡⴻⵣⵏⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S12_4","010_2_4","1SA","2","4","4","ⵍⵇⴻⵡⵙ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵜⵜⵡⴰⵔⵥⴰ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵏⵇⴰⵔⴹⴻⵏ ⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵊⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S12_5","010_2_5","1SA","2","5","5","ⵉⵏⵏⵉ ⵉⵊⵊⵉⵡⵏⴻⵏ ⴰⵔⴻⵀⵏⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵡⴻⵖⵔⵓⵎ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ, ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴵⵓⵣⴻⵏ. ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵜⵉⵙⵍⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("S12_6","010_2_6","1SA","2","6","6","ⴰⵔⴻⴱⴱⵉ ⵉⵏⴻⵇⵇ ⵓ ⵉⵜⵜⵉⵛ ⵜⵓⴷⴰⵔⵜ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⵀⴻⴽⴽⵯⵡⴰ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⵓ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S12_7","010_2_7","1SA","2","7","7","ⵙⵉⴷⵉ ⵉⵜⵜⴰⵔⵔⴰ ⵉⵊⵊ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵓ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵉⵙⵙⵀⴻⴽⴽⵡⴰ ⴷ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("S12_8","010_2_8","1SA","2","8","8","ⴰⵎⵓⵇⵍⵉⵍ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵉ-ⵜ ⵣⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⵍⵎⴻⵙⴽⵉⵏ ⵉⵊⴻⴱⴷ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴼⵔⴰⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵖⵉⵎ ⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⵄⴻⵣⵣ ⴷ ⵍⵡⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴵⴰⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵅⴰⵙⴻⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("S12_9","010_2_9","1SA","2","9","9","ⵏⴻⵜⵜⴰ ⵉ ⵉⵙⵙⵍⴻⵇⵇⴰⵏ ⵅ ⵉⵚⵓⵔⴰⴼ ⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴻⴽⵎⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵛⴰ ⴷ ⴱⵓ ⵜⴻⵖⵔⵓⴹⵜ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S12_10","010_2_10","1SA","2","10","10","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ. ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵙⵙⵀⴻⵎⵀⴻⵎ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵉⵡⵛ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵛⵛ ⵏ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S12_11","010_2_11","1SA","2","11","11","ⵉⵄⵇⴻⴱ ⵉⵍⵇⴰⵏⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵔⴰⵎⴰ, ⵎⴰⵛⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵄⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("S12_12","010_2_12","1SA","2","12","12","ⵎⴰⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵄⴰⵍⵉ ⵜⵓⵖⴰ ⴷ ⵜⴰⵔⵡⴰ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S12_13","010_2_13","1SA","2","13","13","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵓⵎⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⴰⵎⵎⵓ: ⵎⴰⵍⴰ ⵢⵉⵡⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ, ⵅⴻⵏⵏⵉ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵙⵓⵎ ⵄⴰⴷ ⵉⵜⵜⵏⴻⵏⵏⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⴼⵓⵔⵛⵉⵜⴰ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵛⵓⴽⴹⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("S12_14","010_2_14","1SA","2","14","14","ⵉⵊⵊⵓ ⵜⵜ ⴷⵉ ⵍⴱⵓⵔⵎⴻⵜ ⵏⵉⵖ ⴷⴻⴳ ⵓⵟⴻⵏⵊⵉⵔ ⵏⵉⵖ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰ ⵏⵉⵖ ⴷⵉ ⵜⴻⵢⴷⵓⵔⵜ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⴽⵙⵉ ⴼⵓⵔⵛⵉⵜⴰ, ⵉⴽⵙⵉ ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵜ ⴳⴳⵉⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵛⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("S12_15","010_2_15","1SA","2","15","15","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ, ⵇⴱⴻⵍ ⵖⴰ ⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⴰⴷⵓⵏⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ: “ⴻⵡⵛ ⴰⵢⵉ ⴰⵢⵙⵓⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵇⵍⵉⵖ ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⴽ ⵉⴽⵙⵉ ⵛⴰ ⴰⵢⵙⵓⵎ ⵉⵜⵜⵡⴰⵏⴻⵏⵏⴰⵏ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⴰⵣⵉⵣⴰ.” ");
INSERT INTO rift_vpl VALUES ("S12_16","010_2_16","1SA","2","16","16","ⵎⴰⵍⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵡⴻⵔⵢⴰⵣ: “ⴰⵎⴻⵣⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⴰⴷⵓⵏⵜ ⵎⴰⵔⵔⴰ, ⵅⴻⵏⵏⵉ ⴽⵙⵉ ⵎⵉⵏ ⵉⵅⵙ ⵡⵓⵍ ⵏⵏⴻⵛ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ!”, ⵉⵏⵏⴰ ⴰⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⴽⴻⵀⵀⴰⵏ: “ⵍⵍⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⵡⵛⴻⴷ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⵍⵍⴰ, ⴰⴷ ⵜ ⴽⵙⵉⵖ ⵙ ⵓⵖⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("S12_17","010_2_17","1SA","2","17","17","ⴷⴷⴻⵏⴱ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S12_18","010_2_18","1SA","2","18","18","ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵏ ⵍⴻⵇⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S12_19","010_2_19","1SA","2","19","19","ⵢⴻⵎⵎⴰⵙ ⵜⴻⴳⴳⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵓⵛⴰ ⵜᵉⵜⵜⴰⵡⵢⵉ ⴰⵙ ⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵅⵎⵉ ⵜᵉⵜⵜⴳⴻⵄⵄⴻⴷ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵡⵉ ⴷⵉⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S12_20","010_2_20","1SA","2","20","20","ⵉⴳⴳⴰ ⵄⴰⵍⵉ ⵍⴱⴰⵔⴰⴽⴰ ⴷⵉ ⵉⵍⵇⴰⵏⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵉⵍⵉ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵉ ⵜⵙⴻⵍⵍⴻⵎ ⵏⴻⵜⵜⴰⵜ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉ ⵙⵉⴷⵉ.” ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S12_21","010_2_21","1SA","2","21","21","ⵙⵉⴷⵉ ⵎⴰⵛⴰ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵃⴰⵏⵏⴰ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⴰⵔ ⵛⴰⵎⵡⵉⵍ ⴰⵎⴻⵥⵢⴰⵏ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S12_22","010_2_22","1SA","2","22","22","ⵉⴷⵡⴻⵍ ⵄⴰⵍⵉ ⵉⵡⵙⴰⵔ ⴰⵟⵟⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⵍⴰ ⵄⴰⵡⴻⴷ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵟⵟⵚⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S12_23","010_2_23","1SA","2","23","23","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵢⴰ ⴰⵎⵎⵓ, ⴰⵍⴰⵎⵉ ⵉ ⵜⵜⴻⵙⵍⵉⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("S12_24","010_2_24","1SA","2","24","24","ⵍⵍⴰ, ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵉⵃⵍⴰ ⵉ ⵙⵍⵉⵖ. ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⵔⵔⴰⵎ ⵍⴳⴻⵏⵙ-ⴰ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵅⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("S12_25","010_2_25","1SA","2","25","25","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵅⴹⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵉⵃⴽⴻⵎ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵅⴹⴰ ⵅ ⵙⵉⴷⵉ, ⵡⵉ ⵅⴰⵙ ⵖⴰ ⵉⵡⵜⴻⵏ?” ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S12_26","010_2_26","1SA","2","26","26","ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⴰⵎⴻⵥⵢⴰⵏ ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⴰⵔ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ ⵓⵍⴰ ⵖⴰⵔ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S12_27","010_2_27","1SA","2","27","27","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵄⴰⵍⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰ ⵡⴰⵔ ⵉ ⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵏⵉⵛⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⵓⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷⵉ ⵎⵉⵚⵔⴰ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ? ");
INSERT INTO rift_vpl VALUES ("S12_28","010_2_28","1SA","2","28","28","ⵏⴻⵛⵛ ⴼⴰⵔⵣⴻⵖ ⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵏⴻⵛⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴰⵔⵖ ⵍⴻⴱⵅⵓⵔ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴹ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵄⴰⵡⴻⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S12_29","010_2_29","1SA","2","29","29","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵄⴻⴼⴼⵙⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵜⵖⴰⵔⵚⵜ ⵉⵏⵓ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵣⵉ ⵓⵎⵓⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵜⵡⴻⵀⵀⴱⴻⵎ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵏⵓ, ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⵟⵟⴰⵙ ⵅⴰⴼⵉ ⵓⵎⵉ ⵜⵎⴻⵙⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵎⵓⵎⵎⵓ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ?’ ");
INSERT INTO rift_vpl VALUES ("S12_30","010_2_30","1SA","2","30","30","ⵙ ⵓⵢⴰ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵏⵉⵛⴰⵏ: ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ!’, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵢⴰ ⴰⵇⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵡⴻⵇⵇⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ, ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S12_31","010_2_31","1SA","2","31","31","ⵅⵣⴰⵔ ⴰⴷ ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⴰⵖⵉⵍ ⵏⵏⴻⵛ ⴷ ⵓⵖⵉⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S12_32","010_2_32","1SA","2","32","32","ⵛⴻⴽ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⴱⴻⵍⵍⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵉⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵜⵛⵓⵏⵉ-ⵢⴰ ⵎⴰⵔⵔⴰ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵢⵉⵍⵉ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵓⵡⴻⵙⵙⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S12_33","010_2_33","1SA","2","33","33","ⵡⴰⵔ ⵇⴻⵟⵟⵄⴻⵖ ⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉ ɣⴰⵔⴻⴽ ⵉⴵⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵓⵃⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵇⴰⵄ, ⴰⴷ ⵜⴻⴼⵏⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵎⵎⵜⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S12_34","010_2_34","1SA","2","34","34","ⴷ ⵜⴰ ⵉ ⴷ ⴰⴽ ⵖⴰ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⵃⵓⴼⵏⵉ ⴷ ⴼⵉⵏⴰⵃⴰⵙ: ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("S12_35","010_2_35","1SA","2","35","35","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵉ ⵉⵅⴻⴼ ⵉⵏⵓ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵓⵍ ⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵎⵜⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵓⵢⵓⵔ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S12_36","010_2_36","1SA","2","36","36","ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴷ ⴰⵙ ⵉⴱⴻⵏⴷⴻⵇ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵛⵏⵉⴼⵜ ⵏ ⵡⴻⵖⵔⵓⵎ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵔⵏⵉ ⴰⵢⵉ ⵎⵖⵉⵔ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉ ⵎⴰⵛⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("S13_1","010_3_1","1SA","3","1","1","ⵛⴰⵎⵡⵉⵍ ⴰⵎⴻⵥⵢⴰⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵉ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵄⴰⵍⵉ. ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵇⵇⵉⴵⴻⵜ. ⵡⴰⵔ ⵜⵓⵖⵉ ⵜᵉⵜⵜⴻⴼⴼⵉⵖ ⵛⴰ ⵏ ⵍⴻⵡⵃⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("S13_2","010_3_2","1SA","3","2","2","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵓⵎⵉ ⵄⴰⵍⵉ ⵉⵟⵟⴻⵚ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵔⵅⵓⵏⵜ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵍⴰ ⵄⴰⴷ, ⵉⵎⵙⴰⵔ - ");
INSERT INTO rift_vpl VALUES ("S13_3","010_3_3","1SA","3","3","3","ⵄⴰⴷ ⵇⴱⴻⵍ ⵉⵅⵙⵉ ⵍⴻⴼⵏⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⵉⵟⵟⴻⵚ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵙⵉⴷⵉ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ - ");
INSERT INTO rift_vpl VALUES ("S13_4","010_3_4","1SA","3","4","4","ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ ⵉ ⵛⴰⵎⵡⵉⵍ. ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵛⴰⵎⵡⵉⵍ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("S13_5","010_3_5","1SA","3","5","5","ⵏⴻⵜⵜⴰ ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔ ⵄⴰⵍⵉ, ⵉⵏⵏⴰ: “ⴷⴰⵏⵉⵜⴰ ⵉ ⴵⵉⵖ, ⵛⴻⴽ ⵜⵍⴰⵖⵉⴷ ⴰⵢⵉ-ⴷⴷ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⴽ ⴷⴷ-ⵍⴰⵖⵉⵖ ⵛⴰ, ⵄⵇⴻⴱ, ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ!” ⵓⵛⴰ ⵉⵄⵇⴻⴱ, ⵉⵣⵣⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S13_6","010_3_6","1SA","3","6","6","ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ ⵉ ⵛⴰⵎⵡⵉⵍ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵓⵛⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵛⴰⵎⵡⵉⵍ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵄⴰⵍⵉ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵍⴰⵖⵉⴷ ⴰⵢⵉ-ⴷⴷ.” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵏⴻⵜⵜⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⴽ ⴷⴷ-ⵍⴰⵖⵉⵖ ⵛⴰ, ⵎⵎⵉ, ⵄⵇⴻⴱ, ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("S13_7","010_3_7","1SA","3","7","7","ⵛⴰⵎⵡⵉⵍ ⵄⴰⴷ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵙⵉⴷⵉ ⵓ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("S13_8","010_3_8","1SA","3","8","8","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵅ ⵛⴰⵎⵡⵉⵍ ⵄⴰⵡⴻⴷ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵄⴰⵍⵉ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⵛⴻⴽ ⵜⵍⴰⵖⵉⴷ ⴰⵢⵉ-ⴷⴷ.” ⵅⴰⵙ ⵓⵛⴰ ⵉⵃⴻⴽⴽⴰⵔ ⵄⴰⵍⵉ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵍⴰⵖⴰ ⵅ ⵓⵃⴻⵏⵊⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("S13_9","010_3_9","1SA","3","9","9","ⵓⵛⴰ ⵄⴰⵍⵉ ⵉⵏⵏⴰ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵔⵓⵃ, ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ! ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⴰⵛ-ⴷⴷ ⵄⴰⵡⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⵔⵔ ⵅⴰⵙ: ‘ⵙⵉⵡⴻⵍ, ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵜⵜⴻⵙⵍⴰ!’” ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵛⴰⵎⵡⵉⵍ, ⵉⵣⵣⴻⵍ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S13_10","010_3_10","1SA","3","10","10","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵎ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵏⵏⴻⵖⵏⵉ: “ⵛⴰⵎⵡⵉⵍ, ⵛⴰⵎⵡⵉⵍ!” ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⵙⵉⵡⴻⵍ, ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵜⵜⴻⵙⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("S13_11","010_3_11","1SA","3","11","11","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵛⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵟⵏⴻⵟⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S13_12","010_3_12","1SA","3","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵇⴻⴼⵍⴻⵖ ⵎⴰⵔⵔⴰ ⵉ ⵄⴰⵍⵉ, ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵎⵉⵏ ⵣⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S13_13","010_3_13","1SA","3","13","13","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵄⴻⵍⵎⴻⵖ ⴰⵙ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵃⴻⴽⵎⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵍⴰⵎⵉ ⵙⵙⵉⵡⴹⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵏⵏⴻⵄⵍⴻⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⵟⵟⵉⴼ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S13_14","010_3_14","1SA","3","14","14","ⵙ ⵓⵢⴰ ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⴰⵍⵉ: ‘ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴻⵚⵍⴰⵃ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⴰⵍⵉ ⵙ ⵜⵖⴰⵔⵚⵜ ⵓⵍⴰ ⵙ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ!’” ");
INSERT INTO rift_vpl VALUES ("S13_15","010_3_15","1SA","3","15","15","ⵛⴰⵎⵡⵉⵍ ⵉⵇⵇⵉⵎ ⵉⵣⵣⴻⵍ ⴰⵍ ⵚⵚⴱⴻⵃ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⴳⴳⵯⴻⴷ ⴰⴷ ⵉⵃⴰⵊⴰ ⵍⴻⵡⵃⵉⵢ ⵉ ⵄⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("S13_16","010_3_16","1SA","3","16","16","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵄⴰⵍⵉ ⵅ ⵛⴰⵎⵡⵉⵍ, ⵉⵏⵏⴰ: “ⵛⴰⵎⵡⵉⵍ, ⵎⵎⵉ!” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("S13_17","010_3_17","1SA","3","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵎⴰⵏ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵛ ⵉⵏⵏⴰ? ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵙⵏⵓⴼⴼⴰⵔ! ⴻⵊⵊ ⴰⴷ ⴰⵛ ⵉⴳⴳ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵎⵓ, ⵄⴰⴷ ⵎⴰⵀⵓ, ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵅⴰⴼⵉ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵡⴰⵀⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("S13_18","010_3_18","1SA","3","18","18","ⵅⴻⵏⵏⵉ ⵉⵃⴰⵊⴰ ⴰⵙ ⵛⴰⵎⵡⵉⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜⴻⵏ ⵉⴼⴼⴰⵔ. ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵄⴰⵍⵉ: “ⴰⵇⴰ-ⵜ ⴷ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("S13_19","010_3_19","1SA","3","19","19","ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⴰⵔ ⵓ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ ⵓ ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S13_20","010_3_20","1SA","3","20","20","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⴰ ⴰⵇⴰ ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⴻⵎ ⴷ ⴰⵏⴰⴱⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S13_21","010_3_21","1SA","3","21","21","ⵙⵉⴷⵉ ⵉⵇⵇⵉⵎ ⴰⴷ ⴷⴷ-ⵉⴹⵀⴰⵔ ⴷⵉ ⵛⵉⵍⵓ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵛⴰⵎⵡⵉⵍ ⴷⵉ ⵛⵉⵍⵓ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S14_1","010_4_1","1SA","4","1","1","ⴰⵡⴰⵍ ⵏ ⵛⴰⵎⵡⵉⵍ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⴱⵉⵏ-ⵀⴰⵄⵉⵣⵉⵔ, ⵓⵛⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⴼⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("S14_2","010_4_2","1SA","4","2","2","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵓⵎⵉ ⵉⵎⴻⵢⵢⴻⵍ ⵓⵎⴻⵏⵖⵉ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⵉⵜⵜⵡⴰⵖⴻⵍⵍⴻⴱ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵄⵍⴰⵃⴰⵍ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵍⴻⵚⴼⵓⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S14_3","010_4_3","1SA","4","3","3","ⵓⵎⵉ ⵉⵄⵇⴻⴱ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵏⵏⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵜⴰ ⵙⵉⴷⵉ ⴰⵙⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ? ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴽⵙⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵛⵉⵍⵓ, ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S14_4","010_4_4","1SA","4","4","4","ⵍⴳⴻⵏⵙ ⵉⵙⵙⴻⴽⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵛⵉⵍⵓ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵅ ⵉⴽⵉⵔⵓⴱⴻⵏ. ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵍⵉ, ⵃⵓⴼⵏⵉ ⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⴰⴽ-ⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ.    ");
INSERT INTO rift_vpl VALUES ("S14_5","010_4_5","1SA","4","5","5","ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵍⵉⵡⵍⴻⵡ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⴰⵔⵊⵉⵊⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S14_6","010_4_6","1SA","4","6","6","ⵓⵎⵉ ⵙⵍⴰⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵏⵏⴰⵏ: “ⵎⴰⵏⴰ ⵍⵃⴻⵙⵙ-ⴰ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉⵊⴻⵀⴷⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ?” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴼⴻⵀⵎⴻⵏ, ⴰⵇⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵜⵓⵙⴰ-ⴷⴷ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S14_7","010_4_7","1SA","4","7","7","ⴳⴳⵯⴻⴷⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵔⴻⴱⴱⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ!” ⵓⵛⴰ ⵏⵏⴰⵏ: “ⴰⵢⵢⴰⵡ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵢⴰ ⴰⵎⵎⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵎⵙⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("S14_8","010_4_8","1SA","4","8","8","ⵓⵛⵜ ⵅⴰⵏⴻⵖ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ? ⵉⵏⴰ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉ ⵉⵡⵜⵉⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⵔⴰⵢⴻⵃ ⴷⵉ ⵍⴻⵅⵍⴰ! ");
INSERT INTO rift_vpl VALUES ("S14_9","010_4_9","1SA","4","9","9","ⵉⵍⵉⵎ ⵜⵎⴻⵃⴹⴻⵎ ⵓ ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵡⴻⵎ ⵙⴻⵅⵅⴰⵔⴻⵏ. ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⵎⴻⵏⵖⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("S14_10","010_4_10","1SA","4","10","10","ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵓ ⵉⵜⵜⵡⴰⵖⵍⴻⴱ ⵉⵙⵔⴰⵉⵍ. ⴰⵔⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵅⴻⵙⵙⴰⵔⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ, ⴰⵍⴰⵎⵉ ⵡⴹⴰⵏ ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵅ ⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S14_11","010_4_11","1SA","4","11","11","ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜᵉⵜⵜⵡⴰⵃⴻⵡⵡⴻⵙ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵍⵉ, ⵃⵓⴼⵏⵉ ⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S14_12","010_4_12","1SA","4","12","12","ⵅⴻⵏⵏⵉ ⵢⵓⵣⵣⴻⵍ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵛⵉⵍⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵛⴰⵔⵔⴻⴳ ⵓⵛⴰ ⴰⵛⴰⵍ ⵜⵓⵖⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S14_13","010_4_13","1SA","4","13","13","ⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ, ⵉⵇⵇⵉⵎ ⵄⴰⵍⵉ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵉⵇⵛⴻⵄ, ⵎⵉⵏⵣⵉ ⵓⵍ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵃⴰⵊⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⴻⵙⵖⵓⵢ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S14_14","010_4_14","1SA","4","14","14","ⵓⵎⵉ ⵉⵙⵍⴰ ⵄⴰⵍⵉ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵖⵓⵢⵢⵉ, ⵉⵏⵏⴰ: “ⵎⴰⵏⴰ ⵍⵃⴻⵙⵙ ⵏ ⵍⵀⴰⵔⴰⵊ-ⴰ ⵏ ⵍⵖⴰⵛⵉ ⵏⵏⵉ?” ⵅⴻⵏⵏⵉ ⵉⵇⴻⴵⴻⵇ ⵡⴻⵔⵢⴰⵣ, ⵢⵓⵙⴰ-ⴷⴷ, ⵉⵃⴰⵊⴰ ⵜ ⵉ ⵄⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("S14_15","010_4_15","1SA","4","15","15","ⵜⵓⵖⴰ ⵖⴰⵔ ⵄⴰⵍⵉ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏⵜ ⴰⵔⵅⵓⵏⵜ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("S14_16","010_4_16","1SA","4","16","16","ⴰⵔⵢⴰⵣ ⵉⵏⵏⴰ ⵉ ⵄⴰⵍⵉ: “ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ. ⴰⵙⵙ-ⴰ ⴰⵔⴻⵡⵍⴻⵖ ⵣⵉ ⵍⴻⵚⴼⵓⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ⵉⵏⵏⴰ ⴰⵙ ⵄⴰⵍⵉ: “ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⴰ ⵎⵎⵉ?” ");
INSERT INTO rift_vpl VALUES ("S14_17","010_4_17","1SA","4","17","17","ⴰⵔⴻⵇⵇⴰⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⵡⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵍⴳⴻⵏⵙ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵜⴻⵡⵄⴰⵔ ⴰⵟⵟⴰⵙ. ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⵃⵓⴼⵏⵉ ⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⵜⵜⵡⴰⵏⵖⴻⵏ ⵓ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜᵉⵜⵜⵡⴰⵃⴻⵡⵡⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S14_18","010_4_18","1SA","4","18","18","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵢⵉⴷⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵄⴰⵍⵉ ⵉⵡⴹⴰ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵣⵉ ⵍⴽⵓⵔⵙⵉ ⵣⵣⴰⵜ ⵉ ⵜⴻⵡⵡⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴻⵥ ⵣⴻⴳ ⵢⵉⵔⵉ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴰⵙ ⴱⵓⵃⴱⴻⵍ, ⵎⴰⵖⴰⵔ ⴰⵔⵢⴰⵣ ⵜⵓⵖⴰ ⵉⵡⵙⴰⵔ ⵓ ⵉⴷⵇⴻⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("S14_19","010_4_19","1SA","4","19","19","ⵜⴰⵙⵍⵉⵜ ⵏⵏⴻⵙ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵙ ⴼⵉⵏⴰⵃⴰⵙ, ⵜⵓⵖⴰ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵖⴰ ⵄⵍⴰⵢⴻⵏ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ. ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵍⴰ ⴰⵇⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜᵉⵜⵜⵡⴰⵃⴻⵡⵡⴻⵙ, ⵓ ⵄⴻⵎⵎⵉⵙ ⵉⵎⵎⵓⵜ ⵓⵍⴰ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵜⴻⴽⵎⵓⵎⵎⴻⵛ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵍⴻⵡⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S14_20","010_4_20","1SA","4","20","20","ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵏⵏⴰⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴱⴻⴷⴷⴻⵏ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵛⴻⵎ ⵜⵓⵔⵡⴻⴷ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⴷⴷ-ⵜⴰⵔⵔⵉ ⵛⴰ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵃⴻⴽⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S14_21","010_4_21","1SA","4","21","21","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⴰⵙ ⵉ ⵓⵃⴻⵏⵊⵉⵔ ‘ⵉⴽⴰⴱⵓⴷ’, ⵜⴻⵏⵏⴰ: “ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵓⵄⵓⴵⵉ ⵣⵉ ⵉⵙⵔⴰⵉⵍ!”, ⵎⵉⵏⵣⵉ ⵜᵉⵎⵎⴻⴽⵙⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵓⵍⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴻⵡⵜ ⵏ ⵄⴻⵎⵎⵉⵙ ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S14_22","010_4_22","1SA","4","22","22","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵓⵄⵓⴵⵉ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵜᵉⵎⵎⴻⴽⵙⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("S15_1","010_5_1","1SA","5","1","1","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴽⵙⵉⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⵜ ⵣⵉ ⴰⴱⵉⵏ-ⵀⴰⵄⵉⵣⵉⵔ ⵖⴰⵔ ⴰⵛⴷⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S15_2","010_5_2","1SA","5","2","2","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵙⵙⵉⵡⴹⴻⵏ ⵜⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵊⵓⵏ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴷⴰⵊⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S15_3","010_5_3","1SA","5","3","3","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵓⵎⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴰⵛⴷⵓⴷ ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ, ⵅⵣⴰⵔ, ⴷⴰⵊⵓⵏ ⵜⵓⵖⴰ ⵉⵡⴹⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⴷⴰⵊⵓⵏ, ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S15_4","010_5_4","1SA","5","4","4","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵓⵎⵉ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉⵛ ⵄⴰⵡⴻⴷ, ⵅⵣⴰⵔ, ⴷⴰⵊⵓⵏ ⵜⵓⵖⴰ ⵉⵡⴹⴰ ⵄⴰⵡⴻⴷ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴰⵣⴻⴵⵉⴼ ⵏ ⴷⴰⵊⵓⵏ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵙ ⵜⵏⴰⵢⴻⵏ ⵎⵎⴰⵔⵙⴻⵏ ⵇⴻⵙⵙⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴱⴷⴰⵜ. ⵎⵖⵉⵔ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴷⴰⵊⵓⵏ ⵜⵓⵖⴰ ⵜⴻⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S15_5","010_5_5","1SA","5","5","5","ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵄⴼⵉⵙⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⴷⴰⵊⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵊⵓⵏ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⴷⴰⵊⵓⵏ ⴷⵉ ⴰⵛⴷⵓⴷ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S15_6","010_5_6","1SA","5","6","6","ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⴷⵇⴻⵍ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴰⵛⴷⵓⴷ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵄⴻⴱ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵡⵜⴰ ⵜⴻⵏ ⵙ ⵜⵃⴻⴱⴱⴰ, ⴷⵉ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵛⴷⵓⴷ ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S15_7","010_5_7","1SA","5","7","7","ⵓⵎⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴰⵛⴷⵓⴷ ⵥⵔⵉⵏ, ⴰⵇⴰ ⴰⵎⵎⵓ ⵉ ⵉⵎⵙⴰⵔ, ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ: “ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⴻⵇⵇⵉⵎ, ⵎⴰⵖⴰⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⵅⴰⵏⴻⵖ ⴷⴷⵇⴻⵍ ⵓⵍⴰ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷⴰⵊⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("S15_8","010_5_8","1SA","5","8","8","ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⵙ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ?” ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ: “ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⵓⵟⵟⵉⵢ ⵖⴰⵔ ⵊⴰⵜ.” ⵅⴻⵏⵏⵉ ⵙⵙⵎⵓⵟⵟⵉⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S15_9","010_5_9","1SA","5","9","9","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵜⵜ ⵙⵙⵎⵓⵟⵟⵉⵢⴻⵏ, ⵉⵙⵙⵉⵡⴻⴹ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵓⵛⴰ ⵉⵡⵜⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵙ ⵜⵃⴻⴱⴱⴰ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S15_10","010_5_10","1SA","5","10","10","ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵄⴰⵇⵔⵓⵏ. ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵄⴰⵇⵔⵓⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵄⴰⵇⵔⵓⵏ ⵙⵖⵓⵢⴻⵏ, ⵏⵏⴰⵏ: “ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔⵏⴻⵖ ⴷⴰⵏⵉⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵏⵖⴻⵏ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S15_11","010_5_11","1SA","5","11","11","ⵙⵙⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ: “ⵙⵉⴳⴳⵯⴻⵊⴻⵎ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵊⵊⴻⵎ ⵜⵜ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵏⴻⵇⵇ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ!”, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵇⴻⵣⵣⴻⴱ ⵉⵎⵖⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴰⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⵇⴻⵍ ⴰⵟⵟⴰⵙ ⵅ ⵄⴰⵇⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S15_12","010_5_12","1SA","5","12","12","ⵉⵡⴷⴰⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵎⵎⵓⵜⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⵡⴰⵡⵜⴻⵏ ⵙ ⵜⵃⴻⴱⴱⴰ, ⴰⵍⴰⵎⵉ ⴰⵖⵓⵢⵢⵉ ⵏ ⵓⵙⵖⴰⵜⵉ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("S16_1","010_6_1","1SA","6","1","1","ⵓⵎⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵜⴻⴽⴽⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("S16_2","010_6_2","1SA","6","2","2","ⵍⴰⵖⴰⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵅ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⴰⴽ-ⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ? ⵙⴻⵛⵏⴻⵎ ⴰⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵉ ⵖⴰ ⵏⴻⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S16_3","010_6_3","1SA","6","3","3","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⵜⴻⵅⵡⴰ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵅⴻⴵⵚⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵡⴻⵄⴷⴰⵍ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⴻⵏⴼⴰⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⵎⴰⵢⴻⵎⵎⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⴻⴽⴽⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S16_4","010_6_4","1SA","6","4","4","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ: “ⵎⴰⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵏⵇⴻⴷⴷⴻⵎ ⵉ ⵡⴻⵄⴷⴰⵍ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵅⴻⵎⵙⴰ ⵏ ⵜⵃⴻⴱⴱⴰ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⵔⴷⴰⵢⴻⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵅ ⵇⴻⴷⴷⴰ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵜⴻⵍⵇⴻⴼ ⴽⴻⵏⵏⵉⵡ ⵊⵊⵔⵉⵃⴻⵛⵜ ⴷ ⵉⵛⵜⴻⵏ ⵓⵍⴰ ⴷ ⵍⴱⴰⵛⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S16_5","010_6_5","1SA","6","5","5","ⴳⴳⴻⵎ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵜⵃⴻⴱⴱⴰ ⵏⵡⴻⵎ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵖⴰⵔⴷⴰⵢⴻⵏ ⵏⵡⴻⵎ ⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵙⵄⵓⴵⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⵙⵙⴻⴼⵙⴻⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅⴰⵡⴻⵎ, ⵅ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵡⴻⵎ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S16_6","010_6_6","1SA","6","6","6","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵙⵙⵇⴻⵙⵃⴻⵎ ⵓⵍ ⵏⵡⴻⵎ ⴰⵎ ⵙⵙⵇⴻⵙⵃⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⴼⵉⵔⵄⵓⵏ ⵓⵍ ⵏⵙⴻⵏ? ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⵉⵣⴻⵢⵢⴰⵔ ⵏⴻⵜⵜⴰ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵔⵅⵓⵏ ⵉ ⴰⵢⵜ ⵉⵙⵔⴰⵉⵍ ⵓ ⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵛⴰ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("S16_7","010_6_7","1SA","6","7","7","ⵅⴻⵏⵏⵉ  ⵍⴻⵅⵅⵓ, ⴽⵙⵉⵎ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵏ ⵊⴷⵉⴷ, ⵙⵡⴻⵊⴷⴻⵎ ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵙⵙⵓⵟⵟⵓⴹⴻⵏⵜ, ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⵉⵎⵎⴰⵔⵙ ⵄⴰⴷ ⵓⵣⴰⵢⵍⵓ, ⵓ ⵇⵇⵏⴻⵎ ⵜⵉⴼⵓⵏⴰⵙⵉⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵓⴽⴰⵔⵔⵓ ⵓ ⴽⴽⵙⴻⵎ ⴰⵙⴻⵏⵜ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏⵙⴻⵏⵜ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏⵜ ⵓ ⴰⵡⵢⴻⵎ ⵜⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S16_8","010_6_8","1SA","6","8","8","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵎ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵙⴰⵔⵙⴻⵎ ⵜⵜ ⵅ ⵓⴽⴰⵔⵔⵓ ⵓ ⵙⴰⵔⵙⴻⵎ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴻⵏⴷⵓⵇⵜ, ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵙ ⵜⵅⴻⴵⵚⴻⵎ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵡⴻⵄⴷⴰⵍ. ⵙⴻⴽⴽⴻⵎ ⵜⵜ, ⴰⴷ ⵜⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("S16_9","010_6_9","1SA","6","9","9","ⵃⴹⴰⵎ, ⵎⴰⵍⴰ ⴰⴽⴰⵔⵔⵓ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏⵏⴻⵙ, ⵖⴰⵔ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ, ⵅⴻⵏⵏⵉ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵜⵉⵏ ⵙ ⵜⴻⵛⵜⵉ-ⵢⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵍⴰ ⵍⵍⴰ, ⵅⴻⵏⵏⵉ ⵏⴻⵙⵙⴻⵏ ⵏⴻⵛⵛⵉⵏ, ⴰⵇⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵍⴻⵇⴼⴻⵏ: ⴰⵇⴰ ⵜⵓⵙⴰ-ⴷⴷ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("S16_10","010_6_10","1SA","6","10","10","ⵉⵔⵢⴰⵣⴻⵏ ⴳⴳⵉⵏ ⵜⵜ ⴰⵎⵎⵓ. ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵙⵙⵓⵟⵟⵓⴹⴻⵏⵜ, ⵇⵇⵏⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵓⴽⴰⵔⵔⵓ ⵓⵛⴰ ⵇⵇⵏⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏⵜ ⴷⴻⴳ ⵓⵢⴻⵏⵏⵉⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S16_11","010_6_11","1SA","6","11","11","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⵓⴽⴰⵔⵔⵓ, ⵓⵍⴰ ⴷ ⵜⴰⵙⴻⵏⴷⵓⵇⵜ ⴰⴽ-ⴷ ⵉⵖⴰⵔⴷⴰⵢⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵜⵃⴻⴱⴱⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S16_12","010_6_12","1SA","6","12","12","ⵜⵉⴼⵓⵏⴰⵙⵉⵏ ⵓⵢⵓⵔⴻⵏⵜ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵊⵊⵉⵀⴻⵜ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ, ⵓⵢⵓⵔⴻⵏⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ ⵏⵏⵉ. ⵏⵉⵜⴻⵏⵜⵉ ⵇⵇⵉⵎⴻⵏⵜ ⴳⴳⵓⵔⴻⵏⵜ, ⴰⵎ ⵙⵙⵎⵓⵀⵔⵓⵜⴻⵏⵜ, ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵏⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵔⴻⴷⴷⴼⴻⵏ ⵜⴻⵏⵜ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ. ");
INSERT INTO rift_vpl VALUES ("S16_13","010_6_13","1SA","6","13","13","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵜⵓⵖⴰ ⵎⴻⵊⵊⴰⵔⴻⵏ ⵚⵚⴰⴱⴻⵜ ⵏ ⵉⵔⴷⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ⵓⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵙⴻⵏ, ⵥⵔⵉⵏ ⵜⵜⴰⴱⵓⵜ ⵓ ⴼⴰⵔⵃⴻⵏ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵜⵜ ⵥⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S16_14","010_6_14","1SA","6","14","14","ⴰⴽⴰⵔⵔⵓ ⵜⵓⵖⴰ ⵢⵉⵡⴻⴹ ⴰⵍ ⵉⵢⵢⴰⵔ ⵏ ⵢⴰⵛⵓⵡⴰ, ⵡⴻⵏⵏⵉ ⵣⵉ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ, ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵓⴽⴰⵔⵔⵓ ⴷⵉⵏⵏⵉ. ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵏⵉⵜⵏⵉ ⵣⴻⴷⵎⴻⵏ ⵜⵉⴼⴻⵍⵡⵉⵏ ⵏ ⵓⴽⴰⵔⵔⵓ ⵓ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵉⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S16_15","010_6_15","1SA","6","15","15","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴽⵙⵉⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵙⴻⵏⴷⵓⵇⵜ ⵉⵎⵎⴰⵔⵙⴻⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ, ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ, ⵓ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵢⴰ ⵅ ⵡⴻⵥⵔⵓ ⵏⵏⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ ⵓ ⵇⴻⴷⴷⵎⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("S16_16","010_6_16","1SA","6","16","16","ⵓⵎⵉ ⵥⵔⵉⵏ ⵅⴻⵎⵙⴰ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵄⴰⵇⵔⵓⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S16_17","010_6_17","1SA","6","17","17","ⵜⵉⵏⴰ ⴷ ⵜⵉⵃⴻⴱⴱⴰ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⵅⴻⴵⵚⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵡⴻⵄⴷⴰⵍ ⵉ ⵙⵉⴷⵉ: ⵉⵛⵜ ⵉ ⴰⵛⴷⵓⴷ, ⵉⵛⵜ ⵉ ⵖⴰⵣⴰ, ⵉⵛⵜ ⵉ ⴰⵛⵇⵉⵍⵓⵏ, ⵉⵛⵜ ⵉ ⵊⴰⵜ, ⵉⵛⵜ ⵉ ⵄⴰⴽⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S16_18","010_6_18","1SA","6","18","18","ⵓⵍⴰ ⴷ ⵉⵖⴰⵔⴷⴰⵢⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵇⴻⴷⴷⴰ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵉⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⵉ ⵅⴻⵎⵙⴰ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ, ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴰⵍ ⴷⵛⵓⵔⴰⵜ ⵉ ⴷ ⴰⵙⴻⵏⵜ ⵉ-ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⵢⵉⵡⴻⴹ ⵓⴽⴰⵔⵔⵓ ⴰⵍ ⴰⴱⵉⵍ, ⴰⵥⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵥⵔⵓ ⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍ ⴰⵙⵙ-ⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵢⴰⵛⵓⵡⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ. ");
INSERT INTO rift_vpl VALUES ("S16_19","010_6_19","1SA","6","19","19","ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵉⵡⵜⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵅⵣⴰⵔⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵡⵜⴰ ⵏⴻⵜⵜⴰ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵓⵛⴰ ⵉⵛⴹⴻⵏ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ ⵍⴳⴻⵏⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S16_20","010_6_20","1SA","6","20","20","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ: “ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵡⴰ? ⴷ ⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉ ⵖⴰ ⵜⵓⵢⵓⵔ ⵜⵜⴰⴱⵓⵜ?” ");
INSERT INTO rift_vpl VALUES ("S16_21","010_6_21","1SA","6","21","21","ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ, ⵏⵏⴰⵏ: “ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ⵀⵡⴰⵎ ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵜ ⵖⴰⵔⵡⴻⵎ ⵙⴻⵏⵏⴻⵊ!” ");
INSERT INTO rift_vpl VALUES ("S17_1","010_7_1","1SA","7","1","1","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔⵙⴻⵏ ⵙⴻⵏⵏⴻⵊ. ⵏⵉⵜⵏⵉ ⵙⵙⵉⴷⴼⴻⵏ ⵜⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ, ⵅ ⵜⴻⵡⵔⵉⵔⵜ, ⵓⵛⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵎⵎⵉⵙ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴹⴰ ⵅ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S17_2","010_7_2","1SA","7","2","2","ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵜⵜⴰⴱⵓⵜ ⵜⴻⵇⵇⵉⵎ ⴷⵉ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ. ⵜⵓⵖⴰ ⵄⴷⵓⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵉⴷⵉ, ⵜᵉⵜⵜⵛⴻⵜⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S17_3","010_7_3","1SA","7","3","3","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰⵎⵡⵉⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵏⴹⴰⵔⴻⵎ ⵅⴰⵡⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵓⵍⴰ ⴷ ‘ⵄⴰⵛⵜⴰⵔⵓⵜⵉⵏ’, ⵓ ⴰⵔⵔⴻⵎ ⵓⵍ ⵏⵡⴻⵎ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵅⴻⴷⵎⴻⵎ ⴰⵙ ⵉ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S17_4","010_7_4","1SA","7","4","4","ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⴷ ‘ⵄⴰⵛⵜⴰⵔⵓⵜⵉⵏ’ ⵓⵛⴰ ⵄⴻⴱⴷⴻⵏ ⵉ ⵙⵉⴷⵉ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S17_5","010_7_5","1SA","7","5","5","ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⵙⵎⵓⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⵉⵚⴼⴰⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵉ ⵙⵉⴷⵉ ⵉ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("S17_6","010_7_6","1SA","7","6","6","ⵎⵓⵏⴻⵏ ⴷⵉ ⵎⵉⵚⴼⴰ ⵓⵛⴰ ⵓⵢⵎⴻⵏ ⴰⵎⴰⵏ, ⴼⴰⵔⵔⵖⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵥⵓⵎⵎⴻⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⴷⵉⵏ: “ⴰⵇⴰ ⵏⴻⵅⴹⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ!” ⴰⵎⵎⵓ ⵉ ⵉⵃⴽⴻⵎ ⵛⴰⵎⵡⵉⵍ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("S17_7","010_7_7","1SA","7","7","7","ⵓⵎⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⵍⵉⵏ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ ⴷⵉ ⵎⵉⵚⴼⴰⵜ, ⴼⴼⵖⴻⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ. ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵎⴰⵏⴰ ⴰⵢⴰ, ⴳⴳⵯⴻⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S17_8","010_7_8","1SA","7","8","8","ⵏⵏⴰⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵡⴰⵔ ⵙⴱⴻⴷⴷⵉ ⵙ ⵓⵍⴰⵖⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S17_9","010_7_9","1SA","7","9","9","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵛⴰⵎⵡⵉⵍ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵉⵟⵟⴻⴹ ⵓ ⵉⵇⴻⴷⴷⴻⵎ ⵉ-ⵜ ⵇⴰⵄ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ ⵓ ⵛⴰⵎⵡⵉⵍ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S17_10","010_7_10","1SA","7","10","10","ⵓⵎⵉ ⵉⵇⴻⴷⴷⴻⵎ ⵛⴰⵎⵡⵉⵍ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⵓⵛⴰ ⵉⵙⵙⵀⴻⵎⵀⴻⵎ ⵙⵉⴷⵉ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵙⵙⴰⵔⵊⴻⴼ ⵉ-ⵜⴻⵏ ⴰⵍⴰⵎⵉ ⵜⵜⵡⴰⵖⴻⵍⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S17_11","010_7_11","1SA","7","11","11","ⴼⴼⵖⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⴼⴰ, ⴹⴼⴰⵔⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵜⴻⵏ ⴰⵍ ⵙⴰⴷⵓ ⴱⴰⵢⵜ-ⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S17_12","010_7_12","1SA","7","12","12","ⵉⴽⵙⵉ ⵛⴰⵎⵡⵉⵍ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⵊⴰⵔ ⵎⵉⵚⴼⴰ ⴷ ⵙⴰⵏ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉⵙⴻⵎ ‘ⴰⴱⵉⵏ-ⵀⴰⵄⵉⵣⵉⵔ’, ⵉⵏⵏⴰ: “ⴰⵍ ⴷⴰⵏⵉⵜⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⴰⴼⵓⵙ.”    ");
INSERT INTO rift_vpl VALUES ("S17_13","010_7_13","1SA","7","13","13","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵓⴷⵉⴼⴻⵏ ⵛⴰ ⵄⴰⴷ ⴷⴰⵅⴻⵍ ⵉ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵛⴰⵎⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S17_14","010_7_14","1SA","7","14","14","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵄⴰⵇⵔⵓⵏ ⴰⵍ ⵊⴰⵜ ⵉ ⵜⵓⵖⴰ ⵟⵟⴼⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵢⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⴻⵡⵍⴻⵏⵜ-ⴷⴷ ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵉⵇⵍⴻⵄ ⵉ-ⵜⴻⵏⵜ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷⵉⵏ ⵍⴻⵀⵏⴰ ⵊⴰⵔ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S17_15","010_7_15","1SA","7","15","15","ⵜⵓⵖⴰ ⵛⴰⵎⵡⵉⵍ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S17_16","010_7_16","1SA","7","16","16","ⴰⵙⴻⴳⴳⵯⴰⵙ ⵅ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ, ⵉⴳⴳⵓⵔ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵊⵉⵍⵊⴰⵍ ⴷ ⵎⵉⵚⴼⴰ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S17_17","010_7_17","1SA","7","17","17","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵔⴰⵎⴰ, ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴷⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴱⵏⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S18_1","010_8_1","1SA","8","1","1","ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵛⴰⵎⵡⵉⵍ ⵉⵡⵙⴰⵔ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵇⵓⴹⴰⵜ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S18_2","010_8_2","1SA","8","2","2","ⵎⵎⵉⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵓⵡⵉⵍ ⵓ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⴱⵉⵢⴰ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S18_3","010_8_3","1SA","8","3","3","ⵎⴰⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⴰⵔⴻⴷⴼⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⴰⵔⴱⴻⵃ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵟⵟⴼⴻⵏ ⴰⵔⵔⵉⵖⴰⵍⵓⵜ ⵓ ⵙⵙⴼⴰⵔⵔⵖⴻⵏ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("S18_4","010_8_4","1SA","8","4","4","ⵅⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵛⴰⵎⵡⵉⵍ ⴷⵉ ⵔⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("S18_5","010_8_5","1SA","8","5","5","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⴻⵡⵙⴰⵔⴻⴷ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⵛⴰ ⵅ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵛ. ⵙ ⵓⵢⴰ ⴻⴳⴳ ⵍⴻⵅⵅⵓ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅⴰⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⴽⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("S18_6","010_8_6","1SA","8","6","6","ⴰⵡⴰⵍ-ⴰ ⵉⴵⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵛⴰⵎⵡⵉⵍ, ⵍⴰⵎⵉ ⵏⵏⴰⵏ: “ⴻⵡⵛ ⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⴽⴻⵎ!” ⵓⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵥⵥⵓⴵ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S18_7","010_8_7","1SA","8","7","7","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵙⴻⵍ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ ⵉ ⵏⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵛⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⵏⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S18_8","010_8_8","1SA","8","8","8","ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵄⴰⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷ ⴰⵢⵉ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⴰⵎⵎⵓ ⵉ ⴷⴰⵢⴻⴽ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S18_9","010_8_9","1SA","8","9","9","ⵙⴻⵍ ⵍⴻⵅⵅⵓ ⵖⴰⵔⵙⴻⵏ, ⵎⴰⵛⴰ ⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⵙⴰⵔⴳⴻⴱ ⵉ-ⵜⴻⵏ ⵙ ⵍⵃⴻⵇⵇ ⵏ ⵓⵊⴻⴵⵉⴷ ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S18_10","010_8_10","1SA","8","10","10","ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰⵎⵡⵉⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴰⵔⴻⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S18_11","010_8_11","1SA","8","11","11","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵢⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⴷ ⵍⵃⴻⵇⵇ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ: ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ, ⵓ ⴰⴷ ⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S18_12","010_8_12","1SA","8","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵅⴻⵎⵙⵉⵏ, ⵓ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔ ⴰⴷ ⵛⴰⵔⵣⴻⵏ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵎⵊⴰⵔⴻⵏ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⴳⴳⴻⵏ ⴷⴷⵓⵣⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏⵏⴻⵙ ⴷ ⴷⴷⵓⵣⴰⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S18_13","010_8_13","1SA","8","13","13","ⵢⴻⵙⵙⵉⵜⵡⴻⵎ ⴰⴷ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ-ⵢⴰⵡⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏⵜ ⴼⵓⵎⴰⴹⴰⵜ, ⴰⴷ ⵙⵙⵏⴻⵏⵏⴰⵏⵜ ⵓ ⴰⴷ ⴳⴳⵯⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S18_14","010_8_14","1SA","8","14","14","ⴰⴷ ⵉⴽⵙⵉ ⵎⵓⵎⵎⵓ ⵏ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵡⴻⵎ, ⵏ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵡⴻⵎ ⵏ ⵓⴹⵉⵍ ⵓ ⵏ ⵉⵃⵡⵉⵛⴻⵏ ⵏ ⵜⴰⵣⴰⵔⵜ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵡⵛ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S18_15","010_8_15","1SA","8","15","15","ⴰⴷ ⵉⴽⵙⵉ ⵍⴻⵄⵛⵓⵔ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ, ⵏ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵡⴻⵎ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵓ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S18_16","010_8_16","1SA","8","16","16","ⴰⴷ ⵉⴽⵙⵉ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ ⵏⵡⴻⵎ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⵉⵖⵢⴰⵍ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴰⴷ ⴰⵙ ⵅⴻⴷⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S18_17","010_8_17","1SA","8","17","17","ⴰⴷ ⵉⴽⵙⵉ ⵍⴻⵄⵛⵓⵔ ⵏ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S18_18","010_8_18","1SA","8","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵖⵓⵢⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ ⵉ ⵜⴻⵅⴹⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("S18_19","010_8_19","1SA","8","19","19","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⴻⵍ ⵖⴰⵔ ⵛⴰⵎⵡⵉⵍ, ⵏⵏⴰⵏ: “ⵍⵍⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S18_20","010_8_20","1SA","8","20","20","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⴰⵎ ⵍⴻⴳⵏⵓⵙ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵔⵔⴰ, ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⴽⴻⵎ ⵙ ⵍⵃⴻⵇⵇ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵣⵡⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵓⵢⵓⵔ ⵉⵎⴻⵏⵖⴰⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S18_21","010_8_21","1SA","8","21","21","ⵓⵎⵉ ⵉⵙⵍⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ ⵜⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S18_22","010_8_22","1SA","8","22","22","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵙⴻⵍ ⵖⴰⵔⵙⴻⵏ, ⴻⴳⴳ ⵅⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ!” ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴻⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S19_1","010_9_1","1SA","9","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵇⵉⵙ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵔ, ⵎⵎⵉⵙ ⵏ ⴱⴰⴽⵓⵔⴰⵜ, ⵎⵎⵉⵙ ⵏ ⴰⴼⵉⵢⴰⵃ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵡⴰⴳⵍⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S19_2","010_9_2","1SA","9","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⴰⵡⵓⵍ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵓ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵓⵖⵉ ⴰⵥⵔⵉ ⴰⵎ ⵏⴻⵜⵜⴰ. ⵏⴻⵜⵜⴰ ⵢⵓⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵙ ⵜⵉⴷⴷⵉ ⵏ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S19_3","010_9_3","1SA","9","3","3","ⵜⵓⵖⴰ ⵜⵉⵖⵢⴰⵍ ⵏ ⵇⵉⵙ, ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵡⴻⴷⴷⴰⵔⴻⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵇⵉⵙ ⵉ ⵎⵎⵉⵙ ⵛⴰⵡⵓⵍ: “ⴽⵙⵉ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⴰⵡⵢⵉ ⵜ ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⴽⴽⴰⵔ, ⴰⵔⵣⵓ ⵅ ⵜⴻⵖⵢⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("S19_4","010_9_4","1SA","9","4","4","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⴽⴽⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⴰⵍⵉⵛⴰ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⴻⵏⵜ ⵓⴼⵉⵏ. ⵅⴰⵙ ⵓⵛⴰ ⴽⴽⵉⵏ ⵏⵉⵜⵏⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⴰⵄⴰⵍⵉⵎ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵓⴼⵉⵏ ⴷⵉⵏⵏⵉ. ⵅⴻⵏⵏⵉ ⴽⴽⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵓⴼⵉⵏ ⴷⵉⵏⵏⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S19_5","010_9_5","1SA","9","5","5","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵚⵓⴼ, ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ: “ⴰⵙ-ⴷⴷ, ⴰⴷ ⵏⴻⵄⵇⴻⴱ, ⵏⵉⵖ ⴱⴰⴱⴰ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵄⴰⴷ ⵙ ⵡⴻⵎⵏⵓⵙ ⴷⵉ ⵜⴻⵖⵢⴰⵍ, ⵎⴰⵛⴰ ⴷⴰⵢⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S19_6","010_9_6","1SA","9","6","6","ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵅⵣⴰⵔ ⵅⴻⵏⵏⵉ, ⴰⵇⴰ ⵉⵊⵊ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ. ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵛⴻⵏⵏⴻⵄ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⴰⵔ, ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵏⵉⵛⴰⵏ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵙ ⵏⵔⴰⵃ ⴷⵉⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵛⴻⵏ ⴰⴱⵔⵉⴷ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⵓⵢⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("S19_7","010_9_7","1SA","9","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵏⵔⴰⵃ, ⵎⵉⵏ ⵖⴰ ⵏⴰⵡⵉ ⵅⴻⵏⵏⵉ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ? ⵎⴰⵖⴰⵔ ⴰⵖⵔⵓⵎ ⵊⴰⵔ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏⵏⴻⵖ ⵉⵔⵓⵃ. ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴰⵖⵉⵔⴰⵍⵓⵜ ⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵡⵛ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⵉⵖ ⵎⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵏⵏⴻⵖⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("S19_8","010_9_8","1SA","9","8","8","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵄⴰⵡⴻⴷ ⵅ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴷⴰ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ⴰⴷ ⵜ ⵡⵛⴻⵖ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵛⴻⵏ ⴰⴱⵔⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S19_9","010_9_9","1SA","9","9","9","ⵣⵉⵛ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴰ ⴰⵔⴻⴱⴱⵉ: “ⴰⵙⴻⵎ-ⴷⴷ, ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵓⵎⵡⴰⵍⴰⵡ!”, ⵎⴰⵖⴰⵔ ⴰⵏⴰⴱⵉ ⵏ ⵡⴰⵙⵙ-ⴰ, ⵣⵉⵛ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴰⵎⵡⴰⵍⴰⵡ’.    ");
INSERT INTO rift_vpl VALUES ("S19_10","010_9_10","1SA","9","10","10","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵉⵚⴱⴻⵃ! ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ!” ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("S19_11","010_9_11","1SA","9","11","11","ⵓⵎⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵙⴰⵡⴻⵏⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵎⵙⴰⴳⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵜⴻⴱⵍⵉⵖⵉⵏ ⵜⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵎⴻⵏⵜ ⴰⵎⴰⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙⴻⵏⵜ: “ⵎⴰ ⴰⵎⵡⴰⵍⴰⵡ ⴷⴰ?” ");
INSERT INTO rift_vpl VALUES ("S19_12","010_9_12","1SA","9","12","12","ⵏⵉⵜⴻⵏⵜⵉ ⴰⵔⵔⵉⵏⵜ ⵅⴰⵙⴻⵏ, ⵏⵏⴰⵏⵜ: “ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⵉⵀⴰ ⵖⴰⵔ ⵣⵣⴰⵜ. ⴷⴻⵖⵢⴰⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⴰⵙⵙ-ⴰ ⴰⴷ ⵉⴳⴳ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵅ ⵍⴳⴻⵄⵄⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S19_13","010_9_13","1SA","9","13","13","ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ, ⴰⴷ ⵜ ⵜⴰⴼⴻⵎ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵓⵏ ⵉ ⵎⴰⵛⵛⴰ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵏⴻⵜⵜⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵍⴱⴰⵔⴰⴽⴰ ⴷⵉ ⵜⵖⴰⵔⵚⵜ, ⵅⴻⵏⵏⵉ ⵄⴰⴷ ⴰⴷ ⵛⵛⴻⵏ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ. ⴳⴻⵄⵄⴷⴻⵎ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ-ⴰ ⴰⵇⴰ-ⵜ ⴷ ⵍⴼⵓⵔⵚⴰ ⴰⴷ ⵜ ⵜⴰⴼⴻⵎ ⵏⵉⵛⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("S19_14","010_9_14","1SA","9","14","14","ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵛⴰⵎⵡⵉⵍ, ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S19_15","010_9_15","1SA","9","15","15","ⵎⵉⵏⵣⵉ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵇⴱⴻⵍ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵛⴰⵡⵓⵍ, ⵉⵙⵙⴰⵔⴳⴻⴱ ⵙⵉⴷⵉ ⵉ ⵛⴰⵎⵡⵉⵍ ⴷⴻⴳ ⵓⵎⴻⵣⵣⵓⵖ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("S19_16","010_9_16","1SA","9","16","16","“ⵜⵉⵡⴻⵛⵛⴰ ⴰⵎⵎⵓ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⴰⴷ ⵖⴰⵔⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⴰⴷ ⵜ ⵜⴷⴻⵀⵏⴻⴷ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵓ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵙⴻⵏ ⵉ ⵓⵙⵖⴰⵜⵉ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("S19_17","010_9_17","1SA","9","17","17","ⵓⵎⵉ ⵛⴰⵎⵡⵉⵍ ⵉⵥⵔⴰ ⵛⴰⵡⵓⵍ ⵉⵜⵜⴰⵙ-ⴷⴷ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵙⵉⴷⵉ: “ⵅⵣⴰⵔ, ⴷ ⵡⴰ ⴷ ⴰⵔⵢⴰⵣ ⵉ ⵅ ⵉ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⵡⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("S19_18","010_9_18","1SA","9","18","18","ⵢⵓⵢⵓⵔ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵛⴰⵎⵡⵉⵍ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵏⵏⴰ: “ⵙⵛⴻⵏ ⴰⵢⵉ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵡⴰⵍⴰⵡ.” ");
INSERT INTO rift_vpl VALUES ("S19_19","010_9_19","1SA","9","19","19","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⴰⵎⵡⵉⵍ ⵅ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⴰⵎⵡⴰⵍⴰⵡ. ⵓⵢⵓⵔ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⵍⴳⴻⵄⵄⴷⴻⵜ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⵛⵛⴻⵎ ⴰⵙⵙ-ⴰ. ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ ⴰⴷ ⵛⴻⴽ ⵊⵊⴻⵖ ⴰⴷ ⵜⴻⵄⴷⵓⴷ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S19_20","010_9_20","1SA","9","20","20","ⵅ ⵜⴻⵖⵢⴰⵍ ⵉ ⴷ ⴰⵛ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴰⵙⵙ-ⴰ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵣⴻⴳ ⵡⴰⵎⵉ, ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⵡⴻⵎⵏⵓⵙ, ⵎⴰⵖⴰⵔ ⵜⵜⵡⴰⴼⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ. ⵎⴰⵛⴰ ⵡⵉ ⵖⴰⵔ ⵉⵜⵜⵔⴰⵃ ⵎⴰⵔⵔⴰ ⵎⴻⵥⵔⵉ ⵏ ⵉⵙⵔⴰⵉⵍ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔⴻⴽ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ?” ");
INSERT INTO rift_vpl VALUES ("S19_21","010_9_21","1SA","9","21","21","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴵⵉⵖ ⵏⴻⵛⵛ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵣⵉ ⵜⵎⴻⵥⵢⴰⵏⵜ ⵇⴰⵄ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵍⴰⴵ ⵉⵏⵓ ⵜⴰⵎⵓⵇⵍⵉⵍⵜ ⵇⴰⵄ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ? ⵎⴰⵢⴻⵎⵎⵉ ⴽⵉⴷⵉ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⴰⵡⴰⵍⴻⵏ ⴰⵎ ⵉⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("S19_22","010_9_22","1SA","9","22","22","ⵛⴰⵎⵡⵉⵍ ⵉⴽⵙⵉ ⵛⴰⵡⵓⵍ ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ, ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴰⵔⵡⴰ, ⵉⵙⵙⵖⵉⵎ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ. ⵜⵓⵖⴰ ⵏⵏⵢⴰⵔⵡⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S19_23","010_9_23","1SA","9","23","23","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵓⴳⴻⵣⵣⴰⵔ: “ⴰⵡⵉ-ⴷⴷ ⵍⴻⵅⵅⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵛ ⵡⵛⵉⵖ, ⵜⴻⵏⵏⵉ ⵅ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⴻⵊⵊ ⵉ-ⵜⵜ ⵖⴰⵔⴻⴽ!’” ");
INSERT INTO rift_vpl VALUES ("S19_24","010_9_24","1SA","9","24","24","ⴷ ⴰⴳⴻⵣⵣⴰⵔ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵖⵔⵓⴹⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵉⴵⴰⵏ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵣⵣⴰⵜ ⵉ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵢⴰ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ. ⴻⴳⴳ ⵉ-ⵜⵜ ⵣⵣⴰⵜⴻⴽ ⴰⴷ ⵜⴻⵛⵛⴻⴷ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵃⴹⴰ ⵉ ⵜⵙⴰⵄⵄⴻⵜ-ⴰ, ⵓⵎⵉ ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵄⴰⵔⴹⴻⵖ ⵅ ⵍⴳⴻⵏⵙ.’” ⵓⵛⴰ ⵉⵛⵛⴰ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵛⴰⵎⵡⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S19_25","010_9_25","1SA","9","25","25","ⵅⴻⵏⵏⵉ ⵀⵡⴰⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵣⵉ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ ⵅ ⵜⵣⴻⵇⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("S19_26","010_9_26","1SA","9","26","26","ⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ, ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵖⴰⵔ ⵍⴻⴼⵊⴰⵔ ⵏ ⵡⴰⵙⵙ, ⴰⵇⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵛⴰⵎⵡⵉⵍ ⵅ ⵛⴰⵡⵓⵍ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵅ ⵜⵣⴻⵇⵇⴰ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⵇⴻⴱⴱⴹⴻⵖ!” ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵛⴰⵎⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S19_27","010_9_27","1SA","9","27","27","ⵓⵎⵉ ⴷⴷ-ⵀⵡⴰⵏ ⵏⵉⵜⵏⵉ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵛⴰⵡⵓⵍ: “ⵉⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⴷ ⵉⴱⴻⵄⵄⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵖ!” ⵅⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⵊ ⵏⴻⵜⵜⴰ. ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⵇⵇⵉⵎ ⵍⴻⵅⵅⵓ, ⴱⴻⴷⴷ ⴷⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("S110_1","010_10_1","1SA","10","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⵙⵉ ⵛⴰⵎⵡⵉⵍ ⵜⴰⵣⵉⵢⵢⴰⵜ ⵏ ⵣⵣⴻⵛⵜ, ⵉⵙⴻⵢⵢⴻⴱ ⵉ-ⵜⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⵎⴰ ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⴷⵀⵉⵏ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("S110_2","010_10_2","1SA","10","2","2","ⵅⵎⵉ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ ⴰⵙⵙ-ⴰ, ⴰⴷ ⵜⴰⴼⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵏ ⵔⴰⵃⵉⵍ ⴷⵉ ⵚⴰⵍⵚⴰⵃ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: ‘ⵜⵉⵖⵢⴰⵍ ⵉ ⵅ ⵜⵓⵖⴰ ⵜⴰⵔⴻⵣⵣⵓⴷ, ⵜⵜⵡⴰⴼⴻⵏⵜ ⵓⵛⴰ ⴱⴰⴱⴰⵛ ⵉⵙⵎⴻⵃ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⴻⵖⵢⴰⵍ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴷⴰⵢⴻⵙ ⵍⴻⵅⵅⵓ ⴰⵎⵏⵓⵙ ⵅⴰⵡⴻⵎ, ⵉⵇⵇⴰⵔ: ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵅ ⵎⵎⵉ?’” ");
INSERT INTO rift_vpl VALUES ("S110_3","010_10_3","1SA","10","3","3","ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⵏⵉⴷ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵏ ⵜⴰⴱⵓⵔ. ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵎⵎⴻⵍⵇⵉⴷ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵓ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S110_4","010_10_4","1SA","10","4","4","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵡⵛⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵉ ⵖⴰ ⵜᵉⵟⵟⴼⴻⴷ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S110_5","010_10_5","1SA","10","5","5","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵊⵉⴱⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵏⵉ ⴱⴻⴷⴷⴻⵏⵜ ⵜⴻⵛⴱⴰⵔⵉⵏ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵅⵎⵉ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⴷ ⵜⴻⵎⵎⴻⵍⵇⵉⴷ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⴽⵓⵍⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⵉ ⵍⴳⴻⵄⵄⴷⴻⵜ, ⵓⵛⴰ ⵣⵣⴰⵜⵙⴻⵏ ⵍⵀⴰⵔⴱⴰ ⴷ ⵓⴱⴻⵏⴷⵉⵔ ⴷ ⵜⵥⴰⵎⴰⵔⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉ ⴰⵎ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S110_6","010_10_6","1SA","10","6","6","ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵉⵀⵡⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵏⴻⴱⴱⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S110_7","010_10_7","1SA","10","7","7","ⴰⴷ ⵉⵎⵙⴰⵔ ⵅⵎⵉ ⵖⴰⵔⴻⴽ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ-ⴰ, ⴰⵇⴰ ⴰⴷ ⵅⴰⴽ ⵢⵉⵍⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵖⴰ ⵢⴰⴼ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S110_8","010_10_8","1SA","10","8","8","ⴰⴷ ⴰⵢⵉ ⵜⵉⵣⵡⴰⵔⴻⴷ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ, ⵓ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵀⵡⵉⵖ ⵖⴰⵔⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⵉⵏ ⵉ ⵖⴰ ⵜⵔⴰⵊⵉⴷ ⴰⵍ ⴷⴷ ⵖⴰⵔⴻⴽ ⵉ ⵖⴰ ⵢⴰⵙⴻⵖ, ⴰⴷ ⴰⵛ ⴷⴷ-ⴱⴰⵔⵔⵃⴻⵖ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("S110_9","010_10_9","1SA","10","9","9","ⵓⵎⵉ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⴰⵄⵔⵓⵔ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⵓⵢⵓⵔ ⵅ ⵛⴰⵎⵡⵉⵍ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴱⴻⴷⴷⴻⵍ ⵓⵍ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵏⵏⴻⵖⵏⵉ. ⵎⴰⵔⵔⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ-ⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S110_10","010_10_10","1SA","10","10","10","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵊⵉⴱⵄⴰ, ⴰⵇⴰ ⵉⵍⵇⴰ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⴽⵓⵍⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴻⴱⴱⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S110_11","010_10_11","1SA","10","11","11","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜ ⵉⵙⵙⵏⴻⵏ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ, ⵥⵔⵉⵏ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⴰⴽ-ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵢⵓⵖⵉⵏ ⵎⵎⵉⵙ ⵏ ⵇⵉⵛ? ⵎⴰ ⵓⵍⴰ ⴷ ⵛⴰⵡⵓⵍ ⵊⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S110_12","010_10_12","1SA","10","12","12","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙⵙⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ?” ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵡⴰⵡⴰⵍ-ⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ: “ⵎⴰ ⵓⵍⴰ ⴷ ⵛⴰⵡⵓⵍ ⵊⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S110_13","010_10_13","1SA","10","13","13","ⵓⵎⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵜⵜⵏⴻⴱⴱⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S110_14","010_10_14","1SA","10","14","14","ⵄⴻⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ ⴰⵙ ⵓ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵔⴰⵀⴻⵎ ⴽⴻⵏⵏⵉⵡ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴰⵔⴻⵣⵣⵓ ⵅ ⵜⴻⵖⵢⴰⵍ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵏⴻⵥⵔⴰ, ⴰⵇⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⴵⵉⵏⵜ, ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵛⴰⵎⵡⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S110_15","010_10_15","1SA","10","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵄⴻⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ: “ⵉⵏⵉ ⴰⵢⵉ, ⵄⴰⴼⴰⴽ, ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("S110_16","010_10_16","1SA","10","16","16","ⵛⴰⵡⵓⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵄⴻⵎⵎⵉⵙ: “ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵜⵉⵖⵢⴰⵍ ⵜⵜⵡⴰⴼⴻⵏⵜ.” ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⴳⴻⵍⴷⴰ ⵎⴰⵛⴰ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰⵎⵡⵉⵍ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜ ⵉⵄⵉⵡⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S110_17","010_10_17","1SA","10","17","17","ⵛⴰⵎⵡⵉⵍ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("S110_18","010_10_18","1SA","10","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⴼⴻⴽⴽⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵃⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S110_19","010_10_19","1SA","10","19","19","ⵎⴰⵛⴰ ⴰⵙⵙ-ⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⴹⴰⵔⴻⵎ ⵙⵉⴷⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵣⵣⵄⴰⴼ ⵏⵡⴻⵎ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⵏⴰⵎ ⴰⵙ: ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅⴰⵏⴻⵖ! ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏⵡⴻⵎ ⴷ ⵍⵓⵍⵓⴼ ⵏⵡⴻⵎ!’” ");
INSERT INTO rift_vpl VALUES ("S110_20","010_10_20","1SA","10","20","20","ⵛⴰⵎⵡⵉⵍ ⵉⵊⵊⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏⵜ ⵓⵛⴰ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⵙⴻⵏⵜ ");
INSERT INTO rift_vpl VALUES ("S110_21","010_10_21","1SA","10","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⵊⵊⴰ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⴷ ⵜⵇⴰⵔⵔⴻⴱ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⵍⴰⴵ ⵏ ⵎⴰⵜⵔⵉ ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⵛⴰⵡⵓⵍ, ⵎⵎⵉⵙ ⵏ ⵇⵉⵛ. ⴰⵔⵣⵓⵏ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S110_22","010_10_22","1SA","10","22","22","ⵏⵉⵜⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⵙⵉⴷⵉ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ: “ⵎⴰ ⵏⵉⵛⴰⵏ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴷⴰⵏⵉⵜⴰ?” ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⴼⴼⴰⵔ ⵊⴰⵔ ⵍⴻⵃⵡⴰⵢⴻⵊ.” ");
INSERT INTO rift_vpl VALUES ("S110_23","010_10_23","1SA","10","23","23","ⵏⵉⵜⵏⵉ ⵓⵣⵣⵍⴻⵏ ⴷⵉⵏ, ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ⵢⵓⵊⴰⵔ ⵏⴻⵜⵜⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵙ ⵜⵉⴷⴷⵉ ⵏ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S110_24","010_10_24","1SA","10","24","24","ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⵎⴰ ⵜⴻⵥⵔⵉⵎ ⵍⴻⵅⵅⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉⴼⴰⵔⵣ ⵙⵉⴷⵉ? ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵡⵉⵙ.” ⵓⵛⴰ ⵉⵙⵍⵉⵡⵍⴻⵡ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("S110_25","010_10_25","1SA","10","25","25","ⵛⴰⵎⵡⵉⵍ ⵉⵙⵙⵛⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⵍⵃⴻⵇⵇ ⵏ ⵜⴳⴻⵍⴷⴰ, ⵢⵓⵔⴰ ⵉ-ⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⵢⴰⵔⵅⵓ ⵛⴰⵎⵡⵉⵍ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S110_26","010_10_26","1SA","10","26","26","ⵓⵍⴰ ⴷ ⵛⴰⵡⵓⵍ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵊⵉⴱⵄⴰ ⵓⵛⴰ ⵉⵔⵓⵃ ⴰⴽⵉⴷⴻⵙ ⵡⴻⵣⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴰⴷⴰ ⵙⵉⴷⵉ ⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S110_27","010_10_27","1SA","10","27","27","ⵎⴰⵛⴰ ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⴼⴻⴽⴽ ⵡⴻⵔⵢⴰⵣ-ⴰ?” ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵜ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵛⴰ ⵜⴰⵔⵣⴻⴼⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("S111_1","010_11_1","1SA","11","1","1","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵏⴰⵃⴰⵛ, ⴰⵄⴰⵎⵎⵓⵏⵉ, ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⵙ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ ⵏⵏⴰⵏ ⵉ ⵏⴰⵃⴰⵛ: “ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵏⵙⴻⵅⵅⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("S111_2","010_11_2","1SA","11","2","2","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴰⵄⴰⵎⵎⵓⵏⵉ ⵏⴰⵃⴰⵛ: “ⵅ ⵡⴻⴱⵔⵉⴷ-ⴰ ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵇⴻⵍⵄⴻⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵟⵟ ⵜⴰⴼⵓⵙⴻⵛⵜ, ⴰⴷ ⵜⵜ ⴳⴳⴻⵖ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S111_3","010_11_3","1SA","11","3","3","ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵢⴰⴱⵉⵛ ⵏⵏⴰⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵏⴻⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵏⵓⴼⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵏⴻⴼⴼⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S111_4","010_11_4","1SA","11","4","4","ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵊⵉⴱⵄⴰ ⵏ ⵛⴰⵡⵓⵍ, ⵙⵙⵉⵡⴹⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S111_5","010_11_5","1SA","11","5","5","ⵓ ⵅⵣⴰⵔ, ⵛⴰⵡⵓⵍ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵢⵢⴰⵔ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵢⵓⵖⵉⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵔⵓ ⴰⵎⵎⵓ?” ⵏⵉⵜⵏⵉ ⵃⴰⵊⴰⵏ ⴰⵙ ⴰⵡⴰⵍⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("S111_6","010_11_6","1SA","11","6","6","ⵉⵀⵡⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵛⴰⵡⵓⵍ ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵓⵛⴰ ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S111_7","010_11_7","1SA","11","7","7","ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵉⵇⴻⵟⵟⴻⵙ ⵉ-ⵜⴻⵏ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ, ⵉⵙⵙⴻⴽⴽ ⵉⵛⴻⴵⵉⵇⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴰⵏ: “ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴼⴼⵉⵖⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵛⴰⵡⵓⵍ ⵓ ⴰⵡⴰⵔⵏⵉ ⵛⴰⵎⵡⵉⵍ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵅⵣⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⴰⴽ-ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵙ.” ⵅⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵎⵓⵏⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("S111_8","010_11_8","1SA","11","8","8","ⵉⵙⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵛⴰⵡⵓⵍ ⴷⵉ ⴱⴰⵣⴰⵇ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ-ⴰⵍⴻⴼ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S111_9","010_11_9","1SA","11","9","9","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵢⵓⵙⵉⵏ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ: ‘ⵜⵉⵡⴻⵛⵛⴰ, ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⴼⵓⵛⵜ ⵜⴰⵍⵖⴰ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵎ.’” ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵄⴰⵡⴷⴻⵏ ⵜⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ ⵓⵛⴰ ⴼⴰⵔⵃⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S111_10","010_11_10","1SA","11","10","10","ⵏⵏⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ: “ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵏⴻⴼⴼⴻⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴽⵉⴷⵏⴻⵖ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("S111_11","010_11_11","1SA","11","11","11","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵉⴱⴹⴰ ⵍⴳⴻⵏⵙ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⴱⴰⵟⴰⵢⵓⵏⴻⵏ ⵓ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵚⵚⴱⴻⵃ ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓⵛⴰ ⵡⵜⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵖⴰⵔ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ. ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵜⵢⵓⵢⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S111_12","010_11_12","1SA","11","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⴳⴻⵏⵙ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⵏⵏⴰⵏ: ‘ⵎⴰ ⵛⴰⵡⵓⵍ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ?’ ⴰⵡⵢⵉ ⵜⴻⵏ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S111_13","010_11_13","1SA","11","13","13","ⵎⴰⵛⴰ ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ-ⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⴹ-ⴷⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S111_14","010_11_14","1SA","11","14","14","ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵍⴳⴻⵏⵙ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ, ⴰⴷ ⴷⵉⵏⵏⵉ ⵏⵍⴻⵇⵇⴻⵃ ⵜⴰⴳⴻⵍⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("S111_15","010_11_15","1SA","11","15","15","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴷⵉⵏⵏⵉ ⴷⵉ ⵊⵉⵍⵊⴰⵍ ⵛⴰⵡⵓⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵖⴰⵔⵚⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴼⴰⵔⵃ ⵛⴰⵡⵓⵍ ⴰⵟⵟⴰⵙ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S112_1","010_12_1","1SA","12","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵖⴰⵔⵡⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⴰⵎ ⵓ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_2","010_12_2","1SA","12","2","2","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵉⵔⵓⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⵏⴻⵛⵛ ⵡⵙⴰⵔⴻⵖ, ⴷⴻⵡⵍⴻⵖ ⵛⴰⴱⴻⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵔⵔⴰⵡ ⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ. ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ ⴰⵍ ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_3","010_12_3","1SA","12","3","3","ⴰⵇⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⴷⴰ. ⵛⴻⵀⴷⴻⵎ ⵅⴰⴼⵉ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵓ ⵣⵣⴰⵜ ⵉ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴻⵙ. ⵉ ⵓⵎⵉ ⵉⵡⵢⴻⵖ ⵛⴰ ⵏ ⵓⴼⵓⵏⴰⵙ? ⵉ ⵓⵎⵉ ⵉⵡⵢⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵃⵚⴰⵔⴻⵖ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴻⵣⵣⵉⵖ ⵓ ⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵟⵟⴼⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵏⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ? ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵜ ⴰⵔⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S112_4","010_12_4","1SA","12","4","4","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵃⵚⴰⵔⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵖⴻⵣⵣⵉⴷ ⵓ ⵡⴰⵔ ⵜᵉⵟⵟⵉⴼⴻⴷ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S112_5","010_12_5","1SA","12","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵉⴷⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵅⴰⵡⴻⵎ ⵓ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⴰⵙⵙ-ⴰ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵓⴼⵉⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ!” ⵉⵏⵏⴰ ⵍⴳⴻⵏⵙ: “ⴰⵇⴰ-ⵜ ⴷ ⴰⵛⴻⵀⵀⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("S112_6","010_12_6","1SA","12","6","6","ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵍⴳⴻⵏⵙ: “ⴷ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵉⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S112_7","010_12_7","1SA","12","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴱⴻⴷⴷⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵍⵃⴻⵇⵇ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵙⵉⴷⵉ ⵜⵉⵏⵏⵉ ⵉⴳⴳⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_8","010_12_8","1SA","12","8","8","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵙⵖⵓⵢⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ-ⴷⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⵙⵙⵣⴻⴷⵖⴻⵏ ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S112_9","010_12_9","1SA","12","9","9","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵓⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵣⵣⴻⵏⵣ ⵉ-ⵜⴻⵏ ⵉ ⵙⵉⵙⴰⵔⴰ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴷⵉ ⵃⴰⵚⵓⵔ, ⵓ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S112_10","010_12_10","1SA","12","10","10","ⵓⵛⴰ ⵙⵖⵓⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵏⵏⴰⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵎⴻⵃ ⴷⵉ ⵙⵉⴷⵉ, ⵏⵙⴻⵅⵅⴰⵔ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⴷ ‘ⵄⴰⵛⵜⴰⵔⵓⵜⵉⵏ’. ⵓ ⵍⴻⵅⵅⵓ, ⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵛⴻⴽ ⵏⵙⴻⵅⵅⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("S112_11","010_12_11","1SA","12","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵙⵉⴷⵉ ⵢⴰⵔⵓⴱⴱⴰⵄⵍ ⴷ ⴱⴰⴷⴰⵏ ⴷ ⵢⴰⴼⵜⴰⵃ ⴷ ⵛⴰⵎⵡⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S112_12","010_12_12","1SA","12","12","12","ⵓⵎⵉ ⵜⴻⵥⵔⵉⵎ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵏⴰⵃⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ, ⵜⴻⵏⵏⵉⵎ ⴰⵢⵉ: ‘ⵍⵍⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ!’, ⵡⴰⵅⵅⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_13","010_12_13","1SA","12","13","13","ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵉ ⵜⵉⵅⴹⴰⵔⴻⵎ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ. ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_14","010_12_14","1SA","12","14","14","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵓ ⴰⴷ ⵜⴻⵙⵍⴰⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵓ ⵡⴰⵔ ⵜⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ, ⵉⵡⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ, ⴰⴷ ⵜⵉⵍⵉⵎ ⴷⵉ ⵍⴰⵎⴰⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_15","010_12_15","1SA","12","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵎ ⵜ ⵜⵓⵖⴰ ⵅ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_16","010_12_16","1SA","12","16","16","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴱⴻⴷⴷⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵅⵣⴰⵔⴻⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⴷ ⵖⴰ ⵉⴳⴳ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_17","010_12_17","1SA","12","17","17","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵙⵙ-ⴰ ⵚⵚⴰⴱⴻⵜ ⵏ ⵉⵔⴷⴻⵏ? ⵏⴻⵛⵛ ⴰⴷ ⵍⴰⵖⵉⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵛ ⴰⵊⵊⴰⵊⴻⵏ ⴷ ⵡⴻⵏⵥⴰⵔ ⴰⵍ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵓ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵎⴻⵛⵀⴰⵍ ⵉⵎⵖⴰⵔ ⵍⵖⴰⵔ ⵉ ⵜⴻⴳⴳⵉⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("S112_18","010_12_18","1SA","12","18","18","ⵓ ⵛⴰⵎⵡⵉⵍ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵊⵊⴰⵊⵊⴻⵏ ⴷ ⵡⴻⵏⵥⴰⵔ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵉ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵛⴰⵎⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S112_19","010_12_19","1SA","12","19","19","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵥⴰⴵ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵏⵉ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵄⴰⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴰⵢⴰ, ⴱⴻⵍⵍⵉ ⵏⴰⵔⵣⵓ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵏⴻⵛⵛⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("S112_20","010_12_20","1SA","12","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵍⴳⴻⵏⵙ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ! ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ-ⵢⴰ, ⵎⴰⵛⴰ ⵃⴹⴰⵎ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⵃⴻⵢⵢⴰⴷⴻⵎ ⵛⴰ ⵄⴰⴷ ⵣⵉ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S112_21","010_12_21","1SA","12","21","21","ⵡⴰⵔ ⵜⵜⵃⴻⵢⵢⴰⴷⴻⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼ ⵜⴹⴰⴼⴼⴰⵔⴻⵎ ⵍ’ⴰⵚⵏⴰⵎ ⵉⵅⵡⴰⵏ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ ⵓ ⵡⴰⵔ ⵉⵜⵜⴼⴻⴽⴽⵉⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⵅⵡⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S112_22","010_12_22","1SA","12","22","22","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵙⴻⵎⵎⴻⵃ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴳⴳ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S112_23","010_12_23","1SA","12","23","23","ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵛⵇⴰⵏ, ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⴰⵇⴰ ⴰⴷ ⵅⴹⵉⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓⵎⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵜⵥⴰⴵⵉⵜ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⴰⴱⵔⵉⴷ ⵉⵚⴻⴱⵃⴻⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S112_24","010_12_24","1SA","12","24","24","ⵎⵖⵉⵔ, ⴳⴳⵯⴻⴷⴻⵎ ⵙⵉⴷⵉ, ⵙⴻⵅⵅⴰⵔⴻⵎ ⵅⴰⵙ ⵙ ⵍⵎⴰⵏⴻⵜ ⵙ ⵡⵓⵍ ⵏⵡⴻⵎ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔⴻⵎ, ⵎⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵏⴻⵜⵜⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("S112_25","010_12_25","1SA","12","25","25","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵔⵏⵉⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵅⴻⵏⵏⵉ ⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ ⴰⴷ ⵜⵀⴻⵍⵍⴽⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("S113_1","010_13_1","1SA","13","1","1","ⵜⵓⵖⴰ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S113_2","010_13_2","1SA","13","2","2","ⵛⴰⵡⵓⵍ ⵉⴼⴰⵔⵣ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⴰⵍⴼⴰⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⴷⵉ ⵎⵉⵅⵎⴰⵙ ⵓ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⴱⴰⵢⵜ-ⵉⵍ, ⵓ ⴰⵍⴻⴼ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵢⵓⵏⴰⵜⴰⵏ ⴷⵉ ⵊⵉⴱⵄⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵅⵓ ⴰⵙ ⵉⵊⵊ ⵉⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S113_3","010_13_3","1SA","13","3","3","ⵢⵓⵏⴰⵜⴰⵏ ⵉⵖⵍⴻⴱ ⵅ ⵜⴻⵛⴱⴰⵔⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵊⵉⴱⵄⴰ, ⵓⵛⴰ ⵙⵍⴰⵏ ⵅⴰⵙ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵛⴰⵡⵓⵍ ⴰⴷ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵜ ⵙⵍⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("S113_4","010_13_4","1SA","13","4","4","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵍⴰ ⴰⴱⴰⵔⵔⴻⵃ-ⴰ: “ⵛⴰⵡⵓⵍ ⵉⵖⵍⴻⴱ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵛⴱⴰⵔⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⴰⵔⵣⴻⴳ ⵉⵙⵔⴰⵉⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S113_5","010_13_5","1SA","13","5","5","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⵙⵎⵓⵏⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ, ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵓ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵎⵉⵅⵎⴰⵙ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⴱⴰⵢⵜ-ⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S113_6","010_13_6","1SA","13","6","6","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⴰ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵎⵉⵏⵣⵉ ⵓⵥⵥⵍⴻⵏ ⵅ ⵍⴳⴻⵏⵙ. ⵓⵛⴰ ⵉⵏⵏⵓⴼⴰⵔ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵓ ⴷⴻⴳ ⵉⴼⴻⴵⴰⵇⴻⵏ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵓ ⴷⵉ ⵜⵚⵓⴹⴰⵔ ⵓ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵜⵏⵓⴼⴼⵔⴰ ⵓ ⴷⴻⴳ ⵡⴰⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S113_7","010_13_7","1SA","13","7","7","ⵥⵡⴰⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⴰⴷ ⴷ ⵊⵉⵍⵄⴰⴷ. ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵄⴰⴷ ⴷⵉ ⵊⵉⵍⵊⴰⵍ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S113_8","010_13_8","1SA","13","8","8","ⵏⴻⵜⵜⴰ ⵉⵔⴰⵊⴰ ⴷⵉ ⵊⵉⵍⵊⴰⵍ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍ ⵍⵡⴻⵇⵜ ⵉ ⵉⴳⴳⴰ ⵛⴰⵎⵡⵉⵍ. ⵎⴰⵛⴰ ⵓⵎⵉ ⵛⴰⵎⵡⵉⵍ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ, ⴰⵇⴰ ⵉⴱⴻⵣⵣⴻⵄ ⵍⴳⴻⵏⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵢⵓⵔⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S113_9","010_13_9","1SA","13","9","9","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⴰⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⴷⴰ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ!” ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("S113_10","010_13_10","1SA","13","10","10","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵙ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵛⴰⵎⵡⵉⵍ. ⵛⴰⵡⵓⵍ ⵉⴼⴼⴻⵖ ⴰⴷ ⵜ ⵉⵍⵇⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴱⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S113_11","010_13_11","1SA","13","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ?” ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵥⵔⵉⵖ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵢⵓⵢⵓⵔ ⴰⵢⵉ ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵄⴰⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓⵛⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵏⵊⴰⵔⵡⴻⵏ ⵖⴰⵔ ⵎⵉⵅⵎⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("S113_12","010_13_12","1SA","13","12","12","ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ‘ⵍⴻⵅⵅⵓ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵀⵡⴰⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴰⵡⴳⴻⵖ ⵄⴰⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ!’. ⵅ ⵓⵢⴰ ⵓⵛⵉⵖ ⴰⵇⴰ ⴷⵉⵏ ⴰⵖⵉⵍ ⵅⴰⴼⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("S113_13","010_13_13","1SA","13","13","13","ⵛⴰⵎⵡⵉⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵛⴰⵡⵓⵍ: “ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ. ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵛⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵛⴻⴷⴷ ⵍⴻⵅⵅⵓ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵛ ⵅ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S113_14","010_13_14","1SA","13","14","14","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵛⴰ. ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⴰⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵛⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S113_15","010_13_15","1SA","13","15","15","ⵉⴽⴽⴰⵔ ⵛⴰⵎⵡⵉⵍ, ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵊⵉⵍⵊⴰⵍ ⵖⴰⵔ ⵊⵉⴱⵄⴰ ⴷⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵛⴰ ⵛⴰⵡⵓⵍ ⵉⵙⴻⴷⴷ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵛⴰ ⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S113_16","010_13_16","1SA","13","16","16","ⵛⴰⵡⵓⵍ, ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⵙⴻⵏ ⵉⴵⴰⵏ, ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵊⵉⴱⵄⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵓⵛⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⵉⵅⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S113_17","010_13_17","1SA","13","17","17","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵇⵟⴰⵟⵄⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵜⴰⵔⵔⴰ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵄⵓⴼⵔⴰ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵓⵄⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("S113_18","010_13_18","1SA","13","18","18","ⵓ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏⵏⴻⵖⵏⵉ ⵜⴰⵔⵔⴰ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵓ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵜⴰⵔⵔⴰ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵚⴰⴱⵓⵄⵉⵎ, ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S113_19","010_13_19","1SA","13","19","19","ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵣⵉⵍ, ⵎⵉⵏⵣⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵏⵏⴰⵏ: “ⵃⵉⵎⴰ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵙⵙⵉⴼ ⵏⵉⵖ ⵍⴰⵏⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("S113_20","010_13_20","1SA","13","20","20","ⵅ ⵓⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵇⵉⵎ ⵉⵀⴻⴽⴽⵡⴰ ⵖⴰⵔ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵇⴹⴻⵄ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵓⵣⵣⴰⵍ ⵏ ⵡⴻⵙⵖⴰⵔ ⵏⵏⴻⵙ, ⴷⴷⵓⵣⴰⵏ ⵏⵏⴻⵙ, ⵡⵓⵣⵣⴰⵍ ⵏ ⵓⵣⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴷ ⵡⵓⵣⵣⴰⵍ ⵏ ⵜⵙⵉⵍⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S113_21","010_13_21","1SA","13","21","21","ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵉⵣⴻⵢⵏⴰⵜⴻⵏ ⵡⴰⵔ ⵉⵇⴹⵉⵄⴻⵏ ⵖⴰⵔ ⵡⵓⵣⵣⴰⵍ ⵏ ⵉⵙⵓⵖⴰⵔ ⵓ ⵖⴰⵔ ⴷⴷⵓⵣⴰⵏ ⵓ ⵖⴰⵔ ⵜⴰⵣⵣⴰⵔⵉⵏ ⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⵛⵓⴽⴹⴰⵏ ⵓ ⵖⴰⵔ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵏ ⵍⵎⴰⵛⴰⵎ ⵏ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S113_22","010_13_22","1SA","13","22","22","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵡⴰⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⵔⵉⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⴰⵇⴰ ⵜⵜⵡⴰⴼⴻⵏ ⵎⵖⵉⵔ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⴷ ⵢⵓⵏⴰⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S113_23","010_13_23","1SA","13","23","23","ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵎⵉⵅⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_1","010_14_1","1SA","14","1","1","ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵙⵏⴰⵃ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ!”, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜ ⵉⵏⵏⵉ ⵉ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_2","010_14_2","1SA","14","2","2","ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵊⵉⴱⵄⴰ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴰⵔⴻⵎⵎⴰⵎ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵎⵉⵖⵔⵓⵏ, ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⴷⴰⵢⴻⵙ ⵄⵍⴰⵃⴰⵍ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_3","010_14_3","1SA","14","3","3","ⴰⵅⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⵓⵎⴰⵙ ⵏ ⵉⵅⴰⴱⵓⴷ, ⵎⵎⵉⵙ ⵏ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵍⵉ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵛⵉⵍⵓ, ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ. ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴰⵇⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵜⵓⵖⴰ ⵢⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("S114_4","010_14_4","1SA","14","4","4","ⵊⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵯⵓ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉ ⵅ ⵜⵓⵖⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵥⵡⴰ ⵖⴰⵔ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵉⵇⴻⴹⵄⴻⵏ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵜⴻⵚⴹⴰⵔⵜ ⵉⵇⴻⴹⵄⴻⵏ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ⵉⵛⵜ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⴱⵓⵚⴰⵢⵚ ⴷ ⵉⵛⵜ ⵏⵏⴻⵖⵏⵉⵜ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵙⴰⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S114_5","010_14_5","1SA","14","5","5","ⵉⵛⵜ ⵏ ⵜⴻⵚⴷⴰⵔⵜ ⵉⵇⴻⴹⵄⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⵉⵅⵎⴰⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵙⴹⴰⵔⵜ ⵉⵇⴻⴹⵄⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵊⵉⴱⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("S114_6","010_14_6","1SA","14","6","6","ⵉⵏⵏⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵙⵏⴰⵃ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⴻⵙⴽⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⴳⴳ ⵙⵉⴷⵉ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵡⵄⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵙ ⵓⴼⵓⵙ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏⵉⵖ ⵙ ⵓⴼⵓⵙ ⵏ ⴷⵔⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("S114_7","010_14_7","1SA","14","7","7","ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ⵓⵢⵓⵔ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⴰⵎ ⵡⵓⵍ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S114_8","010_14_8","1SA","14","8","8","ⵢⵓⵏⴰⵜⴰⵏ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵏⴻⵙⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S114_9","010_14_9","1SA","14","9","9","ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⵏⵉⵏ: ‘ⴱⴻⴷⴷⴻⵎ ⴰⵍ ⵖⴰⵔⵡⴻⵎ ⴷⴷ ⵖⴰ ⵏⴰⵙ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵏⴻⵜⵜⴳⴻⵄⵄⵉⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S114_10","010_14_10","1SA","14","10","10","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⴳⴻⵄⵄⴷⴻⵎ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵏⴳⴻⵄⵄⴻⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵏⴻⵖ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵖ. ⴰⵢⴰ ⴰⴷ ⴰⵏⴻⵖ ⵢⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("S114_11","010_14_11","1SA","14","11","11","ⵍⴰⵎⵉ ⴷⴷ ⵙⴻⵛⵛⵏⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ: “ⵅⵣⴰⵔⴻⵎ, ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵅⵓⴱⴰⵛ ⵏⵙⴻⵏ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S114_12","010_14_12","1SA","14","12","12","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴰⵏ ⵉ ⵢⵓⵏⴰⵜⴰⵏ ⵓ ⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵙⵏⴰⵃ: “ⴳⴻⵄⵄⴷⴻⵎ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵏⴻⵙⵙⵉⵡⴻⴹ ⵍⴻⵅⴱⴰⵔ!” ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵉ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ: “ⴳⴻⵄⵄⴻⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S114_13","010_14_13","1SA","14","13","13","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵢⵓⵏⴰⵜⴰⵏ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⵓ ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵓⵛⴰ ⵡⴹⴰⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_14","010_14_14","1SA","14","14","14","ⵜⵉⵛⵜⵉ-ⵢⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⵣⵉ ⵉⵡⵜⴰ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵄⵍⴰⵃⴰⵍ ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵅ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉ ⵜⵓⵖⴰ ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵏ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⴰⴷ ⵜ ⵉⵛⴰⵔⵣ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_15","010_14_15","1SA","14","15","15","ⴰⵎⴻⵏⵏⵉ ⵜⵓⴷⴻⴼ ⵜⴰⵔⵊⵉⵊⴻⵜ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵅ ⵢⴻⵢⵢⴰⵔ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓ ⴷⴻⴳ ⵢⵉⵏⵏⵉ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⵓ ⵏ ⵉⴽⴻⵛⵛⴰⴹⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵡⴰⵀ, ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵏⵀⴻⵣⵣ. ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵄⵓⵔⵔⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("S114_16","010_14_16","1SA","14","16","16","ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵛⴰⵡⵓⵍ ⴷⵉ ⵊⵉⴱⵄⴰ ⴷⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵥⵔⵉⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⴱⴻⵣⵣⴻⵄ ⵍⵖⴰⵛⵉ, ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S114_17","010_14_17","1SA","14","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ: “ⴰⵔⵣⵓⵎ ⵅⴻⵏⵏⵉ ⵓ ⵅⵣⴰⵔⴻⵎ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴼⴼⵖⴻⵏ.” ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⵉⵏ ⴵⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_18","010_14_18","1SA","14","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⴰⵅⵉⵢⴰ: “ⴰⵡⵉ-ⴷⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵏⵉⵜⴰ!” ⵎⴰⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ . ");
INSERT INTO rift_vpl VALUES ("S114_19","010_14_19","1SA","14","19","19","ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ ⴰⴽ-ⴷ ⵓⴽⴻⵀⵀⴰⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⵖⴰⵛⵉ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉⴷⵡⴻⵍ ⵉⵏⵏⴻⵀⵡⴻⵍ ⴰⵟⵟⴰⵙ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵓⴽⴻⵀⵀⴰⵏ: “ⴼⴻⴽⴽ ⴰⴼⵓⵙ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("S114_20","010_14_20","1SA","14","20","20","ⵛⴰⵡⵓⵍ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ, ⴰⵇⴰ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵓⵏⴻⵏ, ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵓ ⵅⵣⴰⵔ, ⵙⵙⵉⴼ ⵏ ⵉⵊⵊⴻⵏ ⵜⵓⵖⴰ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⴰⵇⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_21","010_14_21","1SA","14","21","21","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵎⵎⵟⴰⵔⵔⵛⴻⵏ ⵊⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ. ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ ⴷ ⵢⵓⵏⴰⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_22","010_14_22","1SA","14","22","22","ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵙⵍⴰⵏ, ⴰⵇⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⴰⵔⴻⵡⵍⴻⵏ, ⵎⵓⵏⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_23","010_14_23","1SA","14","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴼⴻⴽⴽ ⵙⵉⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⴰⵎⴻⵏⵖⵉ ⵉⴼⴼⴻⵖ ⵓⵍⴰ ⵖⴰⵔ ⴱⴰⵢⵜ-ⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_24","010_14_24","1SA","14","24","24","ⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵔ ⵟⵟⴰⵔⴼ, ⵎⵉⵏⵣⵉ ⵛⴰⵡⵓⵍ ⵉⵊⵊⵓⴵ ⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵎⴰⵛⵛⴰ ⵇⴱⴻⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵏⵜⴰⵇⵎⴻⵖ ⵏⴻⵛⵛ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ!” ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵉⵛⵛⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_25","010_14_25","1SA","14","25","25","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴰⵎⵎⴻⵏⵜ ⵜⴻⵡⵙⴻⵄ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S114_26","010_14_26","1SA","14","26","26","ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⵎⵎⴻⵏⵜ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙ ⵓⴼⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⴳⴳⵯⴻⴷ ⵜⴰⵊⴰⴵⵉⵜ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S114_27","010_14_27","1SA","14","27","27","ⵎⴰⵛⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵙⵍⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵊⵓⴵ ⴱⴰⴱⴰⵙ ⵍⴳⴻⵏⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵓⵣⴻⴵⴰⴹ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵙⴻⵏ ⵉ-ⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵖⵔⴰⵚⵜ ⵏ ⵜⴰⵎⵎⴻⵏⵜ. ⵍⴰⵎⵉ ⵢⵉⵡⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵉⵣⴷⵉⴳⴻⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_28","010_14_28","1SA","14","28","28","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⴱⴰⴱⴰⵛ ⵉⵙⵙⵊⵓⴵ ⵍⴳⴻⵏⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵉⵏⵏⴰ: ‘ⴰⵔⵢⴰⵣ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵙⵙ-ⴰ ⴰⵖⵔⵓⵎ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ!’ ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴼⵏⴰ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("S114_29","010_14_29","1SA","14","29","29","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⵓⵏⴰⵜⴰⵏ: “ⴱⴰⴱⴰ ⵉⵖⴹⴻⵍ ⵜⴰⵎⵎⵓⵔⵜ ⴷⵉ ⴰⵔⵔⵥⵉⵢⵢⴻⵜ. ⵅⵣⴰⵔⴻⵎ ⵡⴰⵀⴰ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵜⵜⵛⴻⵄⵄⵍⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵇⵇⴰⵙⴻⵖ ⴷⵔⵓⵙⵜ ⵣⵉ ⵜⴰⵎⵎⴻⵏⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S114_30","010_14_30","1SA","14","30","30","ⵉⵃⵍⴰ ⴰⵙⴻⵏ ⵎⵍⵉ ⵉⵛⵛⴰ ⵍⴳⴻⵏⵙ ⵎⵍⵉⵃ ⴰⵙⵙ-ⴰ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵉⵟⵟⴻⴼ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵍⴻⵅⵅⵓ ⵜⵉⵛⵜⵉ ⵉ ⵣⵉ ⵡⵜⵉⵏ ⵏⵉⵜⵏⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("S114_31","010_14_31","1SA","14","31","31","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⵜⵉⵏ ⵏⵉⵜⵏⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵣⵉ ⵎⵉⵅⵎⴰⵙ ⴰⵍ ⴰⵢⴰⵍⵓⵏ, ⵓ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⴼⵏⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S114_32","010_14_32","1SA","14","32","32","ⵍⴳⴻⵏⵙ ⵉⵄⴻⵎⵎⴻⴷ ⵅ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵓ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵓⵛⴰ ⵖⴰⵔⵚⴻⵏ ⴰⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵍⴳⴻⵏⵙ ⵉⵛⵛⴰ ⴰⵢⵙⵓⵎ ⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_33","010_14_33","1SA","14","33","33","ⵙⵙⴰⵔⴳⴱⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵛⴰⵡⵓⵍ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵉⵅⴹⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⴰⵢⵙⵓⵎ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⴷⴷⴰⵔⴻⵎ. ⵙⴻⵇⵏⵓⵏⵏⵉⵢⴻⵎ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵙⵙ-ⴰ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("S114_34","010_14_34","1SA","14","34","34","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵄⴰⵡⴻⴷ: “ⴱⴻⵣⵣⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ⵜⵉⵏⵉⵎ ⴰⵙⴻⵏ: ‘ⴻⵊⵊ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵢⴰⵡⵉ ⴰⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ, ⵓ ⴻⵊⵊ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵢⴰⵡⵉ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵏⵏⴻⵙ. ⵖⴰⵔⵚⴻⵎ ⴰⵙⴻⵏ ⴷⴰ, ⵛⵛⴻⵎ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵅⴻⵟⵟⵉⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓⵎⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⵙ ⵉⴷⴰⵎⵎⴻⵏ.” ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵢⵉⵡⵉ-ⴷⴷ ⴰⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ ⵙ ⵓⴼⵓⵙ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵖⴰⵔⵚⴻⵏ ⴰⵙ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S114_35","010_14_35","1SA","14","35","35","ⵓⵛⴰ ⵛⴰⵡⵓⵍ ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵄⴰⵍⵟⴰⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S114_36","010_14_36","1SA","14","36","36","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵀⵡⴰ ⴵⵉⵍⴻⵜ-ⴰ, ⴰⴷ ⵏⴻⴹⴼⴰⵔ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵏⴽⴻⵛⵛⴻⴹ ⴰⵍ ⵜⵓⴼⴼⵓⵜ ⵏ ⵚⵚⴱⴻⵃ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵏᵉⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⴷⴷⴰⵔ ⵄⴰⴷ.” ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ “ⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ⵎⴰⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵉⵏⵏⴰ: “ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵏⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("S114_37","010_14_37","1SA","14","37","37","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵛⴰⵡⵓⵍ ⴰⵔⴻⴱⴱⵉ “ⵎⴰ ⴰⴷ ⵀⵡⵉⵖ, ⴰⴷ ⴹⴼⴰⵔⴻⵖ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ? ⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ?” ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S114_38","010_14_38","1SA","14","38","38","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⴰⵙⴻⵎ-ⴷⴷ ⴷⴰ, ⵎⴰⵔⵔⴰ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵙⵏⴻⵎ ⵓ ⵅⵣⴰⵔⴻⵎ, ⵎⵉⵏ ⴷⵉ ⵉⴵⴰ ⴷⴷⵏⵓⴱ-ⴰ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S114_39","010_14_39","1SA","14","39","39","ⵎⵉⵏⵣⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵎⵎⵉ ⵢⵓⵏⴰⵜⴰⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵏⵉⵛⴰⵏ.” ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S114_40","010_14_40","1SA","14","40","40","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ, ⵏⴻⵛⵛ ⴷ ⵎⵎⵉ ⵢⵓⵏⴰⵜⴰⵏ ⴰⴷ ⵏⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ.” ⵍⴳⴻⵏⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵛⴰⵡⵓⵍ: “ⴻⴳⴳ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S114_41","010_14_41","1SA","14","41","41","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ “ⴰⵔⵔ-ⴷⴷ ⵅⴰⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵏ ⵏⵉⵛⴰⵏ!” ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("S114_42","010_14_42","1SA","14","42","42","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⵏⴹⴰⵔⴻⵎ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵊⴰⵔ ⴰⵢⵉ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉ ⵢⵓⵏⴰⵜⴰⵏ!” ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵢⵓⵏⴰⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_43","010_14_43","1SA","14","43","43","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵢⵓⵏⴰⵜⴰⵏ: “ⵉⵏⵉ ⴰⵢⵉ, ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ!” ⵢⵓⵏⴰⵜⴰⵏ ⵉⵃⴰⵊⴰ ⴰⵙ ⵜ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵇⵇⴰⵙⴻⵖ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵏ ⵜⴰⵎⵎⴻⵏⵜ ⵙ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵓⵥⴻⴵⴰⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵎⵎⵜⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("S114_44","010_14_44","1SA","14","44","44","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⴻⵊⵊ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⴰⵔⴻⴱⴱⵉ ⵜⴰ ⴷ ⵜⴰ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⵇⵇⴻⵖ ⵎⵉⵏⵣⵉ ⵛⴻⴽ, ⵢⵓⵏⴰⵜⴰⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵏⵉⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S114_45","010_14_45","1SA","14","45","45","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ ⵉ ⵛⴰⵡⵓⵍ: “ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵢⵓⵏⴰⵜⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵉⵙⵔⴰⵉⵍ? ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⵙⵙⵉⵡⴻⵍ! ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵡⴻⵟⵟⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵓⵥⴻⵟⵟⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴰⵙⵙ-ⴰ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ.” ⴰⵎⵎⵓ ⵉ ⵉⴼⴻⴽⴽ ⵍⴳⴻⵏⵙ ⵉ ⵢⵓⵏⴰⵜⴰⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S114_46","010_14_46","1SA","14","46","46","ⵛⴰⵡⵓⵍ ⵉⵙⵎⴻⵃ ⴷⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_47","010_14_47","1SA","14","47","47","ⵓⵛⴰ ⵛⴰⵡⵓⵍ ⵉⵟⵟⴻⴼ ⵜⴰⴳⴻⵍⴷⴰ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ: ⴰⴽ-ⴷ ⵎⵓ’ⴰⴱ, ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴰⴽ-ⴷ ⵉⴷⵓⵎ, ⴰⴽ-ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵚⵓⴱⴰ ⵓ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵎⴰⵏⵉ ⵎⴰ ⵢⴰⵔⵔⴰ ⵙ ⵓⵣⴻⴵⵉⴼ, ⵢⵉⵡⵉ-ⴷⴷ ⴰⵖⴻⵍⵍⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("S114_48","010_14_48","1SA","14","48","48","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ⵉⵖⵍⴻⴱ ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵓ ⵉⴼⴻⴽⴽ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵉⴽⴻⵛⵛⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S114_49","010_14_49","1SA","14","49","49","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⵢⵉⵛⵡⵉ ⴷ ⵎⴰⵍⴽⵉⵛⵓⵄⴰ. ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ ⴷ ⵎⵉⵔⴰⴱ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⴻⵏⵣⵓⵜ, ⵓ ⵉⵙⴻⵎ ⵏ ⵜⵎⴰⵥⵓⵥⵜ ⴰⵇⴰ ⴷ ⵎⵉⵅⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S114_50","010_14_50","1SA","14","50","50","ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵅⵉⵏⵓⵄⴰⵎ, ⵢⴻⴵⵉⵙ ⵏ ⴰⵅⵉⵎⴰⵄⴰⵚ. ⵓⵛⴰ ⵉⵙⴻⵎ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴷ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⵄⴻⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S114_51","010_14_51","1SA","14","51","51","ⵇⵉⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵓ ⵏⵉⵔ, ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⴰⴱⵏⵉⵔ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⴱⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S114_52","010_14_52","1SA","14","52","52","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉⵡⵄⴰⵔ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵎⵉⵏ ⵉⴽⴽⴰ ⵉⴷⴷⴰⵔ ⵛⴰⵡⵓⵍ. ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉ ⵉⵥⵔⴰ ⵛⴰⵡⵓⵍ, ⵉⴽⵙⵉ ⵉ-ⵜ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S115_1","010_15_1","1SA","15","1","1","ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴰ ⵉ ⵛⴰⵡⵓⵍ: “ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴷⴻⵀⵏⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵅ ⵉⵙⵔⴰⵉⵍ. ⵙⴻⵍ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S115_2","010_15_2","1SA","15","2","2","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵎⵉⵏ ⵉⴳⴳⴰ ⵄⴰⵎⴰⵍⵉⵇ ⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵉⴱⴻⴷⴷ ⴰⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S115_3","010_15_3","1SA","15","3","3","ⴽⴽⴰⵔ ⵍⴻⵅⵅⵓ ⵓ ⵡⵡⴻⵜ ⵄⴰⵎⴰⵍⵉⵇ. ⵃⴰⵔⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉ ⵓⵜⴻⵃⵃⵉ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵃⵉⵡⵉⵍ ⵛⴰ, ⵎⴰⵛⴰ ⵏⴻⵖ ⵎⴰⵔⵔⴰ, ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⴰⵍ ⵜⴻⵎⵖⴰⵔⵜ, ⵣⴻⴳ ⵓⵃⴻⵏⵊⵉⵔ ⴰⵍ ⴰⵙⴻⵢⵎⵉ, ⵣⴻⴳ ⵓⴼⵓⵏⴰⵙ ⴰⵍ ⵓⴵⵉ, ⵣⴻⴳ ⵡⴻⵍⵖⴻⵎ ⴰⵍ ⴰⵖⵢⵓⵍ!’” ");
INSERT INTO rift_vpl VALUES ("S115_4","010_15_4","1SA","15","4","4","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵛⴰⵡⵓⵍ ⵅ ⵍⴳⴻⵏⵙ. ⵉⵙⴻⴷⴷ ⵉ-ⵜⴻⵏ ⴷⵉ ⵟⴰⵍⴰⵢⵉⵎ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⴷ ⵜⴻⵏⵄⴰⵛ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S115_5","010_15_5","1SA","15","5","5","ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ, ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("S115_6","010_15_6","1SA","15","6","6","ⵓⵛⴰ ⵛⴰⵡⵓⵍ ⵉⵊⵊⴰ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ: “ⴼⴼⵖⴻⵎ, ⴱⴻⵄⵄⴷⴻⵎ, ⵙⴻⵎⵃⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵄⴰⵎⴰⵍⵉⵇ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴻⵃⵃⵉⵖ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ.” ⵅⴰⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("S115_7","010_15_7","1SA","15","7","7","ⵅⴻⵏⵏⵉ ⵉⵖⵍⴻⴱ ⵛⴰⵡⵓⵍ ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵣⵉ ⵃⴰⵡⵉⵍⴰ ⴰⵍ ⵛⵓⵔ ⵉ ⵉⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S115_8","010_15_8","1SA","15","8","8","ⴰⵊⴰⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵎⴰⵍⵉⵇ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵉⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S115_9","010_15_9","1SA","15","9","9","ⵎⴰⵛⴰ ⵛⴰⵡⵓⵍ ⴷ ⵍⴳⴻⵏⵙ ⵃⴰⵡⵍⴻⵏ ⵅ ⴰⵊⴰⵊ ⵓⵍⴰ ⵅ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵓ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵣⵎⴰⵔⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵜⴰⴷⵓⵏⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵇⴰⵄ. ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵔⵓⵙ ⴷ ⵎⵉⵏ ⵉⴹⴻⵄⴼⴻⵏ, ⵃⴰⵔⵔⵎⴻⵏ ⵜ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("S115_10","010_15_10","1SA","15","10","10","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵛⴰⵎⵡⵉⵍ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("S115_11","010_15_11","1SA","15","11","11","“ⵏⴻⵛⵛ ⵏⴻⴷⵎⴻⵖ, ⴰⵇⴰ ⴳⴳⵉⵖ ⵛⴰⵡⵓⵍ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵉⵙⵙⴻⵇⴼⴻⵍ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ.” ⵉⵏⵏⴻⵀⵡⴻⵍ ⵛⴰⵎⵡⵉⵍ, ⵉⵙⵖⵓⵢ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵜⵎⵓⵏ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S115_12","010_15_12","1SA","15","12","12","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵣⵉⵛ ⵉⴽⴽⴰⵔ ⵛⴰⵎⵡⵉⵍ, ⵢⵓⵢⵓⵔ ⴰⴷ ⵉⵍⵇⴰ ⵛⴰⵡⵓⵍ. ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵙ ⵉ ⵛⴰⵎⵡⵉⵍ, ⵏⵏⴰⵏ: “ⵛⴰⵡⵓⵍ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴽⴰⵔⵎⵉⵍ ⵓ ⵉⵙⵙⴱⴻⴷⴷ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵉⵄⴷⵓ, ⵉⵀⵡⴰ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("S115_13","010_15_13","1SA","15","13","13","ⵢⵓⵙⴰ-ⴷⴷ ⵛⴰⵎⵡⵉⵍ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⵓ ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵣⵉ ⵙⵉⴷⵉ! ⵏⴻⵛⵛ ⵙⵙⵇⴻⴼⵍⴻⵖ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S115_14","010_15_14","1SA","15","14","14","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵛⴰⵎⵡⵉⵍ: “ⴷ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵍⵃⴻⵙⵙ-ⴰ ⵏ ⵡⵓⴵⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵉ ⵜⵜⴻⵙⵍⵉⵖ?” ");
INSERT INTO rift_vpl VALUES ("S115_15","010_15_15","1SA","15","15","15","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵣⵉ ⵄⴰⵎⴰⵍⵉⵇ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵃⴰⵡⴻⵍ ⵅ ⵎⵓⵎⵎⵓ ⵏ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵇⴻⴷⴷⵎⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏⵃⴰⵔⵔⴻⵎ ⵉ-ⵜ ⵉ ⵓⵜⴻⵃⵃⵉ.” ");
INSERT INTO rift_vpl VALUES ("S115_16","010_15_16","1SA","15","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵛⴰⵡⵓⵍ: “ⵛⴼⴰ! ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵉⵏⵉⵖ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ.” ⵉⵏⵏⴰ ⴰⵙ ⵛⴰⵡⵓⵍ: “ⵙⵉⵡⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("S115_17","010_15_17","1SA","15","17","17","ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⵓⵎⵉ ⵜⴻⴵⵉⴷ ⵄⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰ ⵡⴰⵔ ⵜⴷⴻⵡⵍⴻⴷ ⵛⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⴷⵀⴻⵏ ⵙⵉⴷⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("S115_18","010_15_18","1SA","15","18","18","ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⵉ ⵛⴻⴽ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ, ⵃⴰⵔⵔⴻⵎ ⵉⵎⴻⴷⵏⴰⴱ ⵏⵏⵉ, ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ, ⵉ ⵓⵜⴻⵃⵃⵉ ⵓ ⵎⵏⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⴰⵍ ⵜⴻⵏ ⵖⴰ ⵜⴻⵇⴹⵉⴷ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("S115_19","010_15_19","1SA","15","19","19","ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⴻⵡⴹⵉⴹ ⵛⴻⴽ ⵅ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵓ ⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⵖⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("S115_20","010_15_20","1SA","15","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵛⵛ ⴽⴽⴻⵖ ⴰⴱⵔⵉⴷ ⵉ ⵅ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ ⴰⵊⴰⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵃⴰⵔⵔⵎⴻⵖ ⵜⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("S115_21","010_15_21","1SA","15","21","21","ⵍⴳⴻⵏⵙ ⵉⴽⵙⵉ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ, ⵎⵓⵎⵎⵓ ⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵢⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵊⵉⵍⵊⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("S115_22","010_15_22","1SA","15","22","22","ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴰ: “ⵎⴰ ⵜⴻⵄⵊⴻⴱ ⴰⵙ ⵉ ⵙⵉⴷⵉ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵙ ⵉⵄⵊⴻⴱ ⵓⵙⴻⴵⵉ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ? ⵅⵣⴰⵔ ⴰⵙⴻⴵⵉ ⵃⵙⴻⵏ ⵣⵉ ⵜⵖⴰⵔⵚⵜ ⵓ ⴰⵙⵃⴻⵙⵙⵉ ⵙ ⵜⴰⵢⵏⵉⵜ ⵃⵙⴻⵏ ⵣⵉ ⵜⴰⴷⵓⵏⵜ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S115_23","010_15_23","1SA","15","23","23","ⵎⵉⵏⵣⵉ ⴰⵖⴻⵡⵡⴻⵖ ⴰⵎ ⴷⴷⴻⵏⴱ ⵏ ⵓⵄⴻⵣⵣⴻⵎ, ⵓ ⵜⴰⵖⴻⵏⵏⴰⵏⵜ ⴰⵎ ⵡⴻⵄⴱⴰⴷ ⵏ ⵚⵚⴰⵏⴰⵎ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵉ ⵛⴻⴽ ⴰⵎ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S115_24","010_15_24","1SA","15","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵜⵄⴻⴷⴷⵉⵖ ⵅ ⵍⵓⵎⵓⵔ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴳⴳⵯⴻⴷⴻⵖ ⵣⵉ ⵍⴳⴻⵏⵙ ⵓ ⵙⵍⵉⵖ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S115_25","010_15_25","1SA","15","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵖⴼⴰⵔ ⴰⵢⵉ ⴷⴷⴻⵏⴱ ⵉⵏⵓ ⵓ ⴷⵡⴻⵍ ⴰⴽⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⴻⵊⴷⴻⵖ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S115_26","010_15_26","1SA","15","26","26","ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵛⴰⵡⵓⵍ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⴷⴻⴽ ⴷⵉⴽⴽⵯⵉⵍⴻⵖ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵙ ⵓⵢⴰ ⵙⵉⴷⵉ ⵉⵏⴹⴰⵔ ⵉ ⵛⴻⴽ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S115_27","010_15_27","1SA","15","27","27","ⵓⵎⵉ ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵢⵓⵢⵓⵔ, ⵉⵛⴻⴱⴱⴰⵔ ⴰⵙ ⵛⴰⵡⵓⵍ ⴷⵉ ⵜⵎⴰ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵛⴰⵔⵔⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("S115_28","010_15_28","1SA","15","28","28","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵛⴰⵎⵡⵉⵍ: “ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵛ ⵙⵉⴷⵉ ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵃⵙⴻⵏ ⵣⵣⴰⵢⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S115_29","010_15_29","1SA","15","29","29","ⵓⵍⴰ ⵍⵄⴰⴹⵉⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵡⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵛⴰ ⵓ ⵡⴰⵔ ⵉⵏⴷⵉⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴱⵏⴰⴷⴻⵎ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵏⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("S115_30","010_15_30","1SA","15","30","30","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ. ⴻⵡⵛ ⴰⵢⵉ ⵎⴰⵛⴰ ⴰⵡⴻⵇⵇⴰⵔ ⵣⵣⴰⵜ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵣⵣⴰⵜ ⵉ ⵉⵙⵔⴰⵉⵍ. ⴷⵡⴻⵍ ⴰⴽⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⴻⵊⴷⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S115_31","010_15_31","1SA","15","31","31","ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵛⴰⵎⵡⵉⵍ, ⵢⴰⵔⴻⴷⴷⴻⴼ ⵛⴰⵡⵓⵍ ⵓ ⵛⴰⵡⵓⵍ ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S115_32","010_15_32","1SA","15","32","32","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⴰⵡⵉ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵊⴰⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵄⴰⵎⴰⵍⵉⵇ. ⴰⵊⴰⵊ ⵢⵓⵢⵓⵔ ⵖⴰⵔⴻⵙ ⵙ ⴰⵔⵔⴰⵜⵓⵃ. ⵉⵏⵏⴰ ⴰⵊⴰⵊ ⴰⴽ-ⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵜⴰⵔⵣⵓⴳⵉ ⵏ ⵍⵎⴻⵡⵜ ⵜᵉⵜⵜⵡⴰⵃⴻⵢⵢⴻⴷ ⵅⴰⴼⵉ.” ");
INSERT INTO rift_vpl VALUES ("S115_33","010_15_33","1SA","15","33","33","ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴰ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵃⴰⵔⵔⴻⵎ ⵙⵙⵉⴼ ⵏⵏⴻⵛ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵃⴰⵔⵔⴻⵎ ⵢⴻⵎⵎⴰⵛ ⵊⴰⵔ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵅ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ.” ⵓ ⵛⴰⵎⵡⵉⵍ ⵉⵇⴻⵟⵟⴻⵙ ⴰⵊⴰⵊ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵊⵉⵍⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S115_34","010_15_34","1SA","15","34","34","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵛⴰⵎⵡⵉⵍ ⵖⴰⵔ ⵔⴰⵎⴰ ⵓ ⵛⴰⵡⵓⵍ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵊⵉⴱⵄⴰ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S115_35","010_15_35","1SA","15","35","35","ⵛⴰⵎⵡⵉⵍ ⵡⴰⵔ ⵉⵥⵔⵉ ⵄⴰⴷ ⵛⴰⵡⵓⵍ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵛⴹⴻⵏ ⵅ ⵛⴰⵡⵓⵍ. ⵓⵛⴰ ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵛⴰⵡⵓⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S116_1","010_16_1","1SA","16","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵎⴻⵛⵃⴰⵍ ⴷ ⴰⵛⴹⴰⵏ ⵉ ⵢⴻⴵⴰⵏ ⵄⴰⴷ ⵖⴰⵔⴻⴽ ⵅ ⵛⴰⵡⵓⵍ, ⵡⴻⵏⵏⵉ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ? ⵄⴻⵎⵎⴰⵔ ⵉⵛⵛ ⵏⵏⴻⵛ ⵙ ⵣⵣⴻⵛⵜ, ⵓⵛⴰ ⵜⵓⵢⵓⵔⴻⴷ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⵢⴰⵙⵙⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵎⵉⵏⵣⵉ ⵊⴰⵔ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⵇⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("S116_2","010_16_2","1SA","16","2","2","ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴷⵉⵏ ⵔⴰⵃⴻⵖ? ⵎⴰⵍⴰ ⵉⵙⴻⵍ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵛⴰⵡⵓⵍ, ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ.” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙⵉⴷⵉ: “ⴽⵙⵉ ⵉⵛⵜ ⵏ ⵜⵄⴻⵊⵎⵉⵜ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴰⴽⵉⴷⴻⴽ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵖ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("S116_3","010_16_3","1SA","16","3","3","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵄⴰⵔⴹⴻⴷ ⵅ ⵢⴰⵙⵙⴰ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅ ⵎⵉⵏ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ. ⵛⴻⴽ ⴰⴷ ⵜⴷⴻⵀⵏⴻⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("S116_4","010_16_4","1SA","16","4","4","ⵛⴰⵎⵡⵉⵍ ⵉⴳⴳⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ, ⵏⵏⴰⵏ: “ⵎⴰ ⵜⴰⵡⴰⵙⵉⵜ ⵏⵏⴻⵛ ⵙ ⵍⴻⵀⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("S116_5","010_16_5","1SA","16","5","5","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙ ⵍⴻⵀⵏⴰ. ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵖ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷ ⵚⵚⴻⴷⵇⴻⵜ ⵉ ⵙⵉⴷⵉ. ⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓ ⴰⵙⴻⵎ-ⴷⴷ ⴰⴽⵉⴷⵉ ⵖⴰⵔ ⵚⵚⴻⴷⵇⴻⵜ. ⵏⴻⵜⵜⴰ ⵉⵇⴻⴷⴷⴻⵙ ⵢⴰⵙⵙⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵄⴰⵔⴹ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("S116_6","010_16_6","1SA","16","6","6","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ, ⵉⵥⵔⴰ ⵏⴻⵜⵜⴰ ⵉⵍⵉⵢⴰⴱ ⵓⵛⴰ ⵉⵅⴰⵔⵔⴻⵚ: “ⴷ ⵡⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S116_7","010_16_7","1SA","16","7","7","ⵙⵉⴷⵉ ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⵉ ⵛⴰⵎⵡⵉⵍ: “ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔ ⵛⴰ ⵖⴰⵔ ⵡⴰⴷⴷⵓⴷ ⵏⵏⴻⵙ ⵓⵍⴰ ⵖⴰⵔ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵏ ⵜⵉⴷⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵏⴹⴰⵔⴻⵖ ⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵜⵜⵀⵉⵎⵎⵉ ⵛⴰ ⵎⵉⵏ ⵖⴰⵔ ⵉⵅⴻⵣⵣⴰⵔ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵡⴰⵍⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵜⵜⵡⴰⵍⴰ ⵓⵍ.” ");
INSERT INTO rift_vpl VALUES ("S116_8","010_16_8","1SA","16","8","8","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵢⴰⵙⵙⴰ ⵅ ⴰⴱⵉⵏⴰⴷⴰⴱ, ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵉⵄⴷⵓ ⵅ ⵛⴰⵎⵡⵉⵍ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵏⵉⵜⴰ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵜ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S116_9","010_16_9","1SA","16","9","9","ⵅⴰⵙ ⵓⵛⴰ ⵉⵊⵊⴰ ⵢⴰⵙⵙⴰ ⴰⴷ ⵅⴰⵙ ⵉⵄⴷⵓ ⵛⴰⵎⵎⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵏⵉⵜⴰ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵜ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S116_10","010_16_10","1SA","16","10","10","ⴰⵎⵎⵓ ⵉ ⵉⵊⵊⴰ ⵢⴰⵙⵙⴰ ⴰⴷ ⵄⴷⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵛⴰⵎⵡⵉⵍ, ⵎⴰⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴰ ⵉ ⵢⴰⵙⵙⴰ: “ⵉⵏⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⵅⴹⴰⵔ ⵛⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S116_11","010_16_11","1SA","16","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵢⴰⵙⵙⴰ: “ⵎⴰ ⴷ ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵛ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴰⵎⴰⵥⵓⵥ ⵉⵇⵇⵉⵎ ⵄⴰⴷ, ⴰⵇⴰ ⵢⴰⵔⴻⴽⴽⵡⴻⵙ ⵓⴵⵉ.” ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ ⵉ ⵢⴰⵙⵙⴰ: “ⵙⴻⴽⴽ ⵉⵊⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵇⵓⵡⵡⵉⵔ ⵛⴰ ⵉ ⵟⵟⴰⴱⵍⴰ ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("S116_12","010_16_12","1SA","16","12","12","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ ⵢⴰⵡⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵔⵔⵓⴱⵢⵓ ⵓ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵛⵏⴰⵏⵜ ⵓ ⵜⵓⵖⴰ ⴷ ⵎⵓⵚⴱⵉⵃ ⵉ ⵍⵅⴻⵣⵔⴰⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴽⴽⴰⵔ, ⴷⴻⵀⵏ ⵉ-ⵜ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷ ⵡⴰ.” ");
INSERT INTO rift_vpl VALUES ("S116_13","010_16_13","1SA","16","13","13","ⵓⵛⴰ ⵉⴽⵙⵉ ⵛⴰⵎⵡⵉⵍ ⵉⵛⵛ ⵙ ⵣⵣⴻⵛⵜ, ⵉⴷⴻⵀⵏ ⵉ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⴰⵢⵜⵎⴰⵙ. ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵉⵀⵡⴰ ⵅ ⴷⴰⵡⵓⴷ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷ ⵜⵙⴰⵡⴻⵏⵜ. ⵛⴰⵎⵡⵉⵍ ⵉⴽⴽⴰⵔ, ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵔⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("S116_14","010_16_14","1SA","16","14","14","ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵛⴰⵡⵓⵍ ⵓ ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵀ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("S116_15","010_16_15","1SA","16","15","15","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ: “ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵀ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S116_16","010_16_16","1SA","16","16","16","ⴻⵊⵊ ⴰⴷ ⵢⵉⵏⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵃⴰⴽⴰⵏ ⴷⵉ ⵍⴳⴰⵎⴱⵔⵉ. ⵎⴰⵍⴰ ⵉⵟⵟⴻⴼ ⵉ ⵛⴻⴽ ⵍⴰⵔⵢⴰⵃ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⵉ-ⵜ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵔⴰⵔ ⵏⴻⵜⵜⴰ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴷⵉ ⵍⴳⴰⵎⴱⵔⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("S116_17","010_16_17","1SA","16","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴰⵔⵣⵓⵎ ⴰⵢⵉ-ⴷⴷ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵉⵔⴰⵔⴻⵏ ⵎⵍⵉⵃ ⵅ ⵍⴳⴰⵎⴱⵔⵉ ⵓ ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴷⴰ ⵖⴰⵔⵉ!” ");
INSERT INTO rift_vpl VALUES ("S116_18","010_16_18","1SA","16","18","18","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵔⴰⵔ ⵎⵍⵉⵃ. ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵄⴻⵙⴽⴰⵔⵉ, ⵉⵙⵙⴻⵏ ⴰⴷ ⵉⵅⴹⴰⵔ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵡⴰⴷⴷⵓⴷ ⵓ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S116_19","010_16_19","1SA","16","19","19","ⵉⵙⵙⴻⴽⴽ ⵛⴰⵡⵓⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵙⴰ, ⵉⵏⵏⴰ: “ⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵎⵎⵉⵛ ⴷⴰⵡⵓⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵡⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("S116_20","010_16_20","1SA","16","20","20","ⵢⴰⵙⵙⴰ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵓⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵢⴰⵔⵜ ⵏ ⴱⵉⵏⵓ ⴷ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵎⵉⵙ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S116_21","010_16_21","1SA","16","21","21","ⴰⵎⵎⵓ ⴷⴷ-ⵢⵓⵙⴰ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⴰⵟⵟⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S116_22","010_16_22","1SA","16","22","22","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵢⴰⵙⵙⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⴻⵊⵊ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⵓⴼⴰ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("S116_23","010_16_23","1SA","16","23","23","ⵎⴻⵍⵎⵉ ⵎⴰ ⴷⴷ-ⵢⵓⵙⴰ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵛⴰⵡⵓⵍ, ⵉⴽⵙⵉ ⴷⴰⵡⵓⴷ ⵍⴳⴰⵎⴱⵔⵉ ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵜⵜⵉⵔⴰⵔ ⴷⴰⵢⴻⵙ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⴷ-ⵢⴰⵔⵔⵉⵏ ⵏⵏⴻⴼⵙ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵎⵍⵉⵃ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵃⴻⵢⵢⴻⴷ ⵅⴰⵙ ⴱⵓⵃⴱⴻⵍ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_1","010_17_1","1SA","17","1","1","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⵙⵎⵓⵏⴻⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓ ⵏⵉⵜⵏⵉ ⵏⵏⵢⴰⵔⵡⴻⵏ ⵖⴰⵔ ⵙⵓⴽⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵊⴰⵔ ⵙⵓⴽⵓ ⴷ ⵄⴰⵣⵉⵇⵇⴰ ⵖⴰⵔ ⴰⴼⴰⵙ-ⴷⴰⵎⵎⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S117_2","010_17_2","1SA","17","2","2","ⵓⵍⴰ ⴷ ⵛⴰⵡⵓⵍ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵢⴰⵔⵡⴻⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵍⴰ. ⵏⵉⵜⵏⵉ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_3","010_17_3","1SA","17","3","3","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⵉ ⵓ ⵜⴰⵖⵣⵓⵔⵜ ⵜⵓⵖⴰ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_4","010_17_4","1SA","17","4","4","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⴰⵣⴻⵄⵄⴰⵎ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵊⵓⵍⵉⵢⴰⵜ. ⵜⵓⵖⴰ-ⵜ ⵣⵉ ⵊⴰⵜ. ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S117_5","010_17_5","1SA","17","5","5","ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙⴽ ⵏ ⵏⵏⵃⴰⵙ, ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵙ ⵜⴻⵇⵛⵓⵔⵉⵏ. ⵜⵓⵖⴰ ⵍⴻⵡⵣⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_6","010_17_6","1SA","17","6","6","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵙⴻⵍⵇⴰⵏ ⵏ ⵉⴼⴰⴷⴷⴻⵏ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵓⵃⴻⵟⵟⵓ ⵏ ⵉⴹⴰⵔⴻⵏ ⵓ ⵊⴰⵔ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵙ ⵢⴰⵔⴱⵓ ⵉⵊⵊ ⵏ ⵓⵃⵔⵉⵛ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_7","010_17_7","1SA","17","7","7","ⴰⵄⵎⵓⴷ ⵏ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵅⴻⵢⵢⴻⴹ ⵓ ⵜⵉⵅⴻⴼⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵜⴻⵡⵣⴻⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵣⵡⴰⵔ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_8","010_17_8","1SA","17","8","8","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⴷⵉⵏ, ⵉⵍⴰⵖⴰ ⵉ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵓ ⵜⵙⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵓⵎⴻⵏⵖⵉ? ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵛⵛ ⴷ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵓ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ? ⴼⴰⵔⵣⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_9","010_17_9","1SA","17","9","9","ⵎⵍⵉ ⵅⴰⴼⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⴰⴷ ⴰⵢⵉ ⵉⵡⵡⴻⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⵔⴻⴱⵃⴻⵖ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵖⴻⵍⴱⴻⵖ, ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵖ, ⴰⴷ ⴰⵏⴻⵖ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("S117_10","010_17_10","1SA","17","10","10","ⵉⵏⵏⴰ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵄⴰⵡⴻⴷ: “ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵙⵜⴻⵀⵣⵉⵖ ⵣⴻⴳ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ‘ⴻⵡⵛ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ!’” ");
INSERT INTO rift_vpl VALUES ("S117_11","010_17_11","1SA","17","11","11","ⵛⴰⵡⵓⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵙⵍⴰⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵓⵛⴰ ⵏⵏⵅⴻⵍⵄⴻⵏ ⵓ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_12","010_17_12","1SA","17","12","12","ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵉⴼⵔⴰⵜⴰ, ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵙⵙⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵃⴻⵙⵙⴱⴻⵏ ⵜ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵊⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_13","010_17_13","1SA","17","13","13","ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵢⴰⵙⵙⴰ ⴹⴼⴰⵔⴻⵏ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵉⵍⵉⵢⴰⴱ, ⴰⵎⴻⵏⵣⵓ, ⵓ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⴰⴱⵉⵏⴰⴷⴰⴱ ⵓ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷ ⵛⴰⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("S117_14","010_17_14","1SA","17","14","14","ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⴷ ⴰⵎⴰⵥⵓⵥ ⵓⵛⴰ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵜⵓⵖⴰ ⴹⴼⴰⵔⴻⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S117_15","010_17_15","1SA","17","15","15","ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⵏⵏⵓⵎ ⵉⵜⵜⵔⴰⵃ ⴷⵉⵏⵏⵉ ⵓ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⴳⴳⵯⴻⵃ-ⴷⴷ ⵣⵉ ⵛⴰⵡⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("S117_16","010_17_16","1SA","17","16","16","ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵉⵙⵙⵛⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉⵏ, ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_17","010_17_17","1SA","17","17","17","ⵉⵏⵏⴰ ⵢⴰⵙⵙⴰ ⵉ ⵎⵎⵉⵙ ⴷⴰⵡⵓⴷ: “ⴽⵙⵉ ⵄⴰⴼⴰⴽ ⵉ ⴰⵢⵜⵎⴰⵛ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵜⴻⵖⵡⴰⵡⵉⵏ-ⴰ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ, ⴰⵡⵢⵉ ⵜⴻⵏⵜ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("S117_18","010_17_18","1SA","17","18","18","ⵓ ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⵓⵙⵙⵉ ⵏ ⵓⵖⵉ-ⵢⴰ ⴰⵡⵢⵉ ⵜⴻⵏⵜ ⵖⴰⵔ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴰⵍⴻⴼ. ⴰⵔⵣⵓ ⵅ ⵢⴰⵢⵜⵎⴰⵛ, ⵎⴰ ⵎⵍⵉⵃ ⵉ ⵉⴵⴰⵏ ⵓ ⴰⵡⵢⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵜ ⵏ ⵡⴻⴹⵎⴰⵏ ⴷ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⵜⵓⴷⴰⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("S117_19","010_17_19","1SA","17","19","19","ⵛⴰⵡⵓⵍ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S117_20","010_17_20","1SA","17","20","20","ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⵣⵉⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵉⵊⵊⴰ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵓ ⵢⵉⵡⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵜ ⵢⵓⵎⵓⵔ ⵢⴰⵙⵙⴰ. ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉ ⵉⴼⴼⴻⵖ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵓⵙⴻⴷⴷⵉ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴱⴷⴰⵏ ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_21","010_17_21","1SA","17","21","21","ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴷⴷⵉ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴷⴷⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_22","010_17_22","1SA","17","22","22","ⴷⴰⵡⵓⴷ ⵉⵊⵊⴰ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵏ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵓⵛⴰ ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔ ⵓⵙⴻⴷⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵓⵎⵉ ⴷⵉⵏ ⵢⵉⵡⴻⴹ, ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵢⴰⵢⵜⵎⴰⵙ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_23","010_17_23","1SA","17","23","23","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ, ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⵊⴰⵀⴻⴷ ⴰⵣⴻⵄⵄⴰⵎ ⵏⵏⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵊⵓⵍⵢⴰⵜ ⵣⵉ ⵊⴰⵜ, ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⴷ ⵉⵊⵊⴻⵏ ⵓ ⴷⴰⵡⵓⴷ ⵉⵙⵍⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_24","010_17_24","1SA","17","24","24","ⵓⵎⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ, ⴰⵔⴻⵡⵍⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_25","010_17_25","1SA","17","25","25","ⵏⵏⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⴰ ⵜⴻⵥⵔⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ? ⵏⴻⵜⵜⴰ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵖⴻⵍⴱⴻⵏ, ⴰⴷ ⵜ ⵢⴰⵔⵔ ⵓⵊⴻⴵⵉⴷ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵢⴻⴵⵉⵙ ⵓ ⴰⴷ ⵉⴽⴽⴻⵙ ⵅ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⴹⴹⴰⵔⵉⴱⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S117_26","010_17_26","1SA","17","26","26","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⴱⴻⴷⴷⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ-ⴰⵢⴰ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴽⴽⴻⵙ ⴰⵙⵜⴻⵀⵣⵉ ⵅ ⵉⵙⵔⴰⵉⵍ? ⵎⵉⵏ ⵉⵄⵏⴰ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ-ⴰⵢⴰ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⴰⵇⴰ ⵉⵙⵜⴻⵀⵣⴰ ⵅ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S117_27","010_17_27","1SA","17","27","27","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵍⴳⴻⵏⵙ ⵙ ⵡⴰⵡⴰⵍ ⴷ ⵉⵊⵊⴻⵏ, ⵏⵏⴰⵏ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵖⴻⵍⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S117_28","010_17_28","1SA","17","28","28","ⵓⵎⴰⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵍⵉⵢⴰⴱ ⵉⵙⵍⴰ ⴰⵙ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏ ⵉⵍⵉⵢⴰⴱ ⵅ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ-ⵜⴻⵀⵡⵉⴷ ⵛⴻⴽ ⴷⴰⵏⵉⵜⴰ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵓⵎⵉ ⵜⴻⵊⵊⵉⴷ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵏ ⵡⵓⴵⵉ ⴷⵉ ⵍⴻⵅⵍⴰ? ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵄⴻⴼⴼⴰⵔ ⵏⵏⴻⵛ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵀⵡⵉⴷ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("S117_29","010_17_29","1SA","17","29","29","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴳⴳⵉⵖ ⵍⴻⵅⵅⵓ ⵄⴰⵡⴻⴷ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵙⵙⴻⵇⵙⵉⵖ?” ");
INSERT INTO rift_vpl VALUES ("S117_30","010_17_30","1SA","17","30","30","ⵏⴻⵜⵜⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵅⴰⵙ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵙⵙⴻⵇⵙⴰ ⴰⵙⴻⵇⵙⵉ ⴷ ⵉⵊⵊⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵍⴳⴻⵏⵙ ⵙ ⵡⴰⵡⴰⵍ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⴰⵔⵔⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S117_31","010_17_31","1SA","17","31","31","ⵏⵉⵜⵏⵉ ⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰⵡⵓⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_32","010_17_32","1SA","17","32","32","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵛⴰⵡⵓⵍ: “ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵜⵜⴻⴼⵛⵉⵍ ⵡⵓⵍ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ. ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("S117_33","010_17_33","1SA","17","33","33","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵛⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ-ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵜᵉⵎⵎⴻⵏⵖⴻⴷ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⴰⵃⵓⴷⵔⵉ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵢⴰⵣ ⴰⵄⴻⵙⴽⴰⵔⵉ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S117_34","010_17_34","1SA","17","34","34","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵛⴰⵡⵓⵍ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴽⴽⵡⴻⵙ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ. ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⴷⴷⵓⴱ, ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵏ ⵜⵃⵉⵎⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("S117_35","010_17_35","1SA","17","35","35","ⵅⴻⵏⵏⵉ ⴹⴼⴰⵔⴻⵖ ⵜ, ⵡⵜⵉⵖ ⵜ ⵓ ⴼⴻⴽⴽⴻⵖ-ⴷⴷ ⵉⵣⵎⴰⵔ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⵍⴰⵎⵉ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴰⴽⵉⴷⵉ, ⵛⴻⴱⴱⴰⵔⴻⵖ ⴰⵙ ⴷⵉ ⵜⵎⴰⵔⵜ, ⵡⵜⵉⵖ ⵜ ⵓⵛⴰ ⵏⵖⵉⵖ ⵜ. ");
INSERT INTO rift_vpl VALUES ("S117_36","010_17_36","1SA","17","36","36","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵏⵖⴰ ⴰⵢⵔⴰⴷ ⵓⵍⴰ ⴷ ⴷⴷⵓⴱ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⴰⴽ-ⴷ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ-ⴰⵢⴰ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⴰⴷ ⴰⵙ ⵜⴻⵎⵙⴰⵔ ⴰⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵜⴻⵀⵣⴰ ⵣⴻⴳ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S117_37","010_17_37","1SA","17","37","37","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵄⴰⵡⴻⴷ: “ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵉⵛⴻⵇⵍⴰⴹⴻⵏ ⵏ ⵡⴰⵢⵔⴰⴷ ⵓ ⵣⴻⴳ ⵉⵛⴻⵇⵍⴰⴹⴻⵏ ⵏ ⴷⴷⵓⴱ, ⴰⴷ ⴰⵢⵉ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ-ⴰⵢⴰ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⴷⴰⵡⵓⴷ: “ⵓⵢⵓⵔ, ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("S117_38","010_17_38","1SA","17","38","38","ⵛⴰⵡⵓⵍ ⵉⵙⵙⵢⴰⵔⴹ ⵉ ⴷⴰⵡⵓⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵉⴳⴳⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙⴽ ⵏ ⵏⵏⵃⴰⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵉⵃⴻⵣⵣⴻⵎ ⴰⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S117_39","010_17_39","1SA","17","39","39","ⵉⵛⴻⴷⴷ ⴷⴰⵡⵓⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵉ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵏⵡⴰ ⴰⴷ ⵢⵓⵢⵓⵔ ⵛⵡⴰⵢⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜ ⵉⵇⴻⴵⴻⴱ ⵄⴻⵎⵎⴰⵔⵚ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵛⴰⵡⵓⵍ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴷⵉ ⵍⴻⵃⵡⴰⵢⴻⵊ-ⴰ, ⵡⴰⵔ ⵜⵜ ⵇⴻⴵⴱⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ!” ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏⵜ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S117_40","010_17_40","1SA","17","40","40","ⵉⴽⵙⵉ ⴰⵄⴻⴽⴽⴰⵣ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵅⴹⴰⵔ ⵅⴻⵎⵙⴰ ⵏ ⵉⵥⵔⴰ ⵉⵃⵏⵓⵏⵏⵢⴻⵏ ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵛⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵖⴰⵔⴻⵙ ⵜⵓⵖⴰ, ⵎⴰⵛⴰ ⵎⴰⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵢⴰⵡⴻⴹ ⴷⴻⵖⵢⴰ, ⵓ ⵜⵓⵖⴰ ⵉⴵⵉⵢ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_41","010_17_41","1SA","17","41","41","ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵢⵓⵢⵓⵔ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵣⵡⴰⵔ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_42","010_17_42","1SA","17","42","42","ⵓⵎⵉ ⴷⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⴻⵃⵇⴰⵔ ⵉ-ⵜ, ⵎⴰⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⴷ ⴰⵃⵓⴷⵔⵉ ⵄⴰⴷ, ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴰⵔⵔⵓⴱⵢⵓ ⴷ ⵎⵓⵚⴱⵉⵃ ⵉ ⵍⵅⴻⵣⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S117_43","010_17_43","1SA","17","43","43","ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵎⴰ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵇⵣⵉⵏ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵙ ⵉⴽⴻⵛⵡⴰⴹ?” ⵓⵛⴰ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵜⵓⵖⴰ ⵉⵏⴻⵄⵄⴻⵍ ⵅ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_44","010_17_44","1SA","17","44","44","ⵉⵏⵏⴰ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵄⴰⵡⴻⴷ ⵉ ⴷⴰⵡⵓⴷ: “ⴰⵙ-ⴷⴷ ⵖⴰⵔⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵚⴰⵔⴹⴻⵏ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("S117_45","010_17_45","1SA","17","45","45","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ: “ⵛⴻⴽ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵏⵙⴰ ⴷ ⵓⵃⵔⵉⵛ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵣⵉ ⵜⴻⵙⵜᵉⵀⴻⵣⵣⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S117_46","010_17_46","1SA","17","46","46","ⴰⵙⵙ-ⴰ ⴰⴷ ⵛⴻⴽ ⵉⴳⴳ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵖⴻⵍⴱⴻⵖ. ⴰⴷ ⴰⵛ ⴽⴽⵙⴻⵖ ⴰⵣⴻⴵⵉⴼ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⴰⴷ ⵡⵛⴻⵖ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵚⴰⵔⴹⴻⵏ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_47","010_17_47","1SA","17","47","47","ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ-ⴰ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⴼⴻⴽⴽⵉ ⵙ ⵙⵙⵉⴼ ⵓⵍⴰ ⵙ ⵍⴰⵏⵙⴰ, ⵎⴰⵖⴰⵔ ⴰⵎⴻⵏⵖⵉ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⴳⴳ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S117_48","010_17_48","1SA","17","48","48","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵉⴽⴽⴰⵔ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵙ ⵜⴰⵣⵍⴰ ⵓⵛⴰ ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔ ⵓⵙⴻⴷⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵍⴻⵄⴷⵓ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_49","010_17_49","1SA","17","49","49","ⵉⵡⵜⴰ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵜⴻⵛⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵉⴽⴽⴻⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ, ⵉⵃⴻⵊⵊⴰⵔ ⵉ-ⵜ ⵙ ⵉⴵⵉⵢ ⵓⵛⴰ ⵉⵍⵇⴻⴼ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⴷⵉ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ. ⴰⵥⵔⵓ ⵉⵏⴷⴻⴼ ⵉ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉⵡⴹⴰ ⵏⴻⵜⵜⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S117_50","010_17_50","1SA","17","50","50","ⴰⵎⵎⵓ ⵉ ⵉⵖⵍⴻⴱ ⴷⴰⵡⵓⴷ ⵅ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⴵⵉⵢ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ. ⵏⴻⵜⵜⴰ ⵉⵍⵇⴻⴼ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ, ⵉⵏⵖⴰ ⵉ-ⵜ. ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵉ ⴷⴰⵡⵓⴷ ⵇⴰⵄ ⵙⵙⵉⴼ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_51","010_17_51","1SA","17","51","51","ⵅⴻⵏⵏⵉ ⵢⵓⵣⵣⴻⵍ ⴷⴰⵡⵓⴷ ⴷⵉⵏ ⵖⴰⵔ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵓ ⵓⵎⵉ ⴷⴷ-ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⵙ, ⵉⵟⵟⴻⴼ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⵉⵊⴱⴻⴷ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵖⵔⴰⴼ, ⵉⵏⵖⴰ ⵉ-ⵜ, ⵓⵛⴰ ⵉⵇⴻⵙⵙ ⴰⵙ ⴰⵣⴻⴵⵉⴼ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ. ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵙⴻⵏ ⵉⵎⵎⵓⵜ, ⴰⵔⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S117_52","010_17_52","1SA","17","52","52","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⴽⴽⴰⵔⴻⵏ, ⵙⵖⵓⵢⴻⵏ ⴰⵍⴰⵖⵉ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵍ ⵊⴰⵜ ⵓ ⴰⵍ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵄⴰⵇⵔⵓⵏ. ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵡⴹⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵣⵉ ⵛⴰⵄⴰⵔⴰⵢⵉⵎ ⴰⵍ ⵊⴰⵜ ⴷ ⵄⴰⵇⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_53","010_17_53","1SA","17","53","53","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵙ ⵡⴻⵛⵏⴰⵇ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴽⴻⵛⵛⴹⴻⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S117_54","010_17_54","1SA","17","54","54","ⵉⴽⵙⵉ ⴷⴰⵡⵓⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ, ⵢⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵛⴰ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_55","010_17_55","1SA","17","55","55","ⵓⵎⵉ ⵉⵥⵔⴰ ⵛⴰⵡⵓⵍ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ, ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⴰⴱⵏⵉⵔ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ: “ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⵎⵉⵙ ⵓⵃⵓⴷⵔⵉ-ⵢⴰ?” ⴰⴱⵏⵉⵔ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S117_56","010_17_56","1SA","17","56","56","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵙⴻⵇⵙⴰ ⵅⴻⵏⵏⵉ ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⵎⵉⵙ ⵓⵃⵓⴹⵔⵉ-ⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("S117_57","010_17_57","1SA","17","57","57","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴷⴰⵡⵓⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵖⵍⴻⴱ ⵅ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ, ⵢⵉⵡⵢⵉ ⵜ ⴰⴽⵉⴷⴻⵙ ⴰⴱⵏⵉⵔ, ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⵖⴰⵔ ⵛⴰⵡⵓⵍ. ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⴰⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S117_58","010_17_58","1SA","17","58","58","ⵛⴰⵡⵓⵍ ⵉⵙⵙⴻⵇⵙⴰ ⵜ: “ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵎⵎⵉⵙ ⵛⴻⴽ, ⴰ ⴰⵃⵓⴷⵔⵉ?” ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⵎⵉⵙ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵏ ⵢⴰⵙⵙⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ.” ");
INSERT INTO rift_vpl VALUES ("S118_1","010_18_1","1SA","18","1","1","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴷⴰⵡⵓⴷ ⵍⵀⴰⵔⴷ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵓ ⵢⵓⵏⴰⵜⴰⵏ ⵉⵜⵜⴻⵅⵙ ⴷⴰⵡⵓⴷ ⴰⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_2","010_18_2","1SA","18","2","2","ⵛⴰⵡⵓⵍ ⵉⴽⵙⵉ ⵖⴰⵔⴻⵙ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓ ⵡⴰⵔ ⵜ ⵉⵊⵊⵉ ⵄⴰⴷ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_3","010_18_3","1SA","18","3","3","ⵢⵓⵏⴰⵜⴰⵏ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⴰⵎ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_4","010_18_4","1SA","18","4","4","ⵢⵓⵏⴰⵜⴰⵏ ⵉⴽⴽⴻⵙ ⴰⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴹ, ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⴷⴰⵡⵓⴷ, ⵓⵍⴰ ⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⴷ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⴷ ⵡⴻⴱⵢⴰⵙ ⵏⵏⴻⵙ ⵉ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("S118_5","010_18_5","1SA","18","5","5","ⴷⴰⵡⵓⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵎⴰⵏⵉ ⵎⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵛⴰⵡⵓⵍ. ⵜⵓⵖⴰ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵎⵍⵉⵃ ⴰⵍⴰⵎⵉ ⵜ ⵢⴰⵔⵔⴰ ⵛⴰⵡⵓⵍ ⵅ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵍⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S118_6","010_18_6","1SA","18","6","6","ⵅⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵓⵎⵉ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⴷⴰⵡⵓⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⴻⵖⵍⴻⴱ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴼⴼⵖⴻⵏⵜ-ⵉ-ⴷⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⵖⴻⵏⵏⵊⴻⵏⵜ ⵓ ⵛⴻⴹⵃⴻⵏⵜ ⵙ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ, ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⵙ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⴼⵉⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S118_7","010_18_7","1SA","18","7","7","ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⵔⵔⵉⵏⵜ ⵎⴻⵥⵔⵉ ⵏⵙⴻⵏⵜ, ⵖⴻⵏⵏⵊⴻⵏⵜ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵏⵏⴰⵏⵜ: “ⵛⴰⵡⵓⵍ ⵉⵖⵍⴻⴱ ⵅ ⵍⵓⵍⵓⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("S118_8","010_18_8","1SA","18","8","8","ⵛⴰⵡⵓⵍ ⵉⴼⴼⵓⴳⴻⵎ ⴰⵟⵟⴰⵙ. ⵜⵓⵖⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⵄⵉⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵡⵛⵉⵏⵜ ⵉ ⴷⴰⵡⵓⴷ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ, ⵎⴰⵛⴰ ⵡⵛⵉⵏⵜ ⴰⵢⵉ ⵎⵖⵉⵔ ⵍⵓⵍⵓⴼ. ⵎⴰⵛⴰ ⵜⴻⵇⵇⵉⵎ ⴰⵙ ⵎⵖⵉⵔ ⵜⴳⴻⵍⴷⴰ ⵡⴰⵀⴰ?” ");
INSERT INTO rift_vpl VALUES ("S118_9","010_18_9","1SA","18","9","9","ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⴻⵏⵏⴻⵊ ⵉⴱⴷⴰ ⵛⴰⵡⵓⵍ ⵉⵃⴻⵟⵟⴰ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S118_10","010_18_10","1SA","18","10","10","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵛⴰⵡⵓⵍ, ⵓ ⵉⴷⵡⴻⵍ ⵉⵜⵜⴻⴽⴽ ⵅ ⵓⵣⴻⴵⵉⴼ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵉⵔⴰⵔ ⴷⴰⵡⵓⴷ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⴳⴰⵎⴱⵔⵉ. ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⴰⵏⵙⴰ ⴷⴻⴳ ⵓⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_11","010_18_11","1SA","18","11","11","ⵛⴰⵡⵓⵍ ⵉⵏⴹⴰⵔ ⵍⴰⵏⵙⴰ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⵍⴻⵇⴼⴻⵖ ⴷⴰⵡⵓⴷ ⵓ ⴰⴷ ⵜ ⵙⴻⵎⵎⴰⵔⴻⵖ ⵖⴰⵔ ⵍⵃⵉⴹ.” ⵉⵣⴻⵎⵎⴰⵔ ⴷⴰⵡⵓⴷ ⴰⴷ ⴰⵙ ⵉⵅⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S118_12","010_18_12","1SA","18","12","12","ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵉ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵙⵎⴻⵃ ⴷⵉ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S118_13","010_18_13","1SA","18","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵛⴰⵡⵓⵍ ⴷⴰⵡⵓⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴰⵍⴻⴼ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵓ ⵉⵜⵜⴰⵔⴻⴳⴳⵯⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_14","010_18_14","1SA","18","14","14","ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵉⴼⵍⴻⵃ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_15","010_18_15","1SA","18","15","15","ⵓⵎⵉ ⵉⵥⵔⴰ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⴼⵍⴻⵃ, ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_16","010_18_16","1SA","18","16","16","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⵜⵜⴻⵅⵙⴻⵏ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵓ ⵉⵜⵜⴰⵔⴻⴳⴳⵯⴰⵃ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S118_17","010_18_17","1SA","18","17","17","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵎⵉⵔⴰⴱ, ⵢⴻⴵⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵇⴰⵄ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ⵎⵖⵉⵔ ⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⴹⴻⴳⴳⵯⴰⵍ ⵉⵎⵃⴻⴹ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵉ ⵏⴻⵛⵛ ⵓ ⵎⵏⴻⵖ ⵉⵎⴻⵏⵖⴰⵏ ⵏ ⵙⵉⴷⵉ.” ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ: “ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴹⵉⴷⴷ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S118_18","010_18_18","1SA","18","18","18","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵛⴰⵡⵓⵍ: “ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ ⴷ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵍⴰⴵ ⵏ ⴱⴰⴱⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("S118_19","010_18_19","1SA","18","19","19","ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵎⵉⵔⴰⴱ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵄⴰⴷⵔⵉⵢⵉⵍ ⵣⵉ ⵎⴰⵃⵓⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S118_20","010_18_20","1SA","18","20","20","ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵅⵙ ⴷⴰⵡⵓⴷ. ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵙ ⵜ ⵉ ⵛⴰⵡⵓⵍ ⵓ ⵜⵓⵖⴰ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⵛⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_21","010_18_21","1SA","18","21","21","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵜⵜ ⵡⵛⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴷⵡⴻⵍ ⴷ ⵍⴼⴻⵅ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ.” ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⴷⴰⵡⵓⴷ: “ⴰⵙⵙ-ⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵉⵏⵓ ⵙ ⵜⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S118_22","010_18_22","1SA","18","22","22","ⵢⵓⵎⵓⵔ ⵛⴰⵡⵓⵍ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⵉⵏⵉ: ‘ⴰⵇⴰ ⵛⴻⴽ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵜⵜⴻⵅⵙⴻⵏ ⵛⴻⴽ. ⵅⴻⵏⵏⵉ ⴷⵡⴻⵍ ⵍⴻⵅⵅⵓ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ.’” ");
INSERT INTO rift_vpl VALUES ("S118_23","010_18_23","1SA","18","23","23","ⵙⵙⵉⵡⵍⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵎⴰ ⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⵀⵡⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵊⵊ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ? ⵎⴰ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⴷ ⴰⵎⵓⵇⵍⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("S118_24","010_18_24","1SA","18","24","24","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ ⵃⴰⵊⴰⵏ ⴰⵙ ⵜ, ⵏⵏⴰⵏ: “ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵡⵓⴷ ⴰⵡⴰⵍⴻⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("S118_25","010_18_25","1SA","18","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ ⵉ ⴷⴰⵡⵓⴷ: ‘ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵄⵊⵉⴱ ⵚⵚⴰⴷⴰⵇ, ⵎⴰⵛⴰ ⵉⵄⵊⴻⴱ ⴰⵙ ⵎⵢⴰ ⵏ ⵍⴻⵄⴷⴰⵍⴻⵢⵢⴰⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵜⴰⵇⴻⵎ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ.” ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴰⴷ ⵉⵏⴻⵖ ⴷⴰⵡⵓⴷ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S118_26","010_18_26","1SA","18","26","26","ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵄⴰⵡⴷⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⴷⴰⵡⵓⴷ. ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⵛⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵍⵎⵉⵊⴰⵍ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S118_27","010_18_27","1SA","18","27","27","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ, ⵓⵛⴰ ⵉⵡⵜⴰ ⵏⴻⵜⵜⴰ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵢⵉⵡⵉ-ⴷⴷ ⴷⴰⵡⵓⴷ ⵍⴻⵄⴷⴰⵍⴻⵢⵢⴰⵜ ⵏⵙⴻⵏ ⵓ ⵙ ⵓⵢⴰ ⵙⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵇⴰⵄ ⵍⵇⴻⴷⴷ-ⴰ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵙ ⵛⴰⵡⵓⵍ ⵢⴻⴵⵉⵙ ⵎⵉⵅⴰⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S118_28","010_18_28","1SA","18","28","28","ⵛⴰⵡⵓⵍ ⵉⵥⵔⴰ ⵓ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵓ ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵅⵙ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("S118_29","010_18_29","1SA","18","29","29","ⵉⴷⵡⴻⵍ ⵛⴰⵡⵓⵍ ⵉⴳⴳⵯⴻⴷ ⵄⴰⴷ ⴽⵜⴰⵔ ⵣⵉ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵛⴰⵡⵓⵍ ⵉⴷⵡⴻⵍ ⴷ ⵍⴻⵄⴷⵓ ⵏ ⴷⴰⵡⵓⴷ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S118_30","010_18_30","1SA","18","30","30","ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵎⵙⴰⵔ, ⵎⴻⵍⵎⵉ ⵎⴰ ⴼⴼⵖⴻⵏ ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵢⴰⵔⴻⵏⵏⵉ ⵎⴰⵀⵓ ⴷⵉ ⵡⴻⴼⵍⴰⵃ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("S119_1","010_19_1","1SA","19","1","1","ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ ⵓ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵖⴻⵏ ⴷⴰⵡⵓⴷ. ⵎⴰⵛⴰ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵉⵙⵙⵄⵉⵣⵣ ⵅⴰⵙ ⴷⴰⵡⵓⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S119_2","010_19_2","1SA","19","2","2","ⵉⵃⴰⵊⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵅ ⵓⵢⴰ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⴱⴰⴱⴰ ⵛⴰⵡⵓⵍ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⵖ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵔⴰⵊⴰ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ. ⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵙⵏⴻⴼⴼⴰⵔ ⵓ ⵅⴻⵎⵎⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S119_3","010_19_3","1SA","19","3","3","ⵏⴻⵛⵛ ⴰⴷ ⴼⴼⵖⴻⵖ, ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⴰⴽ-ⴷ ⴱⴰⴱⴰ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵍⵉⴷ ⵛⴻⴽ. ⴰⴷ ⵅⴰⴽ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⴱⴰⴱⴰ, ⴰⴷ ⵅⵣⴰⵔⴻⵖ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵓⵔⴻⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴳⴱⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S119_4","010_19_4","1SA","19","4","4","ⵢⵓⵏⴰⵜⴰⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵜⵉⵣⵉ ⵏ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⴷⴷⴻⵏⴱ ⴷⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⴰⵡⵓⴷ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⴳⴳⵉ ⵛⴰ ⴷⴷⴻⵏⴱ, ⵓ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴻⴼⴹⴻⵍ ⵉ ⵛⴻⴽ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S119_5","010_19_5","1SA","19","5","5","ⵏⴻⵜⵜⴰ ⵉⵙⴻⴱⴱⴻⵍ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵖⵍⴻⴱ ⵅ ⵓⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵓ ⵙⵉⴷⵉ ⵢⵉⵡⵉⴹ ⵉⵊⵊ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⵓ ⵜⴼⴰⵔⵃⴻⴷ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵅⴹⵉⴷ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⴻⵏⵖⴻⴷ ⴷⴰⵡⵓⴷ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("S119_6","010_19_6","1SA","19","6","6","ⵛⴰⵡⵓⵍ ⵉⵙⵍⴰ ⵖⴰⵔ ⵢⵓⵏⴰⵜⴰⵏ ⵓ ⵛⴰⵡⵓⵍ ⵉⵊⵊⵓⴵ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⴻⵇⵇ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("S119_7","010_19_7","1SA","19","7","7","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵅ ⴷⴰⵡⵓⴷ, ⵉⵃⴰⵊⴰ ⴰⵙ ⵢⵓⵏⴰⵜⴰⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⵢⵓⵏⴰⵜⴰⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴰⵎ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("S119_8","010_19_8","1SA","19","8","8","ⵢⵉⵡⴻⴹ-ⴷⴷ ⵓⵎⴻⵏⵖⵉ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴷⴰⵡⵓⴷ, ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵀⴻⵜⵜⴻⴽ ⵉ-ⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S119_9","010_19_9","1SA","19","9","9","ⵎⴰⵛⴰ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⵙⵉⴷⵉ ⵉⵡⴹⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵅ ⵛⴰⵡⵓⵍ. ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵎⵏⴻⵄ ⵍⴰⵏⵙⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵉⵜⵜⵉⵔⴰⵔ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⴳⴰⵎⴱⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S119_10","010_19_10","1SA","19","10","10","ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵙⴻⵎⵎⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⵃⵉⴹ ⵙ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵏⴻⵙ ⴰⵙ ⵉ ⵛⴰⵡⵓⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⵍⵇⴻⴼ ⵍⵃⵉⴹ ⵙ ⵍⴰⵏⵙⴰ. ⴷⴰⵡⵓⴷ ⵢⴰⵔⵡⴻⵍ, ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴵⵉⵍⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S119_11","010_19_11","1SA","19","11","11","ⵉⵙⵙⴻⴽⴽ ⵛⴰⵡⵓⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵃⴹⴰⵏ ⵓ ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ. ⵎⴰⵛⴰ ⵎⵉⵅⴰⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵜⵃⴰⵊⴰ ⵅⴰⵙ ⵉ ⴷⴰⵡⵓⴷ, ⵜⴻⵏⵏⴰ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵏⵖⴻⴷ ⵜⵉⵡⴻⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("S119_12","010_19_12","1SA","19","12","12","ⵎⵉⵅⴰⵍ ⵜⴻⵙⵙⴻⵀⵡⴰ ⴷⴰⵡⵓⴷ ⵣⵉ ⵍⴽⴰⵣⵉ. ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ, ⵢⴰⵔⵡⴻⵍ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S119_13","010_19_13","1SA","19","13","13","ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵎⵉⵅⴰⵍ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵚⵚⴰⵏⴰⵎ, ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⵉ ⵇⴰⵎⴰ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵀⵉⴹⵓⵔⵜ ⵏ ⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹ ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵣⴻⴵⵉⴼ ⵓ ⵜⴻⴷⵍⴰ ⵉ-ⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("S119_14","010_19_14","1SA","19","14","14","ⵛⴰⵡⵓⵍ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵏⴻⵜⵜⴰ ⵉⵀⵍⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S119_15","010_19_15","1SA","19","15","15","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵛⴰⵡⵓⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵊⵊⴻⵏ ⵅ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴷⵉ ⵜⴰⵙⵙⵓⵜ ⵖⴰⵔⵉ ⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S119_16","010_19_16","1SA","19","16","16","ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵚⵚⴰⵏⴰⵎ ⴷⵉ ⵇⴰⵎⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵀⵉⴹⵓⵔⵜ ⵏ ⵛⵄⴰⵔ ⵏ ⵉⵖⴰⵢⴹ ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S119_17","010_19_17","1SA","19","17","17","ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵎⵉⵅⴰⵍ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵖⴷⴰⵔⴻⴷ ⴰⵎⵎⵓ, ⵜⴻⵊⵊⵉⴷ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⴰⴷ ⵢⴰⵔⵡⴻⵍ, ⴰⵍⴰⵎⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ?” ⵎⵉⵅⴰⵍ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵛⴰⵡⵓⵍ: “ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵏⵖⴻⵖ?’” ");
INSERT INTO rift_vpl VALUES ("S119_18","010_19_18","1SA","19","18","18","ⴰⵎⵎⵓ ⵢⴰⵔⵡⴻⵍ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵛⴰⵎⵡⵉⵍ ⴷⵉ ⵔⴰⵎⴰ, ⵉⵃⴰⵊⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵛⴰⵡⵓⵍ. ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵛⴰⵎⵡⵉⵍ, ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵏⴰⵢⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S119_19","010_19_19","1SA","19","19","19","ⵓⵛⴰ ⵃⴰⵊⴰⵏ ⴰⵢⴰ ⵉ ⵛⴰⵡⵓⵍ, ⵏⵏⴰⵏ: “ⴷⴰⵡⵓⴷ ⴰⵇⴰ-ⵜ ⴷⵉ ⵏⴰⵢⵓⵜ ⵖⴰⵔ ⵔⴰⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("S119_20","010_19_20","1SA","19","20","20","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵛⴰⵡⵓⵍ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⴷⴰⵡⵓⴷ. ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⵜⴰⵔⴱⵉⵄⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ. ⵜⵓⵖⴰ ⵛⴰⵎⵡⵉⵍ ⵉⴱⴻⴷⴷ ⵖⴰⵔⵙⴻⵏ ⴷ ⴰⵎⴻⵃⴹⴰⵢ, ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵛⴰⵡⵓⵍ ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⵏⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S119_21","010_19_21","1SA","19","21","21","ⵓⵎⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵢⴰ ⵉ ⵛⴰⵡⵓⵍ, ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⵏⴻⴱⴱⴰⵏ. ⵢⴰⵔⵏⵉ ⵛⴰⵡⵓⵍ ⴷⴻⴳ ⵓⵙⴻⴽⴽⵉ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⵏⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S119_22","010_19_22","1SA","19","22","22","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵔⴰⵎⴰ. ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵡⴰⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵙⵉⵅⵓ, ⵉⵙⵙⴻⵇⵙⴰ, ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⴵⴰⵏ ⵛⴰⵎⵡⵉⵍ ⴷ ⴷⴰⵡⵓⴷ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵏⴰⵢⵓⵜ ⵖⴰⵔ ⵔⴰⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("S119_23","010_19_23","1SA","19","23","23","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⵉⵏ ⵖⴰⵔ ⵏⴰⵢⵓⵜ ⵖⴰⵔ ⵔⴰⵎⴰ, ⵓ ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴰⵎ ⵉⵜⵜⵏⴻⴱⴱⴰ ⴰⵍ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵏⴰⵢⵓⵜ ⵖⴰⵔ ⵔⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("S119_24","010_19_24","1SA","19","24","24","ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰⵎⵡⵉⵍ. ⴰⵙⵙ ⵏⵏⵉ ⴷ ⴵⵉⵍⴻⵜ ⵜⵎⵓⵏ ⵉⵣⵣⴻⵍ ⴷⵉⵏ ⴷ ⴰⵇⴻⴷⴷⵉⴷ. ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ: “ⵎⴰ ⵓⵍⴰ ⴷ ⵛⴰⵡⵓⵍ ⵊⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S120_1","010_20_1","1SA","20","1","1","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵏⴰⵢⵓⵜ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵔⴰⵎⴰ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵢⵓⵏⴰⵜⴰⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴳⴳⵉⵖ ⵏⴻⵛⵛ? ⵎⴰⵏ ⵍⵊⴰⵔⵉⵎⴰ ⵉⵏⵓ ⴷ ⴷⴷⴻⵏⴱ ⵉ ⴷ ⴰⵙ ⴳⴳⵉⵖ ⵉ ⴱⴰⴱⴰⵛ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⴽⴽⴻⵙ ⵜⵓⴷⴰⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("S120_2","010_20_2","1SA","20","2","2","ⵉⵏⵏⴰ ⴰⵙ ⵢⵓⵏⴰⵜⴰⵏ: “ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⵙⵙⵉⵡⴻⵍ! ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⴷ ⵛⴰ. ⵅⵣⴰⵔ ⴱⴰⴱⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵡⴰⵍⵓ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵉⵖ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ, ⴱⵍⴰ ⵎⴰ ⵉ ⴷ ⴰⵢⵉ ⵜⵜ ⵖⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ. ⵎⴰⵢⴻⵎⵎⵉ ⴱⴰⴱⴰ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ? ⴰⵢⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("S120_3","010_20_3","1SA","20","3","3","ⵅⴻⵏⵏⵉ ⵉⵊⵊⵓⴵ ⴰⵙ ⴷⴰⵡⵓⴷ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵉⵏⵏⴰ: “ⴱⴰⴱⴰⵛ ⵉⵙⵙⴻⵏ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵓⴼⵉⵖ ⵍⵅⴰⴹⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ⵅ ⵓⵢⴰ ⵉⵏⵏⴰ: ‘ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵙⵙⴻⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵙ ⵡⴻⵎⵏⵓⵙ!’ ⵅ ⵓⵢⴰ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵍⵎⴻⵡⵜ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵓⵚⵓⵔⵉⴼ ⵡⴰⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("S120_4","010_20_4","1SA","20","4","4","ⵢⵓⵏⴰⵜⴰⵏ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵜ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S120_5","010_20_5","1SA","20","5","5","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵢⵓⵏⴰⵜⴰⵏ: “ⵅⵣⴰⵔ, ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⵓⵢⵓⵔ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵛⵛⴻⵖ. ⴻⵡⵛ ⴰⵢⵉ ⵜⵜⴻⵙⵍⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵓⴼⴼⴰⵔⴻⵖ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("S120_6","010_20_6","1SA","20","6","6","ⵎⴰⵍⴰ ⵢⴰⵔⵣⵓ ⵅⴰⴼⵉ ⴱⴰⴱⴰⵛ, ⵉⴼⵇⴻⴷ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⵉⵏⵉ: ‘ⴷⴰⵡⵓⴷ ⵉⵃⴻⵛⵛⴻⵎ ⴰⵢⵉ ⵙ ⵡⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⴷⴻⵖⵢⴰ, ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵎⵉⵏⵣⵉ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵎⴰⵔⵔⴰ ⵍⴰⴵ.’ ");
INSERT INTO rift_vpl VALUES ("S120_7","010_20_7","1SA","20","7","7","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: ‘ⵎⵍⵉⵃ!’, ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵢⴰⵔⵖⴰ ⵓⴼⵓⴳⴻⵎ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⴰⴷ ⴷ ⴰⵢⵉ ⵉⴳⴳ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S120_8","010_20_8","1SA","20","8","8","ⴻⴳⴳ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵉⵛⵜ ⵏ ⵍⵊⴰⵔⵉⵎⴰ, ⵏⴻⵖ ⴰⵢⵉ ⵛⴻⴽ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴰⵡⵢⴻⴷ ⵖⴰⵔ ⴱⴰⴱⴰⵛ?” ");
INSERT INTO rift_vpl VALUES ("S120_9","010_20_9","1SA","20","9","9","ⵉⵏⵏⴰ ⵢⵓⵏⴰⵜⴰⵏ: “ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴽ! ⵎⵉⵏⵣⵉ ⵡⴰⵅⵅⴰ ⴰⵔⴻⴳⴱⴻⵖ ⵅⴰⵙ, ⴰⵇⴰ ⴱⴰⴱⴰ ⵉⴳⴳⴰ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⴳⴳ ⵍⵖⴰⵔ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ ⵇⵇⴰⵔⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("S120_10","010_20_10","1SA","20","10","10","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵢⵓⵏⴰⵜⴰⵏ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵔⴻⵇⵇⴰⵙ, ⵎⴰⵍⴰ ⵉⵡⵛⴰ ⴰⵛ ⴱⴰⴱⴰⵛ ⵉⵛⵜ ⵏ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵜⴻⵇⵙⴻⵃ?” ");
INSERT INTO rift_vpl VALUES ("S120_11","010_20_11","1SA","20","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵉ ⴷⴰⵡⵓⴷ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ.” ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ, ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S120_12","010_20_12","1SA","20","12","12","ⵉⵏⵏⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵉ ⴷⴰⵡⵓⴷ: “ⵊⵊⵓⴵⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵉⵖ ⴼⴰⵔⵡⵉⵛⵛⴰ ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ, ⴰⵇⴰ ⵡⵜⵉⵖ ⵍⴻⵃⵙⴰⴱ ⴰⵎⵎⵓ ⴷ ⵡⴰⵎⵎⵓ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴱⴰⴱⴰ, ⵓⴼⵉⵖ ⴰⵇⴰ ⵎⵍⵉⵃ ⵉ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⴻⴽⴽⵉⵖ ⵃⴻⴷ ⴰⴷ ⴰⵛ ⵜ ⵢⵉⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("S120_13","010_20_13","1SA","20","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳ ⵙⵉⴷⵉ ⵜⴰ ⴷ ⵜⴰ ⵙ ⵢⵓⵏⴰⵜⴰⵏ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵎⵍⵉⵃ ⵉ ⴱⴰⴱⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⴳⴳ ⵍⵖⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵜ ⵉⵏⵉⵖ, ⴰⴷ ⵛⴻⴽ ⵊⵊⴻⵖ ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ ⵃⵉⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⵉ ⵍⴻⵀⵏⴰ. ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⴻⴽ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("S120_14","010_20_14","1SA","20","14","14","ⵓⵛⴰ ⵅⴰⴽ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⴰⵀⴰ ⴰⵎ ⴷⴷⴰⵔⴻⵖ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵅⴻⵏⵏⵉ ⵡⴰⵀⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵖ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("S120_15","010_20_15","1SA","20","15","15","ⵎⴰⵛⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜⵇⴻⵟⵟⵄⴻⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵓⵍⴰ ⵅⵎⵉ ⵖⴰ ⵉⵇⴹⴻⵄ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("S120_16","010_20_16","1SA","20","16","16","ⵓⵛⴰ ⵉⴳⴳⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵜⵜⴰⵔ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S120_17","010_20_17","1SA","20","17","17","ⵢⵓⵏⴰⵜⴰⵏ ⵉⵊⵊⴰ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⵊⵊⴰⴵ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ, ⴰⵇⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S120_18","010_20_18","1SA","20","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵢⵓⵏⴰⵜⴰⵏ: “ⵜⵉⵡⴻⵛⵛⴰ ⴷ ⴰⵢⵓⵔ ⴰⵎⴰⵢⵏⵓ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⵉⴼⴻⵏ, ⵎⴰⵖⴰⵔ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵛ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("S120_19","010_20_19","1SA","20","19","19","ⴰⵡⴰⵔⵏⵉ ⵄⴷⵓⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵀⵡⵉⴷ ⵇⴰⵄ, ⴰⴷ ⵜⵔⵓⵃⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵏⵏⵓⴼⴼⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵢⴰⵔⵣⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⵖ, ⵓ ⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵀⴰ’ⵉⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S120_20","010_20_20","1SA","20","20","20","ⵏⴻⵛⵛ ⴰⴷ ⵡⵜⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵣⵣⴰⵜⴻⵙ ⴰⵅⵎⵉ ⵅⵙⴻⵖ ⴰⴷ ⵍⴻⵇⴼⴻⵖ ⵜⴰⵏⴷⴰⵢⵜ. ");
INSERT INTO rift_vpl VALUES ("S120_21","010_20_21","1SA","20","21","21","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵃⵓⴷⵔⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏⵜ, ⴰⴷ ⴰⵙ ⵉⵏⵉⵖ: ‘ⵓⵢⵓⵔ, ⴰⵔⵣⵓ ⵅ ⴼⵍⵉⵜⵛⴰⵜ!’ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ ⵏⵉⵛⴰⵏ ⵉ ⵓⵃⵓⴷⵔⵉ: ‘ⵃⴹⴰ, ⴼⵍⵉⵜⵛⴰⵜ ⴰⵇⴰ ⵓⴷⵙⴻⵏⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵣⵉ ⵖⴰⵔⴻⴽ!’, ⵅⴻⵏⵏⵉ ⴰⵡⵢⵉ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ, ⴰⵙ-ⴷⴷ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⵀⵏⴰ ⵉ ⵛⴻⴽ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵡⴰⵍⵓ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("S120_22","010_20_22","1SA","20","22","22","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵓⵃⵓⴷⵔⵉ: ‘ⵅⵥⴰⵔ, ⴼⵍⵉⵜⵛⴰⵜ ⴰⵇⴰ ⴰⴳⴳⵯⴻⵊⴻⵏⵜ ⵅⴰⴽ ⵄⴰⴷ ⴽⵜⴰⵔ!’, ⵅⴻⵏⵏⵉ ⴰⴳⴳⵯⴻⵊ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽⴰ ⵛⴻⴽ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("S120_23","010_20_23","1SA","20","23","23","ⵓⵛⴰ ⵅ ⵡⴰⵡⴰⵍ ⵉ ⵏⴻⴽⴽⴻⵙ, ⵏⴻⵛⵛ ⴷ ⵛⴻⴽ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ ⵉ ⵍⴻⴱⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("S120_24","010_20_24","1SA","20","24","24","ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴷⴰⵡⵓⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵢⵓⵔ ⴰⵎⴰⵢⵏⵓ ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("S120_25","010_20_25","1SA","20","25","25","ⵜⵓⵖⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ-ⵢⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵉⵎⴻⵏⵙⵉⵢⵢⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⴷⵉ ⵍⴽⵓⵔⵙⵉ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵃⵉⴹ. ⵢⵓⵏⴰⵜⴰⵏ ⵉⴽⴽⴰⵔ ⵓ ⴰⴱⵏⵉⵔ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⴰⵡⵓⵍ ⵓ ⵍⴽⵓⵔⵙⵉ ⵏ ⴷⴰⵡⵓⴷ ⵉⴱⴰⵏ-ⴷⴷ ⵉⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("S120_26","010_20_26","1SA","20","26","26","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵛⴰⵡⵓⵍ ⵡⴰⵔ ⵉⵏⵉ ⵡⴰⵍⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ: “ⵉⵎⵙⴰⵔ ⴰⵙ ⵛⴰ ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ⴰⵇⴰ ⵏⵉⵛⴰⵏ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("S120_27","010_20_27","1SA","20","27","27","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⵓⵔ ⴰⵎⴰⵢⵏⵓ, ⵓⵎⵉ ⵉⵇⵇⵉⵎ ⵍⴽⵓⵔⵙⵉ ⵏ ⴷⴰⵡⵓⴷ ⵉⵅⵡⴰ ⵄⴰⵡⴻⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⵡⴰⵙⵙ-ⴰ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ?” ");
INSERT INTO rift_vpl VALUES ("S120_28","010_20_28","1SA","20","28","28","ⵢⵓⵏⴰⵜⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵛⴰⵡⵓⵍ: “ⴷⴰⵡⵓⴷ ⵉⵃⴻⵛⵛⴻⵎ ⴰⵢⵉ ⴰⵟⵟⴰⵙ ⵎⴰⵃⴻⵏⴷ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("S120_29","010_20_29","1SA","20","29","29","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴳⴳ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴰⴵ ⵏⵏⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵓⵎⴰ ⵉⴳⴳⴰ ⵅⴰⴼⵉ ⴰⴷ ⵃⴹⴰⵔⴻⵖ. ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵓⴼⵉⵖ ⵍⴻⵅⵅⵓ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⴰⵢⵜⵎⴰ.’ ⵅ ⵓⵢⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S120_30","010_20_30","1SA","20","30","30","ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⵖ ⵓⵅⴻⵢⵢⴻⵇ ⵏ ⵛⴰⵡⵓⵍ ⵅ ⵢⵓⵏⴰⵜⴰⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ, ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵖⴻⵏⵏⴰⵏ ⵉⴼⴰⵔⵖⴻⵏ, ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵎⵍⵉⵃ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵉⵅⴹⴰⵔⴻⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵛⴻⴽ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏ ⵢⴻⵎⵎⴰⵛ! ");
INSERT INTO rift_vpl VALUES ("S120_31","010_20_31","1SA","20","31","31","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵉⴷⴷⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵜⴱⴻⴷⴷⵉⴷ ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⴽⴽ ⵉⵊⵊⴻⵏ, ⴰⵡⵢⵉ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵍⵎⴻⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("S120_32","010_20_32","1SA","20","32","32","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⵓⵏⴰⵜⴰⵏ ⵅ ⴱⴰⴱⴰⵙ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⴻⵜⵜⴰ? ⵎⵉⵏ ⵉⴳⴳⴰ?” ");
INSERT INTO rift_vpl VALUES ("S120_33","010_20_33","1SA","20","33","33","ⵅⴻⵏⵏⵉ ⵉⵃⴻⵊⵊⴰⵔ ⵉ-ⵜ ⵛⴰⵡⵓⵍ ⵙ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵍⵇⴻⴼ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⴰⵇⴰ ⴱⴰⴱⴰⵙ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⵏⴻⵖ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S120_34","010_20_34","1SA","20","34","34","ⵉⴽⴽⴰⵔ ⵢⵓⵏⴰⵜⴰⵏ ⵅ ⵟⵟⴰⴱⵍⴰ ⵓⵎⵉ ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵛⵛⵉ ⴰⵖⵔⵓⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵓⵢⵓⵔ ⴰⵎⴰⵢⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴽⴻⵙⵙⵉ ⵙ ⵡⴻⵎⵏⵓⵙ ⵉ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰⵙ ⵜⵓⵖⴰ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ ⵉ-ⵜ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("S120_35","010_20_35","1SA","20","35","35","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵢⵓⵢⵓⵔ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⵉⴳⴳⴰ ⴰⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ ⵓ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵓⵃⵓⴷⵔⵉ ⴷ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S120_36","010_20_36","1SA","20","36","36","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵓⵃⵓⴷⵔⵉ: “ⵓⵢⵓⵔ, ⴰⵔⵣⵓ ⵅ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⵉ ⵖⴰ ⵡⵜⴻⵖ.” ⴰⵃⵓⴷⵔⵉ ⵢⵓⵣⵣⴻⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵉⵛⵜ ⵏ ⴼⵍⵉⵜⵛⴰ ⵜⴻⴽⴽⴰ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S120_37","010_20_37","1SA","20","37","37","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵃⵓⴷⵔⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⴼⵍⵉⵜⵛⴰ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵢⵓⵏⴰⵜⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵃⵓⴷⵔⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵡⴹⵉ ⴼⵍⵉⵜⵛⴰ ⵣⵣⴰⵢⴻⴽ ⴰⵖⵉⵔⵉⵏ ⵄⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("S120_38","010_20_38","1SA","20","38","38","ⵉⵍⴰⵖⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵄⴰⵡⴻⴷ ⵉ ⵓⵃⵓⴷⵔⵉ “ⴷⴻⵖⵢⴰ, ⴰⵣⵣⴻⵍ, ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉ!” ⴰⵃⵓⴷⵔⵉ ⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵢⵓⵏⴰⵜⴰⵏ ⵉⵙⵙⵎⵓⵏ ⴼⵍⵉⵜⵛⴰ ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S120_39","010_20_39","1SA","20","39","39","ⴰⵃⵓⴷⵔⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵡⴰⵍⵓ. ⵎⵖⵉⵔ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⴷⴰⵡⵓⴷ ⵙⵙⵏⴻⵏ ⵅ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S120_40","010_20_40","1SA","20","40","40","ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⵢⵓⵏⴰⵜⴰⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵉ ⵓⵃⵓⴷⵔⵉ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵢⵓⵔ, ⴰⵔⵔ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ!” ");
INSERT INTO rift_vpl VALUES ("S120_41","010_20_41","1SA","20","41","41","ⵓⵎⵉ ⵢⵓⵢⵓⵔ ⵓⵃⵓⴷⵔⵉ, ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵉⵡⴹⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵢⵓⴹⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ⵏⵉⵜⵏⵉ ⵙⵙⵓⴷⵎⴻⵏ ⴰⵢⴰⵡⵢⴰ, ⵔⵓⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴰⵍⴰⵎⵉ ⴷⴰⵡⵓⴷ ⵢⴰⵔⵏⵉ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S120_42","010_20_42","1SA","20","42","42","ⵓ ⵢⵓⵏⴰⵜⴰⵏ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ. ⴰⵇⴰ ⵏⴻⵊⵊⵓⴵ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵏⴻⵖ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵏⵏⴰ: ‘ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⵊⴰⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉⵏⵓ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ!’” ");
INSERT INTO rift_vpl VALUES ("S121_1","010_21_1","1SA","21","1","1","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ, ⵢⵓⵢⵓⵔ, ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵢⵓⵏⴰⵜⴰⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S121_2","010_21_2","1SA","21","2","2","ⵅⴻⵏⵏⵉ ⵢⵉⵡⴻⴹ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵏⵓⴱ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ. ⴰⵅⵉⵎⴰⵍⵉⴽ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵢⴰⵔⵊⴻⴼ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ, ⵡⴰⵔ ⴽⵉⴷⴻⴽ ⵓⵍⴰ ⴷ ⵉⵊⵊ?” ");
INSERT INTO rift_vpl VALUES ("S121_3","010_21_3","1SA","21","3","3","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ: “ⴰⵊⴻⴵⵉⴷ ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴰⵔⴻⵇⵇⴰⵙ, ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵔⵉⴳⴳⵉⴱ ⵅ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵓ ⵅⴰⴽ ⴳⴳⵉⵖ!’ ⵙⴰⵔⴳⴱⴻⵖ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵇⴰ ⴰⴷ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ ⴷ ⵡⴻⵎⵛⴰⵏ-ⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S121_4","010_21_4","1SA","21","4","4","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⵉⵏ ⵖⴰⵔⴻⴽ? ⴻⵡⵛ ⴰⵢⵉ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵉⵖ ⵎⵉⵏ ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⴼⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("S121_5","010_21_5","1SA","21","5","5","ⴰⴽⴻⵀⵀⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⴷⵉⵏ ⴰⵖⵔⵓⵎ ⵉ ⵎⴰⵛⵛⴰ ⵖⴰⵔ ⵓⴼⵓⵙ, ⵎⵖⵉⵔ ⴰⵖⵔⵓⵎ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵡⴰⵀⴰ ⵉ ⴷⴰ. ⵎⴻⵄⵍⵉⴽ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ ⵡⴰⵀⴰ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("S121_6","010_21_6","1SA","21","6","6","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵓⴽⴻⵀⵀⴰⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵜⵡⴰⵃⴻⵢⵢⴷⴻⵏⵜ ⵅⴰⵏⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵍⵇⴰⵄⵉⴷⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⴼⴼⵖⴻⵖ, ⵓ ⵍⴻⵇⵛⵓⵄ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵏⴰⵡⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⵓⴼⴼⵓⵖ ⴰⵎ ⵍⴻⴱⴷⴰ, ⴰⵇⴰ ⵓⴼⴼⵓⵖ-ⴰ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⴰⵙⵙ-ⴰ ⵙ ⵍⴻⵇⵛⵓⵄ.” ");
INSERT INTO rift_vpl VALUES ("S121_7","010_21_7","1SA","21","7","7","ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵙ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵖⵔⵓⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏⵏⵉ ⴰⵖⵔⵓⵎ ⵎⵖⵉⵔ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴰⵖⵔⵓⵎ ⵉⵃⵎⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S121_8","010_21_8","1SA","21","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ ⴷⵉⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴷⵓⵡⴰⵄ, ⵣⵉ ⵉⴷⵓⵎ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⴰⵟⵟⴰⵙ ⵊⴰⵔ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S121_9","010_21_9","1SA","21","9","9","ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵅⵉⵎⴰⵍⵉⴽ: “ⵎⴰ ⵡⴰⵔ ⴷⴰ ⵖⴰⵔⴻⴽ ⵉⵛⵜ ⵏ ⵍⴰⵏⵙⴰ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵖⴰⵔ ⵓⴼⵓⵙ? ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴽⵉⴷⵉ ⴽⵙⵉⵖ ⵙⵙⵉⴼ ⴷ ⵍⴻⵙⵏⴰⵃ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵇⴻⴵⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("S121_10","010_21_10","1SA","21","10","10","ⵉⵏⵏⴰ ⵓⴽⴻⵀⵀⴰⵏ: “ⵙⵙⵉⴼ ⵏ ⵊⵓⵍⵢⴰⵜ, ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ ⵡⴻⵏⵏⵉ ⵅ ⵜⵖⴻⵍⴱⴻⴷ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵍⴰ, ⴰⵇⴰ-ⵜ ⴷⴰ, ⵉⵜⵜⵡⴰⵏⵏⴻⴹ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⴱⴰⵍⵟⵓ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⴷ, ⴽⵙⵉ ⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴰ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵡⴰⵏⵉⵜⴰ.” ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵡⴰⵔ ⵉⴵⵉ ⵉⵊⵊ ⴰⵎ ⵏⴻⵜⵜⴰ! ⴻⵡⵛ ⴰⵢⵉ ⵜ!” ");
INSERT INTO rift_vpl VALUES ("S121_11","010_21_11","1SA","21","11","11","ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ, ⵢⴰⵔⵡⴻⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴰⵅⵉⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S121_12","010_21_12","1SA","21","12","12","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵅⵉⵛ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵖⴻⵏⵏⵊⴻⵏⵜ, ⵛⴻⴹⵃⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵇⵇⴰⵔⴻⵏⵜ: ‘ⵛⴰⵡⵓⵍ ⵉⵖⵍⴻⴱ ⵅ ⵍⵓⵍⵓⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏⵏⴻⵙ?’” ");
INSERT INTO rift_vpl VALUES ("S121_13","010_21_13","1SA","21","13","13","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵅⵉⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S121_14","010_21_14","1SA","21","14","14","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵉⵡⴻⴷⴷⴰⵔ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⵉⵊⵊⴻⵏ ⴷⴰⵢⴻⵙ ⴰⵟⴻⵎⵎⴻⵙ ⵓⵎⵉ ⵅⴰⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ, ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵅⴻⴱⴱⴻⵛ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵊⵊⴰ ⵉⴽⵓⴼⴼⴰⵏ ⵏⵏⴻⵙ ⵀⴻⴽⴽⵡⴰⵏ-ⴷⴷ ⵅ ⵜⵎⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S121_15","010_21_15","1SA","21","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵅⵉⵛ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⵉⴱⴱⵓⵀⵍⵉ. ⵎⴰⵢⴻⵎⵎⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵜⵉⵡⵢⴻⵎ ⵖⴰⵔⵉ?” ");
INSERT INTO rift_vpl VALUES ("S121_16","010_21_16","1SA","21","16","16","ⵎⴰ ⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⵢⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⵜⵉⵡⵢⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵏⵉⵜⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⵉⴳⴳ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ? ⵎⴰ ⴷ ⵡⴰⵏⵉⵜⴰ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("S122_1","010_22_1","1SA","22","1","1","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⴰⵡⵓⴷ ⵙⵙⴻⵏⵏⵉ, ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴼⵔⵉ ⵏ ⴰⴷⵓⵍⵍⴰⵎ. ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵙⵍⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵀⵡⴰⵏ ⵖⴰⵔⴻⵙ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S122_2","010_22_2","1SA","22","2","2","ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵛⴰ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⵓⵎⴰⵔⵡⴰⵙ ⵓ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵙ ⵍⴱⴰⵍ ⴷ ⴰⵎⴻⵔⵣⴰⴳ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵏⵙⴻⵏ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⵇⴻⴷⴷ ⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S122_3","010_22_3","1SA","22","3","3","ⵙⵙⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵎⵉⵚⴼⴰⵜ ⴷⵉ ⵎⵓ’ⴰⴱ. ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ: “ⴻⵊⵊ ⴱⴰⴱⴰ ⴷ ⵢⴻⵎⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⵍ ⵖⴰ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⴽⵉⴷⵉ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S122_4","010_22_4","1SA","22","4","4","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵉⴽⴽⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⴱⵓⵔⵊ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S122_5","010_22_5","1SA","22","5","5","ⵎⴰⵛⴰ ⴰⵏⴰⴱⵉ ⵊⴰⵜ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⴷⵉ ⵍⴱⵓⵔⵊ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ, ⵎⴰⵛⴰ ⴰⴳⴳⵯⴻⵊ, ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ!” ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⴰⵡⵓⴷ, ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵏ ⵃⴰⵔⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("S122_6","010_22_6","1SA","22","6","6","ⵛⴰⵡⵓⵍ ⵉⵙⵍⴰ ⴱⴻⵍⵍⵉ ⴷⴰⵡⵓⴷ ⴷ ⵉⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵜⵜⵡⴰⴼⴻⵏ. ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⵉⵇⵇⵉⵎ ⴷⵉ ⵊⵉⴱⵄⴰ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵎⴰⵔⵉⵙⵜ ⵖⴰⵔ ⵔⴰⵎⴰ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵍⴰⵏⵙⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S122_7","010_22_7","1SA","22","7","7","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴱⴻⴷⴷⴻⵏ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⵙⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ! ⵎⴰ ⴰⴷ ⵉⵡⵛ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵉⵢⵢⴰⵔⴻⵏ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ? ⵎⴰ ⴰⴷ ⵢⴰⵔⵔ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("S122_8","010_22_8","1SA","22","8","8","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵜⴻⴳⴳⵉⵎ ⵅⴰⴼⵉ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴱⴻⵍⵍⵉ ⵎⵎⵉ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⴷ ⴰⵙ ⵛⵇⵉⵖ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⵎ ⴰⵇⴰ ⵎⵎⵉ ⵉⵙⵙⴰⵎⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵅⴰⴼⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵉⵣⴻⵢⵢⴰⵔ ⵙ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("S122_9","010_22_9","1SA","22","9","9","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴷⵓⵡⴰⵄ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵉⴷⵓⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴷⵉ ⵏⵓⴱ ⵖⴰⵔ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("S122_10","010_22_10","1SA","22","10","10","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⴰⵙ ⵎⴰⵛⵛⴰ ⵓⵍⴰ ⴷ ⵙⵙⵉⴼ ⵏ ⵊⵓⵍⵢⴰⵜ, ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("S122_11","010_22_11","1SA","22","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵉⵍⴰⵖⴰ ⵅ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵏⵓⴱ. ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S122_12","010_22_12","1SA","22","12","12","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⵙⴻⵍ, ⵛⴻⴽ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ!” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("S122_13","010_22_13","1SA","22","13","13","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⴼⵉ ⵜⴻⴳⴳⵉⵎ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ, ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵎⴰⵛⵛⴰ ⴷ ⵙⵙⵉⴼ ⵓ ⵜᵉⵜⵜⴰⵔⴻⴷ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⵖⴻⵡⵡⴻⵖ ⵓ ⴰⴷ ⵅⴰⴼⵉ ⵉⵣⴻⵢⵢⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("S122_14","010_22_14","1SA","22","14","14","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵅⵉⵎⴰⵍⵉⴽ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴰⵎ ⴷⴰⵡⵓⴷ, ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵢⴰⵡⴹⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵖⴰⵔ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵛ ⵓ ⵡⵉ ⵖⴰⵔ ⵉⴵⴰ ⵛⵛⴰⵏ ⴰⵎⵎⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("S122_15","010_22_15","1SA","22","15","15","ⵎⴰ ⴰⵙⵙ-ⴰ ⵡⴰⵀⴰ ⵉ ⴽⴽⴰⵔⴻⵖ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ? ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ. ⴻⵊⵊ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⵏⴻⵟⵟⴰⵔ ⵍⴱⴰⵟⴻⵍ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵏⵉⵖ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⵎⵉⵏⵣⵉ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵡⴰⵍⵓ ⵅ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⵎⴰ ⴷ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵏⵉⵖ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵜⴻⴵⴰ.” ");
INSERT INTO rift_vpl VALUES ("S122_16","010_22_16","1SA","22","16","16","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ, ⴰ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("S122_17","010_22_17","1SA","22","17","17","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⵉ ⵉⵍⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵏⵏⵉ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵉⴱⴻⴷⴷⴻⵏ: “ⵏⵇⴻⵍⴱⴻⵎ ⵓ ⵏⵖⴻⵎ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⴼⵓⵙ ⵉ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⴽⴽⵡⴰⵍ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵅⴰⵙ ⵙⵙⴰⵔⴳⴱⴻⵏ ⵛⴰ.” ⵎⴰⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴼⵓⵙ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵡⵜⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S122_18","010_22_18","1SA","22","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⴷⵓⵡⴰⵄ: “ⵏⴻⵇⵍⴻⴱ, ⵡⵡⴻⵜ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ!” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⴷⵓⵡⴰⵄ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵉⴷⵓⵎ, ⵉⵡⵜⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵏⵖⴰ ⵏⴻⵜⵜⴰ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S122_19","010_22_19","1SA","22","19","19","ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵓⵍⴰ ⴷ ⵏⵓⴱ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵉⵙⴻⵢⵎⴰⵏ. ⵉⵡⵜⴰ ⵄⴰⵡⴻⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⴷ ⵡⵓⴵⵉ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S122_20","010_22_20","1SA","22","20","20","ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡ ⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴱⵢⴰⵜⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⵉⵇⴻⴵⴻⵇ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S122_21","010_22_21","1SA","22","21","21","ⴰⴱⵢⴰⵜⴰⵔ ⵉⵃⴰⵊⴰ ⵉ ⴷⴰⵡⵓⴷ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵉⵏⵖⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S122_22","010_22_22","1SA","22","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⴱⵢⴰⵜⴰⵔ: “ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⵓⵡⴰⵄ ⵣⵉ ⵉⴷⵓⵎ ⴷⵉⵏⵏⵉ, ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴰⵊⴰ ⴰⵢⴰ ⵉ ⵛⴰⵡⵓⵍ. ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵅ ⵉⴵⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⵓⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("S122_23","010_22_23","1SA","22","23","23","ⵇⵉⵎ ⵖⴰⵔⵉ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵉⵏⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵏⴻⵖ ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ⴰⵇⴰ ⵛⴻⴽ ⵄⴰⵡⴻⴷ ⵖⴰⵔⵉ ⴷⵉ ⵍⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S123_1","010_23_1","1SA","23","1","1","ⵃⴰⵊⴰⵏ ⵉ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⵇⴰⵄⵉⵍⴰ ⵓⵛⴰ ⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵉⵏⴻⴷⵔⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("S123_2","010_23_2","1SA","23","2","2","ⵉⵙⵙⴻⵇⵙⴰ ⴷⴰⵡⵓⴷ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵖ ⴷⵉⵏ, ⴰⴷ ⵡⵜⴻⵖ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ?” ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⴷⴰⵡⵓⴷ: “ⴼⴼⴻⵖ, ⵡⵡⴻⵜ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴼⴻⴽⴽ ⵇⴰⵄⵉⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("S123_3","010_23_3","1SA","23","3","3","ⵏⵏⴰⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴷⴰⵡⵓⴷ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⵏᵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴷⴻⵖⵢⴰ ⴷⴰ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵎⵎⴻⵛ ⵄⴰⴷ ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ ⵖⴰⵔ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S123_4","010_23_4","1SA","23","4","4","ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵓ ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⵀⵡⴰ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S123_5","010_23_5","1SA","23","5","5","ⵅⴰⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ, ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵢⵓⵥⵥⴻⵍ ⵅ ⵜⵃⵉⵎⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵜⴰ ⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⵎⵎⵓ ⵉ ⵉⴼⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵇⴰⵄⵉⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S123_6","010_23_6","1SA","23","6","6","ⵓⵎⵉ ⴰⴱⵢⴰⵜⴰⵔ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ, ⵉⵎⵙⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵀⵡⴰ ⴰⴽ-ⴷ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S123_7","010_23_7","1SA","23","7","7","ⵃⴰⵊⴰⵏ ⴰⵙ ⵉ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⵉ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵃⴻⴱⴱⴻⵙ ⴰⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("S123_8","010_23_8","1SA","23","8","8","ⵉⵊⵊⴰ ⵛⴰⵡⵓⵍ ⴰⴷ ⵍⴰⵖⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵀⵡⴰⵏ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵏⴹⴻⵏ ⵉ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S123_9","010_23_9","1SA","23","9","9","ⵍⴰⵎⵉ ⵢⴰⵔⴳⴻⴱ ⴷⴰⵡⵓⴷ ⴱⴻⵍⵍⵉ ⵛⴰⵡⵓⵍ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ-ⵢⴰ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴱⵢⴰⵜⴰⵔ: “ⴰⵡⵉ-ⴷⴷ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("S123_10","010_23_10","1SA","23","10","10","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵙⵍⴰ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵉⵄⴻⵎⵎⴻⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵇⴰⵄⵉⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴰⵔⵔⴻⴱ ⵜⴰⵏⴷⵉⵏⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S123_11","010_23_11","1SA","23","11","11","ⵎⴰ ⴰⴷ ⴰⵢⵉ ⵙⵙⴻⵄⴷⵓⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵇⴰⵄⵉⵍⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ? ⵎⴰ ⴰⴷ ⵉⵀⵡⴰ ⵛⴰⵡⵓⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵍⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ? ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ!” ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵀⵡⴰ.” ");
INSERT INTO rift_vpl VALUES ("S123_12","010_23_12","1SA","23","12","12","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵎⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵇⴰⵄⵉⵍⴰ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵏ ⵏⴻⵛⵛ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵓ ⵉ ⵛⴰⵡⵓⵍ?” ⵉⵏⵏⴰ ⵙⵉⴷⵉ “ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵄⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("S123_13","010_23_13","1SA","23","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ, ⴰⵎⴻⵏⵏⵉ ⵙⴻⵜⵜⴰ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵇⴰⵄⵉⵍⴰ, ⴷⴻⵡⵍⴻⵏ ⴳⴳⵓⵔⴻⵏ ⵎⴰⵏⵉ ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ. ⵓⵎⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ ⵉⵏⵊⴻⵎ-ⴷⴷ ⴷⴰⵡⵓⴷ ⵣⵉ ⵇⴰⵄⵉⵍⴰ, ⵉⵊⵊⴰ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴼⴼⵉⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S123_14","010_23_14","1SA","23","14","14","ⴷⴰⵡⵓⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⴻⵅⵍⴰ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵣⵉⴼ. ⵛⴰⵡⵓⵍ ⵢⴰⵔⵣⵓ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S123_15","010_23_15","1SA","23","15","15","ⵓⵎⵉ ⵉⵥⵔⴰ ⴷⴰⵡⵓⴷ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵣⵓ, ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵣⵉⴼ ⴷⵉ ⵅⵓⵔⵉⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("S123_16","010_23_16","1SA","23","16","16","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵅⵓⵔⵉⵙⴰ, ⵉⵙⵙⴻⵊⵀⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("S123_17","010_23_17","1SA","23","17","17","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⵉⵏⵣⵉ ⴰⴼⵓⵙ ⵏ ⴱⴰⴱⴰ ⵛⴰⵡⵓⵍ ⵡⴰⵔ ⵛⴻⴽ ⴷⴷ-ⵉⵜⵜⵉⴽⴽⵯⵉⴹ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵖⴰⵔⴻⴽ. ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ ⵛⴰⵡⵓⵍ ⵉⵙⵙⴻⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("S123_18","010_23_18","1SA","23","18","18","ⵓ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴷⴰⵡⵓⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵅⵓⵔⵉⵙⴰ ⵓ ⵢⵓⵏⴰⵜⴰⵏ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S123_19","010_23_19","1SA","23","19","19","ⵅⴰⵙ ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵣⵉⴼ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⴷⵉ ⵊⵉⴱⵄⴰ, ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⵏⵏⵓⴼⴼⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔⵏⴻⵖ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⴷⵉ ⵅⵓⵔⵉⵙⴰ, ⵅ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵃⴰⵅⵉⵍⴰ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⵏⴻⵣⵔⵓⴼⵜ? ");
INSERT INTO rift_vpl VALUES ("S123_20","010_23_20","1SA","23","20","20","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵀⵡⴰ-ⴷⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⴻⵥⵔⵉ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ. ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵏⵏⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵄⴷⵓ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S123_21","010_23_21","1SA","23","21","21","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵎ ⵣⵉ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵛⵇⵉⵖ ⴰⵡⴻⵎ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("S123_22","010_23_22","1SA","23","22","22","ⵓⵢⵓⵔⴻⵎ, ⵡⴻⵊⴷⴻⵎ ⵄⴰⴷ ⴽⵜⴰⵔ ⵓ ⵃⴹⴰⵎ ⵓ ⵙⵏⴻⵎ ⵓ ⵅⵣⴰⵔⴻⵎ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⴹⴰⵔ ⵏⵏⴻⵙ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜ ⴷⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ, ⵎⴰⵖⴰⵔ ⵇⵇⴰⵔⴻⵏ ⴰⵢⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵃⵔⴰⵢⵎⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S123_23","010_23_23","1SA","23","23","23","ⵃⴹⴰⵎ ⵓ ⵙⵙⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵏ ⵜⵏⵓⴼⴼⵔⴰ ⵎⴰⵏⵉ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵄⴻⵇⴱⴻⵎ ⵎⴰⵍⴰ ⵜⴽⴻⵎⵎⵍⴻⵎ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵓⵢⵓⵔⴻⵖ ⵓ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴰⵔⵣⵓⵖ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵓⵍⵓⴼ ⵏ ⵢⴰⵀⵓⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("S123_24","010_23_24","1SA","23","24","24","ⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵉⵣⵣⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵣⵉⴼ. ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵎⴰⵄⵓⵏ, ⴷⵉ ⵍⴻⵡⴹⴰ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("S123_25","010_23_25","1SA","23","25","25","ⵛⴰⵡⵓⵍ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴼⴼⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⴰⵔⵣⵓⵏ. ⵏⵏⴰⵏ ⴰⵢⴰ ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵣⵉ ⵍⴻⵊⵔⵓⴼ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵎⴰⵄⵓⵏ. ⵓⵎⵉ ⵜ ⵉⵙⵍⴰ ⵛⴰⵡⵓⵍ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴹⴼⴰⵔ ⵏⴻⵜⵜⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵎⴰⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S123_26","010_23_26","1SA","23","26","26","ⵛⴰⵡⵓⵍ ⵉⴽⴽⴰ ⵅ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴷⵔⴰⵔ ⵓ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴽⴽⴻⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵡⴻⴷⵔⴰⵔ. ⵍⴰⵎⵉ ⵉⵇⴻⴵⴻⵇ ⴷⴰⵡⵓⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴳⴳⵯⴻⵊ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰⵡⵓⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵏⵏⴹⴻⵏ-ⴷⴷ ⵉ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵟⵟⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S123_27","010_23_27","1SA","23","27","27","ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⴷⴻⵖⵢⴰ, ⴰⵙ-ⴷⴷ, ⵎⵉⵏⵣⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵀⴻⵊⵎⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("S123_28","010_23_28","1SA","23","28","28","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵛⴰⵡⵓⵍ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵙⴰⵍⴰⵄ-ⵀⴰ-ⵎⴰⵅⵍⵉⴽⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S124_1","010_24_1","1SA","24","1","1","ⵢⵓⵢⵓⵔ ⴷⴰⵡⵓⴷ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⴰⵢⵏ-ⵊⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S124_2","010_24_2","1SA","24","2","2","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵛⴰⵡⵓⵍ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵄⴰⵡⴷⴻⵏ ⴰⵙ, ⵏⵏⴰⵏ: “ⴷⴰⵡⵓⴷ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵄⴰⵢⵏ-ⵊⴰⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S124_3","010_24_3","1SA","24","3","3","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵛⴰⵡⵓⵍ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵜⵚⵓⴹⴰⵔ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵏ ⵍⴻⵊⵔⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("S124_4","010_24_4","1SA","24","4","4","ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵍⴽⵓⵔⵉⵢⵢⴰⵜ ⵏ ⵡⵓⴵⵉ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵢⴻⴼⵔⵉ. ⵛⴰⵡⵓⵍ ⵢⵓⴷⴻⴼ ⵖⴰⵔⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⴻⵍ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⴷⴻⴳ ⵉⴼⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S124_5","010_24_5","1SA","24","5","5","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴷⴰⵡⵓⴷ: “ⵅⵣⴰⵔ, ⵡⴰ ⴷ ⴰⵙⵙ ⵉ ⵅ ⴷ ⴰⵛ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓ ⵛⴻⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵇⴻⵙⵙ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵣⴻⴳ ⵓⵙⴻⵍⵀⴰⵎ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S124_6","010_24_6","1SA","24","6","6","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵎⴰⵛⴰ ⵉⵙⵙⴷⴻⵡⴷⵉⵡ ⵓⵍ ⵏ ⴷⴰⵡⵓⴷ ⴷⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵛⴰⵔⵔⴻⴳ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵣⴻⴳ ⵓⵙⴻⵍⵀⴰⵎ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S124_7","010_24_7","1SA","24","7","7","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ: “ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵃⴹⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵢⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("S124_8","010_24_8","1SA","24","8","8","ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵉⵊⵊⵉ ⴰⴷ ⵀⴻⵊⵎⴻⵏ ⵅ ⵛⴰⵡⵓⵍ. ⵓ ⵛⴰⵡⵓⵍ ⵉⴽⴽⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵉⴼⵔⵉ, ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S124_9","010_24_9","1SA","24","9","9","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵓⵍⴰ ⴷ ⴷⴰⵡⵓⴷ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵉⴼⵔⵉ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ!” ⵓ ⵛⴰⵡⵓⵍ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵓⵛⴰ ⵢⵓⴹⴰⵔ ⴷⴰⵡⵓⴷ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⴱⴻⵏⴷⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("S124_10","010_24_10","1SA","24","10","10","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵛⴰⵡⵓⵍ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵅⵥⴰⵔ, ⴷⴰⵡⵓⴷ ⵉⵅⵙ ⴰⴷ ⴰⵛ ⵉⴳⴳ ⵍⵖⴰⵔ?’ ");
INSERT INTO rift_vpl VALUES ("S124_11","010_24_11","1SA","24","11","11","ⵅⵣⴰⵔ ⴰⵙⵙ-ⴰ ⵜⴻⵥⵔⵉⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵛⴻⴽ ⴰⵙⵙ-ⴰ ⴷⴻⴳ ⵉⴼⵔⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ⵏⵏⴰⵏ ⴰⵢⵉ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵏⵖⴻⵖ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵃⴰⵡⵍⴻⵖ ⵅⴰⴽ, ⵎⵉⵏⵣⵉ ⵏⵏⵉⵖ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵉⵏⵓ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵡⵉⵥⵥⴰⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("S124_12","010_24_12","1SA","24","12","12","ⵅⵣⴰⵔ ⴱⴰⴱⴰ, ⵟⵟⴰⵔⴼ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ⵓⵎⵉ ⵏⴻⵛⵛ ⵛⴰⵔⵔⴳⴻⵖ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵛⴻⴽ ⵏⵖⵉⵖ. ⵅⴻⵏⵏⵉ ⵙⵙⴻⵏ ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵍⴰ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓⵍⴰ ⴷ ⴰⵅⴻⵟⵟⵓ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⴽ ⵅⴹⵉⵖ ⵛⴰ. ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴰⵔⴻⵣⵣⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⴽⴽⵙⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S124_13","010_24_13","1SA","24","13","13","ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵏⵜⴰⵇⴻⵎ ⵉ ⵏⴻⵛⵛ ⵣⵣⴰⵢⴻⴽ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵅⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("S124_14","010_24_14","1SA","24","14","14","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵇⵇⴰⵔ ⵡⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⵏ ⵍⴻⵊⴷⵓⴷ: ‘ⵣⴻⴳ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ!’, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴹⵉⴷⴷ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S124_15","010_24_15","1SA","24","15","15","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉⴹⴻⴼⴼⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜⵢⴻⵎⵎⴰⵔⴻⴷ? ⴰⵡⴰⵔⵏⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵇⵣⵉⵏ ⵉⵎⵎⵓⵜⴻⵏ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵢⴻⵏⵏⵉ ⵏ ⵓⵛⵓⵔⴷⵓ! ");
INSERT INTO rift_vpl VALUES ("S124_16","010_24_16","1SA","24","16","16","ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵇⴰⴹⵉ ⵏⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⵣⴰⵔ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵢⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S124_17","010_24_17","1SA","24","17","17","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴷⴰⵡⵓⴷ ⵅ ⵍⵀⴰⵔⴷ ⵏ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵛⴰⵡⵓⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⵎⴰ ⵜⴰ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ, ⵎⵎⵉ ⴷⴰⵡⵓⴷ?” ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵛⴰⵡⵓⵍ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵉⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("S124_18","010_24_18","1SA","24","18","18","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵅⴰⴼⵉ ⵏⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⴽⵉⴷⵉ ⵎⵍⵉⵃ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⴽⵉⴷⴻⴽ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S124_19","010_24_19","1SA","24","19","19","ⵛⴻⴽ, ⵡⴰⵀ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⵢⵉ ⴰⵙⵙ-ⴰ, ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⵢⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵏⵖⵉⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S124_20","010_24_20","1SA","24","20","20","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵓⴼⴰ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵢⴻⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴷⵉ ⵍⵅⴰⵔ? ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵅⴻⴵⴻⵚ ⵙ ⵍⵅⴰⵔ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S124_21","010_24_21","1SA","24","21","21","ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵓ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⵎⵜⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S124_22","010_24_22","1SA","24","22","22","ⵅ ⵓⵢⴻⵏⵏⵉ ⵊⵊⴰⴵ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⵇⴻⵟⵟⵄⴻⴹ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉⵏⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴽⴽⵙⴻⴷ ⵉⵙⴻⵎ ⵉⵏⵓ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ!” ");
INSERT INTO rift_vpl VALUES ("S124_23","010_24_23","1SA","24","23","23","ⴷⴰⵡⵓⴷ ⵉⵊⵊⵓⴵ ⵉ ⵛⴰⵡⵓⵍ ⵓ ⵛⴰⵡⵓⵍ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵍⴱⵓⵔⵊ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S125_1","010_25_1","1SA","25","1","1","ⵛⴰⵎⵡⵉⵍ ⵉⵎⵎⵓⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵎⵓⵏ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵅⴰⵙ ⴰⴳⴻⵊⴷⵓⵔ ⵓ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵔⴰⵎⴰ. ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵀⵡⴰ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⴼⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S125_2","010_25_2","1SA","25","2","2","ⵜⵓⵖⴰ ⴷⵉ ⵎⴰⵄⵓⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴳⵍⴰ ⴷⵉ ⴽⴰⵔⵎⵉⵍ. ⴰⵔⵢⴰⵣ ⵜⵓⵖⴰ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵉⴵⴰ ⵖⴰⵔⴻⵙ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ ⴷ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⵢⴹⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴵⴰⵙ ⵓⴵⵉ ⵏⵏⴻⵙ ⴷⵉ ⴽⴰⵔⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S125_3","010_25_3","1SA","25","3","3","ⴰⵔⵢⴰⵣ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵏⴰⴱⴰⵍ ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⴰⴱⵉⵊⴰⵢⵉⵍ. ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⴻⵄⵇⴻⵍ ⵎⵍⵉⵃ ⵓ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵎⵓⵚⴱⵉⵃ ⵉ ⵍⵅⴻⵣⵔⴰⵜ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵜⵓⵖⴰ ⵉⵇⵙⴻⵃ ⵓ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⴷ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵉ ⴵⴰⵏⵜ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴰⵎ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S125_4","010_25_4","1SA","25","4","4","ⵓⵎⵉ ⵉⵙⵍⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴰⵇⴰ ⵏⴰⴱⴰⵍ ⵜⵓⵖⴰ ⵉⴵⴰⵙ ⵓⴵⵉ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("S125_5","010_25_5","1SA","25","5","5","ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉⵏ. ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ: “ⴳⴰⵄⵄⴷⴻⵎ ⵖⴰⵔ ⴽⴰⵔⵎⵉⵍ ⵓ ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⴹⴻⵎ ⵖⴰⵔ ⵏⴰⴱⴰⵍ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵙ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S125_6","010_25_6","1SA","25","6","6","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ ⴰⵎⵎⵓ: ‘ⵉⵍⵉ ⴰⴷ ⵅⴰⴽ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("S125_7","010_25_7","1SA","25","7","7","ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵉⵔⴻⵡⵡⴰⵏ. ⵉⵡⴰ ⵅⴻⵏⵏⵉ, ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵜⴻⵏ ⵏⵅⴻⵡⵡⴻⵊ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⵇⵉⵚ ⵡⴰⵍⵓ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵉⴽⴽⵉⵏ ⵏⵉⵜⵏⵉ ⴰⴽⵉⴷⵏⴻⵖ ⴷⵉ ⴽⴰⵔⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S125_8","010_25_8","1SA","25","8","8","ⵙⴻⵇⵙⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ. ⴻⵊⵊ ⴰⴷ ⴰⴼⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵏⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵡⵓⵔⴰⵔ. ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴻⵡⵛ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵉ ⵎⵎⵉⵛ ⴷⴰⵡⵓⴷ ⵎⵉⵏ ⵖⴰ ⵢⴰⴼ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("S125_9","010_25_9","1SA","25","9","9","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⴷⵉⵏ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵏⴰⴱⴰⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴷⴰⵡⵓⴷ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵔⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S125_10","010_25_10","1SA","25","10","10","ⵎⴰⵛⴰ ⵏⴰⴱⴰⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⴰⵡⵓⴷ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ? ⴰⵙⵙ-ⴰ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ. ⴽⵓⵍ ⵉⵊⵊ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S125_11","010_25_11","1SA","25","11","11","ⵎⴰ ⴰⴷ ⴽⵙⵉⵖ ⵅⴻⵏⵏⵉ ⴰⵖⵔⵓⵎ ⵉⵏⵓ ⴷ ⵡⴰⵎⴰⵏ ⵉⵏⵓ ⴷ ⵜⵖⴰⵔⵚⵜ ⵉ ⵖⴰⵔⵚⴻⵖ ⵉ ⵉⵔⴻⵡⵡⴰⵏ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜ ⵡⵛⴻⵖ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵓⵍⴰ ⴷ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("S125_12","010_25_12","1SA","25","12","12","ⵅⴻⵏⵏⵉ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵉ ⵣⵉ ⴷⴷ-ⵓⵙⵉⵏ, ⵄⴻⵇⴱⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵓ ⵃⴰⵊⴰⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S125_13","010_25_13","1SA","25","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ: “ⴽⵓⵔ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⴱⵢⴻⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ!” ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⴱⵢⴻⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⴷⴰⵡⵓⴷ ⵉⴱⵢⴻⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⴷⴰⵡⵓⴷ, ⴰⵎⴻⵏⵏⵉ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵓ ⵇⵇⵉⵎⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵖⴰⵔ ⵍⴻⵃⵡⴰⵢⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("S125_14","010_25_14","1SA","25","14","14","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵉⵃⴰⵊⴰ ⴰⵢⴰ ⵉ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵏⴰⴱⴰⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵏ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵇⵍⴻⵄ ⵅⴰⵙⴻⵏ ⵙ ⵜⵣⴰⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S125_15","010_25_15","1SA","25","15","15","ⵉⵔⵢⴰⵣⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵛⵏⴰⵏ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵙⴻⴷⴷⵄⴻⵏ ⵛⴰ. ⵡⴰⵔ ⵏⴻⴼⵇⵉⴷ ⵡⴰⵍⵓ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⴷⵉⵏⵏⵉ ⵏⴻⵙⵙⴻⵄⴷⵓ ⴰⴽⵉⴷⵙⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("S125_16","010_25_16","1SA","25","16","16","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵉ ⵏⴻⵛⵛⵉⵏ, ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⴽⵉⴷⵙⴻⵏ ⵏⴻⴵⴰ ⵓ ⵜⵓⵖⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵡⴻⵙ ⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("S125_17","010_25_17","1SA","25","17","17","ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵜ. ⵅⵣⴰⵔ ⵎⵍⵉⵃ, ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ, ⵎⴰⵖⴰⵔ ⵍⵖⴰⵔ ⵅ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵎⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉ ⵡⴰⵡⴰⵍ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S125_18","010_25_18","1SA","25","18","18","ⵜⵇⴻⴵⴻⵇ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴻⴽⵙⵉ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵢⵉⵍⴻⵎ ⵉ ⴱⵉⵏⵓ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵅⵙⵉⵡⵉⵏ ⵡⴻⵊⴷⴻⵏⵜ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵜⴻⵖⵡⴰⵡⵉⵏ ⴷ ⵎⵢⴰ ⵏ ⵜⵖⴰⵢⵉⵟⴰⵜⵉⵏ ⵏ ⵣⵣⴱⵉⴱ ⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵖⵔⵓⵎⴻⵏ ⵏ ⵜⴰⵣⴰⵔⵜ, ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴰⵔⵙ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵅ ⵢⴻⵖⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S125_19","010_25_19","1SA","25","19","19","ⵜⴻⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵓⵢⵓⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴷⴼⴻⵖ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵏⵏⵉ ⴰⵢⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵏⴰⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S125_20","010_25_20","1SA","25","20","20","ⵓⵎⵉ ⵜⴻⵏⵢⴰ ⵏⴻⵜⵜⴰⵜ ⵅ ⵡⴻⵖⵢⵓⵍ, ⵜⴻⵀⵡⴰ ⵅ ⵓⴷⵓⵔⵔⵉ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵅⵣⴰⵔ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵀⵡⴰⵏ-ⴷⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵎⵎⴻⵍⵇⴰ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S125_21","010_25_21","1SA","25","21","21","ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⴱⴰⵟⴻⵍ ⵉ ⵃⴹⵉⵖ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵡⴻⴷⴷⴰⵔ ⵡⴰⵍⵓ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵅⴻⴵⴻⵚ ⴰⵢⵉ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵙ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S125_22","010_25_22","1SA","25","22","22","ⴻⵊⵊ ⴰⴷ ⵉⴳⴳ ⴰⵔⴻⴱⴱⵉ ⵜⴰ ⴷ ⵜⴰ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⴷ ⵊⵊⴻⵖ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵅ ⵍⵃⵉⴹ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("S125_23","010_25_23","1SA","25","23","23","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴰⴱⵉⵊⴰⵢⵉⵍ ⴷⴰⵡⵓⴷ, ⵜⴻⴹⵔⴰ ⴷⴻⵖⵢⴰ ⵅ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ, ⵜⴻⵡⴹⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⴷⴰⵡⵓⴷ, ⵜⵓⴹⴰⵔ ⴰⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S125_24","010_25_24","1SA","25","24","24","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ, ⵜⴻⵏⵏⴰ: “ⵏⴻⵛⵛ, ⵡⴰⵀⴰ, ⵉ ⴷⵉ ⵉⴵⴰ ⵍⵄⵉⴱ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ. ⴻⵊⵊ ⴰⴷ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ ⵓ ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S125_25","010_25_25","1SA","25","25","25","ⴻⵊⵊ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵖⴰⵔ ⵏⴰⴱⴰⵍ, ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵏⴻⵜⵜⴰ. ⵏⴰⴱⴰⵍ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵓ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴰⵇⴰ-ⵜⵜ ⴷⴰⵢⴻⵙ. ⵏⴻⵛⵛ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵥⵔⵉⵖ ⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉ ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S125_26","010_25_26","1SA","25","26","26","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵎⵎⴻⵏⵄⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵉⵣⵣⵍⴻⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⴰⴷ ⵜⴼⴻⴽⴽⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵍⴻⵅⵅⵓ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⵖⴰⵔ ⴷⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵎ ⵏⴰⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S125_27","010_25_27","1SA","25","27","27","ⵉⵡⴰ ⵍⴻⵅⵅⵓ, ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⴷⴷ-ⵜⵉⵡⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵡⵛⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S125_28","010_25_28","1SA","25","28","28","ⵜⵜⵣⴰⵡⴳⴻⵖ, ⵖⴼⴰⵔ ⴰⵅⴻⵟⵟⵓ ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵎⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵜⵜⴻⴳⴳ ⴳⴰⵔⵔⴰⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⴼⴼ ⵍⵖⴰⵔ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S125_29","010_25_29","1SA","25","29","29","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⴽⴽⴰⵔ ⵅⴰⴽ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⴹⴼⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵉⵇⵇⴻⵏ ⴷⵉ ⵜⴻⵛⵢⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵃⴻⵊⵊⴰⵔ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵣⴻⴳ ⵓⴽⴻⵎⵎⵉⵛ ⵏ ⵉⴵⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("S125_30","010_25_30","1SA","25","30","30","ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⴳⴳ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⵅⴰⴽ ⵉⵙⵙⵉⵡⴻⵍ ⵓ ⴰⴷ ⵛⴻⴽ ⵢⴻⴳⴳ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("S125_31","010_25_31","1SA","25","31","31","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵢⴰ ⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵣⵉ ⵖⴰ ⵜⴻⵏⵇⴰⵔⴹⴻⴷ ⵓⵍⴰ ⴷ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⵡⵓⵍ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵉⵣⵣⵍⴻⴷ ⵉⴷⴰⵎⵎⴻⵏ ⴱⴰⵟⴻⵍ ⵓ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴳⴳⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⴳⴳ ⵍⵅⴰⵔ ⴷⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵄⵇⴻⵍ ⵅⴻⵏⵏⵉ ⵅ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S125_32","010_25_32","1SA","25","32","32","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⴱⵉⵊⴰⵢⵉⵍ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵛⴻⵎ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⴰⵙⵙ-ⴰ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("S125_33","010_25_33","1SA","25","33","33","ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵓⵍⴰ ⴷ ⵛⴻⵎ, ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⴰⵙⵙ-ⴰ ⵣⴻⴳ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵣⵉ ⵏⵏⴻⵇⵎⴻⵜ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("S125_34","010_25_34","1SA","25","34","34","ⵎⴰⵖⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⴷ ⴰⵎ ⴳⴳⴻⵖ ⵍⵖⴰⵔ, ⵎⴰⵍⴰ ⵛⴻⵎ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴻⴼⴼⵉⵖⴻⴷ ⴷⴻⵖⵢⴰ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵖⴰⵔ ⵜⴼⴰⵡⵜ ⵏ ⵜⵓⴼⴼⵓⵜ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵏ ⵏⴰⴱⴰⵍ, ⵡⴻⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵅ ⵍⵃⵉⴹ!” ");
INSERT INTO rift_vpl VALUES ("S125_35","010_25_35","1SA","25","35","35","ⵓⵛⴰ ⵉⴽⵙⵉ ⴷⴰⵡⵓⴷ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵉⵡⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵎ! ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵍⵉⵖ-ⴷⴷ ⵖⴰⵔⴻⵎ ⵓ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵓⴷⴻⵎ ⵏⵏⴻⵎ ⵉⵃⴻⵣⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S125_36","010_25_36","1SA","25","36","36","ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⴰⴱⵉⵊⴰⵢⵉⵍ ⵖⴰⵔ ⵏⴰⴱⴰⵍ, ⵉⵜⵜⴻⴳⴳ ⵏⴻⵜⵜⴰ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵏ ⵜⵉⵙⵙⵉⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵓⵍ ⵏ ⵏⴰⴱⴰⵍ ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⵉⵙⵛⴰⵔ ⴰⵍ ⵟⵟⴰⵔⴼ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⴰⵎⴻⵥⵢⴰⵏ ⵏⵉⵖ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵅ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵍ ⵜⴰⴼⴰⵡⵜ ⵏ ⵜⵓⴼⴼⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S125_37","010_25_37","1SA","25","37","37","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵍⴰⵎⵉ ⵉⴼⴼⴻⵖ ⴱⵉⵏⵓ ⵅ ⵏⴰⴱⴰⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵏⵏⴰ ⴰⵙ ⵎⴰⵏ ⴰⵢⴰ. ⵓⵛⴰ ⵉⵊⵎⴻⴷ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⴷⵡⴻⵍ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("S125_38","010_25_38","1SA","25","38","38","ⴰⵡⴰⵔⵏⵉ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵡⵜⴰ ⵏⴰⴱⴰⵍ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S125_39","010_25_39","1SA","25","39","39","ⵓⵎⵉ ⵉⵙⵍⴰ ⴷⴰⵡⵓⴷ ⴱⴻⵍⵍⵉ ⵏⴰⴱⴰⵍ ⵉⵎⵎⵓⵜ, ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵃⵓⴽⵎ ⵅ ⵍⵃⴻⴳⵔⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵉⵜⵜⴰⵔ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⴰⵍ, ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⵖⴰⵔ. ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏ ⵏⴰⴱⴰⵍ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ!” ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("S125_40","010_25_40","1SA","25","40","40","ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⴰⴱⵉⵊⴰⵢⵉⵍ ⵖⴰⵔ ⴽⴰⵔⵎⵉⵍ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⴰⵏⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵎ ⵏⴰⵡⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("S125_41","010_25_41","1SA","25","41","41","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ, ⵜⴱⴻⵏⴷⴻⵇ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵜⴰⵎⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷ ⵉⴹⴰⵔⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("S125_42","010_25_42","1SA","25","42","42","ⵜⵇⴻⴵⴻⵇ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴻⴽⴽⴰⵔ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵢⴰ ⵅ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵥⴰⵢⵏⵉⵏ ⵜⵉⵏⵏⵉ ⵜⵜ ⵢⴰⵔⴻⴷⴷⴼⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴹⴼⴰⵔ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S125_43","010_25_43","1SA","25","43","43","ⵢⵉⵡⵉ ⴷⴰⵡⵓⴷ ⵄⴰⵡⴻⴷ ⴰⵅⵉⵏⵓⵄⴰⵎ ⵣⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ⵏⵉⵜⴻⵏⵜⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏⵜ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("S125_44","010_25_44","1SA","25","44","44","ⵛⴰⵡⵓⵍ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵢⴻⴵⵉⵙ ⵎⵉⵅⴰⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵉ ⴱⴰⵍⵜⵉ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵢⵉⵛ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵊⴰⵍⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S126_1","010_26_1","1SA","26","1","1","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵣⵉⴼ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⵖⴰⵔ ⵊⵉⴱⵄⴰ, ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴷⴰⵡⵓⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵃⴰⵅⵉⵍⴰ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵜⵏⴻⵣⵔⵓⴼⵜ?” ");
INSERT INTO rift_vpl VALUES ("S126_2","010_26_2","1SA","26","2","2","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⵉⵀⵡⴰ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵣⵉⴼ, ⴰⴽⵉⴷⴻⵙ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵣⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S126_3","010_26_3","1SA","26","3","3","ⵉⵡⵜⴰ ⵛⴰⵡⵓⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵅ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵃⴰⵅⵉⵍⴰ ⵜⴻⵏⵏⵉ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵜⵏⴻⵣⵔⵓⴼⵜ. ⴷⴰⵡⵓⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⵥⵔⴰ ⵛⴰⵡⵓⵍ ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S126_4","010_26_4","1SA","26","4","4","ⵎⴰⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵅⴱⴰⵔⵊⵉⵢⵢⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S126_5","010_26_5","1SA","26","5","5","ⴷⴰⵡⵓⴷ ⵉⴽⴽⴰⵔ ⵓ ⵢⵓⵙⴰ-ⴷⴷ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⵛⴰⵡⵓⵍ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ. ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⵣⴻⵍ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ. ⵛⴰⵡⵓⵍ ⵉⵟⵟⴻⵚ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S126_6","010_26_6","1SA","26","6","6","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ. ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⴰⵃⵉⵜⵜⵉ, ⵓ ⴰⴽ-ⴷ ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵚⵉⵔⵓⵢⴰ, ⵓⵎⴰⵙ ⵏ ⵢⵓⵡⴰⴱ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⴰⴽⵉⴷⵉ ⵉ ⵖⴰ ⵉⵀⵡⴰⵏ ⵖⴰⵔ ⵛⴰⵡⵓⵍ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ?” ⴰⴱⵉⵛⴰⵢ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴷⴻⴽ ⵀⵡⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("S126_7","010_26_7","1SA","26","7","7","ⵢⵓⵙⴰ-ⴷⴷ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⴰⴱⵉⵛⴰⵢ ⴷⵉ ⴵⵉⵍⴻⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ, ⵓ ⵅⵣⴰⵔ, ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵉⵟⵟⴻⵚ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵜⴻⵊⵊⵓ ⵣⵣⴰⵜ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵉⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⴰⴱⵏⵉⵔ ⴷ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S126_8","010_26_8","1SA","26","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵉⵛⴰⵢ ⵉ ⴷⴰⵡⵓⴷ: “ⴰⵙⵙ-ⴰ ⵉⵇⵇⴻⵏ ⵙⵉⴷⵉ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⴻⵊⵊ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜ ⵙⵙⵏⵓⵇⵇⴱⴻⵖ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵏ ⵍⴰⵏⵙⴰ. ⵡⴰⵔ ⵜⵜⴻⵃⴷⵉⵊⵉⵖ ⴰⴷ ⵜⵜ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("S126_9","010_26_9","1SA","26","9","9","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⴰⴱⵉⵛⴰⵢ: “ⵡⴰⵔ ⵜ ⵜⵜⴰⵔⴻⴷⴷⴻⴵ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⴰⵔⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷ ⴰⴼⵓⵔⵔⵉ?” ");
INSERT INTO rift_vpl VALUES ("S126_10","010_26_10","1SA","26","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⵡⵡⴻⵜ: ⵏⵉⵖ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴰⵙⵙ ⵏⵏⴻⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ ⵏⵉⵖ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S126_11","010_26_11","1SA","26","11","11","ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵃⴹⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵡⵜⴻⵖ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⴽⵙⵉ ⵍⴰⵏⵙⴰ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵜⴻⴱⵔⵉⵇⵜ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ!” ");
INSERT INTO rift_vpl VALUES ("S126_12","010_26_12","1SA","26","12","12","ⵉⴽⵙⵉ ⴷⴰⵡⵓⴷ ⵍⴰⵏⵙⴰ ⴷ ⵜⴻⴱⵔⵉⵇⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵉⵥⵔⵉ, ⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵢⵓⵛⵉ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴼⵉⵇ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵟⵟⵚⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵖⴹⴻⵙ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S126_13","010_26_13","1SA","26","13","13","ⴷⴰⵡⵓⴷ ⵉⵄⴷⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ⵜⵓⵖⴰ ⵉⴵⴰ ⵜⵜⴰⵙⵉⵄ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S126_14","010_26_14","1SA","26","14","14","ⵉⵍⴰⵖⴰ-ⴷⴷ ⴷⴰⵡⵓⴷ ⵉ ⵍⴳⴻⵏⵙ ⵓ ⵉ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⴰⵔⵔⵉⴷ ⵛⴰ, ⴰⴱⵏⵉⵔ?” ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⴱⵏⵉⵔ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⴷ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵓⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("S126_15","010_26_15","1SA","26","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⴱⵏⵉⵔ: “ⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⴷ ⴰⵔⵢⴰⵣ? ⵎⴰⵏ ⵡⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵉ ⵉⴵⴰⵏ ⴰⵎ ⵛⴻⴽ? ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵅ ⵙⵉⴷⵉ ⵏⵏⴻⵛ, ⴰⵊⴻⴵⵉⴷ? ⴰⵇⴰ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵊⴻⴵⵉⴷ, ⵙⵉⴷⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S126_16","010_26_16","1SA","26","16","16","ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵎⵍⵉⵃ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵍⵎⴻⵡⵜ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵄⴻⵙⵙⴻⵎ ⵅ ⵙⵉⴷⵉ ⵏⵡⴻⵎ, ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ! ⵅⵣⴰⵔ ⵎⴰⵏⵉ ⴵⴰⵏⵜ ⵍⴻⵅⵅⵓ ⵍⴰⵏⵙⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵜⴻⴱⵔⵉⵇⵜ ⵏ ⵡⴰⵎⴰⵏ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵜ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("S126_17","010_26_17","1SA","26","17","17","ⵛⴰⵡⵓⵍ ⵉⵄⵇⴻⵍ ⵜⵎⵉⵊⵊⴰ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵎⴰ ⵜⴰ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ, ⴰ ⵎⵎⵉ ⴷⴰⵡⵓⴷ?” ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("S126_18","010_26_18","1SA","26","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⴹⴻⴼⴼⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴰⵎⵎⵓ? ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⴳⴳⵉⵖ ⵓ ⵎⴰⵏ ⵜ ⵍⵄⵉⴱ ⵉ ⵢⵓⵎⵙⴻⵏ ⵖⴰⵔ ⵓⴼⵓⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("S126_19","010_26_19","1SA","26","19","19","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⴰⴷ ⵉⵙⴻⵍ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵀⵡⴻⵍ ⵉ ⵛⴻⴽ ⵅⴰⴼⵉ, ⵉⵍⵉ ⴰⴷ ⵉⵛⴻⵎⵎ ⵏⴻⵜⵜⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷ ⵉⵡⴷⴰⵏ ⵉ ⵉⴵⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵓⵥⵥⵍⴻⵏ ⵅⴰⴼⵉ ⴰⵙⵙ-ⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵇⵇⵏⴻⵖ ⵄⴰⴷ ⵉ ⵍⵡⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓ ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵔⵓⵀ, ⵙⴻⵅⵅⴰⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ!’ ");
INSERT INTO rift_vpl VALUES ("S126_20","010_26_20","1SA","26","20","20","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⵜⵜⵉⵣⵣⵍⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵙⵉⴷⵉ. ⵎⵉⵏⵣⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⴼⴼⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵉⵊⵊ ⵏ ⵓⵢⴻⵏⵏⵉ ⵏ ⵓⵛⵓⵔⴷⵓ ⵡⴰⵀⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⴻⵎⵎⴰⵔⴻⵏ ⵜⴰⵙⴻⴽⴽⵓⵔⵜ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("S126_21","010_26_21","1SA","26","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ, ⵄⵇⴻⴱ-ⴷⴷ, ⴰ ⵎⵎⵉ ⴷⴰⵡⵓⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵛ ⵜⵜⴻⴳⴳⴻⵖ ⵄⴰⴷ ⵍⵖⴰⵔ, ⵎⵉⵏⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵜⵓⵖⴰ ⴰⵙⵙ-ⴰ ⵜⵙⴻⴽⴽⵡⴰ ⵖⴰⵔⴻⴽ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵓ ⵡⴻⴷⴷⴰⵔⴻⵖ ⵙ ⵡⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("S126_22","010_26_22","1SA","26","22","22","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵍⴰⵏⵙⴰ ⵏ ⵓⵊⴻⴵⵉⴷ. ⴻⵊⵊ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵥⵡⴰ, ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ ⵢⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("S126_23","010_26_23","1SA","26","23","23","ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵙⵉⴷⵉ ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⴷ ⵜⵜⵉⵇⵇⴻⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉ ⵛⴻⴽ ⴰⵙⵙ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴷⴻⴳ ⵓⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S126_24","010_26_24","1SA","26","24","24","ⵅⵣⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵙⵙ-ⴰ ⵜⵉⵖⵍⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵜⵉⵖⵍⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⴼⴻⴽⴽ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("S126_25","010_26_25","1SA","26","25","25","ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ, ⵎⵎⵉ ⴷⴰⵡⵓⴷ. ⵎⵉⵏ ⵎⴰ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⴰⵇⴰ ⴰⴷ ⵜⴰⵡⴹⴻⴷ ⵄⴰⵡⴻⴷ.” ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⴰⵡⵓⴷ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵓ ⵛⴰⵡⵓⵍ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S127_1","010_27_1","1SA","27","1","1","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵖ ⵅ ⵓⴼⵓⵙ ⵏ ⵛⴰⵡⵓⵍ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵃⴰⵛⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴹⴻⵄ ⵉ ⵛⴰⵡⵓⵍ ⵍⴰⵢⴰⵙ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵢⴰⵔⵣⵓ ⵄⴰⴷ ⴽⵜⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⴻⵊⵎⴻⵖ ⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S127_2","010_27_2","1SA","27","2","2","ⴷⴰⵡⵓⴷ ⵉⴽⴽⴰⵔ, ⵏⴻⵜⵜⴰ ⴷ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵄⴷⵓⵏ ⵖⴰⵔ ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⵓⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S127_3","010_27_3","1SA","27","3","3","ⵉⵇⵇⵉⵎ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⴰⵅⵉⵙ, ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⴷⴰⵡⵓⴷ ⵉⵣⴷⴻⵖ ⴷⵉⵏ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⴰⵅⵉⵏⵓⵄⴰⵎ ⵣⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵓ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵏⴰⴱⴰⵍ, ⵣⵉ ⴽⴰⵔⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S127_4","010_27_4","1SA","27","4","4","ⵓⵎⵉ ⵏⵏⴰⵏ ⵉ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵊⴰⵜ, ⵡⴰⵔ ⵢⴰⵔⵏⵉ ⵉⵇⵇⵉⵎ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵣⵓ ⵄⴰⴷ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S127_5","010_27_5","1SA","27","5","5","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵅⵉⵛ: “ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⵏⴻⵛⵛ ⵍⵅⴰⴹⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⴻⵡⵛ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⴷⴻⴳ ⵉⵛⵜ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉⵏ. ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵖⴰⵔⴻⴽ ⵉ ⵖⴰ ⵉⵣⴷⴻⵖ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("S127_6","010_27_6","1SA","27","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵙ ⴰⵅⵉⵛ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵚⵉⵇⵍⴰⵖ. ⵙ ⵓⵢⴰ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵚⵉⵇⵍⴰⵖ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S127_7","010_27_7","1SA","27","7","7","ⵓⵙⵙⴰⵏ ⵉ ⵉⴽⴽⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S127_8","010_27_8","1SA","27","8","8","ⴷⴰⵡⵓⴷ ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⴽⴻⵛⵛⴹⴻⵏ ⵉⵊⴰⵛⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴰⵔⵣⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ, ⵎⵉⵏⵣⵉ ⵉⵏⴰ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵓⵔ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S127_9","010_27_9","1SA","27","9","9","ⴷⴰⵡⵓⴷ ⵉⵡⵜⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵉⴷⴷⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ. ⵉⵟⵟⴻⴼ ⵄⴰⵡⴻⴷ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵓⵛⴰ ⵉⵄⵇⴻⴱ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴰⵅⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("S127_10","010_27_10","1SA","27","10","10","ⵓ ⴰⵅⵉⵛ ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵜⵔⵓⵃⴻⵎ ⴰⵙⵙ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴽⴻⵛⵛⴹⴻⵎ?” ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵢⴰⵀⵓⴷⴰ!”, ⵏⵉⵖ: “ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵢⴰⵔⵃⴰⵎⵉⵜⵉⵍⵉⵢⵢⴻⵏ!”, ⵏⵉⵖ: “ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("S127_11","010_27_11","1SA","27","11","11","ⵡⴰⵔ ⵉⵊⵊⵉ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⴷⴷⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵉⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵊⴰⵜ. ⵉⵏⵏⴰ: “ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵜⵜⵄⵉⵡⵉⴷⴻⵏ ⵡⴰⵍⵓ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵜⴰ ⵉ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ!’” ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴻⴳⴳ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵉⴽⴽⴰ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S127_12","010_27_12","1SA","27","12","12","ⴰⵅⵉⵛ ⵉⵜⵜⵉⵇⵇ ⴷⵉ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵅ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("S128_1","010_28_1","1SA","28","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵍⴰⵎⵉ ⵙⵙⵎⵓⵏⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵅⵉⵛ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⴼⴼⵖⴻⴷ ⵙ ⵓⵖⵉⵍ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ, ⵛⴻⴽ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S128_2","010_28_2","1SA","28","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵅⵉⵛ: “ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴻⴳⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ!” ⴰⵅⵉⵛ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵙ ⵓⵢⴰ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⴰⵄⴻⵙⵙⴰⵙ ⵅⴰⴼⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S128_3","010_28_3","1SA","28","3","3","ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵛⴹⴻⵏ ⵅⴰⵙ. ⵏⵉⵜⵏⵉ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵔⴰⵎⴰ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ. ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⵓⵍⴰ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S128_4","010_28_4","1SA","28","4","4","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵓⵏⴰⵎ ⵓ ⵛⴰⵡⵓⵍ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵊⵉⵍⴱⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S128_5","010_28_5","1SA","28","5","5","ⵓⵎⵉ ⵉⵥⵔⴰ ⵛⴰⵡⵓⵍ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵓ ⵡⵓⵍ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⵉⵜⵜⴻⵇⴷⵉⴷⴷⵉⵙ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S128_6","010_28_6","1SA","28","6","6","ⵛⴰⵡⵓⵍ ⵉⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵛⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵜⵉⵔⵊⴰ, ⵓⵍⴰ ⵙ ⵓⵔⵉⵎ, ⵓⵍⴰ ⵙ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S128_7","010_28_7","1SA","28","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴰⵔⵣⵓⵎ ⴰⵢⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⴷⴷⴻⴱⴱⴰⵔⴰⵏ ⵅ ⴱⵓⵃⴱⴻⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⵔⴰⵃⴻⵖ ⵓ ⴰⴷ ⵜⵜ ⵙⵙⴻⵇⵙⵉⵖ.” ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ, ⴷⵉ ⵄⴰⵢⵏ-ⴷⵓⵔ ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵉⴷⴷⴻⴱⴱⴰⵔⴰⵏ ⵅ ⴱⵓⵃⴱⴻⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S128_8","010_28_8","1SA","28","8","8","ⵛⴰⵡⵓⵍ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵢⵓⵢⵓⵔ. ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ, ⵓⵛⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴳⴻⵣⵣⴻⵏ ⴰⵢⵉ ⵣⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵓⵛⴰ ⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⵅ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("S128_9","010_28_9","1SA","28","9","9","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵅⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ: “ⴰⵇⴰ ⴷⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ ⵎⵉⵏ ⵉⴳⴳⴰ ⵛⴰⵡⵓⵍ, ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵃⵃⴰ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵍⴼⴻⵅ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("S128_10","010_28_10","1SA","28","10","10","ⵛⴰⵡⵓⵍ ⵎⴰⵛⴰ ⵉⵊⵊⵓⴵ ⴰⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵛⴻⵎ ⵉⵍⴻⵇⵇⴻⴼ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵛⴰ ⵍⵄⵉⴱ!” ");
INSERT INTO rift_vpl VALUES ("S128_11","010_28_11","1SA","28","11","11","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵅⴻⴼ-ⴷⴷ ⵉ ⵖⴰ ⵍⴰⵖⵉⵖ ⵉ ⵛⴻⴽ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ “ⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⵅ ⵛⴰⵎⵡⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("S128_12","010_28_12","1SA","28","12","12","ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵛⴰⵎⵡⵉⵍ, ⵜⴻⵙⵖⵓⵢ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⵛⴻⵎⵜⴻⴷ? ⵛⴻⴽ ⴰⵇⴰ ⴷ ⵛⴰⵡⵓⵍ!” ");
INSERT INTO rift_vpl VALUES ("S128_13","010_28_13","1SA","28","13","13","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⵎ?” ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵛⴰⵡⵓⵍ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵙⴻⵏ ⴷⴻⴳ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("S128_14","010_28_14","1SA","28","14","14","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⴰ ⵜⵉⴷⴷⵉ ⵏⵏⴻⵙ?” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵉⵊⵊ ⵏ ⵓⵡⴻⵙⵙⴰⵔ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵓ ⵢⴰⵔⴹ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ.” ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵏ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ-ⵜ ⴷ ⵛⴰⵎⵡⵉⵍ, ⵢⵓⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("S128_15","010_28_15","1SA","28","15","15","ⵓⵛⴰ ⵛⴰⵎⵡⵉⵍ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⵀⴻⵡⵍⴻⴷ, ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵍⴰⵖⴰⵏ?” ⵛⴰⵡⵓⵍ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽⵉⴷⵉ ⵓ ⴰⵔⴻⴱⴱⵉ ⵉⵃⴻⵢⵢⴻⴷ ⵅⴰⴼⵉ ⵓ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ ⵄⴰⴷ, ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓⵍⴰ ⵙ ⵜⵉⵔⵊⴰ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅⴰⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S128_16","010_28_16","1SA","28","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵎⵡⵉⵍ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵙⴻⵇⵙⵉⴷ, ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵃⴻⵢⵢⴻⴷ ⵅⴰⴽ ⵓ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴹⵉⴷⴷ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("S128_17","010_28_17","1SA","28","17","17","ⵙⵉⴷⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵣⵣⴰⵢⵉ ⵉⵏⵏⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵇⵍⴻⵄ ⵉ ⵛⴻⴽ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵉ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S128_18","010_28_18","1SA","28","18","18","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⵛⴰ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵄⴰⵎⴰⵍⵉⵇ, ⵅ ⵓⵢⴰ ⵉ ⴷ ⴰⵛ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵙⵙ-ⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S128_19","010_28_19","1SA","28","19","19","ⵙⵉⴷⵉ ⴰⴷ ⴽⵉⴷⴻⴽ ⵉⴳⴳ ⵓⵍⴰ ⴷ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔⵉ. ⵓⵍⴰ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜ ⵉⴳⴳ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S128_20","010_28_20","1SA","28","20","20","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ ⵛⴰⵡⵓⵍ ⴷⴻⵖⵢⴰ, ⵉⴱⴻⵇⵇⴻⴹ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵛⴰⵎⵡⵉⵍ, ⵓⵛⴰ ⵊⵊⴻⵀⴷ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵇⵇⵉⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵛⵛⵉ ⴰⵖⵔⵓⵎ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⴽⴻⵎⵎⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S128_21","010_28_21","1SA","28","21","21","ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⵛⴰⵡⵓⵍ, ⵓⵛⴰ ⵜⴻⵥⵔⴰ ⵉ-ⵜ ⵢⴰⵔⵊⴻⴼ ⴰⵟⵟⴰⵙ. ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵜⴻⵙⵍⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⵙⴻⴱⴱⵍⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⵙⵍⵉⵖ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S128_22","010_28_22","1SA","28","22","22","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ! ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵇⴻⴷⴷⵎⴻⵖ ⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ. ⴻⵛⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵊⵀⴻⴷⴻⴷ ⵅⵎⵉ ⵖⴰ ⵜᵉⵟⵟⴼⴻⴷ ⴰⴱⵔⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S128_23","010_28_23","1SA","28","23","23","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ!” ⵎⴰⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵃⵚⴰⵔⴻⵏ ⵜ ⴰⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵏⴻⵜⵜⴰ ⵖⴰⵔⵙⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵇⵇⵉⵎ ⵅ ⵇⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("S128_24","010_28_24","1SA","28","24","24","ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵉⵎⵙⴻⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵜⵖⴰⵔⵚ ⴰⵙ ⴷⴻⵖⵢⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⴰⵡⵔⴻⵏ, ⵜⴻⴳⴳⵯⴰ ⴰⵔⴻⵛⵜⵉ ⵓ ⵜⴻⴳⴳⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S128_25","010_28_25","1SA","28","25","25","ⵏⴻⵜⵜⴰⵜ ⵜⵇⴻⴷⴷⴻⵎ ⴰⵢⴰ ⵉ ⵛⴰⵡⵓⵍ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵛⵛⵉⵏ ⵏⵉⵜⵏⵉ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴽⴽⴰⵔⴻⵏ ⵓ ⴰⵔⴻⴳⴳⵯⵃⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S129_1","010_29_1","1SA","29","1","1","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⴼⵉⵇ ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S129_2","010_29_2","1SA","29","2","2","ⵓⵛⴰ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵥⵡⴰⵏ ⵖⴰⵔ ⴷⵉⵏ ⵙ ⵍⵎⵢⴰⵡⴰⵜ ⴷ ⵍⵓⵍⵓⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵥⵡⴰ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⴰⵅⵉⵛ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("S129_3","010_29_3","1SA","29","3","3","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ: “ⵎⵉⵏ ⴷⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ-ⴰ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵅⵉⵛ ⵅ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ: “ⵎⴰ ⵡⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴷⴰⵡⵓⴷ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵛⴰⵡⵓⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵉ ⵉⴵⴰⵏ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵡⴰⵙⵙ? ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴻⵄⴷⵓ ⴰⵍ ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ.” ");
INSERT INTO rift_vpl VALUES ("S129_4","010_29_4","1SA","29","4","4","ⴼⴼⵓⴳⴳⵎⴻⵏ ⵅⴰⵙ ⴰⵟⵟⴰⵙ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵏⵏⴰⵏ ⴰⵙ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ: “ⵙⴻⴽⴽ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⵄⵇⴻⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵀⵡⴰ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵖ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ⵎⴰⵖⴰⵔ ⵙ ⵎⵉⵏⵣⵉ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵉⵚⵍⴻⵃ ⴰⴽ-ⴷ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⴽ-ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("S129_5","010_29_5","1SA","29","5","5","ⵎⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴷⴰⵡⵓⴷ ⵡⴻⵏⵏⵉ ⵅ ⵖⴻⵏⵏⵊⴻⵏⵜ ⴷ ⵛⴻⴹⵃⴻⵏⵜ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵏⵏⴰⵏⵜ: ‘ⵛⴰⵡⵓⵍ ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⵍⵓⵍⵓⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵏⴻⵜⵜⴰ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏⵏⴻⵙ?’” ");
INSERT INTO rift_vpl VALUES ("S129_6","010_29_6","1SA","29","6","6","ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⴰⵅⵉⵛ ⵉ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵚⴷⵉⵇ. ⵓⴼⵓⵖ ⵏⵏⴻⵛ ⴷ ⵡⴻⵄⵇⴰⴱ ⵏⵏⴻⵛ ⴰⴽⵉⴷⵉ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵛⴰ ⵏ ⵍⵖⴻⵛⵛ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("S129_7","010_29_7","1SA","29","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵄⵇⴻⴱ, ⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵇⴰⵄ ⵛⴰ ⵏ ⵍⵖⴻⵛⵛ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S129_8","010_29_8","1SA","29","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵅⵉⵛ: “ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⴳⴳⵉⵖ? ⵎⵉⵏ ⵜⵓⴼⵉⴷ ⴷⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⵍ ⴰⵙⵙ-ⴰ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵔⵓⵃⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⴰⴷ ⵎⴻⵏⵖⴻⵖ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("S129_9","010_29_9","1SA","29","9","9","ⴰⵅⵉⵛ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵜⵜ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ.’ ");
INSERT INTO rift_vpl VALUES ("S129_10","010_29_10","1SA","29","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⴽⴽⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ ⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⴷⴷ-ⵢⵓⵙⵉⵏ. ⵎⴰⵍⴰ ⵜⴻⴽⴽⴰⵔⴻⵎ ⵙ ⵡⴰⵙⵙ ⵣⵉⵛ ⵓⵛⴰ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ, ⴼⴼⵖⴻⵎ ⵅⴻⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("S129_11","010_29_11","1SA","29","11","11","ⴷⴰⵡⵓⴷ ⵉⴽⴽⴰⵔ ⵣⵉⵛ, ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵚⵚⴱⴻⵃ, ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⴰⵛⴰ ⴼⴼⵖⴻⵏ, ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S130_1","010_30_1","1SA","30","1","1","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵚⵉⵇⵍⴰⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵜⵓⵖⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⴽⴻⵛⵛⴹⴻⵏ ⵍⵊⴰⵏⵓⴱ ⵓⵍⴰ ⴷ ⵚⵉⵇⵍⴰⵖ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵚⵉⵇⵍⴰⵖ, ⵇⵇⴷⴻⵏ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ ");
INSERT INTO rift_vpl VALUES ("S130_2","010_30_2","1SA","30","2","2","ⵓⵛⴰ ⵃⴻⴱⴱⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ. ⵡⴰⵔ ⵏⵖⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⴰⵎⴻⵥⵢⴰⵏ ⵏⵉⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⴰⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S130_3","010_30_3","1SA","30","3","3","ⵢⵓⵙⴰ-ⴷⴷ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵃⴻⵡⵡⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S130_4","010_30_4","1SA","30","4","4","ⴷⴰⵡⵓⴷ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵙⵖⵓⵢⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵊⵊⴻⵀⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵖⵓⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S130_5","010_30_5","1SA","30","5","5","ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴷⴰⵡⵓⴷ ⵜⵜⵡⴰⵃⴻⵡⵡⵙⴻⵏⵜ, ⴰⵅⵉⵏⵓⵄⴰⵎ ⵣⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵓ ⴰⴱⵉⵊⴰⵢⵉⵍ ⵣⵉ ⴽⴰⵔⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S130_6","010_30_6","1SA","30","6","6","ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⴷ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴰⵔⴻⵊⵎⴻⵏ, ⵎⴰⵖⴰⵔ ⵍⴻⵄⵎⵓⵔ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⴰⵔⴻⵣⴳⴻⵏ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵅ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S130_7","010_30_7","1SA","30","7","7","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴱⵢⴰⵜⴰⵔ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ: “ⴰⵡⵉ-ⴷⴷ ⴷⴰ ⵖⴰⵔⵉ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ!” ⵓ ⴰⴱⵢⴰⵜⴰⵔ ⵢⵉⵡⵉ-ⴷⴷ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S130_8","010_30_8","1SA","30","8","8","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⴷⴰⵡⵓⴷ ⵉ ⵙⵉⴷⵉ: “ⵎⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵖ ⴱⴰⵏⴷⵉⵢⵢⴰ-ⵢⴰ? ⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴰⵔⵜⴻⵖ?” ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵃⴰⵔⵜⴻⴷ ⵓ ⴰⴷ ⵜⴼⴻⴽⴽⴻⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵉⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S130_9","010_30_9","1SA","30","9","9","ⵉⴼⴼⴻⵖ-ⴷⴷ ⴷⴰⵡⵓⴷ, ⵏⴻⵜⵜⴰ ⴷ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ. ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵍ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⴱⴰⵙⵓⵔ, ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("S130_10","010_30_10","1SA","30","10","10","ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵇⵇⵉⵎ ⵉⴹⴻⴼⴼⴰⵔ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏⵏⵉ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⵎⵉⵜⴰⵢⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵃⵍⴻⵏ ⴰⵟⵟⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⵡⴰⵏ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⴱⴰⵛⵓⵔ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S130_11","010_30_11","1SA","30","11","11","ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵚⵔⵉ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵙ ⴰⵖⵔⵓⵎ ⵓ ⵏⴻⵜⵜⴰ ⵉⵛⵛⴰ ⵓ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵙ ⵄⴰⵡⴻⴷ ⴰⵎⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("S130_12","010_30_12","1SA","30","12","12","ⴰⵔⵏⵉⵏ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵜⴰⵣⴰⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⵔⵓⵎⴻⵏ ⵏ ⵣⵣⴱⵉⴱ ⵓ ⵏⴻⵜⵜⴰ ⵉⵛⵛⴰ, ⵉⴷⵡⴻⵍ ⴰⵙ-ⴷⴷ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵛⵛⵉ ⵡⴰⵔ ⵉⵙⵡⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⴵⵉⵢⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("S130_13","010_30_13","1SA","30","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⴷⴰⵡⵓⴷ: “ⵡⵉ ⵛⴻⴽ ⵢⵉⵍⴰⵏ ⵓ ⵎⴰⵏⵉⵙ ⵛⴻⴽ?” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵃⵓⴷⵔⵉ ⴰⵎⵉⵚⵔⵉ: “ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵓ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵊⵊⴰ ⴰⵢⵉ, ⵍⴰⵎⵉ ⵀⴻⵍⵛⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵣⴻⴳ ⵡⴰⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("S130_14","010_30_14","1SA","30","14","14","ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⴽⴻⵛⵛⴻⴹ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵉⴽⴰⵔⵉⵜⵉⵢⵢⵉⵏ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⴽⴰⵍⵉⴱ, ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵛⵎⴻⴹ ⵚⵉⵇⵍⴰⵖ ⵙ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("S130_15","010_30_15","1SA","30","15","15","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⵏⴻⴷⵀⴻⴷ ⵖⴰⵔ ⴱⴰⵏⴷⵉⵢⵢⴰ-ⵢⴰ ⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵊⴰⴵ ⴰⵢⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵏⴻⵇⵇⴻⴷ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵄⴻⴷⴷⵓⴷ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ! ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵏⴻⴷⵀⴻⵖ ⵖⴰⵔ ⴱⴰⵏⴷⵉⵢⵢⴰ-ⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("S130_16","010_30_16","1SA","30","16","16","ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⴷⵉⵏ, ⵓ ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵛⵛⵉⵏ, ⵙⵡⵉⵏ ⵓ ⵛⴻⴹⵃⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S130_17","010_30_17","1SA","30","17","17","ⴷⴰⵡⵓⴷ ⵉⵡⵜⴰ ⵅⴰⵙⴻⵏ ⵣⵉ ⵜⴱⴰⵎⴱⴰⵙⵜ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵏ ⵡⴰⵙⵙ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⵏⵊⵉⵎ, ⵎⵖⵉⵔ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵉⵍⴻⵖⵎⴰⵏ, ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S130_18","010_30_18","1SA","30","18","18","ⴰⵎⵎⵓ ⴷⴷ-ⵉⴼⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴽⴽⵙⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ. ⴷⴰⵡⵓⴷ ⵉⴼⴻⴽⴽ-ⴷⴷ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S130_19","010_30_19","1SA","30","19","19","ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴽⴽⵙⴻⵏ, ⵡⴰⵔ ⵉⵡⴻⴷⴷⴰⵔ ⵡⴰⵍⵓ. ⵎⴰⵔⵔⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S130_20","010_30_20","1SA","30","20","20","ⵉⴽⵙⵉ ⴷⴰⵡⵓⴷ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ⵏⴻⴷⵀⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵜⴰ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⴷⴰⵡⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("S130_21","010_30_21","1SA","30","21","21","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵃⵍⴻⵏ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⴷⴰⵡⵓⴷ ⵄⴰⴷ, ⵉⵏⵏⵉ ⵉⵊⵊⴰ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴱⴰⵛⵓⵔ, ⴰⵇⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ ⵓ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ. ⴷⴰⵡⵓⴷ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S130_22","010_30_22","1SA","30","22","22","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵊⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⴼⴼⵉⵖⴻⵏ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵏᵉⵜⵜⵉⵛ ⵡⴰⵍⵓ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵉ ⴷⴷ-ⵏⴼⴻⴽⴽ, ⵎⵖⵉⵔ ⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ⴷ ⵉⵏⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⴰⵔⴻⴳⴳⵯⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S130_23","010_30_23","1SA","30","23","23","ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵎⴻⵏⵏⵉ, ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⴰⵢⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵃⴹⴰ ⴰⵏⴻⵖ ⵓ ⵉⵡⵛⴰ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵡⴹⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S130_24","010_30_24","1SA","30","24","24","ⵡⵉ ⵖⴰⵔⵡⴻⵎ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵏⵡⴻⵎ? ⵎⴰⵖⴰⵔ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵣⵉⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⴱⴹⴰⵏ ⵊⵎⵉⵄ.” ");
INSERT INTO rift_vpl VALUES ("S130_25","010_30_25","1SA","30","25","25","ⴰⵎⵎⵓ ⵉ ⵜⵜ ⵜⴻⵇⵇⵉⵎ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⴼⴰⵔⵉⴹⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S130_26","010_30_26","1SA","30","26","26","ⵓⵎⵉ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵚⵉⵇⵍⴰⵖ, ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵜⵉⵔⵣⴻⴼⵉⵏ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵖⴰⵔ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ, ⴰⵎ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ: “ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵙⵉⴷⵉ”. ");
INSERT INTO rift_vpl VALUES ("S130_27","010_30_27","1SA","30","27","27","ⵉⵙⵙⴻⴽⴽ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵔⴰⵎⴰⵜ ⴷⵉ ⵍⵊⴰⵏⵓⴱ, ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵢⴰⵜⵜⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("S130_28","010_30_28","1SA","30","28","28","ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵄⴰⵔⵓⵄⵉⵔ, ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵙⵉⴼⵎⵓⵜ, ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵉⵛⵉⵜⵉⵎⵓⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("S130_29","010_30_29","1SA","30","29","29","ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵔⴰⵅⵉⵍ, ⵉ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵢⴰⵔⵃⴰⵎⵜⵉⵍⵉⵢⵢⴻⵏ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("S130_30","010_30_30","1SA","30","30","30","ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵃⵓⵔⵎⴰ, ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⴽⵓⵔ-ⵄⴰⵛⴰⵏ, ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵄⴰⵜⴰⴽ, ");
INSERT INTO rift_vpl VALUES ("S130_31","010_30_31","1SA","30","31","31","ⵉ ⵢⵉⵏⵏⵉ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴽⴽⴰ ⴷⴰⵡⵓⴷ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S131_1","010_31_1","1SA","31","1","1","ⵎⵎⴻⵏⵖⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵡⴹⴰⵏ ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S131_2","010_31_2","1SA","31","2","2","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴹⴼⴰⵔⴻⵏ ⵛⴰⵡⵓⵍ ⴷ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⵓⵛⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵖⵉⵏ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⴰⴱⵉⵏⴰⴷⴰⴱ ⴷ ⵎⴰⵍⴽⵉⵛⵓⵄⴰ, ⴰⵔⵔⴰⵡ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S131_3","010_31_3","1SA","31","3","3","ⵉⴷⵡⴻⵍ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ ⵉⵡⵄⴰⵔ. ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵙ ⵍⵇⴻⵡⵙ, ⵓⴼⵉⵏ ⵜ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ. ");
INSERT INTO rift_vpl VALUES ("S131_4","010_31_4","1SA","31","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ: “ⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵛ, ⵙⵏⵓⵇⵇⴻⴱ ⴰⵢⵉ ⵣⵣⴰⵢⴻⵙ! ⵏⵉⵖ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵓ ⴰⴷ ⵣⵣⴰⵢⵉ ⵙⵜⴻⵀⵣⴰⵏ.” ⵎⴰⵛⴰ ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⵜ ⵉⴳⴳ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ. ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵛⴰⵡⵓⵍ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵊⵊⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⵉⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("S131_5","010_31_5","1SA","31","5","5","ⵓⵎⵉ ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵉⵥⵔⴰ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵉⵎⵎⵓⵜ, ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⴹⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S131_6","010_31_6","1SA","31","6","6","ⴰⵎⵎⵓ ⵉ ⵉⵎⵎⵓⵜ ⵛⴰⵡⵓⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵎⵓⵏ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⴽ-ⴷ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵓⵍⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S131_7","010_31_7","1SA","31","7","7","ⵓⵎⵉ ⵥⵔⵉⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⴷ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵇⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⵡⵍⴻⵏ ⵓ ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵏⵖⴻⵏ, ⵙⴻⵎⵃⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S131_8","010_31_8","1SA","31","8","8","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵓⴼⵉⵏ ⵛⴰⵡⵓⵍ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴹⴰⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S131_9","010_31_9","1SA","31","9","9","ⵏⵉⵜⵏⵉ ⵇⴻⵙⵙⴻⵏ ⴰⵙ ⴰⵣⴻⴵⵉⴼ, ⵙⵙⴰⵔⵅⵓⵏ ⴰⵙ ⵍⴻⵙⵏⴰⵃ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵓ ⵊⴰⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S131_10","010_31_10","1SA","31","10","10","ⵍⴻⵙⵏⴰⵃ ⵏ ⵛⴰⵡⵓⵍ ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ‘ⵄⴰⵛⵜⴰⵔⵓⵜⵉⵏ’, ⵓ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ ⵓⵢⵍⴻⵏ ⵜⵜ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S131_11","010_31_11","1SA","31","11","11","ⵓⵎⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⴱⵉⵛ-ⵊⵉⵍⵄⴰⴷ ⵙⵍⴰⵏ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵛⴰⵡⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("S131_12","010_31_12","1SA","31","12","12","ⴽⴽⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵓⵢⵓⵔⴻⵏ ⴵⵉⵍⴻⵜ ⵜⵎⵓⵏ ⵓⵛⴰ ⴽⵙⵉⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵣⵉ ⵍⵃⵉⴹ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵢⴰⴱⵉⵛ ⵓⵛⴰ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴻⵏⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S131_13","010_31_13","1SA","31","13","13","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵉⵖⵙⴰⵏ ⵏⵙⴻⵏ, ⵏⴻⴹⵍⴻⵏ ⵜⴻⵏ ⵙⴰⴷⵓ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵎⴰⵔⵉⵙⵜ ⵏ ⵢⴰⴱⵉⵛ ⵓⵛⴰ ⵥⵓⵎⵎⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S21_1","011_1_1","2SA","1","1","1","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵛⴰⵡⵓⵍ, ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴷⴰⵡⵓⴷ ⵣⵉ ⵍⴻⵖⵍⴻⴱ ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ, ⵉⵇⵇⵉⵎ ⴷⴰⵡⵓⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵚⵉⵇⵍⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("S21_2","011_1_2","2SA","1","2","2","ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⴰⵇⴰ ⴷⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵛⴰⵡⵓⵍ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵛⴰⵔⵔⴻⴳ ⵓ ⵙ ⵓⵛⴰⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵢⵓⴹⴰⵔ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S21_3","011_1_3","2SA","1","3","3","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵛⴻⴽ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵊⵎⴻⵖ-ⴷⴷ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S21_4","011_1_4","2SA","1","4","4","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷⵉⵏ ⴷ ⵍⴻⵅⴱⴰⵔ? ⵉⵏⵉ ⴰⵢⵉ ⵜ!” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵍⴳⴻⵏⵙ ⵢⴰⵔⵡⴻⵍ ⵣⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵓ ⴰⵟⵟⴰⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴹⴰⵏ, ⵎⵎⵓⵜⴻⵏ. ⵓⵍⴰ ⴷ ⵛⴰⵡⵓⵍ ⴷ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ ⵎⵎⵓⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S21_5","011_1_5","2SA","1","5","5","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵓⵃⵓⴷⵔⵉ ⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴱⴻⵍⵍⵉ ⵛⴰⵡⵓⵍ ⴷ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ ⵎⵎⵓⵜⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S21_6","011_1_6","2SA","1","6","6","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵃⵓⴷⵔⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ: “ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ ⵓⵛⴰ ⵥⵔⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵉⵙⴻⵏⵏⴻⴷ ⵛⴰⵡⵓⵍ ⵅ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵓ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵏⵢⵉⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜ ⴱⵍⴰ ⵇⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("S21_7","011_1_7","2SA","1","7","7","ⵏⴻⵜⵜⴰ, ⴰⵎ ⴷⴷ-ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵉⵥⵔⴰ ⴰⵢⵉ, ⵉⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⵓ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙ: ‘ⴰⵇⴰ-ⵢⵉ ⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("S21_8","011_1_8","2SA","1","8","8","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ?’ ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅⴰⵙ: ‘ⵏⴻⵛⵛ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ.’ ");
INSERT INTO rift_vpl VALUES ("S21_9","011_1_9","2SA","1","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵏⴻⵜⵜⴰ: ‘ⴰⵙ-ⴷⴷ ⵖⴰⵔⵉ, ⵏⴻⵖ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⴻⵍⵇⴻⴼ ⴰⵢⵉ ⵜⵓⵛⵛⴻⵏⵜ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⵓⴷⴰⵔⵜ ⴰⵇⴰ-ⵜⵜ ⴷⴰⵢⵉ.’ ");
INSERT INTO rift_vpl VALUES ("S21_10","011_1_10","2SA","1","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ ⵓ ⵏⵖⵉⵖ ⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴷⴷⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴽⵙⵉⵖ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵇⵢⴰⵙⵜ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⵖⵉⵍ, ⵉⵡⵢⴻⵖ ⵜⴻⵏ-ⴷⴷ ⵍⴻⵅⵅⵓ ⴷⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("S21_11","011_1_11","2SA","1","11","11","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⴷⴰⵡⵓⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵛⴰⵔⵔⴻⴳ ⵉ-ⵜ. ⴰⵎⵎⵓ ⵉ ⵜⵜ ⴳⴳⵉⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S21_12","011_1_12","2SA","1","12","12","ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⴰⴳⴻⵊⴷⵓⵔ, ⵔⵓⵏ ⵓ ⵥⵓⵎⵎⴻⵏ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵅ ⵛⴰⵡⵓⵍ, ⵅ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ, ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S21_13","011_1_13","2SA","1","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⵃⵓⴷⵔⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ-ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ: “ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵛⴻⴽ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("S21_14","011_1_14","2SA","1","14","14","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ, ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴳⴳⵯⵉⴷⴻⴷ ⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⵙ ⵓⴼⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⴻⴷⴷⴵⴻⴷ ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("S21_15","011_1_15","2SA","1","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⴷⴰⵡⵓⴷ ⵅ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵏⴰ: “ⵇⴰⵔⵔⴻⴱ-ⴷⴷ, ⵃⴻⵢⵢⴻⵃ ⵅⴰⵙ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵃⴻⵢⵢⴻⵃ ⵅⴰⵙ ⴰⵍⴰⵎⵉ ⵜ ⵉⵏⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("S21_16","011_1_16","2SA","1","16","16","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵉⵛⵀⴻⴷ ⵅⴰⴽ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵏⵖⵉⵖ ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("S21_17","011_1_17","2SA","1","17","17","ⵉⵖⴻⵏⵏⴻⵊ ⴷⴰⵡⵓⴷ ⵉⵣⵍⵉ-ⵢⴰ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵛⴰⵡⵓⵍ ⵓ ⵅ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S21_18","011_1_18","2SA","1","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵣⵍⵉ ⵏ ⵍⵇⴻⵡⵙ.” ⵅⵣⴰⵔ, ⵢⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S21_19","011_1_19","2SA","1","19","19","“ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⴻⵛ. ⵎⴰⵎⵎⴻⵛ ⵡⴹⴰⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ! ");
INSERT INTO rift_vpl VALUES ("S21_20","011_1_20","2SA","1","20","20","ⵡⴰⵔ ⵜⵜ ⵜⵜⵃⴰⵊⴰⵎ ⴷⵉ ⵊⴰⵜ, ⵡⴰⵔ ⵜⵜⵙⵉⵡⴹⴻⵎ ⵍⴻⵅⴱⴰⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴰⵛⵇⴰⵍⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵡⴰⵔ ⴼⴰⵔⵔⵃⴻⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵡⴰⵔ ⵙⵙⵍⵉⵡⵍⵉⵡⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S21_21","011_1_21","2SA","1","21","21","ⴰ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ, ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵉⵍⵉ ⵏⵏⴷⴰ ⵏⵉⵖ ⴰⵏⵥⴰⵔ, ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⵜⵉⵍⵉⵏ ⵉⵢⵢⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵎⴰⵖⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵡⴰⴱⴻⵇⵇⴻⴹ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵙ ⵍⵄⴰⵔ, ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ, ⴰⵅⵎⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵎⴻⴷⵀⵓⵏ ⵙ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("S21_22","011_1_22","2SA","1","22","22","ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵣⵉ ⵜⴰⴷⵓⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵡⴰⵔ ⴷ ⵉⵎⵏⵉⵄ ⵍⵇⴻⵡⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⵓ ⵙⵙⵉⴼ ⵏ ⵛⴰⵡⵓⵍ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⵉⴱ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S21_23","011_1_23","2SA","1","23","23","ⵛⴰⵡⵓⵍ ⴷ ⵢⵓⵏⴰⵜⴰⵏ ⵜⵜⵡⴰⵄⵉⵣⵣⴻⵏ ⴷ ⵉⵖⵍⴰⵏ ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ, ⵓ ⴷⵉ ⵍⵎⴻⵡⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵎⵎⵙⴻⴱⴹⵉⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴼⵙⵓⵙⴻⵏ ⵅ ⵉⴳⵉⴷⴰⵔⴻⵏ ⴷ ⵊⴻⵀⴷⴻⵏ ⵅ ⵡⴰⵢⵔⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S21_24","011_1_24","2SA","1","24","24","ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵔⵓⵏⵜ ⵅ ⵛⴰⵡⵓⵍ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵏⵜ ⵉⵙⵙⵢⴰⵔⴹⴻⵏ ⵙ ⵓⵣⴻⴳⴳⵯⴰⵖ, ⵙ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵡⴰⵔⵔⵓⴹ ⵏⴽⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S21_25","011_1_25","2SA","1","25","25","ⵎⴰⵎⵎⴻⵛ ⵉ ⵡⴹⴰⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵎⴻⵏⵖⵉ! ⴰ, ⵢⵓⵏⴰⵜⴰⵏ, ⵜⴻⵜⵜⵡⴰⵏⵖⴻⴷ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S21_26","011_1_26","2SA","1","26","26","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ, ⴰ ⵓⵎⴰ ⵢⵓⵏⴰⵜⴰⵏ! ⵛⴻⴽ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵄⵉⵣⵣⴻⴷ ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ. ⵜⵓⵖⴰ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵛ ⵖⴰⵔⵉ ⴷ ⵙⵙⴰⵔ ⴽⵜⴰⵔ ⵅ ⵜⴰⵢⵔⵉ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S21_27","011_1_27","2SA","1","27","27","ⵎⴰⵎⵎⴻⵛ ⵡⴹⴰⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵎⴰⵎⵎⴻⵛ ⵡⴻⴷⴷⴰⵔⴻⵏ ⵍⴻⵙⵏⴰⵃ ⵏ ⵓⵎⴻⵏⵖⵉ!” ");
INSERT INTO rift_vpl VALUES ("S22_1","011_2_1","2SA","2","1","1","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ?” ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴳⴻⵄⵄⴻⴷ!” ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵖⴰ ⴳⴻⵄⵄⴷⴻⵖ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("S22_2","011_2_2","2SA","2","2","2","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⴰⵅⵉⵏⵓⵄⴰⵎ ⵣⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵓ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵏⴰⴱⴰⵍ ⵣⵉ ⴽⴰⵔⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S22_3","011_2_3","2SA","2","3","3","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴽ-ⴷ ⵜⵡⴰⵛⵓⵏⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S22_4","011_2_4","2SA","2","4","4","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ ⵓⵛⴰ ⴷⴻⵀⵏⴻⵏ ⴷⴰⵡⵓⴷ ⴷⵉⵏⵏⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴱⴱⴰⵔⴻⵏ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⴰⵇⴰ ⵏⴻⴹⵍⴻⵏ ⵛⴰⵡⵓⵍ.” ");
INSERT INTO rift_vpl VALUES ("S22_5","011_2_5","2SA","2","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵉ ⵛⴰⵡⵓⵍ, ⵙⵉⴷⵉ ⵏⵡⴻⵎ, ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵏⴻⴹⵍⴻⵎ ⵜ. ");
INSERT INTO rift_vpl VALUES ("S22_6","011_2_6","2SA","2","6","6","ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵛⴻⵏ ⵙⵉⴷⵉ ⵍⴻⵅⵅⵓ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⵙ ⵜⵛⵓⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S22_7","011_2_7","2SA","2","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵊⵊⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵓ ⵉⵍⵉⵎ ⵜⵎⴻⵃⵃⴷⴻⵎ, ⵎⴰⵖⴰⵔ ⵛⴰⵡⵓⵍ, ⵙⵉⴷⵉ ⵏⵡⴻⵎ, ⵉⵎⵎⵓⵜ. ⵓⵍⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⴻⴷⵀⴻⵏ ⴰⵢⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S22_8","011_2_8","2SA","2","8","8","ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵖⴰⵔ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S22_9","011_2_9","2SA","2","9","9","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵊⵉⵍⵄⴰⴷ, ⵅ ⵉⵛⵓⵔⵉⵢⵢⴻⵏ, ⵅ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵅ ⵉⴼⵔⴰⵢⵉⵎ, ⵅ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S22_10","011_2_10","2SA","2","10","10","ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⵖⵉⵔ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S22_11","011_2_11","2SA","2","11","11","ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵉⵃⴽⴻⵎ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S22_12","011_2_12","2SA","2","12","12","ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵣⵉ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S22_13","011_2_13","2SA","2","13","13","ⵓⵍⴰ ⴷ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵎⵎⴻⵍⵇⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵖⴰⵔ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵊⵉⴱⵄⵓⵏ. ⴷⵉⵏⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ, ⵉⵊⵊ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵏ ⵓⵢⴻⵍⵎⴰⵎ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵓⵢⴻⵍⵎⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("S22_14","011_2_14","2SA","2","14","14","ⵉⵏⵏⴰ ⴰⴱⵏⵉⵔ ⵉ ⵢⵓⵡⴰⴱ: “ⴻⵊⵊ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵎⵎⵓⵖⵣⵍⴻⵏ ⵣⵣⴰⵜⵏⴻⵖ.” ⵢⵓⵡⴰⴱ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("S22_15","011_2_15","2SA","2","15","15","ⵏⵉⵜⵏⵉ ⴽⴽⴰⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⵄⴻⴷⴷⵓⵏ. ⴰⵇⴰ ⵃⴻⵙⴱⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵓ ⵜⴻⵏⵄⴰⵛ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S22_16","011_2_16","2SA","2","16","16","ⵉⵊⵊ ⵉⵟⵟⴻⴼ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵓ ⵉⵊⵊⵓ ⴰⵙ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵃⴰⵍⵇⴰⵜ-ⵀⴰⵚⵓⵔⵉⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S22_17","011_2_17","2SA","2","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⵎⴻⵏⵖⵉ ⵉⵇⵙⴻⵃ ⴰⵟⵟⴰⵙ. ⴰⴱⵏⵉⵔ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⵖⴻⵍⵍⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S22_18","011_2_18","2SA","2","18","18","ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵏⵉⵜⵏⵉ ⴷ ⵢⵓⵡⴰⴱ ⴷ ⴰⴱⵉⵛⴰⵢ ⴷ ⵄⴰⵙⴰ’ⵉⵍ. ⵄⴰⵙⴰ’ⵉⵍ ⵜⵓⵖⴰ ⵉⴼⵙⵓⵙ ⵅ ⵉⴹⴰⵔⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵏ ⵡⴻⵣⵖⴰⵔ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S22_19","011_2_19","2SA","2","19","19","ⵄⴰⵙⴰ’ⵉⵍ ⵉⴹⴼⴰⵔ ⴰⴱⵏⵉⵔ. ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ, ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⴰⴱⵏⵉⵔ, ⵍⴰ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("S22_20","011_2_20","2SA","2","20","20","ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⴰⴱⵏⵉⵔ, ⵉⵏⵏⴰ: “ⵎⴰ ⴷ ⵛⴻⴽ, ⵄⴰⵙⴰ’ⵉⵍ?” ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("S22_21","011_2_21","2SA","2","21","21","ⴰⴱⵏⵉⵔ ⵉⵏⵏⴰ ⴰⵙ: “ⴼⴰⵔⵖ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏⵉⵖ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵓ ⵛⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵉⵊⵊ ⵣⴻⴳ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵓ ⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ!” ⵄⴰⵙⴰ’ⵉⵍ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵅⴰⵙ ⵉⵃⴻⵢⵢⴻⴷ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S22_22","011_2_22","2SA","2","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵏⵉⵔ ⵄⴰⵡⴻⴷ ⵉ ⵄⴰⵙⴰ’ⵉⵍ: “ⵃⴻⵢⵢⴻⴷ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ. ⵎⴰⵢⴻⵎⵎⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵡⵜⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ? ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵅⴻⵏⵏⵉ ⵄⴰⴷ ⴰⴷ ⵅⵣⴰⵔⴻⵖ ⵉ ⵓⵎⴰⵛ ⵢⵓⵡⴰⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("S22_23","011_2_23","2SA","2","23","23","ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵢⵓⴳⵉ ⴰⴷ ⴰⵙ ⵉⵃⴻⵢⵢⴻⴷ. ⵅⴻⵏⵏⵉ ⵉⵊⵊⵓ ⴰⵙ ⴰⴱⵏⵉⵔ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵙ ⵢⵉⵅⴻⴼ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⴼⵍⵉⵜⵛⴰ ⵣⵉ ⴹⴻⴼⴼⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⵡⴹⴰ ⴷⵉⵏ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ. ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵡⴹⴰ ⵓ ⵎⴰⵏⵉ ⵉⵎⵎⵓⵜ ⵄⴰⵙⴰ’ⵉⵍ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S22_24","011_2_24","2SA","2","24","24","ⵢⵓⵡⴰⴱ ⴷ ⴰⴱⵉⵛⴰⵢ ⴹⴼⴰⵔⴻⵏ ⴰⴱⵏⵉⵔ. ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵏ ⴰⵎⵎⴰ, ⵜⴻⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵊⵉⵢⴰⵃ, ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⵍⴰ ⵏ ⵊⵉⴱⵄⵓⵏ, ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("S22_25","011_2_25","2SA","2","25","25","ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵎⵓⵏⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⴱⵏⵉⵔ, ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⴰⴽⵉⴷⴻⵙ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵔⵉⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S22_26","011_2_26","2SA","2","26","26","ⴰⴱⵏⵉⵔ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵢⵓⵡⴰⴱ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⴷ ⵉⵛⵛ ⵙⵙⵉⴼ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴻⴽ, ⴰⵇⴰ ⴰⵢⴰ ⴰⴷ ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵇⴻⵟⵟⵓ ⴷ ⴰⵎⴻⵔⵣⴰⴳ? ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵄⵇⴻⴱ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("S22_27","011_2_27","2SA","2","27","27","ⵢⵓⵡⴰⴱ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵍⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵅ ⵉⵊⵊ ⵏ ⵓⵎⵓⵖⵣⴻⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⴳⴻⵏⵙ ⵉⵙⵙⴱⴻⴷⴷ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵖⴰⵔ ⵚⵚⴱⴻⵃ, ⵉⵍⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵎⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("S22_28","011_2_28","2SA","2","28","28","ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵢⵓⵡⴰⴱ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵙⴱⴻⴷⴷ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴹⴼⴰⵔⴻⵏ ⵄⴰⴷ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵡⴰⵔ ⵎⵎⴻⵏⵖⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S22_29","011_2_29","2SA","2","29","29","ⴰⴱⵏⵉⵔ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵛⵓⵇⴻⵏ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⴻⵡⴹⴰ, ⵥⵡⴰⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴽⴽⵉⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵖⵣⵓⵔⵜ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S22_30","011_2_30","2SA","2","30","30","ⵓⵍⴰ ⴷ ⵢⵓⵡⴰⴱ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⴰⴱⵏⵉⵔ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ⵡⴻⴷⴷⴰⵔⴻⵏ ⵜⵙⴻⵄⵟⴰⵛ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵓⵍⴰ ⴷ ⵄⴰⵙⴰ’ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S22_31","011_2_31","2SA","2","31","31","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵡⵜⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴰⴱⵏⵉⵔ. ⵎⵎⵓⵜⴻⵏ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S22_32","011_2_32","2SA","2","32","32","ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵄⴰⵙⴰ’ⵉⵍ ⵓ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⴱⴰⴱⴰⵙ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ⵢⵓⵡⴰⴱ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵓⵢⵓⵔⴻⵏ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵓ ⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵜⴻⵏⵇⴰⵔ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("S23_1","011_3_1","2SA","3","1","1","ⵉⴷⵡⴻⵍ ⵉⵊ ⵏ ⵓⵎⴻⵏⵖⵉ ⵊⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵉ ⵉⴽⴽⵉⵏ ⴰⵟⵟⴰⵙ. ⴷⴰⵡⵓⴷ ⵉⴷⵡⴻⵍ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵊⵊⵀⴻⴷ ⵓ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⴳⴳⵓⵔⴻⵏ ⴰⵔⴻⵅⵅⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S23_2","011_3_2","2SA","3","2","2","ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵜⵜⵡⴰⵔⵡⴻⵏ-ⴷⴷ ⵉ ⴷⴰⵡⵓⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ ⴰⵎⵏⵓⵏ, ⵏ ⴰⵅⵉⵏⵓⵄⴰⵎ ⵜⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉⵜ.    ");
INSERT INTO rift_vpl VALUES ("S23_3","011_3_3","2SA","3","3","3","ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⴽⵉⵍ’ⴰⴱ, ⵏ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵏⴰⴱⴰⵍ, ⴰⴽⴰⵔⵎⴰⵍⵉ, ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴱⵛⴰⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵜⴰⵍⵎⴰⵢ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵛⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("S23_4","011_3_4","2SA","3","4","4","ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷⵓⵏⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⵊⵉⵜ, ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵛⴰⴼⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵟⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("S23_5","011_3_5","2SA","3","5","5","ⵓ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵢⵉⵜⵔⴰⵄⴰⵎ, ⵏ ⵄⴰⵊⵍⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵉⵏⴰ ⵜⵜⵡⴰⵔⵡⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S23_6","011_3_6","2SA","3","6","6","ⵎⵉⵏ ⵉⴽⴽⴰ ⵓⵎⴻⵏⵖⵉ ⵊⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⴱⵏⵉⵔ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S23_7","011_3_7","2SA","3","7","7","ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ, ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵔⵉⵚⴼⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴰⵢⵢⴰ. ⵓⵛⴰ ⵉⵏⵏⴰ ⵉⵛ-ⴱⵓⵛⴰⵜ ⵉ ⴰⴱⵏⵉⵔ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵓⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴰⵢⵢⴰ ⵏ ⴱⴰⴱⴰ?” ");
INSERT INTO rift_vpl VALUES ("S23_8","011_3_8","2SA","3","8","8","ⴰⴱⵏⵉⵔ ⵉⴼⴼⵓⴳⴻⵎ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵉⵏⵏⴰ: “ⵎⴰ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵡⴻⵇⵣⵉⵏ ⵉ ⵉⵇⵇⵏⴻⵏ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵛⴰⵏⴻⵏ ⵄⴰⴷ ⴰⵍ ⴰⵙⵙ-ⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ, ⴱⴰⴱⴰⵛ, ⵓ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⵓ ⵉ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⵊⵊⵉⵏ ⴰⴷ ⵜⴻⵡⴹⵉⴷ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴷⴰⵡⵓⴷ? ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⴼⵉ ⵜⵄⴻⵢⵢⴰⵔⴻⴷ ⴰⵙⵙ-ⴰ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("S23_9","011_3_9","2SA","3","9","9","ⴻⵊⵊ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⴳⴳ ⵜⴰ ⴷ ⵜⴰ ⴰⴽ-ⴷ ⴰⴱⵏⵉⵔ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ! ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵉ ⴷⴰⵡⵓⴷ ⴰⵎⵎⵓ ⵉ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⴳⴳⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("S23_10","011_3_10","2SA","3","10","10","ⵓⵎⵉ ⵖⴰ ⵙⵙⴻⵄⴷⵓⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵅ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("S23_11","011_3_11","2SA","3","11","11","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵅ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵉ ⴰⴱⵏⵉⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S23_12","011_3_12","2SA","3","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⴱⵏⵉⵔ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵡⵉ ⵢⵉⵍⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ?” ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⴻⴳⴳ ⴰⴽⵉⴷⵉ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ, ⵅⵣⴰⵔ, ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⴼⵓⵙ ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵉⵏⵏⴻⵇⵍⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("S23_13","011_3_13","2SA","3","13","13","ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵍⵉⵃ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⴻⴽ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴰⴷ ⴰⵛ ⵜⵜ ⵜⵜⴰⵔⴻⵖ. ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⴷ ⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⴷⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("S23_14","011_3_14","2SA","3","14","14","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ: “ⴻⵡⵛ ⴰⵢⵉ-ⴷⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ ⵎⵉⵅⴰⵍ, ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵡⵢⴻⵖ ⵙ ⵎⵢⴰ ⵏ ⵍⴻⵄⴷⴰⵍⴻⵢⵢⴰⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙ ⵡⴻⵅⴹⴰⴱ ⵏ ⵜⴻⵙⵍⵉⵜ!” ");
INSERT INTO rift_vpl VALUES ("S23_15","011_3_15","2SA","3","15","15","ⵉⵛ-ⴱⵓⵛⴰⵜ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⵉ-ⵜⵜ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵅ ⴼⴰⵍⵟⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵢⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("S23_16","011_3_16","2SA","3","16","16","ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ ⴰⵍ ⴱⴰⵅⵓⵔⵉⵎ, ⵢⵓⵢⵓⵔ ⵉⵜⵜⵔⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⴰⴱⵏⵉⵔ: “ⵓⵢⵓⵔ, ⵄⵇⴻⴱ!” ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("S23_17","011_3_17","2SA","3","17","17","ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴱⵏⵉⵔ ⵅ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴷⴰⵡⵓⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S23_18","011_3_18","2SA","3","18","18","ⵍⴻⵅⵅⵓ ⴳⴳⴻⵎ ⵜ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: ‘ⵙ ⵓⴼⵓⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⴰⴷ ⴼⴻⴽⴽⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("S23_19","011_3_19","2SA","3","19","19","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴱⵏⵉⵔ ⵓⵍⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴰⴱⵏⵉⵔ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S23_20","011_3_20","2SA","3","20","20","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⴱⵏⵉⵔ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ. ⵜⵓⵖⴰ ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⴰⴱⵏⵉⵔ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S23_21","011_3_21","2SA","3","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵏⵉⵔ ⵉ ⴷⴰⵡⵓⴷ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⴰⴷ ⵟⵟⴼⴻⵖ ⴰⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵡⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⴰⴽⵉⴷⴻⴽ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ.” ⵙ ⵓⵢⴰ ⵉⵊⵊⴰ ⴷⴰⵡⵓⴷ ⴰⴱⵏⵉⵔ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S23_22","011_3_22","2SA","3","22","22","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵢⵓⵡⴰⴱ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴰⴼⴰⵔ ⵏ ⵓⴽⴻⵛⵛⴻⴹ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⴱⵏⵉⵔ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ, ⵎⴰⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S23_23","011_3_23","2SA","3","23","23","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵢⵓⵡⴰⴱ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵖⴰⵔⴻⵙ, ⵄⴰⵡⴷⴻⵏ ⵉ ⵢⵓⵡⴰⴱ, ⵏⵏⴰⵏ: “ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴰⴱⵏⵉⵔ ⴷⵉ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("S23_24","011_3_24","2SA","3","24","24","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵢⵓⵡⴰⴱ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ? ⴰⵇⴰ ⴰⴱⵏⵉⵔ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⴽ. ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ? ");
INSERT INTO rift_vpl VALUES ("S23_25","011_3_25","2SA","3","25","25","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ. ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵀⴰ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵛⵎⴻⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵅ ⵡⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵓ ⵅ ⵡⴻⵄⵇⴰⴱ ⵏⵏⴻⵛ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("S23_26","011_3_26","2SA","3","26","26","ⵢⵓⵡⴰⴱ ⵉⴼⴼⴻⵖ ⵣⵉ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⴰⴱⵏⵉⵔ ⵉⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔⵉⵏ ⴰⴷ ⵉⴷⵡⴻⵍ ⵣⴻⴳ ⵡⴰⵏⵓ ⵏ ⵙⵉⵔⴰ. ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵡⴰⵍⵓ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S23_27","011_3_27","2SA","3","27","27","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴰⴱⵏⵉⵔ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⵢⵓⵡⴰⴱ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵍⵀⵓⴷⵏⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵊⵊⵓ ⵜ ⴷⵉⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ, ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵅⵍⴰⴼ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵎⴰⵙ ⵄⴰⵙⴰ’ⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("S23_28","011_3_28","2SA","3","28","28","ⵓⵎⵉ ⵉⵙⵍⴰ ⴷⴰⵡⵓⴷ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⴷ ⴰⴼⵓⵔⵔⵉ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("S23_29","011_3_29","2SA","3","29","29","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵡⴰⴱ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ⴻⵊⵊ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵡⴰⴱ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵏⴻⵇⵇⴻⵚ ⵄⴻⵎⵎⴰⵔⵚ ⵛⴰ ⵏ ⵉⵊⵊ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵓⵙⴻⵢⵢⴻⵍ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵓⵎⴻⴽⴽⵓⴽ ⵏ ⵓⵅⴻⵢⵢⴰⴹ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⵖⵔⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("S23_30","011_3_30","2SA","3","30","30","ⵢⵓⵡⴰⴱ ⴷ ⵓⵎⴰⵙ ⴰⴱⵉⵛⴰⵢ ⵏⵖⵉⵏ ⴰⴱⵏⵉⵔ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⵖⴰ ⵓⵎⴰⵜⵙⴻⵏ ⵄⴰⵙⴰ’ⵉⵍ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S23_31","011_3_31","2SA","3","31","31","ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵢⵓⵡⴰⴱ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ: “ⵛⴰⵔⵔⴳⴻⵎ ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ, ⵢⴰⵔⴹⴻⵎ ⴰⵔⵔⵓⴹ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⵍⵎⴻⵃⵎⴻⵍ ⵏ ⴰⴱⵏⵉⵔ ⴰⵎ ⵜⴻⵛⵛⴰⵜⴻⵎ ⴰⴳⴻⵊⴷⵓⵔ!” ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵍⵎⴻⵃⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S23_32","011_3_32","2SA","3","32","32","ⵍⴰⵎⵉ ⵏⴻⴹⵍⴻⵏ ⴰⴱⵏⵉⵔ ⴷⵉ ⵃⴰⴱⵔⵓⵏ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⵊⴻⴵⵉⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵉⵔⵓ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵏ ⴰⴱⵏⵉⵔ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉⵔⵓ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S23_33","011_3_33","2SA","3","33","33","ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵛⵜ ⵏ ⵓⵛⴻⵜⵛⵉ ⵏ ⵉⵎⴻⵜⵜⴰⵏ ⵉ ⴰⴱⵏⵉⵔ, ⵉⵏⵏⴰ: “ⵎⴰ ⵉⵎⵎⵓⵜ ⴰⴱⵏⵉⵔ ⴰⵎ ⵉⵎⵎⵓⵜ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ? ");
INSERT INTO rift_vpl VALUES ("S23_34","011_3_34","2SA","3","34","34","ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵡⴰⵔ ⵛⴰⵔⴼⴻⵏ ⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵡⴰⵔ ⵇⴻⵢⵢⴷⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵃⴰⵙ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⵡⴹⵉⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵡⴹⴰ ⴱⵏⴰⴷⴻⵎ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵔⵏⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵄⴰⴷ ⴷⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S23_35","011_3_35","2SA","3","35","35","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵣⵉⵢⵢⴰⵔⴻⵏ ⴰⴷ ⵉⵛⵛ ⴰⵖⵔⵓⵎ ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⴰⵣⵉⵍ. ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵊⵊⵓⴵ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵜⴰ ⴷ ⵜⴰ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵛⵛⵉⵖ ⵛⴰ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏⵉⵖ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ!” ");
INSERT INTO rift_vpl VALUES ("S23_36","011_3_36","2SA","3","36","36","ⵎⴰⵏ ⴰⵢⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵜⵓⵖⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S23_37","011_3_37","2SA","3","37","37","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵙⵙⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵇⴰ ⵡⴰⵔ ⴷⴷ-ⵢⴻⴽⴽⵉ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵖⴻⵏ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("S23_38","011_3_38","2SA","3","38","38","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵉⵡⴹⴰ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ, ⵡⴰⵀ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("S23_39","011_3_39","2SA","3","39","39","ⴰⵙⵙ-ⴰ ⴹⴻⵄⴼⴻⵖ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴰⴷⴻⵀⵏⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵉⵔⵢⴰⵣⴻⵏ-ⴰ, ⴰⵔⵔⴰⵡ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵇⴻⵙⵃⴻⵏ ⵅⴰⴼⵉ. ⵙⵉⴷⵉ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴰⵄⴻⴼⴼⴰⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ.” ");
INSERT INTO rift_vpl VALUES ("S24_1","011_4_1","2SA","4","1","1","ⵓⵎⵉ ⵉⵙⵍⴰ ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ ⴰⴱⵏⵉⵔ ⵉⵎⵎⵓⵜ ⴷⵉ ⵃⴰⴱⵔⵓⵏ, ⴷⴻⵡⵍⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴹⴻⵄⴼⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⴻⵅⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("S24_2","011_4_2","2SA","4","2","2","ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵊⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ. ⵉⵊⵊⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴱⴰⵄⵏⴰ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵔⴰⴽⴰⴱ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⵉⵎⵎⵓⵏ, ⴰⴱⵉ’ⵔⵓⵜⵉ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⴱⵉⵄⵔⵓⵜ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ-ⴷⴷ ⵖⴰⵔ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S24_3","011_4_3","2SA","4","3","3","ⵉⴱⵉⵄⵔⵓⵜⵉⵢⵢⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵊⴰⵜⵜⴰⵢⵉⵎ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ ⴰⵍ ⴰⵙⵙ-ⴰ ⴰⵎ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S24_4","011_4_4","2SA","4","4","4","ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⴰⵔⵔⵎⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵍⴻⵅⴱⴰⵔ ⵅ ⵛⴰⵡⵓⵍ ⴷ ⵢⵓⵏⴰⵜⴰⵏ ⵣⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ. ⵜⴻⵏⵏⵉ ⵜ ⵉⵙⵙⴻⵢⵎⴻⵏ ⵜⵓⵖⴰ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜ ⵓⵛⴰ ⵜⴰⵔⵡⴻⵍ. ⴰⵇⴰ ⴷⴻⴳ ⵓⵇⴻⴵⴻⵇ ⵏ ⵜⴰⵔⴻⵡⵍⴰ, ⵉⵎⵙⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵡⴹⴰ, ⵉⴷⵡⴻⵍ ⵉⵇⴰⵔⵔⴻⵎ. ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S24_5","011_4_5","2SA","4","5","5","ⵔⴰⴽⴰⴱ ⴷ ⴱⴰⵄⵏⴰ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⵉⵎⵎⵓⵏ, ⴰⴱⵉⵄⵔⵓⵜⵉ, ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴷⵉ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵛ-ⴱⵓⵛⴰⵜ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⵣⴻⵍ ⴷⵉ ⵇⴰⵎⴰ ⴷⵉ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("S24_6","011_4_6","2SA","4","6","6","ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵅⵎⵉ ⵜⵓⵖⴰ ⵏⵡⴰⵏ ⴰⴷ ⴽⵙⵉⵏ ⵉⵔⴷⴻⵏ, ⵓⵛⴰ ⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵜ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ. ⵔⴰⴽⴰⴱ ⴷ ⵓⵎⴰⵙ ⴱⴰⵄⵏⴰ ⵅⵜⵓⵜⵜⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S24_7","011_4_7","2SA","4","7","7","ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵉⵣⵣⴻⵍ ⴷⵉ ⵇⴰⵎⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵢⵉⴹⴻⵚ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵙⵙⵏⵓⵇⴱⴻⵏ ⵜ, ⵏⵖⵉⵏ ⵜ ⵓⵛⴰ ⵇⴻⵙⵙⴻⵏ ⴰⵙ ⴰⵣⴻⴵⵉⴼ. ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴵⵉⵍⴻⵜ ⵜⵎⵓⵏ, ⴽⴽⵉⵏ ⴰⴱⵔⵉⴷ ⵏ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("S24_8","011_4_8","2SA","4","8","8","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵛ-ⴱⵓⵛⴰⵜ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵅⵣⴰⵔ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵛ. ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵙⵉⴷⵉ ⵉⵅⵍⴻⴼ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⵣⵉ ⵛⴰⵡⵓⵍ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S24_9","011_4_9","2SA","4","9","9","ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵔⴰⴽⴰⴱ ⴷ ⵓⵎⴰⵙ ⴱⴰⵄⵏⴰ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⵉⵎⵎⵓⵏ, ⴰⴱⵉⵄⵔⵓⵜⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("S24_10","011_4_10","2SA","4","10","10","ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ ⵓⵛⴰ ⵉⵏⵏⴰ: ‘ⵅⵥⴰⵔ, ⵛⴰⵡⵓⵍ ⵉⵎⵎⵓⵜ!’, ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵟⵟⴼⴻⵖ ⵜ ⵓⵛⴰ ⵏⵖⵉⵖ ⵜ ⴷⵉ ⵚⵉⵇⵍⴰⵖ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵔⴰⵊⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵍⵎⵓⵏⴻⵜ ⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S24_11","011_4_11","2SA","4","11","11","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵍⴻⵅⵅⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵅ ⵇⴰⵎⴰ ⵏⵏⴻⵙ! ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴻⴵⴼⴻⵖ ⵅⴻⵏⵏⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵎⵃⵉⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("S24_12","011_4_12","2SA","4","12","12","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴷⴰⵡⵓⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵜⴻⵏ. ⵇⴻⵙⵙⴻⵏ ⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵓⵢⵍⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵃⴰⴱⵔⵓⵏ. ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵛ-ⴱⵓⵛⴰⵜ, ⵎⴰⵛⴰ ⴽⵙⵉⵏ ⵜ ⵏⵉⵜⵏⵉ, ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⴰⴱⵏⵉⵔ ⴷⵉ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S25_1","011_5_1","2SA","5","1","1","ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵙⵙⵉⵡⵍⴻⵏⵜ, ⵏⵏⴰⵏⵜ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵖⵓⵙⵙⴰⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S25_2","011_5_2","2SA","5","2","2","ⵉⴹⴻⵏⵏⴰⴹ ⵓⵍⴰ ⴷ ⴼⴰⵔⵉⴹⴻⵏⵏⴰⴹ ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵏⴻⵖ, ⵜⵓⵖⴰ ⴷ ⵛⴻⴽ ⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵓ ⵜⴻⵊⵊⵉⴷ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⴷ ⵉⴷⵡⴻⵍ. ⵄⴰⵡⴻⴷ ⵉⵏⵏⴰ ⴰⵛ ⵙⵉⴷⵉ: ‘ⵛⴻⴽ ⴰⴷ ⵜⴰⵔⴻⵡⵙⴻⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("S25_3","011_5_3","2SA","5","3","3","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵓ ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⴷⴻⵀⵏⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S25_4","011_5_4","2SA","5","4","4","ⵜⵓⵖⴰ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("S25_5","011_5_5","2SA","5","5","5","ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵉⵃⴽⴻⵎ ⵅ ⵢⴰⵀⵓⴷⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S25_6","011_5_6","2SA","5","6","6","ⴰⵊⴻⴵⵉⴷ ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴷⴼⴻⴷ ⵛⴰ ⴷⴰ, ⵎⴰⵖⴰⵔ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷ ⵉⵇⵉⴹⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⵃⵚⴰⵔⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴷⴰⵡⵓⴷ ⵡⴰⵔ ⴷⴰ ⵉⵜⵜⵉⴷⴻⴼ ⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("S25_7","011_5_7","2SA","5","7","7","ⴷⴰⵡⵓⴷ ⵉⵃⴻⵡⵡⴻⵙ ⵍⴱⵓⵔⵊ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴷ ⵡⴻⵏⵏⵉ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S25_8","011_5_8","2SA","5","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⴽⵓⵔ ⵉⵊⵊ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⵉⵊⵊ ⵏ ⵓⵢⴰⴱⵓⵙⵉ, ⴻⵊⵊ-ⵉ-ⵜ ⴰⴷ ⵜ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⴰⵟⵟⴰⵙ. ⵉⵇⵉⴷⴰⵔⴻⵏ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵉⵛⴰⵔⵔⴻⵀ ⵉ-ⵜⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⴷⴰⵡⵓⴷ.” ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ: “ⵉⵊⵊ ⵏ ⵓⴷⴰⵔⵖⴰⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⵇⵉⴷⴰⵔ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("S25_9","011_5_9","2SA","5","9","9","ⴷⴰⵡⵓⴷ ⵉⵇⵇⵉⵎ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ: ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ’. ⵉⴱⵏⴰ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵍⴱⵓⵔⵊ ⵓⵍⴰ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S25_10","011_5_10","2SA","5","10","10","ⴷⴰⵡⵓⴷ ⵉⴷⵡⴻⵍ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S25_11","011_5_11","2SA","5","11","11","ⵃⵉⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ, ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵃⵉⴹ. ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S25_12","011_5_12","2SA","5","12","12","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵜⵓⵖⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S25_13","011_5_13","2SA","5","13","13","ⴰⵡⴰⵔⵏⵉ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ ⵣⵉ ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵢⴰⵔⴻⵏⵏⵉ ⵜⵉⵢⵢⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⵉ ⴷⴰⵡⵓⴷ ⵄⴰⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S25_14","011_5_14","2SA","5","14","14","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ: ⵛⴰⵎⵎⵓⵄ, ⵛⵓⴱⴰⴱ, ⵏⴰⵜⴰⵏ, ⵙⵓⵍⵉⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("S25_15","011_5_15","2SA","5","15","15","ⵢⵉⴱⵃⴰⵔ, ⵉⵍⵉⵛⵓⵄ, ⵏⴰⴼⴰⵊ, ⵢⴰⴼⵉⵄ, ");
INSERT INTO rift_vpl VALUES ("S25_16","011_5_16","2SA","5","16","16","ⴰⵍⵉⵛⴰⵎⴰⵄ, ⴰⵍⵢⴰⴷⴰⵄ ⴷ ⵉⵍⵉⴼⴰⵍⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("S25_17","011_5_17","2SA","5","17","17","ⵓⵎⵉ ⵙⵍⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⴷⴻⵀⵏⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴳⴻⵄⵄⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⴷⴰⵡⵓⴷ. ⴷⴰⵡⵓⴷ ⵉⵙⵍⴰ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ ⵖⴰⵔ ⵍⵇⴻⵍⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S25_18","011_5_18","2SA","5","18","18","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵓⵛⴰ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S25_19","011_5_19","2SA","5","19","19","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⴷⴰⵡⵓⴷ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ? ⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ?” ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⴳⴻⵄⵄⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵏⵉⵛⴰⵏ ⴰⴷ ⴳⴳⴻⵖ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("S25_20","011_5_20","2SA","5","20","20","ⵓ ⵢⵉⵡⴻⴹ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⴱⴰⵄⵍ-ⴼⴰⵔⴰⵚⵉⵎ. ⴷⵉⵏⵏⵉ ⵉⵡⵜⴰ ⴷⴰⵡⵓⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵛⵓⵇ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴷⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵡⴰⵎⴰⵏ.” ⵅ ⵓⵢⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⴱⴰⵄⵍ-ⴼⴰⵔⴰⵚⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S25_21","011_5_21","2SA","5","21","21","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵊⵊⵉⵏ ⴷⵉⵏⵏⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵓ ⴷⴰⵡⵓⴷ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴽⵙⵉⵏ ⵜⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S25_22","011_5_22","2SA","5","22","22","ⴳⴻⵄⵄⴷⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵓ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S25_23","011_5_23","2SA","5","23","23","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⵉⴷ ⵛⴰ ⴹⵉⴷⴷ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⴻⴽⴽ ⴰⵙⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("S25_24","011_5_24","2SA","5","24","24","ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⴻⵛⵍⵉ ⵏ ⵉⵚⵓⵔⴰⴼ ⴷⵉ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵜⵜⵉ, ⵅⴻⵏⵏⵉ ⴼⴼⴻⵖ, ⵜⵀⴻⵊⵎⴻⴷ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⵣⵡⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S25_25","011_5_25","2SA","5","25","25","ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵣⵉ ⵊⵉⴱⵄⴰ ⴰⵍ ⵎⴰⵏⵉ ⵖⴰ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⵊⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S26_1","011_6_1","2SA","6","1","1","ⴷⴰⵡⵓⴷ ⵉⵙⵙⵎⵓⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S26_2","011_6_2","2SA","6","2","2","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵣⵉ ⴱⴰⵄⵍⵉ-ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵜⵜⴰⴱⵓⵜ ⵉ ⵅ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵢⵉⵙⴻⵎ, ⵙ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵅ ⵉⴽⵉⵔⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S26_3","011_6_3","2SA","6","3","3","ⵏⵉⵜⵏⵉ ⵏⴻⴷⵀⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵏ ⵊⴷⵉⴷ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ ⵜⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵄⵔⵓⵔⵜ. ⵄⵓⵣⵣⴰ ⴷ ⴰⵅⵉⵢⵓ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ, ⵏⴻⴷⵀⴻⵏ ⴰⴽⴰⵔⵔⵓ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S26_4","011_6_4","2SA","6","4","4","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ ⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵄⵔⵓⵔⵜ, ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ⴰⵅⵉⵢⵓ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S26_5","011_6_5","2SA","6","5","5","ⴷⴰⵡⵓⴷ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵔⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⴷⴷⵓⵣⴰⵏ ⵏ ⴵⵖⴰ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ, ⵙ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ ⴷ ⵏⵏⴰⵇⵓⵙⴰⵜ ⴷ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S26_6","011_6_6","2SA","6","6","6","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵏⴰⵅⵓⵏ, ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵄⵓⵣⵣⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ, ⵎⵉⵏⵣⵉ ⵏⴷⴻⵔⴼⴻⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S26_7","011_6_7","2SA","6","7","7","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵄⵓⵣⵣⴰ ⵓⵛⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⴷⵉⵏ ⵅ ⵓⵅⴻⵟⵟⵓ-ⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⴷⵉⵏ ⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S26_8","011_6_8","2SA","6","8","8","ⵢⵉⵡⴻⴹ ⵙⵙⴻⵎ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵄⴰⵔ ⴰⵎⵎⵓ ⵅ ⵄⵓⵣⵣⴰ, ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⴼⴰⵔⵉⵚ-ⵄⵓⵣⵣⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S26_9","011_6_9","2SA","6","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⴻⵍⵇⴻⴼ ⴷⴰⵡⵓⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("S26_10","011_6_10","2SA","6","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⴷⴰⵡⵓⴷ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⴷⴰⵡⵓⴷ ⵉⵊⵊⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜⴰⴳⴳⵯⴻⵊ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⴰⵊⵉⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("S26_11","011_6_11","2SA","6","11","11","ⵜⴻⴽⴽⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⴰⵊⵉⵜⵜⵉ, ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴱⴰⵔⴻⴽ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S26_12","011_6_12","2SA","6","12","12","ⵅⴻⵏⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⴰⵡⵓⴷ ⴷⵉⵏ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S26_13","011_6_13","2SA","6","13","13","ⵍⴰⵎⵉ ⵓⵢⵓⵔⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵉⵚⵓⵔⴰⴼ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵇⴻⴷⴷⴻⵎ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵉⵎⴻⵙⵍⴻⵏ ⴷ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("S26_14","011_6_14","2SA","6","14","14","ⴷⴰⵡⵓⴷ ⵉⵛⴹⴻⵃ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵢⴰⵔⴹ ⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵏ ⵍⴻⵇⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S26_15","011_6_15","2SA","6","15","15","ⴷⴰⵡⵓⴷ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵡⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵓ ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("S26_16","011_6_16","2SA","6","16","16","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⴻⵅⵣⴰⵔ-ⴷⴷ ⵣⵉ ⵍⴽⴰⵣⵉ. ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵏⴻⵜⵜⴰⵜ ⵎⴰⵎⵎⴻⵛ ⵉⵏⴻⴳⴳⴻⵣ ⴷ ⵉⵛⴻⵟⵟⴻⵃ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵙⵙⴻⵃⵇⴰⵔ ⵉ-ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S26_17","011_6_17","2SA","6","17","17","ⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵛⴻⴷⴷ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S26_18","011_6_18","2SA","6","18","18","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴷⴰⵡⵓⴷ ⵣⴻⴳ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ, ⵉⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S26_19","011_6_19","2SA","6","19","19","ⵏⴻⵜⵜⴰ ⵉⴱⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵉⵡⵛⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⵅⴻⴱⴱⴰⵣⵜ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵣⵣⴱⵉⴱ. ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S26_20","011_6_20","2SA","6","20","20","ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵙⵙ-ⴰ ⵛⵛⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵉⵄⴰⵔⵔⴰ ⵏⴻⵜⵜⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⵉⵢⵢⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵄⴰⵔⵔⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("S26_21","011_6_21","2SA","6","21","21","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵎⵉⵅⴰⵍ: “ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴼⴰⵔⵣⴻⵏ ⵅ ⴱⴰⴱⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ, ⵅ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵛⴻⵟⵟⵃⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S26_22","011_6_22","2SA","6","22","22","ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵄⴰⴷ ⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⵓⵇⵍⵉⵍ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ⵖⴰⵔ ⵜⵉⵢⵢⴰ ⵉ ⵅ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵛⴻⵎ, ⵖⴰⵔⵙⴻⵏⵜ ⵉ ⵖⴰ ⵟⵟⴼⴻⵖ ⵛⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S26_23","011_6_23","2SA","6","23","23","ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⴻⵇⵇⵉⵎ ⴱⵍⴰ ⴰⵃⴻⵏⵊⵉⵔ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S27_1","011_7_1","2SA","7","1","1","ⵓⵎⵉ ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⵙ ⵍⴻⵀⵏⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("S27_2","011_7_2","2SA","7","2","2","ⴰⵇⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵣⴻⴷⴷⵖⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵎⴰⵛⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵍⴻⵃⵃⴻⴼ ⵙⴰⴷⵓ ⵜⴰⵊⴰⵔⵜⵉⵍⵜ ⵏ ⵓⵇⵉⴹⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("S27_3","011_7_3","2SA","7","3","3","ⵏⴰⵜⴰⵏ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵓⵢⵓⵔ ⵡⴰⵀⴰ, ⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("S27_4","011_7_4","2SA","7","4","4","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵏⴰⵜⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("S27_5","011_7_5","2SA","7","5","5","“ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵉ ⴷⴰⵡⵓⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⴱⵏⵉⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("S27_6","011_7_6","2SA","7","6","6","ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵣⴷⵉⵖⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵣⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⴷⴷ-ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴰⵙⵙ-ⴰ, ⵎⴰⵛⴰ ⴷⵓⵔⵔⵢⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("S27_7","011_7_7","2SA","7","7","7","ⵎⴰⵏⵉ ⵎⴰ ⵓⵢⵓⵔⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵓⵍⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵢⵉⵛⵜ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵏⵏⵉ ⵉ ⵓⵎⵓⵔⴻⵖ ⴰⴷ ⴰⵔⵡⴻⵙⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵏⵏⵉⵖ: ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⴱⵏⵉⵎ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ? ");
INSERT INTO rift_vpl VALUES ("S27_8","011_7_8","2SA","7","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵉ ⴷⴰⵡⵓⴷ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ-ⴷⴷ ⵛⴻⴽ ⵣⵉ ⵍⴽⵓⵔⵉ, ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵡⵓⴵⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S27_9","011_7_9","2SA","7","9","9","ⵎⴰⵏⵉ ⵎⴰ ⵜⵓⵢⵓⵔⴻⴷ, ⴵⵉⵖ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⵓ ⵇⴹⵉⵖ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵛ ⵉⵊⵊ ⵏ ⵉⵙⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⵢⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S27_10","011_7_10","2SA","7","10","10","ⵏⴻⵛⵛ ⵏⴻⵢⵢⵛⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵥⵥⵓⵖ ⵜ ⴷⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⵀⴻⵣⵣⵉ ⵄⴰⴷ ⵓ ⵡⴰⵔ ⵜ ⵃⴻⵚⵚⴰⵔⴻⵏ ⵄⴰⴷ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⵎ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ");
INSERT INTO rift_vpl VALUES ("S27_11","011_7_11","2SA","7","11","11","ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⵍⵇⵓⴹⴰⵜ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵛ ⵍⴻⵀⵏⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵛ ⵉⵙⵙⵛⴻⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⴳⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S27_12","011_7_12","2SA","7","12","12","ⵍⴰⵎⵉ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⴰⴷ ⴷⴷ-ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S27_13","011_7_13","2SA","7","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵍⵄⴰⵔⵛ ⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S27_14","011_7_14","2SA","7","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴱⴰⴱⴰⵙ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴼⴰⵔⵢⴻⴹ, ⴰⴷ ⵜ ⴰⵔⴻⴱⴱⵉⵖ ⵙ ⵡⴻⵄⵎⵓⴷ ⴷ ⵜⴻⵢⵢⵉⵜⴰ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S27_15","011_7_15","2SA","7","15","15","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵅⴻⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⵙⵙⵅⴻⵏⵙⴻⵖ ⵜⵜ ⵅ ⵛⴰⵡⵓⵍ ⵉ ⵅ ⵜⵜ ⴽⴽⵙⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S27_16","011_7_16","2SA","7","16","16","ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⴻⵜⵏⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ, ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("S27_17","011_7_17","2SA","7","17","17","ⵏⴰⵜⴰⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵏⵉⵛⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵃⵉⵢ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S27_18","011_7_18","2SA","7","18","18","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵓ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴰⵇⴰ ⵛⴻⴽ ⵜⵏⴻⴷⵀⴻⴷ ⴰⵢⵉ-ⴷⴷ ⴰⵍ ⴷⴰⵏⵉⵜⴰ? ");
INSERT INTO rift_vpl VALUES ("S27_19","011_7_19","2SA","7","19","19","ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵄⴰⴷ ⴷⵔⵓⵙ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵄⴰⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵉ ⴷⴷ ⵉⵜⵜⴰⵙⴻⵏ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵖⵓⵔⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⵉ ⴱⵏⴰⴷⴻⵎ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("S27_20","011_7_20","2SA","7","20","20","ⵎⵉⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵢⵉⵏⵉ ⴷⴰⵡⵓⴷ ⵄⴰⴷ ⴽⵜⴰⵔ? ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("S27_21","011_7_21","2SA","7","21","21","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵓⵍ ⵏⵏⴻⵛ ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵔⵔⴰ ⴱⵍⴰⵏⵓ ⵉⵎⵖⴰⵔⴻⵏ ⵡⴰⵏⵉⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S27_22","011_7_22","2SA","7","22","22","ⵅ ⵓⵢⴰ ⵛⴻⴽ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⵎ ⵛⴻⴽ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⵖⵉⵔ ⵛⴻⴽ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵏⴻⵙⵍⴰ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S27_23","011_7_23","2SA","7","23","23","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰⵎ ⵉⵙⵔⴰⵉⵍ, ⴰⵢⴻⵏⵏⵉ ⵏ ⵍⴳⴻⵏⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵉⵔⴰⵃ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴼⴷⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵍⴳⴻⵏⵙ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⴳⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵍⴰ ⴷ ⵜⵎⴻⴳⴳⴰ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⴻⴼⴷⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⵣⴻⴳ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("S27_24","011_7_24","2SA","7","24","24","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S27_25","011_7_25","2SA","7","25","25","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⴰⵡⴰⵍ ⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⴻⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S27_26","011_7_26","2SA","7","26","26","ⴻⵊⵊ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⵉ ⵍⴻⴱⴷⴰ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵉⵙⵔⴰⵉⵍ!’, ⵓⵛⴰ ⵉⵍⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴰⵡⵓⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S27_27","011_7_27","2SA","7","27","27","ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ!’ ⵅ ⵓⵢⴰ ⵜⵓⵙⴰ-ⴷⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⵥⴰⴵ ⵜⴰⵥⴰⴵⵉⵜ-ⴰ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S27_28","011_7_28","2SA","7","28","28","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓ ⵛⴻⴽ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵎⴰⵔⵔⴰ ⵜⵛⵓⵏⵉ-ⵢⴰ ⵖⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S27_29","011_7_29","2SA","7","29","29","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵛ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ, ⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⵢⴰ ⵓ ⵙ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⴻⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("S28_1","011_8_1","2SA","8","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⴷⴰⵡⵓⴷ ⵉⴽⴽⴻⵙ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S28_2","011_8_2","2SA","8","2","2","ⵄⴰⵡⴻⴷ ⵉⵖⵍⴻⴱ ⵏⴻⵜⵜⴰ ⵅ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵉ-ⵜⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⴰⵎ ⵣⵣⵍⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵉⵎⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴷⴷⴰⵔⴻⵏ. ⴰⵎⵎⵓ ⵉ ⴷⴻⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴷⴰⵡⵓⴷ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵍⵊⵉⵣⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S28_3","011_8_3","2SA","8","3","3","ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵄⴰⵡⴻⴷ ⵅ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵃⵓⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴰⵏⵉⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵔⵔ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("S28_4","011_8_4","2SA","8","4","4","ⴷⴰⵡⵓⴷ ⵉⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⴰⵍⴻⴼ ⵓ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵓⵛⴰ ⵉⵇⴻⵙⵙ ⴷⴰⵡⵓⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵢⵙⴰⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ, ⵎⴰⵛⴰ ⵉⵊⵊⴰ ⵣⵣⴰⵢⴻⵙ ⵎⵢⴰ ⵏ ⵉⵢⵙⴰⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S28_5","011_8_5","2SA","8","5","5","ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⴰⵎ ⵣⵉ ⴷⵉⵎⴰⵛⵇ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⴰⴼⵓⵙ ⵉ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ, ⵓ ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵅ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("S28_6","011_8_6","2SA","8","6","6","ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⵊⴰⵔ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵏ ⴷⵉⵎⴰⵛⵇ ⵓ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ. ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵜⵜⴰⵙⵉⵄ ⵉ ⴷⴰⵡⵓⴷ ⵎⴰⵏⵉ ⵎⴰ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("S28_7","011_8_7","2SA","8","7","7","ⴷⴰⵡⵓⴷ ⵉⴽⵙⵉ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵏⵏⵉ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙ ⵡⵓⵔⴻⵖ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵓ ⵢⵉⵡⵢⵉ ⵜⴻⵏⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S28_8","011_8_8","2SA","8","8","8","ⵉⴽⵙⵉ ⴷⴰⵡⵓⴷ ⴰⵟⵟⴰⵙ ⵏ ⵏⵏⵃⴰⵙ ⵣⵉ ⴱⴰⵜⴰⵃ ⵓ ⵣⵉ ⴱⵉⵔⴰⵜⴰⵢ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S28_9","011_8_9","2SA","8","9","9","ⵓⵎⵉ ⵜⵓⵄⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵎⴰⵜ, ⵉⵙⵍⴰ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("S28_10","011_8_10","2SA","8","10","10","ⵉⵙⵙⴻⴽⴽ ⵜⵓⵄⵉ ⵎⵎⵉⵙ ⵢⵓⵔⴰⵎ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴱⴰⵔⴻⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ ⵓ ⵉⵖⵍⴻⴱ ⵅⴰⵙ, ⵎⴰⵖⴰⵔ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵜⵓⵄⵉ ⵍⴻⴱⴷⴰ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("S28_11","011_8_11","2SA","8","11","11","ⵉⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵄⴰⵡⴻⴷ ⵉ ⵙⵉⴷⵉ, ⵉⵎⵓⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("S28_12","011_8_12","2SA","8","12","12","ⵣⵉ ⴰⵔⴰⵎ, ⵣⵉ ⵎⵓ’ⴰⴱ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵄⴰⵎⴰⵍⵉⵇ ⵓⵍⴰ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵅⵓⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("S28_13","011_8_13","2SA","8","13","13","ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ, ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵍⴻⵖⵍⴻⴱ ⵅ ⴰⵔⴰⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⵎⴻⴵⴰⵃⵜ, ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S28_14","011_8_14","2SA","8","14","14","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⴷⵉ ⵉⴷⵓⵎ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵎ ⵉⴳⴳⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵎⵉⵢⵢⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴷⴰⵡⵓⴷ. ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵜⵜⴰⵙⵉⵄ ⵉ ⴷⴰⵡⵓⴷ ⵎⴰⵏⵉ ⵎⴰ ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("S28_15","011_8_15","2SA","8","15","15","ⴷⴰⵡⵓⴷ ⵉⵃⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓ ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵙ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S28_16","011_8_16","2SA","8","16","16","ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵍⵓⴷ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("S28_17","011_8_17","2SA","8","17","17","ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⴷ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵢⴰⵜⴰⵔ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵙⴰⵔⴰⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵔⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("S28_18","011_8_18","2SA","8","18","18","ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S29_1","011_9_1","2SA","9","1","1","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵎⴰ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵓⵏⴰⵜⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("S29_2","011_9_2","2SA","9","2","2","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵚⵉⴱⴰ. ⵍⴰⵖⴰⵏ ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰ ⵛⴻⴽ ⴷ ⵚⵉⴱⴰ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S29_3","011_9_3","2SA","9","3","3","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵎⴰ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵛⴰ ⵏ ⵉⵊⵊ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⵉⴷⴷⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ?” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵚⵉⴱⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵄⴹⴰⴱ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S29_4","011_9_4","2SA","9","4","4","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵏⴻⵜⵜⴰ?” ⵚⵉⴱⴰ ⵉⵏⵏⴰ ⴰⵙ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⴰⵅⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵢⵉⵍ, ⴷⵉ ⵍⵓ-ⴷⴰⴱⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("S29_5","011_9_5","2SA","9","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⴷⵉⵏ ⵓ ⵢⵉⵡⵢⵉ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⴰⵅⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵢⵉⵍ ⴷⵉ ⵍⵓ-ⴷⴰⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S29_6","011_9_6","2SA","9","6","6","ⵓⵎⵉ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵡⴹⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵢⵓⴹⴰⵔ ⴰⵙ. ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵎⴰⴼⵉⴱⵓⵛⴰⵜ!” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S29_7","011_9_7","2SA","9","7","7","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴱⴰⴱⴰⵛ ⵢⵓⵏⴰⵜⴰⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵊⴻⴷⴷ ⵏⵏⴻⵛ ⵛⴰⵡⵓⵍ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵍⴻⴱⴷⴰ ⵎⴰⵛⵛⴰ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("S29_8","011_9_8","2SA","9","8","8","ⵅⴻⵏⵏⵉ ⵢⵓⴹⴰⵔ ⴰⵙ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵍⴰⵎⵉ ⵛⴻⴽ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵇⵣⵉⵏ ⵉⵎⵎⵓⵜⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴵⵉⵖ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("S29_9","011_9_9","2SA","9","9","9","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵓⵊⴻⴵⵉⴷ ⵅ ⵚⵉⴱⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⵛⵉⵖ ⵜ ⵉ ⵎⵎⵉⵙ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S29_10","011_9_10","2SA","9","10","10","ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵜⵛⴰⵔⵣⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⴰⵡⵢⴻⴷ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵎⵎⵉⵙ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵡⴻⵖⵔⵓⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵛⵛ. ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵢⴻⵛⵛ ⵍⴻⴱⴷⴰ ⴰⵖⵔⵓⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ.” ⵚⵉⴱⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S29_11","011_9_11","2SA","9","11","11","ⵚⵉⴱⴰ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ!” ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵄⴰⴷ: “ⵎⴰⴼⵉⴱⵓⵛⴰⵜ ⴰⴷ ⵉⵛⵛ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S29_12","011_9_12","2SA","9","12","12","ⵎⴰⴼⵉⴱⵓⵛⴰⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵎⵉⵅⴰ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵚⵉⴱⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("S29_13","011_9_13","2SA","9","13","13","ⵓ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵜⵜ ⵍⴻⴱⴷⴰ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵏⴻⵄⴹⴰⴱ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_1","011_10_1","2SA","10","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵉⵎⵎⵓⵜ. ⵎⵎⵉⵙ ⵃⴰⵏⵓⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("S210_2","011_10_2","2SA","10","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵃⴰⵏⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⴰⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵛⴻⵏ ⴱⴰⴱⴰⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ.” ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵄⴻⵣⵣⴰ ⵅ ⵍⵎⴻⵡⵜ ⵏ ⴱⴰⴱⴰⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_3","011_10_3","2SA","10","3","3","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵉ ⵙⵉⴷⵉ ⵏⵙⴻⵏ ⵃⴰⵏⵓⵏ: “ⵎⴰ ⵉⵅⵙ ⴷⴰⵡⵓⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵓⵎⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵄⴻⵣⵣⴰⵏ? ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵍⴻⵅⴱⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵏ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵏⴻⵜⵜⴰⵜ?” ");
INSERT INTO rift_vpl VALUES ("S210_4","011_10_4","2SA","10","4","4","ⵅⴰⵙ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵃⴰⵏⵓⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵃⴻⴼⴼ ⴰⵙⴻⵏ ⴰⵣⵢⴻⵏ ⵣⵉ ⵜⵎⴰⵔⵜ ⵓ ⵉⵇⴻⵙⵙ ⴰⵙⴻⵏ ⴰⵣⵢⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⴰⵍ ⴹⴻⴼⴼⴰⵔ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_5","011_10_5","2SA","10","5","5","ⵓⵎⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⴻⴽⴽ ⴰⵙⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⴹⵃⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ. ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⴰⵔⵉⵃⴰ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴻⵎⵖⴰⵔ ⵜⵎⴰⵔⵜ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("S210_6","011_10_6","2SA","10","6","6","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴰⵔⵣⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵙⵙⴻⴽⴽⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓ ⵛⵔⴰⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵣⵉ ⴱⴰⵢⵜ-ⵔⴰⵅⵓⴱ ⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵣⵉ ⵚⵓⴱⴰ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵓ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⴰⵄⴽⴰ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵟⵓⴱ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_7","011_10_7","2SA","10","7","7","ⵓⵎⵉ ⵉⵙⵍⴰ ⴷⴰⵡⵓⴷ ⴰⵢⴰ, ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵢⵓⵡⴰⴱ ⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("S210_8","011_10_8","2SA","10","8","8","ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵓ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵏ ⵚⵓⴱⴰ ⴷ ⵔⴰⵅⵓⴱ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵟⵓⴱ ⴷ ⵎⴰⵄⴽⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S210_9","011_10_9","2SA","10","9","9","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⵓⵡⴰⴱ, ⴰⵇⴰ ⴰⵎⴻⵏⵖⵉ ⵉⵅⴻⵥⵥⴰⵔ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵖⴰⵔ ⵣⵣⴰⵜ ⵓ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("S210_10","011_10_10","2SA","10","10","10","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵓⵎⴰⵙ ⴰⴱⵉⵛⴰⵢ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_11","011_10_11","2SA","10","11","11","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵎⴰⵍⴰ ⴰⵔⴰⵎ ⵉⵊⵀⴻⴷ ⵅⴰⴼⵉ, ⵅⴻⵏⵏⵉ ⴰⵙ-ⴷⴷ, ⴼⴻⴽⴽ ⴰⵢⵉ! ⵎⴰⵍⴰ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵊⴻⵀⴷⴻⵏ ⵅⴰⴽ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S210_12","011_10_12","2SA","10","12","12","ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴻⵊⵊ ⵙⵉⴷⵉ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S210_13","011_10_13","2SA","10","13","13","ⵅⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵢⵓⵡⴰⴱ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵔⴰⵎ ⵓⵛⴰ ⵉⵏⴰ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S210_14","011_10_14","2SA","10","14","14","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵔⴻⵡⵍⴻⵏ, ⵟⵟⴼⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⴱⵉⵛⴰⵢ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ⵢⵓⵡⴰⴱ ⵉⵄⵇⴻⴱ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S210_15","011_10_15","2SA","10","15","15","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵖⴻⵍⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⵢⴰⵔⵡⴻⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("S210_16","011_10_16","2SA","10","16","16","ⵓⵛⴰ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵃⵉⵍⴰⵎ. ⵛⵓⴱⴰⴽ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⵉⴼⴼⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_17","011_10_17","2SA","10","17","17","ⵓⵎⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵢⴰ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⵎⵓⵏ ⵏⴻⵜⵜⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵃⵉⵍⴰⵎ. ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S210_18","011_10_18","2SA","10","18","18","ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⴷⴰⵡⵓⴷ ⵉⵇⴹⴰ ⵅ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⴷ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ. ⵄⴰⵡⴻⴷ ⵉⵡⵜⴰ ⵏⴻⵜⵜⴰ ⵛⵓⴱⴰⴽ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S210_19","011_10_19","2SA","10","19","19","ⵓⵎⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵃⴻⵏ ⴰⴽ-ⴷ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵡⴰⵖⴻⵍⵍⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⵓ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵙ. ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴳⴳⵯⴻⴷⴻⵏ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("S211_1","011_11_1","2SA","11","1","1","ⵖⴰⵔ ⵓⴱⴻⴷⴷⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵊⴷⵉⴷ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵢⵓⵡⴰⴱ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⵍⴻⴱⵣⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⵉ ⵔⴰⴱⴱⴰ. ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S211_2","011_11_2","2SA","11","2","2","ⵓⵎⵉ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⵉ ⵜⵎⴻⴷⴷⵉⵜ ⵣⵉ ⵇⴰⵎⴰ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⵅ ⵜⵣⴻⵇⵇⴰ ⵉⵡⴰⵟⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵉⵥⵔⴰ ⵙⵙⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵙⵙⵉⵔⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S211_3","011_11_3","2SA","11","3","3","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⴷⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ. ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵍⵉⵄⴰⵎ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴰⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("S211_4","011_11_4","2SA","11","4","4","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵉⵊⵊⴰ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵣⵉⴷⴳⴻⴷ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ, ⵜⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S211_5","011_11_5","2SA","11","5","5","ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵖⴰ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴽⴽ ⵉⵊⵊ, ⵜⴻⵙⵙⴰⵔⴳⴻⴱ ⴷⴰⵡⵓⴷ, ⵜⴻⵏⵏⴰ: “ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵙ ⴷⴷⴻⵢⵙⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("S211_6","011_11_6","2SA","11","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵖⴰⵔ ⵢⵓⵡⴰⴱ: “ⵙⴻⴽⴽ-ⴷⴷ ⴰⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ ⵖⴰⵔⵉ!” ⵓ ⵢⵓⵡⴰⴱ ⵉⵙⵙⴻⴽⴽ ⵓⵔⵉⵢⴰ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S211_7","011_11_7","2SA","11","7","7","ⵓⵎⵉ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵢⵓⵙⴰ ⵓⵔⵉⵢⴰ, ⵉⵙⵙⴻⵇⵙⴰ ⴷⴰⵡⵓⴷ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵢⵓⵡⴰⴱ ⵓ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵍⴳⴻⵏⵙ ⵓ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⵓⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S211_8","011_11_8","2SA","11","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⵔⵉⵢⴰ:“ ⵀⵡⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⵙⵉⵔⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ!” ⵓⵔⵉⵢⴰ ⵉⵙⵎⴻⵃ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵙⵙⴻⴹⴼⴰⵔⴻⵏ ⴰⵙ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S211_9","011_11_9","2SA","11","9","9","ⵎⴰⵛⴰ ⵓⵔⵉⵢⴰ ⵉⵣⵣⴻⵍ ⵉⵟⵟⴻⵚ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵀⵡⵉ ⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S211_10","011_11_10","2SA","11","10","10","ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⵓⵔⵉⵢⴰ ⵡⴰⵔ ⵉⵀⵡⵉ ⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ.” ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⵔⵉⵢⴰ: “ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍⴻⴷ ⵣⴻⴳ ⵓⵙⴰⴼⴰⵔ? ⵎⴰⵢⴻⵎⵎⵉ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("S211_11","011_11_11","2SA","11","11","11","ⵓⵔⵉⵢⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⴷⴰⵡⵓⴷ: “ⵜⵜⴰⴱⵓⵜ ⴷ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⵜⵜⵖⵉⵎⴰⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵓ ⵙⵉⴷⵉ ⵉⵏⵓ ⵢⵓⵡⴰⴱ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵢⴰⵔⴻⵣⵎⴻⵏ. ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵏⴻⵛⵛ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵖ, ⴰⴷ ⵙⵡⴻⵖ ⵓ ⴰⴷ ⵡⴹⵉⵖ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵏⵓ? ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵜⴻⴷⴷⴰⵔⴻⴷ ⵛⴻⴽ ⵓ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("S211_12","011_11_12","2SA","11","12","12","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⵔⵉⵢⴰ: “ⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⴰⵙⵙ-ⴰ ⵄⴰⴷ ⴷⴰⵏⵉⵜⴰ. ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵄⴰⵡⴻⴷ.” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵓⵔⵉⵢⴰ ⴰⵙⵙ ⵏⵏⵉ ⴷ ⵡⴰⵙⵙ ⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S211_13","011_11_13","2SA","11","13","13","ⵉⵄⴰⵔⴹ ⵉ-ⵜ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵛⴰ, ⵉⵙⵡⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵙⵙⵛⴰⵔ ⵉ-ⵜ. ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵎⴰⵛⴰ ⵉⴼⴼⴻⵖ ⵓⵔⵉⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⵣⴻⵍ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵀⵡⵉ ⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S211_14","011_11_14","2SA","11","14","14","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵢⵓⵔⴰ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵢⵓⵡⴰⴱ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵔⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S211_15","011_11_15","2SA","11","15","15","ⵏⴻⵜⵜⴰ ⵢⵓⵔⴰ ⴷⵉ ⵜⴻⴱⵔⴰⵜ ⵏⵏⵉ: “ⵙⴱⴻⴷⴷⴻⵜ ⵓⵔⵉⵢⴰ ⵖⴰⵔ ⵣⵣⴰⵜ ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵎⴻⵏⵖⵉ ⵉⵇⴻⵙⵃⴻⵏ, ⵅⴻⵏⵏⵉ ⵃⴻⵢⵢⴷⴻⵜ ⵅⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵍⴻⵇⴼⴻⵏ, ⴰⴷ ⵉⵎⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("S211_16","011_11_16","2SA","11","16","16","ⴰⵎ ⵉⵃⵚⴰⵔ ⵢⵓⵡⴰⴱ ⵜⴰⵏⴷⵉⵏⵜ, ⵉⵎⵙⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵔⵉⵢⴰ ⵖⴰⵔ ⵎⴰⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S211_17","011_11_17","2SA","11","17","17","ⵅⴻⵏⵏⵉ ⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵢⵓⵡⴰⴱ. ⵡⴹⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵓⵍⴰ ⴷ ⴰⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S211_18","011_11_18","2SA","11","18","18","ⵢⵓⵡⴰⴱ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵓⵛⴰ ⵉⵃⴰⵊⴰ ⵉ ⴷⴰⵡⵓⴷ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⵓⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S211_19","011_11_19","2SA","11","19","19","ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵛ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⵓⵔ ⵎⴰⵔⵔⴰ ⵓⵎⴻⵏⵖⵉ, ");
INSERT INTO rift_vpl VALUES ("S211_20","011_11_20","2SA","11","20","20","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⴰⴷ ⵉⴽⴽⴰⵔ ⵡⴻⵙⵄⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⴰⵛ ⵢⵉⵏⵉ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵓⴷⵙⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ? ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⵜⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵍⵃⵉⴹ? ");
INSERT INTO rift_vpl VALUES ("S211_21","011_11_21","2SA","11","21","21","ⵎⴰⵏ ⵡⴻⵏ ⵉⵏⵖⵉⵏ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⴱⵓⵛⴰⵜ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵅⴰⵙ ⵜⴰⵙⵉⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵏ ⵜⵙⵉⵔⵜ ⵣⵉ ⵍⵃⵉⴹ, ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⴷⵉ ⵜⴰⴱⴰⵚ? ⵎⴰⵢⴻⵎⵎⵉ ⵜⵓⵢⵓⵔⴻⵎ ⵜⵓⴷⵙⴻⵎ ⴰⵎⵎⵓ ⵍⵃⵉⴹ?’, ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ, ⵉⵜⵜⵡⴰⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("S211_22","011_11_22","2SA","11","22","22","ⴰⵔⴻⵇⵇⴰⵙ ⵢⵓⵢⵓⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⵃⴰⵊⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⵜ ⵉⵙⵙⴻⴽⴽ ⵢⵓⵡⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("S211_23","011_11_23","2SA","11","23","23","ⴰⵔⴻⵇⵇⴰⵙ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⵉⵔⵢⴰⵣⴻⵏ ⵜⵓⵖⴰ ⵊⴻⵀⴷⴻⵏ ⵅⴰⵏⴻⵖ ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ ⴰⵍ ⵉⵢⵢⴰⵔ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵃⵚⴰⵔ ⵉ-ⵜⴻⵏ ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S211_24","011_11_24","2SA","11","24","24","ⵅⴻⵏⵏⵉ ⵡⵜⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵃⴰⴽⴰⵏ ⵙ ⵍⵇⴻⵡⵙ ⵣⵉ ⵍⵃⵉⴹ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵎⵎⵓⵜⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ, ⵉⵎⵎⵓⵜ.” ");
INSERT INTO rift_vpl VALUES ("S211_25","011_11_25","2SA","11","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⵔⴻⵇⵇⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⵉ ⵢⵓⵡⴰⴱ: ‘ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵙⵙⵉⴼ ⴰⴷ ⵉⵛⵛ ⵡⴰⵏⵉⵜⴰ, ⴷⴰⵡⴻⵃⴷⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵀⴷⴻⵎ ⵉ-ⵜⵜ!’ ⴻⴳⴳ ⴷⴰⵢⴻⵙ ⵜⴰⵔⵢⴰⵙⵜ ⵙ ⵡⴰⵡⴰⵍ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("S211_26","011_11_26","2SA","11","26","26","ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⵔⵉⵢⴰ ⵜⴻⵙⵍⴰ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵓⵔⵉⵢⴰ ⵉⵎⵎⵓⵜ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵅ ⵙⵉⴷⵉ ⵏⵏⴻⵙ ⴰⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S211_27","011_11_27","2SA","11","27","27","ⵓⵎⵉ ⵜⴻⵄⴷⵓ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ, ⵜⵓⵖⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S212_1","011_12_1","2SA","12","1","1","ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵏⴰⵜⴰⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵊⵊⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⴳⵍⴰ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷ ⴰⵎⴻⵣⵍⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("S212_2","011_12_2","2SA","12","2","2","ⴱⵓ-ⵡⴰⴳⵍⴰ ⵖⴰⵔⴻⵙ ⴰⴱⴰⵔⵔⵓ ⵏ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S212_3","011_12_3","2SA","12","3","3","ⴰⵎⴻⵣⵍⵓⴹ ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵃⵓⵍⵉⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵙⵖⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵛⵛⴰ ⵉ-ⵜⵜ ⵓ ⵜⴻⴷⵡⴻⵍ ⵜⵎⴻⵇⵇⴰⵔ ⵖⴰⵔⴻⵙ ⵓ ⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ⵜⴻⵛⵛⴰ ⵣⴻⴳ ⵓⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵙ ⵓ ⵜⴻⵙⵡⴰ ⵣⴻⴳ ⵓⴼⴻⵏⵊⴰⵍ ⵏⵏⴻⵙ ⵓ ⵜᵉⵟⵟⴻⵚ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ-ⵜⵜ ⵉ ⵏⴻⵜⵜⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵢⴻⴵⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("S212_4","011_12_4","2SA","12","4","4","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵢⴻⵡⵄⴰⵔ ⵅⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵎⴰⵛⵛⴰ ⵉ ⵓⵎⵙⴻⴱⵔⵉⴷ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ ⵏⵉⵖ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵜⴰⵃⵓⵍⵉⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎⴻⵣⵍⵓⴹ ⵓⵛⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉ-ⵜⵜ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("S212_5","011_12_5","2SA","12","5","5","ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏ ⴷⴰⵡⵓⴷ ⴰⵟⵟⴰⵙ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵉⵏⵏⴰ ⵉ ⵏⴰⵜⴰⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⵢⴰⵣ ⵉ ⵉⴳⴳⵉⵏ ⴰⵢⴰ, ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵍⵎⴻⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("S212_6","011_12_6","2SA","12","6","6","ⵓⵛⴰ ⵜⴰⵃⵓⵍⵉⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⴰⴷ ⵜⵜ ⵉⵅⵍⴻⴼ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵢⴰ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵃⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("S212_7","011_12_7","2SA","12","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴰⵜⴰⵏ ⵉ ⴷⴰⵡⵓⴷ: “ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ. ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵏⴻⵛⵛ ⴷⴻⵀⵏⴻⵖ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵛⴻⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S212_8","011_12_8","2SA","12","8","8","ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵛ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵛ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ. ⵎⴰⵍⴰ ⴰⵢⴰ ⴷⵔⵓⵙ, ⵉⵍⵉ ⴰⴷ ⴰⵔⵏⵉⵖ ⵡⴰ ⵏⵉⵖ ⵜⴰ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("S212_9","011_12_9","2SA","12","9","9","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ? ⵛⴻⴽ ⵜⴻⵏⵖⵉⴷ ⴰⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ ⵙ ⵙⵙⵉⴼ ⵓ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⴳⴳⵉⴷ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⴻⵏⵖⵉⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵙ ⵙⵙⵉⴼ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S212_10","011_12_10","2SA","12","10","10","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵙⵉⴼ ⵡⴰⵔ ⵉⵜⵜⵃⴻⵢⵢⵉⴷ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⴰⵢⵉ ⵓ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⵃⵉⵜⵜⵉ ⵓⵔⵉⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S212_11","011_12_11","2SA","12","11","11","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵥⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴽⴽⵙⴻⵖ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴻⵏⵜ ⵡⵛⴻⵖ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵟⵟⴻⵚ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⴼⵓⵛⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S212_12","011_12_12","2SA","12","12","12","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⵜ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓ ⵖⴰⵔ ⵜⵉⴼⴰⵡⵜ ⵏ ⵜⴼⵓⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("S212_13","011_12_13","2SA","12","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵏⴰⵜⴰⵏ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ!” ⵉⵏⵏⴰ ⵏⴰⵜⴰⵏ ⵉ ⴷⴰⵡⵓⴷ: “ⵙⵉⴷⵉ ⵉⵖⴼⴰⵔ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⵎⴻⵜⵜⵉⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S212_14","011_12_14","2SA","12","14","14","ⵎⴰⵛⴰ, ⵓⵎⵉ ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⵇⵇⴼⴻⵏ ⴰⵟⵟⴰⵙ, ⵙ ⵜⵉⴷⴻⵜⵜ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵎⵎⵉⵛ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S212_15","011_12_15","2SA","12","15","15","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵏⴰⵜⴰⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵙⵉⴷⵉ ⵉⵍⵇⴻⴼ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵔⵉⵢⴰ ⵉ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵃⵍⴻⵛ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S212_16","011_12_16","2SA","12","16","16","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵣⵓ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵉⵥⵓⵎⵎ ⴷⴰⵡⵓⴷ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⵓ ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ, ⵉⵣⵣⴻⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S212_17","011_12_17","2SA","12","17","17","ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵙⵉⵏ-ⴷⴷ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵔⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵅⵙ ⵓ ⵡⴰⵔ ⵉⵛⵛⵉ ⴰⵖⵔⵓⵎ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S212_18","011_12_18","2SA","12","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵎⵎⵓⵜ. ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⴳⴳⵯⴻⴷⴻⵏ ⴰⴷ ⴰⵙ ⵉⵏⵉⵏ, ⴰⵇⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵎⵎⵓⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⵓⵎⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵜⵓⵖⴰ ⵉⴷⴷⴰⵔ ⵄⴰⴷ, ⵏⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵉⵙⵍⵉ ⵛⴰ. ⵎⴰⵎⵎⴻⵛ ⵉ ⵏⵣⴻⵎⵎⴰⵔ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵙ ⵏⵉⵏⵉ: ‘ⴰⵃⴻⵏⵊⵉⵔ ⵉⵎⵎⵓⵜ’? ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S212_19","011_12_19","2SA","12","19","19","ⴷⴰⵡⵓⴷ ⵉⵥⵔⴰ ⴰⵇⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵜⵃⴻⵙⵙⴻⵛⵜ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓ ⴷⴰⵡⵓⴷ ⵢⵓⵛⴰ ⵉⵍⵍⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰ ⵉⵎⵎⵓⵜ ⵓⵃⴻⵏⵊⵉⵔ?” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵇⴰ ⵉⵎⵎⵓⵜ!” ");
INSERT INTO rift_vpl VALUES ("S212_20","011_12_20","2SA","12","20","20","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵙⵙⵉⵔⴷ, ⵉⴷⵀⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⴱⴻⴷⴷⴻⵍ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵙⵊⴻⴷ. ⵓⵎⵉ ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵜⵜⴰⵔ ⴰⵖⵔⵓⵎ ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵖⵔⵓⵎ ⵣⵣⴰⵜⴻⵙ ⵓⵛⴰ ⵉⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S212_21","011_12_21","2SA","12","21","21","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ ⵍⴻⵅⵅⵓ? ⵓⵎⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵄⴰⴷ ⵉⴷⴷⴰⵔ, ⵜⵥⵓⵎⵎⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⵓ ⵜⵔⵓⴷ. ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵓⵃⴻⵏⵊⵉⵔ, ⵜⴻⴽⴽⴰⵔⴻⴷ ⵓⵛⴰ ⵜⴻⵛⵛⵉⴷ ⴰⵖⵔⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("S212_22","011_12_22","2SA","12","22","22","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵓⵎⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵄⴰⴷ ⵉⴷⴷⴰⵔ, ⵥⵓⵎⵎⴻⵖ ⵓ ⵔⵓⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵡⵉ ⵉⵙⵙⵏⴻⵏ, ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⴼⵉ ⵉⵃⵉⵏⵏ ⵓ ⴰⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵉⴷⴷⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("S212_23","011_12_23","2SA","12","23","23","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵉⵎⵎⵓⵜ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵥⵓⵎⵎⴻⵖ ⵄⴰⴷ? ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⴻⵖ? ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⵔⴰⵃⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵉ ⵉⵜⵜⵄⵉⵇⵇⵉⴱ.” ");
INSERT INTO rift_vpl VALUES ("S212_24","011_12_24","2SA","12","24","24","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ ⵓ ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵅⴰⵙ, ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ, ⵉⴳⴳⴰ ⴰⵙ ⵙⵓⵍⵉⵎⴰⵏ. ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ");
INSERT INTO rift_vpl VALUES ("S212_25","011_12_25","2SA","12","25","25","ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵢⴰⴷⵉⴷ-ⵢⴰⵀ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵅⵙ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S212_26","011_12_26","2SA","12","26","26","ⵢⵓⵡⴰⴱ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵔⴰⴱⴱⴰ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵃⴻⵡⵡⴻⵙ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S212_27","011_12_27","2SA","12","27","27","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵢⵓⵡⴰⴱ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵎⵎⴻⵏⵖⴻⵖ ⴰⴽ-ⴷ ⵔⴰⴱⴱⴰ ⵟⵟⴼⴻⵖ ⵓⵍⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S212_28","011_12_28","2SA","12","28","28","ⵙⵎⵓⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵏⵏⴻⴹ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵟⵟⴻⴼ ⵉ-ⵜⵜ, ⵏⵉⵖ ⴰⴷ ⵟⵟⴼⴻⵖ ⵏⴻⵛⵛ ⵜⴰⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("S212_29","011_12_29","2SA","12","29","29","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⴷⴰⵡⵓⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵔⴰⴱⴱⴰ, ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("S212_30","011_12_30","2SA","12","30","30","ⵉⴽⴽⴻⵙ ⵜⵜⴰⵊ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵅⴰⵙ ⵜⴰⵢⴰⵇⵓⵜⵉⵏ ⵉⵖⵍⴰⵏ, ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵜⵜⴰⵊ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S212_31","011_12_31","2SA","12","31","31","ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ ⵓ ⵉⵃⵊⴻⵎ ⵅⴰⵙⴻⵏ ⵙ ⵍⵎⴻⵏⵛⴰⵔⴰⵜ ⴷ ⵉⵢⴰⵍⵣⵉⵎⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵛⵛⵡⴰⵇⴰⵔ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵄⴷⵓⵏ ⵙ ⵍⴽⵓⵛⵛⴰⵜ ⵏ ⵍⵍⴰⵊⵓⵔ. ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⴷⴰⵡⵓⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S213_1","011_13_1","2SA","13","1","1","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ, ⴰⵇⴰ ⴰⴱⵛⴰⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵓⵍⵜⵎⴰⵙ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⴰⵎⴰⵔ, ⵓⵛⴰ ⴰⵎⵏⵓⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵄⵛⴻⵇ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("S213_2","011_13_2","2SA","13","2","2","ⴰⵎⵏⵓⵏ ⵜⵓⵖⴰ ⵉⵛⴹⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⵉⵀⵍⴻⵛ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵍⵜⵎⴰⵙ ⵜⴰⵎⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵎⵏⵓⵏ ⴰⴷ ⴰⵙ ⵉⴳⴳ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("S213_3","011_13_3","2SA","13","3","3","ⴰⵎⵏⵓⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵇⵇⴰⵔⴻⵏ ⴰⵙⵙ ⵢⵓⵏⴰⴷⴰⴱ, ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⴰ, ⵓⵎⴰⵙ ⵏ ⴷⴰⵡⵓⴷ. ⵢⵓⵏⴰⴷⴰⴱ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵃⵔⴰⵢⵎⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S213_4","011_13_4","2SA","13","4","4","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵛⴻⴹⵏⴻⴷ ⴰⵎⵎⵓ ⵣⵉ ⵜⵓⴼⴼⵓⵜ ⴰⵍ ⵜⵓⴼⴼⵓⵜ, ⵛⴻⴽ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ? ⵎⴰ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜ ⵜⵄⴰⵡⴷⴻⴷ?” ⴰⵎⵏⵓⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛ ⵄⴻⵛⵇⴻⵖ ⵜⴰⵎⴰⵔ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵓⵎⴰ ⴰⴱⵛⴰⵍⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("S213_5","011_13_5","2SA","13","5","5","ⵉⵏⵏⴰ ⴰⵙ ⵢⵓⵏⴰⴷⴰⴱ: “ⵣⵣⴻⵍ ⴷⵉ ⵇⴰⵎⴰ ⵓ ⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵀⴻⵍⵛⴻⴷ. ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴱⴰⴱⴰⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴽ ⵉⵙⵙⵉⵊⵊ, ⵉⵏⵉ ⴰⵙ: ‘ⴻⵊⵊ ⵓⵍⵜⵎⴰ ⵜⴰⵎⴰⵔ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛ ⵎⴰⵛⵛⴰ ⵓ ⴰⴷ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵎⴰⵛⵛⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⵖ, ⴰⴷ ⵛⵛⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("S213_6","011_13_6","2SA","13","6","6","ⴰⵎⵏⵓⵏ ⵉⵣⵣⴻⵍ ⴷⵉⵏ, ⵉⵙⵙⵏⵉⵄⵎⵉⵍ ⵉⵀⵍⴻⵛ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⵉⵊⵊ, ⵉⵏⵏⴰ ⴰⵎⵏⵓⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴻⵊⵊ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵓⵍⵜⵎⴰ ⵜⴰⵎⴰⵔ ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵔⵢⵉⵟⴰⵜⵉⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏⵜ ⵛⵛⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S213_7","011_13_7","2SA","13","7","7","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵖⴰⵔ ⵜⴰⵎⴰⵔ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵏⵏⴰ: “ⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵎ ⴰⵎⵏⵓⵏ ⵓ ⵙⴻⵡⵊⴻⴷ ⴰⵙ ⵎⴰⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("S213_8","011_13_8","2SA","13","8","8","ⵜⴰⵎⴰⵔ ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵙ ⴰⵎⵏⵓⵏ ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵉⵣⵣⵍⴻⵏ ⴷⵉ ⵇⴰⵎⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⴰⵔⴻⵛⵜⵉ, ⵜⴻⴳⴳⵯⴰ ⵜ ⵓ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵜⵉⵖⴰⵔⵢⵉⵟⴰⵜⵉⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴳⴳⵯⴰ ⵜⵉⵖⴰⵔⵢⵉⵟⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("S213_9","011_13_9","2SA","13","9","9","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⵎⴰⵔⵎⵉⵜⴰ ⵜⴻⴳⴳⵉⴷ-ⵉ-ⵜⵜ ⵣⵣⴰⵜⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ ⴰⴷ ⵉⵛⵛ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵎⵏⵓⵏ: “ⴻⵊⵊ ⴰⴷ ⵅⴰⴼⵉ ⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ!” ⵓ ⵎⴰⵔⵔⴰ ⴼⴼⵖⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S213_10","011_13_10","2SA","13","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵎⵏⵓⵏ ⵉ ⵜⴰⵎⴰⵔ: “ⴰⵡⵉ-ⴷⴷ ⵎⴰⵛⵛⴰ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ.” ⵓ ⵜⴰⵎⴰⵔ ⵜⴻⴽⵙⵉ ⵜⵉⵖⴰⵔⵢⵉⵟⴰⵜⵉⵏ ⵉ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵓ ⵜⵉⵡⵢⵉ ⵜⴻⵏⵜ ⵉ ⵓⵎⴰⵙ ⴰⵎⵏⵓⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("S213_11","011_13_11","2SA","13","11","11","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵉⵥⵥⵡⵉⴹ ⵉ-ⵜⴻⵏⵜ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵛⵛ. ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵙ-ⴷⴷ, ⵟⵟⴻⵚ ⵖⴰⵔⵉ, ⵓⵍⵜⵎⴰ!” ");
INSERT INTO rift_vpl VALUES ("S213_12","011_13_12","2SA","13","12","12","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵍⵍⴰ, ⴰ ⵓⵎⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵙⴻⵅⵙⴰⵔⵉ ⵛⴰ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("S213_13","011_13_13","2SA","13","13","13","ⵎⴰⵏⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ ⴷⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉⵏⵓ? ⵓ ⵛⴻⴽ, ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵙⵉⵡⴻⵍ ⵎⴰⵛⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵟⵟⴻⴼ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("S213_14","011_13_14","2SA","13","14","14","ⵎⴰⵛⴰ ⴰⵎⵏⵓⵏ ⵡⴰⵔ ⵉⵅⵙ ⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵙⴻⵍ, ⵎⴰⵛⴰ ⵉⵊⵀⴻⴷ ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ ⵉ-ⵜⵜ, ⵉⵟⵟⴻⵚ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S213_15","011_13_15","2SA","13","15","15","ⴷⴰⵡⴻⵃⴷⴰ ⵏⵏⴻⵙ ⵉⵄⵉⴼⴼ ⵉ-ⵜⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵄⵉⴼⴼⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⴰⵄⵉⴼⴼⵉ ⵉ ⵣⵉ ⵜⵜ ⵉⵄⵉⴼⴼ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⴰⵢⵔⵉ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⵜ ⵉⵄⵛⴻⵇ. ⴰⵎⵏⵓⵏ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⴰⴳⴳⵯⴻⵊ!” ");
INSERT INTO rift_vpl VALUES ("S213_16","011_13_16","2SA","13","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⴷⵉⵏ ⵍⴻⵙⴱⴰⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ. ⵜⵓⵄⴻⴼⴼⵏⴰ-ⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⵍⵄⵉⴱ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ.” ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S213_17","011_13_17","2SA","13","17","17","ⵉⵍⴰⵖⴰ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵙ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⴻⴽⴽ ⵜⴰ ⵅⴰⴼⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓ ⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("S213_18","011_13_18","2SA","13","18","18","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵅⴰⵙ ⴰⵔⵔⵓⴹ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵢⴰⵔⴹⴻⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵏⵜ ⴷ ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ. ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵢⵉⵡⵢⵉ ⵜⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S213_19","011_13_19","2SA","13","19","19","ⵜⴰⵎⴰⵔ ⵜⵣⵓⵣⵣⴰⵔ ⵉⵖⵖⴻⴹ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵜⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵉ ⵜⵢⴰⵔⴹ, ⵜⴻⵙⵙⴰⵔⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵓⵢⵓⵔ ⵜⴻⵙⵖⵓⵢⵢⵓ. ");
INSERT INTO rift_vpl VALUES ("S213_20","011_13_20","2SA","13","20","20","ⵓⵎⴰⵙ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵙⵙⴻⵇⵙⴰ ⵜⵜ: “ⵎⴰ ⵜⵓⵖⴰ ⵓⵎⴰⵎ ⴰⵎⵏⵓⵏ ⴰⴽⵉⴷⴻⵎ? ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵓⵍⵜⵎⴰ, ⵙⵓⵙⴻⵎ, ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰⵎ. ⵡⴰⵔ ⴷ ⴰⵎ ⵉⵜⵜⴻⵇⵇⴻⵙ ⴱⵓ ⵍⵃⴰⵍ!” ⵓ ⵜⴰⵎⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵡⴻⵃⵃⴷⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵙ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S213_21","011_13_21","2SA","13","21","21","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵉⴷⵡⴻⵍ ⵉⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S213_22","011_13_22","2SA","13","22","22","ⴰⴱⵛⴰⵍⵓⵎ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⴷ ⴰⴽ-ⴷ ⴰⵎⵏⵓⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⵛⵓⵏⵉ ⵓⵍⴰ ⴷⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵎⴰⵖⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵄⵉⴼⴼ ⴰⵎⵏⵓⵏ ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ ⵓⵍⵜⵎⴰⵙ ⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S213_23","011_13_23","2SA","13","23","23","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵎⵓⵏⴻⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⴱⵛⴰⵍⵓⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵔⴻⵡⵡⴰⵏ ⴷⵉ ⴱⴰⵄⵍ-ⵃⴰⵚⵓⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵄⴰⵔⴹ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S213_24","011_13_24","2SA","13","24","24","ⵢⵓⵢⵓⵔ ⴰⴱⵛⴰⵍⵓⵎ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵖⴰⵔⴻⵙ ⵉⵔⴻⵡⵡⴰⵏ! ⴻⵊⵊ ⵓⵊⴻⴵⵉⴷ ⵙ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S213_25","011_13_25","2SA","13","25","25","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⴰⴱⵛⴰⵍⵓⵎ: “ⵍⵍⴰ, ⴰ ⵎⵎⵉ, ⴻⵊⵊ ⴰⵏⴻⵖ ⵡⴰⵔ ⴷⴷ-ⵏⴻⵜⵜⵉⵙ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⴽ ⵏᵉⵜⵜⴻⴳⴳ ⴷⴷⵇⴻⵍ!” ⵏⴻⵜⵜⴰ ⵉⵣⴻⵢⵢⴰⵔ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴽⵉⴷⴻⵙ ⵢⵓⵢⵓⵔ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("S213_26","011_13_26","2SA","13","26","26","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵛⴰⵍⵓⵎ: “ⵎⴰⵍⴰ ⵍⵍⴰ, ⴻⵊⵊ ⵓⵎⴰ ⴰⵎⵏⵓⵏ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵢⵓⵢⵓⵔ!” ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⴰⴽⵉⴷⴻⴽ ⵉ ⵖⴰ ⵢⵓⵢⵓⵔ?” ");
INSERT INTO rift_vpl VALUES ("S213_27","011_13_27","2SA","13","27","27","ⵓⵎⵉ ⵅⴰⵙ ⵉⵣⴻⵢⵢⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ, ⵉⵊⵊⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⵎⵏⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S213_28","011_13_28","2SA","13","28","28","ⴰⴱⵛⴰⵍⵓⵎ ⵢⵓⵎⵓⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵃⴹⴰⵎ, ⵅⵎⵉ ⵖⴰ ⵢⴰⵔⴻⵛⵛⴻⵇ ⵓⵍ ⵏ ⴰⵎⵏⵓⵏ ⵣⵉ ⴱⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ‘ⵡⵜⴻⵎ ⴰⵎⵏⵓⵏ!’, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜ ⵏⵖⴻⵎ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ! ⵎⴰ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵓⵎⵓⵔⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ? ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⵉⵍⵉⵎ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵔⵢⴰⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("S213_29","011_13_29","2SA","13","29","29","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⴱⵛⴰⵍⵓⵎ ⴳⴳⵉⵏ ⴰⴽ-ⴷ ⴰⵎⵏⵓⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵉⴳⴳⴰ ⴰⴱⵛⴰⵍⵓⵎ. ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵏⵢⵉⵏ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵅ ⵓⵙⴰⵔⴷⵓⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S213_30","011_13_30","2SA","13","30","30","ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⴻⵅⴱⴰⵔ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⴰⴱⵛⴰⵍⵓⵎ ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S213_31","011_13_31","2SA","13","31","31","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵣⵣⴻⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ ⵖⴰⵔⴻⵙ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵉⵛⴰⵔⵔⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S213_32","011_13_32","2SA","13","32","32","ⵎⴰⵛⴰ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⴰ, ⵓⵎⴰⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵍ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ⴰⵎⵏⵓⵏ ⵡⴰⵀⴰ ⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ ⵉⴳⴳⴰ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉⵙⵙⵅⴰⵔⵔⴻⴳ ⵡⴰⵏⵉⵜⴰ ⵓⵍⵜⵎⴰⵙ ⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S213_33","011_13_33","2SA","13","33","33","ⴻⵊⵊ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵍⵃⴰⵍ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ!’, ⵎⴰⵖⴰⵔ ⴰⵎⵏⵓⵏ ⵡⴰⵀⴰ ⵉⵎⵎⵓⵜ.” ");
INSERT INTO rift_vpl VALUES ("S213_34","011_13_34","2SA","13","34","34","ⴰⴱⵛⴰⵍⵓⵎ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ. ⵓⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴻⵙⵙⴰⵏ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵡⴷⴰⵏ ⴰⵟⵟⴰⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵉⴵⴰⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S213_35","011_13_35","2SA","13","35","35","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵏⴰⴷⴰⴱ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵅⵣⴰⵔ, ⴰⵔⵔⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⴷⴷ-ⵜⵜⴰⵙⴻⵏ. ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S213_36","011_13_36","2SA","13","36","36","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵅⴻⴹⵔⴻⵏ-ⴷⴷ ⴰⵔⵔⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵔⵓⵏ. ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴽⵙⵉⵏ ⴷⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S213_37","011_13_37","2SA","13","37","37","ⴰⴱⵛⴰⵍⵓⵎ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⵍⵎⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵅⵓⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵛⵓⵔ. ⴷⴰⵡⵓⴷ ⵉⵛⴹⴻⵏ ⵅ ⵎⵎⵉⵙ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S213_38","011_13_38","2SA","13","38","38","ⴰⴱⵛⴰⵍⵓⵎ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵊⴰⵛⵓⵔ. ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("S213_39","011_13_39","2SA","13","39","39","ⴰⵢⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴼⴻⵖ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⴱⵛⴰⵍⵓⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵄⴻⵣⵣⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵎⴻⵡⵜ ⵏ ⴰⵎⵏⵓⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ ⴰⵇⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S214_1","011_14_1","2SA","14","1","1","ⵓⵎⵉ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵉⵃⴻⴽⴽⴰⵔ ⴰⵇⴰ ⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⴹⵉⴷⴷ ⵉ ⴰⴱⵛⴰⵍⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("S214_2","011_14_2","2SA","14","2","2","ⵉⵙⵙⴻⴽⴽ ⵢⵓⵡⴰⴱ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵜⴰⵇⵓⵄⴰ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⴷ ⵙⵙⴻⵏⵏⵉ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵜⴰⵎⵉⵖⵉⵙⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴻⴳⴳ ⴰⵅⵎⵉ ⵛⴻⵎ ⵜⵛⴻⴹⵏⴻⴷ, ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵡⴰⵔ ⴷⴻⵀⵀⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵣⵣⴻⵛⵜ! ⵙⵏⴻⵄⵎⵉⵍ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵛⴻⴹⵏⴻⵏ ⵅ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S214_3","011_14_3","2SA","14","3","3","ⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵓ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⴰⵡⴰⵍⴻⵏ-ⴰ.” ⵓⵛⴰ ⵢⵓⵡⴰⴱ ⵉⵏⵏⴰ ⴰⵙ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S214_4","011_14_4","2SA","14","4","4","ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵜⴰⵇⵇⵓⵄⴰ ⵜⴻⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴰⵎ ⵜⴻⵡⴹⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵓⴹⴰⵔ ⴰⵙ: “ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⴰ ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("S214_5","011_14_5","2SA","14","5","5","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ?” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴷ ⵜⴰⵊⵊⴰⵍⵜ, ⴰⵔⵢⴰⵣ ⵉⵏⵓ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("S214_6","011_14_6","2SA","14","6","6","ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵎⵎⴻⵏⵖⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵜⴻⵏ ⵉⴱⴹⴰ. ⵅⴻⵏⵏⵉ ⵉⵡⵜⴰ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("S214_7","011_14_7","2SA","14","7","7","ⵓ ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵍⴰⴵ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵏⵏⴰⵏ: ‘ⴰⵡⵉ-ⴷⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵓⵎⴰⵙ ⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⴻⵏⵏⴻⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵎⴰⵙ ⵡⴻⵏⵏⵉ ⵜ ⵉⵏⵖⵉⵏ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⴻⵇⴹⴰ ⵓⵍⴰ ⵅ ⵡⴻⵡⵔⵉⵜ.’ ⴰⵎⵎⵓ ⵉ ⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵅⴻⵙⵢⴻⵏ ⴰⵢⴻⵏⵏⵉ ⵏ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵓ ⵉⵙⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("S214_8","011_14_8","2SA","14","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ! ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵅⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("S214_9","011_14_9","2SA","14","9","9","ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵜⴰⵇⵇⵓⵄⴰ ⵜⴻⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴻⵊⵊ ⴰⴷ ⵜⵉⵍⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅⴰⴼⵉ ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ. ⴰⵊⴻⴵⵉⴷ ⴷ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S214_10","011_14_10","2SA","14","10","10","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵛⴰ ⵅⴰⵎ, ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⴰⴷ ⵛⴻⵎ ⵉⵚⴻⴷⴷⴻⵄ.” ");
INSERT INTO rift_vpl VALUES ("S214_11","011_14_11","2SA","14","11","11","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⴻⵊⵊ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵅⵍⴻⴼ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴰⵔ ⵢⴰⵔⴻⵏⵏⵉ ⵄⴰⴷ ⴷⵉ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵓ ⵡⴰⵔ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵎⵎⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵍⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⵟⵟⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵎⵎⵉⵎ ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("S214_12","011_14_12","2SA","14","12","12","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴻⵊⵊ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵏⵉ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ.” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("S214_13","011_14_13","2SA","14","13","13","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵜⴻⵏⵡⵉⴷ ⵛⴻⴽ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎⵎⵓ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵓⵎⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵍⴻⵅⵅⵓ ⴰⵡⴰⵍ-ⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⵎ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⵄⵉⴱ, ⵎⵉⵏⵣⵉ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⵖⴰⵔⴻⵙ ⵡⴻⵏⵏⵉ ⵜ ⵉⵏⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S214_14","011_14_14","2SA","14","14","14","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵏⴻⵎⵎⴻⵜ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵎ ⵡⴰⵎⴰⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵔⵖⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵏⵏⵢⴰⵔⵡⴻⵏ. ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵍⴻⵄⵎⴰⵔ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⵃⵉⵎⴰ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵎⵎⴻⵏⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S214_15","011_14_15","2SA","14","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴰⵍ-ⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⴰⵢⵉ. ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ: ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⴳⴳ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("S214_16","011_14_16","2SA","14","16","16","ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵙⴻⵍ ⵖⴰⵔ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵜⴻⵃⵃⴰ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵟⵟⴼⴻⵖ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("S214_17","011_14_17","2SA","14","17","17","ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵜⴻⵏⵏⴰ ⵄⴰⵡⴻⴷ: ⴻⵊⵊ ⴰⴷ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵍⴰⵎⵉ ⵉⵜⵜⴻⵙⵍⴰ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S214_18","011_14_18","2SA","14","18","18","ⴰⵊⴻⴵⵉⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⴼⴼⴰⵔ ⵡⴰⵍⵓ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵅ ⵛⴻⵎ ⵉ ⵖⴰ ⵙⵙⴻⵇⵙⵉⵖ.” ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⴰ: “ⴻⵊⵊ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("S214_19","011_14_19","2SA","14","19","19","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰ ⵢⵓⵡⴰⴱ ⵖⴰⵔⴻⵙ ⴰⴼⵓⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ?” ⵜⴰⵎⵖⴰⵔⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⴱⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏⵉⵖ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ! ⵡⴰⵀ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵢⵓⵡⴰⴱ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵢⵓⵎⵓⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S214_20","011_14_20","2SA","14","20","20","ⴰⵢⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵢⵓⵡⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⵊⵊ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵖⵏⵉ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷ ⴰⵎⵉⵖⵉⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵍⴰⵎⵉ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⵎⵙⴰⵔⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("S214_21","011_14_21","2SA","14","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⵓⵡⴰⴱ: “ⵅⵣⴰⵔ ⵄⴰⴼⴰⴽ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵎⴰⵏ ⴰⵢⴰ. ⵓⵢⵓⵔ, ⴰⵡⵉ-ⴷⴷ ⴰⵃⵓⴷⵔⵉ ⴰⴱⵛⴰⵍⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("S214_22","011_14_22","2SA","14","22","22","ⵢⵓⵡⴰⴱ ⵉⵡⴹⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵢⵓⴹⴰⵔ ⴰⵙ, ⵉⵇⴰⴷⴰ ⵉ ⵓⵊⴻⴵⵉⴷ. ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ: “ⴰⵙⵙ-ⴰ ⵉⵙⵙⴻⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵄⵍⴰⵀⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S214_23","011_14_23","2SA","14","23","23","ⵉⴽⴽⴰⵔ ⵢⵓⵡⴰⴱ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵊⴰⵛⵓⵔ ⵓ ⵢⵉⵡⵉⴹ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴽ-ⴷ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S214_24","011_14_24","2SA","14","24","24","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵓⴷⴻⵎ ⵉⵏⵓ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⵥⵥⴰⵔ.” ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⴰⴱⵛⴰⵍⵓⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵥⵔⵉ ⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S214_25","011_14_25","2SA","14","25","25","ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵛⴻⵡⵡⴰⵔ ⴰⵎ ⴰⴱⵛⴰⵍⵓⵎ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ ⴰⵟⵟⴰⵙ. ⵣⵉ ⵜⴰⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⴰⵍ ⵜⵇⵉⵛⵛⵉⵜ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("S214_26","011_14_26","2SA","14","26","26","ⵎⴰⵍⴰ ⵉⵃⴻⴼⴼ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⵉⵏⵏⵓⵎ ⴰⴷ ⵜ ⵉⵃⴻⴼⴼ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵓⵙⵙⴰⵏ ⵏ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⴷⴷⴻⴽⴽⵡⴰⵍ ⵉⴷⵇⴻⵍ ⵅⴰⵙ. ⵉⵃⴻⴼⴼ ⵓ ⵉⵡⵣⴻⵏ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵍⴻⵡⵣⴻⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵎⵉⵜⴰⵢⴻⵏ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵥⵔⵓ ⵙ ⵍⴻⵡⵣⴻⵏ ⵉⵎⵜⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S214_27","011_14_27","2SA","14","27","27","ⵜⵜⵡⴰⵔⵡⴻⵏ-ⴷⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⴰⴱⵛⴰⵍⵓⵎ ⴷ ⵉⵛⵜ ⵏ ⵢⴻⴵⵉⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⴰⵎⴰⵔ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S214_28","011_14_28","2SA","14","28","28","ⴰⴱⵛⴰⵍⵓⵎ ⵉⵣⴷⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵥⵔⵉ ⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S214_29","011_14_29","2SA","14","29","29","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵢⵓⵡⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵢⵓⵡⴰⴱ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵙ. ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵔⴻⵇⵇⴰⵙ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S214_30","011_14_30","2SA","14","30","30","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔⴻⵎ, ⵉⵢⵢⴰⵔ ⵏ ⵢⵓⵡⴰⴱ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵏⵓ ⵓ ⵏⴻⵜⵜⴰ ⵉⵥⵥⵓ ⴷⴰⵢⴻⵙ ⵉⵎⴻⵏⴷⵉ. ⵓⵢⵓⵔⴻⵎ ⴷⵉⵏ, ⵇⵇⴻⴷⴻⵎ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ!” ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⴱⵛⴰⵍⵓⵎ ⵇⵇⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵉⵢⵢⴰⵔ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S214_31","011_14_31","2SA","14","31","31","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵢⵓⵡⴰⴱ ⵓⵛⴰ ⵉⵙⵙⵉⵊⵊ ⵅ ⴰⴱⵛⴰⵍⵓⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵇⵇⴷⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵓⵔⴻⵇⵇⵉⵄ ⵏ ⵉⵢⵢⴰⵔ ⵉ ⵉⴵⴰⵏ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("S214_32","011_14_32","2SA","14","32","32","ⴰⴱⵛⴰⵍⵓⵎ ⵉⵏⵏⴰ ⵉ ⵢⵓⵡⴰⴱ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ‘ⴰⵙ-ⴷⴷ ⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜⵉⵏⵉⴷ: ⵎⵉⵏ ⵖⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⴷⴰ ⵣⵉ ⵊⴰⵛⵓⵔ? ⵎⵍⵉⵃ ⵉ ⵏⴻⵛⵛ ⵎⵍⵉ ⴷⵉⵏⵏⵉ ⵇⵇⵉⵎⴻⵖ.’ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵎⴰⵍⴰ ⴷⴰⵢⵉ ⵄⴰⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S214_33","011_14_33","2SA","14","33","33","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵢⵓⵡⴰⴱ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ ⴰⵙ ⴰⵢⴰ. ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⴰⴱⵛⴰⵍⵓⵎ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⴱⴻⵏⴷⴻⵇ ⴰⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⵓⴷⴻⵎ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S215_1","011_15_1","2SA","15","1","1","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵊⵊⴰ ⴰⴷ ⴰⵙ ⵉⴹⴻⴱⴱⴰⵔⴰⵏ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⴷ ⵉⵢⵙⴰⵏ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S215_2","011_15_2","2SA","15","2","2","ⵜⵓⵖⴰ ⵉⵜⵜⴻⴽⴽⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ ⵣⵉⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⵃⴰⵍ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵎⴻⵍⵎⵉ ⵎⴰ ⵉⵅⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⵔⴰⵃ ⵙ ⵉⵛⵜ ⵏ ⴷⴷⴻⵄⵡⴻⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵉ ⵛⵛⵔⴻⵄ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⵣⵉ ⵎⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵛⴻⴽ?” ⵎⴰⵍⴰ ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⵛⵜ ⵣⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ”, ");
INSERT INTO rift_vpl VALUES ("S215_3","011_15_3","2SA","15","3","3","ⵉⵏⵏⴰ ⴰⵙ ⴰⴱⵛⴰⵍⵓⵎ: “ⵅⵣⴰⵔ, ⴷⴷⴻⵄⵡⴰ ⵏⵏⴻⵛ ⵎⵍⵉⵃ ⵓ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵖⴰ ⵉⵙⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S215_4","011_15_4","2SA","15","4","4","ⴰⴱⵛⴰⵍⵓⵎ ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ: “ⵎⵍⵉ ⴷ ⴰⵢⵉ ⴳⴳⵉⵏ ⴷ ⵍⵇⴰⴹⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵏⵉⵖ ⴷⴷⴻⵄⵡⴻⵜ, ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⴰⵖⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("S215_5","011_15_5","2SA","15","5","5","ⵎⴰⵍⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴱⴻⵏⴷⴻⵇ, ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵓⵛⴰ ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("S215_6","011_15_6","2SA","15","6","6","ⴰⵎⵎⵓ ⵉⴳⴳⴰ ⴰⴱⵛⴰⵍⵓⵎ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵉ ⵛⵛⵔⴻⵄ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⴰⵎⵎⵓ ⵢⵓⵛⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ ⵓⵍ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S215_7","011_15_7","2SA","15","7","7","ⴰⵡⴰⵔⵏⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ, ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵖ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵍⵡⴰⵄⴷ ⵉⵏⵓ ⵉ ⵡⴰⵄⴷⴻⵖ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S215_8","011_15_8","2SA","15","8","8","ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵓⵎⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵖ ⵄⴰⴷ ⴷⵉ ⵊⴰⵛⵓⵔ ⴷⵉ ⴰⵔⴰⵎ, ⵏⵏⵉⵖ: ‘ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵊⵊⴰ ⴰⵢⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴻⴷⵎⴻⵖ ⵉ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("S215_9","011_15_9","2SA","15","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ!” ⵉⴽⴽⴰⵔ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S215_10","011_15_10","2SA","15","10","10","ⴰⴱⵛⴰⵍⵓⵎ ⵎⴰⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉⵏ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵍⴰⵎ ⵉ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⴱⵛⴰⵍⵓⵎ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ.’” ");
INSERT INTO rift_vpl VALUES ("S215_11","011_15_11","2SA","15","11","11","ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵢⵓⵔⴻⵏ ⴰⴽ-ⴷ ⴰⴱⵛⴰⵍⵓⵎ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴷⵉ ⵍⴻⵀⵏⴰ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵅ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("S215_12","011_15_12","2SA","15","12","12","ⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ, ⵉⵙⵙⴻⴽⴽ ⴰⴱⵛⴰⵍⵓⵎ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴰⵅⵉⵜⵓⴼⵉⵍ, ⵣⵉ ⵊⵉⵍⵓ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵛⴰⵡⴰⵔ ⵏ ⴷⴰⵡⵓⴷ, ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵣⵉ ⵊⵉⵍⵓ. ⴰⵎⵎⵓ ⵉ ⵜⴻⴷⵡⴻⵍ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵜⵎⴻⵇⵇⴰⵔ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵍⴳⴻⵏⵙ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S215_13","011_15_13","2SA","15","13","13","ⵅⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵓⵍ ⵏ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⴷⵡⴻⵍ ⴰⴽ-ⴷ ⴰⴱⵛⴰⵍⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("S215_14","011_15_14","2SA","15","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ: “ⴽⴽⴰⵔⴻⵎ, ⴰⴷ ⵏⴰⵔⵡⴻⵍ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵖⴰⵔⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵊⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⴱⵛⴰⵍⵓⵎ. ⴷⴻⵖⵢⴰⵎ ⴷⴻⴳ ⵡⵓⴼⴼⵓⵖ ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⴻⴵⴻⴱ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⴰⵔⵜ, ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵉⴳⴳ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓⵛⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ.” ");
INSERT INTO rift_vpl VALUES ("S215_15","011_15_15","2SA","15","15","15","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S215_16","011_15_16","2SA","15","16","16","ⴰⵎⵎⵓ ⵉ ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ. ⴰⵊⴻⴵⵉⴷ ⵉⵊⵊⴰ ⵄⴻⵛⵔⴰ ⵏ ⵜⵉⵢⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏⵜ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S215_17","011_15_17","2SA","15","17","17","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ, ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("S215_18","011_15_18","2SA","15","18","18","ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵄⴷⵓⵏ ⵅⴰⵙ ⵓⵍⴰ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵏ ⵜⴰⵣⵍⴰ. ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵊⴰⵜ, ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ ⵣⵉ ⵊⴰⵜ, ⴰⵇⴰ ⴽⴽⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S215_19","011_15_19","2SA","15","19","19","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵜⵜⴰⵢ, ⵡⴻⵏⵏⵉ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵊⴰⵜ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⴷ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴽⵉⴷⵏⴻⵖ? ⵄⵇⴻⴱ ⵓ ⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⴰⵇⴰ ⵛⴻⴽ ⴱⴻⵄⴷⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S215_20","011_15_20","2SA","15","20","20","ⵉⴹⴻⵏⵏⴰⴹ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵛⴻⴽ. ⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵡⵢⴻⵖ ⴰⴽⵉⴷⵏⴻⵖ ⴰⵙⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ, ⵓⵎⵉ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ ⵏⴻⵛⵛ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵜⵜⵡⴰⵔⵉⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵍⴰⵃⴻⵖ. ⵄⵇⴻⴱ, ⴰⵡⵉ-ⴷⴷ ⴰⴽⵉⴷⴻⴽ ⴰⵢⵜⵎⴰⵛ. ⴰⴷ ⴽⵉⴷⴻⴽ ⵜⵉⵍⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S215_21","011_15_21","2SA","15","21","21","ⵎⴰⵛⴰ ⵉⵜⵜⴰⵢ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵎⴰ ⵉⵎⵎⵓⵜ ⵏⵉⵖ ⵉⴷⴷⴰⵔ, ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("S215_22","011_15_22","2SA","15","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵉⵜⵜⴰⵢ: “ⵓⵢⵓⵔ ⵅⴻⵏⵏⵉ, ⴻⴽⴽ-ⴷⴷ!” ⵉⴽⴽⴰ ⵅⴰⵙ ⵉⵜⵜⴰⵢ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵊⴰⵜ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S215_23","011_15_23","2SA","15","23","23","ⵎⴰⵔⵔⴰ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵔⵓ ⵓⵎⵉ ⵉⴽⴽⴰ ⵍⴳⴻⵏⵙ. ⴰⵊⴻⴵⵉⴷ ⵉⵥⵡⴰ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵥⵡⴰ, ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S215_24","011_15_24","2SA","15","24","24","ⴰⵇⴰ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵚⴰⴷⵓⵇ ⴷ ⵎⴰⵔⵔⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⴻⵙ. ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⴱⵢⴰⵜⴰⵔ ⵉⴳⴻⵄⵄⴻⴷ ⴷⵉⵏ ⴰⵍⴰⵎⵉ ⵉⵇⴼⴻⵍ ⵓⵄⴻⴷⴷⵓ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S215_25","011_15_25","2SA","15","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵚⴰⴷⵓⵇ: “ⴰⵔⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵢⴰⵔⵔ ⵖⴰⵔ ⴷⴰ, ⴰⴷ ⴰⵢⵉ ⵢⴰⵔⵔ ⴰⴷ ⵥⴰⵔⵖ ⵜⵜⴰⴱⵓⵜ ⵄⴰⵡⴻⴷ ⵓⵍⴰ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("S215_26","011_15_26","2SA","15","26","26","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵅ ⵍⵅⴰⴹⴰⵔ!’, ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴽⵉⴷⵉ ⵉⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S215_27","011_15_27","2SA","15","27","27","ⵢⴰⵔⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴻⴽ ⴷ ⴰⵎⵡⴰⵍⴰⵡ? ⵄⵇⴻⴱ ⴷⵉ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴽⵉⴷⵡⴻⵎ: ⵎⵎⵉⵛ ⴰⵅⵉⵎⴰⵄⴰⵚ, ⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵢⴰⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S215_28","011_15_28","2SA","15","28","28","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵊⵉⵖ ⴷⵉ ⵍⴻⵅⵍⴰ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⵥⴻⴽⴽⵡⴰⵏ ⵅ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵜⴻⴱⵔⴰⵜ ⵣⵣⴰⵢⵡⴻⵎ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("S215_29","011_15_29","2SA","15","29","29","ⵅⴰⵙ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵚⴰⴷⵓⵇ ⴰⴽ-ⴷ ⴰⴱⵢⴰⵜⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S215_30","011_15_30","2SA","15","30","30","ⴷⴰⵡⵓⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵜⴰⵙⴰⵡⴻⵏⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ. ⵉⵔⵓ ⴰⵎ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ. ⵜⵓⵖⴰ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵉⵔⴻⵃⵃⴻⴼ, ⵢⵓⵢⵓⵔ ⵅ ⵉⴹⴰⵔⴻⵏ ⵙ ⵍⴻⵃⴼⴰ. ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵣⴰⵢⴻⵙ ⵉⵔⴻⵃⵃⴻⴼ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ, ⵔⵓⵏ ⴰⵎ ⴳⴻⵄⵄⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S215_31","011_15_31","2SA","15","31","31","ⵅⴻⵏⵏⵉ ⵃⴰⵊⴰⵏ ⴰⵙ ⵉ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⴰⵅⵉⵜⵓⴼⵉⵍ ⵜⵓⵖⴰ-ⵜ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴰⴱⵛⴰⵍⵓⵎ.” ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⴰ ⵙⵉⴷⵉ, ⵙⴱⴻⵟⵟⴻⵍ ⵛⵛⵡⴰⵔ ⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S215_32","011_15_32","2SA","15","32","32","ⵍⴰⵎⵉ ⴷⴰⵡⵓⴷ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵎⴰⵏⵉ ⵜⵜⵏⵓⵎⴰⵏ ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵃⵓⵛⴰⵢ, ⴰⵢⴰⵔⴽⵉ, ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵛⴰⵔⵔⴳⴻⵏ ⵓ ⵙ ⵓⵛⴰⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S215_33","011_15_33","2SA","15","33","33","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵥⵡⵉⴷ ⴰⴽⵉⴷⵉ, ⴰⴷ ⵅⴰⴼⵉ ⵜⵉⵍⵉⴷ ⴷ ⴷⴷⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S215_34","011_15_34","2SA","15","34","34","ⵎⴰⵍⴰ ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵄⴻⵇⴱⴻⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⴰⴱⵛⴰⵍⵓⵎ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰ ⴰⵊⴻⴵⵉⴷ! ⵜⵓⵖⴰ ⴰⵢⵉ ⵣⵉⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴱⴰⴱⴰⵛ, ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ!’, ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴱⴻⴹⵍⴻⴷ ⵛⵛⵡⴰⵔ ⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S215_35","011_15_35","2SA","15","35","35","ⵎⴰ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ? ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⴷ ⵜⵄⴰⵡⴷⴻⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⵙⵍⴻⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S215_36","011_15_36","2SA","15","36","36","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴷⵉⵏⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⵅⵉⵎⴰⵄⴰⵚ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ, ⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵢⴰⵜⴰⵔ. ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⵙⵙⵉⵡⴹⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍ ⵉ ⵜⴻⵙⵍⵉⵎ ⵣⵣⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S215_37","011_15_37","2SA","15","37","37","ⵓⵛⴰ ⵃⵓⵛⴰⵢ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⴷⴰⵡⵓⴷ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴰⴱⵛⴰⵍⵓⵎ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S216_1","011_16_1","2SA","16","1","1","ⵓⵎⵉ ⵉⵄⴷⵓ ⴷⴰⵡⵓⴷ ⵛⵡⴰⵢⵜ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵉⴼⴼⴻⵖ ⵚⵉⴱⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵢⵓⵢⴰ ⵏ ⵢⴻⵖⵢⴰⵍ ⴱⴰⵔⴷⵄⴻⵏ, ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵖⵔⵓⵎⴻⵏ, ⵎⵢⴰ ⵏ ⵉⵖⵔⵓⵎⴻⵏ ⵏ ⵣⵣⴱⵉⴱ ⵓ ⵎⵢⴰ ⵏ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵢⴰⵔⵜ ⴷⴰⵢⴻⵙ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S216_2","011_16_2","2SA","16","2","2","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵚⵉⴱⴰ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵙ ⵓⵢⴰ?” ⵉⵏⵏⴰ ⵚⵉⴱⴰ: “ⵉⵖⵢⴰⵍ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵏⵢⴻⵏ, ⵓ ⴰⵖⵔⵓⵎ ⴷ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ, ⵓ ⴱⵉⵏⵓ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵃⵍⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S216_3","011_16_3","2SA","16","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵎⵎⵉⵙ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ?” ⵉⵏⵏⴰ ⵚⵉⴱⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⴰⵙⵙ-ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴰⵔⵔ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴱⴰⴱⴰ.’” ");
INSERT INTO rift_vpl VALUES ("S216_4","011_16_4","2SA","16","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵚⵉⴱⴰ: “ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵏⵏⴻⵛ!” ⵚⵉⴱⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴱⴻⵏⴷⵇⴻⵖ, ⵎⵍⵉ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("S216_5","011_16_5","2SA","16","5","5","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⴱⴰⵅⵓⵔⵉⵎ, ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵣⵉ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ. ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵔⴰ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⵓⵔ ⴰⵎ ⵉⵏⴻⵄⵄⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S216_6","011_16_6","2SA","16","6","6","ⵏⴻⵜⵜⴰ ⵉⵃⴻⵊⵊⴰⵔ ⴷⴰⵡⵓⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵙ ⵢⴻⵥⵔⴰ, ⴰⵎ ⵉⴱⴻⴷⴷ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⴷ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("S216_7","011_16_7","2SA","16","7","7","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵛⵉⵎⵄⵉ ⴰⵎ ⵜ ⵉⵏⴻⵄⵄⴻⵍ: “ⴰⴳⴳⵯⴻⵊ, ⴰⴳⴳⵯⴻⵊ, ⵛⴻⴽ, ⴰⵔⵢⴰⵣ ⵏ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵡⴻⵔⵢⴰⵣ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("S216_8","011_16_8","2SA","16","8","8","ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⴹ ⵅⴰⴽ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⵡⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵉ ⵜⵃⴻⴽⵎⴻⴷ. ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⵎⵉⵛ ⴰⴱⵛⴰⵍⵓⵎ. ⵅⵣⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵛ ⵓⵎⵉ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S216_9","011_16_9","2SA","16","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⵏⵄⴻⵍ ⵡⴻⵇⵣⵉⵏ-ⴰ ⵉⵎⵎⵓⵜⴻⵏ, ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ? ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴷⵉⵏ ⵥⵡⵉⵖ, ⴰⴷ ⴰⵙ ⵇⴻⵙⵙⴻⵖ ⴰⵣⴻⴵⵉⴼ.” ");
INSERT INTO rift_vpl VALUES ("S216_10","011_16_10","2SA","16","10","10","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⴽⴻⵏⵏⵉⵡ, ⴰⵔⵔⴰⵡ ⵏ ⵚⴰⵔⵓⵢⴰ? ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵄⴻⵍ, ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵏⵄⴻⵍ ⴷⴰⵡⵓⴷ!’ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ?’” ");
INSERT INTO rift_vpl VALUES ("S216_11","011_16_11","2SA","16","11","11","ⴷⴰⵡⵓⴷ ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ ⵉ ⴰⴱⵉⵛⴰⵢ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔⴻⵎ, ⵎⵎⵉ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⴷⴷⴰⵜ ⵉⵏⵓ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ. ⵎⴰⵀⵓ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⵔⵢⴰⵣ-ⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ? ⵊⵊⴻⵎ ⵜ ⴰⴷ ⵉⵏⵄⴻⵍ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉ ⴷ ⴰⵙ ⵜ ⵉⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S216_12","011_16_12","2SA","16","12","12","ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵍⴰ ⵜⴰⵎⴰⵔⴰ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⴻⵙ ⵏ ⵡⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("S216_13","011_16_13","2SA","16","13","13","ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵓ ⵛⵉⵎⵄⵉ ⵢⵓⵢⵓⵔ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵡⵔⵉⵔⵜ, ⴰⵎ ⵉⵏⴻⵄⵄⴻⵍ ⵓ ⵉⵜⵜⵃⴻⵊⵊⴰⵔ ⴷⴰⵡⵓⴷ ⵙ ⵢⴻⵥⵔⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⴰⴷ ⵜⴹⵓⵡ. ");
INSERT INTO rift_vpl VALUES ("S216_14","011_16_14","2SA","16","14","14","ⵢⵉⵡⴻⴹ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴰⵢⴰⴼⵉⵎ. ⴷⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵔ ⵏⵏⴻⴼⵙ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S216_15","011_16_15","2SA","16","15","15","ⴰⴱⵛⴰⵍⵓⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴰⵅⵉⵜⵓⴼⵉⵍ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S216_16","011_16_16","2SA","16","16","16","ⵓⵎⵉ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵃⵓⵛⴰⵢ, ⴰⵢⴰⵔⴽⵉ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⴷⴰⵡⵓⴷ, ⵖⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵃⵓⵛⴰⵢ ⵉⵏⵏⴰ ⵉ ⴰⴱⵛⴰⵍⵓⵎ: “ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("S216_17","011_16_17","2SA","16","17","17","ⴰⴱⵛⴰⵍⵓⵎ ⵉⵏⵏⴰ ⵉ ⵃⵓⵛⴰⵢ: “ⵎⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵅⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵙⵛⴰⵏ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ? ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵔⵉⵃⴻⴷ ⴰⴽ-ⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("S216_18","011_16_18","2SA","16","18","18","ⵃⵓⵛⴰⵢ ⵉⵏⵏⴰ ⵉ ⴰⴱⵛⴰⵍⵓⵎ: “ⵍⵍⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⵇⵇⵉⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("S216_19","011_16_19","2SA","16","19","19","ⵉ ⵓⵎⵉ ⵖⴰ ⵙⴻⵅⵅⴰⵔⴻⵖ ⵅⴻⵏⵏⵉ? ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵎⵉⵙ? ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵅⴻⴷⵎⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱⴰⵛ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵍⵉⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S216_20","011_16_20","2SA","16","20","20","ⴰⴱⵛⴰⵍⵓⵎ ⵉⵏⵏⴰ ⵉ ⴰⵅⵉⵜⵓⴼⵉⵍ: “ⵡⵛⴻⵎ ⴰⵏⴻⵖ ⵛⵛⵡⴰⵔ, ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ?” ");
INSERT INTO rift_vpl VALUES ("S216_21","011_16_21","2SA","16","21","21","ⴰⵅⵉⵜⵓⴼⵉⵍ ⵉⵏⵏⴰ ⵉ ⴰⴱⵛⴰⵍⵓⵎ: “ⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵉⵢⵢⴰ ⵏ ⴱⴰⴱⴰⵛ ⵜⵉⵏⵏⵉ ⵉⵊⵊⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⴰⵏⵜ ⵜⴰⴷⴷⴰⵔⵜ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵙⴻⵍ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴰⵔⵣⴳⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵖⴰⵔ ⴱⴰⴱⴰⵛ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⴵⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S216_22","011_16_22","2SA","16","22","22","ⵡⵜⵉⵏ ⵉ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵛⵜ ⵏ ⵜⵇⵉⴹⵓⵏⵜ ⵅ ⵜⵣⴻⵇⵇⴰ ⵓ ⴰⴱⵛⴰⵍⵓⵎ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⵉⵢⵢⴰ ⵏ ⴱⴰⴱⴰⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S216_23","011_16_23","2SA","16","23","23","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵛⵛⵡⴰⵔ ⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ ⴰⵅⵎⵉ ⵉⵊⵊⴻⵏ ⵢⴰⵔⴻⵣⵣⵓ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵙ ⵎⴰⵔⵔⴰ ⵛⵛⵡⴰⵔ ⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ, ⴰⵎ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴰⵎ ⵖⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S217_1","011_17_1","2SA","17","1","1","ⴰⵅⵉⵜⵓⴼⵉⵍ ⵉⵏⵏⴰ ⵉ ⴰⴱⵛⴰⵍⵓⵎ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴼⴰⵔⵣⴻⵖ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵖ ⴷⴰⵡⵓⴷ ⴵⵉⵍⴻⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("S217_2","011_17_2","2SA","17","2","2","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⵀⴻⵊⵎⴻⵖ, ⵎⵉⵏⵜⵔⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵄⴰⴷ ⵓⵃⵍⴻⵏ ⵓ ⴹⴻⵄⴼⴻⵏ. ⴰⴷ ⵜ ⵙⵙⵉⴳⴳⵯⵉⴷⴻⵖ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴰⴷ ⵢⴰⵔⵡⴻⵍ. ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵏⵖⴻⵖ ⴰⵊⴻⴵⵉⴷ, ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("S217_3","011_17_3","2SA","17","3","3","ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ⵍⵎⴻⵡⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵅ ⵜⴰⵔⴻⵣⵣⵓⴷ ⴰⵇⴰ-ⵜ ⴰⵎ ⵡⴻⴷⵡⴰⵍ ⵏ ⵢⴻⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ, ⵍⴳⴻⵏⵙ ⴰⴷ ⵜ ⵉⵇⴱⴻⵍ, ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("S217_4","011_17_4","2SA","17","4","4","ⵜⵓⵖⴰ ⴰⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⴱⵛⴰⵍⵓⵎ ⵓ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S217_5","011_17_5","2SA","17","5","5","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⴱⵛⴰⵍⵓⵎ: “ⵍⴰⵖⴰⵜ ⵓⵍⴰ ⵉ ⵃⵓⵛⴰⵢ, ⴰⵢⴰⵔⴽⵉ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵙ ⵏⵙⴻⵍ ⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵖⴰ ⵢⵉⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("S217_6","011_17_6","2SA","17","6","6","ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵃⵓⵛⴰⵢ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴱⵛⴰⵍⵓⵎ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵅⵉⵜⵓⴼⵉⵍ. ⵎⴰ ⴰⴷ ⵏⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵙ? ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⵎⵓ, ⵅⴻⵏⵏⵉ ⵙⵉⵡⴻⵍ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("S217_7","011_17_7","2SA","17","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵃⵓⵛⴰⵢ ⵉ ⴰⴱⵛⴰⵍⵓⵎ: “ⵜⵡⴰⵍⴰⵜ-ⴰ ⵛⵛⵡⴰⵔ ⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ ⵡⴰⵔ ⵉⴵⵉ ⵎⵍⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("S217_8","011_17_8","2SA","17","8","8","ⵢⴰⵔⵏⵉ ⵃⵓⵛⴰⵢ ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ, ⵏⵉⵜⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵓ ⴰⵇⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵢⴰⵔⵣⴻⴳ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴷⴷⵓⴱ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵛⴰⵔ ⵡⴻⵏⵊⵓⵖ. ⴱⴰⴱⴰⵛ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵄⴻⵙⴽⴰⵔⵉ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵏⵓⵙⵉ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S217_9","011_17_9","2SA","17","9","9","ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵉⵏⵏⵓⴼⴼⴰⵔ ⴷⴻⴳ ⵉⵊⵊ ⵣⴻⴳ ⵉⴼⵔⴰⵏ ⵏⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵜⵏⵓⴼⴼⵔⴰ. ⵎⴰⵍⴰ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵡⴹⴰⵏ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜ ⵖⴰ ⵉⵙⵍⴻⵏ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴹⴼⴰⵔⴻⵏ ⴰⴱⵛⴰⵍⵓⵎ.’ ");
INSERT INTO rift_vpl VALUES ("S217_10","011_17_10","2SA","17","10","10","ⵅⴻⵏⵏⵉ ⵄⴰⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵡⴻⵏⵏⵉ ⵓⵍ ⵏⵏⴻⵙ ⴰⵎ ⵡⵓⵍ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ, ⴰⴷ ⵉⴼⵛⴻⵍ ⴷⴻⵖⵢⴰ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⴱⴰⴱⴰⵛ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵍⵓⴹⵜ ⵓ ⵖⴰⵔⴻⵙ ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S217_11","011_17_11","2SA","17","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⴷⴻⵖⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓ ⵛⴻⴽ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S217_12","011_17_12","2SA","17","12","12","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵅⴰⵙ ⵏⴻⵀⵊⴻⵎ ⴷⴻⴳ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵜⵏⵓⴼⴼⵔⴰ ⵎⴰⵏⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼ. ⴰⴷ ⵅⴰⵙ ⵏⴻⵀⵊⴻⵎ ⴰⵎ ⵉⵡⴻⵟⵟⴰ ⵏⵏⴷⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S217_13","011_17_13","2SA","17","13","13","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵛⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵙⴻⵖⵡⴰⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⴰⴷ ⵜⵜ ⵏⵊⴰⵔⵔ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("S217_14","011_17_14","2SA","17","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⴱⵛⴰⵍⵓⵎ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵛⵛⵡⴰⵔ ⵏ ⴰⵢⴰⵔⴽⵉ ⵃⵓⵛⴰⵢ ⵉⵃⵍⴰ ⵅ ⵛⵛⵡⴰⵔ ⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ.” ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⴰⴷ ⴱⴻⴹⵍⴻⵏ ⵛⵛⵡⴰⵔ ⵍⴻⵎⵍⵉⵃ ⵏ ⴰⵅⵉⵜⵓⴼⵉⵍ, ⵃⵉⵎⴰ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵡⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵅ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S217_15","011_17_15","2SA","17","15","15","ⵉⵏⵏⴰ ⵃⵓⵛⴰⵢ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ: “ⵜⴰ ⴷ ⵜⴰ ⵉⵛⴰⵡⴰⵔ ⴰⵅⵉⵜⵓⴼⵉⵍ ⵉ ⴰⴱⵛⴰⵍⵓⵎ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⴷ ⵜⴰ ⴷ ⵜⴰ ⵉⵅⴻⴼ ⵡⴻⵚⵚⵉⵖ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("S217_16","011_17_16","2SA","17","16","16","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⴽⴽ ⴷⴻⵖⵢⴰ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⴻⴱⴱⴰⵔ ⵉ ⴷⴰⵡⵓⴷ, ⴰⴷ ⵢⵉⵏⵉ: “ⵡⴰⵔ ⵙⴻⵏⵙ ⴵⵉⵍⴻⵜ-ⴰ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵍⴻⵅⵍⴰ. ⵥⵡⴰ ⴷⴻⵖⵢⴰ, ⵏⵉⵖ ⴰⴷ ⵉⵜⵜⵡⴰⵚⴰⵔⴹ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S217_17","011_17_17","2SA","17","17","17","ⵎⴰⵛⴰ ⵢⵓⵏⴰⵜⴰⵏ ⴷ ⴰⵅⵉⵎⴰⵄⴰⵚ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵔⵓⵊⴰⵍ. ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ ⵜⵓⵢⵓⵔ ⴷⵉⵏⵏⵉ, ⵜⵃⴰⵊⴰ ⴰⵙⴻⵏ ⵜⵜ. ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵓ ⵃⴰⵊⴰⵏ ⵜⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵎⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⴻⵏ ⵥⴰⵔⵔⴻⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S217_18","011_17_18","2SA","17","18","18","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵥⵔⴰ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵃⴰⵊⴰ ⵜ ⵉ ⴰⴱⵛⴰⵍⵓⵎ. ⵎⴰⵛⴰ ⵉⵏⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵓⵣⵣⵍⴻⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⴱⴰⵅⵓⵔⵉⵎ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ ⴷⵉ ⵍⴻⵎⵔⴰⵃ. ⵏⵉⵜⵏⵉ ⴹⵔⵉⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S217_19","011_17_19","2SA","17","19","19","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⴽⵙⵉ ⵜⴰⵣⴰⵔⴱⴻⵍⵜ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵏⵓ ⵓⵛⴰ ⵜⴰⵔⴻⵢⵢⴻⵛ ⵅⴰⵙ ⵉⵡⵣⴰⵏ ⵉ ⵉⵜⵜⵡⴰⵇⴻⵛⵛⴰⵔⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ⴰⵎⵎⵓ ⵉ ⵡⴰⵔ ⴷⴷ-ⵜⴱⵉⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("S217_20","011_17_20","2SA","17","20","20","ⵍⴰⵎⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⴱⵛⴰⵍⵓⵎ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵙⵙⴻⵇⵙⴰⵏ ⵜⵜ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵅⵉⵎⴰⵄⴰⵚ ⴷ ⵢⵓⵏⴰⵜⴰⵏ?” ⵜⴰⵎⵖⴰⵔⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵜⵉⵖⵣⴰⵔⵜ ⵏⵏⵉ.” ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ, ⴰⵔⵣⵓⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵓⴼⵉⵏ. ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S217_21","011_17_21","2SA","17","21","21","ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ, ⵉⵎⵙⴰⵔ, ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵣⴻⴳ ⵡⴰⵏⵓ, ⵓⵢⵓⵔⴻⵏ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ. ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉ ⴷⴰⵡⵓⴷ: “ⴽⴽⴰⵔⴻⵎ, ⵥⵡⴰⵎ ⴰⵎⴰⵏ ⴷⴻⵖⵢⴰ, ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵜⴰ ⴷ ⵛⵛⵡⴰⵔ ⵉ ⵅⴰⵡⴻⵎ ⵉⴳⴳⴰ ⴰⵅⵉⵜⵓⴼⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S217_22","011_17_22","2SA","17","22","22","ⵉⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵍ’ⵓⵔⴷⵓⵏ. ⵖⴰⵔ ⵜⴼⴰⵡⵜ ⵏ ⵜⵓⴼⴼⵓⵜ ⵏ ⵡⴰⵙⵙ, ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵥⵡⵉ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S217_23","011_17_23","2SA","17","23","23","ⵓⵎⵉ ⴰⵅⵉⵜⵓⴼⵉⵍ ⵉⵥⵔⴰ, ⴰⵇⴰ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴱⴻⵟⵟⴻⵍ, ⵉⴱⴰⵔⴷⴻⵄ ⵏⴻⵜⵜⴰ ⵉ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ, ⵉⴽⴽⴰⵔ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵢⵓⵢⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵉⵎⵎⵓⵜ ⵓ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S217_24","011_17_24","2SA","17","24","24","ⴷⴰⵡⵓⴷ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ, ⵓ ⴰⴱⵛⴰⵍⵓⵎ ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S217_25","011_17_25","2SA","17","25","25","ⴰⴱⵛⴰⵍⵓⵎ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵄⴰⵎⴰⵙⴰ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⵓⵡⴰⴱ. ⵄⴰⵎⴰⵙⴰ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵉⵜⵔⴰ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⴷⴼⴻⵏ ⵅ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵏⴰⵃⴰⵛ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⵓⵡⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("S217_26","011_17_26","2SA","17","26","26","ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⴱⵛⴰⵍⵓⵎ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("S217_27","011_17_27","2SA","17","27","27","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵛⵓⴱⵉ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⴰⵛ, ⵣⵉ ⵔⴰⴱⴱⴰ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴷ ⵎⴰⵅⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵢⵉⵍ ⵣⵉ ⵍⵓ-ⴷⴰⴱⴰⵔ, ⴷ ⴱⴰⵔⵣⵉⵍⴰⵢ, ⴰⵊⵉⵍⵄⴰⴷⵉ ⵣⵉ ⵔⵓⵊⴰⵍⵉⵎ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("S217_28","011_17_28","2SA","17","28","28","ⵉⴼⴰⵔⵔⴰⵛⴻⵏ ⴷ ⵟⵟⴱⴰⵚⵉ ⴷ ⵉⵇⴷⵉⵃⴻⵏ ⵏ ⵜⵍⴰⵅⵜ ⴷ ⵉⵔⴷⴻⵏ ⴷ ⵉⵎⴻⵏⴷⵉ ⴷ ⵡⴰⵔⴻⵏ, ⴰⵇⴰ ⵍⴻⵃⴱⵓⴱ ⵇⵍⴰⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⴱⴰⵡⴻⵏ ⴷ ⵍⴻⵄⴷⴻⵙ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵇⵍⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("S217_29","011_17_29","2SA","17","29","29","ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⴷ ⴷⴷⵀⴻⵏ ⴷ ⵡⵓⴵⵉ ⴷ ⵜⵔⵓⵙⵙⵉ ⵏ ⵜⴼⵓⵏⴰⵙⵉⵏ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⵛⴻⵏ. ⵎⴰⵖⴰⵔ ⵏⵏⴰⵏ: “ⵍⴳⴻⵏⵙ ⵉⴵⵓⵥ, ⵉⵀⴻⵢⵢⴻⴼ, ⵉⴼⴼⵓⴷ ⴷⵉⵏ ⴷⵉ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("S218_1","011_18_1","2SA","18","1","1","ⵉⵙⴻⴷⴷ ⴷⴰⵡⵓⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵓ ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("S218_2","011_18_2","2SA","18","2","2","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵍⴳⴻⵏⵙ. ⵉⵛⵜ ⵏ ⵜⵓⵍⵓⵜ ⵣⵣⴰⵢⵙⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵢⵓⵡⴰⴱ, ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵓⵎⴰⵙ ⵏ ⵢⵓⵡⴰⴱ, ⴷ ⵉⵛⵜ ⵏ ⵜⵓⵍⵓⵜ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏ ⵉⵜⵜⴰⵢ, ⵣⵉ ⵊⴰⵜ. ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵍⴳⴻⵏⵙ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("S218_3","011_18_3","2SA","18","3","3","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵜⴻⴼⴼⵖⴻⴹ ⵛⴰ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵡⴻⵍ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵍⴻⵀⵀⵉⵏ. ⵎⴰⵍⴰ ⴰⵣⵢⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵎⵎⵓⵜ, ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵍⴻⵀⵀⵉⵏ. ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵍⴻⵅⵅⵓ ⵜⵙⴻⴽⴽⵡⵯⵉⴷ ⴰⵎ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵣⵣⴰⵢⵏⴻⵖ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵎⵍⵉⵀ, ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵛⴻⴷ ⴰⴼⵓⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("S218_4","011_18_4","2SA","18","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ: “ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ!” ⴰⵊⴻⴵⵉⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⵙ ⵍⵎⵢⴰⵡⴰⵜ ⴷ ⵍⵓⵍⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("S218_5","011_18_5","2SA","18","5","5","ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⵓⵡⴰⴱ, ⴰⴱⵉⵛⴰⵢ ⴷ ⵉⵜⵜⴰⵢ: “ⴻⴳⴳ ⵙ ⵓⵃⴰⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵃⵓⴷⵔⵉ, ⴰⴽ-ⴷ ⴰⴱⵛⴰⵍⵓⵎ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ.” ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵍⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵢⵓⵎⵓⵔ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("S218_6","011_18_6","2SA","18","6","6","ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵉⵢⵢⴰⵔ, ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⴰⵎⴻⵏⵖⵉ ⵉⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S218_7","011_18_7","2SA","18","7","7","ⵜⵜⵡⴰⵖⴻⵍⵍⴱⴻⵏ ⴷⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⴻⵎⵙⴰⵔ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵍⴰⵎⵉ ⵡⴹⴰⵏ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S218_8","011_18_8","2SA","18","8","8","ⴰⵎⴻⵏⵖⵉ ⵉⴼⴼⴻⵖ ⵙⵙⴻⵏⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵙⴰⵔⴹ ⵡⴻⵣⵖⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵙⴰⵔⴹ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("S218_9","011_18_9","2SA","18","9","9","ⵉⵎⵙⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ ⵉⴱⴻⴷⴷ ⵜⵉⵟⵟ ⴷⵉ ⵜⵉⵟⵟ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ⴰⴱⵛⴰⵍⵓⵎ ⵉⵏⵢⴰ ⵅ ⵉⵊⵊ ⵏ ⵓⵙⴻⵔⴷⵓⵏ. ⵓⵎⵉ ⴰⵙⴻⵔⴷⵓⵏ ⵢⵓⵢⵓⵔ ⵙⴰⴷⵓ ⵍⴻⴼⵔⵓⵄ ⵉⵎⵛⵓⴱⴱⵛⴻⵏ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵏⵏⵓⵖ ⵏⴻⵜⵜⴰ ⵙ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⴰⵍⴰⵎⵉ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴻⵏⵏⵓⵢⴻⵍ ⵊⴰⵔ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵙⴻⵔⴷⵓⵏ ⵢⵓⵢⵓⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S218_10","011_18_10","2SA","18","10","10","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵥⵔⴰ ⵉ-ⵜ, ⵉⵃⴰⵊⴰ ⵜ ⵉ ⵢⵓⵡⴰⴱ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴰⴱⵛⴰⵍⵓⵎ ⵢⵓⵢⴻⵍ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("S218_11","011_18_11","2SA","18","11","11","ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉ ⴷ ⴰⵙ ⵉⵃⴰⵊⴰⵏ ⴰⵢⴰ: “ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜ ⵜⴻⵥⵡⵉⴹⴻⴷ ⵛⴰ ⴷⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ? ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵄⴻⵛⵔⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("S218_12","011_18_12","2SA","18","12","12","ⵉⵏⵏⴰ ⵡⴻⵔⵢⴰⵣ ⵉ ⵢⵓⵡⴰⴱ: “ⵡⴰⵔ ⵡⴻⵣⵣⵏⴻⵖ ⵓⵍⴰ ⴷ ⴰⵍⴻⴼ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵙⵙⵡⵉⵥⵥⵉⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵢⵓⵎⵓⵔ ⵉ ⵛⴻⴽ ⴷ ⴰⴱⵉⵛⴰⵢ ⴷ ⵉⵜⵜⴰⵢ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: ‘ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵃⴹⴰ ⵅ ⵓⵃⵓⴹⵔⵉ ⴰⴱⵛⴰⵍⵓⵎ!’ ");
INSERT INTO rift_vpl VALUES ("S218_13","011_18_13","2SA","18","13","13","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵙ ⵍⵖⴻⵛⵛ ⴰⴽ-ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ - ⴰⵇⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⵅⴻⵎⵎⴻⵍ - ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⴽⴽⴰⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("S218_14","011_18_14","2SA","18","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⵔⴰⵊⵉⵖ.” ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴰⵏⵙⴰⵜ, ⵉⵊⵊⵓ ⴰⵙ ⵜⴻⵏⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⴰⴱⵛⴰⵍⵓⵎ, ⴰⵎ ⵏⴻⵜⵜⴰ ⵄⴰⴷ ⵢⵓⵢⴻⵍ ⵉⴷⴷⴰⵔ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("S218_15","011_18_15","2SA","18","15","15","ⵄⴻⵛⵔⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵙⵏⴰⵃ ⵉ ⵢⵓⵡⴰⴱ, ⵏⵏⴹⴻⵏ ⴰⵙ ⵓⵛⴰ ⵡⵜⵉⵏ ⴰⴱⵛⴰⵍⵓⵎ, ⵏⵖⵉⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("S218_16","011_18_16","2SA","18","16","16","ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵢⵓⵡⴰⴱ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵢⵓⵡⴰⴱ ⵉⵅⵙ ⴰⴷ ⵉⵃⴰⵡⴻⵍ ⵅ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("S218_17","011_18_17","2SA","18","17","17","ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⴰⴱⵛⴰⵍⵓⵎ, ⵏⴹⴰⵔⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵜⵓⴵⴻⵖ ⵓ ⵙⵙⴰⵔⴱⵓⵏ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵢⴻⵥⵔⴰ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵟⵟⴻⴼ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S218_18","011_18_18","2SA","18","18","18","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴷⴷⴰⵔ, ⵉⴽⵙⵉ ⴰⴱⵛⴰⵍⵓⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⴰⵢⴹⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵎⵎⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵄⵇⴻⵍ ⵉⵙⴻⵎ ⵉⵏⵓ.” ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵉ ⵓⵎⴰⵢⴹⵓ ⵏⵏⵉ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⴰⵍ ⴰⵙⵙ-ⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵓⵎⴰⵢⴹⵓ ⵏⵏⵉ ‘ⴰⴼⵓⵙ ⵏ ⴰⴱⵛⴰⵍⵓⵎ’. ");
INSERT INTO rift_vpl VALUES ("S218_19","011_18_19","2SA","18","19","19","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵅⵉⵎⴰⵄⴰⵚ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵣⵣⵍⴻⵖ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⴰⵙ ⵙⵙⵉⵡⴹⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵃⴹⴰ ⵜ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("S218_20","011_18_20","2SA","18","20","20","ⵎⴰⵛⴰ ⵢⵓⵡⴰⴱ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵙⵙ-ⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⵛⴰ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏⵏⴻⵖⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ⴰⵙⵙ-ⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⴰⵔⴻⵇⵇⴰⵙ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵎⴰⵖⴰⵔ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵎⵎⵓⵜ.” ");
INSERT INTO rift_vpl VALUES ("S218_21","011_18_21","2SA","18","21","21","ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ ⵉ ⵓⴽⵓⵛⵉ: “ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏ ⵜⴻⵥⵔⵉⴷ ⵛⴻⴽ!” ⴰⴽⵓⵛⵉ ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵢⵓⵡⴰⴱ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵣⵣⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S218_22","011_18_22","2SA","18","22","22","ⵅⴻⵏⵏⵉ ⴰⵅⵉⵎⴰⵄⴰⵚ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ, ⵉⵏⵏⴰ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵉ ⵢⵓⵡⴰⴱ: “ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⵉ ⵉⵅⵙⴻⵏ, ⴻⵊⵊ ⴰⵢⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵣⵣⵍⴻⵖ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⴽⵓⵛⵉ!” ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⴷ ⵄⴰⴷ ⴰⴷ ⵜⴰⵣⵣⵍⴻⴷ, ⴰ ⵎⵎⵉ? ⵡⴰⵔ ⵉⵜⵜⵡⴰⴼ ⵄⴰⴷ ⴰⵔⴻⵇⵇⴰⵙ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵛⴻⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("S218_23","011_18_23","2SA","18","23","23","ⵉⵏⵏⴰ: “ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⵉ ⵉⵅⵙⴻⵏ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴷⵉⵏ ⴰⵣⵣⵍⴻⵖ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵢⵓⵡⴰⴱ: “ⴰⵣⵣⴻⵍ!” ⵓⵛⴰ ⴰⵅⵉⵎⴰⵄⴰⵚ ⵢⵓⵣⵣⴻⵍ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵉⵣⵣⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴽⵓⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("S218_24","011_18_24","2SA","18","24","24","ⴷⴰⵡⵓⴷ ⵉⵇⵇⵉⵎ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵄⴻⵙⵙⴰⵙ ⵉⴳⴻⵄⵄⴻⴷ ⵜⴰⵣⴻⵇⵇⴰ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵃⵉⴹ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵛⴻⵢⵢⴻⵄ, ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⴰⵣⵣⴻⵍ, ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S218_25","011_18_25","2SA","18","25","25","ⴰⵄⴻⵙⵙⴰⵙ ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ ⵉ-ⵜⵜ ⵉ ⵓⵊⴻⴵⵉⴷ. ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵡⴻⴹ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴷ ⴰⵚⴻⴱⵃⴰⵏ!” ⵢⴰⵔⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("S218_26","011_18_26","2SA","18","26","26","ⵅⴻⵏⵏⵉ ⵉⵥⵔⴰ ⵓⵄⴻⵙⵙⴰⵙ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵓⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⵜⵜⴰⵣⵣⴻⵍ ⴷⵉⵏ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ.” ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⴻⴹ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴷ ⴰⵚⴻⴱⵃⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S218_27","011_18_27","2SA","18","27","27","ⴰⵄⴻⵙⵙⴰⵙ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⴳⴳⵓⵔ ⴰⵎ ⴰⵅⵉⵎⴰⵄⴰⵚ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ.” ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵡⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵚⴱⴻⵃ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⴷ ⴰⵚⴻⴱⵃⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S218_28","011_18_28","2SA","18","28","28","ⴰⵅⵉⵎⴰⵄⴰⵚ ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵍⴻⵀⵏⴰ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵉⵙⴻⵍⵍⵎⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴳⴻⵄⵄⴷⴻⵏ ⴰⴼⵓⵙ ⵏⵙⴻⵏ ⵅ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S218_29","011_18_29","2SA","18","29","29","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰ ⴰⵃⵓⴷⵔⵉ, ⴰⴱⵛⴰⵍⵓⵎ, ⴰⵇⴰ-ⵜ ⵎⵍⵉⵃ?” ⵉⵏⵏⴰ ⴰⵅⵉⵎⴰⵄⴰⵚ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵎⵉ ⵢⵓⵡⴰⴱ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵙⵙⴻⴽⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S218_30","011_18_30","2SA","18","30","30","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵃⴻⵢⵢⴻⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⴱⴻⴷⴷ ⴷⴰ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S218_31","011_18_31","2SA","18","31","31","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵓⵍⴰ ⴷ ⴰⴽⵓⵛⵉ. ⴰⴽⵓⵛⵉ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ. ⵙⵉⴷⵉ ⵉⵃⴹⴰ ⵛⴻⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵖⴻⵡⵡⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S218_32","011_18_32","2SA","18","32","32","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵓⴽⵓⵛⵉ: “ⵎⴰ ⴰⵃⵓⴷⵔⵉ, ⴰⴱⵛⴰⵍⵓⵎ, ⴰⵇⴰ-ⵜ ⵎⵍⵉⵃ?” ⵉⵏⵏⴰ ⵓⴽⵓⵛⵉ: “ⵉⵍⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴰⵎ ⵓⵃⵓⴹⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("S219_1","011_19_1","2SA","19","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵓⵊⴻⴵⵉⴷ ⴰⵟⵟⴰⵙ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵡⴰⵔⵜ, ⵉⵔⵓ. ⵓⵛⴰ ⴰⵎ ⵉⴽⴽⴰ ⵙⵙⴰ ⴷ ⵙⵙⴰ, ⵉⵏⵏⴰ ⴰⵎⵎⵓ: “ⴰ ⵎⵎⵉ ⴰⴱⵛⴰⵍⵓⵎ, ⴰ ⵎⵎⵉ, ⴰ ⵎⵎⵉ ⴰⴱⵛⴰⵍⵓⵎ! ⵉⵍⵉ ⵏⴻⵛⵛ ⵎⵎⵓⵜⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ, ⴰ ⴰⴱⵛⴰⵍⵓⵎ, ⴰ ⵎⵎⵉ, ⴰ ⵎⵎⵉ!” ");
INSERT INTO rift_vpl VALUES ("S219_2","011_19_2","2SA","19","2","2","ⵏⵏⴰⵏ ⵉ ⵢⵓⵡⴰⴱ: “ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵉⵜⵜⵔⵓ, ⵉⵜⵜⴻⵛⴹⵉⵏ ⵅ ⴰⴱⵛⴰⵍⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("S219_3","011_19_3","2SA","19","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵙⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ: “ⴰⵊⴻⴵⵉⴷ ⵉⵛⴹⴻⵏ ⵅ ⵎⵎⵉⵙ.” ");
INSERT INTO rift_vpl VALUES ("S219_4","011_19_4","2SA","19","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵃⴰⵎⴰ ⵍⴳⴻⵏⵙ ⵉ ⵉⵜⵜⵙⴻⴹⵃⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵅⵎⵉ ⵜⵜⴰⵔⴻⴽⴽⵯⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S219_5","011_19_5","2SA","19","5","5","ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵍⴻⵃⵃⴻⴼ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵉⵜⵜⵍⴰⵖⴰ ⵓⵊⴻⴵⵉⴷ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ: “ⴰ ⵎⵎⵉ ⴰⴱⵛⴰⵍⵓⵎ, ⴰⴱⵛⴰⵍⵓⵎ, ⴰ ⵎⵎⵉ, ⴰ ⵎⵎⵉ!” ");
INSERT INTO rift_vpl VALUES ("S219_6","011_19_6","2SA","19","6","6","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵢⵓⵡⴰⴱ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵏⵏⴰ: “ⵛⴻⴽ ⴰⵙⵙ-ⴰ ⵜⴻⵙⵙⵃⴻⵛⵎⴻⴷ ⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴻⴽⴽⴻⵏ ⴰⵙⵙ-ⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("S219_7","011_19_7","2SA","19","7","7","ⵓⵎⵉ ⵜⴻⵅⵙⴻⴷ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⵄⵉⴼⴼⴻⵏ ⵓ ⵓⵎⵉ ⵜⵄⵉⴼⴼⴻⴷ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⵅⵙⴻⵏ. ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵏⴻⵖ ⴰⵙⵙ-ⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵏ, ⴰⵇⴰ ⵖⴰⵔⴻⴽ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵡⴰⵔ ⵙⴻⴽⴽⵡⵉⵏ ⵡⴰⵍⵓ. ⵉⵡⴰ ⴰⵙⵙ-ⴰ ⵙⵙⵏⴻⵖ, ⵎⴰⵍⴰ ⴰⴱⵛⴰⵍⵓⵎ ⵉⴷⴷⴰⵔ ⵓ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⵏⴻⵎⵎⵓⵜ, ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S219_8","011_19_8","2SA","19","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴽⴽⴰⵔ, ⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵊⵊⴰⴵⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵍⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴼⴼⵉⵖⴻⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵅⴻⵏⵏⵉ ⴵⵉⵍⴻⵜ-ⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵙⵙⴻⵏⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵀⵓ ⵉ ⵛⴻⴽ ⵅ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵛⴻⴽ ⵉⵍⴻⵇⴼⴻⵏ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ ⴰⵍ ⵉⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("S219_9","011_19_9","2SA","19","9","9","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵓ ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ.” ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵎⴰⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⵡⴻⵍ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S219_10","011_19_10","2SA","19","10","10","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⴻⵛ, ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵍⴻⵅⵅⵓ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴰⴱⵛⴰⵍⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("S219_11","011_19_11","2SA","19","11","11","ⵓⵎⵉ ⴰⴱⵛⴰⵍⵓⵎ, ⵡⴻⵏⵏⵉ ⵏⴻⴷⵀⴻⵏ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵏⴻⵖ, ⵉⵎⵎⵓⵜ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⵓⵙⵎⴻⵎ ⴰⵎⵎⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⴻⵎ ⴰⵊⴻⴵⵉⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴷⴰ?” ");
INSERT INTO rift_vpl VALUES ("S219_12","011_19_12","2SA","19","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ, ⵉⵏⵏⴰ: “ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵔⴻⵎ ⴰⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ?’ - ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ - ");
INSERT INTO rift_vpl VALUES ("S219_13","011_19_13","2SA","19","13","13","‘ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⴷ ⵡⴻⵢⵙⵓⵎ ⵉⵏⵓ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⵎ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵉ ⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⴰⵊⴻⴵⵉⴷ?’ ");
INSERT INTO rift_vpl VALUES ("S219_14","011_19_14","2SA","19","14","14","ⵓⵛⴰ ⵉ ⵄⴰⵎⴰⵙⴰ ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ: ‘ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴻⴽ ⴷ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⴷ ⴰⵢⵙⵓⵎ ⵉⵏⵓ? ⴻⵊⵊ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵜⴰ ⴷ ⵜⴰ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⵓⵡⴰⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("S219_15","011_19_15","2SA","19","15","15","ⴰⵎⵎⵓ ⵉⵣⴻⵎⵎⴰⵔ ⴷⴰⵡⵓⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵊⴱⴻⴷⴷ ⵓⵍ ⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵎ ⵓⵍ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴰⵏ: “ⵄⵇⴻⴱ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S219_16","011_19_16","2SA","19","16","16","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵔⴰⵃⴻⵏ ⴰⴷ ⵄⴰⵡⵏⴻⵏ ⴰⵥⴻⴽⴽⵯⵉ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S219_17","011_19_17","2SA","19","17","17","ⵓⵛⴰ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵔⴰ, ⵉⵊⵊ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⵉ ⴱⴰⵅⵓⵔⵉⵎ ⵉⴽⵙⵉ ⴷⴻⴳ ⵓⴹⴰⵔ ⵏⵏⴻⵙ, ⵉⵀⵡⴰ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S219_18","011_19_18","2SA","19","18","18","ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵄⴰⵡⴻⴷ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓⵍⴰ ⴷ ⵚⵉⴱⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⴰⴷ ⵄⴷⵓⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴷⵉⵏⵏⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S219_19","011_19_19","2SA","19","19","19","ⵜⴻⵥⵡⴰ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵉ ⵓⵙⴻⵥⵡⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵓ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵔⴰ, ⵉⵡⴹⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵎⵉ ⴷⴷ-ⵉⵥⵡⴰ ⵡⴰⵏⵉⵜⴰ ⵍ’ⵓⵔⴷⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("S219_20","011_19_20","2SA","19","20","20","ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴻⵊⵊ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵃⴻⵙⵙⴻⴱ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴰⵔ ⵄⴰⴷ ⴷⴻⴳ ⵓⴼⴰⵔⵢⴻⴹ ⵉ ⵉⴳⴳⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵉⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵜⵜ ⵉⴽⴻⵙⵙⵉ ⴰⵎⵎⵓ ⵖⴰⵔ ⵡⵓⵍ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⵏⵜⴰⵇⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S219_21","011_19_21","2SA","19","21","21","ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵙⵙⴻⵏ: ⵏⴻⵛⵛ, ⵡⴰⵀ, ⵏⴻⵛⵛ ⵅⴹⵉⵖ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵙⴰⴳⴰⵔⴻⵖ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("S219_22","011_19_22","2SA","19","22","22","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵉⵏⵏⴰ: “ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵛⵉⵎⵄⵉ ⴰⴷ ⵉⵎⵎⴻⵜ ⵅ ⵎⴰⵏ ⴰⵢⴰ? ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵄⴻⵍ ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("S219_23","011_19_23","2SA","19","23","23","ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵊⴰⵔ ⴰⵢⵉ-ⴷⴷ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⵔⵔⴰⵡ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵓⵎⵉ ⵜⴷⴻⵡⵍⴻⵎ ⴰⵢⵉ ⴰⵙⵙ-ⴰ ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵉⵎ? ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⴰⵙⵙ-ⴰ ⵛⴰ ⵏ ⵉⵊⵊ ⴷⵉ ⵉⵙⵔⴰⵉⵍ? ⴰⵅⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⵙⵙ-ⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("S219_24","011_19_24","2SA","19","24","24","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⵉ ⵛⵉⵎⵄⵉ: “ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⴷ ⵛⴰ!” ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵊⵊⵓⴵ ⴰⵙ ⵜ. ");
INSERT INTO rift_vpl VALUES ("S219_25","011_19_25","2SA","19","25","25","ⵓⵍⴰ ⴷ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵢⵓⵙⴰ-ⴷⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵔⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵡⴰⵔ ⵉⵃⴻⴼⴼ ⴰⵛⵍⴰⵖⴻⵎ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵚⴻⴱⴱⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵏⴻⵜⵜⴰ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S219_26","011_19_26","2SA","19","26","26","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴽⵉⴷⵉ ⵜⵔⵓⵃⴻⴷ, ⵎⴰⴼⵉⴱⵓⵛⴰⵜ?” ");
INSERT INTO rift_vpl VALUES ("S219_27","011_19_27","2SA","19","27","27","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵉⵖⴷⴰⵔ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴱⴰⵔⴷⵄⴻⵖ ⵉ ⵡⴻⵖⵢⵓⵍ, ⴰⴷ ⵅⴰⵙ ⵏⵢⴻⵖ, ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ!’, ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷ ⴰⵇⴻⵊⴷⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("S219_28","011_19_28","2SA","19","28","28","ⵏⴻⵜⵜⴰ ⵉⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S219_29","011_19_29","2SA","19","29","29","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵎⵖⵉⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵛⴻⴽ ⵜⴻⵙⵙⵖⵉⵎⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵛ! ⵎⵉⵏ ⵖⴰⵔⵉ ⵄⴰⴷ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵓ ⵉ ⵓⵎⵉ ⵖⴰ ⵜⵜⴰⵔⴻⵖ ⵄⴰⴷ ⴽⵜⴰⵔ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("S219_30","011_19_30","2SA","19","30","30","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵄⴰⴷ ⴰⵎⵎⵓ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵛ? ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ ⴰⵛ: ⵛⴻⴽ ⴷ ⵚⵉⴱⴰ, ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴱⴹⴰⵎ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("S219_31","011_19_31","2SA","19","31","31","ⵉⵏⵏⴰ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵏⴻⵜⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⴽⵙⵉ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴰⵇⴰ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("S219_32","011_19_32","2SA","19","32","32","ⴱⴰⵔⵣⵉⵍⵍⴰⵢ, ⴰⵊⵉⵍⵄⴰⴷⵉ, ⵉⵀⵡⴰ ⵣⵉ ⵔⵓⵊⴰⵍⵉⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵡⵛ ⴰⴼⵓⵙ ⵉ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⴰⵎⵎⵓ ⵅ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S219_33","011_19_33","2SA","19","33","33","ⴱⴰⵔⵣⵉⵍⵍⴰⵢ ⵜⵓⵖⴰ ⵉⵡⵙⴰⵔ ⴰⵟⵟⴰⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴽⵙⵉ ⵖⴰⵔⴻⵙ ⴰⵊⴻⴵⵉⴷ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⵉ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⴰⴳⵍⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S219_34","011_19_34","2SA","19","34","34","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⵉ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ: “ⵥⵡⴰ ⴰⴽⵉⴷⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵖⴰⵔⵉ ⴽⵙⵉⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("S219_35","011_19_35","2SA","19","35","35","ⵎⴰⵛⴰ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴻⵛⵃⴰⵍ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵄⴰⴷ ⴷⵉⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⴼⴼⵖⴻⵖ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ? ");
INSERT INTO rift_vpl VALUES ("S219_36","011_19_36","2SA","19","36","36","ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴼⴰⵔⵣⴻⵖ ⵄⴰⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵣⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵇⵇⴰⵙ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵖ ⴷ ⵎⵉⵏ ⵖⴰ ⵙⵡⴻⵖ? ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵍⴻⵖ ⵄⴰⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵜⵎⴻⴷⵢⴰⵣⵉⵏ? ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⵙⵙⴻⴷⵇⴻⵍ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵄⴰⴷ ⵅ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ? ");
INSERT INTO rift_vpl VALUES ("S219_37","011_19_37","2SA","19","37","37","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ. ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵡⵛ ⵓⵊⴻⴵⵉⴷ ⵜⴰⵔⴻⴱⴱⴰⵃⵜ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("S219_38","011_19_38","2SA","19","38","38","ⴻⵊⵊ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵄⵇⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⵜⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵏⵓ, ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵏ ⴱⴰⴱⴰ ⴷ ⵢⴻⵎⵎⴰ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴽⵉⵎⵀⴰⵎ! ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵥⵡⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ. ⴻⴳⴳ ⴰⵙ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("S219_39","011_19_39","2SA","19","39","39","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴽⵉⵎⵀⴰⵎ ⴰⴷ ⴽⵉⴷⵉ ⵉⵥⵡⴰ ⵓ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵙ ⵜ ⴳⴳⴻⵖ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⵉ ⵜⴻⵙⵙⵓⵜⴰⵔⴻⴷ, ⴰⴷ ⴰⵛ ⵜ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S219_40","011_19_40","2SA","19","40","40","ⵓⵎⵉ ⵉⵥⵡⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵥⵡⴰ ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ. ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⵓⴷⴻⵎ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ, ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ. ⵅⴰⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S219_41","011_19_41","2SA","19","41","41","ⴰⵊⴻⴵⵉⴷ ⵎⴰⵛⴰ ⵢⴰⵔⵏⵉ ⵉⵄⴷⵓ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ ⵓ ⴽⵉⵎⵀⴰⵎ ⵉⵄⴷⵓ ⴰⴽⵉⴷⴻⵙ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵄⴷⵓ ⴰⵊⴻⴵⵉⴷ, ⵓⵍⴰ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S219_42","011_19_42","2SA","19","42","42","ⵓ ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵢⴻⵎⵎⵉ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰⵔⴻⵏ ⵛⴻⴽ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓ ⵏⴻⴷⵀⴻⵏ ⴰⵊⴻⴵⵉⴷ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⴰⴽⵉⴷⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("S219_43","011_19_43","2SA","19","43","43","ⵅⴻⵏⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⵉⵏⵣⵉ ⴰⵊⴻⴵⵉⴷ ⵉⵜⵜⴻⵄⵏⴰ ⴰⵏⴻⵖ-ⴷⴷ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⵅⴻⵢⵢⵇⴻⵎ ⵅ ⵓⵢⴰ? ⵎⴰ ⵏⴻⵛⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵉⵖ ⵢⵉⵡⵉ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵉ ⵏⴻⵛⵛⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("S219_44","011_19_44","2SA","19","44","44","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵓⵍⴰ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ ⵖⴰⵔⵏⴻⵖ ⵅⴻⵏⵏⵉ ⴽⵜⴰⵔ ⵅⴰⵡⴻⵎ. ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⵎ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵖ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴰⵔⵔ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ?” ⵓⵛⴰ ⵜⵓⵖⴰ ⴰⵡⴰⵍ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵊⵀⴻⴷ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S220_1","011_20_1","2SA","20","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⴰⴱⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ, ⵉⵊⵊ ⵏ ⵓⴱⵉⵏⵢⴰⵎⵉⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⴷⴰⵡⵓⴷ ⵓ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵍⵡⴰⵔⵜ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ. ⴻⵊⵊ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⴰ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("S220_2","011_20_2","2SA","20","2","2","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵔⵓⵃ ⴰⵡⴰⵔⵏⵉ ⵉ ⵛⴰⴱⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ. ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵇⵇⵉⵎⴻⵏ ⵍⴻⵙⵇⴻⵏ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ, ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵍ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S220_3","011_20_3","2SA","20","3","3","ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⴽⵙⵉ ⵓⵊⴻⴵⵉⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵜⵉⵢⵢⴰ ⵏⵏⴻⵙ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⴰⵏⵜ ⵜⴰⴷⴷⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵃⴹⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵀⵉⵍⵍⴰ ⴷⴰⵢⵙⴻⵏⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏⵜ ⵢⵓⴷⵉⴼ. ⵏⵉⵜⴻⵏⵜⵉ ⵇⵇⵉⵎⴻⵏⵜ ⴱⴻⵍⵍⵄⴻⵏⵜ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵙⴻⵏⵜ, ⴷⴷⴰⵔⴻⵏⵜ ⴷ ⵜⵉⵊⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("S220_4","011_20_4","2SA","20","4","4","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵄⴰⵡⴻⴷ ⵉ ⵄⴰⵎⴰⵙⴰ: “ⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵎⵓⵏⴻⵏ ⵖⴰⵔⵉ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴱⴻⴷⴷ ⵛⴻⴽ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("S220_5","011_20_5","2SA","20","5","5","ⵄⴰⵎⴰⵙⴰ ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⴰⵖⴰ ⵅ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵄⴻⵟⵟⴻⵍ ⵅ ⵍⵡⴻⵇⵜ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S220_6","011_20_6","2SA","20","6","6","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⴱⵉⵛⴰⵢ: “ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵏⴻⵖ ⵉⴳⴳ ⵛⴰⴱⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ, ⵜⵓⵄⴻⴼⴼⵏⴰ ⵎⴰⵀⵓ ⵅ ⴰⴱⵛⴰⵍⵓⵎ. ⴽⵙⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⴹⴼⴰⵔ ⵉ-ⵜ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴼ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S220_7","011_20_7","2SA","20","7","7","ⴼⴼⵖⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⵓⵡⴰⴱ, ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴽ-ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵛⴰⴱⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S220_8","011_20_8","2SA","20","8","8","ⵓⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔ ⵡⴻⵥⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵊⵉⴱⵄⵓⵏ, ⵜⵓⵖⴰ ⵄⴰⵎⴰⵙⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ⵢⵓⵡⴰⴱ ⵜⵓⵖⴰ ⵉⵜⵜⵃⴻⵣⵣⴰⵎ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉ ⵢⴰⵔⴹ. ⵜⵓⵖⴰ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵃⴻⵣⵣⴰⵎ ⴰⴽ-ⴷ ⵙⵙⵉⴼ ⴷⴻⴳ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵉ ⵅⴰⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ. ⵓⵎⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵉⵡⴹⴰ ⴰⵙ ⵙⵙⵉⴼ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S220_9","011_20_9","2SA","20","9","9","ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ ⵉ ⵄⴰⵎⴰⵙⴰ: “ⴰⵇⴰ ⵛⴻⴽ ⵎⵍⵉⵃ, ⵓⵎⴰ?” ⵉⵛⴻⴱⴱⴰⵔ ⵢⵓⵡⴰⴱ ⵙ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⴷⵉ ⵜⵎⴰⵔⵜ ⵏ ⵄⴰⵎⴰⵙⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⵓⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("S220_10","011_20_10","2SA","20","10","10","ⵄⴰⵎⴰⵙⴰ ⵡⴰⵔ ⵉⵃⴻⴽⴽⴰⵔ ⵉ ⵙⵙⵉⴼ ⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵓⵡⴰⴱ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵣⵣⴰⵢⴻⵙ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⴰⵙ-ⴷⴷ ⵡⴰⴷⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⵎⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ. ⵓ ⵢⵓⵡⴰⴱ ⴰⴽ-ⴷ ⵓⵎⴰⵙ ⴰⴱⵉⵛⴰⵢ ⵉⴹⴼⴰⵔ ⵛⴰⴱⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S220_11","011_20_11","2SA","20","11","11","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴱⴻⴷⴷ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵄⴰⵎⴰⵙⴰ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵢⵓⵡⴰⴱ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵏ ⵢⵓⵡⴰⴱ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⴰⴷ ⵉⴹⴼⴰⵔ ⵢⵓⵡⴰⴱ!” ");
INSERT INTO rift_vpl VALUES ("S220_12","011_20_12","2SA","20","12","12","ⵄⴰⵎⴰⵙⴰ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵣⵣⴻⵍ ⵉⵜⵜⵡⴰⵏⵏⴻⴹ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ, ⵉⵊⴰⵔⵔ ⵏⴻⵜⵜⴰ ⵄⴰⵎⴰⵙⴰ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ ⵓ ⵉⵏⴹⴰⵔ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵜⵉⵡⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⵥⵔⴰ ⵇⴰⵄ ⵡⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵡⴹⴻⵏ, ⵉⵇⵇⵉⵎ ⵉⵜⵜⴱⴻⴷⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S220_13","011_20_13","2SA","20","13","13","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⴳⴳⵯⴻⵊ ⵅ ⵡⴻⴱⵔⵉⴷ, ⵄⴷⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵓⵡⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵛⴰⴱⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("S220_14","011_20_14","2SA","20","14","14","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴽⴽⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⴰⴱⴰⵍ ⵓ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵎⴰⵄⴽⴰ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵉⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵓ ⵔⵓⵃⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S220_15","011_20_15","2SA","20","15","15","ⴰⵎⵎⵓ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⴷⵉⵏ ⵓⵛⴰ ⵏⵏⴹⴻⵏ-ⴷⴷ ⵉ ⵛⴰⴱⴰⵄ ⴷⵉ ⴰⴱⴰⵍ-ⴱⴰⵢⵜ-ⵎⴰⵄⴽⴰ. ⵏⵉⵜⵏⵉ ⵙⵙⴻⴼⵢⴻⵏ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⴰⵊ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵍⴱⴰⵔⴰⵊ ⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⵣⵣⴰⵜ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⵢⵓⵡⴰⴱ, ⴳⴳⵉⵏ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⵃⵉⴹ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⵖⴻⴹⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S220_16","011_20_16","2SA","20","16","16","ⵅⴻⵏⵏⵉ ⵜⵍⴰⵖⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵜⵎⵉⵖⵉⵙⵜ ⵣⵉ ⵜⴻⵏⴷⵉⵏ:ⵜ “ⵙⵍⴻⵎ, ⵙⵍⴻⵎ, ⵉⵏⵉⵎ ⵉ ⵢⵓⵡⴰⴱ: ‘ⴰⵙ-ⴷⴷ ⴷⴰ, ⴰⴷⴻⵙ-ⴷⴷ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴽⵉⴷⴻⴽ ⵙⵙⵉⵡⵍⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("S220_17","011_20_17","2SA","20","17","17","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵏⴻⵜⵜⴰ, ⵢⵓⴷⴻⵙ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ: “ⵎⴰ ⵛⴻⴽ ⴷ ⵢⵓⵡⴰⴱ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷ ⵏⴻⵛⵛ.” ⵜⴻⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰⵜ: “ⵙⴻⵍ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵜⴻⵙⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("S220_18","011_20_18","2SA","20","18","18","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ: “ⵣⵉⵛ ⵜⵓⵖⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ, ⵏⵏⴰⵏ: ‘ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵜⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⴰⴱⴰⵍ!’, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("S220_19","011_20_19","2SA","20","19","19","ⵏⴻⵛⵛ ⵣⴻⴳ ⵉⵏⵏⵉ ⵏ ⴰⵢⵜ ⵏ ⵍⴻⵀⵏⴰ ⵓ ⵣⴻⴳ ⵉⵎⵜⵉⵇⵇⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵢⴻⵎⵎⴰⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵚⴰⵔⴹⴻⴷ ⵍⵡⴰⵔⵜ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("S220_20","011_20_20","2SA","20","20","20","ⵢⵓⵡⴰⴱ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰⵢⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵚⴰⵔⴹⴻⵖ ⵓ ⴰⴷ ⵀⴻⴷⵎⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("S220_21","011_20_21","2SA","20","21","21","ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⴰⵎⴻⵏⵏⵉ. ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⴰⴱⵄⴰ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ, ⵉⴽⵙⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵅ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⵡⵛⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⴻⵢⵢⴷⴻⵖ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ.” ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵢⵓⵡⴰⴱ: “ⵅⵣⴰⵔ, ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⵉⵎⵎⴻⵏⴹⴰⵔ ⵜⵉⵡⴰ ⵉ ⵍⵃⵉⴹ.” ");
INSERT INTO rift_vpl VALUES ("S220_22","011_20_22","2SA","20","22","22","ⵜⵓⵙⴰ-ⴷⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓ ⵏⵉⵜⵏⵉ ⵇⴻⵙⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵉ ⵛⴰⴱⵄⴰ, ⵎⵎⵉⵙ ⵏ ⴱⵉⴽⵔⵉ, ⵏⴹⴰⵔⴻⵏ ⵜ ⵉ ⵢⵓⵡⴰⴱ. ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵢⵓⵡⴰⴱ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵏⵉⵜⵏⵉ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵓ ⵢⵓⵡⴰⴱ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S220_23","011_20_23","2SA","20","23","23","ⵢⵓⵡⴰⴱ ⵉⵜⵜⵡⴰⴳⴳ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵜⵓⵖⴰ ⵅ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("S220_24","011_20_24","2SA","20","24","24","ⴰⴷⵓⵔⴰⵎ ⵉⴱⴻⴷⴷ ⵅ ⵍⵊⵉⵣⵢⴰ ⵓ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵍⵓⴷ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("S220_25","011_20_25","2SA","20","25","25","ⵛⵉⵡⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⴰⵔⵉⵔ, ⵓ ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S220_26","011_20_26","2SA","20","26","26","ⵓⵍⴰ ⴷ ⵄⵉⵔⴰ ⵣⵉ ⵢⴰ’ⵉⵔ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵜⵉⵇⵇⵉ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S221_1","011_21_1","2SA","21","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴰⵥ, ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵓ ⴷⴰⵡⵓⴷ ⵢⴰⵔⵣⵓ ⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵙⵉⴷⵉ ⵉⵏⵏⴰ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⵛⴰⵡⵓⵍ ⵓ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⵍⴻⵚⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("S221_2","011_21_2","2SA","21","2","2","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵅ ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ. ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ ⵡⴰⵔ ⴷⴷ-ⵇⵇⴰⵔⵚⴻⵏ ⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵣⵉ ⵎⵉⵏ ⵄⴰⴷ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵊⵊⵓⴵⴻⵏ ⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜⴻⵏ ⵉⵡⵡⴻⵜ ⴷⴻⴳ ⵡⴻⵛⴹⴰⵔ ⵏⵏⴻⵙ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S221_3","011_21_3","2SA","21","3","3","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ: “ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵓ ⵙ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⵚⵍⴰⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴱⴰⵔⴽⴻⵎ ⵍⵡⴰⵔⵜ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("S221_4","011_21_4","2SA","21","4","4","ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵛⵇⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⴷ ⵡⵓⵔⴻⵖ ⵣⵉ ⵛⴰⵡⵓⵍ ⵏⵉⵖ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴰⴷ ⵏⴻⵏⴻⵖ ⵛⴰ ⵏ ⵉⵊⵊ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.” ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵜ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S221_5","011_21_5","2SA","21","5","5","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵉⵛⵇⴰ ⴰⵏⴻⵖ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵇⴹⴰ ⵓ ⵜⵓⵖⴰ ⵉⵏⵡⴰ ⴰⴷ ⵉⵎⵃⴰ ⴰⵖⵉⵎⵉ ⵏⵏⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S221_6","011_21_6","2SA","21","6","6","ⴰⴷ ⴰⵏⴻⵖ ⵎⵎⴻⵡⵛⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴰⵢⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵊⵉⴱⵄⴰ ⵏ ⵛⴰⵡⵓⵍ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵙⵉⴷⵉ!” ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("S221_7","011_21_7","2SA","21","7","7","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⵄⵉⵣⵣ ⵅ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵊⴰⴵⵉⵜ ⵉ ⵙⵉⴷⵉ, ⵜⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵊⴰⵔ ⴷⴰⵡⵓⴷ ⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S221_8","011_21_8","2SA","21","8","8","ⴰⵊⴻⴵⵉⴷ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⵉⵚⴼⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⵢⴰ, ⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵉ ⵛⴰⵡⵓⵍ, ⴰⵔⵎⵓⵏⵉ ⴷ ⵎⴰⴼⵉⴱⵓⵛⴰⵜ, ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⵉⵔⴰⴱ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵉ ⵄⴰⴷⵔⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ ⵣⵉ ⵎⴰⵃⵓⵍⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("S221_9","011_21_9","2SA","21","9","9","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⴰⵢⵍⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵡⴹⴰⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵏⵖⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⵢⵔⴰ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵖⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵜⵎⴻⵢⵔⴰ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S221_10","011_21_10","2SA","21","10","10","ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵔⵉⵚⴼⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⵢⴰ, ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵜⴻⵙⵙⵓ ⵜⵜ ⵣⵣⴰⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⵉⵊⵊ ⵏ ⵊⵊⴰⵔⴼ. ⵣⵉ ⴱⴻⴷⴷⵓ ⵏ ⵜⵎⴻⵢⵔⴰ ⴰⵍ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵣⴻⴵⵄⴻⵏ ⵡⴰⵎⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴻⵊⵊⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵓⵣⵉⵍ ⵓⵍⴰ ⴷ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S221_11","011_21_11","2SA","21","11","11","ⵃⴰⵊⴰⵏ ⴰⵙ ⵉ ⴷⴰⵡⵓⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵔⵉⵚⴼⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⵢⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S221_12","011_21_12","2SA","21","12","12","ⵉⵟⵟⴻⴼ ⴷⴰⵡⵓⴷ ⴰⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⵙⵉ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⴱⵉⵛ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵉⵖⵓⵙⵙⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵉⵖⵓⵙⵙⴰⵏ ⵏ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ ⵏⵏⵉ ⴷⴷ-ⴽⴽⵙⴻⵏ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵡⴰⵣⵣⴰⵖ ⵏ ⴱⴰⵢⵜ-ⵙⴰⵏ, ⵎⴰⵏⵉ ⵜⴻⵏ ⵢⵓⵢⵍⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵖⴻⵍⴱⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵛⴰⵡⵓⵍ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S221_13","011_21_13","2SA","21","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵙⴻⵏⵏⵉ ⵉⵖⵙⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵉⵖⵙⴰⵏ ⵏ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ. ⵏⵉⵜⵏⵉ ⵙⵙⵎⵓⵏⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵖⵙⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵢⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S221_14","011_21_14","2SA","21","14","14","ⵏⴻⴹⵍⴻⵏ ⵉⵖⵙⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵎⵎⵉⵙ ⵢⵓⵏⴰⵜⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷⵉ ⵚⴰⵢⵍⴰⵄ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⴱⴰⴱⴰⵙ ⵇⵉⵙ ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵊⵊⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵜⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵢⵓⴵⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S221_15","011_21_15","2SA","21","15","15","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⵎⴻⵏⵖⴻⵏ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⴷⴰⵡⵓⴷ ⵉⵀⵡⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ⵏⵉⵜⵏⵉ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷⴰⵡⵓⴷ ⵢⵓⵃⴻⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S221_16","011_21_16","2SA","21","16","16","ⵢⵉⵛⴱⵉ-ⴱⴰⵏⵓⴱ, ⵉⵊⵊ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⴰⴼⴰ, ⵡⴻⵏⵏⵉ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵜⴻⵡⵣⴻⵏ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵃⴰⵙ ⵓ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⵢⴻⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵏ ⵊⴷⵉⴷ, ⵉⵟⵟⵖⵉⵍ ⴰⵙ ⴰⴷ ⵉⵡⵡⴻⵜ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("S221_17","011_21_17","2SA","21","17","17","ⵎⴰⵛⴰ ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵉⵡⵛⴰ ⴰⴼⵓⵙ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵡⵜⴰ ⴰⴼⵉⵍⵉⵙⵟⵉⵏⵉ, ⵉⵏⵖⴰ ⵉ-ⵜ. ⵅⴻⵏⵏⵉ ⵊⵊⵓⴵⴻⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⵛⴻⴽ ⵡⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ ⵜⴻⴼⴼⵖⴻⴷ ⵄⴰⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵅⴻⵙⵢⵉⴷ ⵍⴻⴼⵏⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("S221_18","011_21_18","2SA","21","18","18","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵊⵓⴱ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⴰⴱⴽⴰⵢ, ⴰⵃⵓⵛⴰⵢⵉ, ⵉⵡⵜⴰ ⵙⴰⴼ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵔⴰⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("S221_19","011_21_19","2SA","21","19","19","ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⴷⵉⵏ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵊⵓⴱ. ⵉⵍⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵄⵔⵉ-ⴰⵔⵊⵉⵎ, ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵉⵖⵍⴻⴱ ⵅ ⵓⵍⵜⵎⴰⵙ ⵏ ⵊⵓⵍⵢⴰⵜ ⵣⵉ ⵊⴰⵜ. ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵅⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("S221_20","011_21_20","2SA","21","20","20","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵊⴰⵜ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵣⵉⵔⴰⵔ, ⵙ ⵙⴻⵜⵜⴰ ⵏ ⵉⴹⴻⵡⴹⴰⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⵙⴻⵜⵜⴰ ⵏ ⵜⴼⴻⴷⵏⵉⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵓ ⵄⵉⵛⵔⵉⵏ. ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵉ ⵔⴰⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("S221_21","011_21_21","2SA","21","21","21","ⵏⴻⵜⵜⴰ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⴰ, ⵓⵎⴰⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵖⵍⴻⴱ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S221_22","011_21_22","2SA","21","22","22","ⴰⵔⴻⴱⵄⴰ-ⵢⴰ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ-ⴷⴷ ⴷⵉ ⵔⴰⴼⴰ ⴷⵉ ⵊⴰⵜ ⵓ ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_1","011_22_1","2SA","22","1","1","ⴷⴰⵡⵓⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵣⵍⵉ-ⵢⴰ ⵉ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵜ ⵉⴼⴻⴽⴽ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("S222_2","011_22_2","2SA","22","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⴷ ⴰⵎⴼⴻⴽⴽⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_3","011_22_3","2SA","22","3","3","ⵙⵉⴷⵉ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵉⵏⵓ, ⵖⴰⵔⴻⵙ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ. ⵛⴻⴽ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉⵏⵓ ⴷ ⵢⵉⵛⵛ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ, ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷ ⴰⵎⵙⴻⵏⵊⴰⵎ ⵉⵏⵓ. ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⴰⵢⵉ ⵣⵉ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("S222_4","011_22_4","2SA","22","4","4","ⵍⴰⵖⵉⵖ: ⴰⵙⴻⵎⵖⴰⵔ ⵉ ⵙⵉⴷⵉ!, ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_5","011_22_5","2SA","22","5","5","ⵎⴰⵖⴰⵔ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵍⴻⵎⵡⴰⵊ ⵏ ⵍⵎⴻⵡⵜ, ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏⵜ ⴰⵢⵉ ⵍⵃⴻⵎⵍⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴰⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_6","011_22_6","2SA","22","6","6","ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵍⴰⵅⴰⵔⵜ ⵛⴰⵔⴼⴻⵏ ⴰⵢⵉ, ⵜⵉⵅⴻⵛⴼⵉⵏ ⵏ ⵍⵎⴻⵡⵜ ⵃⵚⴰⵔⴻⵏⵜ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_7","011_22_7","2SA","22","7","7","ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅ ⵙⵉⴷⵉ ⵓ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵉ ⵅ ⴷⴷ-ⵍⴰⵖⵉⵖ. ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵙⵍⴰ ⵏⴻⵜⵜⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵓⵛⴰ ⵉⵖⵓⵢⵢⴰⵏ ⵉⵏⵓ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_8","011_22_8","2SA","22","8","8","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵀⴻⵣⵣ ⵓ ⵜⴰⵔⵊⵉⵊⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵙⵓⵙⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵜⵜⵔⴰⵃⴻⵏ-ⴷⴷ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ, ⵏⵀⴻⵣⵣⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ. ");
INSERT INTO rift_vpl VALUES ("S222_9","011_22_9","2SA","22","9","9","ⴷⴷⴻⵅⵅⴰⵏ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵉⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜⵚⴰⵔⴹ, ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_10","011_22_10","2SA","22","10","10","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵢⴰⴹⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ-ⴷⴷ. ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_11","011_22_11","2SA","22","11","11","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ, ⵉⴹⵡⴰ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵥⴰⵔ ⵅ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("S222_12","011_22_12","2SA","22","12","12","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⴵⴻⵙⵜ ⴰⴷ ⴰⵙ ⵜⴻⵏⵏⴻⴹ ⴰⵎ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵡⴰⵎⴰⵏ, ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⵇⴻⵍⵍⵊⴻⵏ ⵉⴱⴱⴰⵔⴻⵛⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_13","011_22_13","2SA","22","13","13","ⵣⵉ ⵜⵉⵙⵙⵉⵇⵜ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵙⵙⴰⵔⵖⴻⵏ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_14","011_22_14","2SA","22","14","14","ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⴰⵊⵊⴰⵊ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵉⴳⴳⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵜⵜⵏⴻⴼⵔⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S222_15","011_22_15","2SA","22","15","15","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⴻⵏ, ⵉⵣⵣⴰⵔⵢⴻⴹ ⴰⵙⵙⴰⵎⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_16","011_22_16","2SA","22","16","16","ⵜⵉⵙⵉⵡⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵜⴱⴰⵏⴻⵏⵜ, ⴷⵙⵓⵙⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷⴻⵡⵍⴻⵏ ⵄⴰⵔⵔⴰⵏ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ ⵏ ⵙⵉⴷⵉ, ⵣⴻⴳ ⵓⵙⵓⴹⵉ ⵏ ⵍⴻⵄⵡⵉⵏ ⵣⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_17","011_22_17","2SA","22","17","17","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ-ⴷⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵣⵉ ⵍⵓⵄⵍⴰ, ⵢⵉⵡⵉ ⴰⵢⵉ, ⵉⵊⴱⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_18","011_22_18","2SA","22","18","18","ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵣⵉ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⵉⵊⴻⵀⴷⴻⵏ, ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵊⴻⵀⴷⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_19","011_22_19","2SA","22","19","19","ⵃⵚⴰⵔⴻⵏ ⴰⵢⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴷ ⴰⵎⵄⴻⵎⵎⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_20","011_22_20","2SA","22","20","20","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵜⵜⴰⵙⵉⵄ, ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵄⵉⵣⵣⴰ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_21","011_22_21","2SA","22","21","21","ⵙⵉⴷⵉ ⵉⵅⵍⴻⴼ ⴰⵢⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵣⴷⵓⴳⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉⵅⴻⴵⴻⵚ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_22","011_22_22","2SA","22","22","22","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵖ ⵛⴰ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵙ ⵓⵅⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("S222_23","011_22_23","2SA","22","23","23","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵃⴻⵢⵢⵉⴷⴻⵖ ⵛⴰ ⵅ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_24","011_22_24","2SA","22","24","24","ⴷⴻⵡⵍⴻⵖ ⴽⴻⵎⵍⴻⵖ ⵉ ⵏⴻⵜⵜⴰ, ⵃⴹⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_25","011_22_25","2SA","22","25","25","ⵙⵉⴷⵉ ⵉⵅⵍⴻⴼ ⴰⵢⵉ ⴰⵏⴻⵛⵜ ⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⴰⵏⴻⵛⵜ ⵏ ⵜⴰⵣⴷⵓⴳⵉ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_26","011_22_26","2SA","22","26","26","ⵉ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴰⵎⵜⵉⵇⵇⵉ ⵉ ⵜⴻⴵⵉⴷ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵉ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵉ ⵜⴻⴵⵉⴷ ⵛⴻⴽ ⵜⴽⴻⵎⵎⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S222_27","011_22_27","2SA","22","27","27","ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⵇⴰ ⵜⴼⴰⵔⵖⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("S222_28","011_22_28","2SA","22","28","28","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ, ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴹⵉⴷⴷ ⵉ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵀⵡⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("S222_29","011_22_29","2SA","22","29","29","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵍⴻⴼⵏⴰⵔ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ! ⵙⵉⴷⵉ ⵉⵜⵜⴻⴳⴳ ⵜⴰⴼⴰⵡⵜ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_30","011_22_30","2SA","22","30","30","ⵎⵉⵏⵣⵉ ⴰⴽⵉⴷⴻⴽ ⴰⴷ ⴰⵣⵣⵍⴻⵖ ⵅ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ, ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴰⴷ ⵏⴻⴳⴳⵣⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("S222_31","011_22_31","2SA","22","31","31","ⴰⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴽⵎⴻⵍ, ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_32","011_22_32","2SA","22","32","32","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵎⵖⵉⵔ ⵙⵉⴷⵉ, ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵚⴹⴰⵔⵜ, ⵎⵖⵉⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("S222_33","011_22_33","2SA","22","33","33","ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⴷ ⵍⵇⴻⵍⵄⴰ ⵉⵏⵓ ⵉⵊⵀⴻⴷ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵅⵓ ⴰⴱⵔⵉⴷ ⵉⵏⵓ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_34","011_22_34","2SA","22","34","34","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵏⵏⵉ ⵏ ⵜⵓⴷⴰⴷⵉⵏ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_35","011_22_35","2SA","22","35","35","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵉⵖⴰⴵⴻⵏ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⴻⵃⴹⴻⵏ ⵉⵊⵊ ⵏ ⵍⵇⴻⵡⵙ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("S222_36","011_22_36","2SA","22","36","36","ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⴰⵙⴻⵍⵇⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵙ ⵓⵡⴰⴹⴻⵄ ⵏⵏⴻⵛ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_37","011_22_37","2SA","22","37","37","ⴰⵇⴰ ⵜⴻⴳⴳⴻⴷ ⵜⵜⴰⵙⵉⵄ ⵉ ⵓⵚⵓⵔⵉⴼ ⵉⵏⵓ ⵙⴰⴷⵓ ⵉⵏⵓ, ⵓⵛⴰ ⵜⵉⵛⴻⵄⴱⵉⵏ ⵉⵏⵓ ⵡⴰⵔ ⵎⴻⵢⵢⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("S222_38","011_22_38","2SA","22","38","38","ⵏⴻⵛⵛ ⴹⴼⴰⵔⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵓⵛⴰ ⵜⴻⵃⵃⵉⵖ ⵜⴻⵏ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵖ ⴰⵍ ⵜⴻⵏ ⵇⴹⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("S222_39","011_22_39","2SA","22","39","39","ⵏⴻⵛⵛ ⵇⴹⵉⵖ ⵜⴻⵏ ⵓ ⵍⴻⴱⵣⴻⵖ ⵜⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴽⴽⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ. ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ-ⴷⴷ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_40","011_22_40","2SA","22","40","40","ⵛⴻⴽ ⵜⴱⴻⵢⵙⴻⴷ ⴰⵢⵉ ⵙ ⵊⵊⴻⵀⴷ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵜⴰⵔⵔⵉⴷ ⵉⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵙⴰⴷⵓ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S222_41","011_22_41","2SA","22","41","41","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⵉⵎⴻⵊⵊⴰⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_42","011_22_42","2SA","22","42","42","ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵎⵙⴻⵏⵊⴻⵎ, ⵍⴰⵖⴰⵏ, ⵅ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵢⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_43","011_22_43","2SA","22","43","43","ⵏⴻⵛⵛ ⵙⵙⵡⴻⴷⴷⴰⵔⴻⵖ ⵜⴻⵏ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎ ⵓⴱⴻⴵⴰⵄ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵄⴻⵊⵏⴻⵖ ⵅⴰⵙⴻⵏ ⵓ ⵍⴻⴱⵣⴻⵖ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_44","011_22_44","2SA","22","44","44","ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⴰⵢⵉ ⵣⴻⴳ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵜⴻⵃⴹⵉⴷ ⴰⵢⵉ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ, ⴰⴷ ⴰⵢⵉ ⵉⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("S222_45","011_22_45","2SA","22","45","45","ⵜⴰⵔⵡⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⵙⵙⵡⴰⴹⵄⴻⵏ ⴰⵢⵉ. ⵎⵖⵉⵔ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵉⵙⵍⴰ ⵓⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ ⵡⴰⵀⴰ, ⵙⵍⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("S222_46","011_22_46","2SA","22","46","46","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴼⴻⵛⵍⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵏⴹⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵍⴱⴰⵔⴰⵊⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S222_47","011_22_47","2SA","22","47","47","ⵜⵓⴷⴰⵔⵜ ⵉ ⵙⵉⴷⵉ. ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵜⴻⵚⴹⴰⵔⵜ ⵉⵏⵓ. ⴻⵊⵊ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ!. ");
INSERT INTO rift_vpl VALUES ("S222_48","011_22_48","2SA","22","48","48","ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⴻⵏⵜⴰⵇⴰⵎⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("S222_49","011_22_49","2SA","22","49","49","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴼⴻⴽⴽⴰⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵡⴰⵀ, ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴹⴰⴷⴷⴰⵏ, ⵛⴻⴽ ⵜⴻⵙⵙⴻⵏⵊⴰⵎⴻⴷ ⴰⵢⵉ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("S222_50","011_22_50","2SA","22","50","50","ⵅ ⵓⵢⴰ, ⵙⵉⴷⵉ, ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ, ⵅⵙⴻⵖ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("S222_51","011_22_51","2SA","22","51","51","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵙⴻⵏⵊⵉⵎⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⵎⵖⴰⵔⴻⵏ, ⵓⵛⴰ ⵉⵙⵙⵛⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵙ, ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("S223_1","011_23_1","2SA","23","1","1","ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴰⵡⵓⴷ. ⴷⴰⵡⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ ⵉⵙⵙⴰⵡⴰⵍ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰⵏ ⵉⵙⵙⴰⵡⴰⵍ, ⴰⵎⴻⴷⵀⵓⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⴻⴷⵢⴰⵣ ⵉⵄⵉⵣⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S223_2","011_23_2","2SA","23","2","2","ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵣⵣⴰⵢⵉ ⵓ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵅ ⵉⵍⴻⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("S223_3","011_23_3","2SA","23","3","3","ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⴰ, ⴰⵇⴰ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ: “ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵊⴰⵔ ⵉⵡⴷⴰⵏ, ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("S223_4","011_23_4","2SA","23","4","4","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵎ ⵜⴼⴰⵡⵜ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵅⵎⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⵓⴼⴼⵓⵜ ⴱⵍⴰ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⵄⴱⵓⴱⴱⵣⴻⵏ, ⵅⵎⵉ, ⵙ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵜⴼⴰⵡⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵥⴰⵔ, ⴰⵇⴰ ⵉⵙⵙⴼⵓⴼⴼⵓⵢ ⴰⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("S223_5","011_23_5","2SA","23","5","5","“ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵏⵏⵉ? ⴰⵇⴰ ⵉⴳⴳⴰ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ⵎⵙⴻⵜⵜⴻⴼ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓ ⵉⵜⵜⵡⴰⵃⴹⴰ. ⵇⴰⵄ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴰⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵖⴻⵎⵎⵉ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("S223_6","011_23_6","2SA","23","6","6","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵙⴻⵟⵟⴰ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵙ ⵓⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("S223_7","011_23_7","2SA","23","7","7","ⴰⵔⵢⴰⵣ ⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⵉⵃⴰⴷⴰ, ⴰⴷ ⵉⵃⴻⵣⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⵓⵣⵣⴰⵍ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵍⴰⵏⵙⴰ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S223_8","011_23_8","2SA","23","8","8","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ: ⵢⵓⵛⴰⵢⴱ ⴱⴰⵛⴰⴱⴱⴰⵜ, ⵎⵎⵉⵙ ⵏ ⴰⵜⴰⵀⴽⴰⵎⵓⵏⵉ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵏⴻⵖⵔⴰⴼⴻⵏ. ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷ ⵍⴻⵀⵣⵓⵟ ⵏⵏⴻⵙ, ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵖⵉ.    ");
INSERT INTO rift_vpl VALUES ("S223_9","011_23_9","2SA","23","9","9","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⴷⵓⴷⵓ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵓⵅⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵙⵜⴻⵀⵣⴰⵏ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⵓⵏⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⴰⵎ ⴳⴻⵄⵄⴷⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("S223_10","011_23_10","2SA","23","10","10","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵉⵡⵜⴰ ⴷⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵍ ⵢⵓⵃⴻⵍ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵉⵍⵚⴻⵇ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵉⴼ. ⵙⵉⴷⵉ ⵢⵉⵡⵉⴹ ⵉⵊⵊ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵄⴻⵇⴱⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S223_11","011_23_11","2SA","23","11","11","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵓⵙⴰ-ⴷⴷ ⵛⴰⵎⵎⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵊⵉ, ⴰⵀⴰⵔⴰⵔⵉ. ⵍⴰⵎⵉ ⵏⵏⵊⴰⵔⵡⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵍⴰⵅⵉ, ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵉⵢⵢⴰⵔ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⵄⴷⴻⵙ. ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S223_12","011_23_12","2SA","23","12","12","ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵓⵔⴻⵇⵇⵉⵄ ⵏ ⵉⵢⵢⴰⵔ ⵏⵏⵉ, ⵉⴼⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵓⵛⴰ ⵉⵖⵍⴻⴱ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⴰⵎⵎⵓ ⵢⴰⵔⵔⴰ ⴰⵙ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵡⴻⵖⵍⴰⴱ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("S223_13","011_23_13","2SA","23","13","13","ⵜⵍⴰⵜⴰ ⵣⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵀⵡⴰⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⵢⵔⴰ, ⴷⴻⴳ ⵉⴼⵔⵉ ⵏ ⴰⴱⴷⵓⵍⵍⴰⵎ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⴻⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S223_14","011_23_14","2SA","23","14","14","ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵍⴱⵉⵃⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("S223_15","011_23_15","2SA","23","15","15","ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵓⴼⴰⴷⵉ, ⵉⵏⵏⴰ: “ⵡⵉ ⴷ ⴰⵢⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵎⴰⵏ ⵣⵉ ⵜⴰⵍⴰ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("S223_16","011_23_16","2SA","23","16","16","ⵅⴻⵏⵏⵉ ⵛⵓⵇⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓⵢⵎⴻⵏ-ⴷⴷ ⴰⵎⴰⵏ ⵣⵉ ⵜⴰⵍⴰ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⴽⵙⵉⵏ ⵜⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ ⴰⴷ ⵜⴻⵏ ⵉⵙⵓ ⵓⵛⴰ ⵉⵣⴻⴵⴻⵄ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S223_17","011_23_17","2SA","23","17","17","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵢⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ. ⵎⴰ ⴰⴷ ⵙⵡⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵔⵓⵃⴻⵏ ⴰⵎ ⵙⴻⴱⴱⵍⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ?” ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵙⵓ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜ ⵉⴳⴳⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S223_18","011_23_18","2SA","23","18","18","ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵍⴰⵜⴰ ⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⵏⵏⴻⴹ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵅ ⵜⴻⵍⵜ-ⵎⵢⴰ, ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵉⵙⴻⵎ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⴻⵄ ⵊⴰⵔ ⵜⵍⴰⵜⴰ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("S223_19","011_23_19","2SA","23","19","19","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⵍⴰⵜⴰ-ⵢⴰ? ⵙ ⵓⵢⴰ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵏⵙⴻⵏ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵉⵡⵉⴹ ⵓⵍⴰ ⵖⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("S223_20","011_23_20","2SA","23","20","20","ⵅⴻⵏⵏⵉ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵡⴻⵔⵢⴰⵣ ⵉⵎⴻⵃⴹⴻⵏ, ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵎⵖⴰⵔⴻⵏⵜ, ⵏⴻⵜⵜⴰ ⵣⵉ ⵇⴰⴱⴹⵉⵢⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵔⴰⴷⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ. ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵉⵖⵍⴻⴱ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵎⵉ ⵉⵡⵜⴰ ⵡⴻⴷⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("S223_21","011_23_21","2SA","23","21","21","ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵓⵍⴰ ⵅ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵚⵔⵉ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⵙⴻⴳⴳⵯⴰⴷⴻⵏ. ⴰⵎⵉⵚⵔⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵍⴰⵏⵙⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵉⵀⵡⴰ ⵖⴰⵔⴻⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ, ⵉⴽⴽⴻⵙ ⵍⴰⵏⵙⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵎⵉⵚⵔⵉ ⵓ ⵉⵏⵖⴰ ⵉ-ⵜ ⵙ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S223_22","011_23_22","2SA","23","22","22","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⴳⴳⴰ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ⵙ ⵓⵢⴰ ⵖⴰⵔⴻⵙ ⵉⵙⴻⵎ ⵉⵛⵏⴻⵄ ⵊⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("S223_23","011_23_23","2SA","23","23","23","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⵍⴰⵜⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⵉⵡⴻⴹ ⴰⵍ ⵜⵍⴰⵜⴰ ⵉⵎⴻⵣⵡⵓⵔⴰ. ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵉ-ⵜ ⵊⴰⵔ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("S223_24","011_23_24","2SA","23","24","24","ⵜⵓⵖⴰ ⵄⴰⵙⴰ’ⵉⵍ, ⵓⵎⴰⵙ ⵏ ⵢⵓⵡⴰⴱ, ⵊⴰⵔ ⵜⵍⴰⵜⵉⵏ; ⵉⵍⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⵓⴷⵓ, ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ; ");
INSERT INTO rift_vpl VALUES ("S223_25","011_23_25","2SA","23","25","25","ⵛⴰⵎⵄⴰ, ⴰⵃⴰⵔⵓⴷⵉ; ⵉⵍⵉⵇⴰ, ⴰⵃⴰⵔⵓⴷⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_26","011_23_26","2SA","23","26","26","ⵀⴰⵍⴰⵚ, ⴰⴼⴰⵍⵟⵉ; ⵄⵉⵔⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵇⵇⵉⵛ, ⴰⵜⵉⵇⵇⵓⵄⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_27","011_23_27","2SA","23","27","27","ⴰⴱⵉⵄⴰⵣⴰⵔ, ⴰⵄⴰⵏⴰⵜⵓⵜⵉ; ⵎⴰⴱⵓⵏⵏⴰⵢ, ⴰⵃⵓⵛⴰⵢⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_28","011_23_28","2SA","23","28","28","ⵚⴰⵍⵎⵓⵏ, ⴰⵅⵓⵅⵉ; ⵎⴰⵀⵔⴰⵢ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_29","011_23_29","2SA","23","29","29","ⵅⴰⵍⴰⴱ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵏⴰ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ; ⵉⵜⵜⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴱⴰⵢ, ⵣⵉ ⵊⵉⴱⵄⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ; ");
INSERT INTO rift_vpl VALUES ("S223_30","011_23_30","2SA","23","30","30","ⴱⴰⵏⴰⵢⴰ, ⵣⵉ ⴼⵉⵔⵄⴰⵜⵓⵏ; ⵀⵉⴷⴷⴰⵢ, ⵣⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ ⵏ ⵊⴰⵄⴰⵛ; ");
INSERT INTO rift_vpl VALUES ("S223_31","011_23_31","2SA","23","31","31","ⴰⴱⵓ-ⵄⴰⵍⴱⵓⵏ, ⴰⵄⴰⵔⴰⴱⴰⵜⵉ; ⵄⴰⵣⵎⴰⵡⴻⵜ, ⴰⴱⴰⵔⵃⵓⵎⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_32","011_23_32","2SA","23","32","32","ⵉⵍⵢⴰⵃⴱⴰ, ⴰⵛⴰⵄⵍⵓⴱⵓⵏⵉ; ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵛⴰⵏ, ⵎⵖⵉⵔ ⵢⵓⵏⴰⵜⴰⵏ; ");
INSERT INTO rift_vpl VALUES ("S223_33","011_23_33","2SA","23","33","33","ⵛⴰⵎⵎⴰ, ⴰⵀⴰⵔⴰⵔⵉ; ⴰⵅⵉⵢⴰⵎ, ⵎⵎⵉⵙ ⵛⴰⵔⴰⵔ, ⴰⵔⴰⵔⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_34","011_23_34","2SA","23","34","34","ⵉⵍⵉⴼⴰⵍⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴰⵃⴰⵙⴱⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵓⵎⴰⵄⴽⵉ; ⵉⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴼⵉⵍ, ⴰⵊⵉⵍⵓⵏⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_35","011_23_35","2SA","23","35","35","ⵃⴰⵚⵔⴰⵢ, ⴰⴽⴰⵔⵎⴰⵍⵉ; ⴼⴰⵄⵔⴰⵢ, ⴰⵍⴰⵔⴱⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_36","011_23_36","2SA","23","36","36","ⵢⵉⵊⵄⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏ, ⵣⵉ ⵚⵓⴱⴰ; ⴱⴰⵏⵉ, ⴰⵊⴰⴷⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_37","011_23_37","2SA","23","37","37","ⵚⴰⵍⴰⵇ, ⴰⵄⴰⵎⵎⵓⵏⵉ; ⵏⴰⵃⵔⴰⵢ, ⴰⴱⵉⵄⵔⵓⵜⵉ, ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ; ");
INSERT INTO rift_vpl VALUES ("S223_38","011_23_38","2SA","23","38","38","ⵄⵉⵔⴰ, ⴰⵢⵉⵜⵔⵉ; ⵊⴰⵔⵉⴱ, ⴰⵢⵉⵜⵔⵉ; ");
INSERT INTO rift_vpl VALUES ("S223_39","011_23_39","2SA","23","39","39","ⵓⵔⵉⵢⴰ, ⴰⵃⵉⵜⵜⵉ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("S224_1","011_24_1","2SA","24","1","1","ⵜⵓⵖⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⴷⴰⵡⵓⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ ⴰⴷ ⵜⵃⴻⵙⴱⴻⴷ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("S224_2","011_24_2","2SA","24","2","2","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⵓⵡⴰⴱ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ: “ⴻⴽⴽ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵙⴻⴷⴷ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵖ ⵍⵇⴻⴷⴷ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("S224_3","011_24_3","2SA","24","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴰⴷ ⵢⴰⵔⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵟⵟⴰⵙ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵅⵅⵓ, ⵄⴰⴷ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵅⵅⵓ, ⵓ ⴻⵊⵊ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵓⵊⴻⴵⵉⴷ ⴰⵢⴰ. ⵎⴰⵛⴰ ⵉ ⵓⵎⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("S224_4","011_24_4","2SA","24","4","4","ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵀⴻⴷ ⵅ ⵢⵓⵡⴰⴱ ⵓ ⵅ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵢⵓⵡⴰⴱ ⴰⴽ-ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵢⴰⴳⴳⵯⴻⵊ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⴷⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("S224_5","011_24_5","2SA","24","5","5","ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵄⴰⵔⵓⵄⵉⵔ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵊⴰⴷ, ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵢⴰⵄⵣⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("S224_6","011_24_6","2SA","24","6","6","ⵓⵙⵉⵏ-ⴷⴷ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵓ ⴷⵉ ⵜⴰⵃⵜⵉⵎ-ⵃⵓⴷⵛⵉ. ⵅⴰⵙ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵏ-ⵢⴰⵄⴰⵏ ⵓ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵚⵉⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("S224_7","011_24_7","2SA","24","7","7","ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⵉ ⵉⴼⴰⵔⵢⴻⵏ ⵙ ⵉⵖⴻⴱⵍⴰⵡⴻⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⴽⴻⵏⵄⴰⵏⵉⵢⵢⴻⵏ, ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S224_8","011_24_8","2SA","24","8","8","ⴰⵎⵎⵓ ⴽⴽⵉⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⴰⵡⴰⵔⵏⵉ ⵄⴷⵓⵏ ⵜⴻⵙⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("S224_9","011_24_9","2SA","24","9","9","ⵓ ⵢⵓⵡⴰⴱ ⵉⵡⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵍⵇⴻⴷⴷ ⵏ ⵍⴻⵃⵙⴰⴱ ⵏ ⵍⴳⴻⵏⵙ. ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵜⴻⵎⵏ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ ⵓ ⵅⴻⵎⵙⴰ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("S224_10","011_24_10","2SA","24","10","10","ⵎⴰⵛⴰ ⵓⵍ ⵏ ⴷⴰⵡⵓⴷ ⵉⴱⴷⴰ ⴰⴷ ⵉⵔⴻⴷⴷⵓ ⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉⵃⵙⴻⴱ ⵍⴳⴻⵏⵙ ⵓ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵙⵉⴷⵉ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⵅⴰⴽ ⴰⵟⵟⴰⵙ ⵙ ⵎⵉⵏ ⴳⴳⵉⵖ. ⴰ ⵙⵉⴷⵉ, ⴽⴽⴻⵙ ⵍⴻⵅⵅⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("S224_11","011_24_11","2SA","24","11","11","ⵓⵎⵉ ⴷⴰⵡⵓⴷ ⵉⴽⴽⴰⵔ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵓⵏⴰⴱⵉ ⵊⴰⴷ, ⴰⵎⵡⴰⵍⴰⵡ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("S224_12","011_24_12","2SA","24","12","12","“ⵓⵢⵓⵔ, ⵙⵉⵡⴻⵍ ⵉ ⴷⴰⵡⵓⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴰⴷ ⴰⵛ ⴷⴷ-ⵙⵙⴰⵔⵙⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ. ⵉⵅⴹⴰⵔ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵜⵜ ⴳⴳⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("S224_13","011_24_13","2SA","24","13","13","ⵢⵓⵙⴰ-ⴷⴷ ⵊⴰⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵅⴻⴱⴱⴰⵔ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⴰⴷ ⵉⵡⴹⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ? ⵏⵉⵖ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⴹⴼⴰⵔ? ⵏⵉⵖ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⵟⵟⴰⵄⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ? ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵙⴻⵏ ⵎⵉⵏ ⵉ ⵖⴰ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵓ ⵅⵣⴰⵔ, ⵎⵉⵏ ⴷⴷ ⵖⴰ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("S224_14","011_24_14","2SA","24","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵊⴰⴷ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⴹⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵎⵖⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⵡⴹⵉⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("S224_15","011_24_15","2SA","24","15","15","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⴹ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵟⵟⴰⵄⵓⵏ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵜⵓⴼⴼⵓⵜ ⴰⵍ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ⵎⵎⵓⵜⴻⵏ ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("S224_16","011_24_16","2SA","24","16","16","ⵓⵎⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵍⵎⴰⵍⴰⴽ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵖⴹⴻⵍ ⵜⴰⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵓⴹⴻⵢⵢⴻⵄ, ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵏⵏⴰ ⵉ ⵍⵎⴰⵍⴰⴽ ⵉ ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⵖⴹⴻⵍ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵓⴹⴻⵢⵢⴻⵄ: “ⵛⴼⴰ, ⵙⴻⵀⵡⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵍⴻⵅⵅⵓ!” ⵜⵓⵖⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⴰⵡⴻⴹ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵢⴰⴱⵓⵙⵉ ⴰⵔⴰⵡⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("S224_17","011_24_17","2SA","24","17","17","ⵓⵎⵉ ⴷⴰⵡⵓⴷ ⵉⵥⵔⴰ ⵍⵎⴰⵍⴰⴽ ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵍⴳⴻⵏⵙ, ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⵓ ⵏⴻⵛⵛ, ⵡⴰⵀ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵎⴰⵛⴰ ⵓⴵⵉ-ⵢⴰ, ⵎⵉⵏ ⴳⴳⵉⵏ? ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⵜⴻⵛⵜⵉ ⵖⴰⵔⵉ ⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("S224_18","011_24_18","2SA","24","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴱⴻⵄⴷⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵊⴰⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⴳⴻⵄⵄⴻⴷ, ⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ ⵅ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵢⴰⴱⵓⵙⵉ ⴰⵔⴰⵡⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("S224_19","011_24_19","2SA","24","19","19","ⴷⴰⵡⵓⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵊⴰⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("S224_20","011_24_20","2SA","24","20","20","ⴰⵔⴰⵡⵏⴰ ⵉⵛⴻⵢⵢⴻⵄ ⵓ ⵉⵥⵔⴰ ⴰⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ. ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴰⵔⴰⵡⵏⴰ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S224_21","011_24_21","2SA","24","21","21","ⴰⵔⴰⵡⵏⴰ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵖⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ?” ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴽ ⵙⵖⴻⵖ ⴰⵏⴷⵔⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴱⵏⵉⵖ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴱⴻⴷⴷ ⵜⴻⵛⵜⵉ ⴷⵉ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("S224_22","011_24_22","2SA","24","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵔⴰⵡⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⴻⵊⵊ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⴽⵙⵉ ⵓ ⴰⴷ ⵉⵡⴻⵀⵀⴻⴱ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵅⵣⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⴽⵙⵉ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ ⴷ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("S224_23","011_24_23","2SA","24","23","23","ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴰⵔⴰⵡⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ.” ⵄⴰⵡⴻⴷ ⵉⵏⵏⴰ ⴰⵔⴰⵡⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵉⵍⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵛⴻⴽ ⵅ ⵍⵅⴰⴹⴰⵔ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("S224_24","011_24_24","2SA","24","24","24","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⵉ ⴰⵔⴰⵡⵏⴰ: “ⵍⵍⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵅⴰⴽ ⵜ ⵙⵖⴻⵖ ⵙ ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉⴽⵎⴻⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵡⴻⵀⵀⴱⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵡⴰⵍⵓ.” ⵓ ⴷⴰⵡⵓⴷ ⵉⵙⵖⴰ ⴰⵏⴷⵔⴰⵔ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵉ ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("S224_25","011_24_25","2SA","24","25","25","ⴷⴰⵡⵓⴷ ⵉⴱⵏⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⵉⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵖⵉⴵⴻⵜ. ⴰⵎⵎⵓ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵙⵉⴷⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵓ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵜⴻⵛⵜⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K11_1","012_1_1","1KI","1","1","1","ⵜⵓⵖⴰ ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⵡⵙⴰⵔ ⵓ ⵉⵎⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ. ⵙⵙⴷⵓⵔⵢⴻⵏ ⵜ ⵙ ⵡⴰⵔⵔⵓⴹ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⵍⵇⵉⴼ ⵄⴰⴷ ⵍⴻⵃⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("K11_2","012_1_2","1KI","1","2","2","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴻⵊⵊ ⴰⴷ ⴰⵔⵣⵓⵏ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵓ ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵀⵉⵍⵍⴰ. ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜᵉⵟⵟⴻⵚ ⵖⴰⵔ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵃⴻⵎⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("K11_3","012_1_3","1KI","1","3","3","ⴰⵔⵣⵓⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ⵓⴼⵉⵏ ⴰⴱⵉⵛⴰⵊ, ⵜⴰⵛⵓⵏⴰⵎⵉⵜ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K11_4","012_1_4","1KI","1","4","4","ⵜⴰⴱⵍⵉⵖⵜ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ ⴰⵟⵟⴰⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵀⵉⵍⵍⴰ ⴷⴰⵢⴻⵙ ⵓ ⵜⵙⴻⵅⵅⴰⵔ ⵅⴰⵙ. ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_5","012_1_5","1KI","1","5","5","ⴰⴷⵓⵏⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⵊⵉⵜ, ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⵓⵄⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ.” ⵏⴻⵜⵜⴰ ⵉⴹⴻⴱⴱⴰⵔ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵉⵣⵡⴰⵔⴻⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙ ⵜⴰⵣⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K11_6","012_1_6","1KI","1","6","6","ⴱⴰⴱⴰⵙ ⵜⵓⵖⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ?” ⵄⴰⵡⴻⴷ ⴰⴷⵓⵏⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ ⵉⵛⵏⴰ. ⵢⴻⵎⵎⴰⵙ ⵜⵓⵔⵓⵡ ⵜ-ⵉ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⴰⴱⵛⴰⵍⵓⵎ.    ");
INSERT INTO rift_vpl VALUES ("K11_7","012_1_7","1KI","1","7","7","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵓ ⴰⴽ-ⴷ ⴰⴱⵢⴰⵜⴰⵔ, ⴰⴽⴻⵀⵀⴰⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⴼⵓⵙ ⵉ ⴰⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_8","012_1_8","1KI","1","8","8","ⵎⴰⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴷ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴷ ⵛⵉⵎⵄⵉ ⴷ ⵔⵉⵄⵉ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵡⴰⵔ ⵇⵇⵉⵏⴻⵏ ⵛⴰ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_9","012_1_9","1KI","1","9","9","ⴰⴷⵓⵏⵉⵢⴰ ⵉⵖⴰⵔⵚ ⵉ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵍⵎⴰⵍ ⵉⵚⴻⵃⵃⴻⵏ ⵖⴰⵔ ⵡⴻⵥⵔⵓ ⵏ ⵣⴰⵃⵉⴼⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵔⵓⵊⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵄⴰⵔⴹ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K11_10","012_1_10","1KI","1","10","10","ⵎⴰⵛⴰ ⴰⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴷ ⴱⴰⵏⴰⵢⴰ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵓⵎⴰⵙ ⵙⵓⵍⵉⵎⴰⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵄⵔⵉⴹ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_11","012_1_11","1KI","1","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴰⵜⴰⵏ ⵉ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵛⴻⵎ, ⴰⵇⴰ ⴰⴷⵓⵏⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⵊⵉⵜ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ? ⴰⵇⴰ ⴷⴰⵡⵓⴷ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵡⴰⵔ ⵅⴰⵙ ⵢⴰⵔⴳⵉⴱ? ");
INSERT INTO rift_vpl VALUES ("K11_12","012_1_12","1KI","1","12","12","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵎ ⵡⵛⴻⵖ ⵛⵛⵡⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵎ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏ ⵎⵎⵉⵎ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K11_13","012_1_13","1KI","1","13","13","ⵓⵢⵓⵔ, ⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵉⵏⵉ ⴰⵙ: ‘ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉⴷ: ⵙ ⵜⵉⴷⴻⵜⵜ, ⵎⵎⵉⵎ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ? ⵎⴰⵢⴻⵎⵎⵉ ⵉⴷⵡⴻⵍ ⵅⴻⵏⵏⵉ ⴰⴷⵓⵏⵉⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ?’ ");
INSERT INTO rift_vpl VALUES ("K11_14","012_1_14","1KI","1","14","14","ⵅⵣⴰⵔ, ⵓⵎⵉ ⵛⴻⵎ ⴷⵉⵏⵏⵉ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵄⴰⴷ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⴰⴷⴼⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("K11_15","012_1_15","1KI","1","15","15","ⴱⴰⵜ-ⵛⴰⴱⴰⵄ ⵜⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ. ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵡⵙⴰⵔ ⴰⵟⵟⴰⵙ ⵓ ⴰⴱⵉⵛⴰⵊ, ⵜⴰⵙⵓⵏⴰⵎⵉⵜ, ⵜⵙⴻⵅⵅⴰⵔ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K11_16","012_1_16","1KI","1","16","16","ⴱⴰⵜ-ⵛⴰⴱⴰⵄ ⵜⵓⴹⴰⵔ, ⵜⴱⴻⵏⴷⴻⵇ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("K11_17","012_1_17","1KI","1","17","17","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵛⴻⴽ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵎ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("K11_18","012_1_18","1KI","1","18","18","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⴰⴷⵓⵏⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵓ ⵍⴻⵅⵅⵓ, ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵛⴻⴽ ⵡⴰⵔ ⵅⴰⵙ ⵜⴻⵙⵙⴰⵔⴳⵉⴱⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_19","012_1_19","1KI","1","19","19","ⵏⴻⵜⵜⴰ ⵉⵖⴰⵔⵚ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵍⵎⴰⵍ ⵉⵚⴻⵃⵃⴻⵏ ⴷ ⵡⵓⴵⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⵄⴰⵔⴹ ⵅ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵅ ⴰⴱⵢⴰⵜⴰⵔ, ⴰⴽⴻⵀⵀⴰⵏ, ⵓ ⵅ ⵢⵓⵡⴰⴱ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵙⵓⵍⵉⵎⴰⵏ, ⵡⴰⵔ ⵜ ⵉⵄⵔⵉⴹ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_20","012_1_20","1KI","1","20","20","ⵖⴰⵔⴻⴽ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵖⴰⵔⴻⴽ ⵛⴻⴽ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⵛⴻⴽ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_21","012_1_21","1KI","1","21","21","ⵏⵉⵖ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⴳⴳ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ.’” ");
INSERT INTO rift_vpl VALUES ("K11_22","012_1_22","1KI","1","22","22","ⵓ ⵅⵣⴰⵔ, ⴰⵎ ⵜⴻⵙⵙⴰⵡⴰⵍ ⵏⴻⵜⵜⴰⵜ ⵄⴰⴷ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⵢⵓⴷⴻⴼ-ⴷⴷ ⴰⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K11_23","012_1_23","1KI","1","23","23","ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⴰⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ.” ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K11_24","012_1_24","1KI","1","24","24","ⵉⵏⵏⴰ ⵏⴰⵜⴰⵏ: “ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵎⴰ ⵜⴻⵏⵏⵉⴷ ⵛⴻⴽ: ‘ⴰⴷⵓⵏⵉⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ’? ");
INSERT INTO rift_vpl VALUES ("K11_25","012_1_25","1KI","1","25","25","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ ⴰⵙⵙ-ⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵖⴰⵔⵚ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵍⵎⴰⵍ ⵉⵚⴻⵃⵃⴻⵏ ⴷ ⵡⵓⴵⵉ ⵓ ⵉⵄⴰⵔⴹ ⵅ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵅ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵅ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴱⵢⴰⵜⴰⵔ. ⵅⵣⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜᵉⵜⵜⴻⵏ, ⵙⴻⵙⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵇⵇⴰⵔⴻⵏ: ‘ⴰⴷ ⵉⴷⴷⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷⵓⵏⵉⵢⴰ!’ ");
INSERT INTO rift_vpl VALUES ("K11_26","012_1_26","1KI","1","26","26","ⵎⴰⵛⴰ ⵏⴻⵛⵛ, ⵏⴻⵛⵛ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴷ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵄⵔⵉⴹ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K11_27","012_1_27","1KI","1","27","27","ⵎⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵡⴰⵡⴰⵍ-ⴰ ⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ? ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⴰⵔⴳⵉⴱⴻⴷ ⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("K11_28","012_1_28","1KI","1","28","28","ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⵍⴰⵖⴰⵜ ⴰⵢⵉ-ⴷⴷ ⵅ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ!” ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵜⴱⴻⴷⴷ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K11_29","012_1_29","1KI","1","29","29","ⵅⴻⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("K11_30","012_1_30","1KI","1","30","30","ⵡⴰⵀ ⵏⵉⵛⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵎ ⵊⵊⵓⴵⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⵉⵖ: ‘ⴰⵇⴰ ⵎⵎⵉⵎ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵓ!’, ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ-ⵜ ⵖⴰ ⴳⴳⴻⵖ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("K11_31","012_1_31","1KI","1","31","31","ⵅⴰⵙ ⵓⵛⴰ ⵜⵓⴹⴰⵔ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴱⴻⵏⴷⴻⵇ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⵏⵏⴰ: “ⴰⴷ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵉ ⵍⴻⴱⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("K11_32","012_1_32","1KI","1","32","32","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ: “ⵍⴰⵖⴰⵜ ⴰⵢⵉ-ⴷⴷ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴷ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K11_33","012_1_33","1KI","1","33","33","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ: “ⴽⵙⵉⵎ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵡⴻⵎ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⴻⵊⵊ ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵉⵏⵉⵢ ⵅ ⵓⵙⴰⵔⴷⵓⵏ ⵉ ⵖⴰⵔⵉ ⵉⴵⴰⵏ ⵓ ⵙⴻⵀⵡⴰ ⵜ ⵖⴰⵔ ⵊⵉⵃⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K11_34","012_1_34","1KI","1","34","34","ⴻⵊⵊ ⴰⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴰⴽ-ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴰⴷ ⵜ ⵉⴷⵀⴻⵏ ⴷⵉⵏⵏⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵜⵓⴷⴰⵔⵜ ⵉ ⵙⵓⵍⵉⵎⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("K11_35","012_1_35","1KI","1","35","35","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵅ ⵢⴰⵀⵓⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K11_36","012_1_36","1KI","1","36","36","ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⴰⵎⵉⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ! ");
INSERT INTO rift_vpl VALUES ("K11_37","012_1_37","1KI","1","37","37","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴵⴰ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵏⴻⵜⵜⴰ ⵓⵍⴰ ⴰⴽ-ⴷ ⵙⵓⵍⵉⵎⴰⵏ. ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵄⴰⴷ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ!” ");
INSERT INTO rift_vpl VALUES ("K11_38","012_1_38","1KI","1","38","38","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴰⴽ-ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴷ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵓ ⴰⴽ-ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ⵏⵉⵜⵏⵉ ⵙⵙⴻⵏⵢⴻⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵅ ⵓⵙⴰⵔⴷⵓⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵓ ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵊⵉⵃⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K11_39","012_1_39","1KI","1","39","39","ⴰⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ, ⵉⴽⵙⵉ ⵉⵛⵛ ⵙ ⵣⵣⴻⵛⵜ ⵣⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵓⵛⴰ ⵉⴷⵀⴻⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⵏⵉⵜⵏⵉ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ: “ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("K11_40","012_1_40","1KI","1","40","40","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⴳⴻⵄⵄⴻⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵉⵡⴷⴰⵏ ⵚⴻⴼⴼⴰⵔⴻⵏ ⴷⵉ ⵜⵣⴰⵎⴰⵔⵉⵏ ⵓ ⴼⴰⵔⵃⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴻⵎⵖⴰⵔ ⴰⵍⴰⵎⵉ ⵜⴼⴻⴵⴻⵇ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵍⵃⴻⵙⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K11_41","012_1_41","1KI","1","41","41","ⵉⵙⵍⴰ ⴰⵢⴰ ⴰⴷⵓⵏⵉⵢⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴱⵃⵍⴰ ⵎⵎⵓⵏⵙⵡⴻⵏ. ⵓⵍⴰ ⴷ ⵢⵓⵡⴰⴱ ⵉⵙⵍⴰ ⵉ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵉⵏⵏⴰ: “ⵎⴰⵏⴰ ⵍⵃⴻⵙⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵎⵎⵓ ⵙ ⵣⵣⵀⵉⵔ ⴰⵟⵟⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("K11_42","012_1_42","1KI","1","42","42","ⴰⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵏⴻⵜⵜⴰ ⵄⴰⴷ, ⵢⵓⵙⴰ-ⴷⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴱⵢⴰⵜⴰⵔ. ⴰⴷⵓⵏⵉⵢⴰ ⵉⵏⵏⴰ: “ⴰⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵎⴻⵃⴹⴻⵏ. ⵛⴻⴽ ⴰⴷ ⵜⴰⵡⵢⴻⴹ ⵏⵉⵛⴰⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K11_43","012_1_43","1KI","1","43","43","ⵢⵓⵏⴰⵜⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⵉ ⴰⴷⵓⵏⵉⵢⴰ: “ⵙ ⵍⴻⵎⵇⵍⵓⴱ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K11_44","012_1_44","1KI","1","44","44","ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⴽⴽ ⴰⴽⵉⴷⴻⵙ ⴰⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴷ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵓ ⵉⵏⴰ ⴳⴳⵉⵏ ⵜ ⴰⴷ ⵉⵏⵉⵢ ⵅ ⵓⵙⴰⵔⴷⵓⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K11_45","012_1_45","1KI","1","45","45","ⴰⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⴷⴻⵀⵏⴻⵏ ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵊⵉⵃⵓⵏ ⵓ ⵙⵙⴻⵏⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⵍⴰⵎⵉ ⵜⴻⵀⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵢⴰ ⴷ ⵍⵃⴻⵙⵙ ⵉ ⵜⴻⵙⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K11_46","012_1_46","1KI","1","46","46","ⵓⵍⴰ ⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("K11_47","012_1_47","1KI","1","47","47","ⵓⵍⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵙⵉⵏ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⴽⴻⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: ‘ⵉⵍⵉ ⴰⴷ ⵢⴰⵔⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵉⵙⴻⵎ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵄⴰⴷ ⵉⵛⵏⴰ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵢⴰⵔⵔ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵄⴰⴷ ⵉⵎⵖⴰⵔ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ.’ ⵅⴰⵙ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵓⵊⴻⴵⵉⴷ ⵅ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K11_48","012_1_48","1KI","1","48","48","ⵄⴰⵡⴻⴷ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: ‘ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴰⵙⵙ-ⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵊⵊⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ, ⵓⵎⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵄⴰⴷ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⵜⵡⴰⵍⴰⵏⵜ ⴰⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("K11_49","012_1_49","1KI","1","49","49","ⵎⴰⵔⵔⴰ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⴷⵓⵏⵉⵢⴰ ⵏⵏⵅⴻⵍⵄⴻⵏ, ⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵢⵓⵢⵓⵔ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K11_50","012_1_50","1KI","1","50","50","ⴰⴷⵓⵏⵉⵢⴰ ⵉⴳⴳⵯⴻⴷ ⵣⵉ ⵙⵓⵍⵉⵎⴰⵏ. ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵢⵓⵢⵓⵔ ⵓⵛⴰ ⵉⵛⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K11_51","012_1_51","1KI","1","51","51","ⵅⴻⴱⴱⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⴰⴷⵓⵏⵉⵢⴰ, ⵉⴳⴳⵯⴻⴷ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵛⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵇⵇⴰⵔ: ‘ⴻⵊⵊ ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⴰⵢⵉ ⵉⵊⵊⴰⴵ ⴰⵙⵙ-ⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵏⴻⵇⵇ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵙ ⵙⵙⵉⴼ!’” ");
INSERT INTO rift_vpl VALUES ("K11_52","012_1_52","1KI","1","52","52","ⵉⵏⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ: “ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴰⵏ-ⴷⴷ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵡⴻⵟⵟⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⵟⵟⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴼ ⴷⴰⵢⴻⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("K11_53","012_1_53","1KI","1","53","53","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⴻⴽⴽ ⵛⴰ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴽⴻⵙⵙⵉⵏ ⵜ ⵣⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ. ⵉⵏⵏⴰ ⴰⵙ ⵙⵓⵍⵉⵎⴰⵏ: “ⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("K12_1","012_2_1","1KI","2","1","1","ⵓⵎⵉ ⴷⴷ-ⵓⴷⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵉⵄⵍⴻⵎ ⵏⴻⵜⵜⴰ ⵉ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K12_2","012_2_2","1KI","2","2","2","“ⵏⴻⵛⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴰⴱⵔⵉⴷ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ ⵓ ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ! ");
INSERT INTO rift_vpl VALUES ("K12_3","012_2_3","1KI","2","3","3","ⵃⴹⴰ ⴰⵡⴻⴽⴽⴻⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵙ ⵍⴻⵄⵇⴻⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴷ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("K12_4","012_2_4","1KI","2","4","4","ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉ ⵅⴰⴼⵉ ⵉⵙⵙⵉⵡⴻⵍ, ⵓⵎⵉ ⵉⵏⵏⴰ: ‘ⵎⴰⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵃⴹⴰⵏ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵓ ⵙ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵙ ⵍⴰⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴻⵔⵢⴰⵣ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K12_5","012_2_5","1KI","2","5","5","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵎⵉⵏ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⵓ ⵉ ⵄⴰⵎⴰⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵜⵉⵔ. ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵀⵏⴰ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵉⴷⴰⵎⵎⴻⵏ ⴰⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴰⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉⴳⴳⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵖⴰⵔ ⵡⴻⴱⵢⴰⵙ ⵏⵏⴻⵙ ⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⵖⴰⵔ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K12_6","012_2_6","1KI","2","6","6","ⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⵉⵛⴰⴱⴻⵏ ⴰⴷ ⵉⵀⵡⴰ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K12_7","012_2_7","1KI","2","7","7","ⵙⵛⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ ⵣⵉ ⵊⵉⵍⵄⴰⴷ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵣⵉ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔⵉ ⵓⵎⵉ ⴰⵔⴻⵡⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵎⴰⵛ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K12_8","012_2_8","1KI","2","8","8","ⵅⵣⴰⵔ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵔⴰ, ⵣⴻⴳ ⴰⵢⵜ ⵏⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵣⵉ ⴱⴰⵅⵓⵔⵉⵎ. ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⴻⴽ. ⵏⴻⵜⵜⴰ ⵉⵏⵄⴻⵍ ⴰⵢⵉ ⵙ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵉⵇⴻⵙⵃⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵏⴻⵛⵛ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ, ⵎⴰⵛⴰ ⵉⵎⵎⵙⴻⵍⵇⴰ ⴰⴽⵉⴷⵉ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⴰⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵏⵏⵉⵖ: ‘ⵖⴰⵔⵉ ⵎⴰⵍⴰ ⴰⴷ ⵛⴻⴽ ⵏⵖⴻⵖ ⵙ ⵙⵙⵉⴼ!’ ");
INSERT INTO rift_vpl VALUES ("K12_9","012_2_9","1KI","2","9","9","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵜ ⵃⴻⵚⵚⴻⴱ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵖⵉⵙ ⵓ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⵃⵉⵎⴰ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⵉⵛⴰⴱⴻⵏ ⴰⴷ ⵉⵀⵡⴰ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⵙ ⵉⴷⴰⵎⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K12_10","012_2_10","1KI","2","10","10","ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K12_11","012_2_11","1KI","2","11","11","ⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⴻⵎ ⴷⴰⵡⵓⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵃⴽⴻⵎ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K12_12","012_2_12","1KI","2","12","12","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ ⵓ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵜⴻⴷⵡⴻⵍ ⵜⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵍⴻⵎⵜⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K12_13","012_2_13","1KI","2","13","13","ⵅⴻⵏⵏⵉ ⴰⴷⵓⵏⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⵊⵉⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵎⴰ ⵜⴰⵡⴰⵙⵉⵜ ⵏⵏⴻⵛ ⵙ ⵍⴻⵀⵏⴰ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵍⴻⵀⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("K12_14","012_2_14","1KI","2","14","14","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴽⵉⵎ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ.” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵙⵉⵡⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("K12_15","012_2_15","1KI","2","15","15","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵛⴻⵎ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵜⵓⵙⴰ ⴰⵢⵉ-ⴷⴷ ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⴳⴳⴰ ⴷⴰⵢⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵎⴰⵛⴰ ⵜⴰⴳⴻⵍⴷⴰ ⵜⴻⵏⵏⴻⵇⵍⴻⴱ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵉ ⵓⵎⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K12_16","012_2_16","1KI","2","16","16","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵅⵙⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵎ ⵜⵜⴰⵔⴻⵖ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵀⴰ. ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴰⴳⵉ!” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: ⴰⵙ: “ⵙⵉⵡⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("K12_17","012_2_17","1KI","2","17","17","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ - ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵛⴻⵎ ⵉⵜⵜⴰⵔⵔⵉ - ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴰⴱⵉⵛⴰⵊ, ⵜⴰⵙⵓⵏⴰⵎⵉⵜ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K12_18","012_2_18","1KI","2","18","18","ⴱⴰⵜ-ⵛⴰⴱⴰⵄ ⵜⴻⵏⵏⴰ: “ⵎⵍⵉⵃ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K12_19","012_2_19","1KI","2","19","19","ⵅⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵅ ⴰⴷⵓⵏⵉⵢⴰ. ⴰⵊⴻⴵⵉⴷ ⵉⴽⴽⴰⵔ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ, ⵢⵓⴹⴰⵔ ⵣⵣⴰⵜⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ, ⵉⵊⵊⴰ ⴰⴷ ⴷⵉⵏ ⵙⵙⴰⵔⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⴽⵓⵔⵙⵉ ⵉ ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⵇⵉⵎ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K12_20","012_2_20","1KI","2","20","20","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰⵜ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴰⵛ ⵜⵜⴰⵔⴻⵖ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵀⴰ. ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴰⴳⵉ!” ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵙⴻⵇⵙⴰ, ⵢⴻⵎⵎⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⴰⵔⵔⵉⵖ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("K12_21","012_2_21","1KI","2","21","21","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⴰⴱⵉⵛⴰⵊ, ⵜⴰⵙⵓⵏⴰⵎⵉⵜ, ⵉ ⵓⵎⴰⵛ ⴰⴷⵓⵏⵉⵢⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K12_22","012_2_22","1KI","2","22","22","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ ⵉ ⵢⴻⵎⵎⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵛⴻⵎ ⵉ ⴰⴷⵓⵏⵉⵢⴰ ⴰⴱⵉⵛⴰⵊ, ⵜⴰⵙⵓⵏⴰⵎⵉⵜ? ⵜⵜⴰⵔ ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵜⴰⴳⴻⵍⴷⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅⴰⴼⵉ, ⵡⴰⵀ ⵜⵜⴰⵔ ⵉ-ⵜⵜ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴱⵢⴰⵜⴰⵔ ⴷ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("K12_23","012_2_23","1KI","2","23","23","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⴰⵔⴻⴱⴱⵉ ⵜⴰ ⴷ ⵜⴰ ⵓ ⵄⴰⴷ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵖⴰⵔ ⴰⴷⵓⵏⵉⵢⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵡⴰⵍ-ⴰ ⴹⵉⴷⴷ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("K12_24","012_2_24","1KI","2","24","24","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵎⵜⵏⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵖⵉⵎⴰⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵇⴱⴻⵍ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⴷⵓⵏⵉⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⴰⵙⵙ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("K12_25","012_2_25","1KI","2","25","25","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵍⵓⵎⵓⵔ-ⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ⵡⴰⵏⵉⵜⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴰⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K12_26","012_2_26","1KI","2","26","26","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴱⵢⴰⵜⴰⵔ: “ⵓⵢⵓⵔ ⵖⴰⵔ ⵄⴰⵏⴰⵜⵓⵜ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⴷⴰⵃⴻⴵ ⵍⵎⴻⵡⵜ. ⴰⵙⵙ-ⴰ ⵎⴰⵛⴰ ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⵇⵇⴻⵖ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴰⵔⴱⵓⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵓ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵡⴻⴷⴷⴱⴻⴷ ⵓⵍⴰ ⵙ ⵎⴰⵔⵔⴰ ⵉ ⵣⵉ ⵉⵡⴻⴷⴷⴻⴱ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("K12_27","012_2_27","1KI","2","27","27","ⵙⵓⵍⵉⵎⴰⵏ ⵢⵓⵥⵥⴻⵍ ⵅ ⴰⴱⵢⴰⵜⴰⵔ ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵄⴰⴷ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⴰⵍⵉ ⴷⵉ ⵛⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("K12_28","012_2_28","1KI","2","28","28","ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵍⴻⵅⴱⴰⵔ ⵖⴰⵔ ⵢⵓⵡⴰⴱ - ⴰⵇⴰ ⵢⵓⵡⴰⴱ ⵉⴼⴼⴻⵖ, ⵉⴹⴼⴰⵔ ⴰⴷⵓⵏⵉⵢⴰ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴹⴼⴰⵔ ⴰⴱⵛⴰⵍⵓⵎ - ⵢⴰⵔⵡⴻⵍ ⵢⵓⵡⴰⴱ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K12_29","012_2_29","1KI","2","29","29","ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴰⵇⴰ ⵢⵓⵡⴰⴱ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵙⵉⴷⵉ. ⵓ ⵅⵣⴰⵔ, ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ. ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⴻⵙ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵉⵏⵏⴰ: “ⵔⵓⵃ ⴷⵉⵏ, ⵏⴻⵖ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("K12_30","012_2_30","1KI","2","30","30","ⴱⴰⵏⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ‘ⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ!’” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵍⵍⴰ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵎⵎⵜⴻⵖ ⴷⴰ!” ⴱⴰⵏⴰⵢⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵜⴰⵎⵡⴰⵔⵔⵉⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵢⵓⵡⴰⴱ ⵓ ⴰⵎⵎⵓ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("K12_31","012_2_31","1KI","2","31","31","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⴻⴳⴳ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ, ⵖⴻⴹⵍ ⵉ-ⵜ ⵓⵛⴰ ⵏⴻⴹⵍ ⵉ-ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴳⴳⵯⴻⵊⴻⴷ ⵅⴰⴼⵉ ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵢⵓⵡⴰⴱ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K12_32","012_2_32","1KI","2","32","32","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵏⴻⵜⵜⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⵉⵃⵍⴰⵏ ⵅⴰⵙ, ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ ⵙ ⵙⵙⵉⴼ ⵓⵎⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ: ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵄⴰⵎⴰⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵜⵉⵔ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K12_33","012_2_33","1KI","2","33","33","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵄⴻⵇⴱⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵡⴰⴱ ⵓ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵣⵉ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K12_34","012_2_34","1KI","2","34","34","ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵡⵜⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("K12_35","012_2_35","1KI","2","35","35","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵅⴻⵏⵏⵉ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵚⴰⴷⵓⵇ, ⴰⴽⴻⵀⵀⴰⵏ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⴱⵢⴰⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K12_36","012_2_36","1KI","2","36","36","ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⵛⵉⵎⵄⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⴱⵏⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵣⴷⴻⵖ ⴷⵉⵏ, ⵡⴰⵔ ⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴷⴰ ⵓⵍⴰ ⵖⴰⵔ ⴷⵉⵀⴰ! ");
INSERT INTO rift_vpl VALUES ("K12_37","012_2_37","1KI","2","37","37","ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⴼⴼⵖⴻⴷ, ⴰⴷ ⵜⴻⵥⵡⵉⴷ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ, ⴰⵇⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵏⵉⵛⴰⵏ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵏⵀⵍⴰ ⵎⵎⴰ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K12_38","012_2_38","1KI","2","38","38","ⵛⵉⵎⵄⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵓⵊⴻⴵⵉⴷ: “ⴰⵡⴰⵍ-ⴰ ⴷ ⵍⴻⵎⵍⵉⵃ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴳⴳ ⵓⵍⴰ ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ⵓ ⵛⵉⵎⵄⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K12_39","012_2_39","1KI","2","39","39","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵛⵉⵎⵄⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴰⵅⵉⵛ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴽⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵜ. ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⵛⵉⵎⵄⵉ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵊⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("K12_40","012_2_40","1KI","2","40","40","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵛⵉⵎⵄⵉ, ⵉⴱⴰⵔⴷⴻⵄ ⵉ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴰⵅⵉⵛ ⵖⴰⵔ ⵊⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵛⵉⵎⵄⵉ ⵢⵓⵢⵓⵔ ⴷⵉⵏ ⵓ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵣⵉ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K12_41","012_2_41","1KI","2","41","41","ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴰⵇⴰ ⵛⵉⵎⵄⵉ ⵉⴼⴼⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵊⴰⵜ ⵓⵛⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("K12_42","012_2_42","1KI","2","42","42","ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⴽⴽ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⵛⵉⵎⵄⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵊⵊⵉⵖ ⴰⴷ ⵜⴻⵊⵊⴰⴵⴻⴷ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵄⴻⵍⵎⴻⵖ ⴰⵛ, ⵏⵏⵉⵖ: ‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⴷⴰ ⵏⵉⵖ ⵖⴰⵔ ⴷⵉⵀⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵏⵉⵛⴰⵏ, ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵏⵃⵍⴰ ⵎⵎⴰ’? ⵓ ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ ⴰⵢⵉ: ‘ⴰⵡⴰⵍ-ⴰ ⵉ ⵙⵍⵉⵖ, ⴰⵇⴰ-ⵜ ⵎⵍⵉⵃ.’ ");
INSERT INTO rift_vpl VALUES ("K12_43","012_2_43","1KI","2","43","43","ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵛⴰ ⵜⴰⵊⴰⴵⵉⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⵓⵎⵓⵔ ⵉ ⴷ ⴰⵛ ⴳⴳⵉⵖ?” ");
INSERT INTO rift_vpl VALUES ("K12_44","012_2_44","1KI","2","44","44","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵄⴰⵡⴻⴷ ⵉ ⵛⵉⵎⵄⵉ: “ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵜⴻⴳⴳⵉⴷ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵛ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K12_45","012_2_45","1KI","2","45","45","ⵎⴰⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("K12_46","012_2_46","1KI","2","46","46","ⵅⴰⵙ ⵓⵛⴰ ⵉⴹⴻⴱⴱⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵅ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵓ ⵡⴰⵏⵉⵜⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵡⵜⴰ ⵛⵉⵎⵄⵉ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵡⴰⵏⵉⵜⴰ. ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⵛⴻⴷⴷ ⵜⴳⴻⵍⴷⵉⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K13_1","012_3_1","1KI","3","1","1","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓⵛⴰ ⵉⵙⵙⵉⴷⵉⴼ ⵉ-ⵜⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵇⴼⴻⵍ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⵃⵉⴹ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K13_2","012_3_2","1KI","3","2","2","ⵎⵖⵉⵔ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵏⵉ ⵉⵜⵜⵇⴻⴷⴷⴰⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵡⴰⵀⴰ, ⵎⵉⵏⵣⵉ ⴰⵍ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴱⴻⵏⵏⵉ ⵄⴰⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K13_3","012_3_3","1KI","3","3","3","ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵙⵉⴷⵉ ⵓⵎⵉ ⵢⵓⵢⵓⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵉⵇⴻⴷⴷⴻⵎ ⵎⵖⵉⵔ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("K13_4","012_3_4","1KI","3","4","4","ⴰⵎⵎⵓ ⵉ ⵢⵓⵢⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵖⴰⵔⵚ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵇⴰⵄ. ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⴰⵍⴻⴼ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("K13_5","012_3_5","1KI","3","5","5","ⵉⴱⴰⵏ-ⴷⴷ ⵙⵉⴷⵉ ⴷⵉ ⵊⵉⴱⵄⵓⵏ ⵙ ⴵⵉⵍⴻⵜ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵔⵊⵉⵜ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⵜⵜⴰⵔ! ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("K13_6","012_3_6","1KI","3","6","6","ⵉⵏⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ: “ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵙ ⵍⴰⵎⴰⵏ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⵖⴰⵔⴻⴽ, ⵓ ⵛⴻⴽ ⵜⵅⴻⵎⵎⵍⴻⴷ ⴰⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ-ⴰ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K13_7","012_3_7","1KI","3","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴵⵉⵖ ⵄⴰⴷ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⴰⵎⴻⵥⵢⴰⵏ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴼⴼⵖⴻⵖ ⵓ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵄⴻⵇⴱⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K13_8","012_3_8","1KI","3","8","8","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵛⴻⴽ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷ ⵏⵉⵖ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴻⵙⵙⴻⴱ ⵣⴻⴳ ⵓⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K13_9","012_3_9","1KI","3","9","9","ⴻⵡⵛ ⵅⴻⵏⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵉⴼⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴼ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵃⴽⴻⵎ ⴷⵉ ⵍⴳⴻⵏⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴰⵔⵣ ⵙ ⵍⴻⵄⵇⴻⵍ ⵊⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵛⵏⴰ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("K13_10","012_3_10","1KI","3","10","10","ⴰⵡⴰⵍ-ⴰ ⵜⵓⵖⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵍⴰⵎⵉ ⵣⴻⵄⵎⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵜⵜⴰⵔ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K13_11","012_3_11","1KI","3","11","11","ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ: “ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜᵉⵜⵜⴰⵔⴻⴷ ⴰⵢⴰ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵛⴰ ⵜⵓⴷⴰⵔⵜ ⵜⴰⵣⵉⵔⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⴷ ⴰⴳⵍⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵛⴰ ⵜⵓⴷⴰⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵍⴻⵄⵇⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵎⵍⵉⵃ ⴷⴷⴻⵄⵡⴰⵜ ⴷⵉ ⵍⵎⴻⵃⴽⴰⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("K13_12","012_3_12","1KI","3","12","12","ⴰⵇⴰ ⵙ ⵓⵢⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵄⵍⴰⵃⵚⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵛ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷ ⴰⴼⴻⵀⵀⴰⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵜⵓⵖⵉ ⵇⴱⴻⵍ ⵉ ⵛⴻⴽ ⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("K13_13","012_3_13","1KI","3","13","13","ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⴷ, ⴰⴷ ⴰⵛ ⵜ ⵡⵛⴻⵖ, ⴰⵎ ⵡⴰⴳⵍⴰ ⴰⵎ ⵓⵄⵓⴵⵉ, ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵛⴻⴽ ⵊⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K13_14","012_3_14","1KI","3","14","14","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵅ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵢⵓⵔ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵣⵓⴳⴳⴰⵔⴻⵖ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K13_15","012_3_15","1KI","3","15","15","ⵉⴼⴰⵇ-ⴷⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵓ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵔⵊⵉⵜ. ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵓ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵉⴳⴳⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⵓ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K13_16","012_3_16","1KI","3","16","16","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵜⵓⵖⴰ-ⵜⴻⵏⵜ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴱⴻⴷⴷⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K13_17","012_3_17","1KI","3","17","17","ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⴰ: “ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵣⴻⴷⴷⵖⴻⵖ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵉⵛⵜ, ⵓ ⵏⴻⵛⵛ ⵓⵔⵡⴻⵖ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K13_18","012_3_18","1KI","3","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵓⵔⵡⴻⵖ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⵎⵓⵏ, ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⵖⵉⵔ ⵏⴻⵛⵛⵉⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K13_19","012_3_19","1KI","3","19","19","ⴰⵃⴻⵏⵊⵉⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ ⵉⵎⵎⵓⵜ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓⵎⵉ ⵜⴻⵣⵣⴻⵍ ⵅⴰⵙ ⴷⴻⴳ ⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("K13_20","012_3_20","1KI","3","20","20","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⴽⴰⵔ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵜⴻⴽⴽⴻⵙ ⴰⵢⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ, ⵓⵎⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵜᵉⵟⵟⴻⵚ, ⵓ ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵎⵎⵉⵙ ⵉⵎⵎⵓⵜⴻⵏ ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("K13_21","012_3_21","1KI","3","21","21","ⵓⵎⵉ ⴽⴽⴰⵔⴻⵖ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⵟⵟⵓⴹⴻⵖ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ, ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ. ⴷⵉ ⵚⵚⴱⴻⵃ ⵜⵓⵖⴰ ⴰⵢⵉ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵎⵍⵉⵃ, ⵥⵔⵉⵖ ⵜⵓⵖⴰ-ⵜ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ ⵏⵏⵉ ⴷⴷ-ⵓⵔⵡⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("K13_22","012_3_22","1KI","3","22","22","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵖⵏⵉⵜ: “ⵍⵍⴰ, ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ ⵓ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵎ!” ⵜⴻⵏⵏⴻⵖⵏⵉⵜ ⵜⴻⵏⵏⴰ: “ⵍⵍⴰ, ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵎ ⵓ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ!” ⴰⵎⵎⵓ ⵉ ⵙⵙⵉⵡⵍⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K13_23","012_3_23","1KI","3","23","23","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵜⴰⵏⵉⵜⴰ ⵜⴻⵇⵇⴰⵔ: ‘ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ ⵓ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵎ!’, ⵓⵛⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵜⴻⵇⵇⴰⵔ: ‘ⵍⵍⴰ, ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵎ ⵓ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("K13_24","012_3_24","1KI","3","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴰⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ!” ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K13_25","012_3_25","1KI","3","25","25","ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵇⴻⵙⵙⴻⵎ ⴰⵃⴻⵏⵊⵉⵔ ⵉⴷⴷⴰⵔⴻⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵡⵛⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵉ ⵢⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵓ ⵡⵛⴻⵎ ⵉ ⵜᵉⵏⵏⴻⵖⵏⵉⵜ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("K13_26","012_3_26","1KI","3","26","26","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⴰⵛⵉⵜ ⵏⵏⴻⵙ ⵉ ⵓⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔ, ⵜⴻⵙⵙⵉⵡⴻⵍ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵃⴻⵏⵊⵉⵔ ⵉⴷⴷⴰⵔ, ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⵏⵏⴰ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⵛⴻⵜ ⴰⵙ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⵡⴰⵔ ⵜ ⵏⴻⵇⵇⴻⵜ!” ⵜⴰⵏⵉⵜⴰ ⵎⴰⵛⴰ ⵜⴻⵏⵏⴰ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⵏⵓ ⵓⵍⴰ ⵏⵏⴻⵎ. ⵇⴻⵙⵙⴻⵜ ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ!” ");
INSERT INTO rift_vpl VALUES ("K13_27","012_3_27","1KI","3","27","27","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵡⵛⴻⵎ ⴰⵙ ⴰⵃⴻⵏⵊⵉⵔ ⵉⴷⴷⴰⵔⴻⵏ! ⵡⴰⵔ ⵜ ⵏⴻⵇⵇⴻⵎ. ⵏⴻⵜⵜⴰⵜ ⴷ ⵢⴻⵎⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("K13_28","012_3_28","1KI","3","28","28","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵍⴰ ⵅ ⵍⴻⵃⴽⴰⵎ ⵉ ⵣⵉ ⵉⵃⴽⴻⵎ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⴱⴻⵍⵍⵉ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵢⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K14_1","012_4_1","1KI","4","1","1","ⵜⵓⵖⴰ ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K14_2","012_4_2","1KI","4","2","2","ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ: ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K14_3","012_4_3","1KI","4","3","3","ⵉⵍⵉⵃⵓⵔⴰⴼ ⴷ ⴰⵅⵉⵢⴰ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵛⵉⵛⴰ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴰⵔⵉⵔⴻⵏ. ⵢⴰⵃⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵍⵓⴷ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵔⵉⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K14_4","012_4_4","1KI","4","4","4","ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵄⴻⵙⴽⴰⵔ. ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K14_5","012_4_5","1KI","4","5","5","ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵡⵓⵍⴰⵜ. ⵣⴰⴱⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵡⴽⵉⵍ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K14_6","012_4_6","1KI","4","6","6","ⴰⵅⵉⵛⴰⵔ ⵜⵓⵖⴰ-ⵜ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⴰⴷⵓⵏⵉⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⴱⴷⴰ ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵊⵉⵣⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K14_7","012_4_7","1KI","4","7","7","ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔⴻⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⵡⵓⵍⴰⵜ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵓⵢⵓⵔ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵜⵓⵖⴰ ⵅⴰⵙ ⴰⴷ ⵜ ⵉⴽⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("K14_8","012_4_8","1KI","4","8","8","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K14_9","012_4_9","1KI","4","9","9","ⵎⵎⵉⵙ ⵏ ⴷⴰⵇⴰⵔ ⴷⵉ ⵎⴰⵇⴰⵙ ⵓ ⴷⵉ ⵛⴰⵄⴰⵍⵓⴱⴱⵉⵎ, ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⴷ ⵉⵍⵓⵏ-ⴱⴰⵢⵜ-ⵃⴰⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K14_10","012_4_10","1KI","4","10","10","ⵎⵎⵉⵙ ⵏ ⵃⴰⵙⴰⴷ ⴷⵉ ⴰⵔⵓⴱⵓⵜ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⵓⴽⵓ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵃⴰⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K14_11","012_4_11","1KI","4","11","11","ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵏ ⴷⵓⵔ. ⵜⴰⴼⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵜⵓⵖⴰ-ⵜⵜ ⵖⴰⵔⴻⵙ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K14_12","012_4_12","1KI","4","12","12","ⴱⴰⵄⵏⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵍⵓⴷ, ⵖⴰⵔⴻⵙ ⵜⴰⵄⵏⴰⴽ, ⵎⴰⵊⵉⴷⴷⵓ ⴷ ⵎⴰⵔⵔⴰ ⴱⴰⵢⵜ-ⵛⴰⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵚⵓⵔⵜⴰⵏ, ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵣⵉ ⴱⴰⵢⵜ-ⵛⴰⵏ ⴰⵍ ⴰⴱⴰⵍ-ⵎⴰⵃⵓⵍⴰ, ⴰⵍ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵢⵓⵇⵎⴰⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K14_13","012_4_13","1KI","4","13","13","ⵎⵎⵉⵙ ⵏ ⵊⴰⴱⴰⵔ ⵜⵓⵖⴰ ⴷⵉ ⵔⴰⵎⵓⵜ-ⵊⵉⵍⵄⴰⴷ. ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰ’ⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵓⵍⴰ ⴷ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵔⵊⵓⴱ, ⵜⴻⵏⵏⵉ ⴷⵉ ⴱⴰⵛⴰⵏ, ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵎⵖⴰⵔⴻⵏⵜ ⵙ ⵍⵃⵉⴹ ⵓ ⵙ ⵣⵣⴻⴽⵔⵓⵏ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K14_14","012_4_14","1KI","4","14","14","ⴰⵅⵉⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵄⵉⴷⴷⵓ, ⵖⴰⵔⴻⵙ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K14_15","012_4_15","1KI","4","15","15","ⴰⵅⵉⵎⴰⵄⴰⵚ ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵡⴰⵍⵉ ⴷⵉ ⵏⴰⴼⵜⴰⵍⵉ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵓⵍⴰ ⴱⴰⵙⵉⵎⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K14_16","012_4_16","1KI","4","16","16","ⴱⴰⵄⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵀⵓⵛⴰⵉ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵡⴰⵍⵉ ⴷⵉ ⴰⵛⵉⵔ ⵓ ⴷⵉ ⴱⴰⵄⴰⵍⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K14_17","012_4_17","1KI","4","17","17","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵔⵓⵃ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵡⴰⵍⵉ ⴷⵉ ⵉⵙⵙⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K14_18","012_4_18","1KI","4","18","18","ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵉⵢⵍⴰ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵡⴰⵍⵉ ⴷⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K14_19","012_4_19","1KI","4","19","19","ⵊⴰⴱⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵡⴰⵍⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵓ ⵏ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵍⵡⴰⵍⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K14_20","012_4_20","1KI","4","20","20","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ ⵙ ⵡⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵎⵎⵓ ⴰⵟⵟⴰⵙ. ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ, ⵙⵡⵉⵏ ⵓ ⴼⴰⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_1","012_5_1","1KI","5","1","1","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵃⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵎⵉⵚⵔⴰ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴰⵡⵢⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ ⵓ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K15_2","012_5_2","1KI","5","2","2","ⴰⵙⵓⵏⵉⵢ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵜⵓⵖⴰ-ⵜ ⵜⵍⴰⵜⵉⵏ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵓ ⵙⴻⵜⵜⵉⵏ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵡⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K15_3","012_5_3","1KI","5","3","3","ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵚⴻⵃⵃⴻⵏ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏ ⵀⴻⴷⴷⵓ ⴷ ⵎⵢⴰ ⵏ ⵡⵓⴵⵉ, ⴰⵀⵜⴰ ⵉ ⵓⴷⴰⴷⴻⵏ, ⵉⵖⴰⵢⴹⴻⵏ ⵏ ⵡⴻⵣⵖⴰⵔ, ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵡⴻⵥⵥⵉⵡⴻⵏ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("K15_4","012_5_4","1KI","5","4","4","ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⵜⵎⴰ-ⵢⴰ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵣⵉ ⵜⵉⴼⵙⴰⵅ ⴰⵍ ⵖⴰⵣⵣⴰ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵅ ⵜⵎⴰ-ⵢⴰ ⵏ ⵉⵖⵣⴰⵔ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴰⵙ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_5","012_5_5","1KI","5","5","5","ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵙⴰⴷⵓ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵙⴰⴷⵓ ⵡⴰⵔⵜⵓ ⵏⵏⴻⵙ, ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_6","012_5_6","1KI","5","6","6","ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵍⴽⵓⵔⵉⵜ ⵏ ⵢⴻⵢⵙⴰⵏ ⵉ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("K15_7","012_5_7","1KI","5","7","7","ⵍⵡⵓⵍⴰⵜ-ⴰ, ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵓⵢⵓⵔ ⵏⵏⴻⵙ, ⵜⵜⵀⵉⵍⵍⴰⵏ ⴷⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵊⵊⵉⵏ ⴰⴷ ⵉⵅⴻⵚⵚ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("K15_8","012_5_8","1KI","5","8","8","ⵉⵎⴻⵏⴷⵉ ⴷ ⵓⵍⵓⵎ ⵉ ⵉⵢⵙⴰⵏ ⵓ ⵉ ⵉⵢⵙⴰⵏ ⵏ ⵜⴰⵣⵍⴰ ⵜⵜⴰⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵎⴰ ⵉⴵⴰ, ⴽⵓⵍ ⵉⵊⵊ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⵡⴻⴽⴽⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K15_9","012_5_9","1KI","5","9","9","ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⵄⵇⴻⵍ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓⵍⴰ ⴷ ⵜⵜⴰⵙⵉⵄ ⵏ ⵜⵓⵙⵙⵏⴰ ⴷⴻⴳ ⵡⵓⵍ ⴰⵎ ⵢⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K15_10","012_5_10","1KI","5","10","10","ⵜⵉⵖⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⵉⵖⵉⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_11","012_5_11","1KI","5","11","11","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⵉⵖⵉⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⵅ ⵉⵜⴰⵏ, ⴰⵣⵔⴰⵃⵉ, ⵅ ⵀⴰⵢⵎⴰⵏ, ⴽⴰⵍⴽⵓⵍ ⴷ ⴷⴰⵔⴷⴰⵄ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⵃⵓⵍ. ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_12","012_5_12","1KI","5","12","12","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ. ⴰⵍⴻⴼ ⵓ-ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⵍⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K15_13","012_5_13","1KI","5","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵡⴻⴷ ⵅ ⵜⵛⴻⵊⵊⵓⵔⴰ, ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⴰⵍ ⵜⵄⴻⵍⴵⴻⵜ ⵉ ⴷⴷ-ⵉⵖⴻⵎⵎⵢⴻⵏ ⵣⵉ ⵍⵃⵉⴹ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵡⴻⴷ ⵅ ⵍⵎⴰⵍ, ⵅ ⵉⵊⴹⴰⴹ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵓ ⵅ ⵉⵙⴻⵍⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_14","012_5_14","1KI","5","14","14","ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵡⴷⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⵜⵉⵖⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵍⴰⵏ ⵅ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K15_15","012_5_15","1KI","5","15","15","ⵃⵉⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ, ⵉⵙⵙⴻⴽⴽ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵍⴰ, ⴰⵇⴰ ⴷⴻⵀⵏⴻⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ. ⵉⵡⴰ ⵃⵉⵔⴰⵎ ⵜⵓⵖⴰ ⵍⴻⴱⴷⴰ ⵉⵜⵜⴻⵅⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K15_16","012_5_16","1KI","5","16","16","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊⴰ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵃⵉⵔⴰⵎ: ");
INSERT INTO rift_vpl VALUES ("K15_17","012_5_17","1KI","5","17","17","“ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⴻⵏⵖⴰⵏ ⵉ ⵣⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("K15_18","012_5_18","1KI","5","18","18","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵡⵛⴰ ⴰⵢⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵍⴻⵀⵏⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ ⴱⵓ ⵡⴻⵖⵔⵉⵎ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⴰⵙⵉⴳⴳⵯⴻⴷ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K15_19","012_5_19","1KI","5","19","19","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵏⵡⵉⵖ ⴰⴷ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: ‘ⵎⵎⵉⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵖⵉⵎⴻⵖ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ, ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("K15_20","012_5_20","1KI","5","20","20","ⵓⵎⵓⵔ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴰⴷ ⴰⵢⵉ ⵣⴻⴷⵎⴻⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ. ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵉⵍⵉⵏ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵍⵎⵓⵏⴻⵜ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⵉⵏⵉⴷ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵣⴷⴻⵎ ⴰⴽⴻⵛⵛⵓⴹ ⴰⵎ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("K15_21","012_5_21","1KI","5","21","21","ⵓⵎⵉ ⵉⵙⵍⴰ ⵃⵉⵔⴰⵎ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴼⴰⵔⵃ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⴰⵙⵙ-ⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵉ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴷ ⴰⵎⵉⵖⵉⵙ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("K15_22","012_5_22","1KI","5","22","22","ⵃⵉⵔⴰⵎ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵓⵎⵉ ⵉ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵖ ⵎⴰⵔⵔⴰ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵛ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("K15_23","012_5_23","1KI","5","23","23","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⵉⵡⴹⴻⵖ ⵅ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵅ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⵉⵏⵉⴷ. ⴷⵉⵏⵏⵉ ⴰⴷ ⵜ ⵙⵙⴰⵔⵅⵓⵖ ⵓ ⵛⴻⴽ ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⴷ, ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵇⴻⴼⵍⴻⴷ ⵎⴰⵔⵔⴰ ⵎⴻⵥⵔⵉ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵎⴰⵛⵛⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K15_24","012_5_24","1KI","5","24","24","ⵓⵛⴰ ⵃⵉⵔⴰⵎ ⵉⵡⵛⴰ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ ⵉ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵔⵔⴰ ⴰⵏⴻⵛⵜ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K15_25","012_5_25","1KI","5","25","25","ⵉⵡⵛⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵉⵔⴷⴻⵏ ⵉ ⵃⵉⵔⴰⵎ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵄⵉⵛⵔⵉⵏ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵣⵣⴻⵛⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⵜⴰⵃⵓⵔⵔⴻⵛⵜ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⵡⵛⴰ ⵙⵓⵍⵉⵎⴰⵏ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵅ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵃⵉⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K15_26","012_5_26","1KI","5","26","26","ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵉⵖⵉⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⵀⵏⴰ ⵊⴰⵔ ⵃⵉⵔⴰⵎ ⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("K15_27","012_5_27","1KI","5","27","27","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ. ⴰⵙⴳⴻⵄⵄⴻⴷ-ⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K15_28","012_5_28","1KI","5","28","28","ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴻⴳ ⵓⵢⵓⵔ, ⵙ ⵏⵏⵓⴱⴻⵜ: ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵓⵔⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ. ⴰⴷⵓⵏⵉⵔⴰⵎ ⵜⵓⵖⴰ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K15_29","012_5_29","1KI","5","29","29","ⵜⵓⵖⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵏ ⵍⴻⵀⵎⴻⵍ ⴷ ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵙⵓⵢⴷⴰⵢⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K15_30","012_5_30","1KI","5","30","30","ⴰⵀⵜⴰ ⵄⴰⴷ ⵉ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵍⴳⴻⵏⵙ ⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K15_31","012_5_31","1KI","5","31","31","ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵇⵛⴻⵏ ⵜⵉⵚⵓⴹⴰⵔ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵜⵉⵚⵓⴹⴰⵔ ⵉⵖⵍⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴷⵙⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵜⵉⵚⵓⴹⴰⵔ-ⴰ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K15_32","012_5_32","1KI","5","32","32","ⵉⴱⴻⵏⵏⴰⵢⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ ⵏ ⵃⵉⵔⴰⵎ ⵓⵍⴰ ⴷ ⵉⵊⵉⴱⴰⵢⵍⵉⵢⵢⴻⵏ ⵏⴻⵇⵛⴻⵏ ⵜⴻⵏⵜ. ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ ⴷ ⵢⴻⵥⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_1","012_6_1","1KI","6","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⴼⴼⵓⵖ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⵣⵉⵡ, ⴰⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.   * ");
INSERT INTO rift_vpl VALUES ("K16_2","012_6_2","1KI","6","2","2","ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵉⴱⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜⵜ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⵔⵓ ⵓ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵓⵄⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("K16_3","012_6_3","1KI","6","3","3","ⴰⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵓⵖⴰ-ⵜ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⴻⵣⵣⵓⴳⴳⴰⵔⵜ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵜⵉⵔⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_4","012_6_4","1KI","6","4","4","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵉⴱⵓⵔⵊⴰⵜⵉⵏ, ⴱⴻⵍⵍⵄⴻⵏ ⵜⴻⵏⵜ ⵙ ⵜⴻⵡⵡⵓⵔⴰ ⴰⴽ-ⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵓⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("K16_5","012_6_5","1KI","6","5","5","ⵖⴰⵔ ⵍⵃⵉⴹ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵣⵣⵉⵢⴰⴷⴰ, ⵖⴰⵔ ⵍⴻⵃⵢⵓⴹ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵍⴻⵃⵢⵓⴹ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ. ⵉⴳⴳⴰ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵍⴻⴹⵔⵓⴼ ⴰⵎ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("K16_6","012_6_6","1KI","6","6","6","ⵜⵉⵙⴻⴼⵍⵉ ⵏ ⵡⴰⴷⴷⴰⵢ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⵔⵓ ⵓ ⵜⴻⵏⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⴳⴳⴰ ⵜⵉⵏⴻⴱⴷⴰⵜⵉⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵜⵉⵙⴻⴼⵍⵉⵏ ⵡⴰⵔ ⵜⵜⵉⴷⴼⴻⵏⵜ ⵛⴰ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_7","012_6_7","1KI","6","7","7","ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵙ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵣⵉ ⵎⴰⵏⵉ ⵜⴻⵏⵜ ⵏⴻⵇⵛⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⵡⵉⵙⵍⴻⵏ ⵉⴼⴹⵉⵙⴻⵏ, ⵏⵉⵖ ⵛⵛⴰⵇⵓⵔ ⵏⵉⵖ ⵛⴰ ⵣⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K16_8","012_6_8","1KI","6","8","8","ⵜⴰⵡⵡⴰⵔⵜ ⵉ ⵍⴻⴱⵏⵉ ⵏ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵎⴻⵔⵡⴰⵙⵓ ⵜⵓⵖⴰ-ⵜⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⴰⵍ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵅ ⴷⴷⵔⵓⵊⴰⵜ ⵢⴻⵏⵏⴹⴻⵏ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵎⴻⵔⵡⴰⵙⵓ ⵓ ⵣⴻⴳ ⵓⵎⴻⵔⵡⴰⵙⵓ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K16_9","012_6_9","1KI","6","9","9","ⴰⵎⵎⵓ ⵉ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ. ⵉⵙⵙⴷⵓⵔⵉⵢ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵜⵃⴻⵏⵢⴰ ⵓ ⵙ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵏⴻⴳⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K16_10","012_6_10","1KI","6","10","10","ⵉⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵍⴻⴱⵏⵉ ⵏ ⵣⵣⵉⵢⴰⴷⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵓⵄⵍⴰ ⵉ ⴽⵓⵍ ⵟⵟⴻⴱⵇⴻⵜ ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵙⴰ ⵙ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵅ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_11","012_6_11","1KI","6","11","11","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K16_12","012_6_12","1KI","6","12","12","“ⵅ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⵜⴱⴻⵏⵏⵉⴷ: ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵄⵍⴰⵃⵚⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⵓⵎⵉ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵓⵢⵓⵔⴻⴷ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⵇⴻⴼⵍⴻⵖ ⴰⵡⴰⵍ ⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K16_13","012_6_13","1KI","6","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴻⵎⵎⵃⴻⵖ ⵛⴰ ⴷⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("K16_14","012_6_14","1KI","6","14","14","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵉⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_15","012_6_15","1KI","6","15","15","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵓⵍⴰ ⴷ ⴰⴷⵎⴰⵡⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵙ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ⵣⵉ ⵜⵉⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵍ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⵣⴻⵇⵇⴰ ⵉⵍⴻⵃⵃⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⵉⵍⴻⵃⵃⴻⴼ ⵉ ⵜⵉⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("K16_16","012_6_16","1KI","6","16","16","ⵜⵓⵖⴰ ⵉⴱⵏⴰ ⵄⴰⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵣⵉ ⵜⵉⵙⵉ ⴰⵍ ⵜⴰⵣⴻⵇⵇⴰ ⵏ ⵍⴻⵃⵢⵓⴹ, ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵜⴰⵙⵉⵄ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ ⴷ ⴰⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉ ⵏⴻⵜⵜⴰ, ⴷ ⴰⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K16_17","012_6_17","1KI","6","17","17","ⵜⴰⴷⴷⴰⵔⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴰⵔⴻⴱⵄⵉⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⵉ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_18","012_6_18","1KI","6","18","18","ⵜⵓⵖⴰ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵜⵜⵡⴰⵏⴻⵇⵇⴻⵛ ⵙ ⵜⵄⴻⴱⴱⵓⵣⵉⵏ ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⴳⴳⵓⵔ ⴰⴷ ⴰⵔⴻⵣⵎⴻⵏⵜ. ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴱⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K16_19","012_6_19","1KI","6","19","19","ⵉⴳⴳⴰ ⴰⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵇⴰⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴰⵔⵙ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K16_20","012_6_20","1KI","6","20","20","ⴰⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⵓⵖⴰ-ⵜ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⵔⵓ ⴷ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵓⵄⵍⴰ. ⵉⵍⴻⵃⵃⴻⴼ ⵉ-ⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ. ⵉⵍⴻⵃⵃⴻⴼ ⵄⴰⵡⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_21","012_6_21","1KI","6","21","21","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵖⴻⴵⴻⴼ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ. ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵙⵙⴻⵄⴷⵓ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵡⵓⵔⴻⵖ. ⵉⵖⴻⴵⴻⴼ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K16_22","012_6_22","1KI","6","22","22","ⵉⵖⴻⴵⴻⴼ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵡⵓⵔⴻⵖ, ⴰⵍⴰⵎⵉ ⵜⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ. ⵉⵖⴻⴵⴻⴼ ⵎⴰⵔⵔⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K16_23","012_6_23","1KI","6","23","23","ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵣⴻⵎⵎⵓⵔ. ⵜⵉⴷⴷⵉ ⵏⵙⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("K16_24","012_6_24","1KI","6","24","24","ⵉⵊⵊ ⵏ ⵡⴰⴼⵔⵉⵡ ⵏ ⵓⴽⵉⵔⵓⴱ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⴷⴻⴳ ⵡⴰⴼⵔⵉⵡ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⴽⵉⵔⵓⴱ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵣⴻⴳ ⵉⵅⴻⴼ ⵏ ⵢⵉⵊⵊ ⵏ ⵡⴰⴼⵔⵉⵡ ⵏⵏⴻⵙ ⴰⵍ ⵉⵅⴻⴼ ⵏ ⵡⴰⴼⵔⵉⵡ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉ ⴰⵇⴰ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K16_25","012_6_25","1KI","6","25","25","ⴰⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵍⴻⵄⴱⴰⵔ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵉⴽⵉⵔⵓⴱⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K16_26","012_6_26","1KI","6","26","26","ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⵜⵓⵖⴰ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵍⵓⵄⵍⴰ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K16_27","012_6_27","1KI","6","27","27","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵅⴻⵍ. ⵉⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵜⵓⵖⴰ ⴱⴻⵣⵣⵄⴻⵏ ⴰⵍⴰⵎⵉ ⴰⴼⵔⵉⵡ ⵏ ⵉⵊⵊ ⵉⵜⵜⴰⴽⴽⵯⴰⴹ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵓ ⴰⴼⵔⵉⵡ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵍⵃⵉⴹ ⵏⵏⴻⵖⵏⵉ. ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵎⵎⵃⴰⴷⴰⵏ ⵉⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵢⴰⵡⵢⴰ, ⴰⴼⵔⵉⵡ ⵖⴰⵔ ⵡⴻⴼⵔⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("K16_28","012_6_28","1KI","6","28","28","ⵏⴻⵜⵜⴰ ⵉⵖⴻⴵⴻⴼ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K16_29","012_6_29","1KI","6","29","29","ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵇⴻⵛ ⵉ-ⵜⴻⵏ ⵙ ⵓⵇⴻⵙⵙⵉ ⵏ ⵉⵏⴻⵇⵇⵉⵛⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵣⵉ ⴷⴰⵅⴻⵍ ⵓ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K16_30","012_6_30","1KI","6","30","30","ⵉⵖⴻⴵⴻⴼ ⵜⵉⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵡⵓⵔⴻⵖ ⴰⵎ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴹⴰⵅⴻⵍ ⴰⵎ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_31","012_6_31","1KI","6","31","31","ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵣⴻⵎⵎⵓⵔ. ⴰⴽⵡⴰⴷⵔⵓⵏ ⵙ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉⵜⵜⴰⵡⵉ ⵉⵊⵊ ⵏ ⵍⴻⵅⵎⵓⵙ ⵏ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("K16_32","012_6_32","1KI","6","32","32","ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵣⴻⵎⵎⵓⵔ. ⵏⴻⵜⵜⴰ ⵉⵏⵇⴻⵛ ⴷⴰⵢⵙⴻⵏ ⵉⵏⴻⵇⵇⵉⵛⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵜⵉⵡⵡⵓⵔⴰ ⵙ ⵡⵓⵔⴻⵖ. ⵓⵍⴰ ⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K16_33","012_6_33","1KI","6","33","33","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵍⴻⴹⵔⵓⴼ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵣⴻⵎⵎⵓⵔ, ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⴰⵄⵜ ⵏ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("K16_34","012_6_34","1KI","6","34","34","ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ. ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⵜⵜⵇⵓⵡⵡⴰⵔⴻⵏⵜ ⴷⵉ ⴱⴰⵔⵔⴰ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵜⵜⵡⴰⵏⴻⵇⵛⴻⵏⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ ⵜⵓⵖⴰ ⵜⵜⵇⵓⵡⵡⴰⵔⴻⵏⵜ ⴷⵉ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K16_35","012_6_35","1KI","6","35","35","ⵏⴻⵜⵜⴰ ⵉⵏⵇⴻⵛ ⴷⴰⵢⵙⴻⵏⵜ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵓⵛⴰ ⵉⵛⴻⵍⵍⴻⵍ ⵉ-ⵜⴻⵏⵜ ⵙ ⵡⵓⵔⴻⵖ, ⵙ ⵉⵊⵊ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵇⵛⵓⵔⵜ ⵉⵍⴻⵖⵖⴻⵏ ⵅ ⵡⴻⵏⵇⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("K16_36","012_6_36","1KI","6","36","36","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵍⴻⵎⵔⴰⵃ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⴷⴷⵉ ⵏ ⵜⵃⴻⵏⵢⴰ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("K16_37","012_6_37","1KI","6","37","37","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵣⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("K16_38","012_6_38","1KI","6","38","38","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴱⵓⵍ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵏⵏⴻⵙ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K17_1","012_7_1","1KI","7","1","1","ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵛⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_2","012_7_2","1KI","7","2","2","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ. ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵓ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⵔⵓ ⵓ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵓⵄⵍⴰ, ⵜᵉⵜⵜⵡⴰⴳⴳ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵓ ⵜⵜⵡⴰⵙⵙⴰⵔⵙⴻⵏⵜ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵜⵉⵡⴰ ⵉ ⵉⴱⵉⵍⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_3","012_7_3","1KI","7","3","3","ⵜⵓⵖⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵣⴻⵇⵇⴰ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵜⵉⵡⴰ ⵉ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ, ⴰⵇⴰ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵜⵃⴻⵏⵢⴰ ⵅ ⵉⵊⵊ ⵏ ⵓⵙⴻⴷⴷⵉ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_4","012_7_4","1KI","7","4","4","ⵜⵓⵖⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴻⴽⵡⴰⵣⵉ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴱⵓⵔⵊⴻⵜ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴱⵓⵔⵊⴻⵜ ⵏⵏⴻⵖⵏⵉ, ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_5","012_7_5","1KI","7","5","5","ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⴷ ⵍⴻⴹⵔⵓⴼ ⵏⵙⴻⵏⵜ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⴽⵡⴰⴷⵔⵓⵏ, ⵓⵛⴰ ⴰⵔⵣⴰⵎ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⵡⴰⵔⵣⴰⵎ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ, ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_6","012_7_6","1KI","7","6","6","ⴰⵙⵇⵉⴼ ⵉⴳⴳⴰ ⵉ-ⵜ ⵙ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵓ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⵔⵓ. ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⵜ ⵏ ⵜⴻⵙⵇⵉⴼⵜ ⵏⵏⴻⵖⵏⵉ ⴰⴽ-ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵇⵇⴻⴼ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K17_7","012_7_7","1KI","7","7","7","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⴰⵅⵅⴰⵎ ⵉ ⵍⵄⴰⵔⵛ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵛⴰⵔⵔⴻⵄ, ⴰⵅⵅⴰⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴰⵄ, ⵓⵛⴰ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵉ-ⵜ ⵣⵉ ⵜⵉⵙⵉ ⵙⵡⴰⴷⴷⴰⵢ ⴰⵍ ⵜⵉⵙⵉ ⵏⵏⴻⵖⵏⵉ ⵙⴻⵏⵏⴻⵊ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("K17_8","012_7_8","1KI","7","8","8","ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ, ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴽⵜⴰⵔ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴰⵄ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴰⵎⴻⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵜⴻⵏⵏⵉ ⵢⵉⵡⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⴰⵎ ⵡⴻⵅⵅⴰⵎ-ⴰ ⵡⴰⵏⵉⵜⴰ.   * ");
INSERT INTO rift_vpl VALUES ("K17_9","012_7_9","1KI","7","9","9","ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ-ⵜ ⵣⵉ ⵜⵚⵓⴹⴰⵔ ⵉⵖⵍⴰⵏ, ⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⵢⴰⵙ, ⵣⵉ ⴷⴰⵅⴻⵍ ⵓ ⵣⵉ ⴱⴰⵔⵔⴰ ⵜⵜⵡⴰⵏⵛⴰⵔⴻⵏ ⵙ ⵍⵎⴻⵏⵛⴰⵔ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵣⵉ ⴷⵙⴰⵙ ⴰⵍ ⵉⵥⵔⴰ ⵏ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ ⵓ ⵣⵉ ⴱⴰⵔⵔⴰ ⴰⵍ ⵍⴻⵎⵔⴰⵃ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_10","012_7_10","1KI","7","10","10","ⴷⵙⴰⵙ ⵉⵜⵜⵡⴰⴳⴳ ⵙ ⵜⵚⵓⴹⴰⵔ ⵉⵖⵍⴰⵏ, ⵉⵥⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵉⵥⵔⴰ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵉⵥⵔⴰ ⵏ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K17_11","012_7_11","1KI","7","11","11","ⵓ ⵜⵉⵡⴰ ⵏⵙⴻⵏ ⵜⵉⵚⵓⴹⴰⵔ ⵉⵖⵍⴰⵏ, ⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⵢⴰⵙ, ⵓⵍⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("K17_12","012_7_12","1KI","7","12","12","ⵍⴻⵎⵔⴰⵃ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵜⵓⵖⴰ-ⵜ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴷⴷⵉ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵉ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K17_13","012_7_13","1KI","7","13","13","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵃⵉⵔⴰⵎ ⵣⵉ ⵚⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_14","012_7_14","1KI","7","14","14","ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵓ ⴱⴰⴱⴰⵙ ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵚⵓⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵎⵣⵉⵍ ⵏ ⵏⵏⵃⴰⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵍⴻⵄⵇⴻⵍ ⴷ ⵜⵓⵙⵙⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵇⴰⵄ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵏⵏⵃⴰⵙ. ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵉⴳⴳⴰ ⵉ-ⵜ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_15","012_7_15","1KI","7","15","15","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⵉⵍⴰⵔ ⵜⵓⵖⴰ-ⵜⵜ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵏⵏⴻⴹ ⵉ ⵓⴱⵉⵍⴰⵔ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K17_16","012_7_16","1KI","7","16","16","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵜⵉⵊⴰⵏ ⵏ ⵏⵏⵃⴰⵙ ⵉⴼⴻⵙⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⴰⵔⵙⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ. ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵜⵓⵖⴰ-ⵜ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏ ⵜⵜⴰⵊ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ-ⵜ ⵓⵍⴰ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_17","012_7_17","1KI","7","17","17","ⵓⵍⴰ ⴷ ⵜⵉⵊⴻⵟⵟⴰⵢⵉⵏ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⵓⴷⵉ, ⴰⵎ ⵉⴼⵉⵍⴰⵏ ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⵉ ⵜⵜⵉⵊⴰⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ. ⵙⴻⴱⵄⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵓ ⵙⴻⴱⵄⴰ ⵉ ⵜⵜⴰⵊ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K17_18","012_7_18","1KI","7","18","18","ⵉⴳⴳⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⵓⴷⵉ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵜⵜⵉⵊⴰⵏ ⵉ ⵉⴵⴰⵏ ⵜⵉⵡⴰ ⵉ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵓⵍⴰ ⵉ ⵜⵜⴰⵊ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K17_19","012_7_19","1KI","7","19","19","ⵜⵜⵉⵊⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⵎ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ, ⵙ ⵉⵊⵊ ⵏ ⵍⵓⵄⵍⴰ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_20","012_7_20","1KI","7","20","20","ⵜⵜⵉⵊⴰⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵙⴻⵏⵏⴻⵊ ⴰⴽ-ⴷ ⵡⵓⴷⴻⵎ ⵏ ⵓⵇⵓⵔⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ-ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵎⵓⴷⴻⵏ. ⵓⵛⴰ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⵅ ⵜⵜⴰⵊ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K17_21","012_7_21","1KI","7","21","21","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵏⴻⵜⵜⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵖⴰⵔ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵉⵙⵙⴱⴻⴷⴷ ⴰⴱⵉⵍⴰⵔ ⴰⴼⵓⵙⵉ, ⵉⴳⴳⴰ ⴰⵙ ⵢⴰⵅⵉⵏ, ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵍⴰ ⴷ ⴰⴱⵉⵍⴰⵔ ⴰⵣⴻⵍⵎⴰⴹ, ⵉⴳⴳⴰ ⴰⵙ ⴱⵓⵄⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("K17_22","012_7_22","1KI","7","22","22","ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⴷⵉ ⴼⵓⵔⵎⴰ ⵏ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵍⵉⵍⵍⴻⵛⵜ. ⴰⵎⵎⵓ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_23","012_7_23","1KI","7","23","23","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵉⴼⴻⵙⵢⴻⵏ ⵉ ⵡⴰⵎⴰⵏ. ⵜⵓⵖⴰ-ⵜ ⵍⴻⵄⴱⴰⵔ ⵏⵏⴻⵙ ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴷ ⴰⵇⵓⵔⴰⵔ ⵇⴰⵄ, ⵓⵛⴰ ⵜⵉⴷⴷⵉ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵙ ⵜⴻⵏⵏⴹⴻⴷ ⵙ ⵉⵛⵜ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("K17_24","012_7_24","1KI","7","24","24","ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵜⵎⴰ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵇⴰⵄ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵄⴻⴱⴱⵓⵣⵉⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ. ⵄⴻⵛⵔⴰ ⴷⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵏⵏⴹⴻⵏⵜ ⵉ ⵜⵔⵉⵎⴰⵏⵜ. ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵏ ⵜⵄⴻⴱⴱⵓⵣⵉⵏ ⴰⴽ-ⴷ ⵏⵏⵓⵡⵡⴰⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵡⴰⴼⴻⵙⵢⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_25","012_7_25","1KI","7","25","25","ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴱⴻⴷⴷ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵙ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵙ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵙ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵓ ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵙ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴰⵔⵙⴰ ⵅⴰⵙⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵣⵣⵄⴻⵏⵇⵓⵇⴰⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K17_26","012_7_26","1KI","7","26","26","ⵜⴻⴳⴷⴰⵔ ⵏ ⵜⵔⵉⵎⴰⵏⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵓⴼⵓⵙ ⵓ ⵜⵎⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵜⵎⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⴼⴻⵏⵊⴰⵍ, ⴰⵎ ⵜⵏⴻⵡⵡⴰⵛⵜ ⵏ ⵜⵍⵉⵍⵍⴻⵛⵜ. ⵜⵡⴰⵡⵉⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵍⴼⴰⵢⴻⵏ ⵉⴱⴰⵜⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_27","012_7_27","1KI","7","27","27","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴻⵛⵔⴰ ⵏ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵜⵓⵖⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴽⴰⵔⵔⵓⵜ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_28","012_7_28","1KI","7","28","28","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ. ⵏⵉⵜⴻⵏⵜⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏⵜ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵄⴰⵔⵔⴹⴻⵏⵜ ⵓ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵄⴰⵔⵔⴹⴻⵏⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵊⴰⵔ ⵛⵛⴰⴼⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K17_29","012_7_29","1KI","7","29","29","ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵄⴰⵔⵔⴹⴻⵏⵜ ⵊⴰⵔ ⵛⵛⴰⴼⵓⴷ, ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⵛⴰⵎⴻⵏ ⵏ ⵡⴻⵢⵔⴰⴷⴻⵏ, ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ. ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵅ ⵛⵛⴰⴼⵓⴷ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⵏⵏⴰⴷ. ⵙⴰⴷⵓ ⵡⴻⵢⵔⴰⴷⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⵉⵙⴻⴷⴷⵉⵢⵉⵏ ⵏ ⵜⴻⴼⵔⴰⵢ ⵏⵏⵉ ⵢⵓⵢⵍⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ . ");
INSERT INTO rift_vpl VALUES ("K17_30","012_7_30","1KI","7","30","30","ⵉⵛⵜ ⵏ ⵜⴽⴰⵔⵔⵓⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵍⴻⵃⵣⴰⵎⴰⵜ ⵏ ⵏⵏⵃⴰⵙ. ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵖⴰⵔⴹⵉⵏ. ⵜⵉⵖⴰⵔⴹⵉⵏ ⵉⴼⴻⵙⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵙⴰⴷⵓ ⵉ ⵜⴱⴰⵏⵢⵓⵜ ⵉ ⵓⵙⵉⵔⴷ, ⵣⵣⴰⵜ ⵉ ⴽⵓⵍ ⵜⴰⵖⴰⵔⴹⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵙⴻⴷⴷⵉⵢⵉⵏ ⵏ ⵜⴻⴼⵔⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("K17_31","012_7_31","1KI","7","31","31","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⵜⴰⵊ ⵏ ⵜⴽⴰⵔⵔⵓⵜ, ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ. ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵇⵓⵔⴰⵔ, ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⴳⴳ. ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵏⵇⴰⵛⵉⵏ, ⵓ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏⵙⴻⵏ ⵄⴰⵔⵔⴹⴻⵏⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ, ⵡⴰⵔ ⴵⵉⵏⵜ ⴷ ⵜⵉⵇⵓⵔⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_32","012_7_32","1KI","7","32","32","ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵙⴰⴷⵓ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵄⴰⵔⵔⴹⴻⵏⵜ ⵓ ⵍⴻⵃⵣⴰⵎⴰⵜ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵛⴻⴷⴷⵏⴻⵏⵜ ⵖⴰⵔ ⵜⴽⴰⵔⵔⵓⵜ. ⵍⵓⵄⵍⴰ ⵏ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵜⵓⵖⴰ-ⵜ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_33","012_7_33","1KI","7","33","33","ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⴰⵎ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ. ⵍⴻⵃⵣⴰⵎⴰⵜ ⵏⵙⴻⵏⵜ, ⵢⴰⵏⵜⴰⵜ ⵏⵙⴻⵏⵜ, ⴰⵔⵔⴰⴷⵢⴰⵡⴰⵜ ⵏⵙⴻⵏⵜ ⴷ ⵉⵖⵓⵍⴰⴼ ⵏ ⵍⴻⵃⵣⴰⵎⴰⵜ ⵏⵙⴻⵏⵜ ⵜⵜⵡⴰⴼⴻⵙⵢⴻⵏⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K17_34","012_7_34","1KI","7","34","34","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴰⵔⴹⵉⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵉⵛⵜ ⵏ ⵜⴽⴰⵔⵔⵓⵜ. ⵜⵉⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵙ ⴼⴼⵖⴻⵏⵜ ⵣⵉ ⵜⴽⴰⵔⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K17_35","012_7_35","1KI","7","35","35","ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴽⴰⵔⵔⵓⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ ⵉⴱⴻⴷⴷ ⵉⵇⵓⵡⵡⴰⵔ ⴰⵙ-ⴷⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴽⴰⵔⵔⵓⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_36","012_7_36","1KI","7","36","36","ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ ⴰⴽ-ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ ⵓ ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵜⵉⵇⴻⴱⴱⴰⵔⵉⵏ ⵏⵙⴻⵏⵜ ⵉⵏⵇⴻⵛ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⵉⵢⵔⴰⴷⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ, ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰ, ⵓⵍⴰ ⴷ ⵜⵉⵙⴻⴷⴷⵉⵢⵉⵏ ⵏ ⵜⴻⴼⵔⴰⵢ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_37","012_7_37","1KI","7","37","37","ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵄⴻⵛⵔⴰ ⵏ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ, ⵎⴰⵔⵔⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⴼⴻⵙⵢⵉ, ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵇⵢⴰⵙ, ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K17_38","012_7_38","1KI","7","38","38","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⴱⴰⵏⵢⵓⵜⵉⵏ ⵏ ⵏⵏⵃⴰⵙ. ⵉⵛⵜ ⵏ ⵜⴱⴰⵏⵢⵓⵜ ⵉⴽⵙⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵉⴱⴰⵜⵓⵜⴻⵏ. ⵉⵛⵜ ⵏ ⵜⴱⴰⵏⵢⵓⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵅ ⵇⴰⵄ ⵉⵛⵜ ⵣⵉ ⵄⴻⵛⵔⴰ ⵏ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴱⴰⵏⵢⵓⵜ.    ");
INSERT INTO rift_vpl VALUES ("K17_39","012_7_39","1KI","7","39","39","ⵉⴳⴳⴰ ⵅⴻⵎⵙⴰ ⵏ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⴰⴼⵓⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵅⴻⵎⵙⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⴰⵣⴻⵍⵎⴰⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵡⴰⵎⴰⵏ ⵉⴳⴳⴰ ⵉ-ⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⴰⴼⵓⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_40","012_7_40","1KI","7","40","40","ⵉⴳⴳⴰ ⵃⵉⵔⴰⵎ ⵄⴰⵡⴻⴷ ⵜⵉⴱⴰⵏⵢⵓⵜⵉⵏ ⵉ ⵓⵙⵉⵔⴷ, ⵉⵖⴻⵏⵊⴰⵢⴻⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ. ⵉⴽⴻⵎⵎⴻⵍ ⵃⵉⵔⴰⵎ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ ⵉⴳⴳⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("K17_41","012_7_41","1KI","7","41","41","ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⵔⴰⵔⴻⵏ ⵏ ⵜⵜⵉⵊⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⵉ, ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵓⵎⵓⴷⴷⵉ ⵉ ⴷ ⴰⵙⴻⵏⵜ-ⵉ-ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⵔⴰⵔⴻⵏ ⵏ ⵜⵜⵉⵊⴰⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K17_42","012_7_42","1KI","7","42","42","ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵓⵎⵓⴷⴷⵉ ⵜⵜⵡⴰⵎⵎⵙⴻⴱⴹⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵉ ⴽⵓⵍ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⵓⴷⴷⵉ ⵉ ⵣⵉ ⴷⵍⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⵔⴰⵔⴻⵏ ⵏ ⵜⵜⵉⵊⴰⵏ ⵉⵏⵏⵉ ⵅ ⵡⵓⴷⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K17_43","012_7_43","1KI","7","43","43","ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵜⴱⴰⵏⵢⵓⵜⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("K17_44","012_7_44","1KI","7","44","44","ⴷ ⵜⴰⵔⵉⵎⴰⵏⵜ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵙⴰⴷⵓ ⵉ ⵜⵔⵉⵎⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("K17_45","012_7_45","1KI","7","45","45","ⴷ ⵜⴻⵢⴷⵓⵔⵉⵏ ⴷ ⵉⵖⴻⵏⵊⴰⵊⴻⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ. ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ ⵉ ⵉⴳⴳⴰ ⵃⵉⵔⴰⵎ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⵉ ⵏⵏⵃⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_46","012_7_46","1KI","7","46","46","ⴰⵊⴻⴵⵉⴷ ⵉⴽⴻⴱⴱ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷⵉ ⵜⵍⴰⵅⵜ ⵉⴳⴷⴰⵔⴻⵏ ⵊⴰⵔ ⵙⵓⴽⴽⵓⵜ ⴷ ⵚⴰⵔⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K17_47","012_7_47","1KI","7","47","47","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⵄⵉⵣⵣ ⵅ ⵡⴻⵡⵣⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ. ⵡⴰⵔ ⴱⴻⵇⵇⵛⴻⵏ ⴷⵉ ⵍⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K17_48","012_7_48","1KI","7","48","48","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ: ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⵓⵔⴻⵖ, ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵡⵓⵔⴻⵖ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("K17_49","012_7_49","1KI","7","49","49","ⵍⴰ ⴷ ⵍⴻⵇⵏⴰⴷⴻⵍ, ⵅⴻⵎⵙⴰ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⴷ ⵅⴻⵎⵙⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⵣⵣⴰⵜ ⵉ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵣⴻⴳ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ, ⵍⴰ ⴷ ⵏⵏⵓⵡⴰⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ ⵏ ⵜⴻⴼⵜⵉⵍⵜ ⵏ ⵡⵓⵔⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("K17_50","012_7_50","1KI","7","50","50","ⵓⵍⴰ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⴷ ⵜⵎⴻⵊⵎⴰⵔⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵍⴻⵎⴼⴰⵙⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵅⴻⵍ, ⵉ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ, ⵓⵍⴰ ⵍⴻⵎⴼⴰⵙⴻⵍ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵣⴻⴳ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K17_51","012_7_51","1KI","7","51","51","ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵓⵛⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⵉⴷⴻⴼ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴱⴰⴱⴰⵙ. ⵉⵙⵙⴰⵔⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.    ");
INSERT INTO rift_vpl VALUES ("K18_1","012_8_1","1KI","8","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵜⴻⵏⵏⵉ ⴷ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_2","012_8_2","1KI","8","2","2","ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵓⵏⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔ ⵍⵄⵉⴷ ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⵉⵜⴰⵏⵉⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("K18_3","012_8_3","1KI","8","3","3","ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵙⵉⵏ-ⴷⴷ ⵓ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K18_4","012_8_4","1KI","8","4","4","ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ. ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_5","012_8_5","1KI","8","5","5","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⵎⵓⵏ ⵓ ⵜⵓⵖⴰ-ⵜⵜ ⴰⴽⵉⴷⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵇⴻⴷⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_6","012_8_6","1KI","8","6","6","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵡⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴷⴻⴳ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ, ⴰⵍ ⵙⴰⴷⵓ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_7","012_8_7","1KI","8","7","7","ⵎⴰⵖⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴱⴻⵣⵣⵄⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵜⵉⵡⴰ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵜⴰⴱⵓⵜ, ⵓⵛⴰ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷⵍⵉⵏ ⵜⵜⴰⴱⵓⵜ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("K18_8","012_8_8","1KI","8","8","8","ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵜⵓⵖⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵍⴰⵎⵉ ⵜⵜⵡⴰⵥⴰⵔⵔⴻⵏ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ, ⵎⴰⵛⴰ ⵣⵉ ⴱⴰⵔⵔⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵥⴰⵔⴻⵏ. ⵉⵄⵓⵎⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K18_9","012_8_9","1KI","8","9","9","ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵛⴰ ⴷⵉ ⵜⵜⴰⴱⵓⵜ ⵎⵖⵉⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵉ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵉⵙⵙⴰⵔⵙ ⵎⵓⵙⴰ ⵖⴰⵔ ⵀⵓⵔⵉⴱ, ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K18_10","012_8_10","1KI","8","10","10","ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K18_11","012_8_11","1KI","8","11","11","ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K18_12","012_8_12","1KI","8","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ: “ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K18_13","012_8_13","1KI","8","13","13","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵛⴻⴽ, ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵉ ⵛⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⵣⴻⴷⵖⴻⴷ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K18_14","012_8_14","1KI","8","14","14","ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⵊⴻⴵⵉⴷ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ-ⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("K18_15","012_8_15","1KI","8","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K18_16","012_8_16","1KI","8","16","16","‘ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵏⴻⴷⵀⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵉⵅⴹⴰⵔⴻⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵉⵅⴹⴰⵔⴻⵖ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("K18_17","012_8_17","1KI","8","17","17","ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K18_18","012_8_18","1KI","8","18","18","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ: ‘ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴱⵏⵉⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ ⵓⵎⵉ ⵜⵜ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K18_19","012_8_19","1KI","8","19","19","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ, ⵎⴰⵛⴰ ⵎⵎⵉⵛ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ. ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("K18_20","012_8_20","1KI","8","20","20","ⵙⵉⴷⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴱⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵓ ⵇⵇⵉⵎⴻⵖ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⴱⵏⵉⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K18_21","012_8_21","1KI","8","21","21","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⵜⵜⴰⴱⵓⵜ ⵜⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵎⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵏⴷⴻⵀ ⵣⵉ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("K18_22","012_8_22","1KI","8","22","22","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("K18_23","012_8_23","1KI","8","23","23","ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵛⴻⴽ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵙⴻⵏⵏⴻⵊ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ, ⵡⴻⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵍⵄⴰⵀⴷ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K18_24","012_8_24","1KI","8","24","24","ⵡⴻⵏⵏⵉ ⵉⵃⴹⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵅ ⵎⵉⵏ ⵅⴻⴼ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⵎⵉⵏⵣⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵓ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⴷⴷ-ⵜⴰⵔⵔⵉⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K18_25","012_8_25","1KI","8","25","25","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⴹⴰⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵅ ⵎⵉⵏ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵣⴰⵢⴻⴽ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵃⴹⴰⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵢⵓⵔⴻⴷ ⵛⴻⴽ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("K18_26","012_8_26","1KI","8","26","26","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴻⴳⴳⴻⵜ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⵉⴷⴻⵜⵜ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K18_27","012_8_27","1KI","8","27","27","ⵎⴰⵖⴰⵔ ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵉⵣⴷⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ? ⵅⵣⴰⵔ, ⴰⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⴰⵊⴻⵏⵏⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵛⴻⴽ ⵉⴽⵙⵉ, ⵎⴻⵛⵃⴰⵍ ⵙ ⴷⵔⵓⵙ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⴻⵛⵛ! ");
INSERT INTO rift_vpl VALUES ("K18_28","012_8_28","1KI","8","28","28","ⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔ ⵓⵣⴰⵡⴻⴳ ⵏⵏⴻⵙ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵓⵍⴰⵖⵉ ⵓ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏⵏⵉ ⵉⵥⵥⵓⴵ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵙⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K18_29","012_8_29","1KI","8","29","29","ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏⵜ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ ⵜⵉⵡⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⵜⵉⵡⴰ ⵉ ⵡⴻⵎⵛⴰⵏ ⵉ ⵅ ⵜⴻⵏⵏⵉⴷ: ‘ⴰⵇⴰ ⵉⵙⴻⵎ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉ ⵓⵙⴻⴵⵉ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵉ ⵉⵥⵥⵓⴵ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ.’ ");
INSERT INTO rift_vpl VALUES ("K18_30","012_8_30","1KI","8","30","30","ⵙⴻⵍ ⵅⴻⵏⵏⵉ ⵉ ⵓⵣⴰⵡⴻⴳ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵓⵣⴰⵡⴻⴳ ⵏⵏⵉ ⵜⵜⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵓ ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⵙⴻⵍ ⵓⵛⴰ ⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K18_31","012_8_31","1KI","8","31","31","ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵉⵊⵊ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵊⵊⵓⴵ ⵓ ⵡⴰⵏⵉⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵛ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("K18_32","012_8_32","1KI","8","32","32","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴽⴽⴰⵔ, ⵃⴽⴻⵎ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵅ ⵓⵄⴻⴼⴼⴰⵏ ⴰⵍⴰⵎⵉ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⵙⴻⴳⴷⴰ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⵍⴰⵎⵉ ⴰⴷ ⴰⵙ ⵜᵉⵜⵜⵡⴰⵖ ⵜⴻⵙⵖⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K18_33","012_8_33","1KI","8","33","33","ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵖⵍⴻⴱ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵄⴷⵓ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⵇⴰⴷⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵥⴰⴵⴻⵏ ⴰⴷ ⴽⵙⵉⵏ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⵉ ⵛⴻⴽ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("K18_34","012_8_34","1KI","8","34","34","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_35","012_8_35","1KI","8","35","35","ⵎⴰⵍⴰ ⵉⴱⴻⵍⵍⴻⵄ ⵓⵊⴻⵏⵏⴰ, ⵅⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵡⴻⵏⵥⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴰⵎ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⴰⴷ ⵇⴰⴷⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵅ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵓⵎⵉ ⵛⴻⴽ ⵜⴻⵏ ⵜⴻⵃⵚⴰⵔⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("K18_36","012_8_36","1KI","8","36","36","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵖⴼⴰⵔ ⴰⵙⴻⵏ ⴷⴷⴻⵏⴱ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⵉ-ⵜⴻⵏ ⴰⴱⵔⵉⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ, ⵓ ⴻⵡⵛ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴰⵏⵥⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K18_37","012_8_37","1KI","8","37","37","ⵎⴰⵍⴰ ⴷⵉⵏ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵉⵖ ⵟⵟⴰⵄⵓⵏ, ⵏⵉⵖ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵉⵎⴻⵏⴷⵉ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵏⵉⵖ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵡⴻⴼⵙⵓ ⵏⵉⵖ ⵜⴰⵎⵓⵖⵔⵉ ⵜⴻⵏⵏⵉ ⵉⵚⴰⵔⵔⴹⴻⵏ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵃⵚⴰⵔ ⵉ-ⵜ ⵍⴻⵄⴷⵓ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵛⴰ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏⵉⵖ ⵛⴰ ⵏ ⵍⴻⵃⵍⴰⵛ, ");
INSERT INTO rift_vpl VALUES ("K18_38","012_8_38","1KI","8","38","38","ⵅⴻⵏⵏⵉ ⵎⴰⵏ ⵎⴰ ⵉ ⵖⴰ ⵉⵥⵥⵓⴵ ⵏⵉⵖ ⵖⴰ ⵉⵜⵜⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵏⵉⵜⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ, ⵙⵙⵏⴻⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵅⴻⵏⵏⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("K18_39","012_8_39","1KI","8","39","39","ⵙⴻⵍ ⵛⴻⴽ ⵖⴰⵔⴻⵙ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⵖⴼⴰⵔ, ⴽⴽⴰⵔ ⵓ ⴻⵡⵛ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ - ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ ⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵀⴰ ⵉ ⵉⵙⵙⵏⴻⵏ ⵓⵍ ⵏ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ - ");
INSERT INTO rift_vpl VALUES ("K18_40","012_8_40","1KI","8","40","40","ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵖⴰ ⴽⴽⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("K18_41","012_8_41","1KI","8","41","41","ⵓⵛⴰ ⵙⴻⵍ ⵛⴻⴽ ⵓⵍⴰ ⵖⴰⵔ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵡⴰⵔ ⵉⴵⴰⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴳⴳⵯⴻⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_42","012_8_42","1KI","8","42","42","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵍⴻⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵅ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵅ ⵓⵖⵉⵍ ⵏⵏⴻⵛ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ! ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷⴷ-ⵢⵓⵙⴰ ⵓ ⴰⴷ ⵉⵥⵥⴰⴵ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("K18_43","012_8_43","1KI","8","43","43","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⵓ ⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⵖⴰⵔⴻⴽ ⵖⴰ ⵉⵍⴰⵖⴰ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵙⵙⵏⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ, ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵓ ⴰⴷ ⵓⵛⵉⵏ, ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵜⵉⵡⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⴱⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("K18_44","012_8_44","1KI","8","44","44","ⵎⴰⵍⴰ ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵏ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⵉ ⵙⵉⴷⵉ ⴰⵎ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵛⴻⴽ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⴱⵏⵉⵖ ⵏⴻⵛⵛ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("K18_45","012_8_45","1KI","8","45","45","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵓ ⵉ ⵓⵣⴰⵡⴻⴳ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴰⵖⴻⴷ ⴰⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K18_46","012_8_46","1KI","8","46","46","ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ - ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴱⵏⴰⴷⴻⵎ ⵉ ⵡⴰⵔ ⵉⵅⴹⴰⵏ - ⵓ ⵛⴻⴽ ⵜⴻⵙⵄⴰⵔⴻⴷ ⵅⴰⵙⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵜⵙⴻⵍⵍⵎⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵄⴷⵓ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏ ⵏⴻⴷⵀⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵄⴷⵓ, ⵎⴰ ⵜⴻⴳⴳⵯⴻⵊ ⵏⵉⵖ ⵜⵓⴷⴻⵙ ⵉ ⵜⴻⴵⴰ, ");
INSERT INTO rift_vpl VALUES ("K18_47","012_8_47","1KI","8","47","47","ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵓⴱⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ, ⵡⴰⵀ, ⴰⴷ ⵜⵓⴱⴻⵏ ⵓ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵍⴰⵖⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⵓ ⵏⴻⴳⴳⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵇⴰ ⵏⴻⴳⴳⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ!’, ");
INSERT INTO rift_vpl VALUES ("K18_48","012_8_48","1KI","8","48","48","ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵥⵥⴰⴵⴻⵏ ⴰⵎ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵛⴻⴽ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⴱⵏⵉⵖ ⵏⴻⵛⵛ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("K18_49","012_8_49","1KI","8","49","49","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵓ ⵉ ⵓⵣⴰⵡⴻⴳ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵖ ⴰⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K18_50","012_8_50","1KI","8","50","50","ⵖⴼⴰⵔ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵎⵉⵏ ⵣⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ ⵓ ⵖⴼⴰⵔ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ ⵉ ⴽⵉⴷⴻⴽ ⵉⵅⴹⴰⵏ, ⵓ ⴻⵡⵛ ⴰⵙⴻⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵔⴻⵃⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_51","012_8_51","1KI","8","51","51","ⵏⵉⵜⵏⵉ ⵎⴰⵖⴰⵔ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⴼⴻⵔⵔⴰⵏ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("K18_52","012_8_52","1KI","8","52","52","ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵔⵣⵎⴻⵏⵜ ⵉ ⵓⵃⴻⵛⵛⴻⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵉ ⵓⵃⴻⵛⵛⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⴻⵙⵍⴻⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⵉ ⵖⴰ ⵍⴰⵖⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("K18_53","012_8_53","1KI","8","53","53","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴼⴰⵔⵣⴻⴷ ⵉ-ⵜⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⵍⵡⴰⵔⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵛⴻⴽ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ, ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵓⵎⵉ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("K18_54","012_8_54","1KI","8","54","54","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵜⵥⴰⴵⵉⵜ-ⴰ ⵓ ⵎⴰⵔⵔⴰ ⴰⵃⴻⵛⵛⴻⵎ-ⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵜ ⵜⵓⵖⴰ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴻⵄⵔⵓⵔ ⵉⵇⵡⴻⵙ ⴰⵎ ⵜⵜⵡⴰⵙⵙⵡⵉⵥⵥⴰⴹⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K18_55","012_8_55","1KI","8","55","55","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("K18_56","012_8_56","1KI","8","56","56","“ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ! ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ ⵉ ⵣⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵎⵓⵙⴰ, ⵡⴰⵔ ⴷⴷ-ⵉⵡⴹⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("K18_57","012_8_57","1KI","8","57","57","ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⴽⵉⴷⵏⴻⵖ ⴰⵎ ⵜⵓⵖⴰ ⵉⴵⴰ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵊⵊⵉ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵏⴻⵟⵟⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("K18_58","012_8_58","1KI","8","58","58","ⵎⴰⵛⴰ ⴰⴷ ⵉⵏⴷⴻⵀ ⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⵖⴰⵔⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵓⵢⵓⵔ ⵅ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵏⴻⵃⴹⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K18_59","012_8_59","1KI","8","59","59","ⴻⵊⵊ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵓⵃⴻⵛⵛⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⴰⴷ ⵉⵍⵉⵏ ⵓⴷⵙⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⴰⵙⵙ ⵙ ⵎⵉⵏ ⵉ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵡⴰⵙⵙ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("K18_60","012_8_60","1KI","8","60","60","ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴷⵉⵏ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("K18_61","012_8_61","1KI","8","61","61","ⵎⴰⵃⴻⵏⴷ ⵓⵍ ⵏⵡⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵓⵏ ⴰⴽ-ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("K18_62","012_8_62","1KI","8","62","62","ⵉⵖⴰⵔⵚ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K18_63","012_8_63","1KI","8","63","63","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵖⴰⵔⵚ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵏⵏⵉ ⵉⵖⴰⵔⵚ ⵉ ⵙⵉⴷⵉ: ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ⴰⵎⵎⵓ ⵉ ⵉⴷⴻⵛⵛⴻⵏ ⵓⵊⴻⴵⵉⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K18_64","012_8_64","1KI","8","64","64","ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵓⵊⴻⴵⵉⴷ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴷⵉⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵍⴰ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ⵎⴰⵖⴰⵔ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K18_65","012_8_65","1KI","8","65","65","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵍⵄⵉⴷ ⵄⴰⵡⴻⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ, ⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ ⴰⵍ ⵜⴰⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ: ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵍⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴽⵜⴰⵔ, ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K18_66","012_8_66","1KI","8","66","66","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵢⴰⵔⵅⵓ ⵏⴻⵜⵜⴰ ⵉ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴰⵔⴽⴻⵏ ⴰⵊⴻⴵⵉⴷ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵙ ⵡⵓⵍ ⵉⴼⴰⵔⵃ ⵓ ⵙ ⵍⵅⴰⴹⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⴰⵡⵓⴷ ⵓ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K19_1","012_9_1","1KI","9","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵓⵍⵉⵎⴰⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⵉ ⵓ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⴳⴳ, ");
INSERT INTO rift_vpl VALUES ("K19_2","012_9_2","1KI","9","2","2","ⵉⴱⴰⵏ-ⴷⴷ ⵙⵉⴷⵉ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⴱⴰⵏ ⴷⵉ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K19_3","012_9_3","1KI","9","3","3","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵛ ⵓ ⵉ ⵓⵃⴻⵛⵛⴻⵎ ⵏⵏⴻⵛ ⵉ ⵣⵉ ⵜⵃⴻⵛⵛⵎⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⴻⴱⵏⵉⴷ, ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵜⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⴷⵉⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ ⵓⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴷ ⵡⵓⵍ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("K19_4","012_9_4","1KI","9","4","4","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ ⵙ ⵡⵓⵍ ⵉⵎⵓⵏ ⵓ ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⵓ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("K19_5","012_9_5","1KI","9","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵛ ⵅ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ, ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⵉ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("K19_6","012_9_6","1KI","9","6","6","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ, ⵛⴻⴽ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵃⴻⵟⵟⴰⵎ ⵄⴰⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⴷ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵏⵏⵉ ⵡⵛⵉⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵏⴷⵇⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("K19_7","012_9_7","1KI","9","7","7","ⵅⴻⵏⵏⵉ ⴰⴷ ⵇⴹⵉⵖ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ ⵓⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴰⴷ ⵜⵜ ⵎⵎⴻⵏⴹⴰⵔⴻⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵓ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵙⵜⴻⵀⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("K19_8","012_9_8","1KI","9","8","8","ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵜⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⴽⴽⴻⵏ, ⴰⴷ ⵉⵜⴻⴱⵀⴻⵜ ⴰⴷ ⵉⵚⴻⴼⴼⴰⵔ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵎⵎⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ?’ ");
INSERT INTO rift_vpl VALUES ("K19_9","012_9_9","1KI","9","9","9","ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵓⵢⵓⵔⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⴱⴻⵏⴷⵇⴻⵏ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵄⴻⴱⴷⴻⵏ, ⵅ ⵓⵢⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ-ⴰ ⵅⴰⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("K19_10","012_9_10","1KI","9","10","10","ⴰⵡⴰⵔⵏⵉ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⵉ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵎⵙⴰⵔ ");
INSERT INTO rift_vpl VALUES ("K19_11","012_9_11","1KI","9","11","11","- ⴰⵎ ⵉⵡⵛⴰ ⵃⵉⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ, ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵙ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ ⴷ ⵡⵓⵔⴻⵖ - ⴰⵇⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵡⵛⴰ ⵉ ⵃⵉⵔⴰⵎ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K19_12","012_9_12","1KI","9","12","12","ⵃⵉⵔⴰⵎ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵚⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⵣⴰⵔ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵡⴰⵔ ⵛⵏⴰⵏⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K19_13","012_9_13","1KI","9","13","13","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵏⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⴰⵡⵎⴰ?” ⵓ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⴰⵙⴻⵏⵜ: ‘ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴰⴱⵓⵍ’. ⵏⵉⵜⴻⵏⵜⵉ ⵜⵜⵡⴰⵍⴰⵖⴰⵏⵜ ⴰⵎⵎⵓ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K19_14","012_9_14","1KI","9","14","14","ⵃⵉⵔⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵉ ⵓⵊⴻⴵⵉⴷ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K19_15","012_9_15","1KI","9","15","15","ⴷ ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵅ ⵍⵊⵉⵣⵢⴰ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⵇⴻⵍⵄⴰ ⴷ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵃⴰⵚⵓⵔ ⴷ ⵎⴰⵊⵉⴷⴷⵓ ⴷ ⵊⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K19_16","012_9_16","1KI","9","16","16","ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵜⵓⵖⴰ ⵉⴳⴻⵄⵄⴻⴷ, ⵉⵟⵟⴻⴼ ⵊⴰⵣⴰⵔ, ⵉⵇⴻⴷⴷ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ. ⵉⵏⵖⴰ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⴷ ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⵜⴻⵙⵍⵉⵜ ⵉ ⵢⴻⴵⵉⵙ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K19_17","012_9_17","1KI","9","17","17","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⵏⴰ ⵅⴻⵏⵏⵉ ⵊⴰⵣⴰⵔ ⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵡⴰⴷⴷⴰⵢ ");
INSERT INTO rift_vpl VALUES ("K19_18","012_9_18","1KI","9","18","18","ⴷ ⴱⴰⵄⵍⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⵜⴰⴷⵎⴰⵔ ⴷⵉ ⵍⴻⵅⵍⴰ ");
INSERT INTO rift_vpl VALUES ("K19_19","012_9_19","1KI","9","19","19","ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵍⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵎⵏⴰⵢⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵜ ⵉⴱⵏⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵅ ⵉⵃⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("K19_20","012_9_20","1KI","9","20","20","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ, ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("K19_21","012_9_21","1KI","9","21","21","ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⵏ ⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵍⵊⵉⵣⵢⴰ ⵏ ⵜⴻⵙⵎⵓⵖⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K19_22","012_9_22","1KI","9","22","22","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⴳⴳⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷ ⵉⵙⵎⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵏⴻⵖⵔⴰⴼⴻⵏ ⵏⵏⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K19_23","012_9_23","1KI","9","23","23","ⵉⵏⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴹⴻⴱⴱⴰⵔⴻⵏ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K19_24","012_9_24","1KI","9","24","24","ⵎⴰⵛⴰ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ ⵜⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⴱⵏⴰ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⵏⴰ ⵍⵇⴻⵍⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("K19_25","012_9_25","1KI","9","25","25","ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⴱⵏⴰ ⵉ ⵙⵉⴷⵉ. ⵄⴰⵡⴻⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵙⴻⵍⵍⴻⵎ ⵏⴻⵜⵜⴰ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵎ ⵜⴻⴽⵎⴻⵍ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K19_26","012_9_26","1KI","9","26","26","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⵏⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⴳⵔⴰⵡ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⴷⵉ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⴰⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵍⴰⵜ, ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K19_27","012_9_27","1KI","9","27","27","ⵃⵉⵔⴰⵎ ⵉⵙⵙⴻⴽⴽ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴰⴳⵔⴰⵡ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⵉ, ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵍⴻⴱⵃⴰⵔ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K19_28","012_9_28","1KI","9","28","28","ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⴼⵉⵔ ⵓ ⴽⵙⵉⵏ ⵙⵙⴻⵏⵏⵉ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K110_1","012_10_1","1KI","10","1","1","ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵜⴻⵙⵍⴰ ⵅ ⵛⵛⴻⵏⵏⵄⴻⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⵇⴻⴵⴻⴱ ⵙ ⵜⵃⵓⵊⴰ ⵏ ⵜⵡⴰⴼⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("K110_2","012_10_2","1KI","10","2","2","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⴰ$ⴰⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ ⵙ ⴷⴷⵇⴻⵍ ⵏ ⵡⴰⴳⵍⴰ ⴰⵟⵟⴰⵙ, ⵙ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵄⵟⵓⵔ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ, ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("K110_3","012_10_3","1KI","10","3","3","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵛⴰⵔⵃ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵜⵃⴰⵊⴰ ⵏⴻⵜⵜⴰⵜ. ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵙ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⴰⵙ ⵜ ⵉⵛⴰⵔⵔⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("K110_4","012_10_4","1KI","10","4","4","ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵜⴻⵥⵔⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵉⴱⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("K110_5","012_10_5","1KI","10","5","5","ⴷ ⵎⴰⵛⵛⴰ ⵅ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵙ, ⴷ ⵎⴰⵎⵎⴻⵛ ⵇⵇⵉⵎⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴷ ⵎⴰⵎⵎⴻⵛ ⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵏⵏⴻⵙ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ, ⴷ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵏⵏⴻⵙ, ⴷ ⴷⴷⵔⵓⵊ ⵏⵏⴻⵙ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵉ ⵅⴻⴼ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⴷⴰⵢⴻⵙ ⵄⵍⴰⵃⴰⵍ ⴱⵓⵃⴱⴻⵍ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K110_6","012_10_6","1KI","10","6","6","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴰⵡⴰⵍ ⵏⵏⵉ ⵙⵍⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ, ⵏⵉⵛⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("K110_7","012_10_7","1KI","10","7","7","ⵏⴻⵛⵛ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵖ ⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ ⴷⴰⵏⵉⵜⴰ ⵓ ⵅⴻⵏⵏⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵥⵔⵉⵏⵜ ⴰⵢⴰ. ⵅⵣⴰⵔ ⴰⵣⵢⴻⵏ ⵣⵉ ⴽⵓⵍ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ. ⵜⵉⵖⵉⵜ ⴷ ⵜⵛⵓⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴻⵏⵏⵄⴻⵜ ⵉ ⵅ ⵙⵍⵉⵖ, ⴰⵇⴰ ⵛⴻⴽ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K110_8","012_10_8","1KI","10","8","8","ⵙⵙⴻⵄⴷ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵛ, ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵍⴻⴱⴷⴰ, ⵉⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K110_9","012_10_9","1KI","10","9","9","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵅ ⵍⵅⴰⴹⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵢⴻⴳⴳ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ, ⵙ ⵓⵢⴰ ⵉⴳⴳⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K110_10","012_10_10","1KI","10","10","10","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵟⵓⵔ ⴷ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ. ⵉⵊⵊ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵍⴻⵄⵟⵓⵔ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵉ ⵉⵡⵛⵉⵏ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K110_11","012_10_11","1KI","10","11","11","ⴰⴳⵔⴰⵡ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵃⵉⵔⴰⵎ ⵉ-ⴷⴷ ⵢⵉⵡⵢⴻⵏ ⵓⵔⴻⵖ ⵣⴻⴳ ⵓⴼⵉⵔ, ⵢⵉⵡⵢⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵚⴰⵏⴷⴰⵍ ⴷ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵣⵉ ⵓⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K110_12","012_10_12","1KI","10","12","12","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵚⴰⵏⴷⴰⵍ ⵡⴰⵏⵉⵜⴰ ⴰⴼⵔⴰⵢⴻⵏ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵍⴰ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⵉ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ. ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵙⴰⵏⴷⴰⵍ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵏⵉⵖ ⵉⵜⵜⵡⴰⵥⴰⵔ ⵄⴰⴷ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K110_13","012_10_13","1KI","10","13","13","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵡⵛⴰ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵎⴰⵔⵔⴰ ⴷⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⵎⵎⴻⵥⵔⵉ, ⵎⵉⵏ ⵎⴰ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵄⴰⴷ, ⵄⵍⴰⵃⵚⴰⴱ ⵜⴰⵛⵔⵉⵎⵜ ⵏ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ. ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴻⵇⵍⴻⴱ, ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K110_14","012_10_14","1KI","10","14","14","ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵜⵓⵖⴰ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("K110_15","012_10_15","1KI","10","15","15","ⴱⵍⴰ ⵎⵉⵏ ⵉⴽⵙⵉ ⵣⴻⴳ ⵉⵜⵜⵉⵊⴰⵔⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵄⴰⵔⴰⴱⵉⵢⵢⴰ ⵓ ⵣⵉ ⵍⵡⵓⵍⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K110_16","012_10_16","1KI","10","16","16","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵙ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⴷⴷⵣⴻⵏ. ⵅ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K110_17","012_10_17","1KI","10","17","17","ⵢⴰⵔⵏⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵙ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⴷⴷⵣⴻⵏ. ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⴻⵍⵜ ⵎⵉⵏⴰⵢⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵜ. ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("K110_18","012_10_18","1KI","10","18","18","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵉ ⵍⵄⴰⵊ ⵓⵛⴰ ⵉⵖⴻⴵⴻⴼ ⵉ-ⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("K110_19","012_10_19","1KI","10","19","19","ⵍⵄⴰⵔⵛ ⵡⴰⵏⵉⵜⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵜⴰⵔⴻⴼⴼⵉⴷⵉⵏ ⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⵄⴰⵔⵛ ⵜⵓⵖⴰ-ⵜ ⵉⵇⵓⵡⵡⴰⵔ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⴽⵓⵔⵙⵉ ⵜⵓⵖⴰ ⴵⴰⵏ ⵉⵖⴰⴵⴻⵏ, ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K110_20","012_10_20","1KI","10","20","20","ⵜⴻⵏⵄⴰⵛ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵅ ⵙⴻⵜⵜⴰ ⵏ ⵜⴰⵔⴻⴼⴼⵉⴷⵉⵏ. ⴰⵎ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵄⴰⴷ ⵓⵍⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("K110_21","012_10_21","1KI","10","21","21","ⵎⴰⵔⵔⴰ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵜⵉⵙⵙⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴰⵢⴻⵙ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵃⴻⵙⵙⴱⴻⵏ ⵜⵜ ⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("K110_22","012_10_22","1KI","10","22","22","ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴰⴳⵔⴰⵡ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ ⵅ ⵍⴻⴱⵃⴰⵔ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵃⵉⵔⴰⵎ. ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵢⵓⴷⴻⴼ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ, ⵢⵉⵡⵉ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ, ⵍⵄⴰⵊ ⴷ ⵉⴱⴰⵖⵓⵙⴻⵏ ⴷ ⵉⵟⴰⵡⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K110_23","012_10_23","1KI","10","23","23","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵄⴷⵓ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷⴻⴳ ⵡⴰⴳⵍⴰ ⴷ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("K110_24","012_10_24","1KI","10","24","24","ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵢⴰⵔⵣⵓ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⴻⵎ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵍⴻⵏ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K110_25","012_10_25","1KI","10","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⴰⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵜⴰⵔⵣⴻⴼⵜ ⵏⵏⴻⵙ, ⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ, ⴰⵔⵔⵓⴹ, ⵍⴻⵙⵏⴰⵃ, ⵍⴻⵄⵟⵓⵔ, ⵉⵢⵙⴰⵏ ⴷ ⵉⵙⴰⵔⴷⴰⵏ. ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K110_26","012_10_26","1KI","10","26","26","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⵎⵓⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ, ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K110_27","012_10_27","1KI","10","27","27","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴰⵟⵟⴰⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵥⵔⴰ, ⵓ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴰⵟⵟⴰⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K110_28","012_10_28","1KI","10","28","28","ⵉⵢⵙⴰⵏ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵇⵉⵡⵉ. ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵜⵜⴰⵎⴰⵏ ⵉⵎⴻⵜⵏⴻⵏ ⵣⵉ ⵇⵉⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("K110_29","012_10_29","1KI","10","29","29","ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵓ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⵙ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ. ⵏⵉⵜⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K111_1","012_11_1","1KI","11","1","1","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵓⵍⴰ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ: ⵜⵉⵎⵖⴰⵔⵉⵏ ⵣⵉ ⵎⵓ’ⴰⴱ, ⵣⵉ ⵄⴰⵎⵎⵓⵏ, ⵣⵉ ⵉⴷⵓⵎ, ⵣⵉ ⵚⵉⴷⵓⵏ ⵓ ⵣⴻⴳ ⵉⵃⵉⵜⵜⵉⵢⵢⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("K111_2","012_11_2","1KI","11","2","2","ⵜⵉⵎⵖⴰⵔⵉⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵜⴰⴷⴼⴻⵎ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵜⵜⴰⴷⴼⴻⵏ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵖⵡⴰⵏ ⵏⵉⵜⵏⵉ ⵓⵍ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ!” ⵎⴰⵛⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵇⵇⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵙ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("K111_3","012_11_3","1KI","11","3","3","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵜⵉⵊⴻⴵⵉⴷⵉⵏ, ⵓ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵜⵉⵢⵢⴰ. ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵖⵡⴰⵏⵜ ⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K111_4","012_11_4","1KI","11","4","4","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⴻⵡⵙⴰⵔ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ ⵖⵡⴰⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵓⵍ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵢⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵎⵓⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵡⵓⵍ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K111_5","012_11_5","1KI","11","5","5","ⵙⵓⵍⵉⵎⴰⵏ ⵢⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⴰⵛⵜⵓⵔⵉⵜ, ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵉⵚⵉⴷⵓⵏⵉⵢⵢⴻⵏ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵎⵉⵍⴽⵓⵎ, ⵏⵏⵄⵉ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K111_6","012_11_6","1KI","11","6","6","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⵛⴹⴰⵔ ⴰⵟⵟⴰⵙ ⵉ ⵙⵉⴷⵉ ⴰⵎ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K111_7","012_11_7","1KI","11","7","7","ⵅⴻⵏⵏⵉ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⴽⴰⵎⵓⵛ, ⵏⵏⵄⵉ ⵏ ⵚⵚⴰⵏⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⵎⵓⵍⵉⴽ, ⵏⵏⵄⵉ ⵏ ⵚⵚⴰⵏⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K111_8","012_11_8","1KI","11","8","8","ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ, ⵜⵉⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵍⴻⴱⵅⵓⵔ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K111_9","012_11_9","1KI","11","9","9","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵙⵄⴰⵔ ⵙⵉⴷⵉ ⵅ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵉⵏⵣⵉ ⵓⵍ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵉⴱⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("K111_10","012_11_10","1KI","11","10","10","ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⴰ ⵍⵓⵎⵓⵔ ⵏⵉⵛⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⴳⴳⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓ ⵏⴻⵜⵜⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴹⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K111_11","012_11_11","1KI","11","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵙⵓⵍⵉⵎⴰⵏ: “ⵎⵉⵏⵣⵉ ⵉⵎⵙⴰⵔ ⴰⵛ ⴰⵎⵎⵓ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵛⴰ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴷ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵏⵏⵉ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵇⴻⵍⵄⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ-ⴰ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K111_12","012_11_12","1KI","11","12","12","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜ ⴳⴳⴻⵖ ⵄⴰⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵜⵜ ⵇⴻⵍⵄⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵎⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("K111_13","012_11_13","1KI","11","13","13","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⴽ ⵇⴻⵍⵄⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵎⴰⵔⵔⴰ. ⴰⴷ ⵡⵛⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵉ ⵎⵎⵉⵛ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("K111_14","012_11_14","1KI","11","14","14","ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽⴰⵔ-ⴷⴷ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊ ⵏ ⵍⴻⵄⴷⵓ ⵀⴰⴷⴰⴷ, ⵣⵉ ⵉⴷⵓⵎ. ⵜⵓⵖⴰ ⵀⴰⴷⴰⴷ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K111_15","012_11_15","1KI","11","15","15","ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵉⴷⵓⵎ ⵓ ⵢⵓⵡⴰⴱ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏⵏⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⴳⴻⵄⵄⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⴹⴻⵍ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵡⴰⴱ ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ ⴷⵉ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K111_16","012_11_16","1KI","11","16","16","ⵎⴰⵖⴰⵔ ⵢⵓⵡⴰⴱ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⵉⵜⴻⵃⵃⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵡⵜⴻⵎ ⴷⵉ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K111_17","012_11_17","1KI","11","17","17","ⵎⴰⵛⴰ ⵀⴰⴷⴰⴷ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵡⴻⵍ, ⵏⴻⵜⵜⴰ ⴷ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⴷⵓⵎⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⴰⴽⵉⴷⴻⵙ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⵜⵓⵖⴰ ⵀⴰⴷⴰⴷ ⵄⴰⴷ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴷ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K111_18","012_11_18","1KI","11","18","18","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵎⵉⴷⵢⴰⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴼⴰⵔⴰⵏ. ⴷⵉⵏⵏⵉ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴼⴰⵔⴰⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ. ⵡⴰⵏⵉⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵡⵛⴰ ⴰⵙ ⴰⵡⴰⵍ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵎⴰⵛⵛⴰ ⵓ ⵉⵡⵛⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K111_19","012_11_19","1KI","11","19","19","ⵀⴰⴷⴰⴷ ⵢⵓⴼⴰ ⴰⵔⴹⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵏⵉⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵓⵍⵜⵎⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵜⵊⴻⴵⵉⴷⵜ ⵜⴰⵃⴼⴰⵏⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("K111_20","012_11_20","1KI","11","20","20","ⵓⵍⵜⵎⴰⵙ ⵏ ⵜⴰⵃⴼⴰⵏⵉⵙ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵎⵎⵉⵙ ⵊⴰⵏⵓⴱⴰⵜ, ⵡⴻⵏⵏⵉ ⵜⴻⵙⵙⵓⵟⵟⵓⴹ ⵜⴰⵃⴼⴰⵏⵉⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵍⴰⵎⵉ ⵅⴻⵏⵏⵉ ⵊⴰⵏⵓⴱⴰⵜ ⵉⵢⵎⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K111_21","012_11_21","1KI","11","21","21","ⵉⵙⵍⴰ ⵀⴰⴷⴰⴷ ⴷⵉ ⵎⵉⵚⵔⴰ ⴱⴻⵍⵍⵉ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵡⴰⴱ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵎⵎⵓⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵀⴰⴷⴰⴷ ⵉ ⴼⵉⵔⵄⵓⵏ: “ⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ, ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("K111_22","012_11_22","1KI","11","22","22","ⵎⴰⵛⴰ ⴼⵉⵔⵄⵓⵏ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵛⴻⴽ ⵉⵅⴻⵚⵚⴻⵏ ⵖⴰⵔⵉ, ⵍⴰⵎⵉ ⴷⴰⵢⴻⴽ ⵥⵔⵉⵖ, ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵄⴻⵇⴱⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⴷⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("K111_23","012_11_23","1KI","11","23","23","ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵅⴰⵙ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵖⵏⵉ, ⵔⴰⵣⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵉⴷⴰⵄ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵏⵏⴻⵙ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("K111_24","012_11_24","1KI","11","24","24","ⵜⵓⵖⴰ ⵉⵙⵙⵎⵓⵏ ⵉⵔⵢⴰⵣⴻⵏ, ⵉⴷⵡⴻⵍ ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏⵙⴻⵏ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴷⴰⵡⵓⴷ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ. ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ, ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⵓ ⴰⵔⴻⵢⵢⵙⴻⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("K111_25","012_11_25","1KI","11","25","25","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵄⴷⵓ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵖⴰⵔ ⵉ ⵉⴳⴳⴰ ⵀⴰⴷⴰⴷ. ⵏⴻⵜⵜⴰ ⵉⵄⵉⴼⴼ ⵉⵙⵔⴰⵉⵍ ⵓ ⵢⴰⵔⴻⵢⵢⴻⵙ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵅ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K111_26","012_11_26","1KI","11","26","26","ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵉⵊⵊ ⵏ ⵉⴼⵔⴰⵜⵉ ⵣⵉ ⵚⴰⵔⴰⴷⴰⵜⴰ, ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵊⴻⴵⵉⴷ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵚⴰⵔⵓⵄⴰ, ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵊⵊⴰⵍⵜ.    ");
INSERT INTO rift_vpl VALUES ("K111_27","012_11_27","1KI","11","27","27","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⴻⵏⵏⴰ ⵍⵇⴻⵍⵄⴰ, ⵉⵇⵇⴻⵏ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K111_28","012_11_28","1KI","11","28","28","ⵜⵓⵖⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ⵉⵥⵔⴰ ⵙⵓⵍⵉⵎⴰⵏ ⴰⵇⴰ ⴰⵃⵓⴷⵔⵉ ⵉⵎⵃⴻⴹ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("K111_29","012_11_29","1KI","11","29","29","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴼⴼⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜ ⵓⵏⴰⴱⵉ ⴰⵅⵉⵢⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵊⴷⵉⴷ ⵓ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K111_30","012_11_30","1KI","11","30","30","ⴰⵅⵉⵢⴰ ⵉⵟⵟⴻⴼ ⴰⵔⵔⵓⴹ ⵏ ⵊⴷⵉⴷ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⵓ ⵉⵛⴰⵔⵔⴻⴳ ⵉ-ⵜ ⴷⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵣⵉⵢⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K111_31","012_11_31","1KI","11","31","31","ⵉⵏⵏⴰ ⵉ ⵢⴰⵔⵓⴱⵄⴰⵎ: “ⴽⵙⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⵣⵉⵢⵏⴰⵜ ⵉ ⵛⴻⴽ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵅⵥⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴰⵔⵔⴳⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵄⴻⵛⵔⴰ ⵏ ⵜⵇⴻⴱⴱⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("K111_32","012_11_32","1KI","11","32","32","ⵎⴰⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵏⴻⵜⵜⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ ⵏⴻⵛⵛ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K111_33","012_11_33","1KI","11","33","33","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ ⵓ ⵙⴻⵊⴷⴻⵏ ⵉ ⴰⵛⵜⵓⵔⵉⵜ, ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵉⵚⵉⴷⵓⵏⵉⵢⵢⴻⵏ, ⵉ ⴽⴰⵎⵓⵛ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵓ ⵉ ⵎⴰⵍⴽⴰⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵃⴹⵉⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⴰⵎ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K111_34","012_11_34","1KI","11","34","34","ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⴻⴽⴽⵙⴻⵖ ⵛⴰ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵙⵙⵎⴻⵜⵏⴻⵖ ⴷ ⵍⵃⴰⴽⴻⵎ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ, ⵡⴻⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⴷ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("K111_35","012_11_35","1KI","11","35","35","ⵎⴰⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵖ ⵜⴰⴳⴻⵍⴷⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵎⵉⵙ ⵓ ⴰⴷ ⵛⴻⴽ ⵡⵛⴻⵖ ⵄⴻⵛⵔⴰ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵣⵣⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("K111_36","012_11_36","1KI","11","36","36","ⵓ ⵉ ⵎⵎⵉⵙ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵉⵍⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⵍⴻⴱⴷⴰ ⵉⵛⵜ ⵏ ⵜⴼⴰⵡⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ ⵏⴻⵛⵛ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("K111_37","012_11_37","1KI","11","37","37","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵖ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K111_38","012_11_38","1KI","11","38","38","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⵅ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵎⵉ ⵉ ⵖⴰ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⴰⵎ ⵜ ⵉⴳⴳⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽⵉⴷⴻⴽ ⵓ ⴰⴷ ⴰⵛ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⴱⵏⵉⵖ ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("K111_39","012_11_39","1KI","11","39","39","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵀⵡⵉⵖ ⵜⴰⵔⵡⴰ ⵏ ⴷⴰⵡⵓⴷ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K111_40","012_11_40","1KI","11","40","40","ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵏⴻⵖ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⴰⵛⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴽⴽⴰⵔ, ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⵛⵉⵛⴰⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ. ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵎⵉⵙⵔⴰ ⴰⵍ ⵍⵎⴻⵡⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K111_41","012_11_41","1KI","11","41","41","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵜⵉⵖⵉⵜ ⵉ ⵖⴰⵔⴻⵙ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("K111_42","012_11_42","1KI","11","42","42","ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵃⴽⴻⵎ ⵙⵓⵍⵉⵎⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⵓⵖⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K111_43","012_11_43","1KI","11","43","43","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ ⵓ ⵎⵎⵉⵙ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K112_1","012_12_1","1KI","12","1","1","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K112_2","012_12_2","1KI","12","2","2","ⵓⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⵉ ⵎⵉⵚⵔⴰ - ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵉⵣⴷⴻⵖ ⴷⵉ ⵎⵉⵚⵔⴰ - ⵉⵎⵙⴰⵔ ");
INSERT INTO rift_vpl VALUES ("K112_3","012_12_3","1KI","12","3","3","ⴰⵇⴰ ⵙⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵊⵊⵉⵏ ⴰⴷ ⵅⴰⵙ ⵍⴰⵖⴰⵏ. ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵙⵉⵏ-ⴷⴷ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽ-ⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("K112_4","012_12_4","1KI","12","4","4","“ⴱⴰⴱⴰⵛ ⵉⴳⴳⴰ ⵅⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵉⵇⵙⴻⵃ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴰⵔⵅⵓ ⵛⴻⴽ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵇⴻⵙⵃⴻⵏ ⵏ ⴱⴰⴱⴰⵛ ⵓⵍⴰ ⴷ ⴰⵣⴰⵢⵍⵓ ⵉⴹⴻⵇⵍⴻⵏ ⵉ ⵅⴰⵏⴻⵖ ⵉⴳⴳⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵏⴻⵅⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("K112_5","012_12_5","1KI","12","5","5","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵢⵓⵔⴻⵎ ⵓ ⵄⴻⵇⴱⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ.” ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("K112_6","012_12_6","1KI","12","6","6","ⵉⵎⵛⴰⵡⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱⴰⵙ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⴷⴷⴰⵔ, ⵉⵏⵏⴰ: “ⵙ ⵎⵉⵏ ⵣⵉ ⴷ ⴰⵢⵉ ⵜⵡⴻⵚⵚⴰⵎ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵅ ⵍⴳⴻⵏⵙ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("K112_7","012_12_7","1KI","12","7","7","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⵙⵙ-ⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ, ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⵓ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵛⵏⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K112_8","012_12_8","1KI","12","8","8","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴹⴰⵔ ⵛⵛⵡⴰⵔ ⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⵡⵛⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵓⵛⴰ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⴱⴻⴷⴷⴻⵏ ⵍⴻⵅⵅⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K112_9","012_12_9","1KI","12","9","9","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ: “ⵎⴰⵏ ⵜᵉⵜⵜⵛⴰⵡⴰⵔⴻⵎ ⴰⴷ ⵜ ⴷⴷ-ⵏⴰⵔⵔ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⵉ, ⵏⵏⴰⵏ ⴰⵢⵉ: ‘ⵙⴰⵔⵅⵓ ⴰⵣⴰⵢⵍⵓ ⵉ ⵅⴰⵏⴻⵖ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵛ.’” ");
INSERT INTO rift_vpl VALUES ("K112_10","012_12_10","1KI","12","10","10","ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵜⵓⵖⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵔⴻⴷ ⵅ ⵍⴳⴻⵏⵙ ⵉ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⵍⴻⵏ, ⵉⵏⵏⴰⵏ: ‘ⴱⴰⴱⴰⵛ ⵉⵙⵙⴻⴹⵇⴻⵍ ⴰⵣⴰⵢⵍⵓ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵛⴻⴽ ⵙⴰⵔⵅⵓ ⵜ ⵅⴰⵏⴻⵖ!’ ⵓ ⴰⵎⵎⵓ ⵉ ⴽⵉⴷⵙⴻⵏ ⵉ ⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ: ‘ⴰⴹⴰⴹ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵏⵓ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("K112_11","012_12_11","1KI","12","11","11","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴱⴰⴱⴰ ⵉⵇⵇⴻⵏ ⴰⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵉⵇⴻⵙⵃⴻⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⴹⴻⵇⵍⴻⵖ ⵄⴰⴷ. ⴱⴰⴱⴰ ⵢⴰⵔⴻⴱⴱⴰ ⴽⴻⵏⵏⵉⵡ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⴱⵉⵖ ⵙ ⵉⵖⴰⵔⴹⵎⵉⵡⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("K112_12","012_12_12","1KI","12","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵄⴻⵇⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("K112_13","012_12_13","1KI","12","13","13","ⴰⵊⴻⴵⵉⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵉⵇⴻⵙⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⴹⴰⵔ ⵛⵛⵡⴰⵔ ⵉ ⴷ ⴰⵙ ⵡⵛⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K112_14","012_12_14","1KI","12","14","14","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⵡⴰⵔ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: “ⴱⴰⴱⴰ ⵉⵙⵙⴻⴹⵇⴻⵍ ⴰⵣⴰⵢⵍⵓ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴹⴻⵇⵍⴻⵖ ⵄⴰⴷ ⴰⵣⴰⵢⵍⵓ ⵏⵡⴻⵎ. ⴱⴰⴱⴰ ⵢⴰⵔⴻⴱⴱⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⴱⵉⵖ ⵙ ⵉⵖⴰⵔⴹⵎⵉⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K112_15","012_12_15","1KI","12","15","15","ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⵙⵍⵉ ⵛⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ, ⵎⴰⵖⴰⵔ ⴰⵏⴻⵇⵍⴻⴱ-ⴰ ⵜⵓⵖⴰ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵣⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵜⴻⵏ ⴰⵡⴰⵍ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⴰⵅⵉⵢⴰ, ⴰⵛⵉⵍⵓⵏⵉ, ⵉ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("K112_16","012_12_16","1KI","12","16","16","ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵥⵔⴰ ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵍⵉ ⵛⴰ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ: “ⵎⴰⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵖⴰⵔⵏⴻⵖ ⴷⵉ ⴷⴰⵡⵓⴷ? ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⵖⴰⵔ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ. ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ! ⵍⵀⴰ ⵍⴻⵅⵅⵓ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰ ⴰⵢⵜ ⵏ ⴷⴰⵡⵓⴷ!” ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K112_17","012_12_17","1KI","12","17","17","ⵎⴰⵛⴰ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵇⴰ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K112_18","012_12_18","1KI","12","18","18","ⴰⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⵙⴻⵏ ⴰⴷⵓⵔⴰⵎ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵍⵊⵉⵣⵢⴰ ⵏ ⵜⴻⵙⵎⵓⵖⵉ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⵊⴻⵎ ⵉ-ⵜ ⵙ ⵢⴻⵥⵔⴰ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ⴰⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵇⴻⴵⴻⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵏⵢⴰ ⴷⴻⵖⵢⴰ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K112_19","012_12_19","1KI","12","19","19","ⴰⵎⵎⵓ ⵉ ⵉⵖⴻⵡⵡⴻⵖ ⵉⵙⵔⴰⵉⵍ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K112_20","012_12_20","1KI","12","20","20","ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵍⴰ ⴰⵇⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⵄⵇⴻⴱ-ⴷⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⴷⴷ-ⵍⴰⵖⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⴹⴻⴼⴼⴰⵔ ⵄⴰⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵎⵖⵉⵔ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K112_21","012_12_21","1KI","12","21","21","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵜⵜⵡⴰⴷⴰⵔⵔⴱⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵖⴰⵔ ⵔⴰⵃⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K112_22","012_12_22","1KI","12","22","22","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵛⴰⵎⵄⵉⵢⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K112_23","012_12_23","1KI","12","23","23","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵜⴻⵏⵏⵉ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("K112_24","012_12_24","1KI","12","24","24","‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⴷⴻⵎ ⵓ ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⴰⵎ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵄⵇⴻⴱ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⵎⵙⴰⵔⴻⵏ ⵣⵣⴰⵢⵉ.’” ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. * ");
INSERT INTO rift_vpl VALUES ("K112_25","012_12_25","1KI","12","25","25","ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴱⵏⴰ ⵛⴰⴽⵉⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⵉⵏⵏⵉ. ⵙⵙⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⵉⴱⵏⴰ ⴼⴰⵏⵓⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K112_26","012_12_26","1KI","12","26","26","ⵉⵏⵏⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵍⴻⵅⵅⵓ ⴰⴷ ⴷⴷ-ⵜⴻⵄⵇⴻⴱ ⵜⴳⴻⵍⴷⵉⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K112_27","012_12_27","1KI","12","27","27","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵡⵓⵍ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵖⴰⵔ ⵙⵉⴷⵉⵜⵙⴻⵏ, ⵖⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ ⵓ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("K112_28","012_12_28","1KI","12","28","28","ⵉⵎⵛⴰⵡⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉ ⵍⴳⴻⵏⵙ: “ⴷ ⴰⵟⵟⴰⵙ ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⵎ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵅⵣⴰⵔ, ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵛⴻⴽ ⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ.”    ");
INSERT INTO rift_vpl VALUES ("K112_29","012_12_29","1KI","12","29","29","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵚⵚⴰⵏⴰⵎ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K112_30","012_12_30","1KI","12","30","30","ⴰⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵄⵔⴰⴹ ⵖⴰⵔ ⴷⴷⵏⵓⴱ. ⵍⴳⴻⵏⵙ ⵉⵣⵡⴰⵔ ⵢⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵍ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K112_31","012_12_31","1KI","12","31","31","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ⵉⴳⴳⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵟⵟⵔⵓⴼⴰ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("K112_32","012_12_32","1KI","12","32","32","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ, ⵉⴳⴳⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ, ⴰⵎ ⵍⵄⵉⴷ ⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⵉⴳⴳⴰ ⴰⵎⵎⵓ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵎ ⵉ ⵢⴻⴳⴳⴰ. ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⴱⵉⵜ-ⵉⵍ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("K112_33","012_12_33","1KI","12","33","33","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵓⵢⵓⵔ ⵉ ⵜⵓⵖⴰ ⵉⵅⴰⵔⵔⴻⵚ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⵉⴳⴳⴰ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵍⴻⴱⵅⵓⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K113_1","012_13_1","1KI","13","1","1","ⵅⵣⴰⵔ, ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ⵢⴰⵔⵓⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⴻⵀⵀⴻⴱ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K113_2","012_13_2","1KI","13","2","2","ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⴰ ⴰⵄⴰⵍⵟⴰⵔ, ⴰⵄⴰⵍⵟⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⵍⴻⵇ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵢⵓⵛⵉⵢⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⴽ ⵉⴳⴳ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵅⴰⴽ ⵉⵡⴻⵀⵀⴱⴻⵏ ⵍⴻⴱⵅⵓⵔ, ⵓ ⴰⴷ ⵅⴰⴽ ⵛⴻⵎⴹⴻⵏ ⵉⵖⵙⴰⵏ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K113_3","012_13_3","1KI","13","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ ⵉⵡⵛⴰ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵉⵏⵏⴰ: “ⵜⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵅ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ. ⵅⵣⴰⵔ, ⴰⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵉⵛⴰⵔⵔⴻⴳ ⵓ ⵉⵖⵖⴻⴹ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⵓⵏⵜ ⵉ ⵅⴰⵙ ⵉⴵⴰⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵃⵔⵓⴵⴻⴹ.” ");
INSERT INTO rift_vpl VALUES ("K113_4","012_13_4","1KI","13","4","4","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵡⴰⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵍⴰⵖⴰⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵏⵏⴰ: “ⵟⵟⴻⴼ ⵉ-ⵜ!” ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ, ⵢⵓⵥⴻⵖ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵄⴰⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K113_5","012_13_5","1KI","13","5","5","ⵉⵛⴰⵔⵔⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵃⵍⵓⴵⴻⴷ ⵣⵣⴰⵢⴻⵙ ⵢⵉⵖⵖⴻⴷ ⵏ ⵜⴰⴷⵓⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵉⵡⵛⴰ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K113_6","012_13_6","1KI","13","6","6","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ: “ⵣⴰⵡⴳ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵥⴰⴵ ⵅⴰⴼⵉ ⵃⵉⵎⴰ ⴰⴼⵓⵙ ⵉⵏⵓ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ!” ⵓⵛⴰ ⵉⵣⴰⵡⴳ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵓⵖⴰ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K113_7","012_13_7","1KI","13","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ: “ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⵔⴻⵢⵢⴻⵃ! ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ.” ");
INSERT INTO rift_vpl VALUES ("K113_8","012_13_8","1KI","13","8","8","ⵎⴰⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵓⵊⴻⴵⵉⴷ: “ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⴰⵣⵢⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴰⴽⵉⴷⴻⴽ ⴳⴳⵓⵔⴻⵖ ⵓ ⵡⴰⵔ ⵜⵜⵉⵛⴻⵖ ⴰⵖⵔⵓⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓⵍⴰ ⵡⴰⵔ ⴷⴰ ⵙⴻⵙⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K113_9","012_13_9","1KI","13","9","9","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⴻⵚⵚⴰ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ‘ⵛⴻⴽ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵜᵉⵜⵜᵉⵜⵜⴻⴷ ⵓ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵜⵙⴻⵙⵙⴻⴷ ⵓ ⵡⴰⵔ ⵜⵄⵉⵇⵇⵉⴱⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷⴷ-ⵜⵓⵙⵉⴷ.’” ");
INSERT INTO rift_vpl VALUES ("K113_10","012_13_10","1KI","13","10","10","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵔⵓⵃ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⵉⴱ ⵛⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K113_11","012_13_11","1KI","13","11","11","ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵉⵡⵙⴰⵔ. ⵎⵎⵉⵙ ⵏⵏⴻⵙ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⵃⴰⵊⴰ ⴰⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵓⵍⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵃⴰⵊⴰⵏ ⴰⵙ ⵜⴻⵏ ⵉ ⴱⴰⴱⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K113_12","012_13_12","1KI","13","12","12","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ: “ⵅ ⵎⴰⵏ ⴰⴱⵔⵉⴷ ⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ?” ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵥⵔⵉⵏ ⵎⴰⵏ ⴰⴱⵔⵉⴷ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵡⴻⵔⵢⴰⵣ ⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K113_13","012_13_13","1KI","13","13","13","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ: “ⴱⴰⵔⴷⵄⴻⵎ ⴰⵢⵉ ⵉ ⵡⴻⵖⵢⵓⵍ!” ⵏⵉⵜⵏⵉ ⴱⴰⵔⴷⵄⴻⵏ ⴰⵙ ⵉ ⵡⴻⵖⵢⵓⵍ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵢⴰ ⵅⴰⵙ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("K113_14","012_13_14","1KI","13","14","14","ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⴷⴷⴻⴼ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜ ⴰⵎ ⵉⵇⵇⵉⵎ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("K113_15","012_13_15","1KI","13","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵙ-ⴷⴷ ⴰⴽⵉⴷⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⴻⵛⵛ ⴰⵖⵔⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("K113_16","012_13_16","1KI","13","16","16","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴽⵉⴷⴻⴽ ⵄⴻⵇⴱⴻⵖ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴰⴽⵉⴷⴻⴽ ⴷⴷ-ⵜⵜⴰⵙⴻⵖ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ, ⵡⴰⵔ ⵙⴻⵙⵙⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K113_17","012_13_17","1KI","13","17","17","ⵎⴰⵖⴰⵔ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⵓ ⵡⴰⵔ ⵜⵙⴻⵙⵙⴻⴷ ⴰⵎⴰⵏ. ⵛⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴷⴷ-ⵜⵄⴻⵇⴱⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷⴷ-ⵜⵓⵙⵉⴷ.’” ");
INSERT INTO rift_vpl VALUES ("K113_18","012_13_18","1KI","13","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⴰⵎ ⵛⴻⴽ, ⵓ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ‘ⴰⵡⵢⵉ ⵜ ⵖⴰⵔⴻⴽ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⵛⵛ ⴰⵖⵔⵓⵎ, ⴰⴷ ⵉⵙⴻⵙⵙ ⴰⵎⴰⵏ.’” ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵅⴰⵔⵔⴻⵇ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K113_19","012_13_19","1KI","13","19","19","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵄⵇⴻⴱ ⴰⴽⵉⴷⴻⵙ, ⵉⵛⵛⴰ ⴰⵖⵔⵓⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵉⵙⵡⴰ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K113_20","012_13_20","1KI","13","20","20","ⵓⵎⵉ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("K113_21","012_13_21","1KI","13","21","21","ⵓ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⵖⴻⵡⵡⵖⴻⴷ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵍⵓⵎⵓⵔ ⵉ ⴷ ⴰⵛ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("K113_22","012_13_22","1KI","13","22","22","ⵎⴰⵛⴰ ⵜⵄⴻⵇⴱⴻⴷ ⵓ ⵜⴻⵛⵛⵉⴷ ⴰⵖⵔⵓⵎ ⵓ ⵜⴻⵙⵡⵉⴷ ⴰⵎⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⵅ ⵉ ⴷ ⴰⵛ ⵉⵏⵏⴰ: ‘ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴷⵉⵏ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜⵙⵙⴻⵙⴻⴷ ⴰⵎⴰⵏ, ⵅ ⵓⵢⴰ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⴰ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("K113_23","012_13_23","1KI","13","23","23","ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵛⵛⴰ ⴷ ⵉⵙⵡⴰ, ⵉⴱⴰⵔⴷⴻⵄ ⴰⵙ ⵉ ⵡⴻⵖⵢⵓⵍ ⵉ ⵓⵏⴰⴱⵉ ⵉ ⴷ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K113_24","012_13_24","1KI","13","24","24","ⴰⵎⵎⵓ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ, ⵉⵏⵖⴰ ⵉ-ⵜ. ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⴷⵉⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵓ ⴰⵖⵢⵓⵍ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴰⵢⵔⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵍⵅⴻⵛⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K113_25","012_13_25","1KI","13","25","25","ⵓ ⵅⵣⴰⵔ, ⵄⴷⵓⵏ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵥⵔⵉⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵅ ⵡⴻⴱⵔⵉⴷ ⵓⵍⴰ ⴷ ⴰⵢⵔⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵍⵅⴻⵛⴱⴻⵜ. ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵏⴰⴱⵉ ⵉⵡⵙⴰⵔⴻⵏ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K113_26","012_13_26","1KI","13","26","26","ⵓⵎⵉ ⴰⵏⴰⴱⵉ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔⵉⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵙⵍⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵡⴰ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵅ ⵓⵢⴻⵏⵏⵉ ⵉⵡⵛⴰ ⵉ-ⵜ ⵙⵉⴷⵉ ⵉ ⵡⴻⵢⵔⴰⴷ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵎⴻⵣⵣⴻⵇ ⵉ-ⵜ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K113_27","012_13_27","1KI","13","27","27","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴱⴰⵔⴷⵄⴻⵎ ⴰⵢⵉ ⵉ ⵡⴻⵖⵢⵓⵍ!” ⵏⵉⵜⵏⵉ ⴱⴰⵔⴷⵄⴻⵏ ⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("K113_28","012_13_28","1KI","13","28","28","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ, ⵢⵓⴼⴰ ⵍⵅⴻⵛⴱⴻⵜ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵅ ⵡⴻⴱⵔⵉⴷ ⵓⵍⴰ ⴷ ⴰⵖⵢⵓⵍ ⴷ ⵡⴰⵢⵔⴰⴷ ⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵅⴻⵛⴱⴻⵜ. ⴰⵢⵔⴰⴷ ⵡⴰⵔ ⵢⴻⵛⵛⵉ ⵍⵅⴻⵛⴱⴻⵜ ⵓ ⵡⴰⵔ ⵉⵎⴻⵣⵣⴻⵇ ⴰⵖⵢⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("K113_29","012_13_29","1KI","13","29","29","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⵏⴰⴱⵉ ⵍⵅⴻⵛⴱⴻⵜ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵡⴻⵖⵢⵓⵍ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⵜ ⴰⴽⵉⴷⴻⵙ. ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵏⴰⴱⵉ ⵉⵡⵙⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵉⵡⵡⴻⵜ ⴰⴳⴻⵊⴷⵓⵔ ⵓ ⴰⴷ ⵜ ⵉⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K113_30","012_13_30","1KI","13","30","30","ⵏⴻⵜⵜⴰ ⵉⵏⴹⴻⵍ ⵍⵅⴻⵛⴱⴻⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵅⴰⵙ ⴰⴳⴻⵊⴷⵓⵔ: “ⵓⵀ, ⵓⵎⴰ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("K113_31","012_13_31","1KI","13","31","31","ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜ ⵉⵏⴹⴻⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵅⵎⵉ ⵖⴰ ⵎⵎⵜⴻⵖ, ⵏⴻⴹⵍⴻⵎ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵉ ⴷⵉ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵙⵙⴰⵔⵙⴻⵎ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("K113_32","012_13_32","1KI","13","32","32","ⵎⴰⵖⴰⵔ ⴰⵡⴰⵍ ⵉ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ-ⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵏⵉⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K113_33","012_13_33","1KI","13","33","33","ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵡⴰⵍ-ⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⴻⴽⴽⵯⵉⵍ ⵛⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵄⴰⵡⴻⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵟⵟⵔⵓⴼⴰ ⵏ ⵍⴳⴻⵏⵙ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ⵡⴻⵏⵏⵉ ⵜ ⵉⵅⵙⴻⵏ, ⵢⴰⵍⴻⵇⵇⴻⵎ ⵉ-ⵜ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K113_34","012_13_34","1KI","13","34","34","ⵣⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵜⴻⵡⴹⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷⵉ ⴷⴷⵏⵓⴱ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵓⵜⴻⵃⵃⵉ ⴷ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K114_1","012_14_1","1KI","14","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⴰⴱⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K114_2","012_14_2","1KI","14","2","2","ⵉⵏⵏⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⴽⴽⴰⵔ, ⴱⴻⴷⴷⴻⵍ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵄⴻⵇⵇⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⵇⴰ ⵛⴻⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⵛⵉⵍⵓ. ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⴰⵏⴰⴱⵉ ⴰⵅⵉⵢⴰ ⵡⴻⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵏⵏⴰⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵍⴳⴻⵏⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K114_3","012_14_3","1KI","14","3","3","ⴽⵙⵉ ⴰⴽⵉⴷⴻⵎ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⵔⵓⵎⴻⵏ ⴷ ⵜⴻⴼⴹⵉⵍⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵇⴷⵉⵃ ⵏ ⵜⴰⵎⵎⴻⵏⵜ ⵓⵛⴰ ⵓⵢⵓⵔ ⵖⴰⵔⴻⵙ! ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵎ ⵉⵏⵉ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵓⵃⴻⵏⵊⵉⵔ.” ");
INSERT INTO rift_vpl VALUES ("K114_4","012_14_4","1KI","14","4","4","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⴽⴰⵔ, ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⵛⵉⵍⵓ, ⵜⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⵉⵢⴰ. ⴰⵅⵉⵢⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵡⵉⵍⵉ ⵎⴰⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵟⵟⴻⵎⵎⵙⴻⵏⵜ ⴷⵉ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K114_5","012_14_5","1KI","14","5","5","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⴰⵅⵉⵢⴰ: “ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵇⵙⴰ ⵅ ⵎⵎⵉⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵉⵀⵍⴻⵛ. ⵜⴰ ⴷ ⵜⴰ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵜⵉⵏⵉⴷ. ⵅⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ, ⴰⴷ ⵉⵎⵙⴰⵔ, ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⵙⵙⵏⵉⵄⵎⵉⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜⴻⵏ ⵏⵏⴻⵖⵏⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("K114_6","012_14_6","1KI","14","6","6","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵅⵉⵢⴰ ⵍⵃⴻⵙⵙ ⵏ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ! ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⵏⵉⵄⵎⵉⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⵎⴻⵛⵏⴰⵡ ⵛⴻⵎ ⴷ ⵉⵛⵜⴻⵏ ⵏⵏⴻⵖⵏⵉⵜ? ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵎ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉⵇⴻⵙⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K114_7","012_14_7","1KI","14","7","7","ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵢⴰⵔⵓⴱⵄⴰⵎ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵛⴻⴽ ⵣⵉ ⵊⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("K114_8","012_14_8","1KI","14","8","8","ⵓⵛⴰ ⵛⴰⵔⵔⴳⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵡⵛⵉⵖ ⴰⵛ ⵜⵜ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴰⵎ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ, ⵡⴻⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⵎⵖⵉⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("K114_9","012_14_9","1KI","14","9","9","ⵓ ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⵉⴷ ⵜⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵎⴰⵀⵓ ⵅ ⵎⵉⵏ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵛⴻⴽ, ⵓⵛⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵜⴻⴳⴳⵉⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉ ⵉⴼⴻⵙⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵄⴰⵔⴻⴷ, ⵓⵛⴰ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵢⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("K114_10","012_14_10","1KI","14","10","10","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴰⵡⵢⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵓ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵣⵉ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵅ ⵍⵃⵉⴹ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵊⵊⵉⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵎⵃⵉⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴼⴰⵔⴹⴻⵏ ⵍⴻⵖⴱⴰⵔ ⴰⵍ ⵖⴰ ⵉⵇⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K114_11","012_14_11","1KI","14","11","11","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉ ⵖⴰ ⵉⵎⵎⵜⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵢⵉⵟⴰⵏ ⵓ ⵡⵉ ⵖⴰ ⵉⵎⵎⵜⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵏⵏⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K114_12","012_14_12","1KI","14","12","12","“ⵓ ⵛⴻⵎ, ⴽⴽⴰⵔ, ⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵎ! ⵎⴰⵍⴰ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K114_13","012_14_13","1KI","14","13","13","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵅⴰⵙ ⵡⵜⴻⵏ ⴰⴳⴻⵊⴷⵓⵔ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜ ⵏⴻⴹⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⵏⴹⴻⵍ, ⵎⴰⵖⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⵜⵜⵡⴰⴼ ⴷⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K114_14","012_14_14","1KI","14","14","14","ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴰⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⴻⵃⵃⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⵙⵙ ⴰⵇⴰ ⴷ ⵡⴰ. ⵎⵉⵏ ⴷⵉⵏ? ⵡⴰⵀ, ⵄⴰⴷ ⵍⴻⵅⵅⵓ! ");
INSERT INTO rift_vpl VALUES ("K114_15","012_14_15","1KI","14","15","15","ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⵡⴻⵜ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵙⵙⴰ ⴷ ⵙⵙⴰ ⴰⵎ ⵓⵖⴰⵏⵉⵎ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵍⴻⵄ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵉⵚⴻⴱⵃⴻⵏ ⵉ ⵉⵡⵛⴰ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴻⵢⵢⴻⵛ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓ ⵙⵄⴰⵔⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K114_16","012_14_16","1KI","14","16","16","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵉ ⵉⴳⴳⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵉ ⵣⵉ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("K114_17","012_14_17","1KI","14","17","17","ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵜᵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵓⵛⴰ ⵜⵉⵡⴻⴹ ⵖⴰⵔ ⵜⵉⵔⵚⴰ. ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵖⴰⵔ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵎⵎⵓⵜ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K114_18","012_14_18","1KI","14","18","18","ⵏⵉⵜⵏⵉ ⵏⴻⴹⵍⴻⵏ ⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵡⵜⴰ ⵅⴰⵙ ⴰⴳⴻⵊⴷⵓⵔ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⴰⵏⴰⴱⵉ ⴰⵅⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K114_19","012_14_19","1KI","14","19","19","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⴰⵎⵎⴻⵛ ⵉⵎⵎⵏⴻⵖ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵃⴽⴻⵎ, ⵅⵣⴰⵔ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K114_20","012_14_20","1KI","14","20","20","ⵓⵙⵙⴰⵏ ⵉ ⵉⵃⴽⴻⵎ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵓ ⵎⵎⵉⵙ ⵏⴰⴷⴰⴱ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K114_21","012_14_21","1KI","14","21","21","ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵜⵓⵖⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⵉⵄⵎⴰ, ⵏⴻⵜⵜⴰⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K114_22","012_14_22","1KI","14","22","22","ⵢⴰⵀⵓⴷⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⵉⵜⵏⵉ ⵙⵄⴰⵔⴻⵏ ⵜ ⵎⴰⵀⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵙ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵅⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K114_23","012_14_23","1KI","14","23","23","ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴱⵏⴰⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵢⵓⵄⵍⴰⵏ ⵓ ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("K114_24","012_14_24","1KI","14","24","24","ⵜⵓⵖⴰ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵎⴻⵜⵍⴻⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵍⵡⴰⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K114_25","012_14_25","1KI","14","25","25","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵛⵉⵛⴰⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⴹⵉⴷⴷ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K114_26","012_14_26","1KI","14","26","26","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵍⴻⴽⵏⵓⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵍⴻⴽⵏⵓⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵡⴰ, ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵎⴰⵔⵔⴰ. ⵢⵉⵡⵉ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K114_27","012_14_27","1KI","14","27","27","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏⵜ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵣⵉ ⵏⵏⵃⴰⵙ. ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵄⴻⵙⵙⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K114_28","012_14_28","1KI","14","28","28","ⵎⴻⵍⵎⵉ ⵎⴰ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⴰⵔⴻⴱⴱⵓⵏ ⵜⴻⵏⵜ ⵓ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("K114_29","012_14_29","1KI","14","29","29","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K114_30","012_14_30","1KI","14","30","30","ⵜⵓⵖⴰ ⵉⴵⴰ ⵓⵎⴻⵏⵖⵉ ⵊⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K114_31","012_14_31","1KI","14","31","31","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⵉⵄⵎⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⵄⴰⵎⵎⵓⵏⵉⵜ. ⵎⵎⵉⵙ ⴰⴱⵉⵢⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_1","012_15_1","1KI","15","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵉⴷⵡⴻⵍ ⴰⴱⵉⵢⴰⵎ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K115_2","012_15_2","1KI","15","2","2","ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵄⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⴱⵉⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K115_3","012_15_3","1KI","15","3","3","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏ ⴱⴰⴱⴰⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵇⴱⴻⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵓⵖⵉ ⵛⴰ ⵉⵛⴹⴰⵔ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵡⵓⵍ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K115_4","012_15_4","1KI","15","4","4","ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴷⴰⵡⵓⴷ ⵉⵡⵛⴰ ⴰⵙ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵎⵉ ⵉⴳⴳⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵎⵎⵉⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵓ ⵓⵎⵉ ⵉⴳⴳⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("K115_5","012_15_5","1KI","15","5","5","ⵎⴰⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ, ⵎⵖⵉⵔ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵔⵉⵢⴰ, ⴰⵃⵉⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("K115_6","012_15_6","1KI","15","6","6","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵎⴻⵏⵖⵉ ⵊⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_7","012_15_7","1KI","15","7","7","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⴱⵉⵢⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⴰⵎⴻⵏⵖⵉ ⵊⴰⵔ ⴰⴱⵉⵢⴰⵎ ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K115_8","012_15_8","1KI","15","8","8","ⴰⴱⵉⵢⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⴰⵙⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_9","012_15_9","1KI","15","9","9","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴷⵡⴻⵍ ⴰⵙⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K115_10","012_15_10","1KI","15","10","10","ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵡⴰⵃⵉⵜ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵃⴻⵏⵏⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵄⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⴱⵉⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K115_11","012_15_11","1KI","15","11","11","ⴰⵙⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K115_12","012_15_12","1KI","15","12","12","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉⵎⴻⵜⵍⴻⵢⵢⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_13","012_15_13","1KI","15","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⵓⵍⴰ ⴷ ⵃⴻⵏⵏⴰⵙ ⵎⴰⵄⴽⴰ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵉ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ. ⴰⵙⴰ ⵉⵇⴻⵙⵙ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵎⴹ ⵉ-ⵜⵜ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K115_14","012_15_14","1KI","15","14","14","ⵡⴰⵔ ⵜⵜⵡⴰⵃⴻⵢⵢⴷⴻⵏⵜ ⵍⴻⴳⵄⵓⴷⵉ, ⵎⴰⵛⴰ ⵓⵍ ⵏ ⴰⵙⴰ ⵜⵓⵖⴰ ⵉⵛⴹⴰⵔ ⵏⵉⵛⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_15","012_15_15","1KI","15","15","15","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⵓⵍⴰ ⴷ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ: ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K115_16","012_15_16","1KI","15","16","16","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵎⴻⵏⵖⵉ ⵊⴰⵔ ⴰⵙⴰ ⴷ ⴱⴰⵄⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K115_17","012_15_17","1KI","15","17","17","ⴱⴰⵄⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵉ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⴱⵏⴰ ⵔⴰⵎⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴰⵙⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_18","012_15_18","1KI","15","18","18","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⴰⵙⴰ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵜⴰⴱⵔⵉⵎⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵣⵢⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("K115_19","012_15_19","1KI","15","19","19","“ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⵊⴰⵔ ⴱⴰⴱⴰ ⴷ ⴱⴰⴱⴰⵛ. ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ. ⵔⵓⵃ, ⴼⵙⵉ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⴱⴰⵄⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴽⴰⵔ ⴰⴷ ⵅⴰⴼⵉ ⵉⴳⴳⵯⴻⵊ.” ");
INSERT INTO rift_vpl VALUES ("K115_20","012_15_20","1KI","15","20","20","ⴱⵉⵏⵀⴰⴷⴰⴷ ⵉⵙⵍⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⵄⵉⵢⵓⵏ ⴷ ⴷⴰⵏ ⴷ ⴰⴱⴰⵍ-ⴱⴰⵢⵜ-ⵎⴰⵄⴽⴰ ⴷ ⵎⴰⵔⵔⴰ ⴽⵉⵏⵏⴰⵔⵓⵜ. ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("K115_21","012_15_21","1KI","15","21","21","ⵓⵎⵉ ⴱⴰⵄⵛⴰ ⵉⵙⵍⴰ ⵅ ⵓⵢⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴷⵉ ⵍⴻⴱⵏⵉ ⵏ ⵔⴰⵎⴰ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⵉⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("K115_22","012_15_22","1KI","15","22","22","ⴰⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵉⵊⵊⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵃⴻⴷ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⵙⴻⵏ ⵉⵥⵔⴰ ⵣⵉ ⵔⴰⵎⴰ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵏⵏⴰ ⴱⴰⵄⵛⴰ. ⵓ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉⴱⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵊⵉⴱⵄⴰ ⴷⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("K115_23","012_15_23","1KI","15","23","23","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵙⴰ, ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉⴱⵏⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵡⵙⴰⵔ, ⵉⵀⵍⴻⵛ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K115_24","012_15_24","1KI","15","24","24","ⴰⵙⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_25","012_15_25","1KI","15","25","25","ⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K115_26","012_15_26","1KI","15","26","26","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⴱⴰⴱⴰⵙ ⵓ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K115_27","012_15_27","1KI","15","27","27","ⴱⴰⵄⵛⴰ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵢⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵉⴳⴳⴰ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓ ⴱⴰⵄⵛⴰ ⵉⵖⵍⴻⴱ ⵅⴰⵙ ⴷⵉ ⵊⵉⴱⴱⴰⵜⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓⵎⵉ ⵏⴰⴷⴰⴱ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵏⵏⴹⴻⵏ ⵉ ⵊⵉⴱⴱⴰⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K115_28","012_15_28","1KI","15","28","28","ⵉⵏⵖⴰ ⵉ-ⵜ ⴱⴰⵄⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K115_29","012_15_29","1KI","15","29","29","ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵇⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ. ⵓⵍⴰ ⴷ ⵛⴰ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵏⵏⴻⴼⵙ, ⵡⴰⵔ ⵜ ⵉⵊⵊⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ, ⴰⵍⴰⵎⵉ ⵜ ⵉⵜⴻⵃⵃⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴰⵅⵉⵢⴰ, ⴰⵛⵉⵍⵓⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("K115_30","012_15_30","1KI","15","30","30","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉ ⵣⵉ ⵉⵅⴹⴰ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵣⵉ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵅⴻⵡⵡⵊⴻⵏ ⵉ ⵣⵉ ⵉⵙⵄⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K115_31","012_15_31","1KI","15","31","31","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵏⴰⴷⴰⴱ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K115_32","012_15_32","1KI","15","32","32","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵎⴻⵏⵖⵉ ⵊⴰⵔ ⴰⵙⴰ ⴷ ⴱⴰⵄⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K115_33","012_15_33","1KI","15","33","33","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⴱⴰⵄⵛⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵢⴰ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⵉⵔⵚⴰ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K115_34","012_15_34","1KI","15","34","34","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵓ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_1","012_16_1","1KI","16","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⴰⵏⵉ. ⴰⵡⴰⵍ ⵜⵓⵖⴰ ⴹⵉⴷⴷ ⵉ ⴱⴰⵄⵛⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K116_2","012_16_2","1KI","16","2","2","“ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ-ⴷⴷ ⵛⴻⴽ ⵣⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵓ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵓ ⵜⴰⵔⵔⵉⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ ⵓⵎⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵄⴰⵔⴻⴷ ⵙ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K116_3","012_16_3","1KI","16","3","3","ⵅⵣⴰⵔ, ⵙ ⵓⵢⴰ ⴰⴷ ⵎⵃⵉⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴱⴰⵄⵛⴰ ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("K116_4","012_16_4","1KI","16","4","4","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⵄⵛⴰ ⵉ ⵖⴰ ⵉⵎⵎⵜⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵢⵉⵟⴰⵏ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵎⵎⵓⵜⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵢⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("K116_5","012_16_5","1KI","16","5","5","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴱⴰⵄⵛⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K116_6","012_16_6","1KI","16","6","6","ⴱⴰⵄⵛⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵜⵉⵔⵚⴰ. ⵎⵎⵉⵙ ⵉⵍⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K116_7","012_16_7","1KI","16","7","7","ⴰⵎⵎⵓ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⴰⵏⵉ, ⵓⵍⴰ ⵅ ⴱⴰⵄⵛⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵉ ⵉⴳⴳⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵜ ⵉⵙⵄⴰⵔ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵓⵛⴰ ⵓⵍⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵇⴹⴰ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_8","012_16_8","1KI","16","8","8","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵉⵍⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵛⴰ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⵉⵔⵚⴰ, ⵉ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_9","012_16_9","1KI","16","9","9","ⵣⵉⵎⵔⵉ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵉⴳⴳⴰ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⵉ ⵜⵉⵔⵚⴰ, ⵜⵓⵖⴰ ⵉⵙⵛⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⵚⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⴷⵉ ⵜⵉⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_10","012_16_10","1KI","16","10","10","ⵣⵉⵎⵔⵉ ⵢⵓⴷⴻⴼ, ⵉⵡⵜⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K116_11","012_16_11","1KI","16","11","11","ⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵏⵢⴰ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵇⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⵄⵛⴰ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ ⵅ ⵍⵃⵉⴹ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵓ ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⵉⵏⵜⴰⵇⴻⵎ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K116_12","012_16_12","1KI","16","12","12","ⴰⵎⵎⵓ ⵉ ⵉⵜⴻⵃⵃⴰ ⵣⵉⵎⵔⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⵄⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴱⴰⵄⵛⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ ⵢⴰⵀⵓ, ");
INSERT INTO rift_vpl VALUES ("K116_13","012_16_13","1KI","16","13","13","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏ ⴱⴰⵄⵛⴰ ⴷ ⴷⴷⵏⵓⴱ ⵏ ⵎⵎⵉⵙ ⵉⵍⴰ ⵉ ⵣⵉ ⵅⴹⴰⵏ ⵏⵉⵜⵏⵉ ⵓ ⵉ ⵣⵉ ⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ ⴰⵎ ⵙⵄⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵉⴱⴻⵟⵟⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K116_14","012_16_14","1KI","16","14","14","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵍⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K116_15","012_16_15","1KI","16","15","15","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⵣⵉⵎⵔⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵜⵉⵔⵚⴰ. ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⵃⴻⵚⵚⴰⵔ ⵉ ⵊⵉⴱⴱⴰⵜⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K116_16","012_16_16","1KI","16","16","16","ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵉⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⴷⵉⵏ, ⵉⵙⵍⴰ ⴰⵇⴰ ⵇⵇⴰⵔⴻⵏ: “ⵣⵉⵎⵔⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓⵛⴰ ⵉⵏⵖⴰ ⴰⵊⴻⴵⵉⴷ.” ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵔⴰ ⵄⵓⵎⵔⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵅ ⵍⵄⴻⵙⴽⴰⵔ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K116_17","012_16_17","1KI","16","17","17","ⵄⵓⵎⵔⵉ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵊⵉⴱⴱⴰⵜⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵉ ⵜⵉⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_18","012_16_18","1KI","16","18","18","ⵓⵎⵉ ⵉⵥⵔⴰ ⵣⵉⵎⵔⵉ ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵍⵇⴻⵍⵄⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵇⴻⴷⴷ ⵜⵉⵡⴰ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ");
INSERT INTO rift_vpl VALUES ("K116_19","012_16_19","1KI","16","19","19","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ, ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵓⵍⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵉ ⵉⴳⴳⴰ ⴰⵎ ⴷ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_20","012_16_20","1KI","16","20","20","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵣⵉⵎⵔⵉ, ⴷ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵉ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K116_21","012_16_21","1KI","16","21","21","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵎⵎⵙⴻⴱⴹⴰ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵉⵢⵏⴰⵜ. ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⴱⴻⴷⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵉⴱⵏⵉ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵏⴰⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵓ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⴱⴻⴷⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵄⵓⵎⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("K116_22","012_16_22","1KI","16","22","22","ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵄⵓⵎⵔⵉ, ⵜⵓⵖⴰ ⵉⵊⵀⴻⴷ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵉⴱⵏⵉ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵏⴰⵜ. ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ ⵜⵉⴱⵏⵉ ⵓ ⵄⵓⵎⵔⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K116_23","012_16_23","1KI","16","23","23","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵄⵓⵎⵔⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⴷⵉ ⵜⵉⵔⵚⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_24","012_16_24","1KI","16","24","24","ⵉⵙⵖⴰ ⴰⴷⵔⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵣⵉ ⵛⴰⵎⵉⵔ ⵙ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⴱⵏⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ. ⵉⵍⴰⵖⴰ ⴰⵙ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵉⴱⵏⴰ ‘ⵙⴰⵎⴰⵔⵢⴰ’, ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⵎ ⵏ ⵛⴰⵎⵉⵔ, ⴱⴰⴱ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K116_25","012_16_25","1KI","16","25","25","ⵄⵓⵎⵔⵉ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵎⴰⵀⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵉⵣⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K116_26","012_16_26","1KI","16","26","26","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⵉ ⴽⵓⵍ ⵜⴰⴱⵔⵉⴷⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵓ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵢⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ, ⵓⵎⵉ ⵙⵄⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵉⴱⴻⵟⵟⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K116_27","012_16_27","1KI","16","27","27","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵄⵓⵎⵔⵉ ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K116_28","012_16_28","1KI","16","28","28","ⵄⵓⵎⵔⵉ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵎⵎⵉⵙ ⴰⵅⴰⴱ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K116_29","012_16_29","1KI","16","29","29","ⴰⵅⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵎⵔⵉ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⵅⴰⴱ ⵎⵎⵉⵙ ⵏ ⵄⵓⵎⵔⵉ, ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_30","012_16_30","1KI","16","30","30","ⴰⵅⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵎⵔⵉ, ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵀⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⴻⵙ ⵉⵣⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K116_31","012_16_31","1KI","16","31","31","ⵜⵓⵖⴰ ⵜⵓⵢⵓⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵉⵣⴰⴱⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵜ-ⴱⴰⵄⴰⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵚⵉⴷⵓⵏⵉⵢⵢⴻⵏ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⴷ ⵉⵄⴱⴻⴷ ⵉ ⴱⴰⵄⵍ, ⵉⵙⵊⴻⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K116_32","012_16_32","1KI","16","32","32","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⴱⴰⵄⵍ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⵍ ⵏⵏⵉ ⵉⴱⵏⴰ ⵏⴻⵜⵜⴰ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K116_33","012_16_33","1KI","16","33","33","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ. ⴰⵅⴰⴱ ⵉⵄⴷⵓ ⵙ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵣⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K116_34","012_16_34","1KI","16","34","34","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⴱⵏⴰ ⵃⵉⵢⵉⵍ, ⵣⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵔⵉⵃⴰ. ⵉⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵓⵎ ⵏ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ ⴰⴱⵉⵔⴰⵎ ⵓ ⴷⵉ ⵙⵙⵓⵎ ⵏ ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ ⵙⴰⵊⵓⴱ ⵢⴰⵔⴻⴽⴽⴻⴱ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K117_1","012_17_1","1KI","17","1","1","ⵉⵍⵉⵢⴰ, ⵣⵉ ⵜⵉⵛⴱⵉ, ⵣⴻⴳ ⵉⵎⴻⵄⵣⴰⴱ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵉⵏⵏⴰ ⵉ ⴰⵅⴰⴱ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵏⵏⴷⴰ ⵏⵉⵖ ⴰⵏⵥⴰⵔ ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ-ⵢⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵢⴰ ⵎⵖⵉⵔ ⵙ ⵡⴰⵡⴰⵍ ⵉⵏⵓ!”    ");
INSERT INTO rift_vpl VALUES ("K117_2","012_17_2","1KI","17","2","2","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K117_3","012_17_3","1KI","17","3","3","“ⵓⵢⵓⵔ ⵙⵙⴻⵏⵏⵉ, ⴰⵔⵔ ⵙ ⵓⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵙⵏⵓⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵉⵖⵣⴰⵔⵜ ⵏ ⴽⵔⵉⵜ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K117_4","012_17_4","1KI","17","4","4","ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵓ ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵉ ⵉⴱⴰⵖⵍⵉⵡⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵛⴻⴽ ⴷⵉⵏⵏⵉ ⵙⵙⴻⵛⵛⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K117_5","012_17_5","1KI","17","5","5","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵉⴳⴳⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴰⴷ ⵉⵣⴷⴻⵖ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴽⵔⵉⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K117_6","012_17_6","1KI","17","6","6","ⵉⴱⴰⵖⵍⵉⵡⴻⵏ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵖⵔⵓⵎ ⴷ ⵡⴻⵢⵙⵓⵎ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓⵍⴰ ⴷ ⴰⵖⵔⵓⵎ ⴷ ⵡⴻⵢⵙⵓⵎ ⵖⴰⵔ ⵜⴰⵎⴻⴷⴷⵉⵜ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵡⴰ ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K117_7","012_17_7","1KI","17","7","7","ⴰⵡⴰⵔⵏⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵥⴻⵖ ⵜⵉⵖⵣⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵡⵜⵉ ⵛⴰ ⵡⴻⵏⵥⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K117_8","012_17_8","1KI","17","8","8","ⵢⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K117_9","012_17_9","1KI","17","9","9","“ⴽⴽⴰⵔ, ⵓⵢⵓⵔ ⵖⴰⵔ ⵚⴰⵔⴼⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵚⵉⴷⵓⵏ, ⵣⴷⴻⵖ ⴷⵉⵏⵏⵉ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⴷⵉⵏⵏⵉ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("K117_10","012_17_10","1KI","17","10","10","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵚⴰⵔⴼⴰⵜ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵜᵉⵜⵜⵃⴰⵔⵡⴰⵛ ⴰⴽⴻⵛⵛⵓⴹ. ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵛⴰ ⵏ ⵡⴰⵎⴰⵏ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴼ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("K117_11","012_17_11","1KI","17","11","11","ⵓⵎⵉ ⵜⵓⵢⵓⵔ ⵏⴻⵜⵜⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵉ ⴰⵢⴰ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵅⴰⵙ: “ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("K117_12","012_17_12","1KI","17","12","12","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏ ⵖⴰⵔⵉ ⴷ ⵜⴰⴼⴷⵉⵍⵜ, ⴰⵇⴰ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵡⵓⵔⵓ ⵏ ⵡⴰⵔⴻⵏ ⴷⴻⴳ ⵓⴱⵓⵇⴰⵍ ⴷ ⵛⴰ ⵏ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴼ! ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⵃⴰⵔⵡⵛⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⴻⵛⵛⵓⴹⴻⵏ ⵓ ⴰⴷ ⵜ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵏⴻⵛⵛ ⴰⴷ ⵏⴻⵎⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("K117_13","012_17_13","1KI","17","13","13","ⵉⵏⵏⴰ ⴰⵙ ⵉⵍⵉⵢⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ. ⵓⵢⵓⵔ, ⴻⴳⴳ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⵏⵏⵉⴷ, ⵎⴰⵛⴰ ⴻⴳⴳ ⴰⵢⵉ-ⴷⴷ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵛⵜ ⵏ ⵜⴻⴼⴹⵉⵍⵜ ⵓ ⴰⵡⵉ ⵜⵜ-ⵉ-ⴷⴷ ⴷⴰ ⵖⴰⵔⵉ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵛⴰ ⵉ ⵛⴻⵎ ⵓ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴷ ⵎⵎⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K117_14","012_17_14","1KI","17","14","14","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵔⴻⵏ ⴷⴻⴳ ⵓⴱⵓⵇⴰⵍ ⵡⴰⵔ ⵉⵅⴻⴽⴽⵯⵉ ⵓ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴼ ⵡⴰⵔ ⵜⵏⴻⵇⵇⵉⵚ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⴰⵏⵥⴰⵔ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("K117_15","012_17_15","1KI","17","15","15","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵢⵓⵔ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⵄⵍⴰⵃⵚⴰⴱ ⴰⵡⴰⵍ ⵏ ⵉⵍⵉⵢⴰ. ⴰⵎⵎⵓ ⵉ ⵉⵛⵛⴰ ⵏⴻⵜⵜⴰⵜ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K117_16","012_17_16","1KI","17","16","16","ⴰⵔⴻⵏ ⴷⴻⴳ ⵓⴱⵓⵇⴰⵍ ⵡⴰⵔ ⵉⵅⴻⴽⴽⵯⵉ ⴷ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴼ ⵡⴰⵔ ⵜⵏⴻⵇⵇⵉⵚ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵍⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K117_17","012_17_17","1KI","17","17","17","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵀⵍⴻⵛ ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ, ⵎⵎⵉⵙ ⵏ ⵍⵍⴰⵍⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ ⵢⴰⵔⵏⵉ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵔⵉ ⵄⴰⴷ ⵏⵏⴻⴼⵙ. ");
INSERT INTO rift_vpl VALUES ("K117_18","012_17_18","1KI","17","18","18","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⵉ ⵉⵍⵉⵢⴰ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⴰ ⵛⴻⴽ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵄⴻⵇⵍⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵉⵏⵓ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵎⵎⵉ?” ");
INSERT INTO rift_vpl VALUES ("K117_19","012_17_19","1KI","17","19","19","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴻⵡⵛ ⴰⵢⵉ-ⴷⴷ ⵎⵎⵉⵎ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵜ ⵣⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵙ, ⵢⴰⵔⴱⵓ ⵜ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴷⴻⵖ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵇⴰⵎⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K117_20","012_17_20","1KI","17","20","20","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰ ⵜⴻⴳⴳⵉⴷ ⵅⴻⵏⵏⵉ ⵄⴰⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷⵉ ⵜⴰⵊⵊⴰⵍⵜ-ⴰ ⵉ ⵖⴰⵔ ⵣⴻⴷⴷⵖⴻⵖ ⵏⴻⵛⵛ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⴰⵍⴰⵎⵉ ⵜⴻⵏⵖⵉⴷ ⵎⵎⵉⵙ?” ");
INSERT INTO rift_vpl VALUES ("K117_21","012_17_21","1KI","17","21","21","ⵏⴻⵜⵜⴰ ⵉⵙⴰⵔⵔⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵉⵡⴰ ⵉ ⵓⵃⴻⵏⵊⵉⵔ ⵓ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴻⵄⵇⴻⴱ ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("K117_22","012_17_22","1KI","17","22","22","ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵍⵉⵢⴰ ⵓⵛⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵄⴰⵡⴻⴷ ⵖⴰⵔⴻⵙ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K117_23","012_17_23","1KI","17","23","23","ⵉⵍⵉⵢⴰ ⵉⴽⵙⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵉⵙⵙⴻⵀⵡⴰ ⵜ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵜ ⵉ ⵢⴻⵎⵎⴰⵙ. ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ: “ⵅⵣⴰⵔ, ⵎⵎⵉⵎ ⵉⴷⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("K117_24","012_17_24","1KI","17","24","24","ⵜⴻⵏⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵉⵍⵉⵢⴰ: “ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⵇⴰ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("K118_1","012_18_1","1KI","18","1","1","ⴰⵡⴰⵔⵏⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵍⵉⵢⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ, ⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⴰⵏⵥⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K118_2","012_18_2","1KI","18","2","2","ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵉⵍⵉⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⴰⵅⴰⴱ. ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⵎⵖⴰⵔ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K118_3","012_18_3","1KI","18","3","3","ⴰⵅⴰⴱ ⵜⵓⵖⴰ ⵉⵍⴰⵖⴰ ⵉ ⵄⵓⴱⴰⴷⵢⴰ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵄⵓⴱⴰⴷⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K118_4","012_18_4","1KI","18","4","4","ⵓⵎⵉ ⵉⵣⴰⴱⴰⵍ ⵉⵇⴹⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵄⵓⴱⴰⴷⵢⴰ ⵢⵉⵡⵉ ⵎⵢⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ, ⵅⴻⵎⵙⵉⵏ ⵅⴻⵎⵙⵉⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵢⴻⴼⵔⵉ, ⵓ ⵉⵄⵜⴻⵇ ⵉ-ⵜⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_5","012_18_5","1KI","18","5","5","ⴰⵅⴰⴱ ⵉⵏⵏⴰ ⵉ ⵄⵓⴱⴰⴷⵢⴰ: “ⵓⵢⵓⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵏⴰⴼ ⴰⵀⴻⴷⴷⵓ ⵓ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵉⵢⵙⴰⵏ ⴷ ⵉⵙⴰⵔⴷⴰⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵓ ⴰⴷ ⵜⴰⴼ ⵏⵀⵍⴰ ⵎⴰ ⵏⴻⵏⵖⴰ ⵍⵎⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("K118_6","012_18_6","1KI","18","6","6","ⵏⵉⵜⵏⵉ ⴱⴹⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵊⴰⵔ ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵛⵓⵇⴻⵏ. ⴰⵅⴰⴱ ⵢⵓⵢⵓⵔ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ, ⵓ ⵄⵓⴱⴰⴷⵢⴰ ⵢⵓⵢⵓⵔ ⵅ ⵉⵊⵊ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵖⵏⵉ, ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K118_7","012_18_7","1KI","18","7","7","ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⵓⴱⴰⴷⵢⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵎⵎⴻⵍⵇⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵍⵉⵢⴰ. ⵄⵓⴱⴰⴷⵢⴰ ⵉⵄⵇⴻⵍ ⵉ-ⵜ, ⵉⵡⴹⴰ ⵣⵣⴰⵜⴻⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴰ: “ⵎⴰ ⴷ ⵛⴻⴽ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵍⵉⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("K118_8","012_18_8","1KI","18","8","8","ⵉⵏⵏⴰ ⴰⵙ ⵡⴰⵏⵉⵜⴰ: “ⴷ ⵏⴻⵛⵛ. ⵓⵢⵓⵔ, ⵉⵏⵏⴰ ⵉ ⵙⵉⴷⵉ ⵏⵏⴻⵛ: ‘ⵅⵥⴰⵔ, ⵉⵍⵉⵢⴰ ⴰⵇⴰ-ⵜ ⴷⴰⵏⵉⵜⴰ!’” ");
INSERT INTO rift_vpl VALUES ("K118_9","012_18_9","1KI","18","9","9","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵏ ⴷⴷⴻⵏⴱ ⵉ ⴳⴳⵉⵖ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⵙⴻⵍⵍⵎⴻⴷ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴰⵅⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("K118_10","012_18_10","1KI","18","10","10","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵎⴰⵏⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵅⴰⴽ ⵢⴰⵔⵣⵓ! ⵎⴰⵍⴰ ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ!’, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴰⴷ ⵉⵊⵊⴰⴵ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_11","012_18_11","1KI","18","11","11","ⵓ ⵍⴻⵅⵅⵓ ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ: ‘ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵙⵉⴷⵉ ⵏⵏⴻⵛ: ⵅⵣⴰⵔ ⵉⵍⵉⵢⴰ ⴰⵇⴰ-ⵜ ⴷⴰⵏⵉⵜⴰ!’ ");
INSERT INTO rift_vpl VALUES ("K118_12","012_18_12","1KI","18","12","12","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵅⵎⵉ ⵉ ⵅⴰⴽ ⵖⴰ ⵓⵢⵓⵔⴻⵖ, ⴰⵇⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⴽⵙⵉ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵏⵉ. ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵏⵉⵖ ⵉ ⴰⵅⴰⴱ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵉⴼ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ, ⵡⴰⵅⵅⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("K118_13","012_18_13","1KI","18","13","13","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵄⵉⵡⴷⴻⵏ ⵛⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏ ⴳⴳⵉⵖ ⵏⴻⵛⵛ, ⵓⵎⵉ ⵉⵣⴰⴱⴰⵍ ⵉⵏⵖⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵙⵉⴷⵉ? ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴽⵓⵍ ⵅⴻⵎⵙⵉⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵢⴻⴼⵔⵉ? ⵓⵍⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⵄⴻⵜⵇⴻⵖ ⵜⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷ ⵡⴰⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("K118_14","012_18_14","1KI","18","14","14","ⵓ ⵍⴻⵅⵅⵓ ⵜⴻⵇⵇⴰⵔⴻⴷ ‘ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵙⵉⴷⵉ ⵏⵏⴻⵛ: ⵅⵣⴰⵔ, ⵉⵍⵉⵢⴰ ⴰⵇⴰ-ⵜ ⴷⴰ!’ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("K118_15","012_18_15","1KI","18","15","15","ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵎⵉ ⴱⴻⴷⴷⴻⵖ, ⴰⵇⴰ ⵏⵉⵛⴰⵏ ⵏⴻⵛⵛ ⴰⴷ ⵙⴻⵛⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴰⵙⵙ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("K118_16","012_18_16","1KI","18","16","16","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵄⵓⴱⴰⴷⵢⴰ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⴰⵅⴰⴱ, ⵉⵅⴻⴱⴱⴰⵔ ⴰⵙ ⵜ. ⵓⵛⴰ ⴰⵅⴰⴱ ⵢⵓⵢⵓⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵉⵍⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K118_17","012_18_17","1KI","18","17","17","ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵅⴰⴱ ⵉⵍⵉⵢⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵅⴰⴱ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⴹⴻⵢⵢⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("K118_18","012_18_18","1KI","18","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴹⵉⵢⵢⵄⴻⵖ ⵛⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵊⵊⵉⵎ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("K118_19","012_18_19","1KI","18","19","19","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔⵉ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ ⵓⵍⴰ ⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴱⴰⵄⵍ ⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵣⵉ ⵟⵟⴰⴱⵍⴰ ⵏ ⵉⵣⴰⴱⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("K118_20","012_18_20","1KI","18","20","20","ⴰⵅⴰⴱ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉⵙⵙⵎⵓⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K118_21","012_18_21","1KI","18","21","21","ⵉⵍⵉⵢⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⵎ ⵄⴰⴷ ⵜⵜⵏⴻⵇⵍⴰⴱⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ? ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ, ⴹⴼⴰⵔⴻⵎ ⴰⵙ-ⴷⴷ, ⵓ ⵎⴰⵍⴰ ⴷ ⴱⴰⵄⵍ, ⵅⴻⵏⵏⵉ ⴹⴼⴰⵔⴻⵎ ⵡⴰⵏⵉⵜⴰ!” ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵓⵍⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("K118_22","012_18_22","1KI","18","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷ ⴰⵏⴰⴱⵉ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴱⴰⵄⵍ ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_23","012_18_23","1KI","18","23","23","ⴻⵊⵊ ⴰⴷ ⴰⵏⴻⵖ ⵡⵛⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⴼⴰⵔⵣⴻⵏ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴷ ⵜ ⴱⴹⴰⵏ ⵓ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵅ ⵓⴽⴻⵛⵛⵓⴹ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵖ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵖ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K118_24","012_18_24","1KI","18","24","24","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵍⴰⵖⴰⵎ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵍⴰⵖⵉⵖ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ, ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵔⴻⴱⴱⵉ.” ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⴰⵡⴰⵍ-ⴰ ⴷ ⵍⴻⵎⵍⵉⵃ!” ");
INSERT INTO rift_vpl VALUES ("K118_25","012_18_25","1KI","18","25","25","ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴱⴰⵄⵍ: “ⵅⴹⴰⵔⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓ ⵙⵙⵡⴻⵊⴷⴻⵎ ⴰⵙ ⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙ ⵡⴰⵟⵟⴰⵙ. ⵍⴰⵖⴰⵎ ⵅⴻⵏⵏⵉ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵔⵓⵙⴰⵎ ⵛⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K118_26","012_18_26","1KI","18","26","26","ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵏⴻⵜⵜⴰ ⵓ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜ. ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⵄⵍ, ⵣⵉ ⵜⵓⴼⴼⵓⵜ ⴰⵍ ⴰⵣⴰⵍ, ⵏⵏⴰⵏ: “ⴰ ⴱⴰⵄⵍ, ⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ!” ⵎⴰⵛⴰ ⵡⴰⵍⵓ ⵏ ⵍⵃⴻⵙⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵛⴰ. ⵏⵉⵜⵏⵉ ⵏⴻⴳⵣⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⴷⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_27","012_18_27","1KI","18","27","27","ⵖⴰⵔ ⵡⴰⵣⴰⵍ ⵉⴱⴷⴰ ⵉⵍⵉⵢⴰ ⵉⵜⵜⵇⴻⵙⵙⴰⵔ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵍⴰⵖⴰⵎ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ. ⵏⵉⵛⴰⵏ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵅⴻⵎⵎⴰⵎ, ⵏⵉⵖ ⵉⵄⴻⵣⵣⴻⵍ ⵛⵡⴰⵢⵜ, ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ⴰⴷ ⵜⴰⵖ ⵉⵜⵜⴻⵟⵟⴻⵚ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⴼⴰⵇ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("K118_28","012_18_28","1KI","18","28","28","ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵇⴻⵙⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⴻⵙⵢⵓⴼ ⴷ ⵉⵃⵔⵉⵛⴻⵏ ⴰⵎ ⵜⵏⴰⵎⵉⵜ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵓⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_29","012_18_29","1KI","18","29","29","ⵓⵎⵉ ⵉⵄⴷⵓ ⴰⵣⴰⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⴱⴱⴰⵏ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵍⵉⵙⵜⵉⵊⴰⴱⴰ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("K118_30","012_18_30","1KI","18","30","30","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ ⵉ ⵍⴳⴻⵏⵙ: “ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ!” ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵄⴷⴻⵍ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵀⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("K118_31","012_18_31","1KI","18","31","31","ⵉⵍⵉⵢⴰ ⵉⴽⵙⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵥⵔⴰ, ⵅ ⵍⵇⴻⴷⴷ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ ⵉ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K118_32","012_18_32","1KI","18","32","32","ⵙ ⵢⴻⵥⵔⴰ ⵏⵏⵉ ⵉⴱⵏⴰ ⵏⴻⵜⵜⴰ ⴰⵄⴰⵍⵟⴰⵔ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵉⵇⴻⵡⵡⴰⵔ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵛⵜ ⵏ ⵜⴰⵔⵢⴰ ⵙ ⵍⵇⴻⴷⴷ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K118_33","012_18_33","1KI","18","33","33","ⵉⵙⴻⵜⵜⴻⴼ ⴰⴽⴻⵛⵛⵓⴹ ⵓⵛⴰ ⵉⴱⴹⴰ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("K118_34","012_18_34","1KI","18","34","34","ⵉⵏⵏⴰ: “ⵄⴻⵎⵎⴰⵔⴻⵎ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴱⵓⵇⴰⵍⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵣⴻⴵⵄⴻⵎ ⵜⴻⵏ ⵜⵉⵡⴰ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵅ ⵓⴽⴻⵛⵛⵓⴹ!” ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ: “ⴳⴳⴻⵎ ⵜ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ!” ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⴳⴳⴻⵎ ⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ!” ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_35","012_18_35","1KI","18","35","35","ⵜⵜⴰⵣⵣⵍⴻⵏ ⵡⴰⵎⴰⵏ, ⵏⵏⴹⴻⵏ ⵉ ⵓⵄⴰⵍⵟⴰⵔ. ⵓ ⵏⴻⵜⵜⴰ ⵉⵄⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵜⴰⵔⵢⴰ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K118_36","012_18_36","1KI","18","36","36","ⵓⵎⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵏⴰⴱⵉ ⵉⵍⵉⵢⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵉⵙⵔⴰⵉⵍ, ⴻⵊⵊ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴰⵙⵙ-ⴰ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉ ⴵⵉⵖ ⵓ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K118_37","012_18_37","1KI","18","37","37","ⴰⵔⵔ ⴰⵢⵉ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ ⴰⵢⵉ-ⴷⴷ, ⵃⵉⵎⴰ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴻⴵⵉⴷ ⵓ ⴰⵇⴰ ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ-ⴷⴷ ⵓⵍ ⵏⵙⴻⵏ ⵖⴰⵔⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("K118_38","012_18_38","1KI","18","38","38","ⵓⵛⴰ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵏ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵛⵛⴰ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵢⴻⵥⵔⴰ ⴷ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⵓⵛⴰ ⵜⴻⵍⵙⴻⵃ ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K118_39","012_18_39","1KI","18","39","39","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵥⵔⴰ ⵉ-ⵜ. ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵏⴰⵏ: “ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("K118_40","012_18_40","1KI","18","40","40","ⵉⵍⵉⵢⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵟⵟⴼⴻⵎ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴱⴰⵄⵍ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵢⴰⵔⵡⴻⵍ.” ⵟⵟⴼⴻⵏ ⵜⴻⵏ, ⵓⵛⴰ ⵉⵍⵉⵢⴰ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⴻⵀⵡⴰⵏ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⵛⵓⵏ, ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K118_41","012_18_41","1KI","18","41","41","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ ⵉ ⴰⵅⴰⴱ: “ⴳⴻⵄⵄⴻⴷ, ⴻⵛⵛ, ⵜⴻⵙⵡⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵇⴰ ⵜⵜⴻⵙⵍⵉⵖ ⵍⵃⴻⵙⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵛⴰⵔⵛⴰⵔ ⵏ ⵡⴻⵏⵥⴰⵔ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("K118_42","012_18_42","1KI","18","42","42","ⴰⵅⴰⴱ ⵉⴳⴻⵄⵄⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛ ⴰⴷ ⵉⵙⵓ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵉⵍⵉⵢⴰ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⴽⴰⵔⵎⵉⵍ. ⵉⵇⵇⵓⵏⵊⴻⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⴳⴳⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵊⴰⵔ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K118_43","012_18_43","1KI","18","43","43","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⴳⴻⵄⵄⴻⴷ ⵓⵛⴰ ⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ!” ⵡⴰⵏⵉⵜⴰ ⵉⴳⴻⵄⵄⴻⴷ, ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵖ ⵡⴰⵍⵓ!” ⵉⵍⵉⵢⴰ ⵉⵏⵏⴰ: “ⴷⵡⴻⵍ-ⴷⴷ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ!”, ⵓⵛⴰ ⴰⵎⵎⵓ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("K118_44","012_18_44","1KI","18","44","44","ⵖⴰⵔ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⵙⴻⵢⵏⵓⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ, ⴰⵎ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⴰⵅⴰⴱ: ‘ⵃⴻⵣⵣⴻⵎ ⵉⵢⵙⴰⵏ, ⵀⵡⴰ-ⴷⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⵏⵥⴰⵔ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜᵉⵟⵟⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("K118_45","012_18_45","1KI","18","45","45","ⵊⴰⵔ ⵓ ⵊⴰⵔ ⵉⴱⴱⴰⵔⵛⴻⵏ ⵓⵊⴻⵏⵏⴰ ⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵓ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵛⴰ ⵉⴱⴷⴰ ⵡⴻⵏⵥⴰⵔ ⴰⴷ ⵉⵡⵡⴻⵜ ⴰⵟⵟⴰⵙ. ⵅⴻⵏⵏⵉ ⵉⵏⵢⴰ ⴰⵅⴰⴱ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ, ⵉⴼⴼⴻⵖ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K118_46","012_18_46","1KI","18","46","46","ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵍⵉⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⴱⵢⴻⵙ ⵜⴰⵄⵊⵉⵏⵏⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵣⵡⴰⵔ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵅⴰⴱ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K119_1","012_19_1","1KI","19","1","1","ⴰⵅⴰⴱ ⵉⵃⴰⵊⴰ ⵉ ⵉⵣⴰⴱⴰⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵉⵍⵉⵢⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵖⴰ ⵉⵍⵉⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("K119_2","012_19_2","1KI","19","2","2","ⵉⵣⴰⴱⴰⵍ ⵜⴻⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵉⵍⵉⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: “ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵜⴰ ⴷ ⵜⴰ ⵓⵍⴰ ⴷ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴳⴳⵉⵖ ⵜⵉⵡⴻⵛⵛⴰ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K119_3","012_19_3","1KI","19","3","3","ⵏⴻⵜⵜⴰ ⵉⵅⵣⴰⵔ, ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵔⵓⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵊⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⵃⵓⴷⵔⵉ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K119_4","012_19_4","1KI","19","4","4","ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵢⵓⵢⵓⵔ ⵜⵉⵛⵍⵉ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⵇⵇⵉⵎ ⵉⵣⵣⴻⵍ ⵙⴰⴷⵓ ⵜⴰⵣⴻⴳⴳⵯⴰⵔⵜ ⵏ ⵡⴰⵣⵣⵓ ⵓⵛⴰ ⵉⵜⵜⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴽⴼⴰ, ⴰ ⵙⵉⴷⵉ, ⴽⵙⵉ ⵍⴻⵅⵅⵓ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴵⵉⵖ ⵃⵙⴻⵏ ⵅ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K119_5","012_19_5","1KI","19","5","5","ⵅⴻⵏⵏⵉ ⵉⵣⵣⴻⵍ, ⵉⵟⵟⴻⵚ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⵏ ⵡⴰⵣⵣⵓ. ⵓ ⵅⵣⴰⵔ, ⵍⵎⴰⵍⴰⴽ ⵉⵃⴰⴷⴰ ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("K119_6","012_19_6","1KI","19","6","6","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⵣⵣⴰⵜ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⴼⴹⵉⵍⵜ ⵉ ⵜⵓⵖⴰ ⵙⵙⴻⵏⴳⵯⴻⵏ ⵜⵜ ⵙ ⵍⴻⴼⵃⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⵉⵇⵜ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵏ. ⵅⴻⵏⵏⵉ ⵉⵛⵛⴰ, ⵉⵙⵡⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵄⴰⵡⴻⴷ ⵉⵣⵣⴻⵍ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K119_7","012_19_7","1KI","19","7","7","ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵃⴰⴷⴰ ⵜ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⴻⵛⵛ, ⵏⵉⵖ ⴰⴱⵔⵉⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵣⵉⵔⴰⵔ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("K119_8","012_19_8","1KI","19","8","8","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵉⵛⵛⴰ, ⵉⵙⵡⴰ. ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵎⴰⵛⵛⴰ ⵢⵓⵢⵓⵔ ⵜⵉⵛⵜⵉ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵉⵢⴰⵍⵉ ⴰⵍ ⴰⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵀⵓⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("K119_9","012_19_9","1KI","19","9","9","ⴷⵉⵏⵏⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵢⴻⴼⵔⵉ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵙ ⴷⵉⵏⵏⵉ. ⵓ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ ⴰⵙ-ⴷⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷⴰ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⵉⵍⵉⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("K119_10","012_19_10","1KI","19","10","10","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵛⴹⴰⵔⴻⵖ ⴰⵍ ⵟⵟⴰⵔⴼ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ, ⵀⴻⴷⵎⴻⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⴽⴽⵙⴻⵏ ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ.”    ");
INSERT INTO rift_vpl VALUES ("K119_11","012_19_11","1KI","19","11","11","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴼⴼⴻⵖ, ⴱⴻⴷⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.” ⵓ ⵅⵣⴰⵔ, ⵉⵄⴷⵓ-ⴷⴷ ⵙⵉⴷⵉ. ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⵎⵖⴰⵔ ⵓ ⵜⴻⵊⵀⴻⴷ ⴰⵇⴰ ⵜⴻⵡⵜⴰ ⵉⴷⵓⵔⴰⵔ ⵓ ⵜⴻⵍⴱⴻⵣ ⵍⴻⵊⵔⵓⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ. ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷⴻⴳ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K119_12","012_19_12","1KI","19","12","12","ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⴰⵡⴰⵔⵏⵉ ⵜⵎⴻⵙⵙⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⴼⵙⵓⵙ, ⵜⴰⵔⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K119_13","012_19_13","1KI","19","13","13","ⵓⵎⵉ ⵉⵙⵍⴰ ⵉⵍⵉⵢⴰ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵍⴻⵃⵃⴻⴼ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⴻⵙ, ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵢⴻⴼⵔⵉ. ⵓ ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ, ⵜⴻⵏⵏⴰ: “ⵎⵉⵏ ⴷⴰ ⵜⴻⴳⴳⴻⴷ ⵉⵍⵉⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("K119_14","012_19_14","1KI","19","14","14","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵛⴹⴰⵔⴻⵖ ⴰⵍ ⵟⵟⴰⵔⴼ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ, ⵀⴻⴷⵎⴻⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵓ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴽⴽⵙⴻⵏ ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K119_15","012_19_15","1KI","19","15","15","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵓⵢⵓⵔ, ⵄⵇⴻⴱ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⴷⵉⵎⴰⵛⵇ ⵓ ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⴷⵉⵏ, ⴷⵀⴻⵏ ⵃⴰⵣⴰⵢⵉⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⴰⵔⴰⵎ! ");
INSERT INTO rift_vpl VALUES ("K119_16","012_19_16","1KI","19","16","16","ⵓⵍⴰ ⴷ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵎⵛⵉ, ⴰⴷ ⵜ ⵜⴷⴻⵀⵏⴻⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵍⵉⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵜ ⵣⵉ ⴰⴱⴰⵍ-ⵎⴰⵃⵓⵍⴰ, ⴷⵀⴻⵏ ⵉ-ⵜ ⴷ ⴰⵏⴰⴱⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K119_17","012_19_17","1KI","19","17","17","ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⴰⵀⵓ ⴰⴷ ⵉⵏⴻⵖ ⵡⵉ ⵖⴰ ⵉⵏⴻⵊⵎⴻⵏ ⵉ ⵙⵙⵉⴼ ⵏ ⵃⴰⵣⴰⵢⵉⵍ, ⵓ ⵉⵍⵉⵛⴰⵄ ⴰⴷ ⵉⵏⴻⵖ ⵡⵉ ⵖⴰ ⵉⵏⴻⵊⵎⴻⵏ ⵉ ⵙⵙⵉⴼ ⵏ ⵢⴰⵀⵓ. ");
INSERT INTO rift_vpl VALUES ("K119_18","012_19_18","1KI","19","18","18","ⵅⴻⵏⵏⵉ ⵊⵊⵉⵖ ⵏⴻⵛⵛ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵍⴻⵄⵎⵓⵔ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵇⵇⵓⵏⵊⴻⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⴱⴰⵄⵍ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵜ ⵉⵙⵙⵓⴷⵎⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K119_19","012_19_19","1KI","19","19","19","ⵉⴼⴼⴻⵖ ⵉⵍⵉⵢⴰ ⵙⵙⴻⵏⵏⵉ, ⵢⵓⴼⴰ ⵉⵍⵉⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵜ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵛⴰⵔⵔⴻⵣ ⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵣⴰⵢⵍⵓⵜⴻⵏ ⵏ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵛⴰⵔⵣ ⵅ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ. ⵉⵍⵉⵢⴰ ⵉⵄⴷⵓ ⵖⴰⵔⴻⵙ, ⵉⵏⴹⴰⵔ ⵅⴰⵙ ⴰⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K119_20","012_19_20","1KI","19","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵎⴻⵃ ⴷⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵉⵄⵍⴻⴼ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵍⵉⵢⴰ, ⵉⵏⵏⴰ: “ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵙⵙⵓⴷⵎⴻⵖ ⴱⴰⴱⴰ ⴷ ⵢⴻⵎⵎⴰ ⵉ ⵓⵇⴻⴱⴱⴻⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵖ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵢⵓⵔ, ⴷⵡⴻⵍ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⴷⴰⵢⴻⴽ ⴳⴳⵉⵖ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("K119_21","012_19_21","1KI","19","21","21","ⵉⵄⵇⴻⴱ ⵏⴻⵜⵜⴰ ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵖⴰⵔⵚ ⴰⵙⴻⵏ. ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵣⴰⵢⵍⵓ ⵉⵙⵙⵏⴻⵏⵏⴰ ⴰⵢⵙⵓⵎ ⵏⵙⴻⵏ, ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵛⵛ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⴽⴽⴰⵔ, ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉⵍⵉⵢⴰ, ⵉⵙⴻⵅⵅⴰⵔ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K120_1","012_20_1","1KI","20","1","1","ⴱⵉⵏⵀⴰⴷⴰⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵙ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⴳⴻⵄⵄⴻⴷ, ⵉⵏⵏⴻⴹ ⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K120_2","012_20_2","1KI","20","2","2","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K120_3","012_20_3","1KI","20","3","3","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴱⵉⵏ-ⵀⴰⴷⴰⴷ: ‘ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵡⵓⵔⴻⵖ ⵏⵏⴻⵛ ⵉⵏⵓ. ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("K120_4","012_20_4","1KI","20","4","4","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⵉⴷ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵛⵛ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("K120_5","012_20_5","1KI","20","5","5","ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵏⵏⴰⵏ: “ⴰⵎⵎⵓ ⵉⵙⵙⵉⵡⴻⵍ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⵊⵊⵉⵖ ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ!, ");
INSERT INTO rift_vpl VALUES ("K120_6","012_20_6","1KI","20","6","6","ⵎⴰⵛⴰ ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⵖⴰⵔⴻⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ. ⴰⴷ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⴽ ⵉⵄⵉⵣⵣⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("K120_7","012_20_7","1KI","20","7","7","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴰ: “ⵙⵏⴻⵎ ⵅⴻⵏⵏⵉ ⵓ ⵅⵣⴰⵔⴻⵎ ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵡⴰ ⵍⵖⴰⵔ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⵉ ⵇⴱⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⵙⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉⵏⵓ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵏⵓ ⴷ ⵡⵓⵔⴻⵖ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵙ ⵜ ⵇⴹⵉⵄⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("K120_8","012_20_8","1KI","20","8","8","ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵜⴻⵙⵍⵉ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛ ⵜⵜⴻⵙⵔⵉⵃ!” ");
INSERT INTO rift_vpl VALUES ("K120_9","012_20_9","1KI","20","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⴱⵉⵏⵀⴰⴷⴰⴷ: “ⵉⵏⵉⵎ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ: ‘ⵎⴰⵔⵔⴰ ⵓⵎⵉ ⵉ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵜ ⴳⴳⴻⵖ, ⵎⴰⵛⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⴳⴳⴻⵖ.’” ⴼⴼⵖⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵡⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K120_10","012_20_10","1KI","20","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴱⵉⵏⵀⴰⴷⴰⴷ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⴰⵎⵎⵓ ⵓ ⴰⴷ ⴰⵔⵏⵉⵏ ⵄⴰⴷ ⴽⵜⴰⵔ, ⵎⴰⵍⴰ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵜⵇⴻⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵛⵓⵔ ⵓⵔⵓ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵢⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("K120_11","012_20_11","1KI","20","11","11","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵉⵏⵉⵎ ⴰⵙ: ‘ⵡⴻⵏⵏⵉ ⵉⴱⴻⵢⵙⴻⵏ ⴰⴱⵢⴰⵙ, ⵡⴰⵔ ⵉⵜⵜⵛⴻⵏⵏⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⴰⵔⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("K120_12","012_20_12","1KI","20","12","12","ⵓⵎⵉ ⵉⵙⵍⴰ ⵉ ⵡⴰⵡⴰⵍ-ⴰ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⴻⵙⵙ ⴰⴽ-ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ, ⴰⵇⴰ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵙⴱⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ!” ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K120_13","012_20_13","1KI","20","13","13","ⵓ ⵅⵣⴰⵔ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ: ‘ⵎⴰ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ ⵍⵖⴰⵛⵉ-ⵢⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ? ⵅⵣⴰⵔ ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵡⵛⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("K120_14","012_20_14","1KI","20","14","14","ⵓⵛⴰ ⴰⵅⴰⴱ ⵉⵏⵏⴰ: “ⵣⵉ ⵎⴰⵏ ⵡⴻⵏ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ.’” ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⴱⴷⴰⵏ ⴰⵎⴻⵏⵖⵉ?” ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴷ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("K120_15","012_20_15","1KI","20","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⴻⴷⴷ ⵏⴻⵜⵜⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ. ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ. ⵉⵙⴻⴷⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K120_16","012_20_16","1KI","20","16","16","ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴰⵣⴰⵍ. ⴱⵉⵏⵀⴰⴷⴰⴷ ⵜⵓⵖⴰ ⵉⵙⵛⴰⵔ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("K120_17","012_20_17","1KI","20","17","17","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ ⴼⴼⵖⴻⵏ-ⴷⴷ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⴱⵉⵏⵀⴰⴷⴰⴷ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵛⴰ ⵏ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("K120_18","012_20_18","1KI","20","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉ ⵍⴻⵀⵏⴰ, ⵟⵟⴼⴻⵎ ⵜⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵓ ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵟⵟⴼⴻⵎ ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⴷⴷⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("K120_19","012_20_19","1KI","20","19","19","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K120_20","012_20_20","1KI","20","20","20","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵖⵍⴻⴱ ⵅ ⵡⴻⵖⵔⵉⵎ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⴰⵔⴻⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵓ ⵉⵙⵔⴰⵉⵍ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ, ⵎⴰⵛⴰ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵏⵊⴻⵎ ⵅ ⵓⵢⵉⵙ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵉⵎⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K120_21","012_20_21","1KI","20","21","21","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⵢⴻⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K120_22","012_20_22","1KI","20","22","22","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵏⴰⴱⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵢⵓⵔ, ⵎⵃⴻⴹ ⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⵙⵙⴻⵏ ⵓ ⵅⵣⴰⵔ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ, ⵎⴰⵖⴰⵔ ⵖⴰⵔ ⵓⴱⴻⴷⴷⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵊⴷⵉⴷ ⴰⴷ ⵅⴰⴽ ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K120_23","012_20_23","1KI","20","23","23","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵅ ⵓⵢⴰ ⵜⵓⵖⴰ ⵊⴻⵀⴷⴻⵏ ⵅⴰⵏⴻⵖ. ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵍⵡⴰⵟⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⵏⴻⵊⵀⴻⴷ ⵏⵉⵛⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("K120_24","012_20_24","1KI","20","24","24","ⴻⴳⴳ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵡⴰⵡⴰⵍ-ⴰ: ⴽⴽⴻⵙ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓ ⴳⴳⴻⵎ ⵍⵡⵓⵍⴰⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K120_25","012_20_25","1KI","20","25","25","ⵙⵎⵓⵏ ⴰⵎⵎⵓ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵜⵡⴻⴷⴷⴰⵔⴻⴷ, ⵙ ⵢⴻⵢⵙⴰⵏ ⴰⵎ ⵢⴻⵢⵙⴰⵏ ⵏⵏⵉ ⵓ ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴰⵎ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⵉ, ⵓⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⵏⴻⵎⵎⵏⴻⵖ ⴷⵉ ⵍⵡⴰⵟⴰ. ⵓⵛⵜ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵏⴻⵊⵀⵉⴷ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵖⴰⵔⵙⴻⵏ ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("K120_26","012_20_26","1KI","20","26","26","ⵖⴰⵔ ⵓⴱⴻⴷⴷⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵊⴷⵉⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴱⵉⵏⵀⴰⴷⴰⴷ ⵉⵙⴻⴷⴷ ⴰⵔⴰⵎ. ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴰⴼⵉⵇ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K120_27","012_20_27","1KI","20","27","27","ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⵙⴻⴷⴷⴻⵏ. ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵍⴻⵄⵡⴻⵍⵜ ⵓ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ. ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵏⵙⴻⵏ ⴰⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ. ⵉⵏⵏⵉ ⵏ ⴰⵔⴰⵎ ⵎⴰⵛⴰ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K120_28","012_20_28","1KI","20","28","28","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵙⵉⴷⵉ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵏ ⴰⵔⴰⵎ ⵉⵏⵏⴰⵏ: ⵙⵉⴷⵉ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵙⴻⴵⵢⵉⵏ!’, ⵅ ⵓⵢⴰ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵍⵖⴰⵛⵉ-ⵢⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵄⴻⵇⵍⴻⵎ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("K120_29","012_20_29","1KI","20","29","29","ⵜⵓⵖⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵡⴰⵢⴰⵡⵢⴰ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴽⴽⴰⵔ ⵓⵎⴻⵏⵖⵉ. ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏⵖⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵣⵉ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K120_30","012_20_30","1KI","20","30","30","ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⴼⵉⵇ ⵓⵛⴰ ⵍⵃⵉⴹ ⵉⵡⴹⴰ ⵅ ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ. ⵓⵍⴰ ⴱⵉⵏⵀⴰⴷⴰⴷ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵢⵓⵢⵓⵔ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K120_31","012_20_31","1KI","20","31","31","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ, ⴰⵇⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴱⵢⴻⵙ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵢⴰⵙ ⵓ ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵖⴰⵔ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵛⴻⴽ ⵢⴻⵊⵊ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("K120_32","012_20_32","1KI","20","32","32","ⵏⵉⵜⵏⵉ ⴱⴻⵢⵙⴻⵏ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⴳⴳⵉⵏ ⵉⵙⴻⵖⵡⴰⵏ ⵖⴰⵔ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⴰⵏ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴱⵉⵏⵀⴰⴷⴰⴷ ⵉⵏⵏⴰ: ‘ⴻⵊⵊ ⴰⴷ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ!’” ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵎⴰ ⵏⴻⵜⵜⴰ ⵉⴷⴷⴰⵔ ⵄⴰⴷ? ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰ!” ");
INSERT INTO rift_vpl VALUES ("K120_33","012_20_33","1KI","20","33","33","ⵉⵔⵢⴰⵣⴻⵏ ⴼⴻⵀⵎⴻⵏ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵜⴻⵚⴱⴻⵃ, ⵓⵛⴰ ⴰⵔⵣⵓⵏ ⴷⴻⵖⵢⴰ ⵅ ⵛⴰ, ⵎⴰ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵏⵉⵛⴰⵏ, ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵓⵎⴰⵛ ⴱⵉⵏⵀⴰⴷⴰⴷ ...” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵙⴻⵎ-ⴷⴷ, ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ.” ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⴱⵉⵏⵀⴰⴷⴰⴷ ⵖⴰⵔⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵢⴰ ⵜ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K120_34","012_20_34","1KI","20","34","34","ⵉⵏⵏⴰ ⴰⵙ ⴱⵉⵏⵀⴰⴷⴰⴷ: “ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴱⴰⴱⴰ ⵣⵉ ⴱⴰⴱⴰⵛ, ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⵔⴻⵖ. ⵉⵡⴰ, ⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵛⵓⵔⴰⵜ ⵉ ⵜⵙⴻⴱⴱⴰⴱⵜ ⴷⵉ ⴷⵉⵎⴰⵛⵇ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴱⴰⴱⴰ ⴷⵛⵓⵔⴰⵜ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ.” ⵓⵛⴰ ⴰⵅⴰⴱ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴰⵔⵅⵓⵖ ⵅ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ.” ⵓ ⵏⴻⵜⵜⴰ ⵉⵇⵇⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵓⵛⴰ ⵢⴰⵔⵅⵓ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K120_35","012_20_35","1KI","20","35","35","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵏⴰ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ: “ⵡⵡⴻⵜ ⴰⵢⵉ!” ⴰⵔⵢⴰⵣ ⵢⵓⴳⵉ ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵉⵡⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K120_36","012_20_36","1KI","20","36","36","ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵎⵖⵉⵔ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⴼⴼⵖⴻⴷ, ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ.” ⵓⵎⵉ ⵅⴰⵙ ⵢⵓⵢⵓⵔ, ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("K120_37","012_20_37","1KI","20","37","37","ⵅⴻⵏⵏⵉ ⵢⵓⴼⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵡⵡⴻⵜ ⴰⵢⵉ!” ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵡⵜⴰ ⵉ-ⵜ ⴰⵎⵎⵓ, ⴰⵍⴰⵎⵉ ⵜ ⵉⵢⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("K120_38","012_20_38","1KI","20","38","38","ⵢⵓⵢⵓⵔ ⵓⵏⴰⴱⵉ, ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵉ ⵓⵎⴻⵍⵇⵉ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ. ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵛⴼⴻⵏ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K120_39","012_20_39","1KI","20","39","39","ⵓⵎⵉ ⴷⴷ-ⵉⵄⴷⵓ ⵓⵊⴻⴵⵉⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵍⴰⵖⴰ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵓⵎⴻⵏⵖⵉ. ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵡⴻⵔⵢⴰⵣ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⵢⵉⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵏⵏⴰ: ‘ⵃⴹⴰ ⴰⵔⵢⴰⵣ-ⴰ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵡⴻⴷⴷⴰⵔ ⵖⴰⵔ ⵓⵙⴻⴷⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⴷ ⵜⵅⴻⴵⵚⴻⴷ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("K120_40","012_20_40","1KI","20","40","40","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵛⴻⵖⴻⵍ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ.” ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵡⴰ ⴷ ⵍⵃⵓⴽⵎ ⵏⵏⴻⵛ, ⵜⴻⵡⵜⵉⴷ ⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("K120_41","012_20_41","1KI","20","41","41","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⴷⴻⵖⵢⴰ ⵍⴻⵛⴼⴻⵏ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵄⵇⴻⵍ ⵉ-ⵜ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K120_42","012_20_42","1KI","20","42","42","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵃⴰⵔⵔⵎⴻⵖ ⵏⴻⵛⵛ ⵉ ⵓⵜⴻⵃⵃⵉ ⴰⴷ ⵉⵏⵊⴻⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵓ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K120_43","012_20_43","1KI","20","43","43","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵢⵓⵔ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉⵅⵙⴰⵔⴻⵏ ⴷ ⵉⵅⴻⵢⵢⵉⵇⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K121_1","012_21_1","1KI","21","1","1","ⴰⵡⴰⵔⵏⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵇⴰ ⴷⵉⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵣⵣⴰⵜ ⵉ ⵍⴻⵇⵚⴰⵔ ⵏ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K121_2","012_21_2","1KI","21","2","2","ⴰⵅⴰⴱ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵏⴰⴱⵓⵜ, ⵉⵏⵏⴰ: “ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⴷ ⵜⴰⵃⵡⵉⵛ ⵜⴰⵣⵉⵣⴰⵡⵜ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵜⵓⴷⴻⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⴹⵉⵍ ⵉⵚⴱⴻⵃ ⵅⴰⵙ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵅⴻⴵⵚⴻⵖ ⵜⵜⵎⴰⵏ ⵏⵏⴻⵙ ⵙ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K121_3","012_21_3","1KI","21","3","3","ⵎⴰⵛⴰ ⵏⴰⴱⵓⵜ ⵉⵏⵏⴰ ⵉ ⴰⵅⴰⴱ: “ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵃⴹⴰ, ⴰⵇⴰ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("K121_4","012_21_4","1KI","21","4","4","ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⴰⵅⴰⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉⵅⵙⴰⵔⴻⵏ ⴷ ⵉⵅⴻⵢⵢⵉⵇⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ, ⵓⵎⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵛ ⵜⵜⵉⵛⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ.” ⵓ ⵏⴻⵜⵜⴰ ⵉⵣⵣⴻⵍ ⵅ ⵇⴰⵎⴰ ⵏⵏⴻⵙ, ⵢⴰⵔⵔⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵃⵉⴹ, ⵡⴰⵔ ⵉⵛⵛⵉ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("K121_5","012_21_5","1KI","21","5","5","ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵣⴰⴱⴰⵍ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ: “ⵎⵉⵏ ⴷⵉⵏ ⴰⵍⴰⵎⵉ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵉⵅⵙⴰⵔ ⴰⵎⵎⵓ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵜⵜⴻⴷ ⴰⵖⵔⵓⵎ?” ");
INSERT INTO rift_vpl VALUES ("K121_6","012_21_6","1KI","21","6","6","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ: “ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ, ⵏⵏⵉⵖ ⴰⵙ: ‘ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ ⵉ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵏⵉⵖ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ!’, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵛ ⵜⵜⵉⵛⴻⵖ ⴰⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ!’” ");
INSERT INTO rift_vpl VALUES ("K121_7","012_21_7","1KI","21","7","7","ⵜⴻⵏⵏⴰ ⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵣⴰⴱⴰⵍ: “ⵎⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⵜⵜⴻⴳⴳⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ? ⴽⴽⴰⵔ, ⴻⵛⵛ ⴰⵖⵔⵓⵎ ⵓ ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ! ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("K121_8","012_21_8","1KI","21","8","8","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⴰ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⴰⵅⴰⴱ ⵓⵛⴰ ⵜⵛⴻⵎⵎⴻⵄ ⵉ-ⵜⴻⵏⵜ ⵙ ⵜⵅⴰⴹⴻⵏⵜ ⵏⵏⴻⵙ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⵓ ⵜⴻⵙⵙⴻⴽⴽ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏⵏⵉ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵓ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵏⴰⴱⵓⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K121_9","012_21_9","1KI","21","9","9","ⴷⵉ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵜⵓⵔⴰ, ⵜⴻⵏⵏⴰ: “ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ ⵓ ⵙⵖⵉⵎⴻⵎ ⵏⴰⴱⵓⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ");
INSERT INTO rift_vpl VALUES ("K121_10","012_21_10","1KI","21","10","10","ⵓⵛⴰ ⵙⴱⴻⴷⴷⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵛⴻⵀⴷⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵛⴻⴽ ⵜⵛⴻⵇⵇⴼⴻⴷ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⴻⴳ ⵓⵊⴻⴵⵉⴷ!’ ⵙⵓⴼⵖⴻⵎ ⵜ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓ ⴰⵔⴻⵊⵎⴻⵎ ⵜ ⴰⵍ ⴷ ⵉⵎⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("K121_11","012_21_11","1KI","21","11","11","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⴳⴳⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵜⵓⵎⵓⵔ ⵉⵣⴰⴱⴰⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵔⵉⵏ ⴷⵉ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("K121_12","012_21_12","1KI","21","12","12","ⵏⵉⵜⵏⵉ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ ⵓ ⵙⵙⵖⵉⵎⴻⵏ ⵏⴰⴱⵓⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("K121_13","012_21_13","1KI","21","13","13","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ. ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵛⴻⵀⴷⴻⵏ ⵅⴰⵙ, ⵅ ⵏⴰⴱⵓⵜ, ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⵏⴰⴱⵓⵜ ⵉⵛⴻⵇⵇⴻⴼ ⴷⵉ ⵙⵉⴷⵉ ⵓ ⴷⴻⴳ ⵓⵊⴻⴵⵉⴷ.” ⵅⴻⵏⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴰⵔⴻⵊⵎⴻⵏ ⵜ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K121_14","012_21_14","1KI","21","14","14","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵊⵊⵉⵏ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⵣⴰⴱⴰⵍ: “ⵏⴰⴱⵓⵜ ⵉⵜⵜⵡⴰⵔⵊⴻⵎ ⵓ ⵉⵎⵎⵓⵜ.” ");
INSERT INTO rift_vpl VALUES ("K121_15","012_21_15","1KI","21","15","15","ⵓⵎⵉ ⵜⴻⵙⵍⴰ ⵉⵣⴰⴱⴰⵍ ⴰⵇⴰ ⵏⴰⴱⵓⵜ ⵉⵜⵜⵡⴰⵔⵊⴻⵎ, ⵉⵎⵎⵓⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵣⴰⴱⴰⵍ ⵜⴻⵏⵏⴰ ⵉ ⴰⵅⴰⴱ: “ⴽⴽⴰⵔ, ⴽⵙⵉ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ, ⴷ ⵍⵡⴰⵔⵜ, ⴰⵃⵡⵉⵛ ⵉ ⵢⵓⴳⵉⵏ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵜ ⵉⵡⵛ ⵙ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⵇⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵏⴰⴱⵓⵜ ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵛⴰ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵉⵎⵎⵓⵜ.” ");
INSERT INTO rift_vpl VALUES ("K121_16","012_21_16","1KI","21","16","16","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵅⴰⴱ, ⴱⴻⵍⵍⵉ ⵏⴰⴱⵓⵜ ⵉⵎⵎⵓⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵅⴰⴱ ⵉⴽⴽⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵀⵡⴰ ⵖⴰⵔ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴽⵙⵉ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K121_17","012_21_17","1KI","21","17","17","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵍⵉⵢⴰ, ⴰⵜⵉⵛⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K121_18","012_21_18","1KI","21","18","18","“ⴽⴽⴰⵔ, ⵀⵡⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵍⵇⵉⴷ ⴰⴽ-ⴷ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵏⴰⴱⵓⵜ ⵎⴰⵏⵉ ⵖⴰⵔ ⴷⴷ-ⵉⵀⵡⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴽⵙⵉ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K121_19","012_21_19","1KI","21","19","19","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵎⴰ ⵜⴻⵏⵖⵉⴷ ⵓ ⵅⴻⵏⵏⵉ ⵜⴻⴽⴽⵙⴻⴷ ⵓⵍⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ?’ ⵄⴰⵡⴻⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵍⴻⵙⵃⴻⵏ ⵉⵟⴰⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵏⴰⴱⵓⵜ, ⴰⴷ ⵍⴻⵙⵃⴻⵏ ⵉⵟⴰⵏ ⵓⵍⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵛ, ⵡⴰⵀ, ⴷ ⵉⵏⵏⵉ ⵏⵏⴻⵛ!’” ");
INSERT INTO rift_vpl VALUES ("K121_20","012_21_20","1KI","21","20","20","ⵉⵏⵏⴰ ⴰⵅⴰⴱ ⵉ ⵉⵍⵉⵢⴰ: “ⵎⴰ ⵜⵓⴼⵉⴷ ⴰⵢⵉ, ⵛⴻⴽ, ⵍⴻⵄⴷⵓ ⵉⵏⵓ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⵛⴻⴽ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K121_21","012_21_21","1KI","21","21","21","ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⵙⵙⵉⵡⴹⴻⵖ ⵍⵖⴰⵔ ⵓ ⴰⴷ ⵎⵃⵉⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵅ ⵍⵃⵉⴹ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵊⵊⵉⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K121_22","012_21_22","1KI","21","22","22","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵓ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⵄⵛⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵢⴰ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵙⵄⴰⵔ ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵄⴰⵔⴻⴷ, ⵓ ⵓⵎⵉ ⵜⴰⵔⵔⵉⴷ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("K121_23","012_21_23","1KI","21","23","23","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵓⵍⴰ ⵅ ⵉⵣⴰⴱⴰⵍ, ⵉⵏⵏⴰ: “ⵉⵟⴰⵏ ⴰⴷ ⵛⵛⴻⵏ ⵉⵣⴰⴱⴰⵍ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⵣⵣⴰⵜ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K121_24","012_21_24","1KI","21","24","24","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⴰⵅⴰⴱ ⵉ ⵖⴰ ⵉⵎⵎⵓⵜⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵉⵟⴰⵏ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵎⵎⵓⵜⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("K121_25","012_21_25","1KI","21","25","25","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⵄⴻⵎⵎⴰⵔⵚ ⴰⵎ ⴰⵅⴰⴱ ⵉ ⵉⵣⵣⴻⵏⵣⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵜ ⵜⵄⴰⵔⵔⴻⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵣⴰⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("K121_26","012_21_26","1KI","21","26","26","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⵓⵎⵉ ⵢⴰⵔⴻⴷⴷⴻⴼ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵓ ⵓⵎⵉ ⵉⴳⴳⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⵉⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵍⵡⴰⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K121_27","012_21_27","1KI","21","27","27","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵅⴰⴱ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⴱⴷⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵢⴰⵔⴹ ⵉⵛⵜ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵉⵥⵓⵎⵎ. ⵄⴰⵡⴻⴷ ⵉⵟⵟⴻⵚ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵓ ⵢⵓⵢⵓⵔ ⵙ ⴰⵔⴻⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K121_28","012_21_28","1KI","21","28","28","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵍⵉⵢⴰ, ⴰⵜⵉⵛⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K121_29","012_21_29","1KI","21","29","29","“ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴻⵀⵡⴰ ⴰⵅⴰⴱ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ? ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⵀⵡⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⴽⴽⵯⵉⴹⴻⵖ ⵍⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵎⵎⵉⵙ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⵖⴰⵔ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K122_1","012_22_1","1KI","22","1","1","ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵃⴹⴰⵏ ⵏⵉⵜⵏⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵎⴻⵏⵖⵉ ⵊⴰⵔ ⴰⵔⴰⵎ ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K122_2","012_22_2","1KI","22","2","2","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⵀⵡⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("K122_3","012_22_3","1KI","22","3","3","ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵏⵏⴻⵖ? ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵃⴹⴰ ⵍⵀⵓⴷⵏⴻⵜ, ⵡⴰⵔ ⵜⴻⵏ ⵏᵉⵜⵜⴻⴽⴽⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ?” ");
INSERT INTO rift_vpl VALUES ("K122_4","012_22_4","1KI","22","4","4","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ “ⵣⴻⵄⵎⴰ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ?” ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⵎ ⵛⴻⴽ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵉⵢⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K122_5","012_22_5","1KI","22","5","5","ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵄⴰⵡⴻⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵙⴻⵇⵙⴰ ⵄⴰⴼⴰⴽ ⴰⵙⵙ-ⴰ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("K122_6","012_22_6","1KI","22","6","6","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵄⵍⴰⵃⴰⵍ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵏⵉⵖ ⴰⴷ ⵜ ⵊⵊⴻⵖ?” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴳⴻⵄⵄⴻⴷ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("K122_7","012_22_7","1KI","22","7","7","ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴷⴰ ⵛⴰ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵇⵙⴰ ⵏⴻⵛⵛⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("K122_8","012_22_8","1KI","22","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⴰⵇⴰ ⵄⴰⴷ ⴷⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵣⵣⴰⵢⴻⵙ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵛⴰⵔⵀⴻⵖ ⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ⴰⵇⴰ-ⵜ ⴷ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⵉⵎⵍⴰ.” ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("K122_9","012_22_9","1KI","22","9","9","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ, ⵉⵏⵏⴰ: “ⴷⴻⵖⵢⴰ, ⴰⵡⵉ-ⴷⴷ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⵉⵎⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("K122_10","012_22_10","1KI","22","10","10","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵢⴰⵔⴹⴻⵏ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵅ ⵡⴰⵣⵣⴰⵢ ⵏ ⵓⵏⴻⴷⵔⴰⵔ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K122_11","012_22_11","1KI","22","11","11","ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵏⵄⴰⵏⴰ, ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵙ ⵢⵉⵏⴰ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⵓⵇⵇⴱⴻⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵍ ⵜⴻⵏ ⵖⴰ ⵜⴻⵇⴹⵉⴹ.’” ");
INSERT INTO rift_vpl VALUES ("K122_12","012_22_12","1KI","22","12","12","ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵏⴻⴱⴱⴰⵏ ⴽⵉⴼⴽⵉⴼ, ⵏⵏⴰⵏ: “ⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴼⴻⵍⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("K122_13","012_22_13","1KI","22","13","13","ⴰⵔⴻⵇⵇⴰⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ:“ⵅⵣⴰⵔ ⵅⴻⵏⵏⵉ, ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⵅⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵙ ⵍⵅⵉⵔ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⴰⴷ ⵉⵍⵉⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴰⵎ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ, ⵙⵉⵡⴻⵍ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K122_14","012_22_14","1KI","22","14","14","ⵎⴰⵛⴰ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵏⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵜ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("K122_15","012_22_15","1KI","22","15","15","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵎⴰ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵏⵉⵖ ⴰⴷ ⵜ ⵏⴻⵊⵊ?” ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⴳⴻⵄⵄⴻⴷ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴼⴻⵍⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("K122_16","012_22_16","1KI","22","16","16","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⵊⴰⴵⴻⵖ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ ⵎⵖⵉⵔ ⵜⵉⴷⴻⵜⵜ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("K122_17","012_22_17","1KI","22","17","17","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⴰⵎ ⵡⵓⴵⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵓⵎⴻⴽⵙⴰⵡ. ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵉⵏⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵉⵙⵉⴷⵉⵜⴻⵏ, ⴻⵊⵊ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵀⵏⴰ.’” ");
INSERT INTO rift_vpl VALUES ("K122_18","012_22_18","1KI","22","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⵏⴻⵜⵜⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵅⴰⴼⵉ ⵡⴰⵍⵓ ⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⵖⵉⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ?’” ");
INSERT INTO rift_vpl VALUES ("K122_19","012_22_19","1KI","22","19","19","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ: “ⵙ ⵓⵢⴰ ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵙⵉⴷⵉ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔⴻⵙ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K122_20","012_22_20","1KI","22","20","20","ⵙⵉⴷⵉ ⵉⵏⵏⴰ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵖⵡⴰⵏ ⴰⵅⴰⴱ ⴰⵍ ⵖⴰ ⵉⴳⴻⵄⵄⴻⴷ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ?’ ⵡⴰ ⵉⵏⵏⴰ ⴰⵎⵎⵓ ⵓ ⵡⵉⵏ ⵉⵏⵏⴰ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("K122_21","012_22_21","1KI","22","21","21","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ, ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵖⵡⵉⵖ.’ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵜ: ‘ⵙ ⵎⵉⵏⵣⵉ?’ ");
INSERT INTO rift_vpl VALUES ("K122_22","012_22_22","1KI","22","22","22","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴼⴼⵖⴻⵖ ⵓ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ.’ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⴰⴷ ⵜⴼⴻⵍⵃⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵖⵡⵉⴷ. ⴼⴼⴻⵖ, ⴻⴳⴳ ⴰⵎⴻⵏⵏⵉ!’ ");
INSERT INTO rift_vpl VALUES ("K122_23","012_22_23","1KI","22","23","23","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⴱⴰⵔⵔⴻⵃ ⵅⴰⴽ ⵙ ⵍⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("K122_24","012_22_24","1KI","22","24","24","ⵅⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵏⵄⴰⵏⴰ, ⵖⴰⵔ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵉⵡⵜⵉ ⵜ ⵖⴰⵔ ⵓⵖⴻⵙⵎⵉⵔ, ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⵉ ⵉⵄⴷⵓ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ?” ");
INSERT INTO rift_vpl VALUES ("K122_25","012_22_25","1KI","22","25","25","ⵉⵏⵏⴰ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ: “ⵅⵣⴰⵔ, ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵜⴻⵎⵀⴰⴼⴻⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K122_26","012_22_26","1KI","22","26","26","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⴰ: “ⵟⵟⴼⴻⵎ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵏⴻⴷⵀⴻⵎ ⵜ ⵖⴰⵔ ⴰⵎⵓⵏ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵖⴰⵔ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K122_27","012_22_27","1KI","22","27","27","ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ⵏⴹⴰⵔⴻⵎ ⵡⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵓ ⵙⴻⵛⵛⴻⵎ ⵜ ⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵍ ⴷⴷ ⵖⴰ ⵄⴻⵇⴱⴻⵖ ⴷⵉ ⵍⴻⵀⵏⴰ.’” ");
INSERT INTO rift_vpl VALUES ("K122_28","012_22_28","1KI","22","28","28","ⵎⵉⵅⴰ-ⵢⴰⵀⵓ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵄⴻⵇⴱⴻⴷ-ⴷⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵍⴻⵀⵏⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵉⵙⵙⵉⵡⴻⵍ!” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵙⵍⴻⵎ, ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ!” ");
INSERT INTO rift_vpl VALUES ("K122_29","012_22_29","1KI","22","29","29","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽ-ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K122_30","012_22_30","1KI","22","30","30","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵏⴻⵛⵛ ⴰⴷ ⴱⴻⴷⴷⵍⴻⵖ ⴰⵔⵔⵓⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ⵛⴻⴽ ⵎⴰⵛⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵢⴰⵔⴹⴻⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ!” ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⴳⴳⴰ ⴰⵔⵔⵓⴹ ⵡⴰⵔ ⵉⴵⵉ ⵏⵏⴻⵙ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("K122_31","012_22_31","1KI","22","31","31","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵉ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ, ⵉⵏⵏⴰ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⵉⵎ ⴰⴽ-ⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏⵉⵖ ⴰⴽ-ⴷ ⵓⵎⴻⵥⵢⴰⵏ, ⵎⵖⵉⵔ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("K122_32","012_22_32","1KI","22","32","32","ⵓⵎⵉ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵥⵔⵉⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷ ⵡⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ!” ⵏⵉⵜⵏⵉ ⵎⴻⵢⵢⵍⴻⵏ ⵅⴰⵙ ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵎⵎⴻⵏⵖⴻⵏ, ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵙⵖⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("K122_33","012_22_33","1KI","22","33","33","ⵓⵎⵉ ⵥⵔⵉⵏ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ, ⵡⴰⵔ ⵜ ⴰⵔⴻⴷⴷⴼⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K122_34","012_22_34","1KI","22","34","34","ⵅⴻⵏⵏⵉ ⵉⵄⴻⵢⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵍⵇⴻⵡⵙ ⵙ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵓⵛⴰ ⵉⵍⵇⴻⴼ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⴰⵔ ⵡⴰⵡⴰⴹⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴰⴽⴰⵔⵔⵓ: “ⵇⵍⴻⴱ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵖⴰⵔ ⵉⵢⵣⵎⴻⵖ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("K122_35","012_22_35","1KI","22","35","35","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⵎⴻⵏⵖⵉ ⵢⴻⵡⵄⴰⵔ ⴰⵟⵟⴰⵙ. ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵉⵎⵎⵓⵜ. ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵢⴻⵣⵣⵉⵎ ⵜⵓⵖⴰ ⵓⵣⵣⵍⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵓⴽⴰⵔⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K122_36","012_22_36","1KI","22","36","36","ⵖⴰⵔ ⵓⵖⴻⴵⴰⵢ ⵏ ⵜⴼⵓⵛⵜ ⵊⵊⵉⵏ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ, ⵏⵏⴰⵏ: “ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("K122_37","012_22_37","1KI","22","37","37","ⵉⵎⵎⵓⵜ ⵓⵊⴻⴵⵉⴷ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ⵏⵉⵜⵏⵉ ⵏⴻⴹⵍⴻⵏ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K122_38","012_22_38","1KI","22","38","38","ⵙⵙⵉⵔⴷⴻⵏ ⴰⴽⴰⵔⵔⵓ ⴷⴻⴳ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵍⴻⵙⵃⴻⵏ ⵉⵟⴰⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵏⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵙⵙⵉⵔⴷⴻⵏⵜ ⴷⴰⵢⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K122_39","012_22_39","1KI","22","39","39","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵅⴰⴱ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⵄⴰⵊ ⵉ ⵉⴱⵏⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵉⴱⵏⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K122_40","012_22_40","1KI","22","40","40","ⴰⵅⴰⴱ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵎⵎⵉⵙ ⴰⵅⴰⵣⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K122_41","012_22_41","1KI","22","41","41","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K122_42","012_22_42","1KI","22","42","42","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵣⵓⴱⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵍⵅⵉ. ");
INSERT INTO rift_vpl VALUES ("K122_43","012_22_43","1KI","22","43","43","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴱⵔⵉⴷⵉⵏ ⵏ ⴱⴰⴱⴰⵙ ⴰⵙⴰ, ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⵉⵃⴻⵢⵢⴻⴷ ⵛⴰ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K122_44","012_22_44","1KI","22","44","44","ⵍⴻⴳⵄⵓⴷⵉ ⵡⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ. ⵍⴳⴻⵏⵙ ⵢⵉⵡⵉ ⵄⴰⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K122_45","012_22_45","1KI","22","45","45","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵃⴹⴰ ⵅ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K122_46","012_22_46","1KI","22","46","46","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ ⵉ ⵉⴳⴳⴰ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵎⵏⴻⵖ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K122_47","012_22_47","1KI","22","47","47","ⵏⴻⵜⵜⴰ ⵉⵎⵃⴰ ⵉⵎⴻⵜⵍⴻⵢⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⴰⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K122_48","012_22_48","1KI","22","48","48","ⴷⵉ ⵉⴷⵓⵎ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⵛⴰ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵍⵡⴰⵍⵉ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K122_49","012_22_49","1KI","22","49","49","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⴳⴳⴰ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵓⴼⵉⵔ ⴰⴷ ⴰⵡⵢⴻⵏ ⵓⵔⴻⵖ. ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵉⵖⴰⵔⵔⵓⴱⴰ ⴰⵔⵥⵉⵏ ⵖⴰⵔ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K122_50","012_22_50","1KI","22","50","50","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⴻⵊⵊ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵏⴻⴷⵀⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵅ ⵉⵖⴰⵔⵔⵓⴱⴰ!”, ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵢⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("K122_51","012_22_51","1KI","22","51","51","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⵢⴰⵀⵓⵔⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K122_52","012_22_52","1KI","22","52","52","ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K122_53","012_22_53","1KI","22","53","53","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⴱⴰⴱⴰⵙ ⵓ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⴻⵎⵎⴰⵙ ⵓ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K122_54","012_22_54","1KI","22","54","54","ⵏⴻⵜⵜⴰ ⵉⵄⴱⴻⴷ ⴱⴰⵄⵍ, ⵉⴱⴻⵏⴷⴻⵇ ⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵄⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K21_1","013_1_1","2KI","1","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵡⵜ ⵏ ⴰⵅⴰⴱ ⵉⵖⴻⵡⵡⴻⵖ ⵎⵓ’ⴰⴱ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K21_2","013_1_2","2KI","1","2","2","ⵉⵡⴹⴰ-ⴷⴷ ⴰⵅⴰⵣⵢⴰ ⵙ ⵜⵔⴰⵛⵛⴰ ⵏ ⵍⴽⴰⵣⵉ ⵏ ⵜⵖⵓⵔⴼⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵉⵀⵍⴻⵛ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⴱⴰⵄⴰⵍ-ⵣⴰⴱⵓⴱ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵄⴰⵇⵔⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵏⴻⵇⵇ ⵍⴻⵀⵍⴰⵛ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("K21_3","013_1_3","2KI","1","3","3","ⵎⴰⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵉⵍⵉⵛⴰⵄ, ⴰⵜⵉⵛⴱⵉ: “ⴽⴽⴰⵔ, ⴳⴻⵄⵄⴻⴷ, ⵍⵇⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ: ‘ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⴷⵉⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵢⵓⵔⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ ⴱⴰⵄⴰⵍ-ⵣⴰⴱⵓⴱ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵄⴰⵇⵔⵓⵏ?’ ");
INSERT INTO rift_vpl VALUES ("K21_4","013_1_4","2KI","1","4","4","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⴷⴷ-ⵜⵀⴻⴽⴽⵯⵉⴷ ⵛⴰ ⵣⵉ ⵜⴰⵙⵙⵓⵜ ⵉ ⵅ ⵜⴳⴻⵄⵄⴷⴻⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵍⵎⴻⵡⵜ.’” ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵉⵍⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K21_5","013_1_5","2KI","1","5","5","ⵍⴰⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴰⵅⴰⵣⵉⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉ ⵏⵉⵜⵏⵉ: “ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵍⴰⵎⵉ ⴷⴷ-ⵜⵄⴻⵇⴱⴻⵎ ⵄⴰⵡⴻⴷ ⴷⴻⵖⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("K21_6","013_1_6","2KI","1","6","6","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ, ⵉⵏⵏⴰ ⴰⵏⴻⵖ: ‘ⵄⴻⵇⴱⴻⵎ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ: ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵣⴻⵄⵎⴰ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵍⴰⵎⵉ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⴱⴰⵄⴰⵍ-ⵣⴰⴱⵓⴱ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵄⴰⵇⵔⵓⵏ? ⵙ ⵓⵢⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵀⴻⴽⴽⵯⵉⴷ ⵛⴰ ⵣⵉ ⵜⴰⵙⵙⵓⵜ ⵉ ⵅ ⵜⴳⴻⵄⵄⴷⴻⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵍⵎⴻⵡⵜ.’” ");
INSERT INTO rift_vpl VALUES ("K21_7","013_1_7","2KI","1","7","7","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵡⴰⴷⴷⵓⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴽⵉⴷⵡⴻⵎ ⵉⵎⵙⴰⴳⴰⵔⴻⵏ ⵓ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵡⴻⵎ ⴰⵡⴰⵍⴻⵏ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("K21_8","013_1_8","2KI","1","8","8","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ, ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵏ ⵛⵛⴰⵔⴽ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵡⴰ ⴷ ⵉⵍⵉⵢⴰ, ⴰⵜⵉⵛⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("K21_9","013_1_9","2KI","1","9","9","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵅⴻⵎⵙⵉⵏ ⴰⴽ-ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ. ⵡⴰⵏⵉⵜⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔⴻⵙ, ⵓ ⵅⵣⴰⵔ, ⵉⵍⵉⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔⴻⵙ: “ⵛⴻⴽ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ ⴰⵛ: ‘ⵀⵡⴰ-ⴷⴷ!’” ");
INSERT INTO rift_vpl VALUES ("K21_10","013_1_10","2KI","1","10","10","ⵉⵍⵉⵢⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵅⴻⵎⵙⵉⵏ: “ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⴰⴷ ⵜⴻⵡⴹⴰ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵛⴻⴽ ⵜⴻⵛⵛ, ⵛⴻⴽ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵛ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵛⵛⴰ ⵉ-ⵜ ⵏⴻⵜⵜⴰ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K21_11","013_1_11","2KI","1","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵅⴻⵎⵙⵉⵏ ⴰⴽ-ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ⵡⴰⵏⵉⵜⴰ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ, ⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ‘ⵀⵡⴰ-ⴷⴷ ⴷⴻⵖⵢⴰ!’” ");
INSERT INTO rift_vpl VALUES ("K21_12","013_1_12","2KI","1","12","12","ⵉⵍⵉⵢⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵖⴰ ⵜⴻⵡⴹⴰ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵛⴻⴽ ⵜⴻⵛⵛ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵛ,” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵛⵛⴰ ⵉ-ⵜ ⵏⴻⵜⵜⴰ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K21_13","013_1_13","2KI","1","13","13","ⵉⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵅⴻⵎⵙⵉⵏ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⴰⴽ-ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ. ⵓⵎⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵅⴻⵎⵙⵉⵏ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔⴻⵙ, ⵢⵓⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵉⵍⵉⵢⴰ ⵓⵛⴰ ⵉⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⴰⴷ ⵜⴻⵙⵡⴰ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ, ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K21_14","013_1_14","2KI","1","14","14","ⵅⵣⴰⵔ, ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵛⵛⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵅⴻⵎⵙⵉⵏ ⴰⴽ-ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ. ⴻⵊⵊ ⴰⴷ ⵜⴻⵙⵡⴰ ⵍⴻⵅⵅⵓ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("K21_15","013_1_15","2KI","1","15","15","ⵓⵛⴰ ⵉⵏⵏⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵍⵉⵢⴰ: “ⵀⵡⴰ ⴰⴽⵉⴷⴻⵙ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ!” ⵉⴽⴽⴰⵔ ⵏⴻⵜⵜⴰ, ⵉⵀⵡⴰ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K21_16","013_1_16","2KI","1","16","16","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⴱⴰⵄⴰⵍ-ⵣⴰⴱⵓⵍ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵄⴰⵇⵔⵓⵏ, ⴰⵅⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⵅ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵙ ⵓⵢⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵀⴻⴽⴽⵡⵉⴷ ⵛⴰ ⵣⵉ ⵜⴰⵙⵙⵓⵜ ⵉ ⵅ ⵜⴳⴻⵄⵄⴷⴻⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵍⵎⴻⵡⵜ.’” ");
INSERT INTO rift_vpl VALUES ("K21_17","013_1_17","2KI","1","17","17","ⴰⵎⵎⵓ ⵉ ⵉⵎⵎⵓⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵍⵉⵢⴰ. ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵎⵎⵉⵙ, ⵉⴷⵡⴻⵍ ⵢⵓⵔⴰⵎ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴰⵀⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K21_18","013_1_18","2KI","1","18","18","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵅⴰⵣⵢⴰ, ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K22_1","013_2_1","2KI","2","1","1","ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵜⵎⴻⴽⵙⵉⵜ ⵏ ⵉⵍⵉⵢⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⵉⴼⴼⴻⵖ ⵉⵍⵉⵢⴰ ⴰⴽ-ⴷ ⵉⵍⵉⵛⴰⵄ ⵣⵉ ⵊⵉⵍⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("K22_2","013_2_2","2KI","2","2","2","ⵉⵏⵏⴰ ⵉⵍⵉⵢⴰ ⵉ ⵉⵍⵉⵛⴰⵄ: “ⵇⵇⵉⵎ ⴷⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ.” ⵎⴰⵛⴰ ⵉⵍⵉⵛⴰⵄ ⵉⵏⵏⴰ:“ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ.” ⴰⵎⵎⵓ ⵉ ⵀⵡⴰⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K22_3","013_2_3","2KI","2","3","3","ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵖⴰⵔ ⵉⵍⵉⵛⴰⵄ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⵙⵙ-ⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⴱⴰⴱ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵜ. ⵙⵇⴰⵔⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("K22_4","013_2_4","2KI","2","4","4","ⵉⵍⵉⵢⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵇⵇⵉⵎ ⴷⴰ, ⵉⵍⵉⵛⴰⵄ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ ⵖⴰⵔ ⴰⵔⵉⵃⴰ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ ⵛⴰ!” ⴰⵎⵎⵓ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("K22_5","013_2_5","2KI","2","5","5","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴰⵔⵉⵃⴰ ⵖⴰⵔ ⵉⵍⵉⵛⴰⵄ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⵙⵙ-ⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⴱⴰⴱ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵜ. ⵙⵇⴰⵔⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("K22_6","013_2_6","2KI","2","6","6","ⵉⵍⵉⵢⴰ ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵇⵇⵉⵎ ⴷⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⴰⵎ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ ⵛⴰ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K22_7","013_2_7","2KI","2","7","7","ⵓⵍⴰ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓⵢⵓⵔⴻⵏ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⴰⵎ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K22_8","013_2_8","2KI","2","8","8","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵉⵍⵉⵢⴰ ⴰⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ, ⵉⵙⵙⵓⵏⵏⴻⴹ ⵉ-ⵜ ⵓⵛⴰ ⵉⵡⵜⴰ ⵣⵣⴰⵢⴻⵙ ⵅ ⵡⴰⵎⴰⵏ ⵏⵏⵉ ⵜⵜⵡⴰⴱⴹⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵅ ⵍⴰⵥⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("K22_9","013_2_9","2KI","2","9","9","ⵍⴰⵎⵉ ⵥⵡⴰⵏ ⵏⵉⵜⵏⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵍⵉⵢⴰ ⵉⵏⵏⴰ ⵉ ⵉⵍⵉⵛⴰⵄ: “ⵜⵜⴰⵔ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⴷ ⴰⵛ ⵖⴰ ⴳⴳⴻⵖ, ⵇⴱⴻⵍ ⵎⵎⴰ ⵅⴰⴽ ⵉ ⵖⴰ ⵎⵎⴻⴽⵙⵉⵖ!” ⵉⵍⵉⵛⴰⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵉⵍⵉ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵀⵡⴰⵏⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("K22_10","013_2_10","2KI","2","10","10","ⵉⵍⵉⵢⴰ ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⵡⵄⴰⵔ. ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⴰⵢⵉ ⵍⴰⵎⵉ ⵅⴰⴽ ⵉ ⵖⴰ ⵎⵎⴻⴽⵙⵉⵖ, ⴰⴷ ⴰⵛ ⵉⵎⵙⴰⵔ ⴰⵎⵎⵓ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("K22_11","013_2_11","2KI","2","11","11","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⵏⵉⵜⵏⵉ ⴳⴳⵓⵔⴻⵏ ⵓ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴽⴰⵔⵔⵓⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴰⴽ-ⴷ ⵉⵢⵙⴰⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵜⴻⵏⵏⵉ ⵜⴻⴱⴹⴰ ⵉ-ⵜⴻⵏ ⵉⵊⵊ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⴰⵎⵎⵓ ⵉⴳⴻⵄⵄⴻⴷ ⵉⵍⵉⵢⴰ ⴷⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K22_12","013_2_12","2KI","2","12","12","ⵉⵍⵉⵛⴰⵄ ⵉⵥⵔⴰ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵅⴰⵙ: “ⴰ ⴱⴰⴱⴰ, ⴰ ⴱⴰⴱⴰ! ⴰⴽⴰⵔⵔⵓ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ!” ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜ ⵉⵜⵡⵉⵍⵉ ⵄⴰⴷ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵛⴰⵔⵔⴻⴳ ⵉ-ⵜ ⵅ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K22_13","013_2_13","2KI","2","13","13","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⴰⵙⴻⵍⵀⴰⵎ ⵉ ⴷⴷ-ⵢⴻⵡⴹⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵉⵄⵇⴻⴱ, ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K22_14","013_2_14","2KI","2","14","14","ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⴰⵙⴻⵍⵀⴰⵎ ⵏ ⵉⵍⵉⵢⴰ ⵉ ⴷⴷ-ⵢⴻⵡⴹⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ, ⵉⵡⵜⴰ ⵣⵣⴰⵢⴻⵙ ⵅ ⵡⴰⵎⴰⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵍⵉⵢⴰ? ⵡⴰⵀ, ⵏⴻⵜⵜⴰ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵅ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵎⵎⵙⴻⴱⴹⴰⵏ ⵏⵉⵜⵏⵉ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵓⵛⴰ ⵉⵥⵡⴰ ⵉⵍⵉⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("K22_15","013_2_15","2KI","2","15","15","ⵓⵎⵉ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⴰⵔⵉⵃⴰ, ⵥⵔⵉⵏ ⵜ, ⵏⵏⴰⵏ: “ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵍⵉⵢⴰ ⵢⴰⵔⵙⴰ ⵅ ⵉⵍⵉⵛⴰⵄ.” ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵓⴹⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K22_16","013_2_16","2KI","2","16","16","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ ⵅⴻⵏⵏⵉ, ⵊⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ, ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵙⵉⴷⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ ⵉⴽⵙⵉ ⵜ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏⵉⵖ ⴷⴻⴳ ⵉⵛⵜ ⵣⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ.” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵙⴻⴽⴽⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ!” ");
INSERT INTO rift_vpl VALUES ("K22_17","013_2_17","2KI","2","17","17","ⵓⵎⵉ ⵅⴰⵙ ⵄⴻⵎⵎⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵡⴻⴷⴷⴰⵔ ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ, ⵉⵏⵏⴰ: “ⵉⵡⴰ ⵙⴻⴽⴽⴻⵎ ⵜⴻⵏ ⴷⵉⵏ!” ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵏⴰ ⴰⵔⵣⵓⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜ ⵓⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K22_18","013_2_18","2KI","2","18","18","ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⴰⵔⵉⵃⴰ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⵎ ⵛⴰ’?” ");
INSERT INTO rift_vpl VALUES ("K22_19","013_2_19","2KI","2","19","19","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴰⵏ ⵉ ⵉⵍⵉⵛⴰⵄ: “ⵅⵣⴰⵔ ⵅⴻⵏⵏⵉ, ⴰⴷⴷⵓⴷ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵎⵍⵉⵃ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵎⴰⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵉⵡⵉ-ⴷⴷ ⴰⴳⵔⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("K22_20","013_2_20","2KI","2","20","20","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵟⵟⴻⴱⵙⵉ ⴷ ⴰⵎⴰⵢⵏⵓ ⵓ ⴳⴳⴻⵎ ⴷⴰⵢⴻⵙ ⵜⴰⵎⴻⴵⴰⵃⵜ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵙ ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("K22_21","013_2_21","2KI","2","21","21","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵜⴰⵍⴰ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵏⵏⵉ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ ⴰⵎⴰⵏ-ⴰ ⵚⴻⴱⵃⴻⵏ. ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵡⵢⴻⵏ ⵍⵎⴻⵡⵜ ⵏⵉⵖ ⴷ ⴰⴳⵔⴰⵢ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("K22_22","013_2_22","2KI","2","22","22","ⴰⵎⴰⵏ ⴷⴻⵡⵍⴻⵏ ⵚⴻⴱⵃⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵍ ⴰⵙⵙ-ⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵉⵍⵉⵛⴰⵄ ⵉ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K22_23","013_2_23","2KI","2","23","23","ⵙⵙⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ⴰⵎ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⴰⴱⵔⵉⴷ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵏⵏⵉ ⵜ ⵉⴽⴽⵯⴰⵔⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵇⴻⵛⵛⴰⵔ, ⴳⴻⵄⵄⴻⴷ! ⴰⵇⴻⵛⵛⴰⵔ, ⴳⴻⵄⵄⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("K22_24","013_2_24","2KI","2","24","24","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵉⵅⵣⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵉⵅⵣⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⴷⴷⵓⴱⴰⵜ ⵣⴻⴳ ⵡⴻⵣⵖⴰⵔ ⵓ ⵎⴻⵣⵣⵇⴻⵏ ⵜⵏⴰⵢⴻⵏ-ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K22_25","013_2_25","2KI","2","25","25","ⵙⵙⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ ⵓⵛⴰ ⵙⵙⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K23_1","013_3_1","2KI","3","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K23_2","013_3_2","2KI","3","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⴰⵎⵎⵓ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵎ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⵎⴰⵖⴰⵔ ⵉⴽⴽⴻⵙ ⴰⵎⴰⵢⴹⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴱⴰⵄⴰⵍ ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K23_3","013_3_3","2KI","3","3","3","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵎⴻⵏⵏⴻⵄ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K23_4","013_3_4","2KI","3","4","4","ⵎⵉⵛⴰⵄ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵓ ⵜⵓⵖⴰ ⵉⵜⵜⵉⵛ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵜⴰⴹⵓⴼⵜ ⵏ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K23_5","013_3_5","2KI","3","5","5","ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⴰⵅⴰⴱ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K23_6","013_3_6","2KI","3","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵔⴰⵎ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵉⵙⴻⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K23_7","013_3_7","2KI","3","7","7","ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: “ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ ⵉⵖⴻⵡⵡⴻⵖ ⵅⴰⴼⵉ. ⵎⴰ ⵛⴻⴽ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⴼⴼⵖⴻⴷ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵎⵓ’ⴰⴱ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴼⴼⵖⴻⵖ ⴰⴽⵉⴷⴻⴽ. ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⵎ ⵛⴻⴽ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵉⵢⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵢⵙⴰⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K23_8","013_3_8","2KI","3","8","8","ⵉⵏⵏⴰ: “ⵅ ⵎⴰⵏ ⴰⴱⵔⵉⴷ ⵉ ⵖⴰ ⵏⴳⴻⵄⵄⴻⴷ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⵍⴰ ⵏ ⵉⴷⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("K23_9","013_3_9","2KI","3","9","9","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ. ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⴰⵎⴰⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⵉ ⵜⴻⵏ ⵉⴹⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K23_10","013_3_10","2KI","3","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⴰⵅⴻⵢⵢⴻⴱ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓⵎⵉ ⴷⴷ-ⵉⵍⴰⵖⴰ ⵙⵉⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵓ’ⴰⴱ!” ");
INSERT INTO rift_vpl VALUES ("K23_11","013_3_11","2KI","3","11","11","ⵓⵛⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉ ⵣⵉ ⵖⴰ ⵏⴻⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ?” ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵉⵍⵉⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵜ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴵⵄⴻⵏ ⴰⵎⴰⵏ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵍⵉⵢⴰ, ⴰⵇⴰ-ⵜ ⴷⴰⵏⵉⵜⴰ!” ");
INSERT INTO rift_vpl VALUES ("K23_12","013_3_12","2KI","3","12","12","ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵖⴰⵔⴻⵙ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ.” ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K23_13","013_3_13","2KI","3","13","13","ⵉⵍⵉⵛⴰⵄ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⵉⵏ ⴷⵉⵏⵏⵉ ⵊⴰⵔ ⴰⵢⵉ-ⴷⴷ ⴷ ⵛⴻⴽ? ⵓⵢⵓⵔ ⵖⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴱⴰⴱⴰⵛ ⵓ ⵖⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵢⴻⵎⵎⴰⵛ!” ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵍⵍⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵜⵍⴰⵜⴰ-ⵢⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵖⴰⵔ ⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵓ’ⴰⴱ.” ");
INSERT INTO rift_vpl VALUES ("K23_14","013_3_14","2KI","3","14","14","ⵉⵍⵉⵛⴰⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵓⵎⵉ ⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⵍⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵓⵡⴻⵇⵇⴰⵔ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵢⵉⵍⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵃⴻⵙⵙⴱⴻⵖ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵅⴻⵣⵣⴰⵔⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("K23_15","013_3_15","2KI","3","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵉⵛⵛⴰⵜ ⵅ ⵉⴼⵉⵍⴰⵏ. ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵉⵔⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵛⵛⴰⵜⴻⵏ ⵅ ⵉⴼⵉⵍⴰⵏ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵢⴰⵔⵙⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K23_16","013_3_16","2KI","3","16","16","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴳⴳⴻⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ-ⴰ ⵜⴰⵍⵢⵉⵡⵉⵏ ⴷ ⵜⴻⵍⵢⵉⵡⵉⵏ ⴽⵜⴰⵔ!’ ");
INSERT INTO rift_vpl VALUES ("K23_17","013_3_17","2KI","3","17","17","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⵎ ⴰⵙⴻⵎⵎⵉⴹ ⵓⵍⴰ ⴷ ⴰⵏⵥⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⴰⵖⵣⵓⵔⵜ-ⴰ ⴰⴷ ⵜⴻⵛⵛⵓⵔ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵯⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵡⴻⵎ ⴷ ⵣⵣⵡⴰⵢⴻⵍ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("K23_18","013_3_18","2KI","3","18","18","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⴷ ⴷⵔⵓⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵓⵍⴰ ⴷ ⵎⵓ’ⴰⴱ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("K23_19","013_3_19","2KI","3","19","19","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵡⵜⴻⵎ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ ⵓ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵓ ⴰⴷ ⵜⵇⴻⴹⵄⴻⵎ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⴰⴷ ⵜⴱⴻⵍⵍⵄⴻⵎ ⵎⴰⵔⵔⴰ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵓ ⴰⴷ ⵜⴹⴻⵢⵢⵄⴻⵎ ⴽⵓⵍ ⵉⵢⵢⴰⵔ ⵉⵚⴻⴱⵃⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵢⴻⵥⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("K23_20","013_3_20","2KI","3","20","20","ⵓⵛⴰ ⴷⵉ ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⵖⴰⵔ ⴷⴷ-ⵜⵜⴰⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵡⴰⵎⴰⵏ ⵣⵉ ⵉⴷⵓⵎ ⵓⵛⴰ ⵜⵖⴻⴱⴱⴰ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K23_21","013_3_21","2KI","3","21","21","ⵎⵓ’ⴰⴱ ⴰⵎ ⵉⴽⵎⴻⵍ ⵉⵙⵍⴰ ⴱⴻⵍⵍⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ, ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⴻⵏⵏⵃⴻⵏ ⵙ ⵡⴻⴱⵢⴰⵙ ⵏ ⵍⴻⵙⵏⴰⵃ ⴰⵍ ⴽⵓⵍ ⵉⵊⵊ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵢⴰ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⴻⵜⵜⴼⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K23_22","013_3_22","2KI","3","22","22","ⵏⵉⵜⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏ ⵚⵚⴱⴻⵃ, ⵓ ⵓⵎⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵅ ⵡⴰⵎⴰⵏ, ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵏⵏⵉ ⵅ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ, ⴰⵇⴰ ⴰⵎⴰⵏ ⴷ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⴰⵎ ⵢⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K23_23","013_3_23","2KI","3","23","23","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵉⵏⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵖⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵎⵎⴻⵏⵖⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵊⵊ ⵉⵡⵜⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵉⵡⴰ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵟⵟⴼⴻⵎ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ!” ");
INSERT INTO rift_vpl VALUES ("K23_24","013_3_24","2KI","3","24","24","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⴽⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵡⵜⵉⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ. ⴰⵔⴻⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⵜⵉⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("K23_25","013_3_25","2KI","3","25","25","ⵏⵉⵜⵏⵉ ⵀⴻⴷⵎⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵏⴹⴰⵔ ⴰⵥⵔⵓ ⵏⵏⴻⵙ ⵅ ⴽⵓⵍ ⵉⵢⵢⴰⵔ ⵉⵚⴻⴱⵃⴻⵏ ⵓⵛⴰ ⴷⵍⵉⵏ ⵜ. ⵄⴰⵡⴻⴷ ⵏⴻⵜⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵇⴻⴹⵄⴻⵏ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵍⴰⵎⵉ ⵛⴻⵟⵟⴻⵏ ⵎⵖⵉⵔ ⵉⵥⵔⴰ ⵏ ⵍⵃⵉⴹ ⵏ ⵇⵉⵔ-ⵃⴰⵔⵉⵙⴰⵜ. ⴰⵢⵜ ⴱⵓ-ⵉⴵⴰⵢⴻⵏ ⵏⵏⴹⴻⵏ ⴰⵙ ⵓⵛⴰ ⵖⴻⴹⵍⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("K23_26","013_3_26","2KI","3","26","26","ⵓⵎⵉ ⵉⵥⵔⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ ⴱⴻⵍⵍⵉ ⴰⵎⴻⵏⵖⵉ ⵉⵡⵄⴰⵔ ⵅⴰⵙ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵊⴻⴱⴷⴻⵏ ⵙⵙⵉⴼ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵓⵇ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K23_27","013_3_27","2KI","3","27","27","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜ ⵅ ⵍⵃⵉⴹ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K24_1","013_4_1","2KI","4","1","1","ⵉⵛⵜ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵍⴰⵖⴰ ⵉ ⵉⵍⵉⵛⴰⵄ, ⵜⴻⵏⵏⴰ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⵔⵢⴰⵣ ⵉⵏⵓ, ⵉⵎⵎⵓⵜ, ⵓⵛⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ. ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴱⴰⴱ ⵏ ⵡⴰⵔⴻⵟⵟⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⴷ ⵉⵙⴻⵎⵖⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K24_2","013_4_2","2KI","4","2","2","ⵉⵏⵏⴰ ⴰⵙ ⵉⵍⵉⵛⴰⵄ: “ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵎ ⴳⴳⴻⵖ? ⵉⵏⵉ ⴰⵢⵉ ⵎⵉⵏ ⵖⴰⵔⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ.” ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵔⴰⴼⵜ ⴷⴰⵢⴻⵙ ⵣⵣⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("K24_3","013_4_3","2KI","4","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵜⵜⴰⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵜⵉⵇⴷⵓⵃⵉⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵉⵇⴷⵓⵃⵉⵏ ⵏ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵎ ⵅⵡⴰⵏⵜ, ⵃⴹⴰ ⵡⴰⵔ ⵉⵍⵉⵏⵜ ⴷⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("K24_4","013_4_4","2KI","4","4","4","ⵅⴻⵏⵏⵉ ⴰⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵎ ⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ. ⴼⴰⵔⵔⴻⵖ ⵅⴻⵏⵏⵉ ⵣⵣⴻⵛⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴷⵓⵃⵉⵏ ⵏⵏⵉ, ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵛⵛⵓⵔ, ⵙⴰⵔⵙ ⵉ-ⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ!” ");
INSERT INTO rift_vpl VALUES ("K24_5","013_4_5","2KI","4","5","5","ⵅⴰⵙ ⵓⵛⴰ ⵜⵓⵢⵓⵔ ⵅⴰⵙ ⵓⵛⴰ ⵜⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵖⴰⵔⴻⵙ ⵜⵉⵇⴷⵓⵃⵉⵏ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴼⴰⵔⵔⴻⵖ ⴷⴰⵢⵙⴻⵏⵜ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("K24_6","013_4_6","2KI","4","6","6","ⵓⵎⵉ ⵛⵛⵓⵔⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴷⵓⵃⵉⵏ, ⵜⴻⵏⵏⴰ ⵉ ⵎⵎⵉⵙ: “ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⴻⵇⴷⵓⵃⵜ!”, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵡⴰⵔ ⴷⴰ ⵜⴻⵇⵇⵉⵎ ⵛⴰ ⵜⴻⵇⴷⵓⵃⵜ ⵄⴰⴷ!” ⵓ ⵣⵣⴻⵛⵜ ⵜⵓⵖⴰ ⵜⴻⵇⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K24_7","013_4_7","2KI","4","7","7","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵢⵓⵔ ⴰⴷ ⵜⵜ ⵜⵅⴻⴱⴱⴰⵔ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ, ⵣⴻⵏⵣ ⵣⵣⴻⵛⵜ ⵓ ⵅⴻⴵⴻⵚ ⴱⴰⴱ ⵏ ⵡⴰⵔⴻⵟⵟⴰⵍ ⵏⵏⴻⵎ ⵓ ⵣⵉ ⵎⵉⵏ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵛⴻⵎ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("K24_8","013_4_8","2KI","4","8","8","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵎⵉ ⴷⴷ-ⵉⴽⴽⴰ ⵉⵍⵉⵛⴰⵄ ⵅ ⵛⵓⵏⴰⵎ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵛⵛ. ⵍⴻⴱⴷⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵜⵜⴻⴽⴽ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵖⴰⵔ ⴷⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛ ⵛⴰ ⵏ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("K24_9","013_4_9","2KI","4","9","9","ⵏⴻⵜⵜⴰⵜ ⵎⴰⵛⴰ ⵜⴻⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵓⵛⵉⵖ ⴰⵇⴰ ⴰⵔⵢⴰⵣ-ⴰ ⵉ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵍⴻⴱⴷⴰ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⵢⴰⵣ ⴰⵎⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K24_10","013_4_10","2KI","4","10","10","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴱⵏⴰ ⵙⴻⵏⵏⴻⵊ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵙ ⵍⴻⵃⵢⵓⴹ, ⵓⵛⴰ ⴰⴷ ⵏⴻⴳⴳ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵇⴰⵎⴰ, ⵉⵛⵜ ⵏ ⵟⵟⴰⴱⵍⴰ, ⵉⵊⵊ ⵏ ⵍⴽⵓⵔⵙⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ ⵉ ⵏⴻⵜⵜⴰ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵄⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K24_11","013_4_11","2KI","4","11","11","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵍⵉⵛⴰⵄ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉⵏ ⵓⵛⴰ ⵉⵄⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵏⵏⴻⵊ ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵣⵣⴻⵍ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K24_12","013_4_12","2KI","4","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵊⵉⵃⴰⵣⵉ: “ⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵜⵛⵓⵏⴰⵎⴻⵛⵜ ⵜⴰⵏⵉⵜⴰ!” ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K24_13","013_4_13","2KI","4","13","13","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰⵏ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⵉⵏⵉ ⴰⵙ: ‘ⵛⴻⵎ ⵜᵉⵜⵀⵉⵍⵍⵉⴷ ⴷⴰⵢⵏⴻⵖ ⴰⵟⵟⴰⵙ. ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵎ ⵉⵜⵜⵡⴰⴳⴳ? ⵎⴰ ⴰⴷ ⵜⴰⵖ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵎⵉⵏ ⵅⴻⴼ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵉⵖ ⴰⴽ-ⴷ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵎ?’” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵏⴻⵛⵛ ⵣⴻⴷⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K24_14","013_4_14","2KI","4","14","14","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴳⴳ?” ⵓⵛⴰ ⵉⵏⵏⴰ ⵊⵉⵃⴰⵣⵉ: “ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵃⴻⵏⵊⵉⵔ ⵓ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵡⵙⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("K24_15","013_4_15","2KI","4","15","15","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ “ⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵇⵇⵉⵎ ⵏⴻⵜⵜⴰⵜ ⵜⴱⴻⴷⴷ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("K24_16","013_4_16","2KI","4","16","16","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⵓⴷⴰⵔⵜ, ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⵃⴻⵏⵊⵉⵔ ⴷⴻⴳ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵎ.” ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵙⵅⴰⵔⵔⵉⵇ ⵣⴻⵄⵎⴰ ⵅ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("K24_17","013_4_17","2KI","4","17","17","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⴷⵡⴻⵍ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵍⵉⵛⴰⵄ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K24_18","013_4_18","2KI","4","18","18","ⵓⵎⵉ ⵉⵎⵖⴰⵔ ⵓⵃⴻⵏⵊⵉⵔ, ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K24_19","013_4_19","2KI","4","19","19","ⵉⵏⵏⴰ ⵉ ⴱⴰⴱⴰⵙ: “ⴰ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⴰ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ!” ⵓⵛⴰ ⴱⴰⴱⴰⵙ ⵉⵏⵏⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ: “ⴰⵔⴱⵓ ⵜ ⵖⴰⵔ ⵢⴻⵎⵎⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("K24_20","013_4_20","2KI","4","20","20","ⵏⴻⵜⵜⴰ ⵢⴰⵔⴱⵓ ⵜ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵢⴻⵎⵎⴰⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⴰⵍ ⴰⵣⴰⵍ, ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K24_21","013_4_21","2KI","4","21","21","ⵏⴻⵜⵜⴰⵜ ⵜⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ, ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵅ ⵇⴰⵎⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K24_22","013_4_22","2KI","4","22","22","ⵜⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷ ⵉⵊⵊ ⵣⵉ ⵜⴻⵖⵢⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵄⴻⵇⴱⴻⵖ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("K24_23","013_4_23","2KI","4","23","23","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔⴻⵙ ⴰⵙⵙ-ⴰ? ⴰⵇⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⴱⴻⴷⴷⵉ ⵏ ⵓⵢⵓⵔ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵙⵙⴻⴱⵜ.” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⴽⵓⵍⵛⵉ ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ!” ");
INSERT INTO rift_vpl VALUES ("K24_24","013_4_24","2KI","4","24","24","ⵏⴻⵜⵜⴰⵜ ⵜⴱⴰⵔⴷⴻⵄ ⵉ ⵜⴻⵖⵢⵓⵍⵜ ⵓ ⵜⴻⵏⵏⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⵏⴷⴻⵀ ⵉ-ⵜⵜ, ⵇⵇⵉⵎ ⴳⴳⵓⵔ. ⴰⵎ ⵜⵏⴻⴷⵀⴻⴷ ⵡⴰⵔ ⵜⴱⴻⴷⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵎⵖⵉⵔ ⵅⵎⵉ ⴷ ⴰⵛ ⵜ ⵉ ⵖⴰ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("K24_25","013_4_25","2KI","4","25","25","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴼⴼⴻⵖ ⵓⵛⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ. ⵓⵎⵉ ⵜⵜ ⵉⵥⵔⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵉⵏⵏⴰ ⵉ ⵊⵉⵃⴰⵣⵉ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴷ ⵜⴰⵛⵓⵏⴰⵎⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("K24_26","013_4_26","2KI","4","26","26","ⵍⴻⵅⵅⵓ, ⵓⵢⵓⵔ ⴷⴻⵖⵢⴰ, ⵍⵇⴰ ⵜⵜ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙ: ‘ⵎⴰ ⴰⵇⴰ ⵛⴻⵎ ⵎⵍⵉⵃ? ⵎⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ ⴰⵇⴰ-ⵜ ⵎⵍⵉⵃ? ⵎⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵎ ⴰⵇⴰ-ⵜ ⵎⵍⵉⵃ?’” ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⴰⵇⴰ-ⵜⴻⵏ ⵎⵍⵉⵃ!” ");
INSERT INTO rift_vpl VALUES ("K24_27","013_4_27","2KI","4","27","27","ⵓⵎⵉ ⵎⴰⵛⴰ ⴷⴷ-ⵜⵓⵙⴰ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵡⴻⴷⵔⴰⵔ, ⵜⵇⴻⴱⴱⴻⴹ ⵏⴻⵜⵜⴰⵜ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵊⵉⵃⴰⵣⵉ ⵢⵓⴷⴻⴼ-ⴷⴷ ⴷⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵄⴰⵔⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ: “ⴰⵃⵜⴰ ⴰⵙ, ⵎⴰⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵛⴹⴻⵏ ⴷⴰⵢⴻⵙ ⵓ ⵙⵉⴷⵉ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵅⴰⴼⵉ ⵎⵉⵏ ⵅⴻⴼ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("K24_28","013_4_28","2KI","4","28","28","ⵜⴻⵏⵏⴰ ⵏⴻⵜⵜⴰⵜ: “ⵎⴰ ⵏⴻⵛⵛ ⵜⵜⴰⵔⴻⵖ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵊⵊ ⵏ ⵎⵎⵉ? ⵎⴰ ⵡⴰⵔ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ‘ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵛⴻⵎⵎⴻⵜ’?” ");
INSERT INTO rift_vpl VALUES ("K24_29","013_4_29","2KI","4","29","29","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵊⵉⵃⴰⵣⵉ: “ⴱⵢⴻⵙ ⵜⴰⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ, ⴽⵙⵉ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ! ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵎⵎⴻⵍⵇⵉⴷ ⵛⴰ ⵏ ⵢⵉⵊⵊ, ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵙⴻⴵⴰⵎ, ⵓ ⵎⴰⵍⴰ ⵉⵙⴻⴵⴻⵎ ⵅⴰⴽ ⵃⴻⴷ, ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵜⵜⴰⵔⵔⵉ ⵛⴰ! ⵙⴰⵔⵙ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵉⵏⵓ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵃⴻⵏⵊⵉⵔ!” ");
INSERT INTO rift_vpl VALUES ("K24_30","013_4_30","2KI","4","30","30","ⵎⴰⵛⴰ ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵜⴻⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵓ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⵃⴻⵢⵢⵉⴷⴻⵖ ⵛⴰ!” ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵉⴹⴼⴰⵔ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("K24_31","013_4_31","2KI","4","31","31","ⵜⵓⵖⴰ ⵊⵉⵃⴰⵣⵉ ⵉⵣⵡⴰⵔ ⴷⴻⵖⵢⴰ ⵣⵣⴰⵜⵙⴻⵏ ⵓ ⵉⵙⵙⴰⵔⵙ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵃⴻⵏⵊⵉⵔ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵛⴰ ⵍⵃⴻⵙⵙ ⵓⵍⴰ ⴷ ⵜⵡⴰⵔⵔⵉⵜ. ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵉⵍⵇⴰ, ⵓⵛⴰ ⵉⵃⴰⵊⴰ ⴰⵙ ⵜ, ⵉⵏⵏⴰ: “ⴰⵃⴻⵏⵊⵉⵔ ⵡⴰⵔ ⴷⴷ-ⵉⴼⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("K24_32","013_4_32","2KI","4","32","32","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵉⵍⵉⵛⴰⵄ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ ⵓⵃⴻⵏⵊⵉⵔ, ⵉⵎⵎⴰⵔⵙ ⵅ ⵇⴰⵎⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K24_33","013_4_33","2KI","4","33","33","ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ, ⵉⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K24_34","013_4_34","2KI","4","34","34","ⵅⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵇⴰⵎⴰ, ⵉⵡⴹⴰ ⵜⵉⵡⴰ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵏⴻⵜⵜⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⵓⵣⵣⴻⵍ ⴰⵎⵎⵓ ⵜⵉⵡⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵃⵎⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K24_35","013_4_35","2KI","4","35","35","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ, ⵢⵓⵢⵓⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵓⵛⴰ ⵉⵙⵙⴱⵓⵣⵣⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵏⵏⴻⵙ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵄⴹⴻⵙ ⵓⵃⴻⵏⵊⵉⵔ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⵓⵃⴻⵏⵊⵉⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K24_36","013_4_36","2KI","4","36","36","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵉ ⵊⵉⵃⴰⵣⵉ, ⵉⵏⵏⴰ: “ⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵜⵛⵓⵏⴰⵎⴻⵛⵜ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵏⴻⵜⵜⴰⵜ ⵖⴰⵔⴻⵙ, ⵓⵛⴰ ⵉⵏⵏⴰ ⵉⵍⵉⵛⴰⵄ: “ⴰⵔⴱⵓ ⵎⵎⵉⵎ!” ");
INSERT INTO rift_vpl VALUES ("K24_37","013_4_37","2KI","4","37","37","ⵜⵓⴷⴻⴼ ⵏⴻⵜⵜⴰⵜ ⴷⵉⵏ, ⵜⴻⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⴹⴰⵔ ⴰⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ. ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵎⵎⵉⵙ ⵓⵛⴰ ⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K24_38","013_4_38","2KI","4","38","38","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵉⵍⵉⵛⴰⵄ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⴻⵙ. ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: “ⴻⴳⴳ ⵎⴰⵔⵎⵉⵜⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⴻⴳⴳ ⵜⴰⵃⵔⵉⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K24_39","013_4_39","2KI","4","39","39","ⵅⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⴱⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵜⵉⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵢⵓⴼⴰ ⵉⵊⵊ ⵏ ⵡⴻⵣⴱⵉⵔ ⵏ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵉⵍⵇⴻⴹ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵍⴰⵎⵉ ⵉⵛⵛⵓⵔ ⵓⴱⴻⵃⵔⵓⵔ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵙ ⵜⴻⵅⵙⴰⵛⵜ ⵏ ⵍⴻⵅⵍⴰ. ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵓⵛⴰ ⵉⵇⴻⵙⵙ ⵉ-ⵜⴻⵏ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜ ⵙⵙⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K24_40","013_4_40","2KI","4","40","40","ⵅⴻⵏⵏⵉ ⴼⴰⵔⵖⴻⵏ ⴰⵢⴰ ⵉ ⵉⵔⵢⴰⵣⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ. ⵓⵎⵉ ⵇⵇⴰⵙⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵃⵔⵉⵔⵜ-ⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵍⴰⵖⴰⵏ: “ⴰ, ⵢⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵍⵎⴻⵡⵜ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K24_41","013_4_41","2KI","4","41","41","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⴷⵔⵓⵙ ⵏ ⵡⴰⵔⴻⵏ!” ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⵢⴻⵙ ⵉ-ⵜ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰ, ⵉⵏⵏⴰ: “ⴼⴰⵔⵖⴻⵎ ⴰⵢⴰ ⵉ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ!” ⵅⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵛⴰ ⵡⴰⵔ ⵉⵃⵍⵉ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K24_42","013_4_42","2KI","4","42","42","ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⴱⴰⵄⵍ-ⵛⴰⵍⵉⵛⴰ, ⵢⵉⵡⵉ-ⴷⴷ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵖⵔⵓⵎ ⵣⵉ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵎⴻⵏⵣⵓⵜ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⵔⵓⵎⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⵍⵃⴻⴱⴱ ⵉⴱⴰⵔⵢⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵢⴰⵔⵜ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴻⵡⵛ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("K24_43","013_4_43","2KI","4","43","43","ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵜ ⵉ ⵖⴰ ⵙⵙⴰⵔⵙⴻⵖ ⵉ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ?” ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵉⵏⵏⴰ: “ⴻⵡⵛ ⵉ-ⵜ ⵉ ⵍⴳⴻⵏⵙ ⴰⴷ ⵜ ⵢⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⴷ ⵛⵛⴻⵏ ⵓ ⵄⴰⴷ ⴰⴷ ⵉⵛⴻⵟⵟ’.” ");
INSERT INTO rift_vpl VALUES ("K24_44","013_4_44","2KI","4","44","44","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵙⴻⵏ ⵜ ⵓⵛⴰ ⵛⵛⵉⵏ ⵏⵉⵜⵏⵉ, ⵓ ⵉⵛⴻⵟⵟ ⵅⴰⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K25_1","013_5_1","2KI","5","1","1","ⵏⵓⵄⵎⴰⵏ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⵙⵙⵓⵎⵄⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ ⵓ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵛⵛⴰⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉ ⵢⵉⵡⵉ ⵙⵉⴷⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⴰⵔⴰⵎ. ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("K25_2","013_5_2","2KI","5","2","2","ⵜⵓⵖⴰ ⴷⵉⵏ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵣⵉ ⴰⵔⴰⵎ, ⵉⵡⵢⴻⵏⵜ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⵎⴻⵃⴱⵓⵙⵜ. ⵜⵓⵖⴰ-ⵜⵜ ⵜⵅⴻⴷⴷⴻⵎ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵏⵓⵄⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K25_3","013_5_3","2KI","5","3","3","ⵜⴻⵏⵏⴰ ⵉ ⵍⴰⵍⵍⴰⵙ: “ⵎⵍⵉ ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵣⵉ ⵍⴱⴰⵔⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K25_4","013_5_4","2KI","5","4","4","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵡⴰⵏⵉⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵃⴰⵊⴰ ⵉ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⴷ ⵡⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵜⴻⴱⵍⵉⵖⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("K25_5","013_5_5","2KI","5","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ: “ⵓⵢⵓⵔ ⴷⵉⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ.” ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵉⴽⵙⵉ ⵄⴻⵛⵔⴰ ⵜⴰⵍⵉⵏⵜⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K25_6","013_5_6","2KI","5","6","6","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵜⴰⴱⵔⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵢⵓⵔⴰ: “ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⴻⴱⵔⴰⵜ-ⴰ ⵖⴰⵔⴻⴽ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵄⴰⵡⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵏⵓⵄⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵙⵙⴳⴻⵏⴼⵉⴷ ⵣⵉ ⵍⴱⴰⵔⵚ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K25_7","013_5_7","2KI","5","7","7","ⵓⵎⵉ ⵉⵖⵔⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴰⴱⵔⴰⵜ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵍⴰⵖⴰ: “ⵏⴻⵛⵛ ⵎⴰⵖⴰⵔ ⵎⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⴻⴷⴷⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵖⴰⵔⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵣⵉ ⵍⴱⴰⵔⵚ ⵏⵏⴻⵙ? ⵉⵡⴰ, ⵙⵙⵏⴻⵎ, ⵓ ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⵢⵉ ⵍⴻⵙⴱⴰⴱ ⵡⴰⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("K25_8","013_5_8","2KI","5","8","8","ⵓⵎⵉ ⵉⵙⵍⴰ ⵉⵍⵉⵛⴰⵄ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴻⵍⵍⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵛⴰⵔⵔⴳⴻⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("K25_9","013_5_9","2KI","5","9","9","ⴰⵎⵎⵓ ⴷⴷ-ⵢⵓⵙⴰ ⵏⵓⵄⵎⴰⵏ ⴰⴽ-ⴷ ⵉⵢⵙⴰⵏ ⴷ ⵓⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵍⵉⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("K25_10","013_5_10","2KI","5","10","10","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵍⵉⵛⴰⵄ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔⴻⵙ, ⵉⵇⵇⴰⵔ: “ⵓⵢⵓⵔ ⵓ ⵙⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⵉ ⵍ’ⵓⵔⴷⵓⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵜⴻⴳⴳⴻⵏⴼⴰ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵣⴷⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("K25_11","013_5_11","2KI","5","11","11","ⵉⴼⴼⵓⴳⴻⵎ ⵏⵓⵄⵎⴰⵏ, ⵓⵛⴰ ⵢⵓⵢⵓⵔ, ⵉⵇⵇⴰⵔ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵉⵅⴻⴼ ⵉⵏⵓ: ‘ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵎⵛⴰⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵍⴱⴰⵔⵚ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴳⴳⴻⵏⴼⴰ ⵍⴱⴰⵔⵚ.’ ");
INSERT INTO rift_vpl VALUES ("K25_12","013_5_12","2KI","5","12","12","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⴱⴰⵏⴰ ⴷ ⴼⴰⵔⴼⴰⵔ, ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⴷⵉⵎⴰⵛⵇ, ⵃⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ⵎⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⵉⵏⵏⵉ ⵙⵙⵉⵔⴷⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⴷⴳⴻⵖ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⵛⴰ ⵢⵓⵢⵓⵔ, ⵉⵙⵄⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K25_13","013_5_13","2KI","5","13","13","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⴱⴰⴱⴰ, ⵎⵍⵉ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵉⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵛⴰ ⵎⵉⵏ ⵉⵡⵄⴰⵔⴻⵏ, ⵉⵍⵉ ⵜⴻⴳⴳⵉⴷ ⵜ? ⵉ ⵎⴰⵍⴰ ⵉⵏⵏⴰ ⵅⴰⴽ ⵄⴰⴷ: ‘ⵙⵉⵔⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⵛⴻⴽ ⵜⵉⵣⴷⵉⴳⴻⴷ?’” ");
INSERT INTO rift_vpl VALUES ("K25_14","013_5_14","2KI","5","14","14","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵖⴹⴻⵚ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⵉ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵡⴰⵡⴰⵍ ⵏ ⵓⵏⴰⴱⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⴳⴳⴻⵏⴼⴰ ⴰⵎ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵓ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("K25_15","013_5_15","2KI","5","15","15","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⴷⵉⵏ, ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵏⵉ ⵎⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵎⵖⵉⵔ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵀⴰ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵄⴰⴼⴻⴽ, ⴽⵙⵉ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵣⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("K25_16","013_5_16","2KI","5","16","16","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵖ ⵡⴰⵍⵓ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("K25_17","013_5_17","2KI","5","17","17","ⵉⵏⵏⴰ ⵏⵓⵄⵎⴰⵏ: “ⵎⴰⵍⴰ ⵍⵍⴰ, ⵉⵍⵉ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ ⵏ ⵓⵛⴰⵍ, ⴰⵏⴻⵛⵜ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵔⴷⴰⵏ ⴰⴷ ⴰⵔⴱⵓⵏ, ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵉⵡⵉ ⵄⴰⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵎⵖⵉⵔ ⵉ ⵙⵉⴷⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("K25_18","013_5_18","2KI","5","18","18","ⵎⴰⵛⴰ ⵉⵍⵉ ⴰⴷ ⵉⵖⴼⴰⵔ ⵙⵉⴷⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵜⴰ ⵡⴰⵀⴰ, ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵔⵉⵎⵎⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴻⵏⴷⴻⵇ ⴰⵎ ⵉⵜⵜⵄⴻⵎⵎⴻⴷ ⴷⵉⵏⵏⵉ ⵅ ⵓⵖⵉⵍ ⵉⵏⵓ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⴻⵏⴷⵇⴻⵖ ⴰⵎⵎⵓ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵔⵉⵎⵎⵓⵏ. ⵎⴰⵍⴰ ⴰⴷ ⴱⴻⵏⴷⵇⴻⵖ ⴰⵎⵎⵓ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵔⵉⵎⵎⵓⵏ, ⵉⵍⵉ ⴰⴷ ⵉⵖⴼⴰⵔ ⵙⵉⴷⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K25_19","013_5_19","2KI","5","19","19","ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵀⵏⴰ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⴰⴼⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ, ⵉⴳⴳⵯⴻⵊ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K25_20","013_5_20","2KI","5","20","20","ⵉⵏⵏⴰ ⵊⵉⵃⴰⵣⵉ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⵍⵉⵛⴰⵄ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ: “ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵙⵙⵄⵉⵣⵣ ⵅ ⵏⴰⵄⵎⴰⵏ, ⴰⵔⴰⵎⵉⵢⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵣⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉ ⴷⴷ-ⵢⵉⵡⵉ ⵏⴻⵜⵜⴰ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴰⵔⴻⴷⴷⴼⴻⵖ ⴷⴻⵖⵢⴰ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴽⵙⵉⵖ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("K25_21","013_5_21","2KI","5","21","21","ⵊⵉⵃⴰⵣⵉ ⵢⵓⵢⵓⵔ, ⵢⴰⵔⴷⴻⴼ ⵏⵓⵄⵎⴰⵏ. ⵓⵎⵉ ⵏⵓⵄⵎⴰⵏ ⵉⵥⵔⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵣⵣⴻⵍ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵉⴹⵔⴰ-ⴷⴷ ⵣⴻⴳ ⵓⴽⴰⵔⵔⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵙⴰⴳⴰⵔ, ⵉⵏⵏⴰ: “ⵎⵍⵉⵃ?” ");
INSERT INTO rift_vpl VALUES ("K25_22","013_5_22","2KI","5","22","22","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⵍⵉⵃ. ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵇⴰ, ⵖⴰⵔ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵓⵙⵉⵏ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ⴻⵡⵛ ⴰⵙⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵜⵢⵓⵢⴰ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("K25_23","013_5_23","2KI","5","23","23","ⵉⵏⵏⴰ ⵏⵓⵄⵎⴰⵏ: “ⵄⴰⴼⴰⴽ, ⴽⵙⵉ ⵣⵣⴰⵢⵉ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ⵏⴻⵜⵜⴰ ⵉⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ ⵓ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵛⵢⴰⵔⵉⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵢⴰⵔⴱⵓⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K25_24","013_5_24","2KI","5","24","24","ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ, ⵉⴽⵙⵉ ⵜⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵓⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ⵉⵊⵊⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K25_25","013_5_25","2KI","5","25","25","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⴷⴻⴼ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ. ⵉⵍⵉⵛⴰⵄ ⵉⵙⵙⴻⵇⵙⴰ ⵜ: “ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⵉⴷ, ⴰ ⵊⵉⵃⴰⵣⵉ?” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ ⵛⴰ ⵎⴰⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("K25_26","013_5_26","2KI","5","26","26","ⵎⴰⵛⴰ ⵉⵍⵉⵛⴰⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵓⵍ ⵉⵏⵓ ⴷⵉⵏ ⵉⵃⴹⴰⵔ ⵓⵎⵉ ⴷⴷ-ⵉⴹⵔⴰ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⵓⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⴽ? ⵎⴰⵖⴰⵔ ⵎⴰ ⴷ ⵍⵃⴰⵍ ⴰⴷ ⵜⵎⴻⵏⵄⴻⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⴰⵔⵔⵓⴹ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴷ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("K25_27","013_5_27","2KI","5","27","27","ⵍⴱⴰⵔⵚ ⵏ ⵏⵓⵄⵎⴰⵏ ⴰⴷ ⵉⵍⵙⴻⵇ ⵉ ⵍⴻⴱⴷⴰ ⴷⴰⵢⴻⴽ ⵓ ⴷⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ!” ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵙ ⵍⴱⴰⵔⵚ, ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴰⵎ ⵡⴻⴷⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K26_1","013_6_1","2KI","6","1","1","ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ ⵉ ⵉⵍⵉⵛⴰⵄ: “ⵅⵣⴰⵔ, ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵏⵣⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵉⵃⵚⴰⵔ ⵉ ⵏⴻⵛⵛⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("K26_2","013_6_2","2KI","6","2","2","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ ⵓ ⴷⵉⵏⵏⵉ ⵇⴰⵄ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴳⴳ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵏⴻⵛⵛⵉⵏ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵓⵢⵓⵔⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("K26_3","013_6_3","2KI","6","3","3","ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵎⴰⵛⴰ ⵉⵏⵏⴰ: “ⵄⴰⴼⴰⴽ, ⵓⵢⵓⵔ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵢⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("K26_4","013_6_4","2KI","6","4","4","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ. ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⴻⴷⵎⴻⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K26_5","013_6_5","2KI","6","5","5","ⵍⴰⵎⵉ ⵉⵣⴷⴻⵎ ⵉⵊⵊ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⴻⵇⴹⴻⵄ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵛⵛⴰⵇⵓⵔ ⵉⵡⴹⴰ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵛⵛⴰⵇⵓⵔ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵔⴹⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("K26_6","013_6_6","2KI","6","6","6","ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵉⵡⴹⴰ?” ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵙⵙⵛⴻⵏ ⴰⵎⵛⴰⵏ, ⵉⵇⴻⵙⵙ ⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⴷⵉⵏ ⵓ ⴰⵎⵎⵓ ⵢⵉⵡⵉ-ⴷⴷ ⵓⵣⵣⴰⵍ ⵉⴳⴳⵓⵔ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("K26_7","013_6_7","2KI","6","7","7","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⴽ!” ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("K26_8","013_6_8","2KI","6","8","8","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⵉⵏ ⴷ ⵡⵉⵏ ⴰⴷ ⵡⵜⴻⵖ ⵉⵇⵉⴹⴰⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K26_9","013_6_9","2KI","6","9","9","ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⴽⴽⴻⴷ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⴷⵉⵏ ⵀⵡⴰⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("K26_10","013_6_10","2KI","6","10","10","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵅ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵄⵍⴻⵎ ⵡⴰⵏⵉⵜⴰ, ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⴷ ⵃⴹⴰⵏ ⴷⵉⵏ. ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵛⴰ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("K26_11","013_6_11","2KI","6","11","11","ⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵉⵀⴰⵊ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵏⵉⵎ ⵎⴰⵏ ⵡⴻⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⵉⵜⵜⵔⴰⵃ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("K26_12","013_6_12","2KI","6","12","12","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⴰ: “ⵍⵍⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ! ⵎⴰⵛⴰ ⵉⵍⵉⵛⴰⵄ, ⴰⵏⴰⴱⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵉⵙⵙⴰⵔⴳⴻⴱ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵡⴰⵍⴻⵏ ⵉ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵛ ⵏ ⵢⵉⴹⴻⵚ.” ");
INSERT INTO rift_vpl VALUES ("K26_13","013_6_13","2KI","6","13","13","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵓⵢⵓⵔⴻⵎ ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ ⵎⴰⵏⵉ ⵉⵜⵜⵉⵍⵉ ⵏⴻⵜⵜⴰ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ.” ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜ, ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⴷⵓⵜⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K26_14","013_6_14","2KI","6","14","14","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⴷⵉⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵏⵏⴹⴻⵏ-ⴷⴷ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K26_15","013_6_15","2KI","6","15","15","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴽⴽⴰⵔ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵜⵓⵖⴰ ⵉⵏⵏⴻⴹ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵢⴻⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⴰⵃⵓⴷⵔⵉ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ?” ");
INSERT INTO rift_vpl VALUES ("K26_16","013_6_16","2KI","6","16","16","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵅ ⵢⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K26_17","013_6_17","2KI","6","17","17","ⵉⵍⵉⵛⴰⵄ ⵉⵥⵥⵓⴵ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⴰⵔⵣⴻⵎ ⴰⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⴰⵔ!” ⵓ ⵙⵉⴷⵉ ⵢⴰⵔⵣⴻⵎ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴰⵍⴰⵎⵉ ⵉⵜⵡⴰⵍⴰ. ⵓ ⵅⵣⴰⵔ, ⴰⴷⵔⴰⵔ ⵉⵛⵛⵓⵔ ⵙ ⵢⴻⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵉⵍⵉⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("K26_18","013_6_18","2KI","6","18","18","ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ, ⵉⵥⵥⵓⴵ ⵉⵍⵉⵛⴰⵄ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵡⵡⴻⵜ ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵙ ⵜⵓⴷⴷⴰⵔⵖⴻⵍⵜ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵜⴻⵏ ⵙ ⵜⵓⴷⴷⴰⵔⵖⴻⵍⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵉⵍⵉⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("K26_19","013_6_19","2KI","6","19","19","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵍⵉⵛⴰⵄ: “ⵡⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⴱⵔⵉⴷ ⵏⵉⵛⴰⵏ ⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵉⵛⴰⵏ. ⴹⴼⴰⵔⴻⵎ ⴰⵢⵉ-ⴷⴷ! ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴻⴷⵀⴻⵖ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵅ ⵜⴰⵔⴻⵣⵣⵓⵎ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K26_20","013_6_20","2KI","6","20","20","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵍⵉⵛⴰⵄ ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵏ!”. ⵓⵛⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵙⴻⵏ ⵙⵉⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴰⵍⴰⵎⵉ ⵥⵔⵉⵏ. ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K26_21","013_6_21","2KI","6","21","21","ⵓⵎⵉ ⵜⴻⵏ ⵉⵥⵔⴰ, ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵉⵍⵉⵛⴰⵄ: “ⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵖ, ⴰ ⴱⴰⴱⴰ?” ");
INSERT INTO rift_vpl VALUES ("K26_22","013_6_22","2KI","6","22","22","ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵇⵇ ⵛⴰ! ⵛⴻⴽ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⴰ ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵉⵏⵏⵉ ⵜⵃⴻⴱⴱⵙⴻⴷ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵛ ⴷ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ? ⵙⴰⵔⵙ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵖⵔⵓⵎ ⴷ ⵡⴰⵎⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⵛⴻⵏ ⴰⴷ ⵙⵡⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K26_23","013_6_23","2KI","6","23","23","ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵙⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ, ⵙⵡⵉⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵢⴰⵔⵅⵓ ⴰⵙⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏⵜ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⴰⵔⴰⵎ ⵄⴰⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K26_24","013_6_24","2KI","6","24","24","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵉⴼⴼⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵏⴻⴹ ⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K26_25","013_6_25","2KI","6","25","25","ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵍⴰⵥ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵊⵊ ⵡⴻⵖⵢⵓⵍ ⵉⵙⴻⴽⴽⵡⴰ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵢⵉⵊⵊ ⵏ ⴰⵔⵔⴱⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵍⴻⵇⵢⴰⵙ ⵙ ⵍⴻⵖⴱⴰⵔ ⵏ ⵡⴻⴷⴱⵉⵔ ⵉⴷⵡⴻⵍ ⵉⵙⴻⴽⴽⵡⴰ ⵅⴻⵎⵙⴰ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K26_26","013_6_26","2KI","6","26","26","ⵓⵎⵉ ⵉⵄⴷⵓ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵍⵃⵉⴹ, ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⵜⵍⴰⵖⴰ ⴰⵙ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⴻⵏⵏⴰ: “ⴻⵡⵛ ⴰⵢⵉ-ⴷⴷ ⴰⴼⵓⵙ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("K26_27","013_6_27","2KI","6","27","27","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵎ ⵉⵡⵛⵉ ⴰⴼⵓⵙ, ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⴷ ⴰⵎ ⵖⴰ ⵡⵛⴻⵖ ⴰⴼⵓⵙ? ⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵛⴰ ⵣⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ ⵏⵉⵖ ⵣⵉ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("K26_28","013_6_28","2KI","6","28","28","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⵉⵏ ⵛⴻⴽ ⵢⵓⵖⵉⵏ?” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⵜⴻⵏⵏⴰ ⴰⵢⵉ: ‘ⴰⵡⵉ-ⴷⴷ ⵎⵎⵉⵎ, ⵃⵉⵎⴰ ⴰⵙⵙ-ⴰ ⴰⴷ ⵜ ⵏⴻⵛⵛ ⵓ ⵎⵎⵉ ⴰⴷ ⵜ ⵏⴻⵛⵛ ⵅⴻⵏⵏⵉ ⵜⵉⵡⴻⵛⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("K26_29","013_6_29","2KI","6","29","29","ⴰⵎⵎⵓ ⵏⴻⵛⵛⵉⵏ ⵏᵉⵙⵙⵏⴻⵏⵏⴰ ⵎⵎⵉ ⵓⵛⴰ ⵏⴻⵛⵛⴰ ⵉ-ⵜ. ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵏⵏⵉⵖ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ: ‘ⴻⵡⵛ ⵍⴻⵅⵅⵓ ⵎⵎⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴻⵛⵛ!’, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵎⵎⵉⵙ.” ");
INSERT INTO rift_vpl VALUES ("K26_30","013_6_30","2KI","6","30","30","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵢⵓⵢⵓⵔ ⵅ ⵍⵃⵉⴹ ⵓⵛⴰ ⵉⵥⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵍⵍⴰ ⴰⵇⴰ ⵢⴰⵔⴹ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K26_31","013_6_31","2KI","6","31","31","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⴰⵔⴻⴱⴱⵉ ⵜⴰ ⴷ ⵜⴰ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ, ⵎⴰⵍⴰ ⵉⵇⵇⵉⵎ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵍⵉⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵜ, ⵅⴰⵙ ⴰⵍ ⴰⵙⵙ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("K26_32","013_6_32","2KI","6","32","32","ⵉⵍⵉⵛⴰⵄ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔⴻⵙ. ⵜⵓⵖⴰ ⵓⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵇⴱⴻⵍ ⵎⴰ ⵢⵉⵡⴻⴹ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⵉⵍⵉⵛⴰⵄ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ: “ⵎⴰ ⵜⴻⵥⵔⵉⵎ ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵇⴻⵜⵜⴰⵍ, ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵇⴻⵙⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ? ⵃⴹⴰⵎ ⵍⴻⵅⵅⵓ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵔⴻⵇⵇⴰⵙ, ⴱⴻⵍⵍⵄⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ ⵓ ⵙⴱⴻⴷⴷⴻⵎ ⵜ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ! ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵏ ⵉⵚⵓⵔⴰⴼ ⵏ ⵙⵉⴷⵉⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("K26_33","013_6_33","2KI","6","33","33","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ, ⵅⵣⴰⵔ, ⵉⵀⵡⴰ-ⴷⴷ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔⴻⵙ. ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵜⵓⵄⴻⴼⴼⵏⴰ-ⵢⴰ ⵣⵉ ⵙⵉⴷⵉ. ⵎⵉⵏ ⵖⴰ ⵔⴰⵊⵉⵖ ⵄⴰⴷ ⵅⴻⵏⵏⵉ ⵣⵉ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("K27_1","013_7_1","2KI","7","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵍⵉⵛⴰⵄ: “ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ! ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ ⴰⴷ ⵜⴻⵙⵡⴰ ⵉⵊⵊ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ ⵓ ⴰⴷ ⵎⵎⴻⵏⵣⴻⵏ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵉⵎⴻⵏⴷⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ ⵡⴰⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("K27_2","013_7_2","2KI","7","2","2","ⵉⵊⵊ ⵏ ⵓⵏⴻⵖⵔⴰⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵡⴻⵏⵏⵉ ⵅ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵉⵄⴻⵎⵎⴻⴷ ⵓⵊⴻⴵⵉⴷ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ: “ⵅⵣⴰⵔ, ⵡⴰⵅⵅⴰ ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵍⴻⴽⵡⴰⵣⴰ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⵢⴰ ⴰⴷ ⵉⵎⵙⴰⵔ?” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⴻⵜⵜⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("K27_3","013_7_3","2KI","7","3","3","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ⵏⵏⴰⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵏⴻⵇⵇⵉⵎ ⴷⴰ ⴰⵍ ⵖⴰ ⵏⴻⵎⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("K27_4","013_7_4","2KI","7","4","4","ⵎⴰⵍⴰ ⴰⴷ ⵏⵉⵏⵉ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ!’, ⵅⴻⵏⵏⵉ ⵉⴵⴰ ⵍⴰⵥ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴻⵎⵎⴻⵜ. ⵓ ⵎⴰⵍⴰ ⵏⴻⵇⵇⵉⵎ ⵏⴻⵛⵛⵉⵏ ⴷⴰ, ⴰⴷ ⵏⴻⵎⵎⴻⵜ ⵄⴰⵡⴻⴷ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⴰⴷ ⵏⴻⵡⴹⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ. ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⴰⵏⴻⵖ ⵏⴻⴷⴷⴰⵔ, ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏⴻⴷⴷⴰⵔ, ⵓ ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⴰⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵎⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("K27_5","013_7_5","2KI","7","5","5","ⵏⵉⵜⵏⵉ ⴽⴽⴰⵔⴻⵏ ⴷⵉ ⵜⴱⴰⵎⴱⴰⵙⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ. ⵎⴰⵛⴰ ⵓⵎⵉ ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ, ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K27_6","013_7_6","2KI","7","6","6","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵊⵊⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵊⴰⵔⵔⵉ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⴷⴷⵔⵉⵣ ⵏ ⵉⵢⵙⴰⵏ ⴷ ⴵⵖⴰ ⵏ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵛⵔⴰ ⴷ ⵉⵃⴰⵔⵔⴻⵛ-ⴷⴷ ⵅⴰⵏⴻⵖ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ.”    ");
INSERT INTO rift_vpl VALUES ("K27_7","013_7_7","2KI","7","7","7","ⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⴷⵉ ⵜⴱⴰⵎⴱⴰⵙⵜ ⵓⵛⴰ ⵊⵊⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷ ⵢⴻⵢⵙⴰⵏ ⵏⵙⴻⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵜⵓⵖⴰ, ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K27_8","013_7_8","2KI","7","8","8","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴱⴰⵔⵚ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ, ⵛⵛⵉⵏ, ⵙⵡⵉⵏ ⵓ ⵉⵡⵢⴻⵏ ⵙⵙⴻⵏⵏⵉ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵔⵔⵓⴹⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⴰⵢⴰ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵓⵍⴰ ⵙⵙⴻⵏⵏⵉ ⵛⴰ, ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("K27_9","013_7_9","2KI","7","9","9","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ. ⴰⵙⵙ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵖⴷ. ⵎⴰⵍⴰ ⵏⵔⴰⵊⴰ ⴷⴰ ⴰⵍ ⵉ ⵖⴰ ⵉⴼⴼⵓ ⵍⵃⴰⵍ, ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵍⵇⴻⴼ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ, ⴰⴷ ⵜ ⵏⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("K27_10","013_7_10","2KI","7","10","10","ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ ⴷⵉⵏ, ⵍⴰⵖⴰⵏ ⵅ ⵓⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵃⴰⵊⴰⵏ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⵓⴷⴻⴼ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ, ⵓ ⵅⵣⴰⵔ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵡⴰⵔ ⵏⴻⵙⵍⵉ ⵉ ⵛⴰ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵢⴻⵡⴷⴰⵏ, ⵎⵖⵉⵔ ⵉⵢⵙⴰⵏ ⵜⵓⵖⴰ ⵇⵇⵏⴻⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⵜⵓⵖⴰ ⵛⴰⵔⴼⴻⵏ, ⴷ ⵉⵇⵉⴹⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K27_11","013_7_11","2KI","7","11","11","ⵉⵍⴰⵖⴰ ⵅ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⵙⵙⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K27_12","013_7_12","2KI","7","12","12","ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵎⵉⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴰⵔⴰⵎ. ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⴵⵓⵥ. ⵅ ⵓⵢⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜⴻⵏ ⵏⴻⵟⵟⴻⴼ ⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ.’” ");
INSERT INTO rift_vpl VALUES ("K27_13","013_7_13","2KI","7","13","13","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⵉⵔⵢⴰⵣⴻⵏ ⴰⴷ ⴽⵙⵉⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵢⵙⴰⵏ ⵏⵏⵉ ⵄⴰⴷ ⴷⵉⵏ ⵉⴵⴰⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵥⴰⵔ ⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴰⵔ ⴰⵎ ⵡⴰⵟⵟⴰⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⴷⴰ ⵉⵇⵇⵉⵎⴻⵏ, ⵏⵉⵖ ⴰⵎ ⵡⴰⵟⵟⴰⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⴻⴽⴽ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵥⴰⵔ ⵎⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("K27_14","013_7_14","2KI","7","14","14","ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵏ ⵜⴰⵣⵍⴰ. ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔⴻⵎ, ⵜⴻⵅⵣⴰⵔⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("K27_15","013_7_15","2KI","7","15","15","ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⴰⵍ ⵍ’ⵓⵔⴷⵓⵏ, ⵓ ⵅⵣⴰⵔ, ⴰⴱⵔⵉⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵜⵉ ⵙ ⵡⴰⵔⵔⵓⴹ ⴷ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏⵏⵉ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵏⵙⴻⵏ. ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵄⴻⵇⴱⴻⵏ ⵓ ⵙⵙⵉⵡⴹⴻⵏ ⵍⴻⵅⴱⴰⵔ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K27_16","013_7_16","2KI","7","16","16","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⴽⴻⵛⵛⴹⴻⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ ⵓⵛⴰ ⵜⴻⵎⵎⴻⵏⵣ ⵉⵊⵊ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵉⵎⴻⵏⴷⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K27_17","013_7_17","2KI","7","17","17","ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵏⴻⵖⵔⴰⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵡⴻⵏⵏⵉ ⵅ ⵉⵜⵜⵛⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵜⴻⵡⵡⴰⵔⵜ, ⵎⴰⵛⴰ ⵉⵄⴼⴻⵙ ⵅⴰⵙ ⵍⴳⴻⵏⵙ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵀⵡⴰ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K27_18","013_7_18","2KI","7","18","18","ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉ ⵉⵏⵏⴰⵏ: “ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ ⴰⴷ ⵎⵎⴻⵏⵣⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵉⵎⴻⵏⴷⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ ⴷ ⵢⵉⵊⵊ ⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵛⵉⵇⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("K27_19","013_7_19","2KI","7","19","19","ⵜⵓⵖⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵏⴻⵖⵔⴰⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵡⴰⵅⵅⴰ ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵍⴻⴽⵡⴰⵣⴰ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵙⴰⵔ ⵓⵢⴰ?” ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜᵉⵜⵜⴻⵜⵜⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("K27_20","013_7_20","2KI","7","20","20","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙ ⵜⴻⵎⵙⴰⵔ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵄⴼⴻⵙ ⵅⴰⵙ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ. ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K28_1","013_8_1","2KI","8","1","1","ⵍⴰⵎⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵍⵉⵛⴰⵄ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴼⴰⵇ ⵎⵎⵉⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⴼⴼⴻⵖ, ⵛⴻⵎ ⴰⴽ-ⴷ ⵜⵡⴰⵛⵓⵏⵜ ⵏⵏⴻⵎ ⵓ ⵣⴷⴻⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴱⴰⵔⵔⴰⵏⴻⵛⵜ ⵎⴰⵏⵉ ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵢⵓⵔⴰ ⵉⵛⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵍⴰⵥ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⴽⴽⴻⵏ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K28_2","013_8_2","2KI","8","2","2","ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⴻⴳⴳⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵜⵡⴰⵛⵓⵏⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵣⴷⴻⵖ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K28_3","013_8_3","2KI","8","3","3","ⴰⵡⴰⵔⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴼⴼⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⴰⵔ ⵜⵡⵉⵣⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K28_4","013_8_4","2KI","8","4","4","ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵜⵜⵃⴰⵔⵔⴻⴹ ⴰⴽ-ⴷ ⵊⵉⵃⴰⵣⵉ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⵃⴰⵊⴰ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵉⴳⴳⴰ ⵉⵍⵉⵛⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("K28_5","013_8_5","2KI","8","5","5","ⵉⵎⵙⴰⵔ ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴰⵡⴰⴷ ⵡⴰⵏⵉⵜⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵙⵙⴼⴰⵇ ⵉⵍⵉⵛⴰⵄ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⵅⵣⴰⵔ, ⵜⵓⵙⴰ-ⴷⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵉⵙⵙⴼⴰⵇ ⵎⵎⵉⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⴰⵔ ⵜⵡⵉⵣⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵊⵉⵃⴰⵣⵉ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵜⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⴷ ⵡⴰ ⴷ ⵎⵎⵉⵙ ⵉ ⴷⴷ-ⵉⵙⵙⴼⴰⵇ ⵉⵍⵉⵛⴰⵄ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K28_6","013_8_6","2KI","8","6","6","ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵃⴰⵊⴰ ⴰⵙ ⵜⵜ-ⵉ-ⴷⴷ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ, ⵉⵏⵏⴰ: “ⵃⴹⴰⵜ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵡⴰⵔⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵚⵚⴰⴱⴻⵜ ⵏ ⵉⵢⵢⴰⵔ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⵊⵊⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵍ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("K28_7","013_8_7","2KI","8","7","7","ⵉⵍⵉⵛⴰⵄ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ ⵓⵎⵉ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵀⵍⴻⵛ. ⵃⴰⵊⴰⵏ ⴰⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("K28_8","013_8_8","2KI","8","8","8","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵃⴰⵣⴰⵢⵉⵍ: “ⴰⵡⵉ-ⴷⴷ ⴰⴽⵉⴷⴻⴽ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ, ⵔⵓⵃ ⴰⴷ ⵜⴻⵍⵇⵉⴷ ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵙⴻⵇⵙⴰ ⵣⵣⴰⵢⴻⵙ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵉⵏⵉⴷ: “ⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵏⴼⵉⵖ ⵣⵉ ⵍⴻⵀⵍⴰⵛ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("K28_9","013_8_9","2KI","8","9","9","ⵃⴰⵣⴰⵢⵉⵍ ⵢⵓⵢⵓⵔ ⴰⴷ ⵜ ⵉⵍⵇⴰ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ, ⵄⵍⴰⵎ ⴽⵓⵍ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⵣⵉ ⴷⵉⵎⴰⵛⵇ, ⵉⵊⵊ ⵏ ⴷⴷⵇⴻⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵍⴻⵖⵎⴰⵏ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⴻⴹ ⵓ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⵙ, ⵉⵏⵏⴰ: “ⵎⵎⵉⵛ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵇⵙⵉⵖ: ‘ⵎⴰ ⴰⴷ ⴳⴳⴻⵏⴼⵉⵖ ⵣⵉ ⵍⴻⵀⵍⴰⵛ-ⴰ?’” ");
INSERT INTO rift_vpl VALUES ("K28_10","013_8_10","2KI","8","10","10","ⵉⵏⵏⴰ ⴰⵙ ⵉⵍⵉⵛⴰⵄ: “ⵓⵢⵓⵔ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ ⵛⴰ ⴽⵓⵍⵛⵉ!’ ⵙⵉⴷⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵏⵉⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K28_11","013_8_11","2KI","8","11","11","ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵉⴱⵄⴰⵔ ⵓ ⵉⵙⵙⴻⵇⵙⴻⵃ ⴷⴰⵢⴻⵙ ⵜⴰⵎⵓⵖⵍⵉ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ. ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K28_12","013_8_12","2KI","8","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵃⴰⵣⴰⵢⵉⵍ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⵔⵓ ⵙⵉⴷⵉ ⵉⵏⵓ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵃⵍⵉⵇ ⵉ ⴷ ⵖⴰ ⵜⴰⵡⵢⴻⴷ ⵛⴻⴽ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵛⴻⴽ ⴰⴷ ⵜⴻⵇⵇⴷⴻⴷ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵜⴻⵏⵖⴻⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⵙ ⵙⵙⵉⴼ, ⴰⴷ ⵜⵍⴻⴱⵣⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵉ ⵉⴽⵙⵉⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴰⴷ ⴰⵙⴻⵏⵜ ⵜⵛⴰⵔⵔⴳⴻⴷ ⴰⵄⴻⴷⴷⵉⵙ.” ");
INSERT INTO rift_vpl VALUES ("K28_13","013_8_13","2KI","8","13","13","ⵃⴰⵣⴰⵢⵉⵍ ⵉⵏⵏⴰ: “ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵄⵏⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⵇⵣⵉⵏ ⵏⵏⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵎ ⵜⴰⵏⵉⵜⴰ?” ⵉⵍⵉⵛⴰⵄ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ-ⴷⴷ ⴱⴻⵍⵍⵉ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⴰⵔⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("K28_14","013_8_14","2KI","8","14","14","ⵅⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⵊ ⵏⴻⵜⵜⴰ ⵅ ⵉⵍⵉⵛⴰⵄ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉⵙ. ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵏⵏⴰ ⵉⵍⵉⵛⴰⵄ?” ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ!’” ");
INSERT INTO rift_vpl VALUES ("K28_15","013_8_15","2KI","8","15","15","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵉⵛⵜ ⵏ ⵎⴰⵍⵜⴰ, ⵉⵙⵙⴻⵖⴹⴻⵚ ⵉ-ⵜⵜ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵃⴰⵣⴰⵢⵉⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K28_16","013_8_16","2KI","8","16","16","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵢⴰⵀⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K28_17","013_8_17","2KI","8","17","17","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K28_18","013_8_18","2KI","8","18","18","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⵢⴻⴵⵉⵙ ⵏ ⴰⵅⴰⴱ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K28_19","013_8_19","2KI","8","19","19","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⴰⵡⵓⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⵉⵏⵏⴰ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵍⴻⴱⴷⴰ ⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K28_20","013_8_20","2KI","8","20","20","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⵣⴻⵎⵎⴰⵔ ⵉⴷⵓⵎ ⴰⴷ ⵉⵅⵜⵓⵜⵜⴻⵍ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵎⵉ ⵖⴻⵡⵡⵖⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K28_21","013_8_21","2KI","8","21","21","ⵅⴰⵙ ⵓⵛⴰ ⵉⵄⴷⵓ ⵢⴰⵀⵓⵔⴰⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵚⴰⵄⵉⵔ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⴽⴽⴰⵔ ⵙ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵉⵀⵊⴻⵎ ⵅ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K28_22","013_8_22","2KI","8","22","22","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵅⵜⵓⵜⵜⵍⴻⵏ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⵙ ⵓⵖⴻⵡⵡⴻⵖ ⵣⵉ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴱⴻⵄⴷⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵓⵍⴰ ⴷ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K28_23","013_8_23","2KI","8","23","23","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⵔⴰⵎ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K28_24","013_8_24","2KI","8","24","24","ⵢⴰⵀⵓⵔⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ, ⴰⵅⴰⵣⵢⴰ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K28_25","013_8_25","2KI","8","25","25","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴱⴷⴰ ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵉⵃⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("K28_26","013_8_26","2KI","8","26","26","ⴰⵅⴰⵣⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⴰⵜⴰⵍⵢⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵄⵓⵎⵔⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K28_27","013_8_27","2KI","8","27","27","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⵓ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("K28_28","013_8_28","2KI","8","28","28","ⵉⴼⴼⴻⵖ ⴰⵅⴰⵣⵢⴰ ⴰⴽ-ⴷ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵖⴻⵍⴱⴻⵏ ⵅ ⵢⵓⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K28_29","013_8_29","2KI","8","29","29","ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵔⴰⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⵓ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⴰⴳⴻⵏⴼⵓ ⵣⴻⴳ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵓⵎⵉ ⵉⵎⵎⵏⴻⵖ ⵏⴻⵜⵜⴰ ⴷⵉ ⵔⴰⵎⵓⵜ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵀⵡⴰ-ⴷⴷ ⴷⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵊⵊ ⵅ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K29_1","013_9_1","2KI","9","1","1","ⵅⴻⵏⵏⵉ ⴰⵏⴰⴱⵉ ⵉⵍⵉⵛⴰⵄ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴱⵢⴻⵙ, ⴽⵙⵉ ⴰⵖⴰⵔⵔⴰⴼ-ⴰ ⵏ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K29_2","013_9_2","2KI","9","2","2","ⵅⵎⵉ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⵡⴹⴻⴷ, ⴰⵔⵣⵓ ⵅ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵎⵛⵉ. ⴰⴷⴻⴼ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⴰⵢⵜⵎⴰⵙ, ⵏⴷⴻⵀ ⵉ-ⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵉⵟⵟⵓⵔⴼⵉⵢ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("K29_3","013_9_3","2KI","9","3","3","ⵅⴻⵏⵏⵉ ⴽⵙⵉ ⴰⵖⴰⵔⵔⴰⴼ ⵏ ⵣⵣⴻⵛⵜ, ⵣⴻⴵⴻⵄ ⵉ-ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⴷⴻⵀⵏⴻⵖ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ.’ ⵅⴻⵏⵏⵉ ⴰⵔⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ, ⴰⵔⵡⴻⵍ, ⵡⴰⵔ ⵜⵜⵔⵉⵊⵉ ⵄⴰⴷ ⴽⵜⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("K29_4","013_9_4","2KI","9","4","4","ⴰⵃⵓⴷⵔⵉ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⵏⴰⴱⵉ, ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K29_5","013_9_5","2KI","9","5","5","ⵓⵎⵉ ⴷⵉⵏ ⴷⴷ-ⵢⵉⵡⴻⴹ, ⵅⵣⴰⵔ, ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵛⴻⴽ, ⴰ ⵍⵇⴻⴱⵟⴰⵏ. ⵢⴰⵀⵓ ⵉⵙⵙⴻⵇⵙⴰ: “ⵉ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵎⴰⵔⵔⴰ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵉ ⵛⴻⴽ, ⴰ ⵍⵇⴻⴱⵟⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("K29_6","013_9_6","2KI","9","6","6","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵢⴰⵀⵓ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ. ⵓ ⵏⴻⵜⵜⴰ ⵉⴼⴰⵔⵔⴻⵖ ⴰⵙ ⵣⵣⴻⵛⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⴷⴻⵀⵏⴻⵖ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ, ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K29_7","013_9_7","2KI","9","7","7","ⵛⴻⴽ ⴰⴷ ⵜⴻⵡⵜⴻⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵙⵉⴷⵉ ⵏⵏⴻⵛ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵣⴰⴱⵉⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K29_8","013_9_8","2KI","9","8","8","ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵅ ⵍⵃⵉⴹ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵊⵊⵉⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K29_9","013_9_9","2KI","9","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⴰⵎⴻⵛⵏⴰⵡ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵓ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⵄⵛⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K29_10","013_9_10","2KI","9","10","10","ⵉⵟⴰⵏ ⴰⴷ ⵛⵛⴻⵏ ⵉⵣⴰⴱⵉⵍ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⵏⴻⴹⵍⴻⵏ.” ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⵏⴻⵜⵜⴰ ⵜⴰⵡⵡⴰⵔⵜ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ.’” ");
INSERT INTO rift_vpl VALUES ("K29_11","013_9_11","2KI","9","11","11","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵢⴰⵀⵓ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵇⴰ ⵛⴻⴽ ⵎⵍⵉⵃ? ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⵓⵙⴰ ⵓⴱⵓⵀⴰⵍⵉ-ⵢⴰ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵔⵢⴰⵣ ⴷ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("K29_12","013_9_12","2KI","9","12","12","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ “ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵏⵉ ⴰⵏⴻⵖ ⵜ!” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⴷ ⵡⴰⵎⵎⵓ ⵉ ⴽⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⴷⴻⵀⵏⴻⵖ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("K29_13","013_9_13","2KI","9","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵇⴻⴵⵇⴻⵏ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵉⴽⵙⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵜⴰⵔⴻⴷⴷⵉⴼⵉⵏ ⵏ ⴷⴷⵔⵓⵊ ⵓⵛⴰ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵏⵏⴰⵏ: “ⵢⴰⵀⵓ ⴷ ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("K29_14","013_9_14","2KI","9","14","14","ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵎⵛⵉ, ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴹⵉⴷⴷ ⵢⵓⵔⴰⵎ. ⵢⵓⵔⴰⵎ, ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⵉⵃⴹⴰ ⵅ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K29_15","013_9_15","2KI","9","15","15","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵢⵓⵔⴰⵎ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ-ⴷⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⵓ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⴰⴳⴻⵏⴼⵓ ⵣⴻⴳ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ, ⵓⵎⵉ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ⵢⴰⵀⵓ ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⴼⵇⴻⵎ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵢⵓⵢⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("K29_16","013_9_16","2KI","9","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵢⴰ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ, ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵢⵓⵔⴰⵎ. ⴰⵅⴰⵣⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⵉⵀⵡⴰ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵊⵊ ⵅ ⵢⵓⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K29_17","013_9_17","2KI","9","17","17","ⴰⵄⴻⵙⵙⴰⵙ ⵉⴱⴻⴷⴷ ⵅ ⵚⵚⵓⵎⵄⴻⵜ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵓⵛⴰ ⵉⵥⵔⴰ ⵢⴰⵀⵓ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⵉⵊⵊ ⵏ ⵓⵀⵉⵎⵓⵔ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵔⴰⵎ: “ⴰⵡⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵓⵢⵉⵙ ⵓⵛⴰ ⵙⵙⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ, ⴰⴷ ⵢⵉⵏⵉ: “ⵎⴰ ⴷ ⵍⴻⵀⵏⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷⴷ-ⵜⵓⵙⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("K29_18","013_9_18","2KI","9","18","18","ⴱⵓ-ⵓⵢⵉⵙ ⵉⵏⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵍⵇⴰ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ‘ⵎⴰ ⴷ ⵍⴻⵀⵏⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷⴷ-ⵜⵓⵙⵉⴷ?’” ⵎⴰⵛⴰ ⵢⴰⵀⵓ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⴰⵏⵉ ⵛⴻⴽ ⵉⵛⵇⴰ ⵍⴻⵀⵏⴰ? ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ.” ⴰⵄⴻⵙⵙⴰⵙ ⵉⵄⵍⴻⵎ ⴰⵢⴰ, ⵉⵏⵏⴰ: “ⴰⵎⵙⴻⵅⵅⴰⵔ ⵢⵉⵡⴻⴹ ⵖⴰⵔⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⵉⴱ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("K29_19","013_9_19","2KI","9","19","19","ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵓⵢⵉⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵏⵉⵜⴰ ⵖⴰⵔⵙⴻⵏ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ‘ⵎⴰ ⴷ ⵍⴻⵀⵏⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷⴷ-ⵜⵓⵙⵉⴷ?’” ⵎⴰⵛⴰ ⵢⴰⵀⵓ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵎⴰⵏⵉ ⵛⴻⴽ ⵉⵛⵇⴰ ⵍⴻⵀⵏⴰ. ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K29_20","013_9_20","2KI","9","20","20","ⴰⵄⴻⵙⵙⴰⵙ ⵉⵄⵍⴻⵎ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ: “ⵏⴻⵜⵜⴰ ⵢⵉⵡⴻⴹ ⵉ-ⵜⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⵉⴱ ⵛⴰ ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⵏⴻⴷⴷⴻⵀ ⴰⵢⵉⵙ, ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴻⴳⴳ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵎⵛⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⴻⴷⴷⴻⵀ ⴰⵎ ⵉⵏⴻⴷⴷⴻⵀ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("K29_21","013_9_21","2KI","9","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵔⴰⵎ: “ⵃⴻⵣⵣⴻⵎ ⴰⴽⴰⵔⵔⵓ!” ⵃⴻⵣⵣⵎⴻⵏ ⴰⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ ⵓ ⵢⵓⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⴰⵅⴰⵣⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵏⴻⴷⵀⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⴰⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵢⴰⵀⵓ ⵓⵛⴰ ⵓⴼⵉⵏ ⵜ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ ⵏ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("K29_22","013_9_22","2KI","9","22","22","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⵓⵔⴰⵎ ⵢⴰⵀⵓ, ⵉⵏⵏⴰ: “ⵎⴰ ⴷ ⵍⴻⵀⵏⴰ ⵉ ⵅⴻⴼ ⴷⴷ-ⵜⵓⵙⵉⴷ, ⴰ ⵢⴰⵀⵓ?” ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵎⴰⵏⴰ ⵍⴻⵀⵏⴰ-ⵢⴰ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏ ⵢⴻⵎⵎⴰⵛ ⵉⵣⴰⴱⵉⵍ ⴷ ⵜⵙⴻⵃⵃⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴰⵎⵎⵓ ⵙ ⵡⴰⵟⵟⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("K29_23","013_9_23","2KI","9","23","23","ⵉⵏⵏⴻⵇⵍⴻⴱ ⵢⵓⵔⴰⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ, ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⴰⵅⴰⵣⵢⴰ: “ⵜⴰⵎⴻⵏⵣⵉⵡⵜ, ⴰⵅⴰⵣⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("K29_24","013_9_24","2KI","9","24","24","ⵎⴰⵛⴰ ⵢⴰⵀⵓ ⵉⵎⵏⴻⵄ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵓⵛⴰ ⵉⵍⵇⴻⴼ ⵢⵓⵔⴰⵎ ⵙ ⴼⵍⵉⵜⵛⴰ ⵊⴰⵔ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ. ⴼⵍⵉⵜⵛⴰ ⵜⴻⵙⵏⵓⵇⵇⴻⴱ ⵇⴰⵄ ⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⴹⴰ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K29_25","013_9_25","2KI","9","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵀⵓ ⵉ ⴱⵉⴷⴽⴰⵔ, ⴰⵏⴻⵖⵔⴰⴼ ⵏⵏⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ: “ⴽⵙⵉ ⵜ ⵓⵛⴰ ⵏⴹⴰⵔ ⵉ-ⵜ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏ ⵏⴰⴱⵓⵜ, ⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉ. ⵄⵇⴻⵍ, ⵏⴻⵛⵛ ⴷ ⵛⴻⴽ, ⵉⵊⵊ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵏⴻⴷⵀⴻⵏ ⵅ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵖ ⴰⵡⴰⵔⵏⵉ ⵉ ⴱⴰⴱⴰⵙ ⴰⵅⴰⴱ ⵓⵎⵉ ⵅⴰⵙ ⵉⵛⴻⵜⵛⴰ ⵙⵉⴷⵉ ⴰⵎⵎⵓ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K29_26","013_9_26","2KI","9","26","26","‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵥⵔⵉⵖ ⵉⴹⴻⵏⵏⴰⴹ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵏⴰⴱⵓⵜ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵣⵣⴰⵢⴻⴽ ⵜⴻⵏ ⵖⴰ ⵅⴻⵍⴼⴻⵖ ⵅ ⵢⴻⵢⵢⴰⵔ-ⴰ, ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ.’ ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴽⵙⵉ ⵜ ⵓⵛⴰ ⵏⴹⴰⵔ ⵉ-ⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("K29_27","013_9_27","2KI","9","27","27","ⵓⵎⵉ ⴰⵅⴰⵣⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵥⵔⴰ ⴰⵢⴰ, ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵀⴰⴳⴰⵏ. ⵢⴰⵀⵓ ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵓ ⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴻⵢⵙⴰⵔⵜ ⵏ ⵊⵓⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵉⴱⵍⵉⵄⴰⵎ, ⵉⵏⵏⴰ: “ⵡⵡⴻⵜ ⵉ-ⵜ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵅ ⵓⴽⴰⵔⵔⵓ!” ⵅⴻⵏⵏⵉ ⵢⴰⵔⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵎⴰⵊⵉⴷⴷⵓ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K29_28","013_9_28","2KI","9","28","28","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵡⵢⴻⵏ ⵜ ⵅ ⵓⴽⴰⵔⵔⵓ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K29_29","013_9_29","2KI","9","29","29","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⵜⵓⵖⴰ ⵉⴷⵡⴻⵍ ⴰⵅⴰⵣⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K29_30","013_9_30","2KI","9","30","30","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵀⵓ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ⵍⴰⵎⵉ ⵜⵜ ⵜⴻⵙⵍⴰ ⵉⵣⴰⴱⵉⵍ, ⵜⴽⴻⵃⵃⴻⵍ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵜⵣⴻⵡⵡⴻⵇ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵅⵣⴰⵔ ⵣⵉ ⵍⴽⴰⵣⵉ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("K29_31","013_9_31","2KI","9","31","31","ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵢⴰⵀⵓ ⵣⵉ ⵜⴰⵡⵡⴰⵔⵜ, ⵜⴻⵏⵏⴰ: “ⵎⴰ ⴷ ⵍⴻⵀⵏⴰ ⵉ ⵅⴻⴼ ⴷⴷ-ⵜⵓⵙⵉⴷ, ⵣⵉⵎⵔⵉ, ⴰ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵙⵉⴷⵉⵙ?”    ");
INSERT INTO rift_vpl VALUES ("K29_32","013_9_32","2KI","9","32","32","ⵏⴻⵜⵜⴰ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴽⴰⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⵉⵏⵏⴰ: “ⵡⵉ ⴰⴽⵉⴷⵉ ⵉⴵⴰⵏ? ⵎⴰⵏ ⵡⴻⵏ?” ⵅⴻⵏⵏⵉ ⵅⵣⴰⵔⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵖⴰⵔⴻⵙ ⴷⵉⵏ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("K29_33","013_9_33","2KI","9","33","33","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴹⴰⵔⴻⵎ ⵜⵜ-ⵉ-ⴷⴷ ⵙⵡⴰⴷⴷⴰⵢ!” ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ-ⵜⵜ-ⵉ-ⴷⴷ ⵙⵡⴰⴷⴷⴰⵢ ⴰⵍⴰⵎⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵔⵓⵛⵛⴻⵏ ⵅ ⵍⵃⵉⴹ ⵓ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵍⴱⴻⵣ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("K29_34","013_9_34","2KI","9","34","34","ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵓⵛⴰ ⵉⵛⵛⴰ, ⵉⵙⵡⴰ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵜⵎⴻⵅⵣⵉⵡⵜ ⵏⵏⵉ ⵓ ⵏⴻⴹⵍⴻⵎ ⵜⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("K29_35","013_9_35","2KI","9","35","35","ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵏⴻⴹⵍⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵏ ⵛⴰ ⵎⵖⵉⵔ ⵜⴰⵛⴻⵇⵇⵓⴼⵜ ⵏ ⵓⵣⴻⴵⵉⴼ ⴷ ⵉⴹⴰⵔⴻⵏ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("K29_36","013_9_36","2KI","9","36","36","ⵓⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ, ⵄⴰⵡⴷⴻⵏ ⴰⵙ ⵜ ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵙⵙⵉⵡⵉⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⵉⵍⵉⵛⴰⵄ ⴰⵜⵉⵛⴱⵉ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵅ ⵢⴻⵢⵢⴰⵔ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵉⵟⴰⵏ ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵉⵣⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K29_37","013_9_37","2KI","9","37","37","ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵉⵣⴰⴱⵉⵍ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵍⴻⵖⴱⴰⵔ ⵅ ⵢⴻⵢⵢⴰⵔ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⴰⵍ ⵖⴰ ⵜⴰⴼ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵖⴰ ⵉⵏⵉⵏ: ⵜⴰ ⴷ ⵉⵣⴰⴱⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("K210_1","013_10_1","2KI","10","1","1","ⴰⵅⴰⴱ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵢⴰⵀⵓ ⵢⵓⵔⴰ ⵜⵉⴱⵔⴰⵜⵉⵏ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵅⴰⴱ. ⴷⴰⵢⵙⴻⵏⵜ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K210_2","013_10_2","2KI","10","2","2","“ⵎⴰⵍⴰ ⵍⴻⵅⵅⵓ ⵜⴰⴱⵔⴰⵜ-ⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ, ⴰⵎ ⵖⴰⵔⵡⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵡⴻⵎ ⵍⴰ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵢⴻⵢⵙⴰⵏ, ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ ⴷ ⵍⴻⵙⵏⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("K210_3","013_10_3","2KI","10","3","3","ⴰⵔⵣⵓⵎ ⵅⴻⵏⵏⵉ ⵅ ⵢⵉⵏⵏⵉ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵇⴰⵄ ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵡⴻⵎ ⵓ ⵙⵖⵉⵎⴻⵎ ⵜ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴱⴰⴱⴰⵙ ⵓ ⵡⵜⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉⵜⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("K210_4","013_10_4","2KI","10","4","4","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵏⵣⴻⵎⵎⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏⴱⴻⴷⴷ?” ");
INSERT INTO rift_vpl VALUES ("K210_5","013_10_5","2KI","10","5","5","ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵅⴰⴱ, ⵙⵙⴻⴽⴽⴻⵏ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵢⴰⵀⵓ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵜⵉⵏⵉⴷ, ⴰⴷ ⵜ ⵏⴻⴳⴳ. ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷ ⴰⵊⴻⴵⵉⴷ. ⴻⴳⴳ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("K210_6","013_10_6","2KI","10","6","6","ⵅⴻⵏⵏⵉ ⵢⵓⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵉⵏⵓ, ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵖⴰⵔ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ, ⴽⵙⵉⵎ ⵅⴻⵏⵏⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵡⴻⵎ, ⵓ ⴰⵙⴻⵎ-ⴷⴷ ⵜⵉⵡⴻⵛⵛⴰ ⴰⵎⵎⵓ ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ ⵖⴰⵔⵉ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ.” ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵢⴰⵔⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K210_7","013_10_7","2KI","10","7","7","ⵓⵎⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⴻⴱⵔⴰⵜ, ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵏⵖⵉⵏ ⵜⴻⵏ ⵎⴰⵔⵔⴰ, ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴽⵓⵔⴱⴰⵜ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K210_8","013_10_8","2KI","10","8","8","ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵉⵙⵙⵉⵡⴻⴹ ⴰⵔⴻⵇⵇⴰⵙ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ.” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵙⴰⵔⵙⴻⵎ ⵜⴻⵏ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⵓⵔⵔⴰⵛ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K210_9","013_10_9","2KI","10","9","9","ⵖⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ, ⵓⵎⵉ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴱⴻⴷⴷ ⴷⵉⵏ, ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ⵅⵣⴰⵔⴻⵎ, ⴷ ⵏⴻⵛⵛ ⵉ ⵉⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵅ ⵙⵉⴷⵉ ⵉⵏⵓ ⵓ ⵏⵖⵉⵖ ⵜ. ⵎⴰⵛⴰ ⵡⵉ ⵉⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰ? ");
INSERT INTO rift_vpl VALUES ("K210_10","013_10_10","2KI","10","10","10","ⵙⵏⴻⵎ, ⴰⵇⴰ ⵡⴰⵔ ⵉⵡⴻⵟⵟⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴹⵉⴷⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵉⵍⵉⵛⴰⵄ.”    ");
INSERT INTO rift_vpl VALUES ("K210_11","013_10_11","2KI","10","11","11","ⵢⴰⵀⵓ ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("K210_12","013_10_12","2KI","10","12","12","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵎⵙⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴻⵍⵇⵉ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K210_13","013_10_13","2KI","10","13","13","ⴰⵇⴰ ⵉⵎⵎⴻⵍⵇⴰ ⵢⴰⵀⵓ ⴰⴽ-ⴷ ⴰⵡⵎⴰⵜⴻⵏ ⵏ ⴰⵅⴰⵣⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⴰⵎ ⴽⴻⵏⵏⵉⵡ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ: “ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵡⵎⴰⵜⴻⵏ ⵏ ⴰⵅⴰⵣⵢⴰ ⵓ ⵏⴻⵀⵡⴰ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⴻⴵⴻⵎ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⵊⴻⴵⵉⴷⵜ.” ");
INSERT INTO rift_vpl VALUES ("K210_14","013_10_14","2KI","10","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵟⵟⴼⴻⵎ ⵜⴻⵏ ⴷⴷⴰⵔⴻⵏ!” ⵟⵟⴼⴻⵏ ⵜⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵓ ⵏⵖⵉⵏ ⵜⴻⵏ ⵖⴰⵔ ⵡⴰⵏⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K210_15","013_10_15","2KI","10","15","15","ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵢⵓⴼⴰ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⴻⴵⴻⵎ ⵅⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵓⵍ ⵏⵏⴻⵛ ⵉⵙⴻⴳⴳⴻⵎ ⴰⴽⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⴻⴳⴳⴻⵎ ⵡⵓⵍ ⵉⵏⵓ ⴰⴽⵉⴷⴻⴽ?” ⵢⵓⵏⴰⴷⴰⴱ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴰⵎⴻⵏⵏⵉ, ⴰⵎⴻⵏⵏⵉ! ⴻⵡⵛ ⴰⵢⵉ-ⴷⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ.” ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⴼⵓⵙ ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵉⵏⵉⵢ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K210_16","013_10_16","2KI","10","16","16","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵙ-ⴷⴷ ⴰⴽⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⴰⵙⴰⵎ ⵉⵏⵓ ⵉ ⵙⵉⴷⵉ.” ⴰⵎⵎⵓ ⵉ ⵊⵊⵉⵏ ⵜ ⴰⴷ ⴷⴷ-ⵉⵏⵉⵢ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("K210_17","013_10_17","2KI","10","17","17","ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ, ⵉⵏⵖⴰ ⵏⴻⵜⵜⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵅⴰⴱ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⴰⵍⴰⵎⵉ ⵜ ⵉⵇⴹⴰ ⵇⴰⵄ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵉ ⵉⵍⵉⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("K210_18","013_10_18","2KI","10","18","18","ⵢⴰⵀⵓ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵅⴰⴱ ⵜⵓⵖⴰ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⴱⴰⵄⴰⵍ ⵛⵡⴰⵢⵜ, ⵎⴰⵛⴰ ⵢⴰⵀⵓ ⴰⴷ ⴰⵙ ⵉⵙⴻⵅⵅⴰⵔ ⴰⵟⵟⴰⵙ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K210_19","013_10_19","2KI","10","19","19","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵍⴰⵖⴰⵎ-ⴷⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴱⴰⵄⴰⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴰⵙⴻⵏ. ⵃⴹⴰⵎ ⴰⵇⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⴱⴰⵄⴰⵍ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵖⴰⴱⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴷⴷⴰⵔ.” ⵢⴰⵀⵓ ⵎⴰⵛⴰ ⵉⴳⴳⴰ ⵜⴰ ⵙ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴹⴰ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⵄⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("K210_20","013_10_20","2KI","10","20","20","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵀⵓ: “ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⵉ ⴱⴰⵄⴰⵍ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴰⵔⵔⵃⴻⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K210_21","013_10_21","2KI","10","21","21","ⵉⵙⵙⴻⴽⴽ ⵢⴰⵀⵓ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⵄⴰⵍ ⵓⵙⵉⵏ-ⴷⴷ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ. ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⴰⵍⴰⵎⵉ ⵜⴻⵛⵛⵓⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("K210_22","013_10_22","2KI","10","22","22","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⴻⵅⵅⴰⵎ ⵏ ⵡⴰⵔⵔⵓⴹ: “ⴰⵡⵉ-ⴷⴷ ⴰⵔⵔⵓⴹⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⵄⴰⵍ!” ⵓ ⵡⴰⵏⵉⵜⴰ ⵢⵉⵡⵉ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵔⵔⵓⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K210_23","013_10_23","2KI","10","23","23","ⵢⵓⴷⴻⴼ ⵢⴰⵀⵓ ⴰⴽ-ⴷ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⵄⴰⵍ: “ⵅⵣⴰⵔⴻⵎ ⵎⵍⵉⵃ, ⴰⵇⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⵖⵉⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⵄⴰⵍ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("K210_24","013_10_24","2KI","10","24","24","ⵓⵎⵉ ⵉⵡⴹⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⴰⵡⵢⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵜⵓⵖⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵢⴰⵀⵓ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⴱⴰⵔⵔⴰ, ⵉⵏⵏⴰ: “ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⵊⵊ ⴰⴷ ⵉⵏⵊⴻⵎ ⵉⵊⵊ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴳⴳⵉⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("K210_25","013_10_25","2KI","10","25","25","ⵍⴰⵎⵉ ⵉⵇⴼⴻⵍ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵟ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵎ ⵏ ⵜⴰⵣⵍⴰ ⵓ ⵉ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ: “ⴰⴷⴼⴻⵎ, ⵡⵜⴻⵎ ⵜⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵏⵊⴻⵎ!” ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵜⴻⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴱⴰⵔⵔⴰ. ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("K210_26","013_10_26","2KI","10","26","26","ⵏⵉⵜⵏⵉ ⴽⴽⵙⴻⵏ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⵓⵛⴰ ⵙⵙⴰⵔⵖⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K210_27","013_10_27","2KI","10","27","27","ⵏⵉⵜⵏⵉ ⴰⵔⵥⵉⵏ ⴰⵎⴻⵢⴹⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴱⴰⵄⴰⵍ. ⵀⴻⴷⵎⴻⵏ ⵄⴰⵡⴻⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵣⵓⴱⴰⵛⵜ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K210_28","013_10_28","2KI","10","28","28","ⴰⵎⵎⵓ ⵉ ⵉⵎⵃⴰ ⵢⴰⵀⵓ ⴱⴰⵄⴰⵍ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K210_29","013_10_29","2KI","10","29","29","ⵎⴰⵛⴰ ⵢⴰⵀⵓ ⵡⴰⵔ ⵉⴱⴻⴷⴷ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ: ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("K210_30","013_10_30","2KI","10","30","30","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓ: “ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⵉⴷ ⵏⵉⵛⴰⵏ ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵉ ⴷⴻⴳ ⵡⵓⵍ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("K210_31","013_10_31","2KI","10","31","31","ⵎⴰⵛⴰ ⵢⴰⵀⵓ ⵡⴰⵔ ⵉⵃⴹⵉ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵓⵢⵓⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K210_32","013_10_32","2KI","10","32","32","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴱⴷⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⵎⵥⵉ ⵉⵙⵔⴰⵉⵍ. ⵃⴰⵣⴰⵢⵉⵍ ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("K210_33","013_10_33","2KI","10","33","33","ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵊⴰⴷⵉⵢⵢⴻⵏ ⴷ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴰⵏⴰⵙⵙⵉⵢⵢⴻⵏ, ⵣⵉ ⴰⵔⵓⵄⵉⵔ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⴰⵔⵏⵓⵏ, ⵓⵍⴰ ⴷ ⵊⵉⵍⵄⴰⴷ ⴷ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K210_34","013_10_34","2KI","10","34","34","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K210_35","013_10_35","2KI","10","35","35","ⵢⴰⵀⵓ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵎⵎⵉⵙ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K210_36","013_10_36","2KI","10","36","36","ⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵢⴰⵀⵓ ⵉⵃⴻⴽⴽⴻⵎ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K211_1","013_11_1","2KI","11","1","1","ⵓⵎⵉ ⵄⴰⵜⴰⵍⵢⴰ, ⵢⴻⵎⵎⴰⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⵜⴻⵥⵔⴰ, ⴰⵇⴰ ⵎⵎⵉⵙ ⵉⵎⵎⵓⵜ, ⵜⴻⴳⴳⴰ ⴰⴷ ⵜⴻⵇⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵔⴰⵡⵜ ⵏ ⵍⴰⴵ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K211_2","013_11_2","2KI","11","2","2","ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⵉⴱⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵔⴰⵎ, ⵓⵍⵜⵎⴰⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⵜⴻⴽⵙⵉ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵣⵉ ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵓⵛⴰ ⵜⵉⵡⵢⵉ ⵜ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵜ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⴰⵙⵙⵓⵜ ⵓⵛⴰ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⴷⵉⵏⵏⵉ ⵣⵉ ⵄⴰⵜⴰⵍⵢⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("K211_3","013_11_3","2KI","11","3","3","ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵏⵓⴼⴼⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵜⴻⵃⴽⴻⵎ ⵄⴰⵜⴰⵍⵢⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K211_4","013_11_4","2KI","11","4","4","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵙⵙⴻⴽⴽ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏ ⵖⴰⵔⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵊⵊⴰⴵⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K211_5","013_11_5","2KI","11","5","5","ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ: ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵄⴻⵙⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K211_6","013_11_6","2KI","11","6","6","ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⴰⴷ ⵜⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵚⵓⵔ ⵓ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵄⴻⵙⵙⴻⵎ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⴷⵉ ⵜⵏⵓⴱⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K211_7","013_11_7","2KI","11","7","7","ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⴻⵢⵏⴰⵜ ⵏⵡⴻⵎ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵃⴹⴰⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K211_8","013_11_8","2KI","11","8","8","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏⵏⴹⴻⵎ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵣⵓⵏ ⴰⴷ ⵢⴰⴷⴻⴼ ⵊⴰⵔ ⵍⴻⵚⴼⵓⴼ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵏ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ ⵏⵉⵖ ⵎⴰⵍⴰ ⵢⵓⴷⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("K211_9","013_11_9","2KI","11","9","9","ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵡⴻⵚⵚⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⵉ ⵢⵓⴷⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("K211_10","013_11_10","2KI","11","10","10","ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵎⵢⴰ ⵉⵡⵛⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵍⴰⵏⵙⴰⵜ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K211_11","013_11_11","2KI","11","11","11","ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⴱⴻⴷⴷⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⴷⴻⴳ ⵓⴼⵓⵙ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵍ ⴰⵖⴻⵣⴷⵉⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵎⵎⵓ ⵇⵓⵡⵡⴰⵔⴻⵏ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K211_12","013_11_12","2KI","11","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵛⵛⵀⴰⴷⴻⵜ. ⴰⵎⵎⵓ ⵉ ⵜ ⴳⴳⵉⵏ ⴷ ⴰⵊⴻⴵⵉⴷ, ⴷⴻⵀⵏⴻⵏ ⵜ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("K211_13","013_11_13","2KI","11","13","13","ⵓⵎⵉ ⵜⴻⵙⵍⴰ ⵄⴰⵜⴰⵍⵢⴰ ⵍⵃⴻⵙⵙ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵏ ⵍⴳⴻⵏⵙ, ⵜⵓⵙⴰ-ⴷⴷ ⵏⴻⵜⵜⴰⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K211_14","013_11_14","2KI","11","14","14","ⵜⴻⵥⵔⴰ, ⵓ ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⴱⵉⵍⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⴷⵉ ⵍⵇⴰⵄⵉⴷⴰ, ⵓⵛⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵉⵏⵏⵉ ⵉⵚⵓⴷⴻⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⵔⴰⵃ ⵓ ⵉⵙⵓⴹ ⴷⵉ ⵍⴻⴱⵡⴰⵇ. ⵅⴻⵏⵏⵉ ⵜⵛⴰⵔⵔⴻⴳ ⵄⴰⵜⴰⵍⵢⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵜⴻⵙⵖⵓⵢ: “ⵜⴰⵎⴻⵏⵣⵉⵡⵜ, ⵜⴰⵎⴻⵏⵣⵉⵡⵜ!” ");
INSERT INTO rift_vpl VALUES ("K211_15","013_11_15","2KI","11","15","15","ⵎⴰⵛⴰ ⵢⵓⵎⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵅ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵡⵢⴻⵎ ⵜⵜ ⵊⴰⵔ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵏⵖⴻⵎ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ ⵙ ⵙⵙⵉⴼ.” ⵎⴰⵖⴰⵔ ⴰⴽⴻⵀⵀⴰⵏ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵏⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("K211_16","013_11_16","2KI","11","16","16","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ, ⵓⵛⴰ ⵍⴰⵎⵉ ⵜⵔⵓⵃ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵉⵢⵙⴰⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵏⵖⵉⵏ ⵜⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K211_17","013_11_17","2KI","11","17","17","ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⵙⵉⴷⵉ ⴷ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("K211_18","013_11_18","2KI","11","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⵓ ⵀⴻⴷⵎⴻⵏ ⵜⵜ. ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⴰⵔⵥⵉⵏ ⵜⴻⵏ ⵇⴰⵄ. ⵓ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵎⴰⵜⵜⴰⵏ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⴱⴰⵄⴰⵍ, ⵣⵣⴰⵜ ⵉ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ. ⴰⴽⴻⵀⵀⴰⵏ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K211_19","013_11_19","2KI","11","19","19","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵀⵡⴰⵏ ⴰⵊⴻⴵⵉⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴽⴽⵉⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓ ⴷⵉⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K211_20","013_11_20","2KI","11","20","20","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴰⵔⵃ ⵓⵛⴰ ⵜⴰⵔⵙⴰ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵇⴰ ⵏⵖⵉⵏ ⵄⴰⵜⴰⵍⵢⴰ ⵙ ⵙⵙⵉⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K212_1","013_12_1","2KI","12","1","1","ⵜⵓⵖⴰ ⵖⴰⵔ ⵢⵓⵡⴰⵛ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K212_2","013_12_2","2KI","12","2","2","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵢⴰⵀⵓ ⵉⴷⵡⴻⵍ ⵢⵓⵡⴰⵛ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴹⵉⴱⵢⴰ ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("K212_3","013_12_3","2KI","12","3","3","ⵢⵓⵡⴰⵛ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵎⵉⵏ ⵉⴽⴽⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("K212_4","013_12_4","2KI","12","4","4","ⵡⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ ⵎⵖⵉⵔ ⵍⴻⴳⵄⵓⴷⵉ. ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⵜⵜⵇⴻⴷⴷⴻⵎ ⵄⴰⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K212_5","013_12_5","2KI","12","5","5","ⵢⵓⵡⴰⵛ ⵉⵏⵏⴰ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: “ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵡⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵍⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵉ ⵉⵄⴻⴷⴷⵓⵏ ⵖⴰⵔ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ, ⵍⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵇⴻⴷⴷⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵍⴰ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵅ ⴷⴷ-ⵢⵓⵙⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("K212_6","013_12_6","2KI","12","6","6","ⴰⴷ ⵜⵜ ⴽⵙⵉⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵙⵙⴻⵏ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⵇⵇⵄⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵉⵀⵔⵓⵔⴰⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵉⵜⵜⵡⴰⴼⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵉⵀⵔⵓⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("K212_7","013_12_7","2KI","12","7","7","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵡⴰⵛ ⵡⴰⵔ ⵄⴻⴷⴷⵍⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⴰⴷ ⵍⴻⵃⵢⵓⴹ ⵉⵀⵔⵓⵔⴰⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K212_8","013_12_8","2KI","12","8","8","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵡⴰⵛ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵓ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵄⴻⴷⴷⵍⴻⵎ ⵍⴻⵃⵢⵓⴹ ⵉⵛⴰⵔⵔⴳⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ? ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵜⴽⴻⵙⵙⵉⵎ ⵄⴰⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜⴻⵙⵙⵏⴻⵎ, ⵎⵖⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵉⵡⴹⴻⵎ ⵉ ⵡⴻⵄⴷⴰⵍ ⵏ ⵎⵉⵏ ⵉⵛⴰⵔⵔⴳⴻⵏ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K212_9","013_12_9","2KI","12","9","9","ⵇⴻⴱⵍⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵏ ⵄⴰⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵉ ⵍⴳⴻⵏⵙ ⵓ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵃⴷⵉⵊⴻⵏ ⵛⴰ ⵄⴰⴷ ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵉⵇⴻⵟⵟⵙⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K212_10","013_12_10","2KI","12","10","10","ⴰⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⴽⵙⵉ ⵉⵛⵜ ⵏ ⵜⵙⴻⵏⴷⵓⵇⵜ, ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵏⵓⵇⵇⵉⴱ ⴷⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵅ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⴳⴳⵉⵏ ⴷⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵡⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K212_11","013_12_11","2KI","12","11","11","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵜⵙⴻⵏⴷⵓⵇⵜ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵎⴰⵔⵉⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵏⵉⵜⵏⵉ ⵙⵙⵎⵓⵏⴻⵏ ⵜⵜ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵓⵛⴰ ⵡⴻⵣⵏⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K212_12","013_12_12","2KI","12","12","12","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵍⵇⴻⴷⴷ ⵉⵡⴻⵣⵏⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵉ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵓ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵜⵜ ⵄⴰⵡⴻⴷ ⵉ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⵉ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("K212_13","013_12_13","2KI","12","13","13","ⵓ ⵉ ⵉⵎⴰⵚⵚⵓⵜⴻⵏ ⴷ ⵉⵙⵓⵢⴷⴰⵢⴻⵏ, ⵓ ⵉ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵜⵚⵓⴹⴰⵔ ⵢⵓⵢⴷⴰⵏ ⵉⵜⵜⴻⵃⵡⴰⵊⴰⵏ ⵉ ⵡⴰⵔⴻⵇⵇⴻⵄ ⵏ ⵎⵉⵏ ⵉⵇⴻⵟⵟⵙⴻⵏ ⵣⵉ ⵍⴻⵃⵢⵓⴹ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵙⴻⵢⵢⴰⵔⴻⵏ ⵉ ⵡⴰⵔⴻⵇⵇⴻⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K212_14","013_12_14","2KI","12","14","14","ⵎⵖⵉⵔ ⵡⴰⵔ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵟⵟⴱⴰⵚⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵍⴰ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ, ⵍⴰ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⵍⴻⴱⵡⴰⵇ, ⵓⵍⴰ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ, ⵣⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K212_15","013_12_15","2KI","12","15","15","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵜⵜ ⵎⴰⵔⵔⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵇⵇⵄⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K212_16","013_12_16","2KI","12","16","16","ⵡⴰⵔ ⵎⵎⵙⴻⵃⵙⵉⴱⴻⵏ ⵛⴰ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵓⵎⵉ ⵡⵛⵉⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵡⵛⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵓⵜⵉⵇⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("K212_17","013_12_17","2KI","12","17","17","ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⴷⴷⴻⵏⴱ ⵡⴰⵔ ⵜⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵜⵓⵖⴰ-ⵜⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K212_18","013_12_18","2KI","12","18","18","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵊⴰⵜ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵄⴻⵡⵡⴻⵍ ⵃⴰⵣⴰⵢⵉⵍ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K212_19","013_12_19","2KI","12","19","19","ⵎⴰⵛⴰ ⵢⵓⵡⴰⵛ ⵉⴽⵙⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏⵜ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵢⴰⵀⵓⵔⴰⵎ ⴷ ⴰⵅⴰⵣⵢⴰ, ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵍⴰ ⴷ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⴰ ⵖⴰⵔ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴳⵯⴻⵊ ⵏⴻⵜⵜⴰ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K212_20","013_12_20","2KI","12","20","20","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵡⴰⵛ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K212_21","013_12_21","2KI","12","21","21","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⵙ, ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓⵛⴰ ⵏⵖⵉⵏ ⵢⵓⵡⴰⵛ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⵇⴻⵍⵄⴰ ⵎⴰⵏⵉⵙ ⵀⴻⴽⴽⵡⴰⵏ ⵖⴰⵔ ⵙⵉⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("K212_22","013_12_22","2KI","12","22","22","ⴰⵇⴰ ⵢⵓⵣⴰⴽⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⴰⵜ, ⴷ ⵢⴰⵀⵓⵣⴰⴱⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵛⵓⵎⵉⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵡⵜⵉⵏ ⵜ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ⵏⵉⵜⵏⵉ ⵏⴻⴹⵍⴻⵏ ⵜ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K213_1","013_13_1","2KI","13","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K213_2","013_13_2","2KI","13","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⴰⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K213_3","013_13_3","2KI","13","3","3","ⵅ ⵓⵢⴻⵏⵏⵉ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵓ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵣⴰⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K213_4","013_13_4","2KI","13","4","4","ⵎⴰⵛⴰ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵉⵃⴻⵛⵛⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⴰⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵥⵔⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵏ ⵉⵃⵚⴰⵍ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K213_5","013_13_5","2KI","13","5","5","ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵏⵊⴻⵎ ⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵏⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴷⴷⵖⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵎ ⵇⴱⴻⵍ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K213_6","013_13_6","2KI","13","6","6","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵏ ⵛⴰ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ⵉⵙⵔⴰⵉⵍ ⵉⵇⵇⵉⵎ ⵉⴳⴳⵓⵔ ⴰⵎⵎⵓ ⵓ ⵜⴻⵇⵇⵉⵎ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵜⴱⴻⴷⴷ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K213_7","013_13_7","2KI","13","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵎⵖⵉⵔ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵄⴻⵛⵔⴰ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵜⵓⵖⴰ ⵉⵇⴹⴰ ⵉ-ⵜⴻⵏ, ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵖⴰⵔ ⵓⵙⴰⵔⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K213_8","013_13_8","2KI","13","8","8","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K213_9","013_13_9","2KI","13","9","9","ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵎⵎⵉⵙ ⵢⵓⵡⴰⵛ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K213_10","013_13_10","2KI","13","10","10","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K213_11","013_13_11","2KI","13","11","11","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵏⵉ ⵢⵓⵢⵓⵔ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K213_12","013_13_12","2KI","13","12","12","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵡⴰⵛ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ ⵉ ⵣⵉ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K213_13","013_13_13","2KI","13","13","13","ⵢⵓⵡⴰⵛ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵢⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ. ⵢⵓⵡⴰⵛ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵊⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K213_14","013_13_14","2KI","13","14","14","ⵉⵍⵉⵛⴰⵄ ⵉⵜⵜⵡⴰⵍⵇⴻⴼ ⵙ ⵍⴻⵀⵍⴰⵛ ⵉ ⵣⵉ ⵖⴰ ⵉⵎⵎⴻⵜ. ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵔⵓ ⵣⵣⴰⵜⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⴰ ⴱⴰⴱⴰ! ⴰⴽⴰⵔⵔⵓ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ!”    ");
INSERT INTO rift_vpl VALUES ("K213_15","013_13_15","2KI","13","15","15","ⵉⵍⵉⵛⴰⵄ ⵉⵏⵏⴰ: “ⴽⵙⵉ ⵍⵇⴻⵡⵙ ⴷ ⴼⵍⵉⵜⵛⴰⵜ!” ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵍⵇⴻⵡⵙ ⴷ ⴼⵍⵉⵜⵛⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K213_16","013_13_16","2KI","13","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵍⵇⴻⵡⵙ!” ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵏⴻⵜⵜⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⵇⴻⵡⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉⵍⵉⵛⴰⵄ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("K213_17","013_13_17","2KI","13","17","17","ⵉⵏⵏⴰ: “ⴰⵔⵣⴻⵎ ⵍⴽⴰⵣⵉ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ!”, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⵎ ⵉ-ⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵍⵉⵛⴰⵄ: “ⵡⵡⴻⵜ!” ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵙ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ. ⵓⵛⴰ ⵉⵏⵏⴰ ⵉⵍⵉⵛⴰⵄ: “ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⴼⵍⵉⵜⵛⴰ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⴼⵍⵉⵜⵛⴰ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴰⵔⴰⵎ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⵖⴻⵍⴱⴻⴷ ⴰⵔⴰⵎ ⴷⵉ ⵄⴰⴼⵉⴽ ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ.” ");
INSERT INTO rift_vpl VALUES ("K213_18","013_13_18","2KI","13","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⴽⵙⵉ ⴼⵍⵉⵜⵛⴰⵜ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⴻⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵡⵡⴻⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵡⵜⴰ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("K213_19","013_13_19","2KI","13","19","19","ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴼⴼⵓⴳⴻⵎ ⵅⴰⵙ ⴰⵟⵟⴰⵙ, ⵉⵏⵏⴰ: “ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵡⵜⴻⴷ ⵅⴻⵎⵙⴰ ⵏⵉⵖ ⵙⴻⵜⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵉⵍⵉ ⴰⴷ ⵜⴻⵖⵍⴻⴱ ⵅ ⴰⵔⴰⵎ ⴰⵍⴰⵎⵉ ⵜ ⵉ ⵖⴰ ⵜⴻⵇⴹⵉⴷ ⵇⴰⵄ. ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⴰⴷ ⵜⵖⴻⵍⴱⴻⴷ ⵅ ⴰⵔⴰⵎ ⵎⵖⵉⵔ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K213_20","013_13_20","2KI","13","20","20","ⵉⵍⵉⵛⴰⵄ ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ. ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⵜⵓⵖⴰ ⵜⵜⵏⵓⵎⴰⵏⵜ ⴰⴷ ⴰⴷⴼⴻⵏⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K213_21","013_13_21","2KI","13","21","21","ⵅⵣⴰⵔ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵟⵟⵍⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵥⵔⵉⵏ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ. ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⴰⵔⵢⴰⵣ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏ ⵉⵍⵉⵛⴰⵄ. ⵓⵎⵉ ⴷⴰⵢⴻⵙ ⵉⵡⴹⴰ ⵡⴻⵔⵢⴰⵣ, ⵉⵃⴰⴷⴰ ⵉⵢⵙⴰⵏ ⵏ ⵉⵍⵉⵛⴰⵄ, ⵉⴷⵡⴻⵍ ⵉⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵉⴱⴻⴷⴷ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K213_22","013_13_22","2KI","13","22","22","ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵃⵚⴰⵔ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("K213_23","013_13_23","2KI","13","23","23","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵃⵉⵏⵏ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⵃⴻⵎ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵖⴰⵔⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵓ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⴽⴽ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰⵍ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("K213_24","013_13_24","2KI","13","24","24","ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵎⵎⵓⵜ ⵓ ⵎⵎⵉⵙ ⴱⵉⵏⵀⴰⴷⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K213_25","013_13_25","2KI","13","25","25","ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵉⴽⴽⴻⵙ-ⴷⴷ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵣⴰⵢⵉⵍ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵡⴰⵏⵉⵜⴰ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ. ⵢⵓⵡⴰⵛ ⵉⵖⵍⴻⴱ ⵅⴰⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K214_1","013_14_1","2KI","14","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴷⵡⴻⵍ ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_2","013_14_2","2KI","14","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵀⵓⵄⴰⴷⴰⵏ, ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K214_3","013_14_3","2KI","14","3","3","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵉⴳⴳⴰ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⵢⵓⵡⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("K214_4","013_14_4","2KI","14","4","4","ⵎⵖⵉⵔ ⵡⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ ⵍⴻⴳⵄⵓⴷⵉ. ⵍⴳⴻⵏⵙ ⵢⵉⵡⵉ ⵄⴰⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K214_5","013_14_5","2KI","14","5","5","ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴰⴳⴻⵍⴷⴰ ⵜⴻⵎⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵏⵖⵉⵏ ⴰⵊⴻⴵⵉⴷ, ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K214_6","013_14_6","2KI","14","6","6","ⵎⴰⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵇⴻⵜⵜⴰⵍⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⵖⵉ ⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵉ ⴷⵉ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵉⴱⴰⴱⴰⵜⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("K214_7","013_14_7","2KI","14","7","7","ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⵎⴻⴵⴰⵃⵜ, ⵄⴻⵛⵔⴰ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵓ ⵉⵟⵟⴻⴼ ⵙⴰⵍⴰⵄ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵓ ⵉⴳⴳⴰ ⴰⵙ ⵢⴰⵇⵜⴰⵢⵉⵍ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_8","013_14_8","2KI","14","8","8","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵎⴰⵚⵢⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵢⵓⵡⴰⵙ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵎⵎⴻⵍⵇⴰ ⵉ ⵓⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("K214_9","013_14_9","2KI","14","9","9","ⵎⴰⵛⴰ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: “ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵉ ⵉⵖⴻⵎⵎⵢⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵉⵙⵙⴻⴽⴽ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵉⵏⵏⴰ: ‘ⴻⵡⵛ ⵢⴻⴵⵉⵙ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ!’ ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⵏ ⵍⴻⵅⵍⴰ ⵉ ⴷⵉⵏ ⵢⵓⵢⵓⵔⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵉⴽⴽⴰ ⵓ ⵉⵄⴼⴻⵙ ⵅ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K214_10","013_14_10","2KI","14","10","10","ⵉⵡⴰ ⵛⴻⴽ ⵜⵖⴻⵍⴱⴻⴷ ⵅ ⵉⴷⵓⵎ ⵓ ⵍⴻⵅⵅⵓ ⵜⴷⴻⵡⵍⴻⴷ ⴷⴰⵢⴻⴽ ⵏⵏⴼⴰⵅⴻⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ⵟⵟⴻⴼ ⴷⴻⴳ ⵓⵡⴻⵇⵇⴰⵔ ⵉ ⵖⴰⵔⴻⴽ ⵓ ⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵍⵖⴰⵔ ⵓ ⴰⴷ ⵜⴻⵡⴹⵉⴷ, ⵛⴻⴽ ⴷ ⵢⴰⵀⵓⴷⴰ ⴰⴽⵉⴷⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("K214_11","013_14_11","2KI","14","11","11","ⵎⴰⵛⴰ ⴰⵎⴰⵚⵢⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⴻⵍ, ⵓⵛⴰ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴳⴻⵄⵄⴻⴷ ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵇⴰⴱⴰⵍⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_12","013_14_12","2KI","14","12","12","ⵢⴰⵀⵓⴷⴰ ⵉⵜⵜⵡⴰⵖⵍⴻⴱ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K214_13","013_14_13","2KI","14","13","13","ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵟⵟⴻⴼ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⴷⵉ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⴷⵉⵏⵏⵉ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵍ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K214_14","013_14_14","2KI","14","14","14","ⵢⵉⵡⵉ ⵎⴰⵔⵔⴰ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵍⴰ ⴷ ⵉⵔⴻⵀⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_15","013_14_15","2KI","14","15","15","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵡⴰⵛ ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K214_16","013_14_16","2KI","14","16","16","ⵢⵓⵡⴰⵛ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵊⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⵎⵉⵙ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K214_17","013_14_17","2KI","14","17","17","ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K214_18","013_14_18","2KI","14","18","18","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵎⴰⵚⵢⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K214_19","013_14_19","2KI","14","19","19","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵅⴰⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵍⴰⵅⵉⵛ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵏⵏⵉ ⵜ ⵉⴹⴼⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴰⵅⵉⵛ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K214_20","013_14_20","2KI","14","20","20","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵅ ⵢⴻⵢⵙⴰⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K214_21","013_14_21","2KI","14","21","21","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵢⵉⵡⵉ ⵄⴰⵣⴰⵔⵢⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔ ⵉⴵⴰ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓ ⴳⴳⵉⵏ ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⴰⵎⴰⵚⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_22","013_14_22","2KI","14","22","22","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵉⵍⴰⵜ ⵓ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵓⵊⴻⴵⵉⴷ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K214_23","013_14_23","2KI","14","23","23","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_24","013_14_24","2KI","14","24","24","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K214_25","013_14_25","2KI","14","25","25","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⴻⵡⴹⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵢⵓⵏⵓⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵉⵜⵜⴰⵢ ⵣⵉ ⵊⴰⵜ-ⵃⴰⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("K214_26","013_14_26","2KI","14","26","26","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵥⵔⴰ ⴰⵇⴰ ⵍⴻⵖⴱⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⵎⴻⵔⵣⴰⴳ ⴰⵟⵟⴰⵙ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵊⵊⵉⵏ ⵓ ⵡⴰⵔ ⵜⵓⵖⵉ ⵡⴻⵏⵏⵉ ⵉⵄⴰⵡⵏⴻⵏ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K214_27","013_14_27","2KI","14","27","27","ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵃⴰ ⵉⵙⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵙⴰⴷⵓ ⵉⵊⴻⵏⵡⴰⵏ, ⵓⵛⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("K214_28","013_14_28","2KI","14","28","28","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵎⵏⴻⵖ ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⴽⴻⵙⵙⴻⴱ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⴷⵉⵎⴰⵛⵇ ⴷ ⵃⴰⵎⴰⵜ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K214_29","013_14_29","2KI","14","29","29","ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵊⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⵎⵉⵙ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_1","013_15_1","2KI","15","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴷⵡⴻⵍ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_2","013_15_2","2KI","15","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⴽⵓⵍⵢⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K215_3","013_15_3","2KI","15","3","3","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴰⵎⴰⵚⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_4","013_15_4","2KI","15","4","4","ⵎⵖⵉⵔ ⵡⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ ⵍⴻⴳⵄⵓⴷⵉ. ⵢⵉⵡⵉ ⵍⴳⴻⵏⵙ ⵄⴰⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K215_5","013_15_5","2KI","15","5","5","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵜⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵍⴰⵎⵉ ⵉⵀⵍⴻⵛ ⵙ ⵍⴱⴰⵔⵚ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵄⵣⴻⵍ, ⵓⵎⵉ ⵢⵓⵜⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵜⵓⵖⴰ ⴷ ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K215_6","013_15_6","2KI","15","6","6","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵄⴰⵣⴰⵔⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K215_7","013_15_7","2KI","15","7","7","ⵄⴰⵣⴰⵔⵢⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⵢⵓⵜⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_8","013_15_8","2KI","15","8","8","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵃⴽⴻⵎ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⵍⵇⴻⴷⴷ ⵏ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K215_9","013_15_9","2KI","15","9","9","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_10","013_15_10","2KI","15","10","10","ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴱⵉⵛ, ⵉⴳⴳⴰ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓⵛⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_11","013_15_11","2KI","15","11","11","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K215_12","013_15_12","2KI","15","12","12","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵢⴰⵀⵓ, ⵉⵏⵏⴰ: “ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K215_13","013_15_13","2KI","15","13","13","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴱⵉⵛ, ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵉⴽⵎⴻⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_14","013_15_14","2KI","15","14","14","ⵎⴰⵏⴰⵃⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵊⴰⴷⵉ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵣⵉ ⵜⵉⵔⵚⴰ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ, ⵉⵡⵜⴰ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴱⵉⵛ, ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_15","013_15_15","2KI","15","15","15","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵛⴰⵍⵍⵓⵎ ⴷ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵉ ⵉⴳⴳⴰ, ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K215_16","013_15_16","2KI","15","16","16","ⵅⴻⵏⵏⵉ ⵉⵖⵍⴻⴱ ⵎⴰⵏⴰⵃⵉⵎ ⵅ ⵜⴰⴼⵙⴰⵃ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⵉ ⴷⴰⵢⴻⵙ, ⵓⵛⴰ ⵉⵡⵜⴰ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵜⵉⵔⵚⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⴰⵔⵣⵉⵎⴻⵏ ⵜⵉⵡⵡⵓⵔⴰ. ⴰⵇⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵉⴼⴻⵜⵜⴻⵇ ⴰⵙⴻⵏⵜ ⴰⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_17","013_15_17","2KI","15","17","17","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵎⴰⵏⴰⵃⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵊⴰⴷⵉ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_18","013_15_18","2KI","15","18","18","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵛⴰ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_19","013_15_19","2KI","15","19","19","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴼⵓⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵉⵀⵊⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵉⵡⵛⴰ ⵎⴰⵏⴰⵃⵉⵎ ⴰⵍⴻⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴼⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴷ ⵉⵃⴽⴻⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_20","013_15_20","2KI","15","20","20","ⵎⴰⵏⴰⵃⵉⵎ ⵉⴳⴳⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵉⵡⵉ ⵏⵏⵓⵇⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ⵣⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⴽⵙⵉ ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K215_21","013_15_21","2KI","15","21","21","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵎⴰⵏⴰⵃⵉⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("K215_22","013_15_22","2KI","15","22","22","ⵎⴰⵏⴰⵃⵉⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵎⵎⵉⵙ ⴼⴰⵇⴰⵃⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_23","013_15_23","2KI","15","23","23","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⵉⵏ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⴼⴰⵇⴰⵃⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵃⵉⵎ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_24","013_15_24","2KI","15","24","24","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_25","013_15_25","2KI","15","25","25","ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⴰⵏⴻⵖⵔⴰⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⴳⴳⴰ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ, ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⴷⵉ ⵍⴱⵓⵔⵊ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⴰⵔⵊⵓⴱ ⴷ ⴰⵔⵢⴰⵀ ⵡⵛⵉⵏ ⴰⵙ ⴰⴼⵓⵙ ⵓ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵊⵉⵍⵄⴰⴷ. ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⴼⴰⵇⴰⵃⵢⴰ ⵓ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K215_26","013_15_26","2KI","15","26","26","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴼⴰⵇⴰⵃⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K215_27","013_15_27","2KI","15","27","27","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⵉⴷⵡⴻⵍ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_28","013_15_28","2KI","15","28","28","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵛⴰ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ ⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_29","013_15_29","2KI","15","29","29","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴼⴰⵇⴰⵃ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵢⵓⵙⴰ-ⴷⴷ ⵜⵉⵖⵍⴰⵜ-ⴼⵉⵍⴰⵙⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⵡⵡⴻⵙ ⵄⴰⵢⵓⵏ ⴷ ⴰⴱⵉⵍ-ⴱⴰⵢⵜ-ⵎⴰⵄⴽⴰ ⴷ ⵢⴰⵏⵓⵃ ⴷ ⵇⴰⴷⴰⵛ ⴷ ⵃⴰⵚⵓⵔ ⴷ ⵊⵉⵍⵄⴰⴷ ⴷ ⵍⵊⴰⵍⵉⵍ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K215_30","013_15_30","2KI","15","30","30","ⵀⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⴰ, ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵅ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ. ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⵓⵜⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_31","013_15_31","2KI","15","31","31","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴼⴰⵇⴰⵃ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K215_32","013_15_32","2KI","15","32","32","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴷⵡⴻⵍ ⵢⵓⵜⴰⵎ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_33","013_15_33","2KI","15","33","33","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵔⵓⵛⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵚⴰⴷⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("K215_34","013_15_34","2KI","15","34","34","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⵄⵓⵣⵣⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_35","013_15_35","2KI","15","35","35","ⵎⵖⵉⵔ ⵡⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ ⵍⴻⴳⵄⵓⴷⵉ. ⵍⴳⴻⵏⵙ ⵢⵉⵡⵢⵉ-ⴷⴷ ⵄⴰⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⴻⵡⵡⴰⵔⵜ ⵢⵓⵄⵍⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K215_36","013_15_36","2KI","15","36","36","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵜⴰⵎ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K215_37","013_15_37","2KI","15","37","37","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴱⴷⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵔⴰⵚⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⴷ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K215_38","013_15_38","2KI","15","38","38","ⵢⵓⵜⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⴰⵃⴰⵣ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K216_1","013_16_1","2KI","16","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⵉⴷⵡⴻⵍ ⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵜⴰⵎ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K216_2","013_16_2","2KI","16","2","2","ⴰⵃⴰⵣ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K216_3","013_16_3","2KI","16","3","3","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵄⴰⴷ ⵎⵎⵉⵙ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵄⴰⵔⵔⴻⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K216_4","013_16_4","2KI","16","4","4","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ-ⴷⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵓ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵓ ⵙⴰⴷⵓ ⵎⴰⵔⵔⴰ ⴰⵣⵖⴰⵔ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("K216_5","013_16_5","2KI","16","5","5","ⵅⴰⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵔⴰⵚⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⴷ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⵉ ⴰⵃⴰⵣ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙ ⵖⴻⵍⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K216_6","013_16_6","2KI","16","6","6","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵔⴰⵚⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵉⵍⴰⵜ ⵉ ⴰⵔⴰⵎ. ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵉⵍⴰⵜ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵖⴰⵔ ⵉⵍⴰⵜ, ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K216_7","013_16_7","2KI","16","7","7","ⴰⵃⴰⵣ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵉ ⵜⵉⵖⵍⴰⵜ-ⴼⵉⵍⴰⵙⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷ ⵎⵎⵉⵛ. ⴳⴻⵄⵄⴻⴷ ⴷ ⵜⴼⴻⴽⴽⴻⴷ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵏⵏⵇⴻⵍⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("K216_8","013_16_8","2KI","16","8","8","ⴰⵃⴰⵣ ⵢⵉⵡⵉ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⴰ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K216_9","013_16_9","2KI","16","9","9","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵙⵍⴰ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ. ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⵜ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⵇⵉⵔ ⵓ ⵉⵏⵖⴰ ⵔⴰⵚⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K216_10","013_16_10","2KI","16","10","10","ⴰⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵜⵉⵖⵍⴰⵜ-ⴼⵉⵍⴰⵙⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵓⵛⴰ ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴷⵉ ⴷⵉⵎⴰⵛⵇ. ⴰⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴷ ⵜⵡⴻⵚⵚⴰⴼ ⵏⵏⴻⵙ ⵏ ⵍⴻⴱⵏⵉ, ⵇⴰⵄ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ, ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵔⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K216_11","013_16_11","2KI","16","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵉⴱⵏⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵔⵉⵢⴰ ⴰⵄⴰⵍⵟⴰⵔ. ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵣⵉ ⴷⵉⵎⴰⵛⵇ, ⴰⵇⴰ ⵉⴱⵏⴰ ⵜ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵔⵉⵢⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵣⵉ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("K216_12","013_16_12","2KI","16","12","12","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵊⴻⴵⵉⴷ ⵣⵉ ⴷⵉⵎⴰⵛⵇ, ⵉⵥⵔⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("K216_13","013_16_13","2KI","16","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵉⵙⴻⵢⵢⴻⴱ ⵅⴰⵙ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵏⵏⴻⵙ. ⵉⵙⵙⴼⴰⵔⵔⵖⴻⵖ ⵓⵍⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵏⴻⵙ ⵏ ⵍⴻⵀⵏⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K216_14","013_16_14","2KI","16","14","14","ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵜ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵣⵉ ⵊⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵊⴷⵉⴷ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵊⴷⵉⴷ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K216_15","013_16_15","2KI","16","15","15","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵉⵡⴻⵚⵚⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵓⵔⵉⵢⴰ, ⵉⵏⵏⴰ: “ⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵚⵚⴱⴻⵃ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ ⵍⴰ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⵓ ⵣⴻⴵⴻⵄ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵏⴻⵖⵏⵉ. ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴰⵔⵣⵓⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K216_16","013_16_16","2KI","16","16","16","ⴰⴽⴻⵀⵀⴰⵏ ⵓⵔⵉⵢⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵙ ⵎⵉⵏⵣⵉ ⵉⵡⴻⵚⵚⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("K216_17","013_16_17","2KI","16","17","17","ⴰⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵉⵇⴻⵙⵙ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵉ ⵢⴻⴵⴰⵏ ⵅ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴰⴱⴰⵏⵢⵓⵜ ⵉ ⵅⴰⵙ ⵉⴵⴰⵏ. ⵉⴽⴽⴻⵙ ⵓⵍⴰ ⴷ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵏ ⵡⴰⵎⴰⵏ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏ ⵏⵏⵃⴰⵙ ⵉⵏⵏⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵉⵛⵜ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⵏ ⵡⴻⵥⵔⵓ.    ");
INSERT INTO rift_vpl VALUES ("K216_18","013_16_18","2KI","16","18","18","ⴱⴰⵙⵓ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵜⵓⵖⴰ ⵉⴱⵏⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⵍⴰ ⴷ ⴰⴷⴰⴼ ⵏ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴱⴰⵔⵔⴰ ⵉⴽⴽⴻⵙ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K216_19","013_16_19","2KI","16","19","19","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵃⴰⵣ ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K216_20","013_16_20","2KI","16","20","20","ⴰⵃⴰⵣ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⵃⵉⵣⵇⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K217_1","013_17_1","2KI","17","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⵡⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⵡⴻⵍ ⵀⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⴰ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴻⵙⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K217_2","013_17_2","2KI","17","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K217_3","013_17_3","2KI","17","3","3","ⵛⴰⵍⵎⴰⵏⴰⵙⵙⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵉⵀⵊⴻⵎ ⵅⴰⵙ ⵓⵛⴰ ⵀⵓⵛⵉⵄⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵅⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵍⵊⵉⵣⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K217_4","013_17_4","2KI","17","4","4","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵢⵓⴼⴰ ⴰⵇⴰ ⵀⵓⵛⵉⵄⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ. ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵉⵡⵉ ⵄⴰⴷ ⵍⵊⵉⵣⵢⴰ ⴰⵎ ⵇⴱⴻⵍ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ. ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵓⵛⴰ ⵉⵛⴻⴷⴷ ⵉ-ⵜ ⵙ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K217_5","013_17_5","2KI","17","5","5","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵡⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K217_6","013_17_6","2KI","17","6","6","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵀⵓⵛⵉⵄⴰ, ⵉⵃⴻⵡⵡⴻⵙ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴰⵛⵛⵓⵔ ⵓ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉ-ⵜⴻⵏ ⴷⵉ ⵃⴰⵍⴰⵃ ⵓ ⵖⴰⵔ ⵅⴰⴱⵓⵔ ⵡⴻⵏⵏⵉ ⴷ ⵉⵖⵣⴰⵔ ⵏ ⵊⵓⵣⴰⵏ, ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵎⴰⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_7","013_17_7","2KI","17","7","7","ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅⴹⴰⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵙⴰⴷⵓ ⵉ ⵓⴼⵓⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵓⵎⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("K217_8","013_17_8","2KI","17","8","8","ⴳⴳⵉⵏ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵄⴰⵔⵔⴻⵏ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_9","013_17_9","2KI","17","9","9","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴷⵍⵉⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵇⵉⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵍⴻⴳⵄⵓⴷⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⵡⴰⵀ, ⵣⵉ ⵍⴱⵓⵔⵊ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⴰⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ ⵙ ⵉⵖⴻⴱⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_10","013_17_10","2KI","17","10","10","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵅ ⴽⵓⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵓ ⵙⴰⴷⵓ ⴽⵓⵍ ⴰⵣⵖⴰⵔ ⴷ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("K217_11","013_17_11","2KI","17","11","11","ⵏⵉⵜⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵄⵓⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴷ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⴰⵍⴰⵎⵉ ⵙⵄⴰⵔⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K217_12","013_17_12","2KI","17","12","12","ⵏⵉⵜⵏⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉ ⵅ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("K217_13","013_17_13","2KI","17","13","13","ⵙⵉⴷⵉ ⵉⵄⵍⴻⵎ ⵉ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓ ⵙ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵎⵡⴰⵍⴰⵡ, ⵉⵏⵏⴰ: “ⵜⵓⴱⴻⵎ ⵣⵉ ⵜⴱⵔⵉⴷⵉⵏ ⵏⵡⴻⵎ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵓ ⵃⴹⴰⵎ ⵅ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⴷ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵉ ⵣⵉ ⵓⵎⵓⵔⴻⵖ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_14","013_17_14","2KI","17","14","14","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵓ ⵜⵓⵖⴰ ⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴳⴳⵉⵏ ⵜⵜⵉⵇⴻⵜ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_15","013_17_15","2KI","17","15","15","ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵉⵛⵀⴻⴷ. ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴱⴻⵟⵟⵍⴻⵏ. ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵅ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⴰⵇⴰ ⴰⴷ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K217_16","013_17_16","2KI","17","16","16","ⵏⵉⵜⵏⵉ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓ ⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵄⴻⴱⴷⴻⵏ ⵉ ⴱⴰⵄⴰⵍ.    ");
INSERT INTO rift_vpl VALUES ("K217_17","013_17_17","2KI","17","17","17","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵛⵓⵇⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵙⵙⵅⴻⴷⵎⴻⵏ ⴰⵄⴻⵣⵣⴻⵎ ⴷ ⵜⴳⴻⵣⵣⴰⵏⵜ. ⵏⵉⵜⵏⵉ ⵣⵣⴻⵏⵣⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵙⵄⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_18","013_17_18","2KI","17","18","18","ⵅ ⵓⵢⴻⵏⵏⵉ ⵉⵙⵄⴰⵔ ⵙⵉⴷⵉ ⴰⵟⵟⴰⵙ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K217_19","013_17_19","2KI","17","19","19","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵢⴰⵀⵓⴷⴰ ⵡⴰⵔ ⵉⵃⴹⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⴳⴳⵉⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_20","013_17_20","2KI","17","20","20","ⵙⵉⴷⵉ ⵉⵏⴹⴰⵔ ⵎⴰⵔⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⴽⴻⵛⵛⴰⴹⴻⵏ ⴰⵍⴰⵎⵉ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K217_21","013_17_21","2KI","17","21","21","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵇⵍⴻⵄ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⴳⴳⵉⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵢⴰⵔⵓⴱⵄⴰⵎ ⵎⴰⵛⴰ ⵉⴱⴹⴰ ⵉⵙⵔⴰⵉⵍ ⵅ ⵙⵉⴷⵉ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_22","013_17_22","2KI","17","22","22","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴽⴽⵉⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵉ ⵉⴳⴳⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵃⴻⵢⵢⴷⴻⵏ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("K217_23","013_17_23","2KI","17","23","23","ⴰⵍⴰⵎⵉ ⵉⵏⴹⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ⵙⵙⵓⴼⴼⵖⴻⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴰⵛⵛⵓⵔ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K217_24","013_17_24","2KI","17","24","24","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵢⵉⵡⵉ-ⴷⴷ ⵉⵡⴷⴰⵏ ⵣⵉ ⴱⴰⴱⵉⵍ ⴷ ⴽⵓⵜⴰ ⴷ ⵄⴰⵡⴰ ⴷ ⵃⴰⵎⴰⵜ ⴷ ⵙⴼⴰⵔⵡⴰⵢⵉⵎ, ⵓⵛⴰ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⴳⴳⵉⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K217_25","013_17_25","2KI","17","25","25","ⵓⵎⵉ ⴷⵉⵏⵏⵉ ⵣⴻⴷⵖⴻⵏ ⵄⴰⴷ ⵛⵡⴰⵢⵜ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴳⴳⵯⵉⴷⴻⵏ ⵛⴰ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵉⵢⵔⴰⴷⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_26","013_17_26","2KI","17","26","26","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⴰⴽ-ⴷ ⵓ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵏⵏⴰⵏ: “ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵓ ⵜⴻⵙⵙⵣⴻⴷⵖⴻⴷ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵅ ⵓⵢⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵢⵔⴰⴷⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵓ ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K217_27","013_17_27","2KI","17","27","27","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵢⵓⵎⵓⵔ, ⵉⵏⵏⴰ: “ⵊⵊⴻⵎ ⴰⴷ ⴷⵉⵏ ⵉⵔⴰⵃ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵏⴻⴷⵀⴻⵎ ⵙⵙⴻⵏⵏⵉ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⵉⵏ ⵔⴰⵃⴻⵏ ⵓ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K217_28","013_17_28","2KI","17","28","28","ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵏⴻⴷⵀⴻⵏ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵣⴷⴻⵖ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ. ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K217_29","013_17_29","2KI","17","29","29","ⵎⴰⵛⴰ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵏⵉ ⴰⴷ ⵉⴳⴳ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⴱⵏⴰⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ, ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K217_30","013_17_30","2KI","17","30","30","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⴱⵉⵍ ⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙⵓⴽⴽⵓⵜ-ⴱⵏⵓⵜ, ⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴽⵓⵜⴰ ⴳⴳⵉⵏ ⵏⴰⵔⵊⴰⵍ, ⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵃⴰⵎⴰⵜ ⴳⴳⵉⵏ ⴰⵛⵉⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("K217_31","013_17_31","2KI","17","31","31","ⵓ ⵉⵄⴰⵡⵉⵢⵢⴻⵏ ⴳⴳⵉⵏ ⵉⵡⵔⴰⴼⴻⵏ ⵏ ⵏⵉⴱⵃⴰⵣ ⴷ ⵜⴰⵔⵜⴰⵇ, ⵓⵛⴰ ⵉⵙⴰⴼⴰⵔⵡⴰⵢⵢⵉⵏ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵉ ⴰⴷⵔⴰⵎⵎⵉⵍⵉⴽ ⴷ ⵄⴰⵏⴰⵎⵎⵉⵍⵉⵅ, ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵙⴼⴰⵔⵡⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K217_32","013_17_32","2KI","17","32","32","ⵙ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⴷ ⵉⵊⵊ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵚⴼⵓⴼ ⵏⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵍⴻⴳⵄⵓⴷⵉ, ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K217_33","013_17_33","2KI","17","33","33","ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓⵍⴰ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K217_34","013_17_34","2KI","17","34","34","ⴰⵍ ⴰⵙⵙ-ⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵟⵟⴱⴰⵢⴻⵄ ⵏⵙⴻⵏ ⵏ ⵣⵉⵛ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵏ ⵛⴰ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⵉⴹⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵍⵓⵎⵓⵔ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵅ ⴰⵢⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵉⵙⴻⵎ ‘ⵉⵙⵔⴰⵉⵍ’. ");
INSERT INTO rift_vpl VALUES ("K217_35","013_17_35","2KI","17","35","35","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵡⴻⵇⵇⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⴰⴹⴰⵔⴻⵎ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵄⴻⴱⴱⴷⴻⵎ ⵓ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⴰⵡⵢⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("K217_36","013_17_36","2KI","17","36","36","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵊⵊⵀⴻⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵙ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ, ⵓ ⴰⴷ ⴰⵙ ⵜⵙⴻⵊⴷⴻⵎ ⵓ ⴰⴷ ⴰⵙ ⵜⴰⵡⵢⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("K217_37","013_17_37","2KI","17","37","37","ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵍⵓⵎⵓⵔ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⵎ ⴽⵓⵍ ⴰⵙⵙ. ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K217_38","013_17_38","2KI","17","38","38","ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⵓⵎ ⵍⵄⴰⵀⴷ ⵉ ⴳⴳⵉⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("K217_39","013_17_39","2KI","17","39","39","ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("K217_40","013_17_40","2KI","17","40","40","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ, ⵎⴰⵛⴰ ⴳⴳⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴱⴱⴰⵔⵜ ⵏⵙⴻⵏ ⵏ ⵣⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("K217_41","013_17_41","2KI","17","41","41","ⵍⴻⴳⵏⵓⵙ ⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ ⵓ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓⵍⴰ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ ⴷⴻⴳ ⵓⵎⵓⵔ ⴷ ⵉⵊⵊⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵄⴰⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K218_1","013_18_1","2KI","18","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵀⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵃⵉⵣⵇⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K218_2","013_18_2","2KI","18","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⴱⵉ, ⵢⴻⴵⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K218_3","013_18_3","2KI","18","3","3","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("K218_4","013_18_4","2KI","18","4","4","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵍⴻⴳⵄⵓⴷⵉ, ⵢⴰⵔⵥⴰ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵀⴷⴻⵎ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵛⴰ ⵉⵍⴱⴻⵣ ⴰⴼⵉⵖⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵎⵓⵙⴰ, ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⴰⵍ ⵓⵙⵙⴰⵏ ⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵏⴰⵃⵓⵛⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K218_5","013_18_5","2KI","18","5","5","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴻⵍ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵏⵉⵖ ⴷⴷⴰⵔⴻⵏ ⵇⴱⴻⵍ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⵎ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K218_6","013_18_6","2KI","18","6","6","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴹⴼⴰⵔ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵃⴻⵢⵢⴻⴷ ⵛⴰ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K218_7","013_18_7","2KI","18","7","7","ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ. ⵎⴰⵏⵉ ⵎⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵃ, ⵜⵓⵖⴰ ⵉⴼⵍⴻⵃ. ⵏⴻⵜⵜⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⴻⵅⵅⴰⵔ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K218_8","013_18_8","2KI","18","8","8","ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⵍ ⵖⴰⵣⵣⴰ ⴰⴽ-ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵙ, ⵣⵉ ⵍⴱⵓⵔⵊ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴰⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K218_9","013_18_9","2KI","18","9","9","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵀⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵛⴰⵍⵎⴰⵏⴰⵙⵙⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("K218_10","013_18_10","2KI","18","10","10","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵃⵓⵛⵉⵄⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵟⵟⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K218_11","013_18_11","2KI","18","11","11","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵏⴷⴻⵀ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴰⵛⵛⵓⵔ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⴷⵉ ⵃⴰⵍⴰⵃ ⵓ ⵖⴰⵔ ⵅⴰⴱⵓⵔ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵖⵣⴰⵔ ⵏ ⵊⵓⵣⴰⵏ, ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵎⴰⴷⴰⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K218_12","013_18_12","2KI","18","12","12","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⵔⵥⵉⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷ ⴰⵙ ⵙⵍⵉⵏ ⵓ ⵡⴰⵔ ⵜ ⴳⴳⵉⵏ.   * ");
INSERT INTO rift_vpl VALUES ("K218_13","013_18_13","2KI","18","13","13","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵉⴼⴼⴻⵖ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵙⵙⵓⵔ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵙ ⵉⵖⴻⴱⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵃⴻⵡⵡⴻⵙ ⵉ-ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K218_14","013_18_14","2KI","18","14","14","ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵖⴰⵔ ⵍⴰⵅⵉⵛ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ! ⴱⴻⵄⵄⴻⴷ ⵅⴰⴼⵉ! ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⴼⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⴰⴷ ⵜ ⵅⴻⴵⵚⴻⵖ.” ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵛⵜ ⵏ ⵍⵊⵉⵣⵢⴰ ⵅ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ: ⵜⴻⵍⵜ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵜⵍⴰⵜⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K218_15","013_18_15","2KI","18","15","15","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵡⵛⴰ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K218_16","013_18_16","2KI","18","16","16","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵇⴻⵙⵙ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵔⵔⴰ ⵡⵓⵔⴻⵖ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵏ ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵖⴻⴵⴻⴼ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵙ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K218_17","013_18_17","2KI","18","17","17","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵍⵊⵉⵏⵉⵔⴰⵍ ⴰⴽ-ⴷ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴷ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⴰⵅⵉⵛ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵇⴰⴷⵓⵙ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵓⵢⴻⵍⵎⴰⵏ ⵏ ⵙⴻⵏⵏⴻⵊ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵢⵓⵄⵍⴰⵏ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵚⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K218_18","013_18_18","2KI","18","18","18","ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵊⴻⴵⵉⴷ. ⵅⴻⵏⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔⵙⴻⵏ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴽ-ⴷ ⵓⵎⴰⵔⵉⵔ ⵛⵉⴱⵏⴰ ⴷ ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ, ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("K218_19","013_18_19","2KI","18","19","19","ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⵉⵎ ⵉ ⵃⵉⵣⵇⵉⵢⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ⵎⴰⵏ ⴰⵜⴻⵛⵍⵉ-ⵢⴰ ⵉ ⵅ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("K218_20","013_18_20","2KI","18","20","20","ⴰⵇⴰ-ⵜ ⴷ ⵍⵀⴰⵔⴷ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵡⴰⵀⴰ, ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵛⵛⵡⴰⵔ ⴷ ⵊⵊⴻⵀⴷ ⵉ ⵓⵎⴻⵏⵖⵉ! ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵅ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵖⴻⵡⵡⵖⴻⴷ ⵅⴰⴼⵉ? ");
INSERT INTO rift_vpl VALUES ("K218_21","013_18_21","2KI","18","21","21","ⵅⵣⴰⵔ, ⵍⴻⵅⵅⵓ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵎⵉⵚⵔⴰ, ⵅ ⵓⵖⴰⵏⵉⵎ ⵏⵏⵉ ⵉⵏⵏⴹⴻⴼⵙⴻⵏ, ⵡⴻⵏⵏⵉ, ⵓⵎⵉ ⵃⴻⴷ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵄⴻⵎⵎⴻⴷ, ⵉⵜⵜⴻⵊⵊⵓⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜ. ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⴻⵛⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K218_22","013_18_22","2KI","18","22","22","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷ ⴰⵢⵉ ⵜⵉⵏⵉⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵛⴻⵍ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!’, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ: ‘ⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵣⵉ ⵉⵃⴻⵢⵢⴻⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵍⴻⴳⵄⵓⴷⵉ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ, ⵓ ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴱⴻⵏⴷⵇⴻⵎ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ-ⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ?’ ");
INSERT INTO rift_vpl VALUES ("K218_23","013_18_23","2KI","18","23","23","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵓⵎⵃⴰⵔⵔⴻⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵎⴰⵍⴰ ⵛⴻⴽ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵓⵢⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("K218_24","013_18_24","2KI","18","24","24","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵏⵏⵇⴻⵍⴱⴻⴷ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵍⵡⴰⵍⵉ, ⵡⴻⵏⵏⵉ ⵇⴰⵄ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵎⵉⵚⵔⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("K218_25","013_18_25","2KI","18","25","25","ⵄⴰⵡⴻⴷ, ⵎⴰⵖⴰⵔ ⵎⴰ ⵏⴻⵛⵛ ⴳⴻⵄⵄⴷⴻⵖ-ⴷⴷ ⴹⵉⴷⴷ ⵏ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵔⴻⴷⴷⴵⴻⵖ ⴱⵍⴰ ⵙⵉⴷⵉ? ⵙⵉⴷⵉ ⵉⵏⵉ ⴰⵢⵉ: ‘ⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⴰⵔⴻⴷⴷⴻⴵ ⵉ-ⵜⵜ!’” ");
INSERT INTO rift_vpl VALUES ("K218_26","013_18_26","2KI","18","26","26","ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ ⴷ ⵛⵉⴱⵏⴰ ⴷ ⵢⵓⵡⴰⵅ ⵉ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ: “ⵙⵉⵡⴻⵍ ⵄⴰⴼⴻⴽ ⵙ ⵉⵍⴻⵙ ⵏ ⵜⵔⴰⵎⵉⵜ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⴼⵀⴻⵎ ⴰⵙ ⵎⵍⵉⵃ. ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵙⵙⵉⵡⵉⵍ ⵙ ⵜⵢⴰⵀⵓⴷⴻⵛⵜ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⴵⴰⵏ ⵅ ⵍⵃⵉⴹ.” ");
INSERT INTO rift_vpl VALUES ("K218_27","013_18_27","2KI","18","27","27","ⵎⴰⵛⴰ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔⴻⴽ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵃⵉⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⵉⵖ ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⴰⴽⵉⴷⵡⴻⵎ ⴰⴷ ⵛⵛⴻⵏ ⴰⵙⵓⴼⴼⴻⵖ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵙⵡⴻⵏ ⵉⴱⴻⵛⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("K218_28","013_18_28","2KI","18","28","28","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⵀⴻⴷ ⵙ ⵜⵢⴰⵀⵓⴷⴻⵛⵜ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ! ");
INSERT INTO rift_vpl VALUES ("K218_29","013_18_29","2KI","18","29","29","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ‘ⵃⴹⴰⵎ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵖⴻⵛⵛⵉ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K218_30","013_18_30","2KI","18","30","30","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⴰⴷ ⵜᵉⵜⵜⴻⵛⵍⴻⵎ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵉⵏⵉⵎ: ⵙⵉⴷⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵏⵉⵛⴰⵏ ⵓ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵡⵛⵉ ⵛⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ.’ ");
INSERT INTO rift_vpl VALUES ("K218_31","013_18_31","2KI","18","31","31","ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ‘ⴳⴳⴻⵎ ⴰⵢⵉ ⴰⵔⵔⴰⵢ ⵓⵛⴰ ⴼⴼⵖⴻⵎ-ⴷⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔⵉ, ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵛⵛ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵣⴻⴳ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵉⵙⵓ ⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵏⵓ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("K218_32","013_18_32","2KI","18","32","32","ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ: ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴻⴷⴷⴰⵔⴻⵎ, ⵡⴰⵔ ⵜⵎⴻⵜⵜⵉⵎ ⵛⴰ. ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵅⵎⵉ ⵉⵇⵇⴰⵔ: ⵙⵉⴷⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ! ");
INSERT INTO rift_vpl VALUES ("K218_33","013_18_33","2KI","18","33","33","ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ? ");
INSERT INTO rift_vpl VALUES ("K218_34","013_18_34","2KI","18","34","34","ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵃⴰⵎⴰⵜ ⴷ ⴰⵔⴼⴰⴷ? ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵙⴼⴰⵔⵡⴰⵢⵉⵎ ⴷ ⵀⴰⵏⵉⵄ ⴷ ⵄⵉⵡⴰ? ⵎⴰ ⴼⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("K218_35","013_18_35","2KI","18","35","35","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵖⵏⵉ ⵉ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⴼⴻⴽⴽ ⵙⵉⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ?’” ");
INSERT INTO rift_vpl VALUES ("K218_36","013_18_36","2KI","18","36","36","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵙⴻⵖⴷ, ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵎⴰⵖⴰⵔ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵜⴰⵔⵔⵉⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("K218_37","013_18_37","2KI","18","37","37","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴽ-ⴷ ⵛⵉⴱⵏⴰ ⴰⵎⴰⵔⵉⵔ, ⴷ ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ, ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵛⴰⵔⵔⴳⴻⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ. ⵏⵉⵜⵏⵉ ⵃⴰⵊⴰⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K219_1","013_19_1","2KI","19","1","1","ⵓⵎⵉ ⵜⴻⵏ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⴷⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.    ");
INSERT INTO rift_vpl VALUES ("K219_2","013_19_2","2KI","19","2","2","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⴰⵍⵢⴰⵇⵉⵎ, ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴷ ⵛⴰⴱⵏⴰ, ⴰⵎⴰⵔⵉⵔ, ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ. ");
INSERT INTO rift_vpl VALUES ("K219_3","013_19_3","2KI","19","3","3","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ: ‘ⴰⵙⵙ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⵏ ⵡⴻⵄⵇⴰⴱ ⵓ ⵏ ⵓⴱⴻⵀⴷⴻⵍ, ⵎⴰⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵡⴹⴻⵏ-ⴷⴷ ⴰⵍ ⴰⵔⵣⴰⵎ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵊⵊⴻⵀⴷ ⵉ ⵜⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("K219_4","013_19_4","2KI","19","4","4","ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵙⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵣⵉ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵓ ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵄⴰⵇⴻⴱ ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵙⵍⴰ. ⵙⴳⴻⵄⵄⴻⴷ ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵥⴰⴵⵉⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴱⴰⵇⵉ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴻⵏ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("K219_5","013_19_5","2KI","19","5","5","ⴰⵎⵎⵓ ⵉⵡⴹⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵖⴰⵔ ⵉⵛⴰⵄⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K219_6","013_19_6","2KI","19","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵛⴰⵄⵢⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ ⵉ ⵙⵉⴷⵉⵜⵡⴻⵎ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵜⴻⵙⵍⵉⴷ ⵛⴻⴽ, ⵉ ⵣⵉ ⵉ ⴷ ⴰⵢⵉ ⵛⴻⵇⵇⴼⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K219_7","013_19_7","2KI","19","7","7","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⵙ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵓ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵏⵖⴻⵖ ⴷⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵙ ⵙⵙⵉⴼ.’” ");
INSERT INTO rift_vpl VALUES ("K219_8","013_19_8","2KI","19","8","8","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵢⵓⴼⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵍⵉⴱⵏⴰ, ⵎⴰⵖⴰⵔ ⵉⵙⵍⴰ ⴰⵇⴰ ⵉⵇⵍⴻⵄ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵉⴼⴼⴻⵖ ⵣⵉ ⵍⴰⵅⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("K219_9","013_19_9","2KI","19","9","9","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵇⴰ ⵏⵏⴰⵏ ⵅ ⵜⵉⵔⵀⴰⵇⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴽⵓⵛ: “ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⴽ ⵉⵎⵎⵏⴻⵖ!”, ⵉⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K219_10","013_19_10","2KI","19","10","10","“ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴰⴽ-ⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵛⴻⴽ ⵉⵖⵡⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵡⴻⵏⵏⵉ ⵅ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⴰⵎ ⵉⵇⵇⴰⵔ: ⵓⵔⵛⴰⵍⵉⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴻⵟⵟⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("K219_11","013_19_11","2KI","19","11","11","ⵅⵣⴰⵔ, ⵜⴻⵙⵍⵉⴷ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ. ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("K219_12","013_19_12","2KI","19","12","12","ⵎⴰ ⴼⴻⴽⴽⴻⵏ ⵜⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ? ⵊⵓⵣⴰⵏ ⴷ ⵃⴰⵔⴰⵏ ⴷ ⵔⵚⵉⴼ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⴷⴰⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴰⵍⴰⵙⵙⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("K219_13","013_19_13","2KI","19","13","13","ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵎⴰⵜ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴼⴰⴷ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴼⴰⵔⵡⴰⵢⵉⵎ ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵀⴰⵏⴰⵄ ⴷ ⵄⵉⵡⵡⴰ?’” ");
INSERT INTO rift_vpl VALUES ("K219_14","013_19_14","2KI","19","14","14","ⵃⵉⵣⵇⵉⵢⴰ ⵉⴽⵙⵉ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵖⵔⴰ ⵉ-ⵜⴻⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⴻⵏⵜ ⵃⵉⵣⵇⵉⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K219_15","013_19_15","2KI","19","15","15","ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵃⵉⵣⵇⵉⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵊⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ! ⵛⴻⴽ, ⵡⴰⵀ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K219_16","013_19_16","2KI","19","16","16","ⴰ ⵙⵉⴷⵉ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ, ⵙⴻⵍ! ⴰ ⵙⵉⴷⵉ, ⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⵣⴰⵔ! ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵙⴰⵏⵃⴰⵔⵉⴱ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K219_17","013_19_17","2KI","19","17","17","ⴷ ⵜⵉⴷⴻⵜⵜ, ⴰ ⵙⵉⴷⵉ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ ⵇⴹⴰⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ, ⵅⴰⵔⵔⴱⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K219_18","013_19_18","2KI","19","18","18","ⵓ ⵏⴹⴰⵔⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵓⴼⵓⵙ ⵏ ⵢⴻⵡⴷⴰⵏ ⵡⴰⵀⴰ, ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵎⵃⴰⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K219_19","013_19_19","2KI","19","19","19","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("K219_20","013_19_20","2KI","19","20","20","ⵅⴻⵏⵏⵉ ⵉⵙⴻⴽⴽ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵙ ⵎⵉⵏⵣⵉ ⵖⴰⵔⵉ ⵜⴻⵥⵥⵓⴵⴻⴷ ⵅ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("K219_21","013_19_21","2KI","19","21","21","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ: ‘ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵜⴻⵙⵙⴻⵃⵇⴰⵔ ⵉ ⵛⴻⴽ, ⵜⴻⵙⵜⴻⵀⵣⴰ ⵣⵣⴰⵢⴻⴽ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵀⴻⵣⵣⴰ ⴰⵣⴻⴵⵉⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵛ! ");
INSERT INTO rift_vpl VALUES ("K219_22","013_19_22","2KI","19","22","22","ⵡⵉ ⵣⵉ ⵜⴻⵙⵜⴻⵀⵣⵉⴷ ⵓ ⵡⵉ ⴷⵉ ⵜⵛⴻⵇⵇⴼⴻⴷ? ⵡⵉ ⵅⴻⴼ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ, ⵓ ⵎⵉⵅⴻⴼ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ? ⵛⴻⴽ ⵜᵉⵜⵜⵖⴻⵏⵏⴰⵏⴻⴷ ⵅ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("K219_23","013_19_23","2KI","19","23","23","ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⴻⵙⵜⴻⵀⵣⵉⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵜⴻⵏⵏⵉⴷ: ⵙ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉⵏⵓ ⴳⴻⵄⵄⴷⴻⵖ ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⵓⴱⵏⴰⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵎⴻⵖ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵙ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵢⵓⵄⵍⴰⵏ ⵓⵍⴰ ⴷ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵙⵙⵉⴱⵔⵉ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵡⴰⵔⴻⵢⵢⴻⵃ ⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ, ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K219_24","013_19_24","2KI","19","24","24","ⵏⴻⵛⵛ ⵖⵣⵉⵖ ⴰⵏⵓⵜⴻⵏ, ⵙⵡⵉⵖ ⴰⵎⴰⵏ. ⵙ ⵜⴰⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵙⵙⵉⵥⵖⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K219_25","013_19_25","2KI","19","25","25","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⴳⴳⵉⵖ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⵡⵛⵉⵖ ⴰⵙ ⵓⴷⴻⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ? ⵍⴻⵅⵅⵓ ⵊⵊⵉⵖ ⵜ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K219_26","013_19_26","2KI","19","26","26","ⵉⵎⴻⵣⴷⴰⵖ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵔⵅⵓⵏ, ⴰⵔⵥⵉⵏ ⵓ ⵙⴻⴹⵃⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵎ ⵡⴻⴼⵙⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⵎ ⵓⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ, ⴰⵎ ⵓⵍⵓⵎ ⵅ ⵜⵣⴻⵖⵡⵉⵏ, ⵓ ⴰⵎ ⵉⵎⴻⵏⴷⵉ ⵉⵛⴻⵎⴹⴻⵏ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K219_27","013_19_27","2KI","19","27","27","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵖⵉⵎⵉ ⵏⵏⴻⵛ ⴷ ⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ ⴷ ⵡⴻⵄⵇⴰⴱ ⵏⵏⴻⵛ ⴷ ⵓⵖⴻⵡⵡⴻⵖ ⵏⵏⴻⵛ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("K219_28","013_19_28","2KI","19","28","28","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵖⴻⵡⵡⵖⴻⴷ ⵅⴰⴼⵉ ⵓ ⵜⵓⴼⴼⴻⵜ ⵏⵏⴻⵛ ⵜⵉⵡⴻⴹ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⴰⴷ ⴰⵛ ⵙⵙⴻⴽⴽⴻⵖ ⵜⴰⵙⴻⵏⵏⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵙⵍⵉⵎⴻⵜ ⵊⴰⵔ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⴷⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⴷⴰ.’ ");
INSERT INTO rift_vpl VALUES ("K219_29","013_19_29","2KI","19","29","29","ⴷ ⵜⴰ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ: ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ-ⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵎⵉⵏ ⵖⴰ ⵉⵖⴻⵎⵎⵢⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵉⵖⴻⵎⵎⵢⴻⵏ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵜⵣⴰⵔⵄⴻⵎ ⵓ ⴰⴷ ⵜⴻⵎⵊⴰⵔⴻⵎ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ, ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵥⵥⵓⵎ ⵜⵣⴰⵢⴰⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K219_30","013_19_30","2KI","19","30","30","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵏⵏⴻⵊⵎⴻⵏ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵉⵡⵡⴻⵜ ⵄⴰⵡⴻⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵓ ⵙⴻⵏⵏⴻⵊ ⴰⴷ ⵢⴰⵡⵉ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K219_31","013_19_31","2KI","19","31","31","ⵎⴰⵖⴰⵔ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵉⴼⴼⴻⵖ ⵎⵉⵏ ⵉⵏⵏⴻⵊⵎⴻⵏ, ⴰⵙⴰⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴷ ⵉⴳⴳ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K219_32","013_19_32","2KI","19","32","32","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⴷⴻⴼ ⵛⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵛⵛⵉⵜ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⴼⵍⵉⵜⵛⴰ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵉⵇⴰⵔⵔⴻⴱ ⵛⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⴱⴻⵇⵇⵉⴹⴻⵏ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⴰⵊ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K219_33","013_19_33","2KI","19","33","33","ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷⴷ ⵖⴰ ⵢⴰⵙ, ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ. ⵡⴰⵔ ⵉⵜⵜⵉⴷⵉⴼ ⵛⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K219_34","013_19_34","2KI","19","34","34","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵍⵇⵉⵖ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵙⵙⵏⴻⵊⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ.’” ");
INSERT INTO rift_vpl VALUES ("K219_35","013_19_35","2KI","19","35","35","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴼⴼⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵖⴰ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵛⵛⵓⵔ. ⵓⵎⵉ ⵉ ⴷⴷ ⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴷ ⵍⵅⴻⵛⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K219_36","013_19_36","2KI","19","36","36","ⵓⵛⴰ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵢⴰⵔⵥⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵉⵔⵓⵃ ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵏⵉⵏⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("K219_37","013_19_37","2KI","19","37","37","ⵓⵎⵉ ⵉⵙⵊⴻⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵏⵉⵙⵔⵓⵅ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷⵔⴰⵎⵎⵉⵍⵉⴽ ⴷ ⵛⴰⵔⴰⵚⴰⵔ ⵏⵖⵉⵏ ⵜ ⵙ ⵙⵙⵉⴼ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵔⴰⵔⴰⵜ. ⵎⵎⵉⵙ ⴰⵙⴰⵔⵃⴰⴷⴷⵓⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K220_1","013_20_1","2KI","20","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵃⵍⴻⵛ ⵃⵉⵣⵇⵉⵢⴰ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⴰⵛ ⵉⵏⴻⵇⵇⴻⵏ. ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴻⵡⵛ ⵍⵓⵎⵓⵔⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ, ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ ⵄⴰⴷ ⴽⵜⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("K220_2","013_20_2","2KI","20","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵃⵉⴹ ⵓⵛⴰ ⵉⵥⵓⴵ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K220_3","013_20_3","2KI","20","3","3","“ⴰ, ⵙⵉⴷⵉ, ⵄⵇⴻⵍ ⴰⵇⴰ ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵙ ⵍⴰⵎⴰⵏ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⵓⵍ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵓ ⴳⴳⵉⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ⵓⵛⴰ ⵉⴱⴷⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵜⵜⵔⵓ ⵙ ⵊⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("K220_4","013_20_4","2KI","20","4","4","ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵉⴼⴼⵉⵖ ⵉⵛⴰⵄⵢⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K220_5","013_20_5","2KI","20","5","5","“ⵄⵇⴻⴱ, ⵉⵏⵉ ⵉ ⵃⵉⵣⵇⵉⵢⴰ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ: ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵛ ⵓ ⵥⵔⵉⵖ ⵉ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⴰⴷ ⵛⴻⴽ ⵙⵙⴳⴻⵏⴼⵉⵖ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K220_6","013_20_6","2KI","20","6","6","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵏⵉⵖ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵓⵍⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵍⵇⵉⵖ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ.’” ");
INSERT INTO rift_vpl VALUES ("K220_7","013_20_7","2KI","20","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉⵛⴰⵄⵢⴰ: “ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵜⴰⵣⴰⵔⵜ!” ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ, ⵙⵙⴰⵔⵙⴻⵏ ⵅ ⵓⴱⵓⵄⵔⵓⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⴳⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("K220_8","013_20_8","2KI","20","8","8","ⵃⵉⵣⵇⵉⵢⴰ ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⵉ ⵉⵛⴰⵄⵢⴰ: “ⵎⴰⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("K220_9","013_20_9","2KI","20","9","9","ⵉⵏⵏⴰ ⵉⵛⴰⵄⵢⴰ: “ⴰⵢⴰ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⵇⴼⴻⵍ ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ: ‘ⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔ ⵜⵉⵍⵉ ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵉⵖ ⴰⴷ ⴷⴷ-ⵜⴻⵄⵇⴻⴱ ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ?’” ");
INSERT INTO rift_vpl VALUES ("K220_10","013_20_10","2KI","20","10","10","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ: “ⵉⵀⵡⴻⵏ ⵉ ⵜⵉⵍⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵣⵣⵓⴳⴳⴰⵔ ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ, ⵍⵍⴰ, ⴻⵊⵊ ⵜⵉⵍⵉ ⴰⴷ ⵜⴻⵄⵇⴻⴱ ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("K220_11","013_20_11","2KI","20","11","11","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵊⵊⴰ ⵜⵉⵍⵉ ⴰⴷ ⵜⴻⵄⵇⴻⴱ ⵅ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵉ ⵅ ⵜⴻⵀⵡⴰ ⵅ ⴷⴷⵔⵓⵊ ⵏ ⴰⵃⴰⵣ: ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K220_12","013_20_12","2KI","20","12","12","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴱⴰⵔⴰⴷⵓⵅ-ⴱⴰⵍⴰⴷⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵍⴰⴷⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵜⵉⴱⵔⴰⵜⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵍⴰ ⴰⵇⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("K220_13","013_20_13","2KI","20","13","13","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵙⵍⴰ ⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏⵏⴻⵙ: ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵄⵟⵓⵔ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵍⴻⵀⵔⵉ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵏ ⵜⵅⵓⴱⴰⵢ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷ ⴰⵙⴻⵏ ⵜ ⵉⵙⵙⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K220_14","013_20_14","2KI","20","14","14","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵏⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵓ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔⴻⴽ?” ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ, ⵣⵉ ⴱⴰⴱⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("K220_15","013_20_15","2KI","20","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ?” ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜ ⵙⵙⴻⵛⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("K220_16","013_20_16","2KI","20","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵛⴰⵄⵢⴰ ⵉ ⵃⵉⵣⵇⵉⵢⴰ: “ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("K220_17","013_20_17","2KI","20","17","17","‘ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵎⴻⵍⵎⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⴰⵍ ⴰⵙⵙ-ⴰ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵡⴰⵍⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K220_18","013_20_18","2KI","20","18","18","ⴰⴷ ⴰⵡⵢⴻⵏ ⵓⵍⴰ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⴽ, ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵜⴻⵊⵊⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("K220_19","013_20_19","2KI","20","19","19","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ ⵉ ⵉⵛⴰⵄⵢⴰ: “ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ ⵉⵚⴱⴻⵃ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵏⵉⵖ ⵍⵍⴰ, ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⴷ ⵍⴰⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("K220_20","013_20_20","2KI","20","20","20","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴰⵢⴻⵍⵎⴰⵎ ⴷ ⵓⵇⴰⴷⵓⵙ ⵏ ⵡⴰⵎⴰⵏ ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⵏⴷⴻⵀ ⴰⵎⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K220_21","013_20_21","2KI","20","21","21","ⵃⵉⵣⵇⵉⵢⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵎⵎⵉⵙ ⵎⴰⵏⴰⵙⵙⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K221_1","013_21_1","2KI","21","1","1","ⵜⵓⵖⴰ ⵖⴰⵔ ⵎⴰⵏⴰⵙⵙⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅⴻⵎⵙⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵀⴰⴼⵚⵉ-ⴱⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("K221_2","013_21_2","2KI","21","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K221_3","013_21_3","2KI","21","3","3","ⵏⴻⵜⵜⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⵄⴷⴻⵍ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵀⴷⴻⵎ ⴱⴰⴱⴰⵙ ⵃⵉⵣⵇⵉⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵉ ⴱⴰⵄⴰⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵜ ⵉⴳⴳⴰ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⵄⴱⴻⴷ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K221_4","013_21_4","2KI","21","4","4","ⵉⵙⵙⴱⴻⴷⴷ ⵄⴰⵡⴻⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵉ ⵅ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("K221_5","013_21_5","2KI","21","5","5","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K221_6","013_21_6","2KI","21","6","6","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵎⵎⵉⵙ ⴰⴷ ⵢⴻⴽⴽ ⵅ ⵜⵎⴻⵙⵙⵉ ⵓ ⵉⵙⵙⵅⴻⴷⴷⴰⵎ ⵜⴰⴱⴻⵣⴳⵉⵡⵜ ⵓ ⵜⵓⵖⴰ ⵉⵜⵜⴳⴻⵣⵣⴻⵏ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ, ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵟⵟⴰⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵄⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K221_7","013_21_7","2KI","21","7","7","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴷⴰⵡⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ: “ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⴼⴰⵔⵣⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K221_8","013_21_8","2KI","21","8","8","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⵄⴰⴷ ⴰⴹⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⵛⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⵎⵖⵉⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵃⴹⴰⵏ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵓⵎⵓⵔⴻⵖ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("K221_9","013_21_9","2KI","21","9","9","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵎⴰⵏⴰⵙⵙⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⴰⵔⴻⵏⵢⴻⵏ ⴷⵉ ⵜⵓⵄⵄⴻⴼⵏⴰ ⵎⴰⵀⵓ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵎⵃⴰ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K221_10","013_21_10","2KI","21","10","10","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K221_11","013_21_11","2KI","21","11","11","“ⵎⵉⵏⵣⵉ ⵎⴰⵏⴰⵙⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴳⴳⴰ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ, ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵄⵄⴻⴼⵏⴰ ⵎⴰⵀⵓ ⵅ ⴰⵢⵜ ⵏ ⴰⵎⵓⵔ ⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵓⵍⴰ ⴷ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵅⴹⴰ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("K221_12","013_21_12","2KI","21","12","12","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⵡⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ, ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵟⵏⴻⵟⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K221_13","013_21_13","2KI","21","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵇⵇⵏⴻⵖ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵍⵎⵉⵣⴰⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ. ⵏⴻⵛⵛ ⴰⴷ ⵎⴻⵙⵃⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴻⵙⵃⴻⵖ ⵉⵊⵊ ⵏ ⵟⵟⴻⴱⵚⵉ. ⵎⴻⵙⵃⴻⵏ ⵜ ⵓ ⵅⴻⵏⵏⵉ ⵇⴻⵍⴱⴻⵏ ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K221_14","013_21_14","2KI","21","14","14","ⴰⴷ ⵊⵊⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵉⵏⵓ, ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⵡⴹⴻⵖ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⵃⴻⴳⴳⵯⴰⵙⵜ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("K221_15","013_21_15","2KI","21","15","15","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⵄⴰⵔⴻⵏ ⴰⵢⵉ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⴼⴼⵖⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K221_16","013_21_16","2KI","21","16","16","ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵎⴰⵏⴰⵙⵙⴰ ⵉⵙⵙⵉⵣⵣⴻⵍ ⴰⵟⵟⴰⵙ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵛⵓⵔ ⵎⴰⵔⵔⴰ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴱⵍⴰ ⵎⴰ ⵏⵉⴷⴰⵔ ⵄⴰⴷ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵢⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵅⴹⴰ, ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K221_17","013_21_17","2KI","21","17","17","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K221_18","013_21_18","2KI","21","18","18","ⵎⴰⵏⴰⵙⵙⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵄⵓⵚⴰ. ⵎⵎⵉⵙ ⴰⵎⵓⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K221_19","013_21_19","2KI","21","19","19","ⴰⵎⵓⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⵛⵓⵍⵍⴰⵎⵉⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵃⴰⵔⵓⵣ ⵣⵉ ⵢⵓⵜⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("K221_20","013_21_20","2KI","21","20","20","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K221_21","013_21_21","2KI","21","21","21","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴽⵓⵍ ⴰⴱⵔⵉⴷ ⵉ ⴷⵉ ⵢⵓⵢⵓⵔ ⴱⴰⴱⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉ ⵜⵓⵖⴰ ⵉⵙⴻⵅⵅⴰⵔ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⵙⵊⴻⴷ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K221_22","013_21_22","2KI","21","22","22","ⵏⴻⵜⵜⴰ ⵉⵙⵎⴻⵃ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵓⵢⵓⵔ ⵛⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K221_23","013_21_23","2KI","21","23","23","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵎⵓⵏ ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓⵛⴰ ⵏⵖⵉⵏ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K221_24","013_21_24","2KI","21","24","24","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵎⵓⵏ, ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴳⴳⵉⵏ ⵎⵎⵉⵙ ⵢⵓⵛⵉⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K221_25","013_21_25","2KI","21","25","25","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵎⵓⵏ ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K221_26","013_21_26","2KI","21","26","26","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵏ ⵄⵓⵣⵣⴰ. ⵎⵎⵉⵙ ⵢⵓⵛⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K222_1","013_22_1","2KI","22","1","1","ⵢⵓⵛⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵡⴰⵃⵉⵜ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⴷⵉⴷⵢⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⴷⴰⵢⴰ ⵣⵉ ⴱⵓⵚⵇⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K222_2","013_22_2","2KI","22","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⵉ ⴽⵓⵍ ⴰⴱⵔⵉⴷ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ, ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("K222_3","013_22_3","2KI","22","3","3","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴰⵚⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K222_4","013_22_4","2KI","22","4","4","“ⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵃⵉⵍⵇⵉⵢⴰ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷⴷ ⵢⵉⵡⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴷ ⵜⵉⵏⵏⵉ ⵉ ⴷⴷ-ⵢⴰⵔⵡⴻⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵣⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("K222_5","013_22_5","2KI","22","5","5","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⴳⴳⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏⵜ ⵡⵛⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⵇⵇⵄⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵉⵀⵔⵓⵔⴰⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("K222_6","013_22_6","2KI","22","6","6","ⵉ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ, ⵉ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ ⴷ ⵉⵎⴰⵚⵚⵓⵜⴻⵏ, ⵓ ⵉ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ ⵉ ⵡⴻⵄⴷⴰⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("K222_7","013_22_7","2KI","22","7","7","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⴳⴳⴻⵏ ⵍⴻⵃⵙⴰⴱ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵓⵜⵉⵇⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("K222_8","013_22_8","2KI","22","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵃⵉⵍⵇⵉⵢⴰ ⵉ ⵓⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ: “ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ⵓⵛⴰ ⵉⵡⵛⴰ ⵃⵉⵍⵇⵉⵢⴰ ⵉ ⵛⴰⴼⴰⵏ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵖⵔⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("K222_9","013_22_9","2KI","22","9","9","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵓⵢⵓⵔ ⵓⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵍⴻⵅⴱⴰⵔ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵙⵙⵎⵓⵏⴻⵏ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴼⴰⵔⵔⵖⴻⵏ ⵜⴻⵏⵜ ⵓⵛⴰ ⵡⵛⵉⵏ ⵜⴻⵏⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵉ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("K222_10","013_22_10","2KI","22","10","10","ⵄⴰⵡⴻⴷ ⵉⵃⴰⵊⴰ ⵓⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⴰⴽⴻⵀⵀⴰⵏ ⵃⵉⵍⵇⵉⵢⴰ ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ.” ⵛⴰⴼⴰⵏ ⵉⵖⵔⴰ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K222_11","013_22_11","2KI","22","11","11","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K222_12","013_22_12","2KI","22","12","12","ⴰⵊⴻⴵⵉⴷ ⵢⵓⵎⵓⵔ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵃⵉⵍⵇⵉⵢⴰ ⵓ ⵉ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵓ ⵉ ⵄⴰⴽⴱⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰ-ⵢⴰⵀ, ⵓ ⵉ ⵛⴰⴼⴰⵏ, ⴰⵎⴰⵔⵉⵔ, ⵓ ⵉ ⵄⴰⵙⴰⵢⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("K222_13","013_22_13","2KI","22","13","13","“ⵓⵢⵓⵔⴻⵎ, ⴰⵔⵣⵓⵎ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵙⵄⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉ ⵢⴰⵔⵖⵉⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵢⵓⵔⴰⵏ ⵉ ⵏⴻⵛⵛⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("K222_14","013_22_14","2KI","22","14","14","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵃⵉⵍⵇⵉⵢⴰ ⴰⴽ-ⴷ ⴰⵅⵉⵇⴰⵎ, ⵄⴰⴽⴱⵓⵔ, ⵛⴰⴼⴰⵏ ⴷ ⵄⴰⵙⴰⵢⴰ ⵖⴰⵔ ⵜⵏⴰⴱⵉⵜ ⵅⵓⵍⴷⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵜⵉⵇⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵔⵃⴰⵙ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵅ ⵡⴰⵔⵔⵓⴹⴻⵏ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵣⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K222_15","013_22_15","2KI","22","15","15","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵉⵏⵉ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("K222_16","013_22_16","2KI","22","16","16","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⵢⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵉ ⵉⵖⵔⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("K222_17","013_22_17","2KI","22","17","17","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ, ⵉⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⵍⴰⵎⵉ ⴷⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⴹⵉⴷⴷ ⵉ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵡⴰⵔ ⵉⵅⴻⵙⵙⵉ ⵛⴰ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("K222_18","013_22_18","2KI","22","18","18","ⵎⴰⵛⴰ ⵉⵏⵉⵎ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵜⴻⵙⵍⵉⴷ ⵛⴻⴽ: ");
INSERT INTO rift_vpl VALUES ("K222_19","013_22_19","2KI","22","19","19","ⵎⵉⵏⵣⵉ ⵓⵍ ⵏⵏⴻⵛ ⵉⴷⵡⴻⵍ ⵢⴰⵔⴹⴻⴱ ⵓ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵎⵉ ⵜⴻⵙⵍⵉⴷ ⵅ ⵎⵉⵏ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ - ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵏⵏⴻⵄⵍⴻⵜ - ⵓ ⵓⵎⵉ ⵜⵛⴰⵔⵔⴳⴻⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⵔⵓⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵅ ⵓⵢⴰ ⴰⴷ ⴰⵛ ⵙⵍⵉⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K222_20","013_22_20","2KI","22","20","20","ⵙ ⵓⵢⴰ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵎⵓⵏⴻⵖ ⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴰⵔⵙⴻⴷ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⴷⵉ ⵍⴻⵀⵏⴰ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵥⴰⵔⵔⴻⵏⵜ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⴷ ⵖⴰ ⴰⵡⵢⴻⵖ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ.’” ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵡⴰⵍ-ⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("K223_1","013_23_1","2KI","23","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵎⵓⵏⴻⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K223_2","013_23_2","2KI","23","2","2","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵖⵔⴰ ⵅⴰⵙⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵜⵓⵖⴰ ⵓⴼⵉⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K223_3","013_23_3","2KI","23","3","3","ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⴱⵉⵍⴰⵔ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⴻⵏ ⵍⵄⴰⵀⴷ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴹⴼⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵃⴹⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵎⵜⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ ⵏⵏⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ. ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("K223_4","013_23_4","2KI","23","4","4","ⴰⵊⴻⴵⵉⴷ ⵢⵓⵎⵓⵔ ⵉ ⵃⵉⵍⵇⵉⵢⴰ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵓⵙⴻⵜⵜⴻⴼ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ ⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⴱⴰⵄⴰⵍ ⵓ ⵉ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵍⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴱⴰⵔⵔⴰ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵇⵉⴷⵔⵓⵏ ⵓ ⵉⵊⵊⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵉⵖⵖⴻⴹ ⵏⵏⴻⵙ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K223_5","013_23_5","2KI","23","5","5","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵄⴰⵡⴻⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵍⴻⵇⵇⵎⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⴷⵉ ⵍⴻⴳⵄⵓⴷⵉ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷⴷ ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⴱⴰⵄⴰⵍ, ⴷ ⵜⴼⵓⵛⵜ, ⴷ ⵜⵣⵉⵔⵉ, ⴷ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_6","013_23_6","2KI","23","6","6","ⵉⵙⵙⵓⴼⴼⴻⵖ ⵓⵍⴰ ⴷ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴱⴰⵔⵔⴰ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵉ-ⵜⵜ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ ⵓ ⵉⴷⴷⴻⵣ ⵉ-ⵜⵜ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵓ ⵢⴰⵔⴻⵢⵢⴻⵛ ⵉ-ⵜⵜ ⵅ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⴰⵢⵜ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("K223_7","013_23_7","2KI","23","7","7","ⵏⴻⵜⵜⴰ ⵉⵀⴷⴻⵎ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵉⵎⴻⵜⵍⴻⵢⵢⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵏⵉ ⵜⵜⵅⴻⵢⵢⴰⴹⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵏⵉ ⴳⴳⵉⵏⵜ ⴰⵎ ⵜⵉⵣⵣⴰⵢⵉⵡⵉⵏ ⵉ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("K223_8","013_23_8","2KI","23","8","8","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵍⴻⴳⵄⵓⴷⵉ ⵎⴰⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ, ⵣⵉ ⵊⴰⴱⵄⴰ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ⵏⴻⵜⵜⴰ ⵉⵀⴷⴻⵎ ⵍⴻⴳⵄⵓⴷⵉ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵍⴰ ⴷ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵢⴰⵛⵓⵡⴰ, ⴰⵣⴻⴵⵉⴼ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⴷⴻⴼ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K223_9","013_23_9","2KI","23","9","9","ⵎⴰⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K223_10","013_23_10","2KI","23","10","10","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵓⵍⴰ ⴷ ⵜⵓⴼⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵀⵉⵏⵏⵓⵎ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵄⴻⴷⴷⵓ ⵎⵎⵉⵙ ⵏⵉⵖ ⵢⴻⴵⵉⵙ ⵅ ⵜⵎⴻⵙⵙⵉ ⵉ ⵎⵓⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("K223_11","013_23_11","2KI","23","11","11","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵉⵢⵙⴰⵏ ⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉ ⵍⴻⵡⵇⴰⵔ ⵏ ⵜⴼⵓⵛⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵜⴻⵅⵅⴰⵎⵜ ⵏ ⵏⴰⵜⴰⵏ-ⵎⴰⵍⴰⴽ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵛⴻⵏⵏⴻⵄ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⴱⴰⵔⵔⴰ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵏⴻⵜⵜⴰ ⵉⵇⴻⴷⴷ ⵉ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵜⴼⵓⵛⵜ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("K223_12","013_23_12","2KI","23","12","12","ⵓⵍⴰ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵏ ⵜⵖⵓⵔⴼⴻⵜ ⵏ ⴰⵃⴰⵣ ⵏⵏⵉ ⴳⴳⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵍⴰ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵉ ⵉⴳⴳⴰ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵀⴷⴻⵎ ⵉ-ⵜⴻⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵍⴱⴻⵣ ⵉ-ⵜⴻⵏ, ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵉ-ⵜⴻⵏ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K223_13","013_23_13","2KI","23","13","13","ⵓⵛⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵓⵊⴻⴵⵉⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵓⴹⴻⵢⵢⴻⵄ, ⵍⴻⴳⵄⵓⴷⵉ ⵉ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⴰⵛⵜⵓⵔⵉⵜ, ⵏⵏⵄⵉ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ, ⵓ ⵉ ⴽⴰⵎⵓⵛ, ⵏⵏⵄⵉ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵓ ⵉ ⵎⵉⵍⴽⵓⵎ, ⵊⵊⵄⵉⴼⴻⵛⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("K223_14","013_23_14","2KI","23","14","14","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵥⴰ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓⵛⴰ ⵉⵀⴷⴻⵎ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵛⴰ ⵉⵛⵛⵓⵔ ⴰⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵙ ⵢⴻⵖⵙⴰⵏ ⵏ ⵢⴻⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K223_15","013_23_15","2KI","23","15","15","ⵓⵍⴰ ⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⵉⴳⴳⵉⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵅⴹⴰ, ⴰⵇⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵏⵏⵉ ⴷ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ, ⵉⵀⴷⴻⵎ ⵉ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵍⴳⴻⵄⵄⴷⴻⵜ, ⵉⴷⴷⴻⵣ ⵉ-ⵜⵜ ⴰⵍⴰⵎⵉ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵜⴰⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("K223_16","013_23_16","2KI","23","16","16","ⵓⵎⵉ ⴷⴷ-ⵉⵏⵏⴻⵇⵍⴻⴱ ⵢⵓⵛⵉⵢⴰ, ⵉⵥⵔⴰ ⵉⵎⴻⴹⵍⴰⵏ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵅ ⵡⴻⴷⵔⴰⵔ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴷⵉⵏ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⴽⵙⵉ-ⴷⴷ ⵉⵖⵙⴰⵏ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵉ-ⵜⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉ-ⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵣⵉ ⵉⴱⴰⵔⵔⴻⵃ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⴱⴰⵔⵔⵃⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_17","013_23_17","2KI","23","17","17","ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ: “ⵎⴰⵏⴰ ⵡⴻⵥⵔⵓ ⵏⵏⵉ ⵉ ⵡⴰⵔ ⵥⵔⵉⵖ ⵄⴻⵎⵎⴰⵔⵙ ⵉ ⴷⵉⵏ ⵜⵡⴰⵍⵉⵖ?” ⵏⵏⴰⵏ ⴰⵙ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ: “ⵡⴰ ⴷ ⴰⵏⴹⴻⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ ⴰⴽ-ⴷ ⵓⵄⴰⵍⵟⴰⵔ-ⴰ ⵏ ⴱⴰⵢⵜ-ⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("K223_18","013_23_18","2KI","23","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵊⵊⴻⵎ ⵜ ⴷⵉⵏ! ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵃⵉⴷⵉ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ!” ⴰⵎⵎⵓ ⵉ ⵊⵊⵉⵏ ⵏⵉⵜⵏⵉ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵢⴻⵖⵙⴰⵏ ⵏ ⵓⵏⴰⴱⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_19","013_23_19","2KI","23","19","19","ⵉⴽⴽⴻⵙ ⵢⵓⵛⵉⵢⴰ ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⵏ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵉ ⵜⵓⵖⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵄⴰⵔⴻⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K223_20","013_23_20","2KI","23","20","20","ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉⵏ, ⵉⵖⴰⵔⵚ ⴰⵙⴻⵏ ⵅ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵉⵖⵙⴰⵏ ⵏ ⵉⵡⴷⴰⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K223_21","013_23_21","2KI","23","21","21","ⴰⵊⴻⴵⵉⴷ ⵢⵓⵎⵓⵔ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⵙⵡⴻⵊⴷⴻⵎ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵔⵉ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵏ ⵍⵄⴰⵀⴷ.” ");
INSERT INTO rift_vpl VALUES ("K223_22","013_23_22","2KI","23","22","22","ⵉⵛⵜ ⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⵎ ⵡⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵄⴻⵎⵎⴰⵔⵚ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵇⵓⴹⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_23","013_23_23","2KI","23","23","23","ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵡⴰⵏⵉⵜⴰ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K223_24","013_23_24","2KI","23","24","24","ⵢⵓⵛⵉⵢⴰ ⵉⴽⴽⴻⵙ ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ, ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⴷ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⴷ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵡⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉ ⵉⵜⵜⵡⴰⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵉ ⵜⵓⵖⴰ ⵢⵓⴼⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵃⵉⵍⵇⵉⵢⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K223_25","013_23_25","2KI","23","25","25","ⵇⴱⴻⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵏⴻⵜⵜⴰ, ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴷ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_26","013_23_26","2KI","23","26","26","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵊⵊⵉ ⵣⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵅ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⴰⵙⵄⴰⵔ ⵉ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_27","013_23_27","2KI","23","27","27","ⵙⵉⴷⵉ ⵉⵏⵏⴰ: “ⴰⴷ ⵙⵙⵉⴳⴳⵯⵊⴻⵖ ⵓⵍⴰ ⴷ ⵢⴰⵀⵓⴷⴰ ⵅ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵖ ⵏⴻⵛⵛ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⴼⴰⵔⵣⴻⵖ, ⵓⵍⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵅⴻⴼ ⵏⵏⵉⵖ: ‘ⴰⴷ ⵢⵉⵍⵉ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷⵉⵀⴰ!’” ");
INSERT INTO rift_vpl VALUES ("K223_28","013_23_28","2KI","23","28","28","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵛⵉⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K223_29","013_23_29","2KI","23","29","29","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⴳⴻⵄⵄⴻⴷ ⴼⵉⵔⵄⵓⵏ ⵏⵉⵅⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⴹⵉⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ⴰⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ ⵉⴼⴼⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵍⵇⴰ, ⵎⴰⵛⴰ ⴼⵉⵔⵄⵓⵏ ⵏⵉⵅⵓ ⵉⵏⵖⴰ ⵉ-ⵜ ⵖⴰⵔ ⵎⴰⵊⵉⴷⴷⵓ ⵍⴰⵎⵉ ⵜ ⵢⴻⵥⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_30","013_23_30","2KI","23","30","30","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵡⵢⴻⵏ ⵜ ⴷ ⴰⵎⴻⵜⵜⵉⵏ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵣⵉ ⵎⴰⵊⵉⴷⴷⵓ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵙⵙⵉⵡⴹⴻⵏ ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ. ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴽⵙⵉ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⵓⵛⴰ ⴷⴻⵀⵏⴻⵏ ⵜ, ⴳⴳⵉⵏ ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K223_31","013_23_31","2KI","23","31","31","ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵃⴰⵎⵓⵜⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K223_32","013_23_32","2KI","23","32","32","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K223_33","013_23_33","2KI","23","33","33","ⴼⵉⵔⵄⵓⵏ ⵏⵉⵅⵓ ⵉⵊⵊⴰ ⴰⴷ ⵜ ⵉⴱⴻⵍⵍⴻⵄ ⴷⵉ ⵔⵉⴱⵍⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎⴰⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵃⴻⴽⴽⴻⵎ ⵄⴰⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵊⵊ ⵏ ⵎⵓⵍⵜⴰ ⵏ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("K223_34","013_23_34","2KI","23","34","34","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴼⵉⵔⵄⵓⵏ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ. ⵎⴰⵛⴰ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵢⵉⵡⵢⵉ ⵉ-ⵜ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("K223_35","013_23_35","2KI","23","35","35","ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵉⵡⵛⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉ ⴼⵉⵔⵄⵓⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵇⴻⴷⴷⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴼⵉⵔⵄⵓⵏ. ⵉⵇⴻⴷⴷⴰⵔ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⴷⴰⵔ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⴰⵔ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵡⵛ ⵉ ⴼⵉⵔⵄⵓⵏ ⵏⵉⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("K223_36","013_23_36","2KI","23","36","36","ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵃⵉⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵣⴰⴱⵉⴷⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⴷⴰⵢⴰ ⵣⵉ ⵔⵓⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("K223_37","013_23_37","2KI","23","37","37","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K224_1","013_24_1","2KI","24","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⴳⴻⵄⵄⴻⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵉⴷⵡⴻⵍ ⵉⵟⴰⵄ ⴰⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⵛⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K224_2","013_24_2","2KI","24","2","2","ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵙⵉⴷⵉ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴷ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⴰⵔⴰⵎ ⴷ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵅⴰⵔⵔⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("K224_3","013_24_3","2KI","24","3","3","ⵡⴰⵀ, ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("K224_4","013_24_4","2KI","24","4","4","ⵓⵍⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵉ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵛⵓⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵙ ⵓⵢⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⴰⵙ ⵉⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("K224_5","013_24_5","2KI","24","5","5","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("K224_6","013_24_6","2KI","24","6","6","ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵎⵎⵉⵙ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K224_7","013_24_7","2KI","24","7","7","ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵡⴰⵔ ⵉⴼⴼⵉⵖ ⵄⴰⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵜⵓⵖⴰ ⵉⴽⵙⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("K224_8","013_24_8","2KI","24","8","8","ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⴻⵃⵓⵛⵟⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵍ-ⵏⴰⵜⴰⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K224_9","013_24_9","2KI","24","9","9","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K224_10","013_24_10","2KI","24","10","10","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵃⵙⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K224_11","013_24_11","2KI","24","11","11","ⵓⵍⴰ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵎ ⵜⵜ ⵃⵚⴰⵔⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K224_12","013_24_12","2KI","24","12","12","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵢⴻⵎⵎⴰⵙ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ. ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵃⴻⴱⴱⴻⵙ ⵉ-ⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K224_13","013_24_13","2KI","24","13","13","ⵏⴻⵜⵜⴰ ⵉⵃⴻⵡⵡⴻⵙ ⵙⵙⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵅⵓⴱⴰⵢ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵅⵓⴱⴰⵢ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⵓⵔⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("K224_14","013_24_14","2KI","24","14","14","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵎⴻⵃⴱⴰⵙ, ⵓⵍⴰ ⴷ ⴽⵓⵍ ⴰⵏⴻⵇⵇⴰⵛ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ ⴷ ⵉⵎⵣⵉⵍⴻⵏ. ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵎⵖⵉⵔ ⵉⵎⴻⵣⵍⴰⴹ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K224_15","013_24_15","2KI","24","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K224_16","013_24_16","2KI","24","16","16","ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ ⴷ ⵉⵎⵣⵉⵍⴻⵏ, ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴷ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵏⵏⵉ ⵉⵜⵜⵇⴻⴷⴷⴰⵏ ⵅ ⵓⵎⴻⵏⵖⵉ, ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K224_17","013_24_17","2KI","24","17","17","ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⴳⴳⴰ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵄⴻⵎⵎⵉⵙ, ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵚⵉⴷⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K224_18","013_24_18","2KI","24","18","18","ⵚⵉⴷⵇⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵃⵉⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵃⴰⵎⵓⵟⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵔⵎⵉⵢⴰ, ⵣⵉ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("K224_19","013_24_19","2KI","24","19","19","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K224_20","013_24_20","2KI","24","20","20","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ ⴰⵍⴰⵎⵉ ⵜⴻⵏ-ⵉ-ⴷⴷ ⵉⵙⵙⴻⴽⴽ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵖⴻⵡⵡⴻⵖ ⵚⵉⴷⵇⵉⵢⴰ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K225_1","013_25_1","2KI","25","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ⵉⵃⵚⴰⵔ ⵉ-ⵜⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵙ ⵙ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⵜⵄⴻⵙⵙⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("K225_2","013_25_2","2KI","25","2","2","ⵃⵚⴰⵔⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_3","013_25_3","2KI","25","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉⴷⵡⴻⵍ ⵍⴰⵥ ⵉⵎⵖⴰⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⵄⴰⴷ ⵎⴰⵛⵛⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K225_4","013_25_4","2KI","25","4","4","ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵔⵥ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴰⵅⵅⴰ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_5","013_25_5","2KI","25","5","5","ⵎⴰⵛⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴹⴼⴰⵔⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵓ ⵏⵉⵜⵏⵉ ⵃⴰⵔⵜⴻⵏ ⵅⴰⵙ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⴰⵔⵉⵃⴰ ⵓ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⴱⴻⵣⵣⵄⴻⵏ ⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K225_6","013_25_6","2KI","25","6","6","ⵟⵟⴼⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵔⵉⴱⵍⴰ, ⵓⵛⴰ ⵃⴻⴽⵎⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("K225_7","013_25_7","2KI","25","7","7","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⵉⴷⵇⵉⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵙⵙⴷⴰⵔⵖⵍⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵚⵉⴷⵇⵉⵢⴰ ⵓⵛⴰ ⵛⴰⵔⴼⴻⵏ ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵃⴰⵙ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K225_8","013_25_8","2KI","25","8","8","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵢⵓⵔ - ⵜⵓⵖⴰ-ⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵙⴻⵄⵟⴰⵛ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ - ⵢⵓⵙⴰ-ⴷⴷ ⵏⴰⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("K225_9","013_25_9","2KI","25","9","9","ⵉⵙⵙⴻⵛⵎⴻⴹ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵍⴰ ⴽⵓⵍ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵙⵙⴰⵔⵖ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("K225_10","013_25_10","2KI","25","10","10","ⵍⴻⵃⵢⵓⴹ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴻⴹⵍⴻⵏ ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("K225_11","013_25_11","2KI","25","11","11","ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵄⴷⵓⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵏⴰⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_12","013_25_12","2KI","25","12","12","ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵊⵊⴰ ⵎⵖⵉⵔ ⵛⴰ ⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⵣⴰⵢⴰⵔⵜ ⴷ ⵉⴼⴻⴵⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K225_13","013_25_13","2KI","25","13","13","ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵏⵏⵃⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⴷ ⵜⵔⵉⵎⴰⵏⵜ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⵥⵉⵏ ⵜⴻⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⵔⴱⵓⵏ ⵎⴰⵔⵔⴰ ⵏⵏⵃⴰⵙ ⵖⴰⵔ ⴱⴰⴱⵉⵍ.   ");
INSERT INTO rift_vpl VALUES ("K225_14","013_25_14","2KI","25","14","14","ⵓⵍⴰ ⴷ ⵜⵉⵢⴷⵓⵔⵉⵏ, ⴷ ⵉⵖⴻⵏⵊⴰⵢⴻⵏ, ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ, ⴷ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ, ⵉⵡⵢⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K225_15","013_25_15","2KI","25","15","15","ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵢⵉⵡⵉ-ⴷⴷ ⵜⵉⵎⴻⵊⵎⴰⵔⵉⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵇⴰⵄ ⵏ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K225_16","013_25_16","2KI","25","16","16","ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵜⵔⵉⵎⴰⵏⵜ ⴷ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵡⴻⵣⵏⴻⵏ ⵏⵏⵃⴰⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_17","013_25_17","2KI","25","17","17","ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⵉⵍⴰⵔ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓ ⵜⵜⴰⵊ ⵉ ⵅⴰⵙ, ⵜⵓⵖⴰ ⵏ ⵏⵏⵃⴰⵙ. ⵍⵓⵄⵍⴰ ⵏ ⵜⵜⴰⵊ ⵜⵓⵖⴰ-ⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. , ⵓ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⴷ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵜⴰⵊ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵏ ⵏⵏⵃⴰⵙ. ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵓⵍⴰ ⵖⴰⵔ ⵓⴱⵉⵍⴰⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵅ ⵜⵔⴰⵛⵛⴰ ⵉ ⵅⴰⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K225_18","013_25_18","2KI","25","18","18","ⵢⵉⵡⵉ-ⴷⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵄⴰⵡⴻⴷ ⵙⴰⵔⴰⵢⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴷ ⵚⴰⴼⴰⵏⵢⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("K225_19","013_25_19","2KI","25","19","19","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⵅ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ ⵣⴻⴳ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵎⴰⵔⵉⵔ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴻⵎⴻⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵓⵍⴰ ⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("K225_20","013_25_20","2KI","25","20","20","ⵢⵉⵡⵉ ⵜⴻⵏ ⵏⴰⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵔⵉⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_21","013_25_21","2KI","25","21","21","ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵡⵡⴻⵜ ⵉ-ⵜⴻⵏ, ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵔⵉⴱⵍⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎⴰⵜ. ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_22","013_25_22","2KI","25","22","22","ⵅ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉ ⵜⵓⵖⴰ ⵉⵊⵊⴰ ⴷⵉⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("K225_23","013_25_23","2KI","25","23","23","ⵓⵎⵉ ⵙⵍⵉⵏ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵏⵉⵜⵏⵉ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ, ⴱⴻⵍⵍⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⴳⴳⴰ ⵊⴰⴷⴰⵍⵢⴰ ⴷ ⴰⵡⴽⵉⵍ, ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ ⴷⵉ ⵎⵉⵚⴼⴰ: ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵃⴰ, ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵜⴰⵏⵃⵓⵎⴰⵜ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ, ⴷ ⵢⴰⵣⴰⵏⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵓⵎⴰⵄⴽⵉ, ⵏⵉⵜⵏⵉ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K225_24","013_25_24","2KI","25","24","24","ⵊⴰⴷⴰⵍⵢⴰ ⵉⵊⵊⵓⴵ ⴰⵙⴻⵏ ⵓ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⵎ ⵎⵍⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("K225_25","013_25_25","2KI","25","25","25","ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ, ⴰⴽ-ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵊⴰⴷⴰⵍⵢⴰ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵓⵍⴰ ⴷ ⵉⵢⴰⵀⵓⴷⵉⵢⵢⴻⵏ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴷⵉ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("K225_26","013_25_26","2KI","25","26","26","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵓⵍⴰ ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("K225_27","013_25_27","2KI","25","27","27","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵡⵉⵍ-ⵎⴰⵔⵓⴷⴰⵅ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⴷⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵉⴹⵍⴻⵇ-ⴷⴷ ⵉ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K225_28","013_25_28","2KI","25","28","28","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵙ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵓ ⵉⴳⴳⴰ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵉ ⵍⴽⴰⵔⴰⵙⵉ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("K225_29","013_25_29","2KI","25","29","29","ⵉⴱⴻⴷⴷⴻⵍ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵍⴻⵃⴱⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⴻⵜⵜ ⵍⴻⴱⴷⴰ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("K225_30","013_25_30","2KI","25","30","30","ⵅ ⵍⵄⵓⵍⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵍⴻⴱⴷⴰ ⵉⵊⵊ ⵏ ⵍⵄⵓⵍⵜ ⴰⵇⴻⴷⴷⴰ ⵏ ⵡⴰⵙⵙ ⵅ ⵡⴰⵙⵙ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_1","014_1_1","1CH","1","1","1","ⴰⴷⴰⵎ, ⵛⵉⵜ, ⴰⵏⵓⵛ, ");
INSERT INTO rift_vpl VALUES ("R11_2","014_1_2","1CH","1","2","2","ⵇⵉⵏⴰⵏ, ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ, ⵢⴰⵔⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("R11_3","014_1_3","1CH","1","3","3","ⵃⴰⵏⵓⵅ, ⵎⴰⵜⵓⵛⴰⵍⴰⵃ, ⵍⴰⵎⴰⴽ, ");
INSERT INTO rift_vpl VALUES ("R11_4","014_1_4","1CH","1","4","4","ⵏⵓⵃ, ⵛⴰⵎ, ⵃⴰⵎ, ⵢⴰⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R11_5","014_1_5","1CH","1","5","5","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴼⴰⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⵓⵎⴰⵔ, ⵎⴰⵊⵓⵊ, ⵎⴰⴷⴰⵢ, ⵢⴰⵡⴰⵏ, ⵜⵓⴱⴰⵍ, ⵎⴰⵛⵉⴽ ⴷ ⵜⵉⵔⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_6","014_1_6","1CH","1","6","6","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⵓⵎⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵛⴽⴰⵏⴰⵣ, ⴷⵉⴼⴰⵜ ⴷ ⵜⵓⵊⴰⵔⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("R11_7","014_1_7","1CH","1","7","7","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵡⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵍⵉⵛⴰ, ⵜⴰⵔⵛⵉⵛⴰ, ⵉⴽⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⴷⵓⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_8","014_1_8","1CH","1","8","8","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴽⵓⵛ, ⵎⵉⵚⵔⴰⵢⵉⵎ, ⴼⵓⵟ ⴷ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_9","014_1_9","1CH","1","9","9","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴽⵓⵛ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵙⴻⴱⴰ, ⵃⴰⵡⵉⵍⴰ, ⵙⴰⴱⵜⴰ, ⵔⴰⵄⴰⵎⴰ ⴷ ⵙⴰⴱⵜⴰⴽⴰ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⵄⴰⵎⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⴱⴰ ⴷ ⴷⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_10","014_1_10","1CH","1","10","10","ⴽⵓⵛ ⵉⵊⵊⴰ-ⴷⴷ ⵏⵉⵎⵔⵓⴷ. ⵡⴰⵏⵉⵜⴰ ⵉⴱⴷⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵊⵊⵉⵀⴻⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R11_11","014_1_11","1CH","1","11","11","ⵎⵉⵚⵔⴰⵢⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵍⵓⴷⵉⵢⵢⴻⵏ, ⵉⵄⴰⵏⴰⵎⵉⵢⵢⴻⵏ, ⵉⵍⴰⵀⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⴰⴼⵜⵓⵃⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R11_12","014_1_12","1CH","1","12","12","ⵉⴼⴰⵜⵔⵓⵙⵉⵢⵢⴻⵏ, ⵉⴽⴰⵙⵍⵓⵃⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵣⵉ ⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⴷ ⵉⴽⴰⴼⵜⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_13","014_1_13","1CH","1","13","13","ⴽⴻⵏⵄⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵚⵉⴷⵓⵏ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⴷ ⵃⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("R11_14","014_1_14","1CH","1","14","14","ⴰⵢⴰⴱⵓⵙⵉ, ⴰⵎⵓⵔⵉ, ⴰⵊⵉⵔⵊⴰⵛⵉ, ");
INSERT INTO rift_vpl VALUES ("R11_15","014_1_15","1CH","1","15","15","ⴰⵃⵉⵡⵉ, ⴰⵄⴰⵔⵇⵉ, ⴰⵙⵉⵏⵉⵢ, ");
INSERT INTO rift_vpl VALUES ("R11_16","014_1_16","1CH","1","16","16","ⴰⵔⵡⴰⴷⵉ, ⴰⵚⴰⵎⴰⵔⵉ ⴷ ⵓⵃⴰⵎⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("R11_17","014_1_17","1CH","1","17","17","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵍⴰⵎ ⴰⵛⵛⵓⵔ, ⴰⵔⴼⴰⴽⵛⴰⴷ, ⵍⵓⴷ, ⴰⵔⴰⵎ, ⵄⵓⵣ, ⵃⵓⵍ, ⵊⴰⵜⴰⵔ ⴷ ⵎⴰⵛⵉⴽ. ");
INSERT INTO rift_vpl VALUES ("R11_18","014_1_18","1CH","1","18","18","ⴰⵔⴼⴰⴽⵛⴰⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵍⴰⵃ ⵓ ⵛⴰⵍⴰⵃ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⴱⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R11_19","014_1_19","1CH","1","19","19","ⵜⵜⵡⴰⵔⵡⴻⵏ-ⴷⴷ ⵉ ⵄⴰⴱⵉⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ⵉⵊⵊⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴼⴰⵍⴰⵊ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⴱⴹⴰ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵓⵎⴰⵙ ⵢⵓⵇⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_20","014_1_20","1CH","1","20","20","ⵢⵓⵇⵟⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵍⵎⵓⴷⴰⴷ, ⵛⴰⵍⴰⴼ, ⵀⴰⴹⴰⵔⵎⴰⵡⵜ, ⵢⴰⵔⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("R11_21","014_1_21","1CH","1","21","21","ⵀⴰⴷⵓⵔⴰⵎ, ⵓⵣⴰⵍ, ⴷⵉⵇⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("R11_22","014_1_22","1CH","1","22","22","ⵄⵉⴱⴰⵍ, ⴰⴱⵉⵎⴰⵢⵉⵍ, ⵛⴰⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("R11_23","014_1_23","1CH","1","23","23","ⵓⴼⵉⵔ, ⵃⴰⵡⵉⵍⴰ ⴷ ⵢⵓⴱⴰⴱ. ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵇⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_24","014_1_24","1CH","1","24","24","ⵛⴰⵎ, ⴰⵔⴼⴰⴽⵛⴰⴷ, ⵛⴰⵍⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("R11_25","014_1_25","1CH","1","25","25","ⵄⴰⴱⵉⵔ, ⴼⴰⵍⴰⵃ, ⵔⴰⵄⵓⵡ, ");
INSERT INTO rift_vpl VALUES ("R11_26","014_1_26","1CH","1","26","26","ⵙⴰⵔⵓⵊ, ⵏⴰⵃⵓⵔ, ⵜⴰⵔⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("R11_27","014_1_27","1CH","1","27","27","ⴰⴱⵔⴰⵎ, ⵡⴰ ⴷ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R11_28","014_1_28","1CH","1","28","28","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵉⵙⵎⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R11_29","014_1_29","1CH","1","29","29","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ: ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵎⴰⵄⵉⵍ ⵜⵓⵖⴰ-ⵜ ⴷ ⵏⴰⴱⴰⵢⵓⵜ, ⵅⴻⵏⵏⵉ ⵇⵉⴷⴰⵔ, ⴰⴷⴰⴱⵉⵍ, ⵎⵉⴱⵙⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("R11_30","014_1_30","1CH","1","30","30","ⵎⵉⵛⵎⴰⵄ, ⴷⵓⵎⴰ, ⵎⴰⵙⵙⴰ, ⵃⴰⴷⴰⴷ ⴷ ⵜⴰⵢⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("R11_31","014_1_31","1CH","1","31","31","ⵢⴰⵟⵓⵔ, ⵏⴰⴼⵉⵛ ⴷ ⵇⵉⴷⵎⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵙⵎⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R11_32","014_1_32","1CH","1","32","32","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵟⵓⵔⴰ, ⵜⴰⵢⵢⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ: ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵣⵉⵎⵔⴰⵏ, ⵢⵓⵇⵛⴰⵏ, ⵎⴰⴷⴰⵏ, ⵎⵉⴷⵢⴰⵏ, ⵢⵉⵛⴱⴰⵇ ⴷ ⵛⵓⵃⴰ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵇⵛⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⴱⴰ ⴷ ⴷⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_33","014_1_33","1CH","1","33","33","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵉⴷⵢⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵢⴼⴰ, ⵄⵉⴼⴰⵔ, ⵃⴰⵏⵓⵅ, ⴰⴱⵉⴷⴰⵄ ⴷ ⴰⵍⴷⴰⵄⴰ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵟⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R11_34","014_1_34","1CH","1","34","34","ⵉⴱⵔⴰⵀⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵙⵃⴰⵇ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵙⵃⴰⵇ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵙⵓ ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R11_35","014_1_35","1CH","1","35","35","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵉⵙⵓ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵍⵉⴼⴰⵣ, ⵔⴰⵄⵓⵡⵉⵍ, ⵢⴰⵄⵓⵛ, ⵢⴰⵄⵍⴰⵎ ⴷ ⵇⵓⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("R11_36","014_1_36","1CH","1","36","36","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵉⴼⴰⵣ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵜⴰⵢⵎⴰⵏ, ⵓⵎⴰⵔ, ⵚⴰⴼⵉ, ⵊⴰⵄⵜⴰⵎ, ⵇⵉⵏⴰⵣ, ⵜⵉⵎⵏⴰⵄ ⴷ ⵄⴰⵎⴰⵍⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("R11_37","014_1_37","1CH","1","37","37","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⵄⵓⵢⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵏⴰⵃⴰⵜ, ⵣⴰⵔⴰⵃ, ⵛⴰⵎⵎⴰ ⴷ ⵎⵉⵣⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("R11_38","014_1_38","1CH","1","38","38","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵙⴰⵄⵉⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵍⵓⵟⴰⵏ, ⵛⵓⴱⴰⵍ, ⵚⵉⴱⵄⵓⵏ, ⵄⴰⵏⴰ, ⴷⵉⵛⵓⵏ, ⵉⵚⴰⵔ ⴷ ⴷⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_39","014_1_39","1CH","1","39","39","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⵓⵟⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵅⵓⵔⵉ ⴷ ⵀⵓⵎⴰⵎ ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⵉⵎⵏⴰⵄ ⴷ ⵓⵍⵜⵎⴰⵙ ⵏ ⵍⵓⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_40","014_1_40","1CH","1","40","40","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵓⴱⴰⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵍⵢⴰⵏ, ⵎⴰⵏⴰⵃⴰⵜ, ⵄⵉⴱⴰⵍ, ⵛⴰⴼⵉ ⴷ ⵓⵏⴰⵎ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵚⵉⴱⵄⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⴰ ⴷ ⵄⴰⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R11_41","014_1_41","1CH","1","41","41","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵏⴰ ⵎⵖⵉⵔ: ⴷⵉⵛⵓⵏ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⵉⵛⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵃⴰⵎⵔⴰⵏ, ⵉⵛⴱⴰⵏ, ⵢⵉⵜⵔⴰⵏ ⴷ ⴽⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_42","014_1_42","1CH","1","42","42","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵚⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴱⵉⵍⵀⴰⵏ ⴷ ⵣⴰⵄⵡⴰⵏ ⴷ ⵢⴰⵄⴽⴰⵏ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⵉⵛⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵓⵚ ⴷ ⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R11_43","014_1_43","1CH","1","43","43","ⵉⵏⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵅ ⵉⴷⵓⵎ, ⵇⴱⴻⵍ ⵎⴰ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⴱⵉⵍⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ. ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴷⵉⵏⵀⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("R11_44","014_1_44","1CH","1","44","44","ⵉⵎⵎⵓⵜ ⴱⵉⵍⴰⵄ ⵓⵛⴰ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ, ⵣⵉ ⴱⵓⵚⵔⴰ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_45","014_1_45","1CH","1","45","45","ⵉⵎⵎⵓⵜ ⵢⵓⵡⴰⴱ ⵓⵛⴰ ⵃⵓⵛⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵜⴰⵢⵎⴰⵏⵉⵢⵢⴻⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_46","014_1_46","1CH","1","46","46","ⵉⵎⵎⵓⵜ ⵃⵓⵛⴰⵎ ⵓⵛⴰ ⵀⴰⴷⴰⴷ ⵎⵎⵉⵙ ⵏ ⴱⴰⴷⴰⴷ ⵡⴻⵏⵏⵉ ⵉⵖⴻⵍⴱⴻⵏ ⵎⵉⴷⵢⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵎⵓ’ⴰⴱ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⴰⵡⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R11_47","014_1_47","1CH","1","47","47","ⵉⵎⵎⵓⵜ ⵀⴰⴷⴰⴷ ⵓⵛⴰ ⵙⴰⵎⵍⴰ ⵣⵉ ⵎⴰⵙⵔⵉⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_48","014_1_48","1CH","1","48","48","ⵉⵎⵎⵓⵜ ⵙⴰⵎⵍⴰ ⵓⵛⴰ ⵛⴰⵡⵓⵍ, ⵣⵉ ⵔⴰⵃⵓⴱⵓⵜ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_49","014_1_49","1CH","1","49","49","ⵉⵎⵎⵓⵜ ⵛⴰⵡⵓⵍ ⵓⵛⴰ ⴱⴰⵄⵍ-ⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴽⴱⵓⵔ, ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R11_50","014_1_50","1CH","1","50","50","ⵉⵎⵎⵓⵜ ⴱⴰⵄⵍ-ⵃⴰⵏⴰⵏ ⵓⵛⴰ ⵀⴰⴷⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴼⴰⵄⵉ ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵀⵉⵟⴰⴱ’ⵉⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵎⴰⵟⵔⵉⴷ, ⵢⴻⴵⵉⵙ ⵏ ⵎⴰ-ⴷⴰⵀⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R11_51","014_1_51","1CH","1","51","51","ⵉⵎⵎⵓⵜ ⵀⴰⴷⴰⴷ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵢⵉⵏⴰ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⴷⵓⵎ: ⴰⵎⵖⴰⵔ ⵜⵉⵎⵏⴰⵄ, ⴷ ⵓⵎⵖⴰⵔ ⵄⴰⵍⵡⴰ, ⴷ ⵓⵎⵖⴰⵔ ⵢⴰⵜⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("R11_52","014_1_52","1CH","1","52","52","ⴷ ⵓⵎⵖⴰⵔ ⴰⵀⵓⵍⵉⴱⴰⵎⴰ, ⴷ ⵓⵎⵖⴰⵔ ⵉⵍⴰ, ⴷ ⵓⵎⵖⴰⵔ ⴼⵉⵏⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("R11_53","014_1_53","1CH","1","53","53","ⴷ ⵓⵎⵖⴰⵔ ⵇⴰⵏⴰⵣ, ⴷ ⵓⵎⵖⴰⵔ ⵜⴰⵢⵎⴰⵏ, ⴷ ⵓⵎⵖⴰⵔ ⵎⵉⴱⵚⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("R11_54","014_1_54","1CH","1","54","54","ⴷ ⵓⵎⵖⴰⵔ ⵎⴰⵊⴷⵉⵢⵉⵍ, ⴷ ⵓⵎⵖⴰⵔ ⵄⵉⵔⴰⵎ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R12_1","014_2_1","1CH","2","1","1","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵔⵓⴱⵉⵏ, ⵛⵉⵎⵄⵓⵏ, ⵍⴰⵡⵉ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵉⵙⵙⴰⴽⴰⵔ ⴷ ⵣⴰⴱⵓⵍⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("R12_2","014_2_2","1CH","2","2","2","ⴷⴰⵏ, ⵢⵓⵙⵓⴼ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵏⴰⴼⵜⴰⵍⵉ, ⵊⴰⴷ ⴷ ⴰⵛⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R12_3","014_2_3","1CH","2","3","3","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵔ ⴷ ⵓⵏⴰⵏ ⴷ ⵛⴰⵢⵍⴰ. ⴰⵇⴰ ⵜⵍⴰⵜⴰ-ⵢⴰ ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⵣⴻⴳ ⵢⴻⴵⵉⵙ ⵏ ⵛⵓⵄⴰ, ⵜⴰⴽⴻⵏⵄⴰⵏⵉⵜ. ⵄⵉⵔ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵖⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("R12_4","014_2_4","1CH","2","4","4","ⵜⴰⵎⴰⵔ, ⵜⴰⵙⵍⵉⵜ ⵏⵏⴻⵙ, ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⴼⴰⵔⵉⵚ ⴷ ⵣⴰⵔⴰⵃ. ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵅⴻⵎⵙⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_5","014_2_5","1CH","2","5","5","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴼⴰⵔⵉⵚ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵃⴰⵚⵔⵓⵏ ⴷ ⵃⴰⵎⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("R12_6","014_2_6","1CH","2","6","6","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵣⴰⵔⴰⵃ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵣⵉⵎⵔⵉ, ⵉⵜⴰⵏ, ⵀⴰⵢⵎⴰⵏ, ⴽⴰⵍⴽⵓⵍ ⴷ ⴷⴰⵔⴰⵄ. ⵙ ⵎⴰⵔⵔⴰ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_7","014_2_7","1CH","2","7","7","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴽⴰⵔⵎⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵅⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⵖⴻⴹⵍⴻⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵖⴱⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⴳⴳⴰ ⵙ ⵍⴻⵖⴷⴰⵔ ⴰⴽ-ⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("R12_8","014_2_8","1CH","2","8","8","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵜⴰⵏ: ⵎⵖⵉⵔ ⵄⴰⵣⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_9","014_2_9","1CH","2","9","9","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⵚⵔⵓⵏ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⵔⵃⴰⵎ’ⵉⵍ ⴷ ⵔⴰⵎ ⴷ ⴽⴰⵍⵓⴱⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R12_10","014_2_10","1CH","2","10","10","ⵔⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ. ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵏⴰⵃⵛⵓⵏ, ⵍⵃⴰⴽⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_11","014_2_11","1CH","2","11","11","ⵏⴰⵃⵛⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵙⴰⵍⵎⵓ. ⵙⴰⵍⵎⵓ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵓⵄⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("R12_12","014_2_12","1CH","2","12","12","ⴱⵓⵄⴰⵣ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⴱⵉⴷ. ⵄⵓⴱⵉⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_13","014_2_13","1CH","2","13","13","ⵢⴰⵙⵙⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵍⵉⵢⴰⴱ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ, ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵛⵉⵎⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R12_14","014_2_14","1CH","2","14","14","ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵔⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("R12_15","014_2_15","1CH","2","15","15","ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵓⵚⴰⵎ ⴷ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R12_16","014_2_16","1CH","2","16","16","ⵙⵓⵢᵉⵜⵎⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵚⴰⵔⵓⵢⴰ ⴷ ⴰⴱⵉⵊⴰⵢⵉⵍ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵚⴰⵔⵓⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⴱⵉⵛⴰⵢ ⴷ ⵢⵓⵡⴰⴱ ⴷ ⵄⴰⵙⴰ’ⵉⵍ, ⵜⵍⴰⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_17","014_2_17","1CH","2","17","17","ⴰⴱⵉⵊⴰⵢⵉⵍ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵄⴰⵎⴰⵙⴰ ⵓ ⴱⴰⴱⴰⵙ ⵏ ⵄⴰⵎⴰⵙⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵢⴰⵜⵔⵓ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⵎⴰⵄⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("R12_18","014_2_18","1CH","2","18","18","ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵚⵔⵓⵏ, ⵉⵊⵊⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵄⴰⵣⵓⴱⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵢⴻⴵⵉⵙ ⵢⴰⵔⵉⵄⵓⵜ. ⴷ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ: ⵢⴰⵛⴰⵔ, ⵛⵓⴱⴰⴱ ⴷ ⴰⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_19","014_2_19","1CH","2","19","19","ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⵄⴰⵣⵓⴱⴰ, ⵢⵉⵡⵉ ⴽⴰⵍⵉⴱ ⵉⴼⵔⴰⵜⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R12_20","014_2_20","1CH","2","20","20","ⵃⵓⵔ ⵉⵊⵊⴰ-ⴷⴷ ⵓⵔⵉ ⵓ ⵓⵔⵉ ⵉⵊⵊⴰ-ⴷⴷ ⴱⴰⵚⴰⵍⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R12_21","014_2_21","1CH","2","21","21","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵓⴷⴻⴼ ⵃⴰⵚⵔⵓⵏ ⵅ ⵢⴻⴵⵉⵙ ⵏ ⵎⴰⵅⵉⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵓ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⵜⵓⵖⴰ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵙⴰⵊⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("R12_22","014_2_22","1CH","2","22","22","ⵙⴰⵊⵓⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰ’ⵉⵔ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R12_23","014_2_23","1CH","2","23","23","ⵊⴰⵛⵓⵔ ⴰⴽ-ⴷ ⴰⵔⴰⵎ ⵉⴽⴽⴻⵙ ⵣⵣⴰⵢⵙⴻⵏ ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰ’ⵉⵔ, ⵓⵍⴰ ⴷ ⵇⴰⵏⴰⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵙ ⵎⴰⵔⵔⴰ ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵅⵉⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R12_24","014_2_24","1CH","2","24","24","ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵡⵜ ⵏ ⵃⴰⵚⵔⵓⵏ ⴷⵉ ⴽⴰⵍⵉⴱ-ⵉⴼⵔⴰⵜⴰ, ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⴰⴱⵉⵢⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵃⴰⵚⵔⵓⵏ, ⴰⵛⵃⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵜⴰⵇⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_25","014_2_25","1CH","2","25","25","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵔⵃⴰⵎ’ⵉⵍ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵃⴰⵚⵔⵓⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵔⴰⵎ, ⴰⵎⴻⵏⵣⵓ, ⵅⴻⵏⵏⵉ ⴱⵓⵏⴰ, ⴰⵡⵔⴰⵏ, ⵓⵚⴰⵎ ⴷ ⴰⵅⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_26","014_2_26","1CH","2","26","26","ⵢⴰⵔⵃⴰⵎ’ⵉⵍ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵖⵏⵉⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵟⴰⵔⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R12_27","014_2_27","1CH","2","27","27","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⵎ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⴰⵔⵃⴰⵎ’ⵉⵍ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵄⴰⵚ ⴷ ⵢⴰⵎⵉⵏ ⴷ ⵄⴰⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R12_28","014_2_28","1CH","2","28","28","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵏⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⵎⵎⴰⵢ ⴷ ⵢⴰⴷⴰⵄ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎⵎⴰⵢ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R12_29","014_2_29","1CH","2","29","29","ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴰⴱⵉⵛⵓⵔ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⴱⵉⵃⴰⵢⵉⵍ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⴰⵃⴱⴰⵏ ⴷ ⵎⵓⵍⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R12_30","014_2_30","1CH","2","30","30","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵏⴰⴷⴰⴱ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵙⴰⵍⴰⴷ ⴷ ⴰⴼⴼⴰⵢⵉⵎ. ⵙⴰⵍⴰⴷ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_31","014_2_31","1CH","2","31","31","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⴼⴼⴰⵢⵉⵎ: ⵎⵖⵉⵔ ⵢⵉⵛⵄⵉ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵉⵛⵄⵉ: ⵎⵖⵉⵔ ⵛⵉⵛⴰⵏ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵛⴰⵏ: ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵢⴻⴵⵉⵙ, ⴰⵃⵍⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R12_32","014_2_32","1CH","2","32","32","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴷⴰⵄ, ⵓⵎⴰⵙ ⵏ ⵛⴰⵎⵎⴰⵢ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⵜⵔⵓ ⴷ ⵢⵓⵏⴰⵜⴰⵏ. ⵢⴰⵜⵔⵓ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_33","014_2_33","1CH","2","33","33","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴼⴰⵍⴰⵜ ⴷ ⵣⴰⵣⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵔⵃⴰⵎ’ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R12_34","014_2_34","1CH","2","34","34","ⵛⵉⵛⴰⵏ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵎⴰⵛⴰ ⵢⴻⵙⵙⵉⵙ ⵡⴰⵀ. ⵛⵉⵛⴰⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴷ ⴰⵎⵉⵚⵔⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵔⵃⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R12_35","014_2_35","1CH","2","35","35","ⵛⵉⵛⴰⵏ ⵉⵡⵛⴰ ⵢⴻⴵⵉⵙ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵢⴰⵔⵃⴰⵄ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵄⴰⵜⵜⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R12_36","014_2_36","1CH","2","36","36","ⵄⴰⵜⵜⴰⵢ ⵉⵊⵊⴰ-ⴷⴷ ⵏⴰⵜⴰⵏ, ⵏⴰⵜⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵣⴰⴱⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("R12_37","014_2_37","1CH","2","37","37","ⵣⴰⴱⴰⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵉⴼⵍⴰⵍ, ⵉⴼⵍⴰⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⴱⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("R12_38","014_2_38","1CH","2","38","38","ⵄⵓⴱⵉⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵀⵓ, ⵢⴰⵀⵓ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵣⴰⵔⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R12_39","014_2_39","1CH","2","39","39","ⵄⴰⵣⴰⵔⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵃⴰⵍⴰⵚ, ⵃⴰⵍⴰⵚ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵍⵄⴰⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("R12_40","014_2_40","1CH","2","40","40","ⵉⵍⵄⴰⵙⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵙⵉⵙⵎⴰⵢ, ⵙⵉⵙⵎⴰⵢ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵍⵍⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("R12_41","014_2_41","1CH","2","41","41","ⵛⴰⵍⵍⵓⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵇⴰⵎⵢⴰ ⵓ ⵢⴰⵇⴰⵎⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵍⵉⵛⴰⵎⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R12_42","014_2_42","1CH","2","42","42","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴽⴰⵍⵉⴱ, ⵓⵎⴰⵙ ⵏ ⵢⴰⵔⵃⴰⵎ’ⵉⵍ: ⵎⵖⵉⵔ ⵎⵉⵛⴰⵄ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵣⵉⴼ, ⵓⵍⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵉⵛⴰ, ⴱⴰⴱⴰⵙ ⵏ ⵃⴰⴱⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_43","014_2_43","1CH","2","43","43","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵇⵓⵔⴰⵃ, ⵜⴰⴼⴼⵓⵄ, ⵔⴰⵇⴰⵎ ⴷ ⵛⴰⵎⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R12_44","014_2_44","1CH","2","44","44","ⵛⴰⵎⴰⵄ ⵉⵊⵊⴰ-ⴷⴷ ⵔⴰⵃⴰⵎ, ⴱⴰⴱⴰⵙ ⵏ ⵊⴰⵔⴰⵇⵄⴰⵎ, ⵓ ⵔⴰⵇⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵎⵎⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R12_45","014_2_45","1CH","2","45","45","ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵎⴰⵉ ⵜⵓⵖⴰ-ⵜ ⴷ ⵎⴰⵄⵓⵏ. ⵎⴰⵄⵓⵏ ⵜⵓⵖⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⴱⴰⵢⵜ-ⵚⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R12_46","014_2_46","1CH","2","46","46","ⵄⵉⵢⴼⴰ, ⵜⴰⵢⵢⴰ ⵏ ⴽⴰⵍⵉⴱ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵃⴰⵔⴰⵏ, ⵎⵓⵚⴰ ⴷ ⵊⴰⵣⵉⵣ. ⵃⴰⵔⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵊⴰⵣⵉⵣ. ");
INSERT INTO rift_vpl VALUES ("R12_47","014_2_47","1CH","2","47","47","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵀ-ⴷⴰⵢ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵔⴰⵊⴰⵎ, ⵢⵓⵜⴰⵎ, ⵊⵉⵛⴰⵏ, ⴼⴰⵍⴰⵟ, ⵄⵉⵢⴼⴰ ⴷ ⵛⴰⵄⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("R12_48","014_2_48","1CH","2","48","48","ⴰⴽ-ⴷ ⵜⴰⵢⵢⴰ ⵏ ⴽⴰⵍⵉⴱ, ⵎⴰⵄⴽⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵛⴰⴱⴰⵔ ⴷ ⵜⴰⵔⵃⴰⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_49","014_2_49","1CH","2","49","49","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵛⴰⵄⴰⴼ, ⴱⴰⴱⴰⵙ ⵏ ⵎⴰⴷⵎⴰⵏⵏⴰ, ⴷ ⵛⴰⵡⴰ, ⴱⴰⴱⴰⵙ ⵏ ⵎⴰⴽⴱⵉⵏⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵊⵉⴱⵄⴰ. ⵢⴻⴵⵉⵙ ⵏ ⴽⴰⵍⵉⴱ ⵜⵓⵖⴰ ⵄⴰⴽⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R12_50","014_2_50","1CH","2","50","50","ⵉⵏⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴽⴰⵍⵉⴱ: ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⴼⵔⴰⵜⴰ, ⵜⵓⵖⴰ ⵛⵓⴱⴰⵍ, ⴱⴰⴱⴰⵙ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("R12_51","014_2_51","1CH","2","51","51","ⵙⴰⵍⵎⴰ, ⴱⴰⴱⴰⵙ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⴷ ⵃⴰⵔⵉⴼ, ⴱⴰⴱⴰⵙ ⵏ ⴱⴰⵢⵜ-ⵊⴰⴷⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R12_52","014_2_52","1CH","2","52","52","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵓⴱⴰⵍ, ⴱⴰⴱⴰⵙ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵀⴰⵔⵓⵡⴰ ⴷ ⵃⴰⵚⵉ-ⵀⴰ-ⵎⴰⵏⵓⵃⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R12_53","014_2_53","1CH","2","53","53","ⵜⵉⵡⴰⵛⵓⵏⵉⵏ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵢⵉⵜⵔⵉⵢⵢⴻⵏ, ⵉⴼⴼⵓⵜⵉⵢⵢⴻⵏ, ⵉⵛⴰⵎⴰⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴰⵛⵔⴰⵄⵉⵢⵢⴻⵏ. ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵉⵚⴰⵔⵄⵉⵢⵢⴻⵏ ⴷ ⵉⵛⵜⴰⵡⵓⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_54","014_2_54","1CH","2","54","54","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵙⴰⵍⵎⴰ: ⵎⵖⵉⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵓⵛⴰ ⵉⵏⴰⵟⵓⴼⴰⵜⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵄⴰⵟⴰⵔⵓⵜ-ⴱⴰⵢⵜ-ⵢⵓ’ⴰⴱ ⴷ ⵃⴰⵚⵉ-ⵀⴰ-ⵎⴰⵏⴰⵃⵜⵉ ⴷ ⵉⵚⵓⵔⵄⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R12_55","014_2_55","1CH","2","55","55","ⵜⵉⵡⴰⵛⵓⵏⵉⵏ ⵏ ⵉⵎⴰⵔⵉⵔⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵢⴰⵄⴱⵉⵚ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵜⵉⵔⵄⴰⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵛⴰⵎⵄⴰⵢⵢⴻⵏ ⴷ ⵉⵙⵓⴽⴰⵏⵉⵢⵢⴻⵏ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵇⵉⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⵉ ⵃⴰⵎⵎⴰⵜ, ⴱⴰⴱⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵔⴰⴽⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R13_1","014_3_1","1CH","3","1","1","ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⴷⵉ ⵃⴰⴱⵔⵓⵏ: ⴰⵎⴻⵏⵣⵓ ⵜⵓⵖⴰ ⴷ ⴰⵎⵏⵓⵏ ⵏ ⴰⵅⵉⵏⵓⵄⴰⵎ, ⵜⴰⵢⴰⵣⵔⴰⵄⵉⵍⵉⵜ; ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⵏ ⴰⴱⵉⵊⴰⵢⵉⵍ, ⵜⴰⴽⴰⵔⵎⴰⵍⵉⵜ; ");
INSERT INTO rift_vpl VALUES ("R13_2","014_3_2","1CH","3","2","2","ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴱⵛⴰⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵜⴰⵍⵎⴰⵢ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵊⴰⵛⵓⵔ; ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷⵓⵏⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⵊⵉⵜ; ");
INSERT INTO rift_vpl VALUES ("R13_3","014_3_3","1CH","3","3","3","ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵛⴰⴼⴰⵟⵢⴰ ⵏ ⴰⴱⵉⵟⴰⵍ, ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵢⵉⵜⴰⵔⵄⴰⵎ, ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵄⴰⵊⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("R13_4","014_3_4","1CH","3","4","4","ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⵙⴻⵜⵜⴰ ⴷⵉ ⵃⴰⴱⵔⵓⵏ, ⵎⵉⵏⵣⵉ ⵉⵃⴽⴻⵎ ⴷⵉⵏⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R13_5","014_3_5","1CH","3","5","5","ⵉⵏⴰ ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ: ⵛⵉⵎⵄⴰ, ⵛⵓⴱⴰⴱ, ⵏⴰⵜⴰⵏ, ⵙⵓⵍⵉⵎⴰⵏ. ⴰⵔⴻⴱⵄⴰ-ⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⴰⵜ-ⵛⵓⵄ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R13_6","014_3_6","1CH","3","6","6","ⵅⴻⵏⵏⵉ ⵢⵉⴱⵃⴰⵔ, ⵉⵍⵉⵛⴰⵎⵄⴰ, ⵉⵍⵉⴼⴰⵍⴰⵟ, ");
INSERT INTO rift_vpl VALUES ("R13_7","014_3_7","1CH","3","7","7","ⵏⵓⵊⴰⵀ, ⵏⴰⴼⴰⵊ, ⵢⴰⴼⵉⵄ, ");
INSERT INTO rift_vpl VALUES ("R13_8","014_3_8","1CH","3","8","8","ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵉⵍⵉⵢⴰⴷⴰⵄ, ⵉⵍⵉⴼⴰⵍⴰⵟ, ⵜⴻⵙⵄⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R13_9","014_3_9","1CH","3","9","9","ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵏⵀⵍⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵜⵉⵢⵢⴰ, ⵓ ⵜⴰⵎⴰⵔ ⵜⵓⵖⴰ ⴷ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R13_10","014_3_10","1CH","3","10","10","ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ-ⵜ ⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⴰⴱⵉⵢⴰ, ⵎⵎⵉⵙ ⴰⵙⴰ, ⵎⵎⵉⵙ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ");
INSERT INTO rift_vpl VALUES ("R13_11","014_3_11","1CH","3","11","11","ⵎⵎⵉⵙ ⵢⴰⵀⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵢⵓⵡⴰⵛ, ");
INSERT INTO rift_vpl VALUES ("R13_12","014_3_12","1CH","3","12","12","ⵎⵎⵉⵙ ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵢⵓⵜⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("R13_13","014_3_13","1CH","3","13","13","ⵎⵎⵉⵙ ⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵎⴰⵏⴰⵙⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("R13_14","014_3_14","1CH","3","14","14","ⵎⵎⵉⵙ ⴰⵎⵓⵏ ⴷ ⵎⵎⵉⵙ ⵢⵓⵛⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R13_15","014_3_15","1CH","3","15","15","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵛⵉⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵎⴻⵏⵣⵓ ⵢⵓⵃⴰⵏⴰⵏ, ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵚⵉⴷⵇⵉⵢⴰ, ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵛⴰⵍⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R13_16","014_3_16","1CH","3","16","16","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ: ⵎⵎⵉⵙ ⵢⴰⴽⵓⵏⵢⴰ ⴷ ⵎⵎⵉⵙ ⵚⵉⴷⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R13_17","014_3_17","1CH","3","17","17","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴽⵓⵏⵢⴰ: ⴰⵙⵙⵉⵔ, ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ, ");
INSERT INTO rift_vpl VALUES ("R13_18","014_3_18","1CH","3","18","18","ⵓ ⵅⴻⵏⵏⵉ ⵎⴰⵍⴽⵉⵔⴰⵎ ⴷ ⴼⴰⴷⴰⵢⴰ ⴷ ⵛⵉⵏⴰⵚⵚⴰⵔ ⴷ ⵢⴰⵇⴰⵎⵢⴰ ⴷ ⵀⵓⵛⴰⵎⵄⴰ ⴷ ⵏⴰⴷⴰⴱⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R13_19","014_3_19","1CH","3","19","19","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴼⴰⴷⴰⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⴷ ⵛⵉⵎⵄⵉ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵛⵓⵍⵍⴰⵎ ⴷ ⵃⴰⵏⴰⵏⵢⴰ, ⵓ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵛⴰⵍⵓⵎⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("R13_20","014_3_20","1CH","3","20","20","ⵓ ⵅⴻⵏⵏⵉ ⵃⴰⵛⵓⴱⴰ ⴷ ⵓⵡⵀⵉⵍ ⴷ ⴱⴰⵔⴰⵅⵢⴰ ⴷ ⵃⴰⵙⴰⴷⵢⴰ ⴷ ⵢⵓⵛⴰⴱ-ⵃⴰⵙⴰⴷ, ⵅⴻⵎⵙⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R13_21","014_3_21","1CH","3","21","21","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⵏⴰⵏ-ⵢⴰⵀ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴼⴰⵍⴰⵟ-ⵢⴰⵀ, ⴷ ⵉⵛⴰⵄⵢⴰ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⴼⴰⵢⴰ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⵏⴰⵏ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⴱⴰⴷⵢⴰ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⴽⴰⵏⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R13_22","014_3_22","1CH","3","22","22","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵅⴰⵏⵢⴰ, ⵎⵖⵉⵔ ⵛⴰⵎⵄⵉⵢⴰ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵉⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵃⴰⵜⵜⵓⵛ, ⵢⵉⵊⵄⴰⵍ, ⴱⴰⵔⵉⵃ, ⵏⴰⵄⴰⵔⵢⴰ ⴷ ⵛⴰⴼⴰⵜ, ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R13_23","014_3_23","1CH","3","23","23","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵏⴰⵄⴰⵔⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵍⵢⵓⵄⵉⵏⴰⵢ, ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵄⴰⵣⵔⵉⵇⴰⵎ, ⵜⵍⴰⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R13_24","014_3_24","1CH","3","24","24","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵢⵓⵄⵉⵏⴰⵢ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵀⵓⴷⴰⵡⵢⴰⵀⵓ, ⵉⵍⵢⴰⵛⵉⴱ, ⴼⴰⵍⴰⵢⴰ, ⵄⴰⵇⵇⵓⴱ, ⵢⵓⵃⴰⵏⴰⵏ, ⴷⴰⵍⴰⵢⴰ ⴷ ⵄⴰⵏⴰⵏⵉ, ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_1","014_4_1","1CH","4","1","1","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴼⴰⵔⵉⵚ, ⵃⴰⵚⵔⵓⵏ ⴷ ⴽⴰⵔⵎⵉ ⴷ ⵃⵓⵔ ⴷ ⵛⵓⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R14_2","014_4_2","1CH","4","2","2","ⵔⴰ’ⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵓⴱⴰⵍ, ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵃⴰⵜ ⵓ ⵢⴰⵃⴰⵜ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵅⵓⵎⴰⵢ ⴷ ⵍⴰⵀⴰⴷ. ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵚⴰⵔⵄⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_3","014_4_3","1CH","4","3","3","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⴱⵉ-ⵄⵉⵟⴰⵎ: ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵢⴰⵛⵎⴰ ⴷ ⵢⴰⴷⴱⴰⵛ. ⵉⵙⴻⵎ ⵏ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴷ ⵀⴰⵚⵚⴰⵍⴰⵍⴼⵓⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R14_4","014_4_4","1CH","4","4","4","ⴼⴰⵏⵓⵡⵉⵍ ⵜⵓⵖⴰ-ⵜ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵊⴰⴷⵓⵔ, ⵓ ⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ-ⵜ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵃⵓⵛⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⵓⵔ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⴼⵔⴰⵜⴰ, ⴱⴰⴱⴰⵙ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("R14_5","014_4_5","1CH","4","5","5","ⴰⵛⵃⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵜⴰⵇⵓⵄⴰ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵃⴰⵍⴰ ⴷ ⵏⴰⵄⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_6","014_4_6","1CH","4","6","6","ⵏⴰⵄⴰⵔⴰ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⴰⵅⵓⵣⵣⴰⵎ, ⵃⴰⴼⴰⵔ, ⵜⴰⵢⵎⴰⵏⵉ ⴷ ⵉⵅⴰⵛⵜⴰⵔⵉⵢⵢⴻⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵏⴰⵄⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_7","014_4_7","1CH","4","7","7","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵚⴰⵔⴰⵜ, ⵚⵓⵃⴰⵔ ⴷ ⵉⵜⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_8","014_4_8","1CH","4","8","8","ⵇⵓⵚ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵏⵓⴱ ⴷ ⵀⴰⵚⵓⴱⵉⴱⴰ, ⴷ ⵍⴰⴵⴰⵜ ⵏ ⴰⵅⴰⵔⵃⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R14_9","014_4_9","1CH","4","9","9","ⵢⴰⵄⴱⵉⵚ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵛⵛⴰⵏ ⵅ ⵢⴰⵢⵜⵎⴰⵙ. ⵢⴻⵎⵎⴰⵙ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⵢⴰⵄⴱⵉⵚ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵏⴻⵛⵛ ⵓⵔⵡⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵙ ⵍⴻⵃⵔⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("R14_10","014_4_10","1CH","4","10","10","ⵉⵍⴰⵖⴰ ⵢⴰⵄⴱⵉⵚ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴱⴰⵔⴽⴻⴷ ⴰⵢⵉ ⵓ ⴰⴷ ⵜⵡⴻⵙⵙⵄⴻⴷ ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⵉ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⵍⵖⴰⵔ ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵍⴻⵇⵇⴻⴼ ⵜⴰⵎⴰⵔⴰ ...!” ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵉⵡⴻⴹ ⴰⵙ ⵎⵉⵏ ⵉⵜⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R14_11","014_4_11","1CH","4","11","11","ⴽⴰⵍⵓⴱ, ⵓⵎⴰⵙ ⵏ ⵛⵓⵃⴰ, ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵃⵉⵔ. ⵡⴰⵏⵉⵜⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵉⵛⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_12","014_4_12","1CH","4","12","12","ⵉⵛⵜⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴱⴰⵢⵜ-ⵔⴰⴼⴰ ⴷ ⴼⴰⵙⵉⵃ ⴷ ⵜⴰⵃⵉⵏⵏⴰ, ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵄⵉⵔ-ⵏⴰⵃⴰⵛ. ⵉⵏⴰ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵔⴰⵢⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_13","014_4_13","1CH","4","13","13","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵏⴰⵣ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵓⵜⵏⵉⵢⵉⵍ ⴷ ⵙⴰⵔⴰⵢⴰ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵎⵖⵉⵔ ⵃⴰⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R14_14","014_4_14","1CH","4","14","14","ⵎⴰⵄⵓⵏⴰⵜⴰⵢ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⴼⵔⴰ, ⵓ ⵙⴰⵔⴰⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵡⴰⴱ, ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵃⵔⴰⵢⴼⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵉⵃⵔⴰⵢⴼⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R14_15","014_4_15","1CH","4","15","15","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵔⵓ, ⵉⵢⵍⴰ ⴷ ⵏⴰⵄⴰⵎ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⴰ, ⵎⵖⵉⵔ ⵇⵉⵏⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("R14_16","014_4_16","1CH","4","16","16","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵍⴰⵍⵉⵢⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵣⵉⴼ ⴷ ⵣⵉⴼⴰ ⴷ ⵜⵉⵔⵉⵢⴰ ⴷ ⴰⵙⴰⵔⴰⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R14_17","014_4_17","1CH","4","17","17","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵉⵣⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⵜⴰⵔ ⴷ ⵎⴰⵔⴰⴷ ⴷ ⵄⵉⴼⴰⵔ ⴷ ⵢⴰⵍⵓⵏ. ⵏⴻⵜⵜⴰⵜ, ⴱⵉⵜⵢⴰ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵎⴰⵔⵢⴰⵎ ⴷ ⵛⴰⵎⵎⴰⵢ ⴷ ⵢⵉⵛⴱⴰⵃ, ⴱⴰⴱⴰⵙ ⵏ ⵉⵛⵜⴰⵎⵓⵄ, ");
INSERT INTO rift_vpl VALUES ("R14_18","014_4_18","1CH","4","18","18","ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵢⴰⵀⵓⴷⴻⵛⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵢⴰⵔⴰⴷ, ⴱⴰⴱⴰⵙ ⵏ ⵊⴰⴷⵓⵔ, ⴷ ⵃⴰⴱⵉⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵓⴽⵓ, ⴷ ⵢⴰⵇⵓⵜⵉⵢⵉⵍ, ⴱⴰⴱⴰⵙ ⵏ ⵣⴰⵏⵓⵃ, ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵜⵢⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵜⴻⵏⵏⵉ ⵢⵉⵡⵉ ⵎⴰⵔⴰⴷ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R14_19","014_4_19","1CH","4","19","19","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵀⵓⴷⵉⵢⴰ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵏⴰⵃⴰⵎ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵇⴰⵄⵉⵍⴰ, ⴰⵊⴰⵔⵎⵉ, ⴷ ⵉⵛⵜⴰⵎⵓⵄⴰ, ⴰⵎⴰⵄⴽⵉ. ");
INSERT INTO rift_vpl VALUES ("R14_20","014_4_20","1CH","4","20","20","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵎⵏⵓⵏ ⴷ ⵔⵉⵏⵏⴰ, ⴱⵉⵏ-ⵃⴰⵏⴰⵏ ⴷ ⵜⵉⵍⵓⵏ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵉⵄⵛⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵣⵓⵃⴰⵢⵜ ⴷ ⴱⴰⵏ-ⵣⵓⵃⴰⵢⵜ. ");
INSERT INTO rift_vpl VALUES ("R14_21","014_4_21","1CH","4","21","21","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵢⵍⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵉⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵍⵉⴽⴰ, ⵍⴰⵄⴷⴰ, ⴱⴰⴱⴰⵙ ⵏ ⵎⴰⵔⵉⵛⴰ, ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵙ ⵜⵉⴼⴼⴻⵙⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵛⴱⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_22","014_4_22","1CH","4","22","22","ⵓ ⵅⴻⵏⵏⵉ ⵢⵓⵇⵉⵎ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴽⵓⵣⵉⴱⴰ, ⴷ ⵢⵓⵡⴰⵛ ⴷ ⵙⴰⵔⴰⴼ, ⵉⵏⵏⵉ ⵉⵚⴻⴵⴹⴻⵏ ⵅ ⵎⵓ’ⴰⴱ, ⴷ ⵢⴰⵛⵓⴱⵉ-ⵍⴰⵃⵎ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵅⴱⴰⵔⴰⵜ ⵜⵉⵇⴷⵉⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_23","014_4_23","1CH","4","23","23","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵓ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵏⴰⵜⴰⵄⵉⵎ ⴷ ⵊⴰⴷⵉⵔⴰ. ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R14_24","014_4_24","1CH","4","24","24","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵏⴰⵎⵓⵢⵉⵍ ⴷ ⵢⴰⵎⵉⵏ, ⵢⴰⵔⵉⴱ, ⵣⴰⵔⴰⵃ, ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("R14_25","014_4_25","1CH","4","25","25","ⵛⴰⵍⵍⵓⵎ ⴷ ⵎⵎⵉⵙ, ⵎⵎⵉⵙ ⵎⵉⴱⵙⴰⵎ, ⵎⵎⵉⵙ ⵎⵉⵛⵎⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R14_26","014_4_26","1CH","4","26","26","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵉⵛⵎⴰⵄ: ⵎⵎⵉⵙ ⵃⴰⵎⵎⵓⵢⵉⵍ, ⵎⵎⵉⵙ ⵣⴰⴽⴽⵓⵔ ⴷ ⵎⵎⵉⵙ ⵛⵉⵎⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("R14_27","014_4_27","1CH","4","27","27","ⵛⵉⵎⵄⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵟⵟⴰⵛ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ⵎⴰⵛⴰ ⴰⵢⵜⵎⴰⵙ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵓⵖⵉ ⴱⵓ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴰⵟⵟⴰⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵎⵎⴰⵔⵏⵉⵏⵜ ⵛⴰ ⴰⵎ ⵜⵉⵏⵏⵉ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_28","014_4_28","1CH","4","28","28","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⴷⵉ ⵎⵓⵍⴰⴷⴰ, ⴷⵉ ⵃⴰⵚⴰⵔ-ⵛⵓⵄⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("R14_29","014_4_29","1CH","4","29","29","ⴷⵉ ⴱⵉⵍⵀⴰ ⴷⵉ ⵄⴰⵚⵉⵎ, ⴷⵉ ⵜⵓⵍⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("R14_30","014_4_30","1CH","4","30","30","ⴷⵉ ⴱⵉⵜⵓⵡⵉⵍ, ⴷⵉ ⵃⵓⵔⵎⴰ, ⴷⵉ ⵚⵉⵇⵍⴰⵖ, ");
INSERT INTO rift_vpl VALUES ("R14_31","014_4_31","1CH","4","31","31","ⴷⵉ ⴱⴰⵢⵜ-ⵎⴰⵔⴽⴰⴱⵓⵜ, ⴷⵉ ⵃⴰⵚⴰⵔ-ⵙⵓⵙⵉⵎ, ⴷⵉ ⴱⴰⵢⵜ-ⴱⵉⵔⵉ ⵓ ⴷⵉ ⵛⴰⵄⴰⵔⴰⵢⵉⵎ. ⴰⵍ ⵉⴷⵡⴻⵍ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵏⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R14_32","014_4_32","1CH","4","32","32","ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵙⴻⵏ: ⵄⵉⵟⴰⵎ, ⵄⴰⵢⵏ, ⵔⵉⵎⵎⵓⵏ, ⵜⵓⴽⴰⵏ ⴷ ⵄⴰⵛⴰⵏ, ⵅⴻⵎⵙⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ");
INSERT INTO rift_vpl VALUES ("R14_33","014_4_33","1CH","4","33","33","ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴷⵛⵓⵔⴰⵜ ⵉ ⴷ ⴰⵙⴻⵏⵜ-ⵉ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵏⴻⴷⴷⴰⵎ-ⴰ, ⴰⵍ ⴱⴰⵄⵍ. ⵜⵉⵏⴰ ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵎⴰⵏⵉ ⵣⴻⴷⵖⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵃⴹⴰⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_34","014_4_34","1CH","4","34","34","ⵎⴰⵛⵓⴱⴰⴱ ⴷ ⵢⴰⵎⵍⵉⴽ ⴷ ⵢⵓⵛⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⴰⵚⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R14_35","014_4_35","1CH","4","35","35","ⴷ ⵢⵓⵡⵉⵍ ⴷ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⴱⴰ, ⵎⵎⵉⵙ ⵏ ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵙⵉⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R14_36","014_4_36","1CH","4","36","36","ⴷ ⵉⵍⵢⵓⵄⵉⵏⴰⵢ ⴷ ⵢⴰⵄⵇⵓⴱⴰ ⴷ ⵢⴰⵛⵓⵃⴰⵢⴰ ⴷ ⵄⴰⵙⴰⵢⴰ ⴷ ⵄⴰⴷⵉⵢⵉⵍ ⴷ ⵢⴰⵙⵉⵎⵉⵢⵉⵍ ⴷ ⴱⴰⵏⴰⵢⴰ ");
INSERT INTO rift_vpl VALUES ("R14_37","014_4_37","1CH","4","37","37","ⴷ ⵣⵉⵣⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⴼⵄⵉ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵍⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴷⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵄⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R14_38","014_4_38","1CH","4","38","38","ⵉⵏⴰ, ⵉⵏⵏⵉ ⵉ ⴷⴰ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷⵉ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵎⵎⴰⵔⵏⵉⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R14_39","014_4_39","1CH","4","39","39","ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ, ⴽⴽⵉⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵏ ⵊⴰⴷⵓⵔ ⴰⵍ ⵛⵛⴰⵔⵇ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵓⴼⵉⵏ ⵎⴰⵏⵉ ⵖⴰ ⵀⴻⴷⴷⴻⵏ ⵡⵓⴵⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_40","014_4_40","1CH","4","40","40","ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⴷⵉⵏ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵛⵛⵓⵔⴻⵏ ⵎⵍⵉⵃ, ⵛⵏⴰⵏ. ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵡⵙⴻⵄ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵜⴰⵔⵙⴰ ⵓ ⴷⴰⵢⴻⵙ ⵍⵀⵓⴷⵏⴻⵜ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵏ ⵃⴰⵎ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⵣⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("R14_41","014_4_41","1CH","4","41","41","ⵉⵏⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵏⵉⵜⵏⵉ ⵀⴻⴷⵎⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵎⴰⵄⵓⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴷⵉⵏ ⵓⴼⵉⵏ, ⵜⴻⵃⵃⴰⵏ ⵜⴻⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵡⵓⴵⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_42","014_4_42","1CH","4","42","42","ⵣⴻⴳ ⵉⵏⴰ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ, ⴼⴼⵖⴻⵏ ⵄⴰⵡⴻⴷ ⵅⴻⵎⵙⴰ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ. ⴼⴰⵍⴰⵟⵢⴰ ⴷ ⵏⴰⵄⵔⵉⵢⴰ ⴷ ⵔⴰⴼⴰⵢⴰ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵉⵛⵄⵉ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R14_43","014_4_43","1CH","4","43","43","ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ ⵉⵏⵏⵉ ⴷⴷ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R15_1","014_5_1","1CH","5","1","1","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⵓⴱⵉⵏ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵔⴰⵉⵍ - ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵏⵣⵓ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵜⴰⵙⵙⵓⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵜⴻⵎⵎⴻⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏⵏⴻⵙ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵙⵓⴼ, ⵎⵎⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ ⴰⵍⴰⵎⵉ ⵢⵓⵙⵓⴼ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R15_2","014_5_2","1CH","5","2","2","ⵎⴰⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⵉⴷⵡⴻⵍ ⴷ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ ⵓ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴼⴻⵖ ⵍⵃⴰⴽⴻⵎ ⵡⴰⵅⵅⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵖⴰⵔ ⵢⵓⵙⵓⴼ - ");
INSERT INTO rift_vpl VALUES ("R15_3","014_5_3","1CH","5","3","3","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⵓⴱⵉⵏ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵃⴰⵏⵓⴽ ⴷ ⴼⴰⵍⵍⵓ, ⵃⴰⵚⵔⵓⵏ ⴷ ⴽⴰⵔⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("R15_4","014_5_4","1CH","5","4","4","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵓⵡⵉⵍ: ⵎⵎⵉⵙ ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵀⴰⵊⵓⵊ ⵎⵎⵉⵙ ⵛⵉⵎⵄⵉ, ");
INSERT INTO rift_vpl VALUES ("R15_5","014_5_5","1CH","5","5","5","ⵎⵎⵉⵙ ⵎⵉⵅⴰ, ⵎⵎⵉⵙ ⵔⴰ’ⴰⵢⴰ, ⵎⵎⵉⵙ ⴱⴰⵄⵍ ");
INSERT INTO rift_vpl VALUES ("R15_6","014_5_6","1CH","5","6","6","ⴷ ⵎⵎⵉⵙ ⴱⴰ’ⵉⵔⴰ, ⵡⴻⵏⵏⵉ ⵢⵉⵡⵢⵉ ⵜⵉⵖⵍⴰⵜ-ⴼⵉⵍⴰⵙⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⴷⵉ ⵍⵎⴻⵏⴼⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_7","014_5_7","1CH","5","7","7","ⴰⵢⵜⵎⴰⵙ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵅⵍⴰⵇ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵣⴻⴵⵉⴼ ⵢⴰⵄⵉⵢⵉⵍ ⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ");
INSERT INTO rift_vpl VALUES ("R15_8","014_5_8","1CH","5","8","8","ⴷ ⴱⵉⵍⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⵉⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵄⴰⵔⵓⵄⵉⵔ ⴰⵍ ⵏⴰⴱⵓ ⴷ ⴱⴰⵄⵍ-ⵎⴰⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_9","014_5_9","1CH","5","9","9","ⵉⵣⴷⴻⵖ ⴷⵉ ⵛⵛⴰⵔⵇ ⴰⵍ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵉ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵎⴰⵖⴰⵔ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R15_10","014_5_10","1CH","5","10","10","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⵀⴰⵊⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⴰⵖⴻⵣⴷⵉⵙ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R15_11","014_5_11","1CH","5","11","11","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⴷ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵊⴻⵎⵎⴰⴹⵉⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⴰⵛⴰⵏ ⴰⵍ ⵙⴰⵍⵅⴰ. ");
INSERT INTO rift_vpl VALUES ("R15_12","014_5_12","1CH","5","12","12","ⵢⵓⵡⵉⵍ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵓ ⵛⴰⴼⴰⵎ ⵜⵓⵖⴰ-ⵜ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷ ⵢⴰⵄⵏⴰⵢ ⴷ ⵛⴰⴼⴰⵜ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_13","014_5_13","1CH","5","13","13","ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⵉⵅⴰⵢⵉⵍ ⴷ ⵎⴰⵛⵓⵍⵍⴰⵎ ⴷ ⵛⴰⴱⵄⴰ ⴷ ⵢⵓⵔⴰⵢ ⴷ ⵢⴰⵄⴽⴰⵏ ⴷ ⵣⵉⵄⴰ ⴷ ⵄⴰⴱⵉⵔ, ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_14","014_5_14","1CH","5","14","14","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⴱⵉⵃⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵃⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃ, ⵎⵎⵉⵙ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵛⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⴷⵓ, ⵎⵎⵉⵙ ⵏ ⴱⵓⵣ. ");
INSERT INTO rift_vpl VALUES ("R15_15","014_5_15","1CH","5","15","15","ⴰⵅⵉ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⴷⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵊⵓⵏⵉ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_16","014_5_16","1CH","5","16","16","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵊⵉⵍⵄⴰⴷ, ⴷⵉ ⴱⴰⵛⴰⵏ ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏ ⵛⴰⵔⵓⵏ ⴰⵍ ⵜⵉⵎⴰⵡⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_17","014_5_17","1CH","5","17","17","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰⵜ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵜⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R15_18","014_5_18","1CH","5","18","18","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⵙⵙⵉⴼ ⴷ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵍⵇⴻⵡⵙ ⵓ ⵜⵓⵖⴰ ⴷⴰⵔⵔⴱⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R15_19","014_5_19","1CH","5","19","19","ⵏⵉⵜⵏⵉ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵀⴰⵊⵔⵉⵢⵢⴻⵏ ⵓ ⴰⴽ-ⴷ ⵢⴰⵟⵓⵔ ⴷ ⵏⴰⴼⵉⵛ ⴷ ⵏⵓⴷⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R15_20","014_5_20","1CH","5","20","20","ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵄⴰⵡⵏⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵀⴰⵊⵔⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵉⴵⴰⵏ, ⵎⵎⴻⵡⵛⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⵉⵙⵙⴰⵔⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⴻⵛⵍⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R15_21","014_5_21","1CH","5","21","21","ⵏⵉⵜⵏⵉ ⵃⴻⵡⵡⵙⴻⵏ ⵍⵎⴰⵍ ⵏⵙⴻⵏ: ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵡⵓⴵⵉ ⵓ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵢⴻⵖⵢⴰⵍ ⵓ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_22","014_5_22","1CH","5","22","22","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⴰⵍ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("R15_23","014_5_23","1CH","5","23","23","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ. ⵏⵉⵜⵏⵉ ⵎⵎⴰⵔⵏⵉⵏ ⵣⵉ ⴱⴰⵛⴰⵏ ⴰⵍ ⴱⴰⵄⵍ-ⵃⵉⵔⵎⵓⵏ ⴷ ⵙⴰⵏⵉⵔ ⴷ ⵡⴻⴷⵔⴰⵔ ⵏ ⵃⴰⵔⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_24","014_5_24","1CH","5","24","24","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ: ⵄⵉⴼⴰⵔ ⴷ ⵢⵉⵛⵄⵉ ⴷ ⵉⵍⵉⵢⵉⵍ ⴷ ⵄⴰⵣⵔⵉⵢⵉⵍ ⴷ ⵉⵔⵎⵉⵢⴰ ⴷ ⵀⵓⴷⴰⵢⴰ ⴷ ⵢⴰⵃⴷⵉⵢⵉⵍ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⵉⵙⴻⵎ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_25","014_5_25","1CH","5","25","25","ⵏⵉⵜⵏⵉ ⵖⴷⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⴻⵃⵃⴰ ⴰⵔⴻⴱⴱⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R15_26","014_5_26","1CH","5","26","26","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴱⵓⵃⴱⴻⵍ ⵏ ⴼⵓⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⴷ ⴱⵓⵃⴱⴻⵍ ⵏ ⵜⵉⵖⵍⴰⵜ-ⴼⵉⵍⵏⴰⵙⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ: ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵃⴰⵍⴰⵃ ⴷ ⵅⴰⴱⵓⵔ ⴷ ⵀⴰⵔⴰⵏ ⵓ ⵖⴰⵔ ⵉⵖⵣⴰⵔ ⵏ ⵊⵓⵣⴰⵏ, ⵓ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R15_27","014_5_27","1CH","5","27","27","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⴰⵔⵛⵓⵏ, ⵇⴰⵀⴰⵜ ⴷ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R15_28","014_5_28","1CH","5","28","28","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵎⵔⴰⵎ, ⵢⵉⵚⵀⴰⵔ ⴷ ⵃⴰⴱⵔⵓⵏ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R15_29","014_5_29","1CH","5","29","29","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵎⵔⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⵓⵙⴰ, ⵓ ⵎⴰⵔⵢⴰⵎ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ, ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R15_30","014_5_30","1CH","5","30","30","ⴰⵍⵉⵄⴰⵣⴰⵔ ⵉⵊⵊⴰ-ⴷⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⴼⵉⵏⴰⵃⴰⵙ ⵉⵊⵊⴰ-ⴷⴷ ⴰⴱⵉⵛⵓⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R15_31","014_5_31","1CH","5","31","31","ⴰⴱⵉⵛⵓⵖⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵓⵇⵇⵉ, ⴱⵓⵇⵇⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⵣⵣⵉ, ");
INSERT INTO rift_vpl VALUES ("R15_32","014_5_32","1CH","5","32","32","ⵄⵓⵣⵣⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵣⴰⵔⴰⵃ-ⵢⴰⵀ, ⵣⴰⵔⴰⵃ-ⵢⴰⵀ ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵔⴰⵢⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("R15_33","014_5_33","1CH","5","33","33","ⵎⴰⵔⴰⵢⵓⵜ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵎⴰⵔⵢⴰ, ⴰⵎⴰⵔⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵅⵉⵟⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("R15_34","014_5_34","1CH","5","34","34","ⴰⵅⵉⵟⵓⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵚⴰⴷⵓⵇ, ⵚⴰⴷⵓⵇ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵅⵉⵎⴰⵄⴰⵚ, ");
INSERT INTO rift_vpl VALUES ("R15_35","014_5_35","1CH","5","35","35","ⴰⵅⵉⵎⴰⵄⴰⵚ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵣⴰⵔⵢⴰ, ⵄⴰⵣⴰⵔⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵃⴰⵏⴰⵏ ");
INSERT INTO rift_vpl VALUES ("R15_36","014_5_36","1CH","5","36","36","ⵓ ⵢⵓⵃⴰⵏⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵣⴰⵔⵢⴰ. ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R15_37","014_5_37","1CH","5","37","37","ⵄⴰⵣⴰⵔⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵎⴰⵔⵢⴰ, ⴰⵎⴰⵔⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵅⵉⵟⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("R15_38","014_5_38","1CH","5","38","38","ⴰⵅⵉⵟⵓⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵚⴰⴷⵓⵇ, ⵚⴰⴷⵓⵇ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵍⵍⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("R15_39","014_5_39","1CH","5","39","39","ⵛⴰⵍⵍⵓⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵃⵉⵍⵇⵉⵢⴰ, ⵃⵉⵍⵇⵉⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵣⴰⵔⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R15_40","014_5_40","1CH","5","40","40","ⵄⴰⵣⴰⵔⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵙⴰⵔⴰⵢⴰ ⵓ ⵙⴰⵔⴰⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R15_41","014_5_41","1CH","5","41","41","ⵢⴰⵀⵓⵚⴰⴷⴰⵇ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵎⵉ ⵙⵉⴷⵉ ⵉⵏⴷⴻⵀ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R16_1","014_6_1","1CH","6","1","1","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⴰⵔⵛⵓⵏ, ⵇⴰⵀⴰⵜ ⴷ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_2","014_6_2","1CH","6","2","2","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵔⵛⵓⵏ: ⵍⵉⴱⵏⵉ ⴷ ⵛⵉⵎⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_3","014_6_3","1CH","6","3","3","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵎⵔⴰⵎ, ⵢⵉⵚⵃⴰⵔ, ⵃⴰⴱⵔⵓⵏ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R16_4","014_6_4","1CH","6","4","4","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵃⵍⵉ ⴷ ⵎⵓⵛⵉ. ⵜⵉⵏⴰ ⴷ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_5","014_6_5","1CH","6","5","5","ⵏ ⵊⴰⵔⵛⵓⵏ: ⵎⵎⵉⵙ ⵍⵉⴱⵏⵉ, ⵎⵎⵉⵙ ⵢⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵣⵉⵎⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_6","014_6_6","1CH","6","6","6","ⵎⵎⵉⵙ ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵄⵉⴷⴷⵓ, ⵎⵎⵉⵙ ⵣⴰⵔⴰⵃ ⴷ ⵎⵎⵉⵙ ⵢⴰⵜⵔⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R16_7","014_6_7","1CH","6","7","7","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵃⴰⵜ: ⵎⵎⵉⵙ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵇⵓⵔⴰⵃ, ⵎⵎⵉⵙ ⴰⵙⵙⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("R16_8","014_6_8","1CH","6","8","8","ⵎⵎⵉⵙ ⵉⵍⵇⴰⵏⴰ, ⵎⵎⵉⵙ ⴰⴱⵉⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⴰⵙⵙⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("R16_9","014_6_9","1CH","6","9","9","ⵎⵎⵉⵙ ⵜⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵓⵔⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵄⵓⵣⵣⵉⵢⴰ ⴷ ⵎⵎⵉⵙ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("R16_10","014_6_10","1CH","6","10","10","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵇⴰⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵎⴰⵙⴰⵢ ⴷ ⴰⵅⵉⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R16_11","014_6_11","1CH","6","11","11","ⵉⵍⵇⴰⵏⴰ: ⵎⵎⵉⵙ ⵜⵓⵖⴰ-ⵜ ⵉⵍⵇⴰⵏⴰ, ⵎⵎⵉⵙ ⵚⵓⴼⴰⵢ, ⵎⵎⵉⵙ ⵏⴰⵃⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("R16_12","014_6_12","1CH","6","12","12","ⵎⵎⵉⵙ ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵢⴰⵔⵓⵃⴰⵎ ⴷ ⵎⵎⵉⵙ ⵉⵍⵇⴰⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R16_13","014_6_13","1CH","6","13","13","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⵓⵡⵉⵍ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⵓ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴰⴱⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R16_14","014_6_14","1CH","6","14","14","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ: ⵎⴰⵃⵍⵉ, ⵎⵎⵉⵙ ⵍⵉⴱⵏⵉ, ⵎⵎⵉⵙ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵄⵓⵣⵣⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_15","014_6_15","1CH","6","15","15","ⵎⵎⵉⵙ ⵛⵉⵎⵄⴰ, ⵎⵎⵉⵙ ⵃⴰⵊⵉⵢⴰ ⴷ ⵎⵎⵉⵙ ⵄⴰⵙⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R16_16","014_6_16","1CH","6","16","16","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵓⵖⴻⵏⵏⴻⵊ ⵏ ⵢⵉⵣⵍⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵉⵡⴻⴹ ⵜⵜⴰⴱⵓⵜ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_17","014_6_17","1CH","6","17","17","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵙ ⵉⵣⵍⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⴰⵍ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵓⵍⵉⵎⴰⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_18","014_6_18","1CH","6","18","18","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵇⴰⵃⴰⵜⵉⵢⵢⴻⵏ: ⵀⴰⵢⵎⴰⵏ, ⴰⵎⴻⴷⵢⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵡⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R16_19","014_6_19","1CH","6","19","19","ⵎⵎⵉⵙ ⵏ ⵉⵍⵇⴰⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵜⵓⵡⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("R16_20","014_6_20","1CH","6","20","20","ⵎⵎⵉⵙ ⵏ ⵚⵓⴼ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵇⴰⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⴰⵙⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("R16_21","014_6_21","1CH","6","21","21","ⵎⵎⵉⵙ ⵏ ⵉⵍⵇⴰⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴼⴰⵏⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_22","014_6_22","1CH","6","22","22","ⵎⵎⵉⵙ ⵏ ⵜⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵏ ⴰⵙⵙⵉⵔ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵔⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("R16_23","014_6_23","1CH","6","23","23","ⵎⵎⵉⵙ ⵏ ⵢⵉⵚⵀⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵀⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ, ⵎⵎⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R16_24","014_6_24","1CH","6","24","24","ⵓⵎⴰⵙ ⴰⵙⴰⴼ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴻⴷⴷⴰ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⴰⵙⴰⴼ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵉ, ");
INSERT INTO rift_vpl VALUES ("R16_25","014_6_25","1CH","6","25","25","ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⴽⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_26","014_6_26","1CH","6","26","26","ⵎⵎⵉⵙ ⵏ ⵉⵜⵏⵉ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴷⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_27","014_6_27","1CH","6","27","27","ⵎⵎⵉⵙ ⵏ ⵉⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵣⵉⵎⵎⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵉ, ");
INSERT INTO rift_vpl VALUES ("R16_28","014_6_28","1CH","6","28","28","ⵎⵎⵉⵙ ⵏ ⵢⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵔⵛⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_29","014_6_29","1CH","6","29","29","ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ: ⵉⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⵉⵛⵉ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⴷⵉ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⵍⵓⵅ, ");
INSERT INTO rift_vpl VALUES ("R16_30","014_6_30","1CH","6","30","30","ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⴰⴱⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_31","014_6_31","1CH","6","31","31","ⵎⵎⵉⵙ ⵏ ⴰⵎⵚⵉ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⵉ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("R16_32","014_6_32","1CH","6","32","32","ⵎⵎⵉⵙ ⵏ ⵎⴰⵃⵍⵉ, ⵎⵎⵉⵙ ⵏ ⵎⵓⵛⵉ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_33","014_6_33","1CH","6","33","33","ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵇⴰⵄ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_34","014_6_34","1CH","6","34","34","ⵎⴰⵛⴰ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⵇⴰⵄ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⵚⵍⴰⵃ ⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_35","014_6_35","1CH","6","35","35","ⵉⵏⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ: ⵎⵎⵉⵙ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⴰⴱⵉⵛⵓⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R16_36","014_6_36","1CH","6","36","36","ⵎⵎⵉⵙ ⴱⵓⵇⵇⵉ, ⵎⵎⵉⵙ ⵄⵓⵣⵣⵉ, ⵎⵎⵉⵙ ⵣⴰⵔⴰⵃ-ⵢⴰⵀ ");
INSERT INTO rift_vpl VALUES ("R16_37","014_6_37","1CH","6","37","37","ⵎⵎⵉⵙ ⵎⴰⵔⴰⵢⵓⵜ, ⵎⵎⵉⵙ ⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⴰⵅⵉⵟⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("R16_38","014_6_38","1CH","6","38","38","ⵎⵎⵉⵙ ⵚⴰⴷⵓⵇ ⴷ ⵎⵎⵉⵙ ⴰⵅⵉⵎⴰⵄⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("R16_39","014_6_39","1CH","6","39","39","ⵉⵏⴰ ⴷ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ: ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⵉ ⵍⴰⴵ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜⵜ ⵜⴻⵇⴷⵓⵃⵜ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_40","014_6_40","1CH","6","40","40","ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵃⴰⴱⵔⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_41","014_6_41","1CH","6","41","41","ⵉⵢⵢⴰⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵡⵛⵉⵏ ⵜ ⵉ ⴽⴰⵍⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴼⵓⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R16_42","014_6_42","1CH","6","42","42","ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵃⴰⴱⵔⵓⵏ ⴷ ⵍⵉⴱⵏⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⵢⴰⵜⵜⵉⵔ ⴷ ⵉⵛⵜⴰⵎⵓⵄⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_43","014_6_43","1CH","6","43","43","ⵃⵉⵍⴰⵢⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⴷⴰⴱⵉⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_44","014_6_44","1CH","6","44","44","ⴷ ⵄⴰⵛⴰⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_45","014_6_45","1CH","6","45","45","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵊⴰⴱⵄⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵄⴰⵍⵍⵉⵎⴰⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵄⴰⵏⴰⵜⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_46","014_6_46","1CH","6","46","46","ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴰⴵ ⵏ ⵜⴻⵇⴱⵉⵍⵜ, ⵜⵜⵡⴰⵄⴻⵢⵢⵏⴻⵏⵜ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵄⴻⵛⵔⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ, ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R16_47","014_6_47","1CH","6","47","47","ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵔⵛⵓⵏ ⵜⵜⵡⴰⵄⴻⵢⵢⵏⴻⵏⵜ ⵄⵍⴰⵃⵚⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ, ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉ ⴱⴰⵛⴰⵏ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R16_48","014_6_48","1CH","6","48","48","ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⵄⵍⴰⵀⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵄⴻⵢⵢⵏⴻⵏⵜ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_49","014_6_49","1CH","6","49","49","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⵛⵉⵏ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R16_50","014_6_50","1CH","6","50","50","ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵡⵛⵉⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵙⴻⵏⵜ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_51","014_6_51","1CH","6","51","51","ⵓⵛⴰ ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ ⵟⵟⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R16_52","014_6_52","1CH","6","52","52","ⵎⵉⵏⵣⵉ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵛⴰⴽⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⴷ ⵊⴰⵣⴰⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_53","014_6_53","1CH","6","53","53","ⴷ ⵢⴰⵇⵎⴰⵄⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_54","014_6_54","1CH","6","54","54","ⴷ ⴰⵢⴰⵍⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⴷ ⵊⴰⵜ-ⵔⵉⵎⵎⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_55","014_6_55","1CH","6","55","55","ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵏⵉⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⴱⵉⵍⵄⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴰⴵ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R16_56","014_6_56","1CH","6","56","56","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵔⵛⵓⵎ ⴽⵙⵉⵏ ⵄⴰⵡⴻⴷ ⵣⵉ ⵍⴰⴵ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: ⵊⵓⵍⴰⵏ ⴷⵉ ⴱⴰⵛⴰⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⴷ ⵄⴰⵛⵜⴰⵔⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_57","014_6_57","1CH","6","57","57","ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵇⴰⴷⴰⵛ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷⵓⴱⵔⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_58","014_6_58","1CH","6","58","58","ⵔⴰⵎⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⵓ ⵄⴰⵏⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_59","014_6_59","1CH","6","59","59","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰⵍ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵄⴰⴱⴷⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_60","014_6_60","1CH","6","60","60","ⴷ ⵃⵓⵇⵓⵇ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵔⴰⵃⵓⴱ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_61","014_6_61","1CH","6","61","61","ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵇⴰⴷⴰⵛ ⴷⵉ ⵍⵊⴰⵍⵉⵍ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵃⴰⵎⵎⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ⴷ ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R16_62","014_6_62","1CH","6","62","62","ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⴽⵙⵉⵏ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ ⵔⵉⵎⵎⵓⵏⵓ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵜⴰⴱⵓⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("R16_63","014_6_63","1CH","6","63","63","ⵓ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⴰⵔⵉⵃⴰ, ⵛⵛⴰⵔⵇ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ ⴱⴰⵚⴰⵔ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵢⴰⵀⵚⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_64","014_6_64","1CH","6","64","64","ⴷ ⵇⴰⴷⵉⵎⵓⵜ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵎⴰⵢⴼⴰⵄⴰ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_65","014_6_65","1CH","6","65","65","ⵓ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵎⴰⵃⴰⵏⴰⵢⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R16_66","014_6_66","1CH","6","66","66","ⴷ ⵃⴰⵛⴱⵓⵏ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⴷ ⵢⴰⵄⵣⵉⵔ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R17_1","014_7_1","1CH","7","1","1","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵙⵙⴰⴽⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵜⵓⵍⴰⵄ ⴷ ⴼⵓⵡⵡⴰ ⴷ ⵢⴰⵛⵓⴱ ⴷ ⵛⵉⵎⵔⵓⵏ, ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_2","014_7_2","1CH","7","2","2","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵜⵓⵍⴰⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⵓⵣⵣⵉ, ⵔⴰⴼⴰⵢⴰ, ⵢⴰⵔⵉⵢⵉⵍ, ⵢⴰⵃⵎⴰⵢ, ⵢⵉⴱⵛⴰⵎ ⴷ ⵛⵉⵎⵓⵡⵉⵍ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵏ ⵜⵓⵍⴰⵄ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵅⵍⴰⵇ ⵏⵙⴻⵏ. ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_3","014_7_3","1CH","7","3","3","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⵣⵣⵉ, ⵎⵖⵉⵔ ⵢⴰⵣⵔⴰⵃⵢⴰ, ⵓ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵣⵔⴰⵃⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⵉⵅⴰⵢⵉⵍ, ⵄⵓⴱⴰⴷⵢⴰ, ⵢⵓⵡⵉⵍ ⴷ ⵢⴰⵛⵛⵉ-ⵢⴰⵀ, ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_4","014_7_4","1CH","7","4","4","ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵍⵓⵎⵓⵔ ⵅ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⴰⵇⴰ-ⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_5","014_7_5","1CH","7","5","5","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵙⴻⴱⵄⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⵉⵙⵜⴰⵜ ⵏ ⵊⵊⴰⴷⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_6","014_7_6","1CH","7","6","6","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴱⵉⵍⴰⵄ, ⴱⴰⴽⴰⵔ ⴷ ⵢⴰⴷⵉⵄⴰⵢⵉⵍ, ⵜⵍⴰⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_7","014_7_7","1CH","7","7","7","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵍⴰⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵚⴱⵓⵏ, ⵄⵓⵣⵣⵉ, ⵄⵓⵣⵣⵉⵢⵉⵍ, ⵢⴰⵔⵉⵎⵓⵜ ⴷ ⵄⴰⵢⵔⵉ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰⵜ ⵏ ⵊⵊⴰⴷⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_8","014_7_8","1CH","7","8","8","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⴰⴽⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵣⴰⵎⵉⵔⴰ, ⵢⵓⵄⴰⵛ, ⵉⵍⵉⵄⴰⵣⴰⵔ, ⵉⵍⵢⵓⵄⵉⵏⴰⵢ, ⵄⵓⵎⵔⵉ, ⵢⴰⵔⵉⵎⵓⵜ, ⴰⴱⵉⵢⴰ, ⵄⴰⵏⴰⵜⵓⵜ ⴷ ⵄⴰⵍⴰⵎⴰⵜ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R17_9","014_7_9","1CH","7","9","9","ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰⵜ ⵏ ⵍⴰⴵⴰⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_10","014_7_10","1CH","7","10","10","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴷⵉⵄⵉⵍ, ⵎⵖⵉⵔ ⴱⵉⵍⵀⴰⵏ. ⵓ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵍⵀⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⵄⵉⵛ, ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵀⵓⴷ, ⴽⴰⵏⵄⴰⵏⴰ, ⵣⴰⵢⵜⴰⵏ, ⵜⴰⵔⵛⵉⵛ ⴷ ⴰⵅⵉⵛⴰⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R17_11","014_7_11","1CH","7","11","11","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴷⵉⵄⵉⵍ. ⵙⴱⴻⵄⵟⴰⵛ-ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_12","014_7_12","1CH","7","12","12","ⵛⵓⴼⴼⵉⵎ ⴷ ⵀⵓⴼⴼⵉⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵉⵔ, ⵀⵓⵛⵉⵎ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵃⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R17_13","014_7_13","1CH","7","13","13","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⴰⵃⵚⵉⵢⵉⵍ, ⵊⵓⵏⵉ, ⵢⴰⵚⴰⵔ ⴷ ⵛⴰⵍⵍⵓⵎ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵍⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_14","014_7_14","1CH","7","14","14","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: ⴰⵛⵔⵉⵢⵉⵍ, ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⵔⴰⵎⵉⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵎⴰⵅⵉⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵊⵉⵍⵄⴰⴷ.    ");
INSERT INTO rift_vpl VALUES ("R17_15","014_7_15","1CH","7","15","15","ⵎⴰⵅⵉⵔ ⵉⴽⵙⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵃⵓⴼⴼⵉⵎ ⴷ ⵛⵓⴼⴼⵉⵎ. ⵉⵙⴻⵎ ⵏ ⵓⵍⵜⵎⴰⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵎⴰⵄⴽⴰ. ⵉⵙⴻⵎ ⵏ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴷ ⵚⴰⵍⵓⴼⵃⴰⴷ. ⵚⴰⵍⵓⴼⵃⴰⴷ ⵖⴰⵔⴻⵙ ⵢⴻⵙⵙⵉⵙ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_16","014_7_16","1CH","7","16","16","ⵎⴰⵄⴽⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⴰⵅⵉⵔ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⵙ ⴼⴰⵔⴰⵛ ⵓ ⵓⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⴰⵔⴰⵛ ⵓ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵓⵍⴰⵎ ⴷ ⵔⴰⵇⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R17_17","014_7_17","1CH","7","17","17","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵍⴰⵎ: ⵎⵖⵉⵔ ⴱⴰⴷⴰⵏ. ⵉⵏⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⵉⵍⵄⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵅⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_18","014_7_18","1CH","7","18","18","ⵅ ⵓⵍⵜⵎⴰⵙ ⵀⴰⵎⵓⵍⴰⴽⴰⵜ, ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵛⵀⵓⴷ, ⴰⴱⵉⵄⴰⵣⴰⵔ ⴷ ⵎⴰⵃⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_19","014_7_19","1CH","7","19","19","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎⵉⴷⴰⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵅⵢⴰⵏ, ⵛⴰⴽⵉⵎ ⴷ ⵍⴰⵇⵃⵉ ⴷ ⴰⵏⵉⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R17_20","014_7_20","1CH","7","20","20","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⵖⵉⵔ ⵛⵓⵜⴰⵍⴰⵃ. ⵎⵎⵉⵙ ⵜⵓⵖⴰ ⴱⴰⵔⴰⴷ, ⵎⵎⵉⵙ ⵜⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵉⵍⵄⴰⴷⴰ, ⵎⵎⵉⵙ ⵜⴰⵃⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("R17_21","014_7_21","1CH","7","21","21","ⵎⵎⵉⵙ ⵣⴰⴱⴰⴷ, ⵎⵎⵉⵙ ⵛⵓⵜⴰⵍⴰⵃ ⵓ ⵅⴻⵏⵏⵉ ⵄⴰⵣⴰⵔ ⴷ ⵉⵍⵄⴰⴷ. ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵊⴰⵜ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵖⵉⵏ ⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵀⵡⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴽⵙⴻⵏ ⵍⵎⴰⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_22","014_7_22","1CH","7","22","22","ⵉⴼⵔⴰⵢⵉⵎ, ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵉⵛⴹⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⴰⵢⵜⵎⴰⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵄⴻⵣⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_23","014_7_23","1CH","7","23","23","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵙ ⴱⴰⵔⵉⵄⴰ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵔⵥⵉⵢⵢⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R17_24","014_7_24","1CH","7","24","24","ⵢⴻⴵⵉⵙ ⵜⵓⵖⴰ ⵛⵉⵔⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴱⴻⴷⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵡⴰⴷⴷⴰⵢ ⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵏⵏⴻⵊ ⴷ ⵓⵣⵣⵉⵏ-ⵛⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_25","014_7_25","1CH","7","25","25","ⵔⴰⴼⴰⵄ ⵜⵓⵖⴰ ⴷ ⵎⵎⵉⵙ ⵓⵍⴰ ⴷ ⵔⴰⵛⴰⴼ. ⵓⵛⴰ ⵎⵎⵉⵙ ⵜⵓⵖⴰ ⴷ ⵜⴰⵍⴰⵃ, ⵎⵎⵉⵙ ⵜⴰⵃⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("R17_26","014_7_26","1CH","7","26","26","ⵎⵎⵉⵙ ⵍⴰⵄⴷⴰⵏ, ⵎⵎⵉⵙ ⵄⴰⵎⵎⵉⵀⵓⴷ, ⵎⵎⵉⵙ ⵉⵍⵉⵛⴰⵎⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("R17_27","014_7_27","1CH","7","27","27","ⵎⵎⵉⵙ ⵏⵓⵏ ⴷ ⵎⵎⵉⵙ ⵢⴰⵛⵓⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_28","014_7_28","1CH","7","28","28","ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⴷ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵜⵓⵖⴰ ⴱⴰⵢⵜ-ⵉⵍ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⴷ ⵏⴰⵄⵔⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓ ⵊⴰⵣⴰⵔ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⵙⴻⵏⵜ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵓⵍⴰ ⴷ ⵛⴰⴽⵉⵎ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴰⵍ ⵖⴰⵣⵣⴰ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_29","014_7_29","1CH","7","29","29","ⵜⵓⵖⴰ ⴱⴰⵢⵜ-ⵛⴰⵏ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵜⴰⵄⵏⴰⴽ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵎⴰⵊⵉⴷⴷⵓ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴷⵓⵔ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ⴰⵢⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵎⵎⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R17_30","014_7_30","1CH","7","30","30","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵛⵉⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⵉⵎⵏⴰ, ⵢⵉⵛⵡⴰ, ⵢⵉⵛⵡⵉ, ⴱⴰⵔⵉⵄⴰ ⴷ ⵙⴰⵔⴰⵃ ⵜⴻⵏⵏⵉ ⴷ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R17_31","014_7_31","1CH","7","31","31","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⴰⵔⵉⵄⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵃⴰⴱⵉⵔ ⴷ ⵎⴰⵍⴽⵉⵢⵉⵍ. ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱⴰ ⵏ ⴱⵉⵔⵣⴰⵡⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R17_32","014_7_32","1CH","7","32","32","ⵃⴰⴱⵉⵔ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⴼⵍⵉⵟ, ⵛⵓⵎⵉⵔ, ⵃⵓⵜⴰⵎ ⴷ ⵛⵓⵄⴰ, ⵓⵍⵜⵎⴰⵜⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("R17_33","014_7_33","1CH","7","33","33","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴼⵍⵉⵟ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴼⴰⵙⴰⴽ, ⴱⵉⵎⵀⴰⵍ ⴷ ⵄⴰⵛⵡⴰⵜ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴼⵍⵉⵟ. ");
INSERT INTO rift_vpl VALUES ("R17_34","014_7_34","1CH","7","34","34","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵅⵉ, ⵔⵓⵀⵊⴰ, ⵢⴰⵀⵓⴱⴱⴰ ⴷ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R17_35","014_7_35","1CH","7","35","35","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵎⴰⵙ ⵀⵉⵍⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵚⵓⴼⴰⵃ, ⵢⵉⵎⵏⴰⵃ, ⵛⴰⵍⴰⵛ ⴷ ⵄⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R17_36","014_7_36","1CH","7","36","36","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵚⵓⴼⴰⵃ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵙⵓⵡⴰⵃ, ⵃⴰⵔⴰⵏⴼⴰⵔ, ⵛⵓⵄⴰⵍ, ⴱⵉⵔⵉ, ⵢⴰⵎⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("R17_37","014_7_37","1CH","7","37","37","ⴱⴰⵚⴰⵔ, ⵀⵓⴷ, ⵛⴰⵎⵎⴰ, ⵛⵉⵍⵛⴰ, ⵢⵉⵜⵔⴰⵏ ⴷ ⴱⴰ’ⵉⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_38","014_7_38","1CH","7","38","38","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵉⵜⵔⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⴼⵓⵏⵏⵉ, ⴼⵉⵛⴼⴰ ⴷ ⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_39","014_7_39","1CH","7","39","39","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⵍⵍⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⴰⵃ, ⵃⴰⵏⵉⵢⵉⵍ ⴷ ⵔⵉⵚⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R17_40","014_7_40","1CH","7","40","40","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵛⵉⵔ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⴼⴰⵔⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰⵜ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵓⵎⴻⵏⵖⵉ. ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⵙⴻⵜⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R18_1","014_8_1","1CH","8","1","1","ⴱⵉⵏⵢⴰⵎⵉⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵉⵍⴰⵄ, ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ, ⴰⵛⴱⵉⵍ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⵅⵔⴰⵅ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("R18_2","014_8_2","1CH","8","2","2","ⵏⴰⵃⵓ ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ ⵔⴰⴼⴰ ⴷ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R18_3","014_8_3","1CH","8","3","3","ⴱⵉⵍⴰⵄ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⵔⴰⵡⴻⵏ-ⴰ: ⴰⴷⴷⴰⵔ, ⵊⵉⵔⴰ ⴷ ⴰⴱⵉⵀⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("R18_4","014_8_4","1CH","8","4","4","ⴰⴱⵉⵛⵓⵄⴰ, ⵏⵓⵄⵎⴰⵏ, ⴰⵅⵓⵅⴰ, ");
INSERT INTO rift_vpl VALUES ("R18_5","014_8_5","1CH","8","5","5","ⵊⵉⵔⴰ, ⵛⴰⴼⵓⴼⴰⵏ ⴷ ⵃⵓⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R18_6","014_8_6","1CH","8","6","6","ⵉⵏⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵃⵓⴷ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⴱⵄⴰ. ⵏⴻⴷⵀⴻⵏ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵎⴰⵏⴰⵃⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("R18_7","014_8_7","1CH","8","7","7","ⴰⵇⴰ ⴷ ⵏⴰⵄⵎⴰⵏ, ⴰⵅⵉⵢⴰ ⴷ ⵊⵉⵔⴰ. ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ. ⵓ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⵣⵣⴰ ⴷ ⴰⵅⵉⵃⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R18_8","014_8_8","1CH","8","8","8","ⵛⴰⵃⴰⵔⴰⵢⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵃⵓⵛⵉⵎ ⴷ ⴱⴰⵄⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R18_9","014_8_9","1CH","8","9","9","ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵅⵓⴷⴰⵛ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⴱⴰⴱ, ⴹⵉⴱⵢⴰ, ⵎⵉⵛⴰ, ⵎⴰⵍⴽⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("R18_10","014_8_10","1CH","8","10","10","ⵢⴰⵄⵓⵚ, ⵛⴰⴱⵉⵢⴰ ⴷ ⵎⵉⵔⵎⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R18_11","014_8_11","1CH","8","11","11","ⴰⴽ-ⴷ ⵃⵓⵛⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⴰⴱⵉⵟⵓⴱ ⴷ ⵉⵍⴼⴰⵄⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R18_12","014_8_12","1CH","8","12","12","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⴼⴰⵄⴰⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⴱⵉⵔ, ⵎⵉⵛⵄⴰⵎ, ⵛⴰⵎⵉⴷ ⵏⵏⵉ ⵉⴱⵏⴰⵏ ⵓⵏⵓ ⴷ ⵍⵓⴷ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R18_13","014_8_13","1CH","8","13","13","ⴱⴰⵔⵉⵄⴰ ⴷ ⵛⴰⵎⴰⵄ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴰⵢⴰⵍⵓⵏ. ⵏⵉⵜⵏⵉ ⵓⵥⵥⵍⴻⵏ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R18_14","014_8_14","1CH","8","14","14","ⴰⵅⵉⵢⵓ, ⵛⴰⵛⴰⵇ, ⵢⴰⵔⵉⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("R18_15","014_8_15","1CH","8","15","15","ⵣⴰⴱⴰⴷⵢⴰ, ⵄⴰⵔⴰⴷ, ⵄⴰⴷⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("R18_16","014_8_16","1CH","8","16","16","ⵎⵉⵅⴰⵢⵉⵍ, ⵊⵉⵛⴼⴰ ⴷ ⵢⵓⵅⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R18_17","014_8_17","1CH","8","17","17","ⵣⴰⴱⴰⴷⵢⴰ, ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵃⴰⵣⴽⵉ, ⵃⴰⴱⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("R18_18","014_8_18","1CH","8","18","18","ⵢⵉⵛⵎⴰⵔⴰⵢ, ⵢⴰⵣⵍⵉⵢⴰ ⴷ ⵢⵓⴱⴰⴱ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⴼⴰⵄⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R18_19","014_8_19","1CH","8","19","19","ⵢⴰⵇⵉⵎ, ⵣⵉⴽⵔⵉ, ⵣⴰⴱⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("R18_20","014_8_20","1CH","8","20","20","ⵉⵍⵉⵄⵉⵏⴰⵢ, ⵚⵉⵍⵍⴰⵜⴰⵢ, ⵉⵍⵉⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R18_21","014_8_21","1CH","8","21","21","ⵄⴰⴷⴰⵢⴰ, ⴱⴰⵔⴰⵢⴰ ⴷ ⵛⵉⵎⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("R18_22","014_8_22","1CH","8","22","22","ⵢⵉⵛⴼⴰⵏ, ⵄⴰⴱⵉⵔ, ⵉⵍⵉⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R18_23","014_8_23","1CH","8","23","23","ⵄⴰⴱⴷⵓⵏ, ⵣⵉⵅⵔⵉ, ⵃⴰⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("R18_24","014_8_24","1CH","8","24","24","ⵃⴰⵏⴰⵏⵢⴰ, ⵄⵉⵍⴰⵎ, ⵄⵏⵜⵓⵜⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R18_25","014_8_25","1CH","8","25","25","ⵢⴰⴼⴷⵉⵢⴰ ⴷ ⴼⴰⵏⵓⵡⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵛⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R18_26","014_8_26","1CH","8","26","26","ⵛⴰⵎⵛⴰⵔⴰⵢ, ⵛⴰⵃⴰⵔⵢⴰ, ⵄⴰⵜⴰⵍⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R18_27","014_8_27","1CH","8","27","27","ⵢⴰⵄⵔⴰⵛⵢⴰ, ⵉⵍⵉⵢⴰ ⴷ ⵣⵉⴽⵔⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵔⵓⵃⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R18_28","014_8_28","1CH","8","28","28","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉ ⵉⴵⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R18_29","014_8_29","1CH","8","29","29","ⴷⵉ ⵊⵉⴱⵄⵓⵏ ⵉⵣⴷⴻⵖ ⴱⴰⴱⴰⵙ ⵏ ⵊⵉⴱⵄⵓⵏ ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵄⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("R18_30","014_8_30","1CH","8","30","30","ⴰⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵄⴰⴱⴷⵓⵏ, ⵅⴻⵏⵏⵉ ⵚⵓⵔ, ⵇⵉⵙ, ⴱⴰⵄⴰⵍ, ⵏⴰⴷⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("R18_31","014_8_31","1CH","8","31","31","ⵊⴰⴷⵓⵔ, ⴰⵅⵅⵉⵢⵓ ⴷ ⵣⴰⴽⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R18_32","014_8_32","1CH","8","32","32","ⵎⵉⵇⵍⵓⵜ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵎⴰ. ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵢⴰⵢⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R18_33","014_8_33","1CH","8","33","33","ⵏⵉⵔ ⵉⵊⵊⴰ-ⴷⴷ ⵇⵉⵙ ⵓ ⵇⵉⵙ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵡⵓⵍ ⵓ ⵛⴰⵡⵓⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⴰⵍⴽⵉⵛⵓⵄⴰ, ⴰⴱⵉⵏⴰⴷⴰⴱ ⴷ ⵉⵛⴱⴰⵄⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R18_34","014_8_34","1CH","8","34","34","ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵜⵓⵖⴰ ⵎⴰⵔⵉⴱ-ⴱⴰⵄⴰⵍ. ⵎⴰⵔⵉⴱ-ⴱⴰⵄⴰⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵎⵉⵅⴰ. ");
INSERT INTO rift_vpl VALUES ("R18_35","014_8_35","1CH","8","35","35","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵉⵅⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴼⵉⵜⵓⵏ, ⵎⴰⵍⵉⴽ, ⵜⴰⵔⵉⵄ ⴷ ⴰⵃⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("R18_36","014_8_36","1CH","8","36","36","ⴰⵃⴰⵣ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵀⵓⵄⴰⴷⴷⴰ ⵓ ⵢⴰⵀⵓⵄⴰⴷⴷⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵍⵎⴰⵜ, ⵄⴰⵣⵎⴰⵡⴻⵜ ⴷ ⵣⵉⵎⵔⵉ. ⵣⵉⵎⵔⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵎⵓⵚⴰ, ");
INSERT INTO rift_vpl VALUES ("R18_37","014_8_37","1CH","8","37","37","ⵓ ⵎⵓⵚⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵉⵏⵄⴰ. ⵎⵎⵉⵙ ⵜⵓⵖⴰ ⵔⴰⴼⴰⵄ, ⵎⵎⵉⵙ ⵉⵍⵄⴰⵙⴰ ⴷ ⵎⵎⵉⵙ ⴰⵚⵉⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R18_38","014_8_38","1CH","8","38","38","ⴰⵚⵉⵢⴰⵍ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵓ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵄⴰⵣⵔⵉⵇⴰⵎ, ⴱⵓⴽⵔⴰ, ⵉⵙⵎⴰⵄⵉⵍ, ⵛⴰⵄⴰⵔⵢⴰ, ⵄⵓⴱⴰⴷⵢⴰ ⴷ ⵃⴰⵏⴰⵏ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵚⵉⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R18_39","014_8_39","1CH","8","39","39","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵎⴰⵙ ⵄⴰⵛⵉⵇ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵓⵍⴰⵎ, ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏⵏⴻⵙ, ⵓ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴷ ⵢⴰⵄⵓⵛ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵍⵉⴼⴰⵍⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("R18_40","014_8_40","1CH","8","40","40","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵍⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵍⵇⴻⵡⵙ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵡⴰⵢⵢⴰⵡⴻⵏ, ⵙ ⵎⴰⵔⵔⴰ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ. ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_1","014_9_1","1CH","9","1","1","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⵉ ⵍⵉⵙⵜⴰⵜ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵓ ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ. ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴷⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_2","014_9_2","1CH","9","2","2","ⵉⵎⴻⵣⴷⴰⵖ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵉ ⵉⴳⴳⵉⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⵅ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R19_3","014_9_3","1CH","9","3","3","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵣⴻⴷⵖⴻⵏ ⵉⵏⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ: ");
INSERT INTO rift_vpl VALUES ("R19_4","014_9_4","1CH","9","4","4","ⵄⵓⵜⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵀⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵎⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵉⵎⵔⵉ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴼⴰⵔⵉⵚ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R19_5","014_9_5","1CH","9","5","5","ⵣⴻⴳ ⴰⵛⵉⵍⵓⵏⵉⵢⵢⴻⵏ: ⵄⴰⵙⴰⵢⴰ, ⴰⵎⴻⵏⵣⵓ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R19_6","014_9_6","1CH","9","6","6","ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵣⴰⵔⴰⵃ: ⵢⴰⵄⵓⵢⵉⵍ ⵡⴰⵀⴰ. ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ ⵎⵢⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_7","014_9_7","1CH","9","7","7","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ: ⵙⴰⵍⵍⵓ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵀⵓⴷⵓⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵙⵏⵓⵡⴰ, ");
INSERT INTO rift_vpl VALUES ("R19_8","014_9_8","1CH","9","8","8","ⴷ ⵢⵉⴱⵏⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃⴰⵎ; ⵓ ⵉⵍⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉ, ⵎⵎⵉⵙ ⵏ ⵎⵉⴽⵔⵉ; ⵓ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵄⵓⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵢⵉⴱⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R19_9","014_9_9","1CH","9","9","9","ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_10","014_9_10","1CH","9","10","10","ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⵢⴰⴷⴰⵄⵢⴰ, ⵢⴰⵀⵓⵢⴰⵔⵉⴱ ⴷ ⵢⴰⴽⵉⵏ; ");
INSERT INTO rift_vpl VALUES ("R19_11","014_9_11","1CH","9","11","11","ⴷ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵔⴰⵢⵓⵜ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ; ");
INSERT INTO rift_vpl VALUES ("R19_12","014_9_12","1CH","9","12","12","ⴷ ⵄⴰⴷⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵛⵃⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⴽⵉⵢⴰ; ⵓ ⵎⴰⵄⵙⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴷⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵃⵣⵉⵔⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵉⵍⵍⵉⵎⵉⵜ, ⵎⵎⵉⵙ ⵏ ⵉⵎⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R19_13","014_9_13","1CH","9","13","13","ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵏⴻⵏ ⵖⴰⵔ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R19_14","014_9_14","1CH","9","14","14","ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⵔⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⴰⴱⵢⴰ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("R19_15","014_9_15","1CH","9","15","15","ⴷ ⴱⴰⵇⴱⴰⵇⴰⵔ ⴷ ⵃⴰⵔⴰⵛ ⴷ ⵊⴰⵍⴰⵍ ⴷ ⵎⴰⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰ, ⵎⵎⵉⵙ ⵏ ⵣⵉⴽⵔⵉ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ; ");
INSERT INTO rift_vpl VALUES ("R19_16","014_9_16","1CH","9","16","16","ⴷ ⵄⵓⴱⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵍⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴷⵓⵜⵓⵏ; ⴷ ⴱⴰⵔⴰⵅⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵇⴰⵏⴰ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⴷⵛⵓⵔ ⵏ ⵉⵏⴰⵟⵓⴼⴰⵜⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_17","014_9_17","1CH","9","17","17","ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⵍⵍⵓⵎ, ⵄⴰⵇⵇⵓⴱ, ⵟⴰⵍⵎⵓⵏ ⴷ ⴰⵅⵉⵎⴰⵏ ⴷ ⵜⴰⵡⵎⴰⵜ ⵏⵙⴻⵏ. ⵛⴰⵍⵍⵓⵎ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R19_18","014_9_18","1CH","9","18","18","ⴰⵍ ⵍⴻⵅⵅⵓ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("R19_19","014_9_19","1CH","9","19","19","ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵢⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵔⴰⵃ, ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵏⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵇⵓⵔⴰⵃⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴱⴷⴰⵜⵉⵏ ⵏ ⵓⵇⵉⴹⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R19_20","014_9_20","1CH","9","20","20","ⴼⵉⵏⴰⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵜⵓⵖⴰ-ⵜ ⵣⵉⵛ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏⵙⴻⵏ. ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R19_21","014_9_21","1CH","9","21","21","ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⴰⵍⵎⵉⵢⴰ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R19_22","014_9_22","1CH","9","22","22","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴰⵎ ⵢⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵡⴰⴷⴰⴼⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⴷⵉ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏ. ⴷⴰⵡⵓⴷ ⴷ ⵛⴰⵎⵡⵉⵍ, ⴰⵎⵡⴰⵍⴰⵡ, ⵙⵙⵎⴻⵜⵏⴻⵏ ⵜⴻⵏ ⴷⵉ ⵍⴼⵓⵙⵉⵏⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵡⴻⴽⴽⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_23","014_9_23","1CH","9","23","23","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵄⴻⵙⵙⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_24","014_9_24","1CH","9","24","24","ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ: ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("R19_25","014_9_25","1CH","9","25","25","ⵜⵓⵖⴰ ⵅ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⴷⵛⵓⵔ ⵏⵙⴻⵏ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵉⵛⵜ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⴷⵉ ⵍⵡⴰⵡⵇⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵊⵎⵉⵄ ⴰⴽⵉⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R19_26","014_9_26","1CH","9","26","26","ⵎⴰⵖⴰⵔ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⴷ ⴰⵙⴻⵏ-ⴷⴷ ⵉⵜⵜⵡⴰⵡⴻⴽⴽⵍⴻⵏ ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵅ ⵜⴻⵡⵡⵓⵔⴰ. ⵏⵉⵜⵏⵉ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵓ ⵅ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R19_27","014_9_27","1CH","9","27","27","ⴷⵉ ⴵⵉⵍⴻⵜ ⵙⵙⴻⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵜⵜⵡⴰⴽⴻⵍⵍⴼⴻⵏ ⵙ ⵜⵄⴻⵙⵙⴰⵙⵜ ⴷ ⵡⴰⵔⵣⴰⵎ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴽⵓⵍ ⵚⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("R19_28","014_9_28","1CH","9","28","28","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵅ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵃⴻⵙⵙⴱⴻⵏ ⵜⴻⵏ ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⵉⴷⴼⴻⵏ ⵓ ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_29","014_9_29","1CH","9","29","29","ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵅ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵅ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⴱⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵊⵊⴰⵡⵉ ⴷ ⵍⴻⵄⵟⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R19_30","014_9_30","1CH","9","30","30","ⵉⵎⵙⴻⵡⵊⵊⴰⴷⴻⵏ ⵏ ⵜⵅⴻⴵⴻⴹⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵄⵟⵓⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_31","014_9_31","1CH","9","31","31","ⵎⴰⵜⵜⵉⵜⵢⴰ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵛⴰⵍⵍⵓⵎ, ⴰⵇⵓⵔⴰⵃⵉ. ⵉⵜⵜⵡⴰⵡⴻⴽⴽⴻⵍ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵙⵙⴻⵏⴳⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R19_32","014_9_32","1CH","9","32","32","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵇⴰⵀⴰⵜⵉⵢⵢⴻⵏ, ⵣⴻⴳ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵜⵓⵖⴰ ⵛⴰ ⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⵅ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⴷⵉ ⵟⵟⴰⴱⵍⴰ ⴽⵓⵍ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("R19_33","014_9_33","1CH","9","33","33","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴼⴻⴽⴽⴻⵏ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵖⵏⵉ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵖⵍⴻⵏ ⴰⴽ-ⴷ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R19_34","014_9_34","1CH","9","34","34","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉ ⵉⴵⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R19_35","014_9_35","1CH","9","35","35","ⴷⵉ ⵊⵉⴱⵄⵓⵏ ⵣⴻⴷⵖⴻⵏ ⵢⴰⵄⵉⵢⵉⵍ, ⴱⴰⴱⴰⵙ ⵏ ⵊⵉⴱⵄⵓⵏ, ⵓ ⵉⵙⴻⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵎⴰⵄⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("R19_36","014_9_36","1CH","9","36","36","ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ ⵜⵓⵖⴰ ⵄⴰⴱⴷⵓⵏ. ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵚⵓⵔ, ⵇⵉⵙ, ⵏⵉⵔ, ⵏⴰⴷⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("R19_37","014_9_37","1CH","9","37","37","ⵊⴰⴷⵓⵔ, ⴰⵅⵉⵢⵓ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⴷ ⵎⵉⵇⵍⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R19_38","014_9_38","1CH","9","38","38","ⵎⵉⵇⵍⵓⵜ ⵉⵊⵊⴰ-ⴷⴷ ⵛⵉⵎⵄⴰ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R19_39","014_9_39","1CH","9","39","39","ⵏⵉⵔ ⵉⵊⵊⴰ-ⴷⴷ ⵇⵉⵙ, ⵇⵉⵙ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵡⵓⵍ ⵓ ⵛⴰⵡⵓⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⴰⵍⴽⵉⵛⵓⵄⴰ, ⴰⴱⵉⵏⴰⴷⴰⴱ ⴷ ⵉⵛⴱⴰⵄⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R19_40","014_9_40","1CH","9","40","40","ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵜⵓⵖⴰ ⵎⴰⵔⵉⴱ-ⴱⴰⵄⴰⵍ, ⵓ ⵎⴰⵔⵉⴱ-ⴱⴰⵄⴰⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵎⵉⵅⴰ. ");
INSERT INTO rift_vpl VALUES ("R19_41","014_9_41","1CH","9","41","41","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵉⵅⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴼⵉⵜⵓⵏ, ⵎⴰⵍⴰⴽ ⴷ ⵜⴰⵃⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R19_42","014_9_42","1CH","9","42","42","ⴰⵃⴰⵣ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵄⵔⴰ, ⵓ ⵢⴰⵄⵔⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵍⵎⴰⵜ, ⵄⴰⵣⵎⴰⵡⴻⵜ ⴷ ⵣⵉⵎⵔⵉ, ⵓ ⵣⵉⵎⵔⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵎⵓⵚⴰ, ");
INSERT INTO rift_vpl VALUES ("R19_43","014_9_43","1CH","9","43","43","ⵓ ⵎⵓⵚⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵉⵏⵄⴰ. ⵎⵎⵉⵙ ⵜⵓⵖⴰ ⵔⴰⴼⴰⵢⴰ, ⵎⵎⵉⵙ ⵉⵍⵄⴰⵙⴰ ⴷ ⵎⵎⵉⵙ ⵏⵏⴻⵙ ⴰⵚⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R19_44","014_9_44","1CH","9","44","44","ⴰⵚⵉⵍ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵓ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵄⴰⵣⵔⵉⵇⴰⵎ ⴷ ⴱⵓⴽⵔⴰ ⴷ ⵉⵙⵎⴰⵄⵉⵍ ⴷ ⵛⴰⵄⴰⵔⵢⴰ ⴷ ⵄⵓⴱⴰⴷⵢⴰ ⴷ ⵃⴰⵏⴰⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵚⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R110_1","014_10_1","1CH","10","1","1","ⵎⵎⴻⵏⵖⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ. ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵡⴹⴰⵏ ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R110_2","014_10_2","1CH","10","2","2","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴹⴼⴰⵔⴻⵏ ⵛⴰⵡⵓⵍ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴱⵍⴰ ⵇⴻⵟⵟⵓ. ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵖⵉⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⴰⴱⵉⵏⴰⴷⴰⴱ ⴷ ⵎⴰⵍⴽⵉⵛⵓⵄⴰ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("R110_3","014_10_3","1CH","10","3","3","ⵜⵓⵖⴰ ⴰⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ ⵉⵡⵄⴰⵔ. ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ ⵓⴼⵉⵏ ⵜ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ. ");
INSERT INTO rift_vpl VALUES ("R110_4","014_10_4","1CH","10","4","4","ⵉⵏⵏⴰ ⵛⴰⵡⵓⵍ ⵉ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ: “ⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵛ, ⵙⵏⵓⵇⵇⴻⴱ ⴰⵢⵉ ⵣⵣⴰⵢⴻⵙ! ⵏⵉⵖ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵉ ⵙⵜⴻⵀⵣⴰⵏ.” ⵎⴰⵛⴰ ⴰⵃⴻⵎⵎⴰⵍ ⵏⵏⴻⵙ ⵏ ⵍⴻⵙⵏⴰⵃ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⵜ ⵉⴳⴳ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ. ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵛⴰⵡⵓⵍ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵙⵙⴻⵖⴹⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R110_5","014_10_5","1CH","10","5","5","ⵓⵎⵉ ⵉⵥⵔⴰ ⵓⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ, ⴰⵇⴰ ⵛⴰⵡⵓⵍ ⵉⵎⵎⵓⵜ, ⵉⵡⴹⴰ ⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵅ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R110_6","014_10_6","1CH","10","6","6","ⵉⵎⵎⵓⵜ ⵛⴰⵡⵓⵍ ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵎⵎⵓ ⵜⴻⵎⵎⵓⵜ ⵇⴰⵄ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R110_7","014_10_7","1CH","10","7","7","ⵓⵎⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⴱⴻⵍⵍⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⵡⵍⴻⵏ ⵓ ⵛⴰⵡⵓⵍ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵏⵖⴻⵏ, ⵙⴻⵎⵃⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R110_8","014_10_8","1CH","10","8","8","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵓⴼⵉⵏ ⵛⴰⵡⵓⵍ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴹⴰⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵊⵉⵍⴱⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R110_9","014_10_9","1CH","10","9","9","ⵏⵉⵜⵏⵉ ⴽⴻⵛⵛⴹⴻⵏ ⵜ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵖⴰⵔ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵓ ⵖⴰⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R110_10","014_10_10","1CH","10","10","10","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵍⴻⵙⵏⴰⵃ ⵏ ⵛⴰⵡⵓⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵓ ⴰⵛⴻⵇⵇⵓⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵙⴻⵎⵎⴰⵔⴻⵏ ⵜ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⴱⴰⵢⵜ-ⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R110_11","014_10_11","1CH","10","11","11","ⵓⵎⵉ ⵙⵍⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⴱⵉⵛ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("R110_12","014_10_12","1CH","10","12","12","ⴽⴽⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⴽⵙⵉⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⵛⴰⵡⵓⵍ ⴷ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵢⴰⴱⵉⵛ. ⵏⵉⵜⵏⵉ ⵏⴻⴹⵍⴻⵏ ⵉⵖⵙⴰⵏ ⵏⵙⴻⵏ ⵙⴰⴷⵓ ⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⴷⵉ ⵢⴰⴱⵉⵛ ⵓⵛⴰ ⵥⵓⵎⵎⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R110_13","014_10_13","1CH","10","13","13","ⵛⴰⵡⵓⵍ ⵉⵎⵎⵓⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴷⴰⵔ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵖⴻⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵟⵟⵉⴼ ⵏⴻⵜⵜⴰ, ⵓ ⵓⵎⵉ ⵢⴰⵔⵣⵓ ⵛⵛⵡⴰⵔ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("R110_14","014_10_14","1CH","10","14","14","ⵡⴰⵔ ⵉⵙⵙⴻⵇⵙⵉ ⵙⵉⴷⵉ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵖⴰ ⵉ-ⵜ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵜⴰⴳⴻⵍⴷⴰ ⵉ ⴷⴰⵡⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R111_1","014_11_1","1CH","11","1","1","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵏⵏⴰⵏ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵖⵙⴰⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R111_2","014_11_2","1CH","11","2","2","ⵄⴰⴷ ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴰⵡⵓⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵏⴻⵖ, ⴰⵇⴰ ⴷ ⵛⴻⴽ ⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⵜⵊⴻⴱⴷⴻⴷ ⵜ-ⵉ-ⴷⴷ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ. ⵄⴰⵡⴻⴷ ⵉⵏⵏⴰ ⴰⵛ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ: ‘ⵛⴻⴽ ⴰⴷ ⵜⴰⵔⴻⵡⵙⴻⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("R111_3","014_11_3","1CH","11","3","3","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⴷⴻⵀⵏⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵛⴰⵎⵡⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("R111_4","014_11_4","1CH","11","4","4","ⴷⴰⵡⵓⴷ ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⴱⵓⵙ. ⴷⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⴱⵓⵙ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R111_5","014_11_5","1CH","11","5","5","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⴱⵓⵙ ⵏⵏⴰⵏ ⵉ ⴷⴰⵡⵓⴷ: “ⵛⴻⴽ ⵡⴰⵔ ⴷⴰ ⵜᵉⵜⵜⵉⴷⴼⴻⴷ ⵛⴰ.” ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵟⵟⴻⴼ ⵍⴱⵓⵔⵊ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R111_6","014_11_6","1CH","11","6","6","ⵎⴰⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⴱⵓⵙ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ. ⵓⵛⴰ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵙⴰⵔⴰⵢⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R111_7","014_11_7","1CH","11","7","7","ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵍⵇⴻⵍⵄⴰ. ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉ ⵍⵇⴻⵍⵄⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R111_8","014_11_8","1CH","11","8","8","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵣⵉ ⵍⵇⴻⵍⵄⴰ ⵓ ⵙⵙⴻⵏⵏⵉ ⵉⵇⵓⵡⵡⴰⵔ ⴰⵙ-ⴷⴷ. ⵉⵄⴷⴻⵍ ⵢⵓⵄⴰⴱ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R111_9","014_11_9","1CH","11","9","9","ⵉⴷⵡⴻⵍ ⴷⴰⵡⵓⴷ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R111_10","014_11_10","1CH","11","10","10","ⵉⵏⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⴷⴰⵡⵓⴷ ⵉⵏⵏⵉ ⵉⵙⵙⵊⵊⴻⵀⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R111_11","014_11_11","1CH","11","11","11","ⵜⴰ ⴷ ⵍⵉⵙⵜⴰ ⵏ ⵍⵄⴰⴷⴰⴷ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⴷⴰⵡⵓⴷ: ⵢⴰⵛⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵀⴰⴽⵎⵓⵏⵉ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵍⴰⵜⵉⵏ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⵏⵏⴻⴹ ⵙ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵅ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R111_12","014_11_12","1CH","11","12","12","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⴷⵓⴷⵓ, ⴰⵅⵓⵅⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("R111_13","014_11_13","1CH","11","13","13","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ ⴷⵉ ⴼⴰⵙ-ⴷⴰⵎⵎⵉⵎ. ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵏⵢⴰⵔⵡⴻⵏ ⴷⵉⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵢⴻⵢⵢⴰⵔ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵙ ⵉⵎⴻⵏⴷⵉ ⵓⵎⵉ ⵢⴰⵔⵡⴻⵍ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R111_14","014_11_14","1CH","11","14","14","ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏⵏⵉ, ⴼⴻⴽⴽⴻⵏ ⵜ, ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵢⴰⵔⵔⴰ ⵙⵉⴷⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R111_15","014_11_15","1CH","11","15","15","ⵜⵍⴰⵜⴰ ⵣⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵀⵡⴰⵏ ⴰⵍ ⵜⴰⵚⴹⴰⵔⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵉⴼⵔⵉ ⵏ ⴰⴱⴷⵓⵍⵍⴰⵎ. ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R111_16","014_11_16","1CH","11","16","16","ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ. ");
INSERT INTO rift_vpl VALUES ("R111_17","014_11_17","1CH","11","17","17","ⴷⴰⵡⵓⴷ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵓⴼⴰⴷⵉ, ⵉⵏⵏⴰ: “ⵡⵉ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵎⴰⵏ ⵣⵉ ⵜⴰⵍⴰ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("R111_18","014_11_18","1CH","11","18","18","ⵅⴻⵏⵏⵉ ⵛⵓⵇⴻⵏ ⵜⵍⴰⵜⴰ ⵏⵏⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓⵢⵎⴻⵏ-ⴷⴷ ⴰⵎⴰⵏ ⵣⵉ ⵜⴰⵍⴰ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⴽⵙⵉⵏ ⵜⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ ⴰⴷ ⵜⴻⵏ ⵉⵙⵓ, ⵎⴰⵛⴰ ⵉⵣⴻⴵⴻⵄ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R111_19","014_11_19","1CH","11","19","19","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⵢⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ. ⵎⴰ ⴰⴷ ⵙⵡⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⴷⴰⵢⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⴻⴱⴱⵍⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ?” ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵙⵓ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴳⴳⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R111_20","014_11_20","1CH","11","20","20","ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⴱ, ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵍⴰⵜⴰ ⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⵏⵏⴻⴹ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵅ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵏ ⵊⴰⵔ ⵜⵍⴰⵜⴰ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R111_21","014_11_21","1CH","11","21","21","ⵊⴰⵔ ⵜⵍⴰⵜⴰ-ⵢⴰ ⵜⵓⵖⴰ ⴰⴱⵉⵛⴰⵢ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵓⵔⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵉ ⵏⵉⵜⵏⵉ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵉⵡⵉⴹ ⵓⵍⴰ ⴰⵎ ⵜⵍⴰⵜⴰ ⵉⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R111_22","014_11_22","1CH","11","22","22","ⵅⴻⵏⵏⵉ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵎⴻⵃⴹⴻⵏ, ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵎⵖⴰⵔⴻⵏⵜ. ⵏⴻⵜⵜⴰ ⵣⵉ ⵇⴰⴱⴹⵉⵢⵉⵍ. ⵉⵖⵍⴻⴱ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵔⴰⴷⴻⵏ ⵊⴻⵀⴷⴻⵏ ⵣⵉ ⵎⵓ’ⴰⴱ. ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵉⵀⵡⴰ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵉⵖⵍⴻⴱ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵎⵉ ⵉⵡⵜⴰ ⵡⴻⴷⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("R111_23","014_11_23","1CH","11","23","23","ⵏⴻⵜⵜⴰ ⵉⵖⵍⴻⴱ ⵓⵍⴰ ⵅ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵚⵔⵉ, ⵙ ⵢⵉⵊⵊ ⵜⵉⴷⴷⵉ ⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⴰⵎⵉⵚⵔⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⴰⵏⵙⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵜⴻⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵅⴻⵢⵢⴻⴹ. ⵉⵀⵡⴰ ⵖⴰⵔⴻⵙ ⵙ ⵡⴻⵄⵎⵓⴷ, ⵉⴽⴽⴻⵙ ⴰⵙ ⵍⴰⵏⵙⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵎⵉⵚⵔⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵙ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R111_24","014_11_24","1CH","11","24","24","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⴳⴳⴰ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ⵙ ⵓⵢⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰ ⵉⵙⴻⵎ ⵉⵛⵏⴻⵄ ⵊⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("R111_25","014_11_25","1CH","11","25","25","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⵍⴰⵜⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⵉⵡⴻⴹ ⴰⵍ ⵜⵍⴰⵜⴰ ⵉⵎⴻⵣⵡⵓⵔⴰ. ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵉ-ⵜ ⵊⴰⵔ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R111_26","014_11_26","1CH","11","26","26","ⴰⵢⵜ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵄⴰⵙⴰ’ⵉⵍ, ⵓⵎⴰⵙ ⵏ ⵢⵓⵡⴰⴱ, ⵉⵍⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⵓⴷⵓ, ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ");
INSERT INTO rift_vpl VALUES ("R111_27","014_11_27","1CH","11","27","27","ⵛⴰⵎⵎⵓⵜ, ⴰⵀⴰⵔⵓⴷⵉ, ⵃⴰⵍⵉⵚ, ⴰⵍⴼⴰⵍⵓⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_28","014_11_28","1CH","11","28","28","ⵄⵉⵔⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵇⵇⵉⵛ, ⴰⵜⵉⵇⵇⵓⵄⵉ, ⴰⴱⵉⵄⴰⵣⴰⵔ, ⴰⵄⴰⵏⴰⵜⵓⵜⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_29","014_11_29","1CH","11","29","29","ⵙⵉⴱⴱⵉⴽⴰⵢ, ⴰⵃⵓⵛⴰⵜⵉ, ⵄⵉⵍⴰⵢ, ⴰⵅⵓⵅⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_30","014_11_30","1CH","11","30","30","ⵎⴰⵀⴰⵔⴰⵢ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ, ⵅⴰⵍⵉⴷ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵏⴰ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_31","014_11_31","1CH","11","31","31","ⵉⵜⵜⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴱⴰⵢ, ⵣⵉ ⵊⵉⴱⵄⴰ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴱⴰⵏⴰⵢⴰ, ⵣⵉ ⴼⵉⵔⵄⴰⵜⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("R111_32","014_11_32","1CH","11","32","32","ⵀⵓⵔⴰⵢ ⵣⵉ ⵜⴻⵖⵣⴰⵔⵉⵏ ⵏ ⵊⴰⵄⴰⵛ, ⴰⴱⵉⵢⵉⵍ, ⴰⵄⴰⵔⴰⴱⴰⵜⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_33","014_11_33","1CH","11","33","33","ⵄⴰⵣⵎⴰⵡⴻⵜ, ⴰⴱⴰⵃⵔⵓⵎⵉ, ⵉⵍⵢⴰⵃⴱⴰ, ⴰⵛⴰⵄⴰⵍⴱⵓⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_34","014_11_34","1CH","11","34","34","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵛⵉⵎ, ⴰⵊⴰⵣⵓⵏⵉ, ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵊⴰⵢ, ⴰⵀⴰⵔⴰⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_35","014_11_35","1CH","11","35","35","ⴰⵅⵉⵢⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⴰⴽⴰⵔ, ⴰⵀⴰⵔⴰⵔⵉ, ⵉⵍⵉⴼⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("R111_36","014_11_36","1CH","11","36","36","ⵃⴰⴼⵉⵔ, ⴰⵎⴰⴽⵉⵔⴰⵜⵉ, ⴰⵅⵉⵢⴰ, ⴰⴼⴰⵍⵓⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_37","014_11_37","1CH","11","37","37","ⵃⴰⵚⵔⵓ, ⴰⴽⴰⵔⵎⴰⵍⵉ, ⵏⴰⵄⵔⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵉⵣⴱⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("R111_38","014_11_38","1CH","11","38","38","ⵢⵓⵡⵉⵍ, ⵓⵎⴰⵙ ⵏ ⵏⴰⵜⴰⵏ, ⵎⵉⴱⵃⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_39","014_11_39","1CH","11","39","39","ⵚⴰⵍⵉⵇ, ⴰⵄⴰⵎⵎⵓⵏⵉ, ⵏⴰⵃⵔⴰⵢ, ⴰⴱⴰ’ⵉⵔⵓⵜⵉ, ⴰⵃⴻⵎⵎⴰⵍ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R111_40","014_11_40","1CH","11","40","40","ⵄⵉⵔⴰ, ⴰⵢⵉⵜⵔⵉ, ⵊⴰⵔⵉⴱ, ⴰⵢⵉⵜⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_41","014_11_41","1CH","11","41","41","ⵓⵔⵉⵢⴰ, ⴰⵃⵉⵜⵜⵉ, ⵣⴰⴱⴰⴷ, ⵎⵎⵉⵙ ⵏ ⴰⵃⵍⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("R111_42","014_11_42","1CH","11","42","42","ⴰⴷⵉⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵣⴰ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵓ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ ⵄⴰⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R111_43","014_11_43","1CH","11","43","43","ⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴽⴰ, ⴷ ⵢⵓⵛⴰⴼⴰⵟ, ⴰⵎⴰⵜⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_44","014_11_44","1CH","11","44","44","ⵄⵓⵣⵣⵉⵢⴰ ⴰⵄⴰⵛⵜⴰⵔⵓⵜⵉ, ⵛⴰⵎⴰⵄ ⴷ ⵢⴰⵄⵉⵢⵉⵍ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⵓⵜⴰⵎ, ⴰⵄⴰⵔⵓⵄⵉⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_45","014_11_45","1CH","11","45","45","ⵢⴰⴷⵉⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵔⵉ, ⵢⵓⵃⴰ, ⵓⵎⴰⵙ, ⴰⵜⵉⵚⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_46","014_11_46","1CH","11","46","46","ⵉⵍⵉⵢⵉⵍ ⴰⵎⴰⵃⵡⵉⵎ, ⵢⴰⵔⵉⴱⴰⵢ ⴷ ⵢⵓⵛⵓⵡⵢⴰ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵏⴰⵄⴰⵎ, ⴷ ⵢⵉⵜⵎⴰ ⴰⵎⵓ’ⴰⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("R111_47","014_11_47","1CH","11","47","47","ⵉⵍⵉⵢⵉⵍ, ⵄⵓⴱⵉⴷ ⴷ ⵢⴰⵄⵙⵉⵢⵉⵍ ⵣⵉ ⵎⴰⵚⵓⴱⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R112_1","014_12_1","1CH","12","1","1","ⵉⵏⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵚⵉⵇⵍⴰⵖ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⴰⵡⵓⴷ ⵉⵜⵜⴻⴳⴳⵯⴻⵊ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵛⴰⵡⵓⵍ, ⵎⵎⵉⵙ ⵏ ⵇⵉⵛ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵇⵇⴻⵏ ⵉ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ ⵉ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R112_2","014_12_2","1CH","12","2","2","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵃⴻⵣⵎⴻⵏ ⵙ ⵍⴻⵇⵡⴰⵙ ⵓ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵃⴻⵊⵊⴰⵔⴻⵏ ⵙ ⵢⴻⵥⵔⴰ ⵓ ⴰⴷ ⵡⵜⴻⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵙ ⵍⵇⴻⵡⵙ ⵙ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵓ ⵙ ⵓⴼⵓⵙ ⴰⵣⴻⵍⵎⴰⴹ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_3","014_12_3","1CH","12","3","3","ⴰⵅⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵢⵓⵡⴰⵛ, ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎⴰⵄⴰ, ⵣⵉ ⵊⵉⴱⵄⴰ, ⵅⴻⵏⵏⵉ ⵢⴰⵣⵓ’ⵉⵍ ⴷ ⴼⴰⵍⴰⵟ, ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵣⵎⴰⵡⴻⵜ, ⵓ ⴱⴰⵔⴰⵅⵢⴰ ⴷ ⵢⴰⵀⵓ, ⵣⵉ ⵄⴰⵏⴰⵜⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("R112_4","014_12_4","1CH","12","4","4","ⵓ ⵢⴰⵛⵎⴰⵄⵢⴰ, ⵣⵉ ⵊⵉⴱⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵊⴰⵔ ⵜⵍⴰⵜⵉⵏ ⵓ ⵜⵓⵖⴰ ⵅ ⵜⵍⴰⵜⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("R112_5","014_12_5","1CH","12","5","5","ⵓⵍⴰ ⴷ ⵉⵔⵎⵉⵢⴰ, ⵢⴰⵃⵣⵉⵢⵉⵍ, ⵢⵓⵃⴰⵏⴰⵏ ⴷ ⵢⵓⵣⴰⴱⴰⴷ, ⴰⵊⴰⴷⵉⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("R112_6","014_12_6","1CH","12","6","6","ⵉⵍⵄⵓⵣⴰⵢ, ⵢⴰⵔⵉⵎⵓⵜ, ⴱⴰⵄⵍⵉⵢⴰ, ⵛⴰⵎⴰⵔⵢⴰ, ⵛⴰⴼⴰⵟⵢⴰ, ⴰⵃⴰⵔⵓⴼⵉ, ");
INSERT INTO rift_vpl VALUES ("R112_7","014_12_7","1CH","12","7","7","ⵉⵍⵇⴰⵏⴰ, ⵢⴰⵛⵛⵉ-ⵢⴰⵀ, ⵄⴰⵣⵔⵉⵢⵉⵍ, ⵢⵓⵄⴰⵣⴰⵔ ⴷ ⵢⴰⵛⵓⴱⵄⴰⵎ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵇⵓⵔⴰⵃⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R112_8","014_12_8","1CH","12","8","8","ⵓ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵢⵓⵄⵉⵍⴰ ⴷ ⵣⴰⴱⴰⴷⵢⴰ, ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵔⵓⵃⴰⵎ ⵣⵉ ⵊⴰⴷⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R112_9","014_12_9","1CH","12","9","9","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵥⵡⴰⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⴷⵉ ⵍⴻⵅⵍⴰ. ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵜⵜⵡⴰⵃⴻⵣⵎⴻⵏ ⵙ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵓ ⵙ ⵉⵃⵔⵉⵛⴻⵏ. ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏ ⵡⴻⵢⵔⴰⴷⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵙ ⵜⴰⵣⵍⴰ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵖⴰⵢⴹⴻⵏ ⵏ ⵡⴻⵣⵖⴰⵔ ⵅ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R112_10","014_12_10","1CH","12","10","10","ⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵄⵓⴱⴰⴷⵢⴰ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵍⵉⵢⴰⴱ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("R112_11","014_12_11","1CH","12","11","11","ⵎⵉⵛⵎⴰⵏⵏⴰ ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⵉⵔⵎⵉⵢⴰ ⴷ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("R112_12","014_12_12","1CH","12","12","12","ⵄⴰⵜⵜⴰⵢ ⴷ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⵉⵍⵉⵢⵉⵍ ⴷ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R112_13","014_12_13","1CH","12","13","13","ⵢⵓⵃⴰⵏⴰⵏ ⴷ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⵉⵍⵣⴰⴱⴰⴷ ⴷ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R112_14","014_12_14","1CH","12","14","14","ⵉⵔⵎⵉⵢⴰ ⴷ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⵎⴰⵅⴱⴰⵏⴰⵢ ⴷ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("R112_15","014_12_15","1CH","12","15","15","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⴷ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⴰⵎⴻⵥⵢⴰⵏ ⵃⴻⵙⴱⴻⵏ ⵜ ⴰⵎ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⴰⵍⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("R112_16","014_12_16","1CH","12","16","16","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵥⵡⴰⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵓⵎⵉ ⵉⵙⴼⵉ ⵍ’ⵓⵔⴷⵓⵏ ⴱⴰⵔⵔⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵓⵡⵡⴰ ⵏⵏⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⵓⵥⵥⵍⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴻⵡⴹⴰⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⴷ ⵍⵖⴰⵔⴱ. ");
INSERT INTO rift_vpl VALUES ("R112_17","014_12_17","1CH","12","17","17","ⵓⵍⴰ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵍⵇⴻⵍⵄⴰ ⵏ ⵡⴻⴷⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R112_18","014_12_18","1CH","12","18","18","ⴷⴰⵡⵓⴷ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵍⵇⴰ, ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵙⵉⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⵎ ⴰⴼⵓⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⵙ ⵡⵓⵍ ⴷ ⵉⵊⵊ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵙⵉⵎ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵙⴻⵍⵍⵎⴻⵎ ⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵍⴻⵅⵛⵓⵏⴻⵜ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴰⴷ ⵜ ⵉⵥⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴵⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("R112_19","014_12_19","1CH","12","19","19","ⵉⵡⴹⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵅ ⵄⴰⵎⴰⵙⴰⵢ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵍⴰⵜⵉⵏ, ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛⵉⵏ ⴰⴽⵉⴷⴻⴽ, ⴷⴰⵡⵓⴷ, ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴽⵉⴷⴻⴽ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ. ⵍⴻⵀⵏⴰ, ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ ⵓ ⵍⴻⵀⵏⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵉⵡⵛⴰ ⴰⵛ ⴰⴼⵓⵙ.” ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏ ⴷⴰⵡⵓⴷ ⵓ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R112_20","014_12_20","1CH","12","20","20","ⵓⵍⴰ ⵣⵉ ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵄⴷⵓⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵛⴰⵡⵓⵍ. ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵊⵊⵉⵏ ⴰⴷ ⵡⵛⴻⵏ ⴰⴼⵓⵙ, ⵎⵉⵏⵣⵉ ⵍⴱⴰⵛⴰⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵙⵙⴻⴽⴽⴻⵏ ⵜ, ⵏⵏⴰⵏ: “ⵣⴻⵄⵎⴰ ⵏⴻⵜⵜⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵄⴷⵓ ⵙ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵛⴰⵡⵓⵍ, ⵙⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("R112_21","014_12_21","1CH","12","21","21","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵚⵉⵇⵍⴰⵖ, ⵄⴷⵓⵏ ⵉⵏⴰ ⵖⴰⵔⴻⵙ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: ⵄⴰⴷⵏⴰⵃ, ⵢⵓⵣⴰⴱⴰⴷ, ⵢⴰⴷⵉⵄⵉⵍ, ⵎⵉⵅⴰⵢⵉⵍ, ⵢⵓⵣⴰⴱⴰⴷ, ⵉⵍⵉⵀⵓ ⴷ ⵚⵉⵍⵍⵜⴰⵢ, ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵅ ⵍⵓⵔⵓⴼ ⵏ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R112_22","014_12_22","1CH","12","22","22","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⴼⵓⵙ ⵉ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴻⵡⵡⴻⴷ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R112_23","014_12_23","1CH","12","23","23","ⵎⴰⵖⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵍ ⴰⵙⵙ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⴰⴼⵓⵙ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵎ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R112_24","014_12_24","1CH","12","24","24","ⵡⴰ ⴷ ⵍⵇⴻⴷⴷ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⵙⵙⴻⵄⴷⵓⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⵛⴰⵡⵓⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("R112_25","014_12_25","1CH","12","25","25","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵉⵃⵔⵉⵛⴻⵏ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵓ-ⵜⴻⵎⵏ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R112_26","014_12_26","1CH","12","26","26","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_27","014_12_27","1CH","12","27","27","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_28","014_12_28","1CH","12","28","28","ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵜⵓⵖⴰ ⴷ ⵍⵃⴰⴽⴻⵎ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_29","014_12_29","1CH","12","29","29","ⵚⴰⴷⵓⵇ ⵜⵓⵖⴰ ⴷ ⴰⵃⵓⴷⵔⵉ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R112_30","014_12_30","1CH","12","30","30","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⵢⵜⵎⴰⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⵃⴻⵟⵟⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("R112_31","014_12_31","1CH","12","31","31","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵜⵎⴻⵏⵢⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_32","014_12_32","1CH","12","32","32","ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R112_33","014_12_33","1CH","12","33","33","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴼⴰⵀⵎⴻⵜ ⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⵉⵏ ⵜⵓⵖⴰ ⵅ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⴳⴳ, ⵜⵓⵖⴰ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵏⵙⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_34","014_12_34","1CH","12","34","34","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵙⵏⴰⵃ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵜⵜⴼⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴷⴷⵉ ⵙ ⵡⵓⵍ ⵉⵎⵓⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_35","014_12_35","1CH","12","35","35","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵍⴻⴼ ⵏ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵍⴰⵏⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("R112_36","014_12_36","1CH","12","36","36","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⴰⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R112_37","014_12_37","1CH","12","37","37","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵛⵉⵔ ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R112_38","014_12_38","1CH","12","38","38","ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⵓⴱⵉⵏ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⴷ ⵓ ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵙⵏⴰⵃ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R112_39","014_12_39","1CH","12","39","39","ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ-ⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵃⴰⴱⵔⵓⵏ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⴷⴻⴳ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵙ ⵡⵓⵍ ⵉⵎⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵡⵓⵍ ⴷ ⵉⵊⵊ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R112_40","014_12_40","1CH","12","40","40","ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉⵏⵏⵉ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵛⵛⵉⵏ ⵙⵡⵉⵏ, ⵎⴰⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R112_41","014_12_41","1CH","12","41","41","ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⴰⵍ ⵉⵙⵙⴰⴽⴰⵔ ⴷ ⵣⴰⴱⵓⵍⵓⵏ ⴷ ⵏⴰⴼⵜⴰⵍⵉ ⵓⵙⵉⵏ-ⴷⴷ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵡⴻⵖⵔⵓⵎ ⵅ ⵉⵖⵢⴰⵍ, ⵅ ⵉⵍⴻⵖⵎⴰⵏ, ⵅ ⵉⵙⴰⵔⴹⴰⵏ ⵓ ⵅ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵙ ⵍⴻⵄⵡⴻⵍⵜ ⴰⵎ ⴼⴰⵔⵉⵏⴰ ⴷ ⵉⵖⵔⵓⵎⴻⵏ ⵏ ⵜⴰⵣⴰⵔⵜ ⴷ ⵉⵖⵔⵓⵎⴻⵏ ⵏ ⵣⵣⴱⵉⴱ ⴷ ⴱⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵡⵓⴵⵉ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R113_1","014_13_1","1CH","13","1","1","ⴷⴰⵡⵓⴷ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵅ ⵎⵢⴰ ⵓ ⴰⴽ-ⴷ ⵎⴽⵓⵍ ⵍⵃⴰⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R113_2","014_13_2","1CH","13","2","2","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⴰⵍⴰ ⵢⴰⵔⴹⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⴻⴽⴽ ⴷⴻⵖⵢⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵏⵏⵢⴰⵔⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R113_3","014_13_3","1CH","13","3","3","ⵓⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵏⴰⵔⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵛⴰⵡⵓⵍ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵏⴻⵍⵀⵉ. ");
INSERT INTO rift_vpl VALUES ("R113_4","014_13_4","1CH","13","4","4","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎⵎⵓ, ⵎⴰⵖⴰⵔ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R113_5","014_13_5","1CH","13","5","5","ⴷⴰⵡⵓⴷ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵣⴻⴳ ⵢⴻⵖⵣⴰⵔ ⵏ ⵛⵉⵃⵓⵔ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⴰⵍ ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R113_6","014_13_6","1CH","13","6","6","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⴱⴰⵄⵍⴰ, ⵖⴰⵔ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙⵙⴻⵏⵏⵉ. ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵊⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵎⴰⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R113_7","014_13_7","1CH","13","7","7","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵏ ⵊⴷⵉⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⴱⵉⵏⴰⴷⴰⴱ. ⵄⵓⵣⵣⴰ ⴷ ⴰⵅⵉⵢⵓ ⵏⴻⴷⵀⴻⵏ ⴰⴽⴰⵔⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("R113_8","014_13_8","1CH","13","8","8","ⴷⴰⵡⵓⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵉⵔⴰⵔⴻⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⴻⵣⵍⴰⵏ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ ⴷ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⴻⴱⵡⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R113_9","014_13_9","1CH","13","9","9","ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⴽⵉⴷⵓⵏ, ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵄⵓⵣⵣⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⵜⴰⴱⵓⵜ ⵎⵉⵏⵣⵉ ⵏⴷⴻⵔⴼⴻⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R113_10","014_13_10","1CH","13","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵄⵓⵣⵣⴰ ⵓⵛⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵎⴰⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R113_11","014_13_11","1CH","13","11","11","ⵢⵉⵡⴻⴹ ⵙⵙⴻⵎ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵙⵄⴰⵔ ⴰⵎⵎⵓ ⵅ ⵄⵓⵣⵣⴰ ⵓ ⵉⴳⴳⴰ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⴼⴰⵔⵉⵚ-ⵄⵓⵣⵣⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R113_12","014_13_12","1CH","13","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⴻⵍⵇⴻⴼ ⴷⴰⵡⵓⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("R113_13","014_13_13","1CH","13","13","13","ⵅ ⵓⵢⴰ ⴷⴰⵡⵓⴷ ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜⴰⴳⴳⵯⴻⵊ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⴰⵊⵉⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("R113_14","014_13_14","1CH","13","14","14","ⵜⴻⴽⴽⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⵓ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R114_1","014_14_1","1CH","14","1","1","ⵃⵉⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ, ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⴷ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵃⵉⴹ ⴷ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ. ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R114_2","014_14_2","1CH","14","2","2","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵉⴷⵉ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R114_3","014_14_3","1CH","14","3","3","ⴷⴰⵡⵓⴷ ⵉⴽⵙⵉ ⵄⴰⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴷⴰⵡⵓⴷ ⵢⴰⵔⵏⵉ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⴷ ⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R114_4","014_14_4","1CH","14","4","4","ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵉ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ: ⵛⴰⵎⵎⵓⵄ, ⵛⵓⴱⴰⴱ, ⵏⴰⵜⴰⵏ, ⵙⵓⵍⵉⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("R114_5","014_14_5","1CH","14","5","5","ⵉⴱⵃⴰⵔ, ⵉⵍⵉⵛⵓⵄ, ⵉⵍⴼⴰⵍⴰⵟ, ");
INSERT INTO rift_vpl VALUES ("R114_6","014_14_6","1CH","14","6","6","ⵏⵓⵊⴰⵀ, ⵏⴰⴼⴰⵊ, ⵢⴰⴼⵉⵄ, ");
INSERT INTO rift_vpl VALUES ("R114_7","014_14_7","1CH","14","7","7","ⵉⵍⵉⵛⴰⵎⴰⵄ, ⴱⴰⵄⴰⵍⵢⴰⴷⴰⵄ ⴷ ⵉⵍⵉⴼⴰⵍⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("R114_8","014_14_8","1CH","14","8","8","ⵓⵎⵉ ⵙⵍⵉⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⴷⴻⵀⵏⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴳⴻⵄⵄⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⴷⴰⵡⵓⴷ. ⴷⴰⵡⵓⴷ ⵉⵙⵍⴰ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵉⵎⵙⴰⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R114_9","014_14_9","1CH","14","9","9","ⵓⵙⵉⵏ-ⴷⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R114_10","014_14_10","1CH","14","10","10","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⴷⴰⵡⵓⴷ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ? ⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ?” ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⴳⴻⵄⵄⴻⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("R114_11","014_14_11","1CH","14","11","11","ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⴱⴰⵄⵍ-ⴼⴰⵔⴰⵚⵉⵎ. ⴷⵉⵏⵏⵉ ⵉⵡⵜⴰ ⴷⴰⵡⵓⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: “ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⵉⵛⵓⵇ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴰⵎ ⵡⴰⵎⴰⵏ ⴰⵔⵥⵉⵏ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ.” ⵅ ⵓⵢⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⴱⴰⵄⵍ-ⴼⴰⵔⴰⵚⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R114_12","014_14_12","1CH","14","12","12","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵊⵊⵉⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⴷⵉⵏⵏⵉ, ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⴷⴰⵡⵓⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("R114_13","014_14_13","1CH","14","13","13","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴳⴻⵄⵄⴷⴻⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R114_14","014_14_14","1CH","14","14","14","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵇⵙⴰ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵜⵜⴳⵉⵄⵄⵉⴷ ⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⵏⴻⴹ ⴰⵙⴻⵏ-ⴷⴷ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("R114_15","014_14_15","1CH","14","15","15","ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⴻⵛⵍⵉ ⵏ ⵉⵚⵓⵔⴰⴼ ⴷⵉ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵜⵜⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵢⵉⵣⵡⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R114_16","014_14_16","1CH","14","16","16","ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵣⵉ ⵊⵉⴱⵄⵓⵏ ⴰⵍ ⵊⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R114_17","014_14_17","1CH","14","17","17","ⴰⵎⵎⵓ ⵉ ⵉⴼⴼⴻⵖ ⵉⵙⴻⵎ ⵏ ⴷⴰⵡⵓⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ, ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⴹ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R115_1","014_15_1","1CH","15","1","1","ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵓⴷⵔⵉⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_2","014_15_2","1CH","15","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵖⵉⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("R115_3","014_15_3","1CH","15","3","3","ⴷⴰⵡⵓⴷ ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("R115_4","014_15_4","1CH","15","4","4","ⴷⴰⵡⵓⴷ ⵉⵙⵙⵎⵓⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_5","014_15_5","1CH","15","5","5","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ ⵜⵓⵖⴰ ⵓⵔⵉⵢⵉⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_6","014_15_6","1CH","15","6","6","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⵄⴰⵙⴰⵢⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_7","014_15_7","1CH","15","7","7","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵔⵛⵓⵎ ⵜⵓⵖⴰ ⵢⵓⵡⵉⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_8","014_15_8","1CH","15","8","8","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵉⵚⴰⴼⴰⵏ ⵜⵓⵖⴰ ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_9","014_15_9","1CH","15","9","9","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⵉⵍⵉⵢⵉⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵎⴻⵏⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_10","014_15_10","1CH","15","10","10","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⵣⵣⵉⵢⵉⵍ ⵜⵓⵖⴰ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵢⴰ ⵓ-ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_11","014_15_11","1CH","15","11","11","ⴷⴰⵡⵓⴷ ⵉⵍⴰⵖⴰ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵚⴰⴷⵓⵇ ⴷ ⴰⴱⵢⴰⵜⴰⵔ, ⵓⵍⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵔⵉⵢⵉⵍ, ⵄⴰⵙⴰⵢⴰ, ⵢⵓⵡⵉⵍ, ⵛⴰⵎⵄⵉⵢⴰ, ⵉⵍⵉⵢⵉⵍ ⴷ ⵄⴰⵎⵎⵉⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R115_12","014_15_12","1CH","15","12","12","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⴷ ⴰⵙ ⵙⵙⵡⴻⵊⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R115_13","014_15_13","1CH","15","13","13","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴳⴳⵉⵎ ⴰⵢⴰ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⵄⴰⵔ ⵅⴰⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵅⴰⵙ ⵏⴰⵔⵣⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("R115_14","014_15_14","1CH","15","14","14","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R115_15","014_15_15","1CH","15","15","15","ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵉⵄⵓⵎⴰⴷ ⵏ ⵜⵔⴻⴱⴱⵓⵜ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R115_16","014_15_16","1CH","15","16","16","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴰⴽ-ⴷ ⴷⴷⵓⵣⴰⵏ ⵏ ⴵⵖⴰ, ⴰⴽ-ⴷ ⵍⵀⴰⵔⴱⴰⵜ, ⴰⴽ-ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⵓ ⴰⴽ-ⴷ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵉⵙⵙⴻⴼⵔⴰⵃⴻⵏ ⵉⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("R115_17","014_15_17","1CH","15","17","17","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵀⴰⵢⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⵉⵍ, ⵓ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ: ⴰⵙⴰⴼ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵓⵎⴰⵜⵙⴻⵏ, ⵉⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵛⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R115_18","014_15_18","1CH","15","18","18","ⵓ ⴰⴽⵉⴷⵙⴻⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⴷⵉ ⴷⴷⵓⵇ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⴱⵉⵏ, ⵢⴰⵄⵣⵉⵢⵉⵍ, ⵛⴰⵎⵉⵔⴰⵎⵓⵜ, ⵢⴰⵃⵉⵢⵉⵍ, ⵄⵓⵏⵏⵉ, ⵉⵍⵉⵢⴰⴱ, ⴱⴰⵏⴰⵢⴰ, ⵎⴰⵄⴰⵙⵢⴰ, ⵎⴰⵜⵜⵉⵜⵢⴰ, ⵉⵍⵉⴼⴰⵍⵢⴰ, ⵎⴰⵇⵏⵉⵢⴰ, ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴷ ⵢⴰⵄⵉⵢⵉⵍ, ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R115_19","014_15_19","1CH","15","19","19","ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵀⴰⵢⵎⴰⵏ ⴷ ⴰⵙⴰⴼ ⴷ ⵉⵜⴰⵏ ⴰⴽ-ⴷ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵏⵏⵃⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵊⵊⴻⵏ ⴰⴷ ⴷⴷⴻⵏⴷⵓⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R115_20","014_15_20","1CH","15","20","20","ⵓ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵄⵓⵣⵣⵉⵢⵉⵍ, ⵛⴰⵎⵉⵔⴰⵎⵓⵜ, ⵢⴰⵃⵉⵢⵉⵍ, ⵄⵓⵏⵏⵉ, ⵉⵍⵉⵢⴰⴱ, ⵎⴰⵄⴰⵙⵢⴰ ⴷ ⴱⴰⵏⴰⵢⴰ ⴰⴽ-ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⵉⵜⵜⵡⴰⵔⵔⵉⴳⵍⴰⵏ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ");
INSERT INTO rift_vpl VALUES ("R115_21","014_15_21","1CH","15","21","21","ⴷ ⵎⴰⵜⵜⵉⵜⵢⴰ, ⵉⵍⵉⴼⴰⵍⵢⴰ, ⵎⴰⵇⵏⵉⵢⴰ, ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⵢⴰⵄⵉⵢⵉⵍ ⴷ ⵄⴰⵣⴰⵣⵢⴰ ⴰⴽ-ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷⵉ ⵍⵎⴻⴼⵜⴰⵃ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⵢⵓⵔⴻⵏ ⵉⵣⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_22","014_15_22","1CH","15","22","22","ⴽⴰⵏⴰⵏⵢⴰ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵏ ⵜⵜⴰⴱⵓⵜ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴰⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵔⴱⵓⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R115_23","014_15_23","1CH","15","23","23","ⴱⴰⵔⴰⵅⵢⴰ ⴷ ⵉⵍⵇⴰⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R115_24","014_15_24","1CH","15","24","24","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵛⴰⴱⴰⵏⵢⴰ, ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵄⴰⵎⴰⵙⴰⵢ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⴱⴰⵏⴰⵊⴰ ⴷ ⵉⵍⵉⵄⴰⵣⴰⵔ ⵙⵓⴹⴻⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴷ ⵢⴰⵃⵉⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R115_25","014_15_25","1CH","15","25","25","ⴰⵎⵎⵓ ⵉ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R115_26","014_15_26","1CH","15","26","26","ⵍⴰⵎⵉ ⴰⵔⴱⵓⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴼⵓⵙ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("R115_27","014_15_27","1CH","15","27","27","ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵓⵍⴰ ⵎⴰⵔⵔⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⵜⵜⴰⴱⵓⵜ ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ, ⴷ ⴽⴰⵏⴰⵏⵢⴰ, ⴰⵎⴻⵃⴹⴰⵢⵉ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ. ⴷⴰⵡⵓⴷ ⵢⴰⵔⴹ ⵉⵊⵊ ⵏ ⵓⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵏ ⵍⴻⵇⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R115_28","014_15_28","1CH","15","28","28","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⴷⵉ ⵍⴻⴱⵡⴰⵇ ⵓ ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵉⵔⴰⵔⴻⵏ ⵙ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R115_29","014_15_29","1CH","15","29","29","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵎⵉⵅⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵛⴰⵡⵓⵍ, ⵜⴻⵅⵣⴰⵔ ⵣⵉ ⵍⴽⴰⵣⵉ, ⵜⴻⵥⵔⴰ ⵎⴰⵎⵎⴻⵛ ⵉⵏⴻⴳⴳⴻⵣ ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⵛⴻⵟⵟⴻⵃ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵓⵛⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔ ⵉ-ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_1","014_16_1","1CH","16","1","1","ⵏⵉⵜⵏⵉ ⵙⵙⵉⴷⴼⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⴷⴷ-ⵉⵛⴻⴷⴷ ⴷⴰⵡⵓⴷ, ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_2","014_16_2","1CH","16","2","2","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴷⴰⵡⵓⴷ ⴰⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ, ⵉⴱⴰⵔⴻⴽ ⵏⴻⵜⵜⴰ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_3","014_16_3","1CH","16","3","3","ⵏⴻⵜⵜⴰ ⵉⴱⴹⴰ ⵉ ⵎⴰⵔⵔⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵉ ⴽⵓⵍ ⵉⵊⵊ, ⵉⵊⵊ ⵏ ⵡⴻⵏⴳⵓⵔ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵉⵊⵊ ⵏ ⵓⵛⴻⴵⵉⵇ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵔⴻⵇⵇⵉⵄ ⵏ ⵣⵣⴱⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("R116_4","014_16_4","1CH","16","4","4","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵛⴰ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵄⴻⵇⵍⴻⵏ ⵓ ⴰⴷ ⵇⴰⴷⴰⵏ ⵓ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R116_5","014_16_5","1CH","16","5","5","ⴰⵙⴰⴼ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓ ⵅⴻⵏⵏⵉ ⵢⴰⵄⵉⵢⵉⵍ, ⵛⴰⵎⵉⵔⴰⵎⵓⵜ, ⵢⴰⵃⵉⵢⵉⵍ, ⵎⴰⵜⵜⵉⵜⵢⴰ, ⵉⵍⵉⵢⴰⴱ, ⴱⴰⵏⴰⵢⴰ, ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴷ ⵢⴰⵄⵉⵢⵉⵍ ⴰⴽ-ⴷⴷⵓⵣⴰⵏⴰⵜ ⴰⵎ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ, ⵓⵛⴰ ⴰⵙⴰⴼ ⵉⴳⴳⴰ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⵙ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R116_6","014_16_6","1CH","16","6","6","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴱⴰⵏⴰⵢⴰ ⴷ ⵢⴰⵃⵣⵉⵢⵉⵍ ⵓⵢⵓⵔⴻⵏ ⵙ ⵍⴻⴱⵡⴰⵇ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_7","014_16_7","1CH","16","7","7","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ ⵉ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵅ ⴰⵙⴰⴼ ⴷ ⴰⵢⵜⵎⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_8","014_16_8","1CH","16","8","8","“ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵍⴰⵖⴰⵎ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_9","014_16_9","1CH","16","9","9","ⵖⴻⵏⵏⵊⴻⵎ ⴰⵙ, ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵏⴻⵜⵜⴰ, ⵙⵉⵡⵍⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_10","014_16_10","1CH","16","10","10","ⵛⴻⵏⵏⵄⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⵎⵇⴻⴷⴷⴻⵙ, ⵃⵉⵎⴰ ⵓⵍ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("R116_11","014_16_11","1CH","16","11","11","ⵙⴻⵇⵙⴰⵎ ⵅ ⵙⵉⴷⵉ ⴷ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⴰⵔⵣⵓⵎ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R116_12","014_16_12","1CH","16","12","12","ⵄⴻⵇⵍⴻⵎ ⵅ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ, ⵅ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_13","014_16_13","1CH","16","13","13","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("R116_14","014_16_14","1CH","16","14","14","ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵙ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R116_15","014_16_15","1CH","16","15","15","ⵄⴻⵇⵍⴻⵎ ⵅ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵡⴻⵚⵚⴰ ⵉ ⴰⵍⴻⴼ ⵏ ⵊⵊⵉⵍⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("R116_16","014_16_16","1CH","16","16","16","ⵍⵄⴰⵀⴷ ⵉ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ-ⵜ ⵙ ⵜⵊⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵉ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R116_17","014_16_17","1CH","16","17","17","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉ ⵉⵙⵔⴰⵉⵍ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("R116_18","014_16_18","1CH","16","18","18","ⵓⵎⵉ ⵉⵏⵏⴰ: ‘ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ!’, ");
INSERT INTO rift_vpl VALUES ("R116_19","014_16_19","1CH","16","19","19","ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵙ ⴷⵔⵓⵙⵜ ⵡⴰⵀⴰ, ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R116_20","014_16_20","1CH","16","20","20","ⵜⴻⵍⵄⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ, ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_21","014_16_21","1CH","16","21","21","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵜⴻⵏ ⵉⵃⵚⴰⵔ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵄⴰⵇⴻⴱ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R116_22","014_16_22","1CH","16","22","22","‘ⵡⴰⵔ ⵜⵜⵃⴰⴷⴰⵎ ⵛⴰ ⵉⵎⴻⴷⵀⴰⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵍⵖⴰⵔ ⴷⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("R116_23","014_16_23","1CH","16","23","23","ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⴱⴰⵔⵔⵃⴻⵎ ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_24","014_16_24","1CH","16","24","24","ⵃⴰⵊⴰⵎ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⴻⵙ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_25","014_16_25","1CH","16","25","25","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵙⴷⴰⵃⴻⴵ ⴰⵙⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴰⴳⴳⵯⴻⴷ ⵎⴰⵀⵓ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R116_26","014_16_26","1CH","16","26","26","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍ’ⴰⵚⵏⴰⵎ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R116_27","014_16_27","1CH","16","27","27","ⵜⵉⵙⵙⵉⵇⵜ ⴷ ⵍⵄⴻⵣⵣ ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵊⵊⴻⵀⴷ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_28","014_16_28","1CH","16","28","28","ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⵄⵓⴵⵉ ⴷ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("R116_29","014_16_29","1CH","16","29","29","ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⵄⵓⴵⵉ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵡⵢⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵓⵛⴰ ⴰⵙⴻⵎ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴱⴻⵏⴷⵇⴻⵎ ⵉ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵛⵓⵡⵡⴰⴹ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R116_30","014_16_30","1CH","16","30","30","ⴰⵔⵊⵉⵊⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ⵏⵉⵛⴰⵏ, ⵍⴻⵅⵅⵓ ⴷⴷⵓⵏⴻⵛⵜ ⵜⴱⴻⴷⴷ ⵜⴻⵎⵜⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵏⵀⴻⵣⵣⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R116_31","014_16_31","1CH","16","31","31","ⴻⵊⵊ ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵉⴼⴰⵔⵃ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴼⴰⵔⵃ, ⴰⴷ ⵉⵏⵉⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ: ⵙⵉⴷⵉ ⵉⵃⴻⴽⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R116_32","014_16_32","1CH","16","32","32","ⴻⵊⵊ ⴰⴷ ⵉⵣⵀⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⴻⵊⵊ ⴰⴷ ⵉⵙⵍⵉⵡⵍⴻⵡ ⵢⴻⵢⵢⴰⵔ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R116_33","014_16_33","1CH","16","33","33","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵍⵉⵡⵍⵉⵡⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⴳⴳⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R116_34","014_16_34","1CH","16","34","34","ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R116_35","014_16_35","1CH","16","35","35","ⵉⵏⵉⵎ: ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵏⴷⴻⵀ ⴰⵏⴻⵖ ⵏⵎⵓⵏ, ⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵇⴰⴷⴰ ⵉⵙⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⴽ ⵓ ⴰⴷ ⵛⴻⴽ ⵏⵚⴻⴱⴱⴻⵃ ⵙ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("R116_36","014_16_36","1CH","16","36","36","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ!” ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵏⴰ: “ⴰⵎⵉⵏ!” ⵓⵛⴰ ⵉⵎⴷⴻⵃ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_37","014_16_37","1CH","16","37","37","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⵉ ⴰⵙⴰⴼ ⴷ ⵢⴰⵢⵜⵎⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵜⴰⴱⵓⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴽⵓⵍ ⴰⵙⵙ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⵉ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R116_38","014_16_38","1CH","16","38","38","ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴷⵉⵜⵓⵏ, ⴷ ⵃⵓⵙⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⵉⵡⵡⵓⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("R116_39","014_16_39","1CH","16","39","39","ⵓⵛⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ ⴷ ⵢⴰⵢⵜⵎⴰⵙ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("R116_40","014_16_40","1CH","16","40","40","ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴱⵍⴰ ⴰⵇⴻⵟⵟⵓ ⵉ ⵙⵉⴷⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R116_41","014_16_41","1CH","16","41","41","ⵖⴰⵔⵙⴻⵏ ⵜⵓⵖⴰ ⵀⴰⵢⵎⴰⵏ ⴷ ⵢⴰⴷⵓⵜⵓⵏ ⴰⴽ-ⴷ ⵉⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵓ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵢⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ: ‘ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("R116_42","014_16_42","1CH","16","42","42","ⵜⵓⵖⴰ ⵖⴰⵔ ⵀⴰⵢⵎⴰⵏ ⴷ ⵢⴰⴷⵓⵜⵓⵏ ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵍⴻⴱⵡⴰⵇ ⴷ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵙⵍⴻⵏ ⵢⴻⵡⴷⴰⵏ, ⵓⵍⴰ ⴷ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴷⵓⵜⵓⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⴷⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("R116_43","014_16_43","1CH","16","43","43","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⴷⴰⵡⵓⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R117_1","014_17_1","1CH","17","1","1","ⵓⵎⵉ ⵉⵣⴷⴻⵖ ⴷⴰⵡⵓⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵣⴻⴷⴷⵖⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵎⴰⵛⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜⵜ ⵙⴰⴷⵓ ⵍⴽⴻⵜⵜⴰⵏ ⵏ ⵓⵇⵉⴹⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("R117_2","014_17_2","1CH","17","2","2","ⵏⴰⵜⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⴷⴰⵡⵓⴷ: “ⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("R117_3","014_17_3","1CH","17","3","3","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵏⴰⵜⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R117_4","014_17_4","1CH","17","4","4","“ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴱⴻⵏⵏⵉⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵏⴻⵛⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("R117_5","014_17_5","1CH","17","5","5","ⵎⴰⵖⴰⵔ ⵣⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⴷⴷ-ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴷⵉⵖⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ ⵣⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ, ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("R117_6","014_17_6","1CH","17","6","6","ⵎⴰⵏⵉ ⵎⴰ ⵓⵢⵓⵔⴻⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵓⵍⴰ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⵇⵓⴹⴰⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵖ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⵉⵖ: ⵎⴰⵢⴻⵎⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴱⴻⵏⵏⵉⵎ ⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ?’ ");
INSERT INTO rift_vpl VALUES ("R117_7","014_17_7","1CH","17","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵉ ⴷⴰⵡⵓⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵊⴻⵀⴷⴻⵏ: ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ-ⴷⴷ ⵛⴻⴽ ⵣⵉ ⵍⴽⵓⵔⵉ, ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵡⵓⴵⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R117_8","014_17_8","1CH","17","8","8","ⵎⴰⵏⵉ ⵎⴰ ⵜⵓⵢⵓⵔⴻⴷ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴰⴽⵉⴷⴻⴽ ⵓ ⵏⴻⵛⵛ ⵜⴻⵃⵃⵉⵖ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵛ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⴰⵎ ⵢⵉⵙⴻⵎ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R117_9","014_17_9","1CH","17","9","9","ⵏⴻⵛⵛ ⵏⴻⵢⵢⵛⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⵥⵥⵓⵖ ⵜ ⴷⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵅⵍⵉⵄ ⵄⴰⴷ ⵓ ⵡⴰⵔ ⵜ ⵃⴻⵚⵚⴰⵔⴻⵏ ⵄⴰⴷ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⵎ ⵣⵉⵛ, ");
INSERT INTO rift_vpl VALUES ("R117_10","014_17_10","1CH","17","10","10","ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵓⵎⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵍⵇⵓⴹⴰⵜ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵛⵛ ⵙⵙⵡⴰⴹⵄⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵓ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵛⴻⴽ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R117_11","014_17_11","1CH","17","11","11","ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵇⴻⴼⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵎⵙⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵎⵎⵉⵛ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵛ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R117_12","014_17_12","1CH","17","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R117_13","014_17_13","1CH","17","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴱⴰⴱⴰⵙ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵢⵉⵍⵉ ⴷ ⵎⵎⵉ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙ ⵙⵙⵃⴻⵢⵢⵉⴷⴻⵖ ⵛⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵙⵃⴻⵢⵢⴷⴻⵖ ⵅ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵛ ⵉⵣⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R117_14","014_17_14","1CH","17","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⵎⴻⵜⵏⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⴰⴷ ⵉⴱⴻⴷⴷ ⵉⵎⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("R117_15","014_17_15","1CH","17","15","15","ⵉⵙⵙⵉⵡⴻⵍ ⵏⴰⵜⴰⵏ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵃⵉⵢ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R117_16","014_17_16","1CH","17","16","16","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴰⵇⴰ ⵛⴻⴽ ⵜⵏⴻⴷⵀⴻⴷ ⴰⵢⵉ-ⴷⴷ ⴰⵍ ⴷⴰⵏⵉⵜⴰ? ");
INSERT INTO rift_vpl VALUES ("R117_17","014_17_17","1CH","17","17","17","ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵍⴻⵅⵅⵓ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵄⴰⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵢⵉⵎⴰⵔ ⵉⴳⴳⵯⴻⵊ ⵓ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⴷⴰⵢⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("R117_18","014_17_18","1CH","17","18","18","ⵎⵉⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵢⵉⵏⵉ ⴷⴰⵡⵓⴷ ⵄⴰⴷ ⴽⵜⴰⵔ ⵅ ⵛⵛⴻⵏⵄⴻⵜ ⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ? ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("R117_19","014_17_19","1CH","17","19","19","ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵖⴰⵔⴻⵜ-ⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵓⵍ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴰⵎⵎⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R117_20","014_17_20","1CH","17","20","20","ⴰ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵛⴻⴽ. ⵡⴰⵔ ⴷⵉⵏ ⴰⵔⴻⴱⴱⵉ ⵎⵖⵉⵔ ⵛⴻⴽ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵏⴻⵙⵍⴰ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R117_21","014_17_21","1CH","17","21","21","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⴰⵢⴻⵏⵏⵉ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵖⴰⵔ ⵉⵔⴰⵃ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴼⴷⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵉⵙⵙⵉⴳⴳⵯⴷⴻⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵍⴻⴳⵏⵓⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵜⴻⴼⴷⵉⴷ ⵣⵉ ⵎⵉⵚⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("R117_22","014_17_22","1CH","17","22","22","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R117_23","014_17_23","1CH","17","23","23","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⴰⵡⴰⵍ ⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⴻⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("R117_24","014_17_24","1CH","17","24","24","ⴻⵊⵊ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⵉ ⵍⴻⴱⴷⴰ ⵓⵎⵉ ⵖⴰ ⵉⵏⵉⵏ: ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵉⵍⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴰⵡⵓⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R117_25","014_17_25","1CH","17","25","25","ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵜⴻⴱⵏⵉⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵅ ⵓⵢⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R117_26","014_17_26","1CH","17","26","26","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵓ ⵛⴻⴽ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵎⴰⵔⵔⴰ ⵜⵛⵓⵏⵉ-ⵢⴰ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R117_27","014_17_27","1CH","17","27","27","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵢⴰⵔⴹⴰ ⵉ ⵛⴻⴽ ⴰⴷ ⵜⴱⴰⵔⴽⴻⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ⵎⵉⵏⵣⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵜⴱⴰⵔⴽⴻⴷ ⵜⵜ ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("R118_1","014_18_1","1CH","18","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵅ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵊⴰⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R118_2","014_18_2","1CH","18","2","2","ⵉⵖⵍⴻⴱ ⵓⵍⴰ ⵅ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴰⵍⴰⵎⵉ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R118_3","014_18_3","1CH","18","3","3","ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵄⴰⵡⴻⴷ ⵅ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ, ⴰⵍ ⵃⴰⵎⴰⵜ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴰⵏⵉⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵜⴻⵎ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("R118_4","014_18_4","1CH","18","4","4","ⴷⴰⵡⵓⴷ ⵉⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⴰⵍⴻⴼ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵓ ⴷⴰⵡⵓⴷ ⵉⵇⴻⵙⵙ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵢⵙⴰⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓⵛⴰ ⵉⵊⵊⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵎⵢⴰ ⵏ ⵉⵢⵙⴰⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R118_5","014_18_5","1CH","18","5","5","ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⴰⵎ ⵣⵉ ⴷⵉⵎⴰⵛⵇ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⴰⴼⵓⵙ ⵉ ⵀⴰⴷⴰⵔ-ⵄⴰⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ, ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵅ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R118_6","014_18_6","1CH","18","6","6","ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵏ ⴷⵉⵎⴰⵛⵇ, ⵓ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ ⴷ ⵍⵊⵉⵣⵢⴰ. ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵜⵜⴰⵙⵉⵄ ⵉ ⴷⴰⵡⵓⴷ ⵎⴰⵏⵉ ⵎⴰ ⵉⵔⵓⵃ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("R118_7","014_18_7","1CH","18","7","7","ⴷⴰⵡⵓⴷ ⵢⵉⵡⵉ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵇⴻⵙⵃⴻⵏ ⵉ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙ ⵡⵓⵔⴻⵖ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵓ ⵢⵉⵡⵢⵉ ⵜⴻⵏⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R118_8","014_18_8","1CH","18","8","8","ⴷⴰⵡⵓⴷ ⵉⴽⵙⵉ ⴰⵟⵟⴰⵙ ⵏ ⵏⵏⵃⴰⵙ ⵣⵉ ⵟⴰⴱⵃⴰⵜ ⴷ ⵅⵓⵏ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ. ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R118_9","014_18_9","1CH","18","9","9","ⵓⵎⵉ ⵜⵓⵄⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵎⴰⵜ, ⵉⵙⵍⴰ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵖⵍⴻⴱ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("R118_10","014_18_10","1CH","18","10","10","ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵎⵎⵉⵙ ⵀⴰⴷⵓⵔⴰⵎ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴱⴰⵔⴻⴽ, ⵎⵉⵏⵣⵉ ⴷⴰⵡⵓⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵓⵛⴰ ⵉⵖⵍⴻⴱ ⵅⴰⵙ - ⵎⴰⵖⴰⵔ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⵉ ⵜⵓⵄⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⴰⵔⴻⵣⵣⵓ ⴰⵎⴻⵏⵖⵉ ⵍⴻⴱⴷⴰ - ⵓ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R118_11","014_18_11","1CH","18","11","11","ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉ ⴷ ⵢⵉⵡⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵣⵉ ⵉⴷⵓⵎ, ⵣⵉ ⵎⵓ’ⴰⴱ, ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⴰⵍⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("R118_12","014_18_12","1CH","18","12","12","ⴰⴱⵉⵛⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⴰⵡⵢⴰ, ⵉⵖⵍⴻⴱ ⵅ ⵉⴷⵓⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⴰⵎⴻⴵⴰⵃⵜ, ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R118_13","014_18_13","1CH","18","13","13","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⴷⵉ ⵉⴷⵓⵎ ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵎⵉⵢⵢⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴷⴰⵡⵓⴷ, ⵓ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵜⵜⴰⵙⵉⵄ ⵉ ⴷⴰⵡⵓⴷ ⵎⴰⵏⵉ ⵎⴰ ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("R118_14","014_18_14","1CH","18","14","14","ⴷⴰⵡⵓⴷ ⵉⵃⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉⴳⴳⴰ ⵙ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R118_15","014_18_15","1CH","18","15","15","ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵍⵓⴷ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("R118_16","014_18_16","1CH","18","16","16","ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⴷ ⴰⴱⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵢⴰⵜⴰⵔ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓ ⵛⴰⵡⵛⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴰⵔⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R118_17","014_18_17","1CH","18","17","17","ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵜⵓⵖⴰ-ⵜ ⵅ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R119_1","014_19_1","1CH","19","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴰⵃⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵉⵎⵎⵓⵜ. ⵎⵎⵉⵙ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R119_2","014_19_2","1CH","19","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵃⴰⵏⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⴰⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵙⵙⵛⴻⵏ ⴱⴰⴱⴰⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ.” ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵄⴻⵣⵣⴰ ⵅ ⵍⵎⴻⵡⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R119_3","014_19_3","1CH","19","3","3","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵉ ⵙⵉⴷⵉ ⵏⵙⴻⵏ ⵃⴰⵏⵓⵏ: “ⵎⴰ ⵉⵅⵙ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵄⴻⵣⵣⴰⵏ? ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴷⴰⵡⵓⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵏ ⵓ ⴰⴷ ⵜⵜ ⴱⴻⵔⴳⴰⴳⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("R119_4","014_19_4","1CH","19","4","4","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵃⴰⵏⵓⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵃⴻⴼⴼ ⴰⵙⴻⵏ ⴰⵣⵢⴻⵏ ⵣⵉ ⵜⵎⴰⵔⵜ, ⵉⵇⴻⵙⵙ ⴰⵙⴻⵏ ⴰⵣⵢⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⴰⵍ ⴹⴻⴼⴼⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R119_5","014_19_5","1CH","19","5","5","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵓⵛⴰ ⵃⴰⵊⴰⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ ⵉ ⴷⴰⵡⵓⴷ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵙⵙⴻⴽⴽ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⴹⵃⴰⵏ ⴰⵟⵟⴰⵙ. ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⴰⵔⵉⵃⴰ ⴰⵍ ⴷ ⵉ ⵖⴰ ⵜⴻⵎⵖⴰⵔ ⵜⵎⴰⵔⵜ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R119_6","014_19_6","1CH","19","6","6","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴰⵔⵣⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⴻⴽⴽ ⵀⴰⵏⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴰⵍⴻⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵔⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵣⵉ ⴰⵔⴰⵎ-ⵏⴰⵀⵔⴰⵢⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ, ⵣⵉ ⴰⵔⴰⵎ-ⵎⴰⵄⴽⴰ ⵓ ⵣⵉ ⵚⵓⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("R119_7","014_19_7","1CH","19","7","7","ⵏⵉⵜⵏⵉ ⵛⵔⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⵛⵔⴰⵏ ⵄⴰⵡⴻⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⴰⵄⴽⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵎⴰⵢⴷⴰⴱⴰ. ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵏⵏⵢⴰⵔⵡⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R119_8","014_19_8","1CH","19","8","8","ⵓⵎⵉ ⵉⵙⵍⴰ ⴷⴰⵡⵓⴷ ⴰⵢⴰ, ⵉⵙⵙⴻⴽⴽ ⵢⵓⵡⴰⴱ ⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("R119_9","014_19_9","1CH","19","9","9","ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓⵛⴰ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵓⵙⵉⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R119_10","014_19_10","1CH","19","10","10","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⵓⵡⴰⴱ, ⴰⵇⴰ ⴰⵎⴻⵏⵖⵉ ⵍⴰ ⵣⴻⴳ ⵓⵔⴻⵏⴷⴰⴷ ⵓⵍⴰ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵉⵅⴹⴰⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R119_11","014_19_11","1CH","19","11","11","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵉ ⵓⴼⵓⵙ ⵏ ⵓⵎⴰⵙ ⴰⴱⵉⵛⴰⵢ ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R119_12","014_19_12","1CH","19","12","12","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵎⴰⵍⴰ ⴰⵔⴰⵎ ⵉⵊⵀⴻⴷ ⵅⴰⴼⵉ, ⵅⴻⵏⵏⵉ ⴰⵙ-ⴷⴷ, ⴻⵡⵛ ⴰⵢⵉ ⴰⴼⵓⵙ! ⵎⴰⵍⴰ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵊⴻⵀⴷⴻⵏ ⵅⴰⴽ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R119_13","014_19_13","1CH","19","13","13","ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵎⵃⴻⴹ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴰⴷ ⵉⴳⴳ ⵙⵉⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("R119_14","014_19_14","1CH","19","14","14","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵢⵓⵡⴰⴱ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵓⵛⴰ ⵉⵏⴰ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R119_15","014_19_15","1CH","19","15","15","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵔⴻⵡⵍⴻⵏ, ⵟⵟⴼⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵎⴰⵙ ⴰⴱⵉⵛⴰⵢ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ⵅⴻⵏⵏⵉ ⵢⵉⵡⴻⴹ ⵢⵓⵡⴰⴱ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R119_16","014_19_16","1CH","19","16","16","ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵔⴰⵎ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵡⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵙⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵓ ⵛⵓⴱⴰⴽ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ ⵢⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R119_17","014_19_17","1CH","19","17","17","ⵓⵎⵉ ⵏⵏⴰⵏ ⴰⵢⴰ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵙⵙⵎⵓⵏ ⵏⴻⵜⵜⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵥⵡⴰ ⵍ’ⵓⵔⴷⵓⵏ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵓⵛⴰ ⵉⵙⴻⴷⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵏⵖⵉ. ⵓⵎⵉ ⵉⵙⴻⴷⴷ ⴷⴰⵡⵓⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ, ⵎⵎⴻⵏⵖⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R119_18","014_19_18","1CH","19","18","18","ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵇⴹⴰ ⴷⴰⵡⵓⴷ ⵅ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⵅ ⴰⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⴰⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ. ⵄⴰⵡⴻⴷ ⵉⵏⵖⴰ ⵏⴻⵜⵜⴰ ⵛⵓⴱⴰⴽ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R119_19","014_19_19","1CH","19","19","19","ⵓⵎⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵀⴰⴷⴰⴷ-ⵄⴰⵣⴰⵔ, ⴰⵇⴰ ⵜⵜⵡⴰⵔⵏⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵙ. ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⴷⵉ ⵍⴻⵄⵇⴻⵍ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵄⴰⴷ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R120_1","014_20_1","1CH","20","1","1","ⵖⴰⵔ ⵓⵇⴻⵟⵟⵓ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵊⴷⵉⴷ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⴷ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵡⴰⴱ ⵉⴳⴻⵡⵡⴻⴷ ⵊⵊⴻⵀⴷ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵢⴰⵔⴻⴷⴷⴻⴵ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⵉ ⵔⴰⴱⴱⴰ, ⵉⵃⵚⴰⵔ ⵉ-ⵜⵜ, ⵓⵎⵉ ⵉⵇⵇⵉⵎ ⴷⴰⵡⵓⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⵓⵡⴰⴱ ⵉⵖⵍⴻⴱ ⵅ ⵔⴰⴱⴱⴰ ⵓⵛⴰ ⵉⵜⴻⵃⵃⴰ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("R120_2","014_20_2","1CH","20","2","2","ⴷⴰⵡⵓⴷ ⵉⴽⴽⴻⵙ ⵜⵜⴰⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵜⵜⴰ ⵢⵓⴼⴰ ⵍⴻⵡⵣⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ⵜⵓⵖⴰ ⵅⴰⵙ ⵜⴰⵢⴰⵇⵓⵜⵉⵏ ⵉⵖⵍⴰⵏ. ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜⴰⵊ ⵏⵏⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R120_3","014_20_3","1CH","20","3","3","ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ ⵓⵛⴰ ⵉⵀⵊⴻⵎ ⵅⴰⵙⴻⵏ ⵙ ⵍⵎⴻⵏⵛⴰⵔⴰⵜ ⴷ ⵉⵢⴰⵍⵣⵉⵎⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵛⵛⵡⴰⵇⴰⵔ ⵏ ⵡⵓⵣⵣⴰⵍ. ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ ⴷⴰⵡⵓⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R120_4","014_20_4","1CH","20","4","4","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵊⴰⵣⴰⵔ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵖⵍⴻⴱ ⵙⴰⴱⴽⴰⵢ, ⴰⵃⵓⵛⴰⵢⵉ, ⵅ ⵙⴰⴼⴼⴰⵢ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⴼⴰ, ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵡⴰⴹⵄⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R120_5","014_20_5","1CH","20","5","5","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⴰⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵉⵍⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵄⵉⵔ, ⵉⵖⵍⴻⴱ ⵅ ⵍⴰⵃⵎⵉ, ⵓⵎⴰⵙ ⵏ ⵊⵓⵍⵉⵢⴰⵜ, ⵣⵉ ⵊⴰⵜ. ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵓⵅⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("R120_6","014_20_6","1CH","20","6","6","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵊⴰⵜ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵣⵉⵔⴰⵔ ⵙ ⵙⴻⵜⵜⴰ ⵏ ⵉⴹⴻⵡⴹⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⵙⴻⵜⵜⴰ ⵏ ⵜⴼⴻⴷⵏⵉⵏ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ. ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵉ ⵔⴰⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("R120_7","014_20_7","1CH","20","7","7","ⵏⴻⵜⵜⴰ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⴰ, ⵓⵎⴰⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵖⵍⴻⴱ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R120_8","014_20_8","1CH","20","8","8","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ-ⴷⴷ ⵉ ⵔⴰⴼⴰ ⴷⵉ ⵊⴰⵜ ⵓ ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R121_1","014_21_1","1CH","21","1","1","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵉⵎ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵖⴰⵔⵔ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⵙⴻⴱ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R121_2","014_21_2","1CH","21","2","2","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵉ ⵢⵓⵡⴰⴱ ⵓ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴳⴻⵏⵙ: “ⵓⵢⵓⵔⴻⵎ, ⵃⴻⵙⵙⴱⴻⵎ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⴰⵍ ⴷⴰⵏ ⵓⵛⴰ ⴰⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵎⴻⵛⵃⴰⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⴻⵛⵃⴰⵍ ⵉⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R121_3","014_21_3","1CH","21","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⵓⵡⴰⴱ: “ⵉⵍⵉ ⴰⴷ ⵢⴰⵔⵏⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⵎ ⵉⴵⴰ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵎⴰⵔⵔⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ? ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵣⵣⴰⵢⵉ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⵙⵙⴰⵔⴱⵓ ⵉⵙⵔⴰⵉⵍ ⴰⵎⴰⵔⵡⴰⵙ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("R121_4","014_21_4","1CH","21","4","4","ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵀⴻⴷ ⵅ ⵢⵓⵡⴰⴱ ⵓ ⵢⵓⵡⴰⴱ ⵉⴼⴼⴻⵖ. ⵉⴽⴽⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R121_5","014_21_5","1CH","21","5","5","ⵢⵓⵡⴰⴱ ⵉⵡⵛⴰ ⵉ ⴷⴰⵡⵓⴷ ⵍⵇⴻⴷⴷ ⵏ ⵍⴻⵃⵙⴰⴱ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎ ⵉⴽⵎⴻⵍ. ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⴰⵢⴻⵙ ⵎⵉⵍⵢⵓⵏ ⵓ-ⵎⵢⴰ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ ⵓ ⵢⴰⵀⵓⴷⴰ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R121_6","014_21_6","1CH","21","6","6","ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵡⴰⵔ ⵜⴻⵏ ⵉⵃⵙⵉⴱ ⵛⴰ, ⵎⴰⵖⴰⵔ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⴷ ⴰⵄⵉⴼⴼⵉ ⵉ ⵢⵓⵡⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R121_7","014_21_7","1CH","21","7","7","ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵜⵓⵖⴰ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵍⵇⴻⴼ ⵉⵙⵔⴰⵉⵍ ⵙ ⵉⵛⵜ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("R121_8","014_21_8","1CH","21","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⵅⴰⴽ ⴰⵟⵟⴰⵙ, ⵙ ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵢⴰ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴽⴽⴻⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("R121_9","014_21_9","1CH","21","9","9","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵊⴰⴷ, ⴰⵎⵡⴰⵍⴰⵡ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R121_10","014_21_10","1CH","21","10","10","“ⵓⵢⵓⵔ, ⵙⵉⵡⴻⵍ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴰⴷ ⴰⵛ ⵙⵙⴰⵔⵙⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ. ⵉⵅⴹⴰⵔ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉ ⵛⴻⴽ. ⴰⴷ ⴰⵛ ⵜⵜ ⴳⴳⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("R121_11","014_21_11","1CH","21","11","11","ⵊⴰⴷ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵉⵅⴹⴰⵔ ⵛⴻⴽ: ");
INSERT INTO rift_vpl VALUES ("R121_12","014_21_12","1CH","21","12","12","ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⴰⵥ, ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵃⵚⴰⵔⴻⵏ ⵓ ⵙⵙⵉⴼ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵉⴹⴼⴰⵔ, ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⵉⴼ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵟⵟⴰⵄⵓⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⴹⴻⵢⵢⴻⵄ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴰⵔⵔⴻⵖ ⵅ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("R121_13","014_21_13","1CH","21","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵊⴰⴷ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵡⴹⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴰⴷ ⵡⴹⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R121_14","014_21_14","1CH","21","14","14","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⵙⵉⴷⵉ ⵟⵟⴰⵄⵓⵏ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵡⴹⴰⵏ ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R121_15","014_21_15","1CH","21","15","15","ⵉⵙⵙⴻⴽⴽ ⴰⵔⴻⴱⴱⵉ ⵍⵎⴰⵍⴰⴽ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴹⴻⵢⵢⴻⵄ. ⵓⵎⵉ ⵉⴱⴷⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⴹⴻⵢⵢⴻⵄ, ⵉⵥⵔⴰ ⵉ-ⵜⵜ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⴷⴻⵎ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵏⵏⴰ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵓⴹⴻⵢⵢⴻⵄ: “ⵛⴼⴰ, ⵙⴻⵀⵡⴰ ⵍⴻⵅⵅⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵛ!” ⵜⵓⵖⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵢⴰⴱⵓⵙⵉ ⵓⵔⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R121_16","014_21_16","1CH","21","16","16","ⵓⵎⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⴰⵡⵓⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⵊⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵊⴻⵏⵏⴰ ⴰⵎ ⵉⵟⵟⴻⴼ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵙⵙⵉⴼ, ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉ-ⵜ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ ⴷⴰⵡⵓⴷ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⵓⵖⴰ ⵍⴻⵃⵃⴼⴻⵏ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R121_17","014_21_17","1CH","21","17","17","ⵓⵛⴰ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ ⵉ ⵉⵏⵏⴰⵏ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵃⴻⵙⴱⴻⵏ ⵍⴳⴻⵏⵙ? ⵡⴰⵀ, ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵓⵖⴰ ⵉⵅⴹⴰⵏ ⴷ ⵏⴻⵛⵛ ⵉ ⵉⴳⴳⵉⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵓⴵⵉ-ⵢⴰ, ⵎⵉⵏ ⴳⴳⵉⵏⵜ? ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⵜⴻⵛⵜⵉ ⵖⴰⵔⵉ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵛⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("R121_18","014_21_18","1CH","21","18","18","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⵊⴰⴷ, ⴰⴷ ⵢⵉⵏⵉ ⵉ ⴷⴰⵡⵓⴷ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴷⴰⵡⵓⴷ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ ⵅ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵢⴰⴱⵓⵙⵉ ⴰⵔⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R121_19","014_21_19","1CH","21","19","19","ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵊⴰⴷ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R121_20","014_21_20","1CH","21","20","20","ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⴰⵔⵏⴰⵏ, ⵉⵥⵔⴰ ⵍⵎⴰⵍⴰⴽ. ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ⵓⵔⵏⴰⵏ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵡⴰⵜ ⵉⵔⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R121_21","014_21_21","1CH","21","21","21","ⵢⵉⵡⴻⴹ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⴰⵔⵏⴰⵏ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵔⵏⴰⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵉⵥⵔⴰ ⴷⴰⵡⵓⴷ. ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⴷⴰⵡⵓⴷ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R121_22","014_21_22","1CH","21","22","22","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵔⵏⴰⵏ: “ⴻⵡⵛ ⴰⵢⵉ ⴰⵏⴷⵔⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⴱⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ. ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⵛⴰⵏ ⵙ ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉⵎⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⴷⴷ ⵜⵉⵛⵜⵉ-ⵢⴰ ⴷⵉ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("R121_23","014_21_23","1CH","21","23","23","ⴰⵔⵏⴰⵏ ⵉⵏⵏⴰ ⵉ ⴷⴰⵡⵓⴷ: “ⴽⵙⵉ ⵜ ⵉ ⵛⴻⴽ ⵓⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵅⵣⴰⵔ, ⴰⴷ ⵡⵛⴻⵖ ⵉⴼⵓⵏⴰⵙⴻⵏ-ⴰ ⴰⵎ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵓ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⵜⵎⴻⵙⵙⵉ ⴷ ⵉⵔⴷⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⴰⵢⴰ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("R121_24","014_21_24","1CH","21","24","24","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉ ⴰⵔⵏⴰⵏ: “ⵍⵍⴰ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⵏⵉⵛⴰⵏ ⴰⴷ ⵜ ⵙⵖⴻⵖ ⵙ ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉⴽⵎⴻⵍ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜ ⴽⴻⵙⵙⵉⵖ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵡⴻⵀⵀⴱⴻⵖ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ ⴱⵍⴰ ⴰⴷ ⵜⵜ ⵅⴻⴵⵚⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("R121_25","014_21_25","1CH","21","25","25","ⴰⵎⵎⵓ ⵉ ⵉⵡⵛⴰ ⴷⴰⵡⵓⴷ ⵉ ⴰⵔⵏⴰⵏ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R121_26","014_21_26","1CH","21","26","26","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴱⴻⴷⴷ ⴷⵉⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵢⵉⵡⵉ ⵅⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵖⵉⴵⴻⵜ. ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵉ ⵙⵉⴷⵉ ⵓ ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵙ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("R121_27","014_21_27","1CH","21","27","27","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⵎⴰⵃⴻⵏⴷ ⴷ ⵢⴰⵔⵔ ⵙⵙⵉⴼ ⴷⴻⴳ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R121_28","014_21_28","1CH","21","28","28","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵓⵎⵉ ⵉⵥⵔⴰ ⴷⴰⵡⵓⴷ ⴰⵇⴰ ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵅ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵢⴰⴱⵓⵙⵉ ⴰⵔⵏⴰⵏ, ⵢⵉⵡⵉ ⴷⵉⵏ ⵜⵉⵖⴰⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("R121_29","014_21_29","1CH","21","29","29","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R121_30","014_21_30","1CH","21","30","30","ⴷⴰⵡⵓⴷ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⵓⵢⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵙⵙⵉⴼ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R122_1","014_22_1","1CH","22","1","1","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ: “ⴷⴰ ⵉ ⵖⴰ ⵜⴱⴻⴷⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴷⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("R122_2","014_22_2","1CH","22","2","2","ⵢⵓⵎⵓⵔ ⴷⴰⵡⵓⴷ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵙⵓⵢⴷⴰⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⵢⴷⴰⵏ ⵉⵥⵔⴰ ⵉ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R122_3","014_22_3","1CH","22","3","3","ⴷⴰⵡⵓⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵣⵣⴰⵍ ⵉ ⵍⴻⵡⵜⴰⴷⴰⵜ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵡⴰⴷⴰⴼ ⵓ ⵉ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ ⵓⵍⴰ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵏⵏⵃⴰⵙ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵡⵣⴻⵏ ⵍⵇⴻⴷⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R122_4","014_22_4","1CH","22","4","4","ⵓⵍⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵙ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ, ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵚⵓⵔ ⵙⵙⵉⵡⴹⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵖⴰⵔ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R122_5","014_22_5","1CH","22","5","5","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵄⴰⴷ ⴷ ⴰⵃⵓⴷⵔⵉ ⴰⵔⵀⴻⴼ. ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰ ⴱⵏⴰⵏ ⵉ ⵙⵉⴷⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵉⵙⵙⵄⵓⴵⴻⵏ ⵃⵉⵎⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⵡⴻⵊⴷⴻⵖ.” ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴷⴰⵡⵓⴷ ⴰⵟⵟⴰⵙ ⵇⴱⴻⵍ ⵉ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R122_6","014_22_6","1CH","22","6","6","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵏⴻⵜⵜⴰ ⵉ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R122_7","014_22_7","1CH","22","7","7","ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵙⵓⵍⵉⵎⴰⵏ: “ⵎⵎⵉ, ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵜⵓⵖⴰ-ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("R122_8","014_22_8","1CH","22","8","8","ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ‘ⵛⴻⴽ ⵜⴻⵙⵙⵉⵣⵣⵍⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵜⴻⴳⴳⵉⴷ ⵉⵎⴻⵏⵖⴰⵏ ⵉⵇⴻⵙⵃⴻⵏ. ⵛⴻⴽ ⵡⴰⵔ ⵜⴱⴻⵏⵏⵉⴷ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⵉⵣⵣⵍⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴰⵟⵟⴰⵙ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R122_9","014_22_9","1CH","22","9","9","ⵅⵣⴰⵔ, ⵎⵎⵉⵛ ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⵃⵓⴷⵏⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵍⵀⵓⴷⵏⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵡⵛⴻⵖ ⵍⴻⵀⵏⴰ ⴷ ⵍⵀⵓⴷⵏⴻⵜ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R122_10","014_22_10","1CH","22","10","10","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵉⵍⵉⵖ ⴷ ⴱⴰⴱⴰⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵅ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ.’ ");
INSERT INTO rift_vpl VALUES ("R122_11","014_22_11","1CH","22","11","11","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵎⵎⵉ, ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⴻⴽ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴼⴻⵍⵃⴻⴷ ⵓ ⴰⴷ ⵜⴻⴱⵏⵉⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵅⴰⴽ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("R122_12","014_22_12","1CH","22","12","12","ⵉⵍⵉ ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵙⵉⴷⵉ ⵍⴻⵄⵇⴻⵍ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓⵍⴰ ⴷ ⵓⵙⵓⵢⴰⵔ ⵅ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R122_13","014_22_13","1CH","22","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴼⴻⵍⵃⴻⴷ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵃⴹⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ, ⵜⵉⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵙ ⵎⵓⵙⴰ ⵉ ⵉⵙⵔⴰⵉⵍ. ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓ ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⴻⴼⵛⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("R122_14","014_22_14","1CH","22","14","14","ⵅⵣⴰⵔ-ⴷⴷ, ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵖⴰⵔ ⵓⴼⵓⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵍⴻⴼ ⵅ ⵡⴰⵍⴻⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵍⴰ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵡⴻⵣⵏⴻⵏ. ⵉⵡⵢⴻⵖ ⵓⵍⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⴷ ⵢⴻⵥⵔⴰ. ⵓ ⵛⴻⴽ ⴰⴷ ⵅⴰⵙ ⵜⴰⵔⴻⵏⵢⴻⴷ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R122_15","014_22_15","1CH","22","15","15","ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵉⵙⵓⵢⴷⴰⵢⴻⵏ ⴷ ⵍⴻⵎⵄⵓⴵⴰⵎ ⵉ ⵓⵏⴻⵇⵇⴰⵛ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷⵉ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R122_16","014_22_16","1CH","22","16","16","ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ ⴰⵏⴻⵛⵜ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵃⴻⵙⴱⴻⵏ. ⴽⴽⴰⵔ, ⴻⴳⴳ ⵉ-ⵜ ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("R122_17","014_22_17","1CH","22","17","17","ⴷⴰⵡⵓⴷ ⵢⵓⵎⵓⵔ ⵄⴰⵡⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵉ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R122_18","014_22_18","1CH","22","18","18","“ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉ ⵍⵀⵓⴷⵏⴻⵜ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ? ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⴻⵎⵎⵓⵔⵜ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R122_19","014_22_19","1CH","22","19","19","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵡⵛⴻⵎ ⵓⵍ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴽⴽⴰⵔⴻⵎ, ⴰⴷ ⵜⴻⴱⵏⴰⵎ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵉⴷⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴱⵏⴰⵏ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("R123_1","014_23_1","1CH","23","1","1","ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴰⵡⵓⴷ ⵉⵡⵙⴰⵔ ⵓ ⵉⵊⵊⵉⵡⴻⵏ ⵓⵙⵙⴰⵏ, ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R123_2","014_23_2","1CH","23","2","2","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_3","014_23_3","1CH","23","3","3","ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⴻⵏⵏⴻⵊ. ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_4","014_23_4","1CH","23","4","4","ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷ ⵉⵎⵙⴻⵢⵢⴰⵔⴻⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("R123_5","014_23_5","1CH","23","5","5","ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵉ ⵉⵥⵔⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴰⵃ ⵉ ⵙⵉⴷⵉ, ⴰⴽ-ⴷ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵏⵏⵉ ⴳⴳⵉⵖ ⵏⴻⵛⵛ, ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ ⵙ ⵢⴻⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("R123_6","014_23_6","1CH","23","6","6","ⴷⴰⵡⵓⴷ ⵉⴱⴹⴰ ⵜⴻⵏ ⴷⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ, ⴰⵎ ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ: ⵊⴰⵔⵛⵓⵏ, ⵇⴰⵀⴰⵜ ⴷ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R123_7","014_23_7","1CH","23","7","7","ⵣⴻⴳ ⵉⵊⴰⵔⵛⵓⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵍⴰⵄⴷⴰⵏ ⴷ ⵛⵉⵎⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("R123_8","014_23_8","1CH","23","8","8","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵄⴷⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵣⴻⴵⵉⴼ ⵢⴰⵃⵉⵢⵉⵍ, ⵣⵉⵜⴰⵎ ⴷ ⵢⵓⵡⵉⵍ, ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_9","014_23_9","1CH","23","9","9","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⵍⵓⵎⵉⵜ, ⵃⴰⵣⵉⵢⵉⵍ ⴷ ⵀⴰⵔⴰⵏ, ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵍⴰⵄⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_10","014_23_10","1CH","23","10","10","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵢⴰⵃⴰⵜ, ⵣⴰⵢⵏⴰ, ⵢⴰⵄⵓⵛ ⴷ ⴱⴰⵔⵉⵄⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵉⵎⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("R123_11","014_23_11","1CH","23","11","11","ⵢⴰⵃⴰⵜ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⵓ ⵣⵉⵣⴰ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⵢⴰⵄⵓⵛ ⴷ ⴱⴰⵔⵉⵄⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⴰⵡⴻⵏ ⴰⵟⵟⴰⵙ. ⵖⴰⵔ ⵍⴻⵃⵙⴰⴱ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_12","014_23_12","1CH","23","12","12","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⴰⵀⴰⵜ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵎⵔⴰⵎ, ⵢⵉⵚⵀⴰⵔ, ⵃⴰⴱⵔⵓⵏ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ, ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_13","014_23_13","1CH","23","13","13","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵎⵔⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⵓⵙⴰ. ⵉⵜⵜⵡⴰⵄⵣⴻⵍ ⵀⴰⵔⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵇⴰⵄ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵉ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵙⴻⵅⵅⴰⵔ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R123_14","014_23_14","1CH","23","14","14","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵓⵙⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵊⴰⵔ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("R123_15","014_23_15","1CH","23","15","15","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵓⵙⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⴰⵔⵛⵓⵎ ⴷ ⵉⵍⵉⵄⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R123_16","014_23_16","1CH","23","16","16","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵔⵛⵓⵏ ⵜⵓⵖⴰ ⵛⴰⴱⵓⵡⵉⵍ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R123_17","014_23_17","1CH","23","17","17","ⵎⵎⵉⵙ ⵏ ⵉⵍⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵔⴰⵃⴰⴱⵢⴰ. ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵉⵍⵉⵄⴰⵣⴰⵔ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⵃⴰⴱⵢⴰ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R123_18","014_23_18","1CH","23","18","18","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵉⵚⵀⴰⵔ ⵜⵓⵖⴰ ⵛⴰⵍⵓⵎⵉⵜ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R123_19","014_23_19","1CH","23","19","19","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⵢⴰⵔⵉⵢⴰ ⴷ ⴰⵣⴻⴵⵉⴼ, ⴰⵎⴰⵔⵢⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵢⴰⵃⵣⵉⵢⵉⵍ ⵡⵉⵙⵙ ⵟⵔⴰⵜⴰ ⴷ ⵢⴰⵇⵎⴰⵄⴰⵎ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R123_20","014_23_20","1CH","23","20","20","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⵣⵣⵉⵢⵉⵍ ⵜⵓⵖⴰ ⵎⵉⵅⴰ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵓ ⵢⴰⵛⵛⵉ-ⵢⴰⵀ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_21","014_23_21","1CH","23","21","21","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵃⵍⵉ ⴷ ⵎⵓⵛⵉ. ⵜⴰⵔⵡⴰ ⵏ ⵎⴰⵃⵍⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵇⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("R123_22","014_23_22","1CH","23","22","22","ⴰⵍⵉⵄⴰⵣⴰⵔ ⵉⵎⵎⵓⵜ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⴱⵓ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵎⴰⵛⴰ ⵢⴻⵙⵙⵉⵙ ⵡⴰⵀ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⵉⵙ, ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R123_23","014_23_23","1CH","23","23","23","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵓⵛⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵃⵍⵉ ⴷ ⵄⴰⴷⵉⵔ ⴷ ⵢⴰⵔⵉⵎⵓⵜ, ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R123_24","014_23_24","1CH","23","24","24","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴰⴵⴰⵜ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵏ ⵖⴰⵔ ⵍⴻⵃⵙⴰⴱ ⵏⵙⴻⵏ ⵙ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⴰⵣⴻⴵⵉⴼ, ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("R123_25","014_23_25","1CH","23","25","25","ⵎⴰⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵡⵛⴰ ⵍⵀⵓⴷⵏⴻⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("R123_26","014_23_26","1CH","23","26","26","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵅ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: “ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵃⴷⵉⵊⴻⵏ ⵄⴰⴷ ⴰⴷ ⴰⵔⴱⵓⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⵉ ⴷⴷ ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("R123_27","014_23_27","1CH","23","27","27","ⵎⵉⵏⵣⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴰⵡⵓⴷ, ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ ⴷ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("R123_28","014_23_28","1CH","23","28","28","ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⵃⴻⵟⵟⵓ ⵅ ⵍⴻⵎⵔⴰⵃⴰⵜ, ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ, ⵅ ⵓⵙⵉⵣⴷⴻⴳ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("R123_29","014_23_29","1CH","23","29","29","ⵅ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ, ⵅ ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵅ ⵜⴻⵍⴼⴰⴼ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵅ ⵡⴻⵅⴷⵉⵎ ⵓ ⵅ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵯⵉⵏ ⴰⵔⴻⵛⵜⵉ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⵇⴻⴷⴷ ⴷ ⵍⴻⵇⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R123_30","014_23_30","1CH","23","30","30","ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵡⴻⵊⴷⴻⵏ ⴷⵉ ⴽⵓⵍ ⵜⵓⴼⴼⵓⵜ ⵃⵉⵎⴰ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵏ ⵓ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("R123_31","014_23_31","1CH","23","31","31","ⵓⵍⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵓ ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵉ ⵢⴻⴵⴰ ⴷⵉ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵍⵉⵇⴰⵏ, ⴱⵍⴰ ⴰⵇⴻⵟⵟⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R123_32","014_23_32","1CH","23","32","32","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵃⴹⴰⵏ ⵜⴰⵡⴻⵇⵇⴰⴼⵜ ⵏⵙⴻⵏ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⴷ ⵜⵡⴻⵇⵇⴰⴼⵜ ⵏⵙⴻⵏ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⵡⴻⵇⵇⴰⴼⵜ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵖⴰⵔ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R124_1","014_24_1","1CH","24","1","1","ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ. ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵏⴰⴷⴰⴱ, ⴰⴱⵉⵀⵓ, ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R124_2","014_24_2","1CH","24","2","2","ⵏⴰⴷⴰⴱ ⴷ ⴰⴱⵉⵀⵓ ⵎⵎⵓⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ. ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵡⴰⵔⵔⴰⵡⴻⵏ. ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵉⵜⴰⵎⴰⵔ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵢⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R124_3","014_24_3","1CH","24","3","3","ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵚⴰⴷⵓⵇ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⴰⴽ-ⴷ ⴰⵅⵉⵎⴰⵍⵉⴽ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵜⴰⵎⴰⵔ ⵉⴱⴹⴰ ⵉ-ⵜⴻⵏ ⴷⴰⵡⵓⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵡⴻⵇⵇⴰⴼⵜ ⵏⵙⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R124_4","014_24_4","1CH","24","4","4","ⵓⴼⵉⵏ ⴰⵇⴰ ⵖⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴰⵟⵟⴰⵙ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵜⴰⵎⴰⵔ. ⴱⴹⴰⵏ ⵜⴻⵏ ⴰⵎⴻⵏⵏⵉ: ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵓ ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵜⴰⵎⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R124_5","014_24_5","1CH","24","5","5","ⵏⵉⵜⵏⵉ ⴱⴹⴰⵏ ⵜⴻⵏ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⴰⵎ ⵢⵉⵏⴰ ⴰⵎ ⵢⵉⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R124_6","014_24_6","1CH","24","6","6","ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⵉⵍ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵎⴰⵔⵉⵔ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ, ⵉⵣⴻⵎⵎⴻⵏ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴷⵓⵇ, ⴷ ⴰⵅⵉⵎⴰⵍⵉⴽ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵢⴰⵜⴰⵔ, ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵊⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵊⴰⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⴳⴳⵉⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴰⴵ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵅⴻⵏⵏⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴰⴵ ⵏ ⵉⵜⴰⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R124_7","014_24_7","1CH","24","7","7","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵢⴰⵀⵓⵢⴰⵔⵉⴱ, ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵢⴰⴷⴰⵄⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R124_8","014_24_8","1CH","24","8","8","ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉ ⵃⴰⵔⵉⵎ, ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉ ⵙⴰⵄⵓⵔⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("R124_9","014_24_9","1CH","24","9","9","ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵉ ⵎⴰⵍⴽⵉⵢⴰ, ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉ ⵎⵉⵢⴰⵎⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("R124_10","014_24_10","1CH","24","10","10","ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉ ⵀⴰⵇⵇⵓⵚ, ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵉ ⴰⴱⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R124_11","014_24_11","1CH","24","11","11","ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵉ ⵢⴻⵛⵓⵄⴰ, ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵉ ⵛⴰⴽⴰⵏⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("R124_12","014_24_12","1CH","24","12","12","ⵡⵉⵙⵙ ⵃⵉⵜⴰⵛ ⵉ ⵉⵍⵢⴰⵛⵉⴱ, ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵉ ⵢⴰⵇⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("R124_13","014_24_13","1CH","24","13","13","ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵉ ⵃⵓⴼⴼⴰ, ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵉ ⵢⴰⵛⴰⴱⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("R124_14","014_24_14","1CH","24","14","14","ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵉ ⴱⵉⵍⵊⴰ, ⵡⵉⵙⵙ ⵙⴻⵟⵟⴰⵛ ⵉ ⵉⵎⵎⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("R124_15","014_24_15","1CH","24","15","15","ⵡⵉⵙⵙ ⵙⴱⴻⵄⵟⴰⵛ ⵉ ⵃⵉⵣⵉⵔ, ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵉ ⵃⴰⴼⵚⵉⵚ, ");
INSERT INTO rift_vpl VALUES ("R124_16","014_24_16","1CH","24","16","16","ⵡⵉⵙⵙ ⵜⵙⴻⵄⵟⴰⵛ ⵉ ⴼⴰⵇⴰⵃⵢⴰ, ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵉ ⵢⴰⵃⴰⵣⵇⵉⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R124_17","014_24_17","1CH","24","17","17","ⵡⵉⵙⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵉ ⵢⴰⵅⵉⵏ, ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵉ ⵊⴰⵎⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("R124_18","014_24_18","1CH","24","18","18","ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵉ ⴷⴰⵍⴰⵢⴰ, ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵉ ⵎⴰⵄⴰⵣⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R124_19","014_24_19","1CH","24","19","19","ⵉⵏⴰ ⵜⵓⵖⴰ ⵅⴰⵙⴻⵏ ⵜⴰⵡⴻⵇⵇⴰⴼⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⴻⵜⵜⴻⴼ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵀⴰⵔⵓⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R124_20","014_24_20","1CH","24","20","20","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⵙⴻⵜⵜⴻⴼ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ: ⵛⵓⴱⴰⵢⵉⵍ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵎⵔⴰⵎ, ⵢⴰⵃⴰⴷⵢⴰ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⵓⴱⴰⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R124_21","014_24_21","1CH","24","21","21","ⵅ ⵔⴰⵃⴰⴱⵢⴰ: ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵔⴰⵃⴰⴱⵢⴰ ⵜⵓⵖⴰ ⵢⴰⵛⵛⵉ-ⵢⴰⵀ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R124_22","014_24_22","1CH","24","22","22","ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⵉⵚⵀⴰⵔ ⵜⵓⵖⴰ ⵛⴰⵍⵓⵎⵉⵜ ⴷ ⴰⵣⴻⴵⵉⴼ. ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵍⵓⵎⵉⵜ ⵜⵓⵖⴰ ⵢⴰⵀⴰⵜ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R124_23","014_24_23","1CH","24","23","23","ⵓ ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵃⴰⴱⵔⵓⵏ ⵜⵓⵖⴰ ⵢⴰⵔⵉⵢⴰ ⴷ ⴰⵣⴻⴵⵉⴼ, ⴰⵎⴰⵔⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵢⴰⵃⵣⵉⵢⵉⵍ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵢⴰⵇⵎⴰⵄⴰⵎ ⴷⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R124_24","014_24_24","1CH","24","24","24","ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⵣⵣⵉⵢⵉⵍ ⵜⵓⵖⴰ ⵎⵉⵅⴰ ⴷ ⴰⵣⴻⴵⵉⴼ. ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵉⵅⴰ ⵜⵓⵖⴰ ⵛⴰⵎⵉⵔ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R124_25","014_24_25","1CH","24","25","25","ⵓⵎⴰⵙ ⵏ ⵎⵉⵅⴰ ⵜⵓⵖⴰ ⴷ ⵢⴰⵛⵛⵉ-ⵢⴰⵀ. ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵛⵛⵉ-ⵢⴰⵀ ⵜⵓⵖⴰ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R124_26","014_24_26","1CH","24","26","26","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵃⵍⵉ ⴷ ⵎⵓⵛⵉ. ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⵄⴰⵣⵢⴰ ⵜⵓⵖⴰ ⴱⴰⵏⵓ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R124_27","014_24_27","1CH","24","27","27","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ ⵙ ⵢⴰⵄⴰⵣⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴱⴰⵏⵓ ⴷ ⵛⵓⵀⴰⵎ ⴷ ⵣⴰⴽⴽⵓⵔ ⴷ ⵄⵉⴱⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R124_28","014_24_28","1CH","24","28","28","ⵉ ⵎⴰⵃⵍⵉ ⵜⵓⵖⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵎⵎⵉⵙ. ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R124_29","014_24_29","1CH","24","29","29","ⵅ ⵇⵉⵙ: ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⵉⵙ: ⵎⵖⵉⵔ ⵢⴰⵔⵃⴰⵎⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R124_30","014_24_30","1CH","24","30","30","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⵓⵛⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⴰⵃⵍⵉ, ⵄⴰⴷⵉⵔ ⴷ ⵢⴰⵔⵉⵎⵓⵜ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵡⵉ, ⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R124_31","014_24_31","1CH","24","31","31","ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜⵉⵇⴻⴷⴷⵓⵃⵉⵏ ⴰⵎ ⵢⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⴷ ⵚⴰⴷⵓⵇ ⴷ ⴰⵅⵉⵎⴰⵍⵉⴽ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵅ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵎ ⵢⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵣⴻⴵⵉⴼ ⴰⵎ ⵓⵎⴰⵜⵙⴻⵏ ⴷ ⴰⵎⴰⵥⵓⵥ. ");
INSERT INTO rift_vpl VALUES ("R125_1","014_25_1","1CH","25","1","1","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵙⴰⴼ ⴷ ⵀⴰⵢⵎⴰⵏ ⴷ ⵢⴰⴷⵓⵜⵓⵏ ⵉⵄⵣⴻⵍ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ. ⵍⵇⴻⴷⴷ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴷ ⵡⴰ: ");
INSERT INTO rift_vpl VALUES ("R125_2","014_25_2","1CH","25","2","2","ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵙⴰⴼ: ⵣⴰⴽⴽⵓⵔ, ⵢⵓⵙⵓⴼ, ⵏⴰⵜⴰⵏⵢⴰ ⴷ ⴰⵛⵔⵉⵢⵉⵍ, ⵏⵉⵜⵏⵉ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵙⴰⴼ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴰⵙⴰⴼ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵅ ⵉⵛⴻⵢⵢⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R125_3","014_25_3","1CH","25","3","3","ⵉ ⵢⴰⴷⵓⵜⵓⵏ: ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴷⵓⵜⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵊⴰⴷⴰⵍⵢⴰ, ⵚⴰⵔⵉ, ⵉⵛⴰⵄⵢⴰ, ⵃⴰⵛⴰⴱⵢⴰ ⴷ ⵎⴰⵜⵜⵉⵜⵢⴰ, ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵢⴰⴷⵓⵜⵓⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⴰⵎ ⵉⵜⵜⵉⵔⴰⵔ ⵅ ⵍⴳⴰⵎⴱⵔⵉ, ⴰⵎ ⵉⵜⵜⵇⴰⴷⴰ ⴷ ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R125_4","014_25_4","1CH","25","4","4","ⵉ ⵀⵉⵎⴰⵏ: ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵢⵎⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴱⵓⵇⵇⵉⵢⴰ, ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵄⵓⵣⵣⵉⵢⵉⵍ, ⵛⴰⴱⵓⵡⵉⵍ, ⵢⴰⵔⵉⵎⵓⵜ, ⵃⴰⵏⴰⵏⵢⴰ, ⵃⴰⵏⴰⵏⵉ, ⵉⵍⵉⵢⴰⵜⴰ, ⵊⵉⴷⴷⴰⵍⵜⵉ, ⵔⵓⵎⴰⵎⵜⵉ-ⵄⴰⵣⴰⵔ, ⵢⵓⵛⴱⴰⵇⴰⵛⴰ, ⵎⴰⵍⵍⵓⵜⵉ, ⵀⵓⵜⵉⵔ ⴷ ⵎⴰⵃⵣⵉⵢⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R125_5","014_25_5","1CH","25","5","5","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵢⵎⴰⵏ, ⴰⵎⵡⴰⵍⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵛⵛ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉ ⵓⵢⴰ ⵢⴰⵔⵣⴻⴼ ⴰⵔⴻⴱⴱⵉ ⵉ ⵀⴰⵢⵎⴰⵏ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_6","014_25_6","1CH","25","6","6","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵏ ⴰⵙⴰⴼ, ⵢⴰⴷⵓⵜⵓⵏ ⴷ ⵀⴰⵢⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵏ ⵉⵣⵍⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵙ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R125_7","014_25_7","1CH","25","7","7","ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⵏ ⴷⴻⴳ ⵉⵣⵍⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵍⵇⴻⴷⴷ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵜⵓⵖⴰ-ⵜ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_8","014_25_8","1CH","25","8","8","ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜⵉⵇⴻⴷⴷⵓⵃⵉⵏ ⵉ ⵜⵄⴻⵙⵙⴰⵙⵜ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⴰⵎ ⵓⵎⵙⴻⵍⵎⴰⴷ ⴰⵎ ⵓⵎⴻⵃⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R125_9","014_25_9","1CH","25","9","9","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵢⵓⵙⵓⴼ. ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵊⴰⴷⴰⵍⵢⴰ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_10","014_25_10","1CH","25","10","10","ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵣⴰⴽⴽⵓⵔ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_11","014_25_11","1CH","25","11","11","ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵢⴰⵚⵔⵉ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_12","014_25_12","1CH","25","12","12","ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵏⴰⵜⴰⵏⵢⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_13","014_25_13","1CH","25","13","13","ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⴱⵓⵇⵇⵉⵢⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_14","014_25_14","1CH","25","14","14","ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵢⴰⵛⴰⵔⵢⵉⵍⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_15","014_25_15","1CH","25","15","15","ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵉⵛⴰⵄⵢⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_16","014_25_16","1CH","25","16","16","ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_17","014_25_17","1CH","25","17","17","ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵛⵉⵎⵄⵉ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_18","014_25_18","1CH","25","18","18","ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵄⴰⵣⴰⵔⵢⵉⵍ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_19","014_25_19","1CH","25","19","19","ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵀⴰⵛⴰⴱⵢⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_20","014_25_20","1CH","25","20","20","ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵛⵓⴱⴰⵢⵉⵍ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_21","014_25_21","1CH","25","21","21","ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵎⴰⵜⵜⵉⵜⵢⴰ. ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_22","014_25_22","1CH","25","22","22","ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵢⴰⵔⵉⵎⵓⵜ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_23","014_25_23","1CH","25","23","23","ⵡⵉⵙⵙ ⵙⴻⵟⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵃⴰⵏⴰⵏ-ⵢⴰⵀ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_24","014_25_24","1CH","25","24","24","ⵡⵉⵙⵙ ⵙⴱⴻⵄⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵢⴰⵛⴱⴰⵇⴰⵛⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_25","014_25_25","1CH","25","25","25","ⵡⵉⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵃⴰⵏⴰⵏⵉ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_26","014_25_26","1CH","25","26","26","ⵡⵉⵙⵙ ⵜⵙⴻⵄⵟⴰⵛ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵎⴰⵍⵍⵓⵜⵉ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_27","014_25_27","1CH","25","27","27","ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵉⵍⵉⵢⴰⵜⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_28","014_25_28","1CH","25","28","28","ⵡⵉⵙⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵀⵓⵜⵉⵔ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_29","014_25_29","1CH","25","29","29","ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵊⵉⴷⴷⴰⵍⵜⵉ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_30","014_25_30","1CH","25","30","30","ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵎⴰⵃⵣⵉⵢⵓⵜ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R125_31","014_25_31","1CH","25","31","31","ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵔⵓⵎⴰⵎⵜⵉ-ⵄⴰⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_1","014_26_1","1CH","26","1","1","ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ: ⵏ ⵉⵇⵓⵔⴰⵃⵉⵢⵢⴻⵏ: ⵎⴰⵛⴰⵍⴰⵎⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵔⵉ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⴱⵉⵢⴰⵙⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("R126_2","014_26_2","1CH","26","2","2","ⵎⴰⵛⴰⵍⴰⵎⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵔⵔⴰⵡⴻⵏ: ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵏⵣⵓ, ⵢⴰⴷⵉⵄⵉⵍ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵣⴰⴱⴰⴷⵢⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵢⴰⵜⵏⵉⵢⵉⵍ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R126_3","014_26_3","1CH","26","3","3","ⵄⵉⵍⴰⵎ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⵢⵓⵃⴰⵏⴰⵏ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⵉⵍⵢⵓⵄⵉⵏⴰⵢ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R126_4","014_26_4","1CH","26","4","4","ⵓⵍⴰ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵔⵔⴰⵡⴻⵏ: ⵛⴰⵎⵄⵉⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵏⵣⵓ, ⵢⴰⵀⵓⵣⴰⴱⴰⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵢⵓⵡⴰⵅ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵙⴰⴽⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⵏⴰⵜⴰⵏⴰⵢⵉⵍ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("R126_5","014_26_5","1CH","26","5","5","ⵄⴰⵎⵉⵢⵉⵍ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⵉⵙⵙⴰⴽⴰⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴼⴰⵄⴰⵍⵜⴰⵢ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⵎⴰⵖⴰⵔ ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R126_6","014_26_6","1CH","26","6","6","ⵓⵍⴰ ⵉ ⵎⵎⵉⵙ ⵛⴰⵎⵄⵉⵢⴰ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⵙ-ⴷⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_7","014_26_7","1CH","26","7","7","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵛⴰⵎⵄⵉⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ: ⵄⵓⵜⵏⵉ, ⵔⴰⴼⴰⵢⵉⵍ, ⵄⵓⴱⵉⴷ, ⵉⵍⵣⴰⴱⴰⴷ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ: ⵉⵍⵉⵀⵓ ⴷ ⵛⴰⵎⴰⴽⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R126_8","014_26_8","1CH","26","8","8","ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ, ⵏⵉⵜⵏⵉ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵛⵛⵓⵔⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R126_9","014_26_9","1CH","26","9","9","ⵎⴰⵛⴰⵍⴰⵎⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_10","014_26_10","1CH","26","10","10","ⵃⵓⵙⴰ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵔⵔⴰⵡⴻⵏ-ⴰ: ⵛⵉⵎⵔⵉ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵎⴻⵏⵣⵓ, ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R126_11","014_26_11","1CH","26","11","11","ⵃⵉⵍⵇⵉⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵜⴰⴱⴰⵍⵢⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ. ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏ ⵃⵓⵙⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_12","014_26_12","1CH","26","12","12","ⵅ ⵜⴻⵔⴱⵉⵄⵉⵏ-ⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵜⵓⵖⴰ ⵛⵛⵖⴻⵍ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_13","014_26_13","1CH","26","13","13","ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵓ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R126_14","014_26_14","1CH","26","14","14","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⵛⵛⴰⵔⵇ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵛⴰⵍⴰⵎⵢⴰ. ⵓⵍⴰ ⵉ ⵎⵎⵉⵙ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵛⴰⵡⴰⵔ ⵙ ⵍⴻⵄⵇⴻⵍ, ⵜⴻⵡⴹⴰ ⴰⵙ-ⴷⴷ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵓ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵏⵏⴻⵙ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵉ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R126_15","014_26_15","1CH","26","15","15","ⵉ ⵄⵓⴱⵉⴷ-ⵉⴷⵓⵎ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵍⵊⴰⵏⵓⴱ ⵓ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_16","014_26_16","1CH","26","16","16","ⵉ ⵛⵓⴼⴼⵉⵎ ⴷ ⵃⵓⵙⴰ ⵜⴻⴽⴽⴰⵔ ⴰⵙⴻⵏ-ⴷⴷ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵍⵖⴰⵔⴱ, ⴰⴽ-ⴷ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⴰⵍⴰⴽⴰⵜ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R126_17","014_26_17","1CH","26","17","17","ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴱⴻⴷⴷⴻⵏ ⵙⴻⵜⵜⴰ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ ⴽⵓⵍ ⴰⵙⵙ ⴰⵔⴻⴱⵄⴰ. ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵄⴰⵡⴻⴷ ⴽⵓⵍ ⴰⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵓ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_18","014_26_18","1CH","26","18","18","ⵖⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵔⴻⴱⵄⴰ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵜⵏⴰⵢⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵓⵖⴻⵣⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("R126_19","014_26_19","1CH","26","19","19","ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵇⵓⵔⴰⵃ ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R126_20","014_26_20","1CH","26","20","20","ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R126_21","014_26_21","1CH","26","21","21","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴰⵄⴷⴰⵏ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵊⴰⵔⵛⵓⵏⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵍⴰⵄⴷⴰⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵍⴰⵄⴷⴰⵏ, ⴰⵊⴰⵔⵛⵓⵏⵉ: ⵊⴰⵃⵉⵢⵉⵍⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R126_22","014_26_22","1CH","26","22","22","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵃⵢⵉⵍⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵣⵉⵜⴰⵎ ⴷ ⵢⵓⵡⵉⵍ, ⵓⵎⴰⵙ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R126_23","014_26_23","1CH","26","23","23","ⵏ ⵄⴰⵎⵔⴰⵎⵉⵢⵢⴻⵏ, ⴷ ⵉⵢⵉⵚⵀⴰⵔⵉⵢⵢⴻⵏ, ⴷ ⵉⵃⴰⴱⵔⵓⵏⵉⵢⵢⴻⵏ, ⴷ ⵉⵄⴰⵣⵉⵢⵉⵍⵉⵢⵢⴻⵏ ");
INSERT INTO rift_vpl VALUES ("R126_24","014_26_24","1CH","26","24","24","ⵜⵓⵖⴰ ⵛⴰⴱⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵔⵛⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵎⵓⵙⴰ, ⴷ ⴰⵎⴻⵃⴹⴰⵢⵉ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R126_25","014_26_25","1CH","26","25","25","ⴰⵢⵜⵎⴰⵙ ⵣⵉ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⵉⵍⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⵎⵉⵙ ⵔⴰⵃⴰⴱⵢⴰ, ⵎⵎⵉⵙ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵣⵉⴽⵔⵉ ⴷ ⵎⵎⵉⵙ ⵛⴰⵍⵓⵎⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R126_26","014_26_26","1CH","26","26","26","ⵛⴰⵍⵓⵎⵉⵜ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏⵜ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⴰⴽ-ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵅ ⵎⵢⴰ, ⵓ ⴰⴽ-ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R126_27","014_26_27","1CH","26","27","27","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵏⵉ ⵣⵉ ⴳⴰⵔⵔⴰⵜ ⵓ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵄⴻⴷⵍⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R126_28","014_26_28","1CH","26","28","28","ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜ ⵓⵎⵡⴰⵍⴰⵡ ⵛⴰⵎⵡⵉⵍ, ⴷ ⵛⴰⵡⵓⵍ, ⵎⵎⵉⵙ ⵏ ⵇⵉⵙ, ⴷ ⴰⴱⵏⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔ, ⴷ ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⴰⵢⴰ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵜⵓⵖⴰ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏ ⵛⴰⵍⵓⵎⵉⵜ ⴷ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R126_29","014_26_29","1CH","26","29","29","ⵣⴻⴳ ⵉⵢⵉⵚⵀⴰⵔⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⴽⴰⵏⴰⵏⵢⴰ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵅⴻⴷⴷⵎⴻⵏ ⴰⵎ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⴱⴰⵔⵔⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R126_30","014_26_30","1CH","26","30","30","ⵣⴻⴳ ⵉⵃⴰⴱⵔⵓⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵜⴰⵡⴻⵇⵇⴰⴼⵜ ⵅ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵃⴰⵛⴰⴱⵢⴰ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⴰⵍⴻⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵙⵉⴷⵉ ⵓ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R126_31","014_26_31","1CH","26","31","31","ⵉ ⵉⵃⴰⴱⵔⵓⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵢⴰⵔⵉⵢⴰ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵉ ⵉⵃⴰⴱⵔⵓⵏⵉⵢⵢⴻⵏ, ⵉ ⵊⵊⵉⵍⴰⵜ ⵏⵏⴻⵙ, ⵊⴰⵔ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ. ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⴷⴰⵡⵓⴷ ⵜⵜⵡⴰⵔⵣⵓⵏ ⵓ ⵜⵜⵡⴰⴼⴻⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⴷⵉ ⵢⴰⵄⵣⵉⵔ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R126_32","014_26_32","1CH","26","32","32","ⴰⵢⵜⵎⴰⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ. ⴰⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉⴳⴳⴰ ⵜⴻⵏ ⵅ ⴰⵢⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵅ ⴰⵢⵜ ⵏ ⵊⴰⴷ ⵓ ⵅ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R127_1","014_27_1","1CH","27","1","1","ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽ-ⴷ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ, ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⵅ ⵎⵢⴰ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵜⴻⵔⴱⵉⵄⵉⵏ, ⴰⵎ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ, ⴰⵎ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⵔⴰⵃⴻⵏ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵣⴻⴳ ⵓⵢⵓⵔ ⴰⵍ ⵓⵢⵓⵔ ⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵢⵓⵔⴻⵏ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ. ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_2","014_27_2","1CH","27","2","2","ⵢⴰⵙⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉⵢⵉⵍ, ⵜⵓⵖⴰ ⵅ ⵜⴻⵔⴱⵉⵄⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_3","014_27_3","1CH","27","3","3","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴼⴰⵔⵉⵚ. ⵏⴻⵜⵜⴰ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("R127_4","014_27_4","1CH","27","4","4","ⴷⵓⴷⴰⵢ, ⴰⵅⵓⵅⵉ, ⵜⵓⵖⴰ ⵅ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ⵎⵉⵇⵍⵓⵜ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_5","014_27_5","1CH","27","5","5","ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵜⵓⵖⴰ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_6","014_27_6","1CH","27","6","6","ⴱⴰⵏⴰⵢⴰ ⵡⴰ ⵜⵓⵖⴰ ⴷ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⵜⵍⴰⵜⵉⵏ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵅ ⵜⵍⴰⵜⵉⵏ. ⵎⵎⵉⵙ ⵄⴰⵎⵎⵉⵣⴰⴱⴰⴷ ⵜⵓⵖⴰ ⵅ ⵜⴻⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R127_7","014_27_7","1CH","27","7","7","ⵄⴰⵙⴰ’ⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⴱ, ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ ⵎⵎⵉⵙ ⵣⴰⴱⴰⴷⵢⴰ ⵜⵓⵖⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_8","014_27_8","1CH","27","8","8","ⵛⴰⵎⵃⵓⵜ, ⴰⵢⴰⵣⵔⴰⵃⵉ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ, ⵜⵓⵖⴰ ⵅ ⵜⴻⵔⴱⵉⵄⵜ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_9","014_27_9","1CH","27","9","9","ⵄⵉⵔⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵇⵇⵉⵙ, ⴰⵜⵉⵇⵇⵓⵄⵉ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_10","014_27_10","1CH","27","10","10","ⵃⴰⵍⵉⵚ, ⴰⴼⴰⵍⵉⵜⵓⵏⵉ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_11","014_27_11","1CH","27","11","11","ⵙⵉⴱⴽⴰⵢ, ⴰⵃⵓⵛⴰⵜⵉ, ⵏ ⵉⵣⴰⵔⴰⵃⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_12","014_27_12","1CH","27","12","12","ⴰⴱⵉⵄⴰⵣⴰⵔ, ⴰⵄⴰⵏⴰⵜⵓⵜⵉ, ⵏ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_13","014_27_13","1CH","27","13","13","ⵎⴰⵀⴰⵔⴰⵢ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ, ⵉ ⵉⵣⴰⵔⴰⵃⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_14","014_27_14","1CH","27","14","14","ⴱⴰⵏⴰⵢⴰ, ⴰⴼⴰⵔⵄⴰⵜⵓⵏⵉ, ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵉ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_15","014_27_15","1CH","27","15","15","ⵅⴰⵍⴷⴰⵢ, ⴰⵏⴰⵟⵓⴼⴰⵜⵉ, ⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⵉ ⵄⵓⵜⵏⵉⵢⵉⵍ, ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵉ ⵓⵢⵓⵔ ⵜⴻⵏⵄⴰⵛ. ⵜⴰⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_16","014_27_16","1CH","27","16","16","ⵉⵏⴰ ⴱⴻⴷⴷⴻⵏ ⵅ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵉ ⵉⵔⵓⴱⵉⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵉⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵣⵉⴽⵔⵉ, ⴷ ⵍⵃⴰⴽⴻⵎ. ⵉ ⵉⵛⴰⵎⵄⵓⵏⵉⵢⵢⴻⵏ: ⵛⴰⴼⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("R127_17","014_27_17","1CH","27","17","17","ⵉ ⵍⴰⵡⵉ: ⵃⴰⵛⴰⴱⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵎⵓⵡⵉⵍ. ⵉ ⵀⴰⵔⵓⵏ: ⵚⴰⴷⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("R127_18","014_27_18","1CH","27","18","18","ⵉ ⵢⴰⵀⵓⴷⴰ: ⵉⵍⵉⵀⵓ, ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ ⵏ ⴷⴰⵡⵓⴷ. ⵉ ⵉⵙⵙⴰⴽⴰⵔ: ⵄⵓⵎⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R127_19","014_27_19","1CH","27","19","19","ⵉ ⵣⴰⴱⵓⵍⵓⵏ: ⵢⵉⵛⵎⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴱⴰⴷⵢⴰ. ⵉ ⵏⴰⴼⵜⴰⵍⵉ: ⵢⴰⵔⵉⵎⵓⵜ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R127_20","014_27_20","1CH","27","20","20","ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ: ⵃⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⴰ. ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ: ⵢⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R127_21","014_27_21","1CH","27","21","21","ⵉ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷⵉ ⵊⵉⵍⵄⴰⴷ: ⵊⴰⴷⴷⵓ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ. ⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ: ⵢⴰⵄⵉⵙⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴰⴱⵏⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R127_22","014_27_22","1CH","27","22","22","ⵉ ⴷⴰⵏ: ⵄⴰⵣⴰⵔⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃⴰⵎ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R127_23","014_27_23","1CH","27","23","23","ⴷⴰⵡⵓⴷ ⵡⴰⵔ ⵉⴽⵙⵉ ⵛⴰ ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⵡⴰⴷⴷⴰⵢ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵔ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R127_24","014_27_24","1CH","27","24","24","ⵢⵓⵡⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵔⵓⵢⴰ, ⵜⵓⵖⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⵃⵙⴻⴱ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⴽⴻⵎⵎⴻⵍ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵍⵇⴻⴷⴷ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R127_25","014_27_25","1CH","27","25","25","ⵄⴰⵣⵎⴰⵡⴻⵜ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴷⵉⵢⵉⵍ, ⵜⵓⵖⴰ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⵜⵓⵖⴰ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ, ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⵓ ⴷⵉ ⵍⴱⵓⵔⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R127_26","014_27_26","1CH","27","26","26","ⵄⴰⵣⵔⵉ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵍⵓⴱ, ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵛⴰⵔⵣⴻⵏ ⴰⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R127_27","014_27_27","1CH","27","27","27","ⵛⵉⵎⵄⵉ, ⴰⵔⴰⵎⴰⵜⵉ, ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ⵣⴰⴱⴷⵉ, ⴰⵛⵉⴼⵎⵉ, ⵜⵓⵖⴰ ⵅ ⵣⵣⴰⴷ ⵏ ⴱⵉⵏⵓ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R127_28","014_27_28","1CH","27","28","28","ⴱⴰⵄⵍ-ⵃⴰⵏⴰⵏ, ⴰⵊⴰⴷⵉⵔⵉ, ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵉⵃⵡⵉⵛⴻⵏ ⵏ ⵣⵣⵉⵜⵓⵏ ⵓ ⵅ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ. ⵢⵓⵡⴰⵛ ⵜⵓⵖⴰ ⵅ ⵣⵣⴰⴷ ⵏ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("R127_29","014_27_29","1CH","27","29","29","ⵛⵉⵟⵔⴰⵢ, ⴰⵛⴰⵔⵓⵏⵉ, ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵉⵏⵏⵉ ⵉⵀⴻⴷⴷⴰ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵛⴰⵔⵓⵏ. ⵛⴰⴼⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵍⴰⵢ, ⵜⵓⵖⴰ ⵅ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R127_30","014_27_30","1CH","27","30","30","ⵓⴱⵉⵍ, ⴰⵙⵎⴰⵄⵉⵍⵉ, ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵉⵍⴻⵖⵎⴰⵏ. ⵢⴰⵃⴰⴷⵢⴰ, ⴰⵎⵉⵔⵓⵏⵓⵜⵉ, ⵜⵓⵖⴰ ⵅ ⵜⵉⵖⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R127_31","014_27_31","1CH","27","31","31","ⵢⴰⵣⵉⵣ, ⴰⵀⴰⵊⵔⵉ, ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴰⵛⴱⴰⵔ ⵅ ⵡⵓⴵⵉ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵅ ⵡⴰⴳⵍⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R127_32","014_27_32","1CH","27","32","32","ⵢⵓⵏⴰⵜⴰⵏ, ⵄⴻⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵜⵓⵖⴰ ⴷ ⴰⵎⵛⴰⵡⴰⵔ, ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⵉⵖⵉⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⴷ ⴰⵎⴰⵔⵉⵔ. ⵢⴰⵃⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴽⵎⵓⵏⵉ, ⵜⵓⵖⴰ ⵖⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵢⴰⵔⴻⴱⴱⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R127_33","014_27_33","1CH","27","33","33","ⴰⵅⵉⵜⵓⴼⵉⵍ ⵜⵓⵖⴰ ⴷ ⴰⵎⵛⴰⵡⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓ ⵃⵓⵛⴰⵢ, ⴰⵢⴰⵔⴽⵉ, ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R127_34","014_27_34","1CH","27","34","34","ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⴰⵢⴰ, ⴷ ⴰⴱⵢⴰⵜⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⴰⵅⵉⵜⵓⴼⵉⵍ. ⵢⵓ’ⴰⴱ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R128_1","014_28_1","1CH","28","1","1","ⴷⴰⵡⵓⴷ ⵉⵙⵙⵎⵓⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⵔⴱⵉⵄⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⴷ ⵍⴽⴻⵙⴱⴻⵜ ⵏ ⵍⵎⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵡⴰⵀ, ⴽⵓⵍ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R128_2","014_28_2","1CH","28","2","2","ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰⵢⵜⵎⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ! ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔⵉ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵓ ⵉ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵅ ⵓⵢⴻⵏⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉ ⵍⴻⴱⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R128_3","014_28_3","1CH","28","3","3","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜⴱⴻⵏⵏⵉⴷ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵉⵎⴻⵏⵖⴰⵏ ⵓ ⵜⴻⵙⵙⵉⵣⵍⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⴷⴰⵎⵎⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("R128_4","014_28_4","1CH","28","4","4","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴼⴰⵔⵣ ⴰⵢⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴼⴰⵔⵣ ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴱⴰⴱⴰ ⵢⴰⵔⴹⴰ ⴷⴰⵢⵉ ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R128_5","014_28_5","1CH","28","5","5","ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵉⵏⵓ - ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ - ⵉⴼⴰⵔⵣ ⵏⴻⵜⵜⴰ ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R128_6","014_28_6","1CH","28","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵎⵎⵉⵛ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉ ⴼⴰⵔⵣⴻⵖ ⴷ ⵎⵎⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵉⵍⵉⵖ ⴷ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R128_7","014_28_7","1CH","28","7","7","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴹⴼⴰⵔ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵙ ⵊⵊⴻⵀⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ.’ ");
INSERT INTO rift_vpl VALUES ("R128_8","014_28_8","1CH","28","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⴷ ⴰⵡⴻⵎ ⵄⴻⵍⵎⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ, ⵓ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵓ ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵜⴰⵏⵉⵜⴰ ⴷ ⵍⵡⴰⵔⵜ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⵊⵊⴻⵎ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵡⴻⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R128_9","014_28_9","1CH","28","9","9","ⵓ ⵛⴻⴽ, ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ, ⵙⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ ⵓ ⵙⴻⵅⵅⴰⵔ ⴰⵙ ⵙ ⵡⵓⵍ ⵉⵎⵓⵏ ⴷ ⵙ ⵍⴻⵄⵎⴰⵔ ⵉⵡⴻⵊⴷⴻⵏ ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵜⵜⴱⴻⵇⵇⴻⵛ ⵎⴰⵔⵔⴰ ⵓⵍⴰⵡⴻⵏ ⵓⵛⴰ ⵉⴼⴻⵀⵀⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵖⴰⵔ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵖ. ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴰⵔⵣⵓⴷ ⵅⴰⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⴼ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵙⴻⵎⵃⴻⴷ ⴷⴰⵢⴻⵙ, ⴰⴷ ⵛⴻⴽ ⵉⵏⴹⴰⵔ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R128_10","014_28_10","1CH","28","10","10","ⵅⵣⴰⵔ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵉ ⵛⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⴻⴱⵏⵉⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵓⵛⴰ ⴻⴳⴳ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("R128_11","014_28_11","1CH","28","11","11","ⴷⴰⵡⵓⴷ ⵉⵡⵛⴰ ⵉ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ ⴰⵎⴻⴷⵢⴰ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ, ⵏ ⵍⴻⴱⵏⵉⵢⴰⵜ ⵏⵏⴻⵙ, ⴷ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⴷ ⵜⵖⵓⵔⴼⴰⵜⵉⵏ ⵏⵏⴻⵙ, ⴷ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵏ ⴷⴰⵅⴻⵍ, ⴷ ⵡⴻⵅⵅⴰⵎ ⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("R128_12","014_28_12","1CH","28","12","12","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ-ⴷⴷ ⵢⵓⵙⴰ ⵙ ⴰⵔⵔⵓⵃ ⵅ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R128_13","014_28_13","1CH","28","13","13","ⵅ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R128_14","014_28_14","1CH","28","14","14","ⵅ ⵡⵓⵔⴻⵖ, ⴰⵇⴰ ⵉⵡⵛⴰ ⵍⴻⵡⵣⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵓⵍⴰ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵡⵛⴰ ⵍⴻⵡⵣⴻⵏ ⵏⵙⴻⵏ, ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⴽⵓⵍ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R128_15","014_28_15","1CH","28","15","15","ⵉⵡⵛⴰ ⵓⵍⴰ ⵍⴻⵡⵣⴻⵏ ⵉ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵙⴻⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵍⴻⵡⵣⴻⵏ ⵏ ⴽⵓⵍ ⵍⵇⴻⵏⴷⵉⵍ ⴰⴽ-ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ ⵡⴻⵃⵃⴷⴻⵙ, ⵓⵍⴰ ⵍⴻⵡⵣⴻⵏ ⵉ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵍⴻⵡⵣⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵇⴻⵏⴷⵉⵍ ⴰⴽ-ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵙ ⵡⴻⵃⵃⴷⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵢⵓⵙⴰ ⴰⴽ-ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴽⵓⵍ ⵍⵇⴻⵏⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R128_16","014_28_16","1CH","28","16","16","ⵄⴰⵡⴻⴷ ⵍⴻⵡⵣⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵟⵟⴰⴱⵍⴰⵜ ⵉ ⵅ ⴱⴻⵣⵣⵄⴻⵏ ⴰⵖⵔⵓⵎ, ⵉ ⴽⵓⵍ ⵟⵟⴰⴱⵍⴰ ⵍⴻⵡⵣⴻⵏ ⵏⵏⴻⵙ ⵡⴻⵃⵃⴷⴻⵙ, ⵓⵍⴰ ⴷ ⵍⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵟⵟⴰⴱⵍⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("R128_17","014_28_17","1CH","28","17","17","ⵓⵍⴰ ⴷ ⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵉ ⴼⵓⵔⵛⴰⵢⴰⵜ, ⵉ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ, ⵉ ⵉⴼⴻⵏⵊⴰⵍⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⴰⴽ-ⴷ ⵍⴻⵡⵣⴻⵏ ⵏ ⴽⵓⵍ ⴰⴼⴻⵏⵊⴰⵍ ⵡⴻⵃⵃⴷⴻⵙ, ⵉ ⵉⴼⴻⵏⵊⴰⵍⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴰⴽ-ⴷ ⵍⴻⵡⵣⴻⵏ ⵉ ⴽⵓⵍ ⴰⴼⴻⵏⵊⴰⵍ ⵡⴻⵃⵃⴷⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R128_18","014_28_18","1CH","28","18","18","ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ ⴰⴽ-ⴷ ⵍⴻⵡⵣⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔ, ⵓⵍⴰ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵍⴻⵡⵣⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵓⵎⴻⴷⵢⴰ ⵏ ⵓⴽⴰⵔⵔⵓ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵉⵏⵏⵉ ⵉⴱⴻⵣⵣⵄⴻⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴷⵍⵉⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R128_19","014_28_19","1CH","28","19","19","ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ, ⵉⵜⵜⵡⴰⵙⵙⴻⴼⵀⴻⵎ ⴰⵢⵉ ⵙ ⵜⵉⵔⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⴷⴷ ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵓⵎⴻⴷⵢⴰ ⵏ ⵍⴻⴱⵏⵉ, ⴰⵇⴰ ⵢⵓⵔⴰⵏⵜ ⴷⵉ ⵜⵉⵔⴰ-ⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R128_20","014_28_20","1CH","28","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ: “ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ, ⵉⵍⵉ ⵜⵎⴻⵃⴹⴻⴷ ⵓ ⴻⴳⴳ ⵉ-ⵜ! ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⴰⵔⴻⵅⵅⵓ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⴻⴽ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵙⴻⵎⵎⴻⵃ ⵏⵉⵖ ⵛⴻⴽ ⵉⵜⵜⴻⵊⵊⵉ ⴰⵍ ⴰⴽⴻⵎⵎⴻⵍ ⵏ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R128_21","014_28_21","1CH","28","21","21","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵇⴰ ⴷⵉⵏ ⵖⴰⵔⴻⴽ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⴷⵉ ⵍⵅⴰⴷⴰⵔ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴳⴳⴻⵏ ⵙ ⵜⵉⵖⵉⵜ ⵉ ⴽⵓⵍ ⵍⵅⴻⴷⵎⴻⵜ. ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("R129_1","014_29_1","1CH","29","1","1","ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ: “ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⴰⵢⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵄⴰⴷ ⴷ ⴰⵃⵓⴷⵔⵉ ⴷ ⴰⵔⴻⵅⴼⴻⵏ ⵓⵛⴰ ⵍⵅⴻⴷⵎⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵍⴻⵇⵚⴰⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R129_2","014_29_2","1CH","29","2","2","ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵉⵏⵓ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵓⵔⴻⵖ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ, ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵏⵏⵃⴰⵙ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ, ⵓⵣⵣⴰⵍ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵣⵣⴰⵍ, ⴰⴽⴻⵛⵛⵓⴹ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ⴷ ⵉⵥⵔⴰ ⵏ ⵓⵏⵉⴽⵙ ⴷ ⵉⵥⵔⴰ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵓⵍⴰ ⴷ ⵉⵥⵔⴰ ⵉⵜⵜⵡⴰⵙⵙⵇⴰⵔⴻⵇⵛⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⵉ ⵜⵛⵓⵢⴰⵔ, ⵓⵍⴰ ⵄⴰⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⵥⵔⴰ ⵏ ⵍⵎⴰⵔⵎⵓⵔ ⴷ ⴰⵛⴻⵎⵍⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R129_3","014_29_3","1CH","29","3","3","ⵣⵉ ⵜⴰⵢⵔⵉ ⵉⵏⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⴷ ⴰⵔⵣⴼⴻⵖ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵉⵏⵓ ⵄⴰⴷ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵜⵉⵡⴰ ⵉ ⵎⵉⵏ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R129_4","014_29_4","1CH","29","4","4","ⵄⴰⴷ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵣⴻⴳ ⵡⵓⵔⴻⵖ ⵏ ⵓⴼⵉⵔ ⴷ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵚⴼⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵃⴻⵏⵏⵛⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⵉⵅⵅⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R129_5","014_29_5","1CH","29","5","5","ⵓⵔⴻⵖ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ, ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵃⵔⴰⵢⴼⵉⵢⵢⴻⵏ. ⵎⴰⵏ ⵡⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⵡⵡⵄⴻⵏ ⴰⵙⵙ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⵉ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("R129_6","014_29_6","1CH","29","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⵅ ⵎⵢⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R129_7","014_29_7","1CH","29","7","7","ⵏⵉⵜⵏⵉ ⴰⵔⵣⴼⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⴷⵔⴰⵅⵎⴰⵜ ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("R129_8","014_29_8","1CH","29","8","8","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵓⴼⵉⵏ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ, ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵉ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵢⴰⵃⵉⵢⵉⵍ, ⴰⵊⴰⵔⵛⵓⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R129_9","014_29_9","1CH","29","9","9","ⵉⴼⴰⵔⵃ ⵍⴳⴻⵏⵙ ⵙ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵣⴻⴳ ⵡⵓⵍ ⵉⵎⵓⵏ ⵇⴰⵄ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵉⴼⴰⵔⵃ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R129_10","014_29_10","1CH","29","10","10","ⴷⴰⵡⵓⴷ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("R129_11","014_29_11","1CH","29","11","11","ⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵍⴻⵎⵖⴰⵔⴻⵜ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷ ⵍⵄⴻⵣⵣ ⴷ ⵎⵉⵏ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⴷ ⵍⵄⴰⴹⴰⵎⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴰ-ⵜ ⵏⵏⴻⵛ. ⵣⵣⴰⵢⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵉ ⵜⴻⴵⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ, ⵣⵣⴰⵢⴻⴽ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵣⴻⴵⵉⴼ ⵜⵉⵡⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R129_12","014_29_12","1CH","29","12","12","ⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓ ⵛⴻⴽ ⵜⵚⴻⴵⴹⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ. ⴰⵇⴰ-ⵜ ⵊⵊⴻⵀⴷ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⴷ ⵊⵊⴻⵀⴷ ⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R129_13","014_29_13","1CH","29","13","13","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵇⴰⴷⴰ ⵛⴻⴽ ⵓ ⵏⴻⵜⵜⵚⴻⴱⴱⴻⵃ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R129_14","014_29_14","1CH","29","14","14","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ ⴷ ⵎⵉⵏ ⵉⵄⵏⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵡⵛ ⴰⵎⵎⵓ ⵙ ⵍⵅⴰⴹⴰⵔ? ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⴽ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵎⴰⵔⵔⴰ ⵓ ⵎⵉⵏ ⵉ ⴷ ⴰⵛ ⵏⴻⵡⵛⴰ, ⵏⴻⵡⵛⴰ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R129_15","014_29_15","1CH","29","15","15","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵎⵖⵉⵔ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵄⵣⴰⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⵉⵍⵉ ⵓ ⵍⴰⵢⴰⵙ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("R129_16","014_29_16","1CH","29","16","16","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵢⵓⵙⴰ-ⴷⴷ ⵎⴰⵔⵔⴰ ⴰⴼⴻⵢⵢⴻⴹ-ⴰ ⵉ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵛⴻⴽ, ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R129_17","014_29_17","1CH","29","17","17","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵇⴻⴵⴱⴻⴷ ⵓⵍ ⵓ ⴰⵇⴰ ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵛ ⵓⵙⴻⴳⴳⴻⵎ. ⵏⴻⵛⵛ, ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⵉⵏⵓ, ⵡⵛⵉⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵓ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉ ⴷⴰ ⵉⴵⴰⵏ - ⵉⵡⴰ ⵥⵔⵉⵖ ⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ - ⵉⵡⵛⴰ ⴰⵛ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵙ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R129_18","014_29_18","1CH","29","18","18","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵉⵙⵔⴰⵉⵍ, ⵃⴹⴰ ⵅⴻⵏⵏⵉ ⵉ ⵍⴻⴱⴷⴰ ⴰⵇⴰ ⴰⵢⴰ ⴰⴷ ⵢⴻⵊⵊ ⵟⵟⴰⴱⴻⵄ ⵅ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓ ⵏⴷⴻⵀ ⵓⵍ ⵏⵙⴻⵏ ⵖⴰⵔⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("R129_19","014_29_19","1CH","29","19","19","ⴻⵡⵛ ⵓⵍⴰ ⵉ ⵎⵎⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵉⵎⵓⵏ ⵇⴰⵄ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴹⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵛ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⵏⴰ ⵍⴻⵇⵚⴰⵔ-ⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵅ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("R129_20","014_29_20","1CH","29","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ: “ⴱⴰⵔⴽⴻⵎ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ!” ⵅⴻⵏⵏⵉ ⵉⴱⴰⵔⴻⴽ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⴹⴰⵔⴻⵏ, ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵙⵉⴷⵉ ⵓ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R129_21","014_29_21","1CH","29","21","21","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⴰⵍⴻⴼ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵍⴻⴼ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ ⵓ ⵅⴻⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵖⴰⵔⵚⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R129_22","014_29_22","1CH","29","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵛⵛⵉⵏ ⵓ ⵙⵡⵉⵏ ⵏⵉⵜⵏⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⴳⴳⵉⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ ⴷⴻⵀⵏⴻⵏ ⵜ ⴷ ⵍⵃⴰⴽⴻⵎ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵓ ⵚⴰⴷⵓⵇ ⴷⴻⵀⵏⴻⵏ ⵜ ⴷ ⴰⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R129_23","014_29_23","1CH","29","23","23","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⵉⴼⵍⴻⵃ ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵍⴰ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R129_24","014_29_24","1CH","29","24","24","ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵡⵜⵉⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R129_25","014_29_25","1CH","29","25","25","ⵢⴰⵔⵔⴰ ⵙⵉⴷⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⵟⵟⴰⵔⴼ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⵡⴻⵇⵇⴰⵔ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ ⵇⴱⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R129_26","014_29_26","1CH","29","26","26","ⴰⵎⵎⵓ ⵉ ⵉⵃⴽⴻⵎ ⴷⴰⵡⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ, ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R129_27","014_29_27","1CH","29","27","27","ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴷⵉ ⵃⴰⴱⵔⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵍⴰⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R129_28","014_29_28","1CH","29","28","28","ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⵓⵎⵉ ⵉⵛⴰⴱ ⵎⵍⵉⵃ, ⵉⵊⵊⵉⵡⴻⵏ ⵓⵙⵙⴰⵏ, ⴰⴳⵍⴰ ⴷ ⵓⵄⵓⴵⵉ. ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R129_29","014_29_29","1CH","29","29","29","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵓⵎⵡⴰⵍⴰⵡ ⵛⴰⵎⵡⵉⵍ ⵓ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⵓ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵓⵎⵡⴰⵍⴰⵡ ⵊⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("R129_30","014_29_30","1CH","29","30","30","ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⵓ ⵅ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⵉ ⵅⴰⵙ ⴷⴷ-ⵉⴽⴽⵉⵏ ⵓⵍⴰ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R21_1","015_1_1","2CH","1","1","1","ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵉⵜⵜⵡⴰⴹⵎⴻⵏ ⴷⵉ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("R21_2","015_1_2","2CH","1","2","2","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⵅ ⵎⵢⴰ, ⴰⴽ-ⴷ ⵍⵇⵓⴹⴰⵜ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R21_3","015_1_3","2CH","1","3","3","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ, ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⴽⵉⴷⴻⵙ, ⵖⴰⵔ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ, ⵎⵉⵏⵣⵉ ⴷⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴳⴳⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("R21_4","015_1_4","2CH","1","4","4","ⵎⴰⵛⴰ ⴷⴰⵡⵓⴷ ⵢⵉⵡⵉ ⵜⵜⴰⴱⵓⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷⴷ ⴰⵙ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ ⵉ ⵜⵜⴰⴱⵓⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R21_5","015_1_5","2CH","1","5","5","ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵉⴳⴳⴰ ⴱⴰⵚⴰⵍⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ, ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⵊⵉⴱⵄⵓⵏ ⵣⵣⴰⵜ ⵉ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵏ ⵙⵉⴷⵉ. ⵙⵓⵍⵉⵎⴰⵏ ⵢⵓⵢⵓⵔ ⴷⵉⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ");
INSERT INTO rift_vpl VALUES ("R21_6","015_1_6","2CH","1","6","6","ⵓⵛⴰ ⵉⵇⴻⴷⴷⴻⵎ ⴷⵉⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵅⴰⵙ ⴰⵍⴻⴼ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("R21_7","015_1_7","2CH","1","7","7","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ, ⵉⴱⴰⵏ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵜⴰⵔ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵛ ⵜ ⵡⵛⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("R21_8","015_1_8","2CH","1","8","8","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵏⵏⴰ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R21_9","015_1_9","2CH","1","9","9","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⴰⴷ ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵡⵙⴻⵄ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R21_10","015_1_10","2CH","1","10","10","ⴻⵡⵛ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵖ ⵓ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎ ⵍⵃⴰⴽⴻⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵍⵃⴻⵇⵇ?” ");
INSERT INTO rift_vpl VALUES ("R21_11","015_1_11","2CH","1","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵙⵓⵍⵉⵎⴰⵏ: “ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵡⵓⵍ ⵓ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⴷ ⴰⴳⵍⴰ, ⵍⴻⴽⵙⵉⴱⴻⵜ ⵏⵉⵖ ⵛⵛⴰⵏ ⵏⵉⵖ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵜⴰⵣⵉⵔⴰⵔⵜ, ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴳⴻⵡⵡⴷⴻⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵙ ⵍⵃⴻⵇⵇ, ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵅⴻⴼ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("R21_12","015_1_12","2CH","1","12","12","ⴰⵇⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵛ ⵍⴻⵅⵅⵓ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ, ⵓ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵄⴰⵡⴻⴷ ⴰⴳⵍⴰ ⴷ ⵍⴻⴽⵙⵉⴱⴻⵜ ⴷ ⵛⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵜⴻⵏ ⵉⵟⵟⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵇⴱⴻⵍ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜᵉⵟⵟⵉⴼⴻⵏ ⵄⴰⴷ ⴰⵎⵎⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("R21_13","015_1_13","2CH","1","13","13","ⵣⵉ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⵅ ⵜⵜⵏⵓⵎⴰⵏ ⵜⵜⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ, ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵊⵉⴱⵄⵓⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵢⵉⵡⴻⴹ-ⴷⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⵃⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R21_14","015_1_14","2CH","1","14","14","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⵎⵓⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵍⴻⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R21_15","015_1_15","2CH","1","15","15","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵏⴻⵛⵜ ⵏ ⵢⴻⵥⵔⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴰⵏⴻⵛⵜ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R21_16","015_1_16","2CH","1","16","16","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵢⵙⴰⵏ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵇⵉⵡⵉ. ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵜⵜⴰⵎⴰⵏ ⵉⵎⴻⵜⵏⴻⵏ ⵣⵉ ⵇⵉⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("R21_17","015_1_17","2CH","1","17","17","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵓⵛⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⵙ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ. ⴰⵎⵎⵓ ⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R21_18","015_1_18","2CH","1","18","18","ⵙⵓⵍⵉⵎⴰⵏ ⵢⵓⵎⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R22_1","015_2_1","2CH","2","1","1","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵃⵙⴻⴱ ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵏ ⵍⴻⵀⵎⴻⵍ ⴷ ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴷⴷⵎⴻⵏ ⴰⵎ ⵢⵉⵙⵓⵢⴷⴰⵢⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓⵍⴰ ⴷ ⵜⵍⴰⵜⴰ-ⴰⵍⴰⴼ ⵓ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⴵⴰⵏ ⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R22_2","015_2_2","2CH","2","2","2","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵃⵉⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ, ⵉⵏⵏⴰ: “ⴻⴳⴳ ⴰⴽⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⴰⴽ-ⴷ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵖⴰⵔⴻⵙ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵣⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R22_3","015_2_3","2CH","2","3","3","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵜ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴱⴻⵅⵅⴰⵔⴻⵖ ⴷⵉⵏ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵙⵙⴰⵔⵙⴻⵖ ⵍⴻⴱⴷⴰ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵇⴻⴷⴷⵎⴻⵖ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵓ ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵅ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R22_4","015_2_4","2CH","2","4","4","ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰ ⴱⵏⵉⵖ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R22_5","015_2_5","2CH","2","5","5","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ? ⴰⵇⴰ ⴰⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⴰⵊⴻⵏⵏⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⴽⵙⵉ! ⵓ ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵎⵖⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⴱⴻⵅⵅⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("R22_6","015_2_6","2CH","2","6","6","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵅⴷⴻⵎ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ ⵓⵍⴰ ⵙ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵃⵎⵉ ⴷ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵓⴷⴻⵀⵎⴰⵏⵉ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵉⵙⵙⴻⵏ ⴰⴷ ⵉⴳⴳ ⵉⵏⵇⴰⵛⴻⵏ, ⵡⴰⵀ, ⵙⴻⴽⴽ ⵉ-ⵜ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵉ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R22_7","015_2_7","2CH","2","7","7","ⵙⵉⵡⴻⴹ ⴰⵢⵉ-ⴷⴷ ⵓⵍⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵓⵎⴻⵔⵣⵉ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵚⴰⵏⴷⴻⵍ ⴰⵣⴻⴳⴳⵯⴰⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⵜⵃⴰⴽⴰⵏ ⴷⴻⴳ ⵓⵏⴻⵣⴷⴰⵎ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵓ ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("R22_8","015_2_8","2CH","2","8","8","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵎⴰⵔⵔⴰ ⴰⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⴱⵏⵉⵖ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵍⴻⵄⵊⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("R22_9","015_2_9","2CH","2","9","9","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵣⴻⵄⵎⴰ ⵉ ⵉⵏⴻⵣⴷⴰⵎⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵎⴻⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ, ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵓⴽⵓⵔⵓ ⵏ ⵢⵉⵔⴷⴻⵏ ⴷ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵓⴽⵓⵔⵓ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵓⴱⴰⵜⵓ ⵏ ⴱⵉⵏⵓ ⴷ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵓⴱⴰⵜⵓ ⵏ ⵣⵣⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("R22_10","015_2_10","2CH","2","10","10","ⵃⵉⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙ ⵜⵉⵔⴰ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵜⴰⴱⵔⴰⵜ-ⴰ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ: “ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R22_11","015_2_11","2CH","2","11","11","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵃⵉⵔⴰⵎ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵉ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵍⴻⵄⵇⴻⵍ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴱⵏⴰⵏ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("R22_12","015_2_12","2CH","2","12","12","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵉⵖⵉⵙ ⵣⵉ ⴱⴰⴱⴰ ⵃⵉⵔⴰⵎ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("R22_13","015_2_13","2CH","2","13","13","ⵎⵎⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⴻⴳ ⵢⴻⵙⵙⵉⵙ ⵏ ⴷⴰⵏ. ⴱⴰⴱⴰⵙ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵚⵓⵔ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵓⵙⵙⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴷⴻⵎ ⵙ ⵡⵓⵔⴻⵖ, ⵏⵏⵓⵇⴰⵔⵜ, ⵏⵏⵃⴰⵙ, ⵓⵣⵣⴰⵍ ⵓ ⵙ ⵡⴻⵥⵔⵓ ⴷ ⵓⴽⴻⵛⵛⵓⴹ, ⵙ ⵓⴼⵉⵍⵓ ⴰⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵓⴷⴻⵀⵎⴰⵏⵉ, ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵓ ⵙ ⵓⴼⵉⵍⵓ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵇⴻⵛ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵛⴻⵎ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵔⴻⵇⵇⴰⵎⴻⵏ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵛ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R22_14","015_2_14","2CH","2","14","14","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵔⴷⴻⵏ ⴷ ⵉⵎⴻⵏⴷⵉ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⴱⵉⵏⵓ, ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ, ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R22_15","015_2_15","2CH","2","15","15","ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵣⴷⴻⵎ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⵓⴱⵏⴰⵏ ⴰⵏⴻⵛⵜ ⵉ ⴷ ⴰⵛ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵜⴻⵏⵜ ⵉ-ⴷⴷ-ⵏⴰⵡⵉ ⵅ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⵃⴻⵏⵢⴰ ⵅ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵢⴰⴼⴰ, ⵓ ⵛⴻⴽ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("R22_16","015_2_16","2CH","2","16","16","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵃⵙⴻⴱ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⴻⵃⵙⴰⴱ ⵓⵎⵉ ⵜⴻⵏ ⵉⵃⵙⴻⴱ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵓⴼⵉⵏ ⴰⵇⴰ ⴷⵉⵏ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵙⴻⵜⵜⴰ ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R22_17","015_2_17","2CH","2","17","17","ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵏ ⵍⴻⵀⵎⴻⵍ ⵓ ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⴷ ⵉⵙⵓⵢⴷⴰⵢⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⴷ ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ-ⵎⵢⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵅⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R23_1","015_3_1","2CH","3","1","1","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⴷⴰ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵎⵓⵔⵉⵢⴰ, ⵎⴰⵏⵉ ⴷⴷ-ⵉⴱⴰⵏ ⵙⵉⴷⵉ ⵉ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ ⵓ ⵎⴰⵏⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵅ ⵓⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵢⴰⴱⵓⵙⵉ ⵓⵔⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_2","015_3_2","2CH","3","2","2","ⵏⴻⵜⵜⴰ ⵉⴱⴷⴰ ⵍⴻⴱⵏⵉ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R23_3","015_3_3","2CH","3","3","3","ⵡⴰⵏⵉⵜⴰ ⴷ ⴷⵙⴰⵙ ⵉ ⵉⵙⵙⴰⵔⵙ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ: ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵖⴰⴵⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⵢⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ-ⵜⵜ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_4","015_3_4","2CH","3","4","4","ⴰⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ, ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵓⵖⴰ-ⵜ ⴷⴰⵢⴻⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵎⵉ ⵜ ⵄⴻⴱⴱⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷⴰⵢⴻⵙ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵜⵓⵖⴰ ⵉⴷⵍⴰ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_5","015_3_5","2CH","3","5","5","ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⴳⴳⴰ ⴰⵙ ⵜⴰⵥⴻⵇⵇⴰ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵅⴰⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵓ ⵉⵣⴻⵡⵡⴻⵇ ⵉ-ⵜ ⵙ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⴷ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵣⴻⵡⵡⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_6","015_3_6","2CH","3","6","6","ⵄⴰⵡⴻⴷ ⵉⵣⴻⵡⵡⴻⵇ ⵏⴻⵜⵜⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵢⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ. ⵓⵔⴻⵖ ⵜⵓⵖⴰ ⴷ ⵓⵔⴻⵖ ⵣⵉ ⴼⴰⵔⴰⵡⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R23_7","015_3_7","2CH","3","7","7","ⴰⵎⵎⵓ ⵉ ⵉⴷⵍⴰ ⵏⴻⵜⵜⴰ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵉⵃⴻⵏⵢⴰ, ⵜⵉⵏⴻⴱⴷⴰⵜⵉⵏ, ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵙ ⵡⵓⵔⴻⵖ, ⵓⵛⴰ ⵉⵏⵇⴻⵛ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷⵉ ⵍⴻⵃⵢⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("R23_8","015_3_8","2CH","3","8","8","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⴰⵅⵅⴰⵎ ⵏ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ. ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵎⵉ ⵜ ⵄⴻⴱⴱⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵓⵍⴰ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷⴰⵢⴻⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⴷⵍⴰ ⵍⴻⵃⵢⵓⴹ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵡⴻⵅⵅⴰⵎ ⵙ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_9","015_3_9","2CH","3","9","9","ⵍⴻⵡⵣⴻⵏ ⵏ ⵉⵎⴻⵙⵎⴰⵔⴻⵏ ⵉⵙⴻⴽⴽⵡⴰ ⵅⴻⵎⵙⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ. ⵉⴷⵍⴰ ⵓⵍⴰ ⴷ ⵜⵉⵖⵓⵔⴼⴰⵜⵉⵏ ⵏ ⵙⴻⵏⵏⴻⵊ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R23_10","015_3_10","2CH","3","10","10","ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵡⴻⵏⵇⴰⵛ, ⵓ ⵉⵍⴻⵃⵃⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R23_11","015_3_11","2CH","3","11","11","ⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵊⵎⵉⵄ ⵄⴻⴱⴱⴰⵔⴻⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ. ⴰⴼⵔⵉⵡ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵄⴻⴱⴱⴰⵔ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ, ⵉⵜⵜⴰⴽⴽⵯⴰⴹ ⵍⵃⵉⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⵛⴰ ⴰⴼⵔⵉⵡ ⵏⵏⴻⵖⵏⵉ ⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⴼⵔⵉⵡ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R23_12","015_3_12","2CH","3","12","12","ⴰⴼⵔⵉⵡ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ ⵉⵄⴻⴱⴱⴰⵔ ⵓⵍⴰ ⴷ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵍⵃⵉⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⴰⴼⵔⵉⵡ ⵏⵏⴻⵖⵏⵉ ⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉⵍⴻⵇⵇⴻⴼ ⴰⴼⵔⵉⵡ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R23_13","015_3_13","2CH","3","13","13","ⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ-ⴰ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵙⵙⴻⵡⴹⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("R23_14","015_3_14","2CH","3","14","14","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⴰⵍⴻⵃⵃⴰⴼ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⴷⴻⵃⵎⵉ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵓ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵓⵛⴰ ⵉⴳⴳⴰ ⵅⴰⵙ ⵉⴽⵉⵔⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_15","015_3_15","2CH","3","15","15","ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵓⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵜⵜⴰⵊⵊ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_16","015_3_16","2CH","3","16","16","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵣⴻⵡⵡⵇⴻⵏ ⴰⵎ ⵜⵉⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⵅ ⵜⵇⵉⵛⵛⴰⵜⵉⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ. ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵎⵢⴰ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵓⵛⴰ ⵉⵛⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵣⴻⵡⵡⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R23_17","015_3_17","2CH","3","17","17","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵊⵊⴻⵏ ⵅ ⵢⴻⴼⵓⵙ ⵓ ⵉⵊⵊⴻⵏ ⵅ ⵓⵣⴻⵍⵎⴰⴹ. ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵉⴳⴳⴰ ⴰⵙ ⵢⴰⵅⵉⵏ ⵓ ⵡⴻⵏⵏⵉ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵉⴳⴳⴰ ⴰⵙ ⴱⵓⵄⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("R24_1","015_4_1","2CH","4","1","1","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ. ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R24_2","015_4_2","2CH","4","2","2","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵉⴼⴻⵙⵢⴻⵏ. ⵜⵓⵖⴰ ⵍⴻⵄⴱⴰⵔ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ, ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵇⵓⵔⴰⵛⵜ. ⵜⵉⴷⴷⵉ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵉⵛⵜ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("R24_3","015_4_3","2CH","4","3","3","ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⴱⴻⴷⴷⴻⵏⵜ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⴰⵇⴰ ⵏⵏⴹⴻⵏⵜ ⴰⵙ-ⴷⴷ ⵇⴰⵄ. ⵏⵏⵓⵡⴰⵔⴰⵜ ⵉ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏⵜ ⵄⴰⴷ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵇⴰⵄ, ⵄⴻⵛⵔⴰ ⴷⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ, ⵜⵓⵖⴰ ⵇⵇⵏⴻⵏⵜ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⴰⵎ ⵇⵓⵡⵡⴰⵔⴻⵏⵜ ⵉ ⵜⵔⵉⵎⴰⵏⵜ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ. ⵏⵏⵓⵡⴰⵔⴰⵜ ⵉ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏⵜ ⵄⴰⴷ ⵜⵓⵖⴰ ⵜⵜⵡⴰⴼⴻⵙⵢⴻⵏⵜ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵜⵔⵉⵎⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R24_4","015_4_4","2CH","4","4","4","ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴱⴻⴷⴷ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵓ ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵏ ⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴰⵔⵙⴰ ⵅⴰⵙⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵣⵣⵄⴻⵏⵇⵓⵇⴰⵜ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏⵜ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("R24_5","015_4_5","2CH","4","5","5","ⵜⵓⵖⴰ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⴻⴳⴷⴰⵔ ⵉⵊⵊ ⵏⵛⴱⴰⵔ ⵏ ⵓⴼⵓⵙ ⵓ ⵜⵎⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵎⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⴼⴻⵏⵊⴰⵍ, ⴰⵎ ⵜⵏⴻⵡⵡⴰⵛⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⵍⵉⵍⵍⴻⵛⵜ. ⵜⴻⴽⵙⵉ ⵜⵡⴰⵡⵉⵜ ⵏⵏⴻⵙ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵉⴱⴰⵜⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R24_6","015_4_6","2CH","4","6","6","ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵄⴻⵛⵔⴰ ⵏ ⵜⴱⴰⵏⵢⵓⵜⵉⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵅⴻⵎⵙⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵅ ⵢⴻⴼⵓⵙ ⵓ ⵅⴻⵎⵙⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵅ ⵓⵣⴻⵍⵎⴰⴹ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⵔⴷⴻⵏ ⵉⵣⵉⵢⵏⴰⵜ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵙⵙⵉⵔⴷⴻⵏ ⵜⴻⵏⵜ ⴷⴰⵢⵙⴻⵏⵜ. ⵎⴰⵛⴰ ⵜⴰⵔⵉⵎⴰⵏⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵙⵙⵉⵔⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R24_7","015_4_7","2CH","4","7","7","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴻⵛⵔⴰ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵏ ⵡⵓⵔⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵅⴻⵎⵙⴰ ⵅ ⵢⴻⴼⵓⵙ ⵓ ⵅⴻⵎⵙⴰ ⵅ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("R24_8","015_4_8","2CH","4","8","8","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴻⵛⵔⴰ ⵏ ⵜⵣⴻⵡⴹⵉⵡⵉⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵅⴻⵎⵙⴰ ⵅ ⵢⴻⴼⵓⵙ ⵓ ⵅⴻⵎⵙⴰ ⵅ ⵓⵣⴻⵍⵎⴰⴹ. ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵎⵢⴰ ⵏ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R24_9","015_4_9","2CH","4","9","9","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⴻⵎⵔⴰⵃ ⵉⵃⵚⴰⵔⴻⵏ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵍⴻⵎⵔⴰⵃ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⵉ ⵍⴻⵎⵔⴰⵃ, ⵓⵛⴰ ⵉⵍⴻⵃⵃⴻⴼ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵙⴻⵏ ⵙ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R24_10","015_4_10","2CH","4","10","10","ⵜⴰⵔⵉⵎⴰⵏⵜ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ, ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("R24_11","015_4_11","2CH","4","11","11","ⵃⵉⵔⴰⵎ ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵜⵉⵢⴷⵓⵔⵉⵏ ⴷ ⵉⵖⴻⵏⵊⴰⵊⴻⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ. ⴰⵎⵎⵓ ⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵃⵓⵔⴰⵎ ⵛⵖⴻⵍ ⵉ ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⴳⴳⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R24_12","015_4_12","2CH","4","12","12","ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵉⵇⵓⵔⴰⵔⴻⵏ, ⴷ ⵜⵜⵉⵊⴰⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ, ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵔⴰⵛⵛⵉⵡⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴷⵍⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⵔⴰⵔⴻⵏ ⵏ ⵜⵜⵉⵊⴰⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R24_13","015_4_13","2CH","4","13","13","ⵓⵍⴰ ⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵔⴻⵎⵎⴰⵎⴻⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵔⴰⵛⵛⵉⵡⵉⵏ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵉ ⴽⵓⵍ ⵜⵔⴰⵛⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴷⵍⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⵔⴰⵔⴻⵏ ⵏ ⵜⵜⵉⵊⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵜⵉⵡⴰ ⵙⴻⵏⵏⴻⵊ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R24_14","015_4_14","2CH","4","14","14","ⵉⴳⴳⴰ ⵜⵉⴽⴰⵔⵔⵓⵜⵉⵏ ⵓ ⵅ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵉⴳⴳⴰ ⵜⵉⴱⴰⵏⵢⵓⵜⵉⵏ ⵉ ⵓⵙⵉⵔⴷ. ");
INSERT INTO rift_vpl VALUES ("R24_15","015_4_15","2CH","4","15","15","ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵜⴰⵔⵉⵎⴰⵏⵜ ⴷ ⵉⵛⵜⴻⵏ, ⵓⵍⴰ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R24_16","015_4_16","2CH","4","16","16","ⵉⴳⴳⴰ ⵃⵉⵔⴰⵎ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵙ ⵓⵍⴰ ⴷ ⵜⴻⵢⴷⵓⵔⵉⵏ ⴷ ⵉⵖⴻⵏⵊⴰⵊⴻⵏ ⴷ ⴼⵓⵔⵛⴰⵢⴰⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ, ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵏⵏⵃⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R24_17","015_4_17","2CH","4","17","17","ⴰⵊⴻⴵⵉⴷ ⵉⴽⴻⴱⴱ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴷⵉ ⵜⵍⴰⵅⵜ ⵉⴳⴷⴰⵔⴻⵏ ⵊⴰⵔ ⵙⵓⴽⴽⵓⵜ ⴷ ⵚⴰⵔⴰⴷⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("R24_18","015_4_18","2CH","4","18","18","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ ⵅ ⵓⴱⴰⵔⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴱⴻⵇⵇⵛⴻⵏ ⵛⴰ ⵄⴰⴷ ⴷⵉ ⵍⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R24_19","015_4_19","2CH","4","19","19","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ: ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⵓⵔⴻⵖ, ⵜⵉⵣⴻⵡⴹⵉⵡⵉⵏ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵎⵎⴰⵔⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("R24_20","015_4_20","2CH","4","20","20","ⵍⴻⵇⵏⴰⴷⴻⵍ ⴰⴽ-ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⴰⵔⵖⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ, ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R24_21","015_4_21","2CH","4","21","21","ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵏⵏⵓⵡⵡⴰⵔ, ⵍⴻⴼⵏⴰⵔⴰⵜ ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ ⵏ ⵜⴻⴼⵜⵉⵍⵜ, ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵡⵓⵔⴻⵖ. ⵜⵓⵖⴰ-ⵜ ⴷ ⵡⵓⵔⴻⵖ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R24_22","015_4_22","2CH","4","22","22","ⵓⵍⴰ ⴷ ⵜⵉⵊⴻⵇⵇⴰⴹⵉⵏ, ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ, ⵜⵉⵖⴻⵏⵊⴰⵢⵉⵏ ⴷ ⵜⵇⴻⴷⴷⵓⵃⵉⵏ ⵏ ⵊⵊⴰⵡⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵣⴻⴳ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ. ⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⴷⴰⵅⴻⵍ ⵣⵣⴰⵜ ⵉ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵣⴻⴳ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R25_1","015_5_1","2CH","5","1","1","ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵓⵛⴰ ⵉⵙⵙⵉⴷⴻⴼ ⵙⵓⵍⵉⵎⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ: ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R25_2","015_5_2","2CH","5","2","2","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵜⴻⵏⵏⵉ ⴷ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R25_3","015_5_3","2CH","5","3","3","ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵓⵏⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵍⵄⵉⴷ. ⵜⵓⵖⴰ-ⵜⵜ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R25_4","015_5_4","2CH","5","4","4","ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵙⵉⵏ-ⴷⴷ ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵜⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R25_5","015_5_5","2CH","5","5","5","ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵓⵇⵉⴹⵓⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ. ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R25_6","015_5_6","2CH","5","6","6","ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵎⵓⵏⴻⵏ, ⵜⵓⵖⴰ ⵜⴱⴻⴷⴷ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⴱⵓⵜ. ⵏⵉⵜⵏⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵇⴻⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R25_7","015_5_7","2CH","5","7","7","ⵉⵡⵢⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴷⴻⴳ ⵡⴻⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ, ⴰⵍ ⵙⴰⴷⵓ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R25_8","015_5_8","2CH","5","8","8","ⵉⴽⵉⵔⵓⴱⴻⵏ ⴱⴻⵣⵣⵄⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵜⴰⴱⵓⵜ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴷⵍⵉⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵜⵜⴰⴱⵓⵜ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⴻⴱⴱⵓⵜ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("R25_9","015_5_9","2CH","5","9","9","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵙⵙⵍⴻⵃⵎⴻⵏ ⵉⵄⵓⵎⴰⴷ ⵏ ⵜⴰⵔⴻⴱⴱⵓⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵏⴻⵏⵜ ⵜⴻⵅⴼⴰⵡⵉⵏ ⵏ ⵉⵄⵓⵎⴰⴷ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵜⴰⴱⵓⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴱⵉⵏⵉⵏⵜ ⵣⵉ ⴱⴰⵔⵔⴰ. ⵜⵜⴰⴱⵓⵜ ⴰⵇⴰ-ⵜⵜ ⴷⵉⵏ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R25_10","015_5_10","2CH","5","10","10","ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷⵉ ⵜⵜⴰⴱⵓⵜ, ⵎⵖⵉⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉⵙⵙⴰⵔⵙ ⵎⵓⵙⴰ ⵖⴰⵔ ⵀⵓⵔⵉⴱ, ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R25_11","015_5_11","2CH","5","11","11","ⴰⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ - ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴼⴻⵏ, ⵜⵓⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("R25_12","015_5_12","2CH","5","12","12","ⴰⵎ ⵜⵓⵖⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ - ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ: ⵉⵏⵏⵉ ⵖⴰⵔ ⴰⵙⴰⴼ ⴷ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵀⴰⵢⵎⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵢⴰⴷⵓⵜⵓⵏ, ⴷ ⵢⵉⵏⵏⵉ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ - ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏ ⵙ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵄⵍⴰⵃⴰⵍ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵉⵜⵜⵙⵓⴹⴻⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R25_13","015_5_13","2CH","5","13","13","ⵙⵓⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⵖⴰⵢⵟⴰ ⵓ ⵖⴻⵏⵏⵊⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵓ ⵜⵜⵇⴰⴷⴰⵏ ⵏⵉⵜⵏⵉ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵙ ⵍⴻⴱⵡⴰⵇ ⴷ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⴵⵖⴰ ⵏⵏⴻⵖⵏⵉ, ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵙⵉⴷⵉ: ‘ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ!’ ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⵓⵙⴻⵢⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("R25_14","015_5_14","2CH","5","14","14","ⵓⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R26_1","015_6_1","2CH","6","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ: “ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R26_2","015_6_2","2CH","6","2","2","ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵛⴻⴽ, ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⵣⴻⴷⵖⴻⴷ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("R26_3","015_6_3","2CH","6","3","3","ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵓⵊⴻⴵⵉⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("R26_4","015_6_4","2CH","6","4","4","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R26_5","015_6_5","2CH","6","5","5","‘ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵏⴻⴷⵀⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵉⵅⴹⴰⵔⴻⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⴱⵏⵉⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵓ ⵡⴰⵔ ⵉⵅⴹⴰⵔⴻⵖ ⴰⵔⵢⴰⵣ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R26_6","015_6_6","2CH","6","6","6","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵅⴷⴰⵔⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⵉⵅⴹⴰⵔⴻⵖ ⴷⴰⵡⵓⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("R26_7","015_6_7","2CH","6","7","7","ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R26_8","015_6_8","2CH","6","8","8","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ: ‘ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴱⵏⵉⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⵇⴰ ⵎⵍⵉⵃ ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R26_9","015_6_9","2CH","6","9","9","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ, ⵎⴰⵛⴰ ⵎⵎⵉⵛ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("R26_10","015_6_10","2CH","6","10","10","ⵙⵉⴷⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴱⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ ⵓ ⵇⵇⵉⵎⴻⵖ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⴱⵏⵉⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R26_11","015_6_11","2CH","6","11","11","ⵏⴻⵛⵛ ⵙⵙⴰⵔⵙⴻⵖ ⴷⵉⵏⵏⵉ ⵜⵜⴰⴱⵓⵜ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("R26_12","015_6_12","2CH","6","12","12","ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R26_13","015_6_13","2CH","6","13","13","ⵎⵉⵏⵣⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⴻⵏⵀⵉⵔⵜ ⵏ ⵏⵏⵃⴰⵙ ⵓ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵎⵔⴰⵃ. ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⵔⵓ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵜⵉⴷⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵅⴰⵙ, ⵉⴱⴻⵏⴷⴻⵇ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴽⵙⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R26_14","015_6_14","2CH","6","14","14","“ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵙⴻⵏⵏⴻⵊ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵍⵄⴰⵀⴷ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R26_15","015_6_15","2CH","6","15","15","ⵡⴻⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵅ ⵎⵉⵏ ⵅⴻⴼ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⵎⵉⵏⵣⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵓ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⵜ ⵜⴽⴻⵎⵎⵍⴻⴷ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R26_16","015_6_16","2CH","6","16","16","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⴹⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴱⴰⴱⴰ ⴷⴰⵡⵓⴷ, ⵅ ⵎⵉⵏ ⵅⴻⴼ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵣⴰⵢⴻⴽ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵛ ⵃⴻⵟⵟⴰⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵢⵓⵔⴻⴷ ⵛⴻⴽ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("R26_17","015_6_17","2CH","6","17","17","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴻⴳⴳ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⵉⴷⴻⵜⵜ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("R26_18","015_6_18","2CH","6","18","18","“ⵎⴰⵖⴰⵔ ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵉⵣⴷⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ? ⵅⵣⴰⵔ ⴰⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⴰⵊⴻⵏⵏⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵛⴻⴽ ⵉⴽⵙⵉ, ⵎⴻⵛⵃⴰⵍ ⵙ ⴷⵔⵓⵙ ⵅⴻⵏⵏⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⴻⵛⵛ! ");
INSERT INTO rift_vpl VALUES ("R26_19","015_6_19","2CH","6","19","19","ⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔ ⵓⵃⴻⵛⵛⴻⵎ ⵏⵏⴻⵙ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵓⵍⴰⵖⵉ ⵓ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏⵏⵉ ⵉⵥⵥⵓⴵ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R26_20","015_6_20","2CH","6","20","20","ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵔⵣⵎⴻⵏⵜ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵜⵉⵡⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⵜⵉⵡⴰ ⵉ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⴷⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵉ ⵉⵥⵥⵓⴵ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R26_21","015_6_21","2CH","6","21","21","ⵙⴻⵍ ⵉ ⵓⵃⴻⵛⵛⴻⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵜⵓⵜⵔⴰ ⵉ ⵜⵜⵥⴰⴵⴰⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⵙⴻⵍ ⵓ ⵖⴼⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("R26_22","015_6_22","2CH","6","22","22","“ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵉⵊⵊ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵊⵊⵓⴵ ⵓ ⵡⴰⵏⵉⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵛ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("R26_23","015_6_23","2CH","6","23","23","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⴽⴽⴰⵔ ⵓ ⵃⴽⴻⵎ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴰⵇⴻⴱ ⵓⵄⴻⴼⴼⴰⵏ, ⴻⵊⵊ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⴷ ⵉⵀⵡⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⴻⴳⴳ ⵙ ⵜⵙⴻⴳⴷⴰ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵓ ⴻⵡⵛ ⵉ-ⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("R26_24","015_6_24","2CH","6","24","24","“ⵎⴰⵍⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵉⵜⵜⵡⴰⵖⵍⴻⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵄⴷⵓ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⵏⴻⵄⵎⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴰⴷ ⵃⴻⵛⵛⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("R26_25","015_6_25","2CH","6","25","25","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵖⴼⴰⵔ ⴷⴷⴻⵏⴱ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⵉⴷ ⵓ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R26_26","015_6_26","2CH","6","26","26","“ⵎⴰⵍⴰ ⴰⵊⴻⵏⵏⴰ ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵡⴻⵏⵥⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴰⵎ ⴰⵔⵔⵉⵏ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⴰⴷ ⵏⴻⵄⵎⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵓⵎⵉ ⵜⴻⵏ ⵜⴻⵃⵚⴰⵔⴻⴷ ⵛⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("R26_27","015_6_27","2CH","6","27","27","ⵙⴻⵍ-ⴷⴷ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵖⴼⴰⵔ ⴰⵙⴻⵏ ⴷⴷⴻⵏⴱ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ ⴰⵙⴻⵏ ⴰⴱⵔⵉⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⴽⴻⵏ, ⵓ ⴻⵡⵛ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⴰⵏⵥⴰⵔ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("R26_28","015_6_28","2CH","6","28","28","“ⵎⴰⵍⴰ ⴷⵉⵏ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵉⵖ ⵟⵟⴰⵄⵓⵏ, ⵏⵉⵖ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵉⵎⴻⵏⴷⵉ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵏⵉⵖ ⵎⴰⵍⴰ ⴷⵉⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵡⴻⴼⵙⵓ ⵏⵉⵖ ⵜⴰⵎⵓⵖⵔⵉ ⵜⴻⵏⵏⵉ ⵉⵚⴰⵔⵔⴹⴻⵏ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵃⵚⴰⵔ ⵉ-ⵜ ⵍⴻⵄⴷⵓ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ ⵛⴰ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏⵉⵖ ⵛⴰ ⵏ ⵍⴻⵃⵍⴰⵛ, ");
INSERT INTO rift_vpl VALUES ("R26_29","015_6_29","2CH","6","29","29","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵎⴰ ⵉ ⵖⴰ ⵉⵥⵥⵓⴵ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵓ ⵎⵉⵏ ⵎⴰ ⵉ ⵖⴰ ⵉⵜⵜⴰⵔ, ⴰⵎ ⵙⵙⵏⴻⵏ ⵏⵉⵜⵏⵉ ⴽⵓⵍ ⵉⵊⵊ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏⵙⴻⵏ ⴷ ⵍⴻⵃⵔⵉⵇ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵅⴻⵏⵏⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R26_30","015_6_30","2CH","6","30","30","ⵡⴰⵀ ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ, ⵓ ⵖⴼⴰⵔ ⵓ ⴻⵡⵛ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵀⴰ ⵉ ⵉⵙⵙⵏⴻⵏ ⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("R26_31","015_6_31","2CH","6","31","31","ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ ⵓ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵖⴰ ⴽⴽⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("R26_32","015_6_32","2CH","6","32","32","“ⵓⵍⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵓⵖⵉⵍ ⵏⵏⴻⵛ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ, ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴰⵎ ⴰⵔⵔⵉⵏ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("R26_33","015_6_33","2CH","6","33","33","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ, ⵓ ⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵖⴰⵔⴻⴽ ⵉ ⵖⴰ ⵉⵍⴰⵖⴰ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵙⵙⵏⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ, ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ, ⵓ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵜⵉⵡⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⴱⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("R26_34","015_6_34","2CH","6","34","34","“ⵎⴰⵍⴰ ⵍⴳⴻⵏⵙ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⵉ ⵜⴻⵏ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⵉ ⵛⴻⴽ ⴰⵎ ⴰⵔⵔⵉⵏ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵛⴻⴽ, ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⴱⵏⵉⵖ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("R26_35","015_6_35","2CH","6","35","35","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵓ ⵉ ⵓⵃⴻⵛⵛⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵖ ⴰⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("R26_36","015_6_36","2CH","6","36","36","“ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⴻⴽ - ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉⵏ - ⵓ ⵛⴻⴽ ⵜⴻⵙⵄⴰⵔⴻⴷ ⵅⴰⵙⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵜⵙⴻⵍⵍⵎⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵄⴷⵓ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏ ⵏⴻⴷⵀⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵄⴷⵓ, ⵜⵉⴳⴳⵯⴻⵊ ⵏⵉⵖ ⵜⵓⴷⴻⵙ ⵉ ⵜⴻⴵⴰ, ");
INSERT INTO rift_vpl VALUES ("R26_37","015_6_37","2CH","6","37","37","ⵓ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵓⴱⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ, ⵡⴰⵀ, ⴰⴷ ⵜⵓⴱⴻⵏ ⵓ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵍⴰⵖⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵃⴻⴱⴱⴰⵙⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⵓ ⵏⴻⴳⴳⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵇⴰ ⵏⴻⴳⴳⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ!, ");
INSERT INTO rift_vpl VALUES ("R26_38","015_6_38","2CH","6","38","38","ⵡⴰⵀ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵥⵥⴰⴵⴻⵏ ⴰⵎ ⴰⵔⵔⵉⵏ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵛⴻⴽ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⴱⵏⵉⵖ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("R26_39","015_6_39","2CH","6","39","39","ⵙⴻⵍ ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ, ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵓ ⵉ ⵓⵃⴻⵛⵛⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵖ ⴰⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ. ⵖⴼⴰⵔ ⵅⴻⵏⵏⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵎⵉⵏ ⵣⵉ ⵅⴰⴽ ⵅⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("R26_40","015_6_40","2CH","6","40","40","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏⵜ ⴰⵔⵣⵎⴻⵏⵜ ⴷ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⵃⴹⴰⵏ ⵉ ⵜⵥⴰⴵⵉⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R26_41","015_6_41","2CH","6","41","41","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⴷⴻⴼ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵛ, ⵛⴻⴽ ⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ. ⴻⵊⵊ ⴰⴷ ⵉⵍⵉⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴹⴻⵏ ⵙ ⵓⵙⴻⵏⵊⴻⵎ, ⵓⵛⴰ ⵉⵍⵉ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵛ ⵙ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R26_42","015_6_42","2CH","6","42","42","ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⴰⵔⵔⵉ ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵛ, ⵉⴷⴰⵔ ⴷⵉ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴰⵡⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("R27_1","015_7_1","2CH","7","1","1","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵓⵍⵉⵎⴰⵏ ⵜⴰⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ, ⵜⴻⵀⵡⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵜⴻⵛⵛⴰ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓⵍⴰ ⴷ ⵜⵖⴰⵔⵚⴰ ⵉⵏⵏⴻⵖⵏⵉ, ⵓⵛⴰ ⵉⵛⵛⵓⵔ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R27_2","015_7_2","2CH","7","2","2","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R27_3","015_7_3","2CH","7","3","3","ⵓⵎⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴱⴻⵍⵍⵉ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ, ⵓⵍⴰ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⴱⴰⵏ-ⴷⴷ ⵜⵉⵡⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ, ⴱⴻⵏⴷⵇⴻⵏ, ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ: “ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ ⵓ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ”. ");
INSERT INTO rift_vpl VALUES ("R27_4","015_7_4","2CH","7","4","4","ⴰⵊⴻⴵⵉⴷ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ, ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R27_5","015_7_5","2CH","7","5","5","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵡⴻⵀⵀⴻⴱ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⴰⵍⴻⴼ ⵏ ⵡⵓⴵⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⵀⵏⴰ. ⴰⵎⵎⵓ ⵉ ⵉⴷⴻⵛⵛⴻⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R27_6","015_7_6","2CH","7","6","6","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⴷⴷⵓⵣⴰⵏ ⵏ ⴵⵖⴰ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ - ‘ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ!’ - ⵙ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵏ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵓ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵙⴻⵏ ⵙⵓⴹⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ, ⴰⵎ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R27_7","015_7_7","2CH","7","7","7","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵢⵉⵡⵉ ⴷⵉⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵖⴰⵔ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴽⵙⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R27_8","015_7_8","2CH","7","8","8","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵄⴻⵢⵢⴻⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵍⵄⵉⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵔ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ, ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ ⴰⵍ ⵜⴰⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R27_9","015_7_9","2CH","7","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⴰⴷⴻⵛⵛⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⵄⵉⴷ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵔ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R27_10","015_7_10","2CH","7","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵢⴰⵔⵅⵓ ⵏⴻⵜⵜⴰ ⵉ ⵍⴳⴻⵏⵙ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵙ ⵡⵓⵍ ⵉⴼⴰⵔⵃⴻⵏ ⵓ ⵙ ⵍⵅⴰⴹⴰⵔ ⵙ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⴰⵡⵓⴷ ⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵓ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R27_11","015_7_11","2CH","7","11","11","ⴰⵎⵎⵓ ⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵓⵍⵉⵎⴰⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⴳⴳ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⴼⵍⴻⵃ ⴰⴷ ⵉⴳⴳ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R27_12","015_7_12","2CH","7","12","12","ⵙⵉⴷⵉ ⵉⴱⴰⵏ-ⴷⴷ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵛ ⵓ ⴼⴰⵔⵣⴻⵖ ⴰⵎⵛⴰⵏ-ⴰ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("R27_13","015_7_13","2CH","7","13","13","ⵅⵎⵉ ⵖⴰ ⴱⴻⵍⵍⵄⴻⵖ ⴰⵊⴻⵏⵏⴰ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵛⵛⵉⵜ ⵡⴻⵏⵥⴰⵔ ⵄⴰⴷ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵓⵎⵓⵔⴻⵖ ⵜⴰⵎⵓⵖⵔⵉ ⵉⵍⴻⵃⵃⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵛⵛ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⵅⵎⵉ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵟⵟⴰⵄⵓⵏ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("R27_14","015_7_14","2CH","7","14","14","ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵉⵏⵓ ⴰⴷ ⵉⵙⵙⴻⵀⵡⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵥⵥⴰⴵ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵣⵓⵏ ⵓⴷⴻⵎ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⵓⴱⴻⵏ ⵣⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵙⴻⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵙⵍⴻⵖ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⴰⵙⴻⵏ ⵖⴼⴰⵔⴻⵖ ⵓ ⴰⴷ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R27_15","015_7_15","2CH","7","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⴷ ⵉⵍⵉⵏⵜ ⴰⵔⵣⵎⴻⵏⵜ ⴷ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵜⵥⴰⴵⵉⵜ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("R27_16","015_7_16","2CH","7","16","16","ⵎⴰⵖⴰⵔ ⵍⴻⵅⵅⵓ ⵉⵅⴹⴰⵔⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵜⵜ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⴷⵉⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴷ ⵡⵓⵍ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R27_17","015_7_17","2CH","7","17","17","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ, ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("R27_18","015_7_18","2CH","7","18","18","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⵄⴰⵀⴷ ⵉ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ, ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("R27_19","015_7_19","2CH","7","19","19","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵣⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⵏⵏⵉ ⵡⵛⵉⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⴷ ⵜⵄⴻⴱⴷⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵏⴷⵇⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("R27_20","015_7_20","2CH","7","20","20","ⵅⴻⵏⵏⵉ ⴰⴷ ⵇⴹⵉⵖ ⵅ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ, ⵓⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⵉ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵜⵜ ⵏⴹⴰⵔⴻⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵓ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵓⵎⴻⴷⵢⴰ ⵓⵍⴰ ⴷ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⴱⴻⵀⴷⴻⵍ ⵉⵜⵜⴻⵇⵇⵙⴻⵏ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R27_21","015_7_21","2CH","7","21","21","ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵜⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⴽⴽⴻⵏ, ⴰⴷ ⵉⵜⴻⴱⵀⴻⵜ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴰⵎⵎⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ?’ ");
INSERT INTO rift_vpl VALUES ("R27_22","015_7_22","2CH","7","22","22","ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵢⵓⵔ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵊⴻⴷ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵄⴱⴻⴷ, ⵅ ⵓⵢⴰ ⵉⵙⵙⴻⵖⴹⴻⵍ ⵏⴻⵜⵜⴰ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ-ⴰ ⵅⴰⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("R28_1","015_8_1","2CH","8","1","1","ⴰⵡⴰⵔⵏⵉ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⵉ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("R28_2","015_8_2","2CH","8","2","2","ⴰⵇⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵃⵉⵔⴰⵎ ⵓⵛⴰ ⵉⵙⵙⴻⵣⴷⴻⵖ ⴷⵉⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R28_3","015_8_3","2CH","8","3","3","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴼⴼⴻⵖ ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔ ⵃⴰⵎⴰⵜ-ⵚⵓⴱⴰ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("R28_4","015_8_4","2CH","8","4","4","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⴰⴷⵎⵓⵔ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵉⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ ⴷⵉ ⵃⴰⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R28_5","015_8_5","2CH","8","5","5","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵓⵍⴰ ⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵏⵏⴻⵊ ⴷ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ ⵏ ⵡⴰⴷⴷⴰⵢ, ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵙ ⵍⴻⵃⵢⵓⴹ ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵓⴱⴻⵍⵍⴻⵄ, ");
INSERT INTO rift_vpl VALUES ("R28_6","015_8_6","2CH","8","6","6","ⵓⵍⴰ ⴷ ⴱⴰⵄⵍⴰⵜ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ, ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⵓ ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⵙⵉⵜⴻⵎ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴷ ⵜⵜ ⵉⴱⵏⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴷⵉ ⵍⵓⴱⵏⴰⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵃⴽⴰⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R28_7","015_8_7","2CH","8","7","7","ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ - ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵏ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ, ⵏ ⵉⵃⵉⵡⵉⵢⵢⴻⵏ ⵓ ⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("R28_8","015_8_8","2CH","8","8","8","ⵓ ⵅ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵇⴹⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ - ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷⴷⵇⵓⵍⴰⵜ ⵇⴻⵙⵃⴻⵏⵜ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R28_9","015_8_9","2CH","8","9","9","ⵎⴰⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⴳⴳⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵉⵏⴻⵖⵔⴰⴼⴻⵏ ⵏⵏⴻⵙ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ, ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R28_10","015_8_10","2CH","8","10","10","ⵉⵏⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴹⴻⴱⴱⴰⵔⴻⵏ ⵅ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R28_11","015_8_11","2CH","8","11","11","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⴱⵏⴰ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ ⵡⴰⵔ ⵜⵣⴻⴷⴷⵉⵖ ⵛⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵜⵜⴰⴱⵓⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R28_12","015_8_12","2CH","8","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⵏⴰ ⵣⵣⴰⵜ ⵉ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("R28_13","015_8_13","2CH","8","13","13","ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⴽⵓⵍ ⴰⵙⵙ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵎⵓⵙⴰ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ, ⵉ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵓ ⵉ ⵜⵍⴰⵜⴰ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ: ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵓ ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R28_14","015_8_14","2CH","8","14","14","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⵓⵙⴰ ⵍⴼⴰⵔⵉⴹⴰ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵄⴰⵡⴻⴷ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ, ⴷ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⴽⵓⵍ ⴰⵙⵙ, ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵍⴰ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴽⵓⵍ ⵜⴰⵡⵡⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵍⵓⵎⵓⵔ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R28_15","015_8_15","2CH","8","15","15","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵏ ⵛⴰ ⵍⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵊⵊⵉⵀⴻⵜ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R28_16","015_8_16","2CH","8","16","16","ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵇⴼⴻⵍ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵙⴰⵔⵙⵉ ⵏ ⴷⵙⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⵍ ⴰⴽⴻⵎⵎⴻⵍ ⵏⵏⴻⵙ, ⵡⴰⵀ ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R28_17","015_8_17","2CH","8","17","17","ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⵉⵔ ⵓ ⵖⴰⵔ ⴰⵢⵍⴰⵜ, ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R28_18","015_8_18","2CH","8","18","18","ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵙⵙⴻⴽⴽ ⵃⵉⵔⴰⵎ ⵖⴰⵔⴻⵙ ⵉⵖⴰⵔⵔⵓⴱⴰ, ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵍⴻⴱⵃⴰⵔ, ⵓ ⵏⴻⴷⵀⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵖⴰⵔ ⵓⴼⵉⵔ ⵓⵛⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ ⵅⴻⵎⵙⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_1","015_9_1","2CH","9","1","1","ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵜⴻⵙⵍⴰ ⵅ ⵛⵛⴻⵏⵏⵄⴻⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵇⴻⴵⴻⴱ ⵙⵓⵍⵉⵎⴰⵏ ⵙ ⵜⵃⵓⵊⴰ ⵏ ⵜⵡⴰⴼⵉⵜ, ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⴰ$ⴰⵏ ⵙ ⴷⴷⵇⴻⵍ ⵏ ⵡⴰⴳⵍⴰ ⴰⵟⵟⴰⵙ, ⵙ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵄⵟⵓⵔ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵛⴰ ⵜⴻⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("R29_2","015_9_2","2CH","9","2","2","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵛⴰⵔⵃ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵙ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵜ ⵉⵛⴰⵔⵔⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("R29_3","015_9_3","2CH","9","3","3","ⵍⴰⵎⵉ ⵜⴻⵥⵔⴰ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵜⵉⵖⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵉⴱⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("R29_4","015_9_4","2CH","9","4","4","ⴷ ⵎⴰⵛⵛⴰ ⵅ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵙ, ⴷ ⵎⴰⵎⵎⴻⵛ ⵇⵇⵉⵎⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴷ ⵎⴰⵎⵎⴻⵛ ⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵏⵏⴻⵙ, ⴷ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⴷ ⵉⵡⴰⵔⵔⴰⴷⴻⵏ ⵏⵏⴻⵙ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴻⵄⵄⴻⴷ ⴰⵎ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⴷⴰⵢⴻⵙ ⵄⵍⴰⵃⴰⵍ ⴱⵓⵃⴱⴻⵍ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R29_5","015_9_5","2CH","9","5","5","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴰⵡⴰⵍ ⵏⵏⵉ ⵙⵍⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ, ⵏⵉⵛⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("R29_6","015_9_6","2CH","9","6","6","ⵏⴻⵛⵛ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵖ ⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ ⴷⴰⵏⵉⵜⴰ ⵓ ⵅⴻⵏⵏⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵥⵔⵉⵏⵜ ⴰⵢⴰ. ⵅⵣⴰⵔ, ⴰⵣⵢⴻⵏ ⵏ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ. ⴰⵇⴰ ⵛⴻⴽ ⵙⴻⵏⵏⴻⵊ ⵅ ⵍⴻⵅⴱⴰⵔ ⵉ ⵅⴰⴽ ⵙⵍⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("R29_7","015_9_7","2CH","9","7","7","ⵙⵙⴻⵄⴷ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵛ, ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵍⴻⴱⴷⴰ ⵓ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵖⴰⵔ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("R29_8","015_9_8","2CH","9","8","8","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵢⴻⴳⴳ ⴷ ⴰⵊⴻⴵⵉⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ. ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴻⵅⵙ ⴰⵟⵟⴰⵙ ⴰⴷ ⵢⴻⵊⵊ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ, ⵙ ⵓⵢⴰ ⵉⴳⴳⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("R29_9","015_9_9","2CH","9","9","9","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵣⴻⵔ ⴷ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ. ⵍⴻⴱⵣⴻⵔ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵉ ⵜⴻⵡⵛⴰ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R29_10","015_9_10","2CH","9","10","10","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵃⵉⵔⴰⵎ ⵉ ⴷⴷ ⵉⵡⵢⴻⵏ ⵓⵔⴻⵖ ⵣⴻⴳ ⵓⴼⵉⵔ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵡⵢⴻⵏ ⵄⴰⵡⴻⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵚⴰⵏⴷⴰⵍ ⴰⵣⴻⴳⴳⵯⴰⵖ ⴷ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_11","015_9_11","2CH","9","11","11","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵚⴰⵏⴷⴻⵍ ⴰⵣⴻⴳⴳⵯⴰⵖ ⴷⴷⵔⵓⵊⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵍⴰ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⵀⴰⵔⴱⴰⵜ ⵉ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ. ⴰⵎ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵜ ⵥⵔⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵇⴱⴻⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R29_12","015_9_12","2CH","9","12","12","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵡⵛⴰ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵛⴰⴱⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴷ ⵎⴻⵥⵔⵉ, ⵎⵉⵏ ⵎⴰ ⵜᵉⵜⵜⴰⵔ, ⵡⴰⵀ, ⴽⵜⴰⵔ ⵣⵉ ⵎⵉⵏ ⴷⴷ ⵜⵜⵉⵡⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴻⵇⵍⴻⴱ ⵓ ⵜⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R29_13","015_9_13","2CH","9","13","13","ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵙⵓⵍⵉⵎⴰⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵜⵓⵖⴰ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("R29_14","015_9_14","2CH","9","14","14","ⵏⵀⵍⴰ ⴰⵔⴱⴻⵃ ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⵙⴻⵡⵡⵇⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵣⵉ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ, ⵓ ⵏⵀⵍⴰ ⴰⵔⴱⴻⵃ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵣⴻⴳ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵄⴰⵔⴰⴱⵉⵢⵢⴰ ⵓ ⵣⵉ ⵍⵡⵓⵍⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R29_15","015_9_15","2CH","9","15","15","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵙ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⴷⴷⵣⴻⵏ. ⵅ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R29_16","015_9_16","2CH","9","16","16","ⵢⴰⵔⵏⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵙ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⴷⴷⵣⴻⵏ. ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵛⵛⵉⵇⵍⵓ ⵏ ⵡⵓⵔⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵜ. ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_17","015_9_17","2CH","9","17","17","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵄⴰⵊ ⵓⵛⴰ ⵉⵖⴻⵍⴼ ⵉ-ⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_18","015_9_18","2CH","9","18","18","ⵍⵄⴰⵔⵛ ⵡⴰⵏⵉⵜⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵜⴰⵔⴻⴼⴼⵉⴷⵉⵏ ⵓ ⵜᵉⵜⵜⵡⴰⵛⴻⴷⴷ ⵉⵛⵜ ⵏ ⵜⵏⴻⴷⴷⴰⴱⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵢⵉⴹⴰⵔⴻⵏ ⵉ ⵍⵄⴰⵔⵛ. ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⴽⵓⵔⵙⵉ ⵜⵓⵖⴰ ⴵⴰⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵄⴰⵔⵛ. ");
INSERT INTO rift_vpl VALUES ("R29_19","015_9_19","2CH","9","19","19","ⵜⴻⵏⵄⴰⵛ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵅ ⵙⴻⵜⵜⴰ ⵏ ⵜⴰⵔⴻⴼⴼⵉⴷⵉⵏ. ⴰⵎ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵄⴰⴷ ⵓⵍⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R29_20","015_9_20","2CH","9","20","20","ⵎⴰⵔⵔⴰ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵜⵉⵙⵙⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⵉⵣⴻⴷⴳⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴰⵢⴻⵙ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵃⴻⵙⵙⴱⴻⵏ ⵜⵜ ⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("R29_21","015_9_21","2CH","9","21","21","ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⵉ ⵉⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵃⵉⵔⴰⵎ. ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵣⵉ ⵜⴰⵔⵛⵉⵛ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ, ⵍⵄⴰⵊ ⴷ ⵉⴱⴰⵖⵓⵙⴻⵏ ⴷ ⵉⵟⴰⵡⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_22","015_9_22","2CH","9","22","22","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵄⴷⵓ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷⴻⴳ ⵡⴰⴳⵍⴰ ⴷ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R29_23","015_9_23","2CH","9","23","23","ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵔⵣⵓⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⴻⵎ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R29_24","015_9_24","2CH","9","24","24","ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⴰⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵜⴰⵔⵣⴻⴼⵜ ⵏⵏⴻⵙ, ⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ, ⴰⵔⵔⵓⴹ, ⵍⴻⵙⵏⴰⵃ, ⵍⴻⵄⵟⵓⵔ, ⵉⵢⵙⴰⵏ ⴷ ⵉⵙⴰⵔⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_25","015_9_25","2CH","9","25","25","ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵍⴽⵓⵔⵉⵜ ⵉ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵉ ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ. ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R29_26","015_9_26","2CH","9","26","26","ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⵍⴼⵓⵔⴰⵟ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R29_27","015_9_27","2CH","9","27","27","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎ ⵢⴻⵥⵔⴰ ⵓ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴰⵎ ⵢⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R29_28","015_9_28","2CH","9","28","28","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵢⵙⴰⵏ ⵉ ⵙⵓⵍⵉⵎⴰⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R29_29","015_9_29","2CH","9","29","29","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ ⵓ ⴷⵉ ⵏⵏⵓⴱⵓⵡⴰ ⵏ ⴰⵅⵉⵢⴰ ⴰⵅⵉⵍⵓⵏⵉ ⵓ ⴷⴻⴳ ⵉⵡⴻⵃⵃⴰⵏ ⵏ ⵓⵎⵡⴰⵍⴰⵡ ⵢⴰⵄⴷⵓ ⵅ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ? ");
INSERT INTO rift_vpl VALUES ("R29_30","015_9_30","2CH","9","30","30","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵃⴽⴻⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R29_31","015_9_31","2CH","9","31","31","ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R210_1","015_10_1","2CH","10","1","1","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R210_2","015_10_2","2CH","10","2","2","ⵓⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⵉ ⵎⵉⵚⵔⴰ - ⵣⴻⵄⵎⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⵡⴻⵍ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ - ⵉⵎⵙⴰⵔ ⴰⵙ ⴰⵇⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("R210_3","015_10_3","2CH","10","3","3","ⵙⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵊⵊⵉⵏ ⴰⴷ ⵅⴰⵙ ⵍⴰⵖⴰⵏ. ⵢⵓⵙⴰ-ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵙⵉⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴽ-ⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("R210_4","015_10_4","2CH","10","4","4","“ⴱⴰⴱⴰⵛ ⵉⴳⴳⴰ ⵅⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵉⵇⵙⴻⵃ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴰⵔⵅⵓ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵇⴻⵙⵃⴻⵏ ⵏ ⴱⴰⴱⴰⵛ ⵓⵍⴰ ⴷ ⴰⵣⴰⵢⵍⵓ ⵉⴷⴻⵇⵍⴻⵏ ⵉ ⵅⴰⵏⴻⵖ ⵉⴳⴳⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵏⴻⵅⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R210_5","015_10_5","2CH","10","5","5","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵢⵓⵔⴻⵎ ⵓ ⵄⴻⵇⴱⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ.” ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R210_6","015_10_6","2CH","10","6","6","ⵉⵎⵛⴰⵡⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⴱⴰⵙ ⵙⵓⵍⵉⵎⴰⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⴷⴷⴰⵔ, ⵉⵏⵏⴰ: “ⵙ ⵎⵉⵏⵣⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⵡⴻⵚⵚⴰⵎ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵅ ⵍⴳⴻⵏⵙ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("R210_7","015_10_7","2CH","10","7","7","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵙ ⵜⵛⵓⵏⵉ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ-ⴰ, ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵍⵅⴰⴹⴰⵔ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵛⵏⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("R210_8","015_10_8","2CH","10","8","8","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴹⴰⵔ ⵛⵛⵡⴰⵔ ⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⵡⵛⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵓⵛⴰ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⴱⴻⴷⴷⴻⵏ ⵍⴻⵅⵅⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R210_9","015_10_9","2CH","10","9","9","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵉ-ⵜⴻⵏ: “ⵙ ⵎⵉⵏⵣⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⵡⴻⵚⵚⴰⵎ ⴰⴷ ⵏⴰⵔⵔ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⵙⵙⵡⵉⵍⴻⵏ ⴰⴽⵉⴷⵉ, ⵏⵏⴰⵏ: ‘ⵙⴰⵔⵅⵓ ⴰⵣⴰⵢⵍⵓ ⵉ ⵅⴰⵏⴻⵖ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵛ.’” ");
INSERT INTO rift_vpl VALUES ("R210_10","015_10_10","2CH","10","10","10","ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵎⵖⴰⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵔⴻⴷ ⵅ ⵍⴳⴻⵏⵙ ⵉ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵓ ⵏⵏⴰⵏ: ‘ⴱⴰⴱⴰⵛ ⵉⵙⵙⴻⴷⵇⴻⵍ ⴰⵣⴰⵢⵍⵓ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵛⴻⴽ ⵙⴰⵔⵅⵓ ⵜ ⵅⴰⵏⴻⵖ!’, ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⴽⵉⴷⵙⴻⵏ ⵉ ⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ: ‘ⴰⴹⴰⴹ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵏⵓ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("R210_11","015_10_11","2CH","10","11","11","ⵎⴰⵍⴰ ⴱⴰⴱⴰ ⵉⵇⵇⴻⵏ ⴰⵡⴻⵎ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵉⵇⵙⴻⵃ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⴷⴻⵇⵍⴻⵖ ⵄⴰⴷ. ⵎⴰⵍⴰ ⴱⴰⴱⴰ ⵢⴰⵔⴻⴱⴱⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⴱⵉⵖ ⵙ ⵉⵖⴰⵔⴹⵎⵉⵡⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("R210_12","015_10_12","2CH","10","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ, ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵄⴻⵇⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("R210_13","015_10_13","2CH","10","13","13","ⴰⵊⴻⴵⵉⴷ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵍⴳⴻⵏⵙ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⵇⴻⵙⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵙⵎⴻⵃ ⴷⵉ ⵛⵛⵡⴰⵔ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R210_14","015_10_14","2CH","10","14","14","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⵡⴰⵔ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴷⴻⵇⵍⴻⵖ ⵄⴰⴷ ⴰⵣⴰⵢⵍⵓ ⵏⵡⴻⵎ. ⴱⴰⴱⴰ ⵢⴰⵔⴻⴱⴱⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴱⴱⵉⵖ ⵙ ⵉⵖⴰⵔⴹⵎⵉⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R210_15","015_10_15","2CH","10","15","15","ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⵙⵍⵉ ⵛⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ, ⵎⴰⵖⴰⵔ ⴰⵏⴻⵇⵍⴻⴱ-ⴰ ⵜⵓⵖⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵙⵉⴷⵉ ⴰⵡⴰⵍ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴰⵅⵉⵢⴰ, ⴰⵛⵉⵍⵓⵏⵉ, ⴰⴽ-ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("R210_16","015_10_16","2CH","10","16","16","ⵓⵎⵉ ⵉⵥⵔⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵙⵍⵉ ⵛⴰ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵖⴰⵔⵏⴻⵖ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ? ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ. ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ, ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵡⴻⵎ, ⴰ ⵉⵙⵔⴰⵉⵍ! ⵍⵀⴰ ⵍⴻⵅⵅⵓ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴷⴰⵡⵓⴷ!” ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R210_17","015_10_17","2CH","10","17","17","ⵜⵓⵖⴰ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R210_18","015_10_18","2CH","10","18","18","ⴰⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⵙⴻⵏ ⴰⴷⵓⵔⴰⵎ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵍⵊⵉⵣⵢⴰ, ⵓ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⵊⵎⴻⵏ ⵜ ⵙ ⵢⴻⵥⵔⴰ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ⴰⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵏⵢⴰ ⴷⴻⵖⵢⴰ ⵅ ⵓⴽⴰⵔⵔⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R210_19","015_10_19","2CH","10","19","19","ⴰⵎⵎⵓ ⵉ ⵉⵖⴻⵡⵡⴻⵖ ⵉⵙⵔⴰⵉⵍ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R211_1","015_11_1","2CH","11","1","1","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵜⵜⵡⴰⴷⴰⵔⵔⴱⴻⵏ ⵅ ⵓⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵖⴰⵔ ⵔⴰⵃⵓⴱⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R211_2","015_11_2","2CH","11","2","2","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵛⴰⵎⵄⵉⵢⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R211_3","015_11_3","2CH","11","3","3","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓⵛⴰ ⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("R211_4","015_11_4","2CH","11","4","4","‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵎ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⵉⵎ ⵛⴰ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵄⵇⴻⴱ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⵎⵙⴰⵔⴻⵏ ⵣⵉ ⵖⴰⵔⵉ.’” ⵏⵉⵜⵏⵉ ⵙⵍⴰⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ, ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⵛⴰ ⵖⴰⵔ ⵢⴰⵔⵓⴱⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R211_5","015_11_5","2CH","11","5","5","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵣⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴼⴰⵔⵢⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R211_6","015_11_6","2CH","11","6","6","ⵉⴱⵏⴰ ⴱⴰⵢⵜ-ⵍⴰⵃⴰⵎ, ⵄⵉⵟⴰⵎ, ⵜⴰⵇⵓⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("R211_7","015_11_7","2CH","11","7","7","ⴱⴰⵢⵜ-ⵚⵓⵔ, ⵙⵓⴽⵓ, ⵄⴰⴷⵓⵍⵍⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("R211_8","015_11_8","2CH","11","8","8","ⵊⴰⵜ, ⵎⴰⵔⵉⵛⴰ, ⵣⵉⴼ, ");
INSERT INTO rift_vpl VALUES ("R211_9","015_11_9","2CH","11","9","9","ⴰⴷⵓⵔⴰⵢⵉⵎ, ⵍⴰⵅⵉⵙ, ⵄⴰⵣⵉⵇⴰ, ");
INSERT INTO rift_vpl VALUES ("R211_10","015_11_10","2CH","11","10","10","ⵚⵓⵔⵄⴰ, ⴰⵢⵢⴰⵍⵓⵏ ⴷ ⵃⴰⴱⵔⵓⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⴰⵇⴰ-ⵜⴻⵏⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R211_11","015_11_11","2CH","11","11","11","ⵉⵙⵙⴻⵊⵀⴻⴷ ⵍⵇⴻⵍⵄⴰⵜ ⵓ ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⵉⵅⵣⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ ⵎⴰⵛⵛⴰ, ⵣⵣⴻⵛⵜ ⴷ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("R211_12","015_11_12","2CH","11","12","12","ⵉⵙⵙⴰⵔⵙ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵉⵃⵔⵉⵛⴻⵏ ⴷⵉ ⴽⵓⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉ-ⵜⴻⵏⵜ ⴰⵍ ⵟⵟⴰⵔⴼ. ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R211_13","015_11_13","2CH","11","13","13","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵇⵇⵏⴻⵏ ⵖⴰⵔⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R211_14","015_11_14","2CH","11","14","14","ⵎⵉⵏⵣⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵊⵊⵉⵏ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏ ⴷ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⵣⵉ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R211_15","015_11_15","2CH","11","15","15","ⵅⴻⵏⵏⵉ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵍⴻⴳⵄⵓⴷⵉ, ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⵓⵢⴰⵏ ⵉⵊⴻⵏⵏⴻⵏ ⵓ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("R211_16","015_11_16","2CH","11","16","16","ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵡⵓⵍ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R211_17","015_11_17","2CH","11","17","17","ⴰⵎⵎⵓ ⵙⵙⵊⴻⵀⴷⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵙⵙⵎⴻⵜⵏⴻⵏ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R211_18","015_11_18","2CH","11","18","18","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵢⵉⵡⵉ ⵎⴰⵃⵍⴰⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵔⵉⵎⵓⵜ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵓⵍⴰ ⴷ ⴰⴱⵉⵃⴰⵢⵉⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵍⵉⵢⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R211_19","015_11_19","2CH","11","19","19","ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ-ⴰ: ⵢⴰⵄⵓⵛ, ⵛⴰⵎⴰⵔⵢⴰ ⴷ ⵣⴰⵀⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R211_20","015_11_20","2CH","11","20","20","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⵉⵡⵉ ⵎⴰⵄⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⴱⵛⴰⵍⵓⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⴰⴱⵉⵢⴰ, ⵄⴰⵜⵜⴰⵢ, ⵣⵉⵣⴰ ⴷ ⵛⴰⵍⵓⵎⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R211_21","015_11_21","2CH","11","21","21","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵎⴰⵄⴽⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴰⴱⵛⴰⵍⵓⵎ, ⴰⵟⵟⴰⵙ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉⵜ ⴷ ⵅ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵢⵉⵡⵉ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵉⵢⵢⴰ. ⵏⴻⵜⵜⴰ ⵢⴻⵊⵊ-ⴷⴷ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("R211_22","015_11_22","2CH","11","22","22","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⴳⴳⴰ ⴰⴱⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴽⴰ, ⴷ ⴰⵣⴻⴵⵉⴼ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⴷ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R211_23","015_11_23","2CH","11","23","23","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⴳⴳⴰ ⵙ ⵍⴻⵄⵇⴻⵍ ⵓⵛⴰ ⵉⴱⴹⴰ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵎⴰⵛⵛⴰ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓ ⵢⴰⵔⵣⵓ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R212_1","015_12_1","2CH","12","1","1","ⵓⵎⵉ ⵜⵓⵖⴰ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵜⵓⵖⴰ ⵉⵊⵀⴻⴷ, ⵉⵡⴹⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R212_2","015_12_2","2CH","12","2","2","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵉⵎⵙⴰⵔ - ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵖⴻⵡⵡⵖⴻⵏ ⵅ ⵙⵉⴷⵉ - ⴰⵇⴰ ⵛⵉⵛⴰⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵓⵔⵛⴰⵍⵉⵎ ");
INSERT INTO rift_vpl VALUES ("R212_3","015_12_3","2CH","12","3","3","ⵙ ⵎⵉⵜⴰⵢⴻⵏ-ⴰⵍⴻⴼ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵛⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽⵉⴷⴻⵙ ⵣⵉ ⵎⵉⵚⵔⴰ: ⵉⵍⵉⴱⵉⵢⵢⴻⵏ, ⵉⵙⵓⴽⴽⵉⵢⵢⴻⵏ ⴷ ⵉⴽⵓⵛⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R212_4","015_12_4","2CH","12","4","4","ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R212_5","015_12_5","2CH","12","5","5","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵏⴰⴱⵉ ⵛⴰⵎⵄⵉⵢⴰ ⵖⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵓ ⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵎⵓⵏⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵛⵉⵛⴰⴽ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅⴰⴼⵉ, ⵅ ⵓⵢⴰ ⵃⴻⵢⵢⴷⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵅⴰⵡⴻⵎ, ⵊⵊⵉⵖ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵛⵉⵛⴰⴽ.’” ");
INSERT INTO rift_vpl VALUES ("R212_6","015_12_6","2CH","12","6","6","ⵅⴻⵏⵏⵉ ⵙⵙⴻⵀⵡⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵓⵊⴻⴵⵉⴷ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵙⵉⴷⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("R212_7","015_12_7","2CH","12","7","7","ⵓⵎⵉ ⵉⵥⵔⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵀⵡⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵛⴰⵎⵄⵉⵢⴰ, ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵙⵙⴻⵀⵡⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⴷⴻⵖⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵛⵉⵛⴰⴽ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⵉⴵⵉⵄ ⵛⴰ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("R212_8","015_12_8","2CH","12","8","8","ⵎⴰⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵏⴻⵛⵛ ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("R212_9","015_12_9","2CH","12","9","9","ⵓⵛⴰ ⵛⵉⵛⴰⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵢⵉⵡⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⴽⵉⵙ ⵎⴰⵔⵔⴰ, ⵓⵍⴰ ⴷ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R212_10","015_12_10","2CH","12","10","10","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏⵜ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵏ ⵏⵏⵃⴰⵙ. ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⵙⵙⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R212_11","015_12_11","2CH","12","11","11","ⵎⴻⵍⵎⵉ ⵎⴰ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ, ⴰⵔⴻⴱⴱⵓⵏ ⵜⴻⵏⵜ ⵓ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("R212_12","015_12_12","2CH","12","12","12","ⵓⵎⵉ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵍⴰⵃⴰⴱⵄⴰⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵊⵊⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅⴰⵙ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜ ⵉⴹⴻⵢⵢⴻⵄ ⵎⴰⵔⵔⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⴷ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵚⴻⴱⵃⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R212_13","015_12_13","2CH","12","13","13","ⴰⵊⴻⴵⵉⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵃⴻⴽⴽⴻⵎ. ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵉⵅⴹⴰⵔ ⵙⵉⴷⵉ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⵉⵄⵎⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵄⴰⵎⵎⵓⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R212_14","015_12_14","2CH","12","14","14","ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R212_15","015_12_15","2CH","12","15","15","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵓⵍⴰ ⴷ ⵉⵎⴻⵏⵖⴰⵏ ⵊⴰⵔ ⵔⴰⵃⴰⴱⵄⴰⵎ ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ, ⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵛⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⵓⵎⵡⴰⵍⴰⵡ ⵄⵉⴷⴷⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵉⵙⵜⴰⵜ ⵏ ⵊⵊⴰⴷⵉⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("R212_16","015_12_16","2CH","12","16","16","ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⴰⴱⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R213_1","015_13_1","2CH","13","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⵉⴷⵡⴻⵍ ⴰⴱⵉⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R213_2","015_13_2","2CH","13","2","2","ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵉⵢⵉⵍ ⵣⵉ ⵊⵉⴱⵄⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵓⵎⴻⵏⵖⵉ ⵊⴰⵔ ⴰⴱⵉⵢⴰ ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R213_3","015_13_3","2CH","13","3","3","ⴰⴱⵉⵢⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⴰⵎⴻⵏⵖⵉ ⵙ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵓⵛⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⴳⴳⴰ ⴰⵙⴻⴷⴷⵉ ⵙ ⵜⴻⵎⵏ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R213_4","015_13_4","2CH","13","4","4","ⵉⴱⴻⴷⴷ ⴰⴱⵉⵢⴰ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⴰⵎⴰⵔⴰⵢⵉⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ ⵖⴰⵔⵉ, ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("R213_5","015_13_5","2CH","13","5","5","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵡⵛⴰ ⵜⴰⴳⴻⵍⴷⴰ ⵅ ⵉⵙⵔⴰⵉⵍ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵜⵎⴻⴵⴰⵃⵜ ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("R213_6","015_13_6","2CH","13","6","6","ⵎⴰⵛⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⴰⴱⴰⵟ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R213_7","015_13_7","2CH","13","7","7","ⵉⵔⵢⴰⵣⴻⵏ ⵉⵅⵡⴰⵏ, ⴰⵢⵜ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵙⵙⵊⴻⵀⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵓⵎⵉ ⵔⴰⵃⴰⴱⵄⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⴰⵃⵏⵉⵏ ⵏ ⵡⵓⵍ ⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵎⵇⵓⴷⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R213_8","015_13_8","2CH","13","8","8","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⵊⴻⵀⴷⴻⵎ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ⵡⴰⵅⵅⴰ, ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵜⴻⴵⴰⵎ, ⵎⴰⵛⴰ ⵖⴰⵔⵡⴻⵎ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⴳⴳⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("R213_9","015_13_9","2CH","13","9","9","ⵎⴰ ⵡⴰⵔ ⵜⴻⵏⴹⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ ⴷ ⵡⴰⵔⵔⴰⵡ ⵏ ⵍⴰⵡⵉ, ⵓ ⵜⴻⴳⴳⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ? ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⵓ ⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴷ ⴰⴽⴻⵀⵀⴰⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R213_10","015_13_10","2CH","13","10","10","ⵎⴰⵛⴰ ⵅⴰⵏⴻⵖ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵅⴰⵙ ⵏⵃⴻⵢⵢⴻⴷ ⵛⴰ, ⵓ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵓ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R213_11","015_13_11","2CH","13","11","11","ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⴷ ⵜⵎⴻⴷⴷⵉⵜ ⵙⵙⴱⴻⵅⵅⴰⵔⴰⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ⵓⵛⴰ ⵃⴹⴰⵏ ⵄⴰⵡⴻⴷ ⵅ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⵓⵙⴻⵜⵜⴻⴼ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵅ ⵜⵣⴻⵡⴹⴰ ⵜⴻⵣⴷⴻⴳ ⵓ ⵅ ⵍⵇⴻⵏⴷⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵅ ⵍⴻⴼⵏⴰⵔⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵙⵙⴰⵔⵖⴻⵏ ⴽⵓⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R213_12","015_13_12","2CH","13","12","12","ⵅⵣⴰⵔⴻⵎ, ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ ⵖⴰⵔ ⵣⵣⴰⵜⵏⴻⵖ, ⵓ ⵖⴰⵔⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵍⴻⴱⵡⴰⵇ ⵉ ⵓⵙⵓⴹⵉ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵙⵓⴹⴻⵏ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ. ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⴰⵎ ⵛⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴼⵍⵉⵃⵉⵎ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("R213_13","015_13_13","2CH","13","13","13","ⵎⴰⵛⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵉⵊⵊⴰ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴳⴳⴻⵏ ⵉⵛⵜ ⵏ ⴷⴷⵓⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵜⴰⵅⵛⴻⴼⵜ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴼⴻⵅ. ");
INSERT INTO rift_vpl VALUES ("R213_14","015_13_14","2CH","13","14","14","ⵓⵎⵉ ⵏⵇⴻⵍⴱⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵥⵔⵉⵏ, ⴰⵇⴰ ⴰⵎⴻⵏⵖⵉ ⵜⵓⵖⴰ-ⵜ ⵣⵉ ⵣⵣⴰⵜ ⴷ ⵣⵉ ⴹⴻⴼⴼⴰⵔ. ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵙⵓⴹⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R213_15","015_13_15","2CH","13","15","15","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴷⴻⴳ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⵍⴰⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷⴻⴳ ⵉⵖⵓⵢⵢⴰⵏ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵜⴰ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⴱⵉⵢⴰ ⴷ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R213_16","015_13_16","2CH","13","16","16","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R213_17","015_13_17","2CH","13","17","17","ⴰⴱⵉⵢⴰ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵡⵜⵉⵏ ⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⵉⵏⵣⵉ ⵡⴹⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵅⴻⵎⵙⴰ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R213_18","015_13_18","2CH","13","18","18","ⴰⵎⵎⵓ ⵉ ⴷⴻⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⴱⴻⵀⵜⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷⴻⵡⵍⴻⵏ ⵊⴻⵀⴷⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵜⴻⵛⵍⴻⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R213_19","015_13_19","2CH","13","19","19","ⴰⴱⵉⵢⴰ ⵉⴹⴼⴰⵔ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵣⵣⴰⵢⴻⵙ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴱⴰⵢⵜ-ⵉⵍ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵢⴰⵛⴰⵏⴰ ⴰⴽ-ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⴼⵔⵓⵏ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R213_20","015_13_20","2CH","13","20","20","ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵊⵊⴻⵀⴷ ⵖⴰⵔ ⵢⴰⵔⵓⴱⵄⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⴱⵉⵢⴰ. ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⵡⵜⴰ ⵉ-ⵜ ⵙⵉⴷⵉ, ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R213_21","015_13_21","2CH","13","21","21","ⴰⴱⵉⵢⴰ ⵎⴰⵛⴰ ⵉⴷⵡⴻⵍ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵊⵊⴻⵀⴷ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉⵊⵊⴰ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵙⴻⵟⵟⴰⵛ ⵏ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("R213_22","015_13_22","2CH","13","22","22","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⴰⴱⵉⵢⴰ, ⴰⵎ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ ⴰⵎ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵜⵖⵓⵔⵉ ⵏ ⵓⵏⴰⴱⵉ ⵄⵉⴷⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("R213_23","015_13_23","2CH","13","23","23","ⴰⴱⵉⵢⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵓⵛⴰ ⵎⵎⵉⵙ ⴰⵙⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⵀⵓⴷⵏⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R214_1","015_14_1","2CH","14","1","1","ⴰⵙⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R214_2","015_14_2","2CH","14","2","2","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵓⵛⴰ ⵢⴰⵔⵥⴰ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵀⴷⴻⵎ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("R214_3","015_14_3","2CH","14","3","3","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⴰⵔⵣⵓⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R214_4","015_14_4","2CH","14","4","4","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵄⴰⵡⴻⴷ ⵍⴻⴳⵄⵓⴷⵉ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵜⴰⴳⴻⵍⴷⵉⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⵀⵓⴷⵏⴻⵜ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("R214_5","015_14_5","2CH","14","5","5","ⵉⴱⵏⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⵀⵓⴷⵏⴻⵜ. ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⴰⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙ ⵍⵀⵓⴷⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R214_6","015_14_6","2CH","14","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓⴷⴰ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴱⵏⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ-ⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵏⴻⵙⵙⴰⵔ ⵙ ⵍⴻⵃⵢⵓⴹ ⴷ ⵍⴱⵓⵔⵊⴰⵜ ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵓⴱⴻⵍⵍⴻⵄ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵄⴰⴷ ⵣⵣⴰⵜⵏⴻⵖ ⵙ ⵍⵀⵓⴷⵏⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵣⵓ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵏⴰⵔⵣⵓ ⵅⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵍⵀⵓⴷⵏⴻⵜ.” ⵓ ⵏⵉⵜⵏⵉ ⴱⵏⴰⵏ ⵓⵛⴰ ⴼⴻⵍⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R214_7","015_14_7","2CH","14","7","7","ⴰⵙⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵍⵜ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵍⴰⵏⵙⴰ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵓ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵍⵇⴻⵡⵙ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R214_8","015_14_8","2CH","14","8","8","ⵉⴼⴼⴻⵖ ⴰⴽⵓⵛⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵣⴰⵔⴰⵃ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵎⴻⵍⵢⵓⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍ ⵎⴰⵔⵉⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R214_9","015_14_9","2CH","14","9","9","ⵉⴼⴼⴻⵖ ⴰⵙⴰ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵙⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵚⴰⴼⴰⵜⴰ ⵖⴰⵔ ⵎⴰⵔⵉⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R214_10","015_14_10","2CH","14","10","10","ⴰⵙⴰ ⵉⵍⴰⵖⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⴰⵢⴰ ⵉⵙⵀⴻⵍ ⵅⴰⴽ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵊⴰⵔ ⵢⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴷ ⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵊⵊⴻⵀⴷ. ⵄⴰⵡⴻⵏ ⴰⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⵛⴻⵍ ⵅⴰⴽ ⵓ ⵏⵓⵙⴰ-ⴷⴷ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵖⴰⵛⵉ-ⵢⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⴰⴽⵉⴷⴻⴽ ⵉⵎⵎⵄⴰⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("R214_11","015_14_11","2CH","14","11","11","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵜⴰ ⴰⵢⵜ ⵏ ⴽⵓⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵙⴰ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⴽⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("R214_12","015_14_12","2CH","14","12","12","ⴰⵙⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ, ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⴰⵍ ⵊⴰⵔⴰⵔ. ⵡⴹⴰⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴽⵓⵛ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵖⴻⵍⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R214_13","015_14_13","2CH","14","13","13","ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵊⴰⵔⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⵔⵔⴻⵀⴱⴻⵜ ⵏ ⵙⵉⴷⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏⵜ. ⵏⵉⵜⵏⵉ ⴽⴻⵛⵛⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵜⴱⴰⵏ-ⴷⴷ ⴷⴰⵢⵙⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("R214_14","015_14_14","2CH","14","14","14","ⵏⵉⵜⵏⵉ ⵀⴻⴷⵎⴻⵏ ⵓⵍⴰ ⴷ ⵉⵇⵉⴹⴰⵏ ⵏ ⵍⵎⴰⵍ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵓⴵⵉ ⴷ ⵉⵍⴻⵖⵎⴰⵏ. ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R215_1","015_15_1","2CH","15","1","1","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R215_2","015_15_2","2CH","15","2","2","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⴰⵙⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⴰⵙⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ! ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴽⵉⴷⴻⵙ. ⵎⴰⵍⴰ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵅⴰⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⴰⴷ ⵜ ⵜⴰⴼⴻⵎ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅⴰⵙ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵃⴻⵢⵢⴻⴷ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("R215_3","015_15_3","2CH","15","3","3","ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵉⵇⵇⵉⵎ ⵉⵙⵔⴰⵉⵍ ⴱⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵉⴷⴻⵜⵜ ⵓ ⴱⵍⴰ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵉⵙⵙⵖⴰⵔⴰⵏ ⵓ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R215_4","015_15_4","2CH","15","4","4","ⵎⴰⵍⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⴰⵔⵣⵓⵏ ⵅⴰⵙ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜ ⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R215_5","015_15_5","2CH","15","5","5","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵍⴻⵀⵏⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵓ ⵉ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴳⴳⵯⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵃⵡⴻⵍ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R215_6","015_15_6","2CH","15","6","6","ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴰⵄⴼⴻⵙ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ, ⵓ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵖⵏⵉⵜ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵉ-ⵜⴻⵏ ⵙ ⴽⵓⵍ ⵍⴻⵃⵚⴰⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R215_7","015_15_7","2CH","15","7","7","ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴰⵔⵅⵓⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵍⵎⵓⵏⴻⵜ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R215_8","015_15_8","2CH","15","8","8","ⵓⵎⵉ ⴰⵙⴰ ⵉⵙⵍⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷ ⵏⵏⵓⴱⵓⵡⴰ ⵏ ⵓⵏⴰⴱⵉ ⵄⵓⴷⵉⴷ, ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵏⵏⵄⴰⵡⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵛⴰ ⵉⵄⴷⴻⵍ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R215_9","015_15_9","2CH","15","9","9","ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓⵍⴰ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⴰⵏⴰⵙⵙⴰ ⵓ ⵛⵉⵎⵄⵓⵏ, ⵎⴰⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵄⴷⵓⵏ ⵖⴰⵔⴻⵙ, ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R215_10","015_15_10","2CH","15","10","10","ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⴰⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R215_11","015_15_11","2CH","15","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ ⴷ ⵜⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵉ ⴽⵉⴷⵙⴻⵏ ⵉⵡⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R215_12","015_15_12","2CH","15","12","12","ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵣⵓⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R215_13","015_15_13","2CH","15","13","13","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⴰⵎ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R215_14","015_15_14","2CH","15","14","14","ⵏⵉⵜⵏⵉ ⵊⵊⵓⴵⴻⵏ ⵉ ⵙⵉⴷⵉ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⵓ ⵙ ⵓⵙⵍⴻⵡⵍⵉⵡ, ⵖⴰⵔ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⵏ ⵍⴻⴱⵡⴰⵇ ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R215_15","015_15_15","2CH","15","15","15","ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⵜⴼⴰⵔⵃ ⵅ ⵜⵊⴰⴵⵉⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⵜ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⵅⴰⵙ ⵙ ⵎⴰⵔⵔⴰ ⴰⵔⴹⴰ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜ ⴰⴼⴻⵏ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵍⵀⵓⴷⵏⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R215_16","015_15_16","2CH","15","16","16","ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⴰⵙⴰ ⵓⵍⴰ ⴷ ⵃⴻⵏⵏⴰⵙ ⵎⴰⵄⴽⴰ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉ ⵜⵔⴻⴱⴱⵉⵜ ⵏ ⵛⵡⴰⵔⵜⵉ. ⴰⵙⴰ ⵉⵛⴻⵇⵇⴰⵔ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵏⵏⴻⵙ, ⵉⵍⴱⴻⵣ ⵉ-ⵜⵜ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵎⴹ ⵉ-ⵜⵜ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R215_17","015_15_17","2CH","15","17","17","ⵡⴰⵔ ⵜⵜⵡⴰⵃⴻⵢⵢⴷⴻⵏⵜ ⵍⴻⴳⵄⵓⴷⵉ, ⵎⴰⵛⴰ ⵓⵍ ⵏ ⴰⵙⴰ ⵜⵓⵖⴰ ⵉⵛⴹⴰⵔ ⵏⵉⵛⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R215_18","015_15_18","2CH","15","18","18","ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵢⵉⵡⵢⵉ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ: ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R215_19","015_15_19","2CH","15","19","19","ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵓⵎⴻⵏⵖⵉ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⴰⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R216_1","015_16_1","2CH","16","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⴰⵙⴰ, ⵉⴼⴼⴻⵖ ⴱⴰⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ. ⵉⴱⵏⴰ ⵔⴰⵎⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏⵉⵖ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R216_2","015_16_2","2CH","16","2","2","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⴰⵙⴰ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵣⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵖⴰⵔ ⴱⵉⵏⵀⴰⴷⴰⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R216_3","015_16_3","2CH","16","3","3","“ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵛⴻⴽ, ⵊⴰⵔ ⴱⴰⴱⴰ ⴷ ⴱⴰⴱⴰⵛ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ. ⵔⵓⵃ ⵛⴻⴽ, ⴼⵙⵉⵢ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⴱⴰⵄⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴷ ⵅⴰⴼⵉ ⵉⴳⴳⵯⴻⵊ.” ");
INSERT INTO rift_vpl VALUES ("R216_4","015_16_4","2CH","16","4","4","ⴱⵉⵏⵀⴰⴷⴰⴷ ⵉⵙⵍⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵓ ⵉⵙⵙⴻⴽⴽ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⵖⴻⵍⴱⴻⵏ ⵅ ⵄⵉⵢⵓⵏ ⴷ ⴷⴰⵏ ⴷ ⴰⴱⴰⵍ-ⵎⴰⵢⵉⵎ ⵓⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("R216_5","015_16_5","2CH","16","5","5","ⵓⵎⵉ ⵉⵙⵍⴰ ⴱⴰⵄⵛⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵍⴻⴱⵏⵉ ⵏ ⵔⴰⵎⴰ ⵓⵛⴰ ⵉⵙⵎⴻⵃ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R216_6","015_16_6","2CH","16","6","6","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵏⵉⵜⵏⵉ ⴽⵙⴻⵏ ⵉⵥⵔⴰ ⵏ ⵔⴰⵎⴰ ⵓⵍⴰ ⴷ ⵜⵉⵃⴻⵏⵢⴰ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⵜ ⵉⴱⵏⴰ ⴱⴰⵄⵛⴰ, ⵓⵛⴰ ⵉⴱⵏⴰ ⵣⵣⴰⵢⴻⵙ ⵊⴰⴱⵄⴰ ⴷ ⵎⵉⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("R216_7","015_16_7","2CH","16","7","7","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⵡⴰⵍⴰⵡ ⵃⴰⵏⴰⵏⵉ ⵖⴰⵔ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵅ ⵓⵢⴰ ⵢⴰⵔⵡⴻⵍ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R216_8","015_16_8","2CH","16","8","8","ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⴽⵓⵛ ⴷ ⴰⵢⵜ ⵏ ⵍⵉⴱⵉⵢⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ? ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵙⵉⴷⵉ, ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("R216_9","015_16_9","2CH","16","9","9","ⵎⴰⵖⴰⵔ ⵜⵃⴻⵡⵡⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵅ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵎ ⵜⴻⴽⵎⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⵙ ⵊⵊⴻⵀⴷ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⵡⵓⵍ ⵉⵎⵓⵏ ⴰⴽⵉⴷⴻⵙ. ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⴻⴳⴳⵉⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵎⴰⵖⴰⵔ ⵣⵉ ⵍⴻⵅⵅⵓ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵉⵎⴻⵏⵖⴰⵏ ⴰⴽⵉⴷⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("R216_10","015_16_10","2CH","16","10","10","ⴰⵙⴰ ⵉⵀⴰⵊ ⵅ ⵓⵎⵡⴰⵍⴰⵡ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⵉⵙⵅⴻⴹ ⵅ ⵓⵢⴰ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵛⵜ ⵉⵃⵚⴰⵔ ⴰⵙⴰ ⵛⴰ ⵣⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R216_11","015_16_11","2CH","16","11","11","ⵅⵣⴰⵔ, ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⴰⵙⴰ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R216_12","015_16_12","2CH","16","12","12","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵉⵀⵍⴻⵛ ⴰⵙⴰ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ. ⵎⴰⵛⴰ ⴷⵉ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ ⵓⵍⴰ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ, ⵡⴰⵔ ⵢⴰⵔⵣⵓ ⵛⴰ ⵅ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵅ ⵉⵎⴻⵙⴳⴻⵏⴼⴰⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R216_13","015_16_13","2CH","16","13","13","ⴰⵙⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵉⵎⵎⵓⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵣⵉ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R216_14","015_16_14","2CH","16","14","14","ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⵅ ⵇⴰⵎⴰ ⵉ ⵜⵓⵖⴰ ⵜⵄⴻⵎⵎⴰⵔ ⵙ ⵍⴻⵄⵟⵓⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴷⴷⴰⵔⴱⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵎⵉⵏ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵃⵔⴰⵢⴼⵉ. ⵏⵉⵜⵏⵉ ⵇⵇⴷⴻⵏ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R217_1","015_17_1","2CH","17","1","1","ⵎⵎⵉⵙ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R217_2","015_17_2","2CH","17","2","2","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉⴳⴳⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵃⴻⵡⵡⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵜⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴱⴰⴱⴰⵙ ⴰⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R217_3","015_17_3","2CH","17","3","3","ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ, ⵡⴰⵔ ⵢⴰⵔⵣⵓ ⵛⴰ ⵅ ‘ⵉⴱⴰⵄⵍⴻⵏ’, ");
INSERT INTO rift_vpl VALUES ("R217_4","015_17_4","2CH","17","4","4","ⵎⴰⵛⴰ ⵢⴰⵔⵣⵓ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴳⴳⵉ ⴰⵎ ⵜ ⵉⴳⴳⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R217_5","015_17_5","2CH","17","5","5","ⵙⵉⴷⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵜⴻⵏⵏⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⵢⵉⵡⵉ ⵜⴰⵔⵣⵉⴼⵉⵏ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ. ⵉⴷⵡⴻⵍ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R217_6","015_17_6","2CH","17","6","6","ⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵃⴻⴹ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵓⵍⴰ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⴷ ⵜⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵣⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R217_7","015_17_7","2CH","17","7","7","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵉⵙⵙⴻⴽⴽ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⵉ ⴱⵉⵏ-ⵃⴰⵢⵉⵍ, ⵄⵓⴱⴰⴷⵢⴰ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵏⴰⵜⴰⵏⵉⵢⵉⵍ ⴷ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵖⴰⵔⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R217_8","015_17_8","2CH","17","8","8","ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵛⴰⵎⵄⵉⵢⴰ, ⵏⴰⵜⴰⵏⵢⴰ, ⵣⴰⴱⴰⴷⵢⴰ, ⵄⴰⵙⴰ’ⵉⵍ, ⵛⴰⵎⵉⵔⴰⵎⵓⵜ, ⵢⵓⵏⴰⵜⴰⵏ, ⵜⵓⴱⵉⵢⴰ ⴷ ⵟⵓⴱ-ⴰⴷⵓⵏⵉⵢⴰ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵍⵉⵛⴰⵎⴰⵄ ⴷ ⵢⴰⵀⵓⵔⴰⵎ ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R217_9","015_17_9","2CH","17","9","9","ⵏⵉⵜⵏⵉ ⵙⵙⵖⴰⵔⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ. ⴽⴽⵉⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵙⵙⵖⴰⵔⴻⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R217_10","015_17_10","2CH","17","10","10","ⵜⵓⵙⴰ-ⴷⴷ ⴰⵔⵔⴻⵀⴱⴻⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵉ-ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵢⴰⵀⵓⴷⴰ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵙⵙⴻⴽⴽⴰⵔⴻⵏⵜ ⴰⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("R217_11","015_17_11","2CH","17","11","11","ⵣⴻⴳ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵉⵡⵢⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴰⵎ ⵍⵊⵉⵣⵢⴰ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ. ⵓⵍⴰ ⴷ ⴰⵄⵔⴰⴱⴻⵏ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵙ ⵓⴵⵉ: ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵎⵓⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R217_12","015_17_12","2CH","17","12","12","ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵢⴰⵔⵏⵉ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⵓⵛⴰ ⵉⴱⵏⴰ ⵍⵇⴻⵍⵄⴰⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R217_13","015_17_13","2CH","17","13","13","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵍⴰ ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R217_14","015_17_14","2CH","17","14","14","ⴷ ⵡⴰⵏⵉⵜⴰ ⴷ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵅ ⵍⵓⵍⵓⴼ: ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷⵏⴰ ⵓ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵍⵜ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R217_15","015_17_15","2CH","17","15","15","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵍⵇⴻⴱⵟⴰⵏ ⵢⴰⵀⵓⵏⴰⵜⴰⵏ, ⴰⴽⵉⴷⴻⵙ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R217_16","015_17_16","2CH","17","16","16","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵄⴰⵎⴰⵙⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵣⵉⴽⵔⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⴻⴱⴱⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵉⵜⴰⵢⴻⵏ-ⴰⵍⴻⴼ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R217_17","015_17_17","2CH","17","17","17","ⵣⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵜⵓⵖⴰ ⴰⵍⵉⵢⴰⴷⴰⵄ, ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵉⵜⴰⵢⴻⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙ ⵍⵇⴻⵡⵙ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R217_18","015_17_18","2CH","17","18","18","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵢⴰⵀⵓⵣⴰⴱⴰⴷ ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵢⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵔⵔⴰ ⵃⴻⵣⵣⵎⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R217_19","015_17_19","2CH","17","19","19","ⵉⵏⴰ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴱⵍⴰ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R218_1","015_18_1","2CH","18","1","1","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵖⴰⵔⴻⵙ ⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⴰⴽ-ⴷ ⴰⵅⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R218_2","015_18_2","2CH","18","2","2","ⴰⵡⴰⵔⵏⵉ ⵛⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⴰⵅⴰⴱ, ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ⴰⵅⴰⴱ ⵉⵖⴰⵔⵚ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ ⵓⵛⴰ ⵉⵖⵡⴰ ⵜ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵔⴰⵎⵓⵜ-ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R218_3","015_18_3","2CH","18","3","3","ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ: “ⵣⴻⵄⵎⴰ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⴼⴼⵖⴻⴷ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ?” ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⵎ ⵛⴻⴽ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴽⵉⴷⴻⴽ ⵏⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("R218_4","015_18_4","2CH","18","4","4","ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵄⴰⵡⴻⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵙⴻⵇⵙⴰ ⵄⴰⴼⴰⴽ ⴰⵙⵙ-ⴰ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("R218_5","015_18_5","2CH","18","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵏⵉⵖ ⴰⴷ ⴳⴳⴻⵖ ⴱⵏⴰⵇⴻⵙ?” ⵏⵏⴰⵏ: “ⴳⴻⵄⵄⴻⴷ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("R218_6","015_18_6","2CH","18","6","6","ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⴷⴰ ⵛⴰ ⵄⴰⴷ ⴰⵏⴰⴱⵉ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵇⵙⴰ?” ");
INSERT INTO rift_vpl VALUES ("R218_7","015_18_7","2CH","18","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⴰⵇⴰ ⴷⴰ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵣⴰⵢⴻⵙ ⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵇⵙⴰ ⵙⵉⴷⵉ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵛⴰⵔⵀⴻⵖ ⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ⴰⵇⴰ ⴷ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⵉⵎⵍⴰ.” ⵉⵏⵏⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ “ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵎⴻⵏⵏⵉ!” ");
INSERT INTO rift_vpl VALUES ("R218_8","015_18_8","2CH","18","8","8","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ, ⵉⵏⵏⴰ: “ⴷⴻⵖⵢⴰ ⴰⵡⵉ-ⴷⴷ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⵉⵎⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("R218_9","015_18_9","2CH","18","9","9","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵏⴻⴷⵔⴰⵔ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R218_10","015_18_10","2CH","18","10","10","ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵏⵄⴰⵏⴰ, ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵙ ⵢⵉⵏⴰ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⵓⵇⵇⴱⴻⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⴰⵍ ⵜⴻⵏ ⵖⴰ ⵜⴻⵇⴹⵉⴹ ⵎⴰⵔⵔⴰ.’” ");
INSERT INTO rift_vpl VALUES ("R218_11","015_18_11","2CH","18","11","11","ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵏⴻⴱⴱⴰⵏ ⴽⵉⴼⴽⵉⴼ, ⵏⵏⴰⵏ: “ⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴼⴻⵍⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("R218_12","015_18_12","2CH","18","12","12","ⴰⵔⴻⵇⵇⴰⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ ⵅⴻⵏⵏⵉ, ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⵅⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵙ ⵍⵅⵉⵔ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⴰⴷ ⵉⵍⵉⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴰⵎ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵉ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R218_13","015_18_13","2CH","18","13","13","ⵎⴰⵛⴰ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵏⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵜ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("R218_14","015_18_14","2CH","18","14","14","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⵉⵅⴰ, ⵎⴰ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵏⵉⵖ ⴰⴷ ⵏⴻⴳⴳ ⴱⵏⴰⵇⴻⵙ?” ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⴳⴰⵄⵄⴷⴻⵎ, ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴼⴻⵍⵃⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R218_15","015_18_15","2CH","18","15","15","ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵛ ⵙⵙⵊⴰⴵⴻⵖ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ ⵎⵖⵉⵔ ⵜⵉⴷⴻⵜⵜ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("R218_16","015_18_16","2CH","18","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⴰⵎ ⵡⵓⴵⵉ ⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵓⵎⴻⴽⵙⴰⵡ. ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵉⵏⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵉⵙⵉⴷⵉⵜⴻⵏ, ⴻⵊⵊ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵀⵏⴰ.’” ");
INSERT INTO rift_vpl VALUES ("R218_17","015_18_17","2CH","18","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵛⴰ ⴷⵉ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ’?” ");
INSERT INTO rift_vpl VALUES ("R218_18","015_18_18","2CH","18","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵄⴰⵡⴻⴷ: “ⵙ ⵓⵢⴰ ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⴰⵇⴰ ⵥⵔⵉⵖ ⵙⵉⴷⵉ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵉⴱⴻⴷⴷ ⵅ ⵢⴻⴼⵓⵙ ⵏⵏⴻⵙ ⴷ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("R218_19","015_18_19","2CH","18","19","19","ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵖⵡⴰⵏ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ?’ ⵡⴰ ⵉⵏⵏⴰ ⴰⵎⵎⵓ ⵓ ⵡⵉⵏ ⵉⵏⵏⴰ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("R218_20","015_18_20","2CH","18","20","20","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ, ⵉⴱⴻⴷⴷ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵖⵡⵉⵖ.’ ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵙⵉⴷⵉ: ‘ⵙ ⵎⵉⵏ ⵣⵉ?’ ");
INSERT INTO rift_vpl VALUES ("R218_21","015_18_21","2CH","18","21","21","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵓ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ.’ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⴰⴷ ⵜⴰⵡⴹⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵖⵡⵉⴷ. ⴼⴼⴻⵖ, ⴻⴳⴳ ⴰⵎⴻⵏⵏⵉ!’ ");
INSERT INTO rift_vpl VALUES ("R218_22","015_18_22","2CH","18","22","22","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵛ ⵓ ⵙⵉⴷⵉ ⵉⴱⴰⵔⵔⴻⵃ ⵅⴰⴽ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("R218_23","015_18_23","2CH","18","23","23","ⵅⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴽⴰⵏⵄⴰⵏⴰ, ⵖⴰⵔ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵉⵡⵡⴻⵜ ⵉ-ⵜ ⵖⴰⵔ ⵓⵖⴻⵙⵎⵉⵔ, ⵉⵏⵏⴰ: “ⵅ ⵎⴰⵏ ⴰⴱⵔⵉⴷ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⵄⴷⵓ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ?” ");
INSERT INTO rift_vpl VALUES ("R218_24","015_18_24","2CH","18","24","24","ⵉⵏⵏⴰ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ: “ⵅⵣⴰⵔ, ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵜⴻⵎⵀⴰⴼⴻⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵖⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("R218_25","015_18_25","2CH","18","25","25","ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⴰ: “ⵟⵟⴼⴻⵎ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵏⴻⴷⵀⴻⵎ ⵄⴰⵡⴻⴷ ⵜ ⵖⴰⵔ ⴰⵎⵓⵏ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵖⴰⵔ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("R218_26","015_18_26","2CH","18","26","26","ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ⵏⴹⴰⵔⴻⵎ ⵡⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵓ ⵙⴻⵛⵛⴻⵎ ⵜ ⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵍ ⵖⴰ ⴷⴻⵡⵍⴻⵖ ⴷⵉ ⵍⴻⵀⵏⴰ.’” ");
INSERT INTO rift_vpl VALUES ("R218_27","015_18_27","2CH","18","27","27","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ: “ⵎⴰⵍⴰ ⵜⵄⴻⵇⴱⴻⴷ-ⴷⴷ ⵛⴰ ⵏ ⵡⴰⵙⵙ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵙⵙⵉⵡⴻⵍ!” ⵓⵛⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵙⵍⴻⵎ-ⴷⴷ ⴰ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ!” ");
INSERT INTO rift_vpl VALUES ("R218_28","015_18_28","2CH","18","28","28","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽ-ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R218_29","015_18_29","2CH","18","29","29","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵏⴻⵛⵛ ⴰⴷ ⴱⴻⴷⴷⵍⴻⵖ ⴰⵔⵔⵓⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵢⴰⵔⴹⴻⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ!” ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⴳⴳⴰ ⴰⵔⵔⵓⴹ ⵡⴰⵔ ⵉⴵⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R218_30","015_18_30","2CH","18","30","30","ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵉⵏⵏⴰ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵏⵖⵉⵎ ⵛⴰ ⴰⴽ-ⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏⵉⵖ ⴰⴽ-ⴷ ⵓⵎⴻⵥⵢⴰⵏ, ⵎⵖⵉⵔ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("R218_31","015_18_31","2CH","18","31","31","ⵓⵎⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵥⵔⵉⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷ ⵡⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ!” ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⴰⵙ ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵎⵎⴻⵏⵖⴻⵏ, ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵙⵖⵓⵢ, ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙ ⴰⴼⵓⵙ ⵓ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⵉ-ⵜⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R218_32","015_18_32","2CH","18","32","32","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜ ⴰⵔⴻⴷⴷⴼⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("R218_33","015_18_33","2CH","18","33","33","ⵅⴻⵏⵏⵉ ⵉⵄⴻⵢⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵍⵇⴻⵡⵙ ⵙ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵓⵛⴰ ⵉⵍⵇⴻⴼ ⴼⵍⵉⵜⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⴰⵔ ⵡⴰⵡⴰⴹ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵡⵓⵣⵣⴰⵍ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴰⴽⴰⵔⵔⵓ: “ⵇⵍⴻⴱ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ-ⴷⴷ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵢⴻⵣⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("R218_34","015_18_34","2CH","18","34","34","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⵎⴻⵏⵖⵉ ⵉⵡⵄⴰⵔ ⴰⵟⵟⴰⵙ. ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ, ⵉⵎⵎⵓⵜ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵓⵖⴻⴵⴰⵢ ⵏ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("R219_1","015_19_1","2CH","19","1","1","ⵉⵄⵇⴻⴱ-ⴷⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R219_2","015_19_2","2CH","19","2","2","ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⴰⵏⵉ, ⴰⵎⵡⴰⵍⴰⵡ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵍⵇⴰ, ⵉⵏⵏⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ: “ⵎⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⵡⵉⵣⴰ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵓ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵉⵏⵏⵉ ⵉⵄⵉⴼⴼⴻⵏ ⵙⵉⴷⵉ? ⴰⵎⵎⵓ ⵉ ⵅⴰⴽ ⴷⴷ-ⵢⵓⵙⴰ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R219_3","015_19_3","2CH","19","3","3","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼ ⴷⴰⵢⴻⴽ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴻⴽⴽⵙⴻⴷ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵓⵍ ⵏⵏⴻⵛ ⵉ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵅ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("R219_4","015_19_4","2CH","19","4","4","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R219_5","015_19_5","2CH","19","5","5","ⵏⴻⵜⵜⴰ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵍⵇⵓⴹⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵍ ⵜⴰⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R219_6","015_19_6","2CH","19","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵍⵇⵓⴹⴰⵜ: “ⵅⵣⴰⵔⴻⵎ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⵎ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵃⴻⴽⴽⵎⴻⵎ ⵉ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵉ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵃⴹⴰⵔ ⴰⴽⵉⴷⵡⴻⵎ ⴷⴻⴳ ⵡⴻⵃⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R219_7","015_19_7","2CH","19","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵜⵉⵍⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ. ⵃⴹⴰⵎ ⵓ ⴳⴳⴻⵎ ⵜ, ⵎⴰⵖⴰⵔ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵍⵖⴻⵛⵛ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵓ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵜⵉⵔⵣⵉⴼⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("R219_8","015_19_8","2CH","19","8","8","ⵓⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⴳⴳⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⵡⴻⴷ ⵛⴰ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵓⴷⴻⴱⴱⴰⵔ ⵏ ⵍⴻⵃⴽⴰⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵉ ⴷⴷⵄⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("R219_9","015_19_9","2CH","19","9","9","ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⴳⴳⴻⵎ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ, ⵙ ⵍⴰⵎⴰⵏ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⵓⵍ ⵏⵉⵛⴰⵏ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R219_10","015_19_10","2CH","19","10","10","ⵖⴰⵔ ⴽⵓⵍ ⴷⴷⴻⵄⵡⴻⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵉ ⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⵊⴰⵔ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵊⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵍⵓⵎⵓⵔ ⴷ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⵍⵎⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵙⵙⴰⵔⴻⴱⴱⵓⵏ ⴷⴷⴻⵏⴱ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵍⴰⵎⵉ ⵅⴰⵡⴻⵎ ⴷⴷ ⵖⴰ ⵉⵡⴹⴰ ⵓⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵓ ⵅ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ. ⴳⴳⴻⵎ ⴰⵎⴻⵏⵏⵉ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜᵉⵙⵙⴰⵔⴻⴱⴱⵓⵎ ⴷⴷⴻⵏⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R219_11","015_19_11","2CH","19","11","11","ⵅⵣⴰⵔⴻⵎ, ⴰⵎⴰⵔⵢⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵅⴰⵡⴻⵎ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵙⵉⴷⵉ, ⵓ ⵣⴰⴱⴰⴷⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵍⵃⴰⴽⴻⵎ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵇⴰ-ⵜ ⵅ ⴽⵓⵍ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵓⵍⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ. ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⴳⴳⴻⵎ ⵜ, ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⵚⴻⵍⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R220_1","015_20_1","2CH","20","1","1","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴷ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵣⴻⴳ ⵉⵎⴰⵄⵓⵏⵉⵢⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("R220_2","015_20_2","2CH","20","2","2","ⵓⵙⵉⵏ-ⴷⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵄⴰⵡⴷⴻⵏ ⵉ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵎⵎⴻⵏⵖⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵣⵉ ⴰⵔⴰⵎ. ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⴷⵉ ⵃⴰⵚⵚⵓⵏ-ⵜⴰⵎⴰⵔ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵄⴰⵢⵏ-ⵊⴰⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("R220_3","015_20_3","2CH","20","3","3","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⴳⴳⵯⴻⴷ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵓⵥⵓⵎⵎⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R220_4","015_20_4","2CH","20","4","4","ⵙⵙⵎⵓⵏⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵣⵓⵏ ⵜⵡⵉⵣⴰ ⵏ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵓⵍⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_5","015_20_5","2CH","20","5","5","ⵉⴱⴻⴷⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵊⴷⵉⴷ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R220_6","015_20_6","2CH","20","6","6","“ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ? ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵎⵎⴰⵔⵙ ⵊⵊⴻⵀⴷ ⴷ ⵜⵣⴻⵎⵎⴰⵔ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("R220_7","015_20_7","2CH","20","7","7","ⴰ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰ ⵡⴰⵔ ⵜⵓⵥⵥⵉⵍⴻⴷ ⵛⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵜⴻⵡⵛⵉⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ ⵉⵄⵉⵣⵣⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("R220_8","015_20_8","2CH","20","8","8","ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⴱⵏⴰⵏ ⴷⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵛⴻⴽ, ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("R220_9","015_20_9","2CH","20","9","9","‘ⵎⴰⵍⴰ ⵉⵍⵇⴻⴼ ⴰⵏⴻⵖ ⵛⴰ ⵏ ⵍⵖⴰⵔ, ⴰⵅⵎⵉ ⵙⵙⵉⴼ ⵏ ⵍⴻⵃⴽⴰⵎ ⵏⵉⵖ ⵟⵟⴰⵄⵓⵏ ⵏⵉⵖ ⵍⴰⵥ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ. ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵏⵍⴰⵖⴰ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵏⴻⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⴻⵙⵍⴻⴷ ⵓ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("R220_10","015_20_10","2CH","20","10","10","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵢⵉⵏⵏⵉ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ - ⵉⵏⵏⵉ ⵉ ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵊⵊⵉⴷ ⵛⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⴽⴽⵉⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R220_11","015_20_11","2CH","20","11","11","ⵅⵣⴰⵔⴻⵎ, ⵏⵉⵜⵏⵉ ⵅⵙⴻⵏ ⴰⴷ ⴰⵏⴻⵖ ⵅⴻⴵⵚⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵛⵉⴷ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R220_12","015_20_12","2CH","20","12","12","ⴰ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵃⴻⴽⴽⵎⴻⴷ ⵛⴰ? ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵏⵣⴻⵎⵎⴰⵔ ⵅ ⵍⵖⴰⵛⵉ-ⵢⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵡⴰⵏⵉⵜⴰ ⵉ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵓ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴰⵔⵔⴰ-ⴷⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⵖⴰⵔⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("R220_13","015_20_13","2CH","20","13","13","ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏⵙⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R220_14","015_20_14","2CH","20","14","14","ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⴷⵉⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵅ ⵢⴰⵃⵣⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵄⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵍⴰⵡⵉ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵙⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("R220_15","015_20_15","2CH","20","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵓ ⵛⴻⴽ, ⴰ, ⴰⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ! ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ, ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵛⴰ ⵣⵉ ⵍⵖⴰⵛⵉ-ⵢⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵡⴰⵏⵉⵜⴰ, ⵎⵉⵏⵣⵉ ⴰⵎⴻⵏⵖⵉ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_16","015_20_16","2CH","20","16","16","ⵀⵡⴰⵎ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵡⴻⵛⵛⴰ. ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⵙⴰⵡⴻⵏⵜ ⵏ ⵚⵉⵚ, ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵅⴻⵛⵛⴻⵎ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵍⴻⵅⵍⴰ ⵏ ⵢⴰⵔⵓⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R220_17","015_20_17","2CH","20","17","17","ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵏⵖⵉⵎ ⵛⴰ. ⴽⴽⴰⵔⴻⵎ, ⵇⵇⵉⵎⴻⵎ ⵜⴱⴻⴷⴷⴻⵎ ⵓ ⵅⵣⴰⵔⴻⵎ, ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⵡⴻⵎ, ⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ! ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ. ⵜⵉⵡⴻⵛⵛⴰ ⴼⴼⵖⴻⵎ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("R220_18","015_20_18","2CH","20","18","18","ⵅⴻⵏⵏⵉ ⵢⵓⴹⴰⵔ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵡⴹⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_19","015_20_19","2CH","20","19","19","ⴽⴽⴰⵔⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵀⴰⵜ ⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵄⵓⴵⴰⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R220_20","015_20_20","2CH","20","20","20","ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ ⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵜⴰⵇⵓⵄⴰ. ⵖⴰⵔ ⵡⵓⴼⴼⵓⵖ ⵏⵙⴻⵏ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⴷⵉⵏ, ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⵢⴰⵀⵓⴷⴰ, ⴷ ⴽⴻⵏⵏⵉⵡ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⵎⵏⴻⵎ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷⵉ ⵍⴰⵎⴰⵏ. ⴰⵎⵏⴻⵎ ⵣⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴼⴻⵍⵃⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R220_21","015_20_21","2CH","20","21","21","ⵏⴻⵜⵜⴰ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⴷ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵚⴻⴱⴱⵃⴻⵏ ⴰⵛⴻⵡⵡⴰⴹ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ, ⴰⵎ ⵖⴰ ⵢⵓⵢⵓⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ, ⴰⴷ ⵉⵏⵉⵏ: “ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("R220_22","015_20_22","2CH","20","22","22","ⴷⵉ ⵍⵡⴻⵇⵜ ⵍⴰⵎⵉ ⴱⴷⴰⵏ ⵏⵉⵜⵏⵉ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴷ ⵓⵚⴻⴱⴱⴻⵃ, ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵍⴻⴼⵅⵓⵅ ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⵎⵓ’ⴰⴱ ⵓ ⵅ ⵢⴻⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴹⵉⴷⴷ ⵉ ⵢⴰⵀⵓⴷⴰ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ, ⵓⵛⴰ ⵜⵜⵡⴰⵖⴻⵍⵍⴱⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_23","015_20_23","2CH","20","23","23","ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴽⴽⴰⵔⴻⵏ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵀⴻⵍⵍⴽⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵏ. ⵓⵎⵉ ⵇⴹⴰⵏ ⵏⵉⵜⵏⵉ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵙⴰⵄⵉⵔ, ⵙⵙⵀⴻⵍⵍⴽⴻⵏ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_24","015_20_24","2CH","20","24","24","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⵉⴹ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⵓⵃⴻⵟⵟⵓ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵏⴹⴰⵔⴻⵏ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵙⴻⵏ ⴰⵡⴰⵏⵉ ⴰⵙⴻⵏ ⵅ ⵍⵖⴰⵛⵉ, ⵓ ⵅⵣⴰⵔ, ⵥⵔⵉⵏ ⵎⵖⵉⵔ ⵍⵅⴻⵛⴱⴰⵜ ⵜⵓⵖⴰ ⵡⴹⴰⵏⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵏⵊⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R220_25","015_20_25","2CH","20","25","25","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⴼⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⴷ ⵍⵅⴻⵛⴱⴰⵜ ⴷ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵣⵣⴰⵢⴻⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⴰⵔⴱⵓⵏ. ⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R220_26","015_20_26","2CH","20","26","26","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵎⵓⵏⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ, ⵎⵉⵏⵣⵉ ⴷⵉⵏ ⴱⴰⵔⴽⴻⵏ ⵙⵉⴷⵉ. ⵅ ⵓⵢⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ: ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ, ⵖⴰⵔ ⵉ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("R220_27","015_20_27","2CH","20","27","27","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⵓⵢⵓⵔ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴼⴰⵔⵃ ⵉ-ⵜⴻⵏ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R220_28","015_20_28","2CH","20","28","28","ⴰⵎ ⵜⵜⵉⵔⴰⵔⴻⵏ ⵙ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⴻⴱⵡⴰⵇ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_29","015_20_29","2CH","20","29","29","ⵜⵓⵖⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵍⵇⴻⴼ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵓⵎⵉ ⵙⵍⵉⵏⵜ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R220_30","015_20_30","2CH","20","30","30","ⵜⵓⴼⴰ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵍⵀⵓⴷⵏⴻⵜ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵉⵡⵛⴰ ⴰⵙ ⵍⴻⵀⵏⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R220_31","015_20_31","2CH","20","31","31","ⴰⵎⵎⵓ ⵉ ⵉⵃⴽⴻⵎ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵅ ⵢⴰⵀⵓⴷⴰ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⴰⵣⵓⴱⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵛⵉⵍⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_32","015_20_32","2CH","20","32","32","ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⴰⵙⴰ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵃⴻⵢⵢⴻⴷ ⵛⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R220_33","015_20_33","2CH","20","33","33","ⵎⵖⵉⵔ ⵍⴻⴳⵄⵓⴷⵉ ⵡⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵜⵓⵖⵉ ⵄⴰⴷ ⵢⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R220_34","015_20_34","2CH","20","34","34","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⴰⵏⵉ, ⵉⵏⵏⵉ ⵉⴳⴳⴰ ⴰⴷ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R220_35","015_20_35","2CH","20","35","35","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⴳⴳⴰ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵅⴰⵣⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴰⵟⵟⴰⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("R220_36","015_20_36","2CH","20","36","36","ⵏⴻⵜⵜⴰ ⵉⵇⵇⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ. ⵏⵉⵜⵏⵉ ⴱⵏⴰⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⵉ ⴷⵉ ⵄⵉⵚⵢⵓⵏ-ⵊⴰⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R220_37","015_20_37","2CH","20","37","37","ⵎⴰⵛⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⴷⵓⴷⴰⵡⴰⵀⵓ ⵣⵉ ⵎⴰⵔⵉⵛⴰ, ⵉⵜⵜⵏⴻⴱⴱⴰ ⵅ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵉⵏⵏⴰ: “ⵎⵉⵏⵣⵉ ⵜⴻⵇⵇⵏⴻⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵅⴰⵣⵉⵢⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵢⴰⵔⵥⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ.” ⴰⵎⵎⵓ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵜⵜⵡⴰⵔⵥⴻⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("R221_1","015_21_1","2CH","21","1","1","ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⵢⴰⵀⵓⵔⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R221_2","015_21_2","2CH","21","2","2","ⴰⵢⵜⵎⴰⵙ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵄⴰⵣⴰⵔⵢⴰ, ⵢⴰⵃⵉⵢⵉⵍ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵄⴰⵣⴰⵔⵢⴰⵀⵓ, ⵎⵉⵅⴰⵢⵉⵍ ⴷ ⵛⴰⴼⴰⵟⵢⴰ. ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R221_3","015_21_3","2CH","21","3","3","ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵔⵣⵉⴼⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⵓⵍⴰ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵛⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵢⴰⵀⵓⵔⴰⵎ, ⵎⴰⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵏⵣⵓ. ");
INSERT INTO rift_vpl VALUES ("R221_4","015_21_4","2CH","21","4","4","ⵓⵎⵉ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵢⴰⵀⵓⵔⴰⵎ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⵎⵏⴻⵄ ⴷⵉ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ ⵙ ⵙⵙⵉⴼ, ⵓⵍⴰ ⴷ ⵛⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R221_5","015_21_5","2CH","21","5","5","ⵢⴰⵀⵓⵔⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R221_6","015_21_6","2CH","21","6","6","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴻⴳⴳⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⵢⴻⴵⵉⵙ ⵏ ⴰⵅⴰⴱ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R221_7","015_21_7","2CH","21","7","7","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴷⴰⵡⵓⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⴷⴰⵡⵓⴷ, ⵓⵛⴰ ⵓⵍⴰ ⵓⵎⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⵉⵏⵏⴰ, ⴰⵇⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵍⴻⴱⴷⴰ ⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R221_8","015_21_8","2CH","21","8","8","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⵅⵜⵓⵜⵜⴻⵍ ⵉⴷⵓⵎ ⵙ ⵓⵖⴻⵡⵡⴻⵖ ⵣⵉ ⵙⴰⴷⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R221_9","015_21_9","2CH","21","9","9","ⵉⵄⴷⵓ ⵢⴰⵀⵓⵔⴰⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⵏ ⵓⵎⴻⵏⵖⵉ. ⴰⵇⴰ ⵉⴽⴽⴰⵔ ⵙ ⴵⵉⵍⴻⵜ ⵓ ⵉⵖⵍⴻⴱ ⵅ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("R221_10","015_21_10","2CH","21","10","10","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵅⵜⵓⵜⵜⵍⴻⵏ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⵙ ⵓⵖⴻⵡⵡⴻⵖ ⵣⵉ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵍ ⴰⵙⵙ-ⴰ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴱⴻⵄⴷⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵓⵍⴰ ⴷ ⵍⵉⴱⵏⴰ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵢⴰⵀⵓⴷⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R221_11","015_21_11","2CH","21","11","11","ⵉⴳⴳⴰ ⵢⴰⵀⵓⵔⴰⵎ ⵓⵍⴰ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵀ, ⵜⵓⵖⴰ ⵉⵄⴰⵔⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R221_12","015_21_12","2CH","21","12","12","ⵜⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵏ ⵓⵏⴰⴱⵉ ⵉⵍⵉⵢⴰ, ⵜⴻⵇⵇⴰⵔ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ: ‘ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵓⵢⵓⵔⴻⴷ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴱⴰⴱⴰⵛ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵓ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴰⵙⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("R221_13","015_21_13","2CH","21","13","13","ⵎⴰⵛⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵜⴰⵔⵔⵉⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⴼⴰⵔⵇ-ⵛⵖⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵓ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵏⵖⵉⴷ ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵛ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⵏⴰⵏ ⵅⴰⴽ, ");
INSERT INTO rift_vpl VALUES ("R221_14","015_21_14","2CH","21","14","14","ⵅⵣⴰⵔ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵍⵇⴻⴼ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R221_15","015_21_15","2CH","21","15","15","ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵡⴹⵉⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵀⵍⴰⵛ ⵏ ⵜⴻⴽⵔⵉⵛⵜ ⵉⵇⴻⵙⵃⴻⵏ, ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴻⴼⴼⴻⵖ ⵄⴰⴷ ⵜⴻⴽⵔⵉⵛⵜ ⵏⵏⴻⵛ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵀⵍⴰⵛ ⵉ ⵉⵜⵜⴷⵓⵎⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("R221_16","015_21_16","2CH","21","16","16","ⵙⵉⴷⵉ ⵉⵙⵙⴻⵀⵡⴻⵍ ⵅ ⵢⴰⵀⵓⵔⴰⵎ ⴰⵔⵔⵓⵃ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵡⴻⵄⵔⴰⴱⴻⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⵖⴻⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴰⵢⵜ ⵏ ⴽⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("R221_17","015_21_17","2CH","21","17","17","ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵇⵇⵉⵎ ⵎⵖⵉⵔ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴰⵎⴰⵥⵓⵥ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R221_18","015_21_18","2CH","21","18","18","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵙⵉⴷⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵀⵍⴰⵛ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("R221_19","015_21_19","2CH","21","19","19","ⵓⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵀⵍⴻⵛ ⴰⵎⵎⵓ ⴰⵙⵙ ⵉⴹⴼⴰⵔ ⵓⵎⴰⵙ, ⵓⵛⴰ ⵜⴻⵄⴷⵓ ⵍⵡⴻⵇⵜ ⴰⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵜⴰⴽⵔⵉⵛⵜ ⵏⵏⴻⵙ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⵙ ⵍⴻⵃⵍⵉⵇ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵙⵙⴰⵔⵖ ⵛⴰ ⵜⵎⴻⵙⵙⵉ ⴰⵎ ⴳⴳⵉⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R221_20","015_21_20","2CH","21","20","20","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⴼⵏⴰ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵏⴷⴻⴱ ⵃⴻⴷ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R222_1","015_22_1","2CH","22","1","1","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴳⴳⵉⵏ ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ, ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵜⵓⴷⴻⴼ ⴰⴽ-ⴷ ⵡⴻⵄⵔⴰⴱⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⴰⵅⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵔⴰⵎ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R222_2","015_22_2","2CH","22","2","2","ⴰⵅⴰⵣⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⴰⵜⴰⵍⵢⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵄⵓⵎⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R222_3","015_22_3","2CH","22","3","3","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⵢⴻⵎⵎⴰⵙ ⴷ ⵜⴰⵎⵛⴰⵡⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("R222_4","015_22_4","2CH","22","4","4","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵎⴰⵖⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⴱⴰⴱⴰⵙ ⵜⵓⵖⴰ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉⴽⴽⴰ ⵅ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R222_5","015_22_5","2CH","22","5","5","ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⵛⵛⵡⴰⵔ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⵖⴰⵔ ⵔⴰⵎⵓⵜ ⴷⵉ ⵊⵉⵍⵄⴰⴷ ⵓⵛⴰ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵖⴻⵍⴱⴻⵏ ⵅ ⵢⵓⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("R222_6","015_22_6","2CH","22","6","6","ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⵓ ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ ⴰⴳⴻⵏⴼⵓ ⵣⴻⴳ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵓⵎⵉ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵔⴰⵎⵓⵜ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ, ⵃⴰⵣⴰⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ⵉⵀⵡⴰ-ⴷⴷ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵔⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⴷⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵊⵊ ⵅ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⴱ, ⴷⵉ ⵢⴰⵣⵔⴰⵄⵉⵍ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("R222_7","015_22_7","2CH","22","7","7","ⴰⵔⴻⴷⴷⴻⴵ ⵏ ⴰⵅⴰⵣⵢⴰ ⵜⵓⵖⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵢⵓⵔⴰⵎ. ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⴷⵉⵏ, ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵢⵓⵔⴰⵎ ⵖⴰⵔ ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵎⵛⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴷⵀⴻⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴹⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R222_8","015_22_8","2CH","22","8","8","ⵓⵎⵉ ⵉⵇⴹⴰ ⵢⴰⵀⵓ ⵍⵃⵓⴽⵎ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⴼⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵢⵜⵎⴰⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴰⵅⴰⵣⵢⴰ, ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R222_9","015_22_9","2CH","22","9","9","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⵓ ⵅ ⴰⵅⴰⵣⵢⴰ. ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜ ⴰⵎ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵢⴰⵀⵓ. ⵏⵖⵉⵏ ⵜ ⵓ ⵏⴻⴹⵍⴻⵏ ⵜ, ⵎⵉⵏⵣⵉ ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ.” ⴰⵎⵎⵓ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⵣⵢⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵊⵊⴻⵀⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵎ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R222_10","015_22_10","2CH","22","10","10","ⵓⵎⵉ ⵄⴰⵜⴰⵍⵢⴰ, ⵢⴻⵎⵎⴰⵙ ⵏ ⴰⵅⴰⵣⵢⴰ ⵜⴻⵥⵔⴰ, ⴰⵇⴰ ⵎⵎⵉⵙ ⵉⵎⵎⵓⵜ, ⵜⴻⴽⴽⴰⵔ, ⵜᵉⵜⴻⵃⵃⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ.    ");
INSERT INTO rift_vpl VALUES ("R222_11","015_22_11","2CH","22","11","11","ⵎⴰⵛⴰ ⵢⴰⵀⵓⵛⵉⴱⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⴽⵙⵉ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⴰⵅⴰⵣⵢⴰ, ⵓⵛⴰ ⵜⴻⵅⴹⴻⴼ ⵉ-ⵜ ⵣⵉ ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵓⵛⴰ ⵜⴻⵙⵙⵉⴷⴻⴼ ⵉ-ⵜ ⴰⴽ-ⴷ ⵜⴻⵏⵏⵉ ⵜ ⵉⵙⵙⵓⵟⵓⴹⴻⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⴰⵙⵙⵓⵜ. ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⴰ ⵢⴰⵀⵓⵛⵉⴱⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵔⴰⵎ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ - ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⴷ ⵓⵍⵜⵎⴰⵙ ⵏ ⴰⵅⴰⵣⵢⴰ - ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⵉ ⵄⴰⵜⴰⵍⵢⴰ ⵓ ⵜⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵜ ⵜⴻⵏⵖⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R222_12","015_22_12","2CH","22","12","12","ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵇⵇⵉⵎ ⵉⵏⵏⵓⴼⴼⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵜⵓⵖⴰ ⵄⴰⵜⴰⵍⵢⴰ ⵜⵃⴻⴽⴽⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R223_1","015_23_1","2CH","23","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴻⵔⵓⵀⴰⵎ ⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵃⴰⵏⴰⵏ, ⴷ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴱⵉⴷ, ⴷ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴷⴰⵢⴰ, ⴷ ⵉⵍⵉⵛⴰⴼⴰⵟ, ⵎⵎⵉⵙ ⵏ ⵣⵉⴽⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_2","015_23_2","2CH","23","2","2","ⵏⵉⵜⵏⵉ ⴽⴽⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵙⵙⵎⵓⵏⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵍⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R223_3","015_23_3","2CH","23","3","3","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ!” ");
INSERT INTO rift_vpl VALUES ("R223_4","015_23_4","2CH","23","4","4","ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ: ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵄⴻⵙⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R223_5","015_23_5","2CH","23","5","5","ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⴰⴷ ⵜⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴷⵙⴰⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_6","015_23_6","2CH","23","6","6","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⵖⵉⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ, ⴰⴷ ⴰⴷⴼⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵃⴹⴰ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴹⴰ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_7","015_23_7","2CH","23","7","7","ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴰⴷ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵣⵓⵏ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵏ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵡⵓⴼⴼⵓⵖ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R223_8","015_23_8","2CH","23","8","8","ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴷ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵢⵓⴷⴼⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵎⴰⵖⴰⵔ ⴰⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵡⴰⵔ ⵉⵡⵛⵉ ⵍⴻⵄⵡⴰⵛⴰⵔ ⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R223_9","015_23_9","2CH","23","9","9","ⴰⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⵡⵛⴰ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⵍⴰⵏⵙⴰⵜ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵇⴻⵙⵃⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_10","015_23_10","2CH","23","10","10","ⵉⵙⵙⴱⴻⴷⴷ ⵍⴳⴻⵏⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵍ ⴰⵖⴻⵣⴷⵉⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵇⵓⵡⵡⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R223_11","015_23_11","2CH","23","11","11","ⵏⵉⵜⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ-ⴷⴷ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵙ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵙ ⵛⵛⵀⴰⴷⴻⵜ. ⴰⵎⵎⵓ ⵉ ⵜ ⴳⴳⵉⵏ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷⴻⵀⵏⴻⵏ ⵜ, ⵏⵏⴰⵏ: “ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("R223_12","015_23_12","2CH","23","12","12","ⵓⵎⵉ ⵜⴻⵙⵍⴰ ⵄⴰⵜⴰⵍⵢⴰ ⵍⵃⴻⵙⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⴷⵉⵏ ⵓⵛⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴰⵊⴻⴵⵉⴷ, ⵜⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_13","015_23_13","2CH","23","13","13","ⵜⴻⵥⵔⴰ, ⵓ ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⴱⵉⵍⴰⵔ ⵖⴰⵔ ⵡⴰⴷⴰⴼ, ⵓ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵙⵓⴹⴻⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⵔⴰⵃ ⵓ ⵉⵙⵓⴹ ⴷⵉ ⵍⴻⴱⵡⴰⵇ. ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴰⴽ-ⴷ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵚⴻⴱⴱⵃⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ. ⵅⴻⵏⵏⵉ ⵜⵛⴰⵔⵔⴻⴳ ⵄⴰⵜⴰⵍⵢⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵙⵖⵓⵢ: “ⵜⴰⵎⴻⵏⵣⵉⵡⵜ, ⵜⴰⵎⴻⵏⵣⵉⵡⵜ!” ");
INSERT INTO rift_vpl VALUES ("R223_14","015_23_14","2CH","23","14","14","ⵎⴰⵛⴰ ⵢⵓⵎⵓⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵎⵢⴰ, ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵅ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵓⴼⴼⵖⴻⵎ ⵜⵜ-ⵉ-ⴷⴷ ⵊⴰⵔ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵏⵖⴻⵎ ⵙ ⵙⵙⵉⴼ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ.” ⵎⴰⵖⴰⵔ ⴰⴽⴻⵀⵀⴰⵏ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜ ⵏⴻⵇⵇⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("R223_15","015_23_15","2CH","23","15","15","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵛⴰ ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⵢⵙⴰⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵏⵖⵉⵏ ⵜⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_16","015_23_16","2CH","23","16","16","ⵉⴳⴳⴰ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵊⴰⵔ ⴰⵙ-ⴷⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R223_17","015_23_17","2CH","23","17","17","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⵄⴰⵍ ⵓ ⵀⴻⴷⵎⴻⵏ ⵜⵜ. ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⴰⵔⵥⵉⵏ ⵜⴻⵏ ⵇⴰⵄ. ⵓ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵎⴰⵜⵜⴰⵏ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⴱⴰⵄⴰⵍ, ⵣⵣⴰⵜ ⵉ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R223_18","015_23_18","2CH","23","18","18","ⵉⴳⴳⴰ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴹⴰ ⴷⴰⵡⵓⴷ ⴷⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵉⵣⵍⴰⵏ, ⴰⵎ ⵜ ⵉⵡⴻⵚⵚⴰ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R223_19","015_23_19","2CH","23","19","19","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵅ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵉⴳⴳⴰ ⵎⴰⵍⴰ ⵉⵅⵎⴻⵊ, ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⴷⴻⴼ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R223_20","015_23_20","2CH","23","20","20","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⴷ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ, ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵙⵙⴻⵀⵡⴰ ⴰⵊⴻⴵⵉⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓ ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵓⵛⴰ ⵙⵙⵖⵉⵎⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R223_21","015_23_21","2CH","23","21","21","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴰⵔⵃ ⵓ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴻⴷⵡⴻⵍ ⵜⴰⵔⵙⴰ, ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵏⵖⵉⵏ ⵄⴰⵜⴰⵍⵢⴰ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R224_1","015_24_1","2CH","24","1","1","ⵢⵓⵡⴰⵛ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴹⵉⴱⵢⴰ ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("R224_2","015_24_2","2CH","24","2","2","ⵢⵓⵡⴰⵛ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵜⵓⵖⴰ ⴰⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R224_3","015_24_3","2CH","24","3","3","ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵢⵉⵡⵉ ⴰⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R224_4","015_24_4","2CH","24","4","4","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵜⵓⵖⴰ ⵉⵏⵡⴰ ⵢⵓⵡⴰⵛ ⵙ ⵡⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵄⴷⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R224_5","015_24_5","2CH","24","5","5","ⵉⵙⵙⵎⵓⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴽⴻⵎ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵢⴰⵔⵡⴻⵎ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⴷⵍⴻⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴱⴷⴰⵎ ⴷⴻⵖⵢⴰ ⵙ ⵓⵢⴰ!” ⵎⴰⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵇⴻⴵⵇⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R224_6","015_24_6","2CH","24","6","6","ⴰⵊⴻⴵⵉⴷ ⵉⵍⴰⵖⴰ ⵉ ⵓⵣⴻⴵⵉⴼ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵅ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴻⵙⵎⵓⵏⵉ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("R224_7","015_24_7","2CH","24","7","7","ⴰⵇⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⴰⵜⴰⵍⵢⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵔⵥⵉⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵙⵙⵎⵓⵟⵟⵉⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ‘ⵉⴱⴰⵄⵍⴻⵏ’.” ");
INSERT INTO rift_vpl VALUES ("R224_8","015_24_8","2CH","24","8","8","ⴰⵊⴻⴵⵉⴷ ⵢⵓⵎⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵉⵛⵜ ⵏ ⵜⵚⴻⵏⴷⵓⵇⵜ ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R224_9","015_24_9","2CH","24","9","9","ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵏ ⵉ ⵙⵉⴷⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏⵏⵉ ⵉⴳⴳⴰ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵅ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("R224_10","015_24_10","2CH","24","10","10","ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⴼⴰⵔⵃⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏⵜ ⴷⵉ ⵜⵚⴻⵏⴷⵓⵇⵜ ⴰⵍⴰⵎⵉ ⵜⴻⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R224_11","015_24_11","2CH","24","11","11","ⴷⵉ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⴷⴷ-ⵙⵙⵉⴷⴼⴻⵏ ⵜⴰⵙⴻⵏⴷⵓⵇⵜ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵥⵔⵉⵏ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⴰⵔⵉⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵓⵡⴻⵇⵇⴰⴼ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵛⴰ ⵙⵙⴻⵅⵡⴰⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵙⴻⵏⴷⵓⵇⵜ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜ ⵓ ⵉⵡⵢⴻⵏ ⵜⵜ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵙⵙ ⵉⴹⴼⴰⵔ ⵓⵎⴰⵙ ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R224_12","015_24_12","2CH","24","12","12","ⴰⵊⴻⴵⵉⴷ ⴷ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵡⵛⵉⵏ ⴰⵢⴰ ⵅⴻⵏⵏⵉ ⵉ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵛⵔⴰⵏ ⵉⵙⵓⵢⴷⴰⵢⴻⵏ ⴷ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵉⵎⵣⵉⵍⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵏⵏⵃⴰⵙ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R224_13","015_24_13","2CH","24","13","13","ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵜⵓⵖⴰ ⵅⴻⴷⴷⵎⴻⵏ ⵍⴻⴱⴷⴰ ⵓ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵜⵓⵢⵓⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜⵓⵖⴰ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓ ⴰⵔⵏⵉⵏ ⴷⵉ ⵍⴻⵎⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R224_14","015_24_14","2CH","24","14","14","ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⵉⵡⵢⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵣⵣⴰⵜ ⵉ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵓⵛⴰ ⵉⴳⴳⴰ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵓ ⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵜⵉⵖⴻⵏⵊⴰⵢⵉⵏ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴽⴽⴰ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⴷⴷⴰⵔ, ⵜⵜⴰⵡⵢⴻⵏ ⵍⴻⴱⴷⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R224_15","015_24_15","2CH","24","15","15","ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵉⵡⵙⴰⵔ ⵓ ⵓⵣⴰⵏ ⵖⴰⵔⴻⵙ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵓⵛⴰ ⵉⵎⵎⵓⵜ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("R224_16","015_24_16","2CH","24","16","16","ⵏⴻⴹⵍⴻⵏ ⵜ ⵊⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R224_17","015_24_17","2CH","24","17","17","ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ ⵓⵙⵉⵏ-ⴷⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵙⵍⴰ ⵖⴰⵔⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R224_18","015_24_18","2CH","24","18","18","ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ⵅⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅ ⵢⴰⵀⵓⴷⴰ ⵓ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R224_19","015_24_19","2CH","24","19","19","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔⴰ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵛⴻⵀⴷⴻⵏ ⵅⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵙⵍⵉⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R224_20","015_24_20","2CH","24","20","20","ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵅ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵅ ⵉⵊⵊ ⵏ ⴷⴷⵔⵓⵊ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵄⴻⴷⴷⴰⵎ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ? ⴰⵎⵎⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴼⵍⵉⵃⴻⵎ ⵛⴰ. ⵎⵉⵏⵣⵉ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵃⴻⵢⵢⴻⴷ ⵏⴻⵜⵜⴰ.’” ");
INSERT INTO rift_vpl VALUES ("R224_21","015_24_21","2CH","24","21","21","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓ ⵃⴻⵊⵊⴰⵔⴻⵏ ⵜ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R224_22","015_24_22","2CH","24","22","22","ⴰⵊⴻⴵⵉⴷ ⵢⵓⵡⴰⵛ ⵡⴰⵔ ⵉⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵜⵓⵖⴰ ⵉⵙⵙⵛⴻⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⴱⴰⴱⴰⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵓⵛⴰ ⵢⵓⵡⴰⵛ ⵉⵏⵖⴰ ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ⵓⵎⵉ ⵉⵎⵎⵓⵜ, ⵉⵏⵏⴰ ⵣⴻⴽⴰⵔⵉⵢⴰ: “ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⵥⴰⵔ, ⴰⴷ ⵢⴰⵔⵣⵓ ⴰⴷ ⵜ ⵉⵅⵍⴻⴼ!” ");
INSERT INTO rift_vpl VALUES ("R224_23","015_24_23","2CH","24","23","23","ⵖⴰⵔ ⵓⵏⴻⵇⵍⴻⴱ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ ⵅ ⵢⵓⵡⴰⵛ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵙⵙⵀⴻⵍⵍⴽⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("R224_24","015_24_24","2CH","24","24","24","ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ ⴷⵔⵓⵙ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵡⴰⵀⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵅ ⵢⵓⵡⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("R224_25","015_24_25","2CH","24","25","25","ⵓⵎⵉ ⵅⴰⵙ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵇⴰ ⵊⵊⵉⵏ ⵜ ⵉⵀⵍⴻⵛ ⴰⵟⵟⴰⵙ. ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵢⵓⵡⴰⵛ ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ. ⵏⵖⵉⵏ ⵜ ⴰⵎ ⵉⴵⴰ ⴷⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵏⴹⵉⵍⴻⵏ ⵛⴰ ⴷⵉ ⵜⵎⴻⴹⵍⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R224_26","015_24_26","2CH","24","26","26","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉ ⵅⴰⵙ ⵉⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ: ⵣⴰⴱⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⴰ, ⵜⴰⵄⴰⵎⵎⵓⵏⴻⵛⵜ, ⵓ ⵢⴰⵀⵓⵣⴰⴱⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵔⵉⵜ, ⵜⴰⵎⵓ’ⴰⴱⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("R224_27","015_24_27","2CH","24","27","27","ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵍⵇⴻⴷⴷ ⵏ ⵎⵉⵏ ⵉ ⵅⴰⵙ ⴳⴳⵉⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵅ ⴷⵙⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵢⵓⵔⴰ ⴷⵉ ⵜⵉⵔⴰ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ⵎⵎⵉⵙ ⴰⵎⴰⵚⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R225_1","015_25_1","2CH","25","1","1","ⴰⵎⴰⵚⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵀⵓⵄⴰⴷⴷⴰⵏ, ⵜⵓⵖⴰ-ⵜⵜ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R225_2","015_25_2","2CH","25","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵡⵓⵍ ⵉⵎⵓⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R225_3","015_25_3","2CH","25","3","3","ⵓⵎⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵏⵖⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵏⵖⵉⵏ ⴱⴰⴱⴰⵙ ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R225_4","015_25_4","2CH","25","4","4","ⵎⴰⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵇⴻⵜⵜⴰⵍⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⵖⵉ ⵛⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ ⵉ ⴷⵉ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵉⴱⴰⴱⴰⵜⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("R225_5","015_25_5","2CH","25","5","5","ⴰⵎⴰⵚⵢⴰ ⵉⵙⵙⵎⵓⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵎⵢⴰ ⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵎⴰⵔⵔⴰ. ⵏⴻⵜⵜⴰ ⵉⵙⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ ⵓⵛⴰ ⵢⵓⴼⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⵜⴻⵍⵜ-ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴷⴰⵔⵔⴱⴻⵏ ⵅ ⵓⵃⵔⵉⵛ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R225_6","015_25_6","2CH","25","6","6","ⵏⴻⵜⵜⴰ ⵉⵛⵔⴰ ⵎⵢⴰⵜ-ⴰⵍⴻⴼ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵙ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R225_7","015_25_7","2CH","25","7","7","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⴰ, ⴰⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴽⵉⴷⴻⴽ ⵉⵜⵜⴻⴼⴼⴻⵖ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⴵⵉ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⵉ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R225_8","015_25_8","2CH","25","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵄⴰⴷ ⴼⴼⴻⵖ, ⴻⴳⴳ ⵉ-ⵜ, ⵉⵡⴰ ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵄⴷⵓ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔⴻⵙ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵄⴰⵡⴻⵏ ⵓ ⴰⴷ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("R225_9","015_25_9","2CH","25","9","9","ⴰⵎⴰⵚⵢⴰ ⵉⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ: “ⵎⴰⵛⴰ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⵙ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵉ ⵡⵛⵉⵖ ⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ?” ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵉⵡⵛ.” ");
INSERT INTO rift_vpl VALUES ("R225_10","015_25_10","2CH","25","10","10","ⵓⵛⴰ ⵉⵄⵣⴻⵍ ⴰⵎⴰⵚⵢⴰ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⴰⵔⴻⴳⴳⵯⴻⵃⴻⵏⵜ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵍⵇⴻⴼ ⵉ-ⵜⴻⵏ ⵓⵅⴻⵢⵢⴻⵇ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵙ ⵜⴻⴼⵇⴻⵃⵜ ⴷ ⵓⴼⵓⴳⴻⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R225_11","015_25_11","2CH","25","11","11","ⴰⵎⴰⵚⵢⴰ ⵉⴳⴳⴰ ⵜⴰⵔⵢⴰⵙⵜ, ⵉⵏⴷⴻⵀ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⵎⴻⴵⴰⵃⵜ, ⵉⵏⵖⴰ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵙⴰⵄⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("R225_12","015_25_12","2CH","25","12","12","ⵄⴰⵡⴻⴷ ⵃⴻⴱⴱⵙⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⵎ ⴷⴷⴰⵔⴻⵏ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵊⵊⴰⵔⴼ ⵓⵛⴰ ⵄⴰⵔⵏⴻⵏ ⵜⴻⵏ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⴰⵍⴰⵎⵉ ⴼⵜⵓⵜⵜⵢⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R225_13","015_25_13","2CH","25","13","13","ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⴰ ⴰⵎⴰⵚⵢⴰ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴽⵉⴷⵙⴻⵏ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵀⴻⵊⵎⴻⵏ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ ⴰⵍ ⴱⴰⵢⵜ-ⵃⵓⵔⵓⵏ, ⵓⵛⴰ ⵏⵖⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵃⴻⵡⵡⵙⴻⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R225_14","015_25_14","2CH","25","14","14","ⴰⵡⴰⵔⵏⵉ ⵍⴻⵖⵍⴻⴱ ⵅ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴰⵎⴰⵚⵢⴰ, ⵢⵉⵡⵉ ⵏⴻⵜⵜⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵙⴰⵄⵉⵔ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜⴻⵙ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R225_15","015_25_15","2CH","25","15","15","ⵓⵛⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⴰⵎⴰⵚⵢⴰ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵖⴰⵔⴻⵙ. ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴰⵔⵣⵓⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ, ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("R225_16","015_25_16","2CH","25","16","16","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵎⵎⵓ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⴳⴳⵉⵏ ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵡⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ? ⴱⴻⴷⴷ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵡⵜⴻⵏ?” ⵅⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵓⵏⴰⴱⵉ, ⵉⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵄⵣⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⴻⴷⴷⴻⴵ, ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ ⵓ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔ ⵛⵛⵡⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("R225_17","015_25_17","2CH","25","17","17","ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵎⵛⴰⵡⴰⵔ. ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵚⴻⵏ ⵖⴰⵔ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵎⵎⴻⵍⵇⴰ ⵉ ⵓⵎⴻⵏⵖⵉ.” ");
INSERT INTO rift_vpl VALUES ("R225_18","015_25_18","2CH","25","18","18","ⵎⴰⵛⴰ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵚ ⵖⴰⵔ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵉ ⵉⵖⴻⵎⵎⵢⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵉⵙⵙⴻⴽⴽ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵖⴰⵔ ⵜⴻⵏⴳⴻⵍⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵉⵏⵏⴰ: ‘ⴻⵡⵛ ⵢⴻⴵⵉⵛ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵎⵎⵉ!’ ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⵉ ⴷⵉⵏ ⵢⵓⵢⵓⵔⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵉⴽⴽⴰ ⵓⵛⴰ ⵉⵄⴼⴻⵙ ⵅ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R225_19","015_25_19","2CH","25","19","19","ⵜⴻⵇⵇⴰⵔⴻⴷ ⴰⴽ-ⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ: ‘ⵅⵣⴰⵔ, ⴰⵇⴰ ⵖⴻⵍⴱⴻⵖ ⵅ ⵉⴷⵓⵎ!’, ⵓ ⵍⴻⵅⵅⵓ ⵜⵓⴷⴻⴼ ⵏⵏⴼⴰⵅⴻⵜ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⵅ ⵛⵛⴰⵏ ⴽⵜⴰⵔ. ⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵖⴻⴹⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵍⵖⴰⵔ ⵓ ⴰⴷ ⵜⴻⵡⴹⵉⴷ, ⵛⴻⴽ ⴷ ⵢⴰⵀⵓⴷⴰ ⴰⴽⵉⴷⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("R225_20","015_25_20","2CH","25","20","20","ⵎⴰⵛⴰ ⴰⵎⴰⵚⵢⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⴻⵍ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("R225_21","015_25_21","2CH","25","21","21","ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⴻⵍⵇⴰⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ, ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R225_22","015_25_22","2CH","25","22","22","ⵢⴰⵀⵓⴷⴰ ⵉⵜⵜⵡⴰⵖⵍⴻⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R225_23","015_25_23","2CH","25","23","23","ⵢⴰⵃⵓⵢⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵟⵟⴻⴼ ⴰⵎⴰⵚⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⴷⵉ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⴷⵉⵏⵏⵉ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵍ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R225_24","015_25_24","2CH","25","24","24","ⵢⵉⵡⵉ ⵎⴰⵔⵔⴰ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵍⴰ ⴷ ⵉⵎⴻⵔⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R225_25","015_25_25","2CH","25","25","25","ⴰⵎⴰⵚⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏ ⵢⵓⵡⴰⵛ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R225_26","015_25_26","2CH","25","26","26","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⴰⵎⴰⵚⵢⴰ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("R225_27","015_25_27","2CH","25","27","27","ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⵃⴻⵢⵢⴻⴷ ⴰⵎⴰⵚⵢⴰ ⵅ ⵙⵉⴷⵉ, ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵍⴰⵅⵉⵛ. ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R225_28","015_25_28","2CH","25","28","28","ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵅ ⵢⴻⵢⵙⴰⵏ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R226_1","015_26_1","2CH","26","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵢⵉⵡⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵄⵓⵣⵣⵉⵢⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴳⴳⵉⵏ ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⴰⵎⴰⵚⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R226_2","015_26_2","2CH","26","2","2","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵉⵍⴰⵜ ⵓ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R226_3","015_26_3","2CH","26","3","3","ⵄⵓⵣⵣⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⴽⵓⵍⵢⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R226_4","015_26_4","2CH","26","4","4","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵉⴳⴳⴰ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴰⵎⴰⵚⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R226_5","015_26_5","2CH","26","5","5","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵉⵙⵙⴻⵀⵡⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R226_6","015_26_6","2CH","26","6","6","ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⵊⴰⵜ ⵓ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⵢⴰⴱⵏⴰ ⴷ ⵍⵃⵉⴹ ⵏ ⴰⵛⴷⵓⴷ. ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵖⴰⵔ ⴰⵛⴷⵓⴷ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R226_7","015_26_7","2CH","26","7","7","ⴰⵔⴻⴱⴱⵉ ⵉⴱⴻⴷⴷ ⴰⴽⵉⴷⴻⵙ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓ ⴹⵉⴷⴷ ⵉ ⵡⴻⵄⵔⴰⴱⴻⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵊⵓⵔ-ⴱⴰⵄⵍ, ⵓ ⴹⵉⴷⴷ ⵉ ⵉⵎⴰⵄⵓⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R226_8","015_26_8","2CH","26","8","8","ⵡⵛⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵍⵊⵉⵣⵢⴰ ⵉ ⵄⵓⵣⵣⵉⵢⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴰⵍ ⵡⴰⴷⴰⴼ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R226_9","015_26_9","2CH","26","9","9","ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵙⵙⴱⴻⴷⴷ ⵄⵓⵣⵣⵉⵢⴰ ⵚⵚⵓⵎⵄⴰⵜ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵓ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵓ ⵖⴰⵔ ⵜⵖⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ-ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R226_10","015_26_10","2CH","26","10","10","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵚⵚⵓⵎⵄⴰⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵉⵖⵣⴰ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵏⵓⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵖⴰⵔⴻⵙ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⵓ ⴷⵉ ⵍⵡⴰⵟⴰ ⵢⵓⵄⵍⴰⵏ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴼⴻⴵⴰⵃⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵓⵍⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵉⵄⴰⵔⵚⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵜⴰⴼⴻⴵⴰⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("R226_11","015_26_11","2CH","26","11","11","ⵄⵓⵣⵣⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵎⴷⴰⵔⵔⴱⴻⵏ, ⵜⵜⴻⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵄⴰⴷⴰⴷ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⴷⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵎⴰⵔⵉⵔ ⵢⴰⵄⵉⵢⵉⵍ ⴷ ⵓⵡⴻⵇⵇⴰⴼ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵙ ⵍⵓⵎⵓⵔ ⵏ ⵃⴰⵏⴰⵏⵢⴰ, ⵉⵊⵊ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R226_12","015_26_12","2CH","26","12","12","ⵍⵇⴻⴷⴷ ⵉⵎⵓⵏ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵜⵓⵖⴰ ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R226_13","015_26_13","2CH","26","13","13","ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵎⴷⴰⵔⵔⴱⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵉⵛⵛⵓⵔⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵉ ⵓⵊⴻⴵⵉⴷ ⴹⵉⴷⴷ ⵉ ⵍⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("R226_14","015_26_14","2CH","26","14","14","ⵄⵓⵣⵣⵉⵢⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵙⴻⵏ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⵉⵃⵔⵉⵛⴻⵏ ⴷ ⵍⴽⴰⵙⴽⴰⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⴻⵇⵡⴰⵙ ⴷ ⵉⵥⵔⴰ ⵏ ⵢⵉⴵⵉⵢ, ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R226_15","015_26_15","2CH","26","15","15","ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⴳⴳⴰ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵎⵙⵓⴼⴼⵖⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⴳⴳⴻⵏ ⵅ ⵚⵚⵓⵎⵄⴰⵜ ⵓ ⵅ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵡⵜⴻⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵓ ⴰⴷ ⵃⴻⵊⵊⴰⵔⴻⵏ ⵉⵥⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵛⵏⴻⵄ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵎⴰⵖⴰⵔ ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⵡⵉⵣⴰ ⵙ ⵍⴻⵄⵊⴻⴱ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵢⴰⵔⵏⵉ ⴷⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("R226_16","015_26_16","2CH","26","16","16","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉⵙⵙⵉⵡⴻⴹ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⵔⴻⵢⵢⴻⴱ ⵓ ⵉⵖⴷⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R226_17","015_26_17","2CH","26","17","17","ⴰⴽⴻⵀⵀⴰⵏ ⵄⴰⵣⴰⵔⵢⴰ ⵢⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵓ ⵓⵢⵓⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R226_18","015_26_18","2CH","26","18","18","ⵏⵉⵜⵏⵉ ⵇⴰⵟⵄⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⵄⵓⵣⵣⵉⵢⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⵛⴻⴽ ⵉⵛⵓⵡⵡⴰⵔ, ⵄⵓⵣⵣⵉⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⵍⴻⴱⵅⵓⵔ ⵉ ⵙⵉⴷⵉ, ⵎⵖⵉⵔ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⵅⵓⵔ. ⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴻⵖⴷⴰⵔⴻⴷ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⴷⴷ-ⵉⵜⵜⵉⵡⵉ ⵛⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("R226_19","015_26_19","2CH","26","19","19","ⵅⴻⵏⵏⵉ ⵉⵙⵄⴰⵔ ⵄⵓⵣⵣⵉⵢⴰ ⴰⵎ ⵉⵟⵟⴻⴼ ⵍⴻⴱⵅⵓⵔ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⵅⵓⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⴰⵎ ⵉⵙⵄⴰⵔ ⴰⵎⵎⵓ ⵅ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⴼⴼⴻⵖ ⴰⵙ ⴷⴷ-ⵍⴱⴰⵔⵚ ⴷⵉ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ, ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("R226_20","015_26_20","2CH","26","20","20","ⵓⵎⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵄⴰⵣⴰⵔⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵖⴰⵔⴻⵙ, ⴰⵇⴰ ⴷⴰ, ⴷⴰⵢⴻⵙ ⵍⴱⴰⵔⵚ ⴷⵉ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵃⵙⴰⵔⴻⵏ ⵜ ⴷⴻⵖⵢⴰ ⴰⴷ ⵙⵙⴻⵏⵏⵉ ⵢⴰⴳⴳⵯⴻⵊ, ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴵⴻⵇ ⴰⴷ ⵉⴼⴼⴻⵖ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("R226_21","015_26_21","2CH","26","21","21","ⵜⵓⵖⴰ ⴰⵊⴻⴵⵉⴷ ⵄⵓⵣⵣⵉⵢⴰ ⵉⵀⵍⴻⵛ ⵙ ⵍⴱⴰⵔⵚ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵄⵣⴻⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵎⵎⵉⵙ ⵢⵓⵜⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⴻⵎ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R226_22","015_26_22","2CH","26","22","22","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⴰⵇⴰ ⵉⵣⴻⵎⵎ ⵉ-ⵜⴻⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ. ");
INSERT INTO rift_vpl VALUES ("R226_23","015_26_23","2CH","26","23","23","ⵄⵓⵣⵣⵉⵢⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍⴱⴰⵔⵚ!” ⵎⵎⵉⵙ ⵢⵓⵜⴰⵎ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R227_1","015_27_1","2CH","27","1","1","ⵢⵓⵜⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵔⵓⵛⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵚⴰⴷⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("R227_2","015_27_2","2CH","27","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⵄⵓⵣⵣⵉⵢⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵛⴰ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ. ⵍⴳⴻⵏⵙ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R227_3","015_27_3","2CH","27","3","3","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵜⴰⵡⵡⴰⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵓⵍⴰ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⵄⵓⴼⵉⵍ ⵉⴱⵏⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R227_4","015_27_4","2CH","27","4","4","ⵉⴱⵏⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⴻⴳ ⵉⵣⴻⵖⵔⴰⵏ ⵉⴱⵏⴰ ⵍⵇⴻⵍⵄⴰⵜ ⴷ ⵚⵚⵓⵎⵄⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("R227_5","015_27_5","2CH","27","5","5","ⵏⴻⵜⵜⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵉⵖⵍⴻⴱ ⵅⴰⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵙⵙⵉⵡⴹⴻⵏ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⵄⴰⴷ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵉⵔⴷⴻⵏ ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ⵓⵍⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵙⵙⵉⵡⴹⴻⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("R227_6","015_27_6","2CH","27","6","6","ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵢⵓⵜⴰⵎ ⵉⵊⵀⴻⴷ, ⵎⴰⵖⴰⵔ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R227_7","015_27_7","2CH","27","7","7","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵜⴰⵎ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵖⴰⵏ ⵉ ⵉⵎⵎⵏⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R227_8","015_27_8","2CH","27","8","8","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R227_9","015_27_9","2CH","27","9","9","ⵢⵓⵜⴰⵎ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ⵎⵎⵉⵙ ⴰⵃⴰⵣ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R228_1","015_28_1","2CH","28","1","1","ⴰⵃⴰⵣ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵙⴻⵟⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R228_2","015_28_2","2CH","28","2","2","ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵄⴰⵡⴻⴷ ⵉⴳⴳⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("R228_3","015_28_3","2CH","28","3","3","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⴻⴱⵅⵓⵔ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⴱⵉⵏ-ⵀⵉⵏⵏⵓⵎ ⵓ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⵉ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵅⴻⴼ ⵢⵓⵥⵥⴻⵍ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R228_4","015_28_4","2CH","28","4","4","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ-ⴷⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵓ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵓ ⵙⴰⴷⵓ ⵎⴰⵔⵔⴰ ⴰⵣⵖⴰⵔ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("R228_5","015_28_5","2CH","28","5","5","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⵉ-ⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵜ ⵓ ⵃⴻⴱⴱⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵉⵎⵖⴰⵔ ⵓ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ. ⵉⵎⵎⴻⵡⵛ ⴰⵃⴰⵣ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵡⵜⵉⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R228_6","015_28_6","2CH","28","6","6","ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⵉⵏⵖⴰ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R228_7","015_28_7","2CH","28","7","7","ⵣⵉⴽⵔⵉ, ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵏⵖⴰ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴷ ⵄⴰⵣⵔⵉⵇⴰⵎ, ⴰⵎⴻⵃⴹⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴷ ⵉⵍⵇⴰⵏⴰ, ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R228_8","015_28_8","2CH","28","8","8","ⵏⴻⴷⵀⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ-ⴰⵍⴻⴼ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵓ ⵟⵟⴼⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵉⵡⵢⴻⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⵉ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R228_9","015_28_9","2CH","28","9","9","ⴷⵉⵏⵏⵉ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵏ ⵙⵉⴷⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⵓⴷⵉⴷ. ⵡⴰⵏⵉⵜⴰ ⵉⴼⴼⴻⵖ, ⵉⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵙ ⵡⴻⵙⵄⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵅ ⵢⴰⵀⵓⴷⴰ, ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⵖⵉⵎ ⵜⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵙⵅⴻⴹ ⵢⵉⵡⴻⴹ ⴰⵍ ⴰⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R228_10","015_28_10","2CH","28","10","10","ⵓ ⵍⴻⵅⵅⵓ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⴰⵎ ⵢⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ. ⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⴹⴼⴰⵔ ⵅⴻⵏⵏⵉ ⵓⵎⴰⵔⵡⴰⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("R228_11","015_28_11","2CH","28","11","11","ⵙⵍⴻⵎ-ⴷⴷ ⵍⴻⵅⵅⵓ ⵖⴰⵔⵉ ⵓ ⴰⵔⵔⴻⵎ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⵉ ⵜⵃⴻⴱⴱⵙⴻⵎ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵅⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("R228_12","015_28_12","2CH","28","12","12","ⵅⴻⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ ⵣⴻⴳ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⴻⴳⴳⵯⴻⵃⴻⵏ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ: ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵃⴰⵏⴰⵏ, ⴱⴰⵔⴰⵅⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵉⵍⵍⵉⵎⵓⵜ, ⵃⵉⵣⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⵍⵓⵎ, ⴷ ⵄⴰⵎⴰⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵀⵉⴷⵍⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("R228_13","015_28_13","2CH","28","13","13","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⵉⵎⴻⵃⴱⴰⵙ ⴷⴰⵏⵉⵜⴰ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵏⴻⵖ ⴷⴷ-ⴰⵔⴻⵏⵢⴻⵏ ⴰⵎⴰⵔⵡⴰⵙ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴰⵔⵏⵉ ⵄⴰⴷ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⴷ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵖ, ⵡⴰⵅⵅⴰ ⵄⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵔⵡⵓⵙⴰ ⵓ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⵅ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("R228_14","015_28_14","2CH","28","14","14","ⵅⴻⵏⵏⵉ ⵙⴻⵎⵃⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⴷⴻⴳ ⵉⵎⴻⵃⴱⴰⵙ ⴷ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵣⵣⴰⵜ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R228_15","015_28_15","2CH","28","15","15","ⵉⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰⵏ ⵇⴱⴻⵍ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵀⴻⵍⵍⴰⵏ ⴷⴻⴳ ⵉⵎⴻⵃⴱⴰⵙ. ⵏⵉⵜⵏⵉ ⵙⵙⵢⴰⵔⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷ ⵉⵄⴰⵔⵢⴰⵏⴻⵏ ⵙ ⵡⴰⵔⵔⵓⴹ ⵣⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ, ⵙⵙⵢⴰⵔⴹⴻⵏ ⵜⴻⵏ ⵙ ⵡⴰⵔⵔⵓⴹ ⴷ ⵜⵙⵉⵍⴰ ⵓ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⴰⴷ ⵛⵛⴻⵏ, ⴰⴷ ⵙⵡⴻⵏ. ⵄⴰⵡⴻⴷ ⴷⴻⵀⵏⴻⵏ ⵜⴻⵏ ⵓⵛⴰ ⵙⵙⵖⵉⵎⴻⵏ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ ⵜⵜⴻⵏⵇⴰⵔⴹⴻⵏ ⵅ ⵢⴻⵖⵢⴰⵍ ⵓ ⴰⵎⵎⵓ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵖⴰⵔ ⴰⵔⵉⵃⴰ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵖⴰⵔ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R228_16","015_28_16","2CH","28","16","16","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵃⴰⵣ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R228_17","015_28_17","2CH","28","17","17","ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⵓⵙⵉⵏ-ⴷⴷ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵏⴻⴷⵀⴻⵏ ⵜⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("R228_18","015_28_18","2CH","28","18","18","ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵀⴻⵊⵎⴻⵏ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⴷ ⵍⵊⴰⵏⵓⴱ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⴱⴰⵢⵜ-ⵛⴰⵎⵙ, ⴰⵢⵢⴰⵍⵓⵏ, ⵊⴰⴷⵉⵔⵓⵜ, ⵙⵓⴽⵓ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵜⵉⵎⵏⴰⵀ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴷ ⵊⵉⵎⵣⵓ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓⵛⴰ ⵣⴻⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R228_19","015_28_19","2CH","28","19","19","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵀⵡⴰ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴰⵃⴰⵣ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴼⴼⵓⵛⵛⴻⵃ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵉⵖⴷⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R228_20","015_28_20","2CH","28","20","20","ⵜⵉⵖⵍⴰⵜ-ⴼⵉⵍⵏⴰⵙⵉⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵅⴰⵙ ⴱⴻⵣⵣⴻⵣ ⵓ ⵡⴰⵔ ⵜ ⵉⵙⵙⴻⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("R228_21","015_28_21","2CH","28","21","21","ⵎⴰⵖⴰⵔ ⵄⴰⴷ ⵎⴰⵍⴰ ⴰⵃⴰⵣ ⵉⴽⵙⵉ ⴰⴳⵍⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ, ⵉⵡⵛⴰ ⴰⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵏⴻⴼⴼⵉⵄ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("R228_22","015_28_22","2CH","28","22","22","ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ, ⵢⴰⵔⵏⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵄⴰⴷ ⴷⵉ ⵍⵖⴻⴷⵔⴰⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R228_23","015_28_23","2CH","28","23","23","ⵏⴻⵜⵜⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⴷⵉⵎⴰⵛⵇ, ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵖⴻⵍⴱⴻⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵔⴰⵎ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⴰⴼⵓⵙ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⴻⵀⵀⴱⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵄⴰⵡⴻⴷ.” ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵙ ⵓ ⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R228_24","015_28_24","2CH","28","24","24","ⴰⵃⴰⵣ ⵉⵙⵙⵎⵓⵏ ⵍⴻⵇⵛⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵢⴰⵔⵥⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓⵛⴰ ⵉⴱⴻⵍⵍⴻⵄ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⴽⵓⵍ ⵜⴰⵖⵎⴰⵔⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R228_25","015_28_25","2CH","28","25","25","ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵄⴰⵔ ⵏⴻⵜⵜⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R228_26","015_28_26","2CH","28","26","26","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R228_27","015_28_27","2CH","28","27","27","ⴰⵃⴰⵣ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵛⴰ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⵎⵉⵙ ⵃⵉⵣⵇⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R229_1","015_29_1","2CH","29","1","1","ⵃⵉⵣⵇⵉⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⴱⵉⵢⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R229_2","015_29_2","2CH","29","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("R229_3","015_29_3","2CH","29","3","3","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵢⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵄⴷⴻⵍ ⵉ-ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R229_4","015_29_4","2CH","29","4","4","ⵉⵙⵙⵉⴷⴻⴼ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏ ⵅ ⵡⴰⵣⵣⴰⵢ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("R229_5","015_29_5","2CH","29","5","5","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵍⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓ ⴽⴽⵙⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_6","015_29_6","2CH","29","6","6","ⵎⴰⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⵓ ⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅⴰⵙ, ⵏⵏⵇⴻⵍⴱⴻⵏ ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⵔⵔⵉⵏ ⵙ ⵡⴻⵄⵔⵓⵔ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_7","015_29_7","2CH","29","7","7","ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⴱⴻⵍⵍⵄⴻⵏ ⵜⴻⵏⵜ, ⵙⵙⵅⴻⵙⵢⴻⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ, ⵡⴰⵔ ⵙⵙⴰⵔⵖⴻⵏ ⵍⴻⴱⵅⵓⵔ ⵓ ⵡⴰⵔ ⵙⵙⴳⵉⵄⵄⴷⴻⵏ ⵄⴰⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_8","015_29_8","2CH","29","8","8","ⵙ ⵓⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⴷⵓⵇⵇⴻⵣ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵓⵙⵉⴳⴳⵯⴻⴷ ⴷ ⵜⵙⴻⴹⵃⴰⵛⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R229_9","015_29_9","2CH","29","9","9","ⵅⵣⴰⵔⴻⵎ, ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ, ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵅ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R229_10","015_29_10","2CH","29","10","10","ⵍⴻⵅⵅⵓ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔⵉ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⴱⴻⵄⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("R229_11","015_29_11","2CH","29","11","11","ⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⴰⵔⴻⵅⵅⵓⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵓ ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵙ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⴰⵙ ⵜⵇⴻⴷⴷⵎⴻⵎ ⵍⴻⴱⵅⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("R229_12","015_29_12","2CH","29","12","12","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⵎⴰⵃⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⴰⵙⴰⵢ, ⴷ ⵢⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵇⵓⵃⴰⵜ. ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵇⵉⵙ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⴷⵉ, ⴷ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵍⴰⵢⵉⵍ. ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵊⴰⵔⵛⵓⵏ, ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵏ ⵣⵉⵎⵎⴰ, ⴷ ⵄⵉⴷⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵅ. ");
INSERT INTO rift_vpl VALUES ("R229_13","015_29_13","2CH","29","13","13","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵍⵉⵚⴰⴼⴰⵏ, ⵛⵉⵎⵔⵉ ⴷ ⵢⴰⵄⵉⵢⵉⵍ, ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵙⴰⴼ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⴷ ⵎⴰⵜⵜⴰⵏⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R229_14","015_29_14","2CH","29","14","14","ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵢⵎⴰⵏ, ⵢⴰⵃⵉⵢⵉⵍ ⴷ ⵛⵉⵎⵄⵉ, ⵓ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵢⴰⴷⵓⵜⵓⵏ, ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⵄⵓⵣⵣⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R229_15","015_29_15","2CH","29","15","15","ⵏⵉⵜⵏⵉ ⵙⵙⵎⵓⵏⴻⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵓⵛⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵡⴻⵏⵏⵉ ⵉⵄⴻⵎⵎⴷⴻⵏ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_16","015_29_16","2CH","29","16","16","ⵓⴷⴼⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓⵛⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵎⴻⵊ ⵉ ⵓⴼⵉⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴽⵙⵉⵏ ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_17","015_29_17","2CH","29","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴱⴷⴰⵏ ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵓⵢⵓⵔ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴻⵙⵇⵉⴼ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵙⵉⴷⵉ. ⴰⵎⵎⵓ ⵉ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⵟⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R229_18","015_29_18","2CH","29","18","18","ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⵉⵣⴷⴻⴳ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵣⴻⵡⴹⴰ ⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R229_19","015_29_19","2CH","29","19","19","ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⵏⴹⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵣ ⵣⵉ ⵍⴻⵖⴷⴰⵔ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ, ⵏⴻⵄⴷⴻⵍ ⵉ-ⵜⴻⵏ ⵓ ⵏⴻⵙⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏ. ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("R229_20","015_29_20","2CH","29","20","20","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵣⵉⵛ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_21","015_29_21","2CH","29","21","21","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵓⵢⴰⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵜⴳⴻⵍⴷⵉⵜ, ⵍⴰ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⵉ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵇⴻⴷⴷⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_22","015_29_22","2CH","29","22","22","ⵖⴰⵔⵚⴻⵏ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵓⵛⴰ ⵙⵙⴻⵍⵇⴰⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵔⵓⵛⵛⴻⵏ ⵜⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⵏⵉⵜⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵓⵍⴰ ⵉ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⵖⴰⵔⵚⴻⵏ ⵓⵍⴰ ⵉ ⵉⵣⵎⴰⵔⴻⵏ ⵓⵛⴰ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R229_23","015_29_23","2CH","29","23","23","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵎⵓⵢⴰⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_24","015_29_24","2CH","29","24","24","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵖⴰⵔⵚⴻⵏ ⴰⵙⴻⵏ ⵓ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⴰⵄⴰⵍⵟⴰⵔ ⵣⵉ ⴷⴷⴻⵏⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⵚⵍⴰⵃ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R229_25","015_29_25","2CH","29","25","25","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵙ ⵜⴰⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⴷ ⵍⵀⴰⵔⴱⴰⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵊⴰⴷ, ⴰⵎⵡⴰⵍⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴷ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ, ⵎⵉⵏⵣⵉ ⵍⵓⵎⵓⵔ-ⴰ ⵜⵓⵖⴰ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵣⵉ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_26","015_29_26","2CH","29","26","26","ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ ⴰⴽ-ⴷ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽ-ⴷ ⵍⴻⴱⵡⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("R229_27","015_29_27","2CH","29","27","27","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵜⴻⴱⴷⴰ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⴱⴷⴰ ⵓⵍⴰ ⴷ ⴰⵣⴻⵀⵀⴻⴷ ⵉ ⵙⵉⴷⵉ ⵙ ⵍⴻⴱⵡⴰⵇ ⵓ ⵙ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R229_28","015_29_28","2CH","29","28","28","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵉⴱⴻⵏⴷⴻⵇ, ⴰⵎ ⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ ⵓ ⵜⵜⵙⵓⴹⴰⵏ ⴷⵉ ⵍⴻⴱⵡⴰⵇ. ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⴽⴽⴰ ⴰⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("R229_29","015_29_29","2CH","29","29","29","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵓⵙⵉⵡⴻⴹ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉⵡⴹⴰ ⵓⵊⴻⴵⵉⴷ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_30","015_29_30","2CH","29","30","30","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⴷ ⵙⵙⵄⵓⴵⴰⵏ ⵙⵉⴷⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵏ ⵓⵎⵡⴰⵍⴰⵡ ⴰⵙⴰⴼ. ⵙⵙⵄⵓⴵⴰⵏ ⵄⴰⴷ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵅⴻⵏⵏⵉ ⵓⴹⴰⵔⴻⵏ ⵓⵛⴰ ⴱⴻⵏⴷⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_31","015_29_31","2CH","29","31","31","ⵃⵉⵣⵇⵉⵢⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵎ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵙⵉⴷⵉ. ⴰⵙⴻⵜⵜⵉⵡ-ⴷⴷ ⵓⵛⴰ ⴰⵡⵢⴻⵎ-ⴷⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵇⴰⴷⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ⵅⴰⵙ ⵓⵛⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵇⴰⴷⵉ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰⵔ ⵜⵜ ⵜⵓⵖⴰ ⴷⵉ ⵍⵅⴰⴷⴰⵔ ⵏⵙⴻⵏ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("R229_32","015_29_32","2CH","29","32","32","ⵍⵇⴻⴷⴷ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⴷⴷ-ⵢⵉⵡⵉ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵎⵢⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵡⵢⴻⵏ-ⴷⴷ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_33","015_29_33","2CH","29","33","33","ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_34","015_29_34","2CH","29","34","34","ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⴷⵔⵓⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴰⵔⵅⵓⵏ ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ. ⵙ ⵓⵢⴰ ⵄⴰⵡⵏⴻⵏ ⵜⴻⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵓ ⴰⵍⴰⵎⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵙⴻⴳⴳⴷⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R229_35","015_29_35","2CH","29","35","35","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⴽ-ⴷ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ. ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⵄⴷⴻⵍ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R229_36","015_29_36","2CH","29","36","36","ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴼⴰⵔⵃⴻⵏ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴳⴻⵏⵙ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("R230_1","015_30_1","2CH","30","1","1","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵙⵙⴻⴽⴽ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⵓ ⵢⵓⵔⴰ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴳⴳⴻⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R230_2","015_30_2","2CH","30","2","2","ⵎⴰⵖⴰⵔ ⵉⵎⵛⴰⵡⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R230_3","015_30_3","2CH","30","3","3","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵛⴰ ⴰⵎ ⴷⴷ-ⵉⵜⵜⵍⵉⵇ, ⵓ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⵎⵓⵏ ⵄⴰⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R230_4","015_30_4","2CH","30","4","4","ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵜⵓⵖⴰ-ⵜⵜ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R230_5","015_30_5","2CH","30","5","5","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⴷⴰⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵜ ⴳⴳⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R230_6","015_30_6","2CH","30","6","6","ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⴽⴽⵉⵏ ⵙ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵓ ⴱⴰⵔⵔⵃⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ: “ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵙⵃⴰⵇ ⴷ ⵉⵙⵔⴰⵉⵍ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_7","015_30_7","2CH","30","7","7","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴷ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵉⵏⵏⵉ ⵉⵖⴷⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵉⵙⴻⵍⵍⴻⵎ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵓⵏⴻⵅⵍⵉⵄ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("R230_8","015_30_8","2CH","30","8","8","ⵡⴰⵔ ⵙⵙⴻⵇⵙⴰⵃⴻⵎ ⵍⴻⵅⵅⵓ ⵉⵔⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵉⵍⵉⵎ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ⵡⵛⴻⵎ ⴰⴼⵓⵙ ⵉ ⵙⵉⴷⵉ ⵓ ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵜⴻⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵏⴻⵜⵜⴰ ⵉ ⵍⴻⴱⴷⴰ. ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵃⴻⵢⵢⴻⴷ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R230_9","015_30_9","2CH","30","9","9","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴰⴼⴻⵏ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ. ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴷ ⴱⴰⴱ ⵏ ⵓⵃⵉⵏⵏⵉ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵙⵙⵃⴻⵢⵢⵉⴷ ⵛⴰ ⵓⴷⴻⵎ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("R230_10","015_30_10","2CH","30","10","10","ⴰⵎⵎⵓ ⵉ ⵓⵢⵓⵔⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴽⴽⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ ⴰⵍ ⵣⴰⴱⵓⵍⵓⵏ, ⵎⴰⵛⴰ ⵉⵡⴷⴰⵏ ⵃⴻⵛⵛⴻⵏ ⵅⴰⵙⴻⵏ ⵓ ⴽⴽⵡⴰⵔⴻⵏ ⵜⴻⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_11","015_30_11","2CH","30","11","11","ⵎⴰⵛⴰ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⴰⵛⵉⵔ, ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵣⴰⴱⵓⵍⵓⵏ ⵙⵙⵡⴰⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R230_12","015_30_12","2CH","30","12","12","ⵓⵍⴰ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵉⵏⴷⴻⵀ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵙ ⵡⵓⵍ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_13","015_30_13","2CH","30","13","13","ⵎⵓⵏⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵡⴷⴰⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵢⵢⴷⴻⵏ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R230_14","015_30_14","2CH","30","14","14","ⵏⵉⵜⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵓ ⴽⴽⵙⴻⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴽⴽⵙⴻⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴷⵉ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_15","015_30_15","2CH","30","15","15","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵖⴰⵔⵚⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵡⴹⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵓ ⴱⴷⴰⵏ ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R230_16","015_30_16","2CH","30","16","16","ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴳⴳⵓⵔ ⵖⴰⵔⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⴽⵙⵉⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_17","015_30_17","2CH","30","17","17","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵡⴰⵔ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵙ ⵓⵢⴰ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵅ ⵜⵖⴰⵔⵚⵜ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴷⵉⴳⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R230_18","015_30_18","2CH","30","18","18","ⵎⴰⵖⴰⵔ ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵣⵣⴰⵢⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⵙⵙⴰⴽⴰⵔ ⴷ ⵣⴰⴱⵓⵍⵓⵏ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ. ⵎⴰⵛⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵥⵥⵓⴵ ⵉ ⵏⵉⵜⵏⵉ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵛⵏⴰ, ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵏⵉⵜⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("R230_19","015_30_19","2CH","30","19","19","ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵏⵡⴰⵏ ⴰⴷ ⵢⴰⵔⵣⵓ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ ⵅ ⴰⵔⴻⴱⴱⵉ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵙⵉⵣⴷⴻⴳ ⵉ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R230_20","015_30_20","2CH","30","20","20","ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⵖⴰⵍ ⵃⵉⵣⵇⵉⵢⴰ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R230_21","015_30_21","2CH","30","21","21","ⴰⵎⵎⵓ ⵉ ⵄⴻⵢⵢⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⵢⴰⵔⵡⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙⵙⵄⵓⴵⴰⵏ ⵙⵉⴷⵉ ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R230_22","015_30_22","2CH","30","22","22","ⵉⵙⵙⵉⵡⴻⵍ ⵃⵉⵣⵇⵉⵢⴰ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⵎⴰⵔⵔⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵛⵏⴰⵏ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉ. ⵛⵛⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵍⵄⵉⴷ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⵓ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_23","015_30_23","2CH","30","23","23","ⵓⵎⵉ ⵉⵎⵛⴰⵡⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵔⵏⵉⵏ ⵏⵉⵜⵏⵉ ⵄⴰⴷ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("R230_24","015_30_24","2CH","30","24","24","ⵎⴰⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ ⵓⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵜⵓⵖⴰ ⵡⵛⵉⵏ ⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ. ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R230_25","015_30_25","2CH","30","25","25","ⵉⴼⴰⵔⵃ ⵎⴰⵔⵔⴰ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵓⵍⴰ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R230_26","015_30_26","2CH","30","26","26","ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⴰⵎ ⵓⵢⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R230_27","015_30_27","2CH","30","27","27","ⵅⴻⵏⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴱⴰⵔⴽⴻⵏ ⵍⴳⴻⵏⵙ. ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ, ⵎⴰⵖⴰⵔ ⵜⴰⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵜⵓⴷⴻⴼ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵜⴰⵎⵇⴻⴷⴷⴻⵙⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R231_1","015_31_1","2CH","31","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴰⵔⵥⵉⵏ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵀⴻⴷⵎⴻⵏ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⵍⴻⴳⵄⵓⴷⵉ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵓⵍⴰ ⴷⵉ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⴰⵏⴰⵙⵙⴰ ⴰⵍⴰⵎⵉ ⵜⵜ ⴽⴻⵎⵎⵍⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵄⴻⵇⴱⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R231_2","015_31_2","2CH","31","2","2","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵄⵍⴰⵃⵚⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ: ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⴰⴷ ⵇⴰⴷⴰⵏ ⵓ ⴰⴷ ⵙⵙⵄⵓⴵⴰⵏ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R231_3","015_31_3","2CH","31","3","3","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵓⵍⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵓⵍⴰ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ, ⵉ ⵓⵢⵓⵔⴻⵏ ⵉⵎⴰⵢⵏⵓⵜⴻⵏ ⵓ ⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R231_4","015_31_4","2CH","31","4","4","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ, ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⵡⴻⵀⵀⴱⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⵉⵏⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵊⴻⵀⴷⴻⵏ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R231_5","015_31_5","2CH","31","5","5","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵏⵏⵉ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵣⴻⴳ ⵓⵙⵓⴼⴼⴻⵖ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵉⵎⴻⵏⴷⵉ, ⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵢⴻⵢⵢⴰⵔ. ⵉⵡⵢⴻⵏ ⵓⵍⴰ ⴷ ⵍⴻⵄⵛⵓⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵙ ⵓⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("R231_6","015_31_6","2CH","31","6","6","ⵜⴰⵔⵡⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵡⵢⴻⵏ ⵓⵍⴰ ⴷ ⵍⴻⵄⵛⵓⵔ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵓ ⵣⴻⴳ ⵡⵓⴵⵉ ⵓⵍⴰ ⴷ ⵍⴻⵄⵛⵓⵔ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵡⵛⵉⵏ ⵜⴻⵏ, ⴳⴳⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵄⵓⵔⵔⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("R231_7","015_31_7","2CH","31","7","7","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴱⴷⴰⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⴻⵏ ⵉⵄⵓⵔⵔⴰⵛ ⵣⵉ ⵜⵉⵙⵉ ⵓ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("R231_8","015_31_8","2CH","31","8","8","ⵓⵎⵉ ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵓⵙⵉⵏ-ⴷⴷ ⵓ ⵥⵔⵉⵏ ⵉⵄⵓⵔⵔⴰⵛ ⵏⵏⵉ, ⴱⴰⵔⴽⴻⵏ ⵙⵉⴷⵉ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R231_9","015_31_9","2CH","31","9","9","ⵉⵙⵙⴻⵇⵙⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵅ ⵉⵄⵓⵔⵔⴰⵛ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("R231_10","015_31_10","2CH","31","10","10","ⵄⴰⵣⴰⵔⵢⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵚⴰⴷⵓⵇ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵏⴻⴽⴽⴰⵔ ⴰⴷ ⵏⴰⵡⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⵏⴻⵛⵛ ⴰⵍ ⵜⵢⴰⵡⴰⵏⵜ ⵓⵛⴰ ⵄⴰⴷ ⵉⵇⵇⵉⵎ ⴰⵟⵟⴰⵙ ⵉⵛⴻⵟⵟ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵉⵇⵇⵉⵎ ⵍⵇⴻⴷⴷ-ⴰ ⵏ ⵡⴰⵟⵟⴰⵙ ⵉⵛⴻⵟⵟ.” ");
INSERT INTO rift_vpl VALUES ("R231_11","015_31_11","2CH","31","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓ ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R231_12","015_31_12","2CH","31","12","12","ⵏⵉⵜⵏⵉ ⵙⵙⵉⴷⴼⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴷ ⵍⴻⵄⵛⵓⵔ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉⵏ ⵙ ⵍⴰⵎⴰⵏ. ⴽⵓⵏⴰⵏⵢⴰ, ⴰⵍⴰⵡⵉ, ⴰⵎⴻⵃⴹⴰⵢ, ⴷ ⵓⵎⴰⵙ ⵛⵉⵎⵄⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R231_13","015_31_13","2CH","31","13","13","ⵢⴰⵃⵉⵢⵉⵍ, ⵄⴰⵣⴰⵣⵢⴰ, ⵏⴰⵃⴰⵜ, ⵄⴰⵙⴰ’ⵉⵍ, ⵢⴰⵔⵉⵎⵓⵜ, ⵢⵓⵣⴰⴱⴰⴷ, ⵉⵍⵉⵢⵉⵍ, ⵢⵉⵙⵎⴰⵅⵢⴰ, ⵎⴰⵃⴰⵜ, ⴱⴰⵏⴰⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⴽⵓⵏⴰⵏⵢⴰ ⴷ ⵛⵉⵎⵄⵉ, ⵓⵎⴰⵙ, ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵓ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⴰⵎⴻⵃⴹⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R231_14","015_31_14","2CH","31","14","14","ⵇⵓⵔⵉ, ⵎⵎⵉⵙ ⵏ ⵢⵉⵎⵏⴰ, ⴰⵍⴰⵡⵉ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ, ⵉⵜⵜⵡⴰⴳⴳ ⵅ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴹⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("R231_15","015_31_15","2CH","31","15","15","ⵄⴰⴷⴰⵏ, ⵎⵉⵏⵢⴰⵎⵉⵏ, ⵢⴻⵛⵓⵄⴰ, ⵛⴰⵎⵄⵉⵢⴰ, ⴰⵎⴰⵔⵢⴰ ⴷ ⵛⴰⴽⵓⵏⵢⴰ ⴱⴻⴷⴷⴻⵏ ⵙ ⵍⵎⴰⵏⴻⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵚⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵡⴻⵣⵣⵄⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵎ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⴰⵎ ⵉ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R231_16","015_31_16","2CH","31","16","16","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴽⵓⵍ ⴰⵙⵙ ⵉ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R231_17","015_31_17","2CH","31","17","17","ⴰⵣⴻⵎⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ-ⵜ ⵄⵍⴰⵃⵚⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⴰⵣⴻⵎⵎⴻⵎ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ, ⵜⵓⵖⴰ-ⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R231_18","015_31_18","2CH","31","18","18","ⵏⵉⵜⵏⵉ ⵡⴻⵣⵣⵄⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵙ ⵍⴰⵎⴰⵏ ⵓⵎⵉ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("R231_19","015_31_19","2CH","31","19","19","ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵎⴰⵔⵔⴰ ⴰⵡⵜⴻⵎ ⵊⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵊⴰⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R231_20","015_31_20","2CH","31","20","20","ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵃⵉⵣⵇⵉⵢⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵛⵏⴰⵏ ⴷ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴷ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R231_21","015_31_21","2CH","31","21","21","ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵉⴱⴷⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⴰⵎⵎⵓ ⴰⵔⴻⴱⴱⵉ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴼⵍⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("R232_1","015_32_1","2CH","32","1","1","ⴰⵡⴰⵔⵏⵉ ⵜⴻⵎⵙⴰⵔⵉⵏ-ⴰ ⴷ ⵡⴻⵙⵛⴰⵏ-ⴰ ⵏ ⵍⴰⵎⴰⵏ, ⵢⵓⵙⴰ-ⴷⴷ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ, ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴰⴷ ⵜⴻⵏⵜ ⵉⵟⵟⴻⴼ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R232_2","015_32_2","2CH","32","2","2","ⵉⵥⵔⴰ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵇⴰ ⵙⴰⵏⵃⴰⵔⵉⴱ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵉⵏⵡⴰ ⴰⴷ ⵉⵃⵊⴻⵎ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R232_3","015_32_3","2CH","32","3","3","ⵏⴻⵜⵜⴰ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵜⵢⴻⵏ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵙ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R232_4","015_32_4","2CH","32","4","4","ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵏⴻⵜⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵍⴰⵡⵉⵏ ⵓⵍⴰ ⴷ ⵜⴻⵖⵣⴰⵔⵜ ⵉ ⴷ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵏⴰⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ ⵓⵛⴰ ⴰⴷ ⴰⴼⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("R232_5","015_32_5","2CH","32","5","5","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵜⴰⵏⴷⵉⵏⵜ, ⵉⵄⴷⴻⵍ ⵎⴰⵔⵔⴰ ⵍⵃⵉⴹ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵔⵥⴻⵏ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴰⵍ ⵚⵚⵓⵎⵄⴰⵜ. ⵓ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵉⵄⴷⴻⵍ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵏⵏⴻⵖⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵍⵇⴻⵍⵄⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⴰⵏⵙⴰⵜ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("R232_6","015_32_6","2CH","32","6","6","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵅ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵍⴰⵎⵉ ⴷⴰⵢⵙⴻⵏ ⵉⴳⴳⴰ ⵓⵍ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R232_7","015_32_7","2CH","32","7","7","“ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⵉⵍⵉⵎ ⵜⵎⴻⵃⴹⴻⵎ, ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵓⵍⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵅ ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R232_8","015_32_8","2CH","32","8","8","ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵖⴰⵔⵏⴻⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵡⵛ ⴰⴼⵓⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⵎⴻⵏⵖⵉ ⵏⵏⴻⵖ.” ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵜⵜⴻⵛⵛⴻⵍ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R232_9","015_32_9","2CH","32","9","9","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⴻⴽⴽ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵣⵣⴰⵜ ⵉ ⵍⴰⵅⵉⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R232_10","015_32_10","2CH","32","10","10","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ‘ⵎⵉⵏ ⵅⴻⴼ ⵜᵉⵜⵜⴻⵛⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵣⴻⵄⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("R232_11","015_32_11","2CH","32","11","11","ⵎⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵖⵡⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⴻⵍⵍⴻⵎ ⵉ ⵍⵎⴻⵡⵜ ⵣⵉ ⵍⴰⵥ ⴷ ⵓⴼⴰⴷⵉ ⵅⵎⵉ ⵉⵇⵇⴰⵔ: ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ!? ");
INSERT INTO rift_vpl VALUES ("R232_12","015_32_12","2CH","32","12","12","ⵎⴰ ⵡⴰⵔ ⵉⴽⴽⵉⵙ ⵃⵉⵣⵇⵉⵢⴰ ⵏⵏⵉ ⵓⵍⴰ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⴻⵙ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⴰ: ⵎⵖⵉⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵜⴱⴻⵏⴷⵇⴻⵎ ⵓ ⴰⴷ ⵅⴰⵙ ⵜⴰⵡⵢⴻⵎ ⵍⴻⴱⵅⵓⵔ!? ");
INSERT INTO rift_vpl VALUES ("R232_13","015_32_13","2CH","32","13","13","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵎⵉⵏ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⴷ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ? ⵎⴰ ⴼⴻⴽⴽⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("R232_14","015_32_14","2CH","32","14","14","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵅ ⵇⴹⴰⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰⵍⴰⵎⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("R232_15","015_32_15","2CH","32","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵛⵎⴻⵜ ⵓ ⵡⴰⵔ ⵜ ⵜⵜⴻⵊⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵖⴻⴽⴽⵡⵉ ⴰⵎⵎⵓ. ⵡⴰⵔ ⵜᵉⵜⵜⵉⵇⵇⴰⵎ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵎⴰⵏ ⵎⴰ ⵍⴳⴻⵏⵙ ⵏⵉⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴻⴽⴽ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵏⵉⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ. ⵎⴻⵛⵃⴰⵍ ⵇⴻⵍⵍ ⵄⴰⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("R232_16","015_32_16","2CH","32","16","16","ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⴹⵉⴷⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵃⵉⵣⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R232_17","015_32_17","2CH","32","17","17","ⵏⴻⵜⵜⴰ ⵢⵓⵔⴰ ⵄⴰⵡⴻⴷ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵢⵙⴻⵏⵜ, ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("R232_18","015_32_18","2CH","32","18","18","ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵜⵢⴰⵀⵓⴷⴻⵛⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵍⵃⵉⴹ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⵅⴰⵔⴻⵡⴹⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R232_19","015_32_19","2CH","32","19","19","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎ ⵅ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵎⵖⵉⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⵡⴷⴰⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R232_20","015_32_20","2CH","32","20","20","ⴰⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵥⵥⵓⴵⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("R232_21","015_32_21","2CH","32","21","21","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ, ⵡⴻⵏⵏⵉ ⵉⵇⴹⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ⵅⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵙ ⵍⴻⵃⵢⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ. ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵏⵖⵉⵏ ⵜ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("R232_22","015_32_22","2CH","32","22","22","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵙⵉⴷⵉ ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R232_23","015_32_23","2CH","32","23","23","ⴰⵟⵟⴰⵙ ⵉ ⴷⴷ ⵢⵉⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵍⴰ ⴷ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵙⵙⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⴻⵡⵇⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("R232_24","015_32_24","2CH","32","24","24","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵀⵍⴻⵛ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⴰⵛ ⵉⵏⴻⵇⵇⴻⵏ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⵎⵎⴻⵜ. ⵉⵥⵥⵓⴵ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ-ⴷⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("R232_25","015_32_25","2CH","32","25","25","ⵎⴰⵛⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵛⵓⵏⵉ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵓⵍ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⴷⴰⵢⴻⵙ ⵏⵏⴼⴰⵅⴻⵜ. ⵅ ⵓⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵅⴰⵙ, ⵅ ⵢⴰⵀⵓⴷⴰ ⵓ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R232_26","015_32_26","2CH","32","26","26","ⵃⵉⵣⵇⵉⵢⴰ ⵎⴰⵛⴰ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⵎ ⵏⴻⵜⵜⴰ ⴰⵎ ⵢⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵍⴰⵎⵉ ⴰⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵢⵓⵙⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵃⵉⵣⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R232_27","015_32_27","2CH","32","27","27","ⵃⵉⵣⵇⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉ ⵏⵏⵓⵇⴰⵔⵜ, ⵉ ⵡⵓⵔⴻⵖ, ⵉ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ, ⵉ ⵍⴻⵄⵟⵓⵔ, ⵉ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R232_28","015_32_28","2CH","32","28","28","ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵜⵉⵅⵓⴱⴰⵢ ⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵉⵎⴻⵏⴷⵉ, ⵉ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ, ⵓⵍⴰ ⴷ ⵍⴽⵓⵔⵉⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⴷ ⵍⴻⵄⵔⴰⵚⵉ ⵉⴼⴰⵔⵢⴻⵏ ⵉ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R232_29","015_32_29","2CH","32","29","29","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵡⴰⴳⵍⴰ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R232_30","015_32_30","2CH","32","30","30","ⵃⵉⵣⵇⵉⵢⴰ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⵉⴱⴻⵍⵍⴻⵄ ⵓⴼⴼⵓⵖ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵊⵉⵃⵓⵏ ⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵎⴰⵏ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⴰⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ ⵜⵓⵖⴰ ⵉⴼⵍⴻⵃ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("R232_31","015_32_31","2CH","32","31","31","ⵎⴰⵛⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⴻⵏⴷⵓⴱⵉⵢⵢⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴱⴰⴱⵉⵍ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉⵎⵖⴰⵔⴻⵏ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵇⴻⴵⴻⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R232_32","015_32_32","2CH","32","32","32","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵃⵉⵣⵇⵉⵢⴰ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⵉ ⵍⴻⵡⵃⵉⵢ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵓ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R232_33","015_32_33","2CH","32","33","33","ⵃⵉⵣⵇⵉⵢⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ ⵏ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵙⵙⴻⵛⵏⴻⵏ ⴰⵙ ⵍⴻⵡⵇⴰⵔ ⵖⴰⵔ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ⵎⵎⵉⵙ ⵎⴰⵏⴰⵙⵙⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R233_1","015_33_1","2CH","33","1","1","ⵎⴰⵏⴰⵙⵙⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵅⴻⵎⵙⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R233_2","015_33_2","2CH","33","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R233_3","015_33_3","2CH","33","3","3","ⵏⴻⵜⵜⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⵄⴷⴻⵍ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵀⴷⴻⵎ ⴱⴰⴱⴰⵙ ⵃⵉⵣⵇⵉⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⵄⴱⴻⴷ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R233_4","015_33_4","2CH","33","4","4","ⵉⵙⵙⴱⴻⴷⴷ ⵄⴰⵡⴻⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵉ ⵅ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("R233_5","015_33_5","2CH","33","5","5","ⵏⴻⵜⵜⴰ ⵉⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R233_6","015_33_6","2CH","33","6","6","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⴽⴽⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ, ⵉⴳⴳⴰ ⵙ ⵜⴱⴻⵣⴳⵉⵡⵜ ⴷ ⵜⴳⴻⵣⵣⴰⵏⵜ ⴷ ⵜⵙⴻⵃⵃⴰⵔⵜ, ⵓ ⵢⵉⵡⵉ-ⴷⴷ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ. ⵉⴳⴳⴰ ⴰⵟⵟⴰⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵄⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("R233_7","015_33_7","2CH","33","7","7","ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏⵏⵉ ⵉⴳⴳⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵉ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ: “ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴻⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R233_8","015_33_8","2CH","33","8","8","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⴰⴹⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵄⴰⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵓⵔⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵎⵖⵉⵔ ⴰⴷ ⵃⴹⴰⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵓⵎⵓⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴳⴳⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("R233_9","015_33_9","2CH","33","9","9","ⵎⴰⵏⴰⵙⵙⴰ ⵉⵊⵊⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⴳⴳⵉⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵅ ⵍⴻⴳⵏⵓⵙ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵇⴹⴰ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R233_10","015_33_10","2CH","33","10","10","ⵉⵡⴰ, ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵉ ⵎⴰⵏⴰⵙⵙⴰ ⵓ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵡⵛⵉⵏ ⵛⴰ ⵜⴰⵢⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("R233_11","015_33_11","2CH","33","11","11","ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⵙⴻⵏ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ⵏⵉⵜⵏⵉ ⵃⴻⴱⴱⵙⴻⵏ ⵎⴰⵏⴰⵙⵙⴰ ⵙ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ, ⵛⴰⵔⴼⴻⵏ ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵃⴰⵙ ⵓⵛⴰ ⵊⵊⵉⵏ ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⵎⵎⵓ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R233_12","015_33_12","2CH","33","12","12","ⵓⵎⵉ ⵜ ⵉⵃⵚⴰⵔ ⵏⴻⵜⵜⴰ ⴰⵎⵎⵓ, ⵉⵣⴰⵡⴻⴳ ⵡⴰⵏⵉⵜⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵓ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵍ ⵟⵟⴰⵔⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R233_13","015_33_13","2CH","33","13","13","ⵉⵥⵥⵓⴵ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⴷ ⵉⵙⵙⴰⵔⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⴻⵙ ⵙ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵏⵏⴻⵙ ⵓ ⵢⴰⵔⵔⴰ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("R233_14","015_33_14","2CH","33","14","14","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⴱⵏⴰ ⵍⵃⵉⴹ ⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵏ ⵊⵉⵃⵓⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ, ⵓ ⵉⴱⵏⴰ ⵉ-ⵜ ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⵉⵇⵓⵡⵡⴰⵔ ⵍⵃⵉⴹ ⵓⵍⴰ ⴷ ⵄⵓⴼⵉⵍ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⴰⵏⴰⵙⵙⵉ ⵍⵃⵉⴹ ⴰⵟⵟⴰⵙ. ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R233_15","015_33_15","2CH","33","15","15","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⴷ ⵍⴻⵅⵢⴰⵍ ⵏ ⵚⵚⴰⵏⴰⵎ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⵏⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("R233_16","015_33_16","2CH","33","16","16","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵅⴰⵙ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵇⴰⴷⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R233_17","015_33_17","2CH","33","17","17","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵏⵉ ⵄⴰⴷ ⵢⵉⵡⵉ ⵜⵉⵖⴰⵔⵚⴰ ⵅ ⵍⴻⴳⵄⵓⴷⵉ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("R233_18","015_33_18","2CH","33","18","18","ⵉⵎⴻⵣⵔⵓⵢⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵡⴰⵍⴰⵡⴻⵏ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R233_19","015_33_19","2CH","33","19","19","ⵜⴰⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵊⵊⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⴷ ⵍⴻⵖⴷⴰⵔ ⵏⵏⴻⵙ ⴷ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵉⴱⵏⴰ ⵍⴻⴳⵄⵓⴷⵉ ⵓ ⵉⵙⵙⴱⴻⴷⴷ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵇⴱⴻⵍ ⵎⴰ ⵉⵜⵜⵡⴰⵙⵙⵡⴰⴹⴻⵄ, ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵡⴰⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R233_20","015_33_20","2CH","33","20","20","ⵎⴰⵏⴰⵙⵙⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵊⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵎⵎⵉⵙ ⴰⵎⵓⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R233_21","015_33_21","2CH","33","21","21","ⴰⵎⵓⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R233_22","015_33_22","2CH","33","22","22","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⵎⴰⵏⴰⵙⵙⴰ. ⴰⵎⵓⵏ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴱⴰⴱⴰⵙ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⵉⵙⴻⵅⵅⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R233_23","015_33_23","2CH","33","23","23","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵡⴰⴹⴻⵄ ⴱⴰⴱⴰⵙ ⵎⴰⵏⴰⵙⵙⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵎⵓⵏ ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵏⵉ ⵡⴰⵀⴰ ⴷⴻⴳ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R233_24","015_33_24","2CH","33","24","24","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R233_25","015_33_25","2CH","33","25","25","ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵛⴰ ⵏⵖⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵉⵏ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵅ ⵓⵊⴻⴵⵉⴷ ⴰⵎⵓⵏ. ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴳⴳⵉⵏ ⵎⵎⵉⵙ ⵢⵓⵛⵉⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R234_1","015_34_1","2CH","34","1","1","ⵢⵓⵛⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵡⴰⵃⵉⵜ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R234_2","015_34_2","2CH","34","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ, ⵡⴰⵔ ⵉⴼⴼⵉⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵍⴰ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("R234_3","015_34_3","2CH","34","3","3","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⴰⵃⵓⴷⵔⵉ, ⵉⴱⴷⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵙ ⴷⴰⵡⵓⴷ. ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵉⴱⴷⴰ ⴰⴷ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵍⴻⴳⵄⵓⴷⵉ, ⵣⵉ ⵜⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵓ ⵣⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R234_4","015_34_4","2CH","34","4","4","ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵀⴻⴷⵎⴻⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏ ‘ⵉⴱⴰⵄⵍⴻⵏ’, ⵓⵛⴰ ⵉⵣⴷⴻⵎ ⵏⴻⵜⵜⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ ⵏⵏⵉ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵉⴱⴰⵏⴻⵏ ⵙⴻⵏⵏⴻⵊ. ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ ⵢⴰⵔⵥⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓⵛⴰ ⵉⴷⴷⴻⵣ ⵉ-ⵜⴻⵏ ⵓ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵏⵙⴻⵏ ⵢⴰⵔⴻⵢⵢⴻⵛ ⵉ-ⵜⵜ ⵅ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("R234_5","015_34_5","2CH","34","5","5","ⵉⵙⵙⴰⵔⵖ ⵉⵖⵙⴰⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵅ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R234_6","015_34_6","2CH","34","6","6","ⵓⵍⴰ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵛⵉⵎⵄⵓⵏ, ⵡⴰⵀ, ⴰⵍ ⵏⴰⴼⵜⴰⵍⵉ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵉⵎⵓⵛⴰⵏ ⵏⵙⴻⵏ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("R234_7","015_34_7","2CH","34","7","7","ⵉⵀⴷⴻⵎ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵍⴱⴻⵣ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ, ⵉⴷⴷⴻⵣ ⵉ-ⵜⴻⵏⵜ, ⵓⵛⴰ ⵉⵣⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ. ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R234_8","015_34_8","2CH","34","8","8","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵛⴰⴼⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴰⵚⴰⵍⵢⴰ, ⴷ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴷ ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R234_9","015_34_9","2CH","34","9","9","ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵃⵉⵍⵇⵉⵢⴰ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓ ⵡⵛⵉⵏ ⴰⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵡⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⵡⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵄⴻⵙⵙⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ, ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵏⴰⵙⵙⴰ ⴷ ⵉⴼⵔⴰⵢⵉⵎ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R234_10","015_34_10","2CH","34","10","10","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵉⵏⴰ ⵡⵛⵉⵏ ⵜⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵓ ⴰⴷ ⵙⵙⵊⴻⵀⴷⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("R234_11","015_34_11","2CH","34","11","11","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵜⵜ ⵉ ⵉⵃⵔⴰⵢⴼⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⵎⴰⵚⵚⵓⵜⴻⵏ ⵉ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ ⵓ ⵉ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⵄⴰⵔⵔⴻⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵜⵉⵖⵓⵔⴼⵉⵏ ⵉ ⵜⵓⴷⵔⵉⵏ, ⵜⵉⵏⵏⵉ ⵉⵊⵊⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴰⵔⵅⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R234_12","015_34_12","2CH","34","12","12","ⵉⵔⵢⴰⵣⴻⵏ ⵅⴻⴷⵎⴻⵏ ⵙ ⵍⴰⵎⴰⵏ. ⵢⴰⵃⴰⵜ ⴷ ⵄⵓⴱⴰⴷⵢⴰ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⵔⴰⵔⵉ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵅⴰⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⴷ ⵎⴰⵛⵓⵍⵍⴰⵎ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵇⵓⵃⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵢⵢⴰⵔⴻⵏ. ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⵜⵜⵃⴰⴽⴰⵏ ⴷⵉ ⴷⴷⵓⵣⴰⵏⴰⵜ ⵏ ⵍⵎⵓⵙⵉⵇⴰ, ");
INSERT INTO rift_vpl VALUES ("R234_13","015_34_13","2CH","34","13","13","ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵄⴰⵡⴻⴷ ⵅ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵃⵎⴻⵍ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⵢⵢⴰⵔⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⴼⴰⵔⵣⴻⵏ. ⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⴰⵔⵉⵔⴻⵏ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R234_14","015_34_14","2CH","34","14","14","ⵓⵎⵉ ⴽⵙⵉⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵡⵢⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵢⵓⴼⴰ ⵓⴽⴻⵀⵀⴰⵏ ⵃⵉⵍⵇⵉⵢⴰ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵅ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R234_15","015_34_15","2CH","34","15","15","ⵃⵉⵍⵇⵉⵢⴰ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵓⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ: “ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ⵓⵛⴰ ⵉⵡⵛⴰ ⵃⵉⵍⴽⵉⵢⴰ ⴰⴷⵍⵉⵙ ⵉ ⵛⴰⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R234_16","015_34_16","2CH","34","16","16","ⵛⴰⴼⴰⵏ ⵢⵉⵡⵉ ⴰⴷⵍⵉⵙ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵅⴻⴱⴱⴰⵔ ⴰⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵓⵎⵓⵔⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("R234_17","015_34_17","2CH","34","17","17","ⵏⵉⵜⵏⵉ ⵙⵙⴼⴰⵔⵔⵖⴻⵏ ⵜⴻⵎⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵓⴼⵉⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⵛⵉⵏ ⵜⴻⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("R234_18","015_34_18","2CH","34","18","18","ⵅⴻⵏⵏⵉ ⵉⵃⴰⵊⴰ ⵓⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵎⵎⵓ, ⵉⵏⵏⴰ: “ⴰⴽⴻⵀⵀⴰⵏ ⵃⵉⵍⵇⵉⵢⴰ ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ!” ⵛⴰⴼⴰⵏ ⵉⵖⵔⴰ ⵣⵣⴰⵢⴻⵙ ⵅ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R234_19","015_34_19","2CH","34","19","19","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵎⵙⴰⵔ, ⵉⵛⴰⵔⵔⴻⴳ ⵏⴻⵜⵜⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R234_20","015_34_20","2CH","34","20","20","ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵉ ⵃⵉⵍⵇⵉⵢⴰ ⵓ ⵉ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵓ ⵉ ⵄⴰⴱⴷⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰ, ⵓ ⵉ ⵓⵎⴰⵔⵉⵔ ⵛⴰⴼⴰⵏ ⵉ ⵄⴰⵙⴰⵢⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("R234_21","015_34_21","2CH","34","21","21","“ⵓⵢⵓⵔⴻⵎ, ⵙⴻⵇⵙⴰⵎ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ. ⵎⴰⵖⴰⵔ ⴰⵙⵄⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵅⴰⵏⴻⵖ ⵉⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵡⴰⵔ ⵃⴹⵉⵏ ⵛⴰ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("R234_22","015_34_22","2CH","34","22","22","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵃⵉⵍⵇⵉⵢⴰ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⵏⴰⴱⵉⵜ ⵅⵓⵍⴷⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵜⵓⵇⴰⵀⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵙⵔⴰ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵍⴻⵀⵔⵉ ⵏ ⵡⴰⵔⵔⵓⴹ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵣⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R234_23","015_34_23","2CH","34","23","23","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵉⵏⵉⵎ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("R234_24","015_34_24","2CH","34","24","24","‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵍⵉ ⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵖⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("R234_25","015_34_25","2CH","34","25","25","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅⴰⴼⵉ ⵓ ⵉⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵣⴻⴵⴻⵄ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵡⴰⵔ ⵉⵅⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("R234_26","015_34_26","2CH","34","26","26","ⵎⴰⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵍⵉⴷ: ");
INSERT INTO rift_vpl VALUES ("R234_27","015_34_27","2CH","34","27","27","ⵎⴰⵖⴰⵔ ⵉⴷⵡⴻⵍ ⵡⵓⵍ ⵏⵏⴻⵛ ⵢⴰⵔⴹⴻⴱ ⵓ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵎⵉ ⵜⴻⵙⵍⵉⴷ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵓ ⵓⵎⵉ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⵛⴰⵔⵔⴳⴻⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⵓ ⵜⵔⵓⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵙ ⵓⵢⴰ ⵙⵍⵉⵖ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⵖⴰⵔⴻⴽ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R234_28","015_34_28","2CH","34","28","28","ⵅⵣⴰⵔ, ⴰⴷ ⵛⴻⴽ ⵙⵙⵎⵓⵏⴻⵖ ⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵙⴻⴷ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵛ ⵙ ⵍⴻⵀⵏⴰ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏⵜ ⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⵉ ⵖⴰ ⵙⵙⵉⵡⴹⴻⵖ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ.’” ⵏⵉⵜⵏⵉ ⵄⴰⵡⴷⴻⵏ ⴰⵡⴰⵍ-ⴰ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R234_29","015_34_29","2CH","34","29","29","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R234_30","015_34_30","2CH","34","30","30","ⵉⴳⴻⵄⵄⴻⴷ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵣⴻⴳ ⵓⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⴰⵎⴻⵥⵢⴰⵏ, ⵓ ⵖⵔⵉⵏ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R234_31","015_34_31","2CH","34","31","31","ⴰⵊⴻⴵⵉⴷ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⵍⵄⴰⵀⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴹⴼⴰⵔ ⵙⵉⴷⵉ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴹⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ ⵉ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("R234_32","015_34_32","2CH","34","32","32","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵙⵙⵎⴻⵜⵏⴻⵏ ⵓⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴳⴳⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵄⴰⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R234_33","015_34_33","2CH","34","33","33","ⵉⴽⴽⴻⵙ ⵢⵓⵛⵉⵢⴰ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵚⵚⴰⵏⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵢⴰⵔⵔⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵏ ⵛⴰ ⵣⴻⴳ ⵡⴻⴹⴼⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_1","015_35_1","2CH","35","1","1","ⵅⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵢⵓⵛⵉⵢⴰ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("R235_2","015_35_2","2CH","35","2","2","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵖⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⴷⴰⵢⵙⴻⵏ ⵓⵍ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R235_3","015_35_3","2CH","35","3","3","ⵉⵏⵏⴰ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ: “ⵙⴰⵔⵙⴻⵎ ⵜⵜⴰⴱⵓⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵉⴱⵏⴰ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⴷ ⴰⴷ ⵜⴰⵔⴱⵓⵎ ⴷⴷⵇⴻⵍ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵡⴻⵎ. ⵙⴻⵅⵅⴰⵔⴻⵎ ⵍⴻⵅⵅⵓ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R235_4","015_35_4","2CH","35","4","4","ⵙⵡⴻⵊⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⵎ ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵡⴻⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵢⵓⵔⴰ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵢⵓⵔⴰ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_5","015_35_5","2CH","35","5","5","ⵙⴱⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵎ ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴱⵉⵄⵉⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵣⵣⴰⵜ ⵉ ⵜⴰⵡⵎⴰⵜ ⵏⵡⴻⵎ, ⴰⵢⵜ ⵏ ⵍⴳⴻⵏⵙ, ⴰⵎ ⵜᵉⵜⵜⵡⴰⵙⴻⵜⵜⴼⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⴻⵜⵜⴻⴼ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵊⵊⴻⴷ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_6","015_35_6","2CH","35","6","6","ⵖⴰⵔⵚⴻⵎ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵓ ⵙⵇⴻⴷⴷⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⵙⵡⴻⵊⴷⴻⵎ ⵜⵜ ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("R235_7","015_35_7","2CH","35","7","7","ⵉⵡⵛⴰ ⵢⵓⵛⵉⵢⴰ ⵓⴵⵉ, ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵉⵎⵓⵢⴰⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ. ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵜⵓⵖⴰ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ. ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⵜⵍⴰⵜⵉⵏ-ⴰⵍⴻⴼ, ⵓ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R235_8","015_35_8","2CH","35","8","8","ⵡⵛⵉⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵍⴳⴻⵏⵙ, ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⵃⵉⵍⵇⵉⵢⴰ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⴷ ⵢⴰⵃⵉⵢⵉⵍ, ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⵛⵉⵏ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵣⴻⴳ ⵡⵓⴵⵉ ⵓ ⵙⴻⵏⵏⴻⵊ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_9","015_35_9","2CH","35","9","9","ⴽⵓⵏⴰⵏⵢⴰ, ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⵏⴰⵜⴰⵏⵉⵢⵉⵍ, ⴰⵢⵜⵎⴰⵙ, ⴷ ⵃⴰⵛⴰⴱⵢⴰ, ⵢⴰⵄⵉⵢⵉⵍ ⴷ ⵢⵓⵣⴰⴱⴰⴷ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵡⵛⵉⵏ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵓⵙⴻⵄⴷⵓ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵣⴻⴳ ⵡⵓⴵⵉ ⵓ ⵅⴻⵏⵏⵉ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_10","015_35_10","2CH","35","10","10","ⴰⵎⵎⵓ ⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵓ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("R235_11","015_35_11","2CH","35","11","11","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵓⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⵓ ⴽⴽⵙⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⵍⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_12","015_35_12","2CH","35","12","12","ⵏⵉⵜⵏⵉ ⵃⵓⵣⴻⵏ ⵉⵣⵉⵢⵏⴰⵜ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵏⵜ ⵡⵛⴻⵏ, ⵉ ⵍⴻⴼⵔⵓⵄ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵉ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵡⴻⵀⵀⴱⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵎⵓⵙⴰ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⵉⵏ ⴰⴽ-ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_13","015_35_13","2CH","35","13","13","ⵅⴻⵏⵏⵉ ⵛⴻⵏⴼⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵜⵉⵡⴰ ⵉ ⵜⵎⴻⵙⵙⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⴷⵉ ⵍⵇⴰⵄⵉⴷⴰ. ⵉⵣⵉⵢⵏⴰⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵛⴻⵏⴼⴻⵏ ⵜⴻⵏ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰⵜ ⴷ ⵉⵟⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵉⵇⵙⵉⵍⵉⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("R235_14","015_35_14","2CH","35","14","14","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵓⵍⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ, ⵜⵓⵖⴰ ⵍⵀⴰⵏ ⴰⴽ-ⴷ ⵓⵡⴻⵀⵀⴻⴱ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴰⴷⵓⵏⵜ ⴰⵍ ⴵⵉⵍⴻⵜ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_15","015_35_15","2CH","35","15","15","ⵉⵎⴻⴷⵢⴰⵣⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵙⴰⴼ, ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵙⴰⴼ, ⵀⴰⵢⵎⴰⵏ ⴷ ⵢⴰⴷⵓⵜⵓⵏ, ⴰⵎⵡⴰⵍⴰⵡ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⴽⵓⵍ ⵜⴰⵡⵡⴰⵔⵜ. ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵊⵊⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵙⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("R235_16","015_35_16","2CH","35","16","16","ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵜⴻⵄⴷⴻⵍ ⵎⵍⵉⵃ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉ ⵓⵃⴻⵟⵟⵓ ⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵓ ⵉ ⵓⵡⴻⵀⵀⴻⴱ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R235_17","015_35_17","2CH","35","17","17","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ, ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵓ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_18","015_35_18","2CH","35","18","18","ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴱⵓ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⵎ ⵡⴰ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵏⴰⴱⵉ ⵛⴰⵎⵡⵉⵍ. ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⴳⴳⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⵢⵓⵛⵉⵢⴰ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ, ⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R235_19","015_35_19","2CH","35","19","19","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵢⵓⵛⵉⵢⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("R235_20","015_35_20","2CH","35","20","20","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⵓⵛⵉⵢⴰ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵏⴰⵅⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⵍⴼⵓⵔⴰⵟ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⴽⴰⵔⴽⴰⵎⵉⵛ. ⵓⵛⴰ ⵢⵓⵛⵉⵢⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R235_21","015_35_21","2CH","35","21","21","ⵏⴰⵅⵓ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ-ⴷⴷ ⴷ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ? ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔⴻⴽ ⵉ ⴷⴷ ⴼⴼⵖⴻⵖ ⴰⵙⵙ-ⴰ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽⵉⴷⵉ. ⵉⵏⵏⴰ ⴰⵢⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵇⴻⴵⵇⴻⵖ. ⵙ ⵓⵢⴰ ⵃⴻⵢⵢⴻⴷ ⵅ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⴵⴰⵏ, ⵏⵉⵖ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⴻⴷⴷⴻⴵ.” ");
INSERT INTO rift_vpl VALUES ("R235_22","015_35_22","2CH","35","22","22","ⵎⴰⵛⴰ ⵢⵓⵛⵉⵢⴰ ⵡⴰⵔ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵣⵣⴰⵢⴻⵙ, ⵎⴰⵛⴰ ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵜⵜⴰ ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵎⵏⴻⵖ, ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵍⵉ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵏⴰⵅⵓ ⵉⵏⵏⵉ ⴷⴷ ⵢⵓⵙⵉⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⴰⵊⵉⴷⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("R235_23","015_35_23","2CH","35","23","23","ⵎⴰⵛⴰ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ ⵍⴻⵇⴼⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵏⴻⴷⵀⴻⵎ ⴰⵢⵉ ⵙⵙⴻⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵢⴻⵣⵎⴻⵖ ⴰⵟⵟⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("R235_24","015_35_24","2CH","35","24","24","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴽⵙⵉⵏ ⵜ ⴷⴻⴳ ⵓⴽⴰⵔⵔⵓ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵉⵎⵎⵓⵜ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵛⴻⴹⵏⴻⵏ ⵅ ⵢⵓⵛⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("R235_25","015_35_25","2CH","35","25","25","ⵉⴳⴳⴰ ⵉⵔⵎⵉⵢⴰ ⵉⵛⵜ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵢⵓⵛⵉⵢⴰ. ⴰⵍ ⴰⵙⵙ-ⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵜⵎⴻⴷⵢⴰⵣⵉⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵢⵓⵛⵉⵢⴰ ⴷⴻⴳ ⵉⵣⵍⴰⵏ ⵏⵙⴻⵏ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵅⵣⴰⵔ, ⴰⵇⴰ-ⵜⴻⵏ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵉⵣⵍⴰⵏ ⵙ ⵉⴳⴻⵊⴷⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("R235_26","015_35_26","2CH","35","26","26","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵛⵉⵢⴰ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("R235_27","015_35_27","2CH","35","27","27","ⵡⴰⵀ, ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏⵏⴻⵙ, ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("R236_1","015_36_1","2CH","36","1","1","ⴽⵙⵉⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⵓⵛⴰ ⴳⴳⵉⵏ ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("R236_2","015_36_2","2CH","36","2","2","ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R236_3","015_36_3","2CH","36","3","3","ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵉⴽⴽⴻⵙ ⵉ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵊⵊ ⵏ ⵎⵓⵍⵜⴰ ⵏ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("R236_4","015_36_4","2CH","36","4","4","ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵉⴳⴳⴰ ⵓⵎⴰⵙ ⴰⵍⵢⴰⵇⵉⵎ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ. ⵎⴰⵛⴰ ⵓⵎⴰⵙ ⵢⴰⵀⵓⵢⴰⵃⴰⵣ ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵏⴰⵅⵓ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("R236_5","015_36_5","2CH","36","5","5","ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵃⵉⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R236_6","015_36_6","2CH","36","6","6","ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⴼⴼⴻⵖ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⵛⴰⵔⴼ ⵉ-ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R236_7","015_36_7","2CH","36","7","7","ⵢⵉⵡⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵍⴻⵇⵛⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⴷⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R236_8","015_36_8","2CH","36","8","8","ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵉ ⵉⴳⴳⴰ ⵓ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ. ⵎⵎⵉⵙ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R236_9","015_36_9","2CH","36","9","9","ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R236_10","015_36_10","2CH","36","10","10","ⵖⴰⵔ ⵓⴱⴻⴷⴷⴻⵍ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉⵊⵊⴰ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵙ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵓⵎⴰⵙ ⵚⵉⴷⵇⵉⵢⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R236_11","015_36_11","2CH","36","11","11","ⵚⵉⴷⵇⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵃⵉⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R236_12","015_36_12","2CH","36","12","12","ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("R236_13","015_36_13","2CH","36","13","13","ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⵡⴻⵏⵏⵉ ⵜ ⵉⵊⵊⵉⵏ ⴰⴷ ⵉⵊⵊⴰⴵ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵎⵃⴻⴹ ⵉⵔⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵯⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R236_14","015_36_14","2CH","36","14","14","ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵔⵓⵃⴻⵏ, ⴰⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⴻⵖⴷⴰⵔ ⵏⵙⴻⵏ, ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵏⵉⵜⵏⵉ ⵙⵙⵅⴻⵎⵊⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("R236_15","015_36_15","2CH","36","15","15","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵏⴻⵀⵀⴰⵔⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵙ, ⵍⴻⵅⵅⵓ ⵏⵉⵖ ⵍⴻⵅⵎⵉⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⵣⵉⴵⵉⵣ ⴰⵙ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R236_16","015_36_16","2CH","36","16","16","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵜⴻⵀⵣⴰⵏ ⵣⴻⴳ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⴰⴹⵚⴰ ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵉⵙⵄⴰⵔ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵓⵙⴳⴻⵏⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("R236_17","015_36_17","2CH","36","17","17","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⴼⴼⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵄⵉⵣⵣ ⵅ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵅ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵓⵍⴰ ⵅ ⵉⵡⴻⵙⵙⵓⵔⴰ ⴷ ⵉⵎⴻⵛⵛⴰⵢⴱⵓⵜⴻⵏ. ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R236_18","015_36_18","2CH","36","18","18","ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵍⴻⵇⵛⵓⵄ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵅⵓⴱⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵅⵓⴱⴰⵢ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵢⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("R236_19","015_36_19","2CH","36","19","19","ⵏⵉⵜⵏⵉ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵀⴻⴷⵎⴻⵏ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵇⵇⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("R236_20","015_36_20","2CH","36","20","20","ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵙⵙⵉⴼ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵍ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵍⴼⵓⵔⵙ, ");
INSERT INTO rift_vpl VALUES ("R236_21","015_36_21","2CH","36","21","21","- ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵇⴼⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ - ⴰⵍⴰⵎⵉ ⵜⴻⴽⵙⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵙ ⵏ ⵙⵙⴻⴱⵜ. ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵜⵓⵖⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴰⵔⴻⵢⵢⴻⵃ, ⴰⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("R236_22","015_36_22","2CH","36","22","22","ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ - ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ - ⵉⵙⵙⴻⴽⴽⴰⵔ-ⴷⴷ ⵙⵉⴷⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ, ⵓⵛⴰ ⵉⵊⵊⴰ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷⵉ ⵜⵉⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("R236_23","015_36_23","2CH","36","23","23","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵉⵡⵛⴰ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵅⴰⴼⵉ ⴰⴷ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵏⴻⵜⵜⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ⴻⵊⵊ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵇⴰⵄ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ! ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⴰⴽⵉⴷⴻⵙ!’” ");
INSERT INTO rift_vpl VALUES ("ER1_1","016_1_1","EZR","1","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ ⵏ ⵍⴼⵓⵔⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ, ⵉⵙⵙⴻⴽⴽⴰⵔ ⵙⵉⴷⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⴽⵓⵔⴰⵛ ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⴷ ⵜⵉⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("ER1_2","016_1_2","EZR","1","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵉⵡⵛⴰ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵅⴰⴼⵉ, ⴰⴷ ⴰⵙ ⴱⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("ER1_3","016_1_3","EZR","1","3","3","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⴻⵙ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER1_4","016_1_4","EZR","1","4","4","ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴷⵉ ⵛⴰ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵙ ⵡⴰⴳⵍⴰ ⴷ ⵍⵎⴰⵍ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.’” ");
INSERT INTO rift_vpl VALUES ("ER1_5","016_1_5","EZR","1","5","5","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵙⵙⴼⴰⵇ ⴰⵔⴻⴱⴱⵉ ⴱⵓⵃⴱⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER1_6","016_1_6","EZR","1","6","6","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⴰⴼⵓⵙ ⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵙ ⵡⵓⵔⴻⵖ, ⵙ ⵡⴰⴳⵍⴰ, ⵙ ⵍⵎⴰⵍ ⵓ ⵙ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ, ⴱⵍⴰ ⵎⵉⵏ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ER1_7","016_1_7","EZR","1","7","7","ⴰⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴽⵙⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ER1_8","016_1_8","EZR","1","8","8","ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵉⵜⵔⴰⴷⴰⵜ, ⴱⴰⴱ ⵏ ⵜⵅⵓⴱⴰⵢ, ⵡⴻⵏⵏⵉ ⵜⴻⵏⵜ ⵉⵡⵛⵉⵏ ⵙ ⵍⴻⵃⵙⴰⴱ ⵉ ⵛⵉⵛⴱⴰⵚⵚⴰⵔ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("ER1_9","016_1_9","EZR","1","9","9","ⵡⴰ ⵜⵓⵖⴰ ⴷ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ: ⵜⵍⴰⵜⵉⵏ ⵏ ⵟⵟⴱⴰⵚⴰ ⵏ ⵡⵓⵔⴻⵖ, ⴰⵍⴻⴼ ⵏ ⵟⵟⴱⴰⵚⴰ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵜⴻⵙⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⴻⵎⵡⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("ER1_10","016_1_10","EZR","1","10","10","ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⴼⴻⵏⵊⴰⵍⴻⵏ ⵏ ⵡⵓⵔⴻⵖ, ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⴻⵏⵊⴰⵍⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⴰⵍⴻⴼ ⵏ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("ER1_11","016_1_11","EZR","1","11","11","ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵜⵓⵖⴰ ⵉⵡⴹⴻⵏ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵓ-ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ. ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵢⵉⵡⵢⵉ ⵜ ⵛⵉⵛⴱⴰⵚⵚⴰⵔ ⴰⴽⵉⴷⴻⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵣⵉ ⴱⴰⴱⵉⵍ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER2_1","016_2_1","EZR","2","1","1","ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵍⵄⴰⵎⴰⵍⴰ ⵏⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ - ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ - ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("ER2_2","016_2_2","EZR","2","2","2","ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴰⴽ-ⴷ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵢⴰⵀⵓⵛⴰⵄ, ⵏⴰⵀⴰⵎⵢⴰ, ⵙⴰⵔⴰⵢⴰ, ⵔⴰⵄⵍⴰⵢⴰ, ⵎⵓⵔⴷⴰⵅⴰⵉ, ⴱⵉⵍⵛⴰⵏ, ⵎⵉⵙⴼⴰⵔ, ⴱⵉⵖⵡⴰⵢ, ⵔⴰⵃⵓⵎ ⴷ ⴱⴰⵄⵏⴰ. ⵡⴰ ⴷ ⵍⵇⴻⴷⴷ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER2_3","016_2_3","EZR","2","3","3","ⴰⵢⵜ ⵏ ⵏ ⴼⴰⵔⵄⵓⵛ, ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_4","016_2_4","EZR","2","4","4","ⴰⵢⵜ ⵏ ⵛⴰⴼⴰⵟⵢⴰ, ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_5","016_2_5","EZR","2","5","5","ⴰⵢⵜ ⵏ ⴰⵔⴰⵃ, ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_6","016_2_6","EZR","2","6","6","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴼⴰⵀⴰⵜ-ⵎⵓ’ⴰⴱ, ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴻⵛⵓⵄⴰ ⴷ ⵢⵓ’ⴰⴱ, ⴰⵍⴼⴰⵢⴻⵏ ⵓ ⵜⴻⵎⵏⴻⵎ-ⵎⵢⴰ ⵓ-ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_7","016_2_7","EZR","2","7","7","ⴰⵢⵜ ⵏ ⵄⵉⵍⴰⵎ, ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_8","016_2_8","EZR","2","8","8","ⴰⵢⵜ ⵏ ⵣⴰⵜⵜⵓ, ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_9","016_2_9","EZR","2","9","9","ⴰⵢⵜ ⵏ ⵣⴰⴽⴽⴰⵢ, ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_10","016_2_10","EZR","2","10","10","ⴰⵢⵜ ⵏ ⴱⴰⵏⵉ, ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_11","016_2_11","EZR","2","11","11","ⴰⵢⵜ ⵏ ⴱⴰⴱⴰⵢ, ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_12","016_2_12","EZR","2","12","12","ⴰⵢⵜ ⵏ ⵄⴰⵔⵊⴰⴷ, ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_13","016_2_13","EZR","2","13","13","ⴰⵢⵜ ⵏ ⴰⴷⵓⵏⵉⵇⴰⵎ, ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_14","016_2_14","EZR","2","14","14","ⴰⵢⵜ ⵏ ⴱⵉⵖⵡⴰⵢ, ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_15","016_2_15","EZR","2","15","15","ⴰⵢⵜ ⵏ ⵄⴰⴷⵉⵏ, ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_16","016_2_16","EZR","2","16","16","ⴰⵢⵜ ⵏ ⴰⵟⵉⵔ, ⵣⵉ ⵃⵉⵣⵇⵉⵢⴰ, ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_17","016_2_17","EZR","2","17","17","ⴰⵢⵜ ⵏ ⴱⵉⵚⴰⵢ, ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_18","016_2_18","EZR","2","18","18","ⴰⵢⵜ ⵏ ⵢⵓⵔⴰ, ⵎⵢⴰ ⵓ-ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_19","016_2_19","EZR","2","19","19","ⴰⵢⵜ ⵏ ⵃⴰⵛⵓⵎ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_20","016_2_20","EZR","2","20","20","ⴰⵢⵜ ⵏ ⵊⵉⴱⴱⴰⵔ, ⵅⴻⵎⵙⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_21","016_2_21","EZR","2","21","21","ⴰⵢⵜ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_22","016_2_22","EZR","2","22","22","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵉ ⵏⴰⵟⵓⴼⴰ, ⵙⴻⵜⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_23","016_2_23","EZR","2","23","23","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵏⴰⵜⵓⵜ, ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_24","016_2_24","EZR","2","24","24","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵄⴰⵣⵎⴰⵡⴻⵜ, ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_25","016_2_25","EZR","2","25","25","ⴰⵢⵜ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵄⴰⵔⵉⵎ, ⴽⴰⴼⵉⵔⴰ ⴷ ⴱⵉⵄⵔⵓⵜ, ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_26","016_2_26","EZR","2","26","26","ⴰⵢⵜ ⵏ ⵔⴰⵎⴰ ⴷ ⵊⴰⴱⴰⵄ, ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵡⴰⵃⴻⴷ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_27","016_2_27","EZR","2","27","27","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵎⵉⵅⵎⴰⵙ, ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_28","016_2_28","EZR","2","28","28","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵄⴰⵢ, ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_29","016_2_29","EZR","2","29","29","ⴰⵢⵜ ⵏ ⵏⴰⴱⵓ, ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_30","016_2_30","EZR","2","30","30","ⴰⵢⵜ ⵏ ⵎⴰⵖⴱⵉⵛ, ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_31","016_2_31","EZR","2","31","31","ⴰⵢⵜ ⵏ ⵉⵊⵊ ⵏ ⵄⵉⵍⴰⵎ ⵏⵏⴻⵖⵏⵉ, ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_32","016_2_32","EZR","2","32","32","ⴰⵢⵜ ⵏ ⵃⴰⵔⵉⵎ, ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_33","016_2_33","EZR","2","33","33","ⴰⵢⵜ ⵏ ⵍⵓⴷ, ⵃⴰⴷⵉⴷ ⴷ ⵓⵏⵓ, ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_34","016_2_34","EZR","2","34","34","ⴰⵢⵜ ⵏ ⴰⵔⵉⵃⴰ, ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_35","016_2_35","EZR","2","35","35","ⴰⵢⵜ ⵏ ⵙⴰⵏⴰ’ⴰ, ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_36","016_2_36","EZR","2","36","36","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⴰⵢⵜ ⵏ ⵢⴰⴷⴰⵄⵢⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴻⵛⵓⵄⴰ, ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_37","016_2_37","EZR","2","37","37","ⴰⵢⵜ ⵏ ⵉⵎⵎⵉⵔ, ⴰⵍⴻⴼ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_38","016_2_38","EZR","2","38","38","ⴰⵢⵜ ⵏ ⴼⴰⵛⵃⵓⵔ, ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_39","016_2_39","EZR","2","39","39","ⴰⵢⵜ ⵏ ⵃⴰⵔⵉⵎ, ⴰⵍⴻⴼ ⵓ-ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_40","016_2_40","EZR","2","40","40","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⴰⵢⵜ ⵏ ⵢⴻⵛⵓⵄⴰ, ⴰⵢⵜ ⵏ ⵇⴰⴷⵎⵉⵢⵉⵍ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵀⵓⴷⴰⵡⵢⴰ, ⴰⵔⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_41","016_2_41","EZR","2","41","41","ⵉⵎⴻⴷⵢⴰⵣⴻⵏ. ⴰⵢⵜ ⵏ ⴰⵙⴰⴼ, ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_42","016_2_42","EZR","2","42","42","ⴰⵢⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ. ⴰⵢⵜ ⵏ ⵛⴰⵍⵍⵓⵎ, ⴰⵢⵜ ⵏ ⴰⵟⵉⵔ, ⴰⵢⵜ ⵏ ⵟⴰⵍⵎⵓⵏ, ⴰⵢⵜ ⵏ ⵄⴰⵇⵇⵓⴱ, ⴰⵢⵜ ⵏ ⵃⴰⵟⵉⵟⴰ, ⴰⵢⵜ ⵏ ⵛⵓⴱⴰⵢ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⵎⵢⴰ ⵓ-ⵜⴻⵙⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_43","016_2_43","EZR","2","43","43","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⵢⵜ ⵏ ⵚⵉⵃⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵙⵓⴼⴰ, ⴰⵢⵜ ⵏ ⵟⴰⴱⴰⵄⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("ER2_44","016_2_44","EZR","2","44","44","ⴰⵢⵜ ⵏ ⵇⵉⵔⵓⵛ, ⴰⵢⵜ ⵏ ⵙⵉⵄⴰⵀⴰ, ⴰⵢⵜ ⵏ ⴼⴰⴷⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("ER2_45","016_2_45","EZR","2","45","45","ⴰⵢⵜ ⵏ ⵍⴰⴱⴰⵏⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵊⴰⴱⴰ, ⴰⵢⵜ ⵏ ⵄⴰⵇⵇⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("ER2_46","016_2_46","EZR","2","46","46","ⴰⵢⵜ ⵏ ⵃⴰⵊⴰⴱ, ⴰⵢⵜ ⵏ ⵛⴰⵎⵍⴰⵢ, ⴰⵢⵜ ⵏ ⵃⴰⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("ER2_47","016_2_47","EZR","2","47","47","ⴰⵢⵜ ⵏ ⵊⴰⴷⵉⵍ, ⴰⵢⵜ ⵏ ⵃⴰⵊⴰⵔ, ⴰⵢⵜ ⵏ ⵔⴰ’ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("ER2_48","016_2_48","EZR","2","48","48","ⴰⵢⵜ ⵏ ⵔⴰⵚⵉⵏ, ⴰⵢⵜ ⵏ ⵏⴰⵇⵇⵓⴷⴰ, ⴰⵢⵜ ⵏ ⵊⴰⵣⵣⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("ER2_49","016_2_49","EZR","2","49","49","ⴰⵢⵜ ⵏ ⵄⵓⵣⵣⴰ, ⴰⵢⵜ ⵏ ⴼⴰⵙⵉⵃ, ⴰⵢⵜ ⵏ ⴱⵉⵙⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("ER2_50","016_2_50","EZR","2","50","50","ⴰⵢⵜ ⵏ ⴰⵙⵏⴰ, ⴰⵢⵜ ⵏ ⵎⴰⵄⵓⵏⵉⵎ, ⴰⵢⵜ ⵏ ⵏⴰⴼⵓⵙⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("ER2_51","016_2_51","EZR","2","51","51","ⴰⵢⵜ ⵏ ⴱⴰⵇⴱⵓⵇ, ⴰⵢⵜ ⵏ ⵃⴰⵇⵓⴼⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵔⵃⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("ER2_52","016_2_52","EZR","2","52","52","ⴰⵢⵜ ⵏ ⴱⴰⵚⵍⵓⵜ, ⴰⵢⵜ ⵏ ⵎⴰⵃⵉⴷⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵔⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("ER2_53","016_2_53","EZR","2","53","53","ⴰⵢⵜ ⵏ ⴱⴰⵔⵇⵓⵙ, ⴰⵢⵜ ⵏ ⵙⵉⵙⴰⵔⴰ, ⴰⵢⵜ ⵏ ⵜⴰⵎⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("ER2_54","016_2_54","EZR","2","54","54","ⴰⵢⵜ ⵏ ⵏⴰⵙⵉⵃ, ⴰⵢⵜ ⵏ ⵃⴰⵟⵉⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("ER2_55","016_2_55","EZR","2","55","55","ⴰⵢⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⴰⵢⵜ ⵏ ⵙⵓⵟⴰⵢ, ⴰⵢⵜ ⵏ ⵙⵓⴼⴰⵔⴰⵜ, ⴰⵢⵜ ⵏ ⴼⴰⵔⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("ER2_56","016_2_56","EZR","2","56","56","ⴰⵢⵜ ⵏ ⵢⴰⵄⴰⵍⴰ, ⴰⵢⵜ ⵏ ⴷⴰⵔⵇⵓⵏ, ⴰⵢⵜ ⵏ ⵊⵉⴷⴷⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("ER2_57","016_2_57","EZR","2","57","57","ⴰⵢⵜ ⵏ ⵛⴰⴼⴰⵟⵢⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵟⵟⵉⵍ, ⴰⵢⵜ ⵏ ⴼⵓⵅⴰⵔⴰⵜ-ⵀⴰ-ⴹⴰⴱⴰⵢⵉⵎ ⴷ ⴰⵢⵜ ⵏ ⴰⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("ER2_58","016_2_58","EZR","2","58","58","ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_59","016_2_59","EZR","2","59","59","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴰⵍ-ⵎⵉⵍⴰⵃ, ⵜⴰⵍ-ⵃⴰⵔⵛⴰ, ⴽⴰⵔⵓⴱ, ⴰⴷⴷⴰⵏ ⴷ ⵉⵎⵎⵉⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵏⵉⵖ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵇⴰⵔⵙⴻⵏ-ⴷⴷ ⵣⵉ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("ER2_60","016_2_60","EZR","2","60","60","ⴰⵢⵜ ⵏ ⴷⴰⵍⴰⵊⴰ, ⴰⵢⵜ ⵏ ⵟⵓⴱⵉⵢⵢⴰ, ⴰⵢⵜ ⵏ ⵏⴰⵇⵓⴷⴰ, ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_61","016_2_61","EZR","2","61","61","ⵓⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⴰⵢⵜ ⵏ ⵃⴰⴱⴰⵢⴰ, ⴰⵢⵜ ⵏ ⵀⴰⵇⵇⵓⵚ, ⴰⵢⵜ ⵏ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ, ⴰⵇⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵊⵉⵍⵄⴰⴷⵉ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ ⵓ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ER2_62","016_2_62","EZR","2","62","62","ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⵅ ⵜⴻⵡⵔⵉⵇⵜ ⵏ ⵓⵣⴻⵎⵎⴻⵎ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("ER2_63","016_2_63","EZR","2","63","63","ⵍⵡⴰⵍⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵏⵏⴰ ⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ ⴰⵍ ⵖⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴽ-ⴷ ⵓⵔⵉⵎ ⴷ ⵜⵓⵎⵎⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER2_64","016_2_64","EZR","2","64","64","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ER2_65","016_2_65","EZR","2","65","65","ⵏⵀⵍⴰ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ ⵏⵙⴻⵏ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵓⵛⴰ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵜⵎⴻⴷⵢⴰⵣⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_66","016_2_66","EZR","2","66","66","ⵉⵢⵙⴰⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ, ⵓ ⵉⵙⴰⵔⴷⴰⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_67","016_2_67","EZR","2","67","67","ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵓ ⵉⵖⵢⴰⵍ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_68","016_2_68","EZR","2","68","68","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵡⵛⵉⵏ ⵛⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ER2_69","016_2_69","EZR","2","69","69","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵉ ⵙⵙⴻⵏⴷⵓⵇ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵏⴻⵛⵜ ⵏ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵡⴰⵃⵉⵜ ⵓ-ⵙⴻⵜⵜⵉⵏ-ⴰⵍⴻⴼ ⵏ ⴷⵔⴰⵅⵎⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵏ ⵎⵉⵏⴰⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵎⵢⴰ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER2_70","016_2_70","EZR","2","70","70","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵛⴰ ⵣⵉ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴳⴳⵉⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵉⴳⴳⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ER3_1","016_3_1","EZR","3","1","1","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ, ⵉⵙⵙⵎⵓⵏ ⵍⴳⴻⵏⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER3_2","016_3_2","EZR","3","2","2","ⵉⴽⴽⴰⵔ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵚⴰⴷⴰⵇ, ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴷ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ, ⵓⵛⴰ ⴱⵏⴰⵏ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("ER3_3","016_3_3","EZR","3","3","3","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵄⴰⵍⵟⴰⵔ ⵅ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ ⵎⴰⵏⵉ ⵜ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵡⴰⵅⵅⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ, ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵅⴰⵙ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ, ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵜⵓⴼⴼⵓⵜ ⵓ ⵉ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("ER3_4","016_3_4","EZR","3","4","4","ⵏⵉⵜⵏⵉ ⵄⴻⵢⵢⴷⴻⵏ ⵄⴰⵡⴻⴷ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵔⴰ, ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⵙⵙ ⵉⴹⴼⴰⵔ ⵓⵎⴰⵙ. ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ER3_5","016_3_5","EZR","3","5","5","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ, ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ, ⵓ ⵄⴰⵡⴻⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴻⵡⵄⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ER3_6","016_3_6","EZR","3","6","6","ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴱⴷⴰⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴷⵙⴰⵙ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("ER3_7","016_3_7","EZR","3","7","7","ⵡⵛⵉⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵉⵎⴰⵚⵚⵓⵜⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵇⵇⵛⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ, ⵓⵛⴰ ⵉ ⴰⵢⵜ ⵏ ⵙⵉⴷⵓⵏ ⵓ ⵉ ⴰⵢⵜ ⵏ ⵚⵓⵔ ⵡⵛⵉⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵛⵛⴰ ⴷ ⵜⵉⵙⵙⵉⵜ ⴷ ⵣⵣⴻⵛⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵏⴻⴳⵍⵉⵏ ⵏ ⵍⵓⴱⵏⴰⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵢⴰⴼⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("ER3_8","016_3_8","EZR","3","8","8","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵡⴰⵡⴰⴹ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴱⴷⴰⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⴷ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵚⴰⴷⴰⵇ, ⴷ ⴰⵢⵜⵎⴰⵙ ⵏⵙⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵄⵉⵛⵍⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⴻⵏⵏⴻⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ER3_9","016_3_9","EZR","3","9","9","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵢⴻⵛⵓⵄⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⴰⴽ-ⴷ ⵇⴰⴷⵎⵢⵉⵍ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵄⴰⵡⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵃⵉⵏⴰⴷⴰⴷ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER3_10","016_3_10","EZR","3","10","10","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ ⵙⵙⵔⵓⵙⴰⵏ ⴷⵙⴰⵙ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵍⴻⴱⵡⴰⵇ, ⵓⵍⴰ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴰⵙⴰⴼ, ⵙ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵛⴻⵏ ⵓⴼⵓⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER3_11","016_3_11","EZR","3","11","11","ⵏⵉⵜⵏⵉ ⵖⴻⵏⵏⵊⴻⵏ ⵙ ⵏⵏⵓⴱⵜⴰⵜ ⵉ ⵙⵉⴷⵉ ⵙ ⵓⵙⴻⵎⵖⴰⵔ ⴷ ⵓⵇⴰⴷⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵅ ⵉⵙⵔⴰⵉⵍ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵖⵓⵢ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉⵎⵖⴰⵔ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⵙⵉⴷⵉ ⵎⴰⵖⴰⵔ ⴷⵙⴰⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴰⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("ER3_12","016_3_12","EZR","3","12","12","ⴰⵟⵟⴰⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ, ⵉⵡⴻⵙⵙⵓⵔⴰ ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵔⵓⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵙⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⴰⵔⴻⵏⵢⴻⵏ ⴷⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵓ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("ER3_13","016_3_13","EZR","3","13","13","ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵍⴳⴻⵏⵙ ⴰⴷ ⵎⴻⵢⵢⵣⴻⵏ ⵊⴰⵔ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵙⵖⵓⵢ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉⵎⵖⴰⵔ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("ER4_1","016_4_1","EZR","4","1","1","ⵓⵎⵉ ⵙⵍⴻⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵜⵓⵖⴰ ⴱⴻⵏⵏⴰⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("ER4_2","016_4_2","EZR","4","2","2","ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴱⵏⴰ ⵊⵎⵉⵄ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⴻⵣⵣⵓ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⵇⴻⴷⴷⴻⵎ ⵜⵉⵖⴰⵔⵚⵉ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⵙⴰⵔⵃⴰⴷⴷⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴰ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ER4_3","016_4_3","EZR","4","3","3","ⵎⴰⵛⴰ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⴷ ⵢⴰⵀⵓⵛⴰⵄ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵊⴰⵔ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵉⴵⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴱⵏⴰ ⵊⵎⵉⵄ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵏⴻⵛⵛⵉⵏ ⵡⴻⵃⵃⴷⵏⴻⵖ ⴰⴷ ⵜⵜ ⵏⴻⴱⵏⴰ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ.” ");
INSERT INTO rift_vpl VALUES ("ER4_4","016_4_4","EZR","4","4","4","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵙⴰⵔⵅⵓⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ ⵜⴻⵏ ⵅ ⵍⴻⴱⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ER4_5","016_4_5","EZR","4","5","5","ⵛⵔⴰⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⴹⵉⴷⴷ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴱⴻⵟⵟⵍⴻⵏ ⴰⵏⵡⴰⵢ ⵏⵙⴻⵏ, ⵓ ⴰⵢⴰ ⵉⴽⴽⴰ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ, ⴰⵍ ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("ER4_6","016_4_6","EZR","4","6","6","ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵖⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ, ⵓⵔⴰⵏ ⵏⵉⵜⵏⵉ ⵉⵊⵊ ⵏ ⵓⵛⴻⵜⵛⵉ ⴹⵉⴷⴷ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER4_7","016_4_7","EZR","4","7","7","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ ⵢⵓⵔⴰ ⴱⵉⵛⵍⴰⵎ ⴰⴽ-ⴷ ⵎⵉⵜⵔⴰⴷⴰⵜ ⴷ ⵟⴰⴱⴰⵢⵉⵍ ⴷ ⵉⵄⵛⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⴻⵖⵏⵉ, ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ. ⵜⵓⵖⴰ ⵜⴰⴱⵔⴰⵜ ⵜⵓⵔⴰ ⵙ ⵜⵉⵔⴰ ⵏ ⵉⵍⴻⵙ ⵏ ⵜⵔⴰⵎⵉⵜ ⵓ ⵜⵓⵖⴰ ⵜⴰⵔⵊⵎⴻⵏ ⵜⵜ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⵔⴰⵎⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("ER4_8","016_4_8","EZR","4","8","8","ⵔⴰⵃⵓⵎ, ⴰⵎⵙⵓⴼⴼⴻⵖ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ, ⴷ ⵓⵎⴰⵔⵉⵔ ⵛⵉⵎⵛⴰⵢ ⵓⵔⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ ⴹⵉⴷⴷ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵢⵓⵔⴰ ⴰⵎⵎⵓ: ");
INSERT INTO rift_vpl VALUES ("ER4_9","016_4_9","EZR","4","9","9","“ⵔⴰⵃⵓⵎ, ⴰⵎⵙⵓⴼⴼⴻⵖ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ, ⴷ ⵓⵎⴰⵔⵉⵔ ⵛⵉⵎⵛⴰⵢ ⴷ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵇⵔⵉⵏⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⵍⵇⵓⴹⴰⵜ, ⵉⵎⵅⴰⵣⵏⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⵛⵛⴻⵏⵄⴻⵜ ⴷ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ ⴷ ⴰⵢⵜ ⵏ ⵉⵔⵉⵅ ⴷ ⴱⴰⴱⵉⵍⵓⵏ ⴷ ⵛⵓⵛⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⵉⵍⴰⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ER4_10","016_4_10","EZR","4","10","10","ⴷ ⵛⵛⵓⵄⵓⴱ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⵉ ⵉⵡⵢⵉ ⵜⴻⵏ ⴰⵙⵏⴰⴼⴼⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵓ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⴷⵉ ⵊⵊⵉⵀⴻⵜ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ... ⵓⵛⴰ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("ER4_11","016_4_11","EZR","4","11","11","ⵜⴰ ⴷ ⵜⵉⵍⴻⵎⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ: “ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ... ⵓⵛⴰ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("ER4_12","016_4_12","EZR","4","12","12","“ⵉⵍⵉ ⴰⴷ ⵉⵙⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ ⵓⴷⴰⵢⴻⵏ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵖⴰⵔⴻⴽ, ⴰⵇⴰ ⵉⵡⴹⴻⵏ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴱⴻⵏⵏⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⴰⵇⴰ ⵜⵜⴽⴻⵎⵎⴰⵍⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵓ ⵄⴻⴷⴷⵍⴻⵏ ⴷⵙⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("ER4_13","016_4_13","EZR","4","13","13","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵍⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵓ ⵍⴻⵃⵢⵓⴹ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵛ ⵍⵊⵉⵣⵢⴰ ⵍⴰ ⴷ ⵍⴻⵄⵛⵓⵔ ⵓⵍⴰ ⴷ ⴹⴹⴰⵔⵉⴱⴰ ⵏ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵙⵙⴻⵅⵙⴰⵔ ⴰⵔⴱⴻⵃ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER4_14","016_4_14","EZR","4","14","14","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵓⵎⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵎⴻⴵⴰⵃ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵖ ⵙ ⵜⵎⴻⴵⴰⵃⵜ ⵏ ⵍⴻⵇⵚⴰⵔ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⵓⵙⵉ ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵅⴻⵣⵣⴰⵔ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⵀⴷⴻⵍ ⵓⵊⴻⴵⵉⴷ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵙⵙⴻⴽⴽ-ⴷⴷ ⵜⴰⴱⵔⴰⵜ-ⴰ ⵓⵛⴰ ⵏⴻⵙⵙⴰⵔⴳⴻⴱ ⴰⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("ER4_15","016_4_15","EZR","4","15","15","ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴰⴼⴻⴷ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵜⵉⵡⵉ-ⴷⴷ ⴰⵔⵔⵥⵉⵢⵢⴻⵜ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓ ⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵓ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵙⵙⴻⴽⴽⴰⵔⴰⵏ ⴷⴰⵢⴻⵙ ⴰⵖⴻⵡⵡⴻⵖ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵀⴷⴻⵎ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("ER4_16","016_4_16","EZR","4","16","16","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴰⵔⴳⴻⴱ ⴰⵊⴻⴵⵉⴷ, ⴰⵇⴰ, ⵎⴰⵍⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜⵜᵉⵜⵜⵉⵍⵉ ⵛⴰ ⵜⴻⵚⵖⴰⵔⵜ ⵄⴰⴷ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ.” ");
INSERT INTO rift_vpl VALUES ("ER4_17","016_4_17","EZR","4","17","17","ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵜⴰⵎⵡⴰⵔⵔⵉⵜ ⵉ ⵔⴰⵃⵓⵎ, ⴰⵎⵙⵓⴼⴼⴻⵖ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ, ⵓ ⵉ ⵓⵎⴰⵔⵉⵔ ⵛⵉⵎⵛⴰⵢ ⴷ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵇⵔⵉⵏⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⵓ ⵓⵍⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ: “ⵍⴻⵀⵏⴰ! ... ⵓⵛⴰ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("ER4_18","016_4_18","EZR","4","18","18","“ⵜⴰⴱⵔⴰⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴻⵎ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵖⴰⵔ ⵅⴰⴼⵉ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ER4_19","016_4_19","EZR","4","19","19","ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵓⵎⵓⵔⴻⵖ ⴰⵢⴰ, ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉⵛⵜ ⵏ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵓⵛⴰ ⵓⴼⵉⵏ ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⵜⵖⴻⵡⵡⴻⵖ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⴷⴰⵢⴻⵙ ⵍⴻⴱⴷⴰ ⴰⵖⴻⵡⵡⴻⵖ ⴷ ⵍⴻⵃⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("ER4_20","016_4_20","EZR","4","20","20","ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⴰⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⴰⵙⴻⵏ ⵍⵊⵉⵣⵢⴰ ⴷ ⵍⴻⵄⵛⵓⵔ ⴷ ⴹⴹⴰⵔⵉⴱⴰ ⵏ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ER4_21","016_4_21","EZR","4","21","21","ⵉⵡⴰ, ⵍⴻⵅⵅⵓ ⵓⵎⵓⵔⴻⵎ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵎ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ. ⵜⴰⵏⴷⵉⵏⵜ ⵡⴰⵔ ⵜⴱⴻⵏⵏⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵣⵣⴰⵢⵉ ⵍⵓⵎⵓⵔ ⵉ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER4_22","016_4_22","EZR","4","22","22","ⵖⴰⵔⵡⴻⵎ ⴰⵇⴰ ⴰⴷ ⵜⴰⵔⵅⵓⵎ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵎⵖⴰⵔ ⴷⵔⵓⵛⵜ ⵄⴰⴷ ⵉ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("ER4_23","016_4_23","EZR","4","23","23","ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵖⴰⵔ ⵜⴻⴱⵔⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ ⵉ ⵔⴰⵃⵓⵎ ⴷ ⵛⵉⵎⵛⴰⵢ, ⴰⵎⴰⵔⵉⵔ, ⴷ ⵉⵇⵔⵉⵏⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⵓⵢⵓⵔⴻⵏ ⵉⵏⴰ ⵙ ⵜⴰⵣⵍⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴻⵏ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ ⵙ ⵓⵖⵉⵍ ⵓ ⵙ ⵍⵅⵓⵏⵛⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ER4_24","016_4_24","EZR","4","24","24","ⵅⴻⵏⵏⵉ ⵜⴱⴻⴷⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("ER5_1","016_5_1","EZR","5","1","1","ⵅⴻⵏⵏⵉ ⵏⴻⴱⴱⴰⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵃⴰⴳⴳⴰⵢ ⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⴷⵓ, ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴰⴱⴱⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("ER5_2","016_5_2","EZR","5","2","2","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⴷ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵚⴰⴷⴰⵇ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER5_3","016_5_3","EZR","5","3","3","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵜⴰⵜⵏⴰⵢ, ⵍⵡⴰⵍⵉ ⵏ ⵡⴻⵇⵍⵉⵎ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴰⴽ-ⴷ ⵛⴰⵜⴰⵔ-ⴱⵓⵣⵏⴰⵢ ⵓ ⵖⴰⵔⵙⴻⵏ ⵉⵇⵔⵉⵏⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ. ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⴰⵎⵎⵓ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵎⵓⵔⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴱⵏⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵍⵃⵉⴹ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("ER5_4","016_5_4","EZR","5","4","4","ⵅⴻⵏⵏⵉ ⵏⴻⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵏⵏⴰⵏ ⵍⴻⴱⵏⵉ-ⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER5_5","016_5_5","EZR","5","5","5","ⵎⴰⵛⴰ ⵜⵉⵟⵟ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⵅ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⴱⴻⴷⴷⴰⵏ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵍ ⵖⴰ ⵜⴰⵡⴻⴹ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵖⴰⵔ ⴷⴰⵔⵉⵢⵓⵙ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⴱⵔⴰⵜ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER5_6","016_5_6","EZR","5","6","6","ⵜⵉⵍⴻⵎⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵜⴰⵜⵏⴰⵢ, ⵍⵡⴰⵍⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴰⴽ-ⴷ ⵛⴰⵜⴰⵔ-ⴱⵓⵣⵏⴰⵢ ⴷ ⵉⵇⵔⵉⵏⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⵉⵇⵔⵉⵏⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("ER5_7","016_5_7","EZR","5","7","7","ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵜⵓⵔⴰ ⴷⴰⵢⴻⵙ ⴰⵎⵎⵓ: “ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ ⵍⴻⵀⵏⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("ER5_8","016_5_8","EZR","5","8","8","“ⵉⵜⵜⵅⴻⵚⵙⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴱⴻⵏⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵙ ⵉⵥⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ, ⵓ ⵉⵜⵜⵡⴰⵜⵜⴻⴳⴳ ⵓⴽⴻⵛⵛⵓⴹ ⴷⵉ ⵍⴻⵃⵢⵓⴹ. ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ ⵙ ⵛⴹⴰⵔⴻⵜ ⵓⵛⴰ ⵜⴻⴳⴳⵓⵔ ⵎⵍⵉⵃ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER5_9","016_5_9","EZR","5","9","9","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵇⵙⴰ ⵉⵎⵖⴰⵔⴻⵏ-ⴰ ⵓ ⵏⴻⵏⵏⴰ ⴰⵙⴻⵏ ⴰⵎⵎⵓ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉⵏ ⵍⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵍⵃⵉⴹ-ⴰ?’ ");
INSERT INTO rift_vpl VALUES ("ER5_10","016_5_10","EZR","5","10","10","ⵏⴻⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⵓⵍⴰ ⵅ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜⴻⵏ-ⵉ-ⴷⴷ-ⵏⵉⵏⵉ, ⴰⵍⴰⵎⵉ ⵏⵉⵡⴻⴹ ⴰⴷ ⵏⵣⴻⵎⵎⴻⵎ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER5_11","016_5_11","EZR","5","11","11","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ ⴰⵏⴻⵖ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵎⵎⵓ: ‘ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵏⴻⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⴷⴰⵏⵉⵜⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ. ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⴱⵏⴰ ⵜⵜ ⵓ ⵉⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("ER5_12","016_5_12","EZR","5","12","12","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⵙⵄⴰⵔⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵇⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵅⴰⵍⴷⵉⵡⵉ, ⵡⴻⵏⵏⵉ ⵉⵀⴻⴷⵎⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⵉⵏⴷⴻⵀ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER5_13","016_5_13","EZR","5","13","13","ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵢⵓⵎⵓⵔ ⴽⵓⵔⴰⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵡⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ER5_14","016_5_14","EZR","5","14","14","ⵓⵍⴰ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⵉⵏⵏⵉ ⵉⴽⴽⴻⵙ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏⵜ ⴽⵓⵔⴰⵛ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⴷⵉ ⴱⴰⴱⵉⵍ ⵓ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵛⴱⴰⵚⵚⴰⵔ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴷ ⵍⵡⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("ER5_15","016_5_15","EZR","5","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: ⴽⵙⵉ ⵍⴻⵇⵛⵓⵄ-ⴰ, ⵔⵓⵃ, ⴳⴳⴻⵎ ⵜⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵣⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("ER5_16","016_5_16","EZR","5","16","16","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵛⵉⵛⴱⴰⵚⵚⴰⵔ ⵡⴰⵏⵉⵜⴰ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴷⵙⵓⵙⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵙⵙⴻⵏⵏⵉ ⴰⵍ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⴱⴻⵏⵏⴰⵏ ⵜⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵄⴰⴷ.’ ");
INSERT INTO rift_vpl VALUES ("ER5_17","016_5_17","EZR","5","17","17","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⵢⴰⵔⴹⴰ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴻⵊⵊ ⴰⴷ ⴰⵔⵣⵓⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⴱⴰⴱⵉⵍ, ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵉⵎⵎⴻⵡⵛ ⵍⵓⵎⵓⵔ ⵣⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵅⴻⵏⵏⵉ ⵍⵇⴰⵔⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("ER6_1","016_6_1","EZR","6","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ ⵍⵓⵎⵓⵔ ⵓⵛⴰ ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵎⴰⵏⵉ ⵜⵜⵡⴰⵅⴻⵎⵎⵍⴻⵏⵜ ⵜⵅⵓⴱⴰⵢ ⴷⵉⵏ ⴷⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER6_2","016_6_2","EZR","6","2","2","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼ ⴷⵉ ⴰⵃⵎⴰⵜⴰ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⵎⵉⴷⵢⴰ ⵓ ⴷⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵜⵉⵔⴰ-ⵢⴰ ⵏ ⵍⵉⴷⴰⵔⴻⵜ: ");
INSERT INTO rift_vpl VALUES ("ER6_3","016_6_3","EZR","6","3","3","“ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⴽⵓⵔⴰⵛ ⵍⵓⵎⵓⵔ-ⴰ: ‘ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴻⴷⴷⵍⴻⵏ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ. ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ER6_4","016_6_4","EZR","6","4","4","ⵙ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵙⴷⵓⴷ ⵏ ⵜⵚⵓⴹⴰⵔ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵙⵙⴻⴷⴷ ⵏ ⵜⴻⴼⵍⴰⵡⵜ ⴷ ⵊⴷⵉⴷ. ⵎⵉⵏ ⴷⵉⵏ ⵉⵅⴻⵚⵚⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⴽⴻⵍⵍⴻⴼ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ER6_5","016_6_5","EZR","6","5","5","ⵓⵍⴰ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⵉⵏⵏⵉ ⵉⴽⴽⴻⵙ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵉⵡⵢⵉ ⵜⴻⵏⵜ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⴰⴷ ⵜⵜⵡⴰⵔⵔⴻⵏⵜ. ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵎⵎⴰⵔⵙⴻⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.’ ");
INSERT INTO rift_vpl VALUES ("ER6_6","016_6_6","EZR","6","6","6","ⵙ ⵓⵢⴰ, ⵜⴰⵜⵏⴰⵢ, ⵍⵡⴰⵍⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵛⴰⵜⴰⵔ-ⴱⵓⵣⵏⴰⵢ ⴷ ⵉⵇⵇⵔⵉⵏⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⵉⵇⵇⵔⵉⵏⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴰⴳⴳⵯⴻⵊⴻⵎ ⵙⵙⴻⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("ER6_7","016_6_7","EZR","6","7","7","ⵊⵊⴻⵎ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⵍⵡⴰⵍⵉ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴰⴷ ⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ER6_8","016_6_8","EZR","6","8","8","ⵄⴰⵡⴻⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵉ ⵍⵓⵎⵓⵔ ⵅ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵡⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉ. ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵣⵉ ⵍⵊⵉⵣⵢⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵙ ⵛⴹⴰⵔⴻⵜ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⵉ ⵛⴰ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ER6_9","016_6_9","EZR","6","9","9","ⵓ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴻⵏ ⵣⴻⴳ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵜⵖⴰⵔⵚⵉ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵓ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴻⵏ ⵣⴻⴳ ⵉⵔⴷⴻⵏ ⴷ ⵜⵎⴻⴵⴰⵃⵜ ⴷ ⴱⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴻⵡⵛ ⵣⴻⴳ ⵡⴰⵙⵙ ⵖⴰⵔ ⵡⴰⵙⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵓⵍⴰ ⴷ ⵡⴰⵍⵓ, ");
INSERT INTO rift_vpl VALUES ("ER6_10","016_6_10","EZR","6","10","10","ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵓⵛⴰ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ER6_11","016_6_11","EZR","6","11","11","ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵉ ⵍⵓⵎⵓⵔ ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴱⴻⴷⴷⵍⴻⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵙⵙⴱⴻⴷⴷⴻⵏ, ⴰⴷ ⵅⴰⵙ ⵉⵜⵜⵡⴰⵢⴻⵍ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵣⵓⴱⴰⵛⵜ ⵏ ⵍⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ER6_12","016_6_12","EZR","6","12","12","ⴻⵊⵊ ⴰⴷ ⵉⵀⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵉⵙⵙⴻⵣⴷⵖⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴽⵓⵍ ⴰⵊⴻⴵⵉⴷ ⴷ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⴻⴷⴷⴻⵍ ⵏⵉⵖ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵛⵛ ⴷⴰⵔⵉⵢⵓⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵍⵓⵎⵓⵔ. ⴻⵊⵊ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵛⴹⴰⵔⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("ER6_13","016_6_13","EZR","6","13","13","ⵅⴻⵏⵏⵉ ⵜⴰⵜⵏⴰⵢ, ⵍⵡⴰⵍⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⴰⴽ-ⴷ ⵛⴰⵜⴰⵔ-ⴱⵓⵣⵏⴰⵢ ⴷ ⵉⵇⵔⵉⵏⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⴳⴳⵉⵏ ⵙ ⵛⴹⴰⵔⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("ER6_14","016_6_14","EZR","6","14","14","ⴱⵏⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⵔⵏⵉⵏ ⵎⵍⵉⵃ ⴷⵉ ⵍⴻⴱⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⵃⴰⴳⴳⴰⵢ ⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⴷⴷⵓ. ⵏⵉⵜⵏⵉ ⴱⵏⴰⵏ ⵓ ⴽⴻⵎⵎⵍⴻⵏ ⵜⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴽⵓⵔⴰⵛ ⴷ ⴷⴰⵔⵉⵢⵓⵙ ⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("ER6_15","016_6_15","EZR","6","15","15","ⵓⵛⴰ ⴰⵎⵎⵓ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵓⵢⵓⵔ ⴰⴷⴰⵔ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("ER6_16","016_6_16","EZR","6","16","16","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⴷⴻⵛⵛⵏⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ER6_17","016_6_17","EZR","6","17","17","ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵎⵢⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ, ⵓ ⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⵓⵢⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER6_18","016_6_18","EZR","6","18","18","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ ⵓ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏⵙⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("ER6_19","016_6_19","EZR","6","19","19","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("ER6_20","016_6_20","EZR","6","20","20","ⵎⵉⵏⵣⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴳⴳⵉⵏ ⴰⴷ ⵙⵙⵉⵣⴷⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵚⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵓ ⵉ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER6_21","016_6_21","EZR","6","21","21","ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵍⵎⴻⵏⴼⴰ, ⵛⵛⵉⵏ ⵣⵣⴰⵢⴻⵙ, ⵓⵍⴰ ⴷ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵅⵓⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER6_22","016_6_22","EZR","6","22","22","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵄⴻⵢⵢⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴼⵔⴰⵃ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵎⴻⵢⵢⴻⵍ ⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵖⴰⵔⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER7_1","016_7_1","EZR","7","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴷ ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ, ⴰⵇⴰ ⴷⵉⵏ ⵄⵉⵣⵔⴰ, ⵎⵎⵉⵙ ⵏ ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("ER7_2","016_7_2","EZR","7","2","2","ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("ER7_3","016_7_3","EZR","7","3","3","ⵎⵎⵉⵙ ⵏ ⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵔⴰⵢⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("ER7_4","016_7_4","EZR","7","4","4","ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ-ⵢⴰⵀ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵉ, ⵎⵎⵉⵙ ⵏ ⴱⵓⵇⵇⵉ, ");
INSERT INTO rift_vpl VALUES ("ER7_5","016_7_5","EZR","7","5","5","ⵎⵎⵉⵙ ⵏ ⴰⴱⵉⵛⵓⵄⴰ, ⵎⵎⵉⵙ ⵏ ⴼⵉⵏⵃⴰⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER7_6","016_7_6","EZR","7","6","6","ⵄⵉⵣⵔⴰ ⵡⴰⵏⵉⵜⴰ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⴱⴰⴱⵉⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵍⵎⴰⴷ ⴷ ⴰⵎⵉⵖⵉⵙ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵡⵛⴰ ⴰⵙ ⵎⴰⵔⵔⴰ ⵅ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵙ ⵎⵉⵏⵣⵉ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ-ⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ER7_7","016_7_7","EZR","7","7","7","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ ⴳⴻⵄⵄⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("ER7_8","016_7_8","EZR","7","8","8","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵉⵡⴻⴹ ⵄⵉⵣⵔⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER7_9","016_7_9","EZR","7","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ-ⵜ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵡⵓⴼⴼⵓⵖ ⵣⵉ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵉⵚⴻⴱⵃⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("ER7_10","016_7_10","EZR","7","10","10","ⵎⴰⵖⴰⵔ ⵄⵉⵣⵔⴰ ⵉⴳⴳⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⵣⵓ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⵓ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER7_11","016_7_11","EZR","7","11","11","ⵜⴰ ⴷ ⵜⵉⵍⴻⵎⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵉⵡⵛⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ ⴰⴽ-ⴷ ⵄⵉⵣⵔⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⴷ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵍⵎⴰⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵉ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("ER7_12","016_7_12","EZR","7","12","12","“ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵉ ⵄⵉⵣⵔⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⴷ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵍⴻⵀⵏⴰ ⵉⵎⵓⵏ! ... ⵓⵛⴰ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("ER7_13","016_7_13","EZR","7","13","13","“ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵉ ⵍⵓⵎⵓⵔ ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵡⴻⵏⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵅⵙ ⴰⴷ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("ER7_14","016_7_14","EZR","7","14","14","ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⴷ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⵇⵇⵛⴻⴷ ⴷⵉ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵍⵃⴰⵍ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("ER7_15","016_7_15","EZR","7","15","15","ⵜᵉⵜⵜⵡⴰⵙⴻⴽⴽⴻⴷ ⵄⴰⵡⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⴰⵡⵢⴻⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⵛⴰ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("ER7_16","016_7_16","EZR","7","16","16","ⵓ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉ ⵖⴰ ⵜⴰⴼⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⴱⴰⴱⵉⵍ, ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵟⴻⵡⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵣⴻⴳ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⵙ ⵓⵟⴻⵡⵡⴻⵄ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("ER7_17","016_7_17","EZR","7","17","17","ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵖⴻⴷ ⵙ ⵏⵏⵓⵇⴰⵔⵜ-ⴰ ⵙ ⵛⴹⴰⵔⴻⵜ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵉⵣⵎⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER7_18","016_7_18","EZR","7","18","18","ⵙ ⵎⵉⵏ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴳⴳⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ ⴷ ⴰⵢⵜⵎⴰⵛ ⵎⵍⵉⵃ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ER7_19","016_7_19","EZR","7","19","19","ⵓⵛⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⴷ ⴰⵛ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵄⴷⵓ ⵜⴻⵏ ⵖⴰⵔ ⴷⵉⵏ ⵣⵣⴰⵜ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER7_20","016_7_20","EZR","7","20","20","ⵎⵉⵏ ⵖⴰ ⵉⵅⴻⵚⵚⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⵅⴰⴽ ⴰⴷ ⵜ ⵜⵅⴻⴵⵚⴻⴷ, ⴻⵡⵛ ⵉ-ⵜ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ER7_21","016_7_21","EZR","7","21","21","ⵏⴻⵛⵛ, ⴰⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵍⵓⵎⵓⵔ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵅ ⵜⵅⵓⴱⴰⵢ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵙ ⵛⴹⴰⵔⴻⵜ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵖⴰ ⵉⵜⵜⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("ER7_22","016_7_22","EZR","7","22","22","ⴰⵍ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⵍ ⵎⵢⴰ ⵉⴽⵓⵔⵓⵜⴻⵏ ⵏ ⵉⵔⴷⴻⵏ, ⴰⵍ ⵎⵢⴰ ⵉⴱⴰⵜⵓⵜⴻⵏ ⵏ ⴱⵉⵏⵓ ⵓ ⴰⵍ ⵎⵢⴰ ⵉⴱⴰⵜⵓⵜⴻⵏ ⵏ ⵣⵣⴻⵛⵜ, ⵓⵛⴰ ⵉ ⵜⵎⴻⴵⴰⵃⵜ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ER7_23","016_7_23","EZR","7","23","23","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵉ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵙ ⵛⴹⴰⵔⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴻⵖⴹⴰⴱ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("ER7_24","016_7_24","EZR","7","24","24","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴷ ⵉⵎⴻⵖⵏⵓⵊⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵏⵉⵜⴰ, ⴰⵇⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⵅⴻⴱⴱⴰⵔ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ ⵍⴻⵄⵛⵓⵔ, ⵍⴰ ⴷ ⵍⵊⵉⵣⵢⴰ ⵓⵍⴰ ⴷ ⴹⴹⴰⵔⵉⴱⴰ ⵏ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ER7_25","016_7_25","EZR","7","25","25","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵄⵉⵣⵔⴰ, ⵙ ⵜⵉⵖⵉⵜ ⵉ ⴷ ⴰⵛ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵍⴻⵇⵇⴻⵎ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵉⵣⴻⵔⴼⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵓⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵉⵏⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("ER7_26","016_7_26","EZR","7","26","26","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴹⴼⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴷ ⵓⵣⴻⵔⴼ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵙ ⵛⴹⴰⵔⴻⵜ, ⵎⴰ ⵙ ⵍⵎⴻⵡⵜ ⵏⵉⵖ ⵙ ⵍⵎⴻⵏⴼⴰ ⵏⵉⵖ ⵙ ⵎⵓⵍⵜⴰ ⵏ ⵡⴰⴳⵍⴰ ⵏⵉⵖ ⵙ ⵍⴻⵃⴱⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("ER7_27","016_7_27","EZR","7","27","27","ⴰⵙⴻⵎⵖⴰⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵢⴰ ⴰⵎⵎⵓ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵏⵉ ⴰⵛⴻⵏⵏⴻⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER7_28","016_7_28","EZR","7","28","28","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ! ⵓⵛⴰ ⵓⵎⵉ ⵅⴰⴼⵉ ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴳⴳⵉⵖ ⵓⵍ ⵓ ⵙⵙⵎⵓⵏⴻⵖ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵉ ⴳⴻⵄⵄⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_1","016_8_1","EZR","8","1","1","ⵉⵏⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ, ⴰⴽ-ⴷ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ ⴷⴷ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⴱⴰⴱⵉⵍ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵜⴳⴻⵍⴷⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("ER8_2","016_8_2","EZR","8","2","2","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴼⵉⵏⵃⴰⵙ: ⵊⴰⵔⵛⵓⵎ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵜⴰⵎⴰⵔ: ⴷⴰⵏⵉⵢⴰⵍ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴷⴰⵡⵓⴷ: ⵃⴰⵟⵟⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("ER8_3","016_8_3","EZR","8","3","3","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵛⴰⴽⴰⵏⵢⴰ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴼⴰⵔⵓⵛ: ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵓ ⴰⴽⵉⴷⴻⵙ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽ-ⴷ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_4","016_8_4","EZR","8","4","4","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴼⴰⵃⴰⵜ-ⵎⵓ’ⴰⴱ: ⵉⵍⵢⵓⵄⵉⵏⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⴰⵃ-ⵢⴰⵀ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_5","016_8_5","EZR","8","5","5","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵛⴰⴽⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵃⵣⵉⵢⵉⵍ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_6","016_8_6","EZR","8","6","6","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⴷⵉⵏ: ⵄⴰⴱⵉⴷ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_7","016_8_7","EZR","8","7","7","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⵉⵍⴰⵎ: ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵜⴰⵍⵢⴰ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_8","016_8_8","EZR","8","8","8","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵛⴰⴼⴰⵟⵢⴰ: ⵣⴰⴱⴰⴷⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰⵢⵉⵍ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_9","016_8_9","EZR","8","9","9","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⵓⵡⴰⴱ: ⵄⵓⴱⴰⴷⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵃⵉⵢⵉⵍ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵎⴻⵏⵜⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_10","016_8_10","EZR","8","10","10","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⴰⵏⵉ: ⵛⴰⵍⵓⵎⵉⵜ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⴰⴼⵢⴰ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_11","016_8_11","EZR","8","11","11","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⴰⴱⴰⵢ: ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⴱⴰⵢ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_12","016_8_12","EZR","8","12","12","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵊⴰⴷ: ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵇⵇⴰⵟⴰⵏ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵎⵢⴰ ⵓ-ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_13","016_8_13","EZR","8","13","13","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴰⴷⵓⵏⵉⵇⴰⵎ, ⵉⵏⴻⴳⴳⵓⵔⴰ, ⴷ ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ: ⵉⵍⵉⴼⴰⵍⴰⵟ, ⵢⴰⵄⵉⵢⵉⵍ ⴷ ⵛⴰⵎⵄⵉⵢⴰ ⵓ ⴰⴽⵉⴷⵙⴻⵏ ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_14","016_8_14","EZR","8","14","14","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵖⵡⴰⵢ: ⵄⵓⵜⴰⵢ ⴷ ⵣⴰⴱⴱⵓⴷ ⵓ ⴰⴽⵉⴷⴻⵙ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_15","016_8_15","EZR","8","15","15","ⵏⴻⵛⵛ ⵙⵙⵎⵓⵏⴻⵖ ⵜⴻⵏ ⵖⴰⵔ ⵉⵖⵣⴰⵔ ⵏⵏⵉ ⵉⵜⵜⴻⴽⴽⴻⵏ ⵅ ⴰⵀⴰⵡⴰ. ⴷⵉⵏⵏⵉ ⵏⴻⵡⵜⴰ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓ ⵏⴻⵛⵛ ⵃⴻⴽⴽⴰⵔⴻⵖ ⵉ ⵍⴳⴻⵏⵙ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵡⴰⵔ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_16","016_8_16","EZR","8","16","16","ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⵔⵉⵢⵉⵍ, ⵛⴰⵎⵄⵉⵢⴰ, ⵉⵍ-ⵏⴰⵜⴰⵏ, ⵢⴰⵔⵉⴱ, ⴰⵍⵏⴰⵜⴰⵏ, ⵏⴰⵜⴰⵏ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵓ ⵖⴰⵔ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵉⵏⵏⵉ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ, ⵓ ⵖⴰⵔ ⵢⵓⵢⴰⵔⵉⴱ ⴷ ⵉⵍ-ⵏⴰⵜⴰⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ER8_17","016_8_17","EZR","8","17","17","ⵓⵎⵓⵔⴻⵖ ⵜⴻⵏ ⵅ ⵄⵉⴷⴷⵓ, ⴰⵣⴻⴵⵉⴼ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴽⴰⵙⵉⴼⵢⴰ, ⵓⵛⴰ ⴳⴳⵉⵖ ⴰⵙⴻⵏ ⴰⵡⴰⵍⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵏⵉⵏ ⵉ ⵄⵉⴷⴷⵓ, ⵉ ⵓⵍⵜⵎⴰⵙ ⵓ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴽⴰⵙⵉⴼⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ER8_18","016_8_18","EZR","8","18","18","ⵓⵎⵉ ⵜⵓⵖⴰ ⵅⴰⵏⴻⵖ ⴰⴼⵓⵙ ⵉⵚⴻⴱⵃⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵙⵙⴻⴽⴽⴻⵏ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵎⴰⵃⵍⵉ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ, ⵎⵎⵉⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⵡⴰⵏⵉⵜⴰ ⴷ ⵛⴰⵔⴰⴱⵢⴰ, ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ER8_19","016_8_19","EZR","8","19","19","ⵓ ⵄⴰⵡⴻⴷ ⵃⴰⵛⴰⴱⵢⴰ ⵓ ⴰⴽⵉⴷⴻⵙ ⵉⵛⴰⵄⵢⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵎⴰⵔⴰⵔⵉ, ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_20","016_8_20","EZR","8","20","20","ⵓ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴷⴰⵡⵓⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_21","016_8_21","EZR","8","21","21","ⵅⴻⵏⵏⵉ ⵍⴰⵖⵉⵖ ⴷⵉⵏⵏⵉ ⵖⴰⵔ ⵉⵖⵣⴰⵔ ⵏ ⴰⵀⴰⵡⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵙⵙⴰⴹⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰⵔ ⵜⵉⵛⵍⵉ ⴷ ⵜⴰⵎⵉⵎⵓⵏⵜ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓ ⵉ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵖ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓ ⵉ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("ER8_22","016_8_22","EZR","8","22","22","ⵎⴰⵖⴰⵔ ⵜⵜⵙⴻⴷⵃⵉⵖ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵣⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⵄⴰⵡⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴹⵉⴷⴷ ⵉ ⵍⴻⵄⴷⵓ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵏⴻⵙⵙⴰⵡⴰⵍ ⴷⴻⴳ ⵓⵊⴻⴵⵉⴷ, ⵏⴻⵏⵏⴰ: “ⴰⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⵎⴰⵛⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵅⴰⵙ ⵉⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ER8_23","016_8_23","EZR","8","23","23","ⵉⵡⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵥⵓⵎⵎ ⵓ ⵏⴻⵜⵜⴰⵔ ⴰⵢⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵜⴰⵊⴻⴱ ⴰⵏⴻⵖ ⵉ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ER8_24","016_8_24","EZR","8","24","24","ⵅⴻⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⵛⴰⵔⴰⴱⵢⴰ ⴷ ⵃⴰⵛⴰⴱⵢⴰ ⵓ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_25","016_8_25","EZR","8","25","25","ⵡⴻⵣⵏⴻⵖ ⵣⵣⴰⵜⵙⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ, ⴰⵇⴰ ⴰⵢⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵜⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵜⵜⵡⴰⴼⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER8_26","016_8_26","EZR","8","26","26","ⵡⴻⵣⵏⴻⵖ ⵓ ⴳⴳⵉⵖ ⴰⵙⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵎⵢⴰ ⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵡⴻⵣⵏⴻⵏ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵓ ⵎⵢⴰ ⵜⴰⵍⵉⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ");
INSERT INTO rift_vpl VALUES ("ER8_27","016_8_27","EZR","8","27","27","ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⴼⴻⵏⵊⴰⵍⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⵙⴻⴽⴽⵯⴰⵏ ⴰⵍⴻⴼ ⴷⵔⴰⵅⵎⴰⵜ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ, ⵉⵛⴻⵍⵍⴻⵍ, ⵉⵛⵏⴰ, ⵉⵖⵍⴰ ⴰⵎ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ER8_28","016_8_28","EZR","8","28","28","ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵓ ⵍⴻⵇⵛⵓⵄ-ⴰ ⴰⵇⴰ ⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴵⴰⵏ, ⵓⵍⴰ ⴷ ⵏⵏⵓⵇⴰⵔⵜ-ⴰ ⴷ ⵡⵓⵔⴻⵖ-ⴰ, ⴰⵇⴰ ⴰⵢⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ER8_29","016_8_29","EZR","8","29","29","ⵄⴻⵙⵙⴻⵎ ⵓ ⵃⴹⴰⵎ ⴰⵢⴰ ⴰⵍ ⵜ ⵖⴰ ⵜⵡⴻⵣⵏⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("ER8_30","016_8_30","EZR","8","30","30","ⵅⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵍⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ER8_31","016_8_31","EZR","8","31","31","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏⴻⴽⴽⴻⵙ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅⴰⵏⴻⵖ ⵓⵛⴰ ⵉⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴻⵄⴷⵓ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⵉⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ER8_32","016_8_32","EZR","8","32","32","ⵓⵛⴰ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵏⴻⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_33","016_8_33","EZR","8","33","33","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉⵜⵜⵡⴰⵡⵣⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵇⵛⵓⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓⵛⴰ ⵏⴻⵡⵛⴰ ⴰⵢⴰ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵔⵉⵎⵓⵜ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉⵢⴰ, ⵓⵛⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⴼⵉⵏⵃⴰⵙ, ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ ⵓⵍⴰ ⴷ ⵢⵓⵣⴰⴱⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵢⴻⵛⵓⵄⴰ, ⴷ ⵏⵓⵄⴰⴷⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⵏⵓⵢ, ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_34","016_8_34","EZR","8","34","34","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⴷ ⵍⴻⵡⵣⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵣⴻⵏ ⵉⵜⵜⵡⴰⵡⵣⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER8_35","016_8_35","EZR","8","35","35","ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ: ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵙⴻⵜⵜⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ, ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⵓⵢⴰⵏ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ER8_36","016_8_36","EZR","8","36","36","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉ ⵍⵡⵓⵍⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⴼⵓⵙ ⵉ ⵍⴳⴻⵏⵙ ⵓ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("ER9_1","016_9_1","EZR","9","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵍⵃⵓⴽⴽⴰⵎ, ⵏⵏⴰⵏ: “ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵡⴰⵎⵙⴻⴱⴹⴰⵏ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ-ⵢⴰ, ⵎⴰⵖⴰⵔ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵜⵉⵏⵏⵉ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ ⴷ ⵉⴼⵉⵔⵉⵣⵉⵢⵢⴻⵏ ⴷ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER9_2","016_9_2","EZR","9","2","2","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵣⴻⴳ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵚⵓⵔⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵙ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ-ⵢⴰ, ⵡⴰⵀ, ⴰⴼⵓⵙ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷⵉ ⵍⴻⵖⴷⴰⵔ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("ER9_3","016_9_3","EZR","9","3","3","ⵓⵎⵉ ⵙⵍⵉⵖ ⴰⵢⴰ, ⵛⴰⵔⵔⴳⴻⵖ ⴰⵔⵔⵓⴹ ⵉⵏⵓ ⴷ ⵓⵙⴻⵍⵀⴰⵎ ⵉⵏⵓ, ⵇⴻⵍⵄⴻⵖ-ⴷⴷ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵓ ⵏ ⵜⵎⴰⵔⵜ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵖ ⵊⴻⵄⵄⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ER9_4","016_9_4","EZR","9","4","4","ⵅⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵎⴰⵔⵔⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴷⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵊⴻⵄⵄⴰⵔⴻⵖ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("ER9_5","016_9_5","EZR","9","5","5","ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ ⴽⴽⴰⵔⴻⵖ ⵣⴻⴳ ⵓⵙⵡⴰⴹⴻⵄ ⵉⵏⵓ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵏⵓ ⴷ ⵓⵙⴻⵍⵀⴰⵎ ⵉⵏⵓ ⵉⵛⴰⵔⵔⴳⴻⵏ ⵓⵛⴰ ⵓⴹⴰⵔⴻⵖ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵓ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ER9_6","016_9_6","EZR","9","6","6","ⵏⵏⵉⵖ: “ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵙⴻⴷⵃⵉⵖ ⵓ ⵜⵜⵡⴰⵙⵙⴱⴻⵀⴷⵍⴻⵖ ⴰⵍ ⵡⴰⵔ ⵣⵄⵉⵎⴻⵖ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵜⴻⵎⵖⴰⵔ ⴰⵏⴻⵖ ⵅ ⵓⵣⴻⴵⵉⴼ ⵓ ⴰⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵖ ⵉⵎⵖⴰⵔ ⴰⵍ ⴰⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("ER9_7","016_9_7","EZR","9","7","7","ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴰⵍ ⴰⵙⵙ-ⴰ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⴻⴳ ⵓⵎⴰⵔⵡⴰⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵏⴻⵎⵎⴻⵡⵛ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ, ⴰⵇⴰ ⵏⴻⵎⵎⴻⵡⵛ ⵉ ⵙⵙⵉⴼ, ⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵉ ⵓⴽⴻⵛⵛⴻⴹ ⵓ ⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵅ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵏⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("ER9_8","016_9_8","EZR","9","8","8","ⵍⴻⵅⵅⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵣⴻⵃⵣⵉⵃⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵏ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵢⴻⵊⵊ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵍⴻⵡⵜⴻⴷ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵜⴼⴰⵡⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⵔⵔ ⵏⵏⴻⴼⵙ ⵛⵡⴰⵢⵜ ⴷⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ER9_9","016_9_9","EZR","9","9","9","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ, ⵎⴰⵛⴰ ⴷⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵏⵏⴻⵖ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵉⵙⵎⵉⵃ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵍⴰ ⴰⵏⴻⵖ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵍⴼⵓⵔⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⵔⵔ ⵏⵏⴻⴼⵙ ⵉ ⵓⵙⴱⴻⴷⴷⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵡⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉ, ⵉ ⵡⴻⵄⴷⴰⵍ ⵏ ⵍⵅⵉⵔⴱⴰⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵙ ⵍⵃⵉⴹ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("ER9_10","016_9_10","EZR","9","10","10","“ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵄⴰⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵙⵎⴻⵃ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("ER9_11","016_9_11","EZR","9","11","11","ⵜⵉⵏⵏⵉ ⵜⵓⵎⵓⵔⴻⴷ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵏⵏⴰⵏ: ‘ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ ⴷ ⵍⵡⴰⵔⵜ, ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵙ ⵍⴻⵅⵎⴻⵊ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ, ⵙ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵜⵜ ⵛⵛⵓⵔⴻⵏ ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ ⵙ ⵜⴻⵅⵎⵓⵊⵉ ⵏⵙⴻⵏ’, ");
INSERT INTO rift_vpl VALUES ("ER9_12","016_9_12","EZR","9","12","12","ⴷ ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵓⵍⴰ ⵄⴰⴷ ⵍⴻⵅⵅⵓ: ‘ⵡⴰⵔ ⵜⵜⵉⵛⴻⵎ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵉⵡⵢⴻⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵎ ⵅ ⵍⴰⵎⴰⵏ ⵏⵙⴻⵏ ⵏⵉⵖ ⵍⵅⴰⵔ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⵜⵊⴻⵀⴷⴻⵎ ⵓ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵎⵓⵎⵎⵓ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴰⴷ ⵜⵜ ⵜⴻⵡⵛⴻⵎ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("ER9_13","016_9_13","EZR","9","13","13","“ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵎⵙⴰⵔⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵖ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⴷ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵖ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵅⴻⴵⵚⴻⴷ ⵛⴰ ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵡⴰⵀⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵛⴰ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵓ ⵜⴻⵡⵛⵉⴷ ⴰⵏⴻⵖ ⵄⴰⴷ ⵉⵏⴰ ⵉⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ ⴰⵎ ⵜⵜ ⵜⴻⴵⴰ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("ER9_14","016_9_14","EZR","9","14","14","ⵎⴰ ⵏⵣⴻⵎⵎⴰⵔ ⵍⴻⵅⵅⵓ ⴰⴷ ⵏⴰⵔⵥ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵏⴻⴳⴳ ⴰⴷ ⵏⴻⴷⵡⴻⵍ ⴷ ⵉⴹⴻⴳⴳⵯⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ? ⵎⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵜⵙⴻⵄⵄⴰⵔⴻⴷ ⴰⵍⴰⵎⵉ ⵅⴰⵏⴻⵖ ⵉ ⵖⴰ ⵜⴻⵇⴹⵉⴷ ⴰⵍ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵊⵊ ⵏ ⵍⴱⴰⵇⵉ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("ER9_15","016_9_15","EZR","9","15","15","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏⵏⴻⵊⵎⴻⵏ ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵙ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵏⴻⴵⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("ER10_1","016_10_1","EZR","10","1","1","ⵓⵎⵉ ⵉⵥⵥⵓⴵ ⵄⵉⵣⵔⴰ ⴰⵎⵎⵓ, ⵉⵏⵄⴻⵎ, ⵉⵔⵓ ⵓⵛⴰ ⵉⵡⴹⴰ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⵅⴰⵙ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵔⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER10_2","016_10_2","EZR","10","2","2","ⵅⴻⵏⵏⵉ ⵛⴰⴽⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵃⵉⵢⵉⵍ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⵉⵍⴰⵎ, ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵄⵉⵣⵔⴰ: “ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⴻⵖⴷⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵉⵡⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵙⵙⴻⵣⴷⴻⵖ ⵉ-ⵜⴻⵏⵜ ⴰⴽⵉⴷⵏⴻⵖ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⵍⴰⵢⴰⵙ ⵉ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_3","016_10_3","EZR","10","3","3","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵥⵥⴻⵍ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵛⴰⵡⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵉ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_4","016_10_4","EZR","10","4","4","ⴽⴽⴰⵔ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⴰⵇⴰ-ⵜⵜ ⵅ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴽⵉⴷⴻⴽ ⵏⴱⴻⴷⴷ. ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ, ⴻⴳⴳ ⵉ-ⵜⵜ!” ");
INSERT INTO rift_vpl VALUES ("ER10_5","016_10_5","EZR","10","5","5","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵄⵉⵣⵔⴰ ⵓⵛⴰ ⵉⵊⵊⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵊⵊⴰⴵⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ-ⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵊⵊⵓⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER10_6","016_10_6","EZR","10","6","6","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵄⵉⵣⵔⴰ ⵉⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵢⴰⵙⵉⴱ. ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⴷⵉⵏⵏⵉ, ⵡⴰⵔ ⵉⵛⵛⵉ ⴰⵖⵔⵓⵎ ⵡⴰⵔ ⵉⵙⵡⵉ ⴰⵎⴰⵏ, ⵎⴰⵖⴰⵔ ⵉⵛⴹⴻⵏ ⵅ ⵍⴻⵖⴷⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_7","016_10_7","EZR","10","7","7","ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵓⵏⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ER10_8","016_10_8","EZR","10","8","8","ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⵉ ⵍⵎⵉⵊⴰⵔ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴷⴻⴳ ⵓⵛⴰⵡⴰⵔ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⴻⵎ ⵓ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵎⵙⴻⴱⴹⴰ ⵅ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ");
INSERT INTO rift_vpl VALUES ("ER10_9","016_10_9","EZR","10","9","9","ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵊⴰⵔⵡⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ. ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵓⵍⴰ ⵣⴻⴳ ⵡⴻⵏⵥⴰⵔ ⵉ ⴷⴷ-ⵉⵡⴻⵜⵜⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ER10_10","016_10_10","EZR","10","10","10","ⵉⴽⴽⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵉⵣⵔⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵖⴷⴰⵔⴻⵎ ⵓ ⵜⵉⵡⵢⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵜⴻⵙⵙⵣⴻⴷⵖⴻⵎ ⵜⴻⵏⵜ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⵉⵎ ⵜⴰⵔⵏⵉⵎ ⴷⴻⴳ ⵓⵎⴰⵔⵡⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ER10_11","016_10_11","EZR","10","11","11","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓ ⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵎⵎⵙⴻⴱⴹⴰⵎ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("ER10_12","016_10_12","EZR","10","12","12","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵙ ⵊⵊⵀⴻⴷ: “ⴰⵇⴰ-ⵜ ⵅ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("ER10_13","016_10_13","EZR","10","13","13","ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⴰⵇⴰ ⴷ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵏⵥⴰⵔ. ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴱⴰⵔⵔⴰ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⵊⵊ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵏⴻⵖ ⵄⴻⴷⴷⴰⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_14","016_10_14","EZR","10","14","14","ⴻⵊⵊ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵢⵉⵡⵢⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ, ⵙⵙⵣⴻⴷⵖⴻⵏ ⵜⴻⵏⵜ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵊⵎⵉⵄ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵡⴻⵙⵙⵓⵔⴰ ⵏ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵙ, ⴰⵍ ⵅⴰⵏⴻⵖ ⵖⴰ ⵉⴱⴻⵄⵄⴻⴷ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("ER10_15","016_10_15","EZR","10","15","15","ⵎⵖⵉⵔ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵄⴰⵙⴰ’ⵉⵍ, ⴷ ⵢⴰⵃⴰⵣⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵜⵉⵇⵡⴰ, ⵜⵓⵖⴰ ⵜⵜⵄⴻⴽⴽⵙⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵎⴰⵛⵓⵍⵍⴰⵎ ⴷ ⵛⴰⴱⴰⵜⴰⵢ, ⴰⵍⴰⵡⵉ, ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("ER10_16","016_10_16","EZR","10","16","16","ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵍⵎⴻⵏⴼⴰ ⴳⴳⵉⵏ ⵜ ⴰⵎⵎⵓ. ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵉⵣⵔⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_17","016_10_17","EZR","10","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵔⴻⵣⵣⵓⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⴷ ⵙⵙⵣⴻⴷⵖⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ER10_18","016_10_18","EZR","10","18","18","ⵉⵜⵜⵡⴰⴼ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵣⴻⴷⵖⴻⵏ ⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵚⴰⴷⴰⵇ, ⵓ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ, ⵎⴰⵄⴰⵙⵉⵢⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵢⴰⵔⵉⴱ ⴷ ⵊⴰⴷⴰⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_19","016_10_19","EZR","10","19","19","ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵅ ⵓⴼⵓⵙ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ, ⵓ ⵓⵎⵉ ⴷⴰⵢⵙⴻⵏ ⴰⵎⴰⵔⵡⴰⵙ, ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵉ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ER10_20","016_10_20","EZR","10","20","20","ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵎⵎⵉⵔ: ⵃⴰⵏⴰⵏⵉ ⴷ ⵣⴰⴱⴰⴷⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_21","016_10_21","EZR","10","21","21","ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵃⴰⵔⵉⵎ: ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵉⵍⵉⵢⴰ, ⵛⴰⵎⵄⵉⵢⴰ, ⵢⴰⵃⵉⵢⵉⵍ ⴷ ⵄⵓⵣⵣⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_22","016_10_22","EZR","10","22","22","ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴼⴰⵛⵃⵓⵔ: ⵉⵍⵢⵓⵄⵉⵏⴰⵢ, ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵉⵙⵎⴰⵄⵉⵍ, ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵢⵓⵣⴰⴱⴰⴷ ⴷ ⴰⵍⵄⴰⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_23","016_10_23","EZR","10","23","23","ⵣⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⵊⵓⵣⴰⴱⴰⴷ, ⵛⵉⵎⵄⵉ, ⵇⴰⵍⴰⵢⴰ, ⵡⴰ ⴷ ⵇⴰⵍⵉⵟⴰ, ⴷ ⴼⴰⵜⵃⵢⴰ, ⵢⴰⵀⵓⴷⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ER10_24","016_10_24","EZR","10","24","24","ⵣⴻⴳ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ: ⴰⵍⵢⴰⵙⵉⴱ. ⵣⴻⴳ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ: ⵛⴰⵍⵍⵓⵎ, ⵟⴰⵍⴰⵎ ⴷ ⵓⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("ER10_25","016_10_25","EZR","10","25","25","ⵣⵉ ⵉⵙⵔⴰⵉⵍ: ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴼⴰⵔⵄⵓⵛ: ⵔⴰⵎⵢⴰ, ⵊⵉⵣⵉⵢⴰ, ⵎⴰⵍⴽⵉⵢⴰ, ⵎⵉⵢⴰⵎⵉⵏ, ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⴰⵍⴽⵉⵢⴰ ⴷ ⴱⴰⵏⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_26","016_10_26","EZR","10","26","26","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⵉⵍⴰⵎ: ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵢⴰⵃⵉⵢⵉⵍ, ⵄⴰⴱⴷⵉ, ⵢⴰⵔⵉⵎⵓⵜ ⴷ ⵉⵍⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_27","016_10_27","EZR","10","27","27","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵣⴰⵜⵜⵓ: ⵉⵍⵢⵓⵄⵉⵏⴰⵢ, ⵉⵍⵢⴰⵛⵉⴱ, ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵢⴰⵔⵉⵎⵓⵜ, ⵣⴰⴱⴰⴷ ⴷ ⵄⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_28","016_10_28","EZR","10","28","28","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⴰⴱⴰⵢ: ⵢⵓⵃⴰⵏⴰⵏ, ⵃⴰⵏⴰⵏⵢⴰ, ⵣⴰⴱⴱⴰⵢ ⴷ ⵄⴰⵜⵍⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("ER10_29","016_10_29","EZR","10","29","29","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⴰⵏⵉ: ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⴰⵍⵍⵓⵅ, ⵄⴰⴷⴰⵢⴰ, ⵢⴰⵛⵓⴱ, ⵛⴰ’ⴰⵍ ⴷ ⵢⴰⵔⴰⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("ER10_30","016_10_30","EZR","10","30","30","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴼⴰⵃⴰⵜ-ⵎⵓ’ⴰⴱ: ⵄⴰⴷⵏⴰ, ⴽⴰⵍⴰⵍ, ⴱⴰⵏⴰⵢⴰ, ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⴰⵜⵜⴰⵏⵢⴰ, ⴱⴰⵚⴰⵍⵉⵢⵉⵍ, ⴱⵉⵏⵏⵓⵢ ⴷ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_31","016_10_31","EZR","10","31","31","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵃⴰⵔⵉⵎ: ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵢⴰⵛⵛⵉ-ⵢⴰⵀ, ⵎⴰⵍⴽⵉⵢⴰ, ⵛⴰⵎⵄⵉⵢⴰ, ⵛⵉⵎⵄⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("ER10_32","016_10_32","EZR","10","32","32","ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⴰⵍⵍⵓⵅ ⴷ ⵛⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_33","016_10_33","EZR","10","33","33","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵃⴰⵛⵓⵎ: ⵎⴰⵜⵜⴰⵏⴰⵢ, ⵎⴰⵜⵜⴰⵜⵜⴰ, ⵣⴰⴱⴰⴷ, ⵉⵍⵉⴼⴰⵍⴰⵟ, ⵢⴰⵔⵉⵎⴰⵢ, ⵎⴰⵏⴰⵙⵙⴰ, ⵛⵉⵎⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("ER10_34","016_10_34","EZR","10","34","34","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⴰⵏⵉ: ⵎⴰⵄⴰⴷⴰⵢ, ⵄⴰⵎⵔⴰⵎ ⴷ ⵓⵡⵢⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("ER10_35","016_10_35","EZR","10","35","35","ⴱⴰⵏⴰⵢⴰ, ⴱⴰⴷⵢⴰ, ⴽⴰⵍⵓⵀⵉ, ");
INSERT INTO rift_vpl VALUES ("ER10_36","016_10_36","EZR","10","36","36","ⵡⴰⵏⵢⴰ, ⵎⴰⵔⵉⵎⵓⵜ, ⵉⵍⵢⴰⵛⵉⴱ, ");
INSERT INTO rift_vpl VALUES ("ER10_37","016_10_37","EZR","10","37","37","ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵎⴰⵜⵜⵏⴰⵢ, ⵢⴰⵄⵙⵓ, ");
INSERT INTO rift_vpl VALUES ("ER10_38","016_10_38","EZR","10","38","38","ⴱⴰⵏⵉ, ⴱⵉⵏⵏⵓⵢ, ⵛⵉⵎⵄⵉ, ");
INSERT INTO rift_vpl VALUES ("ER10_39","016_10_39","EZR","10","39","39","ⵛⴰⵍⵎⴰⵢⴰ, ⵏⴰⵜⴰⵏ, ⵄⴰⴷⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("ER10_40","016_10_40","EZR","10","40","40","ⵎⴰⴽⵏⴰⴷⴱⴰⵢ, ⵛⴰⵛⴰⵢ, ⵛⴰⵔⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("ER10_41","016_10_41","EZR","10","41","41","ⵄⴰⵣⴰⵔⵢⵉⵍ, ⵛⴰⵍⴰⵎⵢⴰ, ⵛⴰⵎⴰⵔⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("ER10_42","016_10_42","EZR","10","42","42","ⵛⴰⵍⵍⵓⵎ, ⴰⵎⴰⵔⵢⴰ, ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("ER10_43","016_10_43","EZR","10","43","43","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵏⴰⴱⵓ: ⵢⴰⵄⵉⵢⵉⵍ, ⵎⴰⵜⵜⵉⵜⵢⴰ, ⵣⴰⴱⴰⴷ, ⵣⴰⴱⵉⵏⴰ, ⵢⴰⴷⴷⵓ, ⵢⵓⵡⵉⵍ ⴷ ⴱⴰⵏⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("ER10_44","016_10_44","EZR","10","44","44","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵜⵓⵖⴰ ⵉⵡⵢⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ ⵓⵛⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵓⵔⵡⴻⵏⵜ-ⵉ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. * ");
INSERT INTO rift_vpl VALUES ("NH1_1","017_1_1","NEH","1","1","1","ⴰⵡⴰⵍⴻⵏ ⵏ ⵏⴰⵃⴰⵎⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴽⴰⵍⵢⴰ. ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⴽⵉⵙⵍⵓⵡ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⴷⵉ ⵛⵓⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NH1_2","017_1_2","NEH","1","2","2","ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵃⴰⵏⴰⵏⵉ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵙⵙⴻⵇⵙⵉⵖ ⵜⴻⵏ ⵅ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵓ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH1_3","017_1_3","NEH","1","3","3","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵢⵉ: “ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⴷⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵓ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵜⵜⵡⴰⵔⵥ ⵓ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("NH1_4","017_1_4","NEH","1","4","4","ⵓⵎⵉ ⵙⵍⵉⵖ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵇⵇⵉⵎⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵔⵓⵖ ⵓ ⵛⴻⴹⵏⴻⵖ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵥⵓⵎⵎⴻⵖ ⵓ ⵥⵓⴵⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH1_5","017_1_5","NEH","1","5","5","ⵏⵏⵉⵖ: “ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("NH1_6","017_1_6","NEH","1","6","6","ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵓⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵉⴼⵜⴻⵏ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⵔⵣⵎⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵏⵏⵉ ⵥⵓⴵⴻⵖ ⴰⵙⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ. ⵏⴻⵄⵎⴻⵖ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⵏⵓⴱ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵣⵉ ⵅⴰⴽ ⵅⴹⴰⵏ. ⵏⴻⵛⵛ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ⴰⵇⴰ ⵏⴻⵅⴹⴰ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("NH1_7","017_1_7","NEH","1","7","7","ⵏⴻⴳⴳⴰ ⴰⴽⵉⴷⴻⴽ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵖⴷⴰⵔ ⵓ ⵡⴰⵔ ⵏⴻⵟⵟⵉⴼ ⵛⴰ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⴷ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉ ⵣⵉ ⵜⵓⵎⵓⵔⴻⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NH1_8","017_1_8","NEH","1","8","8","ⵉⴷⴰⵔ ⴰⵡⴰⵍ ⵉ ⵜⵓⵎⵓⵔⴻⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵎⵓⵙⴰ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵣⴻⴵⵄⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("NH1_9","017_1_9","NEH","1","9","9","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰⴷ ⵟⵟⴼⴻⵎ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ, ⵡⴰⵅⵅⴰ ⴷⵉⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵏⵏⵉ ⵅ ⵢⵓⵥⵥⵍⴻⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵙⵙⴻⵏⵏⵉ, ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵉⵅⴹⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵙⵙⴻⵣⴷⵖⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("NH1_10","017_1_10","NEH","1","10","10","ⵏⵉⵜⵏⵉ ⵡⴰⵀ, ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⴼⴻⴽⴽⴻⴷ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH1_11","017_1_11","NEH","1","11","11","ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⴷ ⵉⴼⵜⴻⵏ ⵓⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⴻⵊⵊ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵡⴻⴹ ⴰⵙⵙ-ⴰ ⵓ ⴻⵡⵛ ⴰⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵔⵢⴰⵣ-ⴰ.” ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵡⴰⵔⵔⴰⴷ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("NH2_1","017_2_1","NEH","2","1","1","ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⵏⵉⵙⴰⵏ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴱⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴽⵙⵉⵖ ⴱⵉⵏⵓ ⵓⵛⴰ ⵡⵛⵉⵖ ⵜ ⵉ ⵓⵊⴻⴵⵉⴷ. ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH2_2","017_2_2","NEH","2","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵏⵣⴻⵎⵎ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵓ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵃⵍⵉⵛⴻⴷ ⵛⴰ? ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⵎⵖⵉⵔ ⴷ ⵉⵊⵊ ⵏ ⵍⵃⴰⵍ ⵏ ⵡⵓⵍ ⵉⴱⴰⵔⵔⵛⵏⴻⵏ.” ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵖ ⵏⵏⵅⴻⵍⵄⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NH2_3","017_2_3","NEH","2","3","3","ⵏⵏⵉⵖ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵜⵓⴷⴰⵔⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵉ ⵍⴻⴱⴷⴰ. ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵉⵏⵣⴻⵎⵎ, ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ, ⴰⵎⵛⴰⵏ ⵏ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵜⴻⵛⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵜⵎⴻⵙⵙⵉ?” ");
INSERT INTO rift_vpl VALUES ("NH2_4","017_2_4","NEH","2","4","4","ⵉⵏⵏⴰ ⴰⵢⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵏ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵛⴻⴽ?” ⵅⴻⵏⵏⵉ ⵥⵓⴵⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ");
INSERT INTO rift_vpl VALUES ("NH2_5","017_2_5","NEH","2","5","5","ⵓⵛⴰ ⵏⵏⵉⵖ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵓ ⵢⵓⴼⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴱⵏⵉⵖ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("NH2_6","017_2_6","NEH","2","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵓⵊⴻⴵⵉⴷ, ⵓⵎⵉ ⵜⴻⵇⵇⵉⵎ ⵜⵊⴻⴵⵉⴷⵜ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ: “ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵜⴻⴽⴽ ⵜⵡⴰⵃⵉⵜ ⵏⵏⴻⵛ ⵓ ⵎⴻⵍⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⵄⴻⵇⴱⴻⴷ?” ⵓⵎⵉ ⴷ ⴰⵙ ⵏⵏⵉⵖ ⵍⵇⴻⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ, ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵎⴰⵏ ⴰⵢⴰ ⵎⵍⵉⵃ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH2_7","017_2_7","NEH","2","7","7","ⴰⵔⵏⵉⵖ ⵏⵏⵉⵖ ⴰⵙ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵅ ⵍⵅⴰⴹⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵎⵎⴻⵡⵛⴻⵏⵜ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵉ ⵍⵡⵓⵍⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵢⴰⵔⵣⵎⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴹⴻⵖ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("NH2_8","017_2_8","NEH","2","8","8","ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⴰⵙⴰⴼ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵡⴻⴼⵜⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵊⵊⴻⵏⵏⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵢⴻⵡⵛ ⴰⴽⴻⵛⵛⵓⴹ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⴳⴳ ⵜⵉⵃⴻⵏⵢⴰ ⵉ ⵜⵣⴻⵇⵇⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⴻⵇⵚⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵓ ⵉ ⵍⵃⵉⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵣⴻⴷⵖⴻⵖ.” ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵢⵉ ⵜⴻⵏⵜ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏⵣⵉ ⴰⴼⵓⵙ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵜ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("NH2_9","017_2_9","NEH","2","9","9","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⵍⵡⵓⵍⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓ ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴻⴽⴽ ⴰⴽⵉⴷⵉ ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏ ⵉⵢⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH2_10","017_2_10","NEH","2","10","10","ⵓⵎⵉ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⵣⵉ ⵃⵓⵔⵓⵏ, ⴷ ⵜⵓⴱⵉⵢⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⴰⵎⵎⵓⵏⵉ, ⵙⵍⵉⵏ ⴰⵢⴰ, ⵜⵓⵖⴰ ⴰⵢⴰ ⵖⴰⵔⵙⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⴱⵏⴰⴷⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵍⵅⴰⵔ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH2_11","017_2_11","NEH","2","11","11","ⴰⵎⵎⵓ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵇⵇⵉⵎⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH2_12","017_2_12","NEH","2","12","12","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵖ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵏⴻⵛⵛ ⴷ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴽⵉⴷⵉ, ⵓⵛⴰ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵡⴰⵔ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⵓⵍ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵡⴰⵔ ⴽⵉⴷⵉ ⴽⵙⵉⵖ ⵍⵎⴰⵍ ⵎⵖⵉⵔ ⵍⵎⴰⵍ ⵎⵉⵏ ⵅⴻⴼ ⵉ ⵏⵢⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("NH2_13","017_2_13","NEH","2","13","13","ⴼⴼⵖⴻⵖ ⵙ ⴵⵉⵍⴻⵜ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⴰⵍ ⵓⴷⴻⵎ ⵏ ⵜⴰⵍⴰ ⵏ ⵍⵀⴰⵢⵛⴻⵜ ⵓ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵖⴱⴰⵔ. ⵏⴻⵛⵛ ⵅⴻⵎⵎⴻⵖ ⵍⴻⵃⵢⵓⴹ ⵉⵜⵜⵡⴰⵔⵥⵉⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵣⵉ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵜⴻⵛⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("NH2_14","017_2_14","NEH","2","14","14","ⵏⴻⵛⵛ ⵏⴻⴷⵀⴻⵖ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⵍⴰ ⵓ ⵖⴰⵔ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⵜⵜⴰⵙⵉⵄ ⵉ ⵍⵎⴰⵍ ⵙⴰⴷⵓ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵏⵉⵖ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NH2_15","017_2_15","NEH","2","15","15","ⵅⴻⵏⵏⵉ ⴳⴻⵄⵄⴷⴻⵖ ⵙ ⴵⵉⵍⴻⵜ ⵅ ⵜⵙⴻⴵⵢⴰ ⵓⵛⴰ ⵅⴻⵎⵎⴻⵖ ⵍⵃⵉⴹ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵖ-ⴷⴷ, ⵓⵛⴰ ⵓⴷⴼⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ⴰⵎⵎⵓ ⵉ-ⴷⴷ-ⵄⴻⵇⴱⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NH2_16","017_2_16","NEH","2","16","16","ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵔⵓⵃⴻⵖ ⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⴳⴳⴻⵖ. ⵎⴰⵖⴰⵔ ⴰⵍ ⴷⵉⵏ ⵡⴰⵔ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵓⵍⴰ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH2_17","017_2_17","NEH","2","17","17","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵍⴻⵖⴱⴻⵏ ⵉ ⴷⵉ ⵏⴻⴵⴰ, ⴰⵇⴰ ⵓⵔⵛⴰⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴻⴵ ⵓ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵜⴻⵛⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵜⵎⴻⵙⵙⵉ. ⴰⵙⴻⵎ-ⴷⴷ, ⴰⴷ ⵏⴻⴱⵏⴰ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⵄⴰⴷ ⴽⵜⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NH2_18","017_2_18","NEH","2","18","18","ⵏⴻⵛⵛ ⵃⴰⵊⵉⵖ ⴰⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵜⵓⵖⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵅⴰⴼⵉ ⵓⵍⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ. ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴽⴽⴰⵔ ⴰⴷ ⵏⴻⴱⵏⴰ.” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵊⴻⵀⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ");
INSERT INTO rift_vpl VALUES ("NH2_19","017_2_19","NEH","2","19","19","ⵓⵎⵉ ⵙⵍⵉⵏ ⵜ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ, ⵣⵉ ⵃⵓⵔⵓⵏ, ⴷ ⵟⵓⴱⵉⵢⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴷ ⵡⴻⵄⵔⴰⴱ ⵊⴰⵛⴰⵎ, ⵙⵙⵜⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵓ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴰⵏⴻⵖ. ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵎⴰⵏⴰⵡⵢⴰ ⵎⵉⵏ ⵉ ⴷⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵖⴻⵡⵡⵖⴻⵎ ⵅ ⵓⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("NH2_20","017_2_20","NEH","2","20","20","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⴰⵏⴻⵖ ⵉⵡⵛ ⴰⴼⵓⵙ, ⵓ ⵏⴻⵛⵛⵉⵏ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵏⴻⴽⴽⴰⵔ ⴰⴷ ⵏⴻⴱⵏⴰ. ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⵓⵍⴰ ⴷ ⵍⵃⴻⵇⵇ ⵏⵉⵖ ⵍⵉⴷⴰⵔⴻⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("NH3_1","017_3_1","NEH","3","1","1","ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵍⵢⴰⵛⵉⴱ, ⵉⴽⴽⴰⵔ, ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⵍⴻⵏ ⴱⵏⴰⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⵓⴵⵉ, ⵇⴻⴷⴷⵙⴻⵏ ⵜⵜ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⵜⵉⵛⵜⵉ ⴰⵍ ⵍⴱⵓⵔⵊ ⵏ ⵎⵢⴰ ⵓ ⴰⵍ ⵍⴱⵓⵔⵊ ⵏ ⵃⴰⵏⴰⵏⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH3_2","017_3_2","NEH","3","2","2","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⴱⵏⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⴰⵔⵉⵃⴰ ⵓⵛⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵉⴱⵏⴰ ⵣⴰⴽⴽⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵉⵎⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("NH3_3","017_3_3","NEH","3","3","3","ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⴻⵙⵍⴻⵎ ⴱⵏⴰⵏ ⵜⵜ ⴰⵢⵜ ⵏ ⵙⴰⵏⴰ’ⴰ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⴽⴽⴱⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵜⵣⴻⵇⵇⴰ ⵓ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵓⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("NH3_4","017_3_4","NEH","3","4","4","ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵉⴱⵏⴰ ⵎⴰⵔⵉⵎⵓⵜ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉ-ⵢⴰⵀ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵇⵇⵓⵚ, ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵉⵣⴰⴱⵢⵉⵍ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵉⵄⴻⴷⴷⴻⵍ ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NH3_5","017_3_5","NEH","3","5","5","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵄⴻⴷⴷⵍⴻⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴰⵇⵇⵓⵄⴰ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⵡⴰⵔ ⵙⵙⴻⵇⵡⵉⵙⴻⵏ ⵛⴰ ⵉⵔⵉ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵙⵉⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH3_6","017_3_6","NEH","3","6","6","ⵉⵄⴻⴷⴷⴻⵍ ⵢⵓⵢⴰⴷⴰⵄ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵙⵉⵃ, ⴰⴽ-ⴷ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵙⵓⴷⵢⴰ, ⵜⴰⵡⵡⴰⵔⵜ ⵜⴰⵇⴷⵉⵎⵜ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⴽⴽⴱⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵜⵣⴻⵇⵇⴰ ⵓ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵓⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("NH3_7","017_3_7","NEH","3","7","7","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵍⴰⵟⵢⴰ ⵣⵉ ⵊⵉⴱⵄⵓⵏ, ⴷ ⵢⴰⴷⵓⵏ, ⴰⵎⵉⵢⴰⵔⵓⵏⵓⵜⵉ, ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵊⵉⴱⵄⵓⵏ ⵓ ⵣⵉ ⵎⵉⵚⴼⴰ ⴰⵍ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⵡⴰⵍⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵖⵉⵔⵉⵏ ⵉ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("NH3_8","017_3_8","NEH","3","8","8","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵄⵓⵣⵣⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵔⵀⴰⵢⴰ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⴷⴷⴰⴷⴻⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵉⵄⴻⴷⴷⴻⵍ ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵍⴻⵄⵟⵓⵍ. ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍ ⵍⵃⵉⴹ ⴷ ⵎⵉⵔⵉⵡ ⴰⵎ ⵜ ⵜⵓⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("NH3_9","017_3_9","NEH","3","9","9","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵔⴰⴼⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵓⵔ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH3_10","017_3_10","NEH","3","10","10","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵢⴰⴷⴰⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵔⵓⵎⴰⴼ, ⴰⵊⴻⵎⵎⴰⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵃⴰⵜⵜⵓⵛ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⴰⴱⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("NH3_11","017_3_11","NEH","3","11","11","ⵎⴰⵍⴽⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵔⵉⵎ ⴷ ⵃⴰⵛⵛⵓⴱ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵃⴰⵜ-ⵎⵓ’ⴰⴱ ⵄⴻⴷⵍⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵍⴰ ⴷ ⵍⴱⵓⵔⵊ ⵏ ⵜⴻⴼⵇⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NH3_12","017_3_12","NEH","3","12","12","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵍⵓⵃⵉⵛ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("NH3_13","017_3_13","NEH","3","13","13","ⵃⴰⵏⵓⵏ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵣⴰⵏⵓⵃ ⵄⴻⴷⵍⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⴽⴽⴱⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵓ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵓⴱⴻⵍⵍⴻⵄ ⵓⵛⴰ ⵄⴻⴷⵍⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵃⵉⴹ ⴰⵍ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NH3_14","017_3_14","NEH","3","14","14","ⵎⴰⵍⴽⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵔⴰⴽⴰⴱ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⴱⴰⵢⵜ-ⴽⴰⵔⵉⵎ, ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵖⴱⴰⵔ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⴽⴽⴻⴱ ⵜⵉⵃⴻⵏⵢⴰ ⵓ ⵉⵙⵙⴱⴻⴷⴷ ⴷⴰⵢⴻⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵓⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("NH3_15","017_3_15","NEH","3","15","15","ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⴽⵓⵍⵀⵓⵣ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵎⵉⵚⴼⴰ, ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⴰⵍⴰ. ⵉⴱⵏⴰ ⵉ-ⵜⵜ ⵓ ⵏⵉⵜⵏⵉ ⴰⵔⴻⴽⴽⴱⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵜⵣⴻⵇⵇⴰ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵉ ⵓⴱⴻⵍⵍⴻⵄ. ⵏⴻⵜⵜⴰ ⵉⵄⴷⴻⵍ ⵄⴰⵡⴻⴷ ⵍⵃⵉⴹ ⵣⴻⴳ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵛⵉⵍⴰⵃ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵍ ⴷⴷⵔⵓⵊ ⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("NH3_16","017_3_16","NEH","3","16","16","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵏⴰⵃⴰⵎⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴱⵓⵇ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⴱⴰⵢⵜ-ⵚⵓⵔ, ⴰⵍ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⴰⵍ ⵊⵊⵓⴱⴱ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓ ⴰⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵢⵜ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("NH3_17","017_3_17","NEH","3","17","17","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵄⴻⴷⴷⵍⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⵔⴰⵃⵓⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⵉ, ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵃⴰⵛⴰⴱⵢⴰ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵇⴰⵄⵉⵍⴰ, ⴷⴻⴳ ⵓⴷⴻⵡⵡⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH3_18","017_3_18","NEH","3","18","18","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵄⴻⴷⴷⵍⴻⵏ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴱⴰⵡⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵏⴰⴷⴰⴷ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵇⴰⵄⵉⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("NH3_19","017_3_19","NEH","3","19","19","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵄⴰⵣⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵢⴻⵛⵓⵄⴰ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵎⵉⵚⴼⴰ, ⵉⵄⴻⴷⴷⴻⵍ ⵉⵛⵜ ⵏ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⵙⴰⵡⴻⵏⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵙⵏⴰⵃ, ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⴷⴻⵡⵡⴰⵔ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("NH3_20","017_3_20","NEH","3","20","20","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴱⴰⵢ, ⵉⵄⴻⴷⴷⴻⵍ ⵙ ⵛⴹⴰⵔⴻⵜ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ, ⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵉⴷⴻⵡⵡⴰⵔ ⵍⵃⵉⴹ ⴰⵍ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵍⵢⴰⵛⵉⴱ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH3_21","017_3_21","NEH","3","21","21","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵎⴰⵔⵉⵎⵓⵜ, ⵎⵎⵉⵙ ⵏ ⵓⵔⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵇⵇⵓⵚ, ⵉⵄⴻⴷⴷⴻⵍ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ, ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵍⵢⴰⵛⵉⴱ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵍⵢⴰⵛⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("NH3_22","017_3_22","NEH","3","22","22","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵄⴻⴷⴷⵍⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NH3_23","017_3_23","NEH","3","23","23","ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵃⴰⵛⵛⵓⴱ, ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵏⴰⵏⵉⵢⴰ, ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH3_24","017_3_24","NEH","3","24","24","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⴱⵉⵏⵏⵓⵢ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵏⴰⴷⴰⴷ, ⵉⵄⴻⴷⴷⴻⵍ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⴰⵣⴰⵔⵢⴰ ⴰⵍ ⵎⴰⵏⵉ ⵖⴰ ⵉⴷⴻⵡⵡⴰⵔ ⵍⵃⵉⴹ ⴰⵍ ⵜⴰⵖⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH3_25","017_3_25","NEH","3","25","25","ⴼⴰⵍⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵣⴰⵢ, ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⵊⴻⵎⵎⴰⴹ ⵎⴰⵏⵉ ⵖⴰ ⵉⴷⴻⵡⵡⴰⵔ ⵍⵃⵉⴹ ⴷ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ ⵡⴻⵏⵏⵉ ⵉⵔⴻⴼⵄⴻⵏ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵙⴻⵏⵏⴻⵊ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴼⴰⴷⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵔⵄⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("NH3_26","017_3_26","NEH","3","26","26","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵄⵓⴼⵉⵍ, ⵜⵓⵖⴰ ⵄⴻⴷⴷⵍⴻⵏ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵎⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓ ⵖⴰⵔ ⵍⴱⵓⵔⵊ ⵉⵙⵙⴻⵡⵛⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NH3_27","017_3_27","NEH","3","27","27","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴰⵇⵇⵓⵄⴰ ⵄⴻⴷⴷⵍⴻⵏ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵍⴱⵓⵔⵊ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵙⵙⴻⵡⵛⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴰⵍ ⵍⵃⵉⴹ ⵏ ⵄⵓⴼⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH3_28","017_3_28","NEH","3","28","28","ⵜⵓⵖⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⴻⴷⴷⵍⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵉⵢⵙⴰⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH3_29","017_3_29","NEH","3","29","29","ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⵉⵎⵎⵉⵔ, ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴽⴰⵏⵢⴰ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("NH3_30","017_3_30","NEH","3","30","30","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⴰⵎⵢⴰ, ⴷ ⵃⴰⵏⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵚⴰⵍⴰⴼ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⵄⴻⴷⴷⵍⴻⵏ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴻⵅⵅⴰⵎⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH3_31","017_3_31","NEH","3","31","31","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵍⴽⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ, ⴰⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ, ⴰⵊⴻⵎⵎⴰⴹ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵃⵙⴰⴱ ⵓ ⴰⵍ ⴰⵅⵅⴰⵎ ⵏ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔ ⵜⴻⵖⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH3_32","017_3_32","NEH","3","32","32","ⵊⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔ ⵜⴻⵖⵎⴰⵔⵜ ⴷ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⵓⴵⵉ, ⵜⵓⵖⴰ ⵄⴻⴷⴷⵍⴻⵏ ⵉⵎⵣⵉⵍⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH3_33","017_3_33","NEH","3","33","33","ⵓⵎⵉ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⵉⵙⵍⴰ, ⴰⵇⴰ ⵏⴱⴻⵏⵏⴰ ⵍⵃⵉⴹ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵀⴰⵊ, ⵉⵙⵄⴰⵔ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ ⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH3_34","017_3_34","NEH","3","34","34","ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ-ⴰ ⵉⴹⴻⵄⴼⴻⵏ? ⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⵊⵊ? ⵎⴰ ⴰⴷ ⵇⴻⴷⵎⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ? ⵎⴰ ⴰⴷ ⵜ ⴽⴻⵎⵎⵍⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ? ⵎⴰ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵥⵔⴰ ⵣⵉ ⴰⵔⵡⵉⵏⴰⵜ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("NH3_35","017_3_35","NEH","3","35","35","ⵜⵓⵖⴰ ⵟⵓⴱⵉⵢⴰ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴰ: “ⵄⴰⴷ ⵎⴰⵍⴰ ⴱⵏⴰⵏ ⵜ ⵄⴰⵡⴻⴷ, ⵅⵎⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵛⵄⴻⴱ ⵡⴰⵀⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵀⴷⴻⵎ ⵍⵃⵉⴹ ⵏⵙⴻⵏ ⵏ ⵡⴻⵥⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("NH3_36","017_3_36","NEH","3","36","36","“ⵙⴻⵍ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵏⴻⴷⵡⴻⵍ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⵓⵛⴰ ⴰⵔⵔ ⴰⵙⴻⵃⵇⴰⵔ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵓⵃⴻⴱⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH3_37","017_3_37","NEH","3","37","37","ⵡⴰⵔ ⵙⴷⵓⵔⵉⵢ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵃⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵄⴰⵔⴻⵏ ⵛⴻⴽ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NH3_38","017_3_38","NEH","3","38","38","ⵏⴻⴱⵏⴰ ⵍⵃⵉⴹ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵍⵃⵉⴹ ⵉⵇⵇⴻⵏ ⴰⵍ ⴰⵣⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⵉⴳⴳⴰ ⵓⵍ ⵏⵙⴻⵏ ⴰⴷ ⵜ ⴳⴳⴻⵏ. * ");
INSERT INTO rift_vpl VALUES ("NH4_1","017_4_1","NEH","4","1","1","ⵓⵎⵉ ⵎⴰⵛⴰ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⴷ ⵟⵓⴱⵉⵢⴰ ⴷ ⵡⴻⵄⵔⴰⴱⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⵉⵛⴷⵓⴷⵉⵢⵢⴻⵏ ⵙⵍⴰⵏ, ⴰⵇⴰ ⴰⵄⴷⴰⵍ ⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵜⵜⵔⴰⵃ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵜⵉⵣⵣⴻⵢⵢⵉⵏ ⴱⴷⴰⵏⵜ ⴰⴷ ⵇⵇⵏⴻⵏⵜ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵅⴻⵢⵢⵇⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NH4_2","017_4_2","NEH","4","2","2","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴳⴳⵉⵏ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⴷⵉⵏⵏⵉ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵍⴻⵃⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NH4_3","017_4_3","NEH","4","3","3","ⵏⴻⵛⵛⵉⵏ ⵎⴰⵛⴰ ⵏⵥⵓⴵ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵙⴻⵏ ⵏⴻⵙⵙⴱⴻⴷⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵅⴰⵙⴻⵏ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH4_4","017_4_4","NEH","4","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵀⵓⴷⴰ: “ⵊⵊⵀⴻⴷ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵢⵓⵃⴻⵍ, ⵎⴰⵖⴰⵔ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⵅⴰⵔⴱⴻⵜ. ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⵅ ⵍⴻⴱⵏⵉ ⵏ ⵍⵃⵉⴹ.” ");
INSERT INTO rift_vpl VALUES ("NH4_5","017_4_5","NEH","4","5","5","ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵖ ⴰⵇⴰ ⵏⵏⴰⵏ: “ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵉⵛⵉⵏ ⵓ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵡⴰⵍⵓ ⴰⵍ ⴷⴷ ⵖⴰ ⵏⴰⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵏⴻⵏⴻⵖ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⴻⵙⵙⴱⴻⴷⴷ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH4_6","017_4_6","NEH","4","6","6","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵏⵏⴰⵏ ⴰⵏⴻⵖ ⵄⴻⵛⵔⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵜⵄⴻⵇⴱⴻⵎ!”, ");
INSERT INTO rift_vpl VALUES ("NH4_7","017_4_7","NEH","4","7","7","ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⴻⵛⵛ ⵍⴳⴻⵏⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵃⵉⴹ ⵖⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵉⵡⴰⵟⴰⵏ ⵓ ⵖⴰⵔ ⵜⵙⴻⵇⵇⴰⵔ ⵉⴼⵔⵓⵔⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏⵙⴻⵏ, ⴰⴽ-ⴷ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⴷ ⵉⵃⵔⵉⵛⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⵇⵡⴰⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH4_8","017_4_8","NEH","4","8","8","ⵅⵣⴰⵔⴻⵖ, ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵖ, ⵏⵏⵉⵖ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵓ ⵉ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵓ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ: “ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ! ⵙⵉⴷⵉ ⵉⵏⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ. ⴼⴻⴽⴽⴰⵔⴻⵎ ⴷⴰⵢⴻⵙ, ⵎⵎⴻⵏⵖⴻⵎ ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("NH4_9","017_4_9","NEH","4","9","9","ⵓⵎⵉ ⵙⵍⴰⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⴳⴻⴱ ⵅⴰⵙ ⵓ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴱⴹⴻⵍ ⴰⵏⵡⴰⵢ ⵏⵙⴻⵏ, ⵉⵎⵙⴰⵔ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵏⴻⵖ ⵏⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵍⵃⵉⴹ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH4_10","017_4_10","NEH","4","10","10","ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵣⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⵜⵓⵖⴰ ⵅⴻⴷⴷⵎⴻⵏ ⵓ ⴰⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵟⵟⴼⴻⵏ ⵉⵃⵔⵉⵛⴻⵏ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⵍⴻⵇⵡⴰⵙ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵓⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴱⴻⴷⴷⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⴽⵓⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("NH4_11","017_4_11","NEH","4","11","11","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴻⵏⵏⴰⵏ ⵍⵃⵉⴹ ⵓⵛⴰ ⵢⴰⵔⴻⴱⴱⵓⵏ ⴷⴷⵇⵓⵍⴰⵜ ⵓⵛⴰ ⵙⵙⴰⵔⴻⴱⴱⵓⵏ ⵜⴻⵏⵜ, ⵅⴻⴷⴷⵎⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵓ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵖⵏⵉ ⵟⵟⴼⴻⵏ ⵍⴰⵏⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NH4_12","017_4_12","NEH","4","12","12","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵏⵏⴰⵏ ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵙⵙⵉⴼ ⵉⵇⵇⴻⵏ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ ⴰⵎ ⵜⵓⵖⴰ ⵉⴱⴻⵏⵏⴰ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NH4_13","017_4_13","NEH","4","13","13","ⵏⵏⵉⵖ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵓ ⵉ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵓ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ: “ⵍⵅⴻⴷⵎⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵓ ⵜⴻⵢⵔⵓ. ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⴱⴻⵣⵣⴻⵄ ⵅ ⵍⵃⵉⴹ, ⵉⵊⵊⴻⵏ ⵉⴳⴳⵯⴻⵊ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH4_14","017_4_14","NEH","4","14","14","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵙⵍⴻⵎ ⴰⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵎⵓⵏⴻⵎ-ⴷⴷ ⴷⵉⵏⵏⵉ ⵅⴰⵏⴻⵖ. ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NH4_15","017_4_15","NEH","4","15","15","ⴰⵎⵎⵓ ⵉ ⵏⴻⵅⴷⴻⵎ ⵓⵛⴰ ⴰⵣⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵟⵟⴼⴻⵏ ⵉⵃⵔⵉⵛⴻⵏ ⵣⵉ ⵜⵓⴼⴼⵓⵜ ⴰⵍ ⴷⴷ ⵖⴰ ⴼⴼⵖⴻⵏ ⵉⵜⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH4_16","017_4_16","NEH","4","16","16","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵏⵏⵉⵖ ⵉ ⵍⴳⴻⵏⵙ: “ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵙⵙⴻⵏⵙ ⴷⴰⵅⴻⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰⵔⵏⴻⵖ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("NH4_17","017_4_17","NEH","4","17","17","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⵡⴰⵔ ⵉⴽⴽⵉⵙ ⴰⵔⵔⵓⴹ, ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵛⵛ ⵍⴰ ⴷ ⴰⵢⵜⵎⴰ ⵍⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵔⵓⵃ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⴰⴽ-ⴷ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH5_1","017_5_1","NEH","5","1","1","ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⵓⵢⵢⵉ ⵉⵎⵖⴰⵔ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ, ⵛⴻⵜⵛⴰⵏ ⵏⵉⵜⵏⵉ ⵅ ⴰⵢⵜⵎⴰⵜⵙⴻⵏⵜ, ⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH5_2","017_5_2","NEH","5","2","2","ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵏⵏⴰⵏ: “ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵟⵟⴰⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵙⴻⵖ ⵉⵎⴻⵏⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵛⵛ ⴰⴷ ⵏⴻⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NH5_3","017_5_3","NEH","5","3","3","ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵀⴻⵏ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵖ ⵏ ⵓⴹⵉⵍ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⴰⴹⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵡⵉ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴰⵥ.” ");
INSERT INTO rift_vpl VALUES ("NH5_4","017_5_4","NEH","5","4","4","ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⴹⴻⵍ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵍⵊⵉⵣⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵅ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵖ ⵓ ⵅ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵖ ⵏ ⵓⴹⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("NH5_5","017_5_5","NEH","5","5","5","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵢⵙⵓⵎ ⵏⵏⴻⵖ ⴷ ⴰⵢⵙⵓⵎ ⵏ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵓ ⵅⵣⴰⵔ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⴰⵔⵔ ⴷ ⵉⵙⴻⵎⵖⴰⵏ. ⴰⵇⴰ ⴷⵉⵏ ⵣⵉ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ ⵜⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵜⵙⴻⵖⵎⵉⵏ, ⵓⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵖ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⵛⴰ ⵓ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵖ ⵏ ⵓⴹⵉⵍ ⴰⵇⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("NH5_6","017_5_6","NEH","5","6","6","ⵓⵎⵉ ⵙⵍⵉⵖ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ ⴷ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ, ⴷⴻⵡⵍⴻⵖ ⵅⴻⵢⵢⵇⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NH5_7","017_5_7","NEH","5","7","7","ⵏⴻⵛⵛ ⵅⴰⵔⵔⵚⴻⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵓ ⵅⴻⵏⵏⵉ ⵛⴻⵜⵛⵉⵖ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵓ ⵅ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ, ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⴷⴰⵢⴻⵙ ⵍⵄⵉⴱ ⵓⵎⵉ ⵉⴳⴳⴰ ⴰⵎⴰⵔⵡⴰⵙ ⴷⴻⴳ ⵓⵎⴰⵙ.” ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴹⵉⴷⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH5_8","017_5_8","NEH","5","8","8","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵖⴰ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⵓⴷⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵣⵣⴻⵏⵣⴻⵏ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵖ. ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵣⵣⴻⵏⵣⴻⵎ ⵄⴰⵡⴻⴷ ⵜⴰⵡⵎⴰⵜⵡⴻⵎ ⵓ ⵜⵜⵡⴰⵎⵎⴻⵙⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵢⵏⴻⵖ ⵄⴰⵡⴻⴷ?” ⵓⵛⴰ ⵙⵙⴻⵖⴷⴻⵏ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH5_9","017_5_9","NEH","5","9","9","ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⵉⵖ: “ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵛⴰⵏ. ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⴻⵃⵇⴰⵔ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("NH5_10","017_5_10","NEH","5","10","10","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⴰⵢⵜⵎⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ ⵏⴰⵔⴹⴻⵔ ⴰⵙⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵉⵎⴻⵏⴷⵉ. ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵎⴻⵃ ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵎⴰⵔⵡⴰⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH5_11","017_5_11","NEH","5","11","11","ⴰⵔⵔⴻⵎ ⴰⵙⴻⵏ ⴰⵙⵙ-ⴰ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵙⴻⵏ ⵏ ⵓⴹⵉⵍ, ⵍⴻⵄⵔⴰⵚⵉⵜ ⵏⵙⴻⵏ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⴻⵎⵃⴻⵏ ⴰⵙⴻⵏ ⴷⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵡⵉⵙⵙ ⵎⵢⴰ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵜᵉⵜⵜᵉⵜⵜⴰⵔⴻⵎ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("NH5_12","017_5_12","NEH","5","12","12","ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⴰⴷ ⴰⵙⴻⵏ ⵜ ⵏⴰⵔⵔ ⵎⴰⵔⵔⴰ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜ ⵏᵉⵜⵜⴻⵜⵜⴰⵔ ⵄⴰⴷ. ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴳⴳ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⵉⴷ ⵛⴻⴽ.” ⵓⵛⴰ ⵍⴰⵖⵉⵖ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵊⵊⵉⵖ ⵜⴻⵏ ⴰⴷ ⵊⵊⴰⴵⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH5_13","017_5_13","NEH","5","13","13","ⵅⴻⵏⵏⵉ ⵣⵣⴻⵔⵣⴻⵖ ⵡⴻⵃⵙⵉⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵏⵓ, ⵏⵏⵉⵖ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵣⵣⴻⵔⵣ ⴰⵔⴻⴱⴱⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ-ⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵉⵍⵉ ⴰⴷ ⵜ ⵣⵣⴻⵔⵣⴻⵏ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵅⵡⴰ.” ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵉⵏⵏⴰ: “ⴰⵎⵉⵏ!” ⵏⵉⵜⵏⵉ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵉⴳⴳⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH5_14","017_5_14","NEH","5","14","14","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴷ ⵢⴰⵢⵜⵎⴰ ⵡⴰⵔ ⵏⴻⵛⵛⵉ ⵛⴰ ⵎⴰⵛⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵍⵡⴰⵍⵉ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⴷ ⵍⵡⴰⵍⵉ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⵉⵛⵔⵉⵏ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⵜⴻⵇⵇⴰⵔ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("NH5_15","017_5_15","NEH","5","15","15","ⵍⵡⵓⵍⴰⵜ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵏⴻⵛⵛ, ⵜⵓⵖⴰ ⴳⴳⵉⵏ ⴷⴷⵇⴻⵍ ⵅ ⵍⴳⴻⵏⵙ ⵓ ⵜⵓⵖⴰ ⴽⵙⵉⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵖⵔⵓⵎ ⴷ ⴱⵉⵏⵓ ⵓ ⵄⴰⵡⴻⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ⵓⵍⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵙⴻⴵⴹⴻⵏ ⵅ ⵍⴳⴻⵏⵙ. ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵡⴰⵔ ⴳⴳⵉⵖ ⴰⵢⴰ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("NH5_16","017_5_16","NEH","5","16","16","ⴰⵇⴰ ⵡⵛⵉⵖ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵖⴰⵔ ⵍⵃⵉⴹ ⵓ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵖⵉ ⵛⴰ ⴰⵃⵡⵉⵛ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵎⵓⵏⴻⵏ ⴷⵉⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH5_17","017_5_17","NEH","5","17","17","ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ ⵇⵇⵉⵎⴻⵏ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⵣⴻⴳ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH5_18","017_5_18","NEH","5","18","18","ⵎⵉⵏ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵢⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⵙⴻⵜⵜⴰ ⵏ ⵜⴻⵅⵙⵉⵡⵉⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⴹⴰⴹ, ⵓ ⴷⵉ ⴽⵓⵍ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⴱⵉⵏⵓ ⵙ ⵓⴼⴻⵢⵢⴻⴹ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵜⵜⴰⵔⴻⵖ ⵎⴰⵛⵛⴰ ⵏ ⵍⵡⴰⵍⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵜⴻⵙⵙⴻⴷⵇⴻⵍ ⴰⵟⵟⴰⵙ ⵅ ⵍⴳⴻⵏⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH5_19","017_5_19","NEH","5","19","19","ⵉⴷⴰⵔ ⴰⵢⵉ ⵙ ⵍⵅⴰⵔ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵖ ⵉ ⵍⴳⴻⵏⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH6_1","017_6_1","NEH","6","1","1","ⵓⵎⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⴷ ⵟⵓⴱⵉⵢⴰ ⴷ ⵡⴻⵄⵔⴰⴱ ⵊⴰⵛⴰⵎ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴱⵏⵉⵖ ⵍⵃⵉⴹ ⵄⴰⵡⴻⴷ ⵓ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⴰⵢⴻⵙ ⵜⴻⵇⵇⵉⵎ ⵜⴰⵣⵣⵉⵜ ⵄⴰⴷ, ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⵄⴰⴷ ⵡⴰⵔ ⴰⵔⴻⴽⴽⴱⴻⵖ ⵜⵉⵡⵡⵓⵔⴰ, ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NH6_2","017_6_2","NEH","6","2","2","ⴰⵇⴰ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⴷ ⵊⴰⵛⴰⵎ ⵙⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵍⴻⵅⴱⴰⵔ, ⵏⵏⴰⵏ: “ⴰⵙ-ⴷⴷ, ⴰⴷ ⵏⴻⵎⵎⵥⴰⵔ ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵓⵏⵓ.” ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵏⵡⴰⵏ ⴰⴷ ⴳⴳⴻⵏ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NH6_3","017_6_3","NEH","6","3","3","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔⵙⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴰⴷ ⵉⵏⵉⵏ: “ⵏⴻⵛⵛ ⵅⴻⴷⴷⵎⴻⵖ ⵍⴻⵅⵅⵓ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴱⴻⴷⴷ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ ⵎⴰⵍⴰ ⵊⵊⵉⵖ ⵜⵜ, ⵀⵡⵉⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("NH6_4","017_6_4","NEH","6","4","4","ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵜⴰⴱⵔⴰⵜ-ⴰ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓ ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵍⴻⴱⴷⴰ ⵙ ⵡⴻⴱⵔⵉⴷ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH6_5","017_6_5","NEH","6","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⵉ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ. ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵜⴰⵔⵣⵎⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NH6_6","017_6_6","NEH","6","6","6","ⵢⵓⵔⴰ ⴷⴰⵢⴻⵙ: “ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵊⴰⵛⵎⵓ ⵉⵇⵇⴰⵔ: ‘ⵛⴻⴽ ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵖⴻⵡⵡⵖⴻⵎ. ⵅ ⵓⵢⴰ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵍⵃⵉⴹ!’, ⵓ ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ ⵅ ⵍⴻⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("NH6_7","017_6_7","NEH","6","7","7","ⵛⴻⴽ ⵄⴰⵡⴻⴷ ⵜⴰⵍⴻⵇⵎⴻⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵢⴰⵀⵓⴷⴰ!’ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴷ ⴰⵡⴹⴻⵏ ⵎⴰⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ. ⵙ ⵓⵢⴰ ⴰⵙ-ⴷⴷ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵏⴻⵎⵛⴰⵡⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("NH6_8","017_6_8","NEH","6","8","8","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵙ ⵜⴰⴱⵔⴰⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵏⵉⵖ: “ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⵜⴻⵏⵏⵉⴷ, ⵡⴰⵔ ⴵⵉⵏⵜ ⵛⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵏⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("NH6_9","017_6_9","NEH","6","9","9","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵅⵙⴻⵏ ⴰⴷ ⴰⵏⴻⵖ ⵙⵙⵉⴳⴳⵯⴷⴻⵏ, ⵏⵏⴰⵏ: “ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⴳⴳⴻⵏ.” ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⵊⵀⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("NH6_10","017_6_10","NEH","6","10","10","ⵏⴻⵛⵛ ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵍⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵀⵉⵟⴰⴱ’ⵉⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⵍⵍⴻⵄ ⵅ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉⵏⵏⵉ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵎⵓⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵣⵣⴰⵡⴻⵛⵜ, ⴰⴷ ⵏⴱⴻⵍⵍⴻⵄ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵏⵉⵜⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵏⵖⴻⵏ, ⵡⴰⵀ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵏⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("NH6_11","017_6_11","NEH","6","11","11","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵎⴰ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵜⴰⵔⴻⵡⵍⴰ? ⵎⴰ ⵉⵊⵊⴻⵏ ⴰⵎ ⵏⴻⵛⵛ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ? ⵡⴰⵔ ⵜⵜ ⵜⵜⴰⴷⴼⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("NH6_12","017_6_12","NEH","6","12","12","ⵎⵉⵏⵣⵉ ⴰⵔⴳⴱⴻⵖ ⵓ ⵥⵔⵉⵖ, ⴰⵇⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⵓⵖⴰ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵏⵏⵓⴱⵓⵡⴰ-ⵢⴰ ⵅⴰⴼⵉ, ⵎⵉⵏⵣⵉ ⵟⵓⴱⵉⵢⴰ ⴷ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⵜⵓⵖⴰ ⵛⵔⴰⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("NH6_13","017_6_13","NEH","6","13","13","ⵜⵓⵖⴰ ⵛⵔⴰⵏ ⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⴰⵎⴻⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵅⴹⵉⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⵛⴰ ⵉ ⵣⵉ ⴷⴰⵢⵉ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⵉⵙⴻⵎ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵄⴻⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH6_14","017_6_14","NEH","6","14","14","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵉⴷⴰⵔ ⵉ ⵟⵓⴱⵉⵢⴰ ⴷ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ, ⵎⵉⵏ ⴳⴳⵉⵏ, ⵓⵍⴰ ⴷ ⵜⴰⵏⴰⴱⵉⵜ ⵏⵓⵄⴰⴷⵢⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⵙⵙⵉⴳⴳⵯⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH6_15","017_6_15","NEH","6","15","15","ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⵃⵉⴹ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵉⵍⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("NH6_16","017_6_16","NEH","6","16","16","ⵓⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵥⵔⵉⵏ ⵜ, ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵓⵛⵉⵏ ⴰⵇⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH6_17","017_6_17","NEH","6","17","17","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓⵔⵉⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⴱⵔⴰⵜⵉⵏ, ⵙⴻⴽⴽⴻⵏ ⵜⴻⵏⵜ ⵉ ⵟⵓⴱⵉⵢⴰ ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵜⵉⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵟⵓⴱⵉⵢⴰ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH6_18","017_6_18","NEH","6","18","18","ⵎⴰⵖⴰⵔ ⴰⵟⵟⴰⵙ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⵊⵊⵓⴵⴻⵏ ⴰⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵛⴰⵅⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴰⵃ, ⵓ ⵎⵎⵉⵙ ⵏⵏⴻⵙ ⵢⵓⵃⴰⵏⴰⵏ ⵜⵓⵖⴰ ⵢⵉⵡⵉ ⵢⴻⴵⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH6_19","017_6_19","NEH","6","19","19","ⵄⴰⵡⴻⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵓ ⵙⵙⵉⵡⴹⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵖⴰⵔⴻⵙ. ⵓ ⵟⵓⴱⵉⵢⴰ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴰⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("NH7_1","017_7_1","NEH","7","1","1","ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵍⵃⵉⴹ ⵄⴰⵡⴻⴷ ⵓ ⴳⴳⵉⵖ ⵜⵉⵡⵡⵓⵔⴰ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴽⴽⴱⴻⵏⵜ, ⴰⵇⴰ ⵍⴻⵇⵇⵎⴻⵖ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_2","017_7_2","NEH","7","2","2","ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵉ ⵓⵎⴰ ⵃⴰⵏⴰⵏⵉ ⵓ ⵉ ⵃⴰⵏⴰⵏⵢⴰ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵇⴻⵍⵄⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ ⴽⵜⴰⵔ ⵅ ⵡⴰⵟⵟⴰⵙ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH7_3","017_7_3","NEH","7","3","3","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵜⵜⵏⵓⵔⵣⵉⵎⴻⵏⵜ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍ ⵖⴰ ⵜⴻⵣⵡⴻⵖ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⵊⵊⴻⵎ ⴰⴷ ⴱⴻⵍⵍⵄⴻⵏ ⵜⵉⵡⵡⵓⵔⴰ ⵓ ⴰⴷ ⴰⵔⵔⴻⵏ ⵉⵣⴻⴽⵔⵓⵏⴻⵏ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵄⴰⴷ ⵉ ⵜⵄⴻⵙⵙⴰⵙⵜ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴳⴳⴻⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH7_4","017_7_4","NEH","7","4","4","ⵜⵓⵖⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴻⵏⵏⴻⵊⴱⴻⴷ ⵓ ⵜⴻⵎⵖⴰⵔ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⴳⴻⵏⵙ ⴷⵔⵓⵙ ⵓ ⵜⵓⴷⵔⵉⵏ ⵜⵓⵖⴰ ⵡⴰⵔ ⴱⵏⵉⵏⵜ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NH7_5","017_7_5","NEH","7","5","5","ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⴰⴷ ⵍⴰⵖⵉⵖ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⵎⵎⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵓⴼⵉⵖ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵓⴼⵉⵖ ⵢⵓⵔⴰ ⴷⴰⵢⴻⵙ ⵎⴰⵏ ⴰⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("NH7_6","017_7_6","NEH","7","6","6","“ⴰⵇⴰ ⴷ ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⵍⵄⴰⵎⴰⵍⴰ ⵏⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ - ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⵉ ⵍⵎⴻⵏⴼⴰ - ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NH7_7","017_7_7","NEH","7","7","7","ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵢⴰⵀⵓⵛⴰⵄ, ⵏⴰⵃⴰⵎⵢⴰ, ⵄⴰⵣⴰⵔⵢⴰ, ⵔⴰⵄⴰⵎⵢⴰ, ⵏⴰⵃⴰⵎⴰⵏⵉ, ⵎⵓⵔⴷⴰⵅⴰⵢ, ⴱⵉⵍⵛⴰⵏ, ⵎⵉⵙⴼⴰⵔⴰⵜ, ⴱⵉⵖⵡⴰⵢ, ⵏⴰⵃⵓⵎ ⴷ ⴱⴰⵄⵏⴰ. ⵡⴰ ⴷ ⵍⵇⴻⴷⴷ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH7_8","017_7_8","NEH","7","8","8","ⴰⵢⵜ ⵏ ⴼⴰⵔⵄⵓⵛ: ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_9","017_7_9","NEH","7","9","9","ⴰⵢⵜ ⵏ ⵛⴰⴼⴰⵟⵢⴰ: ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_10","017_7_10","NEH","7","10","10","ⴰⵢⵜ ⵏ ⴰⵔⴰⵃ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_11","017_7_11","NEH","7","11","11","ⴰⵢⵜ ⵏ ⴼⴰⵀⴰⵜ-ⵎⵓ’ⴰⴱ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⴻⵛⵓⵄⴰ ⴷ ⵢⵓⵡⴰⴱ: ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵜⵎⴻⵏⵢⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ-ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_12","017_7_12","NEH","7","12","12","ⴰⵢⵜ ⵏ ⵄⵉⵍⴰⵎ: ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_13","017_7_13","NEH","7","13","13","ⴰⵢⵜ ⵏ ⵣⴰⵜⵜⵓ: ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_14","017_7_14","NEH","7","14","14","ⴰⵢⵜ ⵏ ⵣⴰⴽⴽⴰⵢ: ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_15","017_7_15","NEH","7","15","15","ⴰⵢⵜ ⵏ ⴱⵉⵏⵏⴰⵢ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_16","017_7_16","NEH","7","16","16","ⴰⵢⵜ ⵏ ⴱⴰⴱⴰⵢ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_17","017_7_17","NEH","7","17","17","ⴰⵢⵜ ⵏ ⵄⴰⵔⵊⴰⴷ: ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵟⴻⵔⵜ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_18","017_7_18","NEH","7","18","18","ⴰⵢⵜ ⵏ ⴰⴷⵓⵏⵉⵇⴰⵎ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_19","017_7_19","NEH","7","19","19","ⴰⵢⵜ ⵏ ⴱⵉⵖⵡⴰⵢ: ⴰⵍⴼⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_20","017_7_20","NEH","7","20","20","ⴰⵢⵜ ⵏ ⵄⴰⴷⵉⵏ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_21","017_7_21","NEH","7","21","21","ⴰⵢⵜ ⵏ ⴰⵟⵉⵔ ⵣⵉ ⵃⵉⵣⵇⵉⵢⴰ: ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_22","017_7_22","NEH","7","22","22","ⴰⵢⵜ ⵏ ⵃⴰⵛⵓⵎ: ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_23","017_7_23","NEH","7","23","23","ⴰⵢⵜ ⵏ ⴱⵉⵚⴰⵢ: ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_24","017_7_24","NEH","7","24","24","ⴰⵢⵜ ⵏ ⵃⴰⵔⵉⴼ: ⵎⵢⴰ ⵓ-ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_25","017_7_25","NEH","7","25","25","ⴰⵢⵜ ⵏ ⵊⵉⴱⵄⵓⵏ: ⵅⴻⵎⵙⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_26","017_7_26","NEH","7","26","26","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷ ⵏⴰⵟⵓⴼⴰ: ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_27","017_7_27","NEH","7","27","27","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵏⴰⵜⵓⵜ: ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_28","017_7_28","NEH","7","28","28","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵄⴰⵣⵎⵓⵜ: ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_29","017_7_29","NEH","7","29","29","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ, ⴽⴰⴼⵉⵔⴰ ⴷ ⴱⵉⵄⵔⵓⵜ: ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_30","017_7_30","NEH","7","30","30","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵔⴰⵎⴰ ⴷ ⵊⴰⴱⴰⵄ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵡⴰⵃⴻⴷ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_31","017_7_31","NEH","7","31","31","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵎⵉⵅⵎⴰⵙ: ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_32","017_7_32","NEH","7","32","32","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵄⴰⵢ: ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_33","017_7_33","NEH","7","33","33","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵏⴰⴱⵓ ⵏⵏⴻⵖⵏⵉ: ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_34","017_7_34","NEH","7","34","34","ⴰⵢⵜ ⵏ ⵉⵊⵊ ⵏ ⵄⵉⵍⴰⵎ ⵏⵏⴻⵖⵏⵉ, ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_35","017_7_35","NEH","7","35","35","ⴰⵢⵜ ⵏ ⵃⴰⵔⵉⵎ: ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_36","017_7_36","NEH","7","36","36","ⴰⵢⵜ ⵏ ⴰⵔⵉⵃⴰ: ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_37","017_7_37","NEH","7","37","37","ⴰⵢⵜ ⵏ ⵍⵓⴷ, ⵃⴰⴷⵉⴷ ⴷ ⵓⵏⵓ: ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵡⴰⵃⴻⴷ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_38","017_7_38","NEH","7","38","38","ⴰⵢⵜ ⵏ ⵙⴰⵏⴰ’ⴰ: ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_39","017_7_39","NEH","7","39","39","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⴰⵢⵜ ⵏ ⵢⴰⴷⴰⵄⵢⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴻⵛⵓⵄⴰ: ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_40","017_7_40","NEH","7","40","40","ⴰⵢⵜ ⵏ ⵉⵎⵎⵉⵔ: ⴰⵍⴻⴼ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_41","017_7_41","NEH","7","41","41","ⴰⵢⵜ ⵏ ⴼⴰⵛⵃⵓⵔ: ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_42","017_7_42","NEH","7","42","42","ⴰⵢⵜ ⵏ ⵃⴰⵔⵉⵎ: ⴰⵍⴻⴼ ⵓ-ⵙⴱⴻⵄⵟⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_43","017_7_43","NEH","7","43","43","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⴰⵢⵜ ⵏ ⵢⴻⵛⵓⵄⴰ, ⴰⵢⵜ ⵏ ⵇⴰⴷⵎⵉⵢⵉⵍ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵀⵓⴷⵓⵡⵢⴰ: ⴰⵔⴻⴱⵄⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_44","017_7_44","NEH","7","44","44","ⵉⵎⴻⴷⵢⴰⵣⴻⵏ. ⴰⵢⵜ ⵏ ⴰⵙⴰⴼ: ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_45","017_7_45","NEH","7","45","45","ⴰⵢⵜ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ. ⴰⵢⵜ ⵏ ⵛⴰⵍⵍⵓⵎ, ⴰⵢⵜ ⵏ ⴰⵟⵉⵔ, ⴰⵢⵜ ⵏ ⵟⴰⵍⵎⵓⵏ, ⴰⵢⵜ ⵏ ⵄⴰⵇⵇⵓⴱ, ⴰⵢⵜ ⵏ ⵃⴰⵟⵉⵟⴰ, ⴰⵢⵜ ⵏ ⵛⵓⴱⴰⵢ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ: ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_46","017_7_46","NEH","7","46","46","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⵢⵜ ⵏ ⵚⵉⵃⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵙⵓⴼⴰ, ⴰⵢⵜ ⵏ ⵟⴰⴱⴰⵄⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("NH7_47","017_7_47","NEH","7","47","47","ⴰⵢⵜ ⵏ ⵇⵉⵔⵓⵛ, ⴰⵢⵜ ⵏ ⵛⵉⵄⴰ, ⴰⵢⵜ ⵏ ⴼⴰⴷⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("NH7_48","017_7_48","NEH","7","48","48","ⴰⵢⵜ ⵏ ⵍⴰⴱⴰⵏⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵊⴰⴱⴰ, ⴰⵢⵜ ⵏ ⵙⴰⵍⵎⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NH7_49","017_7_49","NEH","7","49","49","ⴰⵢⵜ ⵏ ⵃⴰⵏⴰⵏ, ⴰⵢⵜ ⵏ ⵊⴰⴷⵉⵍ, ⴰⵢⵜ ⵏ ⵃⴰⵊⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("NH7_50","017_7_50","NEH","7","50","50","ⴰⵢⵜ ⵏ ⵔⴰ’ⴰⵢⴰ, ⴰⵢⵜ ⵏ ⵔⴰⵚⵉⵏ, ⴰⵢⵜ ⵏ ⵏⴰⵇⵇⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("NH7_51","017_7_51","NEH","7","51","51","ⴰⵢⵜ ⵏ ⵊⴰⵣⵣⴰⵎ, ⴰⵢⵜ ⵏ ⵄⴰⵣⵣⴰ, ⴰⵢⵜ ⵏ ⴼⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("NH7_52","017_7_52","NEH","7","52","52","ⴰⵢⵜ ⵏ ⴱⵉⵙⴰⵢ, ⴰⵢⵜ ⵏ ⵎⴰⵄⵓⵏⵉⵎ, ⴰⵢⵜ ⵏ ⵏⴰⴼⵉⵛⴰⵙⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("NH7_53","017_7_53","NEH","7","53","53","ⴰⵢⵜ ⵏ ⴱⴰⵇⴱⵓⵇ, ⴰⵢⵜ ⵏ ⵃⴰⵇⵓⴼⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵔⵃⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NH7_54","017_7_54","NEH","7","54","54","ⴰⵢⵜ ⵏ ⴱⴰⵚⵍⵉⵜ, ⴰⵢⵜ ⵏ ⵎⴰⵃⵉⴷⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵔⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("NH7_55","017_7_55","NEH","7","55","55","ⴰⵢⵜ ⵏ ⴱⴰⵔⵇⵓⵙ, ⴰⵢⵜ ⵏ ⵙⵉⵙⴰⵔⴰ, ⴰⵢⵜ ⵏ ⵜⴰⵎⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("NH7_56","017_7_56","NEH","7","56","56","ⴰⵢⵜ ⵏ ⵏⴰⵚⵉⵃ, ⴰⵢⵜ ⵏ ⵃⴰⵟⵉⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("NH7_57","017_7_57","NEH","7","57","57","ⴰⵢⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⴰⵢⵜ ⵏ ⵙⵓⵟⴰⵢ, ⴰⵢⵜ ⵏ ⵙⵓⴼⴰⵔⴰⵜ, ⴰⵢⵜ ⵏ ⴼⴰⵔⵉⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("NH7_58","017_7_58","NEH","7","58","58","ⴰⵢⵜ ⵏ ⵢⴰⵄⵍⴰ, ⴰⵢⵜ ⵏ ⴷⴰⵔⵇⵓⵏ, ⴰⵢⵜ ⵏ ⵊⵉⴷⴷⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("NH7_59","017_7_59","NEH","7","59","59","ⴰⵢⵜ ⵏ ⵛⴰⴼⴰⵟⵢⴰ, ⴰⵢⵜ ⵏ ⵃⴰⵜⵜⵉⵍ, ⴰⵢⵜ ⵏ ⴼⵓⵅⴰⵔⴰⵜ-ⵀⴰ-ⴹⴰⴱⴰⵢⵉⵎ ⴷ ⴰⵢⵜ ⵏ ⴰⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_60","017_7_60","NEH","7","60","60","ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⴰⵢⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_61","017_7_61","NEH","7","61","61","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴰⵍ-ⵎⵉⵍⵃ, ⵜⴰⵍ-ⵃⴰⵔⵛⴰ, ⴽⴰⵔⵓⴱ, ⴰⴷⴷⴰⵏ ⴷ ⵉⵎⵎⵉⵔ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵏⵉⵖ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("NH7_62","017_7_62","NEH","7","62","62","ⴰⵢⵜ ⵏ ⴷⴰⵍⴰⵢⴰ, ⴰⵢⵜ ⵏ ⵟⵓⴱⵉⵢⴰ, ⴰⵢⵜ ⵏ ⵏⴰⵇⵇⵓⴷⴰ: ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_63","017_7_63","NEH","7","63","63","ⵓⵛⴰ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⴰⵢⵜ ⵏ ⵃⴰⴱⴰⵢⴰ, ⴰⵢⵜ ⵏ ⵀⴰⵇⵇⵓⵚ, ⴰⵢⵜ ⵏ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ, ⴰⵇⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵊⵉⵍⵄⴰⴷⵉ ⴱⴰⵔⵣⵉⵍⵍⴰⵢ ⵓ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_64","017_7_64","NEH","7","64","64","ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⵅ ⵜⴻⵡⵔⵉⵇⵜ ⵏ ⵓⵣⴻⵎⵎⴻⵎ ⵏⵙⴻⵏ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵊⵊⴰⴷⵉⵔⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NH7_65","017_7_65","NEH","7","65","65","ⵍⵡⴰⵍⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵏⵏⴰ ⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ ⴰⵍ ⵖⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴽ-ⴷ ⵓⵔⵉⵎ ⴷ ⵜⵓⵎⵎⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH7_66","017_7_66","NEH","7","66","66","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NH7_67","017_7_67","NEH","7","67","67","ⵏⵀⵍⴰ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵙⴻⵏ ⴷ ⵜⵉⵢⵢⴰ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ, ⵓⵛⴰ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵜⵎⴻⴷⵢⴰⵣⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_68","017_7_68","NEH","7","68","68","ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵓ ⵉⵖⵢⴰⵍ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_69","017_7_69","NEH","7","69","69","ⵛⴰ ⵣⴻⴳ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵡⵛⵉⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ. ⵍⵡⴰⵍⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵡⵛⴰ ⵉ ⵙⵙⴻⵏⴷⵓⵇ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴰⵍⴻⴼ ⵏ ⴷⵔⴰⵅⵎⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵅⴻⵎⵙⵉⵏ ⵏ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_70","017_7_70","NEH","7","70","70","ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵡⵛⵉⵏ ⵉ ⵙⵙⴻⵏⴷⵓⵇ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⴷⵔⴰⵅⵎⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵎⵉⵏⴰⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH7_71","017_7_71","NEH","7","71","71","ⵓⵛⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵡⵛⴰ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⴷⵔⴰⵅⵎⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵎⵉⵏⴰⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵙⴻⴱⵄⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH7_72","017_7_72","NEH","7","72","72","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵛⴰ ⵣⵉ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH8_1","017_8_1","NEH","8","1","1","ⵓⵎⵉ ⵉⴱⴷⴰ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓⵛⴰ ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⵉⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵎⴰⵏ, ⵏⵏⴰⵏ ⵉ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴻⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⴷ ⵢⴰⵡⵉ ⴰⴷⵍⵉⵙ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵜⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH8_2","017_8_2","NEH","8","2","2","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵉⵣⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⴼⴻⵀⵎⴻⵎ ⵅⵎⵉ ⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵙⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH8_3","017_8_3","NEH","8","3","3","ⵏⴻⵜⵜⴰ ⵉⵖⵔⴰ ⵣⵣⴰⵢⴻⵙ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵣⵣⴰⵢ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵎⴰⵏ, ⵣⵉ ⵜⵓⴼⴼⵓⵜ ⴰⵍ ⴰⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ, ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⴼⴻⵀⵎⴻⵎ. ⵜⵓⵖⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("NH8_4","017_8_4","NEH","8","4","4","ⵓⵛⴰ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵉⴱⴻⴷⴷ ⵅ ⵉⵊⵊ ⵏ ⴷⴷⵔⵓⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵉ ⵓⵢⴰ, ⵓ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⴱⴻⴷⴷⴻⵏ ⵎⴰⵜⵜⵉⵜⵢⴰ ⴷ ⵛⴰⵎⴰⵄ ⴷ ⵄⴰⵏⴰⵢⴰ ⴷ ⵓⵔⵉⵢⴰ ⴷ ⵃⵉⵍⵇⵉⵢⴰ ⴷ ⵎⴰⵄⴰⵙⵉⵢⴰ ⵓ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ ⴱⴻⴷⴷⴻⵏ ⴼⴰⴷⴰⵢⴰ ⴷ ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⵎⴰⵍⴽⵉⵢⴰ ⴷ ⵃⴰⵛⵓⵎ ⴷ ⵃⴰⵛⴱⴰⴷⴷⴰⵏⴰ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⴷ ⵎⴰⵛⵓⵍⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("NH8_5","017_8_5","NEH","8","5","5","ⵢⴰⵔⵣⴻⵎ ⵄⵉⵣⵔⴰ ⴰⴷⵍⵉⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵎⴰⵖⴰⵔ ⵉⴱⴻⴷⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵓⵎⵉ ⵜ ⵢⴰⵔⵣⴻⵎ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NH8_6","017_8_6","NEH","8","6","6","ⵄⵉⵣⵔⴰ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ: “ⴰⵎⵉⵏ, ⴰⵎⵉⵏ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵢⵓⴹⴰⵔⴻⵏ, ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵙⵉⴷⵉ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH8_7","017_8_7","NEH","8","7","7","ⵙⵙⵍⴻⵎⴷⴻⵏ ⵢⴻⵛⵓⵄⴰ, ⴱⴰⵏⵉ, ⵛⴰⵔⴰⴱⵢⴰ, ⵢⴰⵎⵉⵏ, ⵄⴰⵇⵇⵓⴱ, ⵛⴰⴱⴱⴰⵜⴰⵢ, ⵀⵓⴷⵉⵢⴰ, ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵇⴰⵍⵉⵟⴰ, ⵄⴰⵣⴰⵔⵢⴰ, ⵢⵓⵣⴰⴱⴰⴷ, ⵃⴰⵏⴰⵏ, ⴼⴰⵍⴰⵢⴰ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⵍⴳⴻⵏⵙ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH8_8","017_8_8","NEH","8","8","8","ⵖⵔⵉⵏ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵛⴰⵔⵔⵃⴻⵏ ⵓ ⵙⵙⴻⵛⵏⴻⵏ ⵍⵎⴻⵄⵏⴰ ⵉ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵙⵙⴼⴻⵀⵎⴻⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵖⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH8_9","017_8_9","NEH","8","9","9","ⵓⵛⴰ ⵏⴰⵃⴰⵎⵢⴰ, ⵡⴻⵏⵏⵉ ⴷ ⵍⵡⴰⵍⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴰⴷ, ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵍⴻⵎⴷⴻⵏ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ: “ⴰⵙⵙ-ⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵛⵛⴰⵜⴻⵎ ⴰⴳⴻⵊⴷⵓⵔ, ⵡⴰⵔ ⵜⵜⵔⵓⵎ.” ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⵉⵔⵓ ⵓⵎⵉ ⵙⵍⴰⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("NH8_10","017_8_10","NEH","8","10","10","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ: “ⵓⵢⵓⵔⴻⵎ ⵓ ⵜⴻⵛⵛⴻⵎ ⵎⴰⵛⵛⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵣⵣⴻⵛⵜ, ⵙⵙⵡⴻⵎ ⴱⵉⵏⵓ ⴰⵎⵉⵥⵉⴷ ⵓⵛⴰ ⵡⵛⴻⵎ ⵎⴰⵛⵛⴰ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵡⴰⵍⵓ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ⵡⴰⵔ ⵙⵃⵉⵙⵙⵉⴼⴻⵎ, ⵎⴰⵖⴰⵔ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⵇⴻⵍⵄⴰ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NH8_11","017_8_11","NEH","8","11","11","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵙⵙⴼⴻⵡⵡⵊⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⵙⵇⴰⵔⴻⵎ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ-ⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵉ ⵉⴵⴰ. ⵡⴰⵔ ⵙⵃⵉⵙⵙⵉⴼⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("NH8_12","017_8_12","NEH","8","12","12","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⵓ ⴰⴷ ⵚⴻⴷⵇⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴼⴻⵀⵎⴻⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH8_13","017_8_13","NEH","8","13","13","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵎⵓⵏⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("NH8_14","017_8_14","NEH","8","14","14","ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⴷⵉ ⵍⵄⵉⴷ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("NH8_15","017_8_15","NEH","8","15","15","ⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴱⴰⵔⵔⵃⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵏ ⵉⵊⵊ ⵏ ⵓⵍⴰⵖⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉⵏ: “ⴼⵖⴻⵎ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵓ ⴰⵡⵢⴻⵎ-ⴷⴷ ⵉⴼⴻⵜⵡⴰⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷ ⵉⴼⴻⵜⵡⴰⵏ ⵏ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⴷ ⵉⴼⴻⵜⵡⴰⵏ ⵏ ⵜⴰⵔⵉⵃⴰⵏⵜ ⴷ ⵉⴼⴻⵜⵡⴰⵏ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ ⴷ ⵉⴼⴻⵜⵡⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵖⴰⵔⵙⴻⵏⵜ ⵜⵉⴼⵔⴰⵢ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⴳⴳⴻⵎ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("NH8_16","017_8_16","NEH","8","16","16","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⴼⴻⵜⵡⴰⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵜⵣⴻⵇⵇⴰ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏⵙⴻⵏ ⵓ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵎⴰⵏ ⵓ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH8_17","017_8_17","NEH","8","17","17","ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⴳⴳⵉⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵓ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴳⴳⵉⵏ ⴰⵢⴰ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⴰⵍ ⴰⵙⵙ-ⴰ ⵓⵛⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NH8_18","017_8_18","NEH","8","18","18","ⴰⵙⵙ ⵉⴹⴼⴰⵔ ⵓⵎⴰⵙ ⵉⵜⵜⵡⴰⵖⵔⴰ ⵅⴰⵙⴻⵏ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵍ ⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ. ⴰⵎⵎⵓ ⵉ ⵄⴻⵢⵢⴷⴻⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⴷⵉ ⵍⴼⴰⵔⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_1","017_9_1","NEH","9","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ-ⴰ ⵎⵓⵏⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵓⵥⵓⵎⵎⵉ ⵓ ⵍⴻⵃⵃⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⵙ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵅ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("NH9_2","017_9_2","NEH","9","2","2","ⴱⴹⴰⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⴰⵎ ⵇⵇⵉⵎⴻⵏ ⴽⴽⴰⵔⴻⵏ, ⵏⴻⵄⵎⴻⵏ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_3","017_9_3","NEH","9","3","3","ⵅⴰⵙ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵖⵔⵉⵏ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⴰⵄⵜ ⵏ ⵡⴰⵙⵙ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⴰⵄⵜ ⵏⵏⴻⵖⵏⵉ ⵏⴻⵄⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_4","017_9_4","NEH","9","4","4","ⵅ ⴷⴷⵔⵓⵊ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⴱⴻⴷⴷ ⵢⴻⵛⵓⵄⴰ ⴷ ⴱⴰⵏⵉ, ⵇⴰⴷⵎⵉⵢⵉⵍ, ⵛⴰⴱⴰⵏⵢⴰ, ⴱⵓⵏⵏⵉ, ⵛⴰⵔⴰⴱⵢⴰ, ⴱⴰⵏⵉ ⴷ ⴽⴰⵏⴰⵏⵉ, ⵍⴰⵖⴰⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_5","017_9_5","NEH","9","5","5","ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵢⴻⵛⵓⵄⴰ, ⵇⴰⴷⵎⵉⵢⵉⵍ, ⴱⴰⵏⵉ, ⵃⴰⵛⴰⴱⵏⵉⵢⴰ, ⵛⴰⵔⴰⴱⵢⴰ, ⵀⵓⴷⵉⵢⴰ, ⵛⴰⴱⴰⵏⵢⴰ ⴷ ⴼⴰⵜⴰⵃⵢⴰ, ⵏⵏⴰⵏ: “ⴽⴽⴰⵔⴻⵎ, ⵜⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ! ⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵉⵙⴻⵎ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵓⵙⴻⵎⵖⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("NH9_6","017_9_6","NEH","9","6","6","“ⵛⴻⴽ ⴷ ⵙⵉⴷⵉ, ⵎⵖⵉⵔ ⵛⴻⴽ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵊⴻⵏⵏⴰ ⵓⵍⴰ ⴷ ⴰⵊⴻⵏⵏⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵉⴵⴰⵏ, ⵍⴻⴱⵃⵓⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵓ ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵓⵛⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵜⵜⴱⴻⵏⴷⴰⵇⴻⵏⵜ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("NH9_7","017_9_7","NEH","9","7","7","ⵛⴻⴽ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⴰⴱⵔⴰⵎ. ⵛⴻⴽ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵓⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵙ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH9_8","017_9_8","NEH","9","8","8","ⵛⴻⴽ ⵜⵓⴼⵉⴷ ⵓⵍ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓ ⵜⴻⴳⴳⵉⴷ ⴰⴽⵉⴷⴻⵙ ⵍⵄⴰⵀⴷ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵏ ⵉⵃⵉⵜⵜⵉⵢⵢⴻⵏ, ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵏ ⵉⴼⴰⵔⵉⵣⵉⵢⵢⴻⵏ, ⵏ ⵉⵢⴰⴱⵓⵙⵉⵢⵢⴻⵏ ⵓ ⵏ ⵉⵊⵉⵔⵊⴰⵙⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉ ⵜⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("NH9_9","017_9_9","NEH","9","9","9","ⵛⴻⴽ ⵜⴻⵥⵔⵉⴹ ⵜⴰⵎⴰⵔⴰ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⵜⴻⵙⵍⵉⴷ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ ⵣⵉ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_10","017_9_10","NEH","9","10","10","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵙ ⵜⵓⴼⴼⴻⵜ ⵓⵛⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵉⵙⴻⵎ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_11","017_9_11","NEH","9","11","11","ⵛⴻⴽ ⵜⴻⴱⴹⵉⴷ ⵍⴻⴱⵃⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵄⴷⵓⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵜⵜⴰⵥⵥⵍⴻⵏ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵜⴻⵏ ⴷⵉ ⵍⴰⴵⴰⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_12","017_9_12","NEH","9","12","12","ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵜⴳⴻⵡⵡⴷⴻⴷ ⵜⴻⵏ ⵙ ⵡⴰⵙⵙ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⵙⵙⵉ ⵙ ⴵⵉⵍⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⴻⴷ ⵜⴰⴼⴰⵡⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_13","017_9_13","NEH","9","13","13","ⵛⴻⴽ ⵜⴻⵀⵡⵉⴷ-ⴷⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵓ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵎⴰⵏ ⴷ ⵜⵡⴻⵚⵚⴰ ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_14","017_9_14","NEH","9","14","14","ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⵙⴻⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵅⴰⵙⴻⵏ ⵍⵓⵎⵓⵔⴰⵜ ⴷ ⵜⵡⴻⵚⵚⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NH9_15","017_9_15","NEH","9","15","15","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⴰⵖⵔⵓⵎ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉ ⵍⴰⵥ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵎⴰⵏ ⵣⵉ ⵜⴻⵚⴹⴰⵔⵜ ⵉ ⵓⴼⴰⴷⵉ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴻⵏⵏⵉⴷ ⴰⵙⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵉ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵊⵊⴰⴵⴻⴷ ⴰⴷ ⵜⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ-ⵜⴻⵡⵛⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("NH9_16","017_9_16","NEH","9","16","16","“ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴳⴳⵉⵏ ⵙ ⵜⵓⴼⴼⴻⵜ ⴷ ⵜⵖⴻⵏⵏⴰⵏⵜ ⵓ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵖⴰⵔ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NH9_17","017_9_17","NEH","9","17","17","ⵏⵉⵜⵏⵉ ⵓⴳⵉⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⵙⵍⴻⵏ, ⵡⴰⵔ ⴼⴻⴽⴽⴰⵔⴻⵏ ⴷⵉ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ ⵉ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴳⴳⵉⴷ ⵓ ⵏⵉⵜⵏⵉ ⵖⴻⵏⵏⴰⵏ ⵓ ⴷⴻⴳ ⵓⵖⴻⵡⵡⴻⵖ ⵏⵙⴻⵏ ⴳⴳⵉⵏ ⵉⵊⵊ ⴷ ⵓⵣⴻⴵⵉⴼ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵙⵎⵓⵖⵉ ⵏⵙⴻⵏ. ⵎⴰⵛⴰ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵖⴻⴼⴼⴰⵔⴻⵏ, ⴷⴰⵢⴻⴽ ⵍⵅⴰⴹⴰⵔ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⵖⴰⵔⴻⴽ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵙⵎⵉⵃⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_18","017_9_18","NEH","9","18","18","ⵄⴰⴷ, ⵓⵎⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵉⴼⴻⵙⵢⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: ‘ⵡⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵉ ⵛⴻⴽ ⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ’, ⵓⵛⴰ ⵛⴻⵇⵇⴼⴻⵏ ⴰⵟⵟⴰⵙ,    ");
INSERT INTO rift_vpl VALUES ("NH9_19","017_9_19","NEH","9","19","19","ⴰⵇⴰ ⵛⴻⴽ ⴷⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵊⵊⵉⴷ ⵛⴰ ⴷⵉ ⵍⴻⵅⵍⴰ. ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉ ⵉⴵⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⴳⴻⵡⵡⴻⴷ ⵙ ⵡⴰⵙⵙ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⴳⴳⵯⵉⵊ ⵛⴰ, ⵓⵍⴰ ⴷ ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⵉⴵⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵜⴰⴼⴰⵡⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵏ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⴳⴳⵯⵉⵊ ⵛⴰ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH9_20","017_9_20","NEH","9","20","20","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵛ ⴰⵚⴻⴱⵃⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵍⵎⴻⴷ, ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⴽⴽⵉⵙⴻⴷ ⵛⴰ ‘ⵎⴰⵏⵏⴰ’ ⵏⵏⴻⴽ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⴰⵎⴰⵏ ⵉ ⵓⴼⴰⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_21","017_9_21","NEH","9","21","21","ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵀⴻⵍⵍⵉⴷ ⴷⴰⵢⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵜⵜⵅⵉⵚⵚⴰ ⵓⵍⴰ ⴷ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵡⴰⵔ ⵢⴰⵔⵛⵉ ⵛⴰ ⵓⵛⴰ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵓⴼⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_22","017_9_22","NEH","9","22","22","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⴷ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵜⴻⴱⴹⵉⴷ ⴰⵙⴻⵏ ⵜⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵢⵎⵉⵔ. ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵙⵉⵃⵓⵏ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵛⴱⵓⵏ, ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_23","017_9_23","NEH","9","23","23","ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵅ ⵜⵓⵖⴰ ⵜⴻⵏⵏⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH9_24","017_9_24","NEH","9","24","24","ⵢⵓⴷⴻⴼ ⵖⴰⵔⴻⵙ ⵡⴰⵔⵔⴰⵡ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵖⵉⵍ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("NH9_25","017_9_25","NEH","9","25","25","ⵏⵉⵜⵏⵉ ⵃⴻⵡⵡⵙⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵓⴷⵔⵉⵏ ⴷ ⵍⵡⴰⵔⵜ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ, ⴰⵏⵓⵜⴻⵏ ⵉⵜⵜⵡⴰⵖⵣⴻⵏ, ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴷ ⵍⴻⵄⵔⴰⵚⵉⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⴼⵔⵓⵜⴰ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ, ⵊⵊⵉⵡⵏⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⵚⴻⵃⵃⴻⵏ ⵓⵛⴰ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵎⴻⵥⵔⵉ ⵙ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NH9_26","017_9_26","NEH","9","26","26","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵡⴰⵔ ⵟⵟⵉⵄⴻⵏ ⵓⵛⴰ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⴽ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵓ ⵏⵖⵉⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵖⴰⵔⴻⴽ. ⴰⵇⴰ ⵛⴻⵇⵇⴼⴻⵏ ⴷⴰⵢⴻⴽ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵇⵇⴻⴼ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NH9_27","017_9_27","NEH","9","27","27","ⵙ ⵓⵢⴰ ⵜⴰⵔⵔⵉⴷ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏ ⵉⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵃⵚⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅⴰⴽ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔⵙⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴷⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴻⵏⵊⴰⵎⴻⵏ ⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_28","017_9_28","NEH","9","28","28","ⵎⴰⵍⴰ ⵓⴼⵉⵏ ⵍⵀⵓⴷⵏⴻⵜ, ⴳⴳⵉⵏ ⵄⴰⵡⴻⴷ ⵍⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⴻⴵⴹⴻⵏ ⵅⴰⵙⴻⵏ. ⵓⵎⵉ ⵜⵓⴱⴻⵏ, ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅⴰⴽ, ⴰⵇⴰ ⵜⴻⵙⵍⵉⴷ ⴰⵙⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⵎⵎⵓ ⵉ ⵜⴼⴻⴽⴽⴻⴷ ⵉ-ⵜⴻⵏ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_29","017_9_29","NEH","9","29","29","ⵛⴻⴽ ⵜⵛⴻⵀⴷⴻⴷ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵙ ⵜⵓⴼⴼⴻⵜ ⵓ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵖⴰⵔ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ⴰⵇⴰ ⵅⴹⴰⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ, ⵓⵎⵉ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴷⴷⴰⵔ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⴰⵄⵔⵓⵔ, ⵜⵓⵖⴰ ⵙⵙⵇⴻⵙⵃⴻⵏ ⵉⵔⵉ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵙⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_30","017_9_30","NEH","9","30","30","ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵜⵃⴻⵎⵎⵍⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵜⵛⴻⵀⴷⴻⴷ ⴹⵉⴷⴷ ⵉ ⵏⵙⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵛ, ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴻⵡⵛⵉⴷ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_31","017_9_31","NEH","9","31","31","ⵎⴰⵛⴰ ⴷⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵡⴰⵔ ⵜⴻⵏ ⵜⴰⵔⴻⴷⴵⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵙⵎⵉⵃⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵃⵏⵉⵏ ⴷ ⴰⵔⵃⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH9_32","017_9_32","NEH","9","32","32","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵣⴻⵎⵎⴰⵔⴻⵏ, ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵓ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵡⴰⵔ ⵃⴻⵙⵙⴻⴱ ⵛⴰ ⴷⵔⵓⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵖⴱⴻⵏ ⵉ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⴽⴽⵉⵏ, ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖ, ⵅ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ ⵓ ⵅ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵖ ⵓ ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵖ ⵓ ⵅ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_33","017_9_33","NEH","9","33","33","ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵏⴻⵖ ⵉⴽⴽⵉⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵏⴻⵖ ⵙ ⵍⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴳⴳⴰ ⵙ ⵍⴻⵇⵊⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH9_34","017_9_34","NEH","9","34","34","ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖ, ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵖ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵡⴰⵔ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⵓⵍⴰ ⵖⴰⵔ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⵛⴻⵀⴷⴻⴷ ⴹⵉⴷⴷ ⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_35","017_9_35","NEH","9","35","35","ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵙⴻⵏ ⵓ ⵙ ⵍⵅⴰⵔ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⵉⴷ ⵓ ⵙ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⵉⴷ, ⵡⴰⵔ ⵛⴻⴽ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵣⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH9_36","017_9_36","NEH","9","36","36","ⵅⵣⴰⵔ ⴰⵙⵙ-ⴰ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵎⵖⴰⵏ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵜⴻⵡⵛⵉⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵛⵛ ⵍⵖⵉⴵⴻⵜ ⴷ ⵍⵅⴰⵔ, ⵅⵣⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵎⵖⴰⵏ ⵉ ⴷⴰⵢⴻⵙ ⵏⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("NH9_37","017_9_37","NEH","9","37","37","ⵍⵖⵉⴵⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵔⴰⵃ ⵖⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵅⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵚⴻⴵⴰⴹⴻⵏ ⵅ ⴰⵔⵔⴰⵢⴻⵎ ⵏⵏⴻⵖ ⵓ ⵅ ⵍⵎⴰⵍ ⵏⵏⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵖⵉⵍ ⵎⵍⵉⵃ, ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("NH10_1","017_10_1","NEH","10","1","1","“ⵅ ⵇⴰⵄ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉⵎⵜⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵏⵣⴻⵎⵎⴻⵎ ⴷⵉ ⵜⵉⵔⴰ ⵓⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⴻⵖ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵖ ⴰⴷ ⵅⴰⵙ ⴳⴳⴻⵏ ⴰⵛⴻⵎⵎⵉⵄ.” ");
INSERT INTO rift_vpl VALUES ("NH10_2","017_10_2","NEH","10","2","2","ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⴳⴳⵉⵏ ⴰⵛⴻⵎⵎⵉⵄ ⴷ ⵉⵏⴰ: ⵏⴰⵃⴰⵎⵢⴰ, ⵡⴻⵏⵏⵉ ⴷ ⵍⵡⴰⵍⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴽⴰⵍⵢⴰ, ⴷ ⵚⵉⴷⵇⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_3","017_10_3","NEH","10","3","3","ⵙⴰⵔⴰⵢⴰ, ⵄⴰⵣⴰⵔⵢⴰ, ⵉⵔⵎⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_4","017_10_4","NEH","10","4","4","ⴼⴰⵛⵃⵓⵔ, ⴰⵎⴰⵔⵢⴰ, ⵎⴰⵍⴽⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_5","017_10_5","NEH","10","5","5","ⵃⴰⵜⵜⵓⵛ, ⵛⴰⴱⴰⵏⵢⴰ, ⵎⴰⵍⵍⵓⵅ, ");
INSERT INTO rift_vpl VALUES ("NH10_6","017_10_6","NEH","10","6","6","ⵃⴰⵔⵉⵎ, ⵎⴰⵔⵉⵎⵓⵜ, ⵄⵓⴱⴰⴷⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_7","017_10_7","NEH","10","7","7","ⴷⴰⵏⵉⵢⴰⵍ, ⵊⵉⵏⵏⵉⵜⵓⵏ, ⴱⴰⵔⵓⵅ, ");
INSERT INTO rift_vpl VALUES ("NH10_8","017_10_8","NEH","10","8","8","ⵎⴰⵛⵓⵍⵍⴰⵎ, ⴰⴱⵉⵢⴰ, ⵎⵉⵢⴰⵎⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NH10_9","017_10_9","NEH","10","9","9","ⵎⴰⵄⴰⵣⵢⴰ, ⴱⵉⵍⵊⴰⵢ ⴷ ⵛⴰⵎⵄⵉⵢⴰ. ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH10_10","017_10_10","NEH","10","10","10","ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⵢⴻⵛⵓⵄⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵣⴰⵏⵢⴰ, ⴷ ⴱⵉⵏⵏⴰⵢ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵃⵉⵏⴰⴷⴰⴷ, ⵇⴰⴷⵎⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH10_11","017_10_11","NEH","10","11","11","ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ: ⵛⴰⴱⴰⵏⵢⴰ, ⵀⵓⴷⵉⵢⴰ, ⵇⴰⵍⵉⵟⴰ, ⵇⴰⵍⴰⵢⴰ, ⵃⴰⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NH10_12","017_10_12","NEH","10","12","12","ⵎⵉⵅⴰ, ⵔⴰⵃⵓⴱ, ⵃⴰⵛⴰⴱⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_13","017_10_13","NEH","10","13","13","ⵣⴰⴽⴽⵓⵔ, ⵛⴰⵔⴰⴱⵢⴰ, ⵛⴰⴱⴰⵏⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_14","017_10_14","NEH","10","14","14","ⵀⵓⴷⵉⵢⴰ, ⴱⴰⵏⵉ ⴷ ⴱⴰⵏⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("NH10_15","017_10_15","NEH","10","15","15","ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴳⴻⵏⵙ: ⴼⴰⵔⵄⵓⵛ, ⴼⴰⵃⴰⵜ-ⵎⵓ’ⴰⴱ, ⵄⵉⵍⴰⵎ, ⵣⴰⵜⵜⵓ, ⴱⴰⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("NH10_16","017_10_16","NEH","10","16","16","ⴱⵓⵏⵏⵉ, ⵄⴰⵣⵊⴰⴷ, ⴱⵉⴱⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NH10_17","017_10_17","NEH","10","17","17","ⴰⴷⵓⵏⵉⵢⴰ, ⴱⵉⵖⵡⴰⵢ, ⵄⴰⴷⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NH10_18","017_10_18","NEH","10","18","18","ⴰⵟⵉⵔ, ⵃⵉⵣⵇⵉⵢⴰ, ⵄⴰⵣⵣⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("NH10_19","017_10_19","NEH","10","19","19","ⵀⵓⴷⵉⵢⴰ, ⵃⴰⵛⵓⵎ, ⴱⵉⵚⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NH10_20","017_10_20","NEH","10","20","20","ⵃⴰⵔⵉⴼ, ⵄⴰⵏⴰⵜⵓⵜ, ⵏⵉⴱⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NH10_21","017_10_21","NEH","10","21","21","ⵎⴰⵊⴼⵉⵄⴰⵛ, ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵃⴰⵣⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("NH10_22","017_10_22","NEH","10","22","22","ⵎⴰⵛⵉⵣⴰⴱⵢⵉⵍ, ⵚⴰⴷⵓⵇ, ⵢⴰⴷⴷⵓⵄ, ");
INSERT INTO rift_vpl VALUES ("NH10_23","017_10_23","NEH","10","23","23","ⴼⴰⵍⴰⵟⵢⴰ, ⵃⴰⵏⴰⵏ, ⵄⴰⵏⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_24","017_10_24","NEH","10","24","24","ⵀⵓⵛⵉⵄⴰ, ⵃⴰⵏⴰⵏⵢⴰ, ⵃⴰⵛⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("NH10_25","017_10_25","NEH","10","25","25","ⵀⴰⵍⵍⵓⵃⵉⵛ, ⴼⵉⵍⵊⴰ, ⵛⵓⴱⵉⵇ, ");
INSERT INTO rift_vpl VALUES ("NH10_26","017_10_26","NEH","10","26","26","ⵔⴰⵃⵓⵎ, ⵃⴰⵛⴰⴱⵏⴰ, ⵎⴰⵄⴰⵙⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH10_27","017_10_27","NEH","10","27","27","ⴰⵅⵉⵢⴰ, ⵃⴰⵏⴰⵏ, ⵄⴰⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NH10_28","017_10_28","NEH","10","28","28","ⵎⴰⵍⵍⵓⵅ, ⵃⴰⵔⵉⵎ ⴷ ⴱⴰⵄⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("NH10_29","017_10_29","NEH","10","29","29","ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⵉⵎⴻⴷⵢⴰⵣⴻⵏ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⵉⵄⴻⵣⵣⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("NH10_30","017_10_30","NEH","10","30","30","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵚⵇⴻⵏ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵛⵛⴰⵔⵛⴻⵏ ⴷⵉ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵜⵊⴰⴵⵉⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵏⵏⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵅ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵎⴰⵀⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓⵛⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⴷ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH10_31","017_10_31","NEH","10","31","31","ⵄⴰⵡⴻⴷ ⵏⴻⴳⴳⴰ ⵅⴰⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵛ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ ⵉ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵡⵉ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("NH10_32","017_10_32","NEH","10","32","32","ⵓⵛⴰ ⵎⴰⵍⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵙⵉⵏ-ⴷⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵉⵡⵢⴻⵏ ⵚⵚⴻⵍⵄⴻⵜ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵎⴻⵏⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴻⵏⵣⴻⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷⵉ ⵙⵙⴻⴱⵜ ⵏⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵏⴻⵜⵜⵉⵡⵉ ⵡⴰⵍⵓ. ⵓⵛⴰ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵏⴻⴳⴳⴰ ⵅⴰⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵊⵊ ⵜⴰⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ ⵡⴰⵔ ⵏⴽⴻⵙⵙⵉ ⴰⵔⵔⵉⴱⴰ ⵣⴻⴳ ⵓⵍⴰ ⴷ ⵢⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH10_33","017_10_33","NEH","10","33","33","ⵏⴻⴳⴳⴰ ⵅⴰⵏⴻⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵡⵛ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵛⵉⵇⵍⵓ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("NH10_34","017_10_34","NEH","10","34","34","ⵉ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵓ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ, ⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⴷⴷⴻⵏⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⵜⵜⵡⴰⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NH10_35","017_10_35","NEH","10","35","35","ⵏⴻⵛⵛⵉⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵍⴳⴻⵏⵙ, ⴰⵎ ⵏᵉⵜⵜⵡⴰⵙⴻⵜⵜⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵖ, ⴳⴳⵉⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("NH10_36","017_10_36","NEH","10","36","36","ⵓⵛⴰ ⵏⴻⴳⴳⴰ ⵅⴰⵏⴻⵖ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴰⵡⵉ ⵜⴰⵎⴻⵏⵣⵓⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⴷ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵙⴻⴳⴳⵯⴰⵙ ⵅ ⵓⵎⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("NH10_37","017_10_37","NEH","10","37","37","ⵓⵍⴰ ⴷ ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⵓⵛⴰ ⴰⴷ ⵏⴰⵡⵉ ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴻⵖ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("NH10_38","017_10_38","NEH","10","38","38","ⵓⵛⴰ ⵏⴻⴳⴳⴰ ⵅⴰⵏⴻⵖ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵜⵜⴰⵡⵉ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵣⴻⴳ ⵡⴰⵔⴻⵛⵜⵉ ⵏⵏⴻⵖ ⵓ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏⵏⴻⵖ ⵓ ⵣⵉ ⴼⵔⵓⵜⴰ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵓ ⵣⵉ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ ⵖⴰⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⵍⴻⵅⵣⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓⵍⴰ ⴷ ⵍⴻⵄⵛⵓⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⵖⴰⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⵍⴻⵄⵛⵓⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵏⵅⴻⴷⴷⴻⵎ ⵏⴻⵛⵛⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("NH10_39","017_10_39","NEH","10","39","39","ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⴰⵔⵓⵏ, ⵖⴰⵔ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵅⵎⵉ ⵖⴰ ⵟⵟⴼⴻⵏⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵍⴻⵄⵛⵓⵔ. ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵍⴻⵄⵛⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵅⵓⴱⴰⵢ,    ");
INSERT INTO rift_vpl VALUES ("NH10_40","017_10_40","NEH","10","40","40","ⵎⵉⵏⵣⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ, ⵍⴰ ⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵓⵍⴰ ⵏ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⵍⴻⵅⵣⴻⵏ. ⵎⴰⵖⴰⵔ ⵍⴻⵇⵛⵓⵄ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉⵏ, ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏⵙⴻⵎⵎⴻⵃ ⵛⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NH11_1","017_11_1","NEH","11","1","1","ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴳⴻⵏⵙ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵎⵉ ⵍⴳⴻⵏⵙ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴳⴳⴰ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵎⴰⵃⴻⵏⴷ ⵉⵊⵊ ⵣⵉ ⵄⴻⵛⵔⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓ ⵜⴻⵙⵄⴰ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH11_2","017_11_2","NEH","11","2","2","ⵉⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH11_3","017_11_3","NEH","11","3","3","ⵉⵏⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⵄⴰⵎⴰⵍⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⴻⵎⵖⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_4","017_11_4","NEH","11","4","4","ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ: ⵄⴰⵜⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴼⴰⵔⵉⵚ, ");
INSERT INTO rift_vpl VALUES ("NH11_5","017_11_5","NEH","11","5","5","ⵓⵍⴰ ⴷ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⴽⵓⵍⵃⵓⵣⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵣⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴷⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵢⴰⵔⵉⴱ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵓⵛⵉⵍⵓⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH11_6","017_11_6","NEH","11","6","6","ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴼⴰⵔⵉⵚ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_7","017_11_7","NEH","11","7","7","ⵉⵏⴰ ⴷ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ: ⵙⴰⵍⵍⵓ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵄⵉⴷ, ⵎⵎⵉⵙ ⵏ ⴼⴰⴷⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵍⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵜⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵉⵛⴰⵄⵢⴰ ");
INSERT INTO rift_vpl VALUES ("NH11_8","017_11_8","NEH","11","8","8","ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵊⴰⴱⴱⴰⵢ, ⵙⴰⵍⵍⴰⵢ: ⵜⴻⵙⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_9","017_11_9","NEH","11","9","9","ⵜⵓⵖⴰ ⵢⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵣⵉⴽⵔⵉ, ⴷ ⴰⵡⴻⵇⵇⴰⴼ ⵅⴰⵙⴻⵏ ⵓ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵙⵏⵓⵡⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NH11_10","017_11_10","NEH","11","10","10","ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⵢⴰⴷⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵢⴰⵔⵉⴱ, ⵢⴰⴽⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("NH11_11","017_11_11","NEH","11","11","11","ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴷⵓⵇ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵔⴰⵢⵓⵜ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵟⵓⴱ, ⴰⵎⴻⵃⴹⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("NH11_12","017_11_12","NEH","11","12","12","ⵓⵛⴰ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵜⴻⵎⵏ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵅⴻⵏⵏⵉ ⵄⴰⴷⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⵓⵃⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵍⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵚⵉ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵛⵃⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⴽⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH11_13","017_11_13","NEH","11","13","13","ⴷ ⴰⵢⵜⵎⴰⵙ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴰⴵⴰⵜ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⵎⵛⵉⵙⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⴰⵔⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵣⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵍⵉⵎⵓⵜ, ⵎⵎⵉⵙ ⵏ ⵉⵎⵎⵉⵔ ");
INSERT INTO rift_vpl VALUES ("NH11_14","017_11_14","NEH","11","14","14","ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵎⵢⴰ ⵓ-ⵜⵎⴻⵏⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵜⵓⵖⴰ ⵣⴰⴱⴷⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵊⴷⵓⵍⵉⵎ, ⴷ ⴰⵡⴻⵇⵇⴰⴼ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_15","017_11_15","NEH","11","15","15","ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ: ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⵛⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⵔⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⴰⴱⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⵓⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH11_16","017_11_16","NEH","11","16","16","ⵛⴰⴱⴱⴰⵜⴰⵢ ⴷ ⵢⵓⵣⴰⴱⴰⴷ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⴱⴰⵔⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_17","017_11_17","NEH","11","17","17","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ, ⴰⵣⴻⴵⵉⴼ ⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵜⴰⵥⴰⴵⵉⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵇⴰⴷⵉ, ⴷ ⴱⴰⵇⴱⵓⵇⵢⴰ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ, ⵓ ⵄⴰⴱⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵎⵓⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵍⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴷⴰⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_18","017_11_18","NEH","11","18","18","ⵎⴰⵔⵔⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ: ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵜⵎⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_19","017_11_19","NEH","11","19","19","ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ: ⵄⴰⵇⵇⵓⴱ, ⵟⴰⵍⵎⵓⵏ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⵃⴻⵟⵟⵓ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⴱⵄⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_20","017_11_20","NEH","11","20","20","ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵢⵜ ⵉⵙⵔⴰⵉⵍ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH11_21","017_11_21","NEH","11","21","21","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵄⵓⴼⵉⵍ. ⵜⵓⵖⴰ ⵚⵉⵃⴰ ⴷ ⵊⵉⵛⴼⴰ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NH11_22","017_11_22","NEH","11","22","22","ⵜⵓⵖⴰ ⵄⵓⵣⵣⵉ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⵉ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵛⴰⴱⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰ ⴷ ⴰⵡⴻⵇⵇⴰⴼ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴰⵙⴰⴼ ⵜⵓⵖⴰ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("NH11_23","017_11_23","NEH","11","23","23","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵅⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵅ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵇⵇⴰⵏ, ⴽⵓⵍ ⴰⵙⵙ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("NH11_24","017_11_24","NEH","11","24","24","ⵜⵓⵖⴰ ⴼⴰⵟⴰⵃⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵛⵉⵣⴰⴱⵢⵉⵍ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵣⴰⵔⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵍⴻⵇⵇⴼⴻⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("NH11_25","017_11_25","NEH","11","25","25","ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⵖⴰⵔ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵛⴰ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵇⴰⵔⵢⴰⵜ-ⴰⵔⴻⴱⵄⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴷⵉ ⴷⵉⴱⴱⵓⵏ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⵓ ⴷⵉ ⵢⴰⵇⴰⴱⵚⵉⵢⵉⵍ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ");
INSERT INTO rift_vpl VALUES ("NH11_26","017_11_26","NEH","11","26","26","ⵓ ⴷⵉ ⵢⴻⵛⵓⵄⴰ ⵓ ⴷⵉ ⵎⵓⵍⴰⴷⴰ ⵓ ⴷⵉ ⴱⴰⵢⵜ-ⴼⴰⵍⴰⵟ ");
INSERT INTO rift_vpl VALUES ("NH11_27","017_11_27","NEH","11","27","27","ⵓ ⴷⵉ ⵀⴰⵚⴰⵔ-ⵛⵓⵄⴰⵍ ⵓ ⴷⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NH11_28","017_11_28","NEH","11","28","28","ⵓ ⴷⵉ ⵚⵉⵇⵍⴰⵖ ⵓ ⴷⵉ ⵎⴰⴽⵓⵏⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ");
INSERT INTO rift_vpl VALUES ("NH11_29","017_11_29","NEH","11","29","29","ⵓ ⴷⵉ ⵄⴰⵢⵏ-ⵔⵉⵎⵎⵓⵏ ⵓ ⴷⵉ ⵚⴰⵔⵄⴰ ⵓ ⴷⵉ ⵢⴰⵔⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("NH11_30","017_11_30","NEH","11","30","30","ⵣⴰⵏⵓⵃⴰ, ⴰⴷⵓⵍⵍⴰⵎ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵍⴰⵅⵉⵛ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵄⴰⵣⵉⵇⵇⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵣⵉ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ ⴰⵍ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵀⵉⵏⵏⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("NH11_31","017_11_31","NEH","11","31","31","ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵣⵉ ⵊⴰⴱⴰⵄ ⴷⵉ ⵎⵉⵅⵎⴰⵙ ⴷ ⵄⴰⵢⴰ ⴷ ⴱⴰⵢⵜ-ⵉⵍ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("NH11_32","017_11_32","NEH","11","32","32","ⵄⴰⵏⴰⵜⵓⵜ, ⵏⵓⴱ, ⵄⴰⵏⴰⵏⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH11_33","017_11_33","NEH","11","33","33","ⵀⴰⵚⵓⵔ, ⵔⴰⵎⴰ, ⵊⵉⵜⵜⴰⵢⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("NH11_34","017_11_34","NEH","11","34","34","ⵃⴰⴷⵉⴷ, ⵚⴰⴱⵓⵄⵉⵎ, ⵏⴰⴱⴰⵍⵍⴰⵟ, ");
INSERT INTO rift_vpl VALUES ("NH11_35","017_11_35","NEH","11","35","35","ⵍⵓⴷ ⴷ ⵓⵏⵓ ⴷ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵃⵔⴰⵢⴼⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH11_36","017_11_36","NEH","11","36","36","ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⴻⴷⵖⴻⵏ ⴷⵉⵏ ⵜⴻⵔⴱⵉⵃⵉⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NH12_1","017_12_1","NEH","12","1","1","ⵉⵏⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⴰⴽ-ⴷ ⵣⴰⵔⵓⴱⴰⴱⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⴷ ⵢⴰⵀⵓⵛⴰⵄ: ⵙⴰⵔⴰⵢⴰ, ⵉⵔⵎⵉⵢⴰ, ⵄⵉⵣⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_2","017_12_2","NEH","12","2","2","ⴰⵎⴰⵔⵢⴰ, ⵎⴰⵍⵍⵓⵅ, ⵃⴰⵟⵟⵓⵛ, ");
INSERT INTO rift_vpl VALUES ("NH12_3","017_12_3","NEH","12","3","3","ⵛⴰⴽⴰⵏⵢⴰ, ⵔⴰⵃⵓⵎ, ⵎⴰⵔⵉⵎⵓⵜ, ");
INSERT INTO rift_vpl VALUES ("NH12_4","017_12_4","NEH","12","4","4","ⵄⵉⴷⴷⵓ, ⵊⵉⵏⵏⵉⵜⵓⵢ, ⴰⴱⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_5","017_12_5","NEH","12","5","5","ⵎⵉⵢⴰⵎⵉⵏ, ⵎⴰⵄⴰⴷⵢⴰ, ⴱⵉⵍⵊⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_6","017_12_6","NEH","12","6","6","ⵛⴰⵎⵄⵉⵢⴰ, ⵢⵓⵢⴰⵔⵉⴱ, ⵢⴰⴷⴰⵄⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_7","017_12_7","NEH","12","7","7","ⵙⴰⵍⵍⵓ, ⵄⴰⵎⵓⵇ, ⵃⵉⵍⵇⵉⵢⴰ ⴷ ⵢⴰⴷⵄⴰⵢⴰ. ⵉⵏⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵀⵓⵛⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("NH12_8","017_12_8","NEH","12","8","8","ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵏⴰ: ⵢⴻⵛⵓⵄⴰ, ⴱⵉⵏⵏⵓⵢ, ⵇⴰⴷⵎⵉⵢⵉⵍ, ⵛⴰⵔⴰⴱⵢⴰ, ⵢⴰⵀⵓⴷⴰ ⴷ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵉⵣⵍⴰⵏ ⵏ ⵓⵇⴰⴷⵉ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("NH12_9","017_12_9","NEH","12","9","9","ⴱⴰⵇⴱⵓⵇⵢⴰ ⴷ ⵄⵓⵏⵏⵉ, ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵜⵓⵖⴰ ⵃⴻⵟⵟⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH12_10","017_12_10","NEH","12","10","10","ⵢⴻⵛⵓⵄⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵢⴰⵇⵉⵎ, ⵓ ⵢⵓⵢⴰⵇⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵍⵢⴰⵛⵉⴱ, ⵓ ⵉⵍⵢⴰⵛⵉⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵢⴰⴷⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("NH12_11","017_12_11","NEH","12","11","11","ⵓ ⵢⵓⵢⴰⴷⴰⵄ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵓ ⵢⵓⵏⴰⵜⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⴷⴷⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("NH12_12","017_12_12","NEH","12","12","12","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵢⴰⵇⵉⵎ ⵜⵓⵖⴰ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ-ⴰ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵙⴰⵔⴰⵢⴰ: ⵎⴰⵔⴰⵢⴰ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵉⵔⵎⵉⵢⴰ: ⵃⴰⵏⴰⵏⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_13","017_12_13","NEH","12","13","13","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵄⵉⵣⵔⴰ: ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⴰⵎⴰⵔⵢⴰ: ⵢⵓⵃⴰⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NH12_14","017_12_14","NEH","12","14","14","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵍⵉⴽⵓ: ⵢⵓⵏⴰⵜⴰⵏ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵛⴰⴱⵉⵏⵢⴰ: ⵢⵓⵙⵓⴼ, ");
INSERT INTO rift_vpl VALUES ("NH12_15","017_12_15","NEH","12","15","15","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵃⴰⵔⵉⵎ: ⵄⴰⴷⵏⴰ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵎⴰⵔⴰⵢⵓⵜ: ⵃⵉⵍⵇⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NH12_16","017_12_16","NEH","12","16","16","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵄⵉⴷⴷⵓ: ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵊⵉⵏⵏⵉⵜⵓⵏ: ⵎⴰⵛⵓⵍⵍⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("NH12_17","017_12_17","NEH","12","17","17","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⴰⴱⵉⵢⴰ: ⵣⵉⴽⵔⵉ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵎⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵎⵓⵄⴰⴷⵢⴰ: ⴼⵉⵍⵟⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("NH12_18","017_12_18","NEH","12","18","18","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⴱⵉⵍⵊⴰ: ⵛⴰⵎⵎⵓⵄⴰ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵛⴰⵎⵄⵉⵢⴰ: ⵢⵓⵏⴰⵜⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("NH12_19","017_12_19","NEH","12","19","19","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵢⵓⵢⴰⵔⵉⴱ: ⵎⴰⵜⵜⴰⵏⴰⵢ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵄⵓⵣⵣⵉ: ⵢⴰⴷⴰⵄⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_20","017_12_20","NEH","12","20","20","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵙⴰⵍⵍⴰⵢ: ⵇⴰⵍⵍⴰⵢ, ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵄⴰⵎⵓⵇ: ⵄⴰⴱⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("NH12_21","017_12_21","NEH","12","21","21","ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵃⵉⵍⵇⵉⵢⴰ: ⵃⴰⵛⴰⴱⵢⴰ ⵓ ⵉ ⵍⴰⴵⴰⵜ ⵏ ⵢⴰⴷⴰⵄⵢⴰ: ⵏⴰⵜⴰⵏⴰⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("NH12_22","017_12_22","NEH","12","22","22","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵍⵢⴰⵙⵉⴱ, ⵢⵓⵢⴰⴷⴰⵄ, ⵢⵓⵃⴰⵏⴰⵏ ⴷ ⵢⴰⴷⴷⵓⵄ, ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵍ ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⴰⴼⴰⵔⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("NH12_23","017_12_23","NEH","12","23","23","ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏ ⵍⴰⴵⴰⵜ, ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⴰⵍ ⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵢⴰⵛⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("NH12_24","017_12_24","NEH","12","24","24","ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵃⴰⵛⴰⴱⵢⴰ, ⵛⴰⵔⴰⴱⵢⴰ ⴷ ⵢⴻⵛⵓⵄⴰ, ⵎⵎⵉⵙ ⵏ ⵇⴰⴷⵎⵉⵢⵉⵍ, ⵓ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⵊⴻⵎⵎⴰⴹⵉⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵓ ⴰⴷ ⵇⴰⴷⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵉⵊⵊ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH12_25","017_12_25","NEH","12","25","25","ⵜⵓⵖⴰ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⴱⴰⵇⴱⵓⵇⵢⴰ, ⵄⵓⴱⴰⴷⵢⴰ, ⵎⴰⵛⵓⵍⵍⴰⵎ, ⵟⴰⵍⵎⵓⵎ ⴷ ⵄⴰⵇⵇⵓⴱ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉⵏⵏⵉ ⵉⵄⴻⵙⵙⴻⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NH12_26","017_12_26","NEH","12","26","26","ⵉⵏⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵛⴰⵄ ⵎⵎⵉⵙ ⵏ ⵢⵓⵚⴰⴷⴰⵇ, ⵓⵍⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⴰⵃⴰⵎⵢⴰ, ⵍⵡⴰⵍⵉ, ⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴻⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH12_27","017_12_27","NEH","12","27","27","ⵖⴰⵔ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵍⵃⵉⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵔⵣⵓⵏ ⵏⵉⵜⵏⵉ ⵅ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵏ ⴰⴷⴻⵛⵛⴻⵏ, ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵙ ⵓⵇⴰⴷⵉ ⵓ ⵙ ⵢⴻⵣⵍⴰⵏ, ⵙ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵙ ⵍⵀⴰⵔⴱⴰⵜ ⴷ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("NH12_28","017_12_28","NEH","12","28","28","ⵏⵉⵜⵏⵉ ⵙⵙⵎⵓⵏⴻⵏ ⵅ ⴰⵢⵜ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵓⴷⴻⵡⵡⴰⵔ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵣⵉ ⴷⵛⵓⵔⴰⵜ ⵏ ⵓⵏⴰⵟⵓⴼⴰⵜⵉ, ");
INSERT INTO rift_vpl VALUES ("NH12_29","017_12_29","NEH","12","29","29","ⵓ ⵣⵉ ⴱⴰⵢⵜ-ⵊⵉⵍⵊⴰⵍ ⵓⵍⴰ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵊⵉⴱⴰ ⴷ ⵄⴰⵣⵎⴰⵡⴻⵜ, ⵎⵉⵏⵣⵉ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴱⵏⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵛⵓⵔⴰⵜ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH12_30","017_12_30","NEH","12","30","30","ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⴰ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⴷ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("NH12_31","017_12_31","NEH","12","31","31","ⵅⴻⵏⵏⵉ ⴳⴳⵉⵖ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵏⵢⴻⵏ ⵅ ⵍⵃⵉⴹ ⵓ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵔⴱⵉⵄⵉⵏ ⵏ ⵓⵖⴻⵏⵏⴻⵊ ⵉ ⵓⵇⴰⴷⵉ. ⵜⵓⵢⵓⵔ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵙⴻⵏⵏⴻⵊ ⵅ ⵍⵃⵉⴹ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NH12_32","017_12_32","NEH","12","32","32","ⵢⴰⵔⴻⴷⴷⴻⴼ ⵉ-ⵜⵜ ⵀⵓⵛⴰⵄⵢⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_33","017_12_33","NEH","12","33","33","ⵄⴰⵣⴰⵔⵢⴰ, ⵄⵉⵣⵔⴰ, ⵎⴰⵛⵓⵍⵍⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("NH12_34","017_12_34","NEH","12","34","34","ⵢⴰⵀⵓⴷⴰ, ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⵉⵔⵎⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH12_35","017_12_35","NEH","12","35","35","ⵓ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴱⵡⴰⵇ: ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵄⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵅⴰ-ⵢⴰⵀ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴽⵓⵔ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ, ");
INSERT INTO rift_vpl VALUES ("NH12_36","017_12_36","NEH","12","36","36","ⴷ ⴰⵢⵜⵎⴰⵙ ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⵄⴰⵣⴰⵔⵢⵉⵍ, ⵎⵉⵍⴰⵍⴰⵢ, ⵊⵉⵍⴰⵍⴰⵢ, ⵎⴰⵄⴰⵢ, ⵏⴰⵜⴰⵏⴰⵢⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵃⴰⵏⴰⵏⵉ ⴰⴽ-ⴷⴷⵓⵣⴰⵏ ⵏ ⵍⵎⵓⵙⵉⵇⴰ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⵄⵉⵣⵔⴰ, ⴰⵎⵙⴻⵍⵎⴻⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH12_37","017_12_37","NEH","12","37","37","ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⵍⴰ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⵉⵛⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ ⵏⵢⴻⵏ ⴷⴷⵔⵓⵊⵊⴰⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵎⴰⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵍⵃⵉⴹ, ⵜⵜⴻⴽⴽⴻⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵎⴰⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("NH12_38","017_12_38","NEH","12","38","38","ⵜⴰⵔⴱⵉⵃⵜ ⵏ ⵓⵇⴰⴷⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏⵏⴻⵖⵏⵉⵜ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⵔⴻⴷⴷⴼⴻⵖ ⵜⵜ ⴰⴽ-ⴷ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵍⴳⴻⵏⵙ, ⵏⴻⴽⴽⴰ ⵅ ⵍⵃⵉⴹ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴱⵓⵔⵊ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⴰⵍ ⵍⵃⵉⴹ ⴰⵎⵉⵔⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("NH12_39","017_12_39","NEH","12","39","39","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⴻⴽⴽⴰ ⵅ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵅ ⵜⴻⵡⵡⴰⵔⵜ ⵜⴰⵇⴷⵉⵎⵜ ⵓ ⵅ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴷ ⵍⴱⵓⵔⵊ ⵏ ⵃⴰⵏⴰⵏⵉⵢⵉⵍ ⴷ ⵍⴱⵓⵔⵊ ⵏ ⵎⵢⴰ ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH12_40","017_12_40","NEH","12","40","40","ⵅⴻⵏⵏⵉ ⴱⴻⴷⴷⴻⵏⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵔⴱⵉⵃⵉⵏ ⵏ ⵓⵇⴰⴷⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴽ-ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("NH12_41","017_12_41","NEH","12","41","41","ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵉⵏⵢⴰⵎⵉⵏ, ⵎⵉⵅⴰ-ⵢⴰⵀ, ⵉⵍⵢⵓⵄⵉⵏⴰⵢ, ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵃⴰⵏⴰⵏⵢⴰ, ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴱⵡⴰⵇ, ");
INSERT INTO rift_vpl VALUES ("NH12_42","017_12_42","NEH","12","42","42","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵎⴰⵄⴰⵙⵉⵢⴰ ⴷ ⵛⴰⵎⵄⵉⵢⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ ⴷ ⵄⵓⵣⵣⵉ ⴷ ⵢⵓⵃⴰⵏⴰⵏ ⴷ ⵎⴰⵍⴽⵉⵢⴰ ⴷ ⵄⵉⵍⴰⵎ ⴷ ⵄⴰⵣⴰⵔ. ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴳⴳⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵍⴻⵏ ⵓ ⵜⵓⵖⴰ ⵢⵉⵣⵔⴰⵃⴰ ⴷ ⴰⵡⴻⵇⵇⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("NH12_43","017_12_43","NEH","12","43","43","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵖⴰⵔⵚⴰ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ⵎⴰⵔⵔⴰ ⴼⴰⵔⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴼⴰⵔⵃⴻⵏ ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⵍⴰⵎⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵍⵄⵉⴷ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵓⵖⴰ ⵜⵜⴻⵙⵍⴰⵏ ⴰⵙ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("NH12_44","017_12_44","NEH","12","44","44","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴳⴳⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⵉⴵⴰⵏ ⵉ ⵜⵅⵓⴱⴰⵢ, ⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵉ ⵓⵙⵓⴼⴼⵓⵖ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵓ ⵉ ⵍⴻⵄⵛⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵢⴰⵔⵡⴻⵏ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵖⴰⵔ ⴼⴰⵔⵃⴻⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ");
INSERT INTO rift_vpl VALUES ("NH12_45","017_12_45","NEH","12","45","45","ⵓ ⵃⴹⴰⵏ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵓ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵙⵉⵣⴷⴻⴳ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵎⵎⵉⵙ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH12_46","017_12_46","NEH","12","46","46","ⵎⴰⵖⴰⵔ ⵣⵉⵛ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⴷⴰⴼ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵉ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵓⵍⴰ ⵉ ⵓⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("NH12_47","017_12_47","NEH","12","47","47","ⵙ ⵓⵢⴰ ⵉⵡⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⴰⵃⴰⵎⵢⴰ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵏ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⴽⵓⵍ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵜⵜ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵜⵜ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_1","017_13_1","NEH","13","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵖⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵎⵓⵙⴰ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴼ ⴰⵇⴰ ⵜⵓⵔⴰ ⴷⴰⵢⴻⵙ ⴱⴻⵍⵍⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵎⵎⵓⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓ’ⴰⴱⵉⵢ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("NH13_2","017_13_2","NEH","13","2","2","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⴼⵉⵖⴻⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵡⴻⵖⵔⵓⵎ ⴷ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵛⵔⴰⵏ ⴱⵉⵍⵄⴰⵎ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵏⵄⴻⵍ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵍⴱⴰⵔⴰⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("NH13_3","017_13_3","NEH","13","3","3","ⵓⵎⵉ ⵙⵍⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ-ⴰⵢⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴱⴹⴰⵏ ⵅ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵅⴻⴵⴹⴻⵏ ⵣⵉ ⵜⴰⵚⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("NH13_4","017_13_4","NEH","13","4","4","ⵇⴱⴻⵍ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵍⵢⴰⵛⵉⴱ, ⴰⴽⴻⵀⵀⴰⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⵍⴻⵅⵣⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵉⵜⵜⴻⵄⵏⴰⵏ ⵉ ⵟⵓⴱⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("NH13_5","017_13_5","NEH","13","5","5","ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵜⵓⴱⵉⵢⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵅⴻⵎⵎⵍⴻⵏ ⵇⴱⴻⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵊⵊⴰⵡⵉ ⴷ ⵍⴻⵇⵛⵓⵄ, ⵍⴻⵄⵛⵓⵔ ⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ, ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵓ ⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⵓⵍⴰ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_6","017_13_6","NEH","13","6","6","ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵓⵖⵉ ⵛⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⴰⵔⵜⴰⵃⵛⴰⵙⵜⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵜⵓⵖⴰ ⵄⴻⵇⴱⴻⵖ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ⴰⵡⴰⵔⵏⵉ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵡⵓⵙⵙⴰⵏ ⵜⵜⴰⵔⴻⵖ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("NH13_7","017_13_7","NEH","13","7","7","ⵓⵎⵉ ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⴱⴰⵏ-ⴷⴷ ⴰⵢⵉ ⵍⵖⴰⵔ ⵏⵏⵉ ⵉⴳⴳⴰ ⵉⵍⵢⴰⵛⵉⴱ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵟⵓⴱⵉⵢⴰ ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("NH13_8","017_13_8","NEH","13","8","8","ⵜⵓⵖⴰ ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵟⵓⴱⵉⵢⴰ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NH13_9","017_13_9","NEH","13","9","9","ⵏⵏⵉⵖ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵉⵅⵅⴰⵎⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⵔⵔⵉⵖ ⴷⴰⵢⵙⴻⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵊⵊⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("NH13_10","017_13_10","NEH","13","10","10","ⵜⵜⵡⴰⵙⵙⴰⵔⴳⴱⴻⵖ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵎⵎⴻⵡⵛⴻⵏⵜ ⴰⵍⴰⵎⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⴷⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⴰⵔⴻⵡⵍⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH13_11","017_13_11","NEH","13","11","11","ⵎⵎⵛⵓⴱⴱⵛⴻⵖ ⴰⴽ-ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ, ⵏⵏⵉⵖ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵡⴰⵙⵎⴻⵃ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ?” ⵓ ⵏⴻⵛⵛ ⵙⵙⵎⵓⵏⴻⵖ ⵜⴻⵏ ⵓⵛⴰ ⴰⵔⵔⴻⵖ ⵜⴻⵏ-ⵉ-ⴷⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_12","017_13_12","NEH","13","12","12","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⵍⴻⵄⵛⵓⵔ ⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ ⵍⴰ ⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵓⵍⴰ ⵏ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("NH13_13","017_13_13","NEH","13","13","13","ⴳⴳⵉⵖ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ: ⴰⴽⴻⵀⵀⴰⵏ ⵛⴰⵍⴰⵎⵢⴰ ⴷ ⵓⵎⴰⵔⵉⵔ ⵚⴰⴷⵓⵇ ⴷ ⴼⴰⴷⴰⵢⴰ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵖ ⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴽⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵏⵢⴰ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ. ⵏⵉⵜⵏⵉ ⵅⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴹⴰⵏ ⴰⵢⴰ ⵉ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_14","017_13_14","NEH","13","14","14","ⵉⴷⴰⵔ ⴰⵢⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓ ⵡⴰⵔ ⵜⵎⴻⵃⵃⵉⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏⵏⵉ ⵙⵙⴻⵛⵏⴻⵖ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵓ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_15","017_13_15","NEH","13","15","15","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵥⵔⵉⵖ ⴰⵇⴰ ⴷⵉⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵛⵓⵇⴰⵏ ⴷⵉ ⵜⵙⵉⵔⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵉⵛⵓⵡⵡⴰⴼⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ, ⴰⵔⴱⵓⵏ ⵜⴻⵏ ⵅ ⵢⴻⵖⵢⴰⵍ, ⵓⵍⴰ ⴷ ⴱⵉⵏⵓ, ⴰⴹⵉⵍ, ⵜⴰⵣⴰⵔⵜ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵃⵎⵓⵍ ⵏⵏⵉ ⵉⵡⵢⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵛⵛ ⵄⴻⵍⵎⴻⵖ ⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵣⵣⵏⵓⵣⴰⵏ ⵎⴰⵛⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("NH13_16","017_13_16","NEH","13","16","16","ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⵚⵓⵔ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵙⴻⵍⵎⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵙⵙⴻⵍⵄⴻⵜ, ⵣⵣⵏⵓⵣⴰⵏ ⴰⵢⴰ ⴷⵉ ⵙⵙⴻⴱⵜ ⵉ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH13_17","017_13_17","NEH","13","17","17","ⵄⴻⵢⵢⴰⵔⴻⵖ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⵎⴰⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵉ ⵣⵉ ⵜⴻⵙⵙⵄⵉⴵⵜⴻⵎ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ! ");
INSERT INTO rift_vpl VALUES ("NH13_18","017_13_18","NEH","13","18","18","ⵎⴰ ⵡⴰⵔ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⵎⴻⵏⵏⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵙⵙⵉⵡⴻⴹ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ-ⴰ ⵅⴰⵏⴻⵖ ⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ? ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴻⵏⵏⵉⵎ ⵄⴰⴷ ⴷⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵜⴻⵙⵙⵄⵉⴵⵜⴻⵎ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("NH13_19","017_13_19","NEH","13","19","19","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⵡⴹⴰ ⵜⴰⴵⴻⵙⵜ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⴻⴹ ⵙⵙⴻⴱⵜ, ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⴷ ⵜⵜⵡⴰⴱⴻⵍⵍⵄⴻⵏⵜ ⵜⴻⵡⵡⵓⵔⴰ ⵓⵛⴰ ⴰⵔⵏⵉⵖ ⵏⵏⵉⵖ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⵣⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵙⴻⴱⵜ ⵡⴰⵀⴰ. ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵙⵙⵉⴷⵉⴼⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵃⵎⴻⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("NH13_20","017_13_20","NEH","13","20","20","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉⵙⵙⴻⵏⵙⴻⵏ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⴷ ⵉⵎⵣⴻⵏⵣⴰⵏ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵙⵙⴻⵍⵄⴻⵜ ⵄⴰⴷ ⵉⵛⵜ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴱⴰⵔⵔⴰ ⵣⵣⴰⵜ ⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("NH13_21","017_13_21","NEH","13","21","21","ⵓⵛⴰ ⵛⴻⵀⴷⴻⵖ ⵅⴰⵙⴻⵏ, ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵏⵓⵙⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵃⵉⴹ? ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵜ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵡⵜⴻⵖ ⴰⴼⵓⵙ.” ⵙⵙⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⵄⴰⴷ ⴷⵉ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("NH13_22","017_13_22","NEH","13","22","22","ⵏⵏⵉⵖ ⵄⴰⵡⴻⴷ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⴰⴷ ⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⴻⴷⴷⵙⴻⵏ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ⵓⵍⴰ ⵉ ⵓⵢⴰ ⵉⴷⴰⵔ ⴰⵢⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓ ⵃⵉⵏⵏ ⵅⴰⴼⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_23","017_13_23","NEH","13","23","23","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵥⵔⵉⵖ ⵄⴰⵡⴻⴷ ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⴰⵛⴷⵓⴷ ⴷ ⵄⴰⵎⵎⵓⵏ ⴷ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⵙⵙⴻⵣⴷⵖⴻⵏ ⵜⴻⵏⵜ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_24","017_13_24","NEH","13","24","24","ⴰⵣⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵍⴻⵙ ⵏ ⴰⵛⴷⵓⴷ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵉⵍⴻⵙ ⵏ ⵜⵢⴰⵀⵓⴷⴻⵛⵜ, ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵍⴻⵙ ⵏ ⴽⵓⵍ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("NH13_25","017_13_25","NEH","13","25","25","ⵄⴻⵢⵢⴰⵔⴻⵖ ⵜⴻⵏ ⵓ ⵏⴻⵄⵍⴻⵖ ⵜⴻⵏ ⵓ ⵡⵜⵉⵖ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵇⴻⵍⵄⴻⵖ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵙⴻⵏ ⵓ ⵊⵊⵉⵖ ⵜⴻⵏ ⴰⴷ ⵊⵊⴰⴵⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ: “ⵖⴰⵔⵡⴻⵎ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵖⴰⵔⵡⴻⵎ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵏⵉⵖ ⵉ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("NH13_26","017_13_26","NEH","13","26","26","ⵎⴰ ⵡⴰⵔ ⵉⵅⴹⵉ ⵙⵓⵍⵉⵎⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ? ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵎ ⵏⴻⵜⵜⴰ ⵊⴰⵔ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ? ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵖⴰⵔⵔⴻⵏⵜ ⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⴹⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("NH13_27","017_13_27","NEH","13","27","27","ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵏⵙⴻⵍ ⵄⴰⴷ ⴽⵜⴰⵔ ⵓⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵜⵖⴻⴷⴷⴰⵔⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵉⵡⵢⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵣⴻⴷⴷⵖⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("NH13_28","017_13_28","NEH","13","28","28","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵢⴰⴷⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵢⴰⵛⵉⴱ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵙⴰⵏⴱⴰⵍⵍⴰⵟ ⵣⵉ ⵃⵓⵔⵓⵏ. ⵙ ⵓⵢⴰ ⵓⵥⵥⵍⴻⵖ ⵅⴰⵙ ⵣⵉ ⵖⴰⵔⵉ ");
INSERT INTO rift_vpl VALUES ("NH13_29","017_13_29","NEH","13","29","29","ⵉⴷⴰⵔ ⴰⵙⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵅⴻⵎⵊⴻⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴷ ⵍⵄⴰⵀⴷ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵓ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NH13_30","017_13_30","NEH","13","30","30","ⵓ ⵏⴻⵛⵛ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵜⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷ ⵍⵖⵉⴱ, ⵓⵛⴰ ⴰⵔⴻⵛⵛⵃⴻⵖ ⴰⵃⴻⵟⵟⵓ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NH13_31","017_13_31","NEH","13","31","31","ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵖ ⵓⵍⴰ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵓ ⵉ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵚⵚⴰⴱⴻⵜ. ⵉⴷⴰⵔ ⴰⵢⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵉ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ET1_1","018_1_1","EST","1","1","1","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ - ⵏⴻⵜⵜⴰ ⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵀⴻⵏⴷ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ ⵅ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ - ");
INSERT INTO rift_vpl VALUES ("ET1_2","018_1_2","EST","1","2","2","ⵡⴰⵀ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵓⵎⵉ ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⵏ ⵛⵓⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("ET1_3","018_1_3","EST","1","3","3","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵃⴽⴰⵎ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴼⵓⵔⵙ ⴷ ⵎⴰⴷⴰⵢ ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵜⵜⵎⵓⵏⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("ET1_4","018_1_4","EST","1","4","4","ⵓⵎⵉ ⵉⵙⵙⵛⴻⵏ ⴰⴳⵍⴰ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴷ ⵛⵛⴰⵏ ⴷ ⵍⴻⵎⵍⴰⵃⴻⵜ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵇⴰ ⴷⵉ ⵎⵢⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET1_5","018_1_5","EST","1","5","5","ⵓⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵡⵊⴰⴷ ⵓⵊⴻⴵⵉⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ, ⵣⴻⴳ ⵓⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⴰⵎⴻⵥⵢⴰⵏ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵡⴻⵃⵡⵉⵛ ⵏ ⵍⴻⵇⵚⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET1_6","018_1_6","EST","1","6","6","ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⵡⴰⵇⴰⵜ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⴷ ⵉⵣⵉⵣⴰⵡⴻⵏ ⴷ ⵉⴷⴻⵀⵎⴰⵏⴻⵏ ⵎⵎⵓⴷⴻⵏ ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵓⴼⵉⵍⵓ ⴰⵔⵊⵓⵡⴰⵏⵉ ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⵖⴰⵔ ⵉⵇⴻⴹⴱⴰⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵖⴰⵔ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵍⵎⴰⵔⵎⵓⵔ. ⵍⴻⵎⵟⴰⵔⴱⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵎⵎⴰⵔⵙⴻⵏⵜ ⵅ ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵓ ⴰⵣⵉⵣⴰ ⴰⵎ ⵙⵎⴰⵔⴰⵅⵜ ⴷ ⵡⴻⵥⵔⵓ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴷ ⵡⴻⵥⵔⵓ ⴰⵎ ⵜⵢⴰⵇⵓⵜ ⴷ ⵡⴻⵥⵔⵓ ⴷ ⴰⴱⴰⵔⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET1_7","018_1_7","EST","1","7","7","ⵜⴻⵎⵎⴻⵡⵛ ⵜⵙⴻⵙⵙⵉ ⴷⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵎⵎⵙⴻⴱⴹⴰⵏ, ⵜⴰ ⵡⴰⵔ ⵜⴰⵔⵡⵉⵙ ⵜⴰ, ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⴱⵉⵏⵓ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ, ⴰⵏⴻⵛⵜ ⵉ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜ ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("ET1_8","018_1_8","EST","1","8","8","ⵜⵓⵖⴰ ⵙⵡⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵖⵉⵍ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵡⴻⵚⵚⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⵅⴰⴹⴰⵔ ⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("ET1_9","018_1_9","EST","1","9","9","ⵜⴻⴳⴳⴰ ⵜⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("ET1_10","018_1_10","EST","1","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵡⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⴼⴰⵔⵃ ⵙ ⴱⵉⵏⵓ, ⵉⵏⵏⴰ ⵉ ⵎⴰⵀⵓⵎⴰⵏ, ⴱⵉⵣⵜⴰ, ⵃⴰⵔⴱⵓⵏⴰ, ⴱⵉⵖⵜⴰ ⴷ ⴰⴱⴰⵖⵜⴰ, ⵣⵉⵜⴰⵔ ⴷ ⴽⴰⵔⴽⴰⵙ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ");
INSERT INTO rift_vpl VALUES ("ET1_11","018_1_11","EST","1","11","11","ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙ ⵜⵜⴰⵊ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴰⵥⵔⵉ ⵏⵏⴻⵙ ⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⵉ ⵍⵃⵓⴽⴽⴰⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("ET1_12","018_1_12","EST","1","12","12","ⵎⴰⵛⴰ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵜⵓⴳⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ. ⵉⴼⴼⵓⴳⴻⵎ ⵓⵊⴻⴵⵉⴷ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⴷⴰⵢⴻⵙ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET1_13","018_1_13","EST","1","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵉⵏⵏⵉ ⵉⴼⴻⵀⵀⵎⴻⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ - ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵣⴻⵔⴼ ⵓ ⵍⴻⵃⴽⴰⵎ - ");
INSERT INTO rift_vpl VALUES ("ET1_14","018_1_14","EST","1","14","14","ⵉ ⴽⴰⵔⵛⴰⵏⴰ, ⵛⵉⵜⴰⵔ, ⴰⴷⵎⴰⵜⴰ, ⵜⴰⵔⵛⵉⵛ, ⵎⴰⵔⴰⵙ, ⵎⴰⵔⵙⴰⵏⴰ ⴷ ⵎⴰⵎⵓⴽⴰⵏ, ⵙⴻⴱⵄⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴼⵓⵔⵙ ⴷ ⵎⴰⴷⴰⵢ, ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⴽⵙⵉⵏ ⵉⵎⵓⵛⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ: ");
INSERT INTO rift_vpl VALUES ("ET1_15","018_1_15","EST","1","15","15","“ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴻⴳⴳ ⴰⴽ-ⴷ ⵜⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴰⵏⵓⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("ET1_16","018_1_16","EST","1","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⴰⵎⵓⴽⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ: “ⵜⴰⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⵛⴰ ⵍⵄⵉⴱ ⴷⴻⴳ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("ET1_17","018_1_17","EST","1","17","17","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵜⴻⴳⴳⴰ ⵜⵊⴻⴵⵉⴷⵜ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵅⵎⵉ ⵇⵇⴰⵔⴻⵏⵜ: ‘ⴰⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵉⵏⵏⴰ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔ ⵜⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵛⴰ.’ ");
INSERT INTO rift_vpl VALUES ("ET1_18","018_1_18","EST","1","18","18","ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴼⵓⵔⵙ ⴷ ⵎⴰⴷⴰⵢ, ⵜⵉⵏⵏⵉ ⵉⵙⵍⴰⵏ ⵉ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵏ ⵜⵊⴻⴵⵉⴷⵜ, ⴰⴷ ⵉⵏⵉⵏⵜ ⴰⵢⴰ ⴰⵙⵙ-ⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴷⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⵓⵙⴻⵃⵇⴰⵔ ⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ET1_19","018_1_19","EST","1","19","19","ⵎⴰⵍⴰ ⵉⵄⵊⴻⴱ ⴰⵙ ⵍⵃⴰⵍ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴻⵊⵊ ⵉ-ⵜ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵍⵓⵎⵓⵔ, ⴰⴷ ⵜ ⵉⵣⴻⵎⵎⴻⵎ ⴷⵉ ⵍⵇⴰⵡⴰⵏⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ ⴷ ⵎⴰⴷⴰⵢ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜ ⵜⵜⵄⴻⴷⴷⴰⵏ, ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵡⴰⵛⵜⵉ ⵄⴰⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵓⵛⴰ ⴻⵊⵊ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵡⵛ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵉ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵜⵉⵍⵉ ⵃⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET1_20","018_1_20","EST","1","20","20","ⵅⵎⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵡⴻⵇⵇⴰⵔⴻⵏⵜ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ, ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("ET1_21","018_1_21","EST","1","21","21","ⵜⵓⵖⴰ ⴰⵡⴰⵍ-ⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵎⴰⵎⵓⴽⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET1_22","018_1_22","EST","1","22","22","ⵉⵙⵙⴻⴽⴽ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ - ⵉ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⵙ ⵜⵉⵔⴰ ⵏⵏⴻⵙ ⵓ ⵉ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ - ⵃⵉⵎⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET2_1","018_2_1","EST","2","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵎⵉ ⵢⴰⵔⵙⴰ ⵡⴻⵙⵄⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⴷⵡⴻⵍ ⵉⵜⵜⵅⴻⵎⵎⴰⵎ ⴷⴻⴳ ⵡⴰⵛⵜⵉ ⴷ ⵎⵉⵏ ⵜⴻⴳⴳⴰ ⵓ ⴷⵉ ⵎⵉⵏ ⵅⴰⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵍⴻⵃⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("ET2_2","018_2_2","EST","2","2","2","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵃⵓⴹⵔⵉⵢⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ: “ⴻⵊⵊ ⴰⴷ ⴰⵔⵣⵓⵏ ⵜⵉⴱⵍⵉⵖⵉⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵜⵉⵄⴻⵣⵔⵉⵢⵢⵉⵏ ⵉ ⴷⵉ ⵉⴵⴰ ⵡⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("ET2_3","018_2_3","EST","2","3","3","ⴻⵊⵊ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⴳⴳ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⴱⵍⵉⵖⵉⵏ ⵜⵉⵄⴻⵣⵍⵉⵢⵉⵏ ⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⴻⵥⵔⵉ, ⵖⴰⵔ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵙⴰⴷⵓ ⵉ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⵀⵉⵊⴰⵢ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵏ ⵓⵊⴻⴵⵉⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵄⴻⵙⵙⴰⵙ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓ ⴰⴷ ⴰⵙⴻⵏⵜ ⵡⵛⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵓⵜⵀⴻⵍⵍⵉ ⵏ ⵡⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("ET2_4","018_2_4","EST","2","4","4","ⵜⴰⴱⵍⵉⵖⵜ ⵉ ⵖⴰ ⵉⵄⴻⵊⴱⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵊⴻⴵⵉⴷⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴰⵛⵜⵉ.” ⵜⵓⵖⴰ ⴰⵡⴰⵍ-ⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("ET2_5","018_2_5","EST","2","5","5","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵎⵎⵉⵙ ⵏ ⵢⴰ’ⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⴽⵉⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ET2_6","018_2_6","EST","2","6","6","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⴰⴽ-ⴷ ⵢⴰⴽⵓⵏⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵏⴷⴻⵀ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⵉ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("ET2_7","018_2_7","EST","2","7","7","ⴷ ⵏⴻⵜⵜⴰ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵢⵎⴻⵏ ⵀⴰⴷⴰⵙⵙⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵙⵜⵉⵔ, ⵢⴻⴵⵉⵙ ⵏ ⵄⴻⵎⵎⵉⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵄⴰⴷ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ ⵉⵛⵓⵡⵡⴰⵔ ⵓ ⴷⴰⵢⴻⵙ ⴰⵥⵔⵉ. ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⵉⴽⵙⵉ ⵜⵜ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷ ⵢⴻⴵⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("ET2_8","018_2_8","EST","2","8","8","ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵡⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵇⴰⵏⵓⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⴱⵍⵉⵖⵉⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ ⵙⴰⴷⵓ ⵉ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⵀⵉⵊⴰⵢ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵙⵙⴻⵄⴷⵓⵏ ⵉⵙⵜⵉⵔ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⴷⵡⴻⵍ ⵙⴰⴷⵓ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⵀⵉⵊⴰⵢ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ET2_9","018_2_9","EST","2","9","9","ⵜⴻⵄⵊⴻⴱ ⴰⵙ ⵜⴰⴱⵍⵉⵖⵜ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵇⴻⴵⴻⵇ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵓⵜⵀⴻⵍⵍⵉ ⵏ ⵡⴻⵥⵔⵉ ⴷ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵓⵍⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵉⵜⵜⵡⴰⵅⴹⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ET2_10","018_2_10","EST","2","10","10","ⵉⵙⵜⵉⵔ ⵡⴰⵔ ⵜⵅⴻⴱⴱⴰⵔ ⵛⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵏⵉⵖ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉⵡⴻⵚⵚⴰ ⵜⵜ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜ ⵜⴻⵇⵇⴰⵔ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("ET2_11","018_2_11","EST","2","11","11","ⵜⵓⵖⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉⴳⴳⵓⵔ ⴽⵓⵍ ⴰⵙⵙ ⵣⵣⴰⵜ ⵉ ⵍⴻⵎⵍⴰⵀ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵉⵙⵜⵉⵔ ⴷ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET2_12","018_2_12","EST","2","12","12","ⵜⴰⴱⵍⵉⵖⵜ ⴰⵡⴰⵔⵏⵉ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵜⴰⵙ ⴰⵙ-ⴷⴷ ⵏⵏⵓⴱⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⴰⵡⴰⵔⵏⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵓⵢⵓⵔⴻⵏ ⵏ ⵓⵣⴻⵢⵢⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵜⵀⴻⵍⵍⵉ ⵏ ⵡⴻⵥⵔⵉ: ⵙⴻⵜⵜⴰ ⵏ ⵓⵢⵓⵔⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵎⵉⵔⵔⵓ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵙ ⵍⴻⵄⵟⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⴼⵓⵎⴰⴷⴰⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ET2_13","018_2_13","EST","2","13","13","ⴰⵎⵎⵓ ⴷⴷ-ⵜⵓⵙⴰ ⴽⵓⵍ ⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵔ, ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET2_14","018_2_14","EST","2","14","14","ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵜⵓⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵙⴰⴷⵓ ⵓⵃⴻⵟⵟⵓ ⵏ ⵛⴰⵄⴰⵛⵖⴰⵣ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⵉⵢⵢⴰ. ⵡⴰⵔ ⴷⴷ-ⵜⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⴻⵄⵊⴻⴱ ⴰⵙ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET2_15","018_2_15","EST","2","15","15","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵏⵏⵓⴱⴻⵜ ⵏ ⵉⵙⵜⵉⵔ, ⵢⴻⴵⵉⵙ ⵏ ⴰⴱⵉⵃⴰⵢⵉⵍ, ⵄⴻⵎⵎⵉⵙ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵡⴻⵏⵏⵉ ⵜⵜ ⵢⴰⵔⵔⵉⵏ ⴷ ⵢⴻⴵⵉⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵎⵉⵏ ⵉⵏⵏⴰ ⵀⵉⵊⴰⵢ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵓ ⵉⵙⵜⵉⵔ ⵜⵓⵙⴰ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⵜ ⵉⵥⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ET2_16","018_2_16","EST","2","16","16","ⴰⵎⵎⵓ ⵉ ⵉⵡⵢⴻⵏ ⵉⵙⵜⵉⵔ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵓⵢⵓⵔ ⵏ ⵟⵉⴱⵉⵜ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET2_17","018_2_17","EST","2","17","17","ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉⵙⵜⵉⵔ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⴼⴰ ⴰⵔⴹⴰ ⴷ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴽⵜⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵄⵣⵓⵔⴰⵢ ⵏⵏⴻⵖⵏⵉ. ⵉⵙⵙⴰⵔⵙ ⵜⵜⴰⵊ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⵜ ⴷ ⵜⴰⵊⴻⴵⵉⴷⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴰⵛⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("ET2_18","018_2_18","EST","2","18","18","ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵣⵣⴰⵔⴷⴻⵜ ⵏ ⵉⵙⵜⵉⵔ. ⵉⴳⴳⴰ ⵍⴻⵀⵏⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵓ ⵉⵡⵛⴰ ⴰⵔⵔⵉⵖⴰⵍⵓⵜⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET2_19","018_2_19","EST","2","19","19","ⵅⵎⵉ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏⵜ ⵜⵉⵄⵣⵓⵔⴰⵢ ⵄⴰⵡⴻⴷ, ⵉⵇⵇⵉⵎ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET2_20","018_2_20","EST","2","20","20","ⵉⵙⵜⵉⵔ ⵡⴰⵔ ⵜⵅⴻⴱⴱⴰⵔ ⵛⴰ ⵉ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵏⴻⵙ ⵏⵉⵖ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵎⵉⵏⵣⵉ ⵉⵙⵜⵉⵔ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵓⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⴳⴳ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜᵉⵜⵜⵡⴰⵔⴻⴱⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("ET2_21","018_2_21","EST","2","21","21","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵎ ⵉⵇⵇⵉⵎ ⵎⵓⵔⴷⴰⵅⴰⵢ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵜⵓⵖⴰ ⴱⵉⵖⵜⴰⵏ ⴷ ⵜⴰⵔⴰⵛ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵣⴻⴳ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵜⵜⴼⵓⴳⴳⵎⴻⵏ ⴰⵟⵟⴰⵙ ⵓ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴼⵓⵙ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("ET2_22","018_2_22","EST","2","22","22","ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵜⴻⴷⵡⴻⵍ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵅⴻⴱⴱⴰⵔ ⵉ-ⵜⵜ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ, ⵓⵛⴰ ⵉⵙⵜⵉⵔ ⵜⴻⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("ET2_23","018_2_23","EST","2","23","23","ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⵉ ⵓⵛⴰ ⵓⴼⵉⵏ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵉⴷⴻⵜⵜ. ⵓⵢⵍⴻⵏ ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵅ ⵜⴻⵃⵏⴰⵛⵜ ⵓⵛⴰ ⵓⵔⴰⵏ ⵜ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET3_1","018_3_1","EST","3","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵉⴳⴳⴰ ⵛⵛⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵀⴰⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵎⵎⴰⴷⴰⵜⴰ, ⴰⵊⴰⵊⵉ, ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET3_2","018_3_2","EST","3","2","2","ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⴹⴰⵔⴻⵏ, ⵇⴻⵡⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵀⴰⵎⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵜ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ. ⵎⴰⵛⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵡⴰⵔ ⵉⵡⴹⵉ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⴱⴻⵏⴷⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("ET3_3","018_3_3","EST","3","3","3","ⵏⵏⴰⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵄⴻⴷⴷⵉⴷ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("ET3_4","018_3_4","EST","3","4","4","ⵓⵎⵉ ⵅⴰⵙ ⵏⵏⴰⵏ ⴰⵢⴰ ⵣⴻⴳ ⵡⴰⵙⵙ ⵖⴰⵔ ⵡⴰⵙⵙ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵙⵍⵉ ⵛⴰ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⴰⵢⴰ ⵉ ⵀⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉ ⵣⵉ ⵉⵡⵡⴻⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ-ⵜⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵓⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("ET3_5","018_3_5","EST","3","5","5","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵀⴰⵎⴰⵏ ⴱⴻⵍⵍⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵡⴰⵔ ⵢⵉⵡⴹⵉ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⴱⴻⵏⴷⵉⵇ, ⵉⵙⵄⴰⵔ ⵀⴰⵎⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ET3_6","018_3_6","EST","3","6","6","ⵎⴰⵛⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴰⵢⴰ ⴷ ⴰⵙⴻⵃⵇⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵡⴰⵀⴰ, ⵎⵉⵏⵣⵉ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ. ⵙ ⵓⵢⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵀⴰⵎⴰⵏ ⴰⴷ ⵉⵀⴻⵍⵍⴻⴽ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵍⴳⴻⵏⵙ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("ET3_7","018_3_7","EST","3","7","7","ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵓⵔ ⵏ ⵏⵉⵙⴰⵏ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ‘ⴱⵓⵔ’, ⵉⵅⵙ. ⴰⴷ ⵢⵉⵏⵉ ‘ⵜⴰⵇⴻⴷⴷⵓⵃⵜ’, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵀⴰⵎⴰⵏ, ⵉ ⴽⵓⵍ ⴰⵙⵙ ⵓ ⵉ ⴽⵓⵍ ⴰⵢⵓⵔ, ⴰⵍ ⴷⴷ-ⵉⵡⴹⴰ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵓⵔ ⵏ ⴰⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ET3_8","018_3_8","EST","3","8","8","ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ ⵀⴰⵎⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ: “ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵟⴰⵔⵔⴻⵛ ⵓ ⵉⵜⵜⵡⴰⴱⴹⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ. ⵉⵣⴻⵔⴼⴰⵏ ⵏⵙⴻⵏ ⴼⴰⵔⵔⵇⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⵛⴰ ⴷⴻⴳ ⵉⵣⴻⵔⴼⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("ET3_9","018_3_9","EST","3","9","9","ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵔⵉⵏ ⵉⵊⵊ ⵏ ⵍⵓⵎⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⴷ ⵙⵙⵡⴻⵣⵏⴻⵖ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵜⴰⵍⵉⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⴷ ⴳⴳⴻⵖ ⴰⵢⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴹⴰⵏ ⵍⵅⴻⴷⵎⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵙⵉⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("ET3_10","018_3_10","EST","3","10","10","ⵉⴽⴽⴻⵙ ⵓⵊⴻⴵⵉⴷ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⵉ ⵣⵉ ⵢⴰⵔⴻⵛⵛⴻⵎ ⵣⴻⴳ ⵓⴹⴰⴹ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵀⴰⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵎⵎⴰⴷⴰⵜⴰ, ⴰⵊⴰⵊⵉ, ⵍⴻⵄⴷⵓ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET3_11","018_3_11","EST","3","11","11","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵀⴰⵎⴰⵏ: “ⵏⵏⵓⵇⴰⵔⵜ ⵊⵊⵉⵖ ⴰⵛ ⵜⵜ, ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵜⵡⴰⵔⵉⴷ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("ET3_12","018_3_12","EST","3","12","12","ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⴻⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ, ⵎⵍⴰⵖⴰⵏ ⵉⵎⴰⵔⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵔⴰⵏ ⵎⴰⵔⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⵀⴰⵎⴰⵏ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉ ⵍⵡⵓⵍⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⵓ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴽⵓⵍ ⵍⴳⴻⵏⵙ. ⵏⵉⵜⵏⵉ ⵓⵔⴰⵏ ⵉ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⵙ ⵜⵉⵔⴰ ⵏⵏⴻⵙ ⵓ ⵉ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⵙ ⵉⵍⴻⵙ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵜⴰⴱⵔⴰⵜ ⵜⵓⵔⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓ ⵜᵉⵜⵜⵡⴰⵛⴻⵎⵎⴻⵄ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET3_13","018_3_13","EST","3","13","13","ⵙⵙⴻⴽⴽⴻⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⴰⴽ-ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⵃⴰⵏ, ⴰⴷ ⵏⵖⴻⵏ ⵓ ⴰⴷ ⵀⴻⵍⵍⴽⴻⵏ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵓⵔ ⵏ ⴰⴷⴰⵔ, ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("ET3_14","018_3_14","EST","3","14","14","ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⵉⵔⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ, ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵄⴰⵎⴰⵍⴰ ⴰⵍ ⵜⴻⵏⵏⴻⵖⵏⵉ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵃⴻⵣⵣⵎⴻⵏ ⵉ ⵓⵢⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ET3_15","018_3_15","EST","3","15","15","ⴼⴼⵖⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ, ⵜⵜⵡⴰⵛⴻⵊⵊⵄⴻⵏ ⵙ ⵓⵣⴻⵢⵢⴰⵔ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵓⵣⴻⵔⴼ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ. ⵜⵓⵖⴰ ⴰⵊⴻⴵⵉⴷ ⴷ ⵀⴰⵎⴰⵎ ⵇⵇⵉⵎⴻⵏ ⵙⴻⵙⵙⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵛⵓⵛⴰⵏ ⵜⵓⵖⴰ-ⵜⵜ ⵜⴻⵀⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("ET4_1","018_4_1","EST","4","1","1","ⵓⵎⵉ ⵢⴰⵔⴳⴻⴱ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵉⵛⴰⵔⵔⴻⴳ ⵜⵛⴰⵎⵉⵔ ⵏⵏⴻⵙ, ⵢⴰⵔⴹ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵉⵙⵙⵓⵢⴻⵙ ⵉⵖⵖⴻⴹ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵥⵡⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⵓⵖⴰ ⵉⵙⵙⵖⵓⵢⵢⵓ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴻⵊⵀⴻⴷ ⵜⴰⵔⵣⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("ET4_2","018_4_2","EST","4","2","2","ⵢⵉⵡⴻⴹ-ⴷⴷ ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵢⴰⵔⴹ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET4_3","018_4_3","EST","4","3","3","ⴷⵉ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⴷ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⵢⵉⵡⴻⴹ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵍⵇⴻⴼ ⵓⴷⴰⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵓⵥⵓⵎⵎⵉ ⴷ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵉⵖⵓⵢⵢⴰⵏ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵙⴻⵏ ⵥⵥⵍⴻⵏ ⴷⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵢⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("ET4_4","018_4_4","EST","4","4","4","ⵜⵉⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵉⵙⵜⵉⵔ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵙ ⵓⵢⴰ ⵓⵛⴰ ⵜⴻⵃⵣⴻⵏ ⵜⵊⴻⴵⵉⴷⵜ ⴰⵟⵟⴰⵙ. ⵜⴻⵙⵙⴻⴽⴽ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵜ ⵢⴰⵔⴹ, ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏⵏⴻⵙ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵉⵇⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ET4_5","018_4_5","EST","4","5","5","ⵅⴻⵏⵏⵉ ⵜⵍⴰⵖⴰ ⵉⵙⵜⵉⵔ ⵉ ⵀⴰⵜⴰⵅ, ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ, ⵓⵛⴰ ⵜⵓⵎⵓⵔ ⵉ-ⵜ ⵅ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⴻⵏ ⵎⵉⵏ ⵜ ⵢⵓⵖⵉⵏ ⴷ ⵎⴰⵢⴻⵎⵎⵉ ⵉⴳⴳⴰ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("ET4_6","018_4_6","EST","4","6","6","ⵉⴼⴼⴻⵖ ⵀⴰⵜⵜⴰⵅ ⵖⴰⵔ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵖⴰⵔ ⵡⴰⵣⵣⴰⵢ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("ET4_7","018_4_7","EST","4","7","7","ⵓⵛⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉⵄⴰⵡⴻⴷ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵙⴰⵔⴻⵏ ⴷ ⵛⵃⴰⵍ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵉⵡⴰⵄⴻⴷ ⵀⴰⵎⴰⵏ ⴰⴷ ⵜ ⵉⵡⵣⴻⵏ ⵉ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵔⴻⴷⴷⴻⴵ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET4_8","018_4_8","EST","4","8","8","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⵉⵍⴻⵎⵜ ⵏ ⵜⵉⵔⴰ ⵏ ⵓⵣⴻⵔⴼ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⴷⵉ ⵛⵓⵛⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⵛⴻⵏ ⵉ ⵉⵙⵜⵉⵔ ⵓ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ ⵓ ⴰⴷ ⴰⵙ ⵢⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵔⴰⵃ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⴰⵙ ⵜⵣⴰⵡⴳ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵜᵉⵜⵜⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET4_9","018_4_9","EST","4","9","9","ⵢⵓⴷⴻⴼ ⵀⴰⵜⴰⵅ ⵓⵛⴰ ⵉⵄⴰⵡⴻⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉ ⵉⵙⵜⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("ET4_10","018_4_10","EST","4","10","10","ⵜⴻⵙⵙⵉⵡⴻⵍ ⵉⵙⵜⵉⵔ ⵉ ⵀⴰⵜⴰⵅ ⵓⵛⴰ ⵜⵓⵎⵓⵔ ⵉ-ⵜ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ: ");
INSERT INTO rift_vpl VALUES ("ET4_11","018_4_11","EST","4","11","11","“ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙⵙⵏⴻⵏ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵣⵣⴰⵜ, ⴰⵎ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵍⴰⵖⴰ, ⴷ ⴰⵔⵢⴰⵣ ⵏⵉⵖ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵉⴵⴰ, ⴰⵇⴰ ⴷⵉⵏ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⴽⴰⵎ ⵡⴰⵀⴰ, ⴷ ⵍⵎⴻⵡⵜ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⵙ ⴰⵣⴻⴵⴰⴹ ⵏⵏⴻⵙ ⵏ ⵡⵓⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ-ⴰ ⵉ ⵉⵄⴷⵓⵏ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵉⵍⴰⵖⴰ ⵃⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("ET4_12","018_4_12","EST","4","12","12","ⵄⴰⵡⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵙⵜⵉⵔ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("ET4_13","018_4_13","EST","4","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⵙⵜⵉⵔ ⵄⴰⵡⴻⴷ: “ⵡⴰⵔ ⵜⵅⴻⵎⵎⴰⵎ, ⴰⵇⴰ ⵛⴻⵎ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴽⵜⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ET4_14","018_4_14","EST","4","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵛⴻⵎ ⵜⴻⵙⵙⴻⵖⴷⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⴻⴼⵙⴰⵙⴻⵜ ⴷ ⵓⵙⴻⵍⵍⴻⴽ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵛⴻⵎ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵎ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⵎⴰ ⵜⴻⴽⵙⵉⴷ ⴰⵡⴻⵇⵇⴰⵔ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⴰⵎ ⵜⴰⵏⵉⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("ET4_15","018_4_15","EST","4","15","15","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵙⵜⵉⵔ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵅ ⵎⵓⵔⴷⴰⵅⴰⵢ: ");
INSERT INTO rift_vpl VALUES ("ET4_16","018_4_16","EST","4","16","16","“ⵓⵢⵓⵔ, ⵙⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵛⵓⵛⴰⵏ ⵓⵛⴰ ⵥⵓⵎⵎⴻⵎ ⴰⵢⵉ ⵉ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵎ, ⵡⴰⵔ ⵜⵙⴻⵙⵙⴻⵎ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴷ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵉⵏⵓ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⴰⴷ ⵥⵓⵎⵎⴻⵏⵜ ⴰⵎⵎⵓ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵣⴻⵔⴼ. ⵎⴰⵍⴰ ⴼⵏⵉⵖ, ⵅⴻⵏⵏⵉ ⴼⵏⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("ET4_17","018_4_17","EST","4","17","17","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅ ⵉ ⴷ ⴰⵙ ⵜⵓⵎⵓⵔ ⵉⵙⵜⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("ET5_1","018_5_1","EST","5","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵙⵜⵉⵔ ⵜⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵓⵛⴰ ⵜⵔⵓⵃ ⵜⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵏⵉⵛⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵜⵓⵖⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⴳⴻⵍⵍⴷⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ET5_2","018_5_2","EST","5","2","2","ⵓⵎⵉ ⵉⵥⵔⴰ ⵓⵊⴻⴵⵉⴷ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ ⵜⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵜⵓⴼⴰ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵉⵙⵙⴻⵍⵇⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵣⴻⴵⴰⴹ ⵏⵏⴻⵙ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⵉⵙⵜⵉⵔ ⵓⵛⴰ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵉⵙⵜⵉⵔ, ⵜⵃⴰⴷⴰ ⵜⵉⵅⴻⴼⵜ ⵏ ⵓⵣⴻⴵⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("ET5_3","018_5_3","EST","5","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ, ⴰ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ, ⵏⵉⵖ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵎ? ⴰⴷ ⴰⵎ ⵜⴻⵎⵎⴻⵡⵛ, ⵡⴰⵅⵅⴰ ⵜⴻⴵⴰ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ!” ");
INSERT INTO rift_vpl VALUES ("ET5_4","018_5_4","EST","5","4","4","ⵜⴻⵏⵏⴰ ⵉⵙⵜⵉⵔ: “ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵍⵅⴰⴹⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵙⵙ-ⴰ ⴰⴽ-ⴷ ⵀⴰⵎⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⴷ ⴰⵙ ⵙⵙⵡⴻⵊⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("ET5_5","018_5_5","EST","5","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴰⵔⵔⴻⵎ ⵀⴰⵎⴰⵏ ⴰⴷ ⵉⵇⴻⴵⴻⵇ ⴰⴷ ⵉⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⴰ ⵉⵙⵜⵉⵔ.” ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵀⴰⵎⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⵏⵏⵉ ⵉ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵉⵙⵜⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("ET5_6","018_5_6","EST","5","6","6","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵙⵜⵉⵔ ⵓⵎⵉ ⵙⵡⵉⵏ ⴱⵉⵏⵓ: “ⵎⵉⵏ ⴷⴰⵢⴻⵎ ⵉⴵⴰⵏ ⴷ ⵎⴻⵥⵔⵉ? ⴰⴷ ⴰⵎ ⵉⵎⵎⴻⵡⵛ. ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵎ? ⴰⴷ ⵖⴰⵔⴻⵎ ⵜⵉⵍⵉ ⵡⴰⵅⵅⴰ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("ET5_7","018_5_7","EST","5","7","7","ⵅⴻⵏⵏⵉ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵉⵙⵜⵉⵔ, ⵜⴻⵏⵏⴰ: “ⵡⴰ ⴷ ⵎⴻⵥⵔⵉ ⵉⵏⵓ ⴷ ⵜⵓⵜⵔⴰ ⵉⵏⵓ: ");
INSERT INTO rift_vpl VALUES ("ET5_8","018_5_8","EST","5","8","8","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵍⵅⴰⴹⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵎⴻⵥⵔⵉ ⵉⵏⵓ ⴷ ⵜⵓⵜⵔⴰ ⵉⵏⵓ, ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵀⴰⵎⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⵉⵏⵓ ⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵙⵙⵡⴻⵊⴷⴻⵖ, ⵅⴻⵏⵏⵉ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("ET5_9","018_5_9","EST","5","9","9","ⵉⴼⴼⴻⵖ ⵀⴰⵎⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⴼⴰⵔⵃ ⵓ ⵜⵓⵖⴰ-ⵜ ⵅ ⵍⵅⴰⴷⴰⵔ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵥⵔⴰ ⵀⴰⵎⴰⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⵉⴽⴽⴰⵔ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵏⵀⴻⵣⵣ, ⵅⴻⵏⵏⵉ ⵉⵙⵄⴰⵔ ⵀⴰⵎⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ET5_10","018_5_10","EST","5","10","10","ⵎⴰⵛⴰ ⵀⴰⵎⴰⵏ ⵉⵜⴻⴱⴱⴻⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵓ ⵓⵎⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⴷ ⵣⴰⵔⴰⵛ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET5_11","018_5_11","EST","5","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵀⴰⵎⴰⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵅ ⵓⵄⵓⴵⵉ ⵏ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓ ⵅ ⵉⵃⵔⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵉ ⴷ ⴰⵙ ⵉⵛⴻⵏⵏⴻⵄ ⵓⵊⴻⴵⵉⴷ ⵓ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉ-ⵜ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET5_12","018_5_12","EST","5","12","12","ⵄⴰⵡⴻⴷ ⵉⵏⵏⴰ ⵀⴰⵎⴰⵏ: “ⵓⵍⴰ ⴷ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ ⵡⴰⵔ ⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ, ⵎⵖⵉⵔ ⵏⴻⵛⵛ, ⵓⵛⴰ ⴰⵃⴻⵇⵇⴰ ⵓⵍⴰ ⴷ ⵜⵉⵡⴻⵛⵛⴰ ⵜⵜⵡⴰⵄⴰⵔⴹⴻⵖ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET5_13","018_5_13","EST","5","13","13","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵛⵇⵉ ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵖ ⵜⵜⵡⴰⵍⵉⵖ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵓⴷⴰⵢ, ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("ET5_14","018_5_14","EST","5","14","14","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵣⴰⵔⴰⵛ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ: “ⴻⵊⵊ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵛⵜ ⵏ ⵜⵃⴻⵏⴰⵛⵜ ⵎⴰⵏⵉ ⵜ ⵖⴰ ⴰⵢⵍⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⵉⵍⴻⵏ ⵓⵛⴰ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴰⵢⵍⴻⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ.” ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵉ ⵀⴰⵎⴰⵏ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵛⵛⵡⴰⵔ ⵉⵛⵏⴰ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴰⵃⵏⴰⵛⵜ ⵏ ⵡⴰⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("ET6_1","018_6_1","EST","6","1","1","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵢⵓⴳⵉ ⴰⴷ ⵉⴽⴽ ⵉⴹⴻⵚ ⵅ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⴷ ⴰⵙ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴰⴷⵍⵉⵙ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵓⵛⴰ ⵖⵔⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET6_2","018_6_2","EST","6","2","2","ⵉⵜⵜⵡⴰⴼ ⵓⵔⴰⵏ ⴷⴰⵢⴻⵙ, ⴰⵇⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉⵅⴻⴱⴱⴰⵔ ⵅ ⴱⵉⵖⵜⴰⵏⴰ ⴷ ⵜⴰⵔⴰⵛ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵣⴻⴳ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵡⵜⴻⵏ ⴰⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("ET6_3","018_6_3","EST","6","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵏ ⵛⵛⴰⵏ ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵅ ⵎⴰⵏ ⴰⵢⴰ?” ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵃⵓⴹⵔⵉⵢⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴳⴳ ⵡⴰⵍⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("ET6_4","018_6_4","EST","6","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵡⵉ ⴷⵉⵏ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ?” ⵀⴰⵎⴰⵏ ⵜⵓⵖⴰ ⵄⴰⴷ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵇⴰⵄ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵢⴻⵍ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵖⴰⵔ ⵜⵃⴻⵏⴰⵛⵜ ⵏ ⵡⴰⵢⴰⵍ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵉⵙⵙⴻⵡⵊⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("ET6_5","018_6_5","EST","6","5","5","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵇⴰ ⴷ ⵀⴰⵎⴰⵏ ⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⴰⴷⴻⴼ!” ");
INSERT INTO rift_vpl VALUES ("ET6_6","018_6_6","EST","6","6","6","ⵅⵎⵉ ⵢⵓⴷⴻⴼ ⵀⴰⵎⴰⵏ, ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ: “ⵎⵉⵏ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵉ ⵓⵎⵉ ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜ ⵉⵛⴻⵏⵏⴻⵄ?” ⵉⵅⴻⵎⵎⴻⵎ ⵀⴰⵎⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵛⴻⵏⵏⴻⵄ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵉ?” ");
INSERT INTO rift_vpl VALUES ("ET6_7","018_6_7","EST","6","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵀⴰⵎⴰⵏ ⵅ ⵓⵊⴻⴵⵉⴷ: “ⴰⵔⵢⴰⵣ ⵉ ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜ ⵉⵛⴻⵏⵏⴻⵄ, ");
INSERT INTO rift_vpl VALUES ("ET6_8","018_6_8","EST","6","8","8","ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵜⵛⴰⵎⵉⵔ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵉ ⵣⵉ ⵉⵏⵏⵓⵎ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵢⴰⵔⴹ ⵓⵍⴰ ⴷ ⴰⵢⵉⵙ ⵉ ⵅⴻⴼ ⵉⵏⵏⵓⵎ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵏⵉⵢ ⵓⵛⴰ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ET6_9","018_6_9","EST","6","9","9","ⴰⴷ ⴳⴳⴻⵏ ⵜⵛⴰⵎⵉⵔ ⴷ ⵓⵢⵉⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵢⴰⵔⴹⴻⵏ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵛⴻⵏⵏⴻⵄ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⵏⴻⴷⵀⴻⵏ ⵅ ⵓⵢⵉⵙ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵛⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ, ⵡⴻⵏⵏⵉ ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜ ⵉⵛⴻⵏⵏⴻⵄ!’” ");
INSERT INTO rift_vpl VALUES ("ET6_10","018_6_10","EST","6","10","10","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵀⴰⵎⴰⵏ: “ⵇⴻⴵⴻⵇ, ⴽⵙⵉ ⵜⵛⴰⵎⵉⵔ ⴷ ⵓⵢⵉⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⵉⴷ ⵓⵛⴰ ⴻⴳⴳ ⴰⵎⴻⵏⵏⵉ ⴰⴽ-ⴷ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴰⴷ ⵉⵡⴹⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("ET6_11","018_6_11","EST","6","11","11","ⵉⴽⵙⵉ ⵀⴰⵎⴰⵏ ⵜⵛⴰⵎⵉⵔ ⴷ ⵓⵢⵉⵙ ⵓⵛⴰ ⵉⵙⵙⵢⴰⵔⴹ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵙ ⵜⵛⴰⵎⵉⵔ ⵓ ⵉⵙⵙⵏⴻⴷⵀ ⵉ-ⵜ ⵅ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⴰⴱⴰⵔⵔⴻⵃ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⴰⵙ ⵉⵛⴻⵏⵏⴻⵄ!’” ");
INSERT INTO rift_vpl VALUES ("ET6_12","018_6_12","EST","6","12","12","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵄⵇⴻⴱ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵛⴰ ⵀⴰⵎⴰⵏ ⵢⵓⵢⵓⵔ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵃⵣⴻⵏ ⵓ ⵜⵓⵖⴰ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵉⵍⴻⵃⵃⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("ET6_13","018_6_13","EST","6","13","13","ⵉⵄⴰⵡⴻⴷ ⵀⴰⵎⴰⵏ ⵉ ⵣⴰⵔⴰⵛ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⵉⵎⵙⴰⵔⴻⵏ. ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵣⴰⵔⴰⵛ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⵎⴰⵍⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵡⴻⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵜⴻⴱⴷⵉⴷ ⴰⴷ ⵜⴻⵡⴹⵉⴷ, ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉ ⵢⴻⴵⴰ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ, ⵎⴰⵛⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵡⴹⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("ET6_14","018_6_14","EST","6","14","14","ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵄⴰⴷ ⴰⴽⵉⴷⴻⵙ, ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴷ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵇⴻⴵⵇⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵀⴰⵎⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⵏⵏⵉ ⵜⴻⵙⵙⴻⵡⵊⴻⴷ ⵉⵙⵜⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("ET7_1","018_7_1","EST","7","1","1","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵀⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵏ ⴰⴽ-ⴷ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("ET7_2","018_7_2","EST","7","2","2","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ, ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⴽ-ⴷ ⵜⵉⵙⵙⵉⵜ ⵏ ⴱⵉⵏⵓ ⵉ ⵉⵙⵜⵉⵔ: “ⵎⵉⵏ ⴷⴰⵢⴻⵎ ⵉⴵⴰⵏ ⴷ ⵎⴻⵥⵔⵉ, ⴰ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ! ⴰⴷ ⴰⵎ ⵉⵎⵎⴻⵡⵛ. ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵎ? ⴰⴷ ⵖⴰⵔⴻⵎ ⵜⵉⵍⵉ ⵡⴰⵅⵅⴰ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("ET7_3","018_7_3","EST","7","3","3","ⵅⴻⵏⵏⵉ ⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ, ⵜⴻⵏⵏⴰ: “ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵓ ⵎⴰⵍⴰ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵓⵊⴻⴵⵉⴷ ⵙ ⵍⵅⴰⴹⴰⵔ, ⴻⵊⵊ ⴰⴷ ⴰⵢⵉ ⵡⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵅ ⵎⴻⵥⵔⵉ ⵉⵏⵓ ⵓ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵅ ⵜⵓⵜⵔⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ET7_4","018_7_4","EST","7","4","4","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵎⵎⴻⵏⵣ, ⵏⴻⵛⵛ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵓ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵜⴻⵃⵃⴰ. ⵎⴰⵍⴰ ⵏⴻⵎⵎⴻⵏⵣ ⴰⵎ ⵢⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵓⵙⵎⴻⵖ, ⵎⵉⵏⵣⵉ ⵅ ⵓⵢⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⴰⵏⴻⵛⵜ ⴰⵍⴰⵎⵉ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵚⴻⴷⴷⵄⴻⵖ ⴰⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("ET7_5","018_7_5","EST","7","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵉⵏⵏⴰ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ ⵓ ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵍ ⵉⵛⵛⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("ET7_6","018_7_6","EST","7","6","6","ⵜⴻⵏⵏⴰ ⴰⵙ ⵉⵙⵜⵉⵔ: “ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⵚⴰⵔⴻⵏ ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵖ, ⴰⵇⴰ ⴷ ⵡⴰ ⴷ ⵀⴰⵎⴰⵏ ⴰⵄⴻⴼⴼⴰⵏ!” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵀⴰⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵜⵊⴻⴵⵉⴷⵜ. ");
INSERT INTO rift_vpl VALUES ("ET7_7","018_7_7","EST","7","7","7","ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵙ ⵡⴻⵙⵄⴰⵔ, ⵉⵊⵊⴰ ⵜⵉⵙⵙⵉⵜ ⵏ ⴱⵉⵏⵓ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵍⴻⵇⵚⴰⵔ. ⵀⴰⵎⴰⵏ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴻⵛⵛⴻⵎ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵢⵓⵛⴰ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ ⵉⵄⴻⵡⵡⴻⵍ ⴰⴷ ⴰⵙ ⵉⴳⴳ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ET7_8","018_7_8","EST","7","8","8","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵉⵊⴻⴵⵉⴷ ⵣⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵏ ⵍⴻⵇⵚⴰⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵟⵟⴰⴱⵍⴰ ⵏ ⴱⵉⵏⵓ, ⵢⵓⴼⴰ ⵀⴰⵎⴰⵏ ⵉⵡⴹⴰ ⵅ ⵍⴻⵎⵟⴰⵔⴱⴰⵜ ⵉ ⵅ ⵜⵓⵖⴰ ⵜⴻⵣⵣⴻⵍ ⵉⵙⵜⵉⵔ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵉⵀⴻⴽⴽⵡⴻⵍ ⵓⵍⴰ ⴷ ⵜⴰⵊⴻⴵⵉⴷⵜ ⵖⴰⵔⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ!” ⵇⴰⵄ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵍⴻⵃⵃⴼⴻⵏ ⴰⵙ ⵉ ⵀⴰⵎⴰⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("ET7_9","018_7_9","EST","7","9","9","ⵃⴰⵔⴱⵓⵏⴰ, ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⵃⵏⴰⵛⵜ ⵏ ⵡⴰⵢⴰⵍ, ⵜⴻⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵀⴰⵎⴰⵏ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵍⵉⵃ ⴷⴻⴳ ⵓⵊⴻⴵⵉⴷ, ⵜⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵎⴰⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⵉⵍⴻⵏ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ: “ⴰⵢⵍⴻⵎ ⵖⴰⵔⴻⵙ ⵀⴰⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("ET7_10","018_7_10","EST","7","10","10","ⵓⵢⵍⴻⵏ ⵀⴰⵎⴰⵏ ⵖⴰⵔ ⵜⴻⵃⵏⴰⵛⵜ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵓⵛⴰ ⵢⴰⵔⵙⴰ ⵡⴻⵙⵄⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET8_1","018_8_1","EST","8","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵊⴻⴵⵉⴷ ⵉⵡⵛⴰ ⴰⵙ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵎⴰⵏ, ⵍⴻⵄⴷⵓ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵉⵙⵜⵉⵔ ⵜⵅⴻⴱⴱⴰⵔ ⵙ ⵎⵉⵏⵣⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵉ ⵏⴻⵜⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ET8_2","018_8_2","EST","8","2","2","ⵉⴽⴽⴻⵙ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏⵏⴻⵙ ⵏ ⵓⵛⴻⵎⵎⵉⵄ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴽⴽⴻⵙ ⵣⵉ ⵀⴰⵎⴰⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ-ⵜⵜ ⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵓ ⵉⵙⵜⵉⵔ ⵜⴻⴳⴳⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_3","018_8_3","EST","8","3","3","ⵜⴻⵙⵙⵉⵡⴻⵍ ⵉⵙⵜⵉⵔ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ, ⵜᵉⵜⵔⵓ ⵓ ⵜⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵏ ⵀⴰⵎⴰⵏ, ⴰⵊⴰⵊⵉ, ⵓⵍⴰ ⴷ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵉ ⵜⵓⵖⴰ ⵉⵅⴰⵔⵔⴻⵚ ⴹⵉⴷⴷ ⵉ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_4","018_8_4","EST","8","4","4","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵙⵜⵉⵔ ⴰⵣⴻⴵⴰⴹ ⵏⵏⴻⵙ ⵏ ⵡⵓⵔⴻⵖ. ⵅⴻⵏⵏⵉ ⵉⵙⵜⵉⵔ ⵜⴻⴽⴽⴰⵔ, ⵜⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("ET8_5","018_8_5","EST","8","5","5","ⵜⴻⵏⵏⴰ: “ⵎⴰⵍⴰ ⵎⵍⵉⵃ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⵍⵅⴰⴹⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓ ⵎⴰⵍⴰ ⵜⵙⴻⴳⴳⴻⵎ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏⴻⵛⵛ ⵓⴷⴼⴻⵖ ⴰⵙ ⴷⵉ ⵍⵅⴰⴹⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴻⵊⵊ ⴰⴷ ⴰⵔⵉⵏ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴱⴻⴹⵍⴻⵏⵜ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵏⵏⵉ ⴷⵉ ⵜⴻⴵⴰ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵏ ⵀⴰⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵎⵎⴰⴷⴰⵜⴰ, ⴰⵊⴰⵊⵉ, ⵜⵉⵏⵏⵉ ⵉ ⵢⵓⵔⴰ ⵉ ⵓⵀⴻⵍⵍⴻⴽ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ET8_6","018_8_6","EST","8","6","6","ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵢ ⴰⴷ ⵅⵣⴰⵔⴻⵖ ⵍⵖⴰⵔ ⵉ ⵖⴰ ⵉⵍⴻⵇⴼⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ? ⵓ ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵅⵣⴰⵔⴻⵖ ⴰⵀⴻⵍⵍⴻⴽ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("ET8_7","018_8_7","EST","8","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ ⵓ ⵉ ⵡⵓⴷⴰⵢ ⵎⵓⵔⴷⴰⵅⴰⵢ: “ⵅⵣⴰⵔ, ⵡⵛⵉⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵎⴰⵏ ⵉ ⵉⵙⵜⵉⵔ ⵓ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵢⵍⴻⵖ ⵜ ⵖⴰⵔ ⵜⵃⴻⵏⴰⵛⵜ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_8","018_8_8","EST","8","8","8","ⴰⴷ ⵜⴰⵔⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵛⵏⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ⵛⴻⵎⵎⵄⴻⵎ ⵜ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵜⵉⵔⴰ ⵉ ⵢⵓⵔⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵛⴻⵎⵎⵄⴻⵎ ⵜⴻⵏⵜ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵜⴻⵏⵜ ⵉⴱⴹⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("ET8_9","018_8_9","EST","8","9","9","ⵅⴻⵏⵏⵉ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵉⵎⴰⵔⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵢⵓⵔ ⵏ ⵙⵉⵡⴰⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵣⵣⴰⵢⴻⵙ, ⵓⵛⴰ ⵓⵔⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⴰⵇⴰ ⵓⵔⴰⵏ ⵜ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉ ⵍⵡⵓⵍⴰⵜ ⵓ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ, ⵣⵉ ⵍⵀⴻⵏⴷ ⴰⵍ ⴽⵓⵛ, ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ, ⵉ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⵙ ⵜⵉⵔⴰ ⵏⵏⴻⵙ ⵓ ⵉ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵓ ⵄⴰⵡⴻⴷ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵙ ⵜⵉⵔⴰ ⵏⵙⴻⵏ ⵓ ⵙ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_10","018_8_10","EST","8","10","10","ⵉⵜⵜⵡⴰⵔⵉ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⵓ ⵜᵉⵜⵜⵡⴰⵛⴻⵎⵎⴻⵄ ⵜⴻⴱⵔⴰⵜ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏⵏⵉ ⴰⴽ-ⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ ⵏ ⵜⴰⵣⵍⴰ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵏ ⵊⵊⴰⴷⵉⵔⴰ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("ET8_11","018_8_11","EST","8","11","11","ⴷⵉ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵏⵏⵉ ⵉⵡⵛⴰ ⵓⵊⴻⴵⵉⴷ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵓⵏⴻⵏ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⴷⵉ ⴵⴰⵏ, ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⴰⴷ ⵏⵖⴻⵏ ⵓ ⴰⴷ ⵜⴻⵃⵃⴰⵏ ⴽⵓⵍ ⵍⵄⴻⵙⴽⴰⵔ ⵣⵉ ⵍⴳⴻⵏⵙ ⴷ ⵍⵄⴰⵎⴰⵍⴰ ⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵃⵚⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ET8_12","018_8_12","EST","8","12","12","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵢⵓⵔ ⵏ ⴰⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ET8_13","018_8_13","EST","8","13","13","ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵉⵛⵜ ⵏ ⵜⵉⵍⴻⵎⵜ ⵏ ⵜⵉⵔⴰ-ⵢⴰ ⴰⵎ ⵓⵣⴻⵔⴼ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⴰⵇⴰ ⵓⴷⴰⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵃⴻⵣⵣⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵏⵜⴰⵇⵎⴻⵏ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_14","018_8_14","EST","8","14","14","ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵜⴰⵣⵍⴰ, ⵉⵏⵏⵉ ⵢⴻⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ ⵏ ⵜⴰⵣⵍⴰ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⴼⴼⵖⴻⵏ ⴷⴻⵖⵢⴰ, ⵜⵜⵡⴰⵛⴻⵊⵊⵄⴻⵏ ⵙ ⵓⵣⴻⵢⵢⴰⵔ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵓⵣⴻⵔⴼ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_15","018_8_15","EST","8","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵓⵙⴻⵍⵀⴰⵎ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵏ ⵓⴼⵉⵍⵓ ⴰⴷⴻⵀⵎⴰⵏⵉ ⴷ ⵓⵛⴻⵎⵍⴰⵍ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵓⵙⴻⵍⵀⴰⵎ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵓⴼⵉⵍⵓ ⴰⵔⵊⵓⵡⴰⵏⵉ, ⵓⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵛⵓⵛⴰⵏ ⵏⴻⴳⵣⴻⵏ ⴷⴰⵢⴻⵙ ⵉⵡⴷⴰⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ET8_16","018_8_16","EST","8","16","16","ⵓⴷⴰⵢⴻⵏ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵜⴼⴰⵡⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴷ ⵡⴰⵔⵛⵓⵇ ⴷ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET8_17","018_8_17","EST","8","17","17","ⴷⵉ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⵓ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⵎⴰ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵡⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵓⵣⴻⵔⴼ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵡⴰⵔⵛⵓⵇ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵣⵣⵔⵓⴷ ⴷ ⵡⵓⵙⵙⴰⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⵡⴰⵟⵟⴰⵙ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⵡⵍⴻⵏ ⴷ ⵓⴷⴰⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_1","018_9_1","EST","9","1","1","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵓⵔ ⵏ ⴰⴷⴰⵔ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵣⴻⴳ ⵓⵢⵓⵔ ⵏⵏⵉ, ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵓⵣⴻⵔⴼ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵜⵜⵔⴰⵊⴰⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ, ⵜⵓⵖⴰ ⵍⵃⴰⵍ ⵙ ⵍⵄⴻⴽⵙ, ⵎⴰⵖⴰⵔ ⵓⴷⴰⵢⴻⵏ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵛⴰⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_2","018_9_2","EST","9","2","2","ⵙⵙⵎⵓⵏⴻⵏ ⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵜⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵜⵓⵖⴰ ⴼⴻⵛⵍⴻⵏ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_3","018_9_3","EST","9","3","3","ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵡⵓⵍⴰⵜ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵡⵛⵉⵏ ⴰⴼⵓⵙ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵜⴻⵡⴹⴰ ⵅⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ET9_4","018_9_4","EST","9","4","4","ⵎⵉⵏⵣⵉ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵛⵛⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵙ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ, ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵜⵓⵖⴰ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⵜⴰⵔⴻⵏⵏⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("ET9_5","018_9_5","EST","9","5","5","ⵖⴻⵍⴱⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⴰⵎ ⵜⴻⵏ ⵛⵛⴰⵜⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵙ ⵡⴻⵏⵖⴰⵢ ⴷ ⵓⵀⴻⵍⵍⴻⴽ. ⴳⴳⵉⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ET9_6","018_9_6","EST","9","6","6","ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ ⵏⵖⵉⵏ ⵓ ⵀⴻⵍⵍⴽⴻⵏ ⵓⴷⴰⵢⴻⵏ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_7","018_9_7","EST","9","7","7","ⵓⵍⴰ ⴷ ⴼⴰⵔⵛⴰⵏⴷⴰⵜⴰ ⴷ ⴷⴰⵍⴼⵓⵏ ⴷ ⴰⵛⴼⴰⵜ ");
INSERT INTO rift_vpl VALUES ("ET9_8","018_9_8","EST","9","8","8","ⴷ ⴼⵓⵔⴰⵜⴰ ⴷ ⴰⴷⴰⵍⵢⴰ ⴷ ⴰⵔⵉⴷⴰⵜⴰ ");
INSERT INTO rift_vpl VALUES ("ET9_9","018_9_9","EST","9","9","9","ⴷ ⴼⴰⵔⵎⴰⵛⵜⴰ ⴷ ⴰⵔⵉⵙⴰⵢ ⴷ ⴰⵔⵉⴷⴰⵢ ⴷ ⵡⴰⵢⵣⴰⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("ET9_10","018_9_10","EST","9","10","10","ⵄⴻⵛⵔⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵀⴰⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵎⴰⴷⴰⵜ, ⵍⴻⵄⴷⵓ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵏⵖⵉⵏ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵛⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("ET9_11","018_9_11","EST","9","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷ ⵉⵊⵊ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵇⴻⴷⴷⴰ ⵏ ⵉⵎⴻⵜⵜⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_12","018_9_12","EST","9","12","12","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ: “ⴷⵉ ⵍⵇⴻⵍⵄⴰ ⵏ ⵛⵓⵛⴰⵏ ⵓⴷⴰⵢⴻⵏ ⵏⵖⵉⵏ ⵓ ⵀⴻⵍⵍⴽⴻⵏ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵍⴰ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵀⴰⵎⴰⵏ. ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⴳⴳⵉⵏ ⵄⴰⴷ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉ ⵏ ⵓⵊⴻⴵⵉⴷ? ⵎⵉⵏ ⴷⵉⵏ ⵄⴰⴷ ⵖⴰⵔⴻⵎ ⴷ ⴰⵙⵉⵜⴻⵎ? ⴰⴷ ⴰⵎ ⵉⵎⵎⴻⵡⵛ! ⵎⵉⵏ ⵜⴻⵙⵙⵉⵜⵉⵎⴻⴷ? ⴰⴷ ⵖⴰⵔⴻⵎ ⵢⵉⵍⵉ!” ");
INSERT INTO rift_vpl VALUES ("ET9_13","018_9_13","EST","9","13","13","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵏⴰ ⵉⵙⵜⵉⵔ: “ⵎⴰⵍⴰ ⵎⵍⵉⵃ ⵉ ⵓⵊⴻⴵⵉⴷ, ⴻⵊⵊ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵛⵓⵛⴰⵏ ⵓⵍⴰ ⴷ ⵜⵉⵡⴻⵛⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵣⴻⵔⴼ ⵏ ⵡⴰⵙⵙ-ⴰ, ⵓⵛⴰ ⴻⵊⵊ ⴰⴷ ⴰⵢⵍⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵀⴰⵎⴰⵏ ⵖⴰⵔ ⵜⴻⵃⵏⴰⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("ET9_14","018_9_14","EST","9","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎⴻⵏⵏⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⵔⴼ ⴷⵉ ⵛⵓⵛⴰⵏ ⵓⵛⴰ ⵓⵢⵍⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵀⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_15","018_9_15","EST","9","15","15","ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵛⵓⵛⴰⵏ, ⵎⵓⵏⴻⵏ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏ ⴰⴷⴰⵔ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜⴻⵍⵜ-ⵎⵢⴰⵜ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵛⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("ET9_16","018_9_16","EST","9","16","16","ⵎⵓⵏⴻⵏ ⵄⴰⵡⴻⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵍⴻⵀⵏⴰ ⵣⵉ ⵖⴰⵔ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ⵏⵖⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵊⴰⵔ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵛⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("ET9_17","018_9_17","EST","9","17","17","ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏ ⴰⴷⴰⵔ ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⵢⵢⵃⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ET9_18","018_9_18","EST","9","18","18","ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵛⵓⵛⴰⵏ, ⵎⵓⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵓⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵢⵢⵃⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("ET9_19","018_9_19","EST","9","19","19","ⵅ ⵓⵢⴰ ⵓⴷⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴽⴰⵎⴱⵓ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵜⵏⴻⴷⴷⴰⵎ ⴱⵍⴰ ⵍⴻⵃⵢⵓⴹ, ⴳⴳⵉⵏ ⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏ ⴰⴷⴰⵔ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵣⵣⴰⵔⴷⴻⵜ ⴷ ⵍⵅⴰⵔ, ⴰⵙⵙ ⵉ ⴷⵉ ⵙⵙⴻⴽⴽⴰⵏ ⴰⵔⵔⵉⵖⴰⵍⵓⵜ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ET9_20","018_9_20","EST","9","20","20","ⵉⵣⴻⵎⵎⴻⵎ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ-ⴰ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵢⵓⴷⵙⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ET9_21","018_9_21","EST","9","21","21","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵏ ⴰⴷ ⵃⴹⴰⵏ ⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵏ ⴰⴷⴰⵔ ⵓⵍⴰ ⴷ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵣⵣⴰⵢⴻⵙ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⴻⵖⵏⵉ ");
INSERT INTO rift_vpl VALUES ("ET9_22","018_9_22","EST","9","22","22","- ⵄⵍⴰⵃⵙⴰⴱ ⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵟⵟⴼⴻⵏ ⵓⴷⴰⵢⴻⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵢⵓⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⴱⴻⴷⴷⵍⴻⵏ ⵣⵉ ⵍⴻⵃⵣⴻⵏ ⵖⴰⵔ ⵔⴻⴼⵔⴰⵃⴻⵜ ⵓ ⵣⴻⴳ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵡⴰⵙⵙ ⴰⵚⴻⴱⵃⴰⵏ - ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵏ ⴷ ⵓⵙⵙⴰⵏ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⴰⵖⵉⵔⴰⵍⵓⵜ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⵉ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("ET9_23","018_9_23","EST","9","23","23","ⵇⴻⴱⵍⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵎⵉⵏ ⴱⴷⴰⵏ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵄⴰⴷ ⵓ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵢⵓⵔⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("ET9_24","018_9_24","EST","9","24","24","ⵎⵉⵏⵣⵉ ⵀⴰⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵎⴰⴷⴰⵜⴰ, ⴰⵊⴰⵊⵉ, ⵍⴻⵄⴷⵓ ⵏ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ, ⵜⵓⵖⴰ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⵉⵊⵊ ⵏ ⵡⴻⵏⵡⴰⵢ ⴹⵉⴷⴷ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵀⴻⵍⵍⴻⴽ, ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⴹⴰⵔ ‘ⴱⵓⵔ’, ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("ET9_25","018_9_25","EST","9","25","25","ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵉⵙⵜⵉⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵙ ⵜⵉⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵔ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵏⵡⴰⵢ-ⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⴰⵔⵔⴻⵚ ⴹⵉⴷⴷ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⵓⵛⴰ ⵓⵢⵍⴻⵏ ⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴻⵃⵏⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("ET9_26","018_9_26","EST","9","26","26","ⵅ ⵓⵢⴰ ⵍⴰⵖⴰⵏ ⵓⵙⵙⴰⵏ-ⴰ ‘ⴱⵓⵔⵉⵎ’, ⵣⴻⴳ ⵉⵙⴻⵎ ⵏ ‘ⴱⵓⵔ’. ⵅ ⵓⵢⴰ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⴻⴱⵔⴰⵜ-ⴰ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵥⵔⵉⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵙⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ET9_27","018_9_27","EST","9","27","27","ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵃⴹⴰⵏ ⵓⵙⵙⴰⵏ-ⴰ ⵓⵛⴰ ⵇⴻⴱⵍⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵙⵙⵄⴻⴷⴷⵓⵏ ⵛⴰ ⴰⴷ ⵃⴹⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ-ⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⵓⵔⴰ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴻⵇⵜ ⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("ET9_28","018_9_28","EST","9","28","28","ⵓⵛⴰ ⴰⴷ ⵉⴷⴰⵔⴻⵏ ⵓ ⴰⴷ ⵃⴹⴰⵏ ⵓⵙⵙⴰⵏ-ⴰ ⴷⵉ ⴽⵓⵍ ⵊⵊⵉⵍ, ⴷⵉ ⴽⵓⵍ ⵍⴰⴵ, ⴷⵉ ⴽⵓⵍ ⵍⵄⴰⵎⴰⵍⴰ ⵓ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵓ ⵡⴰⵔ ⵙⵙⵄⴻⴷⴷⵓⵏ ⵛⴰ ⵓⵙⵙⴰⵏ-ⴰ ⵏ ⴱⵓⵔⵉⵎ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⴰⴳⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵖⴰⵔ ⵍⵉⴷⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵙ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ET9_29","018_9_29","EST","9","29","29","ⵜⵓⵔⴰ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ, ⵢⴻⴵⵉⵙ ⵏ ⴰⴱⵉⵃⴰⵢⵉⵍ, ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵡⵓⴷⴰⵢ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⴰⵙⴻⵛⵏⵉ ⴷⵉ ⵜⴻⴱⵔⴰⵜ-ⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵅ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⴱⵓⵔⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ET9_30","018_9_30","EST","9","30","30","ⵉⵙⵙⴻⴽⴽ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵎⵢⴰ ⵓ-ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⴻⵀⵏⴰ ⴷ ⵍⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("ET9_31","018_9_31","EST","9","31","31","ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵢⵢⵛⴻⵏ ⵓⵙⵙⴰⵏ-ⴰ ⵏ ⴱⵓⵔⵉⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵡⵓⴷⴰⵢ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⵊⴻⴵⵉⴷⵜ ⵉⵙⵜⵉⵔ, ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵅ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ, ⴰⴽ-ⴷ ⵍⵓⵎⵓⵔⴰⵜ ⵅ ⵓⵥⵓⵎⵎⵉ ⴷ ⵓⵡⴻⵟⵟⵓ ⵏⵙⴻⵏ ⵏ ⵓⴳⴻⵊⴷⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("ET9_32","018_9_32","EST","9","32","32","ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵉⵙⵜⵉⵔ ⴱⴻⴷⴷⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ ⵅ ⵍⵄⵉⴷ ⵏ ⴱⵓⵔⵉⵎ ⵓⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⵔⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("ET10_1","018_10_1","EST","10","1","1","ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ ⴹⴹⴰⵔⵉⴱⴰ ⵅ ⵢⵉⵏⵏⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴷⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ET10_2","018_10_2","EST","10","2","2","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⵏ ⵊⵊⴻⵀⴷ ⴷ ⵜⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⴰⴱⴰⵔⵔⴻⵃ ⵅ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵎⵓⵔⴷⴰⵅⴰⵢ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵡⵛⵉⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵊ ⵏ ⵛⵛⴰⵏ ⵉⵎⵖⴰⵔ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵏ ⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⴰⴷⴰⵢ ⴷ ⵍⴼⵓⵔⵙ? ");
INSERT INTO rift_vpl VALUES ("ET10_3","018_10_3","EST","10","3","3","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵎⵓⵔⴷⴰⵅⴰⵢ ⴷ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵃⴰⵛⵡⵉⵔⵓⵛ, ⵓⵛⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ ⴰⵔⴹⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⵃⵙⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵍⵅⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB1_1","019_1_1","JOB","1","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵄⵓⵚ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵢⵓⴱ. ⴰⵔⵢⴰⵣ-ⴰ ⵜⵓⵖⴰ ⵉⴽⵎⴻⵍ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB1_2","019_1_2","JOB","1","2","2","ⵜⵜⵡⴰⵔⵡⴻⵏ ⴰⵙ-ⴷⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB1_3","019_1_3","JOB","1","3","3","ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⵍⵎⴰⵍ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ ⵓ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⴷ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵜⵢⵓⵢⴰⵡⵉⵏ ⵏ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⴷ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵜⴻⵖⵢⴰⵍ, ⴰⵔⵏⵉ ⵖⴰⵔⴻⵙ ⴰⴱⴰⵔⵔⵓ ⵏ ⵉⵙⴻⵎⵖⴰⵏ. ⴰⵔⵢⴰⵣ-ⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("JB1_4","019_1_4","JOB","1","4","4","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵓⵎⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵙⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵏⵏⵓⴱⴻⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵙⵙⴻⴽⴽⴻⵏ, ⵄⴰⵔⴹⴻⵏ ⵓⵍⴰ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵙⵓⵢᵉⵜⵎⴰⵜⵙⴻⵏ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵛⵛⴻⵏⵜ ⵓ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵙⵡⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB1_5","019_1_5","JOB","1","5","5","ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⴰⵡⴰⵔⵏⵉ ⵏⵏⴹⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵓⴱ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ. ⵣⵉⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵢⵉⵡⵉ ⴷⵉⵏ ⵜⵉⵖⴰⵔⵚⵉ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⵏⴻⵛⵜ ⵍⵄⴰⴷⴰⴷ ⵏ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ. ⵎⴰⵖⴰⵔ ⴰⵢⵓⴱ ⵉⵏⵏⴰ: “ⴰⴷ ⵜⴰⵖ ⵅⴹⴰⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵉⵏⵓ ⵓ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ.” ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⴰⵢⵓⴱ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JB1_6","019_1_6","JOB","1","6","6","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵔⵔⴰⵡ ⵏ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵍⴰ ⴷ ⵛⵛⵉⵟⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB1_7","019_1_7","JOB","1","7","7","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵛⴻⴽ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵛⵉⵟⴰⵏ ⵅ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵓⵙⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵜⵍⴰⵄ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴽⴽⵉⵖ ⵜⵜ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("JB1_8","019_1_8","JOB","1","8","8","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⵎⴰ ⵜⴻⵃⴹⵉⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵢⵓⴱ? ⴰⵎ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ: ⴷ ⴰⵔⵢⴰⵣ ⵉⴽⵎⴻⵍ, ⵉⴳⴳⵓⵔ ⵏⵉⵛⴰⵏ, ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("JB1_9","019_1_9","JOB","1","9","9","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵛⵉⵟⴰⵏ ⵅ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵢⵓⴱ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("JB1_10","019_1_10","JOB","1","10","10","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵇⵉ ⵉ ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ? ⴰⵇⴰ ⵜⴱⴰⵔⴽⴻⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⵎⴰⵍ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB1_11","019_1_11","JOB","1","11","11","ⵙⵡⵉⵥⵥⴻⴹ ⵎⵖⵉⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔⴻⵙ, ⵃⴰⴷⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵉⴱⴻⵄⵄⴻⴷ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JB1_12","019_1_12","JOB","1","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵎⵖⵉⵔ ⵡⴰⵔ ⴷ ⴰⵙ ⵙⵡⵉⵥⵥⵉⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵡⴰⵀⴰ!” ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵛⵛⵉⵟⴰⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB1_13","019_1_13","JOB","1","13","13","ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵢⴻⵙⵙⵉⵙ ⵜⵜᵉⵜⵜⴻⵏ ⵓ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵜⵙⴻⵏ ⴰⵎⴻⵏⵣⵓ, ⵉⵎⵙⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("JB1_14","019_1_14","JOB","1","14","14","ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: “ⵉⴼⵓⵏⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵛⴰⵔⵔⵣⴻⵏ ⵓ ⵜⵉⵖⵢⴰⵍ ⵀⴻⴷⴷⴰⵏⵜ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB1_15","019_1_15","JOB","1","15","15","ⵅⴻⵏⵏⵉ ⵀⴻⵊⵎⴻⵏ ⴰⵢⵜ ⵏ ⵛⴰⴱⴰ, ⴽⵙⵉⵏ ⵜⴻⵏ ⵓⵛⴰ ⵏⵖⵉⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵉⵏⴻⵊⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵄⴰⵡⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JB1_16","019_1_16","JOB","1","16","16","ⵓⵎⵉ ⵜⵓⵖⴰ ⵡⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵜⵉⵎⴻⵙⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵜⴰⵔⵖⴰ ⴷⴻⴳ ⵡⵓⴵⵉ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵜⴻⵛⵛⴰ ⵉ-ⵜⴻⵏ. ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵉⵏⴻⵊⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵄⴰⵡⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JB1_17","019_1_17","JOB","1","17","17","ⵓⵎⵉ ⵜⵓⵖⴰ ⵡⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⴰⵢⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ, ⵀⴻⵊⵎⴻⵏ ⵅ ⵉⵍⴻⵖⵎⴰⵏ, ⴽⵙⵉⵏ ⵜⴻⵏ ⵓⵛⴰ ⵏⵖⵉⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ. ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵉⵏⴻⵊⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵄⴰⵡⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JB1_18","019_1_18","JOB","1","18","18","ⵓⵎⵉ ⵜⵓⵖⴰ ⵡⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵢⴻⵙⵙⵉⵛ ⵛⵛⵉⵏ ⵓ ⵙⵡⵉⵏ ⴱⵉⵏⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵜⵙⴻⵏ ⴰⵎⴻⵏⵣⵓ. ");
INSERT INTO rift_vpl VALUES ("JB1_19","019_1_19","JOB","1","19","19","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵉⵡⵄⴰⵔ ⵅ ⵜⵉⵡⴰ ⵏ ⵍⴻⵅⵍⴰ, ⵉⵍⵇⴻⴼ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵜⴻⵡⴹⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵅ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⴷ ⵜⵃⵓⴷⵔⵉⵢⵢⵉⵏ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⵏⵉⵜⵏⵉ. ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵉⵏⴻⵊⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵄⴰⵡⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JB1_20","019_1_20","JOB","1","20","20","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴰⵢⵓⴱ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ, ⵉⵃⴻⴼⴼ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵉⵡⴹⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⴱⴻⵏⴷⴻⵇ, ");
INSERT INTO rift_vpl VALUES ("JB1_21","019_1_21","JOB","1","21","21","ⵉⵏⵏⴰ: “ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ ⵓ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵉ ⴷⵉⵏ ⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵖ. ⵙⵉⴷⵉ ⵉⵡⵛⴰ, ⵙⵉⴷⵉ ⵉⴽⴽⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JB1_22","019_1_22","JOB","1","22","22","ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵅⴹⵉ ⴰⵢⵓⴱ ⵛⴰ ⵓ ⵡⴰⵔ ⵉⵏⵏⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB2_1","019_2_1","JOB","2","1","1","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵔⵔⴰⵡ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵍⴰ ⴷ ⵛⵛⵉⵟⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB2_2","019_2_2","JOB","2","2","2","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵛⴻⴽ? ⵛⵛⵉⵟⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵓⵙⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵜⵍⴰⵄ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴽⴽⵉⵖ ⵜⵜ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("JB2_3","019_2_3","JOB","2","3","3","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⵎⴰ ⵜⴻⵃⴹⵉⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵢⵓⴱ? ⴰⵎ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ: ⴷ ⴰⵔⵢⴰⵣ ⵉⴽⵎⴻⵍ, ⵉⴳⴳⵓⵔ ⵏⵉⵛⴰⵏ, ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ! ⵄⴰⴷ ⵢⴰⵔⵏⵉ ⵉⵜⵜⴻⵟⵟⴻⴼ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏⵏⴻⵙ, ⵅ ⵎⵉⵏⵏⵉ ⵛⴻⴽ ⴷ ⴰⵢⵉ ⵜⵄⴰⵔⵔⵏⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵚⴰⵔⴹⴻⵖ ⵅ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("JB2_4","019_2_4","JOB","2","4","4","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵛⵉⵟⴰⵏ ⵅ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵜⵉⵍⵎⴻⵛⵜ ⵙ ⵜⴻⵍⵎⴻⵛⵜ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵜ ⵉⵡⵛ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB2_5","019_2_5","JOB","2","5","5","ⵙⵡⵉⵥⵥⴻⴹ ⵎⵖⵉⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵃⴰⴷⴰ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JB2_6","019_2_6","JOB","2","6","6","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴷⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("JB2_7","019_2_7","JOB","2","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵛⵛⵉⵟⴰⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵡⵜⴰ ⴰⵢⵓⴱ ⵙ ⵜⵃⴻⴱⴱⴰ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ, ⵣⵉ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵍ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵓⵛⴻⵇⵇⵓⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB2_8","019_2_8","JOB","2","8","8","ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⴰⵛⴻⴵⵉⵇ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵃⴻⴽⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("JB2_9","019_2_9","JOB","2","9","9","ⵜⴻⵏⵏⴰ ⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ: “ⵎⴰ ⵄⴰⴷ ⵜᵉⵜⵜⴻⵟⵟⴼⴻⴷ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏⵏⴻⵛ? ⵉⵏⵉ ⴰⵙ ⵉ ⴰⵔⴻⴱⴱⵉ: ‘ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ!’, ⵓⵛⴰ ⵎⵎⴻⵜ!” ");
INSERT INTO rift_vpl VALUES ("JB2_10","019_2_10","JOB","2","10","10","ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⴰⵡⴰⵍⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⵓⵀⴰⵍⵉⵢⵢⵉⵏ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵓⵍⴰ ⴷ ⵛⴻⵎ ⴰⵎ ⵢⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ. ⵎⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴽⴻⵙⵙⵉ ⵍⵅⴰⵔ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵏⴽⴻⵙⵙⵉ ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵍⵖⴰⵔ?” ⵙ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⵢⵓⴱ ⵡⴰⵔ ⵉⵅⴹⵉ ⵛⴰ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB2_11","019_2_11","JOB","2","11","11","ⵙⵍⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏ ⴰⵢⵓⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵉⴽⴽⵉⵏ ⴷ ⵍⵖⴰⵔ ⵓ ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⴽⵓⵍ ⵉⵊⵊ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ: ⵉⵍⵉⴼⴰⵣ ⵣⵉ ⵜⴰⵢⵎⴰⵏ, ⴱⵉⵍⴷⴰⴷ ⵣⵉ ⵛⵓⵃⴰ ⵓ ⵚⵓⴼⴰⵔ ⵣⵉ ⵏⴰⵄⵎⴰⵜ. ⴳⴳⵉⵏ ⴰⴷ ⴷⵉⵏ ⵓⵢⵓⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵙⵙⵃⵉⵙⵙⴼⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴳⴳⴻⵏ ⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("JB2_12","019_2_12","JOB","2","12","12","ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵄⵇⵉⵍⴻⵏ ⵛⴰ. ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵓⵛⴰ ⵔⵓⵏ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⵓⵢⵙⴻⵏ ⵉⵖⵖⴻⴹ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵜⵉⵡⴰ ⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB2_13","019_2_13","JOB","2","13","13","ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⴵⵉⵢⴰⵍⵉ. ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵖⴰⵔⴻⵙ, ⵎⴰⵖⴰⵔ ⵥⵔⵉⵏ, ⴰⵇⴰ ⵍⴻⵃⵔⵉⵇ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB3_1","019_3_1","JOB","3","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵢⵓⴱ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵉⵏⵄⴻⵍ ⴰⵙⵙ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB3_2","019_3_2","JOB","3","2","2","ⴰⵢⵓⴱ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB3_3","019_3_3","JOB","3","3","3","ⴰⴷ ⵉⴼⵏⴰ ⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ-ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵖ, ⵓⵍⴰ ⴷ ⴵⵉⵍⴻⵜ ⵉ ⴷⵉ ⵏⵏⴰⵏ: ‘ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵡⴰⴽⵙⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JB3_4","019_3_4","JOB","3","4","4","ⴻⵊⵊ ⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⵙⵙⴻⵇⵙⵉ ⴰⵔⴻⴱⴱⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜᵉⵜⵜⵛⴻⵄⵛⵉⵄ ⵜⴼⴰⵡⵜ ⵏ ⵓⵣⵉⵍ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB3_5","019_3_5","JOB","3","5","5","ⵉⵍⵉ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ ⴰⴷ ⵅⴰⵙ ⴰⵔⵣⵓⵏⵜ, ⴻⵊⵊ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⵜⵉⵡⴰ ⵏⵏⴻⵙ. ⵉⵍⵉ ⴰⴷ ⵅⴰⵙ ⵡⴹⴰⵏⵜ ⵜⴽⴻⴱⴱⴰⵙⵉⵏ ⵙ ⵓⵣⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JB3_6","019_3_6","JOB","3","6","6","ⴰⴷ ⵜⴻⴽⴽⴻⵙ ⵜⴽⴻⴱⴱⴰⵙⵜ ⵢⵓⴵⵖⴻⵏ ⴵⵉⵍⴻⵜ ⵏⵏⵉ, ⴻⵊⵊ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵡⴰⵔ ⵜⴼⴰⵔⵔⴻⵃ ⵊⴰⵔ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⴻⵊⵊ ⵉ-ⵜⵜ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⴷⵉ ⵍⴻⵃⵙⴰⴱ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB3_7","019_3_7","JOB","3","7","7","ⵅⵣⴰⵔ, ⴻⵊⵊ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵔⵓⵡ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵉⴷⴻⴼ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("JB3_8","019_3_8","JOB","3","8","8","ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵙⵙⴼⴻⵟⵟⵃⴻⵏ ⴰⵙⵙ, ⴰⴷ ⵜ ⵏⴻⵄⵍⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵃⴰⴽⴰⵏ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ‘ⵍⵉ$ⵉⵢⴰⵜⴰⵏ’. ");
INSERT INTO rift_vpl VALUES ("JB3_9","019_3_9","JOB","3","9","9","ⴻⵊⵊ ⴰⴷ ⵜⵜⵡⴰⴽⴻⴱⴱⵙⴻⵏ ⵉⵜⵔⴰⵏ ⵏ ⵜⵓⴼⴼⵓⵜ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵔⴰⵊⴰ ⵜⴰⴼⴰⵡⵜ, ⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ. ⴻⵊⵊ ⴰⴱⵍⵉⵡⴻⵏ ⵏ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ ⵡⴰⵔ ⵜⵜ ⵥⴰⵔⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JB3_10","019_3_10","JOB","3","10","10","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴱⴻⵍⵍⴻⵄ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵡⴰⵔ ⵉⴼⴼⴰⵔ ⵍⴻⵖⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB3_11","019_3_11","JOB","3","11","11","ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵎⵎⵓⵜⴻⵖ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴱⵓⵃⴱⴻⵍ, ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ? ");
INSERT INTO rift_vpl VALUES ("JB3_12","019_3_12","JOB","3","12","12","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵔⴰⵊⴰⵏ ⵉⴼⴰⴷⴷⴻⵏ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵉⴱⴱⴰⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵟⵟⴻⴹⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JB3_13","019_3_13","JOB","3","13","13","ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴰⴷ ⵣⵣⵍⴻⵖ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵙⵙⵇⴰⵔⴻⵖ. ⵉⵍⵉ ⴰⴷ ⵟⵟⵚⴻⵖ. ⵅⴻⵏⵏⵉ ⴱⴰⵍⴰⴽ ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵍⵀⵓⴷⵏⴻⵜ ");
INSERT INTO rift_vpl VALUES ("JB3_14","019_3_14","JOB","3","14","14","ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵉⴱⵏⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵔⵔⵡⵉⵏⴰⵜ ⵉⵅⵍⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JB3_15","019_3_15","JOB","3","15","15","ⵏⵉⵖ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵔⴻⵖ, ⵉⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("JB3_16","019_3_16","JOB","3","16","16","ⵏⵉⵖ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵄⴰⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵖⵔⴰⵢ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵜ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵙⴻⵢⵎⴰⵏ ⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵥⵔⵉⵏ ⵜⴰⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB3_17","019_3_17","JOB","3","17","17","ⴷⵉⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵉ ⵚⵚⴷⴻⵄ, ⴷⵉⵏⵏⵉ ⵜⵜⴰⵔⴻⵢⵢⴰⵃⴻⵏ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⴼⵏⴰ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB3_18","019_3_18","JOB","3","18","18","ⴷⵉⵏⵏⵉ ⵜⵜⴰⵔⴻⵢⵢⴰⵃⴻⵏ ⵉⵎⴻⵃⴱⴰⵙ ⵎⵓⵏⴻⵏ, ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵜⵜⴻⵙⵍⴰⵏ ⵄⴰⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵏ ⵉⵙⴻⵎⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB3_19","019_3_19","JOB","3","19","19","ⴰⵇⴰ ⴷⵉⵏ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵎⴻⵖ ⵉⵏⵏⵓⴼⵙⴻⵍ ⴷⵉⵏ ⵣⵉ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB3_20","019_3_20","JOB","3","20","20","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴼⴰⵡⵜ ⵉ ⵍⵎⴻⵙⴽⵉⵏ, ⵓ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵣⴻⴳ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB3_21","019_3_21","JOB","3","21","21","ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵎⴻⵥⵔⴻⵏ ⴷⵉ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵏ, ⵉⵏⵏⵉ ⵉⵖⴻⵣⵣⴰⵏ ⵅ ⵍⵎⴻⵡⵜ ⴽⵜⴰⵔ ⵅ ⵍⴻⴽⵏⵓⵣ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB3_22","019_3_22","JOB","3","22","22","ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵏⴻⴳⴳⵣⴻⵏ, ⵓ ⵜⵜⵖⴻⴱⴱⴰⵏ ⵎⴻⵥⵔⵉ ⵅⵎⵉ ⵜⵜⴰⴼⴻⵏ ⴰⵏⴹⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("JB3_23","019_3_23","JOB","3","23","23","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴼⴰⵡⵜ ⵉ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵉ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB3_24","019_3_24","JOB","3","24","24","ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉⵏⵓ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵓⵡⴻⵃⵡⴻⵃ ⵉⵏⵓ, ⵉⵖⵓⵢⵢⴰⵏ ⵉⵏⵓ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⴰⵎ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB3_25","019_3_25","JOB","3","25","25","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵖ ⵓ ⴰⵎⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵎⵉⵏ ⵣⵉ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ, ⵡⴹⵉⵖ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB3_26","019_3_26","JOB","3","26","26","ⵡⴰⵔ ⵖⴰⵔⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⵡⴰⵔ ⴰⵔⵙⵉⵖ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜⴰⵔⴻⵢⵢⵉⵃⴻⵖ. ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵅⵓⵎⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB4_1","019_4_1","JOB","4","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵍⵉⴼⴰⵣ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵜⴰⵢⵎⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB4_2","019_4_2","JOB","4","2","2","ⵎⴰⵍⴰ ⵃⴻⴷ ⵢⴰⵔⵣⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴽ ⵉⵙⵙⵉⵡⴻⵍ, ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵛⴻⴹⵏⴻⴷ ⵇⴰⵄ ⵙ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰⵛⴰ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB4_3","019_4_3","JOB","4","3","3","ⵅⵣⴰⵔ, ⵜⴻⵙⵙⵖⴰⵔⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵢⴰⵔⵅⵓⵏ ⵜⴻⵙⵙⵎⴻⵃⴹⴻⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB4_4","019_4_4","JOB","4","4","4","ⵡⴻⵏⵏⵉ ⵉⵏⵇⴰⵔⴹⴻⵏ, ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵉ-ⵜ ⵙ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ, ⵓ ⵉⴼⴰⴷⴷⴻⵏ ⵉⴼⴻⵛⵍⴻⵏ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵊⵊⴻⵀⴷ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB4_5","019_4_5","JOB","4","5","5","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵎⵙⴰⵔ ⴰⵢⴰ ⵉ ⵛⴻⴽ, ⵜᵉⵜⵜⵡⴰⵛⴻⴹⵏⴻⴷ ⵇⴰⵄ, ⵍⴻⵅⵅⵓ ⵉⵍⵇⴻⴼ ⵉ ⵛⴻⴽ ⴰⵢⴰ ⵓⵛⴰ ⵜⴰⵔⴻⵊⴼⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB4_6","019_4_6","JOB","4","6","6","ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⵓ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⴰⵢⴰⵙ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB4_7","019_4_7","JOB","4","7","7","ⵅⴻⵎⵎ ⵎⴰⵛⴰ! ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⴰⵎ ⵉⴵⴰ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵓ ⵎⴰⵏⵉ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB4_8","019_4_8","JOB","4","8","8","ⵥⵔⵉⵖ ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵣⴻⵏ ⴷⴷⴻⴵ ⴷ ⵢⵉⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵍⴻⵖⴱⴻⵏ, ⴰⴷ ⵜ ⵎⵊⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB4_9","019_4_9","JOB","4","9","9","ⴰⴷ ⵀⴻⵍⵍⴽⴻⵏ ⵣⴻⴳ ⵓⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⴼⵏⴰⵏ ⵙ ⵓⵙⵓⴹⵉ ⵣⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB4_10","019_4_10","JOB","4","10","10","ⵣⵣⵀⵉⵔ ⵏ ⵡⴻⵢⵔⴰⴷ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⵉⵣⴻⵎ ⴰⵎⴻⵥⵢⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⵏ ⵓ ⵜⵉⵖⵎⴰⵙ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB4_11","019_4_11","JOB","4","11","11","ⴰⴷ ⵉⵀⴻⵍⵍⴻⴽ ⵡⴰⵢⵔⴰⴷ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵢⵓⴼⵉ ⵣⵣⴰⵔⴷⴻⵜ, ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵢⵔⴰⴷⵜ ⴰⴷ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB4_12","019_4_12","JOB","4","12","12","ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵢⵉⵡⴻⴹ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⴰⵎⴻⵣⵣⵓⵖ ⵉⵏⵓ ⵉⵟⵟⴻⴼ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵃⵎⵉⵙ, ");
INSERT INTO rift_vpl VALUES ("JB4_13","019_4_13","JOB","4","13","13","ⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⵔⵇⴻⵖ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ ⵣⴻⴳ ⵉⵡⴻⵃⵃⴰⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴰ ⵢⵉⴹⴻⵚ ⵢⵓⴵⵖⴻⵏ ⵅ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB4_14","019_4_14","JOB","4","14","14","ⵜⴻⵍⵇⴻⴼ ⴰⵢⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵔⵊⵉⵊⵉⵜ, ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵏⵏⵅⴻⵍⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB4_15","019_4_15","JOB","4","15","15","ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵃⵔⴰⵔⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ, ⵉⵙⵙⴱⴻⴷⴷ ⴰⵛⵓⵡⵡⴰⴼ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB4_16","019_4_16","JOB","4","16","16","ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵄⵇⵉⵍⴻⵖ ⵅ ⵜⴻⴼⵔⴰⵙ ⵏⵏⴻⵙ. ⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ⵅⴻⵏⵏⵉ ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵜᵉⵜⵜⴻⵎⵜⵉⵎ, ⵜⴻⵇⵇⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("JB4_17","019_4_17","JOB","4","17","17","‘ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵉⵙⴻⴳⴳⴻⴷ ⵅ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵢⵉⵍⵉ ⵉⵚⴼⴰ ⵅ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ?’ ");
INSERT INTO rift_vpl VALUES ("JB4_18","019_4_18","JOB","4","18","18","ⵅⵣⴰⵔ, ⵡⴰⵔ ⵉⵜⵜⵛⵉⵍⵉ ⵓⵍⴰ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵍⵄⵉⴱ ⵄⴰⴷ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵓⵎⵉ ⵡⴻⴷⴷⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB4_19","019_4_19","JOB","4","19","19","ⵎⴰⵀⵓ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵓⵛⴰⵍ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵄⴻⵊⵊⴰⵊⵜ ⴷ ⴷⵙⴰⵙ ⵏⵙⴻⵏ. ⴰⵇⴰ ⴰⴷ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ ⴰⵎⴻⵣⵡⴰⵔ ⵅ ⵜⵛⵉⵏⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JB4_20","019_4_20","JOB","4","20","20","ⵣⵉ ⵜⵓⴼⴼⵓⵜ ⵏ ⵚⵚⴱⴻⵃ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ ⴰⴷ ⵜⵜⵡⴰⴼⴰⵔⵜⴽⴻⵏ. ⴱⵍⴰ ⵉ ⵉⵡⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵜⴰⵢⵏⵉⵜ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⴼⵏⴰⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JB4_21","019_4_21","JOB","4","21","21","ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵖⴰⵔⵙⴻⵏ ⵜⴻⵙⵖⵓⵏⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ? ⴰⴷ ⵎⵎⵜⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JB5_1","019_5_1","JOB","5","1","1","ⵍⴰⵖⴰ ⵎⴰⵛⴰ! ⵎⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉ ⵅⴰⴽ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ? ⵖⴰⵔ ⵎⴰⵏ ⵣⴻⴳ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉ ⵖⴰ ⵜⵙⴻⵡⴹⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JB5_2","019_5_2","JOB","5","2","2","ⵎⵉⵏⵣⵉ ⴰⵅⴻⵢⵢⴻⵇ ⵉⵏⴻⵇⵇ ⴰⴱⵓⵀⴰⵍⵉ, ⵓ ⵜⵓⵙⵎⵉ ⵜⵏⴻⵇⵇ ⴰⵇⵓⴱⴱⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JB5_3","019_5_3","JOB","5","3","3","ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵉⴹⵍⴻⵇ ⵉ ⵡⴻⵥⵡⴰⵔ, ⵎⴰⵛⴰ ⵅ ⵉⵛⵜ ⵏ ⵍⵖⴻⴼⵍⴻⵜ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴻⵄⵍⴻⵖ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB5_4","019_5_4","JOB","5","4","4","ⵉⴳⴳⵯⴻⵊⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵙⴻⵏⵊⴻⵎ, ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷⵉⵏ ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB5_5","019_5_5","JOB","5","5","5","ⵓⵎⵉ ⵉⵛⵛⴰ ⵓⵎⴻⵀⵢⵓⴼ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ - ⵡⴰⵀ, ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵄⴰⴷ ⵣⴻⴳ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ - ⵓ ⵉⵙⴰⵔⴹ ⵓⵅⴻⵡⵡⴰⵏ ⴰⴳⵍⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB5_6","019_5_6","JOB","5","6","6","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵉ ⵣⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽ ⵍⵖⴰⵔ ⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⴷⴷ-ⵜⵖⴻⵎⵎⵉ ⵜⴰⵎⴰⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("JB5_7","019_5_7","JOB","5","7","7","ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵉ ⵜⴰⵎⴰⵔⴰ, ⴰⵎ ⴳⴻⵄⵄⴷⴻⵏⵜ ⵜⵛⴻⵄⵄⴰⵍⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴹⵡⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB5_8","019_5_8","JOB","5","8","8","ⵎⵍⵉ ⵓⴼⵉⵖ ⴰⴷ ⴰⵔⵣⵓⵖ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉⵏⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("JB5_9","019_5_9","JOB","5","9","9","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵜⴻⵏⵜ ⵉ ⵖⴰ ⵉⴼⴻⵀⵎⴻⵏ, ⵉⵜⵜⴻⴳⴳ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB5_10","019_5_10","JOB","5","10","10","ⵉⵙⵙⴰⴽⴽⵯⴰⴹ ⴰⵏⵥⴰⵔ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰ ⴰⵎⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵉⵢⵢⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB5_11","019_5_11","JOB","5","11","11","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵎⵡⴰⴹⵄⴻⵏ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵛⴻⴹⵏⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⵄⵍⴰⵏ ⵖⴰⵔ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB5_12","019_5_12","JOB","5","12","12","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⵟⵟⴻⵍ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵉⵃⵔⴰⵢⵎⵉⵢⵢⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JB5_13","019_5_13","JOB","5","13","13","ⵉⵎⵉⵖⵉⵙⴻⵏ ⵉⵎⴻⵏⵏⴻⵄ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ, ⵉⵜⵜⵡⴰⵙⵙⴱⴻⵟⵟⴻⵍ ⵛⵛⵡⴰⵔ ⵏ ⵉⵃⵔⴰⵢⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB5_14","019_5_14","JOB","5","14","14","ⴷⴻⴳ ⵓⵣⵉⵍ ⵎⵎⵙⴰⴳⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵜⴰⴵⴻⵙⵜ ⵓⵛⴰ ⴷⵉ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ ⵜⵜⴼⴰⴼⴰⵏ ⴰⵎ ⵜⵜⴼⴰⴼⴰⵏ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB5_15","019_5_15","JOB","5","15","15","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵊⴰⵎ ⵣⵉ ⵙⵙⵉⴼ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB5_16","019_5_16","JOB","5","16","16","ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵍⴰⵢⴰⵙ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵓⵛⴰ ⴷⴷⴻⴵ ⴰⴷ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB5_17","019_5_17","JOB","5","17","17","ⵅⵣⴰⵔ, ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵉⵙⴻⴳⴳⴻⵎ ⴰⵔⴻⴱⴱⵉ. ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵃⵇⵉⵔⵉ ⵛⴰ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ! ");
INSERT INTO rift_vpl VALUES ("JB5_18","019_5_18","JOB","5","18","18","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵢⴻⵣⵣⵉⵎ ⴰⵢⵉ ⵙ ⵉⵊⵊ ⵏ ⵓⵢⴻⵣⵣⵉⵎ ⵉⵜⵜⴻⵇⵇⵙⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴷⴷⴰ, ⵉⵛⵛⴰⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB5_19","019_5_19","JOB","5","19","19","ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵍⴻⵃⵚⴰⵔⴰⵜ ⴰⴷ ⵛⴻⴽ ⵉⴼⴻⴽⴽ, ⴷⵉ ⵜⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵍⴻⵇⵇⴻⴼ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB5_20","019_5_20","JOB","5","20","20","ⴷⵉ ⵍⴰⵥ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵣⵉ ⵍⵎⴻⵡⵜ, ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵣⵉ ⵜⵉⵢⵢⵉⵜⴰ ⵏ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JB5_21","019_5_21","JOB","5","21","21","ⴰⴷ ⵜⵉⵍⵉⴷ ⴷⵉ ⵍⴰⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵔⴻⴽⴽⵓⴹ ⵏ ⵢⵉⵍⴻⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵛⴰ ⵣⴻⴳ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JB5_22","019_5_22","JOB","5","22","22","ⵅ ⵡⴰⵔⴻⴷⴷⴻⴵ ⴷ ⵍⴰⵥ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴹⴻⵃⵛⴻⴷ, ⵣⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("JB5_23","019_5_23","JOB","5","23","23","ⵎⴰⵖⴰⵔ ⵜⵇⴻⴹⵄⴻⴷ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵉⵥⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵅⴻⵏⵏⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JB5_24","019_5_24","JOB","5","24","24","ⴰⴷ ⵜⴰⵔⴳⴱⴻⴷ ⴰⵇⴰ ⵍⴻⵀⵏⴰ ⴷ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴱⴻⵇⵇⵛⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴰⴼⴻⴷ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JB5_25","019_5_25","JOB","5","25","25","ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⴰⵔⵔⴰⵡ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ, ⵓ ⴷⴷⵓⵔⵔⵢⴻⵜ ⵏⵏⴻⵛ ⴰⵎ ⵡⴻⴼⵙⵓ ⴰⵣⵉⵣⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB5_26","019_5_26","JOB","5","26","26","ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⴷⵉ ⵜⴻⵡⵙⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵜⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⴷⵉ ⵍⵃⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB5_27","019_5_27","JOB","5","27","27","ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⵣⵓ ⴷⴰⵢⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ! ⵙⴻⵍ ⵖⴰⵔⴻⵙ, ⵙⵙⴻⵏ ⵉ-ⵜ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("JB6_1","019_6_1","JOB","6","1","1","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB6_2","019_6_2","JOB","6","2","2","ⴰ, ⵎⵍⵉ ⵡⴻⵣⵏⴻⵏ ⵍⵀⴻⵎⵎ ⵉⵏⵓ, ⵎⵍⵉ ⵊⵊⵉⵏ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵅ ⵍⵎⵉⵣⴰⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⴰⵡⵢⴰⵜ ⵓⵍⴰ ⴷ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("JB6_3","019_6_3","JOB","6","3","3","ⵎⴰⵖⴰⵔ ⵍⴻⵅⵅⵓ ⴰⵇⴰ-ⵜ ⵉⴷⵇⴻⵍ ⵅ ⵢⴻⵊⴷⵉ ⵏ ⵍⴻⴱⵃⵓⵔ, ⵅ ⵓⵢⴰ ⵜⵜⴻⴼⴼⵖⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵏⵀⵍⴰ ⴰⵅⴻⵎⵎⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB6_4","019_6_4","JOB","6","4","4","ⵎⴰⵖⴰⵔ ⵏⵏⵓⵖⴻⵏⵜ ⴷⴰⵢⵉ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵍⴰⵎⵉ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵉⵙⴻⵙⵙ ⴰⵔⵔⵀⴰⵊ ⵏⵙⴻⵏⵜ. ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB6_5","019_6_5","JOB","6","5","5","ⵎⴰ ⵉⵙⵙⵃⵓⵏⴷⵔⵓⵜ ⵡⴻⵖⵢⵓⵍ ⵏ ⵍⴻⵅⵍⴰ ⵖⴰⵔ ⴰⵔⴱⵉⵄ ⴰⵣⵉⵣⴰ? ⵏⵉⵖ ⵉⵙⵙⵎⵓⵀⵔⵓⵜ ⵓⴼⵓⵏⴰⵙ ⵖⴰⵔ ⵀⴻⴷⴷⵓ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB6_6","019_6_6","JOB","6","6","6","ⵎⴰⵛⵛⴰ ⴱⵍⴰ ⴰⵍⴻⴷⴷⵉ ⵎⴰ ⴰⴷ ⵜⵜ ⵢⴻⵛⵛ ⴱⵏⴰⴷⴻⵎ ⴱⵍⴰ ⵜⴰⵎⴻⴵⴰⵃⵜ? ⵏⵉⵖ ⴰⵇⴰ ⴷⵉⵏ ⴰⵍⴻⴷⴷⵉ ⴷⵉ ⵍⵎⴻⵃⵃ ⴰⵛⴻⵎⵍⴰⵍ ⵏ ⵜⵎⴻⴵⴰⵍⵜ? ");
INSERT INTO rift_vpl VALUES ("JB6_7","019_6_7","JOB","6","7","7","ⵎⵉⵏ ⵢⵓⴳⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵜ ⵉⵃⴰⴷⴰ, ⵍⴻⵅⵅⵓ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⵎⴰⵛⵛⴰ ⵉⵖⵓⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB6_8","019_6_8","JOB","6","8","8","ⵎⵍⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵎⵉⵏ ⵜⵜⴰⵔⴻⵖ ⵉⵡⴰ, ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏ ⵙⵉⵜⵜⵉⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB6_9","019_6_9","JOB","6","9","9","ⵎⵍⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵍⴱⴻⵣ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴰⵔⵅⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵇⴻⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("JB6_10","019_6_10","JOB","6","10","10","ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵢⵉ ⵢⵉⵍⵉ ⵄⴰⴷ ⴷ ⴰⴼⴻⵡⵡⴻⵊ, ⴰⴷ ⴰⵢⵉ ⵉⵏⵄⴻⵛ ⴷⵉ ⵍⴻⵃⵔⵉⵇ ⵏⵏⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵙⵙⵄⵉⵣⵣⵉ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵏⴽⴰⵔⴻⵖ ⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB6_11","019_6_11","JOB","6","11","11","ⵎⵉⵏ ⵉⵄⵏⴰ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⴰⵇⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵔⴰⵊⵉⵖ ⵄⴰⴷ? ⵏⵉⵖ ⵎⵉⵏ ⵉⵄⵏⴰ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵅ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵣⵣⵓⴳⴰⵔⵜⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵄⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("JB6_12","019_6_12","JOB","6","12","12","ⵎⴰ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴰⵎ ⵊⵊⴻⵀⴷ ⵏ ⵉⵥⵔⴰ? ⵎⴰ ⴰⵢⵙⵓⵎ ⵉⵏⵓ ⴰⵎ ⵏⵏⵃⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("JB6_13","019_6_13","JOB","6","13","13","ⵎⴰ ⵡⴰⵔ ⴵⵉⵖ ⵇⴰⵄ ⴱⵍⴰ ⵜⵡⵉⵣⴰ ⵙ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵓⴼⴻⴽⴽⵉ ⵇⴰⵄ? ");
INSERT INTO rift_vpl VALUES ("JB6_14","019_6_14","JOB","6","14","14","ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵇⴹⴻⵄ ⵍⴰⵢⴰⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵣⴻⴳ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⵍⵍⴰ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴻⵊⵊ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("JB6_15","019_6_15","JOB","6","15","15","ⴰⵢⵜⵎⴰ ⴱⴰⵏⴻⵏ-ⴷⴷ ⴷ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⵎ ⵜⵖⴻⵣⵔⵉⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ, ⴰⵎ ⵜⴰⵙⵙⵓⵜ ⵏ ⵜⵖⴻⵣⵔⵉⵏ ⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ ⴷⴻⵖⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("JB6_16","019_6_16","JOB","6","16","16","ⴰⵎ ⵜⵉⵖⴻⵣⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⴻⵛⵏⴻⵏ ⵙ ⵡⴻⵊⵔⵉⵙ, ⵏⵏⵉ ⴷⵉ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵡⴻⴷⴼⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB6_17","019_6_17","JOB","6","17","17","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⴷⴻⵡⵍⴻⵏⵜ ⵃⵚⴰⵔⴻⵏⵜ, ⴱⴻⴷⴷⴻⵏⵜ, ⵅⵎⵉ ⵃⴻⵎⵎⴰⵏⵜ, ⵜⵜⴰⵥⵖⴻⵏⵜ, ⵉⵎⵃⴰ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB6_18","019_6_18","JOB","6","18","18","ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵜⴻⵛⵍⵉ ⵏⵙⴻⵏ ⴼⴰⵔⵖⴻⵏ, ⴳⴻⵄⵄⴷⴻⵏ ⴷⵉ ⵍⴻⵄⵡⵉⵏ ⵓⵛⴰ ⵡⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB6_19","019_6_19","JOB","6","19","19","ⵉⵎⵙⴻⴱⵔⵉⴷⴻⵏ ⵣⵉ ⵜⴰⵢⵎⴰ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵎⴻⵥⵔⵉⵏ ⴷⴰⵢⵙⴻⵏⵜ, ⵉⴽⴰⵔⴰ$ⴰⵏⴻⵏ ⵣⵉ ⵛⴰⴱⴰ ⵜⵜⵔⴰⵊⴰⵏ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB6_20","019_6_20","JOB","6","20","20","ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵛⴻⵎⵜⴻⵏ ⴷⴻⴳ ⵓⵜⴻⵛⵍⵉ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ. ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⵖⴻⵣⵔⵉⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⴱⴰⵔⵔⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB6_21","019_6_21","JOB","6","21","21","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵍⴻⵅⵅⵓ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵡⴰⵍⵓ, ⵜⴻⵥⵔⵉⵎ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉⵏⵓ ⵓⵛⴰ ⵜᵉⴳⴳⵯⴻⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB6_22","019_6_22","JOB","6","22","22","ⵎⴰ ⵏⵏⵉⵖ: ‘ⴰⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵛⴰ!’ ⵏⵉⵖ: ‘ⵡⵛⴻⵎ ⴰⵢⵉ ⵜⵉⵔⵣⵉⴼⵉⵏ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵡⴻⵎ!’ ");
INSERT INTO rift_vpl VALUES ("JB6_23","019_6_23","JOB","6","23","23","ⵏⵉⵖ: ‘ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ!’ ⵏⵉⵖ: ‘ⴼⴷⵉ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("JB6_24","019_6_24","JOB","6","24","24","ⵙⵖⴰⵔ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⵖⴷⴻⵖ, ⵙⵛⴻⵏ ⴰⵢⵉ ⵎⵉⵏ ⴷⵉ ⵡⴻⴷⴷⴰⵔⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("JB6_25","019_6_25","JOB","6","25","25","ⵎⴰⵎⵎⴻⵛ ⵊⴻⵀⵀⴷⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵢⴻⵛⵏⴰⵏ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵅⴻⴼ ⴰⵡⴻⴱⴱⴻⵅ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JB6_26","019_6_26","JOB","6","26","26","ⵎⴰ ⵜᵉⵜⵜⵅⴰⵔⵔⵚⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵡⴻⴱⴱⵅⴻⵎ ⵣⵣⴰⵢⵙⴻⵏ? ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⴻⴹⵄⴻⵏ ⵍⴰⵢⴰⵙ ⴰⵎ ⵍⴻⵄⵡⵉⵏ ⵉ ⴽⴻⵏⵏⵉⵡ? ");
INSERT INTO rift_vpl VALUES ("JB6_27","019_6_27","JOB","6","27","27","ⵄⴰⴷ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⵏⵉⴱⵓ ⴰⵢⵓⵊⵉⵍ ⴰⴷ ⵅⴰⵙ ⵜⴻⵏⴹⴰⵔⴻⵎ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵓ ⵄⴰⴷ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵡⴻⵎ ⴰⴷ ⵅⴰⵙ ⵜⴻⴳⴳⴻⵎ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("JB6_28","019_6_28","JOB","6","28","28","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ, ⵃⴹⴰⵎ ⵅⴰⴼⵉ ⵎⵍⵉⵃ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵖ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB6_29","019_6_29","JOB","6","29","29","ⵇⴻⴵⴱⴻⵎ ⴰⵢⵉ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴰⵢⵉ ⵢⵉⵍⵉ ⴷⴷⴻⴵ. ⵇⴻⴵⴱⴻⵎ ⴰⵢⵉ ⵄⴰⵡⴻⴷ, ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ ⵜⴱⴻⴷⴷ ⵄⴰⴷ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB6_30","019_6_30","JOB","6","30","30","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵍⵖⴻⵛⵛ ⵅ ⵢⵉⵍⴻⵙ ⵉⵏⵓ? ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵍⴻⴷⴷⵉ ⵡⴰⵏⴻⵖ ⵉⵏⵓ ⵅ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("JB7_1","019_7_1","JOB","7","1","1","ⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵎⴻⵏⵖⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵉⵎⵎⵏⴻⵖ ⴱⵏⴰⴷⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵛⴻⵡⵡⴰⵍ? ");
INSERT INTO rift_vpl VALUES ("JB7_2","019_7_2","JOB","7","2","2","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵉⵎⵙⴻⵖ ⵖⴰⵔ ⵜⵉⵍⵉ, ⴰⵎⵎⵓ ⵉⵜⵜⵔⴰⵊⴰ ⵓⵛⴻⵡⵡⴰⵍ ⵍⵎⵓⵏⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JB7_3","019_7_3","JOB","7","3","3","ⵙ ⵓⵢⴰ ⴷⴻⵡⵍⴻⵏ ⵉⵢⵓⵔⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵓⴱⴰⵔⵔⴻⵇ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵓ ⴵⵢⴰⵍⵉ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵜⴰⵎⴰⵔⴰ ⴱⴹⴰⵏ ⴰⵢⵉ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB7_4","019_7_4","JOB","7","4","4","ⵅⵎⵉ ⵜⵜⴻⵣⵣⵍⴻⵖ ⵜⵜᵉⵟⵟⵚⴻⵖ, ⵇⵇⴰⵔⴻⵖ ‘ⵎⴻⵍⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴽⴽⴰⵔⴻⵖ, ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵜⴻⵄⴷⵓ ⴵⵉⵍⴻⵜ?’ ⵊⵊⵉⵡⵏⴻⵖ ⵙ ⵍⴻⵃⵡⴻⵍ ⴰⵍ ⴷ ⵢⴻⴼⴼⵓ ⵍⵃⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB7_5","019_7_5","JOB","7","5","5","ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵜⵢⴰⵔⴹ ⴷⴻⴳ ⵉⴽⴻⵛⵛⴰⵡⴻⵏ ⵓ ⴷⵉ ⵜⴻⵇⵛⵓⵔⵉⵏ ⵏ ⵓⵛⴰⵍ, ⵜⵉⵍⵎⴻⵛⵜ ⵉⵏⵓ ⵜⵇⴻⵟⵟⴰ ⵓ ⵜᵉⵜⵜⴳⴻⵢⵢⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("JB7_6","019_7_6","JOB","7","6","6","ⴷⴻⵖⵢⴰ ⵅ ⵓⵎⴻⴽⴽⵓⴽ ⵏ ⵓⵅⴻⵢⵢⴰⴹ ⵄⴻⴷⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ, ⵄⴻⴷⴷⵓⵏ ⴱⵍⴰ ⵍⴰⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB7_7","019_7_7","JOB","7","7","7","ⵄⵇⴻⵍ, ⴰⵇⴰ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⴰⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵡⴰⵀⴰ ⵓ ⵜⵉⵟⵟ ⵉⵏⵓ ⵡⴰⵔ ⵜⵥⴰⵔⵔ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB7_8","019_7_8","JOB","7","8","8","ⵜⵉⵟⵟ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔ ⵄⴰⴷ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⴼⵉ ⵉⵍⵉⵏⵜ, ⵎⴰⵛⴰ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷⴰ ⵜⵜⵉⵍⵉⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB7_9","019_7_9","JOB","7","9","9","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴷⵓⵔⵔⵓⵇ ⵓⵙⴻⵢⵏⵓ, ⵉⵄⴻⴷⴷⵓ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵀⵡⴰ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⴳⴻⵄⵄⵉⴷ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB7_10","019_7_10","JOB","7","10","10","ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵄⵉⵇⵇⵉⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⴻⵄⵇⵉⵍ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB7_11","019_7_11","JOB","7","11","11","ⴰⵎⵎⵓ ⵉ ⵡⴰⵔ ⵜⵜⴻⵇⵇⵏⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ, ⴰⴷ ⵛⴻⵜⵛⵉⵖ ⴷⵉ ⵜⴰⵔⵣⵓⴳⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB7_12","019_7_12","JOB","7","12","12","ⵎⴰ ⵏⴻⵛⵛ ⴷ ⵍⴻⴱⵃⴰⵔ ⵏⵉⵖ ⴷ ⵍⵀⴰⵢⵛⴻⵜ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵅⴰⴼⵉ ⴰⵄⴻⵙⵙⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("JB7_13","019_7_13","JOB","7","13","13","ⵎⴰⵍⴰ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ‘ⵜⴰⵙⵙⵓⵜ ⴰⴷ ⴰⵢⵉ ⵜⵄⴻⵣⵣⴰ, ⵇⴰⵎⴰ ⵉⵏⵓ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⵙⵙⴻⵀⵡⴻⵏ ⴰⵛⴻⵜⵛⵉ ⵉⵏⵓ!’, ");
INSERT INTO rift_vpl VALUES ("JB7_14","019_7_14","JOB","7","14","14","ⴰⵎⵎⵓ ⵉⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵖⴻⵣⵣⵉⴷ ⵙ ⵜⵉⵔⵊⵉⵡⵉⵏ ⵓ ⵙ ⵉⵡⴻⵃⵃⴰⵏ ⵜⴻⵙⵙⴰⴳⴳⵯⴰⴷⴻⴷ ⴰⵢⵉ, ");
INSERT INTO rift_vpl VALUES ("JB7_15","019_7_15","JOB","7","15","15","ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⵉⵅⴹⴰⵔ ⴰⵊⴻⵢⵢⴻⴼ, ⵉⵜⵜⵉⵅⴹⴰⵔ ⵍⵎⴻⵡⵜ ⵅ ⵢⴻⵢⵙⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB7_16","019_7_16","JOB","7","16","16","ⵏⴻⵛⵛ ⵜⵜⵄⵉⴼⴼⵉⵖ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⴷⴷⴰⵔⴻⵖ ⵉ ⵍⴻⴱⴷⴰ. ⴰⵔⵅⵓ ⵣⵣⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⴰⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JB7_17","019_7_17","JOB","7","17","17","ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴰ ⵛⴻⴽ ⵜⵃⴻⵙⵙⴱⴻⴷ ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎⵎⵓ, ⴰⵇⴰ ⵜⴻⵍⵀⵉⴷ ⴰⴽⵉⴷⴻⵙ ⵙ ⵡⵓⵍ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB7_18","019_7_18","JOB","7","18","18","ⴰⵇⴰ ⵛⴻⴽ ⵜⴰⵔⴻⵣⵣⴼⴻⴷ ⵖⴰⵔⴻⵙ ⵇⴰⵄ ⴰⵜⴻⴼⴼⵓ, ⵜⵇⴻⴵⴱⴻⴷ ⵉ-ⵜ ⵇⴰⵄ ⵜⴰⵣⴻⵃⵣⵉⵀⵜ? ");
INSERT INTO rift_vpl VALUES ("JB7_19","019_7_19","JOB","7","19","19","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜᵉⵜⵜⴻⴽⴽⵙⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴰⵔⴻⵅⵅⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵖⴻⵍⵢⴻⵖ ⵉⴽⵓⴼⴼⴰⵏ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB7_20","019_7_20","JOB","7","20","20","ⵎⴰ ⵅⴹⵉⵖ? ⵎⵉⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵉ ⵛⴻⴽ, ⵉ ⵛⴻⴽ ⴰ-ⵢ-ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⴱⵏⴰⴷⴻⵎ? ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⴷ ⵜⴰⵃⵊⵓⵔⵜ ⵣⵣⴰⵜⴻⴽ, ⵓ ⴷⴻⵡⵍⴻⵖ ⴷ ⴷⴷⵇⴻⵍ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB7_21","019_7_21","JOB","7","21","21","ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵖⴻⴼⴼⴰⵔⴻⴷ ⴰⵅⴻⵟⵟⵓ ⵉⵏⵓ, ⵓ ⵡⴰⵔ ⵜⵄⴻⴷⴷⵓⴷ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ? ⵎⴰⵖⴰⵔ ⴷⴻⵖⵢⴰ ⴰⴷ ⵣⵣⵍⴻⵖ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵓ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB8_1","019_8_1","JOB","8","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵉⵍⴷⴰⴷ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵓⵃⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB8_2","019_8_2","JOB","8","2","2","ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⴷ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⴰⵎⵎⵓ, ⴰⴷ ⵉⵍⵉⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵜⵀⴰⵔⵢⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JB8_3","019_8_3","JOB","8","3","3","ⵎⴰ ⴰⴷ ⵉⵙⵙⴼⴰⵔⵖ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵙⵖⴰⵔⵜ, ⵏⵉⵖ ⴰⴷ ⵉⵙⵙⴼⴰⵔⵖ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵜⴰⵙⴻⴳⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("JB8_4","019_8_4","JOB","8","4","4","ⵎⴰⵍⴰ ⴰⴽⵉⴷⴻⵙ ⵅⴹⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵅⴻⵟⵟⵓ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB8_5","019_8_5","JOB","8","5","5","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴰⵔⴻⵣⵣⵓⴷ ⴰⵔⴻⴱⴱⵉ ⵙ ⵊⵊⴻⵀⴷ, ⵜᵉⵜⵜⵣⴰⵡⴳⴻⴷ ⴰⵃⵉⵏⵏⵉ ⵖⴰⵔ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ");
INSERT INTO rift_vpl VALUES ("JB8_6","019_8_6","JOB","8","6","6","ⵎⴰⵍⴰ ⵜⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵓ ⵜⵙⴻⴳⴳⵎⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵉⵡⵛⴰ ⵜⴰⵢⵏⵉⵜ ⵏⵉⵛⴰⵏ, ⴰⴷ ⵉⵄⴷⴻⵍ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JB8_7","019_8_7","JOB","8","7","7","ⵡⴰⵅⵅⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵓⵇⵍⵉⵍⵜ, ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB8_8","019_8_8","JOB","8","8","8","ⵡⴰⵀ, ⵙⴻⵇⵙⴰ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵊⵊⵉⵍ ⵉⵄⴷⵓⵏ, ⵃⴻⴽⴽⴰⵔ ⴷⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB8_9","019_8_9","JOB","8","9","9","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏ ⵉⴹⴻⵏⵏⴰⴹ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵡⴰⵍⵓ, ⵎⴰⵖⴰⵔ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("JB8_10","019_8_10","JOB","8","10","10","ⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵙⵙⴻⵍⵎⵉⴷⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵙⵙⵉⵡⵉⵍⴻⵏ, ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB8_11","019_8_11","JOB","8","11","11","ⵎⴰ ⵉⵖⴻⵎⵎⵉ ⵓⵖⴰⵏⵉⵎ ⵏ ⴱⴰⴱⵉⵔⵓⵙ ⴱⵍⴰ ⵙⵙⴻⴱⵅⴻⵜ, ⵎⴰ ⵉⵎⴻⵇⵇⴰⵔ ⵓⵖⴰⵏⵉⵎ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ ⴱⵍⴰ ⴰⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB8_12","019_8_12","JOB","8","12","12","ⵅⵎⵉ ⵉⵜⵜⵏⴻⵡⵡⴰⵔ, ⵡⴰⵔ ⵉⵎⵊⴰⵔ ⵄⴰⴷ, ⵉⵜⵜⴰⵥⴻⵖ ⵇⴱⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵔⴱⵉⵄ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JB8_13","019_8_13","JOB","8","13","13","ⴰⵎⵎⵓ ⵉ ⴵⴰⵏ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵓⵏ ⴰⵔⴻⴱⴱⵉ, ⵍⴰⵢⴰⵙ ⵏ ⵓⵎⵏⴰⴼⴻⵇ ⴰⴷ ⵉⴼⵏⴰ.    ");
INSERT INTO rift_vpl VALUES ("JB8_14","019_8_14","JOB","8","14","14","ⵎⵉⵏ ⵅⴻⴼ ⵉⵄⴻⵎⵎⴻⴷ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ, ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵛⴰⵍ, ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⴷ ⴰⵅⵎⴰⵍ ⵏ ⵇⵓⵏⴷⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JB8_15","019_8_15","JOB","8","15","15","ⴰⴷ ⵉⵙⴻⵏⵏⴻⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⵉ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵛⴻⴱⴱⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JB8_16","019_8_16","JOB","8","16","16","ⵏⴻⵜⵜⴰ ⴷ ⴰⵣⵉⵣⴰ ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵜⴼⵓⵛⵜ, ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⵅ ⵡⴻⵃⵡⵉⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB8_17","019_8_17","JOB","8","17","17","ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵎⵎⵓⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵢⴻⵥⵔⴰ, ⵉⵜⵜⴰⵔⵊⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴻⵥⵔⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB8_18","019_8_18","JOB","8","18","18","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵇⴻⴵⴻⵄ ⵉ-ⵜ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵉⵏⴽⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵛⴻⴽ ⵥⵔⵉⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JB8_19","019_8_19","JOB","8","19","19","ⵅⵣⴰⵔ, ⵜⴰ ⵜⴻⴵⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵖⴻⵎⵢⴻⵏ ⵣⴻⴳ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB8_20","019_8_20","JOB","8","20","20","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵏⴻⵟⵟⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴽⴻⵎⵍⴻⵏ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⴰⴼⵓⵙ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB8_21","019_8_21","JOB","8","21","21","ⵄⴰⴷ ⴰⴷ ⵉⵛⵛⵓⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵙ ⵜⴹⴻⵃⵃⴰⵛⵜ, ⵓ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("JB8_22","019_8_22","JOB","8","22","22","ⵉⵎⴻⵛⵔⴰⵀ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⴹⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵓ ⴰⵇⵉⴹⵓⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB9_1","019_9_1","JOB","9","1","1","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB9_2","019_9_2","JOB","9","2","2","ⵙⵙⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ, ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("JB9_3","019_9_3","JOB","9","3","3","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵛⴰⵔⵔⴻⵄ, ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵅ ⵡⴰⵍⴻⴼ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB9_4","019_9_4","JOB","9","4","4","ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵉⵖⵉⵙ ⵏ ⵡⵓⵍ ⴷ ⴱⵓ-ⵜⵣⴻⵎⵎⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⴷⵉ ⵍⴰⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB9_5","019_9_5","JOB","9","5","5","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵟⵟⵓⵢⴻⵏ ⵉⴷⵓⵔⴰⵔ ⴰⵎ ⵡⴰⵔ ⵜⵜ ⵜⵜⵉⵛⵉⵏ ⵉⵡⴷⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵏⴻⵇⵍⴰⴱⴻⵏ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB9_6","019_9_6","JOB","9","6","6","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵏⵀⴻⵣⵣⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB9_7","019_9_7","JOB","9","7","7","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵎⴰⵔⴻⵏ ⵜⴰⴼⵓⵛⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵜⴻⵏⵇⵉⵔ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⵎⵎⴰⵄⴻⵏ ⵉⵜⵔⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("JB9_8","019_9_8","JOB","9","8","8","ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵀⴰ ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⵉⵊⴻⵏⵡⴰⵏ, ⵏⴻⵜⵜⴰ ⵉⵚⵓⵔⵔⵓⴼ ⵜⵉⵡⴰ ⵏ ⵜⵄⵓⵔⴰⵔ ⵏ ⵍⴻⵎⵡⴰⵊ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB9_9","019_9_9","JOB","9","9","9","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵡⵔⴰⴼ ⵏ ⵉⵜⵔⴰⵏ ⵏ ⴷⴷⵓⴱ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵓⵔⵢⵓⵏ, ⴰⴳⵔⴰⵡ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵜⵔⴰⵏ ⴷ ⵉⵅⴰⵎⵎⴻⵏ ⵏ ⵍⵊⴰⵏⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("JB9_10","019_9_10","JOB","9","10","10","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, - ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⵉⴼⵀⴻⵎ - ⵓⵍⴰ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JB9_11","019_9_11","JOB","9","11","11","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵄⴻⴷⴷⵓ ⵅⴰⴼⵉ, ⵡⴰⵔ ⵜ ⵥⴰⵔⵔⴻⵖ, ⵉⵥⴻⴽⴽⵡⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵜⵜⴰⵛⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JB9_12","019_9_12","JOB","9","12","12","ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵉⵅⴹⴻⴼ ⵏⴻⵜⵜⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜ ⵖⴰ ⵉⵎⴻⵏⵄⴻⵏ? ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: ‘ⵎⵉⵏ ⴷⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵛⴻⴽ?’ ");
INSERT INTO rift_vpl VALUES ("JB9_13","019_9_13","JOB","9","13","13","ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵔⵔⵉ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ, ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⵓⴹⴰⵔⴻⵏ ⵉⵎⵄⴰⵡⴰⵏⴻⵏ ⵏ ‘ⵔⴰⵀⴰⴱ’. ");
INSERT INTO rift_vpl VALUES ("JB9_14","019_9_14","JOB","9","14","14","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴼⴰⵔⵣⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵎⵍⵉⵃ ⵣⵣⴰⵜⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB9_15","019_9_15","JOB","9","15","15","ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵣⴰⵡⴳⴻⵖ ⵍⵇⴰⴹⵉ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵉⵃⵉⵏⵏ, ");
INSERT INTO rift_vpl VALUES ("JB9_16","019_9_16","JOB","9","16","16","ⵎⴰⵍⴰ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔ ⵍⴰⵎⵉ ⵍⴰⵖⵉⵖ, ⵡⴰⵔ ⵜⵜⵖⵉⵍⴻⵖ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB9_17","019_9_17","JOB","9","17","17","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴻⴱⴱⴻⵣ ⴰⵢⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵓ ⵢⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵉⵏⵓ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JB9_18","019_9_18","JOB","9","18","18","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴰⵔⵔⴻⵖ ⵏⵏⴻⴼⵙ, ⵎⴰⵛⴰ ⵉⵙⵙⵊⴰⵡⴰⵏ ⴰⵢⵉ ⵙ ⵜⴰⵔⵣⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("JB9_19","019_9_19","JOB","9","19","19","ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷⵉ ⵊⵊⴻⵀⴷ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵀⴻⴷ ⵇⴰⵄ, ⵎⴰⵍⴰ ⴷⵉ ⵛⵛⵔⴻⵄ, ⵉⵇⵇⴰⵔ: ‘ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵄⴰⵔⴹⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("JB9_20","019_9_20","JOB","9","20","20","ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵄⴰⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴰⴷ ⵅⴰⴼⵉ ⵉⵃⴽⴻⵎ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴱⵍⴰ ⵍⵄⵉⴱ, ⵄⴰⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("JB9_21","019_9_21","JOB","9","21","21","ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴱⵍⴰ ⵍⵄⵉⴱ ⵉ ⴵⵉⵖ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵏⵉⵛⴰⵏ, ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵃⴻⵙⵙⴱⴻⵖ ⵜⵜ ⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JB9_22","019_9_22","JOB","9","22","22","ⵅ ⵓⵢⴰ ⵉ ⵖⴰ ⵉⵏⵉⵖ: ‘ⵇⴰⵄ ⴷ ⵉⵛⵜ! ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴱⵍⴰ ⵍⵄⵉⴱ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵇⴹⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JB9_23","019_9_23","JOB","9","23","23","ⵎⴰⵍⴰ ⴰⵔⴻⴽⴽⵓⴹ ⵉⵏⴻⵇⵇ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵜⴻⵀⴻⵣⵣⴰ ⵣⵉ ⵍⴻⵇⴹⴻⵄ ⵏ ⵍⴰⵢⴰⵙ ⵉ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB9_24","019_9_24","JOB","9","24","24","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵄⴻⴼⴼⴰⵏ. ⵉⵖⴻⵎⴱⴰⴱ ⵏ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵍⴻⵃⵃⴻⴼ ⴰⵙⴻⵏ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⵏⴻⵜⵜⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JB9_25","019_9_25","JOB","9","25","25","ⴷⴻⵖⵢⴰ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⴰⵇⴰ ⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ, ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴷⵉⵏ, ⵡⴰⵔ ⵜⵡⵉⵍⵉⵏ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB9_26","019_9_26","JOB","9","26","26","ⴽⴽⵉⵏ ⴰⵎ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵓⵖⴰⵏⵉⵎ, ⴰⵎ ⵓⴳⵉⴷⴻⵔ ⵉⵃⴻⵡⵡⵎⴻⵏ ⵅ ⵣⵣⴰⵔⴷⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB9_27","019_9_27","JOB","9","27","27","ⵎⴰⵍⴰ ⵏⵏⵉⵖ: ‘ⴰⴷ ⵜⵜⵓⵖ ⴰⵛⴻⵜⵛⵉ ⵉⵏⵓ, ⴰⴷ ⴱⴻⴷⴷⵍⴻⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵛⴻⴹⵏⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵙⵙⴼⵉⵔⵏⵉⵏⴻⵖ!’, ");
INSERT INTO rift_vpl VALUES ("JB9_28","019_9_28","JOB","9","28","28","ⴰⵎⵎⵓ ⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵔⵉⵇ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵛⴻⴽ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜᵉⵜⵜⴱⴰⵔⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JB9_29","019_9_29","JOB","9","29","29","ⵏⴻⵛⵛ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵢⴻⵎⵎⵉ ⵙⵙⵃⵉⵙⵙⵉⴼⴻⵖ ⵉ ⵡⴰⵍⵓ? ");
INSERT INTO rift_vpl VALUES ("JB9_30","019_9_30","JOB","9","30","30","ⵎⴰⵍⴰ ⵙⵙⵉⵔⴷⴻⵖ ⵙ ⵡⴰⵎⴰⵏ ⵏ ⵡⴻⴷⴼⴻⵍ, ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵙ ⵍⵍⵉⵅⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("JB9_31","019_9_31","JOB","9","31","31","ⵄⴰⴷ ⴰⴷ ⴰⵢⵉ ⵜⵏⴻⵜⵢⴻⴷ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵢⴰⵔⵚⵓⴷⴻⵏ, ⴰⵍ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵄⵉⴼⴼ ⵡⴰⵔⵔⵓⴹ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB9_32","019_9_32","JOB","9","32","32","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵅⵎⵉ ⵏⴻⵜⵜⴰⵡⴻⴹ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JB9_33","019_9_33","JOB","9","33","33","ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⵄⴰⴷⴻⵍ ⵊⴰⵔ ⴰⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅⴰⵏⴻⵖ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB9_34","019_9_34","JOB","9","34","34","ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵅⴰⴼⵉ ⵉⴽⵙⵉ ⴰⵄⵎⵓⴷ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ ⵄⴰⴷ ⵓⵀⵓⴷⴷⵉ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB9_35","019_9_35","JOB","9","35","35","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵏⵀⵍⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⵯⴻⴷⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴰⵎⵎⵓ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB10_1","019_10_1","JOB","10","1","1","ⵉⵜⵜⵄⵉⴼⴼⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⴰⵛⴻⵜⵛⵉ ⵉⵏⵓ ⴰⵎⵎⵓ ⵡⴰⵀⴰ ⴱⵍⴰ ⴰⵎⵏⴰⵄ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⵜⴰⵔⵣⵓⴳⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB10_2","019_10_2","JOB","10","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⴰⵔⴻⴱⴱⵉ: ‘ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⴳⴳ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵙⵛⴻⵏ ⴰⵢⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⴰⴽⵉⴷⵉ ⵜᵉⵜⵜⵎⴻⵏⵖⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JB10_3","019_10_3","JOB","10","3","3","ⵎⴰ ⵖⴰⵔⴻⴽ ⵍⴻⴼⴹⴻⵍ ⴰⵇⴰ ⵛⴻⴽ ⵜⵃⴻⵚⵚⴰⵔⴻⴷ ⴰⵢⵉ, ⴰⵇⴰ ⵜⵏⴻⵟⵟⴰⵔⴻⴹ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⴰⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵜⴰⴼⴰⵡⵜ ⵅ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB10_4","019_10_4","JOB","10","4","4","ⵎⴰ ⵖⴰⵔⴻⴽ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⵍⴰⵏ ⵉⵡⴷⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB10_5","019_10_5","JOB","10","5","5","ⵎⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏ ⴱⵏⴰⴷⴻⵎ? ⵎⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵡⴻⵔⵢⴰⵣ, ");
INSERT INTO rift_vpl VALUES ("JB10_6","019_10_6","JOB","10","6","6","ⴰⵇⴰ ⵛⴻⴽ ⵜⴰⵔⴻⵣⵣⵓⴷ ⴰⵎⵎⵓ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⵜᵉⵜⵜⴱⴻⵇⵇⵛⴻⴷ ⴷⵉ ⴷⴷⵏⵓⴱ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB10_7","019_10_7","JOB","10","7","7","ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB10_8","019_10_8","JOB","10","8","8","ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵅⴻⵍⵇⴻⵏ ⴰⵢⵉ, ⴳⴳⵉⵏ ⴰⵢⵉ, ⴰⵇⴰ ⵜⵜⴻⵏⵏⴹⴻⵏ ⴰⵢⵉ, ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵛⴻⴽ ⵜⵚⴰⵔⴹⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB10_9","019_10_9","JOB","10","9","9","ⵄⵇⴻⵍ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⴰⵎ ⵜⴰⵔⵔⵉⵙⵜ, ⵓ ⵖⴰⵔ ⵜⵄⴻⵊⵊⴰⵛⵜ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴰⵔⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB10_10","019_10_10","JOB","10","10","10","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵣⴻⴵⵄⴻⴷ ⴰⵎ ⵓⵖⵉ, ⴰⵎ ⴽⵉⵙⵓ ⵜⴻⵊⵊⵉⴷ ⴰⵢⵉ ⴰⴷ ⵛⵛⵔⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JB10_11","019_10_11","JOB","10","11","11","ⵙ ⵜⴻⵍⵎⴻⵛⵜ ⴷ ⵡⴻⵢⵙⵓⵎ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⴷ ⴰⵢⵉ, ⵙ ⵉⵖⵙⴰⵏ ⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵜⴻⵎⵎⵓⴷⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB10_12","019_10_12","JOB","10","12","12","ⵜⵓⴷⴰⵔⵜ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⴻⵏⵜ, ⴰⵃⴻⵟⵟⵓ ⵏⵏⴻⵛ ⵉⵃⴹⴰ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB10_13","019_10_13","JOB","10","13","13","ⵜⵅⴻⵎⵎⵍⴻⴷ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⴰⵢⴰ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔⴻⴽ ⴷⵉ ⵍⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB10_14","019_10_14","JOB","10","14","14","ⵎⴰⵍⴰ ⵅⴹⵉⵖ, ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵃⴹⵉⴷ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴱⴰⵔⵔⵉⴷ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB10_15","019_10_15","JOB","10","15","15","ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵍⵖⴰⵔ, ⵓⵛⵜ ⵅⴰⴼⵉ! ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉ ⴵⵉⵖ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ. ⵊⵊⵉⵡⵏⴻⵖ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵜⵜⴰⵛⵉⵖ ⴰⴽ-ⴷ ⵍⴻⵎⵃⴰⵢⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB10_16","019_10_16","JOB","10","16","16","ⵎⴰⵍⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⴷ ⴰⵢⵉ ⵜⵏⴻⵢⵎⴰⵔⴻⴷ ⴰⵎ ⵡⴰⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ, ⵍⴻⴱⴷⴰ ⵜᵉⵜⵜⵏⴻⵇⵍⴰⴱⴻⴷ ⵅⴰⴼⵉ ⵙ ⵍⵖⴻⴼⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB10_17","019_10_17","JOB","10","17","17","ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵍⴻⴱⴷⴰ ⵉⵛⴻⵀⵀⴰⴷⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵜⴰⵔⵏⵉⴷ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵅⴰⴼⵉ, ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵉ ⵉⵅⴻⴵⴼⴻⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵀ, ⴰⴷ ⵖⴰⵔⵉ ⵜⵏⴻⴷⵀⴻⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB10_18","019_10_18","JOB","10","18","18","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ? ⵎⵍⵉ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴱⵓⵃⴱⴻⵍ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵟⵟ!’ ");
INSERT INTO rift_vpl VALUES ("JB10_19","019_10_19","JOB","10","19","19","ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⵅⵎⵉ ⵡⴰⵔ ⵉⵍⵉⵖ ⵄⴻⵎⵎⴰⵔⵚ, ⵎⵎⴻⴽⵙⵉⵖ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("JB10_20","019_10_20","JOB","10","20","20","ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵓⴷⵔⵓⵙⴻⵏ? ⵎⵍⵉ ⴷ ⴰⵢⵉ ⵉⵊⵊⴰ, ⴰⴷ ⵅⴰⴼⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴰⵔⵀⴻⵖ ⵛⵡⴰⵢⵜ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("JB10_21","019_10_21","JOB","10","21","21","ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ - ⵡⴰⵔ ⴷⵉⴽⴽⵡⵉⵍⴻⵖ ⵄⴰⴷ - ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("JB10_22","019_10_22","JOB","10","22","22","ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ ⴰⵎ ⵜⵎⴻⴷⴷⵉⵜ, ⴰⵎ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⴱⵉⵏ ⵡⴰⵍⵓ, ⵎⴰⵏⵉ ⵜⴻⴳⴳⴰ ⵜⴼⴰⵡⵜ ⴰⵎ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JB11_1","019_11_1","JOB","11","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵚⵓⴼⴰⵔ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵏⴰⵄⵎⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB11_2","019_11_2","JOB","11","2","2","ⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⴱⵍⴰ ⵜⴰⵎⵡⴰⵔⵔⵉⵜ, ⵓ ⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵓⵇⴻⵎⵎⵓⵎ ⵍⵃⴻⵇⵇ ⵍⴻⴱⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("JB11_3","019_11_3","JOB","11","3","3","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵛ ⴰⴷ ⵉⵙⵙⵖⴻⴷ ⵉⵡⴷⴰⵏ, ⴰⵍⴰⵎⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵜⴻⵀⵣⵉⴷ ⴱⵍⴰ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵙⵙⴻⵃⵛⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ? ");
INSERT INTO rift_vpl VALUES ("JB11_4","019_11_4","JOB","11","4","4","ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ: ‘ⵜⴻⵚⴼⴰ ⵜⵖⵓⵔⵉ ⵉⵏⵓ, ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ!’ ");
INSERT INTO rift_vpl VALUES ("JB11_5","019_11_5","JOB","11","5","5","ⵓⵀ, ⵎⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵙⵙⴰⵡⴰⵍ, ⵎⵍⵉ ⵢⴰⵔⴻⵣⵣⴻⵎ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB11_6","019_11_6","JOB","11","6","6","ⵎⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵉⵙⵙⵛⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵅⴻⵎⵎⵍⴻⵏ ⵏ ⵜⵉⵖⵉⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵙⴻⴽⴽⵡⴰⵏⵜ ⴷⴷⵓⴱⴻⵍ ⵉ ⵓⴼⴻⴽⴽⵉ. ⵙⵙⴻⵏ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵜⵜⵓ ⴰⵟⵟⴰⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ ⴷⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB11_7","019_11_7","JOB","11","7","7","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴱⴻⵇⵇⵛⴻⴷ ⴷⵉ ⵎⵓⵎⵎⵓ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ? ");
INSERT INTO rift_vpl VALUES ("JB11_8","019_11_8","JOB","11","8","8","ⴰⵇⴰ-ⵜⴻⵏ ⴷⵉ ⵍⵓⵄⵍⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ! ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵄⴰⴷ? ⵜⵉⵖⵉⵜ ⵜⵓⴵⴻⵖ ⵅ ⵍⴰⵅⴰⵔⵜ! ⵎⵉⵏ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵙⵏⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JB11_9","019_11_9","JOB","11","9","9","ⵍⴻⵄⴱⴰⵔ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰ ⴰⵟⵟⴰⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⴻⵄⴷⵓ ⴰⵟⵟⴰⵙ ⵅ ⵜⵎⵉⵔⵉⵡⵜ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB11_10","019_11_10","JOB","11","10","10","ⵎⴰⵍⴰ ⵉⵄⴷⵓ ⵏⴻⵜⵜⴰ, ⵉⴱⴻⵍⵍⴻⵄ ⵅ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵙ ⵉ ⴷⴷⴻⵄⵡⴻⵜ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB11_11","019_11_11","JOB","11","11","11","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵉⵖⴻⵛⵛⴰⵛⴻⵏ, ⵉⵜⵜⵡⴰⵍⴰ ⵍⵖⴻⵛⵛ ⴱⵍⴰ ⵎⴰ ⵜ ⵉⵃⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JB11_12","019_11_12","JOB","11","12","12","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴼ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⵖⵢⵓⵍ ⵏ ⵍⴻⵅⵍⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB11_13","019_11_13","JOB","11","13","13","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵄⴻⴷⵍⴻⴷ ⵓⵍ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⴱⴻⵣⵣⴻⵄ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB11_14","019_11_14","JOB","11","14","14","ⵎⴰⵍⴰ ⵉⵔⵚⴻⵇ ⵍⵖⴻⵛⵛ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵙⴰⴳⴳⵯⴻⵊ ⵉ-ⵜ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴷⴷⴻⴵ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⵇⵉⴷⵓⵏⵉⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("JB11_15","019_11_15","JOB","11","15","15","ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴱⵍⴰ ⵍⵄⵉⴱ, ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵏⵉⵛⴰⵏ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JB11_16","019_11_16","JOB","11","16","16","ⵎⴰⵖⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵓⴷ ⵍⴻⵖⴱⴻⵏ ⵏⵏⴻⵛ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⵅⴻⵎⵎⵉⵎⴻⴷ ⵄⴰⴷ ⴰⵎ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⵅⴻⵎⵎⵉⵎⴻⴷ ⵄⴰⴷ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JB11_17","019_11_17","JOB","11","17","17","ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⵖ ⵜⵉⵡⴰ ⵅ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ, ⵡⴰⵅⵅⴰ ⴷⵉⵏ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵜⴻⴼⴼⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JB11_18","019_11_18","JOB","11","18","18","ⴰⴷ ⵜⴰⵛⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⵍⴰⵢⴰⵙ, ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ, ⴰⴷ ⵜᵉⵟⵟⵚⴻⴷ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB11_19","019_11_19","JOB","11","19","19","ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ ⵏⵀⵍⴰ ⵛⴻⴽ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵣⴰⵡⴳⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB11_20","019_11_20","JOB","11","20","20","ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴷⴷⴰⵔⵖⵍⴻⵏⵜ, ⵇⴰⵄ ⵜⴰⵔⴻⵡⵍⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵡⴻⴷⴷⴰⵔ, ⴰⴷ ⵎⴻⵥⵔⴻⵏ ⴰⴷ ⴷⴻⵍⵇⴻⵏ ⵉ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JB12_1","019_12_1","JOB","12","1","1","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB12_2","019_12_2","JOB","12","2","2","ⴷ ⵜⵉⴷⴻⵜⵜ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⴷⴷⴰⵔⴱ ⵏ ⵍⴳⴻⵏⵙ, ⴰⵇⴰ ⵜⵉⵖⵉⵜ ⴰⴷ ⵜⴻⵎⵎⴻⵜ ⴰⴽⵉⴷⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("JB12_3","019_12_3","JOB","12","3","3","ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵍⴻⵄⵇⴻⵍ ⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵡⴻⵟⵟⵉⵖ ⴷⴻⴳ ⵓⵎⵇⵓⴷⴷⵉ ⴰⴽⵉⴷⵡⴻⵎ. ⵡⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("JB12_4","019_12_4","JOB","12","4","4","ⵏⴻⵛⵛ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵜⵙⴻⴹⵃⴰⵛ ⵉ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵖⴰⵔⵉ, ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵙⴻⴹⵃⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JB12_5","019_12_5","JOB","12","5","5","‘ⵍⵃⴻⴳⵔⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵥⴰⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵢⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⵇⵔⴰⴹⴻⵏ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_6","019_12_6","JOB","12","6","6","ⵉⵇⵉⴹⴰⵏ ⵏ ⵉⵎⵜⴻⵃⵃⴰⵢⵢⴻⵏ ⴰⵔⵙⴰⵏ, ⵓ ⵉⵏⵏⵉ ⵉⵙⴻⵄⵄⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⴰⵎⴰⵏ. ⵎⴰⵛⴰ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⴰⵡⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB12_7","019_12_7","JOB","12","7","7","ⵙⴻⵇⵙⴰ ⵅⴻⵏⵏⵉ ⵍⵎⴰⵍ, ⴰⴷ ⴰⵛ ⵜ ⵙⵙⵍⴻⵎⴷⴻⵏ, ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵛⴻⴽ ⵜ ⵃⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_8","019_12_8","JOB","12","8","8","ⵏⵉⵖ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵎⵍⵉⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵛⴻⴽ ⵜⴻⵙⵙⵖⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⴰⵛ ⵜ ⵄⴰⵡⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_9","019_12_9","JOB","12","9","9","ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰⵇⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉ ⵜ ⵉⴳⴳⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("JB12_10","019_12_10","JOB","12","10","10","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⴵⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⴱⵓⵃⴱⴻⵍ ⵏ ⴽⵓⵍ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB12_11","019_12_11","JOB","12","11","11","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵇⴻⴵⵉⴱ ⵓⵎⴻⵣⵣⵓⵖ ⴰⵡⴰⵍⴻⵏ, ⴰⵎ ⵉⵜⵜⵇⴰⵙⴰ ⵡⴰⵏⴻⵖ ⵎⴰⵛⵛⴰ? ");
INSERT INTO rift_vpl VALUES ("JB12_12","019_12_12","JOB","12","12","12","ⵖⴰⵔ ⵉⵡⴻⵙⵙⵓⵔⴰ ⵉ ⵜⴻⴵⴰ ⵜⵉⵖⵉⵜ ⵓ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵜⴰⵣⵉⵔⴰⵔⵜ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JB12_13","019_12_13","JOB","12","13","13","ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵉ ⵜⴻⴵⴰ ⵜⵉⵖⵉⵜ ⴷ ⵊⵊⴻⵀⴷ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵉ ⵢⴻⴵⴰ ⵛⵛⵡⴰⵔ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_14","019_12_14","JOB","12","14","14","ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵀⴻⴷⴷⴻⵎ, ⵡⴰⵔ ⵉⴱⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵄⴰⵡⴻⴷ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴻⵍⵍⴻⵄ ⵅ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴰⵔⴻⵣⵣⴻⵎ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB12_15","019_12_15","JOB","12","15","15","ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵎⴰⵏ, ⴰⴷ ⴰⵥⵖⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵍⴰ ⵢⴰⵔⵅⵓ ⴰⵙⴻⵏ, ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB12_16","019_12_16","JOB","12","16","16","ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵊⵊⴻⵀⴷ ⴷ ⵓⴼⴻⴽⴽⵉ, ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_17","019_12_17","JOB","12","17","17","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵊⵊⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵛⵛⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⵙ ⵍⴻⵃⴼⴰ, ⵍⵇⵓⴹⴰⵜ ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_18","019_12_18","JOB","12","18","18","ⴰⵣⵉⵢⵢⴰⵔ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵙⵙⴱⴻⵟⵟⴻⵍ ⵉ-ⵜ ⵓ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴻⴷⴷⴰ ⵉ-ⵜⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_19","019_12_19","JOB","12","19","19","ⵏⴻⵜⵜⴰ ⵉⵏⴻⴷⴷⴻⵀ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙ ⵍⴻⵃⴼⴰ, ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵉⵖⴻⵟⵟⴻⵔ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_20","019_12_20","JOB","12","20","20","ⵉⵜⵜⴻⴽⴽⴻⵙ ⴰⵡⴰⵍ ⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⵇⴻⴵⴱⴻⵏ, ⵉ ⵉⵡⴻⵙⵙⵓⵔⴰ ⵉⵜⵜⴻⴽⴽⴻⵙ ⴰⵙⴻⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB12_21","019_12_21","JOB","12","21","21","ⴰⵙⴻⵃⵇⴰⵔ ⵉⵜⵜⵣⴻⴵⴰⵄ ⵉ-ⵜ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵉ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⵉⵙⵙⴰⵔⴻⵅⵅⵓ ⴰⵙⴻⵏ ⴰⴱⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB12_22","019_12_22","JOB","12","22","22","ⵉⵎⵓⵛⴰⵏ ⵢⵓⴵⵖⴻⵏ ⵏ ⵜⴰⴵⴻⵙⵜ ⵉⵜⵜⵄⴰⵔⵔⴰ ⵅⴰⵙⴻⵏ, ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵉ-ⵜⵜ ⵖⴰⵔ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB12_23","019_12_23","JOB","12","23","23","ⵍⴻⴳⵏⵓⵙ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵖⴻⵟⵟⴻⵔ ⵉ-ⵜⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵉⵏⴻⴷⴷⴻⵃ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_24","019_12_24","JOB","12","24","24","ⵉⵜⵜⴻⴽⴽⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⵜⵜᵉⵜⵍⵉⵄⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵎⴰⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵉⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB12_25","019_12_25","JOB","12","25","25","ⵏⵉⵜⵏⵉ ⵜⵜⴻⵎⵀⴰⴼⴰⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⴼⴰⵡⵜ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵎⵎⵀⴰⴼⴰⵏ ⴰⵎ ⵢⵉⵎⴻⵙⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB13_1","019_13_1","JOB","13","1","1","ⵅⵣⴰⵔ, ⵇⴰⵄ ⵎⴰⵏ ⴰⵢⴰ ⵜⴻⵥⵔⴰ ⵉ-ⵜ ⵜⵉⵟⵟ ⵉⵏⵓ, ⵉⵙⵍⴰ ⵉ-ⵜ ⵓⵎⴻⵣⵣⵓⵖ ⵉⵏⵓ, ⵉⴼⵀⴻⵎ ⴰⵙ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("JB13_2","019_13_2","JOB","13","2","2","ⵎⵉⵏ ⵜⴻⵙⵙⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵙⵙⵏⴻⵖ ⵜ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵡⴻⵟⵟⵉⵖ ⵛⴰ ⴷⴻⴳ ⵓⵙⴻⵎⵇⵓⴷⴷⵉ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB13_3","019_13_3","JOB","13","3","3","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵎⴻⵥⵔⴻⵖ ⴰⴷ ⵡⵜⴻⵖ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB13_4","019_13_4","JOB","13","4","4","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵓⴼⴼⵓⵖⴻⵎ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴹⴱⵉⴱⴻⵏ ⵉⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB13_5","019_13_5","JOB","13","5","5","ⴰⵅ, ⵎⵍⵉ ⵜⴻⵙⵙⴻⵖⴷⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ! ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵉⵖⵉⵜ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JB13_6","019_13_6","JOB","13","6","6","ⵙⵍⴻⵎ ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵡⵜⴻⵖ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵃⴻⴽⴽⴰⵔⴻⵎ ⵅ ⵓⵎⵛⴰⵔⵔⴰⵄ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JB13_7","019_13_7","JOB","13","7","7","ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵉⵏⵉⵎ ⵍⵖⴻⵛⵛ ⵉ ⵍⴻⴼⴹⴻⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB13_8","019_13_8","JOB","13","8","8","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵡⵜⴻⵎ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵛⴰⵔⵔⵄⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("JB13_9","019_13_9","JOB","13","9","9","ⵎⴰ ⵎⵍⵉⵃ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴻⴵⴻⴱ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵜⴻⵀⵣⴰⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵜᵉⵀⴻⵣⵣⴰⵏ ⵉⵡⴷⴰⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JB13_10","019_13_10","JOB","13","10","10","ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵡⴻⴱⴱⴻⵅ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JB13_11","019_13_11","JOB","13","11","11","ⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⵎⴰ ⵡⴰⵔ ⴷⴷ ⵅⴰⵡⴻⵎ ⵜⵡⴻⵟⵟⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB13_12","019_13_12","JOB","13","12","12","ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⴻⵎⵜⵓⵍ ⵏ ⵡⴰⵍⵓ, ⵍⴻⴳⵄⵓⴷⵉ ⵏⵡⴻⵎ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵓⴱⴻⴵⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JB13_13","019_13_13","JOB","13","13","13","ⵙⴻⵖⴷⴻⵎ ⵣⵣⴰⵜⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ, ⴻⵊⵊ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵙ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB13_14","019_13_14","JOB","13","14","14","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵟⵟⴼⴻⵖ ⴰⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵊⴰⵔ ⵜⴻⵖⵎⴰⵙ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵖⴰ ⵟⵟⴼⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB13_15","019_13_15","JOB","13","15","15","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴷ ⴰⵢⵉ ⵉⵏⴻⵖ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵔⴰⵊⵉⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵡⵜⴻⵖ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB13_16","019_13_16","JOB","13","16","16","ⴷ ⵡⴰ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴰⵎⵏⴰⴼⴻⵇ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB13_17","019_13_17","JOB","13","17","17","ⵙⵍⴻⵎ ⵎⵍⵉⵃ ⵖⴰⵔ ⵍⵀⴰⵔⴷ ⵉⵏⵓ, ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵖⴰⵔ ⵓⵛⴰⵔⵔⴻⵃ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB13_18","019_13_18","JOB","13","18","18","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ ⴷⴷⴻⵄⵡⴻⵜ ⵙ ⵓⵙⴻⵜⵜⴻⴼ, ⵙⵙⵏⴻⵖ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB13_19","019_13_19","JOB","13","19","19","ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⵉⴷⵉ ⵉⵎⵛⴰⵔⵔⵄⴻⵏ? ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⴻⵖⴷⴻⵖ ⴷⴻⵖⵢⴰ, ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JB13_20","019_13_20","JOB","13","20","20","ⵎⵖⵉⵔ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⴳⴳ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵃⵡⴰⵢⴻⵊ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵜⵜⵏⵓⴼⴼⴰⵔⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("JB13_21","019_13_21","JOB","13","21","21","ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵙⵉⴳⴳⵯⴻⵊ ⵉ-ⵜ ⵅⴰⴼⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵏⴻⵅⵍⵉⵄ ⵙ ⵓⵀⵓⴷⴷⵉ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("JB13_22","019_13_22","JOB","13","22","22","ⵍⴰⵖⴰ ⵛⴻⴽ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵏⵉⵖ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵓ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("JB13_23","019_13_23","JOB","13","23","23","ⵎⴻⵛⵃⴰⵍ ⵅⴰⴼⵉ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷ ⴷⴷⴻⵏⴱ? ⵙⵛⴻⵏ ⴰⵢⵉ ⴰⵅⴻⵟⵟⵓ ⵉⵏⵓ ⴷ ⴷⴷⴻⵏⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB13_24","019_13_24","JOB","13","24","24","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ, ⵜⵃⴻⵙⵙⴱⴻⴷ ⴰⵢⵉ ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB13_25","019_13_25","JOB","13","25","25","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴻⵏⵅⴻⵍⵄⴻⴷ ⵜⴰⴼⴰⵔⵛⵜ ⵉ ⵉⵄⴰⵔⵔⴻⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ, ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴹⴼⴰⵔⴻⴷ ⵉⵖⴻⴵ ⵢⵓⵥⵖⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB13_26","019_13_26","JOB","13","26","26","ⵎⴰⵖⴰⵔ ⵜᵉⵜⵜⴰⵔⵉⴷ ⵅⴰⴼⵉ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴰⵔⵣⴰⴳⵉⵏ, ⵜⴱⴻⵟⵟⵉⴷ ⴰⵢⵉ ⴷⴷⵏⵓⴱ ⵏ ⵜⴻⵎⵥⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB13_27","019_13_27","JOB","13","27","27","ⵜⴻⵙⵙⵔⵓⵙⵉⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ, ⵛⴻⴽ ⵜⵃⴻⵟⵟⵉⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵙⵔⴰⵇ ⵉⵏⵓ. ⵜⵃⴻⵟⵟⵉⴷ ⵜⵉⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB13_28","019_13_28","JOB","13","28","28","ⵏ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵎ ⵓⴽⴻⵛⵛⵓⴹ, ⵛⵛⵉⵏ ⵜ ⵉⴽⴻⵛⵛⴰⵡⴻⵏ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⵛⵛⴰ, ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵛⴰ ⵉ-ⵜ ⵜⵛⵉⵏⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JB14_1","019_14_1","JOB","14","1","1","ⴱⵏⴰⴷⴻⵎ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ, ⴰⵇⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⴷⵔⵓⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⵃⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JB14_2","019_14_2","JOB","14","2","2","ⵏⴻⵜⵜⴰ ⵉⵖⴻⵎⵎⵉ ⴰⵎ ⵜⵏⴻⵡⵡⴰⵛⵜ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ. ⵉⵜⵜⵔⴰⴽⴽⵡⴰⵍ ⴰⵎ ⵜⵉⵍⵉ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("JB14_3","019_14_3","JOB","14","3","3","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⴰⵔⴻⵣⵎⴻⴷ ⵜⵉⵡⴰ ⵏⵏⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵜᵉⵜⵜⴰⵡⵢⴻⴷ ⴰⵢⵉ-ⴷⴷ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JB14_4","019_14_4","JOB","14","4","4","ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⴰⴳ ⵣⴻⴳ ⵓⵎⴻⵅⵎⵓⵊ? ⵓⵍⴰ ⴷ ⵉⵊⵊ! ");
INSERT INTO rift_vpl VALUES ("JB14_5","019_14_5","JOB","14","5","5","ⵎⴰⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵓⵔⵉⵏ, ⵍⵇⴻⴷⴷ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔⴻⴽ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵙ ⵍⴻⵃⴷⵓⴷ ⵏⵏⴻⵙ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵏ ⵉⵄⴷⵓ, ");
INSERT INTO rift_vpl VALUES ("JB14_6","019_14_6","JOB","14","6","6","ⵏⴻⵇⵍⴻⴱ ⵅⴻⵏⵏⵉ ⵅⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ, ⴰⵍⴰⵎⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵡⵡⴰⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB14_7","019_14_7","JOB","14","7","7","ⵎⴰⵖⴰⵔ ⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⵍⴰⵢⴰⵙ! ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙ, ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ ⵍⴻⴼⵔⵓⵄ, ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵏ ⵣⴻⴳ ⵓⵖⴻⵎⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("JB14_8","019_14_8","JOB","14","8","8","ⵡⴰⵅⵅⴰ ⵉⵡⵙⴰⵔ ⵡⴻⵥⵡⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵎⵎⵓⵜ ⵊⵊⴷⴻⵄ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵛⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("JB14_9","019_14_9","JOB","14","9","9","ⴰⴷ ⵜⴻⵖⵎⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵄⴰⵡⴻⴷ ⵅⵎⵉ ⵖⴰ ⵜⴰⵛⴰ ⴰⴽ-ⴷ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ ⵍⴻⴼⵔⵓⵄ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵥⵥⵓⵏ ⵜⵜ ⴱⴻⵃⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JB14_10","019_14_10","JOB","14","10","10","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⴼⴻⵏⵏⴰ, ⵎⴰⵍⴰ ⵉⴼⴼⴻⵖ ⴰⵙ ⴱⵓⵃⴱⴻⵍ ⵉ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵏⵉ ⵉⴵⴰ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JB14_11","019_14_11","JOB","14","11","11","ⴰⵎⴰⵏ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ, ⵉⵖⵣⴰⵔ ⵉⵜⵜⴰⵥⴻⵖ ⵓ ⵉⵅⴻⴽⴽⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JB14_12","019_14_12","JOB","14","12","12","ⵉⵣⵣⴻⵍ ⴱⵏⴰⴷⴻⵎ ⴷⵉⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽⴰⵔ ⵄⴰⴷ. ⴰⵍ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴰⵔ ⴷ ⵜⵜⴼⵉⵇⵉⵏ, ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵣⴻⴳ ⵉⴹⴻⵚ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB14_13","019_14_13","JOB","14","13","13","ⴰⵅ, ⵎⵍⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⴰⵔⵔⴻⴷ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⴰⵍ ⵖⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵎⵍⵉ ⴷ ⴰⵢⵉ ⵜⵓⵔⵉⴷ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵉⵎⵜⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵉⴷⴰⵔⴻⴷ ⵄⴰⵡⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("JB14_14","019_14_14","JOB","14","14","14","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵎⵎⵓⵜ, ⵎⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ? ⵅⴻⵏⵏⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵔⴰⵊⵉⵖ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉⵏⵓ, ⴰⵍ ⴷⴷ-ⵢⵓⵙⴰ ⵓⴼⴻⴽⴽⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB14_15","019_14_15","JOB","14","15","15","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⵜⵍⴰⵖⵉⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵎⵎⴻⵥⵍⴻⴷ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB14_16","019_14_16","JOB","14","16","16","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⵃⴻⵙⵙⴱⴻⴷ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵎⴻⵏⵏⵄⴻⴷ ⵍⵖⴰⴹⴰⴱ ⵏⵏⴻⵛ ⵅ ⴷⴷⵏⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB14_17","019_14_17","JOB","14","17","17","ⴰⵅⴻⵟⵟⵓ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵛⴻⵎⵎⴻⵄ ⴷⵉ ⵜⵛⴻⵎⵎⵓⵙⵜ, ⵖⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ ⵜⴰⵔⵏⵉⴷ ⴷⴰⵢⴻⵙ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB14_18","019_14_18","JOB","14","18","18","ⵡⴰⵀ, ⴰⴷⵔⴰⵔ ⵉⵡⴻⵟⵟⴰⵏ, ⵉⴼⴻⵙⵙⵉ, ⵊⴰⵔⴼ ⵉⵃⵔⵓⴵⴻⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB14_19","019_14_19","JOB","14","19","19","ⴰⵎⴰⵏ ⵜⵜⴻⴷⴷⵣⴻⵏ ⵉⵥⵔⴰ, ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵙ ⵜⵜⴻⴽⴽⵙⴻⵏ ⴰⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵜⴰⵔⴻⴷⴷⴵⴻⴷ ⵍⴰⵢⴰⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB14_20","019_14_20","JOB","14","20","20","ⵛⴻⴽ ⵜⴰⵔⴻⵏⵏⵉⴷ ⴷⴰⵢⴻⵙ ⵉ ⵍⴻⴱⴷⴰ, ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ. ⵜᵉⵜⵜⴱⴻⴷⴷⴰⵍⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("JB14_21","019_14_21","JOB","14","21","21","ⵎⴰⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵟⵟⴼⴻⵏ ⵛⵛⴰⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ, ⵎⴰⵍⴰ ⵜⴻⵏ ⴷⴻⴵⴻⵏ, ⵡⴰⵔ ⴽⵉⴷⵙⴻⵏ ⵉⵜⵜⵉⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("JB14_22","019_14_22","JOB","14","22","22","ⵎⴰⵛⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵏⴻⵣⴱⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵓ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⴻⵛⴹⵉⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB15_1","019_15_1","JOB","15","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵍⵉⴼⴰⵣ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵜⴰⵢⵎⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB15_2","019_15_2","JOB","15","2","2","ⵎⴰ ⵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⵉⵖⵉⵙ ⵙ ⵜⵓⵙⵙⵏⴰ ⵉⵅⵡⴰⵏ? ⵎⴰ ⴰⴷ ⵉⵛⵛⵓⵔ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("JB15_3","019_15_3","JOB","15","3","3","ⵎⴰ ⵉⵜⵜⵛⴰⵔⵔⴰⵄ ⵙ ⵍⵀⴰⵔⴷ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ, ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB15_4","019_15_4","JOB","15","4","4","ⵛⴻⴽ ⵜⴰⵔⵥⵉⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⴽⴽⵙⴻⴷ ⵜⴰⵥⴰⴵⵉⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB15_5","019_15_5","JOB","15","5","5","ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵛ ⵍⵀⴰⵔⴷ ⵙ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB15_6","019_15_6","JOB","15","6","6","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵉⵃⴽⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵛⵛ, ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⴽ ⵛⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB15_7","019_15_7","JOB","15","7","7","ⵎⴰ ⵛⴻⴽ ⴷ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ? ⵏⵉⵖ ⵜᵉⵜⵜⵡⴰⵔⵡⴻⴷ ⵇⴱⴻⵍ ⵜⵉⵡⵔⵉⵔⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("JB15_8","019_15_8","JOB","15","8","8","ⵎⴰ ⵜⴻⵙⵙⵃⴻⵙⵙⴻⴷ ⵉ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰ ⵜⵊⴻⴱⴱⴷⴻⴷ ⵜⵉⵖⵉⵜ ⵖⴰⵔⴻⴽ? ");
INSERT INTO rift_vpl VALUES ("JB15_9","019_15_9","JOB","15","9","9","ⵎⵉⵏ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ, ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵜ ⵏⴻⵙⵙⵉⵏ? ⵎⵉⵏ ⵜⴼⴻⵀⵀⵎⴻⴷ ⵛⴻⴽ, ⴰⵇⴰ ⵉⵏⵇⴻⵚ ⵖⴰⵔⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JB15_10","019_15_10","JOB","15","10","10","ⵓⵍⴰ ⵊⴰⵔ ⴰⵏⴻⵖ ⴷ ⴰⵎⵛⴰⵢⴱⵓ ⴷ ⵓⵡⴻⵙⵙⴰⵔ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵅ ⴱⴰⴱⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JB15_11","019_15_11","JOB","15","11","11","ⵎⴰ ⴰⵙⴼⴻⵡⵡⴻⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵔⵓⵙ ⵖⴰⵔⴻⴽ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵙⵙⵉⵡⵍⴻⵏ ⵜ ⴰⴽⵉⴷⴻⴽ ⵙ ⵜⴻⵔⵖⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JB15_12","019_15_12","JOB","15","12","12","ⵎⴰⵢⴻⵎⵎⵉ ⵛⴻⴽ ⵉⵙⵙⴻⵜⵍⴰⵄ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵎⴰⵢⴻⵎⵎⵉ ⵇⴻⴵⵄⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("JB15_13","019_15_13","JOB","15","13","13","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵇⵍⴰⴱⴻⴷ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵛ ⵅ ⴰⵔⴻⴱⴱⵉ, ⴰⵍⴰⵎⵉ ⵜⴻⵙⵙⵓⴼⴼⵓⵖⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB15_14","019_15_14","JOB","15","14","14","ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JB15_15","019_15_15","JOB","15","15","15","ⵅⵣⴰⵔ, ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵛⵉⵍ, ⵓⵍⴰ ⴷ ⵉⵊⴻⵏⵡⴰⵏ ⵡⴰⵔ ⴵⵉⵏ ⵚⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("JB15_16","019_15_16","JOB","15","16","16","ⴰⵀⵜⴰⵜ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴱⵓ-ⵓⴼⴻⵙⵙⴰⴷ, ⵡⴻⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴰⵎ ⵡⴰⵎⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("JB15_17","019_15_17","JOB","15","17","17","ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴰⵛ ⵜ ⵙⵙⴻⵛⵏⴻⵖ, ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵄⴰⵡⴷⴻⵖ ⵎⵉⵏ ⵥⵔⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("JB15_18","019_15_18","JOB","15","18","18","ⵎⵉⵏ ⵄⴰⵡⴷⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⴰⵎ ⵡⴰⵔ ⴼⴼⴰⵔⴻⵏ ⵛⴰ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB15_19","019_15_19","JOB","15","19","19","ⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵀⴰ ⵓⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵅⴰⵙ ⵉⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("JB15_20","019_15_20","JOB","15","20","20","ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵉⴷⴷⴰⵔ ⵓⵄⴻⴼⴼⴰⵏ, ⵉⵎⴰⵔⵔⴻⵜ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⵉⵜⵜⵡⴰⵅⴻⵎⵎⵍⴻⵏ ⵉ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ, ⴰⵇⴰ ⵉⵏⵓⴼⴼⴰⵔ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB15_21","019_15_21","JOB","15","21","21","ⵢⵓⴷⴻⴼ-ⴷⴷ ⵍⵃⴻⵙⵙ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵉⵙⵙⵏⴻⵅⵍⴰⵄⴻⵏ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ. ⵄⴰⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⵅⴰⵙ ⵉⵡⴹⴰ ⵓⵎⵜⴻⵃⵃⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JB15_22","019_15_22","JOB","15","22","22","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵔⵉⵊⵉ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵣⵉ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵉ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JB15_23","019_15_23","JOB","15","23","23","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵎⵀⴰⴼⴰ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵅ ⵡⴻⵖⵔⵓⵎ. ‘ⴰ, ⵎⴰⵏⵉ ⵉ ⵢⴻⴵⴰ?’ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵉ-ⵜ ⵡⴰⵙⵙ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JB15_24","019_15_24","JOB","15","24","24","ⴹⴹⵉⵇⴻⵜ ⴷ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏⵜ ⵏⴻⵜⵜⴰ, ⴰⵔⵏⵉⵏⵜ ⵉ-ⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵡⵊⴻⴷ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JB15_25","019_15_25","JOB","15","25","25","ⵎⴰⵖⴰⵔ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵡⵉⵥⵥⴰⴹ ⵏⴻⵜⵜⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴽ-ⴷ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⵎⴻⵏⵏⴻⵄ ⵜⴰⵖⴻⵏⵏⴰⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB15_26","019_15_26","JOB","15","26","26","ⵙ ⵢⵉⵔⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⵓⴼⵔⴰⵔ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵙ ⵉⴱⵓⵟⵓⵏⴻⵏ ⵉⴳⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB15_27","019_15_27","JOB","15","27","27","ⵎⴰⵖⴰⵔ ⵉⵍⴻⵃⵃⴻⴼ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵙ ⵜⴰⴷⵓⵏⵜ, ⵉⴳⴳⴰ ⵜⴰⴷⵓⵏⵜ ⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB15_28","019_15_28","JOB","15","28","28","ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ, ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵜⵉⵏⵏⵉ ⵢⵓⵔⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JB15_29","019_15_29","JOB","15","29","29","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ, ⵎⴰⵍⴰ ⵎⵉⵏ ⴷⴷ-ⵉⴽⵙⴻⴱ ⵡⴰⵔ ⵢⴰⵔⴻⵏⵏⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB15_30","019_15_30","JOB","15","30","30","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵏⴻⵊⵊⴻⵎ ⵉ ⵜⴰⴵⴻⵙⵜ, ⴰⵛⴻⵄⵄⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ ⴰⴷ ⵢⴻⵛⵛ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴼⵏⴰ ⵙ ⵍⴻⵄⵡⵉⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB15_31","019_15_31","JOB","15","31","31","ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵉⵜⵜⵛⵉⵍⵉ ⵅ ⵍⵖⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⴷ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JB15_32","019_15_32","JOB","15","32","32","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵄⴰⴷ ⵡⴰⵙⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵄⴰⴷ, ⵎⴰⵖⴰⵔ ⵜⴰⵙⴻⵟⵟⴰ ⵏ ⵜⵉⵏⵉ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵣⴻⵢⵣⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JB15_33","019_15_33","JOB","15","33","33","ⴰⴷ ⵉⵙⵙⴻⵖⴹⴻⵍ ⴰⴹⵉⵍ ⵡⴰⵔ ⵉⵙⵙⵏⴻⴷⵢⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ, ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵏⵏⵓⵡⴰⵔ ⵏⵏⴻⵙ ⴰⵎ ⵜⵣⵉⵜⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB15_34","019_15_34","JOB","15","34","34","ⵎⴰⵖⴰⵔ ⴰⴱⴰⵔⵔⵓ ⵏ ⵉⵎⵏⴰⴼⵇⴻⵏ ⴰⵇⴰ-ⵜ ⴱⵍⴰ ⵍⵖⵉⴵⴻⵜ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵜᵉⵜⵜⴻⵜⵜ ⵉⵇⵉⴹⴰⵏ ⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JB15_35","019_15_35","JOB","15","35","35","ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵣⵉ ⵜⴰⵎⴰⵔⴰ, ⵜⵜⵓⵔⵡⴻⵏ ⵍⵖⴻⵛⵛ, ⵍⴻⵅⴷⴻⵄ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB16_1","019_16_1","JOB","16","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB16_2","019_16_2","JOB","16","2","2","ⵎⴰⵏⴰⵡⵢⴰ ⵙⵍⵉⵖ ⴰⵙ ⴰⵟⵟⴰⵙ, ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵎ ⵜⴻⵙⵙⴱⴻⵟⵟⵍⴻⵎ ⴰⵢⵉ ⴰⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JB16_3","019_16_3","JOB","16","3","3","ⵎⴰ ⴰⴷ ⵇⴹⴰⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ? ⵏⵉⵖ ⵎⵉⵏ ⵛⴻⴽ ⵉⵄⴰⵔⵔⵏⴻⵏ ⵄⴰⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⴰⵡⴰⵍ? ");
INSERT INTO rift_vpl VALUES ("JB16_4","019_16_4","JOB","16","4","4","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵍⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵓ. ⵉⵍⵉ ⴰⴷ ⵎⵓⴷⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵅⴰⵡⴻⵎ ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵀⴻⵣⵣⴻⵖ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB16_5","019_16_5","JOB","16","5","5","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⴻⵃⴹⴻⵖ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵓ ⴰⴼⴻⵡⵡⴻⵊ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ ⴰⴷ ⴰⵡⴻⵎ ⵢⴰⵡⵉ ⵍⴻⴼⵙⴰⵙⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB16_6","019_16_6","JOB","16","6","6","ⵎⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵖ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⴻⵊⵊⵉ ⵍⴻⵃⵍⵉⵇ ⵉⵏⵓ ⵓ ⵎⴰⵍⴰ ⵙⵙⴻⵖⴷⴻⵖ, ⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⵃⴻⵢⵢⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JB16_7","019_16_7","JOB","16","7","7","ⵍⴻⵅⵅⵓ ⵉⵙⵙⵉⵃⴻⵍ ⴰⵢⵉ ⵏⴻⵜⵜⴰ, ⵜⴻⵙⵙⴰⵔⵊⴼⴻⴷ ⵛⴻⴽ ⵎⴰⵔⵔⴰ ⵜⴰⵡⴰⵛⵓⵏⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB16_8","019_16_8","JOB","16","8","8","ⵛⴻⴽ ⵜⴻⵙⵙⴷⵓⵔⵓⵢⴻⴷ ⴰⵢⵉ ⵙ ⵜⴻⵇⵛⵓⵔⵜ ⵏ ⵜⴻⵍⵎⴻⵛⵜ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵛⴻⵀⵀⴰⴷⵜ ⵅⴰⴼⵉ, ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ ⵅⴰⴼⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵜⴰⵎⵓⵙⵔⵉⵡⵜ, ⵜᵉⵜⵜⵛⴻⵜⵛⴰ ⵣⵣⴰⵢⵉ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB16_9","019_16_9","JOB","16","9","9","ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⵎⴻⵣⵣⴻⵇ, ⵉⴹⴻⴼⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⴻⵣⵣⴰ ⵖⴰⵔⵉ ⵜⵉⵖⵎⴰⵙ. ⴰⵖⵔⵉⵎ ⵉⵏⵓ ⵉⵙⵙⵇⴻⵟⵟⴰⵄ-ⴷⴷ ⵖⴰⵔⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB16_10","019_16_10","JOB","16","10","10","ⵏⵉⵜⵏⵉ ⵜⵜⵛⴰⵔⵔⴰⴳⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵅⴰⴼⵉ, ⵛⵛⴰⵜⴻⵏ ⴰⵢⵉ ⵙ ⵍⵃⴻⴳⵔⴰ ⵖⴰⵔ ⵓⵇⴰⴱⵙⵉ, ⵜⵜⴻⴽⴽⴰⵔⴻⵏ ⵅⴰⴼⵉ ⵜⵜⵎⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB16_11","019_16_11","JOB","16","11","11","ⵉⵙⴻⵍⵍⴻⵎ ⴰⵢⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵉⵄⴰⵔⵔⴻⵏ ⴰⵢⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB16_12","019_16_12","JOB","16","12","12","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵥⴰ ⴰⵢⵉ, ⵉⵛⴻⴱⴱⴰⵔ ⴰⵢⵉ ⴷⴻⴳ ⵉⵊⵉⵎⴰⵏ, ⵉⵍⴱⴻⵣ ⴰⵢⵉ. ⵉⵙⵙⴱⴻⴷⴷ ⴰⵢⵉ ⴷ ⵜⴰⵃⵊⵓⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB16_13","019_16_13","JOB","16","13","13","ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏⵏⴻⵙ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⵏⵓⵇⵇⵓⴱ ⴰⵢⵉ ⵜⵉⵥⵥⴰⵍ ⴱⵍⴰ ⴰⵀⴰⵡⴻⵍ, ⵉⵜⵜⵣⴻⴵⴰⵄ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵥⵉ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB16_14","019_16_14","JOB","16","14","14","ⵢⴰⵔⴻⵥⵥⴰ ⴰⵢⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵖⵏⵉ, ⵉⵄⵔⴻⴼ-ⴷⴷ ⵅⴰⴼⵉ ⴰⵎ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JB16_15","019_16_15","JOB","16","15","15","ⵅⴻⵢⵢⴹⴻⵖ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵉⵏⵓ, ⵉⵛⵛ ⵉⵏⵓ ⵙⵙⵡⴻⵙⵙⵅⴻⵖ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JB16_16","019_16_16","JOB","16","16","16","ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵉⵣⵡⴻⵖ ⵣⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ ⴰⵇⴰ-ⵜⵜ ⵅ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB16_17","019_16_17","JOB","16","17","17","ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵢⴰⵔⵙⵉ ⵍⵄⵓⵏⴼ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵓ ⵜⴰⵥⴰⴵⵉⵜ ⵉⵏⵓ ⵜⴻⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JB16_18","019_16_18","JOB","16","18","18","ⵓⵀ ⵜⴰⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⴷⴷⴰⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵉⵖⵓⵢⵢⴰⵏ ⵉⵏⵓ ⴰⴷ ⴰⴼⴻⵏ ⴰⵎⵛⴰⵏ ⵉ ⴰⵔⵔⴰⵃⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("JB16_19","019_16_19","JOB","16","19","19","ⵅⵣⴰⵔ, ⵓⵍⴰ ⴷ ⵍⴻⵅⵅⵓ, ⴰⵛⴻⵀⵀⴰⴷ ⵉⵏⵓ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵛⴰⴼⴻⵄ ⵉⵏⵓ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB16_20","019_16_20","JOB","16","20","20","ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ ⴷ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉⵙⵜⵀⴻⵣⵣⴰⵏ, ⵎⴰⵛⴰ ⵜᵉⵜⵜⵔⵓ ⵜⵉⵟⵟ ⵉⵏⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB16_21","019_16_21","JOB","16","21","21","ⴻⵊⵊ-ⵉ-ⵜ ⴰⴷ ⵉⵡⵡⴻⵜ ⴷⴷⴻⵄⵡⴻⵜ ⵅ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB16_22","019_16_22","JOB","16","22","22","ⵎⴰⵖⴰⵔ ⴷⵔⵓⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ-ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵄⴰⴷ, ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ ⴰⴱⵔⵉⴷ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB17_1","019_17_1","JOB","17","1","1","ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵢⴰⵔⵊⴻⴼ, ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵅⴻⵙⵢⴻⵏ, ⵎⵖⵉⵔ ⵉⵎⴻⴹⵍⴰⵏ ⴷ ⴰⵢⵉ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB17_2","019_17_2","JOB","17","2","2","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⵏⵏⵉ ⵉⵙⵜⴻⵀⵣⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⵉ, ⵓ ⵜⵉⵟⵟ ⵉⵏⵓ ⵜⴻⵙⵙⵄⴻⴷⴷⵓ ⴵⵉⵍⴻⵜ ⵊⴰⵔ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ ⵉⵎⴰⵔⵣⴰⴳⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JB17_3","019_17_3","JOB","17","3","3","ⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵏⴻⵛⵛ ⴷⵉⵏ ⵖⴰⵔⴻⴽ. ⵎⴰⵏ ⵡⴻⵏ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵉ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("JB17_4","019_17_4","JOB","17","4","4","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴽⴽⵙⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵅ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵅ ⵓⵢⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵙⵙⵄⵓⴵⵉⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JB17_5","019_17_5","JOB","17","5","5","ⵡⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵏⵄⴻⴷⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB17_6","019_17_6","JOB","17","6","6","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵢⵉ ⴷ ⵍⵎⴰⵜⴰⵍ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵙⵙⵓⵙⵓⴼⴻⵏ ⴰⵙ ⵅ ⵓⵖⴻⵎⴱⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JB17_7","019_17_7","JOB","17","7","7","ⵙ ⵓⵢⴰ ⵉ ⵜⴻⵄⵎⴻⵛ ⵜⵉⵟⵟ ⵉⵏⵓ ⵣⴻⴳ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("JB17_8","019_17_8","JOB","17","8","8","ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵏ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵎⴻⵣⴷⴰⴳ ⵉⵜⵜⵏⴻⵇⵍⴰⴱ ⵅ ⵓⵎⵏⴰⴼⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("JB17_9","019_17_9","JOB","17","9","9","ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵎⴻⵏⵏⴻⵄ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵊⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB17_10","019_17_10","JOB","17","10","10","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ, ⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⴰⵙⴻⵜⵜⵉⵡ-ⴷⴷ ⴷⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵉⵖⵉⵙ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB17_11","019_17_11","JOB","17","11","11","ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ, ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵉⵏⵡⴰⵢⴻⵏ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵎⴻⵥⵔⵉ ⵏ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB17_12","019_17_12","JOB","17","12","12","ⴵⵉⵍⴻⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵜ ⴷ ⴰⵙⵙ, ⵇⵇⴰⵔⴻⵏ: ⴰⵇⴰ ⵜⴰⴼⴰⵡⵜ ⵜᵉⵜⵜⴰⴷⴻⵙ-ⴷⴷ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⵡⴹⴰ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JB17_13","019_17_13","JOB","17","13","13","ⵎⴰⵍⴰ ⵙⵙⵉⵜⵎⴻⵖ ⵄⴰⴷ, ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⵇⴰ ⵍⴰⵅⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⴰⴷ ⴱⴻⵣⵣⵄⴻⵖ ⵜⴰⵙⵙⵓⵜ ⵉⵏⵓ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JB17_14","019_17_14","JOB","17","14","14","ⵖⴰⵔ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⵍⴰⵖⵉⵖ: ‘ⵛⴻⴽ ⴷ ⴱⴰⴱⴰ!’, ⵖⴰⵔ ⵉⴽⴻⵛⵛⴰ: ‘ⵢⴻⵎⵎⴰ!’ ⴷ: ‘ⵓⵍⵜⵎⴰ!’ ");
INSERT INTO rift_vpl VALUES ("JB17_15","019_17_15","JOB","17","15","15","ⵎⴰⵏⵉ ⵉⴵⴰ ⵅⴻⵏⵏⵉ ⵍⴰⵢⴰⵙ ⵉⵏⵓ? ⵍⴰⵢⴰⵙ ⵉⵏⵓ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⵥⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JB17_16","019_17_16","JOB","17","16","16","ⴰⴷ ⵀⵡⴰⵏ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ ⵏ ⵍⴰⵅⴰⵔⵜ, ⵅⵎⵉ ⵉ ⵖⴰ ⵏⴰⴼ ⵏⵎⵓⵏ ⴰⵔⵔⴰⵃⴻⵜ ⴷⴻⴳ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB18_1","019_18_1","JOB","18","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵉⵍⴷⴰⴷ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵓⵃⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB18_2","019_18_2","JOB","18","2","2","ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ ⵜⴰⵔⴻⵣⵣⵓⵎ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ? ⵎⴰⵍⴰ ⵜⴼⴻⵀⵎⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⴰ ⴰⴷ ⵏⴻⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JB18_3","019_18_3","JOB","18","3","3","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵡⴰⴳⴳ ⴰⵎ ⵍⵎⴰⵍ ⵓ ⵏⴻⵜⵜⵡⴰⵃⵚⴰⵔ ⴷⵉ ⴱⵓⵃⴱⴻⵍ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JB18_4","019_18_4","JOB","18","4","4","ⵛⴻⴽ, ⴰ ⵢⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵎⴻⵣⵣⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ! ⵎⴰ ⴰⴷ ⵊⵊⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵟⵟⵉ ⵊⵊⴰⵔⴼ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ?    ");
INSERT INTO rift_vpl VALUES ("JB18_5","019_18_5","JOB","18","5","5","ⵡⴰⵀ, ⵜⴰⴼⴰⵡⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⴻⵅⵙⵉ, ⴰⵛⴻⵄⵄⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵜⴰⴼⴰⵡⵜ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB18_6","019_18_6","JOB","18","6","6","ⵜⴰⴼⴰⵡⵜ ⴷⵉ ⵜⵇⵉⴷⵓⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴱⴱⴰⵔⵛⴻⵏ, ⵍⴻⴼⵏⴰⵔ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵙⵙⵅⴻⵙⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB18_7","019_18_7","JOB","18","7","7","ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵛⵛⵡⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵉⵖⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JB18_8","019_18_8","JOB","18","8","8","ⵎⴰⵖⴰⵔ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵏⵏⴰⵖ ⴷⴻⴳ ⵓⵚⴻⵏⵏⴰⵊ, ⴰⴷ ⵢⵓⵢⵓⵔ ⵅ ⵜⵔⴰⵛⵛⴰ, ⵎⵎⵓⴷⴻⵏ ⵜⵜ ⵉ ⵜⵏⴻⵢⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB18_9","019_18_9","JOB","18","9","9","ⵜⴰⵅⵛⴻⴼⵜ ⴰⴷ ⵜ ⵜⴻⵎⵏⴻⵄ ⵣⴻⴳ ⵓⵏⵉⵔⵣ, ⵍⴼⴻⵅ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜᵉⵟⵟⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("JB18_10","019_18_10","JOB","18","10","10","ⵜⴻⵏⵏⵓⴼⴼⴰⵔ ⵜⴻⵙⵖⵓⵏⵜ ⵏ ⵍⴼⴻⵅ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⴼⴻⵅ ⴰⵇⴰ-ⵜⵜ ⵅ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JB18_11","019_18_11","JOB","18","11","11","ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏ ⵜ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB18_12","019_18_12","JOB","18","12","12","ⵉⵜⵜⵡⴰⵃⵚⴰⵔ ⴷⴰⵢⴻⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⴰⴹⴻⵢⵢⴻⵄ ⵉⵜⵜⵔⴰⵊⴰ ⵉ-ⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB18_13","019_18_13","JOB","18","13","13","ⴰⵔⵥⵉⵢⵢⴻⵜ ⴰⴷ ⵜⴻⵛⵛ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵢⴻⵛⵛ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⴰⵛ ⵉⵏⴻⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB18_14","019_18_14","JOB","18","14","14","ⵎⵉⵏⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵜⵜⵛⴻⵍ, ⵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵣⵉ ⵜⵇⵉⴹⵓⵏⵜ ⵏⵏⴻⵙ. ⵜⵏⴻⴷⴷⴻⵀ ⵉ-ⵜ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB18_15","019_18_15","JOB","18","15","15","ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵢⵉⵏⵏⵉ ⵏⵏⴻⵙ, ⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ, ⵍⴻⵛⴱⴰⵔⵉⵢⵢⴻⵜ ⵜᵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB18_16","019_18_16","JOB","18","16","16","ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ ⵜⵜⴰⵥⵖⴻⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ, ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB18_17","019_18_17","JOB","18","17","17","ⵍⵉⴷⴰⵔⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵉⵙⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB18_18","019_18_18","JOB","18","18","18","ⴰⴷ ⵜ ⵄⴰⵔⵏⴻⵏ ⵣⵉ ⵜⴼⴰⵡⵜ ⵖⴰⵔ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵙⵙⵜⴻⵡⵡⵊⴻⵏ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JB18_19","019_18_19","JOB","18","19","19","ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵡⴰⵔⵔⴰⵡ ⵏⵉⵖ ⵊⵊⴰⴷⵉⵔⴰ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⴷⴷⴰⵔ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB18_20","019_18_20","JOB","18","20","20","ⵅ ⵡⴰⵙⵙ ⵏⵏⴻⵙ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⴷ ⵜⴻⵏ ⵜᵉⵟⵟⴻⴼ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB18_21","019_18_21","JOB","18","21","21","ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⴻⵎⵙⴰⵔ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏ ⵉⵎⴻⵇⵊⴰⵃⴻⵏ, ⵡⴰ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_1","019_19_1","JOB","19","1","1","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB19_2","019_19_2","JOB","19","2","2","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⵎ ⵜⵛⴻⴹⵏⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰⴷ ⴰⵢⵉ ⵜⵍⴻⴱⵣⴻⵎ ⵙ ⵡⴰⵡⴰⵍⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB19_3","019_19_3","JOB","19","3","3","ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵜⴻⴽⴽⵡⴰⵔⴻⵎ ⴰⵢⵉ, ⵡⴰⵔ ⵜᵉⵜⵜⵙⴻⴹⵃⵉⵎ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⵖⴻⵟⵟⵍⴻⵎ ⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB19_4","019_19_4","JOB","19","4","4","ⵎⴰⵍⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴻⴷⴷⴰⵔⴻⵖ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵡⴻⴷⴷⴰⵔ ⵉⵏⵓ ⵉ ⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB19_5","019_19_5","JOB","19","5","5","ⵎⴰⵍⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵛⵛⵉⴽⵉ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴻⵏⵄⴻⵎ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB19_6","019_19_6","JOB","19","6","6","ⵙⵏⴻⵎ ⵅⴻⵏⵏⵉ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵅⴰⴼⵉ, ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⴰⵢⵉ-ⴷⴷ ⵙ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB19_7","019_19_7","JOB","19","7","7","ⵅⵣⴰⵔ, ⵙⵖⵓⵢⵢⵓⵖ: ‘ⵍⴻⵅⵛⵓⵏⴻⵜ!’, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵜⵜⵍⴰⵖⵉⵖ ⵉ ⵜⵡⵉⵣⴰ, ⵎⴰⵛⴰ ⵍⵃⴻⵇⵇ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_8","019_19_8","JOB","19","8","8","ⴰⴱⵔⵉⴷ ⵉⵏⵓ ⵉⵇⵇⴻⵏ ⵉ-ⵜ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵄⴷⵓⵖ, ⵜⴰⴵⴻⵙⵜ ⵉⵙⵙⵓ ⵜⵜ ⵅ ⵉⵎⴻⵙⵔⴰⵇ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB19_9","019_19_9","JOB","19","9","9","ⵍⵄⴻⵣⵣ ⵉⵏⵓ ⵉⴽⴻⵛⵛⴻⴹ ⵉ-ⵜ ⵣⵣⴰⵢⵉ, ⵓ ⵜⵜⴰⵊ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵉⴽⴽⴻⵙ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("JB19_10","019_19_10","JOB","19","10","10","ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵢⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵖ! ⵉⵇⵍⴻⵄ ⵍⴰⵢⴰⵙ ⵉⵏⵓ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB19_11","019_19_11","JOB","19","11","11","ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵢⴰⵔⵖⴰ ⴷⴰⵢⵉ, ⵏⴻⵜⵜⴰ ⵉⵃⴻⵙⵙⴻⴱ ⴰⵢⵉ ⴰⵎ ⵉⵊⵊ ⵣⴻⴳ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB19_12","019_19_12","JOB","19","12","12","ⵎⵓⵏⴻⵏⵜ ⴼⴼⵖⴻⵏⵜ-ⴷⴷ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏⵏⴻⵙ, ⵙⵙⵡⴻⵊⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏⵜ ⵖⴰⵔⵉ ⵓⵛⴰ ⵇⵓⵡⵡⴰⵔⴻⵏⵜ ⵉ ⵜⵇⵉⴹⵓⵏⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB19_13","019_19_13","JOB","19","13","13","ⴰⵢⵜⵎⴰ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵉ-ⵜⴻⵏ ⵅⴰⴼⵉ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵎⵉⴷⴷⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_14","019_19_14","JOB","19","14","14","ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵄⵏⴰⵏ ⵊⵊⵉⵏ ⴰⵢⵉ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵏ ⵜⵜⵓⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_15","019_19_15","JOB","19","15","15","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⵜⵉⵢⵢⴰ ⵉⵏⵓ ⵃⴻⵙⵙⴱⴻⵏ ⴰⵢⵉ ⴷ ⵍⴱⴰⵔⵔⴰⵏⵉ, ⵏⴻⵛⵛ ⴷ ⴰⵖⵔⵉⴱ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB19_16","019_19_16","JOB","19","16","16","ⵍⴰⵖⵉⵖ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔⵉ, ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵃⴻⵛⵛⵎⴻⵖ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB19_17","019_19_17","JOB","19","17","17","ⵍⴻⵄⵡⵉⵏ ⵏ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵉⵏⵓ ⵉⵙⵙⵄⵉⴼⴼ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ, ⴰⵔⵚⵓⴹⴻⵖ ⵉ ⴰⵢⵜⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("JB19_18","019_19_18","JOB","19","18","18","ⵄⴰⴷ ⵉⵃⵔⴰⵎⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴰⵢⵉ. ⵎⴰⵍⴰ ⴽⴽⴰⵔⴻⵖ ⴱⴻⴷⴷⴻⵖ, ⵜⵜⴻⵎⵄⴰⵔⵔⴰⵏ ⵅⴰⴼⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB19_19","019_19_19","JOB","19","19","19","ⵎⴰⵔⵔⴰ ⵉⵎⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ ⵉⵄⵉⵣⵣⴻⵏ ⵛⴰⵔⵔⵀⴻⵏ ⴰⵢⵉ, ⵉⵏⵏⵉ ⵜⵜⴻⵅⵙⴻⵖ, ⵏⵏⵇⴻⵍⴱⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_20","019_19_20","JOB","19","20","20","ⵖⴰⵔ ⵜⴻⵍⵎⴻⵛⵜ ⴷ ⵡⴻⵢⵙⵓⵎ ⵉⵏⵓ ⵍⴻⵙⵙⵇⴻⵏ ⵉⵖⵙⴰⵏ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵏⴻⵊⵎⴻⵖ ⴰⴽ-ⴷ ⵜⵉⵍⵎⴻⵛⵜ ⵏ ⵜⴻⵖⵎⴰⵙ ⵉⵏⵓ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JB19_21","019_19_21","JOB","19","21","21","ⵃⵉⵏⵏⴻⵎ ⵅⴰⴼⵉ, ⵃⵉⵏⵏⴻⵎ ⵅⴰⴼⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ! ⵎⴰⵖⴰⵔ ⴰⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵍⵇⴻⴼ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_22","019_19_22","JOB","19","22","22","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴹⴰⴼⴼⴰⵔⴻⵎ ⴰⵎ ⵜⵜ ⵉⵜⵜⴻⴳⴳ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵜⵊⵉⵡⵉⵏⴻⵎ ⴰⵢⵙⵓⵎ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB19_23","019_19_23","JOB","19","23","23","ⵎⵍⵉ ⵓⵔⴰⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵎⵍⵉ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ! ");
INSERT INTO rift_vpl VALUES ("JB19_24","019_19_24","JOB","19","24","24","ⵎⵍⵉ ⵜⵜⵡⴰⵏⴻⵇⵛⴻⵏ ⵙ ⴱⵍⵓⵎⴰ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓ ⵙ ⵍⴻⵅⴼⵉⴼ ⴷⵉ ⵊⵊⴰⵔⴼ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JB19_25","019_19_25","JOB","19","25","25","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ: ‘ⴰⵎⴻⴼⴷⵉ ⵉⵏⵓ ⵉⴷⴷⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴷ ⴰⵏⴻⴳⴳⴰⵔ ⵅ ⵓⵛⴰⵍ.’ ");
INSERT INTO rift_vpl VALUES ("JB19_26","019_19_26","JOB","19","26","26","ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵍⴱⴻⵣ ⵜⴻⵍⵎⴻⵛⵜ ⵉⵏⵓ ⴰⵎⵎⵓ, ⴰⴷ ⵥⴰⵔⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB19_27","019_19_27","JOB","19","27","27","ⴰⴷ ⵜ ⵥⴰⵔⴻⵖ ⵣⵣⴰⵜⵉ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⴷⴷⴻⵏ. ⵖⴰⵔⴻⵙ ⵉ ⵜⵜⵎⴻⵥⵔⴻⵏⵜ ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB19_28","019_19_28","JOB","19","28","28","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵎⴰⵎⵎⴻⵛ ⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⴹⴼⴰⵔ?’ ⵎⴰⵖⴰⵔ ⴰⵥⵡⴰⵔ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⵜⵜⵡⴰⴼ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB19_29","019_19_29","JOB","19","29","29","ⴳⴳⵯⴻⴷⴻⵎ ⵣⵉ ⵙⵙⵉⴼ, ⵎⴰⵖⴰⵔ ⵙ ⵙⵙⵉⴼ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴻⵙⵄⴰⵔ ⵅ ⴷⴷⵏⵓⴱ ⵉⵏⴻⵇⵇⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("JB20_1","019_20_1","JOB","20","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵚⵓⴼⴰⵔ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵏⴰⵄⵎⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB20_2","019_20_2","JOB","20","2","2","ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵏⵓ ⵜⵜⵖⵉⵎⴰⵏ ⴷⴻⴽⴽⵡⴰⵍⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵇⴻⴵⴻⵇ ⵉ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉⵏ ⴷⵉ ⵍⴱⴰⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB20_3","019_20_3","JOB","20","3","3","ⵙⵍⵉⵖ ⵉⵊⵊ ⵏ ⵓⵡⴻⴱⴱⴻⵅ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴱⴻⵀⴷⴰⵍⴻⵏ, ⵎⴰⵛⴰ ⴱⵓⵃⴱⴻⵍ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB20_4","019_20_4","JOB","20","4","4","ⵉⵡⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵢⴰ, ⴰⵇⴰ-ⵜ ⴷⵉⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴱⵏⴰⴷⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("JB20_5","019_20_5","JOB","20","5","5","ⴰⵇⴰ ⴰⵙⵍⵉⵡⵍⴻⵡ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⴻⴽⴽ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵓⵎⵏⴰⴼⴻⵇ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵣⴻⵃⵣⵉⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("JB20_6","019_20_6","JOB","20","6","6","ⵡⴰⵅⵅⴰ ⵜᵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵙ ⴰⵍ ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴰⵅⵅⴰ ⵉⵜⵜⵃⴰⴷⴰ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵍ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB20_7","019_20_7","JOB","20","7","7","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵓⴼⵖⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵇⴹⴰⵏ ⵉ ⵍⴻⴱⴷⴰ, ⴰⴷ ⵉⵇⴹⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵍⴻⴱⴷⴰ. ⵉⵏⵏⵉ ⵜ ⵉⵥⵔⵉⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⵏⴻⵜⵜⴰ?’ ");
INSERT INTO rift_vpl VALUES ("JB20_8","019_20_8","JOB","20","8","8","ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵉⵔⵊⴰ ⴰⴷ ⵉⴹⵓⵡ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵄⴰⴷ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵜⵍⴻⵄ ⴰⵎ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB20_9","019_20_9","JOB","20","9","9","ⵜⵉⵟⵟ ⵉ ⵜ ⵉⵥⵔⵉⵏ ⵡⴰⵔ ⵜ ⵜⵥⴰⵔⵔ ⵄⴰⵡⴻⴷ, ⵓ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵉⵥⴰⵔⵔ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("JB20_10","019_20_10","JOB","20","10","10","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵙⵙⵊⵉⵡⵏⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ, ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB20_11","019_20_11","JOB","20","11","11","ⵉⵅⵙⴰⵏ ⵏⵏⴻⵙ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⴻⵎⵥⵉ, ⴰⴷ ⵣⵣⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB20_12","019_20_12","JOB","20","12","12","ⵎⴰⵍⴰ ⵍⵖⴰⵔ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴷ ⴰⵎⵉⵥⵉⴷ, ⵎⴰⵍⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⵙⴰⴷⵓ ⵉⵍⴻⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB20_13","019_20_13","JOB","20","13","13","ⵎⴰⵍⴰ ⵉⵃⴹⴰ ⵉ-ⵜ, ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵅⴰⵙ ⵉⵃⴻⵢⵢⴻⴷ, ⵎⴰⵛⴰ ⵉⵎⴻⵏⵏⴻⵄ ⵉ-ⵜ ⴷⴻⴳ ⵡⴰⵏⴻⵖ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB20_14","019_20_14","JOB","20","14","14","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵍ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ, ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⴰⵔⵔⵀⴰⵊ ⵏ ⵜⵔⴻⴼⵙⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB20_15","019_20_15","JOB","20","15","15","ⵉⵚⴰⵔⴹ ⴰⴳⵍⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵄⵓⵇⵇ ⵄⴰⵡⴻⴷ. ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵏⴹⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB20_16","019_20_16","JOB","20","16","16","ⴰⵔⵔⵀⴰⵊ ⵏ ⵜⵔⴻⴼⵙⵉⵡⵉⵏ ⴰⴷ ⵜ ⵉⵟⵟⴻⴹ, ⵉⵍⴻⵙ ⵏ ⵓⴼⵉⵖⴰⵔ ⴰⴷ ⵜ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB20_17","019_20_17","JOB","20","17","17","ⵡⴰⵔ ⵉⵥⴰⵔⵔ ⵉⵖⴻⵣⵔⴰⵏ, ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⴷ ⵜⴰⵔⵢⴰⵡⵉⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵙ ⵜⴰⵎⵎⴻⵏⵜ ⴷ ⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JB20_18","019_20_18","JOB","20","18","18","ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵍⴻⴼⴹⴻⵍ ⵏ ⵓⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜ ⵉⵙⵙⴻⵖⵍⴰⵢ, ⵡⴰⵔ ⵉⵏⴻⴳⴳⴻⵣ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⴳⵍⴰ ⵉ ⴷⴷ-ⵉⴽⵙⴻⴱ, ");
INSERT INTO rift_vpl VALUES ("JB20_19","019_20_19","JOB","20","19","19","ⵎⴰⵖⴰⵔ ⵉⴷⴻⴵ ⵉⵎⴻⵣⵍⴰⴹ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴱⵍⴰ ⵜⵡⵉⵣⴰ, ⵢⵓⵛⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⴱⴻⴷⴷ, ");
INSERT INTO rift_vpl VALUES ("JB20_20","019_20_20","JOB","20","20","20","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵍⵀⵓⴷⵏⴻⵜ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ, ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵉⵏⴻⵊⵊⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JB20_21","019_20_21","JOB","20","21","21","ⵡⴰⵔ ⵉⵜⵜⵛⴻⵟⵟⵉ ⵡⴰⵍⵓ ⵉ ⵓⵎⴻⵔⵄⵉⵇ ⵏⵏⴻⵙ, ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵣⵣⵀⴰⵔ ⵏⵏⴻⵙ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JB20_22","019_20_22","JOB","20","22","22","ⵎⴰⵍⴰ ⵖⴰⵔⴻⵙ ⴰⴼⴻⵢⵢⴻⴹ ⵉⵎⵓⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴰⵔ, ⴰⴷ ⵅⴰⵙ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵏ ⴽⵓⵍ ⵍⵎⴻⵙⴽⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB20_23","019_20_23","JOB","20","23","23","ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛⵓⵔ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴻⴽⴽ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵢⴰⵔⵔ ⴰⴷ ⵅⴰⵙ ⵉⵡⵡⴻⵜ ⴰⵎ ⵡⴻⵏⵥⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⴰⴷ ⵉⵛⵓⴽⴽ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB20_24","019_20_24","JOB","20","24","24","ⵡⴰⵅⵅⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵍⴻⵙⵏⴰⵃ ⵏ ⵡⵓⵣⵣⴰⵍ, ⴰⴷ ⵜ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵍⵇⴻⵡⵙ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB20_25","019_20_25","JOB","20","25","25","ⵉⵊⴻⴱⴱⴻⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴼⵍⵉⵜⵛⴰ, ⴰⵇⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵍⵎⴰⵛⴰⵎ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵉⵥⵉ ⵏⵏⴻⵙ, ⵡⴰⵀ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⴰⴷ ⵅⴰⵙ ⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB20_26","019_20_26","JOB","20","26","26","ⵜⴰⴵⴻⵙⵜ ⵜⴻⴽⵎⴻⵍ ⵜᵉⵜⵜⵃⴰⵎⴰ ⵖⴰⵔ ⵜⵅⵓⴱⴰⵢ ⵏⵏⴻⵙ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ, ⵜⵉⵎⴻⵙⵙⵉ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⴰⴷ ⵜ ⵜⴻⵛⵛ, ⴰⴷ ⵜⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵛⴻⵟⵟⴻⵏ ⴷⵉ ⵜⵇⵉⴹⵓⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB20_27","019_20_27","JOB","20","27","27","ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵉⵄⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵅⴰⵙ ⵜⵖⴻⵡⵡⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB20_28","019_20_28","JOB","20","28","28","ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵔⴰⵃ, ⴰⴷ ⵜⴰⵣⵣⴻⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB20_29","019_20_29","JOB","20","29","29","ⵡⴰ ⴷ ⵎⵉⵏ ⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB21_1","019_21_1","JOB","21","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB21_2","019_21_2","JOB","21","2","2","ⵙⵍⴻⵎ ⵎⵍⵉⵃ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵉ ⵓⵙⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JB21_3","019_21_3","JOB","21","3","3","ⴽⵙⵉⵎ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⵙⵉⵡⵍⴻⵖ, ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵄⴻⴼⴼⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB21_4","019_21_4","JOB","21","4","4","ⵎⴰ ⴰⵛⴻⵜⵛⵉ ⵉⵏⵓ ⵅ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ? ⵏⵉⵖ ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⴱⵍⴰ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JB21_5","019_21_5","JOB","21","5","5","ⵇⴻⵍⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵓⵛⴰ ⵊⵄⴰⵔⴻⵎ, ⵙⴰⵔⵙⴻⵎ ⴰⴼⵓⵙ ⵅ ⵓⵇⴻⵎⵎⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JB21_6","019_21_6","JOB","21","6","6","ⵎⴰⵍⴰ ⵅⴻⵎⵎⴻⵖ ⵡⴰⵀⴰ ⴷⴻⴳ ⵓⵢⴰ, ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵖ ⵓ ⵜⵎⴻⵏⵏⴻⵄ ⵜⴰⵔⵊⵉⵊⵉⵜ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB21_7","019_21_7","JOB","21","7","7","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⵖⵉⵎⴰⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷⴷⴰⵔⴻⵏ, ⵎⴰⵢⴻⵎⵎⵉ ⴷⴷⴰⴽⴽⵡⴰⵍⴻⵏ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⵜⵜⵎⴰⵔⵏⵉⵏ ⵄⴰⴷ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB21_8","019_21_8","JOB","21","8","8","ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⵜⵜⵖⵉⵎⴰⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⵙⴻⵏ, ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵖⴻⴷⴷⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB21_9","019_21_9","JOB","21","9","9","ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵍⴻⵀⵏⴰ ⵏⵀⵍⴰ ⴰⵏⴻⵅⵍⵉⵄ, ⴰⵄⵎⵓⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵜⴻⵏ ⵉⵛⵛⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JB21_10","019_21_10","JOB","21","10","10","ⴰⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ ⵉⵜⵜⴰⵔⵔⴰ ⵓ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉ, ⵜⴰⴼⵓⵏⴰⵙⵜ ⵏⵏⴻⵙ ⵜᵉⵜⵜⴰⵔⵓ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵖⴻⵟⵟⴻⵍ ⴰⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JB21_11","019_21_11","JOB","21","11","11","ⵜⵜⴻⵊⵊⴰⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏ ⴳⴳⵓⵔⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴻⵊⵊⴰⵏ ⵜⴻⵏ ⵏⴻⴳⴳⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB21_12","019_21_12","JOB","21","12","12","ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⴱⴻⵏⴷⵉⵔ ⴷ ⵍⴳⴰⵎⴱⵔⵉ, ⴼⴰⵔⵔⵃⴻⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴻⵎⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("JB21_13","019_21_13","JOB","21","13","13","ⵙⵙⵄⴻⴷⴷⵓⵏ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵣⵣⵀⴰⵔ, ⵎⴰⵛⴰ ⵀⴻⴽⴽⵡⴰⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB21_14","019_21_14","JOB","21","14","14","ⵇⵇⴰⵔⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ: ‘ⵃⴻⵢⵢⴻⴷ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵄⵊⵉⴱ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB21_15","019_21_15","JOB","21","15","15","ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵏⵙⴻⵅⵅⴰⵔ? ⵎⴰⵏ ⵍⴼⴰⵢⴷⴰ ⵉ ⵖⴰⵔⵏⴻⵖ ⵎⴰⵍⴰ ⵏⵣⵉⵢⵢⴰⵔ ⵅⴰⵙ ⵙ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵖ?’ ");
INSERT INTO rift_vpl VALUES ("JB21_16","019_21_16","JOB","21","16","16","ⵅⵣⴰⵔ, ⵣⵣⵀⴰⵔ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ⵛⵛⵡⴰⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JB21_17","019_21_17","JOB","21","17","17","ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵅⴻⵙⵙⵉ ⵅⴻⵏⵏⵉ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵜⴼⴰⵡⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵉⵍⴻⵇⵇⴻⴼ ⵉ-ⵜⴻⵏ ⵓⴹⴻⵢⵢⴻⵄ, ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⴱⴻⵟⵟⴰ ⵏⴻⵜⵜⴰ ⵅⴰⵙⴻⵏ ⵍⴻⵃⵍⵉⵇ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB21_18","019_21_18","JOB","21","18","18","ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵓⵍⵓⵎ ⵣⵣⴰⵜ ⵉ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⵎ ⵉⵖⴻⴵ ⵜⴻⵅⴹⴻⴼ ⵉ-ⵜ ⵜⵃⴰⵔⵢⴰⴹⵜ? ");
INSERT INTO rift_vpl VALUES ("JB21_19","019_21_19","JOB","21","19","19","ⵎⴰ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵅⴻⵎⵎⴻⵍ ⵍⵄⵉⵇⴰⴱ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ!’ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵙ ⵜⵜ ⵉⵅⴻⴵⴻⵚ ⴰⵍ ⵖⴰ ⵢⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("JB21_20","019_21_20","JOB","21","20","20","ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⴰⵀⴻⵍⵍⴻⴽ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵓ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("JB21_21","019_21_21","JOB","21","21","21","ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴰⵔⴹⴰ ⵄⴰⴷ ⴷⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵄⴰⴷ ⵇⴻⴷⴷⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB21_22","019_21_22","JOB","21","22","22","ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵜⵓⵙⵙⵏⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵢⵓⵄⵍⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB21_23","019_21_23","JOB","21","23","23","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵉⵎⵎⵓⵜ ⴷⵉ ⵣⵣⵀⴰⵔ ⵉⵎⵓⵏ, ⴰⵎ ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⵇⴰⵄ ⴷⵉ ⵍⴻⵀⵏⴰ ⵓ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB21_24","019_21_24","JOB","21","24","24","ⴰⵎ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵍⴻⵎⴷⴰⵡⴻⴷ ⵏⵏⴻⵙ ⵙ ⵓⵖⵉ ⵓ ⵉⵜⵜⵡⴰⴱⴻⵣⵣⴻⴳ ⵡⴰⴷⵓⴼ ⵏ ⵢⴻⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB21_25","019_21_25","JOB","21","25","25","ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵎⵎⵓⵜ ⵙ ⵍⴻⵄⵎⴰⵔ ⴷ ⴰⵎⴰⵔⵣⴰⴳ, ⵡⴰⵔ ⴷⴷ-ⵢⵉⵡⵉ ⵍⵉⵇⵇⵉ ⵉ ⵡⴰⵍⵓ ⵏ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB21_26","019_21_26","JOB","21","26","26","ⵎⵓⵏⴻⵏ ⵣⵣⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵓⵛⴰⵍ ⵓ ⵉⴽⴻⵛⵛⴰⵡⴻⵏ ⴷⵍⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB21_27","019_21_27","JOB","21","27","27","ⵅⵣⴰⵔ, ⵙⵙⵏⴻⵖ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ, ⵓⵍⴰ ⴷ ⵜⵉⵎⴻⵄⵎⴰⵍⵜ ⵏⵏⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵜⴷⴻⵍⵎⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JB21_28","019_21_28","JOB","21","28","28","ⵅⵎⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵛⴻⵏⵏⴻⵄ ⵉⵜⵜⵎⴻⵥⵔⵉⵏ ⴷⵉ ⵚⵚⵓⵍⵟⴰ, ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵇⵉⴹⵓⵏⵜ ⵙ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ, ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ?’ ");
INSERT INTO rift_vpl VALUES ("JB21_29","019_21_29","JOB","21","29","29","ⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵇⵙⵉⵎ ⵉⵎⵙⴻⴱⵔⵉⴷⴻⵏ? ⴰⵇⴰ ⵉⵛⴻⵢⵢⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵉⵜⵜⵇⴰⵔⵔⴰⵏ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵏ ⵜⴻⵏⴽⴰⵔⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("JB21_30","019_21_30","JOB","21","30","30","ⵎⴰⵖⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴹⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB21_31","019_21_31","JOB","21","31","31","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜ ⵖⴰ ⵉⵙⵙⴻⵛⵏⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ? ⵎⴰⵍⴰ ⵉⴳⴳⴰ ⵛⴰ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵡⵉ ⵜ ⵉ ⵖⴰ ⵉⵅⴻⴵⵚⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB21_32","019_21_32","JOB","21","32","32","ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⵙⵉ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵖⴰⵔ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵄⴻⵙⵙ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB21_33","019_21_33","JOB","21","33","33","ⵜⵜⵄⴻⵊⵉⴱⴻⵏ ⴰⵙ ⵉⴱⵓⵔⵙⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵓ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵜⵜⵉⵣⵡⴰⵔⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵃⴻⵙⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB21_34","019_21_34","JOB","21","34","34","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⵄⴻⵣⵣⴰⵎ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ? ⵣⵉ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵍⴻⵖⴹⴰⵔ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JB22_1","019_22_1","JOB","22","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵍⵉⴼⴰⵣ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵜⴰⵢⵎⴰⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB22_2","019_22_2","JOB","22","2","2","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵏⴼⴻⵄ ⴰⵔⴻⴱⴱⵉ? ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵙ ⵍⴻⵄⵇⴻⵍ ⵉⵏⴻⴼⴼⴻⵄ ⵎⵖⵉⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB22_3","019_22_3","JOB","22","3","3","ⵎⴰ ⴰⵇⴰ-ⵜ ⴷ ⵍⴼⴰⵢⴷⴰ ⵉ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⴰⵇⴰ ⵛⴻⴽ ⵜⵙⴻⴳⴳⴷⴻⴷ, ⵏⵉⵖ ⴷ ⵍⴻⴼⴹⴻⵍ ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JB22_4","019_22_4","JOB","22","4","4","ⵎⴰ ⵉⵡⵜⵉ ⵉ ⵛⴻⴽ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏⵏⴻⵛ ⵣⵣⴰⵢⴻⵙ, ⵏⵉⵖ ⴰⴷ ⵢⴰⴷⴻⴼ ⴰⴽⵉⴷⴻⴽ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ? ");
INSERT INTO rift_vpl VALUES ("JB22_5","019_22_5","JOB","22","5","5","ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵛ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵏⴻⵛ ⵎⴰ ⵡⴰⵔ ⴵⵉⵏⵜ ⵏⵀⵍⴰ ⴰⵙⴱⴻⴷⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("JB22_6","019_22_6","JOB","22","6","6","ⵎⴰⵖⴰⵔ ⵜⵃⴻⵡⵡⵙⴻⴷ ⴷⴷⵉⵢⵢⴻⵜ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵛ ⴱⴰⵟⴻⵍ, ⵜⴻⴽⴽⵙⴻⴷ ⴰⵔⵔⵓⴹ ⵉ ⵢⵉⵏⵏⵉ ⵙ ⴷⵔⵓⵙ ⵏ ⵡⴻⵔⵔⵓⴹ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JB22_7","019_22_7","JOB","22","7","7","ⵡⴻⵏⵏⵉ ⵢⵓⵃⵍⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵡⵛⵉⴷ ⴰⴷ ⵉⵙⵓ, ⵡⴻⵏⵏⵉ ⵉⴵⵓⵣⴻⵏ ⵜⵇⴻⴹⵄⴻⴷ ⴰⵙ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JB22_8","019_22_8","JOB","22","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⴰⵔⵢⴰⵣ ⵙ ⵓⵖⵉⵍ ⵉⵊⵀⴻⴷ, ⵅⴻⵏⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ-ⵜⵜ ⵉ ⵡⴰⵏⵉⵜⴰ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵣⴷⴻⵖ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB22_9","019_22_9","JOB","22","9","9","ⵜⵉⵊⵊⴰⵍ ⵜⵙⴻⴽⴽⴻⴷ ⵜⴻⵏⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ, ⵉⵖⴰⴵⴻⵏ ⵏ ⵓⵢⵓⵊⵉⵍ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB22_10","019_22_10","JOB","22","10","10","ⵅ ⵓⵢⴰ ⵏⵏⴹⴻⵏⵜ ⴰⵛ ⵍⴻⴼⵅⵓⵅ, ⵓⵛⴰ ⵜⴻⵡⴹⴰⴷ-ⴷⴷ ⵅⴰⴽ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB22_11","019_22_11","JOB","22","11","11","ⵏⵉⵖ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵍⵉⴷ ⵜⴰⴵⴻⵙⵜ, ⴷ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵏⵏⵉ ⵛⴻⴽ ⵢⴻⴷⵍⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("JB22_12","019_22_12","JOB","22","12","12","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⴻⴱⴱⵉ ⵢⵓⵄⵍⴰ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ? ⵅⵣⴰⵔ ⵉⵜⵔⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ, ⵎⴰⵎⵎⴻⵛ ⵄⵓⴵⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JB22_13","019_22_13","JOB","22","13","13","ⵎⴰⵛⴰ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵎⵉⵏ ⵉⵙⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵃⴽⴻⵎ ⵏⵉⵛⴰⵏ ⵣⴻⴳ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB22_14","019_22_14","JOB","22","14","14","ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⴰⵍⴻⵃⵃⴻⴼ ⵉ ⵏⴻⵜⵜⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ, ⵓ ⵅ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵉⴳⴳⵓⵔ ⵏⴻⵜⵜⴰ.’ ");
INSERT INTO rift_vpl VALUES ("JB22_15","019_22_15","JOB","22","15","15","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴹⴼⴰⵔⴻⴹ ⴰⵎⴻⵙⵔⵓⵇ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⴰⵎⴻⵙⵔⵓⵇ ⵏⵏⵉ ⴽⴽⵉⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JB22_16","019_22_16","JOB","22","16","16","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⴰⵎ ⵡⴰⵔ ⴷⴷ-ⵢⵉⵡⵉⴹ ⵄⴰⴷ ⵍⵎⵉⵊⴰⵍ ⵏⵙⴻⵏ, ⵓⵎⵉ ⵜⴼⴻⵢⵢⴻⴹ ⵍⵃⴻⵎⵍⴻⵜ ⴷⵙⴰⵙ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB22_17","019_22_17","JOB","22","17","17","ⵉⵏⵏⵉ ⵉⵏⵏⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ: ‘ⴰⴳⴳⵯⴻⵊ ⵅⴰⵏⴻⵖ!’ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵢⴻⴳⴳ ⵄⴰⴷ ⵉ ⵏⵉⵜⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JB22_18","019_22_18","JOB","22","18","18","ⵉⵡⴰ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵛⵓⵔ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⵙ ⵍⵅⴰⵔ! ⵛⵛⵡⴰⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JB22_19","019_22_19","JOB","22","19","19","ⵥⵔⵉⵏ ⵜⵜ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵓⵛⴰ ⴼⴰⵔⵃⴻⵏ, ⴰⵎⴻⵣⴷⴰⴳ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB22_20","019_22_20","JOB","22","20","20","‘ⴰⵖⵔⵉⵎ ⵏⵏⴻⵖ ⵉⵜⵜⵡⴰⴽⴻⵃⵃⴻⴹ ⵓ ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵜⴻⵛⵛⴰ ⵉ-ⵜ ⵜⵎⴻⵙⵙⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JB22_21","019_22_21","JOB","22","21","21","ⵇⵇⴻⵏ ⵖⴰⵔⴻⵙ, ⴰⴷ ⵖⴰⵔⴻⴽ ⵜⵉⵍⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⵙ ⵓⵢⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB22_22","019_22_22","JOB","22","22","22","ⴽⵙⵉ ⵅⴻⵏⵏⵉ ⵜⴰⵖⵓⵔⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⴻⴳⴳ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB22_23","019_22_23","JOB","22","23","23","ⵎⴰⵍⴰ ⵜⴷⴻⵡⵍⴻⴷ-ⴷⴷ ⵖⴰⵔ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⴷ. ⵙⵉⴳⴳⵯⴻⵊ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵅ ⵜⵇⵉⴹⵓⵏⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB22_24","019_22_24","JOB","22","24","24","ⵙⴰⵔⵙ ⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ ⴷⴻⴳ ⵓⵛⴰⵍ, ⵓⵔⴻⵖ ⵣⵉ ⵓⴼⵉⵔ ⵊⴰⵔ ⵉⵥⵔⴰ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB22_25","019_22_25","JOB","22","25","25","ⵅⴻⵏⵏⵉ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ ⵏⵏⴻⵛ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵛⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("JB22_26","019_22_26","JOB","22","26","26","ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴼⴰⵔⵃⴻⴹ ⵣⴻⴳ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB22_27","019_22_27","JOB","22","27","27","ⴰⴷ ⴰⵙ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵙ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵉⵙⴻⵍ, ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB22_28","019_22_28","JOB","22","28","28","ⵎⴰⵍⴰ ⵜⴻⴽⴽⵙⴻⴷ ⴰⵡⴰⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⵓ ⵜⴰⴼⴰⵡⵜ ⴰⴷ ⵜⴰⵔⴻⵖ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB22_29","019_22_29","JOB","22","29","29","ⵎⴰⵍⴰ ⵙⵙⴻⵀⵡⴰⵏ ⵏⵉⵜⵏⵉ ⵉⵊⵊⴻⵏ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵙⴳⴻⵄⵄⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ!’, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵀⴻⴽⴽⵡⴰⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB22_30","019_22_30","JOB","22","30","30","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴱⵍⴰ ⵍⵄⵉⴱ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵏⵊⴻⵎ ⵙ ⵜⴻⵣⴷⵓⴳⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("JB23_1","019_23_1","JOB","23","1","1","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB23_2","019_23_2","JOB","23","2","2","ⵓⵍⴰ ⴷ ⴰⵙⵙ-ⴰ ⴰⵛⴻⵜⵛⵉ ⵉⵏⵓ ⴷ ⴰⵖⴻⵏⵏⴰⵏ, ⵉⵙⵙⴻⴷⵇⴻⵍ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅ ⵓⵏⴻⴼⴼⴻⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB23_3","019_23_3","JOB","23","3","3","ⵎⵍⵉ ⵙⵙⵏⴻⵖ, ⵎⴰⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⴰⴼⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴹⴻⵖ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB23_4","019_23_4","JOB","23","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⴻⵣⵣⵄⴻⵖ ⵣⵣⴰⵜⴻⵙ ⴷⴷⴻⵄⵡⴻⵜ, ⴰⴷ ⵛⵛⵓⵔⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵓⵛⴰⵔⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("JB23_5","019_23_5","JOB","23","5","5","ⴰⴷ ⵙⵙⵏⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉ ⵅⴰⴼⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔ, ⴰⴷ ⴼⴻⵀⵎⴻⵖ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JB23_6","019_23_6","JOB","23","6","6","ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵎⵛⴰⵔⵔⴻⵄ ⴰⴽⵉⴷⵉ ⵙ ⵊⵊⵀⴻⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ? ⵍⵍⴰ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⵜⴰⵢⵏⵉⵜ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JB23_7","019_23_7","JOB","23","7","7","ⴷⵉⵏⵏⵉ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵎⵛⴰⵔⵔⴻⵄ ⵡⴻⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵓ ⴰⵎⵎⵓ ⵏⴻⵛⵛ ⴰⴷ ⵏⵏⵓⴼⵙⵍⴻⵖ ⵉ ⵍⴻⴱⴷⴰ ⵣⵉ ⵍⵇⴰⴹⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB23_8","019_23_8","JOB","23","8","8","ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⴰⵎⵎⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵏⴻⵜⵜⴰ, ⵓ ⵎⴰⵍⴰ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵍⵖⴰⵔⴱ, ⴰⵎⵎⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵃⴻⴽⴽⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB23_9","019_23_9","JOB","23","9","9","ⵎⴰⵍⴰ ⵖⴰⵔⴻⵙ ⵛⵖⴻⵍ ⴷⵉ ⵛⵛⴰⵎⴰⵍ, ⵡⴰⵔ ⵜ ⵜⵜⵡⵉⵍⵉⵖ, ⵎⴰⵍⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⵡⴰⵔ ⵜ ⵥⴰⵔⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB23_10","019_23_10","JOB","23","10","10","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⴰⴱⵔⵉⴷ ⵉ ⴳⴳⵓⵔⴻⵖ, ⵉⵜⵜⵇⴻⴵⴻⴱ ⴰⵢⵉ, ⴰⴷ ⴼⴼⵖⴻⵖ ⴰⵎ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB23_11","019_23_11","JOB","23","11","11","ⵉⵎⵏⴻⵄ ⵓⴹⴰⵔ ⵉⵏⵓ ⴷⵉ ⵊⵊⵓⵔⵔⴰⵜ ⵏⵏⴻⵙ, ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴹⴼⴰⵔⴻⵖ ⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴼⴼⵉⵖⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB23_12","019_23_12","JOB","23","12","12","ⵜⴰⵡⵚⵉⵢⵢⴻⵜ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴰⵔⵅⵓⵖ. ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵅⴻⵎⵎⵍⴻⵖ ⵜⴻⵏ, ⵎⴰⵀⵓ ⵎⵉⵏ ⵅⴻⴼ ⵜⵜⵡⴰⵡⴻⵚⵚⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JB23_13","019_23_13","JOB","23","13","13","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴹⵉⴷⴷ ⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜ ⵖⴰ ⵉⵎⴻⵏⵄⴻⵏ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ? ⵎⵉⵏ ⵉⵅⵙ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵢⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("JB23_14","019_23_14","JOB","23","14","14","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵇⴼⴰⵍ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵢⵓⵔⴰ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵎ ⵜⵉⵏⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⵍⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB23_15","019_23_15","JOB","23","15","15","ⵅ ⵓⵢⴰ ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵖ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴼⴻⵀⵎⴻⵖ ⵜⵜ ⵎⵍⵉⵃ, ⵓ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB23_16","019_23_16","JOB","23","16","16","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴼⵛⵉⵍ ⵓⵍ ⵉⵏⵓ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⵙⵙⵏⴻⵅⵍⴰⵄ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB23_17","019_23_17","JOB","23","17","17","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵖ ⵣⵉ ⵜⴰⴵⴻⵙⵜ, ⵓⵍⴰ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵏⵏⵉ ⵉⵜⵜⵍⴻⵃⵃⴻⴼ ⵙ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB24_1","019_24_1","JOB","24","1","1","ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏⵜ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵓⵅⴻⴵⴻⵚ ⵙ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵉⵏⵏⵉ ⵜ ⵉⵙⵙⵏⴻⵏ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵏ ⵏⵏⴻⵇⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JB24_2","019_24_2","JOB","24","2","2","ⵏⵉⵜⵏⵉ ⵙⵙⵎⵓⵟⵟⵓⵢⴻⵏ ⵍⴻⵀⴷⵓⴷ, ⵜⵜⴰⵛⴰⵔⴻⵏ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵓⵛⴰ ⴰⵔⴻⴽⴽⵡⵙⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JB24_3","019_24_3","JOB","24","3","3","ⴰⵖⵢⵓⵍ ⵏ ⵉⵢⵓⵊⵉⵍⴻⵏ ⵙⵙⴰⴳⴳⵯⴰⵊⴻⵏ ⵜ, ⵜⵜⵃⴻⵡⵡⵙⴻⵏ ⴰⴼⵓⵏⴰⵙ ⵏ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("JB24_4","019_24_4","JOB","24","4","4","ⵏⵉⵜⵏⵉ ⵄⴰⵔⵔⵏⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ. ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵜⵏⵓⴼⴼⴰⵔⴻⵏ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JB24_5","019_24_5","JOB","24","5","5","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵢⵉⵖⵢⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⵜⵜⴻⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ, ⴰⵔⴻⵣⵣⵓⵏ ⵜⴰⵏⴻⵢⵎⴰⵔⵜ. ⵍⴻⵅⵍⴰ ⵉⵡⵛⴰ ⴰⵙ ⵎⴰⵛⵛⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_6","019_24_6","JOB","24","6","6","ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵃⴻⵜⵜⵛⴻⵏ ⵍⴻⵃⵜⵉⵛ ⵏⵏⴻⵙ, ⵍⴻⵇⵇⴹⴻⵏ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_7","019_24_7","JOB","24","7","7","ⵙⵙⵄⴻⴷⴷⵓⵏ ⴵⵉⵍⴻⵜ ⴷ ⵉⵄⴰⵔⵢⴰⵏⴻⵏ, ⵏⵀⵍⴰ ⴰⵔⵔⵓⴹ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⴷⴷⵓⵔⵉ ⴷⵉ ⵜⴻⵚⵎⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("JB24_8","019_24_8","JOB","24","8","8","ⵣⴻⴳ ⵡⴻⵏⵥⴰⵔ ⵉⵛⵛⴰⵜⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵜⵜⵓⴼⴼⴻⵏ, ⵜⵜⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵊⵊⴰⵔⴼ ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴰⴷⵓⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JB24_9","019_24_9","JOB","24","9","9","ⵣⴻⴳ ⵉⴼⴼⴰⵏ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵜⵜⴻⴽⴽⵙⴻⵏ ⴰⵢⵓⵊⵉⵍ, ⵓⵛⴰ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴰⴹⵎⴰⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵍⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JB24_10","019_24_10","JOB","24","10","10","ⴳⴳⵓⵔⴻⵏ ⴷ ⵉⵄⴰⵔⵢⴰⵏⴻⵏ, ⵏⵀⵍⴰ ⴰⵔⵔⵓⴹ, ⴰⵎ ⴵⵓⵥⴻⵏ ⴰⵔⴻⴱⴱⵓⵏ ⵉⵛⵓⵡⵡⴰⴼⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB24_11","019_24_11","JOB","24","11","11","ⵊⴰⵔ ⵍⴻⵃⵢⵓⴹ ⵜⵜⵄⴻⵙⵙⴰⵔⴻⵏ ⵣⵣⴻⵛⵜ, ⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵔ, ⵎⴰⵛⴰ ⵜⵜⵖⵉⵎⴰⵏ ⴼⴼⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_12","019_24_12","JOB","24","12","12","ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⴻⵖⵏⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵙⵖⵓⵢⵢⵓ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵃⴻⵟⵟⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_13","019_24_13","JOB","24","13","13","ⵉⵏⵏⴻⵖⵏⵉ ⴷ ⵉⵎⵖⴻⵡⵡⵖⴻⵏ ⵅ ⵜⴼⴰⵡⵜ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⴷⵉ ⵜⵉⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB24_14","019_24_14","JOB","24","14","14","ⵇⴱⴻⵍ ⴷⴷ-ⵜⵓⵙⴰ ⵜⴼⴰⵡⵜ, ⵉⵜⵜⴻⴽⴽⴰⵔ ⵓⵇⴻⵜⵜⴰⵍ, ⵉⵏⴻⵇⵇ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⴳⴳⴰ ⴰⵎ ⵓⵅⴻⵡⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_15","019_24_15","JOB","24","15","15","ⵜⵉⵟⵟ ⵏ ⵓⵣⴻⵏⵏⴰⵢ ⵜⵃⴻⵟⵟⴰ ⵜⴰⴵⴻⵙⵜ. ⵉⵇⵇⴰⵔ: ‘ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵟⵟ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵃⴻⵟⵟⵉ!’ ⵉⵍⴻⵃⵃⴻⴼ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB24_16","019_24_16","JOB","24","16","16","ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⵓⴷⵔⵉⵏ. ⵙ ⵡⴰⵙⵙ ⵜⵜⵏⵓⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵡⴰⵍⵓ ⵅ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB24_17","019_24_17","JOB","24","17","17","ⵎⴰⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵜⴱⴰⵏ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵎ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵎⴰⵖⴰⵔ ⵙⵙⵏⴻⵏ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⵏ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB24_18","019_24_18","JOB","24","18","18","ⵏⴻⵜⵜⴰ ⴷ ⴰⴼⵙⵓⵙ ⴰⵎ ⵓⴽⵓⴼⴼⵓ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ ⵉ ⵢⴻⴵⴰ. ⵜⴻⵜⵜⵡⴰⵏⵄⴻⵍ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵡⴰⵔ ⵉⵜⵜⴻⵟⵟⴻⴼ ⵄⴰⴷ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JB24_19","019_24_19","JOB","24","19","19","ⵍⴰⵥⴰⵖ ⴷ ⵍⴻⵃⵎⵓ ⵇⴻⵟⵟⴰⵏ ⵅ ⵡⴰⵎⴰⵏ ⵏ ⵡⴻⴷⴼⴻⵍ, ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⴻⴽⴽⴻⵙ ⵍⴰⵅⴰⵔⵜ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵅⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_20","019_24_20","JOB","24","20","20","ⴰⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⴰⴷ ⵜ ⵉⵜⵜⵓ, ⵉⴽⴻⵛⵛⴰⵡⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵔⵔⴻⵏ ⵎⴻⵥⵔⵉ. ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜ ⵜⵜⵉⴷⴰⵔⴻⵏ ⵄⴰⴷ. ⵉⵜⵜⵡⴰⵔⵥ ⵍⵖⴻⵛⵛ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴼⵔⴻⵡⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ");
INSERT INTO rift_vpl VALUES ("JB24_21","019_24_21","JOB","24","21","21","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴱⵍⴰ ⵜⴰⵔⵡⴰ, ⴷⵉ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ, ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴰⴽ-ⴷ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("JB24_22","019_24_22","JOB","24","22","22","ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵙⵙⴱⴻⴷⴷⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ. ⵉⴱⴻⴷⴷ ⵡⴰⵏⵉⵜⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_23","019_24_23","JOB","24","23","23","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵍⴰⵎⴰⵏ, ⴰⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⵓⴷⴻⴼ ⵜⵜⵉⵇⵇⴻⵜ, ⵄⴰⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_24","019_24_24","JOB","24","24","24","ⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵃⴰⵍ ⴷ ⴰⵇⵓⴹⴰⴹ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵄⴰⴷ. ⴰⴷ ⵀⵡⴰⵏ, ⴰⴷ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⴰⵎ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴰⵎ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⵓⵖⴻⴷⴷⵓⵢ ⵏ ⵢⵉⵔⴷⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB24_25","019_24_25","JOB","24","25","25","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵙⵙⴻⴱⴹⴻⵍ ⵍⵀⴰⵔⴷ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB25_1","019_25_1","JOB","25","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵉⵍⴷⴰⴷ, ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵓⵃⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB25_2","019_25_2","JOB","25","2","2","ⵚⵚⵓⵍⵟⴰ ⴷ ⵊⵊⴻⵀⴷ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵀⵏⴰ ⴷⵉ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB25_3","019_25_3","JOB","25","3","3","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵃⴻⵙⴱⴻⵏ ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰⵔⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ? ⵅ ⵎⴰⵏ ⵡⴰⵔ ⵜᵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB25_4","019_25_4","JOB","25","4","4","ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵎⵎⴻⵛ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ? ");
INSERT INTO rift_vpl VALUES ("JB25_5","019_25_5","JOB","25","5","5","ⵅⵣⴰⵔ, ⵄⴰⴷ ⵜⴰⵣⵉⵔⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴻⵙⵙⴻⴳ ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⵉⵜⵔⴰⵏ ⵡⴰⵔ ⵚⴼⵉⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB25_6","019_25_6","JOB","25","6","6","ⴰⵀⵜⴰ ⵄⴰⴷ ⴱⵏⴰⴷⴻⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⴽⴽⵉ, ⵓ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴰⴽⴻⵛⵛⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("JB26_1","019_26_1","JOB","26","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB26_2","019_26_2","JOB","26","2","2","ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵡⵛⵉⴷ ⴰⴼⵓⵙ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵊⵊⴻⵀⴷ, ⵎⴰⵎⵎⴻⵛ ⵜⴱⴻⴷⴷⴻⴷ ⵖⴰⵔ ⵓⵖⵉⵍ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵜⴻⴵⵉ ⵜⵣⴻⵎⵎⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("JB26_3","019_26_3","JOB","26","3","3","ⵣⴻⵄⵎⴰ ⴰⵇⴰ ⵜⴻⵡⵛⵉⴷ ⴰⵡⴻⵚⵚⵉ ⵉⵙⴻⴱⵃⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵜⴻⴵⵉ ⵜⵉⵖⵉⵜ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵎⵓⵎⵎⵓ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ! ");
INSERT INTO rift_vpl VALUES ("JB26_4","019_26_4","JOB","26","4","4","ⵉ ⵓⵎⵉ ⵜⵄⴰⵡⴷⴻⴷ ⵍⴻⵅⵅⵓ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ? ⵎⴰⵏ ⵏⵏⴻⴼⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⴽ? ");
INSERT INTO rift_vpl VALUES ("JB26_5","019_26_5","JOB","26","5","5","ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ ⴼⴻⵙⵙⵢⴻⵏ ⵙⴰⴷⵓ ⵡⴰⵎⴰⵏ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB26_6","019_26_6","JOB","26","6","6","ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵜⴻⵣⵣⴻⵍ ⵣⵣⴰⵜⴻⵙ ⵍⴰⵅⴰⵔⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵓⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JB26_7","019_26_7","JOB","26","7","7","ⵉⴱⴻⵣⵣⴻⵄ ⴰⵊⴻⵏⵏⴰ ⴷⵉ ⵛⵛⴰⵎⴰⵍ ⵜⵉⵡⴰ ⵍⵅⴰⵡⵉ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ, ⵢⵓⵢⴻⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JB26_8","019_26_8","JOB","26","8","8","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴻⴷⴷⴰ ⴰⵎⴰⵏ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ ⴰⵙⴻⵢⵏⵓ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JB26_9","019_26_9","JOB","26","9","9","ⵉⵙⵙⴷⵓⵔⵔⵓⵢ ⵓⴷⴻⵎ ⵏ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⵅⴰⵙ ⴰⵙⴻⵢⵏⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB26_10","019_26_10","JOB","26","10","10","ⵢⴰⵔⵛⴻⵎ ⵜⴰⵇⵓⵔⴰⵛⵜ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ, ⴰⵍ ⵜⵎⴰ ⵏ ⵜⴼⴰⵡⵜ ⴰⴽ-ⴷ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JB26_11","019_26_11","JOB","26","11","11","ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ, ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵏ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB26_12","019_26_12","JOB","26","12","12","ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵙⵙⵀⴰⵊ ⵍⴻⴱⵃⴰⵔ, ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵉⵍⴱⴻⵣ ⵔⴰⵀⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JB26_13","019_26_13","JOB","26","13","13","ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉⵜⵜⵉⵙⵙⵉⵇ ⵓⵊⴻⵏⵏⴰ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵍⴻⵃⵃⵉⴼⴻⵏ, ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⴰⴼⵉⵖⴰⵔ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵙ ⵜⴰⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JB26_14","019_26_14","JOB","26","14","14","ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵀⴰ ⵉⵅⴻⴼ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵏⴻⵙⵍⴰ ⵎⵖⵉⵔ ⵜⴰⵃⴻⵙⵙⴻⵛⵜ ⵏ ⵛⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵣⵣⴰⵢⴻⵙ. ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴻⵏ ⴰⵊⵊⴰⵊ ⵏ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB27_1","019_27_1","JOB","27","1","1","ⵢⴰⵔⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵓⴱ ⵍⵀⴰⵔⴷ ⵏ ⵍⵎⴰⵜⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB27_2","019_27_2","JOB","27","2","2","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⴽⴽⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵏⵏⵉ ⵉⵙⵙⴰⵔⵣⴰⴳⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB27_3","019_27_3","JOB","27","3","3","ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵏⵏⴻⴼⵙ ⵄⴰⴷ ⴷⴰⵢⵉ ⵓ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB27_4","019_27_4","JOB","27","4","4","ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ ⵍⵖⴻⵛⵛ ⵓ ⵉⵍⴻⵙ ⵉⵏⵓ ⵡⴰⵔ ⵉⵇⵇⴰⵔ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JB27_5","019_27_5","JOB","27","5","5","ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⴰⴷ ⴳⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴷⵉ ⵜⵙⴻⵢⵢⴰⵔⴻⵙⵜ ⵏ ⵜⵉⴷⴻⵜⵜ. ⴰⵍ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⴰⴷ ⵅⴰⴼⵉ ⴽⴽⵙⴻⵏ ⴰⵙⴻⴳⴳⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB27_6","019_27_6","JOB","27","6","6","ⴰⴷ ⵟⵟⴼⴻⵖ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⵅⵅⵓⵖ ⵛⴰ. ⵓⵍ ⵉⵏⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴰⵔⴻⵅⵅⵓ ⵓⵍⴰ ⵅ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB27_7","019_27_7","JOB","27","7","7","ⵎⵍⵉ ⴷⴷ-ⵉⴱⴰⵏ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴷ ⵎⵎⵉⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB27_8","019_27_8","JOB","27","8","8","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵍⴰⵢⴰⵙ ⵏ ⵓⵎⵏⴰⴼⴻⵇ, ⵅⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵅⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵇⵍⴻⵄ ⴰⵔⴻⴱⴱⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB27_9","019_27_9","JOB","27","9","9","ⵎⴰ ⴰⴷ ⵉⵙⴻⵍ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵏⴻⵙ, ⵅⵎⵉ ⵅⴰⵙ ⴷⴷ ⵖⴰ ⵉⵡⴹⴰ ⵍⵃⴻⵚⵔⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB27_10","019_27_10","JOB","27","10","10","ⵎⴰ ⴰⴷ ⵉⴼⴰⵔⵃ ⵖⴰⵔ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ? ⵎⴰ ⴰⴷ ⵉⵍⴰⵖⴰ ⵅ ⴰⵔⴻⴱⴱⵉ ⵎⴻⵍⵎⵉ ⵎⴰ? ");
INSERT INTO rift_vpl VALUES ("JB27_11","019_27_11","JOB","27","11","11","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⵍⴻⵎⴷⴻⵖ ⵅ ⵓⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏ ⵉⵄⴻⵡⵡⴻⵍ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⵜ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB27_12","019_27_12","JOB","27","12","12","ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵎ ⵜⴻⵥⵔⵉⵎ ⵜ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴰⵔⴻⵏⵏⵢⴻⵎ ⵜⴻⵙⵙⵓⴼⴼⵓⵖⴻⵎ ⵎⵉⵏ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵜⴻⵇⵇⴰⵔⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("JB27_13","019_27_13","JOB","27","13","13","“ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵟⵟⴼⴻⵏ ⵣⴻⴳ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ: ");
INSERT INTO rift_vpl VALUES ("JB27_14","019_27_14","JOB","27","14","14","ⵅⵎⵉ ⵖⴰ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵉ ⵙⵙⵉⴼ ⵓⵎⵉ ⵓⵔⵉⵏ. ⵉⵖⴻⴷⴷⵓⵜⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵢⴰⵡⴰⵏⴻⵏ ⴰⵖⵔⵓⵎ,    ");
INSERT INTO rift_vpl VALUES ("JB27_15","019_27_15","JOB","27","15","15","ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵏⴻⴹⵍⴻⵏ ⵙ ⵟⵟⴰⵄⵓⵏ, ⵜⵉⵊⵊⴰⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵔⵓⵏⵜ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JB27_16","019_27_16","JOB","27","16","16","ⵡⴰⵅⵅⴰ ⵉⵊⴰⵔⵔⵓⵡ ⵏⵏⵓⵇⴰⵔⵜ ⴰⵏⴻⵛⵜ ⵏ ⵓⵛⴰⵍ, ⵓ ⵉⵙⵙⴻⵡⵊⴰⴷ ⴰⵔⵔⵓⴹ ⴰⵏⴻⵛⵜ ⵏ ⵓⵛⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("JB27_17","019_27_17","JOB","27","17","17","ⵉⵡⴰ, ⵡⴰⵅⵅⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ, ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵔⴹ ⵓⵛⴰ ⴰⵎⴻⵣⴷⴰⴳ ⴰⴷ ⵉⴱⴹⴰ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB27_18","019_27_18","JOB","27","18","18","ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵜⵛⵉⵏⴷⴰ, ⴰⵎⴻⵛⵏⴰⵡ ⵜⴰⵏⵡⴰⵍⵜ ⵉ ⵉⵙⵙⴱⴻⴷⴷⴰ ⵓⵄⴻⵙⵙⴰⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB27_19","019_27_19","JOB","27","19","19","ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵟⵟⴻⵚ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JB27_20","019_27_20","JOB","27","20","20","ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⴰⴷ ⵅⴰⵙ ⴰⵔⴻⵏⵢⴻⵏ ⴰⵎ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵜⴻⵇⴹⴻⵄ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB27_21","019_27_21","JOB","27","21","21","ⴰⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵛⵛⴰⵔⵇ ⴰⴷ ⵜ ⵉⴽⵙⵉ, ⵉⵡⴰ ⴷⵉⵏⵏⵉ ⵉⵜⵜⵔⴰⵃ, ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵇⵍⴻⵄ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB27_22","019_27_22","JOB","27","22","22","ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⵄⵉⵣⵣⵉ ⵛⴰ. ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⴷⴻⵖⵢⴰ ⵣⵉ ⵜⴻⵛⵜⵉ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB27_23","019_27_23","JOB","27","23","23","ⵉⵡⴷⴰⵏ ⴰⴷ ⵅⴰⵙ ⵡⵡⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵣⵣⴰⵢⴻⵙ ⵙⵜⵀⴻⵣⵣⴰⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵚⴻⴼⴼⴰⵔⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JB28_1","019_28_1","JOB","28","1","1","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⴼ ⵏⵏⵓⵇⴰⵔⵜ, ⵓⵍⴰ ⴷⵉⵏ ⴰⵎⵛⴰⵏ ⵉ ⵡⵓⵔⴻⵖ ⵎⴰⵏⵉ ⵜ ⵙⵙⵉⵣⴷⵉⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_2","019_28_2","JOB","28","2","2","ⵓⵣⵣⴰⵍ ⵜⵜⴰⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵓⵛⴰⵍ ⵓ ⵣⴻⴳ ⵡⴻⵥⵔⵓ ⵙⵙⴼⴻⵙⵙⵢⴻⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB28_3","019_28_3","JOB","28","3","3","ⵉⴳⴳⴰ ⴱⵏⴰⴷⴻⵎ ⵇⴻⵟⵟⵓ ⵉ ⵜⴰⴵⴻⵙⵜ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴷⵉ ⵎⴽⵓⵍ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵎⴰ, ⵅ ⵡⴻⵥⵔⵓ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB28_4","019_28_4","JOB","28","4","4","ⵢⴰⵔⵣⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵅⵊⵉⴹ ⴱⵍⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵃⴻⴷ ⴰⴽⵉⴷⴻⵙ. ⵜⵜⵡⴰⵜⵜⵓⵏ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ, ⵓⵢⵍⴻⵏ ⵜⵜⵔⴰⵃⴻⵏ ⵜⴰⵙⴻⵏ-ⴷⴷ ⴱⵍⴰ ⵉ ⵖⴰ ⵢⴰⵔⵔⴰ ⴰⵙⴻⵏ-ⴷⴷ ⵃⴻⴷ ⵍⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB28_5","019_28_5","JOB","28","5","5","ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵡⴻⵖⵔⵓⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⴰⵅⵎⵉ ⵙ ⵜⵎⴻⵙⵙⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("JB28_6","019_28_6","JOB","28","6","6","ⵉⵥⵔⴰ ⵏⵏⴻⵙ ⴷ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵜⴰⴼⴻⵏ ⵚⴰⴼⴼⵉⵔ, ⴷⴰⵢⴻⵙ ⵉ ⵜⴻⴵⴰ ⵓⵍⴰ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵛⵜ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB28_7","019_28_7","JOB","28","7","7","ⴰⵊⴹⵉⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴰⵎⴻⵙⵔⵓⵇ ⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵜⵉⵟⵟ ⵏ ⵓⵊⴹⵉⴷ ⴰⵎⴻⵙⵙⵖⵓⵢ ⴰⵎⵓⵇⴹⵉⵄ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜ ⵜⴻⵃⴹⵉ. ");
INSERT INTO rift_vpl VALUES ("JB28_8","019_28_8","JOB","28","8","8","ⵉⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵏⴻⴼⴼⵅⴻⵏ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⵢⵓⵔⴻⵏ, ⵓⵍⴰ ⴷ ⴰⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⵡⴰⵔ ⵜ ⵉⵜⵜⵛⵓⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("JB28_9","019_28_9","JOB","28","9","9","ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵉⵙⴰⵔⵔⴻⵃ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⵙⴻⴵⴰⵃ ⵉⵇⴻⵙⵃⴻⵏ, ⵉⵙⵙⵏⴻⵇⵍⴰⴱ ⵉⴷⵓⵔⴰⵔ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("JB28_10","019_28_10","JOB","28","10","10","ⴷⵉ ⵍⴻⵊⵔⵓⴼ ⵉⵇⵇⴰⵣ ⵉⵖⴻⵣⵔⴰⵏ, ⵜⵉⵟⵟ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_11","019_28_11","JOB","28","11","11","ⵉⵃⴻⵡⵡⴻⵇ ⵉ ⵉⵖⴻⵣⵔⴰⵏ ⴰⵍⴰⵎⵉ ⴰⵎⴰⵏ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ, ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵜⵜⴰⵡⵢⵉ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB28_12","019_28_12","JOB","28","12","12","ⵜⵉⵖⵉⵜ ⵎⴰⵛⴰ, ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⴼ? ⵓ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JB28_13","019_28_13","JOB","28","13","13","ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⴼ ⵜⵉⵖⵉⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_14","019_28_14","JOB","28","14","14","ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵇⵇⴰⵔⴻⵏ: ‘ⴷⴰⵢⵏⴻⵖ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ!’, ⵍⴻⴱⵃⴰⵔ ⵉⵇⵇⴰⵔ: ‘ⵖⴰⵔⵉ ⵡⴰⵔ ⴷⴰ ⵜⴻⴵⵉ ⵛⴰ!’ ");
INSERT INTO rift_vpl VALUES ("JB28_15","019_28_15","JOB","28","15","15","ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵙⵙⵓⵎ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵡⴻⵣⵏⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB28_16","019_28_16","JOB","28","16","16","ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵡⴻⵣⵏⴻⵏ ⵙⵙⵓⵎ ⵏⵏⴻⵙ ⵙ ⵡⵓⵔⴻⵖ ⵉⵖⵍⴰⵏ ⵣⵉ ⵓⴼⵉⵔ, ⵙ ⵡⴻⵥⵔⵓ ⵏ ⵓⵏⵉⴽⵙ ⵉⵖⵍⴰⵏ ⴷ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("JB28_17","019_28_17","JOB","28","17","17","ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵎⵎⵇⵓⴷⴷⴰⵏ ⵍⵇⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⴽⵔⵉⵙⵜⴰⵍ, ⵏⵉⵖ ⴰⴷ ⵜⵜ ⴱⴻⴷⴷⵍⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_18","019_28_18","JOB","28","18","18","ⵡⴰⵔ ⵜⵜⴻⵄⵇⵉⵍⴻⵏ ⵄⴰⴷ ⵅ ⵜⵢⴰⵇⵓⵜⵉⵏ ⴷ ⵡⴻⵥⵔⵓ ⵏ ⵓⴽⵔⵉⵙⵜⴰⵍ, ⵎⴰⵖⴰⵔ ⵜⵡⴰⴼⵉⵜ ⵏ ⵜⵉⵖⵉⵜ ⵜⵓⵄⵄⵍⴰ ⵅ ⵜⵡⴰⴼⵉⵜ ⵏ ⵍⵎⴰⵔⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_19","019_28_19","JOB","28","19","19","ⵍⴻⵄⵇⵉⵇ ⴰⵣⴻⴳⴳⵡⴰⵖ ⵣⵉ ⴽⵓⵛ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵡⵉⵙ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵡⵣⴻⵏ ⵜⵉⵖⵉⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_20","019_28_20","JOB","28","20","20","ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⴰ ⵅⴻⵏⵏⵉ ⵜⵉⵖⵉⵜ ⵓ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JB28_21","019_28_21","JOB","28","21","21","ⴰⵇⴰ-ⵜⵜ ⵜⵏⵓⴼⴼⴰⵔ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⵜᵉⵜⵜⵡⴰⵍⴻⵃⵃⴻⴼ ⵅ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JB28_22","019_28_22","JOB","28","22","22","ⴰⵀⴻⵍⵍⴻⴽ ⴷ ⵍⵎⴻⵡⵜ ⵇⵇⴰⵔⴻⵏ: ‘ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵖ ⵏⴻⵙⵍⴰ ⵅⴰⵙ ⵍⴻⵅⴱⴰⵔ!’ ");
INSERT INTO rift_vpl VALUES ("JB28_23","019_28_23","JOB","28","23","23","ⴰⵔⴻⴱⴱⵉ ⵉⴼⴻⵀⵀⴻⵎ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB28_24","019_28_24","JOB","28","24","24","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵍⴰ ⴰⵍ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵥⴰⵔⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB28_25","019_28_25","JOB","28","25","25","ⵓⵎⵉ ⵉⴳⴳⴰ ⵉ ⵓⵙⴻⵎⵎⵉⴹ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵉⵄⴱⴰⵔ ⵍⴻⵄⴱⴰⵔ ⵏ ⵡⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JB28_26","019_28_26","JOB","28","26","26","ⵓⵎⵉ ⵉⴳⴳⴰ ⵉ ⵡⴻⵏⵥⴰⵔ ⵇⴻⵟⵟⵓ, ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉ ⵡⴰⵙⵙⴰⵎ ⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB28_27","019_28_27","JOB","28","27","27","ⵅⴻⵏⵏⵉ ⵉⵥⵔⴰ ⵉ-ⵜⵜ, ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ-ⵜⵜ, ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴻⵇⵇⴻⵛ ⴷⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB28_28","019_28_28","JOB","28","28","28","ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⴱⵏⴰⴷⴻⵎ: ‘ⵅⵣⴰⵔ, ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵙⵉⴷⵉ ⴷ ⵜⵉⵖⵉⵜ, ⴰⴱⴻⵄⵄⴻⴷ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ.’    ");
INSERT INTO rift_vpl VALUES ("JB29_1","019_29_1","JOB","29","1","1","ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵓⴱ ⵍⵀⴰⵔⴷ ⵏ ⵍⵎⴰⵜⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB29_2","019_29_2","JOB","29","2","2","ⵎⵍⵉ ⴵⵉⵖ ⴰⵎ ⴷⴻⴳ ⵓⵢⴻⵏⵏⵉ ⵏ ⵉⵢⵓⵔⴻⵏ ⵉⵄⴷⵓⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ, ⴰⵎ ⴷⴻⴳ ⵓⵢⴻⵏⵏⵉ ⵏ ⵡⵓⵙⵙⴰⵏ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("JB29_3","019_29_3","JOB","29","3","3","ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵍⴻⴼⵏⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⴻⵖ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵓ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵙ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB29_4","019_29_4","JOB","29","4","4","ⵎⵍⵉ ⴵⵉⵖ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵉⵏⵓ, ⵓⵎⵉ ⴰⵎⵓⵏⵉ ⴷⵉ ⵍⴰⵎⴰⵏ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵅ ⵜⵇⵉⴹⵓⵏⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB29_5","019_29_5","JOB","29","5","5","ⵓⵎⵉ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵜⵓⵖⴰ-ⵜ ⵄⴰⴷ ⴰⴽⵉⴷⵉ, ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵄⴰⴷ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ");
INSERT INTO rift_vpl VALUES ("JB29_6","019_29_6","JOB","29","6","6","ⵓⵎⵉ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ ⵜⵓⵖⴰ ⵄⵓⵎⵎⴻⵏ ⴷⵉ ⵜⵔⵓⵙⵙⵉ, ⵓ ⵜⴰⵚⴹⴰⵔⵜ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵣⴻⴵⴰⵄ ⵣⵣⴰⵜⵉ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵣⵣⴻⵛⵜ! ");
INSERT INTO rift_vpl VALUES ("JB29_7","019_29_7","JOB","29","7","7","ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵊⵊⵉⵖ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵢⵉ ⵍⴽⵓⵔⵙⵉ ⵉⵏⵓ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("JB29_8","019_29_8","JOB","29","8","8","ⵏⵏⵓⴼⴰⵔⴻⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵥⵔⵉⵏ, ⵓ ⵉⵎⴻⵛⵛⴰⵢⴱⵓⵜⴻⵏ ⴽⴽⴰⵔⴻⵏ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_9","019_29_9","JOB","29","9","9","ⵍⵃⵓⴽⴽⴰⵎ ⵎⴻⵏⵄⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⵓ ⵙⵙⴰⵔⵙⴻⵏ ⴰⴼⵓⵙ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_10","019_29_10","JOB","29","10","10","ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵜⴻⵙⵇⴰⵔ, ⵉⵍⵙⴻⵇ ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⵖⴰⵔ ⵡⴰⵏⴻⵖ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_11","019_29_11","JOB","29","11","11","ⵎⴰⵍⴰ ⵉⵙⵍⴰ ⴰⵢⵉ ⵓⵎⴻⵣⵣⵓⵖ, ⵉⵙⵙⴻⵎⵖⴰⵔ ⴰⵢⵉ, ⵎⴰⵍⴰ ⵜⴻⵥⵔⴰ ⴰⵢⵉ ⵜⵉⵟⵟ, ⵜⴻⵛⵀⴻⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB29_12","019_29_12","JOB","29","12","12","ⵎⴰⵖⴰⵔ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵍⵎⴻⵙⴽⵉⵏ ⵏⵏⵉ ⵉⵙⵖⵓⵢⴻⵏ, ⴰⵢⵓⵊⵉⵍ ⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵄⴰⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_13","019_29_13","JOB","29","13","13","ⵍⵅⴰⴹⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵄⵍⴰⵢⴻⵏ ⴰⴷ ⵉⵀⴻⵍⵍⴻⴽ, ⵜⵓⵙⴰ-ⴷⴷ ⵅⴰⴼⵉ, ⵓⵍ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⴳⴳⵉⵖ ⵜ ⵉⵙⵍⵉⵡⵍⴻⵡ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB29_14","019_29_14","JOB","29","14","14","ⵢⴰⵔⴹⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ ⵓ ⵜⴰⵙⴻⴳⴷⴰ ⵜⴻⵙⵙⵢⴰⵔⴹ ⴰⵢⵉ. ⵜⵓⵖⴰ ⵛⵛⵔⴻⵄ ⵉⵏⵓ ⴰⵎ ⵓⵙⴻⵍⵀⴰⵎ ⵓ ⴰⵎ ⴰⵔⴻⵥⵥⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB29_15","019_29_15","JOB","29","15","15","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵓⵍⴰ ⴷ ⵉⴹⴰⵔⴻⵏ ⵉ ⵉⵇⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_16","019_29_16","JOB","29","16","16","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉ ⵉⵎⴻⵣⵍⴰⴹ, ⵓⵛⴰ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ, ⴱⴻⵇⵇⵛⴻⵖ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JB29_17","019_29_17","JOB","29","17","17","ⴰⵔⵥⵉⵖ ⵜⵉⵖⵎⴰⵙ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓⵛⴰ ⴽⴽⵙⴻⵖ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵜⴻⵖⵎⴰⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB29_18","019_29_18","JOB","29","18","18","ⵏⵏⵉⵖ: ‘ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵅ ⵍⵄⵓⵛⵛ ⵉⵏⵓ, ⴰⴷ ⴷⴷⴰⵔⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵜⴰⵣⵉⵔⴰⵔⵜ ⴰⵎ ⵓⵊⴹⵉⴷ ⵏ ⴼⵓⵏⵉⴽⵙ.’ ");
INSERT INTO rift_vpl VALUES ("JB29_19","019_29_19","JOB","29","19","19","ⵉⵥⴻⵡⵔⴰⵏ ⵉⵏⵓ ⴱⴻⵣⵣⵄⴻⵖ ⵜⴻⵏ ⴰⵍ ⴰⵎⴰⵏ ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⵇⵇⵉⵎ ⵏⵏⴷⴰ ⵅ ⵍⴻⴼⵔⵓⵄ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB29_20","019_29_20","JOB","29","20","20","ⵜⵓⵖⴰ ⵍⵄⴻⵣⵣ ⵉⵏⵓ ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⵉ ⵍⴻⴱⴷⴰ, ⵍⵇⴻⵡⵙ ⵉⵏⵓ ⵉⵙⵀⴻⵍ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JB29_21","019_29_21","JOB","29","21","21","ⵙⵍⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ, ⵔⴰⵊⴰⵏ, ⵙⵇⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵛⵛⵡⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB29_22","019_29_22","JOB","29","22","22","ⴰⵡⴰⵔⵏⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵓⴷⵓⵎⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_23","019_29_23","JOB","29","23","23","ⵏⵉⵜⵏⵉ ⵔⴰⵊⴰⵏ ⴰⵢⵉ ⴰⵎ ⵔⴰⵊⴰⵏ ⴰⵏⵥⴰⵔ, ⴰⵔⵣⵎⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⴰⵎ ⵜ ⴰⵔⴻⵣⵎⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵥⴰⵔ ⵏ ⵜⴻⴼⵙⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JB29_24","019_29_24","JOB","29","24","24","ⵎⴰⵍⴰ ⵙⴼⴰⵔⵏⵉⵏⴻⵖ ⵖⴰⵔⵙⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵄⴰⴷ ⴰⴷ ⵜⵜⵉⵇⵇⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⴼⴰⵡⵜ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵡⴰⵔ ⵣⵎⵉⵔⴻⵏ ⴰⴷ ⴽⵉⴷⴻⵙ ⵎⵎⵄⴰⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB29_25","019_29_25","JOB","29","25","25","ⵉⵅⴹⴰⵔⴻⵖ ⴰⵙⴻⵏ ⴰⴱⵔⵉⴷ, ⴱⴻⴷⴷⴻⵖ ⴰⵙⴻⵏ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ, ⵣⴻⴷⵖⴻⵖ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵊⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴻⵣⵣⴰⵏ ⵉⵏⵏⵉ ⵉⵛⴻⴹⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_1","019_30_1","JOB","30","1","1","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴹⴻⵃⵃⵛⴻⵏ ⵅⴰⴼⵉ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵅⴰⴼⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ, ⵉⵏⵏⵉ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵡⴰⵔ ⵖⴰⵔⵉ ⵙⴻⴽⴽⵡⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⵖⴰⵔ ⵢⵉⵟⴰⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴵⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB30_2","019_30_2","JOB","30","2","2","ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵅⴻⵏⵏⵉ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ? ⴰⵇⴰ ⵉⴼⵏⴰ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴻⵡⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB30_3","019_30_3","JOB","30","3","3","ⵣⵉ ⵍⵇⵉⴵⴻⵜ ⵓ ⵣⵉ ⵍⴰⵥ ⴷⴻⵡⵍⴻⵏ ⵉⵙⵔⵉⵡⴻⵏ, ⵜⵜⵎⴻⵖⵣⴰⵣⴻⵏ ⴷⵉ ⵍⵡⴰⵟⴰ ⵢⵓⵥⵖⴻⵏ ⴷⵉ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵔⴻⴷⴷⴻⴵ ⴷ ⵓⵔⴻⴱⴱⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JB30_4","019_30_4","JOB","30","4","4","ⵏⵉⵜⵏⵉ ⵍⴻⵇⵇⴹⴻⵏ ⵍⴻⴱⵣⴰⵔ ⴰⵎⴻⴵⴰⵃ ⵊⴰⵔ ⵛⴱⴰⵔⵇ, ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵓⵣⴻⵣⵣⵓ ⴷ ⴰⵖⵔⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_5","019_30_5","JOB","30","5","5","ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙⴻⵏ ⵣⵉ ⵜⵎⵓⵏⴻⵜ ⵏ ⵉⵡⴷⴰⵏ, ⴽⴽⵡⴰⵔⴻⵏ ⵜⴻⵏ ⴰⵎ ⵢⵉⵅⴻⵡⵡⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB30_6","019_30_6","JOB","30","6","6","ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵏ ⵓⵛⴰⵍ ⵓ ⴷⵉ ⵍⴻⵊⵔⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("JB30_7","019_30_7","JOB","30","7","7","ⵙⵖⵓⵢⵢⵓⵏ ⵊⴰⵔ ⵛⴱⴰⵔⵇ, ⵙⴰⴷⵓ ⵜⵉⵣⴻⴳⴳⵡⴰⵔⵉⵏ ⵙⵙⵎⵓⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_8","019_30_8","JOB","30","8","8","ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⴱⵍⴰ ⵉⵙⴻⵎ, ⴷ ⵉⵏⵏⵉ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵓⵣⴻⴵⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("JB30_9","019_30_9","JOB","30","9","9","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⴰⵇⴰ ⴰⵢⵉ ⴷⴻⴳ ⵉⵣⵍⵉ ⵏⵙⴻⵏ ⵏ ⵜⵥⴰⵡⴰⵔⵜ, ⴷⴻⵡⵍⴻⵖ ⴰⵙⴻⵏ ⵉ ⵍⵀⴰⵔⴷ.    ");
INSERT INTO rift_vpl VALUES ("JB30_10","019_30_10","JOB","30","10","10","ⵛⴰⵔⵔⵀⴻⵏ ⴰⵢⵉ, ⵜⵜⴰⴳⴳⵯⴰⵊⴻⵏ ⵅⴰⴼⵉ, ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵓⵙⴼⴻⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB30_11","019_30_11","JOB","30","11","11","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴼⵙⵉ ⴰⵙⵖⵓⵏ ⵏ ⵜⵇⵉⴹⵓⵏⵜ ⵉⵏⵓ ⵓⵛⴰ ⵉⵙⵙⴻⵀⵡⴰ ⴰⵢⵉ. ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵙⵙⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("JB30_12","019_30_12","JOB","30","12","12","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵉⵏⵓ ⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵉⵖⴻⴷⴷⵉⵡⴻⵏ ⵏ ⵜⴰⵔⵔⴰⵡⵜ, ⵄⴰⵔⵔⵏⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ, ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵅⴰⴼⵉ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_13","019_30_13","JOB","30","13","13","ⴰⴱⵔⵉⴷ ⵉⵏⵓ ⴰⵔⵥⵉⵏ ⵜ, ⴰⵔⴻⵏⵏⵢⴻⵏ ⵜⴰⵎⴰⵔⴰ ⵅ ⵜⴰⵎⴰⵔⴰ ⵉⵏⵓ ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⴵⵉ ⵡⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵉⵡⵛⴻⵏ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JB30_14","019_30_14","JOB","30","14","14","ⴰⵅⵎⵉ ⴷⴷ-ⵜⵜⴰⵙⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵏⵓⵇⵇⵉⴱ ⴷ ⵎⵉⵔⵉⵡ, ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵎ ⵍⴻⵎⵡⴰⵊ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_15","019_30_15","JOB","30","15","15","ⵜⵜⵡⴰⴽⴻⴱⴱⴻⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ, ⴰⵎ ⵓⵙⴻⵎⵎⵉⴹ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵛⵛⴰⵏ ⵉⵏⵓ, ⵉⴹⵡⴰ ⵣⵣⵀⴰⵔ ⵉⵏⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB30_16","019_30_16","JOB","30","16","16","ⵙ ⵓⵢⴰ ⵉⴼⴻⵙⵙⵉ ⵍⴻⵅⵅⵓ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⴰⵢⵉ, ⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵖⴱⴻⵏ ⵎⴻⵏⵏⵄⴻⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB30_17","019_30_17","JOB","30","17","17","ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⵙⵙⵏⵓⵇⵇⵓⴱ ⴰⵢⵉ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵉ ⴷⴰⵢⵉ ⵉⴵⴰⵏ, ⵍⴻⵃⵔⵉⵇ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵖⴻⵣⵣⴰⵏ ⵡⴰⵔ ⵢⴰⵔⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JB30_18","019_30_18","JOB","30","18","18","ⵉⵜⵜⵡⴰⴱⴻⴷⴷⴻⵍ ⵡⴰⵔⵔⵓⴷ ⵉⵏⵓ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⴻⵄⵇⵉⵍⴻⵏ ⵄⴰⴷ. ⵉⵛⴰⵔⴼ ⴰⵢⵉ ⴰⵎ ⵜⵎⴰ ⵉ ⵉⵏⵏⴹⴻⵏ ⵉ ⵡⴰⵔⵣⴻⵎ ⵏ ⵢⵉⵔⵉ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JB30_19","019_30_19","JOB","30","19","19","ⵉⵏⴹⴰⵔ ⴰⵢⵉ ⴷⴻⴳ ⵓⴱⴻⴵⴰⵄ, ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵓⵛⴰⵍ ⴷ ⵢⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("JB30_20","019_30_20","JOB","30","20","20","ⵙⵖⵓⵢⵢⵓⵖ ⵖⴰⵔⴻⴽ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵜᵉⵜⵜⴰⵔⵔⵉⴷ, ⵏⴻⵛⵛ ⴱⴻⴷⴷⴻⵖ ⴷⴰ ⵓⵛⴰ ⵛⴻⴽ ⵜᵉⵇⵇⵉⵎⴻⴷ ⵜⵃⴻⵟⵟⵉⴷ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JB30_21","019_30_21","JOB","30","21","21","ⵛⴻⴽ ⵜⴷⴻⵡⵍⴻⴷ ⴰⵢⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ, ⵜᵉⵜⵜⴷⴰⵔⵔⴰⵛⴻⴷ ⵅⴰⴼⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_22","019_30_22","JOB","30","22","22","ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷⴻⴷ ⴰⵢⵉ ⵓ ⵜⵏⴻⴷⴷⵀⴻⴷ ⴰⵢⵉ ⴷⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵜⴻⵙⵙⴻⴼⵔⴰⵖⴻⴷ ⵇⴰⵄ ⴰⴷⴷⵓⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB30_23","019_30_23","JOB","30","23","23","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⵏⴻⴷⵀⴻⴷ ⵖⴰⵔ ⵍⵎⴻⵡⵜ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜⵜⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB30_24","019_30_24","JOB","30","24","24","ⵎⴰ ⵡⴰⵔ ⵉⵏⴻⵟⵟⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵎⴰⵍⴰ ⵉⵡⴹⴰ ⵃⴻⴷ, ⵎⴰ ⵡⴰⵔ ⵉⵙⵖⵓⵢⵢⵓ ⵡⴰⵍⵓ ⵇⴰⵄ ⵖⴰⵔ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB30_25","019_30_25","JOB","30","25","25","ⵎⴰ ⵡⴰⵔ ⵔⵓⵖ ⵅ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴰⵎⴰⵔⴰ, ⵎⴰ ⵡⴰⵔ ⵉⵛⴹⵉⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵅ ⵓⵎⴻⵣⵍⵓⴹ? ");
INSERT INTO rift_vpl VALUES ("JB30_26","019_30_26","JOB","30","26","26","ⵓⵎⵉ ⵙⵙⵉⵜⵎⴻⵖ ⵖⴰⵔ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵓⵎⵉ ⵔⴰⵊⵉⵖ ⵜⴰⴼⴰⵡⵜ, ⵜⵓⵙⴰ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JB30_27","019_30_27","JOB","30","27","27","ⴰⴷⴰⵏ ⵉⵏⵓ ⵜⵜⵏⴻⵏⵏⴰⵏ, ⵡⴰⵔ ⴰⵔⵙⵉⵏ, ⵉⵡⴹⴻⵏ-ⴷⴷ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴰⵎⴰⵔⴰ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JB30_28","019_30_28","JOB","30","28","28","ⵏⴻⵛⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴷⴻⴳ ⵡⴻⵛⴹⴰⵏ, ⴱⵍⴰ ⵍⴻⵀⵎⵓ ⵏ ⵜⴼⵓⵛⵜ. ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵙⵖⵓⵢⵢⵓⵖ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JB30_29","019_30_29","JOB","30","29","29","ⵉ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⵓⵎⴰⵜⵙⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⵏⵏⵄⴰⵎⴻⵜ ⴷ ⴰⵎⵄⴰⵛⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB30_30","019_30_30","JOB","30","30","30","ⵜⵉⵍⵎⴻⵛⵜ ⵉⵏⵓ ⵜⴻⴷⵡⴻⵍ ⵅⴰⴼⵉ ⴷ ⴰⴽⴰⵔⴽⵓⵛ ⴰⴱⴰⵔⵛⴰⵏ, ⵣⵉ ⵜⵎⴻⵙⵙⵉ ⵛⴻⵎⵎⴹⴻⵏ ⵉⵖⵙⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB30_31","019_30_31","JOB","30","31","31","ⵜⴻⴷⵡⴻⵍ ⵜⵉⵔⴰⵔⵜ ⵏ ⵍⴳⴰⵎⴱⵔⵉ ⵉⵏⵓ ⵉ ⵡⴻⵛⴹⴰⵏ, ⵜⴰⵎⵊⴰ ⵉⵏⵓ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB31_1","019_31_1","JOB","31","1","1","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵅⵣⴰⵔⴻⵖ ⵅⴻⵏⵏⵉ ⴷⵉ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("JB31_2","019_31_2","JOB","31","2","2","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵅⴻⵏⵏⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⵏⵉⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵢⵓⵄⵍⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB31_3","019_31_3","JOB","31","3","3","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⴹⴻⵢⵢⴻⵄ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵉ ⵓⵄⴻⴼⴼⴰⵏ, ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JB31_4","019_31_4","JOB","31","4","4","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵏⴻⵜⵜⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ, ⵎⴰ ⵡⴰⵔ ⵉⵃⴻⵙⵙⴻⴱ ⵏⴻⵜⵜⴰ ⵍⵇⴻⴷⴷ ⵏ ⵎⴰⵔⵔⴰ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB31_5","019_31_5","JOB","31","5","5","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵓⵢⵓⵔⴻⵖ ⴷⵉ ⵍⴻⵅⴷⴻⵄ, ⵏⵉⵖ ⵉⵇⴻⴵⴻⵇ ⵓⴹⴰⵔ ⵉⵏⵓ ⵖⴰⵔ ⵍⵖⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("JB31_6","019_31_6","JOB","31","6","6","ⴻⵊⵊ ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵡⵣⴻⵏ ⵅⴻⵏⵏⵉ ⴷⵉ ⵍⵎⵉⵣⴰⵏⴰⵜ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB31_7","019_31_7","JOB","31","7","7","ⵎⴰⵍⴰ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵓⵍ ⵉⵏⵓ ⵉⴹⴼⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵍⵚⴻⵇ ⵍⵄⵉⴱ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB31_8","019_31_8","JOB","31","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⴰⵔⵄⴻⵖ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵛⵛ, ⵓ ⵎⵉⵏ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵖⴻⵎⵎⴰⵢⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵇⵍⴻⵄ! ");
INSERT INTO rift_vpl VALUES ("JB31_9","019_31_9","JOB","31","9","9","ⵎⴰⵍⴰ ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵖⵡⴰ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵏⵉⵖ ⵜⵓⵖⴰ ⵜⵜⵃⴰⵎⵉⵖ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵊⵊⴰⵔ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB31_10","019_31_10","JOB","31","10","10","ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⵜⴻⵃⵔⵉ ⵉⵎⴻⵏⴷⵉ ⵉ ⵢⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵊⵊⴻⵎ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵅⴰⵙ ⴰⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB31_11","019_31_11","JOB","31","11","11","ⵎⴰⵖⴰⵔ ⴰⵢⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⴷ ⵉⵛⵜ ⵏ ⵍⵊⴰⵔⵉⵎⴰ ⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵡⵜⴻⵏ ⵍⵇⵓⴹⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JB31_12","019_31_12","JOB","31","12","12","ⵎⴰⵖⴰⵔ ⴰⵢⴰ ⴷ ⵜⵉⵎⴻⵙⵙⵉ ⵜᵉⵜⵜⴻⵜⵜ ⴰⵍ ⴰⵀⴻⵍⵍⴻⴽ, ⵜⵇⴻⴵⴻⵄ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB31_13","019_31_13","JOB","31","13","13","ⵎⴰⵍⴰ ⵙⵙⵃⴻⵇⵇⴰⵔⴻⵖ ⵍⵃⴻⵇⵇ ⵏ ⵉⵙⵎⴻⵖ ⵉⵏⵓ ⴷ ⵜⴰⵢⵢⴰ ⵉⵏⵓ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⴰⴽⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("JB31_14","019_31_14","JOB","31","14","14","ⵎⵉⵏ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵉⴽⴽⴰⵔ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵇⴻⴵⴻⴱ ⴰⵢⵉ, ⵎⵉⵏ ⵅⴰⵙ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵖ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JB31_15","019_31_15","JOB","31","15","15","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵎⴰ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JB31_16","019_31_16","JOB","31","16","16","ⵎⴰⵍⴰ ⵇⴻⵎⵎⵃⴻⵖ ⴰⵎⴻⵥⵔⵉ ⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵏⵉⵖ ⵙⵙⵔⵓⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⴰⵊⵊⴰⵍⵜ, ");
INSERT INTO rift_vpl VALUES ("JB31_17","019_31_17","JOB","31","17","17","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵎⵖⵉⵔ ⵛⵛⵉⵖ ⴰⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉⵏⵓ, ⴰⵎ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵛⵉ ⵓⵢⵓⵊⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("JB31_18","019_31_18","JOB","31","18","18","- ⵎⴰⵖⴰⵔ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵢⵎⴰ ⵏⴻⵜⵜⴰ ⵖⴰⵔⵉ ⴰⵎ ⵉⵢⵎⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ ⵏⴻⴷⵀⴻⵖ ⵜⵜ - ");
INSERT INTO rift_vpl VALUES ("JB31_19","019_31_19","JOB","31","19","19","ⵎⴰⵍⴰ ⵥⵔⵉⵖ ⵉⵊⵊⴻⵏ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⴵⵉ ⵡⴰⵔⵔⵓⴹ, ⵏⵉⵖ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴷⴷⵓⵔⵉ ⵉ ⵓⵎⴻⵣⵍⵓⴹ, ");
INSERT INTO rift_vpl VALUES ("JB31_20","019_31_20","JOB","31","20","20","ⵎⴰⵍⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴱⴰⵔⴽⴻⵏⵜ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⴳⴳⴰ ⴰⴷ ⵉⵙⵙⵉⵃⵎⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⴵⴰⵙ ⵏ ⵜⴹⵓⴼⵜ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB31_21","019_31_21","JOB","31","21","21","ⵎⴰⵍⴰ ⴰⴼⵓⵙ ⵉⵏⵓ ⵉⵀⵓⴷⴷ ⵅ ⵓⵢⵓⵊⵉⵍ, ⵎⵉⵏⵣⵉ ⵥⵔⵉⵖ ⴰⵇⴰ ⴷⵉⵏ ⵜⵡⵉⵣⴰ ⵉ ⵏⴻⵛⵛ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("JB31_22","019_31_22","JOB","31","22","22","ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⴹⴰ ⵜⴻⵖⵔⵓⴹⵜ ⵉⵏⵓ ⵣⴻⴳ ⵉⵊⵉⵎⴰⵏ, ⴰⴷ ⴰⵢⵉ ⵢⴰⵔⵥ ⵓⵖⵉⵍ ⵉⵏⵓ ⵣⴻⴳ ⵢⵉⵖⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("JB31_23","019_31_23","JOB","31","23","23","ⵎⴰⵖⴰⵔ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵉⵡⴹⴰ ⵓⵏⴻⵅⵍⵉⵄ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵛⵜ ⵏ ⵍⵎⵓⵚⵉⴱⴻⵜ ⵣⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵡⴰⵍⵓ ⵣⵣⴰⵜ ⵉ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB31_24","019_31_24","JOB","31","24","24","ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵓⵔⴻⵖ ⴷ ⴰⵜⴻⵛⵍⵉ ⵉⵏⵓ, ⵏⵉⵖ ⵏⵏⵉⵖ ⵉ ⵡⵓⵔⴻⵖ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ: ‘ⵛⴻⴽ ⴷ ⵍⴰⵎⴰⵏ ⵉⵏⵓ!’, ");
INSERT INTO rift_vpl VALUES ("JB31_25","019_31_25","JOB","31","25","25","ⵎⴰⵍⴰ ⴼⴰⵔⵃⴻⵖ ⵓⵎⵉ ⵉⵎⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵉⵏⵓ, ⵓⵎⵉ ⴰⴼⵓⵙ ⵉⵏⵓ ⵉⵟⵟⴻⴼ ⴰⵟⵟⴰⵙ ⴷ ⴰⴳⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("JB31_26","019_31_26","JOB","31","26","26","ⵎⴰⵍⴰ ⵥⵔⵉⵖ ⵜⴰⴼⴰⵡⵜ ⵏ ⵜⴼⵓⵛⵜ ⵅⵎⵉ ⵜᵉⵜⵜⵡⴻⵙⵙⴻⴳ, ⵏⵉⵖ ⵜⴰⵣⵉⵔⵉ ⵅⵎⵉ ⵜⴻⴳⴳⵓⵔ ⴷⵉ ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB31_27","019_31_27","JOB","31","27","27","ⵓⵛⴰ ⵉⵜⵜⵡⴰⵖⵡⴰ ⵡⵓⵍ ⵉⵏⵓ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵓⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ ⵓⴼⵓⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB31_28","019_31_28","JOB","31","28","28","ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⴷ ⵜⵜ ⵡⵛⴻⵏ ⵉ ⵍⵇⵓⴹⴰⵜ, ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴽⴰⵔⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JB31_29","019_31_29","JOB","31","29","29","ⵎⴰⵍⴰ ⴼⴰⵔⵃⴻⵖ ⵉ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⴼⴰⵔⵃⴻⵖ ⵓⵎⵉ ⵜ ⵉⵍⵇⴻⴼ ⵍⵖⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("JB31_30","019_31_30","JOB","31","30","30","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵡⴰⵔ ⵊⵊⵉⵖ ⴰⵏⴻⵖ ⵉⵏⵓ ⴰⴷ ⵉⵅⴹⴰ, ⵓⵎⵉ ⴽⴽⵡⴰⵔⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵙ ⵏⵏⴻⵄⵍⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("JB31_31","019_31_31","JOB","31","31","31","ⵎⴰⵍⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵉⵏⵓ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵊⵉⵡⵏⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ?’ ");
INSERT INTO rift_vpl VALUES ("JB31_32","019_31_32","JOB","31","32","32","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵉⵙⵙⴻⵏⵙ ⴷⵉ ⴱⴰⵔⵔⴰ ⵅ ⵡⴻⴱⵔⵉⴷ, ⵎⴰⵖⴰⵔ ⵉ ⵓⵎⵙⴻⴱⵔⵉⴷ ⴰⵔⵣⵎⴻⵖ ⵜⵉⵡⵡⵓⵔⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB31_33","019_31_33","JOB","31","33","33","ⵎⴰⵍⴰ ⵏⴻⵛⵛ, ⴰⵎ ⴰⴷⴰⵎ, ⴷⵍⵉⵖ ⴰⵅⴻⵟⵟⵓ ⵉⵏⵓ, ⵓⵎⵉ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JB31_34","019_31_34","JOB","31","34","34","ⵎⵉⵏⵣⵉ ⴳⴳⵯⴻⴷⴻⵖ ⵣⵉ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵏⵉⵖ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ ⴰⵢⵉ ⵓⵙⴻⵃⵇⴰⵔ ⵏ ⵍⵡⴰⵛⵓⵏ ⵉⵏⵓ, ⴰⵍⴰⵎⵉ ⵇⵇⵉⵎⴻⵖ ⵙⵙⴻⵖⴷⴻⵖ, ⵡⴰⵔ ⴼⴼⵉⵖⴻⵖ ⵄⴰⴷ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ... ");
INSERT INTO rift_vpl VALUES ("JB31_35","019_31_35","JOB","31","35","35","ⵎⵍⵉ ⵖⴰⵔⵉ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵍⴻⵏ. ⵅⵣⴰⵔ, ⴰⵛⴻⵎⵎⵉⵄ ⵉⵏⵓ - ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔ - ⵓⵍⴰ ⴷ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⵉ ⵜ ⵢⵓⵔⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB31_36","019_31_36","JOB","31","36","36","ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⵎⴰ ⵡⴰⵔ ⵜ ⴰⵔⴻⴱⴱⵓⵖ ⵅ ⵜⵖⴰⵔⴹⵜ ⵉⵏⵓ, ⴰⴷ ⵜ ⵇⵇⵏⴻⵖ ⵉ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵜⵜⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("JB31_37","019_31_37","JOB","31","37","37","ⵉⵡⴰ, ⴰⴷ ⴰⵙ ⵉⵏⵉⵖ ⵍⵇⴻⴷⴷ ⵏ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ, ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB31_38","019_31_38","JOB","31","38","38","ⵎⴰⵍⴰ ⵍⴻⵄⵔⴰⵚⵉ ⵉⵏⵓ ⵉⵙⵖⵓⵢ ⵅⴰⴼⵉ, ⵉⵄⴻⵢⵢⴰⴷⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵔⵓⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵎⴰⵔⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("JB31_39","019_31_39","JOB","31","39","39","ⵎⴰⵍⴰ ⵛⵛⵉⵖ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵏⵀⵍⴰ ⴰⵅⴻⴵⴻⵚ, ⵏⵉⵖ ⴳⴳⵉⵖ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵉⴹⵍⴻⵇ ⵉ ⴱⵓⵃⴱⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("JB31_40","019_31_40","JOB","31","40","40","ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵖⵎⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⵉⵔⴷⴻⵏ, ⵓⵍⴰ ⴷ ⵍⴻⵄⵛⵓⴱ ⵢⴰⵔⵚⵓⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ⴰⵇⴰ ⴷⴰ ⵉ ⵇⴹⴰⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵢⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JB32_1","019_32_1","JOB","32","1","1","ⵅⴻⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵅ ⴰⵢⵓⴱ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB32_2","019_32_2","JOB","32","2","2","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵖⴰ ⵍⵖⴰⴹⴰⴱ ⵏ ⵉⵍⵉⵀⵓ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⵉⵍ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵓⵣ, ⵣⵉ ⵍⴰⴵ ⵏ ⵔⴰⵎ. ⵢⴰⵔⵖⴰ ⵍⵖⴰⴹⴰⴱ ⵏⵏⴻⵙ ⵅ ⴰⵢⵓⴱ ⵎⵉⵏⵣⵉ ⵉⴳⴳⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵅ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB32_3","019_32_3","JOB","32","3","3","ⵢⴰⵔⵖⴰ ⵍⵖⴰⴹⴰⴱ ⵏⵏⴻⵙ ⵓⵍⴰ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⵉⵏ ⵣⵉ ⵅⴰⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ, ⴰⵔⵔⵉⵏ ⵍⵄⵉⴱ ⴷⵉ ⴰⵢⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JB32_4","019_32_4","JOB","32","4","4","ⵉⵍⵉⵀⵓ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵔⴰⵊⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵢⵓⴱ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵎⵖⴰⵔⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB32_5","019_32_5","JOB","32","5","5","ⵓⵎⵉ ⵉⵥⵔⴰ ⵉⵍⵉⵀⵓ, ⴰⵇⴰ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⵉⵏ ⵣⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵄⴰⴷ, ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB32_6","019_32_6","JOB","32","6","6","ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉⵍⵉⵀⵓ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵉⵍ, ⵣⵉ ⴱⵓⵣ, ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⴻⵛⵛⴰⵢⴱⵓⵜⴻⵏ. ⵅ ⵓⵢⴰ ⵔⴰⵊⵉⵖ ⵓ ⴱⴱⵓⵔⵔⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵜⵓⵙⵙⵏⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB32_7","019_32_7","JOB","32","7","7","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ, ⴻⵊⵊ ⵍⵇⴻⴷⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵓⵎⴻⵛⵛⴰⵢⴱⵓ ⴰⴷ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵜⵉⵖⵉⵜ.’ ");
INSERT INTO rift_vpl VALUES ("JB32_8","019_32_8","JOB","32","8","8","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴱⵓⵃⴱⴻⵍ ⵉⵣⴷⴻⵖ ⴷⵉ ⴱⵏⴰⴷⴻⵎ, ⴰⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⵜⵜⵉⵛ ⴰⵙⴻⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB32_9","019_32_9","JOB","32","9","9","ⵉⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⴻⴵⵉ ⵜⵉⵖⵉⵜ, ⵉⵡⴻⵙⵙⵓⵔⴰ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ ⵉ ⵛⵛⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("JB32_10","019_32_10","JOB","32","10","10","ⵙ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵖ: ‘ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵜⵓⵙⵙⵏⴰ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("JB32_11","019_32_11","JOB","32","11","11","ⵅⵣⴰⵔ, ⵔⴰⵊⵉⵖ ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ, ⵙⵙⵃⴻⵙⵙⴻⵖ ⵖⴰⵔ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵡⴻⵎ, ⴰⵎ ⵜⵓⵖⴰ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB32_12","019_32_12","JOB","32","12","12","ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵎⵍⵉⵃ, ⴰⵇⴰ ⴷⴰ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵇⵏⴻⵄ ⴰⵢⵓⴱ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB32_13","019_32_13","JOB","32","13","13","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⵓⴼⴰ ⵜⵉⵖⵉⵜ! ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵏⴹⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⴱⵏⴰⴷⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("JB32_14","019_32_14","JOB","32","14","14","ⵡⴰⵔ ⴵⵉⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵅⴰⴼⵉ ⵓ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JB32_15","019_32_15","JOB","32","15","15","ⵜⵜⵡⴰⵔⵏⴰⵏ ⵏⵉⵜⵏⵉ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉⵏ ⵄⴰⴷ, ⴰⵡⴰⵍⴻⵏ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB32_16","019_32_16","JOB","32","16","16","ⵍⴰⵊⵉⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵡⴰⵍ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB32_17","019_32_17","JOB","32","17","17","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ ⴷⵉ ⵏⵏⵓⴱⴻⵜ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵜⵓⵙⵙⵏⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB32_18","019_32_18","JOB","32","18","18","ⵎⴰⵖⴰⵔ ⵛⵛⵓⵔⴻⵖ ⵙ ⵡⴰⵡⴰⵍⴻⵏ, ⵉⵃⴻⵙⵙⴰⵔ ⴰⵢⵉ ⴱⵓⵃⴱⴻⵍ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB32_19","019_32_19","JOB","32","19","19","ⵅⵣⴰⵔ, ⴰⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ ⵉⵜⵜⴻⴳⴳ ⴰⵎ ⵜⵣⵉⵢⵢⴰⵜ ⵏ ⴱⵉⵏⵓ ⵡⴰⵔ ⵢⴰⵔⵣⵉⵎⴻⵏ ⵄⴰⴷ, ⴰⵎ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵢⵉⵍⴻⵎ ⵏ ⵊⴷⵉⴷ, ⴰⵇⴰ ⵉⵜⵜⴻⴳⴳ ⴰⵅⵎⵉ ⵉ ⵖⴰ ⵉⴷⴷⵓⵇⵇⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("JB32_20","019_32_20","JOB","32","20","20","ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴼⵙⵓⵙⴻⵖ, ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB32_21","019_32_21","JOB","32","21","21","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵉⵖ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⴰⴽ-ⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵥⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB32_22","019_32_22","JOB","32","22","22","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵣⵉⴹⴻⵏ, ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⴽⴽⴻⵙ ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB33_1","019_33_1","JOB","33","1","1","ⵙⴻⵍ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵍⵀⴰⵔⴷ ⵉⵏⵓ, ⴰⵢⵓⴱ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JB33_2","019_33_2","JOB","33","2","2","ⵅⵣⴰⵔ, ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵉⵙⵙⴰⵡⴰⵍ ⵢⵉⵍⴻⵙ ⵉⵏⵓ ⵙⴰⴷⵓ ⵡⴰⵏⴻⵖ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB33_3","019_33_3","JOB","33","3","3","ⵜⵜⴻⴼⴼⵖⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵣⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⵉⵏⵓ, ⵜⵓⵙⵙⵏⴰ ⵜⴻⵇⵇⵓⵔ ⴰⴷ ⵅⴰⵙ ⵀⴰⵔⵔⴷⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB33_4","019_33_4","JOB","33","4","4","ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵢⵉ, ⴰⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB33_5","019_33_5","JOB","33","5","5","ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ, ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ. ⵙⴰⵔⵙ ⴰⵢⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ, ⴱⴻⴷⴷ ⵣⵣⴰⵜⵉ! ");
INSERT INTO rift_vpl VALUES ("JB33_6","019_33_6","JOB","33","6","6","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵎ ⵛⴻⴽ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵜⵜⵡⴰⴳⴳⴻⵖ ⵣⴻⴳ ⵓⴱⴻⴵⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JB33_7","019_33_7","JOB","33","7","7","ⵅⵣⴰⵔ, ⴰⵀⵓⴷⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵉⴳⴳⵯⵉⴷ ⵛⴰ, ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⵣⴻⵢⵢⴰⵔⴻⵖ ⵛⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB33_8","019_33_8","JOB","33","8","8","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⵜⴻⵏⵏⵉⴷ ⵜ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⵙⵍⵉⵖ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ: ");
INSERT INTO rift_vpl VALUES ("JB33_9","019_33_9","JOB","33","9","9","‘ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⴱⵍⴰ ⴷⴷⴻⵏⴱ, ⴷ ⴰⴼⵓⵔⵔⵉ ⵉ ⴵⵉⵖ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵛⴰ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB33_10","019_33_10","JOB","33","10","10","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵙⵙⵉⴱⴱⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⵛⴻⵜⵛⴰ, ⵉⵃⴻⵙⵙⴻⴱ ⴰⵢⵉ ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB33_11","019_33_11","JOB","33","11","11","ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵉⵇⵇⴻⵏ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵓⴽⴻⵛⵛⵓⴹ, ⵉⵃⴻⵟⵟⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵙⵔⴰⵇ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("JB33_12","019_33_12","JOB","33","12","12","ⵅⵣⴰⵔ, ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵓⵢⴰ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB33_13","019_33_13","JOB","33","13","13","ⵎⵉⵏ ⵅⴻⴼ ⴽⵉⴷⴻⵙ ⵜᵉⵜⵜⴻⵎⵄⴰⵔⵔⵉⴷ? ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵃⵙⴰⴱ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("JB33_14","019_33_14","JOB","33","14","14","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵡⴰⵀ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵃⴻⵟⵟⵉ: ");
INSERT INTO rift_vpl VALUES ("JB33_15","019_33_15","JOB","33","15","15","ⴷⵉ ⵜⵉⵔⵊⴰ, ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵅⵎⵉ ⴷⴷ-ⵉⵡⴻⵟⵟⴰ ⵢⵉⴹⴻⵚ ⵢⵓⴵⵖⴻⵏ ⵅ ⵉⵡⴷⴰⵏ, ⴷⴻⴳ ⵓⵏⵓⴷⴻⵎ ⴷⵉ ⵍⴻⵛⵜⵓ. ");
INSERT INTO rift_vpl VALUES ("JB33_16","019_33_16","JOB","33","16","16","ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⴻⵎ ⵏⴻⵜⵜⴰ ⴰⵎⴻⵣⵣⵓⵖ ⵏ ⵉⵡⴷⴰⵏ, ⵉⵜⵜⵛⴻⵎⵎⴻⵄ ⵙ ⵓⵛⴻⵎⵎⵉⵄ ⵏⵏⴻⵙ ⵅ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB33_17","019_33_17","JOB","33","17","17","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⴱⵏⴰⴷⴻⵎ ⵅ ⵜⵎⴻⴳⴳⵉⵜ ⵏⵏⴻⵙ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵏⵏⴼⴰⵅⴻⵜ ⵅ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("JB33_18","019_33_18","JOB","33","18","18","ⵏⴻⵜⵜⴰ ⵉⵎⴻⵏⵏⴻⵄ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵣⵉ ⵜⵓⵔⵚⵓⴹⵉ, ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵀⴻⵍⵍⴻⴽ ⵙ ⵍⴰⵏⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JB33_19","019_33_19","JOB","33","19","19","ⵉⵊⴻⵢⵢⴻⵃ ⵉ-ⵜ ⵍⴻⵃⵔⵉⵇ ⴷⵉ ⵇⴰⵎⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⴰⵎⴻⵏⵖⵉ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB33_20","019_33_20","JOB","33","20","20","ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵔⵔⴰ ⵉ-ⵜ ⵉⵜⵜⵄⵉⴼⴼⴰ ⴰⵖⵔⵓⵎ ⵓ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⵉⵜⵜⵄⵉⴼⴼⴰ ⵎⴰⵛⵛⴰ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB33_21","019_33_21","JOB","33","21","21","ⵉⵇⴻⵟⵟⴰ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵉⵅⵙⴰⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵥⵔⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ, ⴰⵇⴰ ⵜⵜⴱⴰⵏⴻⵏ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("JB33_22","019_33_22","JOB","33","22","22","ⵉⵜⵜⵇⴰⵔⵔⴰⴱ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵓⵔⵚⵓⴹⵉ, ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵊⴰⵔⵔⴰⵢⴻⵏ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JB33_23","019_33_23","JOB","33","23","23","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵉⴱⴻⴷⴷ ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⵉⵊⵊ ⵏ ⵍⵄⴰⴷⴻⵍ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴰⵍⴻⴼ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⴱⵏⴰⴷⴻⵎ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB33_24","019_33_24","JOB","33","24","24","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⵉⵃⵉⵏⵏ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴼⴻⴽⴽ ⵉ-ⵜ, ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵀⴻⴽⴽⵡⵉ ⵖⴰⵔ ⵜⵓⵔⵚⵓⴹⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⵚⵍⴰⵃ ⵅⴰⵙ!’ ");
INSERT INTO rift_vpl VALUES ("JB33_25","019_33_25","JOB","33","25","25","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵏⴻⵄⵏⴻⵄ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴽⵜⴰⵔ ⵣⵉ ⵟⵟⵔⵉ ⵏ ⵜⴻⵎⵥⵉ, ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB33_26","019_33_26","JOB","33","26","26","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵓⵜⵔⴰ ⵢⵓⴵⵖⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⴹⴰ, ⴰⵍⴰⵎⵉ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵉⵥⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴰⵔⵔ ⵏⴻⵜⵜⴰ ⵉ ⴱⵏⴰⴷⴻⵎ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB33_27","019_33_27","JOB","33","27","27","ⴰⴷ ⵉⵖⴻⵏⵏⴻⵊ ⵉ ⵢⴻⵡⴷⴰⵏ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⵅⴹⵉⵖ, ⵙⵙⴼⴰⵔⵖⴻⵖ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜ ⵢⴻⵅⵍⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JB33_28","019_33_28","JOB","33","28","28","ⵉⴼⴻⴽⴽ ⴰⵔⴻⴱⴱⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵜⵓⵔⵚⵓⴹⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵜⵅⴻⵣⵣⴰⵔ ⴰⵎⵎⵓ ⴷ ⵡⴰⵎⵎⵓ ⴷⵉ ⵜⴼⴰⵡⵜ.’ ");
INSERT INTO rift_vpl VALUES ("JB33_29","019_33_29","JOB","33","29","29","ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ, ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ, ");
INSERT INTO rift_vpl VALUES ("JB33_30","019_33_30","JOB","33","30","30","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵄⵇⴻⴱ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵣⵉ ⵜⵓⵔⵚⵓⴹⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⵢⴰⵔⴻⵇⵇ ⵙ ⵜⴼⴰⵡⵜ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB33_31","019_33_31","JOB","33","31","31","ⵃⴹⴰ, ⴰⵢⵓⴱ! ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ! ⵙⵇⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB33_32","019_33_32","JOB","33","32","32","ⵎⴰⵍⴰ ⵖⴰⵔⴻⴽ ⴰⵡⴰⵍⴻⵏ ⵡⴻⵊⴷⴻⵏ, ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ, ⵙⵉⵡⴻⵍ, ⵎⴰⵖⴰⵔ ⵖⴰⵔⵉ ⵙ ⵍⵅⴰⴹⴰⵔ ⴰⴷ ⵅⴰⴽ ⴱⴰⵔⵔⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JB33_33","019_33_33","JOB","33","33","33","ⵎⴰⵍⴰ ⵍⵍⴰ, ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ! ⵙⵇⴰⵔ, ⵓ ⴰⴷ ⴰⵛ ⵙⵙⵖⴰⵔⴻⵖ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JB34_1","019_34_1","JOB","34","1","1","ⵉⵟⵟⴻⴼ ⵉⵍⵉⵀⵓ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB34_2","019_34_2","JOB","34","2","2","ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵡⵛⴻⵎ ⴰⵢⵉ ⴰⵎⴻⵣⵣⵓⵖ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜ ⵏ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JB34_3","019_34_3","JOB","34","3","3","ⵎⴰⵖⴰⵔ ⴰⵎⴻⵣⵣⵓⵖ ⵉⵏⴻⴱⴱⴻⵛ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵇⴰⵙⴰ ⵡⴰⵏⴻⵖ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JB34_4","019_34_4","JOB","34","4","4","ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⵉⵅⴹⴰⵔ ⵊⴰⵔ ⴰⵏⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_5","019_34_5","JOB","34","5","5","ⵎⴰⵖⴰⵔ ⴰⵢⵓⴱ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⴰⵔⴻⴱⴱⵉ ⵉⴽⴽⴻⵙ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JB34_6","019_34_6","JOB","34","6","6","ⵡⴰⵅⵅⴰ ⵖⴰⵔⵉ ⵍⵃⴻⵇⵇ, ⵄⴰⴷ ⵜⵜⵖⵉⵎⴻⵖ ⵜⵜⴱⴰⵏⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ! ⴰⵢⴻⵣⵣⵉⵎ ⵏ ⴼⵍⵉⵜⵛⴰ ⵉ ⴷⴰⵢⵉ ⵉⴵⴰ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵄⴻⴷⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JB34_7","019_34_7","JOB","34","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵔⵢⴰⵣ ⴰⵎ ⴰⵢⵓⴱ, ⵡⴻⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⴰⵙⵜⴻⵀⵣⵉ ⴰⵎ ⵡⴰⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB34_8","019_34_8","JOB","34","8","8","ⵏⴻⵜⵜⴰ ⵉⴳⴳⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⵎ ⵉⵜⵜⵄⴰⵛⴰⵔ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵉⴳⴳⵓⵔ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_9","019_34_9","JOB","34","9","9","ⵎⴰⵖⴰⵔ ⵉⵏⵏⴰ: ‘ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ ⵡⴰⵍⵓ ⵉ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴰⵔⴹⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JB34_10","019_34_10","JOB","34","10","10","ⵙ ⵓⵢⴰ ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴽⴻⵏⵏⵉⵡ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⴷⵉ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ: ‘ⵉⴳⴳⵯⴻⵊ ⵅ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵓⵍⴰ ⵅ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵎⵉⵏ ⵉⴼⴰⵔⵖⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JB34_11","019_34_11","JOB","34","11","11","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵅⵍⴻⴼ ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵢⴰⵔⵔ ⴰⴷ ⵜ ⵢⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("JB34_12","019_34_12","JOB","34","12","12","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵡⴰⵔ ⵉⵙⵙⴼⴰⵔⵔⵉⵖ ⵛⵛⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("JB34_13","019_34_13","JOB","34","13","13","ⵎⴰⵏ ⵡⴻⵏ ⵜ ⵉⵡⴻⴽⴽⵍⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴰⵔⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("JB34_14","019_34_14","JOB","34","14","14","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵡⵉ ⵄⴰⵡⴻⴷ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⴷ ⵏⵏⴻⴼⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB34_15","019_34_15","JOB","34","15","15","ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⵓⵃⴱⴻⵍ ⵓ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB34_16","019_34_16","JOB","34","16","16","ⵎⴰⵍⴰ ⴷⴰⵢⴻⴽ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵙⴻⵍ ⵅⴻⵏⵏⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB34_17","019_34_17","JOB","34","17","17","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵍⵃⴻⵇⵇ ⴰⴷ ⵉⵃⴽⴻⵎ, ⵏⵉⵖ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ ⴰⴷ ⵜⴻⴷⵄⵉⴷ ⵅ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB34_18","019_34_18","JOB","34","18","18","ⵎⴰ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜⵙⴻⴽⴽⵯⵉⴷ ⵡⴰⵍⵓ!’ ⵓ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ: ‘ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ’? ");
INSERT INTO rift_vpl VALUES ("JB34_19","019_34_19","JOB","34","19","19","ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵣⵡⵉⵍⵉⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⵡⴰⵔ ⵉⵜⵜⵔⵉⵃ ⴰⴽ-ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ ⵅ ⵓⵎⴻⵣⵍⵓⴹ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB34_20","019_34_20","JOB","34","20","20","ⵎⵎⵓⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ, ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ. ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏ ⵏⵉⵜⵏⵉ, ⵍⴳⴻⵏⵙ ⵏⵏⵉ, ⵓⵛⴰ ⵀⴻⵍⵍⴽⴻⵏ. ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⴱⵍⴰ ⵎⴰ ⵉⵃⴰⴷⴰ ⵉ-ⵜ ⵓⴼⵓⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB34_21","019_34_21","JOB","34","21","21","ⵎⴰⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵎⴽⵓⵍ ⵉⵊⵊ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵍⴰ ⵎⵍⵉⵃ ⵎⴰⵔⵔⴰ ⵉⵚⵓⵔⴰⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_22","019_34_22","JOB","34","22","22","ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ ⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵎⴰⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB34_23","019_34_23","JOB","34","23","23","ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵉⵅⵣⴰⵔ ⴷⵉ ⴱⵏⴰⴷⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ, ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⴷⴷⴻⵄⵡⴻⵜ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB34_24","019_34_24","JOB","34","24","24","ⵉⵍⴻⴱⴱⴻⵣ ⵊⵊⵡⴰⵃⴻⵍ ⴱⵍⴰ ⴰⵙⴻⵇⵙⵉ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_25","019_34_25","JOB","34","25","25","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ, ⵉⵙⵙⵏⴻⵇⵍⴰⴱ ⵉ-ⵜⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_26","019_34_26","JOB","34","26","26","ⵉⵛⵛⴰⵜ ⵉ-ⵜⴻⵏ ⵊⴰⵔ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴷⴻⴳ ⵉⵊⵊ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵜⴱⴻⴷⴷⴰⵏ ⵉⵡⴷⴰⵏ ⵜⵜⵡⴰⵍⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JB34_27","019_34_27","JOB","34","27","27","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅⴰⵙ, ⵡⴰⵔ ⵜⵜⵃⴻⴽⴽⵉⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB34_28","019_34_28","JOB","34","28","28","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⴹ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵉⵎⴻⵣⵍⴰⴹ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵜⴰⵊⴻⴱ ⵉ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵍⵎⵓⵙⴰⴽⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_29","019_34_29","JOB","34","29","29","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵍⵀⵓⴷⵏⴻⵜ, ⵎⴰⵏ ⵡⴻⵏ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵍⵄⵉⴱ? ⵎⴰⵍⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵡⵉ ⵜ ⵖⴰ ⵉⵥⴰⵔⴻⵏ? ⵉⵃⴻⴽⴽⴻⵎ ⵍⴰ ⵅ ⵍⴳⴻⵏⵙ ⴰⵎ ⵅ ⴱⵏⴰⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JB34_30","019_34_30","JOB","34","30","30","ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵃⴻⴽⴽⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ, ⵓ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏⵜ ⵄⴰⴷ ⵜⵅⴻⵛⵉⴼⵉⵏ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JB34_31","019_34_31","JOB","34","31","31","ⵎⵍⵉ ⵉⵏⵏⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⴰⵔⴻⴱⴱⵉ ‘ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⵄⵉⵡⵉⴷⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB34_32","019_34_32","JOB","34","32","32","ⵎⵉⵏ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵖ, ⵙⵖⴰⵔ ⴰⵢⵉ ⵜ ⵛⴻⴽ! ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵖ ⵄⴰⴷ.’ ");
INSERT INTO rift_vpl VALUES ("JB34_33","019_34_33","JOB","34","33","33","ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵅⵍⴻⴼ ⵏⴻⵜⵜⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ? ⴰⵇⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵜ! ⴰⵇⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵍⵍⴰ! ⵎⴰⵍⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵜ, ⵉⵏⵉ ⵜⵜ! ");
INSERT INTO rift_vpl VALUES ("JB34_34","019_34_34","JOB","34","34","34","ⵉⵔⵢⴰⵣⴻⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴰⴷ ⴰⵢⵉ ⵉⵏⵉⵏ, ⴰⵎ ⵇⴰⵄ ⴰⵔⵢⴰⵣ ⴰⵎⵉⵖⵉⵙ ⵉⵜⵜⴻⵙⵍⴰ-ⴷⴷ ⵖⴰⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("JB34_35","019_34_35","JOB","34","35","35","ⴰⵇⴰ ⴰⵢⵓⴱ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵜⵓⵙⵙⵏⴰ, ⴰⵇⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴱⵍⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉ ⵢⴻⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB34_36","019_34_36","JOB","34","36","36","ⵉⵡⴰ, ⴻⵊⵊ ⴰⵢⵓⴱ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴵⴻⴱ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ ⴰⵎ ⵉⵔⵢⴰⵣⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB34_37","019_34_37","JOB","34","37","37","ⵎⴰⵖⴰⵔ ⵉ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵢⴰⵔⴻⵏⵏⵉ ⵄⴰⴷ ⴰⵄⴻⴷⴷⵉ, ⵊⴰⵔ ⴰⵏⴻⵖ ⵉⵛⵛⴰⵜ ⵛⴰⵎⵅⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵓ ⵜⵜⵎⴰⵔⴻⵏⵢⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB35_1","019_35_1","JOB","35","1","1","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵍⵉⵀⵓ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB35_2","019_35_2","JOB","35","2","2","ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⴰⵢⴰ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ ⴽⵜⴰⵔ ⵅ ⵜⴻⵏⵏⵉ ⵏ ⴰⵔⴻⴱⴱⵉ’? ");
INSERT INTO rift_vpl VALUES ("JB35_3","019_35_3","JOB","35","3","3","ⵎⴰⵖⴰⵔ ⵜⴻⵏⵏⵉⴷ: ‘ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵖⴰⵔⴻⴽ? ⵎⵉⵏ ⴷ ⴰⵢⵉ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴷⴷⵏⵓⴱ?’ ");
INSERT INTO rift_vpl VALUES ("JB35_4","019_35_4","JOB","35","4","4","ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵓⵍⴰ ⵅ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JB35_5","019_35_5","JOB","35","5","5","ⵅⵣⴰⵔ ⴰⵊⴻⵏⵏⴰ, ⵓ ⵅⵣⴰⵔ, ⵃⴻⴽⴽⴰⵔ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵜⵉⵡⴰ ⵏⵏⴻⵛ ⵇⴰⵄ! ");
INSERT INTO rift_vpl VALUES ("JB35_6","019_35_6","JOB","35","6","6","ⵎⴰⵍⴰ ⵜⴻⵅⴹⵉⴷ, ⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵙ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰⵍⴰ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵛ ⴷ ⴰⵟⵟⴰⵙ, ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵜⴰⵡⵢⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JB35_7","019_35_7","JOB","35","7","7","ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⵜᵉⵜⵜⵉⵛⴻⴷ ⵙ ⵓⵢⴰ, ⵏⵉⵖ ⵎⵉⵏ ⵉⵜⵜⴻⵟⵟⴻⴼ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB35_8","019_35_8","JOB","35","8","8","ⴰⵇⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵛ ⵜⵍⴻⵇⵇⴻⴼ ⴰⵔⵢⴰⵣ ⴰⵎ ⵛⴻⴽ ⵡⴰⵀⴰ, ⵓ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵜᵉⵜⵜⵉⵍⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JB35_9","019_35_9","JOB","35","9","9","ⵙⵖⵓⵢⵢⵓⵏ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴰⵜ, ⵜⵜⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵜⵡⵉⵣⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵖⵉⵍ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("JB35_10","019_35_10","JOB","35","10","10","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵉⵇⵇⴰⵔ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⴷⵉ ⴵⵉⵍⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JB35_11","019_35_11","JOB","35","11","11","ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵙ ⵍⵎⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵙ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ?’ ");
INSERT INTO rift_vpl VALUES ("JB35_12","019_35_12","JOB","35","12","12","ⴷⵉⵏⵏⵉ ⵙⵖⵓⵢⵢⵓⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB35_13","019_35_13","JOB","35","13","13","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵖⴰⵔ ⵉⵖⵓⵢⵢⴰⵏ ⵉⴱⴻⵟⵟⵍⴻⵏ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵉⵍⴻⵀⵀⵉ. ");
INSERT INTO rift_vpl VALUES ("JB35_14","019_35_14","JOB","35","14","14","ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⵡⵉⵍⵉⴷ, ⵜᵉⵜⵜⵖⵉⵎⴰ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵄⴰⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⵔⴰⵊⴰ ⵜ ⵅⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JB35_15","019_35_15","JOB","35","15","15","ⵎⴰⵍⴰ ⵍⴻⵅⵅⵓ ⴰⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵛⵛⵉⵜ ⵄⴰⴷ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵅ ⵓⵄⴻⴷⴷⵉ ⵉⵎⵖⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JB35_16","019_35_16","JOB","35","16","16","ⴰⵢⵓⴱ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴱⴰⵟⴻⵍ, ⵉⵜⵜⴻⴳⴳ ⴰⵡⴰⵍⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵀⵍⴰ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JB36_1","019_36_1","JOB","36","1","1","ⵢⴰⵔⵏⵉ ⵉⵍⵉⵀⵓ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB36_2","019_36_2","JOB","36","2","2","ⵚⴱⴰⵔ ⵛⵡⴰⵢⵜ ⴰⴽⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ, ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⵍⴻⵙⴱⴰⴱ ⴽⵜⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB36_3","019_36_3","JOB","36","3","3","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵜⵓⵙⵙⵏⴰ ⵉⵏⵓ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⴰⴷ ⵏⴻⵄⵎⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_4","019_36_4","JOB","36","4","4","ⵎⴰⵖⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵇⴰ ⴷⴰ ⵣⵣⴰⵜⴻⴽ ⵡⴻⵏⵏⵉ ⴷ ⴱⵓ-ⵜⵓⵙⵙⵏⴰ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JB36_5","019_36_5","JOB","36","5","5","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵙⵙⴻⵃⵇⵉⵔⵉ ⵃⴻⴷ, ⵉⵎⵖⴰⵔ ⵊⵊⵀⴻⴷ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB36_6","019_36_6","JOB","36","6","6","ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵉ ⵉⵎⴻⵣⵍⴰⴹ ⵉⵜⵜⴰⵖ ⴰⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_7","019_36_7","JOB","36","7","7","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵃⴻⵢⵢⵉⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵅ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵎⴰⵛⴰ ⵉⵙⵙⵖⵉⵎⵉ ⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵍⵄⴰⵔⵛ ⴰⴽ-ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_8","019_36_8","JOB","36","8","8","ⵎⴰⵍⴰ ⵜⵜⵡⴰⵡⵜⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⴻⴳⵢⵓⴹ, ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵍⴻⵖⴱⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB36_9","019_36_9","JOB","36","9","9","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⴷ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵎⵖⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB36_10","019_36_10","JOB","36","10","10","ⵢⴰⵔⴻⵣⵣⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ ⵉ ⵓⵡⴻⴱⴱⴻⵅ, ⵉⵇⵇⴰⵔ ⴰⵙⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_11","019_36_11","JOB","36","11","11","ⵎⴰⵍⴰ ⵙⵍⵉⵏ ⵓ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵙ, ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵏ ⴷⴻⴳ ⵡⴻⴼⵍⴰⵃ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ ⵓ ⴷⵉ ⵣⵣⵀⴰⵔ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_12","019_36_12","JOB","36","12","12","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵙⵍⵉⵏ, ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵙ ⵍⴰⵏⵙⴰ, ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⵓⵃⴱⴻⵍ ⴰⵎ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⵉ ⴱⵓ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JB36_13","019_36_13","JOB","36","13","13","ⵏⵉⵜⵏⵉ ⵉⵏⵏⵉ ⵉⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵜⵜⵙⴻⵜⵜⴰⴼⴻⵏ ⴰⵖⴹⴰⴱ, ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⵏ ⴰⵄⴰⵡⴻⵏ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵛⴰⵔⴼ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_14","019_36_14","JOB","36","14","14","ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵄⴰⴷ ⴷⵉ ⵜⴻⵎⵥⵉ, ⵎⴰⵖⴰⵔ ⴷⴷⴰⵔⴻⵏ ⵊⴰⵔ ⵉⵎⴻⵜⵍⴻⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_15","019_36_15","JOB","36","15","15","ⴰⴷ ⵉⴼⴻⴽⴽ ⴰⵎⴻⵣⵍⵓⴹ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵏⵏⴻⵙ, ⴷⵉ ⴷⴷⴻⴵ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_16","019_36_16","JOB","36","16","16","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵄⴰⵔⵔⴻⵏ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵣⴻⴳ ⵡⵓⴹⵓⴼ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵖⴰⵔ ⵜⵜⴰⵙⵉⵄ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵓⵏⴻⴷⵇⴻⴼ, ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵛ ⵜⴻⵛⵛⵓⵔ ⵙ ⵎⴰⵛⵛⴰ ⵉ ⴷⴰⵢⴻⵙ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB36_17","019_36_17","JOB","36","17","17","ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⵏⵏⵓⵖⴻⴷ ⴷⵉ ⵛⵛⵔⴻⵄ ⴰⴽ-ⴷ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⴷⴷⴻⵄⵡⴻⵜ ⴷ ⵜⴻⵏⴼⵓⵍⵜ ⵜⵜⴰⵙⴻⵏⵜ-ⵉ-ⴷⴷ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JB36_18","019_36_18","JOB","36","18","18","ⵃⴹⴰ ⴰⵇⴰ ⴰⵙⵄⴰⵔ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵖⴰⵔⵔⵉ ⵉ ⵓⵙⵜⴻⵀⵣⵉ ⵓ ⵍⵇⴻⴷⴷ ⵏ ⴷⴷⴻⵢⵢⴻⵜ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JB36_19","019_36_19","JOB","36","19","19","ⵎⴰ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴻⵏ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵏⵉⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB36_20","019_36_20","JOB","36","20","20","ⵡⴰⵔ ⵜⵜⵎⴻⵥⵔⵉ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵅⵎⵉ ⵖⴰ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_21","019_36_21","JOB","36","21","21","ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴳⴳⵓⵔ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵎⴰⵏⵉ ⵉⵜⵜⵡⴰⴼⴼ ⵍⵖⴻⵛⵛ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵅⴷⴰⵔⴻⴷ ⴰⵢⴰ ⵅ ⵡⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB36_22","019_36_22","JOB","36","22","22","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵄⵓⴵⴰ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⵙⴻⵍⵎⴰⴷ ⴰⵎ ⵏⴻⵜⵜⴰ? ");
INSERT INTO rift_vpl VALUES ("JB36_23","019_36_23","JOB","36","23","23","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵙ ⵉⵙⵙⵛⴰⵏⴻⵏ ⴰⴱⵔⵉⴷ? ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰⵏ: ‘ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⵖⴻⵛⵛ’? ");
INSERT INTO rift_vpl VALUES ("JB36_24","019_36_24","JOB","36","24","24","ⵄⵇⴻⵍ ⴰⴷ ⵜⴻⵙⵙⵄⵓⴵⵉⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_25","019_36_25","JOB","36","25","25","ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵡⴰⵍⴰ ⵜⵜ, ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵜⵜⵡⴰⵍⴰⵏ ⵜⵜ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_26","019_36_26","JOB","36","26","26","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵏⴻⴼⵀⴻⵎ, ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴰⵔⵣⵓ. ");
INSERT INTO rift_vpl VALUES ("JB36_27","019_36_27","JOB","36","27","27","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵊⴻⴱⴱⴻⴷ ⵜⵓⴷⴷⵉⵎⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵜⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵣⵉ ⵜⴰⵢⵢⵓⵜ ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⴰⵏⵥⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("JB36_28","019_36_28","JOB","36","28","28","ⴰⵏⵥⴰⵔ ⵏⵏⵉ ⵣⵉ ⵜⵜⵏⴻⵙⵏⵉⵙⵉⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⴰⵏⵥⴰⵔ ⵏⵏⵉ ⴷⴷ ⵉⵡⴻⵟⵟⴰⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵅ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB36_29","019_36_29","JOB","36","29","29","ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⵃⴰⴽⴰⵏ ⵄⴻⵎⵎⴰⵔⵚ ⴷⴻⴳ ⵓⴱⴻⵣⵣⴻⵄ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵓⵍⴰ ⴷ ⵍⵃⴻⵙⵙ ⵉⵙⵙⴻⴳⴳⵡⴰⴷⴻⵏ ⵣⵉ ⵜⴻⵅⵣⴰⵏⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB36_30","019_36_30","JOB","36","30","30","ⵅⵣⴰⵔ, ⵉⵜⵜⴱⴻⵣⵣⴻⵄ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵜⵜⵍⴻⵃⵃⴰⴼ ⵣⵣⴰⵢⴻⵙ ⵟⵟⵍⵓⴼⴰ ⵢⵓⴵⵖⴻⵏ ⵇⴰⵄ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB36_31","019_36_31","JOB","36","31","31","ⵎⴰⵖⴰⵔ ⵙ ⵓⵢⴰ ⵉⵜⵜⵛⴰⵔⵔⴻⵄ ⵍⴻⴳⵏⵓⵙ. ⵉⵜⵜⵉⵛⵛ ⵎⴰⵛⵛⴰ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB36_32","019_36_32","JOB","36","32","32","ⵉⵜⵜⵛⵓⵔⵔⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵙ ⵜⴼⴰⵡⵜ, ⵉⵡⴻⵚⵚⴰ ⵜⵜ ⴰⴷ ⵜⴻⵍⵇⴻⴼ ⵜⴰⵏⴷⴰⵢⵜ. ");
INSERT INTO rift_vpl VALUES ("JB36_33","019_36_33","JOB","36","33","33","ⴰⴹⴰⵔⴹⴻⵃ ⵏ ⵡⴰⵙⵙⴰⵎⴻⵏ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵣⵣⴰⵢⴻⵙ, ⵓⵍⴰ ⴷ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵜᵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB37_1","019_37_1","JOB","37","1","1","ⵡⴰⵀ, ⵙ ⵓⵢⴰ ⵉⵜⵜⴰⵔⵊⵉⵊ ⵡⵓⵍ ⵉⵏⵓ, ⵉⵏⴻⵟⵟⵓ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB37_2","019_37_2","JOB","37","2","2","ⵙⵍⴻⵎ ⵎⵍⵉⵃ ⵉ ⵣⵣⵀⵉⵔ ⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵉ ⵡⴻⵊⴷⴰⴱ ⵏ ⵡⴰⵊⵊⴰⵊ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB37_3","019_37_3","JOB","37","3","3","ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵙⴰⴷⵓ ⵎⴰⵔⵔⴰ ⴰⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵙ ⴰⵍ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB37_4","019_37_4","JOB","37","4","4","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵣⴻⵀⵀⴰⵔ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵀⴻⵎⵀⴻⵎ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵎⴻⵏⵏⴻⵄ ⴰⵙⵙⴰⵎⴻⵏ, ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB37_5","019_37_5","JOB","37","5","5","ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴷⵉⵃ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵙ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵍⴻⵄⵊⴻⴱ, ⵉⵜⵜⴻⴳⴳ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴰⵙⴻⵏⵜ ⵏⴼⴻⵀⵀⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB37_6","019_37_6","JOB","37","6","6","ⵎⴰⵖⴰⵔ ⵉⵇⵇⴰⵔ ⵉ ⵡⴻⴷⴼⴻⵍ: ‘ⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴻⵏⵥⴰⵔ, ⴰⵏⵥⴰⵔ ⵉⵛⵛⴰⵜⴻⵏ ⵙ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_7","019_37_7","JOB","37","7","7","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴻⵎⵎⴻⵄ ⴰⴼⵓⵙ ⵏ ⵎⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ, ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB37_8","019_37_8","JOB","37","8","8","ⵍⴻⵡⵃⵓⵛ ⵜⵜⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵓ ⵜⵜⵖⵉⵎⴰⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_9","019_37_9","JOB","37","9","9","ⵜⴻⵜⵜⴰⵙ-ⴷⴷ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵣ ⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵙ ⵏ ⴷⴰⵅⴻⵍ ⵓ ⴰⴽ-ⴷ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵛⵛⴰⵎⴰⵍ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵓⵍⴰ ⴷ ⵜⴻⵙⵎⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("JB37_10","019_37_10","JOB","37","10","10","ⵙ ⵓⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵏⵏⴻⵙ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵊⵔⵉⵙ, ⵊⴻⵎⴷⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_11","019_37_11","JOB","37","11","11","ⵡⴰⵀ, ⵉⵜⵜⵄⴻⵎⵎⴰⵔ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵙ ⵜⵓⴼⴼⴻⵜ, ⵉⵜⵜⴱⴻⵣⵣⴻⵄ ⴰⵙⴻⵢⵏⵓ ⵏ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB37_12","019_37_12","JOB","37","12","12","ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵔⴰⵃ ⵉⵜⵜⴰⵙ-ⴷⴷ, ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵏⴻⴷⴷⴻⵀ ⵏⴻⵜⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB37_13","019_37_13","JOB","37","13","13","ⴰⴷ ⵜⴰⴼ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ, ⵏⵉⵖ ⴰⵎ ⵉ ⵍⴻⴼⴹⴻⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵉⵖ ⴰⵎ ⵡⴻⵙⵛⴰⵏ ⵏ ⵜⵎⴻⵅⵙⴰ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_14","019_37_14","JOB","37","14","14","ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⴰⵢⵓⴱ, ⴱⴻⴷⴷ, ⵙⵇⴰⵔ, ⵓ ⵃⴹⴰ ⵅ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB37_15","019_37_15","JOB","37","15","15","ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵉ ⵅⴰⵙⴻⵏ ⵉⴹⴻⴱⴱⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵔⵓⵖⴰ ⵜⴼⴰⵡⵜ ⵏ ⵓⵙⴻⵢⵏⵓ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB37_16","019_37_16","JOB","37","16","16","ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⵃⵔⴰⵔⴰⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵓⵙⵙⵏⴰ ⵜⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_17","019_37_17","JOB","37","17","17","ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵃⴻⵎⵎⴰ ⵡⴰⵔⵔⵓⴹ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⴰⵔⵔⵉⵃ ⵏ ⵍⵊⴰⵏⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("JB37_18","019_37_18","JOB","37","18","18","ⵎⴰ ⵜⴱⴻⵣⵣⵄⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵍⵇⵓⴱⴱⴻⵜ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵉⵙⵉⵜ ⵉⴼⴻⵙⵢⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB37_19","019_37_19","JOB","37","19","19","ⵙⴰⵔⴳⴻⴱ ⴰⵏⴻⵖ ⵛⴻⴽ ⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵏⵉⵏⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴼⴻⵙⵙⴰⵔ ⵡⴰⵍⵓ ⵎⵍⵉⵃ ⵣⵣⴰⵜⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JB37_20","019_37_20","JOB","37","20","20","ⵎⴰ ⴰⴷ ⴰⵙ ⵀⴰⵊⴰⵏ, ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵎⵎⵓ? ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⴷ ⵜⵜ ⵢⵉⵏⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵚⴰⵔⴹ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_21","019_37_21","JOB","37","21","21","ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⴱⵏⴰⴷⴻⵎ ⵜⴰⴼⴰⵡⵜ, ⵜⴻⵏⵏⵉ ⵢⴰⵔⴻⵇⵇⴻⵏ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵄⴷⵓ ⵓⵙⵓⴹⵉ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⵇⴰ ⵉⴼⴰⵔⵔⴻⴹ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_22","019_37_22","JOB","37","22","22","ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵡⵓⵔⴻⵖ, ⵜⵉⵙⵙⵉⵇⵜ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵜⴰⵔⵙⴰ ⵅ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JB37_23","019_37_23","JOB","37","23","23","ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴰⴼ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵊⵊⴻⵀⴷ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴷⴻⴵⵉ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⵉⴼⴻⵢⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB37_24","019_37_24","JOB","37","24","24","ⵙ ⵓⵢⴰ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵡⴷⴰⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵙⵙⴱⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB38_1","019_38_1","JOB","38","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵅ ⴰⵢⵓⴱ ⵣⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB38_2","019_38_2","JOB","38","2","2","ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴱⴰⵔⵔⵛⵏⴻⵏ ⴰⵛⴰⵡⴰⵔ, ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ? ");
INSERT INTO rift_vpl VALUES ("JB38_3","019_38_3","JOB","38","3","3","ⴱⵢⴻⵙ ⵅⴻⵏⵏⵉ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵛ ⴰⵎ ⵡⴻⵔⵢⴰⵣ. ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵇⵙⵉⵖ ⵓ ⵛⴻⴽ, ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ! ");
INSERT INTO rift_vpl VALUES ("JB38_4","019_38_4","JOB","38","4","4","ⵎⴰⵏⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⵓⵎⵉ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⴷⵙⴰⵙ ⵏ ⵜⴰⵎⵎⵓⵔⵜ? ⵉⵏⵉ ⵜ ⵎⴰⵍⴰ ⵖⴰⵔⴻⴽ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JB38_5","019_38_5","JOB","38","5","5","ⵎⴰⵏ ⵡⴻⵏ ⵉⴳⴳⵉⵏ ⵍⴻⵄⴱⴰⵔ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵜ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ? ⵎⴰⵏ ⵡⴻⵏ ⵅⴰⵙ ⵉⵎⴻⵃⴹⴻⵏ ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JB38_6","019_38_6","JOB","38","6","6","ⵎⵉⵏ ⵅⴻⴼ ⵀⵡⴰⵏ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴰⵔⵙⴻⵏ ⴰⵥⵔⵓ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB38_7","019_38_7","JOB","38","7","7","ⵓⵎⵉ ⵉⵜⵔⴰⵏ ⵏ ⵚⵚⴱⴻⵀ ⵖⴻⵏⵏⵊⴻⵏ ⵊⵎⵉⵄ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵓⵎⵉ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("JB38_8","019_38_8","JOB","38","8","8","ⵎⴰⵏ ⵡⴻⵏ ⵉⴱⴻⵍⵍⵄⴻⵏ ⵍⴻⴱⵃⴰⵔ ⵙ ⵜⴻⵡⵡⵓⵔⴰ, ⵓⵎⵉ ⴷⴷ-ⵉⴷⴷⵓⵇⵇⴻⵣ ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("JB38_9","019_38_9","JOB","38","9","9","ⵓⵎⵉ ⴷ ⴰⵙ ⴳⴳⵉⵖ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ ⴷ ⴰⵎⴻⵏⴷⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜ ⵙⵙⴻⵀⵏⵓⵏⵏⴹⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("JB38_10","019_38_10","JOB","38","10","10","ⵓⵎⵉ ⴷ ⴰⵙ ⴰⵔⵥⵉⵖ ⴰⴼⵔⴰⵢ ⵉⵏⵓ ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵃⴼⵓⵔ ⵢⵓⴵⵖⴻⵏ, ⵓ ⵓⵎⵉ ⴷ ⴰⵙ ⴳⴳⵉⵖ ⴰⵄⵎⵓⴷ ⵉ ⵓⴱⴻⵍⵍⴻⵄ ⴷ ⵜⴻⵡⵡⵓⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("JB38_11","019_38_11","JOB","38","11","11","ⵏⵏⵉⵖ: ‘ⴰⵍ ⴷⴰ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ, ⵡⴰⵔ ⵄⴻⴷⴷⵓ. ⴷⴰⵏⵉⵜⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("JB38_12","019_38_12","JOB","38","12","12","ⵎⴰ ⵜⵓⵎⵓⵔⴻⴷ ⵛⴻⴽ ⴰⵜⴻⴼⴼⵓ ⵏ ⵚⵚⴱⴻⵃ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ? ⵎⴰ ⵜⴻⵙⵙⵛⴰⵏⴻⴷ ⵉ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB38_13","019_38_13","JOB","38","13","13","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵍⴰⵎⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵣⵣⴻⵔⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB38_14","019_38_14","JOB","38","14","14","ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⴰⵔⵔⵉⵙⵜ ⵙⴰⴷⵓ ⵟⵟⴰⴱⴻⵄ, ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⴷ ⵅⴰⵙ ⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⵏⵜ ⵄⴰⵡⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JB38_15","019_38_15","JOB","38","15","15","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⴼⴰⵡⵜ ⵏⵙⴻⵏ ⵓ ⴰⵖⵉⵍ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ. ");
INSERT INTO rift_vpl VALUES ("JB38_16","019_38_16","JOB","38","16","16","ⵎⴰ ⵜⵉⵡⴹⴻⴷ ⵖⴰⵔ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB38_17","019_38_17","JOB","38","17","17","ⵎⴰ ⵜⵜⵡⴰⵄⴰⵔⵔⴰⵏⵜ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⵎⴻⵡⵜ ⵉ ⵛⴻⴽ, ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ? ");
INSERT INTO rift_vpl VALUES ("JB38_18","019_38_18","JOB","38","18","18","ⵎⴰ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵛ ⴰⵍ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ⵉⵏⵉ ⵜ ⵎⴰⵍⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JB38_19","019_38_19","JOB","38","19","19","ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵜⴼⴰⵡⵜ? ⵓ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JB38_20","019_38_20","JOB","38","20","20","ⵃⵉⵎⴰ ⴰⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵜ ⵜⵏⴻⴷⵀⴻⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵓ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ ⵉⵎⴻⵙⵔⴰⵇ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB38_21","019_38_21","JOB","38","21","21","ⵛⴻⴽ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⵏⵉⵖ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⵜⵅⴻⵍⵇⴻⴷ, ⵏⵉⵖ ⵍⵍⴰ? ⵓ ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ ⴷ ⴰⵟⵟⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("JB38_22","019_38_22","JOB","38","22","22","ⵎⴰ ⵜⵓⴷⴼⴻⴷ ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ ⵏ ⵡⴻⴷⴼⴻⵍ, ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵍⴻⵀⵔⵉⵜ ⵏ ⵜⴻⴱⵔⵓⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("JB38_23","019_38_23","JOB","38","23","23","ⵏⵏⵉ ⵅ ⵛⴻⵟⵟⴰⵔⴻⵖ ⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵉ ⵡⴰⵙⵙ ⵏ ⴳⴰⵔⵔⴰ ⴷ ⵓⵎⴻⵏⵖⵉ? ");
INSERT INTO rift_vpl VALUES ("JB38_24","019_38_24","JOB","38","24","24","ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⴱⵔⵉⴷ ⵉⵜⵜⴱⴻⵟⵟⴰⵏ ⵜⵉⴼⴰⵡⵜ, ⵓⵍⴰ ⴷ ⴰⴱⵔⵉⴷ ⵉ ⵣⵉ ⵉⵜⵜⵡⴰⴱⴻⵣⵣⴻⵄ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵛⵛⴰⵔⵇ ⵅ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JB38_25","019_38_25","JOB","38","25","25","ⵎⴰⵏ ⵡⴻⵏ ⵉⴼⴻⴵⴻⵇ ⵍⵎⵉⵣⴰⴱ ⵉ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴻⵏⵥⴰⵔ, ⵓⵍⴰ ⴷ ⴰⴱⵔⵉⴷ ⵉ ⵡⴰⵙⵙⴰⵎ ⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JB38_26","019_38_26","JOB","38","26","26","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⴰⵏⵥⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷⵉ ⵡⴰⵔ ⵉⵣⴷⵉⵖ ⵃⴻⴷ, ⵅ ⵍⴻⵅⵍⴰ ⵉ ⵡⴰⵔ ⴷⵉ ⵉⵣⴷⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ");
INSERT INTO rift_vpl VALUES ("JB38_27","019_38_27","JOB","38","27","27","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴰⵔⵡⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉⵅⵍⴰⵏ ⵓ ⵉⵜⵜⵡⴰⵅⵍⴰⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵖⵎⵉ ⴰⵔⴱⵉⵄ ⴷ ⵟⵟⵔⵉ? ");
INSERT INTO rift_vpl VALUES ("JB38_28","019_38_28","JOB","38","28","28","ⵎⴰ ⴰⵏⵥⴰⵔ ⵖⴰⵔⴻⵙ ⵛⴰ ⵏ ⴱⴰⴱⴰⵙ, ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⵊⵊⴰⵏ ⵜⵓⴷⴷⵉⵎⵉⵏ ⵏ ⵏⵏⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("JB38_29","019_38_29","JOB","38","29","29","ⵣⵉ ⵎⴰⵏ ⴰⵄⴻⴷⴷⵉⵙ ⵉ ⵣⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴻⵊⵔⵉⵙ, ⵓ ⵏⵏⴷⴰ ⵉⵊⴻⵔⵙⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵡⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵢⵓⵔⵡⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB38_30","019_38_30","JOB","38","30","30","ⴷⴷⴰⴽⴽⵡⴰⵍⴻⵏ ⵡⴰⵎⴰⵏ ⴰⵎ ⵡⴻⵥⵔⵓ ⵓⵛⴰ ⵉⵊⴰⵔⵙ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB38_31","019_38_31","JOB","38","31","31","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵛⴻⴷⴷⴻⴷ ⴰⴳⵔⴰⵡ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵜⵔⴰⵏ, ⵏⵉⵖ ⵜⴼⴻⵙⵙⵢⴻⴷ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵢⴻⵜⵔⴰⵏ ⵏ ⵓⵔⵉⵢⵓⵏ? ");
INSERT INTO rift_vpl VALUES ("JB38_32","019_38_32","JOB","38","32","32","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵉⵜⵔⴰⵏ ⵏ ⵣⵓⴷⵢⴰⴽ ⵖⴰⵔ ⵍⵃⴰⵍ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⴷⴷⵓⴱ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB38_33","019_38_33","JOB","38","33","33","ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵏⵉⵖ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴹⴻⴱⴱⴰⵔⴻⴷ ⵅ ⵓⵇⴰⵔⵔⵉ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JB38_34","019_38_34","JOB","38","34","34","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵖⴰⵔ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵜⴷⴻⵍ ⵉⵛⵜ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB38_35","019_38_35","JOB","38","35","35","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴰⵙⵙⴰⵎⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⴻⴵⵇⴻⵏ, ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: ‘ⴰⵇⴰ-ⵏⴻⵖ ⴷⴰ’? ");
INSERT INTO rift_vpl VALUES ("JB38_36","019_38_36","JOB","38","36","36","ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴰⵔⵙⴻⵏ ⵜⵉⵖⵉⵜ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ? ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉⵡⵛⵉⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉ ⵍⴻⵄⵇⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("JB38_37","019_38_37","JOB","38","37","37","ⵎⴰⵏ ⵡⴻⵏ ⵉⴼⴰⵔⵔⵣⴻⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵙ ⵍⴻⵄⵇⴻⵍ, ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵡⵉ ⵜⴻⵏ ⵉⵜⵜⵣⴻⴵⴰⵄⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB38_38","019_38_38","JOB","38","38","38","ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⴼⵙⵉⵢ ⵓⵛⴰⵍ, ⵉⴷⵡⴻⵍ ⴷ ⴰⴱⴻⴵⴰⵄ, ⵓⵛⴰ ⵍⴻⵙⵇⴻⵏ ⵉⴱⵓⵔⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JB38_39","019_38_39","JOB","38","39","39","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵣⵣⴰⵔⴷⴻⵜ ⵉ ⵜⴰⵢⵔⴰⴷⵜ, ⵏⵉⵖ ⴰⴷ ⵜⴻⵙⵙⴻⵍⵀⵓⴷ ⵍⴰⵥ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JB38_40","019_38_40","JOB","38","40","40","ⵍⴰⵎⵉ ⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵏⵙⴻⵏ, ⵓ ⵜⵜⵃⴰⵎⴰⵏ ⵣⵉ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB38_41","019_38_41","JOB","38","41","41","ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴻⵡⵊⴰⴷⴻⵏ ⵉ ⵓⴱⴰⵖⴻⵍ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ, ⵅⵎⵉ ⵙⵖⵓⵢⵢⵓⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵅⵎⵉ ⵜⵜⴻⵎⵀⴰⴼⴰⵏ ⵏⵀⵍⴰ ⵎⴰⵛⵛⴰ? ");
INSERT INTO rift_vpl VALUES ("JB39_1","019_39_1","JOB","39","1","1","ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴻⵍⵎⵉ ⵜⵜⴰⵔⵡⴻⵏⵜ ⵜⵖⴰⵢⴷⵉⵏ ⵏ ⵜⵚⵓⴹⴰⵔ? ⵎⴰ ⵜⵃⴻⵟⵟⵉⴷ ⵜⵉⵔⵡⴰ ⵏ ⵜⵓⴷⴰⴷⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("JB39_2","019_39_2","JOB","39","2","2","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵃⴻⵙⴱⴻⴷ ⵉⵢⵓⵔⴻⵏ ⵏ ⵜⴽⴻⵙⵙⵉⵜ ⵏⵙⴻⵏⵜ, ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵍⵃⴰⵍ ⵏ ⵜⵉⵔⵡⴰ ⵏⵙⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("JB39_3","019_39_3","JOB","39","3","3","ⵏⵉⵜⴻⵏⵜⵉ ⵜⵜⴻⵇⵡⵉⵙⴻⵏⵜ, ⵜⵜⴰⵔⵡⴻⵏⵜ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏⵜ, ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⵏⵙⴻⵏⵜ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB39_4","019_39_4","JOB","39","4","4","ⵎⴻⵃⴹⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏⵜ, ⵎⴻⵇⵇⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵜⵜⴻⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏⵜ ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB39_5","019_39_5","JOB","39","5","5","ⵎⴰⵏ ⵡⴻⵏ ⵢⴰⵔⵅⵓⵏ ⵉ ⵡⴻⵖⵢⵓⵍ ⵏ ⵍⴻⵅⵍⴰ ⵓ ⵜⵉⵙⴰⵔⵔⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵢⵓⵍ ⵏ ⵍⴻⵅⵍⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵜⴻⵏⵜ ⵉⴼⴻⵙⵢⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB39_6","019_39_6","JOB","39","6","6","ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵙ ⵜⴰⵏⴻⵣⵔⵓⴼⵜ ⴷ ⵜⴰⴷⴷⴰⵔⵜ, ⵍⴻⵡⴹⴰ ⴰⵎⴻⴵⴰⵃ ⴷ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB39_7","019_39_7","JOB","39","7","7","ⵏⴻⵜⵜⴰ ⵉⴹⴻⵃⵃⴻⵛ ⵅ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⴻⵢⵢⴰⵔⴻⵏ ⵉⵙⴻⵎⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB39_8","019_39_8","JOB","39","8","8","ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵉⴷⵓⵔⴰⵔ ⴷ ⴷⴷⵎⴰⵏⵉ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵢⴰⵔⴻⵣⵣⵓ ⴷⴰⵢⵙⴻⵏ ⵅ ⵇⴰⵄ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("JB39_9","019_39_9","JOB","39","9","9","ⵎⴰ ⴰⴷ ⵉⵅⵙ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⴰⴷ ⵅⴰⴽ ⵉⵙⴻⵅⵅⴰⵔ? ⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵙ ⵖⴰⵔ ⵍⵎⴻⴷⵡⴻⴷ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB39_10","019_39_10","JOB","39","10","10","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵎⴻⵏⵄⴻⴷ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵙ ⵡⴻⵙⵖⵓⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵄⴻⵢⵢⴻⴷ ⵏ ⵡⴻⵛⵔⴰⵣ? ⵎⴰ ⴰⴷ ⵉⵛⴰⵔⵣ ⵜⵉⵢⵙⴰⵔⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵛ? ");
INSERT INTO rift_vpl VALUES ("JB39_11","019_39_11","JOB","39","11","11","ⵎⴰ ⵜᵉⵜⵜⵛⴰⵍⴻⴷ ⵅⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ, ⵎⴰ ⴰⴷ ⴰⵙ ⵜⴻⵊⵊⵉⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB39_12","019_39_12","JOB","39","12","12","ⵎⴰ ⴰⴷ ⵅⴰⵙ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵔⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⵏⴻⴷⵔⴰⵔ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB39_13","019_39_13","JOB","39","13","13","ⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵏⵏⵄⴰⵎⴻⵜ ⵛⵛⴰⵜⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ. ⵎⴰⵛⴰ ⵎⴰ ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⴰⴼⵔⵉⵡⴻⵏ ⴷ ⵡⴰⵔⵔⵉⵛ ⵉⴷⴰⵍⴼⴻⵏ ⵏ ⵓⴱⴻⵍⵍⴰⵔⵊ? ");
INSERT INTO rift_vpl VALUES ("JB39_14","019_39_14","JOB","39","14","14","ⵎⴰⵖⴰⵔ ⵜᵉⵜⵜⴻⵊⵊⴰ ⵜⵉⵎⴻⴵⴰⵍⵉⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵜᵉⵜⵜⴻⵊⵊⴰ ⵉ-ⵜⴻⵏⵜ ⵜⵜⴻⵃⵎⴰⵏⵜ ⴷⴻⴳ ⵉⵊⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JB39_15","019_39_15","JOB","39","15","15","ⵜᵉⵜⵜᵉⵜⵜⵓ ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵓⴹⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏⵜ ⵉⵍⴱⴻⵣ, ⴰⵇⴰ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏⵜ ⵄⴻⴼⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB39_16","019_39_16","JOB","39","16","16","ⵏⴻⵜⵜⴰⵜ ⵜⵇⴻⵙⵙⴻⵃ ⴷⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵡⴰⵔ ⴵⵉⵏ ⵏⵏⴻⵙ. ⴱⴰⵟⴻⵍ ⵉ ⵜᵉⵜⵜⴻⴳⴳ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴽⴻⵙⵙⵉ ⵙ ⵡⴻⵎⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("JB39_17","019_39_17","JOB","39","17","17","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵊⵊⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜᵉⵜⵜⵓ ⵜⵉⵖⵉⵜ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵡⵛⵉ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB39_18","019_39_18","JOB","39","18","18","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⴽⵙⵉ ⴷⴻⴳ ⵓⴹⴰⵔ ⵏⵏⴻⵙ, ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵜⴹⴻⵃⵃⴻⵛ ⵅ ⵓⵢⵉⵙ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB39_19","019_39_19","JOB","39","19","19","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵊⵊⴻⵀⴷ ⵉ ⵓⵢⵉⵙ? ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⴷ ⵉⵊⵉⵎⴰⵏ ⵏⵏⴻⵙ ⵙ ⵙⵙⴱⵉⴱ? ");
INSERT INTO rift_vpl VALUES ("JB39_20","019_39_20","JOB","39","20","20","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⵉⵏⴻⵟⵟⵓ ⴰⵎ ⵓⴱⵓⵔⵅⴻⵙ? ⵍⵄⴻⵣⵣ ⵏ ⵓⵙⵏⴻⵃⵏⴻⵃ ⵏⵏⴻⵙ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB39_21","019_39_21","JOB","39","21","21","ⵅⴻⴱⴱⵛⴻⵏ ⵉⵢⵙⴰⵏ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵜⵜⵔⴰⵊⴰⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⵉⴼⴰⵔⵃ ⵓⵢⵉⵙ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵉⵜⵜⴻⴼⴼⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵎⴻⵍⵇⴰ ⴰⴽ-ⴷ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("JB39_22","019_39_22","JOB","39","22","22","ⵉⴹⴻⵃⵃⴻⵛ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵏⴻⵅⵍⵉⵄ ⵣⵉ ⵡⴰⵍⵓ, ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵣⵉ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JB39_23","019_39_23","JOB","39","23","23","ⵉⵜⵜⵇⴰⵔⵇⵓⴱ ⵡⴻⵇⵔⴰⴱ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ, ⵍⴰⵏⵙⴰ ⴷ ⴼⵍⵉⵜⵛⴰ ⵜⵜⵉⵙⵙⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB39_24","019_39_24","JOB","39","24","24","ⵙ ⴷⴷⵔⵉⵣ ⵏ ⵜⵛⴻⴹⵢⵉⵏ ⴷ ⵣⵣⵄⴰⵎⴻⵜ ⵉⵚⴰⵔⵔⴻⴹ ⵜⴰⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵙⵓⴹⵉ ⵏ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JB39_25","019_39_25","JOB","39","25","25","ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵙⵙⵏⴻⵃⵏⵉⵃ: ‘ⵀⴻⵀⴻⵀ!’ ⵉⵜⵜⴰⵛⴰ ⴰⴽ-ⴷ ⵓⵎⴻⵏⵖⵉ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵣⵣⴳⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JB39_26","019_39_26","JOB","39","26","26","ⵎⴰ ⵉⵟⵟⴰⵡ ⵍⴱⴰⵣ ⵣⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ? ");
INSERT INTO rift_vpl VALUES ("JB39_27","019_39_27","JOB","39","27","27","ⵎⴰ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵓⴳⵉⴷⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ ⵙ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵛ, ⵉⵜⵜⴻⴳⴳ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵙ ⴷⵉ ⵍⵓⵄⵍⴰ? ");
INSERT INTO rift_vpl VALUES ("JB39_28","019_39_28","JOB","39","28","28","ⵉⵣⴻⴷⴷⴻⵖ ⵓ ⵉⵙⵙⵏⵓⵙⴰ ⵅ ⵊⵊⴰⵔⴼ, ⵅ ⵓⵛⴻⵏⵇⵓⴱ ⵏ ⵊⵊⴰⵔⴼ, ⴰⵇⴰ-ⵜ ⴷ ⵍⴱⵓⵔⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB39_29","019_39_29","JOB","39","29","29","ⵙⵙⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰ ⵣⵣⴰⵔⴷⴻⵜ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵉ-ⵜⵜ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("JB39_30","019_39_30","JOB","39","30","30","ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵙⴻⴽⴽⴼⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⴰⵇⴰ-ⵜ ⴷⵉⵏ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("JB40_1","019_40_1","JOB","40","1","1","ⵢⴰⵔⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵅ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB40_2","019_40_2","JOB","40","2","2","ⵎⴰ ⵉⵅⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵎⵛⴰⵔⵔⴰⵄⴻⵏ ⴰⴽ-ⴷ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵜ ⵉⵙⴻⴳⴳⴻⵎ? ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⴷⵄⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ! ");
INSERT INTO rift_vpl VALUES ("JB40_3","019_40_3","JOB","40","3","3","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵢⵓⴱ ⵅ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB40_4","019_40_4","JOB","40","4","4","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴷⵔⵓⵙ, ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴰⵔⵔⴻⵖ? ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JB40_5","019_40_5","JOB","40","5","5","ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉⵖ ⵄⴰⴷ. ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⴰⵔⴻⵏⵏⵉⵖ! ");
INSERT INTO rift_vpl VALUES ("JB40_6","019_40_6","JOB","40","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵅ ⴰⵢⵓⴱ ⵣⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB40_7","019_40_7","JOB","40","7","7","ⴱⵢⴻⵙ ⵅⴻⵏⵏⵉ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵛ ⴰⵎ ⵡⴻⵔⵢⴰⵣ. ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵇⵙⵉⵖ ⵓ ⵛⴻⴽ, ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ! ");
INSERT INTO rift_vpl VALUES ("JB40_8","019_40_8","JOB","40","8","8","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴰⵔⵥⴻⴷ ⵍⵃⵓⴽⵎ ⵉⵏⵓ? ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⵍⵄⵉⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴱⴰⵏⴻⴷ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JB40_9","019_40_9","JOB","40","9","9","ⵎⴰ ⵖⴰⵔⴻⴽ ⴰⵖⵉⵍ ⴰⵎ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴷⵃⴻⴷ ⴰⵎ ⵡⴰⵊⵊⴰⵊ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB40_10","019_40_10","JOB","40","10","10","ⵇⵇⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵍⵄⴰⴹⴰⵎⴰ ⴷ ⵓⵄⵓⴵⵉ, ⴰⵔⴹ ⵙ ⵜⵉⵙⵙⵉⵇⵜ ⴷ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("JB40_11","019_40_11","JOB","40","11","11","ⴻⵊⵊ ⴰⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵉⵣⴻⴵⴻⵄ, ⵅⵣⴰⵔ ⵖⴰⵔ ⴽⵓⵍ ⴱⵓ ⵏⵏⴼⴰⵅⴻⵜ, ⵓⵛⴰ ⵙⴻⵀⵡⴰ ⵉ-ⵜ! ");
INSERT INTO rift_vpl VALUES ("JB40_12","019_40_12","JOB","40","12","12","ⵅⵣⴰⵔ ⵎⵍⵉⵃ ⵖⴰⵔ ⵎⴽⵓⵍ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ, ⵙⴻⵀⵡⴰ ⵉ-ⵜ, ⵍⴱⴻⵣ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB40_13","019_40_13","JOB","40","13","13","ⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⵓⵏⴻⵏ ⴷⴻⴳ ⵓⵛⴰⵍ, ⵛⴼⴻⵏ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵙⴰⴷⵓ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB40_14","019_40_14","JOB","40","14","14","ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ, ⵎⵉⵏⵣⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JB40_15","019_40_15","JOB","40","15","15","ⵅⵣⴰⵔ ⵎⴰⵛⴰ ⵍⵡⴻⵃⵛ, ‘ⴱᵉⵀⵉⵎⵓⵜ’, ⵡⴻⵏⵏⵉ ⴳⴳⵉⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⴳⴳⵉⵖ. ⵉⵜⵜⴻⵜⵜ ⴰⵔⴱⵉⵄ ⴰⵎ ⵓⴼⵓⵏⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JB40_16","019_40_16","JOB","40","16","16","ⵅⵣⴰⵔ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ, ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵏ ⵓⵄⴻⴷⴷⵉⵙ! ");
INSERT INTO rift_vpl VALUES ("JB40_17","019_40_17","JOB","40","17","17","ⵎⴰⵍⴰ ⵉⵅⵙ, ⴰⴷ ⵉⴳⴳ ⴰⴽⴻⵏⵏⴰⵙ ⵏⵏⴻⵙ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ ⵏⵏⴻⵙ ⵎⴻⵃⴹⴻⵏ ⵎⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB40_18","019_40_18","JOB","40","18","18","ⵉⵅⵙⴰⵏ ⵏⵏⴻⵙ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵎ ⵢⵉⵇⵓⴷⴰⵙ ⵏ ⵏⵏⵃⴰⵙ, ⴰⵎ ⴱⴰⵔⵔⴰⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵉⴹⴰⵔⴻⵏ ⴷ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB40_19","019_40_19","JOB","40","19","19","ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵡⴻⵏⵏⵉ ⵜ ⵢⴻⴳⴳⵉⵏ, ⵉⵡⵛⴰ ⴰⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB40_20","019_40_20","JOB","40","20","20","ⵉⵡⴰ, ⵉⴷⵓⵔⴰⵔ ⵜⵜⴰⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵔⴱⵉⵄ, ⵎⴰⵔⵔⴰ ⵍⴻⵡⵃⵓⵛ ⵏ ⵢⴻⵢⵢⴰⵔ ⵜⵜⵉⵔⴰⵔⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JB40_21","019_40_21","JOB","40","21","21","ⵉⴱⴱⵓⵣⵣⴻⵍ ⵙⴰⴷⵓ ⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵍⵉ, ⴷⴻⴳ ⵓⴷⵓⵔⵔⵉ ⵏ ⵓⵖⴰⵏⵉⵎ, ⴷⵉ ⵙⵙⴻⴱⵅⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JB40_22","019_40_22","JOB","40","22","22","ⴰⴷ ⵅⴰⵙ ⴷⴷⵓⵔⵢⴻⵏⵜ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵉⵍⵉ, ⴽⵓⵍ ⵉⵛⵜ ⵙ ⵜⵉⵍⵉ ⵏⵏⴻⵙ, ⵜⵉⵏⴻⵎⵔⴰⵍⵜ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵜⵜⴻⵏⵏⴹⴻⵏⵜ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JB40_23","019_40_23","JOB","40","23","23","ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⵉⵀⴰⵊ ⵢⴻⵖⵣⴰⵔ, ⵡⴰⵔ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ, ⵉⵜⵜⵖⵉⵎⴰ ⵢⴰⵔⵙⴰ ⵎⴰⵍⴰ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵜⵓⴷⴻⴼ ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JB40_24","019_40_24","JOB","40","24","24","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜ ⵉⵟⵟⴻⴼ ⴰⵎ ⵉⵅⴻⵣⵣⴰⵔ ⵏⴻⵜⵜⴰ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵜⵉⵏⵣⴰⵔⵜ ⵙ ⵜⴻⵙⵖⵓⵏⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("JB40_25","019_40_25","JOB","40","25","25","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵊⴻⴱⴷⴻⴷ ‘ⵍⵉ$ⵉⵢⴰⵜⴰⵏ’ ⵙ ⵜⵙⴻⵏⵏⴰⵔⵜ ⵏ ⵡⴻⵢⵎⴰⵔ, ⵏⵉⵖ ⴰⴷ ⵜⴻⵙⵙⴻⵀⵡⵉⴷ ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵉⵍⵓ ⵏ ⵡⴻⵢⵎⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JB40_26","019_40_26","JOB","40","26","26","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵖⴰⵏⵉⵎ ⴷⵉ ⵜⴻⵏⵣⴰⵔⵜ ⵏⵏⴻⵙ, ⵏⵉⵖ ⴰⴷ ⵜⴻⵙⵙⵏⵓⵇⵇⴱⴻⴷ ⴰⵖⴻⵙⵎⵉⵔ ⵏⵏⴻⵙ ⵙ ⵓⵖⴰⵏⵍⵜⵓ? ");
INSERT INTO rift_vpl VALUES ("JB40_27","019_40_27","JOB","40","27","27","ⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⴰⵔ ⴰⵃⵉⵏⵏⵉ? ⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⴽ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵣⵉⴹⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JB40_28","019_40_28","JOB","40","28","28","ⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⴰⴽⵉⴷⴻⴽ ⵍⵄⴰⵀⴷ? ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⴷ ⴷ ⵉⵙⵎⴻⵖ ⵉ ⵍⴻⴱⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("JB40_29","019_40_29","JOB","40","29","29","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴽⵉⴷⴻⵙ ⵜᵉⵜⵜⵉⵔⴰⵔⴻⴷ ⴰⵎ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴹⵉⴹ, ⵏⵉⵖ ⴰⴷ ⵜ ⵜⴻⵇⵇⵏⴻⴷ ⵉ ⵜⴻⵃⵔⴰⵎⵉⵏ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("JB40_30","019_40_30","JOB","40","30","30","ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴰⵢⴻⵙ ⵙⴻⴱⴱⴻⴱⴻⵏ? ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⴱⴹⴰⵏ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JB40_31","019_40_31","JOB","40","31","31","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵊⵊⵓⴷ ⵜⵉⵍⵎⴻⵛⵜ ⵏⵏⴻⵙ ⵙ ⴼⵍⵉⵜⵛⴰⵜ, ⵏⵉⵖ ⵙ ⵍⴰⵏⵙⴰ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB40_32","019_40_32","JOB","40","32","32","ⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⵅⴻⵎⵎ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⵉⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JB41_1","019_41_1","JOB","41","1","1","ⵅⵣⴰⵔ, ⵇⴰⵄ ⴰⵔⴰⵊⵉ ⴰⴷ ⵉⴼⵛⴻⵍ, ⵎⵖⵉⵔ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵜⴻⵙⵙⴻⵄⴳⴰⵣ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JB41_2","019_41_2","JOB","41","2","2","ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎⵎⵓ ⴷ ⴰⵣⴻⵄⵄⴰⵎ ⴰⵍⴰⵎⵉ ⵜ ⵉ ⵖⴰ ⵉⵀⵡⴻⵍ, ⵎⴰⵏ ⵡⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JB41_3","019_41_3","JOB","41","3","3","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⵉⵏ ⵛⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⴻⵖ? ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉⵊⴻⵏⵡⴰⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JB41_4","019_41_4","JOB","41","4","4","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵙⵇⴰⵔⵉⵖ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵅ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵓ ⵅ ⵓⵛⵓⵡⵡⴰⵔ ⵏ ⵡⴰⴷⴷⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB41_5","019_41_5","JOB","41","5","5","ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵄⵄⵎⴻⵏ ⴰⴷ ⵉⵇⴻⵊⵊⴻⵄ ⵜⴰⵇⵛⵓⵔⵜ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵄⵄⵎⴻⵏ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵜⵢⵓⵢⴰ ⵏ ⵍⴻⵙⴷⵓⴷ ⵏ ⵜⴻⵖⵎⴰⵙ ⵏ ⵉⵖⴻⵙⵎⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JB41_6","019_41_6","JOB","41","6","6","ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵖⴰⵔ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ? ⵎⵉⵏ ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵖⵎⴰⵙ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⴷ ⴰⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JB41_7","019_41_7","JOB","41","7","7","ⵍⴻⵙⴷⵓⴷ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵅ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵙ ⵛⴻⵏⵏⵄⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ ⵙ ⵟⵟⴰⴱⴻⵄ ⵉⵇⵇⵏⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_8","019_41_8","JOB","41","8","8","ⵉⵊⵊⴻⵏ ⵉⵇⵇⵏⴻⵏ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⴷⴷ-ⵢⴰⴷⴻⴼ ⴰⵔⵔⵉⵃ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_9","019_41_9","JOB","41","9","9","ⵍⴻⵙⵙⵇⴻⵏ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ, ⵓⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵎⵎⵙⴻⴱⴹⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_10","019_41_10","JOB","41","10","10","ⵎⴰⵍⴰ ⵉⵄⴹⴻⵙ, ⵜᵉⵜⵜⵛⴻⵄⵛⵉⵄ ⵜⴼⴰⵡⵜ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏⵜ ⴰⵎ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵏ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB41_11","019_41_11","JOB","41","11","11","ⵣⴻⴳ ⵓⵊⴻⵇⵎⵉⵎ ⵏⵏⴻⵙ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ, ⵜⵉⴼⴻⵟⵟⵓⵜⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⴷⵓⵇⵇⵓⵣⴻⵏⵜ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB41_12","019_41_12","JOB","41","12","12","ⴷⴷⴻⵅⵅⴰⵏ ⵉⵜⵜⴼⴻⵡⵡⴰⵔ ⵣⴻⴳ ⵉⵅⵓⴱⴰⵛ ⵏ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵎ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵟⴻⵏⵊⵉⵔ ⵉⵜⵜⵏⴻⵏⵏⴰⵏ ⵙ ⵓⵖⴰⵏⵉⵎ ⵉⴷⴷⵓⵅⵅⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_13","019_41_13","JOB","41","13","13","ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵏⵏⴻⵙ ⵜᵉⵙⵙⴻⴽⴽⴰⵔⴰ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵍⴻⴼⵃⴻⵎ, ⵣⴻⴳ ⵓⵃⴻⵔⵇⵓⵎ ⵏⵏⴻⵙ ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵓⵃⴰⴷⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JB41_14","019_41_14","JOB","41","14","14","ⵊⵊⴻⵀⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵉⵊⵉⵎⴰⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵏⴻⵙ ⵉⵏⴻⵟⵟⵓ ⵓⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JB41_15","019_41_15","JOB","41","15","15","ⵟⵟⵔⵓⴼⴰ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⵎⵎⵍⴻⵙⵇⴻⵏ, ⴰⵎ ⵅⴰⵙⴻⵏ ⴼⴻⵙⵢⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_16","019_41_16","JOB","41","16","16","ⵓⵍ ⵏⵏⴻⵙ ⵉⵇⵙⴻⵃ ⴰⵎ ⵡⴻⵥⵔⵓ, ⵉⵇⵙⴻⵃ ⴰⵎ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵜⵙⵉⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JB41_17","019_41_17","JOB","41","17","17","ⵅⵎⵉ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵏ ⵉⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ, ⵣⴻⴳ ⵓⵇⴻⵣⵣⴻⴱ ⵅⴻⵟⵟⴰⵏ ⴷⵉ ⵜⴻⵏⴷⴰⵢⵜ. ");
INSERT INTO rift_vpl VALUES ("JB41_18","019_41_18","JOB","41","18","18","ⵎⴰⵍⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵃⵔⵉⵛ, ⵍⴰ ⵙ ⵍⴰⵏⵙⴰ ⵓⵍⴰ ⵙ ⴼⵍⵉⵜⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JB41_19","019_41_19","JOB","41","19","19","ⵓⵣⵣⴰⵍ ⵖⴰⵔⴻⵙ ⴰⵎ ⵓⵍⵓⵎ, ⵏⵏⵃⴰⵙ ⴰⵎ ⵓⴽⴻⵛⵛⵓⴹ ⵢⴰⵔⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_20","019_41_20","JOB","41","20","20","ⴼⵍⵉⵜⵛⴰ ⵏ ⵍⵇⴻⵡⵙ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵜⴻⵡⵡⴻⵊ, ⵉⵥⵔⴰ ⵏ ⵉⴵⵉⵢ ⴷⴷⴰⴽⴽⵡⴰⵍⴻⵏ ⵣⵣⴰⵜⴻⵙ ⴷ ⴰⵇⴻⵛⵇⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JB41_21","019_41_21","JOB","41","21","21","ⵉⴷⴻⴱⴱⵓⵣⴻⵏ ⵉⵃⴻⵙⵙⴻⴱ ⵉ-ⵜⴻⵏ ⴰⵎ ⵓⵇⴻⵛⵇⴰⵛ, ⵉⴹⴻⵃⵃⴻⵛ ⵅ ⵓⵣⴻⴱⵣⴻⴱ ⵏ ⵓⵃⵔⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("JB41_22","019_41_22","JOB","41","22","22","ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⴻⵇⴼⴰⵏ ⵉⵇⴻⴹⵄⴻⵏ, ⵉⵜⵜⵊⴰⵔⵔⴰ ⵍⴻⵎⵡⴰⵙ ⵉⵇⴻⴹⵄⴻⵏ ⵏⵏⵉ ⴰⵎ ⵜⴻⵍⵡⵉⵃⵜ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ ⵜⵉⵡⴰ ⵏ ⵓⴱⴻⴵⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JB41_23","019_41_23","JOB","41","23","23","ⵉⴳⴳⴰ ⵍⴰⴵⴰⵖ ⴰⴷ ⵉⵙⵙⵜⴻⵅⵜⴻⵅ ⴰⵎ ⵜⴻⵢⴷⴰⵔⵜ, ⵉⵜⵜⴻⴳⴳ ⵍⴻⴱⵃⴰⵔ ⴰⵎ ⵓⵎⴻⵇⵔⴰⵊ ⵉⵜⵜⵀⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JB41_24","019_41_24","JOB","41","24","24","ⵉⵜⵜⴻⵊⵊⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵊⵊⵓⵔⵔⴻⵜ ⵜⴰⵔⴻⵇⵇ ⴷ ⴰⵎⴻⵙⵔⴰⵇ, ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵜⵜⴱⴰⵏⴻⵏ ⴰⵎ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵎⴻⵛⵛⴰⵢⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("JB41_25","019_41_25","JOB","41","25","25","ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵢⴰⵔⵡⴻⵙ ⴷⴰⵢⴻⵙ, ⵉⵜⵜⵡⴰⴳⴳ ⵃⵉⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB41_26","019_41_26","JOB","41","26","26","ⵉⵏⴹⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵡⵉ ⵢⵓⵄⵍⴰⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵏⴻⴼⴼⵅⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JB42_1","019_42_1","JOB","42","1","1","ⴰⵢⵓⴱ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JB42_2","019_42_2","JOB","42","2","2","“ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵛⴻⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⵉ ⴽⵓⵍⵛⵉ ⵡⴰⵔ ⵉⵙⵙⴱⴻⵟⵟⵉⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵏⵡⴰⵢ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JB42_3","019_42_3","JOB","42","3","3","ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴱⴰⵔⵔⵛⵏⴻⵏ ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ ⵛⵛⵡⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ?’ ⵙ ⵓⵢⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵎⵉⵏ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵖ, ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⴷⵉ ⵜⵜⴱⴻⵀⵜⴻⵖ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵙⵙⵉⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JB42_4","019_42_4","JOB","42","4","4","“ⵙⴻⵍ ⵎⴰⵛⴰ ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ, ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵇⵙⵉⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵅⴰⵙ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JB42_5","019_42_5","JOB","42","5","5","ⵙ ⵓⵎⴻⵣⵣⵓⵖ ⵅⴰⴽ ⵉ ⵙⵍⵉⵖ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⵉⵟⵟ ⵉⵏⵓ ⵜⴻⵥⵔⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JB42_6","019_42_6","JOB","42","6","6","ⵅ ⵓⵢⴰ ⵜⵜⵄⵉⴼⴼⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵓⵛⴰ ⵏⴷⴻⵎⵎⴻⵖ, ⵇⵇⵉⵎⴻⵖ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⴷ ⵢⵉⵖⵖⴻⴹ.” ");
INSERT INTO rift_vpl VALUES ("JB42_7","019_42_7","JOB","42","7","7","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⵉⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴽ-ⴷ ⴰⵢⵓⴱ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵉⵍⵉⴼⴰⵣ ⵣⵉ ⵜⴰⵢⵎⴰⵏ: “ⵍⵖⴰⴹⴰⴱ ⵉⵏⵓ ⵢⴰⵔⵖⴰ ⵅⴰⴽ ⵓ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵛⴰ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⴼⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵢⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JB42_8","019_42_8","JOB","42","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴽⵙⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵢⵓⴱ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵎ ⵜⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⵊⵊⴻⵎ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵢⵓⴱ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵥⵥⴰⴵ. ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵉ ⵡⴻⵙⵜⴰⵊⴻⴱ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⴰⵎ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⵙⵙⵉⵡⵉⵍⴻⵎ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⴼⵉ ⵉⵙⵙⵉⵡⵉⵍ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵢⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("JB42_9","019_42_9","JOB","42","9","9","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵉⵍⵉⴼⴰⵣ ⵣⵉ ⵜⴰⵢⵎⴰⵏ, ⴱⵉⵍⴷⴰⴷ ⵣⵉ ⵛⵓⵃⴰ ⴷ ⵚⵓⴼⴰⵔ ⵣⵉ ⵏⴰⵄⵎⴰⵜ ⵓⵛⴰ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ⵙⵉⴷⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⴰⵢⵓⴱ ⵉ ⵓⵙⵜⴰⵊⴻⴱ ⵏ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JB42_10","019_42_10","JOB","42","10","10","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵥⴰⴵⴰ ⴰⵢⵓⴱ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴻⵇⵍⴻⴱ ⵙⵉⴷⵉ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⴰⵢⵓⴱ ⵉ ⴷⵉ ⵉⴵⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵙⵉⴷⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏ ⴰⵢⵓⴱ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JB42_11","019_42_11","JOB","42","11","11","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵙⵓⵢᵉⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵙⵙⵏⴻⵏ ⵣⵉⵛ. ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⴰⴽⵉⴷⴻⵙ ⴰⵖⵔⵓⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⴻⵛⵏⴻⵏ ⴰⵙ ⴰⵣⵉⴵⴻⵣ ⵏⵙⴻⵏ ⵓⵛⴰ ⵄⴻⵣⵣⴰⵏ ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵉⵖⴹⴻⵍ ⵙⵉⴷⵉ. ⵉⵡⵛⴰ ⴰⵙ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵊⵊ ⵏ ⵏⵏⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JB42_12","019_42_12","JOB","42","12","12","ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵏ ⴰⵢⵓⴱ ⴽⵜⴰⵔ ⵣⵉ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵡⵓⴵⵉ ⴷ ⵙⴻⵜⵜⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⴷ ⵡⴰⵍⴻⴼ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏ ⵜⴻⵖⵏⴰⵛⵜ ⴷ ⵡⴰⵍⴻⴼ ⵏ ⵜⴻⵖⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JB42_13","019_42_13","JOB","42","13","13","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JB42_14","019_42_14","JOB","42","14","14","ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉⴳⴳⴰ ⴰⵙ ⵢⴰⵎⵉⵎⴰ, ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵇⴰⵚⵉⵄⴰ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵇⴰⵔⵏ-ⵀⴰⴼⴼⵓⴽ. ");
INSERT INTO rift_vpl VALUES ("JB42_15","019_42_15","JOB","42","15","15","ⵡⴰⵔ ⵓⴼⵉⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵉⵃⵔⴰⵎⵉⵏ ⵛⵏⴰⵏⵜ ⴰⵎ ⵢⴻⵙⵙⵉⵙ ⵏ ⴰⵢⵓⴱ. ⴱⴰⴱⴰⵜⵙⴻⵏⵜ ⵉⵡⵛⴰ ⴰⵙⴻⵏⵜ ⵜⴰⵙⵖⴰⵔⵜ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JB42_16","019_42_16","JOB","42","16","16","ⴰⵢⵓⴱ ⵉⴷⴷⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⴰ ⵎⵢⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵏⴻⵜⵜⴰ ⵉⵥⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⴰⵍ ⵊⵊⵉⵍ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JB42_17","019_42_17","JOB","42","17","17","ⴰⵢⵓⴱ ⵉⵎⵎⵓⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵡⵙⴰⵔ ⴰⵟⵟⴰⵙ ⵓ ⵜⵓⵖⴰ ⵉⵊⵊⵉⵡⴻⵏ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS1_1","020_1_1","PSA","1","1","1","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵛⵛⵡⴰⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⵎⴻⴷⵏⴰⴱ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS1_2","020_1_2","PSA","1","2","2","ⵎⴰⵛⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵙ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS1_3","020_1_3","PSA","1","3","3","ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉ ⵉⵜⵜⵡⴰⵥⵥⵓⵏ ⵖⴰⵔ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ, ⴰⴼⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵉⵥⴻⵖ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ, ⴰⴷ ⵢⵉⵍⵉ.    ");
INSERT INTO rift_vpl VALUES ("PS1_4","020_1_4","PSA","1","4","4","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵎⵎⵓ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵎ ⵉⵛⴰⵔⴼⴰ ⵉⵜⵜⴰⵡⵉ-ⵢ-ⵉ-ⵜ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("PS1_5","020_1_5","PSA","1","5","5","ⵅ ⵓⵢⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵏ ⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵙⴰⴱ, ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS1_6","020_1_6","PSA","1","6","6","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⴰⴱⵔⵉⴷ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS2_1","020_2_1","PSA","2","1","1","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⵀⴰⵊⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⵜⵜⵅⴰⵔⵔⵉⵚⴻⵏ ⵛⵛⵓⵄⵓⴱ ⴷⵉ ⵍⴱⴰⵟⴻⵔ? ");
INSERT INTO rift_vpl VALUES ("PS2_2","020_2_2","PSA","2","2","2","ⴽⴽⴰⵔⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵎⵛⴰⵡⴰⵔⴻⵏ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵓ ⴹⵉⴷⴷ ⵉ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("PS2_3","020_2_3","PSA","2","3","3","‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵇⴻⵙⵙ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵅⴰⵏⴻⵖ ⵏⴻⵙⵙⴱⴻⵄⵄⴻⴷ ⵜⵉⵙⴻⵖⵡⵉⵏ ⵏⵙⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("PS2_4","020_2_4","PSA","2","4","4","ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉⴹⴻⵃⵃⴻⵛ, ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⵜⴻⵀⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("PS2_5","020_2_5","PSA","2","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵙ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS2_6","020_2_6","PSA","2","6","6","“ⵏⴻⵛⵛ ⴰⵇⴰ ⴷⴻⵀⵏⴻⵖ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵓ, ⵅ ⵚⵉⵀⵢⵓⵏ, ⴰⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS2_7","020_2_7","PSA","2","7","7","ⵏⴻⵛⵛ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵡⴰⵡⴰⵍ! ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵛⴻⴽ ⴷ ⵎⵎⵉ, ⴰⵙⵙ-ⴰ ⵊⵊⵉⵖ-ⴷⴷ ⵛⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("PS2_8","020_2_8","PSA","2","8","8","ⵜⵜⴰⵔ ⵣⵣⴰⵢⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵍⴻⴳⵏⵓⵙ ⴷ ⵍⵡⴰⵔⵜ, ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵍⵉⵏⵜ ⴷ ⴰⴳⵍⴰ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS2_9","020_2_9","PSA","2","9","9","ⴰⴷ ⵜⴻⵏ ⵜⵍⴻⴱⵣⴻⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵇⴹⵉⴱ ⵏ ⵡⵓⵣⵣⴰⵍ, ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵥⵉⴷ ⴷ ⵜⴰⵔⴻⵥⵥⵉⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⵜⵍⴰⵅⵜ.” ");
INSERT INTO rift_vpl VALUES ("PS2_10","020_2_10","PSA","2","10","10","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ, ⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵉⵍⵉⵎ ⴷ ⵉⴼⴻⵀⵀⴰⵎⴻⵏ, ⵜⴻⴱⴱⵜⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰ ⵍⵇⵓⴹⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("PS2_11","020_2_11","PSA","2","11","11","ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ ⵙ ⵜⴻⴳⴳⵯⵓⴷⵉ, ⴼⴰⵔⵃⴻⵎ ⵙ ⵜⴰⵔⵊⵉⵊⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS2_12","020_2_12","PSA","2","12","12","ⵙⵓⴷⵎⴻⵎ ⵎⵎⵉⵙ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⴻⵄⵄⴰⵔ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵡⴰⵅⵅⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵡⴰⵀⴰ. ⵙⵙⴻⵄⴷ ⵏⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS3_1","020_3_1","PSA","3","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ, ⵓⵎⵉ ⵢⴰⵔⵡⴻⵍ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵎⵎⵉⵙ ⴰⴱⵛⴰⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PS3_2","020_3_2","PSA","3","2","2","ⴰ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⵇⴰ ⴽⴻⵜⵜⴰⵔⴻⵏ, ⴰⵟⵟⴰⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴹⵉⴷⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS3_3","020_3_3","PSA","3","3","3","ⴰⵟⵟⴰⵙ ⴰⵇⴰ ⵇⵇⴰⵔⴻⵏ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ: “ⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ!” ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS3_4","020_3_4","PSA","3","4","4","ⴰⵃⴻⵇⵇⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⵉ ⵏⴻⵛⵛ, ⴰⵄⵓⴵⵉ ⵉⵏⵓ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS3_5","020_3_5","PSA","3","5","5","ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵍⴰⵖⵉⵖ ⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS3_6","020_3_6","PSA","3","6","6","ⵙⴻⵏⵏⴷⴻⵖ ⵓⵛⴰ ⵉⴽⴽⴰ ⵅⴰⴼⵉ ⵢⵉⴹⴻⵚ, ⴼⴰⵇⴻⵖ-ⴷⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵜⵜⵄⴰⵡⴻⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS3_7","020_3_7","PSA","3","7","7","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⵉⴷⴻⵖ ⵣⵉ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵙⵙⴱⴻⴷⴷⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS3_8","020_3_8","PSA","3","8","8","ⴽⴽⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵡⵜⵉⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵖⴰⵔ ⵓⵖⴻⵙⵎⵉⵔ, ⴰⵇⴰ ⵜⴻⴷⴷⵣⴻⴷ ⵜⵉⵖⵎⴰⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS3_9","020_3_9","PSA","3","9","9","ⴰⵙⴻⵏⵊⴻⵎ ⴰⵇⴰ-ⵜ ⵏ ⵙⵉⴷⵉ, ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜⵜ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS4_1","020_4_1","PSA","4","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS4_2","020_4_2","PSA","4","2","2","ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ ⵅⵎⵉ ⴷⴷ ⵜⵜⵍⴰⵖⵉⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵙⴻⴳⴷⴰ ⵉⵏⵓ! ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⵜⵜⴰⵙⵉⵄ. ⵃⵉⵏⵏ ⵅⴰⴼⵉ ⵓ ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS4_3","020_4_3","PSA","4","3","3","ⵜⴰⵔⵡⴰ ⵏ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵍ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ ⵉⵏⵓ ⴷ ⵍⵄⴰⵔ? ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵜⴻⵅⵙⴻⵎ ⵍⴱⴰⵟⴻⵍ, ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⵅ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ? ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS4_4","020_4_4","PSA","4","4","4","ⵙⵏⴻⵎ ⵅⴻⵏⵏⵉ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵃⵓⵣⵣ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴰⵎⵜⵉⵇⵇⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵙⴻⵍ ⵅⵎⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵍⴰⵖⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS4_5","020_4_5","PSA","4","5","5","ⴰⵔⵊⵉⵊⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴻⵟⵟⵉⵎ. ⵙⵉⵡⵍⴻⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏⵡⴻⵎ ⴷⵉ ⵍⴻⵛⵜⵓ ⵏⵡⴻⵎ ⵓⵛⴰ ⵙⵓⵙⵎⴻⵎ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS4_6","020_4_6","PSA","4","6","6","ⵇⴻⴷⴷⵎⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵜⵜⴻⵛⵍⴻⵎ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS4_7","020_4_7","PSA","4","7","7","ⴰⵟⵟⴰⵙ ⵇⵇⴰⵔⴻⵏ: “ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵙⵙⴻⵛⵏⴻⵏ ⵍⵅⴰⵔ?” ⴻⵊⵊ ⴰⴷ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⴰⵡⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS4_8","020_4_8","PSA","4","8","8","ⵛⴻⴽ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵖⴰⵔ ⵡⵓⵍ ⵉⵏⵓ, ⴽⵜⴰⵔ ⵅ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⵜⵓⵖⴰ ⴼⴻⵢⵢⴹⴻⵏ ⵉⵎⴻⵏⴷⵉ ⵏⵙⴻⵏ ⴷ ⴱⵉⵏⵓ ⵏⵙⴻⵏ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS4_9","020_4_9","PSA","4","9","9","ⴷⵉ ⵍⴻⵀⵏⴰ ⴰⴷ ⵣⵣⵍⴻⵖ ⵓ ⴰⴷ ⵟⵟⵚⴻⵖ, ⵎⵉⵏⵣⵉ ⵎⵖⵉⵔ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵣⴻⴷⵖⴻⴷ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS5_1","020_5_1","PSA","5","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵜⴻⵎⵊⴰ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS5_2","020_5_2","PSA","5","2","2","ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍ ⵉ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ, ⴼⴻⵀⵎⴻⵜ ⵉ ⵓⵏⵉⵅⵙⴻⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS5_3","020_5_3","PSA","5","3","3","ⵃⴻⴽⴽⴰⵔ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵓⵜⵔⴰ ⵉⵏⵓ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵓ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵇⴰ ⵉ ⵛⴻⴽ ⵓⵎⵉ ⵜⵜⵥⴰⴵⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS5_4","020_5_4","PSA","5","4","4","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⴰ ⵙⵉⴷⵉ, ⵜⴻⵙⵍⵉⴷ ⵛⴻⴽ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏⵏⵇⴻⵍⴱⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵔⴰⵊⵉⵖ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS5_5","020_5_5","PSA","5","5","5","ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⴱⵏⴰⴷⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵉⴼ ⴰⵖⵉⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("PS5_6","020_5_6","PSA","5","6","6","ⵉⴱⵓⵃⴰⵍⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⵜⵜⴱⴻⴷⴷⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵛⴻⴽ ⵜⵛⴰⵔⵔⵀⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS5_7","020_5_7","PSA","5","7","7","ⴰⴷ ⵜⵀⴻⵍⵍⴽⴻⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵙⵉⴷⵉ ⵉⵜⵜⵄⵉⴼⴼⴰ ⴰⵔⵢⴰⵣ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS5_8","020_5_8","PSA","5","8","8","ⵎⴰⵛⴰ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵙⴻⵊⴷⴻⵖ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS5_9","020_5_9","PSA","5","9","9","ⴰ ⵙⵉⴷⵉ, ⵙⵓⵢⵓⵔ ⴰⵢⵉ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵙⴻⴳⴳⴻⵎ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS5_10","020_5_10","PSA","5","10","10","ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵍⴰⵎⴰⵏ, ⵊⵊⵓⴼ ⵏⵙⴻⵏ ⴷ ⴰⵅⴻⵢⵢⴻⴱ, ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⴷ ⴰⵏⴹⴻⵍ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⴰⵔⴻⴱⴱⵓⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵙ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS5_11","020_5_11","PSA","5","11","11","ⵅⵍⴻⴼ ⵣⵣⴰⵢⵙⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵍⴻⵛⵡⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⵥⵥⴻⵍ ⵅⴰⵙⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("PS5_12","020_5_12","PSA","5","12","12","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ⵛⴻⴽ ⵜⴼⴰⵔⵢⴻⴷ ⵅⴰⵙⴻⵏ! ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵏⴻⴳⵣⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴰⵢⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS5_13","020_5_13","PSA","5","13","13","ⵎⵉⵏⵣⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴱⴰⵔⴽⴻⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⴰⴷ ⴰⵙ ⵜⵇⵓⵡⵡⴰⵔⴻⴷ ⵙ ⵓⵃⵉⵏⵏⵉ ⴰⵎ ⵙ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS6_1","020_6_1","PSA","6","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵓⴼⵉⵍⵓ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS6_2","020_6_2","PSA","6","2","2","ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵡⴻⴷⴷⴰⴱ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴰⵔⴻⴱⴱⵉ ⵛⴰ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("PS6_3","020_6_3","PSA","6","3","3","ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵔⵅⵓⵖ. ⵙⴳⴻⵏⴼⴰ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("PS6_4","020_6_4","PSA","6","4","4","ⵡⴰⵀ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵢⴰⵔⵊⴻⴼ ⴰⵟⵟⴰⵙ, ⵓ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵍ ⵎⴻⵍⵎⵉ? ");
INSERT INTO rift_vpl VALUES ("PS6_5","020_6_5","PSA","6","5","5","ⴷⵡⴻⵍ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ, ⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS6_6","020_6_6","PSA","6","6","6","ⵎⵉⵏⵣⵉ ⴷⵉ ⵍⵎⴻⵡⵜ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⴱⵓ ⵍⵉⴷⴰⵔⴻⵜ ⵏⵏⴻⵛ. ⵡⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵇⴰⴷⴰⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("PS6_7","020_6_7","PSA","6","7","7","ⵏⴻⵛⵛ ⵓⵃⵍⴻⵖ ⵙ ⵉⵏⵉⵅⵙⵉⵙⴻⵏ ⵉⵏⵓ. ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ ⵙⵙⵓⴼⴼⴻⵖ ⵇⴰⵎⴰ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⵜⴰⵙⵙⵓⵜ ⵉⵏⵓ ⵜᵉⵟⵟⴻⴱⵟⴻⴱ ⵇⴰⵄ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS6_8","020_6_8","PSA","6","8","8","ⵜⵉⵟⵟ ⵉⵏⵓ ⵜⴻⵖⵍⵉ ⵙ ⵡⴻⵛⴹⴰⵏ, ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵔⵓⵃ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS6_9","020_6_9","PSA","6","9","9","ⴰⴳⴳⵯⴻⵊⴻⵎ ⵅⴰⴼⵉ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS6_10","020_6_10","PSA","6","10","10","ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵉ ⵜⵓⵜⵔⴰ ⵉⵏⵓ, ⵙⵉⴷⵉ ⴰⴷ ⵉⵇⴱⴻⵍ ⵜⴰⵥⴰⴵⵉⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS6_11","020_6_11","PSA","6","11","11","ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵜⴻⵍⵇⴻⴼ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷ ⵓⵏⴻⵅⵍⵉⵄ, ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⴽ-ⴷ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS7_1","020_7_1","PSA","7","1","1","ⵉⵣⵍⵉ ⵏ ⴷⴰⵡⵓⴷ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⵉⵊⵊⵉⵡⵉⵏ, ⵉⵣⵍⵉ ⵏⵏⵉ ⵉⵖⴻⵏⵏⴻⵊ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴽⵓⵛ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS7_2","020_7_2","PSA","7","2","2","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵇⴰ ⵖⴰⵔⴻⴽ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ! ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⴰⵥⵥⵍⴻⵏ ⵓⵛⴰ ⴼⴻⴽⴽ ⴰⵢⵉ, ");
INSERT INTO rift_vpl VALUES ("PS7_3","020_7_3","PSA","7","3","3","ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵣⴻⵄⵄⴻⴼ ⴰⵎ ⵡⴻⵢⵔⴰⴷ, ⴰⴷ ⴰⵢⵉ ⵉⵎⴻⵣⵣⴻⵇ, ⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS7_4","020_7_4","PSA","7","4","4","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵍⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⵖⴻⵛⵛ ⵉⵍⵚⴻⵇ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS7_5","020_7_5","PSA","7","5","5","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵅⴻⵍⴼⴻⵖ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵀⵏⴰ ⵙ ⵍⵖⴰⵔ, - ⵎⴰⵛⴰ ⵙ ⵍⵄⴻⴽⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵅ ⵡⴰⵍⵓ, ⵊⵊⵉⵖ ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ - ");
INSERT INTO rift_vpl VALUES ("PS7_6","020_7_6","PSA","7","6","6","ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵍⴻⵄⴷⵓ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰⴷ ⴰⵢⵉ ⵉⵄⴷⵓ, ⴰⴷ ⵉⵄⴼⴻⵙ ⵅ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⴻⵣⴷⴻⵖ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ! ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS7_7","020_7_7","PSA","7","7","7","ⴽⴽⴰⵔ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵙⵓⵄⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵅ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⴼⴰⵇ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵜⵓⵎⵓⵔⴻⴷ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS7_8","020_7_8","PSA","7","8","8","ⴰⴳⵔⴰⵡ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴰⵛ ⴷⴷ-ⵉⵏⵏⴻⴹ, ⵅⴻⵏⵏⵉ ⴷⵡⴻⵍ ⵜⵉⵡⴰ ⵏⵙⴻⵏ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("PS7_9","020_7_9","PSA","7","9","9","ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴰⴽⴻⵎ ⵍⴻⴳⵏⵓⵙ. ⴰⵖ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ, ⴰ ⵙⵉⴷⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵉ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS7_10","020_7_10","PSA","7","10","10","ⵙⴱⴻⴷⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵙⴻⵎⵜⴻⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵇⴻⴵⴱⴻⵏ ⵓⵍⴰⵡⴻⵏ ⴷ ⵜⵉⵥⵥⴰⵍ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⴻⴳⴳⴷⴻⵏ!    ");
INSERT INTO rift_vpl VALUES ("PS7_11","020_7_11","PSA","7","11","11","ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵉ ⵓⵙⴻⵍⵇⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏ ⵉⵎⵙⴻⴳⴳⵎⴻⵏ ⵏ ⵡⵓⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS7_12","020_7_12","PSA","7","12","12","ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⵇⴰⴹⵉ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⵙⴻⵅⵅⴹⴻⵏ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("PS7_13","020_7_13","PSA","7","13","13","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⵉⴱ, ⴰⴷ ⵉⵙⵙⴻⵇⴹⴻⵄ ⵏⴻⵜⵜⴰ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵎⵃⴻⴹ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵏⴻⵢⵢⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS7_14","020_7_14","PSA","7","14","14","ⵉⴳⴳⴰ ⵅⴰⵙ ⵍⴻⵙⵏⴰⵃ ⵉⵏⴻⵇⵇⴻⵏ, ⴰⴷ ⵢⴰⵔⵔ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS7_15","020_7_15","PSA","7","15","15","ⵅⵣⴰⵔ, ⴰⵇⴰ ⵡⴹⴰⵏ-ⴷⴷ ⵅⴰⵙ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵉⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ ⵏ ⵜⴰⵎⴰⵔⴰ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵓ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS7_16","020_7_16","PSA","7","16","16","ⵉⵇⵇⴰⵣ ⵉⵊⵊ ⵏ ⵡⴻⵃⴼⵓⵔ ⵓⵛⴰ ⵉⵙⵙⵓⴵⴻⵖ ⵉ-ⵜ, ⵎⴰⵛⴰ ⴷ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵉⵡⴹⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS7_17","020_7_17","PSA","7","17","17","ⵜⴰⵎⴰⵔⴰ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵍⴻⵅⵛⵓⵏⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⴰ ⵅ ⵓⵛⴻⵇⵇⵓⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS7_18","020_7_18","PSA","7","18","18","ⴰⴷ ⵇⴰⴷⵉⵖ ⵙⵉⴷⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS8_1","020_8_1","PSA","8","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ⵓⵊⵜⵜⵉ, ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵊⴰⵜ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS8_2","020_8_2","PSA","8","2","2","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵉⵊⵀⴻⴷ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵛ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS8_3","020_8_3","PSA","8","3","3","ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵉⵙⴻⵢⵎⴰⵏ, ⵜⴻⴳⴳⵉⴷ ⴷⵙⴰⵙ ⵉⵊⵀⴻⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⵍⵍⵄⴻⴷ ⴰⴱⵔⵉⴷ ⵅ ⵍⴻⵄⴷⵓ ⵓ ⵅ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵉⵅⵍⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("PS8_4","020_8_4","PSA","8","4","4","ⵎⴰⵍⴰ ⵜⵡⴰⵍⵉⵖ ⴰⵊⴻⵏⵏⴰ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴹⴻⵡⴹⴰⵏ ⵏⵏⴻⵛ, ⵜⴰⵣⵉⵔⵉ ⴷ ⵢⴻⵜⵔⴰⵏ, ⵉⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("PS8_5","020_8_5","PSA","8","5","5","ⵎⵉⵏ ⵉⵄⵏⴰ ⵅⴻⵏⵏⵉ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵅⴰⵔⵔⵚⴻⴷ ⴷⴰⵢⴻⵙ, ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵖⴰⵔⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PS8_6","020_8_6","PSA","8","6","6","ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵜ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵡⴰⵀⴰ ⵇⴻⵍⵍ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵜⵜⴰⵊ ⵏ ⵓⵄⵓⴵⵉ ⴷ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("PS8_7","020_8_7","PSA","8","7","7","ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵜ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵎⴰⵔⵔⴰ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("PS8_8","020_8_8","PSA","8","8","8","ⵓⴵⵉ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⴰ, ⵓⵍⴰ ⴷ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PS8_9","020_8_9","PSA","8","9","9","ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵛⵓⵇⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵍⴻⴱⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("PS8_10","020_8_10","PSA","8","10","10","ⴰ ⵙⵉⴷⵉ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵉⵊⵀⴻⴷ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("PS9_1","020_9_1","PSA","9","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵍⵎⴻⵡⵜ ⵏ ⵎⵎⵉⵙ’. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS9_2","020_9_2","PSA","9","2","2","ⴰⵍⵉⴼ. ⴰⴷ ⵇⴰⴷⵉⵖ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵉⵏⵓ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS9_3","020_9_3","PSA","9","3","3","ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴼⴰⵔⵃⴻⵖ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵙⵍⵉⵡⵍⵉⵡⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵛⴻⴽ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ! ");
INSERT INTO rift_vpl VALUES ("PS9_4","020_9_4","PSA","9","4","4","ⴱⵉⵜ. ⵓⵎⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵡⴹⴰⵏ ⵓ ⵖⴻⵍⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS9_5","020_9_5","PSA","9","5","5","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⵡⴻⵏⵏⵉⴷ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵓ ⵜⴱⴻⵍⵍⵄⴻⴷ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ, ⵜⴻⵇⵇⵉⵎⴻⴷ ⵅ ⵍⵄⴰⵔⵛ, ⴰ ⵛⴻⴽ, ⴷ ⵍⵇⴰⴹⵉ ⴰⵎⵙⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS9_6","020_9_6","PSA","9","6","6","ⴳⵉⵎⴻⵍ. ⵛⴻⴽ ⵜⵡⴻⴱⴱⵅⴻⴷ ⵍⴻⴳⵏⵓⵙ, ⵜⵀⴻⵍⵍⴽⴻⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵜⴻⵎⵃⵉⴷ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS9_7","020_9_7","PSA","9","7","7","ⵀⵉ. ⵍⴻⵄⴷⵓ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵇⴹⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵅⵉⵔⴱⴰⵜ ⵉ ⵍⴻⴱⴷⴰ. ⵜⵖⴻⴹⵍⴻⴷ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏ, ⵍⵉⴷⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵜⴻⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS9_8","020_9_8","PSA","9","8","8","ⵡⴰⵡ. ⵙⵉⴷⵉ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵇⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵉ ⵍⴻⵃⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS9_9","020_9_9","PSA","9","9","9","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⴷⴷⵓⵏⴻⵛⵜ ⵙ ⵜⵙⴻⴳⴷⴰ, ⴰⴷ ⵉⵃⴽⴻⵎ ⵛⵛⵓⵄⵓⴱ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS9_10","020_9_10","PSA","9","10","10","ⵙⵉⴷⵉ ⴷ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵃⵚⴰⵔⴻⵏ, ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS9_11","020_9_11","PSA","9","11","11","ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⵅⴰⴽ ⵜⵜⴻⵛⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵅⴰⴽ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⵙⴻⵎⵎⵃⴻⴷ, ⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS9_12","020_9_12","PSA","9","12","12","ⵣⴰⵢⵉⵏ. ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS9_13","020_9_13","PSA","9","13","13","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⴰⵢⵙⴻⵏ. ⵡⴰⵔ ⵉⵜⵜⵓ ⵛⴰ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS9_14","020_9_14","PSA","9","14","14","ⵅⵉⵜ. ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⵎⴻⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("PS9_15","020_9_15","PSA","9","15","15","ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵏ ⵏⵏⴻⵛ, ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ. ⵏⴻⵛⵛ ⴼⴰⵔⵔⵃⴻⵖ ⵅ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS9_16","020_9_16","PSA","9","16","16","ⵜⵉⵜ. ⵍⴻⴳⵏⵓⵙ ⵡⴹⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵛⴻⴷⴷⴻⵏ ⴷⵉ ⵜⵔⴰⵛⵛⴰ ⵏⵏⵉ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ,. ");
INSERT INTO rift_vpl VALUES ("PS9_17","020_9_17","PSA","9","17","17","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵙⵙⵏⴻⵏ, ⵏⴻⵜⵜⴰ ⵢⵓⵖⴰ ⵜⴰⵙⵖⴰⵔⵜ. ⴰⵄⴻⴼⴼⴰⵏ ⵉⵏⵏⵓⵖ ⴷⵉ ⵜⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ⴻⵊⵊ ⵉⴼⵉⵍⴰⵏ ⴰⴷ ⴷⴷⴻⵏⴷⵏⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS9_18","020_9_18","PSA","9","18","18","ⵢⵓⴷ. ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵜⵜⵓⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS9_19","020_9_19","PSA","9","19","19","ⵎⴰⵛⴰ ⴰⵎⴻⵣⵍⵓⴹ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵜⵜⵓ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵇⴻⵟⵟⴻⵄ ⵍⴰⵢⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS9_20","020_9_20","PSA","9","20","20","ⵇⵓⴼ. ⴽⴽⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴱⵏⴰⴷⴻⵎ ⵉⵊⵀⴻⴷ ⴽⵜⴰⵔ. ⴻⵊⵊ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵜⵜⵡⴰⵛⴰⵔⵔⵄⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS9_21","020_9_21","PSA","9","21","21","ⵙⵉⴳⴳⵯⴻⴷ ⵉ-ⵜⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵡⴷⴰⵏ! ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS10_1","020_10_1","PSA","10","1","1","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵓⵣⴻⵀⵀⴻⴷ 9 ⵍⴰⵎⵉⴷ. ⴰ ⵙⵉⴷⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⵉⴳⴳⵯⴻⵊⴻⴷ ⴰⵎⵎⵓ? ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("PS10_2","020_10_2","PSA","10","2","2","ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⵉⴹⴻⴼⴼⴰⵔ ⵓⵄⴻⴼⴼⴰⵏ ⵍⵎⴻⵙⴽⵉⵏ. ⴰⴷ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵙ ⵜⵎⴻⵄⵎⴰⵍⵜ ⵉ ⴷⵉ ⵜⵜⵅⴰⵔⵔⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS10_3","020_10_3","PSA","10","3","3","ⵎⴰⵖⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵙⵙⵄⵓⴵⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴻⵥⵔⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵉⵜⵜⴱⴰⵔⴻⴽ ⴰⴹⴻⵎⵎⴰⵄ, ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⴷⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS10_4","020_10_4","PSA","10","4","4","ⴰⵄⴻⴼⴼⴰⵏ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵜⵉⵏⵣⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵔ ⵉⵜⵜⴱⴻⵇⵇⴻⵛ, ⵉⵇⵇⴰⵔ. “ⵡⴰⵔ ⴷⵉⵏ ⴰⵔⴻⴱⴱⵉ”, ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PS10_5","020_10_5","PSA","10","5","5","ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴻⴼⴼⵖⴻⵏ ⴰⵙ ⵎⵍⵉⵃ ⴽⵓⵍ ⵜⵡⴰⵍⴰ. ⵍⴻⵀⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ ⵜⵜⵓⵄⵍⴰⵏⵜ ⵅⴰⵙ. ⵉⵜⵜⵣⴰⵡⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS10_6","020_10_6","PSA","10","6","6","ⵏⴻⵜⵜⴰ ⵉⵇⵇⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵡⴰⵔ ⵜⵜⴻⵏⵀⴻⵣⵣⵉⵖ, ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵍⴻⵇⵇⴻⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("PS10_7","020_10_7","PSA","10","7","7","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉⵛⵛⵓⵔ ⵙ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⴷⴷⴻⴵ. ⵙⴰⴷⵓ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⵎⴰⵔⴰ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS10_8","020_10_8","PSA","10","8","8","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵖⴰⵔ ⵡⴻⵛⴱⴰⵔ ⴷⵉ ⴷⵛⵓⵔⴰⵜ, ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵏⴻⵇⵇ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴳⴳⵉⵏ ⵙ ⵛⴰ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵎⵎⴻⵏⴹⴰⵔⴻⵏⵜ ⵅ ⵍⵎⴻⵙⴽⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS10_9","020_10_9","PSA","10","9","9","ⵉⵍⴱⴻⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⴷⴻⴳ ⵓⴷⵓⵔⵔⵉ ⵏ ⵓⵄⵉⵛⵛⵓ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵃⴻⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵛⴰⵔ ⵍⵎⴻⵙⴽⵉⵏ. ⵉⵜⵜⴰⵛⴰⵔ ⵍⵎⴻⵙⴽⵉⵏ ⵓⵎⵉ ⵜ ⵉⵊⴻⴱⴱⴻⴷ ⴷⵉ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS10_10","020_10_10","PSA","10","10","10","ⵏⴻⵜⵜⴰ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ, ⵉⵜⵜⴰⴹⴰⵔ, ⴰⵇⴰ ⵍⵎⴻⵙⴽⵉⵏ ⵉⵡⴻⵟⵟⴰ ⵊⴰⵔ ⵡⴰⵛⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS10_11","020_10_11","PSA","10","11","11","ⵉⵇⵇⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵓ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜ ⵉⵥⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("PS10_12","020_10_12","PSA","10","12","12","ⵇⵓⴼ. ⴽⴽⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓ ⵍⵎⵓⵙⴰⴽⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS10_13","020_10_13","PSA","10","13","13","ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⵓⵄⴻⴼⴼⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵉⵇⵇⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⵇⵇⴰⵛⴻⴷ!”? ");
INSERT INTO rift_vpl VALUES ("PS10_14","020_10_14","PSA","10","14","14","ⵔⵉⵅ. ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵜⴰⵎⴰⵔⴰ ⴷ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⵍⵎⴻⵙⴽⵉⵏ ⵉⵜⵜⴰⵔⵔ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵙ ⵓⵣⴻⴵⵉⴼ. ⵛⴻⴽ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵏ ⵓⵢⵓⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS10_15","020_10_15","PSA","10","15","15","ⵛⵉⵏ. ⴰⵔⵥ ⴰⵖⵉⵍ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵅⵍⴻⴼ ⵍⵖⴰⵔ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⴰⵍ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴼⴻⴷ ⵡⴰⵍⵓ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS10_16","020_10_16","PSA","10","16","16","ⵙⵉⴷⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵍⴻⴳⵏⵓⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS10_17","020_10_17","PSA","10","17","17","ⵜⴰⴼ. ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵉ ⵎⴻⵥⵔⵉ ⵏ ⵉⵎⵡⴰⴹⵄⴻⵏ, ⴰⴷ ⵜⴻⵙⵙⵊⴻⵀⴷⴻⴷ ⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵎⴻⵢⵢⵍⴻⴷ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS10_18","020_10_18","PSA","10","18","18","ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵖⴻⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵓⵢⵓⵊⵉⵍ ⵓ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("PS11_1","020_11_1","PSA","11","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ. ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ: “ⴹⵡⵓ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏⵡⴻⵎ, ⴰ ⵉⵊⴹⴰⴹ!” ");
INSERT INTO rift_vpl VALUES ("PS11_2","020_11_2","PSA","11","2","2","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵇⴰ ⵎⴻⵃⵃⴹⴻⵏ ⵍⵇⴻⵡⵙ, ⵙⵙⵔⵓⵙⴰⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⴼⵉⵍⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵡⵜⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⴷⴻⴳ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵙⴻⴳⴳⴻⴷ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("PS11_3","020_11_3","PSA","11","3","3","ⵡⴰⵀ, ⴷⵙⵓⵙⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ! ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴻⴳⴳ ⵓⵎⵙⴻⴳⴳⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("PS11_4","020_11_4","PSA","11","4","4","ⵙⵉⴷⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵍⵄⴰⵔⵛ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵍⴰⵏⵜ, ⵍⵅⴻⵣⵔⴰⵜ ⵏⵏⴻⵙ ⴰⵔⴻⵣⵣⵓⵏⵜ ⴷⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS11_5","020_11_5","PSA","11","5","5","ⵙⵉⴷⵉ ⵉⵜⵜⴱⴻⵇⵇⴻⵛ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⵄⵉⴼⴼⴰ ⴰⵄⴻⴼⴼⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("PS11_6","020_11_6","PSA","11","6","6","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵏⵥⴰⵔ ⵏ ⵍⴻⴼⵅⵓⵅ, ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵛⴱⴰⵔⵉⵢⵢⴻⵜ ⴷ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴽⴰⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS11_7","020_11_7","PSA","11","7","7","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵉⵜⵜⴻⵅⵙ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ. ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS12_1","020_12_1","PSA","12","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵅ ⵓⴼⵉⵍⵓ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS12_2","020_12_2","PSA","12","2","2","ⵙⴻⵏⵊⴻⵎ, ⴰ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴰⵎⵜⵉⵇⵇⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵊⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS12_3","020_12_3","PSA","12","3","3","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵣⵉⴹⴻⵏ, ⴰⵇⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵎⴱⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PS12_4","020_12_4","PSA","12","4","4","ⴻⵊⵊ ⵙⵉⴷⵉ ⴰⴷ ⵉⵇⴹⴻⵄ ⵎⴰⵔⵔⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵣⵉⴹⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵍⴻⵙ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴽⴻⴱⴱⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PS12_5","020_12_5","PSA","12","5","5","ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵢⵉⵍⵉ ⵓⵇⴰⵔⵔⵓ ⵉⵎⵖⴰⵔ, ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵏⵏⴻⵖ! ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⵅⴰⵏⴻⵖ ⴷ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("PS12_6","020_12_6","PSA","12","6","6","“ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏ ⵍⵎⵓⵙⴰⴽⵉⵏ, ⵓⵍⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵉⵎⴻⵣⵍⴰⴹ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛ”, ⵉⵏⵏⴰ ⵙⵉⴷⵉ, “ⵡⴻⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵉⴷⴷⵓⵇⴻⵣ ⵏⴻⵜⵜⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴰⵡⵢⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("PS12_7","020_12_7","PSA","12","7","7","ⵜⵉⵡⴰⵍⵉⵏ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵡⴰⵍⵉⵏ ⵚⴼⴰⵏⵜ, ⵜⵜⵡⴰⵙⵙⵉⵣⴷⴳⴻⵏⵜ ⴰⵎ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⵉ ⵓⴼⴻⵙⵢⵉ ⴷⴻⴳ ⵓⵛⴰⵍ, ⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.    ");
INSERT INTO rift_vpl VALUES ("PS12_8","020_12_8","PSA","12","8","8","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⴹⵉⴷ, ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴰⵔⴻⴷ ⵣⵉ ⵊⵊⵉⵍ-ⴰ, ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS12_9","020_12_9","PSA","12","9","9","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴳⴳⵓⵔⴻⵏ ⵜⵜⴻⵏⵏⴹⴻⵏ ⵎⴰⵏⵉ ⵎⴰ ⵅⵎⵉ ⵖⴰ ⵉⴽⴽⴰⵔ ⴷⴷⴻⴵ ⵊⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS13_1","020_13_1","PSA","13","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS13_2","020_13_2","PSA","13","2","2","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ, ⴰ ⵙⵉⴷⵉ, ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵜᵉⵜⵜⵓⴷ? ⴰⵍ ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS13_3","020_13_3","PSA","13","3","3","ⵎⴻⵛⵀⴰⵍ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⴳⴳⴻⵖ ⵄⴰⴷ ⵍⴻⵀⵎⵓⵎ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰⵛⴹⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵎⴽⵓⵍ ⴰⵙⵙ? ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵉⵙⵙⵄⵓⴵⴰ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅⴰⴼⵉ? ");
INSERT INTO rift_vpl VALUES ("PS13_4","020_13_4","PSA","13","4","4","ⵅⵣⴰⵔ-ⴷⴷ, ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ! ⴻⴳⴳ ⵜⴼⴰⵡⵜ ⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜᵉⵟⵟⵚⴻⵖ ⵉⴹⴻⵚ ⵏ ⵍⵎⴻⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("PS13_5","020_13_5","PSA","13","5","5","ⵃⵉⵎⴰ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⵡⴰⵔ ⵉⵇⵇⴰⵔ: “ⵏⴻⵛⵛ ⵖⴻⵍⵍⴱⴻⵖ ⵅⴰⵙ!”, ⵃⵉⵎⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵡⴰⵔ ⵉⴼⴰⵔⵔⴻⵃ ⵎⴰⵍⴰ ⴼⴰⵔⵖⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS13_6","020_13_6","PSA","13","6","6","ⵏⴻⵛⵛ ⵜⵜⴻⵛⵍⴻⵖ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ⵓⵍ ⵉⵏⵓ ⴰⴷ ⵉⴼⴰⵔⵃ ⵅ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴷⴰⵢⵉ ⵍⵅⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("PS14_1","020_14_1","PSA","14","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⴰⴱⵓⵀⴰⵍⵉ ⵉⵏⵏⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⴰⵔⴻⴱⴱⵉ!” ⵏⵉⵜⵏⵉ ⵜⵜⴰⵔⴻⴷⴷⴵⴻⵏ, ⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⴹⴻⵅⵙⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS14_2","020_14_2","PSA","14","2","2","ⵙⵉⴷⵉ ⵉⵅⴻⵣⵣⴰⵔ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ, ⵎⴰ ⴷⵉⵏ ⵃⴻⴷ ⴷⴰⵢⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS14_3","020_14_3","PSA","14","3","3","ⵎⴰⵔⵔⴰ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("PS14_4","020_14_4","PSA","14","4","4","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵜⵓⵙⵙⵏⴰ, ⵉⵏⵏⵉ ⵉⵜⵜᵉⵜⵜⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵅⵎⵉ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵖⵔⵓⵎ? ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS14_5","020_14_5","PSA","14","5","5","ⴰⵇⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⴷⵉⵏ ⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽ-ⴷ ⵊⵊⵉⵍ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS14_6","020_14_6","PSA","14","6","6","ⴽⴻⵏⵏⵉⵡ ⵜⵏⴻⴼⴹⴻⵎ ⴰⵔⵔⴰⵢ ⵏ ⵍⵎⵓⵙⴰⴽⵉⵏ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵜⴰⵔⴻⵡⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS14_7","020_14_7","PSA","14","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵚⵉⵀⵢⵓⵏ ⵉ ⵖⴰ ⵢⵉⵡⵢⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ! ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⵉⵎⴻⵃⴱⴰⵙ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵢⴰⵔⵛⴻⵇ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵉⴼⴰⵔⵃ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS15_1","020_15_1","PSA","15","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⵙⵉⴷⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵛ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵣⴻⴷⵖⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS15_2","020_15_2","PSA","15","2","2","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⴽⵎⴰⵍⴻⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵜⵉⴷⴻⵜⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS15_3","020_15_3","PSA","15","3","3","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ ⵉ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵡⴰⵔ ⵉⵜⵜⵣⴰⵡⴰⵔ ⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS15_4","020_15_4","PSA","15","4","4","ⵡⴻⵏⵏⵉ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⵉ-ⵜⴻⵏ. ⵎⴰⵍⴰ ⵉⵊⵊⵓⴵ ⵏⴻⵜⵜⴰ ⵉ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜ ⵉⵜⵜⴱⴻⴷⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS15_5","020_15_5","PSA","15","5","5","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵛⴻⵏ ⵜⴰⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵙ ⵙ ⴰⵔⵔⵉⴱⴰ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⴰⵔⵔⴻⵛⵡⴻⵜ ⴹⵉⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴳⴳⵉⵏ ⵙ ⵛⴰ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵉⴼⴰⵔⵔⴻⵖ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS16_1","020_16_1","PSA","16","1","1","ⵜⵉⵔⴰ ⵉⵏⴻⵇⵛⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⵃⴹⴰ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS16_2","020_16_2","PSA","16","2","2","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵜⴻⵏⵏⴰ ⵉ ⵙⵉⴷⵉ: “ⵛⴻⴽ ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵛⴻⴽ ⴷ ⵍⵅⴰⵔ ⵉⵏⵓ, ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵅⴰⴽ ⵢⵓⵄⵍⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS16_3","020_16_3","PSA","16","3","3","ⵅ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⵉⵜⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⴰⵔⴹⴰ ⵉⵏⵓ ⵉ ⴷⴰⵢⵙⴻⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS16_4","020_16_4","PSA","16","4","4","ⵜⴰⵎⴰⵔⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⵎⵎⵓ ⴷⴻⵖⵢⴰ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⵜⵡⴰⴽⵜⴰⵔⴻⵏⵜ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴼⴰⵔⵔⵉⵖⴻⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS16_5","020_16_5","PSA","16","5","5","ⵙⵉⴷⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⴽⴰⵙ ⵉⵏⵓ. ⵛⴻⴽ ⵜᵉⵟⵟⴼⴻⴷ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS16_6","020_16_6","PSA","16","6","6","ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⴻⵄⴱⴰⵔ ⴽⴽⴰⵔⴻⵏ ⴰⵢⵉ-ⴷⴷ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴰⵀ, ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⴰⵇⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵅⴰⴼⵉ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PS16_7","020_16_7","PSA","16","7","7","ⴰⴷ ⴱⴰⵔⴽⴻⵖ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵏⴻⵚⵃⴻⵏ. ⵓⵍⴰ ⵙ ⴵⵉⵍⴻⵜ ⵙⵙⵍⴻⵎⴷⴻⵏⵜ ⴰⵢⵉ ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS16_8","020_16_8","PSA","16","8","8","ⵜⵜⴻⴳⴳⴻⵖ ⵙⵉⴷⵉ ⵍⴻⴱⴷⴰ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴵⴰ ⵅ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⴼⵛⵉⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS16_9","020_16_9","PSA","16","9","9","ⵙ ⵓⵢⴰ ⵉⴼⴰⵔⵔⴻⵃ ⵓⵍ ⵉⵏⵓ, ⵉⵜⵜⴰⵔⵛⵉⵇ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ⵡⴰⵀ, ⵓⵍⴰ ⴷ ⴷⴷⴰⵜ ⵉⵏⵓ ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS16_10","020_16_10","PSA","16","10","10","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵔ ⵜⵙⴻⵎⵎⵃⴻⴷ ⵛⴰ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵏⵏⴻⵛ ⴰⴷ ⵉⴽⵉⵛⵛⵓ. ");
INSERT INTO rift_vpl VALUES ("PS16_11","020_16_11","PSA","16","11","11","ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵜⵢⴰⵡⴰⵏⵜ ⵣⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⵇⴰ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵏⵏⵉⵄⵎⴰⵜ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS17_1","020_17_1","PSA","17","1","1","ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ, ⴻⴳⴳ ⵍⴱⴰⵍ ⵉ ⵓⵖⵓⵢⵢⵉ ⵉⵏⵓ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵅⵎⵉ ⵜⵜⵥⴰⴵⵉⵖ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⴻⴽⴽ ⵛⴰ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS17_2","020_17_2","PSA","17","2","2","ⴻⵊⵊ ⵍⵃⴻⵇⵇ ⵉⵏⵓ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵖⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS17_3","020_17_3","PSA","17","3","3","ⵛⴻⴽ ⵜⵇⴻⴵⴱⴻⴷ ⵓⵍ ⵉⵏⵓ, ⵜⴰⵔⵣⵓⴷ ⴷⴰⵢⴻⵙ ⵙ ⴵⵉⵍⴻⵜ. ⵜⵊⴰⵔⵔⴱⴻⴷ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⴼⵉⴷ ⵡⴰⵍⵓ. ⵎⴰⵍⴰ ⵏⵡⵉⵖ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵛⴰ ⵡⴰⵔ ⵉⵃⵍⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⵉⵖ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⴷⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS17_4","020_17_4","PSA","17","4","4","ⵅ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS17_5","020_17_5","PSA","17","5","5","ⴻⴳⴳ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ ⴷⵉ ⵊⵊⵓⵔⵔⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴼⴰⵔⵔⵖⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS17_6","020_17_6","PSA","17","6","6","ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⵅⴰⴽ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴻⵣⵣⵓⵖ, ⵙⴻⵍ ⵉ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS17_7","020_17_7","PSA","17","7","7","ⵙⵛⴻⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵏⵊⴰⵎⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⴻⵏⵊⴰⵎⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵡⵡⵖⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PS17_8","020_17_8","PSA","17","8","8","ⵃⴹⴰ ⴰⵢⵉ ⴰⵎ ⵎⵓⵎⵎⵓ ⵏ ⵜⵉⵟⵟ ⵏⵏⴻⵛ, ⵙⵏⵓⴼⴼⴰⵔ ⴰⵢⵉ ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵛ ");
INSERT INTO rift_vpl VALUES ("PS17_9","020_17_9","PSA","17","9","9","ⵣⴻⴳ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴷⴰⵢⵉ ⵃⵚⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵇⵓⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS17_10","020_17_10","PSA","17","10","10","ⵏⵉⵜⵏⵉ ⴱⴻⵍⵍⵄⴻⵏ ⵓⵍ ⵏⵙⴻⵏ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏⵙⴻⵏ, ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵏⵏⴼⴰⵅⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS17_11","020_17_11","PSA","17","11","11","ⵍⴻⵅⵅⵓ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵄⴰⴷ ⵉ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵖ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵎⵎⵓⵇⵇⵍⴻⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵏⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS17_12","020_17_12","PSA","17","12","12","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵡⴻⵢⵔⴰⴷ ⵏⵏⵉ ⵉⵎⴻⵥⵥⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⴻⵣⵣⴻⵇ ⵜⴰⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS17_13","020_17_13","PSA","17","13","13","ⴽⴽⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⵔⵓⵃ ⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ, ⵖⴹⴻⵍ-ⵉ-ⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵛ ⵣⴻⴳ ⵓⵄⴻⴼⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS17_14","020_17_14","PSA","17","14","14","ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵓⴷⴰⵔⵜ-ⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵣⵉ ⵜᵉⵜⵜⵄⴻⵎⵎⴰⵔⴻⴷ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏ ⵙ ⵍⴻⴽⵏⵓⵣ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵢⴰⵡⴰⵏⴻⵏ, ⵜⵜⴻⵊⵊⴰⵏ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS17_15","020_17_15","PSA","17","15","15","ⵏⴻⵛⵛ ⴰⴷ ⵥⴰⵔⴻⵖ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⵜⵙⴻⴳⴷⴰ, ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵊⵊⵉⵡⵏⴻⵖ ⵙ ⵡⴰⴷⴷⵓⴷ ⵏⵏⴻⵛ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴼⴰⵇⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS18_1","020_18_1","PSA","18","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ. ⵏ ⴷⴰⵡⵓⴷ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵢⴻⵣⵍⵉ-ⵢⴰ ⵉ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵜ ⵉⴼⴻⴽⴽ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵛⴰⵡⵓⵍ.   ");
INSERT INTO rift_vpl VALUES ("PS18_2","020_18_2","PSA","18","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS18_3","020_18_3","PSA","18","3","3","ⵙⵉⴷⵉ ⴷ ⵜⴰⵙⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⴷ ⴰⵎⴼⴻⴽⴽⵉ ⵉⵏⵓ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ. ⵛⴻⴽ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵏ ⵓⵙⴻⵍⵇⵉ ⴷ ⵢⵉⵛⵛ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_4","020_18_4","PSA","18","4","4","ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⴰⵙⴻⵎⵖⴰⵔ, ⵓ ⵏⴻⵛⵛ ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_5","020_18_5","PSA","18","5","5","ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏⵜ ⴰⵢⵉ ⵍⵃⴻⵎⵍⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴰⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_6","020_18_6","PSA","18","6","6","ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵍⴰⵅⴰⵔⵜ ⵛⴰⵔⴼⴻⵏ ⴰⵢⵉ, ⵜⵉⵅⴻⵛⴼⵉⵏ ⵏ ⵍⵎⴻⵡⵜ ⵃⵚⴰⵔⴻⵏⵜ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_7","020_18_7","PSA","18","7","7","ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅ ⵙⵉⴷⵉ, ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵉ ⵅ ⴷⴷ-ⵍⴰⵖⵉⵖ. ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵙⵍⴰ ⵏⴻⵜⵜⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵉⵖⵓⵢⵢⴰⵏ ⵉⵏⵓ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS18_8","020_18_8","PSA","18","8","8","ⵅⴻⵏⵏⵉ ⵜⴻⵏⵀⴻⵣⵣ ⵓ ⵜⴰⵔⵊⵉⵊ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵙⵓⵙⴰ ⵏ ⵉⴷⵓⵔⴰⵔ ⵜⵜⵔⴰⵃⴻⵏ-ⴷⴷ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵓ ⵏⵀⴻⵣⵣⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS18_9","020_18_9","PSA","18","9","9","ⵉⴳⴻⵄⵄⴻⴷ ⴷⴷⴻⵅⵅⴰⵏ ⵣⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵉⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜⵚⴰⵔⴹ, ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵣⵣⴰⵢⴻⵙ ⵍⴻⴼⵃⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS18_10","020_18_10","PSA","18","10","10","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵢⴰⴹⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS18_11","020_18_11","PSA","18","11","11","ⵉⵏⴷⴻⵀ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ, ⵡⴰⵀ, ⵉⴹⵡⴰ, ⵏⴻⵜⵜⴰ ⵉⵃⴻⵡⵡⴻⵎ ⵅ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("PS18_12","020_18_12","PSA","18","12","12","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⴵⴻⵙⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵇⵉ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵄⵉⵛⵛⵓ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ, ⴰⵎⴰⵏ ⵉⴱⴱⵓⴱⴱⵙⴻⵏ, ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⴱⴱⴰⵔⴻⵛⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_13","020_18_13","PSA","18","13","13","ⵣⵉ ⵜⵉⵙⵙⵉⵇⵜ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵜⵜⴻⴽⴽⴻⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵏⵏⴻⵙ, ⴰⴽ-ⴷ ⵜⴻⴱⵔⵓⵔⵉ ⴷ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_14","020_18_14","PSA","18","14","14","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵊⵊⴰⵊ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵉⴳⴳⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵜⵜⵏⴻⴼⵔⴰⵔⴰ: ⵜⴰⴱⵔⵓⵔⵉ ⴷ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_15","020_18_15","PSA","18","15","15","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⴻⵏ, ⵉⵣⵣⴰⵔⵢⴻⴹ ⴰⵙⵙⴰⵎⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_16","020_18_16","PSA","18","16","16","ⵜⵉⵙⵉⵡⵉⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵜⴱⴰⵏⴻⵏⵜ, ⴷⵙⵓⵙⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷⴻⵡⵍⴻⵏ ⵄⴰⵔⵔⴰⵏ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵣⴻⴳ ⵓⵙⵓⴹⵉ ⵏ ⵍⴻⵄⵡⵉⵏ ⵣⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS18_17","020_18_17","PSA","18","17","17","ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ-ⴷⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵢⵉⵡⵉ ⴰⵢⵉ, ⵉⵊⴱⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_18","020_18_18","PSA","18","18","18","ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵣⵉ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⵉⵊⴻⵀⴷⴻⵏ, ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵊⴻⵀⵀⴷⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_19","020_18_19","PSA","18","19","19","ⵏⵉⵜⵏⵉ ⵃⵚⴰⵔⴻⵏ ⴰⵢⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴷ ⴰⵎⵄⴻⵎⵎⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_20","020_18_20","PSA","18","20","20","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵜⵜⴰⵙⵉⵄ ⵓⵛⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⵄⵉⵣⵣⴰ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_21","020_18_21","PSA","18","21","21","ⵙⵉⴷⵉ ⵉⵅⵍⴻⴼ ⴰⵢⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵣⴷⵓⴳⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉⵅⴻⴵⴻⵚ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_22","020_18_22","PSA","18","22","22","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵖ ⵛⴰ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵙ ⵓⵅⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("PS18_23","020_18_23","PSA","18","23","23","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵃⴻⵢⵢⵉⴷⴻⵖ ⵛⴰ ⵅ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS18_24","020_18_24","PSA","18","24","24","ⴰⵇⴰ-ⵢⵉ ⴽⴻⵎⵎⵍⴻⵖ ⵏⵉⵛⴰⵏ ⴰⴽⵉⴷⴻⵙ, ⵃⴹⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_25","020_18_25","PSA","18","25","25","ⵙⵉⴷⵉ ⵉⵅⵍⴻⴼ ⴰⵢⵉ ⴰⵏⴻⵛⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⴰⵏⴻⵛⵜ ⵏ ⵜⴰⵣⴷⵓⴳⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS18_26","020_18_26","PSA","18","26","26","ⵉ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴰⵎⵜⵉⵇⵇⵉ ⵉ ⵜⴻⴵⵉⴷ ⵛⴻⴽ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴰⵎⵜⵉⵇⵇⵉ, ⵉ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵉ ⵜⴻⴵⵉⴷ ⵛⴻⴽ ⵜⴽⴻⵎⵎⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS18_27","020_18_27","PSA","18","27","27","ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⵇⴰ ⵜᵉⵜⵜⵎⵓⵖⵣⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS18_28","020_18_28","PSA","18","28","28","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵄⴻⴼⴼⴰⵔⴻⵏⵜ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⴻⵀⵡⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS18_29","020_18_29","PSA","18","29","29","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵍⴻⴼⵏⴰⵔ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ! ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵉⵜⵜⴻⴳⴳ ⵜⴰⴼⴰⵡⵜ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_30","020_18_30","PSA","18","30","30","ⵎⵉⵏⵣⵉ ⴰⴽⵉⴷⴻⴽ ⴰⴷ ⴰⵣⵣⵍⴻⵖ ⵅ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ, ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴰⴷ ⵏⴻⴳⵣⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("PS18_31","020_18_31","PSA","18","31","31","ⴰⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴽⵎⴻⵍ, ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_32","020_18_32","PSA","18","32","32","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵎⵖⵉⵔ ⵙⵉⴷⵉ, ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵚⴹⴰⵔⵜ, ⵎⵖⵉⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("PS18_33","020_18_33","PSA","18","33","33","ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴱⴻⵢⵙⴻⵏ ⵙ ⵊⵊⵀⴻⴷ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⴱⵔⵉⴷ ⵉⵏⵓ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS18_34","020_18_34","PSA","18","34","34","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵏⵏⵉ ⵏ ⵜⵓⴷⴰⴷⵉⵏ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_35","020_18_35","PSA","18","35","35","ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵉⵖⴰⴵⴻⵏ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⴻⵃⴹⴻⵏ ⵉⵊⵊ ⵏ ⵍⵇⴻⵡⵙ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS18_36","020_18_36","PSA","18","36","36","ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⴷ ⴰⵙⴻⵏⵏⴻⴷ ⵉⵏⵓ, ⴰⵡⴰⴹⴻⵄ ⵏⵏⴻⵛ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_37","020_18_37","PSA","18","37","37","ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵜⵜⴰⵙⵉⵄ ⵉ ⵉⵚⵓⵔⵉⴼⴻⵏ ⵉⵏⵓ ⵙⴰⴷⵓ ⵉⵏⵓ, ⵜⵉⵛⴻⵄⴱⵉⵏ ⵉⵏⵓ ⵡⴰⵔ ⵎⴻⵢⵢⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS18_38","020_18_38","PSA","18","38","38","ⵏⴻⵛⵛ ⴹⴼⴰⵔⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵓ ⵃⴰⵔⵜⴻⵖ ⵅⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⵜⵄⵉⵇⵉⴱⴻⵖ ⴰⵍ ⵜⴻⵏ ⵇⴹⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS18_39","020_18_39","PSA","18","39","39","ⵏⴻⵛⵛ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ. ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ-ⴷⴷ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_40","020_18_40","PSA","18","40","40","ⵛⴻⴽ ⵜⴱⴻⵢⵙⴻⴷ ⴰⵢⵉ ⵙ ⵊⵊⴻⵀⴷ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵜⴰⵔⵔⵉⴷ-ⴷⴷ ⵉⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵙⴰⴷⵓ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_41","020_18_41","PSA","18","41","41","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⵉⵎⴻⵊⵊⴰⵔⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_42","020_18_42","PSA","18","42","42","ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴰⵎⵙⴻⵏⵊⴻⵎ, ⵍⴰⵖⴰⵏ ⵅ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵢⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_43","020_18_43","PSA","18","43","43","ⵏⴻⵛⵛ ⵡⴻⴷⴷⴰⵔⴻⵖ ⵜⴻⵏ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵣⵣⴰⵜ ⵉ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⵎ ⵓⴱⴻⴵⴰⵄ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⴼⴰⵔⴹⴻⵖ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_44","020_18_44","PSA","18","44","44","ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⴰⵢⵉ ⵣⴻⴳ ⵉⵎⵛⵓⴱⴱⵛⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵢⴷⵓⴷ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ, ⴰⴷ ⴰⵢⵉ ⵉⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS18_45","020_18_45","PSA","18","45","45","ⵎⵖⵉⵔ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵉⵙⵍⴰ ⵓⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ ⵡⴰⵀⴰ, ⵙⵍⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ. ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⵙⵙⵓⴱⵓⴹⴻⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS18_46","020_18_46","PSA","18","46","46","ⴼⴻⵛⵍⴻⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵏⴹⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵍⴱⴰⵔⴰⵊⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS18_47","020_18_47","PSA","18","47","47","ⵜⵓⴷⴰⵔⵜ ⵉ ⵙⵉⴷⵉ! ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵜⴻⵚⴹⴰⵔⵜ ⵉⵏⵓ. ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS18_48","020_18_48","PSA","18","48","48","ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⴻⵏⵜⴰⵇⴰⵎⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS18_49","020_18_49","PSA","18","49","49","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴼⴻⴽⴽⴰⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵡⴰⵀ, ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴹⴰⴷⴷⴰⵏ, ⵛⴻⴽ ⵜⴻⵙⵙⴻⵏⵊⴰⵎⴻⴷ ⴰⵢⵉ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS18_50","020_18_50","PSA","18","50","50","ⵅ ⵓⵢⴰ, ⵙⵉⴷⵉ, ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS18_51","020_18_51","PSA","18","51","51","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵙⴻⵏⵊⵉⵎⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⵎⵖⴰⵔⴻⵏ, ⵉⵙⵙⵛⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵙ, ⵉ ⴷⴰⵡⵓⴷ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS19_1","020_19_1","PSA","19","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS19_2","020_19_2","PSA","19","2","2","ⵉⵊⴻⵏⵡⴰⵏ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵍⵇⵓⴱⴱⴻⵜ ⵜⴻⵙⵙⴰⵡⴰⵍ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS19_3","020_19_3","PSA","19","3","3","ⴰⵙⵙ ⵉⵙⵙⴰⵣⵣⴰⵍ ⴰⵡⴰⵍⴻⵏ ⵉ ⵡⴰⵙⵙ, ⴵⵉⵍⴻⵜ ⵜⴻⵙⵙⵛⴰⵏ ⵜⵓⵙⵙⵏⴰ ⵖⴰⵔ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS19_4","020_19_4","PSA","19","4","4","ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵍⵀⴰⵔⴷ ⵓ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⴰⵡⴰⵍⴻⵏ, ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⴻⵙⵍⵉ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS19_5","020_19_5","PSA","19","5","5","ⵍⵓⵎⵓⵔⴰⵜ ⵏⵙⴻⵏ ⴼⴼⵖⴻⵏⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⴼⴼⵖⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴷⵉⵀⴰ ⵉⵊⵊ ⵏ ⵓⵇⵉⴹⵓⵏ ⵉ ⵜⴼⵓⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("PS19_6","020_19_6","PSA","19","6","6","ⴰⵎ ⵎⵓⵍⴰⵢ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵍⴻⵎⵍⴰⵛ, ⵉⵙⵍⵉⵡⵍⴻⵡ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵔⵢⴰⵙⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⴷⵉ ⵜⵉⵛⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS19_7","020_19_7","PSA","19","7","7","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵜᵉⵜⵜⵏⵓⴼⴼⴰⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⴻⵜ ⵉ ⵍⵃⴰⴷⵓⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS19_8","020_19_8","PSA","19","8","8","ⴰⵇⴰ ⵜⴻⴽⵎⴻⵍ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⵜⵉⵡⵉ-ⴷⴷ ⴰⴳⴻⵏⴼⵓ ⵉ ⴱⵓⵃⴱⴻⵍ. ⵛⵛⵀⴰⴷⴰⵜ ⵏ ⵙⵉⴷⵉ ⴷⴰⵢⵙⴻⵏⵜ ⵍⴰⵎⴰⵏ, ⵜⵜⵉⵛⵛⴻⵏⵜ ⵜⵉⵖⵉⵜ ⵉ ⵓⵃⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS19_9","020_19_9","PSA","19","9","9","ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⵙⵉⴷⵉ ⵙⴻⴳⴳⴷⴻⵏⵜ, ⵙⵙⴼⴰⵔⵔⵃⴻⵏⵜ ⵓⵍ. ⵜⴰⵡⵚⵉⵢⵢⴻⵜ ⵏ ⵙⵉⴷⵉ ⵜⴻⵚⴼⴰ, ⵜⴻⵙⵙⵛⴰⵏⴰ ⵜⴰⴼⴰⵡⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS19_10","020_19_10","PSA","19","10","10","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵙⵉⴷⵉ ⵜⴻⵚⴼⴰ, ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ. ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⵃⴻⵇⵇ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS19_11","020_19_11","PSA","19","11","11","ⵏⵉⵜⴻⵏⵜⵉ ⵊⴻⴱⴱⴷⴻⵏⵜ ⵎⴻⵥⵔⵉ ⴽⵜⴰⵔ ⵅ ⵡⵓⵔⴻⵖ, ⵡⴰⵀ, ⴽⵜⴰⵔ ⵣⴻⴳ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵎⵉⵥⵉⴷⵉⵏ ⵅ ⵜⴰⵎⵎⴻⵏⵜ ⵏⵉⵖ ⵅ ⵜⴰⵎⵎⴻⵏⵜ ⵏ ⵜⴻⵖⵔⴰⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("PS19_12","020_19_12","PSA","19","12","12","ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵡⴻⴱⴱⴻⵅ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⴷⴻⴳ ⵓⵃⴻⵟⵟⵓ ⵏⵙⴻⵏⵜ ⵜᵉⵜⵜⵏⵓⴼⴼⴰⵔ ⴷⴰⵢⴻⵙ ⵍⵎⵓⵏⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS19_13","020_19_13","PSA","19","13","13","ⴰⵡⴻⴷⴷⴰⵔ, ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵢⵓⵛⵉⵏ? ⵙⵉⵣⴷⴻⴳ ⴰⵢⵉ ⵣⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⴱⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS19_14","020_19_14","PSA","19","14","14","ⵃⴹⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵓⵄⴻⴼⴼⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⵚⴻⴵⵉⴹ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵣⴻⴳ ⵓⵅⴻⵟⵟⵓ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS19_15","020_19_15","PSA","19","15","15","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴷ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵏ ⵡⵓⵍ ⵉⵏⵓ, ⵅ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⴰⵎⴻⴼⴷⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS20_1","020_20_1","PSA","20","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS20_2","020_20_2","PSA","20","2","2","ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵉⵣⴷⴻⵖ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵢⵓⵄⵍⴰⵏ ⵉⴼⴰⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS20_3","020_20_3","PSA","20","3","3","ⴰⴷ ⴰⵛ ⵉⵡⵛ ⴰⴼⵓⵙ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵉⵄⴰⵡⴻⵏ ⵣⵉ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS20_4","020_20_4","PSA","20","4","4","ⴰⴷ ⵛⴻⴽ ⵢⵉⴷⴰⵔ ⴷⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵏⴻⵛ ⴰⵎ ⵜⴰⴷⵓⵏⵜ ⵉ ⵏⴻⵜⵜⴰ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS20_5","020_20_5","PSA","20","5","5","ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵎⵎⴻⵥⵔⵉ ⵡⵓⵍ ⵏⵏⴻⵛ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵉⵏⵡⴰⵢⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS20_6","020_20_6","PSA","20","6","6","ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵙⵍⵉⵡⵍⴻⵡ ⵅ ⵓⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵏⴻⵙⵙⵓⵄⵍⴰ ⵉⴱⴰⵏⴷⵓⵜⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⴰⴷ ⵉⵙⵙⵊⵉⵡⴻⵏ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS20_7","020_20_7","PSA","20","7","7","ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵢⴰⵔⵔ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵙ ⵜⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS20_8","020_20_8","PSA","20","8","8","ⵉⵏⴰ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⴷⴻⴳ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓ ⵉⵏⴰ ⴷⴻⴳ ⵉⵢⵙⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS20_9","020_20_9","PSA","20","9","9","ⵏⵉⵜⵏⵉ ⵓⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵡⴹⴰⵏ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⴽⴽⴰⵔ ⵓ ⵏⴻⵇⵇⵉⵎ ⵏⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PS20_10","020_20_10","PSA","20","10","10","ⴰ ⵙⵉⴷⵉ, ⴰⵡⵉ-ⴷⴷ ⴰⵙⴻⵏⵊⴻⵎ! ⴻⵊⵊ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⵔⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵏⵍⴰⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("PS21_1","020_21_1","PSA","21","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS21_2","020_21_2","PSA","21","2","2","ⴰ ⵙⵉⴷⵉ, ⴰⵊⴻⴵⵉⴷ ⵉⴼⴰⵔⵃ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ, ⵎⴰⵎⵎⴻⵛ ⵉⴼⴰⵔⵃ ⴰⵟⵟⴰⵙ ⵙ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("PS21_3","020_21_3","PSA","21","3","3","ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵎⴻⵥⵔⵉ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵛⴻⴽ ⵡⴰⵔ ⵜⵓⴳⵉⴷ ⵛⴰ ⴰⵣⴰⵡⴻⴳ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS21_4","020_21_4","PSA","21","4","4","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵙ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵍⵅⴰⵔ, ⵜⴻⵇⵇⵏⴻⴷ ⴰⵙ ⵜⵜⴰⵊ ⵏ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS21_5","020_21_5","PSA","21","5","5","ⵉⵜⵜⴰⵔ ⴰⵛ ⵜⵓⴷⴰⵔⵜ, ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵜⵜ, ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS21_6","020_21_6","PSA","21","6","6","ⵉⵎⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵙ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵜⴻⵙⵙⵣⴻⵀⵀⵊⴻⴷ ⵜ ⵙ ⵜⵉⵙⵙⵉⵇⵜ ⴷ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("PS21_7","020_21_7","PSA","21","7","7","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵉ-ⵜ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵛⴻⴽ ⵜⴻⵛⵛⵓⵔⴻⴷ ⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS21_8","020_21_8","PSA","21","8","8","ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵉⵜⵜⵛⴰⵍ ⵅ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⴼⵔⵉⵖ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS21_9","020_21_9","PSA","21","9","9","ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⴼ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⴼ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS21_10","020_21_10","PSA","21","10","10","ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵔⵉⴷ ⴰⵎ ⵜⴻⴼⵇⵓⵏⵜ ⵉⵛⴻⵎⵎⴹⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⴹⵃⴰⵔ ⵏⵏⴻⵛ, ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏ ⵉⵙⴰⵔⴹ ⵙ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS21_11","020_21_11","PSA","21","11","11","ⴰⴷ ⵜⴻⵎⵃⵉⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS21_12","020_21_12","PSA","21","12","12","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵏⴻⴷⵢⴻⵏ ⴰⵛ ⵍⵖⴰⵔ, ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PS21_13","020_21_13","PSA","21","13","13","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ ⴰⴷ ⵜⵏⴻⵢⵢⵛⴻⴷ ⵅ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS21_14","020_21_14","PSA","21","14","14","ⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵛ! ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵖⴻⵏⵏⴻⵊ ⵓ ⴰⴷ ⵏⵣⴻⵀⵀⴻⴷ ⵉ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS22_1","020_22_1","PSA","22","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ, ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵜⵓⴷⴰⴷⵜ ⵏ ⵜⵓⴼⴼⵓⵜ’. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS22_2","020_22_2","PSA","22","2","2","ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵊⵊⵉⴷ? ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵉ ⵜⴻⴵⵉⴷ ⵣⴻⴳ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵙⵖⵓⵢⵢⵓⵖ ⴰⵎ ⵡⴻⵢⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS22_3","020_22_3","PSA","22","3","3","ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵍⴰⵖⵉⵖ ⴷⴻⴳ ⵡⴰⵙⵙ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵔⵔⵉⴷ ⵛⴰ, ⵙ ⴵⵉⵍⴻⵜ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵓⴼⵉⵖ ⴰⵔⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS22_4","020_22_4","PSA","22","4","4","ⵛⴻⴽ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵉ ⵜⴻⴵⵉⴷ, ⵜⵣⴻⴷⴷⵖⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS22_5","020_22_5","PSA","22","5","5","ⵜⵜⴻⵛⵍⴻⵏ ⵅⴰⴽ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵜⵓⵖⴰ ⵜⵜⴻⵛⵍⴻⵏ ⵓ ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵜⴻⵏ ⴰⴷ ⵏⴻⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS22_6","020_22_6","PSA","22","6","6","ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⴻⵛⵍⴻⵏ ⵅⴰⴽ ⵓ ⵡⴰⵔ ⵏⵏⵃⴻⵛⵎⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS22_7","020_22_7","PSA","22","7","7","ⵏⴻⵛⵛ ⴷ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⵢⴰⵣ, ⵏⴻⵛⵛ ⴷ ⵍⵃⴻⴳⵔⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵖ ⵊⴰⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("PS22_8","020_22_8","PSA","22","8","8","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵥⵔⵉⵏ, ⵙⵜⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⵉ, ⴰⵔⴻⵣⵣⵎⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ⵙⵙⴻⵏⵀⴻⵣⵣⴰⵏ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("PS22_9","020_22_9","PSA","22","9","9","ⵇⵇⴰⵔⴻⵏ: “ⵙⴻⵄⴷⵓ ⵜ ⵅ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵜ ⵉⴼⴻⴽⴽ, ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴹⴰ ⵅⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("PS22_10","020_22_10","PSA","22","10","10","ⵛⴻⴽ ⵜⵊⴻⴱⴱⴷⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⴰⵢⵉ ⴷⵉ ⵍⴰⵎⴰⵏ ⵅ ⵡⴰⴱⴱⵓⵛⴻⵏ ⵏ ⵢⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("PS22_11","020_22_11","PSA","22","11","11","ⵣⵉ ⵍⴻⵎⵔⴰⵡⴻⵜ ⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔⴻⵖ ⵅⴰⴽ, ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS22_12","020_22_12","PSA","22","12","12","ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⴱⵓ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵣⵣⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵜⵓⴷⴻⵙ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵛⴰ ⴰⵎⵄⴰⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS22_13","020_22_13","PSA","22","13","13","ⴰⵟⵟⴰⵙ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵣⵉ ⴱⴰⵛⴰⵏ ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵢⵉ-ⴷⴷ, ");
INSERT INTO rift_vpl VALUES ("PS22_14","020_22_14","PSA","22","14","14","ⴰⵔⵣⵎⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⵉⵜⵜⵎⴻⵣⵣⴰⵇⴻⵏ, ⵉⵣⴻⵀⵀⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS22_15","020_22_15","PSA","22","15","15","ⵏⴻⵛⵛ ⵜⵜⵡⴰⴼⴰⵔⵔⵖⴻⵖ ⴰⵎ ⵡⴰⵎⴰⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵜⵜⵡⴰⵎⵎⵙⴻⴱⴹⴰⵏ. ⵓⵍ ⵉⵏⵓ ⴰⵎ ⵛⵛⵎⴻⵄ, ⴰⵇⴰ ⵉⴼⵙⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS22_16","020_22_16","PSA","22","16","16","ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵢⵓⵥⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⴵⵉⵇ ⵏ ⵉⵛⵜ ⵏ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⵉⵍⴻⵙ ⵉⵏⵓ ⵉⵍⵚⴻⵇ ⵖⴰⵔ ⵡⴰⵏⴻⵖ ⵉⵏⵓ. ⵛⴻⴽ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴰⵢⵉ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS22_17","020_22_17","PSA","22","17","17","ⵎⴰⵖⴰⵔ ⵉⵟⴰⵏ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵍⴻⵃⵔⴰⵎ ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⴰⵇⴰ ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ.    ");
INSERT INTO rift_vpl VALUES ("PS22_18","020_22_18","PSA","22","18","18","ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵃⴻⵙⴱⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵍⴰⵏ ⴰⵢⵉ, ⵅⴻⵣⵣⴰⵔⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS22_19","020_22_19","PSA","22","19","19","ⵏⵉⵜⵏⵉ ⴱⴹⴰⵏ ⴰⵔⵔⵓⴹ ⵉⵏⵓ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵍⴻⵄⴱⴰⵢⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS22_20","020_22_20","PSA","22","20","20","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⴰ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⴰⵙ-ⴷⴷ ⴷⴻⵖⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵄⴰⵡⵏⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS22_21","020_22_21","PSA","22","21","21","ⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵙⵙⵉⴼ, ⴰⵢⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵇⴻⵟⵟⴻⵙ ⵏ ⵡⴻⵇⵣⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS22_22","020_22_22","PSA","22","22","22","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴻⵢⵔⴰⴷ, ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ! ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS22_23","020_22_23","PSA","22","23","23","ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵅⴰⴽ ⵚⴻⴱⵃⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("PS22_24","020_22_24","PSA","22","24","24","ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴷⴻⵏ ⵙⵉⴷⵉ, ⵙⴻⵎⵖⴰⵔⴻⵎ ⵜ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵔⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵙⵄⵓⴵⴻⵎ ⵜ ⵓ ⵡⴻⵇⵇⴰⵔⴻⵎ ⵜ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵔⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("PS22_25","020_22_25","PSA","22","25","25","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵙⵙⴻⵃⵇⵉⵔ ⵛⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜ ⵉⵄⵉⴼⴼ ⵛⴰ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵛⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⴰⵙ ⵎⴰⵍⴰ ⵉⵍⴰⵖⴰ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PS22_26","020_22_26","PSA","22","26","26","ⵣⵣⴰⵢⴻⴽ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵇⴰⴷⵉ ⵉⵏⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS22_27","020_22_27","PSA","22","27","27","ⵉⵎⵡⴰⴹⵄⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⵓ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ, ⵉⵏⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵙⵉⴷⵉ ⴰⴷ ⴰⵙ ⵚⴻⴱⴱⵃⴻⵏ, ⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS22_28","020_22_28","PSA","22","28","28","ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜ ⵉⴷⴰⵔⴻⵏⵜ, ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏⵜ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⴻⵊⴷⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS22_29","020_22_29","PSA","22","29","29","ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉ ⵙⵉⴷⵉ ⵉ ⵜⴻⴵⴰ, ⵏⴻⵜⵜⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS22_30","020_22_30","PSA","22","30","30","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵚⴻⵃⵃⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵛⵛⴻⵏ, ⴰⴷ ⵙⴻⵊⴷⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵃⴹⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS22_31","020_22_31","PSA","22","31","31","ⵣⵣⴰⵔⵉⵄⴻⵜ ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵣⴻⵎⵎ ⴷ ⴰⵔⵔⴰⵡ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS22_32","020_22_32","PSA","22","32","32","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⴳⴳⴰ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PS23_1","020_23_1","PSA","23","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵉⵏⵓ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⴻⴽⴽ ⵛⴰ ⵣⵣⵄⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("PS23_2","020_23_2","PSA","23","2","2","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴻⵢⵢⴰⵃ ⴰⵢⵉ ⴷⵉ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉⵣⵉⵣⴰⵡⴻⵏ, ⵉⵏⴻⴷⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵢⴰⵔⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS23_3","020_23_3","PSA","23","3","3","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴼⴰⵇⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵉⵏⴻⴷⴷⴻⵀ ⴰⵢⵉ ⴷⵉ ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS23_4","020_23_4","PSA","23","4","4","ⵡⴰⵅⵅⴰ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵖ ⵣⵉ ⵍⵖⴰⵔ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⴽⵉⴷⵉ. ⴰⵄⴻⴽⴽⴰⵣ ⵏⵏⴻⵛ ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ ⵙⵙⴼⴻⵡⵡⴰⵊⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS23_5","020_23_5","PSA","23","5","5","ⵜⴻⵙⵙⴻⵡⵊⴰⴷⴻⴷ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ⵜⴷⴻⵀⵀⵏⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵙ ⵣⵣⴻⵛⵜ, ⵍⴽⴰⵙ ⵉⵏⵓ ⵉⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("PS23_6","020_23_6","PSA","23","6","6","ⵉⵡⴰ, ⵍⵅⵉⵔ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⴹⴼⴰⵔⴻⵏ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS24_1","020_24_1","PSA","24","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰ. ⴰⵣⴻⵀⵀⴻⴷ ⵓⵎⵉ ⵜⵜⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ ⵏ ⵍⵖⴰⵛⵉ ⵉⵜⵜⵄⴻⵢⵢⴷⴻⵏ: ⵉ ⵙⵉⴷⵉ ⵜⴻⴵⴰ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS24_2","020_24_2","PSA","24","2","2","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ ⵏⵏⴻⵙ ⵅ ⵍⴻⴱⵃⵓⵔ, ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ-ⵜ ⵅ ⵙⵙⴻⵃⵍⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS24_3","020_24_3","PSA","24","3","3","ⵜⵎⵉⵊⵊⴰ: ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS24_4","020_24_4","PSA","24","4","4","ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵖⵏⵉ: ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷ ⵡⵓⵍ ⵉⵚⴼⴰ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵅ ⵍⵖⴻⵛⵛ, ⵡⴰⵔ ⵉⵜⵜⵊⵊⴰⴵⴰ ⵥⵓⵔ! ");
INSERT INTO rift_vpl VALUES ("PS24_5","020_24_5","PSA","24","5","5","ⵎⴰⵔⵔⴰ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ: ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴽⵙⵉ ⵍⴱⴰⵔⴰⴽⴰ ⵣⵉ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS24_6","020_24_6","PSA","24","6","6","ⴷ ⵡⴰ ⴷ ⵊⵊⵉⵍ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⵙ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵄⵇⵓⴱ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS24_7","020_24_7","PSA","24","7","7","ⴱ. ⴰⵣⴻⵀⵀⴻⴷ ⵓⵎⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵉⵀⵢⵓⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ ⵏ ⵍⵖⴰⵛⵉ ⵉⵜⵜⵄⴻⵢⵢⴷⴻⵏ: ⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ, ⴰ ⵜⵉⵡⵡⵓⵔⴰ, ⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ, ⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ ⵏ ⵓⵄⵓⴵⵉ! ");
INSERT INTO rift_vpl VALUES ("PS24_8","020_24_8","PSA","24","8","8","ⵜⵎⵉⵊⵊⴰ ⵣⵉ ⵜⴻⵡⵡⵓⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ: ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵄⵓⴵⵉ ⵡⴰⵏⵉⵜⴰ? ⵎⴰⵔⵔⴰ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ: ⴷ ⵙⵉⴷⵉ, ⵉⵊⵀⴻⴷ ⵉⵊⴻⴱⴱⴰⵔ, ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⵊⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS24_9","020_24_9","PSA","24","9","9","ⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⴽⴻⵏⵜ, ⴰ ⵜⵉⵡⵡⵓⵔⴰ, ⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ, ⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ ⵏ ⵓⵄⵓⴵⵉ! ");
INSERT INTO rift_vpl VALUES ("PS24_10","020_24_10","PSA","24","10","10","ⵜⵎⵉⵊⵊⴰ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ: ⵎⵉⵏ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ, ⴰⵊⴻⴵⵉⴷ-ⴰ ⵏ ⵓⵄⵓⴵⵉ? ⵎⴰⵔⵔⴰ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ: ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵄⵓⴵⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS25_1","020_25_1","PSA","25","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰⵍⵉⴼ. ⴰ ⵙⵉⴷⵉ, ⵖⴰⵔⴻⴽ ⵉ ⴷⴷ-ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS25_2","020_25_2","PSA","25","2","2","ⴱⵉⵜ. ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵜⵜⴻⵛⵍⴻⵖ ⵅⴰⴽ. ⴻⵊⵊ ⴰⵢⵉ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ, ⴻⵊⵊ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⴻⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS25_3","020_25_3","PSA","25","3","3","ⴳⵉⵎⴻⵍ. ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ. ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵙ ⵍⴻⵖⴷⴰⵔ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ, ⴰⴷ ⵙⴻⴹⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS25_4","020_25_4","PSA","25","4","4","ⴷⴰⵍⵉⵜ. ⴰ ⵙⵉⴷⵉ, ⵙⵛⴻⵏ ⴰⵢⵉ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ, ⵙⵖⴰⵔ ⴰⵢⵉ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS25_5","020_25_5","PSA","25","5","5","ⵀⵉ. ⵏⴷⴻⵀ ⴰⵢⵉ ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ ⵓ ⵙⵖⴰⵔ ⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴷⴰⵢⴻⴽ ⴰⵙⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS25_6","020_25_6","PSA","25","6","6","ⵣⴰⵢⵉⵏ. ⵄⵇⴻⵍ, ⴰ ⵙⵉⴷⵉ, ⵅ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ, ⵅ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴵⴰⵏⵜ ⵣⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS25_7","020_25_7","PSA","25","7","7","ⵅⵉⵜ. ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔ ⵛⴰ ⴷⴷⵏⵓⴱ ⵏ ⵜⴻⵎⵥⵉ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵉⵅⴻⵟⵟⴰⵏ ⵉⵏⵓ. ⵅⴻⵎⵎ ⵎⴰⵛⴰ ⵖⴰⵔⵉ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS25_8","020_25_8","PSA","25","8","8","ⵜⵉⵜ. ⵙⵉⴷⵉ ⵉⵚⴱⴻⵃ, ⵉⵛⵏⴰ, ⵅ ⵓⵢⴰ ⴰⴷ ⵉⵙⵙⵖⴰⵔ ⴰⴱⵔⵉⴷ ⵉ ⵉⵎⴻⴷⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PS25_9","020_25_9","PSA","25","9","9","ⵢⵓⴷ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴻⵡⵡⴻⴷ ⵉⵎⵀⵉⵏⴻⵏ ⵙ ⵍⵃⴻⵇⵇ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵉ ⵉⵎⵀⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS25_10","020_25_10","PSA","25","10","10","ⴽⴰⴼ. ⵎⴰⵔⵔⴰ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴷ ⵛⵛⴰⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS25_11","020_25_11","PSA","25","11","11","ⵍⴰⵎⵉⴷ. ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵖⴼⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ-ⵜⵜ ⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS25_12","020_25_12","PSA","25","12","12","ⵎⵉⵎ. ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴰⵔⵢⴰⵣ ⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ? ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴰⴱⵔⵉⴷ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵅⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS25_13","020_25_13","PSA","25","13","13","ⵏⵓⵏ. ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⴻⵏⵙ ⴷⵉ ⵍⵅⵉⵔ, ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⵡⴰⵔⵜ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS25_14","020_25_14","PSA","25","14","14","ⵙⴰⵎⵉⵅ. ⵍⴰⵎⴰⵏ ⵉ ⴷⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵜ ⵉⵙⵙⴰⵔⴳⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("PS25_15","020_25_15","PSA","25","15","15","ⵄⴰⵢⵉⵏ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵍⴻⴱⴷⴰ ⴷⵉ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵣⵉ ⵜⵔⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS25_16","020_25_16","PSA","25","16","16","ⴱⵉ. ⴰⵔⵔ-ⴷⴷ ⵖⴰⵔⵉ ⵙ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵡⴻⵃⵃⴷⵉ ⵓ ⴷⵉ ⵍⴻⵖⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS25_17","020_25_17","PSA","25","17","17","ⵜⵙⴰⴷⵉ. ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏ ⵡⵓⵍ ⵉⵏⵓ ⴰⵇⴰ ⵎⵎⴰⵔⵏⵉⵏⵜ. ⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ ⵣⵉ ⴷⴷⵉⵇⴰⵜ ⵉ ⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS25_18","020_25_18","PSA","25","18","18","ⵔⵉⵅ. ⵅⵣⴰⵔ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⴷ ⵡⴰⵔⴱⴻⵔ ⵉⵏⵓ, ⴽⵙⵉ ⵅⴰⴼⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS25_19","020_25_19","PSA","25","19","19","ⵔⵉⵅ. ⵅⵣⴰⵔ ⵖⴰⵔ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵜⵜⵡⴰⴽⴻⵜⵜⴰⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⵛⴰⵔⵔⵀⴻⵏ ⴰⵢⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵛⵔⴰⵀ ⵉⵇⴻⵙⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS25_20","020_25_20","PSA","25","20","20","ⵛⵉⵏ. ⵃⴹⴰ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵓ ⴼⴻⴽⴽ ⴰⵢⵉ! ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵊⵊⵉ ⵛⴰ ⴰⴷ ⵙⴻⴹⵃⵉⵖ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⴽ ⵉ ⵖⴰ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS25_21","020_25_21","PSA","25","21","21","ⵜⴰⴼ. ⴰⴷ ⵜⴻⵃⴹⴰ ⴰⵢⵉ ⵍⴻⴽⵎⴰⵔⴻⵜ ⴷ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⵎⴰⵖⴰⵔ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴷⴰⵢⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS25_22","020_25_22","PSA","25","22","22","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴼⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS26_1","020_26_1","PSA","26","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰⵖ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵜⵜⴻⵛⵍⴻⵖ ⵅ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴻⴼⵔⵉⵖⴻⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS26_2","020_26_2","PSA","26","2","2","ⵇⴻⴵⴻⴱ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ, ⵊⴰⵔⵔⴻⴱ ⴰⵢⵉ, ⵙⴻⵚⴼⴰ ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ ⴷ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS26_3","020_26_3","PSA","26","3","3","ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⵇⴰ-ⵜⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS26_4","020_26_4","PSA","26","4","4","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵖ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵡⴰⵔ ⵜⵜⵎⵓⵏⴻⵖ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵛⴻⵎⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS26_5","020_26_5","PSA","26","5","5","ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⴰⴳⵔⴰⵡ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵍⴻⵀⵔⴰⵎ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵖ ⴰⴽ-ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS26_6","020_26_6","PSA","26","6","6","ⵏⴻⵛⵛ ⵙⵙⵉⵔⵉⴷⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴰⵎ ⵡⴰⵔ ⴷⴰⵢⵉ ⵍⵄⵉⴱ, ⵜⵜⴻⵏⵏⴹⴻⵖ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵛ, ⵍⵎⴻⴷⴱⴻⵃ ⵏⵏⴻⵛ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("PS26_7","020_26_7","PSA","26","7","7","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵇⴰⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS26_8","020_26_8","PSA","26","8","8","ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS26_9","020_26_9","PSA","26","9","9","ⵡⴰⵔ ⵙⵎⵓⵏⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴽ-ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵖⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵉⵙⵙⴰⵣⵣⴰⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS26_10","020_26_10","PSA","26","10","10","ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⴰⴼⵓⵙ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵉⵛⵛⵓⵔ ⵙ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS26_11","020_26_11","PSA","26","11","11","ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵉⵏⵓ, ⴼⴷⵉ ⴰⵢⵉ ⵓ ⵃⵉⵏⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS26_12","020_26_12","PSA","26","12","12","ⴰⴹⴰⵔ ⵉⵏⵓ ⵉⴱⴻⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴱⴰⵔⴽⴻⵖ ⵙⵉⴷⵉ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS27_1","020_27_1","PSA","27","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵙⵉⴷⵉ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉⵏⵓ ⴷ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵡⵉ ⵣⵉ ⵖⴰ ⴳⴳⵯⴻⴷⴻⵖ? ⵙⵉⴷⵉ ⴷ ⵍⵇⴻⵍⵄⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⵡⵉ ⵣⵉ ⵖⴰ ⵏⵏⵅⴻⵍⵄⴻⵖ ⵄⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("PS27_2","020_27_2","PSA","27","2","2","ⵓⵎⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ ⴷⴷⴰⵜ ⵉⵏⵓ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵏⵏⵇⴰⵔⴹⴻⵏ ⵏⵉⵜⵏⵉ, ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS27_3","020_27_3","PSA","27","3","3","ⵡⴰⵅⵅⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⵃⵊⴻⵎ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓⵍ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ. ⵡⴰⵅⵅⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⴽⴽⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵄⴰⴷ ⵏⴻⵛⵛ ⵜⵜⵖⵉⵎⵉⵖ ⵜⵜⴻⵛⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS27_4","020_27_4","PSA","27","4","4","ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⵜⴰⵔⴻⵖ ⵣⵉ ⵙⵉⴷⵉ, ⵜⴰ ⴰⴷ ⵅⴰⵙ ⴰⵔⵣⵓⵖ: ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵖ ⴷⴷⴰⵔⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵇⵛⴻⵖ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS27_5","020_27_5","PSA","27","5","5","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴷⵓⵔⵔⵓⵢ ⴰⵢⵉ ⴷⴻⴳ ⵓⵄⵓⵛⵛⵉ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵖⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵍⴻⵇⵇⴰ ⴰⵢⵉ ⴷⴻⴳ ⵓⵙⴻⵍⵇⵉ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⴰⵢⵉ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS27_6","020_27_6","PSA","27","6","6","ⵍⴻⵅⵅⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵖⴰⵔ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⴷⵉ ⵍⴱⵓⵇ ⴰⴷ ⴰⵡⵢⴻⵖ ⵜⵉⵖⴰⵔⵚⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ, ⵡⴰⵀ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS27_7","020_27_7","PSA","27","7","7","ⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⵍⴰⵖⵉⵖ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ ⵓ ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS27_8","020_27_8","PSA","27","8","8","ⵣⵣⴰⵢⴻⴽ ⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵡⵓⵍ ⵉⵏⵓ: “ⴰⵔⵣⵓ ⵅ ⵡⵓⴷⴻⵎ ⵉⵏⵓ!” ⵏⴻⵛⵛ ⴰⵔⴻⵣⵣⵓⵖ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS27_9","020_27_9","PSA","27","9","9","ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜⴻⴼⴼⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⵜⵅⵉⵢⵢⴰⴱ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ. ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ. ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵙⴻⵎⵃⴻⴷ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵊⵊⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS27_10","020_27_10","PSA","27","10","10","ⵎⴰⵖⴰⵔ ⴱⴰⴱⴰ ⴷ ⵢⴻⵎⵎⴰ ⴰⵇⴰ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⴽⵙⵉ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS27_11","020_27_11","PSA","27","11","11","ⵙⵛⴻⵏ ⴰⵢⵉ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS27_12","020_27_12","PSA","27","12","12","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵙⴻⵍⵍⴻⵎ ⵖⴰⵔ ⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵍⴻⵛⵀⵓⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴽⴽⴰⵔⴻⵏ ⵅⴰⴼⵉ, ⵉⵏⵏⵉ ⵉ ⵅⴰⴼⵉ ⵉⵜⵜⵙⵓⴹⴻⵏ ⵙ ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS27_13","020_27_13","PSA","27","13","13","ⵓⵀ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵖ ⴰⴷ ⵥⴰⵔⴻⵖ ⵍⵅⴰⵔ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS27_14","020_27_14","PSA","27","14","14","ⵔⴰⵊⴰ ⵙⵉⴷⵉ, ⵔⴰⵊⴰ ⵉ-ⵜ, ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵢⴻⴳⴳ ⵓⵍ, ⵡⴰⵀ ⵔⴰⵊⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS28_1","020_28_1","PSA","28","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⵉ ⵛⴻⴽ ⵓⵎⵉ ⵍⴰⵖⵉⵖ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ. ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜᵉⵜⵜⴻⵙⵍⵉⴷ, ⴰⵍⴰⵎⵉ, ⵙ ⵡⴻⵙⵇⴰⵔ ⵏⵏⴻⵛ ⵣⵣⴰⵜⵉ, ⵡⴰⵔ ⵜⵜⴰⵔⴻⴽⴽⵡⵉⵙⴻⵖ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS28_2","020_28_2","PSA","28","2","2","ⵙⴻⵍ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵓⵜⵔⴰ ⵉⵏⵓ, ⵅⵎⵉ ⵅⴰⴽ ⵜⵜⵍⴰⵖⵉⵖ, ⵅⵎⵉ ⴽⴻⵙⵙⵉⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS28_3","020_28_3","PSA","28","3","3","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵊⴰⵔⵔⵉ ⴰⴽ-ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵊⵊⵉⵔⴰⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵖⴰⵔⵙⴻⵏ ⵉⴵⴰ ⵍⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS28_4","020_28_4","PSA","28","4","4","ⵅⴻⴵⴻⵚ ⴰⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ⵅⴻⴵⴻⵚ ⴰⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⴻⵡⵛ ⴰⵙⴻⵏ ⵍⵎⵓⵏⴻⵜ ⵏⵙⴻⵏ ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS28_5","020_28_5","PSA","28","5","5","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵖⴹⴻⵍ, ⵡⴰⵔ ⵜⴻⵏ ⵉⴱⴻⵏⵏⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS28_6","020_28_6","PSA","28","6","6","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵓⵜⵔⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS28_7","020_28_7","PSA","28","7","7","ⵙⵉⴷⵉ ⴷ ⵍⵄⴻⵣⵣ ⵉⵏⵓ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵏ ⵓⵙⴻⵍⵇⵉ, ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵛⴻⵍ ⵅⴰⵙ ⵓⵛⴰ ⵜⵜⵡⴰⵄⴰⵡⵏⴻⵖ. ⵓⵍ ⵉⵏⵓ ⵉⵏⴻⴳⴳⴻⵣ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵙ ⵢⴻⵣⵍⵉ ⵉⵏⵓ ⴰⴷ ⵜ ⵇⴰⴷⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS28_8","020_28_8","PSA","28","8","8","ⵙⵉⴷⵉ ⴷ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵍⴱⵓⵔⵊ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵉⵙⴻⵏⵊⵉⵎⴻⵏ ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS28_9","020_28_9","PSA","28","9","9","ⵙⴻⵏⵊⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴱⴰⵔⴻⴽ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⵔⵡⴻⵙ ⵉ-ⵜⴻⵏ ⵓ ⴰⵔⴱⵓ ⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS29_1","020_29_1","PSA","29","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰⵔⵔⴰⵡ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⵄⵓⴵⵉ ⴷ ⵜⵣⴻⵎⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS29_2","020_29_2","PSA","29","2","2","ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⵄⵓⴵⵉ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴱⴻⵏⴷⵇⴻⵎ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⵄⴻⵣⵣ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS29_3","020_29_3","PSA","29","3","3","ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜⴻⴷⴷⴰⵔⴹⴻⵃ ⵜⵉⵡⴰ ⵉ ⵡⴰⵎⴰⵏ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵄⵓⴵⵉ ⵉⵙⵙⵀⴻⵎⵀⴻⵎ, ⵙⵉⴷⵉ, ⵅ ⵡⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS29_4","020_29_4","PSA","29","4","4","ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜⴻⵛⵛⵓⵔ ⵙ ⵊⵊⴻⵀⴷ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("PS29_5","020_29_5","PSA","29","5","5","ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜᵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵏⴻⴳⵍⵉⵏ, ⵙⵉⴷⵉ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵜⵉⵏⴻⴳⵍⵉⵏ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS29_6","020_29_6","PSA","29","6","6","ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵏⴻⴳⵣⴻⵏ ⴰⵎ ⵓⵄⴻⵊⵎⵉ, ⴰⴷⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⴷ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵔⵢⵓⵏ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS29_7","020_29_7","PSA","29","7","7","ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜⵏⴻⵇⵇⴻⵛ ⵉⵛⴻⵄⵄⴰⵍⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PS29_8","020_29_8","PSA","29","8","8","ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜⴰⵔⵔⴰ ⵍⴻⵅⵍⴰ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ, ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ ⵍⴻⵅⵍⴰ ⵏ ⵇⴰⴷⴰⵛ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ. ");
INSERT INTO rift_vpl VALUES ("PS29_9","020_29_9","PSA","29","9","9","ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜⴰⵔⵔⴰ ⵜⵓⴷⴰⴷⵉⵏ ⵜⵜⴰⵔⵡⴻⵏⵜ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⵄⴰⵔⵔⴰ ⵉⵣⴻⵖⵔⴰⵏ, ⵎⴰⵛⴰ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵎⴰⵔⵔⴰ ⵜⴻⵙⵙⴰⵡⴰⵍ ⵅ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS29_10","020_29_10","PSA","29","10","10","ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵎⴰ ⴰⵎ ⵍⵇⴰⴹⵉ ⵖⴰⵔ ⵙⵙⴻⵃⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ, ⵙⵉⴷⵉ ⵉⵜⵜⵖⵉⵎⴰ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS29_11","020_29_11","PSA","29","11","11","ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⵛ ⵊⵊⴻⵀⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵙⵉⴷⵉ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS30_1","020_30_1","PSA","30","1","1","ⴰⵣⴻⵀⵀⴻⴷ. ⵉⵣⵍⵉ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS30_2","020_30_2","PSA","30","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵓⵄⵍⵉⵖ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⵢⵉ, ⵡⴰⵔ ⵜⴻⵊⵊⵉⴷ ⵛⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵅ ⵡⴻⵄⵔⵓⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS30_3","020_30_3","PSA","30","3","3","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⴰⵛ, ⵓⵛⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵏⴼⵉⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS30_4","020_30_4","PSA","30","4","4","ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵓⵄⵍⵉⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⴰⵅⴰⵔⵜ, ⵜⴰⵔⵔⵉⴷ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵊⴰⵔ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("PS30_5","020_30_5","PSA","30","5","5","ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ, ⵇⴰⴷⴰⵎ, ⵄⴻⵇⵍⴻⵎ ⵅ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS30_6","020_30_6","PSA","30","6","6","ⵎⴰⵖⴰⵔ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⵜⵜⴻⴽⴽ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵉⵜⵜⵖⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵜⵓⴷⴰⵔⵜ. ⴷⵉ ⵜⵎⴻⴷⴷⵉⵜ ⴰⵇⴰ ⴷⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴰⵍ ⴵⵉⵍⴻⵜ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS30_7","020_30_7","PSA","30","7","7","ⴷⴻⴳ ⵓⴼⵍⴰⵃ ⵉⵏⵓ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: “ⵡⴰⵔ ⵜⵜⴼⴰⵔⵉⵖⴻⵖ ⵛⴰ ⵉ ⵍⴻⴱⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("PS30_8","020_30_8","PSA","30","8","8","ⴰ ⵙⵉⴷⵉ, ⴷⵉ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵜⴻⵙⵙⵎⴻⵜⵏⴻⴷ ⴰⴷⵔⴰⵔ ⵉⵏⵓ ⵙ ⵓⵎⴻⵜⵜⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⵍⴻⵃⵃⴼⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴷⴻⵡⵍⴻⵖ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS30_9","020_30_9","PSA","30","9","9","ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⴰⵛ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ, ⵜⵜⴰⵔⴻⵖ ⴰⵔⴹⴰ ⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS30_10","020_30_10","PSA","30","10","10","ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ, ⵏ ⵓⵀⴻⴽⴽⵡⵓ ⵉⵏⵓ ⵖⴰⵔ ⵜⵓⵔⵚⵓⴹⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ? ⵎⴰ ⴰⴷ ⵛⴻⴽ ⵜⵇⴰⴷⴰ ⵜⵄⴻⵊⵊⴰⵊⵜ? ⵎⴰ ⴰⴷ ⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS30_11","020_30_11","PSA","30","11","11","ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⵙⵉⴷⵉ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵉⵍⵉ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS30_12","020_30_12","PSA","30","12","12","ⵛⴻⴽ ⴰⵇⴰ ⵜⴰⵔⵔⵉⴷ ⵜⵖⵓⵢⵢⵉⵜ ⵉⵏⵓ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵜⴻⵙⵙⴰⵔⵅⵓⴷ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵉⵏⵓ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵜⴻⵙⵙⴱⴻⵢⵙⴻⴷ ⴰⵢⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PS30_13","020_30_13","PSA","30","13","13","ⵃⵉⵎⴰ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⴰⴷ ⴰⵛ ⵉⵣⴻⵀⵀⴻⴷ ⵓ ⵡⴰⵔ ⵉⵜⵜⵙⵓⵙⵓⵎ. ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS31_1","020_31_1","PSA","31","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS31_2","020_31_2","PSA","31","2","2","ⵏⴻⵛⵛ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ ⵖⴰⵔⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵙⴻⴹⵃⵉⵖ ⵉ ⵍⴻⴱⴷⴰ, ⴼⴻⴽⴽ ⴰⵢⵉ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS31_3","020_31_3","PSA","31","3","3","ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ, ⴼⴻⴽⴽ ⴰⵢⵉ ⴷⴻⵖⵢⴰ. ⵉⵍⵉ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⵏⴻⵛⵛ, ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS31_4","020_31_4","PSA","31","4","4","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ. ⵏⴷⴻⵀ ⴰⵢⵉ, ⵜⵀⵉⵍⵍⴰ ⴷⴰⵢⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS31_5","020_31_5","PSA","31","5","5","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵜⵔⴰⵛⵛⴰ ⵏⵏⵉ ⵅⴰⴼⵉ ⴳⴳⵉⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS31_6","020_31_6","PSA","31","6","6","ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⴳⴳⵉⵖ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ. ⵛⴻⴽ ⵜⴻⴼⴷⵉⴷ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵉ ⵜⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS31_7","020_31_7","PSA","31","7","7","ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⵖⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴱⴻⵟⵟⵍⴻⵏ. ⵏⴻⵛⵛ ⵜⵜⴻⵛⵍⴻⵖ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS31_8","020_31_8","PSA","31","8","8","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⵛⵇⴻⵖ ⵓ ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⵣⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⵓ ⵜⴰⵔⴻⴳⴳⴱⴻⴷ ⵅ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS31_9","020_31_9","PSA","31","9","9","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴰⵔⵔⵉⴷ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵍⴻⵄⴷⵓ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⵜⵜⴰⵙⵉⵄ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS31_10","020_31_10","PSA","31","10","10","ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵖ, ⵜⵉⵟⵟ ⵉⵏⵓ ⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷ ⵜⴻⴽⵔⵉⵛⵜ ⵉⵏⵓ ⴰⵇⴰ ⴼⴻⵛⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS31_11","020_31_11","PSA","31","11","11","ⵎⴰⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵜⴽⴻⵎⵎⴻⵍ ⵙ ⵡⴻⵛⴹⴰⵏ, ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵏⵓ ⵙ ⵓⵣⴻⵀⵀⴰⵔ. ⵊⵊⵀⴻⴷ ⵉⵏⵓ ⵉⵀⴻⵢⵢⴻⴼ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⵉⵅⵙⴰⵏ ⵉⵏⵓ ⴰⵇⴰ ⴰⵔⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS31_12","020_31_12","PSA","31","12","12","ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵙⵜⴻⵀⵣⵉ, ⵉ ⵊⵊⵉⵔⴰⵏ ⵉⵏⵓ ⵇⴰⵄ ⴰⵟⵟⴰⵙ, ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵏ ⴷⴻⵡⵍⴻⵖ ⴷ ⵉⵊⵊⴻⵏ ⵉ ⵉⵙⵙⵏⴻⵅⵍⵉⵄⴻⵏ. ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵍⵉⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵜⵜⵔⴰⴽⴽⵡⴰⵍⴻⵏ ⵣⵣⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS31_13","020_31_13","PSA","31","13","13","ⵜⵜⵓⵏ ⴰⵢⵉ ⵙ ⵡⵓⵍ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵛⴻⵇⴼⴰⵏ ⵏ ⵡⴻⵇⴷⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PS31_14","020_31_14","PSA","31","14","14","ⵎⴰⵖⴰⵔ ⵙⵍⵉⵖ ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⵛⴻⵇⵇⴼⴻⵏ ⴷⴰⵢⴻⴽ, ⴰⵙⵙⵉⴳⴳⵯⴻⴷ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵏⵏⴻⴹ ⴰⵢⵉ-ⴷⴷ ⵓⵎⵉ ⵅⴰⴼⵉ ⴳⴳⵉⵏ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ. ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴽⴽⵙⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS31_15","020_31_15","PSA","31","15","15","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵜⴻⵛⵍⴻⵖ ⵅⴰⴽ, ⴰ ⵙⵉⴷⵉ, ⵇⵇⴰⵔⴻⵖ: ‘ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("PS31_16","020_31_16","PSA","31","16","16","ⵍⵡⴻⵇⵜ ⵉⵏⵓ ⴰⵇⴰ-ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵓ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS31_17","020_31_17","PSA","31","17","17","ⴻⵊⵊ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⵖ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS31_18","020_31_18","PSA","31","18","18","ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵜⵜⵙⴻⴹⵃⵉⵖ, ⵎⴰⵖⴰⵔ ⵅⴰⴽ ⵉ ⵜⵜⵍⴰⵖⵉⵖ. ⴰⵔⵔ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ, ⴰⵔⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵓⵙⵎⴻⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS31_19","020_31_19","PSA","31","19","19","ⴻⵊⵊ ⴰⴷ ⵙⵇⴰⵔⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⴹⵉⴷⴷ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵙ ⵓⵄⴻⴼⴼⴰⵔ ⴷ ⵓⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS31_20","020_31_20","PSA","31","20","20","ⵎⴻⵛⵃⴰⵍ ⵉⵎⴻⵇⵇⴰⵔ ⵍⵅⴰⵔ ⵏⵏⴻⵛ ⵉ ⵜⵅⴻⵎⵎⵍⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵏⵏⵉ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("PS31_21","020_31_21","PSA","31","21","21","ⵛⴻⴽ ⵜⴻⵙⵙⴷⵓⵔⵔⵓⵢⴻⴷ ⵉ-ⵜⴻⵏ ⵙ ⵓⵍⴻⵃⵃⴰⴼ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵣⵉ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ. ⵛⴻⴽ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵅⵣⴰⵏⵜ, ⵣⴻⴳ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS31_22","020_31_22","PSA","31","22","22","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵢⵉ-ⴷⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴻⵄⵊⴻⴱ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS31_23","020_31_23","PSA","31","23","23","ⵏⴻⵛⵛ ⴷⴻⵖⵢⴰ ⵏⵏⵉⵖ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ!’ ⵎⴰⵛⴰ ⵄⴰⴷ ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵓⵎⵉ ⴷⴷ ⵅⴰⴽ ⵍⴰⵖⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS31_24","020_31_24","PSA","31","24","24","ⵙⵄⵉⵣⵣⴻⵎ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵃⴻⵟⵟⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵏⵏⴼⴰⵅⴻⵜ, ⵉⵜⵜⵅⴻⴵⴻⵚ ⵉ-ⵜ ⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS31_25","020_31_25","PSA","31","25","25","ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵢⴻⴳⴳ ⵓⵍ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS32_1","020_32_1","PSA","32","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⴰⵅⴻⵎⵎⵉ. ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵜⵄⴻⴷⴷⵉⵜ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⵍⵉⵏ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS32_2","020_32_2","PSA","32","2","2","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵉⵃⴻⵚⵚⴻⴱ ⵙⵉⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴱⵓⵃⴱⴻⵍ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS32_3","020_32_3","PSA","32","3","3","ⵓⵎⵉ ⵙⵇⴰⵔⴻⵖ, ⴰⵔⵛⴰⵏ ⵉⵖⵙⴰⵏ ⵉⵏⵓ, ⵙ ⵓⵣⴻⵀⵀⴰⵔ ⵉⵏⵓ, ⴰⵙⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS32_4","020_32_4","PSA","32","4","4","ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵉⵙⵙⴻⴷⵇⴻⵍ ⴰⵢⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵍⴰⵥⴰⵖ ⵏ ⵓⵏⴻⴱⴷⵓ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS32_5","020_32_5","PSA","32","5","5","ⵙⵙⴰⵔⴻⴳⴱⴻⵖ ⴰⵛ ⴷⴷⴻⵏⴱ ⵉⵏⵓ, ⵡⴰⵔ ⵙⵙⴷⵓⵔⵢⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⴰⴷ ⵏⴻⵄⵎⴻⵖ ⵅ ⵉⵅⴻⵟⵟⴰⵏ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ!”, ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⵜⴻⵖⴼⴰⵔⴻⴷ ⴰⵢⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉⵏⵓ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS32_6","020_32_6","PSA","32","6","6","ⵙ ⵓⵢⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵎⵜⵉⵇⵇⵉ ⴰⴷ ⴰⵛ ⵉⵙⵊⴻⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⵖⴰ ⵜⴻⵊⵊⴻⴷ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵛⴻⴽ ⵢⵓⴼⴰ. ⵅⵎⵉ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵙⵙⴻⵃⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜ ⵜⵍⴻⵇⵇⴻⴼ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS32_7","020_32_7","PSA","32","7","7","ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵓⴷⵓⵔⵔⵉ ⵉ ⵏⴻⵛⵛ, ⵜⴻⵙⵙⴰⵔⴻⴷ ⴰⵢⵉ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵜⵇⵓⵡⵡⴰⵔⴻⴷ ⴰⵢⵉ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵓⴼⴻⴽⴽⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS32_8","020_32_8","PSA","32","8","8","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵡⵛⴻⵖ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵙⵙⵍⴻⵎⴷⴻⵖ ⴰⴱⵔⵉⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵓⵢⵓⵔⴻⴷ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵡⴻⵚⵚⵉⵖ, ⴰⴷ ⵅⴰⴽ ⵜⵉⵍⵉ ⵜⵉⵟⵟ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS32_9","020_32_9","PSA","32","9","9","ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⴰⵎ ⵓⵢⵉⵙ, ⴰⵎ ⵓⵙⴰⵔⴷⵓⵏ ⴱⵍⴰ ⵍⴻⵄⵇⴻⵍ, ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵇⴻⵎⵎⵄⴻⵏ ⵙ ⵙⵙⵔⵉⵎⴻⵜ ⴷ ⵡⴻⵔⵢⴰⵎ, ⵏⵉⵖ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("PS32_10","020_32_10","PSA","32","10","10","ⴰⵟⵟⴰⵙ ⴵⴰⵏⵜ ⵜⴰⵎⴰⵔⴰ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙ ⵉⵇⵓⵡⵡⴰⵔ ⵏⴻⵜⵜⴰ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS32_11","020_32_11","PSA","32","11","11","ⴼⴰⵔⵃⴻⵎ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⵛⵇⴻⵎ, ⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵙⵍⵉⵡⴻⵍⵡⴻⵎ, ⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵍ ⵉⵙⴻⴳⴳⵎⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS33_1","020_33_1","PSA","33","1","1","ⵙⵍⵉⵡⴻⵍⵡⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⴰⵚⴻⴱⴱⴰⵃ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵍⵡⵉⵣⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_2","020_33_2","PSA","33","2","2","ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ ⵙ ⵍⴳⴰⵎⴱⵔⵉ, ⵣⴻⵀⵀⴷⴻⵎ ⴰⵙ ⵙ ⵍⵄⵓⴷ ⵓ ⵙ ⵍⵀⴰⵔⴱⴰ ⴰⴽ-ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⵉⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_3","020_33_3","PSA","33","3","3","ⵖⴻⵏⵏⵊⴻⵎ ⴰⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⴰⵎⴰⵢⵏⵓ, ⵉⵔⴰⵔⴻⵎ ⵎⵍⵉⵃ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⵏ ⵍⴱⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("PS33_4","020_33_4","PSA","33","4","4","ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵙⴻⴳⴳⴻⵎ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ, ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜ ⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_5","020_33_5","PSA","33","5","5","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ. ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS33_6","020_33_6","PSA","33","6","6","ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵣⵉ ⴰⵔⵔⵓⵃ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_7","020_33_7","PSA","33","7","7","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ ⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⵅⴻⵎⵎⴻⵍ ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_8","020_33_8","PSA","33","8","8","ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵣⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⵯⴻⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS33_9","020_33_9","PSA","33","9","9","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵓⵛⴰ ⴰⵇⴰ-ⵜ ⴷⵉⵏ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵎⴰⵔ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⴱⴻⴷⴷ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_10","020_33_10","PSA","33","10","10","ⵙⵉⴷⵉ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵛⵛⵡⴰⵔ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵉⵙⵙⴻⴱⴹⴻⵍ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS33_11","020_33_11","PSA","33","11","11","ⵛⵛⵡⴰⵔ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ, ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS33_12","020_33_12","PSA","33","12","12","ⵙⵙⴻⵄⴷ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⴷ ⵙⵉⴷⵉ, ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵅⴹⴰⵔ ⵉ-ⵜ ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS33_13","020_33_13","PSA","33","13","13","ⵙⵉⴷⵉ ⵉⵅⴻⵣⵣⴰⵔ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵜⵜⵡⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS33_14","020_33_14","PSA","33","14","14","ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵉⵎⴻⵜⵏⴻⵏ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS33_15","020_33_15","PSA","33","15","15","ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉⴽⴻⵡⵡⵏⴻⵏ ⵓⵍ ⵏⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵃⴻⴽⴽⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_16","020_33_16","PSA","33","16","16","ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴰⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴼⴻⴽⴽⵉ ⵙ ⵊⵊⴻⵀⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS33_17","020_33_17","PSA","33","17","17","ⴰⵇⴰ ⴷ ⴰⵅⴰⵔⵔⵉⵇ ⴱⴻⵍⵍⵉ ⴰⵢⵉⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ, ⵄⴰⴷ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⵏⴼⴻⴽⴽⵉ. ");
INSERT INTO rift_vpl VALUES ("PS33_18","020_33_18","PSA","33","18","18","ⵅⵣⴰⵔ, ⵜⵉⵟⵟ ⵏ ⵙⵉⴷⵉ ⵅ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS33_19","020_33_19","PSA","33","19","19","ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⵍⵎⴻⵡⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("PS33_20","020_33_20","PSA","33","20","20","ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⵉⵜⵜⵔⴰⵊⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵄⴰⵡⴻⵏ ⵏⵏⴻⵖ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵉ ⵓⵙⴻⵍⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("PS33_21","020_33_21","PSA","33","21","21","ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴰⵔⵔⴻⵃ ⵡⵓⵍ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⵛⴰⵍ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS33_22","020_33_22","PSA","33","22","22","ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⴰⵔⵙⴰ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵛⴻⴽ ⵏⴻⵜⵜⵔⴰⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("PS34_1","020_34_1","PSA","34","1","1","ⵏ ⴷⴰⵡⵓⴷ, ⵓⵎⵉ ⵉⵙⵙⵏⵉⵄⵎⵉⵍ, ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⴱⵉⵎⵉⵍⵉⴽ, ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵙ ⵢⵓⵥⵥⵍⴻⵏ ⴰⵍⴰⵎⵉ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PS34_2","020_34_2","PSA","34","2","2","ⴰⵍⵉⴼ. ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴱⴰⵔⴽⴻⵖ ⵉ ⵙⵉⴷⵉ ⵍⴻⴱⴷⴰ, ⴰⵚⴻⴱⴱⵉⵃ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴱⵍⴰ ⵇⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("PS34_3","020_34_3","PSA","34","3","3","ⴱⵉⵜ. ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⵚⴻⴱⴱⴻⵃ ⵉ ⵙⵉⴷⵉ. ⵉⵎⵀⵉⵏⴻⵏ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⵓ ⴰⴷ ⴼⴰⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_4","020_34_4","PSA","34","4","4","ⴳⵉⵎⴻⵍ. ⵙⴻⵎⵖⴰⵔⴻⵎ ⴰⴽⵉⴷⵉ ⵙⵉⴷⵉ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⵓⵄⵍⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("PS34_5","020_34_5","PSA","34","5","5","ⴷⴰⵍⵉⵜ. ⵏⴻⵛⵛ ⴰⵔⵣⵓⵖ ⵅ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ, ⵉⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⴻⵅⵍⵉⵄⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS34_6","020_34_6","PSA","34","6","6","ⵀⵉ. ⵏⵉⵜⵏⵉ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵛⴻⵄⵛⴻⵄⴻⵏ, ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵏ ⵣⴻⵡⵖⴻⵏ ⵙ ⵓⵙⴻⴹⵃⵉ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("PS34_7","020_34_7","PSA","34","7","7","ⵣⴰⵢⵉⵏ. ⵍⵎⴻⵙⴽⵉⵏ-ⴰ ⴷⴰⵏⵉⵜⴰ ⵉⵍⴰⵖⴰ ⵓ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵖⴰⵔⴻⵙ, ⵉⴼⴻⴽⴽ ⵉ-ⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS34_8","020_34_8","PSA","34","8","8","ⵅⵉⵜ. ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵇⵓⵡⵡⴰⵔ ⵙ ⵍⵎⴰⵔⴳⴻⵃ ⵏⵏⴻⵙ ⵅ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_9","020_34_9","PSA","34","9","9","ⵜⵉⵜ. ⵇⴰⵙⴻⵎ ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵛⵏⴰ. ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_10","020_34_10","PSA","34","10","10","ⵢⵓⴷ. ⴳⴳⵯⴻⴷⴻⵎ ⵙⵉⴷⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PS34_11","020_34_11","PSA","34","11","11","ⴽⴰⴼ. ⵉⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵜⵜⴻⵃⵡⴰⵊⴻⵏ, ⴷⴰⵢⵙⴻⵏ ⵍⴰⵥ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS34_12","020_34_12","PSA","34","12","12","ⵍⴰⵎⵉⴷ. ⴰⵙⴻⵎ-ⴷⴷ, ⴰ, ⴽⴻⵏⵏⵉⵡ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ! ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⵍⴻⵎⴷⴻⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS34_13","020_34_13","PSA","34","13","13","ⵎⵉⵎ. ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵎⴻⵥⵔⵉ ⴷⵉ ⵜⵓⴷⴰⵔⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵍⵅⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("PS34_14","020_34_14","PSA","34","14","14","ⵏⵓⵏ. ⵎⵏⴻⵄ ⵉⵍⴻⵙ ⵏⵏⴻⵛ ⵣⵉ ⵍⵖⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵏ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS34_15","020_34_15","PSA","34","15","15","ⵙⴰⵎⵉⵅ. ⵃⴻⵢⵢⴻⴷ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓ ⴻⴳⴳ ⵍⵅⴰⵔ, ⴰⵔⵣⵓ ⵅ ⵍⴻⵀⵏⴰ ⵓ ⴹⴼⴰⵔ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS34_16","020_34_16","PSA","34","16","16","ⵄⴰⵢⵉⵏ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ ⵎⴻⵢⵢⵍⴻⵏ ⵖⴰⵔ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_17","020_34_17","PSA","34","17","17","ⴱⵉ. ⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴹⵉⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴰⵢⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS34_18","020_34_18","PSA","34","18","18","ⵜⵙⴰⴷⵉ. ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ ⵓ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵖⴰⵔⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_19","020_34_19","PSA","34","19","19","ⵇⵓⴼ. ⵙⵉⴷⵉ ⵢⵓⴷⴻⵙ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵔⵥ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵉⵙⵙⴻⵏⵊⴰⵎ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵍⴱⴻⵣ ⴱⵓⵃⴱⴻⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_20","020_34_20","PSA","34","20","20","ⵔⵉⵅ. ⴰⵟⵟⴰⵙ ⵉⴵⴰⵏ ⵉⴼⴻⵇⵇⵓⵙⴻⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS34_21","020_34_21","PSA","34","21","21","ⵛⵉⵏ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⵟⵟⴰ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ. ");
INSERT INTO rift_vpl VALUES ("PS34_22","020_34_22","PSA","34","22","22","ⵜⴰⴼ. ⴰⵇⴰ ⵍⵖⴰⵔ ⴰⴷ ⵉⵏⴻⵖ ⴰⵄⴻⴼⴼⴰⵏ, ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵇⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS34_23","020_34_23","PSA","34","23","23","ⵙⵉⴷⵉ ⴰⴷ ⵉⴼⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ, ⵡⴰⵔ ⵜⵜⵡⴰⵄⴰⵇⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_1","020_35_1","PSA","35","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⵎⵛⵓⴱⴱⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ, ⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_2","020_35_2","PSA","35","2","2","ⵟⵟⴻⴼ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⴽⴽⴰⵔ, ⴻⵡⵛ ⴰⵢⵉ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS35_3","020_35_3","PSA","35","3","3","ⵊⴱⴻⴷ-ⴷⴷ ⵍⴰⵏⵙⴰ, ⵇⵇⴻⵏ ⴰⴱⵔⵉⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴷⴷ ⴰⵢⵉ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ, ⵉⵏⵉ ⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ: “ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("PS35_4","020_35_4","PSA","35","4","4","ⴰⵔⵔ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵜⵜⵡⴰⵅⴰⵔⴻⵡⴹⴻⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴹⵃⴻⵏ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⵉ ⵍⵖⴰⵔ ⵅⴰⴼⵉ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_5","020_35_5","PSA","35","5","5","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵢⵉⵛⴰⵔⴼⴰ ⴷⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⴻⵊⵊ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏ ⵉⵄⴰⵔⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_6","020_35_6","PSA","35","6","6","ⴻⵊⵊ ⴰⴷ ⵉⴷⵡⴻⵍ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴷ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹ, ⵓⵛⴰ ⴻⵊⵊ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵏ ⵉⴹⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS35_7","020_35_7","PSA","35","7","7","ⵎⴰⵖⴰⵔ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵅⴰⴼⵉ ⴰⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⴷ ⵜⵔⴰⵛⵛⴰ ⵏⵙⴻⵏ, ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ ⵖⵣⵉⵏ ⵜ ⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS35_8","020_35_8","PSA","35","8","8","ⴻⵊⵊ ⴰⵔⴻⴷⴷⴻⴵ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵙ ⴱⵍⴰ ⵎⴰ ⵉⵙⵙⴻⵏ, ⴻⵊⵊ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴰⴷ ⵜ ⵜᵉⵟⵟⴻⴼ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴰⵢⴻⵙ ⴷⴷ-ⵉⵡⴹⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵙ ⵉⵊⵊ ⵏ ⵓⵡⴻⵟⵟⵓ ⵉ ⵜ ⵉ ⵖⴰ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_9","020_35_9","PSA","35","9","9","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⴼⴰⵔⵃ ⵣⵉ ⵙⵉⴷⵉ, ⴰⴷ ⵢⴰⵔⵛⴻⵇ ⴷⴻⴳ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS35_10","020_35_10","PSA","35","10","10","ⴰⴷ ⵉⵏⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴰⵎ ⵛⴻⴽ! ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴼⴻⴽⴽⴰⵏ ⵍⵎⴻⵙⴽⵉⵏ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵊⴻⵀⵀⴷⴻⵏ, ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⴽⴻⵛⵛⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("PS35_11","020_35_11","PSA","35","11","11","ⵉⵛⴻⵀⵀⴰⴷⴻⵏ ⵉⵇⵟⴰⵟⵄⵉⵢⵢⴻⵏ ⴽⴽⴰⵔⴻⵏ. ⵎⵉⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ, ⵜⵜⵙⴻⵇⵙⴰⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS35_12","020_35_12","PSA","35","12","12","ⴰⵔⵔⵉⵏ ⴰⵢⵉ-ⴷⴷ ⵍⵖⴰⵔ ⴷⵉ ⵍⵅⴰⵔ, ⴳⴳⵉⵏ ⴷⴰⵢⵉ ⵍⴻⵃⵡⴻⵊ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵄⵉⵣⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_13","020_35_13","PSA","35","13","13","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⴰⵔⴹⴻⵖ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵀⴻⴵⵛⴻⵏ ⵏⵉⵜⵏⵉ, ⴳⴳⵉⵖ ⴰⴷ ⵉⵥⵓⵎⵎ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵓⵛⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵉⵏⵓ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵜᵉⴷⴷⴻⴽⴽⵡⴰⵍ-ⴷⴷ ⵖⴰⵔⵉ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS35_14","020_35_14","PSA","35","14","14","ⴰⵅⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ ⵏⵉⵖ ⴷ ⵓⵎⴰ, ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ, ⴰⵎ ⵛⴰ ⵏ ⵉⵊⵊ ⵉⵛⴻⵟⵟ ⵅ ⵢⴻⵎⵎⴰⵙ, ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⴰⵢⵉ ⴳⴳⵓⵔⴻⵖ ⵖⴻⵏⵏⵙⴻⵖ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⴷ ⴰⴱⴰⵔⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_15","020_35_15","PSA","35","15","15","ⵎⴰⵛⴰ ⵅⵎⵉ ⵜⵜⵇⴻⵊⴷⵉⵃⴻⵖ, ⴼⴰⵔⵔⵃⴻⵏ ⵏⵉⵜⵏⵉ, ⵜⵜⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ. ⵜⵜⵎⵓⵏⴻⵏ ⴹⵉⴷⴷ ⵉⵏⵓ ⵉⵏⵏⵉ ⵏ ⵡⴰⴷⴷⴰⵢ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵜ ⵙⵙⵏⴻⵖ. ⵛⴻⵇⵇⴼⴻⵏ ⴷⴰⵢⵉ, ⵡⴰⵔ ⵙⵙⵓⵙⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_16","020_35_16","PSA","35","16","16","ⴰⵎ ⵉⵏⵏⵉ ⵉⵖⴻⵟⵟⵚⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵖⵔⵓⵎ, ⴰⵎⵎⵓ ⵖⴻⵣⵣⴰⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵜⵉⵖⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS35_17","020_35_17","PSA","35","17","17","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵍ ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⴷ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵡⴰⵀⴰ? ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⴻⴳ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏⵙⴻⵏ ⵉ ⵉⴳⴳⵉⵏ, ⴰⵢⴻⵏⵏⵉ ⵉⵏⵓ ⵣⴻⴳ ⵡⴻⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_18","020_35_18","PSA","35","18","18","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⴷⴻⴳ ⵢⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⴷ ⵛⴻⴽ ⵚⴻⴱⴱⵃⴻⵖ ⵊⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS35_19","020_35_19","PSA","35","19","19","ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴷⵉ ⵍⴱⴰⵟⴻⵔ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵅⴰⴼⵉ ⴼⴰⵔⵃⴻⵏ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵅⴰⴼⵉ ⵎⵎⵙⴻⵖⵎⴰⵣⴻⵏ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS35_20","020_35_20","PSA","35","20","20","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⵛⴰ ⵅ ⵍⴻⵀⵏⴰ, ⵎⴰⵛⴰ ⵜⵜⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⴻⴳ ⵉⵏⵡⴰⵢⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵖⴻⵛⵛ ⴹⵉⴷⴷ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⵀⵓⴷⵏⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS35_21","020_35_21","PSA","35","21","21","ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵎⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵇⴰⵄ, ⵇⵇⴰⵔⴻⵏ: “ⵀⴰ, ⵀⴰ, ⵜⵉⵟⵟ ⵏⵏⴻⵖ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⴻⵥⵔⴰ ⵉ-ⵜⵜ!” ");
INSERT INTO rift_vpl VALUES ("PS35_22","020_35_22","PSA","35","22","22","ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⵜⵜ, ⵡⴰⵔ ⵜⵜⴻⵙⵇⴰⵔⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⴻⴳⴳⵯⵉⵊ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS35_23","020_35_23","PSA","35","23","23","ⴼⴰⵇ, ⴽⴽⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵃⴻⵇⵇ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS35_24","020_35_24","PSA","35","24","24","ⵃⴽⴻⵎ ⵅⴰⴼⵉ ⵙ ⵍⵃⴻⵇⵇ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵅⴰⴼⵉ ⴼⴰⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS35_25","020_35_25","PSA","35","25","25","ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵏⵉⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ: “ⵀⴰ, ⴰⵇⴰ ⴰⵏⴻⵖ ⵎⵍⵉⵃ!”, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵏⵉⵏ: “ⴰⵇⴰ ⵏⵙⴰⵔⴹ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("PS35_26","020_35_26","PSA","35","26","26","ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⵅ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⴰⴷ ⵜⵜⵡⴰⵅⴰⵔⴻⵡⴹⴻⵏ ⵓ ⴰⴷ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵊⵎⵉⵄ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵎⵖⴰⵔⴻⵏ ⵣⵣⴰⵜⵉ, ⴰⴷ ⵢⴰⵔⴹⴻⵏ ⵙ ⵓⵙⴻⴹⵃⵉ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS35_27","020_35_27","PSA","35","27","27","ⴻⵊⵊ ⵉⵏⵏⵉ ⵢⴰⵔⴹⴰⵏ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ ⵓ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵉⵏⵉⵏ: “ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵢⴻⴵⴰ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴹⴰⵏ ⴷⵉ ⵍⴻⵀⵏⴰ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("PS35_28","020_35_28","PSA","35","28","28","ⵅⴻⵏⵏⵉ ⵉⵍⴻⵙ ⵉⵏⵓ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴷ ⵓⵚⴻⴱⴱⴻⵃ ⵏⵏⴻⵛ ⴰⵙⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS36_1","020_36_1","PSA","36","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵣⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ. ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS36_2","020_36_2","PSA","36","2","2","ⵉⵙⵙⴰⵡⴰⵍ ⵓⵅⴻⵟⵟⵓ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("PS36_3","020_36_3","PSA","36","3","3","ⵎⵉⵏⵣⵉ ⴰⵅⴻⵟⵟⵓ-ⵢⴰ ⵉⵙⵙⵃⵉⵏⵏⴰⴱ ⵉ-ⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵢⵓⴼⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵜⴰⵔⵔⴰ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵛⵔⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS36_4","020_36_4","PSA","36","4","4","ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵖⴻⵛⵛ ⴷ ⵡⴻⵛⵎⴰⵜ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS36_5","020_36_5","PSA","36","5","5","ⵉⵜⵜⵅⴻⵎⵎⴻⵎ ⴷⵉ ⵍⵖⴻⵛⵛ ⴷⵉ ⵇⴰⵎⴰ ⵏⵏⴻⵙ, ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵡⴰⵔ ⵉⵚⴻⴱⵃⴻⵏ. ⵍⵖⴰⵔ ⵡⴰⵔ ⵜ ⵉⵜⵜⵎⴻⵏⴹⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("PS36_6","020_36_6","PSA","36","6","6","ⴰ ⵙⵉⴷⵉ, ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⴷⴰⵅⴻⵍ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴰⵍ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS36_7","020_36_7","PSA","36","7","7","ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵜⴻⴳⴳⴰ ⴰⵎ ⵢⵉⴷⵓⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ ⴰⵎ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ. ⵙⵉⴷⵉ ⵉⵙⵙⴻⵏⵊⴰⵎ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS36_8","020_36_8","PSA","36","8","8","ⵎⴻⵛⵃⴰⵍ ⵜⵉⵖⵍⴰ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ! ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ ⵖⴰⵔⴻⴽ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵖⴰⵔ ⵜⵉⵍⵉ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS36_9","020_36_9","PSA","36","9","9","ⵜⵜⵡⴰⵙⵊⴰⵡⵏⴻⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵉⵖⵣⴰⵔ ⵙ ⵏⵏⵄⴰⵎⵉ ⵏⵏⴻⵛ ⵜⴻⵡⵛⴻⴷ ⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS36_10","020_36_10","PSA","36","10","10","ⵎⴰⵖⴰⵔ ⵖⴰⵔⴻⴽ ⵉ ⵉⴵⴰ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵜⵓⴷⴰⵔⵜ, ⴷⵉ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵛ ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵍⴰ ⵜⴰⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS36_11","020_36_11","PSA","36","11","11","ⵙⵡⵉⵥⵥⴻⴹ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉⵙⵙⵏⴻⵏ, ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵅ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵍ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS36_12","020_36_12","PSA","36","12","12","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵙ ⵓⴹⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵢⴰⵔⵔ ⴰⴷ ⵜⴻⵍⵍⵄⴻⵖ ⵎⴰⵏⵉ ⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("PS36_13","020_36_13","PSA","36","13","13","ⴰⵇⴰ ⴷⵉⵏ ⵉ ⵡⴹⴰⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵜⵜⵡⴰⵖⴻⴹⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵄⴰⴷ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS37_1","020_37_1","PSA","37","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⴰⵍⵉⴼ. ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵔⴻⵇⵇ ⵜⴻⴼⵇⴻⵃⵜ ⵏⵏⴻⵛ ⵅ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵡⴰⵔ ⵜⵜⴰⵙⴻⵎ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS37_2","020_37_2","PSA","37","2","2","ⵎⴰⵖⴰⵔ ⴰⴷ ⵡⴹⴰⵏ ⴷⴻⵖⵢⴰ ⴰⵎ ⴰⵔⴱⵉⵄ, ⴰⵎ ⴰⵔⴱⵉⵄ ⴰⵣⵉⵣⴰ ⴰⴷ ⵙⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_3","020_37_3","PSA","37","3","3","ⴱⵉⵜ. ⵜⵜⵛⴻⵍ ⵅ ⵙⵉⴷⵉ ⵓ ⴻⴳⴳ ⵍⵅⴰⵔ, ⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵉⵍⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("PS37_4","020_37_4","PSA","37","4","4","ⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵡⵛ ⵎⵉⵏ ⴷⵉ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS37_5","020_37_5","PSA","37","5","5","ⴳⵉⵎⴻⵍ. ⴰⵔⵔ ⵜⵉⵛⵍⵉ ⵏⵏⴻⵛ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵜⵜⵛⴰⵍ ⵅⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("PS37_6","020_37_6","PSA","37","6","6","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⴹⵀⴰⵔ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴰⵎ ⵜⴼⴰⵡⵜ, ⵍⵃⴻⵇⵇ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵛⴻⵄⵛⵉⵄⴻⵏ ⵏ ⵜⴼⵓⵛⵜ ⴷⵉ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS37_7","020_37_7","PSA","37","7","7","ⴷⴰⵍⵉⵜ. ⵙⵓⵙⴻⵎ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵓ ⵔⴰⵊⴰ ⵜ. ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵜⴰⴼⵇⴻⵃⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⴰⵙⴻⵎ ⵅ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵍⵀⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS37_8","020_37_8","PSA","37","8","8","ⵀⵉ. ⴻⵊⵊ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⵙⴰ ⵓ ⴻⵊⵊ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵔⴰⵃ. ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵜⴰⴼⵇⴻⵃⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⴻⵖ. ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⴰⵡⵉ ⵎⵖⵉⵔ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_9","020_37_9","PSA","37","9","9","ⵎⴰⵖⴰⵔ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵉⵜⵉⵎⴻⵏ ⵅ ⵙⵉⴷⵉ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS37_10","020_37_10","PSA","37","10","10","ⵡⴰⵡ. ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵡⴰⵀⴰ ⵓⵛⴰ ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ. ⴰⴷ ⵜⵃⴻⴽⴽⴰⵔⴻⴷ ⵎⵍⵉⵃ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS37_11","020_37_11","PSA","37","11","11","ⵉⵎⵀⵉⵏⴻⵏ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⴰⵔⵔⴻⵏ ⵎⴻⵥⵔⵉ ⴷⵉ ⵍⴻⵀⵏⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_12","020_37_12","PSA","37","12","12","ⵣⴰⵢⵉⵏ. ⴰⵄⴻⴼⴼⴰⵏ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵜⵎⴻⵄⵎⴰⵍⵜ ⵜⵉⵃⵔⴰⵢⵎⵉⵢⵢⵉⵏ ⴹⵉⴷⴷ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵉⵜⵜⵖⴻⵣⵣⴰ ⵅⴰⵙ ⵜⵉⵖⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS37_13","020_37_13","PSA","37","13","13","ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴹⴻⵃⵃⴻⵛ ⵅⴰⵙ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵍⴰ ⴰⵇⴰ ⴰⵙⵙ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS37_14","020_37_14","PSA","37","14","14","ⵅⵉⵜ. ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵊⴻⴱⴷⴻⵏ-ⴷⴷ ⵙⵙⵉⴼ ⵓ ⵎⴻⵃⴹⴻⵏ ⵍⵇⴻⵡⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴻⴹⵍⴻⵏ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_15","020_37_15","PSA","37","15","15","ⵙⵙⵉⴼ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵍⵇⴻⴼ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵍⴻⵇⵡⴰⵙ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_16","020_37_16","PSA","37","16","16","ⵜⵉⵜ. ⴷⵔⵓⵙ ⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵃⵙⴻⵏ ⵣⴻⴳ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_17","020_37_17","PSA","37","17","17","ⵎⴰⵖⴰⵍ ⵉⵖⴰⴵⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⴻⵏⵏⴻⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_18","020_37_18","PSA","37","18","18","ⵢⵓⴷ. ⵙⵉⴷⵉ ⵉⵙⵙⴻⵏ ⵓⵙⵙⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ, ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_19","020_37_19","PSA","37","19","19","ⵡⴰⵔ ⵜⵜⵡⴰⵇⴻⵎⵎⵉⵃⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴰⵥ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵊⵉⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_20","020_37_20","PSA","37","20","20","ⴽⴰⴼ. ⵎⴰⵖⴰⵔ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴼⵏⴰⵏ, ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵇⴹⴰⵏ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉⵖⵍⴰⵏ ⵇⴰⵄ ⵣⴻⴳ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵇⴻⴱⴱⵓⵣⴻⵏ, ⴰⴷ ⴹⵡⴻⵏ ⴷⵉ ⵜⴰⵢⵢⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PS37_21","020_37_21","PSA","37","21","21","ⵍⴰⵎⵉⴷ. ⴰⵄⴻⴼⴼⴰⵏ ⵢⴰⵔⴻⵟⵟⴻⵍ, ⵡⴰⵔ ⵉⵜⵜⴰⵔⵔⵉ ⴰⵎⴰⵔⵡⴰⵙ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⵃⵉⵏⵏ, ⵉⵜⵜⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("PS37_22","020_37_22","PSA","37","22","22","ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_23","020_37_23","PSA","37","23","23","ⵎⵉⵎ. ⵉⵚⵓⵔⴰⴼ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵜⵜⵡⴰⵙⵙⵎⴻⵜⵜⵏⴻⵏ ⵣⵉ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵟⵟⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS37_24","020_37_24","PSA","37","24","24","ⵎⴰⵍⴰ ⵉⵡⴹⴰ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵏⴹⴰⵔ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS37_25","020_37_25","PSA","37","25","25","ⵏⵓⵏ. ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵎⴻⵥⵢⴰⵏ, ⵍⴻⵅⵅⵓ ⵡⵙⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵥⵔⵉⵖ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⵡⴰⵊⵊ, ⵏⵉⵖ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PS37_26","020_37_26","PSA","37","26","26","ⴰⵙⵙ ⵉⴽⵎⴻⵍ ⵉⵜⵜⵃⵉⵏⵏⴰ ⵓ ⵢⴰⵍⴻⵟⵟⴻⵍ ⵉ ⵉⵎⴻⵣⵍⴰⴹ, ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵍⴱⴰⵔⴰⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_27","020_37_27","PSA","37","27","27","ⵙⴰⵎⵉⵅ. ⵃⴻⵢⵢⴻⴷ ⵅ ⵍⵖⴰⵔ ⵓ ⴻⴳⴳ ⵍⵅⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⵜⵉⵍⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS37_28","020_37_28","PSA","37","28","28","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⵍⵃⴻⵇⵇ, ⵡⴰⵔ ⵉⵙⴻⵎⵎⴻⵃ ⴷⴻⴳ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ⵄⴰⵢⵉⵏ. ⴰⴷ ⵜⵜⵡⴰⵃⴹⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ, ⵎⴰⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_29","020_37_29","PSA","37","29","29","ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_30","020_37_30","PSA","37","30","30","ⴱⵉ. ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵜⵉⵖⵉⵜ, ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS37_31","020_37_31","PSA","37","31","31","ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⴻⴼⵔⵉⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_32","020_37_32","PSA","37","32","32","ⵜⵙⴰⴷⵉ. ⴰⵄⴻⴼⴼⴰⵏ ⵉⵍⴻⴱⴱⴻⵜ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜ ⵉⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("PS37_33","020_37_33","PSA","37","33","33","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵔⴻⵅⵅⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵃⴽⴻⵎ ⵅⵎⵉ ⵜ ⵖⴰ ⵉⵃⴰⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS37_34","020_37_34","PSA","37","34","34","ⵇⵓⴼ. ⵙⵉⵜⵉⵎ ⵅ ⵙⵉⴷⵉ ⵓ ⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵔⵜⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ. ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⴰⵇⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS37_35","020_37_35","PSA","37","35","35","ⵔⵉⵅ. ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⴷ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ, ⵉⵎⴻⵇⵇⴰⵔ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS37_36","020_37_36","PSA","37","36","36","ⴰⵇⴰ ⵉⵄⴷⵓ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵡⴰⵔ ⵜ ⵜⵓⵖⵉ ⵛⴰ ⵄⴰⴷ ⴷⵉⵏ. ⴰⵔⵣⵓⵖ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵉⴷⵡⴻⵍ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS37_37","020_37_37","PSA","37","37","37","ⵛⵉⵏ. ⵃⴹⴰ ⵅ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉⴽⵎⴻⵍ ⵓ ⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_38","020_37_38","PSA","37","38","38","ⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵊⵎⵉⵄ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("PS37_39","020_37_39","PSA","37","39","39","ⵜⴰⴼ. ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⵡⵍⴰ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS37_40","020_37_40","PSA","37","40","40","ⵙⵉⴷⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⴰⴼⵓⵙ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⴼⴻⴽⴽ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵏⵊⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS38_1","020_38_1","PSA","38","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵉ ⵍⵉⴷⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS38_2","020_38_2","PSA","38","2","2","ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵄⴰⵇⴰⴱ ⴷⴻⴳ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵡⴻⴷⴷⴰⴱ ⵙ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS38_3","020_38_3","PSA","38","3","3","ⵎⴰⵖⴰⵔ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ ⵓⴷⴼⴻⵏⵜ ⴷⴰⵢⵉ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵣⴻⵢⵢⴰⵔ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS38_4","020_38_4","PSA","38","4","4","ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⴽⴻⵎⵎⵍⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵣⴻⴳ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵎⵉⵏ ⵉⵚⴻⵃⵃⴻⵏ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS38_5","020_38_5","PSA","38","5","5","ⵎⴰⵖⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵉⵏⵓ ⴳⴻⵄⵄⴷⴻⵏⵜ ⴰⵢⵉ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⴷⴻⵇⵇⵍⴻⵏⵜ ⵅⴰⴼⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴷⴷⵇⴻⵍ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS38_6","020_38_6","PSA","38","6","6","ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵉⵏⵓ ⴷⴰⵢⵙⴻⵏ ⴰⵔⵔⵉⵃⴻⵜ, ⴳⴻⵢⵢⵃⴻⵏ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS38_7","020_38_7","PSA","38","7","7","ⴷⴻⵡⵍⴻⵖ ⵇⴻⵡⵙⴻⵖ, ⴷⴻⵡⵍⴻⵖ ⵖⴻⵏⵙⴻⵖ ⴰⵍ ⵟⵟⴰⵔⴼ. ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⴳⴳⵓⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⴰⴱⴰⵔⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS38_8","020_38_8","PSA","38","8","8","ⵎⴰⵖⴰⵔ ⵜⵜⴰⵛⵉⵖ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵉⵏⵓ ⴰⵔⵖⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⴽⴻⵎⵎⵍⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS38_9","020_38_9","PSA","38","9","9","ⵏⴻⵛⵛ ⵊⴻⵎⵎⴷⴻⵖ ⵓ ⵜⵜⵡⴰⵖⴻⴹⵍⴻⵖ ⵇⴰⵄ, ⵙⵖⵓⵢⵢⵓⵖ ⵙ ⵣⵣⵀⵉⵔ ⵏ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS38_10","020_38_10","PSA","38","10","10","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵖⴰⵔⵉ ⵎⴻⵥⵔⵉ ⴰⵇⴰ-ⵜ ⵣⵣⴰⵜⴻⴽ, ⴰⵡⴻⵄⵄⴻⴹ ⵉⵏⵓ ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵏⵓⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS38_11","020_38_11","PSA","38","11","11","ⵓⵍ ⵉⵏⵓ ⵉⴷⴷⴻⵏⴷⵓⵏ, ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵉⴼⴼⴻⵖ ⴰⵢⵉ, ⵓⵍⴰ ⴷ ⵜⴰⴼⴰⵡⵜ ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵡⴰⵀ ⵓⵍⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⴻⴷⴷⴻⵏⵜ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS38_12","020_38_12","PSA","38","12","12","ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ ⴱⴻⴷⴷⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵉⵏⵓ ⵖⴰⵔ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵢⵓⴷⵙⴻⵏ ⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS38_13","020_38_13","PSA","38","13","13","ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴽⴽⵙⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⵏⴻⴷⵢⴻⵏ ⴰⵢⵉ ⵍⴻⴼⵅⵓⵅ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵎ ⵎⵎⴻⵥⵔⴻⵏ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⵏⵉⵜⵏⵉ ⵛⴻⵍⵖⴻⵏ ⵙ ⵍⵖⴻⵛⵛ ⴰⵙⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS38_14","020_38_14","PSA","38","14","14","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴰⵅⵎⵉ ⴷ ⴰⴷⴻⵀⵛⵓⵔ, ⴰⵎ ⵡⴻⵢⵏⴰⵡ ⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵎⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS38_15","020_38_15","PSA","38","15","15","ⵏⴻⵛⵛ ⴰⵎ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵜⵡⴰⵔⵔⵉⵜ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS38_16","020_38_16","PSA","38","16","16","ⵎⴰⵖⴰⵔ ⵜⵜⵔⴰⵊⵉⵖ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⵉⴷ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS38_17","020_38_17","PSA","38","17","17","ⵎⴰⵖⴰⵔ ⵏⵏⵉⵖ: “ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵡⴰⵔ ⵅⴰⴼⵉ ⴼⴰⵔⵔⵃⴻⵏ, ⵅⵎⵉ ⵖⴰ ⴼⴰⵔⵖⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵡⴰⵔ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS38_18","020_38_18","PSA","38","18","18","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵖ, ⵍⴻⵃⵔⵉⵇ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("PS38_19","020_38_19","PSA","38","19","19","ⵎⴰⵖⴰⵔ ⵙⵙⴰⵔⴳⴱⴻⵖ ⴰⵛ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⴰⵇⴰ ⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵖ ⵣⵉ ⴷⴷⴻⵏⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS38_20","020_38_20","PSA","38","20","20","ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⵊⵊⴻⵀⴷ, ⴰⵟⵟⴰⵙ ⴵⴰⵏ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS38_21","020_38_21","PSA","38","21","21","ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵍⵅⴰⵔ ⵙ ⵍⵖⴰⵔ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉⵏⵓ, ⵓⵎⵉ ⵏⴻⵛⵛ ⴰⵔⴻⵣⵣⵓⵖ ⵅ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS38_22","020_38_22","PSA","38","22","22","ⵡⴰⵔ ⴷⴰⵢⵉ ⵙⴻⵎⵎⴻⵃ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⴰⴳⴳⵯⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("PS38_23","020_38_23","PSA","38","23","23","ⴷⴻⵖⵢⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⴰⴼⵓⵙ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS39_1","020_39_1","PSA","39","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵉ ⵢⴰⴷⵓⵜⵓⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS39_2","020_39_2","PSA","39","2","2","ⵏⵏⵉⵖ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⴰⴷ ⵃⴹⵉⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵣⵉ ⴷⴷⴻⵏⴱ ⵏ ⵢⵉⵍⴻⵙ ⵉⵏⵓ, ⴰⴷ ⵟⵟⴼⴻⵖ ⴰⵃⴻⵟⵟⵓ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵎⴰⵏⵜ, ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵓⵄⴻⴼⴼⴰⵏ ⵣⵣⴰⵜⵉ.” ");
INSERT INTO rift_vpl VALUES ("PS39_3","020_39_3","PSA","39","3","3","ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵡⴻⵢⵏⴰⵡ, ⵍⴻⵃⵃⴼⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵙ ⵓⵙⴻⵖⴷ, ⴱⴻⴽⵎⴻⵖ ⵓⵍⴰ ⵅ ⵍⵅⴰⵔ, ⵎⴰⵛⴰ ⵍⴻⵃⵔⵉⵇ ⵉⵏⵓ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS39_4","020_39_4","PSA","39","4","4","ⵓⵍ ⵉⵏⵓ ⵉⴷⵡⴻⵍ ⵉⵃⴻⵎⵎⴰ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ, ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⴻⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵖⴰⵔ ⵓⵏⵉⵅⵙⴻⵙ ⵉⵏⵓ. ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵢⵉⵍⴻⵙ ⵉⵏⵓ: ");
INSERT INTO rift_vpl VALUES ("PS39_5","020_39_5","PSA","39","5","5","“ⴰ ⵙⵉⴷⵉ, ⵙⵛⴻⵏ ⴰⵢⵉ ⴰⵏⴻⴳⴳⴰⵔ ⵉⵏⵓ, ⵎⴰⵏ ⵉⴵⴰ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⴰⵎⵎⴻⵛ ⴰⵔⴻⵅⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS39_6","020_39_6","PSA","39","6","6","ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵛⴱⴰⵔⴻⵏ ⵏ ⵓⴼⵓⵙ, ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵛⴻⴽ ⴰⵅⵎⵉ ⴷ ⵡⴰⵍⵓ. ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵉⴱⴻⴷⴷ ⵉⵎⵜⴻⵏ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴰⵢⵢⵓⵜ.” ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS39_7","020_39_7","PSA","39","7","7","ⵉⵡⴰ, ⴱⵏⴰⴷⴻⵎ ⵉⴳⴳⵓⵔ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ, ⵡⴰⵀ, ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⵓⵜ ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵔⴰⵃ ⵉⵜⵜⴰⵙ-ⴷⴷ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏ, ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏ ⵡⴻⵏ ⵜ ⵉ ⵖⴰ ⵉⴽⵙⵉⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS39_8","020_39_8","PSA","39","8","8","ⵓ ⵍⴻⵅⵅⵓ, ⵎⵉⵏ ⵖⴰ ⵙⵙⵉⵜⵎⴻⵖ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ? ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⵔⴰⵊⵉⵖ ⵛⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("PS39_9","020_39_9","PSA","39","9","9","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵅⴻⵟⵟⴰⵏ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⴳⴳ ⵛⴰ ⴷ ⵜⵉⵙⴻⴹⵃⴰⵛ ⵉ ⵓⴱⵓⵃⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS39_10","020_39_10","PSA","39","10","10","ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵡⴻⵢⵏⴰⵡ, ⵡⴰⵔ ⴰⵔⴻⵣⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴷ ⵛⴻⴽ ⵉ ⵉⴳⴳⵉⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS39_11","020_39_11","PSA","39","11","11","ⴽⵙⵉ ⵣⵣⴰⵢⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴼⴻⵏⵏⵉⵖ ⵙ ⵓⵟⴻⴼⴼⵓ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS39_12","020_39_12","PSA","39","12","12","ⵎⴰⵍⴰ ⵜⵙⴻⴳⴳⴷⴻⴷ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵜⵉⵢⵢⵉⵜⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵜⴻⵙⵙⴼⴻⵙⵢⴻⴷ ⴰⵛⴻⵡⵡⴰⵔ ⵏ ⵡⴰⴷⴷⵓⴷ ⵏⵏⴻⵙ ⴰⵎ ⵜⵛⵉⵏⴷⴰ. ⵉⵡⴰ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴼⵏⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴰⵢⵢⵓⵜ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS39_13","020_39_13","PSA","39","13","13","ⵙⴻⵍ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵙⵃⴻⵙⵙ ⵉ ⵓⵖⵓⵢⵢⵉ ⵉⵏⵓ. ⵡⴰⵔ ⵜⵜⴻⴱⴽⵉⵎ ⵖⴰⵔ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴷ ⴰⵎⵄⴻⵣⵣⴻⴱ ⵖⴰⵔⴻⴽ, ⴰⵎ ⵎⴰⵔⵔⴰ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS39_14","020_39_14","PSA","39","14","14","ⵙⵃⴻⵢⵢⴻⴷ ⵅⴰⴼⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⵄⵛⴻⵄⴻⵖ ⵄⴰⴷ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵇⴱⴻⵍ ⴰⴷ ⵔⴰⵃⴻⵖ ⵓ ⵡⴰⵔ ⴷⴰ ⵜⵜⵉⵍⵉⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS40_1","020_40_1","PSA","40","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⴰⵣⴻⵀⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS40_2","020_40_2","PSA","40","2","2","ⵙⵙⵉⵜⵉⵎⴻⵖ ⵇⴰⵄ ⵅ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵙ ⵓⵣⴻⴵⵉⴼ, ⵉⵙⵙⵃⴻⵙⵙ ⵖⴰⵔ ⵓⵖⵓⵢⵢⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS40_3","020_40_3","PSA","40","3","3","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ ⵉⵏⴻⵇⵇⴻⵏ, ⵣⴻⴳ ⵓⴱⴻⴵⴰⵄ ⴷ ⵓⴱⴰⵔⵢⵓⴹ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵅ ⵜⴻⵚⴹⴰⵔⵜ, ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS40_4","020_40_4","PSA","40","4","4","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⴷ ⴰⵎⴰⵢⵏⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵉ ⴰⵔⴻⴱⴱⵉ. ⴰⵟⵟⴰⵙ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ, ⴰⴷ ⵜⴻⵛⵍⴻⵏ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS40_5","020_40_5","PSA","40","5","5","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵛⵍⴻⵏ ⵅ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵢⵢⵍⴻⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ, ⵓⵍⴰ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵅⴰⵔⵔⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("PS40_6","020_40_6","PSA","40","6","6","ⴰⵟⵟⴰⵙ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ, ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵜⴻⵏⵡⵉⴷ ⵅⴰⵏⴻⵖ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵄⴱⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⴽ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏⵜ ⵀⴰⵊⵉⵖ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙⵙⵉⵡⵍⴻⵖ. ⴰⵇⴰ ⵏⵉⵜⴻⵏⵜⵉ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS40_7","020_40_7","PSA","40","7","7","ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⵛⴻⴽ ⵜⴰⵔⵣⵎⴻⴷ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ. ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜᵉⵜⵜⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS40_8","020_40_8","PSA","40","8","8","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ, ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵢⵓⵔⴰ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS40_9","020_40_9","PSA","40","9","9","ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵎⴻⵥⵔⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ. ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("PS40_10","020_40_10","PSA","40","10","10","ⵏⴻⵛⵛ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵅⵣⴰⵔ, ⵡⴰⵔ ⵜⵜⴻⵇⵇⵏⴻⵖ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS40_11","020_40_11","PSA","40","11","11","ⵡⴰⵔ ⵜⵜⵅⴻⵎⵎⵍⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ, ⵙⵙⴰⵡⴰⵍⴻⵖ ⵅ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ ⵓ ⵅ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ. ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵉ ⴷⴰⵢⴻⴽ ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS40_12","020_40_12","PSA","40","12","12","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⵙⵙⴱⴻⴷⴷⵉⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ. ⴻⵊⵊ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵉ ⴷⴰⵢⴻⴽ ⴰⴷ ⴰⵢⵉ ⵃⴹⴰⵏⵜ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS40_13","020_40_13","PSA","40","13","13","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴻⴱ ⵍⵖⴰⵔ ⵉ ⴷ ⴰⵢⵉ ⵉⵇⵓⵡⵡⴰⵔⴻⵏ, ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵉⵏⵓ ⵜⵜⵎⴻⵏⵄⴻⵏⵜ ⴰⵢⵉ-ⴷⴷ, ⴷⴻⵡⵍⴻⵖ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵖ ⵄⴰⴷ ⵙ ⵎⴰⵏ ⴰⵢⴰ. ⴰⵇⴰ-ⵜⴻⵏⵜ ⴷ ⴰⵟⵟⴰⵙ ⵅ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⴻⴼⵛⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS40_14","020_40_14","PSA","40","14","14","ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵛ ⵢⴰⵔⴹⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴼⴻⴽⴽⴻⴷ, ⴰ ⵙⵉⴷⵉ, ⴷⴻⵖⵢⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS40_15","020_40_15","PSA","40","15","15","ⴻⵊⵊ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵃⵃⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵅⴰⵔⵡⴻⴹⴻⵏ, ⴰⴷ ⵙⵙⵏⵓⴼⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵊⵎⵉⵄ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⴻⴱ ⵉⵏⵓ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴻⵀⴷⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS40_16","020_40_16","PSA","40","16","16","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⴰⵎ ⵓⵅⴻⴵⴻⵚ ⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵙⴻⵏ ⵉ ⵉⴳⴳⵉⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⴰⵔⴻⵏ: “ⵀⴰ, ⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("PS40_17","020_40_17","PSA","40","17","17","ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴽ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⴰⴷ ⴰⵔⵔⴻⵏ ⵎⴻⵥⵔⵉ, ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴼⴰⵔⵃⴻⵏ. ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵉⵏⵉⵏ ⵍⴻⴱⴷⴰ: “ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS40_18","020_40_18","PSA","40","18","18","ⵏⴻⵛⵛ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵓ ⵣⴻⵍⴹⴻⵖ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵄⵇⴻⵍ ⵅⴰⴼⵉ. ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ. ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⵄⴻⵟⵟⴰⵍ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS41_1","020_41_1","PSA","41","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS41_2","020_41_2","PSA","41","2","2","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵀⵀⵎⴻⵏ ⵉ ⵓⵎⴰⵔⵅⵓ. ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⴼⴻⴽⴽ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS41_3","020_41_3","PSA","41","3","3","ⵙⵉⴷⵉ ⴳⴳⵓⵔ ⴰⴷ ⵜ ⵉⵃⴹⴰ, ⴰⴷ ⵜ ⵢⴻⵊⵊ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵡⴰⵔ ⵜ ⵜⵜⵙⴻⵍⵍⴰⵎ ⵛⴰ ⵖⴰⵔ ⵎⵉⵏ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS41_4","020_41_4","PSA","41","4","4","ⵙⵉⴷⵉ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⴰⵙⵙⵓⵜ ⵏ ⵍⴻⵀⵍⴰⵛ. ⵛⴻⴽ ⵜᵉⵜⵜⴱⴻⴷⴷⵍⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵛⵜⵓ ⵏⵏⴻⵙ ⵓⵎⵉ ⵉⵀⴻⴵⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS41_5","020_41_5","PSA","41","5","5","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⴰ ⵙⵉⴷⵉ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⵙⴳⴻⵏⴼⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵅⴹⵉⵖ ⴰⴽⵉⴷⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("PS41_6","020_41_6","PSA","41","6","6","ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅⴰⴼⵉ ⵙ ⵍⵖⴰⵔ: “ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵉⵙⴻⵎ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("PS41_7","020_41_7","PSA","41","7","7","ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵃⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵥⴰⵔ, ⵉⵙⵙⴰⵡⴰⵍ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ⵓⵍ ⵏⵏⴻⵙ ⵉⵙⵙⵎⵓⵏ ⵖⴰⵔⴻⵙ ⵍⵖⴻⵛⵛ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵙⵙⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS41_8","020_41_8","PSA","41","8","8","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵜⵜⴻⵎⵜⴰⵎⴻⵏ ⵅⴰⴼⵉ ⵊⵎⵉⵄ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵜⵜⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⴰⵢⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS41_9","020_41_9","PSA","41","9","9","ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⴰⵛⵜⴰⴱ ⴰⴱⴰⵔⵛⴰⵏ ⵓ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵡⴹⴰⵏ ⴰⵎⵎⵓ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴰⵔ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS41_10","020_41_10","PSA","41","10","10","ⵓⵍⴰ ⴷ ⴰⵔⵢⴰⵣ ⵡⵉ ⴰⴽ-ⴷ ⴷⴷⴰⵔⴻⵖ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵜⵜⵉⵇⵇⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵉⵏⵓ, ⴰⵇⴰ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵅⴰⴼⵉ ⴰⵏⵉⵔⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS41_11","020_41_11","PSA","41","11","11","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⵙⵏⴻⴽⴽⴰⵔ ⴰⵢⵉ-ⴷⴷ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵅⴻⴵⵚⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS41_12","020_41_12","PSA","41","12","12","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵓⵙⵉⵖ ⴰⵛ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⴷⵓⵇⵇⴻⵣ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS41_13","020_41_13","PSA","41","13","13","ⵓ ⵅⴰⴼⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵜⵉⵛⴻⴷ ⴰⵢⵉ ⴰⴼⵓⵙ ⵙ ⵡⴰⵡⴰⵍ ⵏⵏⴻⴽ ⵅ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵉⵏⵓ, ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⴰⵢⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS41_14","020_41_14","PSA","41","14","14","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ! ⴰⵎⵉⵏ, ⵡⴰⵀ, ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("PS42_1","020_42_1","PSA","42","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵅⴻⵎⵎⵉ ⵏ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("PS42_2","020_42_2","PSA","42","2","2","ⴰⵎ ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵖⴰⵔ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵖⴰⵔⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS42_3","020_42_3","PSA","42","3","3","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⴼⴰⴷⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ. ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⴰⴷⴼⴻⵖ, ⴰⴷ ⴱⴰⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("PS42_4","020_42_4","PSA","42","4","4","ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵏⵓ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵖⵔⵓⵎ ⵉⵏⵓ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙⵙ ⵉⵎⵓⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("PS42_5","020_42_5","PSA","42","5","5","ⵏⴻⵛⵛ ⵜⵜⵉⴷⴰⵔⴻⵖ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵙⵙⴼⴰⵔⵔⵖⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵜⵏⵓⵎⴻⵖ ⴳⴳⴻⵄⵄⴷⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵀⵉⵎⵓⵔ ⵉⵇⵇⴻⵏ, ⴰⵎ ⴳⴳⵓⵔⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴷ ⵓⵇⴰⴷⵉ, ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⵉⵜⵜⵄⴻⵢⵢⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS42_6","020_42_6","PSA","42","6","6","ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵇⴻⵏⴹⴻⴷ ⴰⵎⵎⵓ, ⵜⵀⴻⴽⴽⵡⴻⵍⴻⴷ ⴷⴰⵢⵉ? ⵔⴰⵊⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴰⴷ ⵜ ⵇⴰⴷⵉⵖ ⵄⴰⴷ ⵅ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS42_7","020_42_7","PSA","42","7","7","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵇⵏⴻⴹ ⴰⵎⵎⵓ ⴷⴰⵢⵉ. ⵅ ⵓⵢⴰ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵛⴻⴽ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵀⵉⵔⵎⵓⵏ, ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵎⵉⵚⵄⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS42_8","020_42_8","PSA","42","8","8","ⵍⵃⴻⵎⵍⴻⵜ ⵜᵉⵜⵜⵍⴰⵖⴰ ⵉ ⵍⵃⴻⵎⵍⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵣⵣⵀⵉⵔ ⵏ ⵉⵛⴻⵔⵛⵓⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵔⵔⴰ ⵍⴻⵎⵀⴰⵎⴻⴷ ⵏⵏⴻⵛ ⴷ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵛ ⴽⴽⵉⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS42_9","020_42_9","PSA","42","9","9","ⴻⵊⵊ ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⴻⵚⵚⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵙ ⵡⴰⵙⵙ, ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵢⵉⵊⵊ ⵏ ⵉⵣⵍⵉ ⴷⵉ ⴵⵉⵍⴻⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵜⵥⴰⴵⵉⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS42_10","020_42_10","PSA","42","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵛⴻⴽ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵓⴷ? ⵎⴰⵢⴻⵎⵎⵉ ⴳⴳⵓⵔⴻⵖ ⴷⴻⴳ ⵡⴻⵔⵔⵓⴹ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⴻⴵ ⵏ ⵍⴻⵄⴷⵓ?” ");
INSERT INTO rift_vpl VALUES ("PS42_11","020_42_11","PSA","42","11","11","ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵙⵙⴱⴻⵀⵜⵜⵍⴻⵏ ⴰⵢⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⵓⵜ ⵉⵏⴻⵇⵇⴻⵏ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵉⵏⵓ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵇⵇⴰⵔⴻⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("PS42_12","020_42_12","PSA","42","12","12","ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵇⴻⵏⴹⴻⴷ ⴰⵎⵎⵓ, ⵜⵀⴻⴽⴽⵡⴻⵍⴻⴷ ⴷⴰⵢⵉ? ⵔⴰⵊⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜ ⵇⴰⴷⵉⵖ ⵄⴰⴷ ⵅ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵓ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS43_1","020_43_1","PSA","43","1","1","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵓⵣⴻⵀⵀⴻⴷ 42 ⴰⵖ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵏⴷⴻⵀ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ. ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵜⵎⴻⵅⵙⵉⵡⵜ, ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⴷ ⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("PS43_2","020_43_2","PSA","43","2","2","ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⴹⴰⵔⴻⴷ? ⵎⴰⵢⴻⵎⵎⵉ ⴳⴳⵓⵔⴻⵖ ⴷⴻⴳ ⵡⴻⵔⵔⵓⴹ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⴻⴵ ⵏ ⵍⴻⵄⴷⵓ?” ");
INSERT INTO rift_vpl VALUES ("PS43_3","020_43_3","PSA","43","3","3","ⵙⴻⴽⴽ-ⴷⴷ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⴳⴻⵡⵡⴷⴻⵏⵜ, ⴰⴷ ⴰⵢⵉ ⵏⴻⴷⵀⴻⵏⵜ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS43_4","020_43_4","PSA","43","4","4","ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⴷⴷ-ⴰⵙⴻⵖ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⵍⵎⴻⴷⴱⴻⵃ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵔⵛⴻⵇ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵙ ⵍⴳⴰⵎⴱⵔⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS43_5","020_43_5","PSA","43","5","5","ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵇⴻⵏⴹⴻⴷ ⴰⵎⵎⵓ, ⵜⵀⴻⴽⴽⵡⴻⵍⴻⴷ ⴷⴰⵢⵉ? ⵔⴰⵊⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜ ⵇⴰⴷⵉⵖ ⵄⴰⴷ ⵅ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵓ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS44_1","020_44_1","PSA","44","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴰⵅⴻⵎⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("PS44_2","020_44_2","PSA","44","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵜⵜ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵖ, ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵃⴰⵊⴰⵏ ⴰⵏⴻⵖ ⵜⵜ: ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⴳⴳⵉⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS44_3","020_44_3","PSA","44","3","3","ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⵇⴰ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵍⴻⴳⵏⵓⵙ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵜⴻⵥⵥⵓⴷ ⵜⴻⵏ ⴷⴰⵢⴻⵙ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⵖⴰⵔ ⴷⵉ ⵛⵛⵓⵄⵓⴱ, ⵜⴱⴻⵣⵣⵄⴻⴷ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS44_4","020_44_4","PSA","44","4","4","ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵙⵙⵉⴼ, ⴰⵖⵉⵍ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵢⵉⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ, ⴰⵖⵉⵍ ⵏⵏⴻⵛ ⴷ ⵜⴼⴰⵡⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS44_5","020_44_5","PSA","44","5","5","ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ! ⴻⵡⵛ ⵄⴰⴷ ⵍⴻⵅⵅⵓ ⵍⵓⵎⵓⵔ ⵉ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS44_6","020_44_6","PSA","44","6","6","ⴰⴽⵉⴷⴻⴽ ⴰⴷ ⵏⴻⵖⴹⴻⵍ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵏⴻⵄⴼⴻⵙ ⵅ ⵢⵉⵏⵏⵉ ⵅⴰⵏⴻⵖ ⵉⵜⵜⴻⵎⵄⴰⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS44_7","020_44_7","PSA","44","7","7","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵜⴻⵛⵍⴻⵖ ⵅ ⵍⵇⴻⵡⵙ ⵉⵏⵓ, ⵙⵙⵉⴼ ⵉⵏⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵏⵊⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS44_8","020_44_8","PSA","44","8","8","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵏⵊⴰⵎⴻⴷ ⴰⵏⴻⵖ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵜⴻⵙⵙⴱⴻⵀⴷⵉⵍⴻⴷ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵛⴰⵔⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS44_9","020_44_9","PSA","44","9","9","ⵏⵚⴻⴱⴱⴻⵃ ⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵙⵙ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵏⵇⴰⴷⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS44_10","020_44_10","PSA","44","10","10","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵏⴻⵖ, ⵜⴻⵙⵙⴱⴻⵀⴷⴰⵍⴻⴷ ⴰⵏⴻⵖ, ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴼⴼⵉⵖⴻⴷ ⵛⴰ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS44_11","020_44_11","PSA","44","11","11","ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⴰⵏⴻⵖ ⵏⴻⵜⵜⵔⴰⴽⴽⵡⴰⵍ ⵣⵣⴰⵜ ⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵜⵜⴽⴻⵛⵛⴹⴻⵏ ⵎⵉⵏ ⵜⵜⴻⵅⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS44_12","020_44_12","PSA","44","12","12","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵏⴻⵖ ⴰⵎ ⵡⵓⴵⵉ ⵉ ⵎⴰⵛⵛⴰ, ⵜⴻⵣⵣⵓⵣⴰⵔⴻⴷ ⴰⵏⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS44_13","020_44_13","PSA","44","13","13","ⵛⴻⴽ ⵜⴻⵣⵣⵏⵓⵣⵉⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵡⴰⵍⵓ, ⴷⴻⴳ ⵓⵣⵣⴻⵏⵣⵉ ⵏⵙⴻⵏ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴱⵓ ⵍⴻⴼⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS44_14","020_44_14","PSA","44","14","14","ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⵏⴻⵖ ⴷ ⵍⵃⴻⴳⵔⴰ ⵉ ⵡⴰⵊⵊⴰⵔⴻⵏ ⵏⵏⴻⵖ, ⴷ ⴰⵙⵜⴻⵀⵣⵉ ⴷ ⵓⴱⴻⵀⴷⴻⵍ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵜⵜⴻⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS44_15","020_44_15","PSA","44","15","15","ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⵏⴻⵖ ⴷ ⴰⵎⴻⴷⵢⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵀⴻⵣⵣⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵊⴰⵔ ⵛⵛⵓⵄⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS44_16","020_44_16","PSA","44","16","16","ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵔ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵣⵣⴰⵜⵉ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵍⴻⵃⵢⴰ ⵉⴷⵍⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS44_17","020_44_17","PSA","44","17","17","ⵣⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⵔⴰⵏ, ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵄⴷⵓ ⵓ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⵏⵜⴰⵇⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS44_18","020_44_18","PSA","44","18","18","ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⴽⴽⴰ ⵅⴰⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⵜⵜⵓ, ⵡⴰⵔ ⵏⵖⴻⵛⵛ ⵛⴰ ⴷⵉ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS44_19","020_44_19","PSA","44","19","19","ⵓⵍ ⵏⵏⴻⵖ ⵡⴰⵔ ⵉⴷⵡⵉⵍ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵖ ⵡⴰⵔ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵛⴰ ⵣⴻⴳ ⵓⵎⴻⵙⵔⵓⵇ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS44_20","020_44_20","PSA","44","20","20","ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⵜⵍⴻⴱⵣⴻⴷ ⴰⵏⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵜⴻⴷⵍⵉⴷ ⴰⵏⴻⵖ ⵙ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS44_21","020_44_21","PSA","44","21","21","ⵎⵍⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⵓ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵏⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵖⵔⵉⴱ, ");
INSERT INTO rift_vpl VALUES ("PS44_22","020_44_22","PSA","44","22","22","ⵎⴰ ⵉⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ? ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⴳⴳⴻⴱ ⵅ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("PS44_23","020_44_23","PSA","44","23","23","ⵎⴰⵖⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ ⵏⴻⵇⵇⴻⵏ ⴰⵏⴻⵖ ⴽⵓⵍ ⴰⵙⵙ, ⴰⵇⴰ ⵃⴻⵙⵙⴱⴻⵏ ⴰⵏⴻⵖ ⴰⵎ ⵡⵓⴵⵉ ⵏ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("PS44_24","020_44_24","PSA","44","24","24","ⴼⴰⵇ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵟⵟⵚⴻⴷ, ⵙⵉⴷⵉ ⵉⵏⵓ? ⴼⴰⵇ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵏⴻⵟⵟⴰⵔ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("PS44_25","020_44_25","PSA","44","25","25","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⴼⴼⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⵜᵉⵜⵜⵓⴷ ⵍⴻⵖⴱⴻⵏ ⴷ ⴷⴷⴻⴵ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("PS44_26","020_44_26","PSA","44","26","26","ⵎⴰⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⵉⵜⵜⴰⴹⴰⵔ ⵖⴰⵔ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵖ ⵉⵍⴻⵚⵚⴻⵇ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS44_27","020_44_27","PSA","44","27","27","ⴽⴽⴰⵔ, ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⴼⵓⵙ, ⴼⴷⵉ ⵅⴰⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS45_1","020_45_1","PSA","45","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵜⵍⵉⵍⵍⵉⵛⵉⵏ’. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴰⵅⴻⵎⵎⵉ. ⵉⵣⵍⵉ ⵏ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS45_2","020_45_2","PSA","45","2","2","ⵣⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵉⴷⴷⵓⵇⵇⴻⵣ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵇⵇⴰⵔⴻⵖ ⵉ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵙⵙⵡⴻⵊⴷⴻⵖ, ⵉⵍⴻⵙ ⵉⵏⵓ ⴷ ⵍⴻⵇⵍⴻⵎ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵉⵔ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS45_3","020_45_3","PSA","45","3","3","“ⵛⴻⴽ ⵜⴻⵛⵏⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵍⵅⴰⴹⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⴵⴻⵄ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ, ⵅ ⵓⵢⴰ ⵉⴱⴰⵔⴻⴽ ⵉ ⵛⴻⴽ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS45_4","020_45_4","PSA","45","4","4","ⴱⵢⴻⵙ ⵙⵙⵉⴼ ⵅ ⵜⵎⴻⵙⵙⴰⴹⵜ ⵏⵏⴻⵛ, ⴰ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵛ ⴷ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS45_5","020_45_5","PSA","45","5","5","ⵡⴰⵀ, ⵍⵄⴻⵣⵣ ⵏⵏⴻⵛ! ⵉⵍⵉ ⵜⴼⴻⵍⵃⴻⴷ, ⵏⴷⴻⵀ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵉⴷⴻⵜⵜ, ⴹⵉⴷⴷ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ. ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS45_6","020_45_6","PSA","45","6","6","ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵛ ⵇⴻⴹⵄⴻⵏⵜ, - ⵡⴰⵀ, ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵡⴹⴰⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵛ - ⵛⵓⵇⴻⵏⵜ ⵓⵍ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS45_7","020_45_7","PSA","45","7","7","ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵛ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ-ⵜ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵣⴻⴵⴰⴹ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⴰⴹ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS45_8","020_45_8","PSA","45","8","8","ⵛⴻⴽ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵓ ⵜⵛⴰⵔⵔⵀⴻⴷ ⵍⵖⴰⵔ. ⵅ ⵓⵢⴰ ⵉ ⵛⴻⴽ ⵉⴷⵀⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⵉⵡⴰ ⵉ ⵉⵄⵛⵉⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS45_9","020_45_9","PSA","45","9","9","ⵎⴰⵔⵔⴰ ⵍⴻⵄⴱⴰⵢⴰⵜ ⵏⵏⴻⵛ ⴰⵎ ⵎⵉⵔⵔⵓ ⴷ ⵡⴻⵛⴼⵉⵍ ⴷ ⵍⵇⴰⵔⴼⴰ, ⵣⵉ ⵍⴻⵇⵚⵓⵔ ⵏ ⵍⵄⴰⵊ ⵙⵙⴼⴰⵔⵔⴰⵃⴻⵏ ⵛⴻⴽ ⵙ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⴳⴰⵎⴱⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("PS45_10","020_45_10","PSA","45","10","10","ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ-ⵜⴻⵏⵜ ⵊⴰⵔ ⵜⵉⵏⴻⵡⵊⵉⵡⵉⵏ ⵏⵏⴻⵛ ⵉⵡⴻⵇⵇⴰⵔⴻⵏ, ⵜⴰⵙⵍⵉⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⴱⴻⴷⴷ ⴰⵛ ⵅ ⵓⴼⵓⵙⵉ, ⵙ ⵡⴻⵔⵔⵓⴹ ⵣⴻⴳ ⵡⵓⵔⴻⵖ ⵉⵖⵍⴰⵏ ⵇⴰⵄ ⵣⵉ ⵓⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("PS45_11","020_45_11","PSA","45","11","11","ⵙⴻⵍ, ⴰ ⵢⴻⴵⵉ, ⵅⵣⴰⵔ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵎ! ⵜⵜⵓ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵎ! ");
INSERT INTO rift_vpl VALUES ("PS45_12","020_45_12","PSA","45","12","12","ⵅⴻⵏⵏⵉ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵎⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵡⴰⵥⵔⵉ ⵏⵏⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉ ⵏⵏⴻⵎ! ⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PS45_13","020_45_13","PSA","45","13","13","ⵢⴻⴵⵉⵙ ⵏ ⵚⵓⵔ ⵙ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ, ⵡⴰⵀ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⴰⵔⵣⵓⵏ ⴰⴷ ⵅⴰⵎ ⴰⵔⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS45_14","020_45_14","PSA","45","14","14","ⵢⴻⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ-ⵜⵜ ⴷ ⴰⵄⵓⴵⵉ ⵎⴰⵔⵔⴰ ⴷⴰⵅⴻⵍ, ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⵉ ⵣⴻⴳ ⵓⴼⵉⵍⵓ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS45_15","020_45_15","PSA","45","15","15","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ. ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵜⵉⵏⵏⵉ ⵜⵜ ⵉⴹⴻⴼⴼⴰⵔⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⵏⵏⵉ ⴷⴷ ⵖⴰⵔⴻⴽ ⵜⵜⵡⴰⵡⵢⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS45_16","020_45_16","PSA","45","16","16","ⴰⵇⴰ ⵜⵜⵡⴰⵡⵢⴻⵏⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵡⴰⵔⵛⴻⵇ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴰⴷⴼⴻⵏⵜ ⵖⴰⵔ ⵍⴻⵇⵚⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS45_17","020_45_17","PSA","45","17","17","ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS45_18","020_45_18","PSA","45","18","18","ⵏⴻⵛⵛ ⴰⴷ ⵉⴷⴰⵔⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⴽⵓⵍ ⵊⵊⵉⵍ ⴷ ⴽⵓⵍ ⵊⵊⵉⵍ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵅ ⵓⵢⴰ, ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("PS46_1","020_46_1","PSA","46","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⵙ ⵍⵀⴰⵔⴱⴰⵜ ⵉⵜⵜⵡⴰⵔⵔⵉⴳⵍⴰⵏ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ. ⵉⵣⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS46_2","020_46_2","PSA","46","2","2","ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷ ⵊⵊⴻⵀⴷ ⵉ ⵏⴻⵛⵛⵉⵏ. ⴰⵇⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵉⵜⵜⵉⵛ ⴰⴼⵓⵙ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS46_3","020_46_3","PSA","46","3","3","ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵡⴰⵅⵅⴰ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵍ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⵡⴹⴰⵏ ⵉⴷⵓⵔⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("PS46_4","020_46_4","PSA","46","4","4","ⴰⴷ ⵀⴰⵊⴰⵏⵜ ⵍⵃⴻⵎⵍⴰⵜ ⵏⵏⴻⵙ, ⴰⴷ ⴳⴳⴻⵏⵜ ⴰⴽⵓⴼⴼⵓ, ⴰⴷ ⵏⵀⴻⵣⵣⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵙ ⵓⵏⵏⴻⵇⵍⴻⴱ ⵏⵏⴻⵙ! ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS46_5","020_46_5","PSA","46","5","5","ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵉⵖⵣⴰⵔ ⴰⴷ ⵙⵙⴼⴰⵔⵔⵃⴻⵏⵜ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS46_6","020_46_6","PSA","46","6","6","ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⴼⵓⵙ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⵙⵙⵉⵊ ⵜⵓⴼⴼⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PS46_7","020_46_7","PSA","46","7","7","ⵍⴻⴳⵏⵓⵙ ⵎⵓⵣⵣⴰⵔⴻⵏ, ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏⵀⴻⵣⵣⴻⵏⵜ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ, ⵜⴰⵎⵎⵓⵔⵜ ⴰⵇⴰ ⵜⴻⴼⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PS46_8","020_46_8","PSA","46","8","8","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵍⴱⵓⵔⵊ ⵏⵏⴻⵖ ⵢⵓⵄⵍⴰⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS46_9","020_46_9","PSA","46","9","9","ⴰⵙⴻⵎ-ⴷⴷ, ⵅⵣⴰⵔⴻⵎ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⵉ ⵉⴳⴳⵉⵏ ⴰⵏⴻⵅⵍⵉⵄ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS46_10","020_46_10","PSA","46","10","10","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷⴰ ⵉⵎⴻⵏⵖⴰⵏ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵥ ⵍⵇⴻⵡⵙ, ⵉⵛⵛⴰⵜ ⵍⴰⵏⵙⴰ ⴷⵉ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ, ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉⵙⵙⴻⵛⵎⴰⴹ ⵉ-ⵜⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PS46_11","020_46_11","PSA","46","11","11","ⵙⴱⴻⴷⴷ, ⵙⵏⴻⵎ ⵉⵍⵍⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS46_12","020_46_12","PSA","46","12","12","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ ⵉ ⵏⴻⵛⵛⵉⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS47_1","020_47_1","PSA","47","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴰⵣⴻⵀⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS47_2","020_47_2","PSA","47","2","2","ⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵡⵜⴻⵎ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ, ⴷⵓⵇⵇⵣⴻⵎ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS47_3","020_47_3","PSA","47","3","3","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵇⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS47_4","020_47_4","PSA","47","4","4","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⴹⴰⵔⴰ ⴰⵏⴻⵖ ⵍⴻⴳⵏⵓⵙ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵛⵛⵓⵄⵓⴱ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS47_5","020_47_5","PSA","47","5","5","ⵏⴻⵜⵜⴰ ⵉⴼⴰⵔⵔⴻⵣ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵖ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵜⴻⵏⵏⵉ ⴷ ⴰⴼⴻⵢⵢⴻⵛ ⵏ ⵢⴰⵄⵇⵓⴱ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS47_6","020_47_6","PSA","47","6","6","ⴰⵔⴻⴱⴱⵉ ⵢⵓⵍⵉ ⵙⴻⵏⵏⴻⵊ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵙⵉⴷⵉ, ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS47_7","020_47_7","PSA","47","7","7","ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵣⴻⵀⵀⴷⴻⵎ! ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵣⴻⵀⵀⴷⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("PS47_8","020_47_8","PSA","47","8","8","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵣⴻⵀⵀⴷⴻⵎ ⴰⵢⴰ ⵉ ⵓⵅⴻⵎⵎⵉ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS47_9","020_47_9","PSA","47","9","9","ⴰⵔⴻⴱⴱⵉ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵍⴻⴳⵏⵓⵙ, ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS47_10","020_47_10","PSA","47","10","10","ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵎⴰⵖⴰⵔ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵢⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS48_1","020_48_1","PSA","48","1","1","ⵉⵣⵍⵉ, ⴰⵣⴻⵀⵀⴻⴷ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("PS48_2","020_48_2","PSA","48","2","2","ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⴷⴰⵃⴻⴵⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵅ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS48_3","020_48_3","PSA","48","3","3","ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴷ ⵍⴻⵎⵍⴰⵃⴻⵜ, ⴰⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⴰⵇⴰ-ⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS48_4","020_48_4","PSA","48","4","4","ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS48_5","020_48_5","PSA","48","5","5","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵎⵓⵏⴻⵏ, ⴰⵇⴰ ⴼⴼⵖⴻⵏ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("PS48_6","020_48_6","PSA","48","6","6","ⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵏ, ⵜⴱⴻⵀⵜⴻⵏ, ⴰⵇⴰ ⵏⵏⵊⴻⵔⴼⴰⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS48_7","020_48_7","PSA","48","7","7","ⴷⵉⵏⵏⵉ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜⴻⵏ ⵜⴰⵔⵊⵉⵊⵉⵜ, ⴰⵎ ⵍⴻⵃⵔⵉⵇ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜᵉⵜⵜⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("PS48_8","020_48_8","PSA","48","8","8","ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵛⵛⴰⵔⵇ ⵜᵉⵜⵜⴰⵔⴻⵥⵥⵉⴷ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("PS48_9","020_48_9","PSA","48","9","9","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵜ ⵏⴻⵙⵍⴰ, ⴰⵎⵎⵓ ⵉ ⵜⵜ ⵏⴻⵜⵡⴰⵍⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS48_10","020_48_10","PSA","48","10","10","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵏⵉⴷⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS48_11","020_48_11","PSA","48","11","11","ⴰⵎ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵎⵓ ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵓⵍⴰ ⴷ ⵛⵛⴰⵏ ⵏⵏⴻⵛ ⴰⵍ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⵉⵛⵛⵓⵔ ⵙ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS48_12","020_48_12","PSA","48","12","12","ⴻⵊⵊ ⴰⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵉⴼⴰⵔⵃ, ⵊⵊⴻⵎ ⵢⴻⵙⵙⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴰⵔⴻⵛⵇⴻⵏⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS48_13","020_48_13","PSA","48","13","13","ⴽⴽⴻⵎ ⵅ ⵚⵉⵀⵢⵓⵏ, ⵏⵏⴹⴻⵎ ⴰⵙ-ⴷⴷ, ⵃⴻⵙⴱⴻⵎ ⵚⵚⵓⵎⵄⴰⵜ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PS48_14","020_48_14","PSA","48","14","14","ⴳⴳⴻⵎ ⵓⵍ ⵏⵡⴻⵎ ⵅ ⵍⵃⵉⴹ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵅⵣⴰⵔⴻⵎ ⵎⵍⵉⵃ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵜⵜⵄⴰⵡⴷⴻⴷ ⵉ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS48_15","020_48_15","PSA","48","15","15","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS49_1","020_49_1","PSA","49","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴰⵣⴻⵀⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS49_2","020_49_2","PSA","49","2","2","ⵙⵍⴻⵎ ⵉ ⵓⵢⴰ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵙⵃⴻⵙⵙⴻⵎ ⵎⴰⵔⵔⴰ, ⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("PS49_3","020_49_3","PSA","49","3","3","ⴰⵎ ⵜⴰⵔⵡⴰ ⵏ ⴰⴷⴰⵎ, ⴰⵎ ⵜⴰⵔⵡⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵉⵎⴻⵣⵍⴰⴹ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("PS49_4","020_49_4","PSA","49","4","4","ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵉⵙⵙⴰⵡⴰⵍ ⵜⵉⵖⵉⵜ, ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ ⵉⵏⵓ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS49_5","020_49_5","PSA","49","5","5","ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⴰⵎⴻⵣⵣⵓⵖ ⵉⵏⵓ ⵉ ⵡⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ, ⴰⴷ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵜⵃⴰⵊⵉⵜ ⵉⵏⵓ ⵏ ⵜⵡⴰⴼⵉⵜ ⵖⴰⵔ ⵜⵉⵔⴰⵔⵜ ⵏ ⵍⴳⴰⵎⴱⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS49_6","020_49_6","PSA","49","6","6","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⴳⴳⵯⴻⴷⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵅⵎⵉ ⴷⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴻⵏⵏⴻⴹ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⴷⵉ ⵜⵉⵔⵉ ⵉⵏⵓ.    ");
INSERT INTO rift_vpl VALUES ("PS49_7","020_49_7","PSA","49","7","7","ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵏⵙⴻⵏ, ⵜⵜⴼⴻⵢⵢⵛⴻⵏ ⵙ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS49_8","020_49_8","PSA","49","8","8","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵜⴰⵡⵎⴰⵜ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴷⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴷⴷⴻⵢⵢⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS49_9","020_49_9","PSA","49","9","9","ⵜⵜⴰⵎⴰⵏ ⵏ ⵡⴻⵚⵍⴰⵃ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵜⵉⵖⵍⴰ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS49_10","020_49_10","PSA","49","10","10","ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⴽⵉⵛⵛⵓ. ");
INSERT INTO rift_vpl VALUES ("PS49_11","020_49_11","PSA","49","11","11","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵍⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵎⵎⵓⵜⴻⵏ, ⵓⵍⴰ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⴷ ⵓⵇⴻⴼⴼⵓⵃ ⴰⴷ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⴷ ⵊⵊⴻⵏ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵏⵙⴻⵏ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS49_12","020_49_12","PSA","49","12","12","ⴰⵅⴰⵔⵔⴻⵚ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ ⴰⵇⴰ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ⵡⴰⵅⵅⴰ ⵓⵍⴰ ⴷ ⵜⵉⵎⵎⵓⵔⴰ ⴳⴳⵉⵏ ⴰⵙⴻⵏⵜ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS49_13","020_49_13","PSA","49","13","13","ⴱⵏⴰⴷⴻⵎ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵛⵛⴰⵏ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ, ⵏⴻⵜⵜⴰ ⴰⵎ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS49_14","020_49_14","PSA","49","14","14","ⵡⴰ ⴷ ⴰⴱⵔⵉⴷ ⵉ ⵖⴰⵔⵙⴻⵏ, ⵎⵉⵏ ⵅⴻⴼ ⵜⵜⵙⴻⵏⵏⴰⴷⴻⵏ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS49_15","020_49_15","PSA","49","15","15","ⴰⵎ ⵡⵓⴵⵉ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵍⵎⴻⵡⵜ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵡⴻⵙ. ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴻⴽⵎⴻⵏ ⵅ ⵚⵚⴱⴻⵃ, ⴰⴷⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉ ⵍⵖⴻⵛⵛ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS49_16","020_49_16","PSA","49","16","16","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⴼⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴰⵅⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵢⴰⵡⵉ ⴰⴽⵉⵙ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS49_17","020_49_17","PSA","49","17","17","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴷⵡⴻⵍ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵅⵎⵉ ⵉ ⵖⴰ ⵢⴰⵔⵏⵉ ⵓⵛⵓⵡⵡⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS49_18","020_49_18","PSA","49","18","18","ⵎⴰⵖⴰⵔ ⴷⵉ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵉⴽⴻⵙⵙⵉ ⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰⵛⵓⵡⵡⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵀⴻⴽⴽⵡⵉ ⴰⴽⵉⴷⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS49_19","020_49_19","PSA","49","19","19","ⵡⴰⵅⵅⴰ ⵉⴱⴰⵔⴻⴽ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵎⴰⵖⴰⵔ ⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS49_20","020_49_20","PSA","49","20","20","ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⴻⴹ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵊⵊⵉⵍ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵏⵏⵉ ⵡⴰⵔ ⵥⴰⵔⵔⴻⵏ ⵜⴰⴼⴰⵡⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS49_21","020_49_21","PSA","49","21","21","ⴱⵏⴰⴷⴻⵎ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵛⵛⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴼⴻⵀⵀⴻⵎ, ⵏⴻⵜⵜⴰ ⴰⵎ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵉⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS50_1","020_50_1","PSA","50","1","1","ⵉⵊⵊ ⵏ ⵓⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵙⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵍⴰⵖⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵉ ⵎⴰⵏⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⵍ ⵎⴰⵏⵉ ⵜⴻⵖⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS50_2","020_50_2","PSA","50","2","2","ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⴰⵥⵔⵉ ⵉⴽⴻⵎⵎⵍⴻⵏ, ⵉⵜⵜⴱⴰⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵉⵙⵙⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("PS50_3","020_50_3","PSA","50","3","3","ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵡⴰⵔ ⵉⵙⵙⴻⵖⴷ ⵛⴰ. ⵜⵉⵎⴻⵙⵙⵉ ⵣⵣⴰⵜⴻⵙ ⴰⴷ ⵜⴻⵛⵛ, ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⴰⴷ ⵜⵙⵓⴹ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS50_4","020_50_4","PSA","50","4","4","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉ ⵉⵊⴻⵏⵡⴰⵏ ⵙⴻⵏⵏⴻⵊ, ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("PS50_5","020_50_5","PSA","50","5","5","“ⵙⵎⵓⵏⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵉⵏⵓ, ⵉⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵄⴰⵀⴷ ⵙ ⵜⵖⴰⵔⵚⵜ.” ");
INSERT INTO rift_vpl VALUES ("PS50_6","020_50_6","PSA","50","6","6","ⵉⵊⴻⵏⵡⴰⵏ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷ ⵍⵇⴰⴹⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS50_7","020_50_7","PSA","50","7","7","“ⵙⴻⵍ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ, ⵉⵙⵔⴰⵉⵍ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵀⴷⴻⵖ ⴹⵉⴷⴷ ⵏⵏⴻⵛ: ⴰⵇⴰ ⵏⴻⵛⵛ, ⴰⵔⴻⴱⴱⵉ, ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("PS50_8","020_50_8","PSA","50","8","8","ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵜⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵡⴻⴱⴱⵅⴻⵖ, ⵎⴰⵖⴰⵔ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("PS50_9","020_50_9","PSA","50","9","9","ⵡⴰⵔ ⴽⴻⵙⵙⵉⵖ ⵛⴰ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵉⵖⴰⵢⴹⴻⵏ ⵣⵉ ⵜⴻⵇⵡⵉⵔⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS50_10","020_50_10","PSA","50","10","10","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔ ⵏ ⵡⴻⵣⵖⴰⵔ, ⴰⵇⴰ ⵉⵏⵓ, ⵍⵎⴰⵍ ⵅ ⵡⴰⵍⴻⴼ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS50_11","020_50_11","PSA","50","11","11","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⵇⴰ-ⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS50_12","020_50_12","PSA","50","12","12","ⵎⵍⵉ ⵜⵓⵖⴰ ⴷⴰⵢⵉ ⵍⴰⵥ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ ⵇⵇⴰⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵉⵏⵓ ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS50_13","020_50_13","PSA","50","13","13","ⵎⴰ ⴰⴷ ⵛⵛⴻⵖ ⵅⴻⵏⵏⵉ ⴰⵢⵙⵓⵎ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ, ⵏⵉⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS50_14","020_50_14","PSA","50","14","14","ⴰⵡⵉ-ⴷⴷ ⵉ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ, ⴽⴻⵎⵎⴻⵍ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵛ ⵉ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS50_15","020_50_15","PSA","50","15","15","ⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓⵛⴰ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⴳⴳⴻⴷ ⵛⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("PS50_16","020_50_16","PSA","50","16","16","ⵎⴰⵛⴰ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴱⴰⵔⵔⵃⴻⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⴻⴳⴳⵉⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS50_17","020_50_17","PSA","50","17","17","ⵓⵎⵉ ⵜⵛⴰⵔⵔⵀⴻⴷ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵉⵏⵓ ⵓ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("PS50_18","020_50_18","PSA","50","18","18","ⵎⴰⵍⴰ ⵜⴻⵥⵔⵉⴹ ⵉⵊⵊ ⵏ ⵓⵅⴻⵡⵡⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⵓⵔⴻⴷ ⴰⴽⵉⴷⴻⵙ, ⵜᵉⵜⵜⵚⵓⵔⵉⴷ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS50_19","020_50_19","PSA","50","19","19","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⵉ-ⵜ ⵉ ⵍⵖⴰⵔ, ⵉⵍⴻⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵡⴻⵛⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS50_20","020_50_20","PSA","50","20","20","ⵜⴻⵜⵜⵖⵉⵎⵉⴷ ⴷⵉⵏⵏⵉ, ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵅ ⵓⵎⴰⵛ, ⵜⴻⵙⵙⴻⴼⴷⴰⵃⴻⴹ ⵣⵉ ⵎⵎⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS50_21","020_50_21","PSA","50","21","21","ⴰⵢⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵓ ⵏⴻⵛⵛ ⵙⵙⴻⵖⴷⵉⵖ. ⵜⵜⵖⵉⵍ ⴰⵛ, ⴰⵇⴰ ⴰⵢⵉ ⴰⵎ ⵛⴻⴽ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵡⴻⴱⴱⵅⴻⵖ, ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS50_22","020_50_22","PSA","50","22","22","ⴼⵀⴻⵎ ⴰⵢⴰ ⵅⴻⵏⵏⵉ, ⴰ ⵛⴻⴽ ⵉ ⵉⵜⵜⵓⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵜⵎⴻⵣⵣⵇⴻⵖ ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵓⴼⴻⴽⴽⵉ.” ");
INSERT INTO rift_vpl VALUES ("PS50_23","020_50_23","PSA","50","23","23","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵇⴰⴷⵉ, ⵉⵜⵜⴻⴳⴳ ⴰⵢⵉ ⵛⵛⴰⵏ ⵓ ⵉⵙⵙⴻⵡⵊⴰⴷ ⴰⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS51_1","020_51_1","PSA","51","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS51_2","020_51_2","PSA","51","2","2","ⴰⵍⴰⵎⵉ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵏⴰⴱⵉ ⵏⴰⵜⴰⵏ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⴷⴰⵡⵓⴷ ⵅ ⴱⴰⵜ-ⵛⴰⴱⴰⵄ.    ");
INSERT INTO rift_vpl VALUES ("PS51_3","020_51_3","PSA","51","3","3","ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ⵎⵙⴻⵃ ⵉⵅⴻⵟⵟⴰⵏ ⵉⵏⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⴼⴻⵢⵢⴻⴹ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS51_4","020_51_4","PSA","51","4","4","ⵙⵙⵉⵔⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ ⵣⵣⴰⵢⵉ ⵎⴰⵔⵔⴰ, ⵙⵉⵣⴷⴻⴳ ⴰⵢⵉ ⵣⵉ ⴷⴷⴻⵏⴱ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS51_5","020_51_5","PSA","51","5","5","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵉⵅⴻⵟⵟⴰⵏ ⵉⵏⵓ, ⴷⴷⴻⵏⴱ ⵉⵏⵓ ⵍⴻⴱⴷⴰ ⵉⴱⴻⴷⴷ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS51_6","020_51_6","PSA","51","6","6","ⴰⴽⵉⴷⴻⴽ, ⴰⴽⵉⴷⴻⴽ ⵡⴰⵀⴰ ⵉ ⵅⴹⵉⵖ, ⴳⴳⵉⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵛⴻⴽ ⵜⵙⴻⴳⴳⴷⴻⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⵜⴻⵚⴼⵉⴷ ⴷⵉ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS51_7","020_51_7","PSA","51","7","7","ⵅⵣⴰⵔ, ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵖ-ⴷⴷ ⴷⵉ ⴷⴷⵏⵓⴱ, ⴷⵉ ⴷⴷⵏⵓⴱ ⵜⴻⴽⵙⵉ ⴰⵢⵉ ⵢⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("PS51_8","020_51_8","PSA","51","8","8","ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⴷⴰⵅⴻⵍ, ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵜⴻⵙⵙⵛⴰⵏⴻⴷ ⴰⵢⵉ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PS51_9","020_51_9","PSA","51","9","9","ⴽⵙⵉ ⵅⴰⴼⵉ ⴷⴷⵏⵓⴱ ⵙ ⵜⵄⴻⵍⴵⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵇⵇⵓⵔⴻⵖ, ⵙⵉⵔⴷ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵅ ⵡⴻⴷⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS51_10","020_51_10","PSA","51","10","10","ⴰⵔⵔ ⴰⵢⵉ ⴰⴷ ⵙⵍⴻⵖ ⴰⵔⵛⵓⵇ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵃⵉⵎⴰ ⵉⵖⵙⴰⵏ ⵏⵏⵉ ⵜⵍⴻⴱⵣⴻⴷ ⵛⴻⴽ, ⴰⴷ ⵛⴻⴹⵀⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS51_11","020_51_11","PSA","51","11","11","ⵙⵏⵓⴼⴼⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⴷⴷⵏⵓⴱ ⵉⵏⵓ, ⵎⵙⴻⵃ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS51_12","020_51_12","PSA","51","12","12","ⵅⵍⴻⵇ-ⴷⴷ ⴷⴰⵢⵉ ⵓⵍ ⵉⵣⴷⵉⴳ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵊⴻⴷⴷⴻⴷ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⵉⵎⴻⵜⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS51_13","020_51_13","PSA","51","13","13","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵏⴻⵟⵟⴰⵔ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜⴻⴽⴽⴻⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS51_14","020_51_14","PSA","51","14","14","ⴻⵡⵛ ⴰⵢⵉ ⵄⴰⵡⴻⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⴰⵎⵙⴻⵄⵄⴰⴼ ⵉ ⴽⵉⴷⵉ ⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS51_15","020_51_15","PSA","51","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵖⴰⵔⴻⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⵉ ⵢⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵄⴻⴷⴷⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵉⵎⴻⴷⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PS51_16","020_51_16","PSA","51","16","16","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵓⵎⴰⵔⵡⴰⵙ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵍⴻⵡⵍⵉⵡ ⵉⵍⴻⵙ ⵉⵏⵓ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS51_17","020_51_17","PSA","51","17","17","ⴰⵔⵣⴻⵎ ⴰⵢⵉ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵙ ⵛⵛⴰⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS51_18","020_51_18","PSA","51","18","18","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⴽ ⵜⴻⵛⵇⵉ ⵜⵖⴰⵔⵚⵜ, ⵉⵍⵉ ⵡⵛⵉⵖ ⴰⵛ ⵜⵜ, ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵡⴰⵔ ⴷ ⴰⵛ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⵅ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS51_19","020_51_19","PSA","51","19","19","ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵢⴰⵔⴻⵥ, ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵉⴷⴷⴻⵣ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⵉⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("PS51_20","020_51_20","PSA","51","20","20","ⴻⴳⴳ ⵍⵅⴰⵔ ⵉ ⵚⵉⵀⵢⵓⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⴹⴰ ⵏⵏⴻⵛ, ⴱⵏⴰ ⵍⴻⵃⵢⵓⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("PS51_21","020_51_21","PSA","51","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⴹⵉⴷ ⴷⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴷⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉⴽⴻⵎⵎⵍⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS52_1","020_52_1","PSA","52","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵅⴻⵎⵎⵉ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS52_2","020_52_2","PSA","52","2","2","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴷⵓⵡⴰⵄ, ⵣⵉ ⵉⴷⵓⵎ, ⵉⵅⴻⴱⴱⴰⵔ ⵛⴰⵡⵓⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⵉⵎⴰⵍⵉⴽ.” ");
INSERT INTO rift_vpl VALUES ("PS52_3","020_52_3","PSA","52","3","3","ⵎⴰⵎⵎⴻⵛ ⵜⴼⴻⵢⵢⵛⴻⴷ ⵣⵉ ⵜⵄⴻⴼⴼⴰⵏⵜ, ⴰ ⵊⵊⵉⵀⴻⵍ? ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜᵉⵜⵜⴻⴽⴽ ⴰⵙⵙ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS52_4","020_52_4","PSA","52","4","4","ⵉⵍⴻⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵍⵖⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⵎⵓⵙ ⵉⵇⴻⴹⵄⴻⵏ ⵉ ⵓⵃⴻⴼⴼⵉ ⵢⵉⵡⵢⵉ ⴷⵔⵓⵛⵜ ⵙ ⵍⵖⴻⴼⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS52_5","020_52_5","PSA","52","5","5","ⵛⴻⴽ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵟⵟⴰⵙ ⵅ ⵜⵚⴻⴱⵃⴰⵏⵜ, ⵍⵀⴰⵔⴷ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴽⵜⴰⵔ ⵅ ⵍⵀⴰⵔⴷ ⵏ ⵜⵙⴻⴳⴷⴰ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS52_6","020_52_6","PSA","52","6","6","ⵛⴻⴽ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⵡⴰⵍⴻⵏ ⵉⵜⵜⴰⴽⴽⵯⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵍⴻⵙ ⵉⵛⵛⵓⵔ ⵙ ⵡⴻⵛⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS52_7","020_52_7","PSA","52","7","7","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉ ⵍⴻⴱⴷⴰ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵟⵟⴻⴼ, ⴰⴷ ⵛⴻⴽ ⵉⴽⴽⴻⵙ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵇⵍⴻⵄ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵛ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS52_8","020_52_8","PSA","52","8","8","ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ. ⴰⴷ ⵅⴰⵙ ⴹⴻⵃⵛⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ");
INSERT INTO rift_vpl VALUES ("PS52_9","020_52_9","PSA","52","9","9","“ⵅⵣⴰⵔ ⴰⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵉⴳⴳⵉ ⴰⵔⴻⴱⴱⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵛⴻⵍ ⵅ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵜⵓⵖⴰ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ ⵙ ⵟⵟⴱⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉⵖⴻⵛⵛⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("PS52_10","020_52_10","PSA","52","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵣⵉⵜⵓⵏⵜ ⵜⴰⵣⴻⵢⵣⴰⵡⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ ⵉ ⵖⴰ ⵜⵜⵉⵇⵇⴻⵖ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS52_11","020_52_11","PSA","52","11","11","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜ. ⴰⴷ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS53_1","020_53_1","PSA","53","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵉⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ’. ⴰⵅⴻⵎⵎⵉ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS53_2","020_53_2","PSA","53","2","2","ⴰⴱⵓⵀⴰⵍⵉ ⵉⵏⵏⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: “ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⴰⵔⴻⴱⴱⵉ!” ⵏⵉⵜⵏⵉ ⵜⵜⴰⵔⴻⴷⴷⴵⴻⵏ, ⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵏⵏⵄⵉ ⵏ ⵍⵖⴻⵛⵛ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS53_3","020_53_3","PSA","53","3","3","ⴰⵔⴻⴱⴱⵉ ⵉⵅⴻⵣⵣⴰⵔ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵎⴰ ⴷⵉⵏ ⵃⴻⴷ ⵖⴰⵔⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵉⵊⵊⴻⵏ ⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS53_4","020_53_4","PSA","53","4","4","ⵎⴰⵔⵔⴰ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("PS53_5","020_53_5","PSA","53","5","5","ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵓⵙⵙⵏⴰ, ⵉⵏⵏⵉ ⵉⵜⵜᵉⵜⵜⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵅⵎⵉ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵖⵔⵓⵎ? ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵍⴰⵖⴰⵏ ⵅ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS53_6","020_53_6","PSA","53","6","6","ⴰⵇⴰ ⴷⵉⵏ ⵉ ⵅⴰⵙⴻⵏ ⵜⴻⵡⴹⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵉⵎⵖⴰⵔⴻⵏ, ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵣⵉ ⵉ ⵖⴰ ⴳⴳⵯⴻⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵟⴰⵔⵔⴻⵛ ⵉⵖⵙⴰⵏ ⵏ ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⵀⴻⵊⵊⵎⴻⵏ. ⵛⴻⴽ ⵜⴻⵙⵙⴱⴻⵀⴷⵍⴻⴷ ⵉ-ⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS53_7","020_53_7","PSA","53","7","7","ⴰⵀ, ⵉⵍⵉ ⴰⵙⴻⵏⵊⴻⵎ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴻⵖⵢⴰ ⵣⵉ ⵚⵉⵀⵢⵓⵏ! ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵢⴰⵔⵛⴻⵇ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵉⴼⴰⵔⵃ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS54_1","020_54_1","PSA","54","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ⴰⵅⴻⵎⵎⵉ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS54_2","020_54_2","PSA","54","2","2","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵣⵉⴼⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ ⵉ ⵛⴰⵡⵓⵍ: “ⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴷⴰⵡⵓⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔⵏⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("PS54_3","020_54_3","PSA","54","3","3","ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰⵖ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS54_4","020_54_4","PSA","54","4","4","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵍ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⵙⵃⴻⵙⵙ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS54_5","020_54_5","PSA","54","5","5","ⵎⴰⵖⴰⵔ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴽⴽⴰⵔⴻⵏ ⴰⴽⵉⴷⵉ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS54_6","020_54_6","PSA","54","6","6","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ. ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⴻⵏⵏⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS54_7","020_54_7","PSA","54","7","7","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵍⵖⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ⵇⴹⴰ ⵅⴰⵙⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS54_8","020_54_8","PSA","54","8","8","ⵙ ⵍⵅⴰⴹⴰⵔ ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵜⵉⵖⴰⵔⵚⴰ, ⴰⴷ ⵇⴰⴷⵉⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS54_9","020_54_9","PSA","54","9","9","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⴰⵢⵉ-ⴷⴷ ⴰⴷ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("PS55_1","020_55_1","PSA","55","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ⴰⵅⴻⵎⵎⵉ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS55_2","020_55_2","PSA","55","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵍ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⵡⴰⵔ ⵙⵙⵏⵓⴼⴼⴰⵔⴰ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵜⵓⵜⵔⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS55_3","020_55_3","PSA","55","3","3","ⵃⴹⴰ ⴰⵢⵉ ⵓ ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ. ⵏⴻⵛⵛ ⵜⵜⵔⴰⵃⴻⵖ ⵜⵜⴰⵙⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵣⵣⴰⵜ ⴷ ⴹⴻⴼⴼⴰⵔ, ⴰⵎ ⵜⵜⵛⴻⵜⵛⵉⵖ ⵓ ⵙⵙⵖⵓⵏⴼⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("PS55_4","020_55_4","PSA","55","4","4","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵍⴻⵄⴷⵓ, ⵣⴻⴳ ⵓⵀⵓⴷⴷⵉ ⵏ ⵓⵄⴻⴼⴼⴰⵏ. ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵀⴻⵊⵎⴻⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⵢⵉ ⵙ ⵓⵅⴻⵢⵢⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("PS55_5","020_55_5","PSA","55","5","5","ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⴼⴰⵔⴼⵉⵔ ⴷⴰⵢⵉ ⴷⴰⵅⴻⵍ, ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⵏ ⵍⵎⴻⵡⵜ ⵡⴹⴰⵏ-ⴷⴷ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS55_6","020_55_6","PSA","55","6","6","ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵔⵊⵉⵊⵉⵜ ⵜⵜᵉⵟⵟⴼⴻⵏⵜ ⴰⵢⵉ, ⵓⵍⴰ ⴷ ⴰⵔⵊⴻⴼ ⵉⵃⴻⵚⵚⴰⵔ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS55_7","020_55_7","PSA","55","7","7","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵎⵍⵉ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⴰⴼⵔⵉⵡⴻⵏ ⴰⵎ ⵜⴻⴷⴱⵉⵔⵜ, ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴹⵡⵉⵖ, ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵛⴰ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("PS55_8","020_55_8","PSA","55","8","8","ⵅⵣⴰⵔ, ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵇⴰⵄ, ⴰⴷ ⵙⵙⴻⵏⵙⴻⵖ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS55_9","020_55_9","PSA","55","9","9","ⴰⴷ ⴷⴻⵖⵢⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⴼⴻⴽⴽⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵣⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("PS55_10","020_55_10","PSA","55","10","10","ⵚⴰⵔⴹ ⵉ-ⵜⴻⵏ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⴻⴱⴹⴰ ⵉⵍⴻⵙ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵜⵡⴰⵍⵉⵖ ⵍⵄⵓⵏⴼ ⴷ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS55_11","020_55_11","PSA","55","11","11","ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ. ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⵖⴱⴻⵏ ⴷ ⵜⴰⵎⴰⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("PS55_12","020_55_12","PSA","55","12","12","ⵍⵖⴻⵛⵛ ⴰⵇⴰ-ⵜ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ, ⴰⵣⵣⴰⵢ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵃⴻⵢⵢⵉⴷ ⵛⴰ ⴷⴷⴻⴵ ⴷ ⵡⴻⵛⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS55_13","020_55_13","PSA","55","13","13","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵍⴻⵄⴷⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⴽⵙⵉⵖ. ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵡⴰⵍ ⵅⴰⴼⵉ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⴻⵙ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵏⵏⵓⴼⴼⴰⵔⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("PS55_14","020_55_14","PSA","55","14","14","ⵎⴰⵛⴰ ⴰⵇⴰ ⴷ ⵛⴻⴽ, ⴰ ⴱⵏⴰⴷⴻⵎ, ⵛⴻⴽ ⴷ ⴰⵇⵔⵉⵏ ⵉⵏⵓ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ ⴷ ⵊⵊⴰⵔ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS55_15","020_55_15","PSA","55","15","15","ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⴷⵉ ⵜⵜⵉⵇⵇⴻⵜ, ⵏⴻⴳⴳⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵀⵉⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("PS55_16","020_55_16","PSA","55","16","16","ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴻⵡⴹⴰ ⵍⵎⴻⵡⵜ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵀⵡⴰⵏ ⴰⵎ ⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵍⵖⴰⵔ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ, ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS55_17","020_55_17","PSA","55","17","17","ⵏⴻⵛⵛ, ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⴰⵔⴻⴱⴱⵉ, ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS55_18","020_55_18","PSA","55","18","18","ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵙ ⵓⵣⵉⵍ ⴰⴷ ⵛⴻⵜⵛⵉⵖ, ⴰⴷ ⵙⵙⵖⵓⵏⴼⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS55_19","020_55_19","PSA","55","19","19","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵚⵍⴰⵃ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵙ ⵍⴻⵀⵏⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ ⵉ ⵡⴻⵀⵊⴰⵎ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴹⵉⴷⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS55_20","020_55_20","PSA","55","20","20","ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⴻⵍ, ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵉⵙⵙⴻⵀⵡⴰ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵍⵄⴰⵔⵛ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ⵙⵉⵍⴰⵀ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵍⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵛⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS55_21","020_55_21","PSA","55","21","21","ⵏⴻⵜⵜⴰ ⵉⵏⴻⵟⵟⴰⵔ ⴰⴼⵓⵙ ⴷⴻⴳ ⵉⵏⵏⵉ ⴰⴽ-ⴷ ⵡⵉ ⵉⴳⴳⴰ ⵍⴻⵀⵏⴰ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS55_22","020_55_22","PSA","55","22","22","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵢⴰⵔⴹⴻⴱ ⵃⵙⴻⵏ ⵣⵉ ⵜⵔⵓⵙⵙⵉ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵓⵔⵊⴰ ⴰⵎⴻⵏⵖⵉ. ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵍⴻⵇⵇⴰⵖⴻⵏ ⵅ ⵣⵣⴻⵛⵜ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵍⴻⵙⵢⵓⴼ ⵜⵜⵡⴰⵊⴻⴱⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS55_23","020_55_23","PSA","55","23","23","ⵏⴹⴰⵔ ⴰⵎⵏⵓⵙ ⵏⵏⴻⵛ ⵅ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵀⵉⵍⵍⴰ. ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⴼⴰⵔⵖ. ");
INSERT INTO rift_vpl VALUES ("PS55_24","020_55_24","PSA","55","24","24","ⵛⴻⴽ ⵎⴰⵛⴰ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵀⵡⵉⴷ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ. ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵍⵖⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴽⴻⵎⵎⵍⴻⵏ ⴰⵣⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵜⴻⵛⵍⴻⵖ ⵅⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("PS56_1","020_56_1","PSA","56","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵉⵛⵜ ⵏ ⵜⴻⴷⴱⵉⵔⵜ ⵉⴱⴻⴽⴽⵎⴻⵎ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ’. ⵏ ⴷⴰⵡⵓⴷ. ⵜⵉⵔⴰ ⵉⵏⴻⵇⵛⴻⵏ, ⵍⴰⵎⵉ ⵜ ⵟⵟⴼⴻⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS56_2","020_56_2","PSA","56","2","2","ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴰⵢⵉ ⵉⵙⴰⵔⴹ, ⵉⵃⴻⵚⵚⴰⵔ ⴰⵢⵉ ⵓⵎⵊⴰⵀⴻⴷ ⴰⵙⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS56_3","020_56_3","PSA","56","3","3","ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⵚⴰⵔⴹⴻⵏ ⴰⵙⵙ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⵙ ⵏⵏⴼⴰⵅⴻⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ! ");
INSERT INTO rift_vpl VALUES ("PS56_4","020_56_4","PSA","56","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⴳⴳⵯⴻⴷⴻⵖ, ⴰⴷ ⵅⴰⴽ ⵜⵜⴻⵛⵍⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("PS56_5","020_56_5","PSA","56","5","5","ⵅ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵚⴻⴱⵃⴻⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵅ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⵜⴻⵛⵍⴻⵖ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⵉⴷⴻⵖ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵎⵉⴷⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS56_6","020_56_6","PSA","56","6","6","ⵏⵉⵜⵏⵉ ⵇⴻⴵⴱⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴰⵙⵙ ⵉⴽⵎⴻⵍ, ⵎⴰⵔⵔⴰ ⵜⵏⴰⵡⵉ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⴼⵉ ⴷ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS56_7","020_56_7","PSA","56","7","7","ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ, ⵏⵓⴼⴼⴰⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⵃⴻⵟⵟⴰⵏ ⵉⵏⴰⵔⵣⵉⵡⴻⵏ ⵉⵏⵓ, ⵅⵎⵉ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵏⵖⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS56_8","020_56_8","PSA","56","8","8","ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵡⴰⵅⵅⴰ ⴳⴳⵉⵏ ⵍⵖⴻⵛⵛ? ⵙⴻⵀⵡⴰ ⵍⴻⴳⵏⵓⵙ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("PS56_9","020_56_9","PSA","56","9","9","ⵛⴻⴽ ⵜⵃⴻⵙⵙⴱⴻⴷ ⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵟⵍⴰⵄ ⵉⵏⵓ. ⴻⴳⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵏⵓ ⴷⵉ ⵜⵣⴻⵢⵢⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵏⵏⴻⵛ, - ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏⵏⴻⵛ? - ");
INSERT INTO rift_vpl VALUES ("PS56_10","020_56_10","PSA","56","10","10","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵖⴰ ⵍⴰⵖⵉⵖ. ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵢⴰ: ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS56_11","020_56_11","PSA","56","11","11","ⵅ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵅ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS56_12","020_56_12","PSA","56","12","12","ⵅ ⴰⵔⴻⴱⴱⵉ ⵉ ⵅⴻⴼ ⵜⵜⴻⵛⵍⴻⵖ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⵉⴷⴻⵖ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴰⵢⵉ ⵢⴻⴳⴳ? ");
INSERT INTO rift_vpl VALUES ("PS56_13","020_56_13","PSA","56","13","13","ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⵙⵉⵏ ⵍⵡⵓⵄⵓⴷ ⵉ ⵛⴻⴽ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ⴰⴷ ⵜⴻⵏ ⴽⴻⵎⵎⵍⴻⵖ ⵉ ⵛⴻⴽ ⵙ ⵓⵇⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS56_14","020_56_14","PSA","56","14","14","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⵎⴻⵡⵜ! ⵎⴰ ⵡⴰⵔ ⵜⴻⵃⴹⵉⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵣⴻⴳ ⵓⵏⴻⵇⵔⴰⴹ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵜⵓⴷⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("PS57_1","020_57_1","PSA","57","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ‘ⵡⴰⵔ ⵜ ⵜⵜⴰⵔⴻⴷⴷⴻⴵ!’ ⵏ ⴷⴰⵡⵓⴷ. ⵜⵉⵔⴰ ⵉⵏⴻⵇⵛⴻⵏ. ⵓⵎⵉ ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵛⴰⵡⵓⵍ ⴷⴻⴳ ⵉⴼⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS57_2","020_57_2","PSA","57","2","2","ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⵎⴰⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵢⴰⵔⴻⴽⴽⵡⴰⵍ-ⴷⴷ ⵖⴰⵔⴻⴽ. ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⴷⵓⵔⵔⵉ ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵛ, ⴰⵍ ⵖⴰ ⵄⴷⵓⵏⵜ ⵍⵎⵓⵚⵉⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS57_3","020_57_3","PSA","57","3","3","ⵏⴻⵛⵛ ⴰⴷ ⵍⴰⵖⵉⵖ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS57_4","020_57_4","PSA","57","4","4","ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⵙⴰⵔⴹ. ⵙⵉⵍⴰⵀ. ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS57_5","020_57_5","PSA","57","5","5","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⵉⵢⵔⴰⴷⴻⵏ, ⵣⵣⵍⴻⵖ ⵊⴰⵔ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ, ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵏⵉ ⵜⵉⵖⵎⴰⵙ ⵏⵙⴻⵏ ⴰⵎ ⵍⴰⵏⵙⴰⵜ ⴷ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ, ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵉⵇⴹⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PS57_6","020_57_6","PSA","57","6","6","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵔⵔ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵛ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS57_7","020_57_7","PSA","57","7","7","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⵔⴰⵛⵛⴰ ⵉ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵜⵓⵖⴰ ⵉⵖⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵖⵣⵉⵏ ⴰⵢⵉ ⴰⵃⴼⵓⵔ, ⵎⴰⵛⴰ ⵡⴹⴰⵏ ⴷⴰⵢⴻⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS57_8","020_57_8","PSA","57","8","8","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵓⵍ ⵉⵏⵓ ⵢⴰⵔⴻⴽⴽⴻⵏ, ⵓⵍ ⵉⵏⵓ ⵢⴰⵔⴻⴽⴽⴻⵏ. ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS57_9","020_57_9","PSA","57","9","9","ⴼⴰⵇ, ⴰⵄⵓⴵⵉ ⵉⵏⵓ! ⴼⴰⵇ, ⵍⵀⴰⵔⴱⴰ ⴷ ⵍⴳⴰⵎⴱⵔⵉ! ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵙⵙⴼⴰⵇⴻⵖ ⵜⴰⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS57_10","020_57_10","PSA","57","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵊⴰⵔ ⵛⵛⵓⵄⵓⴱ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS57_11","020_57_11","PSA","57","11","11","ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⵉⵊⴻⵏⵡⴰⵏ, ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴰⵍ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS57_12","020_57_12","PSA","57","12","12","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵔⵔ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵛ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS58_1","020_58_1","PSA","58","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ‘ⵡⴰⵔ ⵜ ⵜⵜⴰⵔⴻⴷⴷⴻⴵ!’ ⵏ ⴷⴰⵡⵓⴷ. ⵜⵉⵔⴰ ⵉⵏⴻⵇⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS58_2","020_58_2","PSA","58","2","2","ⵎⴰ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴰⵙⴻⴳⴷⴰ ⴷⴻⴳ ⵓⵙⴻⵖⴷⵉ? ⵎⴰ ⵜⵃⴻⴽⴽⵎⴻⵎ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵍⵃⴻⵇⵇ? ");
INSERT INTO rift_vpl VALUES ("PS58_3","020_58_3","PSA","58","3","3","ⵍⵍⴰ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵡⴻⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵍⵖⴻⵛⵛ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵡⴻⵣⵣⵏⴻⵎ ⵍⵄⵓⵏⴼ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS58_4","020_58_4","PSA","58","4","4","ⵣⴻⴳ ⵡⴰⵎⵉ ⴵⴰⵏ ⴷⵉ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴼⴼⵖⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵡⴻⴷⴷⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS58_5","020_58_5","PSA","58","5","5","ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⵙⵙⴻⵎ ⴰⵎ ⵙⴻⵎⵎ ⵏ ⵓⴼⵉⵖⴰⵔ. ⵏⵉⵜⵏⵉ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵍⴻⴼⵙⴰ ⵜⴰⴷⴻⵀⵛⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS58_6","020_58_6","PSA","58","6","6","ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵄⴻⵣⵣⴰⵎⴻⵏ, ⵓⵍⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵙⴻⵃⵃⴰⵔ ⵏⵏⵉ ⵉⵜⵜⵃⴰⴽⴰⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⵙⴻⵃⵃⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS58_7","020_58_7","PSA","58","7","7","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⵥ ⴰⵙⴻⵏ ⵜⵉⵖⵎⴰⵙ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⴰⵔⵥ ⵜⵉⵖⵎⴰⵙ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵉⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS58_8","020_58_8","PSA","58","8","8","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⴰⵎ ⵡⴰⵎⴰⵏ, ⴰⵍⴰⵎⵉ ⴰⴷ ⴼⴼⵖⴻⵏ. ⵎⴰⵍⴰ ⵉⵎⴻⵃⵃⴻⴹ ⵍⵇⴻⵡⵙ ⵙ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵡⴰⵔ ⵇⴹⵉⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS58_9","020_58_9","PSA","58","9","9","ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴼⵏⴰ ⴰⵎ ⵓⴱⵓⵛⵛⴻⵍ ⵉⵔⵉⵣⵣⴻⵏ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵡⴰⵔ ⵥⴰⵔⵔⴻⵏ ⵜⴼⵓⵛⵜ, ⴰⵎ ⵡⴻⵟⵟⵓ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵜⵎⴻⵟⵟⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PS58_10","020_58_10","PSA","58","10","10","ⵇⴱⴻⵍ ⵉ ⵖⴰ ⴰⵛⴰⵏⵜ ⵎⴰⵔⵎⵉⵜⴰⵜ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵍⴻⵃⵎⵓ ⵏ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵙⵓⴹ ⴰⵍⴰⵎⵉ ⴰⴷ ⵢⴰⵥⵥⴻⵍ ⵅ ⵡⴻⵢⵙⵓⵎ ⴷ ⴰⵣⵉⵣⴰ ⵏⵉⵖ ⵅ ⵡⴻⵢⵙⵓⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS58_11","020_58_11","PSA","58","11","11","ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⴼⴰⵔⵃ ⵅⵎⵉ ⵖⴰ ⵉⵥⴰⵔ ⴰⵏⵜⴰⵇⴻⵎ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS58_12","020_58_12","PSA","58","12","12","ⴰⴷ ⵢⵉⵏⵉ ⴱⵏⴰⴷⴻⵎ: “ⵡⴰⵀ, ⴰⵇⴰ ⴷⵉⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("PS59_1","020_59_1","PSA","59","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ‘ⵡⴰⵔ ⵜ ⵜⵜⴰⵔⴻⴷⴷⴻⴵ!’ ⵏ ⴷⴰⵡⵓⴷ. ⵜⵉⵔⴰ ⵉⵏⴻⵇⵛⴻⵏ. ⵓⵎⵉ ⵛⴰⵡⵓⵍ ⵉⵊⵊⴰ ⴰⴷ ⵃⴹⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS59_2","020_59_2","PSA","59","2","2","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔ ⵓⵃⴻⵟⵟⵓ ⵣⴻⴳ ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⴻⴽⴽⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS59_3","020_59_3","PSA","59","3","3","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS59_4","020_59_4","PSA","59","4","4","ⴰⵇⴰ, ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵎⵓⵏⴻⵏ ⵅⴰⴼⵉ. ⵡⴰⵔ ⴷⵉⵏ ⴰⵅⴻⵟⵟⵓ ⵓⵍⴰ ⴷ ⴷⴷⴻⵏⴱ ⵖⴰⵔⵉ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS59_5","020_59_5","PSA","59","5","5","ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴳⴳⵉⵖ ⵍⵊⴰⵔⵉⵎⴰ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵣⴻⵄⵎⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵜⵜⴰⵣⵣⵍⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵓ ⵙⵙⵡⴻⵊⵊⴰⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⴼⴰⵇ, ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵉ ⵓ ⵅⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS59_6","020_59_6","PSA","59","6","6","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴼⴰⵇ ⵃⵉⵎⴰ ⴰⴷ ⵜⵍⴻⵇⴼⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ⵡⴰⵔ ⵜⵜⵃⵉⵏⵏⵉ ⵅ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS59_7","020_59_7","PSA","59","7","7","ⴰⵇⴰ ⵜⵜⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵜⵜⵣⵓⵏ ⴰⵎ ⵡⴻⵇⵣⵉⵏ, ⵜⵜⴻⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS59_8","020_59_8","PSA","59","8","8","ⵅⵣⴰⵔ, ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵙⵙⵓⵙⵓⴼⴻⵏ ⵇⴰⵄ, ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS59_9","020_59_9","PSA","59","9","9","ⵛⴻⴽ ⵎⴰⵛⴰ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴹⴻⵃⵛⴻⴷ, ⵛⴻⴽ ⴰⴷ ⵜⵃⴻⵛⵛⴻⴷ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS59_10","020_59_10","PSA","59","10","10","ⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵔⴰⵊⵉⵖ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS59_11","020_59_11","PSA","59","11","11","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴰⴷ ⴰⵢⵉ ⵜⵉⵣⵡⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵢⵉ ⵢⴰⵔⵔ ⴰⴷ ⵥⴰⵔⴻⵖ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS59_12","020_59_12","PSA","59","12","12","ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵇⵇ ⵛⴰ, ⵎⴰⵃⴻⵏⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵜⵜⵓ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ, ⵎⴻⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵙⵡⴰⴷⴷⴰⵢ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵉ ⵓⵙⴻⵍⵇⵉ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS59_13","020_59_13","PSA","59","13","13","ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ⵅ ⵓⵢⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⴷⵉ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵙⴻⵏ, ⵓⵍⴰ ⵅ ⵏⵏⴻⵄⵍⴻⵜ ⵓ ⵅ ⵓⵅⴰⵔⵔⵉⵇ ⵏⵏⵉ ⵅⴻⴼ ⵜⵜⵃⴰⵔⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS59_14","020_59_14","PSA","59","14","14","ⴽⴻⵃⵃⴻⴹ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ, ⴽⴻⵃⵃⴻⴹ ⵉ-ⵜⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴵⵉⵏ ⵄⴰⴷ, ⴰⵔⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⴷⵉ ⵢⴰⵄⵇⵓⴱ, ⴰⵍ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS59_15","020_59_15","PSA","59","15","15","ⴰⵇⴰ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵜⵜⵣⵓⵏ ⴰⵎ ⵡⴻⵇⵣⵉⵏ ⵓ ⵜⵜⴻⵏⵏⴹⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS59_16","020_59_16","PSA","59","16","16","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵜⵜⴻⵎⵀⴰⴼⴰⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵅ ⵎⴰⵛⵛⴰ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵙⵙⵏⵓⵙⴰⵏ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵊⵊⵉⵡⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS59_17","020_59_17","PSA","59","17","17","ⵏⴻⵛⵛ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵅ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵛ, ⵖⴰⵔ ⵜⴻⴼⴼⵓⵜ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵖ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ ⵉ ⵏⴻⵛⵛ, ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS59_18","020_59_18","PSA","59","18","18","ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵛⴻⴽ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS60_1","020_60_1","PSA","60","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵜⴰⵍⵉⵍⵍⴻⵛⵜ ⴷ ⴰⵛⴻⵀⵀⴰⴷ’. ⵜⵉⵔⴰ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⴷⴰⵡⵓⴷ ⵉ ⵓⵙⴻⵍⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS60_2","020_60_2","PSA","60","2","2","ⵅ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴰⵔⴰⵎ-ⵏⴰⵀⵔⴰⵢⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ, ⵓ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵔⴰⵎ ⵣⵉ ⵚⵓⴱⴰ, ⵓⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵢⵓⵡⴰⴱ, ⵉⵡⵜⴰ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⵎⴻⴵⴰⵃⵜ, ⵄⴻⵛⵔⴰ ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS60_3","020_60_3","PSA","60","3","3","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⵜⴻⵏⴹⴰⵔⴻⴹ ⴰⵏⴻⵖ, ⵜⴰⵔⵥⵉⴷ ⴰⵏⴻⵖ. ⵜⵓⵖⴰ ⵜⴻⵙⵄⴰⵔⴻⴷ ⴰⵟⵟⴰⵙ! ⵙⴱⴻⴷⴷ ⴰⵏⴻⵖ ⵄⴰⵡⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("PS60_4","020_60_4","PSA","60","4","4","ⵛⴻⴽ ⵜⴻⵙⵙⴻⵏⵀⴻⵣⵣⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴼⴻⴵⵇⴻⴷ ⵜⵜ. ⵙⴳⴻⵏⴼⴰ ⵜⵉⵔⴻⵥⵥⴰ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("PS60_5","020_60_5","PSA","60","5","5","ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ. ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵏⴻⵖ ⴰⴷ ⵏⵙⵓ ⵛⵛⵔⴰⴱ ⵉⵙⵙⴷⴻⵡⵡⴰⵅⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS60_6","020_60_6","PSA","60","6","6","ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵜⴻⴳⴳⵉⴷ ⴰⵙⴻⵏ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉ ⵖⴰⵔ ⵜⵜⵔⴰⴽⴽⵡⴰⵍⴻⵏ ⵣⵉ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS60_7","020_60_7","PSA","60","7","7","ⵃⵉⵎⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ, ⴰⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵓ ⴰⵔⵔ-ⴷⴷ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS60_8","020_60_8","PSA","60","8","8","ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵏⴻⴳⵣⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ⵏⴻⵛⵛ ⴰⴷ ⴱⴹⵉⵖ ⵛⴰⴽⵉⵎ, ⴰⴷ ⵄⴻⴱⴱⴰⵔⴻⵖ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵙⵓⴽⴽⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PS60_9","020_60_9","PSA","60","9","9","ⵊⵉⵍⵄⴰⴷ ⵉⵏⵓ, ⵎⴰⵏⴰⵙⵙⴰ ⵉⵏⵓ, ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵢⴰⵀⵓⴷⴰ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS60_10","020_60_10","PSA","60","10","10","ⵎⵓ’ⴰⴱ ⴷ ⵙⵙⴰⵔⵉⵊ ⵉⵏⵓ ⵉ ⵓⵙⵉⵔⴷ, ⵅ ⵉⴷⵓⵎ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷⵓⵇⵣⴻⵖ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴼⵉⵍⵉⵛⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PS60_11","020_60_11","PSA","60","11","11","ⵡⵉ ⴷ ⴰⵢⵉ ⵉ ⵖⴰ ⵉⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ? ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴳⴻⵡⵡⴷⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵎ? ");
INSERT INTO rift_vpl VALUES ("PS60_12","020_60_12","PSA","60","12","12","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵏⴹⴰⵔⴻⴷ, ⴰ, ⴰⵔⴻⴱⴱⵉ, ⵓ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵖ ⵎⴰ ⵡⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ ⴷⴷ-ⵜⴻⴼⴼⵉⵖⴻⴷ ⵄⴰⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("PS60_13","020_60_13","PSA","60","13","13","ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⴼⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵎⴰⵖⴰⵔ ⴰⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴰ-ⵜ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS60_14","020_60_14","PSA","60","14","14","ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵏⴻⴳⴳ ⵙ ⵡⴻⵎⵃⴰⴷ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⴼⴻⵙ ⵅ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS61_1","020_61_1","PSA","61","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS61_2","020_61_2","PSA","61","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵍ ⵉ ⵓⵍⴰⵖⵉ ⵉⵏⵓ, ⵙⴻⵍ ⵎⵍⵉⵃ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS61_3","020_61_3","PSA","61","3","3","ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵜⵍⴰⵖⵉⵖ ⵅⴰⴽ, ⵅⵎⵉ ⵉⵜⵜⴻⴼⵛⵉⵍ ⵡⵓⵍ ⵉⵏⵓ. ⵏⴷⴻⵀ ⴰⵢⵉ ⵅ ⵉⵊⵊ ⵏ ⵊⵊⴰⵔⴼ ⵢⵓⵄⵍⴰⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS61_4","020_61_4","PSA","61","4","4","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵏⴻⵛⵛ, ⴷ ⵍⴱⵓⵔⵊ ⵉⵊⴻⵀⴷⴻⵏ ⴹⵉⴷⴷ ⵉ ⵍⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("PS61_5","020_61_5","PSA","61","5","5","ⵏⴻⵛⵛ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ, ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵙⴰⴷⵓ ⵓⴷⵓⵔⵔⵉ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵛ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS61_6","020_61_6","PSA","61","6","6","ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵙⵍⵉⴷ ⵖⴰⵔ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ. ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS61_7","020_61_7","PSA","61","7","7","ⴰⵔⵏⵉ ⵄⴰⴷ ⵓⵙⵙⴰⵏ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴻⵊⵊ ⴰⴷ ⴰⵔⴻⴷⴼⴻⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵙ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵊⵊⵉⵍ ⵉⴹⴼⴰⵔ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS61_8","020_61_8","PSA","61","8","8","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⴱⴷⴰ. ⴰⴷ ⵅⴰⵙ ⵜⴻⵃⴹⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS61_9","020_61_9","PSA","61","9","9","ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ, ⴰⵙⵙ ⴰⵡⴰⵔⵏⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS62_1","020_62_1","PSA","62","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵢⴰⴷⵓⵜⵓⵏ. ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS62_2","020_62_2","PSA","62","2","2","ⵡⴰⵀ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵢⴰⵔⴻⵙⵙⴰ, ⵉⵜⵜⵔⴰⵊⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵀⴰ, ⴰⵇⴰ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS62_3","020_62_3","PSA","62","3","3","ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ, ⵡⴰⵔ ⵜⵜᵉⴼⵔⵉⵖⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS62_4","020_62_4","PSA","62","4","4","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⵎ ⵜⵀⴻⵊⵊⵎⴻⵎ ⵅ ⵡⴻⵔⵢⴰⵣ? ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⴰⵇⴰ ⵜⵍⴻⵀⵀⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵖⴹⵍⴻⵎ, ⴰⵎ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵉⵡⴻⵟⵟⴰ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⵉⵜⵜⵡⴰⵖⴹⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("PS62_5","020_62_5","PSA","62","5","5","ⵡⴰⵀ, ⵏⵉⵜⵏⵉ ⵜⵜⴻⵎⵛⴰⵡⴰⵔⴻⵏ ⵡⴰⵀⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵖⴻⴹⵍⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⵟⵟⴰⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ⵜⵜⴱⴰⵔⴽⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⵏⴻⵄⵄⵍⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS62_6","020_62_6","PSA","62","6","6","ⵡⴰⵀ, ⵔⴰⵊⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⴻⵙ ⵍⴰⵢⴰⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS62_7","020_62_7","PSA","62","7","7","ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ, ⵡⴰⵔ ⵜⵜⴻⴼⵔⵉⵖⴻⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS62_8","020_62_8","PSA","62","8","8","ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⴷ ⵓⵄⵓⴵⵉ ⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS62_9","020_62_9","PSA","62","9","9","ⵜⵉⵇⵇⴻⵎ ⵍⴻⴱⴷⴰ ⴷⴰⵢⴻⵙ, ⴰ ⵍⴳⴻⵏⵙ! ⵣⴻⴵⵄⴻⵎ ⵓⵍ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵖ ⵏ ⵜⴰⵔⴻⵡⵍⴰ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS62_10","020_62_10","PSA","62","10","10","ⵡⴰⵀ, ⵜⴰⵔⵡⴰ ⵏ ⴰⴷⴰⵎ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⴻⵄⵡⵉⵏ, ⵜⴰⵔⵡⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⴰⵅⴰⵔⵔⵉⵇ. ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⴷⵉ ⵍⵎⵉⵣⴰⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⴰⵡⵢⴰⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⴼⵙⵓⵙⴻⵏ ⵅ ⵍⴻⵄⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS62_11","020_62_11","PSA","62","11","11","ⵡⴰⵔ ⵜⵜⴻⵛⵍⴻⵎ ⵅ ⴷⴷⴻⴵ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵊⴻⴱⴱⴷⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵙ ⵓⴽⴽⴰⵔⴹⴰ. ⵎⴰⵍⴰ ⴰⴳⵍⴰ ⵉⵎⴻⵇⵇⴰⵔ, ⵡⴰⵔ ⵅⴰⵙ ⵙⵙⵔⵓⵙⴰⵎ ⵓⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS62_12","020_62_12","PSA","62","12","12","ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵙⵍⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⴰⵇⴰ: “ⵊⵊⴻⵀⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ”. ");
INSERT INTO rift_vpl VALUES ("PS62_13","020_62_13","PSA","62","13","13","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ! ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴰⴷ ⵜⵅⴻⴵⵚⴻⴷ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS63_1","020_63_1","PSA","63","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵍⴰⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS63_2","020_63_2","PSA","63","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ! ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⴰⵔⴻⵣⵣⵓⵖ ⵅⴰⴽ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⴼⴰⴷⴰ ⵖⴰⵔⴻⴽ, ⴰⵢⵙⵓⵎ ⵉⵏⵓ ⵉⵜⵜⵎⴻⵥⵔⵉ ⴷⴰⵢⴻⴽ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⵉⵜⵜⴼⴰⴷⴰⵏ ⴱⵍⴰ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS63_3","020_63_3","PSA","63","3","3","ⴰⵎⵎⵓ ⵉ ⴷⴰⵢⴻⴽ ⵅⴻⵣⵣⴰⵔⴻⵖ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⴷ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS63_4","020_63_4","PSA","63","4","4","ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴻⵃⵍⴰ ⵅ ⵜⵓⴷⴰⵔⵜ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵚⴻⴱⴱⵃⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS63_5","020_63_5","PSA","63","5","5","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵛ ⵖⴰ ⴱⴰⵔⴽⴻⵖ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS63_6","020_63_6","PSA","63","6","6","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⵊⵊⵉⵡⴻⵏ ⴰⵎ ⵣⵉ ⵜⴰⴷⵓⵏⵜ ⴷ ⵎⵉⵏ ⵉⵎⴻⵙⵍⴻⵏ, ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵙⵍⵉⵡⵍⴻⵡⴻⵏ ⴰⴷ ⵛⴻⴽ ⵉⵚⴻⴱⴱⴻⵃ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS63_7","020_63_7","PSA","63","7","7","ⵎⴰⵍⴰ ⵜⵜⵅⴰⵔⵔⵚⴻⵖ ⴷⴰⵢⴻⴽ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ⵜⵜⵅⴻⵎⵎⴰⵎⴻⵖ ⴷⴰⵢⴻⴽ ⵖⴰⵔ ⵓⴹⵓⴼⴻⵏ ⵏ ⵡⴻⵛⴱⴰⵔ ⵏ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS63_8","020_63_8","PSA","63","8","8","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ, ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS63_9","020_63_9","PSA","63","9","9","ⵍⴻⵄⵎⴰⵍ ⵉⵏⵓ ⵉⵍⴻⵚⵚⴻⵇ ⴷⴰⵢⴻⴽ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⵉⵜⵜᵉⵟⵟⴻⴼ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS63_10","020_63_10","PSA","63","10","10","ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰⴷ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵢⵓⴵⵖⴻⵏ ⵇⴰⵄ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS63_11","020_63_11","PSA","63","11","11","ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⵙⵙⵉⴼ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵉⵛⴻⵄⴱⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS63_12","020_63_12","PSA","63","12","12","ⵎⴰⵛⴰ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⴼⴰⵔⵃ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉ ⵖⴰⵔⴻⵙ ⵉ ⵖⴰ ⵉⵜⵜⵊⴰⴵⴰⵏ ⴰⴷ ⵉⴼⴻⵢⵢⴻⵛ, ⵎⵉⵏⵣⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PS64_1","020_64_1","PSA","64","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS64_2","020_64_2","PSA","64","2","2","ⵙⴻⵍ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵅⵎⵉ ⵜⵜⵛⴻⵜⵛⵉⵖ, ⵃⴹⴰ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵣⴻⴳ ⵓⵙⵉⴳⴳⵯⴻⴷ ⵏ ⵍⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("PS64_3","020_64_3","PSA","64","3","3","ⵙⴷⵓⵔⵔⵉ ⴰⵢⵉ ⵣⵉ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵣⵉ ⵍⵖⴰⵛⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PS64_4","020_64_4","PSA","64","4","4","ⵉⵏⵏⵉ ⵉⵙⵙⴻⵇⴹⴰⵄⴻⵏ ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵙⵙⵉⴼ, ⵇⴰⵔⵔⵚⴻⵏ ⴰⵡⴰⵍ ⵢⴰⵔⴻⵣⴳⴻⵏ ⴰⵎ ⴼⵍⵉⵜⵛⴰ ⵏ ⵍⵇⴻⵡⵙ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS64_5","020_64_5","PSA","64","5","5","ⵃⵉⵎⴰ ⴰⴷ ⵡⵜⴻⵏ ⵙ ⵍⵇⴻⵡⵙ ⵅ ⵡⴻⵏⵏⵉ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ. ⴷⴻⵖⵢⴰ ⴰⴷ ⵅⴰⵙ ⵏⴻⵢⵢⵛⴻⵏ, ⵉⵡⴰ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏⵣⵉ ⵉ ⵖⴰ ⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS64_6","020_64_6","PSA","64","6","6","ⵏⵉⵜⵏⵉ ⵃⴻⵣⵣⵎⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴷⵢⴻⵏ ⵜⵉⵅⵛⵉⴼⵉⵏ. ⵇⵇⴰⵔⴻⵏ: “ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵥⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS64_7","020_64_7","PSA","64","7","7","ⵏⵉⵜⵏⵉ ⵜⵜⵅⴰⵔⵔⵚⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ: “ⴰⵇⴰ ⵏⴻⵡⵊⴻⴷ, ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵏ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ!” ⴰⵇⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵓ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⴰⵇⴰ ⵢⵓⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS64_8","020_64_8","PSA","64","8","8","ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜⴻⵏ ⵉⵡⵡⴻⵜ ⵙ ⴼⵍⵉⵜⵛⴰ ⵏ ⵍⵇⴻⵡⵙ, ⴷⴻⵖⵢⴰ ⴰⴷ ⴱⴰⵏⴻⵏ ⵊⵊⵔⴰⵢⴻⵃ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS64_9","020_64_9","PSA","64","9","9","ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵔ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ, ⵣⴻⴳ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵜⵜⵡⴰⵍⴰⵏ, ⴰⴷ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS64_10","020_64_10","PSA","64","10","10","ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴰⴷ ⵅⵣⴰⵔⴻⵏ ⵎⵍⵉⵃ ⴷⵉ ⵎⵉⵏ ⴷⴷ ⵉⵜⵜⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("PS64_11","020_64_11","PSA","64","11","11","ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⴼⴰⵔⵃ ⴷⵉ ⵙⵉⴷⵉ ⵓ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵔⵡⴻⵍ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵙⴻⴳⴳⴻⴷ ⵡⵓⵍ ⴰⴷ ⴼⴰⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS65_1","020_65_1","PSA","65","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵉⵣⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS65_2","020_65_2","PSA","65","2","2","ⴰⵚⴻⴱⴱⴻⵃ ⵉⵜⵜⵔⴰⵊⴰ ⵉ ⵛⴻⴽ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⴰ, ⴰⵔⴻⴱⴱⵉ, ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⵡⴰⵄⴷ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS65_3","020_65_3","PSA","65","3","3","ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵥⴰⴵⵉⵜ, ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS65_4","020_65_4","PSA","65","4","4","ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵜⵓⵖⴰ ⵜⴻⵊⵀⴻⴷ ⵅⴰⴼⵉ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⵚⵍⴰⵃ ⵅ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS65_5","020_65_5","PSA","65","5","5","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵜⴼⴰⵔⵔⵣⴻⴷ ⵛⴻⴽ ⵓ ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏⵏⴻⵛ. ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵊⵊⵉⵡⴻⵏ ⵙ ⵍⵅⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS65_6","020_65_6","PSA","65","6","6","ⵛⴻⴽ ⴰⴷ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵙ ⵜⵎⴻⴳⴳⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ. ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵍⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏ ⵍⴻⴱⵃⵓⵔ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS65_7","020_65_7","PSA","65","7","7","ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵔⵓⵙⴰⵏ ⵉⴷⵓⵔⴰⵔ ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵙ, ⵛⴻⴽ ⵜⴱⴻⴽⴽⵙⴻⴷ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PS65_8","020_65_8","PSA","65","8","8","ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵍⴻⵀⵡⴻⵍ ⵏ ⵍⴻⴱⵃⵓⵔ ⵢⴰⵔⴻⵙⵙⴰ, ⵍⴻⵀⵡⴻⵍ ⵏ ⵍⴻⵎⵡⴰⵊ ⵣⵣⵀⵉⵔ ⵏ ⵛⵛⵓⵄⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS65_9","020_65_9","PSA","65","9","9","ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵣⵉ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⵍⴻⴼⵊⴰⵔ ⵏ ⵜⵓⴼⴼⵓⵜ ⴷ ⵡⴻⵟⵟⵓ ⵏ ⵜⵎⴻⴷⴷⵉⵜ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS65_10","020_65_10","PSA","65","10","10","ⵛⴻⴽ ⵜⴰⵔⴻⵣⵣⴼⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⴰⴷ ⵜⵜ ⵛⵓⵇⴻⵏⵜ, ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⵜⵜ-ⵉ-ⴷⴷ ⵙ ⵍⵅⵉⵔ ⴰⵟⵟⴰⵙ. ⵉⵖⵣⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵜⵜ ⵉⵜⵜⵛⵓⵇⴰ ⴰⵇⴰ ⵉⵜⵜⵛⵓⵔ ⵙ ⵡⴰⵎⴰⵏ. ⵛⴻⴽ ⵜⴻⵙⵙⴻⵡⵊⴰⴷⴻⴷ ⵉⵎⴻⵏⴷⵉ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵉ ⵓⵢⴰ ⵉ ⵜⴻⴳⴳⵉⴷ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS65_11","020_65_11","PSA","65","11","11","ⵛⴻⴽ ⵜᵉⵜⵜⵙⴰⵡⴻⴷ ⵎⵙⴻⵇⵇⴻⵎ ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵡⴻⵛⵔⴰⵣ, ⵜⴻⵙⵙⵀⴻⴽⴽⵯⵉⴷ ⵉⴱⵓⴷⴰ ⵏⵏⴻⵙ. ⵜⴻⵙⵙⴰⵔⴹⴰⴱⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵉⵏⴻⵛⵏⴰⵛⴻⵏ, ⵜᵉⵜⵜⴱⴰⵔⴽⴻⴷ ⴰⵖⴻⵎⵎⵓⵢ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS65_12","020_65_12","PSA","65","12","12","ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵜⵜⴰⵊ ⵉ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵍⵅⴰⵔ ⵏⵏⴻⵛ, ⵍⴰⵜⴰⵔⴰⵜ ⵏⵏⴻⵛ ⵜⵜⵓⴷⵓⵎⴻⵏⵜ ⵙ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS65_13","020_65_13","PSA","65","13","13","ⴰⵇⴰ ⵜⵜⵓⴷⵓⵎⴻⵏⵜ ⵅ ⴷⴷⵎⴰⵏⵉ ⵏ ⵍⴻⵅⵍⴰ, ⵜⵉⵡⵔⵉⵔⵉⵏ ⴱⴻⴽⴽⵙⴻⵏⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS65_14","020_65_14","PSA","65","14","14","ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵙⵙⵓⵏⵜ ⵙ ⵡⵓⴵⵉ, ⵜⵉⵖⵣⵓⵔⵉⵏ ⴷⵍⵉⵏⵜ ⵙ ⵉⵎⴻⵏⴷⵉ. ⵏⵉⵜⵏⵉ ⴷⴷⵓⵇⵇⵓⵣⴻⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵡⴰⵀ, ⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS66_1","020_66_1","PSA","66","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵉⵣⵍⵉ. ⴰⵣⴻⵀⵀⴻⴷ. ⴷⵓⵇⵇⵣⴻⵎ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("PS66_2","020_66_2","PSA","66","2","2","ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵙⵙⵄⵓⴵⴰ ⵉ-ⵜ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS66_3","020_66_3","PSA","66","3","3","ⵉⵏⵉⵎ ⵉ ⴰⵔⴻⴱⴱⵉ: “ⵎⴰⵎⵎⴻⵛ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏⵜ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ!” ⵣⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⴽ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS66_4","020_66_4","PSA","66","4","4","ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵡⴰⵀ ⵎⴰⵔⵔⴰ ⴰⴷ ⴰⵛ ⵙⴻⵊⴷⴻⵏ ⵓ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵏ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵏ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS66_5","020_66_5","PSA","66","5","5","ⴰⵙⴻⵎ-ⴷⴷ, ⵅⵣⴰⵔⴻⵎ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵎⵉⵏ ⵉⴳⴳⴰ ⵣⵣⴰⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS66_6","020_66_6","PSA","66","6","6","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵍⴻⴱⵃⴰⵔ ⴷ ⵍⴱⴰⵔ. ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵉⵖⵣⴰⵔ ⵅ ⵉⴹⴰⵔⴻⵏ. ⴷⵉⵏⵏⵉ ⵉ ⵣⵣⴰⵢⴻⵙ ⵏⴼⴰⵔⵔⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PS66_7","020_66_7","PSA","66","7","7","ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵃⴻⴽⴽⴻⵎ ⵉ ⵍⴻⴱⴷⴰ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵜⵜⵄⴻⵙⵙⴻⵏⵜ ⵅ ⵍⴻⴳⵏⵓⵙ. ⵖⴰⵔⵡⴻⵎ ⴰⴷ ⵎⵎⵄⴰⵍⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵡⵡⵖⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS66_8","020_66_8","PSA","66","8","8","ⴱⴰⵔⴽⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴽⴻⵏⵏⵉⵡ ⴰ ⵍⴻⴳⵏⵓⵙ, ⴳⴳⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS66_9","020_66_9","PSA","66","9","9","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵊⵊⵉⵏ ⴰⴹⴰⵔ ⵏⵏⴻⵖ ⴰⴷ ⵉⴼⴰⵔⵖ. ");
INSERT INTO rift_vpl VALUES ("PS66_10","020_66_10","PSA","66","10","10","ⵎⵉⵏⵣⵉ ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⵇⴻⴵⴱⴻⴷ ⴰⵏⴻⵖ, ⵛⴻⴽ ⵜⴻⵙⵙⵉⵣⴻⴷⴳⴻⴷ ⴰⵏⴻⵖ ⴰⵅⵎⵉ ⵙⵙⵉⵣⴷⴰⴳⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS66_11","020_66_11","PSA","66","11","11","ⵛⴻⴽ ⵜⵏⴻⴷⵀⴻⴷ ⴰⵏⴻⵖ ⴷⵉ ⵜⵔⴰⵛⵛⴰ ⵏ ⵍⴼⴻⵅ. ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵅⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⴷⴷⵇⴻⵍ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS66_12","020_66_12","PSA","66","12","12","ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⵉⵡⴷⴰⵏ ⴰⴷ ⵏⵢⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⴷⵡⴻⵍ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⴷ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵏⴻⵖ ⵙ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵉⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("PS66_13","020_66_13","PSA","66","13","13","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵙ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⴷ ⴰⵛ ⵅⴻⴵⵚⴻⵖ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS66_14","020_66_14","PSA","66","14","14","ⵍⵡⵓⵄⵓⴷ ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴻⵟⵇⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS66_15","020_66_15","PSA","66","15","15","ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵍⵎⴰⵔ ⵉⵚⴻⵃⵃⴻⵏ ⴰⴷ ⴰⵛ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⴽ-ⴷ ⵍⴻⴱⵅⵓⵔ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS66_16","020_66_16","PSA","66","16","16","ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⵉⵜⵜⴻⴳⴳⵯⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵙⵙⴻⵜⵜⵉⵡ-ⴷⴷ, ⵙⵍⴻⵎ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵄⴰⵡⴷⴻⵖ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS66_17","020_66_17","PSA","66","17","17","ⵄⴰⴷ ⵉⵍⴰⵖⴰ ⵅⴰⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⵙⴰⴷⵓ ⵢⵉⵍⴻⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS66_18","020_66_18","PSA","66","18","18","ⵎⵍⵉ ⵜⵓⵖⴰ ⵏⵡⵉⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS66_19","020_66_19","PSA","66","19","19","ⴰⵔⴻⴱⴱⵉ ⵎⴰⵛⴰ ⴰⵇⴰ ⵉⵙⵍⴰ ⴰⵢⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS66_20","020_66_20","PSA","66","20","20","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵏⴹⴰⵔⴻⵏ ⵜⴰⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⴽⴽⵉⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS67_1","020_67_1","PSA","67","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ⴰⵣⴻⵀⵀⴻⴷ. ⵉⵣⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS67_2","020_67_2","PSA","67","2","2","ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⵉⵏⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵊⵊⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⴰⵔⵖ - ⵙⵉⵍⴰⵀ - ");
INSERT INTO rift_vpl VALUES ("PS67_3","020_67_3","PSA","67","3","3","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("PS67_4","020_67_4","PSA","67","4","4","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS67_5","020_67_5","PSA","67","5","5","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏⵉⵛⴰⵏ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵓⵢⵓⵔⴻⴷ ⵛⵛⵓⵄⵓⴱ ⵅ ⵜⴻⵎⵎⵓⵔⵜ - ⵙⵉⵍⴰⵀ - ");
INSERT INTO rift_vpl VALUES ("PS67_6","020_67_6","PSA","67","6","6","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS67_7","020_67_7","PSA","67","7","7","ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵉⵛ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⴷ ⴰⵏⴻⵖ ⵉⴱⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS67_8","020_67_8","PSA","67","8","8","ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⴱⴰⵔⴻⴽ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⵯⴻⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS68_1","020_68_1","PSA","68","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⴰⵣⴻⵀⵀⴻⴷ. ⵉⵣⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS68_2","020_68_2","PSA","68","2","2","ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⴽⴽⴰⵔ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜⵡⴰⵔⴻⵢⵢⵛⴻⵏ, ⵉⵏⵏⵉ ⵜ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS68_3","020_68_3","PSA","68","3","3","ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⵉⵟⵟⴰⵡ, ⴰⵎ ⵛⵛⵎⴻⵄ ⵉⴼⴻⵙⵙⵉ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴼⵏⴰⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS68_4","020_68_4","PSA","68","4","4","ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⴰⴷ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⴷ ⵖⴻⴱⴱⴰⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS68_5","020_68_5","PSA","68","5","5","ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵢⵓⵄⵍⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ. ⵙⵉⴷⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵏⴻⴳⵣⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS68_6","020_68_6","PSA","68","6","6","ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏ ⵉⵢⵓⵊⵉⵍⴻⵏ ⴷ ⵍⵇⴰⴹⵉ ⵏ ⵜⵉⵊⵊⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS68_7","020_68_7","PSA","68","7","7","ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵣⴻⴷⴷⴰⵖⴻⵏ ⵉⵏⵏⵉ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵡⴰⵛⵓⵏⵜ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵉⵎⴻⵃⴱⴰⵙ ⵙ ⵓⴼⵍⴰⵃ, ⵎⴰⵛⴰ ⵉⵎⵖⴻⵡⵡⴰⵖⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵣⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS68_8","020_68_8","PSA","68","8","8","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵍⴰⵎⵉ ⵜⵉⵣⵣⴰⵔⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵓⵔⴻⴷ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ - ⵙⵉⵍⴰⵀ - ");
INSERT INTO rift_vpl VALUES ("PS68_9","020_68_9","PSA","68","9","9","ⵜⴻⵏⵀⴻⵣⵣ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵓⵛⵔⵓⵔⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵉⵏⵀⴻⵣⵣ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("PS68_10","020_68_10","PSA","68","10","10","ⴰⴽ-ⴷ ⵡⴻⵏⵥⴰⵔ ⵉⴼⵙⵓⵙⴻⵏ ⵜⵔⵓⵛⵛⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⴰ, ⴰⵔⴻⴱⴱⵉ, ⵅⵎⵉ ⵉ ⵖⴰ ⵉⵙⵍⴰⵡ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ, ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵛⴻⴽ ⵄⴰⵡⴻⴷ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PS68_11","020_68_11","PSA","68","11","11","ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵜⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⴻⵙ. ⵙ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵛ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵜⵜ ⵉ ⵍⵎⴻⵙⴽⵉⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("PS68_12","020_68_12","PSA","68","12","12","ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵡⵛⴰ ⴰⵡⴰⵍ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵜⵜⴽⴻⵡⵡⵏⴻⵏⵜ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⵔⴻⵇⵇⴰⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS68_13","020_68_13","PSA","68","13","13","ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵜⵜⵔⴰⴽⴽⵡⴰⵍⴻⵏ, ⴰⵇⴰ ⵜⵜⵔⴰⴽⴽⵡⴰⵍⴻⵏ, ⵓ ⵜⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⴱⴻⵟⵟⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("PS68_14","020_68_14","PSA","68","14","14","ⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴱⴱⵓⵣⵣⵍⴻⵎ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴰⵔⵢⵉⵡⵉⵏ, ⴰⵎ ⵡⴻⴷⴱⵉⵔ ⵊⴰⵔ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵉ ⵉⵜⵜⵡⴰⵍⴻⵃⵃⴼⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ, ⵊⴰⵔ ⴰⵔⵔⵉⵛ ⵏⵏⴻⵙ ⵙ ⵡⵓⵔⴻⵖ ⴰⵣⵉⵣⴰ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS68_15","020_68_15","PSA","68","15","15","ⵍⴰⵎⵉ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵛ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵛⵛⴰⵜ ⵡⴻⴷⴼⴻⵍ ⵅ ⵚⴰⵍⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS68_16","020_68_16","PSA","68","16","16","ⴰⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ! ⴰⴷⵔⴰⵔ ⵏ ⴱⴰⵛⴰⵏ! ⴰⴷⵔⴰⵔ ⵏ ⴱⴰⵛⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵙ ⵜⵇⵉⵛⵛⵉⵜⵉⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS68_17","020_68_17","PSA","68","17","17","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⴰⵎⵎⵓ ⵙ ⵡⴰⵙⴰⵎ, ⴽⴻⵏⵏⵉⵡ ⴰ ⵉⴷⵓⵔⴰⵔ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵇⵉⵛⵛⵉⵜⵉⵏ ⵏⵡⴻⵎ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵉ ⵉⵎⴻⵥⵔⵉ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ? ⵡⴰⵀ, ⵏⵉⵛⴰⵏ ⵙⵉⴷⵉ ⴰⴷ ⴷⵉⵏ ⵉⵣⴷⴻⵖ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS68_18","020_68_18","PSA","68","18","18","ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵄⴻⵛⵔⴰⵢⴰⵜ ⵏ ⵍⵓⵍⵓⴼ ⴷ ⵄⴻⵛⵔⴰⵢⴰⵜ ⵏ ⵍⵓⵍⵓⴼ, ⵓⵍⴰ ⴷ ⴰⵍⴻⴼ ⵓ ⵄⴰⵡⴻⴷ ⴰⵍⴻⴼ. ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⴰⵙⴻⵏ, ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵍⴻⵃⵃⴻⴼ ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("PS68_19","020_68_19","PSA","68","19","19","ⵛⴻⴽ ⵜⵓⵍⵢⴻⴷ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⵜⵏⴻⴷⵀⴻⴷ ⵉⵎⴻⵃⴱⴰⵙ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵛⴻⴽ ⵜⵎⴻⵏⵄⴻⴷ ⵜⴰⵔⵣⵉⴼⵉⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵉⵡⴰ ⵄⴰⴷ ⵣⴻⴳ ⵉⵎⵖⴻⵡⵡⵖⴻⵏ, ⵃⵉⵎⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS68_20","020_68_20","PSA","68","20","20","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵉⵏⵓ. ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ ⵢⴰⵔⴻⴱⴱⵓ ⵉ ⵏⴻⵛⵛⵉⵏ ⴷⴷⵇⵓⵍⴰⵜ. ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ - ⵙⵉⵍⴰⵀ - ");
INSERT INTO rift_vpl VALUES ("PS68_21","020_68_21","PSA","68","21","21","ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ ⵉ ⵏⴻⵛⵛⵉⵏ. ⴰⵇⴰ ⴷⵉⵏ ⵉⴼⴻⴽⴽⵉⵜⴻⵏ ⵣⵉ ⵍⵎⴻⵡⵜ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS68_22","020_68_22","PSA","68","22","22","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵉⵍⴱⴻⵣ ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ, ⴰⵛⴻⵇⵇⵓⴼ ⵙ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵙ ⵉⵎⴻⵔⵡⵓⵙⴰ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS68_23","020_68_23","PSA","68","23","23","ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵣⵉ ⴱⴰⵛⴰⵏ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵣⵉ ⵍⴰⴵⴰⵖ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PS68_24","020_68_24","PSA","68","24","24","ⵃⵉⵎⴰ ⴰⴷ ⵜⵃⴰⵔⵔⵛⴻⴷ ⵙ ⵓⴹⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵍⴻⵙ ⵏ ⵢⵉⵟⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("PS68_25","020_68_25","PSA","68","25","25","ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵜⵓⵢⵓⵔⴻⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ ⵉⵏⵓ, ⵍⴻⵃⵃⴼⴻⵏ ⴷⵉ ⵜⵇⴻⴷⴷⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("PS68_26","020_68_26","PSA","68","26","26","ⵉⵎⴻⵖⵏⴰⵊⴻⵏ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵉⵏⵏⵉ ⵉⵛⵛⴰⵜⴻⵏ ⵅ ⵉⴼⵉⵍⴰⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵉⵔⴰⵔⴻⵏ ⵅ ⵉⴱⴻⵏⴷⵉⵍⴻⵏ ⵏⵙⴻⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ. ");
INSERT INTO rift_vpl VALUES ("PS68_27","020_68_27","PSA","68","27","27","ⴱⴰⵔⴽⴻⵎ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ, ⴰ ⵙⵉⴷⵉ, ⵣⵉ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS68_28","020_68_28","PSA","68","28","28","ⴰⵇⴰ ⴷⵉⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⵎⴻⵥⵢⴰⵏ, ⵡⴻⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵚⴻⴵⴰⴹⴻⵏ, ⵅⴻⵏⵏⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴽ-ⴷ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵄⵛⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵣⴰⴱⵓⵍⵓⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS68_29","020_68_29","PSA","68","29","29","ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵉⵡⴻⵚⵚⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ. ⴰ, ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵊⵀⴻⴷ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("PS68_30","020_68_30","PSA","68","30","30","ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⴰⵛ ⵉⵡⵢⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS68_31","020_68_31","PSA","68","31","31","ⵙⵉⴳⴳⵯⴻⴷ ⵍⵡⴻⵃⵛ ⵏⵏⵉ ⴷⴻⴳ ⵓⵖⴰⵏⵉⵎ, ⴰⴱⴰⵔⵔⵓ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴽ-ⴷ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵉⵜⵜⵡⴰⵍⴱⴻⵣ, ⴰⵎ ⵏⵏⵓⵇⴰⵔⵜ ⵉⴷⴷⴻⵣ. ⵏⴻⵜⵜⴰ ⵉⵣⴻⴵⴻⵄ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵎⴻⵥⵔⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS68_32","020_68_32","PSA","68","32","32","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⴽⵓⵛ ⴰⴷ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⴻⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS68_33","020_68_33","PSA","68","33","33","ⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵖⴻⵏⵏⵊⴻⵏⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵣⴻⵀⵀⴷⴻⵏⵜ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS68_34","020_68_34","PSA","68","34","34","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⵏⵡⴰⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS68_35","020_68_35","PSA","68","35","35","ⵡⵛⴻⵎ ⵊⵊⴻⵀⴷ ⵉ ⴰⵔⴻⴱⴱⵉ! ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⵜⵉⵡⴰ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS68_36","020_68_36","PSA","68","36","36","ⴰ, ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⴷⴻⴷ ⵣⵉ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵊⵊⴻⵀⴷ ⴷ ⵜⵣⴻⵎⵎⴰⵔ ⵉ ⵍⴳⴻⵏⵙ. ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ. * ");
INSERT INTO rift_vpl VALUES ("PS69_1","020_69_1","PSA","69","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵜⵍⵉⵍⵍⵉⵛⵉⵏ’. ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS69_2","020_69_2","PSA","69","2","2","ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⴰⵎⴰⵏ ⵉⵡⴹⴻⵏ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS69_3","020_69_3","PSA","69","3","3","ⵏⴻⵛⵛ ⵖⴻⴱⴱⵉⵖ ⴷⴻⴳ ⵓⴱⴰⵔⵢⵓⴹ ⵢⵓⴵⴻⵖ, ⵡⴰⵔ ⴷⵉⵏ ⵎⴰⵏⵉ ⵖⴰ ⴱⴻⴷⴷⴻⵖ. ⴰⵇⴰ-ⵢⵉ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵢⵓⴵⵖⴻⵏ ⵓ ⵍⵃⴻⵎⵍⴻⵜ ⵜᵉⵜⵜⴰⵣⵣⴻⵍ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS69_4","020_69_4","PSA","69","4","4","ⵏⴻⵛⵛ ⵓⵃⵍⴻⵖ ⵙ ⵉⵖⵓⵢⵢⴰⵏ, ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵜⴻⴱⴱⵓⵢⴱⴻⵃ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵇⴹⴰⵏⵜ ⵣⴻⴳ ⵓⵔⴰⵊⵉ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS69_5","020_69_5","PSA","69","5","5","ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵅ ⵡⴰⵍⵓ ⵜⵜⵡⴻⵙⵙⵄⴻⵏ ⵅ ⵓⵛⵓⵡⵡⴰⴼ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ. ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵉ ⵅⴰⴼⵉ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⵊⴻⵀⵀⴷⴻⵏ. ⵎⵉⵏ ⵡⴰⵔ ⵓⵛⴰⵔⴻⵖ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS69_6","020_69_6","PSA","69","6","6","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵉⵏⵓ, ⵉⵎⴻⵔⵡⵓⵙⴰ ⵏ ⴷⴷⵏⵓⴱ ⵉⵏⵓ ⵡⴰⵔ ⵅⴰⴽ ⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_7","020_69_7","PSA","69","7","7","ⴻⵊⵊ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵙⵙⵉⵜⵉⵎⴻⵏ, ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵅⴰⴽ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜⵡⴰⴼⴻⵟⵟⵃⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS69_8","020_69_8","PSA","69","8","8","ⵎⴰⵖⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ ⵉ ⴽⴻⵙⵙⵉⵖ ⴰⵙⴻⵃⵇⴰⵔ, ⴰⵙⴻⴹⵃⵉ ⵉⵍⴻⵃⵃⴻⴼ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS69_9","020_69_9","PSA","69","9","9","ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵖⵔⵉⴱ ⵖⴰⵔ ⴰⵢⵜⵎⴰ, ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴻⵎⵎⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS69_10","020_69_10","PSA","69","10","10","ⵎⴰⵖⴰⵔ ⵜⵓⵙⵎⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵜⴻⵛⵛⴰ ⴰⵢⵉ, ⴰⵙⴻⵃⵇⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵉⵡⴹⴰ-ⴷⴷ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS69_11","020_69_11","PSA","69","11","11","ⵏⴻⵛⵛ ⵔⵓⵖ ⵖⴰⵔ ⵓⵥⵓⵎⵎⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴰⵢⴰ ⵢⵉⵡⵉ ⴰⵢⵉ-ⴷⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS69_12","020_69_12","PSA","69","12","12","ⵏⴻⵛⵛ ⵢⴰⵔⴹⴻⵖ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵛⴰ ⴷⴻⵡⵍⴻⵖ ⴰⵙⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⵎⴰⵜⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS69_13","020_69_13","PSA","69","13","13","ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅⴰⴼⵉ, ⵓⵍⴰ ⴷ ⵉⵣⵍⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⵛⵛⵔⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PS69_14","020_69_14","PSA","69","14","14","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵜⵜᵉⵜⵜⴰⵔⴻⵖ ⵖⴰⵔⴻⴽ, ⴰ ⵙⵉⴷⵉ! ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵃⴰⵍ ⵏ ⴰⵔⴹⴰ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ ⵙ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵎⴰⵏⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS69_15","020_69_15","PSA","69","15","15","ⵊⴱⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵓⴱⴰⵔⵢⵓⴹ, ⴻⵊⵊ ⴰⵢⵉ ⵡⴰⵔ ⵜⵜⵖⴻⴱⴱⵉⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵓ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵢⵓⴵⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_16","020_69_16","PSA","69","16","16","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴰⵢⵉ ⵜⴰⵡⵉ ⵍⵃⴻⵎⵍⴻⵜ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵍⴰⴵⴰⵖ ⴰⴷ ⴰⵢⵉ ⵉⵙⴰⵔⴹ, ⴰⴷ ⵅⴰⴼⵉ ⵉⴱⴻⵍⵍⴻⵄ ⵡⴰⵏⵓ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS69_17","020_69_17","PSA","69","17","17","ⴰⵔⵔ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴻⵚⴱⴻⵃ. ⵇⵍⴻⴱ ⵖⴰⵔⵉ ⵄⵍⴰⵃⵚⴰⴱ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⵉⴼⴻⵢⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_18","020_69_18","PSA","69","18","18","ⵡⴰⵔ ⵜⵜⴻⴼⴼⴰⵔ ⵛⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ. ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ ⴷⴰⵡⴻⵃⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS69_19","020_69_19","PSA","69","19","19","ⴰⴷⴻⵙ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴼⴻⴽⴽ ⵉ-ⵜ. ⵙⴻⵚⵍⴻⵃ ⴰⵢⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS69_20","020_69_20","PSA","69","20","20","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵍⵄⴰⵔ ⵉⵏⵓ ⴷ ⵓⵙⴻⴹⵃⵉ ⵉⵏⵓ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉⵏⵓ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS69_21","020_69_21","PSA","69","21","21","ⴰⵙⴻⵃⵇⴰⵔ ⵢⴰⵔⵥ ⴰⵢⵉ ⵓⵍ ⵓ ⵏⴻⵛⵛ ⵇⴻⵏⴹⴻⵖ ⴰⵟⵟⴰⵙ. ⵔⴰⵊⵉⵖ ⴰⵣⵉⴵⴻⵣ, ⵎⴰⵛⴰ ⵡⴰⵍⵓ, ⵏⴻⵛⵛ ⵔⴰⵊⵉⵖ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵄⴻⵣⵣⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_22","020_69_22","PSA","69","22","22","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵙⵙⴻⵎ ⴷⵉ ⵎⴰⵛⵛⴰ ⵉⵏⵓ, ⵉ ⵓⴼⴰⴷⵉ ⵉⵏⵓ ⴳⴳⵉⵏ ⴰⵢⵉ ⴰⴷ ⵙⵡⴻⵖ ⵍⵅⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("PS69_23","020_69_23","PSA","69","23","23","ⴻⵊⵊ ⵟⵟⴰⴱⵍⴰ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⴼⴻⵅ, ⵓⵍⴰ ⴷ ⵜⴰⵅⵛⴻⴼⵜ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵉⴱⴻⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_24","020_69_24","PSA","69","24","24","ⵙⴷⴰⵔⵖⴻⵍ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵄⴰⴷ, ⴰⵔⵔ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏⵜ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS69_25","020_69_25","PSA","69","25","25","ⵣⴻⴵⴻⵄ ⵅⴰⵙⴻⵏ ⴰⵙⵅⴻⴹ ⵏⵏⴻⵛ, ⴻⵊⵊ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵏ ⵉⵍⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("PS69_26","020_69_26","PSA","69","26","26","ⴻⵊⵊ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_27","020_69_27","PSA","69","27","27","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷⴰⵔⵔⴰⵛⴻⵏ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵡⵜⵉⴷ ⵛⴻⴽ, ⵙ ⵍⵀⴰⵔⴷ ⵏⵙⴻⵏ ⴰⵔⵏⵉⵏ ⵉ ⵍⴻⵃⵔⵉⵇ ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⵍⴻⵇⵇⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_28","020_69_28","PSA","69","28","28","ⴰⵔⵔ ⴷⴷⴻⵏⴱ ⵅ ⴷⴷⴻⵏⴱ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS69_29","020_69_29","PSA","69","29","29","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵎⵃⴰⵏ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵣⴻⵎⵎⴰⵎⴻⵏ ⵛⴰ ⵖⴰⵔ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_30","020_69_30","PSA","69","30","30","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵓ ⵜⵜⵏⴻⵣⴱⴰⵔⴻⵖ. ⵉⵍⵉ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS69_31","020_69_31","PSA","69","31","31","ⵏⴻⵛⵛ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵖ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ, ⵙ ⵓⵇⴰⴷⵉ ⴰⴷ ⴰⵙ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS69_32","020_69_32","PSA","69","32","32","ⴰⵢⴰ ⴰⴷ ⵢⴰⵔⴹⴰ ⵙⵉⴷⵉ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵙ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵜⴻⵛⴹⴻⵛⵜ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_33","020_69_33","PSA","69","33","33","ⵉⵎⵀⵉⵏⴻⵏ ⵏⵏⵉ ⵜⵜ ⵉⵥⵔⵉⵏ, ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⵓ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵓⵍ ⵏⵡⴻⵎ ⴰⴷ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS69_34","020_69_34","PSA","69","34","34","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵜⵜⴻⵙⵍⴰ ⵖⴰⵔ ⵉⵎⴻⵣⵍⴰⴹ, ⵡⴰⵔ ⵉⵙⵙⴻⵃⵇⵉⵔⵉ ⵛⴰ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS69_35","020_69_35","PSA","69","35","35","ⴻⵊⵊ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ, ⵍⴻⴱⵃⵓⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS69_36","020_69_36","PSA","69","36","36","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵉⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ, ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS69_37","020_69_37","PSA","69","37","37","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴻⴼ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS70_1","020_70_1","PSA","70","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⵉ ⵍⵉⴷⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS70_2","020_70_2","PSA","70","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴷⴻⵖⵢⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴼⴻⴽⴽⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵄⴰⵡⵏⴻⴷ, ⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS70_3","020_70_3","PSA","70","3","3","ⴻⵊⵊ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵜⵜⵡⴰⵅⴰⵔⴻⵡⴹⴻⵏ ⵓ ⴰⴷ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵟⵟⴰⵏ ⵅ ⵍⵖⴰⵔ ⵉ ⴷⴰⵢⵉ ⵉⵍⴻⵇⵇⴼⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴻⵀⴷⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS70_4","020_70_4","PSA","70","4","4","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴱⴻⵀⴷⴻⵍ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⴰⵔⴻⵏ: “ⵀⴰ, ⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("PS70_5","020_70_5","PSA","70","5","5","ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴽ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⴰⴷ ⴰⵔⵛⵇⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴼⴰⵔⵃⴻⵏ. ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵏⵉⵏ ⵍⴻⴱⴷⴰ: “ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS70_6","020_70_6","PSA","70","6","6","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵓ ⵣⴻⵍⴹⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴷⴻⵖⵢⴰⵜ ⵖⴰⵔⵉ. ⵛⴻⴽ ⴷ ⵜⵡⵉⵣⴰ ⵉⵏⵓ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⵄⴻⵟⵟⴰⵍ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("PS71_1","020_71_1","PSA","71","1","1","ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ ⵖⴰⵔⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⴰⵢⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS71_2","020_71_2","PSA","71","2","2","ⴼⴻⴽⴽ ⴰⵢⵉ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵓ ⴰⵔⵅⵓ ⴰⵢⵉ. ⴰⵔⵔ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵓ ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS71_3","020_71_3","PSA","71","3","3","ⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵏⴻⵛⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵖ ⵍⴻⴱⴷⴰ. ⵛⴻⴽ ⵜⵡⴻⵚⵚⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵖ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵜⴰⵙⴹⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS71_4","020_71_4","PSA","71","4","4","ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵎⵎⵉⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓ ⵣⵉ ⴱⵓ-ⵖⴻⵣⵣⵓ. ");
INSERT INTO rift_vpl VALUES ("PS71_5","020_71_5","PSA","71","5","5","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵍⴰⵢⴰⵙ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵜⴻⵛⵍⵉ ⵉⵏⵓ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS71_6","020_71_6","PSA","71","6","6","ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵜⵓⵖⴰ ⴰⵢⵉ ⵄⴻⵎⵎⴷⴻⵖ ⵅⴰⴽ. ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⵓⵣⴻⵏ, ⵏⴻⵛⵛ ⵚⴻⴱⵃⴻⵖ ⵛⴻⴽ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS71_7","020_71_7","PSA","71","7","7","ⵉ ⵡⴰⵟⵟⴰⵙ ⵏⴻⵛⵛ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⴻⵄⵊⴻⴱ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵉⵊⵀⴻⴷ ⵉ ⵜⴰⵔⴻⵡⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS71_8","020_71_8","PSA","71","8","8","ⴻⵊⵊ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴰⴷ ⵉⵛⵛⵓⵔ ⵙ ⵓⵚⴻⴱⴱⴻⵃ ⵏⵏⴻⵛ, ⴰⵙⵙ ⵉⵎⵓⵏ ⵙ ⵛⵛⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS71_9","020_71_9","PSA","71","9","9","ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⵎⴻⵏⴹⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵡⵙⴰⵔ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⴻⵎⵎⴻⵃ ⵎⴰⵍⴰ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("PS71_10","020_71_10","PSA","71","10","10","ⵎⴰⵖⴰⵔ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅⴰⴼⵉ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⵛⴰⵡⴰⵔⴻⵏ ⵅⴰⴼⵉ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("PS71_11","020_71_11","PSA","71","11","11","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: “ⴰⵔⴻⴱⴱⵉ ⵉⵙⵎⴻⵃ ⴷⴰⵢⴻⵙ. ⴹⴼⴰⵔⴻⵎ ⵜ ⵓ ⵎⴻⵏⵄⴻⵎ ⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS71_12","020_71_12","PSA","71","12","12","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⵜⵉⴳⴳⵯⴻⵊⴻⴷ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴻⵡⵛ ⴰⵢⵉ ⴷⴻⵖⵢⴰ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS71_13","020_71_13","PSA","71","13","13","ⴻⵊⵊ ⵉⵖⵔⵉⵎⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴹⵃⴰⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵛⵛⴻⵏ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵍⵖⴰⵔ ⴰⴷ ⵜⵜⵡⴰⴷⵍⴻⵏ ⵙ ⵓⵙⴻⵃⵇⴰⵔ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS71_14","020_71_14","PSA","71","14","14","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵔⴰⵊⵉⵖ ⵛⴻⴽ ⵍⴻⴱⴷⴰ, ⵓ ⴰⴷ ⴰⵔⵏⵉⵖ ⵄⴰⴷ ⵖⴰⵔ ⵓⵚⴻⴱⴱⴻⵃ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS71_15","020_71_15","PSA","71","15","15","ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⴰⵙⵙ ⵉⵎⵓⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵍⵇⴻⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS71_16","020_71_16","PSA","71","16","16","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵙ ⵜⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⵉⴷⴰⵔⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⵎⵖⵉⵔ ⵜⴻⵏⵏⵉ ⵏⵏⴻⵛ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PS71_17","020_71_17","PSA","71","17","17","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⵜⵓⵖⴰ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⴰⵢⵉ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⴰⵍ ⴰⵙⵙ-ⴰ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS71_18","020_71_18","PSA","71","18","18","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⴻⵎⵎⴻⵃ ⵛⴰ, ⵡⴰⵅⵅⴰ ⵡⵙⴰⵔⴻⵖ ⵛⴰⴱⴻⵖ, ⴰⵍ ⵖⴰ ⵃⴰⵊⵉⵖ ⵉ ⵊⵊⵉⵍ-ⴰ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵍⴰ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS71_19","020_71_19","PSA","71","19","19","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵜⵉⵡⴻⴹ ⴰⵍ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴰⵎ ⵛⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("PS71_20","020_71_20","PSA","71","20","20","ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⵜⴻⴽⴽⴰ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴰⵜ ⴷ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⴷⴷⴰⵔⴻⴷ ⵄⴰⵡⴻⴷ, ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS71_21","020_71_21","PSA","71","21","21","ⵛⴻⴽ ⴰⴷ ⵜⴰⵔⵔⵉⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵉⵏⵓ ⴰⴷ ⵜⴻⵎⵖⴰⵔ, ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⵏⵏⴹⴻⴷ ⵙ ⵓⴼⴻⵡⵡⴻⵊ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS71_22","020_71_22","PSA","71","22","22","ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵄⴰⵡⴻⴷ ⵙ ⵍⵀⴰⵔⴱⴰ, ⵅ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵛⴻⴽ ⵣⴻⵀⵀⴷⴻⵖ ⵙ ⵍⴳⴰⵎⴱⵔⵉ, ⴰ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS71_23","020_71_23","PSA","71","23","23","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵛⴻⴽ, ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵏⵏⵉ ⵜⴻⴼⴷⵉⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS71_24","020_71_24","PSA","71","24","24","ⵓⵍⴰ ⴷ ⵉⵍⴻⵙ ⵉⵏⵓ ⴰⴷ ⵉⵃⴰⵊⴰ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴰⵙⵙ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵙⴻⴹⵃⴰⵏ, ⵉⵡⴰ, ⵜⵜⵡⴰⴼⴻⴹⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_1","020_72_1","PSA","72","1","1","ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⴰ ⴰⵔⴻⴱⴱⵉ, ⴻⵡⵛ ⵉ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴽⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵃⴻⵇⵇ ⵏⵏⴻⵛ, ⵓ ⴻⵡⵛ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⵉ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS72_2","020_72_2","PSA","72","2","2","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴰⴽⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵜⵙⴻⴳⴷⴰ, ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏⵏⴻⵛ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS72_3","020_72_3","PSA","72","3","3","ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵉⵡⵢⴻⵏ ⵍⴻⵀⵏⴰ ⵉ ⵍⴳⴻⵏⵙ, ⵓⵍⴰ ⴷ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵜⴰⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS72_4","020_72_4","PSA","72","4","4","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵖ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏ ⵍⴳⴻⵏⵙ, ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⴰⵔⵡⴰ ⵏ ⵉⵎⴻⵣⵍⴰⴹ, ⵓⵛⴰ ⴰⴷ ⵉⵍⴱⴻⵣ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_5","020_72_5","PSA","72","5","5","ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ ⵎⵉⵏ ⵖⴰ ⵜⴻⴽⴽ ⵜⴼⵓⵛⵜ ⵜⴻⴵⴰ, ⵓ ⵜⴰⵣⵉⵔⵉ ⴰⴷ ⵜⴻⵙⵙⵛⴻⵏ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS72_6","020_72_6","PSA","72","6","6","ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵅ ⵉⵢⵢⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵃⵜⴰⵛ, ⴰⵎ ⵜⵉⵏⴻⵛⵏⴰⵛⵉⵏ ⵉ ⵉⵙⵙⴰⵔⴹⴰⴱⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS72_7","020_72_7","PSA","72","7","7","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵏⵏⵓⵡⴰⵔ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵉⴼⴻⵢⵢⴹⴻⵏ ⴰⵍ ⵖⴰ ⵜⴰⴼⴻⴷ ⵜⴰⵣⵉⵔⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS72_8","020_72_8","PSA","72","8","8","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵍ ⵍⴻⴱⵃⴰⵔ, ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⴰⵍ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS72_9","020_72_9","PSA","72","9","9","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴻⵅⵍⴰ ⴰⴷ ⵇⵇⵓⵏⵊⴻⵍⴻⵏ ⵣⵣⴰⵜⴻⵙ, ⵎⴰⵛⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵍⴻⵙⵃⴻⵏ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS72_10","020_72_10","PSA","72","10","10","ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴰⵔⵛⵉⵛ ⴰⴷ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵛⴰⴱⴰ ⴷ ⵙⴻⴱⴰ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵜⴰⵔⵣⴻⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_11","020_72_11","PSA","72","11","11","ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⴰⵙ ⴰⴹⴰⵔⴻⵏ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴰⵙ ⵄⴻⴱⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_12","020_72_12","PSA","72","12","12","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⴰⵎⴻⵣⵍⵓⴹ, ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵍⴰⵖⴰⵏ, ⵓⵍⴰ ⴷ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⵎⵄⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_13","020_72_13","PSA","72","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⵜⴻⵇ ⴰⵎⴰⵔⵅⵓ ⴷ ⵓⵎⴻⵣⵍⵓⴹ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PS72_14","020_72_14","PSA","72","14","14","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⴷⴷⴻⴵ ⴷ ⵍⵄⵓⵏⴼ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵙⴻⴽⴽⵡⴰⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS72_15","020_72_15","PSA","72","15","15","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⴷⴰⵔ! ⵓ ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵡⵓⵔⴻⵖ ⵣⵉ ⵛⴰⴱⴰ. ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜ ⴱⴰⵔⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_16","020_72_16","PSA","72","16","16","ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣ ⴰⵎ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵓ ⵉⵏⵏⵉ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵏⵏⵓⵡⴰⵔⴻⵏ ⴰⵎ ⴰⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS72_17","020_72_17","PSA","72","17","17","ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ, ⵉⵍⵉ ⴰⴷ ⵉⵏⵏⵓⵡⴰⵔ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴼⵓⵛⵜ. ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵜ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_18","020_72_18","PSA","72","18","18","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PS72_19","020_72_19","PSA","72","19","19","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵉⵙⴻⵎ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ⴰⵎⵉⵏ, ⵡⴰⵀ, ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS72_20","020_72_20","PSA","72","20","20","ⵜⵉⵥⵉⴵⴰⵜⵉⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ, ⴰⵇⴰ ⴽⴻⵎⵎⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS73_1","020_73_1","PSA","73","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ⵡⴰⵀ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵢⵉⵏⵏⵉ ⵙ ⵡⵓⵍ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_2","020_73_2","PSA","73","2","2","ⵏⴻⵛⵛ ⵎⴰⵛⴰ, ⵄⵍⴰⵃⴰⵍ ⵜⵓⵖⴰ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⴰⴷ ⵃⵍⵓⴵⴹⴻⵏ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS73_3","020_73_3","PSA","73","3","3","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵓⵙⵎⴻⵖ ⵣⴻⴳ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵍⴰⵎⵉ ⵥⵔⵉⵖ ⴰⵇⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵎⵍⵉⵃ ⵉ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_4","020_73_4","PSA","73","4","4","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵉⵙⴻⵖⵡⴰⵏ ⵖⴰⵔ ⵍⵎⴻⵡⵜ ⵏⵙⴻⵏ, ⵚⵚⵓⵍⵟⴰ ⵏⵙⴻⵏ ⴰⵇⴰ ⵉⴱⴻⴷⴷ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_5","020_73_5","PSA","73","5","5","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵛⴰⵔⵔⵛⴻⵏ ⴷⵉ ⵜⴰⵎⴰⵔⴰ ⵏ ⵉⵡⴷⴰⵏ, ⵡⴰⵔ ⵜⵜⵡⴰⵍⴻⵇⵇⴼⴻⵏ ⵙ ⵍⵎⵓⵚⵉⴱⴰⵜ ⴰⵎ ⵡⴻⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS73_6","020_73_6","PSA","73","6","6","ⵙ ⵓⵢⴰ ⵜᵉⵜⵜⴰⵢⴻⵍ ⴰⵙⴻⵏ-ⴷⴷ ⵏⵏⴼⴰⵅⴻⵜ ⴰⵎ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵖⴰⵔ ⵢⵉⵔⵉ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵍⴻⵃⵃⴻⴼ ⴰⵙⴻⵏ ⵍⵄⵓⵏⴼ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("PS73_7","020_73_7","PSA","73","7","7","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⴼⴼⵖⴻⵏⵜ ⵣⵉ ⵜⴰⴷⵓⵏⵜ, ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⵓⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_8","020_73_8","PSA","73","8","8","ⵏⵉⵜⵏⵉ ⵙⵜⴻⵀⵣⴰⵏ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵍⵖⴰⵔ, ⵅ ⴷⴷⴻⴵ, ⴰⵇⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("PS73_9","020_73_9","PSA","73","9","9","ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵎⴻⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵅ ⵓⵊⴻⵏⵏⴰ, ⵍⵀⴰⵔⴷ ⵏⵙⴻⵏ ⵉⴳⴳⵓⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS73_10","020_73_10","PSA","73","10","10","ⵙ ⵓⵢⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⴷⴷⴰⴱ ⵏⵙⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⴷⴰ, ⴰⵎⴰⵏ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵜⵜⵙⴻⴽⴽⴰⴼⴻⵏ ⵜⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS73_11","020_73_11","PSA","73","11","11","ⵇⵇⴰⵔⴻⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵙⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ?” “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⴳⴳ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵉⵙⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("PS73_12","020_73_12","PSA","73","12","12","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ! ⵄⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⵙⵙⴻⵡⵙⵉⵄⴻⵏ ⴰⴳⵍⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_13","020_73_13","PSA","73","13","13","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵓⵍ ⵉⵏⵓ ⵓ ⵙⵙⵉⵔⴷⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴷⵉ ⵜⴰⵣⴷⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("PS73_14","020_73_14","PSA","73","14","14","ⴰⵙⵙ ⴰⵎ ⵉⵎⵓⵏ ⵏⴻⵛⵛ ⵜⵉⵢⵢⵉⵜⴰ ⴷⴰⵢⵉ, ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⵜᵉⵜⵜⵡⴰⵔⴻⴱⴱⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS73_15","020_73_15","PSA","73","15","15","ⵎⴰⵍⴰ ⵏⵏⵉⵖ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵎⵎⵓ!”, ⵅⵣⴰⵔ, ⵉⵍⵉ ⵖⴷⴰⵔⴻⵖ ⵊⵊⵉⵍ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS73_16","020_73_16","PSA","73","16","16","ⵉⵜⵜⵍⵉⵖ ⴰⵢⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴼⴻⵀⵎⴻⵖ ⴰⵢⴰ, ⵎⴰⵛⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵎⵖⵉⵔ ⵜⴰⵎⴰⵔⴰ ⵉⴱⴻⵟⵟⵍⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS73_17","020_73_17","PSA","73","17","17","ⴰⵍⴰⵎⵉ ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵃⴻⴽⴽⴰⵔⴻⵖ ⵉ ⵜⵏⴻⴳⴳⴰⵔⵓⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_18","020_73_18","PSA","73","18","18","ⵡⴰⵀ, ⵛⴻⴽ ⵜⴻⵙⵙⵔⵓⵙⵉⴷ ⵜⴻⵏ ⵅ ⵉⵎⵓⵛⴰⵏ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹⴻⵏ, ⵛⴻⴽ ⵜⵖⴻⵟⵟⵍⴻⴷ ⵜⴻⵏ ⴷ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS73_19","020_73_19","PSA","73","19","19","ⵎⴰⵎⵎⴻⵛ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ, ⵜⵜⵡⴰⵎⵃⴰⵏ ⵓ ⵜⵜⵡⴰⵇⴹⴰⵏ ⵙ ⵉⵛⴻⵍⵡⴰⵡⴻⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS73_20","020_73_20","PSA","73","20","20","ⴰⵎ ⵜⴰⵔⵊⵉⵜ ⵖⴰⵔ ⵓⴼⴰⵇⵉ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⴰⴱⴻⵢⵢⴻⵏ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏⵙⴻⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴼⴰⵇⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS73_21","020_73_21","PSA","73","21","21","ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵣⴻⴳ ⵓⵍ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵉⵜⵜⴻⵊⵊⵓ ⴰⵢⵉ ⵍⴻⵃⵔⵉⵇ ⴷⵉ ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS73_22","020_73_22","PSA","73","22","22","ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵇⴻⴼⴼⵓⵃ, ⵜⵓⵖⴰ ⴰⵢⵉ ⵖⴰⵔⴻⴽ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⴱⵍⴰ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS73_23","020_73_23","PSA","73","23","23","ⵄⴰⴷ ⵎⴰⵛⴰ ⵍⴻⴱⴷⴰ ⴰⵇⴰ ⴰⵢⵉ ⵖⴰⵔⴻⴽ, ⵛⴻⴽ ⵜᵉⵟⵟⴼⴻⴷ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS73_24","020_73_24","PSA","73","24","24","ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴳⴻⵡⵡⴷⴻⴷ ⵙ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵛ ⵓ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⴽⵙⵉⴷ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS73_25","020_73_25","PSA","73","25","25","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰⵔⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵃⴰⵛⴰ ⵛⴻⴽ? ⴰⴽⵉⴷⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵢⵉ ⵜⴰⵔⴹⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS73_26","020_73_26","PSA","73","26","26","ⵎⴰⵍⴰ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵡⵓⵍ ⵉⵏⵓ ⵙⴻⵎⵎⵃⴻⵏ ⴷⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵡⵓⵍ ⵉⵏⵓ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS73_27","020_73_27","PSA","73","27","27","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⵊⴻⵏ ⴰⴷ ⴼⵏⴰⵏ. ⵛⴻⴽ ⴰⴷ ⵜⴽⴻⵃⵃⴻⴹⴻⴷ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⵜⵜⵃⴻⵢⵢⴰⴷⴻⵏ ⵓⵎⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS73_28","020_73_28","PSA","73","28","28","ⵏⴻⵛⵛ ⵎⴰⵛⴰ, ⵍⴷⴰⵙⴻⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵎⵍⵉⵃ ⵉ ⵏⴻⵛⵛ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴷ ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS74_1","020_74_1","PSA","74","1","1","ⴰⵅⴻⵎⵎⵉ ⵏ ⴰⵙⴰⴼ. ⵎⴰⵢⴻⵎⵎⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵏⴹⴰⵔⴻⴷ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵢⴰⵔⵖ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵅ ⵡⵓⴵⵉ ⵏ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS74_2","020_74_2","PSA","74","2","2","ⵅⴻⵎⵎⴻⵎ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴽⴻⵙⴱⴻⴷ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ ⵜⴻⵏⵏⵉ ⵜⴻⴼⴷⵉⴷ, ⴰⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵡⴻⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵜⵣⴻⴷⴷⵖⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS74_3","020_74_3","PSA","74","3","3","ⵙⴳⴻⵄⵄⴻⴷ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵛ ⵖⴰⵔ ⵎⵉⵏ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ⵍⴻⵄⴷⵓ ⵢⴰⵔⵔⴰ ⵎⴰⵔⵔⴰ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS74_4","020_74_4","PSA","74","4","4","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵙⵙⴱⵓⵄⵔⵓⵜⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ ⵏ ⵓⵎⵙⴰⴳⴰⵔ, ⵙⵙⴱⴻⴷⴷⴰⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵙⴻⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS74_5","020_74_5","PSA","74","5","5","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵛⵛⵡⴰⵇⴰⵔ ⴷⵉ ⵛⴱⴰⵔⵇ ⵉⵇⵇⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS74_6","020_74_6","PSA","74","6","6","ⵓ ⵅⴻⵏⵏⵉ ⴰⵔⵥⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵇⴰⵛⴻⵏ ⵏⵏⴻⵙ ⵊⵎⵉⵄ, ⵙ ⵛⵛⴰⵇⵓⵔ ⴷ ⵉⴼⴹⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS74_7","020_74_7","PSA","74","7","7","ⵏⵉⵜⵏⵉ ⵇⵇⴻⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⵄⴰⵔⵔⴰⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS74_8","020_74_8","PSA","74","8","8","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏⵜ ⵏⴰⵔⴻⴷⴷⴻⴵ ⵎⴰⵔⵔⴰ!” ⴰⵎⵎⵓ ⵉ ⵙⵙⴰⵔⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS74_9","020_74_9","PSA","74","9","9","ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⴻⵖ ⵡⴰⵔ ⵜⴻⵏⵜ ⵏⴻⵜⵜⵡⵉⵍⵉ ⵄⴰⴷ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵄⴰⴷ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵊⴰⵔ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏ ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS74_10","020_74_10","PSA","74","10","10","ⴰⵍ ⵎⴻⵍⵎⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵙⵜⴻⵀⵣⴰ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ? ⵎⴰ ⴰⴷ ⵉⵛⴻⵇⵇⴻⴼ ⵍⴻⵄⴷⵓ ⵉ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS74_11","020_74_11","PSA","74","11","11","ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵉⵙⵎⴻⵃ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ? ⵙⵓⴼⴼⵓⵖ ⵉ-ⵜ ⵣⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⴻⵛ, ⵇⴹⴰ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS74_12","020_74_12","PSA","74","12","12","ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS74_13","020_74_13","PSA","74","13","13","ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ ⵜⴼⴻⵜⵇⴻⴷ ⵍⴻⴱⵃⴰⵔ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵍⵀⴰⵢⵛⴰⵜ ⵜⴻⴷⴷⵣⴻⴷ ⵉ-ⵜⴻⵏ ⵅ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS74_14","020_74_14","PSA","74","14","14","ⵛⴻⴽ ⵜⵍⴻⴱⵣⴻⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ‘ⵍⵉ$ⵉⵢⴰⵜⴰⵏ’, ⵜⴻⵡⵛⵉⴷ ⵉ-ⵜ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS74_15","020_74_15","PSA","74","15","15","ⵛⴻⴽ ⵜⴼⴻⴵⵇⴻⴷ ⵍⵄⵓⵏⵚⴰⵔ ⴷ ⵜⴻⵖⵣⴰⵔⵜ, ⵛⴻⴽ ⵜⴻⵙⵙⵉⵥⵖⴻⴷ ⵉⵖⴻⵣⵔⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⴱⵍⴰ ⵇⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("PS74_16","020_74_16","PSA","74","16","16","ⴰⵙⵙ ⵏⵏⴻⵛ, ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⴵⵉⵍⴻⵜ, ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴷⵉⵏ ⵜⴰⴼⴰⵡⵜ ⴷ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS74_17","020_74_17","PSA","74","17","17","ⵛⴻⴽ ⵜⴻⵙⵙⵎⴻⵜⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵏⴻⴱⴷⵓ ⴷ ⵜⴳⴻⵔⵙⵜ ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵙⴻⵏ ⵜⵉⴼⵔⴰⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS74_18","020_74_18","PSA","74","18","18","ⵄⵇⴻⵍ ⵅ ⵎⴰⵏ ⴰⵢⴰ: ⵍⴻⵄⴷⵓ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵙⵉⴷⵉ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS74_19","020_74_19","PSA","74","19","19","ⵡⴰⵔ ⵜⵜⵉⵛ ⵍⴻⵄⵎⴰⵔ ⵏ ⵜⴻⵊⵍⵉⵍⵍⴻⵃⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⵡⵃⵓⵛ, ⵡⴰⵔ ⵜᵉⵜⵜⵓ ⵉ ⵍⴻⴱⴷⴰ ⵜⵓⴷⴰⵔⵜ ⵏ ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS74_20","020_74_20","PSA","74","20","20","ⵅⵣⴰⵔ ⵖⴰⵔ ⵍⵄⴰⵀⴷ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵟⵟⵍⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵄⴻⵎⵎⴰⵔⴻⵏⵜ ⵙ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("PS74_21","020_74_21","PSA","74","21","21","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵙ ⵓⵙⴻⴹⵃⵉ, ⴻⵊⵊ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⴰⴹ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS74_22","020_74_22","PSA","74","22","22","ⴽⴽⴰⵔ ⴱⴻⴷⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴱⴻⵍⵍⴻⵄ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵛ, ⵅⴻⵎⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴰⵙⵙ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS74_23","020_74_23","PSA","74","23","23","ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓ ⵛⴰ ⴰⵖⵓⵢⵢⵉ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵛ, ⴰⵙⴱⵓⵄⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵅⴰⴽ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⴱⵍⴰ ⴰⵇⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("PS75_1","020_75_1","PSA","75","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ‘ⵡⴰⵔ ⵜⵜⴰⵔⴻⴷⴷⴻⴵ!’ ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ⵉⵣⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS75_2","020_75_2","PSA","75","2","2","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵇⴰⴷⴰ ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵜⵜⵇⴰⴷⴰ! ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵢⵓⴷⴻⵙ, ⴰⵇⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS75_3","020_75_3","PSA","75","3","3","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵅⴹⴰⵔⴻⵖ ⵍⵃⴰⵍ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴰⴷ ⴳⴳⴻⵖ ⵛⵛⵔⴻⵄ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS75_4","020_75_4","PSA","75","4","4","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵜⴻⴼⵙⵉⵢ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵎⴻⵜⵜⵏⴻⵖ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS75_5","020_75_5","PSA","75","5","5","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ!”, ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ: “ⵡⴰⵔ ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵎ ⵉⵛⵛ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("PS75_6","020_75_6","PSA","75","6","6","ⵡⴰⵔ ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵎ ⵉⵛⵛ ⵏⵡⴻⵎ ⴰⵎⵎⵓ ⵙⴻⵏⵏⴻⵊ, ⵡⴰⵔ ⵙⵙⴰⵡⴰⵍⴻⵎ ⵙ ⵏⵏⴼⴰⵅⴻⵜ!” ");
INSERT INTO rift_vpl VALUES ("PS75_7","020_75_7","PSA","75","7","7","ⵎⴰⵖⴰⵔ ⴰⵙⴳⴻⵄⵄⴻⴷ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵣⵉ ⵛⵛⴰⵔⵇ, ⵏⵉⵖ ⵣⵉ ⵍⵖⴰⵔⴱ ⵓⵍⴰ ⵣⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS75_8","020_75_8","PSA","75","8","8","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⵇⴰⴹⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵙᵉⵀⴻⴽⴽⵯⴰ ⵉⵊⵊⴻⵏ ⵓ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS75_9","020_75_9","PSA","75","9","9","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⴱⵉⵏⵓ ⵉⵜⵜⴻⴳⴳ ⴽⵓⴼⴼⵓ, ⵉⵜⵜⵡⴰⵅⴻⴵⴰⴹ ⵎⴰⵔⵔⴰ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⴽⴻⴱⴱⴰ ⵣⵣⴰⵢⴻⵙ. ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵥⴻⵎⵎⴻⵏ ⵓⵍⴰ ⴷ ⵍⴻⵅⵎⵉⵔⴰ ⵏⵏⴻⵙ ⵓⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS75_10","020_75_10","PSA","75","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴱⴰⵔⵔⵃⴻⵖ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS75_11","020_75_11","PSA","75","11","11","ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵎⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS76_1","020_76_1","PSA","76","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ, ⵉⵣⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS76_2","020_76_2","PSA","76","2","2","ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS76_3","020_76_3","PSA","76","3","3","ⴰⵄⵓⵛⵛⵉ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷⵉ ⵛⴰⵍⵉⵎ, ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⴷⵉ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS76_4","020_76_4","PSA","76","4","4","ⴷⵉⵏⵏⵉ ⵢⴰⵔⵥⴰ ⴼⵍⵉⵜⵛⴰⵜ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵏ ⵍⵇⴻⵡⵙ, ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⴷ ⵙⵙⵉⴼ ⵓⵍⴰ ⴷ ⴰⵎⴻⵏⵖⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS76_5","020_76_5","PSA","76","5","5","ⵜⴻⵙⵙⴰⴳⴳⵯⴰⴷⴻⴷ ⵓ ⵜⵊⴻⵀⴷⴻⴷ ⵉ ⵜⴻⴵⵉⴷ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏⵏⵉ ⵉⵎⵎⴻⵥⵔⴻⵏ ⴷⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("PS76_6","020_76_6","PSA","76","6","6","ⵉⵏⵏⵉ ⵉⵣⴻⵄⵄⴰⵎⴻⵏ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ. ⵏⵉⵜⵏⵉ ⵏⵏⵓⴷⵎⴻⵏ, ⵟⵟⵚⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵎⵄⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS76_7","020_76_7","PSA","76","7","7","ⵙ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵖⴰⵔⵇ ⵓⴽⴰⵔⵔⵓ ⴷ ⵓⵢⵉⵙ ⴷⴻⴳ ⵢⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PS76_8","020_76_8","PSA","76","8","8","ⵛⴻⴽ, ⵡⴰⵀ, ⵛⴻⴽ ⵜⴻⵙⵙⴰⴳⴳⵯⴰⴷⴻⴷ, ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS76_9","020_76_9","PSA","76","9","9","ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵜⴻⴳⴳⵉⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⵓⴽⵎ. ⵜⴻⵟⵟⴻⴼ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵜⴻⵙⵙⴻⵖⴷ, ");
INSERT INTO rift_vpl VALUES ("PS76_10","020_76_10","PSA","76","10","10","ⵓⵎⵉ ⵉⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴻⴽⴽ ⵎⴰⵔⵔⴰ ⵉⵎⵀⵉⵏⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS76_11","020_76_11","PSA","76","11","11","ⵎⴰⵖⴰⵔ ⴰⴼⵓⴳⴻⵎ ⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⵢⴰⵡⵉ ⴰⵇⴰⴷⵉ ⵉ ⵛⴻⴽ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⵏ ⵡⴻⵙⵄⴰⵔ ⴰⴷ ⵜ ⵜⵎⴻⵏⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS76_12","020_76_12","PSA","76","12","12","ⵡⵛⴻⵎ ⵍⵡⵓⵄⵓⴷ ⵓ ⴳⴳⴻⵎ ⵣⵣⴰⵢⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵚⵚⴷⴰⵇⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⵯⴻⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS76_13","020_76_13","PSA","76","13","13","ⵡⴻⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⴱⵓⵃⴱⴻⵍⴰⵜ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⵯⴷⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS77_1","020_77_1","PSA","77","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵢⴰⴷⵓⵜⵓⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("PS77_2","020_77_2","PSA","77","2","2","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵍⴰⵖⵉⵖ, ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS77_3","020_77_3","PSA","77","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⴰⵔⵣⵓⵖ ⵙⵉⴷⵉ ⵉⵏⵓ. ⵙ ⴵⵉⵍⴻⵜ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⴰⵔⵅⵓⵖ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵢⵓⴳⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴻⵣⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("PS77_4","020_77_4","PSA","77","4","4","ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵉⴷⴰⵔⴻⵖ ⴰⵔⴻⴱⴱⵉ, ⵅⴻⵏⵏⵉ ⵜⵜⵣⴻⵀⵀⴰⵔⴻⵖ, ⵜⵜⵅⴻⵎⵎⴰⵎⴻⵖ, ⵓⵛⴰ ⵢⴰⵔⵅⵓ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS77_5","020_77_5","PSA","77","5","5","ⵛⴻⴽ ⵜⴰⵔⵔⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⴼⴰⵇⴻⵏⵜ, ⵏⵏⵀⴻⵡⵍⴻⵖ, ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS77_6","020_77_6","PSA","77","6","6","ⵏⴻⵛⵛ ⵜⵜⵅⴻⵎⵎⴰⵎⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS77_7","020_77_7","PSA","77","7","7","ⵏⴻⵛⵛ ⵜⵜⵉⴷⴰⵔⴻⵖ ⴷⴻⴳ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ ⵉⵏⵓ ⵙ ⴵⵉⵍⴻⵜ, ⵅⵎⵉ ⵜⵜⵅⴻⵎⵎⴰⵎⴻⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵓ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵢⴰⵔⴻⵣⵣⵓ: ");
INSERT INTO rift_vpl VALUES ("PS77_8","020_77_8","PSA","77","8","8","ⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵏⴹⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⵃⵉⵏⵏⵉ ⵄⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("PS77_9","020_77_9","PSA","77","9","9","ⵎⴰ ⵜⴱⴻⴷⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰ ⵉⵜⵜⵡⴰⴱⴹⴻⵍ ⵡⴰⵡⴰⵍ ⵉ ⵉⴵⴰⵏ ⵣⵉ ⵊⵊⵉⵍ ⵉ ⵊⵊⵉⵍ ⵏⵏⴻⵖⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("PS77_10","020_77_10","PSA","77","10","10","ⵎⴰ ⵉⵜⵜⵓ ⴰⵔⴻⴱⴱⵉ ⴰⵃⵉⵏⵏⵉ ⵏⵏⴻⵙ? ⵎⴰ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ?” ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS77_11","020_77_11","PSA","77","11","11","ⵏⵏⵉⵖ: “ⵡⴰ ⴷ ⵍⴻⵄⴷⴰⴱ ⵉⵏⵓ, ⴰⵇⴰ ⴷ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ.” ");
INSERT INTO rift_vpl VALUES ("PS77_12","020_77_12","PSA","77","12","12","ⵏⴻⵛⵛ ⴰⴷ ⵉⴷⴰⵔⴻⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵄⴻⵇⵍⴻⵖ ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ ⵏ ⵣⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("PS77_13","020_77_13","PSA","77","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵎⵎⴰⵎⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS77_14","020_77_14","PSA","77","14","14","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⴰⵇⴰ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ ⵉ ⵢⴻⴵⴰ! ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("PS77_15","020_77_15","PSA","77","15","15","ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS77_16","020_77_16","PSA","77","16","16","ⵛⴻⴽ ⵜⴻⴼⴷⵉⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵓⵖⵉⵍ ⵏⵏⴻⵛ, ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵙⵓⴼ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS77_17","020_77_17","PSA","77","17","17","ⴰⵎⴰⵏ ⵥⵔⵉⵏ ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⴰⵏ ⵥⵔⵉⵏ ⵛⴻⴽ ⵓⵛⴰ ⴰⵔⵊⵉⵊⴻⵏ, ⵡⴰⵀ, ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵏⵏⵀⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS77_18","020_77_18","PSA","77","18","18","ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⴷⴻⵇⵇⵍⴻⵏ ⴼⴰⵔⵔⵖⴻⵏ-ⴷⴷ ⴰⵎⴰⵏ ⵏⵙⴻⵏ, ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵓ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ ⴹⵡⵉⵏⵜ ⴷⴰ ⴷ ⴷⵉⵀⴰ.    ");
INSERT INTO rift_vpl VALUES ("PS77_19","020_77_19","PSA","77","19","19","ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵜⴻⴳⴳⴰ ⴰⵎ ⵡⴰⵊⵊⴰⵊ ⴷⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⴰⵙⵙⴰⵎⴻⵏ ⴳⴳⵉⵏ ⵜⴰⴼⴰⵡⵜ ⵅ ⴷⴷⵓⵏⴻⵛⵜ, ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵏⵀⴻⵣⵣ ⵜⴰⵔⵊⵉⵊ. ` ");
INSERT INTO rift_vpl VALUES ("PS77_20","020_77_20","PSA","77","20","20","ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵉⵛⵓⵇ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⴰⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⵉⵚⵓⵔⴰⴼ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⴱⵉⵏⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS77_21","020_77_21","PSA","77","21","21","ⵛⴻⴽ ⵜⵏⴻⴷⵀⴻⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ, ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_1","020_78_1","PSA","78","1","1","ⴰⵅⴻⵎⵎⵉ ⵏ ⴰⵙⴰⴼ. ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ! ⵎⴻⵢⵢⵍⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵡⴻⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS78_2","020_78_2","PSA","78","2","2","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵏ ⵉⵏⵓ ⵙ ⵡⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("PS78_3","020_78_3","PSA","78","3","3","ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵏⴻⵙⵍⴰ ⵓ ⵏⴻⵙⵙⴻⵏ, ⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵃⴰⵊⴰⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS78_4","020_78_4","PSA","78","4","4","ⵡⴰⵔ ⵜⴻⵏ ⵏᵉⵜⵜⴻⴼⴼⴰⵔ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵣⵉ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ⴰⴷ ⵏⴱⴰⵔⵔⴻⵃ ⵙ ⵜⵎⴻⴳⴳⴰ ⵉⵚⴻⴱⴱⵃⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_5","020_78_5","PSA","78","5","5","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⵉ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⵙⴰⵔⵙ ⵉⵛⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵙⵙⵖⴰⵔⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS78_6","020_78_6","PSA","78","6","6","ⵎⴰⵃⴻⵏⴷ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⵓ ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵜⵜ ⵙⵙⴻⵄⴷⵓⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS78_7","020_78_7","PSA","78","7","7","ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵍⴰⵎⴰⵏ ⵏⵙⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓⵏ ⵛⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵃⴹⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS78_8","020_78_8","PSA","78","8","8","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⴰⵖⴻⵏⵏⴰⵏ ⴷ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵙ ⵡⵓⵍ ⵡⴰⵔ ⵉⵎⵜⴻⵏ ⵓ ⵙ ⴰⵔⵔⵓⵃ ⵉⵖⴷⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS78_9","020_78_9","PSA","78","9","9","ⴰⵢⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ, ⵄⴻⵇⴱⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS78_10","020_78_10","PSA","78","10","10","ⵡⴰⵔ ⵃⴹⴰⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ, ⵓⴳⵉⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_11","020_78_11","PSA","78","11","11","ⵜⵜⵓⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵜⵉⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_12","020_78_12","PSA","78","12","12","ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵜ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵚⵓⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_13","020_78_13","PSA","78","13","13","ⵏⴻⵜⵜⴰ ⵉⴱⴹⴰ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴻⵥⵡⴰ ⵜⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵉⵊⵊⴰ ⴰⵎⴰⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⴰⵎ ⵡⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS78_14","020_78_14","PSA","78","14","14","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵉ-ⵜⴻⵏ ⵙ ⵡⴰⵙⵙ ⵙ ⵓⵙⴻⵢⵏⵓ, ⵙ ⴵⵉⵍⴻⵜ ⵎⴰⵔⵔⴰ ⵙ ⵜⴼⴰⵡⵜ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PS78_15","020_78_15","PSA","78","15","15","ⵏⴻⵜⵜⴰ ⵉⴱⴹⴰ ⵍⴻⵊⵔⵓⴼ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⵡⵛⴰ ⵉ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵙⵓ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⴰⵎⴻⵛⵏⴰⵡ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_16","020_78_16","PSA","78","16","16","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⴰⴷ ⴼⴻⵢⵢⴹⴻⵏⵜ ⵣⵉ ⵙⵙⴻⴵⴰⵃ, ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⴰⵎⴰⵏ ⴰⴷ ⵀⵡⴰⵏ ⴰⵎ ⵢⵉⵖⴻⵣⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_17","020_78_17","PSA","78","17","17","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⵏⵉⵏ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵅⴰⵙ, ⵖⴻⵡⵡⵖⴻⵏ ⵅ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ ⵢⵓⵥⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_18","020_78_18","PSA","78","18","18","ⵏⵉⵜⵏⵉ ⵊⴰⵔⵔⴱⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⵓⵎⵉ ⵜⵜⴰⵔⴻⵏ ⵎⴰⵛⵛⴰ ⵖⴰⵔ ⵎⴻⵥⵔⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_19","020_78_19","PSA","78","19","19","ⵙⵙⵉⵡⵍⴻⵏ ⴹⵉⴷⴷ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵏⵏⴰⵏ: “ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵟⵟⴰⴱⵍⴰ ⴷⵉ ⵍⴻⵅⵍⴰ? ");
INSERT INTO rift_vpl VALUES ("PS78_20","020_78_20","PSA","78","20","20","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⴷⵉ ⵜⴻⵚⴹⴰⵔⵜ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵓⵣⵣⵍⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵎⴰⵏ ⴷ ⵉⵖⴻⵣⵔⴰⵏ. ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵛ ⴰⵖⵔⵓⵎ ⵏⵉⵖ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵢⵙⵓⵎ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("PS78_21","020_78_21","PSA","78","21","21","ⵙ ⵓⵢⴰ ⵉⵙⵍⴰ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴼⴼⵓⴳⴻⵎ. ⵜⵉⵎⴻⵙⵙⵉ ⵜⴰⵔⵖⴰ ⴹⵉⴷⴷ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("PS78_22","020_78_22","PSA","78","22","22","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵎ ⵛⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⵜⵛⵉⵍⵉⵏ ⴷⴻⴳ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_23","020_78_23","PSA","78","23","23","ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵓ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_24","020_78_24","PSA","78","24","24","ⵉⴼⴰⵔⵔⴻⵖ-ⴷⴷ ⵅⴰⵙⴻⵏ ‘ⵎⴰⵏⵏⴰ’ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⵛⴻⵏ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⵎⴻⵏⴷⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_25","020_78_25","PSA","78","25","25","ⵎⴰⵔⵔⴰ ⵛⵛⵉⵏ ⴰⵖⵔⵓⵎ ⵏ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵍⵄⴻⵣⵣ. ⵉⵙⵙⴻⴽⴽ ⴰⵙⴻⵏ ⵎⴰⵛⵛⴰ ⵏⵙⴻⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⴰⵍⴰⵎⵉ ⵊⵊⵉⵡⵏⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("PS78_26","020_78_26","PSA","78","26","26","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⴷ ⵉⴽⴽⴰⵔ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS78_27","020_78_27","PSA","78","27","27","ⵉⵊⵊⴰ ⴰⵢⵙⵓⵎ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵉⵡⴹⴰ ⴰⵎ ⵡⴻⵏⵥⴰⵔ ⵏ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⵉⵊⴹⴰⴹ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⴰⵎ ⵢⵉⵊⴷⵉ ⵏ ⵍⴻⴱⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("PS78_28","020_78_28","PSA","78","28","28","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵡⴹⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_29","020_78_29","PSA","78","29","29","ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⵓ ⵊⵊⵉⵡⵏⴻⵏ ⵇⴰⵄ, ⴽⵙⵉⵏ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⴹⴻⵎⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_30","020_78_30","PSA","78","30","30","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵡⴻⴹⵎⴰⵄ ⵏⵙⴻⵏ, ⵎⴰⵛⵛⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS78_31","020_78_31","PSA","78","31","31","ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⵉⴽⴽⴰⵔ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵇⴻⴱⴱⵓⵣⴻⵏ ⵇⴰⵄ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS78_32","020_78_32","PSA","78","32","32","ⵎⴰⵛⴰ ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⴰⵔⵏⵉⵏ ⴳⴳⵉⵏ ⴷⴷⵏⵓⴱ, ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⴷⵉ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_33","020_78_33","PSA","78","33","33","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ ⴰⴷ ⵄⴷⵓⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴻⴼⵡⴰⵔ, ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵄⵓⵔⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS78_34","020_78_34","PSA","78","34","34","ⵅⵎⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵏⴻⵖ, ⴰⵔⵣⵓⵏ ⵅ ⴰⵔⴻⴱⴱⵉ, ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⴰⵔⵣⵓⵏ ⵅⴰⵙ ⵙ ⵛⴹⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS78_35","020_78_35","PSA","78","35","35","ⵏⵉⵜⵏⵉ ⵄⴻⵇⵍⴻⵏ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏⵙⴻⵏ, ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⴷ ⴰⵎⴻⴼⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_36","020_78_36","PSA","78","36","36","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⵣⵣⴰⵜⴻⵙ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵙ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_37","020_78_37","PSA","78","37","37","ⵡⴰⵔ ⵜⵓⵖⵉ ⵓⵍ ⵏⵙⴻⵏ ⵉⵎⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⵙ ⵍⵎⴰⵏⴻⵜ ⴰⴽ-ⴷ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_38","020_78_38","PSA","78","38","38","ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵃⵃⴻⵎ ⴷⴰⵢⵙⴻⵏ ⵓ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵢⴰⵔⴻⴷⴷⴻⴵ, ⵎⴰⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⵊⵊⴰ ⵣⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⴳⴳⵉ ⵎⴰⵔⵔⴰ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⴽⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS78_39","020_78_39","PSA","78","39","39","ⵏⴻⵜⵜⴰ ⵉⵄⵇⴻⵍ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵎⵖⵉⵔ ⴷ ⴰⵢⵙⵓⵎ ⵡⴰⵀⴰ, ⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵉⵄⴻⴷⴷⵓ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵄⵉⵇⵇⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("PS78_40","020_78_40","PSA","78","40","40","ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵙⵄⴰⵔⴻⵏ ⵜ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴳⴳⵉⵏ ⴰⵙ ⵍⴻⵃⵔⵉⵇ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ! ");
INSERT INTO rift_vpl VALUES ("PS78_41","020_78_41","PSA","78","41","41","ⵜⵡⴰⵍⴰ ⴰⵡⴰⵔⵏⵉ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ ⵇⴻⴵⴱⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⴳⴳⵉⵏ ⵍⴻⵃⵔⵉⵇ ⵉ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS78_42","020_78_42","PSA","78","42","42","ⵡⴰⵔ ⵅⴰⵔⵔⵚⴻⵏ ⵛⴰ ⵄⴰⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏ ⵉⴼⴷⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵃⵚⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS78_43","020_78_43","PSA","78","43","43","ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵓⵍⴰ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵚⵓⵄⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS78_44","020_78_44","PSA","78","44","44","ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵡⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS78_45","020_78_45","PSA","78","45","45","ⵉⵙⵙⴻⴽⴽ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵢⵍⴰⴼ ⵏ ⵉⴱⴻⵄⵄⴰⵛ ⵉ ⵜⴻⵏ ⵉⵛⵛⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⵏⵏⵉ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_46","020_78_46","PSA","78","46","46","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ ⵉ ⵜⵎⵓⵖⵔⵉ ⵉⵚⴰⵔⵔⴹⴻⵏ, ⵓⵍⴰ ⴷ ⵚⵚⴰⴱⴻⵜ ⵏⵙⴻⵏ ⵉ ⵜⵎⵓⵖⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS78_47","020_78_47","PSA","78","47","47","ⵉⵏⵖⴰ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏⵙⴻⵏ ⵙ ⵜⴻⴱⵔⵓⵔⵔⵉ, ⵓⵍⴰ ⴷ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵏⵙⴻⵏ ⵙ ⵜⴽⴻⴹⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_48","020_78_48","PSA","78","48","48","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵍⵎⴰⵍ ⵏⵙⴻⵏ ⵉ ⵓⴱⵔⵓⵔⵉ, ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ ⵉ ⵡⴰⵙⵙⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_49","020_78_49","PSA","78","49","49","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵊⴰⵔ ⴰⵙⴻⵏ, ⴰⵎⵓⵣⵣⴰⵔ ⴷ ⵜⴻⴼⵇⴻⵃⵜ ⴷ ⵍⵃⴻⵚⵔⴰⵏ, ⵓⵎⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵙ ⵊⵊⵔⴰⵢⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PS78_50","020_78_50","PSA","78","50","50","ⵏⴻⵜⵜⴰ ⵉⵙⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵔⴰⵇ ⵉ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵙⵙⵄⵉⵣⵣ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⵍⵎⴻⵡⵜ, ⵉⵙⵙⴻⵄⴷⵓ ⵍⵎⴰⵍ ⵏⵙⴻⵏ ⵉ ⵟⵟⴰⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_51","020_78_51","PSA","78","51","51","ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵉⵎⴻⵏⵣⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵔⵢⴰⵙⵜ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏ ⵃⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS78_52","020_78_52","PSA","78","52","52","ⵉⴳⴳⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵡⵓⴵⵉ, ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵉ-ⵜⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_53","020_78_53","PSA","78","53","53","ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵡⴰⵔ ⴳⴳⵯⵉⴷⴻⵏ ⵡⴰⵍⵓ, ⵎⴰⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵉⴷⵍⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_54","020_78_54","PSA","78","54","54","ⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ-ⴰ ⵏⵏⵉ ⴷ ⵉⴽⵙⴻⴱ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_55","020_78_55","PSA","78","55","55","ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⴻⴳⵏⵓⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵉⴳⴳⴰ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵜⴻⴽⴽⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵙ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵓⵛⴰ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_56","020_78_56","PSA","78","56","56","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴻⴵⴱⴻⵏ ⵜ, ⵙⵄⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⵀⴹⵉⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_57","020_78_57","PSA","78","57","57","ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴳⴳⵉⵏ ⵙ ⵍⴻⵖⴷⴰⵔ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴻⴷⴷⴰⵔⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⴼⵍⵉⵜⵛⴰ ⵏ ⵍⵇⴻⵡⵙ ⵉ ⵉⵜⴻⴼⴼⵖⴻⵏ ⵙ ⵍⴻⵅⴷⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PS78_58","020_78_58","PSA","78","58","58","ⵙⵄⴰⵔⴻⵏ ⵜ ⵙ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵙⴻⵏ ⵉ ⵅ ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ, ⴰⵔⵔⵉⵏ ⵜ ⴰⴷ ⵢⴰⵙⴻⵎ ⵙ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ ");
INSERT INTO rift_vpl VALUES ("PS78_59","020_78_59","PSA","78","59","59","ⴰⵔⴻⴱⴱⵉ ⵉⵙⵍⴰ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵉⴷⵡⴻⵍ ⵉⵄⵉⴼⴼ ⴰⵟⵟⴰⵙ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS78_60","020_78_60","PSA","78","60","60","ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⴷⵉ ⵛⵉⵍⵓ, ⴰⵇⵉⴹⵓⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⵊⴰⵔ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_61","020_78_61","PSA","78","61","61","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵓⵍⴰ ⴷ ⵜⴰⵍⵡⵉⵣⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵜ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_62","020_78_62","PSA","78","62","62","ⵏⴻⵜⵜⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉ ⵙⵙⵉⴼ, ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_63","020_78_63","PSA","78","63","63","ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵛⵛⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ, ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵉⵖⴻⵏⵏⵉⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS78_64","020_78_64","PSA","78","64","64","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵙⴻⵏ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⵜⵉⵊⵊⴰⵍ ⵏⵙⴻⵏ ⵡⴰⵔ ⵔⵓⵏⵜ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_65","020_78_65","PSA","78","65","65","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵇ-ⴷⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵎ ⵛⴰ ⵏ ⵉⵊⵊ ⵉ ⵜⵓⵖⴰ ⵉⵟⵟⵚⴻⵏ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ ⵉⵙⵖⵓⵢⵢⵓ ⵣⵉ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS78_66","020_78_66","PSA","78","66","66","ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵉⵏⵏⵉ ⵜ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵉⴳⴳⴰ ⴷⴰⵢⵙⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_67","020_78_67","PSA","78","67","67","ⴰⵇⵉⴹⵓⵏ ⵏ ⵢⵓⵙⵓⴼ ⵉⵏⴹⴰⵔ ⵉ-ⵜ, ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵡⴰⵔ ⵜⵜ ⵉⴼⴰⵔⵣ. ");
INSERT INTO rift_vpl VALUES ("PS78_68","020_78_68","PSA","78","68","68","ⵉⴼⴰⵔⵣ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_69","020_78_69","PSA","78","69","69","ⵉⴱⵏⴰ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵉⵊⴻⵏⵡⴰⵏ ⵢⵓⵄⵍⴰⵏ, ⴰⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS78_70","020_78_70","PSA","78","70","70","ⵉⴼⴰⵔⵣ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⴰⵡⵓⴷ, ⵉⴽⵙⵉ ⵜ ⵣⵉ ⵍⴽⵓⵔⵉⵜ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("PS78_71","020_78_71","PSA","78","71","71","ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵉ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵡⵓⴵⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⵢⴰⵄⵇⵓⴱ, ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵉⵙⵔⴰⵉⵍ, ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS78_72","020_78_72","PSA","78","72","72","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵙ ⵉ-ⵜⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵉⴳⴻⵡⵡⴻⴷ ⵉ-ⵜⴻⵏ ⵙ ⵓⴼⵓⵙ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS79_1","020_79_1","PSA","79","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ⴰ ⴰⵔⴻⴱⴱⵉ, ⵍⴻⴳⵏⵓⵙ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ. ⵏⵉⵜⵏⵉ ⵙⵙⵅⴻⵎⵊⴻⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵔⵔⵉⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS79_2","020_79_2","PSA","79","2","2","ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵡⵛⵉⵏ ⵜⴻⵏⵜ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⵢⵙⵓⵎ ⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵛ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS79_3","020_79_3","PSA","79","3","3","ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵣⴻⴵⵄⴻⵏ ⵜⴻⵏ ⴰⵎ ⵡⴰⵎⴰⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS79_4","020_79_4","PSA","79","4","4","ⵏⴻⴷⵡⴻⵍ ⴷ ⵍⴻⴼⴷⵉⵃⴻⵜ ⵉ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵖ, ⴷ ⵓⵙⵜⴻⵀⵣⵉ ⴷ ⵓⵙⴻⵃⵇⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS79_5","020_79_5","PSA","79","5","5","ⴰⵔ ⵎⴻⵍⵎⵉ, ⴰ ⵙⵉⴷⵉ? ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⵙⴻⵄⵄⴰⵔⴻⴷ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰ ⴰⴷ ⵜⴰⵔⴻⵖ ⵜⵓⵙⵎⵉ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵉ ⵍⴻⴱⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("PS79_6","020_79_6","PSA","79","6","6","ⴼⴰⵔⵔⴻⵖ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵅ ⵍⴻⴳⵏⵓⵙ ⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵉⵏⴻⵏ, ⵅ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵖⵉⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS79_7","020_79_7","PSA","79","7","7","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⵔⴻⴷⴷⴵⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS79_8","020_79_8","PSA","79","8","8","ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵄⴻⵇⵇⴻⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵏ ⵣⵉⵛ. ⵇⴻⴵⴻⵇ, ⴻⵊⵊ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵜⴻⵎⵙⴰⴳⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⴹⵄⴻⴼ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS79_9","020_79_9","PSA","79","9","9","ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵓ ⵙⴻⵚⵍⴻⵃ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS79_10","020_79_10","PSA","79","10","10","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⵏⵉⵏ ⵍⴻⴳⵏⵓⵙ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ?” ⴻⵊⵊ ⴰⵏⵜⴰⵇⴻⵎ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS79_11","020_79_11","PSA","79","11","11","ⴻⵊⵊ ⴰⵣⴻⵀⵀⴰⵔ ⵏ ⵓⵎⴻⵃⴱⵓⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵃⴹⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⵎⴻⵡⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵖⵉⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS79_12","020_79_12","PSA","79","12","12","ⴰⵔⵔ ⴰⵙⴻⵏ ⵉ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵖ ⴰⴱⴻⵀⴷⴻⵍ ⵏⵙⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵖⴰⵔ ⵡⴻⵃⵙⵉⵏ ⵏⵙⴻⵏ, ⴰⴱⴻⵀⴷⴻⵍ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵛⴻⴽ ⴼⴻⴹⵃⴻⵏ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS79_13","020_79_13","PSA","79","13","13","ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵡⵓⴵⵉ ⵏ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵛ. ⵏⴻⵜⵜⵇⴰⴷⴰ ⵛⴻⴽ ⵉ ⵍⴻⴱⴷⴰ, ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴱⴰⵔⵔⴻⵃ ⵛⵛⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS80_1","020_80_1","PSA","80","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵜⵍⵉⵍⵍⵉⵛⵉⵏ’. ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⴰⵙⴰⴼ. ⴰⵣⴻⵀⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS80_2","020_80_2","PSA","80","2","2","ⵙⴻⵍ, ⴰ ⴰⵎⴻⴽⵙⴰⵡ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴽⴽⵡⴻⵙⴻⵏ ⵢⵓⵙⵓⴼ ⴰⵎ ⵡⵓⴵⵉ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵅ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⴱⴰⵏ-ⴷⴷ ⴷⵉ ⵜⵉⵙⵙⵉⵇⵜ! ");
INSERT INTO rift_vpl VALUES ("PS80_3","020_80_3","PSA","80","3","3","ⵙⴻⴽⴽⴰⵔ ⵊⵊⴻⵀⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴷ ⵎⴰⵏⴰⵙⵙⴰ, ⴰⵙ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴼⴻⴽⴽⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS80_4","020_80_4","PSA","80","4","4","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ, ⴻⵊⵊ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⴰⵔⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("PS80_5","020_80_5","PSA","80","5","5","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⴷ ⵜᵉⵜⵜⵅⴻⵢⵢⴰⵇⴻⴷ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS80_6","020_80_6","PSA","80","6","6","ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵛⴻⴷ ⵜⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵜⴰⵔⵔⵉⴷ ⵜⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS80_7","020_80_7","PSA","80","7","7","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵏⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⵛⴰⵎⵎⴰ ⵏ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⵉ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵖ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ ⵙⵜᵉⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS80_8","020_80_8","PSA","80","8","8","ⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴻⵊⵊ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⴰⵔⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("PS80_9","020_80_9","PSA","80","9","9","ⵛⴻⴽ ⵜⵇⴻⵍⵄⴻⴷ ⵉⵛⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵜⵓⵥⵥⵍⴻⴷ ⵅ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⵜⴻⵥⵥⵓⴷ-ⵉ-ⵜⵜ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS80_10","020_80_10","PSA","80","10","10","ⵛⴻⴽ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⵙ ⴰⵎⵛⴰⵏ ⵓ ⵜⴰⵔⵔⵉⴷ ⵜⵜ-ⵉ-ⴷⴷ ⴰⴷ ⵜⴻⵡⵡⴻⵜ ⵉⵥⴻⵡⵔⴰⵏ, ⵜⵄⴻⵎⵎⴰⵔ ⵜⵣⴰⵢⴰⵔⵜ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS80_11","020_80_11","PSA","80","11","11","ⵜⵜⵡⴰⵙⵙⴷⵓⵔⵢⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵙ ⵜⵉⵍⵉ ⵏⵏⴻⵙ, ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS80_12","020_80_12","PSA","80","12","12","ⵜⴻⴳⴳⴰ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⴰⵡⴹⴻⵏⵜ ⴰⵍ ⵍⴻⴱⵃⴰⵔ, ⵉⴼⴻⵜⵡⴰⵏ ⵏⵏⴻⵙ ⵉⵣⵉⵢⵣⴰⵡⴻⵏ ⴰⵍ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("PS80_13","020_80_13","PSA","80","13","13","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵖⴻⴹⵍⴻⴹ ⵉⵖⴻⴱⵔⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵍⴻⵇⵇⴹⴻⵏ ⵜⵜ? ");
INSERT INTO rift_vpl VALUES ("PS80_14","020_80_14","PSA","80","14","14","ⵉⵍⴻⴼ ⵣⴻⴳ ⵡⴻⵣⵖⴰⵔ ⵉⵇⵍⴻⴱ ⵜⴰⵣⴰⵢⴰⵔⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⵇⴰ ⵉⵀⴷⴰ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PS80_15","020_80_15","PSA","80","15","15","ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ, ⵙⵉⵊⵊ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓ ⵅⵣⴰⵔ, ⴰⵔⵣⴻⴼ ⵜⴰⵣⴰⵢⴰⵔⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("PS80_16","020_80_16","PSA","80","16","16","ⵜⵜⵀⵉⵍⵍⴰ ⴷⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵉⵥⵥⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ, ⴷⵉ ⵎⵎⵉⵛ ⵏⵏⵉ ⵜⴻⵙⵙⵊⴻⵀⴷⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS80_17","020_80_17","PSA","80","17","17","ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵜᵉⵜⵜⵡⴰⵇⴹⴻⵄ. ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴻⴷ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS80_18","020_80_18","PSA","80","18","18","ⴻⵊⵊ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ, ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵜⴻⵙⵙⵊⴻⵀⴷⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS80_19","020_80_19","PSA","80","19","19","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⴽ ⵏⵃⴻⵢⵢⴻⴷ ⵛⴰ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴷⴷⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵍⴰⵖⴰ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS80_20","020_80_20","PSA","80","20","20","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ, ⴻⵊⵊ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⴰⵔⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("PS81_1","020_81_1","PSA","81","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ⵓⵊⵉⵜⵜⵉ, ⴰⵔⵢⴰⵣ ⵣⵉ ⵊⴰⵜ. ⵏ ⴰⵙⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("PS81_2","020_81_2","PSA","81","2","2","ⵙⵍⵉⵡⵍⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵊⵊⴻⵀⴷ ⵏⵏⴻⵖ, ⴷⵓⵇⵇⵣⴻⵎ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS81_3","020_81_3","PSA","81","3","3","ⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵛⵜ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ, ⴰⵡⵉ ⴰⴱⴻⵏⴷⵉⵔ, ⵍⴳⴰⵎⴱⵔⵉ ⵎⵉⵥⵉⴷ ⴷ ⵍⵀⴰⵔⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("PS81_4","020_81_4","PSA","81","4","4","ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵖⴰⵔ ⵓⴱⴻⴷⴷⵉ ⵏ ⵓⵢⵓⵔ, ⵖⴰⵔ ⵜⵣⵉⵔⵉ ⵉⵇⴻⴼⵍⴻⵏ, ⵖⴰⵔ ⵡⴰⵙⵙ ⵏ ⵍⵄⵉⴷ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS81_5","020_81_5","PSA","81","5","5","ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵉⵛⵜ ⵏ ⵍⴼⴰⵔⵉⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS81_6","020_81_6","PSA","81","6","6","ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⴷⵉ ⵢⵓⵙⵓⴼ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⴰⵇⴰ ⵙⵍⵉⵖ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⴼⴻⵀⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS81_7","020_81_7","PSA","81","7","7","ⵜⴰⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ ⴼⴻⴽⴽⴻⵖ ⵜⵜ ⵣⵉ ⴷⴷⵇⴻⵍ, ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴰⵔⵅⵓⵏ ⵣⵉ ⵜⵙⵓⴵⴻⵜ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴱⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("PS81_8","020_81_8","PSA","81","8","8","ⵛⴻⴽ ⵜⵍⴰⵖⵉⴷ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⵏⴻⵛⵛ ⴼⴻⴽⴽⴻⵖ ⵛⴻⴽ ⵣⵣⴰⵢⴻⵙ. ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅⴰⴽ ⴰⵎ ⵜⵜⵏⵓⴼⴼⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵊⵊⴰⵊ, ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ ⵇⴻⴵⴱⴻⵖ ⵛⴻⴽ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS81_9","020_81_9","PSA","81","9","9","ⵙⴻⵍ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵀⴷⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴻⵙⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS81_10","020_81_10","PSA","81","10","10","ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵉⵍⵉ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵖⵔⵉⴱ, ⵡⴰⵔ ⵙᵉⵊⴻⴷ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS81_11","020_81_11","PSA","81","11","11","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵛⵛⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS81_12","020_81_12","PSA","81","12","12","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵡⴰⵔ ⵉⵙⵍⵉ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵅⵙ. ");
INSERT INTO rift_vpl VALUES ("PS81_13","020_81_13","PSA","81","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵊⵊⵉⵖ ⵜⴻⵏ ⵉ ⵡⵓⵍ ⵏⵙⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵍⴻⵛⵡⴰⵔ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS81_14","020_81_14","PSA","81","14","14","ⵎⵍⵉ ⴷⴷ-ⵉⵙⵍⴰ ⵖⴰⵔⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⵍⵉ ⵉⵙⵔⴰⵉⵍ ⵉⵅⵙ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS81_15","020_81_15","PSA","81","15","15","ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⴷⴻⵖⵢⴰ ⵉⵍⵉ ⵇⴹⵉⵖ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⴰⵔⵔⵉⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS81_16","020_81_16","PSA","81","16","16","ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵙⵉⴷⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵜⵜⵎⵓⵔⵓⴷⴻⵏ ⴷⴻⴵⴻⵏ, ⵍⵡⴻⵇⵜ ⵏ ⵓⵅⴻⴵⴻⵚ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS81_17","020_81_17","PSA","81","17","17","ⵉⵍⵉ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙ ⵎⴰⵛⵛⴰ ⵣⵉ ⵍⴻⵎⵍⵉⵃ ⵏ ⵢⵉⵔⴷⴻⵏ, ⵡⴰⵀ, ⵉⵍⵉ ⵙ ⵜⴰⵎⵎⴻⵏⵜ ⵣⵉ ⵊⵊⴰⵔⴼ ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵙⵊⵊⵉⵡⵏⴻⵖ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS82_1","020_82_1","PSA","82","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ⴰⵔⴻⴱⴱⵉ ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵙ ⵍⵃⴻⵇⵇ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS82_2","020_82_2","PSA","82","2","2","ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵜⴻⴽⴽⴻⵎ ⵜⵃⴻⴽⴽⵎⴻⵎ ⵙ ⵍⵖⴻⵛⵛ, ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵓⴷⴻⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ? ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS82_3","020_82_3","PSA","82","3","3","ⵃⴻⴽⵎⴻⵎ ⵙ ⵍⵃⴻⵇⵇ ⵅ ⵓⵎⴰⵔⵅⵓ ⵓ ⵅ ⵓⵢⵓⵊⵉⵍ, ⴰⵖⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵏ ⵓ ⵉ ⵓⵎⴻⵣⵍⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("PS82_4","020_82_4","PSA","82","4","4","ⴼⴻⴽⴽⴻⵎ ⴰⵎⴰⵔⵅⵓ ⴷ ⵓⵎⴻⵣⵍⵓⴹ, ⴼⴻⴽⴽ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS82_5","020_82_5","PSA","82","5","5","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵙⵙⵏⴻⵏ ⵓ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ, ⴳⴳⵓⵔⴻⵏ ⵜⵜⴻⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵔⵔⴰ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS82_6","020_82_6","PSA","82","6","6","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ!” ");
INSERT INTO rift_vpl VALUES ("PS82_7","020_82_7","PSA","82","7","7","ⵄⴰⴷ ⴰⴷ ⵜⴻⵎⵜⴻⵎ ⴰⵎ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵜⴻⵡⴹⴰⵎ ⴰⵎ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS82_8","020_82_8","PSA","82","8","8","ⴽⴽⴰⵔ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⴽⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS83_1","020_83_1","PSA","83","1","1","ⵉⵣⵍⵉ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵙⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("PS83_2","020_83_2","PSA","83","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵙⵙⴻⵖⴷ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⴷⴻⵀⵛⵓⵔ, ⵡⴰⵔ ⵙⴻⵇⵇⴰⵔ ⵛⴰ, ⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS83_3","020_83_3","PSA","83","3","3","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵜⵜⴰⵔⵔⵓⴵⵓⴷⴻⵏ, ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("PS83_4","020_83_4","PSA","83","4","4","ⵜⵜⵅⴰⵔⵔⵚⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⴷⵉ ⵜⵏⵓⴼⴼⴰⵔ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵜⵜⴻⵎⵛⴰⵡⴰⵔⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴹⴰⵏ ⵣⵣⴰⵢⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS83_5","020_83_5","PSA","83","5","5","ⵇⵇⴰⵔⴻⵏ: “ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⵜⴻⵃⵃⴰ ⴰⵎ ⵍⴳⴻⵏⵙ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴰⵔ ⵄⴰⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("PS83_6","020_83_6","PSA","83","6","6","ⵎⴰⵖⴰⵔ ⵜⵜⴻⵎⵛⴰⵡⴰⵔⴻⵏ ⵙ ⵡⵓⵍ ⴷ ⵉⵊⵊ, ⴰⵇⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴹⵉⴷⴷ ⵉ ⵛⴻⴽ: ");
INSERT INTO rift_vpl VALUES ("PS83_7","020_83_7","PSA","83","7","7","ⵉⵇⵉⴹⴰⵏ ⵏ ⵉⴷⵓⵎ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵓ’ⴰⴱ ⴷ ⴰⵢⵜ ⵏ ⵀⴰⵊⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PS83_8","020_83_8","PSA","83","8","8","ⵊⴰⴱⴰⵍ ⴷ ⵄⴰⵎⵎⵓⵏ ⴷ ⵄⴰⵎⴰⵍⵉⵇ, ⴼⵉⵍⵉⵛⵉⵜ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵚⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("PS83_9","020_83_9","PSA","83","9","9","ⵓⵍⴰ ⴷ ⴰⵛⵛⵓⵔ ⵉⵎⵎⴰⵔⵏⵉ ⵖⴰⵔⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⴼⵓⵙ ⵉⵊⵀⴻⴷ ⵉ ⴰⵢⵜ ⵏ ⵍⵓⵟ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS83_10","020_83_10","PSA","83","10","10","ⴻⴳⴳ ⴰⵙⴻⵏ ⴰⵎ ⵎⵉⴷⵢⴰⵏ ⴷ ⵙⵉⵙⴰⵔⴰ, ⴰⵎ ⵢⴰⴱⵉⵏ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵇⵉⵛⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS83_11","020_83_11","PSA","83","11","11","ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵖⴰⵔ ⵄⴰⵢⵏ-ⴷⵓⵔ, ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴻⵖⴱⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS83_12","020_83_12","PSA","83","12","12","ⴻⴳⴳ ⵉ-ⵜⴻⵏ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏⵙⴻⵏ ⴰⵎ ⵖⵓⵔⴰⴱ ⴷ ⴷⵉ’ⴱ, ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⴰⵎ ⵣⴰⴱⴰⵃ ⴷ ⵚⴰⵍⵎⵓⵏⵏⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("PS83_13","020_83_13","PSA","83","13","13","ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴷ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("PS83_14","020_83_14","PSA","83","14","14","ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴻⴳⴳ ⵉ-ⵜⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵇⴻⵍⵍⵉⵊ ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⴷⵉ ⵍⴻⵄⵡⵉⵏ, ⴰⵎ ⵓⵍⵓⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("PS83_15","020_83_15","PSA","83","15","15","ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵜⴻⵙⵙⵔⴻⵇⵇⴰ ⴰⵣⵖⴰⵔ, ⴰⵎ ⵓⵛⴻⵄⵄⴰⵍ ⵉⵜⵜⴻⵜⵜ ⵉⴷⵓⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PS83_16","020_83_16","PSA","83","16","16","ⴰⵥⵥⴻⵍ ⴰⵎⵎⵓ ⵅⴰⵙⴻⵏ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵏⵏⴻⵛ, ⵙⵏⴻⵅⵍⴻⵄ ⵉ-ⵜⴻⵏ ⵙ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS83_17","020_83_17","PSA","83","17","17","ⵍⴻⵃⵃⴻⴼ ⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵙ ⵍⴻⵃⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS83_18","020_83_18","PSA","83","18","18","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴱⴰⵔⵔⵇⴻⵏ ⵓ ⴰⴷ ⴰⵔⴻⵊⴼⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS83_19","020_83_19","PSA","83","19","19","ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵀⴰ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵢⵉⵙⴻⵎ ‘ⵙⵉⴷⵉ’, ⴰⵎⵄⵓⴵⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS84_1","020_84_1","PSA","84","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ⵓⵊⵉⵜⵜⵉ, ⴰⵔⵢⴰⵣ ⵣⵉ ⵊⴰⵜ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴰⵣⴻⵀⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS84_2","020_84_2","PSA","84","2","2","ⵎⴰⵎⵎⴻⵛ ⵜⵜⵄⵉⵣⵣⴻⵏⵜ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ! ");
INSERT INTO rift_vpl VALUES ("PS84_3","020_84_3","PSA","84","3","3","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ, ⵡⴰⵀ, ⵉⴼⴻⵏⵏⴰ ⵙ ⵓⵡⴻⵃⵃⴻⵛ ⵅ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵍ ⵉⵏⵓ ⴷ ⴷⴷⴰⵜ ⵉⵏⵓ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS84_4","020_84_4","PSA","84","4","4","ⵓⵍⴰ ⴷ ⵥⵥⴰⵡⴻⵛ ⵉⵜⵜⴰⴼ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵓ ⵜⴰⴼⴰⵔⴵⴻⵙⵜ ⵜⵓⴼⴰ ⵉⵊⵊ ⵏ ⵍⵄⵓⵛⵛ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⴷⵉ ⵜⴻⵙⵙⵔⵓⵙⵙⴰ ⵉⵙⵙⴹⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵊⴻⴵⵉⴷ ⵉⵏⵓ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS84_5","020_84_5","PSA","84","5","5","ⵙⵙⴻⵄⴷ ⵏⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵜⵜⵚⴻⴱⴱⴰⵃⴻⵏ ⵉ ⵛⴻⴽ ⴱⵍⴰ ⵇⴻⵟⵟⵓ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS84_6","020_84_6","PSA","84","6","6","ⵙⵙⴻⵄⴷ ⵏ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴰⴼⴻⵏ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⴷⴰⵢⴻⴽ, ⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS84_7","020_84_7","PSA","84","7","7","ⵅⵎⵉ ⵜⵜⵛⵓⵇⴰⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⴰⵔⵔⵉⵏ ⵜ ⴷ ⵍⵄⵓⵏⵚⴰⵔ. ⵓⵍⴰ ⴷ ⴰⵏⵥⴰⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵙ ⵍⴱⴰⵔⴰⴽⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS84_8","020_84_8","PSA","84","8","8","ⵏⵉⵜⵏⵉ ⴳⴳⵓⵔⴻⵏ ⵣⵉ ⵊⵊⴻⵀⴷ ⴰⵍ ⵊⵊⴻⵀⴷ, ⴰⴷ ⴷⴷ-ⴱⴰⵏⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS84_9","020_84_9","PSA","84","9","9","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵙⴻⵍ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⵙⵃⴻⵙⵙ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ! ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS84_10","020_84_10","PSA","84","10","10","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵏ ⵓⵙⴻⵍⵇⵉ, ⴰⵇⴰ ⵅⵣⴰⵔ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("PS84_11","020_84_11","PSA","84","11","11","ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏⵏⴻⵛ ⵉⵃⵍⴰ ⵅ ⵡⴰⵍⴻⴼ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵖⵏⵉ. ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⴰⵜⵍⴰⵄ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS84_12","020_84_12","PSA","84","12","12","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⴼⵓⵛⵜ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵉ ⵓⵙⴻⵍⵇⵉ, ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⵛ ⴰⵃⵉⵏⵏⵉ ⴷ ⵓⵄⵓⴵⵉ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵄⵉⵣⵣⵉ ⵍⵅⴰⵔ ⴷⴻⴳ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵙ ⵍⴻⴽⵎⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS84_13","020_84_13","PSA","84","13","13","ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵙⵙⴻⵄⴷ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴷⴰⵢⴻⴽ ⵉⵜⵜⵉⵇⵇⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS85_1","020_85_1","PSA","85","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴰⵣⴻⵀⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS85_2","020_85_2","PSA","85","2","2","ⵛⴻⴽ ⵜⴰⵔⴹⵉⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰ ⵙⵉⴷⵉ, ⵜⴻⵙⵙⴻⵏⵇⴻⵍⴱⴻⴷ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS85_3","020_85_3","PSA","85","3","3","ⵜⴻⴽⴽⵙⴻⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵜⴻⴷⵍⵉⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS85_4","020_85_4","PSA","85","4","4","ⵛⴻⴽ ⵜⵎⴻⵏⵄⴻⴷ ⵎⴰⵔⵔⴰ ⴰⴼⵓⴳⴻⵎ, ⵜⴻⵙⵙⵜⴻⵡⵡⵊⴻⴷ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS85_5","020_85_5","PSA","85","5","5","ⴰⵔⵔ ⴰⵏⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵜⵜⵓ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS85_6","020_85_6","PSA","85","6","6","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⴻⵙⵄⴰⵔⴻⴷ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴰⴷ ⵉⵇⵇⵉⵎ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("PS85_7","020_85_7","PSA","85","7","7","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵉⴼⴰⵔⵃ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS85_8","020_85_8","PSA","85","8","8","ⵙⵛⴻⵏ ⴰⵏⴻⵖ-ⴷⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS85_9","020_85_9","PSA","85","9","9","ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵍⴻⵖ ⵎⵉⵏ ⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ, ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⴰⴽ-ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ ⵅ ⵍⴻⵀⵏⴰ. ⵖⴰⵔⵡⴻⵎ, ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS85_10","020_85_10","PSA","85","10","10","ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS85_11","020_85_11","PSA","85","11","11","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⴰⴷ ⵎⵎⵙⴰⴳⴰⵔⴻⵏ, ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⵎⵎⵙⵓⴷⵓⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS85_12","020_85_12","PSA","85","12","12","ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵖⵎⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵊⵊ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS85_13","020_85_13","PSA","85","13","13","ⵙⵉⴷⵉ ⴰⴷ ⵉⵡⵛ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS85_14","020_85_14","PSA","85","14","14","ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⴰⵙ ⵜⵉⵣⵡⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵃⴹⴰ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS86_1","020_86_1","PSA","86","1","1","ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵖⴰⵔⵉ, ⵙⴻⵍ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵓ ⵣⴻⵍⴹⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS86_2","020_86_2","PSA","86","2","2","ⵃⴹⴰ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵙⴻⵏⵊⴻⵎ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⵜⵜⵛⴰⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS86_3","020_86_3","PSA","86","3","3","ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⵜⵍⴰⵖⵉⵖ ⵅⴰⴽ ⴰⵙⵙ ⴰⵎ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS86_4","020_86_4","PSA","86","4","4","ⵙⴼⴰⵔⵃ ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS86_5","020_86_5","PSA","86","5","5","ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵓ ⴷ ⴰⵎⵙⴰⵎⴻⵃ, ⵖⴰⵔⴻⴽ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵍⴰⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS86_6","020_86_6","PSA","86","6","6","ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⵃⴻⴽⴽⴰⵔ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵓⵜⵔⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS86_7","020_86_7","PSA","86","7","7","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵜⵜⵍⴰⵖⵉⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS86_8","020_86_8","PSA","86","8","8","ⵊⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS86_9","020_86_9","PSA","86","9","9","ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵜⴻⴳⴳⵉⴷ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⴷ ⵙⵙⵄⵓⴵⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS86_10","020_86_10","PSA","86","10","10","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS86_11","020_86_11","PSA","86","11","11","ⵙⵛⴻⵏ ⴰⵢⵉ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ, ⵙⵎⵓⵏ ⵓⵍ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS86_12","020_86_12","PSA","86","12","12","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵉⵏⵓ, ⴰⴷ ⵛⴻⵏⵏⵄⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS86_13","020_86_13","PSA","86","13","13","ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴻⵎⵖⴰⵔ ⵅⴰⴼⵉ, ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⴰⴵⴰⵖ ⵏ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS86_14","020_86_14","PSA","86","14","14","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵉ, ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵏⵖⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ⵛⴻⴽ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⵉⴷ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS86_15","020_86_15","PSA","86","15","15","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵔⵃⵉⵎ ⴷ ⵓⵃⵏⵉⵏ, ⵖⴰⵔⴻⴽ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵓⵍⴰ ⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS86_16","020_86_16","PSA","86","16","16","ⵅⵣⴰⵔ-ⴷⴷ ⵖⴰⵔⵉ ⵓ ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴻⴳⴳ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵙⴻⵏⵊⴻⵎ ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS86_17","020_86_17","PSA","86","17","17","ⴻⴳⴳ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⴰⴼⵓⵙ ⵓ ⵜⴻⵙⵙⴼⴻⵡⵡⵊⴻⴷ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS87_1","020_87_1","PSA","87","1","1","ⴰⵣⴻⵀⵀⴻⴷ, ⵉⵣⵍⵉ ⵏ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⴷⵙⴰⵙ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS87_2","020_87_2","PSA","87","2","2","ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵚⵉⵀⵢⵓⵏ ⴰⵟⵟⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⴷⴷⵖⵉⵏ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS87_3","020_87_3","PSA","87","3","3","ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵢⵓⵄⵍⴰⵏ ⵇⵇⴰⵔⴻⵏ ⵅⴰⵎ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS87_4","020_87_4","PSA","87","4","4","ⵏⴻⵛⵛ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵔⴰⵀⴰⴱ ⴷ ⴱⴰⴱⵉⵍ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵏ. ⵅⵣⴰⵔ, ⴼⵉⵍⵉⵛⵉⵜ ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵚⵓⵔⵉ ⴰⴽ-ⴷ ⵓⴽⵓⵛⵉ ... ‘ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⴷ-ⴷⴷ ⴷⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("PS87_5","020_87_5","PSA","87","5","5","ⵎⴰⵛⴰ ⵅ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ-ⴷⴷ ⴷⴰⵢⴻⵙ!’, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS87_6","020_87_6","PSA","87","6","6","ⵙⵉⴷⵉ ⴰⴷ ⵉⵣⴻⵎⵎⴻⵎ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵍⴻⴳⵏⵓⵙ: ‘ⵡⴰⵏⵉⵜⴰ ⵉⵅⵍⴻⵇ-ⴷⴷ ⴷⵉⵏ’. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS87_7","020_87_7","PSA","87","7","7","ⵏⵉⵜⵏⵉ ⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ ⴰⵎ ⵛⴻⵟⵟⵃⴻⵏ: ‘ⵜⴰⵍⴰⵡⵉⵏ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⴷⴰⵢⴻⵎ!’ ");
INSERT INTO rift_vpl VALUES ("PS88_1","020_88_1","PSA","88","1","1","ⵉⵣⵍⵉ, ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴰⵢⵜ ⵏ ⵇⵓⵔⴰⵃ. ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ, ⵙ ⵜⴻⵖⵏⵉⵏⵜ ⵏ ‘ⵉⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ’ ⵖⴰⵔ ⵍⴻⵃⵚⴰⵔⴰⵜ. ⴰⵅⴻⵎⵎⵉ ⵏ ⵀⴰⵢⵎⴰⵏ, ⴰⵣⵔⴰⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("PS88_2","020_88_2","PSA","88","2","2","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ ⵖⴰ ⵙⵖⵓⵢⴻⵖ ⵖⴰⵔⴻⴽ ⵙ ⴵⵉⵍⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PS88_3","020_88_3","PSA","88","3","3","ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ ⵣⵣⴰⵜⴻⴽ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵉ ⵓⵍⴰⵖⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS88_4","020_88_4","PSA","88","4","4","ⵎⴰⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵊⵊⵉⵡⴻⵏ ⵙ ⵍⵎⵓⵚⵉⴱⴰⵜ, ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵜⵓⴷⴻⵙ-ⴷⴷ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS88_5","020_88_5","PSA","88","5","5","ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⴻⵙⵙⴰⴱⴻⵖ ⴰⵎ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ, ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵎⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵊⵊⵀⴻⴷ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS88_6","020_88_6","PSA","88","6","6","ⴰⵇⴰ ⵜⵜⵡⴰⵃⵓⵣⴻⵖ ⵊⴰⵔ ⵉⵎⴻⵜⵜⴰⵏ, ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵉⵏⵏⵉ ⵉⵣⵣⵍⴻⵏ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⵉⴷⴰⵔⴻⴷ ⵄⴰⴷ, ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS88_7","020_88_7","PSA","88","7","7","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵢⵓⴵⵖⴻⵏ ⵇⴰⵄ, ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴷⵉ ⵍⴰⴵⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("PS88_8","020_88_8","PSA","88","8","8","ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵉⴷⵇⴻⵍ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵡⴰⵊ ⵏ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵜⴻⵙⵙⴷⴻⴵⴻⴷ ⴰⵢⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS88_9","020_88_9","PSA","88","9","9","ⵉⵎⵇⴰⵔⵔⴰⴱⴻⵏ ⵉⵏⵓ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⵉ-ⵜⴻⵏ ⵅⴰⴼⵉ, ⵜⴰⵔⵔⵉⴷ ⴰⵢⵉ ⴷ ⵏⵏⵄⵉ ⵉ ⵏⵉⵜⵏⵉ. ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ ⵅⴰⴼⵉ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS88_10","020_88_10","PSA","88","10","10","ⵜⵉⵟⵟ ⵉⵏⵓ ⵜⴻⵄⵎⴻⵛ ⵙ ⵍⴻⵖⴱⴻⵏ. ⴰ ⵙⵉⴷⵉ, ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵜⵜⵍⴰⵖⵉⵖ ⵖⴰⵔⴻⴽ, ⵏⴻⵛⵛ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS88_11","020_88_11","PSA","88","11","11","ⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵉⵛⵜ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰ ⴷⴻⴳ ⵉⵎⴻⵜⵜⴰⵏ? ⵏⵉⵖ ⴰⴷ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ, ⵎⴰ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ? ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS88_12","020_88_12","PSA","88","12","12","ⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵙ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵓⵀⴻⵍⵍⴻⴽ? ");
INSERT INTO rift_vpl VALUES ("PS88_13","020_88_13","PSA","88","13","13","ⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵏⵜ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴰⵜⵜⵓⵜ? ");
INSERT INTO rift_vpl VALUES ("PS88_14","020_88_14","PSA","88","14","14","ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵜⵜⵍⴰⵖⵉⵖ ⵛⴻⴽ, ⵜⴰⵥⴰⴵⵉⵜ ⵉⵏⵓ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵣⵣⴰⵜⴻⴽ ⵖⴰⵔ ⵓⵜⴻⴼⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("PS88_15","020_88_15","PSA","88","15","15","ⵎⴰⵢⴻⵎⵎⵉ, ⴰ ⵙⵉⴷⵉ, ⵜⵏⴻⵟⵟⴰⵔⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵣⵣⴰⵢⵉ? ");
INSERT INTO rift_vpl VALUES ("PS88_16","020_88_16","PSA","88","16","16","ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ ⵏⴻⵛⵛ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵓ ⴳⴳⵓⵔⴻⵖ ⵖⴰⵔ ⵓⵏⵓⵔⵉ, ⴽⵙⵉⵖ ⵉⵙⵏⴻⵅⵔⵉⵄⴻⵏ ⵏⵏⴻⵛ ⴹⵉⴷⴷ ⵉⵏⵓ, ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS88_17","020_88_17","PSA","88","17","17","ⵜⴻⵜⵜⴻⴽⴽ ⵅⴰⴼⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵉⵜⵜⴻⵃⵃⴰ ⴰⵢⵉ ⵓⵙⴻⴳⴳⵯⵉⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS88_18","020_88_18","PSA","88","18","18","ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵉⵜⵜⴻⵏⵏⴻⴹ ⴰⵢⵉ-ⴷⴷ ⴰⵎ ⵡⴰⵎⴰⵏ, ⵉⵜⵜⵇⵓⵡⵡⴰⵔ ⴰⵢⵉ-ⴷⴷ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS88_19","020_88_19","PSA","88","19","19","ⴰⵎⵄⵉⵣⵣ ⵉⵏⵓ ⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⵉ-ⵜⴻⵏ ⵅⴰⴼⵉ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵏ ⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⵜⵜⵡⴰⵍⴻⵃⵃⴼⴻⵏ ⵙ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_1","020_89_1","PSA","89","1","1","ⴰⵅⴻⵎⵎⵉ ⵏ ⵉⵜⴰⵏ, ⴰⵣⵔⴰⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("PS89_2","020_89_2","PSA","89","2","2","ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS89_3","020_89_3","PSA","89","3","3","ⵎⴰⵖⴰⵔ ⵏⵏⵉⵖ: “ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵇⴰ ⵜⴹⴻⵎⵏⴻⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("PS89_4","020_89_4","PSA","89","4","4","“ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵊⵊⵓⴵⴻⵖ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ: ");
INSERT INTO rift_vpl VALUES ("PS89_5","020_89_5","PSA","89","5","5","‘ⵏⴻⵛⵛ ⴰⴷ ⴹⴻⵎⵏⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⴰⴷ ⴱⵏⵉⵖ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ.’” ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS89_6","020_89_6","PSA","89","6","6","ⵉⵊⴻⵏⵡⴰⵏ ⵜⵜⵇⴰⴷⴰⵏ ⵛⴻⴽ ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵜⵜⵇⴰⴷⴰⵏ ⵛⴻⴽ ⵅ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_7","020_89_7","PSA","89","7","7","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵇⵓⴷⴷⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("PS89_8","020_89_8","PSA","89","8","8","ⴰⵔⴻⴱⴱⵉ ⵉⵡⵄⴰⵔ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS89_9","020_89_9","PSA","89","9","9","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵏ ⵡⴻⵏ ⵖⴰⵔ ⵉⴵⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴰⵎ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ! ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS89_10","020_89_10","PSA","89","10","10","ⵛⴻⴽ ⵜⵃⴻⴽⴽⵎⴻⴷ ⵅ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵅⵎⵉ ⴷⴷ-ⵜⵜⵏⴻⴽⴽⴰⵔⴻⵏ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴰⵔⴻⵙⵙⵉⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS89_11","020_89_11","PSA","89","11","11","ⴰⵇⴰ ⵜⵍⴻⴱⵣⴻⴷ ⵔⴰⵀⴰⴱ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⵓⵇⵇⴱⴻⵏ, ⵜⵣⴻⴵⵄⴻⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵙ ⵓⵖⵉⵍ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS89_12","020_89_12","PSA","89","12","12","ⵏⵏⴻⵛ ⴷ ⵉⵊⴻⵏⵡⴰⵏ, ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ. ⴷⴷⵓⵏⵉⵜ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⵜⴻⴳⴳⵉⴷ ⴰⵙⴻⵏ ⴷⵙⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS89_13","020_89_13","PSA","89","13","13","ⵛⴻⴽ ⵜⵅⴻⵍⵇⴻⴷ-ⴷⴷ ⵛⵛⴰⵎⴰⵍ ⴷ ⵍⵊⴰⵏⵓⴱ, ⵜⴰⴱⵓⵔ ⴷ ⵀⵉⵔⵎⵓⵏ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_14","020_89_14","PSA","89","14","14","ⴰⵇⴰ ⵖⴰⵔⴻⴽ ⴰⵖⵉⵍ ⵉ ⴷⵉ ⵜⴻⴳⴳⵉⴷ ⵜⴰⵔⵢⴰⵙⵜ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵊⵀⴻⴷ, ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS89_15","020_89_15","PSA","89","15","15","ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴷⵙⴰⵙ ⵏ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ, ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵉⵜⵜⵉⵣⵡⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_16","020_89_16","PSA","89","16","16","ⵙⵙⴻⵄⴷ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⵙⵙⵏⴻⵏ ⴰⴷ ⵎⴻⵢⵢⵣⴻⵏ ⴰⵙⵓⴹⵉ ⵙ ⵡⴻⵙⵔⵓⴷⴷⴻⵃ ⵏ ⵍⴱⵓⵇ, ⴰ ⵙⵉⴷⵉ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_17","020_89_17","PSA","89","17","17","ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS89_18","020_89_18","PSA","89","18","18","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵍⴻⵎⵍⴰⵃⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ, ⵉⵛⵛ ⵏⵏⴻⵖ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_19","020_89_19","PSA","89","19","19","ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵏ ⵓⵙⴻⵍⵇⵉ ⵏ ⵙⵉⴷⵉ, ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ ⴰⵇⴰ-ⵜ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS89_20","020_89_20","PSA","89","20","20","ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴷⵉ ⵍⴻⵡⵃⵉⵢ ⵅ ⵓⵎⵜⵉⵇⵇⵉ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉⴷ: “ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴳⴳⵉⵖ ⵜⵡⵉⵣⴰ, ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_21","020_89_21","PSA","89","21","21","ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴷⴰⵡⵓⴷ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⴷⴻⵀⵏⴻⵖ ⵜ ⵙ ⵣⵣⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS89_22","020_89_22","PSA","89","22","22","ⵎⴰⵃⴻⵏⴷ ⴰⴼⵓⵙ ⵉⵏⵓ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵡⴰⵀ ⴰⵖⵉⵍ ⵉⵏⵓ ⴰⴷ ⵜ ⵉⵙⵙⴻⵎⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS89_23","020_89_23","PSA","89","23","23","ⵍⴻⵄⴷⵓ ⵡⴰⵔ ⵜ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵡⴰⵔ ⵜ ⵉⵃⴻⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS89_24","020_89_24","PSA","89","24","24","ⵉⵏⵏⵉ ⵜ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵍⴻⴱⵣⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⴷ ⵜⴻⵏ ⵡⵜⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS89_25","020_89_25","PSA","89","25","25","ⵍⴰⵎⴰⵏ ⵉⵏⵓ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵢⵉⵛⵛ ⵏⵏⴻⵙ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS89_26","020_89_26","PSA","89","26","26","ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⴻⴱⵃⴰⵔ, ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵅ ⵉⵖⴻⵣⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS89_27","020_89_27","PSA","89","27","27","ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵉⵍⴰⵖⴰ: ‘ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴱⴰⴱⴰ ⵉⵏⵓ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("PS89_28","020_89_28","PSA","89","28","28","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⴰⵎⴻⵏⵣⵓ ⵉⵏⵓ, ⴰⵎⵄⵓⴵⵉ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_29","020_89_29","PSA","89","29","29","ⵉ ⵍⴻⴱⴷⴰ ⴰⴷ ⵃⴹⵉⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⵙ, ⵓ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⵙ ⵍⵎⴰⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_30","020_89_30","PSA","89","30","30","ⴰⴷ ⵥⵥⵓⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ, ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵏ ⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS89_31","020_89_31","PSA","89","31","31","ⵎⴰⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ, ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS89_32","020_89_32","PSA","89","32","32","ⵎⴰⵍⴰ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵡⴰⵔ ⵃⴻⵟⵟⵉⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS89_33","020_89_33","PSA","89","33","33","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⴰⵄⴻⴷⴷⵓ ⵏⵙⴻⵏ ⵙ ⵡⴻⵄⵎⵓⴷ, ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵙ ⵜⴻⵢⵢⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PS89_34","020_89_34","PSA","89","34","34","ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⴻⴽⴽⵙⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵡⴰⵔ ⵏⴻⴽⴽⴰⵔⴻⵖ ⵍⵎⴰⵏⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS89_35","020_89_35","PSA","89","35","35","ⵡⴰⵔ ⵜⵜⵖⴻⵚⵚⴰⴱⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ, ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜ ⵜⵜⴱⴻⴷⴷⵉⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS89_36","020_89_36","PSA","89","36","36","ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵖⴰⵔ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵉⵏⵓ: ’ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵅ ⴷⴰⵡⵓⴷ!’ ");
INSERT INTO rift_vpl VALUES ("PS89_37","020_89_37","PSA","89","37","37","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ, ⵓ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⴰⴷ ⴷⵉⵏ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⵉ ⴰⵎ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_38","020_89_38","PSA","89","38","38","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ ⴰⵎ ⵜⵣⵉⵔⵉ ⵓ ⴰⵛⴻⵀⵀⴰⴷ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵜⵉⵇⵇⵉ.” ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS89_39","020_89_39","PSA","89","39","39","ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵄⴰⵔⵔⵏⴻⴷ ⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ, ⵜⴻⵏⴹⴰⵔⴻⴷ ⵜ, ⵛⴻⴽ ⵜⴼⵓⴳⴳⵎⴻⴷ ⵅ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_40","020_89_40","PSA","89","40","40","ⵛⴻⴽ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵜⴼⴻⵙⴷⴻⴷ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ ⵙ ⵓⴱⴻⴵⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_41","020_89_41","PSA","89","41","41","ⵜⵖⴻⴹⵍⴻⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⵓⴷ ⵏⵏⴻⵙ, ⵜⵀⴻⴷⵎⴻⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵉⴼⴰⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS89_42","020_89_42","PSA","89","42","42","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴽⴽⵉⵏ ⴰⴱⵔⵉⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵜ, ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵙⴻⵃⵇⴰⵔ ⵉ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS89_43","020_89_43","PSA","89","43","43","ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵜⴻⵙⵙⴼⴰⵔⵔⵃⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS89_44","020_89_44","PSA","89","44","44","ⵛⴻⴽ ⵜⴻⵙⵙⴻⵏⵇⴻⵍⴱⴻⴷ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⵜ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS89_45","020_89_45","PSA","89","45","45","ⵛⴻⴽ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⴰⵥⵔⵉ ⵏⵏⴻⵙ, ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS89_46","020_89_46","PSA","89","46","46","ⵛⴻⴽ ⵜⴻⵙⵙⴻⵎⵥⵉⴷ ⴰⵙ ⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ, ⵜⴻⴷⵍⵉⴷ ⵜ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS89_47","020_89_47","PSA","89","47","47","ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⴰⴷ ⵢⴰⵔⵖ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⵜⵎⴻⵙⵙⵉ? ");
INSERT INTO rift_vpl VALUES ("PS89_48","020_89_48","PSA","89","48","48","ⵄⵇⴻⵍ ⵅ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ! ⵎⴰⵢⴻⵎⵎⵉ ⴷⴷ-ⵜⵅⴻⵍⵇⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵎⴻⵏⵏⵉ ⴱⴰⵟⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("PS89_49","020_89_49","PSA","89","49","49","ⵎⴰⵏ ⴰⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵍⵎⴻⵡⵜ, ⵎⴰⵏ ⴰⵔⵢⴰⵣ ⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴰⵅⴰⵔⵜ? ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS89_50","020_89_50","PSA","89","50","50","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵏⵉ ⴵⴰⵏⵜ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵏ ⵣⵉⵛ, ⵜⵉⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⴷⴰⵡⵓⴷ ⵙ ⵍⵎⴰⵏⴻⵜ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS89_51","020_89_51","PSA","89","51","51","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵄⵇⴻⵍ ⵅ ⵓⵙⴻⵃⵇⴰⵔ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵏⵏⵉ ⴰⵔⴻⴱⴱⵓⵖ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵉⵏⵓ ⵣⴻⴳ ⵓⴱⴰⵔⵔⵓ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("PS89_52","020_89_52","PSA","89","52","52","ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵉ ⵣⵉ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵉⵚⵓⵔⴰⴼ ⵏ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS89_53","020_89_53","PSA","89","53","53","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ! ⴰⵎⵉⵏ, ⵡⴰⵀ, ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("PS90_1","020_90_1","PSA","90","1","1","ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⵎⵓⵙⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵛⴻⴽ ⵜⵓⵖⴰ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵖ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS90_2","020_90_2","PSA","90","2","2","ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉⴷⵓⵔⴰⵔ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⴷⴷⵓⵏⴻⵛⵜ, ⵡⴰⵀ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS90_3","020_90_3","PSA","90","3","3","ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⵄⴻⵊⵊⴰⵊⵜ. ⵜⴻⵇⵇⴰⵔⴻⴷ: “ⵄⴻⵇⴱⴻⵜⵜⵉⵡ-ⴷⴷ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("PS90_4","020_90_4","PSA","90","4","4","ⵎⴰⵖⴰⵔ ⴰⵍⴻⴼ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⵎ ⵡⴰⵙⵙ ⵏ ⵉⴹⴻⵏⵏⴰⴹ ⵏⵏⵉ ⵉⵄⴷⵓⵏ, ⵓⵍⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵏⵏⵓⴱⴻⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS90_5","020_90_5","PSA","90","5","5","ⵛⴻⴽ ⵜⴼⴰⵔⴹⴻⴷ ⵜⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵢⵉⴹⴻⵚ. ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⴳⴳⵉⵏ ⴰⵎ ⴰⵔⴱⵉⵄ ⵉⵢⴻⵎⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS90_6","020_90_6","PSA","90","6","6","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵉⵜⵜⵣᵉⵢⵣⵉⵡ ⴰⵔⵔⴱⵉⵄ ⵓⵛⴰ ⵉⵢⴻⵎⵎⴰ, ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵉⵜⵜⵡⴰⵎⵊⴰⵔ, ⵉⵜⵜⴰⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS90_7","020_90_7","PSA","90","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴼⵏⴰ ⵙ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵏⴻⵏⵏⴻⵅⵍⴻⵄ ⵣⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS90_8","020_90_8","PSA","90","8","8","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ, ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS90_9","020_90_9","PSA","90","9","9","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ ⴰⴷ ⵄⴷⵓⵏ ⴷⴻⴳ ⵓⴼⵓⴳⴻⵎ ⵏⵏⴻⵛ ⵉⵙⵙⴻⴳⴳⵯⴰⴷⴻⵏ, ⵏⴻⵙⵙⴻⵄⴷⵓ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⵓⴹⵉ. ");
INSERT INTO rift_vpl VALUES ("PS90_10","020_90_10","PSA","90","10","10","ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵜⵜⴻⴽⴽⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵏⵉⵖ, ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵏⵉⵍⵉ ⵏⴻⵊⵀⴻⴷ, ⴰⵇⴰ ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⴷ ⴰⵄⵓⴵⵉ, ⵉⵜⵜⴰⵔⵓ-ⴷⴷ ⵜⴰⵎⴰⵔⴰ ⴷ ⵍⵡⴻⵃⵔⴰⵏ, ⴷⴻⵖⵢⴰ ⵜᵉⵜⵜⴻⴽⴽ ⵜⵄⴻⴷⴷⵓ ⵓ ⵏⴻⵟⵟⴰⵡ ⵖⴰⵔ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS90_11","020_90_11","PSA","90","11","11","ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⵏⴻⵏ ⵍⵇⴻⵙⵃⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⵏⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⴻⴽ ⴰⵎ ⴷⴷ-ⵉⵜⵜⵍⵉⵇ ⴰⴽ-ⴷ ⴰⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵛ ⵏ ⵓⴼⵓⴳⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("PS90_12","020_90_12","PSA","90","12","12","ⵙⴻⵍⵎⴻⴷ ⴰⵏⴻⵖ ⴰⴷ ⵏⵃⴻⵙⵙⴻⴱ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵏⴰⵡⵉ ⵓⵍ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PS90_13","020_90_13","PSA","90","13","13","ⴷⵡⴻⵍ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ, ⴰⵍ ⵎⴻⵍⵎⵉ? ⵃⵉⵏⵏ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS90_14","020_90_14","PSA","90","14","14","ⵙⵊⵊⵉⵡⴻⵏ ⴰⵏⴻⵖ ⵖⴰⵔ ⵓⵜⴻⴼⴼⵓ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵙⵍⵉⵡⵍⴻⵡ, ⴰⴷ ⵏⴼⴰⵔⵃ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS90_15","020_90_15","PSA","90","15","15","ⵙⴼⴰⵔⵃ ⴰⵏⴻⵖ ⴰⵏⴻⵛⵜ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵃⵚⴰⵔⴻⴷ, ⴰⵏⴻⵛⵜ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⴷⵉ ⵏⴻⵥⵔⴰ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS90_16","020_90_16","PSA","90","16","16","ⵙⵛⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵍⵄⴻⵣⵣ ⵏⵏⴻⵛ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS90_17","020_90_17","PSA","90","17","17","ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⴻⵀⵡⴰ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴹⵎⴻⵏ ⵛⴻⴽ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ, ⵡⴰⵀ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⴹⵎⴻⵏ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PS91_1","020_91_1","PSA","91","1","1","ⵜⵎⵉⵊⵊⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ: ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵓⴷⵓⵔⵔⵉ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵙ ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS91_2","020_91_2","PSA","91","2","2","ⵜⵎⵉⵊⵊⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵙⵉⴷⵉ: ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵅ ⵜⵜⴻⵛⵍⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("PS91_3","020_91_3","PSA","91","3","3","ⵜⵎⵉⵊⵊⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ: ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⴼⴻⴽⴽ ⵣⵉ ⵍⴼⴻⵅ ⵏ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵉⵊⴹⴰⴹ, ⵣⵉ ⵟⵟⴰⵄⵓⵏ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS91_4","020_91_4","PSA","91","4","4","ⵙ ⴰⵔⵔⵉⵛ ⵏⵏⴻⵙ ⴰⴷ ⵛⴻⴽ ⵉⴷⴻⵍ, ⵙⴰⴷⵓ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴰⴼⴻⴷ ⴰⴷⵓⵔⵔⵉ. ⵍⵎⴰⵏⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS91_5","020_91_5","PSA","91","5","5","ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵛⴰ ⵣⴻⴳ ⵓⵏⴻⵅⵍⵉⵄ ⵏ ⴵⵉⵍⴻⵜ, ⵣⵉ ⴼⵍⵉⵜⵛⴰ ⵏ ⵍⵇⴻⵡⵙ ⵉ ⴷⵉⵏ ⵉⵟⵟⴰⵡⴻⵏ ⵙ ⵡⴰⵙⵙ, ");
INSERT INTO rift_vpl VALUES ("PS91_6","020_91_6","PSA","91","6","6","ⵓⵍⴰ ⵣⵉ ⵟⵟⴰⵄⵓⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵣⵉ ⵍⵀⴰⵍⴰⴽ ⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵙ ⵓⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS91_7","020_91_7","PSA","91","7","7","ⵡⴰⵅⵅⴰ ⴰⴷ ⵡⴹⴰⵏ ⴰⵍⴻⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ ⵓ ⵄⴻⵛⵔⴰ ⴰⵍⴻⴼ ⵖⴰⵔ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ, ⵄⴰⴷ ⵡⴰⵔ ⵛⴻⴽ ⴷⴷ-ⵉⵜⵜⵉⴽⴽⵯⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("PS91_8","020_91_8","PSA","91","8","8","ⴰⴷ ⵜⵡⴰⵍⵉⴷ ⴰⵢⴰ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵡⴰⵀⴰ, ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⴼ ⵣⴻⴳ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS91_9","020_91_9","PSA","91","9","9","ⵜⵎⵉⵊⵊⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: ⵎⴰⵖⴰⵔ ⵅⴰⴽ: ‘ⵛⴻⴽ ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ!’ ⵜⵎⵉⵊⵊⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS91_10","020_91_10","PSA","91","10","10","ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵜⵏⴻⵟⵟⴻⵃ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵡⴰⵔ ⴷⴷ-ⵜⵇⴰⵔⵔⴰⴱ ⵛⴰ ⵖⴰⵔ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS91_11","020_91_11","PSA","91","11","11","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⴽ ⵢⵓⵎⵓⵔ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵃⴹⴰⵏⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS91_12","020_91_12","PSA","91","12","12","ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵏ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵏⴻⴳⴳⴻⵃ ⴰⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("PS91_13","020_91_13","PSA","91","13","13","ⴰⴷ ⵜⵄⴻⴼⵙⴻⴷ ⵅ ⵡⴻⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⵓ ⵅ ⵜⵍⴻⴼⵙⴰ, ⴰⴷ ⵜⵄⴻⵊⵏⴻⴷ ⵅ ⵡⴻⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵍⵀⴰⵢⵛⴻⵜ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS91_14","020_91_14","PSA","91","14","14","ⵜⵎⵉⵊⵊⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ: ⵓⵎⵉ ⴷⴷ-ⵉⵇⵇⴻⵏ ⵏⴻⵜⵜⴰ ⵖⴰⵔⵉ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⵏⴻⵊⵎⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS91_15","020_91_15","PSA","91","15","15","ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵍⴰⵖⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵖ. ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵇⴰ ⴰⵢⵉ ⵖⴰⵔⴻⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴼⴻⴽⴽⴻⵖ, ⴰⴷ ⴰⵙ ⵙⵙⵄⵓⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS91_16","020_91_16","PSA","91","16","16","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵙⵙⵊⵊⵉⵡⵏⴻⵖ ⴰⴽ-ⴷ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS92_1","020_92_1","PSA","92","1","1","ⴰⵣⴻⵀⵀⵉⴷ. ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ ⵉ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("PS92_2","020_92_2","PSA","92","2","2","ⵎⴰⵎⵎⴻⵛ ⵉⵚⴱⴻⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵇⴰⴷⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵏⵣⴻⵀⵀⴻⴷ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ");
INSERT INTO rift_vpl VALUES ("PS92_3","020_92_3","PSA","92","3","3","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴱⴰⵔⵔⴻⵃ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴷⵉ ⴵⵢⴰⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("PS92_4","020_92_4","PSA","92","4","4","ⴷⵉ ⵍⵀⴰⵔⴱⴰ ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⵉⵍⴰⵏ ⵓ ⴷⵉ ⵍⵀⴰⵔⴱⴰ, ⵙ ⵜⵉⵔⴰⵔⵜ ⵅ ⵉⴼⵉⵍⴰⵏ ⵏ ⵍⴳⴰⵎⴱⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS92_5","020_92_5","PSA","92","5","5","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴼⴰⵔⵃⴻⴷ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ, ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵖ ⵅ ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS92_6","020_92_6","PSA","92","6","6","ⵎⴰⵎⵎⴻⵛ ⵎⵖⴰⵔⴻⵏⵜ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵎⵎⴻⵛ ⵓⴵⵖⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("PS92_7","020_92_7","PSA","92","7","7","ⵉⵊⵊ ⵏ ⵓⵇⴻⴼⴼⵓⵃ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵎⵉⵏ ⵖⴰ ⵉⵄⴰⵡⴻⴷ, ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵡⴰⵔ ⵉⴼⴻⵀⵀⴻⵎ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS92_8","020_92_8","PSA","92","8","8","ⵎⴰⵍⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵖⴻⵎⵎⵢⴻⵏ ⴰⵎ ⴰⵔⴱⵉⵄ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵜⵜⵏⴻⵡⵡⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⵢⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⴰⵜⴻⵃⵃⵉ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS92_9","020_92_9","PSA","92","9","9","ⵛⴻⴽ ⴷ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵉ ⵍⴻⴱⴷⴰ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS92_10","020_92_10","PSA","92","10","10","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ, ⵙⵉⴷⵉ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⴼⵏⴰⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS92_11","020_92_11","PSA","92","11","11","ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⵛⵛⴰⵡ ⵉⵏⵓ ⴰⵎ ⵡⴻⵏⵏⵉ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ, ⵜⵜⵡⴰⴷⴻⵀⵏⴻⵖ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵟⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS92_12","020_92_12","PSA","92","12","12","ⵜⵉⵟⵟ ⵉⵏⵓ ⴰⴷ ⵜⵥⴰⵔ ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⵛⴻⴽⴽⵎⴻⵏ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS92_13","020_92_13","PSA","92","13","13","ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⵏⴻⵡⵡⴰⵔ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ, ⴰⴷ ⵉⵖⵎⵉ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS92_14","020_92_14","PSA","92","14","14","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵥⵥⵓⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵏⵏⵓⵡⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS92_15","020_92_15","PSA","92","15","15","ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⴻⵡⵙⴰⵔ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵚⴻⵃⵃⴻⵏ ⴷ ⵟⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS92_16","020_92_16","PSA","92","16","16","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ, ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⵏⵉⵛⴰⵏ. ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS93_1","020_93_1","PSA","93","1","1","ⵙⵉⴷⵉ ⵉⵃⴻⴽⴽⴻⵎ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⴹ ⵙ ⵍⵄⴰⴹⴰⵎⴰ, ⵙⵉⴷⵉ ⵢⴰⵔⴹ ⵙ ⵊⵊⴻⵀⴷ ⴰⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵃⴻⵣⵣⴰⵎ. ⵡⴰⵀ, ⴷⴷⵓⵏⴻⵛⵜ ⵜⴱⴻⴷⴷ ⵜⴻⵎⵜⴻⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS93_2","020_93_2","PSA","93","2","2","ⵍⴽⵓⵔⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵏⵏⴻⵛ ⵉⵎⵜⴻⵏ ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵛⴻⴽ ⵜⴻⴵⵉⴷ ⵣⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS93_3","020_93_3","PSA","93","3","3","ⵉⵖⴻⵣⵔⴰⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⵉⵖⴻⵣⵔⴰⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ. ⵉⵖⴻⵣⵔⴰⵏ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵍⵃⴻⵙⵙ ⵏ ⵣⵣⵀⵉⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS93_4","020_93_4","PSA","93","4","4","ⵙⵉⴷⵉ ⴷⵉ ⵍⵓⵄⵍⴰ ⵉⵊⵀⴻⴷ ⵅ ⵣⵣⵀⵉⵔ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵅ ⵓⵀⴰⵊⵉ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS93_5","020_93_5","PSA","93","5","5","ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏⵜ ⵍⴰⵎⴰⵏ. ⵜⴰⵇⴻⴷⴷⴰⵙⵜ ⵜⵣⴻⵀⵀⴻⵊ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⵍ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS94_1","020_94_1","PSA","94","1","1","ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵏⵜⴰⵇⴻⵎ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵏⵜⴰⵇⴻⵎ, ⴱⴰⵏ-ⴷⴷ ⴷⵉ ⵜⵉⵙⵙⵉⵇⵜ! ");
INSERT INTO rift_vpl VALUES ("PS94_2","020_94_2","PSA","94","2","2","ⴰ, ⵍⵇⴰⴹⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰⵔⵔ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴰⵎ ⵎⵉⵏ ⵙⵙⴷⴰⵃⴻⴵⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS94_3","020_94_3","PSA","94","3","3","ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⴽⴽⴻⵏ ⵄⴰⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⴽⴽⴻⵏ ⵏⴻⴳⴳⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PS94_4","020_94_4","PSA","94","4","4","ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS94_5","020_94_5","PSA","94","5","5","ⴰ ⵙⵉⴷⵉ, ⵏⵉⵜⵏⵉ ⵍⴻⴱⴱⵣⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵃⴻⵚⵚⴰⵔⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS94_6","020_94_6","PSA","94","6","6","ⵏⵉⵜⵏⵉ ⵏⴻⵇⵇⴻⵏ ⵜⴰⵊⵊⴰⵍⵜ ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵖⴰⵔⵔⵚⴻⵏ ⵉ ⵉⵢⵓⵊⵉⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS94_7","020_94_7","PSA","94","7","7","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: “ⵙⵉⴷⵉ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵡⵉⵍⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵃⴻⴽⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("PS94_8","020_94_8","PSA","94","8","8","ⴼⴻⵜⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴻⴼⴼⵓⵃⴻⵏ ⴷⵉ ⵍⴳⴻⵏⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵜⴷⴻⵡⵍⴻⵎ ⵜⴼⴻⵀⵀⵎⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("PS94_9","020_94_9","PSA","94","9","9","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵡⴻⵏⵏⵉ ⵉⵥⵥⵓⵏ ⴰⵎⴻⵣⵣⵓⵖ? ⵎⴰ ⵡⴰⵔ ⵉⵥⴰⵔⵔ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵉⵟⵟ? ");
INSERT INTO rift_vpl VALUES ("PS94_10","020_94_10","PSA","94","10","10","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵄⴰⵇⴻⴱ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴻⴱⴱⵅⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵜⵓⵙⵙⵏⴰ ⵉ ⴱⵏⴰⴷⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("PS94_11","020_94_11","PSA","94","11","11","ⵙⵉⴷⵉ ⵢⴰⵔⴻⴳⴳⴻⴱ ⵅ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⵓⴹⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PS94_12","020_94_12","PSA","94","12","12","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜᵉⵜⵜⵡⴻⴱⴱⵅⴻⴷ, ⴰ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS94_13","020_94_13","PSA","94","13","13","ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⴰⵔⴻⵢⵢⴻⵃⴻⴷ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⴰⵍ ⵖⴰ ⵃⴼⴰⵔⴻⵏ ⴰⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⵉ ⵓⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS94_14","020_94_14","PSA","94","14","14","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵏⴻⵟⵟⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵙⴻⵎⵎⴻⵃ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS94_15","020_94_15","PSA","94","15","15","ⵎⴰⵖⴰⵔ ⵍⵃⵓⴽⵎ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵓⵍ ⵉⵙⴻⴳⴳⵎⴻⵏ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⴹⴻⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS94_16","020_94_16","PSA","94","16","16","ⵎⴰⵏ ⵡⴻⵏ ⴽⵉⴷⵉ ⵉ ⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⴹⵉⴷⴷ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ? ⵎⴰⵏ ⵡⴻⵏ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵉⵡⵜⴻⵏ ⴹⵉⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ? ");
INSERT INTO rift_vpl VALUES ("PS94_17","020_94_17","PSA","94","17","17","ⵎⵍⵉ ⵡⴰⵔ ⵉⴵⵉ ⵙⵉⴷⵉ ⴷ ⵜⵡⵉⵣⴰ ⵉⵏⵓ, ⵉⵍⵉ ⵉⵣⴷⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵄⵍⴰⵃⴰⵍ ⴷⴻⴳ ⵡⴻⵙⵖⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PS94_18","020_94_18","PSA","94","18","18","ⵎⴰⵍⴰ ⵏⵏⵉⵖ: ‘ⴰⴹⴰⵔ ⵉⵏⵓ ⵉⵜⵜⴻⴼⵔⵉⵖ!’, ⵅⴻⵏⵏⵉ ⵜᵉⵟⵟⴻⴼ ⴰⵢⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS94_19","020_94_19","PSA","94","19","19","ⵎⴰⵍⴰ ⵎⵎⴰⵔⵏⵉⵏ ⴷⴰⵢⵉ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵜⵓⵖⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵓⵙⴼⴻⵡⵡⴻⵊ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS94_20","020_94_20","PSA","94","20","20","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵎⵓⵏ ⵍⴽⵓⵔⵙⵉ ⵏ ⵓⵀⴻⵍⵍⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴹⴻⵏ ⵍⴻⵖⴱⴻⵏ ⵅ ⴷⵙⴰⵙ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("PS94_21","020_94_21","PSA","94","21","21","ⵏⵉⵜⵏⵉ ⵃⴻⵚⵚⴰⵔⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ, ⵛⴻⵀⵀⴷⴻⵏ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵙ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS94_22","020_94_22","PSA","94","22","22","ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS94_23","020_94_23","PSA","94","23","23","ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵙⵙⴻⵄⵇⴻⴱ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⴷ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("PS95_1","020_95_1","PSA","95","1","1","ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵍⵉⵡⵍⴻⵡ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴷⵓⵇⵇⴻⵣ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS95_2","020_95_2","PSA","95","2","2","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⴷⴻⵙ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵙ ⵓⵇⴰⴷⵉ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⴰⵙ ⵏᵉⵙⵍⵉⵡⵍⴻⵡ ⵙ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS95_3","020_95_3","PSA","95","3","3","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⵉⵊⵊ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS95_4","020_95_4","PSA","95","4","4","ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴵⴰⵏ ⵉⵎⵓⵛⴰⵏ ⵢⵓⴵⵖⴻⵏ ⵇⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵜⵉⵇⵉⵛⵛⴰⵜⵉⵏ ⵏ ⵉⴷⵓⵔⴰⵔ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS95_5","020_95_5","PSA","95","5","5","ⵏⵏⴻⵙ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵖⴰⵔ ⵉⵅⵍⴻⵇ ⵉ-ⵜ-ⵉ-ⴷⴷ, ⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⵓⵍⴰ ⴷ ⵍⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS95_6","020_95_6","PSA","95","6","6","ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⴰⵙ ⵏⴱⴻⵏⴷⴻⵇ, ⴰⴷ ⵏⴻⵙⵊⴻⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵊⴻⴷ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("PS95_7","020_95_7","PSA","95","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓ ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵓⴵⵉ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⴰⵙⵙ-ⴰ ⵜⵙⴻⴵⴻⵎ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS95_8","020_95_8","PSA","95","8","8","ⵡⴰⵔ ⵙⵙⴻⵇⵙⵉⵃⴻⵎ ⵛⴰ ⵓⵍ ⵏⵡⴻⵎ, ⴰⵎ ⴷⵉ ⵎⴰⵔⵉⴱⴰ, ⴰⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵎⴰⵙⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("PS95_9","020_95_9","PSA","95","9","9","ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵢⵉ ⵜⵜⵊⴰⵔⵔⴱⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵇⴻⴵⴱⴻⵏ ⴰⵢⵉ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵥⵔⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS95_10","020_95_10","PSA","95","10","10","ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵜⵓⵖⴰ ⵜⵜⵄⵉⴼⴼⴻⵖ ⵊⵊⵉⵍ-ⴰ, ⵏⵏⵉⵖ: “ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵡⵓⵍ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("PS95_11","020_95_11","PSA","95","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ: “ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴷⴼⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⴷⵉ ⴰⵔⵔⴰⵃⴻⵜ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("PS96_1","020_96_1","PSA","96","1","1","ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⴰⵎⴰⵢⵏⵓ, ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("PS96_2","020_96_2","PSA","96","2","2","ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴱⴰⵔⴽⴻⵎ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴱⴻⵛⵛⴰⵔⴻⵎ ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("PS96_3","020_96_3","PSA","96","3","3","ⴱⴰⵔⵔⵃⴻⵎ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⴻⵙ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS96_4","020_96_4","PSA","96","4","4","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵙⴷⴰⵃⴻⴵ ⴰⵙⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴰⴳⴳⵯⴻⴷ ⵎⴰⵀⵓ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS96_5","020_96_5","PSA","96","5","5","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍ’ⴰⵚⵏⴰⵎ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS96_6","020_96_6","PSA","96","6","6","ⵜⵉⵙⵙⵉⵇⵜ ⴷ ⵍⵄⴻⵣⵣ ⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵊⵊⴻⵀⴷ ⴷ ⵡⴰⵥⵔⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS96_7","020_96_7","PSA","96","7","7","ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ, ⴰ, ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⵄⵓⴵⵉ ⴷ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PS96_8","020_96_8","PSA","96","8","8","ⵡⵛⴻⵎ ⵉ ⵙⵉⴷⵉ ⴰⵄⵓⴵⵉ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵡⵢⴻⵎ-ⴷⴷ ⵜⴰⵡⵀⵉⴱⵜ, ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS96_9","020_96_9","PSA","96","9","9","ⴱⴻⵏⴷⴻⵇ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵙ ⵓⵛⴻⵡⵡⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵔⵊⵉⵊⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("PS96_10","020_96_10","PSA","96","10","10","ⵉⵏⵉⵎ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ: “ⵙⵉⴷⵉ ⵉⵃⴻⴽⴽⴻⵎ!” ⵏⵉⵛⴰⵏ, ⵍⴻⵅⵅⵓ ⴷⴷⵓⵏⴻⵛⵜ ⵜⴱⴻⴷⴷ ⵜⴻⵎⵜⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵏⵀⴻⵣⵣⵉ ⵄⴰⴷ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵍⴻⴳⵏⵓⵙ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS96_11","020_96_11","PSA","96","11","11","ⴻⵊⵊ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴰⵔⵛⴻⵇ, ⴻⵊⵊ ⴰⴷ ⵉⵣⵀⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS96_12","020_96_12","PSA","96","12","12","ⴻⵊⵊ ⴰⴷ ⵉⵙⵍⵉⵡⵍⵉⵡ ⵢⴻⵢⵢⴰⵔ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵍⵉⵡⵍⵉⵡⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ ");
INSERT INTO rift_vpl VALUES ("PS96_13","020_96_13","PSA","96","13","13","ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⵜⴰⵎⵎⵓⵔⵜ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⴷⴷⵓⵏⴻⵛⵜ ⵙ ⵜⵙⴻⴳⴷⴰ ⵓ ⵍⴻⴳⵏⵓⵙ ⵙ ⵍⵃⴻⵇⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS97_1","020_97_1","PSA","97","1","1","ⵙⵉⴷⵉ ⵉⵃⴻⴽⴽⴻⵎ, ⴻⵊⵊ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴼⴰⵔⵃ, ⴰⴷ ⴰⵔⴻⵛⵇⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⴻⴳⵣⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS97_2","020_97_2","PSA","97","2","2","ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ, ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴷⵙⴰⵙ ⵏ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS97_3","020_97_3","PSA","97","3","3","ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⴳⴳⵓⵔ ⴰⵙ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵜⵇⴻⴷⴷ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS97_4","020_97_4","PSA","97","4","4","ⴰⵙⵙⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵙⵙⵍⴰⵇⵇⴰⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵜⴰⵎⵎⵓⵔⵜ ⵜⵥⴰⵔⵔ ⵉ-ⵜⵜ, ⵜⴻⵏⵀⴻⵣⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("PS97_5","020_97_5","PSA","97","5","5","ⵉⴷⵓⵔⴰⵔ ⴼⴻⵙⵙⵢⴻⵏ ⴰⵎ ⵛⵛⵎⴻⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS97_6","020_97_6","PSA","97","6","6","ⵉⵊⴻⵏⵡⴰⵏ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵜⵜⵡⴰⵍⴰⵏ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS97_7","020_97_7","PSA","97","7","7","ⴻⵊⵊ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵄⴻⴱⴱⴷⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵍ’ⴰⵚⵏⴰⵎ. ⴱⴻⵏⴷⵇⴻⵎ ⵣⵣⴰⵜⴻⵙ, ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS97_8","020_97_8","PSA","97","8","8","ⵚⵉⵀⵢⵓⵏ ⵉⵙⵍⴰ, ⵉⴼⴰⵔⵃ, ⵢⴻⵙⵙⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵔⴻⵛⵇⴻⵏⵜ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS97_9","020_97_9","PSA","97","9","9","ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴷ ⴰⵎⵄⵓⴵⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS97_10","020_97_10","PSA","97","10","10","ⴽⴻⵏⵏⵉⵡ ⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵙⵉⴷⵉ, ⵛⴰⵔⵀⴻⵎ ⵍⵖⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⵃⴻⵟⵟⴰ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴼⴻⴽⴽⴰ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS97_11","020_97_11","PSA","97","11","11","ⵜⴰⴼⴰⵡⵜ ⵜᵉⵜⵜⵡⴰⵣⴰⵔⵄ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵍ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS97_12","020_97_12","PSA","97","12","12","ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⴼⴰⵔⵃⴻⵎ ⵣⵉ ⵙⵉⴷⵉ, ⵇⴰⴷⴰⵎ ⵅⵎⵉ ⵜᵉⵜⵜⵉⴷⴰⵔⴻⵎ ⵜⴰⵇⴻⴷⴷⴰⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS98_1","020_98_1","PSA","98","1","1","ⴰⵣⴻⵀⵀⵉⴷ. ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ. ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⴷ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS98_2","020_98_2","PSA","98","2","2","ⵙⵉⴷⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ, ⵉⵙⵙⴰⵔⴳⴻⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS98_3","020_98_3","PSA","98","3","3","ⵏⴻⵜⵜⴰ ⵉⵄⵇⴻⵍ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵥⵔⵉⵏⵜ ⴰⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS98_4","020_98_4","PSA","98","4","4","ⴷⵓⵇⵇⵣⴻⵎ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵙⵖⵓⵢⵢⴻⵎ, ⵙⵍⵉⵡⴻⵍⵡⴻⵎ, ⵣⴻⵀⵀⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS98_5","020_98_5","PSA","98","5","5","ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵙⵉⴷⵉ ⵙ ⵍⴳⴰⵎⴱⵔⵉ, ⵙ ⵍⴳⴰⵎⴱⵔⵉ ⵓ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⴻⵣⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("PS98_6","020_98_6","PSA","98","6","6","ⵙ ⵍⴻⴱⵡⴰⵇ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ. ⴷⵓⵇⵇⵣⴻⵎ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS98_7","020_98_7","PSA","98","7","7","ⴻⵊⵊ ⴰⴷ ⵉⵣⵀⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⴰⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS98_8","020_98_8","PSA","98","8","8","ⴻⵊⵊ ⵉⵖⴻⵣⵔⴰⵏ ⴰⴷ ⵡⵜⴻⵏ ⵛⴰⵎⵅⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ, ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵙⵙⵍⵉⵡⵍⴻⵡⴻⵏ ⵊⵎⵉⵄ ");
INSERT INTO rift_vpl VALUES ("PS98_9","020_98_9","PSA","98","9","9","ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵜⵙⴻⴳⴷⴰ, ⵍⴻⴳⵏⵓⵙ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PS99_1","020_99_1","PSA","99","1","1","ⵙⵉⴷⵉ ⵉⵃⴻⴽⴽⴻⵎ, ⴻⵊⵊ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵍⴻⴳⵏⵓⵙ. ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵅ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⴱⴷⴰ ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("PS99_2","020_99_2","PSA","99","2","2","ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵏⴻⵜⵜⴰ ⵢⵓⵄⵍⴰ ⴰⵟⵟⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS99_3","020_99_3","PSA","99","3","3","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵇⴰⴷⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: “ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("PS99_4","020_99_4","PSA","99","4","4","ⵊⵊⴻⵀⴷ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵍⵃⴻⵇⵇ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵉ ⵜⵙⴻⴳⴷⴰ, ⵜⴻⴳⴳⵉⴷ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS99_5","020_99_5","PSA","99","5","5","ⵙⵄⵓⴵⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴱⴻⵏⴷⵇⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PS99_6","020_99_6","PSA","99","6","6","ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⵛⴰⵎⵡⵉⵍ ⵜⵓⵖⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵍⴰⵖⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS99_7","020_99_7","PSA","99","7","7","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵍⵍⵉⵊ ⵏ ⵓⵙⴻⵢⵏⵓ. ⵏⵉⵜⵏⵉ ⵃⴹⴰⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS99_8","020_99_8","PSA","99","8","8","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⴰⵙⴻⵏ. ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵖⴻⴼⴼⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵓⵎⵜⴰⵇⴻⵎ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS99_9","020_99_9","PSA","99","9","9","ⵙⵄⵓⴵⴻⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴱⴻⵏⴷⵇⴻⵎ ⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵉ ⵉⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("PS100_1","020_100_1","PSA","100","1","1","ⵉⵣⵍⵉ ⵏ ⵓⵇⴰⴷⵉ. ⴻⵊⵊ ⴰⴷ ⵜᵉⴷⴷⵓⵇⵇⴻⵣ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS100_2","020_100_2","PSA","100","2","2","ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰⵙⴻⵎ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS100_3","020_100_3","PSA","100","3","3","ⵙⵏⴻⵎ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⴻⴵⴰ. ⵏⴻⵜⵜⴰ ⵉⵅⵍⴻⵇ ⴰⵏⴻⵖ-ⴷⴷ ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⵏⴻⵙ ⵉ ⵏⴻⴵⴰ, ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵡⵓⴵⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS100_4","020_100_4","PSA","100","4","4","ⴰⴷⴼⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵙ ⵓⵇⴰⴷⵉ, ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏⵏⴻⵙ ⵙ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ, ⵇⴰⴷⴰⵎ ⵜ, ⴱⴰⵔⴽⴻⵎ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS100_5","020_100_5","PSA","100","5","5","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS101_1","020_101_1","PSA","101","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵏⴻⵛⵛ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⵃⴻⵇⵇ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS101_2","020_101_2","PSA","101","2","2","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵙ ⵍⴻⵄⵇⴻⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⴽⴻⵎⵎⵍⴻⵏ. ⵎⴻⵍⵎⵉ ⵖⴰⵔⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ? ⵏⴻⵛⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵙ ⵡⵓⵍ ⵏⵉⵛⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS101_3","020_101_3","PSA","101","3","3","ⵏⴻⵛⵛ ⵡⴰⵔ ⵏⴻⵟⵟⴰⵔⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴷⵉ ⵎⵉⵏ ⵉⴼⴻⴹⵃⴻⵏ. ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵃⴻⵢⵢⴷⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵍⴻⵚⵚⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("PS101_4","020_101_4","PSA","101","4","4","ⵓⵍ ⵉⵜⵜⴻⴼⵔⵉⵖⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⴰⴼⵉ ⵢⴰⴳⴳⵯⴻⵊ, ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS101_5","020_101_5","PSA","101","5","5","ⵡⴻⵏⵏⵉ ⵉⵛⴻⵇⵇⴼⴻⵏ ⴷⴻⴳ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⴰⴷ ⵜ ⵜⴻⵃⵃⵉⵖ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⴱⴱⴰⵔⴻⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴻⴼⴼⴰⵔⴻⵏ ⵙ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜ ⴽⴻⵙⵙⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS101_6","020_101_6","PSA","101","6","6","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⵔⴻⵣⵣⵓⵏⵜ ⵅ ⵉⵎⵜⵉⵇⵇⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⵉ ⵇⵇⵉⵎⴻⵏ. ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⴽⴻⵎⵎⵍⴻⵏ, ⴰⴷ ⴰⵢⵉ ⵉⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS101_7","020_101_7","PSA","101","7","7","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS101_8","020_101_8","PSA","101","8","8","ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵎⵃⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS102_1","020_102_1","PSA","102","1","1","ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⵉⵊⵊ ⵏ ⵍⵎⴻⵙⴽⵙⵉⵏ ⵎⴰⵍⴰ ⵎⴰⵏⴰⵢⴻⵏⵏⵉ ⴷ ⴰⵟⵟⴰⵙ ⵅⴰⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴼⴰⵔⵔⴻⵖ ⵉⵎⵓⵏⴰⵙ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS102_2","020_102_2","PSA","102","2","2","ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵖⵓⵢⵢⵉ ⵉⵏⵓ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("PS102_3","020_102_3","PSA","102","3","3","ⵡⴰⵔ ⵜⵜⴻⴼⴼⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵅⴰⴼⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ. ⴰⵔⵔ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵍⴰⵖⵉⵖ, ⵙⴻⵍ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS102_4","020_102_4","PSA","102","4","4","ⵎⵉⵏⵣⵉ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵄⴷⵓⵏ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ, ⵉⵅⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⵜⴻⴼⵇⵓⵏⵜ ⵉⵛⴻⵎⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS102_5","020_102_5","PSA","102","5","5","ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵉⵙⵍⴰⵡ ⵓ ⵢⵓⵥⴻⵖ ⴰⵎ ⴰⵔⴱⵉⵄ, ⴰⵍⴰⵎⵉ ⵜⵜⵓⵖ ⴰⴷ ⵛⵛⴻⵖ ⴰⵖⵔⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS102_6","020_102_6","PSA","102","6","6","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵣⴻⵀⵀⴰⵔ ⵢⵓⴵⵖⴻⵏ ⵉⵏⵓ, ⵍⴻⵚⵇⴻⵏ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵍⵎⴻⵛⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS102_7","020_102_7","PSA","102","7","7","ⵏⴻⵛⵛ ⴰⵎ ⵢⵉⵊⵊ ⴱⵓ-ⵓⵄⵓⵇⵇⵉ ⵏ ⵓⵊⴹⵉⴹ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵎⵓⴽⴰ ⵊⴰⵔ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS102_8","020_102_8","PSA","102","8","8","ⵜⵜⵖⵉⵎⴻⵖ ⴼⴰⵇⴻⵖ ⵙ ⵍⴻⴼⵜⴰⵏⴻⵜ, ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵡⴻⵃⵃⴷⴻⵙ ⵅ ⵜⵣⴻⵇⵇⴰ. ");
INSERT INTO rift_vpl VALUES ("PS102_9","020_102_9","PSA","102","9","9","ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵜⵜⴻⴽⴽⵡⴰⵔⴻⵏ ⴰⵢⵉ ⴰⵙⵙ ⵎⴰⵔⵔⴰ. ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ, ⵏⴻⵄⵄⵍⴻⵏ ⴰⵎ ⵇⵇⴰⵔⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS102_10","020_102_10","PSA","102","10","10","ⵎⴰⵖⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ ⵉⵖⵖⴻⴹ ⴰⵎ ⵡⴻⵖⵔⵓⵎ ⵓ ⵅⴻⴵⴹⴻⵖ ⵜⵉⵙⴻⵙⵙⵉⵜ ⵉⵏⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵏⵓ ");
INSERT INTO rift_vpl VALUES ("PS102_11","020_102_11","PSA","102","11","11","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵛ ⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⵢⵉ ⵓ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵢⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS102_12","020_102_12","PSA","102","12","12","ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵉⵍⵉ ⵉⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ, ⵓ ⵏⴻⵛⵛ ⵜⴰⵥⵖⴻⵖ ⴰⵎ ⵜⵓⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS102_13","020_102_13","PSA","102","13","13","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⴽ ⵉ ⵍⴻⴱⴷⴰ, ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⴰⴷ ⴷⴰⵢⴻⴽ ⵅⴰⵔⵔⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS102_14","020_102_14","PSA","102","14","14","ⵛⴻⴽ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⴰⴷ ⵜⴰⵔⵃⵎⴻⴷ ⵅ ⵚⵉⵀⵢⵓⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷ ⵍⵡⴻⵇⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵜⵃⵉⵏⵏⴻⴷ, ⵎⵉⵏⵣⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PS102_15","020_102_15","PSA","102","15","15","ⵎⴰⵖⴰⵔ ⵉⵥⵔⴰ ⵏⵏⴻⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵙ ⵡⴻⵙⵃⵉⵙⵙⴻⴼ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS102_16","020_102_16","PSA","102","16","16","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS102_17","020_102_17","PSA","102","17","17","ⵅⵎⵉ ⵖⴰ ⵉⴱⵏⴰ ⵙⵉⴷⵉ ⵚⵉⵀⵢⵓⵏ ⵜⵡⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉⵜ, ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS102_18","020_102_18","PSA","102","18","18","ⴰⴷ ⵉⵍⵀⴰ ⴰⴽ-ⴷ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⴻⵣⵍⵓⴹ, ⵡⴰⵔ ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⵛⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS102_19","020_102_19","PSA","102","19","19","ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⵔⵉ ⵉ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ, ⴰⴷ ⵉⵚⴻⴱⴱⴻⵃ ⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("PS102_20","020_102_20","PSA","102","20","20","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵙⵙⵉⵊⵊ-ⴷⴷ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵢⵓⵄⵍⴰⵏ, ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉⵅⵣⴰⵔ-ⴷⴷ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ ");
INSERT INTO rift_vpl VALUES ("PS102_21","020_102_21","PSA","102","21","21","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵍ ⴰⵡⴻⵄⵄⴻⴹ ⵏ ⵓⵎⴻⵃⴱⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵍⵎⴻⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("PS102_22","020_102_22","PSA","102","22","22","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴷ ⵛⵛⴻⵏⵄⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("PS102_23","020_102_23","PSA","102","23","23","ⵅⵎⵉ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS102_24","020_102_24","PSA","102","24","24","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵅⵓ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵡⴻⴱⵔⵉⴷ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵎⵥⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS102_25","020_102_25","PSA","102","25","25","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴽⴻⵙⵙⵉ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵛ ⵜⵜⵖⵉⵎⴰⵏ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS102_26","020_102_26","PSA","102","26","26","ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵜⴻⴳⴳⵉⴷ ⴷⵙⴰⵙ ⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS102_27","020_102_27","PSA","102","27","27","ⵉⵏⴰ ⴰⴷ ⴼⵏⴰⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴷⵓⵎⴻⴷ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⴰⵔⵛⴰⵏ ⴰⵎ ⵡⴰⵔⵔⵓⴹ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴱⴻⴷⴷⵍⴻⴷ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴻⵄⴱⴰⵢⴻⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵜⵡⴰⴱⴻⴷⴷⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS102_28","020_102_28","PSA","102","28","28","ⵛⴻⴽ ⵎⴰⵛⴰ ⴷ ⵛⴻⴽ, ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵛ ⵡⴰⵔ ⵇⴻⵟⵟⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ.’ ");
INSERT INTO rift_vpl VALUES ("PS102_29","020_102_29","PSA","102","29","29","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⵓ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⴻⵜⵏⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS103_1","020_103_1","PSA","103","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_2","020_103_2","PSA","103","2","2","ⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_3","020_103_3","PSA","103","3","3","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵉⵖⴻⴼⴼⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵏⴼⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS103_4","020_103_4","PSA","103","4","4","ⵡⴻⵏⵏⵉ ⵉⴼⴷⵉⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵣⵉ ⵜⵓⵔⵚⵓⴹⵉ, ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⴳⴳⵉⵏ ⵜⵜⴰⵊ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PS103_5","020_103_5","PSA","103","5","5","ⵡⴻⵏⵏⵉ ⵉⵙⵙⵊⵊⴰⵡⴰⵏⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ ⴰⵎ ⵓⴳⵉⴷⴻⵔ. ");
INSERT INTO rift_vpl VALUES ("PS103_6","020_103_6","PSA","103","6","6","ⵙⵉⴷⵉ ⵉⵜⵜⴻⴳⴳ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_7","020_103_7","PSA","103","7","7","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵛⴻⵏ ⵉ ⵎⵓⵙⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS103_8","020_103_8","PSA","103","8","8","ⵙⵉⴷⵉ ⴷ ⴰⵔⵃⵉⵎ ⴷ ⴰⵃⵏⵉⵏ, ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⵉⵛⵛⵓⵔ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_9","020_103_9","PSA","103","9","9","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵜⵜⵅⴻⵢⵢⵉⵇ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS103_10","020_103_10","PSA","103","10","10","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵅⴻⴵⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("PS103_11","020_103_11","PSA","103","11","11","ⵎⴰⵖⴰⵔ ⴰⵎ ⵓⵊⴻⵏⵏⴰ ⵢⵓⵄⵍⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵜⴻⵎⵖⴰⵔ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⵉⵡⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_12","020_103_12","PSA","103","12","12","ⴰⵎ ⵉⴳⴳⵯⴻⵊ ⵛⵛⴰⵔⵇ ⵅ ⵍⵖⴰⵔⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵏⴻⵜⵜⴰ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵏⴻⵖ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS103_13","020_103_13","PSA","103","13","13","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵃⵉⵏⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵃⵉⵏⵏ ⵙⵉⴷⵉ ⵅ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_14","020_103_14","PSA","103","14","14","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵜⵜⵡⴰⴳⴳ, ⵉⵄⵇⴻⵍ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS103_15","020_103_15","PSA","103","15","15","ⵓⵙⵙⴰⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵎⴻⵛⵏⴰⵡ ⵜⵓⴳⴰ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⵏⵓⵡⴰⵔ ⴰⵎ ⵜⵏⵓⵡⵡⴰⵛⵜ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS103_16","020_103_16","PSA","103","16","16","ⵎⴰⵍⴰ ⵉⴽⴽⴰ-ⴷⴷ ⵅⴰⵙ ⵓⵙⴻⵎⵎⵉⴹ, ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵓ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴱⴻⴷⴷ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⵉⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS103_17","020_103_17","PSA","103","17","17","ⵎⴰⵛⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ ⵜⵉⵡⴰ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵓ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵡⴰⵔⵔⴰⵡ ⵏ ⵡⴰⵔⵔⴰⵡ, ");
INSERT INTO rift_vpl VALUES ("PS103_18","020_103_18","PSA","103","18","18","ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵓ ⵉⵄⴻⵇⵇⵍⴻⵏ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_19","020_103_19","PSA","103","19","19","ⵙⵉⴷⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵜⵃⴻⴽⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS103_20","020_103_20","PSA","103","20","20","ⴱⴰⵔⴽⴻⵏⵜ ⵙⵉⴷⵉ, ⴽⴻⵏⵏⵉⵏⵜ, ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS103_21","020_103_21","PSA","103","21","21","ⴱⴰⵔⴽⴻⵏⵜ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵙ, ⴽⴻⵏⵏⵉⵡ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⴰⵔⴻⵛⵇⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS103_22","020_103_22","PSA","103","22","22","ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ, ⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴷⵉ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵜⴻⴵⴰ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ. ⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS104_1","020_104_1","PSA","104","1","1","ⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ! ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵛⴻⴽ! ⵛⴻⴽ ⵜⵢⴰⵔⴹⴻⴷ ⵙ ⵍⵄⴰⴹⴰⵎⴰ ⴷ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("PS104_2","020_104_2","PSA","104","2","2","ⵏⴻⵜⵜⴰ ⵉⵍⴻⵃⵃⴻⴼ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵜⴼⴰⵡⵜ ⴰⵎ ⵙ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴱⴻⵣⵣⴻⵄ ⴰⵊⴻⵏⵏⴰ ⴰⵎ ⵜⵊⴰⵔⵜⵉⵍⵜ ⵏ ⵓⵇⵉⴹⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS104_3","020_104_3","PSA","104","3","3","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵙⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵡⴻⵙⵇⴻⴼ ⵙⴰⴷⵓ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵅ ⵡⴰⵎⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⴰⴽⴰⵔⵔⵓ ⵏⵏⴻⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ");
INSERT INTO rift_vpl VALUES ("PS104_4","020_104_4","PSA","104","4","4","ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵓ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS104_5","020_104_5","PSA","104","5","5","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS104_6","020_104_6","PSA","104","6","6","ⵛⴻⴽ ⵜⵍⴻⵃⵃⴼⴻⴷ ⴰⵙ ⵙ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴰⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ, ⴰⵎⴰⵏ ⴱⴻⴷⴷⴻⵏ ⵜⵉⵡⴰ ⵉ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS104_7","020_104_7","PSA","104","7","7","ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵓⵙⵉⴳⴳⵯⴻⴷ ⵏⵏⴻⵛ, ⵇⴻⴵⵇⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵊⵊⴰⵊ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS104_8","020_104_8","PSA","104","8","8","ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⴷⵓⵔⴰⵔ, ⵀⴻⴽⴽⵡⴰⵏⵜ ⵜⴻⵢⵙⴰⵔⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⴳⴳⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS104_9","020_104_9","PSA","104","9","9","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵎⵉⵔ ⵉ ⵡⴰⵎⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵄⴻⴷⴷⵓⵏ, ⵡⴰⵔ ⴷⴷ-ⴷⴻⴽⴽⵡⵉⵍⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵍⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS104_10","020_104_10","PSA","104","10","10","ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵜⴰⵍⴰⵡⵉⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ, ⴰⵇⴰ ⵜⵜⴰⵣⵣⵍⴻⵏⵜ ⴷⵉⵏ ⵊⴰⵔ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS104_11","020_104_11","PSA","104","11","11","ⴰⵇⴰ ⵡⴰⵔⵔⴷⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵉⵖⵢⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⵜⵜⴻⴽⴽⵙⴻⵏ ⴰⴼⴰⴷⵉ ⵏⵙⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS104_12","020_104_12","PSA","104","12","12","ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵣⵉ ⵊⴰⵔ ⵍⴻⴼⵔⵓⵄ ⵜᵉⵜⵜⴻⴽⴽ-ⴷⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS104_13","020_104_13","PSA","104","13","13","ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵙⵓⵏ ⵉⴷⵓⵔⴰⵔ ⵣⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵢⴰⵡⴰⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS104_14","020_104_14","PSA","104","14","14","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵔⴱⵉⵄ ⵉⵖⴻⵎⵎⵉ ⵉ ⵍⵎⴰⵔ, ⵓⵍⴰ ⴷ ⴰⵖⴻⵎⵎⵓⵢ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴱⵏⴰⴷⴻⵎ. ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⵖⵔⵓⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ");
INSERT INTO rift_vpl VALUES ("PS104_15","020_104_15","PSA","104","15","15","ⵓ ⴱⵉⵏⵓ ⵏⵏⵉ ⵉⵙⵙⴼⴰⵔⵔⴰⵃⴻⵏ ⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ., ⴰⵍⴰⵎⵉ ⵉⵖⴻⵎⴱⴰⴱ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵡⴻⵙⵙⴳⴻⵏ ⵎⴰⵀⵓ ⵣⵉ ⵣⵣⴻⵛⵜ, ⵓⵍⴰ ⴷ ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS104_16","020_104_16","PSA","104","16","16","ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵙⵉⴷⵉ ⵜⵜⵢⴰⵡⴰⵏⴻⵏⵜ, ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵏ ⵍⵓⴱⵏⴰⵏ ⵏⵏⵉ ⵉⵥⵥⵓ ⵏⴻⵜⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("PS104_17","020_104_17","PSA","104","17","17","ⵎⴰⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵊⴹⴰⴹ ⵍⵄⵓⵛⵛ ⵏⵙⴻⵏ, ⵎⴰⵏⵉ ⵉ ⵜⴻⴵⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⴱⴻⵍⵍⴰⵔⵊ ⴷⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵔⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("PS104_18","020_104_18","PSA","104","18","18","ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵉ ⵉⵖⴰⵢⴹⴻⵏ ⵏ ⵜⵚⵓⴹⴰⵔ, ⵍⴻⵊⵔⵓⴼ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵉⴽⴰⵡⴽⴰⵡⴻⵏ ⵏ ⵜⴻⵚⴹⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS104_19","020_104_19","PSA","104","19","19","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⵣⵉⵔⵉ ⴷ ⵍⴻⵄⴱⴰⵔ ⵉ ⵍⴻⵡⵇⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵜⴰⴼⵓⵛⵜ ⵜⴻⵙⵙⴻⵏ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵜⴻⵖⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS104_20","020_104_20","PSA","104","20","20","ⵛⴻⴽ ⵜⴻⵙⵙⴻⴽⴽⵉⴷ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵓ ⵜⴻⵡⴹⴰ-ⴷⴷ ⴵⵉⵍⴻⵜ ⵉ ⴷⵉ ⵜⵜⴻⵅⵜⵓⵜⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵃⵓⵛ ⵏ ⵡⴻⵣⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS104_21","020_104_21","PSA","104","21","21","ⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵣⴻⵀⵀⴰⵔⴻⵏ ⵅ ⵣⵣⴰⵔⴷⴻⵜ, ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵎⴰⵛⵛⴰ ⵏⵙⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PS104_22","020_104_22","PSA","104","22","22","ⵎⴰⵍⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵜⴼⵓⵛⵜ, ⵜⵜⴻⵛⵔⵓⵔⵓⴷⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⴳⴻⵃ, ⵜⵜⵖⴻⵎⵎⴰⵔⴻⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS104_23","020_104_23","PSA","104","23","23","ⵅⴻⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⴻⵖ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⵉ ⵏⵏⴻⵙ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PS104_24","020_104_24","PSA","104","24","24","ⵎⴰⵎⵎⴻⵛ ⴰⵟⵟⴰⵙ ⵉ ⵜⴻⴳⴳⵉⴷ, ⴰ ⵙⵉⴷⵉ, ⵙ ⵜⵉⵖⵉⵜ ⵉ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS104_25","020_104_25","PSA","104","25","25","ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⴱⵃⴰⵔ ⵉⵎⵖⴰⵔ, ⵢⵉⵔⵉⵡ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵏⵉ ⵉⵙⵙⴼⵓⴼⴼⴻⵢ ⵎⴰⵔⵔⴰ ⵙ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("PS104_26","020_104_26","PSA","104","26","26","ⵎⴰⵏⵉ ⴳⴳⵓⵔⴻⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ, ⵓⵍⴰ ⴷ ‘ⵍⵉ$ⵉⵢⴰⵜⴰⵏ’ ⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS104_27","020_104_27","PSA","104","27","27","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵔⴰⵊⴰⵏ ⵛⴻⴽ, ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⴻⴷ ⵎⴰⵛⵛⴰ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS104_28","020_104_28","PSA","104","28","28","ⵎⴰⵍⴰ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ, ⵢⴰⵔⵔⵡⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵍⴰ ⵜⴰⵔⵣⵎⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⴷⴷⴰⴽⴽⵡⴰⵍⴻⵏ ⵊⵊⵉⵡⵏⴻⵏ ⵙ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS104_29","020_104_29","PSA","104","29","29","ⵎⴰⵍⴰ ⵜⴻⴼⴼⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵏ, ⵎⴰⵍⴰ ⵜⴽⴻⵙⵙⵉⴷ ⴰⵙⴻⵏ ⵏⵏⴻⴼⵙ, ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⵓⵃⴱⴻⵍ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵓⵛⴰⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS104_30","020_104_30","PSA","104","30","30","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ, ⴰⴷ ⵜⴰⵔⵔⵉⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴰⵢⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS104_31","020_104_31","PSA","104","31","31","ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⴻⴱⴷⴰ, ⵙⵉⴷⵉ ⴰⴷ ⵉⴼⴰⵔⵃ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS104_32","020_104_32","PSA","104","32","32","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵅⴻⵣⵣⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜᵉⵜⵜⴰⵔⵊⵉⵊⵉ, ⵎⴰⵍⴰ ⵉⵃⴰⴷⴰ ⵉⴷⵓⵔⴰⵔ, ⴰⴷ ⴷⵓⵅⵅⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS104_33","020_104_33","PSA","104","33","33","ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵉ ⵙⵉⴷⵉ ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵖ ⴷⴷⴰⵔⴻⵖ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵎⵉⵏ ⴷⴰ ⵉ ⵖⴰ ⴽⴽⴻⵖ ⴵⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS104_34","020_104_34","PSA","104","34","34","ⴰⵅⴻⵎⵎⴻⵎ ⵉⵏⵓ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⴷⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS104_35","020_104_35","PSA","104","35","35","ⵉⵎⴻⴷⵏⴰⴱ ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵇⴰⵄ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ. ⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PS105_1","020_105_1","PSA","105","1","1","ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵍⴰⵖⴰⵎ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_2","020_105_2","PSA","105","2","2","ⵖⴻⵏⵏⵊⴻⵎ ⴰⵙ, ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵏⴻⵜⵜⴰ, ⵙⵉⵡⵍⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_3","020_105_3","PSA","105","3","3","ⵛⴻⵏⵏⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⵓⵍ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("PS105_4","020_105_4","PSA","105","4","4","ⵙⴻⵇⵙⴰⵎ ⵅ ⵙⵉⴷⵉ ⴷ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⴰⵔⵣⵓⵎ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS105_5","020_105_5","PSA","105","5","5","ⵄⴻⵇⵍⴻⵎ ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ, ⵅ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_6","020_105_6","PSA","105","6","6","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS105_7","020_105_7","PSA","105","7","7","ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵙ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS105_8","020_105_8","PSA","105","8","8","ⵄⴻⵇⵍⴻⵎ ⵅ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵡⴻⵚⵚⴰ ⵉ ⵡⴰⵍⴻⴼ ⵏ ⵊⵊⵉⵍⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("PS105_9","020_105_9","PSA","105","9","9","ⵉ ⵉⴳⴳⴰ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ, ⵓ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉ-ⵜ ⵙ ⵜⵊⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵉ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("PS105_10","020_105_10","PSA","105","10","10","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉ ⵉⵙⵔⴰⵉⵍ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS105_11","020_105_11","PSA","105","11","11","ⵓⵎⵉ ⵉⵏⵏⴰ: “ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("PS105_12","020_105_12","PSA","105","12","12","ⵓⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵙ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵓ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉ ⵜⴻⴵⵉⵎ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_13","020_105_13","PSA","105","13","13","ⵏⵉⵜⵏⵉ ⵜⴻⵍⵄⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ, ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS105_14","020_105_14","PSA","105","14","14","ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵃⵚⴰⵔ, ⵉⵄⴰⵇⴻⴱ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_15","020_105_15","PSA","105","15","15","ⵡⴰⵔ ⵜⵜⵃⴰⴷⴰⵎ ⵛⴰ ⵉⵎⴻⴷⵀⵓⵏⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵍⵖⴰⵔ ⴷⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS105_16","020_105_16","PSA","105","16","16","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵍⴰⵥ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⵢⴰⵔⵥⴰ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PS105_17","020_105_17","PSA","105","17","17","ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵢⵓⵙⵓⴼ ⵉⵎⵎⴻⵏⵣ ⴷ ⵉⵙⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS105_18","020_105_18","PSA","105","18","18","ⵛⴰⵔⴼⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ ⴷⴻⴳ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS105_19","020_105_19","PSA","105","19","19","ⴰⵍ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵇⴼⴻⵍ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉⵚⴻⴼⴼⴰ ⴰⵙ ⵍⵀⴰⵔⴷ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS105_20","020_105_20","PSA","105","20","20","ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵊ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵙⵙⴰⵔⵅⵓ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⴹⵍⴻⵇ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS105_21","020_105_21","PSA","105","21","21","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴱⴰⴱ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_22","020_105_22","PSA","105","22","22","ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵛⴻⴷⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵜⵉⵖⵉⵜ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_23","020_105_23","PSA","105","23","23","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵉⵇⵇⵉⵎ ⵢⴰⵄⵇⵓⴱ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS105_24","020_105_24","PSA","105","24","24","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ, ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⵉⵊⵀⴻⴷ ⵅ ⵢⵉⵏⵏⵉ ⵜ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_25","020_105_25","PSA","105","25","25","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ ⵉⵏⵏⴻⵇⵍⴻⴱ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵛⴰⵔⵔⵀⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴷⴻⵡⵍⴻⵏ ⵖⴻⴷⴷⴰⵔⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_26","020_105_26","PSA","105","26","26","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ⴷ ⵀⴰⵔⵓⵏ ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣ ⵉ-ⵜ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PS105_27","020_105_27","PSA","105","27","27","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵙⴻⵏ ⵉⴼⴰⵔⵣⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵓ ⴳⴳⵉⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS105_28","020_105_28","PSA","105","28","28","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵎⴰⵔⵔⴰ ⴷ ⵜⴰⴵⴻⵙⵜ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴻⵡⵡⵖⴻⵏ ⵛⴰ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS105_29","020_105_29","PSA","105","29","29","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵎⴰⵏ ⵏⵙⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵉⵏⵖⴰ ⵉⵙⴻⵍⵎⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_30","020_105_30","PSA","105","30","30","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⵙⴻⴼⴼⴰⵢ ⵙ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ, ⴰⵍ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_31","020_105_31","PSA","105","31","31","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵢⵍⴰⴼ ⵏ ⵉⴱⴻⵄⵄⴰⵛ, ⵏⵏⴰⵎⵓⵙ ⵡⴹⴰⵏ-ⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS105_32","020_105_32","PSA","105","32","32","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵏⵥⴰⵔ ⵏⵙⴻⵏ ⴷ ⴰⴱⵔⵓⵔⵔⵉ, ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵉⵛⴻⵄⵄⴰⵍⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_33","020_105_33","PSA","105","33","33","ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏⵙⴻⵏ ⴷ ⵡⴰⵔⵜⵓ ⵏⵙⴻⵏ, ⵢⴰⵔⵥⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_34","020_105_34","PSA","105","34","34","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ, ⵅⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⵜⵎⵓⵖⵔⵉ, ⵓⵍⴰ ⴷ ⴱⵓ-ⵡⴻⵍⵙⴰⵃ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PS105_35","020_105_35","PSA","105","35","35","ⵏⵉⵜⵏⵉ ⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴼⵙⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵛⵛⵉⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_36","020_105_36","PSA","105","36","36","ⵏⴻⵜⵜⴰ ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵉⵎⴻⵏⵣⴰ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵢⴰⵙⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_37","020_105_37","PSA","105","37","37","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵙⴻⵏ ⵉ ⵉⵏⴷⴻⵔⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS105_38","020_105_38","PSA","105","38","38","ⵎⵉⵚⵔⴰ ⵜⴼⴰⵔⵃ ⵙ ⵡⵓⴼⴼⵓⵖ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴻⵡⴹⴰ ⵅⴰⵙⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS105_39","020_105_39","PSA","105","39","39","ⵏⴻⵜⵜⴰ ⵉⴱⴻⵣⵣⴻⵄ ⴰⵙⴻⵢⵏⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴰⵔⵡⴰⵇ ⵓ ⵜⵎⴻⵙⵙⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵡⵛ ⵜⴰⴼⴰⵡⵜ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS105_40","020_105_40","PSA","105","40","40","ⵏⵉⵜⵏⵉ ⵥⵥⵓⴵⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵊⴹⴰⴹ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵜⵙⴰⵍⵡⴰ’, ⵉⵙⵙⵊⵊⵉⵡⴻⵏ ⵉ-ⵜⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS105_41","020_105_41","PSA","105","41","41","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⵎ ⵜⴰⵚⴹⴰⵔⵜ, ⴰⵎⴰⵏ ⴷⵓⵇⵇⵣⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ, ⵓⵣⵣⵍⴻⵏ ⵅ ⵍⴰⵥⴰⵖ ⵓ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵢⴻⵖⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS105_42","020_105_42","PSA","105","42","42","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵄⵇⴻⵍ ⵅ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("PS105_43","020_105_43","PSA","105","43","43","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS105_44","020_105_44","PSA","105","44","44","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜⵉⵎⵎⵓⵔⴰ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵏⵉⵜⵏⵉ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⴰⵔⴰ ⵏ ⵛⵛⵓⵄⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("PS105_45","020_105_45","PSA","105","45","45","ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵃⴹⴰⵏ ⵉⵣⴻⵔⴼⴰⵏ ⵏⵏⴻⵙ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS106_1","020_106_1","PSA","106","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ, ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_2","020_106_2","PSA","106","2","2","ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵃⴰⵊⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵏ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PS106_3","020_106_3","PSA","106","3","3","ⵙⵙⴻⵄⴷ ⵏⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⵃⴹⴰⵏ ⵍⵃⴻⵇⵇ, ⵙⵙⴻⵄⴷ ⵏⵏⴻⵙ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⴱⴷⴰ ⵜⴰⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_4","020_106_4","PSA","106","4","4","ⵄⵇⴻⵍ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵙ ⴰⵔⴹⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵄⴰⵀⴻⴷ ⴰⵢⵉ ⵙ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS106_5","020_106_5","PSA","106","5","5","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵖ ⵍⵅⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⵙ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS106_6","020_106_6","PSA","106","6","6","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵏⴻⴳⴳⴰ ⵍⵖⴻⵛⵛ, ⵏⴻⴳⴳⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_7","020_106_7","PSA","106","7","7","ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴷⵉ ⵎⵉⵚⵔⴰ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵉ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵅⴰⵔⵔⵚⴻⵏ ⴷⴻⴳ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵖⴻⵡⵡⵖⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_8","020_106_8","PSA","106","8","8","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS106_9","020_106_9","PSA","106","9","9","ⵏⴻⵜⵜⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵢⵓⵥⴻⵖ, ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⴽⴽⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵊⴰⵔ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴰⵅⵎⵉ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_10","020_106_10","PSA","106","10","10","ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("PS106_11","020_106_11","PSA","106","11","11","ⴰⵎⴰⵏ ⴷⵍⵉⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_12","020_106_12","PSA","106","12","12","ⵏⵉⵜⵏⵉ ⵜⵜⴻⵛⵍⴻⵏ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵚⴻⴱⴱⵃⴻⵏ ⴰⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PS106_13","020_106_13","PSA","106","13","13","ⵎⴰⵛⴰ ⵜⵜⵓⵏ ⴷⴻⵖⵢⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵔⴰⵊⴰⵏ ⵄⴰⴷ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS106_14","020_106_14","PSA","106","14","14","ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵎⴻⵖⵖⵍⴻⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵇⴻⴵⴱⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("PS106_15","020_106_15","PSA","106","15","15","ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵎⵉⵏ ⵜⵜⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉⵙⵙⴻⵎⵥⵉ ⵍⵇⴻⴷⴷ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_16","020_106_16","PSA","106","16","16","ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵓⵙⵎⴻⵏ ⵣⵉ ⵎⵓⵙⴰ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵓⵍⴰ ⵣⵉ ⵀⴰⵔⵓⵏ, ⴰⵎⵇⴻⴷⴷⴻⵙ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS106_17","020_106_17","PSA","106","17","17","ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ, ⵜⵚⴰⵔⴹ ⴷⴰⵜⴰⵏ, ⵓⵛⴰ ⵜⴻⵏⵜⵉⵢ ⴰⴱⴰⵔⵔⵓ ⵏ ⴰⴱⵉⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS106_18","020_106_18","PSA","106","18","18","ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⴱⴷⴰ ⵜⴻⵛⵎⴻⴹ ⵊⴰⵔ ⵓⴱⴰⵔⵔⵓ ⵏⵙⴻⵏ, ⵉⵊⵊ ⵏ ⵓⵛⴻⵄⵄⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵇⵇⴻⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS106_19","020_106_19","PSA","106","19","19","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵖⴰⵔ ⵃⵓⵔⵉⴱ, ⴱⴻⵏⴷⵇⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_20","020_106_20","PSA","106","20","20","ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⵍⴻⵏ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵍⴻⵅⵢⴰⵍ ⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⴰⵔⴱⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("PS106_21","020_106_21","PSA","106","21","21","ⵜⵜⵓⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵉⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("PS106_22","020_106_22","PSA","106","22","22","ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎ, ⵜⵉⵎⴻⴳⴳⴰ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏⵜ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_23","020_106_23","PSA","106","23","23","ⵉⵏⵏⴰ ⴰⵇⴰ ⴰⴷ ⵜⴻⵏ ⵉⴽⴻⵃⵃⴻⴹ, ⵎⵍⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵎⵓⵙⴰ, ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⴷⵉ ⵜⵅⴻⵏⴷⵓⵇⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("PS106_24","020_106_24","PSA","106","24","24","ⵏⵉⵜⵏⵉ ⴽⴽⵙⴻⵏ ⵜⴰⵇⵛⵓⵔⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵄⵉⵣⵣⴻⵏ, ⵡⴰⵔ ⵜⴻⵛⵍⴻⵏ ⵛⴰ ⵅ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS106_25","020_106_25","PSA","106","25","25","ⵏⵉⵜⵏⵉ ⵏⴷⴻⵇⵎⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS106_26","020_106_26","PSA","106","26","26","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅⴰⵙⴻⵏ, ⵉⵊⵊⵓⴵ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵖⴹⴻⵍ ⴷⵉ ⵍⴻⵅⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("PS106_27","020_106_27","PSA","106","27","27","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵖⴹⴻⵍ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵣⴻⴵⴻⵄ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_28","020_106_28","PSA","106","28","28","ⵏⵉⵜⵏⵉ ⵙⵙⵍⴻⵃⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⴱⴰⵄⴰⵍ-ⴼⴰⵖⵓⵔ, ⵛⵛⵉⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵉⵎⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_29","020_106_29","PSA","106","29","29","ⵙⵄⴰⵔⴻⵏ ⵜ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⴷⴷ ⵅⴰⵙⴻⵏ ⵜⴻⵡⴹⴰ ⵊⵊⵔⵉⵃⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS106_30","020_106_30","PSA","106","30","30","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ-ⴷⴷ ⴼⵉⵏⴰⵃⴰⵙ, ⵢⵓⵙⴰ-ⴷⴷ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵓ ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵊⵊⵔⵉⵃⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS106_31","020_106_31","PSA","106","31","31","ⴰⵢⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⴷⴷ ⴷ ⵜⴰⵙⴻⴳⴷⴰ, ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS106_32","020_106_32","PSA","106","32","32","ⵏⵉⵜⵏⵉ ⵙⵄⴰⵔⴻⵏ ⴰⴼⵓⴳⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ, ⴰⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵎⵓⵙⴰ ⵍⵖⴰⵔ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS106_33","020_106_33","PSA","106","33","33","ⵎⴰⵖⴰⵔ ⵙⵙⴰⵔⴻⵣⴳⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵖⴰⵔⴻⵙ ⴰⵍⴰⵎⵉ ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵡⴰⵔ ⵉⴹⴱⵉⵄⴻⵏ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS106_34","020_106_34","PSA","106","34","34","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⴻⵃⵃⴰⵏ ⵍⴻⴳⵏⵓⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS106_35","020_106_35","PSA","106","35","35","ⵎⴰⵛⴰ ⵚⵚⵓⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⵍⴻⵎⴷⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PS106_36","020_106_36","PSA","106","36","36","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴼⴻⵅ. ");
INSERT INTO rift_vpl VALUES ("PS106_37","020_106_37","PSA","106","37","37","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_38","020_106_38","PSA","106","38","38","ⵏⵉⵜⵏⵉ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ, ⵏⵏⵉ ⵉⵡⵢⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⴽⴻⵏⵄⴰⵏ, ⴰⵍⴰⵎⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⴼⵙⴻⴷ ⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_39","020_106_39","PSA","106","39","39","ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵅⴻⵎⵊⴻⵏ ⵣⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ, ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_40","020_106_40","PSA","106","40","40","ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵄⵉⴼⴼ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS106_41","020_106_41","PSA","106","41","41","ⵏⴻⵜⵜⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴵⴰⴹⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_42","020_106_42","PSA","106","42","42","ⵃⵚⴰⵔⴻⵏ ⵜⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⵡⴰⴹⵄⴻⵏ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_43","020_106_43","PSA","106","43","43","ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴼⴻⴽⴽⴰ ⵉ-ⵜⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⴻⵣⴳⴻⵏ ⵅⴰⵙ ⵙ ⵜⵖⴻⵏⵏⴰⵏⵜ ⵏⵙⴻⵏ, ⵜⵜⵡⴰⵙⵙⵎⴻⵥⵢⴻⵏ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_44","020_106_44","PSA","106","44","44","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵅⵣⴰⵔ ⵄⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵓⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵓⵎⵉ ⵉⵙⵍⴰ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_45","020_106_45","PSA","106","45","45","ⵢⵉⴷⴰⵔ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⵓ ⵉⵏⴷⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_46","020_106_46","PSA","106","46","46","ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS106_47","020_106_47","PSA","106","47","47","ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ, ⵏⴷⴻⵀ ⴰⵏⴻⵖ ⵏⵎⵓⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵇⴰⴷⴰ ⵉⵙⴻⵎ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵛⴻⴽ ⵏⵚⴻⴱⴱⴻⵃ ⵙ ⵢⴻⵣⵍⴰⵏ ⵏ ⵓⵙⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS106_48","020_106_48","PSA","106","48","48","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ!” ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎⵉⵏ! ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ!’ ");
INSERT INTO rift_vpl VALUES ("PS107_1","020_107_1","PSA","107","1","1","ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS107_2","020_107_2","PSA","107","2","2","ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵎⵎⵓ, ⵉⵏⵏⵉ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("PS107_3","020_107_3","PSA","107","3","3","ⵉⵏⵏⵉ ⵉⵙⵙⵎⵓⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ, ⵣⵉ ⵛⵛⴰⵔⵇ, ⵣⵉ ⵍⵖⴰⵔⴱ, ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵓ ⵣⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS107_4","020_107_4","PSA","107","4","4","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵉⴽⴽⴰ ⵅ ⵜⵏⴻⵣⵔⵓⴼⵜ, ⵡⴰⵔ ⵓⴼⵉⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_5","020_107_5","PSA","107","5","5","ⴷⴰⵢⵙⴻⵏ ⵍⴰⵥ ⴷ ⵓⴼⴰⴷⵉ, ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵉⴼⵛⴻⵍ ⴷⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_6","020_107_6","PSA","107","6","6","ⵅⴻⵏⵏⵉ ⵙⵖⵓⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_7","020_107_7","PSA","107","7","7","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_8","020_107_8","PSA","107","8","8","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS107_9","020_107_9","PSA","107","9","9","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵊⵊⵉⵡⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⴼⴼⵓⴷⴻⵏ, ⵍⴻⵄⵎⴰⵔ ⵉⴵⵓⵥⴻⵏ ⵉⵛⵛⵓⵔ ⵉ-ⵜ ⵙ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS107_10","020_107_10","PSA","107","10","10","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵙ ⵉⵛⴻⴷⴷⵉⵢⴻⵏ ⵏ ⴷⴷⴻⴵ ⴷ ⵡⵓⵣⵣⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("PS107_11","020_107_11","PSA","107","11","11","ⵎⴰⵖⴰⵔ ⵖⴻⵡⵡⵖⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵛⵛⵡⴰⵔ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS107_12","020_107_12","PSA","107","12","12","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵇⵏⴻⵄ ⵓⵍ ⵏⵙⴻⵏ ⵙ ⵜⴰⵎⴰⵔⴰ, ⵏⵏⴷⴻⵔⴼⴻⵏ, ⵡⴰⵔ ⵓⴼⵉⵏ ⵡⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS107_13","020_107_13","PSA","107","13","13","ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS107_14","020_107_14","PSA","107","14","14","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⴰⴵⴻⵙⵜ ⵓ ⵣⵉ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵢⴰⵔⵥⴰ ⵉⵛⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_15","020_107_15","PSA","107","15","15","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS107_16","020_107_16","PSA","107","16","16","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵥⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵏⵏⵃⴰⵙ, ⵉⵛⴰⵔⵔⴻⴳ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏ ⵡⵓⵣⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS107_17","020_107_17","PSA","107","17","17","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴻⵣⵣⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵅⴻⵟⵟⵓ ⵏⵙⴻⵏ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_18","020_107_18","PSA","107","18","18","ⵉⵄⵉⴼⴼ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵛⵛⴰ, ⵉⵡⴹⴻⵏ ⴰⵍ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS107_19","020_107_19","PSA","107","19","19","ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_20","020_107_20","PSA","107","20","20","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ ⵓ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵉⵃⵓⴼⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_21","020_107_21","PSA","107","21","21","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS107_22","020_107_22","PSA","107","22","22","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵇⴰⴷⵉ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS107_23","020_107_23","PSA","107","23","23","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵙ ⵉⵖⴰⵔⵔⵓⴱⴰ, ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵅ ⵡⴰⵎⴰⵏ ⵉⵡⴻⵙⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_24","020_107_24","PSA","107","24","24","ⵥⵔⵉⵏ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS107_25","020_107_25","PSA","107","25","25","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS107_26","020_107_26","PSA","107","26","26","ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵀⵡⴰⵏ ⵖⴰⵔ ⵜⵉⵙⵉ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ. ⵉⴼⵙⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS107_27","020_107_27","PSA","107","27","27","ⵎⴻⵢⵢⵍⴻⵏ, ⵎⴻⵢⵢⵍⴻⵎ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵓⵎⴻⵙⵛⴰⵔ, ⵉⵡⴻⴷⴷⴰⵔ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_28","020_107_28","PSA","107","28","28","ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_29","020_107_29","PSA","107","29","29","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵙⴻⵎⵎⵉⴹ ⴰⴷ ⵢⴰⵔⵙⴰ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵍⴻⵎⵡⴰⵊ ⵙⵙⴻⵖⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_30","020_107_30","PSA","107","30","30","ⵏⵉⵜⵏⵉ ⴼⴰⵔⵃⴻⵏ ⵓⵎⵉ ⴰⵔⵙⵉⵏ ⵍⴻⵎⵡⴰⵊ ⵓ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵍⵎⵓⵢⵢⵉ ⵉ ⵖⴰⵔⴻⵙ ⵜⵓⵖⴰ ⵜⵜⵎⴻⵥⵔⵉⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_31","020_107_31","PSA","107","31","31","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵇⴰⴷⴰⵏ ⵙⵉⴷⵉ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("PS107_32","020_107_32","PSA","107","32","32","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜ ⵙⵙⵄⵓⴵⴻⵏ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⴰⴷ ⵜ ⵛⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵍⵃⴻⵍⵇⴻⵜ ⵏ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_33","020_107_33","PSA","107","33","33","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵉⵖⴻⵣⵔⴰⵏ ⴷ ⵍⴻⵅⵍⴰ, ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏⵜ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉⴼⴼⵓⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS107_34","020_107_34","PSA","107","34","34","ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵢⴰⵔⵔⴰ ⵉ-ⵜⵜ ⴷ ⵜⴰⵎⴻⴵⴰⵃⵜ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_35","020_107_35","PSA","107","35","35","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵍⴻⵅⵍⴰ ⴷ ⴰⵢⴻⵍⵎⴰⵎ ⵏ ⵡⴰⵎⴰⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PS107_36","020_107_36","PSA","107","36","36","ⴷⵉⵏⵏⵉ ⵉ ⵉⵙⵙⴻⵣⴷⴻⵖ ⵉⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ ⵓⵛⴰ ⴷⵉⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_37","020_107_37","PSA","107","37","37","ⵏⵉⵜⵏⵉ ⵣⴰⵔⵔⵄⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ, ⵜⵜⴻⵥⵥⵓⵏ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ, ⵜⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵉⴳⵓⵎⵎⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_38","020_107_38","PSA","107","38","38","ⵏⴻⵜⵜⴰ ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜⴻⵏ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⴰⴳⵍⴰ ⵏ ⵍⵎⴰⵍ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵥⵉ. ");
INSERT INTO rift_vpl VALUES ("PS107_39","020_107_39","PSA","107","39","39","ⵅⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴷⴰⴽⴽⵡⴰⵍⴻⵏ ⴷⵉ ⴷⵔⵓⵙ ⵄⴰⵡⴻⴷ, ⵀⴻⴽⴽⵡⴰⵏ ⵖⴰⵔ ⵍⴰⴵⴰⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⵍⴻⵖⴱⴻⵏ ⴷ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_40","020_107_40","PSA","107","40","40","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴽⴻⴱⴱⴰ ⴰⵙⴻⵃⵇⴰⵔ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⵜⵜᵉⵜⵍⵉⵄⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵎⴰⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵉⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_41","020_107_41","PSA","107","41","41","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵣⵉ ⵍⴻⵖⴱⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⴰⵎ ⵜⵃⵉⵎⴰⵔⵉⵏ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("PS107_42","020_107_42","PSA","107","42","42","ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵜⵜⵡⴰⵍⴰⵏ ⵓⵛⴰ ⴼⴰⵔⵔⵃⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵜⵜⴻⵇⵇⵏⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS107_43","020_107_43","PSA","107","43","43","ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵃⴹⴰ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵏⴻⵏ ⵏⵉⵛⴰⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS108_1","020_108_1","PSA","108","1","1","ⵉⵣⵍⵉ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS108_2","020_108_2","PSA","108","2","2","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵓⵍ ⵉⵏⵓ ⵉⵄⴻⵡⵡⴻⵍ, ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ, ⵡⴰⵀ ⵓⵍⴰ ⴷ ⴰⵄⵓⴵⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS108_3","020_108_3","PSA","108","3","3","ⴼⴰⵇ, ⵍⵀⴰⵔⴱⴰ ⴷ ⵍⴳⴰⵎⴱⵔⵉ! ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⴼⴰⵇⴻⵖ ⵜⴰⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS108_4","020_108_4","PSA","108","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⴰⴽ ⵣⴻⵀⵀⴷⴻⵖ ⵊⴰⵔ ⵛⵛⵓⵄⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS108_5","020_108_5","PSA","108","5","5","ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵜⵉⵡⴰ ⵉ ⵉⵊⴻⵏⵡⴰⵏ, ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴰⵍ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS108_6","020_108_6","PSA","108","6","6","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵔⵔ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵛ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("PS108_7","020_108_7","PSA","108","7","7","ⵃⵉⵎⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵏⴻⵊⵎⴻⵏ, ⴰⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵓ ⴰⵔⵔ-ⴷⴷ ⵅⴰⵏⴻⵖ ⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS108_8","020_108_8","PSA","108","8","8","ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵖⴰ ⵏⴻⴳⵣⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ⵏⴻⵛⵛ ⴰⴷ ⴱⴹⵉⵖ ⵛⴰⴽⵉⵎ, ⴰⴷ ⵄⴻⴱⴱⴰⵔⴻⵖ ⵜⴰⵢⵙⴰⵔⵜ ⵏ ⵙⵓⴽⴽⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PS108_9","020_108_9","PSA","108","9","9","ⵊⵉⵍⵄⴰⴷ ⵉⵏⵓ, ⵎⴰⵏⴰⵙⵙⴰ ⵉⵏⵓ, ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⴰⵙⴻⵍⵇⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵢⴰⵀⵓⴷⴰ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS108_10","020_108_10","PSA","108","10","10","ⵎⴰⵛⴰ ⵎⵓ’ⴰⴱ ⴷ ⵙⵙⴰⵔⵉⵊ ⵉⵏⵓ ⵏ ⵓⵙⵉⵔⴷ, ⵅ ⵉⴷⵓⵎ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵉⵏⵓ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴼⵉⵍⵉⵛⵉⵜ ⴰⴷ ⴷⵓⵇⵇⵣⴻⵖ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS108_11","020_108_11","PSA","108","11","11","ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ? ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴳⴻⵡⵡⴷⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵎ? ");
INSERT INTO rift_vpl VALUES ("PS108_12","020_108_12","PSA","108","12","12","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵏⴹⴰⵔⴻⴷ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵖ ⵎⴰ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴼⴼⵉⵖⴻⴷ ⵄⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⴰ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("PS108_13","020_108_13","PSA","108","13","13","ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⴼⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵎⴰⵖⴰⵔ ⴰⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴰ ⵉⴱⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS108_14","020_108_14","PSA","108","14","14","ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵏⴻⴳⴳ ⵙ ⵡⴻⵎⵃⴰⴹ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⴼⴻⵙ ⵅ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS109_1","020_109_1","PSA","109","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵉⵏⵓ, ⵡⴰⵔ ⵙⵖⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS109_2","020_109_2","PSA","109","2","2","ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⴰⵇⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵛⵛⵓⵔ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵉⵏⵏⵓⵔⵣⴻⵎ ⵅⴰⴼⵉ. ⵏⵉⵜⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽⵉⴷⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS109_3","020_109_3","PSA","109","3","3","ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴻⵛⵔⴰⵀ, ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽⵉⴷⵉ ⵅ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PS109_4","020_109_4","PSA","109","4","4","ⵉ ⵜⵡⴰⵔⵔⵉⵜ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ, ⵛⵛⴻⵜⵛⴰⵏ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵢⵉ ⵓ ⵏⴻⵛⵛ ⴽⴻⵙⵙⵉⵖ ⵙ ⵍⵎⴻⵄⵔⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("PS109_5","020_109_5","PSA","109","5","5","ⵏⵉⵜⵏⵉ ⵅⴻⴵⵚⴻⵏ ⴰⵢⵉ ⵍⵅⴰⵔ ⵙ ⵍⵖⴰⵔ, ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵙ ⵡⴻⵛⵔⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS109_6","020_109_6","PSA","109","6","6","ⴻⴳⴳ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⴻⵊⵊ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ ⴰⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_7","020_109_7","PSA","109","7","7","ⵎⴰⵍⴰ ⵅⴰⵙ ⵛⴰⵔⵔⵄⴻⵏ, ⴰⴷ ⵉⴼⴼⴻⵖ ⴰⵎ ⵓⵇⵟⴰⵟⵄⵉ ⵓⵛⴰ ⴻⵊⵊ ⵜⴰⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("PS109_8","020_109_8","PSA","109","8","8","ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵓⴷⵔⵓⵙⴻⵏ, ⴻⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⵍⴼⵓⵙⵉⵏⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_9","020_109_9","PSA","109","9","9","ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵢⵓⵊⵉⵍⴻⵏ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("PS109_10","020_109_10","PSA","109","10","10","ⴰⴷ ⵜⴻⵍⵍⵄⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⴰⴷ ⵜⵜⴰⵔⴻⵏ, ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵎⴰⵛⵛⴰ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵏ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS109_11","020_109_11","PSA","109","11","11","ⴰⴷ ⵉⵜⵜⴰⵔ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴰⵔⴱⴻⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_12","020_109_12","PSA","109","12","12","ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴻⵊⵊ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵃⵉⵏⵏ ⵅ ⵉⵢⵓⵊⵉⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_13","020_109_13","PSA","109","13","13","ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵎⵃⴰ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⴷⵉ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS109_14","020_109_14","PSA","109","14","14","ⴰⴷ ⵢⵉⴷⴰⵔ ⵙⵉⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵎⴻⵃⵃⵉ ⴷⴷⴻⵏⴱ ⵏ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_15","020_109_15","PSA","109","15","15","ⵉⵍⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵍⴻⴱⴷⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴽⴽⴻⵙ ⵍⵉⴷⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS109_16","020_109_16","PSA","109","16","16","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵄⵇⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⴳⴳ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⴰⵔⵔⴻⵜ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ, ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵔⵥ ⵡⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS109_17","020_109_17","PSA","109","17","17","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵏⵏⴻⵄⵍⴻⵜ, ⵅⴻⵏⵏⵉ ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵅⴰⵙ ⵜⴻⵡⴹⴰ, ⵓ ⵓⵎⵉ ⵡⴰⵔ ⵉⴼⴰⵔⵃ ⵙ ⵍⴱⴰⵔⴰⴽⴰ, ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵅⴰⵙ ⵜⵉⴳⴳⵯⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("PS109_18","020_109_18","PSA","109","18","18","ⵓⵎⵉ ⵢⴰⵔⴹ ⵏⵏⴻⵄⵍⴻⵜ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⴰⴷⴻⴼ ⵅⴻⵏⵏⵉ ⴰⵎ ⵡⴰⵎⴰⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ, ⴰⵎ ⵣⵣⴻⵛⵜ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_19","020_109_19","PSA","109","19","19","ⴻⵊⵊ ⴰⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⵉ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵉ ⴷⵉ ⵉⵜⵜⵍⴻⵃⵃⴻⴼ, ⴰⵎ ⵡⴻⴱⵢⴰⵙ ⵉ ⵉⴱⴻⴽⴽⴻⵙ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS109_20","020_109_20","PSA","109","20","20","ⵜⴰ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵍⵖⴰⵔ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS109_21","020_109_21","PSA","109","21","21","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⴳⴳ ⴷⴰⵢⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⴼⴻⴽⴽ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS109_22","020_109_22","PSA","109","22","22","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵓ ⵣⴻⵍⴹⴻⵖ, ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴻⴱ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS109_23","020_109_23","PSA","109","23","23","ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵉⵍⵉ ⵉⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵇⴻⵟⵟⵉⵖ, ⵣⵣⵔⵓⵣⴰⵏ ⴰⵢⵉ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵎⵓⵔⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS109_24","020_109_24","PSA","109","24","24","ⵉⴼⴰⴷⴷⴻⵏ ⵉⵏⵓ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵙ ⵓⵥⵓⵎⵎⵉ, ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⴷ ⵜⴰⵎⵓⵙⵔⵉⵡⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ-ⵜⵜ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS109_25","020_109_25","PSA","109","25","25","ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴰⵙⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵙⴻⵃⵇⴰⵔ. ⵎⴰⵍⴰ ⵥⵔⵉⵏ ⴰⵢⵉ, ⵙⵙⴻⵏⵀⴻⵣⵣⴰⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS109_26","020_109_26","PSA","109","26","26","ⴻⵡⵛ ⴰⵢⵉ ⴰⴼⵓⵙ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵄⵍⴰⵃⵚⴰⴱ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS109_27","020_109_27","PSA","109","27","27","ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵛⴻⴽ ⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS109_28","020_109_28","PSA","109","28","28","ⵏⵉⵜⵏⵉ ⴷ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵄⵄⵍⴻⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴱⴰⵔⴽⴻⴷ, ⵎⴰⵍⴰ ⵜⵜⵖⴻⵡⵡⵖⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ ⵎⴰⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("PS109_29","020_109_29","PSA","109","29","29","ⴻⵊⵊ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ ⴰⴷ ⵢⴰⵔⴹⴻⵏ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⴰⴷ ⵍⴻⵃⵃⴼⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴹⵃⵉ ⴰⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS109_30","020_109_30","PSA","109","30","30","ⵣⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⴰⴷ ⵇⴰⴷⵉⵖ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⴰⴷ ⵜ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵊⴰⵔ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS109_31","020_109_31","PSA","109","31","31","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⴰⴽ-ⴷ ⵓⵎⴻⵣⵍⵓⴹ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS110_1","020_110_1","PSA","110","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⵙⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ: ⵇⵉⵎ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵉⵏⵓ, ⴰⵍ ⴷⴷ-ⵙⵙⴰⵔⵙⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS110_2","020_110_2","PSA","110","2","2","ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⴰⵣⴻⴵⴰⴹ ⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵛ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⵛⴻⴽ ⴰⴷ ⵜⵚⴻⵍⵍⵟⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS110_3","020_110_3","PSA","110","3","3","ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵄⵄⴰⴼ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵛ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⵉ ⵜⵉⵙⵙⵉⵇⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⵍⴻⵎⵍⴰⵡⵍⴻⵜ ⵏ ⵜⵓⴼⴼⵓⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵉ ⵛⴻⴽ ⵏⵏⴷⴰ ⵏ ⵢⵉⵏⵏⵉ ⵄⴰⴷ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS110_4","020_110_4","PSA","110","4","4","ⵙⵉⴷⵉ ⵉⵊⵊⵓⴵ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵅⴰⵙ ⵉⵏⴷⴻⵎ: “ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵚⵚⵉⴼⴻⵜ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ!”, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵊⴻⴵⵉⴷ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ’. ");
INSERT INTO rift_vpl VALUES ("PS110_5","020_110_5","PSA","110","5","5","ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵍⴱⴻⵣ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS110_6","020_110_6","PSA","110","6","6","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴰⴽⴻⵎ ⵅ ⵍⴻⴳⵏⵓⵙ, ⴰⵇⴰ ⴷⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵅⴻⵛⴱⴰⵜ, ⴰⴷ ⵉⵍⴱⴻⵣ ⴰⵣⴻⴵⵉⴼ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS110_7","020_110_7","PSA","110","7","7","ⴰⴽ-ⴷ ⵡⴻⴱⵔⵉⴷ ⴰⴷ ⵉⵙⵓ ⵣⵉ ⵜⴻⵖⵣⴰⵔⵜ, ⵅ ⵓⵢⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS111_1","020_111_1","PSA","111","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ⴰⵍⵉⴼ. ⴰⴷ ⵇⴰⴷⴻⵖ ⵙⵉⴷⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵉⵏⵓ, ⴱⵉⵜ. ⴷⵉ ⵍⴰⵎⴰⵏ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ, ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS111_2","020_111_2","PSA","111","2","2","ⴳⵉⵎⴻⵍ. ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏ ⵙⵉⴷⵉ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⴷⴰⵍⵉⵜ. ⴰⵇⴰ ⵜⵡⴰⵔⴻⵣⵣⵓⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴼⴰⵔⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS111_3","020_111_3","PSA","111","3","3","ⵀⵉ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵙ ⵍⵄⴰⴹⴰⵎⴰ ⴷ ⵍⵄⴻⵣⵣ, ⵡⴰⵡ. ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS111_4","020_111_4","PSA","111","4","4","ⵣⴰⵢⵉⵏ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ. ⵅⵉⵜ. ⵙⵉⴷⵉ ⴷ ⴰⵃⵏⵉⵏ ⴷ ⴰⵔⵃⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("PS111_5","020_111_5","PSA","111","5","5","ⵜⵉⵜ. ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵎⴰⵛⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵢⵓⴷ. ⵉⵜⵜⵉⴷⴰⵔ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS111_6","020_111_6","PSA","111","6","6","ⴽⴰⴼ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵛⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵍⴰⵎⵉⴷ. ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS111_7","020_111_7","PSA","111","7","7","ⵎⵉⵎ. ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵍⵃⴻⵇⵇ, ⵏⵓⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷⴰⵢⵙⴻⵏⵜ ⵍⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS111_8","020_111_8","PSA","111","8","8","ⵙⴰⵎⵉⵅ. ⴰⵇⴰ ⴰⵜⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵄⴰⵢⵉⵏ. ⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⵓ ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS111_9","020_111_9","PSA","111","9","9","ⴱⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⵜⴰⵎⴰⵏ ⵏ ⵡⴻⵚⵍⴰⵃ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵜⵙⴰⴷⵉ. ⵉⴳⴳⴰ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ⵇⵓⴼ. ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷ ⵉⵙⵙⴻⴳⴳⵯⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS111_10","020_111_10","PSA","111","10","10","ⵔⵉⵅ. ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵜⵉⵖⵉⵜ. ⵛⵉⵏ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵎⴻⵏⵏⵉ, ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⵇⴻⵍ ⴷ ⵍⴻⵎⵍⵉⵃ. ⵜⴰⴼ. ⵛⵛⴰⵏ ⵏⵏⴻⵙ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS112_1","020_112_1","PSA","112","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ⴰⵍⵉⴼ. ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⴱⵉⵜ. ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS112_2","020_112_2","PSA","112","2","2","ⴳⵉⵎⴻⵍ. ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵊⴻⵀⵀⴷⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⴰⵍⵉⵜ. ⵊⵊⵉⵍ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS112_3","020_112_3","PSA","112","3","3","ⵀⵉ. ⵍⵅⵉⵔ ⴷ ⵡⴰⴳⵍⴰ ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵡ. ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS112_4","020_112_4","PSA","112","4","4","ⵣⴰⵢⵉⵏ. ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⵖⵍⵉ ⵜⴼⴰⵡⵜ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ⵅⵉⵜ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵃⵏⵉⵏ ⴷ ⴰⵔⵃⵉⵎ ⴷ ⵓⵎⵙⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PS112_5","020_112_5","PSA","112","5","5","ⵜⵉⵜ. ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵃⵉⵏⵏⴰ ⵓ ⵢⴰⵔⴻⵟⵟⴻⵍ, ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ, ⵢⵓⴷ. ⴰⵇⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS112_6","020_112_6","PSA","112","6","6","ⴽⴰⴼ. ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ ⵉ ⵍⴻⴱⴷⴰ. ⵍⴰⵎⵉⴷ. ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴻⴳ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS112_7","020_112_7","PSA","112","7","7","ⵎⵉⵎ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵏⵏⴰⴱ ⵉ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵏⵓⵏ. ⵓⵍ ⵏⵏⴻⵙ ⵉⵎⵜⴻⵏ, ⵉⵜⵜⵛⴰⵍ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS112_8","020_112_8","PSA","112","8","8","ⵙⴰⵎⵉⵅ. ⵓⵍ ⵏⵏⴻⵙ ⵉⵎⵜⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ, ⵄⴰⵢⵉⵏ. ⴰⵍ ⵖⴰ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS112_9","020_112_9","PSA","112","9","9","ⴱⵉ. ⵉⵣⵓⵣⵣⴰⵔ, ⵉⵜⵜⵉⵛ ⵉ ⵉⵎⴻⵣⵍⴰⴹ. ⵜⵙⴰⴷⵉ. ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ⵇⵓⴼ. ⵉⵛⵛ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ ⵙ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS112_10","020_112_10","PSA","112","10","10","ⵔⵉⵅ. ⴰⴷ ⵜ ⵉⵥⴰⵔ ⵓⵄⴻⴼⴼⴰⵏ, ⴰⴷ ⵉⴼⴼⵓⴳⴻⵎ. ⵛⵉⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵖⴻⵣⵣ ⵙ ⵜⴻⵖⵎⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⵙⵉ. ⵜⴰⴼ. ⵎⴻⵥⵔⵉ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⴱⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS113_1","020_113_1","PSA","113","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ, ⵙⵄⵓⴵⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵙⵄⵓⴵⴻⵎ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS113_2","020_113_2","PSA","113","2","2","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS113_3","020_113_3","PSA","113","3","3","ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⵍ ⵎⴰⵏⵉⵙ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS113_4","020_113_4","PSA","113","4","4","ⵙⵉⴷⵉ ⵢⵓⵄⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵜⵉⵡⴰ ⵉ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS113_5","020_113_5","PSA","113","5","5","ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴰⵎ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵓⵄⵍⴰ ⵇⴰⵄ, ");
INSERT INTO rift_vpl VALUES ("PS113_6","020_113_6","PSA","113","6","6","ⵡⴻⵏⵏⵉ ⵢⵓⴹⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⴰⵔ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("PS113_7","020_113_7","PSA","113","7","7","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴰⵏ ⴰⵎⵓⵇⵍⵉⵍ ⵣⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵣⴻⴳ ⵡⴻⴼⵔⴰⴹ ");
INSERT INTO rift_vpl VALUES ("PS113_8","020_113_8","PSA","113","8","8","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵙⵖⵉⵎ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS113_9","020_113_9","PSA","113","9","9","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵣⴷⴰⵖⴻⵏ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵎ ⵉⵛⵜ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵜⴼⴰⵔⵃ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS114_1","020_114_1","PSA","114","1","1","ⴰⵍⴰⵎⵉ ⵉⴼⴼⴻⵖ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵎⵉⴷⴷⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("PS114_2","020_114_2","PSA","114","2","2","ⵉⴷⵡⴻⵍ ⵢⴰⵀⵓⴷⴰ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS114_3","020_114_3","PSA","114","3","3","ⵍⴻⴱⵃⴰⵔ ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ, ⵍ’ⵓⵔⴷⵓⵏ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS114_4","020_114_4","PSA","114","4","4","ⵉⴷⵓⵔⴰⵔ ⵏⴻⴳⵣⴻⵏ ⴰⵎ ⵢⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⵎ ⵢⵉⵣⵎⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS114_5","020_114_5","PSA","114","5","5","ⵎⵉⵏ ⵛⴻⴽ ⵢⵓⵖⵉⵏ, ⴰ ⵍⴻⴱⵃⴰⵔ, ⴰⵍⴰⵎⵉ ⵜⵔⴻⴽⴽⵡⴰⵍⴻⴷ, ⴰ ⵛⴻⴽ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵍⴰⵎⵉ ⵜⴻⵏⵇⴻⵍⴱⴻⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("PS114_6","020_114_6","PSA","114","6","6","ⴰ ⵉⴷⵓⵔⴰⵔ, ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵖⵉⵏ ⴰⵍⴰⵎⵉ ⵜⵏⴻⴳⴳⵣⴻⵎ ⴰⵎ ⵢⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⵎ ⵢⵉⵣⵎⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS114_7","020_114_7","PSA","114","7","7","ⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵔⵊⵉⵊⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("PS114_8","020_114_8","PSA","114","8","8","ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵜⴰⵚⴹⴰⵔⵜ ⴷ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ, ⵙⵙⴻⴵⴰⵃ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_1","020_115_1","PSA","115","1","1","ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵏⴻⵛⵛⵉⵏ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵎⴰⵖⴰⵔ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS115_2","020_115_2","PSA","115","2","2","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵇⵇⴰⵔⴻⵏ ⵍⴻⴳⵏⵓⵙ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⵅⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("PS115_3","020_115_3","PSA","115","3","3","ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵢⴰⵔⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_4","020_115_4","PSA","115","4","4","ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_5","020_115_5","PSA","115","5","5","ⵖⴰⵔⵙⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏⵜ, ⵖⴰⵔⵙⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("PS115_6","020_115_6","PSA","115","6","6","ⵖⴰⵔⵙⴻⵏⵜ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏⵜ, ⵖⴰⵔⵙⴻⵏⵜ ⵡⴰⵏⵣⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵛⴻⵎⵎⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS115_7","020_115_7","PSA","115","7","7","ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴱⴱⴰⵔⴻⵏ, ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵍⵃⴻⵙⵙ ⵣⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_8","020_115_8","PSA","115","8","8","ⴻⵊⵊ ⵉⵏⵏⵉ ⵜⴻⵏⵜ ⵉⴳⴳⵉⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⴰⵔⴻⵡⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏⵜ ⵉⵜⵜⴻⵛⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_9","020_115_9","PSA","115","9","9","ⵉⵙⵔⴰⵉⵍ, ⵜⵛⴻⵍ ⵅ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⴷ ⵜⵡⵉⵣⴰ ⵏⵙⴻⵏ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("PS115_10","020_115_10","PSA","115","10","10","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵔⵓⵏ, ⵜⵛⴻⵍ ⵅ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⴷ ⵜⵡⵉⵣⴰ ⵏⵙⴻⵏ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("PS115_11","020_115_11","PSA","115","11","11","ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⵜⴻⵛⵍⴻⵎ ⵅ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⴷ ⵜⵡⵉⵣⴰ ⵏⵙⴻⵏ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵉ ⵓⵙⴻⵍⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("PS115_12","020_115_12","PSA","115","12","12","ⵙⵉⴷⵉ ⵉⵄⵇⴻⵍ ⵅⴰⵏⴻⵖ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ. ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_13","020_115_13","PSA","115","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵣⵉ ⵙⵉⴷⵉ, ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS115_14","020_115_14","PSA","115","14","14","ⵙⵉⴷⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵎⴰⵔⵏⵉ ⵜⴰⵔⵡⴰ, ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS115_15","020_115_15","PSA","115","15","15","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵎ ⵣⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS115_16","020_115_16","PSA","115","16","16","ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴰⵀ, ⵉⵊⴻⵏⵡⴰⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS115_17","020_115_17","PSA","115","17","17","ⵉⵎⴻⵜⵜⴰⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵓⵙⵓⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS115_18","020_115_18","PSA","115","18","18","ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PS116_1","020_116_1","PSA","116","1","1","ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵉ ⵜⵓⵜⵔⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS116_2","020_116_2","PSA","116","2","2","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵢⵉ ⴰⵎⴻⵥⵥⵓⵖ ⵏⵏⴻⵙ. ⴰⴷ ⴰⵙ ⵍⴰⵖⵉⵖ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS116_3","020_116_3","PSA","116","3","3","ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⴼⵉ ⵜⵉⴳⴳⵯⵓⴷⴰ ⵏ ⵍⴰⵅⴰⵔⵜ. ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⴰⵇⴰ ⴰⵢⵉ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⵓ ⵛⴻⴹⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS116_4","020_116_4","PSA","116","4","4","ⵍⴰⵖⵉⵖ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵏⵏⵉⵖ: “ⴰ ⵙⵉⴷⵉ, ⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("PS116_5","020_116_5","PSA","116","5","5","ⵙⵉⴷⵉ ⴷ ⴰⵃⵏⵉⵏ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷⴰⵢⴻⵙ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PS116_6","020_116_6","PSA","116","6","6","ⵙⵉⴷⵉ ⵉⵃⴻⵟⵟⴰ ⵓⵍⴰⵡⴻⵏ ⵏ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴰⵎ ⵓⵏⴻⵄⴹⴰⴱ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS116_7","020_116_7","PSA","116","7","7","ⵀⵏⴰ ⵄⴰⵡⴻⴷ, ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵛ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS116_8","020_116_8","PSA","116","8","8","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵃⴹⵉⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⵎⴻⵡⵜ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵣⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⴰⴹⴰⵔ ⵉⵏⵓ ⵣⴻⴳ ⵓⵏⴻⵇⵔⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PS116_9","020_116_9","PSA","116","9","9","ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS116_10","020_116_10","PSA","116","10","10","ⵏⴻⵛⵛ ⵓⵎⵏⴻⵖ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("PS116_11","020_116_11","PSA","116","11","11","ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵉⵏⵓ ⵏⵏⵉⵖ: “ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS116_12","020_116_12","PSA","116","12","12","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵅⴻⴵⵚⴻⵖ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ? ");
INSERT INTO rift_vpl VALUES ("PS116_13","020_116_13","PSA","116","13","13","ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵍⴽⴰⵙ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS116_14","020_116_14","PSA","116","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ ⵉ ⵙⵉⴷⵉ, ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS116_15","020_116_15","PSA","116","15","15","ⴰⵇⴰ ⵉⵖⵍⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵍⵎⴻⵡⵜ ⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS116_16","020_116_16","PSA","116","16","16","ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵏⵏⴻⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵛ. ⵛⴻⴽ ⵜⴻⵙⵙⴰⵔⵅⵓⴷ ⵅⴰⴼⵉ ⵉⵛⴻⴷⴷⵉⵢⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS116_17","020_116_17","PSA","116","17","17","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ, ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS116_18","020_116_18","PSA","116","18","18","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵖ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ ⵉ ⵙⵉⴷⵉ, ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS116_19","020_116_19","PSA","116","19","19","ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ! ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS117_1","020_117_1","PSA","117","1","1","ⵙⵄⵓⴵⴻⵎ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵚⴻⴱⵃⴻⵎ ⵜ, ⵎⴰⵔⵔⴰ ⵛⵛⵓⵄⵓⴱ! ");
INSERT INTO rift_vpl VALUES ("PS117_2","020_117_2","PSA","117","2","2","ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⵉⵡⴰ ⵏⵏⴻⵖ, ⵍⴰⵎⴰⵏ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PS118_1","020_118_1","PSA","118","1","1","ⵖⴰⵔ ⴱⴻⴷⴷⵓ ... ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS118_2","020_118_2","PSA","118","2","2","ⴻⵊⵊ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵢⵉⵏⵉ: “ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("PS118_3","020_118_3","PSA","118","3","3","ⴻⵊⵊ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵔⵓⵏ ⴰⴷ ⵜⵉⵏⵉ “ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("PS118_4","020_118_4","PSA","118","4","4","ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⵏⵉⵏ: “ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("PS118_5","020_118_5","PSA","118","5","5","ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ... ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵍⴰⵖⵉⵖ ⵖⴰⵔ ⵙⵉⴷⵉ. ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ, ⵉⵡⵛⴰ ⴰⵢⵉ ⵜⵜⴰⵙⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("PS118_6","020_118_6","PSA","118","6","6","ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ? ");
INSERT INTO rift_vpl VALUES ("PS118_7","020_118_7","PSA","118","7","7","ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ ⵊⴰⵔ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵅ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS118_8","020_118_8","PSA","118","8","8","ⵉⵃⵍⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⵅ ⵓⵜⴻⵛⵍⵉ ⵅ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS118_9","020_118_9","PSA","118","9","9","ⵉⵃⵍⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⵅ ⵓⵜⴻⵛⵍⵉ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS118_10","020_118_10","PSA","118","10","10","ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵏⴻⵛⵛ ⵖⴻⴹⵍⴻⵖ ⵜⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS118_11","020_118_11","PSA","118","11","11","ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵡⴰⵀ, ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵢⵉ. ⵏⴻⵛⵛ ⵖⴻⴹⵍⴻⵖ ⵜⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS118_12","020_118_12","PSA","118","12","12","ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⴰⵢⵉ ⴰⵎ ⵜⵣⵉⵣⵡⴰ, ⴰⵇⴰ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵅⴻⵙⵢⴻⵏ. ⵏⴻⵛⵛ ⵖⴻⴹⵍⴻⵖ ⵜⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS118_13","020_118_13","PSA","118","13","13","ⵛⴻⴽ ⵜⵄⴰⵔⵏⴻⴷ ⴰⵢⵉ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ ⴰⵍⴰⵎⵉ ⵄⵍⴰⵃⴰⵍ ⵡⴹⵉⵖ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PS118_14","020_118_14","PSA","118","14","14","ⵙⵉⴷⵉ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴷ ⴰⵣⴻⵀⵀⴻⴷ ⵉⵏⵓ, ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴰⵢⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS118_15","020_118_15","PSA","118","15","15","ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴷ ⵓⵙⴻⵏⵊⴻⵎ. ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PS118_16","020_118_16","PSA","118","16","16","ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ, ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵙ ⵡⴻⵎⵃⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PS118_17","020_118_17","PSA","118","17","17","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵎⴻⵜⵜⵉⵖ ⵛⴰ, ⴰⴷ ⴷⴷⴰⵔⴻⵖ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS118_18","020_118_18","PSA","118","18","18","ⵙⵉⴷⵉ ⵉⵡⴻⴱⴱⴻⵅ ⴰⵢⵉ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵡⵛⵉ ⵉ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS118_19","020_118_19","PSA","118","19","19","ⵖⴰⵔ ⵡⴰⴷⴰⴼ ... ⴰⵔⵣⵎⴻⵎ ⴰⵢⵉ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⵙⴻⴳⴷⴰ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴰⴷⴼⴻⵖ, ⴰⴷ ⵇⴰⴷⵉⵖ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS118_20","020_118_20","PSA","118","20","20","ⵉⵏⵏⵉ ⵢⴰⵔⴻⵃⵃⴱⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵇⵇⴰⵔⴻⵏ ... ⵜⴰ ⴷ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⴷⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS118_21","020_118_21","PSA","118","21","21","ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵇⴰⴷⵉⵖ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵍⵉⴷ, ⵜⴷⴻⵡⵍⴻⴷ ⴰⵢⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS118_22","020_118_22","PSA","118","22","22","ⴰⵥⵔⵓ ⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ, ⵉⴷⵡⴻⵍ ⴷ ⵉⵅⴻⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS118_23","020_118_23","PSA","118","23","23","ⵡⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵄⵊⴻⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS118_24","020_118_24","PSA","118","24","24","ⵡⴰ ⴷ ⴰⵙⵙ ⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⵛⴻⵇ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("PS118_25","020_118_25","PSA","118","25","25","ⴰ ⵙⵉⴷⵉ, ⴰⵡⵉ-ⴷⴷ ⴰⵙⴻⵏⵊⴻⵎ, ⴰ ⵙⵉⴷⵉ, ⴰⵡⵉ-ⴷⴷ ⴰⴼⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("PS118_26","020_118_26","PSA","118","26","26","ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ! ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴱⴰⵔⴻⴽ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS118_27","020_118_27","PSA","118","27","27","ⴰⵔⴻⴱⴱⵉ ⴷ ⵙⵉⴷⵉ ⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⵉⵏ ⵜⴰⴼⴰⵡⵜ. ⵇⵏⴻⵎ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⵄⵉⴷ ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵖⴰⵔ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⵍⵎⴻⴷⴱⴻⵃ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PS118_28","020_118_28","PSA","118","28","28","ⵉⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵇⵇⴰⵔⴻⵏ ... ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵙ ⵓⵢⴰ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⴷ ⵛⴻⴽ ⵙⵙⵄⵓⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS118_29","020_118_29","PSA","118","29","29","ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ... ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_1","020_119_1","PSA","119","1","1","ⴰⵍⵉⴼ. ⵙⵙⴻⵄⴷ ⵏⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⴽⴻⵎⵎⵍⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⴱⵍⴰ ⵍⵄⵉⴱ, ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS119_2","020_119_2","PSA","119","2","2","ⵙⵙⴻⵄⴷ ⵏⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵅⴰⵙ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_3","020_119_3","PSA","119","3","3","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ, ⵎⴰⵛⴰ ⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_4","020_119_4","PSA","119","4","4","ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⵓⵎⴰⵔⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵃⴹⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_5","020_119_5","PSA","119","5","5","ⵎⵍⵉ ⵇⴰⵄ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⵉⵖ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS119_6","020_119_6","PSA","119","6","6","ⵅⴻⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵙⴻⴹⵃⵉⵖ ⵎⴰⵍⴰ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_7","020_119_7","PSA","119","7","7","ⵙ ⵡⵓⵍ ⵉⵇⵇⵓⵔ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵍⴻⵎⴷⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_8","020_119_8","PSA","119","8","8","ⴰⴷ ⵃⴹⵉⵖ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ! ⵡⴰⵔ ⴷⴰⵢⵉ ⵙⴻⵎⵎⴻⵃ ⵎⴰⵔⵔⴰ! ");
INSERT INTO rift_vpl VALUES ("PS119_9","020_119_9","PSA","119","9","9","ⴱⵉⵜ. ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵃⵓⴷⵔⵉ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ? ⵙ ⵡⴻⵎⵏⴰⵄ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_10","020_119_10","PSA","119","10","10","ⵏⴻⵛⵛ ⴰⵔⴻⵣⵣⵓⵖ ⵅⴰⴽ ⵙ ⵡⵓⵍ ⵉⵏⵓ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴼⴼⵖⴻⵖ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_11","020_119_11","PSA","119","11","11","ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ, ⵅⴻⵎⵎⵍⴻⵖ ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴽⵉⴷⴻⴽ ⵅⴻⵟⵟⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_12","020_119_12","PSA","119","12","12","ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_13","020_119_13","PSA","119","13","13","ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ ⴱⴰⵔⵔⵃⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_14","020_119_14","PSA","119","14","14","ⴰⵇⴰ ⴼⴰⵔⵃⴻⵖ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⴰⵎ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵖⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_15","020_119_15","PSA","119","15","15","ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_16","020_119_16","PSA","119","16","16","ⵏⴻⵛⵛ ⵜⵜⴰⵔⵔⴻⵖ ⵎⴻⵥⵍⵉ ⴷⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜ ⵜⵜᵉⵜⵜⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_17","020_119_17","PSA","119","17","17","ⴳⵉⵎⴻⵍ. ⴻⴳⴳ ⵜⵛⵓⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷⴰⵔⴻⵖ ⵓ ⴰⴷ ⵃⴹⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_18","020_119_18","PSA","119","18","18","ⴰⵔⵣⴻⵎ ⴰⵢⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_19","020_119_19","PSA","119","19","19","ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⴼⴼⴰⵔ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_20","020_119_20","PSA","119","20","20","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⵡⴰⴼⵏⴰ ⵙ ⵓⵡⴻⵃⵃⴻⵛ ⵖⴰⵔ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ, ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_21","020_119_21","PSA","119","21","21","ⵛⴻⴽ ⵜⵄⴰⵇⴱⴻⴷ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⵉⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_22","020_119_22","PSA","119","22","22","ⴽⵙⵉ ⵅⴰⴼⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷ ⵓⵙⴻⵃⵇⴰⵔ, ⵎⴰⵖⴰⵔ ⵃⴹⵉⵖ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_23","020_119_23","PSA","119","23","23","ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵇⵇⵉⵎⴻⵏ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵅⴰⴼⵉ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_24","020_119_24","PSA","119","24","24","ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⴷ ⵎⴻⵥⵔⵉ ⵉⵏⵓ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_25","020_119_25","PSA","119","25","25","ⴷⴰⵍⵉⵜ. ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵍⵚⴻⵇ ⵖⴰⵔ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_26","020_119_26","PSA","119","26","26","ⵏⴻⵛⵛ ⵏⴻⵄⵎⴻⵖ ⵉ ⵛⴻⴽ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵓ ⵛⴻⴽ ⵜⴻⵙⵜⴰⵊⴱⴻⴷ ⴰⵢⵉ. ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_27","020_119_27","PSA","119","27","27","ⴰⵔⵔ ⴰⵢⵉ ⴰⴷ ⴼⴻⵀⵎⴻⵖ ⴰⴱⵔⵉⴷ ⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_28","020_119_28","PSA","119","28","28","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⴼⵙⵉ ⵙ ⵡⴻⵛⴹⴰⵏ, ⵙⴻⴳⴳⴻⵎ ⴰⵢⵉ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_29","020_119_29","PSA","119","29","29","ⵙⵉⴳⴳⵯⴻⵊ ⴰⵢⵉ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_30","020_119_30","PSA","119","30","30","ⵏⴻⵛⵛ ⵉⵅⴹⴰⵔⴻⵖ ⴰⴱⵔⵉⴷ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵙⵙⴰⵔⵙⴻⵖ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("PS119_31","020_119_31","PSA","119","31","31","ⵏⴻⵛⵛ ⵛⴻⴱⴱⴰⵔⴻⵖ ⴷⵉ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵙⴻⴹⵃⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_32","020_119_32","PSA","119","32","32","ⵏⴻⵛⵛ ⴰⴷ ⴰⵣⵣⵍⴻⵖ ⴰⴱⵔⵉⴷ ⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⵜⴰⵙⵉⵄ ⵉ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_33","020_119_33","PSA","119","33","33","ⵀⵉ. ⴰ ⵙⵉⴷⵉ! ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⴰⴱⵔⵉⴷ ⵏ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⵙ ⵟⵟⴼⴻⵖ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS119_34","020_119_34","PSA","119","34","34","ⴻⵡⵛ ⴰⵢⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⴹⵉⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵟⵟⴼⴻⵖ ⵙ ⵡⵓⵍ ⵉⵏⵓ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_35","020_119_35","PSA","119","35","35","ⵏⴷⴻⵀ ⴰⵢⵉ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⴼⴰⵔⵔⵃⴻⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_36","020_119_36","PSA","119","36","36","ⴰⵔⵔ ⵓⵍ ⵉⵏⵓ ⵖⴰⵔ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵟⵟⵎⴻⵄ ⵏ ⴰⵔⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PS119_37","020_119_37","PSA","119","37","37","ⵙⵀⴻⵢⵢⴻⴹ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵅ ⵍⴱⴰⵟⴻⵍ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵙ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_38","020_119_38","PSA","119","38","38","ⴹⵎⴻⵏ ⵎⵉⵏ ⵜⴻⵏⵏⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_39","020_119_39","PSA","119","39","39","ⵙⵃⴻⵢⵢⴻⴷ ⵅⴰⴼⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵣⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ, ⵎⴰⵖⴰⵔ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵛⵏⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_40","020_119_40","PSA","119","40","40","ⵅⵣⴰⵔ, ⵜⵜⵡⴻⵃⵃⵛⴻⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⴰⵔⵔ ⴰⵢⵉ ⴷⴷⴰⵔⴻⵖ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_41","020_119_41","PSA","119","41","41","ⵡⴰⵡ. ⴻⵊⵊ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵏⵏⵉⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS119_42","020_119_42","PSA","119","42","42","ⵃⵉⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵔⵔⴻⵖ ⵅ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉⵙⵙⴱⴻⵀⴷⴰⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵜⴻⵛⵍⴻⵖ ⵅ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_43","020_119_43","PSA","119","43","43","ⵡⴰⵔ ⵜⵜⴻⴽⴽⴻⵙ ⴰⵡⴰⵍ ⵏ ⵜⵉⴷⴻⵜⵜ ⵇⴰⵄ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⵜⵔⴰⵊⵉⵖ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_44","020_119_44","PSA","119","44","44","ⵏⴻⵛⵛ ⴰⴷ ⵃⴹⵉⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS119_45","020_119_45","PSA","119","45","45","ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ ⴷⵉ ⵜⵜⴰⵙⵉⵄ, ⵎⴰⵖⴰⵔ ⴰⵔⵣⵓⵖ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_46","020_119_46","PSA","119","46","46","ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵡⴰⵔ ⵣⵣⴰⵜⵙⴻⵏ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_47","020_119_47","PSA","119","47","47","ⴰⴷ ⴰⵔⵔⴻⵖ ⵎⴻⵥⵔⵉ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⵜⵉⵏⵏⵉ ⵉ ⵜⵜⴻⵅⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_48","020_119_48","PSA","119","48","48","ⴰⴷ ⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵇⵉⴱⴰⵍ ⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⵜⵉⵏⵏⵉ ⵉ ⵜⵜⴻⵅⵙⴻⵖ, ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_49","020_119_49","PSA","119","49","49","ⵣⴰⵢⵉⵏ. ⵄⵇⴻⵍ ⵅ ⵡⴰⵡⴰⵍ ⵉ ⵜⴻⵏⵏⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵢⵍⴻⴷ ⴰⵙⵉⵜⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_50","020_119_50","PSA","119","50","50","ⴷ ⵡⴰ ⴷ ⴰⴼⴻⵡⵡⴻⵊ ⵉⵏⵓ ⴷⵉ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵛ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_51","020_119_51","PSA","119","51","51","ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⵙⵜⴻⵀⵣⴰⵏ ⵣⵣⴰⵢⵉ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⵢⵢⵉⴷⴻⵖ ⵛⴰ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_52","020_119_52","PSA","119","52","52","ⵏⴻⵛⵛ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵏ ⵍⴻⴱⴷⴰ, ⴰ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵜⵜⵡⴰⴼⴻⵡⵡⵊⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_53","020_119_53","PSA","119","53","53","ⵜⴰⴼⵇⴻⵃⵜ ⵜᵉⵟⵟⴻⴼ ⴰⵢⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⴻⵎⵎⵃⴻⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_54","020_119_54","PSA","119","54","54","ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵉⵣⵍⴰⵏ ⵉⵏⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴱⴰⵔⵔⴰⵏⴻⵛⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_55","020_119_55","PSA","119","55","55","ⴷⵉ ⴵⵉⵍⴻⵜ ⵜⵓⵖⴰ ⵜⵜⵅⴰⵔⵔⵚⴻⵖ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵓ ⵃⴹⵉⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_56","020_119_56","PSA","119","56","56","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵙⴰⵔ, ⵎⴰⵖⴰⵔ ⵃⴹⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_57","020_119_57","PSA","119","57","57","ⵅⵉⵜ. ⵙⵉⴷⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⴷ ⵃⴹⵉⵖ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_58","020_119_58","PSA","119","58","58","ⵃⴻⵛⵛⵎⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵉⵏⵓ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS119_59","020_119_59","PSA","119","59","59","ⵏⴻⵛⵛ ⵅⴰⵔⵔⵚⴻⵖ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵉⵚⵓⵔⴰⴼ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_60","020_119_60","PSA","119","60","60","ⵏⴻⵛⵛ ⵇⴻⴵⵇⴻⵖ, ⵡⴰⵔ ⵄⴻⵟⵟⴰⵍⴻⵖ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_61","020_119_61","PSA","119","61","61","ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵛⴰⵔⵔⴼⴻⵏ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_62","020_119_62","PSA","119","62","62","ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵜⵜⵏⴻⴽⴽⴰⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵅ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_63","020_119_63","PSA","119","63","63","ⵏⴻⵛⵛ ⴷ ⴰⵄⵛⵉⵔ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵏ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_64","020_119_64","PSA","119","64","64","ⵣⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴻⵛⵛⵓⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_65","020_119_65","PSA","119","65","65","ⵜⵉⵜ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵙ ⵜⵛⵓⵏⵉ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_66","020_119_66","PSA","119","66","66","ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⴻⵢⵢⵣⴻⵖ ⵓ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⵍⵉⵃ, ⵎⵉⵏⵣⵉ ⵜⵜⴻⵛⵍⴻⵖ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_67","020_119_67","PSA","119","67","67","ⵇⴱⴻⵍ ⵎⴰ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ, ⵡⴻⴷⴷⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵃⴻⵟⵟⵉⵖ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS119_68","020_119_68","PSA","119","68","68","ⵛⴻⴽ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_69","020_119_69","PSA","119","69","69","ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴰⵔⴻⵅⵅⵓⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵃⴻⵟⵟⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_70","020_119_70","PSA","119","70","70","ⵓⵍ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⴰⵛⴰⵏ ⴰⵎ ⵜⴰⴷⵓⵏⵜ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵜⵜⴰⴼⴻⵖ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS119_71","020_119_71","PSA","119","71","71","ⵜⵓⵖⴰ ⵉ ⵏⴻⵛⵛ ⵎⵍⵉⵃ ⵓⵎⵉ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵍⴻⵎⴷⴻⵖ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_72","020_119_72","PSA","119","72","72","ⵛⵛⴰⵔⵉⵄⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵖⴰⵔⵉ ⵉⵃⵍⴰ ⴰⵟⵟⴰⵙ ⵅ ⵡⴰⵍⴰⴼ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_73","020_119_73","PSA","119","73","73","ⵢⵓⴷ. ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⴳⴳⵉⵏ ⴰⵢⵉ, ⴽⴻⵡⵡⵏⴻⵏ ⴰⵢⵉ. ⴻⵡⵛ ⴰⵢⵉ ⵍⴻⵄⵇⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵍⴻⵎⴷⴻⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_74","020_119_74","PSA","119","74","74","ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⴷ ⴰⵢⵉ ⵥⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵜⵔⴰⵊⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_75","020_119_75","PSA","119","75","75","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⴻⴳⴳⴷⴻⵏⵜ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ, ⵓ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵃⵚⴰⵔⴻⴷ ⴰⵢⵉ ⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_76","020_119_76","PSA","119","76","76","ⴻⵊⵊ ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⴰⴼⴻⵡⵡⴻⵊ ⵉ ⵏⴻⵛⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵏⵏⵉⴷ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_77","020_119_77","PSA","119","77","77","ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷⴰⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_78","020_119_78","PSA","119","78","78","ⴻⵊⵊ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵙⵙⴼⴰⵔⵔⵖⴻⵏ ⴰⵢⵉ ⵚⵚⵉⴼⴻⵜ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵅⴻⵎⵎⴰⵎⴻⵖ ⴷⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_79","020_119_79","PSA","119","79","79","ⴻⵊⵊ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_80","020_119_80","PSA","119","80","80","ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵓⵍ ⵉⵏⵓ ⵉⵎⵓⵏ ⵖⴰⵔ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_81","020_119_81","PSA","119","81","81","ⴽⴰⴼ. ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵙⵅⴻⴼ ⵣⵉ ⵎⴻⵥⵔⵉ ⵖⴰⵔ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⵜⵔⴰⵊⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_82","020_119_82","PSA","119","82","82","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴷⴻⵇⵇⵍⴻⵏⵜ ⵣⵉ ⵎⴻⵥⵔⵉ ⵖⴰⵔ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ, ⵓⵎⵉ ⵏⵏⵉⵖ: ‘ⵎⴻⵍⵎⵉ ⵉ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⴼⴻⵡⵡⵊⴻⴷ?’ ");
INSERT INTO rift_vpl VALUES ("PS119_83","020_119_83","PSA","119","83","83","ⵎⴰⵖⴰⵔ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵢⵉⵍⴻⵎ ⵜⵓⵢⴻⵍ ⴷⵉ ⴷⴷⴻⵅⵅⴰⵏ, ⵎⴰⵛⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_84","020_119_84","PSA","119","84","84","ⵎⴻⵛⵃⴰⵍ ⵏ ⵡⵓⵙⵙⴰⵏ ⵄⴰⴷ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ? ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵜⵛⴰⵔⵔⵄⴻⴷ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS119_85","020_119_85","PSA","119","85","85","ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⵖⵣⴰⵏ ⴰⵢⵉ ⵉⵃⵓⴼⴰⵔ, ⵎⵉⵏ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_86","020_119_86","PSA","119","86","86","ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ. ⵏⵉⵜⵏⵉ ⵜⵜⴷⴰⵔⵔⴰⵛⴻⵏ ⴰⵢⵉ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴻⵡⵛ ⴰⵢⵉ ⴰⴼⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("PS119_87","020_119_87","PSA","119","87","87","ⵄⵍⴰⵃⴰⵍ ⵉⵍⵉ ⴰⵇⴰ ⵜⴻⵃⵃⴰⵏ ⴰⵢⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵖ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_88","020_119_88","PSA","119","88","88","ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⴹⵉⵖ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_89","020_119_89","PSA","119","89","89","ⵍⴰⵎⵉⴷ. ⴰ ⵙⵉⴷⵉ, ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ ⵉⵎⵜⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_90","020_119_90","PSA","119","90","90","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⵉⵡⴻⴹ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴱⴻⴷⴷ ⵜⴻⵎⵜⴻⵏ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PS119_91","020_119_91","PSA","119","91","91","ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_92","020_119_92","PSA","119","92","92","ⵎⴻⵄⵍⵉⴽ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⴷ ⵎⴻⵥⵔⵉ ⵉⵏⵓ, ⵉⵍⵉ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵖ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_93","020_119_93","PSA","119","93","93","ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⵜⵓⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴰⵔⵔⵉⴷ ⴰⵢⵉ-ⴷⴷ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_94","020_119_94","PSA","119","94","94","ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵉ ⵛⴻⴽ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⴰⵔⵣⵓⵖ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_95","020_119_95","PSA","119","95","95","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵔⴰⵊⴰⵏ ⴰⵢⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵃⵃⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_96","020_119_96","PSA","119","96","96","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⴵⴰ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵖⴰⵔⴻⵙ ⴰⵏⴻⴳⴳⴰⵔ, ⵎⴰⵛⴰ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵛ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_97","020_119_97","PSA","119","97","97","ⵎⵉⵎ. ⵎⴰⵎⵎⴻⵛ ⵉ ⵅⴰⴼⵉ ⵜⵄⵉⵣⵣ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ, ⴰⵙⵙ ⵉⴽⵎⴻⵍ ⵜⵜⵅⴰⵔⵔⵚⴻⵖ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_98","020_119_98","PSA","119","98","98","ⵙ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⵜⴰⵔⵔⵉⴷ ⴰⵢⵉ ⴷ ⴰⵎⵉⵖⵉⵙ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_99","020_119_99","PSA","119","99","99","ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵍⴻⵄⵇⴻⵍ ⴽⵜⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⵜⵅⴰⵔⵔⵚⴻⵖ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_100","020_119_100","PSA","119","100","100","ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴽⵜⴰⵔ ⵅ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⵎⴰⵖⴰⵔ ⵃⴹⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_101","020_119_101","PSA","119","101","101","ⵎⴻⵏⵄⴻⵖ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵣⵉ ⵇⴰⵄ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_102","020_119_102","PSA","119","102","102","ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵖ ⵛⴰ ⵅ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_103","020_119_103","PSA","119","103","103","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⴷ ⵎⵉⵥⵉⴷ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ ⵉ ⵡⴰⵏⴻⵖ ⵉⵏⵓ, ⵅ ⵜⴰⵎⵎⴻⵏⵜ ⵉ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS119_104","020_119_104","PSA","119","104","104","ⵣⵉ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⵜⵜⴰⵔⵔⵉⵖ-ⴷⴷ ⵍⴻⵄⵇⴻⵍ, ⵅ ⵓⵢⴰ ⵛⴰⵔⵔⵀⴻⵖ ⴽⵓⵍ ⴰⵎⴻⵙⵔⵓⵇ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_105","020_119_105","PSA","119","105","105","ⵏⵓⵏ. ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⴷ ⵍⴻⴼⵏⴰⵔ ⵉ ⵓⴹⴰⵔ ⵉⵏⵓ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉ ⵓⵎⴻⵙⵔⵓⵇ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_106","020_119_106","PSA","119","106","106","ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵓ ⴰⴷ ⵜ ⴳⴳⴻⵖ, ⴰⵇⴰ ⴰⴷ ⵃⴹⵉⵖ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_107","020_119_107","PSA","119","107","107","ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_108","020_119_108","PSA","119","108","108","ⵜⵜⵣⴰⵡⴳⴻⵖ, ⴽⵙⵉ ⵙ ⴰⵔⴹⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⵅⴰⴹⴰⵔ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵓ ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_109","020_119_109","PSA","119","109","109","ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵍⴻⴱⴷⴰ ⴷⵉ ⵍⵅⴰⵟⴻⵔ, ⵎⴰⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⵜⵓⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_110","020_119_110","PSA","119","110","110","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴳⴳⵉⵏ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴼⴼⵖⴻⵖ ⵛⴰ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_111","020_119_111","PSA","119","111","111","ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵙⵙⴼⴰⵔⵔⵃⴻⵏⵜ ⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_112","020_119_112","PSA","119","112","112","ⵃⴻⵣⵣⵎⴻⵖ ⵓⵍ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ⵉ ⵍⴻⴱⴷⴰ, ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS119_113","020_119_113","PSA","119","113","113","ⵙⴰⵎⵉⵅ. ⴰⵢⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵎⴱⴰⴱ ⵛⴰⵔⵔⵀⴻⵖ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵜⵜⴻⵅⵙⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_114","020_119_114","PSA","119","114","114","ⵛⴻⴽ ⴷ ⴰⴷⵓⵔⵔⵉ ⵉⵏⵓ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵜⵜⵔⴰⵊⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_115","020_119_115","PSA","119","115","115","ⴱⴻⵄⵄⴷⴻⵎ ⵅⴰⴼⵉ, ⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_116","020_119_116","PSA","119","116","116","ⵙⴻⵏⵏⴻⴷ ⴰⵢⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷⴰⵔⴻⵖ ⵓ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⴷⵉ ⵍⴰⵢⴰⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_117","020_119_117","PSA","119","117","117","ⵄⴻⵎⵎⴻⴷ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵖ, ⵓ ⴰⴷ ⴰⵔⵔⴻⵖ ⵎⴻⵥⵔⵉ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_118","020_119_118","PSA","119","118","118","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ, ⵙⵙⴻⵃⵇⴰⵔⴻⵖ ⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵍⵖⴻⵛⵛ ⵏⵙⴻⵏ ⵎⵖⵉⵔ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_119","020_119_119","PSA","119","119","119","ⴰⵎ ⴽⵓⴼⴼⵓ ⵜⵎⴻⵃⵃⵉⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵙ ⵓⵢⴰ ⵜⵜⴻⵅⵙⴻⵖ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_120","020_119_120","PSA","119","120","120","ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⴻⴽ ⵜⴻⵛⵛⵉⵔⵔⵓⵡ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⴳⴳⵯⴻⴷⴻⵖ ⵣⵉ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_121","020_119_121","PSA","119","121","121","ⵄⴰⵢⵉⵏ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵙⴻⵍⵍⴻⵎ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_122","020_119_122","PSA","119","122","122","ⴻⴳⴳ ⵍⵄⴰⵔⴱⵓⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵃⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_123","020_119_123","PSA","119","123","123","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴷⴻⵇⵇⵍⴻⵏⵜ ⵣⵉ ⵎⴻⵥⵔⵉ ⵖⴰⵔ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵖⴰⵔ ⵍⵡⴰⵄⴷ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_124","020_119_124","PSA","119","124","124","ⴻⴳⴳ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_125","020_119_125","PSA","119","125","125","ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⴻⵡⵛ ⴰⵢⵉ ⵍⴻⵄⵇⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵖ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_126","020_119_126","PSA","119","126","126","ⴰⵇⴰ ⵢⵉⵡⴻⴹ ⴰⵙ-ⴷⴷ ⵍⵃⴰⵍ ⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⵔⵥⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_127","020_119_127","PSA","119","127","127","ⵎⵉⵏⵣⵉ ⵜⵜⴻⵅⵙⴻⵖ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ ⵅ ⵡⵓⵔⴻⵖ, ⵡⴰⵀ ⴰⵟⵟⴰⵙ ⵅ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS119_128","020_119_128","PSA","119","128","128","ⵅ ⵓⵢⴰ ⵃⴻⵙⴱⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⴷⵉ ⴽⵓⵍ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⵛⴰⵔⵀⴻⵖ ⴽⵓⵍ ⴰⵎⴻⵙⵔⵓⵇ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_129","020_119_129","PSA","119","129","129","ⴱⵉ. ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵅ ⵓⵢⴰ ⵉⵃⴻⵟⵟⴰ ⵜⴻⵏⵜ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_130","020_119_130","PSA","119","130","130","ⴰⵏⵓⵔⵣⴻⵎ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵉⵙⵙⵛⴰⵏ ⵜⴰⴼⴰⵡⵜ, ⵉ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ ⵉⵜⵜⵉⵛ ⴰⵙⴻⵏ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS119_131","020_119_131","PSA","119","131","131","ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴰⵟⵟⴰⵙ ⵓ ⵙⵙⴰⵃⵔⴰⵜⴻⵖ ⵣⵉ ⵎⴻⵥⵔⵉ ⵖⴰⵔ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_132","020_119_132","PSA","119","132","132","ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔⵉ ⵓ ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⴻⴽⴽⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_133","020_119_133","PSA","119","133","133","ⵙⴻⵎⵜⴻⵏ ⵉⵚⵓⵔⴰⴼ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵅⴰⴼⵉ ⵉⵃⴽⴻⵎ ⵍⵖⴻⵛⵛ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_134","020_119_134","PSA","119","134","134","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_135","020_119_135","PSA","119","135","135","ⴻⵊⵊ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⵖ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_136","020_119_136","PSA","119","136","136","ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ ⵀⵡⴰⵏⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵃⴻⵟⵟⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_137","020_119_137","PSA","119","137","137","ⵜⵙⴰⴷⵉ. ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⴰ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ ⵙⴻⴳⴳⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_138","020_119_138","PSA","119","138","138","ⵛⴻⴽ ⵜⵓⵎⵓⵔⴻⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⵍⵎⴰⵏⴻⵜ ⵏⵙⴻⵏ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_139","020_119_139","PSA","119","139","139","ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵏⵓ ⵜⴻⵛⵛⴰ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵜⵜⵓⵏ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_140","020_119_140","PSA","119","140","140","ⵍⵡⴰⵄⴷ ⵏⵏⴻⵛ ⵉⵇⵇⵓⵔ ⴰⵟⵟⴰⵙ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_141","020_119_141","PSA","119","141","141","ⵏⴻⵛⵛ ⴷ ⴰⵎⵓⵇⵍⵉⵍ ⵓ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_142","020_119_142","PSA","119","142","142","ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵉ ⵍⴻⴱⴷⴰ, ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_143","020_119_143","PSA","119","143","143","ⴷⴷⵉⵇⴻⵜ ⴷ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵍⴻⵇⵇⴼⴻⵏⵜ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⴷⴰⵢⵙⴻⵏⵜ ⵎⴻⵥⵔⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_144","020_119_144","PSA","119","144","144","ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵜⴻⴵⴰ. ⵙⴻⴼⵀⴻⵎ ⴰⵢⵉ ⵜⴻⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS119_145","020_119_145","PSA","119","145","145","ⵇⵓⴼ. ⵍⴰⵖⵉⵖ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵉⵏⵓ, ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⴹⵉⵖ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_146","020_119_146","PSA","119","146","146","ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅⴰⴽ, ⴼⴻⴽⴽ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⴹⵉⵖ ⵎⴰⵔⵔⴰ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_147","020_119_147","PSA","119","147","147","ⵇⴱⴻⵍ ⵜⵓⴼⴼⵓⵜ ⵜⵓⵖⴰ ⵜⵜⵍⴰⵖⵉⵖ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⵡⵛⴻⴷ ⴰⴼⵓⵙ, ⵔⴰⵊⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_148","020_119_148","PSA","119","148","148","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴼⴰⵇⴻⵏⵜ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ ⵏ ⵡⵓⴹⵓⴼ ⵏ ⵡⴻⵛⴱⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_149","020_119_149","PSA","119","149","149","ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_150","020_119_150","PSA","119","150","150","ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⴼⴹⴰⵢⴻⵃ, ⵓⴷⵙⴻⵏ ⴰⵢⵉ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_151","020_119_151","PSA","119","151","151","ⵛⴻⴽ ⵜⵓⴷⵙⴻⴷ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ ⵉ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_152","020_119_152","PSA","119","152","152","ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⵙⵙⵏⴻⵖ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵏⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_153","020_119_153","PSA","119","153","153","ⵔⵉⵅ. ⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⵓ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵜⵓⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_154","020_119_154","PSA","119","154","154","ⴰⵖ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵓⵛⴰ ⴼⴻⴽⴽ ⴰⵢⵉ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS119_155","020_119_155","PSA","119","155","155","ⵉⴳⴳⵯⴻⵊ ⵓⵙⴻⵏⵊⴻⵎ ⵅ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_156","020_119_156","PSA","119","156","156","ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ ⴷ ⴰⵟⵟⴰⵙ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_157","020_119_157","PSA","119","157","157","ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴷⴰⵔⵔⴰⵛⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⵢⵢⴷⴻⵖ ⵛⴰ ⵅ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_158","020_119_158","PSA","119","158","158","ⵥⵔⵉⵖ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵖⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵄⵉⴼⴼⴻⵖ ⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_159","020_119_159","PSA","119","159","159","ⵅⵣⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_160","020_119_160","PSA","119","160","160","ⴱⴻⴷⴷⵓ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⴷ ⵜⵉⴷⴻⵜⵜ, ⴽⵓⵍ ⵍⴻⵃⴽⴰⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵣⵣⴰⵢⴻⴽ ⴰⵇⴰ-ⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS119_161","020_119_161","PSA","119","161","161","ⵛⵉⵏ. ⵍⵃⵓⴽⴽⴰⵎ ⴷⴰⵔⵔⵛⴻⵏ ⵅⴰⴼⵉ ⵅ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵓⵍ ⵉⵏⵓ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_162","020_119_162","PSA","119","162","162","ⵏⴻⵛⵛ ⴼⴰⵔⵃⴻⵖ ⵅ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵛ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⴰⴼ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS119_163","020_119_163","PSA","119","163","163","ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⴰⵅⴰⵔⵔⵉⵇ ⵓ ⵄⵉⴼⴼⴻⵖ ⵜ, ⵎⴰⵛⴰ ⵜⵜⴻⵅⵙⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_164","020_119_164","PSA","119","164","164","ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵚⴻⴱⵃⴻⵖ ⵛⴻⴽ ⵅ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_165","020_119_165","PSA","119","165","165","ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵀⵏⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵡⴰⵔ ⴷⵉⵏ ⴰⵥⵔⵓ ⵏ ⵓⵏⴻⵇⵔⴰⴹ ⵣⵣⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_166","020_119_166","PSA","119","166","166","ⴰ ⵙⵉⴷⵉ, ⵜⵜⵔⴰⵊⵉⵖ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵓ ⵜⵜⴻⴳⴳⴻⵖ ⵄⵍⴰⵃⵚⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_167","020_119_167","PSA","119","167","167","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵃⴻⵟⵟⴰ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⵜⵜⴻⵅⵙⴻⵖ ⵜⴻⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS119_168","020_119_168","PSA","119","168","168","ⵏⴻⵛⵛ ⵃⴻⵟⵟⵉⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⴰⵔⵣⵎⴻⵏ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS119_169","020_119_169","PSA","119","169","169","ⵜⴰⴼ. ⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵡⴻⴹ ⵓⵍⴰⵖⵉ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴻⵡⵛ ⴰⵢⵉ ⵍⴻⵄⵇⴻⵍ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_170","020_119_170","PSA","119","170","170","ⴻⵊⵊ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⵓⵜⵔⴰ ⵉⵏⵓ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴼⴻⴽⴽ ⴰⵢⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS119_171","020_119_171","PSA","119","171","171","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ ⴰⴷ ⵓⵛⵔⵓⵔⴻⵏ ⴰⵚⴻⴱⴱⴻⵃ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⴰⵢⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_172","020_119_172","PSA","119","172","172","ⵉⵍⴻⵙ ⵉⵏⵓ ⴰⴷ ⵢⴰⵔⵔ ⵎⵉⵏ ⵜⴻⵏⵏⵉⴷ ⵛⴻⴽ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ ⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS119_173","020_119_173","PSA","119","173","173","ⴻⵊⵊ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵜⵡⵉⵣⴰ, ⵎⴰⵖⴰⵔ ⵉⵅⴹⴰⵔⴻⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_174","020_119_174","PSA","119","174","174","ⴰ ⵙⵉⴷⵉ, ⵜⵜⵎⴻⵥⵔⴻⵖ ⵖⴰⵔ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS119_175","020_119_175","PSA","119","175","175","ⴻⵊⵊ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴷ ⵉⴷⴷⴰⵔ, ⴰⴷ ⵛⴻⴽ ⵉⵚⴻⴱⴱⴻⵃ, ⴰⴷ ⴰⵢⵉ ⵄⴰⵡⵏⴻⵏⵜ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS119_176","020_119_176","PSA","119","176","176","ⵏⴻⵛⵛ ⵡⴻⴷⴷⴰⵔⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵀⵓⵍⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ. ⴰⵔⵣⵓ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵜⵓⵖ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS120_1","020_120_1","PSA","120","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS120_2","020_120_2","PSA","120","2","2","ⴰ ⵙⵉⴷⵉ, ⴼⴻⴽⴽ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵣⴻⴳ ⵉⵍⴻⵙ ⵉⵛⴻⵎⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS120_3","020_120_3","PSA","120","3","3","ⵎⵉⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵢⴻⵡⵛ, ⵎⵉⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵢⴰⵔⵏⵉ ⵉⵍⴻⵙ ⵏⵏⵉ ⵉⵛⴻⵎⵎⵜⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS120_4","020_120_4","PSA","120","4","4","ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵇⴻⴹⵄⴻⵏⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵊⴰⵀⴻⴷ, ⴰⴽ-ⴷ ⵍⴻⴼⵃⴻⵎ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴰⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("PS120_5","020_120_5","PSA","120","5","5","ⵓⵛⵜ ⵉⵏⵓ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵎⴰⵛⵉⴽ, ⴰⵇⴰ ⵣⴻⴷⴷⵖⴻⵖ ⵖⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏ ⵇⵉⴷⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("PS120_6","020_120_6","PSA","120","6","6","ⴰⵟⵟⴰⵙ ⵉ ⵉⵣⴷⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS120_7","020_120_7","PSA","120","7","7","ⵏⴻⵛⵛ ⴷ ⴰⵀⴻⴷⴷⴰⵏ, ⵎⴰⵛⴰ ⵅⵎⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⴰⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PS121_1","020_121_1","PSA","121","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ⵎⴰⵏⵉⵙ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵜⵡⵉⵣⴰ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("PS121_2","020_121_2","PSA","121","2","2","ⵜⵡⵉⵣⴰ ⵉⵏⵓ ⵣⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS121_3","020_121_3","PSA","121","3","3","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⴼⴰⵔⵖ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵃⴻⵟⵟⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵏⵓⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PS121_4","020_121_4","PSA","121","4","4","ⵅⵣⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⵜⵜⵏⵓⴷⵓⵎ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵟⵟⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PS121_5","020_121_5","PSA","121","5","5","ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵏⵏⴻⵛ, ⵙⵉⴷⵉ ⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS121_6","020_121_6","PSA","121","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵜⴰⴼⵓⵛⵜ ⵡⴰⵔ ⵛⴻⴽ ⵜⴻⵛⵛⵉⵜ ⵛⴰ, ⵓⵍⴰ ⴷ ⵜⴰⵣⵉⵔⵉ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS121_7","020_121_7","PSA","121","7","7","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵃⴹⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴹⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS121_8","020_121_8","PSA","121","8","8","ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴹⴰ ⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ ⴷ ⵡⴰⴷⴰⴼ ⵏⵏⴻⵛ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS122_1","020_122_1","PSA","122","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏ ⴷⴰⵡⵓⴷ. ⵏⴻⵛⵛ ⴼⴰⵔⵔⵃⴻⵖ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS122_2","020_122_2","PSA","122","2","2","ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵖ ⴱⴻⴷⴷⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ!” ");
INSERT INTO rift_vpl VALUES ("PS122_3","020_122_3","PSA","122","3","3","ⵓⵔⵛⴰⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⴱⴱⴰⵔⴻⵏ ⵎⵍⵉⵃ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS122_4","020_122_4","PSA","122","4","4","ⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏⵜ ⵜⵇⴻⴱⴱⴰⵍ, ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⵉⴹⴰ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵇⴰⴷⴰⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS122_5","020_122_5","PSA","122","5","5","ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵛⵛⵔⴻⵄ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS122_6","020_122_6","PSA","122","6","6","ⵜⵜⴰⵔⴻⵎ ⵉ ⵍⴻⵀⵏⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ: “ⴰⵇⴰ ⴰⴷ ⴼⴻⵍⵃⴻⵏ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS122_7","020_122_7","PSA","122","7","7","ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏ ⵣⵣⴰⵜ ⵏⵏⴻⵎ, ⵓⵍⴰ ⴷ ⵍⵀⵓⴷⵏⴻⵜ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("PS122_8","020_122_8","PSA","122","8","8","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵢⵜⵎⴰ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ ⴰⴷ ⵉⵏⵉⵖ: “ⴰⴷ ⴷⴰⵢⴻⵎ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("PS122_9","020_122_9","PSA","122","9","9","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⴷ ⴰⵛ ⴰⵔⵣⵓⵖ ⵅ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS123_1","020_123_1","PSA","123","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵖⴰⵔⴻⴽ, ⵛⴻⴽ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS123_2","020_123_2","PSA","123","2","2","ⵅⵣⴰⵔ, ⴰⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵙⴻⵎⵖⴰⵏ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⴱⴰⴱ ⵏⵙⴻⵏ, ⴰⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵜⴰⵢⵢⴰ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵍⴰⵍⵍⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵍ ⵅⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵃⵉⵏⵏ. ");
INSERT INTO rift_vpl VALUES ("PS123_3","020_123_3","PSA","123","3","3","ⵃⵉⵏⵏ ⵅⴰⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⵃⵉⵏⵏ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵢⵓⵣⴰ ⵖⴰⵔⵏⴻⵖ ⵓⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS123_4","020_123_4","PSA","123","4","4","ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⵢⵓⵣⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵓⵙⵜⴻⵀⵣⵉ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ, ⵓⵍⴰ ⵣⴻⴳ ⵓⵙⴻⵃⵇⴰⵔ ⵏ ⵉⵖⴻⴱⴱⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS124_1","020_124_1","PSA","124","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏ ⴷⴰⵡⵓⴷ. ⵎⵍⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵉⴱⴻⴷⴷ! ⵉⵏⵉ ⵜ ⵅⴻⵏⵏⵉ ⴰⵎⵎⵓ, ⴰ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("PS124_2","020_124_2","PSA","124","2","2","ⵎⵍⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵉⴱⴻⴷⴷ, ⵓⵎⵉ ⴰⴽⵉⴷⵏⴻⵖ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS124_3","020_124_3","PSA","124","3","3","ⵉⵍⵉ ⵙⴰⵔⴹⴻⵏ ⴰⵏⴻⵖ ⴰⵎ ⵏⴻⴷⴷⴰⵔ, ⵓⵎⵉ ⵢⴰⵔⵖⴰ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵙⴻⵏ ⵅⴰⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("PS124_4","020_124_4","PSA","124","4","4","ⵉⵍⵉ ⴰⵎⴰⵏ ⴼⴻⵢⵢⴹⴻⵏ ⵅⴰⵏⴻⵖ, ⵉⵍⵉ ⵉⵛⵜ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⵜⴻⴽⴽⴰ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("PS124_5","020_124_5","PSA","124","5","5","ⵉⵍⵉ ⴰⵎⴰⵏ ⵉⵃⴰⵊⴻⵏ ⴽⴽⵉⵏ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS124_6","020_124_6","PSA","124","6","6","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵊⵊⵉⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵜⴻⵖⵎⴰⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS124_7","020_124_7","PSA","124","7","7","ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⵢⴰⵔⵡⴻⵍ ⴰⵎ ⵡⴻⵊⴹⵉⴹ ⵣⵉ ⵍⴼⴻⵅ ⵏ ⵓⵏⴻⴳⵎⴰⵔ. ⵍⴼⴻⵅ ⵢⴰⵔⴻⵥ ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵏⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("PS124_8","020_124_8","PSA","124","8","8","ⵜⵡⵉⵣⴰ ⵏⵏⴻⵖ ⵜⴱⴻⴷⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS125_1","020_125_1","PSA","125","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵉⵏⵏⵉ ⵉⵜⵜⴻⵛⵍⴻⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⵉⵏ, ⵎⴰⵛⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS125_2","020_125_2","PSA","125","2","2","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴷⵓⵔⴰⵔ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎⵎⵓ ⵉⵇⵓⵡⵡⴰⵔ ⵙⵉⴷⵉ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS125_3","020_125_3","PSA","125","3","3","ⵎⴰⵖⴰⵔ ⴰⵣⴻⴵⴰⴹ ⵏ ⵍⵖⴰⵔ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵜⵜⴰⵔⴻⵢⵢⴻⵃ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵃⵉⵎⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵡⴰⵔ ⵙⵙⵡⵉⵥⵥⵉⴹⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS125_4","020_125_4","PSA","125","4","4","ⵉⵍⵉ ⴰⴷ ⵢⴻⴳⴳ ⵙⵉⴷⵉ ⵜⴰⵛⵓⵏⵉ ⴷⴻⴳ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ, ⴷⴻⴳ ⵉⵏⵏⵉ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵙ ⵡⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("PS125_5","020_125_5","PSA","125","5","5","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⵢⵢⴷⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵙⵉⴷⵉ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ. ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS126_1","020_126_1","PSA","126","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵓⵎⵉ ⵉⵙⵙⴻⵄⵇⴻⴱ ⵙⵉⴷⵉ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ, ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴰⵅⵎⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵓⵔⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS126_2","020_126_2","PSA","126","2","2","ⵜⵓⵖⴰ ⴰⵇⴻⵎⵎⵓⵏ ⵏⵏⴻⵖ ⵉⵛⵛⵓⵔ ⵙ ⵜⴹⴻⵃⵃⴰⵛⵜ, ⵉⵍⴻⵙ ⵏⵏⴻⵖ ⵉⵛⵛⵓⵔ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⵏⵏⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ: ‘ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴷⴰⵢⵙⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("PS126_3","020_126_3","PSA","126","3","3","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴷⴰⵢⵏⴻⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴼⴰⵔⵃ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS126_4","020_126_4","PSA","126","4","4","ⴰ ⵙⵉⴷⵉ, ⵇⴻⴵⴻⴱ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵏⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵇⴻⴵⴱⴻⵏⵜ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PS126_5","020_126_5","PSA","126","5","5","ⵉⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⴰⴷ ⵎⵊⴰⵔⴻⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PS126_6","020_126_6","PSA","126","6","6","ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ, ⵉⵜⵜⵔⵓ ⵅⵎⵉ ⴷⴷ-ⵉⴳⴳⵓⵔ, ⵎⴰⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵉⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS127_1","020_127_1","PSA","127","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⵎⵍⵉ ⵡⴰⵔ ⵉⴱⴻⵏⵏⵉ ⵙⵉⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⴷ ⵙⵙⵉⵃⵍⴻⵏ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴱⴰⵟⴻⵍ. ⵎⵍⵉ ⵡⴰⵔ ⵉⵃⴻⵟⵟⵉ ⵙⵉⴷⵉ ⵅ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⵄⴻⵙⵙⴰⵙ ⴰⴷ ⵉⵄⴻⵙⵙ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS127_2","020_127_2","PSA","127","2","2","ⴱⴰⵟⴻⵍ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⵎ ⵣⵉⵛ, ⴰⴷ ⵜᵉⵟⵟⵚⴻⵎ ⵜⵄⴻⴹⵍⴻⵎ, ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ ⵏ ⵍⴻⵎⵃⴰⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵉⵛ ⵉ-ⵜ ⵉ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵢⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PS127_3","020_127_3","PSA","127","3","3","ⵅⵣⴰⵔ, ⴰⵔⵔⴰⵡⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵣⵉ ⵙⵉⴷⵉ, ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵎⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS127_4","020_127_4","PSA","127","4","4","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵊⴻⵀⴷⴻⵏⵜ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵎⵎⵓ ⵉ ⴵⴰⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵣⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⴻⵎⵥⵉ. ");
INSERT INTO rift_vpl VALUES ("PS127_5","020_127_5","PSA","127","5","5","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵛⵛⵓⵔ ⴰⵇⵔⴰⴱ ⵏⵏⴻⵙ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ ⵛⴰ ⵓⵎⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PS128_1","020_128_1","PSA","128","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵙⵙⴻⵄⴷ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS128_2","020_128_2","PSA","128","2","2","ⴰⵇⴰ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵣⴻⴳ ⵡⴰⵔⴱⴻⵔ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⵉⵎⵓⵏ ⴷ ⵍⴻⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PS128_3","020_128_3","PSA","128","3","3","ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴰⵔⵔⴰⵡⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵉⵖⴻⵎⵎⵓⵢⴻⵏ ⵏ ⵣⵣⵉⵜⵓⵏ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵉ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS128_4","020_128_4","PSA","128","4","4","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS128_5","020_128_5","PSA","128","5","5","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⵓ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⴰⵇⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵜⵉⵍⵉ ⵎⵍⵉⵃ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS128_6","020_128_6","PSA","128","6","6","ⵡⴰⵀ, ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ⵍⴻⵀⵏⴰ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS129_1","020_129_1","PSA","129","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. “ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ ⵃⵚⴰⵔⴻⵏ ⴰⵢⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ!” ⵉⵏⵉ ⵜ ⵅⴻⵏⵏⵉ ⴰⵎⵎⵓ, ⴰ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("PS129_2","020_129_2","PSA","129","2","2","ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ ⵃⵚⴰⵔⴻⵏ ⴰⵢⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS129_3","020_129_3","PSA","129","3","3","ⵉⵎⵛⴰⵔⵔⵣⴻⵏ ⵛⴰⵔⵣⴻⵏ ⵅ ⵡⴻⵄⵔⵓⵔ ⵉⵏⵓ, ⴳⴳⵉⵏ ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵡⴻⵛⵔⴰⵣ ⵏⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS129_4","020_129_4","PSA","129","4","4","ⵙⵉⴷⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ. ⵏⴻⵜⵜⴰ ⵉⵇⴹⴻⵄ ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS129_5","020_129_5","PSA","129","5","5","ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵔⵏⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS129_6","020_129_6","PSA","129","6","6","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⴰⵔⴱⵉⵄ ⵅ ⵜⵣⴻⵖⵡⵉⵏ ⵉ ⵉⵜⵜⵉⵙⵍⴰⵡ ⵇⴱⴻⵍ ⵉ-ⵜ ⵖⴰ ⵇⴻⵍⵄⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS129_7","020_129_7","PSA","129","7","7","ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵄⴻⵎⵎⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴷⴷⴰⵏ ⵉⵛⵓⵡⵡⴰⴼⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴰⵃⵙⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS129_8","020_129_8","PSA","129","8","8","ⵓ ⵃⵉⵎⴰ ⵉⵎⵙⴻⴱⵔⵉⴷⴻⵏ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ: “ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⵡⴻⵎ!” “ⵏⴻⵛⵛⵉⵏ ⵏⴱⴰⵔⴻⴽ ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("PS130_1","020_130_1","PSA","130","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵣⵉ ⵍⴰⴵⴰⵖ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅⴰⴽ, ⴰ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("PS130_2","020_130_2","PSA","130","2","2","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⴻⵍ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⴻⵊⵊ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⴼⴻⵜⵏⴻⵏ ⵅ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵓⵜⵔⴰ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PS130_3","020_130_3","PSA","130","3","3","ⴰ ⵙⵉⴷⵉ, ⵎⴰⵍⴰ ⵜⴻⵃⴹⵉⴹ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵎⵍⵉⵃ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PS130_4","020_130_4","PSA","130","4","4","ⵎⴰⵛⴰ ⵖⴰⵔⴻⴽ ⴰⵙⴰⵎⴻⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS130_5","020_130_5","PSA","130","5","5","ⵏⴻⵛⵛ ⵙⵉⵜⵉⵎⴻⵖ ⴷⵉ ⵙⵉⴷⵉ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵛⵛⵓⵔ ⵙ ⵓⵙⵉⵜⴻⵎ, ⵜⵜⵔⴰⵊⵉⵖ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS130_6","020_130_6","PSA","130","6","6","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⵔⴰⵊⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵜⵜⵔⴰⵊⴰⵏ ⵖⴰⵔ ⵓⵜⴻⴼⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("PS130_7","020_130_7","PSA","130","7","7","ⴻⵊⵊ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵔⴰⵊⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵖⴰⵔⴻⵙ ⴰⴼⴻⴽⴽⵉ ⵉⵛⴻⵟⵟ. ");
INSERT INTO rift_vpl VALUES ("PS130_8","020_130_8","PSA","130","8","8","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS131_1","020_131_1","PSA","131","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⵙⵉⴷⵉ, ⵓⵍ ⵉⵏⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵏⵏⴼⴰⵅⴻⵜ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⴱⵓ ⵓⵏⴻⵄⴼⴰⵔ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵛⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵓⵊⴰⵔⴻⵏⵜ ⴰⵢⵉ ⵏⵉⵖ ⴷ ⵜⵉⵏⵏⵉ ⴷ ⵍⴻⵄⵊⴻⴱ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS131_2","020_131_2","PSA","131","2","2","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵓ ⵙⵙⴻⵙⵇⴰⵔⴻⵖ ⵜ, ⴰⵎ ⵉⵊⵊ ⵏ ⵓⵏⵉⵢⴱⵓ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵡⵓⵟⵟⵓⴹ ⴰⴽ-ⴷ ⵢⴻⵎⵎⴰⵙ, ⴰⵎ ⵉⵊⵊ ⵏ ⵓⵏⵉⵢⴱⵓ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵡⵓⵜⵜⵓⴹ ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS131_3","020_131_3","PSA","131","3","3","ⴻⵊⵊ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵔⴰⵊⴰ ⵙⵉⴷⵉ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS132_1","020_132_1","PSA","132","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⴰ ⵙⵉⴷⵉ, ⵉⴷⴰⵔ ⴷⴰⵡⵓⴷ, ⵉⴷⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵡⴻⴷⴷⴻⴱ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS132_2","020_132_2","PSA","132","2","2","ⵎⴰⵎⵎⴻⵛ ⵉⵊⵊⵓⴵ ⵉ ⵙⵉⴷⵉ, ⵉⵡⴰⵄⴷ ⵉ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵏ ⵢⴰⵄⵇⵓⴱ: ");
INSERT INTO rift_vpl VALUES ("PS132_3","020_132_3","PSA","132","3","3","“ⵓⵛⵜ, ⵎⴰⵍⴰ ⴰⴷ ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴰⵇⵉⴷⵓⵏⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⴰⴷ ⵃⴻⴱⵛⴻⵖ ⵅ ⵇⴰⵎⴰ ⵏ ⵍⴻⵛⵜⵓ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS132_4","020_132_4","PSA","132","4","4","ⴰⴷ ⵙⴻⵎⵎⵃⴻⵖ ⵢⵉⴹⴻⵚ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⴰⵏⵓⴷⴻⵎ ⵉ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PS132_5","020_132_5","PSA","132","5","5","ⵇⴱⴻⵍ ⵉ ⵖⴰ ⴰⴼⴻⵖ ⴰⵎⵛⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵙⵉⴷⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵏ ⵢⴰⵄⵇⵓⴱ!” ");
INSERT INTO rift_vpl VALUES ("PS132_6","020_132_6","PSA","132","6","6","ⵅⵣⴰⵔ, ⵏⴻⵙⵍⴰ ⵅ ⵜⵜⴰⴱⵓⵜ ⴷⵉ ⵉⴼⵔⴰⵜⴰ, ⵏⵓⴼⴰ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵢⴰⵄⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS132_7","020_132_7","PSA","132","7","7","ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵏⴻⵙⵊⴻⴷ ⵉ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS132_8","020_132_8","PSA","132","8","8","ⴽⴽⴰⵔ, ⵙⵉⴷⵉ, ⵓⵢⵓⵔ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵛ, ⵛⴻⴽ ⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS132_9","020_132_9","PSA","132","9","9","ⴻⵊⵊ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⴹⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ, ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS132_10","020_132_10","PSA","132","10","10","ⵡⴰⵔ ⴷⴷ-ⵜⴰⵔⵔⵉ ⵓⴷⴻⵎ ⵏ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵛ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS132_11","020_132_11","PSA","132","11","11","ⵙⵉⴷⵉ ⵉⵊⵊⵓⴵ ⵉ ⴷⴰⵡⵓⴷ ⵙ ⵍⴰⵎⴰⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵏⴻⵜⵜⴰ ⵅ ⵜⵊⴰⴵⵉⵜ ⵏⵏⴻⵙ: “ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ ⴰⴷ ⵙⵙⵖⵉⵎⴻⵖ ⵉⵊⵊ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS132_12","020_132_12","PSA","132","12","12","ⵎⴰⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵃⴹⴰⵏ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴷ ⵛⵛⵀⴰⴷⴰⵜ ⵉⵏⵓ, ⵜⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⵙⵙⵍⴻⵎⴷⴻⵖ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("PS132_13","020_132_13","PSA","132","13","13","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵚⵉⵀⵢⵓⵏ, ⵉⵎⴻⵥⵔⵉ ⵜⵜ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS132_14","020_132_14","PSA","132","14","14","“ⵡⴰ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵀⴻⵜ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ, ⴷⴰ ⵉ ⵅⵙⴻⵖ ⴰⴷ ⵣⴻⴷⵖⴻⵖ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⵜ. ");
INSERT INTO rift_vpl VALUES ("PS132_15","020_132_15","PSA","132","15","15","ⴰⴷ ⴱⴰⵔⴽⴻⵖ ⵏⵏⵉⵄⵎⴻⵜ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵙⵙⵊⵉⵡⵏⴻⵖ ⵉⵎⴻⵣⵍⴰⴹ ⵏⵏⴻⵙ ⵙ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PS132_16","020_132_16","PSA","132","16","16","ⴰⴷ ⵙⵙⵢⴰⵔⴹⴻⵖ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵙ ⵓⵙⴻⵏⵊⴻⵎ, ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PS132_17","020_132_17","PSA","132","17","17","ⴷⵉⵏⵏⵉ ⴰⴷ ⵙⵙⵖⴻⵎⵎⵢⴻⵖ ⵉⵊⵊ ⵏ ⵓⵢⵉⵛⵛ ⵉ ⴷⴰⵡⵓⴷ, ⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵉⵏⵓ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵜ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS132_18","020_132_18","PSA","132","18","18","ⴰⴷ ⵙⵙⵢⴰⵔⴹⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵙ ⵓⵙⴻⴹⵃⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵅⴰⵙ ⵉⵏⵏⵓⵡⴰⵔ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("PS133_1","020_133_1","PSA","133","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵏ ⴷⴰⵡⵓⴷ. ⵅⵣⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⵉⵚⴱⴻⵃ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵏⴰ, ⵎⴰⵍⴰ ⵜⴰⵡⵎⴰⵜ ⵣⴻⴷⴷⵖⴻⵏ ⵎⵓⵏⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS133_2","020_133_2","PSA","133","2","2","ⴰⵢⴰ ⴰⵎ ⵣⵣⴻⵛⵜ ⵉⵛⵏⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ, ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⵅ ⵜⵎⴰⵔⵜ, ⵅ ⵜⵎⴰⵔⵜ ⵏ ⵀⴰⵔⵓⵏ, ⵜⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵅ ⵜⵎⴰ ⵏ ⵓⴼⵓⵔⵔⵉ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS133_3","020_133_3","PSA","133","3","3","ⴰⵢⴰ ⴰⵎ ⵏⵏⴷⴰ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵉⵔⵎⵓⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵏⴻⵙ, ⵜⵓⴷⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS134_1","020_134_1","PSA","134","1","1","ⵉⵣⵍⵉ ⵏ ⵓⴳⴻⵄⵄⴻⴷ. ⵅⵣⴰⵔ, ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS134_2","020_134_2","PSA","134","2","2","ⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS134_3","020_134_3","PSA","134","3","3","ⴰⴷ ⵛⴻⴽ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS135_1","020_135_1","PSA","135","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ⵚⴻⴱⴱⵃⴻⵎ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵚⴻⴱⴱⵃⴻⵎ ⵅⴰⵙ, ⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("PS135_2","020_135_2","PSA","135","2","2","ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS135_3","020_135_3","PSA","135","3","3","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵚⴱⴻⵃ, ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS135_4","020_135_4","PSA","135","4","4","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴼⴰⵔⵣ ⵢⴰⵄⵇⵓⴱ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS135_5","020_135_5","PSA","135","5","5","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS135_6","020_135_6","PSA","135","6","6","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⴻⵄⵊⵉⴱⴻⵏ ⵉ ⵙⵉⴷⵉ, ⵉⴳⴳⴰ ⵉ-ⵜ, ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵍⴻⴱⵃⵓⵔ ⵓ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS135_7","020_135_7","PSA","135","7","7","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵣⵉ ⵟⵟⵔⵓⴼⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⴰⵙⵙⴰⵎⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵥⴰⵔ, ⵉⵜⵜⴳⴻⵡⵡⴰⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵍⴻⵀⵔⵉⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PS135_8","020_135_8","PSA","135","8","8","ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⵉⵎⴻⵏⵣⴰ ⵏ ⵎⵉⵚⵔⴰ, ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⴰⵍ ⵍⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS135_9","020_135_9","PSA","135","9","9","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⴰ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS135_10","020_135_10","PSA","135","10","10","ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵉⵏⵖⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS135_11","020_135_11","PSA","135","11","11","ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵓ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS135_12","020_135_12","PSA","135","12","12","ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS135_13","020_135_13","PSA","135","13","13","ⴰ ⵙⵉⴷⵉ, ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵅⴰⵔⵔⴻⵚ ⴷⴰⵢⴻⴽ ⴰⴷ ⵢⵉⵍⵉ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS135_14","020_135_14","PSA","135","14","14","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵔⵔ ⵜⴰⵙⵖⴰⵔⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⵉⵏⵏ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS135_15","020_135_15","PSA","135","15","15","ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS135_16","020_135_16","PSA","135","16","16","ⵏⵉⵜⴻⵏⵜⵉ ⵖⴰⵔⵙⴻⵏⵜ ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏⵜ, ⵖⴰⵔⵙⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("PS135_17","020_135_17","PSA","135","17","17","ⵏⵉⵜⴻⵏⵜⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏⵜ, ⵡⴰⵍⵓ ⴰⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS135_18","020_135_18","PSA","135","18","18","ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵏⵜ ⵉⴳⴳⵉⵏ ⴰⵎ ⵏⵉⵜⴻⵏⵜⵉ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵅⴰⵙⴻⵏⵜ ⵉⵜⵜⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("PS135_19","020_135_19","PSA","135","19","19","ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⴰⵔⵓⵏ, ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS135_20","020_135_20","PSA","135","20","20","ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴰⵡⵉ, ⴱⴰⵔⴽⴻⵎ ⵙⵉⴷⵉ! ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ, ⴰⴷ ⴱⴰⵔⴽⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS135_21","020_135_21","PSA","135","21","21","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PS136_1","020_136_1","PSA","136","1","1","ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_2","020_136_2","PSA","136","2","2","ⵇⴰⴷⴰⵎ ⵡⴻⵏⵏⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_3","020_136_3","PSA","136","3","3","ⵇⴰⴷⴰⵎ ⵡⴻⵏⵏⵉ ⴷ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵉⴷⵉⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_4","020_136_4","PSA","136","4","4","... ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_5","020_136_5","PSA","136","5","5","... ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_6","020_136_6","PSA","136","6","6","... ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵅ ⵡⴰⵎⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_7","020_136_7","PSA","136","7","7","... ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵉⴼⴰⵡⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_8","020_136_8","PSA","136","8","8","ⵜⴰⴼⵓⵛⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴽⴻⵎ ⵅ ⵡⴰⵙⵙ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_9","020_136_9","PSA","136","9","9","ⵜⴰⵣⵉⵔⵉ ⴷ ⵉⵜⵔⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵅ ⴵⵉⵍⴻⵜ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_10","020_136_10","PSA","136","10","10","... ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵏⵣⴰ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_11","020_136_11","PSA","136","11","11","... ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_12","020_136_12","PSA","136","12","12","ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵓⵖⵉⵍ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_13","020_136_13","PSA","136","13","13","... ⵡⴻⵏⵏⵉ ⵉⴱⴹⴰⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⵅ ⵜⵏⴰⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_14","020_136_14","PSA","136","14","14","ⵓⵛⴰ ⵉⵙⵙⴻⵥⵡⴰ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_15","020_136_15","PSA","136","15","15","ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⴼⵉⵔⵄⵓⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_16","020_136_16","PSA","136","16","16","... ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⵀⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_17","020_136_17","PSA","136","17","17","... ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_18","020_136_18","PSA","136","18","18","ⵓⵛⴰ ⵉⵏⵖⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_19","020_136_19","PSA","136","19","19","ⵄⵇⴻⵍ ⵅ ⵙⵉⵃⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_20","020_136_20","PSA","136","20","20","ⵅ ⵄⵓⵊ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⵛⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_21","020_136_21","PSA","136","21","21","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS136_22","020_136_22","PSA","136","22","22","ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_23","020_136_23","PSA","136","23","23","ⵉⴷⴰⵔ ⴰⵏⴻⵖ ⴷⵉ ⴷⴷⴻⴵ ⵏⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_24","020_136_24","PSA","136","24","24","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⴰⵏⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⵚⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_25","020_136_25","PSA","136","25","25","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵎⴰⵛⵛⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS136_26","020_136_26","PSA","136","26","26","ⵇⴰⴷⴰⵎ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS137_1","020_137_1","PSA","137","1","1","ⵖⴰⵔ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⴱⴰⴱⵉⵍ, ⴷⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⵖⵉⵎⴰ, ⵏⵔⵓ ⵄⴰⵡⴻⴷ ⵅⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⵉⴷⴰⵔ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("PS137_2","020_137_2","PSA","137","2","2","ⵏⵓⵢⴻⵍ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⵏⵏⴻⵖ ⵖⴰⵔ ⵉⵚⴻⴼⵚⴰⴼⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS137_3","020_137_3","PSA","137","3","3","ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⴱⴱⵙⴻⵏ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⴷⵉⵏⵏⵉ ⴰⴷ ⵏⵖⴻⵏⵏⴻⵊ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ, ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵜⵜⴰⵔⴻⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉⵙⵙⴻⴼⵔⴰⵃⴻⵏ. ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵖⴻⵏⵏⵊⴻⵎ ⵣⴻⵄⵎⴰ ⵉⵊⵊ ⵣⴻⴳ ⵉⵣⵍⴰⵏ ⵏ ⵚⵉⵀⵢⵓⵏ ⵉ ⵏⴻⵛⵛⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("PS137_4","020_137_4","PSA","137","4","4","ⵎⴰⵎⵎⴻⵛ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵖⴻⵏⵏⴻⵊ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⴷⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PS137_5","020_137_5","PSA","137","5","5","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵜⵜⵓⵖ ⵛⴻⵎ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵓ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS137_6","020_137_6","PSA","137","6","6","ⴻⵊⵊ ⴰⴷ ⴰⵢⵉ ⵉⵍⵚⴻⵇ ⵉⵍⴻⵙ ⵉⵏⵓ ⵅ ⵡⴰⵏⴻⵖ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⵉⴷⴰⵔⴻⵖ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵙⵙⵄⵓⴵⵉⵖ ⵓⵔⵛⴰⵍⵉⵎ ⵅ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS137_7","020_137_7","PSA","137","7","7","ⴰ ⵙⵉⴷⵉ, ⵄⵇⴻⵍ ⵅ ⴰⵢⵜ ⵏ ⵉⴷⵓⵎ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵄⴰⵔⵔⴰⵎ ⵜⵜ, ⵄⴰⵔⵔⴰⵎ ⵜⵜ, ⴰⵍ ⴷⵙⴰⵙ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("PS137_8","020_137_8","PSA","137","8","8","ⴰ ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⵉⵍ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵃⵓⵣⴻⵏ ⵉ ⵡⴰⵔⴻⴷⴷⴻⴵ, ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵉⵅⴻⴵⵚⴻⵏ ⵜⴰⵎⴻⴳⴳⵉⵜ ⵉⵄⴻⴼⴼⵏⴻⵏ ⵉ ⴷⴰⵢⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PS137_9","020_137_9","PSA","137","9","9","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵉⵍⴱⴻⵣ ⵅ ⵜⴻⵚⴹⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS138_1","020_138_1","PSA","138","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵖ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵉⵏⵓ, ⴰⴷ ⵛⴻⴽ ⵣⴻⵀⵀⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS138_2","020_138_2","PSA","138","2","2","ⴰⴷ ⴱⴻⵏⴷⵇⴻⵖ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⴷ ⵇⴰⴷⵉⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵅ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓ ⵅ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴻⴷ ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴼⴻⵏ ⵄⴰⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS138_3","020_138_3","PSA","138","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵍⴰⵎⵉ ⵅⴰⴽ ⴷⴷ-ⵍⴰⵖⵉⵖ, ⵜⴰⵔⵔⵉⴷ-ⴷⴷ ⵅⴰⴼⵉ, ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⵊⵊⴻⵀⴷ ⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS138_4","020_138_4","PSA","138","4","4","ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⴰⵏ, ⴰ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS138_5","020_138_5","PSA","138","5","5","ⴰⴷ ⵖⴻⵏⵏⵊⴻⵏ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS138_6","020_138_6","PSA","138","6","6","ⵎⴰⵖⴰⵔ ⵡⴰⵅⵅⴰ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ ⵙⵉⴷⵉ ⴰⵟⵟⴰⵙ, ⵄⴰⴷ ⵉⵅⴻⵣⵣⴰⵔ-ⴷⴷ ⵖⴰⵔ ⵓⵎⵡⴰⴹⴻⵄ, ⵎⴰⵛⴰ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⵉⵙⵙⴻⵏ ⵉ-ⵜ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("PS138_7","020_138_7","PSA","138","7","7","ⵎⴰⵍⴰ ⵓⵢⵓⵔⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜᵉⵜⵜⴰⵔⵔⴻⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ. ⵛⴻⴽ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴹⵉⴷⴷ ⵉ ⵡⴻⵖⴹⴰⴱ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS138_8","020_138_8","PSA","138","8","8","ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⴽⴻⵎⵎⴻⵍ ⵉ ⵏⴻⵛⵛ. ⴰ ⵙⵉⴷⵉ, ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ, ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⴻⵏ ⵜⴰⵔⴻⵅⵅⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS139_1","020_139_1","PSA","139","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⵏ ⴷⴰⵡⵓⴷ. ⴰⵣⴻⵀⵀⴻⴷ. ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴱⴻⵇⵇⵛⴻⴷ ⴰⵢⵉ ⵓ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("PS139_2","020_139_2","PSA","139","2","2","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵖⵉⵎⵉ ⵉⵏⵓ ⴷ ⵓⴱⴻⴷⴷⵉ ⵉⵏⵓ, ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵜⴼⴻⵀⵀⵎⴻⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS139_3","020_139_3","PSA","139","3","3","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵖ ⵓ ⵅⵎⵉ ⵟⵟⵚⴻⵖ ⵜⴰⵔⴻⵣⵣⵓⴷ ⴷⴰⵢⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS139_4","020_139_4","PSA","139","4","4","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵅ ⵢⵉⵍⴻⵙ ⵉⵏⵓ, ⵓ ⵅⵣⴰⵔ, ⵛⴻⴽ ⴰ ⵙⵉⴷⵉ, ⵜⴻⵙⵙⵏⴻⴷ ⵜ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PS139_5","020_139_5","PSA","139","5","5","ⵛⴻⴽ ⵜⵃⴻⵚⵚⴰⵔⴻⴷ ⴰⵢⵉ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵓ ⵣⵉ ⵣⵣⴰⵜ, ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵅⴰⴼⵉ ⵜⴰⵍⴻⵇⵇⴰ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS139_6","020_139_6","PSA","139","6","6","ⵜⵓⵙⵙⵏⴰ-ⵢⴰ ⴷ ⴰⵜⴻⴱⵀⴻⵜ ⵉ ⵏⴻⵛⵛ, ⵜⵓⵄⵍⴰ ⵅⴰⴼⵉ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜⵜ ⴰⵡⴹⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS139_7","020_139_7","PSA","139","7","7","ⵖⴰⵔ ⵎⴰⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵔⴰⵃⴻⵖ ⵣⵉ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵛ, ⵖⴰⵔ ⵎⴰⵏⵉ ⵖⴰ ⴰⵔⴻⵡⵍⴻⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PS139_8","020_139_8","PSA","139","8","8","ⵎⴰⵍⴰ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⵛⴻⴽ ⴷⵉⵏⵏⵉ, ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵍⴰⵅⴰⵔⵜ ⴷ ⵜⴰⵙⵙⵓⵜ ⵉⵏⵓ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵛⴻⴽ ⵓⵍⴰ ⴷⵉⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("PS139_9","020_139_9","PSA","139","9","9","ⵎⴰⵍⴰ ⴽⵙⵉⵖ ⴰⴼⵔⵉⵡⴻⵏ ⴰⵎ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ, ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵇⴰⵄ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PS139_10","020_139_10","PSA","139","10","10","ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷⵉⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⵏⴷⴻⵀ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⴰⴷ ⴰⵢⵉ ⵉⵟⵟⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("PS139_11","020_139_11","PSA","139","11","11","ⵎⴰⵍⴰ ⵏⵏⵉⵖ: “ⵉⵡⴰ ⵜⴰⴵⴻⵙⵜ, ⵡⴹⴰ-ⴷⴷ ⵅⴰⴼⵉ, ⵅⴻⵏⵏⵉ ⴵⵉⵍⴻⵜ ⴷ ⵜⴼⴰⵡⵜ ⵉ ⴷ ⴰⵢⵉ ⵉⵇⵓⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS139_12","020_139_12","PSA","139","12","12","ⵉ ⵛⴻⴽ ⵜⴰⴵⴻⵙⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵟⵟⵍⴰⵎ, ⵉ ⵛⴻⴽ ⴵⵉⵍⴻⵜ ⵜᵉⵜⵜⴻⴳⴳ ⵜⴼⴰⵡⵜ ⴰⵎ ⵓⵣⵉⵍ, ⵉ ⵛⴻⴽ ⵜⴰⴵⴻⵙⵜ ⴰⵇⴰ-ⵜⵜ ⴰⵎ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PS139_13","020_139_13","PSA","139","13","13","ⵡⴰⵀ, ⵛⴻⴽ ⵜⵅⴻⵍⵇⴻⴷ-ⴷⴷ ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ, ⵜⵎⵓⴷⴻⴷ ⴰⵢⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("PS139_14","020_139_14","PSA","139","14","14","ⵇⴰⴷⵉⵖ ⵛⴻⴽ ⵓⵎⵉ ⴷⴷ-ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵖ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵍⴻⵄⵊⴻⴱ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵜⴻⵙⵙⴻⵏ ⵜ ⵎⵍⵉⵃ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS139_15","020_139_15","PSA","139","15","15","ⵉⵅⵙⴰⵏ ⵉⵏⵓ ⵜⵓⵖⴰ ⵡⴰⵔ ⵅⴰⴽ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵓⵎⵉ ⵜⵜⵡⴰⴳⴳⴻⵖ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵜⵜⵡⴰⵎⵓⴷⴻⵖ ⴰⵎ ⵉⵊⵊ ⵏ ⵓⴱⵓⵔⴹⴰ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS139_16","020_139_16","PSA","139","16","16","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵥⵔⵉⵏⵜ ⴰⴱⴻⴷⴷⵓ ⵉⵏⵓ ⵉⴹⴻⴼⵚⴻⵏ. ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵢⵓⵔⴰⵏ, ⴰⵇⴰ ⵓⵙⵙⴰⵏ ⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⴳⴳⴻⵏ, ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵍⴰ ⴷ ⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⴱⴻⴷⴷⵓ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS139_17","020_139_17","PSA","139","17","17","ⵎⴰⵎⵎⴻⵛ ⵖⴰⵔⵉ ⵜⵜⵄⵉⵣⵣⴰⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵎⵎⴻⵛ ⵉⵎⵖⴰⵔ ⵓⴱⴰⵔⵔⵓ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS139_18","020_139_18","PSA","139","18","18","ⵎⴰⵍⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵏ ⵃⴻⵙⴱⴻⵖ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴽⵜⴰⵔ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵢⴻⵊⴷⵉ, ⵓ ⵅⵎⵉ ⴼⴰⵇⴻⵖ, ⴰⵇⴰ ⴰⵢⵉ ⵄⴰⴷ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS139_19","020_139_19","PSA","139","19","19","ⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴻⵄⵍⵉⴽ ⵉ ⵖⴰ ⵜⴻⵏⵖⴻⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴻⵄⵍⵉⴽ ⵉ ⵖⴰ ⵜⴻⵊⵊⴻⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵉⵙⵙⴰⵣⵣⴰⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴰⴷ ⵅⴰⴼⵉ ⴰⴳⴳⵯⴻⵊⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS139_20","020_139_20","PSA","139","20","20","ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⵉⵏⴻⵟⵟⵇⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS139_21","020_139_21","PSA","139","21","21","ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⵛⴰⵔⵔⵀⴻⵖ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵓ ⵎⴰ ⵡⴰⵔ ⵜⵜⵄⵉⴼⴼⴻⵖ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵜⵜⴻⵎⵄⴰⵍⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("PS139_22","020_139_22","PSA","139","22","22","ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⵜⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵛⵔⴰⵀ ⵉⴽⵎⴻⵍ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴰⵢⵉ ⴷ ⵍⵄⴻⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS139_23","020_139_23","PSA","139","23","23","ⴰⵔⵣⵓ ⵅⴰⴼⵉ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⵙⴻⵏ ⵓⵍ ⵉⵏⵓ, ⵇⴻⴵⴻⴱ ⴰⵢⵉ ⵓ ⵙⵙⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS139_24","020_139_24","PSA","139","24","24","ⵅⵣⴰⵔ-ⴷⴷ, ⵎⴰ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⵛⴰ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵇⵊⴰⵃⴻⵜ ⵓ ⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PS140_1","020_140_1","PSA","140","1","1","ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PS140_2","020_140_2","PSA","140","2","2","ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⴰ ⵙⵉⴷⵉ, ⵃⴹⴰ ⴰⵢⵉ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⵄⵓⵏⴼ, ");
INSERT INTO rift_vpl VALUES ("PS140_3","020_140_3","PSA","140","3","3","ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⴷⵉ ⵍⵖⴰⵔ, ⵓ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵉⵎⴻⵏⵖⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS140_4","020_140_4","PSA","140","4","4","ⵏⵉⵜⵏⵉ ⵙⵙⵇⴻⴹⵄⴻⵏ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵖⴰⵔ, ⵙⵙⴻⵎ ⵉⵃⵎⴰ ⴰⵇⴰ-ⵜ ⵙⴰⴷⵓ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS140_5","020_140_5","PSA","140","5","5","ⵃⴹⴰ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ, ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵃⴹⴰ ⴰⵢⵉ ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵍⵄⵓⵏⴼ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵢⵉ ⵖⴻⴹⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS140_6","020_140_6","PSA","140","6","6","ⴰⵢⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵅⴰⴼⵉ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ, ⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⵜⵉⵙⴻⵖⵡⵉⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵔⴰⵛⵛⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵓⵎⴻⵙⵔⴰⵇ, ⴰⵇⴰ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⵉ ⵜⵉⵅⴻⴼⵛⵉⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS140_7","020_140_7","PSA","140","7","7","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵙⵉⴷⵉ: “ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!” ⵙⴻⵍ, ⴰ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵓⵜⵔⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS140_8","020_140_8","PSA","140","8","8","ⴰ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵊⵊⴻⵀⴷ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⴷⴻⵍ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("PS140_9","020_140_9","PSA","140","9","9","ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵢⴰⵔⵔ ⵎⴻⵥⵔⵉ. ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵜⵜⴰⵙⵉⵄ ⵉ ⵡⴻⵏⵡⴰⵢ ⵏⵏⴻⵙ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵙⵙⵄⵓⴵⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS140_10","020_140_10","PSA","140","10","10","ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵉⵍⵉ ⴰⴷ ⵜⴻⵏ ⵉⴷⴻⵍ ⵓⵛⴻⵇⵇⴻⴼ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS140_11","020_140_11","PSA","140","11","11","ⴻⵊⵊ ⴰⴷ ⵅⴰⵙⴻⵏ ⴽⴻⴱⴱⴻⵏ ⵍⴻⴼⵃⴻⵎ, ⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵖⴹⴻⵔ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⴷⵉ ⵍⵃⴻⵎⵍⴰⵜ ⵢⵓⴵⵖⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴽⴽⴰⵔⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS140_12","020_140_12","PSA","140","12","12","ⴻⵊⵊ ⴰⵔⵢⴰⵣ ⵉ ⵉⵛⴻⵇⵇⴼⴻⵏ ⵙ ⵢⵉⵍⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴱⴻⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴻⵊⵊ ⴰⴷ ⵉⵄⴰⵔⵏ ⵍⵖⴰⵔ ⴷⴻⵖⵢⴰ ⴰⵔⵢⴰⵣ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS140_13","020_140_13","PSA","140","13","13","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⵇⴼⴻⵍ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵍⵎⵓⵙⴰⴽⵉⵏ, ⵍⵃⴻⵇⵇ ⵏ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PS140_14","020_140_14","PSA","140","14","14","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵇⴰⴷⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS141_1","020_141_1","PSA","141","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵜⵜⵍⴰⵖⵉⵖ ⵖⴰⵔⴻⴽ, ⴷⴻⵖⵢⴰⵜ ⵖⴰⵔⵉ, ⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵅⵎⵉ ⴷⴷ ⵅⴰⴽ ⵉ ⵖⴰ ⵜⵜⵍⴰⵖⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PS141_2","020_141_2","PSA","141","2","2","ⵉⵍⵉ ⴰⴷ ⵜⴱⴻⴷⴷ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ ⴰⵎ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⴰⵙⴳⴻⵄⵄⴻⴷ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PS141_3","020_141_3","PSA","141","3","3","ⴰ ⵙⵉⴷⵉ, ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵃⴹⴰ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS141_4","020_141_4","PSA","141","4","4","ⴻⴳⴳ ⴰⵇⴰ ⵓⵍ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵏⴻⵊⴱⵉⴷ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵙ ⵍⵖⴻⵛⵛ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴻⴳⴳ ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ ⵣⵉ ⵜⴰⵣⵢⵓⴹⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS141_5","020_141_5","PSA","141","5","5","ⴻⵊⵊ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⴰⵢⵉ ⵉⵡⵡⴻⵜ, ⵎⴰⵖⴰⵔ ⴰⵢⴰ ⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵙⴻⴳⴳⴻⴷ ⴰⵢⵉ, ⴰⵢⴰ ⴷ ⵣⵣⴻⵛⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⴰⴷ ⵜⵜ ⵉⵇⴱⴻⵍ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ. ⵡⴰⵀ, ⵓⵍⴰ ⴰⵎⵎⵓ ⴰⴷ ⵜⵉⵍⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ ⵄⴰⴷ ⴹⵉⴷⴷ ⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS141_6","020_141_6","PSA","141","6","6","ⵍⵇⵓⴹⴰⵜ ⵏⵙⴻⵏ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵊⵊⴰⵔⴼ, ⴰⵇⴰ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴹⴰⵔⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS141_7","020_141_7","PSA","141","7","7","ⴰⵅⵎⵉ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵣ ⵓ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵖ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS141_8","020_141_8","PSA","141","8","8","ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ ⵖⴰⵔⴻⴽ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵢⴰⵔⵅⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("PS141_9","020_141_9","PSA","141","9","9","ⵙⵉⴳⴳⵯⴻⵊ ⴰⵢⵉ ⵉ ⵡⴻⵎⵏⴰⵄ ⵏ ⵍⴼⴻⵅ ⵉ ⴷ ⴰⵢⵉ ⵎⴻⴷⵢⴻⵏ, ⵣⵉ ⵜⴻⵅⵛⵉⴼⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS141_10","020_141_10","PSA","141","10","10","ⵉⵍⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵡⴹⴰⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵜⵔⴰⵛⵛⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵖ ⵄⴻⴷⴷⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("PS142_1","020_142_1","PSA","142","1","1","ⴰⵅⴻⵎⵎⵉ ⵏ ⴷⴰⵡⵓⴷ. ⵜⴰⵥⴰⴵⵉⵜ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⴻⴳ ⵢⴻⴼⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS142_2","020_142_2","PSA","142","2","2","ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵙⵖⵓⵢⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵃⴻⵛⵛⵎⴻⵖ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS142_3","020_142_3","PSA","142","3","3","ⵏⴻⵛⵛ ⵜⵜⵣⴻⴵⴰⵄⴻⵖ ⵉⴼⴻⵇⵇⵓⵚⴻⵏ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵙⵙⴰⵔⴳⴱⴻⵖ ⴰⵙ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS142_4","020_142_4","PSA","142","4","4","ⵎⴰⵍⴰ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵉⴷⵇⴻⵍ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵎⴻⵙⵔⵓⵇ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS142_5","020_142_5","PSA","142","5","5","ⵙⵡⴻⴹ ⵖⴰⵔ ⵓⴼⵓⵙⵉ, ⵓ ⵅⵣⴰⵔ, ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵃⴻⴷ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ, ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⴰⵢⵉ ⵇⴰⵄ ⵎⴰⵏⵉ ⵖⴰ ⴰⵔⴻⵡⵍⴻⵖ, ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS142_6","020_142_6","PSA","142","6","6","ⵏⴻⵛⵛ ⵙⵖⵓⵢⵢⵓⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⴰ ⵙⵉⴷⵉ. ⵇⵇⴰⵔⴻⵖ: “ⵛⴻⴽ ⴷ ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ, ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS142_7","020_142_7","PSA","142","7","7","ⵃⴹⴰ ⵅ ⵓⵖⵓⵢⵢⵉ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴼⵏⵉⵖ ⵇⴰⵄ. ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵊⴻⵀⴷⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("PS142_8","020_142_8","PSA","142","8","8","ⵙⵓⴼⴼⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⴻⵃⴱⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⴰⴷⵉⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵏⵏⴹⴻⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴷⴰⵢⵉ ⵙ ⵜⵛⵓⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("PS143_1","020_143_1","PSA","143","1","1","ⴰⵣⴻⵀⵀⴻⴷ ⵏ ⴷⴰⵡⵓⴷ. ⴰ ⵙⵉⴷⵉ, ⵙⴻⵍ ⵉ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ, ⵙⵃⴻⵙⵙ ⵉ ⵜⵓⵜⵔⴰ ⵉⵏⵓ. ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS143_2","020_143_2","PSA","143","2","2","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⵛⵔⴻⵄ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS143_3","020_143_3","PSA","143","3","3","ⵎⵉⵏⵣⵉ ⵍⴻⵄⴷⵓ ⵉⵜⵜⴷⴰⵔⵔⴰⵛ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵉⵄⴻⴼⴼⴻⵙ ⵅ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵙⵙⵣⴻⴷⴷⴻⵖ ⴰⵢⵉ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵟⵟⵍⴰⵎ, ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PS143_4","020_143_4","PSA","143","4","4","ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵉⵜⵜⴻⴼⵛⵉⵍ ⵅⴰⴼⵉ, ⵓⵍ ⵉⵏⵓ ⵢⴰⵔⴻⵡⵡⴻⵄ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS143_5","020_143_5","PSA","143","5","5","ⵏⴻⵛⵛ ⵜⵜⵄⴻⵇⵍⴻⵖ ⵅ ⵡⵓⵙⵙⴰⵏ ⵉⵄⴷⵓⵏ, ⵜⵜⵅⴻⵎⵎⴰⵎⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ, ⵜⵜⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS143_6","020_143_6","PSA","143","6","6","ⵏⴻⵛⵛ ⵜⵜⴱⴻⵣⵣⵄⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵖⴰⵔⴻⴽ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵣⵣⴰⵜⴻⴽ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴼⵓⴷⴻⵏ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS143_7","020_143_7","PSA","143","7","7","ⴰⵔⵔ-ⴷⴷ ⵅⴰⴼⵉ ⴷⴻⵖⵢⴰ, ⴰ ⵙⵉⴷⵉ, ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵉⵜⵜⴻⴼⵛⵉⵍ, ⵡⴰⵔ ⵙⵙⵏⵓⴼⴼⴰⵔⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵣⵣⴰⵢⵉ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵖ ⴰⵎ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PS143_8","020_143_8","PSA","143","8","8","ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵙⵍⴻⵖ ⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⴼⴼⵓⵜ, ⵎⴰⵖⴰⵔ ⵜⵜⴻⵛⵍⴻⵖ ⵅⴰⴽ. ⵙⵛⴻⵏ ⴰⵢⵉ ⴰⴱⵔⵉⴷ ⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PS143_9","020_143_9","PSA","143","9","9","ⴰ ⵙⵉⴷⵉ, ⴽⴽⴻⵙ ⴰⵢⵉ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ, ⵖⴰⵔⴻⴽ ⵉ ⵖⴰ ⴰⵔⴻⵡⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS143_10","020_143_10","PSA","143","10","10","ⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴹⴰ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ⴻⵊⵊ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵛ ⵉⵚⴻⴱⵃⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⵏⴷⴻⵀ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS143_11","020_143_11","PSA","143","11","11","ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ-ⴷⴷ ⴷⴰⵢⵉ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⵙⵓⴼⴼⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PS143_12","020_143_12","PSA","143","12","12","ⴰⵔⴻⴷⴷⴻⴵ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵛ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵇⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS144_1","020_144_1","PSA","144","1","1","ⵏ ⴷⴰⵡⵓⴷ. ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⵜⴰⵚⴹⴰⵔⵜ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵉⴹⴻⵡⴹⴰⵏ ⵉⵏⵓ ⵉ ⵍⵃⴰⵔⴱ. ");
INSERT INTO rift_vpl VALUES ("PS144_2","020_144_2","PSA","144","2","2","ⵛⴻⴽ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⴵⵉⴷ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ ⵉ ⴷⴰⵢⴻⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ, ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⵢⵓⵄⵍⴰⵏ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵉ ⵓⵙⴻⵍⵇⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴰⵔⴻⴽⴽⵡⴰⵍⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵡⴰⴹⴹⵄⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PS144_3","020_144_3","PSA","144","3","3","ⴰ ⵙⵉⴷⵉ, ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜ ⵜⴻⵙⵙⵏⴻⴷ? ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵅⴰⵔⵔⵉⵚⴻⴷ ⴷⴰⵢⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PS144_4","020_144_4","PSA","144","4","4","ⴱⵏⴰⴷⴻⵎ ⴰⵎⴻⵛⵏⴰⵡ ⵍⴻⴼⵡⴰⵔ, ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵄⴷⵓⵏ ⴰⵎ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PS144_5","020_144_5","PSA","144","5","5","ⵎⴻⵢⵢⴻⵍ ⵉⵊⴻⵏⵡⴰⵏ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵀⵡⴰ-ⴷⴷ. ⵃⴰⴷⴰ ⵉⴷⵓⵔⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⴷⴷⴻⵅⵅⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS144_6","020_144_6","PSA","144","6","6","ⵥⴰⵔⵢⴻⴹ ⴰⵙⵙⴰⵎⴻⵏ ⵓ ⵣⴻⴵⴻⵄ ⵉ-ⵜⴻⵏ, ⵙⴻⴽⴽ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵛ ⵓ ⵙⵅⴰⵔⵡⴻⴹ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS144_7","020_144_7","PSA","144","7","7","ⵙⵡⵉⵥⵥⴻⴹ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ-ⴷⴷ ⵓ ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⵉ ⵍⵃⴻⵎⵍⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS144_8","020_144_8","PSA","144","8","8","ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵉⵇⵇⴰⵔ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⴼⵓⵙ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵛⵛⵓⵔ ⵙ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS144_9","020_144_9","PSA","144","9","9","ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⴰⵛ ⵖⴻⵏⵏⵊⴻⵖ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⴷ ⵏ ⵊⴷⵉⴷ ⵉ ⵛⴻⴽ, ⵙ ⵍⵀⴰⵔⴱⴰ ⵓ ⵙ ⵍⵄⵓⴷ ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⵉⵍⴰⵏ ⴰⴷ ⴰⵛ ⵣⴻⵀⵀⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS144_10","020_144_10","PSA","144","10","10","ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⴹⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵉⵊⴻⵊⴵⵉⴷⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⴰⵡⵓⴷ ⵣⵉ ⵙⵙⵉⴼ ⴰⵄⴻⴼⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PS144_11","020_144_11","PSA","144","11","11","ⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ-ⴷⴷ ⵓ ⴼⴻⴽⴽ ⴰⵢⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵇⴻⵎⵎⵓⵎ ⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵎⵖⵉⵔ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵓ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵉⵛⵛⵓⵔ ⵙ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PS144_12","020_144_12","PSA","144","12","12","ⵎⴻⵄⵍⵉⴽ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵢⵉⵖⴻⴷⴷⵉⵡⴻⵏ, ⵉⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵄⴰⴷ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵙⴻⵏ, ⵢⴻⵙⵙⵉⵜⵏⴻⵖ ⴰⵎ ⵜⵖⴻⵎⵎⴰⵔ ⵉ ⴳⴳⵉⵏ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⵔⵛⴰⵎⴻⵏ, ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⵉ ⵢⵉⵛⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS144_13","020_144_13","PSA","144","13","13","ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵍⴻⵀⵔⵉⵜ ⵏⵏⴻⵖ, ⴰⴷ ⵡⵛⴻⵏ ⵣⵣⴰⴷ ⴰⵡⴰⵔⵏⵉ ⵣⵣⴰⴷ, ⴰⴷ ⵢⴰⵔⵏⵉ ⵡⵓⴵⵉ ⵏⵏⴻⵖ ⵙ ⵍⵓⵍⵓⴼ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⴷⵉ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS144_14","020_144_14","PSA","144","14","14","ⴰⴷ ⵃⴻⵎⵍⴻⵏ ⵉⵎⵡⴰⵏ ⵏⵏⴻⵖ ⵎⵍⵉⵃ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵓⵀⵊⴰⵎ ⵏⵉⵖ ⴷ ⵓⴼⴼⵓⵖ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓⵍⴰ ⴷ ⵉⵖⵓⵢⵢⴰⵏ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PS144_15","020_144_15","PSA","144","15","15","ⵙⵙⴻⵄⴷ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎⵢⴰ. ⵙⵙⴻⵄⴷ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS145_1","020_145_1","PSA","145","1","1","ⵉⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵏ ⴷⴰⵡⵓⴷ. ⴰⵍⵉⴼ. ⴰ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵄⵓⴵⴻⵖ, ⴰⴷ ⴱⴰⵔⴽⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS145_2","020_145_2","PSA","145","2","2","ⴱⵉⵜ. ⴽⵓⵍ ⴰⵙⵙ ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵖ, ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS145_3","020_145_3","PSA","145","3","3","ⴳⵉⵎⴻⵍ. ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵙⴷⵉⵀⴻⴵ ⴰⵙⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵜⴰⵔⴻⵣⵣⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PS145_4","020_145_4","PSA","145","4","4","ⴷⴰⵍⵉⵜ. ⵊⵊⵉⵍ ⴰⵡⴰⵔⵏⵉ ⵊⵊⵉⵍ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_5","020_145_5","PSA","145","5","5","ⵀⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵛ, ⵅ ⵍⴻⵅⴱⴰⵔ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS145_6","020_145_6","PSA","145","6","6","ⵡⴰⵡ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵊⵊⵀⴻⴷ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS145_7","020_145_7","PSA","145","7","7","ⵣⴰⵢⵉⵏ. ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵛ ⵉⴼⴻⵢⵢⴹⴻⵏ ⴰⴷ ⵜⵜ ⴳⴳⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵉⵜⵜⵛⵓⵔⵛⵓⵔ, ⴰⴷ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵉ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PS145_8","020_145_8","PSA","145","8","8","ⵅⵉⵜ. ⵙⵉⴷⵉ ⴷ ⴰⵔⵃⵉⵎ ⴷ ⴰⵃⵏⵉⵏ, ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_9","020_145_9","PSA","145","9","9","ⵜⵉⵜ. ⵙⵉⴷⵉ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵎⴰⵔⵔⴰ, ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⵜⵉⵡⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS145_10","020_145_10","PSA","145","10","10","ⵢⵓⴷ. ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵛⴻⴽ ⵇⴰⴷⵉⵏⵜ, ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⴱⴰⵔⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_11","020_145_11","PSA","145","11","11","ⴽⴰⴼ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵓⵄⵓⴵⵉ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵅ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("PS145_12","020_145_12","PSA","145","12","12","ⵍⴰⵎⵉⴷ. ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙ ⵓⵄⵓⴵⵉ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS145_13","020_145_13","PSA","145","13","13","ⵎⵉⵎ. ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⴽⵓⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS145_14","020_145_14","PSA","145","14","14","ⵙⴰⵎⵉⵅ. ⵙⵉⴷⵉ ⵉⵜⵜⵙⴻⵏⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ, ⵉⵜⵜⵙⴻⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵇⵡⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_15","020_145_15","PSA","145","15","15","ⵄⴰⵢⵉⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵜⵜⵔⴰⵊⴰⵏⵜ ⵛⴻⴽ, ⵛⴻⴽ ⵜᵉⵜⵜⵉⵛⴻⴷ ⴰⵙⴻⵏ ⵎⴰⵛⵛⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_16","020_145_16","PSA","145","16","16","ⴱⵉ. ⵛⴻⴽ ⵜⴰⵔⴻⵣⵣⵎⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ, ⵜⴻⵙⵙⵢⴰⵡⴰⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵅⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_17","020_145_17","PSA","145","17","17","ⵜⵙⴰⴷⵉ. ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⵏⵉⵛⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵜⵜⴻⴳⴳ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS145_18","020_145_18","PSA","145","18","18","ⵇⵓⴼ. ⵙⵉⴷⵉ ⵢⵓⴷⴻⵙ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⵍⴰⵖⴰⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⵍⴰⵖⴰⵏ ⴷⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PS145_19","020_145_19","PSA","145","19","19","ⵔⵉⵅ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴷⴻⵏ, ⵉⵜⵜⴻⵙⵍⴰ ⵉⵖⵓⵢⵢⴰⵏ ⵏⵙⴻⵏ ⵓ ⵉⵙⵙⴻⵏⵊⴰⵎ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_20","020_145_20","PSA","145","20","20","ⵛⵉⵏ. ⵙⵉⴷⵉ ⵉⵃⴻⵟⵟⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⴻⵃⵃⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS145_21","020_145_21","PSA","145","21","21","ⵜⴰⴼ. ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵓⵚⴻⴱⴱⴻⵃ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PS146_1","020_146_1","PSA","146","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ. ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵚⴻⴱⴱⴻⵃ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PS146_2","020_146_2","PSA","146","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵖ ⵉ ⵙⵉⴷⵉ ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵖ ⴷⴷⴰⵔⴻⵖ, ⴰⴷ ⵣⴻⵀⵀⴷⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵎⵉⵏ ⴷⴰ ⵖⴰ ⴽⴽⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PS146_3","020_146_3","PSA","146","3","3","ⵡⴰⵔ ⵜⵛⴻⵍ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵅ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⴱⵓ ⵓⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS146_4","020_146_4","PSA","146","4","4","ⵉⴼⴼⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵇⴹⴰⵏ ⵉⵏⵡⴰⵢⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS146_5","020_146_5","PSA","146","5","5","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⴰⵎⵄⴰⵡⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS146_6","020_146_6","PSA","146","6","6","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PS146_7","020_146_7","PSA","146","7","7","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵖⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵚⵚⴰⵔⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ. ⵙⵉⴷⵉ ⵢⴰⵔⴻⵅⵅⵓ ⵉ ⵉⵎⴻⵃⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS146_8","020_146_8","PSA","146","8","8","ⵙⵉⴷⵉ ⵢⴰⵔⴻⵣⵣⴻⵎ ⵉ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵉⵙⵙⴱⴻⴷⴷⴰ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵉⵜⵜⴻⵇⵡⵉⵙⴻⵏ, ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS146_9","020_146_9","PSA","146","9","9","ⵙⵉⴷⵉ ⵉⵃⴻⵟⵟⴰ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵉⵜⵜⵉⵛ ⴰⴼⵓⵙ ⵉ ⵓⵢⵓⵊⵉⵍ ⴷ ⵜⵉⵊⵊⴰⵍ, ⵎⴰⵛⴰ ⴰⴱⵔⵉⴷ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜ ⵉⵙⵙⴼⴰⵔⵖ. ");
INSERT INTO rift_vpl VALUES ("PS146_10","020_146_10","PSA","146","10","10","ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰ ⵚⵉⵀⵢⵓⵏ, ⵉⵃⴻⴽⴽⴻⵎ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS147_1","020_147_1","PSA","147","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ, ⵎⴰⵖⴰⵔ ⴰⵣⴻⵀⵀⴻⴷ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴰⵙ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⴰⴷ ⴰⵙ ⵏⵚⴻⴱⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PS147_2","020_147_2","PSA","147","2","2","ⵙⵉⴷⵉ ⵉⴱⴻⵏⵏⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵙⵙⵎⵓⵏ ⵉⵎⵎⴻⵏⴻⵄⵔⴰⵇ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PS147_3","020_147_3","PSA","147","3","3","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵓⵍ ⵢⴰⵔⵥⴻⵏ, ⵉⵜⵜⵛⴻⴷⴷⴰ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵙⴻⵏ ⵉⵜⵜⴻⵇⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS147_4","020_147_4","PSA","147","4","4","ⵉⵃⴻⵙⵙⴻⴱ ⵇⴻⴷⴷⴰ ⵏ ⵉⵜⵔⴰⵏ, ⵉⵜⵜⵍⴰⵖⴰ ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵢⵉⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS147_5","020_147_5","PSA","147","5","5","ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔ. ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS147_6","020_147_6","PSA","147","6","6","ⵙⵉⴷⵉ ⵉⵜⵜⵙⴻⵏⵏⴻⴷ ⵉⵎⵡⴰⴹⵄⴻⵏ, ⵉⵙⵙⵀⴻⴽⴽⵡⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PS147_7","020_147_7","PSA","147","7","7","ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ ⵙ ⵓⵖⴻⵏⵏⴻⵊ, ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵙ ⵍⴳⴰⵎⴱⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PS147_8","020_147_8","PSA","147","8","8","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵍⴻⵏ ⴰⵊⴻⵏⵏⴰ ⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵡⵊⴰⴷⴻⵏ ⴰⵏⵥⴰⵔ ⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵖⴻⵎⵎⴰⵢⴻⵏ ⴰⵔⴱⵉⵄ ⵅ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PS147_9","020_147_9","PSA","147","9","9","ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵉ ⵍⵎⴰⵍ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⴰⵖⵍⵉⵡⴻⵏ ⵅⵎⵉ ⵖⴰ ⵙⵖⵓⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS147_10","020_147_10","PSA","147","10","10","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵟⵟⵉ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵓⵢⵉⵙ, ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⴻⵄⵊⵉⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS147_11","020_147_11","PSA","147","11","11","ⵢⴰⵔⴻⵟⵟⴰ ⴰⵙ ⵉ ⵙⵉⴷⵉ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵉⵜⵎⴻⵏ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS147_12","020_147_12","PSA","147","12","12","ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵚⴻⴱⴱⴻⵃ ⵉ ⵙⵉⴷⵉ, ⴰ ⵚⵉⵀⵢⵓⵏ, ⵚⴻⴱⴱⴻⵃ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PS147_13","020_147_13","PSA","147","13","13","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵎⵃⴻⴷ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⵉⴱⴰⵔⴻⴽ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PS147_14","020_147_14","PSA","147","14","14","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵍⴻⵀⵏⴰ ⵉ ⵉⵢⵎⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵙⵙⵊⵉⵡⴻⵏ ⵉ ⵛⴻⴽ ⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵇⴰⵄ ⵏ ⵢⵉⵔⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS147_15","020_147_15","PSA","147","15","15","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽⴰ ⵜⵉⵡⴰⵍⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵉⵜⵜⴰⵣⵣⴻⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PS147_16","020_147_16","PSA","147","16","16","ⵉⵜⵜⵉⵛ ⴰⴷⴼⴻⵍ ⴰⵎ ⵜⴹⵓⴼⵜ, ⵉⵣⵣⵓⵣⴰⵔⴰ ⵏⵏⴷⴰ ⵉⴳⴻⵔⵙⴻⵏ ⴰⵎ ⵢⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("PS147_17","020_147_17","PSA","147","17","17","ⵉⵙⵙⴻⴽⴽⴰ ⴰⴷⴼⴻⵍ ⵏⵏⴻⵙ ⴷ ⵉⴱⵇⵓⵇⴻⵏ, ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⴻⵙⵎⵓⴹⵉ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PS147_18","020_147_18","PSA","147","18","18","ⵉⵙⵙⴻⴽⴽⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⴼⴻⵙⵢⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵊⵊⴰ ⴰⵙⴻⵎⵎⵉⴹ ⵏⵏⴻⵙ ⵉⵜⵜⵙⵓⴹ, ⵅⴻⵏⵏⵉ ⵜⵜⵓⵛⵔⵓⵔⴻⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS147_19","020_147_19","PSA","147","19","19","ⵏⴻⵜⵜⴰ ⵉⴱⴰⵔⵔⴻⵃ ⵉ ⵢⴰⵄⵇⵓⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵉ ⵉⵙⵔⴰⵉⵍ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS147_20","020_147_20","PSA","147","20","20","ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⴳⴳⵉ ⴰⵎⵎⵓ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PS148_1","020_148_1","PSA","148","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ⵚⴻⴱⴱⵃⴻⵎ ⵉ ⵙⵉⴷⵉ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵚⴻⴱⴱⵃⴻⵎ ⵜ ⴷⵉ ⵍⵓⵄⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PS148_2","020_148_2","PSA","148","2","2","ⵚⴻⴱⴱⵃⴻⵎ ⵜ, ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ! ⵚⴻⴱⴱⵃⴻⵎ ⵜ, ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PS148_3","020_148_3","PSA","148","3","3","ⵚⴻⴱⴱⵃⴻⵏⵜ ⵜ, ⵜⴰⴼⵓⵛⵜ ⴷ ⵜⵣⵉⵔⵉ! ⵚⴻⴱⴱⵃⴻⵎ ⵜ, ⵎⴰⵔⵔⴰ ⵉⵜⵔⴰⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS148_4","020_148_4","PSA","148","4","4","ⵚⴻⴱⴱⵃⴻⵜ, ⴰⵊⴻⵏⵏⴰ ⵅ ⵉⵊⴻⵏⵡⴰⵏ, ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵜⵉⵡⴰ ⵉ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PS148_5","020_148_5","PSA","148","5","5","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵓ ⴰⵎⵎⵓ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PS148_6","020_148_6","PSA","148","6","6","ⵏⴻⵜⵜⴰ ⵉⴷⴻⴽⴽⴻⵏ ⵉ-ⵜⴻⵏ ⴷⵉⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜ ⵄⴻⴷⴷⴰⵏ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("PS148_7","020_148_7","PSA","148","7","7","ⵚⴻⴱⴱⵃⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴽⴻⵏⵏⵉⵡ ⵍⵀⴰⵢⵛⴰⵜ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS148_8","020_148_8","PSA","148","8","8","ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵜⴻⴱⵔⵓⵔⵔⵉ ⴷ ⵡⴻⴷⴼⴻⵍ ⴷ ⴷⴷⴻⵅⵅⴰⵏ, ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PS148_9","020_148_9","PSA","148","9","9","ⵉⴷⵓⵔⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵔⵉⵏ, ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⴼⵔⵓⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ");
INSERT INTO rift_vpl VALUES ("PS148_10","020_148_10","PSA","148","10","10","ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵔ, ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ ⴷ ⵉⵊⴹⴰⴹ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS148_11","020_148_11","PSA","148","11","11","ⴽⴻⵏⵏⵉⵡ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵛⵛⵓⵄⵓⴱ, ⴽⴻⵏⵏⵉⵡ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⵇⵓⴹⴰⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("PS148_12","020_148_12","PSA","148","12","12","ⵉⴱⵍⵉⵖⴻⵏ ⵓⵍⴰ ⴷ ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ, ⵉⵡⴻⵙⵙⵓⵔⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PS148_13","020_148_13","PSA","148","13","13","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵡⴰⵀⴰ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ, ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵙ ⵜⴰⵍⴻⵇⵇ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PS148_14","020_148_14","PSA","148","14","14","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵛⵛ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⵚⴻⴱⴱⴻⵃ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ, ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏ ⵍⴳⴻⵏⵙ ⵉ ⴷⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PS149_1","020_149_1","PSA","149","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ⵖⴻⵏⵏⵊⴻⵎ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵊⴷⵉⴷ ⵉ ⵙⵉⴷⵉ, ⵙⵄⵓⴵⴻⵎ ⵜ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PS149_2","020_149_2","PSA","149","2","2","ⴰⴷ ⵉⴼⴰⵔⵃ ⵉⵙⵔⴰⵉⵍ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⴰⴷ ⴰⵔⵛⵇⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⵉⵀⵢⵓⵏ ⵙ ⵓⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PS149_3","020_149_3","PSA","149","3","3","ⴰⴷ ⵚⴻⴱⴱⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵙ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⴰⴷ ⴰⵙ ⵣⴻⵀⵀⴷⴻⵏ ⵙ ⵓⴱⴻⵏⴷⵉⵔ ⴷ ⵍⴳⴰⵎⴱⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("PS149_4","020_149_4","PSA","149","4","4","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵢⴰⵔⴹⴰ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵢⴰⵡⵉ ⵛⵛⴰⵏ ⵉ ⵉⵎⵡⴰⴹⵄⴻⵏ ⵙ ⵡⴻⵏⵊⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PS149_5","020_149_5","PSA","149","5","5","ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⵢⵓⴵⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏⵙⴻⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PS149_6","020_149_6","PSA","149","6","6","ⵉⵣⵍⴰⵏ ⵏ ⵓⵄⵓⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵉⵇⴹⴻⵄ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PS149_7","020_149_7","PSA","149","7","7","ⵃⵉⵎⴰ ⴰⴷ ⵏⵜⴰⵇⵎⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴰⵇⴱⴻⵏ ⵛⵛⵓⵄⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("PS149_8","020_149_8","PSA","149","8","8","ⵃⵉⵎⴰ ⴰⴷ ⵛⴰⵔⴼⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ, ⴰⵢⵜ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏⵙⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵡⵓⵣⵣⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("PS149_9","020_149_9","PSA","149","9","9","ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⴳⴳⴻⵏ ⵍⵃⵓⴽⵎ ⵢⵓⵔⴰⵏ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵄⴰⴹⴰⵎⴰ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵏⵏⴻⵙ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PS150_1","020_150_1","PSA","150","1","1","ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ, ⵚⴻⴱⴱⵃⴻⵎ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵚⴻⴱⴱⵃⴻⵎ ⵜ ⴷⵉ ⵍⴽⵓⴱⴱⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PS150_2","020_150_2","PSA","150","2","2","ⵚⴻⴱⴱⵃⴻⵎ ⵜ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵚⴻⴱⴱⵃⴻⵎ ⵜ ⵅ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ! ");
INSERT INTO rift_vpl VALUES ("PS150_3","020_150_3","PSA","150","3","3","ⵚⴻⴱⴱⵃⴻⵎ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵚⴻⴱⴱⵃⴻⵎ ⵙ ⵍⵀⴰⵔⴱⴰ ⴷ ⵍⴳⴰⵎⴱⵔⵉ! ");
INSERT INTO rift_vpl VALUES ("PS150_4","020_150_4","PSA","150","4","4","ⵚⴻⴱⴱⵃⴻⵎ ⵜ ⵙ ⵓⴱⴻⵏⴷⵉⵔ ⴷ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵚⴻⴱⴱⵃⴻⵎ ⵜ ⵙ ⵜⵉⵔⴰⵔⵜ ⵏ ⵉⴼⵉⵍⴰⵏ ⴷ ⵜⴻⵎⵊⴰ! ");
INSERT INTO rift_vpl VALUES ("PS150_5","020_150_5","PSA","150","5","5","ⵚⴻⴱⴱⵃⴻⵎ ⴰⵙ ⵙ ⵍⵃⴻⵙⵙ ⵉⴼⵙⵓⵙⴻⵏ ⵏ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵚⴻⴱⴱⵃⴻⵎ ⴰⵙ ⵙ ⵍⵃⴻⵙⵙ ⵢⵓⵄⵍⴰⵏ ⵏ ⵜⴻⴵⵓⵏⵉⵏ ⵏ ⵡⵓⵣⵣⴰⵍ! ");
INSERT INTO rift_vpl VALUES ("PS150_6","020_150_6","PSA","150","6","6","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵏⵏⴻⴼⵙ, ⵚⴻⴱⴱⴻⵃ ⵉ ⵙⵉⴷⵉ. ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("PR1_1","021_1_1","PRO","1","1","1","ⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("PR1_2","021_1_2","PRO","1","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵉⵖⵉⵜ ⴷ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⵀⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR1_3","021_1_3","PRO","1","3","3","ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴱⴻⵍ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⴷ ⵍⴻⵄⵇⴻⵍ, ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ ⴷ ⵍⴻⵚⴼⴰⵢⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR1_4","021_1_4","PRO","1","4","4","ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⴰⵙⴼⴰⵔⵣ ⵉ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ, ⵜⵓⵙⵙⵏⴰ ⴷ ⵓⵃⴰⴷⵓⵔ ⵉ ⵓⵃⵓⴷⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PR1_5","021_1_5","PRO","1","5","5","ⴻⵊⵊ ⴰⵎⵉⵖⵉⵙ ⴰⴷ ⵉⵙⴻⵍ ⵓ ⴰⴷ ⵢⴰⵔⵏⵉ ⴷⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵀⵀⵎⴻⵏ ⴰⴷ ⵉⴽⵙⴻⴱ ⵍⴻⵇⵏⴰⵄⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR1_6","021_1_6","PRO","1","6","6","ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⵀⴻⵎ ⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⴷ ⵍⵎⴰⵜⴰⵍ, ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR1_7","021_1_7","PRO","1","7","7","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵜⵉⵖⵉⵜ ⴷ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR1_8","021_1_8","PRO","1","8","8","ⵙⴻⵍ, ⴰ ⵎⵎⵉ, ⵖⴰⵔ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵛ, ⵡⴰⵔ ⵜⵜⴰⴳⵉ ⵛⴰ ⵜⴰⵖⵓⵔⵉ ⵏ ⵢⴻⵎⵎⴰⵛ, ");
INSERT INTO rift_vpl VALUES ("PR1_9","021_1_9","PRO","1","9","9","ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵜⵜⴰⵊ ⵉⵛⵏⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ, ⴷ ⵜⵙⴻⴷⴷⵢⵉⵏ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵉ ⵢⵉⵔⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR1_10","021_1_10","PRO","1","10","10","ⴰ ⵎⵎⵉ, ⵎⴰⵍⴰ ⵅⵙⴻⵏ ⵉⵎⴻⴷⵏⴰⴱ ⴰⴷ ⵛⴻⴽ ⵖⵡⴰⵏ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⴻⴳⴳ ⵛⴰ ⴰⵔⵔⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("PR1_11","021_1_11","PRO","1","11","11","ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: “ⵓⵢⵓⵔ ⴰⴽⵉⴷⵏⴻⵖ, ⴻⵊⵊ ⴰⴷ ⵏⵃⴰⵎⴰ ⵉ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵉ ⵓⵎⴻⵣⴷⴰⴳ, ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR1_12","021_1_12","PRO","1","12","12","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⵚⴰⵔⴹ ⴰⵎ ⴷⴷⴰⵔⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵚⴰⵔⴻⴹ ⵍⴰⵅⴰⵔⵜ, ⴰⵎ ⴽⴻⵎⵍⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵙⴰⵔ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR1_13","021_1_13","PRO","1","13","13","ⴰⴷ ⵏⴰⴼ ⵄⵍⴰⵎⴽⵓⵔ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵢⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ, ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ ⴰⴷ ⵜⴻⵏⵜ ⵏⴻⵛⵛⵓⵔ ⵙ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("PR1_14","021_1_14","PRO","1","14","14","ⵛⴻⴽ ⴰⴷ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵏⵏⴻⵛ ⵊⴰⵔ ⴰⵏⴻⵖ, ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵉⵛⵜ ⵏ ⵜⴻⵛⵢⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("PR1_15","021_1_15","PRO","1","15","15","ⴰ ⵎⵎⵉ, ⵡⴰⵔ ⴽⵉⴷⵙⴻⵏ ⴳⴳⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵙⵉⴳⴳⵯⴻⵊ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵅ ⵓⵎⴻⵙⵔⵓⵇ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR1_16","021_1_16","PRO","1","16","16","ⵎⴰⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔ, ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR1_17","021_1_17","PRO","1","17","17","ⵎⴰⵖⴰⵔ ⵙ ⵍⴱⴰⵟⴻⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴻⵣⵣⴻⵄ ⵜⵔⴰⵛⵛⴰ, ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴼⵔⵉⵡⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR1_18","021_1_18","PRO","1","18","18","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⵃⴰⵎⴰⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵜⵜⴻⴳⴳⴻⵏ ⵍⴼⴻⵅ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR1_19","021_1_19","PRO","1","19","19","ⴰⵎⵎⵓ ⵉ ⵉⴵⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⴰⵔⴱⴻⵃ, ⴰⵇⴰ ⴰⵢⴰ ⵉⵜⵜⴻⵟⵟⴻⴼ ⵍⴻⵄⵎⴰⵔ ⵏ ⵙⵉⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR1_20","021_1_20","PRO","1","20","20","ⵜⵉⵖⵉⵜ ⵜᵉⵜⵜⵍⴰⵖⴰ ⵙ ⵊⵊⵀⴻⴷ ⴷⵉⵀⴰ ⴱⴰⵔⵔⴰ, ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR1_21","021_1_21","PRO","1","21","21","ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵏ ⵉⵎⵓⵛⴰⵏ ⵉ ⴷⴰⵢⵙⴻⵏ ⵍⵀⴰⵔⴰⵊ, ⵜᵉⵜⵜⴱⴰⵔⵔⴰⵃ ⵏⴻⵜⵜⴰⵜ, ⵖⴰⵔ ⵡⴰⴷⴰⴼⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴻⵙⵙⴰⵡⴰⵍ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR1_22","021_1_22","PRO","1","22","22","“ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ ⵜⵜⴻⵅⵙⴻⵏ ⵜⴰⵇⵓⴱⴱⴰⵏⴻⵛⵜ, ⴰⵍ ⵎⴻⵍⵎⵉ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵄⵊⴻⴱ ⵓⵃⴻⵛⵛⵉ ⵉ ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ, ⵓ ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵛⴰⵔⵀⴻⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵜⵓⵙⵙⵏⴰ? ");
INSERT INTO rift_vpl VALUES ("PR1_23","021_1_23","PRO","1","23","23","ⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵓⵡⴻⴱⴱⴻⵅ ⵉⵏⵓ! ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⴼⴰⵔⵔⵖⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴰⴷ ⴰⵡⴻⵎ ⵜⴻⵏ ⵄⴻⵍⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("PR1_24","021_1_24","PRO","1","24","24","“ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⵍⴰⵖⵉⵖ ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵅⵙⴻⵎ, ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵏⴻⵛⵛ ⴰⴼⵓⵙ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵃⴻⴽⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR1_25","021_1_25","PRO","1","25","25","ⵜⴻⵏⴹⴰⵔⴻⵎ ⵛⵛⵡⴰⵔ ⵉⵏⵓ, ⴰⵡⴻⴱⴱⴻⵅ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵜⴻⵇⴱⵉⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR1_26","021_1_26","PRO","1","26","26","ⵙ ⵓⵢⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴹⴻⵃⵛⴻⵖ ⵅ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵡⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵙⵜⴻⵀⵣⴻⵖ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵏⴻⵅⵍⵉⵄ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("PR1_27","021_1_27","PRO","1","27","27","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵏⴻⵅⵍⵉⵄ ⵏⵡⴻⵎ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵔⴻⴷⴷⴻⴵ, ⴰⴹⴻⵢⵢⴻⵄ ⵏⵡⴻⵎ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⵅⵎⵉ ⵅⴰⵡⴻⵎ ⴷⴷ ⵖⴰ ⵜⴻⵡⴹⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⵜⴻⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR1_28","021_1_28","PRO","1","28","28","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵍⴰⵖⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉⵖ, ⴰⴷ ⵅⴰⴼⵉ ⴰⵔⵣⵓⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵉⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR1_29","021_1_29","PRO","1","29","29","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵛⴰⵔⵀⴻⵏ ⵜⵓⵙⵙⵏⴰ, ⵓ ⵡⴰⵔ ⵉⵅⴹⴰⵔⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR1_30","021_1_30","PRO","1","30","30","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⵛⴰ ⵍⴻⵛⵡⴰⵔ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⴰⵡⴻⴱⴱⴻⵅ ⵉⵏⵓ ⵏⴹⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR1_31","021_1_31","PRO","1","31","31","ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ, ⵓ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR1_32","021_1_32","PRO","1","32","32","ⵎⵉⵏⵣⵉ ⵓⴼⴼⵓⵖ ⵏ ⵉⵃⴰⴼⴻⵢⵢⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ, ⵓ ⴰⴼⵍⴰⵃ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR1_33","021_1_33","PRO","1","33","33","ⵡⵉ ⵖⴰⵔⵉ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ, ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷⵉ ⵍⴻⵀⵏⴰ ⴱⵍⴰ ⴰⵏⴻⵅⵍⵉⵄ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("PR2_1","021_2_1","PRO","2","1","1","ⵎⵎⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵜⵇⴻⴱⵍⴻⴷ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵖⴰⵔⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("PR2_2","021_2_2","PRO","2","2","2","ⵎⴰⵃⴻⵏⴷ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⴰⴷ ⵉⵡⵛ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵉⵖⵉⵜ ⵓⵛⴰ ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR2_3","021_2_3","PRO","2","3","3","ⵡⴰⵀ, ⵎⴰⵍⴰ ⵜᵉⵜⵜⵍⴰⵖⵉⴷ-ⴷⴷ ⵅ ⵍⴻⵄⵇⴻⵍ, ⴰⴷ ⵜⴻⵙⵙⵅⴻⴷⵎⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⴼⴻⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR2_4","021_2_4","PRO","2","4","4","ⵎⴰⵍⴰ ⵜⴰⵔⴻⵣⵣⵓⴷ ⵅⴰⵙ ⴰⵎ ⵜⴰⵔⴻⵣⵣⵓⴷ ⵅ ⵏⵏⵓⵇⴰⵔⵜ, ⵎⴰⵍⴰ ⵅⴰⵙ ⵜⴰⵔⴻⵣⵣⵓⴷ ⴰⵎ ⵅ ⵜⵅⵓⴱⴰⵢ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("PR2_5","021_2_5","PRO","2","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴼⴻⵀⵎⴻⴷ ⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ, ⵓ ⴰⴷ ⵜⴰⴼⴻⴷ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PR2_6","021_2_6","PRO","2","6","6","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵜⵜⵉⵛ ⵜⵉⵖⵉⵜ, ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜᵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR2_7","021_2_7","PRO","2","7","7","ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵙⴻⵏ ⵜⵡⵉⵣⴰ, ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⴽⵎⴰⵔⴻⵜ ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉ ⵓⵙⴻⵍⵇⵉ, ");
INSERT INTO rift_vpl VALUES ("PR2_8","021_2_8","PRO","2","8","8","ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵍⵃⴻⵇⵇ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴰⵔ ⴰⴱⵔⵉⴷ ⵏ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵍⴰⵎⴰⵏ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR2_9","021_2_9","PRO","2","9","9","ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴼⴻⵀⵎⴻⴷ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ, ⵓⵍⴰ ⴷ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⴽⵓⵍ ⵍⴰⵜⴰⵔ ⵉⵚⴻⴱⵃⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⴹⴼⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR2_10","021_2_10","PRO","2","10","10","ⵎⴰⵖⴰⵔ ⵜⵉⵖⵉⵜ ⴰⴷ ⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵓ ⵜⵓⵙⵙⵏⴰ ⴰⴷ ⵜⴰⵔⴹⴰ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR2_11","021_2_11","PRO","2","11","11","ⴰⵃⴰⴷⵓⵔ ⴰⴷ ⵅⴰⴽ ⵉⵃⴹⴰ, ⵍⴻⴼⵀⴰⵎⴻⵜ ⴰⴷ ⵅⴰⴽ ⵜⴻⵙⵙⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("PR2_12","021_2_12","PRO","2","12","12","... ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵜⴼⴻⴽⴽ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵇⴻⴵⴱⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR2_13","021_2_13","PRO","2","13","13","ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵙⴻⵎⵃⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵙⵔⴰⵇ ⵉⵙⴻⴳⴳⵎⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵟⵟⵍⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("PR2_14","021_2_14","PRO","2","14","14","ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵓ ⵙⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵅ ⵍⴻⵅⴷⴰⵄⴰⵜ ⵏ ⵍⵖⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PR2_15","021_2_15","PRO","2","15","15","ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⴼⴰⵔⵖⴻⵏ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵢⵢⵍⴻⵏ ⵙⵙⴰ ⴷ ⵙⵙⴰ ⴷⵉ ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR2_16","021_2_16","PRO","2","16","16","... ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵜⴼⴻⴽⴽ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴱⴰⵔⵔⴰⵏⴻⵛⵜ, ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⴱⴰⵔⵔⴰ ⵉ ⵉⵜⵜⵖⴰⵔⵔⴰⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR2_17","021_2_17","PRO","2","17","17","ⵜⴻⵏⵏⵉ ⵉⵙⴻⵎⵃⴻⵏ ⴷⴻⴳ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ, ⵓ ⵜᵉⵜⵜⵓ ⵍⵄⴰⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR2_18","021_2_18","PRO","2","18","18","ⵎⵉⵏⵣⵉ ⵜⵀⴻⴽⴽⵡⴰ ⵖⴰⵔ ⵍⵎⴻⵡⵜ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵍⴰⵜⴰⵔⴰⵜ ⵏⵏⴻⵙ ⵀⴻⴽⴽⵡⴰⵏⵜ ⵖⴰⵔ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR2_19","021_2_19","PRO","2","19","19","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵖⴰ ⵢⴰⴷⴼⴻⵏ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ, ⵡⴰⵔ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵖⴰⵔ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR2_20","021_2_20","PRO","2","20","20","... ⵡⴰⵀ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ, ⵓ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR2_21","021_2_21","PRO","2","21","21","ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵙ ⵍⴻⴽⵎⴰⵔⴻⵜ ⴰⴷ ⴷⴰⵢⴻⵙ ⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR2_22","021_2_22","PRO","2","22","22","ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR3_1","021_3_1","PRO","3","1","1","ⵎⵎⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓ ⵜⴰⵖⵓⵔⵉ ⵉⵏⵓ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵉⵃⴹⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PR3_2","021_3_2","PRO","3","2","2","ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⴰⵛ ⴷⴷ-ⵉⵡⵢⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵓⵍⴰ ⴷ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⴷ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR3_3","021_3_3","PRO","3","3","3","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴼⴼⵖⴻⵏ, ⵇⵇⴻⵏ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵢⵉⵔⵉ ⵏⵏⴻⵛ, ⴰⵔⵉ ⵜⴻⵏ ⵅ ⵜⴻⵍⵡⵉⵃⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PR3_4","021_3_4","PRO","3","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼⴻⴷ ⴰⵔⴹⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR3_5","021_3_5","PRO","3","5","5","ⵜⵉⵇⵇ ⴷⵉ ⵙⵉⴷⵉ ⵙ ⵡⵓⵍ ⵏⵏⴻⵛ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⵜⵜⵛⴰⵍⴰ ⵅ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_6","021_3_6","PRO","3","6","6","ⵙⵙⴻⵏ ⵉ-ⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⴳⴳⴻⵎ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_7","021_3_7","PRO","3","7","7","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵎⵉⵖⵉⵙ. ⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ ⵓ ⴱⴻⵄⵄⴻⴷ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR3_8","021_3_8","PRO","3","8","8","ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴳⴻⵏⴼⵓ ⵉ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴷ ⵡⴻⵏⵄⴰⵛ ⵉ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_9","021_3_9","PRO","3","9","9","ⵡⴻⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵙ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵛ, ⵙ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵎⴰⵔⵔⴰ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_10","021_3_10","PRO","3","10","10","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵏ ⵍⴻⵀⵔⵉⵜ ⵏⵏⴻⵛ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵓ ⵜⵉⵙⵉⵔⵉⵏ ⵏⵏⴻⵛ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⴷⴷⵓⵇⵇⵣⴻⵏ ⵙ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PR3_11","021_3_11","PRO","3","11","11","ⵎⵎⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵏⴻⵟⵟⴰⵔ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴰⵔⵔⴰ ⴰⵄⵔⵓⵔ ⵅ ⵓⵡⴻⴱⴱⴻⵅ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR3_12","021_3_12","PRO","3","12","12","ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵄⵉⵣⵣⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜ ⵉⵄⴰⵇⴻⴱ ⵄⴰⵡⴻⴷ, ⴰⵎ ⵉⵜⵜⴻⴳⴳ ⴱⴰⴱⴰⵙ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵡⴻⵏⵏⵉ ⵅ ⵢⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR3_13","021_3_13","PRO","3","13","13","ⵙⵙⴻⵄⴷ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵜⵜⴰⴼⴻⵏ ⵜⵉⵖⵉⵜ, ⵓⵍⴰ ⴷ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵜⵜⴽⴻⵙⵙⴰⴱⴻⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR3_14","021_3_14","PRO","3","14","14","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵡⵉ ⵏⴻⵜⵜⴰⵜ, ⵜⴻⵃⵍⴰ ⵅ ⵜⵙⴻⴱⴱⴰⴱⵜ ⴷⵉ ⵏⵏⵓⵇⴰⵔⵜ, ⵓ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵃⵍⴰ ⵅ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR3_15","021_3_15","PRO","3","15","15","ⵏⴻⵜⵜⴰⵜ ⵜⵉⵖⵍⴰ ⵅ ⵍⵎⴰⵔⵊⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵎⵎⴻⵥⵔⴻⴷ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⴻⵎⵇⵓⴷⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR3_16","021_3_16","PRO","3","16","16","ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵡⵓⵙⵙⴰⵏ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR3_17","021_3_17","PRO","3","17","17","ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵍⴻⴹⵔⴰⴼⴻⵜ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR3_18","021_3_18","PRO","3","18","18","ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⵍⴻⵙⵇⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵙⵄⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PR3_19","021_3_19","PRO","3","19","19","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴷⵙⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ, ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR3_20","021_3_20","PRO","3","20","20","ⵣⵉ ⵜⵓⵙⵙⵏⴰ ⵏⵏⴻⵙ ⴷⴷⵓⵇⵇⵣⴻⵏ-ⴷⴷ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ, ⵜⵜⵏⴻⵛⵏⵉⵛⴻⵏ-ⴷⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵏⵏⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR3_21","021_3_21","PRO","3","21","21","ⵎⵎⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵊⵊⵉⴷ ⴰⴷ ⴼⴼⵖⴻⵏⵜ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵃⴹⴰ ⴰⴼⵜⴰⵏ ⴷ ⵓⵃⴰⴹⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("PR3_22","021_3_22","PRO","3","22","22","ⵎⴰⵖⴰⵔ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⴰⵔⴹⴰ ⵉ ⵢⵉⵔⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_23","021_3_23","PRO","3","23","23","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⵏⴻⵇⵔⵉⴹⴻⴷ ⴷⴻⴳ ⵓⴹⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_24","021_3_24","PRO","3","24","24","ⵎⴰⵍⴰ ⵜⵔⵓⵃⴻⴷ ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ, ⵡⴰⵔ ⵜⴻⵏⵏⵅⴻⵍⵄⵉⴷ, ⵓ ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴻⵣⵣⵍⴻⴷ, ⴰⴷ ⵢⵉⵥⵉⴷ ⵢⵉⴹⴻⵚ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR3_25","021_3_25","PRO","3","25","25","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⴻⴳ ⵓⵏⴻⵅⵍⵉⵄ ⵏ ⴷⴻⵖⵢⴰ ⵓⵍⴰ ⵣⴻⴳ ⵡⴰⵔⴻⵢⵢⴻⴱ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR3_26","021_3_26","PRO","3","26","26","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⴷ ⴰⵙⴻⵏⵏⴻⴷ ⵏⵏⴻⵛ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴹⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵣⵉ ⵜⵙⴰⵔⵔⵉⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("PR3_27","021_3_27","PRO","3","27","27","ⵡⴰⵔ ⵇⴻⵟⵟⴻⵄ ⵍⵅⴰⵔ ⵅ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR3_28","021_3_28","PRO","3","28","28","ⵡⴰⵔ ⵇⵇⴰⵔ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ: ‘ⵔⵓⵃ ⵓⵛⴰ ⵄⵇⴻⴱ-ⴷⴷ, ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⴰⵛ ⵜⵜ ⵡⵛⴻⵖ!’, ⵎⴰⵍⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR3_29","021_3_29","PRO","3","29","29","ⵡⴰⵔ ⵏⴻⴽⴽⵡⵉ ⵍⵖⴰⵔ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵓⵎⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR3_30","021_3_30","PRO","3","30","30","ⵡⴰⵔ ⵜⴻⵎⵛⵓⴱⴱⵓⵛ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⴳⴳⵉ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR3_31","021_3_31","PRO","3","31","31","ⵡⴰⵔ ⵜⵜⴰⵙⴻⵎ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ, ⵃⴹⴰ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵅⴹⴰⵔⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR3_32","021_3_32","PRO","3","32","32","ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR3_33","021_3_33","PRO","3","33","33","ⵏⵏⴻⵄⵍⴻⵜ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜⵜ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜⵜ ⵉⴱⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR3_34","021_3_34","PRO","3","34","34","ⵎⴰⵍⴰ ⴷ ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⵜⴻⵀⵣⴰ ⵏⴻⵜⵜⴰ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵛⴻⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR3_35","021_3_35","PRO","3","35","35","ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵛⵛⴰⵏ, ⵎⴰⵛⴰ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴰⴷ ⵙⵙⴰⵔⴱⵓⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR4_1","021_4_1","PRO","4","1","1","ⵙⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵖⴰⵔ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ, ⵃⴻⴽⴽⴰⵔⴻⵎ ⵎⵍⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵜⵓⵙⵙⵏⴰ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR4_2","021_4_2","PRO","4","2","2","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⴰⵖⵓⵔⵉ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴰⵔ ⵙⴻⵎⵎⵃⴻⵎ ⴷⵉ ⵜⵖⵓⵔⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR4_3","021_4_3","PRO","4","3","3","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⵎⵎⵉⵙ ⵉ ⴱⴰⴱⴰ, ⴰⵔⴻⵇⵇⴰⵖ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("PR4_4","021_4_4","PRO","4","4","4","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴰⵢⵉ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵃⴹⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("PR4_5","021_4_5","PRO","4","5","5","ⵊⴱⴻⴷ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵜⵉⵖⵉⵜ, ⵊⴱⴻⴷ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵍⴻⵄⵇⴻⵍ, ⵡⴰⵔ ⵜᵉⵜⵜⵓ ⵓ ⵡⴰⵔ ⵜⵃⴻⵢⵢⵉⴷ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR4_6","021_4_6","PRO","4","6","6","ⵡⴰⵔ ⵙⴻⵎⵎⴻⵃ ⴷⵉ ⵜⵉⵖⵉⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵛⴻⴽ ⵜⴻⵃⴹⴰ, ⵙⵄⵉⵣⵣ ⵉ-ⵜⵜ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵛⴻⴽ ⵜⴻⵙⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR4_7","021_4_7","PRO","4","7","7","ⴱⴻⴷⴷⵓ ⵏ ⵜⵉⵖⵉⵜ ⴷ ⵓⴹⵓⴼ ⵏ ⵜⵉⵖⵉⵜ, ⵟⵟⴻⴼ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR4_8","021_4_8","PRO","4","8","8","ⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ, ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴰⵛ ⵜⴻⴳⴳ ⵛⵛⴰⵏ ⵎⴰⵍⴰ ⵜⴷⴰⵔⵔⵄⴻⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR4_9","021_4_9","PRO","4","9","9","ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴰⵛ ⵜⴻⵡⵛ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵜⴻⵛⵏⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⵜⴻⵡⵛ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵉⵣⴻⵡⵡⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR4_10","021_4_10","PRO","4","10","10","ⵙⴻⵍ, ⴰ ⵎⵎⵉ, ⵓ ⴽⵙⵉ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵎⵎⴰⵔⵏⵉⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR4_11","021_4_11","PRO","4","11","11","ⵙⵙⵍⴻⵎⴷⴻⵖ ⴰⵛ ⴰⴱⵔⵉⴷ ⵏ ⵜⵉⵖⵉⵜ, ⵏⴻⴷⵀⴻⵖ ⵛⴻⴽ ⴷⵉ ⵍⴰⵜⴰⵔⴰⵜ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR4_12","021_4_12","PRO","4","12","12","ⵎⴰⵍⴰ ⵜⵓⵢⵓⵔⴻⴷ, ⴰⵚⵓⵔⵉⴼ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵏⴻⵃⵚⵚⴰⵔ, ⵎⴰⵍⴰ ⵜⴰⵣⵣⵍⴻⴷ, ⵡⴰⵔ ⵜⵜⵏⴻⵇⵔⵉⴹⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR4_13","021_4_13","PRO","4","13","13","ⵛⴻⴱⴱⴰⵔ ⴷⵉ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵡⴰⵔ ⵅⴰⵙ ⵜⴻⵎⵎⵙⴻⴱⴹⴰ, ⵃⴹⴰ ⵜⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR4_14","021_4_14","PRO","4","14","14","ⵡⴰⵔ ⴳⴳⵓⵔ ⵅ ⵓⵎⴻⵙⵔⵓⵇ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⴷⵉⴼ ⴰⴱⵔⵉⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PR4_15","021_4_15","PRO","4","15","15","ⵃⴻⵢⵢⴻⴷ ⵅⴰⵙ, ⵡⴰⵔ ⵅⴰⵙ ⴳⴳⵓⵔ, ⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ ⵓ ⴰⴷ ⵜⴻⴽⴽⴻⴷ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR4_16","021_4_16","PRO","4","16","16","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜᵉⵟⵟⵚⴻⵏ ⴰⵎ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵜⵜⵔⴰⵃ ⴰⵙⴻⵏ ⵉⴹⴻⵚ ⵏⵙⴻⵏ ⵎⴰⵍⴰ ⵡⴰⵔ ⵙⵙⵏⴻⵇⵔⵉⴹⴻⵏ ⵃⴻⴷ ⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("PR4_17","021_4_17","PRO","4","17","17","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵖⵔⵓⵎ ⵏ ⵍⵖⴻⵛⵛ, ⵓ ⵏⵉⵜⵏⵉ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ ⵣⵉ ⵜⵎⴻⴳⴳⴰ ⵏ ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR4_18","021_4_18","PRO","4","18","18","ⴰⵎⴻⵙⵔⵓⵇ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⵎ ⵜⴼⴰⵡⵜ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ ⵏ ⵜⴻⴼⴼⵓⵜ, ⵜⴻⵏⵏⵉ ⵜⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵙⴻⵇⵙⴻⵇ ⴰⵍ ⵉⵎⵖⴰⵔ ⵡⴰⵙⵙ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("PR4_19","021_4_19","PRO","4","19","19","ⴰⴱⵔⵉⴷ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵎ ⵜⴰⴵⴻⵙⵜ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵏⵇⴰⵔⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR4_20","021_4_20","PRO","4","20","20","ⵎⵎⵉ ⵉⵏⵓ, ⴻⵡⵛ ⵜⴰⵢⵏⵉⵜ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PR4_21","021_4_21","PRO","4","21","21","ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵖⴻⴼⵍⴻⵏ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵅⴻⵎⵎⴻⵍ ⵉ-ⵜⴻⵏ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PR4_22","021_4_22","PRO","4","22","22","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵢⴰⴼⴻⵏ, ⵓⵍⴰ ⴷ ⴰⴳⴻⵏⴼⵓ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR4_23","021_4_23","PRO","4","23","23","ⵃⴹⴰ ⵓⵍ ⵏⵏⴻⵛ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴹⴰ, ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴼⴼⵖⴻⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR4_24","021_4_24","PRO","4","24","24","ⴽⴽⴻⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵙⴱⴻⵄⵄⴻⴷ ⵅⴰⴽ ⴰⴼⴰⵔⵢⴻⴹ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR4_25","021_4_25","PRO","4","25","25","ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵅⵣⴰⵔⴻⵏⵜ ⵖⴰⵔ ⵣⵣⴰⵜ, ⴻⵊⵊ ⴰⴱⵍⵉⵡⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵅⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR4_26","021_4_26","PRO","4","26","26","ⵡⴰⵟⴰ ⵍⴰⵜⴰⵔ ⵏ ⵓⴹⴰⵔ ⵏⵏⴻⵛ, ⴻⵊⵊ ⴰⴷ ⵉⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⵙⴰⵔⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR4_27","021_4_27","PRO","4","27","27","ⵡⴰⵔ ⴼⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⵙⴱⴻⵄⵄⴻⴷ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR5_1","021_5_1","PRO","5","1","1","ⵎⵎⵉ ⵉⵏⵓ, ⴻⵡⵛ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵉⵖⵉⵜ ⵉⵏⵓ, ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PR5_2","021_5_2","PRO","5","2","2","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵃⴰⴹⵓⵔ, ⵓ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR5_3","021_5_3","PRO","5","3","3","ⵎⵉⵏⵣⵉ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴱⴰⵔⵔⴰⵏⵉⵜ ⵜⵜⵓⴷⵓⵎⴻⵏ ⵙ ⵜⴰⵎⵎⴻⵏⵜ ⵏ ⵜⴻⵖⵔⴰⵚⵜ, ⴰⵏⴻⵖ ⵏⵏⴻⵙ ⴷ ⴰⵍⴻⵇⵇⴰⵖ ⵅ ⵣⵣⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("PR5_4","021_5_4","PRO","5","4","4","ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⴻⵔⵣⴰⴳⵜ ⴰⵎ ⵛⵛⵉⵃ, ⵜⴻⵇⴹⴻⵄ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR5_5","021_5_5","PRO","5","5","5","ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵡⵜ, ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ ⵏⴻⴷⴷⵀⴻⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR5_6","021_5_6","PRO","5","6","6","ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜᵉⵟⵟⵉⴼⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ, ⴳⴳⵓⵔⴻⵏⵜ ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴰ ⴷ ⵙⵙⴰ ⴱⵍⴰ ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR5_7","021_5_7","PRO","5","7","7","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵡⴰⵔ ⵜⵃⴻⵢⵢⴰⴷⴻⵎ ⵛⴰ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR5_8","021_5_8","PRO","5","8","8","ⵙⵉⴳⴳⵯⴻⵊ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵅⴰⵙ, ⵡⴰⵔ ⵜⵜⴰⴷⴻⵙ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR5_9","021_5_9","PRO","5","9","9","ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵛⴻⴷ ⵛⵛⴰⵏ ⵏⵏⴻⵛ ⵉ ⵉⵏⵏⴻⵖⵏⵉ, ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵛ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵇⵙⵉⵃⴻⵏ ⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("PR5_10","021_5_10","PRO","5","10","10","ⵃⵉⵎⴰ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜⵜⵊⴰⵡⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵛ, ⵓ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵙⵙⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR5_11","021_5_11","PRO","5","11","11","ⵓ ⴰⴷ ⵜⵣⴻⵀⵀⴰⵔⴻⴷ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⵅⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵛⵛ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PR5_12","021_5_12","PRO","5","12","12","ⴰⴷ ⵜⵉⵏⵉⴷ: “ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⵛⴰⵔⵀⴻⵖ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵎⴰⵎⵎⴻⵛ ⵉⵏⴹⴰⵔ ⵓⵍ ⵉⵏⵓ ⴰⵡⴻⴱⴱⴻⵅ? ");
INSERT INTO rift_vpl VALUES ("PR5_13","021_5_13","PRO","5","13","13","ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵙⵍⵉⵖ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴷⴰⵔⵔⴱⴻⵏ, ⵡⴰⵔ ⵡⵛⵉⵖ ⴰⵎⴻⵣⵣⵓⵖ ⵉⵏⵓ ⵉ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("PR5_14","021_5_14","PRO","5","14","14","ⵄⵍⴰⵃⴰⵍ ⵜⵓⵖⴰ ⵓⴼⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷⵉ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⵖⴰⵔ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ!” ");
INSERT INTO rift_vpl VALUES ("PR5_15","021_5_15","PRO","5","15","15","ⵙⵓⵡ ⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵏⵓ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵣⵉ ⵍⴰⴵⴰⵖ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR5_16","021_5_16","PRO","5","16","16","ⵉⵍⵉ ⴰⴷ ⵙⵙⴻⴼⵢⴻⵏ ⵡⴰⵎⴰⵏ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵏⴻⵛ ⴱⴰⵔⵔⴰ, ⴰⵎ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ ⵅ ⵉⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR5_17","021_5_17","PRO","5","17","17","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉ ⴷⵉⵏ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR5_18","021_5_18","PRO","5","18","18","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵍⵄⵓⵏⵚⴰⵔ ⵏⵏⴻⵛ, ⴼⴰⵔⵃ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR5_19","021_5_19","PRO","5","19","19","ⵜⵓⴷⴰⴷⵜ ⵉⵄⵉⵣⵣⴻⵏ ⵓⵍⴰ ⴷ ⵜⵉⵖⴻⵢⴷⴻⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏⴻⵜⵜⴰⵜ! ⴻⵊⵊ ⵉⴱⴱⴰⵛ ⵏⵏⴻⵙ ⴰⴷ ⵛⴻⴽ ⵙⵙⵢⵉⵡⵢⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ, ⵙⴻⵍⵍⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵍⴻⴱⴷⴰ ⵖⴰⵔ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PR5_20","021_5_20","PRO","5","20","20","ⵎⴰⵢⴻⵎⵎⵉ, ⴰ ⵎⵎⵉ, ⴰⴷ ⵛⴻⴽ ⵜⴻⵖⵡⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴱⴰⵔⵔⴰⵏⴻⵛⵜ, ⴰⴷ ⵜⴷⴰⵔⵔⵄⴻⴷ ⵉ ⵡⴻⵃⵙⵉⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("PR5_21","021_5_21","PRO","5","21","21","ⵎⴰⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR5_22","021_5_22","PRO","5","22","22","ⵍⵎⵓⵄⵙⵉⵢⵢⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜⵃⴻⴱⴱⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ, ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵛⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PR5_23","021_5_23","PRO","5","23","23","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PR6_1","021_6_1","PRO","6","1","1","ⵎⵎⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵎⴰⵔⵀⵓⵏ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵜⴻⵡⵛⵉⴷ ⵜⵉⵛⵜⵉ ⵏⵏⴻⵛ ⵏ ⵓⴼⵓⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("PR6_2","021_6_2","PRO","6","2","2","ⵎⴰⵍⴰ ⵜⴷⴻⵡⵍⴻⴷ ⵜⴻⵇⵇⵏⴻⴷ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵜᵉⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⴷ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PR6_3","021_6_3","PRO","6","3","3","ⵅⴻⵏⵏⵉ ⴻⴳⴳ ⵜⴰ, ⴰ ⵎⵎⵉ, ⵓ ⴼⴻⴽⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ: ⵓⵢⵓⵔ, ⴱⴻⵏⴷⴻⵇ ⵅⴰⵙ ⵓ ⵣⴻⵢⵢⴰⵔ ⵅ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵢⵓⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR6_4","021_6_4","PRO","6","4","4","ⵡⴰⵔ ⵜⵜⵉⵛ ⵛⴰ ⵉⴹⴻⵚ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⴰⵏⵓⴷⴻⵎ ⵉ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR6_5","021_6_5","PRO","6","5","5","ⴼⴻⴽⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵎ ⵜⵖⴻⵢⴹⴻⵜ ⵏ ⵡⴻⵖⵣⴰⵔ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵏⴻⴳⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR6_6","021_6_6","PRO","6","6","6","ⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴽⴻⴹⴼⴻⵜ, ⵛⴻⴽ, ⴰ ⴰⵎⴻⵄⴳⵓⵣ, ⵅⵣⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵢⵓⵔ ⵏⴻⵜⵜⴰⵜ ⵓ ⴷⵡⴻⵍ ⴷ ⴰⵎⵉⵖⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR6_7","021_6_7","PRO","6","7","7","ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵓⵎⴳⴻⵡⵡⴻⴷ, ⵏⵉⵖ ⴰⵡⴻⵇⵇⴰⴼ ⵏⵉⵖ ⵍⵃⴰⴽⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("PR6_8","021_6_8","PRO","6","8","8","ⵄⴰⴷ ⵜⴻⵙⵙⴻⵡⵊⴰⴷ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ, ⵜⴻⵢⵔⵓ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⵢⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR6_9","021_6_9","PRO","6","9","9","ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴻⵣⵣⵍⴻⴷ, ⵛⴻⴽ, ⴰ ⴰⵎⴻⵄⴳⵓⵣ? ⵎⴻⵍⵎⵉ ⵖⴰ ⵜⴻⴽⴽⴰⵔⴻⴷ ⵣⴻⴳ ⵉⴹⴻⵚ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PR6_10","021_6_10","PRO","6","10","10","ⴰⵔⵏⵉ ⵛⵡⴰⵢⵜ ⵏ ⵢⵉⴹⴻⵚ, ⴰⵔⵏⵉ ⵛⵡⴰⵢⵜ ⵏ ⵓⵡⴰⵔⵔⴻⵛ, ⴰⵔⵏⵉ ⵛⵡⴰⵢⵜ ⵏ ⵓⴱⵓⵣⵣⴻⵍ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵎⵓⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR6_11","021_6_11","PRO","6","11","11","ⴰⵇⴰ ⴷⴰ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵉⵡⴹⴰ ⵣⵣⴻⵍⴹ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵅⴻⵡⵡⴰⵏ, ⵍⴻⵖⴱⴻⵏ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("PR6_12","021_6_12","PRO","6","12","12","ⴱⵏⴰⴷⴻⵎ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⴰⵔⵢⴰⵣ ⵏ ⵍⵖⴻⵛⵛ, ⵉⴳⴳⵓⵔ ⵙ ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵎⵉⵏ ⵉⵄⴻⵡⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR6_13","021_6_13","PRO","6","13","13","ⵉⵖⴻⵎⵎⴻⵣ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵜⵜⵛⴻⵢⵢⴰⵔ ⵙ ⵉⴹⴻⵡⴹⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR6_14","021_6_14","PRO","6","14","14","ⵓⵍ ⵏⵏⴻⵙ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⵅⴷⴰⵄⴰⵜ, ⵉⵏⴻⴽⴽⵡⴰ ⵍⴻⴱⴷⴰ ⵍⵖⴰⵔ, ⵉⵜⵜⵙⴻⴱⴱⴰⴱ ⵉⵎⴻⵏⵖⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR6_15","021_6_15","PRO","6","15","15","ⵅ ⵓⵢⴰ ⴷⴻⵖⵢⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵓⴳⴻⵏⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("PR6_16","021_6_16","PRO","6","16","16","ⵙⴻⵜⵜⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉⵛⴰⵔⵔⴻⵀ ⵉ-ⵜⴻⵏⵜ ⵙⵉⴷⵉ, ⵡⴰⵀ ⵙⴻⴱⵄⴰ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵏⵏⵄⵉ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("PR6_17","021_6_17","PRO","6","17","17","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵏⵏⴼⴰⵅⴻⵜ, ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵓⵍⴰ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵙⵙⴰⵣⵣⴰⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR6_18","021_6_18","PRO","6","18","18","ⵓⵍ ⵉⵏⴻⴽⴽⵡⴰⵏ ⵜⵉⵎⴻⵄⵎⴰⵍⵜ ⵉⵖⴻⵛⵛⴻⵏ, ⵉⴹⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("PR6_19","021_6_19","PRO","6","19","19","ⴰⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴷⴻⴵⵇⴻⵏ ⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵓⵍⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⵉⵎⴻⵏⵖⵉⵢⵢⴻⵏ ⵊⴰⵔ ⵜⴰⵡⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR6_20","021_6_20","PRO","6","20","20","ⴰ ⵎⵎⵉ, ⵃⴹⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵛ, ⵓ ⵡⴰⵔ ⵎⴻⵏⴹⴰⵔ ⵜⴰⵖⵓⵔⵉ ⵏ ⵢⴻⵎⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("PR6_21","021_6_21","PRO","6","21","21","ⵇⵇⴻⵏ ⵉ-ⵜⴻⵏⵜ ⵍⴻⴱⴷⴰ ⵅ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵛⴻⴷⴷ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵢⵉⵔⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR6_22","021_6_22","PRO","6","22","22","ⵎⴰⵍⴰ ⵜⴻⴳⴳⵓⵔⴻⴷ, ⴰⵢⴰ ⴰⴷ ⵛⴻⴽ ⵉⴳⴻⵡⵡⴻⴷ, ⵎⴰⵍⴰ ⵜⴻⵣⵣⵔⴻⴷ, ⴰⵢⴰ ⴰⴷ ⵛⴻⴽ ⵉⵃⴹⴰ, ⵎⴰⵍⴰ ⵜⴼⴰⵇⴻⴷ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR6_23","021_6_23","PRO","6","23","23","ⵎⵉⵏⵣⵉ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⴷ ⵍⴻⴼⵏⴰⵔ ⴷ ⵜⵖⵓⵔⵉ ⴷ ⵜⴼⴰⵡⵜ, ⵉⵡⴻⴱⴱⴰⵅ ⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ");
INSERT INTO rift_vpl VALUES ("PR6_24","021_6_24","PRO","6","24","24","ⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵃⴹⴰⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵣⵉ ⵍⴻⵀⵔⵓⴷ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵢⵉⵍⴻⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR6_25","021_6_25","PRO","6","25","25","ⵡⴰⵔ ⵄⴻⵛⵛⴻⵇ ⵛⴰ ⴰⵥⵔⵉ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵃⴹⴰ ⵡⴰⵔ ⵛⴻⴽ ⵜⴻⵃⵚⵉⵔ ⵙ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR6_26","021_6_26","PRO","6","26","26","ⵎⵉⵏⵣⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴽⵙⵉ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⵅⴻⴱⴱⴰⵣⵜ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵡⴰⵀ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⴰⵇⴰ ⵜⴰⵔⴻⵣⵣⵓ ⵍⴻⵄⵎⴰⵔ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR6_27","021_6_27","PRO","6","27","27","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⵉⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵢⴰⵔⵖ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PR6_28","021_6_28","PRO","6","28","28","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵢⵓⵢⵓⵔ ⵅ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵛⴻⵎⴹⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PR6_29","021_6_29","PRO","6","29","29","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵡⴰⵀ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⵀⴰⴷⴰⵏ, ⵡⴰⵔ ⵉⵜⵜⵡⵉⵃⵙⵉⴱ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("PR6_30","021_6_30","PRO","6","30","30","ⴰⵛⴻⴼⴼⴰⵔ ⵡⴰⵔ ⵜ ⵙⵙⵃⴻⵇⵇⴰⵔⴻⵏ ⵎⴰⵍⴰ ⵢⵓⵛⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵢⵉⵡⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵎⴰⵍⴰ ⴷⴰⵢⴻⵙ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("PR6_31","021_6_31","PRO","6","31","31","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴼ, ⴰⵎⵎⵓ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵅⴻⴵⴻⵚ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵡⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR6_32","021_6_32","PRO","6","32","32","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵣⵣⵉⵏⴰ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵡⵓⵍ ⵉⵎⵜⴻⵏ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⴰ, ⵉⵜⵜⴰⵔⴻⴷⴷⴻⴵ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR6_33","021_6_33","PRO","6","33","33","ⴷⵔⵓⵛⵜ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴰⴷ ⵜⴻⵏ ⵢⴰⴼ, ⵍⴻⵃⵢⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵎⴻⵃⵃⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PR6_34","021_6_34","PRO","6","34","34","ⵎⴰⵖⴰⵔ ⵜⵓⵙⵎⵉ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵙⵄⴰⵔ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵙⴻⵏ ⴰⵃⵉⵏⵏⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵏⵜⴰⵇⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR6_35","021_6_35","PRO","6","35","35","ⵡⴰⵔ ⵉⵃⴻⵙⵙⴻⴱ ⴷⴷⴻⵢⵢⴻⵜ ⵉ ⵡⴻⵚⵍⴻⵃ, ⵡⴰⵔ ⵜⵜ ⵉⵇⴻⴱⴱⴻⵍ, ⴰⴷ ⵢⵓⴳⵉ, ⵡⴰⵅⵅⴰ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⵉⴷ ⴷⵉ ⵜⴻⵔⵣⴻⴼⵜ ⵄⴰⴷ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_1","021_7_1","PRO","7","1","1","ⵎⵎⵉ ⵉⵏⵓ, ⵃⴹⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵅⴻⵎⵎⴻⵍ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵖⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR7_2","021_7_2","PRO","7","2","2","ⵃⴹⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵃⴹⴰ ⵜⴰⵖⵓⵔⵉ ⵉⵏⵓ ⴰⵎ ⵎⵓⵎⵎⵓ ⵏ ⵜⵉⵟⵟ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR7_3","021_7_3","PRO","7","3","3","ⵇⵇⴻⵏ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵉⴹⴻⵡⴹⴰⵏ ⵏⵏⴻⵛ, ⴰⵔⵉ ⵜⴻⵏⵜ ⵅ ⵜⴻⵍⵡⵉⵃⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR7_4","021_7_4","PRO","7","4","4","ⵉⵏⵉ ⵉ ⵜⵉⵖⵉⵜ: ‘ⵛⴻⵎ ⴷ ⵓⵍⵜⵎⴰ!’, ⵓ ⵙⴻⵎⵎⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ: ‘ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ!’, ");
INSERT INTO rift_vpl VALUES ("PR7_5","021_7_5","PRO","7","5","5","ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⵛⴻⴽ ⵃⴹⴰⵏⵜ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴱⴰⵔⵔⴰⵏⴻⵛⵜ, ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⴱⴰⵔⵔⴰ ⵉ ⵛⴻⴽ ⵉⵜⵜⵖⴰⵔⵔⴰⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_6","021_7_6","PRO","7","6","6","ⵎⴰⵖⴰⵔ ⵣⵉ ⵍⴽⴰⵣⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵊⴰⵔ ⵛⵛⴻⴱⴱⴰⵛ ⵏ ⵍⴽⴰⵣⵉ ⵙⴻⵡⴹⴻⵖ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("PR7_7","021_7_7","PRO","7","7","7","ⵙⴻⵡⴹⴻⵖ ⵖⴰⵔ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵃⵉⴽⵉⵏ, ⵊⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⵃⴻⴽⴽⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵓⵃⵓⴷⵔⵉ ⵙ ⵡⵓⵍ ⵡⴰⵔ ⵉⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR7_8","021_7_8","PRO","7","8","8","ⵏⴻⵜⵜⴰ ⵉⵥⵡⴰ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵜⴻⵖⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_9","021_7_9","PRO","7","9","9","ⵖⴰⵔ ⵜⴱⴰⵎⴱⴰⵙⵜ, ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵏ ⵡⴰⵙⵙ, ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⴵⵉⵍⴻⵜ ⴷ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("PR7_10","021_7_10","PRO","7","10","10","ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⵙ, ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("PR7_11","021_7_11","PRO","7","11","11","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵅⵜⵉⵅ ⵓ ⵜⵖⴻⵡⵡⴻⵖ, ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR7_12","021_7_12","PRO","7","12","12","ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⵉ ⴱⴰⵔⵔⴰ, ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⴰⵔ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵜᵉⵜⵜⵃⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("PR7_13","021_7_13","PRO","7","13","13","ⵏⴻⵜⵜⴰⵜ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜ ⵓ ⵜⴻⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ, ⵜⴻⵇⵊⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("PR7_14","021_7_14","PRO","7","14","14","“ⵜⵓⵖⴰ ⵅⴰⴼⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵛⴻⵖ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ. ⴰⵙⵙ-ⴰ ⵙⵙⵇⴻⴼⵍⴻⵖ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR7_15","021_7_15","PRO","7","15","15","ⵅ ⵓⵢⴰ ⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵎⵎⵙⴰⴳⴰⵔⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴽ ⴰⵔⵣⵓⵖ ⵓ ⴰⵎⵎⵓ ⵉ ⵛⴻⴽ ⵓⴼⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PR7_16","021_7_16","PRO","7","16","16","ⵏⴻⵛⵛ ⵙⵙⵓⵖ ⵎⴰⵍⵜⴰⵜ ⵅ ⵇⴰⵎⴰ ⵉⵏⵓ, ⵍⵉⵣⴰⵔⴰⵜ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵣⵉ ⵍⴻⵇⵜⴻⵏ ⴰⵣⴷⴰⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR7_17","021_7_17","PRO","7","17","17","ⵏⴻⵛⵛ ⵔⵓⵛⵛⴻⵖ ⵜⴰⵙⵙⵓⵜ ⵉⵏⵓ ⵙ ⵎⵉⵔⵔⵓ ⴷ ⵡⴻⵛⴼⵉⵍ ⴷ ⵍⵇⴰⵔⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("PR7_18","021_7_18","PRO","7","18","18","ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵊⵊⵉⵡⴻⵏ ⴰⵙⵃⵉⵏⵏⴻⴱ ⴰⵍ ⵜⵓⴼⴼⵓⵜ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵍⵉⵔⴰⵔⵜ ⵏ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("PR7_19","021_7_19","PRO","7","19","19","ⵎⴰⵖⴰⵔ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⴻⵜⵜⴰ ⵉⵙⴰⴼⴰⵔ ⵉⴳⴳⵯⴻⵊ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_20","021_7_20","PRO","7","20","20","ⵉⴽⵙⵉ ⵉⵛⵜ ⵏ ⵜⴽⴻⵎⵎⵓⵙⵜ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴰⴽⵉⴷⴻⵙ, ⴰⴷ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵡⴰⵙⵙ ⵏ ⵜⵣⵉⵔⵉ ⵉⵇⴻⴼⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("PR7_21","021_7_21","PRO","7","21","21","ⴰⵎⵎⵓ ⵉ ⵜ ⵜᵉⵟⵟⴻⴼ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ, ⵜⴻⵖⵡⴰ ⵉ-ⵜ ⵙ ⵍⴻⵀⵔⵓⴷ ⵏⵏⴻⵙ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_22","021_7_22","PRO","7","22","22","ⴷⴻⵖⵢⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴷⴻⴼ ⵉ-ⵜⵜ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵉⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵍⴳⵓⵔⵏⴻⵜ, ⴰⵎ ⵉⵛⵜ ⵏ ⵙⵙⵏⴻⵙⵍⴻⵜ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵓⵎⴰⵔⵔⴻⵜ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ");
INSERT INTO rift_vpl VALUES ("PR7_23","021_7_23","PRO","7","23","23","- ⴰⵍⴰⵎⵉ ⴷⴷ ⴰⵙ ⵜⵛⴰⵔⵔⴻⴳ ⴼⵍⵉⵜⵛⴰ ⵜⵙⴰ - ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⵉⴹⵡⵉⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵏⴷⴰⵢ, ⵓ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵡⴰⴳⴳ ⴹⵉⴷⴷ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_24","021_7_24","PRO","7","24","24","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵓ ⵙⵍⴻⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR7_25","021_7_25","PRO","7","25","25","ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵡⴻⴷⴷⵉⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⵎⴻⵢⵢⵉⵍ ⵖⴰⵔ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR7_26","021_7_26","PRO","7","26","26","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵉⵜⵜⵡⴰⵢⴻⵣⵎⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵖⴹⴻⵔ, ⵉⵎⵖⴰⵔ ⵡⴰⵟⵟⴰⵙ ⵍⵄⴰⴷⴰⴷ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⴻⵏⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("PR7_27","021_7_27","PRO","7","27","27","ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⴱⵔⵉⴷⴻⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR8_1","021_8_1","PRO","8","1","1","ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵍⵉⵖⵉ ⵜⵉⵖⵉⵜ ⵓ ⵡⴰⵔ ⵜⴻⵙⴳⵉⵄⵄⵉⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PR8_2","021_8_2","PRO","8","2","2","ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵅ ⵡⴻⴱⵔⵉⴷ, ⵎⴰⵏⵉ ⵜⵜⴻⵎⵙⴻⵍⵇⴰⵏ ⵉⵎⴻⵙⵔⴰⵇ ⵜⴱⴻⴷⴷ ⵏⴻⵜⵜⴰⵜ ⴷ ⴰⴱⴻⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR8_3","021_8_3","PRO","8","3","3","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵏⵉ ⵖⴰ ⵜⴰⴷⴼⴻⴷ ⵅ ⵜⴻⵡⵡⵓⵔⴰ, ⵜᵉⵜⵜⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ: ");
INSERT INTO rift_vpl VALUES ("PR8_4","021_8_4","PRO","8","4","4","“ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵜⵜⵍⴰⵖⵉⵖ, ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵜᵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR8_5","021_8_5","PRO","8","5","5","ⴽⴻⵏⵏⵉⵡ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ, ⴼⴻⵀⵎⴻⵎ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⴼⵜⴰⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⴼⴻⵀⵎⴻⵎ ⵙ ⵡⵓⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR8_6","021_8_6","PRO","8","6","6","ⵙⵍⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉ ⴷⴷ-ⵉⵊⴻⴱⴱⴷⴻⵏ ⵍⴻⴼⵜⴻⵏ, ⴰⵏⵓⵔⵣⴻⵎ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ ⵊⴻⴱⴱⴻⴷ-ⴷⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR8_7","021_8_7","PRO","8","7","7","ⵎⴰⵖⴰⵔ ⴰⵏⴻⵖ ⵉⵏⵓ ⴰⴷ ⵢⵉⵏⵉ ⵜⵉⴷⴻⵜⵜ ⵙ ⵏⵏⴻⵢⵢⴻⵜ, ⵍⵀⴰⵔⴷ ⵉⵄⴻⴼⴼⵏⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ ⵉ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR8_8","021_8_8","PRO","8","8","8","ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵜⵙⴻⴳⴷⴰ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉⵅⵏⵓⵏⵏⴻⵙⴻⵏ ⵏⵉⵖ ⵉⴼⴰⵔⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR8_9","021_8_9","PRO","8","9","9","ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵚⴼⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⴷⵉ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵓⵍⴰ ⵙ ⵍⴻⵇⵢⴰⵙ ⵉ ⵢⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴰⴼⴻⵏ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR8_10","021_8_10","PRO","8","10","10","ⴽⵙⵉⵎ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵉⵏⵓ, ⵡⴰⵔ ⵉⴵⵉ ⵏⵏⵓⵇⴰⵔⵜ, ⵓⵍⴰ ⵜⵓⵙⵙⵏⴰ ⴽⵜⴰⵔ ⵅ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR8_11","021_8_11","PRO","8","11","11","ⵎⴰⵖⴰⵔ ⵜⵉⵖⵉⵜ ⵃⵙⴻⵏ ⵣⵉ ⵍⵎⴰⵔⵊⴰⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⴻⵥⵔⵉ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵡⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR8_12","021_8_12","PRO","8","12","12","ⵏⴻⵛⵛ, ⵜⵉⵖⵉⵜ, ⵣⴻⴷⴷⵖⴻⵖ ⵖⴰⵔ ⵡⴻⴼⵜⴰⵏ, ⵜⵜⴰⴼⴻⵖ ⵜⵓⵙⵙⵏⴰ ⵙ ⵓⵃⴰⴷⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("PR8_13","021_8_13","PRO","8","13","13","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⴰⵛⵔⴰⵀ ⵏ ⵍⵖⴰⵔ, ⵏⵏⴼⴰⵅⴻⵜ, ⵜⴰⵛⴻⵏⵏⴰⵄⵜ ⴷ ⵓⵎⴻⵙⵔⵓⵇ ⴰⵄⴻⴼⴼⴰⵏ, ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⵓⵍⴰ ⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⵅⴷⴰⵄⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR8_14","021_8_14","PRO","8","14","14","ⵖⴰⵔⵉ ⴰⵛⴰⵡⴰⵔ ⴷ ⵜⵡⵉⵣⴰ, ⵏⴻⵛⵛ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵖⴰⵔⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PR8_15","021_8_15","PRO","8","15","15","ⵣⵣⴰⵢⵉ ⵃⴻⴽⴽⵎⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵣⵣⴰⵢⵉ ⵜⵜⴰⵔⴻⵢⵙⴻⵏ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵙ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR8_16","021_8_16","PRO","8","16","16","ⵣⵣⴰⵢⵉ ⵃⴻⴽⴽⵎⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵎⴰⵔⵔⴰ ⵍⵇⵓⴹⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR8_17","021_8_17","PRO","8","17","17","ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⴷ ⵢⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵣⵉⵛ, ⴰⴷ ⴰⵢⵉ ⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR8_18","021_8_18","PRO","8","18","18","ⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⵉ, ⴰⴳⵍⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR8_19","021_8_19","PRO","8","19","19","ⴼⵔⵓⵜⴰ ⵉⵏⵓ ⵜⴻⵛⵏⴰ ⵅ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⵡⴰⵀ ⵅ ⵡⵓⵔⴻⵖ ⴰⵣⴷⴰⴷ, ⵍⵖⵉⴵⴻⵜ ⵉⵏⵓ ⵜⴻⵄⴷⵓ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵇⵇⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR8_20","021_8_20","PRO","8","20","20","ⵏⴻⵛⵛ ⴳⴳⵓⵔⴻⵖ ⵅ ⵓⵎⴻⵙⵔⵓⵇ ⵏ ⵜⵙⴻⴳⴷⴰ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵍⵃⴻⵇⵇ, ");
INSERT INTO rift_vpl VALUES ("PR8_21","021_8_21","PRO","8","21","21","ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷ ⵍⵡⴰⵔⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵛⵛⵓⵔⴻⵖ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR8_22","021_8_22","PRO","8","22","22","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵢⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵄⴰⴷ ⵇⴱⴻⵍ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PR8_23","021_8_23","PRO","8","23","23","ⵣⵉ ⵍⴻⴱⴷⴰ ⵉⵜⵜⵡⴰⵣⴻⴵⴻⵄ ⵅⴰⴼⵉ ⵊⵊⴻⵀⴷ, ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵣⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("PR8_24","021_8_24","PRO","8","24","24","ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵄⴰⴷ ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ, ⵏⴻⵛⵛ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵖ-ⴷⴷ, ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵄⴰⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR8_25","021_8_25","PRO","8","25","25","ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⴷⵓⵔⴰⵔ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⴻⵡⵔⵉⵔⵉⵏ, ⵜⵓⵖⴰ ⵅⴻⵍⵇⴻⵖ-ⴷⴷ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PR8_26","021_8_26","PRO","8","26","26","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵉⵅⵍⵉⵇ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵉⵢⵢⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR8_27","021_8_27","PRO","8","27","27","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵊⴻⵏⵡⴰⵏ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉⵏ, ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵛⴻⵎ ⵉⵛⵜ ⵏ ⵜⵇⵓⵔⴰⵔⴻⵛⵜ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR8_28","021_8_28","PRO","8","28","28","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵙⴻⵏⵏⴻⵊ, ⵓⵎⵉ ⵜⵜⵡⴰⵊⴻⵀⴷⴻⵏⵜ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR8_29","021_8_29","PRO","8","29","29","ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵢⵎⵉⵔ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⵎⴰⵏ ⵡⴰⵔ ⴷⴷ-ⵄⴻⴷⴷⵓⵏ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("PR8_30","021_8_30","PRO","8","30","30","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵎⵓⴷⵔⵓⵙ ⵉⵄⵉⵣⵣⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ. ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⴷ ⵜⴰⵔⵔⵉⵜ ⵏ ⵎⴻⵥⵔⵉ ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ, ⵜⵜⵉⵔⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PR8_31","021_8_31","PRO","8","31","31","ⵜⵜⵉⵔⴰⵔⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵓⵖⴰ ⵜⴰⵔⵔⵉⵜ ⵏ ⵎⴻⵥⵔⵉ ⵉⵏⵓ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR8_32","021_8_32","PRO","8","32","32","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ! ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR8_33","021_8_33","PRO","8","33","33","ⵙⵍⴻⵎ ⵖⴰⵔ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵓ ⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵡⴰⵔ ⵏⴻⵟⵟⴰⵔⴻⵎ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR8_34","021_8_34","PRO","8","34","34","ⵙⵙⴻⵄⴷ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵖⴰⵔⵉ ⵉⵙⵍⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⵛⴱⴰⵔ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵉⵏⵓ ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵍ ⵡⴰⵙⵙ, ⵉⵃⴻⵜⵜⴰ ⵅ ⵜⵖⴻⵎⵎⴰⵔ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PR8_35","021_8_35","PRO","8","35","35","ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵢⵓⴼⵉⵏ, ⴰⴷ ⵢⴰⴼ ⵜⵓⴷⴰⵔⵜ, ⵓ ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR8_36","021_8_36","PRO","8","36","36","ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵅⴹⴰⵏ, ⵉⵢⴻⵣⵣⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵜⵜⴻⵅⵙⴻⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR9_1","021_9_1","PRO","9","1","1","ⵜⵉⵖⵉⵜ ⵜⴻⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⴳⴳⴰ ⵜⴻⵙⵙⵓⵢⴷⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("PR9_2","021_9_2","PRO","9","2","2","ⵏⴻⵜⵜⴰⵜ ⵜⵖⴰⵔⵚ ⵉ ⵍⵎⴰⵍ ⵏⵏⴻⵙ, ⵜⵅⴻⴵⴻⴹ ⴱⵉⵏⵓ ⵏⵏⴻⵙ. ⵄⴰⵡⴻⴷ ⵜⴻⵙⵙⵓ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR9_3","021_9_3","PRO","9","3","3","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⴽⴽ ⵜⵉⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵙ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ. ⵅ ⵜⵇⵉⵛⵛⴰⵜⵉⵏ ⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜᵉⵜⵜⵍⴰⵖⴰ: ");
INSERT INTO rift_vpl VALUES ("PR9_4","021_9_4","PRO","9","4","4","“ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵃⴰⴼⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴰⵏⵉⵜⴰ!” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⵇⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵛⴰ ⵡⵓⵍ ⵉⵎⵜⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("PR9_5","021_9_5","PRO","9","5","5","“ⴰⵙⴻⵎ-ⴷⴷ, ⵛⵛⴻⵎ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ ⵉⵏⵓ, ⵙⵡⴻⵎ ⵣⵉ ⴱⵉⵏⵓ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵅⴻⴵⴹⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PR9_6","021_9_6","PRO","9","6","6","ⵊⵊⴻⵎ ⵜⴰⵇⵓⴱⴱⴰⵏⴻⵛⵜ, ⵓⵛⴰ ⴷⴷⴰⵔⴻⵎ, ⴹⴼⴰⵔⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("PR9_7","021_9_7","PRO","9","7","7","“ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴻⴱⴱⵅⴻⵏ ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ, ⵉⵙⵙⴰⵔⴻⴱⴱⵓ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴰⵇⴰⴱⴻⵏ ⴰⵄⴻⴼⴼⴰⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⴱⴱⵓ ⴰⴱⴻⵇⵇⵉⴹ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR9_8","021_9_8","PRO","9","8","8","ⵡⴰⵔ ⵜⵜⵄⴻⵢⵢⴰⴱ ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵛⴰⵔⵔⴻⵀ, ⵄⴻⵢⵢⴻⴱ ⴰⵎⵉⵖⵉⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵅⵙ. ");
INSERT INTO rift_vpl VALUES ("PR9_9","021_9_9","PRO","9","9","9","ⴻⵡⵛ ⵉ ⵓⵎⵉⵖⵉⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵎⵉⵖⵉⵙ ⴽⵜⴰⵔ, ⵙⵖⴰⵔ ⵜⵓⵙⵙⵏⴰ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⵀⴻⵎ ⴽⵜⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("PR9_10","021_9_10","PRO","9","10","10","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵜⵉⵖⵉⵜ, ⵜⵓⵙⵙⵏⴰ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR9_11","021_9_11","PRO","9","11","11","ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⵉ ⴰⴷ ⴽⵜⴰⵔⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵛ, ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⴰⴷ ⵜⵜⵡⴰⵔⵏⵉⵏ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR9_12","021_9_12","PRO","9","12","12","ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵎⵉⵖⵉⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵎⵉⵖⵉⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵓ ⵎⴰⵍⴰ ⵜⴻⵙⵜⴻⵀⴻⵣⵣⵉⴷ, ⴰⴷ ⵜⴰⵔⴱⵓⴷ ⴰⵢⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("PR9_13","021_9_13","PRO","9","13","13","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴰⴱⵓⵀⴰⵍⴻⵛⵜ ⵜᵉⵜⵜⴱⵓⵀⵍⵓⵢ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵇⵓⴱⴱⴰⵏⵉⵜ, ⵡⴰⵔ ⵜⴻⵙⵙⴻⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PR9_14","021_9_14","PRO","9","14","14","ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵅ ⵉⵊⵊ ⵏ ⴽⵓⵔⵙⵉ, ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ");
INSERT INTO rift_vpl VALUES ("PR9_15","021_9_15","PRO","9","15","15","ⵃⵉⵎⴰ ⴰⴷ ⵜⵍⴰⵖⴰ ⵅ ⵉⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ, ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵙⴻⵏ, ⵜⴻⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("PR9_16","021_9_16","PRO","9","16","16","“ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵃⴰⴼⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴰⵏⵉⵜⴰ!” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⵇⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵛⴰ ⵡⵓⵍ ⵉⵎⵜⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("PR9_17","021_9_17","PRO","9","17","17","“ⴰⵎⴰⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⴻⵏ ⴷ ⵉⵎⵉⵥⵉⴷⴻⵏ, ⴰⵖⵔⵓⵎ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⴰⵇⴰ ⵉⵛⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("PR9_18","021_9_18","PRO","9","18","18","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ, ⴰⵇⴰ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⴵⴰⵖ ⵏ ⵍⴰⵅⴰⵔⵜ ⵉ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_1","021_10_1","PRO","10","1","1","ⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴷ ⴰⵎⵉⵖⵉⵙ ⵉⵙⵙⴼⴰⵔⵔⴰⵃ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵏ ⵎⵎⵉⵙ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵏⵓⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR10_2","021_10_2","PRO","10","2","2","ⵜⵉⵅⵓⴱⴰⵢ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵡⴰⵔ ⵏⵏⴻⴼⴼⵄⴻⵏⵜ, ⵎⴰⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵜᵉⵜⵜⴼⴻⴽⴽⴰ ⵣⵉ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR10_3","021_10_3","PRO","10","3","3","ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴼ, ⵎⴰⵛⴰ ⵎⴻⵥⵔⵉ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵄⴰⵔⵔⴻⵏ ⵉ-ⵜ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("PR10_4","021_10_4","PRO","10","4","4","ⵡⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵙ ⵓⴼⵓⵙ ⵢⴰⵔⵅⵓⵏ, ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵣⵣⴻⵍⴹ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⵟⵟⴰⵔⴻⵏ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PR10_5","021_10_5","PRO","10","5","5","ⵡⴻⵏⵏⵉ ⵉⵢⴰⵔⵔⵡⴻⵏ ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵉⴼⴻⵀⵀⵎⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⵚⴻⵏ ⴷⵉ ⵜⵎⴻⵢⵔⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR10_6","021_10_6","PRO","10","6","6","ⵍⴱⴰⵔⴰⴽⴰⵜ ⴰⵔⴻⵙⵙⴰⵏⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⵍⵄⵓⵏⴼ ⵉⵙⵙⴷⵓⵔⵔⵓⵢ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_7","021_10_7","PRO","10","7","7","ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵍⴱⴰⵔⴰⴽⴰ, ⵎⴰⵛⴰ ⵉⵙⴻⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵢⴰⵔⵚⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("PR10_8","021_10_8","PRO","10","8","8","ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷⴻⴳ ⵡⵓⵍ, ⴰⴷ ⵉⵇⴱⴻⵍ ⵜⵉⵡⴻⵚⵚⴰ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR10_9","021_10_9","PRO","10","9","9","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⵉⴳⴳⵓⵔ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_10","021_10_10","PRO","10","10","10","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⴻⵎⵎⴰⵣⴻⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵉⵜⵜⴻⴳⴳ ⵍⴻⵃⵔⵉⵇ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR10_11","021_10_11","PRO","10","11","11","ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴷ ⵜⴰⵍⴰ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⵍⵄⵓⵏⴼ ⵉⵙⵙⴷⵓⵔⵔⵓⵢ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_12","021_10_12","PRO","10","12","12","ⴰⵛⵔⴰⵀ ⵜⴻⵙⵙⴻⴽⴽⴰⵔⴰ-ⴷⴷ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⵢⵔⵉ ⵜⴻⵙⵙⴷⵓⵔⵔⵓⵢ ⵎⴰⵔⵔⴰ ⵉⵅⴻⵟⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_13","021_10_13","PRO","10","13","13","ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵜᵉⵜⵜⵡⴰⴼ ⵜⵉⵖⵉⵜ, ⵎⴰⵛⴰ ⴰⵄⵎⵓⴷ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⴱⵓ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR10_14","021_10_14","PRO","10","14","14","ⵉⵎⵉⵖⵉⵙⴻⵏ ⵜⵜⵅⴻⵎⵎⴰⵔⴻⵏ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵉⵜⵜⴰⴷⴻⵙ ⵖⴰⵔ ⵓⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR10_15","021_10_15","PRO","10","15","15","ⵉ ⴱⵓ-ⵡⴰⴳⵍⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵙ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵊⴻⵀⴷⴻⵏ ⵏⵏⴻⵙ, ⵍⴻⴱⵍⴰ ⵏ ⵉⵎⴻⵣⵍⴰⴹ ⴷ ⴰⵀⴻⵍⵍⴻⴽ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_16","021_10_16","PRO","10","16","16","ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⵇⴰ-ⵜⵜ ⵉ ⵜⵓⴷⴰⵔⵜ, ⵍⵎⵓⵏⴻⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵉ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("PR10_17","021_10_17","PRO","10","17","17","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⴰⵇⴰ-ⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵎⵎⵃⴻⵏ ⴷⴻⴳ ⵓⵡⴻⴱⴱⴻⵅ, ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR10_18","021_10_18","PRO","10","18","18","ⵡⵉ ⵉⵜⵜⴻⴼⴼⴰⵔⴻⵏ ⴰⵛⵔⴰⵀⵉ, ⵖⴰⵔⴻⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⵉ ⵉⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⴰⴱⵓⵀⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PR10_19","021_10_19","PRO","10","19","19","ⵖⴰⵔ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵅⴻⵟⵟⵓ ⵉⵏⴻⵇⵇⴻⵚ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵜⵜⴻⴳⴳ ⵙ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR10_20","021_10_20","PRO","10","20","20","ⵏⵏⵓⵇⴰⵔⵜ ⵉⵇⵇⵓⵔⴻⵏ ⴷ ⵉⵍⴻⵙ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵓⵍ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_21","021_10_21","PRO","10","21","21","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵙⵙⴻⵛⵛⴰⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵎⵎⵓⵜⴻⵏ ⵓⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵡⵓⵍ ⵉⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_22","021_10_22","PRO","10","22","22","ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵙⵉⴷⵉ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⴳⵍⴰ, ⴰⵔⴱⴻⵔ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵔⴻⵏⵏⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PR10_23","021_10_23","PRO","10","23","23","ⵉ ⵓⴱⵓⵀⴰⵍⵉ ⵜⴰⵎⴻⴳⴳⵉⵜ ⵏ ⵍⴻⴼⴹⵉⵀⴻⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵓⵔⴰⵔⴻⵜ, ⵎⴰⵛⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴰⴷⴻⴱⴱⴰⵔ ⵙ ⵜⵉⵖⵉⵜ ⴰⵎ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PR10_24","021_10_24","PRO","10","24","24","ⵎⵉⵏ ⵣⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵓⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵜ ⵉⵍⵇⴻⴼ, ⵎⴰⵛⴰ ⴰⵙⵉⵜⴻⵎ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PR10_25","021_10_25","PRO","10","25","25","ⵎⴰⵍⴰ ⵜⴻⵄⴷⵓ-ⴷⴷ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵎⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR10_26","021_10_26","PRO","10","26","26","ⴰⵎ ⴱⵉⵏⵓ ⴰⵙⴻⵎⵎⴰⵎ ⵉ ⵜⴻⵖⵎⴰⵙ ⴷ ⴷⴷⴻⵅⵅⴰⵏ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵓⵎⴻⵄⴳⵓⵣ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_27","021_10_27","PRO","10","27","27","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⵜⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵙⵙⴰⵏ ⵉ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵜⵜⵡⴰⵙⵙⵇⵓⴹⴹⴻⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR10_28","021_10_28","PRO","10","28","28","ⵜⴰⵔⴰⵊⵉⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰⵛⴰ ⵍⴰⵢⴰⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴳⴳⵓⵔ ⴰⴷ ⵉⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR10_29","021_10_29","PRO","10","29","29","ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⴱⵓⵔⵊ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⴷ ⴰⵀⴻⵍⵍⴻⴽ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PR10_30","021_10_30","PRO","10","30","30","ⴰⵎⵙⴻⴳⴳⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵏⵀⴻⵣⵣ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR10_31","021_10_31","PRO","10","31","31","ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵜⵉⵖⵉⵜ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵉⵄⴻⵎⵎⴰⵔ ⵙ ⵍⴻⵅⴷⴰⵄⴰⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("PR10_32","021_10_32","PRO","10","32","32","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵙⵙⵏⴻⵏ ⵎⵉⵏ ⵢⴰⵔⴹⴰⵏ, ⵎⴰⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵉⵙⵙⴻⵏ ⵍⴻⵅⴷⴰⵄⴰⵜ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR11_1","021_11_1","PRO","11","1","1","ⵍⵎⵉⵣⴰⵏ ⴰⵖⴻⵛⵛⴰⵛ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴰⵥⵔⵓ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵜⵜⴰⴼ ⴰⵔⴹⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_2","021_11_2","PRO","11","2","2","ⵎⴰⵍⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵏⵏⴼⴰⵅⴻⵜ, ⵜⵓⵙⴰ-ⴷⴷ ⵓⵍⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵉⵎⵡⴰⴹⵄⴻⵏ ⵜⴻⴵⴰ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PR11_3","021_11_3","PRO","11","3","3","ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵜⵏⴻⴷⴷⴻⵀ ⵉ-ⵜⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ ⵏ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⵜⴰⵍⴻⴷⴷⴻⴵ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_4","021_11_4","PRO","11","4","4","ⴰⴳⵍⴰ ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ ⵖⴰⵔ ⵡⴰⵙⵙ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ, ⵎⴰⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵜᵉⵜⵜⴼⴻⴽⴽⴰ ⵣⵉ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR11_5","021_11_5","PRO","11","5","5","ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵜⵜⴰⵔⵔⴰ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵡⴻⵟⵟⴰ ⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_6","021_11_6","PRO","11","6","6","ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵜⴻⵏ ⵜⴼⴻⴽⴽ, ⵎⴰⵛⴰ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵛⴰⵔⴼⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵥⵔⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_7","021_11_7","PRO","11","7","7","ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⴱⵏⴰⴷⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ, ⵉⴼⵏⴰ ⵍⴰⵢⴰⵙ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵜⵜⵔⴰⵊⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵜⴻⵔⵢⴰⵙⵜ ⴰⴷ ⵉⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR11_8","021_11_8","PRO","11","8","8","ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_9","021_11_9","PRO","11","9","9","ⴰⵎⵏⴰⴼⴻⵇ ⵉⵜⵜⴰⵔⴻⴷⴷⴻⴵ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ ⵙ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR11_10","021_11_10","PRO","11","10","10","ⵜⴰⵏⴷⵉⵏⵜ ⵜᵉⵜⵜⴻⵙⵍⵉⵡⵍⵉⵡ ⵎⴰⵍⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⵍⵉⵃ, ⵓ ⵎⴰⵍⴰ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("PR11_11","021_11_11","PRO","11","11","11","ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR11_12","021_11_12","PRO","11","12","12","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵛⴰ ⵡⵓⵍ ⵉⵎⵜⴻⵏ, ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵜⵜⴻⵙⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR11_13","021_11_13","PRO","11","13","13","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵙ ⵜⴻⵅⴱⴰⵔⵊⵉⵜ, ⵉⵜⵜⵄⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⴷⵉ ⵉⴵⴰ ⴰⵔⵔⵓⵃ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ, ⴰⵇⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR11_14","021_11_14","PRO","11","14","14","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⴰⴷⴻⴱⴱⴰⵔ, ⵉⵡⴻⵟⵟⴰ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵎⵛⴰⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR11_15","021_11_15","PRO","11","15","15","ⵡⴻⵏⵏⵉ ⵉⴹⴻⵎⵎⵏⴻⵏ ⵍⴱⴰⵔⵔⴰⵏⵉ, ⵡⴰⵔ ⴷⴷ ⴰⵙ ⵜᵉⵜⵜⴻⴼⴼⴻⵖ ⵛⴰ ⵎⵍⵉⵃ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵛⵜⵉ ⵅ ⵓⴼⵓⵙ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_16","021_11_16","PRO","11","16","16","ⵜⴰⵎⵖⴰⵔⵜ ⵜᵉⵜⵜⴰⴼ ⴰⵔⴹⴰ, ⵜᵉⵟⵟⴻⴼ ⴷⵉ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PR11_17","021_11_17","PRO","11","17","17","ⴱⵏⴰⴷⴻⵎ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴰⵔ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵇⴻⵙⵙⴰⵃ ⵉⵜⵜⵖⴻⵣⵣⴰ ⴰⵢⵙⵓⵎ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_18","021_11_18","PRO","11","18","18","ⴰⵄⴻⴼⴼⴰⵏ ⵉⵎⴻⵊⵊⴰⵔ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⵖⴻⵛⵛ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⵉⵎⴻⵊⵊⴰⵔ ⵉⵛⵜ ⵏ ⵍⵎⵓⵏⴻⵜ ⵉⵎⴻⵜⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_19","021_11_19","PRO","11","19","19","ⵜⴰⵙⴻⴳⴷⴰ ⵏⵉⵛⴰⵏ ⵜᵉⵜⵜⴰⵡⵉ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴼⴻⵏ ⵍⵖⴰⵔ, ⵢⴰⵔⴻⵣⵣⵓ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_20","021_11_20","PRO","11","20","20","ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵓⵍ ⵉⴼⴰⵔⵖⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵟⵟⴰ ⴷⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_21","021_11_21","PRO","11","21","21","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴱⵍⴰ ⵍⴻⵅⵍⴰⵚ, ⵎⴰⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_22","021_11_22","PRO","11","22","22","ⴰⵎⴻⵛⵏⴰⵡ ⵉⵛⵜ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷⵉ ⵜⵉⵏⵣⴰⵔ ⵏ ⵢⵉⵍⴻⴼ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵛⵏⴰ ⵡⴰⵔ ⴷⵉ ⵉⴵⴰ ⵓⵎⴻⵢⵢⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("PR11_23","021_11_23","PRO","11","23","23","ⵎⴻⵥⵔⵉ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵎⵖⵉⵔ ⵖⴰⵔ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵛⴰ ⵍⴰⵢⴰⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵇⴰ-ⵜ ⵏⵀⵍⴰ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR11_24","021_11_24","PRO","11","24","24","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴱⴻⵟⵟⴰⵏ ⵙ ⵡⴻⵛⵔⵉⵎ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵏⵉ ⴰⵙ ⵄⴰⴷ ⴽⵜⴰⵔ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⴽⵜⴰⵔ ⵅ ⵎⵉⵏ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ, ⵡⴰⵅⵅⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵣⵣⴻⵍⴹ. ");
INSERT INTO rift_vpl VALUES ("PR11_25","021_11_25","PRO","11","25","25","ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⴽⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵊⵉⵡⴻⵏ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⵎⴰⵏ, ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵡⴰⵎⴰⵏ ⵉ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_26","021_11_26","PRO","11","26","26","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵎⵎⴰⵍⴻⵏ ⵉⵎⴻⵏⴷⵉ, ⵉⵏⴻⵄⵄⴻⵍ ⵉ-ⵜ ⵛⵛⴻⵄⴱ, ⵎⴰⵛⴰ ⵍⴱⴰⵔⴰⴽⴰ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵡⴻⵏⵏⵉ ⵉⵣⵏⵓⵣⴰⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR11_27","021_11_27","PRO","11","27","27","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⵟⵟⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵢⴰⵔⴻⵣⵣⵓ ⵎⵉⵏ ⵢⴰⵔⴹⴰⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⴰⵎⴰⵏ ⵍⵖⴰⵔ, ⴰⴷ ⵜ ⵉⵍⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("PR11_28","021_11_28","PRO","11","28","28","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵡⴹⴰ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵜⵜⵏⴻⵄⵏⵉⵄⴻⵏ ⴰⵎ ⵉⴼⴻⵜⵡⴰⵏ ⵉⵣⵉⵣⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR11_29","021_11_29","PRO","11","29","29","ⵡⴻⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⵍⴻⵏ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵡⴰⵔⵜ ⴰⵙⴻⵎⵎⵉⴹ, ⵓ ⴰⴱⵓⵀⴰⵍⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⵓⵍ ⴰⵎⵉⵖⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_30","021_11_30","PRO","11","30","30","ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ ⴷ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵃⴻⵏ ⵍⴻⵄⵎⵓⵔ ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵉⵖⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR11_31","021_11_31","PRO","11","31","31","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⴻⵏⵏⵉ ⵎⴰⵀⵓ ⴰⵄⴻⴼⴼⴰⵏ ⴷ ⵓⵎⴻⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PR12_1","021_12_1","PRO","12","1","1","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵉⵜⵜⴻⵅⵙ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⵡⴻⴱⴱⴻⵅ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵇⴻⴼⴼⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("PR12_2","021_12_2","PRO","12","2","2","ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉⵜⵜⴰⴼ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵉⵏⴻⴽⴽⵡⴰⵏ ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ ⴰⴷ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR12_3","021_12_3","PRO","12","3","3","ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵓⵎⵉ ⵉⵜⵜⴻⴳⴳ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴰⵥⵡⴰⵔ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵏⵀⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("PR12_4","021_12_4","PRO","12","4","4","ⵜⴰⵎⵖⴰⵔⵜ ⵉⵎⴻⵃⴹⴻⵏ ⴷ ⵜⵜⴰⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉ ⵜ ⵢⴰⵔⵔⵉⵏ ⵉⵜⵜⵙⴻⴹⵃⴰ, ⴷ ⵜⴻⵏⵏⵉ ⴰⵎ ⵡⴰⵔⴻⵚⵚⵓⴹ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR12_5","021_12_5","PRO","12","5","5","ⵉⵅⴻⵎⵎⵉⵎⴻⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷ ⵍⵃⴻⵇⵇ, ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⵍⵖⴻⵛⵛ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR12_6","021_12_6","PRO","12","6","6","ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵍⴻⴱⵜⴻⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵎⴰⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR12_7","021_12_7","PRO","12","7","7","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵜⵜⵏⴻⵇⵍⴰⴱⴻⵏ ⵓ ⵡⴰⵔ ⴵⵉⵏ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PR12_8","021_12_8","PRO","12","8","8","ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⵓⵍ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR12_9","021_12_9","PRO","12","9","9","ⵉⵃⵍⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴻⵙⵙⴱⴻⵏ ⵅ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⵏⵏⵄⴻⵏ ⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵖⵔⵓⵎ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵢⴻⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("PR12_10","021_12_10","PRO","12","10","10","ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵙⵙⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵔⵔⴻⵃⵎⴰⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵇⴻⵙⵃⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PR12_11","021_12_11","PRO","12","11","11","ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵣⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵊⵊⴰⵡⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴼⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵅⵡⴰⵏ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵛⴰ ⵡⵓⵍ ⵉⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR12_12","021_12_12","PRO","12","12","12","ⴰⵄⴻⴼⴼⴰⵏ ⵉⵜⵜⴻⵅⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⵔⴰⵛⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴰⵥⵡⴰⵔ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉⵜⵜⵖⵉⵎⴰ ⵉⵜⵜⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("PR12_13","021_12_13","PRO","12","13","13","ⴷⴻⴳ ⵓⵅⴻⵟⵟⵓ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⵏⵊⴻⵎ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR12_14","021_12_14","PRO","12","14","14","ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⵊⵉⵡⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵍⵅⵉⵔ, ⵎⵉⵏ ⴷⴷ-ⵜⵜⴰⵡⵢⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⴷⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR12_15","021_12_15","PRO","12","15","15","ⴰⴱⵔⵉⴷ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵛⵛⵡⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵉⵖⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR12_16","021_12_16","PRO","12","16","16","ⴰⴱⵓⵀⴰⵍⵉ ⵉⵙⵙⵛⴰⵏⴰ ⵍⵀⴻⵎⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⵉⵊⵊ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵜⵜⵏⴻⵏ, ⵉⵜⵜⴷⴰⵍⴰ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR12_17","021_12_17","PRO","12","17","17","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵏⴻⵟⵟⵇⴻⵏ ⵜⵉⴷⴻⵜⵜ, ⵉⵙⵙⵛⴰⵏⴰ ⵜⴰⵙⴻⴳⴷⴰ, ⵎⴰⵛⴰ ⴰⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵉⵙⵙⵛⴰⵏⴰ ⴰⵛⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR12_18","021_12_18","PRO","12","18","18","ⴰⵇⴰ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵀⴰⵔⵡⴰⴹⴻⵏ ⴰⵎ ⵜⴻⵊⵊⵓⵜ ⵏ ⵙⵙⵉⴼ, ⵎⴰⵛⴰ ⵉⵍⴻⵙ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⴳⴻⵏⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("PR12_19","021_12_19","PRO","12","19","19","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⵜⵡⴰⴹⵎⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵉⵍⴻⵙ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵎⵖⵉⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR12_20","021_12_20","PRO","12","20","20","ⴰⵛⵎⴰⵜ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⴻⴽⴽⵡⴰⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵙⵙⵃⴻⵏ ⵍⴻⵀⵏⴰ, ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR12_21","021_12_21","PRO","12","21","21","ⴰⵎⵙⴻⴳⴳⴻⴷ ⵡⴰⵔ ⵜ ⵉⵍⴻⵇⵇⴻⴼ ⵍⵖⴻⵛⵛ, ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR12_22","021_12_22","PRO","12","22","22","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵎⵚⵓⵔⵔⵓⴼⴻⵏ ⵙ ⵍⴰⵎⴰⵏ ⵢⴰⵔⴹⴰⵏ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR12_23","021_12_23","PRO","12","23","23","ⴱⵏⴰⴷⴻⵎ ⵉⴼⴻⵜⵏⴻⵏ ⵉⵙⵙⴷⵓⵔⵔⵓⵢ ⵜⵓⵙⵙⵏⴰ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵓⵍ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉⵙⵖⵓⵢⵢⵓ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PR12_24","021_12_24","PRO","12","24","24","ⴰⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⴰⴷ ⵉⵃⴽⴻⵎ, ⵎⴰⵛⴰ ⵍⴻⵄⴳⴻⵣ ⵉⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PR12_25","021_12_25","PRO","12","25","25","ⴰⵎⵏⵓⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵙⵙⵀⴻⴽⴽⵡⴰ ⵉ-ⵜ, ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵉⵚⴻⴱⵃⴻⵏ ⵉⵙⵙⴼⴰⵔⵔⴰⵃ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR12_26","021_12_26","PRO","12","26","26","ⴰⵎⵙⴻⴳⴳⴰⴷ ⵉⵙⵙⵛⴰⵏⴰ ⴰⴱⵔⵉⴷ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴱⵔⵉⴷ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR12_27","021_12_27","PRO","12","27","27","ⴰⵎⴻⵄⴳⵓⵣ ⵡⴰⵔ ⵉⴹⴻⴼⴼⴰⵔ ⵛⴰ ⴰⵏⴻⵢⵎⴰⵔ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⴰⴳⵍⴰ ⵉⵖⵍⴰⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⵇⴰ ⴷ ⴰⵎⵃⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PR12_28","021_12_28","PRO","12","28","28","ⴷⴻⴳ ⵓⵎⴻⵙⵔⵓⵇ ⵏ ⵜⵙⴻⴳⴷⴰ ⵜⴻⴵⴰ ⵜⵓⴷⴰⵔⵜ, ⴰⴱⵔⵉⴷ ⵏ ⵍⴰⵜⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR13_1","021_13_1","PRO","13","1","1","ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷ ⵚⵚⵉⴼⴻⵜ ⵏ ⵓⵡⴻⴱⴱⴻⵅ ⵏ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵖⴰⵔ ⵓⵜⴻⵅⵜⵉⵅ. ");
INSERT INTO rift_vpl VALUES ("PR13_2","021_13_2","PRO","13","2","2","ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵢⴻⵛⵛ ⴱⵏⴰⴷⴻⵎ ⵍⵅⴰⵔ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵢⴻⵛⵛ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("PR13_3","021_13_3","PRO","13","3","3","ⵡⴻⵏⵏⵉ ⵢⴻⵙⵙⴰⵔⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵉⵃⴻⵟⵟⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵎⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ, ⵉⵜⵜⵔⴰⵊⴰ ⵜ ⵓⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR13_4","021_13_4","PRO","13","4","4","ⵍⴻⵄⵎⴰⵔ ⵏ ⵓⵎⴻⵄⴳⵓⵣ ⵢⴰⵔⵊⴻⴼ, ⵡⴰⵅⵅⴰ ⴰⵢⴰ ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ ⴷⵉ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⵟⵟⴰⵔⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵊⵉⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR13_5","021_13_5","PRO","13","5","5","ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵉⵛⴰⵔⵔⴻⵀ ⵉ-ⵜⴻⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵎⴰⵛⴰ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵙⵙⴰⵔⵣⴰⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉⵙⵙⴼⴻⵟⵟⴰⵃ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PR13_6","021_13_6","PRO","13","6","6","ⵜⴰⵙⴻⴳⴷⴰ ⵜⵃⴻⵟⵟⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴰⴷ ⵜ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⴰⵎⴻⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PR13_7","021_13_7","PRO","13","7","7","ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵡⴰⵍⵓ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵎⴻⵣⵍⴰⴹ, ⵡⴰⵅⵅⴰ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR13_8","021_13_8","PRO","13","8","8","ⴷⴷⴻⵢⵢⴻⵜ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴷ ⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵎⴻⵣⵍⵓⴹ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵀⵓⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR13_9","021_13_9","PRO","13","9","9","ⵜⴰⴼⴰⵡⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵜⴰⵔⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰⵛⴰ ⵍⴻⴼⵏⴰⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⵅⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PR13_10","021_13_10","PRO","13","10","10","ⵣⵉ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵎⵖⵉⵔ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴽⴻⵙⵙⵉⵏ ⴰⵛⴰⵡⴰⵔ, ⵖⴰⵔⵙⴻⵏ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PR13_11","021_13_11","PRO","13","11","11","ⴰⴳⵍⴰ ⵏ ⴷⴻⵖⵢⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴷⵔⵓⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵢⴰⵔⵔⵡⴻⵏ ⵙ ⵓⴼⵓⵙ, ⴰⴷ ⵢⴰⵔⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PR13_12","021_13_12","PRO","13","12","12","ⵍⴰⵢⴰⵙ ⵢⵓⵢⵍⴻⵏ ⵉⵙⵙⵄⵉⴵⴰ ⵓⵍ, ⵎⴰⵛⴰ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵎⴻⵥⵔⵉ ⵉⵛⵛⵓⵔⴻⵏ, ⴰⵇⴰ ⵜⵜ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR13_13","021_13_13","PRO","13","13","13","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⴰⵡⴰⵍ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵇⵇⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PR13_14","021_13_14","PRO","13","14","14","ⵜⴰⵖⵓⵔⵉ ⵏ ⵓⵎⵉⵖⵉⵙ ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵍⵡⴻⵍ ⴱⵏⴰⴷⴻⵎ ⵉ ⵜⴻⵅⵛⵉⴼⵉⵏ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR13_15","021_13_15","PRO","13","15","15","ⵍⴻⵄⵇⴻⵍ ⵉⵚⴻⴱⵃⴻⵏ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵔⴹⴰ, ⵎⴰⵛⴰ ⴰⴱⵔⵉⴷ ⵏ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⵇⴰ ⵉⵇⵙⴻⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR13_16","021_13_16","PRO","13","16","16","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵜⵜⵏⴻⵏ, ⵉⵅⴻⴷⴷⴻⵎ ⵙ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⵜⴰⵖⵢⵓⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR13_17","021_13_17","PRO","13","17","17","ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵡⴻⵟⵟⴰ ⴷⵉ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⴳⴻⵏⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("PR13_18","021_13_18","PRO","13","18","18","ⵣⵣⵍⴻⴹ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴰⵇⴰ ⴰⵜⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵢⵓⴳⵉⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⴰⵡⴻⴱⴱⴻⵅ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵡⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR13_19","021_13_19","PRO","13","19","19","ⵉⵊⵊ ⵏ ⵓⵙⵉⵜⴻⵎ ⵉⵛⵛⵓⵔⴻⵏ ⴷ ⴰⵎⵉⵥⵉⴷ ⵉ ⵍⴻⵄⵎⴰⵔ, ⵎⴰⵛⴰ ⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷ ⵏⵏⵄⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR13_20","021_13_20","PRO","13","20","20","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵎⵚⵓⵔⵔⵓⴼⴻⵏ ⴰⴽ-ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⴰⴷ ⵜ ⵉⵍⵇⴻⴼ ⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("PR13_21","021_13_21","PRO","13","21","21","ⵍⵖⴰⵔ ⴰⴷ ⵉⴹⴼⴰⵔ ⵉⵎⴻⴷⵏⴰⴱ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵜ ⵅⴻⴵⴹⴻⵏ ⵙ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR13_22","021_13_22","PRO","13","22","22","ⵡⴻⵏⵏⵉ ⵉⵚⴻⴱⵃⴻⵏ ⵉⵜⵜⴻⵊⵊⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵡⴰⵢⵢⴰⵡⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴳⵍⴰ ⵏ ⴰⵢⵜ-ⴱⵓ-ⴷⴷⵏⵓⴱ ⵉⵜⵜⵡⴰⵅⴻⵎⵎⴻⵍ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR13_23","021_13_23","PRO","13","23","23","ⴰⵔⴱⴻⵔ ⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵎⴰⵛⵛⴰ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵍⴰⵎⵉ ⴷⵉⵏ ⴰⵏⵇⴰⵙ ⵏ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PR13_24","021_13_24","PRO","13","24","24","ⵡⴻⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⴰⵄⵎⵓⴷ ⵏⵏⴻⵙ, ⵉⵛⴰⵔⵀ ⵎⵎⵉⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵉⵜⵜⴻⴽⴽⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ ⴷⵉ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("PR13_25","021_13_25","PRO","13","25","25","ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⵛⵛ ⴰⵍ ⵖⴰ ⵉⵊⵊⴰⵡⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵄⴻⴷⴷⵉⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴻⵃⵡⴰⵊⴰ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_1","021_14_1","PRO","14","1","1","ⵜⵉⵖⵉⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⴱⴻⵏⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵜⵀⴻⴷⴷⴻⵎ ⵉ-ⵜⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR14_2","021_14_2","PRO","14","2","2","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏⵏⴻⵙ, ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR14_3","021_14_3","PRO","14","3","3","ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⴰⵇⴰ ⴷⵉⵏ ⵍⵎⴻⵛⵄⴻⴹ ⵉ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵃⴻⵟⵟⴰⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_4","021_14_4","PRO","14","4","4","ⵎⴰⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵉⵜⵜⵖⵉⵎⴰ ⵍⵎⴻⴷⵡⴻⴷ ⵉⵅⵡⴰ ⵎⴰⵛⴰ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵇⴰ ⴷⵉⵏ ⵚⵚⴰⴱⴻⵜ ⵜⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR14_5","021_14_5","PRO","14","5","5","ⴰⵛⴻⵀⵀⴰⴷ ⴷ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵛⴰ, ⵎⴰⵛⴰ ⴰⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵉⵜⵜⵙⵓⴹ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_6","021_14_6","PRO","14","6","6","ⵉ ⵓⵎⴻⵙⵜⴻⵀⵣⵉⵢ ⵡⴰⵔ ⴷⵉⵏ ⵜⵉⵖⵉⵜ ⵅⵎⵉ ⵜⵜ ⵢⴰⵔⴻⵣⵣⵓ, ⵎⴰⵛⴰ ⵉ ⵓⴼⴻⵀⵀⴰⵎ ⵉⵀⵡⴻⵏ ⵅⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴼ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_7","021_14_7","PRO","14","7","7","ⴰⴳⴳⵯⴻⵊ ⵅ ⵡⴻⵔⵢⴰⵣ ⴰⴱⵓⵀⴰⵍⵉ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜᵉⵜⵜⵉⴼⴻⴷ ⵛⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_8","021_14_8","PRO","14","8","8","ⵜⵉⵖⵉⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵜⵜⵏⴻⵏ ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷ ⴰⵛⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR14_9","021_14_9","PRO","14","9","9","ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵙⵜⴻⵀⵣⴰⵏ ⵙ ⵡⴻⵄⴷⴰⵍ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⵎⴰⵛⴰ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵜⵜⵡⴰⴼ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR14_10","021_14_10","PRO","14","10","10","ⵓⵍ ⵉⵙⵙⴻⵏ ⵜⴰⵔⵣⵓⴳⵉ ⵏⵏⴻⵙ, ⵍⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵛⴰ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR14_11","021_14_11","PRO","14","11","11","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵎⴰⵛⴰ ⵜⴰⵇⵉⴹⵓⵏⵜ ⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵜᵉⵏⵏⴻⵡⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR14_12","021_14_12","PRO","14","12","12","ⴰⴷ ⵜⴰⵖ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⵇⴰ ⴰⴱⵔⵉⴷ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR14_13","021_14_13","PRO","14","13","13","ⵡⴰⵅⵅⴰ ⵖⴰⵔ ⵡⴻⴹⵃⴰⵛ ⵓⵍ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵃⵔⵉⵇ, ⵡⴰⵀ, ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹ-ⴷⴷ ⴰⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_14","021_14_14","PRO","14","14","14","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵍ ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵊⵉⵡⴻⵏ ⵙ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵓ ⴰⵔⵢⴰⵣ ⴰⵚⴻⴱⵃⴰⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR14_15","021_14_15","PRO","14","15","15","ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵃⴰⴼⵉ, ⵉⵜⵜⴰⵎⴻⵏ ⴷⵉ ⴽⵓⵍ ⴰⵡⴰⵍ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵜⵜⵏⴻⵏ ⵉⵃⴻⵟⵟⴰ ⴰⵚⵓⵔⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR14_16","021_14_16","PRO","14","16","16","ⴰⵎⵉⵖⵉⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵓ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵅ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵙⴻⵄⵄⴰⵔ, ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_17","021_14_17","PRO","14","17","17","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵢⵢⴰⵇⴻⵏ ⴷⴻⵖⵢⴰ, ⴰⴷ ⵉⴳⴳ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵓ ⴰⵔⵢⴰⵣ ⵉⵏⴻⴽⴽⵡⴰⵏ ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵛⴰⵔⵀ. ");
INSERT INTO rift_vpl VALUES ("PR14_18","021_14_18","PRO","14","18","18","ⵉⵃⴰⴼⵉⵢⵢⴻⵏ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴼⴻⵜⵜⵏⴻⵏ, ⴰⴷ ⴰⵙⴻⵏ ⵇⵇⵏⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵏ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_19","021_14_19","PRO","14","19","19","ⵉⵖⴻⵛⵛⴰⵛⴻⵏ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ, ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_20","021_14_20","PRO","14","20","20","ⴰⵎⴻⵣⵍⵓⴹ ⵉⵛⴰⵔⵔⴻⵀ ⵉ-ⵜ ⵄⴰⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵟⵟⴰⵙ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_21","021_14_21","PRO","14","21","21","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵉⵜⵜⴻⴳⴳ ⴷⴷⵏⵓⴱ, ⵎⴰⵛⴰ ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⵉⵏⵏⴰⵏ ⵅ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_22","021_14_22","PRO","14","22","22","ⵉⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⴵⵇⴻⵏ ⵍⵖⴰⵔ, ⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴻⴷⴷⴰⵔⵉⵏ ⵏⵉⵜⵏⵉ? ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⴰⵇⴰ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⴷⵉ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_23","021_14_23","PRO","14","23","23","ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵡⴻⵃⵍⴰⵏ ⵏ ⵡⴰⵔⴱⴻⵔ ⴷⴰⵢⴻⵙ ⵍⴻⴼⴹⴻⵍ, ⵎⴰⵛⴰ ⵍⵀⴰⵔⴷ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵡⴻⵃⵡⴰⵊ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_24","021_14_24","PRO","14","24","24","ⵜⵜⴰⵊ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ, ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_25","021_14_25","PRO","14","25","25","ⴰⵛⴻⵀⵀⴰⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵉⵙⵙⴻⵏⵊⴰⵎ ⵍⴻⵄⵎⵓⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵅⵅⵓⵏ ⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵛⴻⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR14_26","021_14_26","PRO","14","26","26","ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷⴰⵢⴻⵙ ⵜⵜⵉⵇⴻⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR14_27","021_14_27","PRO","14","27","27","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵣⴻⴳ ⵉⵛⴻⴷⴷⵉⵢⴻⵏ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR14_28","021_14_28","PRO","14","28","28","ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵅⴻⵎⵎⴻⵍ ⵓⵛⴻⵡⵡⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵛⴰ ⴷⵉ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵛⵛⴻⵄⴱ ⵉⵅⴻⵎⵎⴻⵍ ⵓⵀⴻⵍⵍⴻⴽ ⵏ ⵍⵃⴰⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR14_29","021_14_29","PRO","14","29","29","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⵖⴰⵔⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵜⴻⵎⵖⴰⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⴱⵓⵃⴱⴻⵍ ⵉⵃⵚⴰⵔⴻⵏ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PR14_30","021_14_30","PRO","14","30","30","ⵓⵍ ⵉⵚⵚⴻⵃ, ⴰⵇⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⵜⵓⵙⵎⵉ ⴷ ⴰⵔⴻⵚⵚⵓⴹ ⵏ ⵢⴻⵖⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_31","021_14_31","PRO","14","31","31","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⵎⴻⵃⴷⴰⵊ, ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉ-ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⵉⵏⵏⴰⵏ ⵅ ⵓⵎⴻⵣⵍⵓⴹ, ⵉⵜⵜⵛⴻⵏⵏⴻⵄ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR14_32","021_14_32","PRO","14","32","32","ⴰⵄⴻⴼⴼⴰⵏ ⵉⵜⵜⴰⵥⵥⴻⵍ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵍⵖⴰⵔ ⵏⵏⴻⵙ ⵉ ⵉⵜⵜⴻⴳⴳ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵍ ⵄⴰⴷ ⴷⵉ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR14_33","021_14_33","PRO","14","33","33","ⵜⵉⵖⵉⵜ ⵜⴰⵔⵙⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵉⴼⴻⵀⵀⴰⵎⴻⵏ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⴷⴻⴳ ⵉⴱⵓⵀⴰⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR14_34","021_14_34","PRO","14","34","34","ⵜⴰⵙⴻⴳⴷⴰ ⵜⴻⵙⵙⵄⵓⴵⴰ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵛⵛⵓⵄⵓⴱ ⴷ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PR14_35","021_14_35","PRO","14","35","35","ⵍⵅⴰⴹⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵔⵙⴰ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⴼⴻⵀⵀⵎⴻⵏ ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴼⴻⵟⵟⵃⴻⵏ ⵉⵍⴻⵇⵇⴻⴼ ⵉ-ⵜ ⵓⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵙ ⵏ ⵓⴼⵓⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR15_1","021_15_1","PRO","15","1","1","ⵜⵡⴰⵔⵔⵉⵜ ⵉⴼⵙⵓⵙⴻⵏ ⵜⴻⵙⵙⴻⵙⵎⴰⴹ ⴰⵅⴻⵢⵢⴻⵇ, ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵉⵜⵜⴻⵇⵇⵙⴻⵏ ⵉⵙⵙⴻⴽⴽⴰⵔⴰ-ⴷⴷ ⴰⵅⴻⵢⵢⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("PR15_2","021_15_2","PRO","15","2","2","ⵉⵍⴻⵙ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵉⵊⴻⴱⴱⴻⴷ ⵜⵓⵙⵙⵏⴰ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵎⴰⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PR15_3","021_15_3","PRO","15","3","3","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ, ⵜⵜⵃⴻⴽⴽⴰⵔⴻⵏⵜ ⵉ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_4","021_15_4","PRO","15","4","4","ⵉⵍⴻⵙ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵏⴼⴰⵏ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⴰⵔⵔⵀⴰⵊ ⵏⵏⴻⵙ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⴱⵓⵃⴱⴻⵍ.    ");
INSERT INTO rift_vpl VALUES ("PR15_5","021_15_5","PRO","15","5","5","ⴰⴱⵓⵀⴰⵍⵉ ⵉⵏⴻⵟⵟⴰⵔ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⴻⴽⴽⴰⵔⴰⵏ ⵉ ⵓⵡⴻⴱⴱⴻⵅ, ⴰⵇⴰ ⵉⴼⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_6","021_15_6","PRO","15","6","6","ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ ⴷⴰⵢⴻⵙ ⵍⴽⴻⵏⵣ ⵉⵎⵖⴰⵔ, ⵎⴰⵛⴰ ⴷⵉ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵡⵉ ⵓⵄⴻⴼⴼⴰⵏ ⴷⴰⵢⴻⵙ ⵜⴰⵎⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR15_7","021_15_7","PRO","15","7","7","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⵓⵍ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_8","021_15_8","PRO","15","8","8","ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵉⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⵇⴰ-ⵜⵜ ⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR15_9","021_15_9","PRO","15","9","9","ⴰⴱⵔⵉⴷ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴰⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PR15_10","021_15_10","PRO","15","10","10","ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵉⵇⴻⵙⵃⴻⵏ ⵜⵍⴻⵇⵇⴻⴼ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵎⵃⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⵡⴻⴱⴱⴻⵅ, ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR15_11","021_15_11","PRO","15","11","11","ⵍⴰⵅⴰⵔⵜ ⴷ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵓⵀⴻⵍⵍⴻⴽ ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⴻⵣⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵡⵓⵍⴰⵡⴻⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("PR15_12","021_15_12","PRO","15","12","12","ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵡⴻⴱⴱⵅⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵔⵉⵃ ⵛⴰ ⵖⴰⵔ ⵉⵎⵉⵖⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_13","021_15_13","PRO","15","13","13","ⵓⵍ ⵉⴼⴰⵔⵃⴻⵏ ⵉⵜⵜⴻⴳⴳ ⵓⴷⴻⵎ ⵉⵛⵏⴰⵏ, ⵎⴰⵛⴰ ⴰⵎⵏⵓⵙ ⴷⴻⴳ ⵡⵓⵍ ⵉⵙⴻⴽⴽⴻⴼ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR15_14","021_15_14","PRO","15","14","14","ⵓⵍ ⵉⴼⴻⵀⵀⵎⴻⵏ ⵢⴰⵔⴻⵣⵣⵓ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉⵙⵙⴻⵛⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PR15_15","021_15_15","PRO","15","15","15","ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵎⴰⵛⴰ ⵓⵍ ⵉⴼⴰⵔⵃⴻⵏ ⴰⵎ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_16","021_15_16","PRO","15","16","16","ⵉⵃⵍⴰ ⴷⵔⵓⵙ ⴰⴽ-ⴷ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ, ⵅ ⵉⵊⵊ ⵏ ⵍⴽⴻⵏⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵍⴻⵃⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR15_17","021_15_17","PRO","15","17","17","ⵉⵃⵍⴰ ⵉⵊⵊ ⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵍⵅⵓⴹⴰⵔⵜ ⵎⴰⵏⵉ ⵜⵃⴻⴽⴽⴻⵎ ⵜⴰⵢⵔⵉ, ⵅ ⵉⵊⵊ ⵏ ⵓⵢⴻⵏⴷⵓⵣ ⵉⵚⴻⵃⵃⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵛⵔⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("PR15_18","021_15_18","PRO","15","18","18","ⴰⵔⵢⴰⵣ ⵉⵜⵜⴰⵔⵔⵓⵊⴷⵓⴷⴻⵏ ⵉⵙⵙⴻⴽⴽⴰⵔⴰ ⵉⵎⴻⵏⵖⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵉⵙⵙⴻⵅⵙⴰⵢ ⴰⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PR15_19","021_15_19","PRO","15","19","19","ⴰⴱⵔⵉⴷ ⵏ ⵓⵎⴻⵄⴳⵓⵣ ⴰⵎ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⴰⵎⴻⵙⵔⵓⵇ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR15_20","021_15_20","PRO","15","20","20","ⵎⵎⵉⵙ ⴰⵎⵉⵖⵉⵙ ⵉⵙⵙⴼⴰⵔⵔⴻⵃ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR15_21","021_15_21","PRO","15","21","21","ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⴱⵓ ⵡⵓⵍ ⵉⵎⵜⴻⵏ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⴳⴳⵓⵔ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_22","021_15_22","PRO","15","22","22","ⵉⵏⵡⴰⵢⴻⵏ ⴼⴻⵛⵛⵍⴻⵏ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵛⵛⵡⴰⵔ, ⵎⴰⵛⴰ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵡⴰⵢ.    ");
INSERT INTO rift_vpl VALUES ("PR15_23","021_15_23","PRO","15","23","23","ⴰⵔⵢⴰⵣ ⵖⴰⵔⴻⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⵉ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⵎⴻⵛⵃⴰⵍ ⵉⵚⴱⴻⵃ ⵡⴰⵡⴰⵍ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PR15_24","021_15_24","PRO","15","24","24","ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⴼⴻⵀⵀⴰⵎ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵍⴰⵅⴰⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("PR15_25","021_15_25","PRO","15","25","25","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⴰⴷ ⵜⵜ ⵉⵇⵍⴻⵄ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴰⵢⵎⵉⵔ ⵏ ⵢⴻⵢⵢⴰⵔ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵉⵙⵙⴻⵎⵜⴰⵏ ⵉ-ⵜ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PR15_26","021_15_26","PRO","15","26","26","ⵉⵅⴻⵎⵎⵉⵎⴻⵏ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_27","021_15_27","PRO","15","27","27","ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⴰⵔⴱⴻⵃ ⵉⵖⴻⵟⵟⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⴰⵔⵔⵥⵉⵢⵢⴻⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵜⴰⵔⵣⵉⴼⵉⵏ, ⴰⴷ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR15_28","021_15_28","PRO","15","28","28","ⵓⵍ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ, ⵎⴰⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⴼⴻⵢⵢⴻⴹ ⵙ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR15_29","021_15_29","PRO","15","29","29","ⵉⴳⴳⵯⴻⵊ ⵙⵉⴷⵉ ⵅ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉⵜⵜⴻⵙⵍⴰ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR15_30","021_15_30","PRO","15","30","30","ⵜⴰⴼⴰⵡⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵜⴻⵙⵙⴼⴰⵔⵔⴻⵃ ⵓⵍ, ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉⵙⵙⵢⵓⵎⴰ ⵉⵖⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_31","021_15_31","PRO","15","31","31","ⴰⵎⴻⵣⵣⵓⵖ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵖⴰⵔ ⵓⵡⴻⴱⴱⴻⵅ ⵉ ⵜⵓⴷⴰⵔⵜ, ⴰⴷ ⵉⵙⵙⴻⵏⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR15_32","021_15_32","PRO","15","32","32","ⵡⴻⵏⵏⵉ ⵉⵏⴻⵟⵟⴰⵔⴻⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵖⴰⵔ ⵓⵡⴻⴱⴱⴻⵅ, ⵉⵙⵙⵢⴰⵡⴰⵏ ⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR15_33","021_15_33","PRO","15","33","33","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵖⴰⵔ ⵜⵉⵖⵉⵜ, ⵓ ⴰⵡⴰⴹⴻⵄ ⵉⵜⵜⵉⵣⵡⴰⵔ ⵉ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR16_1","021_16_1","PRO","16","1","1","ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⴰⵎⵡⴰⵔⵔⵉⵜ ⵏ ⵢⵉⵍⴻⵙ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR16_2","021_16_2","PRO","16","2","2","ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵡⴻⵔⵢⴰⵣ ⵚⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵜⵜⵇⴻⴵⴰⴱ ⴱⵓⵃⴱⴻⵍⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_3","021_16_3","PRO","16","3","3","ⵙⴰⵔⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⴻⵜⵜⵏⴻⵏ ⵉⵏⵡⴰⵢⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR16_4","021_16_4","PRO","16","4","4","ⵙⵉⴷⵉ ⵉⵅⵍⴻⵇ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉ ⵍⵖⴰⵔⴰⴹ ⵏⵏⴻⵙ, ⵄⴰⴷ ⵓⵍⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵉⴳⴳⴰ ⵉ-ⵜ ⵉ ⵡⴰⵙⵙ ⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR16_5","021_16_5","PRO","16","5","5","ⴽⵓⵍ ⴰⵎⵄⴻⴼⴼⴰⵔ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⴰⴼⵓⵙ ⵅⴰⵙ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⴰⴱⴰⵔⵔⵉ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("PR16_6","021_16_6","PRO","16","6","6","ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵅ ⵍⵖⴻⵛⵛ, ⵓ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵡⴻⵔⵢⴰⵣ ⵅ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR16_7","021_16_7","PRO","16","7","7","ⵎⴰⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵢⴰⵔⵔ ⵏⴻⵜⵜⴰ ⵓⵍⴰ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⴽⵉⴷⴻⵙ ⴳⴳⴻⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR16_8","021_16_8","PRO","16","8","8","ⵉⵃⵔⴰ ⴷⵔⵓⵙ ⴰⴽ-ⴷ ⵜⵙⴻⴳⴷⴰ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴱⵍⴰ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PR16_9","021_16_9","PRO","16","9","9","ⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⴻⴷⴷⴻⵀ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR16_10","021_16_10","PRO","16","10","10","ⵍⵃⵓⴽⵎ ⴱⵍⴰ ⴰⴷⵡⴰⵍ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉ ⴷⴻⴳ ⵡⴻⵃⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PR16_11","021_16_11","PRO","16","11","11","ⵍⵎⵉⵣⴰⵏ ⵏⵉⵛⴰⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵏ ⵍⵎⵉⵣⴰⵏ ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵥⵔⴰ ⵏ ⵍⴻⵡⵣⴻⵏ ⴷⵉ ⵜⴻⵛⵢⴰⵔⵜ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR16_12","021_16_12","PRO","16","12","12","ⴷ ⵏⵏⵄⵉ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵅⵎⵉ ⵖⴰ ⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵎⴰⵖⴰⵔ ⵍⵄⴰⵔⵛ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⵣⵉ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR16_13","021_16_13","PRO","16","13","13","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵜⵜⴻⵄⵊⵉⴱⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵏⵉⵛⴰⵏ, ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PR16_14","021_16_14","PRO","16","14","14","ⴰⵙⵄⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⴰⵎⵉⵖⵉⵙ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵜ ⵉ-ⴷⴷ ⵢⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("PR16_15","021_16_15","PRO","16","15","15","ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⴻⴵⴰ ⵜⵓⴷⴰⵔⵜ, ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⴰⵎ ⵓⵙⴻⵢⵏⵓ ⵏ ⵡⴻⵏⵥⴰⵔ ⴷⵉ ⵜⴻⴼⵙⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_16","021_16_16","PRO","16","16","16","ⴰⵇⴰ ⵜⴻⵃⵍⴰ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵏ ⵜⵉⵖⵉⵜ ⵅ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⵓ ⵎⴻⵛⵃⴰⵍ ⴽⵜⴰⵔ ⴰⴷ ⵜⵉⵍⵉ ⵜⵡⴰⴼⵉⵜ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵙⴻⵏⵏⴻⵊ ⵅ ⵜⵡⴰⴼⵉⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_17","021_16_17","PRO","16","17","17","ⴰⴱⵔⵉⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵅ ⵍⵖⴰⵔ. ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵉⵃⴻⵟⵟⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR16_18","021_16_18","PRO","16","18","18","ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵜᵉⵜⵜⵉⵣⵡⴰⵔ-ⴷⴷ ⵉ ⴰⵔⵥⵥⵉⵢⵢⴻⵜ, ⵓ ⵏⵏⴼⴰⵅⴻⵜ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵇⴱⴻⵍ ⵉ ⵓⵡⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("PR16_19","021_16_19","PRO","16","19","19","ⵉⵃⵍⴰ ⴰⵇⵏⴰⵄ ⵏ ⴱⵓⵃⴱⴻⵍ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵅ ⵓⴱⴻⵟⵟⵓ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴰⴽ-ⴷ ⴰⵢⵜ-ⵏⵏⴼⴰⵅⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_20","021_16_20","PRO","16","20","20","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⵎⵍⵉⵃ ⴷⵉ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⴰⴷ ⵢⴰⴼ ⵍⵅⴰⵔ, ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR16_21","021_16_21","PRO","16","21","21","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⵓⵍ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴰⴷ ⵜ ⵙⴻⵎⵎⴰⵏ ⴱⵓ-ⵡⴻⴼⵜⴰⵏ, ⵓ ⵜⴰⵥⵢⵓⴷⵉ ⵏ ⵍⵀⴰⵔⴷ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵜⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_22","021_16_22","PRO","16","22","22","ⵍⴻⵄⵇⴻⵍ ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR16_23","021_16_23","PRO","16","23","23","ⵓⵍ ⵏ ⵓⵎⵉⵖⵉⵙ ⵉⵜⵜⴰⵔⵔⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉⴼⴻⵀⵀⴻⵎ, ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR16_24","021_16_24","PRO","16","24","24","ⴰⵡⴰⵍⴻⵏ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴳⴳⵉⵏ ⴰⵎ ⵜⴰⵎⵎⴻⵏⵜ ⵏ ⵜⴻⵖⵔⴰⵙⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵉⵥⵉⴷⴻⵏ ⵉ ⵍⴻⵄⵎⴰⵔ ⴷ ⵓⴳⴻⵏⴼⵓ ⵉ ⵢⴻⵖⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR16_25","021_16_25","PRO","16","25","25","ⴰⴷ ⵜⴰⵖ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⵇⴰ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_26","021_16_26","PRO","16","26","26","ⵍⴰⵥ ⵏ ⵓⵛⴻⵡⵡⴰⵍ ⵉⵅⴻⴷⴷⴻⵎ ⴰⵙ ⵉ ⵏⴻⵜⵜⴰ, ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉⵏⴻⴷⴷⴻⵀ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_27","021_16_27","PRO","16","27","27","ⴰⵔⵢⴰⵣ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵉⵖⴻⵣⵣⴰ ⵍⵖⴰⵔ, ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⵛⴻⵄⵄⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR16_28","021_16_28","PRO","16","28","28","ⴰⵔⵢⴰⵣ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⵅⴷⴰⵄⴰⵜ ⵉⵙⵙⴻⴽⴽⴰⵔⴰ ⴰⵎⴻⵏⵖⵉ, ⵓ ⴰⵅⴱⴰⵔⵊⵉ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵄⴰⴷ ⴰⴱⴻⵟⵟⵓ ⴰⴽ-ⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR16_29","021_16_29","PRO","16","29","29","ⴰⵔⵢⴰⵣ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⵉⵜⵜⵖⴰⵔⵔⴰ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵉⵏⴻⴷⴷⴻⵀ ⵉ-ⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PR16_30","021_16_30","PRO","16","30","30","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵇⵇⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵔⴱⴰⵜ ⵏ ⵍⴻⵅⴷⴰⵄⴻⵜ, ⵉⵜⵜⴽⴻⵎⵎⴻⵛ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴷⴰ ⵉⴳⴳⴰ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR16_31","021_16_31","PRO","16","31","31","ⴰⵛⵓⵡⵡⴰⴼ ⵉⵛⴰⴱⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵉⵣⴻⵡⵡⵇⴻⵏ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵜ ⵜⴰⴼⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR16_32","021_16_32","PRO","16","32","32","ⵉⵃⵍⴰ ⴱⵓ-ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴱⴱⴰⵜⴻⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵉⵃⵍⴰ ⵅ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵡⵡⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PR16_33","021_16_33","PRO","16","33","33","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ, ⵎⴰⵛⴰ ⵎⴽⵓⵍ ⴰⵔⵔⴰⵢ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR17_1","021_17_1","PRO","17","1","1","ⵉⵃⵍⴰ ⵉⵊⵊ ⵏ ⵓⵣⴻⵄⵄⵉⴼ ⵏ ⵡⴻⵖⵔⵓⵎ ⵢⵓⵥⵖⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵀⵏⴰ, ⵅ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⵖⴰⵔⵚⴰ, ⴷⴰⵢⴻⵙ ⴰⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PR17_2","021_17_2","PRO","17","2","2","ⵉⵊⵊ ⵏ ⵢⵉⵙⵎⴻⵖ ⵉⴼⴻⵜⵏⴻⵏ ⴰⴷ ⵉⴹⴻⴱⴱⴰⵔ ⵅ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏⵏⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⴰⵢⵜⵎⴰⵙ ⴰⴷ ⵉⴱⴹⴰ ⵏⴻⵜⵜⴰ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR17_3","021_17_3","PRO","17","3","3","ⴰⵟⴻⵏⵊⵉⵔ ⵏ ⵓⵙⴻⴼⵙⵉ ⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⴰⴼⴰⵔⵔⴰⵏ ⵉ ⵡⵓⵔⴻⵖ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵜⵜⵊⴰⵔⵔⴰⴱ ⵓⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR17_4","021_17_4","PRO","17","4","4","ⴰⵄⴻⴼⴼⴰⵏ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵉⵜⵜⵉⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵢⵉⵍⴻⵙ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PR17_5","021_17_5","PRO","17","5","5","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⴻⵛⵛⴻⵏ ⵅ ⵓⵎⴻⵣⵍⵓⴹ, ⵉⵙⵙⴼⴻⵟⵟⴻⵃ ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⵅ ⴰⵔⵥⵉⵢⵢⴻⵜ, ⵡⴰⵔ ⵉⵜⵜⵡⵉⵃⵙⵉⴱ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("PR17_6","021_17_6","PRO","17","6","6","ⵜⵜⴰⵊ ⵏ ⵉⵡⴻⵙⵙⵓⵔⴰ ⴷ ⴰⵢⵢⴰⵡⴻⵏ, ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR17_7","021_17_7","PRO","17","7","7","ⴰⵢⴻⵏⵛⵉⵛ ⵏ ⵛⵛⴰⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⴰⴽ-ⴷ ⵓⴱⵓⵀⴰⵍⵉ, ⵅⴻⵏⵏⵉ ⵄⴻⵙⵙⴰⴽ ⵄⴰⴷ ⴰⵢⴻⵏⵛⵉⵛ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴰⴽ-ⴷ ⵓⵎⵛⴻⵏⵏⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PR17_8","021_17_8","PRO","17","8","8","ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⴰⵔⵔⴻⵛⵡⴻⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵉⵣⴻⵡⵡⵇⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵏⵉ ⵎⴰ ⵢⴰⵔⵔⴰ ⵙ ⵓⵣⴻⴵⵉⴼ, ⵉⵜⵜⴻⴼⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PR17_9","021_17_9","PRO","17","9","9","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ ⴰⵅⴻⵟⵟⵓ, ⵢⴰⵔⴻⵣⵣⵓ ⵜⴰⵢⵔⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴰⵡⴰⴷⴻⵏ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵊⴷⵉⴷ, ⵉⴱⴻⵟⵟⴰ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR17_10","021_17_10","PRO","17","10","10","ⵉⵜⵜⵇⴰⵔⵔⴰ ⵓⵜⴻⵅⵜⴻⵅ ⵅ ⵓⴼⴻⵀⵀⴰⵎ ⴰⵟⵟⴰⵙ ⵅ ⵎⵢⴰ ⵏ ⵜⴻⵢⵢⵉⵜⴰ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PR17_11","021_17_11","PRO","17","11","11","ⴰⵎⵖⴻⵡⵡⴻⵖ ⵢⴰⵔⴻⵣⵣⵓ ⵎⵖⵉⵔ ⵅ ⵍⵖⴰⵔ, ⵅ ⵓⵢⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵇⴻⵙⵃⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR17_12","021_17_12","PRO","17","12","12","ⴻⵊⵊ ⴰⴷ ⵉⵎⵎⴻⵍⵇⴰ ⵛⴰ ⵏ ⴷⴷⵓⴱ ⵉ ⵓⵎⵉ ⵜⵜⵡⴰⵛⴰⵔⴻⵏ ⵜⴰⵔⵡⴰ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⴱⵓⵀⴰⵍⵉ ⴷⵉ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR17_13","021_17_13","PRO","17","13","13","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⴵⴰⵚⴻⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵙ ⵍⵖⴰⵔ, ⵡⴰⵔ ⵜᵉⵜⵜⵃⴻⵢⵢⵉⴷ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR17_14","021_17_14","PRO","17","14","14","ⴱⴻⴷⴷⵓ ⵏ ⵓⵎⴻⵏⵖⵉ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵔⵣⴰⵎ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ. ⴻⵊⵊ ⴰⵎⴻⵏⵖⵉ ⴰⴷ ⵢⴰⵔⵙ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⴷⴷⵓⵇⵇⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("PR17_15","021_17_15","PRO","17","15","15","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⴰⵏ ⴰⵄⴻⴼⴼⴰⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⴰⵃⴻⵏ ⴰⵇⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR17_16","021_17_16","PRO","17","16","16","ⵎⴰⵢⴻⵎⵎⵉ ⴷⵉⵏ ⵉ ⵖⴰ ⵉⵍⵉⵏⵜ ⵜⵎⴻⵏⵢⴰⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵖ ⵜⵉⵖⵉⵜ, ⴰⵎ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵓⵍ ⵉ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("PR17_17","021_17_17","PRO","17","17","17","ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⴷ ⵜⵉⴷⴻⵜⵜ ⵉⵜⵜⴻⵅⵙ ⵍⴻⴱⴷⴰ, ⵓ ⵜⴰⵡⵎⴰⵜ ⵜᵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR17_18","021_17_18","PRO","17","18","18","ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵡⵓⵍ ⵉⵎⵜⴻⵏ, ⵉⵛⵛⴰⵜ ⴰⴼⵓⵙ, ⵉⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR17_19","021_17_19","PRO","17","19","19","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵅⴻⵟⵟⵓ, ⵉⵜⵜⴻⵅⵙ ⴰⵎⵛⵓⴱⴱⴻⵛ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴳⴻⵄⵄⴻⴷ, ⵢⴰⵔⴻⵣⵣⵓ ⵜⴰⵔⴻⵥⵥⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PR17_20","021_17_20","PRO","17","20","20","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵍ ⵉⴼⴰⵔⵖ, ⵡⴰⵔ ⵉⵜⵜⵉⴼ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⵖⴻⵏ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⴰⵔⵥⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR17_21","021_17_21","PRO","17","21","21","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ, ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵛⴹⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴱⴰⴱⴰⵙ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("PR17_22","021_17_22","PRO","17","22","22","ⵓⵍ ⵉⴼⴰⵔⵃⴻⵏ ⵉⵊⴻⴱⴱⴻⴷ ⴰⴳⴻⵏⴼⵓ, ⵎⴰⵛⴰ ⴱⵓⵃⴱⴻⵍ ⵉⵛⴻⴹⵏⴻⵏ ⵉⵙⵙⴰⵥⴰⵖ ⵉⵖⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR17_23","021_17_23","PRO","17","23","23","ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⴷⴷ-ⵉⴽⵙⵉ ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⴰⵔⵔⴻⵛⵡⴻⵜ ⵣⴻⴳ ⵡⴻⵃⵙⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴼⴰⵔⵖ ⵉⵎⴻⵙⵔⴰⵇ ⵏ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("PR17_24","021_17_24","PRO","17","24","24","ⴰⴼⴻⵀⵀⴰⵎ ⵉⵜⵜⴻⴳⴳ ⵜⵉⵖⵉⵜ ⵣⵣⴰⵜ ⵉ ⵜⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵜⵜⴰⵡⵢⴻⵏⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR17_25","021_17_25","PRO","17","25","25","ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴰⴱⵓⵀⴰⵍⵉ ⴷ ⵍⴻⵄⴷⴰⴱ ⵉ ⴱⴰⴱⴰⵙ, ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⵉⵇ ⴰⵎⴻⵔⵣⴰⴳ ⵉ ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵢⵓⵔⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR17_26","021_17_26","PRO","17","26","26","ⴰⵡⴻⴷⴷⴻⴱ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵛⴰⵏ, ⴰⵎ ⵓⵍⴰ ⴷ ⵜⵉⵢⵢⵉⵜⴰ ⵉ ⴰⵢⵜ ⵏ ⵟⵟⴰⵙⵉⵍⴻⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR17_27","021_17_27","PRO","17","27","27","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵓⵙⵙⵏⴰ, ⵉⵎⴻⵏⵏⴻⵄ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⴰⵔⵢⴰⵣ ⴰⴼⴻⵀⵀⴰⵎ ⴷⴰⵢⴻⵙ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵢⴰⵔⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("PR17_28","021_17_28","PRO","17","28","28","ⵓⵍⴰ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵙⵙⵖⴰⴷⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⵍⵍⵄⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⴰⴼⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR18_1","021_18_1","PRO","18","1","1","ⵡⴻⵏⵏⵉ ⵉⵄⴻⵣⵣⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⴷⴷⵓⵇⵇⵓⵣ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴷⴻⴱⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR18_2","021_18_2","PRO","18","2","2","ⴰⴱⵓⵀⴰⵍⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵜᵉⵜⵜⴻⵄⵊⵉⴱ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵙ ⵎⵖⵉⵔ ⴰⵄⴰⵔⵔⵉ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR18_3","021_18_3","PRO","18","3","3","ⵅⵎⵉ ⴷⴷ-ⵉⵜⵜⴰⴷⴻⴼ ⵓⵄⴻⴼⴼⴰⵏ, ⵉⵜⵜⴰⵙ-ⴷⴷ ⵓⵍⴰ ⴷ ⴰⵙⴻⵃⵇⴰⵔ, ⵓ ⴰⴽ-ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵍⵄⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR18_4","021_18_4","PRO","18","4","4","ⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵎ ⵡⴰⵎⴰⵏ ⵢⵓⴵⵖⴻⵏ, ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵜⵉⵖⵉⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵖⵣⴰⵔⵜ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR18_5","021_18_5","PRO","18","5","5","ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵎⵍⵉⵃ ⴰⴷ ⵜⴻⵙⵙⵄⵉⵣⵣⴻⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵃⴻⵢⵢⴷⴻⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷⵉ ⵛⵛⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PR18_6","021_18_6","PRO","18","6","6","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵏⴻⴷⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵓⵎⵛⴻⴱⴱⴻⵛ, ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉⵜⵜⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵡⴻⵄⵎⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("PR18_7","021_18_7","PRO","18","7","7","ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⴷ ⴰⵀⴻⵍⵍⴻⴽ ⵏⵏⴻⵙ, ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴼⴻⵅ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR18_8","021_18_8","PRO","18","8","8","ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵅⴱⴰⵔⵊⵉⵢⵢⴻⵏ ⴰⵎ ⵃⴰⵍⴰⵡⵉⵜ, ⵀⴻⴽⴽⵡⴰⵏⵜ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵓⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR18_9","021_18_9","PRO","18","9","9","ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴰⵔⵅⵓ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜ ⴷ ⵓⵎⴰⵙ ⵏ ⴱⴰⴱ ⵏ ⵓⵍⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("PR18_10","021_18_10","PRO","18","10","10","ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵉⵎⵜⴻⵏ, ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵖⴰⵔ ⴷⵉⵏⵏⵉ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⴽⴽⵡⴰⴹ ⴰⵍ ⴷⵉⵏ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR18_11","021_18_11","PRO","18","11","11","ⴰⴳⵍⴰ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵜⴰⵏⵉⵜⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR18_12","021_18_12","PRO","18","12","12","ⵇⴱⴻⵍ ⵎⴰ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵔⵥ, ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⴰⵡⴰⴹⴻⵄ ⵉⵜⵜⵉⵣⵡⴰⵍ ⴰⵙ ⵉ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR18_13","021_18_13","PRO","18","13","13","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⴰⵏ ⴰⵡⴰⵍ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⴻⵍ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PR18_14","021_18_14","PRO","18","14","14","ⴱⵓⵃⴱⴻⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵙⴻⵏⵏⴻⴷ ⵉ-ⵜ ⵖⴰⵔ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴱⵓⵃⴱⴻⵍ ⵉⵜⵜⵡⴰⵔⵥⴻⵏ, ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⴽⵙⵉ? ");
INSERT INTO rift_vpl VALUES ("PR18_15","021_18_15","PRO","18","15","15","ⵓⵍ ⵏ ⵓⴼⴻⵀⵀⴰⵎ ⵢⴰⵔⴻⵣⵣⵓ ⵜⵓⵙⵙⵏⴰ, ⴰⵎⴻⵣⵣⵓⵖ ⵏ ⵓⵎⵉⵖⵉⵙ ⵢⴰⵔⴻⵣⵣⵓ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR18_16","021_18_16","PRO","18","16","16","ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⴰⵔⴻⵣⵣⴻⵎ ⴰⵙ ⵜⵉⵡⵡⵓⵔⴰ, ⵜⵏⴻⴷⴷⴻⵀ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR18_17","021_18_17","PRO","18","17","17","ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵙ ⵉⵜⵜⴱⴰⵏ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵎⴰⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⵏⴻⵛⵛⴻⴱ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR18_18","021_18_18","PRO","18","18","18","ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉⵜⵜⴻⵊⵊⴰⵏ ⵉⵎⴻⵏⵖⴰⵏ ⵜⵜⴱⴻⴷⴷⴰⵏ, ⵜⴱⴻⵟⵟⴰ ⵊⴰⵔ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("PR18_19","021_18_19","PRO","18","19","19","ⵉⵊⵊ ⵏ ⵓⵎⴰ ⵏⵏⵉ ⵓⵎⵉ ⴷⵉ ⴳⴳⵉⵏ ⵍⵄⵉⴱ, ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⴽⵜⴰⵔ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵎⴻⵏⵖⴰⵏ ⴳⴳⵉⵏ ⴰⵎ ⵣⵣⴻⴽⵔⵓⵏ ⵏ ⵍⴻⵇⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR18_20","021_18_20","PRO","18","20","20","ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵢⴰⵡⴰⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵊⵊⴰⵡⴻⵏ ⵣⵉ ⵚⵚⴰⴱⴻⵜ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR18_21","021_18_21","PRO","18","21","21","ⵍⵎⴻⵡⵜ ⴷ ⵜⵓⴷⴰⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵍⴻⵙ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⴰⴷ ⵢⴻⵛⵛ ⵔⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR18_22","021_18_22","PRO","18","22","22","ⵡⴻⵏⵏⵉ ⵢⵓⴼⵉⵏ ⵜⴰⵎⵖⴰⵔⵜ, ⵢⵓⴼⴰ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR18_23","021_18_23","PRO","18","23","23","ⵙ ⵓⵃⴻⵛⵛⴻⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵓⵎⴻⵣⵍⵓⴹ, ⴱⵓ-ⵡⴰⴳⵍⴰ ⵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR18_24","021_18_24","PRO","18","24","24","ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⴰⵟⵟⴰⵙ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵜⴰⵎⴰⵔⴰ, ⵎⴰⵛⴰ ⵛⴰ ⵏ ⵉⵎⵓⵔⴻⵏ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵜⵜⴻⵅⵙ ⵉ ⵛⴻⴽ ⴽⵜⴰⵔ ⵣⵉ ⵜⴰⵡⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR19_1","021_19_1","PRO","19","1","1","ⵉⵃⵍⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏⵏⴻⵙ, ⵅ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⴼⴰⵔⵖⴻⵏ, ⵓ ⴰⵇⴰ ⵜ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("PR19_2","021_19_2","PRO","19","2","2","ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵎⵍⵉⵃ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴻⴵⵇⴻⵏ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR19_3","021_19_3","PRO","19","3","3","ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵙⵙⴼⴰⵔⵔⴰⵖ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵓ ⵅⴻⵏⵏⵉ ⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵄⴰⵔ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR19_4","021_19_4","PRO","19","4","4","ⴰⴳⵍⴰ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ, ⵎⴰⵛⴰ ⴰⵎⴻⵣⵍⵓⴹ ⵉⵙⴻⵎⵎⴻⵃ ⴷⴰⵢⴻⵙ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR19_5","021_19_5","PRO","19","5","5","ⴰⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵃⴻⵙⵙⴻⴱ ⵛⴰ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⴻⵅⵅⵓⵏ ⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⴰⵔ ⵉⵏⴻⵊⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR19_6","021_19_6","PRO","19","6","6","ⴰⵟⵟⴰⵙ ⵜⵜⵣⴰⵡⴳⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵎⵛⴻⵏⵏⴻⵄ, ⴽⵓⵍ ⵉⵊⵊ ⵉⵜⵜⴻⵅⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴻⵔⵣⵉⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR19_7","021_19_7","PRO","19","7","7","ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵛⴰⵔⵔⵀⴻⵏ ⵜ, ⵎⴻⵛⵃⴰⵍ ⵜⵜⵉⴳⴳⵯⴻⵊⵊⴻⵏ ⵅⴰⵙ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ! ⵏⴻⵜⵜⴰ ⵉⴹⴻⴼⴼⴰⵔ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PR19_8","021_19_8","PRO","19","8","8","ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵓⵍ ⴰⵎⵉⵖⵉⵙ, ⵉⵜⵜⴻⵅⵙ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⴰⴷ ⵢⴰⴼ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR19_9","021_19_9","PRO","19","9","9","ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵃⴻⵙⵙⴻⴱ ⵛⴰ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵅⵅⵓⵏ ⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR19_10","021_19_10","PRO","19","10","10","ⴰⴼⴻⵢⵢⴻⵛ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵅ ⵓⴱⵓⵀⴰⵍⵉ, ⵎⴰⵎⵎⴻⵛ ⵄⴰⴷ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵟ ⵅ ⵍⵃⵓⴽⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PR19_11","021_19_11","PRO","19","11","11","ⵍⴻⵄⵇⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜ ⴰⴷ ⵉⴳⴳ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵜⵓⵙⴰ-ⴷⴷ ⵅⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⴻⵢⵢⴻⴽ ⵅ ⵓⵅⴻⵟⵟⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR19_12","021_19_12","PRO","19","12","12","ⴰⵙⵅⴻⴹ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵡⴻⵢⵔⴰⴷ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⴰⵎ ⵏⵏⴷⴰ ⵅ ⴰⵔⴱⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("PR19_13","021_19_13","PRO","19","13","13","ⵎⵎⵉⵙ ⴰⴱⵓⵀⴰⵍⵉ ⴷ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉ ⴱⴰⴱⴰⵙ, ⴰⵎⵛⵓⴱⴱⴻⵛ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⴳⴳⴰ ⴰⵎ ⵜⵓⴷⴷⵉⵎⵜ ⵏ ⵜⵣⴻⵇⵇⴰ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR19_14","021_19_14","PRO","19","14","14","ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵡⴰⴳⵍⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵡⴰⵔⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵎⴰⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⴼⴻⵀⵀⵎⴻⵏ ⴰⵇⴰ-ⵜⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR19_15","021_19_15","PRO","19","15","15","ⵍⴻⵄⴳⴻⵣ ⵢⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵡⴹⴰ ⴷⴻⴳ ⵉⴹⴻⵚ ⵢⵓⴵⵖⴻⵏ, ⵓ ⵍⴻⵄⵎⴰⵔ ⵉⵛⵛⵓⵔ ⵙ ⵍⵖⴻⵛⵛ ⴰⴷ ⵉⴵⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("PR19_16","021_19_16","PRO","19","16","16","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ, ⵉⵃⴻⵟⵟⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴻⵟⵟⵉⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR19_17","021_19_17","PRO","19","17","17","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⵉⵏⵏⴰⵏ ⵅ ⵓⵎⴻⵣⵍⵓⴹ, ⵢⴰⵔⴻⵟⵟⴻⵍ ⵉ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵅⴻⴵⴻⵚ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR19_18","021_19_18","PRO","19","18","18","ⵡⴻⴱⴱⴻⵅ ⵎⵎⵉⵛ, ⵎⴰⵍⴰ ⵄⴰⴷ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⴰⵢⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵏⴻⵇⵇ ⵛⴰ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵛⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⵢⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR19_19","021_19_19","PRO","19","19","19","ⵡⴻⵏⵏⵉ ⵉⵙⵄⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵉ ⵎⴰⵏⴰⵢⴻⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜ ⵜⵎⴻⵏⵄⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴰⵔⴻⵏⵢⴻⴷ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR19_20","021_19_20","PRO","19","20","20","ⵙⴻⵍ ⵛⴻⴽ ⵖⴰⵔ ⵓⵛⴰⵡⴰⵔ ⵓⵛⴰ ⵇⴱⴻⵍ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵎⵉⵖⵉⵙ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR19_21","021_19_21","PRO","19","21","21","ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵅⴻⵎⵎⵉⵎⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵎⴰⵛⴰ ⵛⵛⵡⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⵖⵉⵎⴰ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("PR19_22","021_19_22","PRO","19","22","22","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵃⵙⴻⵏ ⵅ ⵉⵊⵊ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR19_23","021_19_23","PRO","19","23","23","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⵜⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⴻⵟⵟⴻⵚ ⵉⵊⵊⵉⵡⴻⵏ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵛⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR19_24","021_19_24","PRO","19","24","24","ⴰⵎⴻⵄⴳⵓⵣ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⴻⴱⵚⵉ, ⵡⴰⵔ ⵜ-ⵉ-ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("PR19_25","021_19_25","PRO","19","25","25","ⵡⵡⴻⵜ ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴼⵜⴻⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵓ ⵄⴰⵇⴻⴱ ⴰⴼⴻⵀⵀⴰⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⵙⴻⴱ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR19_26","021_19_26","PRO","19","26","26","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵖⴻⵣⵣⵓ ⴷⵉ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵢⴻⵎⵎⴰⵙ, ⴰⵇⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⵉ ⵢⴰⵔⵔⴰⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵙⴻⴹⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("PR19_27","021_19_27","PRO","19","27","27","ⵙⴱⴻⴷⴷ-ⴷⴷ, ⴰ ⵎⵎⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵓⵡⴻⴱⴱⴻⵅ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵃⴻⵢⵢⴷⴻⴷ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR19_28","021_19_28","PRO","19","28","28","ⵉⵊⵊ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵉⵖⴻⵟⵟⴻⵍ ⵣⵉ ⵍⵃⴻⵇⵇ, ⵓⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵚⴰⵔⵔⴻⴹ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PR19_29","021_19_29","PRO","19","29","29","ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ ⵜᵉⵜⵜⵔⴰⵊⴰ ⴰⵜⴻⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ, ⵓ ⵜⵉⵢⵉⵜⵜⴰ ⴷⴻⴳ ⵡⴻⵄⵔⵓⵔ ⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_1","021_20_1","PRO","20","1","1","ⴱⵉⵏⵓ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵜⴻⵀⵣⵉⵢ, ⵛⵛⵔⴰⴱ ⴷ ⴱⵓ-ⵙⵙⴹⴻⵄ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴷ ⴰⵎⵉⵖⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_2","021_20_2","PRO","20","2","2","ⴰⵀⵓⴷⴷⵉ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵡⴰⵢⵔⴰⴷ: ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⴻⵄⴰⵔⴻⵏ, ⵉⵅⴻⵟⵟⴰ ⴰⴽ-ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_3","021_20_3","PRO","20","3","3","ⴰⵙⵎⴰⵃ ⴷⴻⴳ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴰⵇⴰ ⴷ ⵛⵛⴰⵏ ⵉ ⵡⴻⵔⵢⴰⵣ, ⵎⴰⵛⴰ ⴽⵓⵍ ⴰⴱⵓⵀⴰⵍⵉ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("PR20_4","021_20_4","PRO","20","4","4","ⵣⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵅⵔⵉⴼ ⵡⴰⵔ ⵉⵛⴰⵔⵔⴻⵣ ⵓⵎⴻⵄⴳⵓⵣ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⵢⵔⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⴼ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PR20_5","021_20_5","PRO","20","5","5","ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵎⴰⵏ ⵢⵓⴵⵖⴻⵏ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵙⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵢⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR20_6","021_20_6","PRO","20","6","6","ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ‘ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵙⴻⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ’, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵜ ⵉ ⵖⴰ ⵢⴰⴼⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PR20_7","021_20_7","PRO","20","7","7","ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⴳⴳⵓⵔ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏⵏⴻⵙ, ⵙⵙⴻⵄⴷ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵉⵜⵜⴻⵊⵊⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_8","021_20_8","PRO","20","8","8","ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ, ⵉⵜⵜⵚⴻⴼⴼⴰ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_9","021_20_9","PRO","20","9","9","ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵏⵉ: “ⵏⴻⵛⵛ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵓⵍ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵉⵣⴷⵉⴳⴻⵖ ⵣⵉ ⴷⴷⵏⵓⴱ ⵉⵏⵓ!”? ");
INSERT INTO rift_vpl VALUES ("PR20_10","021_20_10","PRO","20","10","10","ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵉⴼⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR20_11","021_20_11","PRO","20","11","11","ⴰⵃⵓⴷⵔⵉ ⵉⵙⵙⵛⴰⵏⴰ ⴷⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⵎⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵚⴼⴰ ⵏⵉⵖ ⴰⵇⴰ ⵏⵉⵛⴰⵏ ⵉ ⵜⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("PR20_12","021_20_12","PRO","20","12","12","ⴰⵎⴻⵣⵣⵓⵖ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴷ ⵜⵉⵟⵟ ⵉⵜⵜⵡⴰⵍⴰⵏ, ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_13","021_20_13","PRO","20","13","13","ⵡⴰⵔ ⵜⵜⴻⵅⵙ ⵉⴹⴻⵚ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⴷⴷⵉⴽⴽⵡⵉⵍⴻⴷ ⴷ ⴰⵎⴻⵣⵍⵓⴹ, ⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵙⵢⵉⵡⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PR20_14","021_20_14","PRO","20","14","14","‘ⵡⴰⵔ ⵉⵃⵍⵉ, ⵡⴰⵔ ⵉⵃⵍⵉ!’, ⵉⵇⵇⴰⵔ ⵓⵎⵙⴻⵡⵡⴻⵇ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵢⵓⵢⵓⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵛⴻⵏⵏⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_15","021_20_15","PRO","20","15","15","ⵓⵔⴻⵖ ⵉⴵⴰ, ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⵎⴰⵔⵊⴰⵏ, ⵎⴰⵛⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵓⵙⵙⵏⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_16","021_20_16","PRO","20","16","16","ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵉⴷⴷⴰⴽⴽⵡⴰⵍ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⵅⴻⵏⵏⵉ ⴽⵙⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓ ⴽⵙⵉ ⵜ ⴷ ⴷⴷⵉⵢⵢⴻⵜ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_17","021_20_17","PRO","20","17","17","ⴷ ⴰⵎⵉⵥⵉⴷ ⵉ ⴱⵏⴰⴷⴻⵎ ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵉⵛⵛⵓⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵙ ⵉⵇⴰⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_18","021_20_18","PRO","20","18","18","ⵉⵅⴻⵎⵎⵉⵎⴻⵏ ⵜⵜⴻⴽⵎⵉⵍⴻⵏ ⵙ ⵓⵛⴰⵡⴰⵔ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵏⴷⴻⵀ ⴰⵎⴻⵏⵖⵉ ⵙ ⵓⴷⴻⴱⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR20_19","021_20_19","PRO","20","19","19","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵙ ⵜⴻⵅⴱⴰⵔⵊⵉⵜ, ⵉⵜⵜⵄⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵙⴻⴱⴱⴻⴱ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵃⵉⵏⵏⵉⴱⴻⵏ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵉⵚⴻⴱⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_20","021_20_20","PRO","20","20","20","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⵄⵍⴻⵏ ⵅ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⵍⴻⴼⵏⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵙⵉ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PR20_21","021_20_21","PRO","20","21","21","ⵎⴰⵍⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⴽⵙⴻⴱ ⴷⴻⵖⵢⴰ ⵙ ⵜⴰⵣⵍⴰ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵡⴰⵔ ⴷⴷ-ⵜⵉⵡⴻⴹ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR20_22","021_20_22","PRO","20","22","22","ⵡⴰⵔ ⵇⵇⴰⵔ: “ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵍⵖⴰⵔ!” ⵎⴰⵛⴰ ⵜⵛⴻⵍ ⵅ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR20_23","021_20_23","PRO","20","23","23","ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵙⵉⴷⵉ, ⵍⵎⵉⵣⴰⵏⴰⵜ ⵉⵖⴻⵛⵛⴻⵏ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PR20_24","021_20_24","PRO","20","24","24","ⵉⵚⵓⵔⴰⴼ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵇⴰ ⴰⵜⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴻⴳⴳ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵙⵙⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("PR20_25","021_20_25","PRO","20","25","25","ⴰⵇⴰ-ⵜ ⴷ ⵍⴼⴻⵅ ⵉ ⴱⵏⴰⴷⴻⵎ ⵉ ⵖⴰ ⵉⵍⴰⵖⴰⵏ ⵙ ⵓⵇⴻⴵⴻⵇ ‘ⴰⵎⵇⴻⴷⴷⴻⵙ’, ⵓ ⵄⴰⴷ ⴰⵡⴰⵔⵏⵉ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⴰ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PR20_26","021_20_26","PRO","20","26","26","ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎⵉⵖⵉⵙ ⵉⵜⵜⵚⴻⴼⴼⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵉⵜⵜⴻⵊⵊⴰ ⵜⴰⵊⴰⵔⵔⴰⵔⵜ ⵏ ⵜⴻⵍⵡⵉⵃⵜ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵄⵇⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("PR20_27","021_20_27","PRO","20","27","27","ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⴻⴼⵏⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵓⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR20_28","021_20_28","PRO","20","28","28","ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⴰⵎⴰⵏ ⵃⴻⵟⵟⴰⵏ ⴰⵊⴻⴵⵉⴷ, ⵓ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉ-ⵜ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_29","021_20_29","PRO","20","29","29","ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⴷ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ, ⵓ ⵍⵄⴰⴹⴰⵎⴰ ⵏ ⵉⵡⴻⵙⵙⵓⵔⴰ ⴷ ⴰⵛⵓⵡⵡⴰⴼ ⵉⵛⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR20_30","021_20_30","PRO","20","30","30","ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵙⵙⵉⵣⴷⵉⴳⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵍⵖⴰⵔ, ⵓ ⵜⵉⵢⵢⵉⵜⴰ ⵚⴻⴼⴼⴰⵏⵜ ⵓⵍⴰ ⴷ ⵜⴰⴽⵔⵉⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_1","021_21_1","PRO","21","1","1","ⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⵏⴻⴷⴷⴻⵀ ⵉ-ⵜ, ⵎⴰⵏⵉ ⵎⴰ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("PR21_2","021_21_2","PRO","21","2","2","ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵜⵜⵇⴻⴵⴰⴱ ⵓⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_3","021_21_3","PRO","21","3","3","ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵜⵙⴻⴳⴷⴰ ⴷ ⵍⵃⴻⵇⵇ, ⴷ ⵜⵉⵏⴰ ⵉ ⵙⵉⴷⵉ ⵃⵙⴻⵏ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_4","021_21_4","PRO","21","4","4","ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷ ⵓⵍ ⴰⵄⴻⴼⴼⴰⵔ, ⴰⵔⴱⴻⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("PR21_5","021_21_5","PRO","21","5","5","ⵉⵅⴻⵎⵎⵉⵎⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵜⵜⴰⵡⵢⴻⵏ ⵎⵖⵉⵔ ⵖⴰⵔ ⵓⴼⴻⵢⵢⴻⴹ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⴰⵟⵟⴰⵙ ⵉⵜⵜⴰⵡⵉ ⵖⴰⵔ ⵍⴻⵃⵡⴻⵊ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR21_6","021_21_6","PRO","21","6","6","ⴰⵙⵎⵓⵏⵉ ⵏ ⵡⴰⴳⵍⴰ ⵙ ⵢⵉⵍⴻⵙ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵉⵄⴻⴷⴷⵓⵏ ⴷⴻⵖⵢⴰ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_7","021_21_7","PRO","21","7","7","ⵍⵄⵓⵏⴼ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⵊⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵜⴰⴳⵉⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_8","021_21_8","PRO","21","8","8","ⴰⴱⵔⵉⴷ ⵏ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⵉⵜⵜⴻⴼⵔⵉⵖ, ⵎⴰⵛⴰ ⴰⵎⴻⵣⴷⴰⴳ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_9","021_21_9","PRO","21","9","9","ⵉⵃⵍⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵜⵣⴻⵇⵇⴰ, ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵛⴰⵔⵛ. ");
INSERT INTO rift_vpl VALUES ("PR21_10","021_21_10","PRO","21","10","10","ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⵎⴻⵥⵔⵉ ⴷⵉ ⵍⵖⴰⵔ, ⴰⵎⵇⴰⵔⵔⴻⴱ ⵏⵏⴻⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⴼ ⴰⵔⴹⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR21_11","021_21_11","PRO","21","11","11","ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵓⵎⴻⵙⵜⴻⵀⵣⵉⵢ, ⵉⴷⴷⴰⴽⴽⵡⴰⵍ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵎⴰⵍⴰ ⵙⵙⵍⴻⵎⴷⴻⵏ ⴰⵎⵉⵖⵉⵙ, ⵉⴽⴻⵙⵙⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR21_12","021_21_12","PRO","21","12","12","ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⴱⴻⵇⵇⴻⵛ ⵎⵍⵉⵃ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵉⵖⴻⵟⵟⴻⵍ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷⵉ ⴰⵔⵥⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_13","021_21_13","PRO","21","13","13","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴻⵍⵍⴰⵄⴻⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵣⵍⵓⴹ, ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵖⵓⵢ ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵜⵜⴰⵔⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_14","021_21_14","PRO","21","14","14","ⵚⵚⴻⴷⵇⴻⵜ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵜⴻⵚⵍⴻⵃⵃⵓ ⵡⴻⵖⴹⴰⴱ, ⵜⴰⵔⵣⴻⴼⵜ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵜⴻⵚⵍⴻⵃⵃⵓ ⴰⵅⴻⵢⵢⴻⵇ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_15","021_21_15","PRO","21","15","15","ⴰⵇⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⴷ ⴰⵛⴻⵍⵡⴰⵡ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PR21_16","021_21_16","PRO","21","16","16","ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵄⵇⴻⵍ, ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_17","021_21_17","PRO","21","17","17","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴼⴰⵔⵔⴰⵊ, ⴰⴷ ⵉⵃⵡⴰⵊ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴱⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ, ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴷ ⴱⵓ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PR21_18","021_21_18","PRO","21","18","18","ⴰⵄⴻⴼⴼⴰⵏ ⴷ ⴷⴷⴻⵢⵢⴻⵜ ⵉ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵓ ⴰⵖⴻⴷⴷⴰⵔ ⴰⴷ ⴷⴷ-ⵢⵉⵍⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_19","021_21_19","PRO","21","19","19","ⵉⵃⵍⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵅⵍⴰⵏ, ⵅ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⵓ ⵉⵜⵜⴻⵇⵇⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_20","021_21_20","PRO","21","20","20","ⵉⵊⵊ ⵏ ⵍⴽⴻⵏⵣ ⵉⵜⵜⵡⴰⵃⵡⴰⵊⴻⵏ ⴷ ⵣⵣⴻⵛⵜ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵚⴰⵔⵔⴻⴹ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_21","021_21_21","PRO","21","21","21","ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵜⵙⴻⴳⴷⴰ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵉⵜⵜⴰⴼ ⵜⵓⴷⴰⵔⵜ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_22","021_21_22","PRO","21","22","22","ⴰⵎⵉⵖⵉⵙ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵍⵓⴹⵜ, ⵉⵖⴻⵟⵟⴻⵍ ⵊⵊⴻⵀⴷ ⵏ ⵜⵜⵉⵇⴻⵜ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_23","021_21_23","PRO","21","23","23","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⴰⵇⴻⵎⵎⵓⵎ ⴷ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ, ⵉⵃⴻⵟⵟⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("PR21_24","021_21_24","PRO","21","24","24","ⵡⴻⵏⵏⵉ ⴷ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⵉⴼⴼⵓⵛⵛⵃⴻⵏ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ‘ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ’, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⴱⵍⴰ ⵍⴻⵇⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR21_25","021_21_25","PRO","21","25","25","ⵛⵛⴻⵀⵡⴻⵜ ⵏ ⵓⵎⴻⵄⴳⵓⵣ ⵜⵏⴻⵇⵇ ⵉ-ⵜ, ⵎⴰⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓⴳⵉⵏ ⴰⴷ ⵅⴻⴷⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_26","021_21_26","PRO","21","26","26","ⴰⵙⵙ ⵉⵎⵓⵏ ⵉⵜⵜⵛⴻⵀⵀⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵓⵛⴻⵀⵀⵉ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⵡⵛ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵜⵜᵉⵟⵟⴻⴼ ⴷⵉ ⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR21_27","021_21_27","PRO","21","27","27","ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⴷ ⵏⵏⵄⵉ, ⵎⴰⵀⵓ ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⴰⵡⵢⴻⵏ ⵙ ⵓⵏⴻⴽⴽⵡⵉ ⵉⵖⴻⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR21_28","021_21_28","PRO","21","28","28","ⴰⵛⴻⵀⵀⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ, ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵜⵉⴷⴻⵜⵜ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR21_29","021_21_29","PRO","21","29","29","ⴰⵔⵢⴰⵣ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR21_30","021_21_30","PRO","21","30","30","ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⵉⵖⵉⵜ ⵓⵍⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴱⵓ ⵓⵛⴰⵡⴰⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR21_31","021_21_31","PRO","21","31","31","ⴰⵢⵉⵙ ⴰⴷ ⴰⵙ ⵃⴻⵣⵣⵎⴻⵏ ⵉ ⵡⴰⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵛⴰ ⵍⴻⵖⵍⴻⴱ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR22_1","021_22_1","PRO","22","1","1","ⵉⵙⴻⵎ ⴰⵚⴻⴱⵃⴰⵏ ⵉⵃⵍⴰ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ, ⴰⵃⵉⵏⵏⵉ ⵉⵃⵍⴰ ⵅ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PR22_2","021_22_2","PRO","22","2","2","ⴱⵓ-ⵡⴰⴳⵍⴰ ⴷ ⵓⵎⴻⵣⵍⵓⴹ ⵜⵜⴻⵎⵙⴰⴳⴰⵔⴻⵏ, ⵙⵉⴷⵉ ⵉ-ⵜⴻⵏ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR22_3","021_22_3","PRO","22","3","3","ⴱⵏⴰⴷⴻⵎ ⵉⴼⴻⵜⵜⵏⴻⵏ ⵉⵜⵜⵡⴰⵍⴰ ⵍⵖⴰⵔ ⵓⵛⴰ ⵉⵜⵜⵏⵓⴼⴼⴰⵔ, ⵎⴰⵛⴰ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ ⴰⵔⴻⵏⵏⵉⵏ ⴳⴳⵓⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵇⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR22_4","021_22_4","PRO","22","4","4","ⵍⵎⵓⵏⴻⵜ ⵉ ⵓⵡⴰⴹⴻⵄ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ, ⴷ ⴰⴳⵍⴰ ⴷ ⵛⵛⴰⵏ ⴷ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR22_5","021_22_5","PRO","22","5","5","ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵍⴻⴼⵅⵓⵅ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵖⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵉⵜⵜⵖⵉⵎⴰ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR22_6","021_22_6","PRO","22","6","6","ⴷⴰⵔⵔⴻⴱ ⴰⵃⵓⴷⵔⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⵢⴰⵙ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⵡⵙⴰⵔ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⵃⴻⵢⵢⵉⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PR22_7","021_22_7","PRO","22","7","7","ⴱⵓ-ⵡⴰⴳⵍⴰ ⵉⵜⵜⵚⴻⴵⴰⴹ ⵅ ⵉⵎⴻⵣⵍⴰⴹ, ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⴷ ⵉⵙⵎⴻⵖ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⵟⵟⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR22_8","021_22_8","PRO","22","8","8","ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵍⵖⴻⵛⵛ, ⴰⴷ ⵉⵎⵊⴰⵔ ⵍⴻⵖⴱⴻⵏ, ⴰⵄⵎⵓⴷ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵙ ⵏ ⵓⴼⵓⴳⴻⵎ ⴰⴷ ⵉⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR22_9","021_22_9","PRO","22","9","9","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⵅⴻⵣⵔⴰⵜ ⵚⴻⴱⵃⴻⵏⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵉⵛ ⵉ ⵉⵎⴻⵣⵍⴰⴹ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR22_10","021_22_10","PRO","22","10","10","ⴰⵥⵥⴻⵍ ⵅ ⵓⵎⴻⵙⵜⴻⵀⵣⵉⵢ, ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⵀⴻⵎⵎ, ⴰⵇⴰ ⵉⴱⴻⴷⴷ ⵓⵎⵃⴰⵔⵡⴰⴹ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR22_11","021_22_11","PRO","22","11","11","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⴹⴰ, ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR22_12","021_22_12","PRO","22","12","12","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵃⴻⵟⵟⴰⵏⵜ ⵅ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵖⴻⴷⴷⴰⵔ ⴰⴷ ⵜⴻⵏ ⵉⴱⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR22_13","021_22_13","PRO","22","13","13","ⴰⵎⴻⵄⴳⵓⵣ ⵉⵇⵇⴰⵔ: “ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴰⵢⵔⴰⴷ ⴷⵉ ⴱⴰⵔⵔⴰ! ⴰⴷ ⵜⴰⵖ ⴱⴰⵍⴰⴽ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴰⵣⵣⴰⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("PR22_14","021_22_14","PRO","22","14","14","ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵢⵓⴵⵖⴻⵏ, ⵡⴻⵏⵏⵉ ⵅ ⵉⴼⴼⵓⴳⴻⵎ ⵙⵉⴷⵉ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR22_15","021_22_15","PRO","22","15","15","ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵜⵍⴻⵙⵙⴻⵇ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵓⵃⵓⴷⵔⵉ, ⴰⵄⵎⵓⴷ ⵏ ⵓⵡⴻⴱⴱⴻⵅ ⴰⴷ ⵜⵜ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR22_16","021_22_16","PRO","22","16","16","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⵎⴰⵔⵅⵓ, ⴰⴷ ⵢⴰⵔⵏⵉ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵉ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⴰⴷ ⵉⵃⵡⴰⵊ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PR22_17","021_22_17","PRO","22","17","17","ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵙⴻⵍ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⴰⵔⵔ ⵓⵍ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵓⵙⵙⵏⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR22_18","021_22_18","PRO","22","18","18","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵎⵍⵉⵃ ⵎⴰⵍⴰ ⵜⵅⴻⵎⵎⵍⴻⴷ ⵜⴻⵏ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵊⵎⵉⵄ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR22_19","021_22_19","PRO","22","19","19","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵓⵜⴻⵛⵍⵉ ⵏⵏⴻⵛ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵛ ⵜⴻⵏ ⵙⵙⴻⵛⵏⴻⵖ ⵍⴻⵅⵅⵓ, ⵡⴰⵀ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR22_20","021_22_20","PRO","22","20","20","ⵎⴰ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵓⵔⵉⵖ ⴰⵡⴰⵍⴻⵏ ⵉⴼⴰⵔⵣⴻⵏ ⴰⵟⵟⴰⵙ, ⵛⵛⵓⵔⴻⵏ ⵙ ⵛⵛⵡⴰⵔ ⴷ ⵜⵓⵙⵙⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("PR22_21","021_22_21","PRO","22","21","21","ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵍⴻⵎⵜⴻⵏ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵃⴻⵏⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⵙ ⵍⴰⵎⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR22_22","021_22_22","PRO","22","22","22","ⵡⴰⵔ ⵜⵜⴽⴻⵛⵛⴰⴹ ⴰⵎⴰⵔⵅⵓ ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴰⵔⵅⵓ, ⵡⴰⵔ ⵍⴻⴱⴱⴻⵣ ⵍⵎⴻⵙⴽⵉⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("PR22_23","021_22_23","PRO","22","23","23","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⴰⵙⴻⵏ ⵢⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR22_24","021_22_24","PRO","22","24","24","ⵡⴰⵔ ⵜⵜⴻⵎⴷⴷⵓⴽⴽⵓⵍ ⴰⴽ-ⴷ ⴰⵔⵢⴰⵣ ⵉⵜⵜⴰⵔⵔⵓⵊⴷⵓⴷⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⴷⴻⴼ ⵖⴰⵔ ⴱⴰⴱ ⵏ ⵡⴻⵙⵄⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PR22_25","021_22_25","PRO","22","25","25","ⵎⴰⵃⴻⵏⴷ ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵏⵉⵎⵉⴷ ⵛⴰ ⴰⴽ-ⴷ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⴼⴻⵅ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR22_26","021_22_26","PRO","22","26","26","ⵡⴰⵔ ⵜⵜⴰⴷⴻⴼ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⵡⴰⵍ ⵙ ⵜⵎⴻⵡⵛⵉⵡⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ, ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵉⵎⴰⵔⵡⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("PR22_27","021_22_27","PRO","22","27","27","ⵎⴰⵍⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵜⵅⴻⴵⵚⴻⴷ, ⵎⴰⵢⴻⵎⵎⵉ ⵉⵊⴻⴱⴱⴻⴷ ⵇⴰⵎⴰ ⵏⵏⴻⵛ ⵣⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PR22_28","021_22_28","PRO","22","28","28","ⵡⴰⵔ ⵙⵎⵓⵟⵟⵓⵢ ⴰⵢⵎⵉⵔ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵡⴻⵏⵏⵉ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR22_29","021_22_29","PRO","22","29","29","ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵎⴻⵃⴹⴻⵏ ⴷⵉ ⵍⵃⵉⵔⴼⴰ ⵏⵏⴻⵙ? ⴰⴷ ⵜ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⵉⴷⴷⴻⵏ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_1","021_23_1","PRO","23","1","1","ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⴽⵉⴷⴻⵙ, ⵃⴹⴰ ⵎⵍⵉⵃ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR23_2","021_23_2","PRO","23","2","2","ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵎⵓⵙ ⵅ ⵢⵉⵍⵉ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR23_3","021_23_3","PRO","23","3","3","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵎⴻⵥⵔⵉ ⴷⵉ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵛⵏⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ-ⵜ ⴷ ⵎⴰⵛⵛⴰ ⵏ ⵜⵓⵅⵅⵓⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR23_4","021_23_4","PRO","23","4","4","ⵡⴰⵔ ⵙⵙⵉⵃⵉⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵙⴰⵔⵅⵓ ⴷⴻⴳ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR23_5","021_23_5","PRO","23","5","5","ⵎⴰⵍⴰ ⵟⵟⴰⵡⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵖⴰⵔⴻⵙ, ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⴰⴳⵍⴰ ⵄⴰⴷ! ⵎⴰⵖⴰⵔ ⴰⴷ ⵉⴳⴳ ⴰⴼⵔⵉⵡⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴹⵡⴰ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ. ");
INSERT INTO rift_vpl VALUES ("PR23_6","021_23_6","PRO","23","6","6","ⵡⴰⵔ ⵜⵜᵉⵜⵜ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵏⵏⵉ ⴷⵉ ⵜⴻⴵⴰ ⵜⵉⵟⵟ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵡⴰⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_7","021_23_7","PRO","23","7","7","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ, ⴰⵎⵎⵓ ⵉ ⵜ ⵉⵜⵜⴻⴳⴳ ⵏⴻⵜⵜⴰ. ⵉⵇⵇⴰⵔ: “ⴻⵛⵛ, ⵜⴻⵙⵡⴻⴷ!”, ⵎⴰⵛⴰ ⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⴰⴽⵉⴷⴻⴽ ⵉⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("PR23_8","021_23_8","PRO","23","8","8","ⴰⵣⴻⵄⵄⵉⴼ ⵉ ⵜⴻⵛⵛⵉⴷ, ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵜⵄⵓⵇⵇⴻⴷ, ⴰⵡⴰⵍⴻⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵏⵏⴻⵛ ⵜⴹⴻⵢⵢⵄⴻⴷ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_9","021_23_9","PRO","23","9","9","ⵡⴰⵔ ⵙⵉⵡⴻⵍ ⴷⴻⴳ ⵓⵎⴻⵣⵣⵓⵖ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵃⵇⴰⵔ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴼⵜⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR23_10","021_23_10","PRO","23","10","10","ⵡⴰⵔ ⵙⵎⵓⵟⵟⵓⵢ ⴰⵢⵎⵉⵔ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵡⴰⵔ ⵜⵜⴰⴷⴻⴼ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵉⵢⵓⵊⵉⵍⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR23_11","021_23_11","PRO","23","11","11","ⵎⴰⵖⴰⵔ ⴰⵎⴻⴼⴷⵉ ⵏⵙⴻⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵢⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("PR23_12","021_23_12","PRO","23","12","12","ⴰⵔⵔ ⵓⵍ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵡⴻⴱⴱⴻⵅ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR23_13","021_23_13","PRO","23","13","13","ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⴼ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵅ ⵓⵃⵓⴷⵔⵉ, ⵡⴰⵅⵅⴰ ⵜⴻⵛⵛⴰⵜⴻⴷ ⵜ ⵙ ⵡⴻⵄⵎⵓⴷ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("PR23_14","021_23_14","PRO","23","14","14","ⵛⴻⴽ ⴰⴷ ⵜ ⵜⴻⵡⵜⴻⴷ ⵙ ⵡⴻⵄⵎⵓⴷ, ⵓ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵣⵉ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR23_15","021_23_15","PRO","23","15","15","ⵎⵎⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵓⵍ ⵏⵏⴻⵛ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴰⴷ ⵉⴼⴰⵔⵃ ⵓⵍⴰ ⴷ ⵓⵍ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR23_16","021_23_16","PRO","23","16","16","ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ ⴰⴷ ⵏⴻⴳⵣⴻⵏⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰⵍⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ ⵙⵙⵉⵡⵍⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_17","021_23_17","PRO","23","17","17","ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵉⵙⵉⵎ ⵣⴻⴳ ⵉⵎⴻⴷⵏⴰⴱ, ⵎⴰⵛⴰ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⴰⵔⵔ ⴰⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴰⵙⵙ ⵉⵎⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("PR23_18","021_23_18","PRO","23","18","18","ⵎⴰⵖⴰⵔ ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⵡⴻⵛⵛⴰ, ⵓ ⵍⴰⵢⴰⵙ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ. ");
INSERT INTO rift_vpl VALUES ("PR23_19","021_23_19","PRO","23","19","19","ⵙⴻⵍ-ⴷⴷ ⵛⴻⴽ, ⴰ ⵎⵎⵉ, ⵉⵍⵉ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵏⴷⴻⵀ ⵓⵍ ⵏⵏⴻⵛ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PR23_20","021_23_20","PRO","23","20","20","ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⵖⴰⵔ ⵉⵙⴽⴰⵔⵊⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⵖⴰⵔ ⵉⵏⵏⵉ ⵉⵍⴻⵀⵀⴼⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("PR23_21","021_23_21","PRO","23","21","21","ⵎⴰⵖⴰⵔ ⴰⵙⴽⴰⵔⵊⵉⵢ ⴷ ⴰⵎⴻⵍⵀⵓⴼ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⴻⵣⵍⴰⴹ, ⵓ ⴰⵏⵓⴷⴻⵎ ⵉⵙⵙⵢⵉⵔⵉⴹ ⴷⴻⴳ ⵉⵃⵍⵓⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_22","021_23_22","PRO","23","22","22","ⵙⴻⵍ-ⴷⴷ ⵛⴻⴽ ⵖⴰⵔ ⴱⴰⴱⴰⵛ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⴷⴷ-ⵉⵊⵊⵉⵏ, ⵓ ⵡⴰⵔ ⵙⵙⴻⵃⵇⵉⵔⵉ ⵢⴻⵎⵎⴰⵛ ⵎⴰⵍⴰ ⵜⴻⵡⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR23_23","021_23_23","PRO","23","23","23","ⵙⴻⵖ-ⴷⴷ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵜⵜ ⵜⴻⵣⵏⵓⵣⴰ ⵛⴰ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⵉⵖⵉⵜ ⴷ ⵓⵡⴻⴱⴱⴻⵅ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR23_24","021_23_24","PRO","23","24","24","ⴱⴰⴱⴰⵙ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⴼⴰⵔⵃ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵊⵊⵉⵏ ⵉⵊⵊ ⵎⵎⵉⵙ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴰⴷ ⴰⵙ ⵉⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("PR23_25","021_23_25","PRO","23","25","25","ⴻⵊⵊ ⴰⴷ ⵉⴼⴰⵔⵃ ⴱⴰⴱⴰⵛ ⵓⵍⴰ ⴷ ⵢⴻⵎⵎⴰⵛ, ⴻⵊⵊ ⵜⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⴰⴷ ⵜⴼⴰⵔⵃ. ");
INSERT INTO rift_vpl VALUES ("PR23_26","021_23_26","PRO","23","26","26","ⴻⵡⵛ ⴰⵢⵉ ⵓⵍ ⵏⵏⴻⵛ, ⴰ ⵎⵎⵉ, ⴻⵊⵊ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⴰⴼⴻⵏⵜ ⴰⵔⴹⴰ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR23_27","021_23_27","PRO","23","27","27","ⵎⴰⵖⴰⵔ ⵜⴰⵎⵖⴰⵔⵜ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵢⵓⴵⵖⴻⵏ, ⵓ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⴱⴰⵔⵔⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵉⵃⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR23_28","021_23_28","PRO","23","28","28","ⵡⴰⵀ, ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵃⴰⵎⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵅⴻⵡⵡⴰⵏ, ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⵊⴰⵔ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_29","021_23_29","PRO","23","29","29","ⵡⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴻⵛⴹⴰⵏ? ⵡⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵣⵣⴻⵍⴹ? ⵡⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵎⵛⵓⴱⴱⴻⵛ? ⵡⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵛⴻⵜⵛⵉ? ⵡⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰⵏ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ? ⵡⵉ ⵉ ⵖⴰⵔ ⴵⴰⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴱⴱⴰⵔⴻⵡⵢⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("PR23_30","021_23_30","PRO","23","30","30","ⵖⴰⵔ ⵉⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵖⴰⵔ ⴱⵉⵏⵓ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ, ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⴰⵙⴻⵏ ⴱⵉⵏⵓ ⵉⵅⴻⴵⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR23_31","021_23_31","PRO","23","31","31","ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⴱⵉⵏⵓ, ⵅⵎⵉ ⵉⵜⵜⴻⵣⵡⵉⵖ, ⵉⵜⵜⵍⵉⵇⵍⵉⵇ ⴷⵉ ⵍⴽⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵀⵡⴻⵏ ⵉ ⵜⵉⵙⵙⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("PR23_32","021_23_32","PRO","23","32","32","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⵜⵜⵖⵉⵎⴰ ⵉⵣⴻⵄⵄⴻⴼ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⵉⵖⴰⵔ, ⵉⵜⵜⵔⵓⵛⵛⴰ ⵙⵙⴻⵎ ⴰⵎ ⵜⵍⴻⴼⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("PR23_33","021_23_33","PRO","23","33","33","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵡⴰⵍⴰⵏⵜ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ, ⵓ ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵅⴰⵔⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("PR23_34","021_23_34","PRO","23","34","34","ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⴻⵟⵟⵚⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵎ ⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⴻⵟⵟⵚⴻⵏ ⴷⵉ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵜⴻⵃⵏⴰⵛⵜ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ");
INSERT INTO rift_vpl VALUES ("PR23_35","021_23_35","PRO","23","35","35","ⴰⴷ ⵜⵉⵏⵉⴷ: “ⵡⵜⵉⵏ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⴻⵣⵎⴻⵖ, ⴷⴻⵅⵎⴻⵏ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⵛⵉⵖ ⴰⴽ-ⴷ ⵡⴰⵍⵓ. ⵎⴻⵍⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⴼⴰⵇⴻⵖ? ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵣⵓⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴱⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("PR24_1","021_24_1","PRO","24","1","1","ⵡⴰⵔ ⵜⵜⴰⵙⴻⵎ. ⵣⴻⴳ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓ ⵛⴰ ⵜⵎⵓⵏⴻⵜ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR24_2","021_24_2","PRO","24","2","2","ⵎⴰⵖⴰⵔ ⵓⵍ ⵏⵙⴻⵏ ⵉⵜⵜⴻⵇⵇⴻⵔ ⵖⴰⵔ ⵓⵔⴻⴷⴷⴻⴵ, ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵢⴻⵏ ⵖⴰⵔ ⴰⵔⵥⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR24_3","021_24_3","PRO","24","3","3","ⵜⴰⴷⴷⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵙ ⵜⵉⵖⵉⵜ, ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PR24_4","021_24_4","PRO","24","4","4","ⵙ ⵜⵓⵙⵙⵏⴰ ⵜⵜⵡⴰⵄⴻⵎⵎⴰⵔⴻⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⴷⴰⵅⴻⵍ, ⵙ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵉⵖⵍⴰⵏ ⴷ ⵡⴰⴳⵍⴰ ⵉⵍⵉⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR24_5","021_24_5","PRO","24","5","5","ⴰⵔⵢⴰⵣ ⴰⵎⵉⵖⵉⵙ ⵉⵊⵀⴻⴷ, ⴰⵔⵢⴰⵣ ⵏ ⵜⵓⵙⵙⵏⴰ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR24_6","021_24_6","PRO","24","6","6","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵓⵎⴻⵏⵖⵉ ⵙ ⵓⴷⴻⴱⴱⴰⵔ, ⵓ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵎⵛⴰⵡⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵓⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR24_7","021_24_7","PRO","24","7","7","ⵜⵉⵖⵉⵜ ⵜⵓⵄⵍⴰ ⵅ ⵓⴱⵓⵀⴰⵍⵉ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PR24_8","021_24_8","PRO","24","8","8","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⵉ ⵍⵖⴰⵔ, ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⴱⵓ-ⵜⴻⵃⵍⴰⵢⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR24_9","021_24_9","PRO","24","9","9","ⵍⴻⵎⵡⴰⵢⴰⵍ ⵏ ⵓⵅⴰⵔⵔⴻⵚ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⴷ ⴷⴷⴻⵏⴱ, ⵓ ⴰⵎⴻⵙⵜⴻⵀⵣⵉⵢ ⴷ ⵏⵏⵄⵉ ⵉ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR24_10","021_24_10","PRO","24","10","10","ⵎⴰⵍⴰ ⵜⴰⵔⵅⵓⴷ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR24_11","021_24_11","PRO","24","11","11","ⵙⴻⵏⵊⴻⵎ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵏⵖⴻⵏ, ⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("PR24_12","021_24_12","PRO","24","12","12","ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵏⵉⴷ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵡⴰⵍⵓ ⵅ ⵎⴰⵏ ⴰⵢⴰ!”, ⵎⴰ ⵡⴻⵏⵏⵉ ⵉⵡⴻⵣⵣⵏⴻⵏ ⵓⵍⴰⵡⴻⵏ, ⵡⴰⵔ ⵜ ⵉⵙⵙⴰⵔⴳⵉⴱ? ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵉⵙⵙⴻⵏ ⵉ-ⵜ! ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴱⵏⴰⴷⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR24_13","021_24_13","PRO","24","13","13","ⴻⵛⵛ ⵜⴰⵎⵎⴻⵏⵜ, ⴰ ⵎⵎⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵚⴱⴻⵃ, ⵜⴰⵎⵎⴻⵏⵜ ⵏ ⵜⴻⵖⵔⴰⵙⵜ ⴰⵇⴰ ⴷ ⵜⵎⵉⵥⵉⴷⵜ ⵉ ⵡⴰⵏⴻⵖ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR24_14","021_24_14","PRO","24","14","14","ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⵉⵖⵉⵜ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ⵎⴰⵍⴰ ⵜⵓⴼⵉⴷ ⵜⵜ, ⵅⴻⵏⵏⵉ ⵜⴻⴵⴰ ⵜⵉⵡⴻⵛⵛⴰ, ⵍⴰⵢⴰⵙ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵇⴻⵟⵟⴻⵄ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PR24_15","021_24_15","PRO","24","15","15","ⴰ ⴰⵄⴻⴼⴼⴰⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⵃⴰⵎⴰ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵡⴰⵔ ⵀⴻⴷⴷⴻⵎ ⴰⵎⵛⴰⵏ ⵏ ⵡⴰⵔⴻⵢⵢⴻⵃ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("PR24_16","021_24_16","PRO","24","16","16","ⵎⴰⵖⴰⵔ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵉⵡⴹⴰ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ ⵙ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR24_17","021_24_17","PRO","24","17","17","ⵡⴰⵔ ⴼⴰⵔⵔⴻⵃ ⵉ ⵓⵡⴻⵟⵟⵓ ⵏ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵇⴰⵔⴹ, ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⴼⴰⵔⵔⴻⵃ, ");
INSERT INTO rift_vpl VALUES ("PR24_18","021_24_18","PRO","24","18","18","ⵎⴰⵃⴻⵏⴷ ⵙⵉⴷⵉ ⵡⴰⵔ ⵜ ⵉⵥⴰⵔⵔ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⵉⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR24_19","021_24_19","PRO","24","19","19","ⵡⴰⵔ ⵜⵜⵅⴻⵢⵢⵉⵇ ⴰⵟⵟⴰⵙ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵡⴰⵔ ⵜⵜⴰⵙⴻⵎ ⵣⴻⴳ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR24_20","021_24_20","PRO","24","20","20","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵉⵡⴻⵛⵛⴰ, ⵍⴻⴼⵏⴰⵔ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("PR24_21","021_24_21","PRO","24","21","21","ⴰ ⵎⵎⵉ, ⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ ⴷ ⵓⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⵜⵜⵅⴻⴵⴻⴹ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵏⵇⴻⵍⴱⴻⵏ ⴽⵓⵍⵛⵉ, ");
INSERT INTO rift_vpl VALUES ("PR24_22","021_24_22","PRO","24","22","22","ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ, ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵏⴻⴳⴳⴰⵔⵓ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("PR24_23","021_24_23","PRO","24","23","23","ⵓⵍⴰ ⴷ ⵢⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ. ⴰⵙⴼⴰⵔⵣ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PR24_24","021_24_24","PRO","24","24","24","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵓⵄⴻⴼⴼⴰⵏ: “ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ!”, ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵜ ⵏⴻⵄⵍⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵜ ⵛⴰⵔⵀⴻⵏ ⵛⵛⵓⵄⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("PR24_25","021_24_25","PRO","24","25","25","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵃⴰⴽⵎⴻⵏ, ⴰⴷ ⵉⵍⵉⵏ ⵎⵍⵉⵃ, ⵍⴱⴰⵔⴰⴽⴰ ⵙ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵜⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR24_26","021_24_26","PRO","24","26","26","ⴰⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵓⴷⵓⵎⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⴰⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR24_27","021_24_27","PRO","24","27","27","ⵙⴻⵡⵊⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⴱⴰⵔⵔⴰ, ⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵓⵛⴰ ⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("PR24_28","021_24_28","PRO","24","28","28","ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ ⵅ ⵊⵊⴰⵔ ⵏⵏⴻⵛ. ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵖⴰⵔⵔⴻⴷ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("PR24_29","021_24_29","PRO","24","29","29","ⵡⴰⵔ ⵇⵇⴰⵔ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ, ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⴰⵙ ⵖⴰ ⴳⴳⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ!”, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR24_30","021_24_30","PRO","24","30","30","ⵏⴻⵛⵛ ⴽⴽⴻⵖ ⵅ ⵢⴻⵢⵢⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵄⴳⵓⵣ, ⵅ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵡⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵎⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR24_31","021_24_31","PRO","24","31","31","ⵅⵣⴰⵔ, ⵜⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⵜⴻⵢⵣⵉⵜ, ⵜⴻⴷⵍⴰ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵍⵃⵉⴹ ⵏⵏⴻⵙ ⵏ ⵡⴻⵥⵔⵓ ⵉⵜⵜⵡⴰⵀⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR24_32","021_24_32","PRO","24","32","32","ⵍⴰⵎⵉ ⵜⵜ ⵥⵔⵉⵖ, ⴽⵙⵉⵖ ⵜⵜ ⵖⴰⵔ ⵡⵓⵍ ⵉⵏⵓ, ⵥⵔⵉⵖ ⵜⵜ ⵓⵛⴰ ⴽⵙⵉⵖ ⵜⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵡⴻⴱⴱⴻⵅ. ");
INSERT INTO rift_vpl VALUES ("PR24_33","021_24_33","PRO","24","33","33","“ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵟⵟⵚⴻⵖ ⵛⵡⴰⵢⵜ ⴷⵔⵓⵙⵜ, ⵛⵡⴰⵢⵜ ⴷⵔⵓⵙⵜ ⵏ ⵓⵏⵓⴷⴻⵎ, ⵛⵡⴰⵢⵜ ⴷⵔⵓⵙⵜ ⵏ ⵓⴱⵓⵣⵣⴻⵍ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴹⴻⴼⵚⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR24_34","021_24_34","PRO","24","34","34","ⴷⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵣⵣⴻⵍⴹ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵍⴻⵖⴱⴻⵏ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵍⴻⵙⵏⴰⵃ.” ");
INSERT INTO rift_vpl VALUES ("PR25_1","021_25_1","PRO","25","1","1","ⵓⵍⴰ ⴷ ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵄⴰⵡⴰⴷⴻⵏ ⵓⵔⵉⵏ ⵜⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR25_2","021_25_2","PRO","25","2","2","ⴰⵇⴰ ⴷ ⵛⵛⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴰⵔ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⵎⴰⵛⴰ ⵛⵛⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⴰⴱⴻⵇⵇⴻⵛ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR25_3","021_25_3","PRO","25","3","3","ⵍⵓⵄⵍⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷ ⵡⵓⵍ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵡⴰⵔ ⴵⵉⵏ ⵉ ⵓⴱⴻⵇⵇⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR25_4","021_25_4","PRO","25","4","4","ⴽⴽⴻⵙ ⴽⵓⴼⴼⵓ ⵣⵉ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵡⴻⵎⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PR25_5","021_25_5","PRO","25","5","5","ⵙⴱⴻⵄⵄⴻⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵜⴻⵏ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵙ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR25_6","021_25_6","PRO","25","6","6","ⵡⴰⵔ ⵜⴼⴻⵢⵢⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉ ⵎⴰⵏⵉ ⵜⵜⴱⴻⴷⴷⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_7","021_25_7","PRO","25","7","7","ⵎⴰⵖⴰⵔ ⵉⵃⵍⴰ ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: “ⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴷⴰ!”, ⵓⵍⴰ ⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵀⵡⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵛⴻⵏⵏⴻⵄ ⵏⵏⵉ ⵥⵔⵉⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR25_8","021_25_8","PRO","25","8","8","ⵡⴰⵔ ⵜⵜⵇⴻⴵⵉⵇ ⴰⴷ ⵜⴻⴷⵄⵉⴷ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⴼⴹⴻⵃ? ");
INSERT INTO rift_vpl VALUES ("PR25_9","021_25_9","PRO","25","9","9","ⵛⴰⵔⵔⴻⵄ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵓⴼⴼⵓⵖ ⵙⵙⵉⵔⵔ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("PR25_10","021_25_10","PRO","25","10","10","ⵃⵉⵎⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵃⴻⵛⵛⴻⵎ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⵄⵄⴻⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵛ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PR25_11","021_25_11","PRO","25","11","11","ⴰⵎ ⵜⵜⴻⴼⴼⴰⵃⵉⵏ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵟⵟⴱⴰⵙⴰ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⵎⵎⵓ ⴵⴰⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵙⵙⵉⵡⵍⴻⵏ ⵜⴻⵏ ⵙ ⵍⴻⵇⵢⴰⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR25_12","021_25_12","PRO","25","12","12","ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉⵖⵍⴰⵏ ⵇⴰⵄ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵓⵡⴻⴱⴱⴻⵅ ⴰⵎⵉⵖⵉⵙ ⵖⴰⵔ ⵓⵎⴻⵣⵣⵓⵖ ⵉⵜⵜⴻⵙⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_13","021_25_13","PRO","25","13","13","ⴰⵎ ⵡⴻⴷⴼⴻⵍ ⴰⵙⴻⵎⵎⴰⴹ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵜⵎⴻⵢⵔⴰ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⴻⴽⴽⴰⵏ, ⵎⴰⵖⴰⵔ ⵉⵙⵙⴼⴰⵇⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR25_14","021_25_14","PRO","25","14","14","ⴰⵎ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⵓⵙⴻⵎⵎⵉⴹ ⴱⵍⴰ ⴰⵏⵥⴰⵔ, ⴰⵎⵎⵓ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵄⴻⴼⴼⴰⵔ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵔⵣⴻⴼⵜ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_15","021_25_15","PRO","25","15","15","ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵇⵏⴻⵄ ⵍⵃⴰⴽⴻⵎ, ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⴰⵎⵉⵥⵉⴷ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵉⵖⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_16","021_25_16","PRO","25","16","16","ⵎⴰⵍⴰ ⵜⵓⴼⵉⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⴻⵛⵛ ⵎⵉⵏ ⵜⴻⵃⵡⴰⵊⴻⴷ ⵡⴰⵀⴰ, ⵏⵉⵖ ⴰⴷ ⵜⴰⴼⴼ ⵜⴻⵛⵛⵉⴷ ⴽⵜⴰⵔ ⵣⵉ ⵎⵉⵏ ⵜⴻⵃⵡⴰⵊⴻⴷ, ⵓ ⴱⴰⵍⴰⴽ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ ⵜⵄⵓⵇⵇⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR25_17","021_25_17","PRO","25","17","17","ⵡⴰⵔ ⵙⵙⵔⵓⵙⴰ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⵏⵉⵖ ⴰⴷ ⵛⴻⴽ ⵉⵊⵊⵉⵡⴻⵏ ⵓ ⴰⴷ ⵛⴻⴽ ⵉⵄⵉⴼⴼ. ");
INSERT INTO rift_vpl VALUES ("PR25_18","021_25_18","PRO","25","18","18","ⴰⵎ ⵡⴻⴼⴹⵉⵙ ⴷ ⵙⵙⵉⴼ ⴷ ⴼⵍⵉⵜⵛⴰ ⵉⵇⴻⴹⵄⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵙ ⵥⵓⵔ ⵅ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR25_19","021_25_19","PRO","25","19","19","ⴰⵎ ⵜⵉⵖⵎⴻⵙⵜ ⵢⴰⵔⵥⴻⵏ ⵓ ⴰⵎ ⵓⴹⴰⵔ ⵉⵏⵇⵔⴰⴹⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵓⵜⴻⵛⵍⵉ ⵅ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵜⵜⵉⵇⴻⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR25_20","021_25_20","PRO","25","20","20","ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴽⴽⵙⴻⵏ ⴰⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⵙⵎⴻⴹ ⵓ ⴰⵎ ⵍⵅⴻⴵ ⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵅ ⵏⵉⵟⵔⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ ⵉⵣⵍⴰⵏ ⵣⵣⴰⵜ ⵉ ⵢⵉⵊⵊⴻⵏ ⵙ ⵡⵓⵍ ⵉⵛⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_21","021_25_21","PRO","25","21","21","ⵎⴰⵍⴰ ⵉⴵⵓⵥ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵅⴻⵏⵏⵉ ⴻⵡⵛ ⴰⵙ ⴰⵖⵔⵓⵎ, ⵎⴰⵍⴰ ⵉⴼⴼⵓⴷ, ⴻⵡⵛ ⴰⵙ ⴰⴷ ⵉⵙⵓ, ");
INSERT INTO rift_vpl VALUES ("PR25_22","021_25_22","PRO","25","22","22","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵜⵢⴰⵔⵔⵡⴻⴷ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵓ ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵅⴻⴵⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("PR25_23","021_25_23","PRO","25","23","23","ⴰⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵏⵥⴰⵔ, ⵉⵍⴻⵙ ⴰⵖⴻⴷⴷⴰⵔ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵓⴷⵎⴰⵡⴻⵏ ⵉⵅⴻⵢⵢⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_24","021_25_24","PRO","25","24","24","ⵉⵃⵍⴰ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵜⵣⴻⵇⵇⴰ, ⵓⵍⴰ ⵅ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵛⴰⵔⵛ. ");
INSERT INTO rift_vpl VALUES ("PR25_25","021_25_25","PRO","25","25","25","ⴰⵎ ⵡⴰⵎⴰⵏ ⵉⵚⴻⵎⵎⴰⴹⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵢⵓⵃⴻⵍ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("PR25_26","021_25_26","PRO","25","26","26","ⴰⵎ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵉⵜⵜⵡⴰⴼⴻⵙⴷⴻⵏ ⵓ ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴰⵏⵓ ⵖⴻⵛⵛⴻⵏ ⵜ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⵣⴻⵄⵣⵉⵄⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_27","021_25_27","PRO","25","27","27","ⵎⴰⵛⵛⴰ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴰⵎⵎⴻⵏⵜ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵎⵍⵉⵃ, ⵎⴰⵛⴰ ⵜⴰⵔⴻⵣⵣⵓⵜ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵢⴻⵡⵄⴰⵔⴻⵏ ⴷ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR25_28","021_25_28","PRO","25","28","28","ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵀⴻⴷⵎⴻⵏ ⴱⵍⴰ ⵍⵃⵉⴹ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵜⵜⴻⵟⵟⴻⴼ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_1","021_26_1","PRO","26","1","1","ⴰⵎ ⵡⴻⴷⴼⴻⵍ ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ ⵓ ⴰⵎ ⵡⴻⵏⵥⴰⵔ ⴷⵉ ⵜⵎⴻⵢⵔⴰ, ⴰⵎⵎⵓ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⵛⴰⵏ ⴰⴽ-ⴷ ⵓⴱⵓⵀⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PR26_2","021_26_2","PRO","26","2","2","ⴰⵎ ⵥⵥⴰⵡⴻⵛ ⵉⵜⵜⴼⴰⵔⴼⴰⵔⴻⵏ, ⴰⵎ ⵜⴼⴰⵍⴵⴻⵙⵜ ⵉⵟⵟⴰⵡⴻⵏ ⵙⵙⴰ ⴷ ⵙⵙⴰ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⴰ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ, ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⵍⴻⵇⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("PR26_3","021_26_3","PRO","26","3","3","ⴰⵔⴻⴽⴽⵓⴹ ⵉ ⵓⵢⵉⵙ, ⵙⵍⵉⵎⴻⵜ ⵉ ⵡⴻⵖⵢⵓⵍ, ⵓ ⴰⵄⵎⵓⴷ ⵉ ⵡⴻⵄⵔⵓⵔ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR26_4","021_26_4","PRO","26","4","4","ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉ ⵅ ⵓⴱⵓⵀⴰⵍⵉ ⴰⵏⴻⵛⵜ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⴰⵔⴻⴽⴽⵡⴻⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR26_5","021_26_5","PRO","26","5","5","ⴰⵔⵔ-ⴷⴷ ⵅ ⵓⴱⵓⵀⴰⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_6","021_26_6","PRO","26","6","6","ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴻⵙⵙⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⵍⵄⵓⵏⴼ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽⴰⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PR26_7","021_26_7","PRO","26","7","7","ⵜⵉⵎⴻⵙⵙⴰⴹⵉⵏ ⵏ ⵓⵏⴻⵄⴹⴰⴱ ⴰⵔⴻⵀⴼⴻⵏⵜ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵓⵍⴰ ⴷ ⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR26_8","021_26_8","PRO","26","8","8","ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴷⴷⴰⵏ ⴰⵥⵔⵓ ⵉⵖⵍⴰⵏ ⴷⴻⴳ ⵉⴵⵉⵢ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵛⵛⴰⵏ ⵉ ⵓⴱⵓⵀⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("PR26_9","021_26_9","PRO","26","9","9","ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵉⵡⴻⵏⵜ ⵏ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⴷⴷ-ⵉⴳⴳⴻⵄⵄⴷⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵙⴽⴰⵔⵊⵉ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵍⵎⴰⵜⴰⵍ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR26_10","021_26_10","PRO","26","10","10","ⴰⵟⵟⴰⵙ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵣⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵍⵎⵓⵏⴻⵜ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵖⴰ ⵉⵛⵔⴰⵏ, ⴰⴷ ⵅⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR26_11","021_26_11","PRO","26","11","11","ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵇⵣⵉⵏ ⵉⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵎⵉⵏ ⵉⵄⵓⵇⵇ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵄⴰⵡⴰⴷ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_12","021_26_12","PRO","26","12","12","ⵎⴰ ⵜⴻⵥⵔⵉⴹ ⵄⴻⵎⵎⴰⵔⵚ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵎⵉⵖⵉⵙ? ⴰⵇⴰ ⴷⵉⵏ ⵍⴰⵢⴰⵙ ⴰⵟⵟⴰⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵓⵍⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_13","021_26_13","PRO","26","13","13","ⴰⵎⴻⵄⴳⵓⵣ ⵉⵇⵇⴰⵔ: “ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴰⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("PR26_14","021_26_14","PRO","26","14","14","ⴰⵎ ⵜⴻⵡⵡⴰⵔⵜ ⵜᵉⵜⵜⵓⵏⵏⵓⴹ ⵉ ⵜⴻⵖⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵓⵏⵓⴹ ⵓⵍⴰ ⴷ ⴰⵎⴻⵄⴳⵓⵣ ⴷⵉ ⵇⴰⵎⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_15","021_26_15","PRO","26","15","15","ⴰⵎⴻⵄⴳⵓⵣ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⴻⴱⵚⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵅⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵙⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("PR26_16","021_26_16","PRO","26","16","16","ⴰⵎⴻⵄⴳⵓⵣ ⵉⵜⵜⵡⴰⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵣⵉ ⵙⴻⴱⵄⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR26_17","021_26_17","PRO","26","17","17","ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵡⴻⵇⵣⵉⵏ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_18","021_26_18","PRO","26","18","18","ⴰⵎ ⵉⵊⵊ ⵏ ⵓⵎⴻⵊⵏⵓⵏ ⵏⵏⵉ ⵉⵛⵛⴰⵜⴻⵏ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⴷ ⴼⵍⵉⵜⵛⴰⵜ ⴷ ⵙⵙⴻⵎ ⵉⵏⴻⵇⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR26_19","021_26_19","PRO","26","19","19","ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵛⴻⵎⵜⴻⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵇⵇⴰⵔ: “ⴰⵇⴰ ⵜⵜⵇⴻⵙⵙⴰⵔⴻⵖ ⵡⴰⵀⴰ, ⵏⵉⵖ ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("PR26_20","021_26_20","PRO","26","20","20","ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⵓⴽⴻⵛⵛⵓⴹ, ⴰⴷ ⵜⴻⵅⵙⵉ ⵜⵎⴻⵙⵙⵉ, ⵓ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵅⴱⴰⵔⵊⵉ, ⵢⴰⵔⴻⵙⵙⴰ ⵓⵎⵛⵓⴱⴱⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR26_21","021_26_21","PRO","26","21","21","ⴰⵎ ⵉⴵⴰ ⵍⴻⴼⵃⴻⵎ ⵉ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵉⵙⵏⴻⴽⴽⴰⵔ ⴰⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PR26_22","021_26_22","PRO","26","22","22","ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵅⴱⴰⵔⵊⵉⵢ ⴰⵎ ⵃⴰⵍⴰⵡⵉⵜ, ⵜⵉⵏⵏⵉ ⵀⴻⴽⴽⵡⴰⵏⵜ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵓⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_23","021_26_23","PRO","26","23","23","ⴰⵎ ⴽⵓⴼⴼⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵅ ⵓⵛⴻⴵⵉⵇ ⵏ ⵜⵍⴰⵅⵜ, ⴰⵎⵎⵓ ⵉ ⴵⴰⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵎⵉⵣⵉⴹⴻⵏ ⵏ ⵢⵉⵊⵊⴻⵏ ⵙ ⵡⵓⵍ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR26_24","021_26_24","PRO","26","24","24","ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵡⴻⵛⵔⴰⵀ, ⵉⵙⵙⵏⵓⴼⴼⴰⵔⴰ ⵉ-ⵜ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PR26_25","021_26_25","PRO","26","25","25","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵃⴻⵛⵛⴻⵎ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜ ⵜⵜⵉⵇⵇⵉ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵙⴻⴱⵄⴰ ⵏ ⵏⵏⵄⴰⵡⴰⵜ ⴰⵇⴰ ⴷⵉⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_26","021_26_26","PRO","26","26","26","ⵓⵍⴰ ⵎⴰⵍⴰ ⵉⵍⴻⵃⵃⴻⴼ ⵡⴻⵛⵔⴰⵀ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵛⵎⴰⵜ, ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("PR26_27","021_26_27","PRO","26","27","27","ⵡⴻⵏⵏⵉ ⵉⵖⵣⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵡⴹⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵓ ⵜⴰⵚⴹⴰⵔⵜ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵙⵙⴻⵇⵏⵓⵏⵏⵓⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR26_28","021_26_28","PRO","26","28","28","ⵉⵍⴻⵙ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵉⵛⴰⵔⵔⴻⵀ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⴷⴷⴵⴻⵏ, ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⴰⵍⴻⵇⵇⴰⵖ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⵅⴰⵔⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR27_1","021_27_1","PRO","27","1","1","ⵡⴰⵔ ⵜⵜⴼⴻⵢⵢⴻⵛ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵉⵡⴻⵛⵛⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⵎⵉⵏ ⴷⴷ ⵖⴰ ⵢⴰⵡⵉ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("PR27_2","021_27_2","PRO","27","2","2","ⴻⵊⵊ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⴷ ⵛⴻⴽ ⵉⵛⴻⵏⵏⴻⵄ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵉⵊⵊ ⵏ ⵎⵉⴷⴷⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR27_3","021_27_3","PRO","27","3","3","ⴰⵥⵔⵓ ⵉⴷⵇⴻⵍ, ⵉⵊⴷⵉ ⵉⵡⴻⵣⵣⴻⵏ, ⵎⴰⵛⴰ ⴰⴼⵓⴳⴻⵎ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵉⴷⵇⴻⵍ ⵅⴰⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_4","021_27_4","PRO","27","4","4","ⴰⵙⵄⴰⵔ ⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⴰⵇⴰ ⴰⵜⴻⵏ ⵇⴻⵙⵃⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⵓⵙⵎⵉ? ");
INSERT INTO rift_vpl VALUES ("PR27_5","021_27_5","PRO","27","5","5","ⵜⴻⵃⵍⴰ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵅ ⵜⴰⵢⵔⵉ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_6","021_27_6","PRO","27","6","6","ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵇⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏ ⵍⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵉⵙⵓⴷⵉⵎⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⵇⴰ ⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR27_7","021_27_7","PRO","27","7","7","ⵡⴻⵏⵏⵉ ⵉⵊⵊⵉⵡⵏⴻⵏ, ⵉⵄⴻⵊⵊⴻⵏ ⵅ ⵜⴰⵎⵎⴻⵏⵜ ⵏ ⵜⴻⵖⵔⴰⵚⵜ, ⵎⴰⵛⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⴰⵔⴻⵣⴳⴻⵏ ⴷ ⴰⵎⵉⵥⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PR27_8","021_27_8","PRO","27","8","8","ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ ⵉⵟⵟⴰⵡ, ⵉⴳⴳⵯⴻⴷ ⵣⵉ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵟⴻⵍⵍⵄⴻⵏ ⴱⴰⵔⵔⴰ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR27_9","021_27_9","PRO","27","9","9","ⵣⵣⴻⵛⵜ ⴷ ⵍⴻⴱⵅⵓⵔ ⵙⵙⴼⴰⵔⵔⴰⵃⴻⵏ ⵓⵍ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵜⴰⵎⵙⴻⵄⵄⴰⴼⵜ ⵉⵛⵏⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵣⵉ ⵛⵛⵡⴰⵔ ⵏ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("PR27_10","021_27_10","PRO","27","10","10","ⵡⴰⵔ ⵙⴻⵎⵎⴻⵃ ⴷⴻⴳ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷⴻⴳ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⴱⴰⴱⴰⵛ, ⵡⴰⵔ ⵜⵜⵉⴷⴻⴼ ⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ. ⵉⵃⵍⴰ ⵉⵊⵊ ⵏ ⵡⴰⵊⵊⴰⵔ ⵢⵓⴷⴻⵙ ⵅ ⵉⵊⵊ ⵏ ⵜⴻⵡⵎⴰⵜ ⵢⵉⴳⴳⵯⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("PR27_11","021_27_11","PRO","27","11","11","ⵉⵍⵉ ⴷ ⴰⵎⵉⵖⵉⵙ, ⴰ ⵎⵎⵉ, ⵓ ⵙⴼⴰⵔⵃ ⵓⵍ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵅ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_12","021_27_12","PRO","27","12","12","ⵡⴻⵏⵏⵉ ⵉⴼⴻⵜⵜⵏⴻⵏ ⵉⵜⵜⵡⴰⵍⴰ ⵍⵖⴰⵔ ⵓⵛⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ ⴰⵔⴻⵏⵏⵉⵏ ⴳⴳⵓⵔⴻⵏ ⵓⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵇⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_13","021_27_13","PRO","27","13","13","ⴽⵙⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵉⴷⴷⴰⴽⴽⵡⴰⵍ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⴽⵙⵉ ⵜ ⴷ ⴷⴷⵉⵢⵢⴻⵜ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR27_14","021_27_14","PRO","27","14","14","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⴽⴻⵏ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ ⵣⵉⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⵏⵏⴻⵄⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR27_15","021_27_15","PRO","27","15","15","ⴰⵎⴻⵛⵏⴰⵡ ⵜⵓⴷⴷⵉⵎⵜ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵏⵥⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_16","021_27_16","PRO","27","16","16","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⴰⵙ ⵉⴱⴻⵍⵍⴻⵄ, ⴰⵇⴰ-ⵜ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵉⵇⴰⵍⴰ ⵉ ⵓⵙⴻⵎⵎⵉⴹ, ⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⵣⵣⴻⵛⵜ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_17","021_27_17","PRO","27","17","17","ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⴹⴰⵄⴻⵏ ⵓⵣⵣⴰⵍ ⵙ ⵡⵓⵣⵣⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵇⴹⴰⵄ ⵡⴻⵔⵢⴰⵣ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵡⴻⵏⵏⵉ ⵜ ⵢⵓⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_18","021_27_18","PRO","27","18","18","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵅ ⵉⵊⵊ ⵏ ⵡⴰⵔⵜⵓ, ⴰⴷ ⵉⵛⵛ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⴱⴰⴱ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PR27_19","021_27_19","PRO","27","19","19","ⴰⵎ ⴷⴷ-ⵉⵜⵜⴱⴰⵏ ⵓⵖⴻⵎⴱⵓⴱ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⴰⵎⵎⵓ ⴷⴷ-ⵉⵜⵜⴱⴰⵏ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⴱⵏⴰⴷⴻⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PR27_20","021_27_20","PRO","27","20","20","ⴰⵎ ⵍⴰⵅⴰⵔⵜ ⴷ ⵓⵙⵀⴻⵍⵍⴻⴽ ⵡⴰⵔ ⵜⵜⵢⵉⵡⵉⵏⴻⵏ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵡⴷⴰⵏ ⵡⴰⵔ ⵜⵜⵉⵡⴹⴻⵏⵜ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("PR27_21","021_27_21","PRO","27","21","21","ⴰⵟⴻⵏⵊⵉⵔ ⵏ ⵓⵙⴻⴼⵙⵉ ⵉ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵓⴼⴰⵔⵔⴰⵏ ⵉ ⵡⵓⵔⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵓⵍⴰ ⴷ ⴰⵔⵢⴰⵣ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵜⵎⴻⴷⴷⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_22","021_27_22","PRO","27","22","22","ⵎⴰⵍⴰ ⵜⴻⴷⴷⵣⴻⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵙ ⵡⴻⵣⴷⵓⵣ ⴷⵉ ⵍⵎⴻⵀⵔⴰⵣ ⵊⴰⵔ ⵍⵃⴻⴱⴱ ⵏ ⵉⵎⴻⵏⴷⵉ, ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵅⴰⵙ ⵜⵃⴻⵢⵢⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("PR27_23","021_27_23","PRO","27","23","23","ⵃⴹⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴱⴰⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵛ, ⵡⴻⵊⵊⴻⵀ ⵓⵍ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR27_24","021_27_24","PRO","27","24","24","ⵎⴰⵖⴰⵔ ⵍⴻⴽⵙⵉⴱⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵉ ⵍⴻⴱⴷⴰ, ⵏⵉⵖ ⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵏⵏⴻⵖⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("PR27_25","021_27_25","PRO","27","25","25","ⵎⴰⵍⴰ ⵉⵔⵓⵃ ⴰⵔⴱⵉⵄ ⵓⵛⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵓⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ, ⵉⵜⵜⵡⴰⵃⵜⴻⵛ ⴰⴼⵙⵓ ⵅ ⵉⴷⵓⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("PR27_26","021_27_26","PRO","27","26","26","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵏ ⵢⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR27_27","021_27_27","PRO","27","27","27","ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵎⵉⵏ ⵜⴻⵃⵡⴰⵊⴻⴷ ⵏ ⵓⵖⵉ ⵏ ⵜⵖⴰⵢⵟⵉⵏ ⵉ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵛ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵍⴻⵄⵡⴻⵍⵜ ⵉ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵛ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR28_1","021_28_1","PRO","28","1","1","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵜⵜⵔⴰⴽⴽⵡⴰⵍⴻⵏ ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵡⵉ ⵉ-ⵜⴻⵏ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵜⴰⵔⵢⴰⵙⵜ ⴰⵎ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵢⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PR28_2","021_28_2","PRO","28","2","2","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵍⴻⵄⵇⴻⵍ ⴷ ⵜⵓⵙⵙⵏⴰ, ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵚⵚⵓⵍⵟⴰ ⵜⴱⴻⴷⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⴰⵣⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR28_3","021_28_3","PRO","28","3","3","ⴰⵔⵢⴰⵣ ⴰⵎⴻⵣⵍⵓⴹ ⵏⵏⵉ ⵉⵜⵜⵣⴻⵢⵢⴰⵔⴻⵏ ⵅ ⵉⵎⴰⵔⵅⴰ, ⴰⵎ ⵡⴻⵏⵥⴰⵔ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵎⴰⵔⵔⴰ, ⴰⵍ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PR28_4","021_28_4","PRO","28","4","4","ⵉⵏⵏⵉ ⵉⵜⵜⴻⵊⵊⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR28_5","021_28_5","PRO","28","5","5","ⵉⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ ⵍⵃⴻⵇⵇ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ, ⴼⴻⵀⵀⵎⴻⵏ ⵉ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("PR28_6","021_28_6","PRO","28","6","6","ⵉⵃⵍⴰ ⵓⵎⴻⵣⵍⵓⴹ ⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵉⵚⴼⴰ, ⵅ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵉⴼⴰⵔⵖ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵔⵉⴷⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("PR28_7","021_28_7","PRO","28","7","7","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵉⴼⴻⵀⵀⴻⵎ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵉⵎⴻⵍⵀⴰⴼ, ⵢⴰⵔⵔⴰ ⴱⴰⴱⴰⵙ ⴰⴷ ⵉⵙⴻⴹⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("PR28_8","021_28_8","PRO","28","8","8","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵙ ⴰⵔⵔⵉⴱⴰ ⴷ ⵡⴰⵔⴱⴻⵃ, ⵉⵙⵙⵎⵓⵏⴰ ⴰⵢⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⵉⵏⵏⴰⵏ ⵅ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PR28_9","021_28_9","PRO","28","9","9","ⵡⴻⵏⵏⵉ ⵉⵙⵙⵃⴻⵢⵢⴰⴷⴻⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵙⴻⴵⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵄⴰⴷ ⵜⴰⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ ⴷ ⵏⵏⵄⵉ. ");
INSERT INTO rift_vpl VALUES ("PR28_10","021_28_10","PRO","28","10","10","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉ ⴷⵉ ⵜⴻⴵⴰ ⵍⴻⴽⵎⴰⵔⴻⵜ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR28_11","021_28_11","PRO","28","11","11","ⴱⵓ-ⵡⴰⴳⵍⴰ ⵉⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵏⵏⵉ ⴷⵉ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵢⴰⵔⴳⴻⴱ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_12","021_28_12","PRO","28","12","12","ⵎⴰⵍⴰ ⴰⴷ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵄⵓⴵⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⴷ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_13","021_28_13","PRO","28","13","13","ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵍⴻⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵜⵜⴻⴼⵍⵉⵃ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⴻⵄⵄⵎⴻⵏ ⵓ ⵉⵜⵜⵃⴻⵢⵢⴰⴷ ⵅⴰⵙⴻⵏ, ⴰⴷ ⵢⴰⴼ ⴰⵔⵔⴻⵃⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR28_14","021_28_14","PRO","28","14","14","ⵙⵙⴻⵄⴷ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ ⴱⵍⴰ ⴰⴱⴻⴷⴷⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰⵃⴻⵏ ⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PR28_15","021_28_15","PRO","28","15","15","ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ ⵉⵜⵜⴰⵔⵔⵓⵊⴷⵓⴷⴻⵏ, ⴰⵎ ⵉⵊⵊ ⵏ ⴷⴷⵓⴱ ⵉⵜⵜⵍⴰⵥⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⵉⵀⴰ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵣⵍⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("PR28_16","021_28_16","PRO","28","16","16","ⵍⵃⴰⴽⴻⵎ ⵏⵏⵉ ⴱⵍⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴻⵔⴱⴰⵃ ⵙ ⵓⴱⴻⵄⵄⴻⵊ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⴰⵔⴱⴻⵃ, ⴰⴷ ⵉⵣⵣⵓⴳⴳⴰⵔⵜ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_17","021_28_17","PRO","28","17","17","ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵓⵎⵉ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵜ ⵉⵙⵙⴱⴻⴷⴷ! ");
INSERT INTO rift_vpl VALUES ("PR28_18","021_28_18","PRO","28","18","18","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⴰⴷ ⵉⵏⵊⴻⵎ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵉⴼⴰⵔⵖ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵔⵉⴷⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⴰⵔ ⴰⴷ ⵉⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR28_19","021_28_19","PRO","28","19","19","ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵣⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵊⵊⴰⵡⴻⵏ ⵙ ⵡⴻⵖⵔⵓⵎ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⵔⵢⴰⵣ ⵉⵅⵡⴰⵏ, ⴰⴷ ⵉⵊⵊⴰⵡⴻⵏ ⵣⵣⴻⵍⴹ. ");
INSERT INTO rift_vpl VALUES ("PR28_20","021_28_20","PRO","28","20","20","ⴰⵔⵢⴰⵣ ⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ ⴰⴷ ⵉⴽⵙⵉ ⴰⵟⵟⴰⵙ ⵏ ⵍⴱⴰⵔⴰⴽⴰⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⴰⴳⵍⴰ, ⵡⴰⵔ ⵉⵜⵜⵡⵉⵃⵙⵉⴱ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("PR28_21","021_28_21","PRO","28","21","21","ⴰⵙⴼⴰⵔⵣ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵡⴰⵔ ⵉⵛⵏⵉ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵍⴻⵇⵇⵓⵣ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉⵣⴻⵎⵎⴰⵔ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PR28_22","021_28_22","PRO","28","22","22","ⴰⵔⵢⴰⵣ ⵙ ⵜⵉⵟⵟ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵉⵜⵜⵇⴻⴵⵉⵇ ⵖⴰⵔ ⵡⴰⴳⵍⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴰⵇⴰ ⵍⴻⵅⵙⴻⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_23","021_28_23","PRO","28","23","23","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴰⵇⴰⴱⴻⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⴰⴷ ⵢⴰⴼ ⴰⵔⴹⴰ ⴽⵜⴰⵔ ⵅ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵛⴰⵏⴰⵏ ⵜⴰⵥⵢⵓⴹⵉ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_24","021_28_24","PRO","28","24","24","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ ⵓⵛⴰ ⵉⵇⵇⴰⵔ: “ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴷⴷⴻⵏⴱ!”, ⴰⵇⴰ-ⵜ ⴷ ⴰⵛⵔⵉⵛ ⵏ ⵉⵊⵊ ⵏ ⴱⵓ-ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR28_25","021_28_25","PRO","28","25","25","ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵏⵏⴼⴰⵅⴻⵜ, ⵉⵙⵙⴻⴽⴽⴰⵔⴰ-ⴷⴷ ⴰⵎⵛⵓⴱⴱⴻⵛ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵍⴰⴱⴰⵙ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_26","021_28_26","PRO","28","26","26","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴷ ⴰⴱⵓⵀⴰⵍⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴷⵉ ⵜⵉⵖⵉⵜ, ⴰⴷ ⵉⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PR28_27","021_28_27","PRO","28","27","27","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵉ ⵉⵎⴻⵣⵍⴰⴹ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⵍⴻⵖⴱⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵇⵇⵏⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR28_28","021_28_28","PRO","28","28","28","ⵎⴰⵍⴰ ⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵏⵓⴼⴼⴰⵔ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_1","021_29_1","PRO","29","1","1","ⴰⵔⵢⴰⵣ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⵃⴻⵏ ⵢⵉⵔⵉ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵄⴰⵇⴱⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⴰⴷ ⵢⴰⵔⵥ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ ⵓⴳⴻⵏⴼⵓ. ");
INSERT INTO rift_vpl VALUES ("PR29_2","021_29_2","PRO","29","2","2","ⵎⴰⵍⴰ ⴷⴻⵡⵍⴻⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵙ ⵚⵚⵓⵍⵟⴰ, ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵃ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵓⵄⴻⴼⴼⴰⵏ, ⵉⵡⴻⵄⵄⴻⴹ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("PR29_3","021_29_3","PRO","29","3","3","ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵉⵖⵉⵜ, ⵉⵙⵙⴼⴰⵔⵔⴰⵃ ⴱⴰⴱⴰⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵎⵓⵏⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR29_4","021_29_4","PRO","29","4","4","ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⴱⴻⴷⴷⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵍⵃⴻⵇⵇ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵉⵀⴻⴷⴷⴻⵎ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PR29_5","021_29_5","PRO","29","5","5","ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵙⵙⵡⴰⵟⴰⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⵉⵛⵜ ⵏ ⵜⵔⴰⵛⵛⴰ ⵉ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR29_6","021_29_6","PRO","29","6","6","ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⴻⵙⵍⵉⵡⵍⴻⵡ ⵓ ⵉⴼⴰⵔⵔⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("PR29_7","021_29_7","PRO","29","7","7","ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵙⵙⴻⵏ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵉⵎⴰⵔⵅⴰ, ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵉⴼⴻⵀⵀⴻⵎ ⵡⴰⵍⵓ ⴷⵉ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PR29_8","021_29_8","PRO","29","8","8","ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⵢⴻⵏ ⵙⵙⴻⴽⴽⴰⵔⴰⵏ ⴰⵖⴻⵡⵡⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵛⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵙⵙⵏⴻⵇⵍⴰⴱⴻⵏ ⴰⵖⴹⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PR29_9","021_29_9","PRO","29","9","9","ⵎⴰⵍⴰ ⴰⵎⵉⵖⵉⵙ ⵉⴽⵙⵉ-ⴷⴷ ⵜⴰⵏⴼⵓⵍⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴳⴳⵓⵔ ⴰⴷ ⵉⵅⴻⵢⵢⴻⵇ ⵡⴰⵏⵉⵜⴰ ⵓ ⴰⴷ ⵉⴹⵃⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵍⵀⵓⴷⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR29_10","021_29_10","PRO","29","10","10","ⵉⵔⵢⴰⵣⴻⵏ ⵓⵎⵉ ⵉⵜⵜⴻⵄⵊⵉⴱ ⵉⴷⴰⵎⵎⴻⵏ ⵛⴰⵔⵔⵀⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴽⴻⵎⵎⵍⴻⵏ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR29_11","021_29_11","PRO","29","11","11","ⴰⴱⵓⵀⴰⵍⵉ ⵉⴹⴻⴵⴻⵇ ⵉ ⵎⴰⵔⵔⴰ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵎⵉⵖⵉⵙ ⵉⵜⵜⵇⴻⵎⵎⴻⵄ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("PR29_12","021_29_12","PRO","29","12","12","ⵍⵃⴰⴽⴻⵎ ⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ ⵉ ⵍⵀⴰⵔⴷ ⵏ ⵉⵅⴰⵔⵔⵉⵇⵇⴻⵏ, ⵣⵣⴰⵢⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_13","021_29_13","PRO","29","13","13","ⴰⵎⴻⵣⵍⵓⴹ ⴷ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵡⴰⵃⵙⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ, ⵎⵙⴰⴳⴰⵔⴻⵏ, ⵙⵉⴷⵉ ⵉⵙⵙⵏⴻⵡⵡⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_14","021_29_14","PRO","29","14","14","ⴰⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵎⴰⵔⵅⴰ ⴷⵉ ⵛⵛⵔⴻⵄ, ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("PR29_15","021_29_15","PRO","29","15","15","ⴰⵄⵎⵓⴷ ⴷ ⵓⵡⴻⴱⴱⴻⵅ ⵜⵜⵉⵛⴻⵏ ⵜⵉⵖⵉⵜ, ⵎⴰⵛⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵊⵊⵉⵏ ⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵢⴰⵔⵔⴰ ⵢⴻⵎⵎⴰⵙ ⴰⴷ ⵜⵙⴻⴹⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("PR29_16","021_29_16","PRO","29","16","16","ⵎⴰⵍⴰ ⴷⴻⵡⵍⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵊⴻⵀⴷⴻⵏ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⴻⵏⵏⵉ ⵓⵅⴻⵟⵟⵓ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵡⴻⵟⵟⵓ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_17","021_29_17","PRO","29","17","17","ⴰⵔⴻⴱⴱⴰ ⵎⵎⵉⵛ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵛ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵜⵉⵎⵉⵥⵉⴷⵉⵏ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR29_18","021_29_18","PRO","29","18","18","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵍⴻⵡⵃⵉⵢ, ⵉⵜⵜⴼⵓⵛⵛⵓⵃ ⵍⴳⴻⵏⵙ, ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("PR29_19","021_29_19","PRO","29","19","19","ⵉⵊⵊ ⵏ ⵉⵙⵎⴻⵖ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜ ⴰⵔⵔⴻⴱⴱⴰⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴻⵀⵀⴻⵎ ⵅⴰⴽ, ⵡⴰⵔ ⵅⴰⴽ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PR29_20","021_29_20","PRO","29","20","20","ⵎⴰ ⵛⴻⴽ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⵥⵔⵉⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵇⴻⴵⵉⵇ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ? ⴰⵇⴰ ⴷⵉⵏ ⵍⴰⵢⴰⵙ ⴽⵜⴰⵔ ⵉ ⵓⴱⵓⵀⴰⵍⵉ ⵓⵍⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR29_21","021_29_21","PRO","29","21","21","ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵉⵙⵙⵓⴱⴻⴹ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ ⵣⵉ ⵜⴻⵎⵥⵉ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵡⴰⵔ ⵜ ⵉⵜⵜⵇⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR29_22","021_29_22","PRO","29","22","22","ⴰⵔⵢⴰⵣ ⵉⵜⵜⴰⵔⵔⵓⵊⴷⵓⴷⴻⵏ ⵉⵙⵙⴻⴽⴽⴰⵔⴰ-ⴷⴷ ⴰⵎⵛⵓⴱⴱⴻⵛ, ⵓ ⴱⴰⴱ ⵏ ⵡⴻⵙⵄⴰⵔ ⵉⵜⵜⴻⴳⴳ ⴰⵟⵟⴰⵙ ⵏ ⵉⵅⴻⵟⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_23","021_29_23","PRO","29","23","23","ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜ ⵉⵙⵙⵡⴰⴹⴻⵄ, ⵎⴰⵛⴰ ⴰⵎⵡⴰⴹⴻⵄ ⵏ ⴱⵓⵃⴱⴻⵍ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴳⴳ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_24","021_29_24","PRO","29","24","24","ⵡⴻⵏⵏⵉ ⵉⴱⴻⵟⵟⴰⵏ ⴰⴽ-ⴷ ⵓⵅⴻⵡⵡⴰⵏ, ⵉⵛⴰⵔⵔⴻⵀ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵙⵍⴰ ⵉ ⵏⵏⴻⵄⵍⴻⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵉⵇⵇⴰⵔ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("PR29_25","021_29_25","PRO","29","25","25","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵜⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵍⴼⴻⵅ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR29_26","021_29_26","PRO","29","26","26","ⴰⵟⵟⴰⵙ ⴰⵔⴻⵣⵣⵓⵏ ⵓⴷⴻⵎ ⵏ ⵍⵃⴰⴽⴻⵎ, ⵡⴰⵅⵅⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PR29_27","021_29_27","PRO","29","27","27","ⴰⵔⵢⴰⵣ ⴰⵖⴻⵛⵛⴰⵛ ⴷ ⵏⵏⵄⵉ ⵉ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ ⵉ ⵓⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_1","021_30_1","PRO","30","1","1","ⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵊⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴽⵉ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵙⵙⴰ. ⵏⴻⵛⵛ ⴰⵔⴱⴻⵍⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵛⵛ ⴰⵔⴱⴻⵍⴻⵖ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴽⴻⵎⵎⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PR30_2","021_30_2","PRO","30","2","2","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵇⴻⴼⴼⵓⵃ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴱⵏⴰⴷⴻⵎ, ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("PR30_3","021_30_3","PRO","30","3","3","ⵏⴻⵛⵛ ⵡⴰⵔ ⵍⵎⵉⴷⴻⵖ ⵜⵉⵖⵉⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_4","021_30_4","PRO","30","4","4","ⵡⵉ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ? ⵎⴰⵏ ⵡⴻⵏ ⵉⵢⴰⵔⵔⵡⴻⵏ ⴰⵙⴻⵎⵎⵉⴹ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ? ⵡⵉ ⵉⵙⵙⴻⵏⵏⴹⴻⵏ ⴰⵎⴰⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ? ⵡⵉ ⵢⴰⵔⴻⴽⴽⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ⵎⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵓ ⵎⴰⵏ ⵉⵙⴻⵎ ⵏ ⵎⵎⵉⵙ? ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("PR30_5","021_30_5","PRO","30","5","5","ⴽⵓⵍ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⴷⵓⵔⵔⵉ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_6","021_30_6","PRO","30","6","6","ⵡⴰⵔ ⴰⵔⴻⵏⵏⵉ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵡⴻⴱⴱⴻⵅ, ⵓ ⴰⴷ ⵜⴱⴰⵏⴻⴷ-ⴷⴷ ⵛⴻⴽ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_7","021_30_7","PRO","30","7","7","ⵏⴻⵛⵛ ⵜⵜⴰⵔⴻⵖ ⴰⵛ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⴻⵏⵜ ⵇⴻⵟⵟⴻⵄ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵎⵎⵜⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PR30_8","021_30_8","PRO","30","8","8","ⵙⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⵎⵉⵏ ⵉⴱⴻⴹⵍⴻⵏ ⴷ ⵍⵀⴰⵔⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵉⵛ ⵣⵣⴻⵍⴹ ⵓⵍⴰ ⴷ ⵡⴰⴳⵍⴰ, ⵛⴰⵔⵔⴻⴳ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("PR30_9","021_30_9","PRO","30","9","9","ⵎⴰⵍⴰ ⵍⵍⴰ, ⵅⵎⵉ ⵖⴰ ⵊⵊⵉⵡⵏⴻⵖ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵛⴻⴽ ⵏⴽⴰⵔⴻⵖ, ⴰⴷ ⵉⵏⵉⵖ ‘ⵡⵉ ⵉⴵⴰⵏ ⵙⵉⴷⵉ?’, ⵏⵉⵖ ⵅⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵣⴻⵍⴹⴻⵖ, ⴰⴷ ⴰⵛⴰⵔⴻⵖ, ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⵉⴱ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PR30_10","021_30_10","PRO","30","10","10","ⵡⴰⵔ ⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵖⴰⵔ ⵙⵉⴷⵉⵙ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵏⴻⵄⵄⴻⵍ ⵓ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⴷⴰⵢⴻⴽ ⵢⵉⵍⵉ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("PR30_11","021_30_11","PRO","30","11","11","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵉ ⵉⵏⴻⵄⵄⵍⴻⵏ ⴱⴰⴱⴰⵙ, ⵓ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⴻⴽ ⵢⴻⵎⵎⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("PR30_12","021_30_12","PRO","30","12","12","ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵉⵔⴷ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PR30_13","021_30_13","PRO","30","13","13","ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵙ ⵍⵅⴻⵣⵔⴰⵜ ⵉⵏⴻⴼⵅⴻⵏ, ⵙ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵉⴳⴻⵄⵄⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PR30_14","021_30_14","PRO","30","14","14","ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵙ ⵜⴻⵖⵎⴰⵙ ⴰⵎ ⵍⴻⵙⵢⵓⴼ ⴷ ⵜⴻⵖⵎⴰⵙ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⴰⵎ ⵍⴻⵎⵡⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵚⴰⵔⴹⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵎⴻⵣⵍⴰⴹ ⵣⴻⴳ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_15","021_30_15","PRO","30","15","15","ⵜⴰⴷⴷⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵙⵙⵉⵙ: ‘ⴻⵡⵛ!’ ‘ⴻⵡⵛ!’ ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ. ⴰⵔⴻⴱⵄⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵏⵉⵏ: “ⵛⴼⴰ!” ");
INSERT INTO rift_vpl VALUES ("PR30_16","021_30_16","PRO","30","16","16","ⵍⴰⵅⴰⵔⵜ ⴷ ⵍⴻⵎⵍⴰⵡⴻⵜ ⵉⴱⴻⵍⵍⵄⴻⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵉⵊⵊⵉⵡⵏⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵣⴻⴳ ⵡⴰⵎⴰⵏ, ⵓⵍⴰ ⴷ ⵜⵎⴻⵙⵙⵉ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏⵜ ⵄⴻⵎⵎⴰⵔⵚ: “ⵛⴼⴰ!” ");
INSERT INTO rift_vpl VALUES ("PR30_17","021_30_17","PRO","30","17","17","ⵜⵉⵟⵟ ⵉ ⵉⵙⵙⵜⴻⵀⵣⴰⵏ ⵣⵉ ⴱⴰⴱⴰⵙ, ⵓ ⵜⴻⵙⵙⴻⵃⵇⴰⵔ ⵟⵟⴰⵄⴻⵜ ⵉ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵜⵜ ⵇⴻⵍⵄⴻⵏ ⵉⴱⴰⵖⵍⵉⵡⴻⵏ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ, ⵓ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏ ⵓⴳⵉⴷⴻⵔ ⴰⴷ ⵜⵜ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_18","021_30_18","PRO","30","18","18","ⵜⵍⴰⵜⴰ-ⵢⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵄⴷⵓⵏⵜ ⴰⵢⵉ ⵙ ⵍⴻⵄⵊⴻⴱ, ⴰⵔⴻⴱⵄⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵙⵙⵉⵏⴻⵖ: ");
INSERT INTO rift_vpl VALUES ("PR30_19","021_30_19","PRO","30","19","19","ⴰⴱⵔⵉⴷ ⵏ ⵓⴳⵉⴷⴻⵔ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⴱⵔⵉⴷ ⵏ ⵓⴼⵉⵖⴰⵔ ⵅ ⵜⴻⵚⴹⴰⵔⵜ, ⴰⴱⵔⵉⴷ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓ ⴰⴱⵔⵉⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⴽ-ⴷ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PR30_20","021_30_20","PRO","30","20","20","ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⴻⴳⴳ ⴰⴱⵔⵉⴷ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵣⴻⵏⵏⴰⵏ: ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⴻⵜⵜ, ⵜⴻⵙⵙⵉⵔⵉⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵜⴻⵇⵇⴰⵔ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴳⴳⵉⵖ ⵡⴰⵍⵓ ⴷ ⵍⵖⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("PR30_21","021_30_21","PRO","30","21","21","ⵙⴰⴷⵓ ⵜⵍⴰⵜⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⴻⵏⵀⴻⵣⵣ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⴰⴷⵓ ⴰⵔⴻⴱⵄⴰ ⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴰⵔⴱⵓ: ");
INSERT INTO rift_vpl VALUES ("PR30_22","021_30_22","PRO","30","22","22","ⵙⴰⴷⵓ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵙⴰⴷⵓ ⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵊⵉⵡⴻⵏ ⴰⵖⵔⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("PR30_23","021_30_23","PRO","30","23","23","ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵎⵍⴻⵛ, ⵓ ⵙⴰⴷⵓ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ ⵎⴰⵍⴰ ⵜᵉⵟⵟⴻⴼ ⵍⵡⴰⵔⵜ ⵏ ⵍⴰⵍⵍⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR30_24","021_30_24","PRO","30","24","24","ⴰⵔⴻⴱⵄⴰ-ⵢⴰ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵇⴰⵄ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵄⴰⴷ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵇⴰⵄ: ");
INSERT INTO rift_vpl VALUES ("PR30_25","021_30_25","PRO","30","25","25","ⵜⵉⴽⴻⴹⴼⵉⵏ ⵡⴰⵔ ⴵⵉⵏⵜ ⴷ ⵍⴳⴻⵏⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⴰⵛⴰ ⵄⴰⴷ ⵏⵉⵜⴻⵏⵜⵉ ⵙⵙⴻⵡⵊⴰⴷⴻⵏⵜ ⵎⴰⵛⵛⴰ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("PR30_26","021_30_26","PRO","30","26","26","ⵉⴽⴰⵡⴽⴰⵡⴻⵏ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵀⵍⴰ ⵊⵊⵀⴻⴷ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴻⵏⵏⴰⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ ⵅ ⵜⴻⵚⴹⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR30_27","021_30_27","PRO","30","27","27","ⵜⴰⵎⵓⵖⵔⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⴰⵊⴻⴵⵉⴷ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵙ ⵓⵙⴻⵜⵜⴻⴼ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR30_28","021_30_28","PRO","30","28","28","ⴰⵣⴻⵔⵎⵓⵎⵎⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜ ⵜᵉⵟⵟⴼⴻⴷ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ, ⵄⴰⴷ ⴰⵇⴰ-ⵜ ⵏⴻⵜⵜⴰ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR30_29","021_30_29","PRO","30","29","29","ⵜⵍⴰⵜⴰ-ⵢⴰ ⵚⵚⵓⵔⵓⴼⴻⵏ ⵙ ⵍⵄⴻⵣⵣ, ⴰⵔⴻⴱⵄⴰ ⴳⴳⵓⵔⴻⵏ ⵙ ⵜⴻⵛⵍⵉ ⵜⴻⵛⵏⴻⵄ: ");
INSERT INTO rift_vpl VALUES ("PR30_30","021_30_30","PRO","30","30","30","ⴰⵢⵔⴰⴷ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵊⴰⵔ ⵍⵎⴰⵔ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴻⵅⵅⵉⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵃⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("PR30_31","021_30_31","PRO","30","31","31","ⵉⵊⵊ ⵏ ⵓⵖⵉⵍⴰⵙ ⵙ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⴱⴻⵢⵙⴻⵏⵜ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ, ⵓ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵍⴰⵖⵉ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("PR30_32","021_30_32","PRO","30","32","32","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵓⵎⵉ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵏⵉⵖ ⵜⵅⴻⵎⵎⴻⵎⴻⴷ ⴷⵉ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ: ⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵅ ⵓⵇⴻⵎⵎⵓⵎ! ");
INSERT INTO rift_vpl VALUES ("PR30_33","021_30_33","PRO","30","33","33","ⵎⴰⵖⴰⵔ ⴰⵙⴻⵏⴷⵓ ⵏ ⵓⵖⵉ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵜⵔⵓⵙⵙⵉ, ⵓ ⴰⵙⴻⵏⴷⵓ ⵏ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵓ ⴰⵙⴻⵏⴷⵓ ⵏ ⵓⵅⴻⵢⵢⴻⵇ, ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴰⵎⵛⵓⴱⴱⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PR31_1","021_31_1","PRO","31","1","1","ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⴰⵎⵓⵢⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵙⵙⴰ, ⵉ ⵣⵉ ⵜ ⵜⵄⴻⵍⵎⴻⴷ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PR31_2","021_31_2","PRO","31","2","2","ⵎⵉⵏ ⴷⵉⵏ, ⴰ ⵎⵎⵉ, ⵎⵉⵏ ⴷⵉⵏ, ⴰ ⵎⵎⵉ ⵏ ⵡⴻⵃⵙⵉⵏ ⵉⵏⵓ, ⵎⵉⵏ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⴰ ⵎⵎⵉ ⵏ ⵍⵡⵓⵄⵓⴷ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("PR31_3","021_31_3","PRO","31","3","3","ⵡⴰⵔ ⵜⵜⵉⵛ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵓⵍⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ ⵉ ⵜⵉⵏⵏⵉ ⵉⵜⵜⵀⴻⵍⵍⴰⴽⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_4","021_31_4","PRO","31","4","4","ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⴰ ⵍⴰⵎⵓⵢⵉⵍ, ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵡⴻⵏ ⴱⵉⵏⵓ, ⵓⵍⴰ ⵉ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⴻⵥⵔⴻⵏ ⴷⵉ ⵛⵛⵔⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("PR31_5","021_31_5","PRO","31","5","5","ⵏⵉⵖ ⴰⴷ ⵉⵙⵓⵡ ⵓ ⴰⴷ ⵉⵜⵜⵓ ⵍⴼⴰⵔⵉⴹⴰ, ⵓ ⴰⴷ ⵉⵙⵙⴼⴰⵔⵖ ⵜⴰⵏⴼⵓⵍⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵅⴻⵢⵢⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_6","021_31_6","PRO","31","6","6","ⴻⵡⵛ ⵛⵛⵔⴰⴱ ⵉ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ, ⵓⵍⴰ ⴷ ⴱⵉⵏⵓ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_7","021_31_7","PRO","31","7","7","ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵓⵡ ⵓ ⴰⴷ ⵉⵜⵜⵓ ⵣⵣⴻⵍⴹ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⵉ ⵜⴰⵎⴰⵔⴰ ⵏⵏⴻⵙ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("PR31_8","021_31_8","PRO","31","8","8","ⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵉ ⵉⵣⵉⵢⵏⴰⵏ, ⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_9","021_31_9","PRO","31","9","9","ⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵃⴽⴻⵎ ⵙ ⵍⵃⵓⴽⵎ ⵏⵉⵛⴰⵏ, ⵓⵛⴰ ⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵓⵎⴻⵣⵍⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("PR31_10","021_31_10","PRO","31","10","10","ⴰⵍⵉⴼ. ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵢⴰⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵎⴻⵃⴹⴻⵏ? ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉⵄⴷⵓ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵔⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_11","021_31_11","PRO","31","11","11","ⴱⵉⵜ. ⵅⴰⵙ ⵉ ⵉⵜⵜⵛⴰⵍⴰ ⵡⵓⵍ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵍⴻⴼⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("PR31_12","021_31_12","PRO","31","12","12","ⴳⵉⵎⴻⵍ. ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⴻⴳⴳ ⴰⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵍⵖⴰⵔ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR31_13","021_31_13","PRO","31","13","13","ⴷⴰⵍⵉⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⴻⵣⵣⵓ ⵜⴰⴹⵓⴼⵜ ⴷ ⵜⵉⴼⴼⴻⵙⵜ, ⵓ ⵜⵅⴻⴷⴷⴻⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵉⵎⴻⵃⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_14","021_31_14","PRO","31","14","14","ⵀⵉ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⴰⵎ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵓⵙⴻⴱⴱⴰⴱ, ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR31_15","021_31_15","PRO","31","15","15","ⵡⴰⵡ. ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵏⴰⴽⴽⴰⵔ ⵓⵎⵉ ⵄⴰⴷ ⵜⴻⴵⴰ ⴵⵉⵍⴻⵜ, ⵜᵉⵜⵜⵉⵛ ⵎⴰⵛⵛⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵉ ⵜⴻⵎⵙⴻⵅⵅⴰⵔⵉⵏ ⵏⵏⴻⵛ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_16","021_31_16","PRO","31","16","16","ⵣⴰⵢⵉⵏ. ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓ ⵜᵉⵜⵜⴻⵟⵟⴻⴼ ⵉ-ⵜ, ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵜⴻⵥⵥⵓ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PR31_17","021_31_17","PRO","31","17","17","ⵅⵉⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⴱⴻⴽⴽⴻⵙ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⵙ ⵊⵊⴻⵀⴷ, ⵓ ⵜⴻⵙⵙⴻⵎⵃⴰⴹ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR31_18","021_31_18","PRO","31","18","18","ⵜⵉⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⵃⴻⴽⴽⴰⵔ ⵉ ⵍⴻⴼⴹⴻⵍ ⵏ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵙ, ⵍⴻⴼⵏⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵅⴻⵙⵙⵉ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PR31_19","021_31_19","PRO","31","19","19","ⵢⵓⴷ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵔⵓⴽⴽⴰ, ⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵟⵟⴼⴻⵏ ⴰⵎⴻⴽⴽⵓⴽ ⵏ ⵓⵅⴻⵢⵢⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("PR31_20","021_31_20","PRO","31","20","20","ⴽⴰⴼ. ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⴻⵣⵣⴻⵎ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵃⴷⴰⵊ, ⵜⴻⵙⵙⵡⴰⵥⵥⴰⴹ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵉ ⵓⵎⴻⵣⵍⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("PR31_21","021_31_21","PRO","31","21","21","ⵍⴰⵎⵉⴷ. ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⴷⴼⴻⵍ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⴰⵔⵔⵓⴹ ⴰⵔⵊⵓⵡⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PR31_22","021_31_22","PRO","31","22","22","ⵎⵉⵎ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵉⵙⵓⵏⵜⴰⵡⵉⵏ ⵏ ⵣⵡⴰⵇ, ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵓⴼⵉⵍⵓ ⴰⵔⵊⵓⵡⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PR31_23","021_31_23","PRO","31","23","23","ⵏⵓⵏ. ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ, ⵅⵎⵉ ⵉⵜⵜⵖⵉⵎⴰ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PR31_24","021_31_24","PRO","31","24","24","ⵙⴰⵎⵉⵅ. ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⴻⴳⴳ ⴰⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ ⵓⵛⴰ ⵜⴻⵣⵣⵏⵓⵣⴰ ⵉ-ⵜ, ⵏⴻⵜⵜⴰⵜ ⵜⴻⵣⵣⵏⵓⵣⴰ ⵉⴱⵓⵢⴰⵙ ⵉ ⵓⵙⴻⴱⴱⴰⴱ ⵣⵉ ⴽⴻⵏⵄⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_25","021_31_25","PRO","31","25","25","ⵄⴰⵢⵉⵏ. ⵊⵊⴻⵀⴷ ⴷ ⵍⵄⴻⵣⵣ ⴷ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰⵜ ⵜⴹⴻⵃⵃⴻⵛ ⵜⴻⵙⴼⴰⵔⵏⵉⵏ ⵅ ⵡⴰⵙⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_26","021_31_26","PRO","31","26","26","ⴱⵉ. ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⴻⵣⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵙ ⵜⵉⵖⵉⵜ, ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⵖⵓⵔⵉ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵅ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PR31_27","021_31_27","PRO","31","27","27","ⵜⵙⴰⴷⵉ. ⵏⴻⵜⵜⴰⵜ ⵜⵃⴻⵟⵟⴰ ⵅ ⵎⵉⵏ ⵉⵜⵜⴻⵎⵎⵙⴰⵔⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵖⵔⵓⵎ ⵏ ⵍⴻⵄⴳⴻⵣ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PR31_28","021_31_28","PRO","31","28","28","ⵇⵓⴼ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴻⴽⴽⴰⵔⴻⵏ, ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵜⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵓⵍⴰ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵜⵜⵎⴻⴷⴷⴻⵃ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PR31_29","021_31_29","PRO","31","29","29","ⵔⵉⵅ. ⴰⵟⵟⴰⵙ ⵏ ⵜⵢⴻⵙⵙⵉⵜ ⴳⴳⵉⵏⵜ ⵜⵉⵎⴻⴳⴳⴰ ⵊⴻⵀⴷⴻⵏⵜ, ⵎⴰⵛⴰ ⵛⴻⵎ ⵜⴻⵄⴷⵓⴷ-ⴷⴷ ⵜⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PR31_30","021_31_30","PRO","31","30","30","ⵛⵉⵏ. ⵍⴻⴱⵀⵓⵜ ⵜⵛⴻⵎⵎⴻⵜ ⵓ ⴰⵥⵔⵉ ⵉⵜⵜⵖⴻⵛⵛⴰ ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴷⴻⵏ ⵙⵉⴷⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PR31_31","021_31_31","PRO","31","31","31","ⵜⴰⴼ. ⵡⵛⴻⵎ ⴰⵙ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵊⵊⴻⵎ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵚⴻⴱⴱⵃⴻⵏⵜ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EC1_1","022_1_1","ECC","1","1","1","ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵎⴱⴰⵔⵔⴻⵃ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EC1_2","022_1_2","ECC","1","2","2","ⴷ ⵉⴱⴻⵟⵟⴰⵍⴻⵏ ⵇⴰⵄ, ⵉⵇⵇⴰⵔ ⵓⵎⴱⴰⵔⵔⴻⵃ, ⴷ ⵉⴱⴻⵟⵟⴰⵍⴻⵏ ⵇⴰⵄ, ⴰⵇⴰ ⴽⵓⵍⵛⵉ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC1_3","022_1_3","ECC","1","3","3","ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵔⴱⴻⵔ ⵉ ⵣⵉ ⵉⵜⵜⵎⴰⵔⵔⴻⵜ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("EC1_4","022_1_4","ECC","1","4","4","ⵊⵊⵉⵍ ⵉⴳⴳⵓⵔ, ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⴰⵙ-ⴷⴷ, ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EC1_5","022_1_5","ECC","1","5","5","ⵜⵏⴻⵇⵇⴰⵔ-ⴷⴷ ⵜⴼⵓⵛⵜ ⵓ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ ⵄⴰⵡⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EC1_6","022_1_6","ECC","1","6","6","ⵉⴳⴳⵓⵔ ⵓⵙⴻⵎⵎⵉⴹ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵓ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ. ⴰⵎ ⵉⴳⴳⵓⵔ ⵉⵜⵜⴻⵏⵏⴻⴹ, ⵉⵜⵜⴻⵏⵏⴻⴹ ⵓⵙⴻⵎⵎⵉⴹ, ⵓⵛⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵓⵙⴻⵎⵎⵉⴹ ⵉⴷⴷⴰⴽⴽⵡⴰⵍ-ⴷⴷ ⵖⴰⵔ ⵓⴷⵓⵡⵡⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC1_7","022_1_7","ECC","1","7","7","ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⵔⴰⵏ ⵜⵜⴽⴻⴱⴱⴰⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵛⵛⵓⵔⵉ ⵍⴻⴱⵃⴰⵔ. ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵜⴰⵣⵣⵍⴻⵏ ⵉⵖⴻⵣⵔⴰⵏ, ⴷⵉⵏⵏⵉ ⵜⵜⵖⵉⵎⴻⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EC1_8","022_1_8","ECC","1","8","8","ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵙⵙⴰⵃⴰⵍⴻⵏⵜ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙ ⵢⵉⵏⵉ ⵛⴰ. ⵄⴻⵎⵎⴰⵔⵚ ⵜⵉⵟⵟ ⴰⴷ ⵜⴻⵊⵊⴰⵡⴻⵏ ⵣⴻⴳ ⵡⴻⵥⵔⵉ ⵓⵛⴰ ⴰⵎⴻⵣⵣⵓⵖ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵊⵊⴰⵡⴻⵏ ⵣⴻⴳ ⵓⵜⴻⵙⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EC1_9","022_1_9","ECC","1","9","9","ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴰⴷ ⵢⵉⵍⵉ, ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵄⴰⵡⴻⴷ. ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵊⴷⵉⴷ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC1_10","022_1_10","ECC","1","10","10","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵇⵇⴰⵔⴻⵏ ⵅⴰⵙ: “ⵅⵣⴰⵔ, ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵊⴷⵉⴷ!”?, ⴰⵇⴰ-ⵜⵜ ⴷⵉⵏ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EC1_11","022_1_11","ECC","1","11","11","ⵡⴰⵔ ⴷⵉⵏ ⴵⵉⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵓⵛⴰ ⵓⵍⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⵉⵍⵉⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EC1_12","022_1_12","ECC","1","12","12","ⵏⴻⵛⵛ, ⴰⵎⴱⴰⵔⵔⴻⵃ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EC1_13","022_1_13","ECC","1","13","13","ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴽⴽⵙⴻⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⴰⴷ ⴰⵔⵣⵓⵖ ⵓ ⴰⴷ ⴱⴻⵇⵇⵛⴻⵖ ⵙ ⵜⵉⵖⵉⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ. ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵛⵛⵖⴻⵍ ⵉⵡⵄⴰⵔ, ⵉⵡⵛⴰ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵍⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC1_14","022_1_14","ECC","1","14","14","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⵓ ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC1_15","022_1_15","ECC","1","15","15","ⵎⵉⵏ ⵉⴼⴰⵔⵖⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⵎ, ⵓ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("EC1_16","022_1_16","ECC","1","16","16","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵜⵉⵖⵉⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⵔⵏⵉⵖ ⴷⴰⵢⴻⵙ, ⵎⴰⵀⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵇⴱⴻⵍ ⵉⵏⵓ. ⵓⵍ ⵉⵏⵓ ⵉⵥⵔⴰ ⴰⵟⵟⴰⵙ ⵏ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EC1_17","022_1_17","ECC","1","17","17","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵓⵍ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵜⵉⵖⵉⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵖ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷ ⵊⵊⵀⴻⵍ. ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⴷ ⴰⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC1_18","022_1_18","ECC","1","18","18","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵉⵖⵉⵜ, ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵍⵀⴻⵎⵎ, ⵓ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵏⵏⵉⵏ ⴷⵉ ⵜⵓⵙⵙⵏⴰ, ⵢⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EC2_1","022_2_1","ECC","2","1","1","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⴰⵙ-ⴷⴷ, ⴰⴷ ⵛⴻⴽ ⵇⴻⴵⴱⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ⵅⵣⴰⵔ ⵖⴰⵔ ⵎⵉⵏ ⵉⵛⵏⴰⵏ!” ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC2_2","022_2_2","ECC","2","2","2","ⵉ ⵜⴰⴷⴻⵃⵃⴰⵛⵜ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: “ⴷ ⵜⴰⴱⵓⵀⴰⵍⵉⵜ ⵛⴻⵎ!”, ⵓ ⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ: “ⵎⵉⵏ ⴷⴷ ⵖⴰ ⵜⴰⵡⵉ ⴰⵎⴻⵏⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("EC2_3","022_2_3","ECC","2","3","3","ⵏⴻⵛⵛ ⴰⵔⵣⵓⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⵓⵎⵉ ⵙⵙⴰⵔⴻⵛⵛⴰⵇⴻⵖ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵙ ⴱⵉⵏⵓ - ⴷⵉ ⵍⵡⴻⵇⵜ ⵎⴰⵏⵉ ⵓⵍ ⵉⵏⵓ ⵉⵇⵇⵉⵎ ⵉⵜⵜᵉⵟⵟⴻⴼ ⵙⵍⴰⵢⴻⵎ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵙ ⵜⵉⵖⵉⵜ - ⵓ ⵓⵎⵉ ⵇⵇⵉⵎⴻⵖ ⵍⴻⵙⵙⵇⴻⵖ ⴷⵉ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ-ⵢⴰ, ⴰⵍⴰⵎⵉ ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵃⵙⴻⵏ ⵇⴰⵄ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ ⴰⵎ ⵃⴻⵙⵙⴱⴻⵏ ⵙ ⵍⵎⴻⵇⵍⵓⴱ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC2_4","022_2_4","ECC","2","4","4","ⵏⴻⵛⵛ ⴰⵔⵏⵉⵖ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵎⵉⵏ ⴳⴳⵉⵖ. ⵏⴻⵛⵛ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵜⵓⴷⵔⵉⵏ, ⵥⵥⵓⵖ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EC2_5","022_2_5","ECC","2","5","5","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵃⵡⵉⵛⴻⵏ ⴷ ⵉⴼⵜⵉⵙⴻⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵏ ⵊⵊⴻⵏⵏⴻⵜ ⵓⵛⴰ ⵥⵥⵓⵖ ⴷⴰⵢⵙⴻⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⴼⵔⵓⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("EC2_6","022_2_6","ECC","2","6","6","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵙⴻⵙⵡⴻⵖ ⴰⵣⵖⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵓⴼⴼⵢⴻⵏⵜ ⵜⵛⴻⵊⵊⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EC2_7","022_2_7","ECC","2","7","7","ⵏⴻⵛⵛ ⵙⵖⵉⵖ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ, ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵜⵜⵡⴰⵔⵡⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵜⵓⵖⴰ ⵖⴰⵔⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵡⵓⴵⵉ, ⴰⵟⵟⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵇⴱⴻⵍ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("EC2_8","022_2_8","ECC","2","8","8","ⵏⴻⵛⵛ ⵙⵙⵎⵓⵏⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⴽⵏⵓⵣ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓ ⵣⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ. ⵏⴻⵛⵛ ⴹⴻⴱⴱⴰⵔⴻⵖ-ⴷⴷ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵉⵎⴻⵖⵏⵓⵊⴻⵏ ⴷ ⵜⵎⴻⵖⵏⵓⵊⵉⵏ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⴷⵉ ⵎⴻⵥⵔⴻⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ: ⵜⴰⵎⵖⴰⵔⵜ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EC2_9","022_2_9","ECC","2","9","9","ⵏⴻⵛⵛ ⴰⵔⵏⵉⵖ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⵔⵏⵉⵖ-ⴷⴷ ⴰⵟⵟⴰⵙ, ⵎⴰⵀⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵏⴻⵛⵛ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵛⴰ ⵜⵉⵖⵉⵜ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EC2_10","022_2_10","ECC","2","10","10","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵎⴻⵥⵔⵉ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏⵜ ⵇⴹⵉⵄⴻⵖ. ⵡⴰⵔ ⵎⴻⵏⵄⴻⵖ ⵉ ⵡⵓⵍ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⵎⴰⵖⴰⵔ ⵓⵍ ⵉⵏⵓ ⵉⴼⴰⵔⵃ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴰⵔⴰ ⵉⵏⵓ: ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EC2_11","022_2_11","ECC","2","11","11","ⵅⴰⵙ ⵓⵛⴰ ⴳⴳⵉⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵏⵓ, ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵓ ⵖⴰⵔ ⵓⵎⴰⵔⵔⴻⵜ ⵏⵏⵉ ⴳⴳⵉⵖ ⴰⵎ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵜⵜⵎⴰⵔⵔⴰⵜⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ⵅⵣⴰⵔ, ⵓⴼⵉⵖ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⴵⵉ ⴱⵓ ⵍⴻⴼⴹⴻⵍ ⵙⴰⴷⵓ ⵜⴰⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC2_12","022_2_12","ECC","2","12","12","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵖ ⵜⵉⵖⵉⵜ, ⵓⵍⴰ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷ ⵜⴰⵖⵢⵓⵍⵉ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵢⴰⵔⴻⵛⵛⵃⴻⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ? ");
INSERT INTO rift_vpl VALUES ("EC2_13","022_2_13","ECC","2","13","13","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴰⵇⴰ ⵜⵉⵖⵉⵜ ⵜⴻⵄⴷⵓ ⵅ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⴰⵎ ⵜⴻⵄⴷⵓ ⵜⴼⴰⵡⵜ ⵅ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EC2_14","022_2_14","ECC","2","14","14","ⴰⵎⵉⵖⵉⵙ ⵖⴰⵔⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴱⵓⵀⴰⵍⵉ ⵉⴳⴳⵓⵔ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ⵅⴻⵏⵏⵉ ⵓⴼⵉⵖ ⴰⵇⴰ ⵜⵍⴻⵇⵇⴻⴼ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵔⴰ ⴷ ⵉⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC2_15","022_2_15","ECC","2","15","15","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⵎⴰⵍⴰ ⵜⴻⵍⵇⴻⴼ ⴰⴱⵓⵀⴰⵍⵉ, ⴰⴷ ⵜⴻⵍⵇⴻⴼ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵎⴻⵢⵢⵣⴻⵖ ⵙ ⵜⵉⵖⵉⵜ?” ⵓⵛⴰ ⵏⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("EC2_16","022_2_16","ECC","2","16","16","ⵎⴰⵖⴰⵔ ⵉ ⵍⴻⴱⴷⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵍⵄⴻⵇⵍⴰⵏ ⵅ ⵓⵎⵉⵖⵉⵙ ⵓⵍⴰ ⵅ ⵓⴱⵓⵀⴰⵍⵉ. ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵜⵜⵓ ⵎⴰⵔⵔⴰ. ⵎⴰ ⵡⴰⵔ ⵉⵎⵎⵓⵜ ⵓⵎⵉⵖⵉⵙ ⴰⵎ ⵓⴱⵓⵀⴰⵍⵉ? ");
INSERT INTO rift_vpl VALUES ("EC2_17","022_2_17","ECC","2","17","17","ⵓⵛⴰ ⴱⴷⵉⵖ ⴰⴷ ⵛⴰⵔⵀⴻⵖ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴰⴷⵓ ⵜⴰⴼⵓⵛⵜ, ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⴼⵉ ⵎⵖⵉⵔ ⴷ ⵜⴰⵎⴰⵔⴰ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC2_18","022_2_18","ECC","2","18","18","ⴱⴷⵉⵖ ⵄⴰⵡⴻⴷ ⴰⴷ ⵛⴰⵔⵀⴻⵖ ⴰⵎⴰⵔⵔⴻⵜ ⵉⵏⵓ ⵉ ⵣⵉ ⵎⴰⵔⵔⵜⴻⵖ ⵙⴰⴷⵓ ⵜⴰⴼⵓⵛⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵊⵊⴻⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("EC2_19","022_2_19","ECC","2","19","19","ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵉⵖⵉⵙ ⵏⵉⵖ ⴷ ⴰⴱⵓⵀⴰⵍⵉ? ⴰⵇⴰ ⴳⴳⵓⵔ ⴰⴷ ⵉⵚⴻⵍⵍⴻⵟ ⵅ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵉⵏⵓ ⵉ ⵣⵉ ⵎⴰⵔⵔⵜⴻⵖ ⵓ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⴵⵉⵖ ⴷ ⴰⵎⵉⵖⵉⵙ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC2_20","022_2_20","ECC","2","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⵇⴻⵍⴱⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵓⵍ ⵉⵏⵓ ⴰⴷ ⵉⵇⵏⴻⴹ ⵅ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵉⵏⵓ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵎⴰⵔⵔⵜⴻⵖ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC2_21","022_2_21","ECC","2","21","21","ⵎⴰⵖⴰⵔ ⵡⴰⵅⵅⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ ⴷ ⵜⵣⴻⵎⵎⴰⵔ, ⵄⴰⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⵜ ⵉⵡⵛ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵡⴰⵔ ⵉⵎⴰⵔⵔⵜⴻⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EC2_22","022_2_22","ECC","2","22","22","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ ⵓ ⵣⵉ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⵜⵜⵎⴰⵔⵔⴰⵜ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("EC2_23","022_2_23","ECC","2","23","23","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⴷ ⴰⵎⵏⵓⵙ ⵓ ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵢⵉⵡⵉⴹ ⵍⵀⴻⵎⵎ. ⵄⴰⴷ ⴷⵉ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵡⵓⵍ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC2_24","022_2_24","ECC","2","24","24","ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴷ ⵍⴻⵎⵍⵉⵃ ⵉ ⴱⵏⴰⴷⴻⵎ ⵅ ⵎⴰⵛⵛⴰ ⴷ ⵜⵙⴻⵙⵡⵉⵜ ⵓⵍⴰ ⵅ ⵓⵎⵉ ⵉⵖⴻⴱⴱⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ. ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EC2_25","022_2_25","ECC","2","25","25","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⴻⵛⵛ ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⴰⵡⵉ ⴰⵍⵉⵇⵇⵉ ⴱⴰⵔⵔⴰ ⵉ ⵏⴻⵛⵛ? ");
INSERT INTO rift_vpl VALUES ("EC2_26","022_2_26","ECC","2","26","26","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵉⵛ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⵉ ⵓⵎⴻⴷⵏⵓⴱ ⵉⵜⵜⵉⵛ ⴰⵙ ⵛⵛⵖⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵢⴰⵔⵡ ⵓ ⴰⴷ ⵉⵙⵙⵎⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵡⵛ ⵅⴻⵏⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉⵛⵏⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC3_1","022_3_1","ECC","3","1","1","ⵎⴰⵔⵔⴰ ⵖⴰⵔⴻⵙ ⵍⵎⵉⵊⴰⵍ ⵏⵏⴻⵙ ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⴽⵓⵍ ⴰⵏⵡⴰⵢ ⵙⴰⴷⵓ ⴰⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EC3_2","022_3_2","ECC","3","2","2","ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⴰⵔⵡⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵍⵎⴻⵡⵜ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⴰⵥⵥⵓⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵇⵍⴰⵄ ⵏ ⵎⵉⵏ ⵉⵜⵡⴰⵥⵥⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("EC3_3","022_3_3","ECC","3","3","3","ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⵎⴻⵏⵖⵉⵡⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵙⴳⴻⵏⴼⵉ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵀⴷⴰⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵍⴻⴱⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EC3_4","022_3_4","ECC","3","4","4","ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⴹⴻⵃⵃⴰⵛⵜ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵛⵛⴹⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EC3_5","022_3_5","ECC","3","5","5","ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵃⴻⵊⵊⴰⵔ ⵏ ⵡⴻⵥⵔⵓ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵊⵔⴰⵡ ⵏ ⵡⴻⵥⵔⵓ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⴷⴰⵔⵔⴻⵄ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵍⴰⴳⴳⵯⴰⵊ ⵅ ⵓⴷⴰⵔⵔⴻⵄ, ");
INSERT INTO rift_vpl VALUES ("EC3_6","022_3_6","ECC","3","6","6","ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⴰⵔⴻⵣⵣⵓⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵡⴻⴷⴷⴰⵔ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵅⴻⵎⵎⴻⵔ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵏⴹⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("EC3_7","022_3_7","ECC","3","7","7","ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵛⴰⵔⵔⴻⴳ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵅⴻⵢⵢⴻⴹ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵙⴻⵖⴷⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵍⵀⴰⵔⴷ, ");
INSERT INTO rift_vpl VALUES ("EC3_8","022_3_8","ECC","3","8","8","ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⴰⵢⵔⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵛⵔⴰⵀ, ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⴳⴰⵔⵔⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EC3_9","022_3_9","ECC","3","9","9","ⵎⴰⵏ ⵜⵉⵣⵉ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⵢⴰⵔⴻⴱⴱⴻⵔ? ");
INSERT INTO rift_vpl VALUES ("EC3_10","022_3_10","ECC","3","10","10","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵛⵛⵖⴻⵍ ⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵉⵃⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC3_11","022_3_11","ECC","3","11","11","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ. ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⴱⵍⴰ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵃⴰⴽⴰ ⴷⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵏⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("EC3_12","022_3_12","ECC","3","12","12","ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⴵⵉ ⵎⵉⵏ ⵉⵃⵍⴰⵏ ⵅ ⵎⵉⵏⵏⵉ ⴼⴰⵔⵔⵃⴻⵏ ⵉⵡⴷⴰⵏ ⵏⵉⵖ ⴰⴷ ⴰⵔⵔⴻⵏ ⵎⴻⵥⵔⵉ ⵎⴻⵍⵎⵉ ⵏⵉⵜⵏⵉ ⵄⴰⴷ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EC3_13","022_3_13","ECC","3","13","13","ⵓ ⵄⴰⵡⴻⴷ ⴰⵇⴰ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵛⵛ, ⴰⴷ ⵉⵙⵓ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵔ ⵎⴻⵥⵔⵉ ⴷⵉ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ. ⴰⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EC3_14","022_3_14","ECC","3","14","14","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⴻⴱⴷⴰ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵎⴰⵔⵏⵉ ⵡⴰⵍⵓ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵇⵉⵙ ⵡⴰⵍⵓ. ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC3_15","022_3_15","ECC","3","15","15","ⵎⵉⵏ ⵉⴵⴰⵏ, ⵜⵓⵖⴰ ⵉⴵⴰ ⵇⴱⴻⵍ ⵓⵛⴰ ⵎⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ, ⵜⵓⵖⴰ ⵉⴵⴰ ⵇⴱⴻⵍ. ⴰⵔⴻⴱⴱⵉ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⵎⵉⵏ ⵉⵄⴷⵓⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EC3_16","022_3_16","ECC","3","16","16","ⴰⵇⴰ ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ ⵄⴰⵡⴻⴷ ⴰⵎⵛⴰⵏ ⵏ ⵍⵃⴻⵇⵇ: ⴰⵇⴰ ⵉⵙⴻⵍⵍⴻⵟ ⴷⵉⵏ ⵍⵖⴻⵛⵛ, ⵓⵛⴰ ⵥⵔⵉⵖ ⵓⵍⴰ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⵙⴻⴳⴷⴰ: ⴰⵇⴰ ⵉⵙⴻⵍⵍⴻⵟ ⴷⵉⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EC3_17","022_3_17","ECC","3","17","17","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴽⵓⵍ ⴰⵏⵡⴰⵢ ⵓ ⵉ ⵇⴰⵄ ⵍⵅⴻⴷⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("EC3_18","022_3_18","ECC","3","18","18","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ: “ⴰⵇⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵉⴼⴻⴼ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵡⴰⵍⴰⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⵎ ⵍⵎⴰⵍ, ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EC3_19","022_3_19","ECC","3","19","19","ⵎⴰⵖⴰⵔ ⵅ ⵜⵉⵔⴰ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵅ ⵜⵉⵔⴰ ⵏ ⵍⵎⴰⵍ: ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵔⴰ ⴷ ⵉⵛⵜ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵎⵓⵜ ⵡⴰ, ⵉⵎⵎⵓⵜ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵖⴰⵔⵙⴻⵏ ⴷ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⴷ ⵉⵊⵊ. ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⴻⴼⴹⴻⵍ ⵉ ⴱⵏⴰⴷⴻⵎ ⵅ ⵍⵎⴰⵍ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC3_20","022_3_20","ECC","3","20","20","ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵓⵛⴰⵍ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EC3_21","022_3_21","ECC","3","21","21","ⵡⵉ ⵉⵙⵙⵏⴻⵏ, ⵎⴰ ⴱⵓⵃⴱⴻⵍ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵓ ⴱⵓⵃⴱⴻⵍ ⵏ ⵍⵎⴰⵍ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("EC3_22","022_3_22","ECC","3","22","22","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⵍⵉⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏ ⵉⵃⵍⴰⵏ ⵅ ⵎⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵃ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⴰⵍ ⵖⴰ ⵉⵥⴰⵔ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("EC4_1","022_4_1","ECC","4","1","1","ⵥⵔⵉⵖ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⴷⴷⴻⴵ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴷⴻⴵⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵓⵎⴼⴻⵡⵡⴻⵊ. ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵄⵓⵏⴼ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵜⵜⴻⴷⴵⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵓⵎⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("EC4_2","022_4_2","ECC","4","2","2","ⵅⴻⵏⵏⵉ ⵚⴻⴱⴱⵃⴻⵖ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ, ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵄⴰⴷ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC4_3","022_4_3","ECC","4","3","3","ⵎⴰⵛⴰ ⵉⵃⵍⴰⵏ ⵅⴰⵙⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵏⵏⵉ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵄⴰⴷ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵥⵔⵉⵏ ⵄⴰⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC4_4","022_4_4","ECC","4","4","4","ⵓⵛⴰ ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⴰⵇⴰ-ⵜ ⵎⵖⵉⵔ ⴷ ⴰⵎⵄⴰⵏⴰⴷ ⵏ ⵉⵊⵊ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC4_5","022_4_5","ECC","4","5","5","ⴰⴱⵓⵀⴰⵍⵉ ⵉⴹⴼⴻⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⴻⵜⵜ ⴰⵢⵙⵓⵎ ⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC4_6","022_4_6","ECC","4","6","6","ⵉⵃⵍⴰ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵓⴼⵓⵙ ⵉⵛⵛⵓⵔ ⵙ ⵍⵀⵓⴷⵏⴻⵜ ⵓⵍⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵓⵎⴰⵔⵔⴻⵜ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC4_7","022_4_7","ECC","4","7","7","ⵄⴰⵡⴻⴷ ⵥⵔⵉⵖ ⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC4_8","022_4_8","ECC","4","8","8","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⴰⵇⴰ ⵜ ⵃⴰⴼⵉ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔⴻⵙ. ⵓⵍⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⴵⵉ ⵓⵃⴻⵏⵊⵉⵔ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵓⵎⴰⵙ. ⵡⴰⵔ ⵉⴵⵉ ⵓⵏⴻⴳⴳⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵢⵉⵡⵉⵏⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴰⴳⵍⴰ. “ⵉ ⵓⵎⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵜⴰⵎⴰⵔⴰ ⵓ ⵙⵙⴻⴽⴽⵉⵖ ⵜⵜ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵜⵛⵓⵏⵉ?” ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵛⵛⵖⴻⵍ ⵉⵡⵄⴰⵔ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("EC4_9","022_4_9","ECC","4","9","9","ⵜⵏⴰⵢⴻⵏ ⵃⵙⴻⵏ ⵣⴻⴳ ⵉⵊⵊⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵍⵎⵓⵏⴻⵜ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⴻⴳ ⵓⵎⴰⵔⵔⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC4_10","022_4_10","ECC","4","10","10","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ, ⴰⴷ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ. ⵎⴰⵛⴰ ⴰⵅⴻⵢⵢⴻⴱ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵡⴻⵃⵃⴷⴻⵙ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵡⴹⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵃⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("EC4_11","022_4_11","ECC","4","11","11","ⵄⴰⵡⴻⴷ ⵎⴰⵍⴰ ⵜⵏⴰⵢⴻⵏ ⵟⵟⵙⴻⵏ ⵎⵓⵏⴻⵏ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⵍⴻⵃⵎⵓ, ⵎⴰⵛⴰ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⴳⴳ ⵉⵊⵊⴻⵏ ⵡⴻⵃⵃⴷⴻⵙ ⴰⴷ ⵉⵃⵎⴰ? ");
INSERT INTO rift_vpl VALUES ("EC4_12","022_4_12","ECC","4","12","12","ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵢⴰⵔⵏⴰ ⵅ ⵉⵊⵊⴻⵏ ⵉ ⵉⴵⴰⵏ ⵡⴻⵃⵃⴷⴻⵙ, ⵎⴰⵛⴰ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⴱⴻⴷⴷⴻⵏ ⵊⵎⵉⵄ. ⵉⵊⵊ ⵏ ⵡⴻⵙⵖⵓⵏ ⵉⵎⵓⴷⴻⵏ ⵅ ⵜⵍⴰⵜⴰ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵓ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EC4_13","022_4_13","ECC","4","13","13","ⵉⵃⵔⴰ ⵉⵊⵊ ⵏ ⵓⵃⵓⴷⵔⵉ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⴷ ⴰⵎⵉⵖⵉⵙ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵡⵙⴰⵔ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵉ ⵡⴰⵔ ⵉⴼⴻⵀⵀⵎⴻⵏ ⵄⴰⴷ ⵉ ⵡⴻⵄⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EC4_14","022_4_14","ECC","4","14","14","ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵍⴻⵃⴱⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC4_15","022_4_15","ECC","4","15","15","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵃⵓⴷⵔⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC4_16","022_4_16","ECC","4","16","16","ⵡⴰⵔ ⴷⵉⵏ ⴰⵏⴻⴳⴳⴰⵔ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴰⵎ ⵉⴽⵎⴻⵍ ⵏⵏⵉ ⵣⵉ ⵉⵣⵡⴰⵔ ⵏⴻⵜⵜⴰ ⴰⵎ ⵢⵉⵅⴻⴼ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴼⴰⵔⵔⵃⴻⵏ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC4_17","022_4_17","ECC","4","17","17","ⵃⴹⴰ ⴰⵚⵓⵔⵉⴼ ⵏⵏⴻⵛ ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵓⵔⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴰⵇⴰⵔⵔⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵃⴻⵙⵙⴻⴷ, ⵃⵙⴻⵏ ⵣⴻⴳ ⵓⵡⴻⵀⵀⴻⴱ ⵏ ⵜⵖⴰⵔⵚⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EC5_1","022_5_1","ECC","5","1","1","ⵡⴰⵔ ⵜⵇⴻⴵⵉⵇ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵓ ⵃⴹⴰ ⴰⵇⴰ ⵓⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⴻⵎⵃⵉⵣⵡⴰⵔ ⴰⴷ ⵉⵏⵟⴻⵇ ⴰⵡⴰⵍ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵅ ⵓⵢⴰ ⴻⵊⵊ ⴰⴷ ⵉⵍⵉⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵓⴷⵔⵓⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC5_2","022_5_2","ECC","5","2","2","ⵎⴰⵖⴰⵔ ⴰⵎ ⵜⴰⵔⵊⵉⵜ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵀⵀⵓ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵍⵀⴰⵔⴷ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC5_3","022_5_3","ECC","5","3","3","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵡⴰⵔ ⵜⵜⵔⴰⵊⴰ ⵛⴰ ⵅⴻⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⴽⴻⵎⵎⵍⴻⴷ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⴻⵄⵊⵉⴱⴻⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ⵎⵉⵏ ⵜⵡⴰⵄⴷⴻⴷ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⵜⴽⴻⵎⵎⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EC5_4","022_5_4","ECC","5","4","4","ⵉⵀⵍⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵡⴰⵄⴷⴻⴷ ⵅ ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵡⴰⵄⴷⴻⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴽⴻⵎⵎⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EC5_5","022_5_5","ECC","5","5","5","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⵇⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⵔ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵅⴹⴰ ⵓ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵎⴰⵍⴰⴽ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵡⴻⴷⴷⴰⵔ ⵡⴰⵀⴰ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⴼⴼⵓⴳⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵓ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("EC5_6","022_5_6","ECC","5","6","6","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵉⵔⵊⴰ, ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏⵜ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ. ⵙ ⵓⵢⴰ: ⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("EC5_7","022_5_7","ECC","5","7","7","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵃⴻⴽⴽⴰⵔⴻⴷ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵓⵍⴰ ⴷ ⴰⵎⵏⴰⵄ ⵏ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰ, ⵡⴰⵔ ⵜⵜⴰⵔⵊⵉⴼ ⵛⴰ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵙⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵖⴰⵔ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⴰⵇⴰ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅⴰⵙ ⵓⵛⴰ ⵅⴰⵙⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵉⵏⵏⵉ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EC5_8","022_5_8","ECC","5","8","8","ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵜⵜⵛⴻⵟⵟⴰⵔⴻⵏ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴼⴻⴵⴰⵃⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⴻⴼⴹⴻⵍ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC5_9","022_5_9","ECC","5","9","9","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ, ⵡⴰⵔ ⵉⵜⵜⵊⵉⵡⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵜⵎⴻⵏⵢⴰⵜ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴳⵍⴰ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵊⵉⵡⵉⵏ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC5_10","022_5_10","ECC","5","10","10","ⵎⴰⵏⵉ ⵉⵜⵜⵎⴰⵔⵏⵉ ⵡⴰⴳⵍⴰ, ⴰⵎⵎⵓ ⵜⵜⵎⴰⵔⵏⵉⵏ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ. ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⵅⵣⴰⵔⴻⵏⵜ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("EC5_11","022_5_11","ECC","5","11","11","ⵉⴹⴻⵚ ⵏ ⵓⵅⴻⴷⴷⴰⵎ ⴷ ⵎⵉⵥⵉⴷ, ⵎⴰ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⴷⵔⵓⵙ ⵏⵉⵖ ⴰⵟⵟⴰⵙ ⵏ ⵎⴰⵛⵛⴰ, ⵎⴰⵛⴰ ⵉ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴰⴼⴻⵢⵢⴻⴹ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵟⵟⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("EC5_12","022_5_12","ECC","5","12","12","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵉ ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵉⵜⵜⴻⴳⴳ ⴰⵎ ⵍⴻⵀⵍⴰⵛ: ⴰⴳⵍⴰ ⵉⵜⵜⵄⴻⵙⵙ ⵅⴰⵙ ⴱⴰⴱ ⵏⵏⴻⵙ ⵉ ⴷⵔⵓⵛⵜ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC5_13","022_5_13","ECC","5","13","13","ⵉⴼⵏⴰ ⵣⴻⵄⵎⴰ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵎⵙⴰⵔⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴻⵊⵊ-ⴷⴷ ⵎⵎⵉⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⵄⴰⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC5_14","022_5_14","ECC","5","14","14","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵄⵇⴻⴱ ⴷ ⴰⵄⴰⵔⵢⴰⵏ. ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ-ⵢⵓⵙⴰ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⵎⴰⵔⵔⴻⵜ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⴽⵙⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵍⵃⴰⵊⵊⴻⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC5_15","022_5_15","ECC","5","15","15","ⵓⵍⴰ ⴷ ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ: ⵏⵉⵛⴰⵏ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵏⴻⵜⵜⴰ, ⴰⴷ ⵢⵓⵢⵓⵔ. ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵏⵏⴻⵙ ⵅⴻⵏⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉⵎⴰⵔⵔⵜⴻⵏ ⵉ ⵓⵙⴻⵎⵎⵉⴹ ⵡⴰⵀⴰ? ");
INSERT INTO rift_vpl VALUES ("EC5_16","022_5_16","ECC","5","16","16","ⵄⴰⵡⴻⴷ ⵉⵜⵜⵖⵉⵎⴰ ⵉⵜⵜⴻⵜⵜ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⵎ ⴽⴻⵎⵍⴻⵏ. ⵉⵜⵜⵡⴰⵎⴰⵔⵔⴻⵜ ⵙ ⵍⴻⵃⵍⴰⵛ ⵏⵏⴻⵙ ⴷ ⵓⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵙ ⵏ ⵡⴻⵖⴹⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("EC5_17","022_5_17","ECC","5","17","17","ⵅⵣⴰⵔ, ⵎⵉⵏ ⵜⵜⵡⴰⵍⵉⵖ ⴷ ⵎⴰⵏ ⴰⵢⴰ: ⴰⵇⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⵓ ⵉⵛⵏⴰ ⴰⵇⴰ ⵉⵊⵊ ⴰⴷ ⵉⵛⵛ, ⴰⴷ ⵉⵙⵓ ⵓ ⴰⴷ ⵉⵥⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ ⵉ ⵓⵎⵉ ⵉⵜⵜⵎⴰⵔⵔⴰⵜ ⴱⵏⴰⴷⴻⵎ ⵙⴰⴷⵓ ⵜⴰⴼⵓⵛⵜ ⴷⵉ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⴰⵔⵣⴻⴼ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC5_18","022_5_18","ECC","5","18","18","ⵄⴰⵡⴻⴷ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵉ ⵓⵎⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴳⵍⴰ ⴷ ⵜⵅⵓⴱⴰⵢ ⵓ ⵉ ⵓⵎⵉ ⵉⵡⵛⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵛ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵔⴱⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴰⵔⵃ ⵖⴰⵔ ⵓⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EC5_19","022_5_19","ECC","5","19","19","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴰⵔ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵍⴰ ⴰⵙ ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC6_1","022_6_1","ECC","6","1","1","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵏⵏⵉ ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ ⵏⵏⵉ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ ⵊⴰⵔ ⵉⵡⴷⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("EC6_2","022_6_2","ECC","6","2","2","ⵉⵊⵊⴻⵏ ⵢⴰⵔⵣⴻⴼ ⴰⵙ ⴰⵔⴻⴱⴱⵉ ⴰⴳⵍⴰ ⴷ ⵜⵅⵓⴱⴰⵢ ⴷ ⵛⵛⴰⵏ. ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⴷ ⵎⴻⵥⵔⵉ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵜ ⵉⵊⵊⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵛ, ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴰⴷ ⵜ ⵉⵛⵛ. ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC6_3","022_6_3","ECC","6","3","3","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⴻⵊⵊ-ⴷⴷ ⵎⵢⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⵉⴷⴷⴰⵔ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵊⵊⵉⵡⴻⵏ ⵛⴰ ⵙ ⵍⵅⴰⵔ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵡⴻⵏⴹⴻⵍ ⵉ ⵏⴻⵜⵜⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ: ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⴰⵢ ⵉⵛⵏⴰ ⴰⵙ ⵅ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("EC6_4","022_6_4","ECC","6","4","4","ⵎⴰⵖⴰⵔ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵓ ⵙ ⵜⴰⴵⴻⵙⵜ ⵉⵜⵜⵡⴰⵍⴻⵃⵃⴻⴼ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC6_5","022_6_5","ECC","6","5","5","ⵏⴻⵜⵜⴰ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵉⵥⵔⵉ ⵜⴰⴼⵓⵛⵜ ⵓ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏ. ⴰⵎⵎⵓ ⵖⴰⵔ ⵡⴻⵖⵔⴰⵢ-ⴰ ⵍⵀⵓⴷⵏⴻⵜ ⴽⵜⴰⵔ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EC6_6","022_6_6","ECC","6","6","6","ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⴷⴷⴰⵔ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵍⵅⴰⵔ! ⵎⴰ ⵡⴰⵔ ⵉⴳⴳⵓⵔⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⴷ ⵉⵊⵊ? ");
INSERT INTO rift_vpl VALUES ("EC6_7","022_6_7","ECC","6","7","7","ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵛⵛⵓⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC6_8","022_6_8","ECC","6","8","8","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵓⵎⵉⵖⵉⵙ ⵅ ⵓⴱⵓⵀⴰⵍⵉ? ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⴷ ⵢⵓⵢⵓⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("EC6_9","022_6_9","ECC","6","9","9","ⵉⵃⵍⴰ ⴰⴷ ⵜⴻⵥⵔⵉⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵅ ⵡⴻⵜⵍⴰⵄ ⵏ ⵍⴻⵄⵎⴰⵔ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⴷ ⵡⴻⴹⴼⴰⵔ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EC6_10","022_6_10","ECC","6","10","10","ⵎⵉⵏ ⵎⴰ ⵉⴵⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵇⴱⴻⵍ, ⵓ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⴱⵏⴰⴷⴻⵎ: ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵛⵓⴱⴱⴻⵛ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC6_11","022_6_11","ECC","6","11","11","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴻⵏⵏⵢⴻⵏ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵏ ⵓⵢⴰ ⵉ ⴱⵏⴰⴷⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("EC6_12","022_6_12","ECC","6","12","12","ⵎⴰⵖⴰⵔ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵉⵃⵍⴰⵏ ⵉ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉⴼⴻⵏⵏⴰⵏ ⵏⵏⵉ ⵉⵙⵙⵄⴻⴷⴷⵓ ⴰⵎ ⵜⵉⵍⵉ? ⵎⴰⵖⴰⵔ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⴱⵏⴰⴷⴻⵎ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("EC7_1","022_7_1","ECC","7","1","1","ⵉⵙⴻⵎ ⵉⵚⴱⴻⵃ ⵉⵃⵍⴰ ⵅ ⵣⵣⴻⵛⵜ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵉⵃⵍⴰ ⵅ ⵡⴰⵙⵙ ⵏ ⵜⴰⵔⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("EC7_2","022_7_2","ECC","7","2","2","ⵜⴻⵃⵍⴰ ⵜⵡⴰⵃⵉⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵜⵡⴰⵃⵉⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ, ⵎⵉⵏⵣⵉ ⴷⵉⵏ ⵉⴵⴰ ⵇⴻⵟⵟⵓ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵔⵔⴰ, ⵓ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC7_3","022_7_3","ECC","7","3","3","ⵉⵃⵍⴰ ⵡⴻⵛⴹⴰⵏ ⵅ ⵜⴷⴻⵃⵃⴰⵛⵜ, ⵎⴰⵖⴰⵔ ⵙ ⵉⵊⵊ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵛⴻⴹⵏⴻⵏ ⵉⴷⴷⴰⴽⴽⵯⴰⵍ ⵡⵓⵍ ⵃⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC7_4","022_7_4","ECC","7","4","4","ⵓⵍ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵛⴰ ⵓⵍ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EC7_5","022_7_5","ECC","7","5","5","ⵉⵃⵍⴰ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵖⴰⵔ ⵓⵡⴻⴱⴱⴻⵅ ⵣⴻⴳ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵅ ⵡⴻⵙⵃⴻⵙⵙⵉ ⵉ ⵢⴻⵣⵍⵉ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC7_6","022_7_6","ECC","7","6","6","ⵎⴰⵖⴰⵔ ⴰⵎ ⵓⵜⴰⵔⵜⴻⴽ ⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵙⴰⴷⵓ ⵓⵎⴻⵇⵔⴰⵊ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⴰ ⵜⴹⴻⵃⵃⴰⵛⵜ ⵏ ⵓⴱⵓⵀⴰⵍⵉ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC7_7","022_7_7","ECC","7","7","7","ⵎⴰⵖⴰⵔ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⴷ ⵜⴻⵙⵙⴱⵓⵀⵍⵉ ⴰⵎⵉⵖⵉⵙ, ⵓ ⵜⴰⵔⵣⴻⴼⵜ ⵏ ⴰⵔⵔⴻⵛⵡⴻⵜ ⵜⴻⵙⵙⴻⵅⵙⴰⵔⴰ ⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("EC7_8","022_7_8","ECC","7","8","8","ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⵃⵍⴰ ⵅ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏⵏⴻⵙ. ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴰⵟⵟⴰⵙ ⵉⵃⵍⴰ ⵅ ⵓⵎⵄⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EC7_9","022_7_9","ECC","7","9","9","ⵡⴰⵔ ⵙⴻⵅⵅⴻⴹ ⴷⴻⵖⵢⴰ ⴷⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉⵣⴻⴷⴷⴻⵖ ⵓⵅⴻⵢⵢⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("EC7_10","022_7_10","ECC","7","10","10","ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔ: “ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⵉⵏ, ⴰⵇⴰ ⵓⵙⵙⴰⵏ ⵏ ⵣⵉⵛ ⵉⵃⵍⴰⵏ ⵅ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⵡⵓⵙⵙⴰⵏ-ⴰ?” ⵎⴰⵖⴰⵔ ⴰⵙⴻⵇⵙⵉ-ⵢⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EC7_11","022_7_11","ECC","7","11","11","ⵜⵉⵖⵉⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵜⴻⵛⵏⴰ, ⵓ ⵜⵉⵖⵉⵜ ⴰⵇⴰ ⴷ ⵍⴻⴼⴹⴻⵍ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵜⴰⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC7_12","022_7_12","ECC","7","12","12","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵉⵖⵉⵜ ⵜⴻⴵⴰ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉ ⵓⵙⴻⵍⵇⵉ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⵎⴻⵏⵢⴰⵜ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵉ ⵓⵙⴻⵍⵇⵉ. ⵍⴻⴼⴹⴻⵍ ⵏ ⵜⵓⵙⵙⵏⴰ ⴰⵇⴰ ⵜⵉⵖⵉⵜ ⵜᵉⵜⵜⵉⵛ ⵜⵓⴷⴰⵔⵜ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC7_13","022_7_13","ECC","7","13","13","ⵅⵣⴰⵔ ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵙⵙⴼⴰⵔⵖ ⵏⴻⵜⵜⴰ? ");
INSERT INTO rift_vpl VALUES ("EC7_14","022_7_14","ECC","7","14","14","ⴰⵔⵔ ⵎⴻⵥⵔⵉ ⵙ ⵍⵅⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⴼⵍⴰⵃ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ, ⵅⵣⴰⵔ ⵅⴻⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵡⴰ ⵓⵍⴰ ⴷ ⵜⴰ, ⵃⵉⵎⴰ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("EC7_15","022_7_15","ECC","7","15","15","ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉ ⵥⵔⵉⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵉⴼⴻⵏⵏⴰⵏ. ⴰⵇⴰ ⴷⵉⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵏⵉ ⵉⵙⵙⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC7_16","022_7_16","ECC","7","16","16","ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⵟⵟⴰⵙ, ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵎⵉⵖⵉⵙ ⴰⵟⵟⴰⵙ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴰⵔⴻⴷⴷⴵⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("EC7_17","022_7_17","ECC","7","17","17","ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴰⵟⵟⴰⵙ ⵓ ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⵄⴰⵡⴻⴷ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⴰⵟⵟⴰⵙ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵉⵡⵉⴹ ⵄⴰⴷ ⵍⵎⵉⵊⴰⵍ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("EC7_18","022_7_18","ECC","7","18","18","ⵎⵍⵉⵃ ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵛⴻⴱⴱⴰⵔⴻⴷ ⴷⵉ ⵜⴰ, ⴰⵎ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴷⵉ ⵜⵉⵏ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EC7_19","022_7_19","ECC","7","19","19","ⵜⵉⵖⵉⵜ ⵜⴻⵙⵙⴻⵊⵀⴻⴷ ⴰⵎⵉⵖⵉⵙ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EC7_20","022_7_20","ECC","7","20","20","ⵡⴰⵀ ⵏⵉⵛⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴰⵔ ⵓ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EC7_21","022_7_21","ECC","7","21","21","ⵡⴰⵔ ⵜⵜⵉⵛ ⵜⴰⵢⵏⵉⵜ ⵏⵏⴻⵛ ⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ, ⵃⵉⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉⴷ ⴰⵇⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵉⵏⵄⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC7_22","022_7_22","ECC","7","22","22","ⵎⴰⵖⴰⵔ ⵓⵍ ⵏⵏⴻⵛ ⵢⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵜⵏⴻⵄⵍⴻⴷ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EC7_23","022_7_23","ECC","7","23","23","ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴱⴻⵇⵇⵛⴻⵖ ⵜ ⵙ ⵜⵉⵖⵉⵜ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵅⵙⴻⵖ ⴰⴷ ⴽⴻⵙⴱⴻⵖ ⵜⵉⵖⵉⵜ!”, ⵎⴰⵛⴰ ⵜⵉⵖⵉⵜ ⵜⴻⵇⵇⵉⵎ ⴰⵢⵉ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("EC7_24","022_7_24","ECC","7","24","24","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴷ ⵎⵉⵏ ⵢⵓⴵⵖⴻⵏ, ⵡⴰⵀ, ⵢⵓⴵⵖⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵢⴰⴼ? ");
INSERT INTO rift_vpl VALUES ("EC7_25","022_7_25","ECC","7","25","25","ⵏⵏⵇⴻⵍⴱⴻⵖ, ⵓⵍⴰ ⴷ ⵓⵍ ⵉⵏⵓ ⴰⴽⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴼⴻⵖ ⵜⵓⵙⵙⵏⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵇⵇⵛⴻⵖ, ⴰⴷ ⴰⵔⵣⵓⵖ ⵜⵉⵖⵉⵜ ⴷ ⵡⴻⵏⵡⴰⵢ ⵉ ⴷⴰⵢⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵖ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵍⵖⴰⵔ ⴷ ⵜⴰⵖⵢⵓⵍⵉ ⵓ ⵜⴰⵖⵢⵓⵍⵉ ⴷⴰⵢⴻⵙ ⴰⵟⴻⵎⵎⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EC7_26","022_7_26","ECC","7","26","26","ⵓⴼⵉⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵔⵣⴰⴳ ⵅ ⵍⵎⴻⵡⵜ: ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵜⵔⴰⵛⵛⴰⵡⵉⵏ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵍⴻⴼⵅⵓⵅ ⵉⵏⴻⵇⵇⴻⵏ ⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ. ⵡⴻⵏⵏⵉ ⵢⴰⵔⴹⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵏⴼⴻⴽⴽ, ⵎⴰⵛⴰ ⴰⵎⴻⴷⵏⵓⴱ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵎⵅⵓⵎⴱⴻⵔ. ");
INSERT INTO rift_vpl VALUES ("EC7_27","022_7_27","ECC","7","27","27","ⵅⵣⴰⵔ, ⴰⵢⴰ ⵉ ⵓⴼⵉⵖ, ⵉⵇⵇⴰⵔ ⵓⵎⴱⴰⵔⵔⴻⵃ, ⵓⵎⵉ ⴰⵔⴻⵏⵢⴻⵖ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⵢⵉⵛⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴰⴼⴻⵖ ⵍⵃⴰⵙⵓⵍ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("EC7_28","022_7_28","ECC","7","28","28","ⵎⵉⵏ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵓⴼⵉⵖ. ⵡⴰⵀ ⵓⴼⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⴻⴳ ⵡⴰⵍⴻⴼ, ⵎⴰⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵖ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵢⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EC7_29","022_7_29","ECC","7","29","29","ⵅⵣⴰⵔ, ⵉⵛⵜ ⵡⴰⵀⴰ ⵉ ⵓⴼⵉⵖ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵢⴻⴱⵔⵉⴷⴻⵏ ⵉⵃⵔⴰⵢⵎⴻⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC8_1","022_8_1","ECC","8","1","1","ⵡⵉ ⵉⴵⴰⵏ ⴰⵎ ⵓⵎⵉⵖⵉⵙ ⵓ ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⴰⴷ ⵉⴼⴻⴽⴽ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ? ⵜⵉⵖⵉⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜᵉⵜⵜⴰⵔⵔⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵉⵜⵜⵏⴻⵡⵡⴰⵔ ⵓⵛⴰ ⵜⴱⴻⴷⴷⴻⵍ ⵜⵉⴼⵔⴰⵙ ⵏ ⵍⴻⵇⵙⴻⵃ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC8_2","022_8_2","ECC","8","2","2","ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ: “ⵃⴹⴰ ⴰⴹⴻⴱⴱⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ!” ⵓ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EC8_3","022_8_3","ECC","8","3","3","ⵡⴰⵔ ⵜⵜⵉⴳⴳⵯⵉⵊ ⵙ ⵜⴰⵣⵍⴰ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵢⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EC8_4","022_8_4","ECC","8","4","4","ⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵢⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵜⴻⵎⵖⴰⵔ. ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: “ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵛⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("EC8_5","022_8_5","ECC","8","5","5","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ, ⵡⴰⵔ ⵜ ⵉⵍⴻⵇⵇⴻⴼ ⵡⴰⵍⵓ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ⵓⵍ ⵏ ⵓⵎⵉⵖⵉⵙ ⵉⵙⵙⴻⵏ ⵍⵃⴰⵍ ⴷ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("EC8_6","022_8_6","ECC","8","6","6","ⵎⴰⵖⴰⵔ ⵉ ⴽⵓⵍ ⴰⵏⵡⴰⵢ ⵉⵊⵊ ⵏ ⵍⵃⴰⵍ ⴷ ⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ, ⵎⴰⵖⴰⵔ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⴻⵙⵙⴻⴷⵇⴰⵍ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("EC8_7","022_8_7","ECC","8","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵙ ⵜ ⵉ ⵖⴰ ⵉⵙⵙⵛⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("EC8_8","022_8_8","ECC","8","8","8","ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵣⴻⵎⵎⴰⵔ ⵅ ⵓⵙⵓⴹⵉ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⴰⵍⴰⵎⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙ ⵉⴱⴻⵍⵍⴻⵄ. ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵡⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴽⵙⵉ ⵜⵜⴻⵙⵔⵉⵃ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⵓ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵡⴰⵔ ⵜⴻⵊⵊⵉ ⴰⴷ ⵏⴻⵊⵎⴻⵏ ⴰⵢⵜⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC8_9","022_8_9","ECC","8","9","9","ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵥⵔⵉⵖ ⵜ, ⵓⵎⵉ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵓⵍ ⵉⵏⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵍⴰⵎⵉ ⵉⵚⴻⵍⵍⴻⵟ ⴱⵏⴰⴷⴻⵎ ⵅ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ ⵉ ⴷⵔⵓⵛⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC8_10","022_8_10","ECC","8","10","10","ⴰⵎⵎⵓ ⵉ ⵥⵔⵉⵖ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵏⴻⴹⵍⴻⵏ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⵓⵎⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ, ⵜⵜⵡⴰⵜⵜⵓⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC8_11","022_8_11","ECC","8","11","11","ⵎⴰⵖⴰⵔ ⵍⵃⵓⴽⵎ ⵅ ⵜⵄⴻⴼⴼⴰⵏⵜ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⴷⴻⵖⵢⴰ, ⵅ ⵓⵢⴰ ⵉⵛⵛⵓⵔ ⵡⵓⵍ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC8_12","022_8_12","ECC","8","12","12","ⵡⴰⵅⵅⴰ ⴰⵎⴻⴷⵏⵓⴱ ⵉⵜⵜⴻⴳⴳ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵎⵢⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓ ⵉⴷⴷⴰⵔ ⴰⵟⵟⴰⵙ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴼⴻⵍⵃⴻⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC8_13","022_8_13","ECC","8","13","13","ⴰⵄⴻⴼⴼⴰⵏ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵎⵍⵉⵃ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜᵉⵜⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⴷ ⵜⴰⵣⵉⵔⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵜⵉⵍⵉ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EC8_14","022_8_14","ECC","8","14","14","ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ: ⴰⵇⴰ ⴷⵉⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉⵜⵜⴻⵎⵎⵙⴰⵔ ⴰⵙⴻⵏ ⴰⵅⵎⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵎ ⵢⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⴻⵎⵙⴰⵔ ⴰⵙⴻⵏ ⴰⵅⵎⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC8_15","022_8_15","ECC","8","15","15","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵜⵜⵚⴻⴱⴱⴰⵃⴻⵖ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵉ ⴱⵏⴰⴷⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵃⵙⴻⵏ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵜⵜ, ⵉⵙⴻⵙⵙ ⵓ ⵉⴼⴰⵔⵔⴻⵃ. ⵉⵍⵉ ⴰⵢⴰ ⴰⴷ ⵜ ⵉⵄⴰⵛⴰⵔ ⴷⴻⴳ ⵓⵎⴰⵔⵔⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⵢⴰⵔⵣⴻⴼ ⴰⵔⴻⴱⴱⵉ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC8_16","022_8_16","ECC","8","16","16","ⵓⵎⵉ ⵜⵓⵖⴰ ⴳⴳⵉⵖ ⵓⵍ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵖ ⵜⵉⵖⵉⵜ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⵣⴰⵔⴻⵖ ⵎⴰⵏ ⵜⴰⵙⴻⴱⴱⴰⴱⵜ ⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ - ⵎⴰⵖⴰⵔ ⴰⵎ ⵙ ⵡⴰⵙⵙ ⴰⵎ ⵙ ⴵⵉⵍⴻⵜ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⵛⴰ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ - ");
INSERT INTO rift_vpl VALUES ("EC8_17","022_8_17","ECC","8","17","17","ⵥⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴼ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵎⴰⵔⵔⴻⵜ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵢⴰⵔⴻⵣⵣⵓ, ⵡⴰⵔ ⵉⵜⵜⵉⴼ ⵡⴰⵍⵓ. ⵡⴰⵅⵅⴰ ⴰⵎⵉⵖⵉⵙ ⴰⴷ ⵢⵉⵏⵉ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵢⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("EC9_1","022_9_1","ECC","9","1","1","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵖⴰⵔ ⵡⵓⵍ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵣⵓⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰⵇⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⴰⵢⵔⵉ ⴷ ⵡⴻⵛⵔⴰⵀ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵉⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⴵⴰ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC9_2","022_9_2","ECC","9","2","2","ⵎⴰⵔⵔⴰ ⵉⴵⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ: ⵜⵉⵔⴰ ⴷ ⵉⵛⵜ ⵜⵍⴻⵇⵇⴻⴼ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷ ⵓⵄⴻⴼⴼⴰⵏ, ⴰⵎ ⵓⵚⴻⴱⵃⴰⵏ ⴷ ⵓⵎⴻⵣⴷⴰⴳ ⴰⵎ ⵓⵎⴻⵅⵎⵓⵊ, ⵡⴻⵏⵏⵉ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ, ⴰⵚⴻⴱⵃⴰⵏ ⴷ ⵓⵎⴻⴷⵏⵓⴱ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵊⵊⴰⴵⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵊⵊⴰⴵ. ");
INSERT INTO rift_vpl VALUES ("EC9_3","022_9_3","ECC","9","3","3","ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵉⵍⵇⴻⴼ ⵉ-ⵜⴻⵏ ⵜⵉⵔⴰ ⴷ ⵉⵛⵜ, ⵓⵛⴰ ⵓⵍⴰ ⵓⵍ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵛⵛⵓⵔ ⵙ ⵍⵖⴰⵔ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⴻⵎⵎⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC9_4","022_9_4","ECC","9","4","4","ⵎⴰⵖⴰⵔ ⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⵉⵜⴻⵎ, ⵎⵉⵏⵣⵉ ⵍⵃⴰⵍ ⵉ ⵡⴻⵇⵣⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵃⵙⴻⵏ ⵣⵉ ⵍⵃⴰⵍ ⵉ ⵡⴻⵢⵔⴰⴷ ⵉⵎⵎⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC9_5","022_9_5","ECC","9","5","5","ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⴻⵜⵜⴰⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵡⴰⵍⵓ ⵇⴰⵄ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜᵉⵟⵟⴼⴻⵏ ⵡⴰⵍⵓ ⵣⵉ ⵍⵎⵓⵏⴻⵜ, ⵎⴰⵖⴰⵔ ⵍⵉⴷⴰⵔⴻⵜ ⵅⴰⴼⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⵜⵜⵓ. ");
INSERT INTO rift_vpl VALUES ("EC9_6","022_9_6","ECC","9","6","6","ⴰⵇⴰ ⵜⴰⵢⵔⵉ ⵏⵙⴻⵏ ⴷ ⵡⴻⵛⵔⴰⵀ ⵏⵙⴻⵏ ⴷ ⵜⵓⵙⵎⵉ ⵏⵙⴻⵏ ⴼⵏⴰⵏ. ⵉ ⵍⴻⴱⴷⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⵄⴰⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⵎⵙⴰⵔⴻⵏ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC9_7","022_9_7","ECC","9","7","7","ⵓⵢⵓⵔ ⵅⴻⵏⵏⵉ, ⵉⵡⴰ ⴻⵛⵛ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵛ, ⵙⵓ ⵙ ⵡⵓⵍ ⵉⴼⴰⵔⵃⴻⵏ ⴱⵉⵏⵓ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵉⵄⵊⴻⴱ ⴰⵙ ⵉ ⴰⵔⴻⴱⴱⵉ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("EC9_8","022_9_8","ECC","9","8","8","ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵍⴻⴱⴷⴰ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵣⵣⴻⵛⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EC9_9","022_9_9","ECC","9","9","9","ⴱⴰⵔⵔⴻⵄ ⵅ ⵜⵓⴷⴰⵔⵜ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵉⴼⴻⵏⵏⴰⵏ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⵎⴰⵍⴰ ⵓⵙⵙⴰⵏ ⵏ ⵍⵃⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵉⴼⴻⵏⵏⴰⵏ ⴷⴰⵏⵉⵜⴰ, ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴷⵉ ⵜⵓⴷⴰⵔⵜ-ⴰ ⵓ ⵖⴰⵔ ⵓⵎⴰⵔⵔⴻⵜ ⵉ ⵣⵉ ⵜⵎⴰⵔⵔⵜⴻⴷ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC9_10","022_9_10","ECC","9","10","10","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⴰⴼ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵢⴻⴳⴳ, ⴻⴳⴳ ⵉ-ⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵍⴰⵅⴰⵔⵜ ⵎⴰⵏⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ, ⵏⵉⵖ ⴰⵅⴰⵔⵔⴻⵚ ⵏⵉⵖ ⵜⵓⵙⵙⵏⴰ ⵓⵍⴰ ⴷ ⵜⵉⵖⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EC9_11","022_9_11","ECC","9","11","11","ⵄⴰⵡⴻⴷ ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ ⴰⵇⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴰⵣⵍⴰ ⵡⴰⵔ ⵖⴻⴵⴱⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵃⴰⵎⴰⵜ, ⵏⵉⵖ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⵓ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⴵⵉ ⵡⴻⵖⵔⵓⵎ ⵍⴻⴱⴷⴰ ⵓ ⵢⵉⵏⵏⵉ ⵙ ⵍⴻⵄⵇⴻⵍ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⴵⵉ ⵡⴰⴳⵍⴰ ⵍⴻⴱⴷⴰ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⴵⵉ ⴰⵔⴹⴰ ⵍⴻⴱⴷⴰ, ⵎⴰⵖⴰⵔ ⵍⵃⴰⵍ ⴷ ⵜⵉⵔⴰ ⵍⴻⵇⵇⴼⴻⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EC9_12","022_9_12","ECC","9","12","12","ⵎⴰⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵍⵎⵉⵊⴰⵍ ⵏⵏⴻⵙ, ⴰⵎ ⵢⵉⵙⴻⵍⵎⴰⵏ ⵉⵏⵃⴻⵚⵔⴻⵏ ⴷⵉ ⵜⵔⴰⵛⵛⴰ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ, ⵓ ⴰⵎ ⵢⵉⵊⴹⴰⴹ ⵉⵏⵏⵃⴻⵚⵔⴻⵏ ⴷⵉ ⵍⴼⴻⵅ. ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷⵉ ⵍⴼⴻⵅ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵅⵎⵉ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵜⵡⴻⵟⵟⴰ ⵜⵔⴰⵛⵛⴰ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EC9_13","022_9_13","ECC","9","13","13","ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴱⴷⵉⵖ ⴰⴷ ⴷⴰⵢⴻⵙ ⵥⵔⵉⵖ ⵜⵉⵖⵉⵜ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⵜⵓⵙⴰ ⴰⵢⵉ-ⴷⴷ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EC9_14","022_9_14","ECC","9","14","14","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⴷⴰⵢⴻⵙ ⴷⵔⵓⵙ ⵏ ⵢⴻⵡⴷⴰⵏ ⵡⴰⵀⴰ. ⵉⴼⴼⴻⵖ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵃⴻⵡⵡⴻⵙ ⵉ-ⵜⵜ, ⵓ ⵉⵙⵙⴱⴻⴷⴷ ⵅⴰⵙ ⵍⴱⴰⵔⴰⵊⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EC9_15","022_9_15","ECC","9","15","15","ⵉⵜⵜⵡⴰⴼⴼ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⴷ ⴰⵎⵉⵖⵉⵙ ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵄⵇⴻⵍ ⵄⴰⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EC9_16","022_9_16","ECC","9","16","16","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: “ⵜⵉⵖⵉⵜ ⵜⴻⵃⵍⴰ ⵅ ⵊⵊⵀⴻⴷ!”, ⵡⴰⵅⵅⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⵜⵉⵖⵉⵜ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵓ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC9_17","022_9_17","ECC","9","17","17","ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⵜⴻⵙⵍⴰⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⵃⵙⴻⵏ ⵣⴻⴳ ⵓⵖⵓⵢⵢⵉ ⵏ ⵍⵃⴰⴽⴻⵎ ⵊⴰⵔ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC9_18","022_9_18","ECC","9","18","18","ⵜⵉⵖⵉⵜ ⵜⴻⵃⵍⴰ ⵅ ⵍⴻⵙⵏⴰⵃ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵏⵓⴱ ⵡⴰⵀⴰ ⵉⵀⴻⴷⴷⴻⵎ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EC10_1","022_10_1","ECC","10","1","1","ⵉⵣⴰⵏ ⵉⵏⴻⵇⵇⴻⵏ ⵜⵜⴰⵔⵔⴰⵏ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵏ ⵓⵄⴻⵟⵟⴰⵔ ⴰⴷ ⵜⴰⵔⵚⵓⴹ ⵓ ⴰⴷ ⵜⴻⵙⵎⴻⵎ. ⴷⵔⵓⵙ ⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵜⵡⴻⵣⵣⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵜⵉⵖⵉⵜ ⴷ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC10_2","022_10_2","ECC","10","2","2","ⵓⵍ ⵏ ⵓⵎⵉⵖⵉⵙ ⴰⵇⴰ-ⵜ ⵉ ⵏⴻⵜⵜⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ, ⵎⴰⵛⴰ ⵓⵍ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵉ ⵡⴰⵏⵉⵜⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("EC10_3","022_10_3","ECC","10","3","3","ⵓⵍⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⵉⵏ ⵅⴻⴼ ⵉⴳⴳⵓⵔ ⵓⴱⵓⵀⴰⵍⵉ, ⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵎⵜⵉⵏ, ⵉⵇⵇⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⴱⵓⵀⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EC10_4","022_10_4","ECC","10","4","4","ⵎⴰⵍⴰ ⵅⴰⴽ ⵉⵅⴻⵢⵢⴻⵇ ⴱⵓⵃⴱⴻⵍ ⵏ ⴱⵓ-ⵊⵊⴻⵀⴷ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⵉⵊ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴷⴷⵡⴰ, ⵢⴰⵔⴻⵙⵙⴰ ⴷⴷⵏⵓⴱ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC10_5","022_10_5","ECC","10","5","5","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⵜⴼⵓⵛⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵡⴻⴷⴷⴰⵔ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ: ");
INSERT INTO rift_vpl VALUES ("EC10_6","022_10_6","ECC","10","6","6","ⴰⵙⴳⴻⵄⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⴰⵎ ⵜⵜⵖⵉⵎⴰⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("EC10_7","022_10_7","ECC","10","7","7","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⵎ ⵢⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EC10_8","022_10_8","ECC","10","8","8","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵇⵇⴰⵣⴻⵏ ⴰⵃⴼⵓⵔ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵡⴹⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵍⵃⵉⴹ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⵇⵇⴻⵙ ⵓⴼⵉⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EC10_9","022_10_9","ECC","10","9","9","ⵡⴻⵏⵏⵉ ⵉⴽⴽⵙⴻⵏ ⵉⵥⵔⴰ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵢⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴼⴻⵜⵜⵇⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ, ⴰⴷ ⵢⵉⵍⵉ ⴷⵉ ⵍⵅⴰⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EC10_10","022_10_10","ECC","10","10","10","ⵎⴰⵍⴰ ⵓⵣⵣⴰⵍ ⵏ ⵛⵛⴰⵇⵓⵔ ⵉⴷⵡⴻⵍ ⵉⵃⴼⴰ ⵓ ⴱⴰⴱ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵉⵙⵙⴻⵇⴹⴻⵄ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵊⵊⵀⴻⴷ ⴽⵜⴰⵔ, ⵎⴰⵛⴰ ⵜⵉⵖⵉⵜ ⵜⴻⵛⵏⴰ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⵍⴻⵃ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EC10_11","022_10_11","ECC","10","11","11","ⵎⴰⵍⴰ ⵉⵣⵄⴻⴼ ⵓⴼⵉⵖⴰⵔ ⵇⴱⴻⵍ ⴰⵄⴻⵣⵣⴻⵎ, ⵡⴰⵔ ⴷⵉⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵓⵄⴻⵣⵣⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EC10_12","022_10_12","ECC","10","12","12","ⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵉⵖⵉⵙ ⴷⴰⵢⵙⴻⵏ ⴰⵔⴹⴰ, ⵎⴰⵛⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵚⴰⵔⴹⴻⵏ ⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EC10_13","022_10_13","ECC","10","13","13","ⴱⴻⴷⴷⵓ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵓ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵎⵉⵏ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴷ ⴰⵟⴻⵎⵎⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC10_14","022_10_14","ECC","10","14","14","ⴰⴱⵓⵀⴰⵍⵉ ⵉⵜⵜⴽⴻⵜⵜⴰⵔ ⵍⵀⴰⵔⴷ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ, ⵓ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵡⵉ ⴷ ⴰⵙ ⵜ ⵉ ⵖⴰ ⵉⵄⴰⵡⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("EC10_15","022_10_15","ECC","10","15","15","ⴰⵎⴰⵔⵔⴻⵜ ⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⵓⵃⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EC10_16","022_10_16","ECC","10","16","16","ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵍⴰ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵎ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵄⴰⴷ, ⵓ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵎ ⵖⴰⵔ ⵜⴻⴼⴼⵓⵜ ⵜⵜᵉⵜⵜⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EC10_17","022_10_17","ECC","10","17","17","ⵙⵙⴻⵄⴷ ⵏⵏⴻⵎ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵍⴰ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵎ ⴷ ⵎⵎⵉⵙ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ⵓ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵎ ⵜⵜᵉⵜⵜⴻⵏ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵎⴻⵃⴷⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴽⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC10_18","022_10_18","ECC","10","18","18","ⵙ ⵍⴻⵄⴳⴻⵣ ⵉ ⵀⴻⴽⴽⵡⴰⵏⵜ ⵜⵉⵃⴻⵏⵢⴰ ⵓ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵢⴰⵔⴻⵀⴼⴻⵏ ⴰⴷ ⵜⵓⴷⵓⵎ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EC10_19","022_10_19","ECC","10","19","19","ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴻⴳⴳ ⴰⵖⵔⵓⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴹⵃⴻⵛ, ⴱⵉⵏⵓ ⵉⵙⵙⴼⴰⵔⵔⴰⵃ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵜⵎⴻⵏⵢⴰⵜ ⵏⴻⴼⴼⵄⴻⵏⵜ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC10_20","022_10_20","ECC","10","20","20","ⵡⴰⵔ ⵏⴻⵄⵄⴻⵍ ⴰⵊⴻⴵⵉⴷ ⵄⴰⴷ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵢⵉⴹⴻⵚ ⵡⴰⵔ ⵏⴻⵄⵄⴻⵍ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵎⴰⵖⴰⵔ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵓⵢⵓⵔⴻⵏ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵓ ⴰⵎⵎⵓ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰⵔ ⴵⴰⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵄⴷⵓ ⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EC11_1","022_11_1","ECC","11","1","1","ⵙⴻⴽⴽ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵛ ⵜⵉⵡⴰ ⵉ ⵡⴰⵎⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜ ⵜⴰⴼⴻⴷ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EC11_2","022_11_2","ECC","11","2","2","ⴱⴹⴰ ⵜ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏⵉⵖ ⵄⴰⴷ ⴷⵉ ⵜⵎⴻⵏⵢⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵎⴰⵏ ⵍⵖⴰⵔ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EC11_3","022_11_3","ECC","11","3","3","ⵎⴰⵍⴰ ⵛⵛⵓⵔⴻⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵜⵜⵣⴻⴵⴰⵄⴻⵏ ⴰⵏⵥⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵡⴹⴰ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏⵉⵖ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⴻⵡⴹⴰ, ⵜᵉⵜⵜⵖⵉⵎⴰ ⴷⵉⵏ ⵜⴻⵣⵣⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC11_4","022_11_4","ECC","11","4","4","ⵡⴻⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⵖⴰⵔ ⵓⵙⴻⵎⵎⵉⴹ, ⵡⴰⵔ ⵉⵜⵜⵉⵡⵉⴹ ⴰⴷ ⵉⵣⴰⵔⵄ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⴻⴱⴷⴰ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵉⵡⵉⴹ ⴰⴷ ⵉⵎⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EC11_5","022_11_5","ECC","11","5","5","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⵎⵎⵓ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵓⵍⴰ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⵖⵙⴰⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ. ⴰⵎⵎⵓ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵓⵍⴰ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EC11_6","022_11_6","ECC","11","6","6","ⵣⴰⵔⵄ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵓ ⵡⴰⵔ ⵜⵜⴻⴽⴽⴻⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵎⵉⵏ ⵉ ⵖⴰ ⵉⴼⵍⴻⵃ, ⵜⴰ ⵏⵉⵖ ⵜⴰ, ⵏⵉⵖ ⵄⴰⴷ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏⵜ ⴰⴷ ⵉⵍⵉⵏⵜ ⵚⴻⴱⵃⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EC11_7","022_11_7","ECC","11","7","7","ⵜⴰⴼⴰⵡⵜ ⴷ ⵜⵎⵉⵥⵉⴷⵜ ⵓⵛⴰ ⵎⵍⵉⵃ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EC11_8","022_11_8","ECC","11","8","8","ⵡⴰⵀ, ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵉⴷⴷⴰⵔ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴼⴰⵔⵃ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⵉ, ⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵄⵇⴻⵍ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵓⵙⵙⴰⵏ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵄⴰⴷ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC11_9","022_11_9","ECC","11","9","9","ⴼⴰⵔⵃ, ⴰ ⵛⴻⴽ ⴰⵃⵓⴷⵔⵉ, ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ, ⵙⴼⴰⵔⵃ ⵓⵍ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ. ⵓⵢⵓⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵎⵉⵏ ⵜⵜⵡⴰⵍⴰⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵙⵙⴻⵏ ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⴽⴽ ⵅ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉ ⵛⵛⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("EC11_10","022_11_10","ECC","11","10","10","ⵙⵉⴳⴳⵯⴻⵊ ⵍⵀⴻⵎⵎ ⵅ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓ ⵙⵃⴻⵢⵢⴻⴷ ⵍⵖⴰⵔ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵜⴻⵎⵥⵉ ⴷ ⵍⵡⴻⵇⵜ ⵙ ⵓⵛⵓⵡⵡⴰⴼ ⴰⴱⴰⵔⵛⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC12_1","022_12_1","ECC","12","1","1","ⵉⴷⴰⵔ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ, ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵖⴰⵔ ⵉ ⵣⵉ ⵖⴰ ⵜⵉⵏⵉⴷ: “ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⴼⵉⵖ ⵍⴻⴼⵔⴰⵃⴻⵜ!”, ");
INSERT INTO rift_vpl VALUES ("EC12_2","022_12_2","ECC","12","2","2","ⵇⴱⴻⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⵛⴻⵏ ⵜⴼⵓⵛⵜ ⴷ ⵜⴼⴰⵡⵜ ⴷ ⵜⵣⵉⵔⵉ ⴷ ⵉⵜⵔⴰⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵥⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("EC12_3","022_12_3","ECC","12","3","3","ⵖⴰⵔ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴷ ⵇⴻⵡⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⵃⴰⵔⵔⵢⴻⵏ ⵜⴰⵙⵉⵔⵜ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏⵜ ⵜⴰⵡⵡⵓⵔⵉ ⵏⵙⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⵇⵇⵉⵎⴻⵏⵜ ⴷⵔⵓⵙ ⵉⴷⵙⴻⵏⵜ, ⵓⵛⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴰⵊⵊⴰⵏ ⵣⵉ ⵍⴽⵡⴰⵣⵉ, ⴰⴷ ⵜⵜⵡⴰⵍⴻⵃⵃⴼⴻⵏⵜ ⵙ ⵜⴰⴵⴻⵙⵜ, ");
INSERT INTO rift_vpl VALUES ("EC12_4","022_12_4","ECC","12","4","4","ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵖⴰⵔ ⵣⵣⴻⵏⵇⵇⴻⵜ ⴰⴷ ⵜⵜⵡⴰⴱⴻⵍⵍⵄⴻⵏⵜ, ⵅⵎⵉ ⴷⴷⵔⵉⵣ ⵏ ⵜⵙⵉⵔⵜ ⴰⴷ ⵉⵙⵙⴻⵖⴷ ⵓⵛⴰ ⵍⵃⴻⵙⵙ ⵏ ⵓⵊⴹⵉⴹ ⴰⴷ ⵜ ⵉⵙⵙⵉⴳⴳⵡⴻⴷ ⴷⴻⴳ ⵢⵉⴹⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵖⴻⵏⵏⵉⵊ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵇⴻⵡⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("EC12_5","022_12_5","ECC","12","5","5","ⵓ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴳⴳⵯⴻⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵢⵓⵄⵍⴰⵏ, ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵓ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴵⴻⵡⵣ ⴰⴷ ⵜⵏⴻⵡⵡⴰⵔ ⵓ ⴰⴱⵓⵔⵅⴻⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⵎⴰⵔⴰ ⵓ ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵏ ‘ⵓⴽⴻⴱⴱⴰⵙ’ ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⵉ ⵄⴰⴷ ⵖⴰⵔ ⵍⴱⴰⵍ - ⵎⴰⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⵉⵏⵏⵉ ⵉⵛⴻⵟⵟⵏⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("EC12_6","022_12_6","ECC","12","6","6","ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵔⵅⵓ ⵜⴻⵙⵖⵓⵏⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⵥ ⵟⵟⴰⵡⵢⵢⴻⵜ ⵏ ⵡⵓⵔⴻⵖ, ⴰⴷ ⵉⵏⵏⴻⴼⵔⴰⵔ ⵡⴻⵇⴱⵓⵛ ⵖⴰⵔ ⵜⴰⵍⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵇⴹⵓ ⵜⵊⴰⵔⵔⴰⵔⵜ ⴷⴻⴳ ⵡⴰⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("EC12_7","022_12_7","ECC","12","7","7","ⵓⵛⴰ ⵓⵛⴰⵍ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ-ⵜⵓⵖⴰ, ⵓ ⴱⵓⵃⴱⴻⵍ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵜ ⵉⵡⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EC12_8","022_12_8","ECC","12","8","8","ⴷ ⵉⴱⴻⵟⵟⴰⵍⴻⵏ ⵇⴰⵄ, ⵉⵇⵇⴰⵔ ⵓⵎⴱⴰⵔⵔⴻⵃ, ⴰⵇⴰ ⴽⵓⵍⵛⵉ ⴷⵉ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EC12_9","022_12_9","ECC","12","9","9","ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵢⴰ, ⵎⵉⵏⵣⵉ ⴰⵎⴱⴰⵔⵔⴻⵃ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵉⵙⵙⴻⵍⵎⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵓⵙⵙⵏⴰ ⵉ ⵍⴳⴻⵏⵙ, ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵍⵓ, ⵉⵜⵜⴱⴻⵇⵇⴰⵛ ⵎⵍⵉⵃ, ⵓⵛⴰ ⵉⵄⴷⴻⵍ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EC12_10","022_12_10","ECC","12","10","10","ⵢⴰⵔⵣⵓ ⵓⵎⴱⴰⵔⵔⴻⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴼ ⴰⵡⴰⵍⴻⵏ ⵉⵄⴻⴷⵍⴻⵏ, ⵓ ⵎⵉⵏ ⵢⵓⵔⴰ, ⴰⵇⴰ-ⵜ ⵏⵉⵛⴰⵏ, ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EC12_11","022_12_11","ECC","12","11","11","ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⵎ ⵢⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵎⴻⵙⵎⵉⵔⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵉⴷⴼⴻⵏ, ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉ-ⴷⴷ-ⵜⵜⴰⵙⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ⴰⵇⴰ-ⵜⴻⵏ ⵎⵎⴻⵡⵛⴻⵏ ⵣⴻⴳ ⵓⵢⴻⵏⵏⵉ ⵏ ⵓⵎⴻⴽⵙⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("EC12_12","022_12_12","ECC","12","12","12","ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰ ⵎⵎⵉ, ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ: ⵡⴰⵔ ⴷⵉⵏ ⴰⵇⴻⵟⵟⵓ ⵏ ⵜⵉⵔⴰ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵓ ⴰⵟⵟⴰⵙ ⵏ ⵜⵖⵓⵔⵉ ⵜⴻⵙⵙⴰⵃⴰⵍ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EC12_13","022_12_13","ECC","12","13","13","ⴰⵡⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵙⵍⵉⴷ, ⴰⵇⴰ ⵜ ⴷ ⵡⴰ: “ⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵃⴹⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ!”, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵢⵓⵔⵉⵏ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EC12_14","022_12_14","ECC","12","14","14","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵡⵉ ⴽⵓⵍ ⵜⴰⵎⴻⴳⴳⵉⵜ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵎⴰ ⵜⵓⵖⴰ ⵉⵚⴱⴻⵃ ⵏⵉⵖ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵃⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("SS1_1","023_1_1","SNG","1","1","1","ⵉⵣⵍⵉ ⵅ ⵉⵣⵍⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS1_2","023_1_2","SNG","1","2","2","“ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵓⴷⴻⵎ ⵙ ⵉⵙⵓⴷⵉⵎⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵓⵙⵃⵉⵏⵏⴻⴱ ⵏⵏⴻⵛ ⵃⵙⴻⵏ ⵣⵉ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("SS1_3","023_1_3","SNG","1","3","3","ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴻⵛⵏⴰ, ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵎ ⵣⵣⴻⵛⵜ ⵉⵣⴻⴵⵄⴻⵏ, ⵅ ⵓⵢⴰ ⵜⵜⴻⵅⵙⴻⵏⵜ ⵛⴻⴽ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("SS1_4","023_1_4","SNG","1","4","4","ⵊⴱⴻⴷ ⴰⵢⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴰⵣⵣⴻⵍ ⴰⵡⴰⵔⵏⵉ ⴰⵛ! ⴰⵊⴻⴵⵉⴷ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⴻⴳ ⵉⵅⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⵛⴻⵇ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵏⴼⴰⵔⵃ, ⴰⴷ ⵏⴻⵄⵇⴻⵍ ⵅ ⵓⵙⵃⵉⵏⵏⴻⴱ ⵏⵏⴻⵛ ⴽⵜⴰⵔ ⵅ ⵎⵉⵏ ⵖⴰ ⵏⴻⵄⵇⴻⵍ ⵅ ⴱⵉⵏⵓ. ⵏⵉⵛⴰⵏ ⵜⵜⴻⵅⵙⴻⵏⵜ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("SS1_5","023_1_5","SNG","1","5","5","“ⴷ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ ⵏⴻⵛⵛ, ⵓ ⵚⴻⴱⵃⴻⵖ, ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎ ⵜⵇⵉⴹⵓⵏⵉⵏ ⵏ ⵇⵉⴷⴰⵔ, ⴰⵎ ⵍⵉⵣⴰⵔⴰⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS1_6","023_1_6","SNG","1","6","6","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⴰⵎⵎⵓ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴱⴱⴰⵔⵛⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⴰⵢⵉ ⵜⴼⵓⵛⵜ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴻⵎⵎⴰ ⵜⵓⵖⴰ ⵅⴻⵢⵢⵇⴻⵏ ⵅⴰⴼⵉ, ⴳⴳⵉⵏ ⴰⵢⵉ ⴰⴷ ⵃⴹⵉⵖ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵃⴹⵉⵖ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("SS1_7","023_1_7","SNG","1","7","7","“ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ, ⵉⵏⵉ ⴰⵢⵉ, ⵎⴰⵏⵉ ⵜⴰⵔⴻⴽⴽⵡⴻⵙⴻⴷ, ⵎⴰⵏⵉ ⵜⴻⵙⵙⴰⵔⴻⵢⵢⴰⵃⴻⴷ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵖⴰⵔ ⵟⵃⴰ ⵏ ⵓⵣⵉⵍ, ⵎⵉⵏⵣⵉ ⵉ ⵓⵎⵉ ⵖⴰ ⵉⵍⵉⵖ ⴰⵎ ⵜⴻⵏⵏⵉ ⵉⵃⴻⵊⴱⴻⵏ ⵖⴰⵔ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("SS1_8","023_1_8","SNG","1","8","8","“ⵎⴰⵍⴰ ⵛⴻⵎ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵊⴰⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵅⴻⵏⵏⵉ ⴼⴼⴻⵖ, ⴹⴼⴰⵔ ⵍⴰⵜⴰⵔ ⵏ ⵡⵓⴵⵉ, ⴰⵔⵡⴻⵙ ⵜⵉⵖⴰⴹⵜⵉⵏ ⵏⵏⴻⵎ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS1_9","023_1_9","SNG","1","9","9","“ⵙⵙⴻⵎⵇⵓⴷⴷⵉⵖ ⵛⴻⵎ ⴰⴽ-ⴷ ⵍⵄⴻⵡⴷⴰ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰ ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("SS1_10","023_1_10","SNG","1","10","10","ⵎⴻⵛⵃⴰⵍ ⵚⴻⴱⵃⴻⵏ ⵉⵎⴻⴳⴳⵉⵣⴻⵏ ⵏⵏⴻⵎ ⵊⴰⵔ ⵜⵙⴻⴷⴷⵢⵉⵏ, ⵉⵔⵉ ⵏⵏⴻⵎ ⵊⴰⵔ ⵉⴼⵉⵍⴰⵏ ⵙ ⵜⵢⴰⵇⵓⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("SS1_11","023_1_11","SNG","1","11","11","ⴰⴷ ⴰⵎ ⵏⴻⴳⴳ ⵜⵉⵙⴻⴷⴷⵢⵉⵏ ⵏ ⵡⵓⵔⴻⵖ, ⴰⴽ-ⴷ ⵜⵏⴻⵇⵇⵉⴹⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("SS1_12","023_1_12","SNG","1","12","12","“ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵏⵏⴻⵙ ⵜⴰⵇⵓⵔⴰⵔⵉⵜ, ⵉⵜⵜⵉⵛⵛ ⵚⵚⴻⵏⴱⴻⵍ ⵉⵏⵓ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("SS1_13","023_1_13","SNG","1","13","13","ⵍⵍⵉⴼ ⵉⵏⵓ ⵉⵜⵜⴻⴳⴳ ⴰⵢⵉ ⴰⵎ ⵜⴻⵛⵢⴰⵔⵜ ⵏ ⵎⵉⵔⵔⵓ, ⵜⴻⵏⵏⵉ ⵉⵙⵙⴻⵏⵙⴻⵏ ⵊⴰⵔ ⵉⴷⵎⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("SS1_14","023_1_14","SNG","1","14","14","ⵍⵍⵉⴼ ⵉⵏⵓ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⵜⵇⴻⴱⴱⵉⴹⵜ ⵏ ⵏⴻⵡⵡⴰⵛ ⵏ ⵍⵃⴻⵏⵏⵉ, ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵏ ⵄⴰⵢⵏ-ⵊⴰⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("SS1_15","023_1_15","SNG","1","15","15","“ⵅⵣⴰⵔ, ⵜⴻⵛⵏⵉⴷ ⵛⴻⵎ, ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ! ⵅⵣⴰⵔ, ⵛⴻⵎ ⵜⴻⵛⵏⵉⴷ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⴷ ⵉⴷⴱⵉⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS1_16","023_1_16","SNG","1","16","16","“ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⴻⵛⵏⵉⴷ, ⴰ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵡⴰⵀ, ⵜⴹⴰⵔⴼⴻⴷ, ⵜⵓⵣⵣⵉⵣⴻⵡⵜ ⴷ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("SS1_17","023_1_17","SNG","1","17","17","ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⵜⵉⵏⴻⴳⵍⵉⵏ, ⵜⵉⵃⴻⵏⵢⴰ ⵏ ⵜⵣⴻⵇⵇⴰ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵔⵣⵉ.” ");
INSERT INTO rift_vpl VALUES ("SS2_1","023_2_1","SNG","2","1","1","“ⵏⴻⵛⵛ ⴷ ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵏ ⵛⴰⵔⵓⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵡⴹⴰⵏⵜ ⵜⵉⴼⵔⴰⵢ ⵄⴻⵎⵎⴰⵔⵚ, ⴷ ⵜⴰⵍⵉⵍⵍⴻⵛⵜ ⵏ ⵜⴻⵢⵙⴰⵔⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS2_2","023_2_2","SNG","2","2","2","“ⴰⵎ ⵜⵍⵉⵍⵍⴻⵛⵜ ⵊⴰⵔ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ ⵊⴰⵔ ⵜⵢⴻⴵⵉⵜⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS2_3","023_2_3","SNG","2","3","3","“ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵜⴻⴼⴼⴰⵃⵜ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵍⵍⵉⴼ ⵉⵏⵓ ⵊⴰⵔ ⵡⴰⵔⵔⴰⵡⴻⵏ. ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵎⵎⴻⵥⵔⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ. ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴷ ⵎⵉⵥⵉⴷ ⵉ ⵡⴰⵏⴻⵖ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("SS2_4","023_2_4","SNG","2","4","4","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵉⵏⵓ, ⵓ ⵜⴰⵢⵔⵉ ⴷ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵏⵏⴻⵙ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("SS2_5","023_2_5","SNG","2","5","5","ⵙⵊⴻⵀⴷⴻⵎ ⴰⵢⵉ ⵙ ⵜⵖⴰⵔⵢⵉⵟⴰⵜⵉⵏ ⵏ ⵣⵣⴱⵉⴱ, ⵙⴱⴰⵔⵔⴷⴻⵎ ⴰⵢⵉ ⵙ ⵜⵜⴻⴼⴼⴰⵃⵉⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵀⴻⵍⵛⴻⵖ ⵙ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("SS2_6","023_2_6","SNG","2","6","6","ⴰⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⵉⴷⴰⵔⵔⴻⵄ ⴰⵢⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("SS2_7","023_2_7","SNG","2","7","7","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵏⵜ ⵙⵙⵊⴰⴵⴰⵖ, ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵜⵖⴰⵢⴹⵉⵏ ⵏ ⵡⴻⵣⵖⴰⵔ ⵓ ⵖⴰⵔ ⵜⵓⴷⴰⴷⵉⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵡⴰⵔ ⵀⴻⴽⴽⵡⵍⴻⵏⵜ ⵜⴰⵢⵔⵉ, ⵡⴰⵔ ⵜⵜ-ⵉ-ⴷⴷ-ⵙⵙⴻⴽⴽⴰⵔⴰⵏⵜ ⴰⵍ ⵜᵉⵜⵜⴻⵅⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("SS2_8","023_2_8","SNG","2","8","8","“ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⵍⵉⴼ ⵉⵏⵓ! ⴰⵇⴰ ⴷⴰ, ⵉⵜⵜⴰⵙ-ⴷⴷ, ⵉⵏⴻⵟⵟⵓ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵉⵏⴻⴳⴳⴻⵣ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("SS2_9","023_2_9","SNG","2","9","9","ⵍⵍⵉⴼ ⵉⵏⵓ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ, ⵏⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵡⵓⴷⴰⴷⴻⵏ. ⴰⵇⴰ-ⵜ ⴷⴰ, ⵉⴱⴻⴷⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵃⵉⴹ ⵏⵏⴻⵖ, ⵉⵅⴻⵣⵣⴰⵔ ⵣⵉ ⵍⴻⴽⵡⴰⵣⵉ, ⵉⵜⵜⵛⴻⵢⵢⴻⵄ ⵣⵉ ⵛⵛⴻⴱⴱⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("SS2_10","023_2_10","SNG","2","10","10","“ⵍⵍⵉⴼ ⵉⵏⵓ ⵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴽⴽⴰⵔ, ⴱⴻⴷⴷ, ⴰ ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ, ⴰⵥⵔⵉ ⵉⵏⵓ, ⴰⵙ-ⴷⴷ! ");
INSERT INTO rift_vpl VALUES ("SS2_11","023_2_11","SNG","2","11","11","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⴰ, ⵜⴰⴳⴻⵔⵙⵜ ⵜⴻⵄⴷⵓ, ⵉⴽⵙⵉ ⵡⴻⵏⵥⴰⵔ, ⴰⵇⴰ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("SS2_12","023_2_12","SNG","2","12","12","ⴱⴰⵏⴻⵏ-ⴷⴷ ⵉⵏⵓⵡⵡⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⵃⴰⵍ ⵏ ⵡⴻⵏⵣⵉⵣ ⴰⵇⴰ-ⵜ ⴷⴰ, ⵓ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⵊⵍⵉⵍⵍⴻⵃⵜ ⵏⴻⵙⵍⴰ ⵉ-ⵜⵜ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("SS2_13","023_2_13","SNG","2","13","13","ⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵉⵜⵜⵅⴻⵎⵎⴰⵍ ⵍⴱⴰⵛⵓⵔ ⵏⵏⴻⵙ, ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵉⵜⵜⵏⴻⵡⵡⴰⵔⴻⵏ ⴰⵔⵅⵓⵏ ⵉ ⵍⴻⴼⵡⴰⵃ. ⴽⴽⴰⵔ, ⴱⴻⴷⴷ, ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ, ⴰⵥⵔⵉ ⵉⵏⵓ, ⴰⵙ-ⴷⴷ!’” ");
INSERT INTO rift_vpl VALUES ("SS2_14","023_2_14","SNG","2","14","14","“ⵜⴰⴷⴱⵉⵔⵜ ⵉⵏⵓ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⴷⵓⵔⵔⵉ ⴷⵉ ⵍⴻⵊⵔⵓⴼ, ⵜⵏⵓⴼⴼⴰⵔ ⴷⵉ ⵜⵙⴰⵡⴻⵏⵜ ⵏ ⵡⴻⴷⵔⴰⵔ. ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵥⴰⵔⴻⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵎ, ⴰⴷ ⵙⵍⴻⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ, ⵎⴰⵖⴰⵔ ⴷ ⵜⵎⵉⵥⵉⴷⵜ ⵉ ⵜⴻⴵⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ, ⵉⵚⴱⴻⵃ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("SS2_15","023_2_15","SNG","2","15","15","“ⵟⵟⴼⴻⵎ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵛⴻⵄⴱⴰⵡⴻⵏ, ⵉⵛⴻⵄⴱⴰⵡⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵢⵜⴰⵔⴻⵏ ⴰⵏⴻⵖ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ, ⵎⴰⵖⴰⵔ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵖ ⵜⵜⵏⴻⵡⵡⴰⵔⴻⵏⵜ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("SS2_16","023_2_16","SNG","2","16","16","ⵍⵍⵉⴼ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⵏⵏⴻⵙ, ⵏⴻⵛⵛ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴽⴽⵡⵙⴻⵏ ⵊⴰⵔ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ ");
INSERT INTO rift_vpl VALUES ("SS2_17","023_2_17","SNG","2","17","17","ⴰⵍ ⵉ ⵖⴰ ⵉⵙⵎⴻⴹ ⵡⴰⵙⵙ ⵓ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏⵜ ⵜⵉⵍⵉⵡⵉⵏ. ⵏⵏⴻⴹ-ⴷⴷ, ⴰ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏⵉⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵡⵓⴷⴰⴷⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉ ⵉⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵙ ⵜⴻⵢⵙⴰⵔⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS3_1","023_3_1","SNG","3","1","1","“ⴰⵔⵣⵓⵖ ⵅⴰⵙ ⴷⵉ ⴵⵢⴰⵍⵉ ⴰⵎ ⴵⵉⵖ ⵅ ⵜⴰⵙⵙⵓⵜ ⵉⵏⵓ, ⴰⵔⵣⵓⵖ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⵔⵣⵓⵖ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵓⴼⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("SS3_2","023_3_2","SNG","3","2","2","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴰⴷ ⴽⴽⴰⵔⴻⵖ, ⴰⴷ ⵙⵓⵃⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵓ ⵅ ⵡⴰⵣⵣⴰⵢⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴰⵔⵣⵓⵖ, ⴰⴷ ⴰⵔⵣⵓⵖ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ.’ ⵏⴻⵛⵛ ⴰⵔⵣⵓⵖ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵓⴼⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("SS3_3","023_3_3","SNG","3","3","3","ⵓⴼⵉⵏ ⴰⵢⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴰⵎ ⵜⵜⴻⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵎⴰ ⵜⴻⵥⵔⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ?’ ");
INSERT INTO rift_vpl VALUES ("SS3_4","023_3_4","SNG","3","4","4","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵄⴷⵓⵖ, ⵓⴼⵉⵖ ⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵟⵟⴼⴻⵖ ⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⵅⵅⵓⵖ ⴰⵍⴰⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵡⵢⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴻⵎⵎⴰ, ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ ⴰⵢⵉ ⵢⵓⵔⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS3_5","023_3_5","SNG","3","5","5","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵏⵜ ⵙⵙⵊⴰⴵⴰⵖ, ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵜⵖⴰⵢⴹⵉⵏ ⵏ ⵡⴻⵣⵖⴰⵔ ⵓ ⵖⴰⵔ ⵜⵓⴷⴰⴷⵉⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵡⴰⵔ ⵀⴻⴽⴽⵡⵍⴻⵏⵜ ⵜⴰⵢⵔⵉ, ⵡⴰⵔ ⵜⵜ-ⵉ-ⴷⴷ-ⵙⵙⴻⴽⴽⴰⵔⴰⵏⵜ ⴰⵍ ⵜᵉⵜⵜⴻⵅⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("SS3_6","023_3_6","SNG","3","6","6","“ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ, ⴰⵎ ⵉⵇⴻⵍⵍⵉⵊⴻⵏ ⵏ ⴷⴷⴻⵅⵅⴰⵏ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵏ ⵎⵉⵔⵔⵓ ⴷ ⵊⵊⴰⵡⵉ, ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴱⵣⴰⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵏ ⵓⵙⴻⴱⴱⴰⴱ? ");
INSERT INTO rift_vpl VALUES ("SS3_7","023_3_7","SNG","3","7","7","ⵅⵣⴰⵔ, ⵍⴻⵛⵜⵓ ⵏ ⵜⵔⴻⴱⴱⵓⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵜⵜⴻⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("SS3_8","023_3_8","SNG","3","8","8","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⵙⵙⵉⴼ, ⵉⵏⵏⵉ ⵉⵍⴻⵎⵎⴷⴻⵏ ⴰⵎⴻⵏⵖⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("SS3_9","023_3_9","SNG","3","9","9","ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵍⴻⵛⵜⵓ ⵉ ⵜⵔⴻⴱⴱⵓⵜ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS3_10","023_3_10","SNG","3","10","10","ⵉⵄⵓⵎⴰⴷ ⵖⴰⵔ ⵜⴻⵖⵎⴰⵔⵜ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⵄⴻⵎⵎⴻⴷ ⵏ ⵡⴻⵄⵔⵓⵔ ⵏ ⵡⵓⵔⴻⵖ ⵓⵛⴰ ⴰⵖⵉⵎⵉ ⵏⵏⴻⵙ ⵏ ⴰⵔⵊⵓⵡⴰⵏⵉ. ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ ⵢⴰⵔⴹⴻⵏ ⵜ ⵙ ⵜⴰⵢⵔⵉ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("SS3_11","023_3_11","SNG","3","11","11","“ⴼⴼⵖⴻⵏⵜ ⵓ ⵅⵣⴰⵔⴻⵏⵜ, ⴽⴻⵏⵏⵉⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴰⵇⴰ ⴷⴰ ⴰⵊⴻⴵⵉⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴽ-ⴷ ⵜⵜⴰⵊ ⵉ ⵣⵉ ⵜ ⵜⴳⴻⵍⵍⴻⴷ ⵢⴻⵎⵎⴰⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⵓⵔⴰⵔ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵢⵓⵥⵖⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("SS4_1","023_4_1","SNG","4","1","1","“ⵅⵣⴰⵔ, ⵜⴻⵛⵏⵉⴷ ⵛⴻⵎ, ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ, ⵛⴻⵎ ⵜⴻⵛⵏⵉⴷ. ⴰⵡⴰⵔⵏⵉ ⵍⵍⵜⴰⵎ ⵏⵏⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⴷ ⵜⵉⴷⴱⵉⵔⵉⵏ. ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵎ ⴰⵎ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("SS4_2","023_4_2","SNG","4","2","2","ⵜⵉⵖⵎⴰⵙ ⵏⵏⴻⵎ ⴳⴳⵉⵏⵜ ⴰⵎ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⵍⵙⵉⵏ ⵜⴻⵏⵜ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵏ, ⵎⴰⵔⵔⴰ ⵜⵉⵅⴻⵙⵡⵉⵏ ⵓⵔⵡⴻⵏⵜ ⵜⴰⵛⵏⵉⵡⵉⵏ, ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵉⵛⵜ ⵏⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS4_3","023_4_3","SNG","4","3","3","ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵎ ⴰⵎ ⵓⴼⵉⵍⵓ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵉⵚⴱⴻⵃ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵎ. ⵍⵃⴻⵏⴽⴰⵜ ⵏⵏⴻⵎ ⴰⵎ ⵜⵔⴻⵎⵎⴰⵏⵜ ⵉⴱⴹⴰⵏ ⵙⴰⴷⵓ ⵍⵍⵜⴰⵎ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("SS4_4","023_4_4","SNG","4","4","4","ⵉⵔⵉ ⵏⵏⴻⵎ ⴰⵎ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴱⵏⴰⵏ ⵜⵜ ⴰⵎ ⵜⴻⵙⴼⵉⴼⵉⵏ ⵏ ⵜⵙⴻⴷⴷⵢⵉⵏ. ⴰⵍⴻⴼ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵓⵢⵍⴻⵏⵜ ⵖⴰⵔⴻⵙ, ⵎⴰⵔⵔⴰ ⴰⵎ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵉⵇⵓⵔⴰⵔⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("SS4_5","023_4_5","SNG","4","5","5","ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ ⴳⴳⵉⵏ ⴰⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴰⵎ ⵡⴰⵛⵏⵉⵡⴻⵏ ⵏ ⵜⵖⴰⵢⴹⴻⵜ ⵏ ⵡⴻⵣⵖⴰⵔ, ⵜⵜⵀⴻⴷⴷⴰⵏ ⴷⵉ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("SS4_6","023_4_6","SNG","4","6","6","ⴰⵍ ⵉ ⵖⴰ ⵉⵙⵎⴻⴹ ⵡⴰⵙⵙ ⵓ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏⵜ ⵜⵉⵍⵉⵡⵉⵏ, ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵓⵎⵉⵔⵔⵓ, ⵖⴰⵔ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵊⵊⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("SS4_7","023_4_7","SNG","4","7","7","ⵛⴻⵎ ⵎⴰⵔⵔⴰ ⴷ ⴰⵥⵔⵉ, ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ, ⵡⴰⵔ ⴷⴰⵢⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("SS4_8","023_4_8","SNG","4","8","8","ⴰⵙ-ⴷⴷ ⴰⴽⵉⴷⵉ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⴰ ⵜⴰⵙⵍⵉⵜ ⵉⵏⵓ, ⴰⵙ-ⴷⴷ ⴰⴽⵉⴷⵉ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵚⵡⴻⴷ-ⴷⴷ ⵣⵉ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⴰⵎⴰⵏⴰ, ⵣⵉ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵛⴰⵏⵉⵔ ⴷ ⵀⵉⵔⵎⵓⵏ, ⵣⵉ ⵖⴰⵔ ⵍⵎⴰⵔⴰⴳⴻⵃ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ, ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵖⵉⵍⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS4_9","023_4_9","SNG","4","9","9","ⵜⵓⵛⴰⵔⴻⴷ ⴰⵢⵉ ⵓⵍ, ⴰ ⵓⵍⵜⵎⴰ, ⴰ ⵜⴰⵙⵍⵉⵜ ⵉⵏⵓ, ⵡⴰⵀ ⵜⵓⵛⴰⵔⴻⴷ ⴰⵢⵉ ⵓⵍ, ⵙ ⵉⵛⵜ ⵏ ⵍⵅⴻⵣⵔⴰⵜ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ, ⵙ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵏ ⵢⵉⵔⵉ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("SS4_10","023_4_10","SNG","4","10","10","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵛⵏⴰ ⵓⵙⵃⵉⵏⵏⴻⴱ ⵏⵏⴻⵎ, ⴰ ⵓⵍⵜⵎⴰ, ⴰ ⵜⴰⵙⵍⵉⵜ ⵉⵏⵓ, ⵎⴻⵛⵃⴰⵍ ⵜⴻⵚⴱⴻⵃ ⵓⵙⵃⵉⵏⵏⴻⴱ ⵏⵏⴻⵎ ⵅ ⴱⵉⵏⵓ, ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵣⵣⴻⵛⵜ ⵏⵏⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵟⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("SS4_11","023_4_11","SNG","4","11","11","ⵣⴻⴳ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵎ, ⴰ ⵜⴰⵙⵍⵉⵜ ⵉⵏⵓ, ⵜᵉⵜⵜⵓⴷⵓⵎ ⵜⴰⵎⵎⴻⵏⵜ ⵏ ⵜⴻⵖⵔⴰⵚⵜ, ⵜⴰⵎⵎⴻⵏⵜ ⴷ ⵓⵖⵉ ⵙⴰⴷⵓ ⵉⵍⴻⵙ ⵏⵏⴻⵎ, ⵓ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ ⴰⵎ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS4_12","023_4_12","SNG","4","12","12","ⴰ ⵓⵍⵜⵎⴰ, ⴰ ⵜⴰⵙⵍⵉⵜ ⵉⵏⵓ, ⵛⴻⵎ ⴷ ⵜⴰⵃⵡⵉⵛⵜ ⵉⴱⴻⵍⵍⵄⴻⵏ, ⴷ ⵜⴰⵍⴰ ⵉⵇⵇⵏⴻⵏ, ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵉⵛⴻⵎⵎⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS4_13","023_4_13","SNG","4","13","13","ⵍⴻⴼⵔⵓⵄ ⵉ ⵣⵣⴰⵢⴻⵎ ⵉⵙⵙⵏⴻⵟⵟⵉⵢⴻⵏ ⴷ ⵊⴻⵏⵏⴻⵜ ⵏ ⵜⵔⴻⵎⵎⴰⵏⵉⵏ, ⵙ ⵍⵖⵉⴵⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵟⵟⴰⵙ, ⵏⵏⴻⵡⵡⴰⵛ ⵏ ⵍⵃⴻⵏⵏⵉ ⴷ ⵚⵚⴻⵏⴱⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("SS4_14","023_4_14","SNG","4","14","14","ⵚⵚⴻⵏⴱⴻⵍ ⴷ ⵣⵣⵄⴻⴼⵔⴰⵏ, ⵙ ⵓⵖⴰⵏⵉⵎ ⵓⵃⴻⵎⵎⵓⵎ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴰⴽ-ⴷ ⵍⵇⴰⵔⴼⴰ, ⵄⵍⴰⵎ ⴽⵓⵍ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵊⵊⴰⵡⵉ, ⵎⵉⵔⵔⵓ ⴷ ⵡⴻⵛⴼⵉⵍ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵟⵓⵔ ⵉⵚⴻⴱⵃⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("SS4_15","023_4_15","SNG","4","15","15","ⴰ ⵜⴰⵍⴰ ⵏ ⵉⵃⵡⵉⵛⴻⵏ, ⴰⵏⵓ ⵏ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS4_16","023_4_16","SNG","4","16","16","“ⴽⴽⴰⵔ, ⴰ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵏⵏⴻⵊ, ⴰⵙ-ⴷⴷ, ⴰ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵙⵡⴰⴷⴷⴰⵢ, ⵙⵓⴹ ⵅ ⵡⴻⵃⵡⵉⵛ ⵉⵏⵓ, ⴻⵊⵊ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵍⴻⵄⵟⵓⵔ ⵏⵏⴻⵙ ⴰⴷ ⵜⵓⵢⵓⵔ. ⴻⵊⵊ ⵍⵍⵉⴼ ⵉⵏⵓ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵛⵛ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵉⵚⴻⴱⵃⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("SS5_1","023_5_1","SNG","5","1","1","“ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵉⵏⵓ, ⴰ ⵓⵍⵜⵎⴰ, ⴰ ⵜⴰⵙⵍⵉⵜ ⵉⵏⵓ, ⵍⴻⵇⴹⴻⵖ ⵎⵉⵔⵔⵓ ⵉⵏⵓ ⴰⴽ-ⴷ ⴱⴰⵍⵙⴰⵎ. ⵉⵏⵓ, ⵛⵛⵉⵖ ⴰⵖⵔⵓⵎ ⵏ ⵜⵣⵉⵣⵡⴰ ⴰⴽ-ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵉⵏⵓ, ⵙⵡⵉⵖ ⴱⵉⵏⵓ ⵉⵏⵓ ⴷ ⵓⵖⵉ ⵉⵏⵓ. ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ, ⴻⵛⵛⴻⵎ, ⵙⵡⴻⵎ, ⵙⵛⴰⵔⴻⵎ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("SS5_2","023_5_2","SNG","5","2","2","“ⵏⴻⵛⵛ ⵟⵟⵙⴻⵖ, ⵎⴰⵛⴰ ⵓⵍ ⵉⵏⵓ ⵉⴼⴰⵇ. ⴰⵇⴰ ⴷⴰ ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵇⴰⵔⵇⴱⴻⵏ: ‘ⴰⵔⵣⴻⵎ ⴰⵢⵉ, ⴰ ⵓⵍⵜⵎⴰ, ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ, ⵜⴰⴷⴱⵉⵔⵜ ⵉⵏⵓ, ⴰ ⴽⵓⵍⵛⵉ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵉⵛⵛⵓⵔ ⵙ ⵏⵏⴷⴰ, ⵉⵎⵓⵣⴰⵔⴻⵏ ⵉⵏⵓ ⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵓⴷⴷⵉⵎⵉⵏ ⵏ ⴵⵉⵍⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("SS5_3","023_5_3","SNG","5","3","3","ⴰⵇⴰ ⴽⴽⵙⴻⵖ ⴰⵔⵔⵓⴹ ⵉⵏⵓ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵜ ⵖⴰ ⵢⴰⵔⴹⴻⵖ ⵄⴰⵡⴻⴷ? ⵉⴹⴰⵔⴻⵏ ⵙⵙⵉⵔⴷⴻⵖ ⵜⴻⵏ, ⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵅⴻⵎⵊⴻⵖ ⵄⴰⵡⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("SS5_4","023_5_4","SNG","5","4","4","ⵍⵍⵉⴼ ⵉⵏⵓ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵏⵓⵇⵇⵉⴱ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵓⵛⴰ ⵉⵏⵀⴻⵣⵣ ⵡⵓⵍ ⵉⵏⵓ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("SS5_5","023_5_5","SNG","5","5","5","ⵏⴻⵛⵛ ⴱⴻⴷⴷⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⵉ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵓⴷⵓⵎⴻⵏ ⵙ ⵎⵉⵔⵔⵓ, ⵣⴻⴳ ⵉⴹⴻⵡⴹⴰⵏ ⵉⵏⵓ ⵉⵙⵙⵉⵣⵣⴻⵍ ⵎⵉⵔⵔⵓ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵣⵣⴻⴽⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("SS5_6","023_5_6","SNG","5","6","6","ⵏⴻⵛⵛ ⴰⵔⵣⵎⴻⵖ ⵉ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵍⵍⵉⴼ ⵉⵏⵓ ⵜⵓⵖⴰ ⵢⵓⵢⵓⵔ, ⵉⵄⴷⵓ. ⵉⴼⴼⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ! ⵏⴻⵛⵛ ⴰⵔⵣⵓⵖ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵓⴼⵉⵖ. ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⴰⵙ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵢⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("SS5_7","023_5_7","SNG","5","7","7","ⵓⴼⵉⵏ ⴰⵢⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵏⴻⴹ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⴰⵢⵉ, ⵢⴻⵣⵎⴻⵏ ⴰⵢⵉ, ⴰⵇⴻⵏⴷⵓⵔ ⵉⵏⵓ ⴽⴽⵙⴻⵏ ⴰⵢⵉ ⵜ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ.” ");
INSERT INTO rift_vpl VALUES ("SS5_8","023_5_8","SNG","5","8","8","“ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵏⵜ ⵙⵙⵊⴰⴵⴰⵖ, ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵜⵓⴼⵉⵏⵜ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵜⵉⵏⵉⵏⵜ? ⴰⵇⴰ ⵜⴻⵙⵙⴻⵃⵍⴻⵛ ⴰⵢⵉ ⵜⴰⵢⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("SS5_9","023_5_9","SNG","5","9","9","“ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵍⵍⵉⴼ ⵏⵏⴻⵎ ⴽⵜⴰⵔ ⵅ ⵍⵍⵉⴼ ⵏⵏⴻⵖⵏⵉ, ⴰ ⵛⴻⵎ ⵉ ⴷⵉ ⵉⴵⴰ ⵡⴰⵥⵔⵉ ⵇⴰⵄ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ? ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵍⵍⵉⴼ ⵏⵏⴻⵎ ⴽⵜⴰⵔ ⵅ ⵉⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵛⴻⵎ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵏⴻⵖ ⵜᵉⵙⵙⵊⴰⴵⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("SS5_10","023_5_10","SNG","5","10","10","“ⵍⵍⵉⴼ ⵉⵏⵓ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ ⴰⵎ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⵜⵜⴱⴰⵏ ⴰⵎ ⵓⴱⴰⵏⴷⵓ ⵙⴻⵏⵏⴻⵊ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("SS5_11","023_5_11","SNG","5","11","11","ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵓⵔⴻⵖ ⵉⵇⵇⵓⵔ ⵉⵚⴼⴰⵏ, ⵉⵎⵓⵣⴰⵔⴻⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⴷ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵎ ⵍⴻⵎⵡⴰⵊ, ⴷ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵖⵍⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS5_12","023_5_12","SNG","5","12","12","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏⵜ ⴰⵎ ⵜⴻⴷⴱⵉⵔⵉⵏ ⵖⴰⵔ ⵜⵙⴻⴵⵢⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵄⵓⵎⵎⴻⵏⵜ ⴷⴻⴳ ⵓⵖⵉ, ⵇⵇⵉⵎⴻⵏⵜ ⴷⵉ ⵜⵛⵓⵢⴰⵔ ⵏⵙⴻⵏ ⴰⵎ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS5_13","023_5_13","SNG","5","13","13","ⵉⵎⴻⴳⴳⵉⵣⴻⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⴰⵎ ⵢⵉⵃⵡⵉⵛⴻⵏ ⵏ ⵍⴻⵄⵟⵓⵔ, ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⵄⵛⵓⴱ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ, ⵜⵜⵓⴷⵓⵎⴻⵏ ⵙ ⵎⵉⵔⵔⵓ ⵉⴼⴻⵙⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS5_14","023_5_14","SNG","5","14","14","ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵇⴻⴹⴱⴰⵏ ⵏ ⵡⵓⵔⴻⵖ, ⵄⴻⵎⵎⴰⵔⴻⵏⵜ ⵙ ⵉⵥⵔⴰ ⵏ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ, ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵍⵄⴰⵊ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⵍⴻⵃⵃⴼⴻⵏ ⵜ ⵙ ⵜⵢⴰⵇⵓⵜⵉⵏ ⵏ ⵚⴰⴼⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("SS5_15","023_5_15","SNG","5","15","15","ⵉⵎⴻⵙⴹⴰⵏ ⵏⵏⴻⵙ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵍⵎⴰⵔⵎⵓⵔ, ⵅ ⴷⵙⵓⵙⴰ ⵏ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ. ⵉⴱⴰⵏ-ⴷⴷ ⵏⴻⵜⵜⴰ ⴰⵎ ⵍⵓⴱⵏⴰⵏ, ⵉⵜⵜⵡⴰⴼⴰⵔⵣ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("SS5_16","023_5_16","SNG","5","16","16","ⴰⵏⴻⵖ ⵏⵏⴻⵙ ⵉⵛⵛⵓⵔ ⵙ ⵜⴰⵥⵢⵓⴷⵉ, ⵎⴰⵔⵔⴰ ⵉ ⵖⴰⵔⴻⵙ ⵉⵛⵓⵡⵡⴰⵔ. ⵡⴰ ⴷ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵡⴰ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ, ⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ!” ");
INSERT INTO rift_vpl VALUES ("SS6_1","023_6_1","SNG","6","1","1","“ⵎⴰⵏⵉ ⵢⵓⵢⵓⵔ ⵍⵍⵉⴼ ⵏⵏⴻⵎ, ⴰ ⵛⴻⵎ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ? ⵎⴰⵏⵉ ⵢⴰⵔⵔⴰ ⵙ ⵓⵣⴻⴵⵉⴼ ⵍⵍⵉⴼ ⵏⵏⴻⵎ? ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵅⴰⵙ ⵏⴰⵔⵣⵓ ⴰⴽⵉⴷⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("SS6_2","023_6_2","SNG","6","2","2","“ⵍⵍⵉⴼ ⵉⵏⵓ ⵉⵀⵡⴰ ⵖⴰⵔ ⵓⵃⵡⵉⵛ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵜⴱⵓⴷⴰ ⵙ ⵍⴻⵄⵟⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵉⵃⵡⵉⵛⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵜⵉⵍⵉⵍⵍⵉⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("SS6_3","023_6_3","SNG","6","3","3","ⵏⴻⵛⵛ ⵣⴻⴳ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵓ ⵍⵍⵉⴼ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵉⵏⵓ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴽⴽⵡⵙⴻⵏ ⵊⴰⵔ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS6_4","023_6_4","SNG","6","4","4","“ⵛⴻⵎ ⵜⵚⴻⴱⵃⴻⴷ, ⴰ ⵜⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜ ⵉⵏⵓ, ⴰⵎⴻⵛⵏⴰⵡ ⵜⵉⵔⵚⴰ, ⵜⴻⵛⵏⵉⴷ ⴰⵎ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴻⵙⵙⴰⴳⴳⵯⴰⴷⴻⴷ ⴰⵎ ⵢⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵙ ⵉⴱⴰⵏⴷⵓⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS6_5","023_6_5","SNG","6","5","5","ⴽⴽⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵣⵣⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵖⴻⴹⵍⴻⵏⵜ ⴰⵢⵉ ⵉⴼⴰⴷⴷⴻⵏ ⴰⵟⵟⴰⵙ. ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵎ ⴰⵎ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵯⴰⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵊⵉⵍⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("SS6_6","023_6_6","SNG","6","6","6","ⵜⵉⵖⵎⴰⵙ ⵏⵏⴻⵎ ⴳⴳⵉⵏⵜ ⴰⵎ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵡⵓⴵⵉ, ⵉ ⴷⴷ-ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵅⴻⵙⵡⵉⵏ ⵓⵔⵡⴻⵏⵜ ⵜⴰⵛⵏⵉⵡⵜ, ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵉⵛⵜ ⵏⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("SS6_7","023_6_7","SNG","6","7","7","ⵍⵃⴻⵏⴽⴰⵜ ⵏⵏⴻⵎ ⴰⵎ ⵜⵔⴻⵎⵎⴰⵏⵜ ⵉⴱⴹⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵍⵜⴰⵎ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("SS6_8","023_6_8","SNG","6","8","8","ⴰⵇⴰ ⴷⵉⵏ ⵙⴻⵜⵜⵉⵏ ⵏ ⵜⵊⴻⴵⵉⴷⵉⵏ ⴷ ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵜⵉⵢⵢⴰ, ⵓⵍⴰ ⴷ ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("SS6_9","023_6_9","SNG","6","9","9","ⵡⴻⵃⵃⴷⴻⵙ ⵏⴻⵜⵜⴰⵜ, ⵜⴰⴷⴱⵉⵔⵜ ⵉⵏⵓ, ⵜⴻⵏⵏⵉ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵉⵏⵓ, ⴰⵢⴻⵏⵏⵉ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴻⵏⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⵖⴰⵔ ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ. ⵎⴰⵍⴰ ⵣⵍⵉⵏⵜ ⵜⵜ ⵜⵢⴻⵙⵙⵉⵜ, ⴰⴷ ⵜⵜ ⵙⵙⵄⵓⴵⴰⵏⵜ, ⵜⵉⵊⴻⴵⵉⴷⵉⵏ ⴷ ⵜⵉⵢⵢⴰ ⴰⴷ ⵜⵜ ⵙⵙⴻⵎⵖⴰⵔⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("SS6_10","023_6_10","SNG","6","10","10","“ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵉⵊⵊⴻⵏ ⴰⵎ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ, ⵜⴻⵛⵏⴰ ⴰⵎ ⵜⵣⵉⵔⵉ ⵉⵇⴻⴼⵍⴻⵏ, ⵜⴻⵚⴼⴰ ⴰⵎ ⵜⴼⵓⵛⵜ ⵢⴰⵔⴻⵇⵇⴻⵏ, ⵜⴻⵙⵙⴰⴳⴳⵯⴰⴷ ⴰⵎ ⵢⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵙ ⵉⴱⴰⵏⴷⵓⵜⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("SS6_11","023_6_11","SNG","6","11","11","“ⵏⴻⵛⵛ ⵃⵡⵉⵖ ⵖⴰⵔ ⵜⴻⵃⵡⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵖⵢⴰⵛⵜ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⴰⵖⴻⵎⵎⵓⵢ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⴰ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ, ⵎⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⴰⵔⴻⵎⵎⴰⵏ ⵜⵜⵏⴻⵡⵡⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("SS6_12","023_6_12","SNG","6","12","12","ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⴷ-ⴰⵔⵔⵉⵖ ⵜⴰⵢⵏⵉⵜ ⴰⵇⴰ ⴳⴳⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷⴻⴳ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⴳⴻⵍⵍⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS7_1","023_7_1","SNG","7","1","1","“ⵄⵇⴻⴱ-ⴷⴷ, ⵄⵇⴻⴱ-ⴷⴷ, ⴰ ⵛⵓⵍⴰⵎⵉⵜ! ⵄⵇⴻⴱ-ⴷⴷ, ⵄⵇⴻⴱ-ⴷⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵎ ⵏⴻⵅⵣⴰⵔ.” “ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⴷⵉ ⵛⵓⵍⴰⵎⵉⵜ?” “ⵏⴻⵜⵜⴰⵜ ⴰⵎ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("SS7_2","023_7_2","SNG","7","2","2","“ⵎⴻⵛⵃⴰⵍ ⵛⵏⴰⵏ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵎ ⴷⵉ ⵚⴰⵏⴷⴰⵍⵉⵢⵢⴰⵜ ⵏⵏⴻⵎ, ⴰ, ⵛⴻⵎ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵛⴻⵏⵏⴻⵄ! ⴰⵃⵏⵓⵏⵏⵉ ⵏ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵎ ⴰⵎ ⵜⵙⴻⴷⴷⵢⵉⵏ ⵉⵖⵍⴰⵏ ⵜⵜⵔⴰⵃⴻⵏⵜ ⵜⵜⴰⵙⴻⵏⵜ-ⴷⴷ, ⵚⵚⴻⵏⵄⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS7_3","023_7_3","SNG","7","3","3","ⵜⴰⵄⴻⴱⴱⵓⴹⵜ ⵏⵏⴻⵎ ⴰⵎ ⵜⵙⴰⵔⵉⵊⵜ ⵜⴻⵃⵏⵓⵏⵏⵉ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴱⵉⵏⵓ ⵉⵅⴻⴵⴹⴻⵏ. ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵎ ⴷ ⴰⴽⴻⵎⵎⵉⵛ ⵏ ⵉⵔⴷⴻⵏ, ⵏⵏⴹⴻⵏⵜ ⴰⵙ-ⴷⴷ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("SS7_4","023_7_4","SNG","7","4","4","ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ ⴳⴳⵉⵏ ⴰⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴰⵎ ⵡⴰⵛⵏⵉⵡⴻⵏ ⵏ ⵜⵖⴰⵢⴹⴻⵜ ⵏ ⵡⴻⵣⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("SS7_5","023_7_5","SNG","7","5","5","ⵉⵔⵉ ⵏⵏⴻⵎ ⵉⴳⴳⴰ ⴰⵎ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⵍⵄⴰⵊ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⴰⵎ ⵢⵉⵢⴻⵍⵎⴰⵎⴻⵏ ⵏ ⵃⴰⵛⴱⵓⵏ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⴰⵜ-ⵔⴰⴱⴱⵉⵎ, ⵜⵉⵏⵣⴰⵔⵜ ⵏⵏⴻⵎ ⴰⵎ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⵍⵓⴱⵏⴰⵏ ⵉ ⵉⵙⵙⴰⵊⵊⴰⵏ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("SS7_6","023_7_6","SNG","7","6","6","ⵜⵉⵡⴰ ⵏⵏⴻⵎ ⵉⴳⴳⴰ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵎ ⴰⵎ ⴽⴰⵔⵎⵉⵍ, ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵎ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉ, ⴰⵊⴻⴵⵉⴷ ⵉⵜⵜⵡⴰⵃⴱⴻⵙ ⴷⴻⴳ ⵉⵎⵓⵣⴰⵔⴻⵏ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("SS7_7","023_7_7","SNG","7","7","7","“ⵎⴻⵛⵃⴰⵍ ⵜⴻⵛⵏⵉⴷ ⵛⴻⵎ, ⵓ ⵎⴻⵛⵃⴰⵍ ⵜⵚⴻⴱⵃⴻⴷ, ⴰ ⵜⴰⵢⵔⵉ, ⴷⵉ ⴽⵓⵍⵛⵉ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⴰⵔⵔ ⵎⴻⵥⵔⵉ!” ");
INSERT INTO rift_vpl VALUES ("SS7_8","023_7_8","SNG","7","8","8","“ⵜⵉⴷⴷⵉ ⵏⵏⴻⵎ ⵜⴰⵔⵡⴻⵙ ⴷⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ, ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ ⴷⴻⴳ ⵉⵣⴻⴽⴽⵓⵏⴻⵏ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("SS7_9","023_7_9","SNG","7","9","9","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴰⴷ ⵏⵢⴻⵖ ⵅ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ, ⴰⴷ ⵟⵟⴼⴻⵖ ⴷⵉ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ.’ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵉⵣⴻⵏⴽⴰⴽ ⵏ ⵓⴹⵉⵍ ⵖⴰⵔ ⵜⵣⴰⵢⴰⵔⵜ, ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵎ ⴰⵎ ⵜⵜⴻⴼⴼⴰⵃⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("SS7_10","023_7_10","SNG","7","10","10","ⴰⵏⴻⵖ ⵏⵏⴻⵎ ⴰⵎ ⴱⵉⵏⵓ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵟⵟⴰⵙ ...”, “... ⵡⴻⵏⵏⵉ ⵉⵜⵜⵔⴰⵃⴻⵏ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵟⵟⵚⴻⵏ ⴰⴷ ⵏⵀⴻⵣⵣⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS7_11","023_7_11","SNG","7","11","11","“ⵏⴻⵛⵛ ⵏ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵖⴰⵔⵉ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("SS7_12","023_7_12","SNG","7","12","12","ⴰⵙ-ⴷⴷ, ⵍⵍⵉⴼ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ, ⴰⴷ ⵏⴻⵙⵙⴻⵏⵙ ⴷⵉ ⵍⴻⴷⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("SS7_13","023_7_13","SNG","7","13","13","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴽⴽⴰⵔ ⵣⵉⵛ ⵃⵉⵎⴰ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵥⴰⵔ, ⵎⴰ ⵜⴰⵣⴰⵢⴰⵔⵜ ⴰⵇⴰ ⵜⴻⵙⵙⵓⴼⴼⵓⵖ, ⵎⴰ ⵏⵏⵓⵡⵡⴰⵔ ⵏⵏⴻⵙ ⵏⵏⵓⵔⵣⵎⴻⵏ, ⵎⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⴰⵔⴻⵎⵎⴰⵏ ⵏⴻⵡⵡⴰⵔⴻⵏⵜ. ⴷⵉⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ ⴰⵙⵃⵉⵏⵏⴻⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("SS7_14","023_7_14","SNG","7","14","14","ⵜⵜⵉⴼⴼⴰⵃⵉⵏ ⵏ ⵜⴰⵢⵔⵉ ⴰⵔⵅⵓⵏⵜ ⵉ ⵍⴻⴼⵡⴰⵃ ⵓ ⵜⵉⵡⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵖ ⴰⵇⴰ ⴷⵉⵏ ⴼⵔⵓⵜⴰⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵜⵉⵏⵏⵉ ⵏ ⵟⵟⵔⵉ ⴷ ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵎⵎⵍⴻⵏ. ⴰ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵅⴻⵎⵎⵍⴻⵖ ⵜⴻⵏⵜ ⵉ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("SS8_1","023_8_1","SNG","8","1","1","“ⴰⵅ, ⵎⴻⵄⵍⵉⴽ ⵇⴰⵄ ⵛⴻⴽ ⴷ ⵓⵎⴰ, ⵜᵉⵟⵟⴻⴹⴻⴷ ⴷⵉ ⵜⴱⵉⴱⴱⵉⵛⵉⵏ ⵏ ⵢⴻⵎⵎⴰ. ⵎⴰⵍⴰ ⵓⴼⵉⵖ ⵛⴻⴽ ⴷⵉ ⴱⴰⵔⵔⴰ, ⴰⴷ ⵛⴻⴽ ⵙⵙⵓⴷⵎⴻⵖ, ⴱⵍⴰ ⵎⴰ ⴷ ⴰⵢⵉ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS8_2","023_8_2","SNG","8","2","2","ⵉⵍⵉ ⴰⴷ ⵛⴻⴽ ⵏⴻⴷⵀⴻⵖ, ⴰⴷ ⵛⴻⴽ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴻⵎⵎⴰ, ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ ⴷⵉⵏ. ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴱⵉⵏⵓ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵙ ⵍⴻⵄⵜⵓⵍ ⴰⴷ ⵜⴻⵙⵡⴻⴷ, ⴰⵥⴻⵎⵎⵉ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉⵏⵓ ⵏ ⵡⴰⵔⴻⵎⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("SS8_3","023_8_3","SNG","8","3","3","ⴰⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⵉⴷⴰⵔⵔⴻⵄ ⴰⵢⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("SS8_4","023_8_4","SNG","8","4","4","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵏⵜ ⵙⵙⵊⴰⴵⴰⵖ, ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ: ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵀⴻⵡⵍⴻⵏⵜ ⵜⴰⵢⵔⵉ ⵏⵉⵖ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴰⵔⴻⵏⵜ, ⵇⴱⴻⵍ ⵎⴰ ⵜᵉⵜⵜⴻⵅⵙ ⵏⴻⵜⵜⴰⵜ?” ");
INSERT INTO rift_vpl VALUES ("SS8_5","023_8_5","SNG","8","5","5","“ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵏⵏⵉ ⴷⵉⵏ ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ, ⵜᵉⵜⵜⵄⴻⵎⵎⴻⴷ ⵅ ⵍⵍⵉⴼ ⵏⵏⴻⵙ?” “ⵙⴰⴷⵓ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵜⴻⴼⴼⴰⵃⵜ ⴰⵔⵔⴻⵖ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵎ, ⵎⴰⵏⵉ ⵛⴻⵎ ⴷⴷ-ⵜⴻⵊⵊⴰ ⵢⴻⵎⵎⴰⵎ ⵙ ⵍⴻⵃⵔⵉⵇ ⵏ ⵜⴰⵔⵡⴰ, ⵎⴰⵏⵉ ⵛⴻⵎ ⴷⴷ-ⵜⴻⵊⵊⴰ ⵜⴻⵏⵏⵉ ⵛⴻⵎ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("SS8_6","023_8_6","SNG","8","6","6","“ⵙⴰⵔⵙ ⴰⵢⵉ ⴰⵎ ⵟⵟⴰⴱⴻⵄ ⵅ ⵡⵓⵍ ⵏⵏⴻⵛ, ⴰⵎ ⵟⵟⴰⴱⴻⵄ ⵅ ⵓⵖⵉⵍ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵜⴰⵢⵔⵉ ⵜⴻⵊⵀⴻⴷ ⴰⵎ ⵍⵎⴻⵡⵜ, ⵜⵓⵙⵎⵉ ⵜⴻⵇⵙⴻⵃ ⴰⵎ ⵍⴰⵅⴰⵔⵜ, ⵜⵉⴼⴻⵟⵟⵓⵜⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵉⴼⴻⵟⵟⵓⵜⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴰⵎ ⵓⵛⴻⵄⵄⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("SS8_7","023_8_7","SNG","8","7","7","ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵅⴻⵙⵢⴻⵏ ⵜⴰⵢⵔⵉ, ⵓⵍⴰ ⴷ ⵉⵖⴻⵣⵔⴰⵏ ⵡⴰⵔ ⵜⵜ ⵜⵜⵉⵡⵢⴻⵏ. ⵡⴰⵅⵅⴰ ⵉⵡⵛⴰ ⵉⵊⵊⴻⵏ ⵉ ⵜⴰⵢⵔⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴷ ⴰⵙⴻⵃⵇⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("SS8_8","023_8_8","SNG","8","8","8","“ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵉⵛⵜ ⵏ ⵓⵍⵜⵎⴰⵜⵏⴻⵖ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ, ⵄⴰⴷ ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⴼⴼⵉⵖⴻⵏ ⵉⴷⵎⴰⵔⴻⵏ. ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⵉ ⵓⵍⵜⵎⴰⵜⵏⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("SS8_9","023_8_9","SNG","8","9","9","“ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵍⵃⵉⴹ, ⴰⴷ ⵅⴰⵙ ⵏⴻⵙⵙⴱⴻⴷⴷ ⴰⵛⴱⴰⵔ ⴰⵎ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵡⵡⴰⵔⵜ, ⴰⴷ ⵜⵜ ⵏⴻⵇⵇⴻⵏ ⵙ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⴻⵏⴳⴻⵍⵜ.” ");
INSERT INTO rift_vpl VALUES ("SS8_10","023_8_10","SNG","8","10","10","“ⵏⴻⵛⵛ ⴷ ⵍⵃⵉⴹ ⵓ ⵉⴷⵎⴰⵔⴻⵏ ⵉⵏⵓ ⴰⵎ ⵍⴱⵓⵔⵊⴰⵜ. ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵖ ⵏⴻⵛⵛ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵎ ⵜⴻⵏⵏⵉ ⵢⵓⴼⵉⵏ ⵍⴻⵃⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("SS8_11","023_8_11","SNG","8","11","11","“ⵙⵓⵍⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⴷⵉ ⴱⴰⵄⵍ-ⵀⴰⵎⵓⵏ. ⵉⵡⵛⴰ ⴰⵎⴰⵔⵊⴻⵄ ⵏⵏⵉ ⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ. ⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵇⴰⵄ ⵉⵊⵊ ⵢⵉⵡⵉ-ⴷⴷ ⴰⵍⴻⴼ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("SS8_12","023_8_12","SNG","8","12","12","“ⴰⵃⵡⵉⵛ ⵏ ⵓⴹⵉⵍ ⵉⵏⵓ, ⴰⵇⴰ-ⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ⴰⵍⴻⴼ ⵏ ⵍⴻⵡⵣⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴰⵇⴰ ⴰⵜⴻⵏ ⵉ ⵛⴻⴽ, ⴰ ⵙⵓⵍⵉⵎⴰⵏ, ⵓ ⴰⵍⴼⴰⵢⴻⵏ ⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⵣⴰⵢⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("SS8_13","023_8_13","SNG","8","13","13","“ⴰ ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵃⵡⵉⵛⴻⵏ, ⵉⵄⵛⵉⵔⴻⵏ ⵏⵏⴻⵎ ⵜⵜⴻⵙⵍⴰⵏ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ, ⵇⵇⴰⵔⴻⵏ: ‘ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵜⵜ ⵙⵍⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("SS8_14","023_8_14","SNG","8","14","14","“ⴷⴻⵖⵢⴰ, ⴰ ⵍⵍⵉⴼ ⵉⵏⵓ, ⴻⴳⴳ ⴰⵎ ⵢⵉⵖⴰⵢⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏⵉⵖ ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⵏ ⵓⴷⴰⴷⴻⵏ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⵄⵛⵓⴱ ⵉⵜⵜⴼⵓⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS1_1","024_1_1","ISA","1","1","1","ⵍⴻⵡⵃⵉⵢ ⵏ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵏⵏⵉ ⵉⵥⵔⴰ ⵅ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⵢⵓⵜⴰⵎ, ⴰⵃⴰⵣ ⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS1_2","024_1_2","ISA","1","2","2","“ⵙⵍⴻⵎ, ⴰ ⵉⵊⴻⵏⵡⴰⵏ, ⵓⵛⴰ ⵙⵙⴻⵖⴷ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍ: ‘ⵏⴻⵛⵛ ⵙⵙⴻⵢⵎⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("IS1_3","024_1_3","ISA","1","3","3","ⴰⴼⵓⵏⴰⵙ ⵉⵙⵙⴻⵏ ⴱⴰⴱ ⵏⵏⴻⵙ ⴷ ⵓⵙⵏⵓⵙ ⵍⵎⴻⴷⵡⴻⴷ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⵓⵙⵙⵏⴰ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⴻⴵⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS1_4","024_1_4","ISA","1","4","4","ⵓⵛⵜ ⵅ ⵍⴳⴻⵏⵙ ⵉ ⵉⵅⴹⴰⵏ, ⵍⴳⴻⵏⵙ ⵉ ⵅ ⵉⴵⴰ ⴷⴷⵇⴻⵍ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵜⴰⵔⵡⴰ ⵏ ⵓⵙⵏⴻⵅⵍⵉⵄ. ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵙⵉⴷⵉ, ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵔⵔⵉⵏ ⴰⵙ-ⴷⴷ ⵙ ⵡⴻⵄⵔⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS1_5","024_1_5","ISA","1","5","5","ⵎⴰⵏⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵡⵜⴻⵎ ⵄⴰⴷ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜⵖⴻⵡⵡⴰⵖⴻⵎ. ⴰⵣⴻⴵⵉⴼ ⵎⴰⵔⵔⴰ ⵉⵀⵍⴻⵛ, ⵓⵍ ⵎⴰⵔⵔⴰ ⵢⵓⵀⴻⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS1_6","024_1_6","ISA","1","6","6","ⵣⵉ ⵜⵍⴻⵇⵇⴰ ⵏ ⵓⴹⴰⵔ ⴰⵍ ⴰⵣⴻⴵⵉⴼ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⵉⴼⴻⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ! ⵎⵖⵉⵔ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ, ⵟⵟⴻⵄⴱⴰⵢⴰⵔ ⴷ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵀⴻⵏⵏⴹⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⵢⴰⵔⴹⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⴰⵔⴻⴹⴱⴻⵏ ⵙ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS1_7","024_1_7","ISA","1","7","7","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵜⴻⵅⵍⴰ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵡⴻⵎ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⴻⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵚⵚⴰⵔⴷⴻⵏ ⵜⵜ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⴰⵅⵎⵉ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵏ ⵜⵜ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_8","024_1_8","ISA","1","8","8","ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵜⴻⵇⵇⵉⵎ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵄⵉⵛⵛⵓⵜ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ, ⴰⵎ ⵜⴻⵅⵅⴰⵏⵜ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏ ⵍⴻⵅⵢⴰⵔ, ⴰⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_9","024_1_9","ISA","1","9","9","ⵎⵍⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵊⵊⵉ ⴷⵔⵓⵙ ⵎⵉⵏ ⵢⴰⵔⴻⵡⵍⴻⵏ, ⵉⵍⵉ ⵏⴻⴷⵡⴻⵍ ⴰⵎ ⵙⴰⴷⵓⵎ, ⵉⵍⵉ ⵏⴻⴳⴳⴰ ⴰⵎ ⵄⴰⵎⵓⵔⵔⴰ.’” ");
INSERT INTO rift_vpl VALUES ("IS1_10","024_1_10","ISA","1","10","10","“ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵙⴰⴷⵓⵎ! ⵡⵛⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰ ⵍⴳⴻⵏⵙ ⵏ ⵄⴰⵎⵓⵔⵔⴰ! ");
INSERT INTO rift_vpl VALUES ("IS1_11","024_1_11","ISA","1","11","11","ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵙ ⵜⵖⴰⵔⵚⵉ ⵏⵡⴻⵎ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵊⵊⵉⵡⵏⴻⵖ ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵜⴰⴷⵓⵏⵜ ⵏ ⵍⵎⴰⵍ ⵉⵚⴻⵃⵃⴻⵏ. ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵢⴻⵣⵎⴰⵔⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵄⵊⵉⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_12","024_1_12","ISA","1","12","12","ⵅⵎⵉ ⴷⴷ-ⵜᵉⵜⵜⴰⵙⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴰⵏⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵄⴰⵔⴹⴻⵏ ⵉ ⵓⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵄⴻⴼⵙⴻⵎ ⵅ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("IS1_13","024_1_13","ISA","1","13","13","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵄⴰⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉⴱⴻⴹⵍⴻⵏ. ⵍⴻⴱⵅⵓⵔ ⵖⴰⵔⵉ ⴷ ⵏⵏⵄⵉ. ⵓⵙⵙⴰⵏ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏ ⵊⴷⵉⴷ ⴷ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⴷ ⵓⵍⴰⵖⵉ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵃⴻⵎⵍⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵄⴰⴷ ⵓⵍⴰ ⴷ ⴰⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_14","024_1_14","ISA","1","14","14","ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵛⴰⵔⵔⴻⵀ ⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵏⵡⴻⵎ ⴷ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏⵡⴻⵎ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔⵉ ⴷ ⵍⴻⵃⵎⴻⵍ, ⵏⴻⵛⵛ ⵓⵃⵍⴻⵖ ⴰⴷ ⵜⴻⵏ ⴰⵔⴱⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("IS1_15","024_1_15","ISA","1","15","15","ⵅⵎⵉ ⵜᵉⵜⵜⵙⴰⵔⵔⴰⵃⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⵜⵜⵍⴻⵃⵃⴼⴻⵖ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵣⵣⴰⵢⵡⴻⵎ. ⵄⴰⴷ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵏⵉⵎ ⴷⵉ ⵜⵥⴰⴵⵉⵜ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⵙⵍⵉⵖ, ⵎⴰⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_16","024_1_16","ISA","1","16","16","ⵙⵉⵔⴷⴻⵎ, ⵙⵉⵣⴷⴻⴳⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵎ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ⵙⴱⴻⴷⴷⴻⵎ ⵣⵉ ⵍⵖⴰⵔ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS1_17","024_1_17","ISA","1","17","17","ⵍⴻⵎⴷⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⵔⵣⵓⵎ ⵅ ⵍⵃⴻⵇⵇ, ⵡⵛⴻⵎ ⴰⴼⵓⵙ ⵉ ⵡⴻⵏⵏⵉ ⵉⵃⵙⴰⵔⴻⵏ, ⴳⴳⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵓⵢⵓⵊⵉⵍ, ⵡⵜⴻⵎ ⵅ ⵜⴰⵊⵊⴰⵍⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS1_18","024_1_18","ISA","1","18","18","“ⴰⵙⴻⵜⵜⵉⵡ-ⴷⴷ ⵓ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏᵉⵜⵜⴻⵎⵃⴰⴽⴻⵎ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ!, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵡⴰⵅⵅⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⴷ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⴰⵎ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵔⴻⵏ ⴰⵎ ⵡⴻⴷⴼⴻⵍ, ⵡⴰⵅⵅⴰ ⴷ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⴰⵎ ⵓⵣⴻⴳⴳⵯⴰⵖ ⵢⵓⴵⵖⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⴰⵎ ⵜⴹⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("IS1_19","024_1_19","ISA","1","19","19","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⵡⵡⵍⴻⵎ, ⵓ ⴰⴷ ⵜⴻⵙⵍⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("IS1_20","024_1_20","ISA","1","20","20","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵓⴳⵉⵎ ⵓⵛⴰ ⴰⴷ ⵜⵖⴻⵡⵡⵖⴻⵎ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴻⵛⵛ ⵙⵙⵉⴼ, ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("IS1_21","024_1_21","ISA","1","21","21","“ⵎⴰⵎⵎⴻⵛ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ! ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵃⴻⵇⵇ, ⵜⴰⵙⴻⴳⴷⴰ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵏⵓⵙⴰ ⴷⴰⵢⴻⵙ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵇⴻⵜⵜⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_22","024_1_22","ISA","1","22","22","ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵎ ⵜⴻⴷⵡⴻⵍ ⴷ ⴽⵓⴼⴼⵓ, ⴱⵉⵏⵓ ⵏⵏⴻⵎ ⵚⵚⵓⵔⴻⵏ ⵜ ⴰⴽ-ⴷ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_23","024_1_23","ISA","1","23","23","ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵎ ⵜⵜⵖⴻⵡⵡⵖⴻⵏ, ⴰⵇⴰ ⴳⴳⵉⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵜⵜⴻⵅⵙⴻⵏ ⵜⵉⵔⵣⵉⴼⵉⵏ ⵓⵛⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⴰⵔⵔⴻⵛⵡⴻⵜ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵉⵖⴻⵏ ⵉ ⵓⵢⵓⵊⵉⵍ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵜⵉⵊⵊⴰⵍ ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⵉⴽⴽⵡⵉⴹ.” ");
INSERT INTO rift_vpl VALUES ("IS1_24","024_1_24","ISA","1","24","24","“ⵙ ⵓⵢⴰ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵓⵛⵜ ⵅⴰⵡⴻⵎ! ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵙ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS1_25","024_1_25","ISA","1","25","25","ⵏⴻⵛⵛ ⴰⴷ ⵡⵜⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅⴰⵡⴻⵎ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵚⴻⴼⴼⵉⵖ ⴰⴽ-ⴷ ⵍⵍⵉⵅⵉⵢⵢⴰ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴼⵉⴼ ⵏⵏⴻⵎ ⴰⴷ ⵜ ⵡⴻⴷⴷⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS1_26","024_1_26","ISA","1","26","26","ⵏⴻⵛⵛ ⴰⴷ ⴰⵎ ⵡⵛⴻⵖ ⵄⴰⵡⴻⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵎ ⴰⵎ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⴷ ⴰⵢⵜ ⵏ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵎ ⴰⵎ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴰⴷ ⴰⵎ ⵍⴰⵖⴰⵏ: ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⵙⴻⴳⴷⴰ!’ ⴷ ‘ⵜⴻⵏⴷⵉⵏⵜ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("IS1_27","024_1_27","ISA","1","27","27","ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ ⵙ ⵍⵃⴻⵇⵇ ⴷ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵓⴱⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴻⵏⵊⵎⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("IS1_28","024_1_28","ISA","1","28","28","ⵎⴰⵛⴰ ⵉⵎⵖⴻⵡⵡⵖⴻⵏ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ ⵊⵎⵉⵄ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵜⵡⴰⵇⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_29","024_1_29","ISA","1","29","29","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⴻⵥⵔⴻⵎ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵙⴻⴹⵃⴰⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵃⵡⵉⵛⴻⵏ ⵏⵏⵉ ⵜⵉⵅⴹⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("IS1_30","024_1_30","ISA","1","30","30","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵉ ⵣⵉ ⴰⴼⴰⵔ ⵏⵏⴻⵙ ⵉⵙⵍⴰⵡ, ⵓ ⴰⵎ ⵡⴻⵃⵡⵉⵛ ⵉ ⵡⴰⵔ ⵖⴰⵔ ⴵⵉⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS1_31","024_1_31","ISA","1","31","31","ⴰⴷ ⵉⴷⵡⴻⵍ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵜⵉⴼⴼⴻⵙⵜ ⵓ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴼⴻⵟⵟⵓⵜ, ⴰⴷ ⴰⵔⵖⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵎⵓⵏⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⵉ ⵖⴰ ⵉⵙⵙⵅⴻⵙⵢⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS2_1","024_2_1","ISA","2","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵥⵔⴰ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵅ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS2_2","024_2_2","ISA","2","2","2","“ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⵉⵎⵜⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵇⴰⵄ ⵏ ⵉⴷⵓⵔⴰⵔ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⴷⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵣⵣⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS2_3","024_2_3","ISA","2","3","3","ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⴷⵉⵏⵏⵉ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⵉ ⵜⴻⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ!’, ⵎⴰⵖⴰⵔ ⵣⵉ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS2_4","024_2_4","ISA","2","4","4","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵊⴰⵔ ⵛⵛⵓⵄⵓⴱ ⵓ ⴰⴷ ⵉⵃⴰⴽⴻⵎ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⴷ ⴷⴷⵓⵣⴰⵏ ⵓ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵙⴻⵏ ⴷ ⵍⴻⵎⵡⴰⵙ ⵉ ⵡⴻⵣⴱⴰⵔ. ⵡⴰⵔ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵄⴰⴷ ⵙⵙⵉⴼ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴰⵔ ⴷⴰⵔⵔⵉⴱⴻⵏ ⵄⴰⴷ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("IS2_5","024_2_5","ISA","2","5","5","ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⵔⴰⵃ-ⴷⴷ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS2_6","024_2_6","ISA","2","6","6","“ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵛⵛⵓⵔⴻⵏ ⵙ ⵓⵇⴰⵔⵔⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵛⴻⵖⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵜⴱⴻⵣⴳⵉⵡⵜ ⴰⵎ ⵍⴳⴻⵏⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵡⵜⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS2_7","024_2_7","ISA","2","7","7","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⴻⵛⵛⵓⵔ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⴰⵏⴻⴳⴳⴰⵔ ⵖⴰⵔ ⵜⵅⵓⴱⴰⵢ ⵏⵙⴻⵏ. ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⴻⵛⵛⵓⵔ ⵙ ⵢⴻⵢⵙⴰⵏ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⴰⵏⴻⴳⴳⴰⵔ ⵖⴰⵔ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS2_8","024_2_8","ISA","2","8","8","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍ’ⴰⵚⵏⴰⵎ, ⵏⵉⵜⵏⵉ ⴱⴻⵏⴷⵇⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⵉ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴹⴻⵡⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS2_9","024_2_9","ISA","2","9","9","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵖⵏⴻⵙ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵀⵡⴰ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⵙⴰⵎⴰⵃ!” ");
INSERT INTO rift_vpl VALUES ("IS2_10","024_2_10","ISA","2","10","10","“ⴰⴷⴻⴼ ⵖⴰⵔ ⵍⴻⵊⵔⵓⴼ, ⵏⵓⴼⴼⴰⵔ ⴷⴻⴳ ⵓⵛⴰⵍ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⵏⴻⵅⵍⵉⵄ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⴻⵣⵣ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("IS2_11","024_2_11","ISA","2","11","11","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⴻⴼⵅⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰⵏⵜ ⵓ ⴰⵛⴻⵏⵏⴻⵄ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⴷ ⵉⵀⵡⴰ. ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵙⵉⴷⵉ ⵡⴰⵀⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS2_12","024_2_12","ISA","2","12","12","ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵉ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⴽⵓⵍ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⴷ ⵓⵎⵄⴻⴼⴼⴰⵔ ⵓ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵄⵓⴵⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("IS2_13","024_2_13","ISA","2","13","13","ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵢⵓⵄⵍⴰⵏ ⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⴱⴻⴵⵓⴹ ⵏ ⴱⴰⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS2_14","024_2_14","ISA","2","14","14","ⵅ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⵉⵄⴻⴼⴼⴰⵔⴻⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵢⵓⵄⵍⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS2_15","024_2_15","ISA","2","15","15","ⵅ ⴽⵓⵍ ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ, ⵅ ⴽⵓⵍ ⵍⵃⵉⴹ ⵏ ⵍⵇⴻⵍⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("IS2_16","024_2_16","ISA","2","16","16","ⵅ ⵎⴰⵔⵔⴰ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS2_17","024_2_17","ISA","2","17","17","ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⵀⵡⴰ ⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰⵏ. ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵙⵉⴷⵉ ⵡⴰⵀⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS2_18","024_2_18","ISA","2","18","18","ⵍ’ⴰⵚⵏⴰⵎ ⴰⴷ ⵜⵜⵡⴰⴱⴻⴹⵍⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS2_19","024_2_19","ISA","2","19","19","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵏ ⵍⴻⵊⵔⵓⴼ ⴷ ⵉⵃⴼⵔⴰⵡⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⵏⴻⵅⵍⵉⵄ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ, ⵅⵎⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS2_20","024_2_20","ISA","2","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵏⴹⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵙ ⵏ ⵡⵓⵔⴻⵖ, ⵉⵏⵏⵉ ⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⴱⴻⵏⴷⵇⴻⵏ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉ ⵉⵊⴰⵔⴱⵓⵄⴻⵏ ⴷ ⵍⵡⴻⴹⵡⴰⴹⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("IS2_21","024_2_21","ISA","2","21","21","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⴷⵉ ⵜⴻⵣⵣⵉⵢⵉⵏ ⵏ ⵍⴻⵊⵔⵓⴼ ⵓ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⴷⴻⴳ ⵡⴻⵥⵔⵓ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⴻⵣⵣ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS2_22","024_2_22","ISA","2","22","22","“ⵃⴻⵢⵢⴷⴻⵎ ⵅ ⴱⵏⴰⴷⴻⵎ, ⵡⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⴵⴰ ⵎⵖⵉⵔ ⵏⵏⴻⴼⵙ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ ⵇⴰⵄ ⴰⴷ ⵅⴰⵙ ⵏⴻⵃⵙⴻⴱ?” ");
INSERT INTO rift_vpl VALUES ("IS3_1","024_3_1","ISA","3","1","1","“ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⴷ ⵉⴽⴽⴻⵙ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ ⵇⴰⵄ ⴰⵄⴻⴽⴽⴰⵣ ⴷ ⵇⴰⵄ ⵜⴰⵖⵖⴰⵔⵛⵜ, ⵇⴰⵄ ⵜⴰⵎⴻⵡⵛⵉⵡⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷ ⵇⴰⵄ ⵜⴰⵎⴻⵡⵛⵉⵡⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵡⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS3_2","024_3_2","ISA","3","2","2","ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷ ⵓⵄⴻⵙⴽⴰⵔⵉ, ⵍⵇⴰⴹⵉ ⴷ ⵓⵏⴰⴱⵉ, ⴰⴳⴻⵣⵣⴰⵏ ⴷ ⵓⵎⵖⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("IS3_3","024_3_3","ISA","3","3","3","ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵅⴻⵎⵙⵉⵏ ⴷ ⴱⵓ-ⵛⵛⴰⵏ, ⴰⵎⵛⴰⵡⴰⵔ, ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵜⵃⴻⵙⵙⴻⵛⵜ ⵏ ⵓⵄⴻⵣⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS3_4","024_3_4","ISA","3","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴳⴳⴻⵖ ⵉⵃⵓⴹⵔⵉⵢⵢⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⴻⵍⵍⵟⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS3_5","024_3_5","ISA","3","5","5","ⵅⴻⵏⵏⵉ ⴷⵉ ⵍⴳⴻⵏⵙ ⴰⴷ ⵃⵙⴰⵔⴻⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵔⵢⴰⵣ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵀⴻⴽⴽⵡⴻⵍⴻⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵃⵓⴷⵔⵉ ⵉ ⵓⵡⴻⵙⵙⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS3_6","024_3_6","ISA","3","6","6","ⵅⵎⵉ ⵖⴰ ⵉⵛⴻⴱⴱⴰⵔ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵓⵎⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵅⴰⵏⴻⵖ. ⴰⵔⵔ ⵍⵅⴰⵔⴱⴻⵜ-ⴰ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵛ!’, ");
INSERT INTO rift_vpl VALUES ("IS3_7","024_3_7","ISA","3","7","7","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⴳⵉ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⴻⵙⴳⴻⵏⴼⵓ. ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵡⴻⵖⵔⵓⵎ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵡⴰⵔⵔⵓⴹ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⴻⵎ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵏ ⵍⴳⴻⵏⵙ!’ ");
INSERT INTO rift_vpl VALUES ("IS3_8","024_3_8","ISA","3","8","8","ⵎⴰⵖⴰⵔ ⵜⴻⵏⵏⴻⴷⵔⴻⴼ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵜⴻⵡⴹⴰ ⵢⴰⵀⵓⴷⴰ, ⵎⵉⵏⵣⵉ ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵄⴰⵔⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS3_9","024_3_9","ISA","3","9","9","ⵜⵉⴼⵔⴰⵙ ⵏ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵛⴻⵀⵀⴷⴻⵏⵜ ⵅⴰⵙⴻⵏ. ⴰⵎ ⵙⴰⴷⵓⵎ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵅ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ. ⵓⵛⵜ ⵅ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS3_10","024_3_10","ISA","3","10","10","“ⵉⵏⵉⵎ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⵇⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ, ⴰⵇⴰ ⴰⴷ ⵛⵛⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS3_11","024_3_11","ISA","3","11","11","ⵓⵛⵜ ⵅ ⵓⵄⴻⴼⴼⴰⵏ. ⵓⵛⵜ ⵅⴰⵙ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜ ⵅⴻⴵⵚⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS3_12","024_3_12","ISA","3","12","12","ⵉⵏⵏⵉ ⵉⴷⴻⴵⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵓⵛⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵜⵚⴻⵍⵍⵟⴻⵏⵜ ⵅⴰⵙ. ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵏⴻⴷⴷⵀⴻⵏ, ⴰⵇⴰ ⵜⵜⵖⴰⵔⵔⴰⵏ ⵛⴻⴽ, ⵓⵛⴰ ⵍⴰⵜⴰⵔ ⵏ ⵜⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵛ ⵎⴻⵙⵙⵃⴻⵏ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS3_13","024_3_13","ISA","3","13","13","“ⵙⵉⴷⵉ ⵉⵡⵊⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ, ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS3_14","024_3_14","ISA","3","14","14","ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵔⴼⴻⵄ ⴷⴷⴻⵄⵡⴻⵜ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⵎ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵓ ⵎⵉⵏ ⵜⵓⵛⴰⵔⴻⵎ ⵉ ⵉⵎⴻⵣⵍⴰⴹ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS3_15","024_3_15","ISA","3","15","15","ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵖⵉⵏ, ⴰⵇⴰ ⵜⵍⴻⴱⴱⵣⴻⵎ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵜᵉⵜⵜⴻⴼⴼⵥⴻⵎ ⵉⵖⴻⵎⴱⴰⴱ ⵏ ⵉⵎⴻⵣⵍⴰⴹ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS3_16","024_3_16","ISA","3","16","16","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: “ⵎⵉⵏⵣⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⴷⴰⵢⵙⴻⵏⵜ ⵏⵏⴼⴰⵅⴻⵜ, ⴳⴳⵓⵔⴻⵏⵜ ⵙ ⵉⵔⴰⵡⴻⵏ ⴳⴻⵄⵄⴷⴻⵏ, ⵙ ⵍⴻⵅⵣⵔⴰⵜ ⵜⵜⵖⴰⵔⵔⴰⵏⵜ, ⴰⵎ ⵜⵜⵔⴰⵃⴻⵏⵜ ⵓ ⵜⵜⵇⴻⵣⵇⵉⵣⴻⵏⵜ ⵙ ⵉⵚⵓⵔⴰⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵟⴻⵏⵟⵓⵏⴻⵏⵜ ⵉⵅⴻⵍⵅⴰⵍⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("IS3_17","024_3_17","ISA","3","17","17","ⴰⴷ ⵢⴰⵔⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵊⴷⴰⵎ ⵅ ⵜⴰⵛⴻⵇⵇⵓⴼⵜ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓⵛⴰ ⴰⴷ ⵉⵄⴰⵔⵔⴰ ⵙⵉⴷⵉ ⵍⵄⴰⵔ ⵏⵙⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS3_18","024_3_18","ISA","3","18","18","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏⵜ ⵉⴽⴽⴻⵙ ⵙⵉⴷⵉ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵣⵓⵟ ⵏⵙⴻⵏⵜ: ⵉⵅⴻⵍⵅⴰⵍⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵍⵉⵣⴰⵔⴰⵜ ⵜⵜⵡⴰⵛⴻⴷⴷⴻⵏⵜ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⴷ ⵜⴻⵣⵔⵉⵡⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ");
INSERT INTO rift_vpl VALUES ("IS3_19","024_3_19","ISA","3","19","19","ⴷ ⵜⴻⵅⵔⴰⵣⵉⵏ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵜⵓⴷⴷⵉⵎⵉⵏ ⴷ ⵜⵉⵎⴻⵇⵢⴰⵙⵉⵏ ⴷ ⵍⵍⵜⴰⵎⴰⵜ ");
INSERT INTO rift_vpl VALUES ("IS3_20","024_3_20","ISA","3","20","20","ⴷ ⵉⵃⴻⵡⵡⴰⵇⴻⵏ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵉ ⵓⵣⴻⴵⵉⴼ ⴷ ⵉⵅⴻⵔⵅⴰⵍⴻⵏ ⴷ ⵜⵃⴻⵣⵣⴰⵎⵉⵏ ⴷ ⵜⵣⵉⵢⵢⴰⵜⵉⵏ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⵍⴻⵃⵔⵓⵣ ");
INSERT INTO rift_vpl VALUES ("IS3_21","024_3_21","ISA","3","21","21","ⴷ ⵜⵅⴰⴷⵉⵏ ⵏ ⵓⴼⵓⵙ ⴷ ⵜⴻⵅⵔⴰⵣⵉⵏ ⵏ ⵜⴻⵏⵣⴰⵔⵉⵏ ");
INSERT INTO rift_vpl VALUES ("IS3_22","024_3_22","ISA","3","22","22","ⴷ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴻⵢⴷⵓⴷ ⴷ ⵍⵉⵣⴰⵔⴰⵜ ⴷ ⵜⵙⴻⴱⵏⴰⵢ ⴷ ⵉⵇⵓⵔⴰⴱ ");
INSERT INTO rift_vpl VALUES ("IS3_23","024_3_23","ISA","3","23","23","ⴷ ⵜⵉⵙⵉⵜⵉⵏ ⴷ ⵡⴻⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵜⵛⵓⵛⵛⴰⵢ ⴷ ⴼⵓⵏⴰⵔⴰⵜ ⵏ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("IS3_24","024_3_24","ISA","3","24","24","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⴱⴰⵍⵙⴰⵎ ⴰⴷ ⵜⵉⵍⵉ ⴰⵔⵔⵉⵃⴻⵜ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵎ ⵏ ⵜⵃⴻⵣⵣⴰⵎⵜ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵙⵖⵓⵏ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵛⴻⵏⴽⵓⴽⵉⵏ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵓⵣⴻⴵⵉⴼ ⴰⵇⴻⵛⵛⴰⵔ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴻⵔⵔⵓⴹ ⵉⵡⵙⴻⵄ ⴰⴷ ⵜⵉⵍⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴻⵥⵔⵉ ⴷ ⵓⵄⴻⴵⴻⵎ ⵏ ⵡⴻⵛⵎⴰⴹ ⵅ ⵜⴻⵍⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS3_25","024_3_25","ISA","3","25","25","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵎ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("IS3_26","024_3_26","ISA","3","26","26","ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⴰⴷ ⵛⴻⵜⵛⴰⵏⵜ ⵓ ⴰⴷ ⵛⴻⴹⵏⴻⵏⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS4_1","024_4_1","ISA","4","1","1","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵛⴻⴱⴱⴰⵔⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⴷ ⵇⵇⴰⵔⴻⵏⵜ: ‘ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵛⵛ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵖ ⵓ ⴰⴷ ⵏⴻⵙⵙⵢⴰⵔⴹ ⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴽⵙⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵡⴰⵀⴰ, ⴽⵙⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵅⴰⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("IS4_2","024_4_2","ISA","4","2","2","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⵓⵖⴻⴷⴷⵓ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴻⵍⵡⵉⵣⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵓ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⵄⴻⵣⵣ ⴷ ⵓⵛⴻⵡⵡⴰⵔ ⵉ ⵎⵉⵏ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS4_3","024_4_3","ISA","4","3","3","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵚⵉⵀⵢⵓⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⴷ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵏⵉⵏ: ‘ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ!’, ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS4_4","024_4_4","ISA","4","4","4","ⵅⵎⵉ ⵖⴰ ⵉⵙⵙⵉⵔⴷ ⵙⵉⴷⵉ ⵍⴻⵅⵎⴻⵊ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓ ⴰⴷ ⵉⵙⵔⵉⵔ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵍⴻⵃⴽⴰⵎ ⵓ ⵙ ⴰⵔⵔⵓⵃ ⵉⵛⴻⵎⵎⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS4_5","024_4_5","ISA","4","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵣⵉⵍ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏⵏⴻⵙ ⵓ ⵙ ⴵⵉⵍⴻⵜ ⴷⴷⴻⵅⵅⴰⵏ ⴷ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⵛⴻⵄⵛⵉⵄⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵉⵡⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵄⵓⴵⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⵇⵉⴷⵓⵏⵜ ⵉ ⵓⴷⵓⵔⵔⵉ ⵏ ⵜⴻⵙⵍⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("IS4_6","024_4_6","ISA","4","6","6","ⴰⴷ ⵢⵉⵍⵉ ⵓⵄⵉⵛⵛⵓ ⵉ ⵜⵉⵍⵉ ⵙ ⵓⵣⵉⵍ ⵣⵉ ⵍⴻⵃⵎⵓ ⵓ ⵉ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷ ⵓⴷⵓⵔⵔⵉ ⵣⵉ ⵍⵃⴻⵎⵍⴻⵜ ⴷ ⵡⴻⵏⵥⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS5_1","024_5_1","ISA","5","1","1","“ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵉⵣⵍⵉ ⵉ ⵍⵍⵉⴼ ⵉⵏⵓ, ⵉⵣⵍⵉ ⵏ ⵍⵍⵉⴼ ⵉⵏⵓ ⵅ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ: ‘ⵍⵍⵉⴼ ⵉⵏⵓ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵎ ⵉⵊⵊ ⵏ ⵢⵉⵛⵛ ⵏ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴷⴻⵀⵏⴻⵏ ⵜ ⵙ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS5_2","024_5_2","ISA","5","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵇⴻⵛ ⵉ-ⵜ ⵓ ⵉⵚⴻⴼⴼⴰ ⵉ-ⵜ ⵣⴻⴳ ⵉⵥⵔⴰ, ⵉⵥⵥⵓ ⵜ ⵙ ⵜⵣⴰⵢⴰⵔⵉⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ⵉⵏⵇⴻⵛ ⴷⴰⵢⴻⵙ ⵜⴰⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ. ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵜⵉⵎ, ⴰⵃⵡⵉⵛ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⴹⵉⵍ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ-ⴷⴷ ⴰⴹⵉⵍ ⴰⵙⴻⵎⵎⴰⵎ.’” ");
INSERT INTO rift_vpl VALUES ("IS5_3","024_5_3","ISA","5","3","3","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵃⴻⴽⵎⴻⵎ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵓⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("IS5_4","024_5_4","ISA","5","4","4","ⵎⵉⵏ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵄⴰⴷ ⴰⴷ ⴳⴳⴻⵖ ⵉ ⵓⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⴳⴳⵉⵖ ⵄⴰⴷ? ⵎⴰⵢⴻⵎⵎⵉ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⴹⵉⵍ ⵎⵍⵉⵃ, ⵓⵎⵉ ⴷⴷ ⵢⵉⵡⵉ ⵎⵖⵉⵔ ⴰⴹⵉⵍ ⴰⵙⴻⵎⵎⴰⵎ? ");
INSERT INTO rift_vpl VALUES ("IS5_5","024_5_5","ISA","5","5","5","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⴰⴽ-ⴷ ⵓⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ: ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⴰⴼⵔⴰⵢ ⵏⵏⴻⵙ ⵉ ⵜ ⵉⵃⴹⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵍⴻⵇⴹⴻⵏ ⵇⴰⵄ, ⴰⴷ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵍⵃⵉⴹ ⴰⵍ ⵅⴰⵙ ⵉ ⵖⴰ ⵄⴻⴼⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS5_6","024_5_6","ISA","5","6","6","ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⵍⴻⵅⵍⴰ, ⵡⴰⵔ ⵜ ⵣⴻⴱⴱⴰⵔⴻⵏ ⵏⵉⵖ ⴰⴷ ⵜ ⵛⴰⵔⵣⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⵣⴻⴳⴳⵯⴰⵔⵜ ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴰⴷ ⴷⵉⵏⵏⵉ ⵖⴻⵎⵢⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵓⵎⵓⵔⴻⵖ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛⴻⵏ ⴰⵏⵥⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS5_7","024_5_7","ISA","5","7","7","ⵎⴰⵖⴰⵔ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⴰⵖⴻⴷⴷⵓⵜ ⵎⵉⵏ ⵅⴻⴼ ⵢⴰⵔⴹⴰ. ⵉⵔⴰⵊⴰ ⵍⵃⴻⵇⵇ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵔⴰⵊⴰ ⵜⴰⵙⴻⴳⴷⴰ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵜⵖⵓⵢⵢⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS5_8","024_5_8","ISA","5","8","8","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⴷⴷⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⴰⵔⴻⵏⵏⵢⴻⵏ ⵉⵢⵢⴰⵔ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ, ⴰⵍ ⵜⴰⴼⴻⴷ ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ ⵡⴻⵎⵛⴰⵏ ⵄⴰⴷ ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵀⴰ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("IS5_9","024_5_9","ISA","5","9","9","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵟⵟⴰⵙ ⵏ ⵜⵓⴷⵔⵉⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⵜⵓⴷⵔⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵜⵉⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ.’ ");
INSERT INTO rift_vpl VALUES ("IS5_10","024_5_10","ISA","5","10","10","ⵎⵉⵏⵣⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⴼⴻⴷⴷⴰⵏⴻⵏ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⴰⵡⵢⴻⵏ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵓⴱⴰⵜⵓ, ⵓ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ ⵏ ⵣⵣⴰⵔⵔⵉⵄⴻⵜ ⴰⴷ ⵢⴰⵡⵉ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏ ⵍⵃⴻⴱⴱ ⵏ ⵉⵔⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS5_11","024_5_11","ISA","5","11","11","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⴽⴽⴰⵔⴻⵏ ⵣⵉⵛ, ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵛⵛⵔⴰⴱ ⵓ ⵜⵜⵖⵉⵎⴰⵏ ⵡⵙⴻⵡⵙⴻⵏ ⴰⵍ ⵜⴱⴰⵎⴱⴰⵙⵜ, ⴰⵍ ⵜⴻⵏ ⵉⵙⵙⴻⵃⵎⴰ ⴱⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS5_12","024_5_12","ISA","5","12","12","ⵍⴳⴰⵎⴱⵔⵉ ⴷ ⵍⵀⴰⵔⴱⴰ ⴷ ⵓⴱⴻⵏⴷⵉⵔ ⴷ ⵜⴻⵎⵊⴰ ⴷ ⴱⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵣⵣⵔⴰⴷⵉ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ ⵙⵉⴷⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵅⴻⵣⵣⴰⵔⴻⵏ, ⵜⴰⵎⴻⴳⴳⵉⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜ ⵜⵜⵡⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS5_13","024_5_13","ISA","5","13","13","ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴻⴵⵉ ⵜⵓⵙⵙⵏⴰ. ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵀⴻⵢⵢⴼⴻⵏ, ⴰⴷ ⵢⴰⵥⴻⵖ ⵓⴱⴰⵔⵔⵓ ⵏⵙⴻⵏ ⵙ ⵓⴼⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS5_14","024_5_14","ISA","5","14","14","ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵜⴰⵔⵣⴻⵎ ⵍⴰⵅⴰⵔⵜ ⴰⵟⵟⴰⵙ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵏⵀⵍⴰ ⵍⴻⵇⵢⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵀⵡⴰ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ ⴷ ⵓⴱⴰⵔⵔⵓ ⵏⵏⴻⵙ ⴷ ⴷⴷⵔⵉⵣ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵏⴻⴳⴳⵣⴻⵏ ⴰⵎⵎⵓ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS5_15","024_5_15","ISA","5","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵅⵏⴻⵙ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰ, ⵓⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("IS5_16","024_5_16","ISA","5","16","16","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵙ ⵍⵃⴻⵇⵇ ⵓ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴰⴷ ⵓⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵙ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS5_17","024_5_17","ISA","5","17","17","ⴰⴷ ⵀⴻⴷⴷⴻⵏ ⴷⵉⵏⵏⵉ ⵉⵣⵎⴰⵔⴻⵏ ⴰⵎ ⵜⵜⵀⴻⴷⴷⴰⵏ ⵅ ⵜⴽⴻⵙⵙⴰⵡⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⵍⴻⵅⵔⴰⴱⵉ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS5_18","024_5_18","ISA","5","18","18","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵊⴻⴱⴱⴷⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵙ ⵜⴻⵙⵖⵓⵏⵉⵏ ⵏ ⵍⵖⴻⵛⵛ ⵓⵍⴰ ⴷ ⴷⴷⴻⵏⴱ ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵉⵇⴻⴱⴱⵓⵣⴻⵏ ⵏ ⵓⴽⴰⵔⵔⵓ ⵏ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS5_19","024_5_19","ISA","5","19","19","ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⴰⵣⵣⴻⵍ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵜ ⵉⴳⴳ ⴷⴻⵖⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵥⴰⵔ, ⵓⵛⴰ ⵛⵛⵡⴰⵔ ⵏ ⵓⵎⵇⴻⴷⴷⴻⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵅⴻⵛⵛ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("IS5_20","024_5_20","ISA","5","20","20","“ⵓⵛⵜ ⵅ ⵢⴻⵏⵏⵉ, ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⵚⴱⴻⵃ ⵓ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵡⴰⵔ ⵉⵃⵍⵉ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⴼⴰⵡⵜ ⵓ ⵜⴰⴼⴰⵡⵜ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵢⴰⵔⵣⵉⴳⴻⵏ ⴷ ⵎⵉⵥⵉⴷ ⵓ ⵎⵉⵏ ⵉⵣⵉⴹⴻⵏ ⴷ ⴰⵎⴰⵔⵣⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("IS5_21","024_5_21","ISA","5","21","21","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵓ ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵙⵙⴱⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⴼⴻⵀⵀⴰⵎⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("IS5_22","024_5_22","ISA","5","22","22","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵖⴰⵔ ⵜⵙⴻⵙⵙⵉⵜ ⵏ ⴱⵉⵏⵓ ⵓ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ ⵖⴰⵔ ⵡⴻⵃⵔⴰⵢ ⵏ ⵛⵛⵔⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("IS5_23","024_5_23","ISA","5","23","23","ⵉⵏⵏⵉ ⵉⵜⵜⵙⴰⵔⵔⴰⵃⴻⵏ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵙ ⵜⴻⵔⵣⴻⴼⵜ ⵉⵖⴻⵛⵛⴻⵏ, ⵎⴰⵛⴰ ⴽⴽⵙⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS5_24","024_5_24","ISA","5","24","24","“ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵉⵅⵙⴰⵔ ⵡⴻⵥⵡⴰⵔ ⵏⵙⴻⵏ ⵓ ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜᵉⴹⵓⵡ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴻⵜⵜ ⵉⵍⴻⵙ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵖⴻⴵ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵀⴻⴽⴽⵡⴰ ⵡⵓⵔⵓⵎ ⵙ ⵓⵛⴻⵄⵄⴰⵍ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵓ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS5_25","024_5_25","ISA","5","25","25","ⵅ ⵓⵢⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴽⵙⵉ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⴰⵍⴰⵎⵉ ⴰⵔⵊⵉⵊⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⵎⴻⴷⴷⴻⵏⵜ ⵅ ⵉⵎⴻⵙⵔⴰⵇ ⴰⵎ ⵡⴻⴼⵔⴰⴹ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵙⴰⵔⵔⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("IS5_26","024_5_26","ISA","5","26","26","ⵎⴰⵖⴰⵔ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵓ ⵣⴻⴳ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜ ⵉⵚⴻⴼⴼⴰⵔ ⵖⴰⵔⴻⵙ. ⵅⵣⴰⵔ, ⵉⵜⵜⴰⵙ-ⴷⴷ ⴷⴻⵖⵢⴰ ⵙ ⵜⴻⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("IS5_27","024_5_27","ISA","5","27","27","ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵢⵓⵃⵉⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵉⵏⵇⴰⵔⴹ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵉⵏⵏⵓⴷⴻⵎ ⵏⵉⵖ ⵉⵟⵟⴻⵚ, ⵓⵍⴰ ⵖⴰⵔ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⴼⵙⵉ ⴰⴱⵢⴰⵙ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ ⵏⵉⵖ ⵉⵇⴻⵟⵟⴻⵙ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS5_28","024_5_28","ISA","5","28","28","ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵙ ⵇⴻⴹⵄⴻⵏⵜ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵡⴰⵙ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵎⴻⵃⵃⴹⴻⵏ. ⵜⵉⵛⴻⴹⵢⵉⵏ ⵏ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵙ ⴱⴰⵏⴻⵏⵜ ⵇⴻⵙⵃⴻⵏⵜ ⴰⵎ ⵓⵇⴰⵢⴰⵙ, ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴰⵎ ⵜⵃⴰⵔⵢⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("IS5_29","024_5_29","ISA","5","29","29","ⵣⵣⵀⵉⵔ ⵏⵏⴻⵙ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵜⴻⵢⵔⴰⴷⵜ ⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵣⴻⵀⵀⴰⵔ ⴰⵎ ⵢⵉⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ⴰⴷ ⵢⴰⵔⵔⵓⴵⴻⴷ, ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⴰⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵊⴰⵔⵔ ⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⵉ ⵜ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS5_30","024_5_30","ISA","5","30","30","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵣⴻⵀⵀⴰⵔ ⴹⵉⴷⴷ ⵍⴳⴻⵏⵙ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵍⴻⴱⵃⴰⵔ. ⴰⴷ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ-ⵜⵜ ⵎⵖⵉⵔ ⴷ ⵜⴰⴵⴻⵙⵜ ⴷ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵓⵛⴰ ⵜⴰⴼⴰⵡⵜ ⴰⴷ ⵜⴻⴱⴱⴰⵔⵛⴻⵏ ⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⴱⴱⴰⵔⴻⵛⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS6_1","024_6_1","ISA","6","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵄⵓⵣⵣⵉⵢⴰ ⵥⵔⵉⵖ ⵙⵉⴷⵉ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵢⵓⵄⵍⴰⵏ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵓⵛⴰ ⴰⴼⵔⴰⵢ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵉⵜⵜⵛⵓⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS6_2","024_6_2","ISA","6","2","2","ⵜⵉⵡⴰ ⵏⵏⴻⵙ ⴱⴻⴷⴷⴻⵏ ⵉⵙⴰⵔⴰⴼⵉⵢⵢⴻⵏ, ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵉⵜⵜⴱⴰⵏⴻⵏ ⴰⵎ ⴷⴰⵢⵙⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ, ⵖⴰⵔⵙⴻⵏ ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ. ⵇⴰⵄ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ. ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵉⵍⴻⵃⵃⴻⴼ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵍⴻⵃⵃⴻⴼ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵓⵖⴰ ⵉⵟⵟⴰⵡ.    ");
INSERT INTO rift_vpl VALUES ("IS6_3","024_6_3","ISA","6","3","3","ⵉⵍⴰⵖⴰ ⵉⵊⵊ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⴰⵎⵇⴻⴷⴷⴰⵙ, ⴰⵎⵇⴻⴷⴷⴰⵙ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ!”, ");
INSERT INTO rift_vpl VALUES ("IS6_4","024_6_4","ISA","6","4","4","ⴰⵍⴰⵎⵉ ⵏⵀⴻⵣⵣⴻⵏ ⴷⵙⵓⵙⴰ ⵏ ⵜⵏⴻⴱⴷⴰⵜⵉⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵍⴰⵖⴰⵏ ⵓⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⴷⴷⴻⵅⵅⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS6_5","024_6_5","ISA","6","5","5","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: “ⵓⵛⵜ ⵅⴰⴼⵉ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵀⴻⵍⵍⴽⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵔⵢⴰⵣ ⴱⵓ-ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵅⴻⵎⵊⴻⵏ ⵓ ⵣⴻⴷⴷⵖⴻⵖ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵅⴻⵎⵊⴻⵏ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵥⵔⵉⵏⵜ ⴰⵊⴻⴵⵉⴷ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS6_6","024_6_6","ISA","6","6","6","ⵉⴹⵡⴰ-ⴷⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵙⴰⵔⴰⴼⵉⵢⵢⴻⵏ ⵖⴰⵔⵉ. ⵢⴰⵔⴱⵓ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴽⵙⵉ ⵙ ⵜⵊⴻⵇⵇⴰⴹⵜ ⵣⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS6_7","024_6_7","ISA","6","7","7","ⵏⴻⵜⵜⴰ ⵉⵃⴰⴷⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⵃⴰⴷⴰ ⵍⴻⴼⵀⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵡⴰⵏⵉⵜⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ. ⵜⴻⵎⵎⴻⴽⵙⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ ⵓ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵉ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("IS6_8","024_6_8","ISA","6","8","8","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵜⴻⵇⵇⴰⵔ: “ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵓ ⵡⵉ ⵖⴰ ⵢⵓⵢⵓⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⵡⴰⵔ ⵉ ⵏⴻⵛⵛⵉⵏ?” ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⵉⵖ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⵙⴻⴽⴽ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("IS6_9","024_6_9","ISA","6","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ ⵓⵛⴰ ⵜⵉⵏⵉⴷ ⵉ ⵍⴳⴻⵏⵙ-ⴰ: ‘ⵡⴰⵅⵅⴰ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵙ ⵜⴻⵢⵏⵉⵜ, ⵡⴰⵔ ⵜ ⵜⴼⴻⵀⵀⵎⴻⵎ!’, ⵓⵛⴰ: ‘ⵡⴰⵅⵅⴰ ⵜⴻⵥⵔⵉⵎ ⵎⵍⵉⵃ, ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⵎ!’ ");
INSERT INTO rift_vpl VALUES ("IS6_10","024_6_10","ISA","6","10","10","ⵙⴻⵇⵙⴻⵃ ⵓⵍ ⵏ ⵍⴳⴻⵏⵙ-ⴰ, ⵓⵛⴰ ⴱⴻⵍⵍⴻⵄ ⴰⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ, ⵙⴻⵍⵙⴻⵇ ⴰⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵎⴰⵃⴻⵏⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵓ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵓ ⵙ ⵡⵓⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS6_11","024_6_11","ISA","6","11","11","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⴰⵍ ⵎⴻⵍⵎⵉ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴰⵍ ⵉ ⵖⴰ ⵜⵜⵡⴰⵅⴰⵔⵔⴱⴻⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵓⵎⴻⵣⴷⵓⵖ, ⵓⵍⴰ ⴷ ⵜⵓⴷⵔⵉⵏ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⴱⵏⴰⴷⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("IS6_12","024_6_12","ISA","6","12","12","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵉⵡⴷⴰⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵅⵡⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS6_13","024_6_13","ISA","6","13","13","ⵎⴰⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ, ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵓ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵍⴱⴻⴵⵓⴹ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏⵜ ⵉ ⵖⴰ ⵣⴻⴷⵎⴻⵏ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵊⵊⴷⴻⵄ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵊⵊⴷⴻⵄ ⵏⵏⴻⵙ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⴰⵎⵇⴻⴷⴷⴻⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS7_1","024_7_1","ISA","7","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⵃⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵜⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⵔⴰⵚⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴰⵎ, ⴰⴽ-ⴷ ⴼⴰⵇⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙ ⵉⵖⴻⵍⵍⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("IS7_2","024_7_2","ISA","7","2","2","ⵓⵎⵉ ⵃⴰⵊⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⵀⵡⴰ ⴰⵔⴰⵎ ⵅ ⵉⴼⵔⴰⵢⵉⵎ!”, ⵢⴰⵔⵊⵉⵊ ⵡⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵡⵓⵍ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴰⵔⵊⵉⵊⵉⵏⵜ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ ⵙ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("IS7_3","024_7_3","ISA","7","3","3","ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵉⵛⴰⵄⵢⴰ: “ⴼⴼⴻⵖ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⴰⵃⴰⵣ, ⵛⴻⴽ ⴷ ⵎⵎⵉⵛ ⵛⴰ’ⴰⵔ-ⵢⴰⵛⵓⴱ, ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵓⵇⴰⴷⵓⵙ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵓⵢⴻⵍⵎⴰⵏ ⵏ ⵙⴻⵏⵏⴻⵊ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵢⵓⵄⵔⴰⵏ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵚⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS7_4","024_7_4","ISA","7","4","4","ⵉⵏⵉ ⴰⵙ: ‘ⵃⴹⴰ, ⴰⵔⵙ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵢⴰⵔⵅⵓ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴼⴹⴰⵡⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵉⴷⴷⵓⵅⵅⵓⵏⴻⵏ, ⵅ ⵓⵅⴻⵢⵢⴻⵇ ⵢⴰⵔⵖⵉⵏ ⵏ ⵔⴰⵚⵉⵏ ⴷ ⴰⵔⴰⵎ, ⵓ ⵏ ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ");
INSERT INTO rift_vpl VALUES ("IS7_5","024_7_5","ISA","7","5","5","ⵓⵎⵉ ⵉⵅⴰⵔⵔⴻⵚ ⴰⵔⴰⵎ ⴷⵉ ⵍⵖⴰⵔ ⵅⴰⴽ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS7_6","024_7_6","ISA","7","6","6","‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵏⴻⵙⵙⵉⴳⴳⵯⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵏⴻⴱⴹⴰ ⵊⴰⵔ ⴰⵏⴻⵖ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⴳⴳ ⴷⵉⵏⵏⵉ ⵎⵎⵉⵙ ⵏ ⵟⴰⴱⵢⵉⵍ ⴷ ⴰⵊⴻⴵⵉⴷ.’ ");
INSERT INTO rift_vpl VALUES ("IS7_7","024_7_7","ISA","7","7","7","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵎⵎⵙⴰⵔ ⵛⴰ!’ ");
INSERT INTO rift_vpl VALUES ("IS7_8","024_7_8","ISA","7","8","8","ⵎⴰⵖⴰⵔ ⴰⵣⴻⴵⵉⴼ ⵏ ⴰⵔⴰⵎ ⴷ ⴷⵉⵎⴰⵛⵇ ⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⴷⵉⵎⴰⵛⵇ ⴷ ⵔⴰⵚⵉⵏ - ⵡⴰⵅⵅⴰ ⴰⵎⵎⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵎⵖⵉⵔ ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵥ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵍ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⵍⴳⴻⵏⵙ - ");
INSERT INTO rift_vpl VALUES ("IS7_9","024_7_9","ISA","7","9","9","ⵓⵛⴰ ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ. ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⴰⵎ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS7_10","024_7_10","ISA","7","10","10","ⵢⴰⵔⵏⵉ ⵙⵉⴷⵉ ⵄⴰⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⴰⴽ-ⴷ ⴰⵃⴰⵣ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS7_11","024_7_11","ISA","7","11","11","“ⵜⵜⴰⵔ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⵜⴰⵔ ⵉ-ⵜⵜ ⵙⵡⴰⴷⴷⴰⵢ ⴷⵉ ⵔⴰⴵⴰⵖ ⵏⵉⵖ ⵜⵜⴰⵔ ⵉ-ⵜⵜ ⴷⵉⵏⵏⵉ ⵙⴻⵏⵏⴻⵊ ⴷⵉ ⵍⵓⵄⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS7_12","024_7_12","ISA","7","12","12","ⵎⴰⵛⴰ ⴰⵃⴰⵣ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜ ⵜⵜᵉⵜⵜⴰⵔⴻⵖ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜⵇⴻⴵⴰⴱⴻⵖ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS7_13","024_7_13","ISA","7","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵙⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴻⴷⴷ ⴰⴷ ⵜⴻⵙⵙⵉⵃⵍⴻⵎ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵉⵃⵍⴻⵎ ⵄⴰⵡⴻⴷ ⵓⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("IS7_14","024_7_14","ISA","7","14","14","ⵙ ⵓⵢⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵍⴻⵄⵍⴰⵎⴻⵜ. ⵅⵣⴰⵔ, ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⴰⴷ ⵜⴻⵢⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ, ⴰⴷ ⵜⴰⵔⵓ ⵎⵎⵉⵙ, ⴰⴷ ⴰⵙ ⵜⴻⴳⴳ ‘ⵄⵉⵎⵎⴰⵏⵓ-ⵉⵍ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ’. ");
INSERT INTO rift_vpl VALUES ("IS7_15","024_7_15","ISA","7","15","15","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵛⵛ ⵜⵔⵓⵙⵙⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⴰⵍ ⵖⴰ ⵉⴼⵜⴻⵏ ⴰⴷ ⵉⵏⴹⴰⵔ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵓ ⴰⴷ ⵉⵅⴹⴰⵔ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS7_16","024_7_16","ISA","7","16","16","ⵎⴰⵖⴰⵔ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⵙⴻⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵉⵏⴹⴰⵔ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵓ ⴰⴷ ⵉⵅⴹⴰⵔ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⴷ ⵜⴻⵅⵍⴰ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵣⵉ ⵛⴻⴽ ⵜᵉⵟⵟⴼⴻⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS7_17","024_7_17","ISA","7","17","17","ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵙⵉⴷⵉ ⵅⴰⴽ ⵓ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵓⵙⵙⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵉⴼⵔⴰⵢⵉⵎ ⵅ ⵢⴰⵀⵓⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS7_18","024_7_18","ISA","7","18","18","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵚⴻⴼⴼⴰⵔ ⵉⵥⴰⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵎⵉⵚⵔⴰ ⵓⵍⴰ ⴷ ⵜⵣⵉⵣⵡⴰ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS7_19","024_7_19","ISA","7","19","19","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵔⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ ⵓ ⴷⵉ ⵜⴻⵣⵣⵉⵢⵉⵏ ⵏ ⵍⴻⵊⵔⵓⴼ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⵃⴰⵔⵔⴰⵛ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ ⵏ ⵍⵡⴰⵔⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("IS7_20","024_7_20","ISA","7","20","20","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵙ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙ ⵉⵊⵊ ⵏ ⵍⵎⵓⵙⵙ ⵉ ⴷ ⵉⵛⵔⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⴷ ⵓⵛⵓⵡⵡⴰⴼ ⵅ ⵉⴹⴰⵔⴻⵏ ⵓⵍⴰ ⴷ ⵜⵎⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS7_21","024_7_21","ISA","7","21","21","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵔⴻⴱⴱⴰ ⵉⵛⵜ ⵏ ⵜⵄⴻⵊⵎⵉⵜ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("IS7_22","024_7_22","ISA","7","22","22","ⵙ ⵜⵢⴰⵡⴰⵏⵜ ⵏ ⵓⵖⵉ ⵉ ⵖⴰ ⵡⵛⴻⵏⵜ, ⴰⴷ ⵢⴻⵛⵛ ⵜⵔⵓⵙⵙⵉ. ⵜⵔⵓⵙⵙⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⴰⴷ ⵢⴻⵛⵛ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS7_23","024_7_23","ISA","7","23","23","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵎ ⵉ ⵅⴻⴼ ⴱⴻⴷⴷⴻⵏ ⴰⵍⴻⴼ ⵏ ⵜⵣⴰⵢⴰⵔⵉⵏ ⵉ ⵉⵙⴻⴽⴽⵡⴰⵏ ⴰⵍⴻⴼ ⵏ ⵍⴻⵡⵣⴰⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵉ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS7_24","024_7_24","ISA","7","24","24","ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⴷⵉⵏ ⵙ ⴼⵍⵉⵜⵛⴰ ⴷ ⵍⵇⴻⵡⵙ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS7_25","024_7_25","ISA","7","25","25","ⵓⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵙⴰⵡⵏⵉⵏ ⵏⵏⵉ ⵛⴰⵔⵔⵣⴻⵏ ⵙ ⵓⵍⵉⵣⵉⵎ, ⵡⴰⵔ ⴷⵉⵏ ⴷⴷ-ⵜⵜⴰⵙⴻⵏ ⵄⴰⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ. ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵔⴻⵏ ⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵄⴻⴼⵙⴻⵏ ⵡⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS8_1","024_8_1","ISA","8","1","1","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⴽⵙⵉ ⵜⴰⵍⵡⵉⵃⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⴰⵔⵉⴷ ⵅⴰⵙ ⵙ ⵍⴻⵇⵍⴻⵎ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵖⴰⵔⴻⵏ: ‘ⵣⵣⴰⵔⴷⴻⵜ ⵙ ⵜⴰⵣⵍⴰ, ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⴷⴻⵖⵢⴰ!’” ");
INSERT INTO rift_vpl VALUES ("IS8_2","024_8_2","ISA","8","2","2","ⵍⴻⵛⵀⵓⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵉⵡⵢⴻⵖ-ⵜⴻⵏ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ: ⴰⴽⴻⵀⵀⴰⵏ ⵓⵔⵉⵢⴰ ⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⴱⵔⴰⵅⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("IS8_3","024_8_3","ISA","8","3","3","ⵜⵓⵖⴰ ⵓⴷⴼⴻⵖ ⵅ ⵜⵏⴰⴱⵉⵜ ⵓ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⴻⴳⴳ ⴰⵙ: ‘ⵎⴰⵀⴰⵔ-ⵛⴰⵍⴰⵍ, ⵅⴰⵛ-ⴱⴰⵣ!’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵣⵣⴰⵔⴷⴻⵜ ⵙ ⵜⴰⵣⵍⴰ, ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⴷⴻⵖⵢⴰ!’ ");
INSERT INTO rift_vpl VALUES ("IS8_4","024_8_4","ISA","8","4","4","ⵎⴰⵖⴰⵔ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵍⵎⴻⴷ ⵓⵃⴻⵏⵊⵉⵔ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴱⴰⴱⴰ!’, ⵏⵉⵖ: ‘ⵢⴻⵎⵎⴰ!’, ⴰⴷ ⴽⴽⵙⴻⵏ ⴰⴳⵍⴰ ⵏ ⴷⵉⵎⴰⵛⵇ ⴷ ⵣⵣⴰⵔⴷⴻⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS8_5","024_8_5","ISA","8","5","5","ⵢⴰⵔⵏⵉ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⴰⴽⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS8_6","024_8_6","ISA","8","6","6","“ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵉⵙⵙⴻⵃⵇⴰⵔ ⴰⵎⴰⵏ ⵢⴰⵔⵙⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵏ ⵛⵉⵍⵓⵀⴰ, ⵙ ⵓⵢⴰ ⵉⴼⴰⵔⵃ ⵔⴰⵚⵉⵏ ⴷ ⵎⵎⵉⵙ ⵏ ⵔⴰⵎⴰⵍⵢⴰⵀⵓ. ");
INSERT INTO rift_vpl VALUES ("IS8_7","024_8_7","ISA","8","7","7","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵢⴰⵔⵔ ⴰⵎⴰⵏ ⵢⴻⵡⵄⴰⵔⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴻⵎⵍⴻⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⴷ ⵎⴰⵔⵔⴰ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ. ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵢⵉⵡⵉⵏ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴼⵉⵢ ⵜⵉⵡⴰ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵓⵡⵡⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS8_8","024_8_8","ISA","8","8","8","ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵜⵜ ⵉⵙⵙⵖⴰⵔⵇ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵣⵣⴻⵍ ⴰⵍ ⴷⴷ-ⴰⵙ ⵉ ⵖⴰ ⵢⴰⵡⴻⴹ ⴰⵍ ⵢⵉⵍⵉ. ⵅⵎⵉ ⵖⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴷⵍⴻⵏ ⵜⵉⵔⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ! ⴰ ⵄⵉⵎⵎⴰⵏⵓ-ⵉⵍ, ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS8_9","024_8_9","ISA","8","9","9","“ⵀⴰⵊⴰⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵛⴰ ⵄⴰⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵍⴻⴱⵣⴻⵎ! ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵡⵛⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ: ⵡⴰⵅⵅⴰ ⵜⵃⴻⵣⵣⵎⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵍⴻⴱⵣⴻⵎ, ⵡⴰⵅⵅⴰ ⵜⵃⴻⵣⵣⵎⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵍⴻⴱⵣⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("IS8_10","024_8_10","ISA","8","10","10","ⵎⵛⴰⵡⴰⵔⴻⵎ, ⵎⴰⵛⴰ ⴰⵎⵛⴰⵡⴰⵔ ⵏⵡⴻⵎ ⴰⴷ ⵉⴼⵛⴻⵍ! ⵉⵏⵉⵎ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ, ‘ⵄⵉⵎⵎⴰⵏⵓ-ⵉⵍ’.” ");
INSERT INTO rift_vpl VALUES ("IS8_11","024_8_11","ISA","8","11","11","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵅⴰⴼⵉ ⵉⵊⵀⴻⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵉⵄⵍⴻⵎ ⴰⵢⵉ ⵃⵉⵎⴰ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴳⴻⵏⵙ-ⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS8_12","024_8_12","ISA","8","12","12","“ⵡⴰⵔ ⵇⵇⴰⵔⴻⵎ ‘ⵜⴰⵎⴻⵄⵎⵓⵍⵜ!’ ⵉ ⵎⴰⵔⵔⴰ ⵓⵎⵉ ⵉⵇⵇⴰⵔ ⵍⴳⴻⵏⵙ-ⴰ ‘ⵜⴰⵎⴻⵄⵎⵓⵍⵜ!’ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵓ ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("IS8_13","024_8_13","ISA","8","13","13","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵜ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵏⵏⵅⴻⵍⵄⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS8_14","024_8_14","ISA","8","14","14","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴷ ⴰⵥⵔⵓ ⵏ ⵓⵏⴻⴷⵔⴰⴼ ⵓⵍⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵓⵏⴻⵇⵔⴰⴹ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷ ⵍⴼⴻⵅ ⴷ ⵜⵔⴰⵛⵛⴰ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS8_15","024_8_15","ISA","8","15","15","ⴰⵟⵟⴰⵙ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ, ⴰⴷ ⵡⴹⴰⵏ, ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴼⴻⵅ ⵓⵛⴰ ⴰⴷ ⵏⵏⴰⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS8_16","024_8_16","ISA","8","16","16","“ⵛⴼⴻⵏ ⵛⵛⵀⴰⴷⴻⵜ, ⵛⴻⵎⵎⴻⵄ ⵛⵛⴰⵔⵉⵄⴰ ⵊⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("IS8_17","024_8_17","ISA","8","17","17","“ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵊⵉⵖ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵍⴻⵃⵃⴼⴻⵏ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵅⴰⵙ ⵉ ⵖⴰ ⵜⴻⵛⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS8_18","024_8_18","ISA","8","18","18","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⵏⴻⵖ ⵏⴻⴵⴰ ⵉ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS8_19","024_8_19","ISA","8","19","19","“ⵎⴰⵍⴰ ⵏⵏⴰⵏ ⴰⵡⴻⵎ: ‘ⵙⴻⵇⵙⴰⵎ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴻⵙⵡⵉⵙⴻⵏ ⵓ ⵉⵜⵜⵡⴻⵛⵡⵉⵛⴻⵏ!’, ⵅⴻⵏⵏⵉ ⵉⵏⵉ: ‘ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ? ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⵉⵎⴻⵜⵜⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ?’” ");
INSERT INTO rift_vpl VALUES ("IS8_20","024_8_20","ISA","8","20","20","“ⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⵖⴰⵔ ⵛⵛⵀⴰⴷⴻⵜ! ⵎⴰⵍⴰ ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ-ⴰ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜᵉⵜⵜⵉⵍⵉ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵊⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS8_21","024_8_21","ISA","8","21","21","“ⴰⴷ ⵉⵏⵏⴻⴹ ⵍⴳⴻⵏⵙ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵛⴹⴻⵏ ⵓ ⵉⴵⵓⵣ, ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⴵⵓⵣ ⵓⵛⴰ ⵉⵅⴻⵢⵢⴻⵇ, ⴰⴷ ⵉⵏⵄⴻⵍ ⵍⴳⴻⵏⵙ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ⵎⴰ ⴰⴷ ⵅⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("IS8_22","024_8_22","ISA","8","22","22","ⵏⵉⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⴷⴰ ⵎⵖⵉⵔ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⵟⵟⵍⴰⵎ, ⵟⵟⵍⴰⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ. ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS8_23","024_8_23","ISA","8","23","23","“ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵟⵟⵍⴰⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵍⴻⵅⵅⵓ. ⵣⵉⵛ ⵢⵉⵡⵉ-ⴷⴷ ⵏⴻⵜⵜⴰ ⴰⵙⴻⵃⵇⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵣⴰⴱⵓⵍⵓⵏ ⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴰⵡⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵛⵛⴰⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ ⵏ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS9_1","024_9_1","ISA","9","1","1","“ⵍⴳⴻⵏⵙ ⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵉⵥⴰⵔ ⵜⴰⴼⴰⵡⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵜⵉⵡⴰ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ ⴰⴷ ⵜⴰⵔⴻⵖ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("IS9_2","024_9_2","ISA","9","2","2","ⵛⴻⴽ ⴰⴷ ⵜⴻⵎⵎⴰⵔⵏⵉⴷ ⴷⵉ ⵍⴳⴻⵏⵙ ⵓ ⴰⴷ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴻⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴼⴰⵔⵃⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵢⵔⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⵔⴻⵛⴳⴻⵏ ⵅⵎⵉ ⴱⴻⵟⵟⴰⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ... ");
INSERT INTO rift_vpl VALUES ("IS9_3","024_9_3","ISA","9","3","3","ⵎⴰⵖⴰⵔ ⴰⵣⴰⵢⵍⵓ ⵏ ⴷⴷⵇⴻⵍ ⵏⵏⴻⵙ ⴷ ⵡⴻⵄⵎⵓⴷ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ ⴷ ⵓⵣⴻⴵⴰⴹ ⵏ ⵓⵡⴻⵇⵇⴰⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜⴰⵔⵥⵉⴷ ⵜⴻⵏ ⴰⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵎⵉⴷⵢⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS9_4","024_9_4","ISA","9","4","4","ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⵍⴱⵓⵟⴰ ⵏⵏⵉ ⵢⵓⴷⴼⴻⵏ ⴷⴻⴳ ⵓⵣⴻⵀⵀⴰⵔ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⴽⵓⵍ ⴰⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⵉ ⵎⴰⵔⵖⴻⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵜⵎⴻⵙⵙⵉ, ");
INSERT INTO rift_vpl VALUES ("IS9_5","024_9_5","ISA","9","5","5","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵔⵓ ⴰⵏⴻⵖ-ⴷⴷ ⵓⵃⴻⵏⵊⵉⵔ, ⵉⵎⵎⴻⵡⵛ ⴰⵏⴻⵖ ⵎⵎⵉⵙ ⵓⵛⴰ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ ⵓ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ ⵉⵙⴻⵎ ⵏⵏⴻⵙ: ⵍⴻⵄⵊⴻⴱ, ⴰⵎⵛⴰⵡⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵉⵊⴻⵀⴷⴻⵏ, ⴱⴰⴱⴰⵙ ⵏ ⵍⴻⴱⴷⴰ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("IS9_6","024_9_6","ISA","9","6","6","ⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵓ ⵉ ⵍⴻⵀⵏⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵇⴻⵟⵟⵓ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵊⵀⴻⴷ ⵙ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ. ⴰⵛⴹⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵉⴳⴳ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS9_7","024_9_7","ISA","9","7","7","“ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵙⵙⴻⴽⴽ ⴰⵡⴰⵍ ⴹⵉⴷⴷ ⵉ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⵡⴹⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS9_8","024_9_8","ISA","9","8","8","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏ, ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⵓ ⵙ ⵡⵓⵍ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵓⴽⴻⴱⴱⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("IS9_9","024_9_9","ISA","9","9","9","‘ⵔⴻⵃⵢⵓⴹ ⵏ ⵍⵍⴰⵊⵓⵔ ⵡⴹⴰⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⴱⵏⴰ ⵄⴰⵡⴻⴷ ⵙ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ. ⵓⵔⵜⴰⵏ ⵏ ⵍⴻⵅⵍⴰ ⵜⵜⵡⴰⵣⴻⴷⵎⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵏⴻⵥⵥⵓ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("IS9_10","024_9_10","ISA","9","10","10","ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵙⵉⴷⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵏ ⵔⴰⵚⵉⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵀⵡⴻⵍ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS9_11","024_9_11","ISA","9","11","11","ⴰⵔⴰⵎ ⵣⵉ ⵛⵛⴰⵔⵇ ⵓ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵣⵉ ⴹⴻⴼⴼⴰⵔ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵚⴰⵔⴹⴻⵏ ⵉⵙⵔⴰⵉⵍ ⵇⴰⵄ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵙⴰⵔⵔⴻⵃ,    ");
INSERT INTO rift_vpl VALUES ("IS9_12","024_9_12","ISA","9","12","12","ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⴷⴷ-ⵉⴷⵉⴽⴽⵡⵉⵍ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵜ ⵉⵡⵜⵉⵏ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS9_13","024_9_13","ISA","9","13","13","“ⴰⴷ ⵉⵇⴻⵙⵙ ⵙⵉⴷⵉ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵣⴻⴵⵉⴼ ⴷ ⵓⴽⴻⵏⵏⴰⵙ, ⵜⴰⵙⴻⵟⵟⴰ ⵏ ⵜⵉⵏⵉ ⴷ ⵓⵖⴰⵏⵉⵎ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("IS9_14","024_9_14","ISA","9","14","14","ⴰⵡⴻⵙⵙⴰⵔ ⴷ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵛⵛⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⵣⴻⴵⵉⴼ, ⵓⵛⴰ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵏⴻⵜⵜⴰ ⴷ ⴰⴽⴻⵏⵏⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS9_15","024_9_15","ISA","9","15","15","ⵎⴰⵖⴰⵔ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴷ ⵉⵎⵖⴻⴽⴽⵯⴰⵢⴻⵏ ⵓ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵚⴰⵔⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS9_16","024_9_16","ISA","9","16","16","ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵉⴼⴰⵔⵔⴻⵃ ⵙⵉⴷⵉ ⵉⵏⵓ ⵅ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ, ⵓ ⵡⴰⵔ ⵢⴰⵔⴻⵃⵃⴻⵎ ⵅ ⵉⵢⵓⵊⵉⵍⴻⵏ ⴷ ⵜⴻⵊⵊⴰⵍ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵏⴰⴼⵇⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵓ ⴽⵓⵍ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵙⴰⵔⵔⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("IS9_17","024_9_17","ISA","9","17","17","“ⵎⴰⵖⴰⵔ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵜⴰⵔⴻⵇⵇ ⴰⵎ ⵜⵎⴻⵙⵙⵉ, ⵜᵉⵜⵜⴻⵜⵜ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ, ⵜⴻⵙⵙⵔⴻⵇⵇⴰ ⵉⵅⴻⵛⵛⴰⴱⴻⵏ ⵏ ⵡⴻⵣⵖⴰⵔ, ⴰⵍⴰⵎⵉ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⴷⵉ ⴷⴷⴻⵅⵅⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("IS9_18","024_9_18","ISA","9","18","18","ⵙ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵉⵙⵙⵇⵓⵙⴱⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵏ ⵜⵎⴻⵙⵙⵉ. ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵃⵉⵡⵉⵍ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS9_19","024_9_19","ISA","9","19","19","ⵡⴰⵅⵅⴰ ⴱⵏⴰⴷⴻⵎ ⵉⵏⴻⵀⵀⴻⵛ ⵖⴰⵔ ⵢⴻⴼⵓⵙ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴵⵓⵣ. ⵡⴰⵅⵅⴰ ⵉⵜⵜⴻⵜⵜ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⵡⴰⵔ ⵜⵜⵢⵉⵡⵉⵏⴻⵏ ⵏⵉⵜⵏⵉ. ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵙⴰⵔⴹ ⴰⵢⵙⵓⵎ ⵏ ⵓⵖⵉⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS9_20","024_9_20","ISA","9","20","20","ⵎⴰⵏⴰⵙⵙⴰ ⴰⴷ ⵉⵙⴰⵔⴹ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⵙⴰⵔⴹ ⵎⴰⵏⴰⵙⵙⴰ ⵓⵛⴰ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵎⵓⵏⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴹⵉⴷⴷ ⵉ ⵢⴰⵀⵓⴷⴰ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵙⴰⵔⵔⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("IS10_1","024_10_1","ISA","10","1","1","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵍⵓⵎⵓⵔⴰⵜ ⵉⵖⴻⵛⵛⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵉⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵜⵜⴹⴻⴵⴻⵏ ");
INSERT INTO rift_vpl VALUES ("IS10_2","024_10_2","ISA","10","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵃⴻⵢⵢⴷⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛⴰⵔⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵍⴰⵎⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵉⵊⵊⴰⵍ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵙⴻⵏ ⵓ ⵉⵢⵓⵊⵉⵍⴻⵏ ⴷ ⵜⴰⵢⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS10_3","024_10_3","ISA","10","3","3","ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵅⴻⴵⴻⵚ ⵓ ⵖⴰⵔ ⵓⵔⴻⴷⴷⴻⴵ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ? ⵡⵉ ⵖⴰⵔ ⵉ ⵖⴰ ⵜⴰⵔⴻⵡⵍⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴼⴻⵎ ⵜⵡⵉⵣⴰ ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵊⵊⴻⵎ ⴰⵄⵓⴵⵉ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("IS10_4","024_10_4","ISA","10","4","4","ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ ⵎⵖⵉⵔ ⴰⴷ ⵓⴹⴰⵔⴻⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵡⴰⵀⴰ ⵊⴰⵔ ⵉⵎⴻⵃⴱⴰⵙ ⵓ ⴰⴷ ⵡⴹⴰⵏ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ. ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵙⴰⵔⵔⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("IS10_5","024_10_5","ISA","10","5","5","“ⵓⵛⵜ ⵅ ⴰⵛⵛⵓⵔ, ⴰⵣⴻⴵⴰⴹ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⴰⵇⴰ ⴰⵙⵅⴻⴹ ⵉⵏⵓ ⴷ ⴰⵄⵎⵓⴷ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("IS10_6","024_10_6","ISA","10","6","6","ⴰⴷ ⵜ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵏⵏⵉⴼⴰⵇ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵓⵎⵓⵔⴻⵖ ⵅ ⵍⴳⴻⵏⵙ ⵉ ⵅ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵓⴼⵓⴳⴻⵎ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵛⴰⵔⴻⵏ ⵜⵓⴽⴽⴰⵔⴹⴰ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴽⴻⵛⵛⴹⴻⵏ ⵇⴰⵄ ⵓ ⴰⴷ ⵜ ⵄⴰⵔⵔⴰⵏ ⵉ ⵓⵏⴻⵄⴼⴰⵙ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵅ ⵉⵎⴻⵙⵔⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("IS10_7","024_10_7","ISA","10","7","7","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⴰⵎⵎⵓ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵎⵖⵉⵔ ⵍⴻⴽⵃⴻⴹ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴹⴰ ⵅ ⵍⴻⴳⵏⵓⵙ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS10_8","024_10_8","ISA","10","8","8","ⵎⴰⵖⴰⵔ ⵉⵇⵇⴰⵔ: ‘ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵏⵓ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵎⴰⵔⵔⴰ? ");
INSERT INTO rift_vpl VALUES ("IS10_9","024_10_9","ISA","10","9","9","ⵎⴰ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵉ ⴽⴰⵍⵏⵓ ⴰⵎⴻⵛⵏⴰⵡ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⴽⴰⵔⴽⴰⵎⵉⵛ? ⵎⴰ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵉ ⵃⴰⵎⴰⵜ ⴰⵎⴻⵛⵏⴰⵡ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⴰⵔⴼⴰⴷ? ⵎⴰ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵉ ⵙⴰⵎⴰⵔⵢⴰ ⴰⵎ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⴷⵉⵎⴰⵛⵇ? ");
INSERT INTO rift_vpl VALUES ("IS10_10","024_10_10","ISA","10","10","10","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⴼⵓⵙ ⵉⵏⵓ ⵉⵟⵟⴻⴼ ⵜⵉⴳⴻⵍⴷⴰⵡⵉⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⵉ ⵣⵉ ⵄⴷⵓⵏⵜ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵙⴰⵎⴰⵔⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("IS10_11","024_10_11","ISA","10","11","11","ⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ?’” ");
INSERT INTO rift_vpl VALUES ("IS10_12","024_10_12","ISA","10","12","12","“ⵎⴰⵛⴰ ⵅⵎⵉ ⵖⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵏⴻⵛⵛ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⴽⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵓⵍⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵔ ⵢⵓⴼⴼⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("IS10_13","024_10_13","ISA","10","13","13","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⴰⵢⴰ ⴳⴳⵉⵖ ⵜ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵙ ⵜⵉⵖⵉⵜ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵍⴻⵄⵇⴻⵍ. ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴽⴽⵙⴻⵖ ⵜⴻⵏ, ⵓ ⵍⴻⵄⵡⴰⵢⴻⴹ ⵏⵙⴻⵏ ⴽⴻⵛⵛⴹⴻⵖ ⵜⴻⵏ, ⵓ ⴰⵎ ⵊⵊⵉⵀⴻⵍ ⵖⴻⴹⵍⴻⵖ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS10_14","024_10_14","ISA","10","14","14","ⴰⵎ ⵍⵄⵓⵛⵛ, ⴰⵎⵎⵓ ⵢⵓⴼⴰ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⴳⵍⴰ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵊⴰⵔⵡⴻⵖ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵊⴰⵔⵡⴻⵏ ⵜⵉⵎⴻⴵⴰⵍⵉⵏ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⴻⵏⵀⴻⵣⵣⵉ ⴰⴼⵔⵉⵡⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⴰⵊⴻⵇⵎⵉⵎ ⵏⵉⵖ ⵉⵊⴰⵡ.’ ");
INSERT INTO rift_vpl VALUES ("IS10_15","024_10_15","ISA","10","15","15","ⵎⴰ ⵉⵜⵜⴼⴻⵢⵢⴻⵛ ⵛⵛⴰⵇⵓⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵛⴻⵇⵇⴰⵔⴻⵏ? ⵏⵉⵖ ⵉⵜⵜⵏⴻⴼⴼⴻⵅ ⵍⵎⴻⵏⵛⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵇⴻⵙⵙⴻⵏ? ⴰⵢⴰ ⵉⵍⵉ ⴰⵅⵎⵉ ⴰⵄⵎⵓⴷ ⵉⵜⵜⵃⴻⵏⵏⴻⴹ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵜ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⵏⵉⵖ ⴰⵅⵎⵉ ⴰⵄⵎⵓⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴱⴰⴱ ⵏⵏⴻⵙ ⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⴰⴽⴻⵛⵛⵓⴹ.” ");
INSERT INTO rift_vpl VALUES ("IS10_16","024_10_16","ISA","10","16","16","ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴱⵓ-ⴷⴻⴵⵉⵙ ⵊⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴱⴱⵓⵣⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵔⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⵙⴰⴷⵓ ⴰⵄⵓⴵⵉ ⵏ ⴰⵛⵛⵓⵔ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵃⴰⴷⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("IS10_17","024_10_17","ISA","10","17","17","ⵜⴰⴼⴰⵡⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⵉⵎⴻⵙⵙⵉ ⵓ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵄⵄⴰⵍ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵎⴹⴻⵏ ⵓ ⴰⴷ ⵜⴻⵛⵛ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("IS10_18","024_10_18","ISA","10","18","18","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴻⵛⵛ ⴰⵄⵓⴵⵉ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏⵏⴻⵙ ⵓ ⵏ ⵍⵄⵉⵔⵙⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵏⵏⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⴷ ⵡⴻⵢⵙⵓⵎ ⵉ ⴷⴰⵢⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵃⵍⵓⵛ ⵉⵜⵜⵔⴰⵃⴻⵏ ⵉⵖⴻⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("IS10_19","024_10_19","ISA","10","19","19","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵉⵊⵊ ⵏ ⵓⵃⵓⴷⵔⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵉⵃⵙⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("IS10_20","024_10_20","ISA","10","20","20","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⵜⵜⵄⴻⵎⵎⵉⴷⴻⵏ ⵄⴰⴷ ⵅ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵛⵛⴰⵜⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵄⴻⵎⵎⴻⴷ ⵉⵙⵔⴰⵉⵍ ⵅ ⵙⵉⴷⵉ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙ ⵍⴰⵎⴰⵏ ⵉⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS10_21","024_10_21","ISA","10","21","21","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS10_22","024_10_22","ISA","10","22","22","ⴰ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵅⵅⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⵎⵎⵓ ⵉⵡⵙⴻⵄ ⴰⵎ ⵢⵉⴵⵉ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵎⵖⵉⵔ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ. ⴰⴽⴻⵃⵃⴻⴹ ⴱⴰⵢⴻⵏ, ⵜⴰⵙⴻⴳⴷⴰ ⵜⴻⵡⵙⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("IS10_23","024_10_23","ISA","10","23","23","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⴷ ⵉⵇⴹⴰ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS10_24","024_10_24","ISA","10","24","24","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⵉ ⴰⵛⵛⵓⵔ ⵅⵎⵉ ⵛⴻⴽ ⵉⵛⵛⴰⵜ ⵙ ⵓⵣⴻⴵⴰⴹ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵅⴰⴽ ⴰⵄⵎⵓⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵙⴰⵔ ⴷⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS10_25","024_10_25","ISA","10","25","25","ⵎⴰⵖⴰⵔ ⵄⴰⴷ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴽⵓⵍ ⵡⴻⵙⵅⴻⴹ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵅ ⵓⵔⴻⴷⴷⴻⴵ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS10_26","024_10_26","ISA","10","26","26","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵉⵃⴻⵏⵏⴻⴹ ⵜⵉⵡⴰ ⵏⵏⴻⵙ ⴰⵔⴻⴽⴽⵓⴹ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵡⵜⴰ ⵎⵉⴷⵢⴰⵏ ⵖⴰⵔ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵖⵓⵔⴰⴱ. ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵙⵡⵉⵥⵥⴰⴹ ⵜⵉⵡⴰ ⵉ ⵍⴻⴱⵃⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴷⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS10_27","024_10_27","ISA","10","27","27","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵡⴹⴰ ⵍⴻⵃⵎⴻⵍ ⵏ ⴰⵛⵛⵓⵔ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵛ ⵓ ⵜⴰⵖⵏⴰⵛⵜ ⵏⵏⴻⵙ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵛ. ⴰⵣⴰⵢⵍⵓ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴻⵟⵟⴻⵍ ⵙ ⵉⵊⵉⵎⴰⵏ ⵏⵏⵉ ⵉⵚⴻⵃⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS10_28","024_10_28","ISA","10","28","28","“ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵄⴰⵢⵢⴰⵜ, ⵉⵄⴷⵓ ⵅ ⵎⵉⵊⵔⵓⵏ, ⵉⵙⵙⴰⵔⵙ ⴷⴷⵓⵣⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵎⵉⵅⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("IS10_29","024_10_29","ISA","10","29","29","ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⵓⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵅ ⵉⴷⵓⵔⴰⵔ, ⴰⴷ ⵙⵙⴻⵏⵙⴻⵏ ⴷⵉ ⵊⴰⴱⴰⵄ. ⵔⴰⵎⴰ ⵜᵉⵜⵜⴰⵔⵊⵉⵊⵉ, ⵜⴰⵔⵡⴻⵍ ⵊⵉⴱⵄⴰ ⵏ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("IS10_30","024_10_30","ISA","10","30","30","ⵙⵖⵓⵢⵢ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵊⴰⵍⵍⵉⵎ! ⴰⵔⵔ ⵍⴱⴰⵍ, ⵍⴰⵢⵛⴰ, ⴰ ⵛⴻⵎ ⵄⴰⵏⴰⵜⵓⵜ, ⵎⴻⵙⴽⵉⵏⴰ! ");
INSERT INTO rift_vpl VALUES ("IS10_31","024_10_31","ISA","10","31","31","ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵎⴰⴷⵎⵉⵏⴰ ⵜⴰⵔⵡⴻⵍ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵉⴱⵉⵎ ⴼⴼⵖⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴼⴻⵏ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS10_32","024_10_32","ISA","10","32","32","ⴰⵙⵙ-ⴰ ⵄⴰⴷ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⵉ ⵏⵓⴱ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵖⴰⵔ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS10_33","024_10_33","ISA","10","33","33","“ⵅⵣⴰⵔ, ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⴷ ⵉⵇⴻⵙⵙ ⵍⴻⴼⵔⵓⵄ ⵙ ⵓⵖⵉⵍ. ⵉⵏⵏⵉ ⵙ ⵜⵉⴷⴷⵉ ⵢⵓⵄⵍⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵣⴻⴷⵎⴻⵏ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS10_34","024_10_34","ISA","10","34","34","ⵛⴱⴰⵔⵇ ⵏ ⵡⴻⵣⵖⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵙ ⵡⵓⵣⵣⴰⵍ ⵓⵛⴰ ⵍⵓⴱⵏⴰⵏ ⴰⴷ ⵉⵡⴹⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS11_1","024_11_1","ISA","11","1","1","“ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵜⵙⴻⵟⵟⴰ ⵣⵉ ⵊⵊⴷⴻⵄ ⵏ ⵢⴰⵙⵙⴰ ⵓ ⵜⴰⵖⴻⴷⴷⵓⵜ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵉ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS11_2","024_11_2","ISA","11","2","2","ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵙⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ, ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⵄⵇⴻⵍ, ⴰⵔⵔⵓⵃ ⵏ ⵛⵛⵡⴰⵔ ⴷ ⵊⵊⴻⵀⴷ, ⴰⵔⵔⵓⵃ ⵏ ⵜⵓⵙⵙⵏⴰ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS11_3","024_11_3","ISA","11","3","3","ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵉⵛⴰⵔⵔⴻⵄ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵜⵜⵡⴰⵍⴰⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵃⴻⴽⴽⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵜⵜⴻⵙⵍⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS11_4","024_11_4","ISA","11","4","4","ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵓ ⴰⴷ ⵉⵃⴽⴻⵎ ⵉⵎⵡⴰⴹⵄⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵍⵃⴻⵇⵇ, ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵜ ⵉⵡⵡⴻⵜ ⵙ ⵓⵣⴻⴵⴰⴹ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓ ⵙ ⵓⵙⵓⴹⵉ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴰⴷ ⵉⵏⴻⵖ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS11_5","024_11_5","ISA","11","5","5","ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⴰⴱⵢⴰⵙ ⵏ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⵓ ⵜⵉⴷⴻⵜⵜ ⴷ ⴰⴱⵢⴰⵙ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS11_6","024_11_6","ISA","11","6","6","ⴰⴷ ⵉⵣⴷⴻⵖ ⵡⵓⵛⵛⴻⵏ ⵖⴰⵔ ⵉⵣⵎⴰⵔ, ⴰⵖⵉⵔⴰⵙ ⴰⴷ ⵉⵊⴻⵏ ⵖⴰⵔ ⵉⵖⴰⵢⴹ ⴰⵎⴻⵥⵢⴰⵏ. ⴰⵄⴻⵊⵎⵉ ⴷ ⵡⴰⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵍⵎⴰⵍ ⵉⵚⴻⵃⵃⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵎⵓⵏⴻⵏ ⵓⵛⴰ ⴰⵃⴻⵏⵊⵉⵔ ⴰⵎⴻⵥⵢⴰⵏ ⴰⴷ ⵜⴻⵏ ⵉⵏⴷⴻⵀ.    ");
INSERT INTO rift_vpl VALUES ("IS11_7","024_11_7","ISA","11","7","7","ⵜⴰⴼⵓⵏⴰⵙⵜ ⴷ ⴷⴷⵓⴱ ⴰⴷ ⵀⴷⴰⵏ ⵊⵎⵉⵄ, ⵓⵛⴰ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵊⵏⴻⵏ ⵖⴰⵔ ⵡⴰⵢⴰⵡⵢⴰ ⵓⵛⴰ ⴰⵢⵔⴰⴷ ⴰⴷ ⵢⴻⵛⵛ ⵍⵓⵎ ⴰⵎ ⵓⴼⵓⵏⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS11_8","024_11_8","ISA","11","8","8","ⴰⵃⴹⵉⴹ ⴰⴷ ⵢⴰⵔⵔ ⵎⴻⵣⵍⵉ ⵣⵣⴰⵜ ⵉ ⵡⴻⵅⴱⵓⵛ ⵏ ⵜⵍⴻⴼⵙⴰ ⵓ ⴰⵏⵉⴱⵓ ⵉ ⴽⴽⵙⴻⵏ ⵣⴻⴳ ⵓⵟⵟⵓⴹ, ⴰⴷ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⵔⵣⴰⵎ ⵏ ⵜⴼⴰⵡⵜ ⵏ ⵡⴻⵃⴼⵓⵔ ⵏ ⵓⴼⵉⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS11_9","024_11_9","ISA","11","9","9","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵔⴻⴷⴷⴻⴵ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⵍⴻⵏ ⵡⴰⵎⴰⵏ ⵜⵉⵙⵉ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS11_10","024_11_10","ISA","11","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⴱⴻⴷⴷ ⵡⴻⵥⵡⴰⵔ ⵏ ⵢⴰⵙⵙⴰ ⴰⵎ ⵜⵄⴻⴵⴰⵏⵜ ⵉ ⵡⴻⵢⴷⵓⴷⴻⵏ. ⵖⴰⵔⴻⵙ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵉⵛⴻⵡⵡⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS11_11","024_11_11","ISA","11","11","11","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵍⵍⴻⴽ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵣⵉ ⴰⵛⵛⵓⵔ, ⵎⵉⵚⵔⴰ, ⴼⴰⵜⵔⵓⵙ, ⴽⵓⵛ, ⵄⵉⵍⴰⵎ, ⵛⵉⵏⵄⴰⵔ ⴷ ⵃⴰⵎⴰⵜ ⵓ ⵣⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS11_12","024_11_12","ISA","11","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵉⵊⴰⵔⵡ ⵄⴰⵡⴻⴷ ⵉⵎⴻⵏⵏⴻⵄⵔⴰⵇ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS11_13","024_11_13","ISA","11","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳⵯⴻⵊ ⵡⴰⵙⴰⵎ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵉⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ. ⵉⴼⵔⴰⵢⵉⵎ ⵡⴰⵔ ⵉⵜⵜⵉⵙⴻⵎ ⵄⴰⴷ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵢⴰⵀⵓⴷⴰ ⵡⴰⵔ ⵉⵃⴻⵚⵚⴰⵔ ⵄⴰⴷ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS11_14","024_11_14","ISA","11","14","14","ⴰⴷ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⴰⵅⵎⵉ ⵟⵟⴰⵡⴻⵏ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵎⵓⵏⴻⵏ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ. ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵎ ⴷ ⵎⵓ’ⴰⴱ ⵓⵛⴰ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴰⴷ ⴰⵙⴻⵏ ⵟⵟⴰⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS11_15","024_11_15","ISA","11","15","15","ⴰⴷ ⵉⵃⴰⵔⵔⴻⵎ ⵙⵉⴷⵉ ⵉⵍⴻⵙ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵙ ⵓⵃⴰⴷⵓⵇ ⵏ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵜ ⵉⵡⵡⴻⵜ ⴰⵍ ⵖⴰ ⵉⴷⵡⴻⵍ ⵙⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ, ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵔ ⴰⵇⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⴽⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵙ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS11_16","024_11_16","ISA","11","16","16","ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⴰⵛⵛⵓⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴵⴰ ⵡⴻⴱⵔⵉⴷ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS12_1","024_12_1","ISA","12","1","1","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵜⵓⵖⴰ ⵛⴻⴽ ⵜⵅⴻⵢⵢⵇⴻⴷ ⵅⴰⴼⵉ, ⵎⴰⵛⴰ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓ ⵛⴻⴽ ⵜⴻⵙⵙⴼⴻⵡⵡⴰⵊⴻⴷ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("IS12_2","024_12_2","ISA","12","2","2","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⵜⵜⴻⵛⵍⴻⵖ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵖ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵊⵊⴻⵀⴷ ⴷ ⵓⵣⴻⵀⵀⵉⴷ ⵉⵏⵓ, ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴰⵢⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("IS12_3","024_12_3","ISA","12","3","3","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵢⵎⴻⵎ ⴰⵎⴰⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵉ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵓⵙⴻⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS12_4","024_12_4","ISA","12","4","4","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵇⴰⴷⴰⵎ ⵉ ⵙⵉⴷⵉ, ⵍⴰⵖⴰⵎ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵙⴻⵛⵏⴻⵎ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴱⴰⵔⵔⵃⴻⵎ ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵄⵓⴵⴰ! ");
INSERT INTO rift_vpl VALUES ("IS12_5","024_12_5","ISA","12","5","5","ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ⴻⵊⵊ ⴰⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS12_6","024_12_6","ISA","12","6","6","ⵙⵍⵉⵡⵍⴻⵡ ⵓ ⵖⴻⵏⵏⴻⵊ, ⴰ ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵎⵉⵏⵣⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("IS13_1","024_13_1","ISA","13","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⴱⴰⴱⵉⵍ ⵏⵏⵉ ⵉⵥⵔⴰ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ. ");
INSERT INTO rift_vpl VALUES ("IS13_2","024_13_2","ISA","13","2","2","“ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵅ ⵡⴻⴷⵔⴰⵔ ⴰⵇⴻⵛⵛⴰⵔ, ⵙⵖⵓⵢⵢⴻⵎ ⵖⴰⵔⵙⴻⵏ, ⵛⴻⵢⵢⴰⵔⴻⵎ ⵙ ⵓⴼⵓⵙ ⴰⵇⴰ ⴰⴷ ⴰⴷⴼⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ!” ");
INSERT INTO rift_vpl VALUES ("IS13_3","024_13_3","ISA","13","3","3","“ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⵅ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵏⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⵉⵏⵏⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵅ ⵍⵄⴰⴹⴰⵎⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS13_4","024_13_4","ISA","13","4","4","“ⴰⵇⴰ ⵣⵣⵀⵉⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵉⴷⵓⵔⴰⵔ, ⴰⵎ ⵏ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵖⴰⵔ, ⵍⵃⴻⵙⵙ ⵏ ⴷⴷⵔⵉⵣ ⵏ ⵜⴳⴻⵍⴷⴰⵡⵉⵏ, ⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵎⵓⵏⴻⵏ. ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵙⴻⴷⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS13_5","024_13_5","ISA","13","5","5","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ, ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵙⵉⴷⵉ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵔⵔⴱⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS13_6","024_13_6","ISA","13","6","6","“ⵙⵖⵓⵢⵢⴻⵎ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⵢⵓⴷⴻⵙ-ⴷⴷ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵎ ⵓⵔⴻⴷⴷⴻⴵ ⵣⴻⴳ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("IS13_7","024_13_7","ISA","13","7","7","ⵅ ⵓⵢⴰ ⴷⴻⵡⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴼⴰⵙⵙⴻⵏ ⴼⴻⵛⵍⴻⵏ ⵓ ⵡⵓⵍ ⵏ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵉⴼⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("IS13_8","024_13_8","ISA","13","8","8","ⵏⵉⵜⵏⵉ ⵏⵏⵅⴻⵍⵄⴻⵏ, ⵉⵍⴻⵇⵇⴻⴼ ⵉ-ⵜⴻⵏ ⵡⴻⵖⵏⴰⵙ ⴷ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ, ⵜⵜⵏⴻⵣⴱⴰⵔⴻⵏ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵓⵏ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⴳⴳⵉⵏ ⴰⵎ ⵢⵉⵛⴻⵄⵄⴰⵍⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS13_9","024_13_9","ISA","13","9","9","“ⵅⵣⴰⵔ, ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵉⵡⵄⴰⵔⴻⵏ ⵓ ⵙ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵔ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵎⵃⴰ ⵉⵎⴻⴷⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("IS13_10","024_13_10","ISA","13","10","10","ⵎⴰⵖⴰⵔ ⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵉⵡⵔⴰⴼⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏ ⵄⴰⴷ ⵜⴰⴼⴰⵡⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⴰⵔⵖ, ⵜⴰⴼⵓⵛⵜ ⴰⴷ ⵜⴻⴱⴱⴰⵔⵛⴻⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⵏⵇⴰⵔ, ⵓⵛⴰ ⵜⴰⵣⵉⵔⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵄⴰⴷ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵛⴻⵄⵛⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("IS13_11","024_13_11","ISA","13","11","11","ⵎⴰⵖⴰⵔ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⵓ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⵓ ⴰⴷ ⵙⵙⴻⵀⵡⵉⵖ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS13_12","024_13_12","ISA","13","12","12","ⴰⴷ ⴰⵔⵔⴻⵖ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⵉⵍⵉ ⵉⵖⵍⴰ ⵅ ⵡⵓⵔⴻⵖ ⴰⵣⴷⴰⴷ, ⵓⵍⴰ ⴷ ⴱⵏⴰⴷⴻⵎ ⵅ ⵡⵓⵔⴻⵖ ⵉⵖⵍⴰⵏ ⵣⵉ ⵓⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("IS13_13","024_13_13","ISA","13","13","13","ⵅ ⵓⵢⴰ ⴰⴷ ⵙⵙⴰⵔⵊⵉⵊⴻⵖ ⵉⵊⴻⵏⵡⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣ ⵜⴻⵎⵎⵓⵔⵜ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵓ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS13_14","024_13_14","ISA","13","14","14","“ⴰⵎ ⵜⵖⴰⵢⴹⴻⵜ ⵏ ⵡⴻⵣⵖⴰⵔ ⵉⵏⵊⴻⵔⴼⴻⵏ, ⴰⵎ ⵡⵓⴵⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⴽⵙⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵏⵉⵜⵏⵉ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS13_15","024_13_15","ISA","13","15","15","ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴻⵏ, ⴰⴷ ⵅⴰⵙ ⵛⵓⵇⴻⵏ, ⵓ ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵟⵟⴼⴻⵏ, ⴰⴷ ⵉⵡⴹⴰ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("IS13_16","024_13_16","ISA","13","16","16","ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏⵜ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS13_17","024_13_17","ISA","13","17","17","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⵃⴰⵔⵔⵛⴻⵖ ⵉⵎⴰⴷⵉⵢⵢⴻⵏ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵛⵇⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵖⴰⵔⵙⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵔⴻⵖ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("IS13_18","024_13_18","ISA","13","18","18","ⵍⴻⵇⵡⴰⵙ ⵏⵙⴻⵏ ⴰⴷ ⵅⴰⵔⵔⴳⴻⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ, ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵏ ⵛⴰ ⵅ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ, ⵓ ⵜⵉⵟⵟ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜᵉⵜⵜⵣⵉⴵⵉⵣ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS13_19","024_13_19","ISA","13","19","19","ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ, ⵜⴰⵍⵡⵉⵣⵜ ⵊⴰⵔ ⵜⴳⴻⵍⴷⴰⵜⵉⵏ, ⵜⴻⵏⵏⵉ ⴷ ⵍⵄⴻⵣⵣ ⴷ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS13_20","024_13_20","ISA","13","20","20","ⵉ ⵍⴻⴱⴷⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵣⴻⴷⴷⵖⴻⵏ ⵄⴰⴷ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ⴰⵄⵔⴰⴱ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵉⵛⵛⵉⵜ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⵄⴰⴷ ⵓ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏ ⴰⴷ ⵜⴰⵔⴻⵢⵢⴻⵃ ⴷⵉⵏ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵙⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("IS13_21","024_13_21","ISA","13","21","21","ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⴰⴷ ⵣⵣⵍⴻⵏ ⴷⵉⵏⵏⵉ ⵓ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵎⵓⴽⴰⵜ, ⵢⴻⵙⵙⵉⵙ ⵏ ⵏⵏⵄⴰⵎⴻⵜ ⴰⴷ ⵣⴻⴷⵖⴻⵏⵜ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⵉⵎⵓⵢⴰⵏ ⵉⵊⴻⵏⵏⴻⵏ ⴰⴷ ⴷⵉⵏⵏⵉ ⵏⴻⴳⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS13_22","024_13_22","ISA","13","22","22","ⴰⴷ ⵙⵙⵎⵉⵄⵄⵉⵡⴻⵏ ⵉⴼⵉⵙⴻⵏ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ ⵏ ⴱⴰⴱⵉⵍ ⵓⵍⴰ ⴷ ⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏ ⵍⴻⵀⵣⵓⵟ. ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴻⴹ ⴷⴻⵖⵢⴰ ⵓ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS14_1","024_14_1","ISA","14","1","1","“ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⵉⵏⵏ ⵅ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⴰⴷ ⵉⴼⴰⵔⵣ ⵉⵙⵔⴰⵉⵍ ⵄⴰⴷ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵍⵀⵓⴷⵏⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ⴰⴱⴰⵔⵔⴰⵏⵉ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵉⵎⵓⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("IS14_2","024_14_2","ISA","14","2","2","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⴷⴼⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⵏ ⵜᵉⵟⵟⴻⴼ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵢⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ. ⴰⴷ ⵃⴻⴱⴱⵙⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵅ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS14_3","024_14_3","ISA","14","3","3","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⵙⵉⴷⵉ ⵣⵉ ⵍⴻⵃⵔⵉⵇ ⵏⵏⴻⵛ, ⵣⴻⴳ ⵓⵏⴻⵅⵍⵉⵄ ⵏⵏⴻⵛ ⵓ ⵣⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵛ ⵉⵇⴻⵙⵃⴻⵏ ⵉ ⵣⵉ ⴳⴳⵉⵏ ⴰⴷ ⴰⵙⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("IS14_4","024_14_4","ISA","14","4","4","ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴰⵎⴻⵜⵜⵉⵍ-ⴰ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴱⴻⴷⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵇⴹⴰ ⵍⴻⵇⵙⴰⵃⴻⵜ?’ ");
INSERT INTO rift_vpl VALUES ("IS14_5","024_14_5","ISA","14","5","5","ⵢⴰⵔⵥⴰ ⵙⵉⴷⵉ ⴰⵄⵎⵓⴷ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⵣⴻⴵⴰⴹ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ, ");
INSERT INTO rift_vpl VALUES ("IS14_6","024_14_6","ISA","14","6","6","ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵍⴻⴳⵏⵓⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵙ ⵜⵉⵢⵢⵉⵜⴰ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵍⴻⴳⵏⵓⵙ ⵙ ⵡⴻⵖⴹⴰⴱ, ⵉⴹⴰⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ ⴱⵍⴰ ⴰⵣⵉⴵⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("IS14_7","024_14_7","ISA","14","7","7","ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴰⵔⵙⴰ, ⵜⴻⵙⵇⴰⵔ. ⵅⴻⵏⵏⵉ ⴷⵓⵇⵇⵓⵣⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS14_8","024_14_8","ISA","14","8","8","ⵓⵍⴰ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵔⵣⵉ ⴼⴰⵔⵔⵃⴻⵏⵜ ⵣⵣⴰⵢⴻⴽ ⵓ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵇⵇⴰⵔⴻⵏⵜ: ‘ⵣⴻⴳ ⵡⴰⵎⵉ ⵛⴻⴽ ⵜⵎⴻⴷⴷⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⴷⴰ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵄⴰⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⵥ!’” ");
INSERT INTO rift_vpl VALUES ("IS14_9","024_14_9","ISA","14","9","9","“ⵍⴰⵅⴰⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⴻⴽ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ. ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵙⵙⴼⴰⵇ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ, ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵜⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵍⴻⴽⵔⴰⵙⵉ ⵏⵙⴻⵏ ⵉⴳⴻⵍⵍⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS14_10","024_14_10","ISA","14","10","10","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: ‘ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵜⴷⴻⵡⵍⴻⴷ ⵜⴰⵔⴻⵀⴼⴻⴷ, ⴰⵎ ⵏⴻⵛⵛⵉⵏ, ⵍⴻⵅⵅⵓ ⵛⴻⴽ ⵜⴰⵔⴻⵡⵙⴻⴷ ⴷⴰⵢⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("IS14_11","024_14_11","ISA","14","11","11","ⴰⵇⴰ ⵜⵎⴻⵏⴹⴰⵔ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵛ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵍⵃⴻⵙⵙ ⵏ ⵍⵀⴰⵔⴱⴰⵜ ⵏⵏⴻⵛ. ⵙⴰⴷⵓ ⵏⵏⴻⵛ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵉⵡⴻⴽⴽⵉⵡⴻⵏ ⴰⵎ ⵍⴻⵎⵜⴰⵃ, ⵓ ⵉⴽⴻⵛⵛⴰⵡⴻⵏ ⴷ ⵎⴰⵍⵜⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS14_12","024_14_12","ISA","14","12","12","ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵡⴹⵉⴷ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵛⴻⴽ, ⴰ ⵢⵉⵜⵔⵉ ⵏ ⵍⴻⴼⵊⴰⵔ ⵉⵜⵜⵙⴻⵇⵙⵉⵇⴻⵏ, ⵎⵎⵉⵙ ⵏ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⵃⴰⵍ! ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵔⵥⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵛⴻⴽ ⴰⵎⴰⵔⵏⵉⵡ ⵏ ⵍⴻⴳⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("IS14_13","024_14_13","ISA","14","13","13","ⵜⴻⵏⵏⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵄⴰⵔⵛ ⵉⵏⵓ ⵜⵉⵡⴰ ⵉ ⵢⴻⵜⵔⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵓⵎⵓⵏⵉ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ ⵏ ⵛⵛⴰⵎⴰⵍ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("IS14_14","024_14_14","ISA","14","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵡⴰ ⵏ ⵜⵇⵉⵛⵛⴰⵜⵉⵏ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⴰⴷ ⴰⵔⵡⵙⴻⵖ ⴷⴻⴳ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ!’ ");
INSERT INTO rift_vpl VALUES ("IS14_15","024_14_15","ISA","14","15","15","ⵍⵍⴰ, ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵙⵙⴻⵀⵡⴰⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⴷⵉ ⵍⴰⴵⴰⵖ ⵇⴰⵄ ⵏ ⵡⴰⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS14_16","024_14_16","ISA","14","16","16","ⵉⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵥⴰⵔⴻⵏ, ⴰⴷ ⴷⴰⵢⴻⴽ ⵊⵄⴰⵔⴻⵏ, ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⴰ ⵡⴰ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵙⵙⴰⵔⵊⵉⵊⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵡⴻⵏⵏⵉ ⵉⵊⵊⵉⵏ ⵜⵉⴳⴻⵍⴷⵉⵏ ⴰⴷ ⵏⵀⴻⵣⵣⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("IS14_17","024_14_17","ISA","14","17","17","ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⵅⵓⵏ ⵉ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⴻⵙ ⴰⴷ ⴰⵔⴻⴽⴽⵯⴻⵃⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("IS14_18","024_14_18","ISA","14","18","18","ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵣⵣⵍⴻⵏ ⴷⵉⵏ ⴷⵉ ⵛⵛⴰⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS14_19","024_14_19","ISA","14","19","19","ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵎⴻⵏⴹⴰⵔⴻⴷ, ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⵛⴻⴽ ⵅ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵛ, ⴰⵎ ⵉⵛⵜ ⵏ ⵏⵏⵄⵉ ⵏ ⵜⵖⴻⴷⴷⵓⵜ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵜⵜ, ⵙⵙⴷⵓⵔⵢⴻⵏ ⵜⵜ ⵙ ⵉⵎⴻⵜⵜⴰⵏ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰⵏ ⵖⴰⵔ ⵉⵥⵔⴰ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵡⴻⵏⴹⴻⵍ, ⴰⵎ ⵍⵅⴻⵛⴱⴻⵜ ⵉ ⵅ ⵄⴻⴼⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS14_20","024_14_20","ISA","14","20","20","ⵡⴰⵔ ⵜⴻⵎⵎⴰⵔⵙⴻⴷ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵅⴰⵔⵔⴱⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⴻⵏⵖⵉⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵉⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS14_21","024_14_21","ISA","14","21","21","ⵙⵡⴻⵊⴷⴻⵎ ⵟⵟⴰⴱⵍⴰ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵏ ⵄⴰⴷ, ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("IS14_22","024_14_22","ISA","14","22","22","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴽⴽⴰⵔⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵣⵉ ⴱⴰⴱⵉⵍ ⴽⵓⵍ ⵉⵙⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⵎ ⵎⵎⵉⵙ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵎⵎⵉⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS14_23","024_14_23","ISA","14","23","23","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴱⴰⴱⵉⵍ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⵡⵓⵛⵜ ⵏ ⴵⵉⵍⴻⵜ ⵓⵍⴰ ⴷ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ. ⴰⴷ ⵜⴻⵏ ⵎⵃⵉⵖ ⵙ ⵜⵎⴻⴷⵡⴰⵙⵜ ⵏ ⵓⵔⴻⴷⴷⴻⴵ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS14_24","024_14_24","ISA","14","24","24","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵊⵊⵓⴵ, ⵉⵏⵏⴰ “ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵉ ⵜⵜ ⵅⴰⵔⵔⵚⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵉ ⵜⵜ ⵓⵔⵉⵖ, ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS14_25","024_14_25","ISA","14","25","25","ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵛⵛⵓⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵓ ⴰⴷ ⵅⴰⵙ ⵄⴻⴼⵙⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⵣⴰⵢⵍⵓ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴽⵙⵉ ⵓ ⵍⴻⵃⵎⴻⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⵡⴹⴰ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS14_26","024_14_26","ISA","14","26","26","ⵡⴰ ⴷ ⴰⵛⴰⵡⴰⵔ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵡⴰ ⴷ ⴰⴼⵓⵙ ⵉ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS14_27","024_14_27","ISA","14","27","27","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵅⴰⵔⵔⴻⵚ ⴰⵢⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⴱⴹⴻⵍ? ⴰⵇⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵙⵙⵡⵉⵥⵥⴰⴹ ⵉ-ⵜ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵢⴰⵔⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ?” ");
INSERT INTO rift_vpl VALUES ("IS14_28","024_14_28","ISA","14","28","28","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏ ⴰⵃⴰⵣ, ⵢⵓⵙⴰ-ⴷⴷ ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵡⴰⵏⵉⵜⴰ: ");
INSERT INTO rift_vpl VALUES ("IS14_29","024_14_29","ISA","14","29","29","“ⵡⴰⵔ ⴼⴰⵔⵔⴻⵃ, ⴰ ⵛⴻⵎ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴼⵉⵍⵉⵛⵉⵜ, ⴰⵇⴰ ⴰⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵛⴻⵎ ⵉⵡⵜⵉⵏ, ⵉⵜⵜⵡⴰⵔⵥ, ⵎⴰⵖⴰⵔ ⵣⴻⴳ ⵡⴻⵥⵡⴰⵔ ⵏ ⵓⴼⵉⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓⵔⴻⴼⵙⵉⵡ ⴰⵎⴻⵙⵎⵓⵎ ⵓ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵃⴰⵢⵛⴻⵜ ⵉⵛⴻⵎⴹⴻⵏ ⵉⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS14_30","024_14_30","ISA","14","30","30","ⵉⵎⴻⵏⵣⴰ ⵏ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ ⴰⴷ ⵀⴷⴰⵏ ⵙ ⵍⵀⵓⴷⵏⴻⵜ ⵓⵛⴰ ⵉⵎⴻⵣⵍⴰⴹ ⴰⴷ ⵣⵣⵍⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵏⵖⴻⵖ ⴰⵥⵡⴰⵔ ⵏⵏⴻⵎ ⵙ ⵍⴰⵥ ⵓⵛⴰ ⴰⵔⴻⴼⵙⵉⵡ ⴰⴷ ⵉⵏⴻⵖ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS14_31","024_14_31","ISA","14","31","31","“ⵔⵓ, ⴰ ⵜⴰⵡⵡⴰⵔⵜ, ⵙⵖⵓⵢⵢ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ, ⴰⵇⴰ ⴼⴻⵛⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴼⵉⵍⵉⵛⵉⵜ! ⵎⴰⵖⴰⵔ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴷⴻⵅⵅⴰⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⴳⴳⵯⴻⵊ ⵣⴻⴳ ⵉⵙⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS14_32","024_14_32","ISA","14","32","32","“ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵅ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵍⴳⴻⵏⵙ?” “ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴷⵙⴰⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵃⵉⵎⴰ ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⴰⵔⴻⵡⵍⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("IS15_1","024_15_1","ISA","15","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⵎⵓ’ⴰⴱ. “ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⵜⵜⵡⴰⵀⴷⴻⵎ ⴰⵔ-ⵎⵓ’ⴰⴱ, ⵉⴷⵡⴻⵍ ⵉⵙⵙⵓⵙⴻⵎ, ⵡⴰⵀ, ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⵜⵜⵡⴰⵀⴷⴻⵎ ⵇⵉⵔ-ⵎⵓ’ⴰⴱ, ⵉⴷⵡⴻⵍ ⵉⵙⵙⵓⵙⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("IS15_2","024_15_2","ISA","15","2","2","ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵉⵜ ⴷ ⴷⵉⴱⵓⵏ, ⵖⴰⵔ ⵍⴻⴳⵄⵓⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⵔⵓⵏ. ⴷⵉⵏⵏⵉ ⴰⴷ ⵉⵔⵓ ⵎⵓ’ⴰⴱ ⵅ ⵏⴰⴱⵓ ⴷ ⵎⴰⵢⴷⴰⴱⴰ. ⵇⴰⵄ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵉⵍⵙⴰ ⴷ ⴰⵇⴻⵛⵛⴰⵔ, ⵎⴰⵔⵔⴰ ⵜⵉⵎⵉⵔⴰ ⵜⵜⵡⴰⵃⴻⴼⴼⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS15_3","024_15_3","ISA","15","3","3","ⴱⴻⵢⵙⴻⵏ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷⴻⴳ ⵉⵣⵏⵉⵇⴻⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴷⵉⵏ ⵎⵖⵉⵔ ⵜⵖⵓⵢⵢⵉⵜ ⵅ ⵜⵣⴻⵖⵡⵉⵏ ⵏⵙⴻⵏ ⵓ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏⵙⴻⵏ, ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵡⴻⵟⵟⴰⵏ-ⴷⴷ ⵅ ⵓⵖⴻⵎⴱⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("IS15_4","024_15_4","ISA","15","4","4","ⵃⴰⵛⴱⵓⵏ ⵉⵙⵖⵓⵢⵢⵓ, ⵓⵍⴰ ⴷ ⴰⵍⵉⵄⴰⵍⴰ. ⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⴰⵍ ⵢⴰⵀⴰⵚ. ⵅ ⵓⵢⴰ ⵙⵖⵓⵢⵢⵓⵏ ⵓⵍⴰ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵎⵓ’ⴰⴱ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⵙⵏⴰⵃ, ⴱⵓⵃⴱⴻⵍ ⵏ ⵎⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⴼⵛⴻⵍ ⴷⴰⵢⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS15_5","024_15_5","ISA","15","5","5","“ⵓⵍ ⵉⵏⵓ ⵉⵙⵖⵓⵢⵢⵓ ⵅ ⵎⵓ’ⴰⴱ. ⵉⵎⴰⵔⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵉⵡⴹⴻⵏ ⴰⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵖⴰⵔ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵜⴰⵄⴻⵊⵎⵉⵜ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⴰⵎ ⵜⵜⵔⵓⵏ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵜⴰⵙⴰⵡⴻⵏⵜ ⵏ ⵍⵓⵃⵉⵜ, ⵡⴰⵀ, ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵃⵓⵔⵓⵏⴰⵢⵉⵎ ⵙⵙⴳⴰⵄⵄⴰⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵖⵓⵢⵢⵉⵜ ⵏ ⵜⵅⴻⵙⵙⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS15_6","024_15_6","ISA","15","6","6","ⵡⴰⵀ, ⴰⵎⴰⵏ ⵏ ⵏⵉⵎⵔⵉⵎ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵉⵎⵓⵛⴰⵏ ⵅⵍⴰⵏ, ⵡⴰⵀ, ⴰⵔⴱⵉⵄ ⵉⵙⵍⴰⵡ, ⴰⵖⴻⵎⵎⵓⵢ ⵏ ⴰⵔⴱⵉⵄ ⵉⵇⴹⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵓⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("IS15_7","024_15_7","ISA","15","7","7","ⵅ ⵓⵢⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⴷ ⵎⵉⵏ ⵄⴰⴷ ⵖⴰⵔⵙⴻⵏ, ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵉⵚⴻⴼⵚⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS15_8","024_15_8","ISA","15","8","8","ⵡⴰⵀ, ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵓⵛⴻⵜⵛⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴰⵡⴻⵄⵄⴻⴹ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴰⵍ ⴰⵊⵍⴰⵢⵉⵎ, ⴰⵖⵓⵢⵢⵉ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴰⵍ ⴱⵉ’ⵔ-ⵉⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS15_9","024_15_9","ISA","15","9","9","ⵄⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵡⴰⵎⴰⵏ ⵏ ⴷⵉⵎⵓⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⵏⵢⴻⵖ ⵅ ⴷⵉⴱⵓⵏ ⵄⴰⴷ ⴽⵜⴰⵔ: ⴰⵢⵔⴰⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵎⵓ’ⴰⴱ, ⵅ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS16_1","024_16_1","ISA","16","1","1","“‘ⵙⴻⴽⴽⴻⵎ ⴷⴷⵎⴰⵏⵉ ⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵉ ⵙⴰⵍⴰⵄ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ!’ ");
INSERT INTO rift_vpl VALUES ("IS16_2","024_16_2","ISA","16","2","2","ⴰⵎ ⵉⵊⴹⴰⴹ ⵢⴰⵔⴻⵡⵍⴻⵏ, ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵡⴻⵏ ⵣⵉ ⵍⵄⵓⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵎⵓ’ⴰⴱ ⵖⴰⵔ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⴰⵔⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("IS16_3","024_16_3","ISA","16","3","3","‘ⴰⵡⵢⴻⵎ ⵅⴻⵏⵏⵉ ⵛⵛⵡⴰⵔ, ⴽⵙⵉⵎ ⴰⵡⴰⵍ, ⴳⴳⴻⵎ ⵜⵉⵍⵉ ⵏⵏⴻⵎ ⴰⵎ ⴵⵉⵍⴻⵜ ⴷⴻⴳ ⵓⵣⵉⵍ, ⵙⵏⵓⴼⴼⴰⵔ ⵉⵎⴻⵜⵍⴰⵄ, ⵡⴰⵔ ⵣⵏⵓⵣⵉ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("IS16_4","024_16_4","ISA","16","4","4","‘ⵊⵊⴻⵎ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵅ ⵢⵓⵥⵥⵍⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵎ ⵇⵇⵉⵎⴻⵏ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ! ⵉⵍⵉ ⴷ ⴰⴷⵓⵔⵔⵉ ⵉ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵎⵜⴻⵃⵃⴰⵢ!’” “ⵍⴻⵃⵚⴰⵔⴻⵜ ⵎⴰⵛⴰ ⴰⴷ ⵜⴱⴻⴷⴷ, ⴰⵜⴻⵃⵃⵉ ⴰⴷ ⵉⵇⴹⴰ, ⵉⵏⵏⵉ ⵉⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵎⵡⴻⴷⴷⴰⵔⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS16_5","024_16_5","ISA","16","5","5","ⵍⴽⵓⵔⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵛⴻⴷⴷ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⵃⴻⵇⵇ ⵓⵛⴰ ⵉⵙⵙⴻⴼⵍⴻⵃ ⵜⴰⵙⴻⴳⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS16_6","024_16_6","ISA","16","6","6","“ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵅ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵔⵜ ⴰⵍ ⵟⵟⴰⵔⴼ. ⵜⴰⵄⴻⴼⴼⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵙ ⴷ ⵣⵣⵄⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ ⵉⵅⵡⴰⵏ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS16_7","024_16_7","ISA","16","7","7","ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵜⵔⵓ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵅ ⵎⵓ’ⴰⴱ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵔⵓⵏ, ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵅ ⵣⵣⴱⵉⴱ ⵏ ⵇⵉⵔ-ⵃⴰⵔⵉⵙⴰⵜ, ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵡⴰⵖⴻⵍⴱⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("IS16_8","024_16_8","ISA","16","8","8","ⵎⴰⵖⴰⵔ ⵉⵙⵍⴰⵡⴻⵏⵜ ⵜⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵏ ⵃⴰⵛⴱⵓⵏ. ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏ ⴹⴹⵉⵍⴻⵛⵜ ⵏ ⵙⵉⴱⵎⴰ ⴰⵔⴻⵏⵏⵢⴻⵏⵜ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵜⵉⵙⴻⴹⵡⵉⵏ ⵢⵉⵡⴹⴻⵏⵜ ⴰⵍ ⵢⴰⵄⵣⵉⵔ, ⵙⵓⵃⴻⵏⵜ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴱⴻⵣⵣⵄⴻⵏⵜ, ⴰⵇⴰ ⵥⵡⴰⵏⵜ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS16_9","024_16_9","ISA","16","9","9","ⵅ ⵓⵢⴰ ⵜⵜⵔⵓⵖ ⵅ ⴹⴹⵉⵍⴻⵛⵜ ⵏ ⵙⵉⴱⵎⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵔⵓⵖ ⵅ ⵢⴰⵄⵣⵉⵔ. ⵙⵙⵓⵖ ⵛⴻⵎ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵏⵓ, ⴰ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵃⴰⵛⴱⵓⵏ ⴷ ⴰⵍⵉⵄⴰⵍⴰ, ⵎⵉⵏⵣⵉ ⵔⵓⵃⴻⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵣⵉ ⵜⵉⵏⵉ ⵏⵏⴻⵎ ⵏ ⵓⵏⴻⴱⴷⵓ ⵓ ⵣⴻⴳ ⵡⴻⵍⵇⴰⴹ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS16_10","024_16_10","ISA","16","10","10","ⵜⵃⴻⵢⵢⴻⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵣⵣⵀⵓ ⵣⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ ⵏ ⵜⴼⴻⴵⴰⵃⵜ, ⵡⴰⵔ ⵜⵜⵖⴻⵏⵏⵉⵊⴻⵏ ⵓ ⵡⴰⵔ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵄⴰⴷ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴼⴼⵙⴻⵏ ⵡⴰⵔ ⵢⴰⵔⴻⴼⴼⴻⵙ ⵄⴰⴷ ⴰⴹⵉⵍ ⴷⵉ ⵜⵙⵉⵍⵜ ⵏ ⵓⴹⵉⵍ. ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⴻⵛⵛ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("IS16_11","024_16_11","ISA","16","11","11","ⵅ ⵓⵢⴰ ⵙⵖⵓⵢⵢⵓⵏⵜ ⵜⴻⴽⵔⵉⵛⵉⵏ ⵉⵏⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴳⴰⵎⴱⵔⵉ ⵅ ⵎⵓ’ⴰⴱ, ⵓ ⴷⴰⵅⴻⵍ ⵉⵏⵓ ⵅ ⴽⵉⵔ-ⵃⴰⵔⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("IS16_12","024_16_12","ISA","16","12","12","ⵅⵎⵉ ⵉ ⵖⴰ ⵢⴰⵃⴻⵍ ⵎⵓ’ⴰⴱ ⵅ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵎⴰⵏⵉ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵇⴰ ⵎⵓ’ⴰⴱ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS16_13","024_16_13","ISA","16","13","13","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵅ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("IS16_14","024_16_14","ISA","16","14","14","ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ, ⵉⵇⵇⴰⵔ: “ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵓⵛⴻⵡⵡⴰⵍ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵓⵄⵓⴵⵉ ⵏ ⵎⵓ’ⴰⴱ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴷⵔⵓⵙ ⵇⴰⵄ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS17_1","024_17_1","ISA","17","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⴷⵉⵎⴰⵛⵇ. “ⴰⵇⴰ ⴷⴰ, ⴷⵉⵎⴰⵛⵇ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⵜⴰⵏⴷⵉⵏⵜ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS17_2","024_17_2","ISA","17","2","2","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵄⴰⵔⵓⵄⵉⵔ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵅⵍⴰⵏⵜ, ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ. ⵜⵉⵏⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵣⵣⵍⴻⵏⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵜⴻⵏⵜ ⵉⵙⵙⴼⴻⵄⴼⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS17_3","024_17_3","ISA","17","3","3","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴹⴰ ⵅ ⵍⵇⴻⵍⵄⴰ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵍⴰ ⵅ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵣⵉ ⴷⵉⵎⴰⵛⵇ ⵓ ⵅ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵔⴰⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵙⴰⵔ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS17_4","024_17_4","ISA","17","4","4","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵙⵍⴰⵡ ⵓⵄⵓⴵⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴰⴷⵓⵏⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵇⵇⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS17_5","024_17_5","ISA","17","5","5","ⴰⴷ ⵢⵉⵍⵉ ⴰⵅⵎⵉ ⵉⵜⵜⵇⴻⴱⴱⴻⴹ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵓⵛⴰ ⵉⵎⴻⵊⵊⴰⵔ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵜⵉⴷⵔⵉⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵅⵎⵉ ⵉⵊⵊ ⵉⵍⴻⵇⵇⴻⴹ ⵜⵉⴷⵔⵉⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵉⵔⴰⴼⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS17_6","024_17_6","ISA","17","6","6","ⴰⴷ ⵉⵇⵇⵉⵎ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵓⵛⴻⵟⵟⵉ ⵉ ⵡⴻⵍⵇⴰⴹ, ⴰⵎ ⵖⴰⵔ ⵡⴻⵣⵡⴰⴹ ⵏ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ, ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵜⵣⵉⵜⵓⵏⵉⵏ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵜⴰⵙⴻⵟⵟⴰ ⵙⴻⵏⵏⴻⵊ, ⵓⵛⴰ ⴰⵔⴻⴱⵄⴰ ⵏⵉⵖ ⵅⴻⵎⵙⴰ ⵖⴰⵔ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵉⵖⴻⵎⵎⴰⵢⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS17_7","024_17_7","ISA","17","7","7","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵅⵣⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵅ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS17_8","024_17_8","ISA","17","8","8","ⵡⴰⵔ ⵉⵜⵜⵡⴰⵍⵉ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵉⴳⴳⵉⵏ ⵉⴹⴻⵡⴹⴰⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵉⵥⵥⴰⵔ, ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵍⵍⴰ ⵓⵍⴰ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ ⵍⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS17_9","024_17_9","ISA","17","9","9","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵉⴼⴰⵔⵢⴻⵏ ⴰⵎ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ ⵓ ⵜⴰⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏⵏⵉ ⵊⵊⵉⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵛⴰⵏ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS17_10","024_17_10","ISA","17","10","10","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜᵉⵜⵜⵓⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⴻⵄⵇⵉⵍⴻⴷ ⵅ ⵜⴻⵚⴹⴰⵔⵜ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ. ⵅ ⵓⵢⴰ ⵜᵉⵜⵜⴻⵥⵥⵓⴷ ⴰⵖⴻⵎⵎⵓⵢ ⵉⴹⴰⵔⴼⴻⵏ ⵓⵛⴰ ⵜⵣⴰⵔⵔⵄⴻⴷ ⵜⵉⵖⴻⴷⴷⵓⵜⵉⵏ ⵜⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS17_11","024_17_11","ISA","17","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⵏⵜ ⵜⴻⵥⵥⵓⴹ, ⴰⴷ ⵜⴻⵏⵜ ⵜⴼⴰⵔⵢⴻⴷ, ⵓ ⵖⴰⵔ ⵓⵜⴻⴼⴼⵓ ⵜⴻⵊⵊⵉⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴼⵓⴼⴼⵉ: ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵎⴻⵊⵔⴰ ⵉⵄⵓⵔⵔⵛⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵍⴰⵛ ⵏⵏⴻⵛ ⴷ ⵍⴻⵃⵔⵉⵇ ⵡⴰⵔ ⵉⵜⵜⴳⴻⵏⴼⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS17_12","024_17_12","ISA","17","12","12","“ⵓⵛⵜ ⵅ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⴰⵎ ⵣⴻⵀⵀⴰⵔⴻⵏ ⵍⴻⴱⵃⵓⵔ, ⵓⵍⴰ ⵓⵛⵜ ⵅ ⴷⴷⵔⵉⵣ ⵏ ⵛⵛⵓⵄⵓⴱ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵎ ⵍⴻⵃⵡⴻⵍ ⵏ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉⵏⵀⴻⵡⵍⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("IS17_13","024_17_13","ISA","17","13","13","ⴰⴷ ⵀⴻⵡⵍⴻⵏ ⵛⵛⵓⵄⵓⴱ ⴰⵎ ⵍⴻⵃⵡⴻⵍ ⵏ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴻⴱⴱⴰ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ⴰⴷ ⵉⵜⵜⵡⴰⵄⴰⵔⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵎ ⵓⵍⵓⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⵜⵜⵡⴰⵄⴰⵔⵏⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⵎ ⵓⵙⴻⵢⵏⵓ ⵏ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵜⴻⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵜⵃⴰⵔⵢⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("IS17_14","024_17_14","ISA","17","14","14","ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ, ⵅⵣⴰⵔ, ⴰⵏⴻⵅⵍⵉⵄ! ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ, ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵜⵜⴰ ⵄⴰⴷ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴽⴻⵛⵛⴹⴻⵏ, ⵣⵣⵀⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵢⵓⵛⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS18_1","024_18_1","ISA","18","1","1","“ⵓⵛⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵓⵔⴻⵏⴷⴰⴷ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ, ");
INSERT INTO rift_vpl VALUES ("IS18_2","024_18_2","ISA","18","2","2","ⵜⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽⴻⵏ ⵉⵎⵙⴻⴽⴽⴰⵏ ⵏⵏⴻⵙ ⵅ ⵍⴻⴱⵃⴰⵔ, ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜⵉⵏ ⵏ ⵓⵖⴰⵏⵉⵎ ⵜⵉⵡⴰ ⵉ ⵡⴰⵎⴰⵏ. ⵓⵢⵓⵔⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵉⴼⵙⵓⵙⴻⵏ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵓ ⵉⵜⵜⵡⴻⵙⵙⴳⴻⵏ ⵏ ⵜⴻⵍⵎⴻⵛⵜ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵣⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⴵⴰ ⵓ ⵣⵉ ⵙⵙⴰ ⵜⵙⴰⵡⴻⵏⵜ, ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⴰⵎⴰⵔⴰⵏ ⵍⴻⴱⴷⴰ ⵓ ⵉⵄⴻⴼⴼⴻⵙ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵇⴻⴹⵄⴻⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS18_3","024_18_3","ISA","18","3","3","ⴰ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⵎⵉ ⵖⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⵎ, ⵓ ⵅⵎⵉ ⵖⴰ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴰⴷ ⵜ ⵜⴻⵙⵍⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("IS18_4","024_18_4","ISA","18","4","4","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⵖⴰⵔⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵃⴹⵉⵖ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ, ⴰⵎ ⵍⴻⵀⵎⵓ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵖⴰⵔ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ, ⴰⵎ ⵓⵙⴻⵢⵏⵓ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵏⵏⴹⴰ ⵖⴰⵔ ⵍⴻⵀⵎⵓ ⵏ ⵚⵚⴰⴱⴻⵜ.’ ");
INSERT INTO rift_vpl VALUES ("IS18_5","024_18_5","ISA","18","5","5","ⵎⴰⵖⴰⵔ ⵇⴱⴻⵍ ⵚⵚⴰⴱⴻⵜ, ⵅⵎⵉ ⵖⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵏⵏⵓⵡⵡⴰⵔ, ⵜⴻⴷⵡⴻⵍ ⵜⵏⴻⵡⵡⴰⵔⵜ ⴷ ⴰⴹⵉⵍ ⵉⵏⴻⵏⵏⴰ, ⴰⴷ ⵉⵣⴱⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵣⴱⵉⵔⴻⵏ ⵙ ⵉⵊⴻⵇⵇⴰⴹⴻⵏ ⵏ ⵡⴻⵣⴱⴰⵔ, ⴰⴷ ⵉⴽⴽⴻⵙ ⴰⵔⴱⵉⴱⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵉⵇⴹⵓ. ");
INSERT INTO rift_vpl VALUES ("IS18_6","024_18_6","ISA","18","6","6","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜⵜⵡⴰⵊⵊⴻⵏ ⵉ ⵉⵊⴹⴰⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵔⵙⴻⵏ ⵉⵊⴹⴰⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵓ ⴷⵉ ⵍⵎⴻⵛⵜⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵔⵙⴻⵏ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS18_7","024_18_7","ISA","18","7","7","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⴷ ⵉⵜⵜⵡⴻⵙⵙⴳⴻⵏ ⵏ ⵜⴻⵍⵎⴻⵛⵜ - ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⴻⴳⴳⵯⴻⴷ ⵣⵣⴰⵢⴻⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⴵⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ, ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⴰⵎⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⵓ ⵉⵄⴻⴼⴼⴻⵙ, ⵏⵏⵉ ⵣⵉ ⵇⴻⴹⵄⴻⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ - ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS19_1","024_19_1","ISA","19","1","1","ⵍⵃⵓⴽⵎ ⵅ ⵎⵉⵚⵔⴰ. “ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵏⵢⴰ ⵅ ⵉⵛⵜ ⵏ ⵜⵙⴻⵢⵏⵓⵜ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ. ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵍ’ⴰⵚⵏⴰⵎ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓ ⴰⵢⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⴼⵛⴻⵍ ⵡⵓⵍ ⴷⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS19_2","024_19_2","ISA","19","2","2","ⵎⴰⵖⴰⵔ ⴰⴷ ⵙⵙⵃⴰⵔⵔⵛⴻⵖ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵅ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵓⵎⴰⵙ, ⵓ ⴽⵓⵍ ⵉⵊⵊ ⴰⴽ-ⴷ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵜⴰⵏⴷⵉⵏⵜ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⴰⴳⴻⵍⴷⵉⵜ ⴰⴽ-ⴷ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("IS19_3","024_19_3","ISA","19","3","3","ⴱⵓⵀⴱⴻⵍ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵢⴰⵔⵊⴻⴼ ⴷⴰⵢⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴼⴻⵙⵅⴻⵖ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⵣⵣⵎⴻⵏ ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS19_4","024_19_4","ISA","19","4","4","ⴰⴷ ⴳⴳⴻⵖ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜⴱⴰⴱ ⵉⵇⴻⵙⵃⴻⵏ ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵉⵡⵄⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵃⴽⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS19_5","024_19_5","ISA","19","5","5","ⴰⵎⴰⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⴰⵥⵖⴻⵏ ⵓ ⵉⵖⵣⴰⵔ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⴷⵉ, ⴰⴷ ⵢⴰⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS19_6","024_19_6","ISA","19","6","6","ⵉⵖⴻⵣⵔⴰⵏ ⴰⴷ ⴰⵔⵅⵓⵏ ⵉ ⴰⵔⵔⵉⵃⴻⵜ ⵢⵓⵔⵙⵓⴹⴻⵏ ⵓ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⴰⵔⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵥⵖⴻⵏ, ⴰⵖⴰⵏⵉⵎ ⴷ ⵜⴻⵍⴳⴰ ⴰⴷ ⵉⵙⵍⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS19_7","024_19_7","ISA","19","7","7","ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵖⴰⵔ ⵏⵉⵍ, ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵉⵖⴻⵣⵔⴰⵏ ⵎⴰⵏⵉ ⵣⴰⵔⵔⵄⴻⵏ, ⴰⴷ ⴰⵥⵖⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("IS19_8","024_19_8","ISA","19","8","8","ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴰⴷ ⵛⴻⴹⵏⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵏⴹⴰⵔⴻⵏ ⵜⴰⵙⴻⵏⵏⴰⵔⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ, ⵓ ⵉⵏⵏⵉ ⵉⴱⴻⵣⵣⵄⴻⵏ ⵜⵔⴰⵛⵛⴰ ⵏ ⵓⴷⴻⵍⵍⴰⵄ ⵅ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵉⵙⵍⴰⵡⴻⵏ ⵣⴻⴳ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS19_9","024_19_9","ISA","19","9","9","ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵜⵉⴼⴼⴻⵙⵜ ⴰⵣⴷⴰⴷ ⵎⴻⵛⵛⴹⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⵓⵍⴰ ⴷ ⵉⴷⴰⵔⵔⴰⵣⴻⵏ ⵏ ⵍⴽⴻⵜⵜⴰⵏ ⴷ ⴰⵛⴻⵎⵍⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("IS19_10","024_19_10","ISA","19","10","10","ⴰⴷ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵎⵓⵏⴻⵜ ⵉⵛⴹⴻⵏ ⴰⵙ ⵍⴻⵄⵎⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS19_11","024_19_11","ISA","19","11","11","“ⵡⴰⵀ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵚⵓⵄⴰⵏ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵛⵛⵡⴰⵔ ⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⵉⴷⵡⴻⵍ ⵉⴱⴱⵓⵀⵍⵉ. ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵄⵄⵎⴻⵎ ⴰⴷ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵄⴰⴷ ⵉ ⴼⵉⵔⵄⵓⵏ: ‘ⵏⴻⵛⵛ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵎⵎⵉⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ?’ ");
INSERT INTO rift_vpl VALUES ("IS19_12","024_19_12","ISA","19","12","12","ⵎⴰⵏⵉ ⴵⴰⵏ ⵅⴻⵏⵏⵉ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵛ? ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵛ ⵙⵙⴰⵔⴳⴱⴻⵏ ⵓ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵛⵏⴻⵏ ⵎⵉⵏ ⵉⵅⴰⵔⵔⴻⵚ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴹⵉⴷⴷ ⵉ ⵎⵉⵚⵔⴰ! ");
INSERT INTO rift_vpl VALUES ("IS19_13","024_19_13","ISA","19","13","13","ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵚⵓⵄⴰⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵜⵜⵡⴰⵛⴻⵎⵜⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵏⵓⴼ. ⴰⴷ ⵙⵙⵡⴻⴷⴷⴰⵔⴻⵏ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⵉⵏⵏⵉ ⴷ ⵉⵥⵔⴰ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS19_14","024_19_14","ISA","19","14","14","“ⵙⵉⴷⵉ ⵉⴽⴻⴱⴱ ⴷⵉ ⵎⵉⵚⵔⴰ ⴱⵓⵃⴱⴻⵍ ⵉⵙⵙⴷⴻⵡⵡⴰⵅⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵙⵙⵡⴻⴷⴷⴰⵔⴻⵏ ⵎⵉⵚⵔⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⴰⵎ ⵓⵎⴻⵙⴽⴰⵔ ⵉⵡⴻⴷⴷⴰⵔ ⴷⵉ ⵜⵄⵓⵇⵇⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS19_15","024_19_15","ISA","19","15","15","ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵉ ⵎⵉⵚⵍⴰ ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ, ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⴳⴳ ⵓⵣⴻⴵⵉⴼ ⵏⵉⵖ ⴰⴽⴻⵏⵏⴰⵙ, ⵜⴰⵙⴻⵟⵟⴰ ⵏⵉⵖ ⴰⵖⴰⵏⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS19_16","024_19_16","ISA","19","16","16","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵎ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ, ⴰⴷ ⵏⵏⵅⴻⵍⵄⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉ ⵣⵉ ⵖⴰⵔⵙⴻⵏ ⵉ ⵖⴰ ⵉⵏⵀⴻⵣⵣ ⵙⵙⴰ ⴷ ⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("IS19_17","024_19_17","ISA","19","17","17","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⴰⵎⴻⴷⵢⴰ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ. ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉⵜⵜⵉⴷⴰⵔⴻⵏ, ⴰⴷ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵅⴰⵔⵔⴻⵚ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵅⴰⵔⵔⴻⵚ.” ");
INSERT INTO rift_vpl VALUES ("IS19_18","024_19_18","ISA","19","18","18","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵅⴻⵎⵙⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⴷ ⴷⵉⵏ ⵙⵙⵉⵡⵍⴻⵏ ⵉⵡⴷⴰⵏ ⵉⵍⴻⵙ ⵏ ⴽⴻⵏⵄⴰⵏ ⵓⵛⴰ ⴰⴷ ⵊⵊⴰⴵⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵉⵛⵜ ⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴰⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ‘ⵉⵔ-ⵀⴰ-ⵀⴻⵔⴻⵙ!’, ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ’. ");
INSERT INTO rift_vpl VALUES ("IS19_19","024_19_19","ISA","19","19","19","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⵉⵊⵊ ⵏ ⵓⵎⴰⵢⴹⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS19_20","024_19_20","ISA","19","20","20","ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ: ⵅⵎⵉ ⵖⴰ ⵍⴰⵖⴰⵏ ⵉ ⵙⵉⴷⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵙⴻⴽⴽ ⴰⵎⵙⴻⵏⵊⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵓ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("IS19_21","024_19_21","ISA","19","21","21","ⴰⴷ ⵉⴷⵡⴻⵍ ⵙⵉⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵙⵙⵏⴻⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵙ ⵜⵖⴰⵔⵚⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵏ ⴰⵡⴰⵍ ⵉ ⵙⵉⴷⵉ ⵓ ⴰⴷ ⵜ ⴽⴻⵎⵎⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS19_22","024_19_22","ISA","19","22","22","ⴰⴷ ⵉⵡⵡⴻⵜ ⵙⵉⴷⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵙ ⵜⵉⵢⵢⵉⵜⴰ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵡⵡⴻⵜ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴳⴻⵏⴼⴰ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴻⵊⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵙ ⵜⵥⴰⴵⵉⵜ ⵢⵓⴵⵖⴻⵏ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴳⴻⵏⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS19_23","024_19_23","ISA","19","23","23","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴰⵛⵛⵓⵔ. ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷⵉ ⴰⵛⵛⵓⵔ. ⴰⴷ ⴰⵙ ⵄⴻⴱⴷⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵉ ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS19_24","024_19_24","ISA","19","24","24","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵙⵔⴰⵉⵍ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴽ-ⴷ ⵎⵉⵚⵔⴰ ⴷ ⴰⵛⵛⵓⵔ, ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS19_25","024_19_25","ISA","19","25","25","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵜⴻⵏ ⵉⴱⴰⵔⴻⴽ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⵉⵚⵔⴰ, ⵓ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴰⵛⵛⵓⵔ, ⵓⵍⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ!’” ");
INSERT INTO rift_vpl VALUES ("IS20_1","024_20_1","ISA","20","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⴷⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵖⴰⵔ ⴰⵛⴷⵓⴷ, ⵓⵎⵉ ⵜ ⵉⵙⵙⴻⴽⴽ ⵙⴰⵔⵊⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵓ ⵉⵎⵎⵏⴻⵖ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⴰⵛⴷⵓⴷ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜ, ");
INSERT INTO rift_vpl VALUES ("IS20_2","024_20_2","ISA","20","2","2","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ, ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ, ⵙⴰⵔⵙ ⴰⵔⵔⵓⴹ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵏⵏⵉ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ ⵓ ⴽⴽⴻⵙ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵛ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ!” ⵉⴳⴳⴰ ⵉ-ⵜ ⵉⵛⴰⵄⵢⴰ, ⵉⴳⴳⵓⵔ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵓ ⵙ ⵍⴻⵃⴼⴰ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS20_3","024_20_3","ISA","20","3","3","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⵓⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵉⵛⴰⵄⵢⴰ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵓ ⵙ ⵍⴻⵃⴼⴰ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⴰⵎ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⵊⴻⴱ ⵉ ⵎⵉⵚⵔⴰ ⵓ ⵉ ⴽⵓⵛ, ");
INSERT INTO rift_vpl VALUES ("IS20_4","024_20_4","ISA","20","4","4","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵏⴷⴻⵀ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵎⴻⵃⴱⴰⵙ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵏ ⴽⵓⵛ, ⴰⵎⴻⵥⵢⴰⵏ ⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⴰⵄⴰⵔⵢⴰⵏ ⴷ ⵓⵃⴻⴼⵢⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ, ⵓⵍⴰ ⵙ ⴷⴷⴰⴱⵓⴱ ⵉⵄⴰⵔⵔⴰⵏ, ⴰⵇⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS20_5","024_20_5","ISA","20","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵓ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⵓⵛ ⵉ ⵖⴰⵔ ⵜⵓⵖⴰ ⵅⴻⵣⵣⴰⵔⴻⵏ ⴷ ⵛⴰ, ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⴰⴼⴻⵢⵢⴻⵛ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS20_6","024_20_6","ISA","20","6","6","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⵉⵏⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ: ‘ⵅⵣⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵎⵙⴰⵔ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵏⵅⴻⵣⵣⴰⵔ ⴷ ⵛⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵏⴰⵔⵡⴻⵍ ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵔⵣⵓ ⵜⵡⵉⵣⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵏⵊⴻⵎ ⵍⴻⵅⵅⵓ?’” ");
INSERT INTO rift_vpl VALUES ("IS21_1","024_21_1","ISA","21","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⵍⴻⵅⵍⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴰⵣⵣⵍⴻⵏⵜ ⵜⵃⴰⵔⵢⴰⴹⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ ⵣⵉ ⵍⴻⵅⵍⴰ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS21_2","024_21_2","ISA","21","2","2","ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵉⵇⵙⴻⵃ: ‘ⴰⵖⴻⴷⴷⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵙ ⵍⴻⵖⴷⴰⵔⴻⵜ ⵓ ⴰⵎⵜⴻⵃⵃⴰⵢ ⴰⴷ ⵉⵜⴻⵃⵃⴰ. ⴳⴻⵄⵄⴻⴷ-ⴷⴷ, ⴰ ⵄⵉⵍⴰⵎ, ⵃⵚⴰⵔ, ⴰ ⵎⴰⴷⴰⵢ!’ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵣⴻⵀⵀⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS21_3","024_21_3","ISA","21","3","3","ⵅ ⵓⵢⴰ ⵜⵜⴻⴽⵙⴻⵏⵜ ⴷⴰⵢⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵉⵏⵓ, ⵓ ⵟⵟⴼⴻⵏ ⴰⵢⵉ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⴰⵎ ⵍⴻⵡⵊⴻⵄ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ. ⵏⴻⵛⵛ ⵜⵜⵏⴻⵣⴱⴰⵔⴻⵖ ⵅⵎⵉ ⴷ ⴰⵙ ⵜⵜⴻⵙⵍⵉⵖ, ⵏⵏⵅⴻⵍⵄⴻⵖ ⵓⵎⵉ ⵜ ⵜⵜⵡⴰⵍⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("IS21_4","024_21_4","ISA","21","4","4","ⵓⵍ ⵉⵏⵓ ⵉⵏⵏⴻⵊⵔⴻⴼ, ⴰⵇⴰⵔⵇⴻⴱ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵏⵀⴻⵣⵣⴰ ⴷⴰⵢⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ. ⵜⴱⴰⵎⴱⴰⵙⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ ⵏⵏⵉ ⵡⴻⵀⵀⵛⴻⵖ ⴰⵟⵟⴰⵙ, ⵉⴳⴳⴰ ⴰⵢⵉ ⵜⵜ ⴷ ⵍⵄⵓⵔⵔⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS21_5","024_21_5","ISA","21","5","5","“ⵙⵔⵓⵙⴰ-ⴷⴷ ⵟⵟⴰⴱⵍⴰ, ⵙⴱⴻⴷⴷ ⴰⵄⴻⵙⵙⴰⵙ, ⴻⵛⵛ, ⵙⵓ!” “ⴽⴽⴰⵔⴻⵎ, ⴰ ⵍⵃⵓⴽⴽⴰⵎ, ⴷⴻⵀⵏⴻⵎ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵙⴻⵍⵇⵉ!” ");
INSERT INTO rift_vpl VALUES ("IS21_6","024_21_6","ISA","21","6","6","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵓⵢⵓⵔ, ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵅⴻⴱⴱⴰⵔ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("IS21_7","024_21_7","ISA","21","7","7","ⴰⵇⴰ ⵉⵥⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵜⵢⵓⵢⴰ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴰⴽ-ⴷ ⵜⵢⵓⵢⴰ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⴰ$ⴰⵏ ⵏ ⵢⴻⵖⵢⴰⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⴰ$ⴰⵏ ⵏ ⵉⵍⴻⵖⵎⴰⵏ. ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰ ⵎⵍⵉⵃ, ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS21_8","024_21_8","ISA","21","8","8","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵥⵔⵉⵏ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵜⵜⴱⴻⴷⴷⵉⵖ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⵅ ⵡⴻⵛⴱⴰⵔ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵓ ⴽⵓⵍ ⴵⵉⵍⴻⵜ ⵜⵜⵄⴻⵙⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS21_9","024_21_9","ISA","21","9","9","ⵅⵣⴰⵔ, ⴷⵉⵀⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵜⵢⵓⵢⴰ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴰⴽ-ⴷ ⵜⵢⵓⵢⴰ ⵏⵏⴻⵖⵏⵉ!” ⵄⴰⵡⴻⴷ ⵉⵟⵟⴻⴼ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⵜⴻⵡⴹⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ, ⵜⴻⵡⴹⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵙ ⵉⵍⴱⴻⵣ ⵉ-ⵜⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("IS21_10","024_21_10","ISA","21","10","10","ⴰ ⴰⵙⴰⵔⵡⴰⵜ ⵉⵏⵓ, ⴰ ⵎⵎⵉⵙ ⵏ ⵓⵏⴻⴷⵔⴰⵔ ⵉⵏⵓ! ⵎⵉⵏ ⵙⵍⵉⵖ ⵣⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⴻⴱⴱⴰⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS21_11","024_21_11","ISA","21","11","11","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⴷⵓⵎⴰ. “ⵣⵉ ⵙⴰⵄⵉⵔ ⵍⴰⵖⴰⵏ ⴰⵢⵉ-ⴷⴷ: ‘ⴰⵄⴻⵙⵙⴰⵙ, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵖⴰ ⵜⴻⴽⴽ ⴵⵉⵍⴻⵜ? ⴰⵄⴻⵙⵙⴰⵙ, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵖⴰ ⵜⴻⴽⴽ ⴵⵉⵍⴻⵜ?’ ");
INSERT INTO rift_vpl VALUES ("IS21_12","024_21_12","ISA","21","12","12","ⵉⵏⵏⴰ ⵓⵄⴻⵙⵙⴰⵙ: ‘ⵢⵓⵙⴰ-ⴷⴷ ⵓⵜⴻⴼⴼⵓ ⵏ ⵍⵃⴰⵍ, ⵓⵍⴰ ⴷ ⴵⵉⵍⴻⵜ ⵜⵓⵙⴰ-ⴷⴷ. ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ, ⵙⴻⵇⵙⴰⵎ! ⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⴰⵙⴻⵎ-ⴷⴷ!’” ");
INSERT INTO rift_vpl VALUES ("IS21_13","024_21_13","ISA","21","13","13","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⴷⵉ ⵜⵎⴻⴷⴷⵉⵜ. “ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵄⵔⴰⴱⴻⵏ ⴰⴷ ⵜⴻⵙⵙⴻⵏⵙⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⴽⴰⵔⴰ$ⴰⵏⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴷⴰⴷⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("IS21_14","024_21_14","ISA","21","14","14","ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵡⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⴼⵓⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵜⴰⵡⵢⴻⵎ ⴰⵎⴰⵏ! ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴰⵢⵎⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵓⵎⴰⵔⵡⴰⵍ ⵙ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("IS21_15","024_21_15","ISA","21","15","15","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵍⴻⵙⵢⵓⴼ, ⵣⵉ ⵙⵙⵉⴼ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵊⴻⴱⴷⴻⵏ, ⵣⵉ ⵍⵇⴻⵡⵙ ⵉⵜⵜⵡⴰⵎⴻⵃⴷⴻⵏ ⵓ ⵣⵉ ⵍⴻⵖⴱⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("IS21_16","024_21_16","ISA","21","16","16","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉⵏⵓ: ‘ⵄⴰⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵓⵛⴻⵡⵡⴰⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⴹⴰ ⵎⴰⵔⵔⴰ ⵅ ⵓⵄⵓⴵⵉ ⵏ ⵇⵉⴷⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("IS21_17","024_21_17","ISA","21","17","17","ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⵇⴻⵡⵙ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵍⵓⴷⵟ ⵏ ⵇⵉⴷⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ ⴰⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("IS22_1","024_22_1","ISA","22","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵍⴻⵡⵃⵉⵢ. “ⵎⵉⵏ ⵛⴻⵎ ⵢⵓⵖⵉⵏ ⴰⵍⴰⵎⵉ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵛⴻⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵅ ⵜⵣⴻⵖⵡⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("IS22_2","024_22_2","ISA","22","2","2","ⴰ ⵛⴻⵎ, ⵜⴻⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⴷⴷⵔⵉⵣ, ⴰ ⵛⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵣⵔⵓⴷⴷⵃⴻⵏ, ⵜⴰⵏⴷⵉⵏⵜ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ: ⵉⵏⵏⵉ ⴷⴰⵢⴻⵎ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵡⴰⵔ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⵡⴰⵔ ⵎⵎⵜⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("IS22_3","024_22_3","ISA","22","3","3","ⵎⴰⵔⵔⴰ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏⵏⴻⵎ ⵎⵓⵏⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ, ⵎⴰⵛⴰ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⵏⵀⵍⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵏ ⵍⵇⴻⵡⵙ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵎ ⵓⴼⵉⵏ, ⵜⵜⵡⴰⵛⴰⵔⴼⴻⵏ, ⵡⴰⵅⵅⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ.” ");
INSERT INTO rift_vpl VALUES ("IS22_4","024_22_4","ISA","22","4","4","“ⵅ ⵓⵢⴰ ⵇⵇⴰⵔⴻⵖ: ‘ⵙⴰⴳⴳⵯⴻⵊⴻⵎ ⵅⴰⴼⵉ ⵍⵅⴻⵣⵔⴰⵜ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⵓⵖ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵃⴻⵚⵚⴰⵔⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵄⴻⵣⵣⴰⵎ ⵅ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("IS22_5","024_22_5","ISA","22","5","5","ⵎⴰⵖⴰⵔ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵡⴻⵣⵔⵓⴷⴷⴻⵃ ⴷ ⵓⵄⴼⴰⵙ ⴷ ⵓⵅⴰⵔⵡⴻⴹ ⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵍⴻⵡⵃⵉⵢ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴷⴰⵍ ⵏ ⵍⵃⵉⴹ ⵓ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵉ ⵅ ⴷⴷ-ⵜⵜⴰⵔⵔⴰⵏ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS22_6","024_22_6","ISA","22","6","6","ⵎⴰⵖⴰⵔ ⵄⵉⵍⴰⵎ ⵉⵟⵟⴻⴼ ⴰⵇⵔⴰⴱ ⵏⵏⴻⵙ ⵙ ⴼⵍⵉⵜⵛⴰⵜ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⴽⴰⵔⵔⵓ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⴰⴽ-ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵜ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵓ ⵇⵉⵔ ⵉⵄⴰⵔⵔⴰ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS22_7","024_22_7","ISA","22","7","7","ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵜⴻⵢⵙⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵏ ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⵉⵎⵏⴰⵢⴻⵏ ⴰⴷ ⵙⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS22_8","024_22_8","ISA","22","8","8","ⴰⴷ ⵉⴽⴽⴻⵙ ⵏⴻⵜⵜⴰ ⴰⵔⵔⵓⴹ ⵅ ⵢⴰⵀⵓⴷⴰ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵖⴰⵔ ⵍⴻⵙⵏⴰⵃ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵣⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS22_9","024_22_9","ISA","22","9","9","ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵜⵉⵣⵣⴻⵢⵢⵉⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⵎ ⴰⵎⴰⵏ ⵏ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("IS22_10","024_22_10","ISA","22","10","10","ⴰⴷ ⵜⵃⴻⵙⴱⴻⵎ ⵜⵓⴷⵔⵉⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴰⴷ ⵜⵀⴻⴷⵎⴻⵎ ⵜⵓⴷⵔⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵊⴻⵀⴷⴻⵎ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("IS22_11","024_22_11","ISA","22","11","11","ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵢⴻⵍⵎⴰⵎ ⵊⴰⵔ ⵍⴻⵃⵢⵓⴹ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⵎ ⴰⵎⴰⵏ ⵏ ⵓⵢⴻⵍⵎⴰⵏ ⴰⵇⴷⵉⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⵓ ⵡⴰⵔ ⵜⵃⴻⵟⵟⵉⵎ ⵡⴻⵏⵏⵉ ⵜ ⵉⵚⴻⵏⵏⵄⴻⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS22_12","024_22_12","ISA","22","12","12","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵍⴰⵖⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵔⵓⵎ, ⴰⴷ ⵜⴻⵙⵖⵓⵢⴻⵎ, ⴰⴷ ⵜⵃⴻⴼⴼⴻⵎ ⴰⵣⴻⴵⵉⴼ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵢⴰⵔⴹⴻⵎ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS22_13","024_22_13","ISA","22","13","13","ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⵛⴰⵇ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵏⴻⵇⵇⴻⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵖⴰⵔⵚⴻⵏ ⵉ ⵡⵓⴵⵉ, ⵜⵜᵉⵜⵜⴻⵏ ⴰⵢⵙⵓⵎ ⵓ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ, ⴰⵎ ⵇⵇⴰⵔⴻⵏ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵛⵛ, ⴰⴷ ⵏⵙⵓ, ⵎⴰⵖⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵏⴻⵎⵎⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS22_14","024_22_14","ISA","22","14","14","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵢⵉ ⵅ ⵓⵢⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⵉⵏⵏⴰ: ‘ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ-ⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵚⵍⴻⵃ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵍ ⵖⴰ ⵜⴻⵎⵎⵜⴻⵎ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS22_15","024_22_15","ISA","22","15","15","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵓⵢⵓⵔ, ⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⵡⴽⵉⵍ ⵏⵏⵉ, ⵖⴰⵔ ⵛⵉⴱⵏⴰ, ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("IS22_16","024_22_16","ISA","22","16","16","ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⵉⴵⴰⵏ ⴷⴰⵏⵉⵜⴰ, ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵖⴰⵔⴻⴽ ⵉⴵⴰⵏ ⴷⴰⵏⵉⵜⴰ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵏⴻⵇⵛⴻⴷ ⴷⴰ ⵉⵊⵊ ⵏ ⵡⴻⵏⴹⴻⵍ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ? ⵉⵡⴰ ⵉⵏⴻⵇⵇⴻⵛ ⴰⵏⴹⴻⵍ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ, ⵉⵏⴻⵇⵇⴻⵛ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷⵉ ⵊⵊⴰⵔⴼ! ");
INSERT INTO rift_vpl VALUES ("IS22_17","024_22_17","ISA","22","17","17","ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵃⴻⵊⵊⴰⵔ ⵙ ⵉⵊⵊ ⵏ ⵓⵃⴻⵊⵊⴰⵔ ⵉⵎⵖⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵟⵟⴻⴼ ⵙ ⵉⵊⵊ ⵏ ⵡⵓⴹⵓⴼ ⵉⵇⵙⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("IS22_18","024_22_18","ISA","22","18","18","ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵃⵏⵓⵏⵏⴻⴹ ⵇⴰⵄ ⴰⵍⴰⵎⵉ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵜⴰⵇⵓⵔⴰⵔⵜ, ⵉⵛⵜ ⵏ ⵜⵛⴰⵎⵎⴰ ⵏⵏⵉ ⵜⵜ ⵉ ⵖⴰ ⵏⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵎⵖⴰⵔ. ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ ⵓ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵍⵉⵏ ⵅⴻⵏⵏⵉ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵛ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ, ⴰ ⵛⴻⴽ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("IS22_19","024_22_19","ISA","22","19","19","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵍⴼⵓⵙⵉⵏⴰ ⵏⵏⴻⵛ, ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵉⵇⵍⴻⵄ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("IS22_20","024_22_20","ISA","22","20","20","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵍⴰⵖⵉⵖ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("IS22_21","024_22_21","ISA","22","21","21","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⵢⴰⵔⴹⴻⵖ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⴱⴻⵢⵙⴻⵖ ⴰⴱⵢⴰⵙ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵡⵛⴻⵖ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS22_22","024_22_22","ISA","22","22","22","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⴰⵔⵙⴻⵖ ⵍⵎⴻⴼⵜⴰⵃ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵣⴻⵎ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⴱⴻⵍⵍⴻⵄ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴻⵍⵍⴻⵄ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵢⴰⵔⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS22_23","024_22_23","ISA","22","23","23","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵡⵜⴻⵖ ⴰⵎ ⵍⴻⵡⵜⴻⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵎⵜⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⴰⵔⵛ ⵏ ⵓⵄⵓⴵⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS22_24","024_22_24","ISA","22","24","24","ⴰⴷ ⵅⴰⵙ ⴰⵢⵍⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵄⵓⴵⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ, ⵉⵖⴻⴷⴷⵓⵢⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⴷ ⵜⵖⴻⴷⴷⵓⵜⵉⵏ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⵛⵓⵄⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⵣⵉ ⵟⵟⴱⴰⵚⵉ ⴰⵍ ⵎⴰⵔⵔⴰ ⵜⵉⵇⵏⵓⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS22_25","024_22_25","ISA","22","25","25","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵍⴻⵡⵜⴻⴷ ⵉ ⵉⵜⵜⵡⴰⵡⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵎⴻⵜⵏⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵡⴹⴰ ⵓⵛⴰ ⴷⴷⵇⴻⵍ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵢⵓⵢⵍⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS23_1","024_23_1","ISA","23","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⵚⵓⵔ. “‘ⵔⵓⵎ, ⴰ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ, ⵎⴰⵖⴰⵔ ⵜⴻⵀⴷⴻⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵍⴰ ⴷ ⵍⵎⵓⵢⵢⵉ.’ ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⵉⵜⵜⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS23_2","024_23_2","ISA","23","2","2","‘ⵙⵓⵙⵎⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⴳⵣⵉⵔⵜ! ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵚⵉⴷⵓⵏ ⵉⵏⵏⵉ ⵉⵥⴻⴽⴽⵡⴰⵏ ⵍⴻⴱⵃⴰⵔ ⵙ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵛⵛⵓⵔⴻⵏ ⵛⴻⵎ ⵙ ⵙⵙⴻⵍⵄⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS23_3","024_23_3","ISA","23","3","3","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵙⵉⵅⵓⵔ, ⵚⵚⴰⴱⴻⵜ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ, ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⴷ ⵍⵎⴰⵔⵙⵉ ⵏ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS23_4","024_23_4","ISA","23","4","4","“‘ⵙⴻⴹⵃⴰ, ⴰ ⵛⴻⵎ ⵚⵉⴷⵓⵏ!’ ⵎⴰⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵉⵇⵇⴰⵔ, ⵍⴱⵓⵔⵊ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉⵇⵇⴰⵔ: ‘ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⵓⵖⵉ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵓⵔⵉⵡⴻⵖ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵖⵉⵎⵉⵖ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵓ ⵡⴰⵔ ⴰⵔⴻⴱⴱⵉⵖ ⵜⵉⵄⵣⵓⵔⴰⵢ.’ ");
INSERT INTO rift_vpl VALUES ("IS23_5","024_23_5","ISA","23","5","5","ⵅⵎⵉ ⵖⴰ ⵢⴰⵡⴻⴹ ⵍⴻⵅⴱⴰⵔ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵣⴱⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵍⴻⵃⵔⵉⵇ ⵅⵎⵉ ⵖⴰ ⵙⵍⴻⵏ ⵉ ⵍⴻⵅⴱⴰⵔ ⵅ ⵚⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS23_6","024_23_6","ISA","23","6","6","“‘ⵥⵡⴰⵎ ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ, ⵙⵖⵓⵢⵢⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⴳⵣⵉⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS23_7","024_23_7","ISA","23","7","7","ⵎⴰ ⵡⴰ ⴷ ⴰⵛⵜⴰⴱ ⵏⵡⴻⵎ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵍ’ⴰⵚⴻⵍ ⵏⵏⴻⵙ ⵉⴵⴰⵏ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ? ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⴰⵔⴱⵓⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⴻⵇⵇⵉⵎ ⴰⵎ ⵜⴱⴰⵔⵔⴰⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS23_8","024_23_8","ISA","23","8","8","ⵡⵉ ⵉⵅⴰⵔⵔⵚⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⵚⵓⵔ, ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⴱⴻⵟⵟⴰⵏ ⵜⵜⵉⵊⴰⵏ, ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ, ⵉⵜⵜⵉⵊⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("IS23_9","024_23_9","ISA","23","9","9","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵄⵉⴵⴻⵜ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⴰⵍⵡⵉⵣⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵥ ⵍⵄⴻⵣⵣ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS23_10","024_23_10","ISA","23","10","10","“‘ⵙⴻⵙⴼⵉⵢ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵏ ⵏⵉⵍ, ⴰ ⵛⴻⵎ ⵢⴻⴵⵉⵙ ⵏ ⵜⴰⵔⵛⵉⵛ! ⵡⴰⵔ ⵛⴻⵎ ⵜⵎⴻⵏⵏⴻⵄ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵄⴰⴷ!’ ");
INSERT INTO rift_vpl VALUES ("IS23_11","024_23_11","ISA","23","11","11","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⴻⴱⵃⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ. ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⴹⵉⴷⴷ ⵉ ⴽⴻⵏⵄⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴱⵓⵔⵊⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS23_12","024_23_12","ISA","23","12","12","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴼⴰⵔⵃⴻⴷ, ⵜᵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵜⴻⴷ, ⴰ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⴷⵓⵏ! ⵔⵓⵃ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴽⵉⵜⵜⵉⵎ, ⴽⴽⴰⵔ, ⵥⵡⴰ. ⵓⵍⴰ ⴷⵉⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵟⵟⵉⴼⴻⴷ ⵍⴻⵀⵏⴰ.’ ");
INSERT INTO rift_vpl VALUES ("IS23_13","024_23_13","ISA","23","13","13","ⵅⵣⴰⵔ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵍⴳⴻⵏⵙ-ⴰ ⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉⵏ, ⴰⵇⴰ ⵉⵏⴻⵢⵢⴻⵛ ⴰⵛⵛⵓⵔ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ - ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵍⴱⵓⵔⵊⴰⵜ ⵏⵙⴻⵏ ⵉ ⵡⴻⵀⵊⴰⵎ, ⵙⵙⵄⴰⵔⵔⴰⵏ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ - ⴰⵇⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS23_14","024_23_14","ISA","23","14","14","ⵔⵓⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ, ⵎⴰⵖⴰⵔ ⵍⴱⵓⵔⵊ ⵏⵡⴻⵎ ⵉⵜⵜⵡⴰⵀⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS23_15","024_23_15","ISA","23","15","15","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵚⵓⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⵜⵓ ⵍⵇⴻⴷⴷ ⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵎ ⵍⵇⴻⴷⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⵉ ⵚⵓⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵣⵍⵉ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ: ");
INSERT INTO rift_vpl VALUES ("IS23_16","024_23_16","ISA","23","16","16","‘ⴽⵙⵉ ⵍⴳⴰⵎⴱⵔⵉ, ⵓⵢⵓⵔ ⵓⵛⴰ ⵏⵏⴻⴹ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰ ⵛⴻⵎ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵉⵜⵜⵡⴰⵜⵜⵓⵏ! ⵉⵔⴰⵔ ⵉⵊⵊ ⵏ ⴵⵖⴰ ⵎⵍⵉⵃ ⵓⵛⴰ ⵖⴻⵏⵏⴻⵊ ⴰⵟⵟⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵎ ⵄⴻⵇⵍⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("IS23_17","024_23_17","ISA","23","17","17","ⴰⵡⴰⵔⵏⵉ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵔⵣⴻⴼ ⵚⵓⵔ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⴰⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS23_18","024_23_18","ISA","23","18","18","ⵎⴰⵛⴰ ⵜⴰⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵙ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⴷ ⵉⵍⵉⵏⵜ ⵇⴻⴷⴷⵙⴻⵏⵜ ⵉ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵅⴻⵎⵎⴻⵍ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵅⴻⵣⵣⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ ⴰⵍ ⵉ ⵖⴰ ⵊⵊⵉⵡⵏⴻⵏ ⵓⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS24_1","024_24_1","ISA","24","1","1","“ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⵅⵡⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⵜⵜ ⵉⵙⵙⵅⴰⵔⵔⴻⴱ, ⴰⴷ ⵉⵇⴻⴵⴻⴱ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴱⴻⵣⵣⴻⵄ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS24_2","024_24_2","ISA","24","2","2","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵍⴳⴻⵏⵙ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ, ⴰⵎ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵓⵍⴰ ⴷ ⵙⵉⴷⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵜⴰⵢⵢⴰ ⵓⵍⴰ ⴷ ⵍⵍⴰⵍⴰⵙ, ⴰⵎ ⵓⵎⵙⴻⵡⵡⴻⵇ ⵓⵍⴰ ⴷ ⴰⵎⵣⴻⵏⵣⵉ, ⴰⵎ ⴰⵔⴻⵟⵟⴰⵍ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉⵏ ⴰⵔⴹⴰⵍ, ⴰⵎ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵓⵍⴰ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS24_3","024_24_3","ISA","24","3","3","ⴰⴷ ⵙⵙⴻⵅⵡⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵜⵜ ⴽⴻⵛⵛⴹⴻⵏ ⵇⴰⵄ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵡⴰⵍ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("IS24_4","024_24_4","ISA","24","4","4","“ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⴹⴻⵏ, ⵜⵉⵙⵍⴰⵡ, ⴷⴷⵓⵏⴻⵛⵜ ⵜⴻⴼⵜⵓⵜⵜⴻⵙ, ⵜⵉⵙⵍⴰⵡ. ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⴼⵜⵓⵜⵜⵓⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS24_5","024_24_5","ISA","24","5","5","ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⴻⵜ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⵄⴻⴷⴷⴰⵏ ⵅ ⵉⵣⴻⵔⴼⴰⵏ, ⵜⵜⴱⴻⴷⴷⴰⵍⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ, ⵜⵜⴰⵔⴻⵥⵥⴰⵏ ⵍⵄⴰⵀⴷ ⵏ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS24_6","024_24_6","ISA","24","6","6","ⵅ ⵓⵢⴰ ⵜᵉⵜⵜⴻⵜⵜ ⵏⵏⴻⵄⵍⴻⵜ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵢⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⵍⵄⵉⴱ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵛⴻⵟⵟⴻⵏ ⴷⵔⵓⵙ ⵏ ⵉⵡⴷⴰⵏ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS24_7","024_24_7","ISA","24","7","7","“ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵉⵛⴹⴻⵏ, ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜⴻⴼⵜⵓⵜⵜⴻⵙ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴼⴰⵔⵃⴻⵏ ⴷⴻⴳ ⵡⵓⵍ, ⵣⴻⵀⵀⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS24_8","024_24_8","ISA","24","8","8","ⵚⴰⴼⵉ ⵜⵉⵛⵜⵉ ⵉⵙⵙⴼⴰⵔⵔⴰⵃⴻⵏ ⵏ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ, ⴷⴷⵔⵉⵣ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵚⴰⴼⵉ ⵜⵉⵏⴻⵅⵜ ⵉⵙⵙⴼⴰⵔⵔⴰⵃⴻⵏ ⵏ ⵍⴳⴰⵎⴱⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS24_9","024_24_9","ISA","24","9","9","ⵡⴰⵔ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ ⵄⴰⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵖⴻⵏⵏⴻⵊ, ⵛⵛⵔⴰⴱ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵔⵣⴰⴳ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵙⴻⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS24_10","024_24_10","ISA","24","10","10","ⵜⴰⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⴱⴻⵍⵍⵄⴻⵏⵜ ⵉ ⵡⴰⴷⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("IS24_11","024_24_11","ISA","24","11","11","ⴷⴻⴳ ⵉⵎⴻⵙⵔⴰⵇ ⵜⵜⵡⴻⵄⵄⴹⴻⵏ ⵉⵡⴷⴰⵏ ⵅ ⴱⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⵡⴻⴷⴷⴰⵔ, ⴰⵙⵍⵉⵡⵍⴻⵡ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS24_12","024_24_12","ISA","24","12","12","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵡⴰⵀⴰ, ⵓ ⵜⴰⵡⵡⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵍⴱⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("IS24_13","024_24_13","ISA","24","13","13","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵖⴰⵔ ⵡⴻⵣⵡⴰⴹ ⵏ ⵓⵣⴻⵎⵎⵓⵔ, ⴰⵎ ⵖⴰⵔ ⵡⴻⵍⵇⴰⴹ ⵏ ⵓⴹⵉⵍ ⵅⵎⵉ ⵖⴰ ⵜⴻⵄⴷⵓ ⵚⵚⴰⴱⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS24_14","024_24_14","ISA","24","14","14","“ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ. ⵓⵎⵉ ⵙⵉⴷⵉ ⵉⵄⵓⴵⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⴷ ⵙⵙⵖⵓⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵉ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS24_15","024_24_15","ISA","24","15","15","ⵅ ⵓⵢⴰ, ⵙⵄⵓⴵⴻⵎ ⵅⴻⵏⵏⵉ ⵙⵉⴷⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵜⴼⴰⵡⵜ, ⵙⵄⵓⴵⴻⵎ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("IS24_16","024_24_16","ISA","24","16","16","ⵣⵉ ⵜⵎⵓⵡⵡⴰ ⵇⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏᵉⵜⵜⴻⵙⵍⴰ ⵉ ⵉⵣⵍⴰⵏ, ⵉ ⵓⵄⵓⴵⵉ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ!” ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ: ⵏⴻⵛⵛ ⴼⴻⵏⵏⵉⵖ, ⴼⴻⵏⵏⵉⵖ, ⵓⵛⵜ ⵅⴰⴼⵉ! ⵉⵎⴽⴻⵛⵛⴰⴹⴻⵏ ⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ, ⵓ ⵉⵎⴽⴻⵛⵛⴰⴹⴻⵏ ⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵎⵉⵏ ⵎⴰ ⵅⵙⴻⵏ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS24_17","024_24_17","ISA","24","17","17","ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴻⵙⵔⴰⴼⵜ ⴷ ⵍⴼⴻⵅ ⴰⴷ ⵅⴰⴽ ⵉⵍⵉⵏ, ⴰ ⴰⵎⴻⵣⴷⵓⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("IS24_18","024_24_18","ISA","24","18","18","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⴷⴷⵔⵉⵣ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵙⵔⴰⴼⵜ, ⴰⴷ ⵉⵏⵏⴰⵖ ⴷⵉ ⵍⴼⴻⵅ, ⵎⴰⵖⴰⵔ ⵜⵉⴱⵓⵔⵊⴰⵜⵉⵏ ⴷⵉ ⵍⵓⵄⵍⴰ ⴰⴷ ⵏⵏⵓⵔⵣⵎⴻⵏⵜ, ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵏⵀⴻⵣⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS24_19","024_24_19","ISA","24","19","19","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵛⴰⵔⵔⴻⴳ ⵇⴰⵄ, ⴰⴷ ⵜⴼⴻⴵⴻⵇ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⴼⴻⴵⴰⵇⴻⵏ, ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS24_20","024_24_20","ISA","24","20","20","ⴰⴷ ⵜⵎⴻⵢⵢⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵛⴰⵔ, ⴰⴷ ⵜⴻⵎⵔⴰⵢⵡⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵄⵛⵓⵛ ⵉ ⵜⵎⴻⵏⵙⵉⵡⵜ. ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⵣⵉⵢⵢⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⵡⴹⴰ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("IS24_21","024_24_21","ISA","24","21","21","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵅⵍⴻⴼ ⵙⵉⴷⵉ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵍⵓⵄⵍⴰ ⴷⵉ ⵍⵓⵄⵍⴰ, ⵓⵍⴰ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵅⵍⴻⴼ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS24_22","024_24_22","ISA","24","22","22","ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⴰⵎ ⵢⵉⵎⴻⵃⴱⴰⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵓ ⴰⴷ ⵜⵜⵡⴰⵃⴻⴱⴷⵙⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵣⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS24_23","024_24_23","ISA","24","23","23","ⵜⴰⵣⵉⵔⵉ ⴰⴷ ⵜⴻⵣⵡⴻⵖ ⵙ ⵓⵙⴻⴹⵃⵉ ⵓ ⵜⴰⴼⵓⵛⵜ ⵜⵙⴻⴹⵃⴰ ⵅⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵣⵣⴰⵜ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴷⵉⵏⵏⵉ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS25_1","024_25_1","ISA","25","1","1","“ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵄⵓⴵⴻⵖ, ⴰⴷ ⵚⴻⴱⴱⵃⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⴻⵄⵊⴻⴱ, ⴰⵟⵟⴰⵙ ⵏ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS25_2","024_25_2","ISA","25","2","2","ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⴰⵄⵓⵔⵔⵉⵛ ⵏ ⵢⴻⵥⵔⴰ, ⵜⴰⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵏ ⴷ ⵍⵅⵉⵔⴱⴻⵜ, ⵍⴻⵇⵚⴰⵔ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴰⵏⴷⵉⵏⵜ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⴷⴷⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("IS25_3","024_25_3","ISA","25","3","3","ⵅ ⵓⵢⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵄⵓⴵⴰ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵊⵀⴻⴷ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵜⴻⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("IS25_4","024_25_4","ISA","25","4","4","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵍⵇⴻⵍⵄⴰ ⵉ ⵓⵎⴰⵔⵅⵓ, ⴷ ⵍⵇⴻⵍⵄⴰ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⵅⵎⵉ ⵉⵜⵜⵏⴻⵃⵚⴰⵔ, ⵛⴻⴽ ⴷ ⴰⴷⵓⵔⵔⵉ ⵉ ⵡⴻⵏⵥⴰⵔ ⵉⵛⵛⴰⵜⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵉⵍⵉ ⴷⵉ ⵍⴻⵃⵎⵓ ⵎⵉⵏⵣⵉ ⵍⵃⴰⵔⴰⵊ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵛⵜ ⴰⵇⴰ-ⵜ ⴰⵎ ⵡⴻⵏⵥⴰⵔ ⵉⵛⵛⴰⵜⴻⵏ ⵅ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("IS25_5","024_25_5","ISA","25","5","5","ⴰⵎ ⵍⴻⵃⵎⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵢⵓⵥⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⴻⵖⴷⴻⴷ ⵍⵃⴰⵔⴰⵊ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⴰⵎ ⵜⵉⵍⵉ ⵏ ⵓⵙⴻⵢⵏⵓ ⵜⴻⵙⵙⴻⵙⵎⵉⴹ ⵍⴻⵀⵎⵓ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴷ ⵉⵣⵍⵉ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS25_6","024_25_6","ISA","25","6","6","“ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵅ ⵡⴻⴷⵔⴰⵔ-ⴰ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵙ ⵎⴰⵛⵛⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⴰⴷⵓⵏⵜ ⵅ ⵡⴻⴷⵔⴰⵔ-ⴰ ⵉ ⵎⴰⵔⵔⴰ ⵔⴻⴳⵏⵓⵙ, ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵙ ⴱⵉⵏⵓ ⵉⵚⴻⴱⵃⴻⵏ ⵇⴰⵄ, ⵙ ⵉⵛⵜ ⵏ ⵎⴰⵛⵛⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⴰⴷⵓⵏⵜ ⴷ ⵡⴰⴷⵓⴼ, ⵙ ⴱⵉⵏⵓ ⵉⵚⴻⴱⵃⴻⵏ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS25_7","024_25_7","ISA","25","7","7","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴻⵟⵟⴻⵍ ⵅ ⵡⴻⴷⵔⴰⵔ-ⴰ ⴰⵍⴻⵃⵃⴰⴼ ⵉ ⵣⵉ ⵜⵜⵍⴻⵃⵃⴰⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓⵍⴰ ⴷ ⴷⴷⵓⵔⵉ ⵉ ⵣⵉ ⵜⵜⵡⴰⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS25_8","024_25_8","ISA","25","8","8","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴰⵔⴹ ⵍⵎⴻⵡⵜ ⵉ ⵍⴻⴱⴷⴰ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⵉⵎⵙⴻⵃ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵎⴱⴰⴱ, ⴰⴷ ⵉⴽⴽⴻⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS25_9","024_25_9","ISA","25","9","9","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⵇⴰ ⴷⴰ, ⵡⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵅⴰⵙ ⵉ ⵏⴻⴳⴳⴰ ⴰⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏⵊⴻⵎ. ⵡⴰ ⴷ ⵙⵉⴷⵉ ⵏⵏⵉ ⵅ ⵏⴻⴳⴳⴰ ⴰⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ, ⴰⴷ ⵏⴻⵙⵍⵉⵡⵍⴻⵡ, ⴰⴷ ⵏⴼⴰⵔⵃ ⵅ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("IS25_10","024_25_10","ISA","25","10","10","ⵎⴰⵖⴰⵔ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⴰⵔⵙ ⵅ ⵡⴻⴷⵔⴰⵔ-ⴰ, ⵎⴰⵛⴰ ⵎⵓ’ⴰⴱ ⴰⴷ ⵉⵜⵜⵡⴰⴷⴷⴻⵣ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⴷⴷⴻⵣ ⵓⵍⵓⵎ, ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⵣⵓⴱⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS25_11","024_25_11","ISA","25","11","11","ⵎⵓ’ⴰⴱ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⴱⴻⵣⵣⴻⵄ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⴰⵎ ⵓⴼⴻⵜⵜⴰⵃ ⴷⴻⴳ ⵡⴻⴼⵜⴰⵃ. ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⴰⴹⴰⵔ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵙ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS25_12","024_25_12","ISA","25","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵀⴷⴻⵎ ⵍⴱⵓⵔⵊ ⵏ ⵉⵖⴻⴱⵍⴰⵡⴻⵏ ⵏⵏⴻⵛ ⵢⵓⵄⵍⴰⵏ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵀⵡⴰ, ⴰⴷ ⵜⴻⵏ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⴻⴳ ⵓⵛⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS26_1","024_26_1","ISA","26","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵏ ⵉⵣⵍⵉ-ⵢⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ: “ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴱⴻⴷⴷ ‘ⴰⵙⴻⵏⵊⴻⵎ’ ⴷ ⵍⴻⵃⵢⵓⴹ ⴷ ⵍⴻⵇⵡⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS26_2","024_26_2","ISA","26","2","2","ⴰⵔⵣⵎⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⵍⴳⴻⵏⵙ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ, ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⴰⵎⴰⵏ ⵉ ⵙⵉⴷⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS26_3","024_26_3","ISA","26","3","3","ⵙ ⵍⴱⴰⵍ ⵉⵎⵜⴻⵏ ⴰⵎ ⵜ ⵉⴵⴰ, ⵛⴻⴽ ⵜⵃⴻⵟⵟⵉⴷ ⵜ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵡⴰⵀ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵛⴰⵍⴰ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("IS26_4","024_26_4","ISA","26","4","4","“ⵜⴻⵛⵍⴻⵎ ⵅ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵖⴰⵔ ⴷⵉ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ, ⵉ ⵜⴻⴵⴰ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵣⵣⵎⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS26_5","024_26_5","ISA","26","5","5","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵔⵔⴰ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ ⴷⵉ ⵍⵓⵄⵍⴰ, ⵜⴰⵏⴷⵉⵏⵜ ⵢⵓⵄⵍⴰⵏ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵀⵡⴰ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵀⵡⴰ ⴰⵍ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⵜⵜ ⵉⵄⴰⵔⵏ ⴷⴻⴳ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("IS26_6","024_26_6","ISA","26","6","6","ⴰⴷ ⵅⴰⵙ ⵉⵄⴼⴻⵙ ⵓⴹⴰⵔ, ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵎⴻⵣⵍⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("IS26_7","024_26_7","ISA","26","7","7","“ⴰⴱⵔⵉⴷ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵉⵡⴰⵟⴰ, ⵏⵉⵛⴰⵏ ⵉ ⵉⴵⴰ ⵍⴰⵜⴰⵔ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵛⴻⴽ ⵜᵉⵜⵜⵙⴻⴳⴳⴰⵎⴻⴷ ⵜ. ");
INSERT INTO rift_vpl VALUES ("IS26_8","024_26_8","ISA","26","8","8","ⵓⵍⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵜⵓⵖⴰ ⵏⴻⵙⵙⵉⵜⵉⵎ ⴰⵛ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ ⵉⵎⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴷⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS26_9","024_26_9","ISA","26","9","9","ⵜⵓⵖⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⵡⴻⵃⵃⴰⵛ ⵉ ⵛⴻⴽ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵓⵍⴰ ⴷ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⴷⴰⵢⵉ, ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵅⴰⴽ ⵙ ⵊⵊⴻⵀⴷ. ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵙⴻⴳⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS26_10","024_26_10","ISA","26","10","10","“ⵎⴰⵍⴰ ⵉⵙⵙⵛⴻⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵃⵉⵏⵏⵉ ⵉ ⵓⵄⴻⴼⴼⴰⵏ, ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵍⴻⵎⵎⴻⴷ ⵜⴰⵙⴻⴳⴷⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⵍⵖⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ, ⵓ ⵡⴰⵔ ⵉⵥⴰⵔⵔ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS26_11","024_26_11","ISA","26","11","11","“ⴰ ⵙⵉⴷⵉ, ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴰⴷ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜ ⵜⵜⵡⵉⵍⵉⵏ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ ⵄⴰⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵣⴻⴳ ⵡⴰⵙⴰⵎ ⵏⵏⴻⵛ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵡⴰⵀ, ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⴻⵛⵛ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS26_12","024_26_12","ISA","26","12","12","ⴰ ⵙⵉⴷⵉ, ⵍⵃⵓⴽⵎ ⵏⵏⴻⵛ ⵅⴰⵏⴻⵖ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵀⵏⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS26_13","024_26_13","ISA","26","13","13","ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉⵙⵉⴷⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵙⴻⴵⴹⴻⵏ ⵅⴰⵏⴻⵖ. ⵣⵣⴰⵢⴻⴽ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴰⵇⴰ ⵏⴻⵜⵜⵉⴷⴰⵔ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS26_14","024_26_14","ISA","26","14","14","ⵉⵎⴻⵜⵜⴰⵏ ⵡⴰⵔ ⵜⵜⴻⴷⴷⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ, ⵍⴻⵅⵢⴰⵍⴰⵜ ⵡⴰⵔ ⵜⵜⵏⴻⴽⴽⴰⵔⴰⵏ. ⵙ ⵓⵢⴰ ⵜⵅⴻⵍⴼⴻⴷ ⴰⵙⴻⵏ ⵙ ⵍⵖⴰⵔ ⵓⵛⴰ ⵜⴻⵇⴹⵉⴷ ⵜⴻⵏ. ⵛⴻⴽ ⵜⴻⴽⴽⵙⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵇⵔⴰⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS26_15","024_26_15","ISA","26","15","15","ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴰⵔⵏⵉⴷ ⴷⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⵛⴻⴽ ⵜⴰⵔⵏⵉⴷ ⴷⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⵜᵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⴷ ⴷⴰⵢⴻⵙ, ⴰⵇⴰ ⵜⴻⵙⵙⵡⴻⵙⵄⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS26_16","024_26_16","ISA","26","16","16","“ⴰ ⵙⵉⴷⵉ, ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵔⵣⵓⵏ ⵅⴰⴽ, ⵣⴻⴵⵄⴻⵏ ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⵏⵙⴻⵏ ⵙ ⵜⵃⴻⵙⵙⴻⵛⵜ, ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵜⵓⵙⴰ ⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS26_17","024_26_17","ISA","26","17","17","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵏⴻⵣⴱⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴷ ⵜⴰⵔⵓ ⴰⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵙ ⵓ ⵜⴻⵙⵖⵓⵢⵢⵓ ⵙ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⵓⵖⴰ ⵏⴻⵛⵛⵉⵏ, ⴰ ⵙⵉⴷⵉ, ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS26_18","024_26_18","ISA","26","18","18","ⵜⵓⵖⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵅⵎⵉ ⵏⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵉⵎⵏⴻⵄ ⴰⵏⴻⵖ ⵍⴻⵃⵔⵉⵇ ⵏ ⵜⴰⵔⵡⴰ, ⵜⵓⵖⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵅⵎⵉ ⵏⵓⵔⵓ ⴰⵙⴻⵎⵎⵉⴹ. ⵡⴰⵔ ⴷⴷ-ⵏⵉⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS26_19","024_26_19","ISA","26","19","19","“ⵉⵎⴻⵜⵜⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⴷⴷⴰⵔⴻⵏ! ⵍⵅⴻⵛⴱⴰⵜ ⵉⵏⵓ ⴰⴷ ⴱⴻⴷⴷⴻⵏⵜ! ⴼⴰⵇⴻⵎ, ⵓⵛⴰ ⵙⵍⵉⵡⴻⵍⵡⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵓⵛⴰⵍ! ⴰⵇⴰ ⵏⵏⴷⴰ ⵏ ⵜⴼⴰⵡⵉⵏ ⴰⵎ ⵏⵏⴷⴰ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴰⵔⵓ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵉⵎⴻⵜⵜⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS26_20","024_26_20","ISA","26","20","20","“ⵓⵢⵓⵔ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⴷⴻⴼ ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵛ ⵏ ⴷⴰⵅⴻⵍ, ⴱⴻⵍⵍⴻⵄ ⵜⵉⵡⵡⵓⵔⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ⵙⵏⵓⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵍⵇⴻⴷⴷ ⵏ ⵉⵛⵜ ⵏ ⵜⵣⴻⵃⵣⵉⵃⵜ ⴰⵍ ⴷⴷ ⵉⵄⴷⵓ ⵡⴻⵙⵅⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("IS26_21","024_26_21","ISA","26","21","21","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⵍⴻⴼ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵄⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵅⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ, ⵡⴰⵔ ⵜⵅⴻⵎⵎⵉⵍ ⵄⴰⴷ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS27_1","024_27_1","ISA","27","1","1","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵅⵍⴻⴼ ⵙⵉⴷⵉ ⵣⵉ ‘ⵍⵉ$ⵉⵢⴰⵜⴰⵏ’, ⴰⴼⵉⵖⴰⵔ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹⴻⵏ ⵙ ⵜⴰⵣⵍⴰ, ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵉⵇⵙⴻⵃ, ⵉⵎⵖⴰⵔ ⴷ ⵉⵊⵀⴻⴷ, ⵡⴰⵀ ⴰⴷ ⵉⵅⵍⴻⴼ ⵣⵉ ‘ⵍⵉ$ⵉⵢⴰⵜⴰⵏ’, ⴰⴼⵉⵖⴰⵔ ⵉⵜⵜⴻⵃⵔⵓⵔⵓⴷⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵉⵏⴻⵖ ⵍⵀⴰⵢⵛⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS27_2","024_27_2","ISA","27","2","2","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ... ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵙ ⴱⵉⵏⵓ ⵉⵛⵏⴰⵏ. ⵖⴻⵏⵏⵊⴻⵎ ⵅⴰⵙ ⵙ ⵏⵏⵓⴱⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS27_3","024_27_3","ISA","27","3","3","ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⵜⵜ ⵉⵃⴹⴰ, ⴰⴷ ⵜⵜ ⵙⵙⴱⴻⵣⵣⴳⴻⵖ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜ ⵉⵊⴰⵔⵔⴻⵃ ⵃⴻⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⵄⴻⵙⵙⴻⵖ ⵙ ⵡⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS27_4","024_27_4","ISA","27","4","4","ⵜⴰⴼⵇⴻⵃⵜ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⴻⴵⵉ ⵇⴰⵄ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵣⵄⴻⵎ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⵣⵣⴰⵜⵉ ⵜⴰⵣⴻⴳⴳⵯⴰⵔⵜ ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵎⵎⴻⵏⵖⴻⵖ, ⴰⴷ ⵜⴻⵏ ⵙⵙⴰⵔⵖⴻⵖ ⵎⵓⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS27_5","024_27_5","ISA","27","5","5","ⵉⵍⵍⴰ ⵎⴰⵍⴰ ⵉⵟⵟⴻⴼ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⵓⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⵍⴻⵀⵏⴰ ⴰⴽⵉⴷⵉ, ⵡⴰⵀ ⴰⴷ ⵢⴻⴳⴳ ⵍⴻⵀⵏⴰ ⴰⴽⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("IS27_6","024_27_6","ISA","27","6","6","“ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵉⵡⵡⴻⵜ ⵢⴰⵄⵇⵓⴱ ⴰⵥⵡⴰⵔ, ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵏⵏⵓⵡⴰⵔ, ⴰⴷ ⵉⵢⵎⴰ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵍⵖⵉⴵⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS27_7","024_27_7","ISA","27","7","7","“ⵎⴰ ⵉⵡⵜⴰ ⵉ-ⵜ ⵏⴻⵜⵜⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ, ⵉⵡⵜⴰ ⵉ-ⵜ? ⵎⴰ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⴻⵜⵜⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("IS27_8","024_27_8","ISA","27","8","8","ⵛⴻⴽ ⵜⴰⵔⴻⴱⴱⵉⴷ ⵜⵜ ⵙ ⵍⴻⵇⵢⴰⵙ ⵍⴰⵎⵉ ⵜⵜ ⵜⴻⵏⴹⴰⵔⴻⴷ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⵣⵣⴰⵔ ⵉ-ⵜⵜ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵏⵏⴻⵙ ⵉⵇⴻⵙⵃⴻⵏ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS27_9","024_27_9","ISA","27","9","9","ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴰⵚⵍⴰⵃ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵢⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵜⴻⴽⵎⴻⵍ ⵣⴻⴳ ⵓⵃⴻⵢⵢⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ: ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵔ ⵎⴰⵔⵔⴰ ⵉⵥⵔⴰ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⴷ ⵉⵥⵔⴰ ⵏ ⵊⵊⴰⵔ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜⵜⴱⴻⴷⴷⵉⵏⵜ ⵄⴰⴷ ⵜⵔⴻⴱⴱⵉⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS27_10","024_27_10","ISA","27","10","10","“ⵎⴰⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵏ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵃⴰⴼⵉ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ, ⵉⵅⵍⴰⵏ ⴰⵎ ⵍⴻⵅⵍⴰ. ⴷⵉⵏⵏⵉ ⴰⴷ ⵉⵀⴷⴰ ⵓⵄⴻⵊⵎⵉ, ⴰⴷ ⴷⵉⵏ ⵉⵊⵏⴰ, ⴰⴷ ⵉⵛⵛ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS27_11","024_27_11","ISA","27","11","11","ⵅⵎⵉ ⵖⴰ ⵢⴰⵥⵖⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ. ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⴰⴷ ⵜⴻⵏ ⵙⵙⴰⵔⵖⴻⵏⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷⴰⵢⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ. ⵅ ⵓⵢⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵣⵣⵉⴵⵉⵣ, ⵓ ⵡⴻⵏⵏⵉ ⵜ ⵉⴽⴻⵡⵡⵏⴻⵏ, ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴰⵔⴻⵟⵟⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS27_12","024_27_12","ISA","27","12","12","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵣⵡⴻⴹ ⵙⵉⴷⵉ ⵜⵉⴷⵔⵉⵏ ⵣⵉ ⵎⴰⵏⵉ ⵉⴵⴰ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⴰⵍ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜⵡⴰⵍⴻⵇⴹⴻⵎ, ⵉⵊⵊⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS27_13","024_27_13","ISA","27","13","13","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵙⵓⴹⴻⵏ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵛⴰⵔⵔⵉ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⴷ ⵀⴻⵍⵍⴽⴻⵏ ⴷⵉ ⴰⵛⵛⵓⵔ ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵉ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS28_1","024_28_1","ISA","28","1","1","“ⵓⵛⵜ ⵅ ⵜⵜⴰⵊ ⵓⵄⴻⴼⴼⴰⵔ ⵏ ⵉⵎⴻⵙⵛⴰⵔⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⴰⵇⴰ ⵜⴰⵍⵡⵉⵣⵜ ⵏⵏⴻⵙ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵉⵙⵍⴰⵡⴻⵏ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵅ ⵢⴻⵖⵍⴻⴱ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS28_2","024_28_2","ISA","28","2","2","ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ ⵉⵊⵀⴻⴷ ⵓ ⵉⵡⵄⴰⵔ ⴰⵎ ⵜⴻⵛⵜⵉ ⵏ ⵜⴻⴱⵔⵓⵔⵉ, ⴰⵎ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵟⵟⴰⵄⵓⵏ ⴷ ⵓⵅⴰⵔⵔⴻⴱ. ⴰⵎ ⵍⵃⴻⵎⵍⴰⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵙⵙⴼⴰⵢⴻⵏ ⴰⴷ ⵉⵏⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵜⴰⵊ ⵏⵏⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS28_3","024_28_3","ISA","28","3","3","ⵜⵜⴰⵊ ⴰⵄⴻⴼⴼⴰⵔ ⵏ ⵉⵎⴻⵙⵛⴰⵔⴻⵏ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵜ ⵄⴻⴼⵙⴻⵏ ⵙ ⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS28_4","024_28_4","ISA","28","4","4","ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵉⵙⵍⴰⵡⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵣⵜ ⵏⵏⴻⵙ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ, ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵜⴱⴰⵛⵓⵔⵜ ⵜⵉⵡⴻⴹ ⵇⴱⴻⵍ ⴰⵏⴻⴱⴷⵓ, ⵜⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵉⵥⵔⴰ ⵉ-ⵜⵜ ⵓⵛⴰ ⵉⵙⵙⴻⵖⵍⵉ ⵉ-ⵜⵜ ⴷⴻⵖⵢⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS28_5","024_28_5","ISA","28","5","5","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵜⴰⵊⵊ ⵏ ⵓⵛⵓⵡⵡⴰⴹ ⴷ ⵜⵜⴰⵊ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("IS28_6","024_28_6","ISA","28","6","6","ⴷ ⴰⵔⵔⵓⵃ ⵏ ⵍⵃⵓⴽⵎ ⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⴽⵓⵔⵙⵉ ⵉ ⵍⵃⵓⴽⵎ, ⵓⵍⴰ ⴷ ⴰⵔⵔⵓⵃ ⵏ ⵜⴰⵔⵢⴰⵙⵜ ⵉ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⴰⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS28_7","024_28_7","ISA","28","7","7","“ⵄⴰⴷ ⵉⵏⴰ ⵜⵜⴻⵎⵎⵔⴰⵢⵡⴰⵏ ⵙ ⴱⵉⵏⵓ, ⵓⵛⴰ ⵜⵜⵡⴰⵔⴻⵏⵢⴻⵏ ⵣⵉ ⵛⵛⵔⴰⴱ. ⵉⵜⵜⴻⵎⵔⴰⵢⵡⴰ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵓⵏⴰⴱⵉ ⵙ ⵛⵛⵔⴰⴱ. ⵜⵜⵡⴰⵚⴰⵔⴹⴻⵏ ⵙ ⴱⵉⵏⵓ, ⵜⵜⵡⴰⵔⴻⵏⵢⴻⵏ ⵣⵉ ⵛⵛⵔⴰⴱ, ⵜⵜⴻⵎⵔⴰⵢⵡⴰⵏ ⵖⴰⵔ ⵉⵡⴻⵃⵃⴰⵏ ⵏⵙⴻⵏ, ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵓⵎⵉ ⵃⴻⴽⴽⵎⴻⵏ ⵖⴰⵔ ⵓⵛⴰⵔⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("IS28_8","024_28_8","ISA","28","8","8","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵟⵟⴰⴱⵍⴰⵜ ⵄⴻⵎⵎⴰⵔⴻⵏⵜ ⵙ ⵜⵔⴰⵔⵉⵜ ⵉⵅⴻⵎⵊⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("IS28_9","024_28_9","ISA","28","9","9","‘ⵉ ⵓⵎⵉ ⵉⵅⵙ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵖⴰⵔ ⵜⵓⵙⵙⵏⴰ, ⵉ ⵓⵎⵉ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴰⵔⴻⵇⵇⴰⵙ? ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⴰⵙⴻⵏ ⵓⵖⵉ, ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⴽⴽⵙⴻⵏ ⴰⴱⴱⵓⵛ? ");
INSERT INTO rift_vpl VALUES ("IS28_10","024_28_10","ISA","28","10","10","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⴰ, ⵍⵓⵎⵓⵔ ⵅ ⵍⵓⵎⵓⵔ, ⵍⵓⵎⵓⵔ ⵅ ⵍⵓⵎⵓⵔ, ⵍⴼⴰⵔⵉⴹⴰ ⵅ ⵍⴼⴰⵔⵉⴹⴰ, ⵍⴼⴰⵔⵉⴹⴰ ⵅ ⵍⴼⴰⵔⵉⴹⴰ, ⴷⴰ ⴷⵔⵓⵙⵜ, ⴷⵉⵀⴰ ⴷⵔⵓⵙⵜ.’” ");
INSERT INTO rift_vpl VALUES ("IS28_11","024_28_11","ISA","28","11","11","“ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ-ⴰ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵟⵟⴻⵡⵟⵉⵡⴻⵏ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("IS28_12","024_28_12","ISA","28","12","12","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ: ‘ⵡⴰ ⴷ ⴰⵔⵔⴰⵃⴻⵜ, ⵡⵛⴻⵎ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵡⴻⵏⵏⵉ ⵢⵓⵃⵍⴻⵏ!’, ⵓⵛⴰ: ‘ⵡⴰ ⴷ ⵍⵎⴰⵔⴳⴻⵃ!’, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⵛⴰ ⴰⴷ ⵙⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS28_13","024_28_13","ISA","28","13","13","ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ: ‘ⵍⵓⵎⵓⵔ ⵅ ⵍⵓⵎⵓⵔ, ⵍⵓⵎⵓⵔ ⵅ ⵍⵓⵎⵓⵔ, ⵍⴼⴰⵔⵉⴹⴰ ⵅ ⵍⴼⴰⵔⵉⴹⴰ, ⵍⴼⴰⵔⵉⴹⴰ ⵅ ⵍⴼⴰⵔⵉⴹⴰ, ⴷⴰ ⴷⵔⵓⵙⵜ, ⴷⵉⵀⴰ ⴷⵔⵓⵙⵜ!’, ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ, ⴰⵎ ⵓⵢⵓⵔⴻⵏ, ⴰⴷ ⵡⴹⴰⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷⵉ ⵍⴼⴻⵅ ⵓ ⴰⴷ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS28_14","024_28_14","ISA","28","14","14","“ⵙ ⵓⵢⴰ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("IS28_15","024_28_15","ISA","28","15","15","ⵎⵉⵏⵣⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⴳⴳⴰ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵍⵎⴻⵡⵜ ⵓ ⵏⴻⴳⴳⴰ ⵉⵛⵜ ⵏ ⴹⴹⵎⴰⵏⴰ ⴰⴽ-ⴷ ⵍⴰⵅⴰⵔⵜ. ⵅⵎⵉ ⵖⴰ ⵉⵄⴷⵓ ⵓⵔⴻⴽⴽⵓⴹ ⵉⴼⴰⵔⵛⴻⵏ, ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵢⵉⵡⵉⴹ, ⵎⴰⵖⴰⵔ ⵏⴻⴳⴳⴰ ⴰⵅⴰⵔⵔⵉⵇ ⴰⵅⵎⵉ ⵎⴰⵏⵉ ⵖⴰⵔ ⵉ ⵖⴰ ⵏⴰⵔⵡⴻⵍ ⵓ ⴰⴷ ⵏⴻⵏⵏⵓⴼⴼⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵖⴻⵛⵛ!’ ");
INSERT INTO rift_vpl VALUES ("IS28_16","024_28_16","ISA","28","16","16","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴰⵥⵔⵓ ⵉⵇⴻⴵⴱⴻⵏ, ⴰⵥⵔⵓ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵉⵖⵍⴰⵏ, ⴷⵙⴰⵙ ⵉⵎⵜⴻⵏ. ⵡⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵔⵉⴽⵡⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("IS28_17","024_28_17","ISA","28","17","17","ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⵍⵃⴻⵇⵇ ⴷ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵓⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⴱⵍⵓⵎⵓ. ⵜⴻⴱⵔⵓⵔⵔⵉ ⴰⴷ ⵜⴻⵃⵃⴰ ⴰⵎⵛⴰⵏ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⴰⵎⴰⵏ ⴰⴷ ⴷⴷ-ⵙⵙⴻⴼⵢⴻⵏ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵓⴷⴷⵓⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS28_18","024_28_18","ISA","28","18","18","ⵍⵄⴰⵀⴷ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵍⵎⴻⵡⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵃⴰ, ⴹⴹⵎⴰⵏⴰ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵍⴰⵅⴰⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵜⴱⴻⴷⴷ. ⵅⵎⵉ ⵖⴰ ⵉⵄⴷⵓ ⵓⵔⴻⴽⴽⵓⴹ ⵉⴼⴰⵔⵛⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⵄⴻⴼⵙⴻⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("IS28_19","024_28_19","ISA","28","19","19","ⵎⴻⵍⵎⵉ ⵎⴰ ⵉⵄⴷⵓ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵡⵉ ⴰⴽⵉⴷⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⵄⴷⵓ ⵜⵓⴼⵓⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵓⴼⵓⵜ, ⵙ ⵡⴰⵙⵙ ⴷ ⴵⵉⵔⴻⵜ. ⵓⵛⴰ ⴰⴼⴻⵀⵀⴰⵎ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⴰⴷ ⵢⴰⵡⵉ ⵎⵖⵉⵔ ⴰⵙⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS28_20","024_28_20","ISA","28","20","20","ⵎⴰⵖⴰⵔ ⵇⴰⵎⴰ ⴰⴷ ⵉⵇⵓⴹⴻⴹ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴱⴱⵓⵣⵣⴻⵔ ⵓⵛⴰ ⵜⴰⵄⵍⴰⵡⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵃⵚⴰⵔ ⴰⵍⴰⵎⵉ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⴷⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("IS28_21","024_28_21","ISA","28","21","21","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⴽⴽⴰⵔ ⴰⵎ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⴼⴰⵔⴰⵚⵉⵎ, ⴰⴷ ⵉⵀⴰⵊ ⴰⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵊⵉⴱⵄⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ: ‘ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⵔⵉⴱ!’, ⵓⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ: ‘ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵖⵔⵉⴱⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS28_22","024_28_22","ISA","28","22","22","ⵓ ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵙⵙⴻⵀⵇⴰⵔⴰ, ⵃⵉⵎⴰ ⵙⵙⵏⴰⵙⴻⵍ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵣⴻⵢⵢⴰⵔⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ, ⵎⴰⵖⴰⵔ ⵙⵍⵉⵖ ⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⵇⴰ ⵉⴽⴽⴻⵙ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS28_23","024_28_23","ISA","28","23","23","“ⵙⵃⴻⵙⵙⴻⵎ ⵓ ⵙⵍⴻⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵃⴹⴰⵎ ⵓ ⵙⵍⴻⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS28_24","024_28_24","ISA","28","24","24","ⵎⴰ ⵉⵛⴰⵔⵔⴻⵣ ⵓⵎⵛⴰⵔⵔⴻⵣ ⴰⵙⵙ ⵉⵎⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴰⵔⵄ? ⵎⴰ ⵍⴻⴱⴷⴰ ⵉⵜⵜⴼⴻⴵⴻⵃ ⵓ ⵉⵏⴻⵇⵇⴻⵛ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("IS28_25","024_28_25","ISA","28","25","25","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⵎⵓ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵡⴰⵟⴰ ⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵉⵙⵙⵓⵢⵓⵙ ⵙⵙⴰⵏⵓⴵ ⵓⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵍⵛⴻⵎⵎⵓⵏ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⵜ, ⵉⴳⴳⴰ ⵉⵔⴷⴻⵏ ⴷⵉ ⵍⴻⵚⴼⵓⴼ ⴷ ⵉⵎⴻⵏⴷⵉ ⴷⵉ ⵉⴽⵡⴰⴷⵔⵓⵏⴻⵏ ⵓⵛⴰ ⴽⴰⵔⵚⴰⵏⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵖⴰⵔ ⵜⵎⴰⵡⵡⵉⵏ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("IS28_26","024_28_26","ISA","28","26","26","ⵉⴷⴰⵔⵔⴻⴱ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵅⴷⴻⵎ ⵏⵉⵛⴰⵏ, ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("IS28_27","024_28_27","ISA","28","27","27","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵙⵙⴰⵔⵡⴰⵜⴻⵏ ⵙⵙⴰⵏⵓⴵ ⵙ ⵜⴻⵍⵡⵉⵃⵜ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ ⵓ ⵡⴰⵔ ⵙⵙⴻⴽⴽⵉⵏ ⵜⴰⵊⴰⵔⵔⴰⵔⵜ ⵏ ⵓⴽⴰⵔⵔⵓ ⵜⵉⵡⴰ ⵏ ⵍⵛⴻⵎⵎⵓⵏ, ⵎⴰⵛⴰ ⵣⴻⴽⴽⵡⴹⴻⵏ ⵙⵙⴰⵏⵓⴵ ⵙ ⵡⴻⵄⵎⵓⴷ ⴷ ⵍⵛⴻⵎⵎⵓⵏ ⵙ ⵓⵇⴻⵟⵟⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("IS28_28","024_28_28","ISA","28","28","28","ⵎⴰ ⵃⴰⵔⵔⵢⴻⵏ ⵉⵎⴻⵏⴷⵉ ⵖⴰⵔ ⵓⵙⴰⵔⵡⴻⵜ? ⵍⵍⴰ, ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵜ ⵉⵙⵙⴰⵔⵡⵉⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵏⴻⴷⴷⴻⵀ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵏ ⵓⴽⴰⵔⵔⵓ ⴷ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ: ⵡⴰⵔ ⵜ ⵉⵃⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS28_29","024_28_29","ISA","28","29","29","ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵛⵛⵡⴰⵔ ⵏⵏⴻⵙ ⴷ ⵍⴻⵄⵊⴻⴱ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵖⴰⵔ ⴷⴻⴳ ⵓⵙⵓⵢⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS29_1","024_29_1","ISA","29","1","1","“ⵓⵛⵜ ⵅ ⴰⵔⵉⵢⵉⵍ, ⴰⵔⵉⵢⵉⵍ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴷⴰⵡⵓⴷ. ⴰⵔⵏⵉⵎ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵓⵙⴻⴳⴳⵯⴰⵙ-ⴰ, ⵊⵊⴻⵎ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⴷ ⵄⴷⵓⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("IS29_2","024_29_2","ISA","29","2","2","ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⵚⴰⵔⴻⵖ ⴰⵔⵉⵢⵉⵍ, ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵓⵡⴻⵃⵡⴻⵃ ⴷ ⵡⴻⵛⴹⴰⵏ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⴰⵔⵉⵢⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS29_3","024_29_3","ISA","29","3","3","ⴰⴷ ⴰⵎ ⵇⴻⵡⵡⴰⵔⴻⵖ ⵓ ⴰⴷ ⵛⴻⵎ ⵃⵚⴰⵔⴻⵖ ⵙ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵓⵃⴻⵟⵟⵓ ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⴱⴰⵔⴰⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS29_4","024_29_4","ISA","29","4","4","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⵉⴷ, ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵏ ⵜⵔⴻⵎⵔⴻⵎⴷ ⵣⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ. ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵜⵜⴰⵏ ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵓⵛⴻⵡⵛⴻⵡ ⵡⴰⵀⴰ ⵣⴻⴳ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("IS29_5","024_29_5","ISA","29","5","5","ⴰⴱⴰⵔⵔⵓ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵜⴰⵣⴷⴰⴷⵜ, ⵓⵛⴰ ⴰⴱⴰⵔⵔⵓ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⴰⵎ ⵓⵍⵓⵎ ⵉⵄⴻⴷⴷⵓⵏ, ⵉⵜⵜⴰⵡⵢ ⵉ-ⵜ ⵓⵙⴻⵎⵎⵉⴹ. ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ! ");
INSERT INTO rift_vpl VALUES ("IS29_6","024_29_6","ISA","29","6","6","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵏⵏⴻⵡⵊⵓ ⵙ ⵡⴰⵊⵊⴰⵊ ⴷ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵙ ⵍⵃⴻⵙⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵓ ⵙ ⵓⵛⴻⵄⵄⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS29_7","024_29_7","ISA","29","7","7","ⴰⵎ ⵜⴰⵔⵊⵉⵜ, ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⴷⵉ ⴵⵉⵍⴻⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⴱⴰⵔⵔⵓ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⴰⵔⵉⵢⵉⵍ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵓ ⴰⴽ-ⴷ ⵍⴱⵓⵔⵊ ⵏⵏⴻⵙ ⴷ ⵉⵏⵏⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⵃⵚⴰⵔⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("IS29_8","024_29_8","ISA","29","8","8","ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵢⵓⵔⵊⴰ ⵓⵎⵉ ⴷⴰⵢⴻⵙ ⵢⴻⴵⴰ ⵍⴰⵥ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵜⵜ, ⵅⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴰⵇ, ⵢⵓⴼⴰ ⴰⵇⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵊⵊⵉⵡⴻⵏ ⵄⴰⴷ. ⵏⵉⵖ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵊⵊⴻⵏ ⵢⵓⵔⵊⴰ ⴰⵎ ⵉⴼⴼⵓⴷ, ⵓ ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵙⴻⵙⵙ, ⵅⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴰⵇ, ⵢⵓⴼⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴼⵏⴰ, ⵓⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵄⴰⴷ ⴰⴷ ⵉⵙⵓ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS29_9","024_29_9","ISA","29","9","9","“ⵊⵄⴰⵔⴻⵎ ⵓ ⵜⴱⴻⵀⵜⴻⵎ, ⵙⵎⴻⵙⵃⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⵍ ⵉ ⵖⴰ ⵜⵉⵍⵉⵎ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ! ⵏⵉⵜⵏⵉ ⵙⵛⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⴱⵉⵏⵓ, ⵜⵜⴻⵎⵔⴰⵢⵡⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵛⵛⵔⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("IS29_10","024_29_10","ISA","29","10","10","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵣⴻⴵⴻⵄ ⵅⴰⵡⴻⵎ ⴱⵓⵃⴱⴻⵍ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⵖⴻⵏ. ⵉⴱⴻⵍⵍⴻⵄ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ, ⵉⵎⵡⴰⵍⴰⵡⴻⵏ ⵏ ⵜⵎⴻⵥⵔⵉⵡⵉⵏ, ⵉⵍⴻⵃⵃⴻⴼ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS29_11","024_29_11","ISA","29","11","11","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⴷⵡⴻⵍ ⵍⴻⵡⵃⵉⵢ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴰⵎ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵜⵉⵖⵔⵉ, ⵇⵇⴰⵔⴻⵏ: ‘ⵖⴰⵔ ⵉ-ⵜ-ⵉ-ⴷ ⵅⴰⴼⵉ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⵖⴰⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵉⵛⴻⵎⵎⴻⵄ.’ ");
INSERT INTO rift_vpl VALUES ("IS29_12","024_29_12","ISA","29","12","12","ⵏⵉⵖ ⵉⵎⵎⴻⵡⵛ ⵡⴻⴷⵍⵉⵙ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵏⴻⵏ ⴰⴷ ⵉⵖⴰⵔ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵖⴰⵔ ⵉ-ⵜ-ⵉ-ⴷ ⵅⴰⴼⵉ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔ ⵏⴻⵜⵜⴰ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("IS29_13","024_29_13","ISA","29","13","13","“ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ‘ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵢⵓⴷⴻⵙ ⴰⵢⵉ-ⴷⴷ ⵎⵖⵉⵔ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵡⴰⵀⴰ ⵓ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⵉ ⵛⵛⴰⵏ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⵓⵍ ⵏⵙⴻⵏ, ⵓ ⵎⵉⵏⵣⵉ ⴰⵡⴻⵇⵇⴰⵔ ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⵉ ⵍⴻⵎⴷⴻⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵡⴰⵀⴰ, ");
INSERT INTO rift_vpl VALUES ("IS29_14","024_29_14","ISA","29","14","14","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵔⴻⵏⵏⵉⵖ ⴰⴷ ⴳⴳⴻⵖ ⴷⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵙ ⵍⴻⵄⵊⴻⴱ, ⵙ ⵍⴻⵄⵊⴻⴱ ⴷ ⵓⵙⵜⴻⴱⵀⴻⵜ. ⵜⵉⵖⵉⵜ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⴷ ⵜⴻⴼⵏⴰ ⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵉⴼⴻⵀⵀⴰⵎⴻⵏ ⴰⴷ ⵜⵡⴻⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS29_15","024_29_15","ISA","29","15","15","ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵏⵓⴼⴼⴰⵔⴰⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ ⴰⵅⴰⵔⵔⵉⵚ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵍⴰⵎ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉⵥⵔⵉⵏ ⴷ ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵏⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("IS29_16","024_29_16","ISA","29","16","16","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴻⵏⵇⴻⵍⴱⴻⵎ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ! ⴰⵅⵎⵉ ⵣⴻⵄⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴱⵓ-ⵜⵍⴰⵅⵜ ⴰⵎ ⵜⵍⴰⵅⵜ, ⴰⵍⴰⵎⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⴷ ⵢⵉⵏⵉ ⵅ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉ!’, ⵓⵛⴰ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ ⴰⴷ ⵜⵉⵏⵉ ⵅ ⵓⵇⴻⴷⴷⴰⵔ ⵏⵏⴻⵙ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵃⵉⴽⵉ ⵡⴰⵍⵓ!’” ");
INSERT INTO rift_vpl VALUES ("IS29_17","024_29_17","ISA","29","17","17","“ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵔⵓⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍ ⵖⴰ ⵉⴷⵡⴻⵍ ⵍⵓⴱⵏⴰⵏ ⴷ ⵍⵄⴰⵔⵙⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵍⵄⴰⵔⵙⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⴰⵣⵖⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("IS29_18","024_29_18","ISA","29","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵙⵍⴻⵏ ⵉⴷⴻⵀⵛⵓⵔⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⵡⴰⵍⴰⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴹⴰⵔⵖⴰⵍⴻⵏ ⵣⵉ ⵜⴰⴵⴻⵙⵜ ⵓ ⵣⵉ ⵟⵟⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("IS29_19","024_29_19","ISA","29","19","19","ⴰⴷ ⴰⵔⵏⵉⵏ ⵉⵎⵡⴰⴹⵄⴻⵏ ⴷⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⵉ ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵊⴰⵔ ⵉⵡⴷⴰⵏ ⴷⴻⴳ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS29_20","024_29_20","ISA","29","20","20","ⵎⴰⵖⴰⵔ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⴰⴷ ⵉⵇⴹⴰ, ⵡⴻⵏⵏⵉ ⵉⵙⵜⵀⴻⵣⴰⵏ ⴰⴷ ⵉⴼⵏⴰ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⵖⴻⵛⵛ ⴰⴷ ⵏⵏⵇⴻⴹⵄⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS29_21","024_29_21","ISA","29","21","21","ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵄⵉⴱ ⴷⵉ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵡⴰⵀⴰ, ⵉⵏⵏⵉ ⵉⵙⵙⵔⵓⵙⴰⵏ ⵍⴻⴼⵅⵓⵅ ⵉ ⵢⵉⵏⵏⵉ ⵉⴷⴻⴼⴼⵄⴻⵏ ⵍⵃⴻⵇⵇ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵄⴰⵔⵔⵏⴻⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵅ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS29_22","024_29_22","ISA","29","22","22","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ: ‘ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⵉⵜⵜⵙⴻⴹⵃⵉ ⵄⴰⴷ ⵓⵛⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⴻⵡⵔⵉⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("IS29_23","024_29_23","ISA","29","23","23","ⵎⴰⵖⴰⵔ ⵅⵎⵉ ⵖⴰ ⵉⵥⴰⵔ ⵏⴻⵜⵜⴰ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS29_24","024_29_24","ISA","29","24","24","ⵉⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴷⵉ ⴱⵓⵃⴱⴻⵍ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⴷⵇⴰⵎⴻⵏ, ⴰⴷ ⴰⵔⵣⵎⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⴰⴷ ⵍⴻⵎⴷⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS30_1","024_30_1","ISA","30","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵓⵛⵜ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵛⵛⵡⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵣⴰⵢⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵄⵓⵔⵔⵛⴻⵏ ⴷⴷⴻⵏⴱ ⵅ ⴷⴷⴻⵏⴱ, ");
INSERT INTO rift_vpl VALUES ("IS30_2","024_30_2","ISA","30","2","2","ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵀⵡⴰⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵏⵀⵍⴰ ⵎⴰ ⴰⴷ ⴰⵢⵉ ⵙⵙⴻⵇⵙⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⴼⴻⵏ ⴰⵙⴻⵍⵇⵉ ⵖⴰⵔ ⵊⵊⴻⵀⴷ ⵏ ⴼⵉⵔⵄⵓⵏ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⵉⵍⵉ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS30_3","024_30_3","ISA","30","3","3","ⵎⴰⵛⴰ ⵊⵊⴻⵀⴷ ⵏ ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⵜᵉⵜⵜⵙⴻⴹⵃⴰⵎ ⵓⵛⴰ ⴰⴷⵓⵔⵔⵉ ⴷⵉ ⵢⵉⵍⵉ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴹⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("IS30_4","024_30_4","ISA","30","4","4","ⵎⴰⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴵⴰⵏ ⴷⵉ ⵚⵓⵄⴰⵏ ⵓⵛⴰ ⵉⵎⵙⴻⴽⴽⴰⵏ ⵏⵏⴻⵙ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵃⴰⵏⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("IS30_5","024_30_5","ISA","30","5","5","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴰⵔⵔⵇⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵏⴻⴼⴼⵄⴻⵏ ⵛⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵛⴻⵏ ⴰⴼⵓⵙ ⵓⵍⴰ ⴷ ⵡⴰⵍⵓ ⵏ ⵍⴻⴼⴹⴻⵍ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵡⵉ ⵖⴰⵔ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷ ⵍⵀⴻⴳⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS30_6","024_30_6","ISA","30","6","6","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⵍⵎⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. “ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⴷⴷⴻⴵ, ⵎⴰⵏⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵜⴰⵢⵔⴰⴷⵜ ⴷ ⵡⴻⵢⵔⴰⴷ ⴷ ⵓⴼⵉⵖⴰⵔ ⴷ ⵍⵃⴰⵢⵛⴻⵜ ⵉⵛⴻⵎⴹⴻⵏ ⵉⵟⵟⴰⵡⴻⵏ, ⴰⵔⴻⴱⴱⵓⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵅ ⵡⴻⵄⵔⵓⵔ ⵏ ⵉⵙⵏⵓⵙⴻⵏ ⴷ ⵍⴻⴽⵏⵓⵣ ⵏⵙⴻⵏ ⵅ ⵜⴻⵄⵔⵓⵔⵉⵏ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⴻⴼⴼⴻⵄ ⴷⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS30_7","024_30_7","ISA","30","7","7","ⵎⴰⵖⴰⵔ ⵎⵉⵚⵔⴰ ⴰⴷ ⵉⵡⵛ ⴰⴼⵓⵙ ⴱⴰⵟⴻⵍ ⵓ ⵉ ⵡⴰⵍⵓ. ⵙ ⵓⵢⴰ ⵍⴰⵖⵉⵖ ⵎⵉⵚⵔⴰ ⵡⴰⵏⵉⵜⴰ: ‘ⵔⴰⵀⴰⴱ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵜⴻⵇⵇⵉⵎ ⵡⴰⵀⴰ!’” ");
INSERT INTO rift_vpl VALUES ("IS30_8","024_30_8","ISA","30","8","8","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵙ-ⴷⴷ, ⴰⵔⵉ ⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵅ ⵜⴻⵍⵡⵉⵃⵜ, ⵅⴻⴱⵛ ⵉ-ⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵃⴹⴰ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵉ ⵍⴻⴱⴷⴰ ⵏ ⵍⴻⴱⴷⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS30_9","024_30_9","ISA","30","9","9","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵍⴳⴻⵏⵙ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("IS30_10","024_30_10","ISA","30","10","10","ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵉⵎⵡⴰⵍⴰⵡⴻⵏ: ‘ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵎ ⵡⴰⵍⵓ!’, ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵉⵡⴻⵃⵃⴰⵏ: ‘ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵎ ⵉⵡⴻⵃⵃⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ. ⵙⵉⵡⵍⴻⵎ ⴰⴽⵉⴷⵏⴻⵖ ⵎⵉⵏ ⴷⴷ ⵉⵙⵙⵃⵉⵏⵏⵉⴱⴻⵏ, ⵎⵍⵉ ⴷ ⴰⵏⴻⵖ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵎⵉⵏ ⵉⵖⴻⵛⵛⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("IS30_11","024_30_11","ISA","30","11","11","ⵃⴻⵢⵢⴷⴻⵎ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴼⴼⵖⴻⵎ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵊⵊⴻⵎ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⵉⴳⴳⵯⴻⵊ!’” ");
INSERT INTO rift_vpl VALUES ("IS30_12","024_30_12","ISA","30","12","12","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⴹⴰⵔⴻⵎ ⴰⵡⴰⵍ-ⴰ, ⵜᵉⵜⵜⴻⵛⵍⴻⵎ ⵅ ⴷⴷⴻⴵ ⵓ ⵅ ⵎⵉⵏ ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵡⴰⵀ, ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵍⴰⵎⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("IS30_13","024_30_13","ISA","30","13","13","ⵙ ⵓⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ-ⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵍⵃⵉⴹ ⵉ ⵖⴰ ⵉⵡⴹⴰⵏ, ⵏⵏⵉ ⵉⴹⴻⵀⵀⴰⵔⴻⵏ ⴷⵉ ⵍⵃⵉⴹ ⵢⵓⵄⵍⴰⵏ, ⴰⵇⴰ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⴷⴻⵖⵢⴰ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("IS30_14","024_30_14","ISA","30","14","14","ⴰⴷ ⵜ ⵢⴰⵔⵥ ⴰⵎ ⵉⵜⵜⵡⴰⵔⵥ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵏⵀⵍⴰ ⴰⵃⵉⵏⵏⵉ. ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⴼⴻⵜⵡⵉⵜⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴼ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵛⴻⵇⵇⵓⴼ ⵄⴰⴷ ⵉ ⵣⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵣⵉ ⵍⵎⴻⵊⵎⴰⵔ ⵏⵉⵖ ⴰⴷ ⴰⵢⵎⴻⵏ ⴰⵎⴰⵏ ⵣⵉ ⵊⵊⵓⴱ.’” ");
INSERT INTO rift_vpl VALUES ("IS30_15","024_30_15","ISA","30","15","15","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵙ ⵜⵜⵓⴱⴻⵜ ⴷ ⵍⵀⵓⴷⵏⴻⵜ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵓⵙⴻⵏⵊⴻⵎ, ⴷⵉ ⵜⵔⵓⵙⵉ ⴷ ⵍⴰⵎⴰⵏ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵊⵊⴻⵀⴷ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵅⵙⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("IS30_16","024_30_16","ISA","30","16","16","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵍⵍⴰ, ⵅ ⵢⴻⵢⵙⴰⵏ ⵏⴻⵅⵙ ⴰⴷ ⵏⴰⵔⵡⴻⵍ!’ ⵅ ⵓⵢⴰ ⵙ ⵓⵖⵉⵍ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ. ⵓⵛⴰ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ: ‘ⵅ ⵉⵢⵙⴰⵏ ⵏ ⵃⴰⵎⴰⵜ ⵏⴻⵅⵙ ⴰⴷ ⵏⵏⵉⵢ ⵉ ⵜⴰⵔⴻⵡⵍⴰⵜ!’ ⵅ ⵓⵢⴰ ⴰⴷ ⵇⴻⴵⵇⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⵙⴻⴹⴼⴰⵔⴻⵏ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("IS30_17","024_30_17","ISA","30","17","17","ⵉⵊⵊ ⵏ ⵍⵓⵍⵓⴼ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵉ ⵓⵀⴻⴷⴷⵉ ⵏ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⵉ ⵓⵀⴻⴷⴷⵉ ⵏ ⵅⴻⵎⵙⴰ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵍ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴰⵎ ⵜⵙⴻⵏⵢⴰⵏⵜ ⵏ ⵓⵛⴻⵏⵢⴰⵍ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ, ⴰⵎ ⵜⵄⴻⴵⴰⵏⵜ ⵅ ⵜⴻⵡⵔⵉⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS30_18","024_30_18","ISA","30","18","18","“ⵙ ⵓⵢⴰ ⴰⴷ ⵔⴰⵊⴰ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵛⴻⵏ ⴰⵃⵉⵏⵏⵉ ⵏⵏⴻⵙ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵢⴰⵔⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵃⴻⵇⵇ. ⵙⵙⴻⵄⴷ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⵔⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS30_19","024_30_19","ISA","30","19","19","ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵔⵓⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⴽ ⵉⵃⵉⵏⵏ, ⵎⴰⵍⴰ ⵉⵙⵍⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵜᵉⵜⵜⵍⴰⵖⴰ, ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵢⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("IS30_20","024_30_20","ISA","30","20","20","ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⵖⵔⵓⵎ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⴷⵉ ⵍⴻⵖⴱⴻⵏ, ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵜⵜⵏⵓⴼⴼⴰⵔⴻⵏ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS30_21","024_30_21","ISA","30","21","21","ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵡⴰⵍ ⵣⵉ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵛ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⴰⵇⴰ ⴰⴱⵔⵉⴷ, ⵓⵢⵓⵔⴻⵎ ⴷⴰⵢⴻⵙ. ⵡⴰⵔ ⵜⵜⴻⴼⴼⵖⴻⵎ ⵢⴻⴼⵓⵙ ⵓⵍⴰ ⴷ ⴰⵣⴻⵍⵎⴰⴹ.’ ");
INSERT INTO rift_vpl VALUES ("IS30_22","024_30_22","ISA","30","22","22","ⴰⴷ ⵜⵃⴻⵙⴱⴻⵎ ⵉⵛⴻⵍⵍⴻⵍⴻⵏ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵛ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵛ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵍⴰ ⴷ ⴰⵍⴻⵃⵃⴻⴼ ⵏ ⵡⵓⵔⴻⵖ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵛ ⵉⴼⴻⵙⵢⴻⵏ ⴷ ⵜⴻⵅⵎⵓⵊⵉ. ⴰⴷ ⵜⴻⵏ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⵉ-ⵜ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵅ ⴵⴰⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵖⴰⵔ ⴱⴰⵔⵔⴰ!’” ");
INSERT INTO rift_vpl VALUES ("IS30_23","024_30_23","ISA","30","23","23","“ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵡⵛ ⵏⴻⵜⵜⴰ ⴰⵏⵥⴰⵔ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵉ ⵜⵣⴰⵔⵄⴻⴷ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵍⴰ ⴷ ⴰⵖⵔⵓⵎ ⴷ ⵚⵚⴰⴱⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⴻⵀⴷⴰ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵛ ⵅ ⴷⴷⵎⴰⵏⵉ ⵉⵙⴰⵔⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS30_24","024_30_24","ISA","30","24","24","ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⴷ ⵢⴻⵖⵢⴰⵍ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵣⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⵛⵛⴻⵏ ⵍⴻⵄⵍⴻⴼ ⵉⵔⴻⴷⴷ ⵉ ⵣⵓⵣⵣⴰⵔⴻⵏ ⵙ ⴵⵓⵃ ⴷ ⵜⴻⵣⵣⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS30_25","024_30_25","ISA","30","25","25","ⵅ ⴽⵓⵍ ⴰⴷⵔⴰⵔ ⵓ ⵅ ⴽⵓⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵉⴳⴻⵄⵄⴷⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⴷ ⵜⵎⵉⵣⴰⴱⵉⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵎⴰⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵖⴰⵔⵚⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵅⵎⵉ ⵖⴰ ⵡⴹⴰⵏ ⵚⵚⵓⵎⵄⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS30_26","024_30_26","ISA","30","26","26","ⵜⴰⴼⴰⵡⵜ ⵏ ⵜⵣⵉⵔⵉ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵜⴼⴰⵡⵜ ⵏ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⵜⴰⴼⴰⵡⵜ ⵏ ⵜⴼⵓⵛⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵊⵀⴻⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵅ ⵜⴼⴰⵡⵜ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵛⴼⴻⵏ ⵙⵉⴷⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴰⵢⴻⵣⵣⵉⵎ ⵏ ⵜⴻⵛⵜⵉ ⵉ ⵉⵡⵜⴰ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS30_27","024_30_27","ISA","30","27","27","“ⵅⵣⴰⵔ, ⵉⵜⵜⴰⵙ-ⴷⴷ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵢⴰⵔⴻⵇⵇ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵓ ⴰⵙⵉⴳⴳⵯⴻⴷ ⵉⵎⵖⴰⵔ, ⵛⵛⵓⵔⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴻⵙⵅⴻⴹ ⵓ ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS30_28","024_30_28","ISA","30","28","28","ⴰⵙⵓⴹⵉ ⵏ ⵏⵏⴻⴼⵙ ⵏⵏⴻⵙ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵉⵙⵙⴻⴼⵢⴻⵏ, ⵉⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵍ ⵉⵔⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⵣⵓⵣⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵙ ⵜⴰⵣⵣⴰⵔⵜ ⵏ ⵓⵔⴻⴷⴷⴻⴵ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵉ ⵍⴻⴳⵏⵓⵙ ⵙⵍⵉⵎⴻⵜ ⵏ ⵓⵖⴰⵔⵔⵉ ⵅ ⵉⵖⴻⵙⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS30_29","024_30_29","ISA","30","29","29","“ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ, ⴰⵎ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⴷⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴱⵏⴰⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵍⵄⵉⴷ, ⵓⵍⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⴻⴳ ⵡⵓⵍ ⴰⵎ ⵖⴰⵔ ⵉⵊⵊⴻⵏ ⵉⴳⴳⵓⵔⴻⵏ ⵓⵎⵉ ⵉⵥⴻⵎⵎⴰⵔ ⴷⵉ ⵜⴻⵎⵊⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS30_30","024_30_30","ISA","30","30","30","ⵙⵉⴷⵉ ⴰⴷ ⵢⴻⵊⵊ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⵀⵡⴰ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵡⴻⵙⵅⴻⴹ ⵏ ⵡⴻⵖⴹⴰⴱ ⴷ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⴰⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵏⵥⴰⵔ ⴷ ⵍⵃⴰⵍ ⵏ ⵡⴻⵏⵥⴰⵔ ⴷ ⵉⴱⵇⵓⵇⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS30_31","024_30_31","ISA","30","31","31","ⵎⴰⵖⴰⵔ ⴰⵛⵛⵓⵔ ⴰⴷ ⵢⴰⵔⵊⵉⵊ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵅⵎⵉ ⵜ ⵖⴰ ⵉⵡⵡⴻⵜ ⵏⴻⵜⵜⴰ ⵙ ⵡⴻⵄⵎⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS30_32","024_30_32","ISA","30","32","32","ⵇⴰⵄ ⵜⵡⴰⵍⴰ ⵉⵄⴻⴷⴷⵓ ⵅⴰⵙ ⵡⴻⵄⵎⵓⴷ ⵏ ⵓⵙⴻⴳⴳⴻⴷ, ⴰⵄⵎⵓⴷ ⵏⵏⵉ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵖⴰⵔ ⵜⵉⵏⴻⵅⵜ ⵏ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ ⴷ ⵙⵏⵉⵜⵔⴰⵜ ⵏ ⵍⴳⴰⵎⴱⵔⵉⵢⵢⴰⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵎⵎⵏⴻⵖ ⵙ ⵉⵖⴰⴵⴻⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS30_33","024_30_33","ISA","30","33","33","ⵎⴰⵖⴰⵔ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵉⵡⵊⴻⴷ ⵡⴻⵎⵛⴰⵏ ⵉ ⵏⵏⵄⵉ ⵏⵏⵉ, ⵉⵡⵊⴻⴷ ⵓⵍⴰ ⵉ ⵓⵊⴻⴵⵉⴷ. ⵉⴳⴳⴰ ⵉ-ⵜ ⵢⵓⴵⴻⵖ ⴷ ⵓⵎⵉⵔⵉⵡ. ⴰⵇⴻⵍⵍⵉⵊ ⵏⵏⴻⵙ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⵇⴻⴷⴷ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴻⵛⴱⴰⵔⵉⵢⵢⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS31_1","024_31_1","ISA","31","1","1","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⴼⴻⵏ ⵜⵡⵉⵣⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⵛⵍⴻⵏ ⵅ ⵢⴻⵢⵙⴰⵏ ⵓ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴰⵎⴰⵏ ⴷⴻⴳ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵓⵍⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵊⵊⴻⵀⴷⴻⵏ, ⴰⵅⵎⵉ ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS31_2","024_31_2","ISA","31","2","2","“ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵏⴻⵜⵜⴰ ⴳⴳⵓⵔ ⴰⴷ ⵢⴻⵊⵊ ⵍⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ⵡⴰⵔ ⵉⵜⵜⴷⵉⴽⴽⵡⵉⵍ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴽⴽⴰⵔ ⴹⵉⴷⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵓ ⴹⵉⴷⴷ ⵉ ⵜⵡⵉⵣⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS31_3","024_31_3","ISA","31","3","3","ⵎⴰⵖⴰⵔ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵡⴷⴰⵏ, ⵡⴰⵔ ⴵⵉⵏ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵉⵢⵙⴰⵏ ⵏⵙⴻⵏ ⴷ ⴰⵢⵙⵓⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⵔⵓⵃ. ⴰⴷ ⵉⵙⴰⵔⵔⴻⵃ ⵙⵉⴷⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵍ ⵉ ⵖⴰ ⵉⵏⵇⴰⵔⴹ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵡⴹⴰ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵇⴹⴰⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS31_4","024_31_4","ISA","31","4","4","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴰⵔⵔⵓⵊⴷⵓⴷ ⵡⴰⵢⵔⴰⴷ ⵏⵉⵖ ⵡⴰⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵅ ⵣⵣⴰⵔⴷⴻⵜ ⵏⵏⴻⵙ ⵅⵎⵉ ⵅⴰⵙ ⴷⴷ-ⵜⵜⵍⴰⵖⴰⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵣⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵉⵅⴻⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴱⴰⵔⵔⵓ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵀⵡⴰ ⵓⵍⴰ ⴷ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓ ⵅ ⵜⴻⵡⵔⵉⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS31_5","024_31_5","ISA","31","5","5","ⴰⵎ ⵢⵉⵊⴹⴰⴹ ⵉⵜⵜⴼⴰⵔⴼⵉⵔⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵄⵓⵛⵛ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵙⵙⴻⵍⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⴷ ⵜⵜ ⵉⵙⵙⴰⵔ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ, ⴰⴷ ⵅⴰⵙ ⵢⴻⴽⴽ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS31_6","024_31_6","ISA","31","6","6","“ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵅ ⵃⴻⵢⵢⴷⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS31_7","024_31_7","ISA","31","7","7","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴽⵓⵍ ⵉⵊⵊ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵙ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵙ ⵏ ⵡⵓⵔⴻⵖ, ⵉⵏⵏⵉ ⵢⴻⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵉ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("IS31_8","024_31_8","ISA","31","8","8","ⴰⵛⵛⵓⵔ ⴰⴷ ⵉⵡⴹⴰ ⵙ ⵙⵙⵉⴼ, ⵡⴰⵔ ⵉⴵⵉ ⵙⵙⵉⴼ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⴰⴷ ⵜ ⵢⴻⵛⵛ ⵙⵙⵉⴼ, ⵡⴰⵔ ⵉⴵⵉ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⴰⵛⵛⵓⵔ ⵣⵣⴰⵜ ⵉ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("IS31_9","024_31_9","ISA","31","9","9","ⵜⴰⵚⴹⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴳⴳⵯⴻⵊ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵓⵛⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵜⵄⴻⴵⴰⵏⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵎⴻⵙⵙⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⵓⵍⴰ ⴷ ⵜⴰⴼⵇⵓⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS32_1","024_32_1","ISA","32","1","1","“ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵃⴽⴻⵎ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵓ ⵍⵃⵓⴽⴽⴰⵎ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("IS32_2","024_32_2","ISA","32","2","2","ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴷⵓⵔⵔⵉ ⵣⴻⴳ ⵡⴻⵏⵥⴰⵔ, ⴰⵎ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵉⵙⵙⵍⴻⵇⵇⴰⵏ ⵣⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⴰⵎ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ, ⴰⵎ ⵜⵉⵍⵉ ⵏ ⵉⵊⵊ ⵏ ⵊⵊⴰⵔⴼ ⵉⴷⴻⵇⵍⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⴼⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS32_3","024_32_3","ISA","32","3","3","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵡⴰⵔ ⵜⵜⴱⴻⵍⵍⵉⵄⴻⵏⵜ ⵄⴰⴷ, ⵓ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⴷ ⵙⵙⵃⴻⵙⵙⴻⵏ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("IS32_4","024_32_4","ISA","32","4","4","ⵓⵍ ⵏ ⵉⵎⵇⴻⴵⵇⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉⵃⴻⵟⵟⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⴼ ⵜⵓⵙⵙⵏⴰ, ⵓ ⵉⵍⴻⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵜⴻⵡⵜⵉⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵡⴻⴷ ⵙ ⵍⴼⴰⵔⵣ. ");
INSERT INTO rift_vpl VALUES ("IS32_5","024_32_5","ISA","32","5","5","ⴰⴱⵓⵀⴰⵍⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵍⵉⵖⵉⵏ ⵄⴰⴷ ‘ⴰⵎⵛⴻⵏⵏⴻⵄ!’, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵎⵎⵜⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ‘ⵎⵎⵉⵙ ⵏ ⵍⵅⵉⵔ!’ ");
INSERT INTO rift_vpl VALUES ("IS32_6","024_32_6","ISA","32","6","6","ⵎⴰⵖⴰⵔ ⴰⴱⵓⵀⴰⵍⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⴻⴳⴳ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⴰⴼⵓⵛⵛⴻⵃ ⵓ ⵉⵜⵜⵛⴻⵇⵇⴻⴼ ⴷⵉ ⵙⵉⴷⵉ, ⵓ ⵓⵎⵉ ⵉⵜⵜⴻⵊⵊⵉ ⵍⴻⵄⵎⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵅⵡⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⴼⵓⴷⴻⵏ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("IS32_7","024_32_7","ISA","32","7","7","ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ ⵏ ⵓⵛⴻⵎⵎⴰⵜ ⵜⵄⴻⴼⴼⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵖⴹⴻⵍ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵣⵍⵓⴹ ⵉⵛⵛⴰⵜ ⵅ ⵍⵃⴻⵇⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS32_8","024_32_8","ISA","32","8","8","ⵎⴰⵛⴰ ⴰⵎⵛⴻⵏⵏⴻⵄ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵉⵏⵡⴰⵢⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⴰⴷ ⵉⴽⴽⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⵉⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS32_9","024_32_9","ISA","32","9","9","“ⴽⴽⴰⵔⴻⵏⵜ, ⴽⴻⵏⵏⵉⵏⵜ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵡⴻⵎⵏⵓⵙ, ⵙⵍⴻⵏⵜ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵙⵉⵎⴰⵏⵜ ⵏⴽⴻⵏⵜ, ⵙⵍⴻⵏⵜ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS32_10","024_32_10","ISA","32","10","10","ⴰⵡⴰⵔⵏⵉ ⵡⵓⵙⵙⴰⵏ ⵏⵉⵖ ⴰⵙⴻⴳⴳⵯⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⵊⵉⵊⴻⵏⵜ, ⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⵇⴹⴰ ⵚⵚⴰⴱⴻⵜ ⵏ ⵓⴹⵉⵍ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⴻⵍⵇⴰⴹ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("IS32_11","024_32_11","ISA","32","11","11","ⵇⴻⴼⵇⴼⴻⵏⵜ, ⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵏⴱⵍⴰ ⴰⵎⵏⵓⵙ, ⴰⵔⵊⵉⵊⴻⵏⵜ, ⴽⴻⵏⵏⵉⵏⵜ ⵜⵉⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ, ⴽⴽⵙⴻⵏⵜ ⴰⵔⵔⵓⴹ, ⵄⴰⵔⵢⵏⴻⵏⵜ, ⵅⴻⵏⵏⵉ ⴱⴻⵢⵙⴻⵏⵜ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⴽⴻⵏⵜ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⴻⵛⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS32_12","024_32_12","ISA","32","12","12","“ⴰⴷ ⵡⵜⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⴷⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ ⵙ ⵉⴳⴻⵊⴷⵓⵔⴻⵏ ⵅ ⵉⵃⵡⵉⵛⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ, ⵅ ⵜⵣⴰⵢⴰⵔⵉⵏ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS32_13","024_32_13","ISA","32","13","13","ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵡⴰⵀ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵙ ⵓⵙⵍⴻⵡⵍⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("IS32_14","024_32_14","ISA","32","14","14","ⵎⴰⵖⴰⵔ ⵍⴻⵇⵚⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵊⵊ, ⴷⴷⵔⵉⵣ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵉⴱⴽⴻⵎ, ⵜⴰⵡⵔⵉⵔⵜ ⵏ ‘ⵄⵓⴼⵉⵍ’ ⴷ ⵍⴱⵓⵔⵊ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴼⵔⴰⵏ ⵉ ⵍⴻⴱⴷⴰ, ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵎⴰⵏⵉ ⵜⵜⴻⵎⵣⵓⵄⴱⵓⴹⴻⵏ ⵉⵖⵢⴰⵍ ⵏ ⵍⴻⵅⵍⴰ, ⴷ ⴷⴷⵎⴰⵏⵉ ⵉ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS32_15","024_32_15","ISA","32","15","15","ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ ⵅⴰⵏⴻⵖ ⴰⵔⵔⵓⵃ ⵣⵉ ⵙⴻⵏⵏⴻⵊ.” “ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⵍⴻⵅⵍⴰ ⴷ ⵍⵄⵉⵔⵙⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⵍⵄⵉⵔⵙⵜ ⵉⵚⴻⴱⵃⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⴰⵣⵖⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("IS32_16","024_32_16","ISA","32","16","16","ⵍⵃⴻⵇⵇ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS32_17","024_32_17","ISA","32","17","17","ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵀⵓⴷⵏⴻⵜ ⴷ ⵍⴰⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS32_18","024_32_18","ISA","32","18","18","ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⵀⵏⴰ, ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⴷⴰⵢⵙⴻⵏⵜ ⵍⴰⵎⴰⵏ ⵓ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⴷⴰⵢⵙⴻⵏ ⴰⵔⵔⴰⵃⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS32_19","024_32_19","ISA","32","19","19","“ⴰⴷ ⵜⴻⵛⵛⴰⵜ ⵜⴱⵔⵓⵔⵔⵉ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴻⵙⵙⴻⵀⵡⴰ ⴰⵣⵖⴰⵔ ⵓⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ ⴰⴷ ⵜⴻⵀⵡⴰ ⴷⵉ ⵍⴻⵡⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS32_20","024_32_20","ISA","32","20","20","“ⵙⵙⴻⵄⴷ ⵏ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴷ ⵡⴻⵖⵢⵓⵍ!” ");
INSERT INTO rift_vpl VALUES ("IS33_1","024_33_1","ISA","33","1","1","“ⵓⵛⵜ ⵅⴰⴽ, ⴰ ⴰⵎⵜⴻⵃⵃⴰⵢ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⵉ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⵛⵛⴹⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵛⴻⴽ ⴽⴻⵛⵛⴹⴻⵏ. ⵎⴰⵍⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴰⵜⴻⵃⵃⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⵉⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("IS33_2","024_33_2","ISA","33","2","2","“ⴰ ⵙⵉⴷⵉ, ⵃⵉⵏⵏ ⵅⴰⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵙⵙⵉⵜⵉⵎ ⴰⵛ. ⵉⵍⵉ ⴷ ⴰⵖⵉⵍ ⵏⵙⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴷⵉ ⴽⵓⵍ ⵚⵚⴱⴻⵃ, ⵡⴰⵀ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵙⴰⵔⴻⵜ ⵉⵍⵉ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS33_3","024_33_3","ISA","33","3","3","“ⵅ ⵍⵃⴻⵙⵙ ⵏ ⵣⵣⵀⵉⵔ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵍⴻⴳⵏⵓⵙ. ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("IS33_4","024_33_4","ISA","33","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵔⴷⴻⵜ ⵏⵡⴻⵎ, ⴰⵎ ⵜⵎⵓⵔⵖⵉ ⵉⵚⴰⵔⵔⴹⴻⵏ ⵜⵜⴻⴽⴽⵙⴻⵏⵜ ⵚⵚⴰⴱⴻⵜ. ⴰⵎ ⵜⵜⴰⵣⵣⵍⴻⵏⵜ ⵜⵎⵓⵔⵖⵉ ⵙⵙⴰ ⴷ ⵙⵙⴰ, ⴰⵎⵎⵓ ⵉ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS33_5","024_33_5","ISA","33","5","5","“ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ ⵙⵉⴷⵉ ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵣⴻⴷⴷⴻⵖ ⵇⴰⵄ ⵙⴻⵏⵏⴻⵊ. ⵏⴻⵜⵜⴰ ⵉⵛⵛⵓⵔ ⵚⵉⵀⵢⵓⵏ ⵙ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS33_6","024_33_6","ISA","33","6","6","ⴰⴷ ⵢⵉⵍⵉ ⵍⴰⵎⴰⵏ ⵅⵎⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏⵜ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵛ, ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵙⴻⵏⵊⴰⵎⴻⵏ, ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ. ⴰⴷ ⵜⵉⵍⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ ⴷ ⵍⴽⴻⵏⵣ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS33_7","024_33_7","ISA","33","7","7","“ⵅⵣⴰⵔ, ⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵜⴰⵔⵢⴰⵙⵜ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵢⵔⴰⴷ ⵙⵖⵓⵢⵢⵓⵏ ⴱⴰⵔⵔⴰ, ⵡⴰⵀ, ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏ ⵍⴻⵀⵏⴰ ⵜⵜⵔⵓⵏ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS33_8","024_33_8","ISA","33","8","8","ⵉⴱⵔⵉⴷⴻⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ ⵜⵜⵡⴰⵊⵊⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵏⵏⵓⵎⴻⵏ ⴰⴷ ⵢⴻⴽⴽ ⵅ ⵓⵎⴻⵙⵔⵓⵇ, ⵉⵙⵎⴻⵃ ⴷⴰⵢⴻⵙ. ⴰⵇⴰ ⵢⴰⵔⵥⴰ ⵍⵄⴰⵀⴷ, ⵉⵙⵙⴻⵃⵇⴰⵔ ⵜⵉⵏⴻⴷⴷⴰⵎ, ⵡⴰⵔ ⵉⵃⴻⵙⵙⴻⴱ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS33_9","024_33_9","ISA","33","9","9","ⵜⴻⵛⴹⴻⵏ ⵓ ⵜⵉⵙⵍⴰⵡ ⵜⴻⵎⵎⵓⵔⵜ. ⵍⵓⴱⵏⴰⵏ ⵉⵙⴻⴹⵃⴰ, ⵢⵓⵥⴻⵖ. ⵍⴻⵡⴹⴰ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ ⵏ ⵛⴰⵔⵓⵏ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⴱⴰⵛⴰⵏ ⴷ ⴽⴰⵔⵎⴰⵍ ⵜⵜⵙⴻⴵⴹⴻⵏ ⴰⴼⴰⵔ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS33_10","024_33_10","ISA","33","10","10","“ⵍⴻⵅⵅⵓ ⴰⴷ ⴽⴽⴰⵔⴻⵖ, ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵖ, ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS33_11","024_33_11","ISA","33","11","11","“ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⵙⵉⵎ ⴷⴷⴻⵢⵙⴻⵜ ⵙ ⵓⵍⵓⵎ, ⴰⴷ ⵜⴰⵔⵡⴻⵎ ⵉⵖⴻⴵ. ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ ⴷ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵢⴻⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS33_12","024_33_12","ISA","33","12","12","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵊⵊⴰⵔ ⵙⵙⴰⵔⵖⴻⵏ ⵜ, ⴰⵎ ⵍⵃⴰⵔⵔⴰⵛ ⵙ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("IS33_13","024_33_13","ISA","33","13","13","ⴽⴻⵏⵏⵉⵡ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵙⵍⴻⵎ ⵎⵉⵏ ⴳⴳⵉⵖ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴷⵉ ⵍⴰⴷⴰⵙ, ⵙⵏⴻⵎ ⵚⵚⵓⵍⵟⴰ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS33_14","024_33_14","ISA","33","14","14","ⵉⵎⴻⴷⵏⴰⴱ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵉⵎⵏⴰⴼⵇⴻⵏ ⵜⵜⵇⴻⴼⵇⴰⴼⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵍⴻⴱⴷⴰ?’” ");
INSERT INTO rift_vpl VALUES ("IS33_15","024_33_15","ISA","33","15","15","“ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵓ ⵉⵇⵇⴰⵔ ⵍⵃⴻⵇⵇ, ⵡⴻⵏⵏⵉ ⵉⵏⴹⴰⵔⴻⵏ ⴰⵔⴱⴻⵃ ⵙ ⵓⴱⴻⵄⵄⴻⵊ, ⵡⴻⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⵓⴹⵓⴼ ⵏ ⵜⴻⵔⵣⵉⴼⵉⵏ ⵏ ⴰⵔⵔⴻⵛⵡⴻⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴻⵍⵍⴰⵄⴻⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ ⵎⴻⵄⵍⵉⴽ ⵢⵓⴼⴰ ⴰⴷ ⵉⵙⴻⵍ ⵅ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵇⵇⵏⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵎⴻⵄⵍⵉⴽ ⵢⵓⴼⴰ ⴰⴷ ⵉⵜⵡⴰⵍⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS33_16","024_33_16","ISA","33","16","16","ⴷ ⵡⴰⵏⵉⵜⴰ ⵉ ⵖⴰ ⵉⵣⴻⴷⵖⴻⵏ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ⵍⵇⴻⵍⵄⴰⵜ ⴷⵉ ⵍⴻⵊⵔⵓⴼ ⴰⴷ ⵉⵍⵉⵏⵜ ⵍⴱⵓⵔⵊ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰⵏ, ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵙ, ⴰⵎⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜⵡⴰⴹⴻⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS33_17","024_33_17","ISA","33","17","17","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵡⴰⵍⴰⵏⵜ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵥⵔⵉ ⵏⵏⴻⵙ, ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴰⵢⴻⵙ ⵜⵜⴰⵙⵉⵄ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS33_18","024_33_18","ISA","33","18","18","ⵓⵍ ⵏⵏⴻⵛ ⴰⴷ ⵉⵄⵇⴻⵍ ⵅ ⵓⵙⵏⴻⵅⵍⵉⵄ. ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵎⴰⵔⵉⵔ? ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵉⵡⴻⵣⵏⴻⵏ? ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵟⵟⴻⵏ ⵍⴱⵓⵔⵊⴰⵜ? ");
INSERT INTO rift_vpl VALUES ("IS33_19","024_33_19","ISA","33","19","19","ⵛⴻⴽ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⴷ ⵄⴰⴷ ⵍⴳⴻⵏⵙ ⵉⵇⴻⵙⵃⴻⵏ ⵏⵏⵉ, ⵍⴳⴻⵏⵙ ⵙ ⵢⵉⵍⴻⵙ ⵉⴷⴻⵇⵍⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⵙⴻⵍ ⴱⵏⴰⴷⴻⵎ, ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵙⵙⵟⴻⵡⵟⵉⵡⴻⵏ ⵙ ⵢⵉⵍⴻⵙ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⴼⵀⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ.” ");
INSERT INTO rift_vpl VALUES ("IS33_20","024_33_20","ISA","33","20","20","“ⵅⵣⴰⵔ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵎⵓⵏⵉⵜⴻⵏ ⵏⵏⴻⵖ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵎⴰⵏ, ⴰⵇⵉⴹⵓⵏ ⵉ ⵡⴰⵔ ⵙⵙⵎⵓⵟⵟⵓⵢⴻⵏ, ⵉ ⵣⵉ ⵍⴻⵡⵜⴰⴷ ⵏⵏⴻⵙ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⵓⵔⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵡⴰⵇⴻⵟⵟⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS33_21","024_33_21","ISA","33","21","21","ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⵙ ⵍⵄⴻⵣⵣ. ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⴷ ⵜⵙⴻⴵⵢⴰⵡⵉⵏ ⵉⵎⵉⵔⵉⵡⴻⵏ. ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵏⴻⴷⵀⴻⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴻⵎⵇⴰⴷⴻⴼ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵙ ⵍⴻⵊⵡⴰⴷ ⴰⴷ ⴷⵉⵏ ⵉⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("IS33_22","024_33_22","ISA","33","22","22","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴷ ⵍⵇⴰⴹⵉ ⵏⵏⴻⵖ, ⵙⵉⴷⵉ ⴷ ⴰⵎⴳⴻⵡⵡⴰⴷ ⵏⵏⴻⵖ, ⵙⵉⴷⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS33_23","024_33_23","ISA","33","23","23","“ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⴰⵔⵅⵓⵏ ⵉⵙⴻⵖⵡⴰⵏ ⵏⵏⴻⵎ, ⵡⴰⵔ ⵎⴻⵏⵏⵄⴻⵏ ⵄⴰⴷ ⵜⵉⵙⴻⵏⵢⴰⵏⵉⵏ ⴷⴻⴳ ⵓⴹⴰⵔ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⵄⴰⴷ ⵍⴱⴰⵛⵛ. ⵎⴰⵛⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴹⴰ ⵣⵣⴰⵔⴷⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵄⴰⴷ ⵉⵏⴻⵄⴹⴰⴱ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("IS33_24","024_33_24","ISA","33","24","24","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⵓⵖ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⵀⴻⵍⵛⴻⵖ!’, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS34_1","024_34_1","ISA","34","1","1","“ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ, ⴰ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴰ, ⵛⵛⵓⵄⵓⴱ, ⴰⵔⵔⴻⵎ-ⴷⴷ ⵍⴱⴰⵍ! ⵙⴻⵍ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵙⵙⴼⵓⴼⴼⵓⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_2","024_34_2","ISA","34","2","2","ⵎⴰⵖⴰⵔ ⴰⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⵙⵄⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("IS34_3","024_34_3","ISA","34","3","3","ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴰⴷ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵏ, ⵓⵛⴰ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ. ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_4","024_34_4","ISA","34","4","4","ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵉⴼⵏⴰ ⵓⵛⴰ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴰⵎ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓ ⴰⴷ ⵉⵡⴹⴰ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⴰⵎ ⵡⴰⴼⴰⵔ ⵅ ⵜⵣⴰⵢⴰⵔⵜ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⴰⵣⴰⵔⵜ ⵣⴻⴳ ⵡⴰⵔⵜⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS34_5","024_34_5","ISA","34","5","5","“ⵎⴰⵖⴰⵔ ⵙⵙⵉⴼ ⵉⵏⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵥⴰⵔ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵅ ⵉⴷⵓⵎ ⵓ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵃⴰⵔⵔⵎⴻⵖ ⵇⴰⵄ ⵉ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("IS34_6","024_34_6","ISA","34","6","6","ⵙⵙⵉⴼ ⵏ ⵙⵉⴷⵉ ⵉⵛⵛⵓⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⴷⵡⴻⵍ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹ ⵙ ⵜⴰⴷⵓⵏⵜ, ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ, ⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵉⵥⵥⴰⵍ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷⵉ ⴱⵓⵚⵔⴰ, ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ.    ");
INSERT INTO rift_vpl VALUES ("IS34_7","024_34_7","ISA","34","7","7","ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵡⴹⴰⵏ ⵉⵖⴰⵢⴹⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⵙⵓ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⴰⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵉⵊⵊⵡⴻⵏ ⵙ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS34_8","024_34_8","ISA","34","8","8","ⵎⴰⵖⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵏⵏⴻⵇⵎⴻⵜ ⵉ ⵙⵉⴷⵉ, ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵓⵅⴻⴵⴻⵚ ⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_9","024_34_9","ISA","34","9","9","ⵜⵉⵖⵣⴰⵔⵉⵏ ⵏ ⵉⴷⵓⵎ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⵉⵣⴻⴼⵜ ⵓ ⴰⵛⴰⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵍⴻⵛⴱⴰⵔⵉⵢⵢⴻⵜ, ⵡⴰⵀ, ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⵉⵣⴻⴼⵜ ⵢⴰⵔⴻⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_10","024_34_10","ISA","34","10","10","ⵡⴰⵔ ⵜⵜⵅⴻⵙⵙⵉ ⵜⵎⴻⵙⵙⵉ ⵏⵏⴻⵙ ⵙ ⴵⵉⵍⴻⵜ ⵓⵍⴰ ⵙ ⵡⴰⵙⵙ, ⴷⴷⴻⵅⵅⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵉ ⵍⴻⴱⴷⴰ. ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵉ ⵍⴻⴱⴷⴰ ⵏ ⵍⴻⴱⴷⴰⵜ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜ ⵉⵥⵡⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("IS34_11","024_34_11","ISA","34","11","11","ⴱⵓ-ⵓⵄⵓⵇⵇⵉ ⴷ ⵜⵡⵓⵛⵜ ⵏ ⴵⵉⵍⴻⵜ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⴱⵓ-ⵓⵙⵓⴹⵉ ⵏ ⵍⵎⴻⵡⵜ ⴷ ⵓⴱⴰⵖⴻⵍ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙ ⵉⵎⵃⴻⴹ ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵍⴻⵅⵍⴰ ⵓ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⴱⵍⵓⵎⵓ ⵏ ⵍⵅⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("IS34_12","024_34_12","ISA","34","12","12","ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵏ ⵜⴰⵚⵉⵍⴻⵜ? ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⴱⵓ ⵜⴳⴻⵍⴷⴰ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⴱⴰⵔⵔⵃⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵇⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_13","024_34_13","ISA","34","13","13","ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵉⵔⴻⵣⵣⴰⵣⴻⵏ ⴷ ⵜⴰⴱⵖⴰ ⵏ ⵓⵙⴻⵏⵏⴰⵏ ⴰⴷ ⵖⴻⵎⵢⴻⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵙ. ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵃⵡⵉⵛ ⵉ ⵢⴻⵙⵙⵉⵙ ⵏ ⵏⵏⵄⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS34_14","024_34_14","ISA","34","14","14","ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⴰⴷ ⵎⵎⴻⵍⵇⴰⵏ ⴰⴽ-ⴷ ⵉⴼⵉⵙⴻⵏ ⵓⵛⴰ ⴰⵎⵢⴰⵏ ⵉⵊⴻⵏⵏⴻⵏ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵍⵡⴻⵃⵛ ⵏ ⴵⵉⵍⴻⵜ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⴷⵉⵏⵏⵉ, ⴰⴷ ⵢⴰⴼ ⴰⵖⵉⵎⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS34_15","024_34_15","ISA","34","15","15","ⴷⵉⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙ ⵜⴼⵉⵖⴰⵔⵜ ⵏ ⴼⵍⵉⵜⵛⴰ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙ ⵜⵉⵎⴻⴵⴰⵍⵉⵏ, ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵙⵙⴼⵔⵓⵔⵉⵢ ⵓⵛⴰ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⴰⴷ ⵜⵀⵉⵍⵍⴰ ⴷⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴷⵉⵏⵏⵉ ⴰⴷ ⵎⵓⵏⴻⵏ ⵉⵊⴹⴰⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_16","024_34_16","ISA","34","16","16","ⴰⵔⵣⵓⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵙⵉⴷⵉ ⵓ ⵖⴰⵔⴻⵎ ⵣⵣⴰⵢⴻⵙ: ‘ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵍⴻⵡⵃⵓⵛ-ⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵏⵇⴻⵚ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⵡⴻⵄⵛⵉⵔ ⵏⵏⴻⵙ!’, ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵢⵓⵔⴰ ⵉ-ⵜ, ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵙⵙⵎⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS34_17","024_34_17","ISA","34","17","17","ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵏⴹⴰⵔ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⴱⴹⴰ ⴰⵙⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⵡⴰⵔⵜⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS35_1","024_35_1","ISA","35","1","1","“ⴰⴷ ⵉⴼⴰⵔⵃ ⵍⴻⵅⵍⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ, ⴰⴷ ⵜⴻⵙⵍⵉⵡⵍⴻⵡ ⵍⴻⵡⴹⴰ, ⴰⴷ ⵜⵏⴻⵡⵡⴰⵔ ⴰⵎ ⵜⵏⴻⵡⵡⴰⵛⵜ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵡⴹⴰⵏⵜ ⵜⵉⴼⵔⴰⵢ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("IS35_2","024_35_2","ISA","35","2","2","ⴰⴷ ⵜⵏⴻⵡⵡⴰⵔ ⴰⴷ ⵜⵛⵓⵡⵡⴰⵔ, ⵡⴰⵀ, ⴰⴷ ⵜⴻⵙⵍⴻⵡⵍⵉⵡ ⵍⴻⵡⴹⴰ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵓⵄⵓⴵⵉ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵍⵄⴻⵣⵣ ⵏ ⴽⴰⵔⵎⵉⵍ ⵓ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵛⴰⵔⵓⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ, ⵍⵄⴻⵣⵣ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS35_3","024_35_3","ISA","35","3","3","“ⵙⵎⴻⵃⴹⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⴰⵔⵅⵓⵏ ⵓ ⵙⵊⴻⵀⴷⴻⵎ ⵉⴼⴰⴷⴷⴻⵏ ⵉⵜⵜⴻⵎⵔⴰⵢⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS35_4","024_35_4","ISA","35","4","4","ⵉⵏⵉⵎ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵍ ⵉⴳⴳⵯⴻⴷ: ‘ⵉⵍⵉⵎ ⴷ ⵉⵔⵢⴰⵣⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ! ⵅⵣⴰⵔⴻⵎ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴰⴷ ⵉⵅⵍⴻⴼ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴻⵅⵍⴰⴼ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵏⵊⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("IS35_5","024_35_5","ISA","35","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵏⵓⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴹⴰⵔⵖⴰⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵉⴷⵓⵀⵛⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS35_6","024_35_6","ISA","35","6","6","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⴳⴻⵣ ⵓⵇⵉⴷⴰⵔ ⴰⵎ ⵓⴷⴰⴷ ⵓⵛⴰ ⵉⵍⴻⵙ ⵏ ⵓⵣⵉⵏⵓⵏ ⴰⴷ ⵉⵙⵍⵉⵡⵍⴻⵡ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷⵓⵇⵇⵣⴻⵏ ⵡⴰⵎⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵍⴰ ⴷ ⵜⵉⵖⵣⴰⵔⵉⵏ ⴷⵉ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("IS35_7","024_35_7","ISA","35","7","7","ⵜⴰⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵙⵙⴰⵔⵉⵊ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵉⴼⴼⵓⴷⴻⵏ ⴷ ⵜⴰⵍⴰⵡⵉⵏ ⵉⵜⵜⴱⴻⵇⴱⵓⵇⴻⵏ. ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵎⴰⵏⵉ ⴰⵔⵔⴻⵢⵃⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵔⴱⵉⵄ ⴰⴽ-ⴷ ⵓⵖⴰⵏⵉⵎ ⴷ ⵡⴻⵣⵔⴰⴼ.” ");
INSERT INTO rift_vpl VALUES ("IS35_8","024_35_8","ISA","35","8","8","“ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ, ⴰⴱⵔⵉⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⵍⴰⵖⴰⵏ ‘ⴰⴱⵔⵉⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ!’. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵅⵎⵓⵊ ⵡⴰⵔ ⵅⴰⵙ ⵉⴳⴳⵓⵔ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⵉⵜⵏⵉ: ⵎⴰⵏ ⵡⴻⵏ ⵎⴰ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ-ⴰ, ⵄⴰⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴻⴷⴷⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS35_9","024_35_9","ISA","35","9","9","ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵉⵜⵜⵉⵍⵉ ⵡⴰⵢⵔⴰⴷ, ⵡⴰⵀ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⴳⵉⵄⵄⵉⴷ ⵏⵉⵖ ⴰⴷ ⵉⵜⵜⵡⴰⴼ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⵉⵜⵜⵛⴰⵔⵔⴻⴳ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ ⴰⴷ ⵅⴰⵙ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS35_10","024_35_10","ISA","35","10","10","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵃⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵄⴻⵇⴱⴻⵏ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ. ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵍⴻⴱⴷⴰ ⴰⴷ ⵜⴰⵔⵙⴰ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ. ⴰⴼⴰⵔⵔⴻⵊ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴰⵡⴹⴻⵏ, ⴰⵛⴹⴰⵏ ⴷ ⵡⴻⵙⵃⵉⵙⵙⴻⴼ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS36_1","024_36_1","ISA","36","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵃⴻⵡⵡⴻⵙ ⵉ-ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS36_2","024_36_2","ISA","36","2","2","ⵉⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵣⵉ ⵍⴰⵅⵉⵛ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ. ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵇⴰⴷⵓⵙ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵙⴻⵏⵏⴻⵊ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵚⴻⴱⴱⴰⵏ. * ");
INSERT INTO rift_vpl VALUES ("IS36_3","024_36_3","ISA","36","3","3","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵖⴰⵔⴻⵙ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴽ-ⴷ ⵓⵎⴰⵔⵉⵔ ⵛⵉⴱⵏⴰ ⴷ ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ, ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ. ");
INSERT INTO rift_vpl VALUES ("IS36_4","024_36_4","ISA","36","4","4","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ: “ⵉⵏⵉⵎ ⵅⴻⵏⵏⵉ ⵉ ⵃⵉⵣⵇⵉⵢⴰ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ‘ⵎⴰⵏ ⴰⵜⴻⵛⵍⵉ ⵡⴰ ⵉ ⵅ ⵜᵉⵜⵜⴰⵛⵍⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("IS36_5","024_36_5","ISA","36","5","5","ⵏⵏⵉⵖ ⴰⵛ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵀⴰⵔⴷ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵡⴰⵀⴰ. ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⵛⵡⴰⵔ ⴷ ⵜⵣⴻⵎⵎⴰⵔ. ⵎⴰⵏ ⵡⴻⵏ ⵅ ⵜᵉⵜⵜⴰⵛⵍⴻⴷ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵖⴻⵡⵡⵖⴻⴷ ⵅⴰⴼⵉ? ");
INSERT INTO rift_vpl VALUES ("IS36_6","024_36_6","ISA","36","6","6","ⵅⵣⴰⵔ, ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵎⵉⵚⵔⴰ, ⵅ ⵓⵖⴰⵏⵉⵎ ⵏⵏⵉ ⵉⵏⵏⴹⴻⴼⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵊⵊⵓⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵎⵉ ⵃⴻⴷ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵄⴻⵎⵎⴻⴷ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜ. ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⴰⵛⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS36_7","024_36_7","ISA","36","7","7","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷ ⴰⵢⵉ ⵜⵉⵏⵉⵎ: ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⴰⵛⴻⵍ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ: ⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵉⵃⴻⵢⵢⴻⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵍⴻⴳⵄⵓⴷⵉ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵓ ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ: ⴰⴷ ⵜⴱⴻⵏⴷⵇⴻⵎ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ-ⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ?’ ");
INSERT INTO rift_vpl VALUES ("IS36_8","024_36_8","ISA","36","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴻⴳⴳ ⵉⵊⵊ ⵏ ⵓⵎⵃⴰⵔⵔⴻⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⵍⴼⴰⵢⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵎⴰⵍⴰ ⵛⴻⴽ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ ⴰⴷ ⴰⵙⴻⵏ-ⴷⴷ ⵜⴰⵡⵢⴻⴷ ⵉⵎⵏⴰⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("IS36_9","024_36_9","ISA","36","9","9","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏⵇⴻⵍⴱⴻⴷ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵍⵡⴰⵍⵉ, ⵡⴻⵏⵏⵉ ⵇⴰⵄ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵎⵉⵚⵔⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("IS36_10","024_36_10","ISA","36","10","10","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰ ⵏⴻⵛⵛ ⴳⴻⵄⵄⴷⴻⵖ-ⴷⴷ ⴹⵉⴷⴷ ⵏ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵔⴻⴷⴷⴵⴻⵖ ⴱⵍⴰ ⵙⵉⴷⵉ? ⵙⵉⴷⵉ ⵉⵏⵉ ⴰⵢⵉ: ‘ⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⴰⵔⴻⴷⴷⴻⴵ ⵉ-ⵜⵜ.’” ");
INSERT INTO rift_vpl VALUES ("IS36_11","024_36_11","ISA","36","11","11","ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⴰⴽ-ⴷ ⵛⵉⴱⵏⴰ ⴷ ⵢⵓⵡⴰⵅ ⵉ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ: “ⵙⵉⵡⴻⵍ ⵄⴰⴼⴻⴽ ⵙ ⵜⵔⴰⵎⵉⵜ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⴼⵀⴻⵎ ⴰⵙ ⵎⵍⵉⵃ. ⵡⴰⵔ ⴽⵉⴷⵏⴻⵖ ⵙⵙⵉⵡⵉⵍ ⵙ ⵜⵢⴰⵀⵓⴷⴻⵛⵜ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⴵⴰⵏ ⵅ ⵍⵃⵉⴹ.” ");
INSERT INTO rift_vpl VALUES ("IS36_12","024_36_12","ISA","36","12","12","ⵎⴰⵛⴰ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵏⵏⴰ: “ⵎⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵙⵉⴷⵉ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔⴻⴽ ⵡⴰⵀⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵃⵉⴹ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⵉⵖ ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⵎⵉⵄ ⴰⴽⵉⴷⵡⴻⵎ ⴰⴷ ⵛⵛⴻⵏ ⴰⵙⵓⴼⴼⴻⵖ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵙⵡⴻⵏ ⵉⴱⴻⵛⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("IS36_13","024_36_13","ISA","36","13","13","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⵀⴻⴷ ⵙ ⵜⵢⴰⵀⵓⴷⴻⵛⵜ, ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ! ");
INSERT INTO rift_vpl VALUES ("IS36_14","024_36_14","ISA","36","14","14","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ: ‘ⵃⴹⴰⵎ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵖⴻⵛⵛⵉ ⵃⵉⵣⵇⵉⵢⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("IS36_15","024_36_15","ISA","36","15","15","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⴰⴷ ⵜᵉⵜⴻⵛⵍⴻⵎ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵉⵏⵉⵎ: ⵙⵉⴷⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵏⵉⵛⴰⵏ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵡⵛⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS36_16","024_36_16","ISA","36","16","16","ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ⴳⴳⴻⵎ ⴰⵢⵉ ⴰⵔⵔⴰⵢ ⵓⵛⴰ ⴼⴼⵖⴻⵎ-ⴷⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔⵉ, ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵛⵛ ⵣⵉ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵙⵓ ⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵏⵓ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("IS36_17","024_36_17","ISA","36","17","17","ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ: ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵡⴻⵖⵔⵓⵎ ⵓ ⵙ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS36_18","024_36_18","ISA","36","18","18","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵃⵉⵣⵇⵉⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵖⴰⵔⵔ ⵅⵎⵉ ⵉⵇⵇⴰⵔ: ⵙⵉⴷⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ. ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ? ");
INSERT INTO rift_vpl VALUES ("IS36_19","024_36_19","ISA","36","19","19","ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵃⴰⵎⴰⵜ ⴷ ⴰⵔⴼⴰⴷ? ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵙⴼⴰⵔⵡⴰⵢⵉⵎ? ⵎⴰ ⵙⵙⵏⴻⵊⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵅⴻⵏⵏⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("IS36_20","024_36_20","ISA","36","20","20","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ-ⵢⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵙⵉⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ?’” ");
INSERT INTO rift_vpl VALUES ("IS36_21","024_36_21","ISA","36","21","21","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵖⴷⴻⵏ, ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⵉⵏ ⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵎⴰⵖⴰⵔ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵜⴰⵔⵔⵉⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("IS36_22","024_36_22","ISA","36","22","22","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴽ-ⴷ ⵛⵉⴱⵏⴰ, ⴰⵎⴰⵔⵉⵔ, ⴷ ⵢⵓⵡⴰⵅ, ⵎⵎⵉⵙ ⵏ ⴰⵙⴰⴼ, ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⵎⴻⵣⵔⵓⵢ, ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵛⴰⵔⵔⴳⴻⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ. ⵏⵉⵜⵏⵉ ⵃⴰⵊⴰⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS37_1","024_37_1","ISA","37","1","1","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⴰⵢⴰ, ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⴷⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS37_2","024_37_2","ISA","37","2","2","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⴰⵍⵢⴰⵇⵉⵎ, ⵍⴻⵎⵇⴻⴷⴷⴻⵎ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴷ ⵛⴰⴱⵏⴰ, ⴰⵎⴰⵔⵉⵔ, ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ. ");
INSERT INTO rift_vpl VALUES ("IS37_3","024_37_3","ISA","37","3","3","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ: ‘ⴰⵙⵙ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⵏ ⵡⴻⵄⵇⴰⴱ ⵓ ⵏ ⵓⴱⴻⵀⴷⴻⵍ, ⵎⴰⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵡⴹⴻⵏ-ⴷⴷ ⴰⵍ ⴰⵔⵣⴰⵎ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵊⵊⴻⵀⴷ ⵉ ⵜⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("IS37_4","024_37_4","ISA","37","4","4","ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵉⵙⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉⵙ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵓ ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵄⴰⵇⴻⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉⵙⵍⴰ. ⵙⴳⴻⵄⵄⴻⴷ ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵥⴰⴵⵉⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴱⴰⵇⵉ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴻⵏ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("IS37_5","024_37_5","ISA","37","5","5","ⴰⵎⵎⵓ ⵉⵡⴹⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ ⵖⴰⵔ ⵉⵛⴰⵄⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("IS37_6","024_37_6","ISA","37","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵛⴰⵄⵢⴰ: “ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ ⵉ ⵙⵉⴷⵉⵜⵡⴻⵎ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵜⴻⵙⵍⵉⴷ, ⵉ ⵣⵉ ⵉ ⴷ ⴰⵢⵉ ⵛⴻⵇⵇⴼⴻⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS37_7","024_37_7","ISA","37","7","7","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⵙ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⵍ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵏⵖⴻⵖ ⴷⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵙ ⵙⵙⵉⴼ.’” ");
INSERT INTO rift_vpl VALUES ("IS37_8","024_37_8","ISA","37","8","8","ⵅⴻⵏⵏⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵢⵓⴼⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵍⵉⴱⵏⴰ, ⵎⴰⵖⴰⵔ ⵉⵙⵍⴰ ⴰⵇⴰ ⵉⵇⵍⴻⵄ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ ⵉⴼⴼⴻⵖ ⵣⵉ ⵍⴰⵅⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("IS37_9","024_37_9","ISA","37","9","9","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵇⴰ ⵏⵏⴰⵏ ⵅ ⵜⵉⵔⵀⴰⵇⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴽⵓⵛ: “ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴽⵉⴷⴻⴽ ⵉⵎⵎⵏⴻⵖ!”, ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵢⴰ, ⵉⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS37_10","024_37_10","ISA","37","10","10","“ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴰⴽ-ⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵛⴻⴽ ⵉⵖⵡⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵡⴻⵏⵏⵉ ⵅ ⵜᵉⵜⵜⵛⴰⵍⴻⴷ ⴰⵎ ⵉⵇⵇⴰⵔ: ⵓⵔⵛⴰⵍⵉⵎ ⵡⴰⵔ ⵜⵡⴻⵟⵟⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("IS37_11","024_37_11","ISA","37","11","11","ⵅⵣⴰⵔ, ⵜⴻⵙⵍⵉⴷ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵏⵏⴻⵖⵏⵉ, ⵜⵉⵏⵏⵉ ⵃⴰⵔⵔⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵓⵜⴻⵃⵃⵉ. ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("IS37_12","024_37_12","ISA","37","12","12","ⵎⴰ ⴼⴻⴽⴽⴻⵏ ⵜⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ? ⵊⵓⵣⴰⵏ ⴷ ⵃⴰⵔⴰⵏ ⴷ ⵔⵚⵉⴼ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⴷⴰⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴰⵍⴰⵙⵙⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("IS37_13","024_37_13","ISA","37","13","13","ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⵃⴰⵎⴰⵜ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵔⴼⴰⴷ ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴼⴰⵔⵡⴰⵢⵉⵎ ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵀⴰⵏⴰⵄ ⴷ ⵄⵉⵡⵡⴰ?’” ");
INSERT INTO rift_vpl VALUES ("IS37_14","024_37_14","ISA","37","14","14","ⵃⵉⵣⵇⵉⵢⴰ ⵉⴽⵙⵉ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵖⵔⵉ ⵜⴻⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⴻⵏⵜ ⵃⵉⵣⵇⵉⵢⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS37_15","024_37_15","ISA","37","15","15","ⵉⵥⵥⵓⴵ ⵃⵉⵣⵇⵉⵢⴰⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS37_16","024_37_16","ISA","37","16","16","“ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵊⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ! ⵛⴻⴽ, ⵡⴰⵀ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS37_17","024_37_17","ISA","37","17","17","ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⴻⵅⵣⴰⵔⴻⴷ! ⵙⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⴰⵏⵃⴰⵔⵉⴱ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵄⴻⵢⵢⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS37_18","024_37_18","ISA","37","18","18","ⴷ ⵜⵉⴷⴻⵜⵜ, ⴰ ⵙⵉⴷⵉ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵛⵛⵓⵔ ⵇⴹⴰⵏ ⵜⵉⵎⵎⵓⵔⴰ ⵏⵏⵉ, ⵅⴰⵔⵔⴱⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("IS37_19","024_37_19","ISA","37","19","19","ⵓ ⵏⴹⴰⵔⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵓⴼⵓⵙ ⵏ ⵢⴻⵡⴷⴰⵏ ⵡⴰⵀⴰ, ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴹⴰⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS37_20","024_37_20","ISA","37","20","20","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS37_21","024_37_21","ISA","37","21","21","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵙ ⵎⵉⵏⵣⵉ ⵜⴻⵥⵥⵓⴵⴻⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵅ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS37_22","024_37_22","ISA","37","22","22","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵅⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵜⴰⵄⵣⴰⵔⵛⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵜⴻⵙⵙⴻⵃⵇⴰⵔ ⵉ ⵛⴻⴽ, ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵜⴻⵀⵣⴰ ⵣⵣⴰⵢⴻⴽ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵀⴻⵣⵣ ⴰⵣⴻⴵⵉⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("IS37_23","024_37_23","ISA","37","23","23","ⵎⴰⵏ ⵡⴻⵏ ⵜⵄⴻⵢⵢⴱⴻⴷ ⵓ ⴷⵉ ⵎⴰⵏ ⵡⴻⵏ ⵜⵛⴻⵇⵇⴼⴻⴷ, ⵎⴰⵏ ⵡⴻⵏ ⵖⴰⵔ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵓ ⵅ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵅⴻⴼ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ? ⵛⴻⴽ ⵜᵉⵜⵜⵖⴻⵏⵏⴰⵏⴻⴷ ⵅ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("IS37_24","024_37_24","ISA","37","24","24","ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⴻⴷⵄⵉⴷ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵜⴻⵏⵏⵉⴷ: ⵙ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉⵏⵓ ⴳⴻⵄⵄⴷⴻⵖ ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⵓⴱⵏⴰⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵎⴻⵖ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵙ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵢⵓⵄⵍⴰⵏ ⵓⵍⴰ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵙ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵏ ⵉⵎⴻⵔⵣⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴰⵍ ⵜⴰⵇⵉⵛⵛⴰⵜ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ, ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS37_25","024_37_25","ISA","37","25","25","ⵏⴻⵛⵛ ⵖⵣⵉⵖ ⴰⵏⵓⵜⴻⵏ ⵓ ⵙⵡⵉⵖ ⴰⵎⴰⵏ. ⵙ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵙⵙⵉⵥⵖⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵎⵉⵚⵔⴰ!’” ");
INSERT INTO rift_vpl VALUES ("IS37_26","024_37_26","ISA","37","26","26","“ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⴳⴳⵉⵖ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵡⵛⵉⵖ ⴰⵙ ⵓⴷⴻⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ? ⵍⴻⵅⵅⵓ ⵊⵊⵉⵖ ⵜ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⴷ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS37_27","024_37_27","ISA","37","27","27","ⵉⵎⴻⵣⴷⴰⵖ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵔⵅⵓⵏ, ⴰⵔⵥⵉⵏ, ⵙⴻⴹⵃⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵎ ⵡⴻⴼⵙⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⵎ ⵓⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ, ⴰⵎ ⵓⵍⵓⵎ ⵅ ⵜⵣⴻⵖⵡⵉⵏ, ⴰⵎ ⵉⵎⴻⵏⴷⵉ ⵉⵛⴻⵎⴹⴻⵏ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS37_28","024_37_28","ISA","37","28","28","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵖⵉⵎⵉ ⵏⵏⴻⵛ ⴷ ⵓⴼⴼⵓⵖ ⵏⵏⴻⵛ ⴷ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵛ ⴷ ⵓⵖⴻⵡⵡⴻⵖ ⵏⵏⴻⵛ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("IS37_29","024_37_29","ISA","37","29","29","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵖⴻⵡⵡⵖⴻⴷ ⵅⴰⴼⵉ ⵓ ⵜⵓⴼⴼⴻⵜ ⵏⵏⴻⵛ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⴰⴷ ⴰⵛ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵛⵜ ⵏ ⵜⵙⴻⵏⵏⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵙⵍⵉⵎⴻⵜ ⵊⴰⵔ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⴷⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS37_30","024_37_30","ISA","37","30","30","“ⵜⴰ ⴰⴷ ⴰⵛ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ: ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ-ⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵎⵉⵏ ⵖⴰ ⵉⵖⴻⵎⵢⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵉⵖⴻⵎⵢⴻⵏ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵜⵣⴰⵔⵄⴻⵎ ⵓ ⴰⴷ ⵜⴻⵎⵊⴰⵔⴻⵎ, ⴰⴷ ⵜⴻⵥⵥⵓⵎ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS37_31","024_37_31","ISA","37","31","31","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵏⴻⵊⵎⴻⵏ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵉⵡⵡⴻⵜ ⵄⴰⵡⴻⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ ⵓ ⵙⴻⵏⵏⴻⵊ ⴰⴷ ⵢⴰⵡⵉ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS37_32","024_37_32","ISA","37","32","32","ⵎⴰⵖⴰⵔ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵉⴼⴼⴻⵖ ⵎⵉⵏ ⵉ ⵖⴰ ⵉⵏⵏⴻⵊⵎⴻⵏ, ⴰⵙⴰⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵜⵜ ⵉⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("IS37_33","024_37_33","ISA","37","33","33","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⴷⴻⴼ ⵛⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵛⵛⵉⵜ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⴼⵍⵉⵜⵛⴰ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵛⴰ ⵙ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⴱⴻⵇⵇⵉⴹ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⴰⵊ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS37_34","024_37_34","ISA","37","34","34","ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷⴷ-ⵢⵓⵙⴰ, ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ. ⵡⴰⵔ ⵉⵜⵜⵉⴷⵉⴼ ⵛⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS37_35","024_37_35","ISA","37","35","35","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵍⵇⵉⵖ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵙⵙⵏⴻⵊⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ.’” ");
INSERT INTO rift_vpl VALUES ("IS37_36","024_37_36","ISA","37","36","36","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⵎⴻⵏⵢⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵛⵛⵓⵔ. ⵓⵎⵉ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴷ ⵍⵅⴻⵛⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS37_37","024_37_37","ISA","37","37","37","ⵓⵛⴰ ⵉⴼⵙⵉ ⵙⴰⵏⵃⴰⵔⵉⴱ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵙ, ⵉⵔⵓⵃ, ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵏⵉⵏⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("IS37_38","024_37_38","ISA","37","38","38","ⵓⵎⵉ ⵉⵙⵊⴻⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵏⵉⵙⵔⵓⵅ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷⵔⴰⵎⵎⵉⵍⵉⴽ ⴷ ⵛⴰⵔⴰⵚⴰⵔ ⵏⵖⵉⵏ ⵜ ⵙ ⵙⵙⵉⴼ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵔⴰⵔⴰⵜ. ⵎⵎⵉⵙ ⴰⵙⴰⵔⵃⴰⴷⴷⵓⵏ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS38_1","024_38_1","ISA","38","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵃⵍⴻⵛ ⵃⵉⵣⵇⵉⵢⴰ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⴰⵛ ⵉⵏⴻⵇⵇⴻⵏ. ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵚ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴻⵡⵛ ⵍⵓⵎⵓⵔⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ, ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ ⵄⴰⴷ ⴽⵜⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("IS38_2","024_38_2","ISA","38","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵃⵉⵣⵇⵉⵢⴰ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵃⵉⴹ ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵖⴰⵔ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("IS38_3","024_38_3","ISA","38","3","3","ⵉⵏⵏⴰ: “ⴰ, ⵙⵉⴷⵉ, ⵄⵇⴻⵍ ⴰⵇⴰ ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵙ ⵍⴰⵎⴰⵏ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⵓⵍ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵓ ⴳⴳⵉⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ.” ⵓⵛⴰ ⵉⴱⴷⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵜⵜⵔⵓ ⵙ ⵊⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("IS38_4","024_38_4","ISA","38","4","4","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵛⴰⵄⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("IS38_5","024_38_5","ISA","38","5","5","“ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵃⵉⵣⵇⵉⵢⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴱⴰⴱⴰⵛ ⴷⴰⵡⵓⴷ: ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵛ ⵓ ⵥⵔⵉⵖ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵏⵉⵖ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS38_6","024_38_6","ISA","38","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵓⵍⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵍⵇⵉⵖ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("IS38_7","024_38_7","ISA","38","7","7","ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵙⵉⴷⵉ ⵉ ⵛⴻⴽ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⴳⴳ ⴰⵡⴰⵍ-ⴰ ⵏⵏⵉ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("IS38_8","024_38_8","ISA","38","8","8","ⵅⵣⴰⵔ, ⴰⴷ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵜⵉⵍⵉ ⵅ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵏ ⴰⵃⴰⵣ ⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵅ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵏ ⴷⴷⵔⵓⵊ ⵏ ⵜⴼⵓⵛⵜ, ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ.’” ⵅⴻⵏⵏⵉ ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵜⴼⵓⵛⵜ ⵄⴻⵛⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵅ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵏⵏⵉ ⵣⵉ ⴷⴷ-ⵜⴻⵀⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("IS38_9","024_38_9","ISA","38","9","9","ⵜⵉⵔⴰ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵃⵍⴻⵛ ⵓⵛⴰ ⵉⴳⴳⴻⵏⴼⴰ ⵣⵉ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS38_10","024_38_10","ISA","38","10","10","“ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵍⴻⵅⵅⵓ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵅ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⴰⵅⴰⵔⵜ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵏⵓ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵣⵣⴰⵢⵉ.’ ");
INSERT INTO rift_vpl VALUES ("IS38_11","024_38_11","ISA","38","11","11","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵥⴰⵔⵔⴻⵖ ⵄⴰⴷ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵖ ⵄⴰⴷ ⵉⵡⴷⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴰⵅⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("IS38_12","024_38_12","ISA","38","12","12","ⵜⵉⵛⵍⵉ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⵜⵜ ⵅⴰⴼⵉ ⴰⵔⵥⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵉ ⵜⵜ ⴽⴽⵙⴻⵏ ⴰⵎ ⴽⴽⵙⴻⵏ ⴰⵇⵉⴹⵓⵏ ⵏ ⵓⵎⴻⴽⵙⴰⵡ. ⴰⵎ ⴱⵓ-ⵓⵣⴻⵟⵟⴰ ⴹⴻⴼⵙⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ. ⴰⴷ ⴰⵢⵉ ⵉⵇⴻⵙⵙ ⵣⵉ ⴷⴷⴻⴱⴱⵓⵣ ⵏ ⵜⵅⴻⵢⵢⴰⴹⵜ: ⴰⴷ ⵜⴻⵇⴹⵉⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵊⴰⵔ ⵡⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("IS38_13","024_38_13","ISA","38","13","13","ⵔⴰⵊⵉⵖ ⵙ ⵚⵚⴱⴰⵔ ⴰⵍ ⴰⵜⴻⴼⴼⵓ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵥ ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⴰⵎ ⵡⴰⵢⵔⴰⴷ: ⴰⴷ ⵜⴻⵇⴹⵉⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵊⴰⵔ ⵓⵜⴻⴼⴼⵓ ⴷ ⴵⵉⵍⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("IS38_14","024_38_14","ISA","38","14","14","ⵜⵜⵊⵉⵡⵊⵉⵡⴻⵖ ⴰⵎ ⵜⴼⴰⵍⴵⴻⵙⵜ ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⴰⵎ ⵜᵉⵟⵟⴰⵡ, ⵜⵜⴳⴻⵔⴳⵓⵔⴻⵖ ⴰⵎ ⵜⴻⴷⴱⵉⵔⵜ. ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ: ‘ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ, ⵉⵍⵉ ⴷ ⴰⴹⵎⴰⵏ ⵉ ⵏⴻⵛⵛ!’ ");
INSERT INTO rift_vpl VALUES ("IS38_15","024_38_15","ISA","38","15","15","ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ? ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵉ-ⵜ. ⵎⴰⵔⵔⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⴽⴽⴻⵖ ⵅ ⵜⴰⵔⵣⵓⴳⵉ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS38_16","024_38_16","ISA","38","16","16","‘ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴷⴷⴰⵔ ⵓⵛⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵜⵓⴷⴰⵔⵜ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ ⵓ ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴰⵔⵔⵉⴷ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("IS38_17","024_38_17","ISA","38","17","17","ⵅⵣⴰⵔ, ⵜⴰⵔⵣⵓⴳⵉ ⵜⵓⵖⴰ ⵜⴰⵔⵣⴻⴳ ⴰⵢⵉ ⵉ ⵍⴻⵀⵏⴰ. ⵛⴻⴽ ⵜⵍⴻⵙⵇⴻⴷ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵃⴹⵉⴷ ⵣⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ, ⵎⴰⵖⴰⵔ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵉⵏⵓ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS38_18","024_38_18","ISA","38","18","18","ⵎⴰⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⵡⴰⵔ ⵛⴻⴽ ⵜⵇⴰⴷⴰ ⵛⴰ, ⵍⵎⴻⵡⵜ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⴻⵎⵖⴰⵔ. ⵡⵉ ⵖⴰ ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ, ⵡⴰⵔ ⵜⵜⵔⵉⵊⵉⵏ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS38_19","024_38_19","ISA","38","19","19","ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵛⴻⴽ ⵉⵇⴰⴷⴰ. ⴱⴰⴱⴰⵜⵙⴻⵏ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("IS38_20","024_38_20","ISA","38","20","20","“ⵙⵉⴷⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ. ⴰⴷ ⵏⵓⵔⴰⵔ ⵙ ⵓⵣⴻⵏⵣⵓⵏ ⵅ ⵉⴼⵉⵍⴰⵏ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS38_21","024_38_21","ISA","38","21","21","ⴰⵇⴰ ⵉⵏⵏⴰ ⵉⵛⴰⵄⵢⴰ: “ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵜⴰⵣⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⵍⴻⵜⴼⴻⵏ ⵅ ⵜⵃⴻⴱⴱⵓⵛⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS38_22","024_38_22","ISA","38","22","22","ⵃⵉⵣⵇⵉⵢⴰ ⴰⵇⴰ ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("IS39_1","024_39_1","ISA","39","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴱⴰⵔⴰⴷⵓⵅ-ⴱⴰⵍⴰⴷⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵍⴰⴷⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵜⵉⴱⵔⴰⵜⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⵙⵍⴰ ⴰⵇⴰ ⵃⵉⵣⵇⵉⵢⴰ ⵉⵀⵍⴻⵛ ⵓⵛⴰ ⵉⴳⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("IS39_2","024_39_2","ISA","39","2","2","ⵉⴼⴰⵔⵃ ⵣⵣⴰⵢⵙⴻⵏ ⵃⵉⵣⵇⵉⵢⴰ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏⵏⴻⵙ: ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵍⴻⵄⵟⵓⵔ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵍⴻⵀⵔⵉ ⵏ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵏ ⵜⵅⵓⴱⴰⵢ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵏⵏⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷ ⴰⵙⴻⵏ ⵜ ⵉⵙⵙⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS39_3","024_39_3","ISA","39","3","3","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵏⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵓ ⵎⴰⵏⵉⵙ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵓⵙⵉⵏ?” ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ, ⵣⵉ ⴱⴰⴱⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS39_4","024_39_4","ISA","39","4","4","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ?” ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ: “ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵜⵅⵓⴱⴰⵢ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜ ⵙⵙⴻⵛⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS39_5","024_39_5","ISA","39","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵛⴰⵄⵢⴰ ⵉ ⵃⵉⵣⵇⵉⵢⴰ: “ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ");
INSERT INTO rift_vpl VALUES ("IS39_6","024_39_6","ISA","39","6","6","‘ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵎⴻⵍⵎⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ ⴰⵍ ⴰⵙⵙ-ⴰ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵡⴰⵍⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS39_7","024_39_7","ISA","39","7","7","ⴰⴷ ⴰⵡⵢⴻⵏ ⵓⵍⴰ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⴻⴽ, ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵜⴻⵊⵊⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("IS39_8","024_39_8","ISA","39","8","8","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵏⵏⴰ ⵉ ⵉⵛⴰⵄⵢⴰ: “ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏⵏⵉⴷ ⵉⵚⴱⴻⵃ.” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⴷ ⵍⴰⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("IS40_1","024_40_1","ISA","40","1","1","“ⵙⴼⴻⵡⵡⴻⵊ, ⵙⴼⴻⵡⵡⴻⵊ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("IS40_2","024_40_2","ISA","40","2","2","ⵙⵉⵡⵍⴻⵎ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴱⴰⵔⵔⵃⴻⵎ ⴰⵙ ⴰⵇⴰ ⴰⵎⴻⵏⵖⵉ ⵏⵏⴻⵙ ⵉⵇⴹⴰ, ⴰⵇⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵚⵍⴻⵃ, ⴰⵇⴰ ⵜⴻⴽⵙⵉ ⵙ ⵓⴹⴻⴼⴼⵓⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS40_3","024_40_3","ISA","40","3","3","ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵖⵓⵢⵢⵓⵏ ⴷⵉ ⵍⴻⵅⵍⴰ: ‘ⵙⵡⴻⵊⴷⴻⵎ ⴰⴱⵔⵉⴷ ⵉ ⵙⵉⴷⵉ, ⵙⴰⵔⵔⵃⴻⵎ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⴱⵔⵉⴷ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("IS40_4","024_40_4","ISA","40","4","4","ⵎⴰⵔⵔⴰ ⵜⵉⵖⵣⵓⵔⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ, ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰⵏ. ⵎⵉⵏ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵙⴻⴳⴳⴻⵎ ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵓⵙⴻⴷⴷⵉ ⵏ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵍⴻⵡⴹⴰ ⵉⵡⴰⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS40_5","024_40_5","ISA","40","5","5","ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⴰⴷ ⵜⵥⴰⵔ ⴰⵇⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS40_6","024_40_6","ISA","40","6","6","“ⵜⵎⵉⵊⵊⴰ ⵜⴻⵏⵏⴰ: ‘ⴱⴰⵔⵔⴻⵃ!’ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵎⵉⵏ ⵖⴰ ⴱⴰⵔⵔⵃⴻⵖ?’ ‘ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⴰⵎ ⴰⵔⴱⵉⵄ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴰⵎ ⵜⵏⴻⵡⵡⴰⵛⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS40_7","024_40_7","ISA","40","7","7","ⴰⵔⴱⵉⵄ ⵉⵜⵜⴰⵥⴻⵖ, ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵜⴻⵙⵍⴰⵡ ⵅⵎⵉ ⵅⴰⵙ ⵉⵜⵜⵙⵓⴹ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ. ⴷ ⵜⵉⴷⴻⵜⵜ, ⵍⴳⴻⵏⵙ ⴷ ⴰⵔⴱⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS40_8","024_40_8","ISA","40","8","8","ⴰⵔⴱⵉⵄ ⵉⵜⵜⴰⵥⴻⵖ, ⵜⴰⵏⴻⵡⵡⴰⵛⵜ ⵜⴻⵙⵍⴰⵡ, ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("IS40_9","024_40_9","ISA","40","9","9","“ⴳⴻⵄⵄⴻⴷ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰ ⵚⵉⵀⵢⵓⵏ, ⴰ ⵛⴻⵎ ⵜⴰⵎⴱⴻⵛⵛⴰⵔⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ ⵙ ⵊⵊⴻⵀⴷ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⴰ ⵛⴻⵎ ⵜⴰⵎⴱⴻⵛⵛⴰⵔⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ, ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ, ⵉⵏⵉ ⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ: ‘ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵏⴽⴻⵏⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS40_10","024_40_10","ISA","40","10","10","ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⵉⵊⵀⴻⴷ ⵓⵛⴰ ⴰⵖⵉⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⵃⴽⴻⵎ. ⵅⵣⴰⵔ, ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⴰⵅⴻⴵⴻⵚ ⵏⵏⴻⵙ ⵉⵣⵡⴰⵔ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS40_11","024_40_11","ISA","40","11","11","ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵓⵎⴻⴽⵙⴰⵡ, ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⴱⵓ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵙ. ⴰⴷ ⵉⵏⴷⴻⵀ ⵉⵏⵏⵉ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ ⵙ ⵍⴻⵄⵇⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS40_12","024_40_12","ISA","40","12","12","“ⵎⴰⵏ ⵡⴻⵏ ⵉⵄⴱⴰⵔⴻⵏ ⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵙ ⵡⵓⵔⵓ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉⴽⵙⵉⵏ ⵍⴻⵇⵢⴰⵙ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙ ⵍⴻⵄⴱⴰⵔ ⵏ ⵓⴼⵓⵙ? ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉⵟⵟⴼⴻⵏ ⵓⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵊⵊ ⵏ ⵍⵎⵓⴷ? ⵎⴰⵏ ⵡⴻⵏ ⵉⵡⴻⵣⵣⵏⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵙ ⵉⵊⵊ ⵏ ⵍⴱⴰⵙⴽⵓ ⵓ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵙ ⵍⵎⵉⵣⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("IS40_13","024_40_13","ISA","40","13","13","ⵎⴰⵏ ⵡⴻⵏ ⵉⴱⴻⵇⵇⵛⴻⵏ ⵅ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵜ ⵉⵙⵙⵖⴰⵔⴻⵏ ⴰⵎ ⵓⵎⵛⴰⵡⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("IS40_14","024_40_14","ISA","40","14","14","ⵡⵉ ⵜ ⵉⵙⴻⵇⵙⴰⵏ ⵏⴻⵜⵜⴰ ⵅ ⵛⵛⵡⴰⵔ ⴷ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵙ ⵉⵙⵙⵛⵏⴻⵏ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓ ⵡⵉ ⴷ ⴰⵙ ⵉⵙⵙⵍⴻⵎⴷⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵍⵃⴻⵇⵇ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⴰⵙ ⵜⵓⵙⵙⵏⴰ? ⵡⵉ ⴷ ⴰⵙ ⵉⵙⵙⴰⵔⴳⴱⴻⵏ ⴰⴱⵔⵉⴷ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("IS40_15","024_40_15","ISA","40","15","15","“ⵅⵣⴰⵔ, ⵍⴻⴳⵏⵓⵙ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵓⴷⴷⵉⵏⵜ ⵣⴻⴳ ⵓⴱⵓⵇⴰⵍ ⵓ ⴰⵎ ⵛⵡⴰⵢⵜ ⵏ ⵜⵏⴻⵖⴷⴰ ⵅ ⵍⵎⵉⵣⴰⵏ. ⴰⵇⴰ ⴷⴰ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⴳⵣⵉⵔⵉⵏ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵉⴼⵙⵓⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS40_16","024_40_16","ISA","40","16","16","ⵍⵓⴱⵏⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵇⵉⴷⴷⵉ ⵉ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵍⵎⴰⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵇⵉⴷⴷⵉⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("IS40_17","024_40_17","ISA","40","17","17","ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⴵⵉⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵃⴻⵙⵙⴻⴱ ⵉ-ⵜⴻⵏ ⴷ ⵡⴰⵍⵓ, ⴷ ⵍⴻⵄⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS40_18","024_40_18","ISA","40","18","18","ⵡⵉ ⴰⴽ-ⴷ ⵉ ⵖⴰ ⵜⴻⵙⵙⴻⵎⵇⵓⴷⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵏⵉⵖ ⵎⴰⵏ ⴰⵔⵡⴰⵙ ⵉ ⵣⵉ ⵜ ⵖⴰ ⵜⵅⴻⵍⴼⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("IS40_19","024_40_19","ISA","40","19","19","“ⴰⵃⵔⴰⵢⴼⵉ ⵉⵜⵜⴽⴻⴱⴱⴰ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵓ ⴰⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵖⴻⴵⴻⴼ ⵉ-ⵜ ⵙ ⵡⵓⵔⴻⵖ ⵓ ⵉⴼⴻⵙⵙⵉ ⴰⵙ ⵜⵉⵙⴻⴷⴷⵢⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS40_20","024_40_20","ISA","40","20","20","ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴰⴷ ⵉⵅⴹⴰⵔ ⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵡⴰⵔ ⵢⴰⵔⴻⵛⵛⵉ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵉⵊⵊ ⵏ ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS40_21","024_40_21","ISA","40","21","21","“ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵜⴻⵙⵙⵉⵏⴻⵎ? ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⵙⵍⵉⵎ? ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵜⵓⵖⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ? ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵜⵃⴻⵟⵟⴰⵎ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("IS40_22","024_40_22","ISA","40","22","22","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵜⵇⵓⵔⴰⵔⵜ ⵏ ⵜⴰⵢⵢⵓⵜ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵜⵜⴱⴰⵏⴻⵏ-ⴷⴷ ⴰⵎ ⵢⵉⴱⵓⵔⴻⵅⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵃⵃⴹⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⴰⵔⵡⴰⵇ, ⵉⵜⵜⴱⴻⵣⵣⴻⵄ ⵉ-ⵜⴻⵏ ⴰⵎ ⵓⵇⵉⴹⵓⵏ ⵉ ⵡⴻⵣⴷⴰⵖ, ");
INSERT INTO rift_vpl VALUES ("IS40_23","024_40_23","ISA","40","23","23","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⴷ ⵡⴰⵍⵓ, ⵓ ⵉⵙⵙⴻⵅⵡⴰ ⵍⵇⵓⴹⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS40_24","024_40_24","ISA","40","24","24","ⵄⴰⴷ ⵛⵡⴰⵢⵜ ⵡⴰⵀⴰ ⵜⵜⵡⴰⵥⵥⵓⵏ, ⵄⴰⴷ ⵛⵡⴰⵢⵜ ⵡⴰⵀⴰ ⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ, ⵄⴰⴷ ⵛⵡⴰⵢⵜ ⵡⴰⵀⴰ ⵉⵡⵜⴰ ⵊⵊⴷⴻⵄ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏⵙⴻⵏ ⴰⵥⵡⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵉⵙⵓⴹ ⵏⴻⵜⵜⴰ ⵅⴰⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵓⵥⵖⴻⵏ ⵓⵛⴰ ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⴽⵙⵉ ⵜⴻⵏ ⴰⵎ ⵓⵍⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS40_25","024_40_25","ISA","40","25","25","“ⴰⴽ-ⴷ ⵎⴰⵏ ⵡⴻⵏ ⵜⴻⵅⵙⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵎⵇⵓⴷⴷⴻⵎ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⵉ ⴰⵔⴻⵡⵙⴻⵖ?, ⵉⵇⵇⴰⵔ ⵓⵎⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS40_26","024_40_26","ISA","40","26","26","ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵓ ⵅⵣⴰⵔⴻⵎ, ⵎⴰⵏ ⵡⴻⵏ ⵉⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ? ⴷ ⵏⴻⵜⵜⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵎⴰⵔⵔⴰ ⵙ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵓ ⵙ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵡⴰⵔ ⵉⴱⴻⵟⵟⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ!” ");
INSERT INTO rift_vpl VALUES ("IS40_27","024_40_27","ISA","40","27","27","“ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵅⴻⵏⵏⵉ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⵓ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⴰⵎⵎⵓ, ⴰ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⴱⵔⵉⴷ ⵉⵏⵓ ⵉⵏⵏⵓⴼⴼⴰⵔ ⵅ ⵙⵉⴷⵉ ⵓ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵜᵉⵜⵜⴻⴽⴽ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ?’ ");
INSERT INTO rift_vpl VALUES ("IS40_28","024_40_28","ISA","40","28","28","ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ? ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵜⴻⵙⵍⵉⴷ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⴱⴷⴰ, ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵟⵟⵔⵓⴼⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵉⵜⵜⵉⵃⴻⵍ ⵓ ⵡⴰⵔ ⵢⴰⵔⴻⵅⵅⵓ? ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴼⵀⴻⵎ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS40_29","024_40_29","ISA","40","29","29","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵉⵛ ⵊⵊⴻⵀⴷ ⵉ ⵡⴻⵏⵏⵉ ⵢⵓⵃⵍⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵊⵊⴻⵀⴷ ⵢⴰⵔⴻⵏⵏⵉ ⴰⵙ ⵊⵊⴻⵀⴷ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS40_30","024_40_30","ISA","40","30","30","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵜⵜⴰⵃⵍⴻⵏ ⵓ ⴰⵔⴻⵅⵅⵓⵏ, ⵉⴱⵍⵉⵖⴻⵏ ⵜⵜⴻⵏⵇⵔⴰⴹⴻⵏ ⵓⵛⴰ ⵡⴻⵟⵟⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS40_31","024_40_31","ISA","40","31","31","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵙⵉⴷⵉ, ⵜⵜⴰⵢⵎⴻⵏ ⵊⵊⴻⵀⴷ ⵏ ⵊⴷⵉⴷ. ⵏⵉⵜⵏⵉ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⴰⵎ ⵓⴳⵉⴷⴻⵔ, ⵜⵜⴰⵣⵣⵍⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵃⵍⴻⵏ, ⴳⴳⵓⵔⴻⵏ ⵎⴰⵛⴰ ⵡⴰⵔ ⴰⵔⴻⵅⵅⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS41_1","024_41_1","ISA","41","1","1","“ⵙⴻⵖⴷⴻⵎ-ⴷⴷ ⵣⵣⴰⵜⵉ, ⴰ ⵜⵉⴳⵣⵉⵔⵉⵏ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵊⵊⴻⵎ ⵛⵛⵓⵄⵓⴱ ⴰⴷ ⵟⵟⴼⴻⵏ ⵊⵊⴻⵀⴷ ⵏ ⵊⴷⵉⴷ, ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴰⴷⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵍⴻⵃⴽⴰⵎ ⵎⴰⵔⵔⴰ ⵏⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("IS41_2","024_41_2","ISA","41","2","2","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⴷ-ⵉⵙⵙⴼⴰⵇⴻⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵎⵙⴰⴳⴰⵔ ⵜⵙⴻⴳⴷⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ? ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⴻⵍⵍⵎⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵙ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ? ⵎⴰⵏ ⵡⴻⵏ ⵢⴰⵔⵔⵉⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⵉ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⴰⵎ ⵓⵍⵓⵎ ⵏⵏⵉ ⴷⵉ ⵉⵜⵜⵙⵓⴹ ⵓⵙⴻⵎⵎⵉⴹ? ");
INSERT INTO rift_vpl VALUES ("IS41_3","024_41_3","ISA","41","3","3","ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ, ⵉⴽⴻⵎⵎⴻⵍ ⵖⴰⵔ ⵣⵣⴰⵜ ⴷⵉ ⵍⴻⵀⵏⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵡⴰⵔ ⵜ ⵉⵃⵉⴷⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS41_4","024_41_4","ISA","41","4","4","ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴻⵇⴼⴻⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵢⴰ? ⵏⴻⵜⵜⴰ, ⵡⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵉ ⵊⵊⵉⵍⴰⵜ: ‘ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓ ⵖⴰⵔ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏⴻⵛⵛ ⵏⴻⵛⵛ.’ ");
INSERT INTO rift_vpl VALUES ("IS41_5","024_41_5","ISA","41","5","5","ⵜⵉⴳⵣⵉⵔⵉⵏ ⵥⵔⵉⵏⵜ ⵜ, ⴳⴳⵯⴻⴷⴻⵏⵜ, ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵔⵊⵉⵊⴻⵏ, ⵏⵉⵜⵏⵉ ⵓⴷⵙⴻⵏ-ⴷⴷ, ⵉⵡⴹⴻⵏ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("IS41_6","024_41_6","ISA","41","6","6","ⵉⵊⵊⴻⵏ ⵉⵡⵛⴰ ⴰⴼⵓⵙ ⵉ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⵉ ⵓⵎⴰⵙ: ‘ⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ!’” ");
INSERT INTO rift_vpl VALUES ("IS41_7","024_41_7","ISA","41","7","7","“ⴰⵚⵏⴰⵢⵄⵉ ⵉⴳⴳⴰ ⵓⵍ ⴷⴻⴳ ⵡⴻⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵜ ⵉⵙⵙⴻⵔⵖⴻⵏ ⵙ ⵡⴻⴼⴹⵉⵙ, ⵡⴻⵏⵏⵉ ⵉⵡⴻⵜⵜⵉⵏ ⵅ ⵥⵥⴻⴱⵔⴰ, ⴰⵎ ⵉⵇⵇⴰⵔ ⵅ ⵎⴰⵎⵎⴻⵛ ⵙⵙⵍⴻⵙⵇⴻⵏ ⵉⵣⵉⵢⵏⴰⵏ: ‘ⴷ ⵍⴻⵎⵍⵉⵃ!’. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵡⴻⵎⵣⵉⵍ ⵉ ⵍⴻⵅⵢⴰⵍ ⵙ ⵉⵎⴻⵙⵎⴰⵔ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS41_8","024_41_8","ISA","41","8","8","“ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⴰ ⵢⴰⵄⵇⵓⴱ ⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵖ, ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ ⵉⵄⵉⵣⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS41_9","024_41_9","ISA","41","9","9","ⵟⵟⴼⴻⵖ ⵛⴻⴽ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅⴰⴽ ⵣⵉ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵇⴰⵄ, ⵏⵏⵉⵖ ⴰⵛ: ‘ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵉⵅⴹⴰⵔⴻⵖ ⵛⴻⴽ, ⵡⴰⵔ ⵛⴻⴽ ⵏⴹⴰⵔⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("IS41_10","024_41_10","ISA","41","10","10","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴵⵉⵖ ⴰⴽⵉⴷⴻⴽ, ⵡⴰⵔ ⵙⵃⵉⵙⵙⵉⴼ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵊⴻⵀⴷⴻⵖ, ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⴼⵓⵙ, ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⴽ ⵎⴻⵏⵄⴻⵖ ⵙ ⵓⴼⵓⵙⵉ ⵉⵛⵛⵓⵔ ⵙ ⵜⵙⴻⴳⴷⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS41_11","024_41_11","ISA","41","11","11","“ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵙⵙⵃⴻⵎⵎⴰⵏ. ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵡⴰⵍⵓ, ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS41_12","024_41_12","ISA","41","12","12","ⵛⴻⴽ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴰⵔⵣⵓⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⵉⴼⴻⴷ. ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴽⵉⴷⴻⴽ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵡⴰⵍⵓ ⴷ ⵍⴱⴰⵟⴻⵍ, ⵡⴰⵀ, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("IS41_13","024_41_13","ISA","41","13","13","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵛ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⴼⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("IS41_14","024_41_14","ISA","41","14","14","ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⵛⴻⴽ ⴰⴽⴻⵛⵛⴰⵡ ⵢⴰⵄⵇⵓⴱ, ⴰ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ! ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⴼⵓⵙ, ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵛ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS41_15","024_41_15","ISA","41","15","15","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⵎ ⴷ ⵜⴰⵍⵡⵉⵃⵜ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ ⴷ ⵜⴰⵎⴰⵢⵏⵓⵜ, ⵙ ⵜⴻⵖⵎⴰⵙ ⵉⵇⴻⴹⵄⴻⵏ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵜⴻⵏ ⵜⵙⵙⴰⵔⵡⵜⴻⴷ ⵓ ⴰⴷ ⵜⴻⵏ ⵜⴻⴷⴷⵣⴻⴷ ⵓ ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⴷ ⵍⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("IS41_16","024_41_16","ISA","41","16","16","ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜⴻⵣⵣⵓⵣⴰⵔⴻⴷ, ⴰⴷ ⵜⴻⵏ ⵢⴰⵡⵉ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⴻⵢⵢⴻⵛ ⵜⵃⴰⵔⵢⴰⴹⵜ. ⵛⴻⴽ ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵙⵍⵉⵡⵍⴻⵡⴻⴷ ⵅ ⵙⵉⴷⵉ, ⴰⴷ ⵜⵛⴻⵏⵏⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS41_17","024_41_17","ISA","41","17","17","“ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⴷ ⵉⵎⴻⵣⵍⴰⴹ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵍⵓ ⴷⴰ. ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⵢⵓⵥⴻⵖ ⵙ ⵓⴼⴰⴷⵉ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵙⵍⴻⵖ, ⵏⴻⵛⵛ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵙⴻⵎⵎⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS41_18","024_41_18","ISA","41","18","18","ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵜⵉⵇⴻⵛⵛⵓⵔⴰ ⴰⴷ ⵊⵊⴻⵖ ⵉⵖⴻⵣⵔⴰⵏ ⴰⴷ ⴷⴷⵓⵇⵇⵣⴻⵏ ⵓⵍⴰ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵡⴹⴰⵜ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵍⴻⵅⵍⴰ ⴷ ⴰⵢⴻⵍⵎⴰⵎ ⵏ ⵡⴰⵎⴰⵏ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴷ ⵜⵉⵏⴻⴷⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS41_19","024_41_19","ISA","41","19","19","ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⴷ ⵥⵥⵓⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⴽⴰⵙⵉⵢⴰ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴰⵔⵉⵃⴰⵏⵜ ⴷ ⵓⵣⴻⵎⵎⵓⵔ, ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴷⵓⵍⴱ ⴷ ⵜⴰⵢⴷⴰ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("IS41_20","024_41_20","ISA","41","20","20","ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ, ⴰⴷ ⵏⴻⵄⵎⴻⵏ, ⴰⴷ ⴰⵔⴳⴱⴻⵏ, ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⵊⵎⵉⵄ, ⴰⵇⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵢⴰ, ⴰⵇⴰ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵅⵍⴻⵇ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("IS41_21","024_41_21","ISA","41","21","21","“ⵇⴻⴷⴷⵎⴻⵎ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵡⴻⵎ ⵣⵣⴰⵜⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵡⵢⴻⵎ-ⴷⴷ ⴱⵓⵔⵀⴰⵏⴰⵜ ⵏⵡⴻⵎ ⵉⵊⴻⵀⴷⴻⵏ ⵇⴰⵄ, ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("IS41_22","024_41_22","ISA","41","22","22","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵓ ⴰⴷ ⴰⵏⴻⵖ ⴱⴰⵔⵔⵃⴻⵏ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ. ⵙⴰⵔⴳⴱⴻⵎ ⴰⵏⴻⵖ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵇⴰⵄ, ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵏⴻⴽⵙⵉ ⵖⴰⵔ ⵡⵓⵍ ⵓⵛⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵙⴻⵏⵜ, ⵏⵉⵖ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵙⴻⵍ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("IS41_23","024_41_23","ISA","41","23","23","ⴱⴰⵔⵔⵃⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷⴰⵡⴻⵃⴷⴰ ⵄⴰⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ⴳⴳⴻⵎ ⵛⴰ ⴷ ⵍⵅⴰⵔ ⵏⵉⵖ ⴷ ⵍⵖⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵅⴻⵣⵣⴰⵔ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ ⵙ ⵍⵅⴻⵣⵔⴰⵜ ⵉⴱⴻⵇⵇⵛⴻⵏ, ⴰⴷ ⵜⵜ ⵏⵥⴰⵔ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS41_24","024_41_24","ISA","41","24","24","ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵇⴻⵍⵍ ⵅ ⵡⴰⵍⵓ ⵓ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵏⵏⴼⴰⵄ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴹⴰⵔⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS41_25","024_41_25","ISA","41","25","25","“ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵊⵊⴻⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⴰⴷ ⵉⵍⴰⵖⴰ ⵅ ⵉⵙⴻⵎ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵎ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵏⵏⵉ ⵉⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵓⴱⴻⴵⴰⵄ, ⴰⴷ ⵉⵄⴼⴻⵙ ⵅ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⴰⵎ ⵅ ⵜⴰⵔⵔⵉⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS41_26","024_41_26","ISA","41","26","26","“ⵎⴰⵏ ⵡⴻⵏ ⵉ-ⵜⵜ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵇⴰⵄ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵏⴻⵙⵙⴻⵏ, ⵏⵉⵖ ⵅⴻⵏⵏⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ-ⵜⵜ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵇⴱⴻⵍ, ⵃⵉⵎⴰ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵉⵏⵉ: ‘ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ!’ ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵜⵜ ⵉⴱⴰⵔⵔⵃⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴰⵔⵔⴰⵏ ⴰⴷ ⵏⵙⴻⵍ ⵛⴰ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵍⵉ ⴰⵡⴻⵎ ⵜⵏⴻⵟⵇⴻⵎ ⵙ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS41_27","024_41_27","ISA","41","27","27","ⴰⵎ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏⵏⵉⵖ ⵏⴻⵛⵛ ⵉ ⵚⵉⵀⵢⵓⵏ: ‘ⴰⵇⴰ-ⵜⴻⵏ ⴷⴰ!’, ⵓ ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⵢⴻⵖ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("IS41_28","024_41_28","ISA","41","28","28","ⵏⴻⵛⵛ ⵅⵣⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ! ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵡⵛ ⵛⵛⵡⴰⵔ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⴻⵇⵙⵉⵖ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⴰⵔⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS41_29","024_41_29","ISA","41","29","29","ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵏⵏⴼⴰⵄ, ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⵄⵡⵉⵏ ⵡⴰⵀⴰ ⵓ ⵅⵡⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS42_1","024_42_1","ISA","42","1","1","“ⵅⵣⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⵜⵜⵄⴰⵡⴰⵏⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵙⵙⴰⵔⵙⴻⵖ ⵅⴰⵙ ⴰⵔⵔⵓⵃ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⴻⵃⴽⴰⵎ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS42_2","024_42_2","ISA","42","2","2","ⵡⴰⵔ ⵉⵙⵖⵓⵢⵢⵓ ⵓ ⵡⴰⵔ ⵉⵙⵙⴳⵉⵄⵄⵉⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵜⵜⴰⵔⵔⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⴷⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS42_3","024_42_3","ISA","42","3","3","ⴰⵖⴰⵏⵉⵎ ⵉⵏⴹⴻⴼⵙⴻⵏ ⵡⴰⵔ ⵜ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ ⵛⴰ ⵓ ⵜⴰⴼⵜⵉⵍⵜ ⵏ ⵜⵉⴼⴼⴻⵙⵜ ⵉⵜⵜⴷⵓⵅⵅⵓⵏⴻⵏ ⵡⴰⵔ ⵜ ⵉⵙⵙⴻⵅⵙⵉⵢ ⵛⴰ, ⵡⴰⵀ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS42_4","024_42_4","ISA","42","4","4","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵃⴻⵍ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵔⴻⵥⵥⵉ ⴰⵍ ⴷⴷ-ⵉⵙⵙⴱⴻⴷⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵙ ⴰⴷ ⵔⴰⵊⴰⵏⵜ ⵜⵉⴳⵣⵉⵔⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS42_5","024_42_5","ISA","42","5","5","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵓ ⵉⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵎⵉⵏ ⵅⴰⵙ ⵉⵖⴻⵎⵎⵢⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵉ ⵍⴳⴻⵏⵙ ⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵓ ⴱⵓⵃⴱⴻⵍ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ: ");
INSERT INTO rift_vpl VALUES ("IS42_6","024_42_6","ISA","42","6","6","‘ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵍⴰⵖⵉⵖ ⴰⵛ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵎⴻⵏⵄⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ, ⴰⴷ ⵛⴻⴽ ⵃⴹⵉⵖ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⵍⴳⴻⵏⵙ ⴷ ⵜⴼⴰⵡⵜ ⵉ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("IS42_7","024_42_7","ISA","42","7","7","ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵣⵎⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⴷⴰⵖⴰⵍⴻⵏ, ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵣⵉ ⵍⴻⵃⴱⴻⵙ ⵓ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("IS42_8","024_42_8","ISA","42","8","8","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵛⴻⵖ ⵛⵛⴰⵏ ⵉⵏⵓ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⴰⵙⴻⵎⵖⴰⵔ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵜⵜⵉⵛⴻⵖ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS42_9","024_42_9","ISA","42","9","9","ⵅⵣⴰⵔ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵉⵡⴹⴻⵏⵜ ⵓⵛⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵊⴷⵉⴷ ⴰⴷ ⵜⴻⵏⵜ ⴱⴰⵔⵔⵃⴻⵖ. ⵇⴱⴻⵍ ⵎⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵏⵜ, ⴰⴷ ⴰⵡⴻⵎ ⵜⴻⵏⵜ ⵙⵙⴻⵛⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("IS42_10","024_42_10","ISA","42","10","10","“ⵖⴻⵏⵏⵊⴻⵎ ⵉⵣⵍⵉ ⵏ ⵊⴷⵉⴷ ⵉ ⵙⵉⴷⵉ, ⴰⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵍⴻⴱⵃⴰⵔ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ: ⴽⴻⵏⵏⵉⵏⵜ ⴰ ⵜⵉⴳⵣⵉⵔⵉⵏ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS42_11","024_42_11","ISA","42","11","11","ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵍⴻⵅⵍⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵍⴻⴷⵛⵓⵔ ⵏⵏⵉ ⴷⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵇⵉⴷⴰⵔ. ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵊⵔⵓⴼ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵅ ⵜⵇⵉⵛⵛⵉⵜⵉⵏ ⵏ ⵉⴷⵓⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("IS42_12","024_42_12","ISA","42","12","12","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵄⵓⴵⴻⵏ ⵙⵉⴷⵉ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵛⵛⴰⵏ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⵣⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS42_13","024_42_13","ISA","42","13","13","ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴰⵎ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵟ, ⴰⴷ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⵎ ⵡⴻⵔⵢⴰⵣ ⵉⵎⴻⵃⴹⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵍⵉⵡⵍⴻⵡ, ⴰⴷ ⵉⵙⵖⵓⵢ ⵉ ⵓⵎⴻⵏⵖⵉ, ⴰⴷ ⵉⵃⵚⴰⵔ ⵇⴰⵄ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS42_14","024_42_14","ISA","42","14","14","“ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵙⵙⴻⵖⴷⴻⵖ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵜⵓⵖⴰ ⵙⵇⴰⵔⴻⵖ, ⵜⵜⴻⴱⴱⴰⵜⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ. ⴰⴷ ⵙⵖⵓⵢⴻⵖ ⴰⵎ ⵢⵉⵛⵜⴻⵏ ⵉⵜⵜⴰⵔⵓⵏ, ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵓ ⴰⴷ ⵜⴻⵏ ⵚⴰⵔⴹⴻⵖ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS42_15","024_42_15","ISA","42","15","15","ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴷ ⴰⵎⴻⵙⵙⵓⵛⵉ ⵓ ⴰⴷ ⵊⵊⴻⵖ ⴰⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵢⴰⵥⴻⵖ, ⵉⵖⴻⵣⵔⴰⵏ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷ ⵜⵉⴳⵣⵉⵔⵉⵏ, ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵥⵖⴻⵖ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS42_16","024_42_16","ISA","42","16","16","ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴰⴷ ⵜⴻⵏ ⵏⴻⴷⵀⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵊⵊⴻⵖ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵅ ⵜⴱⵔⵉⴷⵉⵏ ⵡⴰⵔ ⵜⴻⵏⵜ ⴰⵔⴳⴱⴻⵏ. ⵟⵟⵔⴰⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⵜⴼⴰⵡⵜ, ⵎⵉⵏ ⵉⴼⴰⵔⵖⴻⵏ, ⴰⴷ ⵜ ⵙⴻⴳⴳⴷⴻⵖ. ⵜⵉⵏⴰ ⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵙⴻⵎⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS42_17","024_42_17","ISA","42","17","17","ⵉⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ: ‘ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖ!’, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS42_18","024_42_18","ISA","42","18","18","“ⵙⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⴷⵓⵀⵛⴰⵔ! ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵅⵣⴰⵔⴻⵎ ⵓ ⵡⴰⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("IS42_19","024_42_19","ISA","42","19","19","ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⴰⵎ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⴷ ⴰⴷⴻⵀⵛⵓⵔ ⴰⵎ ⵓⵔⴻⵇⵇⴰⵙ ⵉⵏⵓ? ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⴰⵎ ⵓⵎⵜⵉⵇⵇⵉ ⵓ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⴰⵎ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("IS42_20","024_42_20","ISA","42","20","20","ⴰⵟⵟⴰⵙ ⵉ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⵛⵉⴷ ⵡⴰⵍⵓ, ⵉⵡⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⵎ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS42_21","024_42_21","ISA","42","21","21","ⵜⵓⵖⴰ ⵢⴰⵔⴹⴰ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⴷ ⵉⵙⵙⵄⵓⴵⴰ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("IS42_22","024_42_22","ISA","42","22","22","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵏⵉⵜⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵛⴰⵔⴻⵏ ⵜⵜ, ⴽⴻⵛⵛⴹⴻⵏ ⵜⵜ. ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵛⴻⴷⴷⴻⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ, ⵜⵜⵡⴰⵇⵇⵏⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⵢⵎⴰⵔⵜ, ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵎⵙⴻⵏⵊⴻⵎ, ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵇⵇⴰⵔ: ‘ⴰⵔⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ!’ ");
INSERT INTO rift_vpl VALUES ("IS42_23","024_42_23","ISA","42","23","23","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵃⴻⴽⴽⴰⵔⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵙⴻⵍ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉⵏ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("IS42_24","024_42_24","ISA","42","24","24","ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⵉⵡⴹⴻⵏ ⵢⴰⵄⵇⵓⴱ ⴰⵎ ⵜⴻⵢⵎⴰⵔⵜ ⴷ ⵉⵙⵔⴰⵉⵍ ⵉ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ? ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵉⴳⴳⵉ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵏⴻⵅⴹⴰ? ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS42_25","024_42_25","ISA","42","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵣⴻⴵⴻⵄ ⵅⴰⵙ ⴰⵙⵄⴰⵔ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵍⵄⵓⵏⴼ ⵏ ⴳⴰⵔⵔⴰ. ⵉⵇⴻⵡⵡⴰⵔ ⴰⵙ ⵙ ⵉⵛⴻⵄⵄⴰⵍⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵃⴻⴽⴽⴰⵔ, ⵉⵇⵇⴻⴷ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⵜ ⵉⴽⴻⵙⵙⵉ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS43_1","024_43_1","ISA","43","1","1","“ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴽⴻⵡⵡⴰⵏ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴼⴻⴽⴽⴻⵖ ⵛⴻⴽ, ⵍⴰⵖⵉⵖ ⴰⵛ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵛⴻⴽ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS43_2","024_43_2","ISA","43","2","2","ⵎⴰⵍⴰ ⵜⵛⵓⵇⴻⴷ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵉⵍⵉⵖ ⴰⴽⵉⴷⴻⴽ, ⵎⴰⵍⴰ ⴷⴻⴳ ⵉⵖⴻⵣⵔⴰⵏ, ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⵉⵡⵢⴻⵏ. ⵎⴰⵍⴰ ⵜⴻⵥⵡⵉⴷ ⵅ ⵜⵎⴻⵙⵙⵉ, ⵡⴰⵔ ⵜⵛⴻⵎⵎⴹⴻⴷ, ⵓⵛⴰ ⴰⵛⴻⵄⵄⴰⵍ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵔⵓⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("IS43_3","024_43_3","ISA","43","3","3","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵎⵉⵚⵔⴰ ⴷ ⴷⴷⴻⵢⵢⴻⵜ ⵉ ⵛⴻⴽ, ⴽⵓⵛ ⴷ ⵙⴻⴱⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS43_4","024_43_4","ISA","43","4","4","ⵎⵉⵏⵣⵉ ⵜⵙⴻⴽⴽⵡⵉⴷ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⴷ ⵓ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⴽ. ⵡⵛⵉⵖ ⵉⵡⴷⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS43_5","024_43_5","ISA","43","5","5","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ. ⴰⴷ ⴰⵡⵢⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵣⵉ ⵎⴰⵏⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⴰⴷ ⵛⴻⴽ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵎⴰⵏⵉ ⴷⴷ-ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("IS43_6","024_43_6","ISA","43","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵛⵛⴰⵎⴰⵍ: ‘ⴻⵡⵛ!’ ⵓ ⵉ ⵍⵊⴰⵏⵓⴱ: ‘ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⴼ!’, ⴰⵔⴻⴽⴽⵯⴻⵃ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵢⴻⵙⵙⵉ ⵣⵉ ⵜⵎⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("IS43_7","024_43_7","ISA","43","7","7","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ ⵉ ⵛⵛⴰⵏ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⴽⴻⵡⵡⵏⴻⵖ ⴷ ⵡⴻⵏⵏⵉ ⴳⴳⵉⵖ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("IS43_8","024_43_8","ISA","43","8","8","“ⴻⵊⵊ ⴰⴷ ⵉⴼⴼⴻⵖ ⵍⴳⴻⵏⵙ ⴰⴷⴰⵔⵖⴰⵍ, ⵡⴰⵅⵅⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵓⵍⴰ ⴷ ⵉⴷⵓⵀⵛⴰⵔⴻⵏ, ⵡⴰⵅⵅⴰ ⵖⴰⵔⵙⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS43_9","024_43_9","ISA","43","9","9","ⴻⵊⵊ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴻⵊⵊ ⵛⵛⵓⵄⵓⴱ ⴰⴷ ⵏⵏⵊⴰⵔⵡⴻⵏ! ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵜⴰ, ⴷ ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵏⴻⵖ ⵢⵉⵏⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵣⵉⵛ? ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵍⴻⵛⵀⵓⴷ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ, ⵓⵛⴰ ⴻⵊⵊ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵙⵍⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴷ ⵜⵉⴷⴻⵜⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS43_10","024_43_10","ISA","43","10","10","ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⴷ ⴷⴰⵢⵉ ⵜⴰⵎⵏⴻⵎ, ⴰⴷ ⵜⴼⴻⵀⵎⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ ⵏⴻⵛⵛ. ⵇⴱⴻⵍ ⵏⴻⵛⵛ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ!, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS43_11","024_43_11","ISA","43","11","11","ⵏⴻⵛⵛ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵓⵎⵙⴻⵏⵊⴻⵎ ⵎⵖⵉⵔ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("IS43_12","024_43_12","ISA","43","12","12","ⵏⴻⵛⵛ ⴱⴰⵔⵔⵃⴻⵖ ⵓ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓ ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵓⵎⴻⵊⵊⵓⵏ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⵊⴰⵔ ⴰⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS43_13","024_43_13","ISA","43","13","13","ⵓⵍⴰ ⵣⴻⴳ ⵡⴰⵙⵙ-ⴰ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵏⴻⵛⵛ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ! ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵅⴻⴷⵎⴻⵖ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⵏⵏⴻⵇⵍⴻⴱ?” ");
INSERT INTO rift_vpl VALUES ("IS43_14","024_43_14","ISA","43","14","14","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⴻⴼⴷⵉ ⵏⵡⴻⵎ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵀⵡⴰⵏ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵉⵖⵓⵔⵔⴰⴱⴰ ⵏⵏⵉ ⵣⵉ ⵜⵓⵖⴰ ⴼⴰⵔⵔⵃⴻⵏ ⴰⵎⵎⵓ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("IS43_15","024_43_15","ISA","43","15","15","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("IS43_16","024_43_16","ISA","43","16","16","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⴱⵔⵉⴷ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⴷ ⵜⴻⴱⵔⵉⴷⵜ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS43_17","024_43_17","ISA","43","17","17","ⵡⴻⵏⵏⵉ ⵉⵊⵊⵉⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵢⴻⵢⵙⴰⵏ, ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵊⵊⴻⵀⴷ ⴰⴷ ⴼⴼⵖⴻⵏ - ⴰⵇⴰ ⴷⴰ, ⵣⵣⵍⴻⵏ ⵎⵓⵏⴻⵏ, ⵡⴰⵔ ⵜⵜⵏⴻⴽⴽⴰⵔⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ, ⵅⴻⵙⵢⴻⵏ, ⵇⴹⴰⵏ ⴰⵎ ⵜⴻⴼⵜⵉⵍⵜ ⵏ ⵜⵉⴼⴼⴻⵙⵜ! - ");
INSERT INTO rift_vpl VALUES ("IS43_18","024_43_18","ISA","43","18","18","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵜⵜⵄⴻⵇⵉⵍⴻⵎ ⵄⴰⴷ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵣⵉⵛ, ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔⴻⵎ ⵄⴰⴷ ⵎⵉⵏ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("IS43_19","024_43_19","ISA","43","19","19","ⵅⵣⴰⵔ, ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵊⴷⵉⴷ, ⵍⴻⵅⵅⵓ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ. ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵃⴻⴽⴽⴰⵔⴻⵎ ⵛⴰ? ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴰⴱⵔⵉⴷ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⵖⵣⴰⵔⴻⵏ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("IS43_20","024_43_20","ISA","43","20","20","ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⴰⴷ ⴰⵢⵉ ⵙⵙⵄⵓⴵⴰⵏ, ⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵏⵏⵄⴰⵎⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵎⴰⵏ ⴰⴷ ⴰⵣⵣⵍⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵍⴰ ⴷ ⵉⵖⴻⵣⵔⴰⵏ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵙⵡⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS43_21","024_43_21","ISA","43","21","21","ⵍⴳⴻⵏⵙ-ⴰ ⴳⴳⵉⵖ ⵜ ⵉ ⵏⴻⵛⵛ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵛⵛⴰⵏ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("IS43_22","024_43_22","ISA","43","22","22","“ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⵍⴰⵖⵉⴷ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⵡⴰⵔ ⵜⴻⵙⵙⵉⵃⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴽⵉⴷⵉ, ⴰ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("IS43_23","024_43_23","ISA","43","23","23","ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⵉⵡⵢⴻⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵓⵛⴰ ⵙ ⵜⵖⴰⵔⵚⵉ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵛⴻⵏⵏⵄⴻⴷ. ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵛⴻⴽ ⵃⵚⴰⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵙⵙⵉⵃⵍⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵙ ⵊⵊⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("IS43_24","024_43_24","ISA","43","24","24","ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵖⵉⴷ ⴰⵖⴰⵏⵉⵎ ⵏ ⵓⵃⴻⵎⵎⵓⵎ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵙ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵊⵉⵡⵏⴻⴷ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵙ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵜⴰⵔⵏⵉⴷ ⴰⵢⵉ-ⴷⴷ ⵍⵅⴻⴷⵎⴻⵜ, ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵏⴻⵛ ⵜⴻⵙⵙⵉⵃⵍⴻⴷ ⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS43_25","024_43_25","ISA","43","25","25","“ⵏⴻⵛⵛ, ⴷ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⴻⵙⵃⴻⵏ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵛ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵄⴰⴷ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("IS43_26","024_43_26","ISA","43","26","26","“ⴰⵔⵔ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵍⴱⴰⵍ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵎⵛⴰⵔⵔⴻⵄ, ⵡⵡⴻⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS43_27","024_43_27","ISA","43","27","27","ⴱⴰⴱⴰⵛ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵅⴹⴰ ⵓ ⵓⵍⴰ ⴷ ⵉⵎⵙⴻⵚⵍⴰⵃⴻⵏ ⵏⵏⴻⵛ ⵄⴷⵓⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("IS43_28","024_43_28","ISA","43","28","28","ⵅⴻⵏⵏⵉ ⵙⵙⵄⵉⴵⵜⴻⵖ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓ ⴰⵔⵔⵉⵖ ⵢⴰⵄⵇⵓⴱ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⴻⵎ ⵉ ⵓⵜⴻⵃⵃⵉ ⵓⵛⴰ ⵊⵊⵉⵖ ⵉⵙⵔⴰⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵄⴻⵢⵢⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS44_1","024_44_1","ISA","44","1","1","“ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ, ⵙⴻⵍ, ⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("IS44_2","024_44_2","ISA","44","2","2","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ: ‘ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵢⴰⵛⵓⵔⵓⵏ ⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("IS44_3","024_44_3","ISA","44","3","3","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⴻⵢⵢⵃⴻⵖ ⴰⵎⴰⵏ ⵅ ⵎⵉⵏ ⵉⴼⴼⵓⴷⴻⵏ ⴷ ⵜⵙⴻⴵⵢⴰⵡⵉⵏ ⵅ ⵎⵉⵏ ⵢⵓⵥⵖⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴵⵄⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵅ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵉⵏⵓ ⵅ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS44_4","024_44_4","ISA","44","4","4","ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴻⵎⵢⴻⵏ ⵊⴰⵔ ⴰⵔⴱⵉⵄ, ⴰⵎ ⵢⵉⵚⴻⴼⵚⴰⴼⴻⵏ ⵖⴰⵔ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS44_5","024_44_5","ISA","44","5","5","ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⵏ ⵙⵉⴷⵉ!’ ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵓ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵢⴰⵔⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ: ‘ⵏⴻⵛⵛ ⵏ ⵙⵉⴷⵉ!’ ⵓⵛⴰ ⴰⴷ ⵉⴽⴻⵏⵏⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵢⵉⵙⴻⵎ ⵉⵛⴻⵏⵏⵄⴻⵏ ‘ⵉⵙⵔⴰⵉⵍ’.’” ");
INSERT INTO rift_vpl VALUES ("IS44_6","024_44_6","ISA","44","6","6","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷ ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵙ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵏⴻⵛⵛ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ, ⵏⵀⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS44_7","024_44_7","ISA","44","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⴰⵎ ⵏⴻⵛⵛ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵜ ⵢⵉⵏⵉ ⵓ ⴰⴷ ⴰⵢⵉ ⵜ ⵉⵙⵙⵛⴻⵏ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵥⵥⵓⵖ ⵍⴳⴻⵏⵙ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵄⴰⵡⴷⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵜⵉⵡⴻⵛⵛⴰ, ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS44_8","024_44_8","ISA","44","8","8","ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ. ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵉⵡⴹⴻⵖ ⵣⴻⴳ ⵡⴰⴽⵓⴷ ⵏ ⵣⵉⵛ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ ⵓ ⵎⴰ ⵡⴰⵔ ⵃⴰⵊⵉⵖ ⵜ? ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ ⵉⵏⵓ: ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵀⵍⴰ ⵏⴻⵛⵛ? ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS44_9","024_44_9","ISA","44","9","9","“ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵉⵅⵡⴰⵏ, ⵓ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⵉ ⵜⵜⴻⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵏⴻⴼⴼⵄⴻⵏⵜ ⴷⴻⴳ ⵡⴰⵍⵓ. ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵍⴻⵛⵀⵓⴷ ⵏⵙⴻⵏⵜ ⴰⵇⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏⵜ ⵓ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏⵜ ⵡⴰⵍⵓ, ⴰⵍⴰⵎⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS44_10","024_44_10","ISA","44","10","10","ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⴽⴻⴱⴱⴰⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴰⵎ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⵉⵣⵉ ⵣⵣⴰⵢⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("IS44_11","024_44_11","ISA","44","11","11","ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵉⵛⵔⵉⵛⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ ⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ ⴷ ⵉⵡⴷⴰⵏ ⵡⴰⵀⴰ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵎⵓⵏⴻⵏ, ⴰⴷ ⴽⴽⴰⵔⴻⵏ, ⴰⴷ ⵏⵏⵅⴻⵍⵄⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS44_12","024_44_12","ISA","44","12","12","ⴰⵎⵣⵉⵍ ⵏ ⵡⵓⵣⵣⴰⵍ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵢⴷⵉ ⵏ ⵡⴻⵎⵣⵉⵍ, ⵉⵅⴻⴷⴷⴻⵎ ⵖⴰⵔ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⵉⵜⵜⵇⴰⵔⵔⴻⵙ ⵍⴻⵅⵢⴰⵍ ⵙ ⵉⴼⴹⵉⵙⴻⵏ ⵏⵏⴻⵙ. ⵉⵅⴻⴷⴷⴻⵎ ⵉ-ⵜ ⵙ ⵓⵖⵉⵍ ⵉⵊⴻⵀⴷⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⴵⵓⵥ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⴱⵓ ⵊⵊⵀⴻⴷ ⵄⴰⴷ. ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⴰⵎⴰⵏ ⴰⵍ ⵖⴰ ⵢⴰⵃⴻⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS44_13","024_44_13","ISA","44","13","13","ⴰⵏⴻⵊⵊⴰⵔ ⵉⵄⴻⴱⴱⴰⵔ ⵜⴰⴼⵔⴻⵡⵜ ⵙ ⵓⴼⵉⵍⵓ ⵏⵏⴻⵙ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵢⴰⵔⴻⵛⵛⴻⵎ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵙ ⵓⴽⴻⵔⵔⴰⵊ, ⵓ ⵉⵏⴻⵊⵊⴰⵔ ⵉ-ⵜ ⵙ ⵍⵎⵓⵙ ⵓⵛⴰ ⵢⴰⵔⴻⵛⵛⴻⵎ ⵉ-ⵜ ⵙ ⴷⴷⴻⵡⴰⵔⴰ ⵓ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS44_14","024_44_14","ISA","44","14","14","ⵉⵣⴻⴷⴷⴻⵎ ⴱⵏⴰⴷⴻⵎ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⴽⴻⵙⵙⵉ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵙⵙⵉⴷⵔⵉ ⵏⵉⵖ ⵏ ⵍⴱⴻⴵⵓⴹ, ⵢⴰⵔⴻⵣⵣⵓ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ. ⵉⵜⵜⴻⵥⵥⵓ ⵉⵛⵜ ⵏ ⵜⴰⵢⴷⴰ ⵓⵛⴰ ⵜⵎⴻⵇⵇⴰⵔ ⵙ ⵡⴻⵏⵥⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS44_15","024_44_15","ISA","44","15","15","ⴰⴷ ⵜⵉⵍⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴷ ⵍⴻⴼⵃⴻⵎ ⵉ ⴱⵏⴰⴷⴻⵎ. ⵉⴽⴻⵙⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵉⵥⵖⴰⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ. ⵄⴰⵡⴻⴷ ⵉⵙⵙⵔⴰⵇⵇⴰ ⵜⵉⵎⴻⵙⵙⵉ, ⵉⵙⵙⵏⴻⵏⵏⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵖⵔⵓⵎ. ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉⵜⵜⴻⴳⴳ ⴱⵏⴰⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵜⵜⴱⴻⵏⴷⴰⵇ ⴰⵙ, ⵉⵜⵜⴻⴳⴳ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵛⴰ ⵉⵙⴻⵊⵊⴰⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS44_16","024_44_16","ISA","44","16","16","ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⴻⵛⵎⴰⴹ ⵉ-ⵜ ⵙ ⵜⵎⴻⵙⵙⵉ, ⴰⴽ-ⴷ ⵡⴻⵣⵢⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉⵜⵜⴻⵜⵜ ⴰⵢⵙⵓⵎ. ⵉⵛⴻⵏⵏⴻⴼ ⴰⵢⵙⵓⵎ ⵓⵛⴰ ⵉⵜⵜⵢⴰⵡⴰⵏ. ⵉⵥⵖⴰⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ: ‘ⴰⵀ, ⵎⴰⵎⵎⴻⵛ ⵃⴻⵎⵎⵉⵖ, ⵏⴻⵛⵛ ⵜⵜⴰⵛⵉⵖ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵙⵉ!’ ");
INSERT INTO rift_vpl VALUES ("IS44_17","024_44_17","ISA","44","17","17","ⵣⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵉⵜⵜⴻⴳⴳ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ. ⵉⵙⴻⵊⵊⴰⴷ ⴰⵙ, ⵉⵜⵜⴱⴻⵏⴷⴰⵇ ⵣⵣⴰⵜⴻⵙ, ⵉⵜⵜⵥⴰⴵⴰ ⵖⴰⵔⴻⵙ, ⵉⵇⵇⴰⵔ: ‘ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("IS44_18","024_44_18","ISA","44","18","18","“ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⵡⴰⵔ ⵜⵜⵃⵉⴽⵉⵏ, ⵎⴰⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵎⴻⵙⵃⴻⵏⵜ ⵓⵎⵉ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵡⴰⵍⵓ, ⵓⵛⴰ ⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⵜⴻⴼⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS44_19","024_44_19","ISA","44","19","19","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⵜ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵓⵙⵙⵏⴰ ⵓⵍⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵛⴻⵎⴹⴻⵖ ⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ⵙⵙⵏⴻⵏⵏⴻⵖ ⴰⵖⵔⵓⵎ ⵅ ⵍⴻⴼⵃⴻⵎ ⵏⵏⴻⵙ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵓ ⵛⴻⵏⴼⴻⵖ ⴰⵢⵙⵓⵎ ⵓ ⵛⵛⵉⵖ ⵜ. ⵣⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⴻⵖ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵏ ⵚⵚⴰⵏⴰⵎ, ⵎⴰ ⴰⴷ ⵙⴻⵊⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ?’ ");
INSERT INTO rift_vpl VALUES ("IS44_20","024_44_20","ISA","44","20","20","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵛⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵖⵖⴻⴹ, ⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵖⴰⵔⵔⴻⵏ ⵉⵖⴻⴽⴽⵡⴰ ⵉ-ⵜ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⵖⴻⵛⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵉⵏⵓ?’” ");
INSERT INTO rift_vpl VALUES ("IS44_21","024_44_21","ISA","44","21","21","“ⵄⵇⴻⵍ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⴰ ⵛⴻⴽ ⵉⵙⵔⴰⵉⵍ! ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴽⴻⵡⵡⵏⴻⵖ ⵛⴻⴽ, ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵛⴻⴽ ⵜⵜᵉⵜⵜⵓⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS44_22","024_44_22","ISA","44","22","22","ⵏⴻⵛⵛ ⵎⴻⵙⵙⵃⴻⵖ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵛ ⴰⵎ ⵜⴰⵢⵢⵓⵜ ⵓⵍⴰ ⴷ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⴰⵎ ⵓⵙⴻⵢⵏⵓ. ⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴼⴻⴽⴽⴻⵖ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("IS44_23","024_44_23","ISA","44","23","23","“ⵖⴻⵏⵏⵊⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜ. ⵙⵍⵉⵡⵍⴻⵡⴻⵜ, ⴰ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴽⵙⵉⵎ ⴷⴻⴳ ⵉⵖⵓⵢⵢⴰⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰ ⵉⴷⵓⵔⴰⵔ, ⵙⵍⵉⵡⵍⵉⵡⴻⵎ, ⴰ ⵛⴻⴽ, ⴰⵣⵖⴰⵔ ⴷ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ! ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴼⴻⴽⴽ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⵙⵄⵓⴵⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS44_24","024_44_24","ISA","44","24","24","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵛ: ‘ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⴰⵊⴻⵏⵏⴰ, ⵏⴻⵛⵛ ⵡⴰⵀⴰ, ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵙⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ⵎⴰⵏ ⵡⴻⵏ ⵜⵓⵖⴰ ⵅⴻⵏⵏⵉ ⴰⴽⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("IS44_25","024_44_25","ISA","44","25","25","ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⵙⵙⴱⵓⵀⵍⵉⵖ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵓ ⵢⴰⵔⵔⴰ ⵜⵓⵙⵙⵏⴰ ⵏⵙⴻⵏ ⴷ ⵜⴰⵖⵢⵓⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("IS44_26","024_44_26","ISA","44","26","26","ⵡⴻⵏⵏⵉ ⵉⵙⵙⵎⴻⵜⵏⴻⵏ ⴰⵡⴰⵍ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵓ ⵉⵙⵙⴻⵇⴼⴻⵍ ⵛⵛⵡⴰⵔ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⴰⴷ ⴷⴰⵢⴻⵎ ⵉⵍⵉⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵄⴰⴷ!’ ⵓⵛⴰ ⵉ ⴽⵓⵍ ⵉⵛⵜ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ: ‘ⵛⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⴷ ⵄⴰⵡⴻⴷ!’ ⵓⵛⴰ ‘ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵅⵉⵔⴱⴰⵜ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ!’, ");
INSERT INTO rift_vpl VALUES ("IS44_27","024_44_27","ISA","44","27","27","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵡⴰⵎⴰⵏ ⵢⵓⴵⵖⴻⵏ: ‘ⴰⵥⵖⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵥⵖⴻⵖ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵡⴻⵎ!’, ");
INSERT INTO rift_vpl VALUES ("IS44_28","024_44_28","ISA","44","28","28","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⴽⵓⵔⴰⵛ: ‘ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵉⵏⵓ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵇⴼⴻⵍ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ, ⵓⵎⵉ ⵖⴰ ⵉⵏⵉⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⴰⴷ ⵛⴻⵎ ⵄⴻⴷⵍⴻⵏ!’, ⵓ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ: ‘ⴰⴷ ⴰⵎ ⴳⴳⴻⵏ ⴷⵙⴰⵙ!’” ");
INSERT INTO rift_vpl VALUES ("IS45_1","024_45_1","ISA","45","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵙ, ⵉ ⴽⵓⵔⴰⵛ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵟⵟⴼⴻⵖ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵙⵙⴰⴹⴰⵔⴻⵖ ⵍⴻⴳⵏⵓⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ: ‘ⴰⴷ ⵙⵙⴰⵔⵅⵓⵖ ⵜⵉⵃⴻⵣⵣⴰⵎⵉⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⴰⵔⵣⵎⴻⵖ ⵜⵉⵡⵡⵓⵔⴰ, ⵓ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵡⴰⵔ ⵜⵜⵡⴰⴱⴻⵍⵍⵉⵄⴻⵏⵜ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS45_2","024_45_2","ISA","45","2","2","ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵣⵡⴰⵔⴻⵖ, ⴰⴷ ⵡⴰⵟⵉⵖ ⵎⵉⵏ ⵡⴰⵔ ⵉⵀⴻⵡⵏⴻⵏ, ⴰⴷ ⴰⵔⵥⴻⵖ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵏⵏⵃⴰⵙ ⵓ ⴰⴷ ⵡⵜⵉⵖ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS45_3","024_45_3","ISA","45","3","3","ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵍⴻⴽⵏⵓⵣ ⵏ ⵜⴰⴵⴻⵙⵜ, ⴰⴳⵍⴰ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS45_4","024_45_4","ISA","45","4","4","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⵔⴰⵉⵍ ⵡⴻⵏⵏⵉ ⴼⴰⵔⵣⴻⵖ, ⵍⴰⵖⵉⵖ ⴰⵛ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵡⵛⵉⵖ ⴰⵛ ⵉⵙⴻⵎ ⵏ ⵛⵛⴰⵏ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS45_5","024_45_5","ISA","45","5","5","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵏⵀⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⴻⴱⴱⵉ. ⴰⴷ ⴰⵛ ⵃⴻⵣⵣⵎⴻⵖ ⴰⴱⵢⴰⵙ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("IS45_6","024_45_6","ISA","45","6","6","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵏ ⵣⵉ ⵎⴰⵏⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⵍ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ, ⴰⵇⴰ ⵏⵀⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS45_7","024_45_7","ISA","45","7","7","ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⴻⵖ ⵜⴰⴼⴰⵡⵜ ⵓ ⵅⴻⴵⵇⴻⵖ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ, ⵜⵜⴻⴳⴳⴻⵖ ⵍⴻⵀⵏⴰ ⵓ ⵅⴻⴵⵇⴻⵖ-ⴷⴷ ⵍⵖⴰⵔ, ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("IS45_8","024_45_8","ISA","45","8","8","“ⵓⴷⵓⵎⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵊⴻⵏⵡⴰⵏ, ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⵊⵊⴻⵎ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴼⴰⵔⵔⵖⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⴰⴷ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵍⵖⵉⴵⴻⵜ ⵓ ⴻⵊⵊ ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵜⴻⵖⵎⵉ ⵊⵎⵉⵄ ⴰⴽⵉⴷⴻⵙ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵅⴻⵍⵇⴻⵖ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS45_9","024_45_9","ISA","45","9","9","“ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⵉⵊⵊ ⵏ ⵓⵇⴻⴷⴷⵓⵃ ⵊⴰⵔ ⵉⵇⴻⴷⴷⵓⵃⴻⵏ ⵏⵏⴻⵖⵏⵉ? ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔ ⵜⵍⴰⵅⵜ ⴰⴷ ⵜⵉⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ: ‘ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ?’ ⵏⵉⵖ ⵜⵣⴻⵎⵎⴰⵔ ⵍⵇⴻⵛⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵏⵉ: ‘ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵉⴼⴰⵙⵙⴻⵏ’? ");
INSERT INTO rift_vpl VALUES ("IS45_10","024_45_10","ISA","45","10","10","ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⴱⴰⴱⴰⵙ: ‘ⵎⵉⵏ ⴷⴷ-ⵜⴻⵊⵊⵉⴷ?’ ⵏⵉⵖ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: ‘ⵎⵉⵏ ⴷⴷ-ⵜⵓⵔⵓⴷ?’” ");
INSERT INTO rift_vpl VALUES ("IS45_11","024_45_11","ISA","45","11","11","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ: ‘ⵙⴻⵇⵙⴰⵎ ⴰⵢⵉ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴷⴷ ⵉⵜⵜⴰⵙⴻⵏ, ⵜⵜⴻⵛⵍⴻⵎ ⵅⴰⴼⵉ ⴰⴷ ⵃⴹⵉⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS45_12","024_45_12","ISA","45","12","12","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⵅⴻⵍⵇⴻⵖ-ⴷⴷ ⵅⴰⵙ ⴱⵏⴰⴷⴻⵎ. ⵡⴰⵀ ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵜ ⵢⴻⴳⴳⵉⵏ, ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵙⴻⵏ ⵜⵜⵓⵎⵓⵔⴻⵖ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS45_13","024_45_13","ISA","45","13","13","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵜ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⴰⴷ ⵙⴻⴳⴳⵎⴻⵖ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⵏⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵏⵓ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵏⵓⴼⵙⴻⵍ ⵉⵎⴻⵃⴱⴰⵙ ⵉⵏⵓ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵜⵜⴰⵎⴰⵏ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵜⴰⵔⵣⴻⴼⵜ!’ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.”    ");
INSERT INTO rift_vpl VALUES ("IS45_14","024_45_14","ISA","45","14","14","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵔⴱⴻⵔ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⴷ ⵚⵚⴻⵍⵄⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⵓⵛ ⴷ ⵙⴰⴱⴰ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⴷⵉ ⵜⵉⴷⴷⵉ, ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵥⵡⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⵏⵏⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⵎ ⴹⴼⴰⵔⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⵎ ⵄⴷⵓⵏ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ, ⴰⴷ ⴰⵎ ⵙⴻⵊⴷⴻⵏ, ⴰⴷ ⴰⵎ ⵙⴻⵍⵍⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴷ ⵏⴻⵄⵎⴻⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵖⴰⵔⴻⵎ ⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ ⵎⵖⵉⵔ ⴰⵔⴻⴱⴱⵉ!’ ");
INSERT INTO rift_vpl VALUES ("IS45_15","024_45_15","ISA","45","15","15","ⴷ ⵜⵉⴷⴻⵜⵜ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS45_16","024_45_16","ISA","45","16","16","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⴰⴷ ⵜⵜⵡⴰⴼⴻⴹⵃⴻⵏ ⵄⴰⵡⴻⴷ. ⵉⵎⵣⵉⵍⴻⵏ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴰⴷ ⴼⴼⵖⴻⵏ ⵊⵎⵉⵄ, ⵏⵏⴼⴻⴹⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS45_17","024_45_17","ISA","45","17","17","ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵜⵜⴷⵓⵎⴰⵏ. ⵡⴰⵔ ⵜᵉⵜⵜⵙⴻⴹⵃⵉⵎ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵏⴻⴼⴹⵉⵃⴻⵎ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ.’” ");
INSERT INTO rift_vpl VALUES ("IS45_18","024_45_18","ISA","45","18","18","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵏⴻⵜⵜⴰ, ⴰⵔⴻⴱⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴽⴻⵡⵡⵏⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⵜ, ⵏⴻⵜⵜⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵙⵙⵎⴻⵜⵏⴻⵏ. ⵡⴰⵔ ⵜⵜ-ⵉ-ⴷⴷ-ⵉⵅⵍⵉⵇ ⵜⴻⵅⵡⴰ, ⵎⴰⵛⴰ ⵉⴽⴻⵡⵡⴻⵏ ⵉ-ⵜⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵣⴻⴷⴷⵖⴻⵏ: ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ!” ");
INSERT INTO rift_vpl VALUES ("IS45_19","024_45_19","ISA","45","19","19","“ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⴷⵉ ⵛⴰ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⴱⴰⵔⵔⴻⵛⵏⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵏⵏⵉⵖ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵄⵇⵓⴱ: ⴰⵔⵣⵓⵎ ⴰⵢⵉ ⴱⴰⵟⴻⵍ! ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS45_20","024_45_20","ISA","45","20","20","“ⵎⵓⵏⴻⵎ, ⴰⵙⴻⵎ-ⴷⴷ, ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⵎⵓⵏⴻⵏ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ! ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵡⴰⵍⵓ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓⵛⴰ ⵜⵜⵄⴻⴱⴱⴷⴻⵏ ⵉ ⵢⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS45_21","024_45_21","ISA","45","21","21","ⴱⴰⵔⵔⵃⴻⵎ, ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ. ⵎⵛⴰⵡⴰⵔⴻⵎ ⴷⵉ ⵡⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ: ⵎⴰⵏ ⵡⴻⵏ ⵉⴳⴳⵉⵏ ⴰⴷ ⵙⵍⴻⵏ ⴰⵢⴰ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵣⵉ ⵎⴻⵍⵎⵉ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ? ⵏⵀⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ, ⵏⵀⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷ ⵓⵎⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS45_22","024_45_22","ISA","45","22","22","ⵇⴻⵍⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵓ ⵜⴻⵊⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏ ⵟⵟⵔⵓⴼⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS45_23","024_45_23","ISA","45","23","23","ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵖⴰⵔ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⴰⵡⴰⵍ-ⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵡⴻⴷⵡⴰⵍ: ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⴰⴼⵓⴷ ⴰⴷ ⵢⴰⴹⴰⵔ ⵣⵣⴰⵜⵉ, ⵎⴰⵔⵔⴰ ⵉⵍⴻⵙ ⴰⴷ ⵖⴰⵔⵉ ⵉⵊⵊⴰⴵ! ");
INSERT INTO rift_vpl VALUES ("IS45_24","024_45_24","ISA","45","24","24","ⴰⴷ ⵅⴰⴼⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⴷⵉ ⵙⵉⴷⵉ ⵡⴰⵀⴰ ⵜⴻⴵⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵉⴼⴻⵢⵢⴹⴻⵏ ⴷ ⵊⵊⴻⵀⴷ!’ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⴼⵓⴳⵎⴻⵏ, ⴰⴷ ⵙⴻⴹⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS45_25","024_45_25","ISA","45","25","25","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⵛⴻⵏⵏⵄⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS46_1","024_46_1","ISA","46","1","1","“ⵚⵚⴰⵏⴰⵎ ⴱⵉⵍ ⵢⵓⴹⴰⵔ, ⵏⴰⴱⵓ ⵉⵇⵡⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⴷⴻⵇⵇⵍⴻⵏⵜ ⵉ ⵍⵎⴰⵍ ⵓ ⵉ ⵍⴻⴱⵀⴰⵢⴻⵎ. ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴰⵔⴻⴱⴱⵓⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⴷ ⵍⴻⵃⵎⵓⵍ, ⴷⴷⵇⴻⵍ ⵉ ⵍⵎⴰⵍ ⵉⴼⵏⴰⵏ ⵙ ⵍⵡⴻⵃⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS46_2","024_46_2","ISA","46","2","2","ⴰⵇⴰ ⵇⴻⵡⵙⴻⵏ ⴰⵎ ⴽⴻⵎⵎⵍⴻⵏ, ⵓⴹⴰⵔⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵏ ⴷⴷⵇⴻⵍ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS46_3","024_46_3","ISA","46","3","3","“ⵙⵍⴻⵎ ⵖⴰⵔⵉ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⴽⵙⵉⵖ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ, ⵉⵏⵏⵉ ⴰⵔⴱⵓⵔⴻⵖ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵙⴻⵎⵃⴻⵎ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS46_4","024_46_4","ISA","46","4","4","ⴰⵍ ⵜⴰⵡⵙⴰⵔⵜ ⵏⵡⴻⵎ ⵏⴻⵛⵛ ⵏⴻⵛⵛ, ⴰⵍ ⵖⴰ ⵜⵛⴰⴱⴻⵎ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴱⵓⵖ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴽⵙⵉⵖ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴱⵓⵖ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS46_5","024_46_5","ISA","46","5","5","“ⴰⴽ-ⴷ ⵎⴰⵏ ⵡⴻⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵎⵇⵓⴷⴷⴰⵎ, ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴽⵉⴷⵉ ⵜᵉⵙⵙⴻⴽⴽⵡⵉⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵎⵔⴰⵡⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("IS46_6","024_46_6","ISA","46","6","6","ⵜⵜⴼⴰⵔⵔⴰⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵔⴻⵖ ⵣⵉ ⵜⴻⵛⵢⴰⵔⵜ ⵓ ⵡⴻⵣⵣⵏⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵅ ⵍⵎⵉⵣⴰⵏ. ⵜⵜⵅⴻⴵⵚⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵙⴻⵊⵊⴰⴷⴻⵏ, ⵡⴰⵀ, ⴱⴻⵏⴷⵇⴻⵏ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS46_7","024_46_7","ISA","46","7","7","ⴰⵔⴻⴱⴱⵓⵏ ⵜ ⵅ ⵜⴻⵖⵔⵓⴹⵜ, ⴽⴻⵙⵙⵉⵏ ⵜ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⵅⴻⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴰⵏ ⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⴷⵉⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰ ⵉⴱⴻⴷⴷ, ⵡⴰⵔ ⵉⵜⵜⴻⵏⵀⵉⵣⵣⵉ ⵙⵙⴻⵏⵏⵉ. ⵡⴰⵀ, ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵍⴰⵖⴰ ⴰⵙ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ, ⵡⴰⵔ ⵜ ⵉⵙⵙⴻⵏⵊⴰⵎ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS46_8","024_46_8","ISA","46","8","8","“ⵄⴻⵇⵍⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵍⴱⴰⵍ ⵏⵡⴻⵎ, ⴽⵙⵉⵎ ⵜ ⵖⴰⵔ ⵡⵓⵍ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("IS46_9","024_46_9","ISA","46","9","9","ⵄⴻⵇⵍⴻⵎ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ: ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ: ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵏⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("IS46_10","024_46_10","ISA","46","10","10","ⵡⴻⵏⵏⵉ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⵓⵍⴰ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵎⵙⴰⵔⴻⵏ ⵄⴰⴷ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⴰⵅⴰⵔⵔⴻⵚ ⵉⵏⵓ ⵢⴰⵔⵛⴻⵎ, ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵔⴹⴰ ⵉⵏⵓ!’, ");
INSERT INTO rift_vpl VALUES ("IS46_11","024_46_11","ISA","46","11","11","ⵡⴻⵏⵏⵉ ⵉⵍⴰⵖⴰⵏ ⴰⵊⴹⵉⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵣⵉ ⵛⵛⴰⵔⵇ, ⴰⵔⵢⴰⵣ ⵏ ⵓⵅⴰⵔⵔⴻⵚ ⵏⵏⴻⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴳⴳⵯⴻⵊⴻⵏ. ⵡⴰⵀ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⵉⵡⵍⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵜⵜ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵏⴻⵛⵛ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵜⵜ, ⴰⴷ ⵜⵜ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS46_12","024_46_12","ISA","46","12","12","“ⵙⵍⴻⵎ ⵖⴰⵔⵉ, ⴽⴻⵏⵏⵉⵡ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ, ⵉⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⵙⴻⴳⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("IS46_13","024_46_13","ISA","46","13","13","ⴰⴷ ⴷⴷ-ⵙⵙⵇⴰⵔⵔⴱⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ, ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵯⵉⵊ, ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⵉⵍ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ⴰⴷ ⴰⵡⵢⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵡⵛⴻⵖ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⵉ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS47_1","024_47_1","ISA","47","1","1","“ⵀⵡⴰ, ⵇⵇⵉⵎ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⴰ ⵛⴻⵎ, ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⵉⵍ! ⵇⵇⵉⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ! ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵎ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ‘ⵜⴰⵎⵓⴷⵔⵓⵙⵜ’ ⵏⵉⵖ ‘ⵍⵍⵉⴼ’. ");
INSERT INTO rift_vpl VALUES ("IS47_2","024_47_2","ISA","47","2","2","ⴽⵙⵉ ⵜⴰⵙⵉⵔⵜ ⵓⵛⴰ ⵃⵔⵉⵢ ⴰⵡⵔⴻⵏ! ⴽⴽⴻⵙ ⴰⵍⴻⵃⵃⴰⴼ ⵏⵏⴻⵎ, ⵙⴳⴻⵄⵄⴻⴷ ⴰⴱⴻⵃⵔⵓⵔ ⵏⵏⴻⵎ, ⵄⴰⵔⵔⴰ ⵉⴼⴰⴷⴷⴻⵏ ⵓⵛⴰ ⵜⵛⵓⵇⴻⴷ ⴷⴻⴳ ⵉⵖⴻⵣⵔⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("IS47_3","024_47_3","ISA","47","3","3","ⵍⴻⵃⵢⴰ ⵏⵏⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵥⴰⵔ ⵄⴰⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ. ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵓ ⵡⴰⵔ ⵙⵙⵄⵉⵣⵣⵉⵖ ⵅ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS47_4","024_47_4","ISA","47","4","4","ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵖ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS47_5","024_47_5","ISA","47","5","5","“ⵇⵇⵉⵎ ⴷⵉⵏ ⵓⵛⴰ ⵙⵙⴻⵖⴷ, ⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵎ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ‘ⵍⵍⴰⵍⴰⵙ ⵏ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ’. ");
INSERT INTO rift_vpl VALUES ("IS47_6","024_47_6","ISA","47","6","6","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵙⵙⵄⵉⴵⵜⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ, ⵎⴰⵛⴰ ⵛⴻⵎ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ. ⵄⴰⴷ ⵉ ⵓⵡⴻⵙⵙⴰⵔ ⵜⴻⵇⵇⵏⴻⴷ ⴰⵙ ⵜⴰⵖⵏⴰⵛⵜ ⵜⴻⴷⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("IS47_7","024_47_7","ISA","47","7","7","ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⵍⵍⴰⵍⴰⵙ ⵏ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ ⵉ ⵍⴻⴱⴷⴰ!’, ⵎⵉⵏⵜⵔⴰ ⵡⴰⵔ ⵜⴻⴽⵙⵉⴷ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵡⵓⵍ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵉⴷⴰⵔⴻⴷ ⵇⴻⵟⵟⵓ ⵏ ⵓⵢⴰ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS47_8","024_47_8","ISA","47","8","8","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⵍ ⵉ ⵓⵢⴰ, ⴰ ⵛⴻⵎ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⴻⵥⵔⵉ, ⵜⴻⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: ‘ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏⵏⴻⵖⵏⵉⵜ! ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴷⴰ ⵇⵇⵉⵎⴻⵖ ⴷ ⵜⴰⵊⵊⴰⵍⵜ, ⵏⵀⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("IS47_9","024_47_9","ISA","47","9","9","ⵎⴰⵛⴰ ⵜⵏⴰⵢⴻⵏ-ⴰ ⴰⴷ ⵅⴰⵎ ⵡⴹⴰⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ, ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ: ⵏⵀⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⴰⴷ ⵜⵉⵍⵉⴷ! ⵜⵏⴰⵢⴻⵏ-ⴰ ⴰⴷ ⵅⴰⵎ ⵡⴹⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴳⴻⵣⵣⴰⵏⵜ ⵏⵏⴻⵎ ⴷ ⵓⴱⴰⵔⵔⵓ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS47_10","024_47_10","ISA","47","10","10","ⵎⴰⵖⴰⵔ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵎ, ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ!’ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵎ ⴷ ⵜⵓⵙⵙⵏⴰ ⵏⵏⴻⵎ ⴰⵔⵔⵉⵏⵜ ⵛⴻⵎ ⴰⴷ ⵜⴰⵔⵔⴻⴷ ⵙ ⵡⴻⵄⵔⵓⵔ ⵖⴰⵔⵉ. ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵎ ⵜⴻⵏⵏⵉⴷ: ‘ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵏⵏⴻⵖⵏⵉ!’ ");
INSERT INTO rift_vpl VALUES ("IS47_11","024_47_11","ISA","47","11","11","ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⵢⴰⵙ ⵍⵖⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵎⴰⵎⵎⴻⵛ ⴰⴷ ⴷⴷ-ⵉⵏⵇⴰⵔ, ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵇⴱⴻⵍ. ⴰⵡⴻⴷⴷⴰⵔ ⴰⴷ ⵅⴰⵎ ⵉⵡⴹⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵙ ⵜⴻⵙⵙⵃⴻⵢⴷⴻⴷ. ⴷⴻⵖⵢⴰ ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⵜⴰⵙ ⵜⴻⵛⵜⵉ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵅⴰⵙ ⵜⴰⵔⴳⴱⴻⴷ ⵇⴱⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS47_12","024_47_12","ISA","47","12","12","“ⵉⵡⴰ, ⴰⵔⵣⵓ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴱⴻⴷⴷⴻⴷ ⴷⵉⵏ ⴰⴽ-ⴷ ⵜⴳⴻⵣⵣⴰⵏⵜ ⵏⵏⴻⵎ ⵓ ⴰⴽ-ⴷ ⵓⴱⴰⵔⵔⵓ ⵏⵏⴻⵎ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏⵏⵉ ⵣⵉ ⵜⴻⵙⵙⵉⵃⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ. ⴱⴰⵍⴰⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵖⴰⵔⴻⵎ ⵜⵉⵍⵉ ⵜⵉⵣⵉ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵉⵖ ⴱⴰⵍⴰⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⴷⴻⴷ ⵙ ⵓⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("IS47_13","024_47_13","ISA","47","13","13","ⵜⴻⵙⵙⵉⵃⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵎ. ⵉⵡⴰ, ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴼⴻⴽⴽⴰⵏ ⴰⵊⴻⵏⵏⴰ ⵓ ⵃⴻⵟⵟⴰⵏ ⵉⵜⵔⴰⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴽⴰⵛⴰⴼⴻⵏ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵖⴰⵔ ⵓⴱⴻⴷⴷⵉ ⵏ ⵓⵢⵓⵔ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵛⴻⵎ ⵙⵙⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵎⵉⵏ ⵅⴰⵎ ⵖⴰ ⵉⴽⴽⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS47_14","024_47_14","ISA","47","14","14","ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵓⵍⵓⵎ: ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⵜⵎⴻⵙⵙⵉ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵛⴻⵄⵄⴰⵍⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ. ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵣⵖⴰⵍⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵃⴰⴷⵓⵇ ⵏⵏⵉ ⵖⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS47_15","024_47_15","ISA","47","15","15","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵍⵉⵏ ⵉ ⵛⴻⵎ ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⴰⵃⴰⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ, ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⴻⵎ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ. ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵛⴻⵎ ⵉⵙⵙⴻⵏⵊⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS48_1","024_48_1","ISA","48","1","1","“ⵙⵍⴻⵎ ⴰⵢⴰ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵜⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⵊⴰⴵⴰⵏ ⵖⴰⵔ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⵜⵉⴷⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⵓ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS48_2","024_48_2","ISA","48","2","2","ⵏⵉⵜⵏⵉ ⵜⵜⵍⴰⵖⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ‘ⵍⴳⴻⵏⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ!’ ⵓ ⵜⵜⵛⴰⵍⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS48_3","024_48_3","ISA","48","3","3","“ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅⴰⵙⴻⵏⵜ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ, ⴰⵇⴰ ⴼⴼⵖⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵓⵛⴰ ⴱⴰⵔⵔⵃⴻⵖ ⵣⵣⴰⵢⵙⴻⵏⵜ. ⴷⴻⵖⵢⴰ ⴳⴳⵉⵖ ⵜⴻⵏⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("IS48_4","024_48_4","ISA","48","4","4","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵇⴻⵙⵃⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵉⵊⵉⵎⴰⵏ ⵏⵏⴻⵛ ⴰⵎ ⵜⴱⴰⵔⵔⴰⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓ ⵜⴰⵏⵢⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵅⵎⵉ ⴷⴷ-ⵜⴻⴽⴽⴰ ⵣⵉ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("IS48_5","024_48_5","ISA","48","5","5","ⵙⵙⴰⵔⴳⴱⴻⵖ ⴰⵛ ⵜⴻⵏⵜ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ⵇⴱⴻⵍ ⵎⴰ ⵉⵎⵙⴰⵔ, ⴱⴰⵔⵔⵃⴻⵖ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵎⴰⵃⴻⵏⴷ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵚⵚⴰⵏⴰⵎ ⵉⵏⵓ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ!’, ⵏⵉⵖ ‘ⵍⴻⵅⵢⴰⵔⴰⵜ ⵉⵏⵓ ⵉⵏⴻⵇⵛⴻⵏ!’ ⵏⵉⵖ: ‘ⵍⴻⵅⵢⴰⵍ ⵉⵏⵓ ⵉⴼⴻⵙⵢⴻⵏ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS48_6","024_48_6","ISA","48","6","6","ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵅⴰⵙⴻⵏⵜ, ⵅⵣⴰⵔ ⵎⵍⵉⵃ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ⵎⴰ ⵡⴰⵔ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴱⴰⵔⵔⵃⴻⵎ? ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵛ ⴱⴰⵔⵔⵃⴻⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵊⴷⵉⴷ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("IS48_7","024_48_7","ISA","48","7","7","ⵍⴻⵅⵅⵓ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏⵜ-ⴷⴷ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ⵇⴱⴻⵍ ⴰⵙⵙ-ⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⵜⴻⵙⵍⵉⴷ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵅⵣⴰⵔ, ⵙⵙⵏⴻⵖ ⵜⵜ ⵎⴻⵍⵎⵉ!’ ");
INSERT INTO rift_vpl VALUES ("IS48_8","024_48_8","ISA","48","8","8","ⵡⴰⵀ, ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⵜⴻⵙⵍⵉⴷ ⵓ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵓ ⵄⴰⵡⴻⴷ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⵡⴰⵔ ⵢⴰⵔⵣⵉⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵙ ⵍⴻⵖⴷⴰⵔⴻⵜ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵍⴰⵖⴰⵏ ‘ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ!’ ⵄⴰⴷ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("IS48_9","024_48_9","ISA","48","9","9","“ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴰⴷ ⵙⵙⵄⴻⴹⵍⴻⵖ ⴰⵖⴹⴰⴱ ⵉⵏⵓ, ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵛⵛⴰⵏ ⵉⵏⵓ ⴰⴷ ⵜⴻⴱⴱⵜⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵉ ⵍⵅⴰⵔ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵛⴻⴽ ⵎⴻⵃⵃⵉⵖ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("IS48_10","024_48_10","ISA","48","10","10","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⵚⴼⵉⵖ ⵛⴻⴽ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵏⵏⵓⵇⴰⵔⵜ, ⵇⴻⴵⴱⴻⵖ ⵛⴻⴽ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵓⵙⴻⴼⵚⵉ ⵏ ⵍⴻⵖⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS48_11","024_48_11","ISA","48","11","11","ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⴰⴷ ⵜ ⴳⴳⴻⵖ, ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⵉⵙⴻⵎ ⵉⵏⵓ? ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵜⵜⵉⵛⴻⵖ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS48_12","024_48_12","ISA","48","12","12","“ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⵛⴻⴽ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵍⴰⵖⵉⵖ! ⵏⴻⵛⵛ ⵏⴻⵛⵛ, ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵍⴰ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("IS48_13","024_48_13","ISA","48","13","13","ⴰⴼⵓⵙ ⵉⵏⵓ ⵉⵙⵙⴰⵔⵙ ⵄⴰⵡⴻⴷ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⴰⴼⵓⵙⵉ ⵉⵏⵓ ⵉⴱⴻⵣⵣⴻⵄ ⵉⵊⴻⵏⵡⴰⵏ. ⵎⴰⵍⴰ ⵍⴰⵖⵉⵖ ⴰⵙⴻⵏ, ⵜⵜⴱⴻⴷⴷⴰⵏ ⵏⵉⵜⵏⵉ ⴷⵉⵏⵏⵉ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("IS48_14","024_48_14","ISA","48","14","14","ⵎⵓⵏⴻⵎ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵓ ⵙⵍⴻⵎ: ⵎⴰⵏ ⵡⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⴱⴰⵔⵔⴻⵃ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ? ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ, ⵓ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⴱⴰⴱⵉⵍ, ⴰⵖⵉⵍ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴹⵉⴷⴷ ⵉ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS48_15","024_48_15","ISA","48","15","15","ⴰⵇⴰ ⵏⴻⵛⵛ, ⵡⴰⵀ, ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵜ, ⵓ ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⴰⵙ ⵄⴰⵡⴻⴷ. ⴰⴷ ⴳⴳⴻⵖ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⵍⴻⵃ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS48_16","024_48_16","ISA","48","16","16","ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵙⵍⴻⵎ ⴰⵢⴰ: ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵜⵏⵓⴼⴼⵔⴰ. ⵣⴻⴳ ⵡⴰⵎⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⴷⵉⵏ! ‘ⵓ ⵍⴻⵅⵅⵓ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ, ⴰⴽ-ⴷ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("IS48_17","024_48_17","ISA","48","17","17","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵛ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵙⵙⵍⴻⵎⴷⴻⵏ ⵎⵉⵏ ⵉⵏⴻⴼⴼⵄⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵅ ⵉ ⵖⴰ ⵜⵓⵢⵓⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("IS48_18","024_48_18","ISA","48","18","18","ⴰⵅ, ⵎⵍⵉ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⴼ ⵍⴻⵀⵏⴰ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵓ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴰⵎ ⵍⴻⵎⵡⴰⵊ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("IS48_19","024_48_19","ISA","48","19","19","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵜⵓⵖⴰ-ⵜⵜ ⴰⵎ ⵢⵉⵊⴷⵉ, ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ ⴰⵎ ⵍⵃⴻⴱⴱ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵣⴰⵢⴻⵙ. ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵏⴻⵇⴹⵉⵄ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("IS48_20","024_48_20","ISA","48","20","20","“ⴼⴼⵖⴻⵎ ⵣⵉ ⴱⴰⴱⵉⵍ, ⴰⵔⴻⵡⵍⴻⵎ ⵣⴻⴳ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⴱⴰⵔⵔⵃⴻⵎ ⴰⵙ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵍⴻⵏ ⴰⵢⴰ, ⵙⵓⴼⴼⵖⴻⵎ ⵍⴻⵅⴱⴰⵔ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵏⵉⵎ: ‘ⵙⵉⴷⵉ ⵉⴼⴻⴽⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵢⴰⵄⵇⵓⴱ!’    ");
INSERT INTO rift_vpl VALUES ("IS48_21","024_48_21","ISA","48","21","21","ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⴽⴽⵉ ⵓⴼⴰⴷⵉ ⵓⵎⵉ ⵜⴻⵏ ⴷⴷ-ⵉⴳⴻⵡⵡⴻⴷ ⵙ ⵉⵎⵓⵛⴰⵏ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴱⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵎⴰⵏ ⵣⵉ ⵜⴻⵚⴹⴰⵔⵜ. ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴵⴻⵇ ⵊⵊⴰⵔⴼ, ⴷⴷⵓⵇⵇⵣⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS48_22","024_48_22","ISA","48","22","22","“ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵜⵜⵉⴼⴻⵏ ⵍⴻⵀⵏⴰ!, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS49_1","024_49_1","ISA","49","1","1","“ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⵜⵉⴳⵣⵉⵔⵉⵏ, ⵙⵃⴻⵙⵙⴻⵎ, ⴰ ⵛⵛⵓⵄⵓⴱ ⵏ ⵍⴰⴳⴳⵯⴰⵊ! ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵣⴻⴳ ⵡⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⵉ ⵍⴻⵎⵍⴰⵡⴻⵜ ⵉⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS49_2","024_49_2","ISA","49","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴷ ⵙⵙⵉⴼ ⵉⵇⴻⴹⵄⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴷⵓⵔⵉⵢ ⴰⵢⵉ ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵢⵉ ⴷ ⴼⵍⵉⵜⵛⴰ ⵙ ⵜⵉⵅⴻⴼⵜ ⵉⵇⴻⴹⵄⴻⵏ, ⵉⴳⴳⴰ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⵇⵔⴰⴱ ⵏⵏⴻⵙ ⵏ ⴼⵍⵉⵜⵛⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("IS49_3","024_49_3","ISA","49","3","3","ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ!’” ");
INSERT INTO rift_vpl VALUES ("IS49_4","024_49_4","ISA","49","4","4","“ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⴰⵔⴱⵔⴻⵖ ⵅ ⵡⴰⵍⵓ, ⴹⴻⵢⵢⵄⴻⵖ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴷⵉ ⵍⵅⴰⵡⵉ ⴷ ⵍⴱⴰⵟⴻⵍ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⵓ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("IS49_5","024_49_5","ISA","49","5","5","“ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵙⵙⵄⴻⵇⴱⴻⵖ ⵢⴰⵄⵇⵓⴱ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⵙⵙⵎⵓⵏⴻⵖ ⵉⵙⵔⴰⵉⵍ - ⵡⴰⵀ, ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ! - ");
INSERT INTO rift_vpl VALUES ("IS49_6","024_49_6","ISA","49","6","6","ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⵉⵇⵇⴰⵔ: ‘ⴷⵔⵓⵙ, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴽⴽⴰⵔⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴷⴰⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⴰⵍ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS49_7","024_49_7","ISA","49","7","7","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⴻⴼⴷⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵇⴻⴷⴷⴻⵙ ⵏⵏⴻⵙ, ⵉ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵏ, ⵉ ⵡⴻⵏⵏⵉ ⴷ ⵏⵏⵄⵉ ⵏ ⵍⴳⴻⵏⵙ, ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵚⵚⵓⵍⵟⴰ: ‘ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⵛⴻⴽ ⵥⴰⵔⴻⵏ ⵓ ⴰⴷ ⴽⴽⴰⵔⴻⵏ, ⵍⵃⵓⴽⴽⴰⵎ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⴽ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴼⴰⵔⵣⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("IS49_8","024_49_8","ISA","49","8","8","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴷⵉ ⵍⵃⴰⵍ ⵏ ⴰⵔⴹⴰ, ⵙⵍⵉⵖ ⴰⵛ, ⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵙⴻⵏⵊⴻⵎ, ⵡⵛⵉⵖ ⴰⵛ ⴰⴼⵓⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵃⴹⵉⵖ ⵓ ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⵛⵛⵃⴻⵖ ⴷ ⵍⵄⴰⵀⴷ ⵏ ⵍⴳⴻⵏⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵄⴰⵡⴻⴷ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("IS49_9","024_49_9","ISA","49","9","9","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵉⵎⴻⵃⴱⴰⵙ: ⴼⴼⵖⴻⵎ-ⴷⴷ!, ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ: ⴹⵀⴰⵔⴻⵎ-ⴷⴷ! ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵉⵇⵓⵛⵛⴰⵔⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("IS49_10","024_49_10","ISA","49","10","10","ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵜⵜⴻⴽⴽ ⵍⴰⵥ ⵓⵍⴰ ⴷ ⴰⴼⴰⴷⵉ, ⵍⴻⵃⵎⵓ ⴷ ⵜⴼⵓⵛⵜ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵛⵛⵉⵜ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵃⵉⵏⵏⴰⵏ ⴰⴷ ⵜⴻⵏ ⵉⴳⴻⵡⵡⴻⴷ, ⴰⴷ ⵜⴻⵏ ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS49_11","024_49_11","ISA","49","11","11","ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵓ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵉⵡⴰⵟⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS49_12","024_49_12","ISA","49","12","12","ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ⵅⵣⴰⵔ, ⵉⵏⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵓ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵙⵡⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS49_13","024_49_13","ISA","49","13","13","“ⵙⵍⵉⵡⵍⵉⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵊⴻⵏⵡⴰⵏ, ⴼⴰⵔⵃⴻⵜ, ⴰ ⵛⴻⵎ, ⵜⴰⵎⵎⵓⵔⵜ! ⴰⵔⵔⴻⵎ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⴷⴷⵓⵇⵇⵣⴻⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⵉⵏⵏ ⵅ ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("IS49_14","024_49_14","ISA","49","14","14","“ⵎⴰⵛⴰ ⵚⵉⵀⵢⵓⵏ ⵜⴻⵏⵏⴰ: ‘ⵙⵉⴷⵉ ⵉⵙⵎⴻⵃ ⴷⴰⵢⵉ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵜⵜⵓ ⴰⵢⵉ.’ ");
INSERT INTO rift_vpl VALUES ("IS49_15","024_49_15","ISA","49","15","15","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵓ ⴰⵙⴻⵢⵎⵉ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵃⵉⵏⵏⵉ ⵅ ⵎⵎⵉⵙ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ? ⵡⴰⵅⵅⴰ ⵜᵉⵜⵜⵓ ⵜ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜᵉⵜⵜⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("IS49_16","024_49_16","ISA","49","16","16","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵏⴻⵇⵛⴻⵖ ⵛⴻⵎ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵍⴻⴱⴷⴰ ⵖⴰⵔⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS49_17","024_49_17","ISA","49","17","17","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵄⴻⵍⴼⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⵜⴻⵃⵃⴰⵢⴻⵏ ⵏⵏⴻⵎ ⵓ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵅⴰⵔⵔⴱⴻⵏ ⴰⴷ ⵅⴰⵎ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS49_18","024_49_18","ISA","49","18","18","ⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵎ ⵓⵛⴰ ⵅⵣⴰⵔ ⴷⴰ ⴷ ⴷⵉⵀⴰ. ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵓⵏⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵎ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴰⵔⴹⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⴰⵎ ⵙ ⵍⴻⵀⵣⵓⵟ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵣⴻⵡⵡⵇⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⵎ ⵜ ⵜⴻⴳⴳⴰ ⵜⴻⵙⵍⵉⵜ.’ ");
INSERT INTO rift_vpl VALUES ("IS49_19","024_49_19","ISA","49","19","19","ⵎⴰⵖⴰⵔ ⵍⵅⵉⵔⴱⴰⵜ ⵏⵏⴻⵎ ⴷ ⵉⵎⵓⵛⴰⵏ ⵏⵏⴻⵎ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵡⴰⵀ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵃⵚⴰⵔ ⵉ ⵉⵎⴻⵣⴷⴰⵖ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵛⴻⵎ ⵚⴰⵔⴹⴻⵏ, ⴰⴷ ⵉⵍⵉⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("IS49_20","024_49_20","ISA","49","20","20","ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵢⴻⵎ ⵉⵜⵜⵡⴰⵛⴰⵔⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵎ: ‘ⴰⵎⵛⴰⵏ ⴷⴰⵢⴻⵙ ⵍⵃⴻⵚⵔⴰⵏ ⵅⴰⴼⵉ, ⴻⴳⴳ ⴰⵢⵉ ⴰⵎⵛⴰⵏ ⵉ ⵏⴻⵛⵛ, ⵎⴰⵃⴻⵏⴷ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("IS49_21","024_49_21","ISA","49","21","21","ⴰⴷ ⵜⵉⵏⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵎ: ‘ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ-ⴰ? ⵓⵛⴰⵔⴻⵏ ⴰⵢⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵔⵡⴻⵖ, ⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵢⵉ-ⴷⴷ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⴰⵢⵉ-ⴷⴷ. ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜⴻⵏ ⵉⵙⵙⴻⵢⵎⴻⵏ? ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⴷ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⴻⵟⵟⴻⵏ, ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ?’” ");
INSERT INTO rift_vpl VALUES ("IS49_22","024_49_22","ISA","49","22","22","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉⵏⵓ ⵉ ⵍⴻⴳⵏⵓⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴷⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴰⴷ ⴰⵔⴱⵓⵏ ⵢⴻⵙⵙⵉⵎ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS49_23","024_49_23","ISA","49","23","23","ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⵛⴻⵎ ⵚⵓⵏⴻⵏ, ⵜⵉⵊⴻⴵⵉⴷⵉⵏ ⴰⴷ ⵛⴻⵎ ⵙⵙⵓⵟⵟⴷⴻⵏⵜ. ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⴽ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⴰⵎ ⵍⴻⵙⵃⴻⵏ ⵜⴰⵄⴻⵊⵊⴰⵛⵜ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵎ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵙⵉⵜⵉⵎⴻⵏ, ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ ⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("IS49_24","024_49_24","ISA","49","24","24","“ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⴰⴷ ⵉⴽⴽⴻⵙ ⵅ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵣⵣⴰⵔⴷⴻⵜ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("IS49_25","024_49_25","ISA","49","25","25","ⵎⴰⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵉⵎⴻⵃⴱⴰⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵟ ⵏ ⵓⵇⴻⵀⵀⴰⵔ ⴰⴷ ⵜⴻⵅⵜⵓⵜⵜⴻⵍ ⵣⵉ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵛⴻⵎ ⵉⵛⴰⵔⵔⴻⵄ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵛⴰⵔⵔⵄⴻⵖ, ⵓⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS49_26","024_49_26","ISA","49","26","26","ⵉ ⵢⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵛⴰⵔⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵙ ⴱⵉⵏⵓ ⵥⴻⵎⵎⴻⵏ ⵜ ⵊⴷⵉⴷ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⴰⵎⵙⴻⵏⵊⴰⵎ ⵏⵏⴻⵎ ⴷ ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵎ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵏ ⵢⴰⵄⵇⵓⴱ.’” ");
INSERT INTO rift_vpl VALUES ("IS50_1","024_50_1","ISA","50","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⴻⴱⵔⴰⵜ ⵏ ⵡⴰⴵⴰⴼ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵙⵙⵇⴻⴱⴱⴹⴻⵖ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ? ⵏⵉⵖ ⵉ ⵎⴰⵏ ⵡⴻⵏ ⵣⴻⴳ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⵔⴻⵟⵟⴰⵔ ⵉⵏⵓ ⴽⴻⵏⵏⵉⵡ ⵣⵣⴻⵏⵣⴻⵖ? ⵅⵣⴰⵔ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ ⵜⴻⵎⵎⴻⵏⵣⴻⵎ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ ⵜⴻⵎⵎⴻⵏⵣ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS50_2","024_50_2","ISA","50","2","2","ⵎⴰⵢⴻⵎⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵍⴰⵖⵉⵖ, ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ? ⵎⴰ ⴰⴼⵓⵙ ⵉⵏⵓ ⴷ ⴰⵇⵓⴹⴰⴹ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴻⴽⴽ, ⵎⴰ ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⴵⵉ ⵊⵊⵀⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴻⴽⴽⴻⵖ? ⵅⵣⴰⵔ, ⵙ ⵓⵙⵉⴳⴳⵯⴻⴷ ⵉⵏⵓ ⴰⴷ ⵙⵙⵉⵥⵔⴻⵖ ⵍⴻⴱⵃⴰⵔ, ⴰⴷ ⴳⴳⴻⵖ ⵉⵖⴻⵣⵔⴰⵏ ⴷ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⴰⴷ ⴰⵥⵖⴻⵏ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵢⴰⵔⵚⵓⴹⴻⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵏⵙⴻⵏ ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ ⵡⴰⵎⴰⵏ, ⵓⵛⴰ ⴰⴷ ⵎⵎⵜⴻⵏ ⵣⴻⴳ ⵓⴼⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS50_3","024_50_3","ISA","50","3","3","ⴰⴷ ⵙⵙⵢⴰⵔⴹⴻⵖ ⴰⵊⴻⵏⵏⴰ ⵙ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ, ⴰⴷ ⵜⴻⵏ ⵍⴻⵃⵃⴼⴻⵖ ⵙ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS50_4","024_50_4","ISA","50","4","4","“ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵍⴻⵙ ⵏ ⵓⵎⴻⵃⴹⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵙⵙⵎⴻⵃⴷⴻⵖ ⵡⴻⵏⵏⵉ ⵢⵓⵃⵃⵍⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ. ⵇⴰⵄ ⵜⵓⴼⴼⵓⵜ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴼⴰⵇⴰ ⴰⵢⵉ, ⵉⵙⵙⴼⴰⵇⴰ ⴰⵢⵉ ⴰⵎⴻⵣⵣⵓⵖ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⵙⵍⵉⵖ ⴰⵎ ⵓⵎⴻⵃⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS50_5","024_50_5","ISA","50","5","5","ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵢⴰⵔⵣⴻⵎ ⴰⵢⵉ ⴰⵎⴻⵣⵣⵓⵖ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴻⵡⵡⵖⴻⵖ ⵛⴰ, ⵡⴰⵔ ⴷⴷ-ⴷⴷⵡⵉⵍⴻⵖ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("IS50_6","024_50_6","ISA","50","6","6","ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵄⵔⵓⵔ ⵉⵏⵓ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵜⵉⵏ, ⵓ ⵉⵖⴻⵎⵎⵉⵣⴻⵏ ⵉⵏⵓ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵛⴼⴻⵏ ⵜⵎⴰⵔⵜ. ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵡⴰⵔ ⵜ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵓⵙⴻⵃⵇⴰⵔ ⴷ ⵓⵙⵓⵙⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("IS50_7","024_50_7","ISA","50","7","7","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴰⴼⵓⵙ, ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵇⴻⵟⵟⵉⵖ ⴷⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵅ ⵓⵢⴰ ⵊⵊⵉⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵉⵇⵙⴻⵃ ⴰⵎ ⵙⵙⴻⴵⴰⵃ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS50_8","024_50_8","ISA","50","8","8","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵙⴻⴳⴳⴷⴻⵏ, ⴰⵇⴰ-ⵜ ⵢⵓⴷⴻⵙ. ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵣⴻⵄⵎⴻⵏ ⴰⴷ ⴽⵉⴷⵉ ⵉⵛⴰⵔⵔⴻⵄ? ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴱⴻⴷⴷ ⵏⵎⵓⵏ! ⵎⴰⵏ ⵡⴻⵏ ⴽⵉⴷⵉ ⵉⵜⵜⴻⵎⵛⴰⵔⵔⴰⵄⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS50_9","024_50_9","ISA","50","9","9","ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴰⴼⵓⵙ. ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⴳⴳ ⵍⵄⵉⴱ? ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵉⴷⴷⵓⵢⵙⴰⵔⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛ ⵜⵛⵉⵏⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS50_10","024_50_10","ISA","50","10","10","“ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵙⵉⴷⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ? ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⴷ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵖⴰⵔ ⵜⴻⴵⵉ ⵜⴰⴼⴰⵡⵜ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵜⵜⵛⴻⵍ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵄⴻⵎⵎⴻⴷ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS50_11","024_50_11","ISA","50","11","11","ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵜⴻⵙⵙⴰⵔⵖⴻⵎ ⵜⵉⵎⴻⵙⵙⵉ, ⵜⴱⴻⵢⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⴼⵍⵉⵜⵛⴰⵜ ⵉ ⵓⵙⴻⵛⵎⴰⴹ. ⵉⵡⴰ, ⵓⵢⵓⵔⴻⵎ ⵅⴻⵏⵏⵉ ⴷⵉ ⵜⴼⴰⵡⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏⵡⴻⵎ ⵓ ⵖⴰⵔ ⵜⴼⴰⵡⵜ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⴰⵔⵖⴻⵎ. ⴰⵢⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵢⴰⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵙ ⵍⴻⵃⵔⵉⵇ ⴰⴷ ⵜⴻⵣⵣⵍⴻⵎ ⴷⵉⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS51_1","024_51_1","ISA","51","1","1","“ⵙⵍⴻⵎ ⵖⴰⵔⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵙⵉⴷⵉ! ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵜⴻⵚⴹⴰⵔⵜ ⵎⴰⵏⵉⵙ ⵜᵉⵜⵜⵡⴰⵏⴻⵇⵛⴻⵎ ⵓ ⵖⴰⵔ ⵡⴻⵅⴱⵓⵛ ⵏ ⵡⴰⵏⵓ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵖⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS51_2","024_51_2","ISA","51","2","2","ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ, ⵊⴻⴷⴷⵉⵜⵡⴻⵎ, ⵓ ⵖⴰⵔ ⵙⴰⵔⴰ, ⵜⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ. ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ-ⵜ ⵄⴰⴷ ⵃⴰⴼⵉ ⵓⵎⵉ ⵜ ⵍⴰⵖⵉⵖ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴱⴰⵔⴽⴻⵖ ⵜ ⵓ ⴰⵔⵣⴼⴻⵖ ⴰⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS51_3","024_51_3","ISA","51","3","3","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵎⴰⵔⵔⴰ ⵍⵅⵉⵔⴱⴰⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵢⴰⵔⵔ ⴰⵎ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵄⴰⴷⵏ ⵓ ⵍⴻⵅⵍⴰ ⵏⵏⴻⵙ ⴰⵎ ⵡⴻⵃⵡⵉⵛ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵙⵉⴷⵉ. ⴰⵔⵛⴰⵇ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴻⵏ ⴰⴼⴻⵏ, ⴰⵇⴰⴷⵉ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS51_4","024_51_4","ISA","51","4","4","“ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⵛⵛⴻⵄⴱ ⵉⵏⵓ, ⵓ ⵡⵛⴻⵎ ⴰⵢⵉ ⴰⵎⴻⵣⵣⵓⵖ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵣⵣⴰⵢⵉ ⵜⴻⴼⴼⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴹⴻⵎⵏⴻⵖ ⵍⵃⴻⵇⵇ ⵉⵏⵓ ⴰⵍ ⵖⴰ ⵢⵉⵍⵉ ⵍⵃⴻⵇⵇ ⵉⵏⵓ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS51_5","024_51_5","ISA","51","5","5","ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ ⵜⵓⴷⴻⵙ-ⴷⴷ, ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵓ ⵉⵖⴰⴵⴻⵏ ⵉⵏⵓ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⴰⵢⵉ ⵔⴰⵊⴰⵏⵜ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵜⵎⴻⵏⵜ ⵅ ⵓⵖⵉⵍ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS51_6","024_51_6","ISA","51","6","6","“ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵅⵣⴰⵔⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⴷⴰ ⵙⵡⴰⴷⴷⴰⵢ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵉⴼⴼⴰⵔⴼⴰⵔ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⴷⴷⵓⵢⵙⴰⵔ ⴰⵎ ⵡⴰⵔⵔⵓⴹ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵎⵎⵜⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ, ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜ ⵇⴻⵟⵟⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS51_7","024_51_7","ISA","51","7","7","“ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⴰ ⵛⴻⴽ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⴷⴻⴳ ⵡⵓⵍ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵣⵉ ⵍⵃⴻⴳⵔⴰ ⵏ ⵢⴻⵡⴷⴰⵏ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵛⴻⵎ ⴰⵔⵥⴻⵏ ⵙ ⵓⵄⴻⵢⵢⴻⴱ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("IS51_8","024_51_8","ISA","51","8","8","ⵎⴰⵖⴰⵔ ⵜⴰⵛⵉⵏⴷⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛ ⴰⵎ ⵜᵉⵜⵜⴻⵜⵜ ⴰⵔⵔⵓⴹ, ⵓⵛⴰ ⴰⴽⵉⵛⵛⵓ ⴰⴷ ⵜⴻⵏ ⵢⴻⵛⵛ ⴰⵎ ⵜⴰⴹⵓⴼⵜ, ⵎⴰⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS51_9","024_51_9","ISA","51","9","9","“ⴼⴰⵇ, ⴼⴰⵇ, ⴰⵔⴹ ⵙ ⵊⵊⵀⴻⴷ, ⴰ ⴰⵖⵉⵍ ⵏ ⵙⵉⴷⵉ! ⴼⴰⵇ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵉⵛ, ⴰⵎ ⴷⵉ ⵊⵊⵉⵍⴰⵜ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵡⴻⵛⵃⴰⵔ ⵓⵢⴰ. ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵇⴻⵙⵙⴻⵏ ⵔⴰⵀⴰⴱ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵍⵀⴰⵢⵛⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("IS51_10","024_51_10","ISA","51","10","10","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵥⵖⴻⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵎⴰⵏ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉⵏⵏⵀⴻⵡⵍⴻⵏ ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔⵉⵏ ⴰⴱⵔⵉⴷ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵢⵓⴵⵖⴻⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵥⵡⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("IS51_11","024_51_11","ISA","51","11","11","ⵉⵏⵏⵉ ⵉⴼⴷⴰ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵍⴻⴱⴷⴰ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵡⴰⵔⵛⴰⵇ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰⵎ ⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵍ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵡⴻⵙⵃⵉⵙⵙⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("IS51_12","024_51_12","ISA","51","12","12","“ⴷ ⵏⴻⵛⵛ, ⵡⴰⵀ, ⴷ ⵏⴻⵛⵛ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴼⴻⵡⵡⵊⴻⵏ. ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵉⴼⴻⵏⵏⴰⵏ, ⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⴰⵔⴱⵉⵄ, ");
INSERT INTO rift_vpl VALUES ("IS51_13","024_51_13","ISA","51","13","13","ⵜᵉⵜⵜⴻⵜⵜⵓⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⵣⵣⵄⴻⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵙⴻⵏ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⵍⴻⴱⴷⴰ, ⴰⵙⵙ ⵉⴽⵎⴻⵍ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵙⵄⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵓⵎⵉ ⵉⵙⵙⴻⵡⵊⴰⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ? ⵎⴰⵏⵉ ⵉⴵⴰ ⵅⴻⵏⵏⵉ ⵡⴻⵙⵄⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("IS51_14","024_51_14","ISA","51","14","14","ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴼⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⴰⵎ ⵉⵜⵜⴻⴼⵔⵉⵖ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⴷⴰⵡⴻⵃⴷⴰ. ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵉⵎⴻⵃⴱⴰⵙ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵏⴻⵇⵇⴻⵚ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("IS51_15","024_51_15","ISA","51","15","15","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵀⵡⴰⵍⴻⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵍ ⵖⴰ ⵀⴰⵊⴰⵏ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵙ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS51_16","024_51_16","ISA","51","16","16","ⵜⵜⴻⴳⴳⴻⵖ ⴰⵛ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵓ ⵙⵙⴷⵓⵔⵔⵓⵢⴻⵖ ⵛⴻⴽ ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⵥⵓⵖ ⴰⵊⴻⵏⵏⴰ, ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵚⵉⵀⵢⵓⵏ: ‘ⵛⴻⴽ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("IS51_17","024_51_17","ISA","51","17","17","“ⴼⴰⵇ, ⴼⴰⵇ, ⴽⴽⴰⵔ-ⴷⴷ ⴰ ⵓⵔⵛⴰⵍⵉⵎ! ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵜⴻⵙⵡⵉⴷ ⵣⵉ ⵍⴽⴰⵙ ⵏ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵜⴻⵛⵛⵉⴷ ⵍⴻⵅⵎⵉⵔⴰ ⵣⵉ ⵍⴽⴰⵙ ⵏⵏⵉ ⵉⵙⵙⴷⴻⵡⵡⴰⵅⴻⵏ, ⵡⴰⵀ, ⵜⵥⴻⵎⵎⴻⴷ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("IS51_18","024_51_18","ISA","51","18","18","ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⴳⴻⵡⵡⵉⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ, ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⵢⴻⵎ, ⵡⴰⵔ ⵜⵜ ⵢⴻⵟⵟⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵓⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("IS51_19","024_51_19","ISA","51","19","19","ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵍⴻⵇⴼⴻⵏⵜ ⵛⴻⵎ, ⵎⴰⵛⴰ ⵡⵉ ⵅⴰⵎ ⵉ ⵖⴰ ⵉⵃⵉⵏⵏⴻⵏ? ⵅⵣⴰⵔ, ⴰⵅⴰⵔⵔⴻⴱ ⴷ ⵡⴻⵍⴱⴻⵣ ⴷ ⵍⴰⵥ ⴷ ⵙⵙⵉⴼ! ⵎⴰⵎⵎⴻⵛ ⵛⴻⵎ ⵉ ⵖⴰ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("IS51_20","024_51_20","ISA","51","20","20","ⵡⴹⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ, ⵖⴰⵛⴰⵏ, ⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⴰⵔ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⴰⵎ ⵜⵖⴰⵢⴹⵉⵏ ⵏ ⵡⴻⵣⵖⴰⵔ ⴷⵉ ⵜⵔⴰⵛⵛⴰ. ⵏⵉⵜⵏⵉ ⵊⵊⵉⵡⵏⴻⵏ ⵙ ⵡⴻⵙⵄⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵙ ⵓⵙⵉⴳⴳⵯⴻⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS51_21","024_51_21","ISA","51","21","21","“ⵙ ⵓⵢⴰ ⵙⴻⵍ ⴰⵢⴰ, ⴰ ⵛⴻⵎ ⵍⵎⵉⵙⴽⵉⵏⴰ, ⴷ ⵜⴰⵎⴻⵙⵛⴰⵔⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⴱⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS51_22","024_51_22","ISA","51","22","22","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏⵏⴻⵎ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵛⵛⴰⵜⴻⵏ ⴷⴷⴻⵄⵡⴻⵜ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵍⴽⴰⵙ ⵉⵙⵙⴷⴻⵡⵡⴰⵅⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ, ⵡⴰⵔ ⵜⵙⴻⵙⵙⴻⴷ ⵄⴰⴷ ⴽⵜⴰⵔ ⵣⵉ ⵍⴻⵅⵎⵉⵔⴰ ⵏ ⵍⴽⴰⵙ ⵏ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS51_23","024_51_23","ISA","51","23","23","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵎ ⵉⵖⴻⵣⵣⴰⵏ, ⵉⵏⵏⵉ ⵉⵏⵏⴰⵏ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ: ⵙⴰⴹⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵅⴰⵎ ⵏⴻⵥⵡⴰ! ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵄⵔⵓⵔ ⵏⵏⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⵉⴷ ⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⴱⵔⵉⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⵎ ⵉⵥⵡⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS52_1","024_52_1","ISA","52","1","1","“ⴼⴰⵇ, ⴼⴰⵇ, ⴰⵔⴹ ⵙ ⵊⵊⴻⵀⴷ ⴰ, ⵚⵉⵀⵢⵓⵏ, ⴰⵔⴹ ⵙ ⵡⴻⵔⵔⵓⴹ ⵏⵏⴻⵎ ⵉⵛⵛⵓⵡⵡⴰⵔⴻⵏ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ! ⵣⵉ ⵙⵙⴰ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵎ ⵜ-ⵉ-ⴷⴷ-ⵉⵜⵜⵉⴷⵉⴼ ⵄⴰⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⴷ ⵓⵎⴻⵅⵎⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("IS52_2","024_52_2","ISA","52","2","2","ⵣⴻⵔⵣ ⵅⴰⵎ ⵜⴰⵄⴻⵊⵊⴰⵛⵜ, ⴽⴽⴰⵔ, ⵇⵇⵉⵎ ⵛⴻⵎ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ! ⴰⵔⵅⵓ ⵙⵙⵏⴰⵙⴻⵍ ⵣⴻⴳ ⵢⵉⵔⵉ ⵏⵏⴻⵎ, ⴰ ⵜⴰⵎⴻⵃⴱⵓⵙⵜ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("IS52_3","024_52_3","ISA","52","3","3","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵜⴻⵎⵎⴻⵏⵣⴻⵎ ⵙ ⴱⴰⵟⴻⵍ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴼⴻⴽⴽⴻⵎ ⵄⴰⵡⴻⴷ ⴱⵍⴰ ⵜⵎⴻⵏⵢⴰⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS52_4","024_52_4","ISA","52","4","4","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵣⵉⵛ ⵉⵀⵡⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵇⵇⵉⵎ ⴰⵎ ⵍⴱⴰⵔⵔⴰⵏⵉ, ⵓⵛⴰ ⴰⵛⵛⵓⵔ ⵉⵃⵚⴰⵔ ⵉ-ⵜ ⵅ ⵡⴰⵍⵓ!’” ");
INSERT INTO rift_vpl VALUES ("IS52_5","024_52_5","ISA","52","5","5","“ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵎⵉⵏ ⵖⴰⵔⵉ ⵄⴰⴷ ⵅⴰⴼⵉ ⴰⴷ ⵜⵜ ⴳⴳⴻⵖ ⴷⴰⵏⵉⵜⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴰⵡⵢⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ ⵓⵛⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⵚⴻⵍⵍⵟⴻⵏ ⵙⵙⵖⵓⵢⵢⵓⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵜⵜⵄⴻⵢⵢⴱⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS52_6","024_52_6","ISA","52","6","6","ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵙ ⵓⵢⴰ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ: ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("IS52_7","024_52_7","ISA","52","7","7","“ⵎⴻⵛⵃⴰⵍ ⵛⵏⴰⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⵚⵓⵔⴰⴼ ⵏ ⵓⵎⴱⴻⵛⵛⴰⵔ ⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵍⴻⵀⵏⴰ, ⵏ ⵓⵎⴱⴻⵛⵛⴰⵔ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵓⵙⴻⵏⵊⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵚⵉⵀⵢⵓⵏ: ‘ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ ⴷ ⴰⵊⴻⴵⵉⴷ!’ ");
INSERT INTO rift_vpl VALUES ("IS52_8","024_52_8","ISA","52","8","8","ⵙⵍⴻⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏⵏⴻⵎ! ⵏⵉⵜⵏⵉ ⵜⵜⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵜⵜⴻⵙⵍⵉⵡⵍⵉⵡⴻⵏ ⵎⵓⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵓⴷⴻⵎ ⴷⴻⴳ ⵓⴷⴻⵎ ⴰⴽⵉⴷⴻⵙ ⴰⴷ ⵜⵡⴰⵍⴰⵏ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ ⵖⴰ ⵉⵙⵙⴻⵄⵇⴻⴱ ⵙⵉⴷⵉ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("IS52_9","024_52_9","ISA","52","9","9","ⵙⵖⵓⵢⵢⴻⵏⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵙⵍⵉⵡⵍⴻⵡⴻⵏⵜ ⵜⵎⵓⵏⴻⵏⵜ, ⴰ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵉⴼⴻⴽⴽ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("IS52_10","024_52_10","ISA","52","10","10","ⵉⵄⴰⵔⵔⴰ ⵙⵉⴷⵉ ⴰⵖⵉⵍ ⵏⵏⴻⵙ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴰⵡⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS52_11","024_52_11","ISA","52","11","11","“ⵔⵓⵃⴻⵎ, ⵔⵓⵃⴻⵎ, ⴼⴼⵖⴻⵎ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ, ⵡⴰⵔ ⵜⵜⵃⴰⴷⴰⵎ ⵡⴰⵍⵓ ⵏ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ, ⴼⴼⵖⴻⵎ ⵙⵙⴻⵏⵏⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⵙⵉⵣⴻⴷⴳⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("IS52_12","024_52_12","ISA","52","12","12","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴼⴼⵖⴻⵎ ⵙ ⵜⴻⵣⵍⴰ, ⵡⴰⵔ ⵜⴰⵔⴻⴽⴽⵡⴰⵍⴻⵎ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵢⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵏⵡⴻⵎ ⵓ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏⵡⴻⵎ ⴰⵏⴻⴳⴳⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS53_1","024_53_1","ISA","53","1","1","“ⵅⵣⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴰⴷ ⵢⴻⴳⴳ ⵙ ⵍⴻⵄⵇⴻⵍ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ, ⵡⴰⵀ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("IS53_2","024_53_2","ISA","53","2","2","ⴰⵎ ⵣⵣⴰⵢⴻⴽ ⵏⵏⵅⴻⵍⵄⴻⵏ ⴰⵟⵟⴰⵙ - ⴰⵎⵎⵓ ⵙ ⵡⴰⵟⵟⴰⵙ ⵉⵅⵙⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴰⵎ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⴰⴷⴷⵓⴷ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴰⵎ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ - ");
INSERT INTO rift_vpl VALUES ("IS53_3","024_53_3","ISA","53","3","3","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵙⵙⴻⵏⴳⴻⵣ ⵏⴻⵜⵜⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵡⴰⵀ, ⵄⴰⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⵙⵙⴻⵖⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⴱⴰⵔⵔⵃⴻⵏ, ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ, ⵓ ⵎⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵙⵍⵉⵏ, ⴰⴷ ⵜ ⴼⴻⵀⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS53_4","024_53_4","ISA","53","4","4","“ⵎⴰⵏ ⵡⴻⵏ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵖ ⵓ ⵡⵉ ⵉ ⵓⵎⵉ ⴷ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵏ ⵓⵖⵉⵍ ⵏ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("IS53_5","024_53_5","ISA","53","5","5","ⵎⴰⵖⴰⵔ ⴰⵎ ⵜⵙⴻⵟⵟⴰ ⵉⵎⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰⵎ ⵡⴻⵥⵡⴰⵔ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⴷⴷⵓⴷ ⵏⵉⵖ ⴰⵛⴻⵡⵡⴰⵔ ⵅⵎⵉ ⵜ ⵏⵥⴰⵔ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵡⴰⵥⵔⵉ ⵏ ⵍⵅⴻⵥⵔⴰⵜ ⴰⵍⴰⵎⵉ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⵏⴻⵎⵎⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS53_6","024_53_6","ISA","53","6","6","ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ, ⵉⵎⵎⴻⵏⴹⴰⵔ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⴰⵔⵢⴰⵣ ⵏ ⵍⴻⵃⵔⵉⵇ, ⵉⵙⵙⴻⵏ ⵍⴻⵃⵍⴰⵛ, ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉ ⵓⵎⵉ ⵍⴻⵃⵃⴼⴻⵏ ⴰⵖⴻⵎⴱⵓⴱ, ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⵓ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵜ ⵏⵃⴻⵙⵙⵉⴱ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("IS53_7","024_53_7","ISA","53","7","7","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⴽⵙⵉ ⵅⴰⵙ ⵍⴻⵃⵍⴰⵛ ⵏⵏⴻⵖ ⵓⵛⴰ ⵢⴰⵔⴱⵓ ⵍⴻⵃⵔⵉⵇ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵃⴻⵙⴱ ⵉ-ⵜ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜ ⵍⵎⵓⵚⵉⴱⴰ, ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉⵖⴹⴻⵍ ⵉ-ⵜ ⵓ ⵉⵃⵚⴰⵔ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("IS53_8","024_53_8","ISA","53","8","8","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴻⴱ ⵅ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵖ, ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵍⴻⴱⵣⴻⵏ ⵜ. ⵜⴻⵎⵎⴰⵔⵙ ⵅⴰⵙ ⵜⴻⵛⵜⵉ ⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⴰⴽⴽⵡⴰⴹⴻⵏ ⵍⴻⵀⵏⴰ, ⵓ ⵙ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⴰⵏⴻⵖ ⴷ ⴰⴳⴻⵏⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("IS53_9","024_53_9","ISA","53","9","9","ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⵡⴻⴷⴷⴰⵔ ⴰⵎ ⵡⵓⴵⵉ, ⵏⴻⴷⵡⴻⵍ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⵡⴹⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS53_10","024_53_10","ISA","53","10","10","ⴷⴻⴵⴻⵏ ⵜ, ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜ ⵙⵙⴱⴻⵀⴷⵍⴻⵏ. ⵡⴰⵔ ⵢⴰⵔⵣⵉⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⴰⵎ ⵉⵣⵎⴰⵔ ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵜⵖⴰⵔⵚⵜ, ⴰⵎ ⵜⴻⵅⵙⵉ ⵜⴻⴳⵏⵓ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⴵⴰⵙⴻⵏ, ⴰⵎⵎⵓ ⵡⴰⵔ ⵢⴰⵔⵣⵉⵎ ⵏⴻⵜⵜⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS53_11","024_53_11","ISA","53","11","11","ⵉⵎⵎⴻⴽⵙⵉ-ⴷⴷ ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⵣⵉ ⵍⴻⵃⴽⴰⵎ. ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵊⵊⵉⵍ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵅⴻⵎⵎ ⴷⴰⵢⴻⵙ, ⵣⴻⵄⵎⴰ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⵅⴰⵙ ⵜⵉⵛⵜⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS53_12","024_53_12","ISA","53","12","12","ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵡⴻⵏⴹⴻⵍ ⵖⴰⵔ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⵜⵓⵊⴰⵔ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⵉⵇⴻⵙⵃⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴳⴳⵉ ⵍⵄⵓⵏⴼ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵓⵖⵉ ⵍⵖⴻⵛⵛ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS53_13","024_53_13","ISA","53","13","13","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⴵⴰ ⵉ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵍⴱⴻⵣ, ⵉⵙⵙⴻⵃⵍⴻⵛ ⵉ-ⵜ. ⵍⴰⵎⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⴰⴷ ⵉⵥⴰⵔ ⵏⴻⵜⵜⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ, ⴰⴷ ⵉⵙⵙⵣⵓⴳⴳⴰⵔ ⵏⴻⵜⵜⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⵇⴼⴻⵍ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS53_14","024_53_14","ISA","53","14","14","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵎⴰⵔⵔⴻⵜ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵉⵥⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵊⵊⵉⵡⴻⵏ. ⵙ ⵜⵓⵙⵙⵏⴰ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⴻⴳⴳⴻⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⴰⵎⵙⴻⴳⴳⴻⴷ, ⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵡⴷⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS53_15","024_53_15","ISA","53","15","15","ⵙ ⵓⵢⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵊⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴽ-ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵚⵚⵓⵍⵟⴰ ⴰⴷ ⵉⴱⴹⴰ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ, ⵎⵉⵏⵣⵉ ⵉⵙⴻⴱⴱⴻⵍ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ ⵓⵛⴰ ⵢⴰⵔⴱⵓ ⴷⴷⵏⵓⴱ ⵏ ⵡⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⵜⵜⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ.”    ");
INSERT INTO rift_vpl VALUES ("IS54_1","024_54_1","ISA","54","1","1","“ⵙⵔⵉⵡⵍⴻⵡ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ! ⴷⵓⵇⵇⴻⵣ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵙⵖⵓⵢⵢ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰ ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵡⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵏⵏⵉ ⴷⵉ ⵙⴻⵎⵃⴻⵏ ⴷ ⴰⵟⵟⴰⵙ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS54_2","024_54_2","ISA","54","2","2","ⴻⴳⴳ ⵜⵜⴰⵙⵉⵄ ⵉ ⵉⵇⵉⴹⴰⵏ ⵏⵏⴻⵎ ⵓ ⴻⵊⵊ ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⴰⵔⵡⴰⵇⴰⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵎ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⴻⵏ ⵎⴻⵏⵏⴻⵄ. ⵙⵣⵓⴳⴳⴰⵔ ⵜⵉⵎⵓⵔⴰⵔ ⵏⵏⴻⵎ ⵓⵛⴰ ⵣⵉⵢⵢⴰⵔ ⵍⴻⵡⵜⴰⴷ! ");
INSERT INTO rift_vpl VALUES ("IS54_3","024_54_3","ISA","54","3","3","ⵎⴰⵖⴰⵔ ⵛⴻⵎ ⴰⴷ ⵜⵉⵔⵉⵡⴻⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵓⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵎ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⵍⴻⴳⵏⵓⵙ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵣⴻⴷⵖⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS54_4","024_54_4","ISA","54","4","4","“ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜⵙⴻⴹⵃⵉⴷ ⵓ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⴱⴰⵔⵔⵇⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴼⴻⴹⵃⴻⴷ. ⴰⴷ ⵜᵉⵜⵜⵓⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵄⵇⵉⵍⴻⴷ ⵅ ⵍⴻⵃⵛⵓⵎⵉⵢⵢⴻⵜ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵎ ⴰⵎ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("IS54_5","024_54_5","ISA","54","5","5","ⵎⴰⵖⴰⵔ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⵎ ⵉⴳⴳⵉⵏ, ‘ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ’ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵎ. ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ‘ⴰⵔⴻⴱⴱⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ’. ");
INSERT INTO rift_vpl VALUES ("IS54_6","024_54_6","ISA","54","6","6","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵍⴰⵖⴰ ⵅⴰⵎ ⴰⵎ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⴷⵉ ⵉⵙⵎⴻⵃ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵉ ⴷⴰⵢⴻⵙ ⴰⵛⴹⴰⵏ ⴷⴻⴳ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵓ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵜⴻⵎⵥⵉ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ-ⵜⵜ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ, ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS54_7","024_54_7","ISA","54","7","7","ⵎⵖⵉⵔ ⵜⴰⵣⴻⵃⵣⵉⵃⵜ ⵙⴻⵎⵃⴻⵖ ⴷⴰⵢⴻⵎ, ⵎⴰⵛⴰ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⴷ ⵛⴻⵎ ⵙⵙⵎⵓⵏⴻⵖ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("IS54_8","024_54_8","ISA","54","8","8","ⵓⵎⵉ ⴳⴳⵉⵖ ⴰⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⴰⴷ ⵉⵙⴼⵉ, ⴰⵇⴰ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⵣⵣⴰⵢⴻⵎ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵉ ⵢⵉⵛⵜ ⵜⵣⴻⵃⵣⵉⵃⵜ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵏ ⵍⴻⴱⴷⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵣⵣⵉⴵⵣⴻⴷ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS54_9","024_54_9","ISA","54","9","9","“ⵎⴰⵖⴰⵔ ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⵓⵃ ⵓⵎⵉ ⵊⵊⵓⴵⴻⵖ ⴰⵇⴰ ⴰⵎⴰⵏ ⵏ ⵏⵓⵃ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵙⵙⴼⵉⵢⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ⴰⵎⵎⵓ ⵉ ⵊⵊⵓⴵⴻⵖ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⴷ ⵅⴰⵎ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⵄⵉⵇⵉⴱⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("IS54_10","024_54_10","ISA","54","10","10","ⵎⴰⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵏⵏⵀⴻⵣⵣⴻⵏⵜ, ⵎⴰⵛⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵅⴰⵎ ⵜⵃⴻⵢⵢⴻⴷ ⵓⵛⴰ ⵍⵄⴰⵀⴷ ⵏ ⵍⴻⵀⵏⴰ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⵉ ⵄⴻⵎⵎⴰⵔⵚ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵣⵣⵉⴵⵣⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("IS54_11","024_54_11","ISA","54","11","11","“ⴰ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⵇⴻⵟⵟⴻⴱ ⵓⵙⴻⵎⵎⵉⴹ, ⵜⴻⵏⵏⵉ ⵏⵀⵍⴰ ⴰⴼⴻⵡⵡⴻⵊ! ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵇⵓⵡⵡⴰⵔⴻⵖ ⵉⵥⵔⴰ ⵏⵏⴻⵎ ⵉⵖⵍⴰⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⴰ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⴷⵙⴰⵙ ⵏⵏⴻⵎ ⵅ ⵜⵢⴰⵇⵓⵜⵉⵏ ⵏ ⵚⴰⴼⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("IS54_12","024_54_12","ISA","54","12","12","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⴽⵡⴰⵣⴰ ⵏⵏⴻⵎ ⵉ ⵜⴼⵓⵛⵜ ⵣⴻⴳ ⵓⴽⵔⵉⵙⵜⴰⵍ, ⵓⵍⴰ ⴷ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵎ ⵏ ⵍⴻⵄⵇⴰⵇ ⵉⵣⴻⴳⴳⵡⴰⵖⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵉ ⴷ ⴰⵎ ⵉⵏⵏⴹⴻⵏ ⵣⴻⴳ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS54_13","024_54_13","ISA","54","13","13","ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵍⴻⵀⵏⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS54_14","024_54_14","ISA","54","14","14","ⵛⴻⵎ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴰⵔⴻⴽⴽⵏⴻⴷ ⵙ ⵜⵙⴻⴳⴷⴰ. ⴰⴷ ⵜⵉⵍⵉⴷ ⵜᵉⵜⵜⴰⴳⴳⵯⴻⵊⴻⴷ ⵅ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ, ⵓⵍⴰ ⵅ ⵓⵏⴻⵅⵍⵉⵄ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⴻⵎ ⵉⵜⵜⵉⴽⴽⵡⵉⴹ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS54_15","024_54_15","ISA","54","15","15","ⵅⵣⴰⵔ, ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ, ⵎⴰⵛⴰ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵣⴰⵢⵉ. ⵡⵉ ⵅⴰⵎ ⵉ ⵖⴰ ⵉⵙⵙⵎⵓⵏⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵉⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("IS54_16","024_54_16","ISA","54","16","16","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵅⴻⵍⵇⴻⵖ-ⴷⴷ ⴰⵎⵣⵉⵍ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⵓⴹⴻⵏ ⵜⵉⵔⵊⵉⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓ ⵉⵙⵙⵓⴼⴼⵓⵖ-ⴷⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ ⵄⴰⵡⴻⴷ ⴰⵎⵜⴻⵃⵃⴰⵢ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("IS54_17","024_54_17","ISA","54","17","17","ⴽⵓⵍ ⵍⴻⵙⵏⴰⵃ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵎ, ⵡⴰⵔ ⵉⵜⵜⵉⵡⴻⴹ, ⵓⵛⴰ ⴽⵓⵍ ⵉⵍⴻⵙ ⵏⵏⵉ ⵅⴰⵎ ⵉ ⴷⴷ ⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ, ⴰⴷ ⵜ ⵜⵃⴻⴽⵎⴻⴷ ⵛⴻⵎ. ⵜⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵙⴻⵏ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS55_1","024_55_1","ISA","55","1","1","“ⴰ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴼⴼⵓⴷⴻⵏ, ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵡⴰⵎⴰⵏ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⴵⵉⵏⵜ ⵜⴻⵏⵄⴰⵛⵉⵏ, ⴰⵙⴻⵎ-ⴷⴷ, ⵙⵖⴻⵎ, ⵛⵛⴻⵎ, ⵡⴰⵀ, ⴰⵙⴻⵎ-ⴷⴷ ⵓⵛⴰ ⵙⵖⴻⵎ ⴱⵉⵏⵓ ⴷ ⵓⵖⵉ, ⴱⵍⴰ ⵜⵉⵏⵄⴰⵛⵉⵏ ⵓ ⴱⵍⴰ ⵜⵜⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS55_2","024_55_2","ISA","55","2","2","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵡⴻⵣⵣⵏⴻⵎ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⴰⵖⵔⵓⵎ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵜⵊⴻⵀⴷⴻⵎ ⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵊⵊⵉⵡⵏⴻⵏ? ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵎⵍⵉⵃ, ⵛⵛⴻⵎ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⵓⵛⴰ ⴻⵊⵊ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ ⴰⴷ ⵉⵖⴻⴱⴱⴰ ⵜⴰⴷⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("IS55_3","024_55_3","ISA","55","3","3","ⵡⵛⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ ⵓⵛⴰ ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵙⵍⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⴷⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏ ⵍⴰⵎⴰⵏ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("IS55_4","024_55_4","ISA","55","4","4","ⵅⵣⴰⵔ, ⴳⴳⵉⵖ ⵜ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵉ ⵛⵛⵓⵄⵓⴱ, ⴷ ⵍⵃⴰⴽⴻⵎ, ⴷ ⴱⴰⴱ ⵏ ⵍⵓⵎⵓⵔ ⵉ ⵛⵛⵓⵄⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("IS55_5","024_55_5","ISA","55","5","5","ⵅⵣⴰⵔ, ⴰⴷ ⵜⵍⴰⵖⵉⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ, ⵓ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵉⵏⴻⵏ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵄⵓⴵⴰ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("IS55_6","024_55_6","ISA","55","6","6","“ⴰⵔⵣⵓⵎ ⵅ ⵙⵉⴷⵉ ⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵊⵊⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⴼ, ⵍⴰⵖⴰⵎ ⴰⵙ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("IS55_7","024_55_7","ISA","55","7","7","ⴻⵊⵊ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵉⵙⵎⴻⵃ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵏ ⵍⵖⴻⵛⵛ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵙ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵣⵣⵉⴵⴻⵣ, ⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵖⴻⴼⴼⴰⵔ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS55_8","024_55_8","ISA","55","8","8","ⵎⴰⵖⴰⵔ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⴵⵉⵏ ⴰⵎ ⵢⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵏⵡⴻⵎ ⵓ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⴵⵉⵏ ⴰⵎ ⵢⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS55_9","024_55_9","ISA","55","9","9","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵄⵍⴰⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵢⵓⵄⵍⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵓ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵏⵓ ⵅ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS55_10","024_55_10","ISA","55","10","10","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰ ⵡⴻⵏⵥⴰⵔ ⴷ ⵡⴻⴷⴼⴻⵍ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵛⴰ, ⵎⴰⵛⴰ ⵉⵙⵙⵓⴼⴼⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵛⴰ ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ, ⴰⴷ ⵜⴰⵡⵉ ⴰⵖⴻⵎⵎⵓⵢ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵜⵜⵉⵛ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵡⴻⵏⵏⵉ ⵉⵥⴰⵔⵔⵄⴻⵏ ⴷ ⵡⴻⵖⵔⵓⵎ ⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS55_11","024_55_11","ISA","55","11","11","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵉ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵉⵅⵡⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⵎⵉⵏ ⵅⵙⴻⵖ ⵓ ⴰⴷ ⵢⴰⵡⴻⴹ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔ ⵜ ⵙⵙⴻⴽⴽⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS55_12","024_55_12","ISA","55","12","12","“ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⴷⵉ ⵍⴻⵀⵏⴰ. ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵡⵔⵉⵔⵉⵏ ⴰⴷ ⴷⴷⵓⵇⵇⵣⴻⵏ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵡⵜⴻⵏⵜ ⵛⴰⵎⵅⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS55_13","024_55_13","ISA","55","13","13","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵙⴻⵏⵏⴰⵏ ⴰⴷ ⵜⴻⵖⵎⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⴰⴷ ⵜⴻⵖⵎⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴰⵔⵉⵃⴰⵏⵜ. ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵙⵉⴷⵉ, ⵉ ⵛⵛⴰⵏ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⴻⴱⴷⴰ ⵉ ⵡⴰⵔ ⵉⵎⴻⵃⵃⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("IS56_1","024_56_1","ISA","56","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵃⴹⴰⵎ ⵍⵃⴻⵇⵇ ⵓⵛⴰ ⴳⴳⴻⵎ ⵜⴰⵙⴻⴳⴷⴰ, ⵎⵉⵏⵣⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ ⵢⵓⴷⴻⵙ-ⴷⴷ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴻⵖⵢⴰ, ⵓⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵉⵏⵓ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("IS56_2","024_56_2","ISA","56","2","2","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵉⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS56_3","024_56_3","ISA","56","3","3","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵙⵉⴷⵉ ⵉⵄⵣⴻⵍ ⴰⵢⵉ ⵇⴰⵄ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ!’, ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵉⵎⴻⴵⴰⵍⴻⵏ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵢⵓⵥⵖⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("IS56_4","024_56_4","ISA","56","4","4","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵉⵎⴻⴵⴰⵍⴻⵏ, ⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ ⵓ ⵜⵜⵉⵅⴹⴰⵔⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴹⴰ ⵉⵏⵓ ⵓ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ: ");
INSERT INTO rift_vpl VALUES ("IS56_5","024_56_5","ISA","56","5","5","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵖ ⴰⵎⵛⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⵊⴰⵔ ⵍⴻⵃⵢⵓⴹ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵉⵙⴻⵎ ⵃⵙⴻⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵉⵙⴻⵎ ⵏ ⵍⴻⴱⴷⴰ ⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵎⴻⵃⵃⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS56_6","024_56_6","ISA","56","6","6","ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵏⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵅⵙⴻⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ - ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵉⵜ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵎⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ - ");
INSERT INTO rift_vpl VALUES ("IS56_7","024_56_7","ISA","56","7","7","ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⴼⵔⴰⵃⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵏ ⵜⵥⴰⴵⵉⵜ. ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⴰⵔⴹⴰ ⵉⵏⵓ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵥⴰⴵⵉⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ.’” ");
INSERT INTO rift_vpl VALUES ("IS56_8","024_56_8","ISA","56","8","8","“ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵙⵙⵎⵓⵏⴰⵏ ⵉⵏⵏⵉ ⵅ ⵢⵓⵥⵥⵍⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵙⵙⵎⵓⵏⴻⵖ ⴽⵜⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵖⴰⵔⴻⵙ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("IS56_9","024_56_9","ISA","56","9","9","“ⵎⴰⵔⵔⴰ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ, ⴰⵙⴻⵎ-ⴷⴷ ⵉ ⵎⴰⵛⵛⴰ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵡⴻⵣⵖⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("IS56_10","024_56_10","ISA","56","10","10","ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏⵏⴻⵙ ⴷⴷⴰⵔⵖⵍⴻⵏ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵡⴰⵍⵓ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵟⴰⵏ ⵉⴱⴻⴽⵎⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵓⵏ, ⵟⵟⵙⴻⵏ, ⵣⵣⵍⴻⵏ, ⵜⵜⴻⵅⵙⴻⵏ ⴰⵏⵓⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS56_11","024_56_11","ISA","56","11","11","ⵉⵟⴰⵏ-ⴰ ⴰⵔⵊⴼⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵜⴰⵢⴰⵡⴰⵏⵜ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵡⴰⵔ ⵉⴼⴻⵀⵀⵎⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴹⴻⴼⴼⴰⵔ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⴽⵓⵍ ⵉⵊⵊ ⵢⴰⵔⴻⵣⵣⵓ ⵜⵉⵣⵉ ⵏⵏⴻⵙ, ⵄⴰⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⴳⴳⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS56_12","024_56_12","ISA","56","12","12","ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵙⴻⵜⵜⵉⵡ-ⴷⴷ, ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴱⵉⵏⵓ, ⴰⴷ ⵏⴻⵙⵛⴰⵔ ⵙ ⵛⵛⵔⴰⴱ. ⴰⵎ ⵡⴰⵙⵙ-ⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵜⵉⵡⴻⵛⵛⴰ, ⴰⴷ ⵢⵉⵍⵉ ⵄⴰⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵉⵛⵏⴰⵏ ⵅⴰⵙ!’” ");
INSERT INTO rift_vpl VALUES ("IS57_1","024_57_1","ISA","57","1","1","“ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⵉ ⵜ ⵉⵜⵜⴽⴻⵙⵙⵉⵏ ⵖⴰⵔ ⵡⵓⵍ. ⵉⵔⵢⴰⵣⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵎⵎⴻⴽⵙⵉⵏ, ⴱⵍⴰ ⵎⴰ ⵉⵃⴻⵟⵟⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⵇⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵎⵎⴻⴽⵙⵉ ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴰⵙⵙ ⵏ ⵍⵎⵓⵚⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("IS57_2","024_57_2","ISA","57","2","2","ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ ⴷⵉ ⵍⴻⵀⵏⴰ, ⴰⴷ ⴰⵔⵔⴻⵢⵃⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵇⴰⵎⴰⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵉⵙⴻⴳⴳⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS57_3","024_57_3","ISA","57","3","3","“ⵇⴰⵔⵔⴱⴻⵎ-ⴷⴷ ⴷⴰ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⴱⴻⵣⴳⵉⵡⵜ, ⵜⴰⵔⵡⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ ⵓ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ! ");
INSERT INTO rift_vpl VALUES ("IS57_4","024_57_4","ISA","57","4","4","ⵡⵉ ⵣⵉ ⵜⴻⵙⵜⴻⵀⴻⵣⵣⴰⵎ ⴰⵎⵎⵓ, ⵡⵉ ⵅ ⵜⵛⴰⵔⵔⴰⴳⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵓ ⵡⵉ ⵖⴰⵔ ⵜⵊⴻⴱⴱⴷⴻⵎ ⵉⵍⴻⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵄⴻⴷⴷⵉ, ⵜⴰⵔⵡⴰ ⵏ ⵍⵖⴻⵛⵛ? ");
INSERT INTO rift_vpl VALUES ("IS57_5","024_57_5","ISA","57","5","5","ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵀⴰⵊⴻⵏ ⵖⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵖⴰⵔⵔⵚⴻⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ, ⵙⵡⴰⴷⴷⴰⵢ ⴷⵉ ⵜⴻⵣⵣⵉⵢⵉⵏ ⵏ ⵍⴻⵊⵔⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("IS57_6","024_57_6","ISA","57","6","6","ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵎ ⵖⴰⵔ ⵉⵥⵔⴰ ⵉⵢⵓⵢⴷⴰⵏ ⵏ ⵜⴻⵖⵣⵓⵔⵉⵏ. ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵎ ⴷⴷ-ⵢⴻⴽⴽⴰⵔⴻⵏ. ⵓⵍⴰ ⵉ ⵏⵉⵜⵏⵉ ⵜⵣⴻⴵⵄⴻⴷ ⴰⵙⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⵜⵡⴻⵀⵀⴱⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ. ⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵙⵇⴰⵔⴻⵖ ⵅ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("IS57_7","024_57_7","ISA","57","7","7","“ⵅ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴻⵙⵙⵓⴷ ⵇⴰⵎⴰ ⵏⵏⴻⵎ. ⵓⵍⴰ ⴷⵉⵏⵏⵉ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴻⵀⵀⴱⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("IS57_8","024_57_8","ISA","57","8","8","ⴰⵡⴰⵔⵏⵉ ⵜⴻⵡⵡⴰⵔⵜ ⴷ ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵜⴻⴳⴳⵉⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⴻⵎ ⵏ ⵍⵉⴷⴰⵔⴻⵜ, ‘ⵎⵣⵓⵣⴰ ⵏⵏⴻⵎ’, ⵎⴰⵖⴰⵔ ⵛⴻⵎ ⵜⴻⵏⵄⴻⵣⵍⴻⴷ ⵅⴰⴼⵉ ⴷ ⵜⴰⵄⴰⵔⵢⴰⵏⵜ ⵓ ⵜⴳⴻⵄⵄⴷⴻⴷ ⴷⵉⵏⵏⵉ ⵙⴻⵏⵏⴻⵊ. ⵜⵄⴻⴷⵍⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵇⴰⵎⴰ ⴷ ⵜⵎⵉⵔⵉⵡⵜ ⵓⵛⴰ ⵜⵄⴰⵀⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⴽ-ⴷ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ. ⵜⴻⵜⵜⴻⵅⵙⴻⴷ ⵜⴰⵙⵙⵓⵜ ⵏⵙⴻⵏ, ⵜⴻⵥⵔⵉⴷ ⵜⴰⵔⵢⴰⵙⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS57_9","024_57_9","ISA","57","9","9","ⴰⴽ-ⴷ ⵣⵣⴻⵛⵜ ⵜⵔⵓⵃⴻⴷ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵜⴰⵔⵏⵉⴷ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⴻⵄⵟⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵏⵏⴻⵎ. ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵓⵛⴰ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⵍ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS57_10","024_57_10","ISA","57","10","10","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵙⴰⴳⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵜⵓⵃⵍⴻⴷ, ⵎⴰⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵍⴰⵢⴰⵙ!’ ⵜⵓⴼⵉⴷ ⵊⵊⴻⵀⴷ ⵏ ⵊⴷⵉⴷ ⵉ ⵜⵓⴷⴰⵔⵜ. ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵜⴻⵃⵍⵉⵛⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("IS57_11","024_57_11","ISA","57","11","11","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵜⴻⵙⵙⵃⵉⵙⵙⴼⴻⴷ ⵓ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ ⴰⵇⴰ ⵛⴻⵎ ⵜⴻⵙⵙⵅⴰⵔⵔⵇⴻⴷ ⵅⴰⴼⵉ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵉⴷⴰⵔⴻⴷ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵎ? ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵏⴻⵛⵛ ⵙⵙⴻⵖⴷⴻⵖ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⴰⵍⴰⵎⵉ ⵛⴻⵎ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⴻⴳⴳⵯⵉⴷⴻⴷ ⵛⴰ ⵄⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("IS57_12","024_57_12","ISA","57","12","12","“ⵏⴻⵛⵛ ⴰⴷ ⵄⴰⵡⴷⴻⵖ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵎ: ⵡⴰⵔ ⵛⴻⵎ ⵏⴻⴼⴼⵄⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("IS57_13","024_57_13","ISA","57","13","13","ⵅⵎⵉ ⵖⴰ ⵜⵍⴰⵖⵉⴷ, ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴳⵔⴰⵡ ⵏⵏⴻⵎ ⵉ ⵖⴰⵔⴻⵎ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⴰⴷ ⵛⴻⵎ ⵉⴼⴻⴽⴽ. ⴰⵙⴻⵎⵎⵉⴹ ⴰⴷ ⵜⴻⵏ ⵢⴰⵡⵉ ⵎⴰⵔⵔⴰ, ⵉⵊⵊ ⵏ ⵓⵙⵓⴹⵉ ⴰⴷ ⵜⴻⵏ ⵉⴽⵙⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔⵉ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ, ⴰⴷ ⵉⵡⴰⵔⵜ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS57_14","024_57_14","ISA","57","14","14","“ⴰⴷ ⵢⵉⵏⵉ: ‘ⵙⴳⴻⵄⵄⴷⴻⵎ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⴰⴱⵔⵉⴷ, ⴽⵙⴻⵎ ⵎⵉⵏ ⵉⵙⵙⴻⵏⵇⵔⴰⴹⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("IS57_15","024_57_15","ISA","57","15","15","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵡⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⴱⴷⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵇⴰ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵉⴵⴰ: ‘ⵏⴻⵛⵛ ⵣⴻⴷⴷⵖⴻⵖ ⴷⵉ ⵍⵓⵄⵍⴰ ⵓ ⴷⴻⴳ ⵡⴻⵇⴷⴰⵙ ⵓ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵔⵥ ⴱⵓⵃⴱⴻⵍ ⵓ ⵖⴰⵔ ⵓⵎⵡⴰⴹⴻⵄ ⵏ ⴱⵓⵃⴱⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵔⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵎⵡⴰⴹⵄⴻⵏ ⴷ ⵡⵓⵍ ⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵥⵉⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("IS57_16","024_57_16","ISA","57","16","16","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵖ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴰⴷ ⵢⴰⵔⵅⵓ ⴽⵓⵍ ⴱⵓⵃⴱⴻⵍ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⴳⴳⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("IS57_17","024_57_17","ISA","57","17","17","“ⵏⴻⵛⵛ ⴼⴼⵓⴳⵎⴻⵖ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵔⴱⴻⵃ ⵓⵛⴰ ⵡⵜⵉⵖ ⵍⴳⴻⵏⵙ. ⵏⴻⵛⵛ ⵏⵏⵓⴼⴼⴰⵔⴻⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ. ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵢⵓⵢⵓⵔ, ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS57_18","024_57_18","ISA","57","18","18","“ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵙⵙⴳⴻⵏⴼⵉⵖ, ⴰⴷ ⵜ ⵙⵙⵇⴻⴱⴱⴹⴻⵖ, ⴰⴷ ⴰⵙ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵉⴼⴻⵡⵡⴰⵊⴻⵏ, ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵛⴻⴹⵏⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS57_19","024_57_19","ISA","57","19","19","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ ⵍⵖⵉⴵⴻⵜ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ. ‘ⵍⴻⵀⵏⴰ, ⵍⴻⵀⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS57_20","024_57_20","ISA","57","20","20","ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴳⴳⵉⵏ ⴰⵎ ⵍⴻⴱⵃⴰⵔ ⵉⵏⵏⵀⴻⵡⵍⴻⵏ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⴰⵔⵙⴰ, ⵓⵛⴰ ⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⴱⴰⵔⵢⵓⴹ ⴷ ⵓⴱⴻⴵⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("IS57_21","024_57_21","ISA","57","21","21","ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵍⴻⵀⵏⴰ!, ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS58_1","024_58_1","ISA","58","1","1","“ⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ, ⵡⴰⵔ ⵜⵜⵛⴻⵟⵟⴰⵔ, ⴻⵊⵊ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⴱⴰⵔⵔⴻⵃ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ ⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("IS58_2","024_58_2","ISA","58","2","2","ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⴼⵉ ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ ⵓⵛⴰ ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ, ⴰⵎⴻⵛⵏⴰⵡ ⴵⴰⵏ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵍⵃⴻⵇⵇ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⵉ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("IS58_3","024_58_3","ISA","58","3","3","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵏⵥⵓⵎⵎ, ⵓⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜ ⵜⴻⵥⵔⵉⴷ? ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵙⵙⴻⵛⴹⴰⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵖ ⴰⵎ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵃⴻⴽⴽⴰⵔⴻⴷ?’ ⵅⵣⴰⵔ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵥⵓⵎⵎⵉ ⵏⵡⴻⵎ, ⵜⴰⵔⵔⵉⵎ ⵎⴻⵥⵔⵉ ⵓⵛⴰ ⵜⵣⴻⵢⵢⴰⵔⴻⵎ ⴰⵟⵟⴰⵙ ⵎⴰⵔⵔⴰ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS58_4","024_58_4","ISA","58","4","4","ⵅⵣⴰⵔ, ⴰⵥⵓⵎⵎⵉ ⵏⵡⴻⵎ ⵢⵉⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴷ ⵓⵎⴻⵏⵖⵉ, ⵖⴰⵔ ⵜⵉⵢⵢⵉⵜⴰ ⵙ ⵍⴱⵓⵏⵉⵢⵢⴻⵜ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ. ⵡⴰⵔ ⵜⵜⵥⵓⵎⵎⴻⵎ ⴰⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵙⵙ-ⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵜⵎⵉⵊⵊⴰ ⵏⵡⴻⵎ ⴷⵉ ⵍⵓⵄⵍⴰ! ");
INSERT INTO rift_vpl VALUES ("IS58_5","024_58_5","ISA","58","5","5","ⵎⴰ ⵡⴰ ⴷ ⴰⵥⵓⵎⵎⵉ ⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵖ ⵏⴻⵛⵛ: ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵉⵄⴻⴷⴷⴻⴱ ⴱⵏⴰⴷⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵅ ⵉ ⵖⴰ ⵉⵎⴻⵢⵢⴻⵍ ⴱⵏⴰⴷⴻⵎ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵎ ⵓⵖⴰⵏⵉⵎ, ⵓ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵢⵉⵖⵖⴻⴹ ⴰⵎ ⵇⴰⵎⴰ ⵏⵏⴻⵙ? ⵎⴰ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵉ ⵓⵢⴰ ⴰⵥⵓⵎⵎⵉ, ⵎⴰ ⴰⵢⴰ ⴷ ⴰⵙⵙ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("IS58_6","024_58_6","ISA","58","6","6","“ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰ ⴷ ⴰⵥⵓⵎⵎⵉ ⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵖ: ⴰⴼⴻⴽⴽⵉ ⵏ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵍⵖⴰⵔ, ⴰⵣⴻⵄⵡⴰⴹ ⵏ ⵜⴻⵙⵖⵓⵏⵉⵏ ⵏ ⵣⵣⴰⵢⵍⴻⵜ, ⴰⵏⵓⴼⵙⴻⵍ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵜⴻⴽⴽⵙⴻⵎ ⵇⴰⵄ ⵣⵣⴰⵢⵍⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("IS58_7","024_58_7","ISA","58","7","7","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰ ⴷ ⴰⵥⵓⵎⵎⵉ ⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵖ, ⴰⵇⴰ ⴰⴷ ⵜⴻⴱⴹⵉⴷ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⵓⵣⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵉⴷⴼⴻⴷ ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴷⴰⵔⵔⵛⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ? ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⴰⴷ ⵜ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⴷ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵏⵓⴼⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("IS58_8","024_58_8","ISA","58","8","8","ⵅⴻⵏⵏⵉ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵛ ⴰⴷ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⴰⵎ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⵃⴰⵍ ⵓⵛⴰ ⴰⵙⴳⴻⵏⴼⵉ ⵏⵏⴻⵛ ⴰⴷ ⴷⴷ-ⵢⴰⵡⴻⴹ ⴷⴻⵖⵢⴰ, ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ ⴰⴷ ⴰⵛ ⵜⵉⵣⵡⴰⵔ ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ ⴰⵏⴻⴳⴳⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS58_9","024_58_9","ISA","58","9","9","“ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵍⴰⵖⵉⴷ ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵢⴰⵔⵔ. ⴰⴷ ⵜⴻⵙⵖⵓⵢⴻⴷ ⵖⴰⵔ ⵜⵡⵉⵣⴰ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⵏⴻⵜⵜⴰ: ‘ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!’ ⵎⴰⵍⴰ ⵏⵉⵛⴰⵏ ⵜⴻⴽⴽⵙⴻⴷ ⵣⵣⴰⵢⵔⴻⵜ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⴰⵛⴻⵢⵢⴰⵔ ⵙ ⵓⴹⴰⴹ ⴷ ⵡⴰⵡⴰⵍ ⴰⵄⴻⴼⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("IS58_10","024_58_10","ISA","58","10","10","ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵣⵎⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ ⵓ ⴰⴷ ⵜⴻⵙⵙⵊⵊⵉⵡⵏⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵛⴻⴹⵏⴻⵏ! ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵛ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵓⵛⴰ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵟⵟⵢⴰ ⵏ ⵓⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS58_11","024_58_11","ISA","58","11","11","ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵜⵜⴳⴻⵡⵡⴰⴷ ⵍⴻⴱⴷⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵊⵊⵉⵡⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵢⵓⵥⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴰⵎ ⵡⴻⵃⵡⵉⵛ ⵉⵜⵜⵡⴰⵙⵙⵓⵏ ⵓ ⴰⵎ ⵍⵄⵓⵏⵚⴰⵔ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵏ ⵡⴰⵎⴰⵏ ⵉ ⵡⴰⵔ ⵜⵜⵖⴰⵔⵔⴰⵏ ⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("IS58_12","024_58_12","ISA","58","12","12","ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⴽ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴰⴷ ⵄⴰⵡⴷⴻⵏ ⴰⵙⴱⴻⴷⴷⵉ ⵉ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⴷⵙⵓⵙⴰ ⵏ ⵊⵊⵉⵍⴰⵜ ⵉⵄⴷⵓⵏ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ: ‘ⵡⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵜⴰⵔⴻⵥⵥⵉⵜⵉⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵣⵓⴱⴰⵇ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵓⵢⵓⵔⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("IS58_13","024_58_13","ISA","58","13","13","“ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵜⵇⴻⵍⴱⴻⴷ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵅ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵅ ⵜⴰⴳⴳⵉⵜ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵜⵜⴻⵄⵊⵉⴱⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⵍⴰⵖⵉⴷ ⵉ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ: ‘ⵟⵟⵉⴱⴻⵜ!’, ⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ: ‘ⴰⵄⵓⴵⵉ!’, ⵓⵛⴰ ⴰⴷ ⵜⵡⴻⵇⵇⴰⵔⴻⴷ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⵎ ⵡⴰⵔ ⵜⴹⴻⴼⴼⴰⵔⴻⴹ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵜⵜⴻⵄⵊⵉⴱⴻⵏ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⵉⵍⵉⴷ ⵖⴰⵔ ⵜⵉⵣⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("IS58_14","024_58_14","ISA","58","14","14","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼⴻⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵛ ⴷⵉ ⵙⵉⴷⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵊⵊⴻⵖ ⴰⴷ ⵜⵏⴻⴷⵀⴻⴷ ⵜⵉⵡⴰ ⵉ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵛⵛⴻⵖ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ ⵢⴰⵄⵇⵓⴱ, ⵎⵉⵏⵣⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS59_1","024_59_1","ISA","59","1","1","“ⵅⵣⴰⵔ, ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵇⵓⴹⴰⴹ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ, ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⴷⴷⵓⵀⵛⴰⵔ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("IS59_2","024_59_2","ISA","59","2","2","ⵎⴰⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ ⴷ ⵎⵉⵏ ⵉⵜⵜⴻⵎⵙⴻⴱⴹⴰⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵍⴻⵃⵃⴼⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⴻⵙⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("IS59_3","024_59_3","ISA","59","3","3","ⵎⴰⵖⴰⵔ ⵜⵜⵡⴰⵙⵙⵅⴻⵎⵎⵊⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⴹⴻⵡⴹⴰⵏ ⵏⵡⴻⵎ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵡⴻⵎ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵍⴻⵙ ⵏⵡⴻⵎ ⵉⵏⵟⴻⵇ ⵙ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS59_4","024_59_4","ISA","59","4","4","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵙⵙⵎⵓⵏⴰ ⵙ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴻⵄ ⵙ ⵍⵃⴻⵇⵇ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵄⴻⵎⵎⴷⴻⵏ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴱⴰⵟⴻⵍ ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ⴰⵇⴰ ⴽⴻⵙⵙⵉⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓ ⵜⵜⴰⵔⵡⴻⵏ-ⴷⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS59_5","024_59_5","ISA","59","5","5","ⵃⴻⴱⴹⴻⵏ ⵅ ⵜⵎⴻⴵⴰⵍⵉⵏ ⵏ ⵜⵍⴻⴼⵙⴰ ⵓ ⵣⴻⵟⵟⴻⵏ ⴰⵅⵎⴰⵍ ⵏ ⵇⵓⵏⴷⵄⴰ. ⵡⴻⵏⵏⵉ ⵉⵛⵛⴻⵏ ⵣⵉ ⵜⵎⴻⴵⴰⵍⵉⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵉⵎⵎⴻⵜ, ⵓ ⵅⵎⵉ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵉⵊⵊ ⵉⵛⵜⴻⵏ, ⵜᵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵜⴼⵉⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS59_6","024_59_6","ISA","59","6","6","ⵉⵅⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⵉ ⵡⴻⵔⵔⵓⴹ ⵓⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵔⴹⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ⵎⵉⵏ ⴳⴳⵉⵏ ⴰⵇⴰ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓⵍⴰ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵍⴻⵅⵛⵓⵏⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS59_7","024_59_7","ISA","59","7","7","ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵛⵛⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴰⵔⴻⴷⴷⴻⴵ ⴷ ⵓⴽⴻⵀⵀⴻⴹ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵉⵡⴰⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS59_8","024_59_8","ISA","59","8","8","ⴰⴱⵔⵉⴷ ⵏ ⵍⴻⵀⵏⴰ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵏ ⵓ ⵍⴰⵜⴰⵔⴰⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⵡⴰⵍⵓ ⵏ ⵍⵃⴻⵇⵇ. ⵏⵉⵜⵏⵉ ⵙⵙⴼⴰⵔⵔⴰⵖⴻⵏ ⵉⵣⵓⴱⴰⵇ ⵏⵙⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵉⴳⴳⵓⵔⴻⵏ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS59_9","024_59_9","ISA","59","9","9","“ⵅ ⵓⵢⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵍⵃⴻⵇⵇ ⵉⴳⴳⵯⴻⵊ ⵅⴰⵏⴻⵖ ⵓ ⵜⴰⵙⴻⴳⴷⴰ ⵡⴰⵔ ⴷⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵜᵉⵜⵜⵉⴽⴽⵡⵉⴹ. ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵔⴰⵊⴰ ⵜⴰⴼⴰⵡⵜ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵟⵟⵍⴰⵎ, ⵏⵔⴰⵊⴰ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵜⴼⴰⵡⵜ, ⵎⴰⵛⴰ ⵏⵓⵢⵓⵔ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("IS59_10","024_59_10","ISA","59","10","10","ⵏⴻⵜⵜⴼⴰⴼⴰ ⴰⵎ ⵢⵉⴹⴰⵔⵖⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵍⵃⵉⴹ ⵓ ⵏᵉⵜⵜⴻⵎⵀⴰⴼⴰ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ, ⴰⵅⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴵⵉⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ. ⵏⵡⴻⵟⵟⴰ ⴷⵉ ⵟⵟⵃⴰ ⵏ ⵓⵣⵉⵍ ⴰⵅⵎⵉ ⴷⵉ ⵜⴱⴰⵎⴱⴰⵙⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴰⵅⵎⵉ ⵅ ⵉⵎⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS59_11","024_59_11","ISA","59","11","11","ⵏⴻⵛⵛⵉⵏ ⵏⵣⴻⵀⵀⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵎ ⴷⴷⵓⴱⴰⵜ ⵓ ⵏⴻⵜⵜⴳⴻⵔⴳⵓⵔ ⴰⵎ ⵜⵜⴳⴻⵔⴳⵓⵔⴻⵏⵜ ⵜⴻⴷⴱⵉⵔⵉⵏ, ⵏⴻⵜⵜⵔⴰⵊⴰ ⵍⵃⴻⵇⵇ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ, ⵏⴻⵜⵜⵔⴰⵊⴰ ⴰⵙⴻⵏⵊⴻⵎ, ⵎⴰⵛⴰ ⵉⴳⴳⵯⴻⵊ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS59_12","024_59_12","ISA","59","12","12","ⵎⴰⵖⴰⵔ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵇⵉⴱⴰⵍⵜ ⵛⴻⴽ ⵓ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵛⴻⵀⵀⴷⴻⵏ ⵅⴰⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵖ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⵏⴻⵖ ⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵏⴻⵖ ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⵉ-ⵜⴻⵏⵜ: ");
INSERT INTO rift_vpl VALUES ("IS59_13","024_59_13","ISA","59","13","13","ⴰⵄⴻⴷⴷⵉ ⴷ ⵓⵅⴰⵔⵔⴻⵇ ⵅ ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⵃⴻⵢⵢⴻⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵍⵀⴰⵔⴷ ⵅ ⴷⴷⴻⴵ ⴷ ⵓⵖⴻⵡⵡⴻⵖ, ⴰⵃⴰⵡⴻⵍ ⴷ ⵓⵙⵓⴼⴼⴻⵖ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵣⴻⴳ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("IS59_14","024_59_14","ISA","59","14","14","ⵉⵜⵜⵡⴻⵅⵅⴰⵔ ⵍⵃⴻⵇⵇ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵓⵛⴰ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵜⵙⴻⴳⴷⴰ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵎⴰⵖⴰⵔ ⵜⵉⴷⴻⵜⵜ ⵜⴻⵏⵏⴻⴷⵔⴻⴼ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵓⵛⴰ ⵎⵉⵏ ⵉⵙⴻⴳⴳⵎⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("IS59_15","024_59_15","ISA","59","15","15","ⵜⴱⴻⵟⵟⴻⵍ ⵜⵉⴷⴻⵜⵜ ⵓ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ. ⴰⵢⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵙⵉⴷⵉ ⵓⵛⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("IS59_16","024_59_16","ISA","59","16","16","ⵉⵥⵔⴰ ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴱⵀⴻⵜ ⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⴽⵙⵉ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⵉ ⵓⵛⴻⴼⴼⴰⵄ. ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷ ⴰⵄⴻⵎⵎⴻⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS59_17","024_59_17","ISA","59","17","17","ⵉⵙⵙⵢⴰⵔⴹ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴰⵙⴻⴳⴷⴰ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵍⴽⴰⵙⴽ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵡⴻⵅⵍⴰⴼ ⵓⵛⴰ ⵉⵍⴻⵃⵃⴻⴼ ⵙ ⵜⵓⵙⵎⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵉⵍⴻⵃⵃⴻⴼ ⵙ ⵓⵙⴻⵍⵀⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("IS59_18","024_59_18","ISA","59","18","18","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⴷⴰⵀⴵⴻⵏⵜ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵅⵍⴻⴼ ⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ ⵙ ⵡⴻⵙⵄⴰⵔ, ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵢⵓⵙⵉⵏ. ⵜⵉⴳⵣⵉⵔⵉⵏ ⴰⴷ ⵜⴻⵏⵜ ⵉⵡⵛ ⵍⴻⵅⵍⴻⴼ ⵏⵙⴻⵏⵜ ⵉ ⵉⵙⴷⴰⵃⴵⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS59_19","024_59_19","ISA","59","19","19","“ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵎⴰⵏⵉⵙ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ, ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵉⵃⵚⴰⵔⴻⵏ, ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜ ⵉⵄⴰⵔⵏ. ");
INSERT INTO rift_vpl VALUES ("IS59_20","024_59_20","ISA","59","20","20","ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵎⴻⴼⴷⵉ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⵉ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵓⴱⴻⵏ ⵣⴻⴳ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ ⵣⵉ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS59_21","024_59_21","ISA","59","21","21","“ⵡⴰ ⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⴵⴰⵏ, ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵏⵏⵉ ⴳⴳⵉⵖ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⵃⴻⵢⵢⵉⴷⴻⵏ ⵛⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⴵⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ ⵓⵍⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵛ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS60_1","024_60_1","ISA","60","1","1","“ⴽⴽⴰⵔ, ⴻⴳⴳ ⵜⴼⴰⵡⵜ ⵎⴰⵖⴰⵔ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵎ ⵜⵓⵙⴰ-ⴷⴷ ⵓ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵢⴰⵔⴻⵇⵇ ⵜⵉⵡⴰ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS60_2","024_60_2","ISA","60","2","2","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵜⴰⴵⴻⵙⵜ ⴰⴷ ⵜⴷⴻⵍ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⴰⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ ⴰⴷ ⵉⴷⴻⵍ ⵛⵛⵓⵄⵓⴱ, ⵎⴰⵛⴰ ⵜⵉⵡⴰ ⵏⵏⴻⵎ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵙⵉⴷⵉ ⵓ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵜⵉⵡⴰ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS60_3","024_60_3","ISA","60","3","3","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⴰⵙⴻⵏ ⵓ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵖⴰⵔ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵍⴻⴼⵊⴰⵔ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS60_4","024_60_4","ISA","60","4","4","“ⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ, ⵅⵣⴰⵔ ⴷⴰ ⴷ ⴷⵉⵀⴰ, ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ, ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵎ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵢⴻⵙⵙⵉⵎ ⵜⵜⵡⴰⴽⵙⵉⵏⵜ ⵉ-ⴷⴷ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("IS60_5","024_60_5","ISA","60","5","5","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⴷ ⵓ ⴰⴷ ⵜⵙⵉⵇⵙⵉⵇⴻⴷ ⵓⵛⴰ ⵓⵍ ⵏⵏⴻⵎ ⴰⴷ ⵉⵏⵀⴻⵣⵣ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⵓ ⴰⴷ ⵉⵏⵏⵓⵔⵣⴻⵎ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⴰⴳⵍⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⵉⴷⵡⴻⵍ ⵖⴰⵔⴻⵎ, ⴰⴼⴻⵢⵢⴻⵛ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS60_6","024_60_6","ISA","60","6","6","ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵍⴻⵖⵎⴰⵏ ⴰⴷ ⵛⴻⵎ ⵉⴷⴻⵍ, ⵉⵍⴻⵖⵎⴰⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵣⵉ ⵎⵉⴷⵢⴰⵏ ⴷ ⵄⵉⵢⴼⴰ. ⵎⴰⵔⵔⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵛⴰⴱⴰ. ⴰⴷ ⴰⵡⵢⴻⵏ ⵓⵔⴻⵖ ⴷ ⵊⵊⴰⵡⵉ, ⵓⵛⴰ ⴰⴷ ⴱⴻⵛⵛⴰⵔⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵛⵛⴰⵏ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS60_7","024_60_7","ISA","60","7","7","ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⵏ ⵇⵉⴷⴰⵔ ⴰⴷ ⵖⴰⵔⴻⵎ ⵏⵏⵊⴰⵔⵡⴻⵏ. ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵏ ⵏⴰⴱⴰⵢⵓⵜ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵎ. ⴰⴷ ⵜⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵙ ⴰⵔⴹⴰ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵄⵓⴵⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵄⵓⴵⵉ ⵉⵏⵓ ⵙ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS60_8","024_60_8","ISA","60","8","8","“ⵎⴰⵏ ⵉⵏⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵟⵟⴰⵡⴻⵏ ⵖⴰⵔ ⴷⵉⵏⵏⵉ ⴰⵎ ⵢⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⴰⵎ ⵜⴻⴷⴱⵉⵔⵉⵏ ⵖⴰⵔ ⵍⴻⴽⵡⴰⵣⴰ ⵏⵙⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("IS60_9","024_60_9","ISA","60","9","9","ⵡⴰⵀ, ⵜⵉⴳⵣⵉⵔⵉⵏ ⴰⴷ ⴰⵢⵉ ⵍⴰⵊⴰⵏⵜ, ⵓⵛⴰ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⴰⴽ-ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ ⴷ ⵡⵓⵔⴻⵖ ⵏⵙⴻⵏ, ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ, ⵉ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵄⵓⴵⴰ ⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS60_10","024_60_10","ISA","60","10","10","ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⴱⵏⴰⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵓⵛⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⴰⵎ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵡⵜⵉⵖ ⵛⴻⵎ, ⵎⴰⵛⴰ ⴷⵉ ⴰⵔⴹⴰ ⵉⵏⵓ ⵜⴻⵣⵣⵉⴵⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("IS60_11","024_60_11","ISA","60","11","11","ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵎ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⵍⴻⴱⴷⴰ ⴰⵔⵣⵎⴻⵏⵜ. ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⵜⵜⴱⴻⵍⵍⵉⵄⴻⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵎ ⵙⵙⵉⴷⴼⴻⵏ ⴰⴳⵍⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS60_12","024_60_12","ISA","60","12","12","ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⴰⵎ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⴰⴷ ⵀⴻⵍⵍⴽⴻⵏ, ⵓⵛⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("IS60_13","024_60_13","ISA","60","13","13","“ⴰⵛⵓⵡⵡⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵢⴰⵙ, ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ, ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴷⴷⵓⵍⴱ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵎⵓⵏⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⵡⵡⵇⴻⵏ ⴰⵎⵛⴰⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓⵛⴰ ⴰⵎⵛⴰⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵜ ⵙⵙⵄⵓⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS60_14","024_60_14","ISA","60","14","14","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵛⴻⵎ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵓⵡⴰⴹⴻⵄ, ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵎ ⵉⵙⵜⴻⵀⵣⴰⵏ, ⵓⵛⴰ ⴰⴷ ⴰⵎ ⵍⴰⵖⴰⵏ: ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵙⵉⴷⵉ, ⵚⵉⵀⵢⵓⵏ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ’.” ");
INSERT INTO rift_vpl VALUES ("IS60_15","024_60_15","ISA","60","15","15","“ⵉ ⵓⵎⵉ, ⴰⵇⴰ ⵛⴻⵎ ⵜⵓⵖⴰ ⵜⴻⵅⵍⵉⴷ ⴷ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵀⴻⴷ ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⵅⴰⵎ ⵉⵙⵙⵉⵊⵊ, ⴰⴷ ⵛⴻⵎ ⴳⴳⴻⵖ ⴷ ⵍⵄⴻⵣⵣ ⵉⵜⵜⴷⵓⵎⴰⵏ ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("IS60_16","024_60_16","ISA","60","16","16","ⴰⴷ ⵜᵉⵟⵟⴹⴻⴷ ⴰⵖⵉ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵜᵉⵟⵟⴹⴻⴷ ⵖⴰⵔ ⵉⴼⴼⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵎⵙⴻⵏⵊⴰⵎ ⵏⵏⴻⵎ ⴷ ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵎ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵏ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("IS60_17","024_60_17","ISA","60","17","17","“ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵏⵏⵃⴰⵙ ⴰⴷ ⴰⵡⵢⴻⵖ ⵓⵔⴻⵖ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏⵏⵓⵇⴰⵔⵜ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵃⴰⵙ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⴻⵥⵔⴰ ⵓⵣⵣⴰⵍ. ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵀⵏⴰ ⴷ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵏⵏⴻⵎ ⵓⵍⴰ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS60_18","024_60_18","ISA","60","18","18","ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵏ ⵄⴰⴷ ⵅ ⵍⵄⵓⵏⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ, ⵓⵍⴰ ⵅ ⵡⴰⵔⴻⴷⴷⴻⴵ ⴷ ⵓⵅⴰⵔⵔⴻⴱ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⴻⵎ. ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⴰⴷ ⴰⵙⴻⵏ ⵉⵏⵉⵏ: ‘ⴰⵙⴻⵏⵊⴻⵎ!’, ⵓ ⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵎ: ‘ⵜⴰⵚⴻⴱⴱⵉⵃⵜ!’. ");
INSERT INTO rift_vpl VALUES ("IS60_19","024_60_19","ISA","60","19","19","ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵜⴼⵓⵛⵜ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵎ ⴷⴻⴳ ⵓⵣⵉⵍ ⵓ ⵜⴰⵣⵉⵔⵉ ⵡⴰⵔ ⴷ ⴰⵎ ⵜᵉⵜⵜⵉⵛ ⵄⴰⴷ ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⴰⵎ ⵢⵉⵍⵉ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏ ⵍⴻⴱⴷⴰ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵀⵣⵓⵟ ⵏⵏⴻⵎ ⵉⵛⵏⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("IS60_20","024_60_20","ISA","60","20","20","ⵜⴰⴼⵓⵛⵜ ⵏⵏⴻⵎ ⵡⴰⵔ ⵜⵖⴻⴵⵉ ⵄⴰⴷ ⵓ ⵜⴰⵣⵉⵔⵉ ⵏⵏⴻⵎ ⵡⴰⵔ ⵜⵏⴻⵇⵇⴻⵚ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵎ ⵏ ⵍⴻⴱⴷⴰ ⵓⵛⴰ ⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⴹⴰⵏ ⵏⵏⴻⵎ ⴰⴷ ⵇⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS60_21","024_60_21","ISA","60","21","21","ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ: ⵜⴰⵖⴻⴷⴷⵓⵜ ⵉ ⵥⵥⵓⵖ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ-ⵜⴻⵏ ⵉ ⵍⵄⴻⵣⵣ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("IS60_22","024_60_22","ISA","60","22","22","ⴰⵎⴻⵥⵢⴰⵏ ⵇⴰⵄ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵍⴻⴼ ⵓ ⴰⵎⵓⵇⵍⵉⵍ ⵇⴰⵄ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵍⴳⴻⵏⵙ ⵉⵊⵀⴻⴷ, ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵏⴻⴷⵀⴻⵖ ⴷⴻⵖⵢⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴻⴹ ⵍⵃⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("IS61_1","024_61_1","ISA","61","1","1","“ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ, ⵙⵉⴷⵉ, ⵅⴰⴼⵉ ⵎⵉⵏⵣⵉ ⵉⴷⵀⴻⵏ ⴰⵢⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵎⵡⴰⴹⵄⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴼⵏⴻⵖ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵔⵥ ⵓⵍ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵜⵍⴻⵍⵍⵉ ⵉ ⵉⵎⴻⵃⴱⴰⵙ ⴷ ⵓⵏⵓⴼⵙⴻⵍ ⵣⵉ ⵍⴻⵃⴱⴻⵙ ⵉ ⵢⵉⵏⵏⵉ ⵉⵛⴰⵔⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS61_2","024_61_2","ISA","61","2","2","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⴰⵔⴹⴰ ⵉ ⵙⵉⴷⵉ ⴷ ⵡⴰⵙⵙ ⵏ ⵡⴻⵅⵍⴰⴼ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵛⴻⴹⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS61_3","024_61_3","ISA","61","3","3","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵉ ⵢⵉⵏⵏⵉ ⵉⵛⴻⴹⵏⴻⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⴰⵇⴰ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵏ ⵍⴻⵀⵣⵓⵟ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵢⵉⵖⵖⴻⴹ, ⵣⵣⴻⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴻⵛⴹⴰⵏ, ⴰⵔⵔⵓⴹ ⵏ ⵓⵙⴻⵎⵖⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵜⵜⵡⴰⵔⵥⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵍⴰⵖⴰⵏ ‘ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⴳⴳ ⵏ ⵜⵙⴻⴳⴷⴰ!’, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵥⵥⵓⵏ ⵣⵉ ⵙⵉⴷⵉ, ⵉ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("IS61_4","024_61_4","ISA","61","4","4","“ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵉⵀⴻⴷⵎⴻⵏ ⵏ ⵊⵊⵉⵍⴰⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵣⵡⴰⵔⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⵅⴰⵔⵔⴱⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵀⴻⴷⵎⴻⵏ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS61_5","024_61_5","ISA","61","5","5","ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵡⴻⵊⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵓⴵⵉ ⵏⵡⴻⵎ, ⵓⵛⴰ ⵉⵖⵔⵉⴱⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⴼⴻⴵⴰⵃⴻⵏ ⵏⵡⴻⵎ ⴷ ⴰⵢⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS61_6","024_61_6","ISA","61","6","6","ⵎⴰⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵍⴰⵖⴰⵏ ‘ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵙⵉⴷⵉ!’ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵏ ‘ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!’. ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⴳⵍⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⵜⴼⴻⵢⵢⵛⴻⵎ ⵙ ⵓⵄⵓⴵⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS61_7","024_61_7","ISA","61","7","7","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵙⴻⴹⵃⵉ ⵏⵡⴻⵎ, ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ. ⵙ ⵓⵢⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("IS61_8","024_61_8","ISA","61","8","8","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵜⵜⴻⵅⵙⴻⵖ ⵍⵃⴻⵇⵇ, ⵛⴰⵔⵔⵀⴻⵖ ⵜⵓⴽⴽⴰⵔⴹⴰ ⵙ ⵍⵄⵓⵏⴼ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵍⵎⵓⵏⴻⵜ ⴷⵉ ⵍⴰⵎⴰⵏ, ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵇⵇⵏⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS61_9","024_61_9","ISA","61","9","9","ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵥⴰⵔⴻⵏ, ⴰⴷ ⵇⴻⵏⵄⴻⵏ ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS61_10","024_61_10","ISA","61","10","10","“ⴼⴰⵔⵃⴻⵖ ⴰⵟⵟⴰⵙ ⴷⵉ ⵙⵉⴷⵉ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⴼⴰⵔⵃ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵢⴰⵔⴹ ⴰⵢⵉ ⴰⵔⵔⵓⴹ ⵏ ⵓⵙⴻⵏⵊⴻⵎ, ⵓ ⵙ ⵓⵙⴻⵍⵀⴰⵎ ⵏ ⵜⵙⴻⴳⴷⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵍⴻⵃⵃⴻⴼ, ⴰⵎ ⵎⵓⵍⴰⵢ ⵉ ⵉⵇⵇⵏⴻⵏ ⴰⵔⴻⵥⵥⴻⵜ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵓ ⴰⵎ ⵜⴻⵙⵍⵉⵜ ⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵍⴻⵀⵣⵓⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("IS61_11","024_61_11","ISA","61","11","11","ⵎⴰⵖⴰⵔ ⴰⵎ ⵜⴻⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⴻⵊⵊⴰ ⴰⵖⴻⵎⵎⵓⵢ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓ ⴰⵎ ⵡⴻⵃⵡⵉⵛ ⵉⵙⵙⵖⴻⵎⵎⴰⵢ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵣⴰⵔⵔⵄⴻⵏ, ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵉⵙⵙⴻⵖⵎⴰⵢ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵛⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS62_1","024_62_1","ISA","62","1","1","“ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵚⵉⵀⵢⵓⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⴻⵖⴷⴻⵖ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵡⴰⵔ ⵜⵜⴻⵙⵇⵉⵔⵉⵖ, ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴻⵏⵇⴰⵔ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⴰⵎ ⵜⵉⵙⵙⵉⵇⵜ ⵓ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ ⴰⵎ ⵡⴻⵙⴼⴻⴹ ⵢⴰⵔⴻⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS62_2","024_62_2","ISA","62","2","2","ⴰⴷ ⵥⴰⵔⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵎ ⵓ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵎ. ⴰⴷ ⴰⵎ ⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵊⴷⵉⴷ ⵏⵏⵉ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵉⴳⴳⴰ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS62_3","024_62_3","ISA","62","3","3","ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵜⵜⴰⵊ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵓⵍⴰ ⴷ ⴰⵔⴻⵥⵥⴻⵜ ⵉⴳⴻⵍⵍⴷⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS62_4","024_62_4","ISA","62","4","4","ⵡⴰⵔ ⴷ ⴰⵎ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ‘ⵜⴻⵏⵏⵉ ⴷⵉ ⵙⴻⵎⵃⴻⵏ!’ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ‘ⵜⴰⵎⵎⵓⵔⵜ ⵉⵅⵍⴰⵏ!’, ⵎⴰⵛⴰ ⴰⴷ ⴰⵎ ⵍⴰⵖⴰⵏ ‘ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ!’, ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ‘ⵜⴰⵏⴻⵎⵍⴰⵛⵜ!’, ⵎⴰⵖⴰⵔ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⵉ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS62_5","024_62_5","ISA","62","5","5","ⵎⴰⵖⴰⵔ ⴰⵎ ⵓⵄⴻⵣⵔⵉ ⵉⵎⵍⴻⵛ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⴰⵎⵎⵓ ⵉ ⴽⵉⴷⴻⵎ ⵖⴰ ⵎⴻⵍⵛⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ, ⵓⵛⴰ ⴰⵎ ⵎⵓⵍⴰⵢ ⵉⴼⴰⵔⵔⴻⵃ ⵉ ⵜⴻⵙⵍⵉⵜ, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵎ ⵖⴰ ⵉⴼⴰⵔⵃ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS62_6","024_62_6","ISA","62","6","6","“ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵅ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵖⵉⴷⵉⵏ ⵍⴻⴱⴷⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵄⴻⵇⵇⵍⴻⵏ ⵅ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⴰⵔⴻⵢⵢⵃⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("IS62_7","024_62_7","ISA","62","7","7","ⵡⴰⵔ ⵜⵜⴰⵔⴻⵢⵢⵃⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ⴰⵍ ⴷⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷ ⴰⵚⴻⴱⴱⴻⵃ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("IS62_8","024_62_8","ISA","62","8","8","ⵙⵉⴷⵉ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓ ⵖⴰⵔ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ: ‘ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵡⵛⴻⵖ ⵉⵎⴻⵏⴷⵉ ⵏⵏⴻⵎ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵎ, ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵙⵙⴻⵙⵡⴻⵖ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴱⵉⵏⵓ ⵏⵏⴻⵎ ⵏ ⵊⴷⵉⴷ ⵉ ⵅ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵎⴰⵔⴰ! ");
INSERT INTO rift_vpl VALUES ("IS62_9","024_62_9","ISA","62","9","9","ⵎⴰⵖⴰⵔ ⵡⵉ ⵜ ⵖⴰ ⵉⵙⵙⵎⵓⵏⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ ⵓ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⵓ ⵡⵉ ⵖⴰ ⵉⵍⴻⵇⴹⴻⵏ ⴰⴹⵉⵍ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵡⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS62_10","024_62_10","ISA","62","10","10","“ⵄⴷⵓⵎ, ⵄⴷⵓⵎ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵓⵛⴰ ⵙⵡⴻⵊⴷⴻⵎ ⵉ ⵍⴳⴻⵏⵙ ⴰⴱⵔⵉⴷ. ⵙⴳⴻⵄⵄⴷⴻⵎ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⴰⴱⵔⵉⴷ ⵉⵡⴰⵟⴰⵏ, ⴽⴽⵙⴻⵎ ⵉⵥⵔⴰ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉ ⵍⴻⴳⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("IS62_11","024_62_11","ISA","62","11","11","ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⴷ ⵙⵍⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵉⵏⵉⵎ ⵉ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ: ‘ⵅⵣⴰⵔ, ⴰⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ, ⵅⵣⴰⵔ, ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵍⴻⵅⵍⴰⵚ ⵏⵏⴻⵙ ⵖⴰⵔ ⵣⵣⴰⵜⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("IS62_12","024_62_12","ISA","62","12","12","ⴰⴷ ⴰⵙⴻⵏ ⵇⵇⴰⵔⴻⵏ: ‘ⵍⴳⴻⵏⵙ ⴰⵎⵇⴻⴷⴷⴰⵙ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ ⵏ ⵙⵉⴷⵉ!’, ⵓⵛⴰ ⴰⴷ ⴰⵎ ⵇⵇⴰⵔⴻⵏ: ‘ⵜⴻⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ!’ ⴷ ‘ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ!’.” ");
INSERT INTO rift_vpl VALUES ("IS63_1","024_63_1","ISA","63","1","1","“ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵉⴷⵓⵎ, ⵣⵉ ⴱⵓⵚⵔⴰ, ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵙ ⵓⵣⵣⴻⴳⴳⵡⴰⵖ ⵢⵓⴵⵍⴻⵏ, ⵉⵄⵓⴵⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ?” “ⴷ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴷⵉ ⵜⵙⴻⴳⴷⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("IS63_2","024_63_2","ISA","63","2","2","“ⵎⴰⵢⴻⵎⵎⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⴷ ⴰⵣⴻⴳⴳⵡⴰⵖ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵛ ⴰⵎ ⵡⴻⵔⵔⵓⴹ ⵏ ⵡⴻⵏⵏⵉ ⵉⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("IS63_3","024_63_3","ISA","63","3","3","“ⵏⴻⵛⵛ ⵡⴻⵃⵃⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵄⴻⴼⵙⴻⵏ ⵜⴰⵙⵉⵔⵜ ⵏ ⴱⵉⵏⵓ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴽⵉⴷⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ. ⵄⴻⴼⵙⴻⵖ ⵅⴰⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⵍⴻⴱⵣⴻⵖ ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵔⵓⵛⵛⴻⵏ ⵅ ⵡⴰⵔⵔⵓⴹ ⵉⵏⵓ, ⵓⵛⴰ ⵙⵙⴰⵔⵚⵓⴹⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵓⴹ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS63_4","024_63_4","ISA","63","4","4","ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵡⴻⵅⵍⴰⴼ ⴰⵇⴰ-ⵜ ⵖⴰⵔⵉ ⴷⴻⴳ ⵡⵓⵍ, ⵓ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ.”    ");
INSERT INTO rift_vpl VALUES ("IS63_5","024_63_5","ISA","63","5","5","“ⵏⴻⵛⵛ ⵅⵣⴰⵔⴻⵖ ⴰⵎⵎⵓ ⴷ ⵡⴰⵎⵎⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⵉⵏ ⴰⴼⵓⵙ. ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜⴱⴻⵀⵜⴻⵖ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⴱⴻⴷⴷ. ⵓⴼⵉⵖ ⵎⵖⵉⵔ ⴰⵖⵉⵍ ⵉⵏⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ ⵓⵛⴰ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵜⵓⵖⴰ ⴷ ⴰⵄⴻⵎⵎⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS63_6","024_63_6","ISA","63","6","6","ⵏⴻⵛⵛ ⵄⴻⴼⵙⴻⵖ ⵅ ⵍⴻⴳⵏⵓⵙ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵙⵙᵉⵙⵛⴰⵔⴻⵖ ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⵉⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("IS63_7","024_63_7","ISA","63","7","7","“ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵉⴷⴰⵔⴻⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏ ⵙⵉⴷⵉ, ⵜⵉⵎⴻⴳⴳⴰ ⵉⵚⴻⴱⵃⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵍⵅⵉⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵉⵙⵙⵛⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS63_8","024_63_8","ISA","63","8","8","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵏⵉⵜⵏⵉ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("IS63_9","024_63_9","ISA","63","9","9","ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ, ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜⴻⵏ. ⴷⵉ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ ⴷ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵉⴼⴻⴽⴽ ⵉ-ⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵢⴰⵔⴱⵓ ⵜⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("IS63_10","024_63_10","ISA","63","10","10","“ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵖⴻⵡⵡⵖⴻⵏ ⵓⵛⴰ ⵙⵙⵛⴻⴹⵏⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵙ. ⵅⴰⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴰⵙⴻⵏ ⴷ ⵍⴻⵄⴷⵓ ⵉ ⵏⵉⵜⵏⵉ, ⵉⵎⵎⵏⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS63_11","024_63_11","ISA","63","11","11","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵄⵇⴻⵍ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵅ ⵎⵓⵙⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⴰⴽ-ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ? ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS63_12","024_63_12","ISA","63","12","12","ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵜⵜⵙⴻⵇⵙⵉⵇⴻⵏ ⴰⵟⵟⴰⵙ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵡⴻⵏⵏⵉ ⵉⴱⴹⴰⵏ ⴰⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵙⴻⵎ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("IS63_13","024_63_13","ISA","63","13","13","ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵏⴻⴷⵀⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉⵏⵏⵀⴻⵡⵍⴻⵏ? ⴰⵎ ⵓⵢⵉⵙ ⴷⵉ ⵍⴻⵅⵍⴰ ⵡⴰⵔ ⵏⵏⵇⴰⵔⴹⴻⵏ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("IS63_14","024_63_14","ISA","63","14","14","ⴰⵎ ⵍⵎⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⵉ-ⵜⴻⵏ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵜⵏⴻⴷⵀⴻⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵉⵙⴻⵎ ⵉⵜⵜⵙⴻⵇⵙⵉⵇⴻⵏ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS63_15","024_63_15","ISA","63","15","15","“ⵙⵉⵊⵊ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓ ⵡⴰⵍⴰ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵏⵏⴻⵛ ⴷ ⵜⴻⵙⵙⵉⵇⵜ ⵏⵏⴻⵛ! ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵓⵙⵎⵉ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵎⴰⵏⵉ ⴵⴰⵏⵜ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵛ ⵉⵊⴻⵀⴷⴻⵏ? ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⵅⴰⴼⵉ ⵍⴻⵀⵏⵓⵏⴻⵛⵜ ⵏⵏⴻⵛ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS63_16","024_63_16","ISA","63","16","16","ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵉⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵉⵏ. ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴰⵎⴻⴼⴷⵉ ⵏⵏⴻⵖ, ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⵣⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("IS63_17","024_63_17","ISA","63","17","17","ⴰ ⵙⵉⴷⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵊⵊⵉⴷ ⵏᵉⵜⵜⴻⴼⴼⴻⵖ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⴻⵇⵙⴻⵃⴻⴷ ⵓⵍ ⵏⵏⴻⵖ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⴳⴳⵯⴻⴷ? ⴷⵡⴻⵍ-ⴷⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS63_18","024_63_18","ISA","63","18","18","ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵏ ⵍⵡⴻⵇⵜ. ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵖ ⵄⴻⴼⵙⴻⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS63_19","024_63_19","ISA","63","19","19","ⴰⵇⴰ ⵏⴻⴷⵡⴻⵍ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉ ⵡⴰⵔ ⵅ ⵜⵃⴻⴽⵎⴻⴷ ⵣⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵓ ⵉ ⵅ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⵎⵍⵉ ⵜⵛⴰⵔⵔⴳⴻⴷ ⵉⵊⴻⵏⵡⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⵉⴷ, ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("IS64_1","024_64_1","ISA","64","1","1","“ⵎⵍⵉ ⴷⴷ-ⵜⴻⵀⵡⵉⴷ, ⴰⵎ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵙⵙⴰⵔⴻⵖ ⵜⵉⵣⴳⵉ ⵓ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵜⴻⵙⵙⵜⴰⵔⵜⴰⵔ ⴰⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵣⵣⴰⵜⴻⴽ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("IS64_2","024_64_2","ISA","64","2","2","ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵉ ⵡⴰⵔ ⵜⴻⵏⵜ ⵏⵔⵉⵊⵉ ⵄⴻⵎⵎⴰⵔⵚ. ⵎⵍⵉ ⴷⴷ-ⵜⴻⵀⵡⵉⴷ ⴰⵍⴰⵎⵉ ⴰⵔⵊⵉⵊⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("IS64_3","024_64_3","ISA","64","3","3","“ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜ ⵙⵍⵉⵏ, ⵍⴰ ⴷ ⴰⵎⴻⵣⵣⵓⵖ ⵡⴰⵔ ⵜ ⵉⵙⵍⵉ, ⵓⵍⴰ ⴷ ⵜⵉⵟⵟ ⵡⴰⵔ ⵜ ⵜⴻⵥⵔⵉ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ ⵏⵀⵍⴰ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⵔⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS64_4","024_64_4","ISA","64","4","4","ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⵣⵉ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⴳⴳ, ⴰⴷ ⵜ ⵜⴻⵍⵇⵉⴷ ⵛⴻⴽ, ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵜⵜⴻⵄⵇⵉⵍⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⵜⴻⴼⴼⵓⴳⵎⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ. ⵏⴻⴳⴳⴰ ⵉ-ⵜ ⵄⴰⴷ ⵍⴻⴱⴷⴰ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵊⵎⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("IS64_5","024_64_5","ISA","64","5","5","ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵓⵎⴻⵅⵎⵓⵊ, ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⴰⵎ ⵡⴰⵔⵔⵓⴹ ⵉⵅⴻⴵⴹⴻⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵜⴼⴰⵔⵜ ⵏⵉⵙⵙⵍⴰⵡ, ⵓⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵜⴽⴻⵙⵙⵉ ⴰⵏⴻⵖ ⴰⵎ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("IS64_6","024_64_6","ISA","64","6","6","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵖⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵜⵜⴻⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵉⵟⵟⴻⴼ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ ⵅⴰⵏⴻⵖ ⵓⵛⴰ ⵜⴻⵊⵊⵉⴷ ⴰⵏⴻⵖ ⴰⴷ ⵏⵖⴰⵔⵇ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS64_7","024_64_7","ISA","64","7","7","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵜⵍⴰⵅⵜ ⵓ ⵛⴻⴽ ⴷ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵏⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS64_8","024_64_8","ISA","64","8","8","ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⴻⴳⴳⵉⴷ ⴰⴷ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴰⵎⵎⵓ ⴰⵟⵟⴰⵙ ⵓ ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ⴰⵇⴰ ⴷⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("IS64_9","024_64_9","ISA","64","9","9","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ ⵜⵉⵎⵇⴻⴷⴷⴰⵙⵉⵏ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⴻⵅⵍⴰ, ⵚⵉⵀⵢⵓⵏ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵏⴻⵣⵔⵓⴼⵜ, ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⴰⵎⵛⴰⵏ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS64_10","024_64_10","ISA","64","10","10","ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⴻⵎⵇⴻⴷⴷⴰⵙⵜ ⴷ ⵜⵉⵙⵙⵉⵇⵜ, ⵎⴰⵏⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵛⴻⴽ, ⵜᵉⵜⵜⵡⴰⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵏⴻⵖ ⵉⵄⵉⵣⵣⴻⵏ, ⵉⴷⵡⴻⵍ ⴷ ⵍⵅⵉⵔⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("IS64_11","024_64_11","ISA","64","11","11","ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵎⴻⵏⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵇⴰⵄ ⴰⵢⴰ, ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴻⵖⴷⴻⴷ ⵓ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵃⵚⴰⵔⴻⴷ ⴰⵎⵎⵓ ⴰⵟⵟⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("IS65_1","024_65_1","ISA","65","1","1","“ⵜⵓⵖⴰ ⵜⵜⴱⴰⵏⴻⵖ ⴰⵙⴻⵏ-ⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵙⵙⴻⵇⵙⵉⵏ, ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⴰⴼⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵉⵍⵉⵖⵉⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ: ‘ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("IS65_2","024_65_2","ISA","65","2","2","ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵙⵙⵡⵉⵥⵥⴰⴹⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵡⴻⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵅ ⵍⴻⵃⵙⴰⴱ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("IS65_3","024_65_3","ISA","65","3","3","ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⴻⵄⵄⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⵎ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⴷⴻⵀ ⵉⵃⵡⵉⵛⴻⵏ ⵓ ⴱⴻⵅⵅⴰⵔⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵅ ⵍⵍⴰⵊⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("IS65_4","024_65_4","ISA","65","4","4","ⵏⵉⵜⵏⵉ ⵜⵜⵖⵉⵎⴰⵏ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ, ⵓ ⵜⵜⵏⵓⵙⴰⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⴰⵎ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵉⵍⴼⴰⵏ ⵓ ⵖⴰⵔⵙⴻⵏ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⴰⵔⵔⵡⴰ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS65_5","024_65_5","ISA","65","5","5","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵇⵇⵉⵎ ⵎⴰⵏⵉ ⵜⴻⴵⵉⴷ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴰⴷⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵣⵣⴰⵢⴻⴽ!’ ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵉⵏⵓ, ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵢⴰⵔⴻⵇⵇⴻⵏ ⴰⵙⵙ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("IS65_6","024_65_6","ISA","65","6","6","ⵅⵣⴰⵔ, ⴰⵢⴰ ⵢⵓⵔⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵡⴰⵔ ⵙⵙⵖⵉⴷⵉⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵅⴻⵍⴼⴻⵖ, ⵡⴰⵀ, ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⴰⵢⴰ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("IS65_7","024_65_7","ISA","65","7","7","ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵡⴻⵎ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵍⴻⴱⵅⵓⵔ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ. ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⴰⴷ ⴰⵙⴻⵏ ⵅⴻⴵⵚⴻⵖ ⵍⵎⵓⵏⴻⵜ ⵏⵙⴻⵏ ⵉ ⵙⴷⴰⵀⴵⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS65_8","024_65_8","ISA","65","8","8","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵎⵉ ⵓⴼⵉⵏ ⴰⵥⴻⵎⵎⵉ ⵏ ⵓⴹⵉⵍ ⴷⴻⴳ ⵓⵣⴻⴽⴽⵓⵏ ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ: ⵡⴰⵔ ⵜ ⵊⴰⵔⵔⴻⵃ, ⵎⴰⵖⴰⵔ ⴷⴰⵢⴻⵙ ⵍⴱⴰⵔⴰⴽⴰ!, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⵏ ⵇⴻⵟⵟⵉⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("IS65_9","024_65_9","ISA","65","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵊⵊⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵣⵉ ⵢⴰⵄⵇⵓⴱ ⵓ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴰⵡⵔⵉⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵉⵏⵓ ⵣⵉ ⵢⴰⵀⵓⴷⴰ. ⵉⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏⵏⵉ ⵣⴻⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS65_10","024_65_10","ISA","65","10","10","ⵍⴻⵡⴹⴰ ⵏ ⵛⴰⵔⵓⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⴽⴻⵙⵙⴰⵡⵜ ⵏ ⵡⵓⴵⵉ, ⵓ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⴰⵅⵓⵔ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵉⴼⵓⵏⴰⵙⴻⵏ, ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵡⴻⵏⵏⵉ ⵅⴰⴼⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("IS65_11","024_65_11","ISA","65","11","11","“ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⵜⵜⵓⵏ ⴰⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵟⵟⴰⴱⵍⴰ ⵉ ⵊⴰⴷ ⵓ ⵉⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⴰⵖⴰⵔⵔⴰⴼ ⵙ ⴱⵉⵏⵓ ⵉⵅⴻⴵⴹⴻⵏ ⵉ ⵎⵉⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("IS65_12","024_65_12","ISA","65","12","12","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵃⴻⵙⴱⴻⵖ ⵉ ⵙⵙⵉⴼ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⴹⴰⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵖⴰⵔⵚⴻⵎ, ⵓⵎⵉ ⵏⴻⵛⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵍⴰⵖⵉⵖ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵔⵔⵉⵎ, ⵓⵎⵉ ⵏⴻⵛⵛ ⵖⴰⵔⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⵙⵍⵉⵎ, ⵎⴰⵛⴰ ⵜⴻⴳⴳⵉⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵓ ⵜⵉⵅⴹⴰⵔⴻⵎ ⵎⵉⵏ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵅ ⵍⵅⴰⴹⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("IS65_13","024_65_13","ISA","65","13","13","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵛⵛⴻⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴵⴰⵥⴻⵎ. ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵙⵡⴻⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴼⴼⴰⴷⴻⵎ. ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵙⴻⴹⵃⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("IS65_14","024_65_14","ISA","65","14","14","ⵅⵣⴰⵔ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵡⵓⵍ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵖⵓⵢⴻⵎ ⵣⵉ ⵍⴻⵃⵔⵉⵇ ⵏ ⵡⵓⵍ, ⴰⴷ ⵜⵡⴻⵄⵄⴹⴻⵎ ⵣⵉ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵏ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("IS65_15","024_65_15","ISA","65","15","15","ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⵉⵙⴻⵎ ⵏⵡⴻⵎ ⴰⵎ ⵏⵏⴻⵄⵍⴻⵜ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴻⵖ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵍⴰⵖⴰ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("IS65_16","024_65_16","ISA","65","16","16","ⴰⵍⴰⵎⵉ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵉⴱⴰⵔⴻⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵊⵊⵓⴵ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵖⴰⵔ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏ ⵣⵉⵛ ⴰⴷ ⵜⵜⵡⴰⵜⵜⵓⵏⵜ ⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("IS65_17","024_65_17","ISA","65","17","17","“ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⴻⵏⵡⴰⵏ ⵏ ⵊⴷⵉⴷ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⴷⵉⴷ. ⵡⴰⵔ ⵜⵜⴻⵄⵇⵉⵍⴻⵏ ⵄⴰⴷ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵄⴷⵓⵏ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⴻⵏⵜ ⵄⴰⴷ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵖⴰⵔ ⵍⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("IS65_18","024_65_18","ISA","65","18","18","ⴼⴰⵔⵃⴻⵎ ⵅⴻⵏⵏⵉ ⵓ ⴼⴰⵔⵔⵊⴻⵎ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵅⴻⵍⵇⴻⵖ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⴰⴼⴰⵔⵔⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("IS65_19","024_65_19","ISA","65","19","19","ⵏⴻⵛⵛ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵖ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵙⵍⴻⵏ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵉⵖ ⵏ ⵓⵖⵓⵢⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("IS65_20","024_65_20","ISA","65","20","20","ⴰⵃⴹⵉⴹ ⵉ ⵖⴰ ⵉⴷⴷⴰⵔⴻⵏ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ, ⵓⵍⴰ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴽⴻⵎⵎⵉⵍⴻⵏ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ. ⵎⴰⵖⴰⵔ ⴰⵃⵓⴹⵔⵉ ⴰⴷ ⵉⵎⵎⴻⵜ ⵅⵎⵉ ⵖⴰⵔⴻⵙ ⵖⴰ ⵢⵉⵍⵉ ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓ ⴰⵎⴻⴷⵏⵓⴱ ⴰⴷ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵅⵎⵉ ⵖⴰⵔⴻⵙ ⵖⴰ ⵢⵉⵍⵉ ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("IS65_21","024_65_21","ISA","65","21","21","ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⵏⴰⵏ ⵜⵓⴷⵔⵉⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵣⴻⴷⵖⴻⵏ, ⴰⴷ ⵥⵥⵓⵏ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ, ⴰⴷ ⵛⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS65_22","024_65_22","ISA","65","22","22","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴱⴻⵏⵏⵉⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵣⴷⴻⵖ, ⵡⴰⵔ ⵜⵜⴻⵥⵥⵓⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⵓⵙⵙⴰⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ, ⵓ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⵔⵉⵇⵇⵉ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS65_23","024_65_23","ISA","65","23","23","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴻⴷⴷⵎⴻⵏ ⵄⴰⴷ ⴱⴰⵟⴻⵍ, ⵡⴰⵔ ⵜⵜⵉⵔⵡⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⵓⵛⴻⵍⵡⴰⵡ ⵙ ⵍⵖⴻⴼⵍⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵣⵉ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵜⴰⵔⵔⴰⵡⵜ ⵏⵙⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS65_24","024_65_24","ISA","65","24","24","ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵍⴰⵖⴰⵏ, ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵅⵡⴰⵏⵙⵓ ⵄⴰⴷ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⴰⴷ ⴰⵙⴻⵏ ⵙⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("IS65_25","024_65_25","ISA","65","25","25","ⵓⵛⵛⴻⵏ ⴷ ⵉⵣⵎⴰⵔ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵎⵓⵏⴻⵏ, ⴰⵢⵔⴰⴷ ⴰⴷ ⵉⵛⵛ ⵍⵓⵎ ⴰⵎ ⵓⴼⵓⵏⴰⵙ, ⵓⵛⴰ ⴰⴼⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵓⴼⵉⵖⴰⵔ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓ ⵡⴰⵔ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵍⴻⵇⵊⴰⵔⴻⵜ ⵅ ⵎⴰⵔⵔⴰ ⴰⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS66_1","024_66_1","ISA","66","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵊⴻⵏⵏⴰ ⴷ ⵍⵄⴰⵔⵛ ⵉⵏⵓ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵉ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵅⴻⵏⵏⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⴱⵏⴰⵎ ⵓ ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("IS66_2","024_66_2","ISA","66","2","2","ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵓⴼⵓⵙ ⵉⵏⵓ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵜⵓⵖⴰ ⵉⴵⴰ ⵄⴰⴷ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵅ ⵓⵎⴻⵣⵍⵓⴹ, ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵥⴰⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵓ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("IS66_3","024_66_3","ISA","66","3","3","“ⵡⴻⵏⵏⵉ ⵉⵖⴰⵔⵚⴻⵏ ⵉ ⵓⴼⵓⵏⴰⵙ, ⵉⵏⵖⴰ ⵓⵍⴰ ⴷ ⴰⵔⵢⴰⵣ, ⵓ ⵡⴻⵏⵏⵉ ⵢⵉⵡⵢⴻⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⴷ ⴷⴷⴱⵉⵃⴻⵜ, ⵢⴰⵔⵥⴰ ⵄⴰⵡⴻⴷ ⵉⵔⵉ ⵉ ⵢⵉⵟⴰⵏ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵉⵇⴻⴷⴷⴻⵎ ⵓⵍⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⵉⵍⴻⴼ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴱⴻⵅⵅⴰⵔⴻⵏ ⵊⵊⴰⵡⵉ, ⵉⴱⴰⵔⴻⴽ ⵓⵍⴰ ⴷ ⴰⵄⴱⴻⴷ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ. ⵏⵉⵜⵏⵉ ⵉⵅⴹⴰⵔⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵉⵄⵊⴻⴱ ⴰⵙ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("IS66_4","024_66_4","ISA","66","4","4","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴰⵔⴻⵛⵛⵃⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵜⵉⵢⵢⵉⵜⴰ ⵏⵙⴻⵏ ⵉ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵡⵢⴻⵖ ⵎⵉⵏ ⵣⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⴰⵔⵔⵉⵏ ⵓⵎⵉ ⵏⴻⵛⵛ ⴷ ⴰⵙⴻⵏ ⵍⴰⵖⵉⵖ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵓⵎⵉ ⵖⴰⵔⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵉⵅⴹⴰⵔⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("IS66_5","024_66_5","ISA","66","5","5","“ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ: ‘ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ: ⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴰ ⵙⵉⴷⵉ, ⵙⵛⴻⵏ ⴰⵏⴻⵖ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ!, ⴰⴷ ⵙⴻⴹⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("IS66_6","024_66_6","ISA","66","6","6","ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴷⴷⵔⵉⵣ ⵉⵎⵖⴰⵔ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⵎⵉⵊⵊⴰ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⴻⴵⵚⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵍⵎⵓⵏⴻⵜ ⵏⵙⴻⵏ ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("IS66_7","024_66_7","ISA","66","7","7","“ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵟⵟⴻⴼ ⵍⴻⵃⵔⵉⵇ ⵏ ⵜⴰⵔⵡⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵚⵉⵀⵢⵓⵏ, ⴰⵇⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ, ⵇⴱⴻⵍ ⵉ ⵜⵜ ⵖⴰ ⵎⴻⵏⵄⴻⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ, ⵜⴻⴳⴳⴰ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⴰⵡⵜⴻⵎ ⴰⴷ ⵉⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("IS66_8","024_66_8","ISA","66","8","8","ⵡⵉ ⵉⵙⵍⴰⵏ ⴰⵢⴰ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⵥⵔⵉⵏ ⴰⵢⴰ? ⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴻⵅⵍⴻⵇ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵡⴰⵀⴰ? ⵎⴰ ⴰⴷ ⴷⴷ-ⵉⵅⵍⴻⵇ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵡⴰⵀⴰ? ⵎⴰⵛⴰ ⵓⵙⵉⵏ ⴰⵙ-ⴷⴷ ⵉ ⵚⵉⵀⵢⵓⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⵄⴰⴷ ⵛⵡⴰⵢⵜ ⵡⴰⵀⴰ, ⴰⵇⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("IS66_9","024_66_9","ISA","66","9","9","“ⵎⴰ ⴰⴷ ⴰⵙ ⴰⵔⵣⵎⴻⵖ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵀⵍⴰ ⵎⴰ ⵊⵊⵉⵖ ⵜⵜ ⴰⴷ ⵜⴰⵔⵓ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵎⴰ ⵏⴻⵛⵛ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴰⵡⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⴰⴷ ⴰⵙⴻⵏⵜ ⴱⴻⵍⵍⵄⴻⵖ ⵜⴰⵄⴻⴷⴷⵉⵙⵜ?ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("IS66_10","024_66_10","ISA","66","10","10","“ⴼⴰⵔⵃⴻⵎ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵙⵍⵉⵡⵍⵉⵡⴻⵎ ⴰⵙ, ⴰ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ. ⴼⴰⵔⵃⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⵉⵛⴻⴹⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("IS66_11","024_66_11","ISA","66","11","11","ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵟⵟⴹⴻⵎ, ⴰⴷ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵣⴻⴳ ⵉⴱⴱⴰⵛ ⵏⵏⴻⵙ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵓⴼⴻⵡⵡⴻⵊ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵙ ⵜⵢⴰⵡⴰⵏⵜ ⵓ ⴰⴷ ⵜⴰⵔⵔⴻⵎ ⵎⴻⵥⵔⵉ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵇⴰⵄ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("IS66_12","024_66_12","ISA","66","12","12","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⵉⵣⵣⵍⴻⵖ ⵍⴻⵀⵏⴰ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵓ ⴰⵄⵓⴵⵉ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵎ ⵜⴻⵖⵣⴰⵔⵜ ⵉⵃⴻⵎⵍⴻⵏ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵟⵟⴹⴻⵏ. ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴱⵓⵏ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⵃⵉⵏⵏⴱⴻⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS66_13","024_66_13","ISA","66","13","13","ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜⴻⵙⵙⵍⴻⵀⵀⴰ ⴰⵙ ⵢⴻⵎⵎⴰⵙ, ⴰⵎⵎⵓ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵙⵙⴻⵍⵀⵓⵖ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴼⴻⵡⵡⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("IS66_14","024_66_14","ISA","66","14","14","ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⴰⵢⴰ, ⴰⴷ ⵉⴼⴰⵔⵃ ⵡⵓⵍ ⵏⵡⴻⵎ, ⵓ ⵉⵖⵙⴰⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵏⴻⵄⵛⴻⵏ ⴰⵎ ⴰⵔⴱⵉⵄ ⴰⵣⵉⵣⴰ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵅⴻⴹ ⵅ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("IS66_15","024_66_15","ISA","66","15","15","“ⵎⵉⵏⵣⵉ, ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙⵉⴷⵉ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴳⴳⴻⵏ ⴰⵎ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⵊⵊ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⵙⴰ ⵙ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵙ ⵓ ⵜⴰⴼⵇⴻⵃⵜ ⵏⵏⴻⵙ ⵙ ⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("IS66_16","024_66_16","ISA","66","16","16","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵏⵏⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("IS66_17","024_66_17","ISA","66","17","17","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵉⵙⵙⵉⵣⴷⵉⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵃⵡⵉⵛⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵉⵊⵊⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵉⵍⴼⴰⵏ ⵓⵍⴰ ⴷ ⵏⵏⵄⵉ ⵏ ⵍⵎⴰⵍ ⴷ ⵉⵖⴰⵔⴷⴰⵢⴻⵏ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵇⴹⴰⵏ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("IS66_18","024_66_18","ISA","66","18","18","“ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵄⵓⴵⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS66_19","024_66_19","ISA","66","19","19","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ, ⴼⵓⵟ ⴷ ⵍⵓⴷ, ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ, ⵖⴰⵔ ⵜⵓⴱⴰⵍ ⴷ ⵢⴰⵡⴰⵏ, ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ, ⵜⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵍⵉⵏ ⵍⴻⵅⴱⴰⵔ ⵅⴰⴼⵉ ⵓ ⵡⴰⵔ ⵉⵥⵔⵉⵏ ⴰⵄⵓⴵⵉ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⵉ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("IS66_20","024_66_20","ISA","66","20","20","ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵙⵉⴷⵉ: ⵅ ⵢⴻⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ, ⴷⵉ ⵍⴻⴽⵔⴰⵙⵉ ⵉⵜⵜⵡⴰⵔⴻⴱⴱⵓⵏ, ⵅ ⵉⵙⴰⵔⴷⴰⵏ ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴳⴻⵄⵔⵓⵔⵜ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⴰⵎⵇⴻⴷⴷⴻⵙ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴰⵡⵢⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⵇⴻⴷⴷⵓⵃⵜ ⵜⴻⵣⴷⵉⴳ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS66_21","024_66_21","ISA","66","21","21","ⵓⵍⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⴼⴰⵔⵣⴻⵖ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS66_22","024_66_22","ISA","66","22","22","ⵎⴰⵖⴰⵔ ⴰⵎ ⵢⵉⵊⴻⵏⵡⴰⵏ ⵏ ⵊⴷⵉⴷ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⴷⵉⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⵓⵍⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ ⴷ ⵉⵙⴻⵎ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("IS66_23","024_66_23","ISA","66","23","23","ⴰⴷ ⵉⵎⵙⴰⵔ ⵣⵉ ⵇⴰⵄ ⴰⴱⴻⴷⴷⵉ ⵏ ⵓⵢⵓⵔ ⴰⵍ ⵇⴰⵄ ⴰⴱⴻⴷⴷⵉ ⵏⵏⴻⵖⵏⵉ ⵓ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⵍ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵏⴷⵇⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("IS66_24","024_66_24","ISA","66","24","24","ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ, ⴰⴷ ⵥⴰⵍⴻⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵄⴻⴷⴷⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⴽⴻⵛⵛⴰ ⵏⵙⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵓⵍⴰ ⴷ ⵜⵉⵎⴻⵙⵙⵉ ⵏⵙⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⵅⴻⵙⵙⵉ. ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵏⵏⵄⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR1_1","025_1_1","JER","1","1","1","ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵔⵎⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵣⴻⴳ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵄⴰⵏⴰⵜⵓⵜ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("JR1_2","025_1_2","JER","1","2","2","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵛⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR1_3","025_1_3","JER","1","3","3","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⵓⵍⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵍ ⵎⴰⵏⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JR1_4","025_1_4","JER","1","4","4","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR1_5","025_1_5","JER","1","5","5","“ⵇⴱⴻⵍ ⵎⴰ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴰⵙⴻⵢⵎⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵛ, ⵜⵓⵖⴰ ⵙⵙⵏⴻⵖ ⵛⴻⴽ, ⵓ ⵇⴱⴻⵍ ⵎⴰ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵍⴻⵎⵍⴰⵡⴻⵜ, ⴰⵇⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵛⴻⴽ. ⵏⴻⵛⵛ ⴰⵔⴻⵛⵛⵃⴻⵖ ⵛⴻⴽ ⴷ ⴰⵏⴰⴱⵉ ⵉ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR1_6","025_1_6","JER","1","6","6","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⴰⵀ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ, ⵏⴻⵛⵛ ⵄⴰⴷ ⴷ ⴰⵃⵓⴷⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR1_7","025_1_7","JER","1","7","7","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ: “ⵡⴰⵔ ⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⵄⴰⴷ ⴷ ⴰⵃⵓⴷⵔⵉ!’, ⵎⴰⵖⴰⵔ ⵎⴰⵏⵉ ⵎⴰ ⵛⴻⴽ ⵉ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⴰⴷ ⴷⵉⵏ ⵜⵔⴰⵃⴻⴷ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵓⵎⵓⵔⴻⵖ, ⴰⴷ ⵜ ⵜⵉⵏⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JR1_8","025_1_8","JER","1","8","8","ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ!”, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR1_9","025_1_9","JER","1","9","9","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙⵉⴷⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵃⴰⴷⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵛ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR1_10","025_1_10","JER","1","10","10","ⵅⵣⴰⵔ, ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⵛⵛⵃⴻⵖ ⵅ ⵍⴻⴳⵏⵓⵙ ⵓ ⵅ ⵜⴳⴻⵍⴷⴰⵡⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵇⴻⵍⵄⴻⴷ ⵓ ⴰⴷ ⵜⵀⴻⴷⵎⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⴻⴷⴷⴵⴻⴷ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵖⴻⴹⵍⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴱⵏⵉⴷ ⵓ ⴰⴷ ⵜⴻⵥⵥⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("JR1_11","025_1_11","JER","1","11","11","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ, ⵉⵔⵎⵉⵢⴰ?” ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵙⴻⵟⵟⴰ ⵏ ⴵⴻⵡⵣ.” ");
INSERT INTO rift_vpl VALUES ("JR1_12","025_1_12","JER","1","12","12","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⵏⵉⵛⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵜⵄⴻⵙⵙⴻⵖ ⵅ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR1_13","025_1_13","JER","1","13","13","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ?” ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ: “ⵜⵜⵡⴰⵍⵉⵖ ⵜⴰⵢⴷⴰⵔⵜ ⵉⵜⵜⵏⴻⵏⵏⴰⵏ, ⴰⴱⵓⴹ ⵏⵏⴻⵙ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⴷⴰ ⵣⵉ ⵛⵛⴰⵎⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR1_14","025_1_14","JER","1","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵉ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰ ⵍⵖⴰⵔ-ⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR1_15","025_1_15","JER","1","15","15","ⵎⴰⵖⴰⵔ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⵛⴰⵎⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⴽⵔⴰⵙⵉ ⵏⵙⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓ ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR1_16","025_1_16","JER","1","16","16","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵏⴻⵟⵇⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵏⵓ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵙⴻⵏ: ⴰⵇⴰ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ ⵓⵛⴰ ⴱⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏ ⵉ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR1_17","025_1_17","JER","1","17","17","ⵛⴻⴽ ⵅⴻⵏⵏⵉ, ⵃⴻⵣⵣⴻⵎ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴽⴽⴰⵔ, ⴱⴰⵔⵔⴻⵃ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵓⵎⵓⵔⴻⵖ. ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵉⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵅⵍⵄⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR1_18","025_1_18","JER","1","18","18","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ, ⴷ ⵉⵊⵊ ⵏ ⵓⴱⵉⵍⴰⵔ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏ ⵏⵏⵃⴰⵙ ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ: ⴹⵉⴷⴷ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴹⵉⴷⴷ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⴹⵉⴷⴷ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵓ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR1_19","025_1_19","JER","1","19","19","ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⵉⴷⴻⴽ ⵎⵎⴻⵏⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵛⴻⴽ ⴰⵔⴻⵏⵏⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR2_1","025_2_1","JER","2","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR2_2","025_2_2","JER","2","2","2","“ⵓⵢⵓⵔ, ⴱⴰⵔⵔⴻⵃ ⴷⴻⴳ ⵓⵎⴻⵣⵣⵓⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵖ ⴷⴰⵢⴻⵎ, ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ, ⵅ ⵜⴰⵢⵔⵉ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵏⴻⵅⴹⴰⴱⵜ ⵏⵏⴻⵎ, ⵓⵎⵉ ⴷⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⴹⴼⴰⵔⴻⴷ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵎⴻⵙⵙⵓⵛⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JR2_3","025_2_3","JER","2","3","3","ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⵉ ⵙⵉⴷⵉ, ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵛⴻⵏ, ⵉⴷⴷⴰⴽⴽⵡⴰⵍ ⴷⴰⵢⴻⵙ ⵍⵄⵉⴱ, ⵉⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵍⵖⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR2_4","025_2_4","JER","2","4","4","“ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴷ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR2_5","025_2_5","JER","2","5","5","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵏ ⵍⵖⴻⵛⵛ ⵏⵏⵉ ⴷⴰⵢⵉ ⵓⴼⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⵍⴰⵎⵉ ⵅⴰⴼⵉ ⵃⴻⵢⵢⴹⴻⵏ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("JR2_6","025_2_6","JER","2","6","6","ⵡⴰⵔ ⵙⵙⴻⵇⵙⵉⵏ: ⵎⴰⵏⵉ ⵉⴵⴰ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵛⵏⴻⵏ ⴰⴱⵔⵉⴷ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵉⵅⴻⵏⴷⵔⴰⵇ, ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴰⵥⴰⵖ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵅⴰⵙ ⵉⵄⴷⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴷⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JR2_7","025_2_7","JER","2","7","7","ⵏⴻⵛⵛ ⵉⵡⵢⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵛⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⴷ ⵍⵅⴰⵔ. ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⵉⵏ ⵜⵉⵡⴹⴻⵎ, ⵜⴻⵙⵙⵅⴻⵎⵊⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵏⵓ ⵓ ⵜⴰⵔⵔⵉⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JR2_8","025_2_8","JER","2","8","8","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵔ ⵙⵙⴻⵇⵙⵉⵏ: ⵎⴰⵏⵉ ⵉⴵⴰ ⵙⵉⴷⵉ?, ⵓⵛⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵙⵉⵏⴻⵏ ⵓ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵄⴻⴷⴷⵓⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵓ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵜⵏⴰⴱⴱⴻⵏ ⵙ ⴱⴰⵄⴰⵍ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("JR2_9","025_2_9","JER","2","9","9","ⵙ ⵓⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵏⵉⵖ ⴰⴷ ⵎⵛⵓⴱⴱⵛⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵎⵛⵓⴱⴱⵛⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR2_10","025_2_10","JER","2","10","10","“ⵥⵡⴰⵎ ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴽⵉⵜⵜⵉⵎ, ⴰⵇⴰ ⵙⴻⴽⴽⴻⵎ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵇⵉⴷⴰⵔ, ⴱⴻⵢⵜⴻⵎ ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ ⵎⵍⵉⵃ, ⵎⴰ ⵉⵎⵙⴰⵔ ⵄⴻⵎⵎⴰⵔⵚ ⴰⵎ ⵎⴰⵏ ⴰⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("JR2_11","025_2_11","JER","2","11","11","ⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵉⴱⴻⴷⴷⴻⵍ ⵛⴰ ⵏ ⵍⴳⴻⵏⵙ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ? ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⴰⵛⴰ ⵉⵡⵛⴰ ⵍⵄⴻⵣⵣ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR2_12","025_2_12","JER","2","12","12","ⵉⵍⵉⵎ ⴷ ⵉⴳⵏⴰⵡⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⴽⴻⵏⵏⵉⵡ ⴰ ⵉⵊⴻⵏⵡⴰⵏ, ⴳⴳⵯⴻⴷⴻⵎ, ⵏⵅⴻⵍⵄⴻⵎ ⴰⵍ ⵟⵟⴰⵔⴼ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR2_13","025_2_13","JER","2","13","13","ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵄⵢⵓⴱ: ⵏⴻⵛⵛ, ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⵣⴰⵏ ⴰⵏⵓⵜⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⵏⵓⵜⴻⵏ ⵙ ⵜⴰⵣⵣⴻⵛⵜ ⵉ ⵉⵅⵡⴰⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR2_14","025_2_14","JER","2","14","14","ⵎⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵙⵎⴻⵖ ⵏⵉⵖ ⴷ ⵉⵊⵊ ⵉⵜⵜⵡⴰⵔⵓ ⴷ ⵉⵙⵎⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ? ⵎⴰⵢⴻⵎⵎⵉ ⵉⴷⵡⴻⵍ ⵉ ⵣⵣⴰⵔⴷⴻⵜ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JR2_15","025_2_15","JER","2","15","15","ⵙⵙⴱⵓⵄⵔⵓⵜⴻⵏ ⵅⴰⵙ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴳⴳⵉⵏ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⵙⴻⵏⵜ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JR2_16","025_2_16","JER","2","16","16","ⵄⴰⴷ ⵃⴻⴼⴼⴻⵏ ⴰⵢⵜ ⵏ ⵏⵓⴼ ⴷ ⵜⴰⵃⴼⴰⵏⵉⵙ ⴰⵛⴻⵇⵇⵓⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR2_17","025_2_17","JER","2","17","17","ⵎⴰ ⵡⴰⵔ ⵜⴻⴳⴳⵉⴷ ⵛⴰ ⵎⴰⵏⴰⵡⵢⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵛⴻⵎ ⵜⵙⴻⵎⵃⴻⴷ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ ⴰⵎ ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵃ ⵉ ⵛⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("JR2_18","025_2_18","JER","2","18","18","“ⵍⴻⵅⵅⵓ, ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵎ ⴷ ⵊⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⴷⵉⵏ ⴰⵎⴰⵏ ⵣⵉ ⵛⵉⵅⵓⵔ, ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⴷ ⴰⴱⴰⵔⵛⴰⵏ? ⵎⵉⵏ ⵊⴰⵔ ⴰⵎ ⴷ ⵊⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏ ⴰⵛⵛⵓⵔ ⴰⵍⴰⵎⵉ ⴷⵉⵏ ⵉ ⵖⴰ ⵜⴻⵙⵡⴻⴷ ⴰⵎⴰⵏ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ?    ");
INSERT INTO rift_vpl VALUES ("JR2_19","025_2_19","JER","2","19","19","ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵎ ⴰⴷ ⵛⴻⴽ ⵜⴰⵔⴻⴱⴱⴰ ⵓ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵡⴻⴷⴷⴰⵔ ⵏⵏⴻⵎ ⴰⴷ ⵛⴻⵎ ⵄⴰⵇⴱⴻⵏ. ⵙⵙⴻⵏ ⵓ ⵅⵣⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵉⵃⵍⵉ ⵓ ⵎⴻⵛⵃⴰⵍ ⵢⴰⵔⵣⴻⴳ ⴰⵇⴰ ⵜⵙⴻⵎⵃⴻⴷ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ, ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR2_20","025_2_20","JER","2","20","20","“ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⴰⵔⵥⵉⴷ ⴰⵣⴰⵢⵍⵓ ⵏⵏⴻⵎ, ⵜⵛⴰⵔⵔⴳⴻⴷ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵎ. ⵛⴻⵎ ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⴰⵛ ⵙⴻⵅⵅⴰⵔⴻⵖ!’ ⵎⵉⵏⵣⵉ ⵅ ⴽⵓⵍ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵢⵓⵄⵍⴰⵏ ⵓ ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ ⵜⵓⴹⴰⵔⴻⴷ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR2_21","025_2_21","JER","2","21","21","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵥⵥⵓⵖ ⵛⴻⵎ ⴷ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜⴰⵃⵓⵔⵔⵉⵜ, ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ. ⵎⴰⵎⵎⴻⵛ ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵜⵙⴻⴹⵡⵉⵏ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵏ ⵍⴻⵅⵍⴰ ⵜⴰⴱⴰⵔⵔⴰⵏⴻⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("JR2_22","025_2_22","JER","2","22","22","ⵡⴰⵅⵅⴰ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵍⵍⵉⵅⵉⵢⵢⴰ ⵓⵛⴰ ⵜⴰⵔⵏⵉⴷ ⴰⵙⵔⴰⵢ ⵙ ⵚⵚⴰⴱⵓⵏ, ⵄⴰⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR2_23","025_2_23","JER","2","23","23","“ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵅⴻⵎⵊⴻⵖ ⵛⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴹⴼⴰⵔⴻⵖ ⵛⴰ ‘ⵉⴱⴰⵄⵍⴻⵏ!’ ⵅⵣⴰⵔ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵎ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ, ⵄⵇⴻⵍ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ, ⵛⴻⵎ ⴷ ⵜⴰⵍⵖⴻⵎⵜ ⵜⴻⴼⵙⵓⵙ ⵜᵉⵜⵜⴰⵣⵣⴻⵍ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⴻⵎⵅⴰⵔⵡⴰⴹⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("JR2_24","025_2_24","JER","2","24","24","ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵖⵢⵓⵍⵜ ⵏ ⵍⴻⵅⵔⴰ, ⵉⵏⵏⵓⵎⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⵎⵎⴰⵏ ⴰⵔⵔⵉⵃ ⴷⴻⴳ ⵡⴻⵏⵥⴰⵔ ⵏⵏⴻⵙ ⵓⵎⵉ ⵜⵃⴰⵊ. ⵡⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵏⵏⴻⵛⵡⴻⵜ ⵏⵏⴻⵙ? ⵇⴰⵄ ⵡⵉ ⵜⵜ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵡⴰⵔ ⵉⵃⴷⵉⵊ ⴰⴷ ⵉⵙⵙⵉⵃⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵢⴰⴼ ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⵏⵏⴻⵛⵡⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR2_25","025_2_25","JER","2","25","25","ⵃⴹⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⴹⴰⵔ ⵏⵏⴻⵎ ⴱⵍⴰ ⵜⵉⵙⵉⵍⴰ ⵓⵍⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵥⴻⵖ ⵙ ⵓⴼⴰⴷⵉ! ⵛⴻⵎ ⵎⴰⵛⴰ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⵙⵙⵉⵡⵉⵍ, ⵄⴻⵎⵎⴰⵔⵚ! ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵄⴻⵛⵇⴻⵖ ⴷⵉ ⵎⵉⴷⴷⴻⵏ, ⵅⵙⴻⵖ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("JR2_26","025_2_26","JER","2","26","26","“ⴰⵎ ⵓⵅⴻⵡⵡⴰⵏ ⵉⵏⵏⴻⵃⵚⴻⵍ ⵉⵙⴻⴹⵃⴰ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⴻⴹⵃⴰⵏ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR2_27","025_2_27","JER","2","27","27","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⵉ ⵓⴽⴻⵛⵛⵓⴹ: ‘ⵛⴻⴽ ⴷ ⴱⴰⴱⴰ!’, ⵓ ⵉ ⵡⴻⵥⵔⵓ: ⵛⴻⴽ ⵜⴻⵊⵊⵉⴷ ⴰⵢⵉ-ⴷⴷ!, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵢⵉ ⵙ ⵡⴻⵄⵔⵓⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵖⴻⵎⴱⵓⴱ, ⵎⴰⵛⴰ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵇⵇⴰⵔⴻⵏ: ‘ⴽⴽⴰⵔ, ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JR2_28","025_2_28","JER","2","28","28","ⵎⴰⵏⵉ ⴵⴰⵏ ⵍⴻⵅⵅⵓ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ? ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ, ⵎⴰⵍⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵏ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵡⴻⵎ ⴰⵎ ⵍⵄⴰⴷⴰⴷ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ, ⴰ ⵢⴰⵀⵓⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("JR2_29","025_2_29","JER","2","29","29","“ⵎⴰⵢⴻⵎⵎⵉ ⴰⴽⵉⴷⵉ ⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵎ ⴽⴻⵏⵏⵉⵡ? ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵜᵉⵜⵜⵄⴻⴷⴷⴰⵎ ⵅⴰⴼⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR2_30","025_2_30","JER","2","30","30","ⵅ ⴱⴰⵟⴻⵍ ⵉ ⵡⵜⵉⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵊⵊⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴷ ⴰⵔⴻⵢⵢⴹⴻⵏ. ⵙⵙⵉⴼ ⵏⵡⴻⵎ ⵉⵛⵛⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⴰⵎ ⵡⴰⵢⵔⴰⴷ ⵉⵖⴰⵔⵔⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR2_31","025_2_31","JER","2","31","31","ⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵊⵊⵉⵍ ⵏ ⵢⵉⴹⴰ, ⵃⴹⴰⵎ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵎⴰ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⵍⴻⵅⵍⴰ ⵉ ⵉⵙⵔⴰⵉⵍ, ⵏⵉⵖ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ? ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵉⵇⵇⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ: ‘ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵏⵏⵓⴼⵚⴻⵍ ⵣⵣⴰⵢⴻⴽ, ⵡⴰⵔ ⵉ ⴷⴷ ⵖⴰⵔⴻⴽ ⵏⴻⴷⴷⵉⴽⴽⵡⵉⵍ ⵄⴰⴷ’? ");
INSERT INTO rift_vpl VALUES ("JR2_32","025_2_32","JER","2","32","32","ⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵓ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵜⴰⵍⵡⵉⵣⵜ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⴷ ⵜᵉⵜⵜⵓ ⵜⴻⵙⵍⵉⵜ ⵜⴰⵃⴻⵣⵣⴰⵎⵜ ⵏⵏⴻⵙ ⵉⵣⴻⵡⵡⵇⴻⵏ? ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵓ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JR2_33","025_2_33","JER","2","33","33","ⵎⴻⵛⵃⴰⵍ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⴰⴱⵔⵉⴷ ⵏ ⵜⴰⵢⵔⵉ? ⵙ ⵓⵢⴰ ⵉ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ ⴷⵉ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR2_34","025_2_34","JER","2","34","34","ⵓⵍⴰ ⴷⴻⴳ ⵓⴱⴻⵃⵔⵓⵔ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ ⵓⴼⵉⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⴻⵄⵎⵓⵔⴰⵜ ⵉⴹⴻⵄⴼⴻⵏ ⵉⵣⴷⵉⴳⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵎⵏⵉⵄⴻⴷ ⵓⵎⵉ ⵓⵛⴰⵔⴻⵏ ⵜⵓⴷⵔⵉⵏ, ⵡⴰⵀ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⵉⵎⵙⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("JR2_35","025_2_35","JER","2","35","35","ⵓⵛⴰ ⵄⴰⴷ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴷ ⵜⴰⵎⴻⵣⴷⴰⴳⵜ, ⴰⵇⴰ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⵃⴻⵢⵢⴻⴷ ⵅⴰⴼⵉ!’ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⵎ ⵛⴰⵔⵔⵄⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⴳⴳⵉⵖ ⴷⴷⵏⵓⴱ!’ ");
INSERT INTO rift_vpl VALUES ("JR2_36","025_2_36","JER","2","36","36","ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⵊⴻⴷ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⴱⴻⴷⴷⵍⴻⴷ ⵍⴻⴱⴷⴰ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵎ? ⵓⵍⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⵛⴻⵎ ⵜⴻⵛⵎⴻⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵎ ⵜⴻⵛⵎⴻⵜ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JR2_37","025_2_37","JER","2","37","37","ⵓⵍⴰ ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⵯⴻⵊⴻⴷ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ ⵅ ⵓⵣⴻⴵⵉⴼ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⴹⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵢⴰ ⵓⵍⴰ ⴰⴽⵉⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR3_1","025_3_1","JER","3","1","1","“ⵇⵇⴰⵔⴻⵏ: ‘ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴵⴻⴼ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵢⵓⵔ ⵅⴰⵙ, ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ, ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵅⴻⵏⵏⵉ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴼⵙⴻⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴰⵟⵟⴰⵙ?’ ⵛⴻⵎ ⵎⴰⵛⴰ ⵜⴻⴳⴳⴻⴷ ⴼⴼⴰⵔⵇ-ⵛⵖⴻⵍ ⵏⵏⴻⵎ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⵄⴻⵇⴱⴻⴷ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR3_2","025_3_2","JER","3","2","2","ⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵎ ⴷⵉ ⵍⴻⴳⵄⵓⴷⵉ ⵉ ⵅⴻⴼ ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ, ⵅⵣⴰⵔ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵛⴻⵎ ⵅⴰⵔⴹⴻⵏ? ⴰⵇⴰ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵔⴰⴱ ⴷⵉ ⵍⴻⵅⵍⴰ. ⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⴼⴻⵙⴷⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⴷ ⵍⵖⴰⵔ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR3_3","025_3_3","JER","3","3","3","ⵙ ⵓⵢⴰ ⵉⵜⵜⵡⴰⵎⵏⴻⵄ ⵡⴻⵏⵥⴰⵔ ⵓⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵡⵜⵉ ⵡⴻⵏⵥⴰⵔ ⴰⵊⵓⵔⵉ. ⵎⴰⵛⴰ ⵛⴻⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵎ ⵜⴰⵏⵢⴰⵔⵜ ⵜⴻⵇⵊⴰⵔ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵙⴻⴹⵃⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JR3_4","025_3_4","JER","3","4","4","ⵎⴰ ⵡⴰⵔ ⵜⴻⴱⴷⵉⴷ ⵎⵖⵉⵔ ⵉ ⵛⵡⴰⵢⵜ ⵏ ⵍⵡⴻⵇⵜ ⵡⴰⵀⴰ ⴰⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵍⴰⵖⴰⴷ ‘ⴱⴰⴱⴰ! ⵛⴻⴽ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JR3_5","025_3_5","JER","3","5","5","ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⵜⵜⴱⴻⴷⴷⴰ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵃⴹⴰ ⵉ ⵍⴻⴱⴷⴰ?’ ⵅⵣⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⴰⵔⴻⴷ, ⴰⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵎⴰⵍⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵓ ⵜᵉⵜⵜⵅⴰⵔⵔⵚⴻⴷ ⴰⵇⴰ ⴰⵢⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("JR3_6","025_3_6","JER","3","6","6","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵛⵉⵢⴰ: “ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵎⵉⵏ ⵜⴻⴳⴳⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵙⵔⴰⵉⵍ ⵉⴽⴼⴰⵔⴻⵏ? ⵏⴻⵜⵜⴰⵜ ⵜⴳⴻⵄⵄⴻⴷ ⴽⵓⵍ ⴰⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⵜⴻⵣⵣⴻⵍ ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴷⵉⵏ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ!    ");
INSERT INTO rift_vpl VALUES ("JR3_7","025_3_7","JER","3","7","7","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⴳⴳⴰ ⴰⵢⴰ, ⵏⵏⵉⵖ: ‘ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔⵉ!’, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍ ⵛⴰ. ⵅⴻⵏⵏⵉ ⵜⴻⵥⵔⵉ ⴰⵢⴰ ⵓⵍⵜⵎⴰⵙ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR3_8","025_3_8","JER","3","8","8","ⵥⵔⵉⵖ, ⵓⵎⵉ ⴷ ⴰⵙ ⴵⴼⴻⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵜⴻⵣⵏⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵙⵔⴰⵉⵍ ⵉⴽⴼⴰⵔⴻⵏ ⵓ ⵡⵛⵉⵖ ⴰⵙ ⵜⴰⴱⵔⴰⵜ ⵏ ⵡⴰⴵⴰⴼ, ⴰⵇⴰ ⴰⵢⴰ ⵡⴰⵔ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ ⵓⵍⵜⵎⴰⵙ ⵜⴰⵖⴻⴷⴷⴰⵔⵜ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵢⵓⵔ, ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR3_9","025_3_9","JER","3","9","9","ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵉⵀⴻⵡⵏⴻⵏ, ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴼⵙⴻⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵣⵏⴰ ⵙ ⵡⴻⵥⵔⵓ ⴷ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JR3_10","025_3_10","JER","3","10","10","ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵉ ⵜⴻⵄⵇⵉⴱ ⵓⵍⵜⵎⴰⵙ ⵢⴰⵀⵓⴷⴰ ⵜⴰⵖⴻⴷⴷⴰⵔⵜ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⴻⵙⵙⵏⵉⵄⵎⵉⵍ ⵡⴰⵀⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR3_11","025_3_11","JER","3","11","11","ⵙ ⵓⵢⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵜⴰⵡⴻⵍⵜⵎⴰⵜ ⵉⵙⵔⴰⵉⵍ ⵉⴽⴼⴰⵔⴻⵏ, ⴰⵇⴰ ⵜⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴱⴰⵏ-ⴷⴷ ⵜⵙⴻⴳⴳⴻⴷ ⴽⵜⴰⵔ ⵅ ⵓⵍⵜⵎⴰⵙ ⵢⴰⵀⵓⴷⴰ ⵜⴰⵖⴻⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR3_12","025_3_12","JER","3","12","12","ⵓⵢⵓⵔ, ⵍⴰⵖⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵉⵏⵉ: ‘ⴷⵡⴻⵍ-ⴷⴷ, ⴰ ⵛⴻⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵙⵔⴰⵉⵍ ⵉⴽⴼⴰⵔⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⵛⵉⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵛⵛⵓⵔⴻⵖ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵜⵜⴼⵓⴳⵎⴻⵖ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR3_13","025_3_13","JER","3","13","13","ⵎⴰⵛⴰ ⵏⵄⴻⵎ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ, ⴰⵇⴰ ⵜⵄⴻⴷⴷⵉⴷ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ, ⵓⵛⴰ ⵜⴻⴼⴼⵖⴻⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵖⴰⵔ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR3_14","025_3_14","JER","3","14","14","“ⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⴰ ⵜⴰⵔⵔⴰⵡⵜ ⵉⴽⴼⴰⵔⴻⵏ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵔⵢⴰⵣ ⵏⵡⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⴱⵍⴻⵖ ⵄⴰⵡⴻⴷ, ⵉⵊⵊ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵜⵏⴰⵢⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴰⴵ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR3_15","025_3_15","JER","3","15","15","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵉ ⵉⵅⵙ ⵡⵓⵍ ⵉⵏⵓ, ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵙⴻⵏ ⵙ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR3_16","025_3_16","JER","3","16","16","ⵅⵎⵉ ⵖⴰ ⵜⴻⵎⵎⴰⵔⴻⵏⵢⴻⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴰⴼⴻⴷ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ‘ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ!’ ⵡⴰⵔ ⴷⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⴰⵍⵉ ⵖⴰⵔ ⵍⴱⴰⵍ, ⵡⴰⵔ ⵜⵜ ⵜⵜⵉⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜ ⴼⴻⵇⵇⴷⴻⵏ ⵄⴰⴷ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜ ⵜⵜⵙⴻⵏⵏⴰⵄⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR3_17","025_3_17","JER","3","17","17","“ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ‘ⵍⴽⵓⵔⵙⵉ ⵏ ⵙⵉⴷⵉ!’, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵏⵏⵢⴰⵔⵡⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⴳⴳⵓⵔⴻⵏ ⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR3_18","025_3_18","JER","3","18","18","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⵜⵓⵢⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⴼⴼⵖⴻⵏⵜ ⵎⵓⵏⴻⵏⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR3_19","025_3_19","JER","3","19","19","“ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵏⵏⵉⵖ: ‘ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⵔⴻⵖ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵄⵉⵣⵣⴻⵏ, ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵍⴻⴳⵏⵓⵙ?’ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵖⴰⵔⵉ ⵍⴰⵖⴰⵏ: ⴱⴰⴱⴰ! ⵓⵛⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜᵉⵜⵜⵃⴻⵢⵢⵉⴷⴻⵎ ⵄⴰⴷ!’ ");
INSERT INTO rift_vpl VALUES ("JR3_20","025_3_20","JER","3","20","20","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵖⴷⴰⵔ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵖⴷⴰⵔⴻⵎ ⴰⵢⵉ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR3_21","025_3_21","JER","3","21","21","ⵉⵜⵜⵡⴰⵙⴻⵍ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵉⵇⴻⵛⵛⴰⵔⴻⵏ, ⴰⵏⵉⵅⵙⴻⵙ ⴷ ⵜⵓⵜⵔⴰ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⴼⴰⵔⵖⴻⵏ ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵜⵜⵓⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("JR3_22","025_3_22","JER","3","22","22","“ⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⴰ ⵜⴰⵔⵔⴰⵡⵜ ⵉⴽⴼⴰⵔⴻⵏ!, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⴳⴻⵏⴼⵉⵖ ⴰⴽⴼⴰⵔ ⵏⵡⴻⵎ.” “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⴰ, ⵏⴻⵛⵛⵉⵏ ⵏⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("JR3_23","025_3_23","JER","3","23","23","ⵏⵉⵛⴰⵏ ⵅ ⵡⴰⵍⵓ ⵉ ⵉⵜⵜⵔⴰⵊⴰ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⴷ ⴵⵖⴰⵔⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ. ⵏⵉⵛⴰⵏ, ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵉⴵⴰ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR3_24","025_3_24","JER","3","24","24","ⵍⴻⴼⴹⵉⵃⴻⵜ ⵜⴻⵛⵛⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵖ: ⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵙⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR3_25","025_3_25","JER","3","25","25","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵣⵣⴻⵍ ⴷⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵖ ⵓⵛⴰ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵖ ⵜⴻⴷⵍⴰ ⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵖ ⴰⵍ ⵉⴹⴰ. ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵍⵉ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR4_1","025_4_1","JER","4","1","1","“ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴷⴷ-ⵜⵄⴻⵇⴱⴻⴷ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔⵉ, ⵓ ⵎⴰⵍⴰ ⵜⴻⴽⴽⵙⴻⴷ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵡⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵅ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵜⴻⴷⴷⵓⵔⵉⴷ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JR4_2","025_4_2","JER","4","2","2","ⵊⴰⴵ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵍⵃⴻⵇⵇ ⵓ ⵙ ⵜⵙⴻⴳⴷⴰ, ⵉⵏⵉ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵙⵙⵄⵓⴵⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR4_3","025_4_3","JER","4","3","3","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⵛⴰⵔⵣⴻⵎ ⵉⵢⵢⴰⵔ ⵉⵅⵡⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴰⵔⵔⵄⴻⵎ ⴷⴻⴳ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR4_4","025_4_4","JER","4","4","4","ⵅⴻⵜⵏⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵙⵉⴷⵉ ⵓ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵎ ⵍⴻⵄⴷⴰⵍⴻⵢⵢⴰⵜ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ ⴰⵎ ⵜⵎⴻⵙⵙⵉ, ⴰⴷ ⵉⵛⵎⴻⴹ ⴱⵍⴰ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵙⵙⴻⵅⵙⵉ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR4_5","025_4_5","JER","4","5","5","“ⴱⴰⵔⵔⵃⴻⵎ ⵜⵜ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵊⵊⴻⵎ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵉⵎ: ‘ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ!’, ⵙⵖⵓⵢⵢⴻⵎ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵏⵉⵎ: ‘ⵙⵎⵓⵏⴻⵎ, ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JR4_6","025_4_6","JER","4","6","6","ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵉ ⵚⵉⵀⵢⵓⵏ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵎ ⵜⴱⴻⴷⴷⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⵖⴰⵔ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⵍⵎⵓⵚⵉⴱⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR4_7","025_4_7","JER","4","7","7","ⴰⵢⵔⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵛⴱⴰⵔⵇ ⵏ ⵍⵎⴰⵔⴳⴻⵃ ⵏⵏⴻⵙ, ⴰⵎⵜⴻⵃⵃⴰⵢ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵔⵓⵃ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ. ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("JR4_8","025_4_8","JER","4","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰⵔⴹⴻⵎ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵛⴻⴹⵏⴻⵎ ⵓ ⵡⴻⵄⵄⴹⴻⵎ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵉⵃⴻⵢⵢⴻⴷ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR4_9","025_4_9","JER","4","9","9","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: “ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵓⵍ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵓⵍⴰⵡⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴰⴷ ⴰⵙⴻⵏ ⵜⵔⴰⵃ ⵜⴰⵔⵢⴰⵙⵜ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵏⵏⵅⴻⵍⵄⴻⵏ ⵓⵛⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⴷ ⵜⴱⴻⵀⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR4_10","025_4_10","JER","4","10","10","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⴰⵅ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⵛⴻⴽ ⵜⵛⴻⵎⵜⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ!’ ⵅⵣⴰⵔ, ⵙⵙⵉⴼ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵄⴰⴷ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("JR4_11","025_4_11","JER","4","11","11","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⴰⵙⴻⵎⵎⵉⴹ ⵉⵙⵙⴻⵛⵎⴰⴹ ⵣⵉ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵜⵉⵇⴻⵛⵛⴰⵔⵉⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉ ⵓⵣⵓⵣⵣⴰⵔ ⵏⵉⵖ ⵉ ⵓⵚⴻⴼⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JR4_12","025_4_12","JER","4","12","12","ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵉⵊⵀⴻⴷ ⵅ ⵡⴰⵏⵉⵜⴰ. ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵃⴻⴽⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR4_13","025_4_13","JER","4","13","13","ⵅⵣⴰⵔ, ⵉⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵢⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵓⵛⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⴰⵎ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⵉⵢⵙⴰⵏ ⵏⵏⴻⵙ ⵜⵜⵉⵣⵡⴰⵔⴻⵏ ⵉ ⵉⴳⵉⴷⴰⵔⴻⵏ. ⵓⵛⵜ ⵏⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ!’” ");
INSERT INTO rift_vpl VALUES ("JR4_14","025_4_14","JER","4","14","14","“ⵙⵉⵔⴷ ⵓⵍ ⵏⵏⴻⵎ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⴷ! ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⴽⴽⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵎ?    ");
INSERT INTO rift_vpl VALUES ("JR4_15","025_4_15","JER","4","15","15","ⵎⵉⵏⵣⵉ ⵜⵎⵉⵊⵊⴰ ⵜᵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵣⵉ ⴷⴰⵏ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵜⴻⵛⵜⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ-ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR4_16","025_4_16","JER","4","16","16","ⴱⴰⵔⵃⴻⵎ ⵣⵣⴰⵢⴻⵙ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵊⵊⴻⵎ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵉⵎ: ‘ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⵚⴰⵔⴻⵏ ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ, ⵏⵉⵜⵏⵉ ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ.’ ");
INSERT INTO rift_vpl VALUES ("JR4_17","025_4_17","JER","4","17","17","ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵎ ⵢⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⵖⴻⵡⵡⴻⵖ ⵅⴰⴼⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR4_18","025_4_18","JER","4","18","18","ⵜⴰⴱⵔⵉⴷⵜ ⵏⵏⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵎ ⵉⵡⵢⴻⵏ ⴰⵎ-ⴷⴷ ⴰⵢⴰ. ⴰⵇⴰ-ⵜ ⴷ ⴰⵛⵜⴰⴱ ⴰⴱⴰⵔⵛⴰⵏ ⵏⵏⴻⵎ, ⵢⴰⵔⵣⴻⴳ, ⵉⵍⴻⵇⵇⴻⴼ ⵉ ⵛⴻⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR4_19","025_4_19","JER","4","19","19","“ⵄⴰⵡⴻⵏ ⴰⵢⵉ, ⴰⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ, ⴰⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵜⵜⴼⴰⵔⴼⵉⵔⴻⵖ ⵙ ⵍⴻⵡⵊⴻⵄ, ⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵡⵓⵍ ⵉⵏⵓ, ⵓⵍ ⵉⵏⵓ ⵉⵏⴻⴳⴳⴻⵣ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⴻⵖⴷⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵙⵓⴹⵉ ⵏ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵓⵛⵜ, ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JR4_20","025_4_20","JER","4","20","20","‘ⵜⵉⵛⵜⵉ ⵅ ⵜⴻⵛⵜⵉ!’, ⴰⵎⵎⵓ ⵉ ⵙⵖⵓⵢⵢⵓⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵅⴰⵔⵔⴻⴱ. ⴷⴻⵖⵢⴰ ⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵉⵏⵓ, ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⵜⵊⴰⵔⵜⵉⵍⵉⵏ ⵏ ⵓⵇⵉⴹⵓⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JR4_21","025_4_21","JER","4","21","21","ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ ⴰⴷ ⵜⵡⴰⵍⵉⵖ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓⵛⴰ ⴰⴷ ⵙⵍⴻⵖ ⵉ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ? ");
INSERT INTO rift_vpl VALUES ("JR4_22","025_4_22","JER","4","22","22","ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⴰⴱⵓⵀⴰⵍⵉ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵙⵉⵏⴻⵏ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴱⵍⴰ ⵍⴻⵄⵇⴻⵍ ⵓ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ. ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR4_23","025_4_23","JER","4","23","23","“ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ, ⵅⵣⴰⵔ, ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵍⴻⵅⵍⴰ ⴷ ⵍⵅⴰⵡⵉ ⵓ ⵡⴰⵔ ⵓⴼⵉⵖ ⵜⴰⴼⴰⵡⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR4_24","025_4_24","JER","4","24","24","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⴷⵓⵔⴰⵔ, ⵅⵣⴰⵔ, ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏⵜ ⵜⵜⵔⴰⵃⴻⵏⵜ ⴷ ⵜⵜⴰⵙⴻⵏⵜ ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JR4_25","025_4_25","JER","4","25","25","ⵏⴻⵛⵛ ⵜⵡⴰⵍⵉⵖ, ⵅⵣⴰⵔ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵜⵓⵖⴰ ⴹⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR4_26","025_4_26","JER","4","26","26","ⵏⴻⵛⵛ ⵥⵔⵉⵖ, ⵅⵣⴰⵔ, ⵜⴰⵎⵎⵓⵔⵜ ⵉⵙⵙⴻⵖⵎⴰⵢⴻⵏ ⵜⵓⵖⴰ ⴷ ⵍⴻⵅⵍⴰ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR4_27","025_4_27","JER","4","27","27","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵅⵍⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜ ⵇⴻⵟⵟⵄⴻⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR4_28","025_4_28","JER","4","28","28","ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵜⴻⵛⴹⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⴱⴱⴰⵔⵛⵏⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵜ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵅⴰⵙ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵏⴷⵉⵎⴻⵖ ⵛⴰ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵖ ⴷⴻⴳ ⵡⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JR4_29","025_4_29","JER","4","29","29","ⵣⵉ ⴷⴷⵔⵉⵣ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵢⵙⴰⵏ ⴷ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ ⵜⴰⵔⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ. ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵣⴻⵖⵔⴰⵏ ⵓⵛⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵅ ⵍⴻⵊⵔⵓⴼ, ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵜᵉⵜⵜⵡⴰⵊⵊ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⵓⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR4_30","025_4_30","JER","4","30","30","“ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵏⵏⵉ, ⴰ ⵛⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ? ⵡⴰⵅⵅⴰ ⴰⴷ ⵜⵢⴰⵔⴹⴻⴷ ⴰⵔⵔⵓⴹ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵏⵉⵖ ⴰⴷ ⵜⴻⵇⵇⵏⴻⴷ ⵍⴻⵀⵣⵓⵟ ⵏ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⴰⴷ ⵜⴽⴻⵃⵃⵍⴻⴷ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⵉⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ, ⴰⵇⴰ ⴱⴰⵟⴻⵍ ⴰⴷ ⵜⵣⴻⵡⵡⵇⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ. ⵉⵎⴻⵄⵛⴰⵇⴻⵏ ⴰⴷ ⵛⴻⵎ ⵙⵙⵃⴻⵇⵇⴰⵔⴻⵏ, ⴰⴷ ⴰⵔⵣⵓⵏ ⴰⴷ ⵛⴻⵎ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR4_31","025_4_31","JER","4","31","31","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵜⴻⵙⵍⵉⵖ ⵜⵎⵉⵊⵊⴰ, ⴰⵅⵎⵉ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ, ⴰⵅⵎⵉ ⵣⴻⴳ ⵉⵛⵜⴻⵏ ⵜⵃⴻⵚⵚⴰⵔ ⴷⵉ ⵜⴰⵔⵡⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵜⵍⴻⵇⵇⴻⴹ-ⴷⴷ ⵏⵏⴻⴼⵙ, ⵜⴻⵙⵙⵡⴰⵥⵥⴰⴹ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵜⴻⵙⵖⵓⵢⵢⵓ: ‘ⵓⵛⵜ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⴼⵏⴰ ⵙ ⵢⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("JR5_1","025_5_1","JER","5","1","1","“ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ ⵎⵍⵉⵃ. ⵉⵍⵉⵎ ⵜⴼⴻⵜⵏⴻⵎ ⵓ ⴰⵔⵣⵓⵎ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏⵏⴻⵙ, ⵎⴰ ⴰⴷ ⵜⴰⴼⴻⵎ ⵉⵊⵊⴻⵏ, ⵎⴰ ⴷⵉⵏ ⵉⵊⵊ ⵉⵜⵜⴻⴳⴳ ⵜⴰⵙⴻⴳⴷⴰ, ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵉⴷⴻⵜⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵖⴼⴰⵔⴻⵖ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR5_2","025_5_2","JER","5","2","2","ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ!’, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⵜⵊⴰⴵⴰⵏ ⵥⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("JR5_3","025_5_3","JER","5","3","3","“ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⵃⴻⵟⵟⴰⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵅ ⵜⵉⴷⴻⵜⵜ? ⵛⴻⴽ ⵜⴻⵡⵜⵉⴷ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⵛⵉⵏ ⴰⴽ-ⴷ ⵍⴻⵃⵔⵉⵇ, ⵛⴻⴽ ⵜⴻⵇⴹⵉⴷ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴱⴱⴰⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⴰⵏⵢⴰⵔⵜ ⵏⵙⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵅ ⵡⴻⵥⵔⵓ, ⵏⵉⵜⵏⵉ ⵓⴳⵉⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_4","025_5_4","JER","5","4","4","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴰⵀ, ⵏⵉⵜⵏⵉ ⴷ ⵍⵎⵓⵙⴰⴽⵉⵏ, ⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_5","025_5_5","JER","5","5","5","ⵏⴻⵛⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ.’ ⵏⵉⵜⵏⵉ ⵊⵎⵉⵄ ⵎⴰⵛⴰ ⴰⵔⵥⵉⵏ ⵣⵣⴰⵢⵍⴻⵜ, ⵇⴻⵟⵟⵙⴻⵏ ⵉⵙⴻⵖⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_6","025_5_6","JER","5","6","6","ⵅ ⵓⵢⴰ ⵉⵡⵡⴻⵜ ⵉ-ⵜⴻⵏ ⵡⴰⵢⵔⴰⴷ ⵏ ⵜⴰⴳⴰⵏⵜ, ⵉⵎⴻⵣⵣⴻⵇ ⵉ-ⵜⴻⵏ ⵡⵓⵛⵛⴻⵏ ⵣⵉ ⵍⴻⵡⴹⴰⵜ, ⵉⵜⵜⵃⴰⵎⴰ ⵓⵖⵉⵍⴰⵙ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ. ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜ ⵛⴰⵔⵔⴳⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ ⴷ ⴰⵟⵟⴰⵙ ⵓ ⴰⵃⴻⵢⵢⴻⴷ ⵏⵙⴻⵏ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ.”    ");
INSERT INTO rift_vpl VALUES ("JR5_7","025_5_7","JER","5","7","7","“ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵖⴼⴰⵔⴻⵖ ⵎⴰⵏ ⴰⵢⴰ? ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ, ⵜⵜⵊⴰⴵⴰⵏ ⵖⴰⵔ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ. ⵍⴰⵎⵉ ⵜⴻⵏ ⵙⵙⵊⵉⵡⵏⴻⵖ, ⵣⴻⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ, ⵙⵙⵎⵓⵏⴻⵏ ⵙ ⴷⴷⵃⴰⵙ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR5_8","025_5_8","JER","5","8","8","ⵏⵉⵜⵏⵉ ⴷ ⵉⴽⵉⴷⴰⵔⴻⵏ ⵉⵄⴻⵍⴼⴻⵏ ⵉⵜⵜⴻⵍⵉⵄⴻⵏ. ⴽⵓⵍ ⵉⵊⵊ ⵉⵙⵙⵏⴻⵃⵏⵉⵃ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR5_9","025_5_9","JER","5","9","9","ⵎⴰ ⵡⴰⵔ ⵜⵜⵄⵉⵇⵉⴱⴻⵖ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⵉⵖ ⵡⴰⵔ ⵉⵜⵜⴻⵏⵜⵉⵇⵉⵎ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⴳⴻⵏⵙ ⴰⵎ ⵡⴰⵏⵉⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("JR5_10","025_5_10","JER","5","10","10","“ⴳⴻⵄⵄⴷⴻⵎ ⵅ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵀⴻⴷⵎⴻⵎ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵎⴻⵙⵙⵃⴻⵎ ⵇⴰⵄ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵇⴻⵍⵄⴻⵎ ⵉⵣⴱⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR5_11","025_5_11","JER","5","11","11","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵛⴰ ⵖⴷⴰⵔⴻⵏ ⴰⵢⵉ ⵙ ⵡⴰⵟⵟⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR5_12","025_5_12","JER","5","12","12","ⵏⵉⵜⵏⵉ ⵏⴻⴽⴽⴰⵔⴻⵏ ⵙⵉⴷⵉ, ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵍⴻⵇⵇⴻⴼ ⵍⵖⴰⵔ, ⵡⴰⵔ ⵏⴻⵜⵜⵡⵉⵍⵉ ⵙⵙⵉⴼ ⵓⵍⴰ ⴷ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("JR5_13","025_5_13","JER","5","13","13","ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵉⵎⵙⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("JR5_14","025_5_14","JER","5","14","14","“ⵙ ⵓⵢⴰ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴰⵡⴰⵍ-ⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴷ ⵜⵉⵎⴻⵙⵙⵉ, ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⴰⴽⴻⵛⵛⵓⴹ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JR5_15","025_5_15","JER","5","15","15","ⵅⵣⴰⵔ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⵉⵡⴹⴻⵖ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⴰⵇⴰ-ⵜ ⴷ ⵍⴳⴻⵏⵙ ⵉⵡⵄⴰⵔ, ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵍⴳⴻⵏⵙ ⵉ ⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴻⴽ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵓ ⵡⴰⵔ ⵜⴼⴻⵀⵀⵎⴻⴷ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR5_16","025_5_16","JER","5","16","16","ⴰⵣⴻⵄⴱⵓⵍ ⵏⵏⴻⵙ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵏⴹⴻⵍ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JR5_17","025_5_17","JER","5","17","17","ⴰⴷ ⵉⵛⵛ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵎ ⴷ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵎ, ⴰⴷ ⵉⵛⵛ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴷ ⵢⴻⵙⵙⵉⵎ, ⴰⴷ ⵉⵛⵛ ⵓⴵⵉ ⵏⵏⴻⵎ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵏⴻⵎ, ⴰⴷ ⵉⵛⵛ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵎ ⴷ ⵡⴰⵔⵜⵓ ⵏⵏⴻⵎ, ⵓⵛⴰ ⵙ ⵙⵙⵉⴼ ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵎⵉⵏ ⵅⴻⴼ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR5_18","025_5_18","JER","5","18","18","“ⵎⴰⵛⴰ ⵓⵍⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵇⴻⵟⵟⵉⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR5_19","025_5_19","JER","5","19","19","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ?’, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⴻⵏⵏⵉⵡ ⴷⴰⵢⵉ ⵜⵙⴻⵎⵃⴻⵎ, ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR5_20","025_5_20","JER","5","20","20","“ⴱⴰⵔⵔⵃⴻⵎ ⴰⵢⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵊⵊⴻⵎ ⴰⴷ ⵜ ⵙⵍⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("JR5_21","025_5_21","JER","5","21","21","‘ⵙⵍⴻⵎ ⵉ ⵡⴰⵢⴰ, ⴰ ⵛⴻⴽ ⵍⴳⴻⵏⵙ ⴰⴱⵓⵀⴰⵍⵉ, ⵏⴻⵀⵍⴰ ⵡⵓⵍ! ⵖⴰⵔⵡⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏⵜ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_22","025_5_22","JER","5","22","22","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⵜᵉⵜⵜⴰⵔⵊⵉⵊⵉⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵉ ⵏⴻⵛⵛ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉ ⵍⴻⴱⵃⴰⵔ ⵉⵊⴷⵉ ⴷ ⵡⴻⵢⵎⵉⵔ, ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵄⴷⵓⵏ ⵍⴻⵎⵡⴰⵊ. ⴰⵇⴰ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⵍⴻⵎⵡⴰⵊ, ⵄⴰⴷ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ, ⵜⵜⵀⴰⵊⴰⵏ ⵍⴻⵎⵡⴰⵊ, ⵄⴰⴷ ⵡⴰⵔ ⵜⵜ ⵄⴻⴷⴷⵓⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JR5_23","025_5_23","JER","5","23","23","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵖⴰⵔⴻⵙ ⵓⵍ ⵉⵃⴻⵢⵢⴷⴻⵏ ⴷ ⵉⵖⴻⵡⵡⵖⴻⵏ. ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_24","025_5_24","JER","5","24","24","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳⵯⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⵏⵥⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ, ⴰⵏⵥⴰⵔ ⵏ ⵣⵉⵛ ⴷ ⵡⴻⵏⵥⴰⵔ ⵏ ⵍⴻⵅⵎⵉⵎ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵉ ⵏⴻⵛⵛⵉⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵜⵎⴻⵢⵔⴰ.’ ");
INSERT INTO rift_vpl VALUES ("JR5_25","025_5_25","JER","5","25","25","ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵡⴻⵎ ⵎⴻⵏⵄⴻⵏⵜ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵟⵟⴼⴻⵏ ⵅⴰⵡⴻⵎ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_26","025_5_26","JER","5","26","26","ⵎⴰⵖⴰⵔ ⵓⴼⵉⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⵜⵜⵃⴰⵎⴰⵏ ⴰⵎ ⵢⵉⵢⴻⵎⵎⴰⵔⴻⵏ ⵏ ⵢⴻⵊⴹⴰⴹ. ⵙⵙⴱⴻⴷⴷⴰⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵉⵏⴻⵇⵇⴻⵏ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR5_27","025_5_27","JER","5","27","27","ⴰⵎ ⵍⴻⵇⴼⴻⵣ ⵉⵛⵛⵓⵔ ⵙ ⵉⵊⴹⴰⴹ, ⴰⵎⵎⵓ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵍⵖⴻⵛⵛ. ⵅ ⵓⵢⴰ ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JR5_28","025_5_28","JER","5","28","28","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵓⴼⴼⴻⵏ ⵙ ⵜⴰⴷⵓⵏⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵃⵔⴰⵢⵎⵉⵢⵢⴻⵏ, ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵙⵙⵄⴻⴷⴷⵓⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⴰⵟⵟⴰⵙ. ⵡⴰⵔ ⵃⴻⴽⴽⵎⴻⵏ ⵙ ⵍⵃⴻⵇⵇ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ, ⵓⵍⴰ ⴷⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵓⵢⵓⵊⵉⵍ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴼⴻⵍⵃⴻⵏ ⵏⵉⵜⵏⵉ. ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵛⵛⵉⵜⴻⵏ ⵅ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("JR5_29","025_5_29","JER","5","29","29","ⵎⴰ ⵡⴰⵔ ⵜⵜⵄⵉⵇⵉⴱⴻⵖ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⵅⴻⴵⴼⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵍⴳⴻⵏⵙ ⴰⵎ ⵡⴰⵏⵉⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("JR5_30","025_5_30","JER","5","30","30","“ⵎⵉⵏ ⵉⵜⵜⴻⵏⴻⵅⵍⴰⵄⴻⵏ ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵏⵏⵄⵉ ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR5_31","025_5_31","JER","5","31","31","ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵜⵚⴻⴵⴹⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵙⴻⵏ. ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⴰⵎⵎⵓ. ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴻⴹ ⵇⴻⵟⵟⵓ?” ");
INSERT INTO rift_vpl VALUES ("JR6_1","025_6_1","JER","6","1","1","“ⵙⵉⵡⴹⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷⵉ ⵍⴰⵎⴰⵏ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓⵛⴰ ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵜⴰⵇⵓⵄⴰ. ⵙⴳⴻⵄⵄⴷⴻⵎ ⴰⵛⴻⵏⵢⴰⵍ ⵙ ⴷⴷⴻⵅⵅⴰⵏ ⵣⵉ ⴱⴰⵢⵜ-ⵀⴰ-ⴽⴰⵔⵉⵎ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⵉⴳⵯⴰⴷ ⵍⵖⴰⵔ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⵍⵎⵓⵚⵉⴱⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR6_2","025_6_2","JER","6","2","2","ⵜⴰⵎⵖⴰⵔⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⴱⵓⴹⴻⵏ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵜⵜ ⵙⵙⵀⴻⵍⵍⴽⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR6_3","025_6_3","JER","6","3","3","ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙ ⴷⴷ-ⵇⴻⵡⵡⴰⵔⴻⵏ, ⴰⴷ ⵡⵜⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵅⴰⵙ, ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⴷⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR6_4","025_6_4","JER","6","4","4","ⴰⴷ ⵉⵏⵉⵏ ‘ⵇⴻⴷⴷⵙⴻⵎ ⴰⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⴽⴽⴰⵔⴻⵎ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵙ ⵏⴳⴻⵄⵄⴻⴷ ⵙ ⵓⵣⵉⵍ. ⵓⵛⵜ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵄⵍⴰⵢⴻⵏ ⵉⵄⴷⵓ, ⵎⵉⵏⵣⵉ ⵜⵉⵍⵉⵡⵉⵏ ⵏ ⵜⵎⴻⴷⴷⵉⵜ ⵜⵜⵙⴰⵔⵔⵃⴻⵏⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JR6_5","025_6_5","JER","6","5","5","ⴽⴽⴰⵔⴻⵎ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵙ ⴵⵉⵍⴻⵜ, ⴰⴷ ⵏⴻⵀⴷⴻⵎ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("JR6_6","025_6_6","JER","6","6","6","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⴻⵙⴽⴰⵔⴰⵜ: ⵇⴻⵙⵙⴻⵎ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ, ⵙⴱⴻⴷⴷⴻⵎ ⴰⵛⴱⴰⵔ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴹⵉⴷⴷ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵄⴰⵇⴻⴱ, ⴰⵇⴰ ⴷⴷⴻⴵ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR6_7","025_6_7","JER","6","7","7","ⴰⵎ ⵡⴰⵏⵓ ⵉⵜⵜⴻⵊⵊⴰ ⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵜⵜⴱⴻⵇⴱⵓⵇⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⴻⵊⵊⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵉⴱⴻⵇⴱⴻⵇ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ⵍⵃⴻⵙⵙ ⵏ ⵍⵄⵓⵏⴼ ⴷ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵉⵜⵜⵡⴰⵙⴻⵍ ⴷⴰⵢⴻⵎ, ⵍⴻⵃⵍⴰⵛ ⴷ ⵜⴻⵢⵢⵉⵜⴰ ⴰⵇⴰ-ⵜⴻⵏⵜ ⵍⴻⴱⴷⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR6_8","025_6_8","JER","6","8","8","ⴻⵊⵊ ⵉ ⵛⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵡⴻⴱⴱⵅⴻⴷ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵡⴰⵔ ⵅⴰⵎ ⵜᵉⵜⵜⴻⵎⵙⴻⴱⴹⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⴰⵔⵔⵉⵖ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵅⵍⴰⵏ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR6_9","025_6_9","JER","6","9","9","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰⵎ ⵜⵣⴰⵢⴰⵔⵜ ⴰⴷ ⵍⴻⵇⴹⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵛⴹⴰⵔⴻⵜ. ⴰⵔⵔ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵙⴻⴹⵡⵉⵏ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵍⴻⵇⵇⴹⴻⵏ ⴰⴹⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("JR6_10","025_6_10","JER","6","10","10","ⵡⵉ ⵖⴰⵔ ⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵏⵉⵖ ⵓⵎⵉ ⵖⴰ ⵄⴻⵍⵎⴻⵖ ⵏⴻⵛⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵏ? ⵅⵣⴰⵔ, ⴰⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵍⵓ. ⴰⵇⴰ ⴷⴰ, ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵜⵜⴰⴼⴻⵏ ⵜⴻⵏ ⴷ ⴰⵃⴻⵛⵛⵉ, ⵡⴰⵔ ⵜⴻⵏ ⵃⴷⵉⵊⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR6_11","025_6_11","JER","6","11","11","“ⵙ ⵓⵢⴻⵏⵏⵉ ⵛⵛⵓⵔⴻⵖ ⵙ ⵡⴻⵙⵄⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵓⵃⵍⴻⵖ ⴰⴷ ⵜ ⵎⴻⵏⵄⴻⵖ. ‘ⵣⴻⴵⴻⵄ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵅⴻⵏⵏⵉ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵍⴰ ⵅ ⵓⵎⵓⵏⵉ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵄⴰⴷ ⴰⵔⵢⴰⵣ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⵏ ⵃⴻⴱⴱⵙⴻⵏ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⴰⵎⵖⴰⵔ ⴷ ⵓⵡⴻⵙⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR6_12","025_6_12","JER","6","12","12","ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵉ ⵉⵏⵏⴻⵖⵏⵉ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵃⵡⵉⵛⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵡⵉⵥⵥⴹⴻⵖ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR6_13","025_6_13","JER","6","13","13","ⵎⴰⵖⴰⵔ ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵉⵣⵉ ⵏⵙⴻⵏ, ⵓ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⴰⵍ ⴰⴽⴻⵀⵀⴰⵏ ⵎⴰⵔⵔⴰ ⵜⵛⴻⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JR6_14","025_6_14","JER","6","14","14","ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵅⵙⴻⵏ ⴰⴷ ⵜⵜ ⵙⵙⴳⴻⵏⴼⴰⵏ ⵙ ⵍⴻⵀⵡⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ‘ⵍⴻⵀⵏⴰ, ⵍⴻⵀⵏⴰ!’, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⴻⵀⵏⴰ.    ");
INSERT INTO rift_vpl VALUES ("JR6_15","025_6_15","JER","6","15","15","ⵎⴰ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵎⵉⵏⵣⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ? ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ ⵛⴰ, ⵍⴻⵃⵢⴰ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵏ. ⵙ ⵓⵢⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⵡⴻⵟⵟⴰⵏ. ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵅⴻⵍⴼⴻⵖ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR6_16","025_6_16","JER","6","16","16","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴱⴻⴷⴷⴻⵎ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ, ⵓⵛⴰ ⵃⴷⴰⵎ, ⵙⴻⵇⵙⴰⵎ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⴱⵔⵉⴷ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵎ ⵅⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼⴻⵎ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ!’ ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⴳⴳⵓⵔ!’ ");
INSERT INTO rift_vpl VALUES ("JR6_17","025_6_17","JER","6","17","17","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵡⴻⵎ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵏⵏⵉⵖ: ‘ⵙⵍⴻⵎ ⵉ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ!’, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵏⴻⵙⵃⴻⵙⵙⵉ ⵛⴰ!’ ");
INSERT INTO rift_vpl VALUES ("JR6_18","025_6_18","JER","6","18","18","ⵙ ⵓⵢⴰ ⵙⵍⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴳⵏⵓⵙ, ⵓ ⵛⴻⵎ, ⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ!, ⵙⵙⴻⵏ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JR6_19","025_6_19","JER","6","19","19","ⵙⴻⵍ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⵖⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵍⴳⴻⵏⵙ-ⴰ, ⵍⵖⵉⴵⴻⵜ ⵏ ⵉⵏⵡⴰⵢⴻⵏ ⵏⵙⴻⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵛⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵓ ⵏⴹⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR6_20","025_6_20","JER","6","20","20","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵊⵊⴰⵡⵉ ⵣⵉ ⵛⴰⴱⴰ ⴷ ⵓⵖⴰⵏⵉⵎ ⵓⵃⴻⵎⵎⵓⵎ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵉⴳⴳⵯⴻⵊⴻⵏ? ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵡⴻⵎ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵓⵙⵉⵏⵜ ⵉ ⵍⵅⴰⴹⴰⵔ ⵓ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵄⵊⵉⴱⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR6_21","025_6_21","JER","6","21","21","ⵙ ⵓⵢⴰ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⵄⴻⵏⴽⵔⵉⴼⵉⵏ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵏⵏⵇⴰⵔⴹⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⴰⴽ-ⴷ ⵡⴰⵊⵊⴰⵔ ⴷ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵀⴻⵍⵍⴽⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR6_22","025_6_22","JER","6","22","22","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR6_23","025_6_23","JER","6","23","23","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵍⵇⴻⵡⵙ ⴷ ⵡⴻⵃⵔⵉⵛ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵡⵄⴰⵔ, ⵡⴰⵔ ⴰⵔⵔⴻⵃⵎⴻⵏ. ⴷⴷⵔⵉⵣ ⵏⵙⴻⵏ ⵉⴳⴳⴰ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ. ⴰⵎ ⵡⴻⵔⵢⴰⵣ ⵏ ⵓⵎⴻⵏⵖⵉ ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵏⴻⵜⵜⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵏⵏⴻⵎ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ!” ");
INSERT INTO rift_vpl VALUES ("JR6_24","025_6_24","JER","6","24","24","“ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵅⴰⵙ ⵍⴻⵅⴱⴰⵔ, ⴰⵔⵅⵓⵏ ⴰⵏⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ, ⵉⵍⵇⴻⴼ ⴰⵏⴻⵖ ⵓⵏⴻⴷⵇⴻⴼ, ⵍⴻⵃⵔⵉⵇ ⴰⵎ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR6_25","025_6_25","JER","6","25","25","ⵡⴰⵔ ⵜⵜⴻⴼⴼⵖⴻⵎ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ, ⵡⴰⵔ ⴳⴳⵓⵔⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵙⵙⵉⴼ ⵏ ⵍⴻⵄⴷⵓ, ⵜⵉⴳⴳⵯⵓⴷⵉ ⴰⵇⴰ-ⵜⵜ ⵎⴰⵏⵉ ⵎⴰ! ");
INSERT INTO rift_vpl VALUES ("JR6_26","025_6_26","JER","6","26","26","ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴱⴻⵢⵙⴻⵜ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵣⵓⵣⵣⴰⵔ ⵅⴰⵎ ⵉⵖⵖⴻⴹ, ⵛⴻⴹⵏⴻⵜ ⴰⵎ ⵅ ⵓⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵏⵏⴻⵎ, ⵙⵖⵓⵢⵢ ⵙ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴰⵎⴻⵔⵣⴰⴳⵜ, ⵎⴰⵖⴰⵔ ⴷⴻⵖⵢⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵢⴰⵙ ⵓⵎⵜⴻⵃⵃⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("JR6_27","025_6_27","JER","6","27","27","“ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⴷⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵍⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴰⵔⵣⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("JR6_28","025_6_28","JER","6","28","28","“ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷ ⵉⵏⵏⵉ ⵉⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵣⵉ ⵎⴰⵔⴽⴰⵜ ⵉⵡⵄⴰⵔⴻⵏ ⵇⴰⵄ, ⴳⴳⵓⵔⴻⵏ ⵜⵜⴻⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⵎ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵎⵓⵔⴹⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR6_29","025_6_29","JER","6","29","29","ⴰⵔⵔⴰⴱⵓⵣ ⵉⵛⵎⴻⴹ, ⵍⴻⵅⴼⵉⴼ ⵜⴻⵛⵛⴰ ⵜ ⵜⵎⴻⵙⵙⵉ, ⵎⴰⵛⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⵉⵙⵙⴻⴼⵙⵉ ⵓⴼⴻⵙⵙⴰⵢ ⴰⵎⵎⵓ ⵙ ⵡⴻⵛⴹⴰⵔ, ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR6_30","025_6_30","JER","6","30","30","ⵇⵇⴰⵔⴻⵏ ⴰⵙ: ‘ⵏⵏⵓⵇⴰⵔⵜ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ!’, ⵎⴰⵖⴰⵔ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR7_1","025_7_1","JER","7","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR7_2","025_7_2","JER","7","2","2","“ⴱⴻⴷⴷ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵍⴰⵖⴰ ⴷⵉⵏⵏⵉ ⴰⵡⴰⵍ-ⴰ, ⵉⵏⵉ: ‘ⵙⵍⴻⵎ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵔⵔⴰ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ-ⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⵏⴷⵇⴻⵎ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR7_3","025_7_3","JER","7","3","3","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵄⴻⴷⵍⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵣⴻⴷⵖⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR7_4","025_7_4","JER","7","4","4","ⵡⴰⵔ ⵜⵜⵛⴰⵍⴻⵎ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴰⵎ ⵜⴻⵇⵇⴰⵔⴻⵎ: ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰ ⵣⴻⵄⵎⴰ! ");
INSERT INTO rift_vpl VALUES ("JR7_5","025_7_5","JER","7","5","5","ⵎⴰⵖⴰⵔ ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⵄⴻⴷⵍⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵏⵉⵛⴰⵏ, ⵎⴰⵍⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵍⵃⴻⵇⵇ ⵊⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JR7_6","025_7_6","JER","7","6","6","ⵡⴰⵔ ⵃⴻⵚⵚⴰⵔⴻⵎ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴰⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ, ⵓ ⵡⴰⵔ ⵙⵙⵉⵣⵣⵉⵍⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵡⴰⵔ ⴹⴻⴼⴼⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JR7_7","025_7_7","JER","7","7","7","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵣⴻⴷⵖⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⵛⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR7_8","025_7_8","JER","7","8","8","ⵅⵣⴰⵔ, ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵛⴰⵍⴰⵎ ⵅ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ ⴷⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JR7_9","025_7_9","JER","7","9","9","ⵜᵉⵜⵜⴰⵛⴰⵔⴻⵎ, ⵜⵏⴻⵇⵇⴻⵎ, ⵜⵣⴻⵏⵏⴰⵎ, ⵜᵉⵜⵜⵊⴰⴵⴰⵎ ⵥⵓⵔ, ⵜᵉⵜⵜⵇⴻⴷⴷⴰⵎⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⴱⴰⵄⵍ ⵓ ⵜⴹⴻⴼⴼⴰⵔⴰⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JR7_10","025_7_10","JER","7","10","10","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⵎ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⵣⴻⵄⵎⴻⵎ ⵄⴰⴷ ⴰⴷ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵄⴰⵡⴰⴷⴻⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("JR7_11","025_7_11","JER","7","11","11","ⵎⴰ ⵜⴻⴷⵡⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷ ⵉⴼⵔⵉ ⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ? ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵜ ⵎⵍⵉⵃ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR7_12","025_7_12","JER","7","12","12","“ⵡⴰⵅⵅⴰ, ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵏⵓ ⴷⵉ ⵛⵉⵍⵓ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵙⵙⵣⴻⴷⵖⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⵅⵣⴰⵔⴻⵎ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⴳⴳⵉⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR7_13","025_7_13","JER","7","13","13","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ-ⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ, ⵓ ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⴰⵔⵔⵉⵎ,    ");
INSERT INTO rift_vpl VALUES ("JR7_14","025_7_14","JER","7","14","14","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵎⵉⵏ ⵅⴻⴼ ⵜᵉⵜⵜⵛⴰⵍⴰⵎ, ⵓ ⴰⴽ-ⴷ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵛⵉⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JR7_15","025_7_15","JER","7","15","15","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴹⴰⵔⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴹⴰⵔⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ, ⵎⴰⵔⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR7_16","025_7_16","JER","7","16","16","“ⴰ ⵛⴻⴽ, ⵡⴰⵔ ⵜⵜⵥⴰⴵ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⵡⴰⵔ ⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⵔⵓⴷ ⵏⵉⵖ ⴰⴷ ⵜⴻⵥⵥⴰⴵⴻⴷ ⵓ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⵜᵉⵜⵜⵔⵓⴷ-ⴷⴷ ⵖⴰⵔⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵜⵜⴻⵙⵍⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JR7_17","025_7_17","JER","7","17","17","ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵍⵉⴷ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ? ");
INSERT INTO rift_vpl VALUES ("JR7_18","025_7_18","JER","7","18","18","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵙⵙⵎⵓⵏⴰⵎ ⴰⴽⴻⵛⵛⵓⴹ, ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵙⵙⵔⴰⵇⵇⴰⵏ ⵜⵉⵎⴻⵙⵙⵉ, ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵜⴻⴳⴳⵡⴻⵏⵜ ⴰⵔⴻⵛⵜⵉ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏⵜ ⵜⵉⴼⴹⵉⵍⵉⵏ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴼⴰⵔⵔⵖⴻⵏⵜ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵣⵣⴰⵜ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR7_19","025_7_19","JER","7","19","19","ⵎⴰ ⵙⵄⴰⵔⴻⵏ ⴰⵢⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ? ⵎⴰ ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR7_20","025_7_20","JER","7","20","20","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⴰⴷ ⵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⴷ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ: ⵅ ⵉⵡⴷⴰⵏ, ⵅ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵅ ⵜⵛⴻⵊⵊⵓⵔⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓ ⵅ ⵍⵖⵉⴵⴻⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⴷ ⵢⴰⵔⴻⵇⵇ ⵡⴰⵀ, ⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR7_21","025_7_21","JER","7","21","21","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵙⵎⵓⵏⴻⵎ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵜⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵓⵛⴰ ⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR7_22","025_7_22","JER","7","22","22","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵡⴻⵚⵚⵉⵖ ⵅ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵉ. ");
INSERT INTO rift_vpl VALUES ("JR7_23","025_7_23","JER","7","23","23","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵓⵎⵉ ⵏⵏⵉⵖ: ‘ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵓ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⴰⴱⵔⵉⴷ ⵎⴰⵔⵔⴰ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵓⵎⵓⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⵎⵍⵉⵃ!’ ");
INSERT INTO rift_vpl VALUES ("JR7_24","025_7_24","JER","7","24","24","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⵓⵎⴻⵣⵣⵓⵖ, ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴷ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR7_25","025_7_25","JER","7","25","25","ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴼⴼⵖⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⴰⵙⵙ-ⴰ, ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR7_26","025_7_26","JER","7","26","26","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵉ ⵙⵍⵉⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⴰⵎⴻⵣⵣⵓⵖ. ⵏⵉⵜⵏⵉ ⴰⵔⵏⵉⵏ ⴷⵉ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵎⴰⵀⵓ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR7_27","025_7_27","JER","7","27","27","ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⴽ ⵜⵜⴻⵙⵍⵉⵏ ⵛⴰ. ⵛⴻⴽ ⴰⴷ ⴰⵙⴻⵏ ⵜⵍⴰⵖⵉⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⴽ ⴷⴷ-ⵜⵜⴰⵔⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR7_28","025_7_28","JER","7","28","28","ⵙ ⵓⵢⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵡⴰ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵡⴻⴱⴱⴻⵅ. ⴰⵇⴰ ⵜⵉⴷⴻⵜⵜ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵓ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("JR7_29","025_7_29","JER","7","29","29","“ⵃⴻⴼⴼ ⵜⴰⵊⵊ ⵏⵏⴻⵛ ⵏ ⵡⴻⵄⵣⴰⵍ ⵓⵛⴰ ⵏⴹⴰⵔ ⵉ-ⵜ, ⵡⵡⴻⵜ ⵙ ⵉⴳⴻⵊⴷⵓⵔⴻⵏ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵎⴰⵏⵉ ⵜⵜⵡⴻⵀⵀⴱⴻⵏⵜ ⴷⴷⴱⴰⵢⴻⵃ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⴹⴰⵔ ⵊⵊⵉⵍ ⵎⵉⵏ ⵅⴻⴼ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵓⴼⵓⴳⴻⵎ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("JR7_30","025_7_30","JER","7","30","30","ⵎⴰⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵙⵙⵅⴻⵎⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR7_31","025_7_31","JER","7","31","31","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⵓⴼⴰⵜ ⵎⴰⵏⵉ ⵜⵜⵡⴻⵀⵀⴱⴻⵏⵜ ⴷⴷⴱⴰⵢⴻⵃ, ⴷ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵎⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵓⵎⵓⵔⴻⵖ ⴷ ⵎⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴷⴷⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴱⴰⵍ.”    ");
INSERT INTO rift_vpl VALUES ("JR7_32","025_7_32","JER","7","32","32","“ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵍⴰⵖⴰⵏ ⵄⴰⴷ ‘ⵜⵓⴼⴰⵜ’ ⵏⵉⵖ ‘ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ’, ⵎⴰⵛⴰ ‘ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵡⴻⵏⵖⴰⵢ’, ⵓⵛⴰ ⴷⵉ ⵜⵓⴼⴰⵜ ⴰⴷ ⵏⴻⴹⵍⴻⵏ ⵉⵎⴻⵜⵜⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⴰⵎⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR7_33","025_7_33","JER","7","33","33","ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵉⴳⴳⵯⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JR7_34","025_7_34","JER","7","34","34","ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵎⵓⵍⴰⵢ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴻⵙⵍⵉⵜ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵅⴰⵔⴱⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR8_1","025_8_1","JER","8","1","1","“ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵉⵖⵙⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵖⵙⴰⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ, ⵉⵖⵙⴰⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵙⴻⵏ, ⵉⵖⵙⴰⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⴷ ⵢⴻⵖⵙⴰⵏ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR8_2","025_8_2","JER","8","2","2","ⴰⴷ ⴱⴻⵣⵣⵄⴻⵏ ⵉⵅⵙⴰⵏ ⵉ ⵜⴼⵓⵛⵜ ⴷ ⵜⵣⵉⵔⵉ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴻⴱⴱⴷⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴹⴻⴼⴼⴰⵔⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵛⵛⵡⴰⵔ ⴷ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵙⴻⵊⵊⴰⴷⴻⵏ. ⵡⴰⵔ ⵜⴻⵏ ⴷⴷ-ⵢⴰⵔⵔⵡⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵟⵟⵍⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴻⵖⴱⴰⵔ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR8_3","025_8_3","JER","8","3","3","ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⵙⴻⵏ ⵍⵎⴻⵡⵜ ⵅ ⵜⵓⴷⴰⵔⵜ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⴵⴰⵏ ⵉⵏⵏⵉ ⵄⴰⴷ ⵉⵇⵇⵉⵎⴻⵏ, ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵓⵥⵥⵍⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR8_4","025_8_4","JER","8","4","4","“ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵎⴰ ⴰⴷ ⵡⴹⴰⵏ ⴰⵍ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵡⴰⵔ ⵜⵜⴻⴽⴽⴰⵔⴰⵏ ⵄⴰⴷ? ⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR8_5","025_8_5","JER","8","5","5","ⵎⴰⵢⴻⵎⵎⵉ ⵉⵃⴻⵢⵢⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ, ⵓⵔⵛⴰⵍⵉⵎ ⵜⴰⵏⵉⵜⴰ, ⵍⴻⴱⴷⴰ ⵣⵣⴰⵢⵉ? ⵏⵉⵜⵏⵉ ⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⵛⵎⴰⵜ, ⵓⴳⵉⵏ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR8_6","025_8_6","JER","8","6","6","ⵏⴻⵛⵛ ⵙⵙⵃⴻⵙⵙⴻⵖ, ⵙⵍⵉⵖ: ⵎⵉⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵏⴷⵉⵎ ⵅ ⵍⵖⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵏⵉ: ⵎⵉⵏ ⴳⴳⵉⵖ? ⴽⵓⵍ ⵉⵊⵊ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴰⵣⵣⴻⵍ ⴰⵎ ⵓⵢⵉⵙ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JR8_7","025_8_7","JER","8","7","7","ⵓⵍⴰ ⴷ ⴰⴱⴻⵍⵍⴰⵔⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉⵙⵙⴻⵏ ⵍⴻⵡⵇⴰⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏⵏⴻⵙ. ⵜⴰⵊⵍⵉⵍⵍⴻⵃⵜ ⴷ ⵜⴼⴰⵍⴵⴻⵙⵜ ⵏⵏⵉ ⵉⵟⵟⴰⵡⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ, ⵃⴹⴰⵏⵜ ⵍⵡⴻⵇⵜ ⵏ ⵡⵓⴼⴼⵓⵖ ⵏⵙⴻⵏⵜ, ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵍⵃⴻⵇⵇ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR8_8","025_8_8","JER","8","8","8","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⵎ: ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⵏⴻⵖ! ⵙ ⵜⵉⴷⴻⵜⵜ, ⵅⵣⴰⵔ, ⵍⴻⵇⵍⴻⵎ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵏ ⵉⵎⴰⵔⵉⵔⴻⵏ ⵉⴳⴳⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⴰⵅⴰⵔⵔⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("JR8_9","025_8_9","JER","8","9","9","ⵉⵎⵉⵖⵉⵙⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ, ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ. ⵅⵣⴰⵔ, ⵏⴹⴰⵔⴻⵏ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⵜⵉⵖⵉⵜ ⵉ ⵖⴰⵔⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JR8_10","025_8_10","JER","8","10","10","“ⵙ ⵓⵢⴰ ⴰⴷ ⵡⵛⴻⵖ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵉ ⵉⵏⵏⴻⵖⵏⵉ, ⵉⵢⵢⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⵡⵡⵙⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵉⵣⵉ ⵏⵙⴻⵏ, ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⴰⵍ ⴰⴽⴻⵀⵀⴰⵏ ⵎⴰⵔⵔⴰ ⵜⵛⴻⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JR8_11","025_8_11","JER","8","11","11","ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵅⵙⴻⵏ ⴰⴷ ⵜⵜ ⵙⵙⴳⴻⵏⴼⴰⵏ ⵙ ⵍⴻⵀⵡⴻⵏ ⴰⵎ ⵇⵇⴰⵔⴻⵏ: ‘ⵍⴻⵀⵏⴰ, ⵍⴻⵀⵏⴰ!’, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR8_12","025_8_12","JER","8","12","12","ⵎⴰ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵏⵉⵜⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ? ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ ⵛⴰ, ⵍⴻⵃⵢⴰ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵏ. ⵙ ⵓⵢⴰ ⴰⴷ ⵡⴹⴰⵏ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⵡⴻⵟⵟⴰⵏ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵎⴻⵍⵎⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵅⴻⵍⴼⴻⵖ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR8_13","025_8_13","JER","8","13","13","“ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵍⴻⵇⴹⴻⵖ ⵇⴰⵄ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵓⴹⵉⵍ ⵖⴰⵔ ⵜⵣⴰⵢⴰⵔⵜ ⵓ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵜⴰⵣⴰⵔⵜ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵡⴰⵔⵜⵓ, ⵄⴰⴷ ⵜⵉⴼⵔⴰⵢ ⵡⴹⴰⵏⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴰⵡⵢⴻⵖ ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵄⴻⴼⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR8_14","025_8_14","JER","8","14","14","“ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰ ⵏⴰⵔⵏⵉ ⴷⴻⴳ ⵓⵖⵉⵎⵉ? ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⵎⵓⵏ, ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ, ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵏⴻⵙⵇⴰⵔ. ⴰⵇⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵢⴰⵔⵔⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵇⴰⵔ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⴰⵎⴰⵏ ⵉⵙⵎⵓⵎⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵅⴹⴰ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR8_15","025_8_15","JER","8","15","15","ⵏⴻⵙⵙⵉⵜⵜⵉⵎ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵙⴳⴻⵏⴼⵉ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵎⵖⵉⵔ ⴰⵙⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JR8_16","025_8_16","JER","8","16","16","ⵣⵉ ⴷⴰⵏ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵓⵙⴰⵃⴰⵔⵜ ⵏ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵙ, ⵣⴻⴳ ⵡⴻⵙⵏⴻⵃⵏⴻⵃ ⵏ ⵢⴻⵢⵙⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵏⵏⴻⵙ ⵜⴻⵏⵀⴻⵣⵣⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⵜⴰⵏⴷⵉⵏⵜ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR8_17","025_8_17","JER","8","17","17","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⴼⵉⵖⵔⴰⵏ, ⵉⴼⵉⵖⵔⴰⵏ ⵏ ⴰⵔⵔⵀⴰⵊ, ⴰⴽⵉⴷⵙⴻⵏ ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ ⵓⵄⴻⵣⵣⴻⵎ. ⵉⵏⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵣⴻⵄⴼⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR8_18","025_8_18","JER","8","18","18","“ⴰⵎⵃⴰⴷ ⵉⵏⵓ ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵛⴹⴰⵏ, ⵓⵍ ⵉⵏⵓ ⵢⵓⵃⴻⵍ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR8_19","025_8_19","JER","8","19","19","ⵅⵣⴰⵔ, ⵍⵃⴻⵙⵙ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ: ‘ⵎⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵎⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⴵⵉ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ?’” “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ ⵙ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ, ⵙ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JR8_20","025_8_20","JER","8","20","20","“ⵜⴻⵄⴷⵓ ⵜⵎⴻⵢⵔⴰ, ⵉⴼⴼⴻⵖ ⵓⵏⴻⴱⴷⵓ, ⵓ ⵏⴻⵛⵛⵉⵏ ⵄⴰⴷ ⵡⴰⵔ ⵏⴻⵏⵊⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR8_21","025_8_21","JER","8","21","21","ⵏⴻⵛⵛ ⵜⵜⵡⴰⵔⵥⵉⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⵔⴹⴻⵖ ⴰⵔⵔⵓⴹ ⴷ ⴰⴱⴰⵔⵛⴰⵏ, ⵉⵛⴻⴱⴱⴰⵔ ⴷⴰⵢⵉ ⵓⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JR8_22","025_8_22","JER","8","22","22","ⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⴱⴰⵍⵙⴰⵎ ⴷⵉ ⵊⵉⵍⵄⴰⴷ? ⵎⴰ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵉⴵⵉ ⵓⵎⴻⵙⴳⴻⵏⴼⵓ? ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵉⵏⵏⵉⴹ ⵓⵢⴻⵣⵣⵉⵎ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JR8_23","025_8_23","JER","8","23","23","ⴰⵅ, ⵎⵍⵉ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ ⴷ ⴰⵎⴰⵏ, ⵜⵉⵟⵟ ⵉⵏⵓ ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⵣⵉⵍ ⴷ ⴵⵉⵍⴻⵜ ⵉⵍⵉ ⵔⵓⵖ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JR9_1","025_9_1","JER","9","1","1","“ⴰⵅ, ⵎⵍⵉ ⵖⴰⵔⵉ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⵉ ⵉⵎⵙⴻⴱⵔⵉⴷⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⵙⴻⵎⵃⴻⵖ ⴷⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓⵢⵓⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷ ⵉⵣⴻⵏⵏⴰⵢⴻⵏ, ⴰⵎⵓⵏⵉ ⵏ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR9_2","025_9_2","JER","9","2","2","ⵏⵉⵜⵏⵉ ⵙⵙⵇⴻⴹⵄⴻⵏ ⵉⵍⴻⵙ ⵏⵙⴻⵏ, ⵍⵇⴻⵡⵙ ⵉⵛⵛⵓⵔ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⵡⵉⵍⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵍⵎⴰⵏⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵜⵄⴻⴼⴼⴰⵏⵜ ⵖⴰⵔ ⵓⵍⵜⵎⴰⵙ ⵓⵎⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵙⵉⵏⴻⵏ ⵛⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR9_3","025_9_3","JER","9","3","3","ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⵛⵉⵍⴻⵎ ⵓⵍⴰ ⵅ ⵜⴰⵡⵎⴰⵜ, ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⵜⴰⵡⵎⴰⵜ ⵜᵉⵜⵜⴻⴳⴳ ⵎⵖⵉⵔ ⴰⵛⵎⴰⵜ ⵓ ⴽⵓⵍ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵜⵜⴻⵏⵏⴻⴹ ⴰⵎ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⵙ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR9_4","025_9_4","JER","9","4","4","ⴽⵓⵍ ⵉⵊⵊ ⵉⵜⵜⵖⴰⵔⵔⴰ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵛⴰ ⵜⵉⴷⴻⵜⵜ. ⵏⵉⵜⵏⵉ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⴻⵇ, ⵏⵉⵜⵏⵉ ⵙⵙⴰⵃⴰⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR9_5","025_9_5","JER","9","5","5","ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵜⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴻⵛⵎⴰⵜ. ⵙ ⵡⴻⵛⵎⴰⵜ ⵏⵙⴻⵏ ⵄⴻⵡⵡⵍⴻⵏ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR9_6","025_9_6","JER","9","6","6","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴼⴻⵙⵢⴻⵖ ⵓ ⴰⴷ ⵜⴻⵏ ⵊⴰⵔⵔⴱⴻⵖ, ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴽ-ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JR9_7","025_9_7","JER","9","7","7","ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴰⵎ ⴼⵍⵉⵜⵛⴰ ⵏ ⵍⵇⴻⵡⵙ ⵉⵏⴻⵇⵇⴻⵏ, ⴰⵇⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵡⴻⵛⵎⴰⵜ. ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴽⵓⵍ ⵉⵊⵊ ⵉⵙⵙⴰⵡⴰⵍ ⵅ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵡⵊⴰⴷ ⴰⵙ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ. ");
INSERT INTO rift_vpl VALUES ("JR9_8","025_9_8","JER","9","8","8","ⵎⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵅⴻⴵⴼⴻⵖ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵎⴰ ⵡⴰⵔ ⵉⵅⴻⴵⴻⴼ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵣⵉ ⵍⴳⴻⵏⵙ ⴰⵎ ⵡⴰ?” ");
INSERT INTO rift_vpl VALUES ("JR9_9","025_9_9","JER","9","9","9","“ⵏⴻⵛⵛ ⴰⴷ ⵔⵓⵖ, ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵓⵡⴻⵃⵡⴻⵃ ⵅ ⵉⴷⵓⵔⴰⵔ ⴷ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵎⴰⵖⴰⵔ ⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵙⵙⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽ ⵓ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ ⵍⵃⴻⵙⵙ ⵏ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵄⴰⴷ. ⵣⴻⴳ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴰⵍ ⵍⵎⴰⵍ ⵎⴰⵔⵔⴰ ⴰⵔⴻⵡⵍⴻⵏ, ⴽⴽⴰⵔⴻⵏ ⵓⵢⵓⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR9_10","025_9_10","JER","9","10","10","“ⴰⴷ ⴰⵔⵔⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵉⵣⴻⵍⵍⵉⵊⴻⵏ ⵏ ⵡⴻⵥⵔⵓ, ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵓⴷⵓⵔⵔⵉ ⵉ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵓⵛⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵜⴻⵏⵜ ⴳⴳⴻⵖ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵏⵏⵉ ⴷⵉ ⵡⴰⵔ ⵉⵣⴻⴷⴷⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ.” ");
INSERT INTO rift_vpl VALUES ("JR9_11","025_9_11","JER","9","11","11","“ⵡⵉ ⵉⴵⴰⵏ ⴷ ⴰⵔⵢⴰⵣ ⴰⵎⵉⵖⵉⵙ, ⴰⵇⴰ ⴰⴷ ⵉⵃⴰⴽⴰ ⴷⴻⴳ ⵓⵢⴰ, ⵓ ⵡⵉ ⵖⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴱⴰⵔⵔⴻⵃ ⵅⴻⵏⵏⵉ! ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ ⵜⴰⵎⵎⵓⵔⵜ, ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⴰⵎ ⵍⴻⵅⵍⴰ ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵛⵓⵇⵉ?” ");
INSERT INTO rift_vpl VALUES ("JR9_12","025_9_12","JER","9","12","12","“ⵙⵉⴷⵉ ⵉⵏⵏⴰ: ‘ⵍⴰⵎⵉ ⴰⵔⵅⵓⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⵜⴻⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ, ⵓ ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵜⵜ ⴹⴼⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR9_13","025_9_13","JER","9","13","13","ⵎⴰⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵙⴻⵏ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR9_14","025_9_14","JER","9","14","14","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵛⵛⵉⵃ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⵏ ⴰⵔⵔⵀⴰⵊ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR9_15","025_9_15","JER","9","15","15","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⴻⴽⴽⴻⵖ ⵙⵙⵉⴼ ⴰⵍ ⵜⴻⵏ ⵇⴹⵉⵖ.’ ");
INSERT INTO rift_vpl VALUES ("JR9_16","025_9_16","JER","9","16","16","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵃⴹⴰⵎ, ⵍⴰⵖⴰⵎ-ⴷⴷ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵡⴻⵛⴹⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏⵜ, ⵓⵛⴰ ⵊⵊⴻⵎ ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⵎⵉⵖⵉⵙⵉⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏⵜ!’” ");
INSERT INTO rift_vpl VALUES ("JR9_17","025_9_17","JER","9","17","17","“ⵏⴻⵛⵛ ⵏⵏⵉⵖ, ⵡⴰⵀ, ⵊⵊⴻⵎ ⵜⴻⵏⵜ ⴰⴷ ⴷⴻⵖⵢⴰⵏⵜ ⵓ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅⴰⵏⴻⵖ ⴰⵍ ⴷⴷ-ⴰⵣⵣⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵓ ⵡⴰⵎⴰⵏ ⴰⴷ ⴷⴷ-ⵀⵡⴰⵏ ⵅ ⵡⴰⴱⵍⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR9_18","025_9_18","JER","9","18","18","ⵎⴰⵖⴰⵔ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵙⵍⵉⵏ ⴰⵙ-ⴷⴷ ⵣⵉ ⵚⵉⵀⵢⵓⵏ: ‘ⴰⵅ, ⵎⴰⵎⵎⴻⵛ ⵏⴻⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵏⴻⵛⵛⵉⵏ ⵏⵙⴻⴹⵃⴰ ⴰⵟⵟⴰⵙ ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵅⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴽⴽⴰⵔ ⴰⴷ ⵏⴻⵙⵎⴻⵃ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵖ ⵀⴻⴷⵎⴻⵏ ⵜⴻⵏⵜ.’ ");
INSERT INTO rift_vpl VALUES ("JR9_19","025_9_19","JER","9","19","19","ⵙⵍⴻⵏⵜ ⵅⴻⵏⵏⵉ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⴻⵊⵊ ⴰⵎⴻⵣⵣⵓⵖ ⵏⴽⴻⵏⵜ ⴰⴷ ⵉⴽⵙⵉ ⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⵙⵍⴻⵎⴷⴻⵏⵜ ⵢⴻⵙⵙⵉⵜⴽⴻⵏⵜ ⴰⴷ ⵛⴻⴹⵏⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⵜᵉⵙⵙⴻⵍⵎⴻⴷ ⴽⵓⵍ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵛⵜ ⵏ ⵡⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵉ ⵜⵎⴻⴷⴷⵓⴽⴽⴻⵍⵜⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR9_20","025_9_20","JER","9","20","20","ⵎⵉⵏⵣⵉ ⵍⵎⴻⵡⵜ ⵜⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵍⴻⴽⵡⴰⵣⵉ ⵏⵏⴻⵖ, ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴹⴻⵄ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵣⵉ ⵣⵣⵏⴰⵇⵉ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵣⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR9_21","025_9_21","JER","9","21","21","“ⵙⵉⵡⴻⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵍⵅⴻⵛⴱⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜⴻⵡⴹⴰ ⴰⵎ ⵍⴻⵖⴱⴰⵔ ⵅ ⵢⴻⵢⵢⴰⵔ, ⵓ ⴰⵎ ⵜⵇⴻⴱⴱⵉⴹⵜ ⵏ ⵉⵎⴻⵏⴷⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜ ⵉ ⵖⴰ ⵉⵊⴰⵔⵡⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ.” ");
INSERT INTO rift_vpl VALUES ("JR9_22","025_9_22","JER","9","22","22","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵉⵜⵜⴼⴻⵢⵢⵉⵛ ⵓⵎⵉⵖⵉⵙ ⵙ ⵜⵉⵖⵉⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵡⴰⵔ ⵉⵜⵜⴼⴻⵢⵢⵉⵛ ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵙ, ⴱⵓ-ⵡⴰⴳⵍⴰ ⵡⴰⵔ ⵉⵜⵜⴼⴻⵢⵢⵉⵛ ⵙ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR9_23","025_9_23","JER","9","23","23","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴼⴻⵢⵢⴰⵛⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓ ⵉⵙⵙⴻⵏ ⴰⵢⵉ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵜⴻⵄⵊⵉⴱⴻⵏⵜ ⴰⵢⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR9_24","025_9_24","JER","9","24","24","“ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵅⴻⵜⵏⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵄⴰⴷ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JR9_25","025_9_25","JER","9","25","25","ⵣⵉ ⵎⵉⵚⵔⴰ ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⴷⵓⵎ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⵎⵓ’ⴰⴱ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵃⴻⴼⴼⴰⵏ ⴰⵛⵓⵡⵡⴰⴼ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵡⴰⵔ ⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⴷⴰⵍⵢⴻⵜ ⵅ ⵡⵓⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR10_1","025_10_1","JER","10","1","1","“ⵙⵍⴻⵎ ⴰⵡⴰⵍ ⵉ ⵣⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JR10_2","025_10_2","JER","10","2","2","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵍⴻⵎⵎⴷⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓ ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵣⵉ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵅⵅⴰ ⵍⴻⴳⵏⵓⵙ ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR10_3","025_10_3","JER","10","3","3","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵃⴻⵙⵙⴱⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴷ ⵍⵃⴻⵇⵇ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵢⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⴷⴷ-ⵇⴻⵙⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵣⵖⴰⵔ, ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ ⵏⵏⵉ ⵉⴳⴳⴰ ⵙ ⵉⵎⴻⵢⴷⵉ ⵏ ⵡⴻⵎⵣⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("JR10_4","025_10_4","JER","10","4","4","ⵣⴻⵡⵡⵇⴻⵏ ⵜⵜ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵙ ⵉⵎⴻⵙⵎⵉⵔⴻⵏ ⴷ ⵉⴼⴹⵉⵙⴻⵏ ⵙⵙⵎⴻⵜⵏⴻⵏ ⵜⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵜᵉⵜⵜⴻⵏⵅⵓⵅⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("JR10_5","025_10_5","JER","10","5","5","ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⴱⵓⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⵓⵢⵓⵔⴻⵏⵜ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⴳⴳⴻⵏⵜ ⵎⵉⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵓ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⴳⴳⴻⵏⵜ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR10_6","025_10_6","JER","10","6","6","“ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵎⴰ ⴰⵎ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ! ⵛⴻⴽ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("JR10_7","025_10_7","JER","10","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⵉⴷⴻⵏ, ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴻⴳⵏⵓⵙ? ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵅⴰⴽ, ⵎⴰⵖⴰⵔ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⵎ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("JR10_8","025_10_8","JER","10","8","8","“ⴰⵇⴰ-ⵜⴻⵏ ⵊⵎⵉⵄ ⴷ ⵉⴼⵖⴰⵔ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JR10_9","025_10_9","JER","10","9","9","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵣⵉ ⵜⴰⵔⵛⵉⵛ ⴷ ⵡⵓⵔⴻⵖ ⵣⵉ ⵓⴼⴰⵣ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵃⵔⴰⵢⴼⵉ ⵓⵍⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵡⴻⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ. ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵏ ⵉⴼⵉⵍⴰⵏ ⵉⴷⴻⵀⵎⴰⵏⵉⵢⵢⴻⵏ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉⵢⵢⴻⵏ, ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JR10_10","025_10_10","JER","10","10","10","“ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴻⴱⴷⴰ. ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ ⵙ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴻⴳⵏⵓⵙ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⵙⴻⵏ ⴰⵙⵅⴻⴹ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR10_11","025_10_11","JER","10","11","11","“ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ: ‘ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⴳⴳⵉⵏ ⴰⵊⴻⵏⵏⴰ ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵇⴹⴰⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵙⴰⴷⵓ ⴰⵊⴻⵏⵏⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR10_12","025_10_12","JER","10","12","12","“ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵣⵉ ⵜⵉⵖⵉⵜ ⵓ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵉⴱⴻⵣⵣⴻⵄ ⴰⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR10_13","025_10_13","JER","10","13","13","ⵍⴰⵎⵉ ⵉⵜⵜⴻⵊⵊⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⵙⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⵜⴻⴳⴳⴰ ⴰⵎ ⵓⵛⴰⵔⵛⵓⵔ ⵏ ⵡⴰⵎⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵜⵜⴻⴳⴳ ⴰⵙⵙⴰⵎⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵥⴰⵔ ⵓ ⵉⵙⵙⴻⴽⴽⴰ-ⴷⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵣⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵏ ⵜⵅⵓⴱⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("JR10_14","025_10_14","JER","10","14","14","“ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⴳⴰⵔⵔⵓⴹ, ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ, ⴽⵓⵍ ⴰⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵙⴻⴹⵃⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ ⵉ ⵉⴳⴳⴰ, ⵎⴰⵖⴰⵔ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ ⵉⴼⴻⵙⵢⴻⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⴵⵉ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR10_15","025_10_15","JER","10","15","15","ⴰⵇⴰ ⵜⴻⵏⵜ ⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵜⵙⴻⴹⵃⴰⵛⵜ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵎⴰⵏⵉ ⵜⴻⵏⵜ ⵉ ⵖⴰ ⵄⴰⵇⴱⴻⵏ, ⴰⴷ ⴼⵏⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR10_16","025_10_16","JER","10","16","16","ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⵜⴻⴵⵉ ⴰⵎ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR10_17","025_10_17","JER","10","17","17","“ⵙⴻⴳⴳⵡⴻⵊ ⵙⵙⴻⵍⵄⴻⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ, ⴰ ⵛⴻⵎ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰ! ");
INSERT INTO rift_vpl VALUES ("JR10_18","025_10_18","JER","10","18","18","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵜⵡⴰⵍⴰ-ⵢⴰ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JR10_19","025_10_19","JER","10","19","19","ⵓⵛⵜ ⵉⵏⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵔⴻⵥⵥⵉⵜ ⵉⵏⵓ, ⴰⵢⴻⵣⵣⵉⵎ ⵉⵏⵓ ⵉⵜⵜⴻⵇⵇⴻⵙ ⴰⵢⵉ ⴰⵟⵟⴰⵙ. ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ⴰⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵀⵍⴰⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴽⵙⵉⵖ! ");
INSERT INTO rift_vpl VALUES ("JR10_20","025_10_20","JER","10","20","20","ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ ⵓⵇⵉⴹⵓⵏ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵉⵎⵓⵔⴰⵔ ⵏ ⵓⵇⵉⴹⵓⵏ ⵇⴻⵟⵟⵙⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵓⵢⵓⵔⴻⵏ ⵅⴰⴼⵉ ⵓ ⵡⴰⵔ ⴷⴰ ⴵⵉⵏ ⵄⴰⴷ. ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵇⵉⴷⵓⵏ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵢⴰⵢⴻⵍ ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR10_21","025_10_21","JER","10","21","21","ⵎⴰⵖⴰⵔ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵜⵓⵖⴰ ⵇⴻⵊⵃⴻⵏ, ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⵙ ⴰⵔⵣⵓⵏ. ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR10_22","025_10_22","JER","10","22","22","ⵍⴻⵃⵡⴻⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵇⴰ ⴷⴰ, ⴷⴷⵔⵉⵣ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵛⵛⴰⵎⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵏ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR10_23","025_10_23","JER","10","23","23","“ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵡⴰⵔ ⴷⴷ-ⵜⴻⵇⵇⵉⵎ ⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵅⴹⴰⵔ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉⴳⴳⵓⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⴷⴻⵀ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR10_24","025_10_24","JER","10","24","24","ⵙⴻⴳⴳⴻⵎ ⴰⵢⵉ, ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵙ ⵍⵃⴻⵇⵇ, ⵡⴰⵔ ⵉⴵⵉ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴰⵔⵔⵉⴷ ⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JR10_25","025_10_25","JER","10","25","25","ⵣⴻⴵⴻⵄ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⵉⵏⴻⵏ, ⵓ ⵅ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵖⵉⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵚⴰⵔⴹⴻⵏ ⵢⴰⵄⵇⵓⴱ, ⵚⴰⵔⴹⴻⵏ ⵜ ⵓⵛⴰ ⵇⴹⴰⵏ ⵅⴰⵙ, ⵀⴻⴷⵎⴻⵏ ⴰⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR11_1","025_11_1","JER","11","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR11_2","025_11_2","JER","11","2","2","“ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JR11_3","025_11_3","JER","11","3","3","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR11_4","025_11_4","JER","11","4","4","ⵡⴻⵏⵏⵉ ⵡⴻⵚⵚⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⴻⴳ ⵓⴼⴰⵔⵔⴰⵏ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵍⴰⵎⵉ ⵏⵏⵉⵖ: ⵙⵍⴻⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵚⵚⵉⵖ ⵎⴰⵔⵔⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JR11_5","025_11_5","JER","11","5","5","ⵃⵉⵎⴰ ⴰⴷ ⵎⴻⵏⵄⴻⵖ ⴷⵉ ⵜⵊⴰⴵⵉⵜ ⵏⵏⵉ ⵊⵊⵓⴵⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ.’” ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ, ⵏⵏⵉⵖ: “ⴰⵎⵉⵏ, ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("JR11_6","025_11_6","JER","11","6","6","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⴱⴰⵔⵔⴻⵃ ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵉ: ‘ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ, ⴳⴳⴻⵎ ⵣⵣⴰⵢⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR11_7","025_11_7","JER","11","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵄⴻⵍⵎⴻⵖ ⵙ ⵊⵊⴻⵀⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴰⵍ ⴰⵙⵙ-ⴰ, ⵡⴰⵀ, ⵛⴻⵀⴷⴻⵖ ⵏⵏⵉⵖ: ⵙⵍⴻⵎ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ’ ");
INSERT INTO rift_vpl VALUES ("JR11_8","025_11_8","JER","11","8","8","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ ⴰⵄⴻⴼⴼⴰⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⵉⵡⴹⴻⵖ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ-ⴰ, ⵉⵏⵏⵉ ⵅ ⵜⴻⵏ ⵡⴻⵚⵚⵉⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR11_9","025_11_9","JER","11","9","9","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵊⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵊⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR11_10","025_11_10","JER","11","10","10","ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵏⵏⵉ ⵢⵓⴳⵉⵏ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ ⴹⴻⴼⴼⴰⵔⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ. ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵔⵥⵉⵏ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵏⵏⵉ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR11_11","025_11_11","JER","11","11","11","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵏⴹⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵉ ⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵏⴻⵊⵎⴻⵏ. ⵎⴰⵍⴰ ⵍⴰⵖⴰⵏ ⴰⵢⵉ-ⴷⴷ ⵅⴻⵏⵏⵉ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵜⴻⵙⵍⵉⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JR11_12","025_11_12","JER","11","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ, ⵎⴰⵛⴰ ⵢⵉⵏⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵏ ⴰⴼⵓⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵓⵎⵉ ⵜⴻⵏ ⵉⵍⵇⴻⴼ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR11_13","025_11_13","JER","11","13","13","ⵎⴰⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴰⵏⴻⵛⵜ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ, ⴰ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵉⵄⴰⵍⵜⴰⵔⴻⵏ ⵉ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵉ ⵏⵏⵄⵉ ⵏ ⵚⵚⴰⵏⴰⵎ ⵏⵏⵉ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⴰⵏⴻⵛⵜ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⴱⴰⵄⵍ.’” ");
INSERT INTO rift_vpl VALUES ("JR11_14","025_11_14","JER","11","14","14","“ⵛⴻⴽ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔ ⵉ ⵍⴳⴻⵏⵙ-ⴰ, ⵡⴰⵔ ⵜⵜⴻⴽⴽⴰⵔⴻⴷ ⴰⴷ ⴰⵙⴻⵏ ⵜⵔⵓⴷ ⵏⵉⵖ ⴰⴷ ⴰⵙⴻⵏ ⵜⴻⴷⵄⵉⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵖ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵅⴰⴼⵉ ⴷⴷ ⵖⴰ ⵍⴰⵖⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵉ ⵜⴻⵏ ⵉⵍⴻⵇⴼⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR11_15","025_11_15","JER","11","15","15","“ⵎⵉⵏ ⵉ ⵜⴻⴳⴳⵉⴷ, ⴰ ⵜⴰⵎⵄⵉⵣⵜ ⵉⵏⵓ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵓⵎⵉ ⵜⴻⴵⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰ: ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ ⵅⴰⵎ ⴰⴽ-ⴷ ⵡⴻⵢⵙⵓⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵖⴰⵔ ⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵜⴻⴳⴳⵉⴷ, ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵏⴻⴳⵣⴻⴷ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JR11_16","025_11_16","JER","11","16","16","‘ⵜⴰⵣⵉⵜⵓⵏⵜ ⵜⴰⵣⴻⵢⵣⴰⵡⵜ, ⴰ ⵛⴻⵎ, ⵍⴻⵎⵍⴰⵃⴻⵜ, ⵙ ⵍⵖⵉⴵⴻⵜ ⵉⵛⵏⴰⵏ ⴷⵉ ⵍⴻⵡⵚⵉⴼⴻⵜ!’, ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵎ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵇⵇⴻⴷ ⴰⵙ ⵜⵉⵎⴻⵙⵙⵉ ⴰⵎ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵏ ⵉⵊⵊ ⵏ ⵣⵣⵀⵉⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵔⵥⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR11_17","025_11_17","JER","11","17","17","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵛⴻⵎ ⵉⵥⵥⵓⵏ, ⵉⴳⴳⴰ ⵅⴰⵎ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵉ ⵜⴻⴳⴳⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏⵜ ⵙ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⴱⴰⵄⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR11_18","025_11_18","JER","11","18","18","“ⵙⵉⴷⵉ ⵉⵙⵙⵛⴻⵏ ⵜ ⴰⵢⵉ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ, ⵍⴰⵎⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⵢⵉ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR11_19","025_11_19","JER","11","19","19","ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵜⵓⵖⴰ ⴰⵢⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ ⴰⵢⵏⴰⵡ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⴻⴷⴷⵀⴻⵏ ⵜ ⵉ ⵜⵖⴰⵔⵚⵜ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴹⴻⵢⵢⴻⵄ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⴰⴽ-ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵜⵜ ⵏⵜⴻⵃⵃⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵜⵜⵉⴷⴰⵔⴻⵏ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR11_20","025_11_20","JER","11","20","20","“ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰ ⵛⴻⴽ ⵍⵇⴰⴹⵉ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵏ ⵜⵉⵥⵥⴰⵍ ⴷ ⵡⵓⵍ, ⵙⵛⴻⵏ ⴰⵢⵉ ⵏⵏⴻⵇⵎⴻⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⴻⵍⵍⵎⴻⵖ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ.”    ");
INSERT INTO rift_vpl VALUES ("JR11_21","025_11_21","JER","11","21","21","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵏⴰⵜⵓⵜ, ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵇⵇⴰⵔⴻⵏ: ‘ⵡⴰⵔ ⵜⵜⵏⴰⴱ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵎⴻⵜⵜⵉⴷ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("JR11_22","025_11_22","JER","11","22","22","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵅⴻⴵⵚⴻⵖ: ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("JR11_23","025_11_23","JER","11","23","23","ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵙⵙⵉⵡⴹⴻⵖ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵄⴰⵏⴰⵜⵓⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵅⴻⴵⵚⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR12_1","025_12_1","JER","12","1","1","“ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵖ ⴰⴽⵉⴷⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴰⴷ ⵜⴱⴰⵏⴻⴷ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ. ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⴻⴽ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵍⵃⴻⵇⵇ: ⵎⴰⵢⴻⵎⵎⵉ ⴰⴱⵔⵉⴷ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵙⴻⴳⴳⴻⵎ, ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⴰⵔⵔⴰⵃⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JR12_2","025_12_2","JER","12","2","2","ⵛⴻⴽ ⵜⴻⵥⵥⵓⴷ ⵜⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵉⵥⴻⵡⵔⴰⵏ, ⵏⵉⵜⵏⵉ ⵖⴻⵎⵢⴻⵏ-ⴷⴷ ⵓ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ. ⵛⴻⴽ ⴰⵇⴰ ⵜⵓⴷⵙⴻⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵜⵉⴳⴳⵯⴻⵊⴻⴷ ⵅ ⵜⵉⵥⵥⴰⵍ ⵏⵙⴻⵏ.”    ");
INSERT INTO rift_vpl VALUES ("JR12_3","025_12_3","JER","12","3","3","“ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵜⴻⵙⵙⵏⴻⴷ ⴰⵢⵉ, ⵜᵉⵜⵜⵡⴰⵔⵉⴷ ⴰⵢⵉ ⵓ ⵜⵇⴻⴵⴱⴻⴷ ⵓⵍ ⵉⵏⵓ, ⵎⴰ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⴻⴽ. ⵊⴱⴻⴷ ⵉ-ⵜⴻⵏ ⴰⵎ ⵡⵓⴵⵉ ⵉ ⵜⵖⴰⵔⵚⵜ ⵓ ⵄⵣⴻⵍ ⵉ-ⵜⴻⵏ ⵉ ⵡⴰⵙⵙ ⵏ ⵡⴻⵏⵖⴰⵢ.    ");
INSERT INTO rift_vpl VALUES ("JR12_4","025_12_4","JER","12","4","4","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⴻⴽⴽ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⴹⴻⵏ ⵓ ⴰⴼⵙⵓ ⴰⵣⵉⵣⴰ ⴰⴷ ⵢⴰⵥⴻⵖ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵎⴰⵔⵔⴰ? ⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴹⴻⵢⵢⵄⴻⵏ ⵍⵎⴰⵍ ⴷ ⵢⴻⵊⴹⴰⴹ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR12_5","025_12_5","JER","12","5","5","“ⵎⴰⵍⴰ ⵜⵓⵣⵣⵍⴻⴷ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⵙⵙⴰⵃⴰⵍⴻⵏ ⵛⴻⴽ, ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵏⵏⵉ ⵃⴰⵎⴰⵜ ⴰⴽ-ⴷ ⵉⵢⵙⴰⵏ? ⵎⴰⵍⴰ ⵜᵉⵜⵜⴰⵛⵉⴷ ⴰⵇⴰ ⵛⴻⴽ ⴷⵉ ⵍⴰⵎⴰⵏ ⵎⵖⵉⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵀⵏⴰ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵏⵏⵉ ⴷⵉ ⵛⴱⴰⵔⵇ ⵉⵇⵇⵏⴻⵏ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ? ");
INSERT INTO rift_vpl VALUES ("JR12_6","025_12_6","JER","12","6","6","ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵛ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵛ, ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵖⴻⴷⴷⴰⵔⴻⵏ ⵛⴻⴽ, ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⵢⵓⵏ ⵙ ⵊⵊⵀⴻⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵛ. ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵉⵇⵇⴻⵎ, ⵡⴰⵅⵅⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽⵉⴷⴻⴽ ⵎⵍⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("JR12_7","025_12_7","JER","12","7","7","“ⵏⴻⵛⵛ ⵙⴻⵎⵃⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵏⴹⴰⵔⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ. ⵜⴻⵏⵏⵉ ⵉⵙⵙⵄⵉⵣⵣ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵙⴻⵍⵍⵎⴻⵖ ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR12_8","025_12_8","JER","12","8","8","ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵜⴻⴷⵡⴻⵍ-ⴷⴷ ⴰⴽⵉⴷⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵢⵔⴰⴷ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ. ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴰⴽⵉⴷⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵅ ⵓⵢⴰ ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⵛⴰⵔⵔⵀⴻⵖ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JR12_9","025_12_9","JER","12","9","9","ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⵓⵊⴹⵉⴹ ⵉⴱⴻⵇⵇⴹⴻⵏ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ. ⵜⵜⴻⵏⵏⴹⴻⵏ ⴰⵙ ⵉⵊⴹⴰⴹ ⵉⴽⴻⵛⵛⴹⴻⵏ. ⴽⴽⴰⵔⴻⵎ, ⵙⵎⵓⵏⴻⵎ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("JR12_10","025_12_10","JER","12","10","10","“ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴰⵟⵟⴰⵙ ⵅⴰⵔⵔⴱⴻⵏ ⴰⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ, ⵄⴻⴼⵙⴻⵏ ⵅ ⵢⴻⵢⵢⴰⵔ ⵉⵏⵓ, ⴰⵇⴰ ⴰⵔⵔⵉⵏ ⵉⵢⵢⴰⵔ ⵉⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵍⴰ ⵉⵅⵡⴰ.    ");
INSERT INTO rift_vpl VALUES ("JR12_11","025_12_11","JER","12","11","11","ⴰⵔⵔⵉⵏ ⵉⵢⵢⴰⵔ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ ⵢⴻⵢⵢⴰⵔ, ⵉⵣⵣⴻⵍ ⵣⵣⴰⵜⵉ ⵉⵛⴹⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵅⴰⵔⵔⴻⴱ ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴻⵛⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("JR12_12","025_12_12","JER","12","12","12","ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⵉⵇⴻⵛⵛⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵜⴻⵃⵃⴰⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵙⵉⴼ ⵉⵙⴰⵔⴹ ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵍⴻⵀⵏⴰ ⵉ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR12_13","025_12_13","JER","12","13","13","ⵏⵉⵜⵏⵉ ⵣⴰⵔⵄⴻⵏ ⵉⵔⴷⴻⵏ, ⵎⴰⵛⴰ ⵎⵊⴰⵔⴻⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵏⵉⵜⵏⵉ ⵓⵃⵍⴻⵏ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵏⵏⴼⴰⵄ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵅ ⵚⵚⴰⴱⴻⵜ ⵏⵡⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR12_14","025_12_14","JER","12","14","14","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵎⴰⵔⵔⴰ ⴰⵊⵊⴰⵔⴻⵏ ⵉⵏⵓ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵃⴰⴷⴰⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵉ ⵡⵛⵉⵖ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵇⴻⵍⵄⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵜⵜ ⵇⴻⵍⵄⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR12_15","025_12_15","JER","12","15","15","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏ ⵇⴻⵍⵄⴻⵖ, ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵓ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⵉⵏⵏⴻⵖ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⵄⴻⵇⴱⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR12_16","025_12_16","JER","12","16","16","ⵅⵎⵉ ⵖⴰ ⵍⴻⵎⴷⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵊⵊⴰⴵⴻⵏ ⵖⴰⵔ ⵢⵉⵙⴻⵎ ⵉⵏⵓ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ!’, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵉⵜⵏⵉ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵊⵊⴰⴵⴻⵏ ⵖⴰⵔ ⴱⴰⵄⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR12_17","025_12_17","JER","12","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⵍⵄⴻⵖ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR13_1","025_13_1","JER","13","1","1","“ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵓⵢⵓⵔ, ⵙⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵏ ⵍⴻⵇⵟⴻⵏ ⵓⵛⴰ ⴱⴻⵢⵙ ⵉ-ⵜ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵜⴻⵊⵊⵉ ⴰⴷ ⵢⴰⴷⴻⴼ ⴷⴻⴳ ⵡⴰⵎⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JR13_2","025_13_2","JER","13","2","2","ⵏⴻⵛⵛ ⵙⵖⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴱⴻⵢⵙⴻⵖ ⵜ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR13_3","025_13_3","JER","13","3","3","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR13_4","025_13_4","JER","13","4","4","‘ⴽⵙⵉ ⴰⴱⵢⴰⵙ ⵉ ⵜⴻⵙⵖⵉⴷ, ⵏⵏⵉ ⵜⴱⴻⵢⵙⴻⴷ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴽⴽⴰⵔ, ⵓⵢⵓⵔ ⵖⴰⵔ ⵢⴻⵖⵥⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓⵛⴰ ⴼⴼⴰⵔ ⵉ-ⵜ ⴷⵉⵏⵏⵉ ⴷⵉ ⵜⴰⵣⵣⴻⵛⵜ ⵏ ⵊⵊⴰⵔⴼ.’ ");
INSERT INTO rift_vpl VALUES ("JR13_5","025_13_5","JER","13","5","5","ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ ⵓⵛⴰ ⴼⴼⴰⵔⴻⵖ ⵜ ⵖⴰⵔ ⵍⴼⵓⵔⴰⵟ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵢⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR13_6","025_13_6","JER","13","6","6","“ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⴽⴽⴰⵔ, ⵓⵢⵓⵔ ⵖⴰⵔ ⵍⴼⵓⵔⴰⵟ ⵓⵛⴰ ⴽⵙⵉ ⵙⵙⴻⵏⵏⵉ ⴰⴱⵢⴰⵙ ⵏⵏⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⴼⴼⴰⵔⴻⴷ ⴷⵉⵏⵏⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JR13_7","025_13_7","JER","13","7","7","ⵅⴻⵏⵏⵉ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵍⴼⵓⵔⴰⵟ ⵓⵛⴰ ⵖⵣⵉⵖ ⵓ ⴽⴽⵙⴻⵖ-ⴷⴷ ⴰⴱⵢⴰⵙ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜ ⵜⵓⵖⴰ ⴼⴼⴰⵔⴻⵖ. ⵅⵣⴰⵔ, ⴰⴱⵢⴰⵙ ⵉⴹⴻⵢⵢⴻⵄ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏ ⵓⵎⵉ ⵖⴰ ⵉⵏⴼⵉⵄ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR13_8","025_13_8","JER","13","8","8","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR13_9","025_13_9","JER","13","9","9","‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⴹⴻⵢⵢⵄⴻⵖ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵍⴰ ⴷ ⵏⵏⴼⴰⵅⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR13_10","025_13_10","JER","13","10","10","ⵍⴳⴻⵏⵙ-ⴰ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵏⵉ ⵢⵓⴳⵉⵏ ⴰⴷ ⵉⵙⴻⵍ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⴻⴷⴷⴻⴼ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵄⴱⴻⴷ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵉⴱⴻⵏⴷⴻⵇ, ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴰⵎ ⵡⴻⴱⵢⴰⵙ-ⴰ ⵉ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ ⵉ ⵡⴰⵍⵓ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR13_11","025_13_11","JER","13","11","11","ⵎⴰⵖⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵉⵇⵇⴻⵏ ⵡⴻⴱⵢⴰⵙ ⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⵎⵎⵓ ⵉ ⴰⵔⵔⵉⵖ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵖⴰⵔⵉ ⵇⵇⵏⴻⵏⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴷ ⵛⵛⴰⵏ ⵉⵏⵓ ⴷ ⵓⵄⵓⴵⵉ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR13_12","025_13_12","JER","13","12","12","“ⵛⴻⴽ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ ⴰⵡⴰⵍ-ⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵇⴰⵄ ⴰⵖⴰⵔⵔⴰⴼ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⴱⵉⵏⵓ.’ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ ⵏⵉⵜⵏⵉ: ‘ⵎⴰ ⵣⴻⵄⵎⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵇⴰⵄ ⴰⵖⴰⵔⵔⴰⴼ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⴱⵉⵏⵓ?’ ");
INSERT INTO rift_vpl VALUES ("JR13_13","025_13_13","JER","13","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴰⴷ ⵙⵛⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR13_14","025_13_14","JER","13","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵡⵜⴻⵖ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ, ⵉⵊⵊ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⴱⴰⴱⴰⵜⴻⵏ ⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵃⵉⵏⵏⵉⵖ, ⵡⴰⵔ ⵙⵙⵄⵉⵣⵣⵉⵖ ⵓ ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵖ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴹⴻⵢⵢⵉⵄⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR13_15","025_13_15","JER","13","15","15","“ⵙⵍⴻⵎ ⵓ ⵡⵛⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ, ⵡⴰⵔ ⵜⵜⵏⴻⴼⵅⴻⵎ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR13_16","025_13_16","JER","13","16","16","ⵡⵛⴻⵎ ⵛⵛⴰⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵜⴰⴵⴻⵙⵜ ⵓ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵏⵇⴰⵔⴹⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⴱⴱⵓⴱⵙⴻⵏ, ⴰⵎ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ ⵜⴰⴼⴰⵡⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵢⴰⵔⵔ ⴷ ⵜⵉⵍⵉ ⵏ ⵓⵏⵓⵔⵉ ⵓⵍⴰ ⴷ ⴰⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR13_17","025_13_17","JER","13","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵙⵍⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵔⵓ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵅ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵡⴻⵎ, ⴰⴷ ⵉⴽⵙⵉ ⴷⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵙⵙⴻⵀⵡⴰⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵏⴷⴻⵀ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR13_18","025_13_18","JER","13","18","18","“ⵉⵏⵉ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵊⴻⴵⵉⴷ: ‘ⵙⵡⴰⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵇⵇⵉⵎⴻⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵀⵡⴰ, ⵎⴰⵖⴰⵔ ⵜⵜⴰⵊ ⵏⵡⴻⵎ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵜⴻⵡⴹⴰ ⴰⵡⴻⵎ-ⴷⴷ ⵅ ⵓⵣⴻⴵⵉⴼ.’ ");
INSERT INTO rift_vpl VALUES ("JR13_19","025_13_19","JER","13","19","19","ⵜⵜⵡⴰⴱⴻⵍⵍⵄⴻⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜⴻⵏⵜ ⵢⴰⵔⴻⵣⵣⴻⵎ. ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR13_20","025_13_20","JER","13","20","20","ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵓ ⵅⵣⴰⵔⴻⵎ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ! ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵃⵉⵎⴰⵔⵜ ⵉ ⴷ ⴰⵎ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵓⴵⵉ ⵏⵏⴻⵎ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR13_21","025_13_21","JER","13","21","21","ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⴷ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅⴰⵎ ⵉⵏⵏⵉ ⵉ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵎ ⵉⵄⵉⵣⵣⴻⵏ? ⵎⴰ ⵡⴰⵔ ⵛⴻⵎ ⴷⴷ-ⵎⴻⵏⵏⵄⴻⵏ ⵍⴻⵡⵊⴻⵄ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JR13_22","025_13_22","JER","13","22","22","“ⵅⵎⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵎ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵉⵍⵇⴻⴼ ⵎⴰⵔⵔⴰ ⴰⵢⴰ?’, ⵙⵙⴻⵏ ⴰⵇⴰ: ‘ⵅ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵅⴰⵎ ⵜⵉⵎⵎⴰⵡⵉⵏ ⵏ ⵡⴰⵔⵔⵓⴹ, ⵜⵜⵡⴰⴷⴻⴵⴻⵏ ⵉⵏⵉⵔⵣⴻⵏ ⵏⵏⴻⵎ’. ");
INSERT INTO rift_vpl VALUES ("JR13_23","025_13_23","JER","13","23","23","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ ⴰⴷ ⵉⴱⴻⴷⴷⴻⵍ ⵙⵎⴻⵅ ⵏ ⵜⴻⵍⵎⴻⵛⵜ ⵏⵏⴻⵙ? ⵏⵉⵖ ⴰⵖⵉⵍⴰⵙ ⴰⵔⴻⵇⵇⵉⵄⴻⵏ ⵏⵏⴻⵙ? ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵄⴻⴷⵍⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵏⵏⵓⵎⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR13_24","025_13_24","JER","13","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⴰⵎ ⵓⵍⵓⵎ ⵏⵏⵉ ⵉⵟⵟⴰⵡⴻⵏ ⵙ ⵓⵙⵓⴹⵉ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JR13_25","025_13_25","JER","13","25","25","ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵣⵣⵀⴰⵔ ⵏⵏⴻⵎ ⵉ ⴷ ⴰⵎ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⵣⵣⴰⵢⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵛⴻⵎ ⵜᵉⵜⵜⵓⴷ ⴰⵢⵉ ⵓ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR13_26","025_13_26","JER","13","26","26","ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵉⴱⴻⵃⵔⵓⵔⴻⵏ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ ⴰⵍ ⵜⵉⵡⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("JR13_27","025_13_27","JER","13","27","27","ⵣⵣⵉⵏⴰ ⵏⵏⴻⵎ ⴷ ⵓⵙⵏⴻⵃⵏⴻⵃ ⵉⵏⴻⵣⵔⴻⵏ ⵏⵏⴻⵎ, ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⵉⵏⴼⴻⴹⵃⴻⵏ. ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵥⵔⵉⵖ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵏⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵍ ⵎⴻⵍⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⵉⴳⴻⴷ ⵛⴰ ⵄⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("JR14_1","025_14_1","JER","14","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⵅ ⵍⴰⵥⴰⵖ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR14_2","025_14_2","JER","14","2","2","“ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⴻⵛⴹⴻⵏ ⵓⵛⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵀⴻⵢⵢⴼⴻⵏⵜ. ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵡⴻⵔⵔⵓⴹ ⴷ ⴰⴱⴰⵔⵛⴰⵏ, ⵓⵛⴰ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵓⵛⴻⵜⵛⵉ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵜⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR14_3","025_14_3","JER","14","3","3","ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵙⴻⴽⴽⴻⵏ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵙⴻⵏ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵎⴻⵏ ⴰⵎⴰⵏ. ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴰⵏⵓⵜⴻⵏ ⵏ ⵡⴻⵏⵥⴰⵔ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⴼⵉⵏ ⴰⵎⴰⵏ. ⵏⵉⵜⵏⵉ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⵙ ⵉⴱⵓⵇⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵅⵡⴰⵏ, ⵙⴻⴹⵃⴰⵏ, ⵓⵛⵉⵏ ⵙ ⵓⴱⴰⵔⵔⴻⵇ ⵓⵛⴰ ⵍⴻⵃⵃⴼⴻⵏ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR14_4","025_14_4","JER","14","4","4","ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵔⴻⴳ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⴰⵏⵥⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵉⴼⴻⴵⴰⵃⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ, ⵜⵜⵍⴻⵃⵃⴰⴼⴻⵏ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR14_5","025_14_5","JER","14","5","5","ⵡⴰⵀ, ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⴷⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵎⵎⵉⵙ, ⵎⴰⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵙⵎⴻⵃ ⴷⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⴰⵔⴱⵉⵄ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR14_6","025_14_6","JER","14","6","6","ⵉⵖⵢⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⴱⴻⴷⴷⴻⵏ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵉⵇⵓⵛⵛⴰⵔⴻⵏ, ⵙⵙⵖⴰⵜⴰⵏ ⵖⴰⵔ ⵍⴻⵄⵡⵉⵏ ⴰⵎ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵅⴻⵙⵢⴻⵏⵜ ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴻⴼⵙⵓ ⴰⵣⵉⵣⴰ ⵄⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("JR14_7","025_14_7","JER","14","7","7","“ⵡⴰⵅⵅⴰ ⵛⴻⵀⵀⴷⴻⵏⵜ ⵅⴰⵏⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⴻⴳⴳ ⵉ-ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⴰⵡⴻⴷⴷⴰⵔ ⵏⵏⴻⵖ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵏⴻⵅⴹⴰ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JR14_8","025_14_8","JER","14","8","8","ⵛⴻⴽ ⴷ ⵍⴰⵢⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵉⵍⵉⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⵙⴻⴱⵔⵉⴷ ⵉⵜⵜⵏⵓⵙⴰⵏ ⴵⵉⵍⴻⵜ ⵡⴰⵀⴰ? ");
INSERT INTO rift_vpl VALUES ("JR14_9","025_14_9","JER","14","9","9","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⴵⵉⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴼⴻⴽⴽ? ⴰⵇⴰ ⵛⴻⴽ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵅⴰⵏⴻⵖ, ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵙⴻⵎⵎⴻⵃ!” ");
INSERT INTO rift_vpl VALUES ("JR14_10","025_14_10","JER","14","10","10","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵏⵙ-ⴰ: ‘ⵜⵓⵖⴰ ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⴰⴷ ⵜⴻⵍⵄⴻⵏ, ⵡⴰⵔ ⵙⵙⵄⵉⵣⵣⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵉⴷⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵢⴰⵔⴹⴰ. ⵍⴻⵅⵅⵓ ⴰⴷ ⵢⵉⴷⴰⵔ ⵏⴻⵜⵜⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR14_11","025_14_11","JER","14","11","11","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ! ");
INSERT INTO rift_vpl VALUES ("JR14_12","025_14_12","JER","14","12","12","ⵡⴰⵅⵅⴰ ⵥⵓⵎⵎⴻⵏ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵖ ⵛⴰ ⵖⴰⵔ ⵜⵖⵓⵢⵢⵉⵜ ⵏⵙⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⴰⵔⴹⵉⵖ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵇⴹⵉⵖ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR14_13","025_14_13","JER","14","13","13","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: “ⵡⴰⵢⵢⴰⵡ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙⴻⵏ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⵎ ⵙⵙⵉⴼ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵍⴰⵥ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵍⴻⵀⵏⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ’” ");
INSERT INTO rift_vpl VALUES ("JR14_14","025_14_14","JER","14","14","14","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ, ⵡⴰⵔ ⵜⴻⵏ ⵓⵎⵓⵔⴻⵖ ⵓ ⵡⴰⵔ ⴽⵉⴷⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ. ⵏⵉⵜⵏⵉ ⵜⵜⵏⴰⴱⴱⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⵄⴻⵣⵣⴻⵎ, ⵎⵉⵏ ⵉⴱⴻⴹⵍⴻⵏ ⴷ ⵡⴻⵛⵎⴰⵜ ⵏ ⵡⵓⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR14_15","025_14_15","JER","14","15","15","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: “ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵛⴰ, ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ: ‘ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵙⵙⵉⴼ ⵓⵍⴰ ⴷ ⵍⴰⵥ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ!’, ⴰⵇⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵇⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("JR14_16","025_14_16","JER","14","16","16","ⵍⴳⴻⵏⵙ ⵓⵎⵉ ⵏⴻⴱⴱⴰⵏ, ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴰⵥ ⴷ ⵙⵙⵉⴼ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵏⴻⴹⵍⴻⵏ: ⵏⵉⵜⵏⵉ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ. ⴰⵎⵎⵓ ⴷ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵣⴻⴵⵄⴻⵖ ⵍⵖⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR14_17","025_14_17","JER","14","17","17","“ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ ⴰⵡⴰⵍ-ⴰ: ‘ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴰⴷ ⴷⴷ-ⵙⵙⴻⴼⵢⴻⵏⵜ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⴷ ⴷⴷ-ⵀⵡⴰⵏⵜ, ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ, ⴱⵍⴰ ⵇⴻⵟⵟⵓ!’ ⵎⴰⵖⴰⵔ ⵜᵉⵜⵜⵡⴰⵔⵥ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ, ⵉⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵙ ⵜⴰⵔⴻⵥⵥⵉⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙ ⵓⵢⴻⵣⵣⵉⵎ ⵉⵜⵜⴻⵇⵇⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR14_18","025_14_18","JER","14","18","18","ⵅⵎⵉ ⵖⴰ ⴼⴼⵖⴻⵖ, ⵖⴰⵔ ⵢⴻⵢⵢⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵓ ⵅⵎⵉ ⵖⴰ ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵅⵣⴰⵔ, ⵉⵏⵏⵉ ⵉⵀⴻⵍⵛⴻⵏ ⵙ ⵍⴰⵥ! ⵡⴰⵀ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜᵉⵜⵜⵍⵉⵄⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR14_19","025_14_19","JER","14","19","19","ⵎⴰ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵛⴻⴽ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵔⵔⴰ? ⵎⴰ ⵉⵛⴰⵔⵔⴻⵀ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵚⵉⵀⵢⵓⵏ? ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵡⵜⵉⴷ ⴰⵎⵎⵓ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵇⵇⵉⵎ ⴱⵓ ⵓⴳⴻⵏⴼⵓ? ⵙⵉⵜⵜⵉⵎⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⴰⵎⵛⴰⵏ ⵉ ⵍⵅⴰⵔ, ⵙⵉⵜⵜⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⵡⴻⵇⵜ ⵏ ⵓⴳⴻⵏⴼⵉ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵎⵖⵉⵔ ⴰⵙⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JR14_20","025_14_20","JER","14","20","20","ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵍⵖⴰⵔ ⵏⵏⴻⵖ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JR14_21","025_14_21","JER","14","21","21","ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵙⵙⴻⵃⵇⴰⵔⴰ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵙⵙⴻⵃⵇⴰⵔⴰ ⵍⵄⴰⵔⵛ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ. ⵉⴷⴰⵔ ⴰⵏⴻⵖ, ⵡⴰⵔ ⵜⴰⵔⴻⵥⵥⴰ ⵍⵄⴰⵀⴷ ⵉ ⴽⵉⴷⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ! ");
INSERT INTO rift_vpl VALUES ("JR14_22","025_14_22","JER","14","22","22","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵊⴰⵔ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵡⵛⴻⵏ ⴰⵏⵥⴰⵔ, ⵏⵉⵖ ⵛⵛⴰⵜⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙ ⵡⴻⵏⵥⴰⵔ ⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ? ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵏⵔⴰⵊⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR15_1","025_15_1","JER","15","1","1","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵡⴰⵅⵅⴰ ⵎⴰⵍⴰ ⵉⴱⴻⴷⴷ ⵎⵓⵙⴰ ⴷ ⵛⴰⵎⵡⵉⵍ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵄⴰⴷ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ-ⴰ. ⵙⵉⴳⴳⵯⴻⵊ ⵉ-ⵜⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR15_2","025_15_2","JER","15","2","2","ⵅⵎⵉ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵉⵏⵉⵏ: ‘ⵎⴰⵏⵉ ⵖⴰ ⵏⵓⵢⵓⵔ?’, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵡⵉ ⵉⴵⴰⵏ ⵉ ⵍⵎⴻⵡⵜ, ⵖⴰⵔ ⵍⵎⴻⵡⵜ, ⵡⵉ ⵉⴵⴰⵏ ⵉ ⵙⵙⵉⴼ, ⵖⴰⵔ ⵙⵙⵉⴼ, ⵡⵉ ⵉⴵⴰⵏ ⵉ ⵍⴰⵥ, ⵖⴰⵔ ⵍⴰⵥ ⵓ ⵡⵉ ⵉⴵⴰⵏ ⵉ ⵍⴻⵃⴱⴻⵙ, ⵖⴰⵔ ⵍⴻⵃⴱⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("JR15_3","025_15_3","JER","15","3","3","ⴰⴷ ⵜⴻⵏ ⵅⴻⴵⵚⴻⵖ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴻⴱⵔⵉⴷⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵙ ⵙⵙⵉⴼ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵏⵖⴻⵏ, ⵙ ⵢⵉⵟⴰⵏ ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵊⴰⵔⵔⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵙ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵍⴻⵡⵃⵓⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⵚⴰⵔⴹⴻⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR15_4","025_15_4","JER","15","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⴰⵅⵍⴰⴼ ⵣⵉ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR15_5","025_15_5","JER","15","5","5","“ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵓⵎⵉ ⵖⴰ ⵜⴻⵣⵣⵉⴵⴻⴷ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ? ⵡⵉ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵉⵙⵙⵃⵉⵙⵙⴼⴻⵏ ⵏⵉⵖ ⵡⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵎ ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JR15_6","025_15_6","JER","15","6","6","ⵛⴻⵎ ⵜⵙⴻⵎⵃⴻⴷ ⴷⴰⵢⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵜⴷⴻⵡⵍⴻⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⴰⵔⴻⴷⴷⴵⴻⵖ. ⵏⴻⵛⵛ ⵓⵃⵔⴻⵖ ⵙ ⵓⵃⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR15_7","025_15_7","JER","15","7","7","“ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵙ ⴵⵓⵃ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵛⵛ ⴽⴻⵛⵛⴹⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⵙⵙⵀⴻⵍⵍⴽⴻⵖ ⵜⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⴷⵡⵉⵍⴻⵏ ⵛⴰ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR15_8","025_15_8","JER","15","8","8","ⵜⵉⵊⵊⴰⵍ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⵡⴻⵙⵄⴻⵏⵜ ⵅ ⵢⴻⵊⴷⵉ ⵏ ⵍⴻⴱⵃⵓⵔⴰⵜ. ⴷⵉ ⵟⵟⵢⴰ ⵏ ⵡⴰⵙⵙ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⵉⵡⴹⴻⵖ ⵉⵊⵊ ⵏ ⵓⵎⵜⴻⵃⵃⴰⵢ, ⵅ ⵢⴻⵎⵎⴰⵙ ⴷ ⵓⵃⵓⴷⵔⵉ. ⴷⴻⵖⵢⴰ ⴰⴷ ⵅⴰⵙ ⵡⴹⵉⵖ ⵏⴻⵛⵛ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵉⵏⴻⵅⵍⵉⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR15_9","025_15_9","JER","15","9","9","ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵜⴻⵅⵙⵉ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵍⴻⵇ ⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ, ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ ⵏⵏⴻⵙ ⴰⵎ ⵉⴵⴰ ⵄⴰⴷ ⴷ ⵡⴰⵙⵙ. ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵙⴻⴹⵃⴰ ⵓⵛⴰ ⵜᵉⵜⵜⴻⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵉ-ⴷⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵜ ⵡⵛⴻⵖ ⵉ ⵙⵙⵉⴼ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR15_10","025_15_10","JER","15","10","10","“ⵓⵛⵜ ⵅⴰⴼⵉ, ⵢⴻⵎⵎⴰ, ⴰⵇⴰ ⵛⴻⵎ ⵜⵓⵔⵡⴻⴷ ⴰⵢⵉ-ⴷⴷ: ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵓⵎⵛⵓⴱⴱⴻⵛ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏ ⵓⵎⴻⵏⵖⵉ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏⵜ ⴰⵔⴹⵍⴻⵖ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜᵉⵜⵜⵓⵔⵙⴻⵏ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵏⴻⵄⵄⵍⴻⵏ ⴰⵢⵉ.”    ");
INSERT INTO rift_vpl VALUES ("JR15_11","025_15_11","JER","15","11","11","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴰⵀ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⴳⴳⴻⵖ ⵙ ⵜⵛⵓⵏⵉ ⴰⴽⵉⴷⴻⴽ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴳⴳⵉⵖ ⴰⴷ ⵛⴻⴽ ⵉⵃⵛⴻⵎ ⵍⴻⵄⴷⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⴻⵛⵜⵉ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR15_12","025_15_12","JER","15","12","12","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⴰⵔⵥ ⵓⵣⵣⴰⵍ, ⵓⵣⵣⴰⵍ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⵏⵉⵖ ⵏⵏⵃⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("JR15_13","025_15_13","JER","15","13","13","ⴰⴳⵍⴰ ⵏⵏⴻⵛ ⴷ ⵍⴻⴽⵏⵓⵣ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵍⴻⴳⵏⵓⵙ, ⴱⵍⴰ ⵜⵜⴰⵎⴰⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⵢⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR15_14","025_15_14","JER","15","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵄⴷⵓⵖ ⴰⴽ-ⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵙ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵜⴰⵔⵖⴰ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵜⵛⴻⵎⵎⴻⴹ ⴹⵉⴷⴷ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR15_15","025_15_15","JER","15","15","15","“ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵜ, ⵉⴷⴰⵔ ⴰⵢⵉ ⵓⵛⴰ ⵍⵀⴰ-ⴷⴷ ⴰⴽⵉⴷⵉ! ⵏⵜⴰⵇⴻⵎ ⴰⵢⵉ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ! ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⴽⴽⴻⵙ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⴽ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴰⵟⵟⴰⵙ. ⵙⵙⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⴽⵙⵉⵖ ⵍⵄⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR15_16","025_15_16","JER","15","16","16","ⵓⵎⵉ ⵜⵜⵡⴰⴼⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⵛⵛⵉⵖ ⵜⴻⵏ ⴷⴻⵖⵢⴰ. ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵜⵓⵖⴰ-ⵜ ⵉ ⵏⴻⵛⵛ ⴷ ⴰⵔⵛⵓⵇ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵡⵓⵍ ⵉⵏⵓ ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⴷⵉ ⵜⵉⵡⴰ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR15_17","025_15_17","JER","15","17","17","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵖ ⵛⴰ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵜⴻⵀⵣⴰⵏ, ⵡⴰⵔ ⵏⴻⴳⴳⵣⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵜⵜⵖⵉⵎⵉⵖ ⵡⴻⵃⵃⴷⵉ, ⵎⴰⵖⴰⵔ ⵜⴻⵛⵛⵓⵔⴻⴷ ⴰⵢⵉ ⵙ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR15_18","025_15_18","JER","15","18","18","ⵎⴰⵢⴻⵎⵎⵉ ⵍⴻⵃⵔⵉⵇ ⵉⵏⵓ ⵉⴷⴷⴰⵔ ⵍⴻⴱⴷⴰ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵢⴻⵣⵣⵉⵎ ⵉⵏⵓ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ, ⵎⴰ ⵏⴻⵜⵜⴰ ⵢⵓⴳⵉ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ? ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵛⴻⴽ ⴰⵎ ⵡⴰⵎⴰⵏ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵍⴰⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("JR15_19","025_15_19","JER","15","19","19","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴷⴻⵡⵍⴻⴷ-ⴷⴷ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⴷ ⵓ ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⵎⴰⵍⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵎⵉⵏ ⵉⵖⵍⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵡⴰⵍⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⴷ ⴰⵎ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR15_20","025_15_20","JER","15","20","20","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⴷ ⵍⵃⵉⴹ ⵉⵎⴻⵜⵏⴻⵏ ⵏ ⵏⵏⵃⴰⵙ. ⴰⴷ ⴽⵉⴷⴻⴽ ⵎⵎⴻⵏⵖⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⵏⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR15_21","025_15_21","JER","15","21","21","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴼⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴼⴷⵉⵖ ⵣⴻⴳ ⵡⴻⵎⵏⴰⵄ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR16_1","025_16_1","JER","16","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR16_2","025_16_2","JER","16","2","2","“ⵡⴰⵔ ⵜⵜⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜⵜⵉⵍⵉⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR16_3","025_16_3","JER","16","3","3","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵉⵜⵜⵡⵓⵔⵡⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵅ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵉ ⵜⴻⵏ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵓ ⵅ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵊⵊⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ: ");
INSERT INTO rift_vpl VALUES ("JR16_4","025_16_4","JER","16","4","4","‘ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵡⵄⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵛⴻⵟⵟⴻⵏ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵟⵟⵍⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴻⵖⴱⴰⵔ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵖⴻⵣⵣⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ, ⵓ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR16_5","025_16_5","JER","16","5","5","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵜⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⵡⴰⵔ ⵛⵛⴰⵜ ⴰⴳⴻⵊⴷⵓⵔ, ⵡⴰⵔ ⴰⵔⴻⵃⵃⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴽⴽⵙⴻⵖ ⵍⴻⵀⵏⴰ ⵉⵏⵓ ⵅ ⵍⴳⴻⵏⵙ-ⴰ, ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵏⵓ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JR16_6","025_16_6","JER","16","6","6","ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⴷ ⵎⵎⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ. ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵟⵟⵍⴻⵏ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵛⵛⴰⵜⴻⵏ ⴰⴳⴻⵊⴷⵓⵔ, ⵡⴰⵔ ⵅⴻⴱⴱⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵏⵉⵖ ⴰⴷ ⵙⵙⵇⵓⵛⵛⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR16_7","025_16_7","JER","16","7","7","ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵔⵥ ⵡⴻⵖⵔⵓⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵣⵣⴰⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵅ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉ, ⵓ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⵉⵛⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⵓⵄⴻⵣⵣⵉ ⵅ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR16_8","025_16_8","JER","16","8","8","ⵡⴰⵔ ⵜⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵖⴰⵔⵙⴻⵏ ⵉ ⵎⴰⵛⵛⴰ ⴷ ⵜⵙⴻⵙⵙⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JR16_9","025_16_9","JER","16","9","9","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵔⵛⴰⵇ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵎⵓⵍⴰⵢ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴻⵙⵍⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR16_10","025_16_10","JER","16","10","10","“ⵅⵎⵉ ⵖⴰ ⵜⴱⴰⵔⵔⵃⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅⴰⵏⴻⵖ ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⵊⴰⵔⵉⵎⴰ ⵏⵏⴻⵖ ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵖ ⵉ ⵏⴻⴳⴳⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ?’, ");
INSERT INTO rift_vpl VALUES ("JR16_11","025_16_11","JER","16","11","11","ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⵎⴰⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵄⴻⴱⴷⴻⵏ ⵓ ⵙⴻⵊⴷⴻⵏ ⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⵉ ⵓ ⵡⴰⵔ ⵃⴹⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR16_12","025_16_12","JER","16","12","12","ⵓ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵜⴻⴳⴳⵉⵎ ⵎⴰⵀⵓ ⵅ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵅⵣⴰⵔ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵉⴹⴰⴼⴼⴰⵔ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ, ⴰⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵉ ⵜⴻⵙⵍⵉⵎ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JR16_13","025_16_13","JER","16","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵃⴻⵊⵊⴰⵔⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⵄⴻⴱⴷⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵜⵜⴰⵔⵣⵉⴼⴻⵖ ⵄⴰⴷ ⵙ ⵛⴰ ⵏ ⵍⵅⴰⴹⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("JR16_14","025_16_14","JER","16","14","14","“ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⵏⵉ ⴷⵉ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵉ ⴷⴷ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ!’ ");
INSERT INTO rift_vpl VALUES ("JR16_15","025_16_15","JER","16","15","15","ⵎⴰⵛⴰ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵢⵓⵥⵥⴻⵍ!’ ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR16_16","025_16_16","JER","16","16","16","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵢⵎⴰⵔⴻⵏ, ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵢⴰⵥⵥⵍⴻⵏ ⵣⵉ ⵎⴽⵓⵍ ⴰⴷⵔⴰⵔ ⵓ ⵣⵉ ⵎⴽⵓⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵓ ⵣⴻⴳ ⵉⴼⴻⴵⵉⵇⴻⵏ ⵊⴰⵔ ⵍⴻⵊⵔⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("JR16_17","025_16_17","JER","16","17","17","ⵎⴰⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵜⵜⵡⴰⵍⴰⵏⵜ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵉ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵓⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏⵏⵓⴼⴼⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR16_18","025_16_18","JER","16","18","18","ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵙ ⵓⴹⴻⴼⴼⵓⵙ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⵛⵛⵓⵔⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵙ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵓ ⵙ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR16_19","025_16_19","JER","16","19","19","“ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴷ ⵍⴱⵓⵔⵊ ⵉⵏⵓ ⴷ ⴰⵎⵛⴰⵏ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ. ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴷⴰⵢⴻⵙ ⵎⵖⵉⵔ ⴰⵛⵎⴰⵜ ⴷ ⴰⵄⴱⴻⴷ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵉⵍⴻⵏ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JR16_20","025_16_20","JER","16","20","20","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴳⴳ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ? ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR16_21","025_16_21","JER","16","21","21","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵜⵡⴰⵍⴰ-ⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⵛⴻⵀⴷⴻⵏ, ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⴼⵓⵙ ⵉⵏⵓ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵙⴻⵎ ⵉⵏⵓ ‘ⵙⵉⴷⵉ’.” ");
INSERT INTO rift_vpl VALUES ("JR17_1","025_17_1","JER","17","1","1","“ⵉⵜⵜⵡⴰⵅⴱⴻⵛ ⴷⴷⴻⵏⴱ ⵏ ⵢⴰⵀⵓⴷⴰ ⵙ ⴱⵍⵓⵎⴰ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵙ ⵜⵅⴻⴼⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵎⵉⵔ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵜ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ ⵓ ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR17_2","025_17_2","JER","17","2","2","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵉⴷⴰⵔⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ, ⵜⵜⵉⴷⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵔⴻⴱⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵛⵡⴰⵔⵜⵉ ⵖⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵜⵉⵣⵉⵣⴰⵡⵉⵏ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR17_3","025_17_3","JER","17","3","3","ⴰⴷⵔⴰⵔ ⵉⵏⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴷ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵛ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴽⵏⵓⵣ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ, ⵓⵍⴰ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⴻⵛ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴻⵀⵀⴱⴻⴷ ⴷⴷⴱⴰⵢⴻⵃ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR17_4","025_17_4","JER","17","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⵅⵓⴷ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⵏⵏⵉ ⴷ ⴰⵛ ⵡⵛⵉⵖ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⵉⵙⵎⴻⵖ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴰⴷ ⵜⵙⴰⵔⴻⵖ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵉⵛⴻⵎⵎⴻⴹ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR17_5","025_17_5","JER","17","5","5","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⴷ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⵉⴳⴳⴰ ⴷⴷⴰⵜ ⴷ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵉ ⵅⴻⴼ ⵉⵜⵜⵄⴻⵎⵎⴻⴷ, ⵓ ⵡⴻⵏⵏⵉ ⵓⵍ ⵏⵏⴻⵙ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR17_6","025_17_6","JER","17","6","6","ⵙ ⵎⵉⵏⵣⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⴻⵔⵄⴰⵔ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵛⴰⵏ ⵅ ⵎⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵎⵉⵏ ⵉⵛⵏⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ ⵙ ⵍⴻⵃⵎⵓ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⴻⴳ ⵉⵛⵜ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵡⴰⵔ ⵉⵣⴷⵉⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR17_7","025_17_7","JER","17","7","7","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵙⵉⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵙⵉⴷⵉ ⴷ ⵍⴰⵎⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR17_8","025_17_8","JER","17","8","8","ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵉ ⵉⵜⵜⵡⴰⵥⵥⵓⵏ ⵖⴰⵔ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵜ. ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏ ⵛⴰ ⵎⴻⵍⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⴻⵀⵎⵓ ⵓ ⵜⵉⴼⵔⴰⵢ ⵏⵏⴻⵙ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⴷ ⵜⵉⵣⵉⵢⵣⴰⵡⵉⵏ. ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵍⴰⵥⴰⵖ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵙⵍⵉⵡ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⵉ ⴰⴷ ⵜⴻⴽⵙⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ.’”    ");
INSERT INTO rift_vpl VALUES ("JR17_9","025_17_9","JER","17","9","9","“ⵓⵍ ⴷ ⴰⵖⴻⴷⴷⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵅ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ, ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR17_10","025_17_10","JER","17","10","10","ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵔⴻⵣⵣⵓⵖ ⴷⴻⴳ ⵡⵓⵍ ⵓ ⵜⵜⵊⴰⵔⵔⴰⴱⴻⵖ ⵜⵉⵥⵥⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("JR17_11","025_17_11","JER","17","11","11","ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵙⴻⴽⴽⵓⵔⵜ ⵉ ⵉⵙⵙⴳⵓⵟⵟⵢⴻⵏ ⵅ ⵜⵎⴻⴵⴰⵍⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵔⵓⵡ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⴳⵍⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵍⵃⴻⵇⵇ. ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵉⵙⵎⴻⵃ ⵓ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⴱⵓⵀⴰⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR17_12","025_17_12","JER","17","12","12","“ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ ⵉⴳⴷⴰⵔⴻⵏ ⵙ ⵓⵄⵓⴵⵉ, ⵢⵓⵄⵍⴰⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⴰⵎⵛⴰⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵖ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR17_13","025_17_13","JER","17","13","13","ⵛⴻⴽ ⴷ ⵍⴰⵢⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵃⴻⵢⵢⴷⴻⵏ, ⴰⴷ ⵏⴼⴻⴹⵃⴻⵏ. ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵃⴻⵢⵢⴷⴻⵏ, ⴰⴷ ⵜⵡⴰⵔⵉⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵛⴰⵍ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵙⵉⴷⵉ, ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR17_14","025_17_14","JER","17","14","14","ⵙⴳⴻⵏⴼⴰ ⴰⵢⵉ, ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵏⴼⵉⵖ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵖ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR17_15","025_17_15","JER","17","15","15","ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵢⵉ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵉⵅⴻⵛⵛ!’ ");
INSERT INTO rift_vpl VALUES ("JR17_16","025_17_16","JER","17","16","16","ⵏⴻⵛⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵃⵚⴰⵔⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⵡⴰⵔ ⵎⴻⵥⵔⵉⵖ ⵖⴰⵔ ⵡⴰⵙⵙ ⵏ ⴰⵔⵥⵉⵢⵢⴻⵜ. ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜ: ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR17_17","025_17_17","JER","17","17","17","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵏⴻⵅⵍⵉⵄ ⵛⴰ, ⵛⴻⴽ ⴷ ⴰⴷⵓⵔⵔⵉ ⵉⵏⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR17_18","025_17_18","JER","17","18","18","ⴻⵊⵊ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ ⴰⴷ ⵏⴼⴻⴹⵃⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵏⴼⴻⴹⵃⴻⵖ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵏⵅⴻⵍⵄⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵏⵅⴻⵍⵄⴻⵖ. ⵙⵉⵡⴻⴹ-ⴷⴷ ⵅⴰⵙⴻⵏ ⴰⵙⵙ ⵏ ⵍⵖⴰⵔ ⵓⵛⴰ ⴰⵔⵥ ⵉ-ⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵙ ⵡⴻⴹⴼⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR17_19","025_17_19","JER","17","19","19","“ⴰⵎⵎⵓ ⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ: ‘ⵓⵢⵓⵔ ⵓⵛⴰ ⴱⴻⴷⴷ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵜⴰⵡⵡⵓⵔⵜ ⵉ ⵣⵉ ⵜⵜⴰⴷⴼⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉ ⵣⵉ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵓ, ⵓ ⴻⴳⴳ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵔⵛⴰⵍⵉⵎ ");
INSERT INTO rift_vpl VALUES ("JR17_20","025_17_20","JER","17","20","20","ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴽⴻⵏⵏⵉⵡ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ-ⵢⴰ.’ ");
INSERT INTO rift_vpl VALUES ("JR17_21","025_17_21","JER","17","21","21","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵃⴹⴰⵎ ⵅ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⴷ ⵜⴰⵔⴱⵓⵎ ⵍⴻⵃⵎⴻⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓ ⴰⴷ ⵜ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("JR17_22","025_17_22","JER","17","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵡⴰⵔ ⵜⴻⵙⵙⵓⴼⴼⵓⵖⴻⵎ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵃⵎⴻⵍ ⵣⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴻⵚⵚⵉⵖ ⴱⴰⴱⴰⵜⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("JR17_23","025_17_23","JER","17","23","23","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵖⴻⵏⵏⴰⵏ ⴰⵢⵉ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵙⵍⵉⵏ ⵓ ⵡⴰⵔ ⴽⵙⵉⵏ ⴰⵡⴻⴷⴷⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("JR17_24","025_17_24","JER","17","24","24","“ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵎⵍⵉⵃ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵍⴰⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⵍⴻⵃⵎⴻⵍ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JR17_25","025_17_25","JER","17","25","25","ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⴷⴼⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⵎ ⵏⴻⴷⴷⵀⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵢⵙⴰⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⵅⴻⵏⵏⵉ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵇⵇⵉⵎⴻⵏ ⵣⴻⴷⴷⵖⴻⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR17_26","025_17_26","JER","17","26","26","ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⵣⵉ ⵍⵊⴰⵏⵓⴱ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵚⵚⴻⴷⵇⴻⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵊⵊⴰⵡⵉ ⵓⵛⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR17_27","025_17_27","JER","17","27","27","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜᵉⵜⵜⴻⵙⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵇⴻⴷⴷⵙⴻⵎ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⵎⴻⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵍⴻⵇⵚⵓⵔ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵡⴰⵔ ⴳⴳⵓⵔ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⴻⵅⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR18_1","025_18_1","JER","18","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR18_2","025_18_2","JER","18","2","2","“ⴽⴽⴰⵔ, ⵀⵡⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ. ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵊⵊⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR18_3","025_18_3","JER","18","3","3","ⵅⴻⵏⵏⵉ ⵀⵡⵉⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵓⴼⵉⵖ ⵜ ⵉⵅⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵅ ⵉⵥⵔⴰ ⵉⵜⵜⴻⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR18_4","025_18_4","JER","18","4","4","ⵎⴰⵍⴰ ⵉⵅⵙⴰⵔ ⵓⵖⴰⵔⵔⴰⴼ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵣⵉ ⵜⵍⴰⵅⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵣⵣⴰⵢⴻⵙ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⴷ ⵍⴻⵎⵍⵉⵃ ⵉ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("JR18_5","025_18_5","JER","18","5","5","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR18_6","025_18_6","JER","18","6","6","“ⵎⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⴰⵎ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵡⴰⵏⵉⵜⴰ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵅⵣⴰⵔ, ⴰⵎ ⵜⵍⴰⵅⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JR18_7","025_18_7","JER","18","7","7","ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵅ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴰⵇⴰ ⴰⴷ ⵜ ⵇⴻⵍⵄⴻⵖ, ⴰⴷ ⵜ ⵀⴻⴷⵎⴻⵖ ⵓ ⴰⴷ ⵜ ⵜⴻⵃⵃⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("JR18_8","025_18_8","JER","18","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⵉ ⵅ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⴷⵎⴻⵖ ⵣⵉ ⵍⵖⴰⵔ ⵉ ⵜⵓⵖⴰ ⵏⵡⵉⵖ ⴰⴷ ⴰⵙ ⵜ ⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR18_9","025_18_9","JER","18","9","9","ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵅ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴱⴻⵍⵍⵉ ⴰⴷ ⵜ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵓ ⴰⴷ ⵜ ⵥⵥⵓⵖ, ");
INSERT INTO rift_vpl VALUES ("JR18_10","025_18_10","JER","18","10","10","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴷ ⵢⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵎⵉ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⴷⵎⴻⵖ ⵅ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⵉ ⵏⵏⵉⵖ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜ ⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR18_11","025_18_11","JER","18","11","11","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⵡⴻⵊⴷⴻⵖ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⴹⵉⴷⴷ ⵏⵡⴻⵎ ⵓ ⵏⴻⵛⵛ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵏⵡⴰⵢ ⵅⴰⵡⴻⵎ. ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵅⴻⵏⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ, ⵓ ⵄⴻⴷⵍⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("JR18_12","025_18_12","JER","18","12","12","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵍⴰⵢⴰⵙ ⵡⴰⵍⵓ! ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴹⴼⴰⵔ ⵉⵏⵡⴰⵢⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵏⴻⴳⴳ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ!’” ");
INSERT INTO rift_vpl VALUES ("JR18_13","025_18_13","JER","18","13","13","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵙⴻⵇⵙⴰⵎ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵍⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⴰⵎ ⵡⴰ? ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵉⵙⵔⴰⵉⵍ ⵜⴻⴳⴳⴰ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR18_14","025_18_14","JER","18","14","14","ⵎⴰ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴻⴷⴼⴻⵍ ⵏ ⵍⵓⴱⵏⴰⵏ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ? ⵎⴰ ⴰⴷ ⴰⵥⵖⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵎⴰⵏ ⵉⵜⵜⴱⵓⵇⴱⵓⵇⴻⵏ, ⵉⵙⴻⵎⵎⴰⴹⴻⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR18_15","025_18_15","JER","18","15","15","ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵜⵜⵓ ⴰⵢⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⵜⵜⴰⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵊⵊⵉⵏ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ, ⴷⵉ ⵊⵊⵓⵔⴰⵜ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵣⵓⴱⴰⵇ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵡⴰⵔ ⵉⵡⵉⵟⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("JR18_16","025_18_16","JER","18","16","16","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵜⵙⴻⴹⵃⴰⵛⵜ ⵉ ⵍⴻⴱⴷⴰ. ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵙⵙⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴽⴽⴻⵏ, ⴰⴷ ⵉⵏⵏⴻⵅⵍⴻⵄ, ⴰⴷ ⵉⵀⴻⵣⵣ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR18_17","025_18_17","JER","18","17","17","ⴰⵎ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵍⴻⵄⴷⵓ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵄⵔⵓⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵓⴷⴻⵎ ⵉⵏⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵀⴻⵍⵍⴻⴽ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR18_18","025_18_18","JER","18","18","18","“ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵏⵏⴰⵏ: ‘ⴰⵙⴻⵎ-ⴷⴷ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵅ ⵉⵔⵎⵉⵢⴰ, ⵎⴰⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵇⴹⴰ ⵖⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ, ⵛⵛⵡⴰⵔ ⵖⴰⵔ ⵓⵎⵉⵖⵉⵙ ⵓ ⴰⵡⴰⵍ ⵖⴰⵔ ⵓⵏⴰⴱⵉ. ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜ ⵏⴻⵡⵡⴻⵜ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖ ⵓⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵛ ⵜⴰⵢⵏⵉⵜ ⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵇⵇⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("JR18_19","025_18_19","JER","18","19","19","“ⵃⴹⴰ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ, ⵓ ⵙⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR18_20","025_18_20","JER","18","20","20","ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵅⵍⴻⴼ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵙ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ? ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵖⵣⵉⵏ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⴻⵏⴹⴻⵍⵜ! ⵉⴷⴰⵔ ⵎⴰⵎⵎⴻⵛ ⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜⴻⴽ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴷⵉ ⵍⵅⵉⵔ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴻⵢⵢⴷⴻⵖ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR18_21","025_18_21","JER","18","21","21","ⵙ ⵓⵢⴰ, ⴻⵡⵛ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵉ ⵍⴰⵥ ⵓⵛⴰ ⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⵉ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⵙⵙⵉⴼ ⵓⵛⴰ ⴻⵊⵊ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏⵜ ⴰⵛⴰⵔⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⵉⵊⵊⴰⵍ, ⴻⵊⵊ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵓ ⵉⵃⵓⴹⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏⵜ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JR18_22","025_18_22","JER","18","22","22","ⴻⵊⵊ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵜⵖⵓⵢⵢⵉⵜ ⵣⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ, ⵎⴰⵍⴰ ⵛⴻⴽ ⴷⴻⵖⵢⴰ ⵜⵖⴻⴹⵔⴻⴷ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵓⵎⵉ ⵖⵣⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴹⴻⵍⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵟⵟⴼⴻⵏ, ⵓ ⵙⵙⴰⵔⵙⴻⵏ ⵍⴻⴼⵅⵓⵅ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR18_23","025_18_23","JER","18","23","23","ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵏⵡⴰⵢ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ. ⵡⴰⵔ ⵙⴷⵓⵔⵉⵢ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵎⴻⵃⵃⵉ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵡⴹⴰⵏ ⵣⵣⴰⵜⴻⴽ. ⴻⴳⴳ ⴰⵙⴻⵏ ⴰⵎⵎⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JR19_1","025_19_1","JER","19","1","1","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: “ⵓⵢⵓⵔ ⵓⵛⴰ ⵙⴻⵖ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⵜⵍⴰⵅⵜ ⵓⵛⴰ ⴰⵡⵉ ⵛⴰ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JR19_2","025_19_2","JER","19","2","2","ⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⵛⴻⵇⴼⴰⵏ, ⵓⵛⴰ ⴱⴰⵔⵔⴻⵃ ⴷⵉⵏⵏⵉ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("JR19_3","025_19_3","JER","19","3","3","ⵉⵏⵉ: ‘ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ! ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵎⴰⵃⴻⵏⴷ ⵏ ⵎⴰⵔⵔⴰ ⵏⵏⵉ ⵜⵜ ⵖⴰ ⵉⵙⵍⴻⵏ, ⴰⴷ ⵟⵏⴻⵟⵏⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR19_4","025_19_4","JER","19","4","4","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵃⴻⵢⵢⴷⴻⵏ ⵅⴰⴼⵉ, ⴰⵔⵔⵉⵏ ⴰⵎⵛⴰⵏ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⵉⵜⵏⵉ ⵄⴻⵎⵎⴰⵔⴻⵏ ⴰⵎⵛⴰⵏ-ⴰ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR19_5","025_19_5","JER","19","5","5","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵎⴰⵏⵉ ⵜⵜⵡⴻⵀⵀⴱⴻⵏⵜ ⴷⴷⴱⴰⵢⴻⵃ ⵏⵙⴻⵏ ⵉ ⴱⴰⵄⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ, ⴰⵎ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⴱⴰⵄⵍ, ⵎⵉⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵓⵎⵓⵔⴻⵖ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ ⴷ ⵎⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜ ⴳⴳⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("JR19_6","025_19_6","JER","19","6","6","“ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ⵉ ⵡⴻⵎⵛⴰⵏ-ⴰ ‘ⵜⵓⴼⴰⵜ’ ⵏⵉⵖ ‘ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ’, ⵎⴰⵛⴰ ‘ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵡⴻⵏⵖⴰⵢ’. ");
INSERT INTO rift_vpl VALUES ("JR19_7","025_19_7","JER","19","7","7","ⵎⴰⵖⴰⵔ ⴰⴷ ⵙⵙⴱⴻⵟⵟⵍⴻⵖ ⵉⵏⵡⴰⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵖⴻⴹⵍⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵍⵎⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("JR19_8","025_19_8","JER","19","8","8","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵜⵙⴻⴹⵃⴰⵛ. ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⴷⴷ ⵖⴰ ⵉⴽⴽⴻⵏ ⴰⴷ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵓ ⴰⴷ ⵉⵚⴻⴼⴼⴰⵔ ⵙ ⴰⵙⵔⵓⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR19_9","025_19_9","JER","19","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵖ ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏ ⵢⴻⵙⵙⵉⵜⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴰⵢⵙⵓⵎ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉ ⵣⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵃⵚⴰⵔⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR19_10","025_19_10","JER","19","10","10","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⵜⴰⵔⵥⴻⴷ ⴰⵖⴰⵔⵔⴰⴼ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵢⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR19_11","025_19_11","JER","19","11","11","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴰⵔⵥⴻⵖ ⵍⴳⴻⵏⵙ-ⴰ ⴷ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴰⵔⴻⵥⵥⴰⵏ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵄⴻⴷⵍⴻⵏ ⵄⴰⴷ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏ ⵏⴻⴹⵍⴻⵏ ⴷⵉ ⵜⵓⴼⴰⵜ ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵏⴻⴹⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR19_12","025_19_12","JER","19","12","12","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴰⵎ ⵜⵓⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR19_13","025_19_13","JER","19","13","13","ⵜⵓⴷⵔⵉⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⵅⴻⵎⵊⴻⵏⵜ ⴰⵎ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵓⴼⴰⵜ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⵉ ⵣⵉ ⵅ ⵜⵣⴻⵖⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵇⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵍⴻⴱⵅⵓⵔ ⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR19_14","025_19_14","JER","19","14","14","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵜⵓⴼⴰⵜ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⴻⴱⴱⴰ, ⵢⵓⵢⵓⵔ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("JR19_15","025_19_15","JER","19","15","15","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵏⵉ ⵅ ⵙⵙⵉⵡⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵎⴻⵏⵄⴻⵏ ⵜⴰⵖⴻⵏⵏⴰⵏⵜ ⴰⵎ ⵓⴳⵉⵏ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("JR20_1","025_20_1","JER","20","1","1","ⵍⴰⵎⵉ ⴼⴰⵛⵃⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵉⵎⵎⵉⵔ, ⴰⴽⴻⵀⵀⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷ ⴰⵡⴻⵇⵇⴰⴼ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵙⵍⴰ ⵉ ⵉⵔⵎⵉⵢⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR20_2","025_20_2","JER","20","2","2","ⵉⵡⵜⴰ ⴼⴰⵛⵃⵓⵔ ⴰⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵓⵛⴰ ⵉⵃⴻⴱⴱⴻⵙ ⵉ-ⵜ ⴷⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵙⴻⵏⵏⴻⵊ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR20_3","025_20_3","JER","20","3","3","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵊⵊⴰ ⴼⴰⵛⵃⵓⵔ ⴰⴷ ⴰⵔⵅⵓⵏ ⵉ ⵉⵔⵎⵉⵢⴰ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵉⵔⵎⵉⵢⴰ: “ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⴼⴰⵛⵃⵓⵔ, ⵎⴰⵛⴰ ⵎⴰⵊⵓⵔ-ⵎⵉⵙⵙⴰⴱⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("JR20_4","025_20_4","JER","20","4","4","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⴰⵙⵏⴻⵅⵍⵉⵄ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⴻⵅⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵜ ⵜⵜⵡⴰⵍⴰⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JR20_5","025_20_5","JER","20","5","5","ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⴰⴷ ⵜⴻⵏ ⵙⴻⵍⵍⵎⴻⵖ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵖⵍⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵅⵓⴱⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴳⴳⴻⵖ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏ ⴰⵛⴰⵔⴻⵏ, ⴰⴷ ⵜⴻⵏ ⴽⵙⵉⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR20_6","025_20_6","JER","20","6","6","ⵛⴻⴽ, ⴼⴰⵛⵃⵓⵔ, ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ ⴷ ⵉⵎⴻⵃⴱⴰⵙ. ⵛⴻⴽ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵏⴻⴹⵍⴻⴷ ⴷⵉⵏⵏⵉ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵛ ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵏⴻⴱⴱⵉⴷ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR20_7","025_20_7","JER","20","7","7","“ⵛⴻⴽ ⵜⵊⴻⴱⴷⴻⴷ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵖ. ⵛⴻⴽ ⵜⵊⴻⵀⴷⴻⴷ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ, ⵜⵖⴻⵍⴱⴻⴷ ⴰⵢⵉ. ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵜⵜⵖⵉⵎⴰⵏ ⴷⴻⵃⵃⵛⴻⵏ ⴷⴰⵢⵉ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵙⵜⴻⵀⵣⴰⵏ ⵣⵣⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JR20_8","025_20_8","JER","20","8","8","ⵎⴰⵖⴰⵔ ⵎⴻⵍⵎⵉ ⵎⴰ ⵙⵙⵉⵡⵍⴻⵖ, ⵙⵖⵓⵢⵢⵓⵖ ‘ⵍⴻⵅⵛⵓⵏⴻⵛⵜ!’, ⵍⴰⵖⵉⵖ ‘ⴰⵏⴻⵅⵍⵉⵄ!’, ⵎⴰⵖⴰⵔ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵜⵜⴰⵡⵉ ⴰⵢⵉ-ⴷⴷ ⴰⵙⵙ ⵉⵎⵓⵏ ⵎⵖⵉⵔ ⴰⵙⴻⵃⵇⴰⵔ ⴷ ⵓⵙⵜⴻⵀⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("JR20_9","025_20_9","JER","20","9","9","ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵄⴰⴷ ⵓ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵖ ⵄⴰⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ!’, ⵅⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵢⴰⵔⴻⵇⵇⴻⵏ, ⵜᵉⵜⵜⵡⴰⵃⴱⴻⵙ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵙⵙⴰⵃⴰⵍⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵚⴱⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵣⴻⵎⵎⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR20_10","025_20_10","JER","20","10","10","ⵎⴰⵖⴰⵔ ⵙⵍⵉⵖ ⴰⵛⴻⵇⵇⴻⴼ ⵙ ⵍⵀⴰⵔⴷ ⵏ ⵡⴰⵟⵟⴰⵙ: ‘ⵎⴰⵊⵓⵔ-ⵎⵉⵙⵙⴰⵙⵉⴱ’, ‘ⴰⵙⵉⴳⴳⵯⴻⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵇⵇⴰⵔⴻⵏ. ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵙⴰⵔⴳⴻⴱ ⴰⵏⴻⵖ!, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴱⴰⵔⵔⴻⵃ!’ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴽ-ⴷ ⴷⴷⴰⵔⴻⵖ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵉⵜⵜⵔⴰⵊⴰ ⴰⵍ ⵖⴰ ⵏⵇⴰⵔⴹⴻⵖ. ⵇⵇⴰⵔⴻⵏ: ‘ⴰⴷ ⵜⴰⵖ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⵖⵡⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵏⴻⵖⵍⴻⴱ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵅⵍⴻⴼ.’” ");
INSERT INTO rift_vpl VALUES ("JR20_11","025_20_11","JER","20","11","11","“ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⴰⴽⵉⴷⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵅ ⵓⵢⴰ ⵉ ⵖⴰ ⵏⵏⵇⴰⵔⴹⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵡⴰⵍⵓ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴳⴳⵉⵏ ⵙ ⵍⴻⵄⵇⴻⵍ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR20_12","025_20_12","JER","20","12","12","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴻⴵⴰⴱⴻⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵜⵉⵥⵥⴰⵍ ⴷ ⵡⵓⵍ, ⵙⵛⴻⵏ ⴰⵢⵉ ⵏⵏⴻⵇⵎⴻⵜ ⵏⵏⴻⵛ ⵅⴰⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵛ ⵜⴰⵖⴰⵡⵙⴰ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR20_13","025_20_13","JER","20","13","13","“ⵣⴻⵀⵀⴷⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵙⴻⵎⵖⴰⵔⴻⵎ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⴰⵎⴻⵣⵍⵓⴹ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR20_14","025_20_14","JER","20","14","14","“ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ-ⵜⵜⵡⴰⵔⵡⴻⵖ! ⴰⵙⵙ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⵓⵔⵓ ⵢⴻⵎⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("JR20_15","025_20_15","JER","20","15","15","ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⴱⴰⴱⴰ, ⵉⵏⵏⴰ: ‘ⴰⵇⴰ ⵉⵜⵜⵡⴰⵔⵓⵡ ⴰⵛ-ⴷⴷ ⵓⵃⴻⵏⵊⵉⵔ!’ ⵓⵛⴰ ⵉⵙⵙⴼⴰⵔⵃ ⵉ-ⵜ ⴰⵎⵎⵓ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR20_16","025_20_16","JER","20","16","16","ⴻⵊⵊ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵙⵉⴷⵉ ⴱⵍⴰ ⵎⴰ ⵉⵏⴷⴻⵎ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵍⴻⵃⵔⵉⵇ ⵖⴰⵔ ⵜⴻⴼⴼⵓⵜ ⵓ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵖⴰⵔ ⵟⵟⵢⴰ ⵏ ⵡⴰⵙⵙ, ");
INSERT INTO rift_vpl VALUES ("JR20_17","025_20_17","JER","20","17","17","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵏⵖⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ. ⴰⵎⵎⵓ ⵜⴻⴷⵡⴻⵍ ⵢⴻⵎⵎⴰ ⴷ ⴰⵏⴹⴻⵍ ⵉⵏⵓ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⵉⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("JR20_18","025_20_18","JER","20","18","18","ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ? ⵎⴰ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵖ ⵜⴰⵎⴰⵔⴰ ⴷ ⵡⴻⵛⴹⴰⵏ ⵡⴰⵀⴰ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵇⴹⵉⵖ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⴷⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("JR21_1","025_21_1","JER","21","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵓⵎⵉ ⴰⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⴻⵙ ⴼⴰⵛⵃⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵍⴽⵉⵢⴰ, ⴷ ⵚⴰⴼⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR21_2","025_21_2","JER","21","2","2","“ⵙⴻⵇⵙⴰ ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽⵉⴷⵏⴻⵖ. ⴰⴷ ⵜⴰⵖ ⵙⵉⴷⵉ ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵉⴳⴳ ⵉⵛⵜ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⴻⵢⵢⴻⴷ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JR21_3","025_21_3","JER","21","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵔⵎⵉⵢⴰ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ ⵉ ⵚⵉⴷⵇⵉⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("JR21_4","025_21_4","JER","21","4","4","‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵍⴻⵙⵏⴰⵃ ⵉ ⵣⵉ ⵜⵜⵎⴻⵏⵖⴰⵎ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵃⵉⴹ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR21_5","025_21_5","JER","21","5","5","ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵎⴻⵏⵖⴻⵖ ⵙ ⵓⴼⵓⵙ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴷ ⵓⵖⵉⵍ ⵉⵊⴻⵀⴷⴻⵏ, ⵙ ⵡⴻⵖⴹⴰⴱ ⴷ ⵡⴻⵙⵄⴰⵔ ⵓ ⵙ ⵓⴷⵓⵇⵇⴻⵣ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JR21_6","025_21_6","JER","21","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵡⵜⴻⵖ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⵎ ⵉⵡⴷⴰⵏ ⵓⵍⴰ ⴷ ⵍⵎⴰⵔ: ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵟⵟⴰⵄⵓⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR21_7","025_21_7","JER","21","7","7","ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵖ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵣⵉ ⵟⵟⴰⵄⵓⵏ, ⵣⵉ ⵙⵙⵉⴼ ⵓ ⵣⵉ ⵍⴰⵥ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵃⵉⵏⵏⵉ, ⵡⴰⵔ ⵉⵙⵙⵄⵉⵣⵣⵉ ⵓ ⵡⴰⵔ ⵢⴰⵔⴻⵃⵃⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR21_8","025_21_8","JER","21","8","8","“ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵡⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⴷ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JR21_9","025_21_9","JER","21","9","9","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵙ ⵙⵙⵉⴼ, ⵙ ⵍⴰⵥ ⵏⵉⵖ ⵙ ⵟⵟⴰⵄⵓⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵄⴷⵓ ⵖⴰⵔ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵓⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵢⵉⵍⵉ ⴰⵎ ⵜⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JR21_10","025_21_10","JER","21","10","10","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵙ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵍⵅⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⴰⵎⵛⴰⵏ-ⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵄⴷⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵇⵇⴻⴷ ⵜⵉⵎⴻⵙⵙⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR21_11","025_21_11","JER","21","11","11","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("JR21_12","025_21_12","JER","21","12","12","“ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵙⴻⴳⴳⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⴻⴼⴼⵓⵜ, ⴼⴻⴽⴽⴻⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵏⵉⵖ ⴰⴷ ⵢⴰⵔⵔⴻⵥ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵅⵙⵉ ⵄⴰⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR21_13","025_21_13","JER","21","13","13","ⵅⵣⴰⵔ, ⴰⴷ ⵛⴻⵎ ⵍⴻⵇⴼⴻⵖ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵢⵙⴰⵔⵜ, ⵛⴻⵎ, ⴰ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵍⵡⴰⵟⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵉⵀⵡⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("JR21_14","025_21_14","JER","21","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵇⴱⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ.’”    ");
INSERT INTO rift_vpl VALUES ("JR22_1","025_22_1","JER","22","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵀⵡⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵉ ⴷⵉⵏ ⴰⵡⴰⵍ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR22_2","025_22_2","JER","22","2","2","ⴰⴷ ⵜⵉⵏⵉⴷ: ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ, ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ-ⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("JR22_3","025_22_3","JER","22","3","3","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴳⴳⴻⵎ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⵓ ⵙⵙⵏⴻⵊⵎⴻⵎ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ. ⵡⴰⵔ ⵃⴻⵚⵚⴰⵔⴻⵎ, ⵡⴰⵔ ⵛⵛⴰⵜⴻⵎ ⵍⴱⴰⵔⵔⴰⵏⵉ ⴷ ⵓⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ. ⵡⴰⵔ ⵙⵙⵉⵣⵣⵉⵍⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("JR22_4","025_22_4","JER","22","4","4","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵡⴰⵍ-ⴰ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⴷⴼⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⴷⴰⵡⵓⴷ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴻⴷⵀⴻⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵢⴻⵢⵙⴰⵏ, ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR22_5","025_22_5","JER","22","5","5","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ, ⴰⵇⴰ ⵊⵊⵓⴵⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⴷ ⵍⵅⵉⵔⴱⴻⵜ.’” ");
INSERT INTO rift_vpl VALUES ("JR22_6","025_22_6","JER","22","6","6","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ: ‘ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⵜⵓⵙⵉⴷ ⴰⵢⵉ ⵅ ⵍⵅⴰⴹⴰⵔ ⴰⵎ ⵊⵉⵍⵄⴰⴷ ⵓ ⴰⵎ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵍⵓⴱⵏⴰⵏ, ⴷ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵛⴻⴽ ⵜⵜⴻⴳⴳⴻⵖ ⴷ ⵍⴻⵅⵍⴰ, ⵜⵉⵏⴻⴷⴷⴰⵎ ⵡⴰⵔ ⵉⵣⴷⵉⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR22_7","025_22_7","JER","22","7","7","ⵏⴻⵛⵛ ⴰⴷ ⵃⵓⵣⴻⵖ ⴹⵉⴷⴷ ⵏⵏⴻⵛ ⵉⵎⵜⴻⵃⵃⴰⵢⵢⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵉ ⵡⴻⵏⵖⴰⵢ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⴻⵙⵙⴻⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵛ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵉ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ ⵙ ⵛⵛⵡⴰⵇⴰⵔ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵡⵛⴻⵏ ⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JR22_8","025_22_8","JER","22","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴽⴽⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⴷ ⵉⵏⵉⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵓⵎⵇⴰⵔⵔⴰⴱ ⵏⵏⴻⵙ: ⵎⴰⵢⴻⵎⵎⵉ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("JR22_9","025_22_9","JER","22","9","9","ⴰⴷ ⵉⵏⵉⵏ: ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵄⴻⴱⴱⴷⴻⵏ ⴰⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR22_10","025_22_10","JER","22","10","10","“ⵡⴰⵔ ⵜⵜⵔⵓⵎ ⵅ ⵓⵎⴻⵜⵜⵉⵏ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵛⵛⴰⵜⴻⵎ ⴰⴳⴻⵊⴷⵓⵔ. ⵔⵓⵎ ⵅ ⵡⴻⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵥⴰⵔ ⵄⴰⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵎⴰⵏⵉ ⵉⵅⵍⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("JR22_11","025_22_11","JER","22","11","11","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵛⴰⵍⵍⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⵢⵓⵛⵉⵢⴰ, ⵛⴰⵍⵍⵓⵎ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ: ‘ⵏⴻⵜⵜⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴷⵉⵏⵏⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR22_12","025_22_12","JER","22","12","12","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜ ⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵥⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵄⴰⵡⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR22_13","025_22_13","JER","22","13","13","“ⴰⵅⴻⵢⵢⴻⴱ ⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵜⵉⵖⵓⵔⴼⵉⵏ ⵏⵏⴻⵙ ⵙ ⵍⵖⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵅⴻⴷⴷⴰⵎⴻⵏ ⵡⴻⵏⵏⵉ ⵜ ⵢⵓⴷⵙⴻⵏ ⵏⴻⵀⵍⴰ ⴰⵅⴻⴵⴻⵚ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵉⵛ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JR22_14","025_22_14","JER","22","14","14","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵢⵓⵄⵍⴰⵏ ⴰⵟⵟⴰⵙ ⵙ ⵜⵖⵓⵔⴼⵉⵏ ⵉⵡⴻⵙⵄⴻⵏ.’ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⴳⴳ ⵜⵉⴱⵓⵔⵊⴰⵜⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⴻⵇⵇⴻⴼ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵣⴻⵡⵡⴻⵇ ⵙ ⵜⵉⵏⵜⴰⵜ ⵜⵉⵣⴻⴳⴳⵯⴰⵖⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR22_15","025_22_15","JER","22","15","15","ⵎⴰ ⵜⵃⴻⴽⴽⵎⴻⴷ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵓⵎⵉ ⵜᵉⵜⵜⴻⵎⵃⵉⵣⵡⴰⵔⴻⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵏⴻⴳⵍⵉⵏ? ⴱⴰⴱⴰⵛ ⵎⴰ ⵡⴰⵔ ⵉⵛⵛⵉ, ⵎⴰ ⵡⴰⵔ ⵉⵙⵡⵉ ⵓ ⵎⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ? ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵎⵍⵉⵃ ⵅⴰⵙ ⵅⴻⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("JR22_16","025_22_16","JER","22","16","16","ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ. ⵜⵓⵖⴰ ⵎⵍⵉⵃ ⵅⴰⵙ ⵅⴻⵏⵏⵉ. ⵎⴰ ⴰⵢⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵇⴰ ⴱⵏⴰⴷⴻⵎ ⵉⵙⵙⴻⵏ ⴰⵢⵉ?, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR22_17","025_22_17","JER","22","17","17","ⵎⴰⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴷ ⵡⵓⵍ ⵏⵏⴻⵛ ⴰⵇⴰ ⵜⴻⵏ ⵎⵖⵉⵔ ⵅ ⵜⵉⵣⵉ ⵏⵏⴻⵛ ⵡⴰⵀⴰ, ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⵣⵣⵍⴻⴷ, ⵓ ⵅ ⴷⴷⴻⴵ ⴷ ⵓⴱⴻⵄⵄⴻⵊ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JR22_18","025_22_18","JER","22","18","18","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ: ‘ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⴰⵙ ⵛⴻⵟⵟⵏⴻⵏ: ⴰⵅ, ⵓⵎⴰ! ⵏⵉⵖ: ⴰⵅ, ⵓⵍⵜⵎⴰ! ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵛⴻⵟⵟⵏⴻⵏ: ⴰⵅ, ⵙⵉⴷⵉ! ⵏⵉⵖ: ⴰⵅ, ⵍⵄⴰⴹⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("JR22_19","025_22_19","JER","22","19","19","ⴰⴷ ⵏⴻⴹⵍⴻⵏ ⵙ ⵡⴻⵏⴹⴰⵍ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ. ⴰⴷ ⵜ ⵊⴰⵔⵔⴻⵏ ⵓ ⴰⴷ ⵜ ⵏⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⴱⴰⵔⵔⴰ ⵉ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR22_20","025_22_20","JER","22","20","20","“ⴳⴻⵄⵄⴻⴷ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵙⵖⵓⵢⵢ ⵓⵛⴰ ⴻⵊⵊ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⴷⵉ ⴱⴰⵛⴰⵏ. ⵙⵖⵓⵢⵢ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵣⵉ ⴰⴱⴰⵔⵉⵎ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵜⵡⴰⵔⵥⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR22_21","025_22_21","JER","22","21","21","ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⴻⵎ ⵍⴰⵎⵉ ⵛⴻⵎ ⵜⵓⵖⴰ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵛⴻⵎ ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵙⵍⴻⵖ!’ ⴰⵎⵎⵓ ⵉ ⵜ ⵜⴻⴳⴳⵉⴷ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ, ⵎⴰⵖⴰⵔ ⵛⴻⵎ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR22_22","025_22_22","JER","22","22","22","ⵎⴰⵔⵔⴰ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵡⴻⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵛⴰ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵙⴻⴹⵃⵉⴷ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⴼⴻⴹⵃⴻⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR22_23","025_22_23","JER","22","23","23","ⵛⴻⵎ, ⴰ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵃⴻⴱⴹⴻⵏ ⴷⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵏⴻⴳⵍⵉⵏ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜⵣⴻⵀⵀⴰⵔⴻⴷ ⵅⵎⵉ ⴷ ⴰⵎ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵍⴻⵡⵊⴻⵄ, ⵍⴻⵃⵔⵉⵇ ⴰⵎ ⵢⵉⵛⵜⴻⵏ ⵜᵉⵜⵜⴰⵔⵓ!” ");
INSERT INTO rift_vpl VALUES ("JR22_24","025_22_24","JER","22","24","24","“ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵅⵅⴰ, ⵎⴰⵍⴰ ⴽⵓⵏ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⵓⵖⴰ ⴷ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰⵇⴰ ⴰⴷ ⵛⴻⴽ ⴽⴽⵙⴻⵖ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR22_25","025_22_25","JER","22","25","25","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵡⵛⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵣⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⴷ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR22_26","025_22_26","JER","22","26","26","ⵛⴻⴽ ⴷ ⵢⴻⵎⵎⴰⵛ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴹⴰⵔⴻⵖ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖⵏⵉⵜ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⴻⵅⵍⵉⵇⴻⵎ, ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⴰⴷ ⵜⵎⴻⵜⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR22_27","025_22_27","JER","22","27","27","ⵡⴰⵔ ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵎ ⵄⴻⵎⵎⴰⵔⵚ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⴻⵥⵔⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜⵄⴻⵇⴱⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR22_28","025_22_28","JER","22","28","28","“ⵎⴰ ⴽⵓⵏ-ⵢⴰⵀⵓ ⴰⵔⵢⴰⵣ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵉⵎⵎⴻⵏⴹⴰⵔ, ⵢⴰⵔⵔⴻⵥ? ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵅⵙ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ? ⵎⴰⵢⴻⵎⵎⵉ ⵜ ⵃⴻⵊⵊⴰⵔⴻⵏ, ⵏⴻⵜⵜⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ, ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⵜ ⵙⵙⵉⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR22_29","025_22_29","JER","22","29","29","ⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴰⵎⵎⵓⵔⵜ, ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("JR22_30","025_22_30","JER","22","30","30","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵣⴻⵎⵎ ⴰⵔⵢⴰⵣ-ⴰ ⵏⵀⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵣⵣⵀⵉⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ. ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵔⵔⴰⵡ ⵏⵏⴻⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵣⵣⵀⵉⵔ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ, ⴰⴷ ⵉⵃⴽⴻⵎ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR23_1","025_23_1","JER","23","1","1","“ⵓⵛⵜ ⵅ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵉ ⵉⵏⴻⵇⵇⴻⵏ ⵓ ⵣⵓⵣⵣⴰⵔⴰⵏ ⵓⴵⵉ ⵏ ⴷⴷⵎⴰⵏⵉ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.    ");
INSERT INTO rift_vpl VALUES ("JR23_2","025_23_2","JER","23","2","2","ⵙ ⵓⵢⴰ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴻⴽⴽⵡⵙⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ: ‘ⴽⴻⵏⵏⵉⵡ ⵜⵣⵓⵣⵣⴰⵔⴻⵎ ⵓⴵⵉ ⵉⵏⵓ ⵓⵛⴰ ⵜⵓⵥⵥⵍⴻⵎ ⵅⴰⵙⴻⵏ. ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵃⴹⵉⵎ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_3","025_23_3","JER","23","3","3","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵡⵓⴵⵉ ⵉⵏⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏⵜ ⵓⵥⵥⵍⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵍⴽⵓⵔⵉⵜ ⵏⵙⴻⵏⵜ, ⴰⴷ ⴰⵔⵡⴻⵏⵜ, ⴰⴷ ⵎⵎⴰⵔⵏⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR23_4","025_23_4","JER","23","4","4","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏⵜ ⴳⴳⴻⵖ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⵉ ⵜⴻⵏⵜ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵏⵜ ⵄⴰⴷ ⵓ ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵏⵜ ⵓ ⵡⴰⵔ ⵜⵜⵡⴻⴷⴷⵉⵔⵉⵏⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR23_5","025_23_5","JER","23","5","5","“ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉ ⴷⴰⵡⵓⴷ ⴰⵖⴻⴷⴷⵓ ⵏ ⵜⵙⴻⴳⴷⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵎ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⵉⴼⵍⴻⵃ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR23_6","025_23_6","JER","23","6","6","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ. ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵙⴻⵎ ⵉ ⵣⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵍⴰⵖⴰⵏ: ⵙⵉⴷⵉ, ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR23_7","025_23_7","JER","23","7","7","“ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ!’, ");
INSERT INTO rift_vpl VALUES ("JR23_8","025_23_8","JER","23","8","8","ⵎⴰⵛⴰ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵏⵏⵉ ⴷⴷ-ⵉⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵢⴰⵔⵔⵉⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵎⴰⵏⵉⵙ ⵅⴰⵙⴻⵏ ⵓⵥⵥⵍⴻⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR23_9","025_23_9","JER","23","9","9","ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. “ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵔⵥ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ. ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵛⵓⵔ, ⴰⵎ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵢⴰⵔⵏⵉ ⴱⵉⵏⵓ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR23_10","025_23_10","JER","23","10","10","ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵢⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⴹⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ, ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵥⵖⴻⵏⵜ. ⵎⴰⵏⵉ ⵅⵙⴻⵏ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵓⵍⴰ ⴷ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR23_11","025_23_11","JER","23","11","11","ⵎⴰⵖⴰⵔ ⴰⵎ ⵓⵏⴰⴱⵉ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ ⵜⵜⵡⴰⴼⴻⵙⴷⴻⵏ, ⵄⴰⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵜⵜⴰⴼⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_12","025_23_12","JER","23","12","12","ⵙ ⵓⵢⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⴷⵡⴻⵍ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴻⵡⴹⴰ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ⴰⴷ ⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵡⴹⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵅⴻⵍⴼⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR23_13","025_23_13","JER","23","13","13","“ⴰⵇⴰ ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵙⵙⵜⴻⴱⵀⴰⵜⴻⵏ ⵖⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵙⴰⵎⴰⵔⵢⴰ: ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⴻⵏ ⵙ ⴱⴰⵄⵍ ⵓⵛⴰ ⵜⵜⵖⴰⵔⵔⴰⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR23_14","025_23_14","JER","23","14","14","ⵎⴰⵛⴰ ⵖⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵇⴰⵄ: ⵏⵉⵜⵏⵉ ⵣⴻⵏⵏⴰⵏ, ⵓⵢⵓⵔⴻⵏ ⴰⵎ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⵙⵙⵊⴻⵀⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ. ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⵍⵉⵖ ⵏⴻⵛⵛ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴰⵎ ⵙⴰⴷⵓⵎ, ⵓⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⵄⴰⵎⵓⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR23_15","025_23_15","JER","23","15","15","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵛⵛⵉⵃ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⵏ ⴰⵔⵔⵀⴰⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵡⴻⵏ, ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵖⴻⵙⵙⴻⴱ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR23_16","025_23_16","JER","23","16","16","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ, ⴰⵎ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ ⴱⴰⵟⴻⵍ. ⵏⵉⵜⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⵡⵓⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⵍⴻⵡⵃⵉⵢ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_17","025_23_17","JER","23","17","17","ⵍⴻⴱⴷⴰ ⵇⵇⴰⵔⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ: ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ-ⵜ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ! ⵓ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵇⵇⴰⵔⴻⵏ: ⵡⴰⵔ ⴷⴷ ⵅⴰⵡⴻⵎ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("JR23_18","025_23_18","JER","23","18","18","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⴷⵉ ⵍⵃⴻⵍⵇⴻⵜ ⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵉⵥⵔⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓ ⵉⵙⵍⴰ ⴰⵙ? ⵡⵉ ⵉⵙⵙⵃⴻⵙⵙⴻⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵍⴰ ⵖⴰⵔⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JR23_19","025_23_19","JER","23","19","19","ⵅⵣⴰⵔ, ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵏ ⵙⵉⴷⵉ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵡⴻⵙⵄⴰⵔ, ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⵣⵣⴻⴱⵣⵉⴱ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR23_20","025_23_20","JER","23","20","20","ⴰⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵯⵉⵍ ⵛⴰ ⴰⵍ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ. ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴰⵙ ⵜⴼⴻⵀⵎⴻⵎ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR23_21","025_23_21","JER","23","21","21","ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵙⵙⴻⴽⴽⵉⵖ ⵛⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴳⴳⵓⵔⴻⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵏⵉⵜⵏⵉ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ ⵛⴰ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⵏⴻⴱⴱⴰⵏ ⴷⴻⵖⵢⴰ ⵣⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR23_22","025_23_22","JER","23","22","22","ⵎⵍⵉ ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵀⴻⵍⵇⴻⵜ ⵏ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵍⵉ ⴰⵔⵔⵉⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵓ ⵉⵍⵉ ⴰⵔⵔⵉⵏ ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴰⵄⴻⴼⴼⴰⵏ ⵓ ⵣⵉ ⵍⵖⴰⵔ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR23_23","025_23_23","JER","23","23","23","“ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍⴰⴷⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ? ");
INSERT INTO rift_vpl VALUES ("JR23_24","025_23_24","JER","23","24","24","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵏⵏⵓⴼⴼⴰⵔ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵥⴰⵔⵔⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ ⵡⴻⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_25","025_23_25","JER","23","25","25","ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⴰⵎ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵇⵇⴰⵔⴻⵏ: ‘ⵜⵓⵖⴰ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⵉⵔⵊⴰ, ⵉⵛⵜ ⵏ ⵜⵉⵔⵊⴰ!’ ");
INSERT INTO rift_vpl VALUES ("JR23_26","025_23_26","JER","23","26","26","ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵉⵔⵊⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⴰⵎ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ? ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵡⴻⵛⵎⴰⵟ ⵏ ⵡⵓⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR23_27","025_23_27","JER","23","27","27","ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵔⵔⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵉⵜⵜⵓ ⵉⵙⴻⵎ ⵉⵏⵓ ⵙ ⵜⵉⵔⵊⴰ ⵏⵙⴻⵏ ⵏⵏⵉ ⵜⵜⵀⴰⵊⴰⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵓⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵙ ⴱⴰⵄⵍ. ");
INSERT INTO rift_vpl VALUES ("JR23_28","025_23_28","JER","23","28","28","ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵊⴰ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵜⵜ ⵉⵃⴰⵊⴰ, ⵓ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵡⴰⵍ ⵉⵏⵓ ⵙ ⵜⵉⴷⴻⵜⵜ. ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⵓⵎ ⵖⴰⵔ ⵉⵎⴻⵏⴷⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_29","025_23_29","JER","23","29","29","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⴰⵎ ⵜⵎⴻⵙⵙⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⴼⴹⵉⵙ ⵉ ⵉⵍⴻⴱⴱⵣⴻⵏ ⵜⴰⵚⴹⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JR23_30","025_23_30","JER","23","30","30","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵍⴻⵇⴼⴻⵖ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⵜⵜⴰⵛⴰⵔⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵉⵊⵊ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_31","025_23_31","JER","23","31","31","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵍⴻⵇⴼⴻⵖ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⵙⵙⵅⴻⴷⴷⴰⵎⴻⵏ ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⵓ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎⵎⵓ: ‘ⵏⴻⵜⵜⴰ ⵉⵇⵇⴰⵔ!’ ");
INSERT INTO rift_vpl VALUES ("JR23_32","025_23_32","JER","23","32","32","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵍⴻⵇⴼⴻⵖ ⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵜⵉⵔⵊⴰ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⵜⵜⵃⴰⵊⴰⵏ ⵜⵉⵔⵊⴰ ⵏⵏⵉ ⵓ ⴰⵎⵎⵓ ⵉ ⵜⵜⵖⴰⵔⵔⴰⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⴻⴳ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⵀⴰⵔⴷ ⵏⵙⴻⵏ ⵉⴱⴻⵟⵟⵍⴻⵏ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵓ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ ⴰⵡⴰⵍ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵏⵏⴼⴻⵄ ⵉ ⵍⴳⴻⵏⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR23_33","025_23_33","JER","23","33","33","“ⵅⵎⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⵉⵏ ⵉⵄⵏⴰ ⵅⴻⵏⵏⵉ ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ?’, ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⵎⵉⵏ ⵉⵄⵏⴰ ⵅⴻⵏⵏⵉ ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ?’ ‘ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴹⴰⵔⴻⵖ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR23_34","025_23_34","JER","23","34","34","ⴰⵏⴰⴱⵉ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴰⵎ ⵙⵜᵉⵀⴻⵣⵣⴰⵏ: ‘ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ?’, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵅⴻⵍⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR23_35","025_23_35","JER","23","35","35","ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ, ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵓⵎⴰⵙ: ‘ⵎⴰⵎⵎⴻⵛ ⵅⴰⴽ ⴷⴷ-ⵢⴰⵔⵔⴰ ⵙⵉⴷⵉ?’, ⵓ: ‘ⵎⵉⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ?’ ");
INSERT INTO rift_vpl VALUES ("JR23_36","025_23_36","JER","23","36","36","ⵡⴰⵔ ⵜⵉⴷⴰⵔⴻⵎ ⵄⴰⴷ ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⵎⵉⵏ ⵖⴰ ⵢⵉⵏⵉ ⴽⵓⵍ ⵉⵊⵊ: ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴼⴰⵔⵖⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR23_37","025_23_37","JER","23","37","37","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⴷ ⵉ ⵓⵏⴰⴱⵉ: ‘ⵎⴰⵎⵎⴻⵛ ⵅⴰⴽ ⴷⴷ-ⵢⴰⵔⵔⴰ ⵙⵉⴷⵉ?’, ⵏⵉⵖ: ‘ⵎⵉⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ?’ ");
INSERT INTO rift_vpl VALUES ("JR23_38","025_23_38","JER","23","38","38","ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ: ‘ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ?’, ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴰⵡⴰⵍ-ⴰ: ‘ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ?’, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵊⵊⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵏⵉ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵛⴰ: ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵙⵉⴷⵉ?’, ");
INSERT INTO rift_vpl VALUES ("JR23_39","025_23_39","JER","23","39","39","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵜⵓⵖ ⵇⴰⵄ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴹⴰⵔⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵡⴻⵎ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵡⵛⵉⵖ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR23_40","025_23_40","JER","23","40","40","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⵍⵃⴻⴳⵔⴰ ⵉ ⵍⴻⴱⴷⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵜⵜⵓⵏ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("JR24_1","025_24_1","JER","24","1","1","ⵙⵉⴷⵉ ⵉⵊⵊⴰ ⴰⵢⵉ ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⴰⵏ ⴰⵢⴰ. ⵅⵣⴰⵔ, ⵜⵜⵡⴰⵙⵙⴰⵔⵙⴻⵏⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵏ ⵜⴰⵣⴰⵔⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵏⴷⴻⵀ ⵢⴰⴽⵓⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴽ-ⴷ ⵉⵃⵔⴰⵢⴼⵉⵢⵢⴻⵏ ⴷ ⵢⴻⵎⵣⵉⵍⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR24_2","025_24_2","JER","24","2","2","ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⵓⴵⴻⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴰⵣⴰⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⵎ ⵍⴱⴰⵛⵓⵔ. ⴷⵉ ⵜⵙⵓⴵⴻⵜ ⵏⵏⴻⵖⵏⵉⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴰⵣⴰⵔⵜ ⵡⴰⵔ ⵜⴻⵃⵔⵉ ⴰⵟⵟⴰⵙ, ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⵜⴻⵃⵔⵉ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JR24_3","025_24_3","JER","24","3","3","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ, ⵉⵔⵎⵉⵢⴰ?” ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵜⴰⵣⴰⵔⵜ. ⵜⴰⵣⴰⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ ⵜⴻⵚⴱⴻⵃ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⴻⵃⵍⵉ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵛⵛⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR24_4","025_24_4","JER","24","4","4","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR24_5","025_24_5","JER","24","5","5","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎ ⵜⴰⵣⴰⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵃⴻⵙⴱⴻⵖ ⵚⴻⴱⵃⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵅ ⵓⵥⵥⵍⴻⵖ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR24_6","025_24_6","JER","24","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⴰⵔⵙⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵙ ⴰⵔⴹⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵖ, ⵡⴰⵔ ⵜⴻⵏ ⵀⴻⴷⴷⵎⴻⵖ, ⴰⴷ ⵜⴻⵏ ⵥⵥⵓⵖ, ⵡⴰⵔ ⵜⴻⵏ ⵇⴻⴵⵄⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR24_7","025_24_7","JER","24","7","7","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⴻⵏ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ ⵉⵎⵓⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR24_8","025_24_8","JER","24","8","8","“ⴰⵎ ⵜⴰⵣⴰⵔⵜ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵃⵍⵉ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵛⵛⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴰⵔⵔⴻⵖ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR24_9","025_24_9","JER","24","9","9","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴷ ⵍⵃⴻⴳⵔⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵙⵜⴻⵀⵣⵉ ⴷ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵢⴰⵥⵥⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR24_10","025_24_10","JER","24","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ ⴰⵍ ⴷⴷ-ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴰⵙⴻⵏ ⵡⵛⵉⵖ, ⵉ ⵏⵉⵜⵏⵉ ⵓ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR25_1","025_25_1","JER","25","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR25_2","025_25_2","JER","25","2","2","ⵉⵏⵏⴰ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⴰⵡⴰⵍ-ⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR25_3","025_25_3","JER","25","3","3","“ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵢⵓⵛⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵍ ⴰⵙⵙ-ⴰ, ⴰⵇⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⵊⴰⵍ ⵏ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵡⴰⵀ, ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⵏⴻⵛⵛ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JR25_4","025_25_4","JER","25","4","4","ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ-ⴷⴷ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵓ ⵡⴰⵔ ⵜⴻⵡⵛⵉⵎ ⵛⴰ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵡⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR25_5","025_25_5","JER","25","5","5","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: ‘ⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ ⵓ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵓⵛⴰ ⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵓ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵣⵉ ⵍⴻⴱⴷⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JR25_6","025_25_6","JER","25","6","6","ⵡⴰⵔ ⵜⵜⵔⴰⴷⴷⴰⴼⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⴱⴷⴻⵎ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵜⴱⴻⵏⴷⵇⴻⵎ. ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⴻⵄⵄⴰⵔⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⴻⴳⴳⴻⵖ ⵍⵖⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("JR25_7","025_25_7","JER","25","7","7","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⵙⵍⵉⵎ ⵛⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵄⴰⵔⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⵉ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR25_8","025_25_8","JER","25","8","8","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JR25_9","025_25_9","JER","25","9","9","ⵅⵣⴰⵔ, ⵙ ⵓⵢⴰ ⴰⴷ ⴳⴳⴻⵖ ⴰⴷ ⴰⵡⵢⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⵡⴹⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵃⴰⵔⵔⵎⴻⵖ ⵉ ⵓⵜⴻⵃⵃⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵜⵙⴻⴹⵃⴰⵛⵜ ⵓⵍⴰ ⴷ ⵍⵅⵉⵔⴱⴰⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR25_10","025_25_10","JER","25","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴽⴽⵙⴻⵖ ⵍⵃⴻⵙⵙ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵔⵛⴰⵇ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵎⵓⵍⴰⵢ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴻⵙⵍⵉⵜ, ⴷⴷⵔⵉⵣ ⵏ ⵢⴻⵥⵔⴰ ⵏ ⵜⵙⵉⵔⵜ ⵓⵍⴰ ⴷ ⵜⴼⴰⵡⵜ ⵏ ⵍⴻⴼⵏⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR25_11","025_25_11","JER","25","11","11","ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵓ ⵍⴻⴳⵏⵓⵙ-ⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JR25_12","025_25_12","JER","25","12","12","ⵅⵎⵉ ⵖⴰ ⵄⴷⵓⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵍⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR25_13","025_25_13","JER","25","13","13","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵏⵏⵉ ⵅⴰⵙ ⵏⵏⵉⵖ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵎⵉⵏ ⵉⵏⴻⴱⴱⴰ ⵉⵔⵎⵉⵢⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JR25_14","025_25_14","JER","25","14","14","ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ, ⵡⴰⵀ, ⵏⵉⵜⵏⵉ, ⴰⴷ ⵄⴻⴱⴱⴷⴻⵏ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵅⴻⵍⴼⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR25_15","025_25_15","JER","25","15","15","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴽⵙⵉ ⵍⴽⴰⵙ-ⴰ ⵏ ⴱⵉⵏⵓ ⵏ ⵡⴻⵙⵄⴰⵔ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵓ ⴻⵡⵛ ⵉ-ⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR25_16","025_25_16","JER","25","16","16","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵡⴻⵏ, ⴰⴷ ⵎⴻⵢⵢⵍⴻⵏ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⴱⵓⵀⵍⵓⵢⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵙⵉⴼ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR25_17","025_25_17","JER","25","17","17","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⴽⵙⵉⵖ ⵍⴽⴰⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⵡⵛⵉⵖ ⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("JR25_18","025_25_18","JER","25","18","18","... ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴷ ⵍⵅⵉⵔⴱⴻⵜ, ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵜⵙⴻⴹⵃⴰⵛⵜ ⵓⵍⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR25_19","025_25_19","JER","25","19","19","... ⵉ ⴼⵉⵍⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JR25_20","025_25_20","JER","25","20","20","... ⵉ ⵓⴱⴰⵔⵔⵓ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ... ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵄⵓⵚ ... ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵉ ⴰⵛⵇⴰⵍⵓⵏ, ⵖⴰⵣⵣⴰ, ⵄⴰⵇⵔⵓⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⴰⵛⴷⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("JR25_21","025_25_21","JER","25","21","21","... ⵉ ⵉⴷⵓⵎ, ⵎⵓ’ⴰⴱ ⴷ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("JR25_22","025_25_22","JER","25","22","22","... ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵚⵓⵔ, ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵚⵉⴷⵓⵏ ⵓ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("JR25_23","025_25_23","JER","25","23","23","... ⵉ ⴷⴰⴷⴰⵏ, ⵜⴰⵢⵎⴰ, ⴱⵓⵣ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵃⴻⴼⴼⴰⵏ ⴰⵛⵓⵡⵡⴰⴼ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("JR25_24","025_25_24","JER","25","24","24","... ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵄⵔⴰⴱⴻⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("JR25_25","025_25_25","JER","25","25","25","... ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵣⵉⵎⵔⵉ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵄⵉⵍⴰⵎ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⴰⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("JR25_26","025_25_26","JER","25","26","26","... ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵛⵛⴰⵎⴰⵍ, ⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ, ⵉⵊⵊⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ... ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵉⵙⵓ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵉⵛⴰⴽ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR25_27","025_25_27","JER","25","27","27","“ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵙⵡⴻⵎ, ⵙⵛⴰⵔⴻⵎ, ⵄⵓⵇⵇⴻⵎ, ⵡⴹⴰⵎ ⵓ ⵡⴰⵔ ⵜⴻⴽⴽⴰⵔⴻⵎ ⵄⴰⴷ ⵣⵣⴰⵜ ⵉ ⵙⵙⵉⴼ ⵉ ⴷⴷ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("JR25_28","025_25_28","JER","25","28","28","ⵅⵎⵉ ⵖⴰ ⴰⴳⵉⵏ ⴰⴷ ⴽⵙⵉⵏ ⵍⴽⴰⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵡⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵙ ⵓⵖⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JR25_29","025_25_29","JER","25","29","29","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵅ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴱⴷⵉⵖ ⵙ ⵍⵖⴰⵔ. ⵎⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⴳⴳⴻⵏ ⴰⵎ ⵜⵜⴻⴳⴳⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ? ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵍⴰⵖⵉⵖ ⵉ ⵙⵙⵉⴼ ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.’” ");
INSERT INTO rift_vpl VALUES ("JR25_30","025_25_30","JER","25","30","30","“ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵏⴻⴱⴱⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵓⵛⴰ ⴰⴷ ⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵉⵣⴻⵀⵀⴰⵔ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴻⵀⵀⴰⵔ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵍⴰⵖⴰ ⴰⵎ ⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴼⴼⵙⴻⵏ ⴰⴹⵉⵍ, ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JR25_31","025_25_31","JER","25","31","31","ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵉⵙⵙⵏⴻⵅⵍⵉⵄⴻⵏ ⴰⵍ ⵜⵎⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⴷⴷⴻⵄⵡⴻⵜ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵉⴽⵎⴻⵍ, ⴰⴷ ⵉⵄⴰⵔⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵖⴰⵔ ⵙⵙⵉⴼ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JR25_32","025_25_32","JER","25","32","32","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵜⴻⵙⵙⵓⵔⵓⴼ ⵣⵉ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ, ⵉⵛⵜ ⵏ ⵜⵀⴰⵔⵢⴰⴹⵜ ⵜⴻⵡⵄⴰⵔ ⵜⴻⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⵎⵓⵡⵡⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR25_33","025_25_33","JER","25","33","33","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ ⵅ ⵉⵛⵜ ⵏ ⵜⵎⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵜⵎⴰ ⵏⵏⴻⵖⵏⵉ. ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⵔⵓⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵊⴰⵔⵔⵡⴻⵏ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵟⵟⵍⴻⵏ. ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴻⵖⴱⴰⵔ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR25_34","025_25_34","JER","25","34","34","ⵔⵓⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⵙⵖⵓⵢⴻⵎ. ⵣⵓⵣⵣⴰⵔⴻⵎ ⴰⵛⴰⵍ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵊⵊⴻⵀⴷ ⵅ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵡⵓⴵⵉ, ⵎⴰⵖⴰⵔ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵍⵃⴰⵍ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏⵡⴻⵎ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴼⵔⵓⵔⵢⴻⵎ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵉⵖⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JR25_35","025_25_35","JER","25","35","35","ⵡⴰⵔ ⵜⵏⴻⴼⴼⴻⵄ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵓⵍⴰ ⴷ ⵡⴻⵏⵊⴰⵎ ⵏ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵊⵊⴻⵀⴷ ⵅ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("JR25_36","025_25_36","JER","25","36","36","ⵙⵃⴻⵙⵙⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵖⵓⵢⵢⵓⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵙ ⵊⵊⴻⵀⴷ, ⵎⴰⵎⵎⴻⵛ ⵜⵜⵔⵓⵏ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵊⵊⴻⵀⴷ ⵅ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵡⵓⴵⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵜⵜⴰⵔⴻⴷⴷⴻⴵ ⴷⴷⵎⴰⵏⵉ ⵏⵙⴻⵏ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JR25_37","025_25_37","JER","25","37","37","ⵎⴰⵖⴰⵔ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵓⴳⵏⵓⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR25_38","025_25_38","JER","25","38","38","ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵊⵊⴰ ⵏⴻⵜⵜⴰ ⴰⴷⵓⵔⵔⵉ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵙ ⵍⵃⴰⴷⵓⵇ ⵏ ⵙⵙⵉⴼ ⵏ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵙ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JR26_1","025_26_1","JER","26","1","1","ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ-ⴰ ⵣⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR26_2","025_26_2","JER","26","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴱⴻⴷⴷ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏⵏⵉ ⵣⵉ ⵛⴻⴽ ⵡⴻⵚⵚⵉⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵏⴷⵇⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵡⴰⵔ ⵜ ⵜⴻⵇⵇⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR26_3","025_26_3","JER","26","3","3","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵙⵍⴻⵏ, ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵏⴻⴷⵎⴻⵖ ⵅ ⵍⵖⴰⵔ ⵏⵏⵉ ⵏⵡⵉⵖ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜ ⴳⴳⴻⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR26_4","025_26_4","JER","26","4","4","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵖⴰⵔⵉ ⵜⴻⵙⵍⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴳⴳⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("JR26_5","025_26_5","JER","26","5","5","ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵙⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JR26_6","025_26_6","JER","26","6","6","ⵅⴻⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵖ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⴰⵎ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵛⵉⵍⵓ, ⵓⵛⴰ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("JR26_7","025_26_7","JER","26","7","7","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵙⵍⵉⵏ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵔⵎⵉⵢⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR26_8","025_26_8","JER","26","8","8","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵉⵔⵎⵉⵢⴰ ⴰⵡⴰⵍ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵟⵟⴼⴻⵏ ⵜ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("JR26_9","025_26_9","JER","26","9","9","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵏⴻⴱⴱⵉⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵜⴻⵏⵏⵉⴷ: ‘ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵛⵉⵍⵓ ⵓ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ?’” ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵎⵓⵏ ⵅ ⵉⵔⵎⵉⵢⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR26_10","025_26_10","JER","26","10","10","ⵓⵎⵉ ⵙⵍⵉⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵊⴷⵉⴷ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR26_11","025_26_11","JER","26","11","11","ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⴰⵔⵢⴰⵣ-ⴰ ⵉⵙⴷⴰⵀⴻⴵ ⵍⵎⴻⵡⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵜⴻⵙⵍⴰⵎ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR26_12","025_26_12","JER","26","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵔⵎⵉⵢⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴱⴱⵉⵖ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵜⴻⵙⵍⵉⵎ ⴹⵉⴷⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⴹⵉⴷⴷ ⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR26_13","025_26_13","JER","26","13","13","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵄⴻⴷⵍⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵓⵛⴰ ⵚⵍⴻⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵉ ⵅⴰⵡⴻⵎ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR26_14","025_26_14","JER","26","14","14","ⵎⴰⵛⴰ ⵏⴻⵛⵛ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ, ⴳⴳⴻⵎ ⵣⵣⴰⵢⵉ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR26_15","025_26_15","JER","26","15","15","ⵙⵏⴻⵎ ⵎⴰⵛⴰ ⵏⵉⵛⴰⵏ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵏⵖⵉⵎ ⴰⵢⵉ, ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR26_16","025_26_16","JER","26","16","16","ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴰⵏ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ: “ⴰⵔⵢⴰⵣ-ⴰ ⵡⴰⵔ ⵉⵙⵙⴷⵉⵃⴻⴵ ⵍⵎⴻⵡⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵏⴻⵖ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR26_17","025_26_17","JER","26","17","17","ⵛⴰ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴽⴽⴰⵔⴻⵏ, ⴱⴻⴷⴷⴻⵏ. ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("JR26_18","025_26_18","JER","26","18","18","“ⵎⵉⵅⴰ ⵣⵉ ⵎⵓⵔⴰⵛⵉⵜ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴰⴱⴱⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵣ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵓ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⵓ ⴰⴷⵔⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵎⴰⵏⵉ ⵖⴰ ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ.’    ");
INSERT INTO rift_vpl VALUES ("JR26_19","025_26_19","JER","26","19","19","ⵎⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵃⵉⵣⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ? ⵎⴰ ⵡⴰⵔ ⵉⴳⴳⵯⵉⴷ ⵏⴻⵜⵜⴰ ⵙⵉⴷⵉ ⵓ ⵉⴽⵙⵉ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⵉ ⵙⵉⴷⵉ ⴰⵍⴰⵎⵉ ⵉⵏⴷⴻⵎ ⵅ ⵍⵖⴰⵔ ⵉ ⵅⴰⵙⴻⵏ ⵉⵇⵇⴰⵔ? ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR26_20","025_26_20","JER","26","20","20","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵓⵔⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵄⵉⵢⴰ, ⵣⵉ ⵇⴰⵔⵢⴰⵜ-ⵢⴰⵄⴰⵔⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⵏⴻⴱⴱⴰ ⴹⵉⴷⴷ ⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR26_21","025_26_21","JER","26","21","21","ⵅⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵉⵅⵙ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜ ⵉⵏⴻⵖ. ⵉⵙⵍⴰ ⵓⵔⵉⵢⴰ ⴰⵢⴰ, ⵉⴳⴳⵯⴻⴷ, ⵢⴰⵔⵡⴻⵍ ⵓ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR26_22","025_26_22","JER","26","22","22","ⴰⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵎⴰⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ: ⵉⵍ-ⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴽⴱⵓⵔ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵉⵔⵢⴰⵣⴻⵏ. ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR26_23","025_26_23","JER","26","23","23","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵓⵔⵉⵢⴰ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵖⴰ ⵉ-ⵜ ⵙ ⵙⵙⵉⴼ. ⵏⴻⵜⵜⴰ ⵉⵏⴹⴰⵔ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JR26_24","025_26_24","JER","26","24","24","ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⵉⵔⵎⵉⵢⴰ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜ ⵜⵜⵉⵛⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR27_1","025_27_1","JER","27","1","1","ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ-ⴰ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR27_2","025_27_2","JER","27","2","2","“ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⴻⴳⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵙⴻⵖⵡⴰⵏ ⴷ ⵉⵣⴰⵢⵍⵓⵜⴻⵏ, ⵓ ⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵛ ");
INSERT INTO rift_vpl VALUES ("JR27_3","025_27_3","JER","27","3","3","ⵓⵛⴰ ⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ, ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ ⵓ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵚⵉⴷⵓⵏ, ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR27_4","025_27_4","JER","27","4","4","ⵓⵎⵓⵔ ⴰⵙⴻⵏ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⵙⵉⴷⵉⵜⴻⵏ ⵏⵙⴻⵏ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ ⵉ ⵉⵙⵉⴷⵉⵜⴻⵏ ⵏⵡⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("JR27_5","025_27_5","JER","27","5","5","ⵙ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵓⴼⵓⵙ ⵉⵏⵓ ⵉⵙⵙⵡⵉⵥⵥⴰⴷⴻⵏ ⴳⴳⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⵉ ⵡⴻⵏⵏⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR27_6","025_27_6","JER","27","6","6","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ-ⵢⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ. ⵡⵛⵉⵖ ⴰⵙ ⵓⵍⴰ ⴷ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR27_7","025_27_7","JER","27","7","7","ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓⵍⴰ ⵉ ⵎⵎⵉⵙ ⴷ ⵎⵎⵉⵙ ⵏ ⵎⵎⵉⵙ ⴰⵍⴰⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⵃⴰⵍ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR27_8","025_27_8","JER","27","8","8","ⵍⴳⴻⵏⵙ ⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵉ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⴰⵙ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⵀⵡⴰ ⵉⵍⵉ ⵏⵏⴻⵙ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵓⵣⴰⵢⵍⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵍ ⵜⴻⵏ ⵉ ⵖⴰ ⵇⴹⵉⵖ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR27_9","025_27_9","JER","27","9","9","ⴽⴻⵏⵏⵉⵡ ⵅⴻⵏⵏⵉ, ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵏⵡⴻⵎ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⵉⵔⵊⴰ ⵏⵡⴻⵎ ⴷ ⵉⴱⴻⵣⴳⴰⵡⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵙⴻⵃⵃⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵙⴻⵅⵅⴰⵔⴰⵎ ⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ!, ");
INSERT INTO rift_vpl VALUES ("JR27_10","025_27_10","JER","27","10","10","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ, ⴰⵍⴰⵎⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵏ ⴰⵥⵥⵍⴻⵖ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR27_11","025_27_11","JER","27","11","11","ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴰⴹⴰⵔⴻⵏ ⵉⵍⵉ ⵏⵏⴻⵙ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵓⵣⴰⵢⵍⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵙⵙⴻⵅⵅⴰⵔ, ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴰⴷ ⵜ ⵊⵊⴻⵖ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵛⴰⵔⵣ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵣⴷⴻⵖ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR27_12","025_27_12","JER","27","12","12","ⵅⴻⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵏⵏⵉⵖ: “ⴳⴳⴻⵎ ⵉⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵓⵣⴰⵢⵍⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵙⴻⵅⵅⴰⵔⴻⵎ ⴰⵙ ⵓ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴻⴷⴷⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR27_13","025_27_13","JER","27","13","13","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵏⵖⴻⵎ, ⵛⴻⴽ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵅ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR27_14","025_27_14","JER","27","14","14","ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵛⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ!’, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⴱⴱⴰⵏ ⴰⵡⴻⵎ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR27_15","025_27_15","JER","27","15","15","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵥⵥⵍⴻⵖ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ,” ");
INSERT INTO rift_vpl VALUES ("JR27_16","025_27_16","JER","27","16","16","ⵙⵙⵉⵡⵍⴻⵖ ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵏⵏⵉⵖ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: ⵅⵣⴰⵔ, ⵍⴻⵇⵛⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⵜⵡⴰⵔⵔⴻⵏ ⴷⴻⵖⵢⴰ ⵣⵉ ⴱⴰⴱⵉⵍ!, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR27_17","025_27_17","JER","27","17","17","ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵜⴻⵙⵍⵉⵎ ⵛⴰ, ⵎⴰⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴻⴷⴷⴰⵔⴻⵎ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⵉⵔⴱⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JR27_18","025_27_18","JER","27","18","18","ⵎⵍⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⴵⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵖⴰⵔⵙⴻⵏ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵇⴰ ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR27_19","025_27_19","JER","27","19","19","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵅ ⵉⴱⵉⵍⴰⵔⴻⵏ, ⵅ ⵍⴻⴱⵃⴰⵔ ⵏ ⵏⵏⵃⴰⵙ, ⵅ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵖⵏⵉ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR27_20","025_27_20","JER","27","20","20","ⵉⵏⵏⵉ ⵡⴰⵔ ⴽⵉⴷⴻⵙ ⵉⴽⵙⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓⵎⵉ ⵉⵏⴷⴻⵀ ⵢⴰⴽⵓⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JR27_21","025_27_21","JER","27","21","21","ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵍⴻⵇⵛⵓⵄ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ: ");
INSERT INTO rift_vpl VALUES ("JR27_22","025_27_22","JER","27","22","22","ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⴰⴷ ⵎⵎⴻⴽⵙⵉⵏ ⵓ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ ⴰⵍ ⴰⵙⵙ ⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ ⵖⴰ ⴰⵔⵣⴼⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵓ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR28_1","025_28_1","JER","28","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ, ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⵓⵔ, ⴰⵏⴰⴱⵉ ⵣⵉ ⵊⵉⴱⵄⵓⵏ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵎⵓⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR28_2","025_28_2","JER","28","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵣⴰⵢⵍⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR28_3","025_28_3","JER","28","3","3","ⵄⴰⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⵉ ⵉⴽⵙⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓⵛⴰ ⵢⵉⵡⵢ-ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR28_4","025_28_4","JER","28","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵢⴰⴽⵓⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵉ ⴷⴷ-ⵢⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵣⴰⵢⵍⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("JR28_5","025_28_5","JER","28","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵉ ⵓⵏⴰⴱⵉ ⵃⴰⵏⴰⵏⵢⴰ - ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵓⵏ, ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ - ");
INSERT INTO rift_vpl VALUES ("JR28_6","025_28_6","JER","28","6","6","ⵡⴰⵀ ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ: “ⴰⵎⵉⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙⵉⴷⵉ! ⵉⵍⵉ ⴰⴷ ⵉⵙⵙⴻⵇⴼⴻⵍ ⵙⵉⴷⵉ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵉ ⵜⵏⴻⴱⴱⵉⴷ ⴰⵍⴰⵎⵉ ⵖⴰ ⵢⴰⵔⵔ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵣⵉ ⴱⴰⴱⵉⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("JR28_7","025_28_7","JER","28","7","7","ⵙⴻⵍ ⵎⴰⵛⴰ ⵉ ⵡⴰⵡⴰⵍ-ⴰ ⵉ ⵣⵉ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ ⵓ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⵓⵏ: ");
INSERT INTO rift_vpl VALUES ("JR28_8","025_28_8","JER","28","8","8","‘ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉⵏⵓ ⴷ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵏⴻⴱⴱⴰⵏ ⴹⵉⴷⴷ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵓ ⴹⵉⴷⴷ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴳⴻⵍⴷⵉⵜⵉⵏ ⵅ ⴳⴰⵔⵔⴰ, ⵅ ⵉⵛⴻⵍⵡⴰⵡⴻⵏ ⵓ ⵅ ⵟⵟⴰⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR28_9","025_28_9","JER","28","9","9","ⵎⴰⵛⴰ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⵅ ⵙⵍⴰⵎ, ⵎⴰⵍⴰ ⴰⵡⴰⵍ ⵏ ⵓⵏⴰⴱⵉ ⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵏⴰⴱⵉ ⵏⵏⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR28_10","025_28_10","JER","28","10","10","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵓⵏⴰⴱⵉ ⵃⴰⵏⴰⵏⵢⴰ ⴰⵣⴰⵢⵍⵓ ⵏ ⵢⵉⵔⵉ ⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵢⴰⵔⵥ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("JR28_11","025_28_11","JER","28","11","11","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵃⴰⵏⴰⵏⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵄⴷⵓⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴽⴻⵎⵎⵍⴻⵏ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵣⴰⵢⵍⵓ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉ ⵉⴵⴰⵏ ⵅ ⵢⵉⵍⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ.” ⵓⵛⴰ ⵉⵔⵎⵉⵢⴰ ⵢⵓⵢⵓⵔ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR28_12","025_28_12","JER","28","12","12","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵢⴰⵔⵥⴰ ⵓⵏⴰⴱⵉ ⵃⴰⵏⴰⵏⵢⴰ ⴰⵣⴰⵢⵍⵓ ⵅ ⵢⵉⵍⴰⵡⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR28_13","025_28_13","JER","28","13","13","“ⵓⵢⵓⵔ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵃⴰⵏⴰⵏⵢⴰ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵉⵣⴰⵢⵍⵓⵜⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵜⴰⵔⵥⵉⴷ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵉⵣⴰⵢⵍⵓⵜⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JR28_14","025_28_14","JER","28","14","14","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵏ ⵡⵓⵣⵣⴰⵍ ⵙⵙⴰⵔⵙⴻⵖ ⵜ ⵅ ⵢⵉⵍⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ⵓⵍⴰ ⴷ ⵍⵎⴰⵍ ⵡⵛⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JR28_15","025_28_15","JER","28","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵉ ⵓⵏⴰⴱⵉ ⵃⴰⵏⴰⵏⵢⴰ: “ⵙⴻⵍ, ⵃⴰⵏⴰⵏⵢⴰ, ⵙⵉⴷⵉ ⵡⴰⵔ ⵛⴻⴽ ⴷⴷ ⵉⵙⵙⴻⴽⴽ ⵛⴰ ⵓ ⵛⴻⴽ ⵜⵖⴰⵔⵔⴻⴷ ⵍⴳⴻⵏⵙ-ⴰ ⴰⴷ ⵉⵜⵜⵛⴻⵍ ⵅ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR28_16","025_28_16","JER","28","16","16","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵏⴹⴰⵔⴻⵖ. ⵄⴰⴷ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ-ⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵅ ⵓⵃⴻⵢⵢⴻⴷ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR28_17","025_28_17","JER","28","17","17","ⵉⵎⵎⵓⵜ ⵓⵏⴰⴱⵉ ⵃⴰⵏⴰⵏⵢⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JR29_1","025_29_1","JER","29","1","1","ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⴷⴻⵀ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("JR29_2","025_29_2","JER","29","2","2","ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⵉ ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵢⴰⴽⵓⵏⵢⴰ ⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵍⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵍⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ⵍⴰ ⵍⴻⵎⵄⵓⴵⴰⵎ ⵓⵍⴰ ⴷ ⵉⵎⵣⵉⵍⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR29_3","025_29_3","JER","29","3","3","ⵉⵙⵙⴻⴽⴽ ⵉⵔⵎⵉⵢⴰ ⵜⴰⴱⵔⴰⵜ ⵏⵏⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⴰⵍⵄⴰⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⴷ ⵊⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵍⵇⵉⵢⴰ, ⵉⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵖⴰⵔ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵜⴰⴱⵔⴰⵜ ⵜⴻⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR29_4","025_29_4","JER","29","4","4","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴱⴰⴱⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("JR29_5","025_29_5","JER","29","5","5","‘ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵓⴷⵔⵉⵏ ⵓⵛⴰ ⵣⴻⴷⵖⴻⵎ ⴷⴰⵢⵙⴻⵏⵜ, ⵥⵥⵓⵎ ⵉⵃⵡⵉⵛⴻⵏ ⵓⵛⴰ ⵛⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR29_6","025_29_6","JER","29","6","6","ⴰⵡⵢⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵓⵛⴰ ⵊⵊⴻⵎ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⴰⵡⵢⴻⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵓⵛⴰ ⵡⵛⴻⵎ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⵔⵡⴻⵏⵜ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ⵃⴹⴰⵎ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⴻⵎⵎⴰⵔⵏⵉⵎ, ⵡⴰⵔ ⵜⵏⴻⵇⵇⵚⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JR29_7","025_29_7","JER","29","7","7","ⴰⵔⵣⵓⵎ ⵍⴻⵀⵏⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵏⴻⴷⵀⴻⵖ ⵓ ⵜⵜⴰⵔⴻⵎ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴷⵉ ⵍⴻⵀⵏⴰ ⵏⵏⴻⵙ ⵉ ⵉⴵⴰ ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("JR29_8","025_29_8","JER","29","8","8","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵛⴻⵎⵜⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵓ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⵉⵔⵊⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵊⵊⴰⵏ ⴰⴷ ⵜⴰⵔⵊⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("JR29_9","025_29_9","JER","29","9","9","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⴱⴱⴰⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⴷⴷ-ⵙⴻⴽⴽⴻⵖ ⵛⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JR29_10","025_29_10","JER","29","10","10","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵎⵉ ⵖⴰ ⵇⴻⴼⵍⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⴱⴰⴱⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⵣⴼⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵡⴰⵍ ⵉⵏⵓ ⴰⵚⴻⴱⵃⴰⵏ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR29_11","025_29_11","JER","29","11","11","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵎⴰⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉ ⵖⴰⵔⵉ ⵅⴰⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵍⴻⵀⵏⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵏ ⵍⵖⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵉⵎⴰⵔ ⴷ ⵍⴰⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR29_12","025_29_12","JER","29","12","12","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵍⴰⵖⴰⵎ, ⴰⴷ ⵖⴰⵔⵉ ⵜⴻⵥⵥⴰⴵⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵙⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR29_13","025_29_13","JER","29","13","13","ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⵎ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵜⴰⴼⴻⵎ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵣⵓⵎ ⵅⴰⴼⵉ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR29_14","025_29_14","JER","29","14","14","ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵜⵜⵡⴰⴼⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵅⴰⵡⴻⵎ ⵓⵥⵥⵍⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵏⴻⴷⵀⴻⵖ ⴷⵉ ⵍⵎⴻⵏⴼⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR29_15","025_29_15","JER","29","15","15","“ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰⵎ: ‘ⵙⵉⴷⵉ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷⵉ ⴱⴰⴱⵉⵍ!’, ");
INSERT INTO rift_vpl VALUES ("JR29_16","025_29_16","JER","29","16","16","ⵅ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵓⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ, ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⵉⵏⵏⵉ ⵡⴰⵔ ⴰⴽⵉⴷⵡⴻⵎ ⵢⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("JR29_17","025_29_17","JER","29","17","17","ⵡⴰⵀ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵊⵊⴻⵖ ⴰⵎ ⵜⴰⵣⴰⵔⵜ ⵉⵅⵙⴰⵔⴻⵏ, ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR29_18","025_29_18","JER","29","18","18","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴹⴼⴰⵔⴻⵖ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⴻⵅⵣⵉ ⴷ ⵓⵙⵉⴳⴳⵯⴻⴷ ⴷ ⵜⵙⴻⴹⵃⴰⵛⵜ ⴷ ⵍⵃⴻⴳⵔⴰ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR29_19","025_29_19","JER","29","19","19","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ⵄⴰⴷ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙⵙⴻⴽⴽⴻⵖ ⵜⴻⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR29_20","025_29_20","JER","29","20","20","“ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵉⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR29_21","025_29_21","JER","29","21","21","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⴰⵅⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵍⴰⵢⴰ, ⵓ ⵅ ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR29_22","025_29_22","JER","29","22","22","ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⴱⵉⵍ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴽⴽⵙⴻⵏ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ, ⴰⴷ ⵉⵏⵉⵏ: ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵢⴻⴳⴳ ⴰⵎ ⵚⵉⴷⵇⵉⵢⴰ ⴷ ⴰⵃⴰⴱ ⵏⵏⵉ ⵉⵛⵏⴻⴼ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵙ ⵜⵎⴻⵙⵙⵉ!, ");
INSERT INTO rift_vpl VALUES ("JR29_23","025_29_23","JER","29","23","23","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵛⵜ ⵏ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ: ⵏⵉⵜⵏⵉ ⵣⵏⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⵡⵉ ⵜⴻⵏ ⵢⵓⴷⵙⴻⵏ ⵓ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵏⵏⵉⵖ. ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵀⴷⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR29_24","025_29_24","JER","29","24","24","ⵉ ⵛⴰⵎⵄⵉⵢⴰ ⵣⵉ ⵏⴰⵃⵍⴰⵎ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ ⴰⵎⵎⵓ: ");
INSERT INTO rift_vpl VALUES ("JR29_25","025_29_25","JER","29","25","25","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵇⵇⴰⵔ: ‘ⵎⵉⵏⵣⵉ ⵙ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ-ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴼⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵢⵓⵔⴰ ⴷⴰⵢⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("JR29_26","025_29_26","JER","29","26","26","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵢⴰⵀⵓⵢⴰⴷⴰⵄ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵓⴱⵓⵀⴰⵍⵉ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵏⴰⴱⵉ. ⴰⴷ ⵜ ⵜⴻⵇⵇⵏⴻⴷ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⴰⴽ-ⴷ ⵍⴳⵉⴷ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR29_27","025_29_27","JER","29","27","27","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵄⴰⵇⴱⴻⴷ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵄⴰⵏⴰⵜⵓⵜ, ⵡⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵏⴰⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("JR29_28","025_29_28","JER","29","28","28","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵏⴻⵛⵛⵉⵏ ⴷⵉ ⴱⴰⴱⵉⵍ ⵎⴰⵏⵉ ⵉⵇⵇⴰⵔ: ⴰⵟⵟⴰⵙ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ! ⵙⴱⴻⴷⴷⴻⵎ ⵜⵓⴷⵔⵉⵏ ⵓ ⵣⴻⴷⵖⴻⵎ ⴷⴰⵢⵙⴻⵏⵜ, ⵥⵥⵓⵎ ⵉⵃⵡⵉⵛⴻⵏ ⵓ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵍⵉⵇⵇⵉ ⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("JR29_29","025_29_29","JER","29","29","29","ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵚⴰⴼⴰⵏⵢⴰ ⵜⴰⴱⵔⴰⵜ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR29_30","025_29_30","JER","29","30","30","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR29_31","025_29_31","JER","29","31","31","“ⵙⵇⴰⴷ ⴰⵔⴻⵇⵇⴰⵙ-ⴰ ⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵛⵉⵎⵄⵉⵢⴰ ⵣⵉ ⵏⴰⵃⵍⴰⵎ: ⵎⵉⵏⵣⵉ ⵛⴰⵎⵄⵉⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴰⴱⴱ ⴰⵡⴻⵎ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ-ⵉ-ⴷⴷ ⵙⵙⴻⴽⴽⴻⵖ, ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵉⵇⵇⴻⵎ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ!’, ");
INSERT INTO rift_vpl VALUES ("JR29_32","025_29_32","JER","29","32","32","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵉ ⵛⴰⵎⵄⵉⵢⴰ ⵣⵉ ⵏⴰⵃⵍⴰⵎ ⵓ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵥⴰⵔⵔ ⵍⵅⵉⵔ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵙ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⴷ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR30_1","025_30_1","JER","30","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵙⵉⴷⵉ ⵉ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR30_2","025_30_2","JER","30","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵇⵇⴰⵔ: ‘ⴰⵔⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷ ⴰⵛ ⵏⵏⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JR30_3","025_30_3","JER","30","3","3","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⵛⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("JR30_4","025_30_4","JER","30","4","4","ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉ ⵣⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ: ");
INSERT INTO rift_vpl VALUES ("JR30_5","025_30_5","JER","30","5","5","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵏⴻⵙⵍⴰ ⵍⵃⴻⵙⵙ ⵉⵙⵙⵉⴳⴳⵯⴰⴷⴻⵏ, ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵉⵙⵙⵏⴻⵅⵍⵉⵄⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR30_6","025_30_6","JER","30","6","6","ⵙⴻⵇⵙⴰⵎ ⵓ ⵅⵣⴰⵔⴻⵎ, ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵔⵓⵡ? ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⵜⵡⴰⵍⵉⵖ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜᵉⵜⵜⴰⵔⵓ, ⵓ ⵇⴰⵄ ⴰⵖⴻⵎⴱⵓⴱ ⵉⴷⵡⴻⵍ ⵉⵡⴰⵔⵖ ⴰⵎ ⵍⵅⴻⵛⴱⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("JR30_7","025_30_7","JER","30","7","7","ⵓⵛⵜ, ⵎⴰⵖⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵙⵙ ⵏⵏⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵏⴻⵜⵜⴰ. ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR30_8","025_30_8","JER","30","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵣⴰⵢⵍⵓ ⵅ ⵢⵉⵍⴰⵡⴻⵏ ⵏⵏⴻⵛ. ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜ ⵜⵜⴻⵊⵊⵉⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵙⴻⵅⵅⴰⵔ ⵄⴰⴷ ⴰⵎ ⵢⵉⵙⵎⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("JR30_9","025_30_9","JER","30","9","9","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓⵍⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ ⴷⴰⵡⵓⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR30_10","025_30_10","JER","30","10","10","“ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ, ⴰ ⵛⴻⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⴻⴼⵛⵉⵍ ⵛⴰ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵜⵉⵎⵎⵓⵔⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵓⵍⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏ. ⴰⴷ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⴰⴷ ⵉⴷⴷⴰⵔ ⴷⵉ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JR30_11","025_30_11","JER","30","11","11","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵖⴰⵔ ⵛⴻⴽ ⵣⵓⵣⵣⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵛⴻⴽ ⵇⴻⵟⵟⵉⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⴱⴱⵉⵖ ⵙ ⵍⴻⵄⴱⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵀⴻⵚⵚⴱⴻⵖ ⴷ ⴰⵎⴻⵣⴷⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("JR30_12","025_30_12","JER","30","12","12","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵎ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⴳⴳⴻⵏⴼⴰ, ⴰⵢⴻⵣⵣⵉⵎ ⵏⵏⴻⵎ ⵉⵜⵜⴻⵇⵇⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR30_13","025_30_13","JER","30","13","13","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵅⴰⵎ ⵉⵙⵙⵄⵉⵣⵣ ⴰⵍ ⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵉⵛⴼⴻⵏ, ⵡⴰⵔ ⵖⴰⵔⴻⵎ ⵛⴰ ⴷⴷⴰⵡⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⵅ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR30_14","025_30_14","JER","30","14","14","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵜⵓⵏ ⵛⴻⵎ, ⵡⴰⵔ ⵅⴰⵎ ⵜⵜⵙⴻⵇⵙⵉⵏ, ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵛⴰⵜ ⵍⴻⵄⴷⵓ ⴰⵎⵎⵓ ⵉ ⵛⴻⵎ ⵡⵜⵉⵖ, ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉ ⵢⴰⵔⴻⴱⴱⴰⵏ ⵙ ⵍⴻⵇⵙⴰⵃⴻⵜ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ ⵉⵎⵖⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵎ ⵡⴻⵙⵄⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR30_15","025_30_15","JER","30","15","15","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵖⵓⵢⵢⵓⴷ ⴰⵎⵎⵓ ⵅ ⵜⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵎ, ⵅ ⵍⴻⵃⵔⵉⵇ ⵏⵏⴻⵎ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ? ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ ⵉⵎⵖⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵎ ⵡⴻⵙⵄⴻⵏ ⴰⵟⵟⴰⵙ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴷⴰⵢⴻⵎ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR30_16","025_30_16","JER","30","16","16","ⵙ ⵓⵢⴰ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⴼⴼⵣⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵛⵛⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵓ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⴽⴻⵛⵛⴹⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⵎ ⵢⵓⵛⴰⵔⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⴷ ⵜⵓⴽⴽⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JR30_17","025_30_17","JER","30","17","17","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⵛⴻⴼⵏⴻⵖ ⵓ ⴰⴷ ⵛⴻⵎ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵣⴻⴳ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⴻⵎ ⵏⵏⵉ ⵉ ⴷⴰⵢⴻⵎ ⵡⵜⵉⵏ ⵏⵉⵜⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ ⴰⵎ ‘ⵜⴰⵎⴻⵏⴹⴰⵔⵜ!’, ⵇⵇⴰⵔⴻⵏ: ⴰⵇⴰ-ⵜⵜ ⴷ ⵚⵉⵀⵢⵓⵏ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⵙⴻⵇⵙⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ!’” ");
INSERT INTO rift_vpl VALUES ("JR30_18","025_30_18","JER","30","18","18","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵉⵇⵉⴹⴰⵏ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⵃⵎⴻⵖ ⵅ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ. ⴰⴷ ⴱⵏⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵄⴰⵡⴻⴷ ⵅ ⵍⵅⵉⵔⴱⴰⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴻⵇⵚⴰⵔ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵉⵚⴻⵃⵃ. ");
INSERT INTO rift_vpl VALUES ("JR30_19","025_30_19","JER","30","19","19","ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ ⵏ ⵓⵇⴰⴷⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⴻⵡⴷⴰⵏ ⵉⴼⴰⵔⵔⵃⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⵉⴽⴽⵡⵉⵍⴻⵏ ⴷⵔⵓⵙ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵖ ⵍⵄⴻⵣⵣ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⵉⵔⵉⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR30_20","025_30_20","JER","30","20","20","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵓⵛⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵃⵚⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR30_21","025_30_21","JER","30","21","21","ⴰⵎⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵓ ⵍⵃⴰⴽⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴼⴻⵖ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵇⴰⵔⵔⴱⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵢⴰⴷⴻⵙ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⴹⵎⴰⵏ ⵙ ⵡⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⴷⴻⵙ?’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR30_22","025_30_22","JER","30","22","22","“ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR30_23","025_30_23","JER","30","23","23","“ⵅⵣⴰⵔ, ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵏ ⵙⵉⴷⵉ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵡⴻⵙⵄⴰⵔ, ⴰⵎ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⵣⵣⴻⴱⵣⵉⴱ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵀⵡⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR30_24","025_30_24","JER","30","24","24","ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉ ⵛⴰ ⴰⵍ ⴷ ⵉⴳⴳⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⴻⵏ. ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴰⵙ ⵜⴼⴻⵀⵎⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR31_1","025_31_1","JER","31","1","1","“ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JR31_2","025_31_2","JER","31","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵍⴳⴻⵏⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵙⵙⵉⴼ, ⵢⵓⴼⴰ ⴰⵔⴹⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ, ⵡⴰⵀ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ ⵉⵙⵔⴰⵉⵍ!’” ");
INSERT INTO rift_vpl VALUES ("JR31_3","025_31_3","JER","31","3","3","“ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵉⴱⴰⵏ ⴰⵢⵉ-ⴷⴷ ⵙⵉⴷⵉ!” ... “ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⵎ ⵙ ⵜⴰⵢⵔⵉ ⵏ ⵍⴻⴱⴷⴰ, ⵅ ⵓⵢⴰ ⵛⴻⵎ ⴷⴷ-ⵊⴻⴱⴷⴻⵖ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR31_4","025_31_4","JER","31","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⴱⵏⵉⵖ ⵄⴰⵡⴻⴷ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⵉⴷ ⵄⴰⵡⴻⴷ, ⴰ ⵛⴻⵎ ⵉⵙⵔⴰⵉⵍ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ. ⵛⴻⵎ ⴰⴷ ⵜⵣⴻⵡⵡⵇⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵄⴰⵡⴻⴷ ⵙ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ, ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ ⵙ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR31_5","025_31_5","JER","31","5","5","ⴰⴷ ⵜⴻⵥⵥⵓⴷ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ: ⵉⵏⵏⵉ ⵉⵜⵜⴻⵥⵥⵓⵏ ⴰⴷ ⵜⴻⵏⵜ ⵥⵥⵓⵏ ⵓ ⵍⵖⵉⴵⴻⵜ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵔⵔⴻⵏ ⵎⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JR31_6","025_31_6","JER","31","6","6","ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ: ‘ⴽⴽⴰⵔⴻⵎ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ, ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!’” ");
INSERT INTO rift_vpl VALUES ("JR31_7","025_31_7","JER","31","7","7","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵖⴻⵏⵏⵊⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵙⵍⵉⵡⵍⵉⵡⴻⵎ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴱⴰⵔⵔⵃⴻⵎ, ⵙⴻⵎⵖⴰⵔⴻⵎ ⵜ, ⵉⵏⵉⵎ: ⴰ ⵙⵉⴷⵉ, ⵙⴻⵏⵊⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR31_8","025_31_8","JER","31","8","8","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵇⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴷ ⵜⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵡⴻⵏ. ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⴷⴰ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR31_9","025_31_9","JER","31","9","9","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵜⵜⵔⵓⵏ, ⴰⴷ ⵜⴻⵏ ⴳⴻⵡⵡⴷⴻⵖ ⴰⵎ ⴽⴻⵙⵙⵉⵏ ⵙ ⵍⵎⴻⵄⵔⵓⴼ. ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⴷⵀⴻⵖ ⵖⴰⵔ ⵜⴻⵖⵣⴰⵔⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⵜⵏⴻⵇⵔⵉⴹⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴱⴰⴱⴰⵙ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⵎⵉ ⴰⵎⴻⵏⵣⵓ.’” ");
INSERT INTO rift_vpl VALUES ("JR31_10","025_31_10","JER","31","10","10","“ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴳⵏⵓⵙ, ⴱⴰⵔⵔⵃⴻⵎ ⵜ ⵅ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⵏⵉⵎ: ‘ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⵣⵓⵣⴰⵔⴻⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵜ ⵉⵙⵙⵎⵓⵏ ⵄⴰⵡⴻⴷ ⵓ ⴰⴷ ⵜ ⵢⴰⵔⵡⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⴰⵔⴻⴽⴽⵡⴻⵙ ⵓⵎⴻⴽⵙⴰⵡ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR31_11","025_31_11","JER","31","11","11","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⴼⴷⵉ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵉⴼⴻⴽⴽ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵊⴻⵀⴷⴻⵏ.’   ");
INSERT INTO rift_vpl VALUES ("JR31_12","025_31_12","JER","31","12","12","ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵓ ⴰⴷ ⵙⵍⵉⵡⵍⴻⵡⴻⵏ ⵅ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓⵛⴰ ⴰⴷ ⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵍⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵉⵎⴻⵏⴷⵉ, ⵖⴰⵔ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⵖⴰⵔ ⵣⵣⴻⵛⵜ, ⵖⴰⵔ ⵉⵣⵎⴰⵔⴻⵏ ⵓ ⵖⴰⵔ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ. ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵍⴻⵄⵔⴰⵚⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⵏ ⵓⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵉⵍⵉⵏ ⵛⴻⴹⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR31_13","025_31_13","JER","31","13","13","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴼⴰⵔⵃ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵖⴰⵔ ⵛⵛⴹⵉⵃ ⵙ ⵏⵏⵓⴱⵜⴰⵜ, ⵓⵍⴰ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵎⵓⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴰⵛⴹⴰⵏ ⵏⵙⴻⵏ ⴷ ⴰⵔⵛⵓⵇ, ⴰⴷ ⵜⴻⵏ ⵄⴻⵣⵣⵉⵖ, ⴰⴷ ⵜⴻⵏ ⵙⵙⴼⴰⵔⵃⴻⵖ ⴰⵡⴰⵔⵏⵉ ⵡⴻⵛⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR31_14","025_31_14","JER","31","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵊⵉⵡⵏⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙ ⵜⴰⴷⵓⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⵓⵛⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵊⵊⵉⵡⴻⵏ ⵙ ⵍⵅⴰⵔ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR31_15","025_31_15","JER","31","15","15","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⴷⵉ ⵔⴰⵎⴰ, ⴰⵡⴻⵄⵄⴻⴷ ⴷ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴰⵔⵣⴰⴳⴻⵏ: ⵔⴰⵃⵉⵍ ⵜᵉⵜⵜⵔⵓ ⵅ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴻⵣⵣⴰ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵄⴰⴷ.’ ");
INSERT INTO rift_vpl VALUES ("JR31_16","025_31_16","JER","31","16","16","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵟⵟⴻⴼ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵎ ⵉ ⵓⵏⵉⵅⵙⴻⵙ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⵉ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵜⴻⴵⴰ ⵍⵎⵓⵏⴻⵜ ⵉ ⵡⴰⵔⴱⴻⵔ ⵏⵏⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("JR31_17","025_31_17","JER","31","17","17","ⴰⵇⴰ ⴷⵉⵏ ⵍⴰⵢⴰⵙ ⵉ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR31_18","025_31_18","JER","31","18","18","“ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵎⵍⵉⵃ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⵛⴻⵜⵛⴰ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵏⵏⴰ: ‘ⵛⴻⴽ ⵜⴰⵔⴻⴱⴱⵉⴷ ⴰⵢⵉ ⵓ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵔⴻⴱⴱⵉⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵄⴻⵊⵎⵉ ⵡⴰⵔ ⵉⵜⵜⴹⴰⵡⴰⵄⴻⵏ. ⴰⵔⵔ ⴰⵢⵉ, ⴷⴻⵖⵢⴰ ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR31_19","025_31_19","JER","31","19","19","ⵎⴰⵖⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ, ⵜⵓⴱⴻⵖ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵖ ⵙⵙⵏⴻⵖ, ⵡⵜⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ. ⵏⴻⵛⵛ ⵙⴻⴹⵃⵉⵖ, ⵏⴼⴻⴹⵃⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵔⴱⵓⵖ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵜⴻⵎⵥⵉ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("JR31_20","025_31_20","JER","31","20","20","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵎⵎⵉ ⵉⵖⵍⴰⵏ ⵖⴰⵔⵉ ⴷ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ ⵉⵄⵉⵣⵣⴻⵏ? ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔⴻⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵇⵇⵉⵎⴻⵖ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵜ. ⵅ ⵓⵢⴰ ⵉⵛⵛⴰⵜ ⵊⵊⵓⴼ ⵉⵏⵓ ⴷⴰⵢⵉ. ⵏⵉⵛⴰⵏ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴰⵔⵔⴻⵃⵎⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR31_21","025_31_21","JER","31","21","21","“ⵙⴱⴻⴷⴷ ⵉⵇⵓⴵⴰⵢ ⵉ ⵡⴻⵙⵛⴰⵏ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵙⴰⵔⵙ ⵉⵥⵔⴰ ⵏ ⵊⵊⵓⵔⵔⴰⵜ ⵏ ⵡⴻⴱⵔⵉⴷ, ⴻⴳⴳ ⵓⵍ ⵏⵏⴻⵎ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ, ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⴷⵉ ⵜⴻⴳⴳⵓⵔⴻⴷ. ⴷⵡⴻⵍ, ⴰ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵉⵙⵔⴰⵉⵍ, ⴷⵡⴻⵍ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR31_22","025_31_22","JER","31","22","22","ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜᵉⵜⵜⵍⵉⵄⴻⴷ, ⴰ ⵛⴻⵎ, ⵢⴻⴵⵉⵙ ⵉ ⵅⴰⴼⵉ ⵉⵃⴻⵢⵢⴷⴻⵏ? ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ: ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵀⵉⵍⵍⴰ ⵎⴰⵔⵔⴰ ⵉ ⵡⴻⵔⵢⴰⵣ.” ");
INSERT INTO rift_vpl VALUES ("JR31_23","025_31_23","JER","31","23","23","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵡⴰⵍ-ⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵅⵎⵉ ⵖⴰ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏ: ⴰⴷ ⵛⴻⵎ ⵉⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵜⵙⴻⴳⴷⴰ, ⴰ ⴰⴷⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JR31_24","025_31_24","JER","31","24","24","ⵢⴰⵀⵓⴷⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⴷⵖⴻⵏⵜ ⵊⵎⵉⵄ, ⵉⴼⴻⴵⴰⵃⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵜⵍⵉⵄⴻⵏ ⴰⴽ-ⴷ ⵜⵃⵉⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR31_25","025_31_25","JER","31","25","25","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⴻⵙⵙⵓⵖ ⵍⴻⵄⵎⴰⵔ ⵢⵓⵃⵍⴻⵏ ⵓⵛⴰ ⵙⵙⵊⵉⵡⵏⴻⵖ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵉⵃⵣⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR31_26","025_31_26","JER","31","26","26","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴼⴰⵇⴻⵖ-ⴷⴷ ⵓⵛⴰ ⵓⵛⵉⵖ ⵎⴻⵛⵃⴰⵔ ⵢⵉⵣⵉⴹ ⵢⵉⴹⴻⵚ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR31_27","025_31_27","JER","31","27","27","“ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵣⴰⵔⵄⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵙ ⵣⵣⴰⵔⵔⵉⵄⴻⵜ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JR31_28","025_31_28","JER","31","28","28","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙⴻⵏ ⵄⴻⵙⵙⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⵍⵄⴻⵖ, ⴰⴷ ⵀⴻⴷⵎⴻⵖ, ⴰⴷ ⴰⵔⵥⴻⵖ, ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵍⵖⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵄⴻⵙⵙⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵥⵥⵓⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR31_29","025_31_29","JER","31","29","29","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⴰⴷ ⵉⵏⵉⵏ ⵄⴰⴷ: ‘ⵉⴱⴰⴱⴰⵜⴻⵏ ⵛⵛⵉⵏ ⴰⴹⵉⵍ ⴰⵙⴻⵎⵎⴰⵎ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏⵜ ⵜⴻⵖⵎⴰⵙ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵃⴼⴰⵏⵜ.’ ");
INSERT INTO rift_vpl VALUES ("JR31_30","025_31_30","JER","31","30","30","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵎⵎⴻⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵣⵉ ⵎⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⴹⵉⵔ ⴰⵙⴻⵎⵎⴰⵎ, ⴰⴷ ⴰⵙ ⴷⴻⵡⵍⴻⵏⵜ ⵜⴻⵖⵎⴰⵙ ⵃⴼⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR31_31","025_31_31","JER","31","31","31","“ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⵏⵉ ⴷⵉ ⵖⴰ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("JR31_32","025_31_32","JER","31","32","32","ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⵄⴰⵀⴷ ⵉ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵓⵎⵉ ⵜⴻⵏ ⵟⵟⴼⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⴷⵀⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵏⵏⵉ ⴰⵔⵥⵉⵏ, ⵡⴰⵅⵅⴰ ⵣⴻⵄⵎⴰ ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵔⵢⴰⵣ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR31_33","025_31_33","JER","31","33","33","ⵎⴰⵖⴰⵔ ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⴰⵔⵉⵖ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⵙⵉⴷⵉ ⵉ ⵏⵉⵜⵏⵉ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JR31_34","025_31_34","JER","31","34","34","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵙⵙⴻⵍⵎⵉⴷ ⵄⴰⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵏⵉⵖ ⵓⵎⴰⵙ, ⴰⵎ ⵇⵇⴰⵔⴻⵏ: ‘ⵙⵙⴻⵏ ⵙⵉⴷⵉ!’, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⴻⵏ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵖⴼⴰⵔⴻⵖ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵄⴰⴷ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR31_35","025_31_35","JER","31","35","35","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴼⵓⵛⵜ ⵉ ⵜⴼⴰⵡⵜ ⴷⴻⴳ ⵡⴰⵙⵙ, ⵡⴻⵏⵏⵉ ⵢⵓⵎⵓⵔⴻⵏ ⵜⴰⵣⵉⵔⵉ ⴷ ⵉⵜⵔⴰⵏ ⵉ ⵜⴼⴰⵡⵜ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵀⵡⴰⵍⴻⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵍⴰⵎⵉ ⴷⴷ-ⴷⵓⵇⵇⵓⵣⴻⵏⵜ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("JR31_36","025_31_36","JER","31","36","36","‘ⵎⴰⵍⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ-ⴰ ⴰⴷ ⴷⴷ-ⵡⴹⴰⵏⵜ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴱⴻⴷⴷ ⵓⵍⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JR31_37","025_31_37","JER","31","37","37","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵍⴰ ⵜⵜⵡⴰⵄⴱⴰⵔⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵓ ⵎⴰⵍⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵔⵣⵓⵏ ⵙⴰⴷⵓ ⴷⵙⵓⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR31_38","025_31_38","JER","31","38","38","“ⵅⵣⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⴱⵏⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵄⴰⵡⴻⴷ ⵉ ⵙⵉⴷⵉ, ⵣⵉ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⵃⴰⵏⴰⵏⵉⵢⵉⵍ ⴰⵍ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("JR31_39","025_31_39","JER","31","39","39","ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵇⵢⴰⵙ ⵄⴰⴷ ⴽⵜⴰⵔ, ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵖⴰⵔ ⵜⴻⵡⵔⵉⵔⵜ ⵏ ⵊⴰⵔⵉⴱ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵊⵓⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JR31_40","025_31_40","JER","31","40","40","ⵎⴰⵔⵔⴰ ⵜⴰⵢⵙⴰⵔⵜ ⵙ ⵍⵅⴻⵛⴱⴰⵜ ⵉⵎⵎⵓⵜⴻⵏ ⵓ ⵙ ⵢⵉⵖⵖⴻⴹ ⴷ ⵎⴰⵔⵔⴰ ⵉⵢⵢⴰⵔⴻⵏ ⴰⵍ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵇⵉⴷⵔⵓⵏ ⴰⵍ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵢⴻⵢⵙⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ. ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴷⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵄⴰⴷ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR32_1","025_32_1","JER","32","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⵙⴻⴳⴳⵯⴰⵙ-ⴰ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR32_2","025_32_2","JER","32","2","2","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵃⴻⵚⵚⴰⵔ-ⴷⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴰⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⴻⴱⴱⴻⵙ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR32_3","025_32_3","JER","32","3","3","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⵃⴻⴱⴱⴻⵙ ⵉ-ⵜ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵎ ⴷ ⴰⵙ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵏⴰⴱⴱⴻⴷ, ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("JR32_4","025_32_4","JER","32","4","4","ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴰⵔ ⵉⵏⴻⵊⵊⴻⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵥⴰⵔ ⵜⵉⵟⵟ ⴷⵉ ⵜⵉⵟⵟ. ");
INSERT INTO rift_vpl VALUES ("JR32_5","025_32_5","JER","32","5","5","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⵚⵉⴷⵇⵉⵢⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵇⵇⵉⵎ, ⴰⵍ ⵖⴰⵔⴻⵙ ⵉ ⵖⴰ ⵔⴰⵃⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵖⴻⵎ ⴰⴽ-ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⴽⴽⵡⵉⴹⴻⵎ ⵛⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR32_6","025_32_6","JER","32","6","6","ⵉⵔⵎⵉⵢⴰ ⵉⵏⵏⴰ: “ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR32_7","025_32_7","JER","32","7","7","‘ⵅⵣⴰⵔ, ⵃⴰⵏⴰⵎ’ⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴻⵎⵎⵉⵛ ⵛⴰⵍⵍⵓⵎ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵏⵉ: ⵙⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵢⵢⴰⵔ ⵉⵏⵓ ⴷⵉ ⵄⴰⵏⴰⵜⵓⵜ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵍⵃⴻⵇⵇ ⵏ ⵍⴻⴼⴷⵉⵢⵢⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵙⵖⵉⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR32_8","025_32_8","JER","32","8","8","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵃⴰⵏⴰⵎ’ⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴻⵎⵎⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵙⴻⵖ ⵅⴻⵏⵏⵉ ⵉⵢⵢⴰⵔ ⵉⵏⵓ ⴷⵉ ⵄⴰⵏⴰⵜⵓⵜ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵍⵃⴻⵇⵇ ⴰⴷ ⵜ ⵜⵡⴰⵔⵜⴻⴷ ⵓⵛⴰ ⵖⴰⵔⴻⴽ ⵍⵃⴻⵇⵇ ⵏ ⵓⵙⵓⴼⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⴼⴷⵉⴷ, ⴰⴷ ⵜ ⵜⴻⵙⵖⴻⴷ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⵙⵏⴻⵖ ⵉⵍⵍⴰ ⴰⵡⴰⵍ-ⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR32_9","025_32_9","JER","32","9","9","ⴰⵎⵎⵓ ⵉ ⵙⵖⵉⵖ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵄⴰⵏⴰⵜⵓⵜ ⵅ ⵃⴰⵏⴰⵎ’ⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴻⵎⵎⵉ, ⵓⵛⴰ ⵡⴻⵣⵏⴻⵖ ⴰⵙ ⵏⵏⵓⵇⴰⵔⵜ: ⵙⴱⴻⵄⵟⴰⵛ ⵛⵉⵇⵍⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR32_10","025_32_10","JER","32","10","10","ⵏⴻⵛⵛ ⵡⴻⵇⵇⵄⴻⵖ ⵅ ⵜⴰⴱⵔⴰⵜ, ⵛⴻⵎⵎⵄⴻⵖ ⵜⵜ ⵓⵛⴰ ⵊⵊⵉⵖ ⵛⵛⵀⵓⴷ ⴰⴷ ⵜⵜ ⵙⵙⵎⴻⵜⵏⴻⵏ ⵓⵛⴰ ⵡⴻⵣⵏⴻⵖ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵍⵎⵉⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR32_11","025_32_11","JER","32","11","11","ⴽⵙⵉⵖ ⵜⴰⴱⵔⴰⵜ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵛⴻⵎⵎⵄⴻⵏ, ⵉⵜⵜⵡⴰⵔⵉ ⴷⴰⵢⴻⵙ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⴳⴳ ⵍⵄⴰⵀⴷ ⵓ ⵎⵉⵏ ⴵⴰⵏⵜ ⵍⴼⴰⵔⴰⵢⵉⴹ, ⵓⵍⴰ ⵜⴰⴱⵔⴰⵜ ⵢⴰⵔⴻⵣⵎⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JR32_12","025_32_12","JER","32","12","12","ⵓⵛⴰ ⵡⵛⵉⵖ ⵜⴰⴱⵔⴰⵜ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵉ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵃⵙⵉⵢⴰ, ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵃⴰⵏⴰⵎ’ⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵄⴻⵎⵎⵉ, ⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⵛⵀⵓⴷ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴻⵇⵇⵄⴻⵏ ⵜⴰⴱⵔⴰⵜ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR32_13","025_32_13","JER","32","13","13","ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⴱⴰⵔⵓⵅ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("JR32_14","025_32_14","JER","32","14","14","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴽⵙⵉ ⵜⵉⴱⵔⴰⵜⵉⵏ-ⴰ, ⵜⴰⴱⵔⴰⵜ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ, ⴰⵎ ⵜⴻⵏⵏⵉ ⵉⵛⴻⵎⵎⵄⴻⵏ ⴰⵎ ⵜⴰⵏⵉⵜⴰ, ⵜⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵓⵛⴰ ⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵜⵍⴰⵅⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵃⴹⴰⵏⵜ!’ ");
INSERT INTO rift_vpl VALUES ("JR32_15","025_32_15","JER","32","15","15","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⴷ ⵜⵜⵡⴰⵙⵖⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵓⴷⵔⵉⵏ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR32_16","025_32_16","JER","32","16","16","ⴰⵡⴰⵔⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵡⵛⵉⵖ ⵜⴰⴱⵔⴰⵜ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ ⵉ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵥⵥⵓⴵⴻⵖ ⵙ ⵍⴰⴵⴰⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("JR32_17","025_32_17","JER","32","17","17","“ⴰⵅ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵙ ⵓⵖⵉⵍ ⵏⵏⴻⵛ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ. ⵡⴰⵔ ⵅⴰⴽ ⵉⵡⵄⴰⵔ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JR32_18","025_32_18","JER","32","18","18","ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵍⵓⵍⵓⴼ ⵓⵛⴰ ⵜⵅⴻⴵⵚⴻⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⴰ ⵛⴻⴽ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⴰⵊⴻⴱⴱⴰⵔ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ: ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR32_19","025_32_19","JER","32","19","19","ⵛⴻⴽ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵛⵛⵡⴰⵔ ⵓ ⵜⴻⵊⵀⴻⴷ ⴷⵉ ⵜⵎⴻⴳⴳⴰ, ⵎⴰⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵜⵜⵄⴻⵙⵙⴻⵏⵜ ⵅ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵅⴻⴵⵚⴻⴹ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR32_20","025_32_20","JER","32","20","20","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵊⵉⵣⴰⵜ ⴷⵉ ⵎⵉⵚⵔⴰ, ⴰⵍ ⴰⵙⵙ-ⴰ, ⴰⵎ ⴷⴻⴳ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⴷⴻⴳ ⵉⵡⴷⴰⵏ ⵏⵏⴻⵖⵏⵉ. ⵜⴻⴳⴳⵉⴷ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR32_21","025_32_21","JER","32","21","21","ⵛⴻⴽ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ-ⴷⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⵙ ⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴰⴹⴻⵏ, ⵓⵎⵉ ⵜⴻⵙⵙⴻⴽⴽⴰⵔⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JR32_22","025_32_22","JER","32","22","22","ⵛⴻⴽ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ, ⵜⴻⵏⵏⵉ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜ ⵜⴻⵡⵛⴻⴷ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR32_23","025_32_23","JER","32","23","23","ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜⵜ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵓ ⵡⴰⵔ ⴳⴳⵉⵏ ⵄⵍⴰⵃⵚⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏⵣⵉ ⵜⴻⵏ ⵜⵡⴻⵚⵚⵉⴷ. ⵙ ⵓⵢⴰ ⵉ ⵜⴻⵏ ⵉⵍⵇⴻⴼ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR32_24","025_32_24","JER","32","24","24","ⵅⵣⴰⵔ, ⵉⵛⴱⴰⵔⴻⵏ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ! ⵏⵉⵜⵏⵉ ⵉⵡⴹⴻⵏ-ⴷⴷ ⴰⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ, ⵓⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴻⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ. ⵎⵉⵏ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⵇⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ. ⵅⵣⴰⵔ, ⵜᵉⵜⵜⵡⴰⵔⵉⴷ ⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR32_25","025_32_25","JER","32","25","25","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⴻⵏⵏⵉⴷ ⴰⵢⵉ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵙⴻⵖ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⴻⵊⵊ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵜⵜ ⵙⵙⵎⴻⵜⵏⴻⵏ, ⵍⴰⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵏⴷⵉⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR32_26","025_32_26","JER","32","26","26","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR32_27","025_32_27","JER","32","27","27","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵎⴰⵔⵔⴰ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ. ⵎⴰ ⵉⵡⵄⴰⵔ ⵅⴰⴼⵉ ⵛⴰ?’ ");
INSERT INTO rift_vpl VALUES ("JR32_28","025_32_28","JER","32","28","28","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⵟⵟⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("JR32_29","025_32_29","JER","32","29","29","ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⴷⴼⴻⵏ, ⴰⴷ ⵇⴻⴷⴷⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⴰⴽ-ⴷ ⵜⵓⴷⵔⵉⵏ ⵏⵏⵉ ⵅ ⵜⵣⴻⵖⵡⵉⵏ ⵏⵙⴻⵏⵜ ⵉ ⵣⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⴱⴰⵄⵍ ⵓⵛⴰ ⵙⴻⵢⵢⴱⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR32_30","025_32_30","JER","32","30","30","ⵎⴰⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵎⵖⵉⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⵄⴰⵔⴻⵏ ⴰⵢⵉ ⵙ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ!’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR32_31","025_32_31","JER","32","31","31","‘ⵎⴰⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵜⵜ ⵉ ⵏⴻⵛⵛ ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⴷ ⵡⴻⵙⵄⴰⵔ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⴰⵍ ⴰⵙⵙ-ⴰ, ⴰⵍⴰⵎⵉ ⵜⵜ ⵖⴰ ⵏⴹⴰⵔⴻⵖ ⵅ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ");
INSERT INTO rift_vpl VALUES ("JR32_32","025_32_32","JER","32","32","32","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR32_33","025_32_33","JER","32","33","33","ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵢⵉ-ⴷⴷ ⵙ ⵡⴻⵄⵔⵓⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵖⴻⵎⴱⵓⴱ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵙⵙⵍⴻⵎⴷⴻⵖ ⵜⴻⵏ, ⵄⴰⴷ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙⵙⵖⴰⵔⴻⵖ ⵜⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JR32_34","025_32_34","JER","32","34","34","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵅⴻⴼ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵙⵙⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR32_35","025_32_35","JER","32","35","35","ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⴱⴰⵄⵍ ⵎⴰⵏⵉ ⵉ ⴷ ⴰⵙ ⵜⵜⵡⴻⵀⵀⴱⴻⵏ ⴷⴷⴱⴰⵢⴻⵃ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⵀⵉⵏⵏⵓⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏⵜ ⵉ ⵎⵓⵍⴰⴽ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵎⵉⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵓⵎⵓⵔⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵓ ⵎⵉⵏ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴱⴰⵍ ⵉⵏⵓ, ⴰⵇⴰ ⴰⴷ ⴳⴳⴻⵏ ⵏⵏⵄⵉ ⴰⵎ ⵡⴰ ⴰⵍⴰⵎⵉ ⵄⴰⵔⵏⴻⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⴷⴷⵏⵓⴱ.’” ");
INSERT INTO rift_vpl VALUES ("JR32_36","025_32_36","JER","32","36","36","“ⵙ ⵓⵢⴰ, ⵍⴻⵅⵅⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵉ ⵅ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⴰⵇⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵙ ⵙⵙⵉⴼ, ⵙ ⵍⴰⵥ ⵓ ⵙ ⵟⵟⴰⵄⵓⵏ!’: ");
INSERT INTO rift_vpl VALUES ("JR32_37","025_32_37","JER","32","37","37","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵓⵥⵥⵍⴻⵖ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⵓ ⴷⴻⴳ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR32_38","025_32_38","JER","32","38","38","ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR32_39","025_32_39","JER","32","39","39","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵓⵍ ⴷ ⵉⵊⵊ ⵓⵍⴰ ⴷ ⵡⴻⴱⵔⵉⴷ ⴷ ⵉⵊⵊ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵉ ⵜⵉⵣⵉ ⵏⵙⴻⵏ ⵓ ⵉ ⵜⵉⵣⵉ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR32_40","025_32_40","JER","32","40","40","ⵏⴻⵛⵛ ⴰⴽⵉⴷⵙⴻⵏ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⴰⵇⴰ ⵡⴰⵔ ⵜⵜⵃⴻⵢⵢⵉⴷⴻⵖ ⵣⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⴰⵔⵙⴻⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜⵃⴻⵢⵢⵉⴷⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR32_41","025_32_41","JER","32","41","41","ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴼⴰⵔⵃⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜⵜⵀⵉⵍⵍⵉⵖ ⵓ ⵣⵉ ⵍⵎⴰⵏⴻⵜ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵥⵥⵓⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵉⵏⵓ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("JR32_42","025_32_42","JER","32","42","42","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ ⵉⵡⵢⴻⵖ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ-ⵢⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴰⵎⵎⵓ ⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵙⵙⵉⵡⴹⴻⵖ ⵎⴰⵔⵔⴰ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⵅⴰⵙⴻⵏ ⵏⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JR32_43","025_32_43","JER","32","43","43","ⴰⴷ ⵙⵖⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵢⵢⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵉ ⵅⴻⴼ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ: ‘ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵏⵀⵍⴰ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵔ, ⵜⴻⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JR32_44","025_32_44","JER","32","44","44","ⴰⴷ ⵙⵖⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵙ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⴷ ⵡⴻⵇⵇⵄⴻⵏ ⵓ ⴰⴷ ⵛⴻⵎⵎⵄⴻⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏ ⵜⵎⴻⵙⵖⵉⵡⵜ, ⴰⴷ ⴰⵡⵢⴻⵏ ⵍⴻⵛⵀⵓⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵎⴻⵜⵏⴻⵏ ⵜⴰⵎⴻⵙⵖⵉⵡⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR33_1","025_33_1","JER","33","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ ⵅⴰⵙ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR33_2","025_33_2","JER","33","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵜⵜ ⵢⴰⵔⴻⵛⵎⴻⵏ ⴰⵍⴰⵎⵉ ⵜⵜ ⵖⴰ ⵉⴱⴻⴷⴷ ⴷ ⵓⴱⴻⴷⴷⵉ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("JR33_3","025_33_3","JER","33","3","3","‘ⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵓ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR33_4","025_33_4","JER","33","4","4","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵜⵓⴷⵔⵉⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵅ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵓⴷⵓⵔⵔⵉ ⴹⵉⴷⴷ ⵏ ⵡⴻⵛⴱⴰⵔⴻⵏ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⴹⵉⴷⴷ ⵏ ⵙⵙⵉⴼ: ");
INSERT INTO rift_vpl VALUES ("JR33_5","025_33_5","JER","33","5","5","ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵏⵉ ⵙ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵏⵖⵉⵖ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵙⵙⴷⵓⵔⵔⵢⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JR33_6","025_33_6","JER","33","6","6","ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ-ⵜⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⵄⴷⴰⵍ ⴷ ⵓⴳⴻⵏⴼⵓ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵄⴰⵔⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵍⴻⵀⵏⴰ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JR33_7","025_33_7","JER","33","7","7","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓ ⴰⴷ ⵜⴻⵏ ⴱⵏⵉⵖ ⴰⵎ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JR33_8","025_33_8","JER","33","8","8","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⴽⵉⴷⵉ ⵅⴹⴰⵏ. ⴰⴷ ⵖⴼⴰⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵅⴹⴰⵏ ⴰⴽⵉⴷⵉ ⵓⵛⴰ ⵄⴻⴷⴷⴰⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JR33_9","025_33_9","JER","33","9","9","ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵏⴻⵛⵛ ⴷ ⵉⵙⴻⵎ ⵉⵙⵙⴻⴼⵔⴰⵃⴻⵏ ⴷ ⵓⵙⴻⵎⵖⴰⵔ ⴷ ⵛⵛⴰⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵍⴰⵏ ⵍⵅⴰⵔ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⴳⴳⴻⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵓ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵏⴰ ⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⴳⴳⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR33_10","025_33_10","JER","33","10","10","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵉ ⵅ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ: ‘ⴰⵇⴰ-ⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⴷ ⵍⵎⴰⵍ!’, ⵡⴰⵀ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⴷ ⴰⵎⴻⵣⴷⵓⵖ ⵏⵉⵖ ⴷ ⵍⵎⴰⵍ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵄⴰⴷ ");
INSERT INTO rift_vpl VALUES ("JR33_11","025_33_11","JER","33","11","11","ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵔⵛⴰⵇ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵎⵓⵍⴰⵢ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵜⴻⵙⵍⵉⵜ, ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ⵇⴰⴷⴰⵎ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵚⴱⴻⵃ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ!, ⵜⵎⵉⵊⵊⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⴰⵇⴰⴷⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR33_12","025_33_12","JER","33","12","12","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵉ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⴷ ⵍⵎⴰⵍ, ⵡⴰⵀ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏⵜ ⵄⴰⵡⴻⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("JR33_13","025_33_13","JER","33","13","13","ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵄⴷⵓⵏ ⵡⵓⴵⵉ ⵄⴰⵡⴻⴷ ⵙⴰⴷⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵃⴻⵙⵙⴱⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR33_14","025_33_14","JER","33","14","14","“ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵖ ⴰⵡⴰⵍ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⵉ ⵙⵙⵉⵡⵍⴻⵖ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR33_15","025_33_15","JER","33","15","15","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵙⵙⵖⴻⵎⵢⴻⵖ ⵉ ⴷⴰⵡⵓⴷ ⴰⵖⴻⴷⴷⵓ ⵏ ⵜⵙⴻⴳⴷⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴻⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR33_16","025_33_16","JER","33","16","16","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵜⴻⵣⴷⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ, ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ: ‘ⵙⵉⴷⵉ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR33_17","025_33_17","JER","33","17","17","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵏⵇⴻⵚ ⵉ ⴷⴰⵡⵓⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("JR33_18","025_33_18","JER","33","18","18","ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵏⴻⵇⵇⴻⵚ ⵄⴻⵎⵎⴰⵔⵚ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵏⵉⵖ ⴰⴷ ⵉⵙⵙⴱⴻⵅⵅⴰⵔ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵉⵖ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR33_19","025_33_19","JER","33","19","19","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR33_20","025_33_20","JER","33","20","20","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵍⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴰⵔⵥⵎⴻⵎ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵙ ⵡⴰⵙⵙ ⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵙ ⴵⵉⵍⴻⵜ ⴰⵍ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR33_21","025_33_21","JER","33","21","21","ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ ⵓⵍⴰ ⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵎⵎⵉⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵓ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR33_22","025_33_22","JER","33","22","22","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⴷⵉ ⵏ ⵍⴻⴱⵃⴰⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴱⴰⵔ, ⴰⵎⵎⵓ ⵙ ⵡⴰⵟⵟⴰⵙ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵜⴰⵔⵡⴰ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⵓ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR33_23","025_33_23","JER","33","23","23","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR33_24","025_33_24","JER","33","24","24","“ⵎⴰ ⵡⴰⵔ ⵜⴻⵥⵔⵉⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴰⵡⴰⵍ ⵍⴳⴻⵏⵙ-ⴰ, ⵇⵇⴰⵔⴻⵏ: ‘ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴰⴵⴰⵜ ⵏⵏⵉ ⵉⴼⴰⵔⵣ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏⵜ’? ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⵜⴻⵀⵣⴰⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR33_25","025_33_25","JER","33","25","25","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰⵍⴰ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵙ ⵡⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵖ ⵜⵜⴻⴳⴳⴻⵖ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("JR33_26","025_33_26","JER","33","26","26","ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴷⴰⵡⵓⴷ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵄⴰⴷ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉⵏⵏⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⵉⵏⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR34_1","025_34_1","JER","34","1","1","ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ - ⵓⵎⵉ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⴼⵓⵙ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵜⵓⵖⴰ ⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ - ⵉ ⵉⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("JR34_2","025_34_2","JER","34","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵓⵢⵓⵔ ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵉ ⴰⵙ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵇⵇⴻⴷ ⵜⵉⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JR34_3","025_34_3","JER","34","3","3","ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵏⴻⵊⵊⵎⴻⴷ ⵉ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴷ ⵛⴻⴽ ⵟⵟⴼⴻⵏ ⵓ ⴰⴷ ⵛⴻⴽ ⵡⵛⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵜⵉⵟⵟ ⴷⵉ ⵜⵉⵟⵟ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴹⴻⴷ ⴰⵍ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR34_4","025_34_4","JER","34","4","4","ⵙⴻⵍ ⵎⴰⵛⴰ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⵎⵎⵓ ⵉ ⵅⴰⴽ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵏⵖⴻⴷ ⵛⴰ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JR34_5","025_34_5","JER","34","5","5","ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⴷⵉ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉⵢⴰⵜ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵛ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵣⵉⵛ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵛⴻⴽ, ⴰⴷ ⵙⵙⴰⵔⵖⴻⵏ ⵄⴰⵡⴻⴷ ⴷ ⵜⵉⵎⴻⵙⵙⵉⵢⴰⵜ ⵉ ⵛⴻⴽ ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵡⵜⴻⵏ ⴰⴳⴻⵊⴷⵓⵔ, ⴰⴷ ⵉⵏⵉⵏ: ⴰⵅ, ⵙⵉⴷⵉ!’, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴰⵍ-ⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR34_6","025_34_6","JER","34","6","6","ⵉⵙⵙⵉⵡⴻⵍ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JR34_7","025_34_7","JER","34","7","7","ⵓⵎⵉ ⵜⵓⵖⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⴽ-ⴷ ⵍⴰⵅⵉⵛ ⴷ ⵄⴰⵣⵉⵇⴰ, ⵎⴰⵖⴰⵔ ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⵊⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR34_8","025_34_8","JER","34","8","8","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⵉⵇⵇⴻⵏ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵓⵙⴰⵔⵔⴻⵃ ⵊⴰⵔ ⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR34_9","025_34_9","JER","34","9","9","ⵎⴰⵃⴻⵏⴷ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ ⵓ ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ, ⵉ ⵓⵄⵉⴱⵔⴰⵏⵉ ⵓ ⵉ ⵜⵄⵉⴱⵔⴰⵏⴻⵛⵜ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵙⵎⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR34_10","025_34_10","JER","34","10","10","ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⵍⵄⴰⵀⴷ, ⵙⵍⵉⵏ ⴰⵇⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵖⴰⵔⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵙⵎⴻⵖ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR34_11","025_34_11","JER","34","11","11","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴱⴻⴷⴷⵍⴻⵏ, ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵔⵅⵓⵏ, ⵃⵚⴰⵔⴻⵏ ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⵄⴰⵡⴻⴷ ⴷ ⵉⵎⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR34_12","025_34_12","JER","34","12","12","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR34_13","025_34_13","JER","34","13","13","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⵏ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ, ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("JR34_14","025_34_14","JER","34","14","14","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵓⵎⴰⵙ ⴰⵄⵉⴱⵔⴰⵏⵉ ⵏⵏⵉ ⴷ ⴰⵛ ⵉⵣⵣⴻⵏⵣⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵅⴻⴷⴷⴻⵎ ⵉ ⵛⴻⴽ ⵙⴻⵜⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵜⴰⵔⵅⵓⴷ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵜⵍⴻⵍⵍⵉ! ⵎⴰⵛⴰ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵙⵍⵉⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⵛⴰ ⴰⵎⴻⵣⵣⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("JR34_15","025_34_15","JER","34","15","15","ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ, ⵜⴻⴳⴳⵉⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⵎ ⵉⴱⴰⵔⵔⴻⵃ ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵓⵙⴰⵔⵅⵓ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴳⴳⵉⵎ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⵉⵏ ⵅⴻⴼ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JR34_16","025_34_16","JER","34","16","16","ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵜⴻⵏⵏⵇⴻⵍⴱⴻⵎ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵜⴻⵙⵙⵄⵉⴵⵜⴻⵎ ⵉⵙⴻⵎ ⵉⵏⵓ. ⴽⵓⵍ ⵉⵊⵊ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵙⵎⴻⵖ ⵏⵏⴻⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴰⵔⵅⵓⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵏⵉ ⵅⵙⴻⵏ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵃⵚⴰⵔⴻⵎ ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏ ⴷ ⵉⵎⵙⴻⵎⵖⴰⵏ ⴷ ⵜⵉⵢⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR34_17","025_34_17","JER","34","17","17","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⵙⵍⵉⵎ ⵎⴰⵃⴻⵏⴷ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵓⵙⴰⵔⵅⵓ ⵉ ⵓⵎⴰⵙ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⵅⵣⴰⵔ, ⴰⵎⵎⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵓⵙⴰⵔⵅⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵖ ⵉ ⵙⵙⵉⴼ, ⵉ ⵟⵟⴰⵄⵓⵏ ⵓ ⵉ ⵍⴰⵥ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴳⴳⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JR34_18","025_34_18","JER","34","18","18","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵄⴷⵓⵏ ⵅ ⵍⵄⴰⵀⴷ ⵉⵏⵓ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⴳⴳⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⴰⵎ ⵓⵄⴻⵊⵎⵉ ⵏⵏⵉ ⴱⴹⴰⵏ ⵅ ⵜⵏⴰⵢⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵊⴰⵔ ⵉⵣⴻⵢⵏⴰⵜ ⵏⵏⴻⵙ ⵛⵓⵇⴻⵏ ⵏⵉⵜⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("JR34_19","025_34_19","JER","34","19","19","ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵉⵛⵓⵇⴻⵏ ⵎⴰⵔⵔⴰ ⵊⴰⵔ ⵉⵣⵉⵢⵏⴰⵜ ⵏ ⵓⵄⴻⵊⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("JR34_20","025_34_20","JER","34","20","20","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ ⵓⵛⴰ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉ ⵍⵎⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("JR34_21","025_34_21","JER","34","21","21","ⵓⵍⴰ ⴷ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⴼⴼⵖⴻⵏ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("JR34_22","025_34_22","JER","34","22","22","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵓⵎⵓⵔⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⵉⴷⴻⵙ ⵎⵎⴻⵏⵖⴻⵏ, ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵇⵇⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⵓⵖ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR35_1","025_35_1","JER","35","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR35_2","025_35_2","JER","35","2","2","“ⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵔⵉⴽⴰⴱ ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⴰⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵉⵊⵊ ⵣⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ, ⵓ ⴻⵡⵛ ⴰⵙⴻⵏ ⴱⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR35_3","025_35_3","JER","35","3","3","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵖ-ⴷⴷ ⵢⴰⵣⴰⵏⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵉⵔⵎⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⴱⵚⵉⵏⵉⵢⴰ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⵎⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵔⵉⴽⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JR35_4","025_35_4","JER","35","4","4","ⵉⵡⵢⴻⵖ ⵜⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴰⵢⵜ ⵏ ⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵊⴷⴰⵍⵢⴰ, ⴰⵔⵢⴰⵣ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵅⵅⴰⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⴻⵅⵅⴰⵎ ⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵜⵉⵡⴰ ⵉ ⵡⴻⵅⵅⴰⵎ ⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⵍⵓⵎ, ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR35_5","025_35_5","JER","35","5","5","ⵏⴻⵛⵛ ⵙⵙⴰⵔⵙⴻⵖ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⴱⵉⵏⵓ ⴷ ⵍⴽⵉⵙⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵔⵉⴽⴰⴱ ⵓⵛⴰ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: ‘ⵙⵡⴻⵎ ⴱⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("JR35_6","025_35_6","JER","35","6","6","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⵙⴻⵙⵙ ⵛⴰ ⴱⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⵉⵡⴻⵚⵚⴰ ⴰⵏⴻⵖ, ⵉⵏⵏⴰ: ⴽⴻⵏⵏⵉⵡ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵜⵙⴻⵙⵙⴻⵎ ⴱⵉⵏⵓ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⴰⵍ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR35_7","025_35_7","JER","35","7","7","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⴱⵏⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵉⵖ ⴰⴷ ⵜⵣⴰⵔⵄⴻⵎ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵉⵖ ⴰⴷ ⵜⴻⵥⵥⵓⵎ ⵜⴰⵣⴰⵢⴰⵔⵜ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵉⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⴽⴽⴻⵎ ⵜⴻⴷⴷⴰⵔⴻⵎ ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵓⵙⵙⴰⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵉ ⵖⴰ ⵜⵣⴻⴷⵖⴻⵎ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR35_8","025_35_8","JER","35","8","8","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⴻⵚⵚⴰ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏⵙⴻⵙⵙ ⴱⵉⵏⵓ ⵎⴰⵔⵔⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵖ ⴷ ⵢⴻⵙⵙⵉⵜⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("JR35_9","025_35_9","JER","35","9","9","ⵓ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏⴱⴻⵏⵏⵉ ⵜⵓⴷⵔⵉⵏ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ. ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵏⵉⵖ ⵉⵢⵢⴰⵔ ⵏⵉⵖ ⵣⵣⴰⵔⵉⵄⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JR35_10","025_35_10","JER","35","10","10","ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ. ⴰⵎⵎⵓ ⵉ ⵏⴻⵙⵍⴰ ⵓ ⵏⴻⴳⴳⴰ ⵄⵍⴰⵃⵚⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⴻⵚⵚⴰ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵢⵓⵏⴰⴷⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JR35_11","025_35_11","JER","35","11","11","ⵓⵎⵉ ⵎⴰⵛⴰ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⴳⴻⵄⵄⴻⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵏⵏⴰ: ⴰⵙⴻⵎ-ⴷⴷ, ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴰⵔⴰⵎ! ⵙ ⵓⵢⴻⵏⵏⵉ ⵉ ⵏⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR35_12","025_35_12","JER","35","12","12","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR35_13","025_35_13","JER","35","13","13","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵓⵢⵓⵔ, ⵉⵏⵉ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵙ ⵓⵜⴻⵙⵍⵉ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ?’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR35_14","025_35_14","JER","35","14","14","ⴰⵡⴰⵍⴻⵏ ⵏ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⵉⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ, ⴰⵇⴰ ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ-ⴷⴷ, ⵎⴰⵖⴰⵔ ⴰⵍ ⴰⵙⵙ-ⴰ ⵡⴰⵔ ⵙⵡⵉⵏ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⵖⴰⵔ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵡⴰⵀ ⵄⴰⴷ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴻⵙⵍⵉⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JR35_15","025_35_15","JER","35","15","15","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ⵄⴰⴷ ⵣⵉⵛ ⵙⴻⴽⴽⴻⵖ ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉⵏ: ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵅⴻⵏⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ ⵓ ⴳⴳⴻⵎ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵓ ⵡⴰⵔ ⵜⵔⴰⴷⴷⴰⴼⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ, ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵡⵛⵉⵖ ⵓ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵡⵛⵉⵎ ⴰⵎⴻⵣⵣⵓⵖ ⵓ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⵙⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR35_16","025_35_16","JER","35","16","16","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⵙⵙⵇⴻⴼⵍⴻⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏⵏⵉ ⵜⴻⵏ ⵢⵓⵎⵓⵔ, ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⵉⵙⵍⵉ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR35_17","025_35_17","JER","35","17","17","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⵢⴻⵖ ⵅ ⵢⴰⵀⵓⴷⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵏⵏⵉⵖ, ⵎⵉⵏⵣⵉ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ, ⵓⵛⴰ ⵍⴰⵖⵉⵖ ⴰⵙⴻⵏ ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⴰⵔⵔⵉⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR35_18","025_35_18","JER","35","18","18","ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵔⵉⴽⴰⴱ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵓⵎⵉ ⵜⴻⵙⵍⵉⵎ ⵖⴰⵔ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵢⵓⵏⴰⴷⴰⴱ ⵓⵛⴰ ⵜⴻⵃⴹⴰⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵓ ⵜⴻⴳⴳⵉⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("JR35_19","025_35_19","JER","35","19","19","ⵅ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵉ ⵢⵓⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⵔⵉⴽⴰⴱ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⴱⴻⴷⴷⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("JR36_1","025_36_1","JER","36","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵡⴰⵏⵉⵜⴰ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR36_2","025_36_2","JER","36","2","2","“ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵓⵛⴰ ⴰⵔⵉ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵖⴰⵔⴻⴽ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵉⵙⵔⴰⵉⵍ ⵓ ⵅ ⵢⴰⵀⵓⴷⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⴷ ⵖⴰⵔⴻⴽ ⵙⵙⵉⵡⵍⴻⵖ, ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵛⵉⵢⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR36_3","025_36_3","JER","36","3","3","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵙⵍⴻⵏ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵏⵉ ⵅⵙⴻⵖ ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⴰⴷ ⵜⵓⴱⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵖⴼⴰⵔⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴷ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR36_4","025_36_4","JER","36","4","4","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉⵔⵎⵉⵢⴰ ⵅ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵓⵛⴰ ⵢⵓⵔⴰ ⴱⴰⵔⵓⵅ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR36_5","025_36_5","JER","36","5","5","ⵢⵓⵎⵓⵔ ⵉⵔⵎⵉⵢⴰ ⵉ ⴱⴰⵔⵓⵅ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⵖ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR36_6","025_36_6","JER","36","6","6","ⴰⴷⴻⴼ-ⴷⴷ ⵛⴻⴽ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵖⴰⵔ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏⵏⵉ ⵜⵓⵔⵉⴷ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵥⵓⵎⵎⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵜⵖⴰⵔⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR36_7","025_36_7","JER","36","7","7","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵢⴰⴼ ⵜⵓⵜⵔⴰ ⵏⵙⴻⵏ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⴰⴷ ⵜⵓⴱⴻⵏ ⵏⵉⵜⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵖⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵢⴻⴵⴰ ⵡⴻⵖⴹⴰⴱ ⴷ ⵡⴻⵙⵄⴰⵔ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵉ ⵍⴳⴻⵏⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR36_8","025_36_8","JER","36","8","8","ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵓⵛⴰ ⵉⵖⵔⴰ-ⴷⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR36_9","025_36_9","JER","36","9","9","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR36_10","025_36_10","JER","36","10","10","ⵉⵖⵔⴰ-ⴷⴷ ⴱⴰⵔⵓⵅ ⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵔⵎⵉⵢⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵊⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⴰⵎⴰⵔⵉⵔ, ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵙⴻⵏⵏⴻⵊ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵊⴷⵉⴷ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR36_11","025_36_11","JER","36","11","11","ⵓⵎⵉ ⵎⵉⵅⴰ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵊⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵉⵙⵍⴰ ⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR36_12","025_36_12","JER","36","12","12","ⵉⵀⵡⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵓⵎⴰⵔⵉⵔ. ⵅⵣⴰⵔ, ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ: ⴰⵍⵉⵛⴰⵎⴰⵄ, ⴰⵎⴰⵔⵉⵔ, ⴷⴰⵍⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎⵄⵉⵢⴰ, ⵉⵍ-ⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴽⴱⵓⵔ, ⵊⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⴰⵏⵢⴰ, ⵓ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JR36_13","025_36_13","JER","36","13","13","ⵎⵉⵅⴰ-ⵢⴰⵀⵓ ⵉⵄⴰⵡⴻⴷ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵍⴰ ⵓⵎⵉ ⴷⴷ-ⵉⵖⵔⴰ ⴱⴰⵔⵓⵅ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JR36_14","025_36_14","JER","36","14","14","ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵢⴰⵀⵓⴷⵉ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⴰⵎⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴽⵓⵛⵉ, ⵖⴰⵔ ⴱⴰⵔⵓⵅ, ⵏⵏⴰⵏ: “ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⴻⵖⵔⵉⴷ ⵅ ⵍⴳⴻⵏⵙ, ⴽⵙⵉ ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⵙ-ⴷⴷ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⵙⵉ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⵉ ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR36_15","025_36_15","JER","36","15","15","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵇⵇⵉⵎ, ⵜⵖⴰⵔⴻⴷ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵅⴰⵏⴻⵖ!” ⵅⴻⵏⵏⵉ ⵉⵖⵔⴰ ⵜ ⴱⴰⵔⵓⵅ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR36_16","025_36_16","JER","36","16","16","ⵓⵎⵉ ⵙⵍⵉⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ, ⵅⵣⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⵉ ⴱⴰⵔⵓⵅ: “ⵏⵉⵛⴰⵏ ⴰⴷ ⵏⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JR36_17","025_36_17","JER","36","17","17","ⵏⵉⵜⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⴱⴰⵔⵓⵅ, ⵏⵏⴰⵏ: “ⵉⵏⵉ ⴰⵏⴻⵖ ⵎⴰⵛⴰ, ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("JR36_18","025_36_18","JER","36","18","18","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⴱⴰⵔⵓⵅ: “ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉ ⵅⴰⴼⵉ ⵉⵖⵔⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵓ ⵏⴻⵛⵛ ⵓⵔⵉⵖ ⵜⴻⵏ ⵙ ⵙⵙⵎⴻⵅ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR36_19","025_36_19","JER","36","19","19","ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉ ⴱⴰⵔⵓⵅ: “ⵓⵢⵓⵔ, ⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵉⵔⵎⵉⵢⴰ! ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵙⴻⵏ ⵎⴰⵏⵉ ⵜⴻⴵⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR36_20","025_36_20","JER","36","20","20","ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵍⴻⵎⵔⴰⵃ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵅⴻⵎⵎⵍⴻⵏ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵉⵍⵉⵛⴰⵎⴰⵄ, ⴰⵎⴰⵔⵉⵔ, ⵓ ⵏⵉⵜⵏⵉ ⵃⴰⵊⴰⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JR36_21","025_36_21","JER","36","21","21","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ. ⵡⴰⵏⵉⵜⴰ ⵢⵉⵡⵉ ⵜ ⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴰⵍⵉⵛⴰⵎⴰⵄ, ⴰⵎⴰⵔⵉⵔ, ⵓⵛⴰ ⵉⵖⵔⴰ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵢⴰⵀⵓⴷⵉ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⵉ ⴷⴷ-ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JR36_22","025_36_22","JER","36","22","22","ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴰⴳⴰⵔⵙⵜ, ⵜⵓⵖⴰ ⴷ ⴰⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ. ⵣⵣⴰⵜⴻⵙ ⵜⴰⵔⴻⵇⵇ ⴷⵉⵏⵏⵉ ⵜⵎⴻⵙⵙⵉ ⵅ ⵜⵎⴻⵊⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR36_23","025_36_23","JER","36","23","23","ⵍⴰⵎⵉ ⵉⵖⵔⴰ ⵢⴰⵀⵓⴷⵉ ⵜⵍⴰⵜⴰ ⵏⵉⵖ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴻⵡⴹⴰⵏ, ⵉⵇⴻⵙⵙ ⵉ-ⵜⴻⵏ ⵓⵊⴻⴵⵉⴷ ⵙ ⵍⵎⵓⵙⵙ ⵏ ⵓⵎⴰⵔⵉⵔ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵅ ⵍⵎⴻⵊⵎⴰⵔ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵅ ⵍⵎⴻⵊⵎⴰⵔ ⵜⴻⵛⵛⴰ ⵎⴰⵔⵔⴰ ⴰⴷⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JR36_24","025_36_24","JER","36","24","24","ⴰⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⵏⵏⵅⴻⵍⵄⴻⵏ ⵓ ⵡⴰⵔ ⵛⴰⵔⵔⴳⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR36_25","025_36_25","JER","36","25","25","ⵜⵜⴰⵔⴻⵏ ⵉⵍ-ⵏⴰⵜⴰⵏ ⴷ ⴷⴰⵍⴰⵢⴰ ⴷ ⵊⴰⵎⴰⵔⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵙⵙⴻⵛⵎⵉⴹ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("JR36_26","025_36_26","JER","36","26","26","ⵄⴰⴷ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⴰⵔⵃⴰⵎⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉ ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⵔⴰⵢⵉⵍ, ⵓ ⵉ ⵛⴰⵍⴰⵎⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⴷⵉⵢⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵎⴰⵔⵉⵔ ⴱⴰⵔⵓⵅ ⴷ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⴷ ⵉⵎⴻⵃⴱⴰⵙ. ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR36_27","025_36_27","JER","36","27","27","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵓⵊⴻⴵⵉⴷ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵢⵓⵔⴰ ⴱⴰⵔⵓⵅ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR36_28","025_36_28","JER","36","28","28","“ⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓ ⴰⵔⵉ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("JR36_29","025_36_29","JER","36","29","29","ⵓⵛⴰ ⵉⵏⵉ ⵉ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵛⴻⴽ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵜⴻⵏⵏⵉⴷ: ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰⵢⴻⵙ ⵜⵓⵔⵉⴷ, ⵜⴻⵏⵏⵉⴷ: ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⴷ ⵉⵅⴰⵔⵔⴻⴱ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵎⵃⴰ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ?’ ");
INSERT INTO rift_vpl VALUES ("JR36_30","025_36_30","JER","36","30","30","‘ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵅ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ: ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵉ ⵍⴻⵃⵎⵓ ⵏ ⵓⵣⵉⵍ ⵓ ⵉ ⵜⴻⵙⵎⴻⴹ ⵏ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JR36_31","025_36_31","JER","36","31","31","ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵅⴻⵍⴼⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⵓⵍⴰ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵖⴻⴹⵍⴻⵖ ⵅⴰⵙⴻⵏ, ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵅ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵉ ⴷ ⴰⵙⴻⵏ ⵏⵏⵉⵖ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR36_32","025_36_32","JER","36","32","32","ⵉⴽⵙⵉ ⵉⵔⵎⵉⵢⴰ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⵓⵎⴰⵔⵉⵔ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ. ⵡⴰⵏⵉⵜⴰ ⵢⵓⵔⴰ ⵅⴰⵙ, ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ, ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵜⵜⵡⴰⵔⵏⵉⵏ ⵄⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⴻⵏ ⵢⵓⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR37_1","025_37_1","JER","37","1","1","ⵉⴷⵡⴻⵍ ⵚⵉⴷⵇⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴽⵓⵏ-ⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR37_2","025_37_2","JER","37","2","2","ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵙⵍⵉ ⵛⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵡⴰⵏⵉⵜⴰ ⵓⵍⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR37_3","025_37_3","JER","37","3","3","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵢⴰⵀⵓⵅⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⴰⵎⵢⴰ, ⴷ ⵚⴰⴼⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴰⵙⵉⵢⴰ, ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵏⵉⵏ: “ⵥⴰⴵ ⵅⴰⵏⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("JR37_4","025_37_4","JER","37","4","4","ⵉⵔⵎⵉⵢⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴷⴻⴼ ⵓ ⴰⴷ ⵉⴼⴼⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜ ⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵍⵃⴻⴱⵙ. ");
INSERT INTO rift_vpl VALUES ("JR37_5","025_37_5","JER","37","5","5","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴼⵉⵔⵄⵓⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵓⵎⵉ ⵙⵍⵉⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR37_6","025_37_6","JER","37","6","6","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR37_7","025_37_7","JER","37","7","7","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ: ⵅⵣⴰⵔ, ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴼⵉⵔⵄⵓⵏ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⴼⵓⵙ, ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵎⵉⵚⵔⴰ! ");
INSERT INTO rift_vpl VALUES ("JR37_8","025_37_8","JER","37","8","8","ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵟⵟⴼⴻⵏ, ⴰⴷ ⴰⵙ ⵇⵇⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JR37_9","025_37_9","JER","37","9","9","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴰⵔ ⵛⴻⵎⵎⵜⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵅⵎⵉ ⵖⴰ ⵜⵉⵏⵉⵎ: ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵅⴰⵏⴻⵖ ⴰⴳⴳⵯⴻⵊⴻⵏ, ⴰⴷ ⵓⵢⵓⵔⴻⵏ!, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR37_10","025_37_10","JER","37","10","10","ⵄⴰⴷ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵍⴱⴻⵎ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵇⵇⵉⵎⴻⵏ ⵎⵖⵉⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵢⴻⵣⵎⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵇⵇⴷⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR37_11","025_37_11","JER","37","11","11","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴼⵉⵔⵄⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("JR37_12","025_37_12","JER","37","12","12","ⵉⴼⴼⴻⵖ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR37_13","025_37_13","JER","37","13","13","ⵍⴰⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⴰⵎⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⴰⵏⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴰⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⴷ ⵖⴰⵔ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("JR37_14","025_37_14","JER","37","14","14","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵉⵔⵎⵉⵢⴰ: “ⵎⴰⵏ ⴰⵢⴰ ⵎⵖⵉⵔ ⴷ ⴰⵅⴰⵔⵔⵉⵇ! ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ!” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵙⵍⵉ ⵛⴰ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵢⴰⵔⵉⵢⵢⴰ ⵉⵔⵎⵉⵢⴰ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JR37_15","025_37_15","JER","37","15","15","ⴼⴼⵓⴳⵎⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⴰⵟⵟⴰⵙ ⵅ ⵉⵔⵎⵉⵢⴰ, ⵡⵜⵉⵏ ⵜ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵔⵉⵔ ⵢⵓⵏⴰⵜⴰⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴰⵔⵔⵉⵏ ⵜⵜ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JR37_16","025_37_16","JER","37","16","16","ⴰⵎⵎⵓ ⴷⴷ-ⵉⵡⴹⴰ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵉⵎⴻⵃⴱⴰⵙ ⵓ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵃⴱⴻⵙ. ⴷⵉⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵉⵔⵎⵉⵢⴰ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR37_17","025_37_17","JER","37","17","17","ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵉⵊⵊⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵓⵊⴻⴵⵉⴷ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵣⴻⵄⵎⴰ ⵛⴰ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ?” ⵉⵏⵏⴰ ⴰⵙ ⵉⵔⵎⵉⵢⴰ: “ⴰⵇⴰ-ⵜ ⴷⵉⵏ!” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵛⴻⴽ ⴰⴷ ⵜⴻⵡⴹⵉⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR37_18","025_37_18","JER","37","18","18","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ: “ⵎⴰⵏ ⵍⵄⵉⴱ ⵉ ⴷⴰⵢⴻⴽ ⴳⴳⵉⵖ ⵏⵉⵖ ⴷⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵏⵉⵖ ⴷⵉ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵢⵉ ⵜⴻⵏⴹⴰⵔⴻⵎ ⴷⵉ ⵍⴻⵃⴱⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JR37_19","025_37_19","JER","37","19","19","ⵎⴰⵏⵉ ⴵⴰⵏ ⵍⴻⵅⵅⵓ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵇⵇⴰⵔⴻⵏ: ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⴹⵉⴷⴷ ⵏⵡⴻⵎ ⵓ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("JR37_20","025_37_20","JER","37","20","20","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⵍ ⵎⴰⵛⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ! ⵉⵍⵉ ⴰⴷ ⵜⴰⴼ ⵜⵓⵜⵔⴰ ⵉⵏⵓ ⴷ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ! ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴰⵢⵉ ⴰⵔⵔⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴰⵔⵉⵔ ⵢⵓⵏⴰⵜⴰⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵜⵜⵎⴻⵜⵜⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR37_21","025_37_21","JER","37","21","21","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵉⵔⵎⵉⵢⴰ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵙ ⴽⵓⵍ ⴰⵙⵙ ⵉⵊⵊ ⵏ ⵡⴻⵏⴳⵓⵔ ⵏ ⵡⴻⵖⵔⵓⵎ ⵣⵉ ⵣⵣⴻⵏⵇⴻⵜ ⵏ ⵉⵅⴱⴰⵢⵣⵉⵢⵢⴻⵏ ⴰⵍⴰⵎⵉ ⵉⵇⴹⴰ ⵡⴻⵖⵔⵓⵎ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵉⵔⵎⵉⵢⴰ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR38_1","025_38_1","JER","38","1","1","ⵍⴰⵎⵉ ⵛⴰⴼⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵏ, ⴷ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵛⵃⵓⵔ, ⴷ ⵢⵓⵅⴰⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⴰⵎⵢⴰ, ⴷ ⴼⴰⵛⵃⵓⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⴽⵉⵢⴰ, ⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵔⵎⵉⵢⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵓⵎⵉ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR38_2","025_38_2","JER","38","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵙ ⵙⵙⵉⴼ, ⵙ ⵍⴰⵥ ⵏⵉⵖ ⵙ ⵟⵟⴰⵄⵓⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⴰⴽⵉⴷⴻⵙ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⴰⵎ ⵜⴽⴻⵛⵛⴰⴹⵜ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ!’. ");
INSERT INTO rift_vpl VALUES ("JR38_3","025_38_3","JER","38","3","3","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵜ ⵉⵟⵟⴻⴼ!’”, ");
INSERT INTO rift_vpl VALUES ("JR38_4","025_38_4","JER","38","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵡⴻⵔⵢⴰⵣ-ⴰ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⴼⵛⴰⵍ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵄⴰⴷ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓⵍⴰ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓⵎⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵎⴰⵖⴰⵔ ⴰⵔⵢⴰⵣ-ⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⵛⴰ ⵍⴻⵀⵏⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵎⴰⵛⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵍⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JR38_5","025_38_5","JER","38","5","5","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ: “ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵡⴻⵎ ⵉⴳⴳ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("JR38_6","025_38_6","JER","38","6","6","ⵟⵟⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵔⵎⵉⵢⴰ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜ ⴷⴻⴳ ⵡⴰⵏⵓ ⵏ ⵎⵎⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵍⴽⵉⵢⴰ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ. ⵙⴻⵢⵢⴱⴻⵏ ⵉⵔⵎⵉⵢⴰ ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ. ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵡⴰⵎⴰⵏ ⴷⴻⴳ ⵡⴰⵏⵓ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⴰⴱⴰⵔⵢⵓⴹ ⵓⵛⴰ ⵉⵖⴹⴻⵙ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵓⴱⴰⵔⵢⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JR38_7","025_38_7","JER","38","7","7","ⵓⵎⵉ ⵉⵙⵍⴰ ⵄⴰⴱⴷ-ⵎⴰⵍⵉⴽ, ⴰⴽⵓⵛⵉ, ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⵇⴰ ⵏⴹⴰⵔⴻⵏ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵡⴰⵏⵓ, ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("JR38_8","025_38_8","JER","38","8","8","ⵉⴼⴼⴻⵖ ⵄⴰⴱⴷ-ⵎⴰⵍⵉⴽ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR38_9","025_38_9","JER","38","9","9","“ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵊⴻⴵⵉⴷ, ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⴳⴳⵉⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵡⴻⵏⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴰⵏⵓ. ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏⵏⵉ ⵉⵎⵎⴻⵜ ⵙ ⵍⴰⵥ, ⵎⴰⵖⴰⵔ ⵄⴰⴷ ⵡⴰⵍⵓ ⴰⵖⵔⵓⵎ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR38_10","025_38_10","JER","38","10","10","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵄⴰⴱⴷ-ⵎⴰⵍⵉⴽ ⴰⴽⵓⵛⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ, ⵉⵏⵏⴰ: “ⴽⵙⵉ ⵙⵙⴻⵏⵏⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⴳⴻⵄⵄⴻⴷ ⴰⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵣⴻⴳ ⵡⴰⵏⵓ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR38_11","025_38_11","JER","38","11","11","ⵄⴰⴱⴷ-ⵎⴰⵍⵉⴽ ⵉⴽⵙⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵍ ⵡⴰⴷⴷⴰⵢ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ. ⵙⵙⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵉⴽⴻⵜⵜⴰⵏⴻⵏ ⵉⵇⴷⵉⵎⴻⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵉⵇⵇⴰⵔⵚⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵀⵡⴰ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR38_12","025_38_12","JER","38","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵄⴰⴱⴷ-ⵎⴰⵍⵉⴽ ⴰⴽⵓⵛⵉ ⵉ ⵉⵔⵎⵉⵢⴰ: “ⴻⴳⴳ ⵉⴽⴻⵜⵜⴰⵏⴻⵏ ⵉⵇⴷⵉⵎⴻⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵉⵇⵇⴰⵔⵚⴻⵏ ⵙⴰⴷⵓ ⵜⵉⴷⴷⵉⵖⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴻⴳⴳ ⵉⵙⴻⵖⵡⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ!” ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⵜ ⵉⴳⴳⴰ ⵉⵔⵎⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR38_13","025_38_13","JER","38","13","13","ⵊⴻⴱⴷⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵉⵔⵎⵉⵢⴰ ⵙ ⵉⵙⴻⵖⵡⴰⵏ ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵏⵓ. ⵎⴰⵛⴰ ⵉⵔⵎⵉⵢⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR38_14","025_38_14","JER","38","14","14","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵛⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵊⵊⴰ ⴰⴷ ⴰⵙ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴰⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵔⵎⵉⵢⴰ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵇⵙⵉⵖ ⵅ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⵡⴰⵔ ⵅⴰⴼⵉ ⵜⵜ ⵜⵜⴻⴼⴼⴰⵔ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("JR38_15","025_38_15","JER","38","15","15","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵔⵎⵉⵢⴰ ⵅ ⵚⵉⴷⵇⵉⵢⴰ: “ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵛⴻⴽ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵏⴻⵇⵇⴻⴷ ⵣⴻⵄⵎⴰ? ⵓ ⵎⴰⵍⴰ ⵡⵛⵉⵖ ⴰⵛ ⵉⵊⵊ ⵏ ⴰⵔⵔⴰⵢ, ⵛⴻⴽ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜᵉⵜⵜⴻⵙⵍⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("JR38_16","025_38_16","JER","38","16","16","ⵅⴰⵙ ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵉ ⵉⵔⵎⵉⵢⴰ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⵜⵓⴷⴰⵔⵜ-ⴰ: ‘ⵓⵛⵜ ⵅⴰⴼⵉ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵏⵖⵉⵖ ⵛⴻⴽ ⵏⵉⵖ ⵎⴰⵍⴰ ⵡⵛⵉⵖ ⵛⴻⴽ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ!’” ");
INSERT INTO rift_vpl VALUES ("JR38_17","025_38_17","JER","38","17","17","ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ ⵉ ⵚⵉⴷⵇⵉⵢⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵓⵛⴰ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴰⴹ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵡⴰⵀ ⵛⴻⴽ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR38_18","025_38_18","JER","38","18","18","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴼⴼⵉⵖⴻⴷ ⵛⴰ ⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⵛⴻⴽ ⵡⴰⵔ ⵜⵏⴻⵊⵊⵎⴻⴷ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR38_19","025_38_19","JER","38","19","19","ⴰⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ ⵉⵏⵏⴰ ⵉ ⵉⵔⵎⵉⵢⴰ: “ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵢⴻⵄⴷⵓⵏ ⵖⴰⵔ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⵙⵄⴻⴷⴷⵓⵏ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵅⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR38_20","025_38_20","JER","38","20","20","ⵉⵏⵏⴰ ⴰⵙ ⵉⵔⵎⵉⵢⴰ: “ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵛⴻⴽ ⵙⴻⵍⵍⵎⴻⵏ ⵛⴰ. ⵙⴻⵍ ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⵖⴰⵔ ⵍⵃⴰⵍⴹ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ ⵓ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR38_21","025_38_21","JER","38","21","21","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⴳⵉⴷ ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ, ⵅⴻⵏⵏⵉ ⴷ ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵛⴻⵏ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("JR38_22","025_38_22","JER","38","22","22","‘ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏⵜ ⵖⴰⵔ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵅⵣⴰⵔ, ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⵉⵏⵉⵏⵜ: ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⴽ-ⴷ ⵜⵓⵖⴰ ⵜⴻⴷⴷⴰⵔⴻⴷ ⴷⵉ ⵍⴻⵀⵏⴰ, ⴰⵇⴰ ⵖⴷⴰⵔⴻⵏ ⵛⴻⴽ ⵓ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴰⴽ, ⵏⵏⵓⵖⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⴱⴰⵔⵢⵓⴹ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("JR38_23","025_38_23","JER","38","23","23","ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵏⴻⵊⵊⵎⴻⴷ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵟⵟⴼⴻⴷ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR38_24","025_38_24","JER","38","24","24","ⵅⴻⵏⵏⵉ ⵚⵉⴷⵇⵉⵢⴰ ⵉⵏⵏⴰ ⵉ ⵉⵔⵎⵉⵢⴰ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵙⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⵎⵎⴻⵜⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JR38_25","025_38_25","JER","38","25","25","ⵎⴰⵍⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵙⵍⵉⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⴻⴽ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: ‘ⵉⵏⵉ ⴰⵏⴻⵖ ⵎⵉⵏ ⵜⴻⵏⵏⵉⴷ ⵉ ⵓⵊⴻⴵⵉⴷ! ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵜⴻⴼⴼⴰⵔ ⵡⴰⵍⵓ, ⵏⵉⵖ ⴰⵇⴰ ⴰⴷ ⵛⴻⴽ ⵏⴻⵏⵏⴻⵖ: ⵎⵉⵏ ⵅⴰⵙ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ?’ ");
INSERT INTO rift_vpl VALUES ("JR38_26","025_38_26","JER","38","26","26","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⵏⴻⵛⵛ ⵡⴹⵉⵖ ⵙ ⵍⵇⴻⴷⴷ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴰⵢⵉ ⴰⵔⵔⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵏⴰⵜⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏⵏⵉ ⵎⵎⵜⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("JR38_27","025_38_27","JER","38","27","27","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ, ⵉⵃⴰⵊⴰ ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ. ⵅⴰⵙ ⵓⵛⴰ ⵊⵊⵉⵏ ⵜ ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵍⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR38_28","025_38_28","JER","38","28","28","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵉⵔⵎⵉⵢⴰ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ ⴰⵍ ⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵓⵔⵛⴰⵍⵉⵎ, ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⵄⴰⴷ ⴷⵉⵏ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR39_1","025_39_1","JER","39","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JR39_2","025_39_2","JER","39","2","2","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵚⵉⴷⵇⵉⵢⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵓⵢⵓⵔ, ⵡⵜⵉⵏ ⵉⴱⵓⵅⵅⴰⵛ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR39_3","025_39_3","JER","39","3","3","ⵅⴰⵙ ⵓⵛⴰ ⵓⴷⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵎⵎⴰⵙ: ⵏⴰⵔⵊⴰⵍ-ⵛⴰⵔⴰⵚⴰⵔ, ⵛⴰⵎⵊⴰⵔ-ⵏⴰⴱⵓ, ⵙⴰⵔⵙⴰⵅⵉⵎ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵏⴰⵔⵊⴰⵍ-ⵛⴰⵔⵚⴰⵔ, ⴰⵣⴻⴵⵉⴼ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⵙⴻⵃⵃⴰⵔⵜ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵏⵏⴻⵖⵏⵉ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR39_4","025_39_4","JER","39","4","4","ⵍⴰⵎⵉ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵥⵔⵉⵏ ⵜⴻⵏ, ⴰⵔⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ, ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⴵⵉⵍⴻⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⵉⵜⵏⵉ ⴽⴽⵉⵏ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵖⴰⵔ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JR39_5","025_39_5","JER","39","5","5","ⴹⴼⴰⵔⴻⵏ ⵜⴻⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵃⴰⵔⵜⴻⵏ ⵅ ⵚⵉⴷⵇⵉⵢⴰ ⴷⵉ ⵍⴻⵡⴹⴰⵜ ⵏ ⴰⵔⵉⵃⴰ. ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵜ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵔⵉⴱⵍⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎⴰⵜ, ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵃⴽⴻⵎ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR39_6","025_39_6","JER","39","6","6","ⵉⵊⵊⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⵉⴷⵇⵉⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷⵉ ⵔⵉⴱⵍⴰ. ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵖⴰⵔⵚ ⴰⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR39_7","025_39_7","JER","39","7","7","ⵉⵙⵙⴷⴰⵔⵖⴻⵍ ⵏⴻⵜⵜⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵚⵉⴷⵇⵉⵢⴰ ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⵉ-ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵃⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR39_8","025_39_8","JER","39","8","8","ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⵍⵥⵉⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR39_9","025_39_9","JER","39","9","9","ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵄⴷⵓⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵏⴰⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴷⵉ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JR39_10","025_39_10","JER","39","10","10","ⵣⴻⴳ ⵉⵎⴻⵣⵍⴰⴹ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵡⴰⵍⵓ, ⵉⵊⵊⴰ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴷ ⵉⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR39_11","025_39_11","JER","39","11","11","ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵅ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR39_12","025_39_12","JER","39","12","12","“ⴰⵡⵢⵉ ⵜ-ⵉ-ⴷⴷ, ⵃⴹⴰ ⵅⴰⵙ. ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴻⴳⴳ ⴰⴽⵉⴷⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵢⵉⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR39_13","025_39_13","JER","39","13","13","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵛⴰ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵏⴻⴱⵓⵛⴰⵣⴱⴰⵏ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴷ ⵏⴰⵔⵊⴰⵍ-ⵛⴰⵔⴰⵚⴰⵔ, ⴰⵣⴻⴵⵉⴼ ⵏ ⴰⵢⵜ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ, ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR39_14","025_39_14","JER","39","14","14","ⵊⵊⵉⵏ ⵜⴻⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⵊⴰⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JR39_15","025_39_15","JER","39","15","15","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR39_16","025_39_16","JER","39","16","16","“ⵔⵓⵃ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵄⴰⴱⴷ-ⵎⴰⵍⵉⴽ, ⴰⴽⵓⵛⵉ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⵉ ⵍⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵍⵅⴰⵔ, ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JR39_17","025_39_17","JER","39","17","17","ⵎⴰⵛⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵡⵛⵉⴷ ⵛⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵣⵉ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR39_18","025_39_18","JER","39","18","18","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ. ⵡⴰⵔ ⵛⵛⴰⵜⴻⵏ ⵙ ⵙⵙⵉⴼ. ⴰⴷ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅⴰⴼⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR40_1","025_40_1","JER","40","1","1","ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵢⵉⵡⵉ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵣⵉ ⵔⴰⵎⴰ. ⵓⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵡⵢⴻⵏ, ⵉⵜⵜⵡⴰⵛⴰⵔⴼ ⵏⴻⵜⵜⴰ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⴷⴷⵀⴻⵏ ⴷ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR40_2","025_40_2","JER","40","2","2","ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉ ⴷⴷ-ⵢⵉⵡⵉ ⵉⵔⵎⵉⵢⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⵖⴰⵔ-ⴰ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ");
INSERT INTO rift_vpl VALUES ("JR40_3","025_40_3","JER","40","3","3","ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵏⵏⴰ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⴹⴰⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵍⵇⴻⴼ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR40_4","025_40_4","JER","40","4","4","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴼⴻⵙⵢⴻⵖ ⴰⵙⵙ-ⴰ ⵙⵙⵏⴰⵙⴻⵍ ⵏⵏⵉ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ⵎⴰⵍⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⴽⵉⴷⵉ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⵙ-ⴷⴷ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵖ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵉ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⴻⵊⵊ ⵉ-ⵜ ⵅⴻⵏⵏⵉ. ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵣⵣⴰⵜⴻⴽ. ⵛⴻⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵛ ⵉⵜⵜⵖⵉⵍ ⴷ ⵎⵍⵉⵃ ⴷ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("JR40_5","025_40_5","JER","40","5","5","ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵉⵄⵇⵉⴱ, ⵢⴰⵔⵏⵉ ⵉⵏⵏⴰ: “ⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵇⵇⵉⵎ ⵖⴰⵔⴻⵙ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ⵏⵉⵖ ⵓⵢⵓⵔ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⵔⵉⴷ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵔⴰⵃⴻⴷ.” ⵅⴰⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵍⴻⵄⵡⴻⵍⵜ ⵉ ⵓⵎⵓⴷⴷⵓ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵢⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JR40_6","025_40_6","JER","40","6","6","ⵢⵓⵢⵓⵔ ⵉⵔⵎⵉⵢⴰ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵖⴰⵔ ⵎⵉⵚⴼⴰⵜ. ⵉⵇⵇⵉⵎ ⵉⵜⵜⵏⵓⵙⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR40_7","025_40_7","JER","40","7","7","ⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ, ⵙⵍⵉⵏ ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⴳⴳⴰ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵉⴳⴳⴰ ⵉ-ⵜ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵅ ⵉⵎⴻⵣⵍⴰⴹ ⵇⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("JR40_8","025_40_8","JER","40","8","8","ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ ⴷⵉ ⵎⵉⵚⴼⴰⵜ: ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵢⵓⵃⴰⵏⴰⵏ ⴷ ⵢⵓⵏⴰⵜⴰⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵇⴰⵔⵉⵃⴰ, ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵜⴰⵏⵃⵓⵎⴰⵜ, ⴰⵔⵏⵉ ⵅⴰⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵄⵉⴼⴰ, ⴰⵏⵟⵓⴼⴰⵜⵉ, ⴷ ⵢⴰⵣⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵓⵎⴰⵄⴽⵉ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR40_9","025_40_9","JER","40","9","9","ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵉⵊⵊⵓⴵ ⴰⵙⴻⵏ ⵓ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⵎ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("JR40_10","025_40_10","JER","40","10","10","ⵓⵛⴰ ⵏⴻⵛⵛ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵣⴻⴷⴷⵖⴻⵖ ⴷⵉ ⵎⵉⵚⴼⴰⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⴷ ⴰⵎⴻⵏⴷⵓⴱ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵎⵓⵏⴻⵎ ⴱⵉⵏⵓ ⴷ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ ⴷ ⵣⵣⴻⵛⵜ, ⵓⵛⴰ ⴳⴳⴻⵎ ⴰⵢⴰ ⴷⴻⴳ ⵉⵇⴷⵉⵃⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵜᵉⵟⵟⴼⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR40_11","025_40_11","JER","40","11","11","ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⵓ’ⴰⴱ ⵓ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⴷⵉ ⵉⴷⵓⵎ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵉⵏⵏⴻⵖⵏⵉ, ⵙⵍⵉⵏ ⴰⵇⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵊⵊⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR40_12","025_40_12","JER","40","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵎⴰⵔⵔⴰ ⵡⵓⴷⴰⵢⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵓⵥⵥⵍⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ ⵖⴰⵔ ⵎⵉⵚⴼⴰⵜ. ⵏⵉⵜⵏⵉ ⵙⵙⵎⵓⵏⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⴱⵉⵏⵓ ⴷ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("JR40_13","025_40_13","JER","40","13","13","ⵓⵍⴰ ⴷ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵃⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ ⵖⴰⵔ ⵎⵉⵚⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR40_14","025_40_14","JER","40","14","14","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ, ⴰⵇⴰ ⴱⴰⵄⵍⵉⵙ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⵖ?” ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵢⵓⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR40_15","025_40_15","JER","40","15","15","ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵃⴰ, ⵎⴰⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵊⴰⴷⴰⵍⵢⴰ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⴷⵉ ⵎⵉⵚⴼⴰⵜ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴷⵉⵏ ⵍⴰⵃⴻⵖ ⵓ ⴰⴷ ⵏⵖⴻⵖ ⵉⵙⵎⴰⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ. ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵉⵏⴻⵖ ⵃⴻⴷ ⵓ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉ ⴷⴷ-ⵅⴰⴽ ⵉⵎⵓⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵣⵓⵣⵣⴰⵔⴻⵏ ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("JR40_16","025_40_16","JER","40","16","16","ⵎⴰⵛⴰ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵉⵏⵏⴰ ⵉ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵃⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴰⵢⴰ, ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ ⵅ ⵉⵙⵎⴰⵄⵉⵍ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR41_1","025_41_1","JER","41","1","1","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵉⵍⵉⵛⴰⵎⴰⵄ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵣⵉ ⵍⵡⴰⵛⵓⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⴰⴽⵉⴷⴻⵙ ⵄⴰⴷ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵖⴰⵔ ⵎⵉⵚⴼⴰⵜ. ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ ⵜⵜᵉⵜⵜⴻⵏ ⴷⵉⵏ ⴷⵉ ⵎⵉⵚⴼⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR41_2","025_41_2","JER","41","2","2","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ ⵓⵛⴰ ⵡⵜⵉⵏ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵙ ⵙⵙⵉⴼ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵏⵖⴰ ⵉⵙⵎⴰⵄⵉⵍ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR41_3","025_41_3","JER","41","3","3","ⵉⵏⵖⴰ ⵉⵙⵎⴰⵄⵉⵍ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵉ ⵖⴰⵔⴻⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ ⴷⵉ ⵎⵉⵚⴼⴰⵜ, ⵓⵍⴰ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉⵏ, ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR41_4","025_41_4","JER","41","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵖⴰ ⵊⴰⴷⴰⵍⵢⴰ, ⴰⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵢⴰⵔⴳⵉⴱ ⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("JR41_5","025_41_5","JER","41","5","5","ⵓⵙⵉⵏ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵛⴰⴽⵉⵎ, ⵛⵉⵍⵓ ⴷ ⵙⴰⵎⴰⵔⵢⴰ, ⵜⵎⴻⵏⵢⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵙ ⵜⵉⵎⵉⵔⴰ ⵃⴻⴼⴼⴻⵏⵜ ⴷ ⵡⴻⵔⵔⵓⴹ ⵉⵛⴰⵔⵔⴻⴳ ⴷ ⵉⵅⴻⴱⴱⵉⵛⴻⵏ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵊⵊⴰⵡⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR41_6","025_41_6","JER","41","6","6","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵣⵉ ⵎⵉⵚⴼⴰⵜ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵔⵓ ⴰⵎ ⵉⴳⴳⵓⵔ. ⵓⵎⵉ ⵜⴻⵏ ⵉⵎⵎⴻⵍⵇⴰ, ⵉⵏⵏⴰ: “ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ!” ");
INSERT INTO rift_vpl VALUES ("JR41_7","025_41_7","JER","41","7","7","ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵖⴰⵔⵚ ⴰⵙⴻⵏ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ. ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR41_8","025_41_8","JER","41","8","8","ⵎⴰⵛⴰ ⵜⵜⵡⴰⴼⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵏⵏⴰⵏ ⵉ ⵉⵙⵎⴰⵄⵉⵍ: “ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵏⴻⵇⵇ ⵛⴰ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵍⴻⵄⵡⴻⵍⵜ ⵉⵅⴻⵎⵎⵍⴻⵏ ⵏ ⵉⵔⴷⴻⵏ, ⵉⵎⴻⵏⴷⵉ, ⵣⵣⴻⵛⵜ ⴷ ⵜⴰⵎⵎⴻⵏⵜ.” ⵅⴻⵏⵏⵉ ⵉⵃⵜⴰ ⵅⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵏⵖⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR41_9","025_41_9","JER","41","9","9","ⴰⵏⵓ ⵏⵏⵉ ⴷⵉ ⵉⵏⴹⴰⵔ ⵉⵙⵎⴰⵄⵉⵍ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴰⵜ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵏⵖⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵊⴰⴷⴰⵍⵢⴰ, ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵙⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⴰⵄⵛⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵉⵛⵛⵓⵔ ⵉ-ⵜ ⵙ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR41_10","025_41_10","JER","41","10","10","ⵉⵏⴷⴻⵀ ⵉⵙⵎⴰⵄⵉⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⵣⵉ ⵍⴳⴻⵏⵙ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⵉⵚⴼⴰⵜ, ⴷ ⵉⵎⴻⵃⴱⴰⵙ, ⴰⵇⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴷⵉ ⵎⵉⵚⴼⴰⵜ, ⵉⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ. ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵄⴷⵓ ⵅ ⵍ’ⵓⵔⴷⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR41_11","025_41_11","JER","41","11","11","ⵓⵎⵉ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵀⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵙⵍⵉⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("JR41_12","025_41_12","JER","41","12","12","ⵉⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⴰⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ. ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⵜ ⵖⴰⵔ ⵓⵢⴻⵍⵎⴰⵎ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵖⴰⵔ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR41_13","025_41_13","JER","41","13","13","ⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⵉⵙⵎⴰⵄⵉⵍ, ⵉⵏⵟⴻⵃ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵃⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵖⴰⵔⴻⵙ, ⴼⴰⵔⵃⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR41_14","025_41_14","JER","41","14","14","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⴷⴻⵀ ⵉⵙⵎⴰⵄⵉⵍ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵣⵉ ⵎⵉⵚⴼⴰⵜ, ⵇⴻⵍⴱⴻⵏ, ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵓⵛⴰ ⵄⴷⵓⵏ ⵖⴰⵔ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("JR41_15","025_41_15","JER","41","15","15","ⵉⵙⵎⴰⵄⵉⵍ ⵎⴰⵛⴰ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵢⴰⵔⵡⴻⵍ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵢⵓⵃⴰⵏⴰⵏ ⴰⴽ-ⴷ ⵜⵎⴻⵏⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR41_16","025_41_16","JER","41","16","16","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵢⴰⵃ, ⵏⴻⵜⵜⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵢⵉⵡⵉ ⵏⴻⵜⵜⴰ ⵣⵉ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵣⵉ ⵎⵉⵚⴼⴰⵜ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵖⴰ ⵡⴰⵏⵉⵜⴰ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ: ⴰⵇⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⵄⵇⴻⴱ ⵏⴻⵜⵜⴰ ⵣⵉ ⵊⵉⴱⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR41_17","025_41_17","JER","41","17","17","ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏ ⴽⵉⵎⵀⴰⵏ ⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵏⵏⵉ ⵄⴷⵓⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR41_18","025_41_18","JER","41","18","18","ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵎⴰⵖⴰⵔ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵙⵎⴰⵄⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏⵢⴰ, ⵉⵏⵖⴰ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵍⴱⴰⵛⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR42_1","025_42_1","JER","42","1","1","ⵅⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵢⴰⵃ, ⴷ ⵢⴰⵣⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⵓⵛⴰⵄⵢⴰ, ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR42_2","025_42_2","JER","42","2","2","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵢⴰ: “ⵉⵍⵉ ⴰⴷ ⵢⴰⴼ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵖ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵜⵜⴰⵔ ⴰⵏⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵙ ⴷⵔⵓⵙ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜᵉⵜⵡⴰⵔⵉⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓⵎⵉ ⵖⴰⵔⵏⴻⵖ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR42_3","025_42_3","JER","42","3","3","ⵉⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵛⴻⵏ ⵎⴰⵏ ⴰⴱⵔⵉⴷ ⵉ ⵖⴰ ⵏⴻⴹⴼⴰⵔ ⴷ ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("JR42_4","025_42_4","JER","42","4","4","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ: “ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵜ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍ ⵏⵏⵉ ⵣⵉ ⴷⴷ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵢⴰⵔⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR42_5","025_42_5","JER","42","5","5","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵉ ⵉⵔⵎⵉⵢⴰ: “ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵛⵛⴰⵀⴻⴷ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷ ⴰⵚⴷⵉⵇ ⵊⴰⵔ ⴰⵏⴻⵖ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⴽⵓⵍ ⴰⵡⴰⵍ ⵏⵏⵉ ⴽⵉⴷⴻⴽ ⵖⴰⵔⵏⴻⵖ ⴷⴷ ⵖⴰ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("JR42_6","025_42_6","JER","42","6","6","ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵉⵖ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⴰⴷ ⵏⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉ ⵓⵎⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵏⴻⵙⵙⴻⴽⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵉⵍⵉ ⵎⵍⵉⵃ ⵅⵎⵉ ⵖⴰ ⵏⵙⴻⵍ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR42_7","025_42_7","JER","42","7","7","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR42_8","025_42_8","JER","42","8","8","ⵅⴰⵙ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵏⴻⵜⵜⴰ ⵅ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵢⴰⵃ, ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⴵⴰⵏ, ⵓⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵣⴻⴳ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR42_9","025_42_9","JER","42","9","9","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⵉⵡⴹⴻⵖ ⵜⵓⵜⵔⴰ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("JR42_10","025_42_10","JER","42","10","10","‘ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⴰⵎⵎⵓ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵓ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵀⴻⴷⴷⵎⴻⵖ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⵥⵓⵖ ⵓ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵇⴻⵍⵄⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵏⴻⴷⴷⵎⴻⵖ ⵅ ⵍⵖⴰⵔ ⵉ ⴷⴰⵢⵡⴻⵎ ⴳⴳⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JR42_11","025_42_11","JER","42","11","11","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ. ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴼⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR42_12","025_42_12","JER","42","12","12","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⵃⵎⴻⵖ ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵃⴻⵎ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⵔ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR42_13","025_42_13","JER","42","13","13","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵖⵉⵎⵉ ⵛⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ, ⵓ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JR42_14","025_42_14","JER","42","14","14","ⴰⴷ ⵜⵉⵏⵉⵎ: ⵍⵍⴰ, ⵏⴻⵅⵙ ⴰⴷ ⵏⵓⵢⵓⵔ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵎⴰⵏⵉ ⵡⴰⵔ ⵏⵥⴰⵔⵔ ⴰⵎⴻⵏⵖⵉ ⵓ ⵡⴰⵔ ⵏᵉⵜⵜⴻⵙⵍⵉ ⵉ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵡⴰⵔ ⵏⴻⵜⵜⵍⵉⵥⵉ ⴰⵖⵔⵓⵎ. ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⵉ ⵏⴻⵅⵙ ⴰⴷ ⵏⴻⵇⵇⵉⵎ!’, ");
INSERT INTO rift_vpl VALUES ("JR42_15","025_42_15","JER","42","15","15","ⵅⴻⵏⵏⵉ ⵙⵍⴻⵎ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴽⴻⵏⵏⵉⵡ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⵎⵎⴷⴻⵎ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴹⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⵣⴻⴷⵖⴻⵎ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR42_16","025_42_16","JER","42","16","16","ⵅⴻⵏⵏⵉ ⵙⵙⵉⴼ ⵉ ⵣⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵍⵇⴻⴼ ⴷⵉⵏⵏⵉ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⵍⴰⵥ ⵉ ⵣⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⴹⴼⴰⵔ ⴷⵉⵏⵏⵉ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⴻⵎⵎⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR42_17","025_42_17","JER","42","17","17","ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⴻⵊⵊⴻⵎ ⵏⵉⵖ ⵉⵜⵜⴰⵔⴻⴽⴽⵡⴰⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⵖⴰⵔ ⵉ ⵅⴰⵙⴻⵏ ⴷⴷ ⵖⴰ ⵖⴻⴹⵍⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("JR42_18","025_42_18","JER","42","18","18","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⴷ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵣⴻⴵⴻⵄ ⵓⵍⴰ ⴷ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵅⴰⵡⴻⵎ ⵎⴰⵍⴰ ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⴻⵅⵣⵉ ⴷ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵜⵙⴻⴹⵃⴰⵛⵜ, ⵓⵍⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵍⵃⴻⴳⵔⴰ. ⴰⵎⵛⴰⵏ-ⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⵜ ⵜⵥⴰⵔⴻⵎ ⵄⴰⴷ.’ ");
INSERT INTO rift_vpl VALUES ("JR42_19","025_42_19","JER","42","19","19","ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵖⴰⵔⵡⴻⵎ, ⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ! ⵡⴰⵔ ⵜⵜⵉⴷⴼⴻⵎ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⵙⵏⴻⵎ ⵎⵍⵉⵃ ⴰⵇⴰ ⵏⴻⵛⵛ ⵄⴻⵍⵎⴻⵖ ⴰⵡⴻⵎ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR42_20","025_42_20","JER","42","20","20","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵛⵛⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵜⴻⵏⵏⴰⵎ: ‘ⵥⴰⴵ ⴰⵏⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵉⵏⵉ ⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⴰⴷ ⵢⵉⵏⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵜ ⵏⴻⴳⴳ!’ ");
INSERT INTO rift_vpl VALUES ("JR42_21","025_42_21","JER","42","21","21","ⴰⵙⵙ-ⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵙ ⵎⵉⵏ ⵣⵉ ⵉ ⴷ ⴰⵢⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("JR42_22","025_42_22","JER","42","22","22","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⵏⴻⵎ ⵎⵍⵉⵃ ⴰⵇⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⵎ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR43_1","025_43_1","JER","43","1","1","ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵉⵔⵎⵉⵢⴰ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵙ ⵎⵉⵏ ⵣⵉ ⵜⵓⵖⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR43_2","025_43_2","JER","43","2","2","ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵣⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵀⵓⵛⴰⵄⵢⴰ, ⵓ ⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵢⴰⵃ, ⴷ ⵎⴰⵔⵔⴰ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⵉ ⵉⵔⵎⵉⵢⴰ: “ⵛⴻⴽ ⵜⴻⵙⵙⵅⴰⵔⵔⵉⵇⴻⴷ. ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵛⴻⴽ ⴷⴷ-ⵉⵙⴻⴽⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JR43_3","025_43_3","JER","43","3","3","ⵎⴰⵛⴰ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵉ ⵛⴻⴽ ⵉ ⴷⴷ-ⵉⵃⴰⵔⵔⵛⴻⵏ ⵅⴰⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⵙⴻⵍⵍⵎⴻⴷ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵏⵖⴻⵏ ⵓ ⴰⴷ ⴰⵏⴻⵖ ⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⴱⴰⴱⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR43_4","025_43_4","JER","43","4","4","ⴰⵎⵎⵓ ⵡⴰⵔ ⵉⵙⵍⵉ ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵢⴰⵃ, ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR43_5","025_43_5","JER","43","5","5","ⵢⵓⵃⴰⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵇⴰⵔⵉⵢⴰⵃ, ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴷⴻⵡⵍⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵓⵥⵥⵍⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ: ");
INSERT INTO rift_vpl VALUES ("JR43_6","025_43_6","JER","43","6","6","ⵉⵔⵢⴰⵣⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵊⵊⴰ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵖⴰⵔ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵅⵉⵇⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⵓⵍⴰ ⴷ ⴰⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⴷ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("JR43_7","025_43_7","JER","43","7","7","ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵍ ⵜⴰⵃⴼⴰⵏⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JR43_8","025_43_8","JER","43","8","8","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⴷⵉ ⵜⴰⵃⴼⴰⵏⵃⵉⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR43_9","025_43_9","JER","43","9","9","“ⴽⵙⵉ ⵉⵥⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⵓⴼⴼⴰⵔ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵓⴱⴻⴵⴰⵄ ⵏ ⵜⵉⵙⵉ ⵏ ⵍⵓⵚⴰ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⵉⵔⵄⵓⵏ ⴷⵉ ⵜⴰⵃⴼⴰⵏⵉⵙ. ⴻⴳⴳ ⵉ-ⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("JR43_10","025_43_10","JER","43","10","10","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⵢⴻⵖ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵅ ⵢⴻⵥⵔⴰ-ⵢⴰ ⵏⵏⵉ ⵏⵓⴼⴼⴰⵔⴻⵖ ⴷⵉⵏⵏⵉ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵜⵉⵡⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR43_11","025_43_11","JER","43","11","11","ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ: ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵍⵎⴻⵡⵜ, ⵙ ⵍⵎⴻⵡⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵉ ⵓⵃⴻⴱⴱⴻⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵙⵙⵉⴼ, ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JR43_12","025_43_12","JER","43","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⵙⵙⴰⵔⴻⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵎⵉⵚⵔⴰ, ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵖ ⵉⵅⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵓ ⴰⴷ ⴰⵡⵢⴻⵖ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵉⵎⴻⵃⴱⴰⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⴹ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵎ ⵓⵎⴻⴽⵙⴰⵡ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR43_13","025_43_13","JER","43","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵥ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵜⵎⴻⵙⵙⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR44_1","025_44_1","JER","44","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵉⵔⵎⵉⵢⴰ ⵉ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⴰⵊⴷⴰⵍ ⴷ ⵜⴰⵃⴼⴰⵏⵃⵉⵙ ⴷ ⵏⵓⴼ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴼⴰⵜⵔⵓⵙ, ⵉ ⵉⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("JR44_2","025_44_2","JER","44","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵜⴻⵥⵔⵉⵎ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵖ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵍⴻⵅⵅⵓ ⴷⴻⵡⵍⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⵍⵅⵉⵔⴱⴻⵜ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ");
INSERT INTO rift_vpl VALUES ("JR44_3","025_44_3","JER","44","3","3","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵍⴻⴱⵅⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵄⴻⴱⴷⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵏⵉⵜⵏⵉ, ⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵓⵍⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR44_4","025_44_4","JER","44","4","4","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵄⴰⴷ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙⵙⴻⴽⴽⴻⵖ ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉⵏ: ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵏⵏⵄⵉ-ⵢⴰ ⵏⵏⵉ ⵛⴰⵔⵔⵀⴻⵖ ⵏⴻⵛⵛ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR44_5","025_44_5","JER","44","5","5","ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵍⵉⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵙⴻⵏ ⵓⵎⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵏⴻⴷⵎⴻⵏ ⵣⵉ ⵍⵖⴰⵔ ⵏⵙⴻⵏ, ⵓⵎⵉ ⵡⴰⵔ ⵡⴻⵀⵀⴱⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR44_6","025_44_6","JER","44","6","6","ⵙ ⵓⵢⴰ ⵉ ⴼⴰⵔⵖⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⴷ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ, ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏⵜ ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR44_7","025_44_7","JER","44","7","7","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵍⵖⴰⵔ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵅ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ ⴰⵍⴰⵎⵉ ⵜⵇⴻⵟⵟⴰⵎ ⵅ ⵡⴻⵔⵢⴰⵣ ⴷ ⵜⴻⵎⵖⴰⵔⵜ, ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵓⵙⴻⵢⵎⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵛⴻⵟⵟ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR44_8","025_44_8","JER","44","8","8","ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⵙⴻⵄⵄⴰⵔⴻⵎ ⵙ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⵓⵎⵉ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴰⵎ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵎⴰⵏⵉ ⵖⴰⵔ ⴷⴷ-ⵜⵉⵡⴹⴻⵎ ⵍⴻⵅⵅⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⵣⴻⴷⵖⴻⵎ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⵇⴻⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⵎⵎⵓ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⴻⵅⵣⵉ ⴷ ⵍⵃⴻⴳⵔⴰ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("JR44_9","025_44_9","JER","44","9","9","ⵎⴰ ⵜᵉⵜⵜⵓⵎ ⴽⴻⵏⵏⵉⵡ ⵇⴰⵄ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴷ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⵍⵖⴰⵔ ⵉ ⵜⴻⴳⴳⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⴷ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ? ");
INSERT INTO rift_vpl VALUES ("JR44_10","025_44_10","JER","44","10","10","ⴰⵍ ⴰⵙⵙ-ⴰ ⵉ ⴷⵉ ⵏⴻⴵⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜⵜⵡⴰⵔⵔⵥⴻⵏ ⴷⴻⴳ ⵡⵓⵍ, ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜⴻⴳⴳⵯⴷⴻⵏ ⵓ ⵡⴰⵔ ⴹⴻⴼⴼⴰⵔⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⴷ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵡⵛⵉⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵡⴻⵎ ⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR44_11","025_44_11","JER","44","11","11","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵉ ⵍⵖⴰⵔ ⵅⴰⵡⴻⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵇⴹⵉⵖ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR44_12","025_44_12","JER","44","12","12","ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⵉ ⵉⵄⴻⵎⵎⴷⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵣⴻⴷⵖⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵡⴹⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⴻⵅⵣⵉ ⴷ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵍⵃⴻⴳⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR44_13","025_44_13","JER","44","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵙ ⵙⵙⵉⴼ, ⵙ ⵍⴰⵥ ⵓ ⵙ ⵟⵟⴰⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR44_14","025_44_14","JER","44","14","14","ⵣⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏⵏⵉ ⵣⴻⴷⵖⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵡⴰⵔ ⵉⵏⴻⵊⵊⵉⵎ ⵏⵉⵖ ⵉⵜⵜⴰⵔⴻⴽⴽⵡⴰⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵏⵉ ⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ. ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⵄⵇⵉⴱⴻⵏ ⵛⴰ, ⵎⵖⵉⵔ ⵛⴰ ⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR44_15","025_44_15","JER","44","15","15","ⵅⴻⵏⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅ ⵉⵔⵎⵉⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵡⴻⵀⵀⴱⴻⵏⵜ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴷⵉ ⴼⴰⵜⵔⵓⵙ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("JR44_16","025_44_16","JER","44","16","16","“ⵅ ⵡⴰⵡⴰⵍ ⵉ ⴽⵉⴷⵏⴻⵖ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵏᵉⵜⵜⴻⵙⵍⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JR44_17","025_44_17","JER","44","17","17","ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵖ ⴰⴷ ⵜ ⵏⴻⴳⴳ ⵓⵎⵉ ⵖⴰ ⵏⴻⵙⵙⴱⴻⵅⵅⴰⵔ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵓⵎⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵏⵙⴻⵢⵢⴻⴱ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵏⴻⴳⴳⴰ, ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ, ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵊⵊⵉⵡⴻⵏ ⵏⴻⵛⵛⵉⵏ ⵙ ⵡⴻⵖⵔⵓⵎ ⵓ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵎⵍⵉⵃ, ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⴰⵔⵊⵉⵊⴰⵜ ⵣⵉ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR44_18","025_44_18","JER","44","18","18","ⵣⴻⴳ ⵡⴰⵎⵉ ⵎⴰⵛⴰ ⵏⴻⵙⵙⴱⴻⴷⴷ ⵏⴻⵜⵜⵡⴻⵀⵀⴻⴱ ⵍⴻⴱⵅⵓⵔ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵣⴻⴳ ⵓⵙⴻⵢⵢⴻⴱ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵉ ⵏⴻⵜⵜⴰⵜ, ⴰⵇⴰ ⵏⴻⵃⵡⴰⵊ ⵓ ⵏⴻⴼⵏⴰ ⵏⴻⵛⵛⵉⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("JR44_19","025_44_19","JER","44","19","19","ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴱⴻⵅⵅⴰⵔ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵏⵙⴻⵢⵢⴻⴱ ⴰⵙ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ, ⵎⴰ ⵏⵀⵍⴰ ⴰⵔⴳⴰⴱ ⴷ ⵍⵅⴰⴹⴰⵔ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵖ ⵏⴻⴳⴳⴰ ⴰⵙ ⵜⵉⴼⴹⵉⵔⵉⵏ ⵉ ⵚⵚⴻⴷⵇⴻⵜ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵢⴰⵔⵡⴻⵙⴻⵏ ⵓ ⵏⵙⴻⵢⵢⴻⴱ ⴰⵙ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ?” ");
INSERT INTO rift_vpl VALUES ("JR44_20","025_44_20","JER","44","20","20","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵔⵎⵉⵢⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵖⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷⴷ ⵅⴰⵙ ⵢⴰⵔⵔⵉⵏ ⴰⵎⵎⵓ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR44_21","025_44_21","JER","44","21","21","“ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵏⵏⵉ ⵜⴻⵙⵙⴱⴻⵅⵅⴰⵔⴻⵎ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵡⴻⵎ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵉⴷⴰⵔ ⵙⵉⴷⵉ ⵏⵉⵖ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏⵜ ⵖⴰⵔ ⵍⴱⴰⵍ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JR44_22","025_44_22","JER","44","22","22","ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵉⵚⴻⴱⴱⴰⵔ ⴰⵡⴻⵎ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ, ⵅ ⵊⵊⵄⴰⵢⴻⴼ ⵉ ⵜⴻⴳⴳⵉⵎ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵅⵍⴰⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR44_23","025_44_23","JER","44","23","23","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⵢⴻⵎ-ⴷⴷ ⵍⴻⴱⵅⵓⵔ ⵓ ⵜⴻⵅⴹⴰⵎ ⴰⴽ-ⴷ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵛⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵙ, ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵏⴻⵙ, ⵅ ⵓⵢⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵍⵇⴻⴼ ⵍⵖⴰⵔ-ⴰ, ⴰⵎ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR44_24","025_44_24","JER","44","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ: “ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR44_25","025_44_25","JER","44","25","25","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵇⵇⴰⵔ: ‘ⵅ ⴽⴻⵏⵏⵉⵡ ⵓ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵜⴻⵏⵏⴰⵎ ⵜ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ ⵓ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵜⴻⴳⴳⵉⵎ ⵜ, ⵜⴻⵏⵏⴰⵎ: ⴰⵎⴻⵡⵛⵉ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵏⴻⴳⴳⴰ, ⴰⴷ ⵜ ⵏⴽⴻⵎⵎⴻⵍ ⵏⵉⵛⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵏⵇⴻⴷⴷⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵜⵊⴻⴵⵉⴷⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⴻⵢⵢⴻⴱ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ⵅⴻⵏⵏⵉ ⴽⴻⵎⵎⵍⴻⵎ ⵏⵉⵛⴰⵏ ⵍⵡⵓⵄⵓⴷ ⵉ ⵜⵡⴰⵄⴷⴻⵎ ⵓ ⴳⴳⴻⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⵡⴰⵄⴷⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JR44_26","025_44_26","JER","44","26","26","“ⵙ ⵓⵢⴰ ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⴰ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵄⴰⴷ ⵣⵉ ⵛⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵉⴳⴳⴰ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⴷ ⵢⵉⵏⵉ: ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("JR44_27","025_44_27","JER","44","27","27","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵄⴻⵙⵙⴻⵖ ⵉ ⵍⵖⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵍⵅⴰⵔ. ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⴷ ⵀⴻⵍⵍⴽⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR44_28","025_44_28","JER","44","28","28","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵙⵙⵉⴼ, ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵡⵓⵔⵓ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵡⴰⵍ ⵏ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ, ⵡⴻⵏⵏⵉ ⵉⵏⵓ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR44_29","025_44_29","JER","44","29","29","ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵇⴱⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵅⴰⵡⴻⵎ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵉ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR44_30","025_44_30","JER","44","30","30","ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⴼⵉⵔⵄⵓⵏ ⵃⵓⴼⵔⴰⵄ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⵉⵡⴹⴻⵖ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JR45_1","025_45_1","JER","45","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵉ ⴱⴰⵔⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵓⵎⵉ ⵢⵓⵔⴰ ⵡⴰⵏⵉⵜⴰ ⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵔⵎⵉⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR45_2","025_45_2","JER","45","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⴰⴽ, ⴰ ⴱⴰⵔⵓⵅ! ");
INSERT INTO rift_vpl VALUES ("JR45_3","025_45_3","JER","45","3","3","ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ: ‘ⴰⵅⴻⵢⵢⴻⴱ ⵉ ⵏⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵢⴰⵔⴻⵏⵏⵉ ⵄⴰⴷ ⴰⵛⴹⴰⵏ ⵅ ⵍⴻⵃⵔⵉⵇ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵓⵃⵍⴻⵖ ⵙ ⵡⴻⵣⵀⴰⵔ, ⵡⴰⵔ ⵓⴼⵉⵖ ⴰⵔⵔⴰⵃⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("JR45_4","025_45_4","JER","45","4","4","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵎⵉⵏ ⵙⵙⴱⴻⴷⴷⴻⵖ, ⴰⴷ ⵜ ⵖⴻⴹⵍⴻⵖ, ⵓ ⵎⵉⵏ ⵥⵥⵓⵖ, ⴰⴷ ⵜ ⵇⴻⵍⵄⴻⵖ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JR45_5","025_45_5","JER","45","5","5","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ? ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴰⵔⴻⵣⵣⵓⴷ ⵛⴰ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR46_1","025_46_1","JER","46","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵅ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JR46_2","025_46_2","JER","46","2","2","ⵅ ⵎⵉⵚⵔⴰ ⴹⵉⴷⴷ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⴼⵉⵔⵄⵓⵏ ⵏⴰⵅⵓ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵖⴰⵔ ⴽⴰⵔⴽⴰⵎⵉⵛ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⵏⴰ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵛⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR46_3","025_46_3","JER","46","3","3","“ⵙⵡⴻⵊⴷⴻⵎ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵙⴳⴻⵄⵄⴷⴻⵎ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ! ");
INSERT INTO rift_vpl VALUES ("JR46_4","025_46_4","JER","46","4","4","ⵃⴻⵣⵣⵎⴻⵏ ⵉ ⵉⵢⵙⴰⵏ, ⵏⵢⴻⵎ ⵅⴰⵙⴻⵎ, ⴰ ⵉⵎⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵢⵙⴰⵏ! ⵙⴱⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵍⴽⴰⵙⴽⴰⵜ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ. ⵙⵇⴻⴹⵄⴻⵎ ⴼⵍⵉⵜⵛⴰⵜ ⵓⵛⴰ ⵃⴻⵣⵣⵎⴻⵎ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ! ");
INSERT INTO rift_vpl VALUES ("JR46_5","025_46_5","JER","46","5","5","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⵡⴰⵍⵉⵖ ⵏⴻⵛⵛ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵏⵏⵅⴻⵍⵄⴻⵏ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ? ⵄⴰⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵔⵥⴻⵏ, ⵎⴻⵏⵄⴻⵏ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵓⵛⴰ ⵡⴰⵔ ⵉ-ⴷⴷ-ⵏⵏⵇⴻⵍⴱⴻⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⵏⴻⵅⵍⵉⵄ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR46_6","025_46_6","JER","46","6","6","ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⴼⵙⵓⵙⴻⵏ ⵙ ⵉⴹⴰⵔⴻⵏ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⴽⴽⵡⴰⵍ ⵓⵍⴰ ⴷ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵡⴰⵔ ⵉⵏⴻⵊⵊⴻⵎ: ⵏⵏⵇⴰⵔⴹⴻⵏ, ⵡⴹⴰⵏ ⴷⵉ ⵛⵛⴰⵎⴰⵍ, ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ.” ");
INSERT INTO rift_vpl VALUES ("JR46_7","025_46_7","JER","46","7","7","“ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷⵉⵏ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⴰⵎ ⵡⴰⵎⴰⵏ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵣⴻⵀⵀⴰⵔⴻⵏ ⴰⵎ ⵢⵉⵖⴻⵣⵔⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JR46_8","025_46_8","JER","46","8","8","ⵎⵉⵚⵔⴰ ⵜⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴰⵎ ⵡⴰⵎⴰⵏ, ⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵣⴻⵀⵀⴰⵔⴻⵏ ⴰⵎ ⵢⵉⵖⴻⵣⵔⴰⵏ, ⵜⴻⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ, ⴰⴷ ⴷⵍⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⵇⴹⵉⵖ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR46_9","025_46_9","JER","46","9","9","ⴳⴻⵄⵄⴷⴻⵎ, ⴰ ⵉⵢⵙⴰⵏ, ⵎⵓⵣⵣⴰⵔⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ! ⵊⵊⴻⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴰⴷ ⴼⴼⵖⴻⵏ: ⴰⵢⵜ ⵏ ⴽⵓⵛ, ⴰⵢⵜ ⵏ ⴼⵓⵟ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⴰⵢⵜ ⵏ ⵍⵓⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⵍⵇⴻⵡⵙ ⵓⵛⴰ ⵎⴻⵃⵃⴹⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("JR46_10","025_46_10","JER","46","10","10","ⴰⵙⵙ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵡⴻⵅⵍⴰⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⵍⴻⴼ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ. ⴰⴷ ⵢⴻⵛⵛ ⵙⵙⵉⴼ, ⴰⴷ ⵉⵊⵊⴰⵡⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵛⴰⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("JR46_11","025_46_11","JER","46","11","11","ⴳⴻⵄⵄⴷⴻⵎ ⵖⴰⵔ ⵊⵉⵍⵄⴰⴷ, ⴰⵡⵢⴻⵎ-ⴷ ⴱⴰⵍⵙⴰⵎ, ⴰ ⵛⴻⵎ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵉⴵⵉⵙ ⵏ ⵎⵉⵚⵔⴰ!. ⴱⴰⵟⴻⵍ ⵜⴰⵔⴻⵏⵏⵉⴷ ⴷⵉ ⴷⴷⵡⴰⵡⴰⵜ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵖⴰⵔⴻⵎ ⴱⵓ ⴷⴷⴰⵡⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⴷ ⵅ ⵓⵢⴻⵣⵣⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR46_12","025_46_12","JER","46","12","12","ⵙⵍⵉⵏ ⵍⴻⴳⵏⵓⵙ ⵅ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⴻⵛⵛⵓⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⴻⴳ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵍⴻⵃⵍⵉⵇ ⵏⵏⴻⵎ, ⵎⴰⵖⴰⵔ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵎⵇⴰⵔⵇⴻⴱ ⴰⴽ-ⴷ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵟ ⵏⵏⴻⵖⵏⵉ, ⵎⵓⵏⴻⵏ ⵡⴹⴰⵏ ⵙ ⵜⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR46_13","025_46_13","JER","46","13","13","ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵅ ⵜⵡⴰⵙⵉⵜ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JR46_14","025_46_14","JER","46","14","14","“ⴱⴰⵔⵔⵃⴻⵎ ⵜ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓ ⵊⵊⴻⵎ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⴷⵉ ⵎⴰⵊⴷⴰⵍ, ⵊⵊⴻⵎ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⴷⵉ ⵏⵓⴼ ⴷ ⵜⴰⵃⴼⴰⵏⵃⵉⵙ. ⵉⵏⵉⵎ: ‘ⴱⴻⴷⴷ ⴰⴱⴻⴷⴷⵉ, ⵡⵊⴻⴷ!’, ⵎⴰⵖⴰⵔ ⵙⵙⵉⴼ ⵉⵛⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR46_15","025_46_15","JER","46","15","15","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⵡⴰⵎⵃⴰⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵛ? ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵄⴰⵔⵔⴻⵏ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("JR46_16","025_46_16","JER","46","16","16","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵟⵟⴰⵙ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ, ⵡⴰⵀ, ⴰⵔⵢⴰⵣ ⵉⵡⴹⴰ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: ‘ⴽⴽⴰⵔⴻⵎ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵏⴻⵅⵍⴻⵇ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵙⵉⴼ ⵉⵡⵄⴰⵔⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JR46_17","025_46_17","JER","46","17","17","ⴷⵉⵏ ⵉ ⵍⴰⵖⴰⵏ ⵏⵉⵜⵏⵉ: ‘ⴰⵇⴰ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⴰⵇⴰ ⵉⵊⵊⴰ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⴷ ⵜⴻⵄⴷⵓ.’” ");
INSERT INTO rift_vpl VALUES ("JR46_18","025_46_18","JER","46","18","18","“ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ: ‘ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⵎ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴱⵓⵔ ⵊⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵓ ⴰⵎ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("JR46_19","025_46_19","JER","46","19","19","ⵙⵎⵓⵏ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏⵏⴻⵎ ⵉ ⵍⵎⴻⵏⴼⴰ, ⴰ ⵛⴻⵎ ⵜⴰⵎⴻⵣⴷⵓⵖⵜ, ⵉⴵⵉⵙ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵏⵓⴼ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵣⴻⴷⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR46_20","025_46_20","JER","46","20","20","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵄⴻⵊⵎⵉⵜ ⵜⴻⵛⵏⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵢⴰⵔⴻⵣⵣⵉ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵉ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JR46_21","025_46_21","JER","46","21","21","ⵓⵍⴰ ⴷ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⴰⵎ ⵢⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵉⵚⴻⵃⵃⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ, ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵊⵎⵉⵄ, ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵙⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵢⴰⵙ, ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏ ⵡⴻⵅⵍⴰⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR46_22","025_46_22","JER","46","22","22","ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵜⴻⴳⴳⴰ ⴰⵎ ⵍⵃⴻⵙⵙ ⵏ ⵓⴼⵉⵖⴰⵔ ⵉⵃⵔⴰⵔⵔⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⵉⵏ ⵓⵢⵓⵔⴻⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵛⵛⵡⴰⵇⴰⵔ ⴰⵎ ⵢⵉⵏⴻⵣⴷⴰⵎⴻⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JR46_23","025_46_23","JER","46","23","23","ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⴻⵙⵙⴻⵏ ⴰⵣⵖⴰⵔ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵅ ⵉⴱⵓⵔⴻⵅⵙⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR46_24","025_46_24","JER","46","24","24","ⵜⵙⴻⴹⵃⴰ ⵢⴻⴵⵉⵙ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵛⵛⴰⵎⴰⵍ.’” ");
INSERT INTO rift_vpl VALUES ("JR46_25","025_46_25","JER","46","25","25","“ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵄⴰⵇⴱⴻⵖ ⴰⵎⵓⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵏⵓ, ⴷ ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⵉⵚⵔⴰ, ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴼⵉⵔⵄⵓⵏ ⴷ ⵢⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵜⵜⵛⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR46_26","025_46_26","JER","46","26","26","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵍⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵓⵍⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵢⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵎⴻⵣⴷⴰⵖ ⵄⴰⵡⴻⴷ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵉⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR46_27","025_46_27","JER","46","27","27","“ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ, ⴰ ⵛⴻⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ, ⵡⴰⵔ ⵜⴻⴼⵛⵉⵍ ⵛⴰ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵜⵉⵎⵎⵓⵔⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵓⵍⴰ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏ. ⴰⴷ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⴰⴷ ⵉⴷⴷⴰⵔ ⴷⵉ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("JR46_28","025_46_28","JER","46","28","28","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⴰ ⵛⴻⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵖ, ⵎⴰⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵅⴰⴽ ⵇⴻⵟⵟⵉⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵛⴻⴽ ⵡⴻⴱⴱⵅⴻⵖ ⵙ ⵍⴻⵄⴱⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⵡⴰⵔ ⵛⴻⴽ ⵀⴻⵚⵚⴱⴻⵖ ⴷ ⴰⵎⴻⵣⴷⴰⴳ.’” ");
INSERT INTO rift_vpl VALUES ("JR47_1","025_47_1","JER","47","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⴰⵡⴰⵍ ⵉ ⵉⵡⴻⵊⵊⵀⴻⵏ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵇⴱⴻⵍ ⵎⴰ ⵉⵡⵜⴰ ⴼⵉⵔⵄⵓⵏ ⵖⴰⵣⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("JR47_2","025_47_2","JER","47","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⴰⵎⴰⵏ ⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵜⴻⵙⵙⴼⴰⵢ. ⴰⴷ ⵃⴻⵎⵍⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ, ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ. ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵉⵡⴷⴰⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵛⴻⴹⵏⴻⵏ ⴰⵟⵟⴰⵙ ");
INSERT INTO rift_vpl VALUES ("JR47_3","025_47_3","JER","47","3","3","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵣⴱⴰⵔ ⵏ ⵜⴻⵛⵜⵉ ⵏ ⵜⵛⴻⴹⵢⵉⵏ ⵏ ⵢⴻⵢⵙⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵔⵉⵣ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⴷ ⵓⵇⴰⵔⵇⴻⴱ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ. ⵄⴰⴷ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵡⴰⵔ ⵃⴻⴽⴽⴰⵔⴻⵏ ⵛⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵎⴰⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴰⵔⴻⵀⴼⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JR47_4","025_47_4","JER","47","4","4","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵙⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵉ ⵚⵓⵔ ⴷ ⵚⵉⴷⵓⵏ ⴽⵓⵍ ⴱⵓ-ⵜⵡⵉⵣⴰ ⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⵜⴻⵃⵃⴰ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⴽⴰⴼⵜⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JR47_5","025_47_5","JER","47","5","5","ⵜⵓⵙⴰ-ⴷⴷ ⵜⵇⴻⵛⵛⴰⵔⵜ ⵅ ⵖⴰⵣⵣⴰ, ⵜⴻⵙⵙⴻⵖⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵛⵇⴰⵍⵓⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏⵙⴻⵏ. ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵄⴰⴷ ⵜⵅⴻⴱⴱⵛⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JR47_6","025_47_6","JER","47","6","6","ⵓⵛⵜ ⵅⴰⴽ, ⴰ ⵙⵙⵉⴼ ⵏ ⵙⵉⴷⵉ, ⴰⵍ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵄⴰⴷ ⵏⴻⵀⵍⴰ ⴰⵔⵔⴰⵃⴻⵜ? ⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵏⵏⴻⵛ, ⵇⵇⵉⵎ ⵡⴰⵔ ⵜⴻⵏⵀⴻⵣⵣⴰ! ");
INSERT INTO rift_vpl VALUES ("JR47_7","025_47_7","JER","47","7","7","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴰⵔⵙⵉⴷ? ⴰⵇⴰ ⵙⵉⴷⵉ ⵢⵓⵎⵓⵔ ⵙⵙⵉⴼ ⴹⵉⴷⴷ ⵉ ⴰⵛⵇⴰⵍⵓⵏ ⵓ ⴹⵉⴷⴷ ⵉ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵉ ⵎⴰⵏⴰⵢⴻⵏⵏⵉ ⵉ ⵉⵜⵜⵡⴰⴳⴳ.’” ");
INSERT INTO rift_vpl VALUES ("JR48_1","025_48_1","JER","48","1","1","ⵅ ⵎⵓ’ⴰⴱ “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵓⵛⵜ ⵅ ⵏⴰⴱⵓ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜᵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵍⴻⵃⵢⴰ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ. ⵍⴱⵓⵔⵊ ⵢⵓⵄⵍⴰⵏ ⵜᵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵍⴻⵀⵢⴰ ⵓ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("JR48_2","025_48_2","JER","48","2","2","ⵍⵄⴻⵣⵣ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ. ⴷⵉ ⵃⴰⵛⴱⵓⵏ ⵅⴰⵔⵔⵚⴻⵏ ⴷⵉ ⵍⵖⴰⵔ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⵜ ⵏⴻⴽⴽⴻⵙ ⵣⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ⵓⵍⴰ ⴷ ⵛⴻⴽ, ⵎⴰⴷⵎⵉⵏ, ⴰⴷ ⵛⴻⴽ ⵙⵙⴱⴻⴽⵎⴻⵏ, ⵙⵙⵉⴼ ⴳⴳⵓⵔ ⴰⴷ ⵛⴻⴽ ⵉⴹⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR48_3","025_48_3","JER","48","3","3","ⵜⴻⴼⴼⴻⵖ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵍⴻⵃⵔⵉⵇ ⵣⵉ ⵃⵓⵔⵓⵏⴰⵢⵉⵎ: ⴰⵅⴰⵔⵔⴻⴱ ⴷ ⵍⵎⵓⵚⵉⴱⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ! ");
INSERT INTO rift_vpl VALUES ("JR48_4","025_48_4","JER","48","4","4","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ ⵜᵉⵜⵜⵡⴰⵔⵥ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴳⴳⵉⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴻⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JR48_5","025_48_5","JER","48","5","5","ⵡⴰⵀ, ⴰⵎ ⵉⵜⵜⵔⵓ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵏⴻⵜⵜⴰ ⵜⵙⴰⵡⴻⵏⵜ ⵏ ⵍⵓⵃⵉⵜ, ⵎⴰⵖⴰⵔ ⵖⴰⵔ ⵓⵀⴻⴽⴽⵡⵓ ⵖⴰⵔ ⵃⵓⵔⵓⵏⴰⵢⵉⵎ ⵙⵍⵉⵏ ⴰⴷⵓⵇⵇⴻⵣ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵜⵅⴻⵙⵙⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR48_6","025_48_6","JER","48","6","6","ⴰⵔⴻⵡⵍⴻⵎ, ⵙⵏⴻⵊⵎⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ, ⴷⴻⵡⵍⴻⵎ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵅⴻⵛⵛⴰⴱ ⴷⵉ ⵜⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("JR48_7","025_48_7","JER","48","7","7","ⵎⵉⵏⵣⵉ ⵛⴻⵎ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵎ ⴷ ⵍⴻⴽⵏⵓⵣ ⵏⵏⴻⵎ, ⵓⵍⴰ ⴷ ⵛⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵟⵟⴼⴻⴷ. ⴽⴰⵎⵓⵛ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR48_8","025_48_8","JER","48","8","8","ⴰⵎⵜⴻⵃⵃⴰⵢ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏⵊⴻⵎ. ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴹⴻⵍ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵓⵛⴰ ⵍⵡⴰⵟⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵏⵏⴰ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR48_9","025_48_9","JER","48","9","9","“ⵡⵛⴻⵎ ⴰⴼⵔⵉⵡⴻⵏ ⵉ ⵎⵓ’ⴰⴱ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⵙ ⵜⴰⵣⵍⴰ ⵓⵛⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JR48_10","025_48_10","JER","48","10","10","ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵅⵓⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⵅ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_11","025_48_11","JER","48","11","11","ⵜⵓⵖⴰ ⵎⵓ’ⴰⴱ ⴷⵉ ⵍⴰⵎⴰⵏ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ, ⵢⴰⵔⵙⴰ ⴰⵎ ⴱⵉⵏⵓ ⵅ ⵍⴻⵅⵎⵉⵔⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜ ⴼⴰⵔⵔⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴷⵉⵃ ⵖⴰⵔ ⵓⵇⴷⵉⵃ ⵏⵏⴻⵖⵏⵉ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴼⴼⵉⵖ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ. ⵅ ⵓⵢⴰ ⵉⵇⵇⵉⵎ ⴰⵙ ⵓⵍⴻⴷⴷⵉ ⵏⵏⴻⵙ ⴷ ⵍⴻⴼⵡⴰⵃ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⴱⴻⴷⴷⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR48_12","025_48_12","JER","48","12","12","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴰⵔⵔⵖⴻⵏ ⵉⵇⴷⵉⵃⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜ ⴼⴰⵔⵔⵖⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴻⵅⵡⴰⵏ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⴰⵔⵥⴻⵏ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR48_13","025_48_13","JER","48","13","13","ⵎⵓ’ⴰⴱ ⴰⴷ ⵉⵏⵏⴻⴼⴹⴻⵃ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴽⴰⵎⵓⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵏⴻⴼⴹⴻⵃ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⴰⵢⵜ-ⵉⵍ, ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜⵜᵉⵜⵛⵍⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR48_14","025_48_14","JER","48","14","14","ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ, ⵉⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ?’ ");
INSERT INTO rift_vpl VALUES ("JR48_15","025_48_15","JER","48","15","15","ⵎⵓ’ⴰⴱ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵍⴻⵄⴷⵓ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ. ⴰⵛⴻⵡⵡⴰⵔ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔ ⵜⵖⴰⵔⵚⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR48_16","025_48_16","JER","48","16","16","“ⴰⴹⴻⵢⵢⴻⵄ ⵏ ⵎⵓ’ⴰⴱ ⵢⵓⴷⴻⵙ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵓ ⵍⵖⴰⵔ ⵏⵏⴻⵙ ⵢⵉⵡⴻⴹ-ⴷⴷ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR48_17","025_48_17","JER","48","17","17","ⵛⴻⵜⵛⴰⵎ ⵅⴰⵙ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵉⵏⵉⵎ: ‘ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵢⴰⵔⵔⴻⵥ ⵓⵣⴻⴵⴰⴹ ⵏ ⵚⵚⵓⵍⵟⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⵜⴰⵙⴻⵟⵟⴰ ⵏⵏⵉ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵟⵟⴰⵙ?’ ");
INSERT INTO rift_vpl VALUES ("JR48_18","025_48_18","JER","48","18","18","ⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵎ ⵢⵓⵄⵍⴰⵏ, ⵇⵇⵉⵎ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⴼⴰⴷⵉ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵢⴻⴵⵉⵙ ⵏ ⴷⵉⴱⵓⵏ, ⵎⴰⵖⴰⵔ ⴰⵎⵜⴻⵃⵃⴰⵢ ⵏ ⵎⵓ’ⴰⴱ ⵉⵀⴻⵊⵊⴻⵎ-ⴷⴷ ⵅⴰⵎ, ⴰⵇⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR48_19","025_48_19","JER","48","19","19","ⴱⴻⴷⴷⴻⵜ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵅⵣⴰⵔⴻⵜ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵄⴰⵔⵓⵄⵉⵔ! ⵙⴻⵇⵙⴰⵜ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ, ⵉⵏⵉ: ‘ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("JR48_20","025_48_20","JER","48","20","20","ⵉⵏⵏⴻⴼⴹⴻⵃ ⵎⵓ’ⴰⴱ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵍⴱⴻⵣ. ⵛⴻⵜⵛⴰ, ⵙⵖⵓⵢⵢ, ⴻⵊⵊ ⴰⴷ ⵙⵙⵏⴻⵏ ⴷⵉ ⴰⵔⵏⵓⵏ ⴰⵇⴰ ⵎⵓ’ⴰⴱ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("JR48_21","025_48_21","JER","48","21","21","ⵢⵉⵡⴻⴹ-ⴷⴷ ⵍⵃⵓⴽⵎ ⵅ ⵍⵡⴰⵟⴰ, ⵅ ⵃⵓⵍⵓⵏ, ⵅ ⵢⴰⵃⵚⴰ, ⵅ ⵎⴰⵢⴼⴰⵄⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("JR48_22","025_48_22","JER","48","22","22","ⵅ ⴷⵉⴱⵓⵏ, ⵅ ⵏⴰⴱⵓ, ⵅ ⴱⴰⵢⵜ-ⴷⴰⴱⵍⴰⵜⴰⵢⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JR48_23","025_48_23","JER","48","23","23","ⵅ ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ, ⵅ ⴱⴰⵢⵜ-ⵊⴰⵎⵓⵍ, ⵅ ⴱⴰⵢⵜ-ⵎⴰⵄⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("JR48_24","025_48_24","JER","48","24","24","ⵅ ⵇⴰⵔⵢⵓⵜ ⵓ ⵅ ⴱⵓⵚⵔⴰ, ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵜⵉⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴷ ⵜⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_25","025_48_25","JER","48","25","25","ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵢⵉⵛⵛ ⵏ ⵎⵓ’ⴰⴱ, ⵢⴰⵔⴻⵥ ⵓⵖⵉⵍ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR48_26","025_48_26","JER","48","26","26","“ⵙⵛⴰⵔⴻⵎ ⵜ ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⴼⴼⴰⵔ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴽⴻⴱⴱⴰⵔ. ⴰⴷ ⵉⵡⴹⴰ ⵎⵓ’ⴰⴱ ⴷⴻⴳ ⵉⵄⵓⵇⵇⴰⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉ ⵜⵙⴻⴹⵃⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JR48_27","025_48_27","JER","48","27","27","ⵏⵉⵖ ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⵙⵔⴰⵉⵍ ⵉ ⵜⵙⴻⴹⵃⴰⵛⵜ ⵉ ⵛⴻⴽ? ⵎⴰ ⵟⵟⴼⴻⵏ ⵜ ⵣⴻⵄⵎⴰ ⵊⴰⵔ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵄⴻⵢⵢⴰⴱⴻⴷ ⵜ ⴰⵎ ⵜⴻⵙⵙⴻⵏⵀⴻⵣⵣⵉⴷ ⴰⵣⴻⴵⵉⴼ ⵎⴻⵍⵎⵉ ⵎⴰ ⵉⵡⴹⴰ ⴰⵛ-ⴷⴷ ⵅ ⵢⵉⵍⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JR48_28","025_48_28","JER","48","28","28","ⴼⴼⵖⴻⵎ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ, ⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵍⴻⵊⵔⵓⴼ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵎⵓ’ⴰⴱ! ⴳⴳⴻⵎ ⴰⵎ ⵜⴻⴷⴱⵉⵔⵜ ⵉ ⵉⴳⴳⵉⵏ ⵍⵄⵓⵛⵛ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵢⴻⴼⵔⵉ ⵉⵜⵜⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_29","025_48_29","JER","48","29","29","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵅ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵎⵓ’ⴰⴱ, ⴷⴰⵢⴻⵙ ⵏⵏⴼⴰⵅⴻⵜ ⴰⵟⵟⴰⵙ: ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵙ, ⴰⵄⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ ⴷ ⵡⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵓⵄⵍⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR48_30","025_48_30","JER","48","30","30","“ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵣⵣⵄⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵍⵖⴻⵛⵛ ⵏ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_31","025_48_31","JER","48","31","31","ⵅ ⵓⵢⴰ ⵉ ⵖⴰ ⵡⵜⴻⵖ ⴰⴳⴻⵊⴷⵓⵔ ⵅ ⵎⵓ’ⴰⴱ, ⵅ ⵎⴰⵔⵔⴰ ⵎⵓ’ⴰⴱ ⴰⴷ ⵙⵖⵓⵢⴻⵖ, ⴰⴷ ⵣⴻⵀⵀⴰⵔⴻⵏ ⵅ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵇⵉⵔ-ⵃⴰⵔⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JR48_32","025_48_32","JER","48","32","32","ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏ ⵢⴰⵄⵣⵉⵔ ⴰⴷ ⵅⴰⵎ ⵔⵓⵖ, ⴰ ⵛⴻⵎ ⵜⵣⴰⵢⴰⵔⵜ ⵏ ⵙⵉⴱⵎⴰ. ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵎ ⵄⴷⵓⵏ ⵍⴻⴱⵃⴰⵔ, ⵉⵡⴹⴻⵏ-ⴷⴷ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵊⴰⵄⵣⵉⵔ. ⵢⵓⵙⴰ-ⴷⴷ ⵎⴰⵛⴰ ⵓⵎⵜⴻⵃⵃⴰⵢ ⵉⵀⵊⴻⵎ ⵅ ⵜⵉⵏⵉ ⵏⵏⴻⵎ ⵏ ⵓⵏⴻⴱⴷⵓ ⵓⵍⴰ ⵅ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵎ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR48_33","025_48_33","JER","48","33","33","ⵜⵔⵓⵃ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵡⴻⵔⵛⴰⵇ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⵙⴻɣ̮ⵎⴰⵢⴻⵏ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵎⵉⵏⵣⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ ⴱⵉⵏⵓ ⵣⵉ ⵜⴻⵢⵙⵉⵔⵉⵏ ⵏ ⵓⴹⵉⵍ. ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⴰⴷ ⴷⴷⵣⴻⵏ ⵄⴰⴷ ⴰⴹⵉⵍ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ. ⴰⵙⵍⵉⵡⵍⴻⵡ? ⵛⴼⴰ ⵓⵙⵍⵉⵡⵍⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("JR48_34","025_48_34","JER","48","34","34","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵃⴰⵛⴱⵓⵏ ⴰⵍ ⴰⵍⵉⵄⴰⵍⴰ, ⴰⵍ ⵢⴰⵀⴰⵚ, ⵡⴰⵀ, ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵣⵉ ⵚⵓⵄⴰⵔ ⴰⵍ ⵃⵓⵔⵓⵏⴰⵢⵉⵎ, ⵜⴰⵄⴻⵊⵎⵉⵜ ⵏⵏⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵎⴰⵖⴰⵔ ⵄⴰⴷ ⴰⵎⴰⵏ ⵏ ⵏⵉⵎⵔⵉⵎ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵢⴻⵔⵎⴰⵎⴻⵏ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_35","025_48_35","JER","48","35","35","ⵡⴻⵏⵏⵉ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⴷⵉ ⵍⴻⴳⵄⵓⴷⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵎⵓ’ⴰⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR48_36","025_48_36","JER","48","36","36","“ⵅ ⵓⵢⴰ ⵉⵜⵜⵄⴻⴼⴼⴰⵔ ⵡⵓⵍ ⵉⵏⵓ ⵅ ⵎⵓ’ⴰⴱ ⴰⵎ ⵜⴻⵎⵊⴰ, ⵓⵍ ⵉⵏⵓ ⵉⵜⵜⵄⴻⴼⴼⴰⵔ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵇⵉⵔ-ⵃⴰⵔⵉⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵊⴰ, ⵎⵉⵏⵣⵉ ⴰⴼⴻⵢⵢⴻⴹ ⵏⵏⵉ ⵉⴽⵙⴻⴱ, ⴰⵇⴰ ⵉⵡⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR48_37","025_48_37","JER","48","37","37","ⵇⴰⵄ ⵉⵣⴻⴵⵉⴼⴻⵏ ⴷ ⵉⵇⴻⵛⵛⵓⵔⴰ ⵓ ⵇⴰⵄ ⵜⵉⵎⵉⵔⴰ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏⵜ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⵉⵇⴻⵙⵙⵉⵜⴻⵏ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⵉ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵙⴻⵏ ⴰⵇⴰ ⵜⴰⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_38","025_48_38","JER","48","38","38","ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵖⵡⵉⵏ ⵏ ⵎⵓ’ⴰⴱ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵎⴰⵏⵉ ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵔⵥⵉⵖ ⵎⵓ’ⴰⴱ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⴰⵔⴹⴰ ⵄⴰⴷ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR48_39","025_48_39","JER","48","39","39","ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵡⵡⴻⵜ ⵎⵓ’ⴰⴱ, ⵎⴰⵎⵎⴻⵛ ⵙⵙⵖⵓⵢⵢⵓⵏ ⵏⵉⵜⵏⵉ. ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵙⴻⵏ ⴷ ⵢⴰⵔⵔⴰ ⵎⵓ’ⴰⴱ ⵙ ⵡⴻⵄⵔⵓⵔ ⵙ ⵓⵙⴻⴹⵃⵉ! ⵎⵓ’ⴰⴱ ⵉⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵙⵜⴻⵀⵣⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵓⵙⵏⴻⵅⵍⵉⵄ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR48_40","025_48_40","JER","48","40","40","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ ⴰⴷ ⵉⵃⴻⵡⵡⴻⵎ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⴰⴷ ⵉⴱⴻⵣⵣⴻⵄ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵏ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JR48_41","025_48_41","JER","48","41","41","ⵇⴰⵔⵢⵓⵜ ⵟⵟⴼⴻⵏ ⵜ ⵓⵛⴰ ⵖⴻⵍⴱⴻⵏ ⵅ ⵍⵇⴻⵍⵄⴰⵜ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵡⵓⵍ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⵎⵓ’ⴰⴱ ⴰⵎ ⵡⵓⵍ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_42","025_48_42","JER","48","42","42","ⵎⵓ’ⴰⴱ ⴰⴷ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⵍⴳⴻⵏⵙ ⵎⴰⵖⴰⵔ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR48_43","025_48_43","JER","48","43","43","ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵡⴻⵏⴷⴰⵢ ⴷ ⵍⴼⴻⵅ ⴰⴷ ⵅⴰⴽ ⵉⵍⵉⵏ, ⴰ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⵓ’ⴰⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR48_44","025_48_44","JER","48","44","44","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ, ⵓ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵙⵔⴰⴼⵜ, ⴰⴷ ⵉⵏⵏⴰⵖ ⴷⵉ ⵍⴼⴻⵅ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⵢⴻⵖ ⵅ ⵎⵓ’ⴰⴱ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵡⴻⵅⵍⴰⴼ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR48_45","025_48_45","JER","48","45","45","“ⴷⵉ ⵜⵉⵍⵉ ⵏ ⵃⴰⵛⴱⵓⵏ ⵇⵇⵉⵎⴻⵏ ⵉⵎⴰⵔⵡⴰⵍ ⵜⵜⴱⴻⴷⴷⴰⵏ ⴱⵍⴰ ⵊⵊⴻⵀⴷ, ⵎⴰⵖⴰⵔ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵃⴰⵛⴱⵓⵏ, ⵉⵊⵊ ⵏ ⵓⵀⴰⴷⵓⵇ ⵣⵉ ⵙⵉⵃⵓⵏ, ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵛⵛⴰ ⵍⵃⴻⵏⴽⴰⵜ ⵏ ⵓⵣⴻⴵⵉⴼ ⵎⵓ’ⴰⴱ ⴷ ⴰⵛⴻⵇⵇⵓⴼ ⵏ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JR48_46","025_48_46","JER","48","46","46","ⵓⵛⵜ ⵅⴰⴽ, ⵎⵓ’ⴰⴱ, ⴰⵇⴰ ⵉⵅⵙⴰⵔ ⵍⴳⴻⵏⵙ ⵏ ⴽⴰⵎⵓⵛ, ⵎⴰⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵢⴻⵙⵙⵉⵛ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR48_47","025_48_47","JER","48","47","47","ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵎⵓ’ⴰⴱ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ⴰⵍ ⴷⴰⵏⵉⵜⴰ ⵉⴵⴰ ⵡⴰⵡⴰⵍ ⵉ ⵢⵓⵔⵉⵏ ⵅ ⵍⵃⵓⴽⵎ ⵅ ⵎⵓ’ⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JR49_1","025_49_1","JER","49","1","1","ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵎⴰ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ? ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⴰⵡⵔⵉⵜ? ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵓⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵊⴰⴷ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵊⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("JR49_2","025_49_2","JER","49","2","2","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵓⵙⵙⴰⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵊⵊⴻⵖ ⴰⴷ ⵜⵜⵡⴰⵙⵍⴻⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵔⴰⴱⴱⴰ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏ ⵍⵅⴰⵔⴱⴻⵜ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⵇⵇⴷⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵡⴰⵔⵜ ⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⴽⴽⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR49_3","025_49_3","JER","49","3","3","ⵔⵓ, ⴰ ⵃⴰⵛⴱⵓⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵄⴰⵢ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵙⵖⵓⵢⵢⴻⵏⵜ, ⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵢⴻⵙⵙⵉⵙ ⵏ ⵔⴰⴱⴱⴰ, ⵃⴻⵣⵣⵎⴻⵏⵜ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵛⴻⴹⵏⴻⵏⵜ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏⵜ ⵖⴰⵔ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵛⴱⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ, ⵎⵉⵍⴽⵓⵎ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JR49_4","025_49_4","JER","49","4","4","“ⵎⴻⵛⵃⴰⵍ ⵜᵉⵜⵜⴼⴻⵢⵢⵛⴻⴷ ⵙ ⵍⴻⵡⴹⴰⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵉⵏ ⵏⵏⴻⵎ, ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵍⴻⵡⴹⴰ ⵏⵏⴻⵎ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⴰ ⵛⴻⵎ ⵢⴻⴵⵉⵙ ⵉⴽⴼⴰⵔⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵜⴻⵇⵇⴰⵔ: ‘ⵡⵉ ⴷⴷ ⵖⴰⵔⵉ ⵉ ⵖⴰ ⵉⵇⴰⵔⵔⴱⴻⵏ?’ ");
INSERT INTO rift_vpl VALUES ("JR49_5","025_49_5","JER","49","5","5","ⵅⵣⴰⵔ, ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⵖⴻⴹⵔⴻⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵎ, ⴽⵓⵍ ⵉⵊⵊ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵎⵓⵏⴻⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR49_6","025_49_6","JER","49","6","6","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR49_7","025_49_7","JER","49","7","7","ⵅ ⵉⴷⵓⵎ “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵄⴰⴷ ⵜⵉⵖⵉⵜ ⴷⵉ ⵜⵉⵢⵎⴰⵏ? ⵎⴰ ⵉⴱⴹⴻⵍ ⵛⵛⵡⴰⵔ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ? ⵎⴰ ⵜⴹⴻⵢⵢⴻⵄ ⵜⵉⵖⵉⵜ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR49_8","025_49_8","JER","49","8","8","ⴰⵔⴻⵡⵍⴻⵎ, ⴷⴻⵡⵍⴻⵎ, ⴼⴼⴰⵔⴻⵎ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵢⵓⴵⵖⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴰⴷⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴰⵡⵢⴻⵖ ⴰⴹⴻⵢⵢⴻⵄ ⵏ ⵄⵉⵙⵓ, ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⵉ ⴰⴷ ⵜ ⵄⴰⵇⴱⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR49_9","025_49_9","JER","49","9","9","ⵎⴰⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵉⵎⴻⵍⵇⴰⴹ ⵏ ⵓⴹⵉⵍ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏ ⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ? ⵎⴰⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ ⵙ ⴵⵉⵍⴻⵜ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴹⴻⵢⵢⵉⵄⴻⵏ ⴰⵍ ⵖⴰ ⵊⵊⵉⵡⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JR49_10","025_49_10","JER","49","10","10","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵇⴻⵛⵛⴰⵔⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵄⵉⵙⵓ, ⵄⴰⵔⵔⵉⵖ ⵅ ⵉⵎⵓⵛⴰⵏ ⵏⵏⴻⵙ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵄⴰⴷ ⴰⴷ ⵉⵏⵏⵓⴼⴼⴰⵔ. ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JR49_11","025_49_11","JER","49","11","11","ⴻⵊⵊ ⵉⵢⵓⵊⵉⵍⴻⵏ ⵏⵏⴻⵛ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵃⴹⵉⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ, ⵜⵉⵊⵊⴰⵍ ⵏⵏⴻⵛ ⴻⵊⵊ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⵅⴰⴼⵉ ⵜⵜⴻⵛⵍⴻⵏⵜ.’ ");
INSERT INTO rift_vpl VALUES ("JR49_12","025_49_12","JER","49","12","12","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵜ ⵉⵙⵙⴷⵉⵀⴻⴵⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⵣⵉ ⵍⴽⴰⵙ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵡⴻⵏ. ⵓ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⴷⴰⵀⴻⴵⴻⵏ, ⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⵔⵉⴷ? ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⵔⵉⴷ ⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵡⴻⴷ ⵙ ⵓⵖⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JR49_13","025_49_13","JER","49","13","13","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵊⵊⵓⴵⴻⵖ ⵖⴰⵔ ⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴱⵓⵚⵔⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵍⵃⴻⴳⵔⴰ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⵉⵔⴱⴻⵜ ⴷ ⵏⵏⴻⵄⵍⴻⵜ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⵉⵔⴱⴰⵜ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("JR49_14","025_49_14","JER","49","14","14","“ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵙⵎⵓⵏⴻⵎ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⵅⴰⵙ, ⴽⴽⴰⵔⴻⵎ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ!’ ");
INSERT INTO rift_vpl VALUES ("JR49_15","025_49_15","JER","49","15","15","ⵎⵉⵏⵣⵉ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⵎⵥⵉⵢⴻⵖ ⵛⴻⴽ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵊⴰⵔ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR49_16","025_49_16","JER","49","16","16","ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵛ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵜⵖⴰⵔⵔ ⵉ ⵛⴻⴽ ⵓⵍⴰ ⴷ ⵣⵣⵄⴰⵎⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ, ⴰ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⴼⴻⴵⵉⵇⴻⵏ ⵏ ⵍⴻⵊⵔⵓⴼ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵜⴻⵡⵔⵉⵔⵉⵏ! ⵡⴰⵅⵅⴰ ⵜⴻⴳⴳⵉⴷ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵛ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ ⴰⵎ ⵜ ⵉⵜⵜⴻⴳⴳ ⵓⴳⵉⴷⴻⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵖⴻⴹⵍⴻⵖ ⵙⵙⴻⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR49_17","025_49_17","JER","49","17","17","ⵉⴷⵓⵎ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ. ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⴷⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⴽⴽⴻⵏ, ⴰⴷ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵓ ⴰⴷ ⵉⵚⴻⴼⴼⴰⵔ ⵙ ⵡⴻⵙⵔⵓⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR49_18","025_49_18","JER","49","18","18","ⴰⵎ ⵖⴰⵔ ⵓⵏⴻⵇⵍⴻⴱ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵢⵓⴷⵙⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JR49_19","025_49_19","JER","49","19","19","ⵅⵣⴰⵔ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵢⵔⴰⴷ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵛⴱⴰⵔⵇ ⵉⵇⵇⵏⴻⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴹⵉⴷⴷ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⴰⴷ ⴰⵣⵣⴻⵍ ⵙⵙⴻⵏⵏⵉ, ⵓ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴼⴰⵔⵣⴻⵖ, ⴰⴷ ⵅⴰⵙ ⵜ ⴰⵔⴻⵛⵛⵃⴻⵖ. ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴰⵎ ⵏⴻⵛⵛ, ⵎⴰⵏ ⵡⴻⵏ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵉⵍⴰⵖⴰⵏ ⵉ ⴷⴷⴻⵄⵡⴻⵜ? ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⵉ ⵉⴱⴻⴷⴷ? ");
INSERT INTO rift_vpl VALUES ("JR49_20","025_49_20","JER","49","20","20","ⵙ ⵓⵢⴰ, ⵙⵍⴻⵎ ⵉ ⵓⵛⴰⵡⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵇⴹⴻⵄ ⵅ ⵉⴷⵓⵎ, ⵓ ⵙⵍⴻⵎ ⵉ ⵉⵏⵡⴰⵢⴻⵏ ⵏⵏⵉ ⵉⵅⴰⵔⵔⴻⵚ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴰⵢⵎⴰⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⵏⵏⵉ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⵓⴵⵉ ⴰⴷ ⵜⴻⵏ ⵊⴰⵔⵔⴻⵏ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵅⵍⴻⵄ!’ ");
INSERT INTO rift_vpl VALUES ("JR49_21","025_49_21","JER","49","21","21","ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵙⴻⵏ, ⵙ ⵜⵖⵓⵢⵢⵉⵜ ⵉ ⵣⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵃⴻⵙⵙ ⵏⵏⴻⵙ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⴻⵍⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("JR49_22","025_49_22","JER","49","22","22","ⵅⵣⴰⵔ, ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⵜⵜⴻⵃⵔⴰⵔⴰ, ⵉⵜⵜⴱⴻⵣⵣⴰⵄ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵏ ⴱⵓⵚⵔⴰ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵡⵓⵍ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⵉⴷⵓⵎ ⴰⵎ ⵡⵓⵍ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⵍⴻⵃⵔⵉⵇ ⵏ ⵜⴰⵔⵡⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR49_23","025_49_23","JER","49","23","23","ⵅ ⴷⵉⵎⴰⵛⵇ “ⵃⴰⵎⴰⵜ ⴷ ⴰⵔⴼⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⵉ ⵡⴰⵔⴻⵇⵇⴰⵙ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⴼⴻⵛⵍⴻⵏ. ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵜᵉⵜⵜⵡⴰⴼ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵙⴰ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR49_24","025_49_24","JER","49","24","24","ⵜⴰⵔⵅⵓ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⵉⵎⴰⵛⵇ, ⵜⴻⵏⵏⴻⵇⵍⴻⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⴷⵉ ⵜⴰⵔⴻⵡⵍⴰ. ⵉⵎⵏⴻⵄ ⵉ-ⵜⵜ ⵓⵇⴷⵉⴷⴷⴻⵙ. ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⵍⴻⵡⵊⴻⵄ ⴰⵎ ⵏ ⵉⵛⵜ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ ⵟⵟⴼⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JR49_25","025_49_25","JER","49","25","25","ⵜⴰⵏⴷⵉⵏⵜ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵎⴰ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⴰⵎ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("JR49_26","025_49_26","JER","49","26","26","ⵙ ⵓⵢⴰ ⴰⴷ ⵡⴹⴰⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⴻⵖⴷⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR49_27","025_49_27","JER","49","27","27","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⴷⵉⵎⴰⵛⵇ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏ ⴱⵉⵏⵀⴰⴷⴰⴷ.” ");
INSERT INTO rift_vpl VALUES ("JR49_28","025_49_28","JER","49","28","28","ⵅ ⵡⴻⵄⵔⴰⴱⴻⵏ ⵅ ⵇⵉⴷⴰⵔ ⴷ ⵜⴳⴻⵍⴷⵉⵜⵉⵏ ⵏ ⵃⴰⵚⵓⵔ ⵏⵏⵉ ⵉⵖⵍⴻⴱ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴽⴽⴰⵔⴻⵎ ⵓⵛⴰ ⵀⴻⵊⵎⴻⵎ ⵅ ⵇⵉⴷⴰⵔ ⵓⵛⴰ ⴰⵔⴻⴷⴷⴵⴻⵎ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("JR49_29","025_49_29","JER","49","29","29","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⴽⴽⵙⴻⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷ ⵡⵓⴵⵉ ⵏⵙⴻⵏ, ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵏ ⵓⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵛⵛ ⵏⵙⴻⵏ. ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ. ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵖⵓⵢⴻⵏ: ⴰⵙⵉⴳⴳⵯⴻⴷ ⵎⴰⵏⵉ ⵎⴰ! ");
INSERT INTO rift_vpl VALUES ("JR49_30","025_49_30","JER","49","30","30","ⴰⵔⴻⵡⵍⴻⵎ, ⴱⴻⵄⵄⴷⴻⵎ, ⴼⴼⴰⵔⴻⵎ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵢⵓⴵⵖⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵃⴰⵚⵓⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵇⴹⴻⵄ ⵅⴰⵡⴻⵎ ⴰⵛⴰⵡⴰⵔ ⵓⵛⴰ ⵉⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵏⵡⴰⵢ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR49_31","025_49_31","JER","49","31","31","ⴽⴽⴰⵔⴻⵎ, ⴳⴻⵄⵄⴷⴻⵎ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⵓ ⴷⵉ ⵍⴰⵎⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⴻⵡⵡⵓⵔⴰ ⵓⵍⴰ ⴷ ⵣⵣⴻⵏⴽⵔⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR49_32","025_49_32","JER","49","32","32","ⵉⵍⴻⵖⵎⴰⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵡⵡⵙⴻⵏ ⵓⵛⴰ ⴰⴱⴰⵔⵔⵓ ⵏ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ ⵏ ⵍⵎⴰⵍ ⴰⴷ ⵜⵜⵡⴰⵛⴰⵔⴻⵏⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵃⴻⴼⴼⴰⵏ ⴰⵛⵓⵡⵡⴰⴼ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ, . ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⴹⴻⵢⵢⴻⵄ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR49_33","025_49_33","JER","49","33","33","ⵀⴰⵚⵓⵔ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR49_34","025_49_34","JER","49","34","34","ⵅ ⵄⵉⵍⴰⵎ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵅ ⵄⵉⵍⴰⵎ, ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JR49_35","025_49_35","JER","49","35","35","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⵍⵇⴻⵡⵙ ⵏ ⵄⵉⵍⴰⵎ, ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("JR49_36","025_49_36","JER","49","36","36","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⵅ ⵄⵉⵍⴰⵎ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ. ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⵍⴳⴻⵏⵙ ⵎⴰⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⴻⵏ ⵉⵏⵏⵉ ⵅ ⵓⵥⵥⵍⴻⵏ ⵣⵉ ⵄⵉⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JR49_37","025_49_37","JER","49","37","37","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵅⵍⵄⴻⵖ ⴰⵢⵜ ⵏ ⵄⵉⵍⴰⵎ ⵣⵣⴰⵜ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵓ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵖⴻⴹⵍⴻⵖ ⵍⵖⴰⵔ ⵅⴰⵙⴻⵏ, ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⴻⴹⴼⴰⵔⴻⵖ ⵙⵙⵉⴼ ⴰⵍ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JR49_38","025_49_38","JER","49","38","38","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵄⴰⵔⵛ ⵉⵏⵓ ⴷⵉ ⵄⵉⵍⴰⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⴰⵊⴻⴵⵉⴷ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵙⵙⴻⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR49_39","025_49_39","JER","49","39","39","ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵄⵉⵍⴰⵎ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("JR50_1","025_50_1","JER","50","1","1","ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⵅ ⴱⴰⴱⵉⵍ, ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR50_2","025_50_2","JER","50","2","2","“ⴱⴰⵔⵔⵃⴻⵎ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵊⵊⴻⵎ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵄⴻⴵⴰⵏⵜ, ⵊⵊⴻⵎ ⴰⴷ ⴰⵙ ⵙⵍⴻⵎ, ⵡⴰⵔ ⵜⵜ ⵙⵏⵓⴼⴼⴰⵔⴰⵎ. ⵉⵏⵉⵎ: ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ, ⴱⵉⵍ ⵉⵙⴻⴹⵃⴰ, ⵎⴰⵔⵓⴷⴰⵅ ⴰⵇⴰ ⵢⴰⵔⵥⴰ, ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵜⵜⵡⴰⴱⴰⵔⵇⴻⵏ, ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JR50_3","025_50_3","JER","50","3","3","ⵎⴰⵖⴰⵔ ⵉⵀⵊⴻⵎ-ⴷⴷ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⴰⴷ ⵢⴰⵔⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⴰⵍ ⵍⵎⴰⵍ ⴰⵔⴻⵡⵍⴻⵏ, ⴼⴼⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR50_4","025_50_4","JER","50","4","4","“ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⵎ ⵜⵜⵔⵓⵏ, ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_5","025_50_5","JER","50","5","5","ⵅ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ, ⴰⵇⴰ ⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵉ ⵏⴹⴰⵔⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵙ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵜⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_6","025_50_6","JER","50","6","6","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵓⴵⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴻⵏⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵅ ⵉⴷⵓⵔⴰⵔ ⵉⴽⴼⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏⵜ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⴰⵍ ⵜⴻⵡⵔⵉⵔⵜ, ⵜⵜⵓⵏⵜ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR50_7","025_50_7","JER","50","7","7","ⵎⴰⵔⵔⴰ ⵡⵉ ⵜⴻⵏⵜ ⵢⵓⴼⵉⵏ, ⵛⵛⵉⵏ ⵜⴻⵏⵜ ⵓⵛⴰ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏⵜ ⵏⵏⴰⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴰⵔⵙ ⵃⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵅⴹⴰⵏⵜ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⴽ-ⴷ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵜⵙⴻⴳⴷⴰ, ⴰⴽ-ⴷ ⵍⴰⵢⴰⵙ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏⵜ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("JR50_8","025_50_8","JER","50","8","8","ⴰⵔⵡⵍⴻⵎ ⵣⵉ ⴱⴰⴱⵉⵍ, ⴼⴼⵖⴻⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵉⵍⵉⵎ ⴰⵎ ⵢⵉⵖⴰⵢⴹⴻⵏ ⵉⵜⵜⵉⵣⵡⴰⵔⴻⵏ ⵉ ⵡⵓⴵⵉ!” ");
INSERT INTO rift_vpl VALUES ("JR50_9","025_50_9","JER","50","9","9","“ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⴰⴷ ⴷⴷ-ⵙⵙⵃⴰⵔⵔⵛⴻⵖ ⵅ ⴱⴰⴱⵉⵍ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ. ⴼⵍⵉⵜⵛⴰⵜ ⵏⵙⴻⵏ ⴰⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵍⵓⴹⵜ ⵉⵎⴻⵃⴹⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴷ-ⵜⵄⵉⵇⵇⵉⴱ ⵜⴻⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JR50_10","025_50_10","JER","50","10","10","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⴽⴻⵛⵛⴹⴻⵏ, ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR50_11","025_50_11","JER","50","11","11","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴼⴰⵔⵃⴻⵎ, ⴰⵇⴰ ⵜⵏⴻⴳⴳⵣⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴽⴻⵛⵛⴹⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ. ⴽⴻⵏⵏⵉⵡ ⵜⵏⴻⴷⵡⴻⵎ ⴰⵎ ⵜⵄⴻⵊⵎⵉⵢⵢⵉⵏ ⴷⵉ ⴷⴷⴻⵎⵏⴻⵜ ⵓ ⵜⴻⵙⵙⵏⴻⵃⵏⵉⵃⴻⵎ ⴰⵎ ⵢⴻⵢⵙⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_12","025_50_12","JER","50","12","12","ⵜⵙⴻⴹⵃⴰ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ, ⵜⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ, ⴰⵇⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜⵜ ⵓⵙⴻⵃⵛⴻⵎ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵏ ⵍⴻⴳⵏⵓⵙ: ⵎⵖⵉⵔ ⴷ ⵍⴻⵅⵍⴰ ⴷ ⵍⴻⴽⵃⴻⴹ ⴷ ⵜⴰⵏⴻⵣⵔⵓⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("JR50_13","025_50_13","JER","50","13","13","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵄⴷⵓⵏ ⵅ ⴱⴰⴱⵉⵍ ⴰⴷ ⵉⵏⵏⴻⵅⵍⴻⵄ, ⴰⴷ ⵉⵚⴻⴼⴼⴰⵔ ⵙ ⵓⵄⴻⵢⵢⴻⴱ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR50_14","025_50_14","JER","50","14","14","“ⵙⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴱⴰⴱⵉⵍ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵍⵇⴻⵡⵙ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵅⴹⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR50_15","025_50_15","JER","50","15","15","ⵙⵖⵓⵢⵢⴻⵎ ⵅⴰⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵙⴻⵍⵍⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵡⴹⴰⵏ ⵍⴱⵓⵔⵊⴰⵜ ⵏⵏⴻⵙ, ⵀⴻⴷⵎⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵡⴰ ⴷ ⵏⵏⴻⵇⵎⴻⵜ ⵏ ⵙⵉⴷⵉ. ⵅⴻⵍⴼⴻⵎ ⵣⵣⴰⵢⴻⵙ, ⴳⴳⴻⵎ ⵣⵣⴰⵢⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⴳⴳⴰ ⵏⴻⵜⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR50_16","025_50_16","JER","50","16","16","ⴽⴽⵙⴻⵎ ⴰⵣⴰⵔⵔⴰⵄ ⵣⵉ ⴱⴰⴱⵉⵍ ⴷ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴰⵎⵊⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⵊⵔⴰ! ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵙⵉⴼ ⵉⵇⴻⵙⵃⴻⵏ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR50_17","025_50_17","JER","50","17","17","“ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⵉ ⵅⴻⴼ ⵓⵥⵥⵍⴻⵏ, ⵜⴻⵏⵏⵉ ⵅ ⵄⴻⵔⴼⴻⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ. ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵉⵙⴰⵔⴹ ⵉ-ⵜⵜ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⴷⴷⴻⵣ ⴰⵙ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR50_18","025_50_18","JER","50","18","18","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴻⵍⴼⴻⵖ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JR50_19","025_50_19","JER","50","19","19","ⵉⵙⵔⴰⵉⵍ ⵎⴰⵛⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⵅ ⴽⴰⵔⵎⴰⵍ ⴷ ⴱⴰⵛⴰⵏ, ⴰⴷ ⵜⴻⵊⵊⴰⵡⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵊⵉⵍⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("JR50_20","025_50_20","JER","50","20","20","“ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵍⵄⵉⴱ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⵓ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵉⴼⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⴰⵔⵔⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵖⴼⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR50_21","025_50_21","JER","50","21","21","ⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⴰⵔⴰⵜⴰⵢⵉⵎ, ‘ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵓⵖⴻⵡⵡⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ’, ⵓ ⴹⵉⴷⴷ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴼⴰⵇⵓⴷ, ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵡⴻⵅⵍⴻⴼ’. ⴰⵔⴻⴷⴷⴻⴵ ⵓ ⵃⴰⵔⵔⴻⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉ ⵓⵜⴻⵃⵃⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⴻⴳⴳ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR50_22","025_50_22","JER","50","22","22","“ⴰⵇⴰ ⴷⴰ, ⵉⵜⵜⵡⴰⵙⴻⵍ ⵍⵀⴰⵔⴰⵊ ⵏ ⵓⵎⴻⵏⵖⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵛⵜ ⵏ ⵍⵎⵓⵚⵉⴱⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR50_23","025_50_23","JER","50","23","23","ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵓ ⵉⵜⵜⵡⴰⵔⵥ ⵡⴻⴼⴹⵉⵙ ⵏ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ! ⵎⴰⵎⵎⴻⵛ ⵉⴷⵡⴻⵍ ⴱⴰⴱⵉⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("JR50_24","025_50_24","JER","50","24","24","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵎ, ⴰ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵓⵛⴰ ⵜⴻⵊⵊⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⴷ ⵛⴻⵎ ⴳⴳⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵜⵓⵛⵉⴷ. ⵓⴼⵉⵏ ⴷ ⵟⵟⴼⴻⵏ ⵓⵍⴰ ⴷ ⵛⴻⵎ, ⵎⴰⵖⴰⵔ ⵛⴻⵎ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵎⵄⴰⵔⵔⵉⴷ ⴰⴽ-ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR50_25","025_50_25","JER","50","25","25","ⵙⵉⴷⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵅⵅⴰⵎ ⵏⵏⴻⵙ ⵏ ⵜⵅⵓⴱⴰⵢ ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⴷⴷⵓⵣⴰⵏ ⵏ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_26","025_50_26","JER","50","26","26","ⴰⵣⵣⵍⴻⵎ ⵖⴰⵔⴻⵙ ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵔⵣⵎⴻⵎ ⵍⴻⵅⵣⴰⵢⴻⵏ ⵏⵏⴻⵙ, ⵏⴹⴰⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵅ ⵉⵄⵓⵔⵔⵉⵛⴻⵏ ⵢⵓⵄⵍⴰⵏ ⵓⵛⴰ ⵃⴰⵔⵔⵎⴻⵎ ⵜⴻⵏ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵃⴹⴰⵎ ⵎⵍⵉⵃ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JR50_27","025_50_27","JER","50","27","27","ⵏⵖⴻⵎ ⵎⴰⵔⵔⴰ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵙⴻⵀⵡⴰⵎ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵜⵖⴰⵔⵚⵜ. ⵓⵛⵜ ⵅⴰⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏⵙⴻⵏ ⵢⵉⵡⴻⴹ-ⴷⴷ, ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵄⴰⵇⴻⴱ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("JR50_28","025_50_28","JER","50","28","28","ⴰⵇⴰ ⴷⴰ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵉⵎⴰⵔⵡⴰⵍⴻⵏ ⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⴰⴱⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⴰⵅⵍⴰⴼ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴰⵅⵍⴰⴼ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR50_29","025_50_29","JER","50","29","29","“ⵍⴰⵖⴰⵎ ⵉ ⴰⵢⵜ ⵏ ⵍⵇⴻⵡⵙ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵊⴻⴱⴱⴷⴻⵏ ⵍⵇⴻⵡⵙ! ⵃⵚⴰⵔⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵃⴹⴰⵎ ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵏⵊⴻⵎ. ⵅⴻⵍⴼⴻⵎ ⵜⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⴳⴳⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⴳⴳⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⴼⴼⵓⵛⵛⴻⵃ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⴽ-ⴷ ⵓⵎⵇⴻⴷⴷⴻⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR50_30","025_50_30","JER","50","30","30","ⵙ ⵓⵢⴰ ⴰⴷ ⵡⴹⴰⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵓⵙⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR50_31","025_50_31","JER","50","31","31","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵎ ⴽⴽⴰⵔⴻⵖ, ⴰ ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⴼⴼⵓⵛⵛⵃⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ ⵏⵏⴻⵎ ⵢⵉⵡⴻⴹ-ⴷⴷ, ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⴷⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵅⴻⴵⵚⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR50_32","025_50_32","JER","50","32","32","ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉⴼⴼⵓⵛⵛⵃⴻⵏ ⴰⴷ ⵉⵏⵇⴰⵔⴹ, ⴰⴷ ⵉⵡⴹⴰ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵉⵙⵙⴱⴻⴷⴷⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵇⵇⴷⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏⵜ-ⵉ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR50_33","025_50_33","JER","50","33","33","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ, ⵟⵟⴼⴻⵏ ⵜⴻⵏ, ⵓⴳⵉⵏ ⴰⴷ ⵊⵊⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⴰⵔⵅⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_34","025_50_34","JER","50","34","34","ⵎⴰⵛⴰ ⴰⵎⴻⴼⴷⵉ ⵏⵙⴻⵏ ⵉⵊⵀⴻⴷ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴳⴳⵓⵔ ⴰⴷ ⵉⵡⵡⴻⵜ ⵅ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⵀⵓⴷⵏⴻⵜ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴰⵔⵊⵉⵊ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⴱⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("JR50_35","025_50_35","JER","50","35","35","“ⵙⵙⵉⴼ ⵅ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⴱⵉⵍ, ⵅ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵓ ⵅ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR50_36","025_50_36","JER","50","36","36","ⵙⵙⵉⴼ ⵅ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵙⵙⵉⴼ ⵅ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_37","025_50_37","JER","50","37","37","ⵙⵙⵉⴼ ⵅ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵓⴱⴰⵔⵔⵓ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵙⵙⵉⴼ ⵅ ⵍⴻⴽⵏⵓⵣ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_38","025_50_38","JER","50","38","38","ⵍⴻⴽⵃⴻⴹ ⵅ ⵡⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵥⵖⴻⵏ, ⵎⴰⵖⴰⵔ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵣⵉ ⵏⵏⵄⴰⵡⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JR50_39","025_50_39","JER","50","39","39","ⵙ ⵓⵢⴰ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵢⵉⴼⵉⵙⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵏⵏⵄⴰⵎⴻⵜ ⴰⴷ ⵣⴻⴷⵖⴻⵏⵜ ⴷⵉⵏ. ⵉ ⵍⴻⴱⴷⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵣⴻⴷⴷⵖⴻⵏ ⵄⴰⴷ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR50_40","025_50_40","JER","50","40","40","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵙ ⵢⵓⴷⵙⴻⵏ, ⴰⵎⵎⵓ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR50_41","025_50_41","JER","50","41","41","“ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵔⵔⴻⵏ ⴰⴷ ⴼⴰⵇⴻⵏ ⵣⵉ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR50_42","025_50_42","JER","50","42","42","ⵏⵉⵜⵏⵉ ⵎⴻⵏⵏⵄⴻⵏ ⴷⵉ ⵍⵇⴻⵡⵙ ⴷ ⴼⵍⵉⵜⵛⴰ. ⵏⵉⵜⵏⵉ ⵜⵜⴻⵡⵄⴰⵔⴻⵏ, ⵡⴰⵔ ⴰⵔⵔⴻⵃⴻⵎⴻⵏ. ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵏⵉⵜⵏⵉ ⵏⵏⴰⵢⴻⵏ ⵅ ⵢⴻⵢⵙⴰⵏ. ⴰⵇⴰ ⵜⵜⵃⴻⵣⵣⴰⵎⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴰⴽⵉⴷⴻⵎ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("JR50_43","025_50_43","JER","50","43","43","ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵍⴻⵅⴱⴰⵔ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵟⵟⵙⴻⵏ. ⵜⴻⵟⵟⴻⴼ ⵉ-ⵜ ⵉ-ⴷⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵓⵍⴰ ⴷ ⵍⴻⵃⵔⵉⵇ ⴰⵎ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR50_44","025_50_44","JER","50","44","44","ⵅⵣⴰⵔ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵢⵔⴰⴷ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵛⴱⴰⵔⵇ ⵉⵇⵇⵏⴻⵏ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⴰⵣⵣⵍⴻⵏ ⵙⵙⴻⵏⵏⵉ, ⵓ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴼⴰⵔⵣⴻⵖ, ⴰⴷ ⵅⴰⵙ ⵜ ⴰⵔⴻⵛⵛⵃⴻⵖ. ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴰⵎ ⵏⴻⵛⵛ, ⵎⴰⵏ ⵡⴻⵏ ⵅⴰⴼⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵍⴰⵖⴰⵏ ⵉ ⴷⴷⴻⵄⵡⴻⵜ? ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⵉ ⵉⴱⴻⴷⴷ? ");
INSERT INTO rift_vpl VALUES ("JR50_45","025_50_45","JER","50","45","45","ⵙ ⵓⵢⴰ, ⵙⵍⴻⵎ ⵉ ⵓⵛⴰⵡⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵇⴹⴻⵄ ⵅ ⴱⴰⴱⵉⵍ ⵓ ⵙⵍⴻⵎ ⵉ ⵉⵏⵡⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⵅⴰⵔⵔⴻⵚ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⵏⵏⵉ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⵓⴵⵉ ⴰⴷ ⵜⴻⵏ ⵊⴰⵔⵔⴻⵏ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵅⵍⴻⵄ!’ ");
INSERT INTO rift_vpl VALUES ("JR50_46","025_50_46","JER","50","46","46","ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ ⵣⵉ ⵍⵃⴻⵙⵙ ⵏ ⵓⵟⴻⴼⴼⵓ ⵏ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⵖⵓⵢⵢⵉ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR51_1","025_51_1","JER","51","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵅ ⴱⴰⴱⵉⵍ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JR51_2","025_51_2","JER","51","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⴰⴷ ⵜⵜ ⵣⵓⵣⵣⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴼⴰⵔⴹⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵖⴰⵔ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_3","025_51_3","JER","51","3","3","ⴻⵊⵊ ⴰⵎⵊⴻⴱⴱⴰⴷ ⵏ ⵍⵇⴻⵡⵙ ⴰⴷ ⵉⵎⵃⴻⴹ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵃⴹⴻⵏ ⵍⵇⴻⵡⵙ ⵓ ⴹⵉⴷⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵡⵓⵣⵣⴰⵍ. ⵡⴰⵔ ⵜⵜⵃⵉⵡⵉⵍⴻⵎ ⵅ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ, ⵃⴰⵔⵔⵎⴻⵎ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵉ ⵓⵜⴻⵃⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("JR51_4","025_51_4","JER","51","4","4","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵡⴹⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵓ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵅⴰⵔⵔⵇⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("JR51_5","025_51_5","JER","51","5","5","“ⵎⴰⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵊⵊⴻⵏ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵣⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵎⴰⵔⵡⴰⵙ ⵖⴰⵔ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR51_6","025_51_6","JER","51","6","6","“ⴰⵔⴻⵡⵍⴻⵎ ⵣⵉ ⴱⴰⴱⵉⵍ, ⴻⵊⵊ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴽⵓⵍ ⵉⵊⵊ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴱⴻⴽⴽⵎⴻⵎ ⵉ ⵍⴻⴱⴷⴰ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵅⵍⴰⴼ ⵏ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵅⵍⴻⴼ ⵎⵉⵏ ⵜⴻⵙⴷⴰⵀⴻⴵ.” ");
INSERT INTO rift_vpl VALUES ("JR51_7","025_51_7","JER","51","7","7","“ⴱⴰⴱⵉⵍ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⵏ ⵡⵓⵔⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⵉⵙⵛⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵣⵉ ⴱⵉⵏⵓ ⵏⵏⴻⵙ ⵙⵡⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵅ ⵓⵢⴰ ⵉⴼⴼⴻⵖ ⵍⴻⵄⵇⴻⵍ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JR51_8","025_51_8","JER","51","8","8","ⴷⴻⵖⵢⴰ ⵜⴻⵡⴹⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵜᵉⵜⵜⵡⴰⵀⴷⴻⵎ. ⵡⵜⴻⵎ ⵅⴰⵙ ⴰⴳⴻⵊⴷⵓⵔ, ⴰⵡⵢⴻⵎ ⴰⵙ-ⴷⴷ ⴱⴰⵍⵙⴰⵎ ⵉ ⵍⴻⵃⵔⵉⵇ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR51_9","025_51_9","JER","51","9","9","“ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵏⴰⵡⵉ ⴰⴳⴻⵏⴼⵓ ⵉ ⴱⴰⴱⵉⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴰⴳⴻⵏⴼⵓ. ⵊⵊⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⵓ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵍⵃⵓⴽⵎ ⵅⴰⵙ ⵢⵉⵡⴻⴹ ⴰⵍ ⴰⵊⴻⵏⵏⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⴰⵍ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR51_10","025_51_10","JER","51","10","10","“ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⴹ-ⴷⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵖⴰⵔ ⵜⴼⴰⵡⵜ. ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵄⴰⵡⴻⴷ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JR51_11","025_51_11","JER","51","11","11","“ⵙⵇⴻⴹⵄⴻⵎ ⴼⵍⵉⵜⵛⴰⵜ, ⵟⵟⴼⴻⵎ ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ. ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽⴰⵔ-ⴷⴷ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⴰⴷⴰⵢ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵄⴻⵡⵡⴻⵍ ⴰⴷ ⵉⵀⴷⴻⵎ ⴱⴰⴱⵉⵍ, ⵎⴰⵖⴰⵔ ⵡⴰ ⴷ ⴰⵅⵍⴰⴼ ⵏ ⵙⵉⴷⵉ, ⴰⵅⵍⴰⴼ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR51_12","025_51_12","JER","51","12","12","ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵄⴻⴵⴰⵏⵜ ⵅ ⵍⴻⵃⵢⵓⴹ ⵏ ⴱⴰⴱⵉⵍ, ⵣⴻⵢⵢⴰⵔⴻⵎ ⵜⴰⵄⴻⵙⵙⴰⵙⵜ, ⵙⴱⴻⴷⴷⴻⵎ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⴳⴳⴻⵎ ⵍⴻⴼⵅⵓⵅ, ⵎⴰⵖⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵄⴻⵡⵡⴻⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⵏⴰ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR51_13","025_51_13","JER","51","13","13","ⵛⴻⵎ, ⴰ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵎⴰⵏⵉ ⵡⴻⵙⵄⴻⵏ ⵡⴰⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ, ⵇⴻⵟⵟⵓ ⵏⵏⴻⵎ ⵢⵉⵡⴻⴹ-ⴷⴷ, ⴰⵇⴰ ⵉⵛⵛⵓⵔ ⵍⵇⴻⴷⴷ ⵏ ⵟⵟⵎⴻⵄ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR51_14","025_51_14","JER","51","14","14","ⵉⵊⵊⵓⴵ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵖⴰⵔ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ: ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵛⵛⵓⵔⴻⵖ ⵛⴻⵎ ⵙ ⵉⵡⴷⴰⵏ ⴰⵎ ⵜⵎⵓⵔⵖⵉ, ⵄⴰⴷ ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⵍⴰⵖⴰⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵓⵙⵍⵉⵡⵍⴻⵡ!” ");
INSERT INTO rift_vpl VALUES ("JR51_15","025_51_15","JER","51","15","15","“ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵣⵉ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ ⵓ ⵉⴱⴻⵣⵣⴻⵄ ⴰⵊⴻⵏⵏⴰ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR51_16","025_51_16","JER","51","16","16","ⵍⴰⵎⵉ ⵉⵜⵜⴻⵊⵊⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⵙⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⵜⴻⴳⴳⴰ ⴰⵎ ⵓⵛⴰⵔⵛⵓⵔ ⵏ ⵡⴰⵎⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵜⵜⴻⴳⴳ ⴰⵙⵙⴰⵎⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵥⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰ-ⴷⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵣⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵏ ⵜⵅⵓⴱⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JR51_17","025_51_17","JER","51","17","17","ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⴳⴰⵔⵔⵓⴹ, ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ, ⴽⵓⵍ ⴰⵎⵣⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉⵜⵜⵙⴻⴹⵃⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉ ⵉⴳⴳⴰ, ⵎⴰⵖⴰⵔ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ ⵉⴼⴻⵙⵢⴻⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⴵⵉ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR51_18","025_51_18","JER","51","18","18","ⴰⵇⴰ-ⵜⴻⵏⵜ ⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⵙⴻⴹⵃⴰⵛⵜ! ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵅⵍⴰⴼ ⵏⵙⴻⵏⵜ, ⴰⴷ ⴼⵏⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR51_19","025_51_19","JER","51","19","19","“ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵡⴰⵔ ⵜⴻⴵⵉ ⴰⵎ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵉⵙⵔⴰⵉⵍ ⴷ ⵜⴰⵇⴱⵉⵍⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR51_20","025_51_20","JER","51","20","20","“ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴰⵢⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵛⵛⴰⵇⵓⵔ, ⵍⴻⵙⵏⴰⵃ ⵉⵏⵓ ⵉ ⵓⵎⴻⵏⵖⵉ. ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⵍⴻⴳⵏⵓⵙ, ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵖⴻⴹⵍⴻⵖ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_21","025_51_21","JER","51","21","21","ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⵢⵉⵙ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ ⵓ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⴽⴰⵔⵔⵓ ⵏ ⵓⵎⴻⵏⵖⵉ ⴷ ⵡⴻⵏⵏⵉ ⵜ ⵉⵏⴻⴷⴷⵀⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR51_22","025_51_22","JER","51","22","22","ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⵔⵢⴰⵣ ⴷ ⵜⴻⵎⵖⴰⵔⵜ, ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⵡⴻⵙⵙⴰⵔ ⴷ ⵓⵃⵓⴹⵔⵉ ⵓ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⴱⵍⵉⵖ ⴷ ⵜⴻⴱⵍⵉⵖⵜ, ");
INSERT INTO rift_vpl VALUES ("JR51_23","025_51_23","JER","51","23","23","ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⵎⴻⴽⵙⴰⵡ ⴷ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⴰⴼⴻⴵⴰⵃ ⴷ ⵣⵣⴰⵢⵍⴻⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ, ⵓ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵖ ⵍⵡⵓⵍⴰⵜ ⴷ ⵉⵎⵙⴻⵢⵢⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("JR51_24","025_51_24","JER","51","24","24","ⵎⴰⵛⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵏⴻⵛⵛ ⵣⵉ ⴱⴰⴱⵉⵍ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵉ ⴳⴳⵉⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR51_25","025_51_25","JER","51","25","25","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴷⴻⴽ ⴷⴷ-ⵍⵀⵉⵖ, ⵛⴻⴽ ⴰⴷⵔⴰⵔ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵓ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵇⵏⵓⵏⵏⵢⴻⵖ ⵣⵉ ⵍⴻⵊⵔⵓⴼ ⵓ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⴰⴷⵔⴰⵔ ⵉⵛⴻⵎⵎⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_26","025_51_26","JER","51","26","26","ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵜⵜⴰⵡⵢⴻⵏ ⵄⴰⴷ ⴰⵥⵔⵓ ⵉ ⵡⴻⵥⵔⵓ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵓⵍⴰ ⴷ ⴰⵥⵔⵓ ⵉ ⴷⵙⵓⵙⴰ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⵉ ⵍⵅⵉⵔⴱⴰⵜ ⵉ ⵍⴻⴱⴷⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR51_27","025_51_27","JER","51","27","27","“ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⴰⵄⴻⴵⴰⵏⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴼⴰⵔⵣⴻⵎ ⵍⴻⴳⵏⵓⵙ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵍⴰⵖⴰⵎ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵉ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴰⵔⴰⵔⴰⵟ, ⵎⵉⵏⵏⵉ ⴷ ⴰⵛⴽⴰⵏⴰⵣ, ⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵊⵊⴻⵎ ⵉⵢⵙⴰⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵢⵍⴰⴼ ⵏ ⵜⵎⵓⵖⵔⵉ ⵉⵚⴰⵔⵔⴹⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_28","025_51_28","JER","51","28","28","ⴼⴰⵔⵣⴻⵎ ⵍⴻⴳⵏⵓⵙ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵎⴰⴷⴰⵢ ⴰⴽ-ⴷ ⵍⵡⵓⵍⴰⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵅ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR51_29","025_51_29","JER","51","29","29","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏⵀⴻⵣⵣ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⴼⴰⵔⵖ ⵙ ⵍⴻⵃⵔⵉⵇ, ⵎⵉⵏⵣⵉ ⵉⵏⵡⴰⵢⴻⵏ ⵏ ⵙⵉⴷⵉ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵛⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JR51_30","025_51_30","JER","51","30","30","ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏ ⴱⴰⴱⵉⵍ ⵙⴻⵎⵃⴻⵏ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵙⴻⵏ. ⵜⴻⴼⵛⴻⵍ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ. ⵏⵉⵜⵏⵉ ⵇⵇⴷⴻⵏ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵄⵓⵎⴰⴷ ⵏⵙⴻⵏ ⵉ ⵓⴱⴻⵍⵍⴻⵄ ⵜⵜⵡⴰⵔⵥⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_31","025_51_31","JER","51","31","31","ⴰⵎⵙⴰⵣⵣⴰⵍ ⵏⵏⵉ ⵅ ⵓⵎⵙⴰⵣⵣⴰⵍ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⴰⵣⵣⴻⵍ-ⴷⴷ, ⴰⵔⴻⵇⵇⴰⵙ ⵏⵏⵉ ⵅ ⵓⵔⴻⵇⵇⴰⵙ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴰⵊⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵇⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JR51_32","025_51_32","JER","51","32","32","ⴰⵇⴰ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵓ ⵜⵜⵡⴰⵎⴻⵏⵄⴻⵏ, ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵓⵖⴰⵏⵉⵎ ⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_33","025_51_33","JER","51","33","33","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⵉⵍ ⵜⴻⴳⴳⴰ ⴰⵎ ⵓⵏⴻⴷⵔⴰⵔ, ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵍⵡⴻⵇⵜ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵄⴻⴼⵙⴻⵏ. ⵄⴰⴷ ⴷⵔⵓⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵅⴻⵏⵏⵉ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⵊⵔⴰ ⵉ ⵏⴻⵜⵜⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("JR51_34","025_51_34","JER","51","34","34","“ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵛⵛⴰ ⴰⵢⵉ, ⵉⵍⴱⴻⵣ ⴰⵢⵉ, ⵉⴳⴳⴰ ⴰⵢⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵇⴷⵉⵃ ⵉⵅⵡⴰⵏ, ⵉⵙⴰⵔⴹ ⴰⵢⵉ ⴰⵎ ⵍⵀⴰⵢⵛⴻⵜ, ⵉⵄⴻⵎⵎⴰⵔ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⵙ ⵍⴻⵃⵣⵓⵜ ⵉⵏⵓ ⵓⵛⴰ ⵢⵓⵥⵥⴻⵍ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JR51_35","025_51_35","JER","51","35","35","ⴻⵊⵊ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⴱⴰⴱⵉⵍ ⵍⵄⵓⵏⴼ ⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⵉⵏ ⵓ ⴷⴻⴳ ⵢⵉⵏⵏⵉ ⵉ ⵉⴵⴰⵏ ⴷ ⴷⴷⴰⵜ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⴰⵔ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ. ‘ⴻⵊⵊ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("JR51_36","025_51_36","JER","51","36","36","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵜⵜⴻⴷⵄⵉⵖ ⴷⴷⵄⴰⵡⵉ ⵏⵏⴻⵎ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵅⴻⵍⴼⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵥⵖⴻⵖ ⵍⴻⴱⵃⴰⵔ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵊⵊⴻⵖ ⵜⴰⵍⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⴰⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JR51_37","025_51_37","JER","51","37","37","ⴱⴰⴱⵉⵍ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵎⵖⵉⵔ ⴷ ⵍⵅⵉⵔⴱⴰⵜ, ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵓⵙⴻⵎⵥⵉ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("JR51_38","025_51_38","JER","51","38","38","“ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴰⴷ ⵣⴻⵀⵀⴰⵔⴻⵏ ⴰⵎ ⵡⴰⵢⵔⴰⴷⴻⵏ, ⴰⴷ ⵙⵙⵎⵉⵄⵄⵔⵉⵡⴻⵏ ⴰⵎ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_39","025_51_39","JER","51","39","39","ⵅⵎⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵃⵎⴰⵏ, ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⵣⵣⴰⵜⵙⴻⵏ ⵜⴰⵙⴻⵙⵙⵉⵜ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙᵉⵙⵛⴰⵔⴻⵖ ⴰⵍ ⵖⴰ ⴷⴻⵡⵡⵅⴻⵏ ⵓⵛⴰ ⴰⴷ ⵟⵟⵚⴻⵏ ⵉⴹⴻⵚ ⵏ ⵍⴻⴱⴷⴰ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴼⴰⵇⴻⵏ ⵄⴰⴷ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR51_40","025_51_40","JER","51","40","40","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⴰⵎ ⵢⵉⵣⴻⵎⵔⴰⵡⴻⵏ ⵖⴰⵔ ⵜⵖⴰⵔⵚⵜ, ⴰⵎ ⵢⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴰⴽ-ⴷ ⵉⵖⴰⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_41","025_51_41","JER","51","41","41","ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵛⵉⵛⴰⴽ ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵍⵄⴻⵣⵣ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ⵎⴰⵎⵎⴻⵛ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("JR51_42","025_51_42","JER","51","42","42","ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵍⴻⴱⵃⴰⵔ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ, ⵙ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⴷⴻⵍ ⵏⴻⵜⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JR51_43","025_51_43","JER","51","43","43","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴷ ⵜⵏⴻⵣⵔⵓⴼⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵓ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵛⵓⵇⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR51_44","025_51_44","JER","51","44","44","ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⴱⵉⵍ ⴷⵉ ⴱⴰⴱⵉⵍ, ⴰⴷ ⴽⴽⵙⴻⵖ ⵣⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵙⴰⵔⴹ. ⵍⴻⴳⵏⵓⵙ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵄⴰⴷ. ⵄⴰⴷ ⵍⵃⵉⴹ ⵏ ⴱⴰⴱⵉⵍ ⴰⴷ ⵉⵡⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("JR51_45","025_51_45","JER","51","45","45","“ⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR51_46","025_51_46","JER","51","46","46","ⵎⴰⵍⴰ ⵍⵍⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴹⴻⵄⴼⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵉ ⵍⴻⵅⴱⴰⵔ ⵏⵏⵉ ⵉ ⵖⴰ ⵙⵍⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⵄⵓⵏⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵅ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR51_47","025_51_47","JER","51","47","47","“ⵙ ⵓⵢⴻⵏⵏⵉ ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⴱⴰⴱⵉⵍ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏⵏⴻⴼⴹⴻⵃ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴰⴷ ⵡⴹⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR51_48","025_51_48","JER","51","48","48","ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⵙⴻⵏ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵏ ⵅ ⴱⴰⴱⵉⵍ. ⵎⴰⵖⴰⵔ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⵜⴻⵃⵃⴰⵢⵢⴻⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JR51_49","025_51_49","JER","51","49","49","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴱⴰⴱⵉⵍ ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵡⴹⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JR51_50","025_51_50","JER","51","50","50","“ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ ⵉ ⵙⵙⵉⴼ, ⴼⴼⵖⴻⵎ, ⵡⴰⵔ ⵙⴱⴻⴷⴷⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ! ⵅⴻⵎⵎⴻⵎ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⴷⵉ ⵙⵉⴷⵉ ⵓ ⵊⵊⴻⵎ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵖⴰⵔ ⵍⴱⴰⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JR51_51","025_51_51","JER","51","51","51","ⵏⴻⵛⵛⵉⵏ ⵏⵙⴻⴹⵃⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵙⵍⴰ ⵅ ⵓⵙⴻⵃⵇⴰⵔ, ⵜⴻⵣⵡⴻⵖ ⵏ ⵍⴻⵃⵢⴰ ⵜⴻⴷⵍⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴳⴻⵄⵄⴷⴻⵏ ⵅ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR51_52","025_51_52","JER","51","52","52","“ⵙ ⵓⵢⴰ ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⵍⴼⴻⵖ ⵣⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⵉⵏⴻⵇⵛⴻⵏ ⵓⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜⵡⴰⵣⴱⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_53","025_51_53","JER","51","53","53","ⵡⴰⵅⵅⴰ ⵎⴰⵍⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵍ ⴰⵊⴻⵏⵏⴰ, ⵡⴰⵅⵅⴰ ⵜⴻⴳⴳⴰ ⵍⴱⴰⵔⴰⵊ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵢⵓⵄⵍⴰⵏ ⴰⵍ ⵎⴰⵏⵉ ⵡⴰⵔ ⵢⵉⵡⵉⴹ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⵜⴻⵃⵃⴰⵢⴻⵏ ⵣⵣⴰⵢⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR51_54","025_51_54","JER","51","54","54","“ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵃⴻⵙⵙ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵉ ⴱⴰⴱⵉⵍ, ⴰⵎⴻⵛⵏⴰⵡ ⵏ ⵉⵛⵜ ⵏ ⵍⵎⵓⵚⵉⴱⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR51_55","025_51_55","JER","51","55","55","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⴰⴷ ⵉⵅⴰⵔⵔⴻⴱ ⴱⴰⴱⵉⵍ ⵓ ⴰⴷ ⵉⵇⴹⴰ ⵅ ⴷⴷⵔⵉⵣ ⵏⵏⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⵍⴻⵎⵡⴰⵊ ⵏⵙⴻⵏ ⴰⴷ ⵣⴻⵀⵀⴰⵔⴻⵏ ⴰⵎ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⴷⴷⵔⵉⵣ ⵏ ⵓⵣⴻⵀⵀⴰⵔ ⵏⵙⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JR51_56","025_51_56","JER","51","56","56","ⵎⵉⵏⵣⵉ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⵜⴻⵃⵃⴰⵢⴻⵏ, ⵅ ⴱⴰⴱⵉⵍ, ⵓⵛⴰ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ, ⵍⴻⵇⵡⴰⵙ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵡⴻⵅⵍⴰⴼ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵅⵍⴻⴼ ⵏⵉⵛⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JR51_57","025_51_57","JER","51","57","57","“ⴰⴷ ⵙⵙᵉⵙⵛⴰⵔⴻⵖ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⵡⵓⵍⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵎⵙⴻⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴻⴹⵚⴻⵏ ⴷⴻⴳ ⵢⵉⴹⴻⵚ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴼⴰⵇⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JR51_58","025_51_58","JER","51","58","58","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: “ⴰⴷ ⴰⵔⵔⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵉⵎⵉⵔⵉⵡⴻⵏ ⵏ ⴱⴰⴱⵉⵍ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰⵏ ⴰⴷ ⵜⴻⵏⵜ ⵇⴻⴷⴷⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴰⵃⵍⴻⵏ ⴱⴰⵟⴻⵍ ⵓ ⵛⵛⵓⵄⵓⴱ ⵙⵙⵉⵃⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("JR51_59","025_51_59","JER","51","59","59","ⴰⵡⴰⵍ ⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵉ ⵙⴰⵔⴰⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ-ⵢⴰⵀ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵃⵙⵉⵢⵢⴰ, ⵓⵎⵉ ⵡⴰⵏⵉⵜⴰ ⵢⵓⵢⵓⵔ ⵣⵉ ⵚⵉⴷⵇⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵙⴰⵔⴰⵢⴰ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR51_60","025_51_60","JER","51","60","60","ⵉⵔⵎⵉⵢⴰ ⵢⵓⵔⴰ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵅ ⴱⴰⴱⵉⵍ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵉⵏ ⵅ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR51_61","025_51_61","JER","51","61","61","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉⵔⵎⵉⵢⴰ ⵉ ⵙⴰⵔⴰⵢⴰ: “ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⵅⵣⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴰⴷ ⵜⴱⴰⵔⵔⵃⴻⴷ ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JR51_62","025_51_62","JER","51","62","62","ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵅ ⵡⴻⵎⵛⴰⵏ-ⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⴽⵙⴻⴷ ⵉⵎⴻⵣⴷⴰⵖ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵍⴰ ⴱⵏⴰⴷⴻⵎ ⵓⵍⴰ ⴷ ⵍⵎⴰⵍ, ⵓ ⴱⴻⵍⵍⵉ ⴰⵎⵛⴰⵏ-ⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("JR51_63","025_51_63","JER","51","63","63","ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵣⴻⴳ ⵓⵖⴰⵔⵉ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⴻⵇⵇⵏⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ, ⴰⴷ ⵜ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ. ");
INSERT INTO rift_vpl VALUES ("JR51_64","025_51_64","JER","51","64","64","ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵖⴻⴱⴱⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵡⴰⵔ ⵜⴳⵉⵄⵄⵉⴷ ⵄⴰⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵉ ⵅⴰⵙ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵍⴰⵡⴻⵏ.’” ⴰⵍ ⴷⴰ ⵉ ⵢⵉⵡⴹⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵔⵎⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_1","025_52_1","JER","52","1","1","ⵚⵉⴷⵇⵉⵢⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵏⴻⵜⵜⴰ ⵉⵃⴽⴻⵎ ⵃⵉⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵢⴻⵎⵎⴰⵙ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵃⴰⵎⵓⵜⴰⵍ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵔⵎⵉⵢⴰ ⵣⵉ ⵍⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_2","025_52_2","JER","52","2","2","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR52_3","025_52_3","JER","52","3","3","ⵎⴰⵖⴰⵔ ⴰⵅⴻⵢⵢⴻⵇ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵙⴰ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵢⴰⵀⵓⴷⴰ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵉⵏⴹⴰⵔ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵚⵉⴷⵇⵉⵢⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR52_4","025_52_4","JER","52","4","4","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵙ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵏⵉⵜⵏⵉ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵓⵛⴰ ⵇⴻⵡⵡⴰⵔⴻⵏ ⴰⵙ ⵙ ⵊⵊⴻⵀⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR52_5","025_52_5","JER","52","5","5","ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⵃⵙⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵚⵉⴷⵇⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_6","025_52_6","JER","52","6","6","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵓⵢⵓⵔ, ⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵍⴰⵥ ⵉⵎⴻⵇⵇⴰⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⴱⵓ ⵡⴻⵖⵔⵓⵎ ⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("JR52_7","025_52_7","JER","52","7","7","ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵔⵥ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⵔⴻⵡⵍⴻⵏ, ⴼⴼⵖⴻⵏ ⵙ ⴵⵉⵍⴻⵜ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⵃⵡⵉⵛ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵎⵉ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵜⵓⵖⴰ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵢⵓⵢⵓⵔ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_8","025_52_8","JER","52","8","8","ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵉⴹⴼⴰⵔ ⴰⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵃⴰⵔⵜⴻⵏ ⵅ ⵚⵉⴷⵇⵉⵢⴰ ⴷⵉ ⵍⵡⴰⵟⴰⵜ ⵏ ⴰⵔⵉⵃⴰ. ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵙⵙⴻⴱⴹⴰⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR52_9","025_52_9","JER","52","9","9","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵔⵉⴱⵍⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎⴰⵜ ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵃⴽⴻⵎ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JR52_10","025_52_10","JER","52","10","10","ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵏⵖⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⵉⴷⵇⵉⵢⴰ ⵣⵣⴰⵜ ⵉ ⵟⵟⵉⵜⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵔⵉⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_11","025_52_11","JER","52","11","11","ⵉⵙⵙⴷⴰⵔⵖⴻⵍ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵚⵉⴷⵇⵉⵢⴰ ⵓⵛⴰ ⵉⵇⵇⴻⵏ ⵉ-ⵜ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵏⵏⵃⴰⵙ. ⴰⵎⵎⵓ ⵉ ⵜ ⵢⵉⵡⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴰⵍ ⴰⵙⵙ ⵓⵎⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JR52_12","025_52_12","JER","52","12","12","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ - ⵜⵓⵖⴰ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵙⴻⵄⵟⴰⵛ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ - ⵅⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵏⴰⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⴻⵅⵅⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JR52_13","025_52_13","JER","52","13","13","ⵉⵙⵙⴰⵔⵖ ⵏⴻⵜⵜⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⵓⴷⵔⵉⵏ ⵏ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵉⵙⵙⴰⵔⵖ ⵉ-ⵜⴻⵏⵜ ⵄⴰⵡⴻⴷ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JR52_14","025_52_14","JER","52","14","14","ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⵇⴰ ⴰⵔⵥⵉⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⵓⴹ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR52_15","025_52_15","JER","52","15","15","ⵉⵎⴻⵣⵍⴰⴹ ⵇⴰⵄ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⵊⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵉⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔⴻⵙ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ ⵏ ⵍⵖⴰⵛⵉ, ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴷⵉ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_16","025_52_16","JER","52","16","16","ⵎⴰⵛⴰ ⵣⴻⴳ ⵉⵎⴻⵣⵍⴰⴹ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵊⵊⴰ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵉⵊⵊ ⵏ ⴷⵔⵓⵙ ⴰⵎ ⵢⵉⵎⴻⵍⵇⴰⴹ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵓ ⴰⵎ ⵢⵉⴼⴻⴵⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR52_17","025_52_17","JER","52","17","17","ⵓⵛⴰ ⴰⵔⵥⵉⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵏⵏⵃⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵜⵉⴽⴰⵔⵔⵓⵜⵉⵏ ⴷ ⵜⵔⵉⵎⴰⵏⵜ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴽⵙⵉⵏ ⵎⴰⵔⵔⴰ ⵏⵏⵃⴰⵙ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⴱⴰⴱⵉⵍ.    ");
INSERT INTO rift_vpl VALUES ("JR52_18","025_52_18","JER","52","18","18","ⵓⵍⴰ ⴷ ⵜⵉⵢⴷⵓⵔⵉⵏ ⴷ ⵉⵖⴻⵏⵊⴰⵢⴻⵏ ⴷ ⵜⵊⴻⵇⵇⴰⴹⵉⵏ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ ⵉ ⵣⵉ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ, ⴽⵙⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR52_19","025_52_19","JER","52","19","19","ⴰⵎⵎⵓ ⵉ ⵉⴽⵙⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵟⵟⴱⴰⵚⴰ ⴷ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⴷ ⵜⴻⵢⴷⵓⵔⵉⵏ ⴷ ⵍⴻⵇⵏⴰⴷⴻⵍ ⴷ ⵜⵖⴻⵏⵊⴰⵢⵉⵏ ⴷ ⵍⴽⵉⵙⴰⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵏ ⵡⵓⵔⴻⵖ ⵇⴰⵄ ⵏⵉⵖ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JR52_20","025_52_20","JER","52","20","20","ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴷ ⵜⵔⵉⵎⴰⵏⵜ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵏ ⵏⵏⵃⴰⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⵓⵍⴰ ⵅ ⵜⴽⴰⵔⵔⵓⵜⵉⵏ ⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ: ⴰⵇⴰ ⵏⵏⵃⴰⵙ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ-ⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵡⴻⵣⵏⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_21","025_52_21","JER","52","21","21","ⵅ ⵉⴱⵉⵍⴰⵔⴻⵏ: ⵜⵓⵖⴰ ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⵉⵍⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⵏⵏⴻⴹ. ⵜⵓⵖⴰ ⵍⴳⴻⴷⵔⴰⵏ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴻⵡⴹⴰⵏ ⵓⵛⴰ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵜⵓⵖⴰ-ⵜ ⵉⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_22","025_52_22","JER","52","22","22","ⵜⵜⴰⵊ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵏ ⵏⵏⵃⴰⵙ. ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵜⵓⵖⴰ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵅ ⵜⵜⴰⵊ ⵜⵓⵖⴰ ⵅⴰⵙ ⵜⵔⴰⵛⵛⴰ ⴷ ⵜⵔⴻⵎⵎⴰⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵏ ⵏⵏⵃⴰⵙ. ⴰⵎ ⵜⵓⵖⴰ ⵡⴰⵏⵉⵜⴰ, ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵓⵍⴰ ⴷ ⴰⴱⵉⵍⴰⵔ ⵏⵏⴻⵖⵏⵉ ⴷ ⵜⵔⴻⵎⵎⴰⵏⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR52_23","025_52_23","JER","52","23","23","ⵜⵉⵔⴻⵎⵎⴰⵏⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ⵎⴰⵔⵔⴰ ⵜⵉⵔⴻⵎⵎⴰⵏⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷⵉ ⵎⵢⴰ ⵅ ⵜⵔⴰⵛⵛⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JR52_24","025_52_24","JER","52","24","24","ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵢⵉⵡⵉ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⵓⵍⴰ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙⴰⵔⴰⵢⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵚⴰⴼⴰⵏⵢⴰ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JR52_25","025_52_25","JER","52","25","25","ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵛⴻⵏⵏⴻⵄ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⵍⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵍⴰ ⴷ ⴰⵎⴰⵔⵉⵔ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴻⵏ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵓⵍⴰ ⴷ ⵙⴻⵜⵜⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JR52_26","025_52_26","JER","52","26","26","ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵢⵉⵡⵉ ⵜⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵔⵉⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_27","025_52_27","JER","52","27","27","ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵉⵡⵜⴰ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵏⵖⴰ ⵉ-ⵜⴻⵏ ⴷⵉ ⵔⵉⴱⵍⴰ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎⴰⵜ. ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_28","025_52_28","JER","52","28","28","ⵡⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵏⴷⴻⵀ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ ⴷⵉ ⵍⵎⴻⵏⴼⴰ: ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵏⴷⴻⵀ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JR52_29","025_52_29","JER","52","29","29","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⵢⵉⵡⵉ ⵜⴻⵎⵏⴻⵎ-ⵎⵢⴰ ⵓ-ⵜⵏⴰⵢⴻⵏ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵡⴷⴰⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JR52_30","025_52_30","JER","52","30","30","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ ⵉⵏⴷⴻⵀ ⵏⴻⴱⵓⵣⴰⵔⴰⴷⴰⵏ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵙⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ. ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵓ-ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JR52_31","025_52_31","JER","52","31","31","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵡⵉⵍ-ⵎⴰⵔⵓⴷⴰⵅ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JR52_32","025_52_32","JER","52","32","32","ⵏⴻⵜⵜⴰ ⵉⵄⴷⴻⵍ ⴰⴽⵉⴷⴻⵙ, ⵉⵡⵛⴰ ⴰⵙ ⵍⴽⵓⵔⵙⵉ ⵏⵏⴻⵙ ⵜⵉⵡⴰ ⵉ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JR52_33","025_52_33","JER","52","33","33","ⵉⵙⵙⴰⵔⵙ ⵢⴰⵀⵓⵢⴰⴽⵉⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵏ ⵍⴻⵃⴱⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⴻⵜⵜ ⵖⴰⵔⴻⵙ, ⵎⵉⵏ ⵉⴽⴽⴰ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JR52_34","025_52_34","JER","52","34","34","ⵅ ⵍⵎⴻⵄⵜⴻⵇ ⵏⵏⴻⵙ: ⵍⴻⴱⴷⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵍⵎⴻⵄⵜⴻⵇ ⵏⵏⴻⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴽⵓⵍ ⴰⵙⵙ ⵎⵉⵏ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⵏ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵎⵉⵏ ⵉⴽⴽⴰ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LM1_1","026_1_1","LAM","1","1","1","ⴰⵍⵉⴼ. ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⵉⵎ ⴷⵉⵀⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵡⴻⵃⵃⴷⴻⵙ! ⵜⵓⵖⴰ ⵍⴻⴱⴷⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵖⴰⵛⵉ, ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ, ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵉⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵊⴰⵔ ⵍⵄⴰⵎⴰⵍⴰⵜ, ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("LM1_2","026_1_2","LAM","1","2","2","ⴱⵉⵜ. ⵜᵉⵜⵜⵔⵓ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ ⵙ ⴵⵉⵍⴻⵜ, ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵅ ⵉⵎⴻⴳⴳⵉⵣⴻⵏ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⵄⴻⵣⵣⴰⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⵖⴷⴰⵔⴻⵏ-ⵜⵜ, ⴷⴻⵡⵍⴻⵏ ⴰⵙ ⴷ ⵍⵄⴻⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LM1_3","026_1_3","LAM","1","3","3","ⴳⵉⵎⴻⵍ. ⵜᵉⵜⵜⵡⴰⵃⴻⴱⴱⴻⵙ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴱⴻⵏ, ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵜⵅⴻⵎⵎⴰⵙⵜ ⵏⵏⴻⵙ ⵉⵇⴻⵙⵃⴻⵏ. ⵜᵉⵜⵜⵖⵉⵎⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵡⴰⵔ ⵜⵓⴼⵉ ⴰⵔⵔⴰⵃⴻⵜ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵜ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ ⵃⴰⵔⵔⵜⴻⵏ ⵅⴰⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM1_4","026_1_4","LAM","1","4","4","ⴷⴰⵍⵉⵜ. ⵉⴱⵔⵉⴷⴻⵏ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ ⵛⴻⴹⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴳⴳⵓⵔ ⵄⴰⴷ ⵖⴰⵔ ⵍⵄⵉⴷ. ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵅⵍⴰⵏⵜ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵣⴻⵀⵀⴰⵔⴻⵏ, ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵏⵏⴻⵙ ⵛⴻⴹⵏⴻⵏⵜ, ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⴰⵔⵣⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("LM1_5","026_1_5","LAM","1","5","5","ⵀⵉ. ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏ ⵃⴻⴽⴽⵎⴻⵏ ⵅⴰⵙ, ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴼⴰⵔⵔⵃⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵛⴹⴻⵏ ⵉ-ⵜⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM1_6","026_1_6","LAM","1","6","6","ⵡⴰⵡ. ⴰⵛⴻⵡⵡⴰⵔ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵉⵏⴳⴻⵣ ⵣⵣⴰⵢⴻⵙ, ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⴰⵎ ⵓⴷⴰⴷⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⴼⴻⵏ ⴷⴷⴻⵎⵏⴻⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴱⵍⴰ ⵊⵊⴻⵀⴷ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⴹⴰⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM1_7","026_1_7","LAM","1","7","7","ⵣⴰⵢⵉⵏ. ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵖⴱⴻⵏ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴻⵜⵍⴰⵄ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵄⵇⴻⵍ ⵓⵔⵛⴰⵍⵉⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵖⵍⴰⵏ, ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵜⵓⵖⴰ ⵣⵉⵛ. ⵍⴰⵎⵉ ⵉⵡⴹⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵡⴻⵖⵔⵉⵎ, ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⴰⴼⵓⵙ. ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ ⵥⵔⵉⵏ ⵜⵜ, ⵙⵜⴻⵀⵣⴰⵏ ⵣⴻⴳ ⵓⵔⴻⴷⴷⴻⴵ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM1_8","026_1_8","LAM","1","8","8","ⵅⵉⵜ. ⵓⵔⵛⴰⵍⵉⵎ ⵜⵓⵖⴰ ⵜⵅⴻⵟⵟⴰ ⴰⵟⵟⴰⵙ. ⵅ ⵓⵢⴰ ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜ ⵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ, ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵜⵜ, ⵎⵉⵏⵣⵉ ⵥⵔⵉⵏ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵙ. ⵓⵍⴰ ⵏⴻⵜⵜⴰⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⵣⴻⵀⵀⴰⵔ, ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LM1_9","026_1_9","LAM","1","9","9","ⵜⵉⵜ. ⵜⴰⵅⵎⵓⵊⵉ ⵏⵏⴻⵙ ⵜⴻⵍⵚⴻⵇ ⵖⴰⵔ ⵜⵎⵓⵡⵡⴰ ⵏ ⵓⴱⴻⵃⵔⵓⵔ ⵏⵏⴻⵙ, ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵅⴻⵎⵎ. ⴰⵇⴰ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵍⴰⴵⴰⵖ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵉⵙⵙⵜⴻⴱⵀⵜⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜⵜ ⵉⵄⴻⵣⵣⵉ. ⵅⵣⴰⵔ ⵎⴰⵛⴰ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵍⴻⵄⴷⵓ ⵉⵙⵙⵎⴻⵇⵇⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM1_10","026_1_10","LAM","1","10","10","ⵢⵓⴷ. ⴰⵖⵔⵉⵎ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵖⵍⴰⵏ. ⵉⵡⴰ ⵜⴻⵥⵔⴰ ⵏⴻⵜⵜⴰⵜ ⵎⴰⵎⵎⴻⵛ ⵓⴷⴼⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵍⴻⴳⵏⵓⵙ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵎⵓⵔⴻⴷ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LM1_11","026_1_11","LAM","1","11","11","ⴽⴰⴼ. ⵇⴰⵄ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵣⴻⵀⵀⴰⵔⴻⵏ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⵖⵔⵓⵎ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵛⵛⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⴰⵙⴻⴼⵙⵉ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ. ⵅⵣⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵍⴰ ⵎⴰⵎⵎⴻⵛ ⴷⴻⵡⵍⴻⵖ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LM1_12","026_1_12","LAM","1","12","12","ⵍⴰⵎⵉⴷ. ⵎⴰ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵉⵛⵇⵉ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ ⵅ ⵡⴻⴱⵔⵉⴷ? ⵡⴰⵍⴰⵎ ⵓ ⵅⵣⴰⵔⴻⵎ, ⵎⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⴻⵃⵔⵉⵇ ⴰⵎ ⵍⴻⵃⵔⵉⵇ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵅⴻⵢⵢⴻⵇ ⵙⵉⴷⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM1_13","026_1_13","LAM","1","13","13","ⵎⵉⵎ. ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵜⵉⵎⴻⵙⵙⵉ ⴷⴻⴳ ⵉⵖⵙⴰⵏ ⵉⵏⵓ, ⵜⵛⴻⴱⴱⴰⵔ ⴷⴰⵢⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵏⴹⴰⵔ-ⴷⴷ ⵜⵔⴰⵛⵛⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ, ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⵇⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵢⵉ, ⵉⵙⵙⴻⵀⵍⴻⵛ ⴰⵢⵉ ⴰⵙⵙ ⴰⵎ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LM1_14","026_1_14","LAM","1","14","14","ⵏⵓⵏ. ⵉⵜⵜⵡⴰⵛⴻⴷⴷ ⵓⵣⴰⵢⵍⵓ ⵏ ⵉⵄⴻⴷⵉⵢⵢⴻⵏ ⵉⵏⵓ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜⵜⵡⴰⵎⵓⴷⴻⵏ, ⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵅ ⵢⵉⵔⵉ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴰⴷ ⵉⴼⵛⴻⵍ. ⵉⵡⵛⴰ ⴰⵢⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LM1_15","026_1_15","LAM","1","15","15","ⵙⴰⵎⵉⵅ. ⵉⵏⴹⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵙⵜ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⴹⵉⴷⴷ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵥ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⵇⴰ ⵉⵄⴼⴻⵙ ⴷⵉ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ, ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ, ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LM1_16","026_1_16","LAM","1","16","16","ⵄⴰⵢⵉⵏ. ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⵜⵔⵓⵖ, ⴰ ⵜⵉⵟⵟ ⵉⵏⵓ, ⴰ ⵜⵉⵟⵟ ⵉⵏⵓ ⵉⵙⵙⴰⵣⵣⴰⵍⴻⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⴻⵙⴼⴻⵡⵡⴻⵊ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ. ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵍⴻⵄⴷⵓ ⵉⵊⵀⴻⴷ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM1_17","026_1_17","LAM","1","17","17","ⴱⵉ. ⵜⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵚⵉⵀⵢⵓⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵡⵉ ⵜⵜ ⵖⴰ ⵉⵙⵙⴼⴻⵡⵡⵊⴻⵏ. ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵅ ⵢⴰⵄⵇⵓⴱ, ⴰⵇⴰ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⴷⴷ-ⵏⵏⴹⴻⵏ. ⵓⵔⵛⴰⵍⵉⵎ ⵜⴻⴷⵡⴻⵍ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM1_18","026_1_18","LAM","1","18","18","ⵜⵙⴰⴷⵉ. ⵙⵉⴷⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵖⴻⵡⵡⵖⴻⵖ ⵅ ⵍⵓⵎⵓⵔⴰⵜ ⵏⵏⴻⵙ. ⵙⵍⴻⵎ ⵅⴻⵏⵏⵉ, ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵍⴻⵀⵍⵉⵇ ⵉⵏⵓ. ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵉⵏⵓ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵏⵓ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("LM1_19","026_1_19","LAM","1","19","19","ⵇⵓⴼ. ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⵅ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵛⴻⵎⵜⴻⵏ ⴰⵢⵉ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵓ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵏⵓ ⴹⴻⵍⵇⴻⵏ ⵉ ⴱⵓⵃⴱⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵎⴰⵛⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵎⴻⵃⴹⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM1_20","026_1_20","LAM","1","20","20","ⵔⵉⵅ. ⵅⵣⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵜⴰⴽⵔⵉⵛⵜ ⵉⵏⵓ ⵜⴻⵏⵏⴻⵃⵡⴻⵍ, ⵓⵍ ⵉⵏⵓ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵣⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵖⴻⵡⵡⵖⴻⵖ ⴰⵟⵟⴰⵙ. ⴷⵉ ⴱⴰⵔⵔⴰ ⵉ ⴷ ⴰⵢⵉ ⵢⵓⵛⴰⵔ ⵙⵙⵉⴼ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⴷⴰⵅⴻⵍ ⵉⵃⴻⴽⴽⴻⵎ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LM1_21","026_1_21","LAM","1","21","21","ⵛⵉⵏ. ⵙⵍⵉⵏ ⵎⴰⵎⵎⴻⵛ ⵣⴻⵀⵀⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵙⴼⴻⵡⵡⴻⵊ, ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵙⵍⵉⵏ ⵅ ⴰⵔⵥⵉⵢⵢⴻⵜ ⵉⵏⵓ. ⴼⴰⵔⵃⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⵉ ⵜⵜ ⵉⴳⴳⵉⵏ. ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⴰⵙⵙ ⵉ ⵣⵉ ⴷⴷ-ⵜⵄⴻⵍⵎⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴵⵉⵖ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("LM1_22","026_1_22","LAM","1","22","22","ⵜⴰⴼ. ⴻⵊⵊ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵙⴻⵏ ⵣⵣⴰⵜⴻⴽ, ⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵣⵣⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⵉⵏⵓ ⴷ ⴰⵟⵟⴰⵙ, ⵓⵍ ⵉⵏⵓ ⵢⵓⵃⴻⵍ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LM2_1","026_2_1","LAM","2","1","1","ⴰⵍⵉⴼ. ⵎⴰⵎⵎⴻⵛ ⵉⴷⵍⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ? ⴰⵇⴰ ⴰⵄⵓⴵⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM2_2","026_2_2","LAM","2","2","2","ⴱⵉⵜ. ⵉⵇⴹⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⴷⴷⴰⵖ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵉⵊⵊⵉ ⴰⴷ ⵏⴻⵊⵎⴻⵏⵜ. ⴷⴻⴳ ⵓⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵙ ⵏ ⵓⴼⵓⴳⴻⵎ ⵉⵀⴷⴻⵎ ⵍⵇⴻⵍⵄⴰⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⴱⴻⵇⵇⴻⴹ ⵉ-ⵜⴻⵏⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵙⵙⵄⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM2_3","026_2_3","LAM","2","3","3","ⴳⵉⵎⴻⵍ. ⴷⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⵇⴻⵙⵙ ⵇⴰⵄ ⵉⵛⵛ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵢⴰⵔⵔⴰ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵣⵣⴰⵜ ⵉ ⵍⴻⵄⴷⵓ, ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵖⴰ ⴹⵉⴷⴷ ⵉ ⵢⴰⵄⵇⵓⴱ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⵜᵉⵜⵜⴻⵜⵜ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM2_4","026_2_4","LAM","2","4","4","ⴷⴰⵍⵉⵜ. ⵏⴻⵜⵜⴰ ⵉⵎⵃⴻⴹ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⴰⵎ ⵍⴻⵄⴷⵓ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⴰⵎ ⵍⴻⵄⴷⵓ, ⵡⴻⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵎⵎⴻⵥⵔⵉ ⵜⵉⵟⵟ. ⴷⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵉⴼⴰⵔⵔⴻⵖ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵙ ⴰⵎ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LM2_5","026_2_5","LAM","2","5","5","ⵀⵉ. ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴷⵡⴻⵍ ⴰⵎ ⵍⴻⵄⴷⵓ, ⵉⵚⴰⵔⴹ ⵉⵙⵔⴰⵉⵍ, ⵉⵚⴰⵔⴹ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ, ⵉⵀⴷⴻⵎ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵙ, ⵓ ⵢⴰⵔⵏⵉ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵛⴹⴰⵏ ⴷ ⵉⵖⵓⵢⵢⴰⵏ ⵖⴰⵔ ⵢⴻⴵⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LM2_6","026_2_6","LAM","2","6","6","ⵡⴰⵡ. ⵏⴻⵜⵜⴰ ⵉⵇⵍⴻⵄ ⵙ ⵍⵄⵓⵏⴼ ⴰⵄⵉⵛⵛⵓ ⵏⵏⴻⵙ, ⴰⵎ ⵉⵊⵊ ⵏ ⵡⴻⵃⵡⵉⵛ. ⵢⴰⵔⴻⵢⵢⴻⴱ ⴰⵎⵛⴰⵏ ⵏ ⵓⵎⵙⴰⴳⴰⵔ. ⵉⵙⵙⴻⵜⵜⵓ ⵙⵉⴷⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⴰⵙⵙ ⵏ ⵍⵄⵉⴷ ⴷ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵓ ⴷⴻⴳ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵙ ⵉⵏⴹⴰⵔ ⴰⵊⴻⴵⵉⴷ ⴷ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LM2_7","026_2_7","LAM","2","7","7","ⵣⴰⵢⵉⵏ. ⵉⴷⵡⴻⵍ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵛⴰⵔⵔⴻⵀ ⴰⵄⴰⵍⵟⴰⵔ ⵏⵏⴻⵙ, ⵉⵏⴹⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⵍⴻⵃⵢⵓⴹ ⵏ ⵢⴻⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵇⵚⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴻⵄⴷⵓ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⵄⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("LM2_8","026_2_8","LAM","2","8","8","ⵅⵉⵜ. ⵙⵉⴷⵉ ⵉⵅⴰⵔⵔⴻⵚ ⴰⴷ ⵉⵀⴷⴻⵎ ⵍⵃⵉⴹ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵉⵙⴰⵔⵔⴻⵃ ⵅⴰⵙ ⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵡⴰⵔ ⴷⴷ-ⵉⵊⴱⵉⴷ ⵖⴰⵔⴻⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵚⴰⵔⴹ. ⵉⵊⵊⴰ ⴰⵛⴱⴰⵔ ⵏ ⵣⵣⴰⵜ ⴷ ⵍⵃⵉⴹ ⴰⴷ ⵛⴻⴹⵏⴻⵏ, ⴰⵇⴰ ⵜⵜⵡⴰⵖⴻⴹⵍⴻⵏ ⵊⵎⵉⵄ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LM2_9","026_2_9","LAM","2","9","9","ⵜⵉⵜ. ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵖⴰⵔⵇⴻⵏⵜ ⴷⴻⴳ ⵓⵛⴰⵍ, ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵏ ⵓⴱⴻⵍⵍⴻⵄ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉ-ⵜⴻⵏ, ⵢⴰⵔⵥⴰ ⵉ-ⵜⴻⵏ. ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵓⵙⴻⵍⵎⴻⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜᵉⵟⵟⵉⴼⴻⵏ ⵛⴰ ⵍⴻⵡⵃⵉⵢ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LM2_10","026_2_10","LAM","2","10","10","ⵢⵓⴷ. ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ ⵇⵇⵉⵎⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴱⴻⴽⵎⴻⵏ, ⵣⵓⵣⵣⴰⵔⴰⵏ ⵓⵛⴰⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ⴱⴻⵢⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ. ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵙⵙⴰⴹⴰⵔⴻⵏⵜ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LM2_11","026_2_11","LAM","2","11","11","ⴽⴰⴼ. ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵀⵍⴻⵏⵜ ⵣⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵜⴰⴽⵔⵉⵛⵜ ⵉⵏⵓ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ, ⵜᵉⵜⵜⵡⴰⵣⴻⴵⴻⵄ ⵜⵙⴰ ⵉⵏⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵅ ⵜⵔⴻⵥⵥⵉⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵓⵙⴻⵢⵎⵉ ⵜⵜⵖⴰⵛⴰⵏ ⵅ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LM2_12","026_2_12","LAM","2","12","12","ⵍⴰⵎⵉⴷ. ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⵉ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵄⴰⴷ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ?”, ⵅⵎⵉ ⵡⴻⵟⵟⴰⵏ ⵅ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵅⵎⵉ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM2_13","026_2_13","LAM","2","13","13","ⵎⵉⵎ. ⵎⵉⵏ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵉⵏⵉⵖ, ⵎⵉⵏ ⵖⴰⵔ ⵛⴻⵎ ⵉ ⵖⴰ ⵙⵙⴻⵎⵇⵓⴷⴷⵉⵖ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ? ⵎⵉⵏ ⵖⴰⵔ ⵛⴻⵎ ⵉ ⵖⴰ ⵙⵙⴻⵎⵇⵓⴷⴷⵉⵖ, ⴰⵍⴰⵎⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ, ⴰ ⵛⴻⵎ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵎ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵎ ⵍⴻⴱⵃⴰⵔ, ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⵎ ⵉⵙⵙⴳⴻⵏⴼⴰ? ");
INSERT INTO rift_vpl VALUES ("LM2_14","026_2_14","LAM","2","14","14","ⵏⵓⵏ. ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵎ ⵥⵔⵉⵏ ⵉⵡⴻⵃⵃⴰⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵉⴱⵓⵃⴰⵍⵉⵢⵢⴻⵏ, ⵡⴰⵔ ⵙⵙⵄⴰⵔⵔⴰⵏ ⵛⴰ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵏ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵏⴻⵎ. ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵎ ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ ⵎⵖⵉⵔ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵜⵃⵓⵊⴰ ⵏ ⵓⵖⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LM2_15","026_2_15","LAM","2","15","15","ⵙⴰⵎⵉⵅ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵎ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ ⵛⵛⴰⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵙ ⵓⵏⴻⵅⵍⵉⵄ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵎ. ⵏⵉⵜⵏⵉ ⵜⵜⵚⴻⴼⴼⴰⵔⴻⵏ ⵓ ⵙⵙⴻⵏⵀⴻⵣⵣⴰⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵅ ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰ ⴷ ⵜⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵓⵎⵉ ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵥⵔⵉ ⵏⵏⴻⵙ ⵉⴽⵎⴻⵍ, ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ!”? ");
INSERT INTO rift_vpl VALUES ("LM2_16","026_2_16","LAM","2","16","16","ⴱⵉ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵎ ⴰⵔⴻⵣⵎⴻⵏ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⵏⵙⴻⵏ, ⵜⵜⵚⴻⴼⴼⴰⵔⴻⵏ ⵓ ⵜⵜⵖⴻⵣⵣⴰⵏ ⵜⵉⵖⵎⴰⵙ, ⵇⵇⴰⵔⴻⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⵚⴰⵔⴹ ⵉ-ⵜⵜ. ⵡⴰ ⴷ ⴰⵙⵙ ⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⵔⴰⵊⴰ, ⵍⴻⵅⵅⵓ ⵏⵓⴼⴰ ⵉ-ⵜ, ⵏⴻⵜⵜⵡⴰⵍⴰ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("LM2_17","026_2_17","LAM","2","17","17","ⵄⴰⵢⵉⵏ. ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⵎⵉⵏ ⵉⵅⴰⵔⵔⴻⵚ, ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ. ⵉⵀⴷⴻⵎ ⵉ ⵛⴻⵎ, ⵡⴰⵔ ⵅⴰⵎ ⵉⵃⵉⵡⴻⵍ. ⵍⴻⵄⴷⵓ ⵉⵊⵊⴰ ⵉ-ⵜ ⵉⴼⴰⵔⵃ ⵣⵣⴰⵢⴻⵎ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵛⵛ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LM2_18","026_2_18","LAM","2","18","18","ⵜⵙⴰⴷⵉ. ⵓⵍ ⵏⵙⴻⵏ ⵉⵙⵖⵓⵢⵢⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, “ⴰ ⵍⵃⵉⴹ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴻⵊⵊ ⴰⴷ ⴰⵣⵣⵍⴻⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵎ ⴰⵎ ⵜⴻⵖⵣⴰⵔⵜ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵏⴻⵇⵚⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵎⵓⵎⵎⵓ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⴰⴷ ⵉⴱⴻⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("LM2_19","026_2_19","LAM","2","19","19","ⵇⵓⴼ. ⴽⴽⴰⵔ, ⵙⵖⵓⵢⵢ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵏ ⴵⵉⵍⴻⵜ, ⵣⴻⴵⴻⵄ ⵓⵍ ⵏⵏⴻⵎ ⴰⵎ ⵡⴰⵎⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ. ⵙⴳⴻⵄⵄⴻⴷ ⵖⴰⵔⴻⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵍⴰⵥ, ⵖⴰⵔ ⵜⵖⴻⵎⵎⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM2_20","026_2_20","LAM","2","20","20","ⵔⵉⵅ. ⵅⵣⴰⵔ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵍⴰ ⵎⵍⵉⵃ ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⵛⴻⵏⵜ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏⵜ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ ⵉ ⴷⵉ ⵜⵜⵀⵉⵍⵍⴰⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ? ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵓⵏⴰⴱⵉ ⴷ ⵓⴽⴻⵀⵀⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("LM2_21","026_2_21","LAM","2","21","21","ⵛⵉⵏ. ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵡⴻⵙⵙⵓⵔⴰ ⴱⵓⵣⵣⵍⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ. ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵉⵏⵓ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵏⵓ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ. ⵜⴻⵏⵖⵉⴷ ⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵜⵖⴰⵔⵚⴻⴹ ⴰⵙⴻⵏ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵃⵉⵡⵍⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LM2_22","026_2_22","LAM","2","22","22","ⵜⴰⴼ. ⵜⵄⴰⵔⵔⵏⴻⴷ-ⴷⴷ ⵖⴰⵔⵉ ⵎⵉⵏ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ. ⵡⴰⵔ ⵉⵏⴻⵊⵊⵉⵎ ⵏⵉⵖ ⵉⵜⵜⴰⵔⴻⴽⴽⵡⴰⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ. ⵉⵏⵏⵉ ⵉ ⴷⵉ ⵜⵜⵀⵉⵍⵍⵉⵖ ⵓ ⴰⵔⴻⴱⴱⵉⵖ ⵉⵇⴹⴰ ⵉ-ⵜⴻⵏ ⵍⴻⵄⴷⵓ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_1","026_3_1","LAM","3","1","1","ⴰⵍⵉⴼ. ⵏⴻⵛⵛ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵍⴻⵖⴱⴻⵏ ⵙ ⵡⴻⵄⵎⵓⴷ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵙ ⵏ ⵓⴼⵓⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LM3_2","026_3_2","LAM","3","2","2","ⴰⵍⵉⴼ. ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⵢⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LM3_3","026_3_3","LAM","3","3","3","ⴰⵍⵉⴼ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵍⴻⴱⴷⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉⵏⵓ, ⴰⵙⵙ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LM3_4","026_3_4","LAM","3","4","4","ⴱⵉⵜ. ⵏⴻⵜⵜⴰ ⵉⴹⴻⵢⵢⴻⵄ ⴰⵢⵙⵓⵎ ⵉⵏⵓ ⴷ ⵜⴻⵍⵎⴻⵛⵜ ⵉⵏⵓ, ⵢⴰⵔⵥⴰ ⵉⵖⵙⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_5","026_3_5","LAM","3","5","5","ⴱⵉⵜ. ⵏⴻⵜⵜⴰ ⴱⵏⴰ ⵉⵛⵜ ⵏ ⵍⴻⴱⵏⵉⵢⵢⴻⵜ ⵅⴰⴼⵉ ⵓ ⵉⵇⵓⵡⵡⴰⵔ ⴰⵢⵉ ⵙ ⴰⵔⵔⵀⴰⵊ ⴷ ⵜⴰⵎⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_6","026_3_6","LAM","3","6","6","ⴱⵉⵜ. ⴷⵉ ⵟⵟⵍⴰⵎ ⵉⵊⵊⴰ ⴰⵢⵉ ⵣⴻⴷⴷⵖⴻⵖ, ⴰⵎ ⵉⵎⴻⵜⵜⴰⵏ ⵏ ⵡⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_7","026_3_7","LAM","3","7","7","ⴳⵉⵎⴻⵍ. ⵏⴻⵜⵜⴰ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵢⵉ ⵊⴰⵔ ⵍⴻⵃⵢⵓⴹ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵏⴻⵊⵎⴻⵖ. ⵉⵙⵙⴻⴷⵇⴻⵍ ⵅⴰⴼⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵏⵓ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_8","026_3_8","LAM","3","8","8","ⴳⵉⵎⴻⵍ. ⵄⴰⴷ ⵎⴻⵍⵎⵉ ⵜⵜⵍⴰⵖⵉⵖ ⵓ ⵙⵖⵓⵢⵢⵓⵖ, ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⴱⴽⴻⵎ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_9","026_3_9","LAM","3","9","9","ⴳⵉⵎⴻⵍ. ⵙ ⵜⵚⵓⴹⴰⵔ ⵉⵏⵊⴰⵔⴻⵏ ⵉⴱⴻⵍⵍⴻⵄ ⵅⴰⴼⵉ ⴰⴱⵔⵉⴷ, ⵉⵙⵙⴼⴰⵔⵖ ⵉⵎⴻⵙⵔⴰⵇ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_10","026_3_10","LAM","3","10","10","ⴷⴰⵍⵉⵜ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉ ⵏⴻⵛⵛ ⴰⵎ ⴷⴷⵓⴱ ⵉⵜⵜⵃⴰⵎⴰⵏ, ⴰⵎ ⵡⴰⵢⵔⴰⴷ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_11","026_3_11","LAM","3","11","11","ⴷⴰⵍⵉⵜ. ⵏⴻⵜⵜⴰ ⵢⵓⵥⵥⴻⵍ ⵅⴰⴼⵉ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵎⴻⵣⵣⴻⵇ ⴰⵢⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵊⵊⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_12","026_3_12","LAM","3","12","12","ⴷⴰⵍⵉⵜ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵎⵃⴻⴹ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⵢⵉ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵡⴰⴹ ⵉ ⴼⵍⵉⵜⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_13","026_3_13","LAM","3","13","13","ⵀⵉ. ⴼⵍⵉⵜⵛⴰⵜ ⵣⴻⴳ ⵡⴻⵇⵔⴰⴱ ⵏⵏⴻⵙ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⴰⴷⴼⴻⵏⵜ ⴷⵉ ⵜⵉⵥⵥⴰⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_14","026_3_14","LAM","3","14","14","ⵀⵉ. ⴷⴻⵡⵍⴻⵖ ⴷ ⵜⴰⵙⴻⴹⵀⴰⵛⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴷ ⵉⵣⵍⵉ ⵏⵙⴻⵏ ⵏ ⵓⵣⴰⵡⴰⵔ ⴰⵙⵙ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_15","026_3_15","LAM","3","15","15","ⵀⵉ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵊⵊⵉⵡⴻⵏ ⴰⵢⵉ ⵙ ⵜⴰⵔⵣⵓⴳⵉ, ⵉⵙⵙⴻⵙⵙⵓ ⴰⵢⵉ ⵙ ⵛⵛⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("LM3_16","026_3_16","LAM","3","16","16","ⵡⴰⵡ. ⵜⵉⵖⵎⴰⵙ ⵉⵏⵓ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏⵜ ⵣⴻⵄⵄⴼⴻⵏⵜ ⴷⴻⴳ ⵓⵇⴰⵢⴰⵙ ⴰⵍⴰⵎⵉ ⴰⵔⵥⵉⵏⵜ, ⵉⴷⵍⴰ ⴰⵢⵉ ⵙ ⵢⵉⵖⵖⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LM3_17","026_3_17","LAM","3","17","17","ⵡⴰⵡ. ⵛⴻⴽ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵅ ⵍⴻⵀⵏⴰ, ⵏⴻⵛⵛ ⵜⵜⵓⵖ ⵎⴰⵔⵔⴰ ⵜⵛⵓⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_18","026_3_18","LAM","3","18","18","ⵡⴰⵡ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵉⵇⴹⴰ, ⵓⵍⴰ ⴷ ⴰⵙⵉⵜⴻⵎ ⵉⵏⵓ ⴷⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LM3_19","026_3_19","LAM","3","19","19","ⵣⴰⵢⵉⵏ. ⵄⵇⴻⵍ ⵅ ⵍⴻⵖⴱⴻⵏ ⵉⵏⵓ ⴷ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵉⵏⵓ, ⵅ ⵛⵛⵉⵃ ⴷ ⴰⵔⵔⵀⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("LM3_20","026_3_20","LAM","3","20","20","ⵣⴰⵢⵉⵏ. ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⵏⵉⵛⴰⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵉⵛⴹⴻⵏ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_21","026_3_21","LAM","3","21","21","ⵣⴰⵢⵉⵏ. ⴰⵢⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵡⵓⵍ, ⵅ ⵓⵢⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵙⵙⵉⵜⵉⵎⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LM3_22","026_3_22","LAM","3","22","22","ⵅⵉⵜ. ⵙ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵛⴰ, ⵎⵉⵏⵣⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_23","026_3_23","LAM","3","23","23","ⵅⵉⵜ. ⴰⵇⴰ-ⵜⵜ ⴷ ⵊⴷⵉⴷ ⴽⵓⵍ ⵚⵚⴱⴻⵃ, ⵍⴰⵎⴰⵏ ⵏⵏⴻⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_24","026_3_24","LAM","3","24","24","ⵅⵉⵜ. ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⴷ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵅ ⵓⵢⴰ ⵜⵜⵖⵉⵎⵉⵖ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_25","026_3_25","LAM","3","25","25","ⵜⵉⵜ. ⵉⵚⴱⴻⵃ ⵙⵉⴷⵉ ⵉ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵙⵙⵉⵜⵉⵎⴻⵏ, ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵅⴰⵙ ⵢⴰⵔⴻⵣⵣⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_26","026_3_26","LAM","3","26","26","ⵜⵉⵜ. ⴰⵇⴰ ⵎⵍⵉⵃ ⴰⵔⴰⵊⵉ ⵙ ⵓⵙⵉⵜⴻⵎ ⵖⴰⵔ ⵣⵣⴰⵜ, ⴰⵔⴰⵊⵉ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⵖⴰⵔ ⵓⵙⴻⵏⵊⴻⵎ ⵣⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_27","026_3_27","LAM","3","27","27","ⵜⵉⵜ. ⵎⵍⵉⵃ ⵉ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵔⴱⵓ ⴰⵣⴰⵢⵍⵓ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_28","026_3_28","LAM","3","28","28","ⵢⵓⴷ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵇⵇⵉⵎ ⵃⴰⴼⵉ, ⴰⴷ ⵉⵙⵙⴻⵖⴷ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_29","026_3_29","LAM","3","29","29","ⵢⵓⴷ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴳⴳ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⴰⴷ ⵢⵉⵏⵉ: “ⴰⴷ ⵜⴰⵖ ⵉⴵⴰ ⵍⴰⵢⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("LM3_30","026_3_30","LAM","3","30","30","ⵢⵓⴷ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵡⵛ ⴰⵎⴻⴳⴳⵉⵣ ⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⵛⵛⴰⵜⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵊⵊⵉⵡⴻⵏ ⵙ ⵓⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LM3_31","026_3_31","LAM","3","31","31","ⴽⴰⴼ. ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⵏⴻⵟⵟⴰⵔ ⵃⴻⴷ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("LM3_32","026_3_32","LAM","3","32","32","ⴽⴰⴼ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵛⴹⴻⵏ ⵃⴻⴷ, ⴰⴷ ⵅⴰⵙ ⵉⵃⵉⵏⵏ ⵄⴰⵡⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LM3_33","026_3_33","LAM","3","33","33","ⴽⴰⴼ. ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵚⵚⴰⵔ ⵏⵉⵖ ⵉⵙⵙⴻⵛⴹⵉⵏ ⵜⴰⵔⵡⴰ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("LM3_34","026_3_34","LAM","3","34","34","ⵍⴰⵎⵉⴷ. ⵅⵎⵉ ⵖⴰ ⵍⴻⴱⵣⴻⵏ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴱⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LM3_35","026_3_35","LAM","3","35","35","ⵍⴰⵎⵉⴷ. ⵅⵎⵉ ⵖⴰ ⵃⴰⵔⵔⴼⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ");
INSERT INTO rift_vpl VALUES ("LM3_36","026_3_36","LAM","3","36","36","ⵍⴰⵎⵉⴷ. ⵅⵎⵉ ⵖⴰ ⵇⴻⵍⴱⴻⵏ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵣⴻⵄⵎⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("LM3_37","026_3_37","LAM","3","37","37","ⵎⵉⵎ. ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("LM3_38","026_3_38","LAM","3","38","38","ⵎⵉⵎ. ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LM3_39","026_3_39","LAM","3","39","39","ⵎⵉⵎ. ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵛⴻⵜⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵉⴷⴷⴰⵔⴻⵏ ⵄⴰⴷ? ⴻⵊⵊ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⵛⴻⵜⵛⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_40","026_3_40","LAM","3","40","40","ⵏⵓⵏ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵅⵣⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵖ, ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵏⴰⵔⵣⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵏⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_41","026_3_41","LAM","3","41","41","ⵏⵓⵏ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴽ-ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⵓⵍⴰ ⴷ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ, ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_42","026_3_42","LAM","3","42","42","ⵏⵓⵏ. ⵏⴻⵛⵛⵉⵏ ⵏⵄⴻⴷⴷⴰ ⵓ ⵏⵖⴻⵡⵡⴻⵖ, ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵖⴼⴰⵔⴻⴷ ⵛⴰ ⵉ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_43","026_3_43","LAM","3","43","43","ⵙⴰⵎⵉⵅ. ⵛⴻⴽ ⵜⵍⴻⵃⵃⴼⴻⴷ ⴰⵏⴻⵖ ⵙ ⵡⴻⵖⴹⴰⴱ, ⵜⴻⴹⴼⴰⵔⴻⴹ ⴰⵏⴻⵖ, ⵜⴻⵏⵖⵉⴷ, ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵜⵃⵉⵡⵍⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_44","026_3_44","LAM","3","44","44","ⵙⴰⵎⵉⵅ. ⵜⵍⴻⵃⵃⴼⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⵙⴻⵢⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⴼ ⵜⴰⵥⴰⴵⵉⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_45","026_3_45","LAM","3","45","45","ⵙⴰⵎⵉⵅ. ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ-ⴷⴷ ⴰⵏⴻⵖ ⴷ ⵜⴰⵅⵎⵓⵊⵉ ⴷ ⵡⴻⴼⵔⴰⴹ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("LM3_46","026_3_46","LAM","3","46","46","ⴱⵉ. ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ ⴰⵔⵣⵎⴻⵏ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_47","026_3_47","LAM","3","47","47","ⴱⵉ. ⵜⵉⴳⴳⵯⵓⴷⴰ ⴷ ⵍⴼⴻⵅ ⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵣⵢⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ, ⴰⵅⴰⵔⵔⴻⴱ ⴷ ⴰⵔⵥⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LM3_48","026_3_48","LAM","3","48","48","ⴱⵉ. ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵜⵜⴰⵣⵣⵍⴻⵏⵜ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵅ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_49","026_3_49","LAM","3","49","49","ⵄⴰⵢⵉⵏ. ⵜⵉⵟⵟ ⵉⵏⵓ ⵜⴻⵇⵇⵉⵎ ⵜᵉⵜⵜⴰⵣⵣⴻⵍ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⵢⵢⵉⵃ, ⵡⴰⵔ ⵜⴻⵙⵙⴱⴻⴷⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LM3_50","026_3_50","LAM","3","50","50","ⵄⴰⵢⵉⵏ. ⴰⵍ ⴷ ⵉ ⵖⴰ ⵉⵙⵙⵉⵊⵊ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_51","026_3_51","LAM","3","51","51","ⵄⴰⵢⵉⵏ. ⵜⵉⵟⵟ ⵉⵏⵓ ⵜᵉⵜⵜⴻⴳⴳ ⴰⵢⵉ ⵍⴻⵃⵔⵉⵇ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_52","026_3_52","LAM","3","52","52","ⵜⵙⴰⴷⵉ. ⴰⵔⴻⴷⴷⴼⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LM3_53","026_3_53","LAM","3","53","53","ⵜⵙⴰⴷⵉ. ⵏⵉⵜⵏⵉ ⵙⵙⴱⴻⴽⵎⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷⴻⴳ ⵡⴰⵏⵓ, ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⴰⵥⵔⵓ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_54","026_3_54","LAM","3","54","54","ⵜⵙⴰⴷⵉ. ⴰⵎⴰⵏ ⵃⴻⵎⵍⴻⵏ-ⴷⴷ ⵅ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵏⵏⵉⵖ: “ⴰⵇⴰ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵖ ⴵⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("LM3_55","026_3_55","LAM","3","55","55","ⵇⵓⴼ. ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵣⵉ ⵍⴰⴵⴰⵖ ⵏ ⵡⴰⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_56","026_3_56","LAM","3","56","56","ⵇⵓⴼ. ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⵇⵇⴻⵏ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵓⵣⴻⵀⵀⴰⵔ ⵉⵏⵓ, ⵣⵣⴰⵜ ⵉ ⵉⵖⵓⵢⵢⴰⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("LM3_57","026_3_57","LAM","3","57","57","ⵇⵓⴼ. ⵛⴻⴽ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵖⴰⵔⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵍⴰⵖⵉⵖ, ⵜⴻⵏⵏⵉⴷ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("LM3_58","026_3_58","LAM","3","58","58","ⵔⵉⵅ. ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵜⴰⵔⴻⴼⵄⴻⴷ ⴷⴷⵄⴰⵡⵉ ⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_59","026_3_59","LAM","3","59","59","ⵔⵉⵅ. ⴰ ⵙⵉⴷⵉ, ⵜⴻⵥⵔⵉⴷ ⴷⴷⴻⴵ ⵉ ⴷⴰⵢⵉ ⵉⴳⴳⵉⵏ, ⴰⵖ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_60","026_3_60","LAM","3","60","60","ⵔⵉⵅ. ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵅⵍⴰⴼ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵏⵡⴰⵏ ⴹⵉⴷⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM3_61","026_3_61","LAM","3","61","61","ⵛⵉⵏ. ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵍⵃⴻⴳⵔⴰ ⵏⵙⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵏⵡⴰⵏ ⴹⵉⴷⴷ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("LM3_62","026_3_62","LAM","3","62","62","ⵛⵉⵏ. ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵊⴰⵔ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⴽⴽⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵍⴻⵎⵡⴰⵢⴰⵍ ⵏⵙⴻⵏ ⵏ ⵓⵅⴰⵔⵔⴻⵚ ⵅⴰⴼⵉ ⴰⵙⵙ ⵉⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_63","026_3_63","LAM","3","63","63","ⵛⵉⵏ. ⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵖⵉⵎⵉ ⴷ ⵓⴱⴻⴷⴷⵉ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ ⴷ ⵉⵣⵍⵉ ⵏⵙⴻⵏ ⵏ ⵓⵙⵜⴻⵀⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("LM3_64","026_3_64","LAM","3","64","64","ⵜⴰⴼ. ⴰ ⵙⵉⴷⵉ, ⵅⴻⴵⴻⵚ ⵉ-ⵜⴻⵏ ⵍⵎⵓⵏⴻⵜ ⵏⵙⴻⵏ ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM3_65","026_3_65","LAM","3","65","65","ⵜⴰⴼ. ⵙⴷⴰⵖⵔⴻⵍ ⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴻⵊⵊ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⴷⴷ-ⵅⴰⵙⴻⵏ-ⵜⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LM3_66","026_3_66","LAM","3","66","66","ⵜⴰⴼ. ⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵇⴹⴰ ⵅⴰⵙⴻⵏ ⵣⵉ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LM4_1","026_4_1","LAM","4","1","1","ⴰⵍⵉⴼ. ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵉⴱⴱⴰⵔⵛⴻⵏ ⵡⵓⵔⴻⵖ ⴰⵎⵎⵓ, ⵎⴰⵎⵎⴻⵛ ⵉⴱⴻⴷⴷⴻⵍ ⵡⵓⵔⴻⵖ ⵉⵛⵏⴰ ⵇⴰⵄ ⴰⵎⵎⵓ! ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵉⵥⵔⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵉⴱⵔⵉⴷⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("LM4_2","026_4_2","LAM","4","2","2","ⴱⵉⵜ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵖⵍⴰⵏ ⵏ ⵚⵉⵀⵢⵓⵏ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ. ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵅⵅⵓ ⴰⵎ ⵢⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵜⵍⴰⵅⵜ, ⴰⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ! ");
INSERT INTO rift_vpl VALUES ("LM4_3","026_4_3","LAM","4","3","3","ⴳⵉⵎⴻⵍ. ⵄⴰⴷ ⵜⵓⵛⵛⴰⵏⵉⵏ ⵏ ⵍⴻⵅⵍⴰ ⵉ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⵉⴱⴱⵉⵛⵉⵏ, ⵙⵙⵓⵟⵟⵓⴹⴻⵏⵜ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏⵜ, ⵎⴰⵛⴰ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵡⵄⴰⵔ, ⴰⵎ ⵏⵏⵄⴰⵎⴰⵜ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LM4_4","026_4_4","LAM","4","4","4","ⴷⴰⵍⵉⵜ. ⵉⵍⴻⵙ ⵏ ⵡⴻⵃⴹⵉⴹ ⵉⵍⵚⴻⵇ ⵖⴰⵔ ⵡⴰⵏⴻⵖ ⵏⵏⴻⵙ ⵙ ⵓⴼⴰⴷⵉ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵜᵉⵜⵜⴰⵔⴻⵏ ⴰⵖⵔⵓⵎ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜ ⵢⴻⴱⴹⵉ. ");
INSERT INTO rift_vpl VALUES ("LM4_5","026_4_5","LAM","4","5","5","ⵀⵉ. ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵣⵉⵛ ⵎⴰⵛⵛⴰ ⵉⵍⴻⴷⴷⴻⵏ, ⵖⴰⵛⴰⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵢⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵃⴻⵏⵏⴹⴻⵏ ⵍⴻⵅⵅⵓ ⴷⵉ ⵍⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LM4_6","026_4_6","LAM","4","6","6","ⵡⴰⵡ. ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵙⴰⴷⵓⵎ, ⵜⴻⵏⵏⵉ ⵉⵏⵇⴻⵍⴱⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ, ⴱⵍⴰ ⵜⵜⵙⴰⵅⵅⵓⵔ ⵏ ⵉⴼⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM4_7","026_4_7","LAM","4","7","7","ⵣⴰⵢⵉⵏ. ⵜⵓⵖⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏⵏⴻⵙ ⵚⴼⴰⵏ ⵅ ⵡⴻⴷⴼⴻⵍ, ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⵅ ⵓⵖⵉ, ⴰⵔⵔⵉⵎⴰⵜ ⵏⵙⴻⵏ ⵣⴻⵡⵖⴻⵏ ⵅ ⵍⵎⴰⵔⵊⴰⵏ, ⴰⴷⴷⵓⴷ ⵏⵙⴻⵏ ⵢⴰⵔⴻⵇⵇ ⴰⵎ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("LM4_8","026_4_8","LAM","4","8","8","ⵅⵉⵜ. ⵍⴻⵅⵅⵓ ⵉⴱⴻⴷⴷⴻⵍ ⵡⴰⴷⴷⵓⴷ ⵏⵙⴻⵏ, ⵉⴷⵡⴻⵍ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵅ ⵜⴰⴵⴻⵙⵜ, ⵡⴰⵔ ⵜⵜⵡⴰⵄⵇⵉⵍⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵄⴰⴷ. ⵜⵉⵍⵎⴻⵛⵜ ⵏⵙⴻⵏ ⵜⴻⵍⵚⴻⵇ ⵅ ⵢⴻⵖⵙⴰⵏ ⵏⵙⴻⵏ, ⵜⵓⵥⴻⵖ, ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("LM4_9","026_4_9","LAM","4","9","9","ⵜⵉⵜ. ⵉⵃⵍⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵍⴰⵥ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⵙⵢⴻⵏ, ⵜⵜⵡⴰⵍⴻⵇⴼⴻⵏ ⵙ ⵡⴻⵏⵇⴰⵙ ⵏ ⵚⵚⴰⴱⴻⵜ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LM4_10","026_4_10","LAM","4","10","10","ⵢⵓⴷ. ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵃⵉⵏⵏⴰⵏ ⵇⴱⴻⵍ, ⵙⵙⵏⴻⵏⵏⴰⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴰⵙⴻⵏⵜ ⴷ ⵎⴰⵛⵛⴰ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵔⴻⵥⵥⵉⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LM4_11","026_4_11","LAM","4","11","11","ⴽⴰⴼ. ⵙⵉⴷⵉ ⵢⴰⵔⵅⵓ ⵉ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵙ, ⵉⵙⵙⴼⴰⵔⵔⴻⵖ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵏⵏⵉ ⵉⵛⵛⴻⵏ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM4_12","026_4_12","LAM","4","12","12","ⵍⴰⵎⵉⴷ. ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵍ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⵇⴰ ⴰⵖⵔⵉⵎ ⴷ ⵍⴻⵄⴷⵓ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LM4_13","026_4_13","LAM","4","13","13","ⵎⵉⵎ. ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LM4_14","026_4_14","LAM","4","14","14","ⵏⵓⵏ. ⵜⴻⵜⵜⵍⵉⵄⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ, ⵎⴻⵙⵍⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵃⴰⴷⴰ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM4_15","026_4_15","LAM","4","15","15","ⵙⴰⵎⵉⵅ. “ⴰⴳⴳⵯⴻⵊⴻⵎ, ⴰⵇⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵅⴻⵎⵊⴻⵏ!”, ⵍⴰⵖⴰⵏ ⴰⵙⴻⵏ: “ⴰⴳⴳⵯⴻⵊⴻⵎ, ⴰⴳⴳⵯⴻⵊⴻⵎ, ⵡⴰⵔ ⵜ ⵜⵜⵃⴰⴷⴰⵎ!” ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ, ⵇⵇⵉⵎⴻⵏ ⵡⴻⴷⴷⴰⵔⴻⵏ. ⵉⵜⵜⵡⴰⵏⵏⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ ⵄⴰⴷ ⴽⵜⴰⵔ ⴰⵎ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LM4_16","026_4_16","LAM","4","16","16","ⴱⵉ. ⴰⵖⴻⵎⴱⵓⴱ ⵏ ⵙⵉⴷⵉ ⵢⴰⵔⴻⵢⵢⴻⵛ ⵉ-ⵜⴻⵏ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵉⵅⵣⴰⵔ ⵄⴰⴷ. ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴰⵡⴻⵇⵇⴰⵔ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵡⴻⵙⵙⵓⵔⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵙⵙⴻⵛⵏⴻⵏ ⴰⵃⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LM4_17","026_4_17","LAM","4","17","17","ⵄⴰⵢⵉⵏ. ⵍⴻⴱⴷⴰ ⵜⵜⴻⴼⵛⵉⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ, ⵓⵎⵉ ⵅⵣⴰⵔⴻⵏⵜ ⵖⴰⵔ ⵜⵡⵉⵣⴰ. ⵜⵓⵖⴰ-ⵜ ⴱⴰⵟⴻⵍ! ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵅⴻⵣⵣⴰⵔ ⵏⵏⴻⵖ ⵏⴻⵜⵜⵔⴰⵊⴰ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LM4_18","026_4_18","LAM","4","18","18","ⵜⵙⴰⴷⵉ. ⵏⵉⵜⵏⵉ ⵃⵚⴰⵔⴻⵏ ⴰⵏⴻⵖ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵏⴻⵇⵇⵉⵎ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵓⵢⵓⵔ ⵅ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏⵏⴻⵖ. ⵇⴻⵟⵟⵓ ⵏⵏⴻⵖ ⵜⵓⵖⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ, ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ ⵇⴹⴰⵏ, ⵡⴰⵀ, ⵇⴻⵟⵟⵓ ⵏⵏⴻⵖ ⵢⵓⵙⴰ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("LM4_19","026_4_19","LAM","4","19","19","ⵇⵓⴼ. ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴼⵙⵓⵙⴻⵏ ⵅ ⵉⴳⵉⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵏⵉⵜⵏⵉ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵏⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ, ⴳⴳⵉⵏ ⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LM4_20","026_4_20","LAM","4","20","20","ⵔⵉⵅ. ⵏⵏⴻⴼⵙ ⵏ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵖ, ⵍⵎⴰⵙⵉⵃ ⵏ ⵙⵉⴷⵉ, ⵉⵜⵜⵡⴰⵃⴻⴱⴱⴻⵙ ⴷⵉ ⵉⵃⵓⴼⴰⵔ ⵏⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵅ ⵏⴻⵏⵏⴰ: “ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("LM4_21","026_4_21","LAM","4","21","21","ⵛⵉⵏ. ⵙⵍⵉⵡⵍⴻⵡ ⵓ ⴼⴰⵔⵃ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵉⴷⵓⵎ, ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵄⵓⵚ! ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵛⴻⵎ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵢⴰⵙ ⵍⴽⴰⵙ, ⵛⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵛⴰⵔⴻⴷ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("LM4_22","026_4_22","LAM","4","22","22","ⵜⴰⴼ. ⵖⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵓⵏⴻⴳⴳⴰⵔ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ! ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉ ⵛⴻⵎ ⵉⵜⵜⵃⴻⵡⵡⵉⵙ ⵄⴰⴷ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵉⵅⴻⴵⴻⵚ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵎ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵉⴷⵓⵎ! ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⴰⵔⵔⴰ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LM5_1","026_5_1","LAM","5","1","1","ⵄⵇⴻⵍ, ⴰ ⵙⵉⴷⵉ, ⵅ ⵎⵉⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵎⵙⴰⵔⴻⵏ, ⵅⵣⴰⵔ-ⴷⴷ ⵓ ⵡⴰⵍⴰ ⵍⵃⴻⴳⵔⴰ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LM5_2","026_5_2","LAM","5","2","2","ⵜⴻⵡⴹⴰ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵖ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵖ ⵔⵓⵃⴻⵏⵜ ⵜⵜ ⵖⴰⵔ ⵎⵉⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM5_3","026_5_3","LAM","5","3","3","ⵏⴻⵛⵛⵉⵏ ⵏⴻⴷⵡⴻⵍ ⴷ ⵉⵢⵓⵊⵉⵍⴻⵏ ⴱⵍⴰ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵜⵉⵢⴻⵎⵎⴰⵜⵉⵏ ⵏⵏⴻⵖ ⴷⴻⵡⵍⴻⵏⵜ ⴰⵎ ⵜⵉⵊⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LM5_4","026_5_4","LAM","5","4","4","ⴰⵎⴰⵏ ⵏⵏⴻⵖ ⵏⵙⴻⵙⵙ ⵉ-ⵜⴻⵏ ⵙ ⵜⵎⴻⵏⵢⴰⵜ, ⴰⴽⴻⵛⵛⵓⴹ ⵏⵏⴻⵖ ⵏⴻⵜⵜⵅⴻⴵⴰⵚ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LM5_5","026_5_5","LAM","5","5","5","ⴹⴻⴼⴼⴰⵔⴻⵏ ⴰⵏⴻⵖ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵎⵎⵓⵜ ⵙ ⵍⵡⴻⵃⵍⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵊⵊⵉⵏ ⴰⵔⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LM5_6","026_5_6","LAM","5","6","6","ⴰⵇⴰ ⵏⵙⴰⵔⵔⴻⵃ ⴰⴼⵓⵙ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⴰⵛⵛⵓⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵊⵊⵉⵡⴻⵏ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("LM5_7","026_5_7","LAM","5","7","7","ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵖ ⵅⴹⴰⵏ, ⵡⴰⵔ ⴵⵉⵏ ⵄⴰⴷ. ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴰⵔⴻⴱⴱⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM5_8","026_5_8","LAM","5","8","8","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴷⴻⴱⴱⴰⵔⴰⵏ ⵅⴰⵏⴻⵖ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏⴼⴻⴽⴽⵉ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM5_9","026_5_9","LAM","5","9","9","ⵏⴻⵛⵛⵉⵏ ⵏⵙⴻⴱⴱⴻⵍ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵏⴰⵡⵉ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵖ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵙⵉⴼ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LM5_10","026_5_10","LAM","5","10","10","ⵜⵉⵍⵎⴻⵛⵜ ⵏⵏⴻⵖ ⵜᵉⵜⵜⴻⵃⴷⵓⴷⵓⵇ ⴰⵎ ⵜⴻⴼⵇⵓⵏⵜ, ⵣⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("LM5_11","026_5_11","LAM","5","11","11","ⵙⵙⵅⴰⵔⴳⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵓⵍⴰ ⴷ ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LM5_12","026_5_12","LAM","5","12","12","ⵍⵃⵓⴽⴽⴰⵎ ⵢⵓⵢⵍⴻⵏ ⵜⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵉⵡⴻⵙⵙⵓⵔⴰ ⵡⴰⵔ ⵜⴻⵏ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LM5_13","026_5_13","LAM","5","13","13","ⵉⵔⵢⴰⵣⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵇⴰⵄ ⴰⵔⴻⴱⴱⵓⵏ ⵉⵥⵔⴰ ⵏ ⵜⵙⵉⵔⵜ, ⵓ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵜⵜⵏⴻⵇⵔⴰⴹⴻⵏ ⵙⴰⴷⵓ ⵍⴻⵃⵎⴻⵍ ⵏ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("LM5_14","026_5_14","LAM","5","14","14","ⵉⵎⵖⴰⵔⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⵖⵉⵎⵉ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵣⴻⴳ ⵓⵣⴻⵏⵣⵓⵏ ⵏⵙⴻⵏ ⵅ ⵉⴼⵉⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LM5_15","026_5_15","LAM","5","15","15","ⵜⵡⴻⴷⴷⴰⵔ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵖ, ⵛⵛⴹⵉⵃ ⵏⵏⴻⵖ ⵙ ⵏⵏⵓⴱⵜⴰⵜ ⵉⴷⵡⴻⵍ ⴷ ⴰⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LM5_16","026_5_16","LAM","5","16","16","ⵉⵡⴹⴰ ⴰⵏⴻⵖ ⵜⴰⵊⵊ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵖ. ⵓⵛⵜ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LM5_17","026_5_17","LAM","5","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵀⵍⴻⵛ ⵡⵓⵍ ⵏⵏⴻⵖ ⴰⵟⵟⴰⵙ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴱⴱⴰⵔⴻⵛⵏⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("LM5_18","026_5_18","LAM","5","18","18","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴱⴻⵏ, ⵎⴰⵏⵉ ⵜⵜⴰⵡⵢⴻⵏ ⵜⵜⴰⵔⵔⴰⵏ ⵉⵛⴻⵄⴱⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LM5_19","026_5_19","LAM","5","19","19","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵉ ⵍⴻⴱⴷⴰ, ⵍⴽⵓⵔⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LM5_20","026_5_20","LAM","5","20","20","ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ ⴰⴷ ⴰⵏⴻⵖ ⵜᵉⵜⵜⵓⴷ ⵉ ⵍⴻⴱⴷⴰ? ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⴷⴰⵢⵏⴻⵖ ⵜⵙⴻⵎⵃⴻⴷ ⵇⴰⵄ ⴰⵏⴻⵛⵜ ⵓⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("LM5_21","026_5_21","LAM","5","21","21","ⴰ ⵙⵉⴷⵉ, ⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵏⴻⴷⵡⴻⵍ. ⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵖ ⴷ ⵊⴷⵉⴷ ⴰⵎ ⵣⵉⵛ. ");
INSERT INTO rift_vpl VALUES ("LM5_22","026_5_22","LAM","5","22","22","ⵎⴰⵖⴰⵔ ⵎⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵏⴻⵖ ⴽⵓⵍⵛⵉ? ⵎⴰ ⵜⴻⴼⴼⵓⴳⵎⴻⴷ ⵅⴰⵏⴻⵖ ⴰⵎⵎⵓ ⵇⴰⵄ? ");
INSERT INTO rift_vpl VALUES ("EK1_1","027_1_1","EZK","1","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⵉⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵢⵓⵔ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵔⴻⵣⵎⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵡⴻⵃⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EK1_2","027_1_2","EZK","1","2","2","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵢⵓⵔ - ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⵓⵢⴰⴽⵉⵏ - ");
INSERT INTO rift_vpl VALUES ("EK1_3","027_1_3","EZK","1","3","3","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵃⵉⵣⵇⵉⵢⴰⵍ, ⵎⵎⵉⵙ ⵏ ⴱⵓⵣⵉ, ⴰⴽⴻⵀⵀⴰⵏ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK1_4","027_1_4","EZK","1","4","4","ⵥⵔⵉⵖ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵣⵉ ⵛⵛⴰⵎⴰⵍ, ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵜᵉⵜⵜⵛⴻⵄⵄⴻⵍ, ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵉ ⵓⵙⴻⵢⵏⵓ ⵉⵊⵊ ⵏ ⵓⵡⴻⵙⵙⴻⴳ. ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵉⴱⴰⵏ-ⴷⴷ ⵛⴰ ⴰⵎ ⵡⵓⵣⵣⴰⵍ ⵉⵜⵜⵡⴻⵙⵙⴳⴻⵏ, ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK1_5","027_1_5","EZK","1","5","5","ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵜⴱⴰⵏ-ⴷⴷ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ. ⴰⵎⵎⵓ ⴷⴷ-ⴹⵀⴰⵔⴻⵏ ⵢⵉⵏⴰ: ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵚⵚⵉⴼⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK1_6","027_1_6","EZK","1","6","6","ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_7","027_1_7","EZK","1","7","7","ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏⵉⵛⴰⵏ ⵓ ⵜⵉⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵓⵄⴻⵊⵎⵉ ⵓⵛⴰ ⵜⵜⵉⵙⵙⵉⵇⴻⵏⵜ ⵜⵍⴻⵇⵇⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⵏⵏⵃⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_8","027_1_8","EZK","1","8","8","ⵙⴰⴷⵓ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ. ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵓⴷⵎⴰⵡⴻⵏ ⴷ ⵡⴰⴼⵔⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_9","027_1_9","EZK","1","9","9","ⵜⵓⵖⴰ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵎⵓⵏⴻⵏ ⵉⵊⵊ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵛⴰ ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ. ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳⵓⵔ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK1_10","027_1_10","EZK","1","10","10","ⴰⵔⵡⴰⵙ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵢⵔⴰⴷ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⵓⴼⵓⵏⴰⵙ ⵓⵛⴰ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵓⴷⴻⵎ ⵏ ⵓⴳⵉⴷⴻⵔ. ");
INSERT INTO rift_vpl VALUES ("EK1_11","027_1_11","EZK","1","11","11","ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵎⵙⴻⴱⴹⴰⵏ ⵖⴰⵔ ⵜⵉⵡⴰ. ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵜⵜⵎⵓⵏⴰⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵓ ⵜⵏⴰⵢⴻⵏ ⴷⵍⵉⵏ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_12","027_1_12","EZK","1","12","12","ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ⵎⴰⵏⵉ ⵎⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⵔⵔⵓⵃ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵏⴻⵇⵍⵉⴱⴻⵏ ⵛⴰ ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_13","027_1_13","EZK","1","13","13","ⵅ ⵡⴰⵔⵡⴰⵙ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ: ⴰⵇⴰ ⴱⴰⵏⴻⵏ-ⴷⴷ ⴰⵎ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵉⵛⴻⵎⵎⴹⴻⵏ, ⴰⵎ ⵢⵉⵚⴻⴼⴹⴰⵡⴻⵏ. ⵜⵓⵖⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵜᵉⵜⵜⵔⴰⵃ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⵊⴰⵔ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵜᵉⵜⵜⵉⵙⵙⵉⵇ ⵓ ⵣⵉ ⵜⵎⴻⵙⵙⵉ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵡⴰⵙⵙⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_14","027_1_14","EZK","1","14","14","ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ, ⴷⴻⴽⴽⵡⴰⵍⴻⵏ-ⴷⴷ, ⵉⵜⵜⴱⴰⵏ ⴰⵎ ⵡⴰⵙⵙⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_15","027_1_15","EZK","1","15","15","ⵍⴰⵎⵉ ⵥⵔⵉⵖ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ, ⵅⵣⴰⵔ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵜⴱⴻⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵖⴰⵔ ⴽⵓⵍ ⵉⵊⵊ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_16","027_1_16","EZK","1","16","16","ⵜⴰⵊⴰⵔⵔⴰⵔⵉⵏ ⴷ ⵜⵡⴰⴳⴳⵉⵜ ⵏⵙⴻⵏ ⴱⴰⵏⴻⵏⵜ-ⵉ-ⴷⴷ ⴰⵎ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ ⵓ ⵖⴰⵔⵙⴻⵏ ⵚⵚⵉⴼⴻⵜ ⴷ ⵉⵛⵜ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ. ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⴹⵀⴰⵔⴻⵏⵜ ⵓ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵜⵓⵖⴰ ⴰⵅⵎⵉ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵜⵓⵖⴰ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK1_17","027_1_17","EZK","1","17","17","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ, ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵏⴻⵇⵍⵉⴱⴻⵏ ⵛⴰ ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_18","027_1_18","EZK","1","18","18","ⵢⴰⵏⵜⴰⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵓⵄⵍⴰⵏⵜ ⵓ ⵙⵙⴰⴳⵯⴰⴷⴻⵏⵜ ⵓ ⵢⴰⵏⵜⴰⵜ ⵏⵙⴻⵏ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉ ⴷ ⴰⵙⴻⵏⵜ-ⵉ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ, ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK1_19","027_1_19","EZK","1","19","19","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⴳⴳⵓⵔⴻⵏⵜ ⵓⵍⴰ ⴷ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵏⵉ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵙⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵓ ⵅⵎⵉ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵓⵍⴰ ⴷ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_20","027_1_20","EZK","1","20","20","ⴰⵍ ⵎⴰⵏⵉ ⵉⵅⵙ ⴰⵔⵔⵓⵃ ⴰⴷ ⵢⵓⵢⵓⵔ, ⴷⵉⵏ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵏⵉ ⵉⵅⵙ ⴰⵔⵔⵓⵃ ⴰⴷ ⵉⵔⴰⵃ, ⵓⵛⴰ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ, ⵎⴰⵖⴰⵔ ⴰⵔⵔⵓⵃ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴷⵉ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_21","027_1_21","EZK","1","21","21","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⴳⴳⵓⵔⴻⵏⵜ ⵓⵍⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ, ⵓ ⵅⵎⵉ ⵜⵜⴱⴻⴷⴷⴰⵏ ⵏⵉⵜⵏⵉ, ⴱⴻⴷⴷⴻⵏⵜ ⵓⵍⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ ⵓ ⵅⵎⵉ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ, ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵓⵍⴰ ⴷ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵔⵔⵓⵃ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴷⵉ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_22","027_1_22","EZK","1","22","22","ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⵉⵏ ⵢⴰⵔⴻⵡⵙⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵇⵓⴱⴱⴻⵜ, ⵜⴱⴰⵏ-ⴷⴷ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵇⵓⴱⴱⴻⵜ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵡⴻⵊⵔⵉⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_23","027_1_23","EZK","1","23","23","ⵙⴰⴷⵓ ⵍⵇⵓⴱⴱⴻⵜ ⵜⵓⵖⴰ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵙⴻⴳⴳⵎⴻⵏ, ⵙⵙⵡⵉⵥⵥⴰⴹⴻⵏ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⵙ, ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⵉ, ⵜⵓⵖⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_24","027_1_24","EZK","1","24","24","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ, ⵙⵍⵉⵖ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵎ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵇⴰ ⵍⵃⴻⵙⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⵍⵃⴻⵙⵙ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵍⴰⵎⵉ ⴱⴻⴷⴷⴻⵏ, ⵙⵙⴻⵀⵡⴰⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_25","027_1_25","EZK","1","25","25","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵇⵓⴱⴱⴻⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ. ⵍⴰⵎⵉ ⵅⴻⵏⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ, ⵙⵙⴻⵀⵡⴰⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK1_26","027_1_26","EZK","1","26","26","ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵇⵓⴱⴱⴻⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵉⴱⴰⵏ-ⴷⴷ ⵛⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ ⵙ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ ⵓ ⵙⴻⵏⵏⴻⵊ ⵇⴰⵄ ⵅ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ ⴰⵎ ⵍⵄⴰⵔⵛ, ⵉⵇⵇⵉⵎ ⵅⴰⵙ ⵙⴻⵏⵏⴻⵊ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ ⴰⵎ ⵚⵚⵉⴼⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK1_27","027_1_27","EZK","1","27","27","ⵓⵛⴰ ⵥⵔⵉⵖ ⴰⵇⴰ ⵚⵙⵉⴼⴻⵜ ⵜᵉⵜⵜⴱⴰⵏ ⴰⵎ ⵡⵓⵣⵣⴰⵍ ⵉⵜⵜⵡⴻⵙⵙⴳⴻⵏ, ⵜⴱⴰⵏ-ⴷⴷ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ. ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⴰⵍ ⵙⴻⵏⵏⴻⵊ ⵓ ⵣⵉ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⴰⵍ ⵡⴰⴷⴷⴰⵢ, ⵥⵔⵉⵖ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵡⴻⵙⵙⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("EK1_28","027_1_28","EZK","1","28","28","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜᵉⵜⵜⴱⴰⵏ ⵜⴻⵙⵍⵉⵜ ⵏ ⵡⴻⵏⵥⴰⵔ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵡⴻⵏⵥⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵛⵛⵓⴼ ⵏ ⵓⵡⴻⵙⵙⴻⴳ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⵡⴰⵏⵉⵜⴰ ⴷ ⵓⴷⴻⵎ ⵏ ⵡⴰⴷⴷⵓⴷ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ. ⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵖ, ⵡⴹⵉⵖ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⵍⵉⵖ ⵜⵎⵉⵊⵊⴰ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK2_1","027_2_1","EZK","2","1","1","ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴽⴽⴰⵔ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EK2_2","027_2_2","EZK","2","2","2","ⵍⴰⵎⵉ ⴰⴽⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ, ⵢⵓⴷⴻⴼ-ⴷⴷ ⴷⴰⵢⵉ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ-ⴷⴷ ⴰⵢⵉ ⵅ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK2_3","027_2_3","EZK","2","3","3","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴻⵛⵛ ⵙⴻⴽⴽⴻⵖ ⵛⴻⴽ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ. ⵏⵉⵜⵏⵉ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⵄⴻⴷⴷⴰⵏ ⵅⴰⴼⵉ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("EK2_4","027_2_4","EZK","2","4","4","ⵏⵉⵜⵏⵉ ⴷ ⴰⵔⵔⴰⵡ ⵏ ⵡⵓⴷⴻⵎ ⵉⵇⴻⵙⵃⴻⵏ ⴷ ⵡⵓⵍ ⵉⵣⴻⵍⴳⴻⵏ. ⵏⴻⵛⵛ ⵙⴻⴽⴽⴻⵖ ⵛⴻⴽ ⵖⴰⵔⵙⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ!’ ");
INSERT INTO rift_vpl VALUES ("EK2_5","027_2_5","EZK","2","5","5","ⵎⴰ ⴰⴷ ⴰⵛ ⵙⵍⴻⵏ ⵏⵉⵖ ⴰⴷ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⴰⵏⴰⴱⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK2_6","027_2_6","EZK","2","6","6","ⵓⵛⴰ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵓⵍⴰ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ. ⵡⴰⵅⵅⴰ ⴰⵇⴰ ⴷⵉⵏ ⵖⴰⵔⴻⴽ ⵜⵉⵣⴻⴳⴳⵯⵓⵔⴰ ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓ ⵡⴰⵅⵅⴰ ⵣⴻⴷⴷⵖⴻⵏⵜ ⵖⴰⵔⴻⴽ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵏⴻⵅⵍⵉⵄ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK2_7","027_2_7","EZK","2","7","7","ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⵏⵉⵖ ⴰⴷ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⵜⵜⵖⴻⵡⵡⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK2_8","027_2_8","EZK","2","8","8","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⴻⵍ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵜⵜⵖⴻⵡⵡⵉⵖ ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ. ⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⴻⵛⵛ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EK2_9","027_2_9","EZK","2","9","9","ⵓⵛⴰ ⵥⵔⵉⵖ, ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ-ⴷⴷ ⵖⴰⵔⵉ, ⵓ ⵅⵣⴰⵔ, ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK2_10","027_2_10","EZK","2","10","10","ⵏⴻⵜⵜⴰ ⵉⴱⴻⵣⵣⴻⵄ ⵉ-ⵜ ⵣⵣⴰⵜⵉ. ⵜⵓⵖⴰ ⵢⵓⵔⴰ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⴷ ⵡⴰⴷⴷⴰⵢ ⵓⵛⴰ ⵜⵜⵡⴰⵔⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵣⵍⴰⵏ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵓⵙⵇⵉⵏⵏⴻⴼ ⴷ ⵓⵡⴻⵃⵡⴻⵃ ⵏ ⵜⴰⵎⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK3_1","027_3_1","EZK","3","1","1","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⴷⴰⵏⵉⵜⴰ, ⴻⵛⵛ ⵉ-ⵜ! ⴻⵛⵛ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EK3_2","027_3_2","EZK","3","2","2","ⵏⴻⵛⵛ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵛⵛ ⴰⵢⵉ ⴰⴷⵍⵉⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK3_3","027_3_3","EZK","3","3","3","ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵄⵍⴻⴼ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ, ⵛⵛⵓⵔ ⵜⴰⴽⵔⵉⵛⵜ ⵏⵏⴻⵛ ⵙ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ.” ⵅⴻⵏⵏⵉ ⵛⵛⵉⵖ ⵓ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵉⵥⵉⴷ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⴰⵎ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK3_4","027_3_4","EZK","3","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵢⵓⵔ, ⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK3_5","027_3_5","EZK","3","5","5","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⴷ ⵛⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵉⵡⵄⴰⵔ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉⵇⵙⴻⵃ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EK3_6","027_3_6","EZK","3","6","6","ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⴰⵟⵟⴰⵙ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵉⵡⵄⴰⵔ ⵏⵉⵖ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉⵇⵙⴻⵃ, ⵉ ⵣⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴼⴻⵀⵎⴻⴷ ⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ. ⵎⴰⵍⴰ ⵙⴻⴽⴽⴻⵖ ⵛⴻⴽ ⵖⴰⵔⵙⴻⵏ ⵏⵉⵜⵏⵉ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴰⵛ ⵙⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK3_7","027_3_7","EZK","3","7","7","ⵎⴰⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵙⴻⵍ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⴷⴷ-ⵙⵍⴻⵏ ⵖⴰⵔⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵉⵇⵙⴻⵃ ⵓ ⵖⴰⵔⵙⴻⵏ ⵓⵍ ⵢⴻⵣⵍⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("EK3_8","027_3_8","EZK","3","8","8","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵉⵇⵙⴻⵃ ⴰⵎ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵓ ⵜⴰⵏⵢⴰⵔⵜ ⵏⵏⴻⵛ ⴳⴳⵉⵖ ⵜⵜ ⵜⴻⵇⵙⴻⵃ ⴰⵎ ⵜⴻⵏⵢⴰⵔⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK3_9","027_3_9","EZK","3","9","9","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⴰⵏⵢⴰⵔⵜ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵎⵉⵔ ⵉ ⵉⴵⴰⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⵅⴻⴷⵎⴻⵛⵜ ⵏ ⵡⴻⵥⵔⵓ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄ ⵛⴰ ⵣⴻⴳ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK3_10","027_3_10","EZK","3","10","10","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵃⴹⴰ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⴻⴽ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⴻⵍ ⵖⴰⵔⵙⴻⵏ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK3_11","027_3_11","EZK","3","11","11","ⵓⵢⵓⵔ, ⴰⴷⴻⴼ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ!’, ⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⵏⵉⵖ ⴰⴷ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK3_12","027_3_12","EZK","3","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵙⵍⵉⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⴷⴷⴰⵔⴷⵉⵃ ⴰⵟⵟⴰⵙ, ⵜⴻⵇⵇⴰⵔ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("EK3_13","027_3_13","EZK","3","13","13","ⵙⵍⵉⵖ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵍⴻⵇⵇⴼⴻⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵍⴰ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵣⵣⴰⵜ ⵏⵙⴻⵏ ⵓ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⴷⴰⵔⴷⵉⵃ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK3_14","027_3_14","EZK","3","14","14","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⵢⵉ. ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ, ⴷ ⴰⵎⴰⵔⵣⴰⴳ, ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⴷⴰⵢⵉ ⵓ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴷⵇⴻⵍ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("EK3_15","027_3_15","EZK","3","15","15","ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⴷⵉ ⵜⴰⵍ-ⴰ$ⵉ$, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ. ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⴷⵉⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ, ⵡⴰⵀ, ⵇⵇⵉⵎⴻⵖ ⴷⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵜⵜⴱⴻⵀⵜⴻⵖ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK3_16","027_3_16","EZK","3","16","16","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK3_17","027_3_17","EZK","3","17","17","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴰⵄⴻⵙⵙⴰⵙ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⴽ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⵍⵎⴻⴷ ⵣⵣⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("EK3_18","027_3_18","EZK","3","18","18","ⵅⵎⵉ ⵖⴰ ⵉⵏⵉⵖ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ!’ ⵓⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵄⵍⵉⵎⴻⴷ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⵍⵎⴻⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵃⴹⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵄⴻⴼⴼⴰⵏ ⵏⵏⵉ ⴷⵉ ⵍⵖⴻⵛⵛ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵜⵜⴰⵔⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK3_19","027_3_19","EZK","3","19","19","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵄⴻⵍⵎⴻⴷ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴱⴻⵄⵄⴻⴷ ⵛⴰ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⵓ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EK3_20","027_3_20","EZK","3","20","20","“ⵎⴰⵍⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⴱⴻⵄⵄⴻⴷ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅⵎⵉ ⵖⴰ ⵙⵙⴰⵔⵙⴻⵖ ⵉⵛⵜ ⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵣⵣⴰⵜⴻⵙ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵅⴹⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ. ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵄⵍⵉⵎⴻⴷ, ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⵉ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵉ ⵢⴻⴳⴳⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵉⴷⴰⵔⴻⵏ ⵄⴰⴷ. ⵎⴰⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵜⵜⴰⵔⴻⵖ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK3_21","027_3_21","EZK","3","21","21","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵄⴻⵍⵎⴻⴷ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⴹⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵄⵍⴻⵎ, ⵓ ⵛⴻⴽ ⵜⴼⴻⴽⴽⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EK3_22","027_3_22","EZK","3","22","22","ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉⵏ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵅⴰⴼⵉ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴽⴽⴰⵔ, ⴼⴼⴻⵖ ⵖⴰⵔ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⴰⴷ ⴽⵉⴷⴻⴽ ⵙⵙⵉⵡⵍⴻⵖ ⴷⵉⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK3_23","027_3_23","EZK","3","23","23","ⴽⴽⴰⵔⴻⵖ ⵓⵛⴰ ⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ, ⵅⵣⴰⵔ, ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴻⴷⴷⴰ ⴷⵉⵏⵏⵉ ⴰⵎ ⵓⵄⵓⴵⵉ ⵉ ⵥⵔⵉⵖ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ ⵓⵛⴰ ⵡⴹⵉⵖ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK3_24","027_3_24","EZK","3","24","24","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⴷⴰⵢⵉ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⴰⵢⵉ ⵅ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵓⵢⵓⵔ, ⴱⴻⵍⵍⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ.    ");
INSERT INTO rift_vpl VALUES ("EK3_25","027_3_25","EZK","3","25","25","ⵓ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵅⵣⴰⵔ, ⴰⴷ ⴰⵛ ⴳⴳⴻⵏ ⵉⵙⴻⵖⵡⴰⵏ ⵓ ⴰⴷ ⵛⴻⴽ ⵛⴰⵔⴼⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ⵡⴰⵔ ⵜᵉⵜⵜⴻⴼⴼⴻⵖ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK3_26","027_3_26","EZK","3","26","26","ⴰⴷ ⵙⵙⵍⴻⵙⵇⴻⵖ ⵉⵍⴻⵙ ⵏⵏⴻⵛ ⵖⴰⵔ ⵡⴰⵏⴻⵖ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⵣⵉⵏⵓⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⴷ ⴰⵔⵢⴰⵣ ⵊⴰⵔ ⴰⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵡⴻⴱⴱⵅⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵖⴻⵡⵡⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK3_27","027_3_27","EZK","3","27","27","ⵎⴰⵛⴰ ⵏⴻⵛⵛ, ⵅⵎⵉ ⴽⵉⴽ ⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ, ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵡⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ, ⴰⴷ ⵉⵙⴻⵍ, ⵓⵛⴰ ⵡⵉ ⵉⵙⴻⵎⵎⵃⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵅⵅⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵙⵎⴻⵃ!’, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵖⴻⵡⵡⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EK4_1","027_4_1","EZK","4","1","1","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴽⵙⵉ ⵉⵛⵜ ⵏ ⵍⵓⵚⴰ ⵏ ⵜⵍⴰⵅⵜ ⵓⵛⴰ ⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⵔⵛⴻⵎ ⵅⴰⵙ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK4_2","027_4_2","EZK","4","2","2","ⵇⴻⵡⵡⴰⵔ ⴰⵙ ⵓⵛⴰ ⴱⵏⴰ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⴰⵊ ⵓⵛⴰ ⴻⴳⴳ ⵅⴰⵙ ⴰⵛⴱⴰⵔ, ⴻⴳⴳ ⵅⴰⵙ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⵡⵡⴻⵜ ⵅⴰⵙ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⴻⴷⵀⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EK4_3","027_4_3","EZK","4","3","3","ⵓⵛⴰ ⵛⴻⴽ, ⴽⵙⵉ ⵉⵛⵜ ⵏ ⵎⴰⵔⵎⵉⵜⴰ ⵏ ⵡⵓⵣⵣⴰⵍ ⵓⵛⴰ ⴻⴳⴳ ⵉ-ⵜⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵊⴰⵔ ⵛⴻⴽ ⴷ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵅⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵜ ⵜⴻⵃⵚⴰⵔⴻⴷ: ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK4_4","027_4_4","EZK","4","4","4","ⵓⵛⴰ ⵛⴻⴽ, ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ ⴰⵣⴻⵍⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⴳⴳⴻⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵏⴻⵛⵜ ⵏ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵜⴻⵣⵣⵍⴻⴷ, ⴰⴷ ⵜⴰⵔⴱⵓⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK4_5","027_4_5","EZK","4","5","5","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⴳⴳⴻⵖ ⵍⵄⴰⴷⴰⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴰⵎ ⵍⵄⴰⴷⴰⴷ ⵏ ⵡⵓⵙⵙⴰⵏ: ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴰⵔⴱⵓⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK4_6","027_4_6","EZK","4","6","6","ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ ⵄⴰⵡⴻⴷ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⴱⵓⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK4_7","027_4_7","EZK","4","7","7","ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜᵉⵜⵜⴰⵔⵔⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴰⴷ ⵜⵄⴰⵔⵔⵉⴷ ⴰⵖⵉⵍ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵏⴻⴱⴱⵉⴷ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK4_8","027_4_8","EZK","4","8","8","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⴳⴳⴻⵖ ⵜⵉⵙⵖⵓⵏⵉⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵏⵏⵇⴻⵍⴱⴻⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⴰⵍ ⵖⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EK4_9","027_4_9","EZK","4","9","9","“ⴽⵙⵉ ⵉⵔⴷⴻⵏ, ⵉⵎⴻⵏⴷⵉ, ⵉⴱⴰⵡⴻⵏ, ⵍⴻⵄⴷⴻⵙ, ⵜⴰⴼⵙⴰⵡⵜ ⴷ ⴽⴰⵔⵚⴰⵏⴰ ⵓⵛⴰ ⴻⴳⴳ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⴱⵇⴻⵛⵜ ⵓⵛⴰ ⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵖⵔⵓⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵢⴰ ⴰⵎ ⵎⴻⵛⵃⴰⵍ ⵍⵄⴰⴷⴰⴷ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵣⵣⵍⴻⴷ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵛ, ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK4_10","027_4_10","EZK","4","10","10","ⵎⴰⵛⵛⴰ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵛⵛⴻⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵡⵣⴻⵏ: ⵄⵉⵛⵔⵉⵏ ⵛⵉⵇⵍⵓ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ⴰⴷ ⵜⵜ ⵜⴻⵛⵛⴻⴷ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK4_11","027_4_11","EZK","4","11","11","ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⴰⵎⴰⵏ ⵙ ⵍⴻⵄⴱⴰⵔ: ⵉⵛⵜ ⵏ ⵜⵙⵉⵜⵜⵓⵜ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ. ⴰⴷ ⵜⵜ ⵜⴻⵙⵡⴻⴷ ⵣⵉ ⵍⵡⴻⵇⵜ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK4_12","027_4_12","EZK","4","12","12","ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⵉⵛⵜ ⵏ ⵜⵅⴻⴱⴱⴰⵣⵜ ⵏ ⵉⵎⴻⵏⴷⵉ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜᵉⵙⵙⴻⵏⴳⴳⵯⴻⴷ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵅ ⵉⵥⵥⴰⵏ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EK4_13","027_4_13","EZK","4","13","13","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵛⵛⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵖⵔⵓⵎ ⵏⵙⴻⵏ ⵉⵅⴻⵎⵊⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵜⴻⵏ ⵖⴰⵔ ⵉ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("EK4_14","027_4_14","EZK","4","14","14","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵄⴻⵎⵎⴰⵔⵚ ⵙ ⵎⴰⵛⵛⴰ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ ⴰⵍ ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⵛⵉⵖ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵉⵖ ⵎⵉⵏ ⵉⵎⴻⵣⵣⵇⴻⵏ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵡⴻⵢⵙⵓⵎ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("EK4_15","027_4_15","EZK","4","15","15","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵅⵣⴰⵔ, ⴰⴷ ⴰⵛ ⵡⵛⵉⵖ ⵍⴻⵖⴱⴰⵔ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⴱⴰⵔⵔⵓⴹ ⵏ ⴱⵏⴰⴷⴻⵎ. ⵙⴻⵡⵊⴻⴷ ⵅⴰⵙ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EK4_16","027_4_16","EZK","4","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵅⵣⴰⵔ, ⴰⴷ ⴰⵔⵥⴻⵖ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵙ ⵍⴻⵡⵣⴻⵏ ⵙ ⵓⵏⴻⵅⵍⵉⵄ ⵓⵛⴰ ⵙ ⴰⵔⵊⴻⴼ ⴰⴷ ⵙⵡⴻⵏ ⴰⵎⴰⵏ ⵙ ⵍⴻⵄⴱⴰⵔ,   ");
INSERT INTO rift_vpl VALUES ("EK4_17","027_4_17","EZK","4","17","17","ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴻⵖⵔⵓⵎ ⴷ ⵡⴰⵎⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⵣⴰⵔⴻⵏ ⴰⵢⴰⵡⵢⴰ ⵙ ⴰⵔⵊⴻⴼ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵔⵚⵓⴹⴻⵏ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK5_1","027_5_1","EZK","5","1","1","“ⵓⵛⴰ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵍⵎⵓⵙ ⵉⵇⴹⴻⵄ, ⴽⵙⵉ ⵉⵊⵊ ⵍⵎⵓⵙ ⵏ ⵓⵃⴻⴼⴼⴰⴼ ⵓⵛⴰ ⵙⴻⴽⴽ ⵉ-ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⵎⴰⵔⵜ ⵏⵏⴻⵛ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵊⵊ ⵏ ⵍⵎⵉⵣⴰⵏ ⵓⵛⴰ ⴰⵛⵓⵡⵡⴰⴼ ⴰⴷ ⵜⴻⵏ ⵜⴻⴱⴹⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("EK5_2","027_5_2","EZK","5","2","2","ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵜⴻⵡⵜⴻⴷ ⵙ ⵙⵙⵉⴼ ⵏⵏⴻⵛ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⵜ ⵜⵣⵓⵣⵣⴰⵔⴻⴷ ⴷⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵊⴻⴱⴷⴻⵖ ⵙⵙⵉⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK5_3","027_5_3","EZK","5","3","3","ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵛⵡⴰⵢⵜ ⵏ ⵉⵥⴻⵟⵟⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⵛⴻⴷⴷⴻⴷ ⴷⴻⴳ ⵉⴱⴻⵃⵔⵓⵔⴻⵏ ⵏ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK5_4","027_5_4","EZK","5","4","4","ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⵙⵉⴷ ⵄⴰⴷ ⵛⵡⴰⵢⵜ ⵏ ⵉⵥⴻⵟⵟⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵛⴻⵎⴹⴻⴷ ⵙ ⵜⵎⴻⵙⵙⵉ. ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⵜⵎⴻⵙⵙⵉ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EK5_5","027_5_5","EZK","5","5","5","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵜⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵥⵥⵓⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK5_6","027_5_6","EZK","5","6","6","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵖⴻⵡⵡⴻⵖ ⵅ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵎⴰⵀⵓ ⵍⴻⴳⵏⵓⵙ, ⵓⵍⴰ ⵅ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵎⴰⵀⵓ ⵜⵉⵎⵎⵓⵔⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵡⴰⵔ ⵜⴻⵏⵜ ⴹⴼⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK5_7","027_5_7","EZK","5","7","7","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵎⴰⵀⵓ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵡⴰⵔ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵜⴻⴳⴳⵉⵎ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ⵄⴰⴷ ⵡⴰⵔ ⵜⴻⴳⴳⵉⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ’, ");
INSERT INTO rift_vpl VALUES ("EK5_8","027_5_8","EZK","5","8","8","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵎ ⵇⴻⵍⴱⴻⵖ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK5_9","027_5_9","EZK","5","9","9","ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴳⴳⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴳⴳⵉⵖ ⵓ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK5_10","027_5_10","EZK","5","10","10","ⵙ ⵓⵢⴰ ⵉⴱⴰⴱⴰⵜⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⴰⵔⵔⴰⵡ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⵔⵔⴰⵡ ⴰⴷ ⵛⵛⴻⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵎ ⴳⴳⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵜ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ.’” ");
INSERT INTO rift_vpl VALUES ("EK5_11","027_5_11","EZK","5","11","11","“ⵙ ⵓⵢⴰ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵙ ⵜⵉⴷⴻⵜⵜ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⴹⵄⴻⵖ, ⵡⴰⵔ ⵣⵣⵉⴵⵉⵣⴻⵖ, ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵖ, ⵓⵎⵉ ⵜⴻⵙⵙⵅⴻⵎⵊⴻⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵏⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("EK5_12","027_5_12","EZK","5","12","12","ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵎⵎⴻⵜ ⵙ ⵟⵟⴰⵄⵓⵏ ⵓ ⵙ ⵍⴰⵥ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ, ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⴻⵡⴹⴰ ⵙ ⵙⵙⵉⴼ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵎ, ⵓ ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⴰⴷ ⵜⵜ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴰⴷ ⴷⴷ-ⵊⴻⴱⴷⴻⵖ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EK5_13","027_5_13","EZK","5","13","13","ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⴰⴷ ⵉⵊⵊⵉⵡⴻⵏ ⴰⵍ ⵓⵏⴻⴳⴳⴰⵔ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⴰⵔⵙⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⵉⵡⵍⴻⵖ ⴷⵉ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵅⵎⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK5_14","027_5_14","EZK","5","14","14","ⴰⴷ ⵛⴻⵎ ⴰⵔⵔⴻⵖ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵙⵜⴻⵀⵣⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EK5_15","027_5_15","EZK","5","15","15","ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵓⵙⵜⴻⵀⵣⵉ ⴷ ⵍⵃⴻⴳⵔⴰ, ⵉ ⵓⵎⴻⴷⵢⴰ ⵏ ⵓⵙⴻⵇⵙⴻⵃ ⴷ ⵓⵙⵉⴳⴳⵯⴻⴷ ⵉ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵅⵎⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵇⴹⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵙ ⵡⴻⵖⴹⴰⴱ ⵓ ⵙ ⵡⴻⵙⵄⴰⵔ ⵓ ⵙ ⵜⵉⵢⵉⵜⵜⴰ ⵉⵃⵎⴰⵏ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("EK5_16","027_5_16","EZK","5","16","16","ⵅⵎⵉ ⵜⴻⵏ ⵖⴰ ⵡⵜⴻⵖ ⵙ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⴰⵥ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵔⴻⴷⴷⴻⴵ, ⵜⵉⵏⵏⵉ ⵖⴰ ⵡⵜⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵀⴻⵍⵍⴽⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⴰⵔⵏⵉⵖ ⵍⴰⵥ ⵓ ⴰⴷ ⴰⵔⵥⴻⵖ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK5_17","027_5_17","EZK","5","17","17","ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⴻⴽⴽⴻⵖ ⵍⴰⵥ ⴷ ⵍⴻⵡⵃⵓⵛ ⵉⵡⵄⴰⵔⴻⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⴽⴽⵙⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ. ⵟⵟⴰⵄⵓⵏ ⴷ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴰⴷ ⴽⴽⴻⵏ ⵅⴰⵎ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵎ ⵙⵙⴻⴽⴽⴻⵖ ⵙⵙⵉⴼ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("EK6_1","027_6_1","EZK","6","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK6_2","027_6_2","EZK","6","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵏⴰⴱⴱ ⵅⴰⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EK6_3","027_6_3","EZK","6","3","3","ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉ ⵉⴷⵓⵔⴰⵔ ⵓ ⵉ ⵜⴻⵡⵔⵉⵔⵉⵏ, ⵉ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵓ ⵉ ⵜⴻⵖⵣⵓⵔⵜⵉⵏ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⴻⴽⴽⴻⵖ ⵙⵙⵉⴼ ⵓⵛⴰ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵡⴻⵎ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴻⵀⵀⴰⴱⴻⵎ ⴷⴷⴱⴰⵢⴻⵃ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⴻⴷⴷⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK6_4","027_6_4","EZK","6","4","4","ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵓ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⴱⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK6_5","027_6_5","EZK","6","5","5","ⴰⴷ ⴳⴳⴻⵖ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵣⴰⵜ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵉⵖⵙⴰⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵎⵉⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK6_6","027_6_6","EZK","6","6","6","ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ ⵓⵛⴰ ⵍⴻⴳⵄⵓⴷⵉ ⴰⴷ ⵜⴻⵏⵜ ⵊⵊⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⴷ ⵜⵜⵡⴰⵊⵊⴻⵏ, ⵓⵛⴰ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ ⵓ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴼⵓⵛⵜ ⴰⴷ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵓ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵎⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK6_7","027_6_7","EZK","6","7","7","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK6_8","027_6_8","EZK","6","8","8","“ⴰⴷ ⴳⴳⴻⵖ ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵙⵙⵉⴼ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK6_9","027_6_9","EZK","6","9","9","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⵊⵎⴻⵏ ⴰⴷ ⵅⴰⴼⵉ ⵄⴻⵇⵍⴻⵏ ⵊⴰⵔ ⵔⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵜⵜⵡⴰⵏⴻⴷⴷⵀⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵔⵥⵉⵖ ⵓⵍ ⵏⵙⴻⵏ ⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ, ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉⴹⴼⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵄⵉⴼⴼⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵉⵄⴻⴼⴼⵏⴻⵏ ⵏⵏⵉ ⴳⴳⵉⵏ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴰⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK6_10","027_6_10","EZK","6","10","10","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵏⵏⵉⵖ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴳⴳⴻⵖ ⵍⵖⴰⵔ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK6_11","027_6_11","EZK","6","11","11","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵡⵡⴻⵜ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⴷⴰⵔⵔⴻⵛ ⵙ ⵓⴹⴰⵔ ⵏⵏⴻⵛ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵢ!’ ⵅ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵡⴰⵜ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵙ ⵍⴰⵥ ⵓ ⵙ ⵟⵟⴰⵄⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("EK6_12","027_6_12","EZK","6","12","12","ⵡⵉ ⵉⴵⴰⵏ ⵢⵉⴳⴳⵯⴻⵊ ⴰⴷ ⵉⵎⵎⴻⵜ ⵙ ⵟⵟⴰⵄⵓⵏ ⵓ ⵡⵉ ⵉⴵⴰⵏ ⵢⵓⴷⴻⵙ ⴰⴷ ⵉⵡⴹⴰ ⵙ ⵙⵙⵉⴼ ⵓ ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ ⴰⴷ ⵉⵎⵎⴻⵜ ⵙ ⵍⴰⵥ, ⴰⵎⵎⵓ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK6_13","027_6_13","EZK","6","13","13","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵊⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵅ ⴽⵓⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵜⵓⵄⵍⴰ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵇⵇⵉⵛⴰⵜⵉⵏ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ ⵓ ⵙⴰⴷⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴻⴼⵔⴰⵢ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵏⵏⵓⵎⴻⵏ ⵙⵙⴻⵡⵊⴰⴷⴻⵏ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK6_14","027_6_14","EZK","6","14","14","ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵎⴰⵀⵓ ⵍⴻⵅⵍⴰ ⵏ ⴷⴰⴱⵍⴰ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK7_1","027_7_1","EZK","7","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK7_2","027_7_2","EZK","7","2","2","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵏⴻⴳⴳⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵓⵏⴻⴳⴳⴰⵔ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK7_3","027_7_3","EZK","7","3","3","ⵍⴻⵅⵅⵓ ⵢⵓⵙⴰ-ⴷⴷ ⵅⴰⵎ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵙⴻⴽⴽⴻⵖ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⴰⴷ ⵅⴰⵎ ⵃⴻⴽⵎⴻⵖ ⴰⵎ ⵢⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⴳⴳⴻⵖ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK7_4","027_7_4","EZK","7","4","4","ⵡⴰⵔ ⴷ ⴰⵎ ⵣⵣⵉⴵⵉⵣⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵖ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵎ ⵓ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ ⴰⴷ ⵛⴻⵎ ⵍⴻⵇⴼⴻⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("EK7_5","027_7_5","EZK","7","5","5","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ, ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵉⴼⴰⵔⵣⴻⵏ, ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK7_6","027_7_6","EZK","7","6","6","ⵢⵓⵙⴰ-ⴷⴷ ⵓⵏⴻⴳⴳⴰⵔ, ⴰⵏⴻⴳⴳⴰⵔ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⴼⴰⵇ-ⴷⴷ ⴹⵉⴷⴷ ⵏⵏⴻⵎ, ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ! ");
INSERT INTO rift_vpl VALUES ("EK7_7","027_7_7","EZK","7","7","7","ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⴰ ⴰⵎⴻⵣⴷⵓⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴰⵙⴰⵄⵄⴻⵜ ⵜⵓⵙⴰ-ⴷⴷ, ⴰⵙⵙ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⴰⵙⵍⵉⵡⵍⴻⵡ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK7_8","027_7_8","EZK","7","8","8","ⵍⴻⵅⵅⵓ ⴷⴻⵖⵢⴰ ⴰⴷ ⵅⴰⵎ ⵣⴻⴵⵄⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵎ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵖⴹⴰⴱ ⵉⵏⵓ. ⴰⴷ ⵅⴰⵎ ⵃⴻⴽⵎⴻⵖ ⴰⵏⴻⵛⵜ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⵙⵙⵉⵡⴹⴻⵖ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK7_9","027_7_9","EZK","7","9","9","ⵡⴰⵔ ⵣⵣⵉⴵⵉⵣⴻⵖ ⵓ ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵖ. ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵎⵉⵏ ⵜⴻⵙⵙⴷⴰⵀⴻⴵⴻⴷ, ⵓ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵛⵛⴰⵜⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK7_10","027_7_10","EZK","7","10","10","‘ⵅⵣⴰⵔ, ⴰⵙⵙ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⵜⴻⵇⴹⴰ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⵜⵏⴻⵡⵡⴰⵔ ⵜⴰⵖⵖⴰⵔⵛⵜ, ⵜⴻⵙⵙⴻⵏⴷⵉ ⵏⵏⴼⴰⵅⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EK7_11","027_7_11","EZK","7","11","11","ⵉⴳⴻⵄⵄⴻⴷ ⵍⵄⵓⵏⴼ ⴰⵎ ⵓⵣⴻⴵⴰⴹ ⵏ ⵍⵖⴰⵔ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵡⴰⵍⵓ ⵏ ⵍⵖⴰⵛⵉ ⵏⵙⴻⵏ ⵉⵏⵀⴻⵡⵍⴻⵏ, ⵡⴰⵍⵓ ⵏ ⴷⴷⵔⵉⵣ ⵏⵙⴻⵏ ⵓ ⵡⴰⵍⵓ ⵏ ⵓⵙⴻⵎⵖⴰⵔ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EK7_12","027_7_12","EZK","7","12","12","ⵜⵓⵙⴰ-ⴷⴷ ⵜⵙⴰⵄⵄⴻⵜ, ⵉⵅⴻⵛⵛⴻⴷ ⵡⴰⵙⵙ. ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵙⵖⵉⵏ ⵡⴰⵔ ⵉⴼⴰⵔⵔⴻⵃ ⵓ ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵣⵣⵏⵓⵣⴰⵏ ⵡⴰⵔ ⵉⵜⵜⴻⵛⴹⵉⵏ, ⵎⵉⵏⵣⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⴰⵇⴰ-ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK7_13","027_7_13","EZK","7","13","13","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵣⵣⵏⵓⵣⴰⵏ ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵖⴰⵔ ⵎⵉⵏ ⵉⵎⵎⴻⵏⵣⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⴱⴻⵟⵟⵉⵍ ⵍⴻⵡⵃⵉⵢ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵜⵜᵉⵟⵟⴻⴼ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK7_14","027_7_14","EZK","7","14","14","ⵏⵉⵜⵏⵉ ⵙⵓⴹⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⴷⵉ ⵍⴱⵓⵇ ⵓⵛⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵡⴰⵢⴻⵊ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ⵎⵉⵏⵣⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("EK7_15","027_7_15","EZK","7","15","15","‘ⵣⵉ ⴱⴰⵔⵔⴰ ⵙⵙⵉⴼ ⵓ ⵣⵉ ⴷⴰⵅⴻⵍ ⵟⵟⴰⵄⵓⵏ ⴷ ⵍⴰⵥ. ⵡⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⴰⴷ ⵉⵎⵎⴻⵜ ⵙ ⵙⵙⵉⴼ, ⵡⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵜ ⵢⴻⵛⵛ ⵍⴰⵥ ⴷ ⵟⵟⴰⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EK7_16","027_7_16","EZK","7","16","16","ⵡⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵢⴰⵔⴻⵡⵍⴻⵏ, ⵡⴰⵀ ⴰⴷ ⵏⴻⵊⵎⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⴰⵎ ⵉⴷⴱⵉⵔⴻⵏ ⵣⵉ ⵜⴻⵖⵣⵓⵔⵉⵏ, ⴰⴷ ⵏⵏⴻⵣⴱⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK7_17","027_7_17","EZK","7","17","17","ⵎⴰⵔⵔⴰ ⵉⴼⴰⵙⵙⴻⵏ ⴰⴷ ⵀⴻⵢⵢⴼⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵉⴼⴰⴷⴷⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵎⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK7_18","027_7_18","EZK","7","18","18","‘ⴰⴷ ⴱⴻⵢⵙⴻⵏ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ, ⴰⵔⵊⴻⴼ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵅ ⵎⴰⵔⵔⴰ ⵓⴷⵎⴰⵡⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵃⵢⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵜⵓⵇⴻⵛⵛⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK7_19","027_7_19","EZK","7","19","19","ⴰⴷ ⵏⴹⴰⵔⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵓ ⵓⵔⴻⵖ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴻⵅⵎⴻⵊ. ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ ⴷ ⵡⵓⵔⴻⵖ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⴼⴻⴽⴽⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵙⵊⵉⵡⵏⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵏⵉⵖ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵜⴰⴽⵔⵉⵛⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⵜⵓⵖⴰ ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵏⴻⵇⵔⴰⴹ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK7_20","027_7_20","EZK","7","20","20","ⴰⵥⵔⵉ ⵏ ⵜⴻⵍⵡⵉⵣⵜ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⵍⵄⴰⴹⴰⵎⴰ ⵢⵓⵄⵍⴰⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴷⴰⵢⴻⵙ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ. ⵅ ⵓⵢⴰ ⴰⵔⵔⵉⵖ ⵜⴰⵍⵡⵉⵣⵜ ⴷ ⵜⴰⵅⵎⵓⵊⵉ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK7_21","027_7_21","EZK","7","21","21","ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⴷ ⵜⵓⵛⵛⴻⴼⴼⵔⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵜⴰⵍⵡⵉⵣⵜ. ");
INSERT INTO rift_vpl VALUES ("EK7_22","027_7_22","EZK","7","22","22","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉⵏⵓ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ ⴰⴷ ⴷⵉⵏ ⴰⴷⴼⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵎⴰⵔⵔⴰ’. ");
INSERT INTO rift_vpl VALUES ("EK7_23","027_7_23","EZK","7","23","23","‘ⵙⴻⵡⵊⴻⴷ ⵙⵙⵏⴻⵙⵍⴻⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⵄⵓⵏⴼ. ");
INSERT INTO rift_vpl VALUES ("EK7_24","027_7_24","EZK","7","24","24","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⵢⴻⵖ ⵍⴻⴳⵏⵓⵙ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵇⴰⵄ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ, ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵄⵉⴵⵜⴻⵏⵜ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK7_25","027_7_25","EZK","7","25","25","ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵣⵓⵏ ⵍⴻⵀⵏⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EK7_26","027_7_26","EZK","7","26","26","ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴻⵍⵡⴰⵡ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵛⴻⵍⵡⴰⵡ, ⴰⴷ ⵢⵉⵍⵉ ⵍⵀⴰⵔⴷ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵀⴰⵔⴷ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵣⵓⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⵓⵏⴰⴱⵉ, ⵡⴰⵅⵅⴰ ⵜⴻⵇⴹⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵛⵛⵡⴰⵔ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EK7_27","027_7_27","EZK","7","27","27","ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵛⴹⴻⵏ, ⵍⵃⴰⴽⴻⵎ ⴰⴷ ⵢⴰⵔⴹ ⴰⵏⴻⵅⵍⵉⵄ ⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵇⴰⵔⵔⵎⴻⵏ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ. ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⴻⵖ ⴰⵎ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵃⴻⴽⵎⴻⵖ ⴰⵎ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵙⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK8_1","027_8_1","EZK","8","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵢⵓⵔ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵖ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵅⴰⴼⵉ ⴷⵉⵏ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK8_2","027_8_2","EZK","8","2","2","ⵏⴻⵛⵛ ⵥⵔⵉⵖ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵚⵙⵉⴼⴻⵜ ⵏⵏⴻⵙ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵙⵉ. ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ ⴰⵇⴰ ⵉⴱⴰⵏ-ⴷⴷ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵓ ⵣⵉ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⴰⵍ ⵙⴻⵏⵏⴻⵊ ⵜⵓⵖⴰ ⴰⵅⵎⵉ ⵜⴻⵥⵔⵉⴷ ⵜⵉⵙⵙⵉⵇⵜ, ⵜⴱⴰⵏ-ⴷⴷ ⴰⵎ ⵡⵓⵣⵣⴰⵍ ⵉⵜⵜⵡⴻⵙⵙⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK8_3","027_8_3","EZK","8","3","3","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ-ⴷⴷ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⵣⴰⵔⴻⵣⵜ ⵏ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ ⵊⴰⵔ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⵉ ⵉⵡⴻⵃⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵜⵓⵙⵎⵉ ⵏⵏⵉ ⵉⵙⵙⴻⴽⴽⴰⵔⴰⵏ ⵜⵓⵙⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("EK8_4","027_8_4","EZK","8","4","4","ⵓ ⵅⵣⴰⵔ, ⴷⵉⵏ ⵉ ⵉⴵⴰ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵜⵜⴱⴰⵏ-ⴷⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵥⵔⵉⵖ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK8_5","027_8_5","EZK","8","5","5","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⴳⴻⵄⵄⴻⴷ ⵍⴻⵅⵅⵓ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵛ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ!” ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⴰⵎⵓⵖⵍⵉ ⵉⵏⵓ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵎⴰⵍ, ⵓ ⵅⵣⴰⵔ, ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵍⴻⵅⵢⴰⵍ ⵏⵏⵉ ⵏ ⵚⵚⴰⵏⴰⵎ ⵏ ⵜⵓⵙⵎⵉ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴷⴻⴳ ⵡⴰⴷⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("EK8_6","027_8_6","EZK","8","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ, ⵊⵊⵄⴰⵢⴻⴼ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏⵏⵉ ⵜᵉⵜⵜⴻⴳⴳ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴰⵏⵉⵜⴰ, ⴰⵍⴰⵎⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⴳⴳⵯⴻⵊⴻⵖ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵄⴰⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵅ ⵜⵉⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK8_7","027_8_7","EZK","8","7","7","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ ⴰⵢⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⵎⵔⴰⵃ. ⵓⵎⵉ ⵥⵔⵉⵖ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵃⴼⵓⵔ ⴷⵉ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("EK8_8","027_8_8","EZK","8","8","8","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵖⴰⵣ ⵅⴻⵏⵏⵉ ⵍⵃⵉⴹ.” ⵏⴻⵛⵛ ⵖⵣⵉⵖ ⵍⵃⵉⴹ ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴰⴷⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("EK8_9","027_8_9","EZK","8","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⴷⴻⴼ, ⵓⵛⴰ ⵅⵣⴰⵔ ⵊⵊⵄⴰⵢⴻⴼ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴷⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK8_10","027_8_10","EZK","8","10","10","ⵓⴷⴼⴻⵖ ⵓⵛⴰ ⵥⵔⵉⵖ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵏⴻⵇⵇⴰⵛⴻⵏ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵜⵜⴱⵓⵄⴻⵏ, ⵏ ⵍⵎⴰⵍ ⴰⵎⴻⵏⴳⵓⵙ ⵓ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⵏⴻⵇⵛⴻⵏ ⴷⵉ ⵍⵃⵉⴷ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("EK8_11","027_8_11","EZK","8","11","11","ⴰⵇⴰ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴽ-ⴷ ⵢⴰⵣⴰⵏⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵛⴰⴼⴰⵏ, ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵙⴻⵏ, ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⵙⴻⵏ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵍⵎⴻⵊⵎⴰⵔ ⵏⵏⴻⵙ ⵏ ⵍⴻⴱⵅⵓⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⵍⵉ ⵜⴻⵊⵏⴻⵡⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EK8_12","027_8_12","EZK","8","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ ⵉⵏⴻⵇⵛⴻⵏ, ⵎⴰⵖⴰⵔ ⵇⵇⴰⵔⴻⵏ: ⵙⵉⴷⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵥⵔⵉ, ⵙⵉⴷⵉ ⵢⴻⵊⵊⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EK8_13","027_8_13","EZK","8","13","13","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵄⴰⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵅ ⵜⵉⵏⴰ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK8_14","027_8_14","EZK","8","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵓ ⵅⵣⴰⵔ, ⵇⵇⵉⵎⴻⵏⵜ ⴷⵉⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵜⵔⵓⵏⵜ ⴷⵉ ⵜⴰⵎⵎⵓⵣ. ");
INSERT INTO rift_vpl VALUES ("EK8_15","027_8_15","EZK","8","15","15","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⴰⵢⴰ! ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵄⴰⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵎⵖⴰⵔⴻⵏⵜ ⵅ ⵜⵉⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK8_16","027_8_16","EZK","8","16","16","ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵙⵉⴷⵉ, ⵊⴰⵔ ⵡⴻⵙⵇⵉⴼ ⴷ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵄⵍⴰⵃⴰⵍ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵉⵄⵓⵔⴰⵔ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⴻⵊⴷⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EK8_17","027_8_17","EZK","8","17","17","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⴰⵢⴰ? ⵎⴰ ⴰⵇⴰ ⴷⵔⵓⵙⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵊⵊⵄⴰⵢⴻⴼ-ⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴷⴰⵏⵉⵜⴰ? ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵛⵛⵓⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵍⵄⵓⵏⴼ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏ. ⵅⵣⴰⵔ, ⵜⵜⴻⴳⴳⴻⵏ ⵄⴰⴷ ⵜⴰⵙⴻⵟⵟⴰ ⵉⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EK8_18","027_8_18","EZK","8","18","18","ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵙ ⵡⴻⵙⵄⴰⵔ. ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵣⵣⵉⴵⵉⵣ ⵃⴻⴷ ⵓ ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵖ. ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⵢⵓⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵜⴻⵙⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("EK9_1","027_9_1","EZK","9","1","1","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉⵏⵓ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵏ ⵓⵔⴻⴷⴷⴻⴵ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EK9_2","027_9_2","EZK","9","2","2","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵙⴻⵜⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⵍⴻⵙⵏⴰⵃ ⵏⵏⴻⵙ ⵉ ⵓⵜⴻⵃⵃⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⵍⴻⵇⵟⴻⵏ, ⵢⵉⵡⵉ ⵜⴰⴷⵡⴰⵜ ⵏ ⵓⵎⴰⵔⵉⵔ ⵖⴰⵔ ⵡⴻⴱⵢⴰⵙ ⵏⵏⴻⵙ. ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK9_3","027_9_3","EZK","9","3","3","ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⵉ ⵅ ⵉⴵⴰⵏ, ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵢⵉⵡⵢⴻⵏ ⵜⴰⴷⵡⴰⵜ ⵏ ⵓⵎⴰⵔⵉⵔ ⵖⴰⵔ ⵡⴻⴱⵢⴰⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK9_4","027_9_4","EZK","9","4","4","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵛⵓⵇⵇ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⴻⴳⴳ ⴽⵔⵓⵣ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵅ ⵜⴻⵏⵢⴰⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵏⵉⵅⵙⵉⵙⴻⵏ ⴷ ⵜⵜⵡⴻⵄⵄⴹⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EK9_5","027_9_5","EZK","9","5","5","ⵓⵎⵉ ⵙⵍⵉⵖ, ⵉⵏⵏⴰ ⵉ ⵉⵏⵏⴻⵖⵏⵉ: “ⵛⵓⵇⵇⴻⵎ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵏⵖⴻⵎ, ⵡⴰⵔ ⵣⵣⵉⴵⵉⵣⴻⵎ ⵓ ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("EK9_6","027_9_6","EZK","9","6","6","ⵏⵖⴻⵎ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⵉⵃⵓⴹⵔⵉⵢⵢⴻⵏ, ⵜⵉⵄⴻⵣⵔⵉⵢⵉⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵇⴰⵄ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵀⴰⴷⴰⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵅⴰⵙ ⴽⵔⵓⵛ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ. ⴱⴷⴰⵎ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⵣⴻⴳ ⵉⵡⴻⵙⵙⵓⵔⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK9_7","027_9_7","EZK","9","7","7","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵅⴻⵎⵊⴻⵎ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵛⵛⵓⵔⴻⵎ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵙ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ. ⴼⴼⵖⴻⵎ!” ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵏⵖⵉⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK9_8","027_9_8","EZK","9","8","8","ⵍⴰⵎⵉ ⵜⴻⵏ ⵏⵖⵉⵏ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵖ ⵏⴻⵛⵛ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴹⵉⵖ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵏⵏⵉⵖ: “ⴰⵅ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⴰ ⴰⴷ ⵜⴰⵔⴻⴷⴷⴵⴻⴷ ⵍⴻⵅⵅⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵖⴰ ⵜⵣⴻⴵⵄⴻⴷ ⴰⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵅ ⵓⵔⵛⴰⵍⵉⵎ?” ");
INSERT INTO rift_vpl VALUES ("EK9_9","027_9_9","EZK","9","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵢⴰⵀⵓⴷⴰ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵙⴼⴰⵔⵖ ⵏ ⵍⵃⴻⵇⵇ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵙⵉⴷⵉ ⵉⵙⵎⴻⵃ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵥⴰⵔⵔ!’ ");
INSERT INTO rift_vpl VALUES ("EK9_10","027_9_10","EZK","9","10","10","ⵙ ⵓⵢⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵎⵎⵓ. ⵜⵉⵟⵟ ⵉⵏⵓ ⵡⴰⵔ ⵜⵙⴻⵎⵎⴻⵃ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵃⵉⵏⵏⵉⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK9_11","027_9_11","EZK","9","11","11","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵖⴰⵔ ⵡⴻⴱⵢⴰⵙ ⵏⵏⴻⵙ ⵜⴰⴷⵡⴰⵜ ⵏ ⵓⵎⴰⵔⵉⵔ, ⴰⵇⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ, ⵉⵏⵏⴰ: “ⴳⴳⵉⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⵓⵎⵓⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("EK10_1","027_10_1","EZK","10","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵥⵔⵉⵖ, ⵅⵣⴰⵔ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵇⵓⴱⴱⴻⵜ, ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵛⴰ ⴰⵎ ⵡⴻⵥⵔⵓ ⵏ ⵚⴰⴼⴼⵉⵔ, ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ, ⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵏⵉⵜⵏⵉ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("EK10_2","027_10_2","EZK","10","2","2","ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴷ ⵏ ⵍⴻⵇⵟⴻⵏ, ⵉⵏⵏⴰ: “ⴰⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵊⴰⵔ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵉⵜⵜⴻⵏⵏⴹⴻⵏ, ⴰⵍ ⵙⴰⴷⵓ ⵉ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⵓⵛⴰ ⵛⵛⵓⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵙ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵣⵉ ⵊⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵓⵛⴰ ⵣⴻⴵⴻⵄ ⵉ-ⵜ ⵅ ⵜⴻⵏⴷⵉⵏⵜ!” ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵊⴰⵔ ⴰⵙⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ.    ");
INSERT INTO rift_vpl VALUES ("EK10_3","027_10_3","EZK","10","3","3","ⵉⴽⵉⵔⵓⴱⴻⵏ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵎⵉ ⴷⴷ-ⵢⴰⴷⴻⴼ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⴰⵙⴻⵢⵏⵓ ⵉⵛⵛⵓⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK10_4","027_10_4","EZK","10","4","4","ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵓⵅⵉⵔⵓⴱ, ⵉⵄⴷⵓ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵓⵙⴻⵢⵏⵓ ⵓ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵙ ⵜⴻⵙⵙⵉⵇⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK10_5","027_10_5","EZK","10","5","5","ⴷⵔⵉⵣⵣ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵉⵜⵜⵡⴰⵙⴻⵍ-ⴷⴷ ⴰⵍ ⴷⴰⵅⴻⵍ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⴰⵎ ⵜⵎⵉⵊⵊⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵅⵎⵉ ⵉⵙⵙⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK10_6","027_10_6","EZK","10","6","6","ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ, ⵉⵏⵏⴰ: “ⴽⵙⵉ ⵜⵉⵎⴻⵙⵙⵉ ⵣⵉ ⵊⴰⵔ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵉⵜⵜⴻⵏⴹⴻⵏ, ⵣⵉ ⵊⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ!”, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵉⵜⵜⴻⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_7","027_10_7","EZK","10","7","7","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵣⵉ ⵊⴰⵔ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵉⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ. ⵡⴰⵏⵉⵜⴰ ⵉⴽⵙⵉ ⵜⵜ ⵓⵛⴰ ⵉⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK10_8","027_10_8","EZK","10","8","8","ⵙⴰⴷⵓ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵉⵜⵜⵡⴰⵥⴰⵔ ⵛⴰ ⴰⵎ ⵚⵚⵉⴼⴻⵜ ⵏ ⵓⴼⵓⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK10_9","027_10_9","EZK","10","9","9","ⵅⴻⵏⵏⵉ ⵥⵔⵉⵖ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ. ⵓⴷⴻⵎ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⴰⵎ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EK10_10","027_10_10","EZK","10","10","10","ⵅ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⴹⵀⴰⵔⴻⵏ, ⴰⵇⴰ ⴰⵔⴻⴱⵄⴰ ⵖⴰⵔⵙⴻⵏ ⵚⵚⵉⴼⴻⵜ ⴷ ⵉⵛⵜⴻⵏ, ⴰⵅⵎⵉ ⵉⵛⵜ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵜᵉⵜⵜⵍⵉⵇ ⵏⵉⵛⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK10_11","027_10_11","EZK","10","11","11","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ, ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵏⴻⵇⵍⵉⴱⴻⵏ ⵛⴰ ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⴰⵔⵔⴰ ⵜⵊⴰⵔⵔⴰⵔⵜ ⵏ ⵣⵣⴰⵜ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴹⴼⴰⵔⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵛⴰ ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_12","027_10_12","EZK","10","12","12","ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ: ⵉⵄⵓⵔⴰⵔ ⵏⵙⴻⵏ, ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⴰⵔⴻⴱⵄⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ, ⵡⴰⵀ ⵄⴰⴷ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_13","027_10_13","EZK","10","13","13","ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⴰⵇⴰ ⵜᵉⵜⵜⵍⴰⵖⴰ ⴰⵙⴻⵏⵜ ⵉ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ: ‘ⵜⴰⵊⴰⵔⵔⴰⵔⵜ ⵏ ⴷⴷⴻⵡⵔⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("EK10_14","027_10_14","EZK","10","14","14","ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ: ⵓⴷⴻⵎ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⴷ ⵓⴷⴻⵎ ⵏ ⵓⴽⵉⵔⵓⴱ, ⵓ ⵓⴷⴻⵎ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵓⴷⴻⵎ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⵓⴷⴻⵎ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷ ⵓⴷⴻⵎ ⵏ ⵡⴻⵢⵔⴰⴷ, ⵓ ⵓⴷⴻⵎ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴷ ⵓⴷⴻⵎ ⵏ ⵓⴳⵉⴷⴻⵔ. ");
INSERT INTO rift_vpl VALUES ("EK10_15","027_10_15","EZK","10","15","15","ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵡⴰ ⴷ ⵙⵉⵎⴰⵏⵜ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉ ⵥⵔⵉⵖ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EK10_16","027_10_16","EZK","10","16","16","ⵓⵎⵉ ⵓⵢⵓⵔⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ, ⵓⵢⵓⵔⴻⵏⵜ ⵓⵍⴰ ⴷ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ, ⵓⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵇⵏⵓⵏⵏⵢⴻⵏⵜ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵏⵉ ⴰⵍⴰⵎⵉ ⴰⴳⴳⵯⴻⵊⴻⵏⵜ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_17","027_10_17","EZK","10","17","17","ⵓⵎⵉ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ, ⴱⴻⴷⴷⴻⵏⵜ ⵓⵍⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ, ⵓⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵓⵍⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴷⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK10_18","027_10_18","EZK","10","18","18","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵏ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⴽⵉⵔⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_19","027_10_19","EZK","10","19","19","ⵉⴽⵉⵔⵓⴱⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ, ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ-ⵜ ⵅⴰⵙⴻⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("EK10_20","027_10_20","EZK","10","20","20","ⵡⴰ ⴷ ⴰⵎⵓⴷⴷⴰⵔ ⵉ ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ. ⵅⴻⵏⵏⵉ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⵉⵔⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_21","027_10_21","EZK","10","21","21","ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵓ ⵙⴰⴷⵓ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⴷⵉⵏ ⵎⵉⵏ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK10_22","027_10_22","EZK","10","22","22","ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵏⵉ ⵥⵔⵉⵖ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ, ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⴱⴰⵏⴻⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵏⵉ, ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴳⴳⵓⵔⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK11_1","027_11_1","EZK","11","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ ⴰⵔⵔⵓⵃ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵓ ⵅⵣⴰⵔ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵥⵔⵉⵖ ⵢⴰⵣⴰⵏⵢⴰⵀⵓ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵣⵓⵔ, ⵓ ⴼⴰⵍⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⴰⵢⴰ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("EK11_2","027_11_2","EZK","11","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⴰ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⵉ ⴷⴷⴻⴵ, ⵜⵜⵉⵛⴻⵏ ⵛⵛⵡⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("EK11_3","027_11_3","EZK","11","3","3","ⵇⵇⴰⵔⴻⵏ: ‘ⵡⴰⵔ ⴱⴻⵏⵏⴰⵎ ⵄⴰⴷ ⵜⵓⴷⵔⵉⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ-ⴰ! ⵜⴰⵏⵉⵜⴰ ⴷ ⵎⴰⵔⵎⵉⵜⴰ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵢⵙⵓⵎ!’” ");
INSERT INTO rift_vpl VALUES ("EK11_4","027_11_4","EZK","11","4","4","“ⵙ ⵓⵢⴰ ⵏⴰⴱⴱ ⵅⴰⵙⴻⵏ, ⵏⴰⴱⴱ, ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("EK11_5","027_11_5","EZK","11","5","5","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵅⴰⴼⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ! ⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵏⵏⵉ ⵉⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK11_6","027_11_6","EZK","11","6","6","ⵜⴰⵔⵏⵉⵎ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵓⵛⴰ ⵜⴻⵛⵛⵓⵔⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵙ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("EK11_7","027_11_7","EZK","11","7","7","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵉⵏⵏⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⵙⵙⴰⵔⵙⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⵢⵙⵓⵎ ⵓ ⵏⴻⵜⵜⴰⵜ ⴷ ⵎⴰⵔⵎⵉⵜⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK11_8","027_11_8","EZK","11","8","8","ⵙⵙⵉⴼ ⵜᵉⵜⵜⴻⴳⴳⵯⴷⴻⵎ, ⴷ ⵙⵙⵉⴼ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK11_9","027_11_9","EZK","11","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴻⴷⵀⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK11_10","027_11_10","EZK","11","10","10","ⵙ ⵙⵙⵉⴼ ⴰⴷ ⵜⴻⵡⴹⴰⵎ. ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK11_11","027_11_11","EZK","11","11","11","ⵜⴰⵏⴷⵉⵏⵜ-ⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜᵉⵜⵜⵉⵍⵉ ⴷ ⵎⴰⵔⵎⵉⵜⴰ ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⵉⵍⵉⵎ ⴷ ⴰⵢⵙⵓⵎ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK11_12","027_11_12","EZK","11","12","12","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵜⴻⴳⴳⵉⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵜⴻⴳⴳⵉⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK11_13","027_11_13","EZK","11","13","13","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⵉⵖ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴼⴰⵍⴰⵟⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵏⴰⵢⴰ, ⵉⵎⵎⵓⵜ. ⵅⴻⵏⵏⵉ ⵡⴹⵉⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵓⵛⴰ ⵍⴰⵖⵉⵖ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⵏⵏⵉⵖ: “ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⴰ ⴰⴷ ⵜⴻⵇⴹⵉⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("EK11_14","027_11_14","EZK","11","14","14","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK11_15","027_11_15","EZK","11","15","15","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⴷ ⴰⵢⵜⵎⴰⵛ, ⴰⵢⵜⵎⴰⵛ, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵎⴻⴼⴷⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵏⵏⴰⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⴰⴳⴳⵯⴻⵊⴻⵎ ⵅ ⵙⵉⴷⵉ, ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵏⴻⵖ ⴷ ⵜⴰⵙⵖⴰⵔⵜ!’” ");
INSERT INTO rift_vpl VALUES ("EK11_16","027_11_16","EZK","11","16","16","“ⵙ ⵓⵢⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵖ ⵜⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴱⴻⵣⵣⵄⴻⵖ ⵜⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⴰ, ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵖ ⵄⴰⴷ ⵛⵡⴰⵢⵜ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⵡⴹⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK11_17","027_11_17","EZK","11","17","17","“ⵙ ⵓⵢⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⴳⴳⵓⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵎ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK11_18","027_11_18","EZK","11","18","18","ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⵉⵏ ⴰⵡⴹⴻⵏ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴽⴽⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK11_19","027_11_19","EZK","11","19","19","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⴷ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵡⴻⵎ. ⴰⴷ ⴽⴽⵙⴻⵖ ⵓⵍ ⵏ ⵡⴻⵥⵔⵓ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵓⵍ ⵏ ⵡⴻⵢⵙⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("EK11_20","027_11_20","EZK","11","20","20","ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⴰⴷ ⵃⴹⴰⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴳⴳⴻⵏ. ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK11_21","027_11_21","EZK","11","21","21","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵓⵍ ⵏⵙⴻⵏ ⴰⴷ ⵉⴹⴼⴰⵔ ⵓⵍ ⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK11_22","027_11_22","EZK","11","22","22","ⵅⴻⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⵓ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵜⵓⵖⴰ ⵣⵣⴰⵜⵙⴻⵏ ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ-ⵜ ⵅⴰⵙⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK11_23","027_11_23","EZK","11","23","23","ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴱⴻⴷⴷⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK11_24","027_11_24","EZK","11","24","24","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⵢⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵣⵣⴰⵢⵉ ⵍⴻⵡⵃⵉⵢ ⵉ ⵥⵔⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("EK11_25","027_11_25","EZK","11","25","25","ⵓ ⵏⵏⵉⵖ ⵉ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷ ⴰⵢⵉ ⵉⵙⵙⵛⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK12_1","027_12_1","EZK","12","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK12_2","027_12_2","EZK","12","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵛⴻⴽ ⵜⵣⴻⴷⴷⵖⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵍⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ, ⵓⵍⴰ ⴷ ⵉⵎⴻⵊⵊⴰⵏⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵍⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK12_3","027_12_3","EZK","12","3","3","ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⴻⵡⵊⴻⴷ ⵍⴻⵃⵡⴰⵢⴻⵊ ⵉ ⵍⵎⴻⵏⴼⴰ ⵓⵛⴰ ⵓⵢⵓⵔ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵏⴻⵄⵎⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK12_4","027_12_4","EZK","12","4","4","ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⵍⴻⵃⵡⴰⵢⴻⵛ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⵣⵉⵍ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⵎ ⵍⴻⵃⵡⴰⵢⴻⵛ ⵉ ⵍⵎⴻⵏⴼⴰ, ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ ⴷⵉ ⵜⵎⴻⴷⴷⵉⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("EK12_5","027_12_5","EZK","12","5","5","ⴻⴳⴳ ⴰⵏⵓⵇⵇⵉⴱ ⴷⵉ ⵍⵃⵉⴹ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK12_6","027_12_6","EZK","12","6","6","ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⴰⵡⵢⴻⴷ ⴰⵢⴰ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵏⵏⴻⵛ, ⴷⵉ ⵜⴱⴰⵎⴱⴰⵙⵜ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵢⴰ. ⴰⴷ ⵜⴻⴼⴼⴰⵔⴻⴷ ⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⴻⵄⵊⴻⴱ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EK12_7","027_12_7","EZK","12","7","7","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⴻⵚⵚⴰ. ⵙ ⵓⵣⵉⵍ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵍⴻⵃⵡⴰⵢⴻⵛ ⵉⵏⵓ ⴰⵎ ⵍⴻⵃⵡⴰⵢⴻⵛ ⵉ ⵍⵎⴻⵏⴼⴰ. ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵖⵣⵉⵖ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⵅ ⵍⵃⵉⴹ ⵓ ⴷⵉ ⴵⵉⵍⴻⵜ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵉⵡⵢⴻⵖ ⵜ ⵅ ⵜⵖⴰⵔⴹⵉⵏ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK12_8","027_12_8","EZK","12","8","8","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵅ ⵜⵓⴼⴼⵓⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK12_9","027_12_9","EZK","12","9","9","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵜⴻⵏⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵏⵏⵉ: ‘ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ?’ ");
INSERT INTO rift_vpl VALUES ("EK12_10","027_12_10","EZK","12","10","10","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵍⵃⴰⴽⴻⵎ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK12_11","027_12_11","EZK","12","11","11","ⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⴻⵄⵊⴻⴱ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⴷⴰⵢⵙⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EK12_12","027_12_12","EZK","12","12","12","ⵍⵃⴰⴽⴻⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⴻⵃⵡⴰⵢⴻⵛ ⵅ ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵙ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⵣⴰⵏ ⵅ ⵍⵃⵉⴹ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⴻⵍ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵇⵇⵉⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵥⴰⵔ ⵄⴰⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK12_13","027_12_13","EZK","12","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴱⴻⵣⵣⵄⴻⵖ ⵜⵔⴰⵛⵛⴰ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⴷⵉ ⵍⴼⴻⵅ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵉⵥⴰⵔⵔ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EK12_14","027_12_14","EZK","12","14","14","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵄⴰⵡⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵏ ⴱⴻⵣⵣⵄⴻⵖ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵛⴰ ⴰⴷ ⵊⴻⴱⴷⴻⵖ ⵙⵙⵉⴼ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK12_15","027_12_15","EZK","12","15","15","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵜⴻⵏ ⵖⴰ ⴱⴻⵣⵣⵄⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK12_16","027_12_16","EZK","12","16","16","ⵎⴰⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵊⵊⴻⵖ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ ⵣⵉ ⵙⵙⵉⴼ, ⵣⵉ ⵍⴰⵥ ⵓ ⵣⵉ ⵟⵟⴰⵄⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴰⵡⴷⴻⵏ ⵉ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⵡⴹⴻⵏ, ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ ⵏⵏⵉ ⴳⴳⵉⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK12_17","027_12_17","EZK","12","17","17","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK12_18","027_12_18","EZK","12","18","18","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵛ ⵙ ⵜⴰⵔⵊⵉⵊⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⴰⵎⴰⵏ ⵏⵏⴻⵛ ⵙ ⵡⴰⵔⵊⴻⴼ ⴷ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK12_19","027_12_19","EZK","12","19","19","ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵢⴻⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵏⵙⴻⵏ ⵙ ⵡⴻⵛⴹⴰⵏ ⵓ ⴰⴷ ⵙⵡⴻⵏ ⴰⵎⴰⵏ ⵏⵙⴻⵏ ⵙ ⵡⴻⵊⵄⴰⵔ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴰⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⵓⵏⴼ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK12_20","027_12_20","EZK","12","20","20","ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ. ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK12_21","027_12_21","EZK","12","21","21","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK12_22","027_12_22","EZK","12","22","22","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵏ ⴰⵎⴻⴷⵢⴰ ⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⴷⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵎⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵄⴻⴷⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ ⵓⵔⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ’?” ");
INSERT INTO rift_vpl VALUES ("EK12_23","027_12_23","EZK","12","23","23","“ⵙ ⵓⵢⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵄⴰⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵎ ⵓⵎⴻⴷⵢⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ.’” “ⵙ ⵓⵢⴰ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⴰⵎⵎⵓ: ‘ⴰⵇⴰ ⵉⵡⴹⴻⵏ-ⴷⴷ ⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴰⵙⴻⵇⴼⴻⵍ ⵏ ⴽⵓⵍ ⵍⴻⵡⵃⵉⵢ!’ ");
INSERT INTO rift_vpl VALUES ("EK12_24","027_12_24","EZK","12","24","24","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵍⴻⵡⵃⵉⵢ ⵡⴰⵔ ⵉⴵⵉⵏ ⵓⵍⴰ ⴷ ⵜⴰⴳⴻⵣⵣⴰⵏⵜ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵉⵣⵉⴹⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK12_25","027_12_25","EZK","12","25","25","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ. ⴰⵡⴰⵍ ⵉ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ, ⴰⴷ ⵢⵉⵍⵉ, ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⴰⵍ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵓⵛⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK12_26","027_12_26","EZK","12","26","26","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK12_27","027_12_27","EZK","12","27","27","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵅⵣⴰⵔ, ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵍⴻⵡⵃⵉⵢ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰ ⴰⵇⴰ-ⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵡⴻⵇⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵜⵜⵏⴰⴱⴱⴰ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵟⵟⴰⵙ.’” ");
INSERT INTO rift_vpl VALUES ("EK12_28","027_12_28","EZK","12","28","28","“ⵙ ⵓⵢⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⴰⵍ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ. ⴰⵡⴰⵍ ⵉ ⵏⵏⵉⵖ, ⴰⴷ ⵢⵉⵍⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK13_1","027_13_1","EZK","13","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK13_2","027_13_2","EZK","13","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ, ⵓⵛⴰ ⵉⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵖⴰⵔ ⵎⴻⵥⵔⵉ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ: ‘ⵙⵔⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("EK13_3","027_13_3","EZK","13","3","3","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵓⵛⵜ ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⴱⵓⵃⴰⵍⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⴰⵡⴰⵔⵏⵉ ⵎⵉⵏ ⵡⴰⵔ ⵥⵔⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("EK13_4","027_13_4","EZK","13","4","4","ⴰ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵢⵉⵛⴻⵄⴱⴰⵡⴻⵏ ⵊⴰⵔ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK13_5","027_13_5","EZK","13","5","5","ⵡⴰⵔ ⵜⵓⵍⵢⴻⵎ ⵖⴰⵔ ⵜⵉⵣⵣⴻⵢⵢⵉⵏ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵉⵖ ⵜⴻⴱⵏⴰⵎ ⵍⵃⵉⴹ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜⴱⴻⴷⴷⴰⵎ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK13_6","027_13_6","EZK","13","6","6","ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵍⵉⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ, ⵓⵛⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵜⴰⴳⴻⵣⵣⴰⵏⵜ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ⵙⵉⴷⵉ ⵉⵇⵇⴰⵔ!, ⵡⴰⵅⵅⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⴻⴽⴽ ⵛⴰ, ⵄⴰⴷ ⵙⵉⵜⵜⵉⵎⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵡⴰⵍ ⴰⴷ ⵉⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK13_7","027_13_7","EZK","13","7","7","ⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵥⵔⵉⵎ ⵅⴻⵏⵏⵉ ⵉⵡⴻⵃⵃⴰⵏ ⵡⴰⵔ ⵉⴵⵉⵏ, ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⵉⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵜⴰⴳⴻⵣⵣⴰⵏⵜ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵎⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ: ⵙⵉⴷⵉ ⵉⵇⵇⴰⵔ!, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵖ ⵛⴰ?’” ");
INSERT INTO rift_vpl VALUES ("EK13_8","027_13_8","EZK","13","8","8","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ ⵍⴱⴰⵟⴻⵍ ⵓ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵉⵡⴻⵃⵃⴰⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵅⴰⵡⴻⵎ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK13_9","027_13_9","EZK","13","9","9","ⴰⴷ ⵢⵉⵍⵉ ⵓⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵍⴱⴰⵟⴻⵍ ⵓ ⵜⵜⴳⴻⵣⵣⴰⵏⴻⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⵛⴰ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵜⵜⵡⴰⵣⴻⵎⵎⵉⵎⴻⵏ ⵛⴰ ⴷⵉ ⵍⵉⵙⵜⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵙⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK13_10","027_13_10","EZK","13","10","10","“ⵎⵉⵏⵣⵉ, ⵡⴰⵀ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵖⴰⵔⵔⴰⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵇⵇⴰⵔⴻⵏ: ‘ⵍⴻⵀⵏⴰ!’ ⴰⵎ ⵡⴰⵔ ⵉⴵⵉ ⵍⴻⵀⵏⴰ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴱⵏⴰ ⵍⴳⴻⵏⵙ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ. ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ, ⵅⴻⵏⵏⵉ ⵜⵜⵍⴻⵃⵃⴰⴼⴻⵏ ⴰⵙ ⵄⴰⵡⴻⴷ ⵙ ⵊⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK13_11","027_13_11","EZK","13","11","11","ⵉⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵍⴻⵃⵃⴰⴼⴻⵏ ⵍⵃⵉⴹ ⵙ ⵊⵊⴰⵔ, ⴱⴻⵍⵍⵉ ⴰⴷ ⵉⵡⴹⴰ. ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴻⵏⵥⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴱⵇⵓⵇⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ, ⴰⴷ ⵜⴻⵡⴹⴰⵎ, ⵓⵛⴰ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("EK13_12","027_13_12","EZK","13","12","12","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵅⵎⵉ ⵉⵡⴹⴰ ⵍⵃⵉⴹ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⵊⵊⴰⵔ ⵉ ⵣⵉ ⴷ ⴰⵙ ⵜⵍⴻⵃⵃⴼⴻⵎ?’” ");
INSERT INTO rift_vpl VALUES ("EK13_13","027_13_13","EZK","13","13","13","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⴰⴷ ⵜ ⴰⵔⵥⴻⵖ ⵙ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵓ ⵙ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵥⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵟⵟⴰⵙ ⵓ ⵙ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⴰⴷ ⵡⴹⴰⵏ ⵉⴱⵇⵓⵇⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵇⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EK13_14","027_13_14","EZK","13","14","14","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵖⴻⴹⵍⴻⵖ ⵍⵃⵉⴹ ⵏⵏⵉ ⵜⵍⴻⵃⵃⴼⴻⵎ ⵙ ⵊⵊⴰⵔ ⵉⴼⴻⵙⵢⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵎⵎⴻⵏⴹⴰⵔⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⴷⵙⴰⵙ ⵏⵏⴻⵙ. ⴰⴷ ⵜⴻⵡⴹⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK13_15","027_13_15","EZK","13","15","15","ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵅ ⵍⵃⵉⴹ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵜ ⵉⴷⵍⵉⵏ ⵙ ⵊⵊⴰⵔ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ ⵍⵃⵉⴹ ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵍⴻⵃⵃⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK13_16","027_13_16","EZK","13","16","16","ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵉⵏⴻⴱⴱⴰⵏ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵜⵡⴰⵍⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⵏⴻⵜⵜⴰⵜ ⴰⵎ ⵡⴰⵔ ⵉⴵⵉ ⵍⴻⵀⵏⴰ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK13_17","027_13_17","EZK","13","17","17","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵣⴻⴳ ⵡⵓⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ, ⵓ ⵏⴻⴱⴱⴰ ⵅⴰⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("EK13_18","027_13_18","EZK","13","18","18","ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵓⵛⵜ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵢⵢⴰⴹⴻⵏ ⵍⴻⵛⴼⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵎⴼⴰⵚⴻⵍ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵓⵛⴰ ⵜⵜⴻⴳⴳⴻⵏⵜ ⵉⵍⴻⵃⵃⴰⴼ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵓⵎⴻⵥⵢⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⵎⴰⵔⴻⵏⵜ ⵍⴻⵄⵎⵓⵔ! ⵎⴰ ⵜⴻⵅⵙⴻⵏⵜ ⴰⴷ ⵜⴻⴳⵎⴰⵔⴻⵏⵜ ⵍⴻⵄⵎⵓⵔ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⵃⴹⴰⵏⵜ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("EK13_19","027_13_19","EZK","13","19","19","ⵎⴰ ⵜⴻⵅⵙⴻⵏⵜ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴼⴻⵙⴷⴻⵏⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵛⴰ ⵏ ⵡⵓⵔⴰⵡⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⵛⴰ ⵏ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏⵖⴻⵏⵜ ⵍⴻⵄⵎⵓⵔ, ⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵎⵎⵜⴻⵏ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵃⴹⴰⵏⵜ ⵜⵓⴷⴰⵔⵜ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ, ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵏⴽⴻⵏⵜ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵏⵏⵉ ⵉⵙⵙⵃⴻⵙⵙⴰⵏ ⵖⴰⵔ ⵓⵅⴰⵔⵔⵉⵇ?’” ");
INSERT INTO rift_vpl VALUES ("EK13_20","027_13_20","EZK","13","20","20","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⴰⴷ ⴰⵔⵔⴻⵖ ⵍⴻⵛⴼⴻⵏ ⵏⴽⴻⵏⵜ ⵉ ⵣⵉ ⵜⵢⴻⵎⵎⴰⵔⴻⵏⵜ ⴷⵉⵏ, ⴰⴷ ⴹⵡⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵄⵎⵓⵔ. ⴰⴷ ⵜⴻⵏ ⵇⴻⵍⵄⴻⵖ ⵣⴻⴳ ⵉⵖⴰⴵⴻⵏ ⵏⴽⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⴷⴻⵍⵇⴻⵖ ⵉ ⵍⴻⵄⵎⵓⵔ ⵉ ⵜⵢⴻⵎⵎⴰⵔⴻⵏⵜ, ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⵄⵎⵓⵔ ⴰⴷ ⴹⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK13_21","027_13_21","EZK","13","21","21","ⴰⴷ ⵛⴰⵔⵔⴳⴻⵖ ⵉⵍⴻⵃⵃⴰⴼⴻⵏ ⵏⴽⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⴽⴻⵏⵜ ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⴽⴻⵏⵜ. ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵏⵜ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵏⵜ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EK13_22","027_13_22","EZK","13","22","22","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵏⵜ ⵜⴻⵙⵙⵅⴻⵢⵢⵇⴻⵏⵜ ⵓⵍ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵓⵎⵉ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴳⴳⵉⵖ ⵍⴻⵃⵔⵉⵇ ⵓ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵏⵜ ⵜⴻⵙⵙⵊⴻⵀⴷⴻⵏⵜ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⵍⴰⵎⵉ ⴰⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⴷⴷ-ⵉⴷⵡⵉⵍ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("EK13_23","027_13_23","EZK","13","23","23","“ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ ⵉⵡⴻⵃⵃⴰⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵄⴰⴷ ⵙ ⵜⴳⴻⵣⵣⴰⵏⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK14_1","027_14_1","EZK","14","1","1","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EK14_2","027_14_2","EZK","14","2","2","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK14_3","027_14_3","EZK","14","3","3","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵊⵊⴻⵖ ⵄⴰⴷ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⵛⵛⵡⴰⵔ ⵣⵣⴰⵢⵉ?” ");
INSERT INTO rift_vpl VALUES ("EK14_4","027_14_4","EZK","14","4","4","“ⵙ ⵓⵢⴰ, ⵛⴻⴽ, ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵓⵏⴰⴱⵉ, ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔ, ⵎⴰⵍⴰ ⵉⵜⵜⴰⵙ-ⴷⴷ, ⴰⵏⴻⵛⵜ ⵍⵇⴻⴷⴷ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("EK14_5","027_14_5","EZK","14","5","5","ⵃⵉⵎⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵍⴻⵇⴼⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅⴰⴼⵉ ⵎⴰⵔⵔⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ.’” ");
INSERT INTO rift_vpl VALUES ("EK14_6","027_14_6","EZK","14","6","6","“ⵙ ⵓⵢⴰ, ⵉⵏⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵓⵛⴰ ⵇⴻⵍⴱⴻⵎ ⵅ ⵉⵎⴻⵢⴹⴰ ⵏⵡⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓⵛⴰ ⴰⵔⵔⴻⵎ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵡⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("EK14_7","027_14_7","EZK","14","7","7","ⵎⵉⵏⵣⵉ ⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵣⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ - ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴳⴳⵯⴻⵊⴻⵏ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ ⵓ ⵉⵜⵜⴻⵊⵊⴰ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵓⵏⴰⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⵓ ⵣⵣⴰⵢⴻⵙ ⵛⵛⵡⴰⵔ - ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK14_8","027_14_8","EZK","14","8","8","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⵊⵄⴰⵔⴻⵖ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵇⴻⴹⵄⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK14_9","027_14_9","EZK","14","9","9","“‘ⵅⵎⵉ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵉⵊⵊⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵖⴰⵔⵔⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⵖⴰⵔⵔⴻⵖ ⴰⵏⴰⴱⵉ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⴻⵃⵃⵉⵖ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK14_10","027_14_10","EZK","14","10","10","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ⴰⵏⴻⵛⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵛⵛⵡⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵓⵏⴰⴱⵉ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EK14_11","027_14_11","EZK","14","11","11","ⵃⵉⵎⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴻⴷⴷⴰⵔ ⵄⴰⴷ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵉⵏⵓ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK14_12","027_14_12","EZK","14","12","12","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK14_13","027_14_13","EZK","14","13","13","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵍⴰ ⵜⴻⵅⴹⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴽⵉⴷⵉ ⴰⵎ ⵜᵉⵜⵜⴻⴳⴳ ⵙ ⵍⵖⴻⴷⵔⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ⴰⴷ ⴰⵔⵥⴻⵖ ⵍⴻⵄⵡⴻⵍⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⴷⴰⵢⴻⵙ ⵍⴰⵥ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵃⵃⵉⵖ ⴰⵎ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵍⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK14_14","027_14_14","EZK","14","14","14","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ-ⴰ, ⵏⵓⵃ ⴷ ⴷⴰⵏⵉⵢⵉⵍ ⴷ ⴰⵢⵓⴱ, ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵎⵖⵉⵔ ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK14_15","027_14_15","EZK","14","15","15","“ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⴰⴷ ⵥⵡⴰⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴽⴻⵛⵛⴹⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵢⴻⴵⵉ ⵡⵉ ⵙⵙⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⵄⴷⵓⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵡⵃⵓⵛ ⵉⵡⵄⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK14_16","027_14_16","EZK","14","16","16","ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵉⵖ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ, ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵎⵖⵉⵔ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK14_17","027_14_17","EZK","14","17","17","“ⵏⵉⵖ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵙⵙⵉⴼ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ, ⴰⴷ ⵉⵏⵉⵖ: ‘ⵙⵙⵉⴼ, ⴻⴽⴽ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!’, ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵇⴻⴹⵄⴻⵖ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EK14_18","027_14_18","EZK","14","18","18","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵉⵖ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ, ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵎⵖⵉⵔ ⵉⵅⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK14_19","027_14_19","EZK","14","19","19","“ⵏⵉⵖ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵟⵟⴰⵄⵓⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵙⵙⴼⴰⵔⵖⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵇⴻⴹⵄⴻⵖ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EK14_20","027_14_20","EZK","14","20","20","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵏⵓⵃ ⴷ ⴷⴰⵏⵉⵢⴰⵍ ⴷ ⴰⵢⵓⴱ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵉⵖ ⵜⵉⵃⴻⵏⵊⵉⵔⵉⵏ, ⴰⴷ ⴼⴻⴽⴽⴻⵏ ⵎⵖⵉⵔ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK14_21","027_14_21","EZK","14","21","21","“ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⴰⵀⵓ ⵅⵎⵉ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⴹⵉⴷⴷ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵏⵓ ⵉⵇⴻⵙⵃⴻⵏ ⵎⴰⵔⵔⴰ: ⵙⵙⵉⴼ ⴷ ⵍⴰⵥ ⴷ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵟⵟⴰⵄⵓⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵇⴻⴹⵄⴻⵖ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ! ");
INSERT INTO rift_vpl VALUES ("EK14_22","027_14_22","EZK","14","22","22","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⵉⵏⵏⵉ ⵉⵏⵏⴻⵊⵎⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴱⴰⵔⵔⴰ, ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⵎ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ⵅⵣⴰⵔ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⵊⴻⵎ ⵅ ⵍⵖⴰⵔ ⵏⵏⵉ ⵙⵙⵉⵡⴹⴻⵖ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ⵡⴰⵀ, ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵙⵙⵉⵡⴹⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK14_23","027_14_23","EZK","14","23","23","ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴼⴻⵡⵡⵊⴻⵏ ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⴳⴳⵉⵖ, ⵡⴰⵔ ⵜ ⴳⴳⵉⵖ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK15_1","027_15_1","EZK","15","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK15_2","027_15_2","EZK","15","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏ ⵉⵄⵏⴰ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴽⵜⴰⵔ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⴻⵖⵏⵉ, ⴽⵜⴰⵔ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵡⴻⵣⵖⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("EK15_3","027_15_3","EZK","15","3","3","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ ⴰⴽⴻⵛⵛⵓⴹ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉⵏⴻⴼⴼⵄⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ? ⵎⴰ ⵉⵜⵜⵡⴰⴽⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵍⴻⵡⵜⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴰⵢⵍⴻⴷ ⵛⴰ ⵏ ⵍⵇⴻⵛⵄⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("EK15_4","027_15_4","EZK","15","4","4","ⵅⵣⴰⵔ, ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵜⵎⴻⵙⵙⵉ. ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⴻⵛⵛ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵓ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵡⴻⵙⵜ ⵉⵜⵜⵡⴰⵛⴻⵎⴹ. ⵎⴰ ⴰⴷ ⵉⵚⵍⴻⵃ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⵉ ⵄⴰⴷ ⵉ ⵢⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵍⵅⴻⴷⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("EK15_5","027_15_5","EZK","15","5","5","ⵅⵣⴰⵔ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵎⵓⵏ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵍⵅⴻⴷⵎⴻⵜ. ⵎⴻⵛⵃⴰⵍ ⵇⴻⵍⵍ ⵄⴰⴷ ⵓⵎⵉ ⵜ ⵜⴻⵛⵛⴰ ⵜⵉⵎⴻⵙⵙⵉ, ⵉⵛⵎⴻⴹ ⵓⴽⴻⵛⵛⵓⴹ. ⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴳⴳⴻⵏ ⵄⴰⴷ ⵛⴰ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵍⵅⴻⴷⵎⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("EK15_6","027_15_6","EZK","15","6","6","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵎⴰⵎⵎⴻⵛ ⵉ ⵡⵛⵉⵖ ⴰⴽⴻⵛⵛⵓⴹ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵊⴰⵔ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵡⴻⵣⵖⴰⵔ ⵉ ⵜⵉⵎⴻⵙⵙⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⴻⵍⵍⵎⴻⵖ ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵜⵎⴻⵙⵙⵉ! ");
INSERT INTO rift_vpl VALUES ("EK15_7","027_15_7","EZK","15","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵙⴻⵏ. ⵅⵎⵉ ⵉ ⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⵜⵎⴻⵙⵙⵉ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵓⵎⵉ ⴳⴳⵉⵖ ⵓⴷⴻⵎ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK15_8","027_15_8","EZK","15","8","8","ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵖⴷⴰⵔⴻⵏ ⴰⵢⵉ ⵙ ⵉⵛⵜ ⵍⴻⵖⴷⴰⵔⴻⵜ ⵉⵇⴻⵙⵃⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK16_1","027_16_1","EZK","16","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK16_2","027_16_2","EZK","16","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⵛⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK16_3","027_16_3","EZK","16","3","3","ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ⵅ ⵍ’ⴰⵚⴻⵍ ⵏⵏⴻⵎ ⴷ ⵡⴻⵅⵍⴰⵇ ⵏⵏⴻⵎ ⴰⵇⴰ ⵛⴻⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ. ⵜⵓⵖⴰ ⴱⴰⴱⴰⵎ ⴷ ⴰⵎⵓⵔⵉ ⵓ ⵢⴻⵎⵎⴰⵎ ⴷ ⵜⴰⵃⵉⵜⵜⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_4","027_16_4","EZK","16","4","4","ⵖⴰⵔ ⵜⵍⴰⵍⵉⵜ ⵏⵏⴻⵎ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⴷ, ⵡⴰⵔ ⴷ ⴰⵎ ⵇⴻⵙⵙⴻⵏ ⵜⴰⵄⴻⴱⴱⵓⵜ ⵏⵉⵖ ⵙⵙⵉⵔⴷⴻⵏ ⵛⴻⵎ ⵙ ⵡⴰⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵎ ⵙⵙⵉⵣⴷⴻⴳⴻⵏ. ⵡⴰⵔ ⵛⴻⵎ ⵎⴻⴵⵃⴻⵏ ⵙ ⵜⵎⴻⴵⴰⵃⵜ ⵏⵉⵖ ⵛⴻⵎ ⵙⵙⴻⵏⵏⴹⴻⵏ ⵙ ⵜⴻⵃⵍⵓⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_5","027_16_5","EZK","16","5","5","ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⵅⴻⵣⵣⴰⵔ ⵉ ⵛⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵟⵟ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵎ ⵢⴻⴳⴳ ⵛⴰ ⵣⵉ ⴷⴷⴻⴳⴳⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵎ ⵜⴻⵣⵣⵉⴵⴻⵣ, ⵎⴰⵛⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⴷ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ ⵙ ⵍⵃⴻⴳⵔⴰ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("EK16_6","027_16_6","EZK","16","6","6","“ⵓⵎⵉ ⵥⵡⵉⵖ ⵣⵣⴰⵜⴻⴽ, ⵥⵔⵉⵖ ⵛⴻⵎ ⵜᵉⵜⵜⵏⴻⵇⵍⴰⴱⴻⴷ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵎ. ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵎ ⵓⵎⵉ ⵛⴻⵎ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵎ: ‘ⴷⴷⴰⵔ!’, ⵡⴰⵀ, ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵎ ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴻⵎ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵎ: ‘ⴷⴷⴰⵔ!’ ");
INSERT INTO rift_vpl VALUES ("EK16_7","027_16_7","EZK","16","7","7","ⴰⵔⵏⵉⵖ ⴷⴰⵢⴻⴽ ⴰⵍⴰⵎⵉ ⵜⴼⴻⵢⵢⴹⴻⴷ ⴰⵎ ⵓⵖⴻⵎⵎⵓⵢ ⵏ ⵢⴻⵢⵢⴰⵔ. ⵛⴻⵎ ⵜⴻⵢⵎⵉⴷ, ⵜⴻⵎⵖⴰⵔⴻⴷ ⵓⵛⴰ ⵜⵉⵡⴹⴻⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴻⵛⵏⵉⴷ ⴰⵟⵟⴰⵙ. ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵊⴻⵎⴷⴻⵏ ⵓ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵎ ⵉⵎⵖⴰⵔ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵛⴻⵎ ⴷ ⵜⴰⵄⴰⵔⵢⴰⵏⵜ ⴷ ⵜⴰⵇⴻⴷⴷⵉⴷⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_8","027_16_8","EZK","16","8","8","ⵓⵎⵉ ⵥⵡⵉⵖ ⵣⵣⴰⵜⴻⵎ, ⵥⵔⵉⵖ ⵛⴻⵎ ⵓⵛⴰ ⵅⵣⴰⵔ, ⵓⵙⵙⴰⵏ ⵏⵏⴻⵎ ⵉⵡⴹⴻⵏ, ⵓⵙⵙⴰⵏ ⵏ ⵜⴰⵢⵔⵉ. ⵏⴻⵛⵛ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵔⵉⵡⴻⵏ ⵉⵏⵓ ⵅⴰⵎ ⵓⵛⴰ ⴷⵍⵉⵖ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏⵏⴻⵎ. ⵊⵊⵓⴵⴻⵖ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵎ ⵓⵛⴰ ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴷⴻⵡⵍⴻⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK16_9","027_16_9","EZK","16","9","9","ⵙⵙⵉⵔⴷⴻⵖ ⵛⴻⵎ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵙⵍⵉⵍⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵎ ⵣⵣⴰⵢⴻⵎ ⵓⵛⴰ ⴷⴻⵀⵏⴻⵖ ⵛⴻⵎ ⵙ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_10","027_16_10","EZK","16","10","10","ⵏⴻⵛⵛ ⵙⵙⵢⴰⵔⴹⴻⵖ ⵛⴻⵎ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏ ⵓⴱⵓⵔⴹⴰ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ ⵓⵛⴰ ⵙⵙⵖⵓⵏⴻⵖ ⵛⴻⵎ ⵙ ⵜⵙⵉⵍⴰ ⵏ ⵜⴻⵍⵎⴻⵛⵜ ⵏ ⴷⴷⴻⵏⴼⵉⵍ ⵓⵛⴰ ⵙⵙⴱⴻⵢⵙⴻⵖ ⵛⴻⵎ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵓⵛⴰ ⴷⵍⵉⵖ ⵛⴻⵎ ⵙ ⵍⴻⵀⵔⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("EK16_11","027_16_11","EZK","16","11","11","ⵇⵇⵏⴻⵖ ⵛⴻⵎ ⵙ ⵍⴻⵀⵣⵓⵟ ⵓⵛⴰ ⴳⴳⵉⵖ ⴰⵎ ⵜⵎⴻⵇⵢⴰⵙⵉⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴻⵛⵜ ⴷⴻⴳ ⵢⵉⵔⵉ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_12","027_16_12","EZK","16","12","12","ⴳⴳⵉⵖ ⵜⴰⵅⴰⴷⴻⵏⵜ ⴷⵉ ⵜⵉⵏⵣⴰⵔⵜ ⵏⵏⴻⵎ ⴷ ⵜⴻⵅⵔⴰⵣⵉⵏ ⴷⴻⴳ ⵉⵎⴻⵊⵊⴰⵏ ⵏⵏⴻⵎ ⴷ ⵜⵜⴰⵊ ⵉⵛⵏⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_13","027_16_13","EZK","16","13","13","ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⵡⴰⵣⴻⵀⵀⵊⴻⴷ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ ⵜⵓⵖⴰ-ⵜ ⵙ ⵍⴻⵇⵜⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵍⴻⵀⵔⵉⵔ ⴷ ⵓⴱⵓⵔⴹⴰⵔ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ. ⵛⴻⵎ ⵜⵓⵖⴰ ⵜⴻⵛⵛⵉⴷ ⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⴷ ⵣⵣⴻⵛⵜ. ⵜⵓⵖⴰ ⵛⴻⵎ ⵜⴻⵛⵏⵉⴷ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⴼⴻⵍⵃⴻⴷ ⴰⵍⴰⵎⵉ ⵜⴷⴻⵡⵍⴻⴷ ⵜⴻⵙⵙⴷⴰⵀⵊⴻⴷ ⵜⴰⴳⴻⵍⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK16_14","027_16_14","EZK","16","14","14","ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⴽ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵥⵔⵉ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵥⵔⵉ ⵏⵏⴻⵎ ⵏⵉⵛⴰⵏ ⵣⴻⴳ ⵓⵛⴻⵡⵡⴰⵔ ⵉⵏⵓ ⵉ ⵅⴰⵎ ⵙⵙⴰⵔⵙⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK16_15","027_16_15","EZK","16","15","15","“ⵎⴰⵛⴰ ⵜᵉⵜⵜⵉⵇⵇⴻⴷ ⴷⴻⴳ ⵡⴻⵥⵔⵉ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⴻⵎ ⴰⵎ ⵜᵉⵜⵜⵉⵇⵇⴻⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⴼⴰⵔⵔⵖⴻⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵡⵉ ⵢⴻⵄⴷⵓⵏ: ⵉ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴰⵥⵔⵉ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_16","027_16_16","EZK","16","16","16","ⵜⴻⴽⵙⵉⴷ ⵛⴰ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ, ⵜⴻⴳⴳⵉⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵙ ⵜⵉⵏⵜⴰⵜ ⴰⵟⵟⴰⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴼⴼⵙᵉⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴷⵉⵏ. ⴰⵎ ⵎⴰⵏ ⴰⵢⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_17","027_16_17","EZK","16","17","17","ⵜⴻⴽⵙⵉⴷ ⵍⴻⵀⵣⵓⵟ ⵏ ⵡⵓⵔⴻⵖ ⵉⵏⵓ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵏⵓ ⵏⵏⵉ ⴷ ⴰⵛ ⵡⵛⵉⵖ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴼⵙᵉⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_18","027_16_18","EZK","16","18","18","ⵜⴻⴽⵙⵉⴷ ⴰⵔⵔⵓⴹ ⵏ ⵓⴱⵓⵔⴹⴰⵔ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ ⵓⵛⴰ ⵜⵍⴻⵃⵃⴼⴻⴷ ⴰⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵣⵣⴻⵛⵜ ⵉⵏⵓ ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵏⵓ ⵣⵣⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_19","027_16_19","EZK","16","19","19","ⴰⵖⵔⵓⵎ ⵉⵏⵓ ⵏⵏⵉ ⴷ ⴰⵎ ⵡⵛⵉⵖ, ⵡⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵣⵣⴻⵛⵜ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵉ ⵣⵉ ⵛⴻⵎ ⵙⵙⴻⵛⵛⴻⵖ, ⴰⵇⴰ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴰⵢⴰ ⴷ ⴰⵔⵔⵉⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵣⵣⴰⵜⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵎⵙⴰⵔ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK16_20","027_16_20","EZK","16","20","20","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴷ ⵢⴻⵙⵙⵉⵎ ⵏⵏⵉ ⴷⴷ-ⵜⵓⵔⵡⴻⴷ ⵉ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵜⴻⴽⵙⵉⴷ ⵜⴻⵏ ⵓⵛⴰ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵜⴻⵏ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵏⵉⵜⵏⵉ. ⵎⴰ ⵅⴻⵏⵏⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⴷ ⴷⵔⵓⵙⵜ ⵡⴰⵀⴰ, ");
INSERT INTO rift_vpl VALUES ("EK16_21","027_16_21","EZK","16","21","21","ⴰⵍⴰⵎⵉ ⵜⵖⴰⵔⵚⴻⴷ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵓⵛⴰ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ ⵜⴻⵏ ⵓⵎⵉ ⵜⴻⵏ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵅ ⵜⵎⴻⵙⵙⵉ? ");
INSERT INTO rift_vpl VALUES ("EK16_22","027_16_22","EZK","16","22","22","ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ ⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⵡⴰⵔ ⵜⵉⴷⴰⵔⴻⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴻⵎ ⴷ ⵜⴰⵄⴰⵔⵢⴰⵏⵜ, ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⵉⴷ ⵓ ⵜᵉⵜⵜⵏⴻⵇⵍⴰⴱⴻⴷ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_23","027_16_23","EZK","16","23","23","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵉ ⵜⴻⴳⴳⵉⴷ - ⴰⵢ, ⴰⵢⴻⵀⵀⴰⵜ ⵅⴰⵎ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ - ⵉⵎⵙⴰⵔ ");
INSERT INTO rift_vpl VALUES ("EK16_24","027_16_24","EZK","16","24","24","ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴱⵏⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵓⵛⴰ ⵜⴻⴳⴳⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵣⵣⴰⵢ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("EK16_25","027_16_25","EZK","16","25","25","ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵣⴻⴵⵉⴼ ⵏ ⵡⴻⴱⵔⵉⴷ ⵜⴻⴱⵏⵉⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ. ⵜⵊⴻⵢⵢⵃⴻⴷ ⴰⵥⵔⵉ ⵏⵏⴻⵎ ⵙ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵡⵉ ⵢⴻⵄⴷⵓⵏ ⵓⵛⴰ ⵜⴰⵔⵏⵉⴷ ⴰⵟⵟⴰⵙ ⴷⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_26","027_16_26","EZK","16","26","26","ⵜⴻⵙⵙⴼⴻⵙⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓⵍⴰ ⵙ ⴰⵢⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵎ ⵏⵏⵉ ⵉⵇⵇⴱⵓⴱⴱⵓⵣⴻⵏ ⵙ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ. ⵜⴰⵔⵏⵉⴷ ⴰⵎⵎⵓ ⴰⵟⵟⴰⵙ ⴷⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵄⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_27","027_16_27","EZK","16","27","27","ⵅⵣⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵎ ⵓⵛⴰ ⵙⵙⵏⴻⵇⵚⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵎ ⵉ ⴷ ⴰⵎ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵓⵛⴰ ⵙⴻⵍⵍⵎⴻⵖ ⵛⴻⵎ ⵖⴰⵔ ⵎⴻⵥⵔⵉ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵖⴰⵔ ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ, ⵜⵉⵏⵏⵉ ⵜⵜⵙⴻⴹⵃⴰⵏⵜ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵎ ⵉⴼⴻⴹⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_28","027_16_28","EZK","16","28","28","ⵜⴻⵙⵙⴻⴼⵙᵉⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ, ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ. ⵜⴻⵙⵙⴻⴼⵙᵉⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⴼⵉⴷ ⴰⵊⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_29","027_16_29","EZK","16","29","29","ⵜⴰⵔⵏⵉⴷ ⴰⵟⵟⴰⵙ ⴷⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⴰⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⴻⵊⵊⵉⵡⵏⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_30","027_16_30","EZK","16","30","30","ⵎⴻⵛⵃⴰⵍ ⵉⵀⵍⴻⵛ ⵡⵓⵍ ⵏⵏⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵉⵖⴻⵡⵡⵖⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK16_31","027_16_31","EZK","16","31","31","ⵓⵎⵉ ⵜⴻⴱⵏⵉⴷ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏ ⴽⵓⵍ ⴰⴱⵔⵉⴷ, ⵜⴻⴳⴳⵉⴷ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⴰ ⴷⵉ ⴽⵓⵍ ⴰⵣⵣⴰⵢ, ⴱⵍⴰ ⵎⴰ ⵜⴻⴵⵉⴷ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓⵎⵉ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵍⴻⵅⵍⴰⵚ ⵏⵏⴻⵎ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK16_32","027_16_32","EZK","16","32","32","ⴰ ⵛⴻⵎ, ⵜⴰⵎⵖⴰⵔⵜ ⵉⵣⴻⵏⵏⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK16_33","027_16_33","EZK","16","33","33","ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵡⵛⵉⵏ ⴰⵙⴻⵏⵜ ⵍⵎⵓⵏⴻⵜ, ⵎⴰⵛⴰ ⵛⴻⵎ ⵜⴻⵡⵛⵉⴷ ⵜⵉⵎⴻⵡⵛⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵏ ⵜⴻⵙⵙⴻⵖⵡⵉⴷ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_34","027_16_34","EZK","16","34","34","ⴰⵎⵎⵓ, ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ, ⴰⴷ ⴽⵉⴷⴻⵎ ⵉⵎⵙⴰⵔ ⵍⵄⴻⴽⵙ ⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵛⴻⵎ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴳⴳⴻⵏ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ. ⵎⴰⵍⴰ ⵛⴻⵎ ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵍⴻⵅⵍⴰⵚ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵡⴰⵔ ⵜᵉⵟⵟⴼⴻⴷ ⵛⴰ ⵍⴻⵅⵍⴰⵚ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵛⴻⵎ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵍⵄⴻⴽⵙ ⵣⵣⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK16_35","027_16_35","EZK","16","35","35","“ⵙ ⵓⵢⴰ, ⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK16_36","027_16_36","EZK","16","36","36","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴼⴰⵔⵔⵖⴻⴷ ⵏⵏⵃⴰⵙ ⵏⵏⴻⵎ ⵉⵜⵜⵡⴰⵍⴻⵃⵃⴼⴻⵏ ⵙ ⴷⴷⵔⴰ ⵓ ⵜⴻⵙⵙⵄⴰⵔⵔⵉⴷ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵎ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵢⴹⴰ ⵏⵏⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ, ⵓ ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⵉⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("EK16_37","027_16_37","EZK","16","37","37","ⵅⵣⴰⵔ, ⵙ ⵓⵢⴰ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵎ ⵉⵜⵜⴻⵄⵊⵉⴱⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⴻⵅⵙⴻⴷ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵛⴰⵔⵀⴻⴷ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵙⵙⵎⵓⵏⴻⵖ ⵅⴰⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵄⴰⵔⵔⵉⵖ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵎ, ⴰⵍ ⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_38","027_16_38","EZK","16","38","38","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵎ ⵛⴰⵔⵔⵄⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉ ⵜⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ ⴷ ⵜⵉⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⵙⴻⵍⵍⵎⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⵙⵄⴰⵔ ⴷ ⵜⵓⵙⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("EK16_39","027_16_39","EZK","16","39","39","ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵛⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵥⴻⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⴰⵎ ⴽⴽⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ, ⴰⴷ ⴰⵡⵢⴻⵏ ⵍⴻⵀⵣⵓⵟ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⵊⵊⴻⵏ ⴷ ⵜⴰⵄⴰⵔⵢⴰⵏⵜ ⴷ ⵜⴰⵇⴻⴷⴷⵉⴷⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_40","027_16_40","EZK","16","40","40","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⴰⴷ ⵅⴰⵎ ⵙⵙⵉⵡⴹⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⴰⵔⴻⵊⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⵇⴻⵙⵙⴻⵏ ⵙ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK16_41","027_16_41","EZK","16","41","41","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵎ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⵙⵙⴻⵀⵡⴰⵏ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵣⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ, ⵡⴰⵔ ⵜⴱⴻⵟⵟⵉⴷ ⵄⴰⴷ ⵍⴻⵅⵍⴰⵚ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK16_42","027_16_42","EZK","16","42","42","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⴰⵔⵙⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵅⴰⵎ ⵓⵛⴰ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵅⴰⵎ ⵜⴱⴻⵄⵄⴻⴷ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴰⵔⴻⵢⵢⵃⴻⵖ, ⵡⴰⵔ ⵜⵜⵄⴻⵙⵙⵉⴱⴻⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_43","027_16_43","EZK","16","43","43","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵉⴷⴰⵔⴻⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵄⴰⵔⴻⴷ ⵙ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰⵇⴰ ⴷⴰ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⴰⴷ ⴰⵡⵢⴻⵖ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴳⴳⴻⵖ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ ⵓⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⵄⵉⵇⵉⴱⴻⵖ ⵛⴰ.’”   ");
INSERT INTO rift_vpl VALUES ("EK16_44","027_16_44","EZK","16","44","44","“ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵡⴻⵣⵏⴻⵏ, ⴰⴷ ⵅⴰⵎ ⵉⵙⵙⴰⵡⴰⵍ ⴰⵡⴰⵍ-ⴰ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵎ ⵢⴻⵎⵎⴰⵙ, ⴰⵎ ⵢⴻⴵⵉⵙ!’ ");
INSERT INTO rift_vpl VALUES ("EK16_45","027_16_45","EZK","16","45","45","ⴰⵇⴰ ⵛⴻⵎ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵎ ⵏⵏⵉ ⵉⵄⵉⴼⴼⴻⵏ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵛⴻⵎ ⴷ ⵓⵍⵜⵎⴰⵙ ⵏ ⵙⵓⵢᵉⵜⵎⴰⵎ ⵏⵏⵉ ⵉⵄⵉⴼⴼⴻⵏ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ. ⵜⵓⵖⴰ ⵢⴻⵎⵎⴰⵎ ⴷ ⵜⴰⵃⵉⵜⵜⵉⵜ ⵓ ⴱⴰⴱⴰⵎ ⴷ ⴰⵎⵓⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EK16_46","027_16_46","EZK","16","46","46","ⵓⵍⵜⵎⴰⵎ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵇⴰ-ⵜⵜ ⵙⴰⵎⴰⵔⵢⴰ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵢⴻⵙⵙⵉⵙ ⵏⵏⴻⵙ ⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵓⵥⴻⵔⵎⴰⴹ ⵏⵏⴻⵎ, ⵓ ⵓⵍⵜⵎⴰⵎ ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵣⵣⴰⵢⴻⵎ, ⵜⵣⴻⴷⴷⴻⵖ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏⵏⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵙⴰⴷⵓⵎ ⴷ ⵢⴻⵙⵙⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EK16_47","027_16_47","EZK","16","47","47","ⵛⴻⵎ ⵡⴰⵔ ⵜⴻⴳⴳⵓⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏⵜ ⵓ ⵡⴰⵔ ⵜⴻⴳⴳⵉⴷ ⴰⵎ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏⵜ. ⵎⴰⵛⴰ ⴰⵅⵎⵉ ⵎⴰⵎⵎⴻⵛ ⴷⴷⴻⴳⴳⴰ ⵜⵓⵖⴰ ⴷⵔⵓⵙⵜ ⵡⴰⵀⴰ, ⵜⴼⴻⵙⴷⴻⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_48","027_16_48","EZK","16","48","48","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴰⵇⴰ ⵙⴰⴷⵓⵎ, ⵓⵍⵜⵎⴰⵎ ⴰⴽ-ⴷ ⵢⴻⵙⵙⵉⵙ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⴰⵎ ⵜⴻⴳⴳⵉⴷ ⵛⴻⵎ ⴷ ⵢⴻⵙⵙⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_49","027_16_49","EZK","16","49","49","ⵅⵣⴰⵔ, ⵜⴰ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵓⵍⵜⵎⴰⵎ ⵙⴰⴷⵓⵎ: ⵏⵏⴼⴰⵅⴻⵜ, ⵜⵢⴰⵡⴰⵏⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⴱⵍⴰ ⴰⵎⵏⵓⵙ, ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵙ ⵓ ⵏ ⵢⴻⵙⵙⵉⵙ, ⵎⴰⵛⴰ ⴰⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵓ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵙⵙⴻⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_50","027_16_50","EZK","16","50","50","ⵏⵉⵜⴻⵏⵜⵉ ⵏⵏⴻⴼⵅⴻⵏⵜ ⵓⵛⴰ ⴳⴳⵉⵏⵜ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⵓⵎⵉ ⵥⵔⵉⵖ ⴰⵢⴰ, ⵏⴹⴰⵔⴻⵖ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_51","027_16_51","EZK","16","51","51","ⵎⴰⵛⴰ ⵙⴰⵎⴰⵔⵢⴰ ⵡⴰⵔ ⵜⵅⴻⵟⵟⵉ ⵓⵍⴰ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵎ ⵓⵛⴰ ⵛⴻⵎ ⵜⴻⴳⴳⵉⴷ ⵊⵊⵄⴰⵢⴻⴼ ⴽⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ. ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵉ ⵜⴻⴳⴳⵉⴷ, ⵜⴰⵔⵔⴻⴷ ⵙⵓⵢᵉⵜⵎⴰⵎ ⴱⴰⵏⴻⵏⵜ ⵙⴻⴳⴳⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_52","027_16_52","EZK","16","52","52","ⵅⴻⵏⵏⵉ ⵛⴻⵎ ⵄⴰⵡⴻⴷ, ⴽⵙⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴻⵡⵜⵉⴷ ⵅ ⵙⵓⵢᵉⵜⵎⴰⵎ. ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴷⴷⵏⵓⴱ ⴷ ⵊⵊⵄⵉⴼⴻⵛⵜ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⴱⴰⵏⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⵙⴻⴳⴳⴷⴻⵏⵜ ⵅⴰⵎ. ⵙⴻⴹⵃⴰ ⵓ ⴽⵙⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴰⵔⵔⵉⴷ ⵙⵓⵢᵉⵜⵎⴰⵎ ⴱⴰⵏⴻⵏⵜ ⵙⴻⴳⴳⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK16_53","027_16_53","EZK","16","53","53","ⵅⵎⵉ ⵖⴰ ⴱⴻⵟⵟⵍⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏⵜ, ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵢⴻⵙⵙⵉⵙ, ⵓⵍⴰ ⴷ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵢⴻⵙⵙⵉⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⴻⵟⵟⵍⴻⵖ ⵄⴰⵡⴻⴷ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵏⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("EK16_54","027_16_54","EZK","16","54","54","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵙⴻⴹⵃⵉⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ, ⵍⴰⵎⵉ ⵛⴻⵎ ⵜⴻⵏⵜ ⵜⴻⵙⵙⴼⴻⵡⵡⵊⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_55","027_16_55","EZK","16","55","55","ⵎⴰⵍⴰ ⵙⵓⵢᵉⵜⵎⴰⵎ, ⵙⴰⴷⵓⵎ ⴷ ⵢⴻⵙⵙⵉⵙ, ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏⵜ ⵖⴰⵔ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵙⴻⵏⵜ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵢⴻⵙⵙⵉⵙ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏⵜ ⵖⴰⵔ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵙⴻⵏⵜ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⴷ ⵓⵍⴰ ⴷ ⵛⴻⵎ ⴷ ⵢⴻⵙⵙⵎⴰⵎ ⵖⴰⵔ ⵓⵎⴻⴷⴷⵓⵔ ⵏⴽⴻⵏⵜ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("EK16_56","027_16_56","EZK","16","56","56","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵛⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵎ ⵅ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵓⵍⵜⵎⴰⵎ ⵙⴰⴷⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("EK16_57","027_16_57","EZK","16","57","57","ⵇⴱⴻⵍ ⵎⴰ ⵉⵄⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵉⵎⵙⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⵃⴻⴳⵔⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵢⴻⵙⵙⵉⵙ ⵏ ⴰⵔⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵛⴻⵎ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_58","027_16_58","EZK","16","58","58","ⵍⴻⴼⴹⴰⵢⴻⵃ ⵏⵏⴻⵎ ⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴽⵙⵉⴷ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK16_59","027_16_59","EZK","16","59","59","“ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴳⴳⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵛⴻⵎ ⵓⵎⵉ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵜⴰⵊⴰⴵⵉⵜ ⵙ ⵜⵔⴻⵥⵥⵉⵜ ⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("EK16_60","027_16_60","EZK","16","60","60","ⵎⴰⵛⴰ ⵄⴰⴷ ⴰⴷ ⵄⴻⵇⵍⴻⵖ ⵅ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_61","027_16_61","EZK","16","61","61","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⴷⴰⵔⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵙⴻⴹⵃⵉⴷ ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⵢⴻⴷ ⵙⵓⵢᵉⵜⵎⴰⵎ ⵏⵏⵉ ⵎⵖⴰⵔⴻⵏⵜ ⵣⵣⴰⵢⴻⵎ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⵉⵏⵏⵉ ⵜⵉⵎⴰⵥⵓⵥⵉⵏ ⵅⴰⵎ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵎ ⵜⴻⵏⵜ ⵡⵛⵉⵖ ⴷ ⵢⴻⵙⵙⵉⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK16_62","027_16_62","EZK","16","62","62","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EK16_63","027_16_63","EZK","16","63","63","ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⴷⴰⵔⴻⴷ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵙⴻⴹⵃⵉⴷ ⵓⵛⴰ ⵡⴰⵔ ⵜⴰⵔⴻⵣⵣⵎⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ, ⵅⵎⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⵚⵍⴰⵃ ⵉ ⵛⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK17_1","027_17_1","EZK","17","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK17_2","027_17_2","EZK","17","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵟⵃⴰⵊⵉⵜ ⵏ ⵜⵡⴰⴼⵉⵜ ⵓ ⴻⵡⵛ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ");
INSERT INTO rift_vpl VALUES ("EK17_3","027_17_3","EZK","17","3","3","ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⴰⴳⵉⴷⴻⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⴰⵔⴻⵣⵎⴻⵏ, ⴷⴰⵢⵙⴻⵏ ⵍⴻⵡⵜⴰⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴰⵔⵔⵉⵛ ⴷ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⵜⵓⵛⵛⴻⵏⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("EK17_4","027_17_4","EZK","17","4","4","ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵏⴷⴰⵢⴻⵏ ⵉⴽⴽⴻⵙ ⵉ-ⵜ, ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵜⵉⵊⴰⵔⴰ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK17_5","027_17_5","EZK","17","5","5","ⵉⴽⵙⵉ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉⵛⵏⴰ ⵉ ⵡⴻⵣⵔⴰⵄ. ⵉⴽⵙⵉ ⵜⵜ, ⵉⵥⵥⵓ ⵜⵜ ⴰⵎ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵚⴻⴼⵚⴰⴼ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK17_6","027_17_6","EZK","17","6","6","ⵜⴻⵖⵎⵉ-ⴷⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵙ ⵍⴻⴼⵔⵓⵄ ⵡⴻⵙⵙⵄⴻⵏ ⴰⴽ-ⴷ ⵜⵔⵓⵏⴽⵓ ⴷ ⴰⵇⵓⴹⴰⴹ ⵏⵏⵉ ⵣⵉ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵙⴻⴹⵡⵉⵏ ⵖⴰⵔ ⵓⴳⵉⴷⴻⵔ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵇⵇⵉⵎⴻⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵓⵛⴰ ⵜⴻⴳⴳⴰ ⴰⴷ ⵙⵙⴻⵏⴷⵢⴻⵏ ⵉⴼⴻⵜⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK17_7","027_17_7","EZK","17","7","7","ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⴰⵔⵔⵉⵛ ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜⴰⵔⵔⴰ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵜⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⵥⵥⵓ ⵃⵉⵎⴰ ⴰⴳⵉⴷⴻⵔ ⴰⴷ ⴰⵙ ⵉⵙⵙⴻⵙⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("EK17_8","027_17_8","EZK","17","8","8","ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵥⵥⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉⵙⴱⴻⵃ ⵣⵣⴰⵜ ⵉ ⵡⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜⴻⵛⵛⵓⵔ.’ ");
INSERT INTO rift_vpl VALUES ("EK17_9","027_17_9","EZK","17","9","9","ⵉⵏⵉ ⵅⴻⵏⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⵎⵍⵉⵃ? ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵓⴳⵉⴷⴻⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵇⴹⴻⵄ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⴰⵥⴻⵖ? ⵡⴰⵀ ⴰⴷ ⵜⴰⵥⴻⵖ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴼⵔⴰⵢ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⵖⴻⵎⵎⵢⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵃⴷⵉⵊ ⵄⴰⴷ ⵓⵖⵉⵍ ⵉⵊⴻⵀⴷⴻⵏ ⵏⵉⵖ ⵍⵖⴰⵛⵉ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK17_10","027_17_10","EZK","17","10","10","ⵅⵣⴰⵔ, ⵡⴰⵅⵅⴰ ⵥⵥⵓⵏ ⵜⵜ, ⵎⴰⵛⴰ ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴼⵍⴻⵃ? ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵥⴻⵖ ⵅⵎⵉ ⵜⵜ ⵖⴰ ⵉⵍⵇⴻⴼ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵍⵖⴰⵔⴱ? ⵡⴰⵀ, ⴰⴷ ⵜⴰⵥⴻⵖ ⵅ ⵉⵄⵓⵔⴰⵔ ⵏ ⵍⴻⵄⵔⴰⵚⵉ ⵎⴰⵏⵉ ⴷⴷ-ⵜⵖⴻⵎⵎⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK17_11","027_17_11","EZK","17","11","11","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK17_12","027_17_12","EZK","17","12","12","“ⵉⵏⵉ ⵍⴻⵅⵅⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ: ‘ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵎⵉⵏ ⵄⵏⴰⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ?’ ⵉⵏⵉ: ‘ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔⴻⵙ ⴷⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK17_13","027_17_13","EZK","17","13","13","ⵉⵟⵟⴻⴼ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⴰⴷ ⵉⵡⵛ ⵜⴰⵊⴰⴵⵉⵜ ⵓ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵉⴽⴽⴻⵙ ⵉ-ⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK17_14","027_17_14","EZK","17","14","14","ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵜⵡⴰⴹⴻⵄ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⴳⵉⵄⵄⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⴰ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜᵉⵜⵜⴱⴻⴷⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK17_15","027_17_15","EZK","17","15","15","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵖⴻⵡⵡⴻⵖ ⵅⴰⵙ, ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵉⵢⵙⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴳⴻⵏⵙ. ⵎⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⴰⵢⴰ ⵎⵍⵉⵃ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵢⴰ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵥⵉⵏ ⵍⵄⴰⵀⴷ ⴰⴷ ⵢⴰⵔⵡⴻⵍ?’” ");
INSERT INTO rift_vpl VALUES ("EK17_16","027_17_16","EZK","17","16","16","“ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵏⴻⵜⵜⴰ ⵜⴰⵊⴰⴵⵉⵜ ⵉ ⴷ ⴰⵙ ⵉⵊⵊⵓⴵ, ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵢⴰⵔⵥ ⵍⵄⴰⵀⴷ ⵉ ⴽⵉⴷⴻⵙ ⵉⴳⴳⴰ, ⴰⵇⴰ ⴷⵉⵏ ⵖⴰⵔⴻⵙ, ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⴱⴰⴱⵉⵍ, ⴰⴷ ⵉⵎⵎⴻⵜ! ");
INSERT INTO rift_vpl VALUES ("EK17_17","027_17_17","EZK","17","17","17","ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴼⵉⵔⵄⵓⵏ ⵙ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵉⵎⵖⴰⵔ ⴰⴷ ⵢⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ, ⵅⵎⵉ ⵖⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⴱⵏⴰⵏ ⵉⵊⵊ ⵏ ⵡⴻⵛⴱⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵖⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("EK17_18","027_17_18","EZK","17","18","18","ⴰⵇⴰ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵜⴰⵊⴰⴵⵉⵜ ⵓⵎⵉ ⵢⴰⵔⵥⴰ ⵍⵄⴰⵀⴷ ⵉ ⵅ ⵉⵡⵛⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ. ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵉⵜⵜⵔⴰⴽⴽⵡⴰⵍ.’” ");
INSERT INTO rift_vpl VALUES ("EK17_19","027_17_19","EZK","17","19","19","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵜⴰⵊⴰⴵⵉⵜ ⵉ ⴷ ⴰⵢⵉ ⵉⵊⵊⵓⴵ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵉ-ⵜⵜ, ⵓⵍⴰ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⴽⵉⴷⵉ ⵉⴳⴳⴰ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⴰⵔⵥⴰ ⵉ-ⵜ, ⴰⴷ ⵜⴻⵏ-ⵉ-ⴷⴷ ⴰⵔⵔⴻⵖ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("EK17_20","027_17_20","EZK","17","20","20","ⴰⴷ ⵅⴰⵙ ⴱⴻⵣⵣⵄⴻⵖ ⵜⵔⴰⵛⵛⴰ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉⵛⴰⵔⴼ ⴷⵉ ⵍⴼⴻⵅ ⵉⵏⵓ. ⴰⴷ ⵜ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵛⴰⵔⵔⵄⴻⵖ ⴷⵉⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴷⴰⵔⴻⵜ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵉⵖⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK17_21","027_17_21","EZK","17","21","21","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ. ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⵉⵡⵍⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK17_22","027_17_22","EZK","17","22","22","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵉⵊⵊ ⵏ ⵓⴼⴻⵜⵡⵉ ⵏ ⵜⵓⵛⵛⴻⵏⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵢⵓⵄⵍⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵥⵥⵓⵖ. ⵣⴻⴳ ⵓⵣⴻⴵⵉⴼ ⴰⴽ-ⴷ ⵜⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⵇⴻⵍⵄⴻⵖ ⵉⵛⵜ ⵏ ⵜⵙⴻⵟⵟⴰ ⵜⴰⵔⵀⴻⴼ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵥⵥⵓⵖ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK17_23","027_17_23","EZK","17","23","23","ⴰⴷ ⵜⵜ ⵥⵥⵓⵖ ⵅ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⵇⴰⵄ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵜⴰⵏⵉⵜⴰ ⴰⴷ ⵜⴰⵡⵉ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵔ ⵍⵖⵉⴵⴻⵜ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵉⵊⴻⵀⴷⴻⵏ. ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵊⴹⴰⴹ ⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⴼⵔⵉⵡⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⵏⵉⵜⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EK17_24","027_17_24","EZK","17","24","24","ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⴻⵀⵡⵉⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵓⵛⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵇⵓⴹⴰⴹⵜ ⵓ ⵙⵙⵉⵥⵖⴻⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⴻⵢⵣⴰⵜ ⵓⵛⴰ ⴰⵔⵔⵉⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴰⴷ ⵜⵏⴻⵡⵡⴰⵔ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⵉⵡⵍⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK18_1","027_18_1","EZK","18","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK18_2","027_18_2","EZK","18","2","2","“ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵖⵉⵏ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⵉⵡⵢⴻⵎ ⴰⵡⴰⵍ-ⴰ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵉⴱⴰⴱⴰⵜⴻⵏ ⵛⵛⵉⵏ ⴰⴹⵉⵍ ⴰⵙⴻⵎⵎⴰⵖ ⵓⵛⴰ ⵜⵉⵖⵎⴰⵙ ⵏ ⵡⴰⵔⵔⴰⵡ ⴷⴻⵡⵍⴻⵏⵜ ⵃⴰⵔⴻⵛⵡⴻⵏⵜ’? ");
INSERT INTO rift_vpl VALUES ("EK18_3","027_18_3","EZK","18","3","3","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵛⵜ ⵅⴰⵡⴻⵎ ⵎⴰⵍⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⴰⵡⴰⵍ-ⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("EK18_4","027_18_4","EZK","18","4","4","ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⵓⵔ ⵉⵏⵓ, ⴰⵎ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⴰⴱⴰⵙ ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏ ⵎⵎⵉⵙ ⵉⵏⵓ. ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉⵅⴹⴰⵏ, ⴰⴷ ⵉⵎⵎⴻⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EK18_5","027_18_5","EZK","18","5","5","“ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉ ⵢⴻⴵⴰ, ⵉⵜⵜⴻⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("EK18_6","027_18_6","EZK","18","6","6","ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⴷⴷⴱⴰⵢⴻⵃ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵡⴰⵔ ⵉⵙⵙⴳⵉⵄⵄⵉⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵉⵙⵙⴻⵅⵎⵉⵊ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⵉⴱ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵄⴻⵣⵣⵍⴻⵏ ⵓⵎⵉ ⵅⴰⵙ ⵉⴷⴰⵎⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK18_7","027_18_7","EZK","18","7","7","ⵡⴰⵔ ⵉⵃⴻⵚⵚⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ ⴷⴷⵉⵢⵢⴻⵜ ⵉ ⴱⵓ-ⴰⵎⴰⵔⵡⴰⵙ, ⵡⴰⵔ ⵉⵜⵜⴽⴻⵛⵛⴰⴹ, ⵡⴻⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ ⵉⵜⵜⵉⵛ ⴰⵙ ⵡⴻⵖⵔⵓⵎ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵉⵙⵙⴷⴷⵓⵔⵉ ⵉ-ⵜ ⵙ ⵡⴰⵔⵔⵓⴹ, ");
INSERT INTO rift_vpl VALUES ("EK18_8","027_18_8","EZK","18","8","8","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵟⵟⴻⵍ ⵙ ⴰⵔⵔⵉⴱⴰ ⵏⵉⵖ ⴰⴷ ⵉⴽⵙⵉ ⴰⵔⴱⴻⵃ, ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵜⵜⴻⴳⴳⵯⴻⵊ ⵅ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵏⵉⵛⴰⵏ ⵊⴰⵔ ⵡⴻⵔⵢⴰⵣ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EK18_9","027_18_9","EZK","18","9","9","ⵉⴳⴳⵓⵔ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⵉⵃⴻⵟⵟⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓⵎⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙ ⵍⴰⵎⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK18_10","027_18_10","EZK","18","10","10","ⵎⴰⵍⴰ ⵢⴻⵊⵊ-ⴷⴷ ⵎⵎⵉⵙ ⴷ ⴰⵛⴻⴼⴼⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⴰⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("EK18_11","027_18_11","EZK","18","11","11","ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵎⴰⵛⴰ ⵎⵎⵉⵙ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⴻⵜⵜ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵉⵙⵙⴻⵅⵎⴻⵊ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK18_12","027_18_12","EZK","18","12","12","ⵉⵃⴻⵚⵚⴰⵔ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ, ⵉⵜⵜⴽⴻⵛⵛⴰⴹ, ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⴷⴷⵉⵢⵢⴻⵜ, ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵉⵜⵜⴻⴳⴳ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("EK18_13","027_18_13","EZK","18","13","13","ⵢⴰⵔⴻⵟⵟⴻⵍ ⵙ ⴰⵔⵔⵉⴱⴰ, ⵉⵜⵜᵉⵟⵟⴻⴼ ⴰⵔⴱⴻⵃ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵎⵎⵉⵙ ⵡⴰⵏⵉⵜⴰ ⵉⴷⴷⴰⵔ? ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴷⴷⴰⵔ ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⵉ. ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⵉⵍⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK18_14","027_18_14","EZK","18","14","14","“ⵅⵣⴰⵔ, ⵎⴰⵍⴰ ⴰⴷ ⴷⴷ-ⵢⴻⵊⵊ ⵎⵎⵉⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵉⵅⴻⵣⵣⴰⵔ ⵡⴰⵀⴰ ⴰⵎ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("EK18_15","027_18_15","EZK","18","15","15","ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵡⴰⵔ ⵉⵙⵙⴳⵉⵄⵄⵉⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵉⵙⵙⴻⵅⵎⵉⵊ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK18_16","027_18_16","EZK","18","16","16","ⵡⴰⵔ ⵉⵃⴻⵚⵚⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵡⴰⵔ ⵉⵎⴻⵏⵏⴻⵄ ⴷⴷⵉⵢⵢⴻⵜ, ⵡⴰⵔ ⵉⵜⵜⴽⴻⵛⵛⴰⴹ, ⵉⵜⵜⵉⵛ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵙ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ, ⵉⵙⵙⴷⵓⵔⵔⵓⵢ ⵉ ⵓⵄⴰⵔⵢⴰⵏ ⵙ ⵡⴰⵔⵔⵓⴹ, ");
INSERT INTO rift_vpl VALUES ("EK18_17","027_18_17","EZK","18","17","17","ⵉⵜⵜⴰⴳⴳⵯⴻⵊ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵎⴻⵣⵍⵓⴹ, ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⴰⵔⵔⵉⴱⴰ ⴷ ⵡⴰⵔⴱⴻⵃ, ⵉⵜⵜⴻⴳⴳ ⵙ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⵉⵃⴻⵟⵟⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⴰⵇⴰ ⵎⵎⵉⵙ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵙ, ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EK18_18","027_18_18","EZK","18","18","18","ⴱⴰⴱⴰⵙ ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵅ ⵓⵎⵉ ⵉⴳⴳⴰ ⴱⴻⵣⵣⴻⵣ ⵅ ⵉⵡⴷⴰⵏ ⵙ ⵍⴻⵅⵛⵓⵏⴻⵜ, ⵉⴽⴻⵛⵛⴻⴹ ⴰⴳⵍⴰ ⵓⵛⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EK18_19","027_18_19","EZK","18","19","19","“ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵎⵎⵉⵙ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵙ? ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⵉⵃⴹⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜⴻⵏⵜ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EK18_20","027_18_20","EZK","18","20","20","ⵍⴻⵄⵎⴰⵔ ⵏⵏⵉ ⵉⵅⴹⴰⵏ, ⴰⴷ ⵉⵎⵎⴻⵜ. ⵎⵎⵉⵙ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉ ⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵎⵎⵉⵙ. ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK18_21","027_18_21","EZK","18","21","21","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵄⴻⴼⴼⴰⵏ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵏⵉ ⵉⴳⴳⴰ, ⴰⴷ ⵉⵃⴹⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵢⴻⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EK18_22","027_18_22","EZK","18","22","22","ⵎⴰⵔⵔⴰ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵡⴰⵃⴻⵙⵙⴱⴻⵏ ⵛⴰ. ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ, ⴰⴷ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK18_23","027_18_23","EZK","18","23","23","ⵎⴰ ⴰⴷ ⴰⵔⴹⵉⵖ ⵙ ⵜⵉⴷⴻⵜⵜ ⵍⵎⴻⵡⵜ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ?’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ‘ⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴷⴷⴰⵔ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴷⵡⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("EK18_24","027_18_24","EZK","18","24","24","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⴷⴷⴻⴵ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳ ⵓⵄⴻⴼⴼⴰⵏ, ⴰⴷ ⵉⴳⴳ ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ? ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵄⵇⵉⵍ ⵄⴰⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⵉ ⵉⴳⴳⴰ. ⵙ ⵍⴻⵖⴷⴰⵔⴻⵜ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⵖⴷⴰⵔ ⵓ ⵙ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵉⴷⴷⴻⵏⴱ, ⵙ ⵢⵉⵏⴰ ⴰⴷ ⵉⵎⵎⴻⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EK18_25","027_18_25","EZK","18","25","25","“ⵜⴻⵇⵇⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ: ‘ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ!’. ⵙⵍⴻⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰ ⴰⴱⵔⵉⴷ ⵉⵏⵓ ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵛⴰⵏ? ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵡⴰⵔ ⵙⴻⴳⴳⵎⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("EK18_26","027_18_26","EZK","18","26","26","ⵎⴰⵍⴰ ⵉⵃⴻⵢⵢⴻⴷ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⴷⴷⴻⴵ ⵓ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⵉ ⴷⴷⴻⴵ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("EK18_27","027_18_27","EZK","18","27","27","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵓⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK18_28","027_18_28","EZK","18","28","28","ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵍⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ. ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EK18_29","027_18_29","EZK","18","29","29","ⵉⵏⵏⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵔⴻⵏⵏⴰⵏ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴻⵎ!’ ⵎⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⵙⴻⴳⴳⵎⴻⵏ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ⴷ ⵜⵉⴷⴻⵜⵜ ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵡⴰⵔ ⵙⴻⴳⴳⵎⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("EK18_30","027_18_30","EZK","18","30","30","“ⵙ ⵓⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵛⴰⵔⵔⵄⴻⵖ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⵉⵊⵊ ⴰⵏⴻⵛⵜ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ⵄⴻⵇⴱⴻⵎ, ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ ⴷ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("EK18_31","027_18_31","EZK","18","31","31","ⵏⴹⴰⵔⴻⵎ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ ⵉ ⵣⵉ ⵜⵄⴻⴷⴷⴰⵎ. ⴳⴳⴻⵎ ⵓⵍ ⵏⵡⴻⵎ ⴷ ⴰⵎⴰⵢⵏⵓ ⵓ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ ⴷ ⴰⵎⴰⵢⵏⵓ. ⵎⴰⵖⴰⵔ ⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("EK18_32","027_18_32","EZK","18","32","32","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴰⵔⴹⵉⵖ ⴷⵉ ⵍⵎⴻⵡⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⵓⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵓⵛⴰ ⴷⴷⴰⵔⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("EK19_1","027_19_1","EZK","19","1","1","“ⵛⴻⴽ ⵅⴻⵏⵏⵉ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵢⴻⵥⵔⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ");
INSERT INTO rift_vpl VALUES ("EK19_2","027_19_2","EZK","19","2","2","ⵓⵛⴰ ⵉⵏⵉ: ‘ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴻⵣⵣⴻⵍ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ ⴰⵎ ⵜⴻⵢⵔⴰⴷⵜ ⵜⴻⵣⵣⴻⵍ ⵊⴰⵔ ⵜⴻⵢⵔⴰⴷⵉⵏ! ⵜⴻⵙⵙⵢⴻⵎ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵊⴰⵔ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EK19_3","027_19_3","EZK","19","3","3","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵢⴻⵎ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ. ⵡⴰⵏⵉⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ, ⵉⵍⵎⴻⴷ ⴰⴷ ⵉⵛⴰⵔⵔⴻⴳ ⵜⴰⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⵄⴰⴷ ⵉⵡⴷⴰⵏ ⵉⵛⵛⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK19_4","027_19_4","EZK","19","4","4","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵃⴻⴱⴱⵙⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵙ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.’ ");
INSERT INTO rift_vpl VALUES ("EK19_5","027_19_5","EZK","19","5","5","‘ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⴰⵇⴰ ⵍⴰⵢⴰⵙ ⵏⵏⴻⵙ ⵉⵔⵓⵃ, ⵉⴱⴹⴻⵍ, ⵅⴻⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK19_6","027_19_6","EZK","19","6","6","ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⵊⴰⵔ ⵡⴰⵢⵔⴰⴷⴻⵏ, ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵢⵔⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ, ⵉⵍⵎⴻⴷ ⴰⴷ ⵉⵛⴰⵔⵔⴻⴳ ⵜⴰⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⵄⴰⴷ ⵉⵡⴷⴰⵏ ⵉⵛⵛⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK19_7","027_19_7","EZK","19","7","7","ⵏⴻⵜⵜⴰ ⵉⵖⵚⴻⴱ ⵜⵉⵊⵊⴰⵍ ⵏⵙⴻⵏ, ⵢⴰⵔⴻⴷⴷⴻⴵ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⵙⵓⵙⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵓⵣⴻⵀⵀⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK19_8","027_19_8","EZK","19","8","8","ⵅⴻⵏⵏⵉ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵅⴰⵙ ⵍⴻⴳⵏⵓⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓⵛⴰ ⴱⴻⵣⵣⵄⴻⵏ ⵅⴰⵙ ⵜⵔⴰⵛⵛⴰ ⵏⵙⴻⵏ, ⵟⵟⴼⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏⵙⴻⵏ ⵏ ⵜⵓⵔⵚⵓⴹⵉ. ");
INSERT INTO rift_vpl VALUES ("EK19_9","027_19_9","EZK","19","9","9","ⵏⵉⵜⵏⵉ ⴱⴻⵍⵍⵄⴻⵏ ⵅⴰⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵇⴼⴻⵣ ⵙ ⵜⵙⴻⵏⵏⴰⵔⵉⵏ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵄⴰⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("EK19_10","027_19_10","EZK","19","10","10","’ⵜⵓⵖⴰ ⵢⴻⵎⵎⴰⵛ ⴰⵎ ⵜⵣⴰⵢⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵛ, ⵜᵉⵜⵜⵡⴰⵥⵥⵓ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ. ⵜⵓⵖⴰ ⵙ ⵍⵖⵉⴵⴻⵜ ⵓ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵙⴻⴹⵡⵉⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK19_11","027_19_11","EZK","19","11","11","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵎ ⵉⵣⴻⴵⴰⴹ ⵏ ⵍⵃⵓⴽⴽⴰⵎ. ⵜⵔⵓⵏⴽⵓ ⵏ ⵢⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴻⵄⵄⴻⴷ ⵊⴰⵔ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵓⵛⴰ ⵙ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵥⴰⵔ ⵏⵉⵛⴰⵏ, ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK19_12","027_19_12","EZK","19","12","12","ⵎⴰⵛⴰ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵙ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵡⴻⵙⵄⴰⵔ, ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⴰⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵛⵛⴰⵔⵇ ⵢⵓⵥⴻⵖ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ⴰⵔⵥⴻⵏ ⵓⵛⴰ ⵓⵥⵖⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵛⵛⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK19_13","027_19_13","EZK","19","13","13","ⵍⴻⵅⵅⵓ ⵥⵥⵓⵏ ⵜ ⴷⵉ  ⵍⴻⵅⵍⴰ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⴷ ⵉⴼⴼⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK19_14","027_19_14","EZK","19","14","14","ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴻⵟⵟⴰ ⵣⵉ ⵊⴰⵔ ⵜⵣⴻⵔⵎⵉⵏ ⵏⵏⴻⵙ, ⵜⴻⵛⵛⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵜⵙⴻⵟⵟⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵓⵍⴰ ⴷ ⴰⵣⴻⴵⴰⴹ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴽⴻⵎ.’” ⵡⴰ ⴷ ⵉⵊⵊ ⵏ ⵢⴻⵥⵔⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵢⴻⵥⵔⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EK20_1","027_20_1","EZK","20","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("EK20_2","027_20_2","EZK","20","2","2","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK20_3","027_20_3","EZK","20","3","3","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⴰ ⵜⵓⵙⵉⵎ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ? ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴻⵊⵊⵉⵖ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⵎⵛⴰⵡⴰⵔⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK20_4","027_20_4","EZK","20","4","4","‘ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵃⴻⴽⵎⴻⴷ, ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⵃⴻⴽⵎⴻⴷ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ? ⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵊⵊⵄⴰⵢⴻⴼ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EK20_5","027_20_5","EZK","20","5","5","ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵅⴹⴰⵔⴻⵖ ⵉⵙⵔⴰⵉⵍ, ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵏⴻⵛⵛ ⴰⴼⵓⵙ ⵉⵏⵓ, ⵊⵊⵓⴵⴻⵖ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓⵛⴰ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ, ⵏⵏⵉⵖ: ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_6","027_20_6","EZK","20","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⵙⴻⵏ ⴰⴼⵓⵙ ⵉⵏⵓ ⵊⵊⵓⴵⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵖ ⵏⴻⵛⵛ ⵉ ⵏⵉⵜⵏⵉ, ⵜⴰⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_7","027_20_7","EZK","20","7","7","ⵏⵏⵉⵖ ⴰⵙⴻⵏ: ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⵉⵊⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵎⵉⵚⵔⴰ, ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("EK20_8","027_20_8","EZK","20","8","8","“ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⴼⵉ ⵓⵛⴰ ⵡⴰⵔ ⵅⵉⵙⴻⵏ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵙⵍⴻⵏ. ⵡⴰⵔ ⵏⴹⴰⵔⴻⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵊⵊⵉⵏ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ. ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴰⴷ ⵅⴰⵙⴻⵏ ⵣⴻⴵⵄⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵖⴰⴹⴰⴱ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_9","027_20_9","EZK","20","9","9","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⴼⵙⴰⴷ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵉ ⵓⵎⵉ ⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵅⵎⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_10","027_20_10","EZK","20","10","10","ⵙⵙⵓⴼⴼⵖⴻⵖ ⵜⴻⵏ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵖ ⵜⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_11","027_20_11","EZK","20","11","11","ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵜⴻⵏ ⵅ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵉ ⵣⵉ ⵖⴰ ⵉⴷⴷⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉ ⵖⴰ ⵢⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("EK20_12","027_20_12","EZK","20","12","12","ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⵏⵉⵜⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK20_13","027_20_13","EZK","20","13","13","ⵎⴰⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵖⴻⵡⵡⴻⵖ ⵅⴰⴼⵉ ⴷⵉ ⵍⴻⵅⵍⴰ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵉ ⵣⵉ ⵖⴰ ⵉⴷⴷⴰⵔ ⴱⵏⴰⴷⴻⵏ ⵏⵏⵉ ⵜⴻⵏⵜ ⵉⴳⴳⵉⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵏⵏⵉⵖ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵅⴰⵙⴻⵏ ⴼⴰⵔⵔⵖⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⴷⵉ ⵍⴻⵅⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵇⴹⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("EK20_14","027_20_14","EZK","20","14","14","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵉⵜ ⵛⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵍⵉⵏ ⵓⵎⵉ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_15","027_20_15","EZK","20","15","15","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵊⵊⵓⴵⴻⵖ ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ, ⵜⴰⵎⵎⵓⵔⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵓⵖⵉ ⴷ ⵜⴰⵎⵎⴻⵏⵜ, ⵜⴻⵏⵏⵉ ⵢⴻⴵⴰⵏ ⴷ ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("EK20_16","027_20_16","EZK","20","16","16","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ⵡⴰⵔ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ, ⵎⴰⵖⴰⵔ ⵓⵍ ⵏⵙⴻⵏ ⵉⴹⴼⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_17","027_20_17","EZK","20","17","17","ⵎⴰⵛⴰ ⵙⴻⵎⵃⴻⵖ ⴰⵙⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵓ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵇⴹⵉⵖ ⴷⵉ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK20_18","027_20_18","EZK","20","18","18","“ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ: ‘ⵡⴰⵔ ⴳⴳⵓⵔⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⵉⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_19","027_20_19","EZK","20","19","19","ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ! ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵃⴹⴰⵎ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓⵛⴰ ⴳⴳⴻⵎ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK20_20","027_20_20","EZK","20","20","20","ⵙⵇⴻⴷⴷⵙⴻⵎ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵊⴰⵔ ⴰⵢⵉ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("EK20_21","027_20_21","EZK","20","21","21","ⵎⴰⵛⴰ ⵄⴰⴷ ⴰⵔⵔⴰⵡ ⵏⵙⴻⵏ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⴼⵉ: ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵃⴹⵉⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵓⵢⵓⵔⴻⵏ, ⵎⵉⵏ ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵜⴻⵏⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴷⴷⴰⵔ. ⵏⵉⵜⵏⵉ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ ⴰⵍⴰⵎⵉ ⵏⵏⵉⵖ, ⴰⴷ ⵅⴰⵙⴻⵏ ⴼⴰⵔⵔⵖⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵎⵎⵓ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_22","027_20_22","EZK","20","22","22","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⴰⴼⵓⵙ ⵉⵏⵓ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴹⵉⴷⴷ ⵏⵙⴻⵏ. ⴳⴳⵉⵖ ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⵉⵊ ⵉⵙⴻⵎ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵜⴻⵏ-ⴷⴷ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK20_23","027_20_23","EZK","20","23","23","ⵄⴰⵡⴻⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵊⵊⵓⴵⴻⵖ ⴰⴷ ⵜⴻⵏ ⴱⴻⵣⵣⵄⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("EK20_24","027_20_24","EZK","20","24","24","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ, ⵓ ⵎⵉⵏⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK20_25","027_20_25","EZK","20","25","25","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉ ⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK20_26","027_20_26","EZK","20","26","26","ⵏⴻⵛⵛ ⵙⵙⵅⴻⵎⵊⴻⵖ ⵜⴻⵏ ⵙ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⵎⵍⴰⵡⴻⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵢⴻⴽⴽ ⵜⵉⵎⴻⵙⵙⵉ, ⴳⴳⵉⵖ ⵜⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⵃⵉⵖ ⴰⵍⴰⵎⵉ ⵖⴰ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK20_27","027_20_27","EZK","20","27","27","“ⵙ ⵓⵢⴰ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵓⵍⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴰⵢⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴰⵢⵉ ⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK20_28","027_20_28","EZK","20","28","28","ⵍⴰⵎⵉ ⵜⴻⵏ ⵙⵙⵉⴷⴼⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵏⵏⵉ ⵅ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⵜ ⵡⵛⴻⵖ, ⵅⴻⵣⵣⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⴽⵓⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵢⵓⵄⵍⴰⵏ ⵓ ⵖⴰⵔ ⵡⴻⵣⵖⴰⵔ ⵉⵎⵛⵓⴱⴱⵛⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴷⵉⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵓ ⵇⴻⴷⴷⵎⴻⵏ ⴷⵉⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵙⵄⴰⵔⴻⵏⵜ, ⵓ ⵇⵇⴻⴷⵎⴻⵏ ⴷⵉⵏ ⴰⵔⵔⵉⵃⴻⵜ ⵏⵙⴻⵏ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵓ ⵙⴻⵢⵢⴱⴻⵏ ⴷⵉⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("EK20_29","027_20_29","EZK","20","29","29","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: ‘ⵎⴰⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏⵏⵉ ⵖⴰⵔ ⵖⴰ ⵜⵔⴰⵃⴻⵎ? ⵉⵙⴻⵎ ⵏⵏⴻⵙ ‘ⴱⴰⵎⴰⵀ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵍⴳⴻⵄⵄⴷⴻⵜ’, ⴰⵍ ⴰⵙⵙ-ⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK20_30","027_20_30","EZK","20","30","30","“ⵙ ⵓⵢⴰ, ⵉⵏⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵅⴻⵎⵎⵉⵊⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵅ ⵙⵉⵎⴰⵏⵜ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⴻⴼⵙⵉⴷⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⵎ ⵜⴹⴻⴼⴼⴰⵔⴰⵎ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ? ");
INSERT INTO rift_vpl VALUES ("EK20_31","027_20_31","EZK","20","31","31","ⴰⵎ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ, ⵜⴻⵙⵙⴻⴽⴽⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵅ ⵜⵎⴻⵙⵙⵉ ⵓ ⵜⴻⵙⵙⵅⴻⵎⵎⴰⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏⵡⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴰⵍ ⴰⵙⵙ-ⴰ? ⵎⴰ ⵏⴻⵛⵛ ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵊⵊⴻⵖ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵊⵊⵉⵖ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵇⵙⴰⵎ! ");
INSERT INTO rift_vpl VALUES ("EK20_32","027_20_32","EZK","20","32","32","ⵎⵉⵏ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⴷⵉ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ: ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⴰⵎ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⵎ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵓⵎⵉ ⵖⴰ ⵏⴻⵄⴱⴻⴷ ⵚⵚⴰⵏⴰⵎ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("EK20_33","027_20_33","EZK","20","33","33","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵚⴻⵍⵍⵟⴻⵖ ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵙ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⵓ ⵙ ⵓⴼⴰⵔⵔⴻⵖ ⵏ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("EK20_34","027_20_34","EZK","20","34","34","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵙ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵓⵖⵉⵍ ⵉⵙⵙⵡⵉⵥⵥⴰⴹⴻⵏ ⵓ ⵙ ⵓⴼⴰⵔⵔⴻⵖ ⵏ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK20_35","027_20_35","EZK","20","35","35","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⴷⵉⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵛⴰⵔⵔⵄⴻⵖ, ⵓⴷⴻⵎ ⴷ ⵓⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_36","027_20_36","EZK","20","36","36","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵃⴻⴽⵎⴻⵖ ⵅ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵎⵎⵓ ⵉ ⵅⴰⵡⴻⵎ ⵖⴰ ⵃⴻⴽⵎⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK20_37","027_20_37","EZK","20","37","37","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⴽⴽⴻⵖ ⵙⴰⴷⵓ ⵓⵣⴻⴵⴰⴷ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⴷⴼⴻⵖ ⴷⵉ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("EK20_38","027_20_38","EZK","20","38","38","ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵣⵓⵣⵣⴰⵔⴻɣ ⵉⵎⵖⴻⵡⵡⴰⵖⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻɣ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵖⵓⴱⴱⵉⵢⴻⵜ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⴰⵎ ⵢⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴽⴽⵡⵉⴹⴻⵏ ⵛⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK20_39","027_20_39","EZK","20","39","39","“ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏⵏⴻⵙ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵖⴰⵔⵉ ⵜⴻⵙⵍⴻⵎ ⵙ ⵜⵉⴷⴻⵜⵜ. ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵙⵙⴻⵅⵙⴰⵔⴰⵎ ⵄⴰⴷ ⵉⵙⴻⵎ ⵉⵏⵓ ⵙ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵢⴹⴰ ⵏⵡⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_40","027_20_40","EZK","20","40","40","ⵎⵉⵏⵣⵉ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵅ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴷⵉⵏ ⴰⴷ ⴰⵢⵉ ⵜⵙⴻⵅⵅⴰⵔ ⵇⴰⵄ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ. ⴷⵉⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵔⴹⵉⵖ ⵓⵛⴰ ⴷⵉⵏ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵓⵍⴰ ⴷ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵎⵉⵏ ⵖⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK20_41","027_20_41","EZK","20","41","41","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⴰⵔⴹⵉⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴰⵔⵔⵉⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ ⵣⵣⴰⵜ ⵉ-ⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ");
INSERT INTO rift_vpl VALUES ("EK20_42","027_20_42","EZK","20","42","42","ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵡⵢⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ, ⵊⵊⵓⴵⴻⵖ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_43","027_20_43","EZK","20","43","43","ⴷⵉⵏ ⴰⴷ ⵜⵉⴷⴰⵔⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵏⵏⵉ ⵣⵉ ⵜⴻⵙⵙⵅⴻⵎⵊⴻⵏ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵛⴰⵔⵀⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵉⵄⴻⴼⴼⵏⴻⵏ ⵉ ⵜⴻⴳⴳⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK20_44","027_20_44","EZK","20","44","44","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵍⴰⵎⵉ ⴳⴳⵉⵖ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵉⵖⴻⵛⵛⴻⵏ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK21_1","027_21_1","EZK","21","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK21_2","027_21_2","EZK","21","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴻⴳⴳ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⴻⵊⵊ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵓⴷⵓⵎⴻⵏ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓⵛⴰ ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵉ ⵡⴻⵣⵖⴰⵔ ⵏ ⵢⴻⵢⵢⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("EK21_3","027_21_3","EZK","21","3","3","ⵉⵏⵉ ⵉ ⵡⴻⵣⵖⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ: ‘ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵖ ⴷⴰⵢⴻⵎ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵣⵉⵣⴰⵡⵜ ⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵢⵓⵥⵖⴻⵏ. ⴰⵛⴻⵄⵄⴰⵍ ⵏ ⵍⵄⴰⴱⵓⵇ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵙⵙⵉ ⵓ ⵙ ⵓⵢⴰ ⴰⴷ ⵜⵜⵡⴰⵛⴻⵎⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵎⴱⴰⴱ ⵣⵉ ⵍⵊⴰⵏⵓⴱ ⴰⵍ ⵛⵛⴰⵎⴰⵍ ");
INSERT INTO rift_vpl VALUES ("EK21_4","027_21_4","EZK","21","4","4","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ. ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵅⴻⵙⵙⵉ ⵛⴰ.’ ");
INSERT INTO rift_vpl VALUES ("EK21_5","027_21_5","EZK","21","5","5","ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ‘ⴰ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵄⴰⴷ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⵅⴰⴼⵉ: ‘ⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵙ ⵜⵃⵓⵊⴰ ⵏ ⵜⵡⴰⴼⵉⵜ ⵡⴰⵀⴰ?’!” ");
INSERT INTO rift_vpl VALUES ("EK21_6","027_21_6","EZK","21","6","6","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK21_7","027_21_7","EZK","21","7","7","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴻⴳⴳ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴻⵊⵊ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵓⴷⵓⵎⴻⵏ ⴹⵉⴷⴷ ⵉ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK21_8","027_21_8","EZK","21","8","8","ⵉⵏⵉ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⴰⵇⴰ ⵖⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵊⴻⴱⴷⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⴰⵎ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⵎ ⵓⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK21_9","027_21_9","EZK","21","9","9","ⵎⵉⵏⵣⵉ ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⴰⵎ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴰⵎ ⵓⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ, ⵙ ⵓⵢⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵏⵏⴻⵙ, ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵣⵉ ⵍⵊⴰⵏⵓⴱ ⴰⵍ ⵛⵛⴰⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EK21_10","027_21_10","EZK","21","10","10","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵊⴻⴱⴷⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ. ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵡⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("EK21_11","027_21_11","EZK","21","11","11","“ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⵖⵓⵏⴼⴰ, ⵙⵖⵓⵏⴼⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵙ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵜⵜⵡⴰⵔⵥⴻⵏⵜ ⴷ ⵜⴰⵔⵣⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("EK21_12","027_21_12","EZK","21","12","12","ⴰⴷ ⵉⵎⵙⴰⵔ ⵅⵎⵉ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵉⵏⵉⵏ: ‘ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⵖⵓⵏⴼⵉⴷ ⴰⵎⵎⵓ?’, ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵙⵍⵉⵖ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴽⵓⵍ ⵓⵍ ⴰⴷ ⵉⴼⵙⵉ ⵓ ⵎⴰⵔⵔⴰ ⵉⴼⴰⵙⵙⴻⵏ ⴰⴷ ⵀⴻⵢⵢⴼⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⴱⵓⵃⴱⴻⵍ ⴰⴷ ⵢⴰⵔⵅⵓ ⵓ ⵎⴰⵔⵔⴰ ⵉⴼⴰⴷⴷⴻⵏ ⴰⴷ ⴰⵔⴷⴱⴻⵏ ⴰⵎ ⵡⴰⵎⴰⵏ. ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK21_13","027_21_13","EZK","21","13","13","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK21_14","027_21_14","EZK","21","14","14","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ!’ ⵓⵛⴰ ⵉⵏⵉ: ‘ⵙⵙⵉⴼ, ⵙⵙⵉⴼ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵇⴹⴻⵄ ⵓ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK21_15","027_21_15","EZK","21","15","15","ⵉⵜⵜⵡⴰⵙⵙⴻⵇⴹⴻⵄ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵖⴰⵔⵚ ⵜⵉⵖⴰⵔⵚⴰ, ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⴻⵍⵍⴻⵛ.’ ⵏⵉⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴼⴰⵔⵔⴻⵃ, ⴰⴷ ⵏⵉⵏⵉ: ‘ⴰⵣⴻⴵⴰⴹ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏ ⵎⵎⵉ ⵉⵙⵙⴻⵃⵇⴰⵔ ⴽⵓⵍ ⴰⴽⴻⵛⵛⵓⴹ ⵏⵏⴻⵖⵏⵉ?’ ");
INSERT INTO rift_vpl VALUES ("EK21_16","027_21_16","EZK","21","16","16","‘ⵉⵎⵎⴻⵡⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ. ⵙⵙⵉⴼ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵓ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵇⴻⵜⵜⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK21_17","027_21_17","EZK","21","17","17","ⵙⵖⵓⵢⵢ ⵓⵛⴰ ⵜⵔⵓⴷ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵇⴰ ⵎⵎⴻⵡⵛⴻⵏ ⵉ ⵙⵙⵉⴼ ⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵙ ⵓⵢⴰ, ⵡⵡⴻⵜ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵜ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("EK21_18","027_21_18","EZK","21","18","18","‘ⵡⴰⵀ, ⵙⵙⵉⴼ ⵉⵜⵜⵡⴰⵇⴻⴵⴻⴱ. ⵎⴰⵛⴰ ⵎⴰⵏⴰ, ⵎⴰⵍⴰ ⴰⵣⴻⴵⴰⴹ ⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⴰⴽⴻⵛⵛⵓⴹ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ?’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK21_19","027_21_19","EZK","21","19","19","‘ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ, ⵓⵛⴰ ⵡⵡⴻⵜ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵖⴰⵔ ⵙⵙⵉⴼ ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⵏⴰⵢⴻⵏ, ⵡⴰⵀ, ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ. ⴰⵇⴰ-ⵜ ⴷ ⵙⵙⵉⴼ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵙⵙⵉⴼ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⵖ, ⵙⵙⵉⴼ ⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵜⵜⴰⴷⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK21_20","027_21_20","EZK","21","20","20","ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵓⵍ ⴰⴷ ⵉⴼⵙⵉ ⵓⵛⴰ ⴰⴷ ⵎⵎⴰⵔⴻⵏⵢⴻⵏⵜ ⵜⵄⴻⵏⴽⵔⵉⴼⵉⵏ. ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ ⴳⴳⵉⵖ ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵙⴻⵏ. ⴰⵢ, ⴰⵇⴰ ⵙⵙⵉⴼ ⵉⵡⵊⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⴻⵍⵍⴻⵛ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵊⴻⴱⴱ-ⴷⴷ ⵣⴻⴳ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵖⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("EK21_21","027_21_21","EZK","21","21","21","ⵙⵎⵓⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ, ⵇⴻⵙⵙ ⵖⴰⵔ ⵓⴼⵓⵙⵉ, ⴱⴻⴷⴷ, ⵇⴻⵙⵙ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⴰⵔⵔ ⵍⴻⵇⴹⴻⵄ ⵏⵏⴻⵛ ⵎⴰⵏⵉ ⵎⴰ ⵜⴻⵅⵙⴻⴷ.’ ");
INSERT INTO rift_vpl VALUES ("EK21_22","027_21_22","EZK","21","22","22","‘ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵡⵜⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK21_23","027_21_23","EZK","21","23","23","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK21_24","027_21_24","EZK","21","24","24","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴻⴳⴳ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵣⵉ ⵎⴰⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵙⵉⴼ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ⵏⵇⴻⵛ ⵉⵊⵊ ⵏ ⵓⵛⵉⵢⵢⴰⵔ ⵖⴰⵔ ⵓⴱⴻⵟⵟⵓ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵏⵇⴻⵛ ⵉ-ⵜ ⵖⴰⵔ ⵓⴱⴻⵟⵟⵓ ⵏ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK21_25","027_21_25","EZK","21","25","25","ⴰⴷ ⵜⵏⴻⵢⵢⵛⴻⴷ ⴰⴱⵔⵉⴷ ⵙ ⵎⴰⵏⵉⵙ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵙⵉⴼ ⵖⴰⵔ ⵔⴰⴱⴱⴰ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⴰⵍ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵏ: ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK21_26","027_21_26","EZK","21","26","26","ⵎⵉⵏⵣⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴰⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵎⴰⵏⵉ ⴼⴰⵔⵇⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ, ⵖⴰⵔ ⵓⴱⴻⴷⴷⵓ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵄⴻⵣⵣⴻⵎ. ⴰⴷ ⵉⵣⵣⴻⵔⵣ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵚ, ⴰⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⴰⴷ ⵉⵅⵣⴰⵔ ⵜⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EK21_27","027_21_27","EZK","21","27","27","ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⴼⵓⵙⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵛⵜⴰⴱ ⵏ ‘ⵓⵔⵛⴰⵍⵉⵎ!’, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵢⴻⴳⴳ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⴻⴷⵀⴰⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵡⴻⵏⵖⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⴻⴷⵀⴰⵎ ⴹⵉⴷⴷ ⵉ ⵜⴻⵡⵡⵓⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⴰⵛⴱⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⴱⴰⵔⴰⵊⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK21_28","027_21_28","EZK","21","28","28","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⴰⵎ ⵓⴳⴻⵣⵣⴻⵏ ⵉⵖⴻⵛⵛⴻⵏ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵊⴰⴵⴰⵜⵉⵏ ⵉⵎⴻⵜⵏⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵄⵇⴻⵍ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK21_29","027_21_29","EZK","21","29","29","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⴷⵉ: ‘ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴻⵄⵇⵉⵍⴻⵎ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ ⵓⵎⵉ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ ⵜⵜⴱⴰⵏⴻⵏ ⵏⵉⵛⴰⵏ, ⵅⵎⵉ ⵜⵜⵡⴰⵥⴰⵔⵔⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ, ⵡⴰⵀ, ⵎⵉⵏⵣⵉ ⵜⵙⵙⴻⵄⵇⵉⵍⴻⵎ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ, ⵙ ⵓⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵟⵟⴼⴻⵏ ⵙ ⵓⴼⵓⵙ.’ ");
INSERT INTO rift_vpl VALUES ("EK21_30","027_21_30","EZK","21","30","30","ⵓ ⵛⴻⴽ, ⴰⵄⴻⴼⴼⴰⵏ ⵉⵢⴻⵣⵣⵎⴻⵏ ⵉ ⵍⵎⴻⵡⵜ, ⵛⴻⴽ, ⴰ ⵍⵃⴰⴽⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴻⵏⵏⵉ ⴰⵙⵙ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵙⴰⴱ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("EK21_31","027_21_31","EZK","21","31","31","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵛ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴽⴽⴻⵙ ⴰⵔⴻⵥⵥⴻⵜ ⵏⵏⵉ, ⴽⴽⴻⵙ ⵜⵜⴰⵊ ⵏⵏⵉ. ⴰⵎⵎⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ. ⵎⵉⵏ ⵉⵙⵙⴻⵀⵡⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ, ⵓ ⵎⵉⵏ ⵉⵙⵙⵓⵄⵍⴰⵏ, ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("EK21_32","027_21_32","EZK","21","32","32","ⴰⴷ ⴰⵔⵔⴻⵖ ⴰⵢⴰ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⵡⴰⵀ, ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⴷ ⵍⵅⴰⵔⴱⴻⵜ. ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ, ⵎⵖⵉⵔ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰⵏ ⵍⵃⴻⵇⵇ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵜ ⵡⵛⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK21_33","027_21_33","EZK","21","33","33","“ⵓ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓ ⵅ ⵓⵙⴻⵃⵇⴰⵔ ⵏⵙⴻⵏ!’ ⵉⵏⵉ: ‘ⵙⵙⵉⴼ, ⵙⵙⵉⴼ ⵉⵜⵜⵡⴰⵊⴻⴱⴷ-ⴷⴷ, ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵛⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⴻⵍⵍⴻⵛ, ... ");
INSERT INTO rift_vpl VALUES ("EK21_34","027_21_34","EZK","21","34","34","- ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵍⴰⵏ ⵉ ⵛⴻⴽ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵡⴰⵔ ⵉⴵⵉⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴳⴻⵣⵣⵏⴻⵏ ⵉ ⵛⴻⴽ ⵉⵊⵊ ⵏ ⵓⴳⴻⵣⵣⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ - ... ⴰⵇⴰ ⵙⵙⵉⴼ ⵉⵜⵜⵡⴰⵊⴻⴱⴷ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵢⴰⵔⵔ ⵖⴰⵔ ⵉⵔⴰⵡⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵏⵏⵉ ⵣⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵙⵙ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵙⴰⴱ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EK21_35","027_21_35","EZK","21","35","35","ⴰⵔⵔ ⵙⵙⵉⴼ ⵖⴰⵔ ⵓⴼⵓⵔⵔⵓ ⵏ ⵡⴻⵖⵍⴰⴼ ⵏⵏⴻⵙ. ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⴷ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍ’ⴰⵚⴻⵍ ⵏⵏⴻⵛ ⴰⴷ ⵛⴻⴽ ⵃⴻⴽⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK21_36","027_21_36","EZK","21","36","36","ⴰⴷ ⵅⴰⴽ ⵣⴻⴵⵄⴻⵖ ⵡⴻⵙⵅⴻⴹ ⵉⵏⵓ. ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵉⵏⵓ ⵏ ⵓⴼⵓⴳⴻⵎ ⴰⴷ ⵅⴰⴽ ⵙⵓⴹⴻⵖ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵖⴻⵣⵣⵓ ⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⴷ ⴷⴻⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK21_37","027_21_37","EZK","21","37","37","ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵜⵎⴻⵙⵙⵉ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⵣⵣⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵇⴰⵄ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴰⵢⴻⴽ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK22_1","027_22_1","EZK","22","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK22_2","027_22_2","EZK","22","2","2","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ, ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ? ⵙⵛⴻⵏ ⴰⵙ ⵅⴻⵏⵏⵉ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK22_3","027_22_3","EZK","22","3","3","ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵛⴻⵎ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ, ⵜⴻⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ, ⵜⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("EK22_4","027_22_4","EZK","22","4","4","ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⵉⵣⵣⵍⴻⴷ, ⵜⴷⴻⵡⵍⴻⴷ ⵙ ⵓⵎⴰⵔⵡⴰⵙ ⵓ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏⵏⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ, ⴰⵇⴰ ⵜⴻⵙⵙⵅⴻⵎⵊⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ, ⵜⴻⵙⵙⵉⵡⴹⴻⴷ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⵔⴻⵀⵀⴳⴻⴷ ⴰⵍ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵎ. ⵅ ⵓⵢⴰ ⵡⵛⵉⵖ ⵛⴻⵎ ⵉ ⵍⴻⴳⵏⵓⵙ ⵉ ⵓⵙⴻⵃⵇⴰⵔ ⵓ ⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵉ ⵓⵙⵜⴻⵀⵣⵉ. ");
INSERT INTO rift_vpl VALUES ("EK22_5","027_22_5","EZK","22","5","5","ⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵙⵜⴻⵀⵣⴰⵏ: ’ⵛⴻⵎ, ⴰ ⵜⴰⵎⴻⵅⵎⵓⵊⵜ ⵏ ⵢⵉⵙⴻⵎ, ⵛⴻⵎ, ⵜⴻⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵓⵚⴻⴷⴷⴻⵄ! ");
INSERT INTO rift_vpl VALUES ("EK22_6","027_22_6","EZK","22","6","6","ⵅⵣⴰⵔ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴰⵢⴻⵎ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵍⴻⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK22_7","027_22_7","EZK","22","7","7","ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⴷ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⴷⴰⵢⴻⵎ, ⴳⴳⵉⵏ ⵙ ⵓⵖⵉⵍ ⴰⴽ-ⴷ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ, ⵃⵚⴰⵔⴻⵏ ⴰⵢⵓⵊⵉⵍ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵉ ⴷⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK22_8","027_22_8","EZK","22","8","8","ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⴷ ⵜ, ⵓⵛⴰ ⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵉⵏⵓ ⵜⴻⵙⵙⵄⵉⴵⵜⴻⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK22_9","027_22_9","EZK","22","9","9","ⵉⵎⵛⴻⵇⵇⴰⴼⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴰⵢⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ. ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵛⵛⵉⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏⵏⵉ ⴷⵉⵏⵏⵉ ⵖⴰⵔⴻⵎ, ⴰⵇⴰ ⴳⴳⵉⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK22_10","027_22_10","EZK","22","10","10","ⵏⵉⵜⵏⵉ ⵙⵙⵄⴰⵔⵔⴰⵏ ⵍⵄⴰⵔ ⵏ ⴱⴰⴱⴰⵎ ⵏⵏⵉ ⴷⵉⵏ ⵖⴰⵔⴻⵎ, ⵓ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵅⵎⴻⵊ ⵓⵎⵉ ⵅⴰⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⵇⴰ ⵖⴻⵚⴱⴻⵏ ⵜⵜ ⴷⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK22_11","027_22_11","EZK","22","11","11","ⵉⵊⵊⴻⵏ ⵉⴳⴳⴰ ⵏⵏⵄⵉ ⴰⴽ-ⴷ ⵜⵎⴻⵟⵟⵓⵜ ⵏ ⵡⴰⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵎⵎⵉⵙ, ⵉⵜⵜⴻⴳⴳ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴰⴽⵉⴷⴻⵙ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵖⵚⴻⴱ ⵓⵍⵜⵎⴰⵙ, ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⴰⵙ, ⴷⵉⵏ ⵖⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK22_12","027_22_12","EZK","22","12","12","ⴰⵇⴰ ⵟⵟⴼⴻⵏ ⴷⵉⵏ ⵖⴰⵔⴻⵎ ⴰⵔⵔⴻⵛⵡⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵜⴻⴽⵙⵉⴷ ⴰⵔⵔⵉⴱⴰ ⴷ ⴰⵔⴱⴻⵃ ⵓⵛⴰ ⵜⴱⴻⵄⵄⵊⴻⴷ ⴰⵊⵊⴰⵔ ⵏⵏⴻⵛ ⵙ ⵓⵖⵉⵍ, ⵎⴰⵛⴰ ⵜᵉⵜⵜⵓⴷ ⴰⵢⵉ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK22_13","027_22_13","EZK","22","13","13","“ⵅⵣⴰⵔ, ⵡⵜⵉⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴱⴻⵄⵄⴻⵊ ⵉ ⵜⴻⴳⴳⵉⴷ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ.    ");
INSERT INTO rift_vpl VALUES ("EK22_14","027_22_14","EZK","22","14","14","ⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵍ ⵏⵏⴻⵎ ⵉⵎⵜⴻⵏ? ⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ ⵊⴻⵀⴷⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵎ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK22_15","027_22_15","EZK","22","15","15","ⴰⴷ ⵛⴻⵎ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵛⴻⵎ ⴱⴻⵣⵣⵄⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⴰ, ⵓ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵜⴰⵅⵎⵓⵊⵉ ⵏⵏⴻⵎ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EK22_16","027_22_16","EZK","22","16","16","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵜⴻⴷ ⵣⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵛⴻⵎ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK22_17","027_22_17","EZK","22","17","17","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK22_18","027_22_18","EZK","22","18","18","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⵡⵍⴻⵏ ⴰⵢⵉ ⴰⵎ ⴽⵓⴼⴼⵓ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵉⵙⵜⴰⵏⵢⵓ ⴷ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⴻⵅⴼⵉⴼ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⴼⵇⵓⵏⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴽⵓⴼⴼⵓ ⵏ ⵏⵏⵓⵇⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EK22_19","027_22_19","EZK","22","19","19","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴷⴻⵡⵍⴻⵎ ⴰⵎ ⴽⵓⴼⴼⵓ, ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK22_20","027_22_20","EZK","22","20","20","ⴰⵅⵎⵉ ⵢⴰⵔⵡⴻⵏ ⵏⵏⵃⴰⵙ ⴷ ⵉⵙⵜⴰⵏⵢⵓ ⴷ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⴻⵅⴼⵉⴼ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵛⴻⵄⵄⵍⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴼⴻⵙⵢⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴰⵎⵎⵓ ⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵙⵙⵎⵓⵏⴻⵖ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ. ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴰⵔⵙⴻⵖ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴼⴻⵙⵢⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK22_21","027_22_21","EZK","22","21","21","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵓⴹⴻⵖ ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵉⵏⵓ ⵏ ⵓⴼⵓⴳⴻⵎ ⴰⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⵙⵢⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK22_22","027_22_22","EZK","22","22","22","ⴰⵅⵎⵉ ⵙⵙⴼⴻⵙⵢⴻⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴼⴻⵙⵢⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⴼⴰⵔⵖⴻⵖ ⵅⴰⵡⴻⵎ ⴰⵙⵄⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("EK22_23","027_22_23","EZK","22","23","23","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK22_24","027_22_24","EZK","22","24","24","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵉ ⵉ ⵜⴻⵎⵎⵓⵔⵜ: ‘ⵛⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⵉⴳⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵓⴼⴼⴻⵏ ⵙ ⵡⴻⵏⵥⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵙⵅⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("EK22_25","027_22_25","EZK","22","25","25","ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⵉⵙⴰⵔⴹ ⵜⴰⵢⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵛⵛⵉⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵄⵎⵓⵔ. ⴽⴽⵙⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⴰⵅⴰⴱⴻⵛⵜ ⴷ ⵎⵉⵏ ⵉⵖⵍⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⵔⵏⵉⵏ ⵜⵉⵊⵊⴰⵍ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK22_26","027_22_26","EZK","22","26","26","ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵙⴻⵏ ⵙⵙⵄⵉⴵⵉⵜⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⵓⵛⴰ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⴰⵔⵔⵣⴻⵏ ⵛⴰ ⵊⴰⵔ ⵎⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵙⵙⵄⵉⴵⵜⴻⵏ, ⵡⴰⵔ ⵙⵙⵛⴰⵏⴰⵏ ⵛⴰ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ ⴷ ⵎⵉⵏ ⵉⵣⴷⵉⴳⴻⵏ ⵓⵛⴰ ⵜⵜⴱⴻⵍⵍⴰⵄⴻⵏ ⵓⵍⴰ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵉ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ ⵓⵛⴰ ⴰⵎⵎⵓ ⵜⵜⵡⴰⵙⵙⵄⵉⴵⵉⵜⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK22_27","027_22_27","EZK","22","27","27","ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⴰⵎ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵛⴰⵔⵔⴳⴻⵏ ⵜⴰⵢⵎⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⵄⵎⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵔⴱⴻⵃ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK22_28","027_22_28","EZK","22","28","28","ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷⵍⵉⵏ ⵜⴻⵏ ⵙ ⵊⵊⵉⵍ ⵢⵓⵥⵖⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵍⴰⵏ ⵉⵡⴻⵃⵃⴰⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵓⵛⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵙ ⵜⴳⴻⵣⵣⴰⵏⵜ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ!, ⴰⵎ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵏⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("EK22_29","027_22_29","EZK","22","29","29","ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⴳⴳⴰ ⴱⴻⵣⵣⴻⵣ ⵅ ⵉⵡⴷⴰⵏ ⵙ ⵍⴻⵅⵛⵓⵏⴻⵜ, ⴽⴻⵛⵛⴹⴻⵏ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ, ⵃⴻⵚⵚⴰⵔⴻⵏ ⵍⵎⴻⵙⴽⵉⵏ ⴷ ⵓⵎⴻⵣⵍⵓⴹ, ⵓⵛⴰ ⴷⴻⴵⴻⵏ ⴰⴱⴰⵔⵔⴰⵏⵉ ⴱⵍⴰ ⵎⴰ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("EK22_30","027_22_30","EZK","22","30","30","ⴰⵔⵣⵓⵖ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵓⵛⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⴰⵣⵣⵉⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜ ⵜⵜⴰⵔⴻⴷⴵⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵓⴼⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("EK22_31","027_22_31","EZK","22","31","31","ⵅⴰⵙ ⵓⵛⴰ ⵙⵙⴼⴰⵔⵖⴻⵖ ⵅⴰⵙⴻⵏ ⴰⵙⵅⴻⴹ ⵉⵏⵓ. ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵉⵏⵓ ⵏ ⵓⴼⵓⴳⴻⵎ ⵇⴹⵉⵖ ⵅⴰⵙⴻⵏ, ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴰⵔⵔⵉⵖ ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK23_1","027_23_1","EZK","23","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK23_2","027_23_2","EZK","23","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵢⴻⵙⵙⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_3","027_23_3","EZK","23","3","3","ⵏⵉⵜⴻⵏⵜⵉ ⵙⵙⴼⴻⵙⴷⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵙⴻⵏⵜ ⵙⵙⴼⴻⵙⴷⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ. ⴷⵉⵏ ⵜⵓⵖⴰ ⵄⴻⴱⵣⴻⵏⵜ ⴷⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⴷⵉⵏ ⵃⴰⴷⴰⵏ ⵉⴱⴱⴰⵛ ⵏⵙⴻⵏⵜ ⵉⵄⵓⵣⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_4","027_23_4","EZK","23","4","4","ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏⵜ ⵜⵓⵖⴰ ⵓⵀⵓⵍⴰ, ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵙⴻⵏⵜ, ⴷ ⵓⵍⵜⵎⴰⵙ ⵓⵀⵓⵍⵉⴱⴰ. ⵏⵉⵜⴻⵏⵜⵉ ⴷⴻⵡⵍⴻⵏⵜ ⵉⵏⵓ ⵓⵛⴰ ⵓⵔⵡⴻⵏⵜ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ. ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏⵜ: ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵓⵀⵓⵍⴰ, ⵓ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵓⵀⵓⵍⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("EK23_5","027_23_5","EZK","23","5","5","ⵓⵀⵓⵍⴰ ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔⵉ ⵓ ⵜⴻⵄⵛⴻⵇ ⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ, ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK23_6","027_23_6","EZK","23","6","6","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴰⴷⴻⵃⵎⵉ, ⵍⵡⵓⵍⴰⵜ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵢⴻⵏⵢⵉⵏ ⵙ ⵓⵢⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EK23_7","027_23_7","EZK","23","7","7","ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵜⴻⵡⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵏⵉⵜⵏⵉ, ⵖⴰⵔ ⵍⴻⵎⵅⴻⵢⵢⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵙ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜᵉⵜⵜⴻⵅⵙ, ⵙ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵚⵚⴰⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EK23_8","027_23_8","EZK","23","8","8","ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴻⵊⵊⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ ⵟⵟⵙⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵃⴰⴷⴰⵏ ⵉⴱⴱⴰⵛ ⵏⵏⴻⵙ ⵉⵄⵓⵣⵔⵢⴻⵏ ⵓⵛⴰ ⵙⵙⴼⴰⵔⵔⵖⴻⵏ ⵅⴰⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK23_9","027_23_9","EZK","23","9","9","“ⵙ ⵓⵢⴰ ⵡⵛⵉⵖ ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ ⵉ ⵜⵓⵖⴰ ⵜⴻⵄⵛⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("EK23_10","027_23_10","EZK","23","10","10","ⵏⵉⵜⵏⵉ ⵙⵙⵄⴰⵔⵔⴰⵏ ⵍⵄⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜⵜ ⵙ ⵙⵙⵉⴼ. ⵜⴻⴷⵡⴻⵍ ⴰⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵡⴰⵔ ⵉⵛⵏⵉⵄ ⵊⴰⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⴹⴻⵏ ⵅⴰⵙ ⵍⴻⵃⴽⴰⵎⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("EK23_11","027_23_11","EZK","23","11","11","“ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵓⵍⵜⵎⴰⵙ, ⵓⵀⵓⵍⵉⴱⴰ, ⴰⵇⴰ ⵜⴰⵔⵏⵉ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵄⵛⴻⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴰⵔⵏⵉ ⵓⵍⴰ ⴷⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⴽⵜⴰⵔ ⵅ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏ ⵓⵍⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK23_12","027_23_12","EZK","23","12","12","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵄⵛⴻⵇ ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ, ⵍⵡⵓⵍⴰⵜ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ, ⵊⵊⵉⵔⴰⵏ ⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴷ ⵍⴻⵎⵍⵉⵃ ⵇⴰⵄ, ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵢⴻⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ, ⵎⴰⵔⵔⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_13","027_23_13","EZK","23","13","13","ⵥⵔⵉⵖ ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵏⵉⵜⴻⵏⵜⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏⵜ ⵓⵢⵓⵔⴻⵏⵜ ⴰⴱⵔⵉⴷ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_14","027_23_14","EZK","23","14","14","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵏⵉ ⵄⴰⴷ ⴷⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ. ⵓⵎⵉ ⵜⴻⵥⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵃⴻⵏⵏⵛⴻⵏ ⵜⴻⵏ ⵅ ⵍⵃⵉⴹ, ⵜⵚⴰⵡⴰⵔ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵔⵛⴰⵎⴻⵏ ⴷⵉ ⵜⵉⵏⵜⴰⵜ ⵜⵉⵣⴻⴳⴳⵯⴰⵖⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("EK23_15","027_23_15","EZK","23","15","15","ⴱⴻⵢⵙⴻⵏ ⵙ ⵡⴻⴱⵢⴰⵙ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵙⴻⵏ, ⵙ ⵉⵔⴻⵥⵥⴰⵜ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵇⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵛⵛⵓⴼ ⴰⵎ ⵢⵉⵏⴻⵖⵔⴰⴼⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⴰⵔⴻⵡⵙⴻⵏ ⴷⵉ ⴰⵢⵜ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵏⵉ ⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_16","027_23_16","EZK","23","16","16","ⴰⵎⵎⵓ ⵉ ⵜⴻⴷⵡⴻⵍ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⴻⵅⵙ ⵉ-ⵜⴻⵏ ⵓⵎⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵥⵔⵉⵏⵜ ⵜⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⴽⴽ ⵖⴰⵔⵙⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_17","027_23_17","EZK","23","17","17","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴰⵢⵜ ⵏ ⴱⴰⴱⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⵚⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴷⵉ ⵇⴰⵎⴰ ⵏ ⵜⵎⴻⵅⵙⴰ ⵓⵛⴰ ⵙⵙⵅⴻⵎⵊⴻⵏ ⵜⵜ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⵊ ⵅⴰⵙⴻⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK23_18","027_23_18","EZK","23","18","18","ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵏⴻⵜⵜⴰⵜ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵓⵛⴰ ⵜⴻⵙⵙⵄⴰⵔⵔⴰ ⵍⵄⴰⵔ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⵊ ⵅⴰⵙ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵓⵍⴰ ⵅ ⵓⵍⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK23_19","027_23_19","EZK","23","19","19","ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵜⴻⵄⵇⴻⵍ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK23_20","027_23_20","EZK","23","20","20","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵄⵛⴻⵇ ⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵉⵏⵏⵉ ⴰⵢⵙⵓⵎ ⵏⵙⴻⵏ ⴰⵎ ⵡⴻⵢⵙⵓⵎ ⵏ ⵉⵖⵢⴰⵍ ⵓ ⵉⵏⵏⵉ ⴰⴷⵄⴰⵇ ⵏⵙⴻⵏ ⴰⵎ ⵡⴻⴷⵄⴰⵇ ⵏ ⵉⵢⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_21","027_23_21","EZK","23","21","21","ⴰⵇⴰ ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵍⴻⴼⴹⵉⵀⴻⵜ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵎ, ⴰⵍⴰⵎⵉ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵃⴰⴷⴰⵏ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵏ ⵜⴻⵎⵥⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK23_22","027_23_22","EZK","23","22","22","“ⵙ ⵓⵢⴰ, ⵓⵀⵓⵍⵉⴱⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵎ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⴰⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("EK23_23","027_23_23","EZK","23","23","23","ⵜⴰⵔⵡⴰ ⵏ ⴱⴰⴱⵉⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⴷ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵓ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴰⵛⵛⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵊⴻⴱⴱⴷⴻⵏ ⵎⴻⵥⵔⵉ, ⵍⵡⵓⵍⴰⵜ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ, ⵉⵏⴻⵖⵔⴰⴼⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙ ⵢⵉⵙⴻⵎ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵢⴻⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_24","027_23_24","EZK","23","24","24","ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵎ ⴷⴷ-ⵓⵙⵉⵏ ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵉⵇⴰⵔⵇⴱⴻⵏ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵙ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⵓⵍⴰ ⵙ ⵍⴽⴰⵙⴽ ⵅ ⵓⵣⴻⴵⵉⴼ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵎ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⴷⴷⴻⵄⵡⴻⵜ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⵎ ⵃⴻⴽⵎⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_25","027_23_25","EZK","23","25","25","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵛⴻⵎ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴳⴳⴻⵏ ⵙ ⵡⴻⵙⵄⴰⵔ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⵇⵙⴻⵏ ⵜⵉⵏⵣⴰⵔⵉⵏ ⵏⵏⴻⵎ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵉⵡⴹⴰ ⵙ ⵙⵙⵉⴼ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴽⵙⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⴷ ⵢⴻⵙⵙⵉⵎ ⵏⵏⴻⵎ ⵓⵛⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK23_26","027_23_26","EZK","23","26","26","ⴰⴷ ⴽⴽⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵏ ⵍⴻⵀⵣⵓⵟ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK23_27","027_23_27","EZK","23","27","27","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ ⵓⵍⴰ ⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⵙⵙⴳⵉⵄⵄⴷⴻⴷ ⵄⴰⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⵓ ⵡⴰⵔ ⵜⵉⴷⴰⵔⴻⴷ ⵄⴰⴷ ⵎⵉⵚⵔⴰ.’ ");
INSERT INTO rift_vpl VALUES ("EK23_28","027_23_28","EZK","23","28","28","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⴳⴳⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK23_29","027_23_29","EZK","23","29","29","ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴳⴳⴻⵏ ⴰⵎ ⵡⴻⵛⵔⴰⵀ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⴽⴽⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉ ⵓⵎⵉ ⵜⴰⵔⴱⵔⴻⴷ ⵓⵛⴰ ⴰⴷ ⵛⴻⵎ ⵊⵊⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⵉⴷ ⴷ ⵜⵓⵄⴰⵔⵢⴰⵏⵜ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⵍⵄⴰⵔ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ ⵓⵍⴰ ⴷ ⵍⴻⴼⴹⵉⵀⴻⵜ ⵏⵏⴻⵎ ⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK23_30","027_23_30","EZK","23","30","30","ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴳⴳⴻⵏ ⴰⵢⴰ ⵎⵉⵏⵣⵉ ⵜⴻⴹⴼⴰⵔⴻⴷ ⵍⴻⴳⵏⵓⵙ ⴰⵎ ⵉⴳⴳⵓⵔ ⴱⵏⴰⴷⴻⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵅⴻⵎⵊⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏ ⵚⵚⴰⵏⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_31","027_23_31","EZK","23","31","31","ⵜⵓⵢⵓⵔⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵓⵍⵜⵎⴰⵎ, ⵓⵛⴰ ⴰⴷ ⴰⵎ ⵡⵛⴻⵖ ⵍⴽⴰⵙ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("EK23_32","027_23_32","EZK","23","32","32","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⵍⴽⴰⵙ ⵏ ⵓⵍⵜⵎⴰⵎ ⵡⴻⵏⵏⵉ ⵢⵓⴵⵖⴻⵏ ⵓ ⵉⵡⴻⵙⵄⴻⵏ, ⴰⵍⴰⵎⵉ ⵍⵇⴻⴷⴷ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⵔ ⵍⵄⴻⴷⵢⴰⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⴷⴻⵀⵛⴻⵏ ⵙ ⵍⵃⴻⴳⵔⴰ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵙⵜⴻⵀⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_33","027_23_33","EZK","23","33","33","ⴰⴷ ⵜⴻⵛⵛⵓⵔⴻⴷ ⵙ ⵡⴻⵙⵛⴰⵔ ⴷ ⵡⴻⵛⴹⴰⵏ. ⵍⴽⴰⵙ ⵏ ⵓⵍⵜⵎⴰⵎ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵡⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("EK23_34","027_23_34","EZK","23","34","34","ⴰⴷ ⵜ ⵜⴻⵙⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⵜ ⵜⵥⴻⵎⵎⴻⴷ, ⴰⴷ ⵜⵖⴻⵣⵣⴻⴷ ⵛⵇⵓⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵇⴻⴱⵛⴻⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK23_35","027_23_35","EZK","23","35","35","‘ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⴷⴰⵢⵉ ⵜᵉⵜⵜⵓⴷ ⵓⵛⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⴷ ⴰⵢⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵎ, ⵙ ⵓⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⵎ ⴰⴷ ⵜⴰⵔⴱⵓⴷ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵓⵍⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ ⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("EK23_36","027_23_36","EZK","23","36","36","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵛⴰⵔⵔⵄⴻⴷ ⵓⵀⵓⵍⴰ ⴷ ⵓⵀⵓⵍⵉⴱⴰ? ⵉⵏⵉ ⴰⵙⴻⵏⵜ ⵅⴻⵏⵏⵉ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_37","027_23_37","EZK","23","37","37","ⵎⵉⵏⵣⵉ ⵣⴻⵏⵏⴰⵏⵜ ⵓⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵍⴻⵚⵇⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ ⵓ ⵣⴻⵏⵏⴰⵏⵜ ⴰⴽ-ⴷ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏⵜ. ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵢⴰ ⴰⵔⵔⵉⵏⵜ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ, ⵉⵏⵏⵉ ⵓⵔⵡⴻⵏⵜ ⵉ ⵏⴻⵛⵛ, ⴰⴷ ⵥⵡⴰⵏ ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_38","027_23_38","EZK","23","38","38","ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴳⴳⵉⵏⵜ ⴷⴰⵢⵉ: ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵙⵅⴻⵎⵊⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵙⵙⵄⵉⴵⵜⴻⵏⵜ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_39","027_23_39","EZK","23","39","39","ⵎⵉⵏⵣⵉ ⵓⵎⵉ ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏⵜ ⵉ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵙⵙⵄⵉⴵⵜⴻⵏⵜ. ⵅⵣⴰⵔ, ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK23_40","027_23_40","EZK","23","40","40","ⵄⴰⴷ ⵙⵙⴻⴽⴽⴻⵏⵜ ⵅ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ⵙⵙⴻⴽⴽⴻⵏ ⴰⵔⴻⵇⵇⴰⵙ ⵖⴰⵔⵙⴻⵏ, ⵓ ⵅⵣⴰⵔ, ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ, ⵉⵏⵏⵉ ⵉ ⵅ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ, ⵉ ⵅ ⵜⴽⵓⵍⴰⵔⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⵜⵀⴻⵣⵟⴻⴷ ⵙ ⵜⴻⵍⵡⵉⵣⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_41","027_23_41","EZK","23","41","41","ⵜⴻⵇⵇⵉⵎⴻⴷ ⵅ ⵉⵊⵊ ⵏ ⵍⴻⵛⵜⵓ ⵢⴻⵛⵏⴰ, ⵜⵓⵖⴰ ⵣⵣⴰⵜⴻⵙ ⵟⵟⴰⴱⵍⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵅ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK23_42","027_23_42","EZK","23","42","42","ⵍⴰⵎⵉ ⵉⵙⵙⵓⵙⴻⵎ ⵍⵃⴻⵙⵙ ⵏ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵖⴰⵔⴻⵙ, ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵉⵙⴽⴰⵔⵊⵉⵢⵢⴻⵏ ⵣⵉ ⵍⴻⵅⵍⴰ ⵖⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍⵖⴰⵛⵉ ⵏ ⵉⵡⴷⴰⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⵉⵎⴻⵇⵢⴰⵙⵉⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵜⴰⵊⵊ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_43","027_23_43","EZK","23","43","43","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ⴰⵇⴰ ⴰⵜⴻⵏ ⵣⴻⵏⵏⴰⵏ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷⴷⵓⵢⵙⴰⵔⴻⵏ. ⵍⴻⵅⵅⵓ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK23_44","027_23_44","EZK","23","44","44","ⵏⵉⵜⵏⵉ ⵓⴷⴼⴻⵏ ⵅⴰⵙ ⴰⵎ ⵓⴷⴼⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⴰⵎⵎⵓ ⵓⴷⴼⴻⵏ ⵅ ⵓⵀⵓⵍⴰ ⵓ ⵅ ⵓⵀⵓⵍⵉⴱⴰ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⴹⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK23_45","027_23_45","EZK","23","45","45","ⵉⵔⵢⴰⵣⴻⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⵃⴻⴽⵎⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵃⴻⵇⵇ ⵏ ⵜⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵃⴻⵇⵇ ⵏ ⵜⵉⵏⵏⵉ ⵉⵙⵙⵉⵣⵣⴰⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉⵣⴻⵏⵏⴰⵏ ⵓⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵍⴻⵚⵇⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("EK23_46","027_23_46","EZK","23","46","46","“ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏⵜ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_47","027_23_47","EZK","23","47","47","ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵜⴻⵏⵜ ⵢⴰⵔⵊⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵇⴻⴹⵄⴻⵏ ⵙ ⵍⴻⵙⵢⵓⴼ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏⵜ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏⵜ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK23_48","027_23_48","EZK","23","48","48","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⴻⴼⴹⴰⵢⴻⵃ ⵏⵙⴻⵏⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵄⴻⵍⵎⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏⵜ ⵄⴰⴷ ⴰⵎ ⵍⴻⴼⴹⴰⵢⴻⵃ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK23_49","027_23_49","EZK","23","49","49","ⴰⵎⵎⵓ ⵉ ⵅⴰⴽⴻⵏⵜ ⵖⴰ ⴳⴳⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⴽⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⴱⵓⵏⵜ ⴷⴷⵏⵓⴱ ⵏ ⵡⴻⵄⴱⴻⴷ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏⴽⴻⵏⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵏⵜ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵉⴷⵉ ⴷ ⵙⵉⴷⵉ!’” ");
INSERT INTO rift_vpl VALUES ("EK24_1","027_24_1","EZK","24","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK24_2","027_24_2","EZK","24","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵙⴻⵎ ⵏ ⴰⵙⵙ-ⴰ, ⵉⵙⴻⵎ ⵏ ⴰⵙⵙ ⵏ ⵢⵉⴹⴰ. ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵏⵏⵉⵜ ⴰⴷ ⵉⵃⵚⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK24_3","027_24_3","EZK","24","3","3","ⵙⵉⵡⴻⵍ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵏⵏⵉ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴻⴳⴳ ⵉⵛⵜ ⵏ ⵜⴻⵢⴷⵓⵔⵜ, ⴻⴳⴳ ⵉ-ⵜⵜ ⵓⵛⴰ ⴽⴻⴱⴱ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK24_4","027_24_4","EZK","24","4","4","ⴻⴳⴳ ⴷⴰⵢⴻⵙ ⵜⵉⴼⴻⵜⵜⵓⵜⵉⵏ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵎⴰⵔⵔⴰ ⵜⵉⴼⴻⵜⵜⵓⵜⵉⵏ ⵉⵛⵏⴰⵏ, ⵜⴰⵎⴻⵚⵚⴰⴹⵜ ⴷ ⵜⴻⵖⵔⵓⴹⵜ, ⵄⴻⵎⵎⴰⵔ ⵉ-ⵜⵜ ⵙ ⵢⴻⵖⵙⴰⵏ ⴷ ⵍⴻⵎⵍⵉⵃ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EK24_5","027_24_5","EZK","24","5","5","ⴽⵙⵉ ⵍⴻⵎⵍⵉⵃ ⵏ ⵡⵓⴵⵉ ⵓⵛⴰ ⴰⵔⵔ ⵓⵍⴰ ⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵙⴰⴷⵓ ⵏⵙⴻⵏ. ⴻⵊⵊ ⴰⴷ ⵙⴻⵀⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵍⵉⵃ ⴰⵍⴰⵎⵉ ⵄⴰⴷ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵜⵡⴰⵏⴻⵏⵏⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK24_6","027_24_6","EZK","24","6","6","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵛⵜ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ! ⵜⴰⵢⴷⵓⵔⵜ ⵉ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⵄⴰⴷ ⴷⴰⵢⴻⵙ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵡⴰⵔ ⵢⴻⴽⴽⵉⵙ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ! ⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⵜⴰⴼⴻⵜⵜⵓⵜ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⴼⴻⵜⵜⵓⵜ ⵏⵏⴻⵖⵏⵉ ⴱⵍⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⴳⴳⵉⴷ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("EK24_7","027_24_7","EZK","24","7","7","ⵎⵉⵏⵣⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ, ⵜⴻⵙⵙⵉⵣⴻⵍ ⵉ-ⵜⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ. ⵡⴰⵔ ⵜⴻⵏ ⵜⴻⵙⵙⵉⵣⵣⵉⵍ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⴷⴷⵉⵍ ⵙ ⵓⵛⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK24_8","027_24_8","EZK","24","8","8","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴰⵔ ⵡⴻⵙⵄⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵇⴰⵎ, ⴳⴳⵉⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵜⴻⵙⵙⵉⵣⵣⴻⵍ ⵏⴻⵜⵜⴰⵜ ⵅ ⵜⴻⵚⴹⴰⵔⵜ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷⴰⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("EK24_9","027_24_9","EZK","24","9","9","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵛⵜ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ! ⵏⴻⵛⵛ ⵙ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⴰⴷ ⴳⴳⴻⵖ ⴰⵇⴻⵍⵍⵉⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⵓⵛⴻⵄⵄⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵎⵖⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("EK24_10","027_24_10","EZK","24","10","10","ⴰⵔⵏⵉ ⴰⴽⴻⵛⵛⵓⴹ, ⴻⵊⵊ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ, ⵛⴻⵏⵏⴻⴼ ⴰⵢⵙⵓⵎ ⵎⵍⵉⵃ ⵓⵛⴰ ⴻⵊⵊ ⴰⵅⴻⴵⴻⴹ ⵏ ⵍⴻⴱⵥⴰⵔ ⴰⴷ ⵉⵜⵜⴻⵅⵜⵜⴻⵅ ⵎⵍⵉⵃ ⵓⵛⴰ ⴻⵊⵊ ⵉⵖⵙⴰⵏ ⴰⴷ ⵛⴻⵎⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK24_11","027_24_11","EZK","24","11","11","ⴰⵔⵔ ⵅⴻⵏⵏⵉ ⵜⴰⵢⴷⵓⵔⵜ ⵉⵅⵡⴰⵏ ⵄⴰⵡⴻⴷ ⵅ ⵍⴻⴼⵃⴻⵎ ⵏⵏⴻⵙ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⵎⴰ ⴰⴷ ⵉⵛⵎⴻⴹ ⴷⴷⵔⴰ ⵏⵏⴻⵙ ⵏ ⵏⵏⵃⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⴼⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵅⵎⵓⵊⵉ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⵉ ⵍⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("EK24_12","027_24_12","EZK","24","12","12","ⵎⴰⵔⵔⴰ ⴰⵎⴰⵔⵔⴻⵜ ⴰⵇⴰ-ⵜ ⴷⵉ ⴱⴰⵟⴻⵍ. ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵙ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ ⵣⵣⴰⵢⴻⵙ. ⴰⵔⵔ ⵍⴻⵅⵎⴻⵊ ⵏⵏⵉ ⴷⵉ ⵜⵎⴻⵙⵙⵉ! ");
INSERT INTO rift_vpl VALUES ("EK24_13","027_24_13","EZK","24","13","13","ⴷⵉ ⵜⴻⵅⵎⵓⵊⵉ ⵏⵏⴻⵎ ⵜⴻⴵⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵛⴻⵎ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⵉⴳⴻⴷ. ⵅ ⵓⵢⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⵉⴳⴻⴷ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵏⴻⵎ ⴰⵍ ⵅⴰⵎ ⵉ ⵖⴰ ⵙⵙⵉⵡⴹⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK24_14","027_24_14","EZK","24","14","14","ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⵉⵡⵍⴻⵖ. ⴰⴷ ⵉⴼⴼⴻⵖ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴳⴳⴻⵖ. ⵡⴰⵔ ⵙⴻⵎⵃⴻⵖ ⴷⴻⴳ ⵉⵎⴻⵔⵡⵓⵙⴰ ⵓ ⵡⴰⵔ ⵣⵣⵉⴵⵣⴻⵖ ⵓ ⵡⴰⵔ ⵏⴷⵉⵎⴻⵖ. ⴰⴷ ⵅⴰⵎ ⵃⴻⴽⵎⴻⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵎ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK24_15","027_24_15","EZK","24","15","15","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK24_16","027_24_16","EZK","24","16","16","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵅⵣⴰⵔ, ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵙⵙⴻⵖ ⵎⴻⵥⵔⵉ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ. ⵡⴰⵔ ⵜⵜᵉⵜⵜⵔⵓ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵓⵣⵣⵍⴻⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK24_17","027_24_17","EZK","24","17","17","ⵙⵖⵓⵢⵢ ⴷⴻⴳ ⵓⵀⴻⴷⴷⴻⵏ, ⵡⴰⵔ ⵛⴻⵟⵟⴻⵏ ⵅ ⵓⵎⴻⵜⵜⵉⵏ. ⵇⵇⴻⵏ ⴰⵔⴻⵥⵥⴻⵜ ⵏⵏⴻⵛ ⵅⴰⴽ ⵓⵛⴰ ⴻⴳⴳ ⵜⵉⵙⵉⵍⴰ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵓ ⵡⴰⵔ ⵜⵜⵍⴻⵃⵃⵉⴼ ⴰⵛⵍⴰⵖⴻⵎ ⵖⴰⵔ ⵓⵢⴻⵏⵛⵉⵛ ⵏⵉⵖ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵉⵡⴷⴰⵏ ⵉ ⵡⴻⵛⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK24_18","027_24_18","EZK","24","18","18","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵙⵙⵉⵡⵍⴻⵖ ⵉ ⵍⴳⴻⵏⵙ ⵓ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵜⴻⵎⵎⵓⵜ ⵜⵎⴻⵟⵟⵓⵜ ⵉⵏⵓ ⵓ ⴷⵉ ⵜⵡⴻⵛⵛⴰ ⴳⴳⵉⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵡⴻⵚⵚⴰ. ");
INSERT INTO rift_vpl VALUES ("EK24_19","027_24_19","EZK","24","19","19","ⵉⵏⵏⴰ ⴰⵢⵉ ⵍⴳⴻⵏⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵎⵉⵏ ⵄⵏⴰⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⴻⴳⴳⴻⴷ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("EK24_20","027_24_20","EZK","24","20","20","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: “ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK24_21","027_24_21","EZK","24","21","21","‘ⵉⵏⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵄⵉⴵⵜⴻⵖ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵜⴻⵏⵏⵉ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵊⵊⴻⵀⴷ ⵏⵡⴻⵎ ⴷ ⵓⵎⴻⵥⵔⵉ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴷ ⵍⴻⵀⵣⵓⵟ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ, ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ ⵏⵏⵉ ⵜⴻⵊⵊⵉⵎ ⴷⵉⵏ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EK24_22","027_24_22","EZK","24","22","22","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ ⵏⴻⵛⵛ. ⵡⴰⵔ ⵜᵉⵜⵜⵍⴻⵃⵃⵉⴼⴻⵎ ⴰⵛⵍⴰⵖⴻⵎ ⵖⴰⵔ ⵓⵢⴻⵏⵛⵉⵛ ⵓⵛⴰ ⴰⵖⵔⵓⵎ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ, ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK24_23","027_24_23","EZK","24","23","23","ⴰⵔⴻⵥⵥⴰⵜ ⵏⵡⴻⵎ ⴰⴷ ⵉⵍⵉⵏⵜ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ ⵓ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵡⴻⵎ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵜⵛⴻⵟⵟⵏⴻⵎ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵔⵓⵎ. ⴰⴷ ⵜᵉⵜⴻⵃⵃⴰⵎ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⵡⴻⵃⵡⴻⵃⴻⵎ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK24_24","027_24_24","EZK","24","24","24","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵃⵉⵣⵇⵉⵢⴰⵍ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⴻⵄⵊⴻⴱ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ. ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴷⴷⴻⴳⴳⴰ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵙⵉⴷⵉ, ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK24_25","027_24_25","EZK","24","25","25","“ⵓⵛⴰ ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵇⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⴽⴻⵙⵙⴻⵖ ⵍⴱⵓⵔⵊ ⵏⵙⴻⵏ, ⵍⴻⴼⵔⴰⵃⴻⵜ ⵅ ⵜⴻⵍⵡⵉⵣⵜ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⵎⴻⵥⵔⵉ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵙⴻⵏ ⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("EK24_26","027_24_26","EZK","24","26","26","ⴰⵇⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵍⴻⵏ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EK24_27","027_24_27","EZK","24","27","27","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ, ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⵄⴰⴷ ⴷ ⴰⵢⵏⴰⵡ. ⵛⴻⴽ ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵍⵉⴷ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵍⴻⵄⵊⴻⴱ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK25_1","027_25_1","EZK","25","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK25_2","027_25_2","EZK","25","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵓⵛⴰ ⵏⴰⴱⴱ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK25_3","027_25_3","EZK","25","3","3","ⵉⵏⵉ ⵉ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ: ‘ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ ‘ⵢⴰ, ⴰⵢⵓⵣ!’ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵎⵉ ⵜⵜ ⵙⵙⵄⵉⴵⵜⴻⵏ, ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵎⵉ ⵜⵜ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⵓⵍⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵍⴰⵎⵉ ⵜⴻⵏ ⵉⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("EK25_4","027_25_4","EZK","25","4","4","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵛⴻⵎ ⴰ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏⵙⴻⵏ ⴷⴰⵢⴻⵎ ⵓⵛⴰ ⴰⴷ ⴰⵔⵔⴻⵏ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ ⴷⴰⵢⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵙⵡⴻⵏ ⴰⵛⴻⴼⴼⴰⵢ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK25_5","027_25_5","EZK","25","5","5","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵔⴰⴱⴱⴰ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵉⵍⴻⵖⵎⴰⵏ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵡⴰⵔⴻⵢⵢⴻⵃ ⵉ ⵡⵓⴵⵉ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("EK25_6","027_25_6","EZK","25","6","6","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⵜⴻⵡⵜⵉⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵉⵊⵊ ⴷⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵜⴻⴷⵣⴻⴷ ⵙ ⵓⴹⴰⵔ ⵓ ⵜⴼⴰⵔⵃⴻⴷ ⵙ ⵎⴰⵔⵔⴰ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵏⴻⵛ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EK25_7","027_25_7","EZK","25","7","7","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⴹⵉⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵛⴻⴽ ⵇⴻⴹⵄⴻⵖ ⵣⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵜⴻⵃⵃⵉⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ. ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK25_8","027_25_8","EZK","25","8","8","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⵎⵓ’ⴰⴱ ⴷ ⵙⴰⵄⵉⵔ ⵇⵇⴰⵔⴻⵏ: ⵅⵣⴰⵔ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⴻⴵⴰ ⴰⵎ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ!, ");
INSERT INTO rift_vpl VALUES ("EK25_9","027_25_9","EZK","25","9","9","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵎⵓ’ⴰⴱ, ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ, ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵇⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⴷ ⵜⴰⵍⵡⵉⵣⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ: ⴱⴰⵢⵜ-ⵢⴰⵛⵉⵎⵓⵜ, ⴱⴰⵄⵍ-ⵎⴰⵄⵓⵏ ⴷ ⵇⴰⵔⵢⴰⵜⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK25_10","027_25_10","EZK","25","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏⵜ ⵡⵛⴻⵖ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⴰⵢⵜ ⵏ ⵛⵛⴰⵔⵇ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵍⵉⴷⴰⵔⴻⵜ ⴷⴻⴳ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK25_11","027_25_11","EZK","25","11","11","ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵅ ⵎⵓ’ⴰⴱ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK25_12","027_25_12","EZK","25","12","12","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⵉⴷⵓⵎ ⵉⴳⴳⴰ ⵙ ⵏⵏⴻⵇⵎⴻⵜ ⵡⴰⵀⴰ ⴹⵉⴷⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷⴰⵢⵙⴻⵏ ⵍⵄⵉⴱ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴻⵇⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK25_13","027_25_13","EZK","25","13","13","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵉⴷⵓⵎ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵇⴻⴹⵄⴻⵖ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ ⵓⵛⴰ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⵣⵉ ⵜⴰⵢⵎⴰⵏ, ⵓⵛⴰ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⴰⵍ ⴷⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK25_14","027_25_14","EZK","25","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵏⵏⴻⵇⵎⴻⵜ ⵉⵏⵓ ⵅ ⵉⴷⵓⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⴰⴽ-ⴷ ⵉⴷⵓⵎ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⵄⴰⵔ ⵉⵏⵓ, ⴰⴷ ⵙⵙⵏⴻⵏ ⵏⵏⴻⵇⵎⴻⵜ ⵉⵏⵓ!’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK25_15","027_25_15","EZK","25","15","15","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴳⴳⵉⵏ ⵙ ⵏⵏⴻⵇⵎⴻⵜ ⵓ ⵏⴻⵇⵎⴻⵏ ⵙ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵡⵓⵍ ⵓⵎⵉ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵍⴻⵄⴷⴰⵡⴻⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EK25_16","027_25_16","EZK","25","16","16","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⵉⴽⴰⵔⵉⵜⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK25_17","027_25_17","EZK","25","17","17","ⵏⵏⴻⵇⵎⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵙ ⵍⴻⵄⵇⴰⵢⴻⴱ ⵉⵇⴻⵙⵃⴻⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴳⴳⴻⵖ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵖ ⵏⵏⴻⵇⵎⴻⵜ ⵉⵏⵓ ⴷⴰⵢⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK26_1","027_26_1","EZK","26","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⵄⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK26_2","027_26_2","EZK","26","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵎⵉ ⵜⴻⵏⵏⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⵅ ⵓⵔⵛⴰⵍⵉⵎ: ‘ⵢⴰ ⴰⵢⵓⵣ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵔⴻⵥⵥⴰ, ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵜᵉⵜⵜⵡⴰⵔⵣⴻⵎ ⵖⴰⵔⵉ. ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵡⴰⴳⵍⴰ ⴰⵟⵟⴰⵙ, ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵍⴻⵅⵅⵓ!’, ");
INSERT INTO rift_vpl VALUES ("EK26_3","027_26_3","EZK","26","3","3","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴵⵉⵖ ⴹⵉⴷⴷ ⵏⵏⴻⵛ, ⴰ ⵚⵓⵔ! ⴰⴷ ⵅⴰⵎ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵅ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵍⴻⴱⵃⴰⵔ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK26_4","027_26_4","EZK","26","4","4","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⵀⵢⵓⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⵓⵛⴰ ⴰⴷ ⴰⵔⵥⴻⵏ ⵚⵚⵓⵎⵄⴰⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴽⴽⵙⴻⵖ ⴰⵛⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵖ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK26_5","027_26_5","EZK","26","5","5","ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⴱⴻⵣⵣⵄⴻⵏ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⵉ ⵜⵏⴻⵢⵎⴰⵔⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK26_6","027_26_6","EZK","26","6","6","ⵢⴻⵙⵙⵉⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵅ ⵍⴱⴰⵔⵔ, ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏⵜ ⵙ ⵙⵙⵉⴼ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK26_7","027_26_7","EZK","26","7","7","“ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵅ ⵚⵓⵔ ⴰⴽ-ⴷ ⵉⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ, ⴰⴽ-ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵓ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK26_8","027_26_8","EZK","26","8","8","ⴰⴷ ⵉⵏⴻⵖ ⵙ ⵙⵙⵉⴼ ⵢⴻⵙⵙⵉⵎ ⵏⵏⵉ ⵢⴻⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵍⵇⴰⵎⵎⴰⵜ ⴹⵉⴷⴷ ⵏⵏⴻⵎ, ⴰⴷ ⵉⴱⵏⴰ ⵉⵊⵊ ⵏ ⵡⴻⵛⴱⴰⵔ ⴹⵉⴷⴷ ⵏⵏⴻⵎ ⵓ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⴹⵉⴷⴷ ⵏⵏⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵙⵇⵉⴼⵜ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵜⵜ ⵙ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK26_9","027_26_9","EZK","26","9","9","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵏ ⵡⴻⴷⵀⴰⵎ ⴹⵉⴷⴷ ⵉ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵃⴻⵢⵢⴻⴷ ⵙⵙⵓⵎⵄⴰⵜ ⵏⵏⴻⵎ ⵙ ⵍⴻⵙⵢⵓⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK26_10","027_26_10","EZK","26","10","10","ⴰⴷ ⴰⵎ ⵉⴷⴻⵍ ⵍⴻⵄⵊⴰⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵙ, ⵙ ⵣⵣⵀⵉⵔ ⵏ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵓⵇⴰⵔⵇⴻⴱ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⴷ ⴷⴷⵔⵉⵣ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵅ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵎ ⴰⵎ ⴷⴷ-ⵓⴷⴼⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜᵉⵜⵜⵡⴰⵀⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK26_11","027_26_11","EZK","26","11","11","ⵙ ⵉⵛⵓⵛⵛⴰ ⵏ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵄⴼⴻⵙ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵎ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵉⵏⴻⵖ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ ⵙ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵎ ⵉⵊⴻⵀⴷⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("EK26_12","027_26_12","EZK","26","12","12","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵛⴰⵔⴻⵏ ⴰⴳⵍⴰ ⵏⵏⴻⵎ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵜⴰⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵎ, ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ, ⴰⴷ ⵖⴻⴹⵍⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏⵏⴻⵎ ⵉⵄⵉⵣⵣⴻⵏ. ⵉⵥⵔⴰ ⵏⵏⴻⵎ ⴷ ⵜⵃⴻⵏⵢⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴷ ⵏⵏⴻⵎ ⴷ ⵍⴻⵄⵊⴰⵊ ⵏⵏⴻⵎ ⴰⴷ ⵜⴻⵏ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK26_13","027_26_13","EZK","26","13","13","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⴻⵙⵇⴰⵔⴻⵖ ⴷⴷⵔⵉⵣ ⵏ ⵉⵥⵍⴰⵏ ⵏⵏⴻⵎ ⵓⵛⴰ ⵍⵃⴻⵙⵙ ⵏ ⵍⴳⴰⵎⴱⵔⵉⵢⴰⵜ ⵏⵏⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EK26_14","027_26_14","EZK","26","14","14","ⴰⴷ ⵛⴻⵎ ⴰⵔⵔⴻⵖ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ ⵉ ⵡⴻⴼⵙⴰⵔ ⵏ ⵜⵔⴰⵛⵛⵉⵡⵉⵏ ⵉ ⵜⵏⴻⵢⵎⴰⵔⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ. ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⵉⴷ ⵄⴰⵡⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵏⵏⵉⵖ ⵜ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK26_15","027_26_15","EZK","26","15","15","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵉ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⵚⵓⵔ: ‘ⵎⴰ ⵡⴰⵔ ⵜⵜⴰⵔⵊⵉⵊⵉⵏⵜ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵎ, ⵅⵎⵉ ⵙⵙⴱⵓⵄⵔⵓⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵢⴻⵣⵣⵎⴻⵏ ⵉ ⵍⵎⴻⵡⵜ, ⵅⵎⵉ ⵖⴰ ⵜⴻⵎⵙⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵉⵏⴻⵇⵇⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("EK26_16","027_26_16","EZK","26","16","16","ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⴷⴷ-ⵀⵡⴰⵏ ⵣⵉ ⵍⴻⴽⵔⴰⵙⵉ ⵏⵙⴻⵏ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⴻⴹⵍⴻⵏ ⵉⵃⴰⵛⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⴽⴽⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵉⴱⵓⵔⴹⴰⵔⴻⵏ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ. ⴰⴷ ⵍⴻⵃⵃⴼⴻⵏ ⵙ ⵍⵄⵓⵔⵔⴻⵜ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⴷⵉ ⴽⵓⵍ ⵍⵡⴻⵇⵜ ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⵏⵅⴻⵍⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK26_17","027_26_17","EZK","26","17","17","ⴰⴷ ⵅⴰⵎ ⵙⵙⵉⵍⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ, ⴰⴷ ⴰⵎ ⵉⵏⵉⵏ: ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵜⴻⵃⵃⵉⴷ, ⴰ ⵛⴻⵎ, ⵜⴻⵏⵏⵉ ⵉ ⴷⵉ ⵣⴻⴷⵖⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵍⴻⴱⵃⴰⵔ, ⴰ ⵛⴻⵎ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵛⴻⵎ, ⴰ ⵚⵓⵔ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵔⵊⴻⴼ ⵊⴰⵔ ⴰⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⵖⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("EK26_18","027_26_18","EZK","26","18","18","ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏⵜ ⵜⴻⴳⵣⵉⵔⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵎ, ⵡⴰⵀ ⵜⵉⴳⵣⵉⵔⵉⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⵏⵏⵅⴻⵍⵄⴻⵏⵜ ⵙ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("EK26_19","027_26_19","EZK","26","19","19","“ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵎⵉ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⵢⴰⵔⵔⴻⵖ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏ ⴰⵎ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴷⵉⵖⴻⵏ, ⵅⵎⵉ ⵅⴰⵎ ⵉ ⵖⴰ ⵙⵙⵉⵡⴹⴻⵖ ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵓⵛⴰ ⵅⵎⵉ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⴰⴷ ⵛⴻⵎ ⴷⵍⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK26_20","027_26_20","EZK","26","20","20","ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⵎ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ, ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏ ⵍⵡⴻⵇⵜ ⵏ ⵣⵉⵛ. ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⵙⴻⵖ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⵏ ⵣⵉⵛ, ⵖⴰⵔ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵎ ⵜⵜⵉⵍⵉⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵄⴰⴷ. ⵎⴰⵛⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵡⵛⴻⵖ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("EK26_21","027_26_21","EZK","26","21","21","ⴰⴷ ⵛⴻⵎ ⴰⵔⵔⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵡⴰⵔⵊⴻⴼ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⵄⴰⴷ. ⴰⴷ ⵅⴰⵎ ⴰⵔⵣⵓⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⴼⵉⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵉ ⵍⴻⴱⴷⴰ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK27_1","027_27_1","EZK","27","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK27_2","027_27_2","EZK","27","2","2","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵉ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵅ ⵚⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EK27_3","027_27_3","EZK","27","3","3","ⵉⵏⵉ ⵉ ⵚⵓⵔ, ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⴰⵟⵟⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴰ ⵚⵓⵔ, ⵛⴻⵎ ⵜⴻⵇⵇⴰⵔⴻⴷ: ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵡⴰⵥⵔⵉ!’ ");
INSERT INTO rift_vpl VALUES ("EK27_4","027_27_4","EZK","27","4","4","ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵓⵢⴻⵍⵣⵉⵎ ⵏⵏⴻⵎ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ, ⵉⵏⵏⵉ ⵛⴻⵎ ⵉⴱⵏⴰⵏ ⴰⵇⴰ ⴳⴳⵉⵏ ⴰⵥⵔⵉ ⵏⵏⴻⵎ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK27_5","027_27_5","EZK","27","5","5","ⵎⴰⵔⵔⴰ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵏ ⵏ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⴻⵎ ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⵉ ⵛⴻⵎ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵣⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵔⵣⵉ, ⵉⵡⵢⴻⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵣⵉ ⵍⵓⴱⵏⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵎ ⴳⴳⴻⵏ ⵜⵉⵃⴻⵏⵢⴰ ⵉ ⵍⴱⴰⵛⵛⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK27_6","027_27_6","EZK","27","6","6","ⵣⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⴱⴻⴵⵓⴹ ⵏ ⴱⴰⵛⴰⵏ ⴳⴳⵉⵏ ⵍⴻⵎⵇⴰⴷⴻⴼ ⵏⵏⴻⵎ, ⵍⴱⴰⵏⴽⵓⵡⴰⵜ ⵏⵏⴻⵎ ⵉ ⵉⵇⴻⴷⴷⴰⴼⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵣⵉ ⵍⵄⴰⵊ ⵉⵜⵜⵡⴰⴳⴳ ⴷⴻⴳ ⵓⴽⴻⵛⵛⵓⴷ ⵏ ⵜⴻⵏⴳⴻⵍⵜ, ⵉⵡⵢⴻⵏ ⵜ ⵣⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⴰⵢⵜ ⵏ ⴽⵉⵜⵜⵉⵎ.    ");
INSERT INTO rift_vpl VALUES ("EK27_7","027_27_7","EZK","27","7","7","ⵍⴱⴰⵛⵛ ⵏⵏⴻⵎ ⵜⵓⵖⴰ-ⵜ ⵙ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵅⴻⵢⵢⴹⴻⵏ ⵜ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵉⵏⵜⴰⵜ. ⵍⴱⴰⵛⵛ ⵜⵓⵖⴰ ⵉ ⵛⴻⵎ ⴷ ⵜⴰⵄⴻⴵⴰⵏⵜ, ⵜⴰⵙⵇⵉⴼⵜ ⵏ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵎ ⵜⵓⵖⴰ-ⵜⵜ ⵣⴻⴳ ⵓⴼⵉⵍⵓ ⵓⴷⴻⵀⵎⴰⵏⵉ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉ ⵣⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵏ ⵉⵍⵉⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EK27_8","027_27_8","EZK","27","8","8","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵚⵉⴷⵓⵏ ⵓ ⵏ ⴰⵔⵡⴰⴷ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵇⴻⴷⴷⴰⴼⴻⵏ ⵏⵏⴻⵎ. ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵎ, ⴰ ⵚⵓⵔ, ⵏⵏⵉ ⴷⴰⵢⴻⵎ ⵉⴵⴰⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵏⴻⴷⴷⴰⵀⴻⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_9","027_27_9","EZK","27","9","9","ⵉⵡⴻⵙⵙⵓⵔⴰ ⵏ ⵊⵓⴱⴰⵢⵍ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴰⵢⴻⵎ, ⵄⴻⴷⴷⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵣⵣⴰ ⵏⵏⴻⵎ. ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵎ ⵙⴻⴱⴱⴻⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK27_10","027_27_10","EZK","27","10","10","ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵚ, ⵏ ⵍⵓⴷ ⵓ ⵏ ⴼⵓⵟ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵎ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ. ⵓⵢⵍⴻⵏ ⴷⴰⵢⴻⵎ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⴽⴰⵙⴽ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵎ ⵍⵄⴻⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("EK27_11","027_27_11","EZK","27","11","11","ⴰⵢⵜ ⵏ ⴰⵔⵡⴰⴷ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵎ ⵓⵛⴰ ⵉⴳⴰⵎⵎⴰⴷⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵔⵢⴰⵙⵜ ⵏⵏⴻⵎ, ⴱⴻⴷⴷⴻⵏ ⵅ ⵙⵙⵓⵎⵄⴰⵜ ⵏⵏⴻⵎ. ⵜⵉⵙⴻⴷⴷⴰⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵏ ⵓⵙⴻⵍⵇⵉ ⵉ ⵜⵓⵖⴰ ⵓⵢⵍⴻⵏⵜ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵅ ⵍⴻⵃⵢⵓⴹ, ⴰⵔⵏⵉⵏⵜ ⴷⴻⴳ ⵡⴰⵥⵔⵉ ⵏⵏⴻⵎ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK27_12","027_27_12","EZK","27","12","12","ⵜⴰⵔⵛⵉⵙ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵙⴻⴱⴱⴰⴱ ⴰⴽⵉⴷⴻⵎ ⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⴳⴻⵍⵡⴰⵏ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵎ ⵏⵏⵓⵇⴰⵔⵜ, ⵓⵣⵣⴰⵍ, ⴰⵙⵜⴰⵏⵢⵓ ⴷ ⵍⴻⵅⴼⵉⴼ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK27_13","027_27_13","EZK","27","13","13","ⵢⴰⵡⴰⵏ ⴷ ⵜⵓⴱⴰⵍ ⴷ ⵎⴰⵛⵉⵅ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⴻⵎ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵎ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵏⵏⵃⴰⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_14","027_27_14","EZK","27","14","14","ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⵓⵊⴰⵔⵎⴰ ⵡⵛⵉⵏ ⴰⵎ ⵢⵉⵢⵙⴰⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵉⵙⴻⵔⴷⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK27_15","027_27_15","EZK","27","15","15","ⴰⵔⵔⴰⵡ ⵏ ⴷⴰⴷⴰⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵎ. ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵜⵓⵖⴰ ⵅⵙⴻⵏⵜ ⴰⴷ ⵟⵟⴼⴻⵏⵜ ⵙⵙⴻⵍⵄⴻⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ. ⵜⵉⵖⵎⴰⵙ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏ ⵍⴼⵉⵍ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵏ ⵡⴻⴱⵏⵓⵙ ⴰⵔⵔⵉⵏⵜ ⴰⵎ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ ⴷ ⴰⵔⵔⵉⵖⴰⵍⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK27_16","027_27_16","EZK","27","16","16","ⴰⵔⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⴱⴱⴰⴱ ⴰⴽⵉⴷⴻⵎ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⵚⴻⵏⵏⵄⴻⴷ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵎ ⴽⴰⵔⴱⵓⵏⴽⴻⵍ ⴷ ⴰⵊⵓⵔⵡⴰⵏⵉ ⴷ ⵍⴱⵓⵔⴹⴰ ⵙ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴷ ⵍⵎⴰⵔⵊⴰⵏ ⴷ ⵍⴻⵄⵇⴰⵇ ⵉⵣⴻⴳⴳⵡⴰⵖⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵜⵇⴻⴷⴷⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK27_17","027_27_17","EZK","27","17","17","ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽⵉⴷⴻⵎ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⴰⵎ ⵢⵉⵎⴻⵏⴷⵉ ⵣⵉ ⵎⵉⵏⵏⵉⵜ ⵓⵍⴰ ⴷ ⵃⴰⵍⴰⵡⵉⵜ, ⵜⴰⵎⵎⴻⵏⵜ, ⵣⵣⴻⵛⵜ ⴷ ⴱⴰⵍⵙⴰⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_18","027_27_18","EZK","27","18","18","ⴷⵉⵎⴰⵛⵇ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⴱⴱⴰⴱ ⴰⴽⵉⴷⴻⵎ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵇⵛⵓⵄ ⵉ ⵜⵚⴻⵏⵏⵄⴻⴷ, ⵅ ⵎⴰⵔⵔⴰ ⵉⴳⴻⵍⵡⴰⵏ ⵏⵏⴻⵎ, ⵙ ⴱⵉⵏⵓ ⵏ ⵅⵉⵍⴱⵓⵏ ⴷ ⵜⴹⵓⴼⵜ ⵜⴰⵛⴻⵎⵍⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("EK27_19","027_27_19","EZK","27","19","19","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ, ⵡⵛⵉⵏ ⴰⵎ ⵡⴰⴷⴰⵏ ⴷ ⵢⴰⵡⴰⵏ ⵓⵣⵣⴰⵍ ⵏ ⵡⴻⵎⵣⵉⵍ ⴷ ⵇⴰⵙⵙⵉⵢⴰ ⴷ ⵓⵖⴰⵏⵉⵎ ⴰⵃⴻⵎⵎⵓⵎ ⵉⵜⵜⴼⵓⵃⴻⵏ ⵣⵉ ⵓⵣⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK27_20","027_27_20","EZK","27","20","20","ⴷⴰⴷⴰⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⴱⴱⴰⴱ ⴰⴽⵉⴷⴻⵎ ⵙ ⵡⴻⵔⵔⵓⴹ ⵏ ⵜⴱⴰⵔⴷⵉⵡⵉⵏ ⵉ ⵓⵏⴻⴷⴷⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("EK27_21","027_27_21","EZK","27","21","21","ⵉⵄⵔⴰⴱⴻⵏ ⴷⵉ ⵍⵡⴰⵟⴰⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵇⵉⴷⴰⵔ ⵜⵓⵖⴰ ⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽⵉⴷⴻⵎ. ⴷⴻⴳ ⵉⵣⴻⵎⵔⴰⵡⴻⵏ ⴷ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽⵉⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_22","027_27_22","EZK","27","22","22","ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵛⴰⴱⴰ ⴷ ⵢⵉⵏⵏⵉ ⵏ ⵔⴰⵄⵎⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⴻⵎ. ⵏⵉⵜⵏⵉ ⵡⵛⵉⵏ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵍⴻⵄⵟⵓⵔ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⴷ ⵡⵓⵔⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵙⵙⴻⵍⵄⴰⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵜⵇⴻⴷⴷⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK27_23","027_27_23","EZK","27","23","23","ⵃⴰⵔⴰⵏ ⴷ ⴽⵉⵏⵏⴰ ⴷ ⵄⴰⴷⴰⵏ, ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵛⴰⴱⴰ, ⴰⵛⵛⵓⵔ ⴷ ⴽⵉⵍⵎⴰⴷ, ⵜⵓⵖⴰ ⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽⵉⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_24","027_27_24","EZK","27","24","24","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽⵉⴷⴻⵎ ⴷⴻⴳ ⵍⴻⵄⴱⴰⵢⴰⵜ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴷ ⵉⵙⴻⵍⵀⴰⵎⴻⵏ ⵉⴷⴻⵃⵎⵉⵢⵢⴻⵏ ⴷ ⵍⴱⵓⵔⴹⴰⵜ ⵜⵉⵇⴰⵔⵇⴰⵛⵉⵏ ⵓ ⴷⵉ ⵍⴽⴻⵜⵜⴰⵏ ⵉⵖⵍⴰⵏ ⵙ ⵉⴼⵉⵍⴰⵏ ⵏ ⵜⵉⵏⵜⴰⵜ ⵉⴼⴰⵔⵣⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵎ ⵙ ⵜⴻⵙⵖⵓⵏⵉⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵉⵜⵜⵡⴰⵎⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK27_25","027_27_25","EZK","27","25","25","ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⵜⴰⵔⵛⵉⵛ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⴽⴰⵔⴰ$ⴰⵏⴻⵏ ⵏⵏⴻⵎ ⴷ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵎ. ⵜⵓⵖⴰ ⵛⴻⵎ ⴷⵉⵏⵏⵉ, ⵜⴻⵛⵛⵓⵔⴻⴷ ⵓ ⵜⴷⴻⵇⵍⴻⴷ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EK27_26","027_27_26","EZK","27","26","26","ⵉⵇⴻⴷⴷⴰⴼⴻⵏ ⵏⵏⴻⵎ ⵉⵡⵢⴻⵏ ⵛⴻⵎ ⵖⴰⵔ ⵡⴰⵎⴰⵏ ⵢⵓⵄⵍⴰⵏ, ⴰⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵛⵛⴰⵔⵇ ⵢⴰⵔⵥⴰ ⵛⴻⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EK27_27","027_27_27","EZK","27","27","27","ⵉⴳⴻⵍⵡⴰⵏ ⵏⵏⴻⵎ ⴷ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⵉ ⵜⴻⵣⵣⴻⵏⵣⴻⴷ ⴷ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵎ, ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵎ ⴷ ⵉⵏⴻⴷⴷⴰⵀⴻⵏ ⵏⵏⴻⵎ ⴷ ⵢⵉⵏⵏⵉ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵜⵉⵔⴻⵥⵥⴰ ⵏⵏⴻⵎ, ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴰⴽⵉⴷⴻⵎ, ⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵎ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ, ⴰⴷ ⵡⴹⴰⵏ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_28","027_27_28","EZK","27","28","28","ⵣⵉ ⵍⵃⴻⵙⵙ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵉⵏⴻⴷⴷⴰⵀⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK27_29","027_27_29","EZK","27","29","29","ⴰⴷ ⵀⵡⴰⵏ ⵣⵉ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵜⵉⵎⴻⵇⴷⴰⴼⵉⵏ, ⵎⴰⵔⵔⴰ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⴻⴷⴷⴰⵀⴻⵏ ⵏⵏⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("EK27_30","027_27_30","EZK","27","30","30","ⵓⵛⴰ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴰⵔⵣⴰⴳⴻⵏ, ⴰⴷ ⵏⴹⴰⵔⴻⵏ ⴰⵛⴰⵍ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵣⵓⵣⵣⴰⵔⴻⵏ ⵉⵖⵖⴻⴹ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK27_31","027_27_31","EZK","27","31","31","ⵓⵛⴰ ⴰⴷ ⵃⴻⴼⴼⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⴻⵢⵙⴻⵏ ⵙ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⵔⵓⵏ ⵙ ⵍⴻⵄⵎⴰⵔ ⵉⵛⵛⵓⵔ ⵙ ⵜⴰⵔⵣⵓⴳⵉ ⵓ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴰⵎⴻⵔⵣⴰⴳⵜ. ");
INSERT INTO rift_vpl VALUES ("EK27_32","027_27_32","EZK","27","32","32","ⴰⵎ ⵜⵜⵡⴻⵃⵡⵉⵃⴻⵏ ⴰⴷ ⵅⴰⵎ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵓⵛⴰ ⴰⴷ ⵅⴰⵎ ⵡⵜⴻⵏ ⴰⴳⴻⵊⴷⵓⵔ, ⴰⴷ ⵉⵏⵉⵏ: ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴰⵎ ⵚⵓⵔ, ⴰⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("EK27_33","027_27_33","EZK","27","33","33","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵎ ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⵓⵔ, ⵜⵓⵖⴰ ⵜⴻⵙⵙⵊⵉⵡⵏⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴳⴻⵍⵡⴰⵏ ⵏⵏⴻⵎ ⴷ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵎ ⵜⴰⵔⵔⵉⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⵜⵡⴰⵊⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK27_34","027_27_34","EZK","27","34","34","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵔⵥⴻⴷ ⵙ ⵍⴻⴱⵃⵓⵔ, ⴷⵉ ⵍⵎⴻⵀⵎⵓⴷ ⵏ ⵡⴰⵎⴰⵏ, ⵜⵓⵖⴰ ⵜⴻⵡⴹⴰ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵓ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵉ ⵖⴰⵔⴻⵎ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK27_35","027_27_35","EZK","27","35","35","ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵜⵜⴱⴻⵀⵜⴻⵏ ⵓ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⴼⴻⵏ, ⵜⵜⵏⴻⵅⵍⴰⵄⴻⵏ ⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK27_36","027_27_36","EZK","27","36","36","ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵅⴰⵎ ⵚⴻⴼⴼⴰⵔⴻⵏ, ⴰⵇⴰ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵉ ⵡⴰⵔⵊⴻⴼ, ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⵄⴰⴷ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK28_1","027_28_1","EZK","28","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK28_2","027_28_2","EZK","28","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵉ ⵉ ⵍⵃⴰⴽⴻⵎ ⵏ ⵚⵓⵔ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵓⵍ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉⴷ: ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵛⵛ ⵜⵜⵖⵉⵎⵉⵖ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴱⵃⵓⵔ!, ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⴷ ⴱⵏⴰⴷⴻⵎ, ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵓⵍ ⵏⵏⴻⵛ ⵅⴻⵏⵏⵉ ⴰⵎ ⵡⵓⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EK28_3","027_28_3","EZK","28","3","3","ⵅⵣⴰⵔ, ⵛⴻⴽ ⴷ ⴰⵎⵉⵖⵉⵙ ⵅ ⴷⴰⵏⵉⵢⵉⵍ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵙⵙⵉⵔⵔ ⵅⴰⴽ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK28_4","027_28_4","EZK","28","4","4","ⵙ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏⵏⴻⵛ ⴰⵇⴰ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⴳⴻⵍⵡⴰⵏ ⵎⵖⴰⵔⴻⵏ ⵓ ⵜⴻⴳⴳⵉⴷ ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵛ ⵏ ⵜⵅⵓⴱⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("EK28_5","027_28_5","EZK","28","5","5","ⵙ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ ⵉⵎⵖⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵛ, ⵜⴰⵔⵏⵉⴷ ⴷⴻⴳ ⵉⴳⴻⵍⵡⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴳⴻⵍⵡⴰⵏ ⵏⵏⴻⵛ ⵎⵖⴰⵔⴻⵏ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵡⵓⵍ ⵏⵏⴻⵛ ⵉⵅⴻⴼ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("EK28_6","027_28_6","EZK","28","6","6","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵓⵍ ⵏⵏⴻⵛ ⴰⵎ ⵡⵓⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("EK28_7","027_28_7","EZK","28","7","7","ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵍⴻⴳⵏⵓⵙ ⵉⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⵊⴻⴱⴷⴻⵏ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵡⴻⵥⵔⵉ ⵏ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK28_8","027_28_8","EZK","28","8","8","ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵀⵡⴰⵏ ⵖⴰⵔ ⵡⴻⵃⴼⵓⵔ ⵏ ⵜⵓⵔⵚⵓⴹⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵍⵎⴻⵡⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("EK28_9","027_28_9","EZK","28","9","9","ⵎⴰ ⵜⵣⴻⵄⵎⴻⴷ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⵉⵏⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵏⵖⴻⵏ: ‘ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ’? ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴱⵏⴰⴷⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⴷⴻⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK28_10","027_28_10","EZK","28","10","10","ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵜ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK28_11","027_28_11","EZK","28","11","11","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK28_12","027_28_12","EZK","28","12","12","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⵚⵓⵔ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴰ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⴷ ⵍⵅⴰⵜⴻⵎ ⵏ ⵍⴻⴱⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ, ⵜⴻⵛⵛⵓⵔⴻⴷ ⵙ ⵜⵉⵖⵉⵜ ⵓ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴷⴻⴳ ⵡⴻⵥⵔⵉ! ");
INSERT INTO rift_vpl VALUES ("EK28_13","027_28_13","EZK","28","13","13","ⵜⵓⵖⴰ ⵛⴻⴽ ⴷⵉ ⵄⴰⴷⵏ, ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⵓⵖⴰ ⴷⵍⵉⵏ ⵛⴻⴽ ⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ, ⵙ ⵍⴻⵄⵇⴰⵇ, ⵜⵢⴰⵇⵓⵜ ⴷ ⴷⵢⴰⵎⴰⵏⵜⵉ, ⵙ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ, ⵓⵏⵉⴽⵙ ⴷ ⵢⴰⵙⴱⵉⵙ, ⵙ ⵚⴰⴼⴼⵉⵔ ⴰⵣⵉⵣⴰ, ⴽⴰⵔⴱⵓⵏⴽⴻⵍ, ⵙⵎⴰⵔⴰⵅⵜ ⴷ ⵡⵓⵔⴻⵖ. ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴱⴻⵏⴷⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵓⴱⴰⵔⵔⵓ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⵜⵓⵖⴰ ⴷⴰⵢⴻⴽ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⴷ ⵜⵓⵖⴰ ⵡⴻⵊⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK28_14","027_28_14","EZK","28","14","14","ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⴷ ⴰⵎⴻⴷⵀⵓⵏ ⵉⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ, ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷⵉⵏ. ⵜⵓⵖⴰ ⵛⴻⴽ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⴳⴳⵓⵔⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵥⵔⴰ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK28_15","027_28_15","EZK","28","15","15","ⵜⵓⵖⴰ ⵛⴻⴽ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⴷ, ⴰⵍ ⴷⴰⵢⴻⴽ ⵜᵉⵜⵜⵡⴰⴼ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EK28_16","027_28_16","EZK","28","16","16","ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵛ, ⵉⵛⵛⵓⵔ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵛ ⵙ ⵍⴻⵅⵛⵓⵏⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵅⴹⵉⴹ. ⵙ ⵓⵢⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵖ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵛⴻⴽ ⵎⵃⵉⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵥⵔⴰ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⴰ ⵛⴻⴽ ⴰⴽⵉⵔⵓⴱ ⵉⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EK28_17","027_28_17","EZK","28","17","17","ⵓⵍ ⵏⵏⴻⵛ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵥⵔⵉ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⴻⵙⵙⵄⵉⴵⵜⴻⴷ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵛ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵛ ⵉⵄⴻⴼⴼⴰⵔⴻⵏ. ⵏⴻⵛⵛ ⵏⴹⴰⵔⴻⵖ ⵛⴻⴽ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⴳⴳⵉⵖ ⵛⴻⴽ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⴻⴽ ⵅⵣⴰⵔⴻⵏ ⵙ ⵍⵃⴻⴳⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK28_18","027_28_18","EZK","28","18","18","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ ⴷ ⵍⵖⴻⵛⵛ ⵏ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⵖⴻⵙⴱⴻⴷ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⵔⵉⵖ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵛⵛⴻⵏ, ⵓⵛⴰ ⴰⵔⵔⵉⵖ ⵛⴻⴽ ⴷ ⵉⵖⵖⴻⴹ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵜⵜⵡⴰⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK28_19","027_28_19","EZK","28","19","19","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵙⵙⵏⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰⵔⴻⵊⴼⴻⵏ ⵣⵣⴰⵢⴻⴽ. ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵡⴰⵔⵊⴻⴼ ⵓ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⴷ ⵄⴰⴷ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK28_20","027_28_20","EZK","28","20","20","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK28_21","027_28_21","EZK","28","21","21","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵚⵉⴷⵓⵏ ⵓⵛⴰ ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK28_22","027_28_22","EZK","28","22","22","ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴹⵉⴷⴷ ⵏⵏⴻⵎ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵚⵉⴷⵓⵏ! ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵛ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵅⵎⵉ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⴷⵉ ⵚⵉⴷⵓⵏ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK28_23","027_28_23","EZK","28","23","23","ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵟⵟⴰⵄⵓⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵙ ⵙⵙⵉⴼ ⵏⵏⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵣⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EK28_24","027_28_24","EZK","28","24","24","ⵓⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵙⴻⵏⵏⴰⵏ ⵉⵇⴻⴱⵛⴻⵏ ⵏⵉⵖ ⵜⴰⵣⴻⴳⴳⵯⴰⵔⵜ ⵉⵜⵜⴻⵇⵇⵙⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴷ ⵙⵉⴷⵉ ⵉ ⴵⵉⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK28_25","027_28_25","EZK","28","25","25","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵎⵉ ⵖⴰ ⵙⵙⵎⵓⵏⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵎⴰⵏⵉ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵏⴻⵛⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ ⴷⴰⵢⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("EK28_26","027_28_26","EZK","28","26","26","ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⴱⵏⴰⵏ ⵜⵓⴷⵔⵉⵏ, ⴰⴷ ⴳⴳⴻⵏ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⵓ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵥⵥⵓⵏ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ, ⵡⴰⵀ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⵉⵏ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴳⴳⵉⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⴽⴻⵛⵛⴹⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK29_1","027_29_1","EZK","29","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵓⵢⵓⵔ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK29_2","027_29_2","EZK","29","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵏⴰⴱⴱ ⵅⴰⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK29_3","027_29_3","EZK","29","3","3","ⵙⵉⵡⴻⵍ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴹⵉⴷⴷ ⵏⵏⴻⵛ, ⴰ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵛⴻⴽ ⴷ ⵍⵀⴰⵢⵛⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⵉ ⵉⵣⵣⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ⵉⵖⵣⴰⵔ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("EK29_4","027_29_4","EZK","29","4","4","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⴷⴻⴳ ⵓⵖⴻⵙⵎⴰⵔ ⵏⵏⴻⵛ, ⴰⴷ ⵙⵙⵍⴻⵙⵇⴻⵖ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⴻⵇⵛⵓⵔⵉⵏ ⵏⵏⴻⵛ. ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⵊⴻⴱⴷⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵍⴻⵙⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵇⵛⵓⵔⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK29_5","027_29_5","EZK","29","5","5","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵏⴹⴰⵔⴻⵖ ⴱⴰⵔⵔⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵛ. ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵜⴻⵡⴹⵉⴷ. ⵡⴰⵔ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵏⵉⵖ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵡⵛⴻⵖ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EK29_6","027_29_6","EZK","29","6","6","ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⴰⵣⴻⴵⴰⴹ ⵏ ⵓⵖⴰⵏⵉⵎ ⵉ ⵅ ⵜⵓⵖⴰ ⵜⵙⴻⵏⵏⴻⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK29_7","027_29_7","EZK","29","7","7","ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵛⴻⴽ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵜⴼⴻⴵⵇⴻⴷ ⵓⵛⴰ ⵜⴻⵙⵙⵏⵓⵇⵇⴱⴻⴷ ⵖⴰⵔⵙⴻⵏ ⵜⴰⵖⵔⵓⴹⵜ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ, ⵓ ⵎⴰⵍⴰ ⵅⴰⴽ ⵙⵙⴻⵏⴷⴻⵏ, ⵜⴰⵔⵥⵉⴷ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⵊⵉⵊⴻⴷ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK29_8","027_29_8","EZK","29","8","8","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⵙⵙⴻⵄⴷⵓⵖ ⵙⵙⵉⴼ ⵓⵛⴰ ⴰⴷ ⵇⴻⵙⵙⴻⵖ ⵣⵣⴰⵢⴻⴽ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK29_9","027_29_9","EZK","29","9","9","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵉ ⵓⵔⴻⴷⴷⴻⴵ ⵓ ⵉ ⵍⵅⵉⵔⴱⴻⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵉⵖⵣⴰⵔ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜ!’” ");
INSERT INTO rift_vpl VALUES ("EK29_10","027_29_10","EZK","29","10","10","“ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵅⴰⴽ ⵓ ⵅ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵍⴻⵅⵔⴰⴱⵉ, ⵡⴰⵀ, ⴷ ⵉⵛⵜ ⵏ ⵍⵅⵉⵔⴱⴻⵜ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵣⵉ ⵎⴰⵊⴷⴰⵍ ⴰⵍ ⴰⵙⵡⴰⵏ, ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ. ");
INSERT INTO rift_vpl VALUES ("EK29_11","027_29_11","EZK","29","11","11","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵥⴻⴽⴽⵡⵉ ⵅ ⵓⴹⴰⵔ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴹⴰⵔ ⵏ ⵍⵎⴰⵍ ⴰⴷ ⵅⴰⵙ ⵉⵥⵡⴰ. ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵜⵜⵉⵍⵉⵏ ⵉⵎⴻⵣⴹⴰⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵔ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EK29_12","027_29_12","EZK","29","12","12","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵍⴰ ⴷ ⴰⵔⴻⴷⴷⴻⴵ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏⵜ ⵓⵛⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⴰⵔⴻⴷⴷⴻⴵ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⵍⵅⵉⵔⴱⴰⵜ, ⵍⵎⵉⵊⴰⵔ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵓⵢⵙⴻⵖ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴱⴻⵣⵣⵄⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK29_13","027_29_13","EZK","29","13","13","“ⵎⴰⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⵄⴷⵓⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK29_14","027_29_14","EZK","29","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴱⴻⴷⴷⵍⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵄⴻⵇⴱⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴼⴰⵜⵔⵓⵙ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ, ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵜⴰⵎⴻⵄⵏⴰⵏⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EK29_15","027_29_15","EZK","29","15","15","ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⴻⵄⵏⴰⵏⵓⵛⵜ ⵣⵉ ⵜⴳⴻⵍⴷⴰⵜⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵄⴰⴷ ⵅ ⵍⴻⴳⵏⵓⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⴻⵥⵢⴻⵖ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⵚⴻⵍⵍⵟⴻⵏ ⵄⴰⴷ ⵅ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK29_16","027_29_16","EZK","29","16","16","ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⴰⵜⴻⵛⵍⵉ ⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵙⵙⵉⴷⴰⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔⵙⴻⵏ, ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴷ ⵙⵉⴷⵉ ⵉ ⴵⵉⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK29_17","027_29_17","EZK","29","17","17","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK29_18","027_29_18","EZK","29","18","18","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵢⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵢⴻⴳⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴹⵉⴷⴷ ⵉ ⵚⵓⵔ. ⵎⴰⵔⵔⴰ ⴰⵣⴻⴵⵉⴼ ⵉⵇⵇⵉⵎ ⴷ ⴰⵇⴻⵛⵛⴰⵔ ⵓ ⵎⴰⵔⵔⴰ ⵜⴰⵖⵍⵓⴹⵜ ⵜⴰⵔⴽⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵍⴻⵅⵍⴰⵚ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ, ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵢⴻⴳⴳⴰ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK29_19","027_29_19","EZK","29","19","19","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵉ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵢⴰⵡⵉ ⴰⴼⴻⵢⵢⴻⴹ ⵏ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵜⵓⴽⴽⴰⵔⴹⴰ. ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵅⵍⴰⵚ ⵏⵏⴻⵙ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK29_20","027_29_20","EZK","29","20","20","ⵅ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⵉ ⵢⴻⴳⴳⴰ ⴹⵉⴷⴷ ⵚⵓⵔ ⵡⵛⵉⵖ ⴰⵙ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⵍⴻⵅⵍⴰⵚ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK29_21","027_29_21","EZK","29","21","21","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⵛⵛ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK30_1","027_30_1","EZK","30","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK30_2","027_30_2","EZK","30","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵔⵓⵎ! ⴰⵢⵢⴻⵀⵀⴰⵜ ⵅ ⵡⴰⵙⵙ ⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("EK30_3","027_30_3","EZK","30","3","3","ⵎⵉⵏⵣⵉ ⵢⵓⴷⴻⵙ ⵉ ⵢⴻⴵⴰ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵢⵓⴷⴻⵙ ⵉ ⵢⴻⴵⴰ ⵡⴰⵙⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵙⵙ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK30_4","027_30_4","EZK","30","4","4","ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙⵙⵉⴼ ⴷⵉ ⵎⵉⵚⵔⴰ. ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵔⵊⴻⴼ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ, ⵅⵎⵉ ⵖⴰ ⵡⴹⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⴰⴼⴻⵢⵢⴻⴹ ⵏ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK30_5","027_30_5","EZK","30","5","5","ⴽⵓⵛ ⴷ ⴼⵓⵟ ⴷ ⵍⵓⴷ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⴷ ⴽⵓⴱ ⴷ ⴰⵢⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵄⴰⵀⴷ ⴰⴷ ⴽⵉⵙⴻⵏ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ.’” ");
INSERT INTO rift_vpl VALUES ("EK30_6","027_30_6","EZK","30","6","6","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵉⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵎⵉⵚⵔⴰ ⴰⴷ ⵡⴹⴰⵏ ⵓ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⵖⴰⵔⵇ. ⵣⵉ ⵎⴰⵊⴷⴰⵍ ⴰⵍ ⴰⵙⵡⴰⵏ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK30_7","027_30_7","EZK","30","7","7","’ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵉⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏⵜ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⵡⴰⵅⴰⵔⵔⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK30_8","027_30_8","EZK","30","8","8","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⵙⵙⴰⵔⵖⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⵄⴰⵡⴰⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK30_9","027_30_9","EZK","30","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵙ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏ ⴽⵓⵛ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷⵉ ⵍⴰⵎⴰⵏ. ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵢⵉⵍⵉ ⵡⴰⵔⵊⴻⴼ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵎⴻⵛⵏⴰⵡ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏ ⵎⵉⵚⵔⴰ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ!’” ");
INSERT INTO rift_vpl VALUES ("EK30_10","027_30_10","EZK","30","10","10","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵔⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK30_11","027_30_11","EZK","30","11","11","ⵏⴻⵜⵜⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ, ⵉⵎⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵇⴰⵄ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⵃⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⴹⵉⴷⴷ ⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK30_12","027_30_12","EZK","30","12","12","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵥⵖⴻⵖ ⵉⵖⴻⵣⵔⴰⵏ ⵓⵛⴰ ⴰⴷ ⵣⵣⴻⵏⵣⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ ⴰⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK30_13","027_30_13","EZK","30","13","13","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓⵛⴰ ⴰⴷ ⵇⴹⵉⵖ ⵅ ⵍ’ⴰⵚⵏⴰⵎ ⵣⵉ ⵏⵓⴼ. ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⴷⴼⴻⵖ ⵍⵄⵓⵔⵔⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK30_14","027_30_14","EZK","30","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⴼⴰⵜⵔⵓⵙ ⵓ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵖ ⵚⵓⵄⴰⵏ ⵓ ⴰⴷ ⴰⵡⵢⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵉⵏⵓ ⴷⵉ ⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK30_15","027_30_15","EZK","30","15","15","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴼⴰⵔⵖⴻⵖ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵅ ⵙⵉⵏ, ⵍⴱⵓⵔⵊ ⵏ ⵎⵉⵚⵔⴰ, ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK30_16","027_30_16","EZK","30","16","16","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⴷⴼⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵙⵉⵏ ⴰⴷ ⵜⴻⴼⵙⵉ ⵙ ⵍⴻⵃⵔⵉⵇ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵏⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⴵⴻⵇ ⵓ ⵏⵓⴼ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("EK30_17","027_30_17","EZK","30","17","17","ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵣⵉ ⴰⵡⴰⵏ ⴷ ⴼⵉⴱⵉⵙⵜⴰ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏⵜ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EK30_18","027_30_18","EZK","30","18","18","ⴰⵙⵙ ⴰⴷ ⵉⵜⵜⴱⴰⵔⵛⴻⵏ ⴷⵉ ⵜⴰⵃⴼⴰⵃⵉⵙ ⵅⵎⵉ ⵖⴰ ⵢⴰⵔⵥⴻⵖ ⵏⴻⵛⵛ ⴰⵣⴰⵢⵍⵓ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⴰⴷ ⴰⵙ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷⵉⵏⵏⵉ. ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⴰⴷ ⵜⵜ ⵉⵙⵙⴷⵓⵔⵔⵉ ⵓⵛⴰ ⵢⴻⵙⵙⵉⵙ ⴰⴷ ⵓⵢⵓⵔⴻⵏⵜ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EK30_19","027_30_19","EZK","30","19","19","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵅ ⵎⵉⵙⵍⴰ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK30_20","027_30_20","EZK","30","20","20","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ, ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK30_21","027_30_21","EZK","30","21","21","“‘ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴻⵛⵛ ⴰⵔⵥⵉⵖ ⴰⵖⵉⵍ ⵏ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ. ⵅⵣⴰⵔ, ⵡⴰⵔ ⵜ ⵉⵊⴻⴱⴱⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ, ⵡⴰⵔ ⵜ ⵜⵜⴻⵏⵏⴹⴻⵏ ⵙ ⴱⵉⵏⴷⴰⵜ ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜ ⵖⴰ ⵙⵙⵊⴻⵀⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵙⵙⵉⴼ ⵄⴰⵡⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("EK30_22","027_30_22","EZK","30","22","22","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵅ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵍⴰ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ, ⴰⵎ ⵓⵖⵉⵍ ⵉⵊⴻⵀⴷⴻⵏ ⵄⴰⴷ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵥⵉⵏ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵙⵙⵉⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵡⴹⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK30_23","027_30_23","EZK","30","23","23","ⵏⴻⵛⵛ ⴰⴷ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵜⴻⵏ ⴱⴻⵣⵣⵄⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK30_24","027_30_24","EZK","30","24","24","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵊⴻⵀⴷⴻⵖ ⵉⵖⴰⴵⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵖⴰⴵⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⵜⴻⵏ ⴰⵔⵥⴻⵖ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵙⵖⵓⵢ ⴰⵎ ⵉⵙⵖⵓⵢⵢⵓ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⵓⵇⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK30_25","027_30_25","EZK","30","25","25","ⵡⴰⵀ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵊⴻⵀⴷⴻⵖ ⵉⵖⴰⴵⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵎⴰⵛⴰ ⵉⵖⴰⴵⴻⵏ ⵏ ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⵡⴹⴰⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⴳⴳⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK30_26","027_30_26","EZK","30","26","26","ⵏⴻⵛⵛ ⴰⴷ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵜⴻⵏ ⴱⴻⵣⵣⵄⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⴰ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK31_1","027_31_1","EZK","31","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK31_2","027_31_2","EZK","31","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵉ ⵉ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ: ‘ⵡⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵎⵇⵓⴷⴷⴰⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("EK31_3","027_31_3","EZK","31","3","3","ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⴰⵛⵛⵓⵔ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⴰⴽ-ⴷ ⵜⵙⴻⴹⵡⵉⵏ ⵉⵛⵏⴰⵏ ⴷ ⵜⵉⴼⵔⴰⵢ ⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵉⵍⵉ ⵎⵍⵉⵃ ⵓ ⴰⴽ-ⴷ ⵜⵉⴷⴷⵉ ⴷ ⴰⵣⵉⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⴰⵍⴰⵎⵉ ⵜⵓⵛⵛⴻⵏⵜ ⵏⵏⴻⵙ ⵜⵉⵡⴻⴹ-ⴷⴷ ⴰⵍ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK31_4","027_31_4","EZK","31","4","4","ⴰⵎⴰⵏ ⴰⵔⵔⵉⵏ ⵜⵜ ⴰⴷ ⵉⵢⵎⴰ, ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵜ ⴰⵟⵟⴰⵙ. ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵡⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵙⵙⵉⵣⵣⵍⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵜⴻⴱⵀⵉⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴰⵔⵔⵉⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK31_5","027_31_5","EZK","31","5","5","ⵅ ⵓⵢⴰ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ ⵜⵉⴷⴷⵉ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵓ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏⵜ ⵙ ⵡⴰⵟⵟⴰⵙ ⵓ ⵉⴼⴻⵜⵡⴰⵏ ⵏⵏⴻⵙ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⵉⴼⴻⵢⵢⴹⴻⵏ, ⵅⵎⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵖⴻⵎⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("EK31_6","027_31_6","EZK","31","6","6","ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴳⴳⵉⵏ ⵍⵄⵓⵛⵛ ⵏⵙⴻⵏ ⴷⵉ ⵜⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ ⴼⴻⵔⵅⴻⵏ ⵙⴰⴷⵓ ⵉⴼⴻⵜⵡⴰⵏ ⵏⵏⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵎⵖⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵖⵉⵎⴰⵏ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK31_7","027_31_7","EZK","31","7","7","ⵜⵓⵖⴰ-ⵜⵜ ⵜⴻⵛⵏⴰ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⵓ ⵙ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵥⵡⴰⵔ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK31_8","027_31_8","EZK","31","8","8","ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵅⴰⵙ ⵄⴷⵓⵏⵜ, ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵔⵣⵉ ⵡⴰⵔ ⵙⴻⴽⴽⵡⵉⵏⵜ ⵜⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⴷⵓⵍⴱ ⵡⴰⵔ ⵙⴻⴽⴽⵡⵉⵏⵜ ⵉⴼⴻⵜⵡⴰⵏ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵔⵡⴻⵙ ⴷⴰⵢⴻⵙ ⴷⴻⴳ ⵡⴰⵥⵔⵉ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("EK31_9","027_31_9","EZK","31","9","9","ⴳⴳⵉⵖ ⵜⵜ ⵜⴻⵛⵏⴰ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵓⵙⵎⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵄⴰⴷⵏ, ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK31_10","027_31_10","EZK","31","10","10","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵎⵉ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵜⵉⴷⴷⵉ ⵏⵏⴻⵎ, ⵡⴰⵀ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵜⵓⵛⵛⴻⵏⵜ ⵏⵏⴻⵙ ⵊⴰⵔ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EK31_11","027_31_11","EZK","31","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⵛⵉⵖ ⵜⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵇⴰⵄ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷ-ⵉⵜⵜⵍⵉⵇⴻⵏ ⴰⴽ-ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵓⵥⵥⵍⴻⵖ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK31_12","027_31_12","EZK","31","12","12","ⵣⴻⴷⵎⴻⵏ ⵜⵜ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵍⴻⴳⵏⵓⵙ ⵉⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ, ⵣⴻⴷⵎⴻⵏ ⵜ ⵓⵛⴰ ⵊⵊⵉⵏ ⵜⵜ. ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⵡⴹⴰⵏⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵣⵓⵔⵜⵉⵏ, ⵉⴼⴻⵜⵡⴰⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵔⵥⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵀⵡⴰⵏ-ⴷⴷ ⵣⵉ ⵙⴰⴷⵓ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵊⵊⵉⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EK31_13","027_31_13","EZK","31","13","13","ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⴻⴷⵖⴻⵏ ⵅ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⵡⴹⴰⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅ ⵉⴼⴻⵜⵡⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK31_14","027_31_14","EZK","31","14","14","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵜⵜ, ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵡⴰⵔ ⴷⵉⴽⴽⵡⵉⵍⴻⵏⵜ ⵄⴰⴷ ⵜⵜⵏⴻⴼⴼⵅⴻⵏⵜ ⵙ ⵜⵉⴷⴷⵉ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵏⵜ ⵜⵓⵛⵛⴻⵏⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⵉ ⵉⵙⵡⵉⵏ ⴰⵎⴰⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵏⵜ ⵄⴰⴷ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⴷⵉ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵙⴻⵏⵜ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵎⴻⵡⵛⴻⵏⵜ ⵉ ⵍⵎⴻⵡⵜ, ⵖⴰⵔ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ.’” ");
INSERT INTO rift_vpl VALUES ("EK31_15","027_31_15","EZK","31","15","15","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵜⴻⵀⵡⴰ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ, ⴳⴳⵉⵖ ⵉⵊⵊ ⵡⴻⵛⴹⴰⵏ. ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⴷⵍⵉⵖ ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴼⴻⵛⵍⴻⵏ ⵡⴰⵎⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ. ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⵙⵙⴱⴰⵔⵔⴻⵛⵏⴻⵖ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ ⵛⴻⴹⵏⴻⵏⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK31_16","027_31_16","EZK","31","16","16","ⵙ ⴷⴷⵔⵉⵣ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵙ ⵙⵙⴰⵔⵊⵉⵊⴻⵖ ⵍⴻⴳⵏⵓⵙ, ⵓⵎⵉ ⵜⵜ ⵙⵙⴻⵀⵡⵉⵖ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ. ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵄⴰⴷⵏ, ⵜⵉⵏⵏⵉ ⵉⵄⵉⵣⵣⴻⵏ ⴰⵟⵟⴰⵙ ⴷ ⵜⵉⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵣⵉ ⵍⵓⴱⵏⴰⵏ, ⵜⵉⵏⵏⵉ ⵉⵙⵡⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⵊⴻⵏⵜ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK31_17","027_31_17","EZK","31","17","17","ⵓⵍⴰ ⴷ ⵏⵉⵜⴻⵏⵜⵉ ⵀⵡⴰⵏⵜ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ, ⵖⴰⵔ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵖⵉⵍ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK31_18","027_31_18","EZK","31","18","18","ⴰⴽ ⵡⵉ ⵜⵙⴰⵡⵉⴷ ⴰⵎⵎⵓ ⴷⵉ ⵍⵄⴻⵣⵣ ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵄⴰⴷⵏ? ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⵉⴷ ⴰⴽ-ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵄⴰⴷⵏ ⴰⵍ ⵔⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⴷ ⵜⴱⵓⵣⵣⵍⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ. ⵓⵛⴰ ⴰⴷ ⵉⵏⵉⵏ: ⵡⴰ ⴷ ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK32_1","027_32_1","EZK","32","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK32_2","027_32_2","EZK","32","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵉⵏⵉ ⴰⵙ: ‘ⵜⵓⵖⴰ ⵛⴻⴽ ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵜⵓⵖⴰ ⵛⴻⴽ ⴰⵎ ⵍⵀⴰⵢⵛⴻⵜ ⴷⵉ ⵍⴻⴱⵃⵓⵔ. ⵜⵖⴻⴹⵍⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⴻⴳ ⵉⵖⴻⵣⵔⴰⵏ, ⵜⴻⵙⵙⴻⵏⵀⴻⵣⵣⴻⴷ ⴰⵎⴰⵏ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⴻⵙⵙⴻⴼⵙⴰⴷ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_3","027_32_3","EZK","32","3","3","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⴽ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵜⵔⴰⵛⵛⴰ ⵉⵏⵓ, ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵟⵟⴰⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⵉⵍⵢⴻⵏ ⴰⴽ-ⴷ ⵜⵔⴰⵛⵛⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK32_4","027_32_4","EZK","32","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵊⵊⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵛⴻⴽ ⵏⴹⴰⵔⴻⵖ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ. ⴰⴷ ⵅⴰⴽ ⵙⵙⵣⴻⴷⵖⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵙⵙⵊⵉⵡⵏⴻⵖ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK32_5","027_32_5","EZK","32","5","5","ⴰⴷ ⴳⴳⴻⵖ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵛ ⵅ ⵉⴷⵓⵔⴰⵔ ⵓⵛⴰ ⴰⴷ ⵛⵛⵓⵔⴻⵖ ⵜⵉⵖⵣⵓⵔⵉⵏ ⵙ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵡⴰⵔⵔⴰⵢⴻⵎ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK32_6","027_32_6","EZK","32","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵙⵡⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵍ ⵉⴷⵓⵔⴰⵔ, ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⴰⴷ ⵛⵛⵓⵔⴻⵏⵜ ⵣⵣⴰⵢⴻⴽ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_7","027_32_7","EZK","32","7","7","‘ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴷⵓⵔⵢⴻⵖ ⴰⵊⴻⵏⵏⴰ ⵅⵎⵉ ⵛⴻⴽ ⵖⴰ ⵙⵙⵅⴻⵙⵢⴻⵖ. ⴰⴷ ⵙⵙⴱⴰⵔⵔⴻⵛⵏⴻⵖ ⵉⵜⵔⴰⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵙⵙⴷⵓⵔⵢⴻⵖ ⵜⴰⴼⵓⵛⵜ ⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵓⵛⴰ ⵜⴰⵣⵉⵔⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵄⴰⴷ ⴰⴷ ⵜⴰⵔⵖⴰ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK32_8","027_32_8","EZK","32","8","8","ⵎⴰⵔⵔⴰ ⵜⵉⴼⴰⵡⵉⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵜⴻⵏⵜ ⵙⵙⴱⴰⵔⵔⴻⵛⵏⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⴰⴵⴻⵙⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK32_9","027_32_9","EZK","32","9","9","‘ⵏⴻⵛⵛ ⴰⴷ ⵖⴻⵣⵣⵉⵖ ⵓⵍ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵓⵎⵉ ⵉ ⵖⴰ ⵢⴰⵡⵢⴻⵖ ⵍⴻⵅⴱⴰⵔ ⵏ ⵜⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵛ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⴰ ⵉ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EK32_10","027_32_10","EZK","32","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵅⵍⵄⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ ⵓ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵣⴻⴳ ⵡⴰⵔⵊⴻⴼ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ, ⵅⵎⵉ ⵖⴰ ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵖ ⵙⵙⵉⴼ ⵉⵏⵓ ⵙⵙⴰ ⴷ ⵙⵙⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵍⴻⴱⴷⴰ, ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵡⴻⵟⵟⵓ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_11","027_32_11","EZK","32","11","11","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵙⵙⵉⴼ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ ⴰⴷ ⵅⴰⴽ ⵢⴻⵎⵎⴰⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("EK32_12","027_32_12","EZK","32","12","12","ⵙ ⵍⴻⵙⵢⵓⴼ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴰⴷ ⵖⴻⴹⵍⴻⵖ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵛ ⵉⵏⵀⴻⵡⵍⴻⵏ. ⴰⵇⴰ-ⵜⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵇⴻⵙⵃⴻⵏ ⴰⵟⵟⴰⵙ ⵎⴰⵔⵔⴰ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⴹⴰⵏ ⵅ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("EK32_13","027_32_13","EZK","32","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⵅ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴹⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴰⵔⵡⵉ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵛⴹⴻⵛⵜ ⵏ ⵍⵎⴰⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⴰⵔⵡⵉ ⵄⴰⴷ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_14","027_32_14","EZK","32","14","14","‘ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⵀⵡⵉⵖ ⴰⵎⴰⵏ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵚⴼⴰⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵙⴻⵏ ⴰⴷ ⵙⵙⵉⵣⵣⵍⴻⵏ ⴰⵎ ⵣⵣⴻⵛⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK32_15","027_32_15","EZK","32","15","15","‘ⴰⵍⴰⵎⵉ ⴳⴳⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴷ ⴰⵔⴻⴷⴷⴻⴵ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵜⴻⵃⴼⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⴰⵍⴰⵎⵉ ⵡⵜⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK32_16","027_32_16","EZK","32","16","16","“ⵡⴰ ⴷ ⵉⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵖⴻⵏⵏⵊⴻⵏ ⴰⵎ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵢⴻⵙⵙⵉⵜⵙⴻⵏⵜ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⴰⴷ ⵜ ⵖⴻⵏⵏⵊⴻⵏⵜ ⴰⵎ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ, ⴰⴷ ⵜ ⵖⴻⵏⵏⵊⴻⵏⵜ ⴰⵎ ⵢⴻⵣⵍⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵎⵉⵚⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK32_17","027_32_17","EZK","32","17","17","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK32_18","027_32_18","EZK","32","18","18","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵡⵡⴻⵜ ⴰⴳⴻⵊⴷⵓⵔ ⵅ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵎⵉⵚⵔⴰ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵀⵡⴰ, ⵎⵉⵚⵔⴰ ⴰⴽ-ⴷ ⵢⴻⵙⵙⵉⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ, ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK32_19","027_32_19","EZK","32","19","19","ⵎⴰ ⵛⴻⴽ ⵉⵄⵉⵣⵣⴻⵏ ⵅ ⵎⴰⵏ ⵎⵎⴰ? ⵀⵡⴰ, ⴻⵊⵊ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⵙⴻⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK32_20","027_32_20","EZK","32","20","20","ⴰⴷ ⵡⴹⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ. ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⵙⵙⵉⴼ. ⵊⴰⵔⵔ ⵎⵉⵚⵔⴰ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK32_21","027_32_21","EZK","32","21","21","ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵓ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵜ ⵉⵄⴰⵡⴰⵏⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴰⵅⴰⵔⵜ. ⵀⵡⴰⵏ ⵏⵉⵜⵏⵉ, ⴰⵇⴰ ⵣⵣⵍⴻⵏ ⴷⵉⵏⵏⵉ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_22","027_32_22","EZK","32","22","22","‘ⴷⵉⵀⴰ ⵉⴵⴰ ⴰⵛⵛⵓⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏⵏⴻⵙ, ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵏⵖⴻⵏ, ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EK32_23","027_32_23","EZK","32","23","23","ⵉⵎⴻⴹⵍⴰⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵖⴻⵎⵎⴰⵔ ⵏ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ ⵓ ⴰⴳⵔⴰⵡ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ, ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_24","027_32_24","EZK","32","24","24","‘ⴷⵉⵀⴰ ⵄⵉⵍⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ, ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵀⵡⴰⵏ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵙⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK32_25","027_32_25","EZK","32","25","25","ⴳⴳⵉⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ. ⵉⵎⴻⴹⵍⴰⵏ ⵏⵏⴻⵙ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵙⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⴻⴽⴽⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_26","027_32_26","EZK","32","26","26","ⴷⵉⵀⴰ ⵎⴰⵛⵉⵅ-ⵜⵓⴱⴰⵍ ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ. ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵏⴻⵙ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK32_27","027_32_27","EZK","32","27","27","ⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵡⴰⵔ ⵣⵣⵉⵍⴻⵏ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ ⵉⵀⵡⴰⵏ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⴰⴽ-ⴷ ⵍⴻⵙⵏⴰⵃ ⵏⵙⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ. ⵎⵎⴰⵔⵙⴻⵏ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⵙⴰⴷⵓ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴰⵇⴰ-ⵜⵜ ⵅ ⵢⴻⵢⵙⴰⵏ ⵏⵙⴻⵏ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵉ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK32_28","027_32_28","EZK","32","28","28","ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴰⵔⵥⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵣⵣⵍⴻⴷ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_29","027_32_29","EZK","32","29","29","‘ⴷⵉⵀⴰ ⵉⴷⵓⵎ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵚⵚⵓⵍⵜⴰ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ. ⵣⵣⵍⴻⵏ ⴷⵉⵏⵏⵉ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵓ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ’. ");
INSERT INTO rift_vpl VALUES ("EK32_30","027_32_30","EZK","32","30","30","‘ⴷⵉⵀⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ ⵣⵉ ⵛⵛⵎⴰⵍ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ, ⵓ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵚⵉⴷⵓⵏ, ⵉⵏⵏⵉ ⵉⵀⵡⴰⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ. ⴰⵇⴰ ⵜⵜⵙⴻⴹⵃⴰⵏ ⴷⵉⵏⵏⵉ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵉⵡⴷⴰⵏ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⵏⵙⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ. ⴰⵇⴰ ⵣⵣⵍⴻⵏ ⴷⵉⵏⵏⵉ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵓⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵡⴻⵏⴹⴻⵍ.’ ");
INSERT INTO rift_vpl VALUES ("EK32_31","027_32_31","EZK","32","31","31","‘ⴼⵉⵔⵄⵓⵏ ⴰⴷ ⵜⴻⵏ ⵉⵥⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⴻⵊ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ, ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EK32_32","027_32_32","EZK","32","32","32","‘ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵊⵊⵉⵖ ⵜ ⴰⴷ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵉⵏⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⴰⵔⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵙ ⵙⵙⵉⴼ, ⴼⵉⵔⵄⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ,’ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK33_1","027_33_1","EZK","33","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK33_2","027_33_2","EZK","33","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵅⵎⵉ ⵖⴰ ⵢⴰⵡⵢⴻⵖ ⵙⵙⵉⴼ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵟⵟⵔⵓⴼⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷ ⴰⵄⴻⵙⵙⴰⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EK33_3","027_33_3","EZK","33","3","3","ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵡⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵙⵙⵉⴼ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵛⴰ ⵉⵄⴻⴵⴻⵎ ⵉ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("EK33_4","027_33_4","EZK","33","4","4","ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵉⵙⵍⴰ ⵉ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵄⵍⴻⵎ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵙⵙⵉⴼ, ⵉⴽⴽⴻⵙ ⵉ-ⵜ, ⵅⴻⵏⵏⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK33_5","027_33_5","EZK","33","5","5","ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵄⵍⴻⵎ, ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵙ, ⵎⴰⵛⴰ ⵍⴻⵄⵎⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵉⵊⵊⵉⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵄⵍⴻⵎ, ⴰⴷ ⵉⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK33_6","027_33_6","EZK","33","6","6","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵄⴻⵙⵙⴰⵙ ⵉⵜⵡⴰⵍⴰ ⵙⵙⵉⴼ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵡⴰⵔ ⵉⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵄⵍⴻⵎ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵙⵙⵉⴼ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⴽⴽⴻⵙ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵎⴻⴽⵙⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵄⴻⵙⵙⴰⵙ.’” ");
INSERT INTO rift_vpl VALUES ("EK33_7","027_33_7","EZK","33","7","7","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴰⵄⴻⵙⵙⴰⵙ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜⵄⴻⵍⵎⴻⴷ ⵣⵣⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("EK33_8","027_33_8","EZK","33","8","8","ⵓⵎⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵓⵄⴻⴼⴼⴰⵏ: ‘ⴰ ⴰⵄⴻⴼⴼⴰⵏ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⵍⵎⴻⵡⵜ!’, ⵓ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⵉⵍⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵄⴻⵍⵎⴻⴷ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓⵄⴻⴼⴼⴰⵏ ⵏⵏⵉ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK33_9","027_33_9","EZK","33","9","9","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵄⴻⵍⵎⴻⴷ ⵉ ⵓⵄⴻⴼⴼⴰⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵃⴻⵢⵢⴻⴷ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⴻⵜ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("EK33_10","027_33_10","EZK","33","10","10","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ, ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵉⵄⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵖ ⴷ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⴰⵇⴰ ⴰⵜⴻⵏ ⵅⴰⵏⴻⵖ ⵓⵛⴰ ⵏⵀⴻⵍⵍⴻⴽ ⴷⴰⵢⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵏⴻⵇⵇⵉⵎ ⵏⴻⴷⴷⴰⵔ?’ ");
INSERT INTO rift_vpl VALUES ("EK33_11","027_33_11","EZK","33","11","11","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴰⵔⴻⵟⵟⵉⵖ ⵅ ⵍⵎⴻⵡⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵔⴹⴻⵖ ⴰⵄⴻⴼⴼⴰⵏ ⵅⵎⵉ ⵖⴰ ⵉⵜⵓⴱ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴷⴷⴰⵔ. ⵜⵓⴱⴻⵎ, ⵜⵓⴱⴻⵎ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ?’” ");
INSERT INTO rift_vpl VALUES ("EK33_12","027_33_12","EZK","33","12","12","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵏⵉ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ: ‘ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ ⵡⴰⵔ ⵜ ⵉⵙⵙⵏⴻⵊⵊⵉⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵉⵅⴹⴰ ⵓⵛⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵏⵇⴰⵔⴻⴹ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵉⵜⵓⴱ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ. ⴰⵎⵙⴻⴳⴳⴻⴷ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴷⴷⴰⵔ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵉⵅⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("EK33_13","027_33_13","EZK","33","13","13","ⵓⵎⵉ ⵏⵏⵉⵖ ⵏⴻⵛⵛ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵉⵇⵇ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵍⵉⴷⴰⵔⴻⵜ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⵉ ⵍⵖⴻⵛⵛ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ, ⴰⵇⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EK33_14","027_33_14","EZK","33","14","14","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵓⵄⴻⴼⴼⴰⵏ: ⵍⵎⴻⵡⵜ ⵉ ⵖⴰ ⵜⴻⵎⵎⵜⴻⴷ!, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵓⴱ ⵅ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("EK33_15","027_33_15","EZK","33","15","15","- ⴰⵇⴰ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵉⵙⵙⴻⵄⵇⴻⴱ ⴷⴷⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⴻⵏ, ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⵖⴻⵛⵛ - ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EK33_16","027_33_16","EZK","33","16","16","ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⵉ ⵉⴳⴳⴰ, ⵡⴰⵔ ⴷⴷ ⴰⵙ ⵜⵜⵡⴰⵃⴻⵙⵙⴱⴻⵏ ⵛⴰ. ⵉⴳⴳⴰ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ⴰⴷ ⵉⴷⴷⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EK33_17","027_33_17","EZK","33","17","17","“ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ!’, ⵓⵎⵉ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK33_18","027_33_18","EZK","33","18","18","ⵎⴰⵍⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵅ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⵍⵖⴻⵛⵛ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵎⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("EK33_19","027_33_19","EZK","33","19","19","ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⵉⵜⵓⴱ ⵓⵄⴻⴼⴼⴰⵏ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK33_20","027_33_20","EZK","33","20","20","ⵄⴰⴷ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ!’ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵖ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴽⵓⵍ ⵉⵊⵊ ⴰⵎ ⵢⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EK33_21","027_33_21","EZK","33","21","21","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏⵏⴻⵖ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵓⵢⵓⵔ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴰⵍ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⴰ: “ⵜⴰⵏⴷⵉⵏⵜ ⵜᵉⵜⵜⵡⴰⵖⴻⵍⵍⴻⴱ!” ");
INSERT INTO rift_vpl VALUES ("EK33_22","027_33_22","EZK","33","22","22","ⵖⴰⵔ ⴵⵉⵍⴻⵜ ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵅⴰⴼⵉ, ⵇⴱⴻⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵎⴰⵔⵡⴰⵍ ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵢⵉ ⴰⵇⴻⵎⵎⵓⵎ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵎⴰⵔⵡⴰⵍ ⵖⴰⵔⵉ ⴷⵉ ⵚⵚⴱⴻⵃ. ⵜⵓⵖⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵉⵜⵜⵡⴰⵔⵣⴻⵎ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵄⴰⴷ ⴷ ⴰⵢⵏⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("EK33_23","027_33_23","EZK","33","23","23","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK33_24","027_33_24","EZK","33","24","24","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⵅⵉⵔⴱⴰⵜ-ⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ‘ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊ ⵓⵛⴰ ⵉⵡⴰⵔⵜ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ. ⵏⴻⵛⵛⵉⵏ ⵍⴻⵅⵅⵓ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵜⴻⵎⵎⴻⵡⵛ ⴰⵏⴻⵖ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⴰⵙⵖⴰⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("EK33_25","027_33_25","EZK","33","25","25","ⵙ ⵓⵢⴰ, ⵉⵏⵉ ⴰⵙⴻⵏ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵜⴻⵎ ⴰⵢⵙⵓⵎ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵡⴻⵎ ⵓⵛⴰ ⵜⴻⵙⵙⵉⵣⵣⴰⵍⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ. ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("EK33_26","027_33_26","EZK","33","26","26","ⵜⴻⵜⵜⴱⴻⴷⴷⴰⵎ ⵅ ⵙⵙⵉⴼ ⵏⵡⴻⵎ, ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵊⵊⵄⵉⴼⴻⵛⵜ ⵓ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵙⵙⵅⴻⵎⵎⴰⵊ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ?’ ");
INSERT INTO rift_vpl VALUES ("EK33_27","027_33_27","EZK","33","27","27","ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵜⵉⵏⵉⴷ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵍⵅⵉⵔⴱⴰⵜ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ, ⵓ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵜ ⵡⵛⴻⵖ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵚⴰⵔⴹⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵓ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵟⵟⴰⵄⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("EK33_28","027_33_28","EZK","33","28","28","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⴰⵔⴻⴷⴷⴻⴵ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵡⴰⵔⵊⴻⴼ ⵓⵛⴰ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ. ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵥⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK33_29","027_33_29","EZK","33","29","29","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⴰⵔⵔⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⴰⵔⴻⴷⴷⴻⴵ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏ ⵡⴰⵔⵊⴻⴼ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ ⵏⵏⵉ ⴳⴳⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK33_30","027_33_30","EZK","33","30","30","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵢⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅⴰⴽ ⵖⴰⵔ ⵍⴻⵃⵢⵓⴹ ⵓ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⵓⴷⵔⵉⵏ. ⵉⵊⵊ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴽⵓⵍ ⵉⵊⵊ ⴰⴽ-ⴷ ⵓⵎⴰⵙ, ⵓⵛⴰ ⵉⵇⵇⴰⵔ: ‘ⴰⵙⴻⵎ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵓⵛⴰ ⵙⵍⴻⵎ ⵎⴰⵏ ⴰⵡⴰⵍ ⵉ ⴷⴷ ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ!’ ");
INSERT INTO rift_vpl VALUES ("EK33_31","027_33_31","EZK","33","31","31","ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴳⴻⵏⵙ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⴻⴽ ⴰⵎ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ, ⵎⴰⵖⴰⵔ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⵜⴰⵢⵔⵉ, ⵎⴰⵛⴰ ⵓⵍ ⵏⵙⴻⵏ ⵉⴳⴳⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⴻⴼⴹⴻⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK33_32","027_33_32","EZK","33","32","32","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵛⴻⴽ ⵖⴰⵔⵙⴻⵏ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ ⵉⵣⵍⴰⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵚⴱⴻⵃ, ⴰⵎⴻⵛⵏⴰⵡ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴳⴳⴰ ⵍⵎⵓⵙⵉⵇⴰ ⵎⵍⵉⵃ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK33_33","027_33_33","EZK","33","33","33","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵢⴰ - ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ! - ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK34_1","027_34_1","EZK","34","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK34_2","027_34_2","EZK","34","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵓⵛⵜ ⵅ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵢⴰⵔⴻⴽⴽⵡⴻⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ! ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⵓⴵⵉ?    ");
INSERT INTO rift_vpl VALUES ("EK34_3","027_34_3","EZK","34","3","3","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵜⴰⴷⵓⵏⵜ ⵓⵛⴰ ⵜⴰⵔⵔⴹⴻⵎ ⵜⴰⴹⵓⴼⵜ, ⵜⵖⴰⵔⵔⵚⴻⵎ ⵉ ⵍⵎⴰⵍ ⵉⵎⴻⵙⵙⵍⴻⵏ ⵎⵍⵉⵃ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴰⵔⴻⴽⴽⵡⵉⵙⴻⵎ ⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("EK34_4","027_34_4","EZK","34","4","4","ⵡⴰⵔ ⵜⴻⵙⵙⵎⴻⵄⵣⴻⵎ ⵎⵉⵏ ⵉⵀⴻⵢⵢⴼⴻⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵙⴳⴻⵏⴼⵉⵎ ⵎⵉⵏ ⵉⵃⴻⵍⵛⴻⵏ, ⵎⵉⵏ ⵉⵜⵜⵡⴰⵔⵥⵉⵏ ⵡⴰⵔ ⵜ ⵜⵛⴻⴼⴼⵏⴻⵎ, ⵎⵉⵏ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⴰⵔⵔⵉⵎ ⵓ ⵎⵉⵏ ⵉⵅⵙⴰⵔⴻⵏ ⵡⴰⵔ ⵅⴰⵙ ⵜⴰⵔⴻⵣⵣⵓⵎ, ⵎⴰⵛⴰ ⵙ ⵓⵇⴰⴱⵓ ⴷ ⵓⴼⵓⵙ ⵉⵇⴻⵙⵃⴻⵏ ⵜⵃⴻⴽⴽⵎⴻⵎ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK34_5","027_34_5","EZK","34","5","5","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⴱⵓ ⵓⵎⴻⴽⵙⴰⵡ. ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴻⵢⵎⴰⵔⵜ ⵏ ⵍⴻⵡⵃⵓⵛ ⵏ ⴱⴰⵔⵔⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK34_6","027_34_6","EZK","34","6","6","ⵓⵢⵓⵔⴻⵏ ⵡⴻⴷⴷⴰⵔⴻⵏ ⵓⴵⵉ ⵉⵏⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⵓ ⵅ ⴽⵓⵍ ⵜⴰⵡⵔⵉⵔⵜ ⵢⵓⵄⵍⴰⵏ, ⵓⴵⵉ ⵉⵏⵓ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⵙⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵅⴰⵙⴻⵏ ⵢⴰⵔⴻⵣⵣⵓⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK34_7","027_34_7","EZK","34","7","7","“ⵙ ⵓⵢⴰ, ⴰ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ: ");
INSERT INTO rift_vpl VALUES ("EK34_8","027_34_8","EZK","34","8","8","‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵏⴻⵛⵛ ⵅⴰⵙⴻⵏ? ⵎⵉⵏⵣⵉ ⵓⴵⵉ ⵉⵏⵓ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⵢⵎⴰⵔⵜ ⵓ ⵓⴵⵉ ⵉⵏⵓ ⴷⴻⵡⵍⴻⵏ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ, ⵓⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵎⴻⴽⵙⴰⵡ ⵓ ⵎⵉⵏⵣⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⵜⵜⵙⴻⵇⵙⴰⵏ ⵛⴰ ⵅ ⵡⵓⴵⵉ ⵉⵏⵓ ⵓ ⵓⵎⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵉⵏⵓ ⴰⵔⴻⵡⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵓⴵⵉ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("EK34_9","027_34_9","EZK","34","9","9","“ⵙ ⵓⵢⴰ, ⴰ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("EK34_10","027_34_10","EZK","34","10","10","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴹⵉⴷⴷ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⵉ! ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵓⴵⵉ ⵉⵏⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵣⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵡⵓⴵⵉ, ⴰⵍⴰⵎⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵡⴰⵔ ⵢⴰⵔⴻⴽⴽⵡⴻⵙⴻⵏ ⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓⴵⵉ ⵉⵏⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⴷ ⵎⴰⵛⵛⴰ.’ ");
INSERT INTO rift_vpl VALUES ("EK34_11","027_34_11","EZK","34","11","11","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵇⵙⵉⵖ ⵅ ⵡⵓⴵⵉ ⵉⵏⵓ ⵓ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵔⵣⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("EK34_12","027_34_12","EZK","34","12","12","ⴰⵎ ⵓⵎⴻⴽⵙⴰⵡ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵢⴻⴵⴰ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ ⵉⴱⴻⵣⵣⵄⴻⵏ, ⴰⵎⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵣⵓⵖ ⵏⴻⵛⵛ ⵅ ⵡⵓⴵⵉ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵜⵡⴰⴱⴻⵣⵣⵄⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("EK34_13","027_34_13","EZK","34","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⵡⵙⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵉ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK34_14","027_34_14","EZK","34","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⵡⵙⴻⵖ ⵅ ⵉⵛⵜ ⵏ ⴷⴷⴻⵎⵏⴻⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ⵅ ⵉⴷⵓⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⵍⵎⴻⴷⵡⴻⵍ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏⵙⴻⵏ. ⴷⵉⵏⵏⵉ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴷⴷⴻⵎⵏⴻⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵓ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴷⴷⴻⵎⵏⴻⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴷ ⵍⴻⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK34_15","027_34_15","EZK","34","15","15","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵖ ⵓⴵⵉ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK34_16","027_34_16","EZK","34","16","16","‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵣⵓⵖ ⵎⵉⵏ ⵉⵅⵙⴰⵔⴻⵏ ⵓⵛⴰ ⵎⵉⵏ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⵓ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵔⵥⵉⵏ ⴰⴷ ⵜ ⵛⴻⴼⵏⴻⵖ ⵓ ⵎⵉⵏ ⵉⵀⴻⵍⵛⴻⵏ ⴰⴷ ⵜ ⵙⵙⵊⴻⵀⴷⴻⵖ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵎⴻⵙⵙⵍⴻⵏ ⴷ ⵎⵉⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴷ ⵜ ⴰⵔⴻⴷⴷⴵⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⵡⵙⴻⵖ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("EK34_17","027_34_17","EZK","34","17","17","ⵓ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵓⴵⵉ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵃⴻⴽⵎⴻⵖ ⵊⴰⵔ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵖⵏⵉ, ⵊⴰⵔ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK34_18","027_34_18","EZK","34","18","18","ⵎⴰ ⴷⵔⵓⵙⵜ ⴰⵡⴻⵎ ⵓⵎⵉ ⵜⴻⵛⵛⵉⵎ ⴷⴷⴻⵎⵏⴻⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵉⵏⵓ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⵄⴻⴼⵙⴻⵎ ⵅ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉ ⵜⴰⵔⴻⵡⵙⴰ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⴰⵎⴰⵏ ⵉⵚⴼⴰⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵡⵢⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("EK34_19","027_34_19","EZK","34","19","19","ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵅⴻⵏⵏⵉ ⵉ ⵡⵓⴵⵉ ⵉⵏⵓ ⴰⴷ ⵛⵛⴻⵏ ⵎⵉⵏ ⵅⴻⴼ ⵄⴻⴼⵙⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵓ ⴰⴷ ⵙⵡⴻⵏ ⵎⵉⵏ ⵙⵙⴰⵔⵡⵢⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ?’” ");
INSERT INTO rift_vpl VALUES ("EK34_20","027_34_20","EZK","34","20","20","“ⵙ ⵓⵢⴰ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵖ ⵊⴰⵔ ⵡⵓⴵⵉ ⵉⵎⴻⵙⵙⵍⴻⵏ ⴷ ⵡⵓⴵⵉ ⵉⴽⴽⵓⵛⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK34_21","027_34_21","EZK","34","21","21","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵓⴵⵉ ⵉⴹⴻⵄⴼⴻⵏ ⵜⵄⴰⵔⵏⴻⵎ ⵉ-ⵜⴻⵏ ⵙ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵙ ⵜⴻⵖⵔⵓⴹⵜ ⵓ ⵜⴻⵙⵙⵇⴰⵔⴱⴻⵎ ⵜⴻⵏ ⵙ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵜⴱⴻⵣⵣⵄⴻⵎ ⴷⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK34_22","027_34_22","EZK","34","22","22","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓⴵⵉ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⵉ ⵜⴻⵢⵎⴰⵔⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵖ ⵊⴰⵔ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⴵⵉ ⴷ ⵡⵓⴵⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK34_23","027_34_23","EZK","34","23","23","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⵏⵏⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵙⴻⵏ: ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵡⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⴽⵙⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("EK34_24","027_34_24","EZK","34","24","24","ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⵏⵉⵖ ⵜ. ");
INSERT INTO rift_vpl VALUES ("EK34_25","027_34_25","EZK","34","25","25","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵍⴻⵀⵏⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵖ ⵍⴻⵡⵃⵓⵛ ⵉⵡⵄⴰⵔⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵙ ⵍⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵟⵟⵚⴻⵏ ⴷⴻⴳ ⵉⵣⴻⵖⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK34_26","027_34_26","EZK","34","26","26","ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⵏⵏⴹⴻⵏ ⵉ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⴰⵏⵥⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ. ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵡⴻⵏⵥⴰⵔ ⴰⵟⵟⴰⵙ ⵙ ⵍⴱⴰⵔⴰⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("EK34_27","027_34_27","EZK","34","27","27","ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵡⵛⴻⵏⵜ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏⵜ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵡⵛ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⴰⵔⵥⴻⵖ ⵉⵎⵇⴻⴵⴰⴷⴻⵏ ⵏ ⵣⵣⴰⵢⵍⴻⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵇⴻⵍⵄⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵊⵊⵉⵏ ⴰⴷ ⴰⵙⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK34_28","027_34_28","EZK","34","28","28","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵍⴻⵡⵃⵓⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⴻⵏ ⵚⴰⵔⵔⴹⴻⵏ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EK34_29","027_34_29","EZK","34","29","29","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⴷⵓⵇⵇⵣⴻⵖ ⵉⵊⵊ ⵏ ⵓⵖⴻⵎⵎⵓⵢ, ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵉⵛⴻⵏⵏⵄⴻⵏ. ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵎⴻⴽⵙⵉⵏ ⵄⴰⴷ ⵙ ⵍⴰⵥ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵡⴰⵔ ⴰⵔⴻⴱⴱⵓⵏ ⵄⴰⴷ ⵍⵃⴻⴳⵔⴰ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK34_30","027_34_30","EZK","34","30","30","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴰⵢⵉ ⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK34_31","027_34_31","EZK","34","31","31","ⴽⴻⵏⵏⵉⵡ, ⴰ ⵓⴵⵉ ⵉⵏⵓ, ⵓⴵⵉ ⵏ ⵍⵎⴻⴷⵡⴻⵍ ⵉⵏⵓ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴽⴻⵏⵏⵉⵡ ⴷ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK35_1","027_35_1","EZK","35","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK35_2","027_35_2","EZK","35","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⵓ ⵏⴰⴱⴱ ⵅⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("EK35_3","027_35_3","EZK","35","3","3","ⵡⴰⵀ, ⵉⵏⵉ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ, ⴰ, ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⵓⵛⴰ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵜⴰⵔⴻⴷⴷⴻⴵⵜ ⴷ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EK35_4","027_35_4","EZK","35","4","4","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵜⴰⵔⴻⴷⴷⴻⴵⵜ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EK35_5","027_35_5","EZK","35","5","5","ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⴽ ⵍⴻⵄⴷⴰⵡⴰⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵓ ⵎⵉⵏⵣⵉ ⵜⵙⴻⵍⵍⵎⴻⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⵙⵙⵉⴼ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵙⴻⵏ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⵃⵉⵙⴰⴱ ⴰⵏⴻⴳⴳⴰⵔ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EK35_6","027_35_6","EZK","35","6","6","“ⵙ ⵓⵢⴰ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵇⴰⵄ ⵓ ⵉⴷⴰⵎⵎⴻⵏ ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵏ. ⵡⴰⵀ ⵓⵎⵉ ⵡⴰⵔ ⵜⵛⴰⵔⵀⴻⴷ ⵛⴰ ⴰⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK35_7","027_35_7","EZK","35","7","7","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ ⴷ ⵜⴰⵔⴻⴷⴷⴻⴵⵜ ⴷ ⵍⵅⴰⵔⴱⴻⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵇⴻⵙⵙⴻⵖ ⵡⵉ ⵉⵄⴻⴷⴷⵓⵏ ⴷ ⵡⵉ ⴷⴷ-ⵉⴷⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK35_8","027_35_8","EZK","35","8","8","ⵏⴻⵛⵛ ⴰⴷ ⵛⵛⵓⵔⴻⵖ ⵉⴷⵓⵔⴰⵔ ⵏⵏⴻⵙ ⵙ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵜⵉⵡⵔⵉⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵜⴻⵖⵣⵓⵔⵜⵉⵏ ⵏⵏⴻⵛ, ⵡⴰⵀ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ ⴰⴷ ⵡⴹⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK35_9","027_35_9","EZK","35","9","9","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⵜⵉⵔⴻⴷⴷⴻⴵⵉⵏ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵜⵡⵉⴼⴻⵏ ⵄⴰⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EK35_10","027_35_10","EZK","35","10","10","ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⵉⴷ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⴰ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵜⴻⵏⵜ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ!, ⴰⵎ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK35_11","027_35_11","EZK","35","11","11","“ⵙ ⵓⵢⴰ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⴰⵏⴻⵛⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵓ ⴰⵏⴻⵛⵜ ⵏ ⵜⵓⵙⵎⵉ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⴽ ⴷⴻⴳ ⵡⴻⵛⵔⴰⵀ ⵏⵏⴻⵛ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⴻⵏ ⵅⵎⵉ ⵅⴰⴽ ⵖⴰ ⵃⴻⴽⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK35_12","027_35_12","EZK","35","12","12","ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵍⵉⵖ ⵉ ⵎⴰⵔⵔⴰ ⴰⵛⴻⵇⵇⴰⴼ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴹⵉⴷⴷ ⵉ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⴻⵏⵏⵉⴷ: ⴰⵇⴰ ⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵎⵎⴻⵡⵛⴻⵏ ⴰⵏⴻⵖ ⴷ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("EK35_13","027_35_13","EZK","35","13","13","ⴰⵎⵎⵓ ⵉ ⵅⴰⴼⵉ ⵜⵇⴻⵍⴱⴻⵎ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ ⵉⵛⵛⵓⵔ ⵙ ⵓⴽⴻⴱⴱⴰⵔ ⵓⵛⴰ ⵜⴰⵔⵏⵉⵎ ⵜⴼⴰⵔⵔⵖⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ. ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵜ.’ ");
INSERT INTO rift_vpl VALUES ("EK35_14","027_35_14","EZK","35","14","14","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴰⵎ ⵜⴼⴰⵔⵔⴻⵃ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK35_15","027_35_15","EZK","35","15","15","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴼⴰⵔⵃⴻⴷ ⵙ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴽ ⴳⴳⴻⵖ ⴰⵎⵎⵓ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵄⵉⵔ, ⵛⴻⵎ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ, ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵜⴰⵔⴻⴷⴷⴻⴵⵜ! ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK36_1","027_36_1","EZK","36","1","1","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⵉ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵉ: ‘ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("EK36_2","027_36_2","EZK","36","2","2","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⵉⵏⵣⵉ ⵍⴻⵄⴷⵓ ⵉⵏⵏⴰ ⵅⴰⵡⴻⵎ: ⵉⵢⴰ, ⴰⵇⴰ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵍⴻⴱⴷⴰ ⴷⴻⵡⵍⴻⵏⵜ ⴰⵏⴻⵖ ⴷ ⵜⴰⵙⵖⴰⵔⵜ! ... ");
INSERT INTO rift_vpl VALUES ("EK36_3","027_36_3","EZK","36","3","3","... ⵙ ⵓⵢⴰ ⵏⴰⴱⴱ, ⵉⵏⵉ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⵉⵏⵣⵉ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵓ ⵚⴰⵔⴹⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵅⴰⵡⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵓⵛⴰ ⵜⴷⴻⵡⵍⴻⵎ ⵉ ⵓⵛⴻⵇⵇⴰⴼ ⵊⴰⵔ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("EK36_4","027_36_4","EZK","36","4","4","... ⵙ ⵓⵢⴰ, ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉ ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵡⵔⵉⵔⵉⵏ, ⵉ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⴷ ⵍⵡⴰⵟⴰⵜ, ⵉ ⵍⵅⵉⵔⴱⴰⵜ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ ⵓ ⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⵉⵊⵊⵉⵏ, ⵜⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵍⵃⴻⴳⵔⴰ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK36_5","027_36_5","EZK","36","5","5","... ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵏ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ ⴹⵉⴷⴷ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴷⵓⵎ, ⵉⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵏⵓ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵎⴰⵔⵔⴰ, ⵙ ⵍⴻⵄⵎⴰⵔ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵓⵙⴻⵃⵇⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵏⵜ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ! ");
INSERT INTO rift_vpl VALUES ("EK36_6","027_36_6","EZK","36","6","6","... ⵙ ⵓⵢⴰ, ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵏⵉ ⵉ ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵡⵔⵉⵔⵉⵏ ⵓ ⵉ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⴷ ⵍⵡⴰⵟⴰⵜ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵉⵡⵍⴻⵖ ⴷⵉ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴷⴻⴳ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⴰⵔⴱⵓⵎ ⵍⵃⴻⴳⵔⴰ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK36_7","027_36_7","EZK","36","7","7","... ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ, ⵥⵓⴵⴻⵖ: ⵙ ⵜⵉⴷⴻⵜⵜ, ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵃⴻⴳⵔⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EK36_8","027_36_8","EZK","36","8","8","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵄⴰⵡⴻⴷ ⵍⴻⴼⵔⵓⵄ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵡⴻⵎ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵄⵍⴰⵃⴰⵍ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_9","027_36_9","EZK","36","9","9","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵏⵇⴻⵍⴱⴻⵖ ⵓ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴷⵓⵔⴰⵔ, ⴰⴷ ⵅⴰⵡⴻⵎ ⵛⴰⵔⵣⴻⵏ ⵄⴰⵡⴻⴷ ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵣⴰⵔⵔⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_10","027_36_10","EZK","36","10","10","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵏⵉⵖ ⵉⵡⴷⴰⵏ ⵅⴰⵡⴻⵎ, ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵏⴻⵜⵜⴰⵜ, ⵓⵛⴰ ⴰⴷ ⵙⵙⵣⴻⴷⵖⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵓ ⴰⴷ ⴱⵏⴰⵏ ⵍⵅⵉⵔⴱⴰⵜ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK36_11","027_36_11","EZK","36","11","11","ⴰⴷ ⵅⴰⵡⴻⵎ ⴰⵔⵏⵉⵖ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵏⵉⵏ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⴷⴷ-ⵊⵊⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵣⴻⴷⵖⴻⵖ ⴷⵉⵏ ⵄⴰⵡⴻⴷ, ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵍⵃⴰⵍ ⵃⵙⴻⵏ ⵅ ⵓⵎⴻⵣⵡⴰⵔ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK36_12","027_36_12","EZK","36","12","12","ⴰⴷ ⵊⵊⴻⵖ ⵉⵡⴷⴰⵏ ⴰⴷ ⵅⴰⵡⴻⵎ ⵓⵢⵓⵔⴻⵏ: ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵟⵟⴼⴻⵏ ⴷ ⵍⵡⴰⵔⵜ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵍⵉⵎ ⴷ ⵍⵡⴰⵔⵜ, ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵎ ⵄⴰⴷ ⴰⵔⵔⴰⵡ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_13","027_36_13","EZK","36","13","13","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵎⵉⵏⵣⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵡⴻⵎ: ⵛⴻⵎ ⵜᵉⵜⵜⴻⴷ ⵉⵡⴷⴰⵏ ⵓ ⵛⴻⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⴰⵔⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ! ... ");
INSERT INTO rift_vpl VALUES ("EK36_14","027_36_14","EZK","36","14","14","... ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⴻⵛⵛⴻⴷ ⵄⴰⴷ ⵉⵡⴷⴰⵏ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵏⴻⵇⵔⴰⴹⴻⴷ ⵄⴰⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK36_15","027_36_15","EZK","36","15","15","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵄⴰⴷ ⵍⵃⴻⴳⵔⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⵅⴰⵎ ⵓ ⵡⴰⵔ ⵜⴽⴻⵙⵙⵉⴷ ⵄⴰⴷ ⴰⵙⵜⴻⵀⵣⵉ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵏⴻⵇⵔⴰⴹⴻⴷ ⵄⴰⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK36_16","027_36_16","EZK","36","16","16","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK36_17","027_36_17","EZK","36","17","17","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵙⵙⵅⴻⵎⵎⵊⴻⵏ ⵜⵜ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ⴰⴱⵔⵉⴷ ⵏⵙⴻⵏ ⵜⵓⵖⴰ-ⵜ ⴰⵎ ⵍⴻⵅⵎⴻⵊ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵅ ⴵⴰⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵄⵣⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK36_18","027_36_18","EZK","36","18","18","ⵏⴻⵛⵛ ⵙⵙⴼⴰⵔⵔⵖⴻⵖ ⵅⴰⵙⴻⵏ ⴰⵙⵄⴰⵔ ⵉⵏⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏⵙⴻⵎ ⵉ ⵣⵉ ⵜⵜ ⵙⵙⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_19","027_36_19","EZK","36","19","19","ⵏⴻⵅⵅ ⵙⵙⴱⴻⵣⵣⵄⴻⵖ ⵜⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⵓⵢⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⴰ. ⵏⴻⵛⵛ ⵃⴻⴽⵎⴻⵖ ⵅⴰⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⵢⵓⵔⵜ ⵏⵙⴻⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_20","027_36_20","EZK","36","20","20","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵓⵢⵓⵔⴻⵏ, ⵙⵙⴼⴻⴹⵃⴻⵏ ⵉⵙⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵅⴰⵙⴻⵏ: ‘ⵉⵏⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("EK36_21","027_36_21","EZK","36","21","21","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵄⵉⵣⵣⴻⵖ ⵜⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⴻⴼⴹⴻⵃ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ... ");
INSERT INTO rift_vpl VALUES ("EK36_22","027_36_22","EZK","36","22","22","... ⵙ ⵓⵢⴰ, ⵉⵏⵉ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⴳⴳⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⴼⴻⴹⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⵓⵢⵓⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_23","027_36_23","EZK","36","23","23","ⵎⴰⵖⴰⵔ ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⴼⴻⴹⵃⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ ⴷⴰⵢⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_24","027_36_24","EZK","36","24","24","ⵎⵉⵏⵣⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴽⵙⵉⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_25","027_36_25","EZK","36","25","25","ⴰⴷ ⵅⴰⵡⴻⵎ ⵣⴻⴵⵄⴻⵖ ⴰⵎⴰⵏ ⵉⵣⴷⵉⴳⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳⴻⵎ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⵣⴷⴻⴳⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵎⵓⵊⴰⵜ ⵏⵡⴻⵎ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵢⴹⴰ ⵏⵡⴻⵎ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_26","027_36_26","EZK","36","26","26","ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵓⵍ ⵏ ⵊⴷⵉⴷ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⴱⵓⵃⴱⴻⵍ ⴰⵎⴰⵢⵏⵓ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵖ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵓⵍ ⵏ ⵡⴻⵥⵔⵓ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵓⵍ ⵏ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_27","027_36_27","EZK","36","27","27","ⴰⴷ ⴳⴳⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵡⴻⵎ ⵓ ⴰⴷ ⴰⵔⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_28","027_36_28","EZK","36","28","28","ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_29","027_36_29","EZK","36","29","29","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵎⵓⵊⴰⵜ ⵏⵡⴻⵎ. ⴰⴷ ⵍⴰⵖⵉⵖ ⵉ ⵉⵎⴻⵏⴷⵉ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴰⵔⵏⵉⵖ ⴰⵟⵟⴰⵙ ⵓ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⵉⵛⴻⵖ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("EK36_30","027_36_30","EZK","36","30","30","ⴰⴷ ⴰⵔⵏⵉⵖ ⴰⵎⴻⵏⵏⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵓ ⵏ ⵢⴻⵢⵢⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⴻⴽⴽ ⵄⴰⴷ ⵍⵃⴻⴳⵔⴰ ⵏ ⵍⴰⵥ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EK36_31","027_36_31","EZK","36","31","31","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⴷⴰⵔⴻⵎ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵉⵄⴻⴼⴼⵏⴻⵏ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵄⵉⴼⴼⴻⵎ ⵣⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓ ⵣⵉ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK36_32","027_36_32","EZK","36","32","32","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⴳⴳⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵙⵏⴻⵎ ⵜⵜ ⵎⵍⵉⵃ! ⵙⴻⴹⵃⴰⵎ ⵓ ⵙⵙⵏⴻⵎ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EK36_33","027_36_33","EZK","36","33","33","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵡⴻⵎ, ⴰⴷ ⵙⵙⵣⴻⴷⵖⴻⵖ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⴱⵏⵉⵖ ⵄⴰⵡⴻⴷ ⵍⵅⵉⵔⴱⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK36_34","027_36_34","EZK","36","34","34","ⵜⴰⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵣ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵜ ⵉⵥⴻⴽⴽⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK36_35","027_36_35","EZK","36","35","35","ⴰⴷ ⵉⵏⵉⵏ: ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⵄⴰⴷⵏ ⵓ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵜⵜⵡⴰⵅⴰⵔⵔⴰⴱⴻⵏⵜ ⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ ⴷ ⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏⵜ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵏⵜ ⵓ ⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵎⴻⵣⴷⴰⵖ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK36_36","027_36_36","EZK","36","36","36","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴰⴷ ⴱⵏⵉⵖ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ ⵄⴰⵡⴻⴷ ⵓ ⴰⴷ ⵥⵥⵓⵖ ⵅ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⵉⵡⵍⴻⵖ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴳⴳⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK36_37","027_36_37","EZK","36","37","37","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴰⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵍⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜ ⴳⴳⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴰⵔⵏⵉⵖ ⵉⵡⴷⴰⵏ, ⴰⵍⴰⵎⵉ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⴰⵏⴻⵛⵜ ⵏ ⵉⵡⴷⴰⵏ ⴰⵎ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("EK36_38","027_36_38","EZK","36","38","38","ⴰⵏⴻⵛⵜ ⵉⴵⴰⵏ ⵏ ⵡⵓⴵⵉ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵡⵓⴵⵉ ⵉ ⵛⵛⵓⵔⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵍⵉⵏⵜ ⵜⵏⴻⴷⴷⴰⵎ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵡⵓⴵⵉ ⴷ ⵉⵡⴷⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK37_1","027_37_1","EZK","37","1","1","ⵜⵓⵖⴰ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵅⴰⴼⵉ ⵓⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ-ⴷⴷ ⴷⵉ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵢⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵡⴹⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴻⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵖⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK37_2","027_37_2","EZK","37","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵖⵙⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵡⴹⴰ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵓⵥⵖⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK37_3","027_37_3","EZK","37","3","3","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵉⵖⵙⴰⵏ-ⴰ ⵄⴰⵡⴻⴷ?” ⵏⵏⵉⵖ ⵏⴻⵛⵛ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜ!” ");
INSERT INTO rift_vpl VALUES ("EK37_4","027_37_4","EZK","37","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵏⴰⴱⴱ ⵅ ⵢⴻⵖⵙⴰⵏ-ⴰ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰ ⵉⵖⵙⴰⵏ ⵓⵥⵖⴻⵏ, ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK37_5","027_37_5","EZK","37","5","5","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉ ⵉⵖⵙⴰⵏ-ⴰ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵙⵙⵉⴷⴼⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK37_6","027_37_6","EZK","37","6","6","ⴰⴷ ⵅⴰⵡⴻⵎ ⴳⴳⴻⵖ ⵉⵥⴻⵡⵔⴰⵏ ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⵢⵙⵓⵎ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⵍⴻⵖ ⵙ ⵉⵍⴻⵎ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⴳⴳⴻⵖ ⴱⵓⵃⴱⴻⵍ, ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK37_7","027_37_7","EZK","37","7","7","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵡⴻⵚⵚⴰ, ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⴻⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵊⵉⵜ ⵓⵛⴰ ⵉⵖⵙⴰⵏ ⵎⵓⵏⴻⵏ, ⴽⵓⵍ ⵉⵖⴻⵙ ⴰⴽ-ⴷ ⵉⵖⴻⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK37_8","027_37_8","EZK","37","8","8","ⵥⵍⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏ ⵅⴰⵙⴻⵏ-ⴷⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵓ ⵢⵓⵍⵉ ⵅⴰⵙⴻⵏ ⵡⴻⵢⵙⵓⵎ ⵓ ⵏⴻⵜⵜⴰ ⵉⴷⵍⴰ ⵉ-ⵜⴻⵏ ⵙ ⵢⵉⵍⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⵓⵖⵉ ⵄⴰⴷ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK37_9","027_37_9","EZK","37","9","9","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵏⴰⴱⴱ ⵉ ⴰⵔⵔⵓⵃ, ⵏⴰⴱⴱ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵛⴰ ⵉⵏⵉ ⵉ ⴰⵔⵔⵓⵃ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴰⵙ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⴰ ⴰⵔⵔⵓⵃ, ⵓ ⵙⵓⴹ ⴷⴻⴳ ⵉⵏⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK37_10","027_37_10","EZK","37","10","10","ⵅⴻⵏⵏⵉ ⵏⴰⴱⴱⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵡⴻⵚⵚⴰ. ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⴰⵔⵔⵓⵃ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⴷⴷⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK37_11","027_37_11","EZK","37","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵖⵙⴰⵏ-ⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵉⵖⵙⴰⵏ ⵏⵏⴻⵖ ⵓⵥⵖⴻⵏ ⵓⵛⴰ ⵍⴰⵢⴰⵙ ⵏⵏⴻⵖ ⵉⵡⴻⴷⴷⴰⵔ ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵇⴹⴻⵄ!’ ");
INSERT INTO rift_vpl VALUES ("EK37_12","027_37_12","EZK","37","12","12","ⵙ ⵓⵢⴰ, ⵏⴰⴱⴱ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵣⵎⴻⵖ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵡⴻⵎ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵡⴻⵎ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵖ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK37_13","027_37_13","EZK","37","13","13","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⵓⵎⵉ ⴰⵔⵣⵎⴻⵖ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵡⴻⵎ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK37_14","027_37_14","EZK","37","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⴷⴰⵢⵡⴻⵎ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴰⵔⵙⴻⵖ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵙⵙⵉⵡⵍⴻⵖ ⵓⵛⴰ ⴳⴳⵉⵖ ⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK37_15","027_37_15","EZK","37","15","15","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK37_16","027_37_16","EZK","37","16","16","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⴰⴹ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓⵛⴰ ⴰⵔⵉ ⴷⴰⵢⴻⵙ: ‘ⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵉ ⴰⵔⵔⴰⵡ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ!’ ⴽⵙⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⵣⴻⴵⴰⴹ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⵔⵉ ⴷⴰⵢⴻⵙ: ‘ⵉ ⵢⵓⵙⵓⴼ, ⴰⵣⴻⴵⴰⴷ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("EK37_17","027_37_17","EZK","37","17","17","ⵙⵎⵓⵏ ⵜⴻⵏ ⵅⴻⵏⵏⵉ ⵉⵊⵊ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⴰⴹ ⵉ ⵛⴻⴽ. ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵊⵊ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK37_18","027_37_18","EZK","37","18","18","ⵅⵎⵉ ⴽⵉⴽ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵜⴰⵔⵡⴰ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵎⴰ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵉⵏⵉⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⵛⴻⴽ?’, ");
INSERT INTO rift_vpl VALUES ("EK37_19","027_37_19","EZK","37","19","19","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⵙⵉⵖ ⴰⵣⴻⴵⴰⴹ ⵏ ⵢⵓⵙⵓⴼ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⴰⵣⴻⴵⴰⴹ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⴰⴽ-ⴷ ⵓⵣⴻⴵⴰⴹ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⴵⴰⴹ ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵊⵊ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("EK37_20","027_37_20","EZK","37","20","20","ⵉⵣⴻⴵⴰⴹⴻⵏ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵉ ⵅ ⵜⵓⵔⵉⴷ, ⴰⴷ ⵉⵍⵉⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK37_21","027_37_21","EZK","37","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵟⵟⴼⴻⵖ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏⵉ ⵖⴰⵔ ⵓⵢⵓⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵣⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK37_22","027_37_22","EZK","37","22","22","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜⵜⵡⴰⴱⴹⴰⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK37_23","027_37_23","EZK","37","23","23","ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵙ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵉ ⴷⵉ ⵅⴹⵉⵏ ⵏⵉⵜⵏⵉ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⵣⴻⴷⴳⴻⵖ. ⵅⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EK37_24","027_37_24","EZK","37","24","24","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⵉ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴹⴼⴰⵔⴻⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵃⴹⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴳⴳⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("EK37_25","027_37_25","EZK","37","25","25","ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵢⴰⵄⵇⵓⴱ, ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵡⴰⵀ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⴷⴰⵡⵓⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK37_26","027_37_26","EZK","37","26","26","ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵇⴻⴹⵄⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵍⴻⵀⵏⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴱⴰⵔⴽⴻⵖ ⵓ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴰⵔⵏⵉⵖ ⴰⵟⵟⴰⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK37_27","027_37_27","EZK","37","27","27","ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("EK37_28","027_37_28","EZK","37","28","28","ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵉⵙⵔⴰⵉⵍ ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK38_1","027_38_1","EZK","38","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("EK38_2","027_38_2","EZK","38","2","2","“ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵔⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵖⴰⵔ ⵀⴰⵊⵓⵊ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⴰⵊⵓⵊ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵔⵓⵛ, ⵎⴰⵛⵉⴽ ⴷ ⵜⵓⴱⴰⵍ, ⵓⵛⴰ ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵏⵏⴻⵙ,    ");
INSERT INTO rift_vpl VALUES ("EK38_3","027_38_3","EZK","38","3","3","ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴹⵉⴷⴷ ⵏⵏⴻⵛ, ⴰ ⵀⴰⵊⵓⵊ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵔⵓⵛ, ⵎⴰⵛⵉⴽ ⴷ ⵜⵓⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK38_4","027_38_4","EZK","38","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵇⴻⵎⵎⵄⴻⵖ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⴷⴻⴳ ⵉⵇⴰⴱⵙⵉⵡⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⵓⴼⴼⵖⴻⵖ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵛ, ⵉⵢⵙⴰⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ, ⵎⴰⵔⵔⴰ ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ, ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ, ⵙ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EK38_5","027_38_5","EZK","38","5","5","ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ, ⵏ ⴽⵓⵛ ⵓ ⵏ ⴼⵓⵟ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵙ ⵜⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⴷ ⵍⴽⴰⵙⴽ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("EK38_6","027_38_6","EZK","38","6","6","ⵊⵓⵎⴰⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵓⵊⴰⵔⵎⴰ ⵣⵉ ⵟⵟⵔⵓⴼⴰ ⵏ ⵛⵛⴰⵎⴰⵍ ⵇⴰⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("EK38_7","027_38_7","EZK","38","7","7","ⵉⵍⵉ ⵜⵡⴻⵊⴷⴻⴷ ⵓ ⵙⴻⵡⵊⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏⵏⴻⵛ ⵏⵏⵉ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⵖⴰⵔⴻⴽ, ⵓ ⵉⵍⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK38_8","027_38_8","EZK","38","8","8","ⴰⵡⴰⵔⵏⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⵉⴷ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴻⴷⵍⴻⵏ ⵣⵉ ⵙⵙⵉⴼ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵍⵅⵉⵔⴱⴻⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⴰⵣⵉⵔⴰⵔ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵓ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵣⴻⴷⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK38_9","027_38_9","EZK","38","9","9","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⴷ ⴰⵎ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⴰⵎ ⵓⵙⴻⵢⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴷⵍⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴽⵉⴽ ⵉⴵⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("EK38_10","027_38_10","EZK","38","10","10","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⴷ ⴰⴷⴼⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⵅⴰⵔⵔⵚⴻⴷ ⴷⵉ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK38_11","027_38_11","EZK","38","11","11","ⴰⴷ ⵜⵉⵏⵉⴷ: ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵜⵏⴻⴷⴷⴰⵎ ⴱⵍⴰ ⵍⴻⵃⵢⵓⴹ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵖⴰⵔ ⵢⴻⵏⵏⵉ ⴷⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵀⵏⴰ ⵓ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵎⴰⵔⵔⴰ ⴱⵍⴰ ⵍⵃⵉⴹ ⵓ ⴱⵍⴰ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏⵉⵖ ⵜⵉⵡⵡⵓⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("EK38_12","027_38_12","EZK","38","12","12","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵖ ⵓ ⴰⴷ ⴰⵛⴰⵔⴻⵖ ⴰⴳⵍⴰ! ⵡⴰⵀ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵔⵔⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵅ ⵍⵅⵉⵔⴱⴰⵜ ⵏⵏⵉ ⴷⵉ ⵣⴻⴷⴷⵖⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵡⴷⴰⵏ, ⵅ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵡⴻⵏⵏⵉ ⵉⴽⴻⵙⴱⴻⵏ ⵍⵎⴰⵍ ⴷ ⵡⴰⴳⵍⴰ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵜⵄⴻⴱⴱⵓⴹⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK38_13","027_38_13","EZK","38","13","13","ⵛⴰⴱⴰ ⴷ ⴷⴰⴷⴰⵏ ⴷ ⵜⵜⵓⵊⴰⵔ ⵏ ⵜⴰⵔⵛⵉⵛ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⴰⵛ ⵉⵏⵉⵏ: ⵎⴰ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ? ⵎⴰ ⵜⴻⵙⵙⵎⵓⵏⴻⴷ ⴰⴳⵔⴰⵡ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴽⴻⵛⵛⴹⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵍⵎⴰⵍ ⴷ ⵡⴰⴳⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵛⴰⵔⴻⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ?’” ");
INSERT INTO rift_vpl VALUES ("EK38_14","027_38_14","EZK","38","14","14","“ⵙ ⵓⵢⴰ, ⵏⴰⴱⴱ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵛⴰ ⵉⵏⵉ ⵉ ⵀⴰⵊⵓⵊ ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵅⵎⵉ ⵖⴰ ⵉⵣⴷⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("EK38_15","027_38_15","EZK","38","15","15","ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ, ⵣⵉ ⵟⵟⵔⵓⴼⴰ ⵏ ⵛⵛⴰⵎⴰⵍ ⵇⴰⵄ, ⵛⴻⴽ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴽⵉⴷⴻⴽ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵙ ⵉⵢⵙⴰⵏ, ⵉⵊⵊ ⵏ ⵡⴻⴳⵔⴰⵡ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK38_16","027_38_16","EZK","38","16","16","ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⴷ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴷⵍⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ. ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵉⵡⴹⴻⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⴻⵏ, ⵅⵎⵉ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⴰ ⵀⴰⵊⵓⵊ!’ ");
INSERT INTO rift_vpl VALUES ("EK38_17","027_38_17","EZK","38","17","17","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵎⴰ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵅ ⵙⵙⵉⵡⵍⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵉⵛ, ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵍⵎⵉⵊⴰⵍ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵉⵡⴹⴻⵖ ⴹⵉⴷⴷ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("EK38_18","027_38_18","EZK","38","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵀⴰⵊⵓⵊ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⴷ ⵢⴰⵍⵉ ⵡⴻⵙⵄⴰⵔ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK38_19","027_38_19","EZK","38","19","19","ⴷⵉ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵉⵏⵓ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏⵏⵉⵖ: ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵎⴰⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EK38_20","027_38_20","EZK","38","20","20","ⴰⵍⴰⵎⵉ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ, ⵓ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵎⴻⵏⴹⴰⵔⴻⵏ ⵓ ⵍⴻⵊⵔⵓⴼ ⵉⵄⵓⴵⴻⵏ ⴰⴷ ⵀⵔⵓⵔⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵃⵢⵓⴹ ⴰⴷ ⵡⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK38_21","027_38_21","EZK","38","21","21","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵍⴰⵖⵉⵖ ⵅ ⵙⵙⵉⴼ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ⵙⵙⵉⴼ ⵏ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK38_22","027_38_22","EZK","38","22","22","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⵃⴻⴽⵎⴻⵖ ⵙ ⵟⵟⴰⵄⵓⵏ ⵓ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⴳⴳⴻⵖ ⵓ ⵅ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵓ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴽⵉⴷⴻⵙ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ, ⴰⵏⵥⴰⵔ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵉⴱⵇⵓⵇⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ ⴷ ⵜⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵛⴱⴰⵔⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EK38_23","027_38_23","EZK","38","23","23","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK39_1","027_39_1","EZK","39","1","1","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵏⴰⴱⴱ ⴹⵉⴷⴷ ⵉ ⵀⴰⵊⵓⵊ ⵓⵛⴰ ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵢⵉ ⵅⴰⴽ, ⴰ, ⵛⴻⴽ ⵀⴰⵊⵓⵊ, ⵍⵃⴰⴽⴻⵎ ⵏ ⵔⵓⵛ, ⵎⴰⵛⵉⴽ ⴷ ⵜⵓⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK39_2","027_39_2","EZK","39","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵓ ⴰⴷ ⴷⴰⵢⴻⴽ ⴳⴳⴻⵖ ⵜⵉⵙⴻⵏⵏⴰⵔⵉⵏ ⵓ ⴰⴷ ⵛⴻⴽ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵣⵉ ⵟⵟⵔⵓⴼⴰ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⴳⴻⵡⵡⴷⴻⵖ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK39_3","027_39_3","EZK","39","3","3","ⴰⴷ ⵡⵜⴻⵖ ⵍⵇⴻⵡⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⵣⴻⵍⵎⴰⴹ ⵓⵛⴰ ⴰⴷ ⵖⴻⴹⵍⴻⵖ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵛ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_4","027_39_4","EZK","39","4","4","ⴰⴷ ⵜⴻⵡⴹⵉⴷ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵛ ⴷ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⴽ. ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵛⴻⴽ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵊⴹⴰⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵓ ⵉ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("EK39_5","027_39_5","EZK","39","5","5","ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵜⴻⵡⴹⵉⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_6","027_39_6","EZK","39","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⵅ ⵎⴰⵊⵓⵊ ⵓ ⵅ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵙ ⵍⴻⵃⵏⴰ ⴷⵉ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_7","027_39_7","EZK","39","7","7","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴰⵏⴻⵖ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⵄⴰⴷ ⴰⴷ ⵙⵙⵅⴻⵎⵊⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK39_8","027_39_8","EZK","39","8","8","ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓ ⴰⴷ ⵉⵎⵙⴰⵔ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ⵡⴰ ⴷ ⴰⵙⵙ ⵏⵏⵉ ⵅ ⵙⵙⵉⵡⵍⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("EK39_9","027_39_9","EZK","39","9","9","“ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵙⵏⴰⵃ: ⴰⵎ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⴰⵎ ⵜⵙⴻⴷⴷⴰⵔⵉⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵓⵍⴰ ⴷ ⵍⵇⴻⵡⵙ ⴷ ⴼⵍⵉⵜⵛⴰⵜ ⴷ ⵉⵄⵓⵎⴰⴷ ⵉ ⵢⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⵃⵔⵉⵛⴻⵏ. ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_10","027_39_10","EZK","39","10","10","ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵡⵢⴻⵏ ⴰⴽⴻⵛⵛⵓⴹ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵓ ⵡⴰⵔ ⵜⵜⵇⴻⵙⵙⵉⵏ ⵜⴰⴼⵍⴰⵡⵜ ⵣⴻⴳ ⵉⵣⴻⵖⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵙ ⵍⴻⵙⵏⴰⵀ ⵓⵛⴰ ⴰⴷ ⴽⴻⵛⵛⴹⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⴽⴻⵛⵛⴹⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵛⴰⵔⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵢⵓⵛⴰⵔⴻⵏ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK39_11","027_39_11","EZK","39","11","11","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵖ ⴷⵉⵏ ⴰⵎⵛⴰⵏ ⵉ ⵀⴰⵊⵓⵊ ⵉⵊⵊ ⵏ ⵡⴻⵏⴹⴻⵍ ⴷⵉ ⵉⵙⵔⴰⵉⵍ, ⵍⴻⵡⴹⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵥⴻⴽⴽⵡⴰⵏ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓ ⵜⴰⵏⵉⵜⴰ ⴰⴷ ⵜⴱⴻⵍⵍⴻⵄ ⴰⴱⵔⵉⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵥⴻⴽⴽⵡⴰⵏ. ⴷⵉⵏ ⵉ ⵖⴰ ⵏⴻⴹⵍⴻⵏ ⵀⴰⵊⵓⵊ ⴷ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⴻⵙ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵓ ⴰⴷ ⵅⴰⵙ ⵍⴰⵖⴰⵏ: ⵍⴻⵡⴹⴰ ⵏ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵀⴰⵊⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("EK39_12","027_39_12","EZK","39","12","12","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⵏ ⵜⴻⵏⴹⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK39_13","027_39_13","EZK","39","13","13","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵏ ⵏⴻⴹⵍⴻⵏ ⵓⵛⴰ ⴰⵢⴰ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⵉ ⵛⵛⴰⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_14","027_39_14","EZK","39","14","14","‘ⴰⴷ ⴼⴰⵔⵣⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⵡⴰⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵎⵎⵓⵔⵜ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴹⵍⴻⵏ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⴽⴽⵉⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴱⵓⵣⵣⵍⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ⴰⵡⴰⵔⵏⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴰⴷ ⵇⴻⴵⴱⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_15","027_39_15","EZK","39","15","15","ⵉⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵥⵡⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵜ ⵥⵡⴰⵏ ⵓ ⵅⵎⵉ ⵉⵜⵜⵡⴰⵍⴰ ⵃⴻⴷ ⵉⵊⵊ ⵏ ⵢⵉⵖⴻⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵢⴻⴳⴳ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵍⵎⴰⵔⴽⴰ ⴰⵍ ⵜ ⵖⴰ ⵏⴻⴹⵍⴻⵏ ⵉⵏⵏⵉ ⵉⵏⴻⵟⵟⴰⵍⴻⵏ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ ⵏ ⵀⴰⵊⵓⵊ. ");
INSERT INTO rift_vpl VALUES ("EK39_16","027_39_16","EZK","39","16","16","ⵄⴰⵡⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉⵙⴻⵎ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ‘ⵍⵖⴰⵛⵉ ⵉⵏⵀⴻⵡⵍⴻⵏ’. ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵉⵣⴻⴷⴳⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EK39_17","027_39_17","EZK","39","17","17","“ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵉⵏⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵔⴽⴰⵜ ⵏ ⵉⵊⴹⴰⴹ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ: ⵎⵓⵏⴻⵎ-ⴷⴷ ⴷⴰ, ⴰⵙⴻⵎ-ⴷⴷ, ⵙⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵖⴰⵔ ⵜⵖⴰⵔⵚⵜ ⵉⵏⵓ ⵏⵏⵉ ⵖⴰⵔⵚⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵜⴰⵖⴰⵔⵚⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ, ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK39_18","027_39_18","EZK","39","18","18","ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⵓ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷⴻⵡⵙⴻⵏ ⴷⵉ ⴱⴰⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK39_19","027_39_19","EZK","39","19","19","ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⵜⴰⴷⵓⵏⵜ ⴰⵍ ⵖⴰ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⴰⵍ ⵖⴰ ⵜⴻⵙⵛⴰⵔⴻⵎ ⵣⵉ ⵜⵖⴰⵔⵚⵜ ⵉⵏⵓ ⵉ ⵖⴰⵔⵚⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("EK39_20","027_39_20","EZK","39","20","20","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ ⵙ ⵉⵢⵙⴰⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ, ⵙ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK39_21","027_39_21","EZK","39","21","21","ⴰⴷ ⴳⴳⴻⵖ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵥⴰⵔⴻⵏ ⵍⵃⵓⴽⵎ ⵉⵏⵓ ⵏⵏⵉ ⴳⴳⵉⵖ, ⵓⵍⴰ ⴷ ⴰⴼⵓⵙ ⵏⵏⵉ ⵊⴰⵔ ⴰⵙⴻⵏ ⵙⵙⴰⵔⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EK39_22","027_39_22","EZK","39","22","22","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⵙⵙⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓ ⵣⵉ ⵙⵙⴰ ⵜⵙⴰⵡⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK39_23","027_39_23","EZK","39","23","23","ⴰⴷ ⵙⵙⵏⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵇⴰ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵖⴻⴷⴷⴰⵔⴻⵏ ⴰⵢⵉ ⵓⵛⴰ ⵏⴻⵛⵛ ⴼⴼⴰⵔⴻⵖ ⵅⴰⵙⴻⵏ ⵓⴷⴻⵎ ⵉⵏⵓ ⵓⵛⴰ ⵡⵛⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵖⵔⵉⵎⴻⵏ ⵏⵙⴻⵏ ⵓ ⵅⴻⵏⵏⵉ ⵡⴹⴰⵏ ⵎⴰⵔⵔⴰ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EK39_24","027_39_24","EZK","39","24","24","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴰⵅⵎⵓⵊⵉ ⵏⵙⴻⵏ ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴼⴼⴰⵔⴻⵖ ⵣⵣⴰⵢⵙⴻⵏ ⵓⴷⴻⵎ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("EK39_25","027_39_25","EZK","39","25","25","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵍⴻⵅⵅⵓ ⴰⴷ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵉⵎⴻⵃⴱⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵃⵉⵏⵏⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵓⵙⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK39_26","027_39_26","EZK","39","26","26","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⵖⴹⴰⵔⴻⵏ ⵅⵎⵉ ⵏⵉⵜⵏⵉ ⵄⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵡⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵉⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK39_27","027_39_27","EZK","39","27","27","ⵅⵎⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵖ ⵣⵣⴰⵢⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("EK39_28","027_39_28","EZK","39","28","28","ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵏⴻⴷⵀⴻⵖ ⵜⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵏⴻⵛⵛ ⵙⵙⵎⵓⵏⴻⵖ ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵊⵊⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK39_29","027_39_29","EZK","39","29","29","ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵜⴻⴼⴼⴰⵔⴻⵖ ⵄⴰⴷ ⵓⴷⴻⵎ ⵉⵏⵓ, ⵅⵎⵉ ⴰⵇⴰ ⵙⵙⴼⴰⵔⵔⵖⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK40_1","027_40_1","EZK","40","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏⵏⴻⵖ, ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⵓⵢⵓⵔ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⵡⵜⵉⵏ ⵜⴰⵏⴷⵉⵏⵜ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵏⵉⵜ, ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵅⴰⴼⵉ ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_2","027_40_2","EZK","40","2","2","ⴷⵉ ⵉⵡⴻⵃⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵢⵉ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⵎⵉⵅⴻⴼ ⵜⵓⵖⴰ ⵛⴰ ⵏ ⵍⴻⴱⵏⵉ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK40_3","027_40_3","EZK","40","3","3","ⵢⵉⵡⵢⵉ ⴰⵢⵉ ⴷⵉⵏ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵙ ⴰⵎ ⵚⵚⵉⴼⴻⵜ ⵏ ⵏⵏⵃⴰⵙ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵇⵟⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_4","027_40_4","EZK","40","4","4","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵅⵣⴰⵔ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ, ⵙⴻⵍ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⴰⵔⵙ ⵓⵍ ⵏⵏⴻⵛ ⵉ ⵎⴰⵔⵔⴰ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⴻⵛⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⵇⴻⴱⴷⴻⴷ ⵖⴰⵔ ⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵙⵙⴻⵛⵏⴻⵖ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵡⴰⵍⵉⴷ, ⵉⵏⵉ ⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("EK40_5","027_40_5","EZK","40","5","5","ⵅⵣⴰⵔ, ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴽⵓⵍⵛⵉ. ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵔⵢⴰⵣ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔ ⵏ ⵓⴼⵓⵙ. ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⵜⵉⵔⵓ ⵏ ⵍⵃⵉⴹ ⵏⵏⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ, ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK40_6","027_40_6","EZK","40","6","6","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵅ ⴷⴷⵔⵓⵊ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵓ ⵜⵉⵔⵓ ⵏ ⵜⵏⴻⴱⴷⴰⵜ ⵏⵏⴻⵖⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_7","027_40_7","EZK","40","7","7","ⵜⵓⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵅⵅⴰⵎⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ. ⵊⴰⵔ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK40_8","027_40_8","EZK","40","8","8","ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⴰⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK40_9","027_40_9","EZK","40","9","9","ⵉⵄⴱⴰⵔ ⴰⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⴰⵙⵇⵉⴼ ⵏ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_10","027_40_10","EZK","40","10","10","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵜⵍⴰⵜⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵖⴰⵔⵙⴻⵏⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵄⴱⴰⵔ. ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴷ ⵖⴰⵔⵙⴻⵏ ⴷ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_11","027_40_11","EZK","40","11","11","ⵉⵄⴱⴰⵔ ⵜⵉⵔⵓ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵍⴰ ⴷ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵜⵍⴻⵟⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_12","027_40_12","EZK","40","12","12","ⵜⵜⴰⵙⵉⵄ ⵣⵣⴰⵜ ⵉ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓⵛⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴰⵙⵉⵄ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ. ⵉⵛⵜ ⵏ ⵜⴻⵅⵅⴰⵎⵜ ⵖⴰⵔⴻⵙ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⴷ ⵙⴻⵜⵜⴰ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_13","027_40_13","EZK","40","13","13","ⵉⵄⴱⴰⵔ ⵄⴰⵡⴻⴷ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵣⵉ ⵜⵣⴻⵇⵇⴰ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵅⵅⴰⵎⵜ ⴰⵍ ⵜⴰⵣⴻⵇⵇⴰ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴰⴷⴰⴼ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵡⴰⴷⴰⴼ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_14","027_40_14","EZK","40","14","14","ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵍⴻⵄⴱⴰⵔ ⵖⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ: ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵍⴻⵎⵔⴰⵃ ⵉⴽⴽⴰ ⵅ ⵟⵟⴰⵔⴼ ⵏ ⵍⵃⵉⴹ, ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵍⴻⵎⵔⴰⵃ ⵉ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK40_15","027_40_15","EZK","40","15","15","ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴰⴷⴰⴼ ⴰⵍ ⵣⵣⴰⵜ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴷⴰⵅⴻⵍ, ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_16","027_40_16","EZK","40","16","16","ⵜⵓⵖⴰ ⵍⴻⴽⵡⴰⵣⵉ ⵃⵚⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓ ⵖⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴷⴰⵅⴻⵍ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ, ⵓⵍⴰ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⴱⴰⵔⵔⴰ ⵓ ⵜⵓⵖⴰ ⵍⴻⴽⵡⴰⵣⵉ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓ ⵅ ⴽⵓⵍ ⵉⵊⵊ ⵣⵉ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⵜᵉⵜⵜⴰⴼⴻⴷ ⴷⵉⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_17","027_40_17","EZK","40","17","17","ⵉⵏⴷⴻⵀ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵅⵅⴰⵎⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵍⴻⵎⵔⴰⵃ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵖⴰⵔ ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_18","027_40_18","EZK","40","18","18","ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⵜⵓⵖⴰ-ⵜⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵜⴻⵇⵇⴻⵏ ⵏⵉⵛⴰⵏ ⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ⵜⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⵉⵙⵉ ⵏ ⵣⵣⴻⵍⵍⵉⵊ ⵉ ⵉⴵⴰⵏ ⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("EK40_19","027_40_19","EZK","40","19","19","ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⵜⵉⵔⵓ ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ ⵏ ⵍⴻⵎⵔⴰⵃ ⴰⵍ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ, ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵉⵄⴱⴰⵔ ⵛⵛⴰⵔⵇ ⴷ ⵛⵛⴰⵎⴰⵍ ⵏ ⵍⴻⵎⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EK40_20","027_40_20","EZK","40","20","20","ⵣⵉ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⵉⵄⴱⴰⵔ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK40_21","027_40_21","EZK","40","21","21","ⵜⵓⵖⴰ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⴷ ⵜⵍⴰⵜⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⴷ ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ ⵏ ⵍⵃⵉⴹ ⵓⵍⴰ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⴷ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_22","027_40_22","EZK","40","22","22","ⵍⴻⴽⵡⴰⵣⵉ ⵏⵏⴻⵙ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵓⵍⴰ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⴻⵙ ⵏ ⵜⵉⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔⴻⵙ ⵅ ⵉⵊⵊ ⵏ ⴷⴷⵔⵓⵊ ⴰⴽ-ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵓⵛⴰ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_23","027_40_23","EZK","40","23","23","ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵜⵓⵖⴰ-ⵜⵜ ⵣⵣⴰⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⴷ ⵜⴻⵏⵏⵉ ⵏ ⵛⵛⴰⵔⵇ. ⵣⴻⴳ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⴰⵔⵔⴰ ⴰⵍ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴷⴰⵅⴻⵍ ⵉⵄⴱⴰⵔ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_24","027_40_24","EZK","40","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵓ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ⵉⵄⴱⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵍⴻⵄⴱⵓⵔⴰⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EK40_25","027_40_25","EZK","40","25","25","ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔⴻⵙ ⵍⴻⴽⵡⴰⵣⵉ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏ ⴱⴰⵔⵔⴰ ⴷⴰⵢⵙⴻⵏ ⵍⴻⴽⵡⴰⵣⵉ ⴰⵎ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_26","027_40_26","EZK","40","26","26","ⴷⵔⵓⵊⵊ ⴷⴰⵢⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵓ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵏⵉ ⵅ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ, ⵉⵛⵜⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵉⵛⵜⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_27","027_40_27","EZK","40","27","27","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ⵉⵄⴱⴰⵔ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴰⵍ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ: ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_28","027_40_28","EZK","40","28","28","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ. ⵉⵄⴱⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵜⵓⵖⴰ ⵍⴻⵄⴱⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_29","027_40_29","EZK","40","29","29","ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⴷ ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ ⵏ ⵍⵃⵉⴹ ⵓⵍⴰ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⴷ ⵍⴻⵄⴱⵓⵔⴰⵜ ⴷ ⵉⵊⵊⴻⵏ. ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⴻⴽⵡⴰⵣⵉ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴽⵡⴰⵣⵉ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵜⵉⵏⵏⵉ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_30","027_40_30","EZK","40","30","30","ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵍⴻⵃⵢⵓⴹ ⵏ ⴱⴰⵔⵔⴰ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷⵉ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_31","027_40_31","EZK","40","31","31","ⵜⵓⵖⴰ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵅ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⵓ ⴷⴷⵔⵓⵊ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_32","027_40_32","EZK","40","32","32","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ. ⵉⵄⴱⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵜⵓⵖⴰ ⵍⴻⵄⴱⵓⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_33","027_40_33","EZK","40","33","33","ⵜⵉⵅⵅⴰⵎⵉⵏ ⵏⵏⴻⵙ ⴷ ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ ⵏ ⵍⵃⵉⴹ ⵓⵍⴰ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⴷ ⵍⴻⵄⴱⵓⵔⴰⵜ ⴷ ⵉⵊⵊⴻⵏ. ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵍⴻⴽⵡⴰⵣⵉ ⵓⵛⴰ ⵓⵍⴰ ⵖⴰⵔ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵉ ⴷⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴹⴻⵏ ⵎⴰⵔⵔⴰ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_34","027_40_34","EZK","40","34","34","ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵅ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⵏⵏⴻⵙ, ⴰⵎ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓⵍⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⵓ ⴷⴷⵔⵓⵊ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_35","027_40_35","EZK","40","35","35","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵅⴻⵏⵏⵉ ⵍⴻⵄⴱⵓⵔⴰⵜ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_36","027_40_36","EZK","40","36","36","ⵜⵉⵅⵅⴰⵎⵉⵏ ⵏⵏⴻⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴷ ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ ⵏ ⵍⵃⵉⴷ ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⴽⵡⴰⵣⵉ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵙⴻⵏ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_37","027_40_37","EZK","40","37","37","ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ ⵏ ⵍⵃⵉⴹ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵅ ⵍⴻⴹⵔⵓⴼ ⵏⵏⴻⵙ. ⴷⴷⵔⵓⵊ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_38","027_40_38","EZK","40","38","38","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵅⵅⴰⵎ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⴷ ⴷⵉⵏ ⵙⵙⵉⵔⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("EK40_39","027_40_39","EZK","40","39","39","ⴷⵉ ⴷⴰⵅⴻⵍ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⴰⴱⵍⴰⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⴰⴱⵍⴰⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏⵜ ⵖⴰⵔⵚⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK40_40","027_40_40","EZK","40","40","40","ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵖⴰⵔ ⵎⴰⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⴰⴱⵍⴰⵜ, ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵟⵟⴰⴱⵍⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_41","027_40_41","EZK","40","41","41","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵟⵟⴰⴱⵍⴰⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⴰⵔⴻⴱⵄⴰ ⵏ ⵟⵟⴰⴱⵍⴰⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵎⴻⵏⵢⴰ ⵏ ⵟⵟⴰⴱⵍⴰⵜ ⵉ ⵎⵉⵏ ⵅⴻⴼ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_42","027_40_42","EZK","40","42","42","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵟⵟⴰⴱⵍⴰⵜ ⵣⵉ ⵜⵚⵓⴹⴰⵔ ⵉⵜⵜⵡⴰⵏⴻⵇⵛⴻⵏ ⵖⴰⵔ ⴷⴷⵔⵓⵊ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏ ⵟⵟⴰⴱⵍⴰ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵡⴻⵣⵢⴻⵏ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ. ⵎⵎⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵍⴻⵇⵛⵓⵄ ⵉ ⵣⵉ ⵖⴰⵔⵔⵚⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_43","027_40_43","EZK","40","43","43","ⵜⴰⵔⵢⵉⵡⵉⵏ ⵏ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔ ⵏ ⵓⴼⵓⵙ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵓ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵎⵎⴰⵔⵙⴻⵏ ⴰⵢⵙⵓⵎ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵅ ⵟⵟⴰⴱⵍⴰⵜ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK40_44","027_40_44","EZK","40","44","44","ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴷⴰⵅⴻⵍ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵅⵅⴰⵎⵉⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ. ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵣⵣⴰⵜ ⵜⵓⵖⴰ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ⵜⴰⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵔⵇ ⵜⵓⵖⴰ ⵜⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK40_45","027_40_45","EZK","40","45","45","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ: “ⵜⴰⵅⵅⴰⵎⵜ-ⴰ ⵏⵏⵉ ⵣⵉ ⵉⵅⴻⵣⵣⴰⵔ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⴰⵇⴰ-ⵜⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_46","027_40_46","EZK","40","46","46","ⵜⴰⵅⵅⴰⵎⵜ ⵏⵏⵉ ⵜⵅⴻⵣⵣⴰⵔ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⴰⵇⴰ-ⵜⵜ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ⵏⵉⵜⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⵚⴰⴷⵓⵇ ⵏⵏⵉ ⵖⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK40_47","027_40_47","EZK","40","47","47","ⵉⵄⴱⴰⵔ ⵍⴻⵎⵔⴰⵃ: ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵉⵊⵊ ⵏ ⵓⴽⵡⴰⴷⵔⵓⵏ. ⴰⵄⴰⵍⵜⴰⵔ ⵜⵓⵖⴰ-ⵜ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK40_48","027_40_48","EZK","40","48","48","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵉ ⴰⵢⵉ ⵖⴰⵔ ⵡⴻⵙⵇⵉⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ ⵏ ⵡⴻⵙⵇⵉⴼ, ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⵓⵍⴰ ⴷ ⵜⵉⵔⵓ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK40_49","027_40_49","EZK","40","49","49","ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⵏ ⵡⴻⵙⵇⵉⴼ ⵜⵓⵖⴰ-ⵜⵜ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵃⵉⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵔⴻⴼⴼⵉⴷⵉⵏ ⵏ ⴷⴷⵔⵓⵊ ⵉ ⵣⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵖⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ, ⵉⵊⵊ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵉⵊⵊ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. * ");
INSERT INTO rift_vpl VALUES ("EK41_1","027_41_1","EZK","41","1","1","ⵏⴻⵜⵜⴰ ⵢⵉⵡⵉ ⴰⵢⵉ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵍⴻⴹⵔⵓⴼ ⵏ ⵍⵃⵉⴹ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⵅ ⵜⵉⵔⵓ ⵏ ⵓⵇⵉⴹⵓⵏ. * ");
INSERT INTO rift_vpl VALUES ("EK41_2","027_41_2","EZK","41","2","2","ⵜⵉⵔⵓ ⵏ ⵡⴰⴷⴰⴼ ⵜⵓⵖⴰ-ⵜⵜ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵓⴷⵎⴰⵡⴻⵏ ⵏ ⵍⴻⵃⵢⵓⴹ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴰⴷⴰⴼ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ⵉⵄⴱⴰⵔ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ: ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵜⵉⵔⵓ ⵏⵏⴻⵙ: ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK41_3","027_41_3","EZK","41","3","3","ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵍⵃⵉⴹ ⵏⵏⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵡⴰⴷⴰⴼ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵜⵉⵔⵓ ⵏ ⵡⴰⴷⴰⴼ ⵙⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK41_4","027_41_4","EZK","41","4","4","ⵉⵄⴱⴰⵔ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ: ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵜⵉⵔⵓ ⵏⵏⴻⵙ: ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵡⴻⵅⵅⴰⵎ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵡⴰ ⴷ ⴰⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("EK41_5","027_41_5","EZK","41","5","5","ⵉⵄⴱⴰⵔ ⵍⵃⵉⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ: ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵜⵉⵔⵓ ⵏ ⴽⵓⵍ ⴰⵅⵅⴰⵎ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK41_6","027_41_6","EZK","41","6","6","ⵜⵉⵅⵅⴰⵎⵉⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵜⴰⵅⵅⴰⵎⵜ ⵣⵣⴰⵜ ⵉ ⵜⴻⵅⵅⴰⵎⵜ ⵏⵏⴻⵖⵏⵉ, ⵜⵍⴰⵜⴰ ⴷⵉ ⵍⵓⵄⵍⴰ, ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵅⵅⴰⵎⵜ. ⵓⵛⴰ ⵜⵉⵅⵅⴰⵎⵉⵏ ⵏⵏⵉ ⵉⵡⴹⴻⵏⵜ ⴰⵍ ⵍⵃⵉⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵉ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⴰⵙⴻⵏⵏⴻⴷ ⵉ ⵜⵃⴻⵏⵢⴰ ⵏ ⵜⴻⵅⵅⴰⵎⵉⵏ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⵡⴹⴻⵏⵜ ⵜⵃⴻⵏⵢⴰ ⴰⵍ ⴷⴰⵅⴻⵍ ⴷⵉ ⵍⵃⵉⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK41_7","027_41_7","EZK","41","7","7","ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵉⵎⵎⴰⵔⵏⵉ ⴷⵉ ⵜⵜⴰⵙⵉⵄ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵅ ⴽⵓⵍ ⵟⵟⴻⴱⵇⴻⵜ ⵎⴰⵖⴰⵔ ⵅ ⴽⵓⵍ ⵟⵟⴻⴱⵇⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵏⴻⴹ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⴽⵓⵍⵡⴰⵔ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵔⵔⴰ. ⵅ ⵓⵢⴰ ⵜⴻⴷⵡⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⴷⴰⵢⴻⵙ ⵜⵜⴰⵙⵉⵄ ⴽⵜⴰⵔ ⵙⴻⵏⵏⴻⵊ ⵓ ⴰⵎⵎⵓ ⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⴻⴳ ⵡⴰⴷⴷⴰⵢ ⵖⴰⵔ ⵟⵟⴻⴱⵇⴻⵜ ⵙⴻⵏⵏⴻⵊ ⵙ ⵟⵟⴻⴱⵇⴻⵜ ⵏ ⵍⵡⴻⵙⵟ. ");
INSERT INTO rift_vpl VALUES ("EK41_8","027_41_8","EZK","41","8","8","ⵥⵔⵉⵖ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴷⵙⵓⵙⴰ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ: ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵉⴽⴻⵎⵎⵍⴻⵏ, ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴰⵍ ⵎⴰⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⵉⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK41_9","027_41_9","EZK","41","9","9","ⵜⵉⵔⵓ ⵏ ⵍⵃⵉⴹ ⵏⵏⵉ ⵉⴳⴳⴰ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⴱⴰⵔⵔⴰ ⵏ ⵍⴻⴱⵏⵉ ⴰⴽ-ⴷ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ, ⵜⵓⵖⴰ-ⵜⵜ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⵜⴰⵙⵉⵄ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⴰⴽ-ⴷ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ, ⵜⵜⴰⵙⵉⵄ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ-ⴷⴷ ⴰⴽ-ⴷ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK41_10","027_41_10","EZK","41","10","10","ⵓⵛⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵜⵜⴰⵙⵉⵄ ⵊⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⴷⵉ ⵍⴻⵎⵍⴰⵃ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴷ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK41_11","027_41_11","EZK","41","11","11","ⵜⴻⴼⴼⴻⵖ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵖⴰⵔ ⵜⵜⴰⵙⵉⵄ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵓⵛⴰ ⵜⴰⵡⵡⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ ⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ⵜⵉⵔⵓ ⵏ ⵜⵜⴰⵙⵉⵄ ⵉⵇⵇⵉⵎⴻⵏ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK41_12","027_41_12","EZK","41","12","12","ⵍⴻⴱⵏⵉ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵍⵃⵉⴹ ⵏ ⵍⴻⴱⵏⵉ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵅⴻⵎⵙⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK41_13","027_41_13","EZK","41","13","13","ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ: ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⴷ ⵍⴻⴱⵏⵉ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴷ ⵉⵛⵜ: ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK41_14","027_41_14","EZK","41","14","14","ⴰⵎ ⵜⵉⵔⵓ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵏ ⴹⴻⴼⴼⴰⵔ ⴰⵎ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵏ ⵛⵛⴰⵔⵇ ⵜⵓⵖⴰ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK41_15","027_41_15","EZK","41","15","15","ⵉⵄⴱⴰⵔ ⵓⵍⴰ ⴷ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵍⴻⴱⵏⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⴰⵍ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ. ⵉⴽⵓⵍⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵎⵢⴰ ⵏ ⵓⵖⵉⵍ. ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵙⵇⵉⴼⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("EK41_16","027_41_16","EZK","41","16","16","ⵜⵉⵏⴻⴱⴷⴰⵜⵉⵏ ⴷ ⵍⴻⴽⵡⴰⵣⵉ ⵉⵃⵚⴰⵔⴻⵏ ⴷ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵙ ⵉⴽⵓⵍⵡⴰⵔⴻⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⴼⵡⴰⵇⵉ ⵏⵙⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵜⵏⴻⴱⴷⴰⵜⵉⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ, ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴷⵓⵔⵉ ⵙ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴷ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵍⴻⴽⵡⴰⵣⵉ ⵓⵛⴰ ⵍⴻⴽⵡⴰⵣⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⵙⴷⵓⵔⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK41_17","027_41_17","EZK","41","17","17","ⵅ ⵡⵓⴷⴻⵎ ⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⴷⴰⴼ, ⴰⵎ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⴷⴰⵅⴻⵍ ⴰⵎ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⴱⴰⵔⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⵃⵉⴹ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵍⵡⵉⵃⵉⵏ ⵏ ⵓⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("EK41_18","027_41_18","EZK","41","18","18","ⵜⵓⵖⴰ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵅⴰⵙⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ. ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ ⵊⴰⵔ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⵉⵔⵓⴱ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴽⵓⵍ ⴰⴽⵉⵔⵓⴱ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("EK41_19","027_41_19","EZK","41","19","19","ⵓⴷⴻⵎ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⴷ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵉⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ⴰⵎⵎⵓ ⵉ ⵜⴻⵏ ⴳⴳⵉⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK41_20","027_41_20","EZK","41","20","20","ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵙⴻⵏⵏⴻⵊ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵅ ⵍⵃⵉⴹ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK41_21","027_41_21","EZK","41","21","21","ⵍⴻⴹⵔⵓⴼ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⴽⵡⴰⴷⵔⵓⵏ ⵓⵛⴰ ⵛⵛⵓⴼ ⵏ ⵓⵇⴻⴷⴷⴰⵙ ⵉⴹⵀⴰⵔ-ⴷⴷ ⴰⵎ ⵛⵛⵓⴼ ⵏ ⵣⵣⴰⵡⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EK41_22","027_41_22","EZK","41","22","22","ⴰⵄⴰⵍⵟⴰⵔ ⵜⵓⵖⴰ-ⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵍⴻⴱⵏⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ. ⵖⴰⵔⴻⵙ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⵓⵛⴰ ⵍⴻⴱⵏⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ: “ⵜⴰ ⴷ ⵜⴰⵣⴻⵡⴹⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK41_23","027_41_23","EZK","41","23","23","ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵡⴻⵇⴷⴰⵙ ⵖⴰⵔⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵡⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK41_24","027_41_24","EZK","41","24","24","ⵜⵓⵖⴰ ⵖⴰⵔ ⵜⵉⵡⵡⵓⵔⴰ, ⵖⴰⵔ ⴽⵓⵍ ⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⴰⵎ ⵡⴰⴼⵔⵉⵡⴻⵏ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵏⵓⵇⵇⴰⵔⴻⵏ, ⵜⵏⴰⵢⴻⵏ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓ ⵜⵏⴰⵢⴻⵏ ⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK41_25","027_41_25","EZK","41","25","25","ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⴽⵉⵔⵓⴱⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵅ ⵍⴻⵃⵢⵓⴹ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴰⵙⵇⵉⴼⵜ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵡⴻⵙⵇⵉⴼ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK41_26","027_41_26","EZK","41","26","26","ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⴽⵡⴰⵣⵉ ⵃⵙⴰⵔⴻⵏ ⴷ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵉⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵡⴻⵙⵇⵉⴼ, ⵖⴰⵔ ⵉⵅⵅⴰⵎⴻⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵖⴰⵔ ⵜⴻⵙⵇⵉⴼⵉⵏ. * ");
INSERT INTO rift_vpl VALUES ("EK42_1","027_42_1","EZK","42","1","1","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ-ⴷⴷ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ. ⵏⴻⵜⵜⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("EK42_2","027_42_2","EZK","42","2","2","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⴷ ⴰⵣⵉⵔⴰⵔ ⵏ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵛⵛⴰⵎⴰⵍ, ⵎⴰⵛⴰ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK42_3","027_42_3","EZK","42","3","3","ⵜⵓⵖⴰ ⵍⴻⴱⵏⵉ ⵣⵣⴰⵜ ⵉ ⵜⵜⴰⵙⵉⵄ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵓ ⵣⵣⴰⵜ ⵉ ⵣⵣⴻⵍⵍⵉⵊ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ. ⵉⵊⵊ ⵏ ⵓⴽⵓⵍⵡⴰⵔ ⴰⴽ-ⴷ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵙⴻⵏⵏⴻⴷ ⵅ ⵓⴽⵓⵍⵡⴰⵔ ⵏⵏⴻⵖⵏⵉ, ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵟⵟⴻⴱⵇⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK42_4","027_42_4","EZK","42","4","4","ⵣⵣⴰⵜ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴽⵓⵍⵡⴰⵔ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵡⴰⴷⴰⴼ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK42_5","027_42_5","EZK","42","5","5","ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵙⴻⵏⵏⴻⵊ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵃⵚⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⴽⵓⵍⵡⴰⵔⴻⵏ ⴽⴽⵙⴻⵏ ⴽⵜⴰⵔ ⵜⵜⴰⵙⵉⵄ ⵣⵣⴰⵢⵙⴻⵏ ⵅ ⵢⴻⵅⵅⴰⵎⴻⵏ ⵏ ⵡⴰⴷⴷⴰⵢ ⵓ ⵅ ⵢⴻⵅⵅⴰⵎⴻⵏ ⵖⴰⵔ ⵍⵡⴻⵙⵜ ⵏ ⵍⴻⴱⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK42_6","027_42_6","EZK","42","6","6","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⴼⵡⴰⵇⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⴰⵎ ⵢⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵍⴻⵎⵔⴰⵃⴰⵜ. ⵅ ⵓⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵉⵅⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵃⵙⴰⵔⴻⵏ ⴽⵜⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⵏ ⵡⴰⴷⴷⴰⵢ ⴷ ⵢⵉⵏⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⴰⵎ ⵖⴰⵔⵙⴻⵏ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK42_7","027_42_7","EZK","42","7","7","ⵍⵃⵉⴹ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⴻⵅⵅⴰⵎⴻⵏ, ⵍⵃⵉⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ ⵣⵣⴰⵜ ⵉ ⵢⴻⵅⵅⴰⵎⴻⵏ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK42_8","027_42_8","EZK","42","8","8","ⵎⵉⵏⵣⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵎⵢⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK42_9","027_42_9","EZK","42","9","9","ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵉⵅⵅⴰⵎⴻⵏ-ⴰ ⵜⴻⴳⴳⵓⵔ ⵜⴻⴱⵔⵉⴷⵜ ⵣⵉ ⵛⵛⴰⵔⵇ ⵅⵎⵉ ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵡⴹⴻⴷ ⵣⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK42_10","027_42_10","EZK","42","10","10","ⵖⴰⵔ ⵜⵉⵔⵓ ⵏ ⵍⵃⵉⴹ ⵏ ⵍⴻⵎⵔⴰⵃ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵍⵃⵉⴹ ⵣⵣⴰⵜ ⵉ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵏⵉ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵉⵅⵅⴰⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EK42_11","027_42_11","EZK","42","11","11","ⵓⵛⴰ ⴰⴽⵓⵍⵡⴰⵔ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ ⵣⵣⴰⵜⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵎ ⵜⴻⵏⵏⵉ ⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ, ⴰⵏⴻⵛⵜ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⵏⴻⵛⵜ ⵜⵉⵔⵓ ⵓ ⵎⴰⵔⵔⴰ ⵓⴼⴼⵓⵖⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵎ ⵚⵚⴻⵏⵄⴰⵜ ⴷ ⵡⴰⴷⴰⴼⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵅⴰⵎⵎⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK42_12","027_42_12","EZK","42","12","12","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⵉⵏ ⴰⴷⴰⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵅⵅⴰⵎⵉⵏ ⵜⵉⵏⵏⵉ ⵉⵡⴻⵊⵊⵀⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⴰⵎⴻⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⴵⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⴱⴻⴷⴷⵓ ⵏ ⵜⴻⴱⵔⵉⴷⵜ, ⵜⴰⴱⵔⵉⴷⵜ ⵏⵏⵉ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵍⵃⵉⴷ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ ⵓⵛⴰ ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵉ ⵅ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵛⵛⴰⵔⵇ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK42_13","027_42_13","EZK","42","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵓ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵉⵜⵜⵡⴰⵄⴻⵣⵍⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵅⵅⴰⵎⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵎⴰⵏⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵛⵛⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵟⵟⴰⵙ. ⴷⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵙⴰⵔⵙⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵟⵟⴰⵙ: ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⵎⵉⵏⵣⵉ ⴰⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⴻⵙ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EK42_14","027_42_14","EZK","42","14","14","ⵅⵎⵉ ⵖⴰ ⵓⴷⴼⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ. ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ. ⴰⴷ ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵍⴳⴻⵏⵙ.” * ");
INSERT INTO rift_vpl VALUES ("EK42_15","027_42_15","EZK","42","15","15","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵏⴻⵜⵜⴰ ⵍⴻⵄⴱⴰⵔ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵙⵙⵓⴼⴼⵓⵖ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵉⴽⵙⵉ ⵍⴻⵄⴱⴰⵔ ⵏ ⵊⵊⵉⵀⴻⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EK42_16","027_42_16","EZK","42","16","16","ⵉⵄⴱⴰⵔ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵙ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ: ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵙ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("EK42_17","027_42_17","EZK","42","17","17","ⵉⵄⴱⴰⵔ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ, ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵙ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("EK42_18","027_42_18","EZK","42","18","18","ⵉⵄⴱⴰⵔ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵙ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK42_19","027_42_19","EZK","42","19","19","ⵉⵏⵓⵇⵇⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵙ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK42_20","027_42_20","EZK","42","20","20","ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴰⵔⵣ ⵊⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK43_1","027_43_1","EZK","43","1","1","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("EK43_2","027_43_2","EZK","43","2","2","ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴰⵎ ⵍⵀⴻⵙⵙ ⵏ ⵡⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵛⴻⵄⵛⴻⵄ ⵙ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK43_3","027_43_3","EZK","43","3","3","ⵓⴷⴻⵎ ⵏ ⵍⴻⵡⵃⵉⵢ ⵉ ⵥⵔⵉⵖ ⵜⵓⵖⴰ ⴰⵎ ⵍⴻⵡⵃⵉⵢ ⵉ ⵥⵔⵉⵖ ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ. ⴰⵇⴰ ⴷ ⵉⵡⴻⵃⵃⴰⵏ ⴰⵎ ⵍⴻⵡⵃⵉⵢ ⵉ ⵥⵔⵉⵖ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵅⴰⴱⵓⵔ, ⵓⵛⴰ ⵡⴹⵉⵖ ⵙ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK43_4","027_43_4","EZK","43","4","4","ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("EK43_5","027_43_5","EZK","43","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵢⵉ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵉⵙⵙⵉⴷⴻⴼ ⴰⵢⵉ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK43_6","027_43_6","EZK","43","6","6","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵉ ⵣⵉ ⴷⴰⵅⴻⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK43_7","027_43_7","EZK","43","7","7","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵡⴰ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵍⵄⴰⵔⵛ ⵉⵏⵓ ⵓ ⴰⵎⵛⴰⵏ ⵏ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ, ⵎⴰⵏⵉ ⵖⴰ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵍⴻⴱⴷⴰ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⵄⴰⴷ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ ⵓ ⵙ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏⵙⴻⵏ ⵎⴰⵏⵉ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EK43_8","027_43_8","EZK","43","8","8","ⴰⵎ ⴳⴳⵉⵏ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵏⴻⴱⴷⴰⵜ ⵉⵏⵓ, ⴷ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏⵙⴻⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉⵏⵓ, ⵉⵇⵇⵉⵎ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⵊⴰⵔ ⴰⵢⵉ-ⴷⴷ ⴷ ⵏⵉⵜⵏⵉ. ⴰⵎⵎⵓ ⵉ ⵙⵙⴻⵅⵎⴻⵊⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵙⴻⵏ ⵏⵏⵉ ⴳⴳⵉⵏ, ⴰⵍⴰⵎⵉ ⵛⵛⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK43_9","027_43_9","EZK","43","9","9","ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⴼⵉ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ ⴷ ⵍⵅⴻⵛⴱⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK43_10","027_43_10","EZK","43","10","10","ⵛⴻⴽ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵄⴱⴰⵔⴻⵏ ⵛⵛⴻⴽⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK43_11","027_43_11","EZK","43","11","11","ⵎⴰⵍⴰ ⵙⴻⴹⵃⴰⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵏ, ⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵅⴻⵏⵏⵉ ⵛⵛⴻⴽⵍ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵜⵉⵙⴰⵔⵙ ⵏⵏⴻⵙ, ⵓⴼⴼⵓⵖⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⴷⴰⴼⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵛⵛⴻⴽⵍ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵉⵛⴽⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵔⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵃⴹⴰⵏ ⵎⴰⵔⵔⴰ ⵛⵛⴻⴽⵍ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK43_12","027_43_12","EZK","43","12","12","“ⵜⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ: ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ. ⵜⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EK43_13","027_43_13","EZK","43","13","13","“ⵉⵏⴰ ⴷ ⵍⴻⵄⴱⵓⵔⴰⵜ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵙ ⵉⵖⴰⴵⴻⵏ: ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷ ⵉⵊⵊ ⵏ ⵛⴱⴰⵔ ⵏ ⵓⴼⵓⵙ. ⵜⴰⵔⵢⴰ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ. ⵜⵎⴰ ⵏⵏⴻⵙ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⵇⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ. ⵡⴰ ⴷ ⴷⵙⴰⵙ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK43_14","027_43_14","EZK","43","14","14","ⵣⵉ ⵜⴰⵔⵢⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵜⴰⵔⴻⴼⴼⵉⴷⴻⵜ ⵏ ⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵄⴰⵍⵟⴰⵔ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ: ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ, ⵓ ⵣⵉ ⵜⵔⴻⴼⴼⵉⴷⴻⵜ ⵏ ⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴰⵍ ⵜⴰⵔⴻⴼⴼⵉⴷⴻⵜ ⵏ ⵙⴻⵏⵏⴻⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ: ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK43_15","027_43_15","EZK","43","15","15","ⵍⴻⴱⵏⵉ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⴰⴷⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ’, ⵉⴳⴳⴰ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷⵉ ⵍⵓⵄⵍⴰ ⵓ ⵣⴻⴳ ⵓⴼⵓⵔⵏⵓ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK43_16","027_43_16","EZK","43","16","16","ⴰⴼⵓⵔⵏⵓ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵉⵊⵊ ⵏ ⵓⴽⵡⴰⴷⵔⵓⵏ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK43_17","027_43_17","EZK","43","17","17","ⵜⴰⵔⴻⴼⴼⵉⴷⴻⵜ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵖⴰⴵⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵜⵎⴰ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⵇⴰ ⴷ ⴰⵣⵢⴻⵏ ⵏ ⵓⵖⵉⵍ, ⵓⵛⴰ ⵜⴰⵔⵢⴰ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴰⵔⴻⴼⴼⵉⴷⵉⵏ ⵏ ⴷⴷⵔⵓⵊ ⵏⵏⴻⵙ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ.” * ");
INSERT INTO rift_vpl VALUES ("EK43_18","027_43_18","EZK","43","18","18","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵜⵉⵏⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜ ⵖⴰ ⴳⴳⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵣⴻⴵⵄⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("EK43_19","027_43_19","EZK","43","19","19","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴳ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⵉ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⵉ ⵚⴰⴷⵓⵇ, ⵉⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK43_20","027_43_20","EZK","43","20","20","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴳⴳⴻⴷ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⴻⵜ ⵓ ⵅ ⵜⵎⴰ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵙ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⴽⵙⴻⴷ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵜ ⵜⵚⴻⵍⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK43_21","027_43_21","EZK","43","21","21","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⴼⵓⵏⴰⵙ ⵏⵏⵉ ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴱⴰⵔⵔⴰ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK43_22","027_43_22","EZK","43","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴽⴽⵙⴻⵏ ⴷⴷⴻⵏⴱ ⵣⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵣⵣⴰⵢⴻⵙ ⴽⴽⵙⴻⵏ ⴷⴷⴻⵏⴱ ⵙ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK43_23","027_43_23","EZK","43","23","23","ⵅⵎⵉ ⵖⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵜⴰⴽⴻⵙⵙⵉⵜ ⵏ ⴷⴷⴻⵏⴱ, ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ ⵉⵛⵏⴰⵏ ⵇⴰⵄ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("EK43_24","027_43_24","EZK","43","24","24","ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵜⴻⵙⵙⵇⴰⵔⵔⴱⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵅⴰⵙ ⵙⵙⵓⵢⵓⵙⴻⵏ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK43_25","027_43_25","EZK","43","25","25","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴷⵉ ⴽⵓⵍ ⴰⵙⵙ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ. ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵏ ⵡⵓⴵⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK43_26","027_43_26","EZK","43","26","26","ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵚⵍⴰⵃ ⵉ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓ ⴰⴷ ⵜ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK43_27","027_43_27","EZK","43","27","27","ⵎⴰⵍⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵙⵙⴰⵏ-ⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⴱⴻⵍⵍⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵓⵇⴰⴷⵉ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵡⴻⵎ ⴰⵔⴹⵉⵖ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK44_1","027_44_1","EZK","44","1","1","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⴰⵔⵔⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵜⵓⵖⴰ ⵜⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("EK44_2","027_44_2","EZK","44","2","2","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⵜⴰⵡⵡⴰⵔⵜ-ⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⵍⵍⴻⵄ, ⵡⴰⵔ ⵜⴰⵔⵣⴻⵎ ⵛⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴰⴷⴻⴼ. ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵢⵓⴷⴻⴼ ⵣⵣⴰⵢⴻⵙ, ⵅ ⵓⵢⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⵍⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("EK44_3","027_44_3","EZK","44","3","3","ⵍⵃⴰⴽⴻⵎ ⵡⴰⵀⴰ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⵍⵃⴰⴽⴻⵎ, ⴰⴷ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵢⴻⵛⵛ ⴰⵖⵔⵓⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⴰⴷ ⵢⴰⴷⴻⴼ ⵙ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵙ ⵓⴽⵓⵍⵡⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("EK44_4","027_44_4","EZK","44","4","4","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵙ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵅⴻⵣⵣⴰⵔⴻⵖ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵅⴻⵏⵏⵉ ⵡⴹⵉⵖ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK44_5","027_44_5","EZK","44","5","5","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴻⴳⴳ ⵓⵍ ⵏⵏⴻⵛ, ⵅⵣⴰⵔ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⴻⵍ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵣⴻⵔⴼⴰⵏ ⵏⵏⴻⵙ. ⴻⴳⴳ ⵓⵍ ⵏⵏⴻⵛ ⵅ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵎⴰⵔⵔⴰ ⵓⴼⴼⵓⵖⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("EK44_6","027_44_6","EZK","44","6","6","ⵓⵛⴰ ⵉⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵡⵡⵖⴻⵏ, ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵛⴼⴰ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵏⵡⴻⵎ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EK44_7","027_44_7","EZK","44","7","7","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵉⴷⴼⴻⵎ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵏ ⵡⵓⵍ ⵓ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴰⴷ ⵙⵙⵄⵉⴵⵜⴻⵏ ⴰⵎⵎⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⵢⴻⵎ ⴰⵖⵔⵓⵎ ⵉⵏⵓ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵜⴰⴷⵓⵏⵜ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵓ ⴰⵔⵥⵉⵏ ⵏⵉⵜⵏⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵄⴰⵢⴻⴼ ⵉ ⵜⴻⴳⴳⵉⵎ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK44_8","027_44_8","EZK","44","8","8","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵃⴹⵉⵎ ⴰⵃⴻⵟⵟⵓ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵏⴻⵛⵛ ⵓⵛⴰ ⵜⴻⴳⴳⵉⵎ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK44_9","027_44_9","EZK","44","9","9","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵓⵍ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵉ ⴽⵓⵍ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK44_10","027_44_10","EZK","44","10","10","ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵢⴰⴳⴳⵯⴻⵊⴻⵏ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵣⵣⴰⵢⵉ ⵉⵡⴻⴷⴷⴰⵔ ⵉⵙⵔⴰⵉⵍ, ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵓⵢⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_11","027_44_11","EZK","44","11","11","ⴰⴷ ⵃⴹⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⵜ ⵉ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_12","027_44_12","EZK","44","12","12","ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⴻⵢⴹⴰ ⵏⵙⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵓ ⵓⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵓⵢⴰ ⴰⵇⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵏⴻⵛⵛ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅⴰⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK44_13","027_44_13","EZK","44","13","13","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵏⵓ, ⵖⴰⵔ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴱⵓⵏ ⵍⴻⴼⴷⵉⵃⴻⵜ ⵏⵙⴻⵏ ⴷ ⵊⵊⵄⴰⵢⴻⴼ ⵉ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_14","027_44_14","EZK","44","14","14","ⴰⴷ ⵜⴻⵏ ⴳⴳⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵅ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴳⴳ.’” ");
INSERT INTO rift_vpl VALUES ("EK44_15","027_44_15","EZK","44","15","15","“ⵎⴰⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ, ⴰⵢⵜ ⵏ ⵚⴰⴷⵓⵇ, ⵉⵏⵏⵉ ⵉⵃⴹⴰⵏ ⴰⵃⴻⵟⵟⵓ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅⵎⵉ ⵅⴰⴼⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵜⴰⴷⵓⵏⵜ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK44_16","027_44_16","EZK","44","16","16","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓ ⴰⴷ ⵃⴹⴰⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("EK44_17","027_44_17","EZK","44","17","17","ⴰⴷ ⵢⵉⵍⵉ ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ, ⴰⴷ ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵏ ⵍⴻⵇⵟⴻⵏ. ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⵔⴹⴻⵏ ⵛⴰ ⵏ ⵜⴰⴹⵓⴼⵜ ⵅⵎⵉ ⵖⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵓ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK44_18","027_44_18","EZK","44","18","18","ⴰⵔⴻⵥⵥⴰⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵓ ⵙⵙⵔⴰⵡⴻⵍ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⴱⴻⵢⵙⴻⵏ ⵛⴰ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK44_19","027_44_19","EZK","44","19","19","ⵅⵎⵉ ⵖⴰ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴳⴻⵏⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴽⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵉ ⴷⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⴷⴻⴳ ⵉⵅⵅⴰⵎⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⵇⴻⴷⴷⴰⵙⴻⵏ ⵍⴳⴻⵏⵙ ⵙ ⵡⴰⵔⵔⵓⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_20","027_44_20","EZK","44","20","20","ⵡⴰⵔ ⵙⵙⵇⵓⵛⵛⴰⵔⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏ ⵜⵉⵊⴻⵟⵟⴰⵢⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⴰⵢⵍⴻⵏⵜ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⴻⵙⵙⴻⵏ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EK44_21","027_44_21","EZK","44","21","21","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⵙⵓ ⴱⵉⵏⵓ, ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK44_22","027_44_22","EZK","44","22","22","ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵏⵓⵍⵓⴼⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵉⵄⴻⴷⴷⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵎⵖⵉⵔ ⵜⵉⵄⵣⵓⵔⴰⵢ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_23","027_44_23","EZK","44","23","23","ⴰⴷ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⴰⵔⴻⴳⴱⴻⵏ ⵍⴼⴰⵔⵣ ⵊⴰⵔ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ ⴷ ⵎⵉⵏ ⵉⵣⴷⵉⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_24","027_44_24","EZK","44","24","24","ⴷⴻⴳ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵏ. ⴰⴷ ⵜⴻⵏ ⵃⴰⴽⵎⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵃⴹⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⵏⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵉⵏⵓ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵓⵙⵙⴰⵏ ⵉⵏⵓ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("EK44_25","027_44_25","EZK","44","25","25","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵔⴻⵃⵃⴻⴳ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵎⵎⵓⵜⴻⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵉⵄⴻⴷⴷⴻⵍ ⵡⴰⵀⴰ ⴰⴷ ⵙⵙⵅⴻⵎⵊⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵎⵖⵉⵔ ⵉ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵏⵉⵖ ⵉ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵏⵉⵖ ⵉ ⵎⵎⵉⵜⵙⴻⵏ ⵏⵉⵖ ⵉ ⵢⴻⴵⵉⵜⵙⴻⵏ ⵏⵉⵖ ⵉ ⵓⵎⴰⵜⵙⴻⵏ ⵏⵉⵖ ⵉ ⵓⵍⵜⵎⴰⵜⵙⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵎⵍⵉⵛⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("EK44_26","027_44_26","EZK","44","26","26","ⴰⵡⴰⵔⵏⵉ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵃⴻⵙⵙⴱⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("EK44_27","027_44_27","EZK","44","27","27","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵇⴻⴷⴷⴰⵙ, ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("EK44_28","027_44_28","EZK","44","28","28","“ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ: ⵏⴻⵛⵛ ⴷ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⵉⵛⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⴳⵍⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ: ⵏⴻⵛⵛ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK44_29","027_44_29","EZK","44","29","29","ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵛⵛⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ. ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EK44_30","027_44_30","EZK","44","30","30","ⵎⵓⵎⵎⵓ ⵏ ⵜⵎⴻⵏⵣⵓⵜ ⵏ ⵎⴰⵔⵔⴰ ⵓ ⵎⴰⵔⵔⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵡⴰⵔⴻⵛⵜⵉ ⵏⵡⴻⵎ ⴰⴷ ⵜⵜ ⵜⴻⵡⵛⴻⴷ ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵙⴰ ⵍⴱⴰⵔⴰⴽⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("EK44_31","027_44_31","EZK","44","31","31","ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵉⵖ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴳⴻⵏ ⵏ ⵉⵊⴹⴰⴹ ⵏⵉⵖ ⵏ ⵍⴻⴱⵃⴰⵢⴻⵎ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK45_1","027_45_1","EZK","45","1","1","“ⵅⵎⵉ ⵖⴰ ⵜⴻⴱⴹⴰⵎ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ ⵙ ⵜⵇⴻⴷⴷⵓⵃⵜ, ⴰⴷ ⵜⵡⴻⵀⵀⴱⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ, ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ: ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK45_2","027_45_2","EZK","45","2","2","ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⴷⵉ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵍⵉⵏ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵓⵛⴰ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EK45_3","027_45_3","EZK","45","3","3","ⵙ ⵍⴻⵄⴱⴰⵔ-ⴰ ⴰⴷ ⵜⴻⵄⴱⴰⵔⴻⴷ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ ⴷⵉ ⵜⵉⵔⵓ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵓ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵉⵍⵉ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK45_4","027_45_4","EZK","45","4","4","ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵙⵉⴷⵉ. ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵏⵉⵜⵏⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK45_5","027_45_5","EZK","45","5","5","ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵓ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵎⵓⵍⴽ ⵉ ⵏⵉⵜⵏⵉ, ⵙ ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵉⵅⵅⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK45_6","027_45_6","EZK","45","6","6","ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵓ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵣⵣⴰⵜ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ. ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK45_7","027_45_7","EZK","45","7","7","ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵃⴰⴽⴻⵎ ⴰⴷ ⵜⵉⵍⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓⵍⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵓ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵣⵣⴰⵜ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵓ ⵣⵣⴰⵜ ⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵓ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵜⵓⵣⵣⵓⴳⴳⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵙⴻⵇⵇⴰⵍ ⵏ ⵍⵡⴰⵔⵜ, ⵣⴻⴳ ⵡⴻⵢⵎⵉⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⴰⵍ ⵡⴻⵢⵎⵉⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("EK45_8","027_45_8","EZK","45","8","8","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵙ, ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ⵓ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵏⵓ ⵡⴰⵔ ⵃⴻⵙⵙⴰⵔⴻⵏ ⵄⴰⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("EK45_9","027_45_9","EZK","45","9","9","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵛⴼⴰ ⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵉⵙⵔⴰⵢⵉⵍ! ⵙⴱⴻⵄⵄⴻⴷ ⵅⴰⵡⴻⵎ ⵍⵄⵓⵏⴼ ⵓ ⴳⴳⴻⵎ ⵍⵃⴻⵇⵇ ⴷ ⵜⵙⴻⴳⴷⴰ ⵓⵛⴰ ⴽⴽⵙⴻⵎ ⵉⴱⴻⵄⵄⴰⵊ ⵏⵡⴻⵎ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK45_10","027_45_10","EZK","45","10","10","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵍⵎⵉⵣⴰⵏ ⵏⵉⵛⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵏⵉⵛⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵜⵓ ⵏⵉⵛⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("EK45_11","027_45_11","EZK","45","11","11","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵄⴱⴰⵔ ⵏ ⵉⴼⴰ ⴷ ⵍⴻⵄⴱⴰⵔ ⵏ ⵓⴱⴰⵜⵓ ⴷ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵓⴱⴰⵜⵓ ⴷ ⵉⵛⵜ ⵣⵉ ⵜⵄⴻⵛⵛⴰⵔⵜ ⵏ ⵓⵃⵓⵎⵉⵔ, ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵄⴻⵛⵛⴰⵔⵜ ⵏ ⵓⵃⵓⵎⵉⵔ ⴰⴷ ⵜⴻⵙⵡⴰ ⵉⴼⴰ. ⵍⴻⵇⵢⴰⵙ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵣⴻⴳ ⵓⵃⵓⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("EK45_12","027_45_12","EZK","45","12","12","ⴰⵛⵉⵇⵍ ⴰⵇⴰ-ⵜ ⵄⵉⵛⵔⵉⵏ ⵊⵉⵔⴰ. ⵄⵉⵛⵔⵉⵏ ⵛⵉⵇⵍⵓ, ⵅⴻⵎⵙⴰ ⵓ-ⵄⴻⵛⵔⵉⵏ ⵛⵉⵇⵍⵓ, ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵛⵉⵇⵍⵓ, ⴰⴷ ⴰⵡⴻⵎ ⵢⵉⵍⵉ ⵉⵊⵊⴻⵏ ⵎⵉⵏⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK45_13","027_45_13","EZK","45","13","13","“ⵜⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ: ⵉⵛⵜ ⵏ ⵜⵙⵉⵜⵜⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ ⵏ ⵢⵉⵔⴷⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⵉⵜⵜⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK45_14","027_45_14","EZK","45","14","14","ⵅ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵣⵣⴻⵛⵜ, ⵜⴰⵡⵚⵉⵢⵢⴻⵜ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵓⴱⴰⵜⵓ ⵏ ⵣⵣⴻⵛⵜ: ⴰⵇⴰ ⵉⵛⵜ ⵏ ⵜⴻⵄⵛⴰⵔⵜ ⵏ ⵓⴱⴰⵜⵓ ⵏ ⵉⵊⵊ ⵏ ⵓⴽⵓⵔⵓ, ⴰⴽⵓⵔⵓ ⵏⵏⵉ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ ⵏ ⵄⴻⵛⵔⴰ ⵉⴱⴰⵜⵓⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵄⴻⵛⵔⴰ ⵉⴱⴰⵜⵓⵜⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("EK45_15","027_45_15","EZK","45","15","15","ⵅⴻⵏⵏⵉ ⵉⵊⵊ ⵣⴻⴳ ⵡⵓⴵⵉ ⵅ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵡⵓⴵⵉ ⵣⵉ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵙ ⵡⴰⵎⴰⵏ, ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵓ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⵀⵏⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴰⵚⵍⴰⵃ ⵉ ⵏⵉⵜⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK45_16","027_45_16","EZK","45","16","16","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴰⵔⵛⴻⵏ ⴷⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵍⵃⴰⴽⴻⵎ ⴷⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK45_17","027_45_17","EZK","45","17","17","ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵍⵃⴰⴽⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⴳⴳ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵓ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ, ⵡⴰⵀ, ⵅ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⴰⵚⵍⴰⵃ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("EK45_18","027_45_18","EZK","45","18","18","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵓⵢⵓⵔ, ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴽⴽⵙⴻⴷ ⴷⴷⴻⵏⴱ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK45_19","027_45_19","EZK","45","19","19","ⴰⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵉⴽⵙⵉ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵢⴻⴳⴳ ⵅ ⵍⴻⴹⵔⵓⴼ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⵔⴻⴼⴼⵉⴷⴻⵜ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵅ ⵍⴻⴹⵔⵓⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EK45_20","027_45_20","EZK","45","20","20","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵓⵢⵓⵔ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴻⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵇⵓⴱⴱⴰⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴰⵚⵍⴰⵃ ⵉ ⵜⴰⴷⴷⴰⵔⵜ.’” ");
INSERT INTO rift_vpl VALUES ("EK45_21","027_45_21","EZK","45","21","21","“ⴷⴻⴳ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⴰⴷ ⵜⵉⵍⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⴷ ⵢⵉⵍⵉ ⵍⵄⵉⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EK45_22","027_45_22","EZK","45","22","22","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵍⵃⴰⴽⴻⵎ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵜⵖⴰⵔⵚⵟ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK45_23","027_45_23","EZK","45","23","23","ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵄⵉⴷ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ: ⵙⴻⴱⵄⴰ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵉⵛⵏⴰⵏ, ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⵢⴰⵏ ⵣⴻⴳ ⵉⵖⴰⵢⴹⴻⵏ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("EK45_24","027_45_24","EZK","45","24","24","ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵄⴰⵡⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ: ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("EK45_25","027_45_25","EZK","45","25","25","ⴷⴻⴳ ⵢⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵢⵓⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵢⴻⴳⴳ ⴰⵎⵎⵓ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⵄⵉⴷ, ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ: ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ, ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⵎ ⵣⵣⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("EK46_1","027_46_1","EZK","46","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴷⴰⵅⴻⵍ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⴰⴷ ⵜⵉⵍⵉ ⵜⴱⴻⵍⵍⴻⵄ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵅⴻⴷⵎⴻⵜ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⴷ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⵓⵍⴰ ⵅ ⵡⴰⵙⵙ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⴰⴷ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK46_2","027_46_2","EZK","46","2","2","ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ ⵍⵃⴰⴽⴻⵎ ⵣⵉ ⴱⴰⵔⵔⴰ ⵙ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵏⴻⵙ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⵖⴰⵔⵚⴰ ⵏⵏⴻⵙ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵊⴻⴷ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ. ⵡⴰⵔ ⵜⵜⴱⴻⵍⵍⵉⵄⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵍ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("EK46_3","027_46_3","EZK","46","3","3","ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵉⵙⵊⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⴰⴷⴰⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵓ ⵅ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK46_4","027_46_4","EZK","46","4","4","ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵏⵉ ⵉ ⵖⴰ ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ ⵍⵃⴰⴽⴻⵎ ⵉ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵙⴻⵜⵜⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵛⵏⴰⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EK46_5","027_46_5","EZK","46","5","5","ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴰⴷ ⵜⵉⵍⵉ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵔⵖⵉⴵⴻⵜ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵢⴰⵡⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵔⵏⵉ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ ⵉ ⴽⵓⵍ ⵉⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("EK46_6","027_46_6","EZK","46","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ: ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵉⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ, ⴰⵎⴻⵥⵢⴰⵏ ⵏ ⵜⴼⵓⵏⴰⵙⵜ, ⵓ ⵙⴻⵜⵜⴰ ⵏ ⵉⵣⵎⴰⵔⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵍⵉⵏ ⵛⵏⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("EK46_7","027_46_7","EZK","46","7","7","ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⵉⵛⴰⵔⵔⵉ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ ⴰⵏⴻⵛⵜ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵢⴰⵡⵉ, ⵓ ⵣⵉ ⵣⵣⴻⵛⵜ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵉ ⴽⵓⵍ ⵉⴼⴰ.’” ");
INSERT INTO rift_vpl VALUES ("EK46_8","027_46_8","EZK","46","8","8","“ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴻⴼ ⵍⵃⴰⴽⴻⵎ, ⴰⴷ ⵢⴰⴷⴻⴼ ⵣⴻⴳ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵡⴻⵙⵇⵉⴼ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵓⴽⵓⵍⵡⴰⵔ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK46_9","027_46_9","EZK","46","9","9","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵍⴻⵄⵢⵓⴷⴰⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵣⴻⴳ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⴱⴻⵏⴷⴻⵇ, ⴰⴷ ⵉⴼⴼⴻⵖ ⵙ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵓ ⵡⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵙ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⴰⴷ ⵉⴼⴼⴻⵖ ⵙ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ. ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵣⵉ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵎⴰⵏⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ, ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵏⵏⵉ ⵢⴻⴵⴰⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK46_10","027_46_10","EZK","46","10","10","ⵍⵃⴰⴽⴻⵎ ⴰⴷ ⵢⴰⴷⴻⴼ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵙⴻⵏ. ⵅⵎⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵓ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴼⴼⵖⴻⵏ, ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵊⵎⵉⵄ.” ");
INSERT INTO rift_vpl VALUES ("EK46_11","027_46_11","EZK","46","11","11","“ⴷⵉ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵏ ⵍⵄⵉⴷ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⴰⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵓ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⵉ ⴽⵓⵍ ⵉⵛⴰⵔⵔⵉ ⵓ ⵉ ⵉⵣⵎⴰⵔⴻⵏ ⴰⵏⴻⵛⵜ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵢⴰⵡⵉ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵔⵏⵉ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ ⵉ ⴽⵓⵍ ⵉⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK46_12","027_46_12","EZK","46","12","12","“ⵅⵎⵉ ⵖⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵍⵃⴰⴽⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵅⴰⴹⴰⵔ, ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵏⵉⵖ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⵀⵏⴰ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵅⴰⴹⴰⵔ ⵉ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⴰⵔⵣⵎⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵏ ⵍⴻⵀⵏⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵓ ⵅⵎⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⴰⴷ ⴱⴻⵍⵍⵄⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK46_13","027_46_13","EZK","46","13","13","“ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵡⴻⵛⵎⴰⴹ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EK46_14","027_46_14","EZK","46","14","14","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴷⵉ ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⵉⵛⵜ ⵏ ⵜⵙⵉⵜⵜⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵉⴼⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵏⵓ ⵏ ⵣⵣⴻⵛⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵙⵓⴼⴼⴻⴷ ⴰⵔⴻⵏ ⴰⵣⴷⴰⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵙⵉⴷⵉ. ⴰⵇⴰ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK46_15","027_46_15","EZK","46","15","15","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵣⵎⴰⵔ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵣⵣⴻⵛⵜ ⴷⵉ ⴽⵓⵍ ⵜⵉⵡⴻⵛⵛⴰ ⴰⵎ ⵜⵖⴰⵔⵚⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("EK46_16","027_46_16","EZK","46","16","16","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵅⵎⵉ ⵖⴰ ⵉⵡⵛ ⵍⵃⴰⴽⴻⵎ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵉ ⵢⵉⵊⵊ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ. ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴷ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK46_17","027_46_17","EZK","46","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵡⵛⴰ ⵣⵉ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⴰⵔⵣⴻⴼⵜ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵏ ⵜⵍⴻⵍⵍⵉ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴻⴷⵡⴻⵍ ⵜⴻⵙⵖⴰⵔⵜ ⵖⴰⵔ ⵍⵃⴰⴽⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK46_18","027_46_18","EZK","46","18","18","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵍⵃⴰⴽⴻⵎ ⴰⴷ ⵉⴽⴽⴻⵙ ⵛⴰ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⴳⴻⵏⵙ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⴽⴻⵛⵛⴻⴹ ⴰⴳⵍⴰ ⵏⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵡⴰⵔⵜ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓⵎⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵇⵍⴻⵄ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("EK46_19","027_46_19","EZK","46","19","19","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴰⵎ ⴷⴷ-ⵉⴽⴽⴰ ⵅ ⵜⴻⴱⵔⵉⴷⵜ ⵏⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴰⵍ ⵉⵅⵅⴰⵎⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴰⵍⴰⵏ ⵛⵛⴰⵎⴰⵍ. ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵍⵖⴰⵔⴱ. ");
INSERT INTO rift_vpl VALUES ("EK46_20","027_46_20","EZK","46","20","20","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵡⴰ ⴷ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⵡⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⴷ ⵜⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⴳⴳⵡⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵛⴰ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⵍⴳⴻⵏⵙ ⴰⵎⵎⵓ.” ");
INSERT INTO rift_vpl VALUES ("EK46_21","027_46_21","EZK","46","21","21","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵍⴻⵎⵔⴰⵃ. ⵓ ⵅⵣⴰⵔ, ⴷⵉ ⴽⵓⵍ ⵜⴰⵖⵎⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⴼⴰⵔⵣⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⴷⵉ ⴽⵓⵍ ⵜⴰⵖⵎⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("EK46_22","027_46_22","EZK","46","22","22","ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⵣⵣⴰⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵅⵅⴰⵎⴻⵏ ⴰⵎ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵉⵙⴻⵇⵇⴼⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵉⵅⵅⴰⵎⴻⵏ ⴷⴻⴳ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⴱⴰⵔ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EK46_23","027_46_23","EZK","46","23","23","ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵅⴰⵎⵎⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⵉⵢⵜ ⵉ ⴷ ⴰⵙⴻⵏ-ⴷⴷ ⵉⵏⵏⴹⴻⵏ. ⴰⵇⴰ ⴳⴳⵉⵏ ⵍⵎⴻⵊⵎⴰⵔⴰⵜ ⵙⴰⴷⵓ ⵉ ⵜⵙⴻⴷⴷⵢⵉⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK46_24","027_46_24","EZK","46","24","24","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵜⵉⵏⴰ ⴷ ⴽⵓⵣⵉⵏⴰⵜ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⴳⴳⵯⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴳⴻⵏⵙ.” * ");
INSERT INTO rift_vpl VALUES ("EK47_1","027_47_1","EZK","47","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵢⵉⵡⵉ ⴰⵢⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴰⴷⴰⴼ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵓ ⵅⵣⴰⵔ, ⵣⵉ ⵙⴰⴷⵓ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵜⴻⴼⴼⵖⴻⵏ ⵡⴰⵎⴰⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵎⵉⵏⵣⵉ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓ ⵜⵓⵖⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵀⴻⴽⴽⵡⴰⵏ ⴰⵎⴰⵏ ⵣⵉ ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK47_2","027_47_2","EZK","47","2","2","ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵓⴽⵓⵍⵡⴰⵔ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵜⴻⴱⵔⵉⴷⵜ ⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⴰⵔⵔⴰ, ⵖⴰⵔ ⵓⴽⵓⵍⵡⴰⵔ ⵏⵏⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵓ ⵅⵣⴰⵔ, ⴰⵎⴰⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵣⵉ ⵜⴻⵖⵎⴰⵔⵜ ⵏ ⵣⵣⴰⵜ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("EK47_3","027_47_3","EZK","47","3","3","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵄⴱⴰⵔ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵉⵙⵙⴻⵥⵡⴰ ⴰⵢⵉ ⵅ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⵎⴰⵏ ⵉⵡⴹⴻⵏ ⴰⵍ ⵜⵉⵛⴻⵄⴱⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK47_4","027_47_4","EZK","47","4","4","ⵉⵄⴱⴰⵔ ⵄⴰⵡⴻⴷ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵥⵡⴰ ⴰⵢⵉ ⵅ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⵎⴰⵏ ⵉⵡⴹⴻⵏ ⴰⵍ ⵉⴼⴰⴷⴷⴻⵏ. ⵄⴰⵡⴻⴷ ⵉⵄⴱⴰⵔ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵥⵡⴰ ⴰⵢⵉ ⵄⴰⴷ ⴽⵜⴰⵔ ⵓⵛⴰ ⴰⵎⴰⵏ ⵉⵡⴹⴻⵏ ⴰⵍ ⵜⵉⵊⵄⵉⵏⵏⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK47_5","027_47_5","EZK","47","5","5","ⵉⵄⴱⴰⵔ ⵜⵡⴰⵍⴰⵜ ⵏⵏⴻⵖⵏⵉ ⴰⵍⴻⴼ ⵏ ⵉⵖⴰⴵⴻⵏ ⵓⵛⴰ ⴰⵎⴰⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵉⵖⵣⴰⵔ ⵡⴰⵔ ⵣⵎⵉⵔⴻⵖ ⴰⴷ ⵜ ⵥⵡⵉⵖ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵎⴰⵏ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵄⵓⵎⵎ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵉⵖⵣⴰⵔ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵜ ⵉⵥⵡⴰ ⵅ ⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK47_6","027_47_6","EZK","47","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵜⵜ, ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ?” ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴰⵎ ⴳⴳⵓⵔⴻⵖ ⵏⵏⴻⵛ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK47_7","027_47_7","EZK","47","7","7","ⵓⵎⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵏⴻⵛⵛ, ⵅⵣⴰⵔ, ⴱⴻⴷⴷⴻⵏⵜ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵅ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ, ⴰⵎ ⵖⴰⵔ ⵜⵎⴰ-ⵢⴰ ⴰⵎ ⵖⴰⵔ ⵜⵎⴰ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EK47_8","027_47_8","EZK","47","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⵎⴰⵏ-ⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵀⴻⴽⴽⵡⴰⵏ ⵖⴰⵔ ⵍⴻⵡⴹⴰ ⵓⵛⴰ ⵜⵜⴰⴽⴽⵡⴰⴹⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵉⵎⵎⵓⵜⴻⵏ. ⵅⴻⵏⵏⵉ ⵜⵜⴰⵣⵣⵍⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴳⴻⵏⴼⴰⵏ ⴰⵎⴰⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EK47_9","027_47_9","EZK","47","9","9","ⴰⴷ ⵉⵎⵙⴰⵔ, ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵉ ⴷⵉⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵎⴰⵏⵉ ⵎⴰ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴹⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ. ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⴰⵎⴰⵏ-ⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵎⴰⵏⵉ ⵎⴰ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵢⴻⵖⵣⴰⵔ-ⴰ, ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("EK47_10","027_47_10","EZK","47","10","10","ⴰⴷ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵢⴻⵎⵎⴰⵔⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵣⵉ ⵄⴰⵢⵏ-ⵊⴰⴷⵢⵉ ⴰⵍ ⵄⴰⵢⵏ-ⵄⵉⴳⵍⴰⵢⵉⵎ. ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵉⵎⵓⵛⴰⵏ ⵉ ⵓⵊⴻⴼⴼⴰⴼ ⵏ ⵜⵔⴰⵛⵛⴰⵡⵉⵏ. ⴰⵙⵍⴻⵎ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵔⴽⴰ ⵏⵏⴻⵙ, ⴰⵎ ⵡⴻⵙⵍⴻⵎ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("EK47_11","027_47_11","EZK","47","11","11","ⵎⴰⵛⴰ ⵜⵉⵏⴷⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵢⴻⵍⵎⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵡⴰⴳⴳⴻⵏⴼⴰⵏ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵎⴻⴵⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK47_12","027_47_12","EZK","47","12","12","ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ, ⵅ ⵜⵎⴰ ⵏⵏⴻⵙ, ⵅ ⵜⵎⴰ-ⵢⴰ ⵓ ⵅ ⵜⵎⴰ ⵏⵏⵉ, ⴰⴷ ⵉⵍⵉⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵛⵛⴻⵏ, ⵜⵉⵏⵏⵉ ⵓⵎⵉ ⵜⴰⴼⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵙⵍⴰⵡ ⵓ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏⵜ ⵡⴰⵔ ⵜ ⵇⴻⵟⵟⵉ ⵛⴰ. ⴽⵓⵍ ⴰⵢⵓⵔ ⴰⴷ ⵡⵛⴻⵏⵜ ⵍⵖⵉⴵⴻⵜ ⴷ ⵟⵟⵔⵉ, ⵎⴰⵖⴰⵔ ⴰⵎⴰⵏ ⵏ ⵢⴻⵖⵣⴰⵔ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏⵜ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵎⴰⵛⵛⴰ ⴷ ⵜⴰⴼⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵉ ⵓⴳⴻⵏⴼⵓ.” ");
INSERT INTO rift_vpl VALUES ("EK47_13","027_47_13","EZK","47","13","13","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵢⵎⵉⵔ ⵉ ⵅ ⵉ ⵖⴰ ⵜⴻⵡⵛⵉⵎ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵢⵓⵙⵓⴼ ⴰⴷ ⵉⴽⵙⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK47_14","027_47_14","EZK","47","14","14","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜ ⵜⵡⴰⵔⵜⴻⵎ, ⵉⵊⵊ ⴰⵎ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉ ⵓⵢⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵓⵛⴰ ⵊⵊⵓⴵⴻⵖ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK47_15","027_47_15","EZK","47","15","15","ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ: ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ, ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵃⵉⵜⵍⵓⵏ ⴰⵍ ⴷⴷ-ⵜⵓⵙⵉⴷ ⵖⴰⵔ ⵚⴰⴷⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("EK47_16","027_47_16","EZK","47","16","16","ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵃⴰⵎⴰⵜ, ⴱⴰⵢⵔⵓⵜⴰ, ⵙⵉⴱⵔⴰⵢⵉⵎ ⵏⵏⵉ ⵢⴻⴵⴰ ⵊⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴷⵉⵎⴰⵛⵇ ⴷ ⵡⴻⵢⵎⵉⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⵎⴰⵜ, ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵃⴰⵚⵔ-ⵀⴰⵜⵉⵅⵓⵏ ⵏⵏⵉ ⵢⴻⴵⴰ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵃⴰⵡⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK47_17","027_47_17","EZK","47","17","17","ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴻⵢⵎⵉⵔ ⵖⴰⵔ ⵃⴰⵙⵔ-ⵄⴰⵢⵏⵓⵏ, ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⴷⵉⵎⴰⵛⵇ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵓ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⵃⴰⵎⴰⵜ. ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EK47_18","027_47_18","EZK","47","18","18","ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵉⵜⵜⴻⴽⴽ ⵣⵉ ⵊⴰⵔ ⵃⴰⵡⵔⴰⵏ ⴷ ⴷⵉⵎⴰⵛⵇ ⵓ ⵣⵉ ⵊⴰⵔ ⵊⵉⵍⵄⴰⴷ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵍ’ⵓⵔⴷⵓⵏ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜ ⵜⵄⴻⴱⴱⴰⵔⴻⵎ ⵣⴻⴳ ⵡⴻⵢⵎⵉⵔ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵏ ⵛⵛⴰⵔⵇ. ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("EK47_19","027_47_19","EZK","47","19","19","ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ, ⴰⵇⴰ-ⵜ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵣⵉ ⵜⴰⵎⴰⵔ ⴰⵍ ⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⵓⵜ-ⵇⴰⴷⴰⵛ ⵓⵛⴰ ⵉⵜⵜⴻⴽⴽ ⵅ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("EK47_20","027_47_20","EZK","47","20","20","ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⴷ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵣⴻⴳ ⵡⴻⵢⵎⵉⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⴰⵍ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ, ⵡⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ.’” ");
INSERT INTO rift_vpl VALUES ("EK47_21","027_47_21","EZK","47","21","21","“ⴰⴷ ⵜⴻⴱⴹⴰⵎ ⵜⴰⵎⵎⵓⵔⵜ-ⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK47_22","027_47_22","EZK","47","22","22","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜ ⵊⵊⴻⵏ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵓⵔⵡⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⴰⵙⴻⵏ ⵜⵉⵍⵉ ⵜⴰⵙⵖⴰⵔⵜ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK47_23","027_47_23","EZK","47","23","23","ⵖⴰⵔ ⵜⴻⵇⴱⵉⵍⵜ ⵉ ⵖⴰⵔ ⵖⴰ ⵉⵣⴷⴻⵖ ⴰⵎ ⵓⴱⴰⵔⵔⴰⵏⵉ, ⴷⵉⵏ ⴰⴷ ⴰⵙ ⵜⴻⵡⵛⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ! ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("EK48_1","027_48_1","EZK","48","1","1","“ⵉⵏⴰ ⴷ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ. ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵛⵛⴰⵎⴰⵍ ⵇⴰⵄ, ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵃⵉⵜⵍⵓⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⵜⴰⵡⴹⴻⴷ ⵖⴰⵔ ⵃⴰⵎⴰⵜ, ⵃⴰⵚⴰⵔ-ⵄⵉⵏⴰⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⴷⵉⵎⴰⵛⵇ, ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵏ ⵃⴰⵎⴰⵜ ⵓⵎⵉ ⵅⴰⵙ ⵜᵉⵜⵜⴻⴽⴽⴻⴷ: ⴰⴷ ⴰⵙ ⵢⵉⵍⵉ ⴰⵎ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵎ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_2","027_48_2","EZK","48","2","2","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⴷⴰⵏ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⴰⵛⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("EK48_3","027_48_3","EZK","48","3","3","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⴰⵛⵉⵔ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EK48_4","027_48_4","EZK","48","4","4","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵎⴰⵏⴰⵙⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("EK48_5","027_48_5","EZK","48","5","5","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵉⴼⵔⴰⵢⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("EK48_6","027_48_6","EZK","48","6","6","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵔⵓⴱⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_7","027_48_7","EZK","48","7","7","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵔⵓⴱⵉⵏ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("EK48_8","027_48_8","EZK","48","8","8","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⵡⴻⵀⵀⴱⴻⵎ, ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵓ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⵎ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵙⴻⵇⵇⴰⵔ ⵉⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK48_9","027_48_9","EZK","48","9","9","ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ, ⴰⴷ ⵜⵉⵍⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵓ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK48_10","027_48_10","EZK","48","10","10","ⵜⴰⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵉⵏⴰ: ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵓ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵓ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵓ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK48_11","027_48_11","EZK","48","11","11","ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵚⴰⴷⵓⵇ, ⵉⵏⵏⵉ ⵉⵃⴹⴰⵏ ⴰⵃⴻⵟⵟⵓ ⵉⵏⵓ, ⵉⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵛⴰ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵡⴻⴷⴷⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎ ⴼⴼⵖⴻⵏ ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("EK48_12","027_48_12","EZK","48","12","12","ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵉ ⵏⵉⵜⵏⵉ ⵣⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵇⴻⴷⴷⴻⵙ ⵇⴰⵄ, ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_13","027_48_13","EZK","48","13","13","ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵉ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ⵎⴰⵔⵔⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵓ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵄⴰⵡⴻⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK48_14","027_48_14","EZK","48","14","14","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⵣⴻⵏⵣⴻⵏ ⵓⵍⴰ ⴷ ⵛⴰ ⵣⵣⴰⵢⴻⵙ, ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵜ ⴱⴻⴷⴷⵍⴻⵏ ⵏⵉⵖ ⴰⴷ ⵜⵜ ⵙⵙⴻⵄⴷⵓⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⵎⵅⴻⵢⵢⴻⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("EK48_15","027_48_15","EZK","48","15","15","ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵜⵉⵔⵓ, ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⴽⵓⵍ ⴰⵙⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵓ ⵉ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ. ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK48_16","027_48_16","EZK","48","16","16","ⵉⵏⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴻⵄⴱⵓⵔⴰⵜ ⵏⵏⴻⵙ: ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵎⴰⵍ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⴻⴱⵃⴰⵔ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK48_17","027_48_17","EZK","48","17","17","ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ: ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⵉⵍⵉⵏⵜ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK48_18","027_48_18","EZK","48","18","18","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ, ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⴷ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ, ⴰⴷ ⵢⵉⵍⵉ ⵣⵣⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ. ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵎⴰⵛⵛⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EK48_19","027_48_19","EZK","48","19","19","ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⵇⴰ ⴰⴷ ⵜⵜ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("EK48_20","027_48_20","EZK","48","20","20","ⵎⴰⵔⵔⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴰⴷ ⵜⵉⵍⵉ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵅ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ. ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⵡⴰⴷⵔⵓⵏ ⴰⴽ-ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK48_21","027_48_21","EZK","48","21","21","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⵃⴰⴽⴻⵎ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⵓ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵣⵣⴰⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵛⵛⴰⵔⵇ, ⵓ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵖⵓⵏⴰⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⴰⵍ ⴰⵢⵎⵉⵔ ⵏ ⵍⵖⴰⵔⴱ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵣⵣⴰⵜ ⵉ ⵜⵙⴻⵇⵇⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⵃⴰⴽⴻⵎ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⵓ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EK48_22","027_48_22","EZK","48","22","22","ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵓ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⵉ ⵍⵃⴰⴽⴻⵎ, ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵊⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉ ⵍⵃⴰⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EK48_23","027_48_23","EZK","48","23","23","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_24","027_48_24","EZK","48","24","24","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_25","027_48_25","EZK","48","25","25","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵉⵙⵙⴰⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EK48_26","027_48_26","EZK","48","26","26","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_27","027_48_27","EZK","48","27","27","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵣⴰⴱⵓⵍⵓⵏ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵍ ⵍⴻⴱⵃⴰⵔ: ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⵊⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("EK48_28","027_48_28","EZK","48","28","28","ⵅ ⵡⴻⵢⵎⵉⵔ ⵏ ⵊⴰⴷ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⴷⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵢⵎⵉⵔ ⵣⵉ ⵜⴰⵎⴰⵔ ⴰⵍ ⴰⵎⴰⵏ ⵏ ⵎⴰⵔⵉⴱⴰ-ⵇⴰⴷⴰⵛ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴻⴽⴽ ⵅ ⵜⴻⵖⵣⴰⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_29","027_48_29","EZK","48","29","29","ⵜⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜ ⵜⴻⴱⴹⴰⵎ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵉ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵜⵉⵏⴰ ⴷ ⵜⵉⵙⴻⵇⵇⴰⵔ ⵏⵙⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” * ");
INSERT INTO rift_vpl VALUES ("EK48_30","027_48_30","EZK","48","30","30","“ⴷ ⵢⵉⵏⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵓⴼⴼⵓⵖⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ: ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵍⴻⵄⴱⵓⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("EK48_31","027_48_31","EZK","48","31","31","ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵜⵜⵡⴰⵍⴰⵖⴰⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ: ⵉⵛⵜⴻⵏ ⵏ ⵔⵓⴱⵉⵏ, ⵉⵛⵜⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵛⵜⴻⵏ ⵏ ⵍⴰⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("EK48_32","027_48_32","EZK","48","32","32","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⵛⴰⵔⵇ ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵍⴻⵄⴱⵓⵔⴰⵜ, ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ: ⵉⵛⵜⴻⵏ ⵏ ⵢⵓⵙⵓⴼ, ⵉⵛⵜⴻⵏ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵉⵛⵜⴻⵏ ⵏ ⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_33","027_48_33","EZK","48","33","33","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵍⴻⵄⴱⵓⵔⴰⵜ, ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ: ⵉⵛⵜⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵉⵛⵜⴻⵏ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵉⵛⵜⴻⵏ ⵏ ⵣⴰⴱⵓⵍⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("EK48_34","027_48_34","EZK","48","34","34","ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵖⴰⵔⴱ ⴰⵇⴰ ⴷⵉⵏ ⵅⴻⵎⵙⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⵎⵢⴰ ⵏ ⵍⴻⵄⴱⵓⵔⴰⵜ, ⴰⴽ-ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵙⴻⵏ: ⵉⵛⵜⴻⵏ ⵏ ⵊⴰⴷ, ⵉⵛⵜⴻⵏ ⵏ ⴰⵛⵉⵔ, ⵉⵛⵜⴻⵏ ⵏ ⵏⴰⴼⵜⴰⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("EK48_35","027_48_35","EZK","48","35","35","ⵍⴻⵄⴱⴰⵔ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⵎⴻⵏⵟⴰⵛ-ⴰⵍⴻⴼ ⵏ ⵍⴻⵄⴱⵓⵔⴰⵜ ⵓ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵢⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵡⴰ: ‘ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷⵉⵏ!’ ” ");
INSERT INTO rift_vpl VALUES ("DN1_1","028_1_1","DAN","1","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("DN1_2","028_1_2","DAN","1","2","2","ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵢⴰⵀⵓⵢⴰⵇⵉⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵜⵜⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵉⵏⵄⴰⵔ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵜⵅⵓⴱⴰⵢ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN1_3","028_1_3","DAN","1","3","3","ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⴰⵛⴼⴰⵏⴰⵣ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⴰⵡⵉ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("DN1_4","028_1_4","DAN","1","4","4","ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ, ⵉⵏⵏⵉ ⴷ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ, ⵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ, ⵙⵙⵏⴻⵏ ⵜⵓⵙⵙⵏⴰ, ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⵇⴻⵍ ⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵢⵉⵍⴻⵙ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN1_5","028_1_5","DAN","1","5","5","ⴰⵊⴻⴵⵉⴷ ⵉⴳⴳⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⵎⴰⵄⵉⵛⴰ ⴷⵉ ⴽⵓⵍ ⴰⵙⵙ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵣⵉ ⴱⵉⵏⵓ ⵏ ⵟⵟⴰⴱⵍⴰ ⵏ ⵜⵙⴻⵙⵙⵉⵜ ⵏⵏⴻⵙ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⵉ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN1_6","028_1_6","DAN","1","6","6","ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ, ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⵄⴰⵣⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("DN1_7","028_1_7","DAN","1","7","7","ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ. ⴷⴰⵏⵉⵢⴰⵍ ⵉⴳⴳⴰ ⴰⵙ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⵃⴰⵏⴰⵏⵢⴰ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵢⵉⵍ ⵎⵉⵛⴰⵅ ⵓ ⵄⴰⵣⴰⵔⵢⴰ ⵉⴳⴳⴰ ⴰⵙ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ. ");
INSERT INTO rift_vpl VALUES ("DN1_8","028_1_8","DAN","1","8","8","ⴷⴰⵏⵉⵢⴰⵍ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵙⵙⵅⴻⵎⵎⵉⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵎⴰⵛⵛⴰ ⴷ ⴱⵉⵏⵓ ⵏ ⵟⵟⴰⴱⵍⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵉⵜⵜⴰⵔ ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵅⴻⵎⵎⵉⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN1_9","028_1_9","DAN","1","9","9","ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵛⴻⵏ ⵉ ⴷⴰⵏⵉⵢⴰⵍ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN1_10","028_1_10","DAN","1","10","10","ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵉⵏⵏⴰ ⵉ ⴷⴰⵏⵉⵢⴰⵍ: “ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⵣⵉ ⴱⴰⴱ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵡⴻⵚⵚⴰⵏ ⵅ ⵎⴰⵛⵛⴰ ⴷ ⵜⵙⴻⵙⵙⵉⵜ, ⵎⴰⵖⴰⵔ ⵎⴰⵢⴻⵎⵎⵉ ⴰⴷ ⵉⵥⴰⵔ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵡⴻⵎ ⵣⴻⵔⵔⵢⴻⵏ ⵅ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵇⵔⵉⵏⴻⵏ ⵏⵡⴻⵎ? ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵉ ⵓⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("DN1_11","028_1_11","DAN","1","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴰⵏⵉⵢⴰⵍ ⵉ ⵓⵡⴻⵇⵇⴰⴼ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵅ ⴷⴰⵏⵉⵢⴰⵍ, ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⵄⴰⵣⴰⵔⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("DN1_12","028_1_12","DAN","1","12","12","“ⵇⴻⴵⴻⴱ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴻⵊⵊ ⴰⴷ ⴰⵏⴻⵖ ⵡⵛⴻⵏ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵉ ⵎⴰⵛⵛⴰ ⵓⵍⴰ ⴷ ⵡⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵏⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("DN1_13","028_1_13","DAN","1","13","13","ⵅⴻⵏⵏⵉ ⴻⵊⵊ ⴰⴷ ⴰⵏⴻⵖ ⵇⴻⴷⴷⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵡⴰⴷⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵜⵜᵉⵜⵜⴻⵏ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵡⴰⴷⴷⵓⴷ ⵏⵙⴻⵏ ⵓ ⴻⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("DN1_14","028_1_14","DAN","1","14","14","ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵇⴻⴵⴻⴱ ⵉ-ⵜⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN1_15","028_1_15","DAN","1","15","15","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵜⴱⴰⵏⴻⵏ ⵛⵏⴰⵏ ⵓ ⵚⴻⴱⵃⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵉ ⵉⵛⵛⴻⵏ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN1_16","028_1_16","DAN","1","16","16","ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵡⴻⵇⵇⴰⴼ ⵉⴽⴽⴻⵙ ⴰⵙⴻⵏ ⵎⴰⵛⵛⴰ ⵏⵙⴻⵏ ⵉⴳⴻⵍⵍⴷⴻⵏ ⴷ ⴱⵉⵏⵓ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵙⵡⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN1_17","028_1_17","DAN","1","17","17","ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ-ⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⵄⵇⴻⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵜⵉⵖⵉⵜ. ⵓⵛⴰ ⵉ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵡⵛⴰ ⴰⵙ ⵓⵍⴰ ⴷ ⴰⵃⴻⴽⴽⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵡⵃⵉⵢ ⴷ ⵜⵉⵔⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("DN1_18","028_1_18","DAN","1","18","18","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵇⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵇⴻⴷⴷⵎⴻⵏ ⵣⵣⴰⵜⴻⵙ, ⵢⵉⵡⵢⵉ ⵉ-ⵜⴻⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⵜⵡⴰⴷⴷⵣⴻⵏ ⵉⵎⴻⴵⴰⵍⴻⵏ, ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN1_19","028_1_19","DAN","1","19","19","ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵎ ⴷⴰⵏⵉⵢⴰⵍ, ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⵄⴰⵣⴰⵔⵢⴰ ⵓ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN1_20","028_1_20","DAN","1","20","20","ⴷⵉ ⴽⵓⵍ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉ ⵅ ⵜⵓⵖⴰ ⵜⴻⵏ ⵉⵜⵜⵙⴻⵇⵙⴰ ⵓⵊⴻⴵⵉⴷ, ⵢⵓⴼⴰ ⴰⵇⴰ ⵄⴷⵓⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN1_21","028_1_21","DAN","1","21","21","ⴷⴰⵏⵉⵢⴰⵍ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵊⴻⴵⵉⴷ ⴽⵓⵔⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("DN2_1","028_2_1","DAN","2","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵢⵓⵔⵊⴰ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵜⵉⵔⵊⴰ. ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵉⵏⵏⴻⵃⵡⴻⵍ ⵓⵛⴰ ⵉⵔⵓⵃ ⴰⵙ ⵢⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("DN2_2","028_2_2","DAN","2","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⴷ ⵉⵙⴻⵃⵃⴰⵔⴻⵏ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙ ⴼⴻⵙⵙⴰⵔⴻⵏ ⵜⵉⵔⵊⴰ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN2_3","028_2_3","DAN","2","3","3","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ: “ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ ⵓ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵉⵏⵏⴻⵃⵡⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⵜⴻⵅⵙ ⴰⴷ ⵜⵉⵏⵉ ⵜⴰⵔⵊⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("DN2_4","028_2_4","DAN","2","4","4","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ ⴰⵇⴰ-ⵜ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵜⵔⴰⵎⵉⵜ. ⴰ ⴰⵊⴻⴵⵉⴷ, ⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ! ⵉⵏⵉ ⴰⵙⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⴰⵔⵊⵉⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⴽ ⵜⵜ ⵏⴼⴻⵙⵙⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("DN2_5","028_2_5","DAN","2","5","5","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ ⵉ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ: “ⴰⵇⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵓⵎⵓⵔ. ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⵎ ⵅ ⵜⴰⵔⵊⵉⵜ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵎ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⵔⴻⵏ ⴷ ⵜⵉⵣⵓⴱⴰⵢⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DN2_6","028_2_6","DAN","2","6","6","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴼⴻⵙⵙⴰⵔⴻⵎ ⴰⵢⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵊⵉⵜ ⴷ ⵎⵉⵏ ⵜⴻⵅⵙ ⴰⴷ ⵜⵉⵏⵉ, ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵣⵣⴰⵢⵉ ⵜⴰⵔⵣⴻⴼⵉⵏ ⴷ ⴰⵔⵔⵉⵖⴰⵍⵓⵜⴻⵏ ⴷ ⵛⵛⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ, ⵙⴻⵛⵛⵏⴻⵎ ⴰⵢⵉ ⵜⴰⵔⵊⵉⵜ ⵉⵏⵓ ⴷ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN2_7","028_2_7","DAN","2","7","7","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵅⴰⵙ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵏⵏⴰⵏ: “ⴻⵊⵊ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⵃⴰⵊⴰ ⵜⴰⵔⵊⵉⵜ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵏⴻⵡⵛ ⴰⴼⴻⵙⵙⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("DN2_8","028_2_8","DAN","2","8","8","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴰⵔⴻⴱⵃⴻⵎ ⵍⵡⴻⵇⵜ, ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴰⵇⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵓⵎⵓⵔ ⵣⵣⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("DN2_9","028_2_9","DAN","2","9","9","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⵎ ⵅ ⵜⴰⵔⵊⵉⵜ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵍⵇⴻⴼ ⵍⵃⵓⴽⵎ ⴷ ⵉⵊⵊ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⴽⵙⴻⵎ ⴰⵡⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⵙⵙⵅⴰⵔⵔⵇⴻⵎ ⵓ ⴰⴷ ⴰⵢⵉ ⵜⵖⴻⵛⵛⴻⵎ ⴰⵍ ⵖⴰ ⵜⴱⴻⴷⴷⴻⵍ ⵍⵡⴻⵇⵜ. ⵙ ⵓⵢⴻⵏⵏⵉ, ⵉⵏⵉ ⴰⵢⵉ ⵜⴰⵔⵊⵉⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⵎ ⵓⵍⴰ ⴷ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN2_10","028_2_10","DAN","2","10","10","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴼⴻⵙⵙⴰⵔ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵉ ⵓⵊⴻⴵⵉⴷ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵉⵖ ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵖⴰⵔⴻⵙ ⴷ ⵜⵉⵣⴻⵎⵎⴰⵔ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⵏ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⴰⵎ ⵜⴰⵏⵉⵜⴰ ⵣⵉ ⵛⴰ ⵏ ⵓⵙⴻⵃⵃⴰⵔ ⵏⵉⵖ ⴰⵎⴻⵙⵏⴰⵡ ⵏ ⵉⵜⵔⴰⵏ ⵏⵉⵖ ⴰⴽⴰⵍⴷⴰⵏⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("DN2_11","028_2_11","DAN","2","11","11","ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵉⵜⵜⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵜⴻⵡⵄⴰⵔ ⴰⵟⵟⴰⵙ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⴰⵔⴳⴻⴱ, ⵎⵖⵉⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN2_12","028_2_12","DAN","2","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ ⵉⵜⵜⵃⴰⵊⴰ ⵓ ⵉⵜⵜⵅⴻⵢⵢⴰⵇ ⴽⵜⴰⵔ, ⵢⵓⵎⵓⵔ ⴰⴷ ⵏⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN2_13","028_2_13","DAN","2","13","13","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵖⴻⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ. ⴰⵔⵣⵓⵏ ⵓⵍⴰ ⵅ ⴷⴰⵏⵉⵢⴰⵍ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN2_14","028_2_14","DAN","2","14","14","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴷⴰⵏⵉⵢⴰⵍ ⵙ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⵄⵇⴻⵍ ⵖⴰⵔ ⴰⵔⵉⵢⵓⵅ, ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⴻⵖ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN2_15","028_2_15","DAN","2","15","15","ⴷⴰⵏⵉⴻⵍ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⴰⵔⵉⵢⵓⵅ, ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵍⵓⵎⵓⵍ ⴰⵎⵎⵓ ⵙ ⵜⴰⵣⵍⴰ?” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵔⵉⵢⵓⵅ ⵅ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉ ⴷⴰⵏⵉⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("DN2_16","028_2_16","DAN","2","16","16","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⴷⴰⵏⵉⵢⴰⵍ ⵓⵛⴰ ⵉⵜⵜⴰⵔ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⴼⴻⵙⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN2_17","028_2_17","DAN","2","17","17","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⴰⵏⵉⵢⴰⵍ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵃⴰⵊⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵉⵄⵛⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵃⴰⵏⴰⵏⵢⴰ, ⵎⵉⵛⴰⵢⵉⵍ ⴷ ⵄⴰⵣⴰⵔⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("DN2_18","028_2_18","DAN","2","18","18","ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵅ ⵙⵙⵉⵔⵔ-ⴰ ⵃⵉⵎⴰ ⴷⴰⵏⵉⵢⴰⵍ ⴷ ⵉⵄⵛⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⵉⴽⴻⵏ ⵛⴰ ⴰⴽ-ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN2_19","028_2_19","DAN","2","19","19","ⵅⴰⵙ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ-ⴷⴷ ⵉ ⴷⴰⵏⵉⵢⴰⵍ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵙ ⴵⵉⵍⴻⵜ. ⵅⴻⵏⵏⵉ ⵉⴱⴰⵔⴻⴽ ⴷⴰⵏⵉⵢⴰⵍ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN2_20","028_2_20","DAN","2","20","20","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍⴻⴱⴷⴰ ⴰⵍ ⵍⴻⴱⴷⴰ ⵇⴰⵄ, ⵎⴰⵖⴰⵔ ⵜⵉⵖⵉⵜ ⴷ ⵊⵊⴻⵀⴷ ⴰⵇⴰ ⴰⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN2_21","028_2_21","DAN","2","21","21","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴱⴻⴷⴷⴰⵍ ⵣⵣⴰⵎⴰⵏⴰⵜ ⴷ ⵜⵙⴰⵄⵄⴻⵜⵉⵏ. ⵏⴻⵜⵜⴰ ⵉⴽⴽⴻⵙ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵜⵉⵖⵉⵜ ⵉ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵓ ⵜⵓⵙⵙⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⵄⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DN2_22","028_2_22","DAN","2","22","22","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵢⵓⴵⵖⴻⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵖⴰⵔ ⵜⴰⴼⴰⵡⵜ ⵜⵣⴻⴷⴷⴻⵖ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN2_23","028_2_23","DAN","2","23","23","ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⴰⵇⴰ ⵜⵜⵇⴰⴷⵉⵖ ⵓ ⵜⵜⵚⴻⴱⴱⵃⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⵉⵖⵉⵜ ⴷ ⵊⵊⴻⵀⴷ, ⵓ ⵓⵎⵉ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴰⵢⵉ ⵍⴻⵅⵅⵓ ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵏⴻⵜⵜⴰⵔ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⴰⵏⴻⵖ ⵅ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("DN2_24","028_2_24","DAN","2","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⴷⴰⵏⵉⵢⴰⵍ ⵖⴰⵔ ⴰⵔⵉⵢⵓⵅ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⵉⵍ. ⵢⵓⵢⵓⵔ ⵖⴰⵔⴻⵙ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⴰⵎⵎⵓ: “ⵡⴰⵔ ⵏⴻⵇⵇ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⵉⵍ, ⵎⴰⵛⴰ ⵏⴷⴻⵀ ⴰⵢⵉ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⴰⴼⴻⵙⵙⴰⵔ ⵉ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("DN2_25","028_2_25","DAN","2","25","25","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⴰⵔⵉⵢⵓⵅ ⴷⴰⵏⵉⵢⴰⵍ ⵙ ⵜⴰⵣⵍⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⴰⵎⵎⵓ: “ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵊⴰⵔ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵡⴻⵏⵏⵉ ⴷ ⵉ ⵖⴰ ⵉⵙⵙⴻⵛⵏⴻⵏ ⴰⴼⴻⵙⵙⴰⵔ ⵉ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("DN2_26","028_2_26","DAN","2","26","26","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⴷⴰⵏⵉⵢⴰⵍ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ: “ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴰⵔⴳⴱⴻⴷ ⵅ ⵜⴰⵔⵊⵉⵜ ⵏⵏⵉ ⵥⵔⵉⵖ ⴷ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("DN2_27","028_2_27","DAN","2","27","27","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴷⴰⵏⵉⵢⴰⵍ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉ ⵉⵜⵜⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵎ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⴰⴷ ⵜ ⵙⵙⴰⵔⴻⴳⴱⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN2_28","028_2_28","DAN","2","28","28","ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴳⴰⴱⴻⵏ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴰⵇⴰ ⵜⴰ ⴷ ⵜⴰⵔⵊⵉⵜ ⵏⵏⴻⵛ ⴷ ⵉⵡⴻⵃⵃⴰⵏ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⴷⵉ ⵜⴰⵙⵙⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("DN2_29","028_2_29","DAN","2","29","29","ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵓⵎⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⴷⵉ ⵜⴰⵙⵙⵓⵜ ⵓⵙⵉⵏ ⴰⵛ-ⴷⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵅ ⵎⵉⵏ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵓ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴳⴱⴻⵏ ⵎⵉⵏ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ, ⴰⵇⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵛ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN2_30","028_2_30","DAN","2","30","30","ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵜⵉⵖⵉⵜ ⵏⵏⵉ ⴷⴰⵢⵉ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵓⴼⴻⵙⵙⴰⵔ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DN2_31","028_2_31","DAN","2","31","31","“ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵜⵓⵖⴰ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵓ ⵜⴻⵥⵔⵉⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵍⴻⵅⵢⴰⵍ-ⴰ ⵜⵓⵖⴰ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⵓ ⵜⵉⵙⵙⵉⵇⵜ ⵏⵏⴻⵙ ⵜⴻⴵⴰ ⴰⵍ ⵟⵟⴰⵔⴼ. ⴰⵇⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⴽ ⵓ ⵉⵙⵙⵉⴳⴳⵯⴻⴷ ⴰⵎ ⵜ ⵜⴻⵥⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN2_32","028_2_32","DAN","2","32","32","ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴻⵅⵢⴰⵍ-ⴰ ⵜⵓⵖⴰ ⴷ ⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⴷ ⵏⵏⵓⵇⴰⵔⵜ, ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⴷ ⵜⵉⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ ⴷ ⵏⵏⵃⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("DN2_33","028_2_33","DAN","2","33","33","ⵜⵉⵎⴻⵙⵙⴰⴹⵉⵏ ⵏⵏⴻⵙ ⴷ ⵓⵣⵣⴰⵍ, ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵛⵡⴰⵢⵜ ⴷ ⵓⵣⵣⴰⵍ ⵓ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏ ⴷ ⵜⴰⵔⵔⵉⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("DN2_34","028_2_34","DAN","2","34","34","ⴰⵢⴰ ⵉ ⵜⴻⵥⵔⵉⴷ, ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵛⴻⴵⴻⵇ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴱⵍⴰ ⵉⴼⴰⵙⵙⴻⵏ. ⵡⴰⵏⵉⵜⴰ ⵉⵍⵇⴻⴼ ⵍⴻⵅⵢⴰⵍ ⵏⵏⵉ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵏ ⵡⵓⵣⵣⴰⵍ ⴰⴽ-ⴷ ⵜⴰⵔⵔⵉⵙⵜ, ⵓⵛⴰ ⵉⵍⴱⴻⵣ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN2_35","028_2_35","DAN","2","35","35","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴱⴻⵣ ⵡⵓⵣⵣⴰⵍ ⴷ ⵜⴰⵔⵔⵉⵙⵜ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵓⵍⵓⵎ ⵏ ⵉⵏⴻⴷⵔⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ, ⵓⵛⴰ ⵉⵙⵓⴹ ⴷⴰⵢⵙⴻⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵓⵔⴻⵜ. ⵎⴰⵛⴰ ⴰⵥⵔⵓ ⵏⵏⵉ ⵉⵍⴻⵇⴼⴻⵏ ⵍⴻⵅⵢⴰⵍ, ⵉⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵄⴻⵎⵎⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DN2_36","028_2_36","DAN","2","36","36","ⴷ ⵜⴰ ⴷ ⵜⴰⵔⵊⵉⵜ. ⴰⴷ ⵏⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵜⴻⵅⵙ ⴰⴷ ⵜⵉⵏⵉ ⵍⴻⵅⵅⵓ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ. * ");
INSERT INTO rift_vpl VALUES ("DN2_37","028_2_37","DAN","2","37","37","ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵜⴻⴵⵉⴷ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵉⵡⵛⴰ ⴰⵛ ⵜⴰⴳⴻⵍⴷⴰ ⴷ ⵜⵣⴻⵎⵎⴰⵔ ⴷ ⵊⵊⴻⵀⴷ ⴷ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN2_38","028_2_38","DAN","2","38","38","ⵎⴰⵏⵉ ⵎⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⴳⴳⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵛⴻⴽ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ. ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⵉ ⵏ ⵡⵓⵔⴻⵖ. * ");
INSERT INTO rift_vpl VALUES ("DN2_39","028_2_39","DAN","2","39","39","ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵖⵏⵉⵜ, ⵜⵓⴷⵔⵓⵙ ⵅ ⵜⴻⵏⵏⵉ ⵏⵏⴻⵛ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵏⵏⴻⵖⵏⵉⵜ, ⵜⴰⴳⴻⵍⴷⵉⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵏⵏⵃⴰⵙ, ⵜⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵃⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. * ");
INSERT INTO rift_vpl VALUES ("DN2_40","028_2_40","DAN","2","40","40","ⵓⵛⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵊⵀⴻⴷ ⴰⵎ ⵡⵓⵣⵣⴰⵍ, ⵎⴰⵖⴰⵔ ⵓⵣⵣⴰⵍ ⵉⵍⴻⴱⴱⴻⵣ ⵓ ⵉⴱⴰⵔⵔⵉ ⵎⴰⵔⵔⴰ, ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵡⵓⵣⵣⴰⵍ ⵎⴰⵔⵔⴰ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵍⴱⴻⵣ ⵓ ⵜⴱⴰⵔⵔⵉ ⵎⴰⵔⵔⴰ. * ");
INSERT INTO rift_vpl VALUES ("DN2_41","028_2_41","DAN","2","41","41","ⵓⵎⵉ ⵜⴻⵥⵔⵉⴷ ⴱⴻⵍⵍⵉ ⵉⴹⴰⵔⴻⵏ ⴷ ⵜⴼⴻⴷⵏⵉⵏ ⴰⵇⴰ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵜⴰⵔⵔⵉⵙⵜ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵓ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵡⵓⵣⵣⴰⵍ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵇⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵜⴻⵎⵙⴻⴱⴹⴰ. ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵀⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵉⵍⵉ ⵍⴻⵇⵙⴰⵃⴻⵜ ⴰⵎ ⵡⵓⵣⵣⴰⵍ, ⵎⴰⵖⴰⵔ ⵜⴻⵥⵔⵉⴷ ⵓⵣⵣⴰⵍ ⵉⵚⵚⵓⵔ ⵙ ⵜⴰⵔⵔⵉⵙⵜ ⵏ ⵜⵍⴰⵅⵜ. ");
INSERT INTO rift_vpl VALUES ("DN2_42","028_2_42","DAN","2","42","42","ⵓ ⵓⵎⵉ ⵜⴻⵥⵔⵉⴷ ⵜⵉⴼⴻⴷⵏⵉⵏ ⵏ ⵉⴹⴰⵔⴻⵏ, ⴰⵇⴰ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙ ⵡⵓⵣⵣⴰⵍ ⵓ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙ ⵜⴰⵔⵔⵉⵙⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵇⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⵉ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⴻⵙ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵉⵍⵉ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵓ ⵛⵡⴰⵢⵜ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵔⵅⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("DN2_43","028_2_43","DAN","2","43","43","ⵓ ⵓⵎⵉ ⵜⴻⵥⵔⵉⴹ ⴰⵇⴰ ⵓⵣⵣⴰⵍ ⵉⵚⵚⵓⵔ ⵙ ⵜⴰⵔⵔⵉⵙⵜ ⵏ ⵜⵍⴰⵅⵜ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵚⵚⵓⵔⴻⵏ ⵙ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵍⴻⵙⵙⵇⴻⵏ ⵛⴰ ⵉⵊⵊ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵡⴰ ⵡⴰⵔ ⵉⵍⴻⵙⵙⴻⵇ ⴰⴽ-ⴷ ⵡⴰ, ⴰⵎ ⵡⵓⵣⵣⴰⵍ ⵡⴰⵔ ⵉⵍⴻⵙⵙⵇⴻⵏ ⴰⴽ-ⴷ ⵜⵍⴰⵅⵜ. ");
INSERT INTO rift_vpl VALUES ("DN2_44","028_2_44","DAN","2","44","44","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴹⴻⵢⵢⵉⵄ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜᵉⵜⵜⵔⵉⵃ ⵄⴻⵎⵎⴰⵔⵚ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵜⴻⵍⴱⴻⵣ ⵓ ⴰⴷ ⵜⴻⴱⴹⴻⵍ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏⵏⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵜ ⵜⵉⵍⵉ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("DN2_45","028_2_45","DAN","2","45","45","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴻⵥⵔⵉⴷ, ⵉⵜⵜⵡⴰⵛⴻⴵⴻⵇ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⴱⵍⴰ ⵉⴼⴰⵙⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵍⴻⴱⵣⴻⵏ ⵓⵣⵣⴰⵍ ⴷ ⵜⴰⵔⵔⵉⵙⵜ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ. ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵇⴰ ⵉⵙⵙⵛⴻⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ. ⵜⴰⵔⵊⵉⵜ ⴰⵇⴰ ⵜⴱⴻⴷⴷ ⵓ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ ⴷ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("DN2_46","028_2_46","DAN","2","46","46","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵙⵊⴻⴷ ⵉ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵡⴻⵚⵚⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⴷ ⵍⴻⴱⵅⵓⵔ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("DN2_47","028_2_47","DAN","2","47","47","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵅ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵏⵏⴰ: “ⴷ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴳⴰⴱⴻⵏ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵉⵡⴹⴻⴷ ⴰⴷ ⵜⴽⴻⵛⴼⴻⴷ ⴰⵢⴰ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN2_48","028_2_48","DAN","2","48","48","ⵅⴰⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⴷⴰⵏⵉⵢⴰⵍ ⴰⵙⴻⵎⵖⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵉⵡⵛⴰ ⴰⵙ ⵜⵉⵔⵣⵉⴼⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ⵉⴳⴳⴰ ⵉ-ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⴱⴰⴱⵉⵍ ⵓ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵔⵔⴰⵢⵙ ⵅ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN2_49","028_2_49","DAN","2","49","49","ⵓ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⵓⵜⵔⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⴳⴳⴰ ⵙⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵅ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⴱⴰⴱⵉⵍ, ⵎⴰⵛⴰ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵍⴻⵇⵚⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN3_1","028_3_1","DAN","3","1","1","ⴰⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏ ⵡⵓⵔⴻⵖ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵓⵄⵍⴰ ⵏ ⵙⴻⵜⵜⵉⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵢⵉⵊⵊ ⵏ ⵜⵉⵔⵓ ⵏ ⵙⴻⵜⵜⴰ ⵏ ⵉⵖⴰⴵⴻⵏ. ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⵍⵡⴰⵟⴰ ⵏ ⴷⵓⵔⴰ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN3_2","028_3_2","DAN","3","2","2","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵍⵡⵓⵍⴰⵜ, ⵍⵇⵓⴹⴰⵜ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴷ ⵢⵉⵏⵏⵉ ⵅ ⵜⵅⵓⴱⴰⵢ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵣⴻⵔⴼⴰⵏ ⴷ ⵉⵎⵡⴻⴹⴹⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵛⵛⵔⴻⵄ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵖⴰⵔ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏⵏⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN3_3","028_3_3","DAN","3","3","3","ⵅⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵍⵡⵓⵍⴰⵜ ⴷ ⵍⵇⵓⴹⴰⵜ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴷ ⵢⵉⵏⵏⵉ ⵅ ⵜⵅⵓⴱⴰⵢ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵣⴻⵔⴼⴰⵏ ⴷ ⵉⵎⵡⴻⴹⴹⴼⴻⵏ ⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵛⵛⵔⴻⵄ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰⵜ ⵉ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵍⴻⵅⵢⴰⵍ ⵏⵏⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⵓ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏⵏⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN3_4","028_3_4","DAN","3","4","4","ⵉⵍⴰⵖⴰ ⵉⵊⵊ ⵏ ⵓⵎⴱⴰⵔⵔⴻⵃ ⵙ ⵊⵊⴻⵀⴷ ... “ⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ, ⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵍⵉⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵖⴰ ⵉⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("DN3_5","028_3_5","DAN","3","5","5","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⵙⵍⴻⵎ ⵍⵃⴻⵙⵙ ⵏ ⵍⴱⵓⵇ ⴷ ⵜⵣⴰⵎⵎⴰⵔⵜ ⴷ ⵍⵄⵓⴷ ⴷ ⵍⴳⴰⵎⴱⵔⵉ ⴷ ⵍⵀⴰⵔⴱⴰ ⴷ ⵜⴻⵎⵊⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⴵⵖⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵡⴹⴰⵎ ⴰⴷ ⵜⵙⴻⵊⴷⴻⵎ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN3_6","028_3_6","DAN","3","6","6","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵡⴹⵉⵏ ⵓ ⵡⴰⵔ ⵉⵙⵊⴻⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("DN3_7","028_3_7","DAN","3","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵙⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵍⴱⵓⵇ ⴷ ⵜⵣⴰⵎⴰⵔⵜ ⴷ ⵍⵄⵓⴷ ⴷ ⵍⴳⴰⵎⴱⵔⵉ ⴷ ⵍⵀⴰⵔⴱⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⴷⴷⵓⵣⴰⵏ ⵏ ⴵⵖⴰ, ⵡⴹⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵙⴻⵊⴷⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⵉⵙⵙⴱⴻⴷⴷ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN3_8","028_3_8","DAN","3","8","8","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷ ⵉⵛⵜⴻⵏ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵛⴰ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ, ⵛⴻⵜⵛⴰⵏ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵙ ⴱⵟⴰⵢⵟⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("DN3_9","028_3_9","DAN","3","9","9","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ: “ⴰ ⴰⵊⴻⴵⵉⴷ, ⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("DN3_10","028_3_10","DAN","3","10","10","ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵜⵓⵎⵓⵔⴻⴷ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵉⵙⵍⵉⵏ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵍⴱⵓⵇ ⴷ ⵜⵣⴰⵎⴰⵔⵜ ⴷ ⵍⵄⵓⴷ ⴷ ⵍⴳⴰⵎⴱⵔⵉ ⴷ ⵍⵀⴰⵔⴱⴰ ⴷ ⵜⴻⵎⵊⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⴷⴷⵓⵣⴰⵏ ⵏ ⴵⵖⴰ, ⴰⴷ ⵡⴹⴰⵏ ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DN3_11","028_3_11","DAN","3","11","11","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵡⴹⵉⵏ ⵓ ⵉⵙⵊⴻⴷ, ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN3_12","028_3_12","DAN","3","12","12","ⴰⵇⴰ ⴷⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵓⴷⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⴳⴳⵉⴷ ⵅ ⵓⴹⴻⴱⴱⴰⵔ ⵏ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⴱⴰⴱⵉⵍ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ. ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵡⴰⵔ ⵡⵛⵉⵏ ⵜⴰⵢⵏⵉⵜ ⵉ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵛ, ⴰ ⴰⵊⴻⴵⵉⴷ. ⴰⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ ⵓ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⴷ ⴰⵙ ⵙⴻⵊⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN3_13","028_3_13","DAN","3","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⴷⴻⴳ ⵓⵅⴻⵢⵢⴻⵇ ⴷ ⵜⴻⴼⵇⴻⵃⵜ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⴷ ⵏⴻⴷⵀⴻⵏ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ ⵣⵣⴰⵜⴻⵙ. ⵅⴻⵏⵏⵉ ⵏⴻⴷⵀⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN3_14","028_3_14","DAN","3","14","14","ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ ⵎⴰ ⵙ ⵏⴻⵄⵎⴰⴷⴰ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵎ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵜⵙⴻⵊⵊⴰⴷⴻⵎ ⵉ ⵍⴻⵅⵢⴰⵍ ⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("DN3_15","028_3_15","DAN","3","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ, ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⵙⵍⴻⵎ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵍⴱⵓⵇ ⴷ ⵜⵣⴰⵎⴰⵔⵜ ⴷ ⵍⵄⵓⴷ ⴷ ⵍⴳⴰⵎⴱⵔⵉ ⴷ ⵍⵀⴰⵔⴱⴰ ⴷ ⵜⴻⵎⵊⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⴷⴷⵓⵣⴰⵏ ⵏ ⴵⵖⴰ, ⵜⵡⴻⵊⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵡⴹⴰⵎ ⵓ ⴰⴷ ⵜⵙⴻⵊⴷⴻⵎ ⵉ ⵍⴻⵅⵢⴰⵍ ⵉ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵎⵍⵉⵃ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵙⴻⵊⴷⴻⵎ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔⴻⵎ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ⵓ ⵎⴰⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("DN3_16","028_3_16","DAN","3","16","16","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵛⴰⴷⵔⴰⵅ ⴷ ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ, ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ: “ⵡⴰⵔ ⵏⴻⵃⴷⴰⵊ ⴰⴷ ⵅⴰⴽ ⴷⴷ-ⵏⴰⵔⵔ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DN3_17","028_3_17","DAN","3","17","17","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵏⵏⵉ ⵏⵙⴻⵅⵅⴰⵔ, ⵖⴰⵔⴻⵙ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⴰ ⴰⵊⴻⴵⵉⴷ! ");
INSERT INTO rift_vpl VALUES ("DN3_18","028_3_18","DAN","3","18","18","ⵎⴰⵍⴰ ⵍⵍⴰ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴻⵇⵇⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵛ ⴷ ⵍⴻⵅⵢⴰⵍ ⵉ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⵛⴻⴽ, ⵡⴰⵔ ⴷ ⴰⵙ ⵏⵙⴻⵊⵊⴻⴷ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("DN3_19","028_3_19","DAN","3","19","19","ⵅⴻⵏⵏⵉ ⵉⵙⵄⴰⵔ ⵓⵊⴻⴵⵉⴹ ⵓ ⵜⴱⴻⴷⴷⴻⵍ ⵚⵚⵉⴼⴻⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ. ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⴷ ⴰⵔⵏⵉⵏ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵓⵎⴻⵏ ⵜⵜ ⵙⵙⴰⵔⴻⵇⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DN3_20","028_3_20","DAN","3","20","20","ⵓ ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵇⴰⵄ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵛⴰⵔⴼⴻⵏ ⵛⴰⴷⵔⴰⵅ ⴷ ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵏ ⴰⵎⵎⵓ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN3_21","028_3_21","DAN","3","21","21","ⵅⴻⵏⵏⵉ ⵜⵜⵡⴰⵛⴰⵔⴼⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⴽ-ⴷ ⵉⵙⴻⵍⵀⴰⵎⴻⵏ ⵏⵙⴻⵏ ⴷ ⵙⵙⵔⴰⵡⴻⵍ ⵏⵙⴻⵏ ⴷ ⵜⵛⵓⵛⵛⴰⵢ ⵏⵙⴻⵏ ⴷ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN3_22","028_3_22","DAN","3","22","22","ⵎⵉⵏⵣⵉ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵇⵙⴻⵃ ⴰⵟⵟⴰⵙ ⵓ ⵜⴰⴼⵇⵓⵏⵜ ⵜⴻⵃⵎⴰ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵏⵖⵉⵏ ⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵛⴰⴷⵔⴰⵅ ⴷ ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ, ");
INSERT INTO rift_vpl VALUES ("DN3_23","028_3_23","DAN","3","23","23","ⵓⵛⴰ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ, ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ, ⵡⴹⴰⵏ ⵜⵜⵡⴰⵛⴰⵔⴼⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN3_24","028_3_24","DAN","3","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⵉⴽⴽⴰⵔ ⴷⴻⵖⵢⴰ, ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰ ⵡⴰⵔ ⵏⴻⵏⴹⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⴼⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵏⵉⵛⴰⵏ, ⴰ ⴰⵊⴻⴵⵉⴷ” ");
INSERT INTO rift_vpl VALUES ("DN3_25","028_3_25","DAN","3","25","25","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵜⵜⵡⴰⵍⵉⵖ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⴳⴳⵉ ⵛⴰ ⵓ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("DN3_26","028_3_26","DAN","3","26","26","ⵅⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ, ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ, ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ, ⵄⴰⴱⴷ-ⵏⴰⵖⵓ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⴼⴼⵖⴻⵎ-ⴷⴷ ⵓ ⴰⵙⴻⵎ-ⴷⴷ ⴷⴰ!” ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ, ⵛⴰⴷⵔⴰⵅ ⴷ ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN3_27","028_3_27","DAN","3","27","27","ⵅⴻⵏⵏⵉ ⵙⵙⵎⵓⵏⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵥⵔⵉⵏ ⴰⵇⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴰⵔ ⵛⴰ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⴰⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵛⵎⵉⴹ ⵛⴰ ⵓ ⵉⵙⴻⵍⵀⴰⵎⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵍⴻⵇⴼⴻⵏ ⵓ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("DN3_28","028_3_28","DAN","3","28","28","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ ⵏ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ ⵓ ⵉⴼⴻⴽⴽ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⵉⵜⵜⴻⵛⵍⴻⵏ. ⵏⵉⵜⵏⵉ ⴱⴻⴹⵍⴻⵏ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵙⴻⵍⵍⵎⴻⵏ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵏⵉⵖ ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⵖⵉⵔ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN3_29","028_3_29","DAN","3","29","29","ⵅ ⵓⵢⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵉ ⵍⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⴷ ⵛⵛⴻⵄⴱ ⴷ ⵢⵉⵍⴻⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵇⵇⴼⴻⵏ ⴷⴻⴳ ⴰⵔⴻⴱⴱⵉ ⵏ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⵓⴱⴰⵢ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴼⴻⴽⴽ ⴰⵎⵎⵓ.” ");
INSERT INTO rift_vpl VALUES ("DN3_30","028_3_30","DAN","3","30","30","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⵛⵛⴰⵏ ⵉ ⵛⴰⴷⵔⴰⵅ, ⵎⵉⵛⴰⵅ ⴷ ⵄⴰⴱⴷ-ⵏⴰⵖⵓ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN3_31","028_3_31","DAN","3","31","31","“ⴰⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴻⵔ, ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ: ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("DN3_32","028_3_32","DAN","3","32","32","ⵉⵄⵊⴻⴱ ⴰⵢⵉ ⵍⵃⴰⵍ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("DN3_33","028_3_33","DAN","3","33","33","ⵎⴰⵎⵎⴻⵛ ⵎⵖⴰⵔⴻⵏⵜ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵎⵎⴻⵛ ⵊⴻⵀⴷⴻⵏⵜ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⴻⵙ! ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵉ ⵍⴻⴱⴷⴰ ⴷ ⵍⵎⵓⵍⴽ ⵏⵏⴻⵙ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("DN4_1","028_4_1","DAN","4","1","1","“ⵏⴻⵛⵛ, ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⴰⵎⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⵙ ⵜⵜⵉⵙⵉⵔ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DN4_2","028_4_2","DAN","4","2","2","ⵅⴻⵏⵏⵉ ⵥⵔⵉⵖ ⵉⵛⵜ ⵏ ⵜⴻⵔⵊⵉⵜ, ⵜⴻⵙⵙⵉⴳⴳⵯⴻⴷ ⴰⵢⵉ. ⵙⵙⵃⴻⵢⵢⴰⵔⴻⵏ ⴰⵢⵉ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵉ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ⵓⵍⴰ ⴷ ⵉⵡⴻⵃⵃⴰⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DN4_3","028_4_3","DAN","4","3","3","ⵙ ⵓⵢⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⵉ ⵍⵓⵎⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵣⵣⴰⵜⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ ⵙⵙⴰⵔⴳⴱⴻⵏ ⴰⴼⴻⵙⵙⴰⵔ ⵏ ⵜⴻⵔⵊⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("DN4_4","028_4_4","DAN","4","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵓ ⵏⴻⵛⵛ ⵄⴰⵡⴷⴻⵖ ⴰⵙⴻⵏ ⵜⴰⵔⵊⵉⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵙⵙⴰⵔⴳⴱⴻⵏ ⵅ ⵓⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN4_5","028_4_5","DAN","4","5","5","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⴷⴰⵏⵉⵢⴰⵍ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ ⵖⴰⵔ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵃⴰⵊⵉⵖ ⵜⴰⵔⵊⵉⵜ ⵓⵛⴰ ⵏⵏⵉⵖ: ");
INSERT INTO rift_vpl VALUES ("DN4_6","028_4_6","DAN","4","6","6","‘ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⵛⴻⴽ, ⴰ ⴰⵔⵔⴰⵢⵙ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ, ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉ ⴷⴰⵢⴻⴽ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵓ ⵡⴰⵔ ⵅⴰⴽ ⵉⵡⵄⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵙⵙⵉⵔ. ⵉⵏⵉ ⴰⵢⵉ ⵉⵡⴻⵃⵃⴰⵏ ⵏⵏⵉ ⵥⵔⵉⵖ ⴷ ⵓⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN4_7","028_4_7","DAN","4","7","7","ⵉⵡⴻⵃⵃⴰⵏ ⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ⴰⵇⴰ ⴷ ⵜⵉⵏⴰ: ⵏⴻⵛⵛ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵓⵖⴰ ⵜⵓⵄⵍⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DN4_8","028_4_8","DAN","4","8","8","ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵎⵖⴰⵔ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵊⵀⴻⴷ ⵓ ⵜⴰⵇⵉⵛⵛⴰⵜ ⵏⵏⴻⵙ ⵜⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓ ⵜᵉⵜⵜⵡⴰⵥⴰⵔⵔ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DN4_9","028_4_9","DAN","4","9","9","ⵜⵉⴼⵔⴰⵢ ⵏⵏⴻⵙ ⵚⴻⴱⵃⴻⵏⵜ ⵓ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⴰⵟⵟⴰⵙ ⵓ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵎⴰⵛⵛⴰ ⵉ ⵎⴰⵔⵔⴰ. ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏ ⵍⴻⵅⵍⴰ ⵓⴼⵉⵏ ⵜⵉⵍⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⵓ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⴻⴷⵖⴻⵏ ⵊⴰⵔ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⵓ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵛ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ.” ” ");
INSERT INTO rift_vpl VALUES ("DN4_10","028_4_10","DAN","4","10","10","“ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⵡⴻⵃⵃⴰⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ, ⵉⵊⵊ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵉⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DN4_11","028_4_11","DAN","4","11","11","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵙ ⵊⵊⴻⵀⴷ, ⵉⵏⵏⴰ ⴰⵎⵎⵓ: ‘ⵣⴷⴻⵎ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵓⵛⴰ ⵇⴻⵙⵙⴻⵎ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ. ⴽⴽⵙⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵜⵉⴼⵔⴰⵢ ⵏⵏⴻⵙ ⵓ ⵣⴻⴵⵄⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⴹⴰⴹ ⵣⵉ ⵊⴰⵔ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DN4_12","028_4_12","DAN","4","12","12","ⵎⴰⵛⴰ ⴻⵊⵊ ⵊⵊⴷⴻⵄ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵙ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵇⵇⵉⵎ ⵙ ⵉⵛⵜ ⵏ ⵜⵙⴰⵔⵔⵉⴼⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵏⵏⵃⴰⵙ ⵊⴰⵔ ⴰⵔⴱⵉⵄ ⴰⵣⵉⵣⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⵓⴼⴼ ⵙ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵍⴻⵡⵃⵓⵛ ⵊⴰⵔ ⵛⴱⴰⵔⵇ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DN4_13","028_4_13","DAN","4","13","13","ⴻⵊⵊ ⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⴱⴻⴷⴷⴻⵍ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⴻⵡⵛ ⴰⵙ ⵓⵍ ⵏ ⵉⵊⵊ ⵏ ⵍⵃⴰⵢⴰⵡⴰⵏ. ⴰⵎⵎⵓ ⵅⴰⵙ ⵉ ⵖⴰ ⵄⴷⵓⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("DN4_14","028_4_14","DAN","4","14","14","ⵜⴰⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵜⴱⴻⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵓ ⵜⵓⵜⵔⴰ-ⵢⴰ ⴰⵇⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴷ ⵏⴻⵄⵎⴻⵏ ⴰⵇⴰ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵖⴰⵔⴻⵙ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵅ ⵜⴳⴻⵍⴷⴰ ⵏ ⵢⴻⵡⴷⴰⵏ ⵓ ⴰⴷ ⵜⵜ ⵉⵡⵛ ⵉ ⵡⵉ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵅⴰⵙ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵓⵇⵍⵉⵍ ⵇⴰⵄ ⵊⴰⵔ ⵉⵡⴷⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("DN4_15","028_4_15","DAN","4","15","15","ⵜⴰⵔⵊⵉⵜ-ⴰ ⵥⵔⵉⵖ ⵜⵜ ⵏⴻⵛⵛ, ⴰⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ⵛⴻⴽ, ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⵉⵏⵉ ⴰⵢⵉ ⴰⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵡⵛⴻⵏ ⴰⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵀ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ, ⵎⵉⵏⵣⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("DN4_16","028_4_16","DAN","4","16","16","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴰⵏⵉⵢⴰⵍ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⵢⴰⵔⵊⴻⴼ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵓⵛⴰ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵏⵏⴻⵙ ⵙⵙⵃⴻⵢⵢⴰⵔⴻⵏ ⵜ. ⵉⵟⵟⴻⴼ ⵓⵊⴻⴵⵉⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⴻⵊⵊ ⵜⴰⵔⵊⵉⵜ ⴷ ⵓⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵛⴻⴽ ⵙⵙⵃⴻⵢⵢⴰⵔⴻⵏ!” ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⵊⵊ ⵜⴰⵔⵊⵉⵜ ⴰⴷ ⵜⵉⵍⵉ ⵅ ⵢⵉⵏⵏⵉ ⵛⴻⴽ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵓ ⴰⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("DN4_17","028_4_17","DAN","4","17","17","ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏⵏⵉ ⵜⴻⵥⵔⵉⴷ, ⵜⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵜⴻⵎⵖⴰⵔ ⵓ ⵜⴻⵊⵀⴻⴷ, ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵉⵡⴻⴹ ⵜⴰⵇⵉⵛⵛⴰⵜ ⵏⵏⴻⵙ ⴰⵍ ⴰⵊⴻⵏⵏⴰ ⵓ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("DN4_18","028_4_18","DAN","4","18","18","- ⵙ ⵜⴻⴼⵔⴰⵢ ⵏⵏⴻⵙ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴻⵏ ⵎⴰⵛⵛⴰ ⵉ ⵎⴰⵔⵔⴰ, ⵓ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵙ ⵣⴻⴷⴷⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵓⵍⴰ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⴻⴷⴷⵖⴻⵏ ⵊⴰⵔ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ - ");
INSERT INTO rift_vpl VALUES ("DN4_19","028_4_19","DAN","4","19","19","ⴰⵇⴰ ⴷ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵜⵊⴻⵀⴷⴻⴷ, ⵎⴰⵖⴰⵔ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵛ ⵜⴻⵎⵎⴰⵔⵏⵉ ⴰⵍⴰⵎⵉ ⵜⵉⵡⴻⴹ ⴰⵍ ⴰⵊⴻⵏⵏⴰ ⵓ ⵍⵎⵓⵍⴽ ⵏⵏⴻⵛ ⴰⵍ ⵟⵟⴰⵔⴼ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DN4_20","028_4_20","DAN","4","20","20","ⵓ ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵓⵊⴻⴵⵉⴷ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ, ⵉⵊⵊ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ, ⵉⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉ ⵉⵏⵏⴰⵏ: ‘ⵣⴷⴻⵎ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵓ ⵖⴻⴹⵍⴻⵎ ⵉ-ⵜⵜ, ⵎⴰⵛⴰ ⴻⵊⵊ ⵊⵊⴷⴻⵄ ⵙ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵛⴰⵍ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵔⵔⵉⴼⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵏⵏⵃⴰⵙ ⵊⴰⵔ ⴰⵔⴱⵉⵄ ⵏ ⵍⴻⵅⵍⴰ ⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⵓⴼⴼ ⵙ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵊⴰⵔ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⴰⵍⴰⵎⵉ ⵅⴰⵙ ⵄⴷⵓⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ!’, ");
INSERT INTO rift_vpl VALUES ("DN4_21","028_4_21","DAN","4","21","21","ⴰⵇⴰ ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵍⵎⴻⵄⵏⴰ ⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⵇⴰⵔⴰⵔ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵉⵊⵊ ⵏ ⵍⵇⴰⵔⴰⵔ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵅ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("DN4_22","028_4_22","DAN","4","22","22","ⴰⴷ ⵅⴰⴽ ⴰⵥⵥⵍⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴰⴽ-ⴷ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⴰⵎ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴰⴷ ⴰⴽ ⵙⵙⴻⵛⵛⴻⵏ ⴰⵔⴱⵉⵄ ⵓ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵓⴼⴼ. ⴰⵎⵎⵓ ⵉ ⵅⴰⴽ ⵖⴰ ⵄⴷⵓⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⴰⵍ ⵖⴰ ⵜⵏⴻⵄⵎⴻⴷ ⴰⵇⴰ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵜⴳⴻⵍⴷⴰ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵉⵜⵜⵉⵛ ⵉ-ⵜⵜ ⵉ ⵡⵉ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DN4_23","028_4_23","DAN","4","23","23","ⴰⵇⴰ ⵏⵏⴰⵏ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵊⵊ ⵊⵊⴷⴻⵄ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⴰⴽ-ⴷ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ, ⴰⵇⴰ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵅⵎⵉ ⵖⴰ ⵜⵏⴻⵄⵎⴻⴷ ⴰⵇⴰ ⵚⵚⵓⵍⵜⴰ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵉ ⵜⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("DN4_24","028_4_24","DAN","4","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵉⵍⵉ ⴰⴷ ⵢⵉⵍⵉ ⵛⵛⵡⴰⵔ ⵉⵏⵓ ⵉ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ. ⴰⵔⵥ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵙ ⵜⵙⴻⴳⴷⴰ ⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ ⵓⵎⵉ ⵜⴻⴳⴳⵉⴷ ⵙ ⵓⵃⵉⵏⵏⵉ ⵉ ⵍⵎⵓⵙⴰⴽⵉⵏ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵣⵣⵓⴳⴳⴰⵔ ⵜⵜⵉⵙⵉⵔ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DN4_25","028_4_25","DAN","4","25","25","ⵇⴰⵄ ⵎⴰⵏ ⴰⵢⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN4_26","028_4_26","DAN","4","26","26","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⵅ ⵜⵣⴻⵇⵇⴰ ⵏ ⵍⴻⵇⵚⴰⵔ ⵏ ⴱⴰⴱⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("DN4_27","028_4_27","DAN","4","27","27","ⵉⵙⵙⵉⵡⴻⵍ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴱⴰⴱⵉⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⵉ ⴱⵏⵉⵖ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵜⵣⴻⵎⵎⴰⵔ ⵉⵏⵓ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵜⴳⴻⵍⴷⴰ ⵓ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("DN4_28","028_4_28","DAN","4","28","28","ⵄⴰⴷ ⵜⵓⵖⴰ ⵡⴰⵡⴰⵍ-ⴰ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵜⴻⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ: ⵜⴰⴳⴻⵍⴷⴰ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("DN4_29","028_4_29","DAN","4","29","29","ⴰⴷ ⵅⴰⴽ ⴰⵥⵥⵍⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴰⴽ-ⴷ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⴰⵎ ⵍⴻⴱⵀⴰⵢⴻⵎ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵛⵛⴻⵏ ⴰⵔⴱⵉⵄ ⵓ ⴰⴷ ⵅⴰⴽ ⵄⴷⵓⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⴰⵍ ⵖⴰ ⵜⵏⴻⵄⵎⴻⴷ ⴰⵇⴰ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⴳⴻⵍⴷⴰ ⵏ ⵉⵡⴷⴰⵏ ⵖⴰⵔ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵓ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵡⵉ ⵉⵅⵙ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("DN4_30","028_4_30","DAN","4","30","30","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵉⵇⴼⴻⵍ ⵡⴰⵡⴰⵍ-ⴰ ⵅ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⵎⵉⵏⵣⵉ ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏ ⵉⵡⴷⴰⵏ. ⵜⵓⵖⴰ ⵉⵜⵜⴻⵜⵜ ⴰⵔⴱⵉⵄ ⴰⵎ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵉⵙⵙⵓⴼⴼ ⵉ-ⵜⵜ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⴷ ⴰⵣⵉⵔⴰⵔ ⴰⵎ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⴳⵉⴷⴰⵔⴻⵏ ⵓ ⴰⵛⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵏⵏⵉ ⵏ ⵉⵊⴹⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("DN4_31","028_4_31","DAN","4","31","31","ⴰⵡⴰⵔⵏⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ-ⴰ, ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵏⵏⴻⵛ, ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ ⵍⴻⵄⵇⴻⵍ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵚⴻⴱⵃⴻⵖ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵓ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵓ ⵙⵙⵄⵓⴵⴻⵖ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵖⴰⵔ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵚⵚⵓⵍⵟⴰ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵜⴻⵇⵇⵉⵎ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN4_32","028_4_32","DAN","4","32","32","ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵡⴰⵍⵓ ⵓ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵅⵙ ⵙ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵙ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵎⵏⴻⵄ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ?! ");
INSERT INTO rift_vpl VALUES ("DN4_33","028_4_33","DAN","4","33","33","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⴰⵢⵉ-ⴷⴷ ⵍⴻⵄⵇⴻⵍ. ⵓⵍⴰ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵜⴳⴻⵍⴷⴰ ⵉⵏⵓ ⴷ ⵍⵄⴰⴹⴰⵎⴰ ⵉⵏⵓ ⴷ ⵓⵛⴻⵡⵡⴰⵔ ⵉⵏⵓ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵅⴰⴼⵉ. ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵏⵓ ⴷ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⴰⵔⵣⵓⵏ ⵄⴰⵡⴻⴷ ⵅⴰⴼⵉ ⵓ ⵜⵜⵡⴰⵙⵙⵎⴻⵜⵏⴻⵖ ⴷⵉ ⵜⴳⴻⵍⴷⴰ ⵉⵏⵓ ⵓ ⵄⴰⴷ ⵉⵎⵎⴰⵔⵏⵉ ⴰⵢⵉ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DN4_34","028_4_34","DAN","4","34","34","ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛ, ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⵙⵙⵄⵓⴵⴻⵖ ⵓ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴰⵊⴻⴵⵉⴷ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏⵏⴻⵙ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ ⴷ ⵜⴰⵙⴻⴳⴷⴰ. ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵏⵏⴼⴰⵅⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("DN5_1","028_5_1","DAN","5","1","1","ⴰⵊⴻⴵⵉⴷ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵙⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵡⴰⵍⴻⴼ ⵏ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵡⴰ ⴱⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⴰⵍⴻⴼ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DN5_2","028_5_2","DAN","5","2","2","ⵍⴰⵎⵉ ⵉⵇⵇⴰⵙ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ ⴱⵉⵏⵓ, ⵢⵓⵎⴰⵔ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⵉ ⵉⴽⵙⵉ ⴱⴰⴱⴰⵙ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵓ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN5_3","028_5_3","DAN","5","3","3","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⵏⵏⵉ ⴷⴷ-ⴽⴽⵙⴻⵏ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵉⵙⵡⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN5_4","028_5_4","DAN","5","4","4","ⵏⵉⵜⵏⵉ ⵙⵡⵉⵏ ⴱⵉⵏⵓ ⵓ ⵚⴻⴱⴱⵃⴻⵏ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ ⴷ ⵡⴻⵥⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("DN5_5","028_5_5","DAN","5","5","5","ⴷⵉ ⵍⵡⴻⵇⵜ ⴷ ⵉⵛⵜ ⴹⵀⴰⵔⴻⵏ-ⴷⴷ ⵉⴹⴻⵡⴹⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⵉⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵉ ⵍⵇⴻⵏⴷⵉⵍ ⵅ ⵊⵊⴰⵔ ⵏ ⵍⵃⵉⴹ ⵏ ⵍⴻⵇⵚⴰⵔ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⵓⵛⴰ ⵉⵥⵔⴰ ⵓⵊⴻⴵⵉⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵓⴼⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DN5_6","028_5_6","DAN","5","6","6","ⵅⴻⵏⵏⵉ ⵜⴱⴻⴷⴷⴻⵍ ⵜⵉⵏⵜⴰ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵙ ⵙⵙⵉⴳⴳⵯⴷⴻⵏ ⵜ ⵓ ⵜⵉⵙⵖⵓⵏⵉⵏ ⵏ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏⵜ ⴼⴻⵙⵢⴻⵏⵜ ⵓ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ ⴷⴷⵓⵇⵣⴻⵏ ⵉⵊⵊ ⴰⵔⴻⵏⴷⴰⴷ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DN5_7","028_5_7","DAN","5","7","7","ⴰⵊⴻⴵⵉⴷ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵣⵣⴰⵜⴻⵙ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵓ ⴰⵊⴻⴵⵉⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⴱⴰⴱⵉⵍ: “ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵖⴰⵔ ⵜⵉⵔⴰ-ⵢⴰ ⵓ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵙⵙⵢⴰⵔⴹⴻⵏ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⴷ ⴰⴷⴻⵀⵎⴰⵏⵉ, ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("DN5_8","028_5_8","DAN","5","8","8","ⵅⴻⵏⵏⵉ ⵓⴷⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵏ ⵜⵉⵔⴰ ⵏⵏⵉ ⵓ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵙⵙⴰⵔⴳⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN5_9","028_5_9","DAN","5","9","9","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴻⵅⵍⴻⵄ ⵓⵊⴻⴵⵉⴷ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ ⵓ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵜⴱⴻⴷⴷⴻⵍ ⵓ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵇⵇⵉⵎⴻⵏ ⵃⴻⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN5_10","028_5_10","DAN","5","10","10","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵀⴰⵔⴷ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵜⵓⴷⴻⴼ ⵜⵊⴻⴵⵉⴷⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴻⵏⵙⵉ. ⵜⴻⵙⵙⵉⵡⴻⵍ ⵜⵊⴻⴵⵉⴷⵜ, ⵜⴻⵏⵏⴰ: “ⴰ ⴰⵊⴻⴵⵉⴷ, ⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ! ⴻⵊⵊ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵛⴻⴽ ⵙⵙⵏⴻⵅⵍⵉⵄⴻⵏ ⵓ ⴻⵊⵊ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⴱⴻⴷⴷⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("DN5_11","028_5_11","DAN","5","11","11","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ ⵉ ⴷⵉ ⵉⴵⴰ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴱⴰⴱⴰⵛ ⵓⴼⵉⵏ ⴷⴰⵢⴻⵙ ⵜⴰⴼⴰⵡⵜ, ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵜⵉⵖⵉⵜ ⴰⵎ ⵜⵉⵖⵉⵜ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⵓⵊⴻⴵⵉⴷ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ, ⴱⴰⴱⴰⵛ, ⴷ ⴰⵔⵔⴰⵢⵙ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⴷ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ, ⵡⴰⵀ, ⴱⴰⴱⴰⵛ, ⴰ ⴰⵊⴻⴵⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("DN5_12","028_5_12","DAN","5","12","12","ⵎⵉⵏⵣⵉ ⴷⵉ ⴷⴰⵏⵉⵢⴰⵍ, ⵉ ⵓⵎⵉ ⵉⴳⴳⴰ ⵓⵊⴻⴵⵉⴷ ⵉⵙⴻⵎ ⵏ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⴼ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵛⵏⴰ ⴰⵟⵟⴰⵙ ⴷ ⵜⵓⵙⵙⵏⴰ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴻⵙⵙⴰⵔ ⵜⵉⵔⵊⴰ ⵓ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵓ ⴰⴷ ⵉⴼⴻⴽⴽ ⵉⴼⴻⵇⵇⵓⵙⴻⵏ ⵉⵡⵄⴰⵔⴻⵏ. ⴻⵊⵊ ⴰⴷ ⵍⴰⵖⴰⵏ ⵅ ⴷⴰⵏⵉⵢⴰⵍ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN5_13","028_5_13","DAN","5","13","13","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⴷⴰⵏⵉⵢⴰⵍ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ. ⴰⵊⴻⴵⵉⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⴷⴰⵏⵉⵢⴰⵍ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵊⵊ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵢⵉⵡⵉ ⵓⵊⴻⴵⵉⴷ, ⴱⴰⴱⴰ, ⴰⴽⵉⴷⴻⵙ ⵣⵉ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("DN5_14","028_5_14","DAN","5","14","14","ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵅⴰⴽ, ⴰⵇⴰ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⴻⴽ, ⵓ ⵜᵉⵜⵜⵡⴰⴼ ⴷⴰⵢⴻⴽ ⵜⴰⴼⴰⵡⵜ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵜⵉⵖⵉⵜ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("DN5_15","028_5_15","DAN","5","15","15","ⴰⵇⴰ ⵏⴻⴷⵀⴻⵏ ⵣⵣⴰⵜⵉ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵉⵎⴻⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵏ ⵜⵉⵔⴰ-ⵢⴰ ⵓ ⴰⴷ ⵙⵙⴰⵔⴳⴱⴻⵏ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵙⵙⴰⵔⴳⴱⴻⵏ ⵅ ⵍⵎⴻⵄⵏⴰ ⵏ ⵡⴰⵡⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DN5_16","028_5_16","DAN","5","16","16","ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵙⵍⵉⵖ ⵅⴰⴽ ⴰⵇⴰ ⵛⴻⴽ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴼⴻⵙⵙⴰⵔⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵓ ⴰⴷ ⵜⴼⴻⴽⴽⴻⴷ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵡⵄⴰⵔⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵖⴰⵔⴻⴷ ⵜⵉⵔⴰ-ⵢⴰ ⵓ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴰⵔⴻⴳⴱⴻⴷ ⵅ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵛⴻⴽ ⵙⵙⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴰⴷⴻⵀⵎⴰⵏⵉ, ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵛ, ⵓ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵍⵃⴰⴽⴻⵎ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("DN5_17","028_5_17","DAN","5","17","17","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵏⵏⴰ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⵜⵉⵔⵣⵉⴼⵉⵏ ⵏⵏⴻⵛ ⴰⴷ ⵖⴰⵔⴻⴽ ⵇⵇⵉⵎⴻⵏⵜ ⵓ ⵛⵛⴰⵏ ⵏⵏⴻⵛ ⴻⵡⵛ ⵉ-ⵜ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵎⴰⵛⴰ ⵜⵉⵔⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵜⴻⵏⵜ ⵖⴰⵔⴻⵖ ⵓ ⴰⴷ ⵜ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅ ⵍⵎⴻⵄⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DN5_18","028_5_18","DAN","5","18","18","ⵅⴰⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵉⵡⵛⴰ ⵉ ⴱⴰⴱⴰⵛ ⵏⴰⴱⵓⵅⴰⴷⵏⴰⵚⵚⴰⵔ ⵜⴰⴳⴻⵍⴷⴰ ⵓⵍⴰ ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⴷ ⵛⵛⴰⵏ ⴷ ⵍⵄⴰⴹⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("DN5_19","028_5_19","DAN","5","19","19","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ, ⴷⴻⵡⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵜⵜⵇⴻⴼⵇⵉⴼⴻⵏ ⵣⵣⴰⵜⴻⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⴻⵇⵇ ⵡⴻⵏⵏⵉ ⵢⴻⵅⵙ, ⵉⵜⵜⴻⵊⵊⴰ ⵉⴷⴷⴰⵔ ⵡⴻⵏⵏⵉ ⵢⴻⵅⵙ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵡⴻⵏⵏⵉ ⵢⴻⵅⵙ ⵓ ⵉⵙⵙⴼⴻⵟⵟⴰⵃ ⵡⴻⵏⵏⵉ ⵢⴻⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DN5_20","028_5_20","DAN","5","20","20","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⴱⴷⴰ ⵓⵍ ⵏⵏⴻⵙ ⵉⵜⵜⵏⵓⵔⴼⵓⵄ ⵓ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵉⵜⵜⴻⵇⵙⴰⵃ ⴰⵍⴰⵎⵉ ⵜⴻⴷⵡⴻⵍ ⴷⴰⵢⴻⵙ ⵏⵏⴼⴰⵅⴻⵜ, ⵉⵜⵜⵡⴰⵖⴹⴻⵍ ⵣⵉ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵓ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN5_21","028_5_21","DAN","5","21","21","ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⴰⵎ ⵡⵓⵍ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴰⴽ-ⴷ ⵢⴻⵖⵢⴰⵍ ⵏ ⵍⴻⵅⵍⴰ. ⵡⵛⵉⵏ ⴰⵙ ⴰⵔⴱⵉⵄ ⴷ ⵎⴰⵛⵛⴰ ⴰⵎ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓ ⵏⵏⴷⴰ ⵏ ⵓⵊⴻⵏⵏⴰ ⵉⵙⵙⵓⴼⴼⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⵉⵏⵄⴻⵎ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵜⴳⴻⵍⴷⴰ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵉⵡⵛⴰ ⵉ-ⵜⵜ ⵉ ⵡⴻⵏⵏⵉ ⵢⴻⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DN5_22","028_5_22","DAN","5","22","22","ⵓ ⵛⴻⴽ, ⵎⵎⵉⵙ, ⴱⴰⵍⵛⴰⵚⵚⴰⵔ, ⵡⴰⵅⵅⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⴷ ⵓⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DN5_23","028_5_23","DAN","5","23","23","ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴹⵉⴷⴷ ⵉ ⵙⵉⴷⵉ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⵍⴻⵇⵛⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜⴻⴽ. ⵓ ⵛⴻⴽ ⴷ ⴰⵢⵜ ⵏ ⵚⵚⵓⵍⵜⴰ ⵏⵏⴻⵛ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵛ ⴷ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵛ ⵙⵡⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵛⴻⴽ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵚⴻⴱⴱⴰⵃⴻⴷ ⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴷ ⵡⵓⵣⵣⴰⵍ ⴷ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵡⴻⵥⵔⵓ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵄⵓⴵⵉⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("DN5_24","028_5_24","DAN","5","24","24","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ ⵉⴹⴻⵡⴹⴰⵏ ⵏ ⵓⴼⵓⵙ ⵏⵏⵉ ⵢⵓⵔⵉⵏ ⵜⵉⵔⴰ-ⵢⴰ ⵅ ⵍⵃⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("DN5_25","028_5_25","DAN","5","25","25","ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵉⵔⴰ ⵉ ⵢⵓⵔⵉⵏ: ‘ⵎⵉⵏⵉ, ⵎⵉⵏⵉ, ⵜⵉⴽⵉⵍ, ⵓⴼⴰⵔⵙⵉⵏ’. ");
INSERT INTO rift_vpl VALUES ("DN5_26","028_5_26","DAN","5","26","26","ⵡⴰ ⴷ ⵍⵎⴻⵄⵏⴰ ⵏ ⵡⴰⵡⴰⵍ-ⴰ. ‘ⵎⵉⵏⵉ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ, ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵃⵙⴻⴱ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵛ ⵓ ⵉⵇⴹⴰ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("DN5_27","028_5_27","DAN","5","27","27","‘ⵜⵉⴽⵉⵍ’, ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵡⴻⵣⵏⴻⴷ ⵅ ⵍⵎⵉⵣⴰⵏ ⵓ ⵓⴼⵉⵏ ⵛⴻⴽ ⵜⴻⴼⵙⵓⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("DN5_28","028_5_28","DAN","5","28","28","‘ⴼⴰⵔⵉⵙ’, ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ ⵜⴻⵎⵎⵙⴻⴱⴹⴰ ⵓ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⴰⵢⵜ ⵏ ⵎⴰⴷⴰⵢ ⴷ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN5_29","028_5_29","DAN","5","29","29","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵎⴰⵔ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵢⴰⵔⴹⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⴰⵔⵔⵓⴹ ⴰⴷⴻⵀⵎⴰⵏⵉ, ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴻⵏⴷⴻⵛⵜ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵙ, ⵓ ⴰⴷ ⵅⴰⵙ ⴱⴰⵔⵔⵃⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("DN5_30","028_5_30","DAN","5","30","30","ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⵖ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN6_1","028_6_1","DAN","6","1","1","ⴷⴰⵔⵉⵢⵓⵙ, ⴰⵎⴰⴷⴰⵢ, ⵉⴽⵙⵉ ⵜⴰⴳⴻⵍⴷⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵄⵍⴰⵃⴰⵍ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DN6_2","028_6_2","DAN","6","2","2","ⵢⴰⵔⴹⴰ ⴷⴰⵔⵉⵢⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵍⴻⵇⵇⴻⵎ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵎⴰⵏⵉ ⵎⴰ ⴷⵉ ⴽⵓⵍ ⵜⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("DN6_3","028_6_3","DAN","6","3","3","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵅⴰⵙⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ⵜⵓⵖⴰ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵏ ⵍⴻⵃⵙⴰⴱ, ⵃⵉⵎⴰ ⴰⵊⴻⴵⵉⴷ ⵡⴰⵔ ⵜ ⵜⵍⴻⵇⵇⴻⴼ ⵜⵅⴻⵙⵙⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DN6_4","028_6_4","DAN","6","4","4","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵄⴻⴷⴷⵓ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⵉ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵉⵛⵏⴰ ⴰⵟⵟⴰⵙ, ⵓ ⴰⵊⴻⴵⵉⴷ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵢⴻⴳⴳ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("DN6_5","028_6_5","DAN","6","5","5","ⵅⴻⵏⵏⵉ ⴰⵔⵣⵓⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⵛⵜ ⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⴰⵀⵎⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵉⵖ ⵍⵖⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⵉⴼ ⵍⴻⵄⴳⴻⵣ ⵏⵉⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵓⵔⴻⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DN6_6","028_6_6","DAN","6","6","6","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ: “ⵡⴰⵔ ⵏⴻⵜⵜⵉⴼ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵜⵜⵓⵀⵎⴻⵜ ⵅ ⴷⴰⵏⵉⵢⴰⵍ-ⴰ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵏⵓⴼⴰ ⵉ-ⵜⵜ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN6_7","028_6_7","DAN","6","7","7","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵓⵙⵉⵏ-ⴷⴷ ⵀⴰⵊⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ, ⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("DN6_8","028_6_8","DAN","6","8","8","ⵎⵛⴰⵡⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ: ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷ ⵉⵎⵛⴰⵡⴰⵔⴻⵏ ⴷ ⵍⵡⵓⵍⴰⵜ, ⵃⵉⵎⴰ ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉⵊⵊ ⵏ ⵍⵓⵎⵓⵔ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵃⴽⴰⵎ ⵉⵏⴻⵀⵀⴰⵏ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵉⵛⵜ ⵏ ⵜⵓⵜⵔⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵉⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⵖⵉⵔ ⵉ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⴷⵉ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN6_9","028_6_9","DAN","6","9","9","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵙⴻⴽⴽⴰⵔ ⵍⵓⵎⵓⵔ ⵓ ⵡⴻⵇⵇⴻⵄ ⵜⵉⵔⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴱⴻⵟⵟⴻⵍ ⵍⵓⵎⵓⵔ ⵓ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⵓⵍ ⵍⵇⴰⵏⵓⵏ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⴷⴰⵢ ⴷ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN6_10","028_6_10","DAN","6","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⵢⵓⵔⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ ⵜⵉⵔⴰ ⴷ ⵍⵓⵎⵓⵔ ⵏⵏⵉ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN6_11","028_6_11","DAN","6","11","11","ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⴰⵇⴰ ⵜⵉⵔⴰ-ⵢⴰ ⵜᵉⵜⵜⵡⴰⵡⴻⵇⵇⴻⵄ, ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵜⵉⴱⵓⵔⵊⴰⵜⵉⵏ ⵏ ⵜⵖⵓⵔⴼⴻⵜ ⵏⵏⴻⵙ ⴰⵔⴻⵣⵎⴻⵏⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵜⵜⴰ ⵉⵙⵊⴻⴷ ⴷⵉⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ, ⵉⵥⵥⵓⴵ ⵓ ⵉⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DN6_12","028_6_12","DAN","6","12","12","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙ ⵓⵀⴰⵊⵉ ⵓⵛⴰ ⵓⴼⵉⵏ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵜⵜⵥⴰⴵⴰ ⵓ ⵉⵜⵜⵣⴰⵡⴰⴳ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN6_13","028_6_13","DAN","6","13","13","ⵅⴻⵏⵏⵉ ⵓⴷⴼⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓ ⵙⵙⵉⵡⵍⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ: “ⵎⴰ ⵡⴰⵔ ⵜⵡⴻⵇⵇⵄⴻⴷ ⵛⴰ ⵉⵊⵊ ⵏ ⵍⵓⵎⵓⵔ ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ, ⴷⵉ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵖⴰ ⵉⵇⴻⴷⴷⵎⴻⵏ ⵉⵛⵜ ⵏ ⵜⵓⵜⵔⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵉⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⵖⵉⵔ ⵉ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⴰⴷ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵏⵏⴰ: “ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜⴱⴻⴷⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵇⴰⵏⵓⵏ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⴷⴰⵢ ⴷ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ ⵏⵏⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN6_14","028_6_14","DAN","6","14","14","ⵅⴻⵏⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵓⵊⴻⴵⵉⴷ: “ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵓⵍⴰ ⴷ ⵍⵓⵎⵓⵔ ⵏⵏⵉ ⵜⵡⴻⵇⵇⵄⴻⴷ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⵥⴰⴵⴰ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ.” ");
INSERT INTO rift_vpl VALUES ("DN6_15","028_6_15","DAN","6","15","15","ⵓⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⴰⵡⴰⵍ-ⴰ, ⵉⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵅ ⵡⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴻⴽⴽ ⴷⴰⵏⵉⵢⴰⵍ. ⴰⵍ ⴰⵖⴻⴵⴰⵢ ⵏ ⵜⴼⵓⵛⵜ ⵉⴳⴳⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DN6_16","028_6_16","DAN","6","16","16","ⵅⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵙ ⵓⵀⴰⵊⵉ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵏⵏⴰⵏ ⵉ ⵓⵊⴻⴵⵉⴷ: “ⴰ ⴰⵊⴻⴵⵉⴷ, ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⵇⴰⵏⵓⵏ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⴷⴰⵢ ⴷ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ ⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴻⴷⴷⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵍⵓⵎⵓⵔ ⵏⵉⵖ ⴷ ⵍⴻⵃⴽⴰⵎ ⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵊⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("DN6_17","028_6_17","DAN","6","17","17","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⵏⴻⴷⵀⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⵣⵣⴰⵜⴻⵙ ⵓ ⵏⴹⴰⵔⴻⵏ ⵜ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ. ⴰⵊⴻⴵⵉⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⴷⴰⵏⵉⵢⴰⵍ: “ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵜⵡⴻⵇⵇⴰⵔⴻⴷ ⵍⴻⴱⴷⴰ, ⴰⴷ ⵛⴻⴽ ⵉⴼⴻⴽⴽ!” ");
INSERT INTO rift_vpl VALUES ("DN6_18","028_6_18","DAN","6","18","18","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵓⵛⴰ ⵉⵛⴻⵎⵎⴻⵄ ⵉ-ⵜ ⵓⵊⴻⴵⵉⴷ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏⵏⴻⵙ ⵓⵍⴰ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉⵍ ⴰⵔⵔⴰⵢ ⵅ ⴷⴰⵏⵉⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("DN6_19","028_6_19","DAN","6","19","19","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵓⵊⴻⴵⵉⴷ ⵖⴰⵔ ⵍⴻⵇⵚⴰⵔ ⵏⵏⴻⵙ. ⵉⵙⵙⴻⵄⴷⵓ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⴷⴻⴳ ⵓⵥⵓⵎⵎⵉ ⵓ ⵡⴰⵔ ⵢⴻⵊⵊⵉ ⴰⴷ ⴰⵙ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴰⴼⴰⵔⵔⴻⵊ ⵓⵛⴰ ⵉⴹⵡⴰ ⵣⵣⴰⵢⴻⵙ ⵢⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("DN6_20","028_6_20","DAN","6","20","20","ⵣⵉⵛ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵖⴰⵔ ⵡⴻⵏⵇⴰⵔ ⵏ ⵜⴼⴰⵡⵜ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ, ⵉⵜⵜⴰⵥⵥⴻⵍ ⵖⴰⵔ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN6_21","028_6_21","DAN","6","21","21","ⵓⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵜⴻⵙⵔⴰⴼⵜ, ⵉⵍⴰⵖⴰ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵛⴹⴻⵏ ⵅ ⴷⴰⵏⵉⵢⴰⵍ. ⴰⵊⴻⴵⵉⴷ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ ⵉ ⴷⴰⵏⵉⵢⴰⵍ: “ⴰ ⴷⴰⵏⵉⵢⴰⵍ, ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ! ⵎⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵜⵡⴻⵇⵇⴰⵔⴻⴷ ⵍⴻⴱⴷⴰ, ⵎⴰ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵛⴻⴽ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵉⵢⵔⴰⴷⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("DN6_22","028_6_22","DAN","6","22","22","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵏⵉⵢⴰⵍ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ “ⴰ ⴰⵊⴻⴵⵉⴷ, ⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("DN6_23","028_6_23","DAN","6","23","23","ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ ⵓ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ. ⵜⵓⵖⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⵢⵣⵎⴻⵏ ⵎⴰⵖⴰⵔ ⵢⵓⴼⴰ ⴰⵢⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵣⵣⴰⵜⴻⵙ. ⵓⵍⴰ ⴰⴽⵉⴷⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵡⴰⵔ ⴳⴳⵉⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵊⴰⵔⵉⵎⴰ!” ");
INSERT INTO rift_vpl VALUES ("DN6_24","028_6_24","DAN","6","24","24","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵃ ⵓⵊⴻⴵⵉⴷ ⴰⵟⵟⴰⵙ, ⵢⵓⵎⵓⵔ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⵣⵉ ⵜⴻⵙⵔⴰⴼⵜ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵉⵡⵢⴻⵏ ⵣⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵛⴻⵍ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN6_25","028_6_25","DAN","6","25","25","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵓⵊⴻⴵⵉⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵀⵎⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ. ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵉⵡⵉⴹⴻⵏ ⵛⴰ ⵖⴰⵔ ⵜⵉⵙⵉ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵓⵎⵉ ⵜⴻⵏ ⵟⵟⴼⴻⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵓⵛⴰ ⵎⴻⵣⵣⵇⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵖⵙⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN6_26","028_6_26","DAN","6","26","26","ⵅⴻⵏⵏⵉ ⵢⵓⵔⴰ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ: “ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DN6_27","028_6_27","DAN","6","27","27","ⴰⵇⴰ ⵙⵙⵓⴼⴼⵖⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵓⵎⵓⵔ ⵃⵉⵎⴰ ⵉⵎⴻⵣⴷⴰⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ, ⵜⴻⵏⵏⵉ ⵅ ⵚⴻⵍⵍⵟⴻⵖ, ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵓ ⴰⴷ ⵇⴻⴼⵇⴼⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⴷⴰⵏⵉⵢⴰⵍ ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ ⵓ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜ ⴹⴰⵔⵔⴻⵏ ⵓ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("DN6_28","028_6_28","DAN","6","28","28","ⵏⴻⵜⵜⴰ ⵉⴼⴻⴽⴽ ⵓ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵓ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵉⴼⴻⴽⴽⴻⵏ ⵓ ⵉⵙⵙⴻⵏⵊⵎⴻⵏ ⴷⴰⵏⵉⵢⴰⵍ ⵣⴻⴳ ⵡⴰⵛⵛⴰⵔⴻⵏ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN6_29","028_6_29","DAN","6","29","29","ⴷⴰⵏⵉⵢⴰⵍ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⴼⵍⴻⵃ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴰⴳⴻⵍⴷⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴷⴰⵔⵉⵢⵓⵙ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⴽⵓⵔⴰⵛ, ⴰⴼⴰⵔⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("DN7_1","028_7_1","DAN","7","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴱⴰⴱⵉⵍ, ⵉⵥⵔⴰ ⴷⴰⵏⵉⵢⴰⵍ ⵉⵛⵜ ⵏ ⵜⴰⵔⵊⵉⵜ ⴷ ⵉⵡⴻⵃⵃⴰⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⵉ ⵜⴰⵙⵙⵓⵜ. ⵅⴻⵏⵏⵉ ⵢⵓⵔⴰ ⵜⴰⵔⵊⵉⵜ ⵏⵏⵉ ⵓⵛⴰ ⵉⵃⴰⵊⴰ ⵣⵣⴰⵢⴻⵙ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DN7_2","028_7_2","DAN","7","2","2","ⵉⵙⵙⵉⵡⴻⵍ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵏⵏⴰ: “ⵜⵡⴰⵍⵉⵖ ⵙ ⴵⵉⵍⴻⵜ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵙⵙⵀⴻⵡⵍⴻⵏ ⵍⴻⴱⵃⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("DN7_3","028_7_3","DAN","7","3","3","ⵓⵛⴰ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵡⵙⴻⵏ ⵛⴰ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ, ⴳⴻⵄⵄⴷⴻⵏ-ⴷⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN7_4","028_7_4","DAN","7","4","4","ⵜⵓⵖⴰ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵎ ⵡⴻⵢⵔⴰⴷ, ⵖⴰⵔⴻⵙ ⴰⴼⵔⵉⵡⴻⵏ ⴰⵎ ⵓⴳⵉⴷⴻⵔ. ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵅⴻⵣⵣⴰⵔⴻⵖ ⴰⵍⴰⵎⵉ ⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ. ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵉⵊⵊ ⵏ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DN7_5","028_7_5","DAN","7","5","5","ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵢⴰⵔⵡⴻⵙ ⴷⵉ ⴷⴷⵓⴱ ⵓ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵊⴰⵔ ⵜⴻⵖⵎⴰⵙ ⵏⵏⴻⵙ ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵖⵙⴰⵏ ⵏ ⵜⵖⴻⵣⴷⵉⵙⵜ ⵣⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ, ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: ‘ⴽⴽⴰⵔ, ⴻⵛⵛ ⴰⵟⵟⴰⵙ ⵏ ⵡⴻⵢⵙⵓⵎ!’ ");
INSERT INTO rift_vpl VALUES ("DN7_6","028_7_6","DAN","7","6","6","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵡⴰⵍⵉⵖ ⵄⴰⵡⴻⴷ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵓⵖⵉⵍⴰⵙ. ⵖⴰⵔⴻⵙ ⵅ ⵡⴻⵄⵔⵓⵔ ⵏⵏⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵊⴹⵉⴹ. ⴰⵎⵓⴷⴷⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵓⵛⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵚⵚⵓⵍⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("DN7_7","028_7_7","DAN","7","7","7","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵡⴰⵍⵉⵖ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵉⵡⴻⵃⵃⴰⵏ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵓ ⵅⵣⴰⵔ, ⴰⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⵓ ⵉⵙⵙⵏⴻⵅⵍⴰⵄ ⵓ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵊⵊⴻⵀⴷ. ⵖⴰⵔⴻⵙ ⵜⵉⵖⵎⴰⵙ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵉⵛⵛⴰ, ⵉⵍⴱⴻⵣ ⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉⵄⴼⴻⵙ ⵅⴰⵙ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵜⵓⵖⴰ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_8","028_7_8","DAN","7","8","8","ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴰⵛⵛⴰⵡ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵉⴳⴻⵄⵄⴻⴷ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓ ⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏ-ⴷⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵓⵛⴰ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ. ⵓ ⵅⵣⴰⵔ, ⴷⴻⴳ ⵡⴰⵛⵛⴰⵡ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵅⵎⵉ ⴷⴰⵢⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⵢⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⴼⴹⴰⵢⴻⵃ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_9","028_7_9","DAN","7","9","9","ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵡⴰⵍⵉⵖ ⴰⵍⴰⵎⵉ ⵎⵎⴰⵔⵙⴻⵏ ⵍⴻⴽⵔⴰⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵓⵡⴻⵙⵙⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴰⵎ ⵡⴻⴷⴼⴻⵍ ⵓ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⴰⵎ ⵜⴰⴹⵓⴼⵜ ⵜⴻⵚⴼⴰ. ⵍⴽⵓⵔⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_10","028_7_10","DAN","7","10","10","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵜⵎⴻⵙⵙⵉ. ⴰⵍⴻⴼ ⵅ ⵍⵓⵍⵓⴼ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴰⵏ ⴰⵙ ⵓ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⴻⵙ. ⴰⴳⵔⴰⵡ ⵏ ⵛⵛⵔⴻⵄ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵓⵖⵉⵎⵉ ⵓⵛⴰ ⵏⵏⵓⵔⵣⵎⴻⵏ ⵉⴷⵍⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_11","028_7_11","DAN","7","11","11","ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵢⵉⵛⵛ ⵏⵏⵉ. ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵅⴻⵣⵣⴰⵔⴻⵖ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵓⵎⵓⴷⴷⴰⵔ ⵓ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵓ ⵉⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ ⵉ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_12","028_7_12","DAN","7","12","12","ⵓⵍⴰ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⴰⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵙⴻⵏ ⵓ ⵉⵎⵎⴻⵡⵛ ⴰⵙⴻⵏ ⵜⴰⵣⵣⵓⴳⴳⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⴰⵍ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵓ ⴰⵍ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_13","028_7_13","DAN","7","13","13","ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵡⴰⵍⵉⵖ ⴷⵉ ⵉⵡⴻⵃⵃⴰⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵓ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓ ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⵓⵡⴻⵙⵙⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⵛⴰ ⵙⵙⵇⴰⵔⵔⴱⴻⵏ ⵜ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN7_14","028_7_14","DAN","7","14","14","ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⴷ ⵛⵛⴰⵏ ⴷ ⵜⴳⴻⵍⴷⴰ, ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵙ. ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵚⵚⵓⵍⵟⴰ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⵓ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⴹⴰⵔⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_15","028_7_15","DAN","7","15","15","ⵏⴻⵛⵛ, ⴷⴰⵏⵉⵢⴰⵍ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵃⵉⵙⵙⴻⴼ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⴷⴰⵅⴻⵍ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵓ ⵉⵡⴻⵃⵃⴰⵏ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ ⵙⵙⴻⵏⵅⴻⵍⵄⴻⵏⵜ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("DN7_16","028_7_16","DAN","7","16","16","ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵓ ⵙⵙⴻⵇⵙⵉⵖ ⵜ ⵅ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⴰⴽⵉⴷⵉ, ⵉⵛⴰⵔⵔⴻⵃ ⴰⵢⵉ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DN7_17","028_7_17","DAN","7","17","17","“ⵉⵎⵓⴷⴷⴰⵔⴻⵏ-ⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⴰⵔⴻⴱⵄⴰ ⵏⵏⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DN7_18","028_7_18","DAN","7","18","18","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵓ ⵜⴰⴳⴻⵍⴷⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵀ, ⵉ ⵍⴻⴱⴷⴰ ⵏ ⵍⴻⴱⴷⴰⵢⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("DN7_19","028_7_19","DAN","7","19","19","ⵅⴻⵏⵏⵉ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵏⴻⵖ ⵍⵎⴻⵄⵏⴰ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵎⵎⵙⴻⴱⴹⴰ ⴰⵟⵟⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⴻⵖⵏⵉ, ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⴱⵍⴰ ⵍⵃⴻⴷ. ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵜⵉⵖⵎⴰⵙ ⵏ ⵡⵓⵣⵣⴰⵍ ⴷ ⵡⴰⵛⵛⴰⵔⴻⵏ ⵏ ⵏⵏⵃⴰⵙ, ⵉⵛⵛⴰ, ⵉⵍⴱⴻⵣ ⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉⵄⴼⴻⵙ ⵅⴰⵙ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN7_20","028_7_20","DAN","7","20","20","ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵏⴻⵖ ⵄⴰⵡⴻⴷ ⵍⵎⴻⵄⵏⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵉ ⵓⵎⵉ ⴷⴷ-ⵡⴹⴰⵏ ⵜⵍⴰⵜⴰ ⵣⵣⴰⵜⴻⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏ ⵅ ⵢⵉⵛⵛ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷ ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵛⵛⵓⵔ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴱⴰⵏ-ⴷⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("DN7_21","028_7_21","DAN","7","21","21","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴰⵇⴰ ⵉⵛⵛ ⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽ-ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵉⵖⴻⵍⵍⴻⴱ ⵅⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DN7_22","028_7_22","DAN","7","22","22","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵎⵖⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓ ⵢⵓⵖⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵜⵙⴰⵄⵄⴻⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("DN7_23","028_7_23","DAN","7","23","23","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵎⵎⵓ: “ⴰⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⴻⵎⵙⴻⴱⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵢⴻⵛⵛ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵅⴰⵙ ⵉⵄⴼⴻⵙ ⵓ ⴰⴷ ⵜⵜ ⵉⵍⴱⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("DN7_24","028_7_24","DAN","7","24","24","ⵓ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ, ⴰⵇⴰ ⵣⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴰⴷ ⵉⴽⴽⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⴻⴵ ⵜⵍⴰⵜⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN7_25","028_7_25","DAN","7","25","25","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵄⴻⴼⴼⴰⵔ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵎⵄⵓⴵⵉ ⵏ ⴽⵓⵍⵛⵉ ⵓ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵓ ⴰⴷ ⵢⴰⵔⵣⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⴻⴷⴷⴻⵍ ⵣⵣⵎⴰⵏⴰⵜ ⴷ ⵛⵛⴰⵔⵉⵄⴰ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⴻⵡⵛⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⵍⴻⵡⵇⴰⵜ ⴷ ⵉⵊⵊ ⵡⴻⵣⵢⴻⵏ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("DN7_26","028_7_26","DAN","7","26","26","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⵡⴻⴳⵔⴰⵡ ⵏ ⵛⵛⵔⴻⵄ ⴷⴻⴳ ⵓⵖⵉⵎⵉ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰ ⴰⵎ ⵉⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("DN7_27","028_7_27","DAN","7","27","27","ⵎⴰⵛⴰ ⵜⴰⴳⴻⵍⴷⴰ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵎⵎⴻⵡⵛⴻⵏⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⴰⴷ ⵜ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵓ ⴰⴷ ⴰⵙ ⵟⴰⵄⴻⵏ ⵉ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("DN7_28","028_7_28","DAN","7","28","28","ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵡⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ. ⵅⴰⴼⵉ ⵏⴻⵛⵛ, ⵏⴻⵛⵛ ⴷⴰⵏⵉⵢⴰⵍ, ⴰⵇⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵏⵓ ⵙⵙⴻⵏⵅⴻⵍⵄⴻⵏ ⴰⵢⵉ ⵓ ⵜⵉⵙⵙⵉⵇⵜ ⵜⵔⵓⵃ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⴰⵡⴰⵍ ⵏⵏⵉ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ. ⴰⵍ ⴷⴰⵏⵉⵜⴰ ⵉ ⵜⵉⵡⴻⴹ ⵜⵉⵔⴰ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵜⵔⴰⵎⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("DN8_1","028_8_1","DAN","8","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴱⴰⵍⵛⴰⵚⵚⴰⵔ, ⵉⴱⴰⵏ-ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ, ⵉ ⵏⴻⵛⵛ ⴷⴰⵏⵉⵢⴰⵍ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⴻⵡⵃⵉⵢ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴱⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN8_2","028_8_2","DAN","8","2","2","ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵍⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵓ ⵥⵔⵉⵖ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⴱⵓⵔⵊ ⵏ ⵛⵓⵛⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵄⴰⵎⴰⵍⴰ ⵏ ⵄⵉⵍⴰⵎ. ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⴷⵉ ⵍⴻⵡⵃⵉⵢ ⵜⵓⵖⴰ ⴰⵢⵉ ⵖⴰⵔ ⵢⴻⵖⵣⴰⵔ ⵏ ⵓⵍⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("DN8_3","028_8_3","DAN","8","3","3","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵉⵖⵣⴰⵔ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵓ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵣⵉⵔⴰⵔⴻⵏ. ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵢⵉⵛⵛ ⵣⵣⴰⵢⵙⴻⵏ ⵢⵓⵄⵍⴰ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵡⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵉⴳⴻⵄⵄⴻⴷ ⴷ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN8_4","028_8_4","DAN","8","4","4","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴰⵇⴰ ⵉⵛⴰⵔⵔⵉ ⵉⵛⵛⴰⵜ ⵙ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵖⴰⵔⴱ ⵓ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⴷ ⵍⵊⴰⵏⵓⴱ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⴻⵙ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵡⵉ ⵖⴰ ⵉⵏⴻⵊⵎⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⵉⵅⵙ ⵓ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN8_5","028_8_5","DAN","8","5","5","ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵃⴻⴽⴽⴰⵔⴻⵖ, ⵓ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵎⵢⴰⵏ ⵣⵉ ⵍⵖⴰⵔⴱ ⵅ ⵎⴰⵔⵔⴰ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵉⵃⵉⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ. ⴰⵎⵢⴰⵏ-ⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⴷⴷⴻⴳ ⵏ ⵢⵉⵛⵛ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ ⵍⵇⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DN8_6","028_8_6","DAN","8","6","6","ⵏⴻⵜⵜⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵉⵛⴰⵔⵔⵉ ⵏⵏⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ, ⵡⴻⵏⵏⵉ ⵥⵔⵉⵖ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵉⵖⵣⴰⵔ. ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵙ ⵜⴻⵣⵍⴰ ⴰⴽ-ⴷ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("DN8_7","028_8_7","DAN","8","7","7","ⵓ ⵥⵔⵉⵖ ⴰⵇⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵉⵛⵛⴰⵜ ⴷⴰⵢⴻⵙ ⵙ ⵜⴻⵢⵢⵉⵜⴰ ⵇⴻⵙⵃⴻⵏⵜ. ⵏⴻⵜⵜⴰ ⵉⵎⵇⴰⵔⵇⴻⴱ ⴰⴽ-ⴷ ⵉⵛⴰⵔⵔⵉ ⵓ ⵢⴰⵔⵥⴰ ⴰⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵛⴰⵔⵔⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵊⵊⴻⵃⴷ ⵄⴰⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ. ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵢⴰⵔⴼⴻⵙ ⵉ-ⵜ ⵓ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵜ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN8_8","028_8_8","DAN","8","8","8","ⴰⵎⵢⴰⵏ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵎⴰⵛⴰ ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ, ⵢⴰⵔⵥⴰ ⵢⵉⵛⵛ ⵏⵏⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵛⴰ ⵅⴻⵍⴼⴻⵏ-ⴷⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DN8_9","028_8_9","DAN","8","9","9","ⵣⴻⴳ ⵢⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵢⵉⵛⵛ ⴷ ⴰⵎⴻⵄⵏⴰⵏ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵓ ⵖⴰⵔ ⵛⵛⴰⵔⵇ ⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵍⵡⵉⵣⵜ. ");
INSERT INTO rift_vpl VALUES ("DN8_10","028_8_10","DAN","8","10","10","ⵉⴷⵡⴻⵍ ⵉⵎⵖⴰⵔ ⵉⴳⴻⵄⵄⴻⴷ ⴰⵍ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⵏⴹⴰⵔ-ⴷⴷ ⵛⴰ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵣⵉ ⵢⴻⵜⵔⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵢⴰⵔⴼⴻⵙ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN8_11","028_8_11","DAN","8","11","11","ⵡⴰⵀ, ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ⵡⴰⵏⵉⵜⴰ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN8_12","028_8_12","DAN","8","12","12","ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵅ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⴷⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⴷⴷⵉ ⵓⵛⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ-ⴷⴷ ⵜⵉⴷⴻⵜⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵉⴼⴼⴻⵖ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("DN8_13","028_8_13","DAN","8","13","13","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵙⵍⵉⵖ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵉⵙⵙⴰⵡⴰⵍ ⵓ ⵉⵏⵏⴰ ⵉⵊⵊ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ: “ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵍⴻⵡⵃⵉⵢ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⴷⴰ ⴷ ⵏⵏⵄⵉ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴰⵇⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴼⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("DN8_14","028_8_14","DAN","8","14","14","ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⵍ ⴰⵍⴼⴰⵢⴻⵏ ⴷ ⵜⴻⵍⵜ-ⵎⵢⴰ ⵏ ⵜⵎⴻⴷⴷⵉⵜⵉⵏ ⴷ ⵜⵓⴼⴼⵓⵜⵉⵏ, ⵅⴻⵏⵏⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴳⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("DN8_15","028_8_15","DAN","8","15","15","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⵍⴰⵎⵉ ⵏⴻⵛⵛ, ⴷⴰⵏⵉⵢⴰⵍ, ⵥⵔⵉⵖ ⵍⴻⵡⵃⵉⵢ ⵏⵏⵉ ⵓ ⴰⵔⵣⵓⵖ ⴰⴷ ⵙⵙⵏⴻⵖ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⵉ ⴰⵎ ⵡⴰⴷⴷⵓⴷ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("DN8_16","028_8_16","DAN","8","16","16","ⵓⵛⴰ ⵙⵍⵉⵖ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵊⴰⵔ ⵜⴻⵎⵎⴰⵡⵉⵏ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵓⵍⴰⵢ, ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⵊⵉⴱⵔⵉⵍ, ⴼⴻⵙⵙⴰⵔ ⴰⵙ ⵍⴻⵡⵃⵉⵢ!” ");
INSERT INTO rift_vpl VALUES ("DN8_17","028_8_17","DAN","8","17","17","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵉⵏⵓ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴱⴻⴷⴷⵉⵖ ⵓ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ, ⵏⵏⵅⴻⵍⵄⴻⵖ ⵓ ⵡⴹⵉⵖ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵙⵙⴻⵏ ⴰⵇⴰ ⵍⴻⵡⵃⵉⵢ ⵉⵍⴻⵇⵇⴻⴼ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴻⴳⴳⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("DN8_18","028_8_18","DAN","8","18","18","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍ, ⵀⵡⵉⵖ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵢⵉⵊⵊ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ. ⵅⴻⵏⵏⵉ ⵉⵃⴰⴷⴰ ⴰⵢⵉ, ⵉⵙⵙⴱⴻⴷⴷ ⴰⵢⵉ ⵅ ⵉⴹⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DN8_19","028_8_19","DAN","8","19","19","ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵍⵡⴻⵇⵜ-ⴰ ⵏ ⵡⴻⵙⵅⴻⴹ, ⵎⴰⵖⴰⵔ ⴰⵏⴻⴳⴳⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN8_20","028_8_20","DAN","8","20","20","ⵉⵛⴰⵔⵔⵉ ⵏⵏⵉ ⵜⴻⵥⵔⵉⴷ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ. ⵉⵏⴰ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵎⴰⴷⴰⵢ ⴷ ⴰⵢⵜ ⵏ ⵍⴼⵓⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("DN8_21","028_8_21","DAN","8","21","21","ⴰⵎⵢⴰⵏ ⵏⵏⵉ ⵙ ⵓⵛⵓⵡⵡⴰⴼ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵡⴰⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵏ ⵍⵢⵓⵏⴰⵏ ⵓ ⵉⵛⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("DN8_22","028_8_22","DAN","8","22","22","ⵉⵛⵛ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵥ, ⵅⴻⵍⴼⴻⵏ ⵜ ⴰⵔⴻⴱⵄⴰ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵏ ⴰⵢⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵣⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⴷ ⴽⴽⴰⵔⴻⵏⵜ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN8_23","028_8_23","DAN","8","23","23","ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵙⴻⵏ, ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ ⴰⵍ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ, ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵙ ⵡⵓⴷⴻⵎ ⵉⵇⵙⴻⵃ ⵓ ⵙ ⵍⴻⵄⵇⴻⵍ ⵏ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DN8_24","028_8_24","DAN","8","24","24","ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴰⴷ ⵉⵎⵖⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵙ ⵓⵜⴻⴱⵀⴻⵜ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⴼⵍⴻⵃ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ, ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN8_25","028_8_25","DAN","8","25","25","ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵉⵏⵊⴻⵃ ⵍⵖⴻⵛⵛ ⵏⵏⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵟⵟⴰⵙ ⵓ ⴰⴷ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵎⴰ ⵉⴽⴽⴰ ⵅⴰⵙ ⵓⴼⵓⵙ ⴳⴳⵓⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ. ");
INSERT INTO rift_vpl VALUES ("DN8_26","028_8_26","DAN","8","26","26","ⵍⴻⵡⵃⵉⵢ ⵏ ⵜⵎⴻⴷⴷⵉⵜⵉⵏ ⴷ ⵜⴻⴼⴼⵓⵜⵉⵏ ⵉ ⵅⴻⴼ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⵉⴷⴻⵜⵜ. ⵓ ⵛⴻⴽ, ⵛⴻⵎⵎⴻⵄ ⵍⴻⵡⵃⵉⵢ-ⴰ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN8_27","028_8_27","DAN","8","27","27","ⵏⴻⵛⵛ, ⴷⴰⵏⵉⵢⴰⵍ, ⵜⵓⵖⴰ ⴹⴻⵄⴼⴻⵖ ⴰⵟⵟⴰⵙ ⵓ ⵀⴻⵍⵛⴻⵖ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵖ-ⴷⴷ ⵓ ⴳⴳⵉⵖ ⵄⴰⵡⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ⵏⵏⵅⴻⵍⵄⴻⵖ ⵣⵉ ⵍⴻⵡⵃⵉⵢ-ⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵢⵓⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("DN9_1","028_9_1","DAN","9","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵃⴰⵛⵡⵉⵔⵓⵙ, ⵡⴻⵏⵏⵉ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵎⴰⴷⴰⵢ, ⵡⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("DN9_2","028_9_2","DAN","9","2","2","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏⵏⴻⵙ ⵉⴱⴰⵏ-ⴰⵢⵉ-ⴷⴷ, ⵉ ⵏⴻⵛⵛ ⴷⴰⵏⵉⵢⴰⵍ, ⵣⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ, ⴱⴻⵍⵍⵉ ⵍⵇⴻⴷⴷ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⵅ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ ⵉ ⵓⴽⴻⵎⵎⴻⵍ ⵏ ⵍⵡⴻⵇⵜ ⵏ ⵍⵅⵉⵔⴱⴰⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⵓⵖⴰ-ⵜ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("DN9_3","028_9_3","DAN","9","3","3","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⴰⵔⵣⵓⵖ ⵙ ⵜⵥⴰⴵⵉⵜ ⴷ ⵓⵣⴰⵡⴻⴳ, ⵙ ⵓⵥⵓⵎⵎⵉ ⴷⴻⴳ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵢⵉⵖⵖⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("DN9_4","028_9_4","DAN","9","4","4","ⵏⴻⵛⵛ ⵥⵥⵓⴵⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓ ⵏⴻⵄⵎⴻⵖ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⵏⵏⵉⵖ “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵉⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN9_5","028_9_5","DAN","9","5","5","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⵓ ⵏⴻⴳⴳⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷ ⵍⵖⴰⵔ ⵓ ⵏⵖⴻⵡⵡⴻⵖ ⴰⵎ ⵏⴻⴼⴼⴻⵖ ⵣⵉ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DN9_6","028_9_6","DAN","9","6","6","ⵡⴰⵔ ⵏⴻⵙⵍⵉ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵍⴰ ⵉ ⵎⴰⵔⵔⴰ  ⵍⴳⴻⵏⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DN9_7","028_9_7","DAN","9","7","7","ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵖⴰⵔⴻⴽ ⵜⴰⵙⴻⴳⴷⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵍⴻⵃⵢⴰ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⴰⵙⵙ-ⴰ, ⵖⴰⵔ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵢⵓⴷⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵯⴻⵊⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵎⵓⵔⴰ ⵎⴰⵏⵉ ⵅⴰⵙⴻⵏ ⵜⵓⵥⵥⵍⴻⴷ ⵛⴻⴽ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵖⴷⴰⵔ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵛⴻⴽ ⵖⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN9_8","028_9_8","DAN","9","8","8","ⴰ ⵙⵉⴷⵉ, ⴷⴰⵢⵏⴻⵖ ⵍⴻⵃⵢⴰ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵖ, ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵏⴻⵖ ⴷⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵖ ⴷⴻⴳ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵖ ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("DN9_9","028_9_9","DAN","9","9","9","ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵡⴻⵖⴼⴰⵔ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵖⴻⵡⵡⴻⵖ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DN9_10","028_9_10","DAN","9","10","10","ⵡⴰⵔ ⵏⴻⵙⵍⵉ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⵉ ⵍⵇⴰⵡⴰⵏⵉⵏ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN9_11","028_9_11","DAN","9","11","11","ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⴷⴷⴰ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵛ ⵓ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ. ⵓ ⴰⵎⵎⵓ ⵉ ⵅⴰⵏⴻⵖ ⵜᵉⵜⵜⵡⴰⵣⴻⴵⴻⵄ ⵏⵏⴻⵄⵍⴻⵜ ⵉ ⵉⵜⵜⵡⴰⴹⴻⵎⵏⴻⵏ ⵙ ⵜⵊⴰⴵⵉⵜ ⵉ ⵉⵜⵜⵡⴰⵔⵉⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN9_12","028_9_12","DAN","9","12","12","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴱⴻⴷⴷⴰⵏ, ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵏⴻⵖ ⵓ ⴰⴽ-ⴷ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵖ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⵅⴰⵏⴻⵖ ⵉⵃⴻⴽⴽⵎⴻⵏ, ⴰⵎ ⴷⴰⵢⵏⴻⵖ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵡⴰⵔ ⵉⵎⵙⴰⵔⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵉⵜⵜⵡⴰⴳⴳ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("DN9_13","028_9_13","DAN","9","13","13","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵎⵓ ⵢⵓⵙⴰ-ⴷⴷ ⵅⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵏⵉ. ⵓ ⵏⴻⵛⵛⵉⵏ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵏⵣⴰⵡⴻⴳ ⵛⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵃⴻⵢⵢⴻⴷ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴰⵔⵣⵓ ⴰⴷ ⵏⴻⴼⵀⴻⵎ ⵜⵉⴷⴻⵜⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DN9_14","028_9_14","DAN","9","14","14","ⵙⵉⴷⵉ ⵉⵃⴹⴰ ⵍⵖⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵅⴰⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵄⴰⵢⴻⵍ ⵏⵏⴻⵙ ⵏⵏⵉ ⵉⴳⴳⴰ ⵓⵎⵉ ⵡⴰⵔ ⵏⴻⵙⵍⵉ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN9_15","028_9_15","DAN","9","15","15","ⵓ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⴹⴰ ⵓ ⵏⴻⴳⴳⴰ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN9_16","028_9_16","DAN","9","16","16","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵛ, ⵙⵃⴻⵢⵢⴻⴷ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴷ ⵡⴻⵙⵄⴰⵔ ⵏⵏⴻⵛ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵛ ⵓⵔⵛⴰⵍⵉⵎ, ⵅ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵖⴰⵔ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵜⴻⴷⵡⴻⵍ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵍⵄⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN9_17","028_9_17","DAN","9","17","17","ⵓ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵙⴻⵍ ⵖⴰⵔ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⵓ ⵖⴰⵔ ⵓⵣⴰⵡⴻⴳ ⵏⵏⴻⵙ, ⴻⵊⵊ ⵓⴷⴻⵎ ⵏⵏⴻⵛ ⴰⴷ ⵢⴻⴳⴳ ⵜⴰⴼⴰⵡⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⵍⵅⴰⵔⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DN9_18","028_9_18","DAN","9","18","18","ⴻⵡⵛ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⵙⴻⵍ. ⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓ ⵅⵣⴰⵔ ⵍⵅⵉⵔⴱⴰⵜ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵡⴹⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵣⴰⵡⴻⴳ ⵅ ⵓⵙⴷⴰⵀⴻⴵⵉ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵅ ⵓⵙⴷⴰⵀⴻⴵⵉ ⵏ ⴰⵔⵔⴰⵃⵎⴻⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DN9_19","028_9_19","DAN","9","19","19","ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⴻⵍ! ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵖⴼⴰⵔ! ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵃⴹⴰ ⵓⵛⴰ ⴻⴳⴳ, ⵡⴰⵔ ⵜⵄⴻⵟⵟⴰⵍ ⵛⴰ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵛ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("DN9_20","028_9_20","DAN","9","20","20","ⴰⵎ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵄⴰⴷ ⵓ ⵜⵜⵥⴰⴵⵉⵖ ⵓ ⵏⴻⵄⵄⵎⴻⵖ ⵙ ⴷⴷⵏⵓⴱ ⵉⵏⵓ ⴷ ⴷⴷⵏⵓⴱ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵓ ⵜⵜⵣⴻⴵⵄⴻⵖ ⴰⵣⴰⵡⴻⴳ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴻⴷⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("DN9_21","028_9_21","DAN","9","21","21","ⴰⵎ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵄⴰⴷ ⴰⵎⵎⵓ, ⵜⵜⵥⴰⴵⵉⵖ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵔⵢⴰⵣ ⵊⵉⴱⵔⵉⵍ ⵏⵏⵉ ⵥⵔⵉⵖ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴷⵉ ⵍⴻⵡⵃⵉⵢ, ⵉⴹⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔⵉ. ⵉⵃⴰⴷⴰ ⴰⵢⵉ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵎⴻⴷⴷⵉⵜ.    ");
INSERT INTO rift_vpl VALUES ("DN9_22","028_9_22","DAN","9","22","22","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴼⵀⴻⵎ ⵓ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴷⴰⵏⵉⵢⴰⵍ, ⵏⴻⵛⵛ ⴼⴼⵖⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅ ⵍⵎⴻⵄⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DN9_23","028_9_23","DAN","9","23","23","ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵣⴰⵡⴻⴳ ⵏⵏⴻⵛ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵓ ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵜ ⵏⵏⵉⵖ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵄⵉⵣⵣⴻⵏ ⴰⵟⵟⴰⵙ. ⴼⵀⴻⵎ ⴰⵡⴰⵍ-ⴰ ⵓ ⴰⵔⵣⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷⵉ ⵍⴻⵡⵃⵉⵢ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DN9_24","028_9_24","DAN","9","24","24","ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙⴻⴱⵄⵉⵏ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵓⵄⴻⴷⴷⵓ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵛⴻⵎⵎⴻⵄ ⴷⴷⴻⵏⴱ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵚⵍⴻⵃ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵡⵉ ⵜⵙⴻⴳⴷⴰ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⴻⵡⵃⵉⵢ ⴷ ⵓⵏⴰⴱⵉⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴷⵀⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("DN9_25","028_9_25","DAN","9","25","25","ⵙⵙⴻⵏ ⵓ ⴼⵀⴻⵎ, ⴰⵇⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴰⵡⴰⵍ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⴷⵍⴻⵏ ⵓ ⴰⴷ ⴱⵏⴰⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍ ⴰⵎⴻⴷⵀⵓⵏ, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵍⵎⴰⵙⵉⵃ, ⵍⵃⴰⴽⴻⵎ, ⴰⵇⴰ ⵙⴻⴱⵄⴰ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ, ⵓ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵙⵉⵎⴰⵏⴰⵜ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵏⴷⵉⵏⵜ ⵜᵉⵜⵡⴰⵄⴻⴷⴻⵍ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵡⴰⵣⵣⴰⵢ ⴷ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ, ⵄⴰⴷ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵍⴻⵡⵇⴰⵜ ⵢⴻⵡⵄⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN9_26","028_9_26","DAN","9","26","26","ⴰⵡⴰⵔⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵓⵎⴻⴷⵀⵓⵏ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵡⴰⵍⵓ. ⵓ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵊⵊ ⵏ ⵍⵃⴰⴽⴻⵎ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵓ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴷⵉ ⵙⵙⴻⵃⵍⴻⵜ ⵓⵛⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵓⵎⴻⵏⵖⵉ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ, ⴰⵔⴻⴷⴷⴻⴵ ⵏⵏⵉ ⴰⵇⴰ ⵢⵓⵔⴰ ⴰⴷ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("DN9_27","028_9_27","DAN","9","27","27","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⴷⵇⴻⵍ ⵍⵄⴰⵀⴷ ⵉ ⵡⴰⵟⵟⴰⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵉⵛⵜ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵓ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵜⴰⵖⴰⵔⵚⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵅ ⵡⴰⴼⵔⵉⵡ ⵏ ⵏⵏⵄⴰⵡⴰⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵓⵎⵜⴻⵃⵃⴰⵢ ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ ⵍⴻⵃⴽⴰⵎ ⵉ ⵢⵓⵔⵉⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ.    ");
INSERT INTO rift_vpl VALUES ("DN10_1","028_10_1","DAN","10","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⴽⵓⵔⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴼⵓⵔⵙ, ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⴷⴰⵏⵉⵢⴰⵍ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵍⵟⴰⵛⴰⵚⵚⴰⵔ, ⵓ ⴰⵡⴰⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵖⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵏⴻⵜⵜⴰ ⵉⴼⵀⴻⵎ ⴰⵡⴰⵍ ⵏⵏⵉ ⵓ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵍⴻⵡⵃⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("DN10_2","028_10_2","DAN","10","2","2","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵢⵉ, ⴷⴰⵏⵉⵢⴰⵍ, ⵛⴻⴹⵏⴻⵖ ⵜⵍⴰⵜⴰ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⴰⵙⵙ ⴰⵡⴰⵔⵏⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("DN10_3","028_10_3","DAN","10","3","3","ⵎⴰⵛⵛⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵍⵉⵇⴰⵏ, ⵡⴰⵔ ⵜ ⵛⵛⵉⵖ, ⴰⵢⵙⵓⵎ ⴷ ⴱⵉⵏⵓ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ⵡⴰⵔ ⴷⵀⵉⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴰⵍⴰⵎⵉ ⵄⴷⵓⵏⵜ ⵜⵍⴰⵜⴰ ⵏ ⵙⵙⵉⵎⴰⵏⴰⵜ ⴽⴻⵎⵎⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("DN10_4","028_10_4","DAN","10","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵖ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴷⴰⵊⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("DN10_5","028_10_5","DAN","10","5","5","ⵏⴻⵛⵛ ⵙⵙⴳⴳⴰⵄⴷⴻⵖ ⵜⴰⵎⵓⵖⵍⵉ ⵉⵏⵓ ⵓⵛⴰ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⴰⵔⴹ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵓ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ ⵉⴱⵢⴻⵙ ⵏⴻⵜⵜⴰ ⵙ ⵡⵓⵔⴻⵖ ⵉⵖⵍⴰⵏ ⵇⴰⵄ ⵣⵉ ⵓⴼⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("DN10_6","028_10_6","DAN","10","6","6","ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵎ ⵡⴻⵥⵔⵓ ⵏ ⵜⴻⵅⵔⵉⵙⵓⵍⵉⵜ ⵓ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵢⴰⵔⴻⵇⵇ ⴰⵎ ⵡⴰⵙⵙⴰⵎⴻⵏ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵎ ⵢⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⵢⴰⵔⴻⵇⵇⴻⵏ ⵓ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴻⵙⵙⴳⴻⵏ ⴰⵎ ⵏⵏⵃⴰⵙ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ ⵓ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴰⵎ ⵣⵣⵀⵉⵔ ⵏ ⵉⵊⵊ ⵏ ⵓⵀⵉⵎⵓⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN10_7","028_10_7","DAN","10","7","7","ⵎⵖⵉⵔ ⵏⴻⵛⵛ, ⴷⴰⵏⵉⵢⴰⵍ, ⵥⵔⵉⵖ ⵍⴻⵡⵃⵉⵢ, ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵖⴰⵔⵉ ⵉⴵⴰⵏ, ⵡⴰⵔ ⵥⵔⵉⵏ ⵛⴰ ⵍⴻⵡⵃⵉⵢ, ⵎⴰⵛⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⴰⵔⵔⴻⵀⴱⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN10_8","028_10_8","DAN","10","8","8","ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵡⴻⵃⵃⴷⵉ ⵓ ⵥⵔⵉⵖ ⵍⴻⵡⵃⵉⵢ-ⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵡⴰⵏⵉⵜⴰ, ⵓ ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵇⵇⵉⵎ ⵊⵊⴻⵀⴷ ⵄⴰⴷ. ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵖⴻⵛⵛ ⵓ ⵡⴰⵔ ⵎⵏⵉⵄⵖ ⵊⵊⴻⵀⴷ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DN10_9","028_10_9","DAN","10","9","9","ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵣⵣⵀⵉⵔ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵓ ⵍⴰⵎⵉ ⵙⵍⵉⵖ ⵣⵣⵀⵉⵔ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵡⴹⵉⵖ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ ⵓ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵜⵓⵖⴰ ⵢⴰⵔⵔⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("DN10_10","028_10_10","DAN","10","10","10","ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⴼⵓⵙ ⵉⵃⴰⴷⴰ ⴰⵢⵉ ⵓ ⵢⴰⵔⵔⴰ ⴰⵢⵉ ⵜⵜⴻⵏⵀⴻⵣⵣⴻⵖ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⴷ ⵜⵍⴻⵇⵇⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("DN10_11","028_10_11","DAN","10","11","11","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴷⴰⵏⵉⵢⴰⵍ, ⵛⴻⴽ ⴷ ⴰⵔⵢⴰⵣ ⵉⵄⵉⵣⵣⴻⵏ ⴰⵟⵟⴰⵙ, ⵃⴹⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ ⵓ ⴽⴽⴰⵔ, ⴱⴻⴷⴷ ⴷⵉⵏ, ⵎⵉⵏⵣⵉ ⵍⴻⵅⵅⵓ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵏⴻⵛⵛ ⵖⴰⵔⴻⴽ.” ⵍⴰⵎⵉ ⴰⴽⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ, ⴽⴽⴰⵔⴻⵖ-ⴷⴷ ⵏⴻⵛⵛ ⴰⵎ ⵜⵜⴰⵔⵊⵉⵊⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DN10_12","028_10_12","DAN","10","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⴷⴰⵏⵉⵢⴰⵍ, ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⴷⵉ ⵜⴰⵔⵔⵉⴷ ⵓⵍ ⵏⵏⴻⵛ ⵖⴰⵔ ⵜⵉⵖⵉⵜ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⵍⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵓⵙⵉⵖ-ⴷⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("DN10_13","028_10_13","DAN","10","13","13","ⵎⴰⵛⴰ ⵍⵃⴰⴽⴻⵎ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵍⴼⵓⵔⵙ ⵜⵓⵖⴰ ⵉⴽⴽⴰⵔ ⴹⵉⴷⴷ ⵉⵏⵓ ⵡⴰⵃⴷ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵓ ⵅⵣⴰⵔ, ⵎⵉⵅⴰⵢⵉⵍ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵢⵓⵙⴰ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴰⴼⵓⵙ ⵓ ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ ⵜⵜᵉⵟⵟⴼⴻⵖ ⵚⵚⵓⵍⵟⴰ ⴷⵉⵏⵏⵉ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵍⴼⵓⵔⵙ. ");
INSERT INTO rift_vpl VALUES ("DN10_14","028_10_14","DAN","10","14","14","ⵍⴻⵅⵅⵓ ⵓⵙⵉⵖ-ⴷⴷ ⵏⴻⵛⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⴼⴻⵀⵎⴻⵖ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵎⵉⵏⵣⵉ ⵍⴻⵡⵃⵉⵢ ⴰⵇⴰ-ⵜ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("DN10_15","028_10_15","DAN","10","15","15","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ, ⵓⴹⴰⵔⴻⵖ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⵙⴻⵖⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DN10_16","028_10_16","DAN","10","16","16","ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊⴻⵏ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵃⴰⴷⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ. ⵅⴻⵏⵏⵉ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵖ, ⵏⵏⵉⵖ ⵉ ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⵉ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵓⵎⵉ ⵥⵔⵉⵖ ⵍⴻⵡⵃⵉⵢ, ⵉⵟⵟⴻⴼ ⴰⵢⵉ ⴰⵎ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ, ⴰⵎ ⵡⴰⵔ ⵎⵏⵉⵄⴻⵖ ⵊⵊⴻⵀⴷ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DN10_17","028_10_17","DAN","10","17","17","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⴰⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ, ⴰ ⵙⵉⴷⵉ? ⴰⵇⴰ ⵏⴻⵛⵛ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵇⵇⵉⵎ ⵊⵊⴻⵀⴷ ⵏⵉⵖ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DN10_18","028_10_18","DAN","10","18","18","ⵅⴻⵏⵏⵉ ⵉⵃⴰⴷⴰ ⴰⵢⵉ ⵄⴰⵡⴻⴷ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵉⴳⴳⴰ ⴷⴰⵢⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("DN10_19","028_10_19","DAN","10","19","19","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵛⴻⴽ, ⴰ ⴰⵔⵢⴰⵣ ⵉⵄⵉⵣⵣⴻⵏ! ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ, ⴻⴳⴳ ⵜⴰⵔⵢⴰⵙⵜ, ⵡⴰⵀ, ⴻⴳⴳ ⵜⴰⵔⵢⴰⵙⵜ!” ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵎⵎⵓ, ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ ⵊⵊⴻⵀⴷ ⵄⴰⵡⴻⴷ ⵓ ⵏⵏⵉⵖ: “ⵙⵉⵡⴻⵍ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⴷⴰⵢⵉ ⵊⵊⴻⵀⴷ.” ");
INSERT INTO rift_vpl VALUES ("DN10_20","028_10_20","DAN","10","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ, ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵓⵙⵉⵖ? ⵍⴻⵅⵅⵓ ⴰⴷ ⵄⴻⵇⴱⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵎⴻⵏⵖⴻⵖ ⴰⴽ-ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⴼⵓⵔⵙ ⵓ ⵅⵎⵉ ⵖⴰ ⴼⴼⵖⴻⵖ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⵢⵓⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN10_21","028_10_21","DAN","10","21","21","ⵎⴰⵛⴰ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵉ ⵅⴰⵙⴻⵏ ⴷ ⵉⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⵉ, ⵎⵖⵉⵔ ⵍⵃⴰⴽⴻⵎ ⵏⵡⴻⵎ, ⵎⵉⵅⴰⵢⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("DN11_1","028_11_1","DAN","11","1","1","“ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⴰⵎⴰⴷⴰⵢ, ⴱⴻⴷⴷⴻⵖ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵙⴻⵊⴻⵀⴷⴻⵖ ⵓ ⴰⴷ ⴰⵙ ⵙⵙⴻⵏⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("DN11_2","028_11_2","DAN","11","2","2","ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴷ ⵜⵉⴷⴻⵜⵜ! ⵅⵣⴰⵔ, ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⵉ ⵍⴼⵓⵔⵙ ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴰⴷ ⵉⴳⴳ ⴰⴳⵍⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴽⵜⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⴻⵖⵏⵉ. ⵓ ⴰⵡⴰⵔⵏⵉ ⵅⵎⵉ ⵖⴰ ⵉⵟⵟⴻⴼ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵙ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⴷⴷⴻⵏ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵢⴰⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_3","028_11_3","DAN","11","3","3","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵀⴻⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵚⴻⵍⵍⵟⴻⵏ ⵙ ⵚⵚⵓⵍⵟⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("DN11_4","028_11_4","DAN","11","4","4","ⵅⵎⵉ ⵖⴰ ⵉⴽⴽⴰⵔ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜⴰⵔⴻⵥ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⵚⴻⴱⴹⴰ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵉ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜᵉⵜⵜⵉⵍⵉ ⵚⵚⵓⵍⵟⴰ ⴰⵎ ⵜⴻⵏⵏⵉ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵚⴻⵍⵍⴻⴹ ⵏⴻⵜⵜⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("DN11_5","028_11_5","DAN","11","5","5","ⵅⴻⵏⵏⵉ ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ ⵅⴰⵙ ⵓ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵉⵚⴻⵍⵍⴻⵟ ⵙ ⵚⵚⵓⵍⵟⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_6","028_11_6","DAN","11","6","6","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵛⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵓ ⵢⴻⴵⵉⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜⵙⴻⴳⴳⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵃⴹⴰ ⵊⵊⴻⵀⴷ ⵏ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ, ⵓ ⴰⵖⵉⵍ ⵏⵏⴻⵙ ⴰⵎ ⵏⵏⴻⵖⵏⵉ. ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵜⵜ ⵉⵡⵢⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ ⵢⵓⵔⵡⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵙⵙⵊⴻⵀⴷⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("DN11_7","028_11_7","DAN","11","7","7","ⵎⴰⵛⴰ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⵖⴻⴷⴷⵓⵜ ⵏ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⴽⴽⴰⵔ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⴹⵉⴷⴷ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵛⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵍⴱⵓⵔⵊ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵉⴳⴳ ⵎⵉⵏ ⵉⵅⵙ ⵓ ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⵉⵊⵀⴻⴷ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("DN11_8","028_11_8","DAN","11","8","8","ⴰⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⴼⴻⵙⵢⴻⵏ ⴷ ⵍⴻⵇⵛⵓⵄ ⵏⵙⴻⵏ ⵉⵖⵍⴰⵏ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⴰⴷ ⵜⴻⵏ ⵢⴰⵡⵉ ⴷ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴱⴻⵄⵄⴻⴷ ⵛⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("DN11_9","028_11_9","DAN","11","9","9","ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_10","028_11_10","DAN","11","10","10","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵃⴻⵣⵣⵎⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵓ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓ ⴰⴷ ⵉⵄⴻⵎⵎⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⴰⴷ ⵅⴰⵙ ⵉⵄⴷⵓ. ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ, ⴰⴷ ⵃⴻⵣⵣⵎⴻⵏ ⵄⴰⵡⴻⴷ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴷ ⵢⴰⴷⴻⴼ ⴰⵍ ⵍⴱⵓⵔⵊ ⵏⵏⴻⵙ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_11","028_11_11","DAN","11","11","11","ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⵓⵣⵣⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓⵛⴰ ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⴼⴼⴻⵖ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵎⵓⵏⴻⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵎⴰⵛⴰ ⴰⴱⴰⵔⵔⵓ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_12","028_11_12","DAN","11","12","12","ⵎⴰⵍⴰ ⵉⵎⵎⴻⴽⵙⵉ ⵓⴱⴰⵔⵔⵓ ⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵖⴷⴻⵍ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴰⵔⵏⵉ ⴷⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("DN11_13","028_11_13","DAN","11","13","13","ⴰⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵓ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴽⵜⴰⵔ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⴰⵡⴰⵔⵏⵉ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("DN11_14","028_11_14","DAN","11","14","14","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⵖⴻⵡⵡⵖⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵇⴻⴼⵍⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_15","028_11_15","DAN","11","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ, ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵓ ⴰⴷ ⵉⵟⵟⴻⴼ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴼⴰⵔⵢⴻⵏ. ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵊⴰⵏⵓⴱ ⵉⵊⴻⵀⴷⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵇⴰⵡⴰⵎⴻⵏ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵍⵍⴰ. ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵊⵊⴻⵀⴷ ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵜⵜⴱⴻⴷⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_16","028_11_16","DAN","11","16","16","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⵅⵙ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵍⵡⵉⵣⵜ ⵓ ⴰⵔⴻⴷⴷⴻⴵ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_17","028_11_17","DAN","11","17","17","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⴰⴷ ⵉⵙⵙⴻⵎⵜⴻⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔⴻⵙ ⵉⵎⵜⴰⵡⵉⵢⵢⴻⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵢⴻⴵⵉⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏⵏⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⴼⴼⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("DN11_18","028_11_18","DAN","11","18","18","ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵔⵔ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵉⵏ ⵓⵛⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵙⴻⵏⵜ. ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵍⵃⴻⴳⵔⴰ ⵏⵏⴻⵙ ⵅⴰⵙ, ⴱⵍⴰ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⵅⴻⴵⴻⵚ ⵍⵃⴻⴳⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_19","028_11_19","DAN","11","19","19","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵔ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴱⵓⵔⵊⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⵇⴰⵔⴹ, ⴰⴷ ⵉⵡⴹⴰ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼⴼⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("DN11_20","028_11_20","DAN","11","20","20","ⴰⴷ ⵉⴽⴽⴰⵔ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵄⴷⵓⵏ ⵉⵊⵊⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵀⵡⴰⵏ ⴰⵄⵓⴵⵉ ⵏ ⵜⴳⴻⵍⴷⵉⵜ, ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵔⵥ ⴷⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⵓⵍⴰ ⵙ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("DN11_21","028_11_21","DAN","11","21","21","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵃⴻⴳⴳⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛⴻⵏ ⵍⵄⴰⴹⴰⵎⴰ ⵉⴳⴻⵍⵍⴷⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵍⵖⴻⴼⵍⴻⵜ ⵓ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_22","028_11_22","DAN","11","22","22","ⵉⵖⴰⴵⴻⵏ ⵉⵊⴻⵀⴷⴻⵏ ⵏⵏⵉ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⴷ ⵜⵜⵡⴰⵎⵃⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ ⵓ ⴰⴷ ⵜⵜⵡⴰⵔⵔⵥⴻⵏ ⵓⵍⴰ ⴷ ⵍⵃⴰⴽⴻⵎ ⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("DN11_23","028_11_23","DAN","11","23","23","ⵓ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉ ⵖⴰ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴻⵇⴷ ⴰⴽⵉⴷⴻⵙ, ⴰⴷ ⵉⴳⴳ ⵙ ⵍⵖⴻⵛⵛ. ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵓ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵣⴻⵎⵎⴰⵔ ⵅⴰⵙⴻⵏ ⵙ ⴷⵔⵓⵙ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("DN11_24","028_11_24","DAN","11","24","24","ⴰⴷ ⵢⴰⴷⴻⴼ ⵙ ⵍⵖⴻⴼⵍⴻⵜ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵉⵙⵙⵖⴻⵎⵎⴰⵢⴻⵏ ⵏ ⵍⵄⴰⵎⴰⵍⴰ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵡⴰⵔ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵏⵉⵖ ⵍⴻⵊⴷⵓⴷ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ: ⴰⴷ ⵢⴰⵛⴰⵔ ⵓ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵓ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰⵡⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵣⴻⴵⴻⵄ ⵊⴰⵔ ⴰⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⴳⴳⵓⵔ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵉⵏⵡⴰⵢⴻⵏ ⴹⵉⴷⴷ ⵉ ⵍⵇⴻⵍⵄⴰⵜ, ⴰⵍ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_25","028_11_25","DAN","11","25","25","ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵢⴰⵔⵔ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷ ⵡⵓⵍ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓⵛⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵊⵀⴻⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵅⴰⵙ ⴳⴳⴻⵏ ⵜⵉⵎⴻⵄⵎⴰⵍⵜ, ");
INSERT INTO rift_vpl VALUES ("DN11_26","028_11_26","DAN","11","26","26","ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⵜ ⴰⵔⵥⴻⵏ ⵓ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵃⴰ ⵓ ⴰⵟⵟⴰⵙ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_27","028_11_27","DAN","11","27","27","ⵓⵍ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ-ⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵙⵙⴻⴳⴳⵓⵔ ⵖⴰⵔ ⵍⵖⴰⵔ ⵓ ⵅ ⵟⵟⴰⴱⵍⴰ ⴷ ⵉⵛⵜ ⴰⴷ ⵉⵏⵉⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ, ⵎⴰⵖⴰⵔ ⴰⵏⴻⴳⴳⴰⵔ ⵉⵜⵜⵔⴰⵊⴰ ⵄⴰⴷ ⴰⵍ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_28","028_11_28","DAN","11","28","28","ⵙ ⵓⴱⴰⵔⵔⵓ ⵏ ⵡⴰⴳⵍⴰ ⴰⴷ ⵢⴰⵔⴻⴳⴳⵯⴻⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵓ ⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴹⵉⴷⴷ ⵉ ⵍⵄⴰⵀⴷ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⴰⵎⴻⵏⵏⵉ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_29","028_11_29","DAN","11","29","29","ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ, ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ, ⵎⴰⵛⴰ ⵜⵡⴰⵍⴰ-ⵢⴰ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⴰⵎ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("DN11_30","028_11_30","DAN","11","30","30","ⵎⴰⵖⴰⵔ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏ ⴽⵉⵜⵜⵉⵎ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵉⴳⴳⵯⴻⴷ, ⴰⴷ ⵉⵄⵇⴻⴱ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵅⴻⴹ ⵅ ⵍⵄⴰⵀⴷ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴰⴷ ⵉⴳⴳ ⴰⵎⴻⵏⵏⵉ. ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⵄⵇⴻⴱ ⴰⴷ ⵉⵎⵎⵙⴻⴼⵀⴻⵎ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵄⴰⵀⴷ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_31","028_11_31","DAN","11","31","31","ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵉⵖⴰⴵⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵉ ⵣⵣⴰⵢⴻⵙ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵚⴱⴻⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵍⴱⵓⵔⵊ, ⵓⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⴰⴷ ⴷⵉⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵏⵄⵉ ⵏ ⵓⵅⴰⵔⵔⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("DN11_32","028_11_32","DAN","11","32","32","ⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵅ ⵍⵄⴰⵀⴷ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ, ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⴳⴳⵓⵔ ⴰⴷ ⵉⵍⵉⵏ ⵊⴻⵀⴷⴻⵏ ⵓ ⴰⴷ ⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_33","028_11_33","DAN","11","33","33","ⵉⴼⴻⵀⵀⴰⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⵙⵙⴼⴻⵜⵏⴻⵏ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ ⵙ ⵙⵙⵉⴼ ⴷ ⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵜⵎⴻⵃⴱⴰⵙⵜ ⴷ ⵓⴽⴻⵛⵛⴻⴹ, ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_34","028_11_34","DAN","11","34","34","ⵅⵎⵉ ⵖⴰ ⵏⵇⴰⵔⴹⴻⵏ, ⴰⴷ ⴰⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⵉⵣⴰ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵓ ⴰⵟⵟⴰⵙ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵎⵓⵏⴻⵏ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("DN11_35","028_11_35","DAN","11","35","35","ⵛⴰ ⵣⴻⴳ ⵉⴼⴻⵀⵀⴰⵎⴻⵏ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴻⴳⴳⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴰⵍ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_36","028_11_36","DAN","11","36","36","ⴰⵊⴻⴵⵉⴷ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ ⵓ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⵅ ⴽⵓⵍ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵏⵉ ⵍⴻⵄⵊⴻⴱ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⴹⵉⴷⴷ ⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⵍⴻⵃ ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴻⵙⵅⴻⴹ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵢⵓⵔⴰ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("DN11_37","028_11_37","DAN","11","37","37","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴳⴳⵓⵔ ⴰⴷ ⵜ ⵛⵇⴰⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵍⴻⵖⵔⵉⵣⴻⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵛⵇⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⵅ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("DN11_38","028_11_38","DAN","11","38","38","ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴱⵓⵔⵊⴰⵜ. ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ ⴷ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_39","028_11_39","DAN","11","39","39","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⴹⵉⴷⴷ ⵉ ⵍⵇⴻⵍⵄⴰⵜ ⵙ ⴰⵔⴻⴱⴱⵉ ⴰⵖⵔⵉⴱ. ⵡⴻⵏⵏⵉ ⵜ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ, ⴰⴷ ⵉⴽⵙⵉ ⴰⵟⵟⴰⵙ ⵏ ⵛⵛⴰⵏ ⵓ ⴰⴷ ⵉⵚⴻⵍⵍⴻⵟ ⵅ ⵡⴰⵟⵟⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴱⴹⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⵎⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("DN11_40","028_11_40","DAN","11","40","40","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴻⴳⴳⴰⵔⵓ ⴰⴷ ⴰⵙ ⵉⵣⴷⴻⵎ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵊⴰⵏⵓⴱ ⵙ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓ ⴰⵊⴻⴵⵉⴷ ⵏ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⵅⴰⵙ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵙ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵜⵉⵎⵎⵓⵔⴰ ⴰⵎ ⵍⵃⴻⵎⵍⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("DN11_41","028_11_41","DAN","11","41","41","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵜⴻⵍⵡⵉⵣⵜ ⵓ ⴰⵟⵟⴰⵙ ⴰⴷ ⵏⵏⵇⴰⵔⴹⴻⵏ, ⵎⴰⵛⴰ ⵉⵏⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ: ⵉⴷⵓⵎ ⴷ ⵎⵓ’ⴰⴱ ⴷ ⵓⵎⴻⵣⵡⴰⵔ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("DN11_42","028_11_42","DAN","11","42","42","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⴰ. ⵓⵍⴰ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵡⴰⵔ ⵜⵏⴻⵊⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("DN11_43","028_11_43","DAN","11","43","43","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵚⴻⵍⵍⴻⵟ ⵅ ⵜⵅⵓⴱⴰⵢ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ ⵏ ⵎⵉⵚⵔⴰ. ⴰⵢⵜ ⵏ ⵍⵉⴱⵢⴰ ⴷ ⴰⵢⵜ ⵏ ⴽⵓⵛ ⴰⴷ ⵜ ⴹⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("DN11_44","028_11_44","DAN","11","44","44","ⵎⴰⵛⴰ ⵍⴻⵅⴱⵓⵔⴰⵜ ⵣⵉ ⵛⵛⴰⵔⵇ ⵓ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⵜ ⵙⵙⵏⴻⵅⵍⴻⵄⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵙ ⵡⴻⵙⵄⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵟⵟⴰⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵜⴻⵃⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("DN11_45","028_11_45","DAN","11","45","45","ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⵉⵅⵓⵣⴰⵏ ⵏⵏⴻⵙ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵊⴰⵔ ⵍⴻⴱⵃⵓⵔ ⴷ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴻⵍⵡⵉⵣⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵡⴻⴹ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⴼ ⵃⴻⴷ ⴰⴷ ⵜ ⵉⵄⴰⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("DN12_1","028_12_1","DAN","12","1","1","“ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵉⴽⴽⴰⵔ ⵎⵉⵅⴰⵢⵉⵍ, ⵍⵃⴰⴽⴻⵎ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ. ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴰⵎ ⵡⴰⵔ ⵜⴻⴵⵉ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏⵏⵉ. ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴰⵇⴰ ⵓⵔⵉⵏ ⵜ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("DN12_2","028_12_2","DAN","12","2","2","ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵟⵟⵚⴻⵏ ⴷⵉ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴼⴰⵇⴻⵏ, ⵉⵏⴰ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴼⴰⵇⴻⵏ ⵉ ⵓⴱⴻⵀⴷⴻⵍ ⵓ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵄⵉⴼⴼⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("DN12_3","028_12_3","DAN","12","3","3","ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴰⴷ ⴰⵔⵖⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⴰⵔⴻⵇⵇ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴰⵟⵟⴰⵙ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ, ⴰⵎ ⵢⵉⵜⵔⴰⵏ, ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("DN12_4","028_12_4","DAN","12","4","4","ⵓ ⵛⴻⴽ, ⴷⴰⵏⵉⵢⴰⵍ, ⵙⵏⵓⴼⴼⴰⵔ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵓ ⵜⵛⴻⵎⵎⵄⴻⴷ ⴰⴷⵍⵉⵙ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴻⴳⴳⴰⵔ. ⴰⵟⵟⴰⵙ ⴰⴷ ⴰⵔⵣⵓⵏ ⵓ ⵜⵓⵙⵙⵏⴰ ⴰⴷ ⵜⴻⵎⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("DN12_5","028_12_5","DAN","12","5","5","ⵓ ⵏⴻⵛⵛ, ⴷⴰⵏⵉⵢⴰⵍ, ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴱⴻⴷⴷⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵖⴰⵔ ⵜⵎⴰ-ⵢⴰ ⵏ ⵉⵖⵣⴰⵔ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏⵏⴻⵖⵏⵉ ⵏ ⵉⵖⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN12_6","028_12_6","DAN","12","6","6","ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵎⴰⵏ ⵏ ⵉⵖⵣⴰⵔ: “ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("DN12_7","028_12_7","DAN","12","7","7","ⵓ ⵙⵍⵉⵖ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵎⴰⵏ ⵏ ⵉⵖⵣⴰⵔ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⴷ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵓ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ, ⴱⴻⵍⵍⵉ ⵅⵎⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵇⴹⴰ ⵓⴼⴰⵔⵜⴻⴽ ⵏ ⵓⴼⵓⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⵍⴻⵡⵇⴰⵜ ⴷ ⵡⴻⵣⵢⴻⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵓⵇⴻⵟⵟⵓ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("DN12_8","028_12_8","DAN","12","8","8","ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⴼⵀⵉⵎⴻⵖ ⵓ ⵏⵏⵉⵖ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("DN12_9","028_12_9","DAN","12","9","9","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵓⵢⵓⵔ, ⴷⴰⵏⵉⵢⴰⵍ, ⵎⴰⵖⴰⵔ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⵍⵍⵄⴻⵏ, ⵛⴻⵎⵎⵄⴻⵏ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("DN12_10","028_12_10","DAN","12","10","10","ⴰⵟⵟⴰⵙ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵚⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⴼⴻⵀⵀⵎⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⴷ ⴼⴻⵀⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("DN12_11","028_12_11","DAN","12","11","11","ⵣⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⴱⴷⴰ ⵓ ⵉⵎⵎⴰⵔⵙ ⵏⵏⵄⵉ ⵏ ⵓⵅⴰⵔⵔⴻⴱ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN12_12","028_12_12","DAN","12","12","12","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵓ ⴰⴷ ⵢⴰⵡⴻⴹ ⴰⵍⴻⴼ ⵓ-ⵜⴻⵍⵜ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("DN12_13","028_12_13","DAN","12","13","13","ⵓ ⵛⴻⴽ, ⵓⵢⵓⵔ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ. ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⴷ ⵓ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS1_1","029_1_1","HOS","1","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵃⵓⵛⵉⵄⴰ, ⵎⵎⵉⵙ ⵏ ⴱⵉⵔⵉ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⵢⵓⵜⴰⵎ, ⴰⵃⴰⵣ ⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("HS1_2","029_1_2","HOS","1","2","2","ⴰⴱⴻⴷⴷⵓ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵀⵓⵛⵉⵄⴰ. ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵀⵓⵛⵉⵄⴰ: “ⵔⵓⵃ, ⴰⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓⵍⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵎⴰⵖⴰⵔ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵜⴻⵣⵏⴰ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⴼⴼⴻⵖ ⵣⴻⴳ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("HS1_3","029_1_3","HOS","1","3","3","ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ, ⵢⵉⵡⵉ ⵊⵓⵎⴰⵔ, ⵢⴻⴵⵉⵙ ⵏ ⴷⵉⴱⵍⴰⵢⵉⵎ, ⵓ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("HS1_4","029_1_4","HOS","1","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵍⴰⵖⴰ ⴰⵙ ⵙ ⵢⵉⵙⴻⵎ ⵏ ‘ⵢⴰⵣⵔⴰⵄⵉⵍ’, ⵎⴰⵖⴰⵔ ⵛⵡⴰⵢⵜ ⵏ ⵍⵡⴻⵇⵜ ⵡⴰⵀⴰ ⵓ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⵅ ⵜⴳⴻⵍⴷⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("HS1_5","029_1_5","HOS","1","5","5","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵥⴻⵖ ⵍⵇⴻⵡⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⴻⵡⴹⴰ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("HS1_6","029_1_6","HOS","1","6","6","ⵓⵛⴰ ⵜⴻⴽⵙⵉ ⵏⴻⵜⵜⴰⵜ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⵓⵔⵓⵡ-ⴷⴷ ⵢⴻⴵⵉⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵍⴰⵖⴰ ⴰⵙ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵍⵓ-ⵔⵓⵃⴰⵎⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴰⵔⵔⴻⵃⵃⵎⴻⵖ ⵄⴰⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵖ ⵙⴻⵎⵎⵃⴻⵖ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS1_7","029_1_7","HOS","1","7","7","ⵎⴰⵛⴰ ⴰⴷ ⴰⵔⵔⴻⵃⵎⴻⵖ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ! ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⴻⵏⵊⵎⴻⵖ ⵙ ⵍⵇⴻⵡⵙ ⵏⵉⵖ ⵙ ⵙⵙⵉⴼ ⵏⵉⵖ ⵙ ⵉⵢⵙⴰⵏ ⵓⵍⴰ ⵙ ⵉⵎⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS1_8","029_1_8","HOS","1","8","8","ⴰⵍⴰⵎⵉ ⵜⴻⴽⴽⴻⵙ ⵓⵟⵟⵓⴹ ⵉ ⵍⵓ-ⵔⵓⵃⴰⵎⴰ, ⵜⴻⴽⵙⵉ ⵄⴰⵡⴻⴷ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("HS1_9","029_1_9","HOS","1","9","9","ⵓⵛⴰ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵍⴰⵖⴰ ⴰⵙ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵍⵓ-ⵄⴰⵎⵎⵉ, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵄⴰⴷ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵄⴰⴷ ⴷⴰ ⵉ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("HS2_1","029_2_1","HOS","2","1","1","“ⴰⴷ ⵢⵉⵍⵉ ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵢⴻⵊⴷⵉ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴱⴰⵔ ⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ, ⵓⵛⴰ ⴰⴷ ⵜⴰⴼⴻⴷ ⵎⴰⵏⵉ ⴷ ⴰⵙⴻⵏ ⵏⵏⴰⵏ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’, ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴰ: ‘ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("HS2_2","029_2_2","HOS","2","2","2","ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ, ⴰⴷ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⵖⴰⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵢⴰⵣⵔⴰⵄⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS2_3","029_2_3","HOS","2","3","3","ⵉⵏⵉⵎ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵡⴻⵎ: ‘ⵄⴻⵎⵎⵉ!’ ⵓ ⵉ ⵙⵓⵢᵉⵜⵎⴰⵜⵡⴻⵎ ‘ⵔⵓⵃⴰⵎⴰ!’” ");
INSERT INTO rift_vpl VALUES ("HS2_4","029_2_4","HOS","2","4","4","“ⴷⵄⴰⵎ ⴰⴽ-ⴷ ⵢⴻⵎⵎⴰⵜⵡⴻⵎ, ⴷⵄⴰⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ. ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⴻⴽⴽⴻⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵣⵣⵉⵏⴰ ⵣⵉ ⵊⴰⵔ ⵉⴱⴱⴰⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS2_5","029_2_5","HOS","2","5","5","ⵏⵉⵖ ⴰⵇⴰ ⴰⴷ ⴰⵙ ⴽⴽⵙⴻⵖ ⴰⵔⵔⵓⴹ ⴰⴷ ⵜⵜ ⵊⵊⴻⵖ ⴷ ⵜⴰⵄⴰⵔⵢⴰⵏⵜ¸ ⴰⴷ ⵜⵜ ⵙⵙⴰⵔⵙⴻⵖ ⴷⵉⵀⴰ ⴰⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⴷⵉ ⴷⴷ-ⵜⴻⵅⵍⴻⵇ, ⵡⴰⵀ, ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵅⵍⴰ, ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵊⵊⴻⵖ ⴰⴷ ⵜⴻⵎⵎⴻⵜ ⵙ ⵓⴼⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS2_6","029_2_6","HOS","2","6","6","ⵏⴻⵛⵛ ⵡⴰⵔ ⴰⵔⵔⴻⵃⵎⴻⵖ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("HS2_7","029_2_7","HOS","2","7","7","ⵎⴰⵖⴰⵔ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⴰⵇⴰ ⵜⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵣⵣⴰⵢⵙⴻⵏ, ⵜⴻⴳⴳⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵎⴰⵖⴰⵔ ⵜⴻⵇⵇⴰⵔ: ‘ⴰⴷ ⴹⴼⴰⵔⴻⵖ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵄⴻⵛⵛⵇⴻⵏ, ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵉⵏⵓ ⴷ ⵡⴰⵎⴰⵏ ⵉⵏⵓ ⴷ ⵜⴰⴹⵓⴼⵜ ⵉⵏⵓ ⴷ ⵜⵉⴼⴼⴻⵙⵜ ⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ ⵉⵏⵓ ⴷ ⵜⵙⴻⵙⵙⵉⵜ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("HS2_8","029_2_8","HOS","2","8","8","ⵙ ⵓⵢⴰ, ⴰⵇⴰ ⴰⴷ ⴱⴻⵍⵍⵄⴻⵖ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵎ ⵙ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⴰⵖⴱⴰⵔ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴼ ⵄⴰⴷ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS2_9","029_2_9","HOS","2","9","9","ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⴹⴼⴰⵔ ⵉⵏⵏⵉ ⵜⵜ ⵉⵄⴻⵛⵇⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⵃⴰⵔⵔⴻⵜ. ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴰⵔⵣⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⵉⴼ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵄⴻⵇⴱⴻⵖ, ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵓ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⵎⵍⵉⵃ ⵅ ⵍⴻⵅⵅⵓ.’ ");
INSERT INTO rift_vpl VALUES ("HS2_10","029_2_10","HOS","2","10","10","ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴻⵄⵇⵉⵍ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵉⵡⵛⵉⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ, ⵓ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵉⵡⵛⵉⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵓⵔⴻⵖ ⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ ⴰⵇⴰ ⴳⴳⵉⵏ ⵜ ⵖⴰⵔ ⴱⴰⵄⵍ. ");
INSERT INTO rift_vpl VALUES ("HS2_11","029_2_11","HOS","2","11","11","ⵙ ⵓⵢⴰ ⵉ ⵖⴰ ⵄⴻⵇⴱⴻⵖ, ⴰⴷ ⴽⴽⵙⴻⵖ ⵉⵎⴻⵏⴷⵉ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵓⵍⴰ ⴷ ⴱⵉⵏⵓ ⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓ ⵜⴰⴹⵓⴼⵜ ⵉⵏⵓ ⴷ ⵜⵉⴼⴼⴻⵙⵜ ⵉⵏⵓ ⵉ ⵣⵉ ⵜⴻⴷⴷⴰⵍ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏⵜ ⵇⴻⵍⵄⴻⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS2_12","029_2_12","HOS","2","12","12","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⵄⴰⵔⵔⵉⵖ ⵅ ⵍⴻⵃⵢⴰ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HS2_13","029_2_13","HOS","2","13","13","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ, ⵓⵔⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵏ ⵓⴱⴻⴷⴷⵉ ⵏ ⵓⵢⵓⵔ ⵓⵍⴰ ⴷ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS2_14","029_2_14","HOS","2","14","14","ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵡⴰⵔⵜⵓ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⴻⵏⵏⴰ: ‘ⵜⵉⵏⴰ ⴷ ⵍⵎⵓⵏⴻⵜ ⵉ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ.’ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⵔⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵖⴰⵔ ⵓ ⵍⵎⴰⵍ ⵏ ⵢⴻⵢⵢⴰⵔ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵛⵛⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("HS2_15","029_2_15","HOS","2","15","15","ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⵡⵜⴻⵖ ⵅ ⵓⵙⵙⴰⵏ ⵏ ‘ⵉⴱⴰⵄⵍⴻⵏ’, ⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵜⵉⵡⵉ-ⴷⴷ ⴰⵙⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵓ ⵜⴻⴳⴳⴰ ⵜⴰⵅⵔⴰⵣⵜ ⵏⵏⴻⵙ ⴷ ⵜⵙⴻⴷⴷⴻⵛⵜ ⵏⵏⴻⵙ, ⵓ ⵜⴻⴹⴼⴰⵔ ⵉⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵜⵜⵓ ⴰⵢⵉ!”, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS2_16","029_2_16","HOS","2","16","16","“ⵙ ⵓⵢⴰ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⵖⴰⵔⵔⴻⵖ, ⴰⴷ ⵜⵜ ⵏⴻⴷⵀⴻⵖ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵓ ⴷⵉⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS2_17","029_2_17","HOS","2","17","17","ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ ⵓ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⴰⵅⵓⵔ ⴷ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵍⴰⵢⴰⵙ. ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴷⵉⵏⵏⵉ ⵜⵖⴻⵏⵏⴻⵊ ⴰⵎ ⵜⵖⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ, ⴰⵎ ⵅ ⵡⴰⵙⵙ ⵓⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HS2_18","029_2_18","HOS","2","18","18","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵢⵉ ⵜⵍⴰⵖⵉⴷ: ‘ⴰⵔⵢⴰⵣ ⵉⵏⵓ!’, ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵄⴰⴷ: ‘ⴱⴰⵄⵍ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("HS2_19","029_2_19","HOS","2","19","19","ⴰⴷ ⴰⵙ ⴽⴽⵙⴻⵖ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ⵡⴰⵔ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵏ ⵄⴰⴷ ⴷⴻⴳ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS2_20","029_2_20","HOS","2","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ, ⴰⴽ-ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴽ-ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⴷ ⴽⴽⵙⴻⵖ ⵍⵇⴻⵡⵙ ⴷ ⵙⵙⵉⴼ ⴷ ⵓⵎⴻⵏⵖⵉ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⴰⵔⵔⴻⵢⵃⴻⵖ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ.    ");
INSERT INTO rift_vpl VALUES ("HS2_21","029_2_21","HOS","2","21","21","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⵅⴻⴹⴱⴻⵖ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵀ, ⴰⴷ ⵛⴻⵎ ⵅⴻⴹⴱⴻⵖ ⵙ ⵜⵙⴻⴳⴷⴰ ⴷ ⵍⵀⴻⵇⵇ, ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HS2_22","029_2_22","HOS","2","22","22","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⵅⴻⴹⴱⴻⵖ ⵙ ⵍⴰⵎⴰⵏ, ⵓ ⵛⴻⵎ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS2_23","029_2_23","HOS","2","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵍⴻⵖ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵉⵙⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ");
INSERT INTO rift_vpl VALUES ("HS2_24","029_2_24","HOS","2","24","24","ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⵙⴻⵍ ⵖⴰⵔ ⵉⵎⴻⵏⴷⵉ ⵓⵍⴰ ⵖⴰⵔ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ, ⵓ ⵉⵏⴰ ⴰⴷ ⵙⵍⴻⵏ ⵖⴰⵔ ⵢⴰⵣⵔⴰⵄⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("HS2_25","029_2_25","HOS","2","25","25","ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⵣⴰⵔⵄⴻⵖ ⵉ ⵏⴻⵛⵛ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵃⵎⴻⵖ ⵅ ⵍⵓ-ⵔⵓⵃⴰⵎⴰ, ⵓ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵍⵓ-ⵄⴰⵎⵎⵉ: ‘ⵛⴻⵎ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉ ⵜⴻⴵⵉⴷ!’, ⵓ ⵍⴳⴻⵏⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("HS3_1","029_3_1","HOS","3","1","1","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵔⵓⵃ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⴻⵅⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵄⵉⵣⵣⴻⵏ ⵣⴻⴳ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⴻⵣⵏⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵉⴷⵉ ⵉⵜⵜⴻⵅⵙ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓ ⵜⵜⴻⵅⵙⴻⵏ ⵚⵚⴻⴷⵇⴻⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵙ ⵣⵣⴱⵉⴱ.” ");
INSERT INTO rift_vpl VALUES ("HS3_2","029_3_2","HOS","3","2","2","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵖⵉⵖ ⵜⵜ ⵉ ⵏⴻⵛⵛ ⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵓⵇⵉⵢⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵓⵃⵓⵎⵉⵔ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS3_3","029_3_3","HOS","3","3","3","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙ: “ⵛⴻⵎ ⴰⴷ ⵖⴰⵔⵉ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵎⴻⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("HS3_4","029_3_4","HOS","3","4","4","ⵎⴰⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⴱⵍⴰ ⴰⵊⴻⴵⵉⴷ, ⴱⵍⴰ ⵍⵃⴰⴽⴻⵎ, ⴱⵍⴰ ⵜⴰⵖⴰⵔⵚⵜ, ⴱⵍⴰ ⴰⵎⴰⵢⴹⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴱⵍⴰ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("HS3_5","029_3_5","HOS","3","5","5","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ¸ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵓ ⵅ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ. ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS4_1","029_4_1","HOS","4","1","1","“ⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴽⵙⵉ ⵜⴰⵏⴼⵓⵍⵜ ⴹⵉⴷⴷ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵢⴻⴵⵉ ⵍⴰⵎⴰⵏ ⵏⵉⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓⵍⴰ ⴷ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("HS4_2","029_4_2","HOS","4","2","2","ⵜⵉⴽⴽⵯⵓⵔⴰ ⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵓⵎⴻⵏⵖⵉ ⴷ ⵜⵓⵛⵛⴻⴼⴼⵔⴰ ⴷ ⵣⵣⵉⵏⴰ! ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⴷⵓⵇⵇⵣⴻⵏ, ⴰⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS4_3","029_4_3","HOS","4","3","3","ⵅ ⵓⵢⴰ ⵜⵛⴻⵟⵟⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵓ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵉⵜⵜⴰⵥⴻⵖ: ⵍⴻⵡⵃⵓⵛ ⵏ ⵢⴻⵢⵢⴰⵔ ⴷ ⵢⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵀ, ⵓⵍⴰ ⴷ ⵉⵙⴻⵍⵎⴰⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS4_4","029_4_4","HOS","4","4","4","ⵎⴰⵛⴰ ⵓⵛⵜ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⴷ ⵖⴰ ⵉⴽⵙⵉⵏ ⵜⴰⵏⴼⵓⵍⵜ ⵓ ⵓⵛⵜ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵜⵛⴰⵏ. ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⵅⵎⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵛⴻⵏ ⴰⴽ-ⴷ ⵓⴽⴻⵀⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS4_5","029_4_5","HOS","4","5","5","ⵙ ⵓⵣⵉⵍ ⴰⴷ ⵜⴻⵏⵇⴰⵔⴹⴻⴷ ⵓ ⵙ ⴵⵉⵍⴻⵜ ⴰⴷ ⵉⵏⵇⴰⵔⴹ ⵄⴰⴷ ⴰⵏⴰⴱⵉ ⴰⴽⵉⴷⴻⴽ, ⵓ ⵢⴻⵎⵎⴰⵛ ⴰⴷ ⵜⵜ ⵙⵙⵀⴻⵍⵍⴽⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HS4_6","029_4_6","HOS","4","6","6","ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⴷⵡⴻⵍ ⴷ ⴰⵢⵏⴰⵡ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜ ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ. ⵓⵎⵉ ⵛⴻⴽ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵜⵓⵙⵙⵏⴰ, ⵏⴹⴰⵔⴻⵖ ⵛⴻⴽ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵄⴰⴷ ⴰⵎ ⵓⴽⴻⵀⵀⴰⵏ. ⵓⵎⵉ ⵛⴻⴽ ⵜᵉⵜⵜⵓⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵓⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HS4_7","029_4_7","HOS","4","7","7","ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵡⴻⵙⵄⴻⵏ¸ ⴰⵔⵏⵉⵏ ⴷⵉ ⴷⴷⵏⵓⴱ ⴰⴽⵉⴷⵉ. ⴰⴷ ⴰⵔⵔⴻⵖ ⵛⵛⴰⵏ ⵏⵙⴻⵏ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HS4_8","029_4_8","HOS","4","8","8","ⵏⵉⵜⵏⵉ ⵜⵜᵉⵜⵜⴻⵏ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ ⵜⵜⴰⵔⵔⴰⵏ ⵎⴻⵥⵔⵉ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS4_9","029_4_9","HOS","4","9","9","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵉⴵⴰ ⵓⴽⴻⵀⵀⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵍⴳⴻⵏⵙ. ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⵙ ⵅⴻⵍⴼⴻⵖ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ ⵓ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵜⴻⵏⵜ ⵅⴻⴵⵚⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HS4_10","029_4_10","HOS","4","10","10","ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵊⵊⵉⵡⵉⵏⴻⵏ ⵛⴰ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵎⴰⵔⴻⵏⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⴻⴳ ⵓⵃⴻⵜⵜⵓ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS4_11","029_4_11","HOS","4","11","11","ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⴱⵉⵏⵓ ⵓ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴰⵇⴰ ⴽⴽⵙⴻⵏ ⵓⵍ ⵉ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HS4_12","029_4_12","HOS","4","12","12","ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵜⵜⵙⴻⵇⵙⴰ ⵚⵚⴰⵏⴰⵎ ⵏⵏⴻⵙ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵜⴻⵡⵛ ⵍⴻⵅⴱⴰⵔ, ⵎⵉⵏⵣⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵉⵖⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⵍⴰⵎⵉ ⴼⴼⵖⴻⵏ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ ⵣⵉ ⵙⴰⴷⵓ ⴰⵃⴻⵟⵟⵓ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS4_13","029_4_13","HOS","4","13","13","ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵓ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵔⵉⵏ ⵜⵜⴰⵡⵢⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ, ⵙⴰⴷⵓ ⵍⴱⴻⴵⵓⴹ ⴷ ⵚⵚⴻⴼⵚⴰⴼ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵢⵉⴳⴳ, ⵎⵉⵏⵣⵉ ⵜⵉⵍⵉ ⵏⵙⴻⵏ ⵜⴻⵚⴱⴻⵃ. ⵅ ⵓⵢⴰ ⵙⵙⴻⴼⵙⴰⴷⴻⵏⵜ ⵢⴻⵙⵙⵉⵜⵡⴻⵎ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵓ ⵜⵉⵙⵍⴰⵜⵉⵏ ⵏⵡⴻⵎ ⵜⵜⴰⵔⴻⵥⵥⴰⵏⵜ ⵍⴻⵎⵍⴰⵛ ⵙ ⵣⵣⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HS4_14","029_4_14","HOS","4","14","14","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵡⵉⴹⴻⵖ ⵍⵃⵓⴽⵎ ⵅ ⵢⴻⵙⵙⵉⵜⵡⴻⵎ ⵓⵎⵉ ⵙⵙⴼⴻⵙⴷⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵓⵍⴰ ⵅ ⵜⴻⵙⵍⴰⵜⵉⵏ ⵏⵡⴻⵎ ⵓⵎⵉ ⵜⵜⴰⵔⴻⵥⵥⴰⵏⵜ ⵍⴻⵎⵍⴰⵛ ⵙ ⵣⵣⵉⵏⴰ. ⴰⵇⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵃⵓⵣⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏⵜ ⵜⵉⵖⴰⵔⵚⴰ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ. ⴰⴷ ⵉⵡⴹⴰ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵍⴻⵄⵇⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("HS4_15","029_4_15","HOS","4","15","15","“ⵡⴰⵅⵅⴰ ⵛⴻⴽ, ⵉⵙⵔⴰⵉⵍ, ⵜⴻⵙⵙⴻⴼⵙⴻⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵜⵜⴰⵔⵔⵉ ⵓⵍⴰ ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ. ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⵉⵎ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ, ⵡⴰⵔ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵎ ⵖⴰⵔ ⴱⴰⵢⵜ-ⴰⵡⴰⵏ ⵓ ⵡⴰⵔ ⵜⵜⵊⴰⴵⴰⵎ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⵙⵉⴷⵉ!’ ");
INSERT INTO rift_vpl VALUES ("HS4_16","029_4_16","HOS","4","16","16","ⵎⵉⵏⵣⵉ ⵉⵙⵔⴰⵉⵍ ⴷⴰⵢⴻⵙ ⵜⴰⵖⴻⵏⵏⴰⵏⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴼⵓⵏⴰⵙⵜ ⵜⵄⴰⵔⵔⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵡⴻⵙ ⵙⵉⴷⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵎⴰⵔ ⴰⵎⴻⵥⵢⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵉⵡⴻⵙⵄⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("HS4_17","029_4_17","HOS","4","17","17","ⵉⴼⵔⴰⵢⵉⵎ ⵉⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⴻⵊⵊ ⵉ-ⵜ, ⵉⵙⵎⴻⵃ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS4_18","029_4_18","HOS","4","18","18","ⵜⴰⵙⴻⵙⵙⵉⵜ ⵏⵙⴻⵏ ⴷⴰⵢⴻⵙ ⵙⵙⴻⵎ, ⵜⵜⴻⴳⴳⴻⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⵡⴰⵔⵏⵉ ⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵓ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ ⵏⵙⴻⵏ ⵜⵜⴻⵅⵙⴻⵏ ⵎⵖⵉⵔ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("HS4_19","029_4_19","HOS","4","19","19","ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⵙⵙⵊⴻⴱⴷ ⵉ-ⵜⵜ ⵙ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ: ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⵙⴻⴹⵃⴰⵏ ⵣⵉ ⵜⵖⴰⵔⵚⵉ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS5_1","029_5_1","HOS","5","1","1","“ⵙⵍⴻⵎ ⴰⵢⴰ, ⴽⴻⵏⵏⵉⵡ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵃⴹⴰⵎ ⴽⴻⵏⵏⵉⵡ ⴰⵢⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵡⵛⴻⵎ ⴰⵎⴻⵣⵣⵓⵖ, ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵖⴰⵔ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⵉ ⵎⵉⵚⴼⴰⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵔⴰⵛⵛⴰ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵜⴰⴱⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("HS5_2","029_5_2","HOS","5","2","2","ⵉⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵙⵙⵉⴵⵖⴻⵏ ⵜⴰⵙⵔⴰⴼⵜ ⵏ ⵡⴻⵏⵖⴰⵢ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵄⴰⵇⴱⴻⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HS5_3","029_5_3","HOS","5","3","3","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⵏⵏⵓⴼⴼⴰⵔ. ⵎⴰⵖⴰⵔ ⵍⴻⵅⵅⵓ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵉⴼⵔⴰⵢⵉⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵙⵔⴰⵉⵍ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS5_4","029_5_4","HOS","5","4","4","ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵜⵎⴻⵏⵏⵄⴻⵏⵜ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS5_5","029_5_5","HOS","5","5","5","ⴰⵄⴻⴼⴼⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵅⴰⵙ ⵉⴷⵄⴰ ⵙ ⴱⵟⴰⵢⵟⴰⵢ. ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵉⵏⵇⴰⵔⴹ. ");
INSERT INTO rift_vpl VALUES ("HS5_6","029_5_6","HOS","5","6","6","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⴳⴳⵯⴻⵊⴻⵏ ⴰⴽ-ⴷ ⵡⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜ ⵜⵜⵉⴼⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS5_7","029_5_7","HOS","5","7","7","ⵏⵉⵜⵏⵉ ⵖⴷⴰⵔⴻⵏ ⵙⵉⴷⵉ ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ-ⴷⴷ ⵜⴰⵔⵡⴰ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴻⵏ ⵢⴻⵛⵛ ⵓⵢⵓⵔ ⴰⵎⴰⵢⵏⵓ ⴰⴽ-ⴷ ⵜⵙⴻⵇⵇⴰⵍ ⵏⵙⴻⵏ ⵏ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("HS5_8","029_5_8","HOS","5","8","8","“ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵊⵉⴱⵄⴰ, ⴷⵉ ⵍⴱⵓⵇ ⴷⵉ ⵔⴰⵎⴰ, ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴱⴰⵢⵜ-ⴰⵡⴰⵏ: ‘ⴰⵡⴰⵔⵏⵉ ⴰⵛ, ⴰ ⴱⵉⵏⵢⴰⵎⵉⵏ!’ ");
INSERT INTO rift_vpl VALUES ("HS5_9","029_5_9","HOS","5","9","9","ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵄⵉⵇⴰⴱ. ⵏⴻⵛⵛ ⴱⴰⵔⵔⵃⴻⵖ ⵊⴰⵔ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳ ⴰⴷ ⵉⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HS5_10","029_5_10","HOS","5","10","10","ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵎⵓⵟⵟⵓⵢⴻⵏ ⵉⵥⵔⴰ ⵏ ⵡⴻⵢⵎⵉⵔ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵣⴻⴵⵄⴻⵖ ⴰⴷⵓⵇⵇⴻⵣ ⵉⵏⵓ ⵏ ⵓⴼⵓⴳⴻⵎ ⴰⵎ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS5_11","029_5_11","HOS","5","11","11","“ⵉⴼⵔⴰⵢⵉⵎ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ, ⵍⵃⴻⵇⵇ ⵉⵜⵜⵡⴰⵍⴱⴻⵣ, ⵎⴰⵖⴰⵔ ⵉⵄⵊⴻⴱ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴹⴼⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("HS5_12","029_5_12","HOS","5","12","12","ⵏⴻⵛⵛ ⴰⵎ ⵜⵛⵉⵏⴷⴰ ⵉ ⵉⴼⵔⴰⵢⵉⵎ ⵓ ⴰⵎ ⵓⵔⴻⵚⵚⵓⴹ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HS5_13","029_5_13","HOS","5","13","13","ⵓⵎⵉ ⵉⵥⵔⴰ ⵉⴼⵔⴰⵢⵉⵎ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ ⵓ ⵢⴰⵀⵓⴷⴰ ⵜⴰⵔⴻⵃⵙⵉⵜ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ ⵉⴼⵔⴰⵢⵉⵎ ⵖⴰⵔ ⴰⵛⵛⵓⵔ, ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵔⴻⵇⵇⴰⵙ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵔⵉⴱ. ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵓ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⴽⴻⵙⵙⵉ ⵜⴰⵔⴻⵃⵙⵉⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HS5_14","029_5_14","HOS","5","14","14","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⵉ ⵉⴼⵔⴰⵢⵉⵎ ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ ⵓ ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵏⴻⵛⵛ, ⵡⴰⵀ ⵏⴻⵛⵛ, ⴰⴷ ⵎⴻⵣⵣⵇⴻⵖ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵖ, ⴰⴷ ⵜ ⴰⵡⵢⴻⵖ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵡⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS5_15","029_5_15","HOS","5","15","15","ⵏⴻⵛⵛ ⴰⴷ ⴼⴼⵖⴻⵖ ⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵄⴻⵇⴱⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵓ, ⴰⵍ ⵖⴰ ⵏⴻⵄⵎⴻⵏ ⵓ ⴰⴷ ⴰⵔⵣⵓⵏ ⵓⴷⴻⵎ ⵉⵏⵓ. ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⴰⴷ ⵅⴰⴼⵉ ⴰⵔⵣⵓⵏ ⵣⵉⵛ ⵖⴰⵔ ⵚⵚⴱⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("HS6_1","029_6_1","HOS","6","1","1","“ⴰⵙⴻⵎ-ⴷⴷ, ⴰⴷ ⴷⴷ-ⵏⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵇⴻⵣⵣⴰⵔ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴳⴻⵏⴼⴰ, ⵏⴻⵜⵜⴰ ⵉⵡⵜⴰ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵛⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS6_2","029_6_2","HOS","6","2","2","ⴰⵡⴰⵔⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⵔ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS6_3","029_6_3","HOS","6","3","3","ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵙⵙⴻⵏ, ⴰⴷ ⵏⴻⴹⴼⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵙⵉⴷⵉ. ⴰⴹⵀⴰⵔ ⵏⵏⴻⵙ ⵉⵎⵜⴻⵏ ⴰⵎ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⴻⴼⵊⴰⵔ. ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵢⴰⵙ ⴰⵎ ⵡⴻⵏⵥⴰⵔ, ⴰⵎ ⵡⴻⵏⵥⴰⵔ ⵏ ⴰⵔⴱⵉⵄ ⵏⵏⵉ ⵉⵙⵙⴰⵔⴹⴰⴱⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ.”    ");
INSERT INTO rift_vpl VALUES ("HS6_4","029_6_4","HOS","6","4","4","“ⵎⵉⵏ ⴰⴽⵉⴷⴻⴽ ⵖⴰ ⴳⴳⴻⵖ, ⴰ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⵉⵏ ⴰⴽⵉⴷⴻⴽ ⵖⴰ ⴳⴳⴻⵖ, ⴰ ⵢⴰⵀⵓⴷⴰ. ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏⵡⴻⵎ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜᵉⵜⵜⴻⴳⴳ ⴰⵎ ⵓⵙⴻⵢⵏⵓ ⵖⴰⵔ ⵜⴻⴼⴼⵓⵜ ⵓ ⴰⵎ ⵏⵏⴷⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵇⴻⵟⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("HS6_5","029_6_5","HOS","6","5","5","ⵅ ⵓⵢⴰ ⵏⴻⵛⵛ ⵇⴻⵙⵙⴻⵖ ⵜⴻⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⵎ ⵙ ⵉⵊⵊ ⵏ ⵓⵢⴻⵍⵣⵉⵎ. ⵏⴻⵛⵛ ⵏⵖⵉⵖ ⵜⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ⵍⴻⵃⴽⴰⵎⴰⵜ ⵅⴰⴽ ⴰⵎⴻⵛⵏⴰⵡ ⵜⴼⴰⵡⵜ ⵉⵏⵏⵓⴼⵙⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS6_6","029_6_6","HOS","6","6","6","ⵎⵉⵏⵣⵉ ⵜⵜⴻⵅⵙⴻⵖ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵜⴰⵖⴰⵔⵚⵜ, ⵓ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉ ⵜⵜⴻⵅⵙⴻⵖ ⵜⵜ ⵅ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("HS6_7","029_6_7","HOS","6","7","7","“ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⴰⵏ ⵅ ⵍⵄⴰⵀⴷ ⴰⵎ ⴰⴷⴰⵎ. ⴷⵉⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵖⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS6_8","029_6_8","HOS","6","8","8","ⵊⵉⵍⵄⴰⴷ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS6_9","029_6_9","HOS","6","9","9","ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ ⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⴻⵔⴼⵉⵇⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵏⵉⵜⵏⵉ ⵏⴻⵇⵇⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⴷⴷ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⴼⴹⴰⵢⴻⵃ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("HS6_10","029_6_10","HOS","6","10","10","ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⵙⵙⵏⴻⵅⵍⴰⵄ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵅⵣⴰⵔ, ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⵉⵙⵔⴰⵉⵍ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("HS6_11","029_6_11","HOS","6","11","11","“ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ, ⴰ ⵢⴰⵀⵓⴷⴰ, ⴰⵇⴰ ⵜⴻⵎⵎⴰⵔⵙ ⵉⵛⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵉ ⵛⴻⴽ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵉⵎⴻⵃⴱⴰⵙ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("HS7_1","029_7_1","HOS","7","1","1","“ⴰⵎ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵉⵙⵔⴰⵉⵍ, ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵍⵖⴻⵛⵛ. ⴰⵛⴻⴼⴼⴰⵔ ⵉⵜⵜⴰⴷⴻⴼ ⵓ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵜᵉⵜⵜⴽⴻⵛⵛⴰⴹ ⴷⵉ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HS7_2","029_7_2","HOS","7","2","2","ⵎⴰⵛⴰ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⵏⴹⴻⵏⵜ ⴰⵙⴻⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HS7_3","029_7_3","HOS","7","3","3","ⵏⵉⵜⵏⵉ ⵙⵙⴼⵔⴰⵃⴻⵏ ⴰⵊⴻⴵⵉⴷ ⵙ ⵍⵖⴰⵔ ⵏⵙⴻⵏ ⵓ ⵍⵃⵓⴽⴽⴰⵎ ⵙⵙⴼⵔⴰⵃⴻⵏ ⵜⴻⵏ ⵙ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS7_4","029_7_4","HOS","7","4","4","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⵣⴻⵏⵏⴰⵢⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⴰⵔⵔⴰⵏ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵎⴰⵏ ⵣⴻⴳ ⵓⵅⴻⴱⴱⴰⵣ. ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵉⵙⵙⴱⴻⴷⴷ ⵣⴻⴳ ⵓⵛⴻⵎⵎⵓⴹ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴳⴳⵯⵉⵏ ⴰⵔⴻⵛⵜⵉ ⴰⵍ ⵉⵙⵎⴻⵎ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("HS7_5","029_7_5","HOS","7","5","5","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵖ ⵙⵙⵀⴻⵍⵛⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⵃⴰⴷⵓⵇ ⵏ ⴱⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉ ⵢⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS7_6","029_7_6","HOS","7","6","6","ⵅⵎⵉ ⴷⴷ-ⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ, ⵢⴰⵔⴻⵇⵇ ⵓⵍ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⴰⵔⵔⴰⵏ ⵣⵉ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ. ⵉⵜⵜⴻⵟⵟⴻⵚ ⵓⵅⴻⴱⴱⴰⵣ ⵏⵙⴻⵏ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ. ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵢⴰⵔⴻⵇⵇ ⵓⴼⴰⵔⵔⴰⵏ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS7_7","029_7_7","HOS","7","7","7","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵃⴻⵎⵎⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴼⴰⵔⵔⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜᵉⵜⵜⴻⵏ ⵍⵇⵓⴹⴰⵜ ⵏⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵡⴹⴰⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉ ⴷⴷ ⵅⴰⴼⵉ ⵖⴰ ⵉⵍⴰⵖⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS7_8","029_7_8","HOS","7","8","8","“ⵉⴼⵔⴰⵢⵉⵎ ⵉⵊⵊⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵙⵙⵓⵔ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⴼⴹⵉⵍⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵇⵍⴻⴱ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("HS7_9","029_7_9","HOS","7","9","9","ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵙⴰⵔⴹⴻⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⵉⵛⵉ. ⵓⵍⴰ ⴷ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⵉⵜⵜⵛⴰⴱ, ⵡⴰⵔ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⵉⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("HS7_10","029_7_10","HOS","7","10","10","ⴰⵄⴻⴼⴼⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵅⴰⵙ ⵉⴷⵄⴰ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵏ ⵛⴰ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓ ⵡⴰⵔ ⵜ ⴰⵔⵣⵓⵏ ⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("HS7_11","029_7_11","HOS","7","11","11","ⵉⴼⵔⴰⵢⵉⵎ ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⴷⴱⵉⵔⵜ ⴰⵃⴰⴼⵉ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵍⴻⴼⵀⴰⵎⴻⵜ. ⵏⵉⵜⵏⵉ ⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵎⵉⵚⵔⴰ, ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("HS7_12","029_7_12","HOS","7","12","12","ⵅⵎⵉ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵜⵜⴱⴻⵣⵣⴰⵄⴻⵖ ⵏⴻⵛⵛ ⵜⵔⴰⵛⵛⴰ ⵉⵏⵓ ⵅⴰⵙⴻⵏ, ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵙⵙⴻⵀⵡⵉⵖ ⴰⵎ ⵢⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⵜⴻⵏ ⵡⴻⴱⴱⵅⴻⵖ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⵍⴻⵅⴱⴰⵔ ⵣⵉ ⵊⵊⵀⴻⵜ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS7_13","029_7_13","HOS","7","13","13","ⵓⵛⵜ ⵅⴰⵙⴻⵏ ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵣⴰⵢⵉ. ⴰⴽⴻⵃⵃⴻⴹ ⵅⴰⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⴰⵏ ⵅⴰⴼⵉ. ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⴷ ⵜⴻⵏ ⴼⴷⵉⵖ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⵅⴰⴼⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS7_14","029_7_14","HOS","7","14","14","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵙⵖⵓⵢⴻⵏ ⵛⴰ ⵖⴰⵔⵉ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵅⵎⵉ ⵟⵟⵚⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⵍⴻⵛⵜⵓ ⵏⵙⴻⵏ ⵜⵜⵛⴻⵜⵛⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵜⵎⵓⵏⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⴰⵇⴰ ⵜⵜⵖⴻⵏⵏⴰⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("HS7_15","029_7_15","HOS","7","15","15","ⵏⴻⵛⵛ ⴷⴰⵔⵔⴱⴻⵖ ⵓ ⵙⵙⵊⴻⵀⴷⴻⵖ ⵉⵖⴰⴵⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⴷⴰⵢⵉ ⴷⵉ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HS7_16","029_7_16","HOS","7","16","16","ⵏⵉⵜⵏⵉ ⵜⵜⵄⴰⵇⵇⴰⴱⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵇⴻⵡⵙ ⵉⵅⴻⵟⵟⴰⵏ, ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ ⵡⴻⵟⵟⴰⵏ ⵣⵉ ⵙⵙⵉⴼ, ⵣⵉ ⵙⴻⵎⵎ ⵉⵏⴻⵇⵇⴻⵏ ⵏ ⵢⵉⵍⴻⵙ ⵏⵙⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⴳⴳⴻⵏ ⵜⵉⴹⴻⵃⵃⴰⵛ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("HS8_1","029_8_1","HOS","8","1","1","“ⴳⴳⴻⵎ ⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵉ ⵓⵙⵓⴹⵉ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ. ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ ⵉⵟⵟⴰⵡ ⵏⴻⵜⵜⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵄⴻⴷⴷⴰⵏ ⵅ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵓ ⵖⴻⵡⵡⵖⴻⵏ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HS8_2","029_8_2","HOS","8","2","2","ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⴼⵉ ⴷⴷ-ⵍⴰⵖⴰⵏ: ‘ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵏⴻⵛⵛⵉⵏ, ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⵛⴻⴽ!’ ");
INSERT INTO rift_vpl VALUES ("HS8_3","029_8_3","HOS","8","3","3","ⵉⵙⵔⴰⵉⵍ ⵉⵏⴹⴰⵔ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵍⴻⵄⴷⵓ ⴰⴷ ⵜ ⵉⴹⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HS8_4","029_8_4","HOS","8","4","4","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵅⴰⵙⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵣⵣⴰⵢⵉ, ⵏⵉⵜⵏⵉ ⴰⵔⴻⵛⵛⵃⴻⵏ ⵍⵃⵓⴽⴽⴰⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜ ⵙⵙⵉⵏⴻⵖ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵍⴻⵅⵢⴰⵍ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("HS8_5","029_8_5","HOS","8","5","5","ⴰⵄⴻⵊⵎⵉ ⵏⵏⴻⵛ ⴷ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ, ⴰ ⵙⴰⵎⴰⵔⵢⴰ! ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⵢⴰⵔⴻⵇⵇ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ. ⴰⵍ ⵎⴻⵍⵎⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⵙⵉⵏ ⵜⴰⵣⴷⵓⴳⵉ? ");
INSERT INTO rift_vpl VALUES ("HS8_6","029_8_6","HOS","8","6","6","ⵎⴰⵖⴰⵔ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⴻⵅⵢⴰⵍ ⵏ ⵚⵚⴰⵏⴰⵎ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⴱⵓ-ⵚⵚⴻⵏⵄⴻⵜ ⵉⴳⴳⴰ ⵉ-ⵜ ⵓ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ. ⵡⴰⵀ, ⴰⴷ ⵉⴷⵡⴻⵍ ⵍⴻⵅⵢⴰⵍ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ, ⴰⵄⴻⵊⵎⵉ ⵏ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("HS8_7","029_8_7","HOS","8","7","7","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵣⴰⵔⵔⵄⴻⵏ ⴰⵙⴻⵎⵎⵉⴹ ⵓ ⵎⴻⵊⵊⴰⵔⴻⵏ ⵜⴰⵃⴰⵔⵢⴰⴹⵜ. ⵡⴰⵔ ⵜⵜⵉⴼⴻⵏ ⵜⵉⴷⵔⵉⵏ ⵖⴰⵔ ⵉⵖⴻⴷⴷⵓⵢⴻⵏ, ⵓ ⵣⴻⴳ ⵉⵎⴻⵏⴷⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵙⵙⵎⵉⴷ, ⵏⵉⵖ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ, ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵚⴰⵔⴹⴻⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS8_8","029_8_8","HOS","8","8","8","“ⴰⵇⴰ ⵉⵙⵔⴰⵉⵍ ⵉⵜⵜⵡⴰⵚⴰⵔⴹ. ⵍⴻⵅⵅⵓ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("HS8_9","029_8_9","HOS","8","9","9","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⴰⵛⵛⵓⵔ. ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ ⵏ ⵍⴻⵅⵍⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵜⵜⵅⴻⴵⴰⵚⴻⵏ ⵉ ⵉⵎⵃⵉⴱⴱⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS8_10","029_8_10","HOS","8","10","10","ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵣⵣⴻⵏⵣⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵛⴰ ⴳⴳⵓⵔ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵡⴻⵖ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵡⴰⵀⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵣⵣⴻⵢⵢⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵍⵃⵓⴽⴽⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("HS8_11","029_8_11","HOS","8","11","11","ⵎⴰⵖⴰⵔ ⵉⴼⵔⴰⵢⵉⵎ ⵉⴳⴳⴰ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴷⴷⴻⵏⴱ. ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("HS8_12","029_8_12","HOS","8","12","12","ⵏⴻⵛⵛ ⵓⵔⵉⵖ ⴰⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵅⴰⵙⴻⵏⵜ ⴰⵎ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵖⵔⵉⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("HS8_13","029_8_13","HOS","8","13","13","ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵏ ⵚⵚⴷⴰⵇⵉ ⵉⵏⵓ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴻⵀⵀⴱⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴰⵢⵙⵓⵎ ⵓⵛⴰ ⵜⵜᵉⵜⵜⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵢⴰⵔⴻⵟⵟⵉ. ⵍⴻⵅⵅⵓ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HS8_14","029_8_14","HOS","8","14","14","ⵎⴰⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ ⵉⵜⵜⵓ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⵉⴱⵏⴰ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ, ⵓⵛⴰ ⵢⴰⵀⵓⴷⴰ ⵉⴽⴻⵜⵜⴰⵔ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("HS9_1","029_9_1","HOS","9","1","1","“ⵡⴰⵔ ⴼⴰⵔⵔⴻⵃ ⵛⴰ ⴰⵎⵎⵓ, ⵉⵙⵔⴰⵉⵍ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⴻⵙⵍⵉⵡⵍⵉⵡⴻⴷ ⴰⵎ ⵍⴻⴳⵏⵓⵙ. ⵎⴰⵖⴰⵔ ⵜⵉⴳⴳⵯⴻⵊⴻⴷ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴰⵎ ⵜⴻⵙⵙⴻⴼⵙⴻⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⵜⴻⵜⵜⴻⵅⵙⴻⴷ ⵍⵎⵓⵏⴻⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵏⴻⴷⵔⴰⵔ ⵏ ⵓⵙⴰⵔⵡⴻⵜ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS9_2","029_9_2","HOS","9","2","2","ⴰⵏⴷⵔⴰⵔ ⴷ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵙⵙⴻⵛⵛⴻⵏ ⵛⴰ ⵓ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴰⴷ ⵜⵜ ⵉⵅⴻⵢⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("HS9_3","029_9_3","HOS","9","3","3","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵖⵉⵎⴰⵏ ⵛⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ ⴷⵉ ⴰⵛⵛⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("HS9_4","029_9_4","HOS","9","4","4","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⴻⵢⵢⴱⴻⵏ ⵛⴰ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⴱⵉⵏⵓ ⵉ ⵙⵉⴷⵉ ⵓ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⵡⴰⵔ ⵅⴰⵙ ⴰⵔⴻⵟⵟⴰⵏⵜ. ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵏⵜ ⴰⵎ ⵡⴻⵖⵔⵓⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉⵛⴻⵟⵟⵏⴻⵏ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵛⵛⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵅⴻⵎⵊⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵖⵔⵓⵎ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HS9_5","029_9_5","HOS","9","5","5","ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⵅⴻⵏⵏⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⵄⵉⴷ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵄⵉⴷ ⵏ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("HS9_6","029_9_6","HOS","9","6","6","ⵎⴰⵖⴰⵔ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴰⴳⴳⵯⴻⵊⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵔⴻⴷⴷⴻⴵ. ⵎⵉⵚⵔⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵎⵓⵏ, ⵎⵓⴼ ⴰⴷ ⵜⴻⵏ ⵜⴻⵏⴹⴻⵍ. ⵉⵔⴻⵣⵣⴰⵣⴻⵏ ⴰⴷ ⵎⴻⵥⵥⵔⴻⵏ ⴷⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ, ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴰⴷ ⵉⵟⵟⴻⴼ ⴰⵎⵛⴰⵏ ⵏ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS9_7","029_9_7","HOS","9","7","7","ⴰⵇⴰ ⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴰⵔⵔⴻⴱ ⵓⵙⵉⵏ-ⴷⴷ, ⴰⵇⴰ ⵓⵙⵙⴰⵏ ⵏ ⵍⵄⵉⵇⴰⴱ ⵓⵙⵉⵏ-ⴷⴷ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜ ⵙⵙⵏⴻⵏ, ⵉⵏⵏⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ⴰⵏⴰⴱⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴰⴱⵓⵀⴰⵍⵉ ⵉ ⵏⵉⵜⵏⵉ, ⴰⵔⵢⴰⵣ ⴰⵔⵔⵓⵃⴰⵏⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵊⵏⵓⵏ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⴷⴰⵡⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HS9_8","029_9_8","HOS","9","8","8","ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵉⵜⵜⵄⴻⵙⵙⴰⵙ ⴰⴽ-ⴷ ⵓⵄⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵡⴰⵀ, ⵏⴻⵜⵜⴰ, ⴰⵏⴰⴱⵉ ⵉⵜⵜⴰⴼ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⵏ ⵓⵏⴻⴳⵎⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⵍⴻⵄⴷⴰⵡⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS9_9","029_9_9","HOS","9","9","9","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔⵇⴻⵏ ⴰⵍ ⵉⵍⵉ, ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵏ ⵊⵉⴱⵄⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⵇⴻⵍ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵉⵅⵍⴻⴼ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS9_10","029_9_10","HOS","9","10","10","“ⵏⴻⵛⵛ ⵓⴼⵉⵖ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵓⴹⵉⵍ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵥⵔⵉⵖ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴰⵎ ⵢⵉⵎⴻⵏⵣⴰ ⵏ ⵡⴰⵔⵜⵓ ⴷⵉ ⵜⴻⵎⵥⵉ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⴱⴰⵄⵍ-ⴼⴰⵖⵓⵔ ⵓⵛⴰ ⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵏⵏⵄⴰⵡⴰⵜ ⴰⵎ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS9_11","029_9_11","HOS","9","11","11","ⵅ ⵢⵉⵏⵏⵉ ⵏ ⵉⴼⵔⴰⵢⵉⵎ, ⴰⵇⴰ ⴰⵄⵓⴵⵉ ⵏⵙⴻⵏ ⴰⴷ ⵉⴹⵓ ⴰⵎ ⵡⴻⵊⴹⵉⴹ, ⴰⴷ ⵢⴰⴳⴳⵯⴻⵊ ⵅ ⵡⴻⵅⵍⴰⵇ ⵓ ⵅ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⵓ ⵅ ⵜⴽⴻⵙⵙⵉⵜ ⵏ ⵜⴰⵔⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("HS9_12","029_9_12","HOS","9","12","12","ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵢⴰⵎⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵍ ⵖⴰ ⵎⵖⴰⵔⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⵏⵀⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⴱⵏⴰⴷⴻⵎ. ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⵉ ⵏⵉⵜⵏⵉ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵓⵛⵜ, ⵅⵎⵉ ⵅⴰⵙⴻⵏ ⵖⴰ ⵃⴻⵢⵢⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HS9_13","029_9_13","HOS","9","13","13","ⴰⵅⵎⵉ ⵥⵔⵉⵖ ⵚⵓⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⵥⵥⵓ ⵉⴼⵔⴰⵢⵉⵎ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵊⵊⵉⵀⴻⵜ ⴰⵔⴹⴰⵏ. ⵓ ⵍⴻⵅⵅⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵉ ⵓⵇⴻⵜⵜⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("HS9_14","029_9_14","HOS","9","14","14","ⴻⵡⵛ ⴰⵙⴻⵏ, ⴰ ⵙⵉⴷⵉ! ⵎⵉⵏ ⵉ ⵖⴰ ⵜⴻⵡⵛⴻⴷ? ⴻⵡⵛ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵙ ⵡⴻⵟⵟⵓⵡ ⵏ ⵉⵙⴻⵢⵎⴰⵏ ⴷ ⵢⴻⴱⴱⴰⵛ ⵢⵓⵥⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS9_15","029_9_15","HOS","9","15","15","ⵎⴰⵔⵔⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵏⵙⴻⵏ ⵜⵄⴰⵔⵔⴰ ⴷⵉ ⵊⵉⵍⵊⴰⵍ, ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵛⴰⵔⵀⴻⵖ ⵜⴻⵏ ⵅ ⵜⵄⴻⴼⴼⴰⵏⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⴰⵥⵥⵍⴻⵖ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ. ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜⴻⵏ ⵅⵙⴻⵖ ⵄⴰⴷ, ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵙⴻⵏ ⴷ ⵉⵎⵖⴻⵡⵡⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS9_16","029_9_16","HOS","9","16","16","ⵉⴼⵔⴰⵢⵉⵎ ⵉⵜⵜⵡⴰⵡⵡⴻⵜ, ⵉⵥⴻⵡⵔⴰⵏ ⵏⵙⴻⵏ ⵓⵥⵖⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⵔⵡⴻⵏ ⵄⴰⴷ. ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴰⵔⵡⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⵏⵖⴻⵖ ⵉⵎⵄⵉⵣⵣⴰⵏ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS9_17","029_9_17","HOS","9","17","17","ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵉⵏⴹⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵜⴻⵙⵍⵉⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜᵉⵜⵍⵉⵄⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("HS10_1","029_10_1","HOS","10","1","1","“ⵉⵙⵔⴰⵉⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵜⴻⵡⵙⴻⵄ, ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵎⵎⴰⵔⵏⵉ, ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴻⵛⵃⴰⵍ ⵜⴻⵛⵏⴰ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS10_2","029_10_2","HOS","10","2","2","ⵓⵍ ⵏⵙⴻⵏ ⴰⵇⴰ ⵉⵜⵜⵡⴰⴱⴹⴰ, ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⵍⵄⵉⴱ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵥ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵀⴷⴻⵎ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("HS10_3","029_10_3","HOS","10","3","3","ⵎⴰⵖⴰⵔ ⵍⴻⵅⵅⵓ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⴳⴳⵯⵉⴷ ⵛⴰ ⵙⵉⴷⵉ, ⵓ ⵄⴰⴷ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵊⴻⴵⵉⴷ: ‘ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵏⴻⵖ ⵉⴳⴳ?’ ");
INSERT INTO rift_vpl VALUES ("HS10_4","029_10_4","HOS","10","4","4","ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ, ⵜⵜⵊⴰⴵⴰⵏ ⵥⵓⵔ ⴰⵎ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ, ⵓⵛⴰ ⵍⵃⵓⴽⵎ ⵉⴷⵡⴻⵍ ⵉⵜⵜⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⵛⴻⴱ ⴰⵎⴻⵙⵎⵓⵎ ⴷⵉ ⵍⴻⵅⴹⵓⴹ ⵏ ⵉⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS10_5","029_10_5","HOS","10","5","5","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴰⴷ ⵏⵏⵅⴻⵍⵄⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵄⴻⵊⵎⵉ ⵏ ⴱⴰⵢⵜ-ⴰⵡⴰⵏ, ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⵉⵛⴹⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⵛⴻⴹⵏⴻⵏ, ⵅ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS10_6","029_10_6","HOS","10","6","6","ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⴰⵛⵛⵓⵔ ⴷ ⵜⴰⵔⵣⴻⴼⵜ ⵉ ⵓⵊⴻⴵⵉⴷ ⵢⴰⵔⵉⴱ. ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⴳⴳ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵙⴻⴹⵃⴰ ⵣⵉ ⵍⵇⴰⵔⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS10_7","029_10_7","HOS","10","7","7","ⵉⵜⵜⵡⴰⵙⵙⴻⵙⵇⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴰⵎ ⵓⴽⵓⴼⴼⵓ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS10_8","029_10_8","HOS","10","8","8","ⴰⴷ ⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏⵜ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⴰⵡⴰⵏ, ⴰⵇⴰ-ⵜⴻⵏⵜ ⴷ ⴷⴷⴻⵏⴱ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⴰⴷ ⵓⵄⵍⴰⵏ ⵅ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⴷⵓⵔⴰⵔ: ‘ⴷⵍⴻⵎ ⴰⵏⴻⵖ!’ ⵓ ⵉ ⵜⴻⵡⵔⵉⵔⵉⵏ: ‘ⵡⴹⴰⵏⵜ-ⵉ-ⴷⴷ ⵅⴰⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("HS10_9","029_10_9","HOS","10","9","9","ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵊⵉⴱⵄⴰ ⵜⴻⴳⴳⵉⴷ ⴷⴷⵏⵓⴱ, ⴰ ⵉⵙⵔⴰⵉⵍ. ⴷⵉⵏⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ, ⵉⵡⴰ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵍⴻⵇⵇⵉⴼ ⵍⴰⵜⴰⵔ ⵏ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷⵉ ⵊⵉⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("HS10_10","029_10_10","HOS","10","10","10","ⴰⵇⴰ ⴷⴰⵢⵉ ⵎⴻⵥⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵛⴰⵔⴼⴻⵖ ⵓ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⵍⴻⴳⵏⵓⵙ ⵅⵎⵉ ⵜⴻⵏ ⵖⴰ ⵛⴰⵔⴼⴻⵖ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS10_11","029_10_11","HOS","10","11","11","“ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⵊⵎⵉⵜ ⵉⵜⵜⵡⴰⴷⴰⵔⵔⴱⴻⵏ, ⵜᵉⵜⵜⴻⵅⵙ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵡⴻⵜ. ⵏⴻⵛⵛ ⵄⴷⵓⵖ ⵅ ⵜⵛⵓⵏⵉ ⵏ ⵢⵉⵔⵉ ⵏⵏⴻⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵏⴻⴷⵀⴻⵖ ⵉⴼⵔⴰⵢⵉⵎ, ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵛⴰⵔⵣ, ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵉⵏⵇⴻⵛ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS10_12","029_10_12","HOS","10","12","12","ⵣⴰⵔⵄⴻⵎ ⵜⴰⵙⴻⴳⴷⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵊⴰⵔⴻⵎ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵄⴻⵎⵎⴰⵔⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ, ⵛⴰⵔⵣⴻⵎ ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉⵅⵡⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜ ⴷ ⵍⵃⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⵅ ⵙⵉⴷⵉ, ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵏⴻⵜⵜⴰ ⵓ ⴰⴷ ⵢⴰⵔⵔⴰ ⵜⴰⵙⴻⴳⴷⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵜⴻⵛⵛⴰⵜ ⴰⵎ ⵡⴻⵏⵥⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("HS10_13","029_10_13","HOS","10","13","13","“ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵛⴰⵔⵣⴻⵎ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵜⵚⴻⵢⵢⴼⴻⵎ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵜⴻⵛⵛⵉⵎ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵅⴰⵔⵔⵉⵇ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜᵉⵜⴻⵛⵍⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ ⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ, ⵅ ⵓⴱⴰⵔⵔⵓ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HS10_14","029_10_14","HOS","10","14","14","ⴰⴷ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⴷⴷⵔⵉⵣ ⵏ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵓ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵀⴷⴻⵎ ⵛⴰⵍⵎⴰⵏ ⴱⴰⵢⵜ-ⴰⵔⴱⵉⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ, ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵍⴱⴻⵣ ⵉⵛⵜ ⵏ ⵢⴻⵎⵎⴰⵙ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS10_15","029_10_15","HOS","10","15","15","ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⴱⴰⵢⵜ-ⵉⵍ ⴰⴽⵉⴷⵡⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵡⴻⵎ ⵢⵓⴵⵖⴻⵏ. ⵖⴰⵔ ⵍⴻⴼⵊⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵖⴹ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵖⴷ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("HS11_1","029_11_1","HOS","11","1","1","“ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵔⴰⵉⵍ ⵄⴰⴷ ⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵖ ⵜ ⵓ ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵉ ⵎⵎⵉ ⵣⵉ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HS11_2","029_11_2","HOS","11","2","2","ⵓⵍⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵓ ⵍⴰⵖⴰⵏ ⵅⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⵖⵢⴰ ⵅ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ‘ⵉⴱⴰⵄⵍⴻⵏ’ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵙⴻⵏ ⵉⵏⴻⵇⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS11_3","029_11_3","HOS","11","3","3","ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵜⵉⵛⵍⵉ ⵉ ⵉⴼⵔⴰⵢⵉⵎ, ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵜⴻⵏ ⵅ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵙⵙⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS11_4","029_11_4","HOS","11","4","4","ⵙ ⵜⴻⵙⵖⵓⵏⵉⵏ ⵏ ⴱⵏⴰⴷⴻⵎ ⵊⴻⴱⴷⴻⵖ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ, ⵙ ⵜⵎⵓⵔⴰⵔ ⵏ ⵜⵎⴻⵅⵙⵉⵡⵜ, ⵓ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵉ ⵏⵉⵜⵏⵉ ⴰⵎ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵣⵣⴰⵢⵍⴻⵜ ⵣⴻⴳ ⵉⵖⴻⵙⵎⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵛⵛ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⴰⴷ ⵉⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("HS11_5","029_11_5","HOS","11","5","5","“ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⵙ ⵓⵣⴻⴵⵉⴼ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⴰⵛⵛⵓⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵓⴳⵉⵏ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS11_6","029_11_6","HOS","11","6","6","ⵙⵙⵉⴼ ⴰⴷ ⵉⵏⵏⴻⴹ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵙ ⵏ ⵓⴱⴻⵍⵍⴻⵄ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵓ ⴰⴷ ⵜⴻⵏ ⵢⴻⵛⵛ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS11_7","029_11_7","HOS","11","7","7","ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵇⵇⵉⵎ ⵉⵜⵜⵏⴻⵇⵍⴰⴱ ⵅⴰⴼⵉ. ⵏⵉⵜⵏⵉ ⵜⵜⵍⴰⵖⴰⵏ ⵊⵎⵉⵄ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵄⵓⴵⵉ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("HS11_8","029_11_8","HOS","11","8","8","“ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⴻⵍⵍⵎⴻⵖ, ⵉⴼⵔⴰⵢⵉⵎ? ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⴻⵍⵍⵎⴻⵖ, ⵉⵙⵔⴰⵉⵍ? ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⴻⵍⵍⵎⴻⵖ ⴰⵎ ⴰⴷⴰⵎⴰ, ⴰⴷ ⵛⴻⴽ ⴳⴳⴻⵖ ⴷ ⴰⵎⴻⴷⵢⴰ ⴰⵎ ⵚⴰⴱⵓⵢⵉⵎ? ⵓⵍ ⵉⵏⵓ ⵉⵏⵏⴻⵃⵡⴻⵍ ⵣⵣⴰⵢⵉ, ⴰⵣⵉⴵⴻⵣ ⵉⵏⵓ ⵉⵜⵜⴻⵅⵜⵓⵅ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("HS11_9","029_11_9","HOS","11","9","9","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵊⵊⵉⵖ ⴰⴷ ⴰⵔⵅⵓⵖ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⴷⴷⵉⴽⴽⵡⵉⵍⴻⵖ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵉⴼⵔⴰⵢⵉⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴱⵏⴰⴷⴻⵎ, ⵏⴻⵛⵛ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⴻⵖ ⵛⴰ ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⵍⵖⴰⴹⴰⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HS11_10","029_11_10","HOS","11","10","10","ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⵓⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵎⵓⵀⵔⵓⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵢⵔⴰⴷ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵉⵙⵙⵎⵓⵀⵔⵓⵜ ⵏⴻⵜⵜⴰ ⵓⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵣⵉ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HS11_11","029_11_11","HOS","11","11","11","ⴰⵎ ⵉⵊⴹⴰⴹ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⴰⵎ ⵜⴻⴷⴱⵉⵔⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵛⵛⵓⵔ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵣⴻⴷⴻⵖ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("HS12_1","029_12_1","HOS","12","1","1","“ⵉⴼⵔⴰⵢⵉⵎ ⵉⵜⵜⴻⵏⵏⴻⴹ ⴰⵢⵉ ⵙ ⵓⵅⴰⵔⵔⵉⵇ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵙ ⵍⵖⴻⵛⵛ, ⵎⴰⵛⴰ ⵢⴰⵀⵓⴷⴰ ⵉⵜⵜⴻⵜⵍⵉⵄ ⵄⴰⴷ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⴽ-ⴷ ⵓⵎⵇⴻⴷⴷⴰⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("HS12_2","029_12_2","HOS","12","2","2","ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⵢⵓⵢⵓⵔ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⴻⵎⵎⵉⴹ. ⴰⵙⵙ ⵎⴰⵔⵔⴰ ⵢⴰⵔⴻⵏⵏⵉ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵓⵔⴻⴷⴷⴻⴵ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⴰⵛⵛⵓⵔ ⵓⵛⴰ ⵜⵜⴰⵡⵢⴻⵏ ⵣⵣⴻⵛⵜ ⵖⴰⵔ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("HS12_3","029_12_3","HOS","12","3","3","“ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵙ ⵢⴰⵄⵇⵓⴱ ⵄⵍⴰⵃⵙⴰⴱ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵉⵅⴻⴵⴻⵚ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HS12_4","029_12_4","HOS","12","4","4","ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⵉⵟⵟⴻⴼ ⵓⵎⴰⵙ ⵖⴰⵔ ⵓⵏⵉⵔⵣ ⵓ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴷ ⴰⵔⵢⴰⵣ ⵉⵊⵀⴻⴷ ⵉⵎⵎⵄⴰⵍⴰ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HS12_5","029_12_5","HOS","12","5","5","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽ ⵓⵛⴰ ⵉⵖⵍⴻⴱ. ⵉⵔⵓ, ⵉⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ. ⵢⵓⴼⴰ ⵉ-ⵜ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵓ ⴷⵉⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("HS12_6","029_12_6","HOS","12","6","6","ⵡⴰⵀ, ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵙⵉⴷⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉ ⵍⵉⴷⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HS12_7","029_12_7","HOS","12","7","7","ⴷⵡⴻⵍ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵃⴹⴰ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⵍⵃⴻⵇⵇ, ⵓ ⵙⵉⵜⵉⵎ ⵍⴻⴱⴷⴰ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("HS12_8","029_12_8","HOS","12","8","8","“ⴽⴻⵏⵄⴰⵏ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵍⵎⵉⵣⴰⵏ ⵉⵖⴻⵛⵛ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵙ ⴰⴷ ⵉⴱⴻⵄⵄⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("HS12_9","029_12_9","HOS","12","9","9","ⵎⴰⵛⴰ ⵉⴼⵔⴰⵢⵉⵎ ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵢⴰⵔⵡⴻⵖ ⵉⵛⵜ ⵏ ⵍⴻⴽⵙⵉⴱⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ. ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵓ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⵜⵉⴼⴻⵏ ⵛⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴷⴷⴻⵏⴱ.’” ");
INSERT INTO rift_vpl VALUES ("HS12_10","029_12_10","HOS","12","10","10","“ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⴻⴼⴼⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵊⵊⴻⵖ ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("HS12_11","029_12_11","HOS","12","11","11","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵏⵉⵖ ⵍⴻⵡⵃⵉⵢ ⴰⵟⵟⴰⵙ ⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵍⴻⵎⵜⵓⵍ.” ");
INSERT INTO rift_vpl VALUES ("HS12_12","029_12_12","HOS","12","12","12","“ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵊⵉⵍⵄⴰⴷ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵅⵡⴰⵏ ⵇⴰⵄ ⴷⵉ ⵊⵉⵍⵄⴰⴷ. ⴰⵇⴰ ⵇⴻⴷⴷⵎⴻⵏ ⴷⵉⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵄⵓⵔⵔⵉⵛⴻⵏ ⵏ ⵉⵥⵔⴰ ⴷⵉ ⵍⴻⵅⴹⵓⴹ ⵏ ⵉⵢⵢⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS12_13","029_12_13","HOS","12","13","13","ⵢⴰⵄⵇⵓⴱ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴰⵔⴰⵎ ⵓ ⵉⵙⵔⴰⵉⵍ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵅ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵙ ⵜⴰⵃⵉⵎⴰⵔⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("HS12_14","029_12_14","HOS","12","14","14","ⵎⴰⵛⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⵉⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵢⴰⵔⵡⴻⵙ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("HS12_15","029_12_15","HOS","12","15","15","ⵉⴼⵔⴰⵢⵉⵎ ⵜⵓⵖⴰ ⵉⵙⵄⴰⵔ ⵉ-ⵜ ⴰⵟⵟⴰⵙ. ⵙ ⵓⵢⴰ ⴰⴷ ⵢⴻⵊⵊ ⵙⵉⴷⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵓ ⵙⵉⴷⵉ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵉⵅⴻⴵⴻⵚ ⵍⵃⴻⴳⵔⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("HS13_1","029_13_1","HOS","13","1","1","“ⵓⵎⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵉⴼⵔⴰⵢⵉⵎ, ⴰⵇⴰ ⴷⵉⵏ ⵜⴰⵔⵊⵉⵊⴻⵜ ⵙ ⵓⵡⴻⵇⵇⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⴷⵏⵓⴱ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵄⴱⴻⴷ ⵏⵏⴻⵙ ⵉ ⴱⴰⵄⵍ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("HS13_2","029_13_2","HOS","13","2","2","ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵄⴰⵡⴻⴷ ⴰⵔⵏⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⵏⵓⴱ ⵓ ⴳⴳⵉⵏ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⴰⵇⴰ-ⵜⴻⵏⵜ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵎⴰⵔⵔⴰ, ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⵣⵉⵍ. ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ ⵅⴰⵙⴻⵏ: ‘ⴻⵊⵊ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⴻⵀⵀⴱⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⴰⴷ ⵙⵙⵓⴷⵓⵎⴻⵏ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ-ⴰ!’ ");
INSERT INTO rift_vpl VALUES ("HS13_3","029_13_3","HOS","13","3","3","ⵙ ⵓⵢⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵏ ⵚⵚⴱⴻⵃ ⵓ ⴰⵎ ⵏⵏⴷⴰ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵏⵏⵉ ⴷⴻⵖⵢⴰ ⵉⵄⴻⴷⴷⵓⵏ, ⴰⵎ ⵓⵍⵓⵎ ⵉⵟⵟⴰⵡⴻⵏ ⵣⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ ⵓ ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴱⵓⵔⵊⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("HS13_4","029_13_4","HOS","13","4","4","“ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵙⵏⴻⴷ ⴱⵓ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ ⵎⵖⵉⵔ ⵏⴻⵛⵛ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵎⵖⵉⵔ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("HS13_5","029_13_5","HOS","13","5","5","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵛⴻⴽ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⴻⵃⵎⵓ ⵢⴰⵔⴻⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS13_6","029_13_6","HOS","13","6","6","ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴷⴷⴻⵎⵏⴻⵜ ⵏⵙⴻⵏ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⴷⴻⵡⵍⴻⵏ ⵊⵊⵉⵡⵏⴻⵏ. ⴰⵍⴰⵎⵉ ⵊⵊⵉⵡⵏⴻⵏ, ⵉⵏⵏⵓⵔⴼⴻⵄ ⵡⵓⵍ ⵏⵙⴻⵏ. ⵅ ⵓⵢⴰ ⵜⵜⵓⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("HS13_7","029_13_7","HOS","13","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⵉ ⵏⵉⵜⵏⵉ ⴰⵎ ⵡⴻⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔⴻⵏ, ⴰⵎ ⵓⵖⵉⵍⴰⵙ ⵍⴻⴱⵜⴻⵖ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("HS13_8","029_13_8","HOS","13","8","8","ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴷⴷⵓⴱ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵓⵛⴰⵔⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⵍⵥⴻⵖ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵚⴰⵔⴹⴻⵖ ⵜⴻⵏ ⴷⵉⵏ ⴰⵎ ⵜⵉⵣⴻⵎⵜ. ⵍⴻⵡⵃⵓⵛ ⵏ ⵍⴻⵅⵍⴰ ⵎⴻⵣⵣⵇⴻⵏ ⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS13_9","029_13_9","HOS","13","9","9","“ⵎⴰⵏ ⴰⵢⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⴽⴻⵃⵃⴻⴹ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵜⵄⴻⴽⴽⵙⴻⴷ ⴰⵢⵉ, ⴹⵉⴷⴷ ⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HS13_10","029_13_10","HOS","13","10","10","ⵎⴰⵏⵉ ⵉⴵⴰ ⵅⴻⵏⵏⵉ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵛ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵛ! ⵓ ⵎⴰⵏⵉ ⴵⴰⵏ ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵛ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⴻⵡⵛ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵍⴰ ⴷ ⵍⵃⵓⴽⴽⴰⵎ’? ");
INSERT INTO rift_vpl VALUES ("HS13_11","029_13_11","HOS","13","11","11","ⵙ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵡⵛⵉⵖ ⴰⵛ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵙ ⵓⴷⵓⵇⵇⴻⵣ ⵉⵏⵓ ⵏ ⵓⴼⵓⴳⴻⵎ ⴽⴽⵙⴻⵖ ⴰⵛ ⵜ. ");
INSERT INTO rift_vpl VALUES ("HS13_12","029_13_12","HOS","13","12","12","ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⵜᵉⵜⵜⵡⴰⵇⴻⴱⴱⴻⴹ ⴰⵎ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵇⴻⴱⴱⵉⴹⵟ, ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵃⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS13_13","029_13_13","HOS","13","13","13","ⵍⴻⵃⵔⵉⵇ ⵏ ⵜⴰⵔⵡⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵙ. ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵉⵇⵇⵉⵎ ⴱⵍⴰ ⵜⵉⵖⵉⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴼⴻⵖ ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴰⵔⵣⴻⵎ ⵍⴻⵎⵍⴰⵡⵍⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HS13_14","029_13_14","HOS","13","14","14","“ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⴰⵅⴰⵔⵜ ⴰⴷ ⵜⴻⵏ ⴼⴷⵉⵖ, ⴰⴷ ⵜⴻⵏ ⴼⴻⴽⴽⴻⵖ ⵣⵉ ⵍⵎⴻⵡⵜ. ⴰ ⵍⵎⴻⵡⵜ, ⵎⴰⵏⵉ ⴵⴰⵏ ⵍⴻⵃⵍⴰⵛⴰⵜ ⵏ ⵟⵟⴰⵄⵓⵏ ⵏⵏⴻⵎ, ⴰ ⵍⴰⵅⴰⵔⵜ, ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵓⵔⵚⵓⴹⵉ ⵏⵏⴻⵎ? ⵎⴰ ⴰⴷ ⵏⴻⴷⵎⴻⵖ ⵄⴰⴷ? ⵍⵍⴰ, ⴰⵢⴰ ⵉⵏⵓⴼⴼⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HS13_15","029_13_15","HOS","13","15","15","ⵡⴰⵅⵅⴰ ⴳⴳⵓⵔ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵊⴰⵔ ⴰⵢⵜⵎⴰⵙ, ⵄⴰⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵣⵉ ⵛⵛⴰⵔⵇ, ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉ-ⴷⴷ ⵉ ⵖⴰ ⵉⴽⴽⴰⵔⴻⵏ, - ⵜⴰⵍⴰ ⵏⵏⴻⵙ ⴳⴳⵓⵔ ⴰⴷ ⵜⴰⵥⴻⵖ, ⴰⵏⵓ ⵏⵏⴻⵙ ⴳⴳⵓⵔ ⴰⴷ ⵉⵡⴹⴰ - ⴳⴳⵓⵔ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵓⵙⴻⵎⵎⵉⴹ ⵉⵛⵜ ⵏ ⵜⵅⴰⴱⴻⵛⵜ ⵣⵉ ⵎⴽⵓⵍ ⵍⴻⵇⵛⵓⵄ ⵉⵖⵍⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("HS14_1","029_14_1","HOS","14","1","1","“ⵙⴰⵎⴰⵔⵢⴰ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⴰⵅⴻⴵⴻⵚ, ⵎⵉⵏⵣⵉ ⵜⵖⴻⵡⵡⴻⵖ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴰⴷ ⵜⵜⵡⴰⵛⴰⵔⵔⴳⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("HS14_2","029_14_2","HOS","14","2","2","ⴰ ⵉⵙⵔⴰⵉⵍ, ⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵜⴻⵏⴷⴻⵔⴼⴻⴷ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HS14_3","029_14_3","HOS","14","3","3","ⴽⵙⵉⵎ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏ ⵜⵜⵓⴱⴻⵜ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ. ⵉⵏⵉⵎ ⴰⵙ: ⴽⵙⵉ ⵅⴰⵏⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵎⴰⵔⵔⴰ ⵓ ⵇⴱⴻⵍ ⵣⵣⴰⵢⵏⴻⵖ ⵎⵉⵏ ⵉⵛⵏⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴰⵡⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴰⴹⵃⵉⵢⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⵓⵄⵓⴷ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HS14_4","029_14_4","HOS","14","4","4","ⴰⵛⵛⵓⵔ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏⵊⴰⵎ, ⵡⴰⵔ ⵏⴻⴳⴳⵓⵔ ⵅ ⵢⴻⵢⵙⴰⵏ ⵓ ⵡⴰⵔ ⵏⴻⵇⵇⴰⵔ ⵉ ⵜⵎⴻⴳⴳⴰ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ: ‘ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ’, ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵔⵃⴻⵎ ⵓⵢⵓⵊⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("HS14_5","029_14_5","HOS","14","5","5","“ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵣⵉ ⵜⵖⴻⵏⵏⴰⵏⵜ ⵏⵙⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵜⵜⴻⵅⵙⴻⵖ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⵖⴹⴰⴱ ⵉⵏⵓ ⵉⵃⴻⵢⵢⴻⴷ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("HS14_6","029_14_6","HOS","14","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⵉ ⵉⵙⵔⴰⵉⵍ ⴰⵎ ⵏⵏⴷⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵏⵓⵡⵡⴰⵔ ⴰⵎ ⵜⵏⴻⵡⵡⴰⵛⵜ ⵏ ⵜⴻⵍⵍⵉⵍⵉⵛⵜ, ⴰⴷ ⵉⵡⵡⴻⵜ ⵉⵙⵔⴰⵉⵍ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⴰⵎ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS14_7","029_14_7","HOS","14","7","7","ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⵓⴳⴳⴰⵔⵜⴻⵏ ⵓ ⴰⵡⴻⵇⵇⴰⵔ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵓⵣⴻⵎⵎⵓⵔ ⵓ ⵍⴻⴼⵡⴰⵃ ⵏⵏⴻⵙ ⴰⵎ ⵍⴻⴼⵡⴰⵃ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS14_8","029_14_8","HOS","14","8","8","ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ, ⴰⴷ ⵙⵙⴻⴷⴷⴰⵔⴻⵏ ⵉⵎⴻⵏⴷⵉ, ⴰⴷ ⵏⴻⵡⵡⴰⵔⴻⵏ ⴰⵎ ⵜⵣⴰⵢⴰⵔⵜ. ⵍⵉⴷⴰⵔⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⴰⵅⵎⵉ ⴱⵉⵏⵓ ⵏ ⵍⵓⴱⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HS14_9","029_14_9","HOS","14","9","9","ⴰ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⵉⵏ ⵖⴰⵔⵉ ⵄⴰⴷ ⴰⴽ-ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ?’ ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⴰⵙ ⵓ ⴰⴷ ⵅⴰⵙ ⵙⵙⵉⵊⵊⴻⵖ. ⴰⴷ ⵉⵍⵉⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ ⴰⵣⵉⵣⴰ, ⵣⵣⴰⵢⵉ ⵉ ⵜᵉⵜⵜⵡⴰⴼ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("HS14_10","029_14_10","HOS","14","10","10","“ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷ ⴰⴼⴻⵀⵀⴰⵎ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵜⴻⵏⵜ ⵉⵙⵙⵏⴻⵏ? ⵡⴰⵀ, ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏⵉⵛⴰⵏ ⵉ ⵢⴻⴵⴰⵏ ⵓ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵓⵢⵓⵔⴻⵏ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵄⴻⴷⴷⴰⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵏⵏⴷⴻⵔⴼⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JL1_1","030_1_1","JOL","1","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵢⵓⵡⵉⵍ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵜⵓ’ⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JL1_2","030_1_2","JOL","1","2","2","“ⵙⵍⴻⵎ ⴰⵢⴰ, ⴰ ⵉⵡⴻⵙⵙⵓⵔⴰ, ⵙⵃⴻⵙⵙⴻⵎ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ! ⵎⴰ ⵉⵎⵙⴰⵔ ⵓⵢⴰ ⵄⴻⵎⵎⴰⵔⵚ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JL1_3","030_1_3","JOL","1","3","3","ⵃⴰⵊⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⵅ ⵓⵢⴰ ⵓ ⵊⵊⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜ ⵃⴰⵊⴰⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵉ ⵊⵊⵉⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL1_4","030_1_4","JOL","1","4","4","ⵎⵉⵏ ⵉⵊⵊⴰ ⴱⵓ-ⵡⴻⵇⴹⴻⵄ, ⵜⴻⵛⵛⴰ ⵉ-ⵜ ⵜⵎⵓⵔⵖⵉ, ⵎⵉⵏ ⵜⴻⵊⵊⴰ ⵜⵎⵓⵔⵖⵉ, ⵉⵛⵛⴰ ⵉ-ⵜ ⴱⵓ-ⵡⴻⵍⵙⴰⵃ, ⵎⵉⵏ ⵉⵊⵊⴰ ⴱⵓ-ⵡⴻⵍⵙⴰⵃ, ⵉⵛⵛⴰ ⵉ-ⵜ ⴱⵓ-ⵓⵚⴰⵔⴷ.” ");
INSERT INTO rift_vpl VALUES ("JL1_5","030_1_5","JOL","1","5","5","“ⴼⴰⵇⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵙⴽⴰⵔⵊⵉⵢⵢⴻⵏ, ⵜⵔⵓⵎ, ⵙⵖⵓⵢⵢⴻⵎ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵉⵏⵓ ⵥⴻⵎⵎⴻⵏ ⵜ ⵊⴷⵉⴷ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JL1_6","030_1_6","JOL","1","6","6","ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ. ⵖⴰⵔⴻⵙ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵓ ⵍⵇⴻⴷⴷ ⵏⵏⴻⵙ ⴱⵍⴰ ⵍⴻⵃⵙⴰⴱ. ⵜⵉⵖⵎⴰⵙ ⵏⵏⴻⵙ ⴰⵎ ⵜⴻⵖⵎⴰⵙ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵓ ⵜⵉⵖⵎⴰⵙ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵜⵉⵏⵏⵉ ⵏ ⵜⴻⵢⵔⴰⴷⵜ. ");
INSERT INTO rift_vpl VALUES ("JL1_7","030_1_7","JOL","1","7","7","ⴰⵇⴰ ⵢⴰⵔⵔⴰ ⵜⵣⴰⵢⴰⵔⵜ ⵉⵏⵓ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵓ ⵢⴰⵔⵣⴰ ⵡⴰⵔⵜⵓ ⵉⵏⵓ, ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⵇⴰⵄ ⴷ ⴰⵇⴻⵛⵛⴰⵔ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜ, ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏⵏⴻⵙ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JL1_8","030_1_8","JOL","1","8","8","ⵛⴻⵜⵛⴰⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵜⴻⵏⵏⵉ ⵉⴱⴻⵢⵙⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JL1_9","030_1_9","JOL","1","9","9","ⵜᵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵛⴻⵟⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL1_10","030_1_10","JOL","1","10","10","ⴰⵇⴰ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵢⵉⵢⵢⴰⵔ, ⵜⴻⵛⴹⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵉⵎⴻⵏⴷⵉ ⵉⴹⴻⵢⵢⴻⵄ, ⵢⵓⵥⴻⵖ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ, ⵜⴻⵊⵎⴻⴷ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JL1_11","030_1_11","JOL","1","11","11","ⵙⴻⴹⵃⴰⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴵⴰⵃⴻⵏ, ⵙⵖⵓⵢⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴰⵢⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ, ⵅ ⵢⵉⵔⴷⴻⵏ ⴷ ⵉⵎⴻⵏⴷⵉ, ⵎⴰⵖⴰⵔ ⵚⵚⴰⴱⴻⵜ ⵏ ⵢⵉⵢⵢⴰⵔ ⵜⵡⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JL1_12","030_1_12","JOL","1","12","12","ⵜⴰⵣⴰⵢⴰⵔⵜ ⵜⵓⵥⴻⵖ, ⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵉⵙⵍⴰⵡ, ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴰⵔⴻⵎⵎⴰⵏ, ⵓⵍⴰ ⴷ ⵜⵉⵏⵉ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵜⴻⴼⴼⴰⵃⵜ, ⵡⴰⵀ, ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⵢⵢⴰⵔ ⵙⵍⴰⵡⴻⵏⵜ, ⵄⴰⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵔⵓⵃ.” ");
INSERT INTO rift_vpl VALUES ("JL1_13","030_1_13","JOL","1","13","13","“ⴱⴻⵢⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓ ⵡⵜⴻⵎ ⴰⴳⴻⵊⴷⵓⵔ, ⴽⴻⵏⵏⵉⵡ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ! ⵙⵢⵓⵢⵢⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵙⴻⵎ-ⴷⴷ ⵓ ⵜⴻⵙⵙⴻⵏⵙⴻⵎ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵜⵜⵡⴰⴽⴽⵙⴻⵏⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JL1_14","030_1_14","JOL","1","14","14","ⵄⴻⵍⵎⴻⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ ⵉⵇⴻⴷⴷⴻⵙ, ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ, ⵙⵎⵓⵏⴻⵎ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵓ ⵍⴰⵖⴰⵎ ⵖⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JL1_15","030_1_15","JOL","1","15","15","“ⵡⵉⵀ, ⴰⵙⵙ ⵏⵏⵉ! ⵎⵉⵏⵣⵉ ⵢⵓⴷⴻⵙ-ⴷⴷ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⵓ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵙⵙ ⵏⵏⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵔⴻⴷⴷⴻⴵ ⵏ ⵓⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("JL1_16","030_1_16","JOL","1","16","16","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵎⴰⵛⵛⴰ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ? ⵓⵍⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⴰⵔⵛⵓⵇ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JL1_17","030_1_17","JOL","1","17","17","ⵉⵄⴻⵇⵇⴰⵢⴻⵏ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵓⵥⵖⴻⵏ ⵙⴰⴷⵓ ⵉⴱⵓⵔⵙⴰ, ⵉⵅⵅⴰⵎⴻⵏ ⵏ ⵍⴻⵅⵣⴻⵏ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵍⴻⵀⵔⵉⵜ ⵀⴻⴷⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵎⴻⵏⴷⵉ ⵉⵏⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JL1_18","030_1_18","JOL","1","18","18","ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵎⵓⵀⵔⵓⵜ ⵍⵎⴰⵔ! ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⵇⵇⵉⵎⴻⵏⵜ ⵃⴰⵢⴰⵔ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏⵜ ⴱⵓ ⴷⴷⴻⵎⵏⴻⵜ ⵏ ⵜⴰⵔⴻⵡⵙⴰ! ⵓⵍⴰ ⴷ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵡⵓⴵⵉ ⴼⵏⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JL1_19","030_1_19","JOL","1","19","19","“ⵖⴰⵔⴻⴽ ⵉ ⵜⵜⵍⴰⵖⵉⵖ ⵏⴻⵛⵛ, ⴰ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵛⵛⴰ ⴷⴷⵎⴰⵏⵉ ⵏ ⵍⴻⵅⵍⴰ ⵓ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⵄⵄⴰⵍ ⴰⵇⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵢⵉⵢⵢⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JL1_20","030_1_20","JOL","1","20","20","ⵓⵔⴰ ⴷ ⵍⵎⴰⵍ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵙⴻⴽⴽⵯⴹⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵎⵉⵏⵣⵉ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵓⵥⵖⴻⵏⵜ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵛⵛⴰ ⴷⴷⵎⴰⵏⵉ ⵏ ⵍⴻⵅⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("JL2_1","030_2_1","JOL","2","1","1","“ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵚⵓⴷⴻⵎ ⴷⴰⵢⴻⵙ ⵙ ⵊⵊⴻⵀⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵊⵊⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ, ⵎⴰⵖⴰⵔ ⵢⵓⴷⴻⵙ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵀ, ⴰⵇⴰ-ⵜ ⵢⵓⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JL2_2","030_2_2","JOL","2","2","2","ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵓ ⵏ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ. ⴰⵎ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⵃⴰⵍ ⵉⴳⴳⵓⵔⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵉⵊⵀⴻⴷ! ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⵡⴻⴷ, ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JL2_3","030_2_3","JOL","2","3","3","ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ ⵜᵉⵜⵜⴻⵜⵜ ⵜⵎⴻⵙⵙⵉ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵛⴻⵎⵎⴻⴹ ⵓⵛⴻⵄⵄⴰⵍ. ⵣⵣⴰⵜⴻⵙ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⴳⴳⴰ ⴰⵎ ⵡⴻⵃⵡⵉⵛ ⵏ ⵄⴰⴷⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ. ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JL2_4","030_2_4","JOL","2","4","4","ⵛⵛⵓⴼ ⵏⵙⴻⵏ ⴰⵎ ⵛⵛⵓⴼ ⵏ ⵢⵉⵢⵙⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⴰⵣⵣⵍⴻⵏ ⴰⵎ ⵢⵉⵢⵙⴰⵏ ⵏ ⵜⴰⵣⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JL2_5","030_2_5","JOL","2","5","5","ⴰⵎ ⵓⵇⴰⵔⵇⴻⴱ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵅ ⵜⵇⵉⵛⵛⵉⵜⵉⵏ ⵏ ⵉⴷⵓⵔⴰⵔ, ⴰⵎⵎⵓ ⵏⴻⴳⴳⵣⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵎ ⵍⵃⴻⵙⵙ ⵏ ⵓⵛⴻⵄⵄⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵉⵖⴻⴵ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵉⵙⴻⴷⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JL2_6","030_2_6","JOL","2","6","6","ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵔⵔⴰ ⵉⵖⴻⵎⴱⴰⴱ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JL2_7","030_2_7","JOL","2","7","7","“ⵏⵉⵜⵏⵉ ⵜⵜⴰⵣⵣⵍⴻⵏ ⴰⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⴰⵎ ⵢⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵍⵃⵉⴹ, ⴽⵓⵍ ⵉⵊⵊ ⵉⴳⴳⵓⵔ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵏ ⵛⴰ ⵣⴻⴳ ⵓⵎⴻⵙⵔⵓⵇ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL2_8","030_2_8","JOL","2","8","8","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵄⴰⵔⵔⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴽⵓⵍ ⴱⵓ-ⵟⴻⵖⵍⵓⴹⵜ ⵉⴳⴳⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ, ⵓ ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵡⴹⴰⵏ ⵙ ⵍⴰⵏⵙⴰ, ⵡⴰⵔ ⵜⵜⴻⵎⵙⴱⴻⵄⵄⵉⴷⴻⵏ ");
INSERT INTO rift_vpl VALUES ("JL2_9","030_2_9","JOL","2","9","9","ⵏⵉⵜⵏⵉ ⵡⴻⵟⵟⴰⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⵜⴰⵣⵣⵍⴻⵏ ⵅ ⵍⵃⵉⴹ, ⵜⵜⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⵜⵓⴷⵔⵉⵏ, ⵜⵜⴰⴷⴼⴻⵏ ⵣⵉ ⵍⴻⴽⵡⴰⵣⴰ ⴰⵎ ⵓⵅⴻⵡⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JL2_10","030_2_10","JOL","2","10","10","ⵜᵉⵜⵜⴰⵔⵊⵉⵊⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵉⵊⴻⵏⵡⴰⵏ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ, ⵜⴰⴼⵓⵛⵜ ⴷ ⵜⵣⵉⵔⵉ ⴱⴱⴰⵔⵛⵏⴻⵏⵜ ⵓ ⵉⵜⵔⴰⵏ ⴰⵔⵔⵉⵏ ⵜⴰⴼⴰⵡⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL2_11","030_2_11","JOL","2","11","11","ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⵣⵣⴰⵜ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵙ ⵚⵚⵓⵍⵟⴰ ⵉⵜⵜⴽⴻⵎⵎⴰⵍ ⵏⴻⵜⵜⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⴰⵟⵟⴰⵙ. ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⴽⵙⵉ?” ");
INSERT INTO rift_vpl VALUES ("JL2_12","030_2_12","JOL","2","12","12","“ⵓⵍⴰ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵄⴻⵇⴱⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ, ⵙ ⵓⵥⵓⵎⵎⵉ ⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵓ ⵙ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JL2_13","030_2_13","JOL","2","13","13","ⵛⴰⵔⵔⴳⴻⵎ ⵓⵍ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ, ⵓ ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵃⵏⵉⵏ ⴷ ⴰⵔⵃⵉⵎ ⵓ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⴻⴷⴷⴻⵎ ⵅ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JL2_14","030_2_14","JOL","2","14","14","ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⴰⴷ ⵉⵏⴷⴻⵎ ⵓ ⴰⴷ ⵢⴻⵊⵊ ⵉⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ. ⴰⵡⴰⵔⵏⵉ ⴰⵙ: ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵉⵛⵜ ⵏ ⵜⴻⵡⴱⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JL2_15","030_2_15","JOL","2","15","15","“ⵙⵓⴹⴻⵎ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵚⵉⵀⵢⵓⵏ, ⵇⴻⴷⴷⵙⴻⵎ ⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ, ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⴼⴰⵔⵣ. ");
INSERT INTO rift_vpl VALUES ("JL2_16","030_2_16","JOL","2","16","16","ⵙⵎⵓⵏⴻⵎ ⵍⴳⴻⵏⵙ, ⵇⴻⴷⴷⵙⴻⵎ ⴰⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ, ⵊⴰⵔⵡⴻⵎ ⵉⵎⵖⴰⵔⴻⵏ, ⵙⵎⵓⵏⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵓⵍⴰ ⴷ ⵉⵙⴻⵢⵎⴰⵏ ⵏⵏⵉ ⵄⴰⴷ ⵉⵜⵜⴻⵟⵟⴹⴻⵏ. ⴻⵊⵊ ⵎⵓⵍⴰⵢ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵙ ⵏ ⴷⴰⵅⴻⵍ ⴷ ⵜⴻⵙⵍⵉⵜ ⵣⴻⴳ ⵓⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JL2_17","030_2_17","JOL","2","17","17","ⵊⵊⴻⵎ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵔⵓⵏ ⵊⴰⵔ ⵡⴻⵙⵇⵉⴼ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵊⵊⴻⵎ ⵉ-ⵜⴻⵏ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵙⵄⵉⵣⵣ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ, ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵜⴻⵀⴻⵣⵣⴰⵏ ⵓ ⴰⴷ ⵜⵜ ⴳⴳⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵍⵎⴰⵜⴰⵍ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵇⵇⴰⵔⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ: ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ?’” ");
INSERT INTO rift_vpl VALUES ("JL2_18","030_2_18","JOL","2","18","18","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴻⵎ ⵙⵉⴷⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ ⵓ ⵉⵃⵉⵏⵏ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JL2_19","030_2_19","JOL","2","19","19","ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵉⵎⴻⵏⴷⵉ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵊⵊⴰⵡⵏⴻⵎ, ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⵉⵛⴻⵖ ⵄⴰⴷ ⵉ ⵓⵙⴻⵃⵇⴰⵔ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JL2_20","030_2_20","JOL","2","20","20","ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⴰⴷ ⵜ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵖ ⵅⴰⵡⴻⵎ ⵓ ⴰⴷ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⵓⵥⵖⴻⵏ ⵜᵉⵜⵜⵡⴰⴽⴻⵃⵃⴻⴹ. ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵛⵛⴰⵔⵇ ⵓ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴷⵉ ⵛⵛⴰⵔⵇ. ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵔⵔⵉⵃⴻⵜ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵜⴻⵔⵚⵓⴹⵉ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⴳⴳⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JL2_21","030_2_21","JOL","2","21","21","“ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵙⵍⵉⵡⵍⴻⵡ ⴷ ⵜⴼⴰⵔⵃⴻⴷ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⴳⴳⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JL2_22","030_2_22","JOL","2","22","22","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ, ⴰ ⵍⵎⴰⵍ ⵏ ⵢⵉⵢⵢⴰⵔ, ⵎⴰⵖⴰⵔ ⴷⴷⵎⴰⵏⵉ ⵏ ⵍⴻⵅⵍⴰ ⴰⴷ ⵣⵣⴻⵢⵣⵓⵏ, ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⴰⴷ ⵡⵛⴻⵏⵜ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏⵜ, ⵜⴰⵣⴰⵢⴰⵔⵜ ⴷ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⴰⴷ ⵡⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL2_23","030_2_23","JOL","2","23","23","ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵙⵍⵉⵡⵍⴻⵡⴻⵎ ⵓ ⴼⴰⵔⵃⴻⵎ ⴷⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⵎⵙⴻⵖⵖⴰⵔ ⵏ ⵜⵙⴻⴳⴷⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⵀⵡⴰ ⴰⵏⵥⴰⵔ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⵏⵥⴰⵔ ⵏ ⵍⴻⵅⵔⵉⴼ ⴷ ⵡⴻⵏⵥⴰⵔ ⵏ ⴰⵔⴱⵉⵄ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵢⵉⵎⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("JL2_24","030_2_24","JOL","2","24","24","ⵉⵏⴻⴷⵔⴰⵔ ⴰⴷ ⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵎⴻⵏⴷⵉ ⵓ ⵜⵉⵙⴰⵔⴼⵉⵏ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⵙⵙⴻⴼⵢⴻⵏⵜ ⵙ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JL2_25","030_2_25","JOL","2","25","25","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵅⴻⵍⴼⴻⵖ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉ ⵛⵛⵉⵏⵜ ⵜⵎⵓⵔⵖⵉ - ⴱⵓ-ⵡⴻⵍⵙⴰⵃ ⴷ ⴱⵓ-ⵓⵚⴰⵔⴹ ⴷ ⴱⵓ-ⵡⴻⵇⴹⴻⵄ - ⵍⵄⴻⵙⴽⴰⵔ ⵉⵏⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JL2_26","030_2_26","JOL","2","26","26","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵍ ⵖⴰ ⵜⴼⴻⵢⵢⴹⴻⵎ, ⴰⵍ ⵖⴰ ⵜⴻⵊⵊⴰⵡⵏⴻⵎ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵚⴻⴱⴱⵃⴻⵎ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⴳⴳⵉⵏ ⵍⴻⵄⵊⴻⴱ, ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵙⴻⴹⵃⴰ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JL2_27","030_2_27","JOL","2","27","27","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉ ⴵⵉⵖ ⵓ ⴷ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ ⵓ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵡⴰⵔ ⵉⵜⵜⵙⴻⴹⵃⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JL3_1","030_3_1","JOL","3","1","1","“ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴵⵄⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵅ ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵢⴻⵙⵙⵉⵜⵡⴻⵎ ⴰⴷ ⵏⴻⴱⴱⴰⵏ, ⵉⵡⴻⵙⵙⵓⵔⴰ ⵏⵡⴻⵎ ⴰⴷ ⵓⵔⵊⴰⵏ ⵜⵉⵔⵊⴰ ⵓ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵥⴰⵔⴻⵏ ⵉⵡⴻⵃⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JL3_2","030_3_2","JOL","3","2","2","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴼⴰⵔⵔⵖⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵓⵍⴰ ⵅ ⵉⵙⴻⵎⵖⴰⵏ ⵓ ⵅ ⵜⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JL3_3","030_3_3","JOL","3","3","3","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ: ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵜⵎⴻⵙⵙⵉ ⴷ ⵉⵇⴻⵍⵍⵉⵊⴻⵏ ⵏ ⴷⴷⴻⵅⵅⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JL3_4","030_3_4","JOL","3","4","4","ⵜⴰⴼⵓⵛⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵓ ⵜⴰⵣⵉⵔⵉ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵇⴱⴻⵍ ⵎⴰ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵉⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JL3_5","030_3_5","JOL","3","5","5","ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵍⴰⵖⴰⵏ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⵏⵊⴻⵎ, ⵎⴰⵖⴰⵔ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵢⵉⵍⵉ ⵓⵙⴻⵏⵊⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⵓ ⵖⴰⵔ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵉ ⵅⴻⴼ ⵖⴰ ⵉⵍⴰⵖⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JL4_1","030_4_1","JOL","4","1","1","“ⵎⴰⵖⴰⵔ, ⵅⵣⴰⵔ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵅⵎⵉ ⵖⴰ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JL4_2","030_4_2","JOL","4","2","2","ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵜⴻⵏ ⵏⴻⴷⵀⴻⵖ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ. ⴷⵉⵏⵏⵉ ⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵎⵛⴰⵔⵔⴰⵄⴻⵖ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵣⵓⵣⵣⴰⵔⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷ ⵜⴻⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴱⴹⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JL4_3","030_4_3","JOL","4","3","3","ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⵡⵛⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵃⵔⴰⵎ ⴷ ⵜⵜⴻⵅⵍⵉⵚⴻⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵉⵛⵜ ⵏ ⵜⴻⵃⵔⴰⵎⵜ ⵜⴻⵎⵎⴻⵏⵣ ⵉ ⴱⵉⵏⵓ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL4_4","030_4_4","JOL","4","4","4","ⵓ ⵄⴰⵡⴻⴷ, ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ ⴰⴽⵉⴷⵉ, ⵚⵓⵔ ⴷ ⵚⵉⴷⵓⵏ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴼⵉⵍⵉⵛⵉⵜ. ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⵅⴻⴵⵚⴻⵎ ⵎⵉⵏ ⴳⴳⵉⵖ? ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⵅⴻⴵⵚⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵄⴻⵇⴱⴻⵖ ⴷⴻⵖⵢⴰ ⵓ ⵙ ⵜⴰⵣⵍⴰ ⵎⵉⵏ ⵜⴻⴳⴳⵉⵎ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JL4_5","030_4_5","JOL","4","5","5","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⴽⵙⵉⵎ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉⵏⵓ ⵓ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⵢⴻⵎ ⵍⴻⵇⵛⵓⵄ ⵉⵏⵓ ⵢⵉⵖⵍⴰⵏ ⵖⴰⵔ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JL4_6","030_4_6","JOL","4","6","6","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵣⵣⴻⵏⵣⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵡⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL4_7","030_4_7","JOL","4","7","7","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⴻⵏ ⵜⴻⵣⵣⴻⵏⵣⴻⵎ ⵓ ⴰⴷ ⵙⵙⵄⴻⵇⴱⴻⵖ ⵎⵉⵏ ⵜⴻⴳⴳⵉⵎ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JL4_8","030_4_8","JOL","4","8","8","ⴰⴷ ⵣⵣⴻⵏⵣⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵢⴻⵙⵙⵉⵜⵡⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⵢⵉⵏⴰ ⴰⴷ ⵜⴻⵏ ⵣⵣⴻⵏⵣⴻⵏ ⵉ ⵉⵙⴰⴱⴰ’ⵉⵢⵢⴻⵏ, ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⴳⴳⵯⴻⵊ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("JL4_9","030_4_9","JOL","4","9","9","“ⵍⴰⵖⴰⵎ ⴰⵢⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵇⴻⴷⴷⵙⴻⵎ ⴰⵎⴻⵏⵖⵉ, ⵙⴻⴽⴽⴰⵔⴻⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ, ⵊⵊⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ, ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("JL4_10","030_4_10","JOL","4","10","10","ⵃⴻⴷⴷⴻⵎ ⴷⴷⵓⵣⴰⵏ ⵏⵡⴻⵎ ⴷ ⵍⴻⵙⵢⵓⴼ ⵓⵍⴰ ⴷ ⵍⴻⵎⵡⴰⵙ ⵏⵡⴻⵎ ⵏ ⵡⴻⵣⴱⴰⵔ ⴰⵍ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⴷ ⴼⵍⵉⵜⵛⴰⵜ, ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⴷ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ!’ ");
INSERT INTO rift_vpl VALUES ("JL4_11","030_4_11","JOL","4","11","11","ⴰⵣⵣⵍⴻⵎ ⵓ ⵜⴰⵙⴻⵎ-ⴷⴷ, ⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ⵙⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⴷⵉⵏⵏⵉ, ⴰ ⵙⵉⴷⵉ, ⴰⵢⵜ ⵏⵏⴻⵛ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ! ");
INSERT INTO rift_vpl VALUES ("JL4_12","030_4_12","JOL","4","12","12","ⵊⵊⴻⵎ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ. ⵎⴰⵖⴰⵔ ⴷⵉⵏⵏⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵏⴻⵛⵛ ⵃⵉⵎⴰ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ-ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL4_13","030_4_13","JOL","4","13","13","ⴳⴳⴻⵎ ⴰⵎⵊⴰⵔ ⴷⴰⵢⴻⵙ, ⵎⴰⵖⴰⵔ ⵚⵚⴰⴱⴻⵜ ⵜⴻⵏⵏⴳⵯⴰ, ⴰⵙⴻⵎ-ⴷⴷ, ⵀⵡⴰⵎ, ⵎⵉⵏⵣⵉ ⵜⴰⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⵜⴻⵛⵛⵓⵔ ⵓ ⵚⵚⵡⴰⵔⴻⵊ ⵏ ⵜⵙⵉⵔⵜ ⴼⴻⵢⵢⴹⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵏⵙⴻⵏ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("JL4_14","030_4_14","JOL","4","14","14","“ⵉⴱⴰⵔⵔⵓⵜⴻⵏ, ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⴻⵍⵡⵉⵃⵜ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹⴻⵏ ⵏ ⵓⵙⴰⵔⵡⴻⵜ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⵢⵓⴷⴻⵙ, ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵜⴻⵍⵡⵉⵃⵜ ⵉⵜⵜⴻⵃⵔⵓⴵⵓⴹⴻⵏ ⵉ ⵓⵙⴰⵔⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JL4_15","030_4_15","JOL","4","15","15","ⵜⴰⴼⵓⵛⵜ ⴷ ⵜⵣⵉⵔⵉ ⴱⴱⴰⵔⵛⵏⴻⵏⵜ, ⵉⵜⵔⴰⵏ ⴰⵔⵔⵉⵏ ⵜⴰⴼⴰⵡⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL4_16","030_4_16","JOL","4","16","16","ⵙⵉⴷⵉ ⴰⴷ ⵉⵣⴻⵀⵀⴰⵔ ⵣⵉ ⵚⵉⵀⵢⵓⵏ ⵓ ⴰⴷ ⵢⴰⵔⵔ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍⴰⵎⵉ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴷ ⴰⴷⵓⵔⵔⵉ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⴷ ⵍⴱⵓⵔⵊ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JL4_17","030_4_17","JOL","4","17","17","“ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵚⵉⵀⵢⵓⵏ, ⴰⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵜⵉⵍⵉ ⵜⵇⴻⴷⴷⴻⵙ. ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⵜ ⵛⵓⵇⴻⵏ ⵄⴰⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JL4_18","030_4_18","JOL","4","18","18","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵓⴷⵎⴻⵏ ⵙ ⴱⵉⵏⵓ ⵥⴻⵎⵎⴻⵏ ⵜ ⵊⴷⵉⴷ ⵓ ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵙⵙⴻⴼⵢⴻⵏⵜ ⵙ ⵓⵖⵉ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵡⴰⵎⴰⵏ ⵓ ⵢⵉⵛⵜ ⵏ ⵜⴰⵍⴰ ⴰⴷ ⵜⴻⴷⴷⵓⵇⵇⴻⵣ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵜⴼⴻⵢⵢⴻⴹ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵛⵉⵟⵟⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JL4_19","030_4_19","JOL","4","19","19","ⵎⵉⵚⵔⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵓ ⵉⴷⵓⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵅⵍⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⵓⵏⴼ ⵉ ⴳⴳⵉⵏ ⴹⵉⴷⴷ ⵉ ⴰⵢⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵣⵉ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JL4_20","030_4_20","JOL","4","20","20","ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ ⵓ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵊⵊⵉⵍ ⴰⵍ ⵊⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JL4_21","030_4_21","JOL","4","21","21","ⵏⴻⵛⵛ ⴰⴷ ⵃⴻⵙⴱⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵢⵖⴰ ⵃⴻⵙⵙⴰⴱⴻⵖ ⵡⴰⵔ ⵉⵣⴷⵉⴳⴻⵏ, ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵚⵉⵀⵢⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("AM1_1","031_1_1","AMO","1","1","1","ⴰⵡⴰⵍⴻⵏ ⵏ ⵄⴰⵎⵓⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵊⴰⵔ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵜⴰⵇⵓⵄⴰ, ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵥⵔⴰ ⵅ ⵉⵙⵔⴰⵉⵍ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵡⴰⵛ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵇⴱⴻⵍ ⵉ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AM1_2","031_1_2","AMO","1","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⴰⴷ ⵉⵣⴻⵀⵀⴰⵔ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ ⴰⴷ ⵛⴻⴹⵏⴻⵏⵜ ⵓ ⵜⴰⵇⵉⵛⵛⴻⵜ ⵏ ⴽⴰⵔⵎⵉⵍ ⴰⴷ ⵜⵉⵙⵍⴰⵡ.” ");
INSERT INTO rift_vpl VALUES ("AM1_3","031_1_3","AMO","1","3","3","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⴷⵉⵎⴰⵛⵇ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵡⴰⵜⴻⵏ ⵊⵉⵍⵄⴰⴷ ⵙ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵉⵜⵜⴻⵃⵍⵓⴵⵓⴹⴻⵏ ⵏ ⵡⵓⵣⵣⴰⵍ ⵉ ⵓⵙⴰⵔⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AM1_4","031_1_4","AMO","1","4","4","ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵃⴰⵣⴰⵢⵉⵍ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏ ⴱⵉⵏⵀⴰⴷⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("AM1_5","031_1_5","AMO","1","5","5","ⴰⴷ ⴰⵔⵥⴻⵖ ⵣⵣⴻⴽⵔⵓⵏ ⵏ ⴷⵉⵎⴰⵛⵇ ⵓ ⴰⴷ ⵎⵃⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵣⵉ ⴱⵓⵇⵄⴰ-ⴰⵡⴰⵏ, ⵣⵉ ⵍⴻⵡⴹⴰ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ, ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⴻⵥⵔⵉ ⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⴰⵣⴻⴵⴰⴹ, ⵓ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴰⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵖⴰⵔ ⵇⵉⵔ!, ⵉⵏⵏⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM1_6","031_1_6","AMO","1","6","6","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⵖⴰⵣⵣⴰ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵇⴰⵄ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵉⴷⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("AM1_7","031_1_7","AMO","1","7","7","ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⴰⵅⴻⵍ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⵖⴰⵣⵣⴰ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM1_8","031_1_8","AMO","1","8","8","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⴰⵎⴻⵣⴷⵓⵖ ⵣⵉ ⴰⵛⴷⵓⴷ ⵓ ⵣⵉ ⴰⵛⵇⴰⵍⵓⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⴰⵣⴻⴵⴰⴹ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⵙⵉⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵄⴰⵇⵔⵓⵏ ⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM1_9","031_1_9","AMO","1","9","9","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⵚⵓⵔ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⴻⵍⵍⵎⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵇⴰⵄ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⵉ ⵉⴷⵓⵎ, ⵡⴰⵔ ⵉⴷⴰⵔⴻⵏ ⵍⵄⴰⵀⴷ ⴰⴽ-ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM1_10","031_1_10","AMO","1","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⴰⵅⴻⵍ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⵚⵓⵔ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AM1_11","031_1_11","AMO","1","11","11","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⵉⴷⵓⵎ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴹⴼⴰⵔ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵙ ⵙ ⵙⵙⵉⴼ ⵓ ⵉⵙⵙⵄⵉⴵⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ, ⵓ ⵎⵉⵏⵣⵉ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵉⵛⴰⵔⵔⴻⴳ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵓ ⵎⵉⵏⵣⵉ ⴰⵀⴻⴷⴷⵉ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵙ ⵏ ⵓⴼⵓⴳⴻⵎ ⵉⵇⵇⵉⵎ ⵉⵙⵙⴰⴳⴳⵡⴰⴷ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("AM1_12","031_1_12","AMO","1","12","12","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵜⴰⵢⵎⴰⵏ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏ ⴱⵓⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("AM1_13","031_1_13","AMO","1","13","13","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⵉⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵛⴰⵔⵔⴳⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⵣⵉ ⵊⵉⵍⵄⴰⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵡⴻⵙⵙⵄⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM1_14","031_1_14","AMO","1","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴰⵔⵖⴻⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⴰⵅⴻⵍ ⵉ ⵍⴻⵃⵢⵓⴹ ⵏ ⵔⴰⴱⴱⴰ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ, ⵖⴰⵔ ⵉⵖⵓⵢⵢⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴰⵎ ⵉⵙⵓⴹ ⵓⵙⴻⵎⵎⵉⴹ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("AM1_15","031_1_15","AMO","1","15","15","ⴰⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM2_1","031_2_1","AMO","2","1","1","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⵎⵓ’ⴰⴱ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵉⵢⵙⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏ ⵉⴷⵓⵎ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵊⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("AM2_2","031_2_2","AMO","2","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵎⵓ’ⴰⴱ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏ ⵇⴰⵔⵢⵓⵜ. ⵎⵓ’ⴰⴱ ⴰⴷ ⵉⵎⵎⴻⵜ ⵖⴰⵔ ⴷⴷⵔⵉⵣ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵖⴰⵔ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵓ ⵖⴰⵔ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("AM2_3","031_2_3","AMO","2","3","3","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵍⵇⴰⴹⵉ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵏⵖⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM2_4","031_2_4","AMO","2","4","4","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⵢⴰⵀⵓⴷⴰ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵇⴱⵉⵍⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⵎⵉⵏⵣⵉ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵙⴻⵏ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵏⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⴰⵔⵔⵉⵏ ⵜⴻⵏ ⵡⴻⴷⴷⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AM2_5","031_2_5","AMO","2","5","5","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⴰⴷ ⵜⴻⵛⵛ ⵍⴻⵇⵚⵓⵔ ⵏ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("AM2_6","031_2_6","AMO","2","6","6","“ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵉ ⵉⴳⴳⴰ ⵉⵙⵔⴰ’ⵉⵍ, ⵄⴰⴷ ⵎⴰⵀⵓ ⵅ ⴰⵔⴻⴱⵄⴰ, ⵡⴰⵔ ⵜ ⵙⵙⴱⴻⵟⵟⴰⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵣⵣⴻⵏⵣⴻⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵙ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⴰⵎⴻⵣⵍⵓⴹ ⵉ ⵜⵢⵓⵢⴰ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("AM2_7","031_2_7","AMO","2","7","7","ⵏⵉⵜⵏⵉ ⵜⴻⵛⴹⵉⴹⵉⵃⴻⵏ ⵖⴰⵔ ⵜⵄⴻⵊⵊⴰⵊⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⴱⴻⵍⵍⴰⵄⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵉⵎⵡⴰⴹⵄⴻⵏ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ. ⴰⵔⵢⴰⵣ ⴷ ⴱⴰⴱⴰⵙ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵃⵔⴰⵎⵜ ⴷ ⵉⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴻⴹⵃⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM2_8","031_2_8","AMO","2","8","8","ⵏⵉⵜⵏⵉ ⵙⵙⵡⴰⵥⵥⴰⴹⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵎⴽⵓⵍ ⴰⵄⴰⵍⵟⴰⵔ ⵅ ⵡⴰⵔⵔⵓⴹ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵔⴻⵀⵏⴻⵏ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ ⵙⵙⴰⵖⴻⵏ ⵜ ⵙ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵅ ⵉⵜⵜⵡⴰⴳⴳ ⵎⵓⵍⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("AM2_9","031_2_9","AMO","2","9","9","ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴻⵃⵃⵉⵖ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵄⵍⴰⵏ ⴰⵎ ⵜⵏⴻⴳⵍⵉⵏ ⵢⵓⵄⵍⴰⵏ ⵓ ⵊⴻⵀⵀⴷⴻⵏ ⴰⵎ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⴱⴻⴵⵓⴹ. ⵏⴻⵛⵛ ⵜⴻⵃⵃⵉⵖ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⵓ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵙ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("AM2_10","031_2_10","AMO","2","10","10","ⴷ ⵏⴻⵛⵛ ⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⴰⵔⵔⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵢⵓⵔⴻⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵎⵓⵔⵉⵢⵢⴻⵏ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AM2_11","031_2_11","AMO","2","11","11","ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴰⵔⵔⵉⵖ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵣⴻⴳ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⴰⵔⵔⵉⵖ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵍⵡⴰⵄⴷ. ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ?!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM2_12","031_2_12","AMO","2","12","12","ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵜⴰⵔⵔⵉⵎ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵜⵜⴰⵊ ⵏ ⵡⴻⵄⵣⴰⵍ ⴰⴷ ⵙⵡⴻⵏ ⴱⵉⵏⵓ ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⵡⴻⵚⵚⴰⵎ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⴰⵎ: ‘ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵏⴻⴱⴱⴰⵎ!’ ");
INSERT INTO rift_vpl VALUES ("AM2_13","031_2_13","AMO","2","13","13","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵄⴻⴱⴱⵣⴻⵖ ⵙⵡⴰⴷⴷⴰⵢ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴽⴰⵔⵔⵓⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⵜⵄⴻⴱⴱⴻⵣ ⵜⵉⵊⴰⵔⵔⴰⵔⵉⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("AM2_14","031_2_14","AMO","2","14","14","ⴰⵇⴰ ⵚⴰⴼⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⴼⵙⵓⵙⴻⵏ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵃⴹⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵓ ⴱⵓ-ⵜⴻⵖⵍⵓⴹⵜ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM2_15","031_2_15","AMO","2","15","15","ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⴷⵉ ⵍⵇⴻⵡⵙ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⴱⴻⴷⴷ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⵜⴰⵣⵍⴰ, ⵡⴰⵔ ⵉⵏⴻⵊⵊⴻⵎ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⴰⵢⵉⵙ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM2_16","031_2_16","AMO","2","16","16","ⵡⴻⵏⵏⵉ ⵉⵣⴻⵄⵄⵎⴻⵏ ⵇⴰⵄ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM3_1","031_3_1","AMO","3","1","1","“ⵙⵍⴻⵎ ⴰⵡⴰⵍ-ⴰ ⵉ ⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴽ-ⴷ ⴽⵓⵍ ⵍⴰⴵ ⵏⵏⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵏⴻⵛⵛ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⴰⵎ ⵇⵇⴰⵔⴻⵖ: ");
INSERT INTO rift_vpl VALUES ("AM3_2","031_3_2","AMO","3","2","2","‘ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵙⵙⵏⴻⵖ ⵎⵖⵉⵔ ⴽⴻⵏⵏⵉⵡ. ⵅ ⵓⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵇⴱⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴰⵜ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("AM3_3","031_3_3","AMO","3","3","3","ⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵜⵏⴰⵢⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⴱⵍⴰ ⵎⴰ ⵜⵜⴰⴼⵇⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("AM3_4","031_3_4","AMO","3","4","4","ⵎⴰ ⴰⴷ ⵉⵣⴻⵀⵀⴰⵔ ⵡⴰⵢⵔⴰⴷ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ ⵍⴰⵎⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵣⵣⴰⵔⴷⴻⵜ? ⵎⴰ ⴰⵢⵔⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴰⴷ ⵢⴻⵊⵊ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵣⴻⴳ ⵢⴻⴼⵔⵉ, ⴰⵎ ⵡⴰⵔ ⵉⵎⵏⵉⵄ ⵡⴰⵍⵓ? ");
INSERT INTO rift_vpl VALUES ("AM3_5","031_3_5","AMO","3","5","5","ⵎⴰ ⴰⴷ ⵉⵏⴹⴰⵔ ⵡⴻⵊⴹⵉⴹ ⴷⵉ ⵍⴼⴻⵅ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⴷⴰⵢⴻⵙ ⵎⴰⵛⵛⴰ ⵉ ⵏⴻⵜⵜⴰ? ⵎⴰ ⴰⴷ ⵉⵏⵏⵓⵔⴼⴻⵄ ⵍⴼⴻⵅ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵍⴰ ⵜⴻⵅⵡⴰ? ");
INSERT INTO rift_vpl VALUES ("AM3_6","031_3_6","AMO","3","6","6","ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ ⵍⴳⴻⵏⵙ? ⵎⴰⵍⴰ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵓⵛⴻⵍⵡⴰⵡ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰ ⵡⴰⵔ ⵜⵜ ⵉⴳⴳⵉ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("AM3_7","031_3_7","AMO","3","7","7","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⴻⵜ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵙ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM3_8","031_3_8","AMO","3","8","8","ⴰⵢⵔⴰⴷ ⵉⵣⴻⵀⵀⴰⵔ, ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴷⴻⵏ? ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ, ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵏⴻⴱⴱⴰ?’” ");
INSERT INTO rift_vpl VALUES ("AM3_9","031_3_9","AMO","3","9","9","“ⵊⵊⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⴰⵢⴰ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⴷⵉ ⴰⵛⴷⵓⴷ ⵓ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵉⵏⵉ: ‘ⵎⵓⵏⴻⵎ ⵅ ⵉⴷⵓⵔⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⵅⵣⴰⵔⴻⵎ ⴰⵏⴻⵀⵡⴻⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⵓ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("AM3_10","031_3_10","AMO","3","10","10","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⵉⵜⵏⵉ ⵉⵏⵏⵉ ⵉⵢⴰⵔⵔⵡⴻⵏ ⵍⵄⵓⵏⴼ ⴷ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AM3_11","031_3_11","AMO","3","11","11","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ‘ⵉⵊⵊ ⵏ ⵍⴻⵄⴷⵓ! ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ! ⴰⴷ ⵉⵙⵙⴻⵀⵡⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵎ ⵣⵣⴰⵢⴻⵎ ⵓ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵎ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AM3_12","031_3_12","AMO","3","12","12","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⵎ ⵉⴼⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵢⵉⵅⴻⴼ ⵏ ⵓⵎⴻⵣⵣⵓⵖ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴰⵢⵔⴰⴷ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵜⵜⵖⵉⵎⴰⵏ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵅ ⵜⵎⴰ ⵏ ⵇⴰⵎⴰ ⵓ ⵅ ⵢⵉⵛⵜ ⵏ ⵜⵣⴻⵔⴱⵉⵢⵢⴻⵜ ⵣⵉ ⴷⵉⵎⴰⵛⵇ ⴳⴳⵉⵏ ⵜⵜ ⵅ ⵢⵉⵛⵜ ⵏ ⵍⴻⵎⵟⴰⵔⴱⴻⵜ.’” ");
INSERT INTO rift_vpl VALUES ("AM3_13","031_3_13","AMO","3","13","13","“ⵙⵍⴻⵎ ⵓ ⵛⴻⵀⴷⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("AM3_14","031_3_14","AMO","3","14","14","ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵅⴻⵍⴼⴻⵖ ⵉⵅⴻⵟⵟⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵄⴰⵡⴻⴷ ⴰⵅⴻⴵⴻⵚ ⵅ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵉⵍ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⴷ ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AM3_15","031_3_15","AMO","3","15","15","ⵏⴻⵛⵛ ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵜⴳⴰⵔⵙⵜ ⴷ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵓⵏⴻⴱⴷⵓ ⵓ ⵜⵓⴷⵔⵉⵏ ⵏ ⵍⵄⴰⵊ ⴰⴷ ⵜⵜⵡⴰⵇⴹⴰⵏⵜ, ⵓ ⴰⵟⵟⴰⵙ ⵏ ⵜⵓⴷⵔⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴵⴻⵏⵜ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM4_1","031_4_1","AMO","4","1","1","“ⵙⵍⴻⵏⵜ, ⴰⵡⴰⵍ-ⴰ, ⴰ ⵜⵉⴼⵓⵏⴰⵙⵉⵏ ⵏ ⴱⴰⵛⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⵜⵉⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵉⵎⴻⵣⵍⴰⴹ, ⵜⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏⵙⴻⵏ: ‘ⴰⵡⵢⴻⵎ-ⴷⴷ ⵛⴰ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵏⴻⵙⵙⵓ!’ ");
INSERT INTO rift_vpl VALUES ("AM4_2","031_4_2","AMO","4","2","2","ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉⵊⵊⵓⴵ ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴰⴷ ⵅⴰⴽⴻⵏⵜ ⴷⴷ-ⴽⴽⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⴷ ⴽⴻⵏⵏⵉⵏⵜ ⴽⴽⵙⴻⵏ ⵙ ⵉⵖⴰⵏⵜⵛⵓⵜⴻⵏ ⵓ ⵎⵉⵏ ⵣⵣⴰⵢⴽⴻⵏⵜ ⵉⵇⵇⵉⵎⴻⵏ ⵙ ⵜⵚⴻⵏⵏⴰⵔⵉⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AM4_3","031_4_3","AMO","4","3","3","ⴽⴻⵏⵏⵉⵏⵜ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵏⵜ ⵣⵉ ⵜⵉⵣⵣⴻⵢⵢⵉⵏ ⵏ ⵍⴻⵃⵢⵓⴹ, ⴽⵓⵍ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ. ⴽⴻⵏⵏⵉⵏⵜ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏⵜ ⵖⴰⵔ ⵀⴰⵔⵎⵓⵏ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM4_4","031_4_4","AMO","4","4","4","ⵉⵡⴰ, ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵉⵍ ⵓ ⵄⴻⴷⴷⴰⵎ, ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ ⵓ ⴰⵔⵏⵉⵎ ⴷⴻⴳ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ. ⵉⵡⴰ, ⴰⵡⵢⴻⵎ-ⴷⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⴽⵓⵍ ⵚⵚⴱⴻⵃ ⴷ ⵍⴻⵄⵛⵓⵔ ⵏⵡⴻⵎ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("AM4_5","031_4_5","AMO","4","5","5","ⵉⵡⴰ, ⵙⴱⴻⵅⵅⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵇⴰⴷⵉ ⵙ ⵡⴻⵖⵔⵓⵎ ⴰⴽ-ⴷ ⵡⴻⵏⵜⵓⵏ ⵓ ⵍⴰⵖⴰⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵙ ⵍⵅⴰⴹⴰⵔ, ⴱⴰⵔⵔⵃⴻⵎ ⵣⵣⴰⵢⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⴻⵄⵊⵉⴱ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM4_6","031_4_6","AMO","4","6","6","“ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⵊⵊⵉⵖ ⴰⵡⴻⵎ ⵜⴰⵣⴷⵓⴳⵉ ⵏ ⵜⴻⵖⵎⴰⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵡⴻⵎ ⵓ ⵜⵓⵇⵍⵉⵍⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵏⵡⴻⵎ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ. ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍⴻⵎ ⵖⴰⵔⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM4_7","031_4_7","AMO","4","7","7","ⵏⴻⵛⵛ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵅⴰⵡⴻⵎ ⴰⵏⵥⴰⵔ ⵓⵎⵉ ⴷⵉⵏ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴰⵍ ⵜⵎⴻⵢⵔⴰ ⵓ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴰⴷ ⵉⵡⵡⴻⵜ ⵡⴻⵏⵥⴰⵔ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⴰⵛⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⴳⴳⵉⵖ ⴰⴷ ⵉⵡⵡⴻⵜ ⵡⴻⵏⵥⴰⵔ. ⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵡⴻⵏⵥⴰⵔ ⵓ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵉ ⵅ ⵡⴰⵔ ⵉⵡⵜⵉ ⵡⴻⵏⵥⴰⵔ, ⵉⵏⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AM4_8","031_4_8","AMO","4","8","8","ⵜⵏⴰⵢⴻⵏ, ⵜⵍⴰⵜⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⵓⵢⵓⵔⴻⵏⵜ ⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏⵜ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵡⴻⵏⵜ ⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⵊⵊⵉⵡⵏⴻⵏⵜ ⵛⴰ. ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍⴻⵎ ⵖⴰⵔⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM4_9","031_4_9","AMO","4","9","9","ⵏⴻⵛⵛ ⵡⵜⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵎⴻⵏⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵙ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵡⴻⴼⵙⵓ. ⴰⵟⵟⴰⵙ ⵏ ⵉⵃⵡⵉⵛⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏⵡⴻⵎ ⵏ ⵓⴹⵉⵍ ⴷ ⵡⵓⵔⵜⴰⵏ ⵏⵡⴻⵎ ⴷ ⵜⵣⵉⵜⵓⵏⵉⵏ ⵏⵡⴻⵎ ⴰⵇⴰ ⵉⵛⵛⴰ ⵉ-ⵜⴻⵏ ⴱⵓ-ⵡⴻⵇⴹⴻⵄ. ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍⴻⵎ ⵖⴰⵔⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM4_10","031_4_10","AMO","4","10","10","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵟⵟⴰⵄⵓⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ ⴷⵉ ⵎⵉⵚⵔⴰ. ⵏⴻⵛⵛ ⵏⵖⵉⵖ ⵉⵃⵓⴷⵔⵉⵢⴻⵏ ⵏⵡⴻⵎ ⵙ ⵙⵙⵉⴼ, ⵉⵢⵙⴰⵏ ⵏⵡⴻⵎ ⵏⴻⴷⵀⴻⵖ ⵜⴻⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵟ ⵓ ⴰⵔⵔⵉⵖ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵍ ⵡⴻⵏⵣⴰⵔⴻⵏ ⵏⵡⴻⵎ. ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍⴻⵎ ⵖⴰⵔⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM4_11","031_4_11","AMO","4","11","11","ⵏⴻⵛⵛ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵙⵙⵏⴻⵇⵍⴰⴱ ⴰⵔⴻⴱⴱⵉ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ. ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏ ⵣⴻⴳ ⵓⵃⴰⴷⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ. ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ-ⵜⴻⴷⵡⵉⵍⴻⵎ ⵖⴰⵔⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM4_12","031_4_12","AMO","4","12","12","ⵙ ⵓⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⴰⵢⴰ, ⴰ ⵉⵙⵔⴰⵉⵍ! ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ, ⵃⴻⵣⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵎⵎⴻⵍⵇⵉⴷ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("AM4_13","031_4_13","AMO","4","13","13","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵉⴽⴻⵡⵡⵏⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⵉⵜⵜⴻⵊⵊⴰ-ⴷⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵓ ⵉⵙⵙⵛⴰⵏ ⵎⵉⵏ ⴷⵉ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⵃⴰⵍ ⴷ ⵜⴰⴵⴻⵙⵜ ⵓ ⵉⴳⴳⵓⵔ ⵜⵉⵡⴰ ⵉ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ: ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AM5_1","031_5_1","AMO","5","1","1","“ⵙⵍⴻⵎ ⴰⵡⴰⵍ-ⴰ ⵉ ⵅⴰⵡⴻⵎ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ, ⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵓⴳⴻⵊⴷⵓⵔ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AM5_2","031_5_2","AMO","5","2","2","“ⴰⵇⴰ ⵜⴻⵡⴹⴰ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵉⵙⵔⴰⵉⵍ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⴽⴽⴰⵔ ⵄⴰⴷ. ⵏⴻⵜⵜⴰⵜ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⵜⵜ ⵖⴰ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AM5_3","031_5_3","AMO","5","3","3","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵙ ⵡⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⴷ ⴰⵙ ⵜⵛⴻⵟⵟ ⵎⵢⴰ, ⵓ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵙ ⵎⵢⴰ, ⴰⴷ ⴰⵙ ⵜⵛⴻⵟⵟ ⵄⴻⵛⵔⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AM5_4","031_5_4","AMO","5","4","4","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ⴰⵔⵣⵓⵎ ⵅⴰⴼⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("AM5_5","031_5_5","AMO","5","5","5","ⵡⴰⵔ ⵜⴰⵔⴻⵣⵣⴼⴻⵎ ⴱⴰⵢⵜ-ⵉⵍ, ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙⴻⵎ ⵖⴰⵔ ⵊⵉⵍⵊⴰⵍ ⵓ ⵡⴰⵔ ⵄⴻⴷⴷⵓⵎ ⵅ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ, ⵎⵉⵏⵣⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⵊⵉⵍⵊⴰⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵓ ⴱⴰⵢⵜ-ⵉⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴻⵟⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("AM5_6","031_5_6","AMO","5","6","6","ⴰⵔⵣⵓⵎ ⵅ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵉⴷⵉⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵅⵙⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴱⴰⵢⵜ-ⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("AM5_7","031_5_7","AMO","5","7","7","“ⴰⵅⴻⵢⵢⴻⴱ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵍⵃⴻⵇⵇ ⵖⴰⵔ ⵛⵛⵉⵃ ⵓ ⵉⵏⵏⵉ ⵉⵙⵙⵀⴻⴽⴽⵯⴰⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AM5_8","031_5_8","AMO","5","8","8","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⴱⵍⵉⵢⴰⴷⴻⵏ ⴷ ⵓⵔⵉⵢⵓⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ ⴷ ⵜⵓⴼⴼⵓⵜ ⵏ ⵍⵃⴰⵍ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵉ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓ ⵉⴼⴰⵔⵔⴻⵖ ⵉ-ⵜⴻⵏ ⵜⵉⵡⴰ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ!, ");
INSERT INTO rift_vpl VALUES ("AM5_9","031_5_9","AMO","5","9","9","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴰⵔⴻⴷⴷⴻⴵ ⴰⵎ ⵡⴰⵙⵙⴰⵎ ⵅ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵓ ⴰⵇⴰ ⵢⴰⵔⵔⴰ ⴰⵔⴻⴷⴷⴻⴵ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅ ⵍⵇⴻⵍⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("AM5_10","031_5_10","AMO","5","10","10","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵛⴰⵔⵔⵀⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⴼⴰⵄⴻⵏ ⵅ ⵍⵃⴻⵇⵇ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⵄⵉⴼⴼⴰⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AM5_11","031_5_11","AMO","5","11","11","ⵙ ⵓⵢⴰ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⴼⴼⵙⴻⵎ ⵅ ⵓⵎⵓⵇⵍⵉⵍ ⵓ ⵜᵉⵜⵜⴽⴻⵙⵙⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵄⵛⵓⵔ ⵏ ⵉⵎⴻⵏⴷⵉ: ⵡⴰⵅⵅⴰ ⵜⴻⴱⵏⴰⵎ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ ⵙ ⵡⴻⵥⵔⵓ ⵢⵓⵢⴷⴰⵏ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵣⴻⴷⴷⵖⴻⵎ, ⵡⴰⵅⵅⴰ ⵜⴻⵥⵥⵓⵎ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵛⵏⴰⵏⵜ ⴷⴻⴳ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜⵙⴻⵙⵙⴻⵎ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("AM5_12","031_5_12","AMO","5","12","12","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ ⵓ ⴰⵇⴰ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵙⵙⴻⴳⴳⵯⴰⴷⴻⵏ: ⵏⵉⵜⵏⵉ ⵃⴻⵚⵚⴰⵔⴻⵏ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵜⵜᵉⵟⵟⴼⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵍⵖⴻⵛⵛ ⵓ ⵄⴰⵔⵔⵏⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AM5_13","031_5_13","AMO","5","13","13","ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵙⵙⴻⵖⴷ ⵓⵎⵉⵖⵉⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("AM5_14","031_5_14","AMO","5","14","14","“ⴰⵔⵣⵓⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵢⵉⵍⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("AM5_15","031_5_15","AMO","5","15","15","ⵛⴰⵔⵀⴻⵎ ⵎⵉⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵜⴻⵅⵙⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⵙⵎⴻⵜⵏⴻⵎ ⵍⵃⴻⵇⵇ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⵃⵉⵏⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵅ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵢⵓⵙⵓⴼ.” ");
INSERT INTO rift_vpl VALUES ("AM5_16","031_5_16","AMO","5","16","16","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵙⵉⴷⵉ ⵉⵏⵓ: ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵣⵣⴰⵢⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵣⵣⵏⴰⵇⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⵢⵢⴰⵡ! ⴰⵢⵢⴰⵡ!’, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵍⴰⵖⴰⵏ ⵅ ⵓⴼⴻⴵⴰⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵛⴹⴻⵏ, ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵉⵣⵍⴰⵏ ⵏ ⵡⴻⵛⴹⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵙ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AM5_17","031_5_17","AMO","5","17","17","ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵛⵓⵇⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM5_18","031_5_18","AMO","5","18","18","“ⴰⵢⵢⴰⵡ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵎⴻⵥⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉ! ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉ? ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⵜⴰⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("AM5_19","031_5_19","AMO","5","19","19","ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵛⴰ ⵏ ⵉⵊⵊ ⵉ ⵢⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵡⴰⵢⵔⴰⴷ, ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴷⴷⵓⴱ, ⵏⵉⵖ ⴰⵎ ⵛⴰ ⵏ ⵉⵊⵊ ⵉ ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵄⴻⵎⵎⴻⴷ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵍⵃⵉⴹ, ⵅⴻⵏⵏⵉ ⵉⵣⵄⴻⴼ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵓⴼⵉⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AM5_20","031_5_20","AMO","5","20","20","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⴵⴻⵙⵜ ⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⵜⴼⴰⵡⵜ? ⴷ ⵟⵟⵍⴰⵎ ⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⵜⴼⴰⵡⵜ!” ");
INSERT INTO rift_vpl VALUES ("AM5_21","031_5_21","AMO","5","21","21","“ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ, ⵄⵉⴼⴼⴻⵖ ⵓⵔⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵓ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵛⴻⵎⵎⴻⵖ ⵉⵎⵓⵏⵉⵜⴻⵏ ⵏⵡⴻⵎ ⵉⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM5_22","031_5_22","AMO","5","22","22","ⵎⴰⵖⴰⵔ ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⵢⴻⵎ ⴰⵢⵉ-ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏⵡⴻⵎ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵡⴻⵎ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⴰⵔⴻⵟⵟⵉⵖ ⵛⴰ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔⴻⵖ ⵡⴰⵍⵓ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⵀⵏⴰ ⵏ ⵍⵎⴰⵍ ⵉⵚⴻⵃⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM5_23","031_5_23","AMO","5","23","23","ⵙⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⴷⴷⵔⵉⵣ ⵏ ⵉⵣⵍⴰⵏ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵙⵍⴻⵖ ⵍⵃⴻⵙⵙ ⵏ ⵍⵀⴰⵔⴱⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("AM5_24","031_5_24","AMO","5","24","24","ⴻⵊⵊ ⵍⵃⵓⴽⵎ ⴰⴷ ⵢⴰⵣⵣⴻⵍ ⴰⵎ ⵡⴰⵎⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵓ ⵜⴰⵙⴻⴳⴷⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵉⵖⵣⴰⵔ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("AM5_25","031_5_25","AMO","5","25","25","“ⵎⴰ ⵜⵉⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("AM5_26","031_5_26","AMO","5","26","26","ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴱⵓⵎ ⵉⵇⵉⴹⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ ⴷ ⵓⴹⴰⵔ ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜⵜⴱⴻⴷⴷⴰⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵡⴻⵎ ⵉ ⵢⴻⵜⵔⵉ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⵜⴻⴳⴳⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("AM5_27","031_5_27","AMO","5","27","27","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴻⴷⵀⴻⵖ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ, ⴰⵖⵉⵔⵉⵏ ⵉ ⴷⵉⵎⴰⵛⵇ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵇⴰ ⴷ ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AM6_1","031_6_1","AMO","6","1","1","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⴷⵉ ⵢⴻⴵⵉ ⴱⵓ ⵡⴻⵎⵏⵓⵙ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵜᵉⵜⵜⴰⵙ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AM6_2","031_6_2","AMO","6","2","2","ⵄⴷⵓⵎ ⵖⴰⵔ ⴽⴰⵍⵏⴰ ⵓ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ! ⵓⵢⵓⵔⴻⵎ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵃⴰⵎⴰⵜ ⵓ ⵀⵡⴰⵎ-ⴷⴷ ⵖⴰⵔ ⵊⴰⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ⵎⴰ ⵏⵉⵜⵏⵉ ⵃⵙⴻⵏ ⵣⵉ ⵜⴳⴻⵍⴷⴰⵡⵉⵏ-ⴰ ⵏⵉⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("AM6_3","031_6_3","AMO","6","3","3","ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵙⵙⴱⴻⵄⵄⴷⴻⵏ ⴰⵙⵙ ⴰⵄⴻⴼⴼⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵜⴻⵙⵙⵇⴰⵔⵔⴰⴱⴻⵎ ⵍⴽⵓⵍⵙⵉ ⵏ ⵍⵄⵓⵏⴼ, ");
INSERT INTO rift_vpl VALUES ("AM6_4","031_6_4","AMO","6","4","4","ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵜⵜⴻⵣⵣⵍⴻⵏ ⵅ ⵇⴰⵎⴰⵜ ⵏ ⵍⵄⴰⵊ ⵓⵛⴰ ⵜⵜⴻⵙⵟⵉⵍⴻⵏ ⵅ ⵍⴻⵎⵟⴰⵔⴱⴰⵜ ⵏⵡⴻⵎ ⵓ ⵜⵜᵉⵜⵜⴻⵏ ⵉⵣⵎⴰⵔⴻⵏ ⵏ ⵡⵓⴵⵉ ⵓⵍⴰ ⴷ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴽⵓⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("AM6_5","031_6_5","AMO","6","5","5","ⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵖⴻⵏⵏⵊⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ ⵖⴰⵔ ⴵⵖⴰ ⵏ ⵍⵀⴰⵔⴱⴰ, ⴰⵎ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵏ ⵉⵣⵍⴰⵏ ⵙ ⴷⴷⵓⵣⴰⵏ ⵏ ⵍⵎⵓⵙⵉⵇⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("AM6_6","031_6_6","AMO","6","6","6","ⵉⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⴱⵉⵏⵓ ⵣⵉ ⵟⵟⴰⵡⵢⴰⵜ ⵏ ⵓⵔⵓⵛⵛⵉ, ⵉⵏⵏⵉ ⵉⴷⴻⵀⵀⵏⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵍⴻⵎⵅⴻⵢⵢⴰⵔ ⵏ ⵣⵣⴻⵛⵜ ⵓ ⵡⴰⵔ ⵜⵜⴰⵔⵔⴰⵏ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵔⴻⵥⵥⵉⵜ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("AM6_7","031_6_7","AMO","6","7","7","ⵙ ⵓⵢⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵅⵅⵓ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ. ⴰⵇⴰ ⵉⵜⵜⵡⴰⵇⴹⴰ ⴷⴷⵔⵉⵣ ⵏ ⵓⵖⵓⵢⵢⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴷⵉⵏ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ");
INSERT INTO rift_vpl VALUES ("AM6_8","031_6_8","AMO","6","8","8","ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵉⵊⵊⵓⴵ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵏⴻⵛⵛ ⵄⵉⴼⴼⴻⵖ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⵛⴰⵔⵔⵀⴻⵖ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵙⴻⵍⵍⵎⴻⵖ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AM6_9","031_6_9","AMO","6","9","9","“ⴰⴷ ⵉⵎⵙⴰⵔ ⵍⴰⵎⵉ ⵇⵇⵉⵎⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵔⵢⴰⵣⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵉⵛⵜ, ⴰⵇⴰ ⴰⴷ ⵎⵎⵜⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AM6_10","031_6_10","AMO","6","10","10","ⵎⴰⵍⴰ ⵄⴻⵎⵎⵉⵙ, ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⵙⵛⴻⵎⴹ, ⴰⴷ ⵜ ⵉⴽⵙⵉ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⵅⴻⵛⴱⴻⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵄⴰⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ: ‘ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵖⴰⵔⴻⴽ ⵄⴰⴷ ⴽⵜⴰⵔ?’, ⵓⵛⴰ ⴰⴷ ⵢⵉⵏⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: ‘ⵓⵍⴰ ⴷ ⵉⵊⵊ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⵏⴻⵜⵜⴰ: ‘ⵙⵇⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵉⴷⴰⵔ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ.’” ");
INSERT INTO rift_vpl VALUES ("AM6_11","031_6_11","AMO","6","11","11","“ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵜⵜⴰⵎⴰⵔ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵍ ⵖⴰ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM6_12","031_6_12","AMO","6","12","12","ⵎⴰ ⴰⴷ ⵜⴰⵣⵣⵍⴻⵏ ⵉⵢⵙⴰⵏ ⵅ ⵍⴻⵊⵔⵓⴼ? ⵎⴰ ⴰⴷ ⵜ ⵛⴰⵔⵣⴻⵏ ⵙ ⵉⴼⵓⵏⴰⵙⴻⵏ? ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵜⴰⵔⵔⵉⵎ ⵍⵃⴻⵇⵇ ⴷ ⴰⵔⵔⵀⴰⵊ ⵓ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵜⴰⵔⵔⵉⵎ ⵜⵜ ⴷ ⵛⵛⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AM6_13","031_6_13","AMO","6","13","13","ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⵣⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰ ⵡⴰⵔ ⵏⴻⵟⵟⵉⴼ ⴰⵛⵛⴰⵡⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵖ?’ ");
INSERT INTO rift_vpl VALUES ("AM6_14","031_6_14","AMO","6","14","14","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴹⵉⴷⴷ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵃⵚⴰⵔⴻⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵉⵡⴷⴰⵏ ⵖⴰⵔ ⵃⴰⵎⴰⵜ ⴰⵍ ⵜⴰⵖⵣⴰⵔⵜ ⵏ ⵍⴻⵡⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("AM7_1","031_7_1","AMO","7","1","1","“ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵜⵜ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ! ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⴱⵓⵔⴻⵅⵙⴻⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵔⴱⵉⵄ ⴰⵏⴻⴳⴳⴰⵔ ⵉⴱⴻⴷⴷⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ. ⵅⵣⴰⵔ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵔⴱⵉⵄ ⴰⵏⴻⴳⴳⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⵃⴻⵜⵛⴻⵏ ⴰⵔⴱⵉⵄ ⵉ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("AM7_2","031_7_2","AMO","7","2","2","ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵓⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵙⴰⵎⴻⵃ ⵎⴰⵛⴰ! ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴷ ⵉⴱⴻⴷⴷ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("AM7_3","031_7_3","AMO","7","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ‘ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ!’, ⵉⵏⵏⴰ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("AM7_4","031_7_4","AMO","7","4","4","“ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵜⵜ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵍⵄⵉⵇⴰⴱ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴻⵛⵛⴰ ⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴰⵍⴰⵎⵉ ⴰⴷ ⵜⴻⵛⵛ ⵓⵍⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AM7_5","031_7_5","AMO","7","5","5","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵙⴱⴻⴷⴷ ⵎⴰⵛⴰ! ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴷ ⵉⴱⴻⴷⴷ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("AM7_6","031_7_6","AMO","7","6","6","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵎ ⵙⵉⴷⵉ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ‘ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ!’, ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ!” ");
INSERT INTO rift_vpl VALUES ("AM7_7","031_7_7","AMO","7","7","7","“ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵜⵜ ⵏⴻⵜⵜⴰ: ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⴻⴷⴷ ⵅ ⵢⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵉ ⵉⵜⵜⵡⴰⴳⴳ ⵙ ⴱⵍⵓⵎⵓ ⵓ ⵢⵉⵊⵊ ⵏ ⴱⵍⵓⵎⵓ ⵜⵓⵖⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM7_8","031_7_8","AMO","7","8","8","ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵔⵉⴷ ⵛⴻⴽ, ⵄⴰⵎⵓⵙ?’ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵉⵊⵊ ⵏ ⴱⵍⵓⵎⵓ!’ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ: ‘ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴱⵍⵓⵎⵓ ⵉⵏⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙ ⵄⴻⴷⴷⵓⵖ ⵄⴰⴷ! ");
INSERT INTO rift_vpl VALUES ("AM7_9","031_7_9","AMO","7","9","9","ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵉⵙⵃⴰⵇ ⴰⴷ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ ⵓ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵔⵓⴱⵄⴰⵎ ⵙ ⵙⵙⵉⴼ.’” ");
INSERT INTO rift_vpl VALUES ("AM7_10","031_7_10","AMO","7","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵎⴰⵚⵢⴰ, ⴰⴽⴻⵀⵀⴰⵏ ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵢⴰⵔⵓⴱⵄⴰⵎ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⴰ: “ⵄⴰⵎⵓⵙ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴹⵉⴷⴷ ⵉ ⵛⴻⴽ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⴽⵙⵉ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM7_11","031_7_11","AMO","7","11","11","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵄⴰⵎⵓⵙ: ‘ⵢⴰⵔⵓⴱⵄⴰⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵙ ⵙⵙⵉⴼ ⵓ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵖⴰⵔ ⵍⵎⴻⵏⴼⴰ, ⴰⴷ ⵜ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("AM7_12","031_7_12","AMO","7","12","12","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵎⴰⵚⵢⴰ ⵉ ⵄⴰⵎⵓⵙ: “ⴰ ⵛⴻⴽ, ⴰⵎⵡⴰⵍⴰⵡ, ⵔⵓⵃ, ⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ! ⴻⵛⵛ ⴷⵉⵏⵏⵉ ⴰⵖⵔⵓⵎ ⵓ ⵏⴰⴱⴱ ⴷⵉⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("AM7_13","031_7_13","AMO","7","13","13","ⴷⵉ ⴱⴰⵢⵜ-ⵉⵍ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵏⴻⴱⴱⵉⴷ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("AM7_14","031_7_14","AMO","7","14","14","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵄⴰⵎⵓⵙ, ⵉⵏⵏⴰ ⵉ ⴰⵎⴰⵚⵢⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴰⵏⴰⴱⵉ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵎⵎⵉⵙ ⵏ ⵓⵏⴰⴱⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴱⵓ-ⵍⴻⴱⵀⴰⵢⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵍⴻⵇⵇⴹⴻⵏ ⵜⴰⵣⴰⵔⵜ ⵜⴰⴱⵓⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("AM7_15","031_7_15","AMO","7","15","15","ⵙⵉⴷⵉ ⵉⴽⴽⴻⵙ ⴰⵢⵉ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵡⵓⴵⵉ ⵓ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵓⵢⵓⵔ, ⵏⴰⴱⴱ ⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("AM7_16","031_7_16","AMO","7","16","16","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵏⴻⴱⴱⵉⴷ ⴹⵉⴷⴷ ⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⴰⴷ ⵜⴻⵙⵙⵓⴷⵎⴻⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵃⴰⵇ!’ ");
INSERT INTO rift_vpl VALUES ("AM7_17","031_7_17","AMO","7","17","17","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⴻⵙⵙⴻⴼⵙⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵓⵖⵉⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ ⴷ ⵢⴻⵙⵙⵉⵛ ⵏⵏⴻⵛ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵙⵙⵉⴼ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜ ⴱⴹⴰⵏ ⵙ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴻⵎⵎⵜⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵅⵎⴻⵊ ⵓ ⵙ ⵜⵉⴷⴻⵜⵜ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⴷⵉ ⵍⵎⴻⵏⴼⴰ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AM8_1","031_8_1","AMO","8","1","1","“ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵜⵜ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⵙⵓⴵⴻⵜ ⴷⴰⵢⴻⵙ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ! ");
INSERT INTO rift_vpl VALUES ("AM8_2","031_8_2","AMO","8","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ ⴰ ⵄⴰⵎⵓⵙ?’ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵉⵛⵜ ⵏ ⵜⵙⵓⴵⴻⵜ ⴷⴰⵢⴻⵙ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ!’ ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵇⴻⵟⵟⵓ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙ ⵄⴻⴷⴷⵓⵖ ⵄⴰⴷ! ");
INSERT INTO rift_vpl VALUES ("AM8_3","031_8_3","AMO","8","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵉⵣⵍⴰⵏ ⵏ ⵍⴻⵇⵚⴰⵔ ⴷ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ. ⴰⴷ ⵉⵍⵉⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵍⵅⴻⵛⴱⴰⵜ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ, ⵜⵉⵏⵏⵉ ⵉⵏⴹⴰⵔ ⵏⴻⵜⵜⴰ. ⵙⴻⵖⴷ!’” ");
INSERT INTO rift_vpl VALUES ("AM8_4","031_8_4","AMO","8","4","4","“ⵙⵍⴻⵎ ⴰⵢⴰ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵚⴰⵔⵔⴹⴻⵏ ⴰⵎⴻⵣⵍⵓⴹ ⵓ ⵜⴻⵇⴹⴰⵎ ⵅ ⵍⵎⵓⵙⴰⴽⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("AM8_5","031_8_5","AMO","8","5","5","ⴰⵎ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴻⵍⵎⵉ ⵖⴰ ⵉⵄⴷⵓ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⴰⵍⴰⵎⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵣⵣⴻⵏⵣ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ. ⵓ ⵎⴻⵍⵎⵉ ⵖⴰ ⵉⵄⴷⵓ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⴰⵍⴰⵎⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴰⵔⵣⴻⵎ ⵜⵉⵙⵔⴰⴼⵉⵏ ⵏ ⵢⵉⵔⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵥⵉ ⵍⴻⵄⴱⴰⵔ ⵏ ⵉⴼⴰ ⵓ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵖⴰⵔ ⵛⵉⵇⵍⵓ ⵓ ⴰⴷ ⵏⴻⵛⵎⴻⵜ ⵙ ⵍⵎⵉⵣⴰⵏⴰⵜ ⵏ ⵍⵖⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("AM8_6","031_8_6","AMO","8","6","6","ⴰⵍⴰⵎⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵙⴻⵖ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ ⵙ ⵜⴻⵏⵄⴰⵛⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵍⴰ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⵉ ⵜⵢⵓⵢⴰ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ!’, ⵓ ⴰⵎ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⴰⴷ ⵏⴻⵣⵣⴻⵏⵣ ⵉⵛⴰⵔⴼⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵎⴻⵏⴷⵉ!’” ");
INSERT INTO rift_vpl VALUES ("AM8_7","031_8_7","AMO","8","7","7","“ⵙⵉⴷⵉ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵢⴰⵄⵇⵓⴱ: ‘ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⵜⵓⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("AM8_8","031_8_8","AMO","8","8","8","ⵎⴰ ⵡⴰⵔ ⵜⵜⴻⵏⵀⴻⵣⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵛⴻⴹⵏⴻⵏ? ⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴳⴻⵄⵄⵉⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵎⵓⵏ ⴰⵎ ⵢⴻⵖⵣⴰⵔ, ⴰⴷ ⵜⴰⵍⵉ ⵓ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⴰ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵏ ⵎⵉⵚⵔⴰ?” ");
INSERT INTO rift_vpl VALUES ("AM8_9","031_8_9","AMO","8","9","9","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴼⵓⵛⵜ ⴰⴷ ⵜⴻⵖⵍⵉ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ ⵓ ⴰⴷ ⵙⵙⴱⴰⵔⴻⵛⵏⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵟⵃⴰ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("AM8_10","031_8_10","AMO","8","10","10","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴼⵉⵛⵜⴰⵜ ⵏⵡⴻⵎ ⴷ ⴰⵛⴹⴰⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵣⵍⴰⵏ ⵏⵡⴻⵎ ⴷ ⵉⵣⵍⴰⵏ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴱⴻⵢⵙⴰ ⵓ ⵅ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ ⴰⴷ ⴳⴳⴻⵖ ⵜⵓⵇⴻⵛⵛⴰⵔⵜ. ⴰⴷ ⴰⵡⵢⴻⵖ ⴰⵛⴹⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵡⴻⵛⴹⴰⵏ ⵅ ⵓⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ, ⵓ ⴰⵇⴻⵟⵟⵓ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷ ⴰⵎⴰⵔⵣⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("AM8_11","031_8_11","AMO","8","11","11","“ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵍⴰⵥ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵍⴰⵥ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴼⴰⴷ ⵏ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵓⴼⴰⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM8_12","031_8_12","AMO","8","12","12","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜⴻⵍⵄⴻⵏ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵓ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵖⴰⵔ ⵛⵛⴰⵔⵇ, ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵜⵜⵉⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AM8_13","031_8_13","AMO","8","13","13","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵖⴰⵛⴰⵏⵜ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵏⵏⵉ ⵉⵛⵏⴰⵏ ⵇⴰⵄ ⵓⵍⴰ ⴷ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵙ ⵓⴼⴰⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("AM8_14","031_8_14","AMO","8","14","14","ⵉⵏⵏⵉ ⵉⵜⵜⵊⵊⴰⴵⴰⵏ ⵖⴰⵔ ⵓⵎⴰⵔⵡⴰⵙ ⵏ ⵙⴰⵎⴰⵔⵢⴰ, ⵇⵇⴰⵔⴻⵏ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⵉⴷⴷⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰ ⴷⴰⵏ, ⵓ ⴰⵎ ⵉⴷⴷⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⴱⵉ’ⵔ-ⵙⴻⴱⵄⴰ!’, ⴰⴷ ⵡⴹⴰⵏ, ⵡⴰⵔ ⵜⵜⴻⴽⴽⴰⵔⴻⵏ ⵄⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("AM9_1","031_9_1","AMO","9","1","1","“ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⵉⵏⵏⴰ: ‘ⵡⵡⴻⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⴱⵉⵍⴰⵔ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⴰⵔⵊⵉⵊⴻⵏⵜ ⵜⵏⴻⴱⴷⴰⵜⵉⵏ ⵓ ⴰⵔⵥ ⵉ-ⵜⴻⵏⵜ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ. ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⴷ ⵜ ⵏⵖⴻⵖ ⵙ ⵙⵙⵉⴼ. ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⵔⵉⴽⴽⵯⵉⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵡⴰⵍ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵏⴻⵊⵊⵎⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ. ");
INSERT INTO rift_vpl VALUES ("AM9_2","031_9_2","AMO","9","2","2","ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵖⵣⵉⵏ ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵏ ⵍⴰⵅⴰⵔⵜ, ⴰⴼⵓⵙ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⵏⵏⵉ ⵢⴰⵡⵉ, ⵓ ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴰⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵙⵙⴻⵀⵡⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("AM9_3","031_9_3","AMO","9","3","3","ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅ ⵜⵇⵉⵛⵛⴰⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⴽⴰⵔⵎⵉⵍ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵣⵓⵖ ⵓ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵙⵙⴻⵏⵏⵉ. ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵅ ⵜⵉⵙⵉ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵡⴻⵚⵚⵉⵖ ⴰⴼⵉⵖⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵣⵄⴻⴼ, ");
INSERT INTO rift_vpl VALUES ("AM9_4","031_9_4","AMO","9","4","4","ⵓ ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ, ⵏⴻⵛⵛ ⴰⴷ ⵡⴻⵚⵚⵉⵖ ⴷⵉⵏⵏⵉ ⵙⵙⵉⴼ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵏⴹⴰⵔⴻⵖ ⵜⵉⵟⵟ ⵉⵏⵓ ⵉ ⵍⵖⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AM9_5","031_9_5","AMO","9","5","5","ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⴰⴷⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⴰⵍⴰⵎⵉ ⵜⴻⵏⵀⴻⵣⵣ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵛⴻⴹⵏⴻⵏ. ⵜᵉⵜⵜⴳⴻⵄⵄⴻⴷ ⵜⵎⵓⵏ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵏ ⵏⵉⵍ ⵓⵛⴰ ⵜᵉⵜⵜⴰⵍⵉ ⵜⵀⴻⴽⴽⵡⵉ ⴰⵎ ⵢⴻⵖⵣⴰⵔ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AM9_6","031_9_6","AMO","9","6","6","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴱⴻⵏⵏⴰⵏ ⵉⵅⵅⴰⵎⴻⵏ ⵏⵏⴻⵙ ⵙⴻⵏⵏⴻⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵉⵜⵜⴻⴳⴳ ⵍⵇⵓⴱⴱⴻⵜ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵉ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⵜⵜⴼⴰⵔⵔⴻⵖ ⵉ-ⵜⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⵉⴷⵉ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM9_7","031_9_7","AMO","9","7","7","ⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵉⵏⵓ ⴰⵎ ⴰⵢⵜ ⵏ ⴽⵓⵛ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⵉⵙⵔⴰⵉⵍ ⵣⵉ ⵎⵉⵚⵔⴰ ⵓ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⵣⵉ ⴽⴰⴼⵜⵓⵔ ⵓ ⴰⵔⴰⵎ ⵣⵉ ⵇⵉⵔ? ");
INSERT INTO rift_vpl VALUES ("AM9_8","031_9_8","AMO","9","8","8","ⵅⵣⴰⵔⴻⵎ, ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴹⵉⴷⴷ ⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵜⴰⵎⴻⴷⵏⵓⴱⵜ. ⵏⴻⵛⵛ ⴰⴷ ⵜⵜ ⵜⴻⵃⵃⵉⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵃⵃⵉⵖ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AM9_9","031_9_9","AMO","9","9","9","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵓⵎⵓⵔⴻⵖ ⵓ ⴰⴷ ⵣⵣⴻⵍⵣⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵣⵣⴻⵍⵣⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴱⵓ-ⵙⵉⵢⵢⴰⵔ ⵓ ⵡⴰⵔ ⵜⵡⴻⵟⵟⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AM9_10","031_9_10","AMO","9","10","10","ⵎⴰⵔⵔⴰ ⵉⵎⴻⴷⵏⴰⴱ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵍⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵍⴻⵇⵇⴻⴼ ⵛⴰ ⵓ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⵉⴱ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("AM9_11","031_9_11","AMO","9","11","11","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵄⴰⵡⴻⴷ ⵜⴰⵅⵣⴰⵏⵜ ⵉⵡⴻⵟⵟⴰⵏ ⵏ ⴷⴰⵡⵓⴷ ⵉ ⵉⵡⴹⴰⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵇⵇⵏⴻⵖ ⵜⵉⵣⵣⴰ ⵏⵏⴻⵙ ⵓ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ, ⴰⴷ ⵜ ⴰⵔⵔⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⴱⵏⵉⵖ ⵄⴰⵡⴻⴷ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("AM9_12","031_9_12","AMO","9","12","12","ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵉⴷⵓⵎ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵅ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AM9_13","031_9_13","AMO","9","13","13","ⵅⵣⴰⵔⴻⵎ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵣⴻⵏ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵉⵃⴰⵔⵜ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵍⴻⴱⴱⵣⴻⵏ ⴰⴹⵉⵍ ⵙ ⵉⴹⴰⵔⴻⵏ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵉⵃⴰⵔⵜ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴹⴻⵏ ⴰⴼⵓⵙ ⴰⴽ-ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ, ⵓ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⵜⵜⵓⵛⵔⵓⵔⴻⵏ ⵙ ⴱⵉⵏⵓ ⵥⴻⵎⵎⴻⵏ ⵜ ⵊⴷⵉⴷ, ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵙⵙⴻⴼⵢⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AM9_14","031_9_14","AMO","9","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵉⵙⵔⴰⵉⵍ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵀⴻⴷⵎⴻⵏ ⵓ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵣⴻⴷⴷⵖⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵉⵎⴰⵔⵊⴰⵄⴻⵏ ⵏ ⵓⴹⵉⵍ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵥⵥⵓⵏ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ ⵓ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵙⵡⴻⵏ ⴱⵉⵏⵓ, ⴰⴷ ⴳⴳⴻⵏ ⵉⵃⵡⵉⵛⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AM9_15","031_9_15","AMO","9","15","15","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵥⵥⵓⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵏⵏⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵡⵛⵉⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("OB1_1","032_1_1","OBA","1","1","1","ⵍⴻⵡⵃⵉⵢ ⵏ ⵄⵓⴱⴰⴷⵢⴰ. “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵅ ⵉⴷⵓⵎ: ’ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⵣⵉ ⵙⵉⴷⵉ, ⵓ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⴽⴽⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ: ⴽⴽⴰⵔ, ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵅⴰⵙ ⵏⵖⴻⵡⵡⴻⵖ, ⴰⴷ ⵏⴻⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⴷⵓⵎ!’ ");
INSERT INTO rift_vpl VALUES ("OB1_2","032_1_2","OBA","1","2","2","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴰⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("OB1_3","032_1_3","OBA","1","3","3","ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ ⵜⴻⵛⵎⴻⵜ ⵉ ⵛⴻⴽ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏ ⵓⴷⵓⵔⵔⵉ ⵊⴰⵔ ⵍⴻⵊⵔⵓⴼ, ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵛ ⵢⵓⵄⵍⴰⵏ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ: ‘ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵖⴻⴹⵍⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ?’ ");
INSERT INTO rift_vpl VALUES ("OB1_4","032_1_4","OBA","1","4","4","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⵎ ⵓⴳⵉⴷⴻⵔ, ⵏⵉⵖ ⵜⴻⴳⴳⵉⴷ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵛ ⵊⴰⵔ ⵉⵜⵔⴰⵏ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵙⵙⴻⵀⵡⵉⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("OB1_5","032_1_5","OBA","1","5","5","“ⵎⴰⵍⴰ ⵓⴷⴼⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ, ⵏⵉⵖ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ ⵙ ⴵⵉⵍⴻⵜ, - ⴰ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵍⴻⴷⴷⴵⴻⴷ ⴰⵍ ⵟⵟⴰⵔⴼ - ⵎⴰ ⵡⴰⵔ ⵜⵜⴰⵛⴰⵔⴻⵏ ⴰⵍ ⵖⴰⵔⵙⴻⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⵉⵏ ⵉⴽⴼⴰⵏ? ⵎⴰⵍⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵍⴻⵇⴹⴻⵏ ⴰⴹⵉⵍ, ⵎⴰ ⴰⴷ ⵊⵊⴻⵏ ⵛⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵍⴻⵇⴹⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("OB1_6","032_1_6","OBA","1","6","6","ⴰ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴰⵔⵣⵓⵏ ⴷⵉ ⵄⵉⵙⵓ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴱⴻⵇⵇⵛⴻⵏ ⵍⴻⴽⵏⵓⵣ ⵏⵏⴻⵙ ⵏⵏⵓⴼⴰⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("OB1_7","032_1_7","OBA","1","7","7","ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⴻⴽ, ⵄⴰⵔⵏⴻⵏ ⵛⴻⴽ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⴽ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵛⴻⵎⵜⴻⵏ ⵛⴻⴽ, ⵏⵉⵜⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴰⴽ. ⴰⵖⵔⵓⵎ ⵣⵣⴰⵢⴻⴽ ⴳⴳⵉⵏ ⵜ ⴷ ⵜⴰⵔⴻⵃⵙⵉⵜ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵛ. ‘ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ.’    ");
INSERT INTO rift_vpl VALUES ("OB1_8","032_1_8","OBA","1","8","8","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵣⵉ ⵉⴷⵓⵎ, ⵓ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⵉⵙⵓ? ");
INSERT INTO rift_vpl VALUES ("OB1_9","032_1_9","OBA","1","9","9","ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⴰ ⵜⴰⵢⵎⴰⵏ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⵉⵙⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵙ ⵡⴻⵏⵖⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("OB1_10","032_1_10","OBA","1","10","10","“ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵄⵓⵏⴼ ⵅ ⵓⵎⴰⵛ ⵢⴰⵄⵇⵓⴱ, ⴰⴷ ⵛⴻⴽ ⵜⴷⴻⵍ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴽⵙⴻⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("OB1_11","032_1_11","OBA","1","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⵜⴱⴻⴷⴷⴻⴷ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⵓ ⵓⴷⴼⴻⵏ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ, ⵓ ⵏⴹⴰⵔⴻⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⵓⵖⴰ ⵛⴻⴽ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("OB1_12","032_1_12","OBA","1","12","12","ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵎⴰⵛ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵛⵜⴰⴱ ⵏⵏⴻⵙ ⴰⴱⴰⵔⵛⴰⵏ, ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴰⵔⴻⵣⵎⴻⴷ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("OB1_13","032_1_13","OBA","1","13","13","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵀⴻⵍⵍⴻⴽ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵙⴻⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵖⴰⵔ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⴹⴻⵢⵢⴻⵄ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("OB1_14","032_1_14","OBA","1","14","14","ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵜⵎⴻⵍⵇⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⴻⵃⵃⵉⴷ ⵉⵏⵏⵉ ⵉⵏⴻⵊⵎⴻⵏ ⵓ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵙⴻⵍⵍⵎⴻⴷ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("OB1_15","032_1_15","OBA","1","15","15","“ⵎⴰⵖⴰⵔ ⵢⵓⴷⴻⵙ-ⴷⴷ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ! ⴰⵎ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ, ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⴳⴳ, ⴰⵅⴻⴵⴻⵚ ⵏⵏⴻⵛ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("OB1_16","032_1_16","OBA","1","16","16","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵡⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵎⵎⵓ ⴰⴷ ⵙⵡⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵍⴻⴱⴷⴰ, ⵡⴰⵀ, ⴰⴷ ⵙⵡⴻⵏ ⴰⴷ ⵙⴻⴽⴽⴼⴻⵏ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵅⵎⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵓⵖⴰ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("OB1_17","032_1_17","OBA","1","17","17","ⵎⴰⵛⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⵢⵉⵍⵉ ⵎⵉⵏ ⵉⵏⵏⴻⵊⵎⴻⵏ, ⵓ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵇⴻⴷⴷⴻⵙ, ⵓ ⵉⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵉⵙⴻⵇⵇⴰⵍ ⵏ ⵍⵡⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("OB1_18","032_1_18","OBA","1","18","18","ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵉⵎⴻⵙⵙⵉ, ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⴷ ⴰⵛⴻⵄⵄⴰⵍ, ⵓⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵉⵙⵓ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵢⵉⵖⴻⴵ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵓ ⴰⴷ ⵜⴻⵏ ⵛⵛⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⴷⴷⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵄⵉⵙⵓ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("OB1_19","032_1_19","OBA","1","19","19","“ⵉⵏⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵟⵟⴼⴻⵏ ⵉⴷⵓⵔⴰⵔ ⵏ ⵄⵉⵙⵓ ⴷ ⵜⴰⵙⵖⴰⵔⵜ, ⵓ ⵢⵉⵏⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ ⴷ ⵍⵡⴰⵔⵜ ⵡⴰⵀ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⵉⵢⵢⴰⵔ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴷ ⵢⴻⵢⵢⴰⵔ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵍⵡⴰⵔⵜ, ⵓ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⴷ ⵉⵟⵟⴻⴼ ⵊⵉⵍⵄⴰⴷ ⴷ ⵍⵡⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("OB1_20","032_1_20","OBA","1","20","20","ⵓ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵣⵉ ⵍⵄⴻⵙⴽⴰⵔ-ⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⴷ ⵍⵡⴰⵔⵜ ⴰⵍ ⵚⴰⵔⴼⴰⵜ, ⵓ ⵉⵎⴻⵏⴼⵉⵢⵢⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵚⴰⴼⴰⵔⴰⴷ, ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("OB1_21","032_1_21","OBA","1","21","21","ⵉⵎⵙⴻⵍⵍⴽⴻⵏ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⴰⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴰⴽⵎⴻⵏ ⴰⴷⵔⴰⵔ ⵏ ⵄⵉⵙⵓ, ⵓⵛⴰ ⵜⴰⴳⴻⵍⴷⴰ ⴰⴷ ⵜⵉⵍⵉ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JH1_1","033_1_1","JON","1","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵢⵓⵏⵓⵙ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵉⵜⵜⴰⵢ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JH1_2","033_1_2","JON","1","2","2","“ⴽⴽⴰⵔ, ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵏⵉⵏⵡⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⴱⴰⵔⵔⴻⵃ ⴹⵉⴷⴷ ⵏⵏⴻⵙ ⵎⵉⵏⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵙⴻⵏ ⵜⴳⴻⵄⵄⴻⴷ ⴰⵎ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵃⴻⵜ ⵢⴰⵔⵚⵓⴷⴻⵏ ⴰⵍ ⵓⴷⴻⵎ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JH1_3","033_1_3","JON","1","3","3","ⵎⴰⵛⴰ ⵢⵓⵏⵓⵙ ⵉⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵏⴻⵜⵜⴰ ⵉⵀⵡⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⴰⴼⴰ ⵓⵛⴰ ⵢⵓⴼⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⴰⴷ ⵜⵔⴰⵃ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⴰⵔⵛⵉⵛ. ⵏⴻⵜⵜⴰ ⵉⵅⴻⴵⴻⵚ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⵙⴰⴼⴰⵔ ⵓⵛⴰ ⵉⵏⵢⴰ ⴷⴰⵢⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ, ⵉⵅⵙ ⴰⴷ ⵉⴳⴳⵯⴻⵊ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JH1_4","033_1_4","JON","1","4","4","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵉⵊⵀⴻⴷ ⵅ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵉⴷⵡⴻⵍ ⴷ ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵍⴻⴱⵃⴰⵔ ⴰⵍⴰⵎⵉ ⵄⵍⴰⵃⴰⵍ ⵜⵉⵡⴻⴹ ⴰⴷ ⵜⴰⵔⵥ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JH1_5","033_1_5","JON","1","5","5","ⴳⴳⵯⴻⴷⴻⵏ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉⵙⵖⵓⵢ, ⵉⵜⵜⴰⵔ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵍⴻⵇⵛⵓⵄ ⵏⵏⵉ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⵙⵏⴻⵇⵚⴻⵏ ⴷⴷⵇⴻⵍ. ⵜⵓⵖⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵢⵓⵏⵓⵙ ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⵣⵣⴻⵍ ⴷⵉⵏ ⵓⵛⴰ ⵉⵟⵟⴻⵚ ⵉⵊⵊ ⵏ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JH1_6","033_1_6","JON","1","6","6","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴱⴰⴱ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ, ⵎⴰⵢⴻⵎⵎⵉ ⴷⵉⵏⵏⵉ ⵜᵉⵟⵟⵚⴻⴷ? ⴽⴽⴰⵔ, ⵍⴰⵖⴰ ⵅ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴰⵖ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽⴰⵔ ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⵖⴰⵔⵔⴻⵇ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("JH1_7","033_1_7","JON","1","7","7","ⵏⵏⴰⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⴰⵙ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴹⴰⵔ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⵉⵏ ⴷⵉ ⵏⵏⵄⵉ-ⵢⴰ.” ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵜⵇⴻⴷⴷⵓⵃⵜ ⴷⴻⴳ ⵢⵓⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("JH1_8","033_1_8","JON","1","8","8","ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵉⵏⵉ ⴰⵏⴻⵖ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵃⴽⴻⵎ ⵏⵏⵄⵉ-ⵢⴰ. ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ? ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵓⵙⵉⴷ? ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵓ ⵣⵉ ⵎⴰⵏ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰⵔ ⵜⴻⵇⵇⵏⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("JH1_9","033_1_9","JON","1","9","9","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⴷ ⴰⵄⵉⴱⵔⴰⵏⵉ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵖ ⵣⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵍⴻⴱⵃⴰⵔ ⴷ ⵍⴱⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JH1_10","033_1_10","JON","1","10","10","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵜⴻⴳⴳⵉⴷ?” ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵙⵙⵏⴻⵏ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵍ-ⴷⴷ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵜⵓⵖⴰ ⵣⴻⵄⵎⴰ ⵉⵙⵙⵅⴻⴱⴱⴰⵔ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JH1_11","033_1_11","JON","1","11","11","ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉ ⵖⴰ ⵏⴻⴳⴳ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵀⴻⴷⴷⴻⵏ ⵍⴻⴱⵃⴰⵔ?” ⵎⵉⵏⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵜⵓⵖⴰ ⵄⴰⴷ ⵢⴰⵔⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵀⴰⵊⵉ. ");
INSERT INTO rift_vpl VALUES ("JH1_12","033_1_12","JON","1","12","12","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⵙⵉⵎ ⴰⵢⵉ ⵓ ⵏⴹⴰⵔⴻⵎ ⴰⵢⵉ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵀⴻⴷⴷⴻⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵜⴰⵃⴰⵔⵢⴰⴹⵜ-ⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵡⴹⴰⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JH1_13","033_1_13","JON","1","13","13","ⵎⴰⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⵓⵖⴰ ⵇⴻⴷⴷⴼⴻⵏ ⵖⴰⵔ ⵍⴱⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵜⵓⵖⴰ ⵄⴰⴷ ⵢⴰⵔⴻⵏⵏⵉ ⵅⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵓⵀⴰⵊⵉ. ");
INSERT INTO rift_vpl VALUES ("JH1_14","033_1_14","JON","1","14","14","ⵅⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵉ ⵙⵉⴷⵉ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵜⴻⵊⵊⵉ ⵛⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵃⴻⵙⵙⵉⴱⴻⴷ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⵜⴻⴳⴳⵉⴷ ⵎⵉⵏ ⴷ ⴰⵛ ⵢⴰⵔⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JH1_15","033_1_15","JON","1","15","15","ⵅⴰⵙ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵢⵓⵏⵓⵙ, ⵏⴹⴰⵔⴻⵏ ⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵓⵀⴰⵊⵉ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JH1_16","033_1_16","JON","1","16","16","ⴳⴳⵯⴷⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵣⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵖⴰⵔⵚⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵡⴰⵄⴷⴻⵏ ⵍⵡⵓⵄⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("JH2_1","033_2_1","JON","2","1","1","ⵉⵙⵙⴻⵡⵊⴻⴷ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵡⴻⵙⵍⴻⵎ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵖⵔⵉ ⵢⵓⵏⵓⵙ ⵓⵛⴰ ⵢⵓⵏⵓⵙ ⵉⴽⴽⴰ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⴵⵉⵢⴰⵍⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵡⴻⵙⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JH2_2","033_2_2","JON","2","2","2","ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵢⵓⵏⵓⵙ ⵉ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵡⴻⵙⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JH2_3","033_2_3","JON","2","3","3","ⵉⵏⵏⴰ: ”ⵣⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵉⵏⵓ ⵍⴰⵖⵉⵖ ⵉ ⵙⵉⴷⵉ ⵓ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ. ⵣⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵏ ⵍⴰⵅⴰⵔⵜ ⵍⴰⵖⵉⵖ ⵓⵛⴰ ⵛⴻⴽ ⵜⴻⵙⵍⵉⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JH2_4","033_2_4","JON","2","4","4","ⵜⵓⵖⴰ ⵜⴻⵏⴹⴰⵔⴻⴷ ⴰⵢⵉ ⴷⵉ ⵍⴰⴵⴰⵖ, ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵍⴻⴱⵃⵓⵔ, ⵜⴻⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵍⴻⵎⵡⴰⵊ. ⵎⴰⵔⵔⴰ ⵣⵣⵀⵉⵔ ⵏⵏⴻⵛ ⴷ ⵍⴻⵎⵡⴰⵊ ⵏⵏⴻⵛ ⴽⴽⵉⵏ-ⴷⴷ ⵅⴰⴼⵉ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JH2_5","033_2_5","JON","2","5","5","ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ. ⵄⴰⴷ ⴰⴷ ⵜⵡⴰⵍⵉⵖ ⵄⴰⵡⴻⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JH2_6","033_2_6","JON","2","6","6","ⵟⵟⴼⴻⵏ ⴰⵢⵉ ⵡⴰⵎⴰⵏ ⴰⵍ ⵎⴰⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⵏⵏⴹⴻⵏ ⴰⵢⵉ-ⴷⴷ, ⵉⵍⵚⴻⵇ-ⴷⴷ ⴰⵔⴱⵉⵄ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JH2_7","033_2_7","JON","2","7","7","ⵀⵡⵉⵖ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ ⵢⵓⴵⵖⴻⵏ ⵇⴰⵄ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵜⵜⵡⴰⴱⴻⵍⵍⵄⴻⵏ ⵣⵣⴻⴽⵔⵓⵏⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵅⴰⴼⵉ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵣⵉ ⵜⵓⵔⵚⵓⴹⵉ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JH2_8","033_2_8","JON","2","8","8","ⵓⵎⵉ ⵉⴷⴻⵡⵡⴻⵅ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⴰⵢⵉ, ⴼⴻⴽⴽⴰⵔⴻⵖ ⴷⵉ ⵙⵉⴷⵉ, ⵓ ⵜⴰⵥⴰⴵⵉⵜ ⵉⵏⵓ ⵜⴳⴻⵄⵄⴻⴷ ⵖⴰⵔⴻⴽ, ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JH2_9","033_2_9","JON","2","9","9","ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴷⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴱⴻⵟⵟⵍⴻⵏ ⴷ ⵉⵖⴻⵛⵛⴻⵏ, ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵏⵙⴻⵏ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JH2_10","033_2_10","JON","2","10","10","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵃⴻⵎⴷⴻⵖ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵓⵇⴰⴷⵉ. ⵎⵉⵏ ⵡⴰⵄⴷⴻⵖ, ⴰⴷ ⵜ ⵇⴻⴼⵍⴻⵖ. ⴰⵙⴻⵏⵊⴻⵎ ⵣⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JH2_11","033_2_11","JON","2","11","11","ⵉⵙⵙⵉⵡⴻⵍ ⵙⵉⴷⵉ ⴰⴽ-ⴷ ⵡⴻⵙⵍⴻⵎ ⵓⵛⴰ ⵉⵄⵓⵇⵇ-ⴷⴷ ⵢⵓⵏⵓⵙ ⴷⵉ ⵍⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JH3_1","033_3_1","JON","3","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵢⵓⵏⵓⵙ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JH3_2","033_3_2","JON","3","2","2","“ⴽⴽⴰⵔ, ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵏⵉⵏⵡⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⴱⴰⵔⵔⴻⵃ ⴰⵙⴻⵏ ⵜⴰⴱⴰⵔⵔⴻⵃⵜ ⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵏⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JH3_3","033_3_3","JON","3","3","3","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵢⵓⵏⵓⵙ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵏⵉⵏⵡⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ. ⵜⵓⵖⴰ ⵏⵉⵏⵡⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙ ⵡⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵜⵉⵛⵍⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵓⵛⵓⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("JH3_4","033_3_4","JON","3","4","4","ⵢⵓⴷⴻⴼ ⵢⵓⵏⵓⵙ ⵜⴰⵏⴷⵉⵏⵜ ⵜⵉⵛⵍⵉ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵛⴰ ⵉⴱⴰⵔⵔⴻⵃ, ⵉⵏⵏⴰ: “ⴰⵡⴰⵔⵏⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵏⴻⵇⵍⴻⴱ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵏⵉⵏⵡⴰ.” ");
INSERT INTO rift_vpl VALUES ("JH3_5","033_3_5","JON","3","5","5","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵏⵉⵏⵡⴰ ⵓⵎⵏⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵥⵓⵎⵎⵉ ⵓⵛⴰ ⴰⵔⴹⴻⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ, ⵣⴻⴳ ⵓⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⴰⵎⴻⵥⵢⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JH3_6","033_3_6","JON","3","6","6","ⵢⵉⵡⴻⴹ ⵡⴰⵡⴰⵍ ⵓⵍⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ ⵏ ⵏⵉⵏⵡⴰ ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵣⵉ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ⵉⴽⴽⴻⵙ ⵅⴰⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⵉⵙⵙⴷⵓⵔⵉⵢ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵅ ⵢⵉⵖⵖⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JH3_7","033_3_7","JON","3","7","7","ⵅ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵛⵛⵓⵔⴼⴰ ⴳⴳⵉⵏ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⵏⵉⵏⵡⴰ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷ ⵡⵓⴵⵉ ⴰⴷ ⵛⵛⴻⵏ ⵛⴰ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵀⴷⴰⵏ ⵓⵍⴰ ⴰⴷ ⵙⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JH3_8","033_3_8","JON","3","8","8","ⵊⵊⴻⵎ ⴰⴷ ⵢⴰⵔⴹ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴰⴷ ⵉⵜⵓⴱ ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⴰⵄⴻⴼⴼⴰⵏ ⵓ ⵣⵉ ⵍⵄⵓⵏⴼ ⵉ ⵢⵓⵎⵙⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JH3_9","033_3_9","JON","3","9","9","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵉⵏⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴰⴷ ⵉⵜⵓⴱ ⵓⵛⴰ ⴰⴷ ⵉⴱⴻⵄⵄⴻⴷ ⵅ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵜⵀⴻⵍⵍⵉⴽ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("JH3_10","033_3_10","JON","3","10","10","ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏ ⴳⴳⵉⵏ, ⴰⵇⴰ ⵜⵓⴱⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏⵙⴻⵏ ⴰⵄⴻⴼⴼⴰⵏ ⵓⵛⴰ ⵉⵏⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵅ ⵍⵖⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⴳⴳ ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JH4_1","033_4_1","JON","4","1","1","ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⵉ ⵢⵓⵏⵓⵙ ⵓⵛⴰ ⵜⵀⴰⵊ ⵜⴻⴼⵇⴻⵃⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JH4_2","033_4_2","JON","4","2","2","ⵉⵥⵥⵓⴵ ⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⵏⵏⵉⵖ ⴰⵎⵎⵓ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵏⵓ? ⵅ ⵓⵢⴰ ⵏⵡⵉⵖ ⴰⴷ ⵜⵜ ⵊⵊⴻⵖ ⵓⵎⵉ ⴳⴳⵉⵖ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵜⴰⵔⵛⵉⵛ ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵃⵏⵉⵏ ⴷ ⴰⵔⵃⵉⵎ, ⵖⴰⵔⴻⴽ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵜⵏⴻⴷⵎⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JH4_3","033_4_3","JON","4","3","3","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⴽⴽⴻⵙ ⵣⵣⴰⵢⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⴱⴰⵏ ⴰⵢⵉ ⴱⴻⵍⵍⵉ ⵍⵎⴻⵡⵜ ⵉⵏⵓ ⵃⵙⴻⵏ ⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JH4_4","033_4_4","JON","4","4","4","ⵉⵏⵏⴰ ⵙⵉⴷⵉ: “ⵎⴰ ⵜⴻⵛⵏⴰ ⵓⵎⵉ ⵜⵅⴻⵢⵢⵇⴻⴷ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("JH4_5","033_4_5","JON","4","5","5","ⵉⴼⴼⴻⵖ ⵢⵓⵏⵓⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵇⵇⵉⵎ ⴷⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵇ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⵉⴳⴳⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴰⵙⴻⵇⵇⴰⴼⵜ ⵏ ⵉⴼⴻⵜⵡⴰⵏ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵙ ⴷⵉ ⵜⵉⵍⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⴰⵔ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JH4_6","033_4_6","JON","4","6","6","ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵜⴻⴱⵀⴻⵜ ⵓⵛⴰ ⵉⵊⵊⴰ-ⵉ-ⵜⵜ ⴰⴷ ⵜⴻⵢⵎⴰ ⵜⵓⵄⵍⴰ ⵅ ⵢⵓⵏⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵉⵍⵉ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵏⴻⵙ. ⵉⴼⴰⵔⵃ ⵢⵓⵏⵓⵙ ⴰⵟⵟⴰⵙ ⵅ ⵜⵛⴻⵊⵊⴰⵔⵜ-ⴰ ⵏ ⵍⴻⵄⵊⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("JH4_7","033_4_7","JON","4","7","7","ⵎⴰⵛⴰ ⵖⴰⵔ ⵍⴻⴼⵊⴰⵔ ⵏ ⵜⵡⴻⵛⵛⴰ ⵏ ⵡⴰⵙⵙ ⵉ ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵛⵜ ⵏ ⵜⴽⴻⵛⵛⴰ ⵏⵏⵉ ⵜⴻⵙⵙⴻⵃⵍⴻⵛ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵜⴻⴱⵀⴻⵜ ⵏⵏⵉ ⴰⵍⴰⵎⵉ ⵜⵓⵥⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JH4_8","033_4_8","JON","4","8","8","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵛⵛⴰⵔⵇ ⵉⵃⴰⵔⵔⴻⵏ ⵓⵛⴰ ⵜⴻⵡⵜⴰ ⵜⴼⵓⵛⵜ ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵏⵓⵙ ⴰⵍⴰⵎⵉ ⵉⴷⴻⵡⵡⴻⵅ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⵓ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵉⵏⵏⴰ: “ⵉⵜⵜⴱⴰⵏ ⴰⵢⵉ ⴱⴻⵍⵍⵉ ⵍⵎⴻⵡⵜ ⵉⵏⵓ ⵃⵙⴻⵏ ⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JH4_9","033_4_9","JON","4","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵓⵏⵓⵙ: “ⵎⴰ ⵜⴻⵛⵏⴰ ⵓⵎⵉ ⵜⵅⴻⵢⵢⵇⴻⴷ ⴰⵎⵎⵓ ⵅ ⵜⵛⴻⵊⵊⴰⵔⵜ-ⴰ ⵏ ⵓⵜⴻⴱⵀⴻⵜ?” ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴷ ⵚⵚⴻⵃ ⴰⵇⴰ ⵅⴻⵢⵢⵇⴻⵖ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵎⵎⵜⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("JH4_10","033_4_10","JON","4","10","10","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: “ⵛⴻⴽ ⵜⴻⵣⵣⵉⴵⴻⵣ ⴰⵛ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵜⴻⴱⵀⴻⵜ ⵉ ⵓⵎⵉ ⵡⴰⵔ ⵜⵅⴻⴷⵎⴻⴷ ⵓ ⵉ ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵢⵎⴻⴷ, ⴷ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JH4_11","033_4_11","JON","4","11","11","ⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵣⵣⵉⴵⴻⵣ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵏⵉⵏⵡⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴻⵏⵏⵉ ⵉ ⴷⵉ ⵉⴵⴰ ⴽⵜⴰⵔ ⵣⵉ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⵏ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⴷ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⴰⵣⴻⵍⵎⴰⴹ ⵓ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵢⴰ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("MC1_1","034_1_1","MIC","1","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵎⵉⵅⴰ, ⴰⵎⵓⵔⴰⵛⵜⵉ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵜⴰⵎ ⴷ ⴰⵃⴰⵣ ⴷ ⵃⵉⵣⵇⵉⵢⴰ, ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵡⴰⵍ ⵉ ⵉⵥⵔⴰ ⵅ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MC1_2","034_1_2","MIC","1","2","2","“ⵙⵍⴻⵎ-ⴷⴷ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵍⴻⴳⵏⵓⵙ, ⵉⵍⵉⵎ ⵜⴼⴻⵜⵏⴻⵎ, ⴰ ⵛⴻⵎ, ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ! ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵅⴰⵡⴻⵎ, ⵙⵉⴷⵉ ⵉⵏⵓ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC1_3","034_1_3","MIC","1","3","3","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔⴻⵎ, ⵙⵉⴷⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵓ ⴰⴷ ⵉⵚⵓⵔⴼ ⵅ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MC1_4","034_1_4","MIC","1","4","4","ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵙⴰⴷⵓ ⵏⵏⴻⵙ, ⵓ ⵜⵉⵖⵣⵓⵔⵉⵏ ⴰⴷ ⵜⵜⵡⴰⴱⴹⴰⵏⵜ, ⴰⵎ ⵛⵛⵎⴻⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴰⵎ ⵡⴰⵎⴰⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⴼⴰⵔⵔⵖⴻⵏ ⵣⵉ ⵜⴻⵢⵙⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MC1_5","034_1_5","MIC","1","5","5","ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵅⴻⵟⵟⵓ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵅⴻⵟⵟⵓ ⵏ ⵢⴰⵄⵇⵓⴱ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵙⴰⵎⴰⵔⵢⴰ? ⵓ ⵎⵉⵏ ⴵⴰⵏ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵢⴰⵀⵓⴷⴰ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵓⵔⵛⴰⵍⵉⵎ? ");
INSERT INTO rift_vpl VALUES ("MC1_6","034_1_6","MIC","1","6","6","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵙⴰⵎⴰⵔⵢⴰ ⴷ ⵍⵅⴰⵔⴱⴻⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⴷ ⴰⵎⴰⵔⵊⴻⵄ ⵎⴰⵏⵉ ⵖⴰ ⵥⵥⵓⵏ ⵜⴰⵣⴰⵢⴰⵔⵜ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵉⵥⵔⴰ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ, ⵓ ⴰⴷ ⵄⴰⵔⵔⵉⵖ ⵅ ⴷⵙⵓⵙⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MC1_7","034_1_7","MIC","1","7","7","ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⵉⵏⴻⵇⵛⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵍⴻⴷⴵⴻⵏⵜ ⵓ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⴷ ⵜⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵙ ⵉⵏⴻⵇⵛⴻⵏ ⴰⴷ ⵜⴻⵏⵜ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵏⴻⵛⵛ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰⵜ ⵜⵢⴰⵔⴻⵡ ⵉ-ⵜⴻⵏⵜ ⵣⵉ ⵍⵎⵓⵏⴻⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵓ ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏⵜ ⵄⴰⵡⴻⴷ ⴷ ⵍⵎⵓⵏⴻⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MC1_8","034_1_8","MIC","1","8","8","“ⵅ ⵓⵢⴰ ⴰⴷ ⵛⴻⴹⵏⴻⵖ ⵓ ⴰⴷ ⵡⵜⴻⵖ ⴰⴳⴻⵊⴷⵓⵔ, ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵙ ⵍⴻⵃⴼⴰ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⴰⴷ ⵙⵙⵎⵉⵄⵡⴻⵖ ⴰⵎ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ, ⵓ ⴰⴷ ⵙⵖⵓⵢⴻⵖ ⴰⵎ ⵢⴻⵙⵙⵉⵙ ⵏ ⵏⵏⵄⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MC1_9","034_1_9","MIC","1","9","9","ⵎⴰⵖⴰⵔ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⴻⵙ ⵏⴻⵇⵇⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵍ ⵢⴰⵀⵓⴷⴰ, ⵉⵡⴻⵙⵙⴻⵄ ⵍⵃⵓⴽⵎ ⴰⵍ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴰⵍ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MC1_10","034_1_10","MIC","1","10","10","ⵡⴰⵔ ⵜⵜⴱⴰⵔⵔⵃⴻⵎ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵊⴰⵜ, ⵡⴰⵔ ⵜᵉⵜⵜⵔⵓⵎ, ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⵙⵙⵉⵡⵉⵍ. ⴷⵉ ⴱⴰⵢⵜ-ⵍⵉ’ⴰⴼⵔⴰ ⵣⵓⵣⵣⴰⵔⴻⵖ ⴰⵛⴰⵍ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MC1_11","034_1_11","MIC","1","11","11","ⵄⴷⵓ, ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵛⴰⴼⵉⵔ, ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵓ ⵙ ⵍⴻⵃⵢⴰ. ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵚⴰⵏⴰⵏ ⵡⴰⵔ ⵜⴻⴼⴼⵉⵖ ⵛⴰ. ⵜⴰⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵏ ⴱⴰⵢⵜ-ⵀⴰ-ⵉⵟⵚⵉⵍ ⵜⴻⴽⴽⴻⵙ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴱⴻⴷⴷⵉ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MC1_12","034_1_12","MIC","1","12","12","ⵎⴰⵖⴰⵔ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⴰⵔⵓⵜ, ⵜᵉⵜⵜⴻⵇⵏⵓⵏⵏⵓⵢ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴻⵎⵎⵓⵔⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵅⴰⵔ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵍⵖⴰⵔ ⵏ ⵙⵉⴷⵉ, ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ.    ");
INSERT INTO rift_vpl VALUES ("MC1_13","034_1_13","MIC","1","13","13","ⵃⴻⵣⵣⵎⴻⵎ ⵉⵢⵙⴰⵏ ⵏ ⵜⴰⵣⵍⴰ ⵣⵣⴰⵜ ⵉ ⵓⴽⴰⵔⵔⵓ, ⴰ ⵛⴻⵎ, ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⴰⵅⵉⵛ! ⵏⴻⵜⵜⴰⵜ ⴷ ⴱⴻⵟⵟⵓ ⵏ ⴷⴷⴻⵏⴱ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵎⴰⵖⴰⵔ ⴷⴰⵢⴻⴽ ⵜⵜⵡⴰⴼⴻⵏ ⵉⵅⴻⵟⵟⴰⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MC1_14","034_1_14","MIC","1","14","14","ⵙ ⵓⵢⴰ ⴻⵡⵛ ⴰⵔⵔⵉⵖⴰⵍⵓⵜⴻⵏ ⵏ ⵓⵎⵙⴻⴱⴹⵉ ⵉ ⵎⵓⵔⴰⵛⴰⵜ-ⵊⴰⵜ! ⵜⵓⴷⵔⵉⵏ ⵏ ⴰⴽⵣⵉⴱ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵖⴻⵛⵛ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MC1_15","034_1_15","MIC","1","15","15","ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵎ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⵡⵔⵉⵜ, ⴰ ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵎⴰⵔⵉⵛⴰ! ⴰⵄⵓⴵⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵍ ⵖⴰⵔ ⵄⴰⴷⵓⵍⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("MC1_16","034_1_16","MIC","1","16","16","ⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴷ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ ⵓ ⵃⴻⴼⴼ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ ⵉⵄⵉⵣⵣⴻⵏ. ⴰⵔⵔ ⵜⴰⵇⴻⵛⵛⴰⵔⵜ ⵏⵏⴻⵎ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵎⴻⵛⵏⴰⵡ ⴰⴳⵉⴷⴻⵔ, ⵎⵉⵏⵣⵉ ⵜⵜⵡⴰⵡⵢⴻⵏ ⵣⵣⴰⵢⴻⵎ ⵖⴰⵔ ⵜⵎⴻⵃⴱⴰⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("MC2_1","034_2_1","MIC","2","1","1","“ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵎⵎⴰⵎⴻⵏ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵎⵎⴰⵎⴻⵏ ⴷⵉ ⵍⵖⴰⵔ ⴷⵉ ⵇⴰⵎⴰⵜ ⵏⵙⴻⵏ. ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⴰⴷ ⵜ ⴳⴳⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⴼⵓⵙ ⵏⵙⴻⵏ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵣⴻⵎⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MC2_2","034_2_2","MIC","2","2","2","ⵏⵉⵜⵏⵉ ⵎⵎⴻⵥⵍⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵜⴽⴻⵛⵛⴹⴻⵏ ⵜⴻⵏ ⵄⴰⵡⴻⴷ, ⵓⵍⴰ ⴷ ⵜⵓⴷⵔⵉⵏ, ⵓⵛⴰ ⵜⵜᵉⵟⵟⴼⴻⵏ ⵜⴻⵏⵜ. ⴰⵎⵎⵓ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⵙ ⵍⴻⵅⵛⵓⵏⴻⵜ ⵉ ⵡⴻⵔⵢⴰⵣ ⵓ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵀ, ⵉ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵓ ⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MC2_3","034_2_3","MIC","2","3","3","“ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵜⵡⴻⵏⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵅ ⵍⴰⴵ-ⴰ, ⵉ ⵣⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵊⴻⴱⴷⴻⵎ ⵉⵔⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵓ ⵉ ⵣⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵄⴰⴷ ⵙ ⵓⵄⴻⴼⴼⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MC2_4","034_2_4","MIC","2","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⵎⴰⵜⴰⵍ ⵓ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵏ ⵉⵊⵊ ⵏ ⵢⴻⵥⵔⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⴰⵎ ⵜⵜⵛⴻⵜⵛⴰⵏ, ⵓ ⴰⴷ ⵉⵏⵉⵏ: ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵇⴰⵄ! ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵉⴽⵙⵉ ⵣⵣⴰⵢⵉ? ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵏⴻⵖ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ! ");
INSERT INTO rift_vpl VALUES ("MC2_5","034_2_5","MIC","2","5","5","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⴹⴰⵔⴻⵏ ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵇⵢⴰⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⴷⴻⴳ ⵡⴻⴳⵔⴰⵡ ⵏ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("MC2_6","034_2_6","MIC","2","6","6","“‘ⵡⴰⵔ ⵙⵙⵓⴼⴼⵓⵖⴻⵎ ⴰⵡⴰⵍ ⴰⵎⵎⵓ ⵙ ⵓⴽⵓⴼⴼⵓ!’, ⴰⵎⵎⵓ ⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵎ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⴽⵓⴼⴼⵓ. ‘ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵡⴰⵍ ⵙ ⵓⴽⵓⴼⴼⵓ!’ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙⵙ! ");
INSERT INTO rift_vpl VALUES ("MC2_7","034_2_7","MIC","2","7","7","ⴰ ⴽⴻⵏⵏⵉⵡ, ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵢⴰ? ‘ⵎⴰ ⵉⵊⵊⴰ ⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ?’ ⵏⵉⵖ: ‘ⵎⴰ ⵜⵉⵏⴰ ⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ?’ ⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵍⵅⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵙ ⵜⵙⴻⴳⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("MC2_8","034_2_8","MIC","2","8","8","ⵎⴰⵛⴰ ⵄⴰⴷ ⵉⴷⴻⵏⵏⴰⴹ ⵉⴽⴽⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴻⵄⴷⵓ. ⵜⵇⴻⵍⵄⴻⵎ ⴰⵔⵔⵓⴹ ⴷ ⵓⴱⴰⵔⵜⴻⵙⵙⵓ ⵣⴻⴳ ⵉⵎⵙⴻⴱⵔⵉⴷⴻⵏ ⵉⵇⴻⴼⵍⴻⵏ ⵉ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵔⵉⵊⵉⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵄⵉⴼⴼⴻⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("MC2_9","034_2_9","MIC","2","9","9","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵓⴼⴼⵓⵖⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏⵜ ⵉⵄⵉⵣⵣⴻⵏ. ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵜⴻⴽⴽⵙⴻⵎ ⴰⵙⴻⵏ ⵜⴰⵍⵡⵉⵣⵜ ⵉⵏⵓ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MC2_10","034_2_10","MIC","2","10","10","ⴽⴽⴰⵔⴻⵎ ⵓ ⴰⴳⴳⵯⴻⵊⴻⵎ, ⵎⵉⵏⵣⵉ ⵡⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ! ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ, ⴰⴷ ⵜⴰⵡⵉ ⴰⵔⴻⴷⴷⴻⴵ, ⵡⴰⵀ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⵓⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("MC2_11","034_2_11","MIC","2","11","11","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊ ⵉⴹⴻⴼⴼⴰⵔ ⴰⵙⴻⵎⵎⵉⴹ, ⵉⵇⵇⴰⵔ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵓⵛⴰ ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⵓⴼⴼⵖⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵙ ⵓⴽⵓⴼⴼⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴱⵉⵏⵓ ⴷ ⵛⵛⵔⴰⴱ!’ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵏⴰⴱⵉ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵙ ⵓⴽⵓⴼⴼⵓ.” ");
INSERT INTO rift_vpl VALUES ("MC2_12","034_2_12","MIC","2","12","12","“ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰ ⵢⴰⵄⵇⵓⴱ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵖ ⵖⴰⵔⵉ ⵇⴰⵄ, ⵏⵉⵛⴰⵏ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵉⵙⵔⴰⵉⵍ. ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ ⴰⵎ ⵡⵓⴵⵉ ⵏ ⴱⵓⵚⵔⴰ, ⴰⵎ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵔⴻⴽⴽⵡⴰⵙⵜ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MC2_13","034_2_13","MIC","2","13","13","ⴰⵎⴼⴻⴵⴻⵇ ⴰⴷ ⵉⵣⵡⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴻⴵⵇⴻⵏ ⵓ ⴰⴷ ⵄⴷⵓⵏ ⵅ ⵜⴻⵡⵡⴰⵔⵜ, ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ. ⴰⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ ⴰⴷ ⵉⵣⵡⴰⵔ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ, ⵓ ⵙⵉⴷⵉ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC3_1","034_3_1","MIC","3","1","1","“ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ‘ⵙⵍⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵓ ⴽⴻⵏⵏⵉⵡ, ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ! ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵜⴰⵙⵖⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("MC3_2","034_3_2","MIC","3","2","2","ⵏⵉⵜⵏⵉ ⵛⴰⵔⵔⵀⴻⵏ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⵓ ⵜⵜⴻⵅⵙⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ! ⵏⵉⵜⵏⵉ ⴽⴽⵙⴻⵏ ⴰⵙⴻⵏ ⵜⵉⵍⵎⴻⵛⵜ ⵓⵍⴰ ⴷ ⴰⵢⵙⵓⵎ ⵅ ⵉⵖⵙⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC3_3","034_3_3","MIC","3","3","3","ⵡⴰⵀ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⴽⴽⵙⴻⵏ ⴰⵙⴻⵏ ⵜⵉⵍⵎⴻⵛⵜ ⵓⵛⴰ ⵜⵜⴰⵔⴻⵥⵥⴰⵏ ⵉⵖⵙⴰⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⵜⴻⵏ ⴰⵎ ⴷⵉ ⵎⴰⵔⵎⵉⵜⴰ, ⴰⵎ ⵡⴻⵢⵙⵓⵎ ⴷⴻⴳ ⵓⵟⴻⵏⵊⵉⵔ.” ");
INSERT INTO rift_vpl VALUES ("MC3_4","034_3_4","MIC","3","4","4","“ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵙⵖⵓⵢⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ. ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴼⴼⴰⵔ ⵓⴷⴻⵎ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵔ ⵉ ⵉⴳⴳⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC3_5","034_3_5","MIC","3","5","5","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵖⴰⵔⵔⴰⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔⵙⴻⵏ ⵄⴰⴷ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵉⵣⴻⵄⴼⴻⵏ ⵙ ⵜⴻⵖⵎⴰⵙ ⵏⵙⴻⵏ, ⴰⴷ ⵍⴰⵖⴰⵏ ‘ⵍⴻⵀⵏⴰ!’, ⵎⴰⵛⴰ ⴹⵉⴷⴷ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⴻⴳⴳ ⵡⴰⵍⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⴰⴷ ⵅⴰⵙ ⵇⴻⴷⴷⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("MC3_6","034_3_6","MIC","3","6","6","ⵙ ⵓⵢⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵜⴻⵡⴹⴰ ⴵⵉⵍⴻⵜ, ⴱⵍⴰ ⵍⴻⵡⵃⵉⵢ, ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵡⴹⴰ ⵜⴰⴵⴻⵙⵜ ⴱⵍⴰ ⵜⴰⴳⴻⵣⵣⴰⵏⵜ. ⴰⴷ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⴰⴷ ⵉⴱⴱⴰⵔⵛⴻⵏ ⵡⴰⵙⵙ ⵜⵉⵡⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC3_7","034_3_7","MIC","3","7","7","ⵉⵎⵡⴰⵍⴰⵡⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⵓ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵣⴻⵡⵖⵡⴻⵏ ⵙ ⵍⴻⵃⵢⴰ, ⵓ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵍⴻⵃⵃⴼⴻⵏ ⴰⵛⵍⴰⵖⴻⵎ ⵖⴰⵔ ⵓⵢⴻⵏⵛⵉⵛ, ⵎⵉⵏⵣⵉ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MC3_8","034_3_8","MIC","3","8","8","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵛⵛⵓⵔⴻⵖ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ, ⵓ ⵙ ⵍⵃⴻⵇⵇ ⴷ ⵜⴻⵔⵢⴰⵙⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵉ ⵢⴰⵄⵇⵓⴱ ⵅ ⵓⵅⴻⵟⵟⵓ ⵏⵏⴻⵙ ⵓ ⵉ ⵉⵙⵔⴰⵉⵍ ⵅ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MC3_9","034_3_9","MIC","3","9","9","“ⵙⵍⴻⵎ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵓ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵍⵃⴻⵇⵇ, ⵓ ⵙⵙⴼⴰⵔⵔⴰⵖⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵙⴻⴳⴳⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MC3_10","034_3_10","MIC","3","10","10","ⵉⵏⵏⵉ ⵉⴱⴻⵏⵏⴰⵏ ⵚⵉⵀⵢⵓⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⵓ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("MC3_11","034_3_11","MIC","3","11","11","ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴹⴻⴱⴱⴰⵔⴰⵏ ⴷⴷⵄⴰⵡⵉ ⵉ ⴰⵔⵔⴻⵛⵡⴻⵜ, ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵙ ⵍⵎⵓⵏⴻⵜ, ⵓ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴳⴻⵣⵣⴰⵏⴻⵏ ⵙ ⵜⵎⴻⵏⵢⴰⵜ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵙⵉⴷⵉ ⵅⵎⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵙⵉⴷⵉ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵖ? ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵍⴻⵇⵇⴻⴼ ⵍⵖⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("MC3_12","034_3_12","MIC","3","12","12","ⵙ ⵓⵢⴰ, ⴰⵇⴰ-ⵜⵜ ⵣⵣⴰⵢⵡⴻⵎ, ⴰⵇⴰ ⴰⴷ ⵛⴰⵔⵣⴻⵏ ⵚⵉⵀⵢⵓⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵢⵢⴰⵔ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵍⵅⴰⵔⴱⴻⵜ, ⵓ ⴰⴷⵔⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵍⴻⴳⵄⵓⴷⵉ ⵏ ⵡⴻⵣⵖⴰⵔ.”    ");
INSERT INTO rift_vpl VALUES ("MC4_1","034_4_1","MIC","4","1","1","“ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⴷⵔⴰⵔ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⴱⴻⴷⴷ ⵉⵎⵜⴻⵏ ⵅ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵉⴷⵓⵔⴰⵔ. ⴰⴷ ⵢⵉⵍⵉ ⵢⵓⵄⵍⴰ ⵅ ⵜⴻⵡⵔⵉⵔⵉⵏ, ⵓⵛⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC4_2","034_4_2","MIC","4","2","2","ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: “ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ ⵓ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵏⵓⵢⵓⵔ ⵏⴻⵛⵛⵉⵏ ⴷⴻⴳ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵣⵉ ⵚⵉⵀⵢⵓⵏ ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MC4_3","034_4_3","MIC","4","3","3","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⴰⴷ ⵉⵙⴻⴳⴳⴻⵎ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ, ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵍⴻⴳⵏⵓⵙ ⵉⴳⴳⵯⴻⵊⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵙⵢⵓⴼ ⵏⵙⴻⵏ ⴷ ⴷⴷⵓⵣⴰⵏ ⵓ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵙⴻⵏ ⴷ ⵍⴻⵎⵡⴰⵙ ⵏ ⵡⴻⵣⴱⴰⵔ. ⵡⴰⵔ ⵉⵙⵙⴳⵉⵄⵄⵉⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵄⴰⴷ ⵙⵙⵉⴼ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵍⴻⵎⵎⴷⴻⵏ ⵄⴰⴷ ⴰⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("MC4_4","034_4_4","MIC","4","4","4","ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵙⴰⴷⵓ ⵜⵣⴰⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵙⴰⴷⵓ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ, ⵎⴰⵖⴰⵔ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⵇⴰ ⵉⵏⵏⴰ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("MC4_5","034_4_5","MIC","4","5","5","“ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵓⵢⵓⵔⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("MC4_6","034_4_6","MIC","4","6","6","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⴰⴷ ⵢⴰⵔⵡⴻⵖ ⵎⵉⵏ ⵉⵇⴻⵊⴷⵃⴻⵏ, ⵓ ⴰⴷ ⵖⴰⵔⵉ ⵙⵙⵎⵓⵏⴻⵖ ⵎⵉⵏ ⵅ ⵓⵣⵣⵍⴻⵏ, ⵓ ⵡⵉ ⴷⵉ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MC4_7","034_4_7","MIC","4","7","7","ⵎⵉⵏ ⵉⵇⴻⵊⴷⵃⴻⵏ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⵍⴱⴰⵇⵉ, ⵓⵍⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵍ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MC4_8","034_4_8","MIC","4","8","8","ⵉ ⵛⴻⵎ, ⵎⵉⴳⴷⴰⵍ-ⵄⵉⴷⵔ, ⴰ ⵛⴻⵎ, ⵜⴰⵡⵔⵉⵔⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ! ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵜⴰⵙ, ⵡⴰⵀ, ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵜⴰⵙ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵜⴻⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("MC4_9","034_4_9","MIC","4","9","9","“ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵖⵓⵢⵢⵓⴷ ⴰⵎⵎⵓ ⵙ ⵊⵊⴻⵀⴷ? ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵎ ⵉⴵⵉ ⵓⵊⴻⴵⵉⴷ? ⵎⴰ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⵓⵎⵛⴰⵡⴰⵔ ⵏⵏⴻⵎ, ⴰⵇⴰ ⵉⵟⵟⴻⴼ ⵉ ⵛⴻⵎ ⵍⴻⵃⵔⵉⵇ ⴰⵎ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MC4_10","034_4_10","MIC","4","10","10","ⵖⵏⴻⵙ ⵓ ⵜⵄⴻⴱⴱⵣⴻⴷ, ⴰ ⵛⴻⵎ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⴰⵎ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉⵜⵜⴰⵔⵡⴻⵏ. ⵎⴰⵖⴰⵔ ⵡⴰⵅⵅⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⵜⵣⴻⴷⵖⴻⴷ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⴰⵍ ⴱⴰⴱⵉⵍ. ⵎⴰⵛⴰ ⴷⵉⵏ ⴰⴷ ⵜⵏⴻⵊⵎⴻⴷ, ⴷⵉⵏⵏⵉ ⴰⴷ ⵛⴻⵎ ⵉⴼⴻⴽⴽ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MC4_11","034_4_11","MIC","4","11","11","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵎⵓⵏⴻⵏ ⵅⴰⴽ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ. ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ!’ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵚⵉⵀⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MC4_12","034_4_12","MIC","4","12","12","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵉⵏⵡⴰⵢⴻⵏ ⵏ ⵙⵉⴷⵉ, ⵓ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ ⵛⴰ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵙ! ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵜⴻⵏ ⵖⴰⵔⴻⵙ ⴰⵎ ⵜⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷⴻⴳ ⵓⵏⴻⴷⵔⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MC4_13","034_4_13","MIC","4","13","13","“ⴽⴽⴰⵔ, ⵜⴻⵙⵙⴰⵔⴻⵡⵜⴻⴷ, ⴰ ⵛⴻⵎ, ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵢⵉⵛⵛ ⵏⵏⴻⵎ ⴷ ⵓⵣⵣⴰⵍ, ⵓ ⴰⴷ ⴰⵎ ⴳⴳⴻⵖ ⵜⵉⵛⴻⴹⵢⵉⵏ ⵏⵏⴻⵎ ⵣⵉ ⵏⵏⵃⴰⵙ, ⵓ ⵛⴻⵎ ⴰⴷ ⵜⵍⴻⴱⵣⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵃⴰⵔⵔⵎⴻⵖ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵉ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MC4_14","034_4_14","MIC","4","14","14","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵍⴻⵃⵎⴻⵎ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰ ⵛⴻⵎ ⵢⴻⴵⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⴱⴰⵏⴷⵉⵢⵢⴰ ⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ! ⵏⴻⵜⵜⴰ ⵉⵃⴻⵚⵚⴰⵔ ⴰⵏⴻⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴰⵜⴻⵏ ⵍⵇⴰⴹⵉ ⵏ ⵉⵙⵔⴰⵉⵍ ⵅ ⵓⵇⴰⴱⵙⵉ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ.” ");
INSERT INTO rift_vpl VALUES ("MC5_1","034_5_1","MIC","5","1","1","“ⵓ ⵛⴻⴽ, ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⵉⴼⵔⴰⵜⴰ, ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⵊⴰⵔ ⵍⵓⵍⵓⴼ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵇⴰ ⵣⵣⴰⵢⴻⴽ ⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ ⵉ ⵏⴻⵛⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵙⵔⴰⵉⵍ. ⴰⴱⴰⵏⵉ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ, ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MC5_2","034_5_2","MIC","5","2","2","ⵙ ⵓⵢⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⴻⵍⵍⴻⵎ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⴰⵇⴰ ⵜⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵏ, ⴰⵇⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵍⴱⴰⵇⵉ ⵏ ⵢⴰⵢⵜⵎⴰⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MC5_3","034_5_3","MIC","5","3","3","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴻⴷⴷ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏ ⵙⵉⴷⵉ, ⴷⵉ ⵍⵓⵄⵍⴰ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MC5_4","034_5_4","MIC","5","4","4","ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵀⵏⴰ.” “ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴰⵛⵛⵓⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ, ⵓ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵍⴻⵇⵚⵓⵔ ⵏⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵙ ⵏⴻⵙⵙⴻⵍⵇⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴷ ⵜⵎⴻⵏⵢⴰ ⵏ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵣⵉ ⵎⵉⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC5_5","034_5_5","MIC","5","5","5","ⵏⵉⵜⵏⵉ ⴰⴷ ⵃⴹⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵛⵛⵓⵔ ⵙ ⵙⵙⵉⴼ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵏⵉⵎⵔⵓⴷ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴰⵛⵛⵓⵔ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴰⵏⵉⵜⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ ⵓ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("MC5_6","034_5_6","MIC","5","6","6","“ⵍⴱⴰⵇⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵏⵏⴷⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵎⴻⵛⵏⴰⵡ ⵜⵉⴷⴷⵓⵎⵉⵏ ⵅ ⵡⴻⴼⵙⵓ ⴰⵣⵉⵣⴰ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓ ⵡⴰⵔ ⵉⵜⵜⵔⵉⵊⵉⵏ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MC5_7","034_5_7","MIC","5","7","7","ⵍⴱⴰⵇⵉ ⵏ ⵢⴰⵄⵇⵓⴱ ⴰⴷ ⵢⵉⵍⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⵎⴻⵛⵏⴰⵡ ⴰⵢⵔⴰⴷ ⵊⴰⵔ ⵍⵎⴰⵍ ⵏ ⵢⴻⵣⵖⴰⵔ, ⴰⵎⴻⵛⵏⴰⵡ ⴰⵢⵔⴰⴷ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵊⴰⵔ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ ⵏ ⵡⵓⴵⵉ, ⵡⴻⵏⵏⵉ, ⵅⵎⵉ ⵖⴰ ⵉⵄⴷⵓ, ⵉⵄⴻⴼⴼⴻⵙ ⵓ ⵉⵜⵜⵛⴰⵔⵔⴰⴳ ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⵖⴰ ⵉⴼⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC5_8","034_5_8","MIC","5","8","8","ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⵎⵃⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC5_9","034_5_9","MIC","5","9","9","“ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵉⵢⵙⴰⵏ ⵏⵏⴻⵛ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵙⵙⵀⴻⵍⵍⴽⴻⵖ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MC5_10","034_5_10","MIC","5","10","10","ⴰⴷ ⵎⵃⵉⵖ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MC5_11","034_5_11","MIC","5","11","11","ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⵜⴰⵙⴻⵃⵃⴰⵔⵜ ⵏⵏⴻⵛ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵎ ⵓ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⵉⴱⴻⵣⴳⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC5_12","034_5_12","MIC","5","12","12","ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏⵏⴻⵎ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵉⵎⴰⵢⴹⵓⵜⴻⵏ ⵏⵏⴻⵛ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵎⵃⵉⵖ ⵣⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⵏⴷⴰⵇⴻⴷ ⵄⴰⴷ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MC5_13","034_5_13","MIC","5","13","13","ⵓ ⵜⵉⵔⴻⴱⴱⵉⵏ ⵏⵏⴻⵛ ⵏ ⵛⵡⴰⵔⵜⵉ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⵃⵃⵉⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵛ. ⵎⴰⵛⴰ ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ");
INSERT INTO rift_vpl VALUES ("MC5_14","034_5_14","MIC","5","14","14","ⵓⵛⴰ ⴰⴷ ⵏⵜⴰⵇⵎⴻⵖ ⵙ ⵡⴻⵖⴹⴰⴱ ⵓ ⵙ ⵡⴻⵙⵄⴰⵔ ⵅ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC6_1","034_6_1","MIC","6","1","1","“ⵙⵍⴻⵎ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ⴽⴽⴰⵔ, ⵛⴰⵔⵔⴻⵄ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵉⴷⵓⵔⴰⵔ, ⵓ ⴻⵊⵊ ⵜⵉⵡⵔⵉⵔⵉⵏ ⴰⴷ ⵙⵍⴻⵏⵜ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("MC6_2","034_6_2","MIC","6","2","2","ⵙⵍⴻⵎ, ⴰ ⵉⴷⵓⵔⴰⵔ, ⵉ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⴷⵙⵓⵙⴰ ⵉⵎⴻⵜⵏⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⴷⴷⴻⵄⵡⴻⵜ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵏⴻⵜⵜⴰ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⴰⴽ-ⴷ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("MC6_3","034_6_3","MIC","6","3","3","“ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⵉⵏ ⴷ ⴰⵛ ⴳⴳⵉⵖ, ⵓ ⵙ ⵎⴰⵏⵜⴻⵏ ⵉ ⵣⵉ ⵛⴻⴽ ⵙⵙⵉⵃⵍⴻⵖ? ⵛⴻⵀⵀⴻⴷ ⴹⵉⴷⴷ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("MC6_4","034_6_4","MIC","6","4","4","ⵏⴻⵛⵛ ⵏⴻⴷⵀⴻⵖ ⵛⴻⴽ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵎⵓⵙⴰ ⴷ ⵀⴰⵔⵓⵏ ⴷ ⵎⴰⵔⵢⴰⵎ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MC6_5","034_6_5","MIC","6","5","5","ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴼⴻⴽⴽⴰⵔ ⵎⵍⵉⵃ ⴷⵉ ⵍⵖⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⵏⴻⴽⴽⵯⴰ ⴰⴷ ⵢⴻⴳⴳ ⴱⴰⵍⴰⴽ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵓ’ⴰⴱ, ⵓ ⴷⵉ ⵎⵉⵏ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⴰ ⴱⵉⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵄⵓⵔ ⵓ ⴷⵉ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵣⵉ ⵛⵉⵟⵟⵉⵎ ⴰⵍ ⵊⵉⵍⵊⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("MC6_6","034_6_6","MIC","6","6","6","“ⵙ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⴰⴷ ⵎⵎⴻⵍⵇⵉⵖ ⴰⴽ-ⴷ ⵙⵉⴷⵉ, ⴰⴷ ⴰⴹⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵢⵓⵄⵍⴰⵏ? ⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴷ ⵜ ⵎⵎⴻⵍⵇⵉⵖ ⵙ ⵜⵖⴰⵔⵚⴰ ⵏ ⵡⴻⵛⵎⴰⴹ, ⵏⵉⵖ ⵙ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("MC6_7","034_6_7","MIC","6","7","7","ⵎⴰ ⴰⴷ ⵢⴰⵔⴹⴰ ⵙⵉⴷⵉ ⵙ ⵍⵓⵍⵓⴼ ⵏ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ, ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵜⵖⴻⵣⵔⴰⵜⵉⵏ ⵏ ⵣⵣⴻⵛⵜ? ⵎⴰ ⴰⴷ ⵡⵛⴻⵖ ⴰⵎⴻⵏⵣⵓ ⵉⵏⵓ ⵉ ⵓⵅⴻⵟⵟⵓ ⵉⵏⵓ, ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ ⵉ ⴷⴷⵏⵓⴱ ⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("MC6_8","034_6_8","MIC","6","8","8","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ ⵛⴻⴽ, ⴰ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏ ⵉⵛⵏⴰⵏ, ⵓ ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⴻⵜⵜⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵍⵅⴰⵔ, ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ, ⵓ ⴰⴷ ⵜⵓⵢⵓⵔⴻⴷ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵙ ⵓⵡⴰⴹⴻⵄ!” ");
INSERT INTO rift_vpl VALUES ("MC6_9","034_6_9","MIC","6","9","9","“ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ ⵜᵉⵜⵜⵍⴰⵖⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵓⴼⴻⴽⴽⵉ. ⵙⵍⴻⵎ ⵉ ⵡⴻⵄⵎⵓⴷ ⵓ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵉⵙⵙⴻⴽⴽⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("MC6_10","034_6_10","MIC","6","10","10","ⵎⴰ ⴷⵉⵏ ⵄⴰⴷ ⵍⴻⵅⵣⵉⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵖⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⵍⵎⵓⴷ ⵏ ⵉⴼⴰ ⵉⵏⵇⴻⵚ? ");
INSERT INTO rift_vpl VALUES ("MC6_11","034_6_11","MIC","6","11","11","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵙ ⵍⵎⵉⵣⴰⵏⴰⵜ ⵏ ⵍⵖⴰⵔ, ⵓ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⴻⵛⵢⴰⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⵡⵣⵏⴰⵜ ⵉⵖⴻⵛⵛⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MC6_12","034_6_12","MIC","6","12","12","ⴰⵢⵜ ⴱⵓ-ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴰⵇⴰ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⵄⵓⵏⴼ, ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵇⵇⴰⵔⴻⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓ ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⴰⵇⴰ ⵉⵜⵜⵖⴻⵛⵛⴰ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC6_13","034_6_13","MIC","6","13","13","“ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⵇⴰ ⵊⴰⵔⵃⴻⵖ ⵛⴻⵎ ⵙ ⵜⴻⵢⵢⵉⵜⴰ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MC6_14","034_6_14","MIC","6","14","14","ⴰⴷ ⵜⴻⵛⵛⴻⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵊⵉⵡⵉⵏⴻⴷ, ⵓ ⴰⴷ ⴷⴰⵢⴻⵎ ⵢⵉⵍⵉ ⵍⴰⵥ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵎ. ⴰⴷ ⵜⴻⴼⴼⵖⴻⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵏⴻⵊⵊⵎⴻⴷ, ⵓ ⵎⵉⵏ ⵉⵏⴻⵊⵎⴻⵏ, ⴰⴷ ⵜ ⵙⵙⴻⵄⴷⵓⵖ ⵉ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("MC6_15","034_6_15","MIC","6","15","15","ⴳⴳⵓⵔ ⴰⴷ ⵜⵣⴰⵔⵄⴻⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵎⴻⵊⵊⴰⵔⴻⴷ, ⴰⴷ ⵜⴻⴷⴷⵣⴻⴷ ⴰⵥⴻⵎⵎⵓⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴷⴻⵀⵀⵏⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵙ ⵣⵣⴻⵛⵜ ⴰⴷ ⵜⵥⴻⵎⵎⴻⴷ ⵓⵍⴰ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵣⴻⴳ ⵓⴹⵉⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵙⵙⴻⵙⵙⴻⴷ ⴱⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MC6_16","034_6_16","MIC","6","16","16","ⵎⴰⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵃⴻⵟⵟⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵄⵓⵎⵔⵉ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵅⴰⴱ, ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⴹⴻⴼⴼⴰⵔⴻⵎ ⵍⴻⵛⵡⴰⵔ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵢⴰⵔⵔⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵉ ⵓⵙⴻⵎⵥⵉ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴰⵔⴱⵓⵎ ⵍⵃⴻⴳⵔⴰ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("MC7_1","034_7_1","MIC","7","1","1","“ⵓⵛⵜ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵢⵉ ⵖⴰⵔⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵖⴰⵔ ⵜⵎⴻⵢⵔⴰ ⵏ ⵜⵉⵏⵉ ⵏ ⵓⵏⴻⴱⴷⵓ, ⴰⵎⴻⵛⵏⴰⵡ ⵖⴰⵔ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴻⵍⵇⴰⴹ ⵏ ⵓⴹⵉⵍ: ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⴽⴽⵓⵏ ⵏ ⵓⴹⵉⵍ ⵉ ⵎⴰⵛⵛⴰ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴱⴰⵛⵓⵔ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ ⵉ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MC7_2","034_7_2","MIC","7","2","2","ⴰⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉ ⴷⴰⵢⴻⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵚⴻⴱⵃⴰⵏ ⵊⴰⵔ ⵉⵡⴷⴰⵏ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵃⴰⵎⴰⵏ ⵅ ⵉⴷⴰⵎⵎⴻⵏ, ⵉⵊⵊⴻⵏ ⵉⵢⴻⵎⵎⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵜⵔⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MC7_3","034_7_3","MIC","7","3","3","ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵡⴻⵊⴷⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⵖⴰⵔ. ⵍⵃⴰⴽⴻⵎ ⵉⵜⵜⴰⵔ ⵓ ⵍⵇⴰⴹⵉ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵅⴻⴵⴻⵚ, ⵓ ⵡⴻⵏⵏⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵙⵙⴰⵡⴰⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴻⵥⵔⵉ ⴰⵄⴻⴼⴼⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵓ ⴰⵎⵎⵓ ⵉ ⵙⵙⴼⴰⵔⵖⴻⵏ ⵏⵉⵜⵏⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MC7_4","034_7_4","MIC","7","4","4","ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⴰⵟⵟⴰⵙ ⴰⵇⴰ-ⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵛⴱⴰⵔⵇ ⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵚⴷⵉⵇ ⵏ ⵡⵓⵍ ⵇⴰⵄ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵇⴰ-ⵜ ⵎⴰⵀⵓ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⴼⵔⴰⵢ ⵏ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ⴰⵙⵙ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏⵏⴻⵛ, ⴰⵙⵙ ⵏ ⵓⵅⴻⴵⴻⵚ, ⵢⵓⵙⴰ-ⴷⴷ. ⵍⴻⵅⵅⵓ ⴰⴷ ⵏⵅⴻⵍⵄⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC7_5","034_7_5","MIC","7","5","5","“ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵛⵍⴻⴷ ⵅ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ ⵉⵄⵉⵣⵣⴻⵏ. ⵃⴹⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵣⵉ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MC7_6","034_7_6","MIC","7","6","6","ⵎⴰⵖⴰⵔ ⵎⵎⵉⵙ ⵉⵙⵙⴻⵃⵇⴰⵔⴰ ⴱⴰⴱⴰⵙ, ⵢⴻⴵⵉⵙ ⵜᵉⵜⵜⴹⴰⴷⴷⴰ ⵢⴻⵎⵎⴰⵙ, ⵜⴰⵙⵍⵉⵜ ⵅ ⵍⴰⵍⵍⴰⵙ, ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵇⴰ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MC7_7","034_7_7","MIC","7","7","7","“ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵅⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵔⴰⵊⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MC7_8","034_7_8","MIC","7","8","8","“ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵙⴼⴰⵔⵔⴻⵃ, ⴰ ⵛⴻⵎ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⴷ ⵍⴻⵄⴷⵓ ⵉⵏⵓ! ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵡⴹⵉⵖ, ⴰⴷ ⴽⴽⴰⵔⴻⵖ ⵄⴰⵡⴻⴷ, ⵎⴰⵍⴰ ⵇⵇⵉⵎⴻⵖ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("MC7_9","034_7_9","MIC","7","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴽⵙⵉⵖ ⴰⵙⵅⴻⴹ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵅⴹⵉⵖ ⴰⴽⵉⴷⴻⵙ, ⴰⵍ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵉⵡⵡⴻⵜ ⵏⴻⵜⵜⴰ ⵅ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ ⵓ ⴰⴷ ⴰⵢⵉ ⵢⴰⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵖⴰⵔ ⵜⴼⴰⵡⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵥⴰⵔⴻⵖ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MC7_10","034_7_10","MIC","7","10","10","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⴷ ⵍⴻⵄⴷⵓ ⵉⵏⵓ ⴰⴷ ⵜⵥⴰⵔ ⴰⵢⴰ. ⵎⵍⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵜⴷⴻⵍ ⵍⴻⵃⵢⴰ ⵉ ⵜⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ?’ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⴰⴷ ⵖⴰⵔⴻⵙ ⵅⵣⴰⵔⴻⵏⵜ! ⵍⴻⵅⵅⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴷⴷⴻⵣ ⵏⴻⵜⵜⴰⵜ, ⴰⵎ ⵓⴱⴻⴵⴰⵄ ⴷⵉ ⵣⵣⵏⴰⵇⵉ.” ");
INSERT INTO rift_vpl VALUES ("MC7_11","034_7_11","MIC","7","11","11","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⴱⵏⴰ ⵏⴻⵜⵜⴰ ⵍⴻⵃⵢⵓⴹ ⵏⵏⴻⵛ ⵄⴰⵡⴻⴷ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵔⴰⵃ ⵍⵃⴻⵇⵇ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MC7_12","034_7_12","MIC","7","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ, ⵣⵉ ⴰⵛⵛⵓⵔ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵎⵉⵚⵔⴰ, ⵓ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵍ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ, ⵓ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵍ ⵍⴻⴱⵃⴰⵔ ⵓ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⴰⵍ ⵡⴻⴷⵔⴰⵔ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MC7_13","034_7_13","MIC","7","13","13","ⵎⴰⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC7_14","034_7_14","MIC","7","14","14","“ⴰⵔⵡⴻⵙ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵙ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵛ, ⵓⴵⵉ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵡⴻⵃⵃⴷⴻⵙ ⴷⴻⴳ ⵡⴻⵣⵖⴰⵔ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴽⴰⵔⵎⵉⵍ. ⴻⵊⵊ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⴰⵔⴻⵡⵙⴻⵏ ⴷⵉ ⴱⴰⵛⴰⵏ ⴷ ⵊⵉⵍⵄⴰⴷ, ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MC7_15","034_7_15","MIC","7","15","15","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵛⵏⴻⵖ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ, ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MC7_16","034_7_16","MIC","7","16","16","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵜ ⵜⵡⴰⵍⵉⵏ, ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴰⴼⵓⵙ ⵅ ⵓⵇⴻⵎⵎⵓⵎ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴷⵓⵀⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC7_17","034_7_17","MIC","7","17","17","ⵏⵉⵜⵏⵉ ⴰⴷ ⵍⴻⵙⵃⴻⵏ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⴰⵎ ⵓⴼⵉⵖⴰⵔ, ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵍⴱⵓⵔⵊⴰⵜ ⵏⵙⴻⵏ ⴰⵎ ⵉⵎⵓⴷⴷⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⴱⵓⵄⴻⵏ. ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⴳⴳⵯⴻⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MC7_18","034_7_18","MIC","7","18","18","“ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵖⴻⴼⴼⴰⵔⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵡⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ ⵅ ⵓⵅⴻⵟⵟⵓ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ? ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵎⴻⵏⵏⴻⵄ ⵉ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵢⴰⵔⴹⴰ ⴰⵙ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MC7_19","034_7_19","MIC","7","19","19","ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵢⴰⵔⵃⴻⵎ ⵄⴰⵡⴻⴷ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⴼⴻⵙ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵖ, ⵡⴰⵀ, ⵛⴻⴽ ⴰⴷ ⵜⴻⵏⴹⴰⵔⴻⴷ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MC7_20","034_7_20","MIC","7","20","20","ⵉⵍⵉ ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵍⴰⵎⴰⵏ ⵉ ⵢⴰⵄⵇⵓⴱ ⵓ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("NM1_1","035_1_1","NAM","1","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵅ ⵏⵉⵏⵡⴰ. ⴰⴷⵍⵉⵙ ⵏ ⵍⴻⵡⵃⵉⵢ ⵏ ⵏⴰⵃⵓⵎ, ⴰⵍⵇⵓⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("NM1_2","035_1_2","NAM","1","2","2","ⴰⵍⵉⴼ. - ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴰⵙⵎⴻⵏ ⵓ ⵙⵉⴷⵉ ⵉⵏⵜⴰⵇⴰⵎ, ⵙⵉⴷⵉ ⴷ ⴰⵏⴻⵇⵇⴰⵎ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱ ⵏ ⵡⴻⵙⵄⴰⵔ. ⵙⵉⴷⵉ ⴷ ⴰⵏⴻⵇⵇⴰⵎ ⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("NM1_3","035_1_3","NAM","1","3","3","ⵙⵉⴷⵉ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵓ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔ ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴱⴰⵔⵔⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⴻⵏⴱ. ⴱⵉⵜ. ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵓ ⴷⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NM1_4","035_1_4","NAM","1","4","4","ⴳⵉⵎⴻⵍ. - ⵏⴻⵜⵜⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵍⴻⴱⵃⴰⵔ, ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜ ⵢⵓⵥⴻⵖ, ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⵔⴰⵏ ⵉⵜⵜⴻⵊⵊⴰ ⵉ-ⵜⴻⵏ ⵜⵜⴰⵥⵖⴻⵏ. ⴷⴰⵍⵉⵜ. ⴱⴰⵛⴰⵏ ⴷ ⴽⴰⵔⵎⴰⵍ ⵙⵍⴰⵡⴻⵏ, ⵓⵍⴰ ⴷ ⵏⵏⵓⵡⴰⵔ ⵏ ⵍⵓⴱⵏⴰⵏ ⵉⵙⵍⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("NM1_5","035_1_5","NAM","1","5","5","ⵀⵉ. - ⵉⴷⵓⵔⴰⵔ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵣⵣⴰⵢⴻⵙ, ⵓ ⵜⵉⵡⵔⵉⵔⵉⵏ ⴼⴻⵙⵙⵢⴻⵏⵜ, ⵡⴰⵡ. ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵡⵉ ⵅⴰⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("NM1_6","035_1_6","NAM","1","6","6","ⵣⴰⵢⵉⵏ. - ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⴻⵙⵅⴻⴹ ⵏⵏⴻⵙ, ⵓ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴽⴽⴰⵔ ⵣⵣⴰⵜ ⵉ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ? ⵅⵉⵜ. ⴰⵙⵄⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴽⴻⴱⴱ-ⴷⴷ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵓ ⵜⵉⵚⵓⴹⴰⵔ ⵜⵜⵡⴰⵇⴻⴵⵄⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("NM1_7","035_1_7","NAM","1","7","7","ⵜⵉⵜ. - ⵉⵛⵏⴰ ⵙⵉⴷⵉ ⵉ ⴷⴷⵓⵔⵔⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ. ⵢⵓⴷ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵢⴰⵔⴻⴽⴽⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM1_8","035_1_8","NAM","1","8","8","ⴽⴰⴼ. - ⵙ ⵢⵉⵛⵜ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⵉⴼⴻⵢⵢⴹⴻⵏ ⴰⴷ ⵢⵓⵇⴰ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵉⴹⴼⴰⵔ, ⴰⵍ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("NM1_9","035_1_9","NAM","1","9","9","ⵎⵉⵎ. - ⵎⵉⵏ ⵜⵅⴰⵔⵔⵚⴻⵎ ⵅⴻⵏⵏⵉ ⵅ ⵙⵉⴷⵉ? ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵇⴹⴰ ⵇⴰⵄ. ⴰⵖⵓⴼⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM1_10","035_1_10","NAM","1","10","10","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵎⵓⴷⴻⵏ ⵄⴰⴷ ⴰⵎ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵓ ⵖⴻⵍⵍⴰⵏ ⴰⵎ ⵢⵉⵎⴻⵙⵛⴰⵔⴻⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵜⵡⴰⵛⵛⴻⵏ ⵏⵉⵜⵏⵉ ⵇⴰⵄ ⴰⵎ ⵓⵍⵓⵎ ⵢⵓⵥⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM1_11","035_1_11","NAM","1","11","11","ⵣⵣⴰⵢⴻⴽ ⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴰⵔⵔⵚⴻⵏ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵅ ⵙⵉⴷⵉ, ⴰⵎⵛⴰⵡⴰⵔ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("NM1_12","035_1_12","NAM","1","12","12","ⴰⵎⵎⵓ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ: ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴼⴻⵍⵃⴻⵏ ⵓ ⴵⴰⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵄⴷⵓ. ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵅⴰⴽ ⴰⵖⵉⵍ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⴽ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵖⵉⵍ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("NM1_13","035_1_13","NAM","1","13","13","ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵣⴰⵢⵍⵓ ⵏⵏⴻⵙ ⵉ ⵅⴰⴽ ⵉⵎⵎⴰⵔⵙⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴰⵔⵔⴳⴻⵖ ⵜⵉⵙⵖⵓⵏⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NM1_14","035_1_14","NAM","1","14","14","ⵙⵉⴷⵉ ⵉⵡⴻⵚⵚⴰ ⵅⴰⴽ, ⴰⵇⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵃⴻⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⵏⴻⵇⵛⴻⵏ ⴷ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉⴼⴻⵙⵢⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⴰⵏⴹⴻⵍ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵓⴼⵉⵖ ⵛⴻⴽ ⵜⴻⴼⵙⵓⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("NM2_1","035_2_1","NAM","2","1","1","ⵅⵣⴰⵔ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵡⴻⵏⵏⵉ ⵉⵅⴻⴱⴱⴰⵔⴻⵏ ⵙ ⵍⴻⵀⵏⴰ. ⵄⴻⵢⵢⴻⴷ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏⵏⴻⵛ, ⴰ ⵢⴰⵀⵓⴷⴰ, ⵙⴻⵇⴼⴻⵍ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵉⵥⴻⴽⴽⵡⵉ ⵅⴰⴽ ⵄⴰⴷ, ⵏⴻⵜⵜⴰ ⵉⵏⵏⴻⵇⴹⴻⵄ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NM2_2","035_2_2","NAM","2","2","2","ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵢⵓⵥⵥⵍⴻⵏ ⵅ ⵉⵡⴷⴰⵏ ⵙ ⵍⵄⵓⵏⴼ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵅⴰⴽ! ⵄⴻⵙⵙ ⵅ ⵍⴱⵓⵔⵊ, ⵃⴹⴰ ⴰⴱⵔⵉⴷ, ⵙⴻⵎⵃⴻⴹ ⵜⵉⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵛ, ⴰⵔⵏⵉ ⴷⵉ ⵊⵊⵀⴻⴷ ⵏⵏⴻⵛ! ");
INSERT INTO rift_vpl VALUES ("NM2_3","035_2_3","NAM","2","3","3","ⵙ ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵍⵄⴻⵣⵣ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵄⴻⵣⵣ ⵏ ⵉⵙⵔⴰⵉⵍ. ⵎⴰⵖⴰⵔ ⵉⴽⴻⵛⵛⴰⴹⴻⵏ ⴽⴻⵛⵛⴹⴻⵏ ⵜⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⵖⴻⴹⵍⴻⵏ ⵜⵉⵣⴻⵔⵎⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM2_4","035_2_4","NAM","2","4","4","ⵜⵛⴰⴱⴱⴰⵜ ⵏ ⵓⵙⴻⵍⵇⵉ ⵏ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵣⴻⵡⵖⴻⵏⵜ, ⵉⵔⵢⴰⵣⴻⵏ ⵉⵎⴻⵃⴹⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⵙ ⵡⴰⵔⵔⵓⴹ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵖⴰⵔ ⵜⴻⵙⵙⵉⵇⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵓⵎⴻⵔⵣⵉ ⴰⴷ ⵏⵏⵀⴻⵣⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM2_5","035_2_5","NAM","2","5","5","ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵀⴰⵊⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ, ⴰⵇⴰ ⵥⵥⴻⵄⵡⴰⴹⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⴰ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ, ⵜⵜⵡⴰⴹⵀⴰⵔⴻⵏ ⴰⵎ ⵢⵉⵚⴻⴼⴹⴰⵡⴻⵏ, ⵏⵉⵜⵏⵉ ⴳⴻⵎⵎⴰⵔⴻⵏ ⴷⴰ ⴷ ⴷⵉⵀⴰ ⴰⵎ ⵡⴰⵙⵙⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM2_6","035_2_6","NAM","2","6","6","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ, ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵜⵜⵏⴻⵇⵔⴰⴹⴻⵏ ⴰⵎ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵍⵃⵉⴹ ⵏⵙⴻⵏ, ⵎⴰⵏⵉ ⵉⴱⴻⴷⴷ ⵙⵙⵇⴻⴼ ⵏ ⵓⵀⵊⴰⵎ ⵉⵡⵊⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("NM2_7","035_2_7","NAM","2","7","7","ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏⵏⵓⵔⴻⵣⵎⴻⵏⵜ, ⵓ ⵍⴻⵇⵚⴰⵔ ⴰⴷ ⵉⴼⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("NM2_8","035_2_8","NAM","2","8","8","ⴰⵇⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜⴱⴻⴷⴷ ⵏⵉⵛⴰⵏ! ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ, ⵓ ⵜⵉⵢⵢⴰ ⵏⵏⴻⵙ ⵙⵖⵓⵢⵢⵓⵏⵜ ⴰⵎⴻⵛⵏⴰⵡ ⴰⴱⴰⵔⵔⵉ ⵏ ⵜⴻⴷⴱⵉⵔⵉⵏ, ⴰⵎ ⵛⵛⴰⵜⴻⵏⵜ ⴷⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("NM2_9","035_2_9","NAM","2","9","9","ⵏⵉⵏⵡⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵢⴻⵍⵎⴰⵎ ⵏ ⵡⴰⵎⴰⵏ ⵣⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉⴵⴰ. ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⴰⵔⴻⴽⴽⵡⴻⵍⴻⵏ ⵏⵉⵜⵏⵉ. ⴱⴻⴷⴷⴻⵎ! ⴱⴻⴷⴷⴻⵎ!, ⵜⵜⵍⴰⵖⴰⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵏⴻⵇⵍⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("NM2_10","035_2_10","NAM","2","10","10","ⴽⴻⵛⵛⴹⴻⵎ ⵏⵏⵓⵇⴰⵔⵜ, ⴽⴻⵛⵛⴹⴻⵎ ⵓⵔⴻⵖ! ⵡⴰⵔ ⴷⵉⵏ ⵇⴻⵟⵟⵓ ⵉ ⵍⴻⴽⵏⵓⵣ, ⵖⴰⵔ ⵓⵛⴻⵡⵡⴰⵔ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵇⵛⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("NM2_11","035_2_11","NAM","2","11","11","ⵜⴻⵅⵡⴰ, ⵜᵉⵜⵜⵡⴰⴽⴻⵛⵛⴻⴹ ⵓ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵏⴻⵜⵜⴰⵜ, ⵓⵍ ⵉⴼⵙⵉ ⵓⵛⴰ ⵉⴼⴰⴷⴷⴻⵏ ⴼⴻⵛⵍⴻⵏ, ⵜⵜⴻⴽⴽⵙⴻⵏⵜ ⴰⵙ ⵜⵉⵊⵄⵉⵏⵏⴰ ⵎⴰⵔⵔⴰ ⵓ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵡⴰⵔⵖⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("NM2_12","035_2_12","NAM","2","12","12","ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⴻⵅⵅⵓ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ, ⴷ ⵍⵎⴻⴷⵡⴻⵍ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵎⴰⵏⵉ ⵢⵓⵢⵓⵔ ⵡⴻⵢⵔⴰⴷ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵢⵔⴰⴷⵜ ⴰⴽ-ⴷ ⵡⴻⵢⵔⴰⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉⵙⵙⵏⴻⵅⵍⴻⵄ ⵉ-ⵜⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("NM2_13","035_2_13","NAM","2","13","13","ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⴻⵅⵅⵓ ⵡⴰⵢⵔⴰⴷ ⵏⵏⵉ ⵉⵎⴻⵣⵣⵇⴻⵏ ⵎⵉⵏ ⵃⴷⴰⵊⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓ ⵉⵊⴻⵢⵢⴻⴼ ⵉ ⵜⴰⵢⵔⴰⴷⵉⵏ ⵏⵏⴻⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵉⴼⵔⴰⵏ ⵏⵏⴻⵙ ⵙ ⵓⴽⴻⵛⵛⴻⴹ, ⴷ ⵉⵎⵓⵛⴰⵏ ⵏⵏⴻⵙ ⵏ ⵓⴷⵓⵔⵔⵉ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴳⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("NM2_14","035_2_14","NAM","2","14","14","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⵅⴰⴽ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵛ ⴷ ⴷⴷⴻⵅⵅⴰⵏ. ⴰⴷ ⵛⵛⴻⵖ ⵙⵙⵉⴼ ⵉⵢⵔⴰⴷⴻⵏ ⵏⵏⴻⵛ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵇⴻⴹⵄⴻⵖ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵛ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NM3_1","035_3_1","NAM","3","1","1","ⵓⵛⵜ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ! ⴰⵇⴰ-ⵜⵜ ⴷ ⴰⵅⴰⵔⵔⵉⵇ ⴷ ⵍⵄⵓⵏⴼ ⵎⴰⵔⵔⴰ, ⵜⵓⴽⴽⴰⵔⴹⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⴷⴷⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("NM3_2","035_3_2","NAM","3","2","2","ⵍⵃⴻⵙⵙ ⵏ ⵓⵔⴻⴽⴽⵓⴹ, ⵍⵃⴻⵙⵙ ⵏ ⵓⵇⴰⵔⵇⴻⴱ ⵏ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ, ⵉⵢⵙⴰⵏ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵉⵏⴻⵟⵟⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM3_3","035_3_3","NAM","3","3","3","ⴰⵎⴻⵏⵏⴰⵢ ⵉⵏⵢⴰ, ⵙⵙⵉⴼ ⵉⵜⵜⵡⴻⵙⵙⴻⴳ, ⴼⵍⵉⵜⵛⴰ ⴰⵇⴰ-ⵜⵜ ⴰⵎ ⵡⴰⵙⵙⴰⵎ. ⴰⵟⵟⴰⵙ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵄⵓⵔⵔⵉⵛ ⵏ ⵉⵎⴻⵜⵜⴰⵏ, ⵍⵅⴻⵛⴱⴰⵜ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏⵜ ⵍⵃⴻⴷ, ⵡⴰⵀ, ⵜⵜⴻⵏⵇⵔⴰⴹⴻⵏ ⴷⵉ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("NM3_4","035_3_4","NAM","3","4","4","ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵍⵎⵓⵃⴻⵙⵏⴰ, ⵏ ⵍⴰⵍⵍⴰ ⵏ ⵜⵙⴻⵃⵃⴰⵔⵜ, ⵜⴻⵏⵏⵉ ⵉⵣⵣⵏⵓⵣⴰⵏ ⵍⴻⴳⵏⵓⵙ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵙ ⵓⵙⴻⵃⵃⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("NM3_5","035_3_5","NAM","3","5","5","ⵅⵣⴰⵔ, ⵙ ⵓⵢⴰ ⴰⴷ ⵅⴰⵎ ⵉⵍⵉⵖ, ⴰⵎⵎⵓ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵎⵓⵡⵡⴰ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵎ ⵜⵉⵡⵡⴰ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵎ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⵉ ⵍⴻⴳⵏⵓⵙ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏⵏⴻⵎ, ⵓ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵏⴻⵎ ⵉ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("NM3_6","035_3_6","NAM","3","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵎ ⵍⴻⵇⴼⴻⵖ ⵙ ⵏⵏⵄⴰⵡⴰⵜ, ⵓ ⴰⴷ ⵛⴻⵎ ⵙⵙⴼⴻⴹⵃⴻⵖ ⵓ ⴰⴷ ⵛⴻⵎ ⴰⵔⵔⴻⵖ ⵉ ⵓⵙⴼⵓⵔⵔⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("NM3_7","035_3_7","NAM","3","7","7","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵎⴰⵏ ⵡⴻⵏ ⵛⴻⵎ ⵉ ⵖⴰ ⵉⵥⴰⵔⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵢⴰⵔⵡⴻⵍ, ⴰⴷ ⵢⵉⵏⵉ “ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵏⵉⵏⵡⴰ ⵜⵅⴰⵔⵔⴻⴱ! ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵛⴻⴹⵏⴻⵏ?” ⵎⴰⵏⵉ ⴷ ⴰⵎ ⵉ ⵖⴰ ⵢⴰⵔⵣⵓⵖ ⵉⵏⵏⵉ ⵛⴻⵎ ⵉ ⵖⴰ ⵉⵙⵙⴼⴻⵡⵡⵊⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("NM3_8","035_3_8","NAM","3","8","8","ⵎⴰ ⵛⴻⵎ ⵃⵙⴻⵏ ⵣⵉ ⵏⵓ-ⴰⵎⵓⵏ ⵏⵏⵉ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵖⴰⵔ ⵉⵖⴻⵣⵔⴰⵏ, ⴰⵎ ⴷ ⴰⵙ ⵇⴻⵡⵡⴰⵔⴻⵏ ⵡⴰⵎⴰⵏ, ⴰⵍⴰⵎⵉ ⵍⴻⴱⵃⴰⵔ ⴷ ⴰⵛⴱⴰⵔ ⵏⵏⴻⵙ ⵏ ⵣⵣⴰⵜ, ⴰⵇⴰ ⵍⵃⵉⴹ ⵏⵏⴻⵙ ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("NM3_9","035_3_9","NAM","3","9","9","ⴽⵓⵛ ⵜⵓⵖⴰ ⴷ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⵎⵉⵙⵍⴰ, ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⴻⵙ ⴰⵏⴻⴳⴳⴰⵔ. ⴼⵓⵟ ⴷ ⴰⵢⵜ ⵏ ⵍⵉⴱⵉⵢⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵉⵎⵄⴰⵡⵏⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("NM3_10","035_3_10","NAM","3","10","10","ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵢⵓⵔ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ. ⵓⵍⴰ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ ⴷⵉ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵎⴰⵔⵔⴰ ⵏ ⵜⴻⴱⵔⵉⴷⵉⵏ, ⵓ ⵅ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏⵏⴻⵙ ⵏⴹⴰⵔⴻⵏ ⵅⴰⵙⴻⵏ ⵜⴰⵇⴻⴷⴷⵓⵃⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵛⴰⵔⴼⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("NM3_11","035_3_11","NAM","3","11","11","ⵓⵍⴰ ⴷ ⵛⴻⵎ ⴰⴷ ⵜⴻⵙⵛⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵎ. ⵄⴰⵡⴻⴷ ⵛⴻⵎ ⴰⴷ ⵜⴰⵔⵣⵓⴷ ⵉⵊⵊ ⵏ ⵍⴱⵓⵔⵊ ⵉ ⵓⴷⵓⵔⵔⵉ ⵣⵉ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("NM3_12","035_3_12","NAM","3","12","12","ⵎⴰⵔⵔⴰ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵎ ⴰⵎ ⵡⵓⵔⵜⴰⵏ ⴰⴽ-ⴷ ⵍⴱⴰⵛⵓⵔ. ⵎⴰⵍⴰ ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏ, ⴰⴷ ⵡⴹⴰⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵢⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("NM3_13","035_3_13","NAM","3","13","13","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷ ⵡⴰ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ. ⵜⵜⵏⵓⵔⵣⵎⴻⵏⵜ ⵜⴻⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵎ ⵇⴰⵄ ⵉ ⵍⴻⵄⴷⵓ, ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⴻⵛⵛ ⵉⵄⵓⵎⴰⴷ ⵏⵏⴻⵎ ⵏ ⵡⴻⴼⵔⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("NM3_14","035_3_14","NAM","3","14","14","ⴰⵢⴻⵎ ⴰⵎⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵙⴻⵎⵜⴻⵏ ⵍⵇⴻⵍⵄⴰⵜ ⵏⵏⴻⵎ, ⴱⴻⴷⴷ ⴷⵉ ⵜⵍⴰⵅⵜ, ⵄⴻⴼⵙ ⴷⵉ ⵜⴰⵔⵔⵉⵙⵜ, ⵙⴻⵇⵙⴻⵃ ⵉⵥⵔⴰ ⵉⵜⵜⵡⴰⵙⵙⵓⵢⴷⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("NM3_15","035_3_15","NAM","3","15","15","ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵛⴻⵎ ⵜⴻⵛⵛ ⴷⵉⵏ, ⵙⵙⵉⴼ ⴰⴷ ⵛⴻⵎ ⵉⵏⴻⵖ, ⴰⴷ ⵛⴻⵎ ⵜⴻⵛⵛ ⴰⵎ ⴱⵓ-ⵡⴻⵍⵙⴰⵃ! ⴰⵔⵏⵉ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⵎ ⴱⵓ-ⵡⴻⵍⵙⴰⵃ, ⴰⵔⵏⵉ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵎ ⴰⵎ ⵜⵎⵓⵔⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("NM3_16","035_3_16","NAM","3","16","16","ⵛⴻⴽ ⵜⴻⵙⵙⵎⴰⵔⵏⵉⴷ ⴷⴻⴳ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⴻⵎ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ. ⴱⵓ-ⵡⴻⵍⵙⴰⵃ ⴰⴷ ⵉⵙⵙⴰⵔⵙ ⵜⵉⵍⵎⴻⵛⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⴹⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("NM3_17","035_3_17","NAM","3","17","17","ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ ⵏⵏⴻⵎ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵢⵍⴰⴼ ⵏ ⵜⵎⵓⵔⵖⵉ ⵓ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵎ ⴰⵎ ⵢⵉⵅⴻⵏⴼⵓⵙⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵢⴰⵔⵙⴰⵏ ⴷⵉ ⵍⴻⵃⵢⵓⴹ ⴷⴻⴳ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴷ ⴰⵚⴻⵎⵎⴰⴹ. ⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵟⵟⴰⵡⴻⵏ ⵙⵙⴻⵏⵏⵉ ⴷⴻⵖⵢⴰ. ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵃⴻⴷ ⴰⵎⵛⴰⵏ ⵏⵙⴻⵏ. ⵎⴰⵏⵉ ⵔⵓⵃⴻⵏ ⵏⵉⵜⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("NM3_18","035_3_18","NAM","3","18","18","ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵏⴻⵛ ⵜⵜⵏⵓⴷⵓⵎⴻⵏ, ⴰⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⴰⵛⵛⵓⵔ, ⴰⵢⵜ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⵜⵜᵉⵟⵟⵚⴻⵏ, ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵣⴻⴵⵄⴻⵏ ⵅ ⵉⴷⵓⵔⴰⵔ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵉⵙⵙⵎⵓⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("NM3_19","035_3_19","NAM","3","19","19","ⵡⴰⵔ ⴷⵉⵏ ⴰⵙⴳⴻⵏⴼⵉ ⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏⵏⴻⵛ, ⵉⵜⵜⴻⴽⴽⴻⵙ ⴰⵛ ⵓⵢⴻⵣⵣⵉⵎ! ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵅⴰⴽ ⵉⵙⵍⵉⵏ ⵍⴻⵅⴱⴰⵔ, ⴰⴷ ⵛⵛⴰⵜⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ, ⵎⴰⵖⴰⵔ ⵅ ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵓ ⵛⴰ ⵍⴻⴱⴷⴰ ⵍⵖⴰⵔ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("HK1_1","036_1_1","HAB","1","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏⵏⵉ ⵉⵥⵔⴰ ⵓⵏⴰⴱⵉ ⵃⴰⴱⴰⵇⵇⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("HK1_2","036_1_2","HAB","1","2","2","“ⴰ ⵙⵉⴷⵉ, ⴰⵍ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵍⴰⵖⵉⵖ ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴻⵙⵍⵉⴷ, ⴰⵍ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵍⴰⵖⵉⵖ ‘ⵍⵄⵓⵏⴼ!’, ⵓ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵏⵊⴰⵎⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("HK1_3","036_1_3","HAB","1","3","3","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵓ ⵜᵉⵜⵜⵖⵉⵎⵉⴷ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵖⴰⵔ ⵍⴻⵖⴱⴻⵏ? ⵎⴰⵖⴰⵔ ⴰⵔⴻⴷⴷⴻⴵ ⴷ ⵍⵄⵓⵏⴼ ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵔⴻⵏⴷⴰⴷ ⵉⵏⵓ, ⵓ ⵉⵎⵙⴰⵔ ⵓⵎⵛⵓⴱⴱⴻⵛ, ⵉⴽⴽⴰⵔ-ⴷⴷ ⵓⵔⵓⴷⴷⴻⵣ. ");
INSERT INTO rift_vpl VALUES ("HK1_4","036_1_4","HAB","1","4","4","ⵅ ⵓⵢⴰ ⵜⴻⴷⵡⴻⵍ ⵛⵛⴰⵔⵉⵄⴰ ⴱⵍⴰ ⵊⵊⴻⵀⴷ, ⵓ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵍⵃⴻⵇⵇ, ⵎⴰⵖⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵉ ⵓⵎⵙⴻⴳⴳⴻⴷ. ⵅ ⵓⵢⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵍⵃⴻⵇⵇ ⵉⴼⴰⵔⵖ. ");
INSERT INTO rift_vpl VALUES ("HK1_5","036_1_5","HAB","1","5","5","ⵅⵣⴰⵔⴻⵎ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵅⵣⴰⵔⴻⵎ, ⵉⵏⵏⵓⵔⵣⴻⵎ ⵓⵇⴻⵎⵎⵓⵎ ⵙ ⵓⵜⴻⴱⵀⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵎⵏⴻⵎ ⵎⴰⵍⴰ ⵜⵜ ⵃⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HK1_6","036_1_6","HAB","1","6","6","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ, ⵍⴳⴻⵏⵙ ⵉⵇⴻⵙⵃⴻⵏ ⵓ ⵉⵎⵇⴻⴵⵇⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⴻⵡⵙⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⵉⵣⴻⴷⴷⵉⵖⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK1_7","036_1_7","HAB","1","7","7","ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵓ ⵉⵙⵙⵏⴻⵅⵍⴰⵄⴻⵏ ⵉⴵⴰⵏ! ⵍⵃⴻⵇⵇ ⵏⵏⴻⵙ ⴷ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK1_8","036_1_8","HAB","1","8","8","ⵉⵢⵙⴰⵏ ⵏⵏⴻⵙ ⴼⵙⵓⵙⴻⵏ ⵅ ⵓⵖⵉⵍⴰⵙ, ⵏⵉⵜⵏⵉ ⵎⵎⵓⵣⵣⴰⵔⴻⵏ ⵎⴰⵀⵓ ⵓⵛⵛⴰⵏⴻⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵔⴰⴱⴰⵄⴻⵏ. ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵏⵉⵜⵏⵉ ⵟⵟⴰⵡⴻⵏ ⴰⵎ ⵓⴳⵉⴷⴻⵔ ⵏⵏⵉ ⵉⵜⵜⵇⴻⴵⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("HK1_9","036_1_9","HAB","1","9","9","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵙ-ⴷⴷ, ⴰⵎⴻⵏ ⵉⴽⵎⴻⵍ, ⵉ ⵍⵄⵓⵏⴼ, ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵎⵓⵏⴰ ⵉⵎⴻⵃⴱⴰⵙ ⴰⵎ ⵢⴻⵊⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HK1_10","036_1_10","HAB","1","10","10","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵇⴻⵚⵚⴰⵔ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓ ⵉⵏⵏⵉ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⴻⵏ ⴷ ⵜⴰⴹⴻⵃⵃⴰⵛⵜ. ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⵉⴹⴻⵃⵃⴻⵛ ⵅ ⴽⵓⵍ ⵍⵇⴻⵍⵄⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵄⵓⵔⵔⴻⵛ ⵓⵛⴰⵍ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵜ ⵉⵟⵟⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("HK1_11","036_1_11","HAB","1","11","11","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⵏⴻⵄⵜⴰⵔ ⴰⵎ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⴷ ⵉⵄⴷⵓ, ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⴷⵏⵓⴱ, ⵎⴰⵖⴰⵔ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK1_12","036_1_12","HAB","1","12","12","ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉⵏⵓ? ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ! ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵉ-ⵜ ⵉ ⵍⵃⵓⴽⵎ, ⴰ ⵜⴰⵚⴹⴰⵔⵜ, ⵛⴻⴽ ⵜⴼⴰⵔⵣⴻⴷ ⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵍⵄⵉⵇⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("HK1_13","036_1_13","HAB","1","13","13","ⵛⴻⴽ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⴰⵟⵟⴰⵙ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵍⴰⵏⵜ ⵍⵖⴰⵔ. ⵛⴻⴽ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵚⴻⵡⴹⴻⴷ ⴷⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⵚⴻⵡⴹⴻⴷ ⵡⴰⵀⴰ ⴷⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵍⴻⵖⴷⴰⵔⴻⵜ? ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜⴻⵙⵙⴻⵖⴹⴻⴷ ⵅⵎⵉ ⵉⵚⴰⵔⵔⴻⴹ ⵓⵄⴻⴼⴼⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵙ ⵉⵙⴻⴳⴳⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("HK1_14","036_1_14","HAB","1","14","14","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵡⴷⴰⵏ ⴰⵎ ⵢⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴰⵎ ⵉⵎⵎⵓⴷⴰⵔ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵍⵃⴰⴽⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("HK1_15","036_1_15","HAB","1","15","15","ⵙ ⵜⵙⴻⵏⵏⴰⵔⵜ ⵉⵙⵙⴳⴻⵄⵄⴰⴷ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ, ⵉⵢⴰⵔⵔⵓ ⵉ-ⵜⴻⵏ ⵙ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵏ ⵓⴷⴻⵍⵍⴰⵄ. ⵅ ⵓⵢⴰ ⵉⴼⴰⵔⵔⴻⵃ ⵓ ⵉⵜⵜⴼⴰⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("HK1_16","036_1_16","HAB","1","16","16","ⵅ ⵓⵢⴰ ⵉⵡⴻⵀⵀⴻⴱ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⴱⴻⵅⵅⴰⵔ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵜⵔⴰⵛⵛⴰ ⵏ ⵓⴷⴻⵍⵍⴰⵄ ⵏⵏⴻⵙ. ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵎⵖⴰⵔ, ⵓⵍⴰ ⴷ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⴰⵇⴰ ⵜⵍⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("HK1_17","036_1_17","HAB","1","17","17","ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵙⵙⴻⵅⵡⴰ ⵜⵔⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵍⴻⴱⴷⴰ ⵉⵏⴻⵇⵇ ⵍⴻⴳⵏⵓⵙ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵢⴻⵊⵊ ⵃⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("HK2_1","036_2_1","HAB","2","1","1","ⵏⴻⵛⵛ ⴰⴷ ⴱⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵉⵏⵓ ⵓ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵅ ⵚⵚⵓⵎⵄⴻⵜ ⵏ ⵜⵄⴻⵙⵙⴰⵙⵜ, ⴰⴷ ⵚⴻⵡⴹⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵏⵉ ⵏⴻⵜⵜⴰ, ⵓ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵖ ⵅ ⵓⵛⴻⵜⵛⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HK2_2","036_2_2","HAB","2","2","2","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ⴰⵔⵉ ⵍⴻⵡⵃⵉⵢ ⴰⵔⵉ ⵜ ⵉⴼⴰⵔⵣ ⵅ ⵜⴻⵍⵡⵉⵃⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ ⴰⵎ ⴷⴷ-ⵉⵜⵜⴰⵣⵣⴻⵍ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HK2_3","036_2_3","HAB","2","3","3","ⵎⴰⵖⴰⵔ ⵍⴻⵡⵃⵉⵢ ⵉⵜⵜⵔⴰⵊⴰ ⵄⴰⴷ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵢⵓⵔⴰⵏ. ⵉⵜⵜⴻⵎⵃⵉⵣⵡⴰⵔ ⵖⴰⵔ ⵓⵇⴻⵟⵟⵓ ⵓ ⵡⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵛⴰ. ⵎⴰⵍⴰ ⵉⵇⵇⵉⵎ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ, ⵇⵇⵉⵎ ⵔⴰⵊⴰ ⵜ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵉⵄⴻⵟⵟⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("HK2_4","036_2_4","HAB","2","4","4","ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⵓⴼⴼ, ⵡⴰⵀ, ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴻⵎ ⴷⴰⵢⴻⵙ, ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HK2_5","036_2_5","HAB","2","5","5","ⵙ ⵜⵉⴷⴻⵜⵜ, ⴱⵉⵏⵓ ⴰⵇⴰ ⵉⵛⴻⵎⵎⴻⵜ! ⴱⵉⵏⵓ ⴰⵇⴰ-ⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⵢⵢⵃⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⴰⵎⴻⵍⵀⴰⴼ ⴰⵎ ⵍⴰⵅⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵊⵊⵉⵡⵉⵏ ⴰⵎ ⵍⵎⴻⵡⵜ ⵓ ⵉⵢⵔⵓ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓ ⵉⵙⵙⵎⵓⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵢⴷⵓⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HK2_6","036_2_6","HAB","2","6","6","ⵎⴰ ⵡⴰⵔ ⴷⴷ ⵅⴰⵙ ⵜⵜⵉⵡⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉⵡⴻⵣⵏⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵢⴻⵥⵔⵉ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⵎⵄⴰⵏⵉ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⵊⴰⵔⵔⵡⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵏⵏⴻⵙ! ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ? ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴷⴻⵇⵇⴰⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴻⵔⵀⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("HK2_7","036_2_7","HAB","2","7","7","ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴽⴽⴰⵔⴻⵏ ⵙ ⵍⵖⴻⴼⵍⴻⵜ ⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵖⴰ ⵉⵣⴻⵄⴼⴻⵏ, ⵓ ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴼⴰⵇⴰⵏ ⵛⴰ ⵉⵏⵏⵉ ⵛⴻⴽ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⵜᵉⵜⵜⴰⵔⵊⵉⵊⴻⴷ, ⵓ ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⵉⵍⵉⴷ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("HK2_8","036_2_8","HAB","2","8","8","ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴽⴻⵛⵛⴹⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵛⴻⴽ ⴽⴻⵛⵛⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⵄⵓⵏⴼ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HK2_9","036_2_9","HAB","2","9","9","ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⴽⴻⵙⵙⴱⴻⵏ ⵙ ⵍⵖⴻⵛⵛ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⵏⴰ ⵍⵄⵓⵛⵛ ⵏⵏⴻⵙ ⴷⵉ ⵍⵓⵄⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵊⴻⵎ ⴰⵎⵎⵓ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HK2_10","036_2_10","HAB","2","10","10","ⵛⴻⴽ ⵜⵛⴰⵡⴰⵔⴻⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⴹⵉⴷ ⵅ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴳⴳⵉⴷ ⴷⴷⴻⵏⴱ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HK2_11","036_2_11","HAB","2","11","11","ⵎⵉⵏⵣⵉ ⴰⵥⵔⵓ ⵉⵙⵖⵓⵢⵢⵓ-ⴷⴷ ⵣⵉ ⵍⵃⵉⴹ, ⵓ ⵜⴰⵃⵏⴰⵛⵜ ⵜᵉⵜⵜⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵣⵉ ⵊⴰⵔ ⵜⴻⴼⵍⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("HK2_12","036_2_12","HAB","2","12","12","ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⴱⴻⵏⵏⴰⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵍⴰ ⵅ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵔⵓⵙⴰⵏ ⴷⵙⴰⵙ ⵏ ⵢⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵍⵖⴻⵛⵛ! ");
INSERT INTO rift_vpl VALUES ("HK2_13","036_2_13","HAB","2","13","13","ⵅⵣⴰⵔ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵇⴰ ⵍⴻⴳⵏⵓⵙ ⴰⵔⴻⴱⴱⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵜⵎⴻⵙⵙⵉ, ⵓ ⵛⵛⵓⵄⵓⴱ ⵜⵜⴰⵃⵍⴻⵏ ⵉ ⵡⴰⵍⵓ? ");
INSERT INTO rift_vpl VALUES ("HK2_14","036_2_14","HAB","2","14","14","ⵎⴰⵖⴰⵔ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴷⴰⵍⴻⵏ ⵡⴰⵎⴰⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HK2_15","036_2_15","HAB","2","15","15","ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵙⵡⴻⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⵅⴻⴵⴹⴻⵏ ⴱⵉⵏⵓ ⵙ ⵙⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⵅⴻⵏⵏⵉ ⵉⵙⵙᵉⵙⵛⴰⵔ ⵉ-ⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⴰⵔ ⵜⵓⵄⵄⴰⵔⵢⴰⵏⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HK2_16","036_2_16","HAB","2","16","16","ⴰⴷ ⵜⴻⵙⵙⵊⵊⵉⵡⵏⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵛⵛⴰⵏ. ⵙⵓ ⵛⴻⴽ ⵍⴻⵅⵅⵓ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⴻⵊⵊ ⴰⵅⵜⴰⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉⵜⵜⴱⴰⵏ. ⵍⴽⴰⵙ ⵣⴻⴳ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⵢⴰⵙ, ⵓⵍⴰ ⴷ ⵍⴻⴼⴷⵉⵃⴻⵜ ⵅ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HK2_17","036_2_17","HAB","2","17","17","ⵎⴰⵖⴰⵔ ⵍⵄⵓⵏⴼ ⵉ ⵜⴻⴳⴳⵉⴷ ⴹⵉⴷⴷ ⵉ ⵍⵓⴱⵏⴰⵏ ⴰⴷ ⵛⴻⴽ ⵉⴷⴻⵍ ⵓⵍⴰ ⴷ ⴰⵔⴻⴷⴷⴻⴵ ⵏ ⵍⵎⴰⵍ ⵉ ⵣⵉ ⵜⴻⵏ ⵜⴻⵙⵙⵉⴳⴳⵯⴷⴻⴷ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⵄⵓⵏⴼ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HK2_18","036_2_18","HAB","2","18","18","ⵎⴰ ⵜⵉⵣⵉ ⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⵏⴻⵇⵛⴻⵏ, ⵓⵎⵉ ⵜ ⵉⵏⵇⴻⵛ ⵓⵏⴻⵇⵇⴰⵛ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵏ ⵜⵉⵣⵉ ⵏ ⵢⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉⴼⴻⵙⵢⴻⵏ ⵓⵎⵉ ⴰⵏⴻⵇⵇⴰⵛ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵍⵎⴻⴷ ⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵍⴰⵎⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ ⵉⵜⵜⵛⴻⵍ ⵅ ⵎⵉⵏ ⵉⴳⴳⴰ, ⵓⵎⵉ ⵉⵜⵜⴻⴳⴳ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴳⵏⴰⵡⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("HK2_19","036_2_19","HAB","2","19","19","ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵓⴽⴻⵛⵛⵓⴹ ‘ⴼⴰⵇ!’ ⵓ ⵉ ⵡⴻⵥⵔⵓ ⵉⴳⵏⴰⵡⴻⵏ: ‘ⴽⴽⴰⵔ!’. ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ? ⵅⵣⴰⵔ, ⴰⵇⴰ ⵍⴻⵃⵃⴼⴻⵏ ⵜ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵇⴰⵄ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("HK2_20","036_2_20","HAB","2","20","20","ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵙⵓⵙⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("HK3_1","036_3_1","HAB","3","1","1","ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⵃⴰⴱⴰⵇⵇⵓⵇ, ⴰⵏⴰⴱⵉ, ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⵉⵊⵊⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("HK3_2","036_3_2","HAB","3","2","2","ⴰ ⵙⵉⴷⵉ, ⵓⵎⵉ ⵙⵍⵉⵖ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵛ, ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ. ⴰ ⵙⵉⴷⵉ, ⵙⵏⴻⴷⴷⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵛ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵙⴻⵛⵛⴻⵏ ⵉ-ⵜⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵄⵇⴻⵍ ⵅ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HK3_3","036_3_3","HAB","3","3","3","ⴰⵔⴻⴱⴱⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵜⴰⵢⵎⴰⵏ ⵓ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⴼⴰⵔⴰⵏ. ⵙⵉⵍⴰⵀ. ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ ⵜⴻⴷⵍⴰ ⵉⵊⴻⵏⵡⴰⵏ ⵓ ⴰⵚⴻⴱⴱⴻⵃ ⵏⵏⴻⵙ ⵉⵛⵛⵓⵔ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("HK3_4","036_3_4","HAB","3","4","4","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵙⵙⵉⵇⵜ ⴰⵎ ⵜⴼⴰⵡⵜ, ⴼⴼⵖⴻⵏⵜ-ⵉ-ⴷⴷ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵡⴰⵙⵙⴰⵎ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜⴻⵏⵜ ⵖⴰⵔⴻⵙ, ⵓ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵏⵓⴼⴼⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK3_5","036_3_5","HAB","3","5","5","ⵟⵟⴰⵄⵓⵏ ⵉⵜⵜⵉⵣⵡⴰⵔ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵍⵃⴰⴷⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK3_6","036_3_6","HAB","3","6","6","ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ, ⵏⴻⵜⵜⴰ ⵉⵥⵔⴰ ⵓ ⵉⴳⴳⴰ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵍⴻⴳⵏⵓⵙ! ⵉⴷⵓⵔⴰⵔ ⵏ ⵣⵉⵛ ⵜⵜⵡⴰⵍⴻⴱⵣⴻⵏ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ, ⵜⵉⵡⵔⵉⵔⵉⵏ ⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵖⴻⵏⵙⴻⵏⵜ! ⵉⴱⵔⵉⴷⴻⵏ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⴰⵇⴰ ⴰⵜⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK3_7","036_3_7","HAB","3","7","7","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⵇⵉⴹⴰⵏ ⵏ ⴽⵓⵛⴰⵏ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵜⵉⵊⴰⵔⵜⵉⵍⵉⵏ ⵏ ⵉⵇⵉⴹⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⴷⵢⴰⵏ ⵉⵜⵜⴰⵡⵉ ⵜⴻⵏⵜ ⵓⵙⴻⵎⵎⵉⴹ ⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("HK3_8","036_3_8","HAB","3","8","8","ⵎⴰ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵖⴻⵣⵔⴰⵏ? ⵎⴰ ⵜⵓⵖⴰ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵛ ⴹⵉⴷⴷ ⵉ ⵉⵖⴻⵣⵔⴰⵏ? ⵎⴰ ⵜⵓⵖⴰ ⴰⴷⵓⵇⵇⴻⵣ ⵏⵏⴻⵛ ⵏ ⵓⴼⵓⴳⴻⵎ ⴹⵉⴷⴷ ⵉ ⵍⴻⴱⵃⴰⵔ, ⵍⴰⵎⵉ ⵜⵏⴻⴷⵀⴻⴷ ⵅ ⵢⴻⵢⵙⴰⵏ ⵏⵏⴻⵛ, ⵅ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏⵏⴻⵛ ⵏ ⵓⵙⴻⵏⵊⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("HK3_9","036_3_9","HAB","3","9","9","ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⵎⴰⵔⵔⴰ, ⵜⵉⵊⴰⴵⵉⵜⵉⵏ ⵉ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵉⵄⵓⵎⴰⴷ ⵏⴻⵛⵛ ⵉ ⵓⵙⴻⵇⵙⴰⵃ. ⵙⵉⵍⴰⵀ. ⵜⴼⴻⴵⵇⴻⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵉⵖⴻⵣⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HK3_10","036_3_10","HAB","3","10","10","ⵍⴰⵎⵉ ⵛⴻⴽ ⵥⵔⵉⵏ ⵉⴷⵓⵔⴰⵔ, ⵉⵍⵇⴻⴼ ⵉ-ⵜⴻⵏ ⵍⴻⵡⵊⴻⵄ, ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵜⵓⵖⴰ ⵜⵄⴻⴷⴷⵓ, ⴰⵎⴰⵏ ⵉⵀⴻⵡⵍⴻⵏ ⴰⵔⵔⵉⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ, ⴳⴻⵄⵄⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HK3_11","036_3_11","HAB","3","11","11","ⵜⴰⴼⵓⵛⵜ, ⵓⵍⴰ ⴷ ⵓⵢⵓⵔ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ. ⴰⵇⴰ ⵔⵓⵃⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴼⴰⵡⵜ ⵏ ⴼⵍⵉⵜⵛⴰⵜ ⵏ ⵍⵇⴻⵡⵙ ⵏⵏⴻⵛ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵍⴰⵏⵙⴰ ⵏⵏⴻⵛ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HK3_12","036_3_12","HAB","3","12","12","ⵙ ⵡⴻⵙⵅⴻⴹ ⵜⴻⵚⵚⵓⵔⵓⴼⴻⴷ ⵜⵉⵡⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵙ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ ⵜⵄⴻⴼⵙⴻⴷ ⵅ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("HK3_13","036_3_13","HAB","3","13","13","ⵛⴻⴽ ⵜⴻⴼⴼⵖⴻⴷ ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ, ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵓⵎⴻⴷⵀⵓⵏ ⵏⵏⴻⵛ. ⴰⵇⴰ ⵛⴻⴽ ⵜⵇⴻⴵⵄⴻⴷ ⵜⴰⵣⴻⵇⵇⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵜⵄⴰⵔⵔⵉⴷ ⴷⵙⴰⵙ ⴰⵍ ⵉⵔⵉ. ⵙⵉⵍⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("HK3_14","036_3_14","HAB","3","14","14","ⴰⵣⴻⴵⵉⴼ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⴰⵇⴰ ⵜⴻⵙⵙⵏⵓⵇⵇⴱⴻⴷ ⵉ-ⵜ ⵙ ⵍⴰⵏⵙⴰⵜ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵄⴻⵍⴼⴻⵏ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵣⴻⴵⵄⴻⵏ. ⴰⵇⴰ ⴷ ⵎⴻⵥⵔⵉ ⵏⵙⴻⵏ ⵎⴰⵍⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⵍⵎⴻⵙⴽⵉⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HK3_15","036_3_15","HAB","3","15","15","ⴰⴽ-ⴷ ⵉⵢⵙⴰⵏ ⵏⵏⴻⵛ ⵜᵉⵟⵟⴼⴻⴷ ⴰⴱⵔⵉⴷ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⴰⴽⵓⴼⴼⵓ ⵏ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HK3_16","036_3_16","HAB","3","16","16","ⵍⴰⵎⵉ ⵙⵍⵉⵖ, ⵢⴰⵔⵊⵉⵊ ⵓⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ. ⵓⵎⵉ ⵙⵍⵉⵖ ⵍⵃⴻⵙⵙ ⵏⵏⵉ, ⴰⵔⵊⵉⵊⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵏⵓ, ⴰⵅⴻⵙⵙⴰⵔ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵉⵖⵙⴰⵏ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⴰⵔⵊⵉⵊⴻⵖ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵓ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⵔⴰⵊⵉⵖ ⴷⵉ ⵍⵅⴰⴹⴰⵔ ⵅ ⵡⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵅⵎⵉ ⵖⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵅ ⵍⴳⴻⵏⵙ, ⵓ ⴰⴷ ⴰⵏⴻⵖ ⵉⵃⵚⴰⵔ ⴰⴽ-ⴷ ⴱⴰⵏⴷⵉⵢⵢⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HK3_17","036_3_17","HAB","3","17","17","ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵉⵜⵜⵏⵓⵡⵡⴰⵔ ⵡⴰⵔⵜⵓ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵍⵖⵉⴵⴻⵜ ⵖⴰⵔ ⵜⵣⴰⵢⴰⵔⵜ, ⵡⴰⵅⵅⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⴰⴷ ⵜⴻⴼⵛⴻⵍ ⵓⵍⴰ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⵜⵜⵉⵛⴻⵏ ⵍⵎⴰⵛⵓⵍ, ⵓ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵡⵓⴵⵉ ⵣⵉ ⵍⴽⵓⵍⵉ ⵓ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⴷ ⵜⴼⵓⵏⴰⵙⵉⵏ ⴷⵉ ⵍⴽⵓⵔⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("HK3_18","036_3_18","HAB","3","18","18","ⵄⴰⴷ ⴰⵎⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵍⵉⵡⴻⵍⵡⴻⵖ ⵉ ⵙⵉⴷⵉ, ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("HK3_19","036_3_19","HAB","3","19","19","ⵙⵉⴷⵉ, ⵙⵉⴷⵉ ⵉⵏⵓ, ⵏⴻⵜⵜⴰ ⴷ ⵊⵊⵀⴻⴷ ⵉⵏⵓ. ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⴼⵙⵓⵙⴻⵏ ⴰⵎ ⵢⵉⴹⴰⵔⴻⵏ ⵏ ⵜⵓⴷⴰⴷⵉⵏ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵊⵊⴰ ⴰⵢⵉ ⵚⵚⵓⵔⵓⴼⴻⵖ ⵅ ⵍⴻⴳⵄⵓⴷⵉ. ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵖⵏⴰⵊⴻⵏ. ⴰⴽ-ⴷ ⵓⵣⴻⵏⵣⵓⵏ ⵉⵏⵓ ⵅ ⵉⴼⵉⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP1_1","037_1_1","ZEP","1","1","1","ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵉ ⵚⴰⴼⴰⵏⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴽⵓⵛⵉ, ⵎⵎⵉⵙ ⵏ ⵊⴰⴷⴰⵍⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⴰⵔⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵃⵉⵣⵇⵉⵢⴰ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵛⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴰⵎⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("ZP1_2","037_1_2","ZEP","1","2","2","ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵇⴰⵄ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP1_3","037_1_3","ZEP","1","3","3","ⴰⴷ ⴽⴽⵙⴻⵖ ⴱⵏⴰⴷⴻⵎ ⴷ ⵍⵎⴰⵍ, ⴰⴷ ⴽⴽⵙⴻⵖ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵉⵙⴻⵍⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷ ⵜⵄⴻⵏⴽⵔⵉⴼⵉⵏ ⴰⴽ-ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵡⴰⵀ ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⴱⵏⴰⴷⴻⵎ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP1_4","037_1_4","ZEP","1","4","4","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ ⴹⵉⴷⴷ ⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⴹⵉⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⴱⴰⵄⵍ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⴰⴽ-ⴷ ⵢⵉⵙⴻⵎ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵍ’ⴰⵚⵏⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("ZP1_5","037_1_5","ZEP","1","5","5","ⴷ ⵢⵉⵏⵏⵉ ⵉⵙⴻⵊⴷⴻⵏ ⵅ ⵜⵣⴻⵖⵡⵉⵏ ⵣⵣⴰⵜ ⵉ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵓ ⵉⵏⵏⵉ, ⴰⵎ ⴱⴻⵏⴷⵇⴻⵏ, ⵊⵊⵓⴵⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵓ ⴰⵇⴰ ⵊⵊⵓⴵⴻⵏ ⵉ ⵎⴰⵍⴽⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("ZP1_6","037_1_6","ZEP","1","6","6","ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵄⴰⵇⵇⴰⴱⴻⵏ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵓ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵙⵉⴷⵉ ⵓ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵙⵙⴻⵇⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP1_7","037_1_7","ZEP","1","7","7","ⵙⴻⵖⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⵢⵓⴷⴻⵙ. ⵙⵉⴷⵉ ⴰⵇⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ, ⵏⴻⵜⵜⴰ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵉⵎⴻⵄⵔⴰⴹⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZP1_8","037_1_8","ZEP","1","8","8","ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵄⴰⵇⴱⴻⵖ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⴰⵔⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴰⵖⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("ZP1_9","037_1_9","ZEP","1","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵄⴰⵇⴱⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵏⴻⴳⴳⵣⴻⵏ ⵜⴰⵏⴻⴱⴷⴰⵜ, ⵉⵏⵏⵉ ⵉⵜⵜⵄⴻⵎⵎⴰⵔⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉⵜⵙⴻⵏ ⵙ ⵍⵄⵓⵏⴼ ⴷ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("ZP1_10","037_1_10","ZEP","1","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⵓⵍⴰ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵔⵓⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵊⴷⵉⴷ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵜⴻⵎⵖⴰⵔ ⵣⵉ ⵜⴻⵡⵔⵉⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP1_11","037_1_11","ZEP","1","11","11","ⵔⵓⵎ, ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⵎⴻⵀⵔⴰⵣ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵙⴻⴱⴱⴰⴱⴱⴻⵏ ⵜⵜⵡⴰⵙⴻⵖⴹⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵡⴻⵣⵣⵏⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP1_12","037_1_12","ZEP","1","12","12","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⴱⴻⵇⵇⵛⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵍⴻⵇⵏⴰⴷⴻⵍ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵄⴰⵇⴱⴻⵖ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴷⴰⵔⴻⵏ ⵣⵉ ⵍⴰⵜⴰⵔ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⴱⵉⵏⵓ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ: ‘ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴰⵔ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵍⵖⴰⵔ!’ ");
INSERT INTO rift_vpl VALUES ("ZP1_13","037_1_13","ZEP","1","13","13","ⴰⴳⵍⴰ ⵏⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵍⵅⴰⵔⴱⴻⵜ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⵏⴰⵏ ⵜⵓⴷⵔⵉⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵣⴻⴷⴷⵖⴻⵏ ⵛⴰ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⵥⵓⵏ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⴻⵙⵙⴻⵏ ⵣⵉ ⴱⵉⵏⵓ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZP1_14","037_1_14","ZEP","1","14","14","ⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵙⵉⴷⵉ ⵢⵓⴷⴻⵙ, ⴰⵇⴰ-ⵜ ⵢⵓⴷⴻⵙ, ⴷⴻⵖⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ. ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉ! ⴰⴷ ⵉⵙⵖⵓⵢ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⴷⵉⵏ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴰⵔⵣⴻⴳ. ");
INSERT INTO rift_vpl VALUES ("ZP1_15","037_1_15","ZEP","1","15","15","ⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵙⵙ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ, ⴷ ⴰⵙⵙ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷ ⴹⴹⵉⵇⴰ, ⴷ ⴰⵙⵙ ⵏ ⵓⵅⴰⵔⵔⴻⴱ ⴷ ⵡⴰⵔⴻⴷⴷⴻⴵ, ⴷ ⴰⵙⵙ ⵏ ⵟⵟⵍⴰⵎ ⴷ ⵜⴰⴵⴻⵙⵜ, ⴷ ⴰⵙⵙ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴷ ⵓⵙⴻⵢⵏⵓ ⵉⴱⴱⵓⵎⴱⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("ZP1_16","037_1_16","ZEP","1","16","16","ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓ ⵏ ⵉⵖⵓⵢⵢⴰⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵉⴼⴰⵔⵢⴻⵏ ⵓ ⴹⵉⴷⴷ ⵉ ⵚⵚⵓⵎⵄⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵖⴻⵎⵎⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("ZP1_17","037_1_17","ZEP","1","17","17","ⵏⴻⵛⵛ ⴰⴷ ⵃⵚⴰⵔⴻⵖ ⵉⵡⴷⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴰⵎ ⵢⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴷⴷⴻⵏⴱ ⵅ ⵙⵉⴷⵉ. ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵜⵄⴻⵊⵊⴰⵊⵜ, ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⵅⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP1_18","037_1_18","ZEP","1","18","18","ⵓⵍⴰ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵙⴻⵏ ⴷ ⵡⵓⵔⴻⵖ ⵏⵙⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⴼⵓⴳⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵜⵉⵎⴻⵙⵙⵉ ⵏ ⵜⵓⵙⵎⵉ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵜⴻⵛⵛ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⴷⴻⵖⵢⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⴹⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ZP2_1","037_2_1","ZEP","2","1","1","ⵙⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵖⴰⵔ ⵍⴻⵄⵇⴻⵍ, ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵄⵇⴻⵍ, ⴰ ⵍⴳⴻⵏⵙ ⴱⵍⴰ ⴰⵙⴻⴹⵃⵉ, ");
INSERT INTO rift_vpl VALUES ("ZP2_2","037_2_2","ZEP","2","2","2","ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵍⵃⵓⴽⵎ - ⴰⵙⵙ ⴰⵎ ⵓⵍⵓⵎ ⵉⵄⴻⴷⴷⵓ - ⵇⴱⴻⵍ ⵉ ⵅⴰⵡⴻⵎ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ, ⵇⴱⴻⵍ ⵉ ⵅⴰⵡⴻⵎ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP2_3","037_2_3","ZEP","2","3","3","ⴰⵔⵣⵓⵎ ⵅ ⵙⵉⴷⵉ, ⵎⴰⵔⵔⴰ ⵉⵎⵡⴰⴹⵄⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵃⴻⵇⵇ ⵏⵏⴻⵙ! ⴰⵔⵣⵓⵎ ⵜⴰⵙⴻⴳⴷⴰ, ⴰⵔⵣⵓⵎ ⴰⵡⴰⴹⴻⵄ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜⴻⵏⵏⵓⴼⴼⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP2_4","037_2_4","ZEP","2","4","4","ⵎⴰⵖⴰⵔ ⵖⴰⵣⵣⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵊⵊ, ⴰⵛⵇⴰⵍⵓⵏ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⴰⵛⴷⵓⴷ ⴰⴷ ⵅⴰⵙ ⴰⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ, ⵓⵛⴰ ⵄⴰⵇⵔⵓⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("ZP2_5","037_2_5","ZEP","2","5","5","ⵓⵛⵜ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵍⴳⴻⵏⵙ ⵏ ⵉⴽⴰⵔⵉⵜⵉⵢⵢⴻⵏ. ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⵉⵍⵉ, ⴰ ⴽⴻⵏⵄⴰⵏ, ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ! ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵀⴻⵍⵍⴽⴻⵖ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵎⴻⵣⴷⵓⵖ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("ZP2_6","037_2_6","ZEP","2","6","6","ⵜⴰⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⴷⴷⵎⴰⵏⵉ ⵏ ⵜⴰⵔⴻⵡⵙⴰ, ⵓⵍⴰ ⴷ ⵡⴰⵏⵓⵜⴻⵏ ⵉ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴷ ⵍⴽⵓⵔⵉⵜ ⵉ ⵡⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP2_7","037_2_7","ZEP","2","7","7","ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴰⵔⴻⵡⵙⴻⵏ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ. ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⴰⵛⵇⴰⵍⵓⵏ ⴰⴷ ⴷⵉⵏ ⴰⵔⵙⴻⵏ ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵔⵣⴻⴼ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵏⴻⵇⵍⴻⴱ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP2_8","037_2_8","ZEP","2","8","8","ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵉ ⵓⵙⴻⵃⵇⴰⵔ ⵏ ⵎⵓ’ⴰⴱ ⴷ ⵓⵛⴻⵇⵇⴻⴼ ⵏ ⴰⵢⵜ ⵏ ⵄⴰⵎⵎⵓⵏ, ⵉ ⵣⵉ ⵙⵙⵃⴻⵇⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵓ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP2_9","037_2_9","ZEP","2","9","9","ⵙ ⵓⵢⴰ, ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ: ⵎⵓ’ⴰⴱ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵙⴰⴷⵓⵎ, ⵓ ⴰⵢⵜ ⵏ ⵎⵓ’ⴰⴱ ⴰⵎ ⵄⴰⵎⵓⵔⵔⴰ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵖⴻⵎⵎⵓⵢ ⵏ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵏⵓⵜⴻⵏ ⵏ ⵜⵎⴻⴵⴰⵃⵜ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵜⴻⵏ ⵉⴽⴻⵛⵛⴻⴹ ⵓ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ZP2_10","037_2_10","ZEP","2","10","10","ⴰⵢⴰ ⴰⴷ ⵜⴻⵏ ⵉⵍⵇⴻⴼ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵏⵏⴼⴰⵅⴻⵜ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵓ ⴰⵔⵣⵎⴻⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵅ ⵍⴳⴻⵏⵙ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZP2_11","037_2_11","ZEP","2","11","11","ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⴼⴼⴻⵖ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⴹⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵙ ⴱⴻⵏⴷⵇⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵔⵔⴰ ⵜⵉⴳⵣⵉⵔⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("ZP2_12","037_2_12","ZEP","2","12","12","ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ, ⴰ ⴰⵢⵜ ⵏ ⴽⵓⵛ, ⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵙⵙⵉⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ZP2_13","037_2_13","ZEP","2","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵛⵛⵓⵔ, ⵓ ⴰⴷ ⵢⴰⵔⵔ ⵏⵉⵏⵡⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ, ⵜⵓⵥⴻⵖ ⴰⵎ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("ZP2_14","037_2_14","ZEP","2","14","14","ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴰⴷ ⴳⴻⵢⵢⵔⴻⵏⵜ ⵜⵃⵉⵎⵔⵉⵡⵉⵏ, ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵓⴱⴰⵔⵔⵓ ⵏ ⵏ ⵍⴳⴻⵏⵙ. ⵓⵍⴰ ⴷ ⴱⵓ-ⵉⵄⵓⵇⵇⴰⵏ, ⵡⴰⵀ ⵓⵍⴰ ⴷ ⵜⵡⵓⵛⵜ ⵏ ⴵⵉⵍⴻⵜ ⴰⴷ ⵙⵙⴻⵏⵙⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⴰⴷ ⵜⵖⴻⵏⵏⴻⵊ ⵣⵉ ⵍⴽⴰⵣⵉ, ⴰⵔⴻⴷⴷⴻⴵ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵜⵏⴻⴱⴷⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵜⴰⴼⵔⴻⵡⵜ ⵏ ⵜⴻⵏⴳⴻⵍⵜ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("ZP2_15","037_2_15","ZEP","2","15","15","ⴷ ⵜⴰ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵙⵍⵉⵡⵍⵉⵡⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵍⴰⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: ‘ⵏⴻⵛⵛ ⴷ ⵜⴻⵏⵏⵉ, ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉ!’ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ, ⵉⵛⵜ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵍⵎⴰⵍ ⵏ ⵍⴻⵅⵍⴰ! ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⵖⴰ ⵉⴽⴽⴻⵏ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵚⴻⴼⴼⴰⵔ ⵓ ⵙ ⵓⵙⴻⵃⵇⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵀⴻⵣⵣ ⴰⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZP3_1","037_3_1","ZEP","3","1","1","ⵓⵛⵜ ⵅⴰⵎ, ⵜⴻⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ ⴷ ⵢⴰⵔⵚⵓⴹⴻⵏ, ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴷⴷⴻⴵ! ");
INSERT INTO rift_vpl VALUES ("ZP3_2","037_3_2","ZEP","3","2","2","ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉ ⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ, ⵡⴰⵔ ⵜⵇⴻⴱⴱⴻⵍ ⴰⵡⴻⴷⴷⴻⴱ, ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵛⵉⵍ ⵅ ⵙⵉⴷⵉ, ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵇⴰⵔⵔⴰⴱ ⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZP3_3","037_3_3","ZEP","3","3","3","ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴷ ⴰⵢⵔⴰⴷⴻⵏ ⵉⵜⵜⴰⵔⵔⵓⵊⴷⵓⴷⴻⵏ, ⵍⵇⵓⴹⴰⵜ ⵏⵏⴻⵙ ⴷ ⵓⵛⵛⴰⵏⴻⵏ ⵏ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉⵏ ⵡⴰⵍⵓ ⴰⵍ ⵜⵓⴼⴼⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("ZP3_4","037_3_4","ZEP","3","4","4","ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷⴰⵢⵙⴻⵏ ⵍⴻⴼⵛⵓⵛ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵅⴻⴷⴷⴰⵄⴻⵏ! ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵅⴰⵍⴼⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("ZP3_5","037_3_5","ZEP","3","5","5","ⵙⵉⴷⵉ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ. ⴽⵓⵍ ⵜⵓⴼⴼⵓⵜ ⵉⵜⵜⴰⵔⵔⴰ ⵍⵃⴻⵇⵇ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴼⴰⵡⵜ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵏⴻⵇⵇⴻⵚ! ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵛⴰ ⴰⵙⴻⴹⵃⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP3_6","037_3_6","ZEP","3","6","6","ⵏⴻⵛⵛ ⵇⴹⵉⵖ ⵍⴻⴳⵏⵓⵙ, ⴰⵔⴻⴷⴷⴵⴻⵖ ⵚⵚⵓⵎⵄⴰⵜ ⵏⵙⴻⵏ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ. ⵏⴻⵛⵛ ⵅⵍⵉⵖ ⵉ ⵜⴱⵔⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵉⵜⵜⵙⴰⵔⴰ ⴷⵉⵏⵏⵉ. ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ, ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵃⴻⴷ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⴷⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("ZP3_7","037_3_7","ZEP","3","7","7","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ⵉⵜⵜⵅⴻⵚⵚⴰ ⵛⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵯⴻⴷⴻⴷ, ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⵡⴻⴷⴷⴻⴱ!, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ, ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⴳⴳⴻⵖ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⵉⵜⵏⵉ ⵖⴻⵡⵡⵖⴻⵏ ⵣⵉⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴼⴻⴹⵃⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⴰⵍ ⵟⵟⴰⵔⴼ. ");
INSERT INTO rift_vpl VALUES ("ZP3_8","037_3_8","ZEP","3","8","8","ⵙ ⵓⵢⴰ ⵔⴰⵊⴰⵎ ⴰⵢⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ ⵖⴰ ⴽⴽⴰⵔⴻⵖ ⵉ ⵜⴽⴻⵛⵛⴰⴹⵜ. ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⴷ ⵍⵃⵓⴽⵎ ⵉⵏⵓ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴰⵇⴰ ⴰⴷ ⵊⴰⵔⵡⴻⵖ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵜⵉⴳⴻⵍⴷⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⵙⴼⴻⵙⵢⴻⵖ ⴰⵙⵅⴻⴹ ⵉⵏⵓ, ⵎⴰⵔⵔⴰ ⵍⵃⴰⴷⵓⵇ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⵜⵓⵙⵎⵉ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ZP3_9","037_3_9","ZEP","3","9","9","ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴱⴻⴷⴷⵍⴻⵖ ⵍⵃⴰⵔⴷ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴰⴷ ⵜⴻⵏ ⵡⵛⴻⵖ, ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵍⴰⵖⴰⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵄⴻⴱⴱⴷⴻⵏ ⴰⵎ ⵙ ⵢⵉⵛⵜ ⵏ ⵜⴻⵖⵔⵓⴹⵜ. ");
INSERT INTO rift_vpl VALUES ("ZP3_10","037_3_10","ZEP","3","10","10","ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⴽⵓⵛ, ⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵜⵜⵥⴰⴵⴰⵏ, ⵢⴻⴵⵉⵙ ⵏ ⵉⵎⵎⵟⴰⵔⵔⵛⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵜⵜ ⴰⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵜⴻⵡⵀⵉⴱⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ZP3_11","037_3_11","ZEP","3","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵔ ⵜⵙⴻⴹⵃⵉⴷ ⵛⴰ ⵄⴰⴷ, ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵉ ⵣⵉ ⵅⴰⴼⵉ ⵜⵖⴻⵡⵡⵖⴻⴷ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴽⴽⵙⴻⵖ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ ⵉⵏⵏⵉ ⵉⵜⵜⴼⴻⵢⵢⵛⴻⵏ ⴷⵉ ⵏⵏⴼⴰⵅⴻⵜ, ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⴳⴻⵄⵄⴰⴷⴻⵎ ⵄⴰⴷ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵏⵓ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP3_12","037_3_12","ZEP","3","12","12","ⵏⴻⵛⵛ ⴰⴷ ⵊⵊⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ, ⵉⵥⴻⵍⴹ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZP3_13","037_3_13","ZEP","3","13","13","ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵛⴰ, ⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⵉⴼⵉ ⵢⵉⵍⴻⵙ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵀⴻⴷⴷⴰⵏ ⴰⴷ ⵣⵣⵍⴻⵏ, ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("ZP3_14","037_3_14","ZEP","3","14","14","ⵖⴻⵏⵏⴻⵊ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵙⵍⵉⵡⵍⴻⵡ, ⴰ ⵉⵙⵔⴰⵉⵍ. ⴼⴰⵔⵃ ⵓ ⵜⴼⴰⴵⵉⴷ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵏⴻⵎ, ⴰ, ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("ZP3_15","037_3_15","ZEP","3","15","15","ⵙⵉⴷⵉ ⵉⴽⴽⴻⵙ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵎ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵎⵃⴰ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵎ. ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ! ⵡⴰⵔ ⵜⵥⴰⵔⵔⴻⴷ ⵄⴰⴷ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZP3_16","037_3_16","ZEP","3","16","16","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ: ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵚⵉⵀⵢⵓⵏ! ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵎ ⴰⴷ ⴰⵔⵅⵓⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ! ");
INSERT INTO rift_vpl VALUES ("ZP3_17","037_3_17","ZEP","3","17","17","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵎ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵎ, ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵎ ⵉⴼⴰⵔⵃ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⴻⵖⴹ ⴷⵉ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵎ ⵉⵙⵍⵉⵡⵍⴻⵡ ⵙ ⵓⵖⴻⵏⵏⴻⵊ.’ ");
INSERT INTO rift_vpl VALUES ("ZP3_18","037_3_18","ZEP","3","18","18","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵉⵏⵏⵉ ⵉⵛⴻⵟⵟⵏⴻⵏ ⵓⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴰⵔⵛⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵍⵄⵉⴷ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵢⴻⵎ! ⴷⴷⵇⴻⵍ ⵏ ⵍⵃⴻⴳⵔⴰ ⴰⵇⴰ-ⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ZP3_19","037_3_19","ZEP","3","19","19","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⵖⵍⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵛⴻⵎ ⵉⵃⵚⴰⵔⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵉⵇⴻⵊⴷⴰⵃⴻⵏ ⵓ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵍⵄⴻⵣⵣ ⴷ ⵢⵉⵊⵊ ⵏ ⵉⵙⴻⵎ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵏⵏⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵉⵙⵙⴼⴻⵟⵟⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZP3_20","037_3_20","ZEP","3","20","20","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⴰⵔⵔⴻⵖ, ⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵎⵓⵏⴻⵖ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵉⵛⴻⵏⵏⵄⴻⵏ ⴷ ⵍⵄⴻⵣⵣ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵅⵎⵉ ⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵖⴰ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵜⴰⵎⴻⵃⴱⴰⵙⵜ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HG1_1","038_1_1","HAG","1","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵓⵢⵓⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵙ ⵓⴼⵓⵙ ⵏ ⵃⴰⴳⴳⴰⵢ, ⴰⵏⴰⴱⵉ, ⵖⴰⵔ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰ’ⴰⵍⵜⵉⵢⴰⵍ, ⵍⵡⴰⵍⵉ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵖⴰⵔ ⵢⴰⵀⵓⵛⴰⵄ ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("HG1_2","038_1_2","HAG","1","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔ, ⵉⵇⵇⴰⵔ: ⵍⴳⴻⵏⵙ-ⴰ ⵉⵇⵇⴰⵔ: ‘ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵢⵉⵡⵉⴹ ⵍⵃⴰⵍ, ⵍⵃⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵄⴰⵡⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("HG1_3","038_1_3","HAG","1","3","3","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ ⵃⴰⴳⴳⴰⵢ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("HG1_4","038_1_4","HAG","1","4","4","“ⵎⴰ ⵢⵉⵡⴻⴷ-ⴷⴷ ⵍⵃⴰⵍ ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵣⴻⴷⵖⴻⵎ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⴻⵇⵇⴼⴻⵏ, ⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⴷ ⵍⵅⴰⵔⴱⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("HG1_5","038_1_5","HAG","1","5","5","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵃⴹⴰⵎ ⵎⵍⵉⵃ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ... ");
INSERT INTO rift_vpl VALUES ("HG1_6","038_1_6","HAG","1","6","6","ⴽⴻⵏⵏⵉⵡ ⵜⵣⴰⵔⵔⵄⴻⵎ ⴰⵟⵟⴰⵙ, ⵜⵎⴻⵊⵊⴰⵔⴻⵎ ⴷⵔⵓⵙ. ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵊⵊⵉⵡⵉⵏⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵜⵙⴻⵙⵙⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵜⴻⵙⵛⴰⵔⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵜⵢⴰⵔⴹⴻⵎ ⴰⵔⵔⵓⴹ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵙⵙⵃⴻⵎⵎⵉ, ⵓ ⵡⴻⵏⵏⵉ ⴷ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⵍⵎⵓⵏⴻⵜ, ⴰⴷ ⵉⵟⵟⴻⴼ ⵍⵎⵓⵏⴻⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴽⴻⵎⵎⵓⵙⵜ ⵜᵉⵏⵏⵓⵇⵇⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("HG1_7","038_1_7","HAG","1","7","7","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔ: ⵃⴹⴰⵎ ⵎⵍⵉⵃ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HG1_8","038_1_8","HAG","1","8","8","ⴳⴻⵄⵄⴷⴻⵎ ⴰⴷⵔⴰⵔ, ⴰⵡⵢⴻⵎ-ⴷⴷ ⴰⴽⴻⵛⵛⵓⴹ ⵓ ⴱⵏⴰⵎ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴰⵔⴹⵉⵖ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HG1_9","038_1_9","HAG","1","9","9","ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ ⵜⴰⵢⵏⵉⵜ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵛⴰ ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ-ⵜ ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵓ ⵅⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵜᵉⵜⵜⴰⵡⵢⴻⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⴻⵛⵛ ⵜⵜⵙⵓⴹⴻⵖ ⵅⴰⵙ. ⵎⴰⵢⴻⵎⵎⵉ? ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵜⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⴰⵎ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HG1_10","038_1_10","HAG","1","10","10","ⵅ ⵓⵢⴰ ⵎⴻⵏⵏⵄⴻⵏ ⵅⴰⵡⴻⵎ ⵉⵊⴻⵏⵡⴰⵏ ⵏⵏⴷⴰ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⵜⵎⴻⵏⵏⴻⵄ ⵅⴰⵡⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HG1_11","038_1_11","HAG","1","11","11","ⵏⴻⵛⵛ ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅ ⵍⴻⴽⵃⴻⴹ ⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵅ ⵉⴷⵓⵔⴰⵔ, ⵅ ⵉⵎⴻⵏⴷⵉ, ⵅ ⴱⵉⵏⵓ, ⵅ ⵣⵣⴻⵛⵜ, ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⴷⴷ-ⵜᵉⵜⵜⴰⵡⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⵅ ⵉⵡⴷⴰⵏ ⵓ ⵅ ⵍⵎⴰⵍ ⵓ ⵅ ⵡⴰⵔⴱⴻⵔ ⵏ ⵉⴼⴰⵙⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("HG1_12","038_1_12","HAG","1","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵍⴰ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰ’ⴰⵍⵜⵉⵢⴰⵍ, ⵓ ⴰⴽⵉⴷⴻⵙ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵃⴰⴳⴳⴰⵢ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜ ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ⵓ ⵏⵉⵜⵏⵉ, ⵍⴳⴻⵏⵙ, ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HG1_13","038_1_13","HAG","1","13","13","ⵉⴱⴰⵔⵔⴻⵃ ⵃⴰⴳⴳⴰⵢ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉ, ⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ!” ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HG1_14","038_1_14","HAG","1","14","14","ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽⴰⵔ ⵙⵉⴷⵉ ⴱⵓⵃⴱⴻⵍ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰ’ⴰⵍⵜⵉⵢⴰⵍ, ⵍⵡⴰⵍⵉ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵍⴰ ⴷ ⴱⵓⵃⴱⴻⵍ ⵏ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓⵍⴰ ⴷ ⴱⵓⵃⴱⴻⵍ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵓ ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵓ ⴳⴳⵉⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HG1_15","038_1_15","HAG","1","15","15","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("HG2_1","038_2_1","HAG","2","1","1","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵡⴰⵃⵉⵜ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⵃⴰⴳⴳⴰⵢ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("HG2_2","038_2_2","HAG","2","2","2","“ⵙⵉⵡⴻⵍ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⵍⵡⴰⵍⵉ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵖⴰⵔ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓ ⵖⴰⵔ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("HG2_3","038_2_3","HAG","2","3","3","ⵡⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵄⴰⴷ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵙ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ? ⴷ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵜ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵍⴻⵅⵅⵓ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵊⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⵎ ⵡⴰⵍⵓ? ");
INSERT INTO rift_vpl VALUES ("HG2_4","038_2_4","HAG","2","4","4","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵎⵃⴻⴹ, ⴰ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⵃⴻⴹ, ⴰ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴻⵃⴹⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⴽⴽⴰⵔⴻⵎ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("HG2_5","038_2_5","HAG","2","5","5","ⴰⵡⴰⵍ ⵉ ⵣⵉ ⴳⴳⵉⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⴰⴽⵉⴷⵡⴻⵎ, ⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵎⵉⵚⵔⴰ, ⵓ ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("HG2_6","038_2_6","HAG","2","6","6","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵄⴰⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵏ ⵍⵃⴰⵍ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵖ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⴻⴱⵃⴰⵔ ⴷ ⵍⴱⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("HG2_7","038_2_7","HAG","2","7","7","ⵏⴻⵛⵛ ⴰⴷ ⵊⵊⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴰⵔⵊⵉⵊⴻⵏ ⵓ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵎⵉⵏ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⵛⵓⵔⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵙ ⵓⵄⵓⴵⵉ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("HG2_8","038_2_8","HAG","2","8","8","ⵉⵏⵓ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵉⵏⵓ ⵡⵓⵔⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("HG2_9","038_2_9","HAG","2","9","9","ⴰⵄⵓⴵⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵍⴻⵀⵏⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("HG2_10","038_2_10","HAG","2","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⴼⵓⵙ ⵏ ⵃⴰⴳⴳⴰⵢ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("HG2_11","038_2_11","HAG","2","11","11","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵙⴻⵇⵙⴰⵎ ⵅⴻⵏⵏⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵅ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵏⵉ: ");
INSERT INTO rift_vpl VALUES ("HG2_12","038_2_12","HAG","2","12","12","ⵅⵣⴰⵔ, ⵉⵊⵊⴻⵏ ⵉⴽⵙⵉ ⴰⵢⵙⵓⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⴻⴳ ⵓⴱⴻⵃⵔⵓⵔ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓ ⵙ ⵓⴱⴻⵃⵔⵓⵔ ⵏⵏⴻⵙ ⵉⵃⴰⴷⴰ ⴰⵖⵔⵓⵎ ⵏⵉⵖ ⵎⵉⵏ ⵉⵡⴻⵏⵏⴰⵏ ⵏⵉⵖ ⴱⵉⵏⵓ ⵏⵉⵖ ⵣⵣⴻⵛⵜ ⵏⵉⵖ ⵎⵉⵏ ⵎⴰ ⵉⵜⵜⴻⵎⵡⴰⵛⵛⴰⵏ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵇⴻⴷⴷⴻⵙ?” ⵓⵛⴰ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵏⵏⴰⵏ “ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("HG2_13","038_2_13","HAG","2","13","13","ⵓⵛⴰ ⵉⵏⵏⴰ ⵃⴰⴳⴳⴰⵢ: “ⵎⴰⵍⴰ ⵉⵊⵊ ⵉⴷⵡⴻⵍ ⵉⵅⵎⴻⵊ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⵛⴱⴻⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵃⴰⴷⴰ ⵛⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵅⴻⵏⵏⵉ ⵉⵅⵎⴻⵊ?” ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵏⵏⴰⵏ: “ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵅⵎⴻⵊ!” ");
INSERT INTO rift_vpl VALUES ("HG2_14","038_2_14","HAG","2","14","14","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵃⴰⴳⴳⴰⵢ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⵍⴳⴻⵏⵙ-ⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓ ⵎⵉⵏ ⵇⴻⴷⴷⵎⴻⵏ ⴷ ⴷⴷⴱⵉⵃⴻⵜ, ⴰⵇⴰ-ⵜⵜ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("HG2_15","038_2_15","HAG","2","15","15","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵣⴻⴳ ⵡⴰⵙⵙ-ⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴳⴳⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ: ⵇⴱⴻⵍ ⵎⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵡⴻⵥⵍⵓ ⵅ ⵡⴻⵥⵔⵓ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("HG2_16","038_2_16","HAG","2","16","16","ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⵓⵢⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵢⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵢⵉⵊⵊ ⵏ ⵓⵄⵓⵔⵔⵉⵛ ⵏ ⵉⵎⴻⵏⴷⵉ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⴻⵇⵢⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⵖⵉⵔ ⵄⴻⵛⵔⴰ, ⵓ ⵢⵓⵙⴰ-ⴷⴷ ⵢⵉⵊⵊ ⵖⴰⵔ ⵢⵉⵛⵜ ⵏ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵢⴻⵎ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⴱⴰⵔⵎⵉⵍⴻⵏ, ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⵖⵉⵔ ⵄⵉⵛⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("HG2_17","038_2_17","HAG","2","17","17","ⵏⴻⵛⵛ ⵡⵜⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵎⴻⵏⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵎⴹⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ, ⵙ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵡⴻⴼⵙⵓ ⵓ ⵙ ⵜⴻⴱⵔⵓⵔⵔⵉ, ⵡⵜⵉⵖ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵉ ⵜⴻⴷⵡⵉⵍⴻⵎ ⵛⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HG2_18","038_2_18","HAG","2","18","18","ⵣⴻⴳ ⵡⴰⵙⵙ-ⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴳⴳⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ, ⴳⴳⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("HG2_19","038_2_19","HAG","2","19","19","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵣⵣⴰⵔⵔⵉⵄⴻⵜ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ? ⵜⴰⵣⴰⵢⴰⵔⵜ ⴷ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⴰⵔⴻⵎⵎⴰⵏ ⴷ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵄⴰⴷ ⵍⵖⵉⴵⴻⵜ! ⵣⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⴰⴷ ⴱⴰⵔⴽⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("HG2_20","038_2_20","HAG","2","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵃⴰⴳⴳⴰⵢ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("HG2_21","038_2_21","HAG","2","21","21","“ⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵍⵡⴰⵍⵉ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵏⵉ: ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵏⵀⴻⵣⵣⴻⵖ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("HG2_22","038_2_22","HAG","2","22","22","ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵍⵄⴰⵔⵛ ⵏ ⵜⴳⴻⵍⴷⵉⵏ ⴷ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⵜⴳⴻⵍⴷⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵏⵇⴻⵍⴱⴻⵖ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵙ ⵢⵉⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵓⵍⴰ ⴷ ⵢⵉⵢⵙⴰⵏ ⴰⴽ-ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵖⴻⴹⵍⴻⵏ, ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵙⵙⵉⴼ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("HG2_23","038_2_23","HAG","2","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵖ, ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰ’ⴰⵍⵜⵉⵢⴰⵍ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴷ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵓⵛⴻⵎⵎⴻⵄ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵉⵅⴹⴰⵔⴻⵖ ⵛⴻⴽ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC1_1","039_1_1","ZEC","1","1","1","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⴷⴰⵔⵉⵢⵓⵙ, ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⴷⴷⵓ, ⴰⵏⴰⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC1_2","039_1_2","ZEC","1","2","2","“ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⵉⴼⴼⵓⴳⴻⵎ ⴰⵟⵟⴰⵙ ⵅ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC1_3","039_1_3","ZEC","1","3","3","ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ-ⴷⴷ ⴷⴻⵡⵍⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC1_4","039_1_4","ZEC","1","4","4","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⴱⴰⵔⵔⵃⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵣⵉⵛ, ⵏⵏⴰⵏ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵡⴻⵎ ⵉⵄⴻⴼⴼⵏⴻⵏ ⵓ ⵣⵉ ⵜⵎⴻⴳⴳⴰ ⵏⵡⴻⵎ ⵉⵄⴻⴼⴼⵏⴻⵏ!’ ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵡⵛⵉⵏ ⴰⵎⴻⵣⵣⵓⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC1_5","039_1_5","ZEC","1","5","5","ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵎⴰⵏⵉ ⴵⴰⵏ? ⵓ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("ZC1_6","039_1_6","ZEC","1","6","6","ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵏⵏⵉ ⵓⵎⵓⵔⴻⵖ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵎⴰ ⵡⴰⵔ ⵍⵇⵉⴼⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ? ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ, ⵏⵏⴰⵏ: ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵏⴻⴽⴽⵯⴰ ⴰⴷ ⵢⴻⴳⴳ ⴰⴽⵉⴷⵏⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵖ ⴷ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("ZC1_7","039_1_7","ZEC","1","7","7","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ, ⵡⴰ ⴷ ⴰⵢⵓⵔ ⵏ ⵛⴰⴱⴰⵟ, ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⴷⴰⵔⵉⵢⵓⵙ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⴰⵔⴰⵅⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵉⴷⴷⵓ, ⴰⵏⴰⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("ZC1_8","039_1_8","ZEC","1","8","8","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵅ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵔⵉⵃⴰⵏⵜ ⴷⵉ ⵍⴰⴵⴰⵖ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴷⵉⵏ ⵉⵢⵙⴰⵏ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ ⴷ ⵢⴻⵢⵙⴰⵏ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ ⴷ ⵢⴻⵢⵙⴰⵏ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC1_9","039_1_9","ZEC","1","9","9","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ?” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("ZC1_10","039_1_10","ZEC","1","10","10","ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵔⵉⵃⴰⵏⵜ, ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵃⵉⵎⴰ ⴰⴷ ⵙⵓⵃⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC1_11","039_1_11","ZEC","1","11","11","ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵊⴰⵔ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵜⵔⵉⵃⴰⵏⵜ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⵙⵓⵃ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵇⵇⵉⵎ, ⵜⴰⵔⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("ZC1_12","039_1_12","ZEC","1","12","12","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵍ ⵎⴻⵍⵎⵉ ⵄⴰⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵃⵉⵏⵏⵉⴷ ⵅ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵅ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵢⴰⵀⵓⴷⴰ ⵏⵏⵉ ⵅ ⵜⵓⵖⴰ ⵜⵙⴻⵅⴹⴻⴷ ⵙⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ-ⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("ZC1_13","039_1_13","ZEC","1","13","13","ⵙⵉⴷⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵛⵏⴰⵏ, ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("ZC1_14","039_1_14","ZEC","1","14","14","ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴱⴰⵔⵔⴻⵃ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵏⴻⵛⵛ ⵓⵙⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵚⵉⵀⵢⵓⵏ ⵙ ⵡⴰⵙⴰⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC1_15","039_1_15","ZEC","1","15","15","ⵙ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⴼⴼⵓⴳⵎⴻⵖ ⵅ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⴻⴼⵅⴻⵏ. ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴼⴼⵓⴳⵎⴻⵖ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵏ ⵍⵡⴻⵇⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ ⴰⵔⵏⵉⵏ ⴷⴰⵢⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("ZC1_16","039_1_16","ZEC","1","16","16","ⵙ ⵓⵢⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵜⴻⵃⵏⵓⵏⴻⵛⵜ, ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⴷⴰⵢⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓⵛⴰ ⴰⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵅ ⵓⵔⵛⴰⵍⵉⵎ.’ ");
INSERT INTO rift_vpl VALUES ("ZC1_17","039_1_17","ZEC","1","17","17","ⴰⵔⵏⵉ ⴱⴰⵔⵔⴻⵃ, ⵉⵏⵉ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉⵏⵓ ⴰⴷ ⴼⴻⵢⵢⴹⴻⵏⵜ ⵄⴰⵡⴻⴷ ⵙ ⵍⵅⴰⵔ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵚⵉⵀⵢⵓⵏ ⵄⴰⵡⴻⴷ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵅⴹⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⵡⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("ZC2_1","039_2_1","ZEC","2","1","1","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC2_2","039_2_2","ZEC","2","2","2","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⴼⵉ: “ⵉⵏⴰ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⵉ ⵉⵣⵣⵓⵣⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ, ⵉⵙⵔⴰⵉⵍ ⴷ ⵓⵔⵛⴰⵍⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("ZC2_3","039_2_3","ZEC","2","3","3","ⵅⴻⵏⵏⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵣⵉⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC2_4","039_2_4","ZEC","2","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵎⵉⵏ ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ?” ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵏⵏⴰ: “ⵉⵏⴰ ⴷ ⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⵉ ⵉⵣⵣⵓⵣⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵏⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵅⵍⵄⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴹⴰⵔⴻⵏ ⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵛⵛ ⴹⵉⴷⴷ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵣⵓⵣⵣⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ZC2_5","039_2_5","ZEC","2","5","5","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵓⴼⵉⵍⵓ ⵏ ⵍⴻⵄⴱⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC2_6","039_2_6","ZEC","2","6","6","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵛⴻⴽ?” ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ “ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵄⴱⴰⵔⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵥⴰⵔⴻⵖ ⵎⴻⵛⵃⴰⵍ ⵜⴻⴵⴰ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⵓ ⵎⴻⵛⵃⴰⵍ ⵜⴻⴵⴰ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("ZC2_7","039_2_7","ZEC","2","7","7","ⵓ ⵅⵣⴰⵔ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵎⵎⴻⵍⵇⴰ, ");
INSERT INTO rift_vpl VALUES ("ZC2_8","039_2_8","ZEC","2","8","8","ⵉⵏⵏⴰ ⴰⵙ: “ⴷⴻⵖⵢⴻⵜ, ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵓⵃⵓⴷⵔⵉ ⵏⵏⵉ, ⵉⵏⵉ: ‘ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵓⵔⵔⵣⵎⴻⵏⵜ ⴱⵍⴰ ⵍⴻⵃⵢⵓⴹ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC2_9","039_2_9","ZEC","2","9","9","ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵉⵍⵉⵖ ⴷ ⵉⵊⵊ ⵏ ⵍⵃⵉⴹ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉ ⴷ ⴰⵙ-ⴷⴷ ⵉⵜⵜⴻⵏⵏⴹⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⵉⵍⵉⵖ ⵉ ⵓⵄⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC2_10","039_2_10","ZEC","2","10","10","ⴷⴻⵖⵢⴰⵎ, ⴷⴻⵖⵢⴰⵎ, ⴰⵔⴻⵡⵍⴻⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴱⴹⵉⵖ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC2_11","039_2_11","ZEC","2","11","11","ⴷⴻⵖⵢⴰⵜ, ⵚⵉⵀⵢⵓⵏ, ⴼⴻⴽⴽⴻⵜ, ⵛⴻⵎ ⴷ ⵜⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵖⴰⵔ ⵢⴻⴵⵉⵙ ⵏ ⴱⴰⴱⵉⵍ!’” ");
INSERT INTO rift_vpl VALUES ("ZC2_12","039_2_12","ZEC","2","12","12","“ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵄⵓⴵⵉ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵎ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵃⴰⴷⴰⵏ, ⵉⵃⴰⴷⴰ ⵎⵓⵎⵎⵓ ⵏ ⵜⵉⵟⵟ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ZC2_13","039_2_13","ZEC","2","13","13","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵅⴰⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵙⴻⵏ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC2_14","039_2_14","ZEC","2","14","14","ⵙⵍⵉⵡⵍⴻⵡ ⵓ ⴼⴰⵔⵃ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵓ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("ZC2_15","039_2_15","ZEC","2","15","15","‘ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⴰⴷ ⵇⵇⵏⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏⵏⴻⵎ ⵓ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC2_16","039_2_16","ZEC","2","16","16","ⵙⵉⴷⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴼⴰⵔⵣ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("ZC2_17","039_2_17","ZEC","2","17","17","ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⴰⴷ ⵉⵙⵙⴻⵖⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⴼⴰⵇ-ⴷⴷ ⵣⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("ZC3_1","039_3_1","ZEC","3","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵢⴰⵀⵓⵛⴰⵄ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ. ⵛⵛⵉⵟⴰⵏ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵢⴰⵛⵓⵄⴰ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⵛⴻⵜⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("ZC3_2","039_3_2","ZEC","3","2","2","ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵛⵛⵉⵟⴰⵏ: “ⴰⴷ ⵢⵉⵍⵉ ⴰⴷ ⵛⴻⴽ ⵉⵄⴰⵇⴻⴱ ⵙⵉⴷⵉ, ⴰ ⵛⵛⵉⵟⴰⵏ! ⴰⴷ ⵛⴻⴽ ⵉⵄⴰⵇⴻⴱ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⴼⴰⵔⵣⴻⵏ ⵓⵔⵛⴰⵍⵉⵎ! ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵢⴰⵀⵓⵛⴰⵄ ⵡⴰⵏⵉⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵇⴻⵍⵄⴻⵏ ⵜ-ⴷⴷ ⵣⵉ ⵜⵎⴻⵙⵙⵉ?” ");
INSERT INTO rift_vpl VALUES ("ZC3_3","039_3_3","ZEC","3","3","3","ⵢⴰⵀⵓⵛⴰⵄ ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵉⵡⴻⵙⵙⵅⴻⵏ ⴰⵎ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵎⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("ZC3_4","039_3_4","ZEC","3","4","4","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵏⴻⵜⵜⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴽⴽⵙⴻⵎ ⴰⵙ ⴰⵔⵔⵓⴹ ⵉⵡⴻⵙⵙⵅⴻⵏ ⵉ ⵡⴰⵏⵉⵜⴰ!” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴽⴽⵙⴻⵖ ⵣⵣⴰⵢⴻⴽ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵛⴻⴽ ⵙⵙⵢⴰⵔⴹⴻⵖ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ZC3_5","039_3_5","ZEC","3","5","5","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⴰⴷ ⴰⵙ ⵇⵇⵏⴻⵏ ⵉⵛⵜ ⵏ ⴰⵔⴻⵥⵥⴻⵜ ⵜⴰⵎⴻⵣⴷⴰⴳⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ!” ⵓ ⵏⵉⵜⵏⵉ ⵇⵇⵏⴻⵏ ⴰⵙ ⴰⵔⴻⵥⵥⴻⵜ ⵜⴰⵎⴻⵣⴷⴰⴳⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⵢⴰⵔⴹⴻⵏ ⴰⵙ ⴰⵔⵔⵓⴹ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ, ⴰⵎ ⵜⵓⵖⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⴱⴻⴷⴷ ⴷⵉⵏ ");
INSERT INTO rift_vpl VALUES ("ZC3_6","039_3_6","ZEC","3","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵛⵀⴻⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⵢⴰⵀⵓⵛⴰⵄ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC3_7","039_3_7","ZEC","3","7","7","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⵓⵢⵓⵔⴻⴷ ⵅ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ, ⵓ ⵎⴰⵍⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵓⵢⵓⵔⴻⴷ ⵓⵍⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵙ ⵍⵃⴻⵇⵇ ⵓ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵃⴹⴰⵢ ⵏ ⵍⴻⵎⵔⴰⵃⴰⵜ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵊⴰⵔ ⵉⵏⵏⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC3_8","039_3_8","ZEC","3","8","8","ⵅⴻⵏⵏⵉ ⵙⴻⵍ, ⵢⴰⵀⵓⵛⴰⵄ, ⵛⴻⴽ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵛⴻⴽ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵛ, ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜⴻⴽ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵓⵜⴻⴱⵀⴻⵜ, ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵖ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ‘ⴰⵖⴻⴷⴷⵓ’. ");
INSERT INTO rift_vpl VALUES ("ZC3_9","039_3_9","ZEC","3","9","9","ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴰⵥⵔⵓ, ⵡⴻⵏⵏⵉ ⴷⵉⵏ ⵙⵙⴰⵔⵙⴻⵖ ⵣⵣⴰⵜ ⵉ ⵢⴰⵀⵓⵛⴰⵄ, ⵅ ⵡⴻⵥⵍⵓ ⵏⵏⵉ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴻⵇⵛⴻⵖ ⵜⴰⵏⴻⵇⵇⴰⵛⵜ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴽⵙⴻⵖ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ! ");
INSERT INTO rift_vpl VALUES ("ZC3_10","039_3_10","ZEC","3","10","10","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⴷ ⵜⵄⴰⵔⴹⴻⵎ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙⴰⴷⵓ ⵜⵣⴰⵢⴰⵔⵜ ⵓ ⵙⴰⴷⵓ ⵡⴰⵔⵜⵓ.’” ");
INSERT INTO rift_vpl VALUES ("ZC4_1","039_4_1","ZEC","4","1","1","ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵉⵄⵇⴻⴱ-ⴷⴷ ⵓⵛⴰ ⵉⵙⵙⴼⴰⵇ ⴰⵢⵉ-ⴷⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵙⵙⴼⴰⵇⴰⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⴻⴳ ⵢⵉⴹⴻⵚ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC4_2","039_4_2","ZEC","4","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵎⵉⵏ ⵜⴻⵥⵔⵉⴷ?” ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵏⴻⵛⵛ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⵇⴻⵏⴷⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⵎⴰⵔⵔⴰ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵣⵣⴻⵛⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⵅⴰⵙ ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ, ⵙⴻⴱⵄⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⴱⵓⴹⴻⵏ ⵉ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("ZC4_3","039_4_3","ZEC","4","3","3","ⵓ ⵣⵣⴰⵜⴻⵙ ⴰⵇⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ, ⵉⵊⵊ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵣⵣⴻⵛⵜ ⵓ ⵉⵊⵊ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("ZC4_4","039_4_4","ZEC","4","4","4","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵓ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵏⵏⵉⵖ: “ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⵉⵏ ⵄⵏⴰⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("ZC4_5","039_4_5","ZEC","4","5","5","ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴻⴽ, ⵎⵉⵏ ⵄⵏⴰⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ?” ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("ZC4_6","039_4_6","ZEC","4","6","6","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⴰⴽⵉⴷⵉ, ⵉⵏⵏⴰ: “ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⴰⵡⴰⵍ ⵏⵏⵉ ⵉⵇⵇⴰⵔ: ‘ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵊⵊⴻⵀⴷ ⵓⵍⴰ ⵙ ⵍⵄⵓⵏⴼ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⴰⵔⵔⵓⵃ ⵉⵏⵓ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC4_7","039_4_7","ZEC","4","7","7","ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰ ⴰⴷⵔⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ? ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⵉⵛⵜ ⵏ ⵍⵡⴰⵟⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵥⵔⵓ ⵏ ⵏⵏⴻⵊ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ: ‘ⴰⵔⴹⴰ, ⴰⵔⴹⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ!’” ");
INSERT INTO rift_vpl VALUES ("ZC4_8","039_4_8","ZEC","4","8","8","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC4_9","039_4_9","ZEC","4","9","9","“ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⵙⵙⴰⵔⵙⴻⵏ ⴷⵙⴰⵙ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⴽⴻⵎⵎⵍⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC4_10","039_4_10","ZEC","4","10","10","ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⴰⵙⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ? ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⵉ ⴳⴳⵓⵔ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⵅⵎⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⴰⵥⵔⵓ ⵏ ⵜⴻⵖⵎⴰⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵏⵏⵉ ⵉⵜⵜⴻⴽⴽⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC4_11","039_4_11","ZEC","4","11","11","ⵏⴻⵛⵛ ⴰⵔⵔⴻⵖ-ⴷⴷ, ⵏⵏⵉⵖ ⴰⵙ: “ⵎⴰⵏⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⴻⵎⵎⵓⵔⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⴷ ⵓⵥⴻⵔⵎⴰⴹ ⵏ ⵍⵇⴻⵏⴷⵉⵍ?” ");
INSERT INTO rift_vpl VALUES ("ZC4_12","039_4_12","ZEC","4","12","12","ⴰⵔⵏⵉⵖ ⵟⵟⴼⴻⵖ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵏⵏⵉⵖ ⴰⵙ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⴼⵔⵓⵄ ⵏ ⵓⵣⴻⵎⵎⵓⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⴷⴰⵙ ⵏ ⵡⵓⵔⴻⵖ, ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴼⴰⵔⵔⴰⵖⴻⵏ ⵣⵣⴻⵛⵜ ⵙ ⵜⵉⵏⵜⴰ ⵏⵏⴻⵙ ⵏ ⵡⵓⵔⴻⵖ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⵓⴷⴰⵙ ⵏⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("ZC4_13","039_4_13","ZEC","4","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵡⴰⵍ-ⴷⴷ ⵖⴰⵔⵉ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴻⴽ ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ?” ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("ZC4_14","039_4_14","ZEC","4","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵉⵏⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⵉⵜⵜⵡⴰⴷⴻⵀⵏⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC5_1","039_5_1","ZEC","5","1","1","ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵉⵟⵟⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("ZC5_2","039_5_2","ZEC","5","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ?” ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵉⵟⵟⴰⵡ ⵙ ⵢⵉⵊⵊ ⵏ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⵓ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵖⴰⴵⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ZC5_3","039_5_3","ZEC","5","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵜⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵛⴰⵔⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ-ⴰ ⵓ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵊⵊⴰⴵⴻⵏ ⵥⵓⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⵅ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC5_4","039_5_4","ZEC","5","4","4","ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵏⵏⴻⵄⵍⴻⵜ ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵛⴻⴼⴼⴰⵔ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵊⴰⴵⴰⵏ ⵥⵓⵔ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⵙⵙⴻⵏⵙ ⴷⵉ ⵍⵡⴻⵙⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⵜ ⵢⴻⵛⵛ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵏⵏⴻⵙ ⴷ ⵉⵥⵔⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("ZC5_5","039_5_5","ZEC","5","5","5","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵓ ⵅⵣⴰⵔ ⵎⵉⵏ ⴷⵉⵏ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("ZC5_6","039_5_6","ZEC","5","6","6","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: “ⵎⴰⵏⴰⵡⵢⴰ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰ ⴷ ⵍⵎⵓⴷ ⵏ ⵉⴼⴰ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ.” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵜⴰ ⴷ ⴼⵓⵔⵎⴰ ⵏⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC5_7","039_5_7","ZEC","5","7","7","ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵍⴻⵅⴼⵉⴼ ⴷ ⵜⴰⵇⵓⵔⴰⵔⵉⵔⵜ ⵓ ⵜⴻⵇⵇⵉⵎ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("ZC5_8","039_5_8","ZEC","5","8","8","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵜⴰ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ!” ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜⵜ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵉⴼⴰ ⵏⵏⵉ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⴰⵥⵔⵓ ⵏ ⵍⴻⵅⴼⵉⴼ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC5_9","039_5_9","ZEC","5","9","9","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵣⵣⴰⵜ ⵓ ⴰⵙⴻⵎⵎⵉⴹ ⵉⵛⵛⵓⵔ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏⵜ. ⵏⵉⵜⴻⵏⵜⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏⵜ ⴰⴼⵔⵉⵡⴻⵏ ⴰⵎ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏ ⵓⴱⴻⵍⵍⴰⵔⵊ ⵓ ⵏⵉⵜⴻⵏⵜⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵉⴼⴰ ⵏⵏⵉ ⵊⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("ZC5_10","039_5_10","ZEC","5","10","10","ⵅⴻⵏⵏⵉ ⵏⵏⵉⵖ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ: “ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵏⵜ ⴰⴽ-ⴷ ⵉⴼⴰ-ⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("ZC5_11","039_5_11","ZEC","5","11","11","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⴱⵏⴰⵏ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵉⵏⴰⵔ. ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⴷⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("ZC6_1","039_6_1","ZEC","6","1","1","ⵏⴻⵛⵛ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⵓⵔⴰⵔ ⵓ ⵉⴷⵓⵔⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⴷⵓⵔⴰⵔ ⵏ ⵏⵏⵃⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC6_2","039_6_2","ZEC","6","2","2","ⵖⴰⵔ ⵓⴽⴰⵔⵔⵓ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵢⵙⴰⵏ ⴷ ⵉⵣⴻⴳⴳⵯⴰⵖⴻⵏ, ⵖⴰⵔ ⵓⴽⴰⵔⵔⵓ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵢⵙⴰⵏ ⴷ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ZC6_3","039_6_3","ZEC","6","3","3","ⵖⴰⵔ ⵓⴽⴰⵔⵔⵓ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵢⵙⴰⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⵓ ⵖⴰⵔ ⵓⴽⴰⵔⵔⵓ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵉⵢⵙⴰⵏ ⴷ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵢⵙⴰⵏ ⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC6_4","039_6_4","ZEC","6","4","4","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ, ⵏⵏⵉⵖ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("ZC6_5","039_6_5","ZEC","6","5","5","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵉⵏⴰ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵎⴰⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC6_6","039_6_6","ZEC","6","6","6","ⵉⵏⵏⵉ ⵙ ⵉⵢⵙⴰⵏ ⵉⴱⴰⵔⵛⴰⵏⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ ⵓ ⵉⵢⵙⴰⵏ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⴰⴷ ⵜⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ, ⵓⵛⴰ ⵉⵢⵙⴰⵏ ⵉⵇⴰⵔⵇⴰⵛⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("ZC6_7","039_6_7","ZEC","6","7","7","ⵉⵢⵙⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ ⴼⴼⵖⴻⵏ, ⴰⵔⵣⵓⵏ ⴰⴷ ⵥⵡⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⴼⴼⵖⴻⵎ, ⵥⵡⴰⵎ ⵜⴰⵎⵎⵓⵔⵜ!” ⵓ ⵏⵉⵜⵏⵉ ⵥⵡⴰⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC6_8","039_6_8","ZEC","6","8","8","ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵉⵢⵙⴰⵏ ⵏⵏⵉ ⵉⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ, ⴰⵇⴰ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵛⵛⴰⵎⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("ZC6_9","039_6_9","ZEC","6","9","9","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC6_10","039_6_10","ZEC","6","10","10","“ⴽⵙⵉ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⵎⴻⵏⴼⴰ, ⵣⵉ ⵃⴰⵍⵉⵎ, ⵟⵓⴱⵉⵢⴰ ⴷ ⵢⴰⴷⴰⵄⵢⴰ ⵓ ⵔⵓⵃ ⴷⵉⵏⵏⵉ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓ ⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵛⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴼⴰⵏⵢⴰ, ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("ZC6_11","039_6_11","ZEC","6","11","11","ⴽⵙⵉ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ, ⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵉⵊⴰⵏ ⵓ ⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⴰⵀⵓⵛⴰⵄ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⵚⴰⴷⴰⵇ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ZC6_12","039_6_12","ZEC","6","12","12","ⵓ ⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵉ ⴰⵙ: ‘ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ‘ⴰⵖⴻⴷⴷⵓ’ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⵏⴰ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC6_13","039_6_13","ZEC","6","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⵏⴰ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴰⴷ ⵢⴰⵔⴹ ⵍⵄⴰⴹⴰⵎⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵓ ⴰⴷ ⵢⵉⵍⵉ ⵊⴰⵔ ⴰⵙⴻⵏ ⵛⵛⵡⴰⵔ ⵙ ⵍⴻⵀⵏⴰ.’ ");
INSERT INTO rift_vpl VALUES ("ZC6_14","039_6_14","ZEC","6","14","14","ⵜⵜⵉⵊⴰⵏ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵃⴰⵍⵉⵎ, ⵟⵓⴱⵉⵢⴰ, ⵢⴰⴷⴰⵄⵢⴰ ⴷ ⵃⴰⵢⵏ, ⵎⵎⵉⵙ ⵏ ⵚⴰⴼⴰⵏⵢⴰ, ⴷ ⵍⵉⴷⴰⵔⴻⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC6_15","039_6_15","ZEC","6","15","15","ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵡⴷⴰⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⵏⴰⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ. ⴰⵢⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵙⵍⴰⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("ZC7_1","039_7_1","ZEC","7","1","1","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵔⵉⵢⵓⵙ, ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵏ ⴽⵉⵙⵍⵓⵡ, ");
INSERT INTO rift_vpl VALUES ("ZC7_2","039_7_2","ZEC","7","2","2","ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ ⵍⴳⴻⵏⵙ ⵏ ⴱⴰⵢⵜ-ⵉⵍ ⵛⴰⵔⴰⵚⵉⵔ ⴷ ⵔⴰⵊⴰⵎ-ⵎⴰⵍⵉⴽ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("ZC7_3","039_7_3","ZEC","7","3","3","ⵓⵎⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⴰⴽ-ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ: “ⵎⴰ ⴰⴷ ⴰⵔⵏⵉⵖ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⴰⴷ ⵔⵓⵖ ⵓ ⴰⴷ ⵄⴻⵣⵍⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵜⴻⴳⴳⴻⵖ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ?” ");
INSERT INTO rift_vpl VALUES ("ZC7_4","039_7_4","ZEC","7","4","4","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC7_5","039_7_5","ZEC","7","5","5","“ⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵓ ⴰⴽ-ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵉ: ⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵥⵓⵎⵎⴻⵎ ⵓ ⵜⴻⵡⵜⵉⵎ ⵅ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵣⴻⴳ ⵡⴻⵛⴹⴰⵏ, ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵓ ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰ ⵜⵥⵓⵎⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅⴻⵏⵏⵉ ⵉ ⵏⴻⵛⵛ, ⵙ ⵜⵉⴷⴻⵜⵜ ⵉ ⵏⴻⵛⵛ? ");
INSERT INTO rift_vpl VALUES ("ZC7_6","039_7_6","ZEC","7","6","6","ⵍⴰⵎⵉ ⵜⴻⵛⵛⵉⵎ ⵓ ⵍⴰⵎⵉ ⵜⴻⵙⵡⵉⵎ, ⵎⴰ ⵡⴰⵔ ⵜⵉⵛⵛⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓ ⵎⴰ ⵡⴰⵔ ⵜⵉⵙⵡⵉⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("ZC7_7","039_7_7","ZEC","7","7","7","ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⵍⵉⵇ ⴰⴷ ⵢⵉⵍⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵣⵉⵛ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵓⵔⵛⴰⵍⵉⵎ ⵄⴰⴷ ⵙ ⵉⵎⴻⵣⴷⴰⵖ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⴰⴽ-ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵓ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵎⴻⵣⴷⴰⵖ ⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵡⴰⵟⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("ZC7_8","039_7_8","ZEC","7","8","8","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC7_9","039_7_9","ZEC","7","9","9","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵃⴻⴽⵎⴻⵎ ⵙ ⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⴳⴳⴻⵎ ⵙ ⵜⵎⴻⵅⵙⵉⵡⵜ ⵉⵛⴻⵡⵡⴰⵔⴻⵏ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵉⵊⵊ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC7_10","039_7_10","ZEC","7","10","10","ⵡⴰⵔ ⵃⴻⵚⵚⴰⵔⴻⵎ ⵜⴰⵊⵊⴰⵍⵜ ⵓⵍⴰ ⴷ ⴰⵢⵓⵊⵉⵍ ⵏⵉⵖ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵓⵍⴰ ⴷ ⴰⵎⴻⵥⵍⵓⴹ, ⵓ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵍⵖⴰⵔ ⴹⵉⴷⴷ ⵉ ⵓⵎⴰⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("ZC7_11","039_7_11","ZEC","7","11","11","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵓⴳⵉⵏ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ ⵓ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵙ ⵍⵎⴻⵇⵍⵓⴱ ⵓ ⴱⴻⵍⵍⵄⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC7_12","039_7_12","ZEC","7","12","12","ⵏⵉⵜⵏⵉ ⵙⵙⵇⴻⵙⵃⴻⵏ ⵓⵍ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵎⵉⵔ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵣⵉⵛ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC7_13","039_7_13","ZEC","7","13","13","ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵍⴰⵖⴰ ⵏⴻⵜⵜⴰ ⵣⵉⵛ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵍⴰⵖⴰⵏ ⵍⴻⵅⵅⵓ ⵏⵉⵜⵏⵉ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵖ ⵛⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC7_14","039_7_14","ZEC","7","14","14","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵣⵓⵣⵣⴰⵔⴻⵖ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴰⵔⵔⴻⴱ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵄⴰⴷ ⵡⴰⵔ ⵅⴰⵙ ⵉⵥⴻⴽⴽⵡⵉ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵡⵉⵍ. ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉⵄⵉⵣⵣⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵓⵏⴻⵅⵍⵉⵄ.’” ");
INSERT INTO rift_vpl VALUES ("ZC8_1","039_8_1","ZEC","8","1","1","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC8_2","039_8_2","ZEC","8","2","2","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵙ ⵡⴰⵙⴰⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓⵙⵎⴻⵖ ⵣⵉ ⵚⵉⵀⵢⵓⵏ, ⵙ ⵡⴻⵙⵄⴰⵔ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵙⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("ZC8_3","039_8_3","ZEC","8","3","3","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⵏⴻⵛⵛ ⵄⴻⵇⴱⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵚⵉⵀⵢⵓⵏ ⵓ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ‘ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵜⵉⴷⴻⵜⵜ!’, ⵓ ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⴰⵙ ⵉⵏⵉⵏ ‘ⴰⴷⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("ZC8_4","039_8_4","ZEC","8","4","4","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰⴷ ⵉⵍⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵡⴻⵙⵙⵓⵔⴰ ⴷ ⵜⵡⴻⵙⵙⵓⵔⴰ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵖⴰ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZC8_5","039_8_5","ZEC","8","5","5","ⴰⵣⵣⴰⵢⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵉ ⵉⵜⵜⵉⵔⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢⴻⵏ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("ZC8_6","039_8_6","ZEC","8","6","6","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵎⴰⵖⴰⵔ ⴷ ⵍⴻⵄⵊⴻⴱ ⵇⴰⵄ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵢⴰ ⵓⵍⴰ ⵉ ⵏⴻⵛⵛ ⴷ ⵍⴻⵄⵊⴻⴱ ⵇⴰⵄ?’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC8_7","039_8_7","ZEC","8","7","7","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵏⵇⴰⵔ ⵏ ⵜⴼⵓⵛⵜ ⵓ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵓⵖⴻⴵⵉ ⵏ ⵜⴼⵓⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("ZC8_8","039_8_8","ZEC","8","8","8","ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⴰⵡⵢⴻⵖ ⴷⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉ ⵏⴻⵛⵛ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⵉⵜⵏⵉ, ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⵓ ⴷⵉ ⵜⵙⴻⴳⴷⴰ.’ ");
INSERT INTO rift_vpl VALUES ("ZC8_9","039_8_9","ZEC","8","9","9","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⵎⴻⵃⴹⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ-ⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵉ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ZC8_10","039_8_10","ZEC","8","10","10","ⵎⴰⵖⴰⵔ ⵇⴱⴻⵍ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵡⴰⵍⵓ ⵣⵉ ⵍⵎⵓⵏⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵉⵛⵜ ⵏ ⵍⴻⴱⵀⵉⵎⴻⵜ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⴰⵡⵉ ⵡⴰⵍⵓ ⵓ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴷⴻⵡⵍⴻⵏ, ⵡⴰⵔ ⵢⵉⵡⵉ ⵍⴰⵎⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵄⴷⵓ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC8_11","039_8_11","ZEC","8","11","11","ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵎ ⵡⵓⵙⵙⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC8_12","039_8_12","ZEC","8","12","12","ⵎⴰⵖⴰⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵍⴻⵀⵏⴰ, ⵜⴰⵣⴰⵢⴰⵔⵜ, ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵡⵛ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ ⵓ ⴰⵊⴻⵏⵏⴰ ⴰⴷ ⵉⵡⵛ ⵏⵏⴷⴰ ⵏⵏⴻⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵉ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("ZC8_13","039_8_13","ZEC","8","13","13","ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵏⵏⴻⵄⵍⴻⵜ ⵊⴰⵔ ⵔⴻⴳⵏⵓⵙ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵓ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⴽⴻⵏⵏⵉⵡ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ, ⵎⴻⵃⴹⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ!’ ");
INSERT INTO rift_vpl VALUES ("ZC8_14","039_8_14","ZEC","8","14","14","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵅⴰⵔⵔⵚⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⵍⵖⴰⵔ, ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵙⵙⴼⵓⴳⵎⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵏⴷⵉⵎⴻⵖ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("ZC8_15","039_8_15","ZEC","8","15","15","ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ ⵏⴻⵛⵛ ⵍⴻⵅⵅⵓ ⴰⴷ ⵅⴰⵔⵔⵚⴻⵖ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ-ⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵍⵅⴰⵔ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("ZC8_16","039_8_16","ZEC","8","16","16","ⵜⵉⵏⴰ ⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴰⴷ ⵜⴻⵏⵜ ⵜⴻⴳⴳⴻⵎ: ⵙⵉⵡⵍⴻⵎ ⵜⵉⴷⴻⵜⵜ ⴽⵓⵍ ⵉⵊⵊ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵛⴰⵔⵔⵄⴻⵎ ⴷⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵡⴻⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⵓ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵍⵉⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC8_17","039_8_17","ZEC","8","17","17","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵍⵖⴰⵔ ⵅ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵎ ⵜⴰⵊⴰⴵⵉⵜ ⵥⵓⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵛⴰⵔⵔⵀⴻⵖ ⵎⴰⵔⵔⴰ ⴰⵢⴰ!’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("ZC8_18","039_8_18","ZEC","8","18","18","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("ZC8_19","039_8_19","ZEC","8","19","19","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰⵥⵓⵎⵎⵉ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵓ ⴰⵥⵓⵎⵎⵉ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵓ ⴰⵥⵓⵎⵎⵉ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵓ ⴰⵥⵓⵎⵎⵉ ⵏ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⴷ ⵡⴰⵔⵛⴻⵇ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ. ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵛⵏⴰⵏ. ⵅⵙⴻⵎ ⵜⵉⴷⴻⵜⵜ ⴷ ⵍⴻⵀⵏⴰ!’ ");
INSERT INTO rift_vpl VALUES ("ZC8_20","039_8_20","ZEC","8","20","20","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴰⵇⴰ ⵍⴻⴳⵏⵓⵙ ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵏⴻⴷⴷⴰⵎ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵄⴰⴷ ⴷⴰⵏⵉⵜⴰ! ");
INSERT INTO rift_vpl VALUES ("ZC8_21","039_8_21","ZEC","8","21","21","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵖⵏⵉⵜ, ⴰⴷ ⵉⵏⵉⵏ: ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⴰⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵜⵜⴰⵔ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵔⵣⵓ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("ZC8_22","039_8_22","ZEC","8","22","22","ⴰⵟⵟⴰⵙ ⵏ ⵉⵢⴷⵓⴷⴻⵏ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⴰⵔⴹⴰ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ.’ ");
INSERT INTO rift_vpl VALUES ("ZC8_23","039_8_23","ZEC","8","23","23","ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ‘ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵜⵍⴰⵢⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵟⵟⴼⴻⵏ, ⵡⴰⵀ, ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⴱⴻⵃⵍⵓⵍ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵔⴰⵃ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵏⴻⵙⵍⴰ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⵡⴻⵎ!’” ");
INSERT INTO rift_vpl VALUES ("ZC9_1","039_9_1","ZEC","9","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵃⴰⴷⵔⴰⵅ, ⵍⵃⵓⴽⵎ ⵏⵏⵉ ⵢⴰⵔⵙⴰⵏ ⵅ ⴷⵉⵎⴰⵛⵇ. “ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵃⴻⵟⵟⴰ ⵅ ⴱⵏⴰⴷⴻⵎ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("ZC9_2","039_9_2","ZEC","9","2","2","ⵓⵍⴰ ⵅ ⵃⴰⵎⴰⵜ ⵉ-ⵜⵜ-ⴷⴷ-ⵉⵍⴻⵙⵇⴻⵏ, ⵅ ⵚⵓⵔ ⴷ ⵚⵉⴷⵓⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⵜⵉⵎⵉⵖⵉⵙⵉⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC9_3","039_9_3","ZEC","9","3","3","ⵜⴻⴱⵏⴰ ⵚⵓⵔ ⵉⵊⵊ ⵏ ⵍⴱⴰⵔⴰⵊ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵜⴻⵢⵔⵓ ⵏⵏⵓⵇⴰⵔⵜ ⴰⵎ ⵜⵄⴻⵊⵊⴰⵊⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ ⴰⵎ ⵓⴱⴻⴵⴰⵄ ⵏ ⵉⵎⴻⵙⵔⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("ZC9_4","039_9_4","ZEC","9","4","4","ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵜⵜ ⵉⵟⵟⴻⴼ, ⴰⴷ ⵉⵡⵡⴻⵜ ⵍⴱⴰⵔⴰⵊ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⵛⵛ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("ZC9_5","039_9_5","ZEC","9","5","5","“ⴰⵛⴽⴻⵍⵓⵏ ⴰⴷ ⵜⵜ ⵜⵥⴰⵔ, ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴻⴳⴳⵯⴻⴷ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵖⴰⵣⵣⴰ, ⴰⴷ ⵜⴰⵔⵊⵉⵊ ⴰⵟⵟⴰⵙ, ⵓⵍⴰ ⴷ ⵄⴰⵇⵔⵓⵏ, ⵎⴰⵖⴰⵔ ⴰⴷ ⵉⴼⵛⴻⵍ ⵓⵔⴰⵊⵉ ⵏⵏⴻⵙ. ⴰⴷ ⵉⵜⵜⵡⴰⵜⴻⵃⵃⴰ ⵓⵊⴻⴵⵉⴷ ⵣⵉ ⵖⴰⵣⵣⴰ ⵓ ⴷⵉ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵛⵇⴰⵍⵓⵏ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵣⴻⴷⴷⴻⵖ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC9_6","039_9_6","ZEC","9","6","6","ⵎⵎⵉⵙ ⵏ ⵍⴻⵃⵔⴰⵎ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⴰⵛⴷⵓⴷ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⵉⴼⵉⵍⵉⵙⵟⵉⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC9_7","039_9_7","ZEC","9","7","7","ⵏⴻⵛⵛ ⴰⴷ ⴽⵙⵉⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵏⵏⵄⴰⵡⴰⵜ ⵣⵉ ⵊⴰⵔ ⵜⵉⵖⵎⴰⵙ ⵏⵏⴻⵙ ⵓ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵎⵖⴰⵔ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵓ ⵄⴰⵇⵔⵓⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵢⴰⴱⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC9_8","039_9_8","ZEC","9","8","8","ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵍⵎⴰⵔⴳⴻⵃ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⴹⵉⴷⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵥⵡⴰⵏ ⵓ ⴹⵉⴷⴷ ⵏ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴷⴻⵡⵍⴻⵏ, ⵃⵉⵎⴰ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵡⴰⵔ ⵅⴰⵙ ⵉⵄⴻⴷⴷⵓ ⵛⴰ ⵄⴰⴷ, ⵎⴰⵖⴰⵔ ⵍⴻⵅⵅⵓ ⵥⵍⵉⵖ ⵜ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("ZC9_9","039_9_9","ZEC","9","9","9","“ⴼⴰⵔⵃ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵙⵍⵉⵡⵍⴻⵡ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ! ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵎ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵓ ⴰⵇⴰ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏ ⵓⵙⴻⵏⵊⴻⵎ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵡⴰⴹⴻⵄ, ⵉⵏⵢⴰ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵖⵢⵓⵍ, ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵣⵄⵓⵇ, ⴰⵙⵏⵓⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵖⵢⵓⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC9_10","039_9_10","ZEC","9","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵇⴹⵉⵖ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵓⵎⴻⵏⵖⵉ ⵣⵉ ⵉⴼⵔⴰⵢⵉⵎ ⵓⵍⴰ ⴷ ⵉⵢⵙⴰⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⴷ ⵉⵜⵜⵡⴰⵇⵍⴻⵄ ⵓⵍⴰ ⴷ ⵍⵇⴻⵡⵙ ⵏ ⵓⵎⴻⵏⵖⵉ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵀⵏⴰ ⵉ ⵔⴻⴳⵏⵓⵙ ⵓ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵍ ⵍⴻⴱⵃⴰⵔ, ⵣⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⴰⵍ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC9_11","039_9_11","ZEC","9","11","11","“ⵡⴰⵀ ⵓⵍⴰ ⴷ ⵛⴻⵎ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵎ ⴼⴻⴽⴽⴻⵖ-ⴷⴷ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⴻⵎ ⵣⴻⴳ ⵡⴰⵏⵓ ⵢⵓⵥⵖⴻⵏ ⵉ ⵡⴰⵔ ⴷⵉ ⴵⵉⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC9_12","039_9_12","ZEC","9","12","12","ⵄⴻⵇⴱⴻⵎ ⵖⴰⵔ ⵍⴱⵓⵔⵊ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵃⴱⴰⵙ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴰⵢⴰⵙ. ⵓⵍⴰ ⴷ ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ: ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⴰⵔⵔⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("ZC9_13","039_9_13","ZEC","9","13","13","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵎⴻⵃⴹⴻⵖ ⵢⴰⵀⵓⴷⴰ ⴰⵎ ⵉⵊⵊ ⵏ ⵍⵇⴻⵡⵙ ⵓ ⴰⴷ ⴳⴳⴻⵖ ⵉⴼⵔⴰⵢⵉⵎ ⵅ ⵍⵇⴻⵡⵙ. ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵎ, ⴰ ⵚⵉⵀⵢⵓⵏ, ⴹⵉⴷⴷ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵛ, ⴰ ⵢⴰⵡⴰⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵖ ⴰⵎ ⵙⵙⵉⴼ ⵏ ⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC9_14","039_9_14","ZEC","9","14","14","“ⵙⵉⴷⵉ ⴰⴷ ⵉⴱⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏ ⵓ ⴼⵍⵉⵜⵛⴰⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵜⵡⴻⵙⵙⴳⴻⵏⵜ ⴰⵎ ⵡⴰⵙⵙⴰⵎ ⵓ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵙⵉⴷⵉ, ⴰⴷ ⵉⵙⵓⴹ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴽ-ⴷ ⵜⵃⴰⵔⵢⴰⴹⵉⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("ZC9_15","039_9_15","ZEC","9","15","15","ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴷⵓⵔⵉⵢ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⵛⴻⵏ, ⴰⴷ ⴷⴷⵣⴻⵏ ⵉⵥⵔⴰ ⵏ ⵉⴵⵉⵢ ⵓⵛⴰ ⴰⴷ ⵙⵡⴻⵏ, ⴰⴷ ⴳⴳⴻⵏ ⴷⴷⵔⵉⵣ ⴰⵎ ⵖⴰⵔ ⴱⵉⵏⵓ ⵓ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⴰⵎ ⵟⵟⴰⵡⵢⴰ ⵏ ⵓⵔⵓⵛⵛⵉ, ⴰⵎ ⵜⵖⴻⵎⵎⴰⵔ ⵏ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZC9_16","039_9_16","ZEC","9","16","16","ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵎ ⵡⵓⴵⵉ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⵅ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC9_17","039_9_17","ZEC","9","17","17","ⵎⴰⵖⴰⵔ ⵎⴻⵛⵀⴰⵍ ⵉⵎⵖⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵍⵅⴰⵔ ⵏⵏⴻⵙ ⵓ ⵎⴻⵛⵀⴰⵍ ⵉⵎⵖⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵥⵍⵉ ⵏⵏⴻⵙ! ⵉⵎⴻⵏⴷⵉ ⴰⴷ ⵉⵙⵙⴻⵖⵎⵉ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ ⵓⵍⴰ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵜⵉⵄⵣⴰⵔⵉⵢⵢⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("ZC10_1","039_10_1","ZEC","10","1","1","“ⵜⵜⴰⵔⴻⵎ ⴰⵏⵥⴰⵔ ⵣⵉ ⵙⵉⴷⵉ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵏⵥⴰⵔ ⵏ ⵜⴻⴼⵙⵓⵜ. ⵙⵉⴷⵉ ⵉⵜⵜⴻⴳⴳ ⴰⵙⵙⴰⵎⴻⵏ, ⵡⴰⵀ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵉⴱⵓⴷⴰ ⵏ ⵡⴻⵏⵥⴰⵔ, ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵡⴻⴼⵙⵓ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZC10_2","039_10_2","ZEC","10","2","2","ⵎⴰⵖⴰⵔ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵍⵖⴻⵛⵛ, ⵓ ⵉⴳⴻⵣⵣⴰⵏⴻⵏ ⵜⵜⵡⴰⵍⴰⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵜⵜⵄⴰⵡⴰⴷⴻⵏ ⵜⵉⵔⵊⴰ ⵉⵛⴻⵎⵎⵜⴻⵏ, ⵏⵉⵜⵏⵉ ⵙⵙⴼⴻⵡⵡⴰⵊⴻⵏ ⵙ ⵍⴻⵄⵡⵉⵏ. ⵅ ⵓⵢⴰ ⵉ ⵜⵜⵡⴰⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⴰⵎ ⵡⵓⴵⵉ, ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⴻⴽⵙⴰⵡ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ.”    ");
INSERT INTO rift_vpl VALUES ("ZC10_3","039_10_3","ZEC","10","3","3","“ⵅ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵢⴰⵔⵖⴰ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵉⵖⴰⵢⴹⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⴰⴷ ⵉⵙⵙⵉⵊⵊ ⵅ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⴻⴷⴷ ⴰⵎ ⵓⵢⵉⵙ ⵏⵏⴻⵙ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC10_4","039_10_4","ZEC","10","4","4","ⵣⵣⴰⵢⴻⵙ ⴰⵥⵔⵓ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ⵣⵣⴰⵢⴻⵙ ⵍⴻⵡⵜⴻⴷ, ⵣⵣⴰⵢⴻⵙ ⵍⵇⴻⵡⵙ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵣⴻⵢⵢⴰⵔⴻⵏ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("ZC10_5","039_10_5","ZEC","10","5","5","ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵉⵏⵏⵉ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴰⴷ ⵄⴻⴼⵙⴻⵏ ⵅ ⵓⴱⴻⴵⴰⵄ ⴷⵉ ⵣⵣⵏⴰⵇⵉ. ⵡⴰⵀ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵉⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC10_6","039_10_6","ZEC","10","6","6","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵊⴻⵀⴷⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⵓ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵓⵙⵓⴼ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⵔⵔⴻⵃⵎⴻⵖ ⴷⴰⵢⵙⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴰⵅⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵙⵍⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("ZC10_7","039_10_7","ZEC","10","7","7","“ⵉⵏⵏⵉ ⵏ ⵉⴼⵔⴰⵢⵉⵎ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵜⴻⵖⵔⵓⴹⵜ ⵓ ⵓⵍ ⵏⵙⴻⵏ ⴰⴷ ⵉⴼⴰⵔⵃ ⴰⵎ ⵖⴰⵔ ⴱⵉⵏⵓ, ⵓ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ ⵓ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⵓⵍ ⵏⵙⴻⵏ ⴰⴷ ⵉⴼⴰⵔⵃ ⴷⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC10_8","039_10_8","ZEC","10","8","8","ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵚⴻⴼⴼⴰⵔⴻⵖ ⵓ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴼⴷⵉⵖ ⵜⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC10_9","039_10_9","ZEC","10","9","9","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵣⴰⵔⵄⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⴷⴰⵔⴻⵏ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵉⴳⴳⵯⴻⵊⵊⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC10_10","039_10_10","ZEC","10","10","10","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵊⵊⴻⵖ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵣⵉ ⵎⵉⵙⵍⴰ, ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵙⵙⵎⵓⵏⴻⵖ ⵣⵉ ⴰⵛⵛⵓⵔ ⵓ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵍⵄⴰⴷ ⵓ ⵖⴰⵔ ⵍⵓⴱⵏⴰⵏ, ⵎⴰⵛⴰ ⴰⵢⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⵇⴻⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC10_11","039_10_11","ZEC","10","11","11","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵥⵡⴰ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ ⵓ ⴰⴷ ⵉⵡⵡⴻⵜ ⵍⴻⵎⵡⴰⵊ ⵏ ⵍⴻⴱⵃⴰⵔ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ ⵢⵓⴵⵖⴻⵏ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵏⵉⵍ ⴰⴷ ⴰⵥⵖⴻⵏ. ⵏⵏⴼⴰⵅⴻⵜ ⵏ ⴰⵛⵛⵓⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵡⴰⴹⴻⵄ, ⵓ ⴰⵣⴻⴵⴰⴹ ⵏ ⵎⵉⵙⵍⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵡⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZC10_12","039_10_12","ZEC","10","12","12","ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵊⴻⵀⴷⴻⵖ ⴷⵉ ⵙⵉⴷⵉ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ!”, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC11_1","039_11_1","ZEC","11","1","1","“ⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵛ, ⴰ ⵍⵓⴱⵏⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⴻⵛⵛ ⵜⵉⵏⴻⴳⵍⵉⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("ZC11_2","039_11_2","ZEC","11","2","2","ⵔⵓ, ⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵓⵎⴻⵔⵣⵉ, ⵎⴰⵖⴰⵔ ⵜⴰⵏⴳⴻⵍⵜ ⵜⴻⵡⴹⴰ, ⵎⴰⵖⴰⵔ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏⵜ! ⵔⵓⵜ, ⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏ ⵍⴱⴻⴵⵓⴹ ⵏ ⴱⴰⵛⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵣⵖⴰⵔ ⵉⵎⵎⵛⵓⴱⴱⵛⴻⵏ ⵉⵡⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("ZC11_3","039_11_3","ZEC","11","3","3","“ⵙⵍⴻⵎ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵄⵓⴵⵉ ⵏⵙⴻⵏ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵙⵍⴻⵎ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵓⵣⴻⵀⵀⴰⵔ ⵏ ⵡⴻⵢⵔⴰⴷⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵍⵄⴻⵣⵣ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ.” ");
INSERT INTO rift_vpl VALUES ("ZC11_4","039_11_4","ZEC","11","4","4","“ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ: ‘ⴰⵔⵡⴻⵙ ⵓⴵⵉ ⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵖⴰⵔⵚⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("ZC11_5","039_11_5","ZEC","11","5","5","ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵎⴻⵍⵍⴽⴻⵏ ⵏⴻⵇⵇⴻⵏ ⵜⴻⵏ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵇⴱⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵎⴻⵍⵍⴽⴻⵏ ⵣⵣⴻⵏⵣⴻⵏ ⵜⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔⵉ ⴰⴳⵍⴰ! ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵣⵣⵉⴵⵉⵣⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("ZC11_6","039_11_6","ZEC","11","6","6","“ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵣⵣⵉⴵⵉⵣⴻⵏ ⵄⴰⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵉ ⵉⵡⴷⴰⵏ ⴽⵓⵍ ⵉⵊⵊ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵙ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵄⴻⴼⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴼⴻⴽⴽⴻⵖ ⵛⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ZC11_7","039_11_7","ZEC","11","7","7","“ⵏⴻⵛⵛ ⴰⵔⴻⵡⵙⴻⵖ ⵓⴵⵉ ⵜⵉⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵖⴰⵔⵚⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⵓⴵⵉ ⵉⵜⵜⵡⴰⵃⵙⴰⵔⴻⵏ. ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜᵉⵖⵖⴰⵔⵢⴻⵏ. ⵉⵛⵜ ⴳⴳⵉⵖ ⴰⵙ ‘ⵍⵅⴰⴹⴰⵔ!’ ⵓ ⵜⴻⵏⵏⴻⵖⵏⵉ ⴳⴳⵉⵖ ⴰⵙ ‘ⵜⴰⵖⵔⵓⴹⵜ!’, ⵓ ⴰⵎⵎⵓ ⵉ ⴰⵔⵡⵙⴻⵖ ⵏⴻⵛⵛ ⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("ZC11_8","039_11_8","ZEC","11","8","8","“ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵢⵓⵔ ⵜⵜⴻⵃⵃⵉⵖ ⵜⵍⴰⵜⴰ ⵣⴻⴳ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ. ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⴱⵓ ⵄⴰⴷ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵙⴻⵏ ⵉⵛⴰⵔⵀ ⴰⵢⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("ZC11_9","039_11_9","ZEC","11","9","9","ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⴰⵔⴻⴽⴽⵡⵙⴻⵖ! ⵎⵉⵏ ⵉⵎⵎⵓⵜⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵎⵎⴻⵜ ⵓ ⵎⵉⵏ ⵉⵀⴻⵍⵍⴽⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ, ⵓ ⵊⵊⴻⵎ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵉⵊⵊ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC11_10","039_11_10","ZEC","11","10","10","ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵉⵏⵓ ‘ⵔⵅⴰⴹⴰⵔ’, ⵓⵛⴰ ⴰⵔⵥⵉⵖ ⵜⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵎⵎⵓ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⵏⵏⵉ ⴳⴳⵉⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC11_11","039_11_11","ZEC","11","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵍⵄⴰⵀⴷ ⵢⴰⵔⵔⴻⵥ ⵓ ⴰⵎⵎⵓ ⵉ ⵙⵙⵏⴻⵏ ⵡⵓⴵⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⴻⵟⵟⴰⵏ, ⴰⵇⴰ ⴰⵢⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("ZC11_12","039_11_12","ZEC","11","12","12","“ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙⴻⵏ: ‘ⵎⴰⵍⴰ ⴰⵢⴰ ⵎⵍⵉⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵡⵛⴻⵎ ⴰⵢⵉ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ, ⵓ ⵎⴰⵍⴰ ⵍⵍⴰ, ⵊⵊⴻⵎ ⵜ!’ ⵅⴻⵏⵏⵉ ⵡⴻⵣⵏⴻⵏ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ: ⵜⵍⴰⵜⵉⵏ ⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC11_13","039_11_13","ZEC","11","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉ: ‘ⵏⴹⴰⵔ ⵍⵎⵓⵏⴻⵜ ⵏⵏⵉ ⵖⴰⵔ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⵜⵜⴰⵎⴰⵏ ⵏⵏⵉ ‘ⵉⵚⴻⴱⵃⴻⵏ’ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴳⴳⵉⵏ ⵜⵜⴰⵎⴰⵏ!’ ⵓ ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵜⵍⴰⵜⵉⵏ ⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵖ ⵜⴻⵏⵜ ⵖⴰⵔ ⴱⵓ-ⵜⵍⴰⵅⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ZC11_14","039_11_14","ZEC","11","14","14","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⵔⵥⵉⵖ ⵏⴻⵛⵛ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵉⵏⵓ ⵏⵏⴻⵖⵏⵉ ⵜⴻⵏⵏⵉ ⴳⴳⵉⵖ ⴰⵙ ‘ⵜⴰⵖⵔⵓⴹⵜ’ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵥⴻⵖ ⴰⵎⵎⵓ ⵜⴰⵡⵎⴰⵜ ⵊⴰⵔ ⵢⴰⵀⵓⴷⴰ ⴷ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("ZC11_15","039_11_15","ZEC","11","15","15","“ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴽⵙⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⴷⴷⵓⵣⴰⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⴰⴱⵓⵀⴰⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("ZC11_16","039_11_16","ZEC","11","16","16","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⵊⵊⴻⵖ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ: ⵎⵉⵏ ⵉⵔⵓⵃⴻⵏ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ, ⵎⵉⵏ ⵉⵎⵟⴰⵔⵔⵛⴻⵏ ⵡⴰⵔ ⵜ ⵢⴰⵔⴻⵣⵣⵓ, ⵎⵉⵏ ⵢⴰⵔⵥⴻⵏ ⵡⴰⵔ ⵜ ⵉⵙⵙⴳⴻⵏⴼⵉ ⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴱⴻⴷⴷ, ⵡⴰⵔ ⵜ ⵉⵃⴻⵟⵟⵉ ⵏⴻⵜⵜⴰ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴻⵛⵛ ⴰⵢⵙⵓⵎ ⵏ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵉⵚⴻⵃⵃⴻⵏ ⵓ ⴰⴷ ⴰⵙⴻⵏⵜ ⵉⴽⴽⴻⵙ ⵜⵉⵛⴻⴹⵢⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("ZC11_17","039_11_17","ZEC","11","17","17","“ⵓⵛⵜ ⵅ ⵓⵎⴻⴽⵙⴰⵡ ⵉ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ, ⵡⴻⵏⵏⵉ ⵉⵙⴻⵎⵎⵃⴻⵏ ⴷⴻⴳ ⵡⵓⴵⵉ! ⵙⵙⵉⴼ ⴰⴷ ⴷⴷ-ⵉⵄⴷⵓ ⵅ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⵓ ⵅ ⵜⵉⵟⵟ ⵏⵏⴻⵙ ⵜⴰⴼⵓⵙⴻⵛⵜ. ⴰⵖⵉⵍ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵥⴻⵖ ⵎⴰⵔⵔⴰ, ⵓ ⵜⵉⵟⵟ ⵏⵏⴻⵙ ⵜⴰⴼⵓⵙⴻⵛⵜ ⴰⴷ ⵜⴻⵄⵎⴻⵛ ⵎⴰⵔⵔⴰ!” ");
INSERT INTO rift_vpl VALUES ("ZC12_1","039_12_1","ZEC","12","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵙⵔⴰⵉⵍ. ⵙⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴻⵣⵣⴰⵄⴻⵏ ⴰⵊⴻⵏⵏⴰ ⵓ ⵉⵙⵙⵔⵓⵙⴰ ⴷⵙⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵉⵙⵙⴱⴻⴷⴷⴰ ⴰⵔⵔⵓⵃ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("ZC12_2","039_12_2","ZEC","12","2","2","“ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵟⵟⴻⴱⵚⵉ ⵏ ⵓⴷⴻⵡⵡⴻⵅ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵟⵟⴻⴱⵚⵉ ⵏⵏⵉ ⵓⵍⴰ ⵅ ⵢⴰⵀⵓⴷⴰ ⵖⴰⵔ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC12_3","039_12_3","ZEC","12","3","3","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵉⴷⴻⵇⵍⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⴰⴷ ⵙⵙⵢⴻⵣⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC12_4","039_12_4","ZEC","12","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⵡⵜⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵢⵙⴰⵏ ⵙ ⴰⵔⵊⴻⴼ ⴷ ⵉⵎⵏⴰⵢⴻⵏ ⵏⵏⴻⵙ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴰⵔⴻⵣⵣⵎⴻⵖ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵅⵎⵉ ⵉ ⵖⴰ ⵡⵜⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵢⵙⴰⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵙ ⵜⵓⴷⴷⴰⵔⵖⴻⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC12_5","039_12_5","ZEC","12","5","5","ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵏⵉⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ: ‘ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("ZC12_6","039_12_6","ZEC","12","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴳⴳⴻⵖ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵎⴻⵊⵎⴰⵔ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷⵉ ⵜⴰⴼⴼⴰ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⵓ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵚⴼⴻⴹ ⵊⴰⵔ ⵜⵉⵇⴻⴱⴱⵉⴹⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⴼⴼⵣⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵓ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ, ⵓⵛⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC12_7","039_12_7","ZEC","12","7","7","ⵙⵉⴷⵉ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵎⴻⵣⵡⴰⵔ ⵉⵇⵉⴹⴰⵏ ⵏ ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⵛⵛⴰⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵛⵛⴰⵏ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵡⴰⵔ ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵟⵟⴰⵙ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⴰⵀⵓⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("ZC12_8","039_12_8","ZEC","12","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵙⵉⴷⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵏⵇⴰⵔⴹⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵎ ⴷⴰⵡⵓⴷ ⵓⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC12_9","039_12_9","ZEC","12","9","9","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵔⴻⴽⴽⵣⴻⵖ ⴰⴷ ⵎⵃⵉⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC12_10","039_12_10","ZEC","12","10","10","ⵎⴰⵛⴰ ⴰⴷ ⴼⴰⵔⵔⵖⴻⵖ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴹⴰ ⴷ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓ ⵅ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵅⵣⴰⵔⴻⵏ ⵡⴻⵏⵏⵉ ⴷⵉ ⵙⵙⵏⵓⵇⵇⴱⴻⵏ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙ ⵡⵜⴻⵏ ⴰⵢⴻⵊⴷⵓⵔ ⴰⵎ ⵡⵜⵉⵏ ⴰⴳⴻⵊⴷⵓⵔ ⵅ ⵓⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵓ ⴰⴷ ⵅⴰⵙ ⵛⴻⴹⵏⴻⵏ ⵙ ⵜⴻⵔⵣⵓⴳⵉ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵛⴹⵉⵏⴻⵏ ⵅ ⵍⵎⴻⵡⵜ ⵏ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ. ");
INSERT INTO rift_vpl VALUES ("ZC12_11","039_12_11","ZEC","12","11","11","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵜⴻⵎⵖⴰⵔ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵏ ⵀⴰⴷⴰⴷ-ⵔⵉⵎⵎⵓⵏ ⴷⵉ ⵜⴻⵖⵣⵓⵔⵜ ⵏ ⵎⴰⵊⵉⴷⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC12_12","039_12_12","ZEC","12","12","12","ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⵙⵖⵓⵢ ⵣⴻⴳ ⵡⴻⵛⴹⴰⵏ, ⴽⵓⵍ ⵍⴰⴵ ⵡⴻⵃⵃⴷⴻⵙ. ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵡⴻⵃⵃⴷⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ, ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵏⴰⵜⴰⵏ ⵡⴻⵃⵃⴷⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC12_13","039_12_13","ZEC","12","13","13","ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴰⵡⵉ ⵡⴻⵃⵃⴷⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ, ⵍⴰⴵ ⵏ ⵛⵉⵎⵄⵉ ⵡⴻⵃⵃⴷⴻⵙ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC12_14","039_12_14","ZEC","12","14","14","ⵎⴰⵔⵔⴰ ⵍⴰⴵⴰⵜ ⵏⵏⴻⵖⵏⵉ, ⴽⵓⵍ ⵍⴰⴵ ⵡⴻⵃⵃⴷⴻⵙ ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("ZC13_1","039_13_1","ZEC","13","1","1","“ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴳⴳⵓⵔ ⴰⴷ ⵜⴻⴷⴷⵓⵇⵇⴻⵣ ⵉⵛⵜ ⵏ ⵜⴰⵍⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ ⵓⵍⴰ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⴹⵉⴷⴷ ⵉ ⴷⴷⴻⵏⴱ ⵓ ⴹⵉⴷⴷ ⵉ ⵍⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("ZC13_2","039_13_2","ZEC","13","2","2","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵃⵃⵉⵖ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵄⴻⵇⵇⵍⴻⵏ ⵄⴰⴷ. ⵓⵍⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⴱⵓⵃⴱⴻⵍ ⴰⵎⴻⵏⴳⵓⵙ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("ZC13_3","039_13_3","ZEC","13","3","3","ⴰⴷ ⵉⵎⵙⴰⵔ, ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵏⴻⴱⴱⴰ, ⴱⴻⵍⵍⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵉⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵉⵊⵊⵉⵏ, ⴰⴷ ⴰⵙ ⵉⵏⵉⵏ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷⴻⴳ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ!’ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵉⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵉⵊⵊⵉⵏ, ⴰⴷ ⵜ ⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵅⵎⵉ ⵖⴰ ⵉⵏⴻⴱⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("ZC13_4","039_13_4","ZEC","13","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⴷ ⵙⴻⴹⵃⴰⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵅ ⵍⴻⵡⵃⵉⵢ ⵏⵏⴻⵙ ⵉ ⵉⵜⵡⴰⵍⴰ ⵅⵎⵉ ⵜⵓⵖⴰ ⵉⵏⴻⴱⴱⴰ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵉⵔⵉⴹⴻⵏ ⵛⴰ ⴰⴱⴰⵔⵜⴻⵙⵙⵓ ⵏ ⵛⵛⵄⴰⵔ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵅⴰⵔⵔⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC13_5","039_13_5","ZEC","13","5","5","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵏⵉ ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴰⵏⴰⴱⵉ, ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴼⴻⴵⵃⴻⵏ ⵉⵢⵢⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⴽⵙⴻⴱ ⴰⵢⵉ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("ZC13_6","039_13_6","ZEC","13","6","6","ⴰⴷ ⴰⵙ ⵉⵏⵉⵏ: ‘ⵎⵉⵏ ⵄⵏⴰⵏ ⵅⴻⵏⵏⵉ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ-ⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ?’, ⴰⴷ ⵢⵉⵏⵉ ⵏⴻⵜⵜⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵡⵜⵉⵏ ⴰⵢⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("ZC13_7","039_13_7","ZEC","13","7","7","“ⵙⵙⵉⴼ, ⴽⴽⴰⵔ ⵅ ⵓⵎⴻⴽⵙⴰⵡ ⵉⵏⵓ ⵓ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵄⴰⵛⴰⵔ ⵉⵏⵓ!, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵡⵡⴻⵜ ⴰⵎⴻⴽⵙⴰⵡ ⵉⵏⵓ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵡⵓⴵⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⵄⴰⵡⴻⴷ ⵉ ⵓⵙⴻⵍⵇⵉ ⵜⵉⵡⵡⴰ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ZC13_8","039_13_8","ZEC","13","8","8","“ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⴻⵢⵏⴰⵜ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴹⵄⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⵓⵃⴱⴻⵍ, ⵎⴰⵛⴰ ⴰⵣⵢⴻⵏ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵇⵇⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC13_9","039_13_9","ZEC","13","9","9","ⴰⵣⵢⴻⵏ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵜ ⵏⴹⴰⵔⴻⵖ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙᵉⵚⴼⵉⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⴻⵚⴼⴰⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵊⴰⵔⵔⴱⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵊⴰⵔⵔⴰⴱⴻⵏ ⵓⵔⴻⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵙⵍⴻⵖ. ⴰⴷ ⵉⵏⵉⵖ: ‘ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’ ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵏⵉⵏ: ‘ⵙⵉⴷⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("ZC14_1","039_14_1","ZEC","14","1","1","“ⵅⵣⴰⵔⴻⵜ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⵙⵉⴷⵉ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⴱⴹⴰ ⵜⴽⴻⵛⵛⴰⴹⵜ ⵏⵏⴻⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("ZC14_2","039_14_2","ZEC","14","2","2","ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵓⵎⴻⵏⵖⵉ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⴰⵏⴷⵉⵏⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ, ⵜⵓⴷⵔⵉⵏ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵛⵛⴹⴻⵏⵜ, ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⵓⵇⵇⴱⴻⵏⵜ ⵓ ⴰⵣⵢⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⴷⵉ ⵍⵎⴻⵏⴼⴰ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵡⴰⵔ ⴳⴳⵓⵔ ⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("ZC14_3","039_14_3","ZEC","14","3","3","ⵙⵉⴷⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵍⴻⴳⵏⵓⵙ ⴰⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵎⴻⵏⵖⵉ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵉⵜⵜⵎⴻⵏⵖⴰ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵡⴻⵀⵊⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC14_4","039_14_4","ZEC","14","4","4","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴱⴻⴷⴷⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ ⵡⴻⵏⵏⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵛⵛⴰⵔⵇ. ⴰⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴵⴻⵇ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⵉⵢⵏⴰⵜ, ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵇ ⵓ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵜⴻⵖⵣⵓⵔⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⵣⵢⴻⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⴰⴷ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵓ ⴰⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏ ⵡⴻⴷⵔⴰⵔ ⴰⴷ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("ZC14_5","039_14_5","ZEC","14","5","5","ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ ⵣⵉ ⵀⴻⴽⴽⵡⵓ ⵏ ⵉⴷⵓⵔⴰⵔ ⵉⵏⵓ, ⵎⴰⵖⴰⵔ ⵜⴰⵖⵣⵓⵔⵜ ⵏ ⵉⴷⵓⵔⴰⵔ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴻⴹ ⴰⵍ ⴰⵚⴰⵍ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴰⵔⴻⵡⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵄⵓⵣⵣⵉⵢⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵛⴰ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴰⴽⵉⴷⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("ZC14_6","039_14_6","ZEC","14","6","6","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴳⴳⵓⵔ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⴼⴰⵡⵜ, ⵉⵜⵔⴰⵏ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC14_7","039_14_7","ZEC","14","7","7","ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵙⵙ ⵓⵍⴰ ⴷ ⴵⵉⵍⴻⵜ. ⴰⴷ ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵏ ⵓⵄⴻⵛⵛⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("ZC14_8","039_14_8","ZEC","14","8","8","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵣⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴰⵛⴰⵔⵇⵉ ⵓ ⴰⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⵖⴰⵔⴱⵉ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⴷⴻⴳ ⵓⵏⴻⴱⴷⵓ ⵓ ⴷⵉ ⵜⴳⴰⵔⵙⵜ.    ");
INSERT INTO rift_vpl VALUES ("ZC14_9","039_14_9","ZEC","14","9","9","ⵙⵉⴷⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵙⵉⴷⵉ ⵓ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵢⵉⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ZC14_10","039_14_10","ZEC","14","10","10","ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴰⵎ ⵍⴻⵡⴹⴰ, ⵣⵉ ⵊⴰⴱⵄⴰ ⴰⵍ ⵔⵉⵎⵎⵓⵏ, ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⴰⵏⴷⵉⵏⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵓ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ ⵉⵡⴷⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ ⴰⵍ ⴰⵎⵛⴰⵏ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵉ ⴷⵉⵏ ⵜⵓⵖⴰ ⵣⵉⵛ, ⴰⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ⵓ ⵣⵉ ⵍⴱⵓⵔⵊ ⵏ ⵃⴰⵏⴰⵏⵉⵢⵉⵍ ⴰⵍ ⵜⵉⵙⴰⵔⵉⵏ ⵏ ⵡⴻⵃⵔⴰⵢ ⵏ ⴷⴷⵉⵍⴻⵛⵜ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("ZC14_11","039_14_11","ZEC","14","11","11","ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ ⵓ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵃⴰⵔⵔⴻⵎ ⵉ ⵓⵜⴻⵃⵃⵉ, ⵎⵉⵏⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC14_12","039_14_12","ZEC","14","12","12","ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵉⵛⵜⵉ ⵉ ⵣⵉ ⵖⴰ ⵉⵡⵡⴻⵜ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵓⵔⵛⴰⵍⵉⵎ: ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵔ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⴽⴽⵉⵛⵛⵓ ⴰⵎ ⵏⴻⵜⵜⴰ ⵄⴰⴷ ⵉⴱⴻⴷⴷ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⴷ ⴽⴽⵉⵛⵛⵡⴻⵏⵜ ⴷⴻⴳ ⵉⵅⵓⴱⴰⵛ ⵏⵙⴻⵏ ⵓ ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⴰⴷ ⵉⴽⴽⵉⵛⵛⵓ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC14_13","039_14_13","ZEC","14","13","13","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴳⴳⵓⵔ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵓⵎⵅⴰⵔⵡⴻⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵉ ⵙⵉⴷⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⵊⴰⵔ ⴰⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⵟⵟⴻⴼ ⴽⵓⵍ ⵉⵊⵊ ⴰⴼⵓⵙ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵓ ⵅⴻⵏⵏⵉ ⴰⴼⵓⵙ ⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵏⵏⴻⵇⵍⴻⴱ ⴹⵉⴷⴷ ⵉ ⵓⴼⵓⵙ ⵏ ⵊⵊⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC14_14","039_14_14","ZEC","14","14","14","ⵄⴰⴷ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⵢⴰⵀⵓⴷⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⵡⴰⴳⵍⴰ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ: ⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⴰⵔⵔⵓⴹ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("ZC14_15","039_14_15","ZEC","14","15","15","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵄⴰⵡⴻⴷ ⵜⴻⵛⵜⵉ ⵏ ⵓⵢⵉⵙ ⴷ ⵓⵙⴰⵔⴷⵓⵏ ⴷ ⵡⴻⵍⵖⴻⵎ ⴷ ⵢⴻⵖⵢⴰⵍ ⴷ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵇⴰ ⵜⵉⵛⵜⵉ-ⵢⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵍⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("ZC14_16","039_14_16","ZEC","14","16","16","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴰⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵏⴷⵇⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵢⵢⴷⴻⵏ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC14_17","039_14_17","ZEC","14","17","17","ⴰⴷ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵍⴰⴵⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴳⵉⵄⵄⵉⴷ ⵛⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴻⵏⴷⴻⵇ ⵉ ⵓⵊⴻⴵⵉⴷ, ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴰⵇⴰ ⵡⴰⵔ ⵅⴰⵙ ⵉⵡⴻⵟⵟⵉ ⵛⴰ ⵡⴻⵏⵥⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZC14_18","039_14_18","ZEC","14","18","18","ⵎⴰⵍⴰ ⵍⴰⴵ ⵏ ⵎⵉⵚⵔⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵛⴰ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵛⵛⵉⵜ ⵡⴻⵏⵥⴰⵔ. ⵜⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵉⵛⵜⵉ ⵉ ⵣⵉ ⵖⴰ ⵉⵍⵇⴻⴼ ⵙⵉⴷⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⴳⵉⵄⵄⵉⴷⴻⵏ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵢⵢⴷⴻⵏ ⴼⵉⵛⵜⴰ ⵏ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC14_19","039_14_19","ZEC","14","19","19","ⵜⴰ ⴳⴳⵓⵔ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⵉⵛⵜⵉ ⵉ ⴷⴷⵏⵓⴱ ⵏ ⵎⵉⵚⵔⴰ ⵓⵍⴰ ⴷ ⵜⵉⵛⵜⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵉⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⴳⴻⵄⵄⴻⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵢⵢⴷⴻⵏ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ZC14_20","039_14_20","ZEC","14","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴳⴳⵓⵔ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵜⵏⴰⵇⵓⵙⵉⵏ ⵏ ⵢⴻⵢⵙⴰⵏ ‘ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ!’ ⵜⵜⵏⴰⵊⴰⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵟⵟⴰⵡⵢⴰⵜ ⵉ ⵓⵔⵓⵛⵛⵉ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("ZC14_21","039_14_21","ZEC","14","21","21","ⵎⴰⵔⵔⴰ ⵜⵜⵏⴰⵊⴰⵔ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⴰⴷ ⵉⵍⵉⵏ ⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴽⵙⵉⵏ ⵓ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵙⵙⵏⴻⵏⵏⴰⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⴽⴻⵏⵄⴰⵏⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML1_1","040_1_1","MAL","1","1","1","ⵍⵃⵓⴽⵎ ⵉⵙⵙⴰⴳⴳⵯⴰⴷⴻⵏ. ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵙⵔⴰⵉⵍ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⴰⵍⴰⵅⵉ. ");
INSERT INTO rift_vpl VALUES ("ML1_2","040_1_2","MAL","1","2","2","“ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⴽ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵏⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⵅⵙⴻⴷ?’ ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵄⵉⵙⵓ ⴷ ⵓⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵓ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵢⴰⵄⵇⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("ML1_3","040_1_3","MAL","1","3","3","ⵎⴰⵛⴰ ⵛⴰⵔⵀⴻⵖ ⵄⵉⵙⵓ. ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ ⵉⴷⵓⵔⴰⵔ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵜⵜⵡⴰⵔⴻⴷⴷⴵⴻⵏ ⵓⵍⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵏ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("ML1_4","040_1_4","MAL","1","4","4","ⵡⴰⵅⵅⴰ ⵉⴷⵓⵎ ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ, ⵎⴰⵛⴰ ⴰⴷ ⵏⴻⴱⵏⴰ ⵍⵅⵉⵔⴱⴰⵜ ⵄⴰⵡⴻⴷ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ: ⵏⵉⵜⵏⵉ ⴰⴷ ⴱⵏⴰⵏ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵓ ⴰⴷ ⴰⵙⴻⵏ ⵍⴰⵖⴰⵏ ‘ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵓⵄⴻⴼⴼⴰⵏ’, ⵓ ⵄⴰⵡⴻⴷ: ‘ⵍⴳⴻⵏⵙ ⵡⴻⵏⵏⵉ ⵅ ⵉⵙⴻⵅⵅⴻⴹ ⵙⵉⴷⵉ ⵉ ⵍⴻⴱⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("ML1_5","040_1_5","MAL","1","5","5","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙⵉⴷⵉ ⵜⵉⵡⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ!’” ");
INSERT INTO rift_vpl VALUES ("ML1_6","040_1_6","MAL","1","6","6","“ⵎⵎⵉⵙ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵙ ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴱⴰⴱ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴷ ⴱⴰⴱⴰ, ⵎⴰⵏⵉ ⵉⵇⵇⵉⵎ ⵅⴻⵏⵏⵉ ⵍⴻⵡⵇⴰⵔ ⵉ ⵏⴻⵛⵛ? ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴷ ⵙⵉⴷⵉ, ⵎⴰⵏⵉ ⵜⴻⵇⵇⵉⵎ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏⵏⵉ ⵣⵣⴰⵢⵉ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ. ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⵉⵏ ⵣⵉ ⵏⴻⵙⵙⴻⵃⵇⴰⵔ ⵏⴻⵛⵛⵉⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ?’ ");
INSERT INTO rift_vpl VALUES ("ML1_7","040_1_7","MAL","1","7","7","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⵡⵢⴻⵎ-ⴷⴷ ⴰⵖⵔⵓⵎ ⵉⵅⴻⵎⵊⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ, ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⵉⵏ ⵣⵉ ⵉ ⵛⴻⴽ ⵏⴻⵙⵙⵅⴻⵎⵎⴻⵊ?’ ⵎⵉⵏ ⵣⵉ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⵎⴻⵃⵇⵓⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("ML1_8","040_1_8","MAL","1","8","8","ⵎⴰⵖⴰⵔ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⵡⵢⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⴹⴰⵔⵖⴰⵍ ⵉ ⵜⴰⵖⴰⵔⵚⵜ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵢⴰ ⴷ ⵍⵖⴰⵔ? ⵓ ⵅⵎⵉ ⵖⴰ ⵜⴰⵡⵢⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵇⴻⵊⴷⴰⵃ ⵏⵉⵖ ⵎⵉⵏ ⵉⵀⴻⵍⵛⴻⵏ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵢⴰ ⴷ ⵍⵖⴰⵔ! ⵙⵉⵡⴻⴹ ⴰⵢⴰ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵖⴰⵔ ⵍⵡⴰⵍⵉ. ⵎⴰ ⵛⴻⴽ ⴰⴷ ⴰⵙ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏⵉⵖ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⵍⵉⵃ ⴰⴽⵉⴷⴻⴽ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML1_9","040_1_9","MAL","1","9","9","“ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰⵔⵣⵓⵎ ⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵃⵉⵏⵏ. ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵣⵣⴰⵢⵡⴻⵎ! ⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴻⵛⵏⴰ ⵉ ⵢⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ML1_10","040_1_10","MAL","1","10","10","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⴱⴻⵍⵍⵄⴻⵏ ⵅⴻⵏⵏⵉ ⵜⵉⵡⵡⵓⵔⴰ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵙⵔⵉⵇⵇⵉⵏ ⵄⴰⴷ ⴰⵄⴰⵍⵟⴰⵔ ⵉⵏⵓ ⴱⴰⵟⴻⵍ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵜⵜⵉⴼⴻⵖ ⴰⵔⴹⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⵓⵍⴰ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ML1_11","040_1_11","MAL","1","11","11","ⵎⴰⵖⴰⵔ ⵣⵉ ⵎⴰⵏⵉ ⴷⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴰⵍ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⵅⵓⵔ ⵉ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵖⴰⵔ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ML1_12","040_1_12","MAL","1","12","12","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵄⵉⴵⵉⵜⴻⵎ ⵉⵙⴻⵎ ⵏⵏⵉ ⴰⵎ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ ⵜⴻⵅⵎⴻⵊ ⵓ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ, ⴷ ⵜⴰⵎⴻⵃⵇⵓⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("ML1_13","040_1_13","MAL","1","13","13","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ: ‘ⵅⵣⴰⵔ, ⵎⴰⵏⴰ ⴰⵎⵏⵓⵙ- ⴰ!’, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵜⵙⵓⴹⵎⴻⵎ ⵅⴰⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⵡⵢⴻⵎ-ⴷⴷ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⴻⵏ, ⵓ ⵎⵉⵏ ⵉⵜⵜⵇⴻⵊⴷⵃⴻⵏ ⴷ ⵎⵉⵏ ⵉⵀⴻⵍⵛⴻⵏ ⵜᵉⵜⵜⵡⴰⵢⴻⵎ-ⴷⴷ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ. ⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵄⵊⴻⴱ ⵎⴰⵏ ⴰⵢⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ?, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ML1_14","040_1_14","MAL","1","14","14","ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵓⵖⴻⵛⵛⴰⵛ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍ ⴷ ⴰⵡⵜⴻⵎ ⴷⵉ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⴰⵄⴷ ⵉ-ⵜ ⵓ ⵅⴻⵏⵏⵉ ⵉⵖⴰⵔⵚ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵍ ⴷ ⴰⵏⴻⵄⴹⵓⴱ ⵉ ⵙⵉⴷⵉ! ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵓ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("ML2_1","040_2_1","MAL","2","1","1","“ⵍⴻⵅⵅⵓ, ⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰ ⵜⴻⵡⵚⵉⵢⵢⴻⵜ-ⴰ, ⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ML2_2","040_2_2","MAL","2","2","2","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵓ ⵡⴰⵔ ⵜⵜ ⵜⴽⴻⵙⵙⵉⵎ ⵖⴰⵔ ⵡⵓⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵛⴻⵏⵏⵄⴻⵎ ⵉⵙⴻⵎ ⵉⵏⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵏⵏⴻⵄⵍⴻⵜ ⵊⴰⵔ ⴰⵡⴻⵎ ⵓ ⴰⴷ ⵏⴻⵄⵍⴻⵖ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏⵡⴻⵎ, ⵡⴰⵀ, ⴰⵇⴰ ⵏⴻⵄⵍⴻⵖ ⵜⴻⵏ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜ ⵜⴽⴻⵙⵙⵉⵎ ⵖⴰⵔ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("ML2_3","040_2_3","MAL","2","3","3","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵇⴱⴻⵖ ⴷⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵓ ⴰⴷ ⵣⵓⵣⵣⴰⵔⴻⵖ ⴰⵎⴻⵙⵙⴰⵍ ⵅ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵡⴻⵎ, ⴰⵎⴻⵙⵙⴰⵍ ⵏ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵏⵡⴻⵎ, ⵓ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵢⴻⵏ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("ML2_4","040_2_4","MAL","2","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽ-ⴷ ⵍⴰⵡⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ML2_5","040_2_5","MAL","2","5","5","ⵍⵄⴰⵀⴷ ⵉⵏⵓ ⴰⴽⵉⴷⴻⵙ ⵜⵓⵖⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵓ ⴷ ⵍⴻⵀⵏⴰ. ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵙ ⵜⴻⵏ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⴳⴳⵯⴻⴷ ⵏⴻⵜⵜⴰ ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵣⴰⵢⵉ ⵓ ⵉⵜⵜⴻⵏⴻⵅⵍⴰⵄ ⵣⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("ML2_6","040_2_6","MAL","2","6","6","ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⵉⴷⴻⵜⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵅ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵉ ⴷⵉ ⵍⴻⵀⵏⴰ ⵓ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵓ ⵢⴰⵔⵔⴰ ⴰⵟⵟⴰⵙ ⵜⵓⴱⴻⵏ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ML2_7","040_2_7","MAL","2","7","7","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⴷ ⵃⴹⴰⵏ ⵜⵓⵙⵙⵏⴰ ⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⵔⴻⵣⵣⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴽⴽⵉ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML2_8","040_2_8","MAL","2","8","8","“ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅ ⵡⴻⴱⵔⵉⴷ, ⵜⴻⵙⵙⴻⵏⵇⴰⵔⴹⴻⵎ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⵖⵓⵔⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵜⴰⵔⴻⴷⴷⴵⴻⵎ ⵍⵄⴰⵀⴷ ⵏ ⵍⴰⵡⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ML2_9","040_2_9","MAL","2","9","9","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵄⵉⴼⴼⴻⵎ ⵓ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵃⴹⵉⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵓ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵓⵙⴻⵍⵎⴻⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("ML2_10","040_2_10","MAL","2","10","10","“ⵎⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⴱⴰⴱⴰ? ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵅⵍⴻⵇ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⵏⵖⴻⴷⴷⴰⵔ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵍⴰⵎⵉ ⵏⴻⵙⵙⴻⴼⵙⴰⴷ ⵍⵄⴰⵀⴷ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("ML2_11","040_2_11","MAL","2","11","11","ⵢⴰⵀⵓⴷⴰ ⴰⵇⴰ ⵉⵖⴷⴰⵔ, ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉⵛⵜ ⵏ ⵊⵊⵄⵉⴼⴻⵛⵜ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵙⵄⵉⴵⴻⵜ ⵎⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵉⵜⵜⴻⵅⵙ ⵏⴻⵜⵜⴰ, ⵎⴰⵖⴰⵔ ⵢⴰⵀⵓⴷⴰ ⵉⵎⵍⴻⵛ ⵢⴻⴵⵉⵙ ⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵖⵔⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("ML2_12","040_2_12","MAL","2","12","12","ⵙⵉⴷⵉ ⴰⴷ ⵉⵜⴻⵃⵃⴰ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵣⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵡⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵉⵜⵜⴰⵔⵔⴰⵏ, ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴻⵀⵀⴱⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML2_13","040_2_13","MAL","2","13","13","“ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴷⴷⴰⵍⴻⵎ ⴰⵄⴰⵍⵟⴰⵔ ⵏ ⵙⵉⴷⵉ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵙ ⵜⵖⵓⵢⵢⵉⵜ ⵓ ⵙ ⵙⵇⵉⵏⴼⴻⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵄⴰⴷ ⵜⴻⵢⵏⵉⵜ ⵣⵣⴰⵢⴻⵙ ⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓ ⵡⴰⵔ ⵜⵜ ⵉⵇⴻⴱⴱⴻⵍ ⵄⴰⴷ ⵙ ⴰⵔⴹⴰ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("ML2_14","040_2_14","MAL","2","14","14","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵢⴻⵎⵎⵉ?’ ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵜⵓⵖⴰ ⴷ ⵛⵛⴰⵀⴻⴷ ⵊⴰⵔ ⵛⴻⴽ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ, ⵜⴻⵏⵏⵉ ⵜⴻⵖⴷⴰⵔⴻⴷ ⵛⴻⴽ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵄⵛⵉⵔⵜ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("ML2_15","040_2_15","MAL","2","15","15","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⴰⴷ ⴱⵓⵃⴱⴻⵍ, ⵡⴰⵔ ⵉⴳⴳⵉ ⵎⴰⵏ ⴰⵢⴰ! ⵓ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⵡⴰⵏⵉⵜⴰ? ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ! ⵙ ⵓⵢⴰ, ⵃⴹⴰⵎ ⵅ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ ⵓ ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵉⵖⴻⴷⴷⴰⵔ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵟⴻⵎⵣⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("ML2_16","040_2_16","MAL","2","16","16","ⵎⴰⵖⴰⵔ: ‘ⵏⴻⵜⵜⴰ ⵉⵇⵇⴰⵔ, ⴰⵇⴰ ⵉⵛⴰⵔⵀ ⵉ-ⵜⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ: ⴰⴵⴰⴼ!’, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ‘ⴰⵎⵎⵓ ⵉ ⵉⴷⴷⴰⵍ ⵏⴻⵜⵜⴰ ⵍⵖⴻⵛⵛ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ!’, ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵙ ⵓⵢⴰ ⵃⴹⴰⵎ ⵅ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⵖⴻⴷⴷⴰⵔⴻⵎ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("ML2_17","040_2_17","MAL","2","17","17","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴰⵀⴰⵍⴻⵎ ⵙⵉⴷⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⵉⵏ ⵣⵉ ⵜ ⵏⴻⵙⵙⴰⵀⴰⵍ ⵏⴻⵛⵛⵉⵏ?’ ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵇⴰⵄ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵉⵚⴱⴻⵃ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ ⴰⵙ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ!’, ⵏⵉⵖ: ‘ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⵃⵓⴽⵎ?’” ");
INSERT INTO rift_vpl VALUES ("ML3_1","040_3_1","MAL","3","1","1","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⴱⵔⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵉⵏⵓ. ⴷⴻⵖⵢⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⴻⵙ, ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵜⴰⵔⴻⵣⵣⵓⵎ ⴽⴻⵏⵏⵉⵡ, ⵍⵎⴰⵍⴰⴽ ⵏ ⵍⵄⴰⵀⴷ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏⵡⴻⵎ. ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ!, ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ML3_2","040_3_2","MAL","3","2","2","ⵎⴰⵛⴰ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵢⴰⵔⴱⵓⵏ ⴰⵙⵙ ⵏ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴱⴻⴷⴷ, ⵅⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⴱⴰⵏ ⵏⴻⵜⵜⴰ? ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⵎ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⵙⴻⴼⵙⴰⵢ ⵓ ⴰⵎ ⵍⵍⵉⵅⵉⵢⵢⴰ ⵏ ⵉⵖⴻⵙⵙⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ML3_3","040_3_3","MAL","3","3","3","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ, ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⴼⵙⵉⵢⵢⴻⵏ ⵓ ⵉⵜⵜⵚⴻⴼⴼⴰⵏ ⵏⵏⵓⵇⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵣⴷⵉⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵍⴰⵡⵉ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⵚⴻⴼⴼⴰ ⴰⵎ ⵡⵓⵔⴻⵖ ⵓ ⴰⵎ ⵏⵏⵓⵇⴰⵔⵜ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴻⵀⵀⴱⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("ML3_4","040_3_4","MAL","3","4","4","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⵖⵉⴵⴻⵜ ⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵣⵉⵛ, ⴰⵎ ⴷⴻⴳ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("ML3_5","040_3_5","MAL","3","5","5","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷⵙⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵖ ⵓ ⴰⴷ ⵛⴻⵀⴷⴻⵖ ⵙ ⵜⴰⵣⵍⴰ ⵅ ⵉⵙⴻⵃⵃⴰⵔⴻⵏ ⴷ ⵉⵎⵣⴻⵏⵏⴰⵢⴻⵏ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵊⴰⴵⴰⵏ ⵥⵓⵔ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵍⵎⵓⵏⴻⵜ ⵏ ⵓⵛⴻⵡⵡⴰⵍ, ⵓ ⵅ ⵢⴻⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⵜⴰⵊⵊⴰⵍⵜ ⴷ ⵓⵢⵓⵊⵉⵍ ⵓ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵛⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML3_6","040_3_6","MAL","3","6","6","“ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ, ⵙⵉⴷⵉ, ⵡⴰⵔ ⴱⴻⴷⴷⵍⴻⵖ ⵛⴰ ⵓ ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵡⴰⵔ ⵜⴻⴼⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("ML3_7","040_3_7","MAL","3","7","7","ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵃⴹⵉⵎ ⵛⴰ. ⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴻⵡⵍⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵙ ⵎⵉⵏ ⵣⵉ ⵉ ⴷⴷ ⵖⴰ ⵏⴻⴷⵡⴻⵍ?’ ");
INSERT INTO rift_vpl VALUES ("ML3_8","040_3_8","MAL","3","8","8","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⴰⵛⴰⵔ ⴰⵔⴻⴱⴱⵉ? ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⵛⴰⵔⴻⵎ ⴰⵢⵉ ⵓ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵙ ⵎⵉⵏ ⵣⵉ ⵛⴻⴽ ⵏⴻⵜⵜⴰⵛⴰⵔ?’ ⵣⵉ ⵍⴻⵄⵛⵓⵔ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴳⴻⵄⵄⴻⴷ! ");
INSERT INTO rift_vpl VALUES ("ML3_9","040_3_9","MAL","3","9","9","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵏⴻⵄⵍⴻⵎ ⵙ ⵢⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⵛⴰⵔⴻⵎ ⴰⵢⵉ, ⵡⴰⵀ, ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("ML3_10","040_3_10","MAL","3","10","10","ⴰⵡⵢⴻⵎ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵛⵓⵔ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵍⴻⵅⵣⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵎⴰⵛⵛⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵓ ⵇⴻⴵⴱⴻⵎ ⴰⵢⵉ ⵣⵣⴰⵢⴻⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⵎⴰ ⵏⴻⵛⵛ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⴰⵔⴻⵣⵣⵎⴻⵖ ⵜⵉⴱⵓⵔⵊⴰⵜⵉⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵣⴻⴵⵄⴻⵖ ⵍⴱⴰⵔⴰⴽⴰ, ⴰⵍ ⴷⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⴽⵜⴰⵔ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵃⴷⴰⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ML3_11","040_3_11","MAL","3","11","11","ⴰⴱⵓⵔⵅⴻⵙ ⴰⴷ ⵜ ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵊⴻⵢⵢⴻⵃ ⵚⵚⴰⴱⴻⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵡⴻⵎ ⵓ ⵎⴰⵃⴻⵏⴷ ⵜⴰⵣⴰⵢⴰⵔⵜ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵡⵉ ⵍⵖⵉⴵⴻⵜ ⵉ ⵡⴰⵔ ⵢⵉⵡⵉⴹⴻⵏ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("ML3_12","040_3_12","MAL","3","12","12","ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵉⵏⵉⵏ: ‘ⴷ ⴰⵎⵉⵎⵓⵏ ⵉ ⴽⴻⵏⵏⵉⵡ!’, ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵢⴰⵔⴹⴰⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML3_13","040_3_13","MAL","3","13","13","“ⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ ⴷⴻⵡⵍⴻⵏ ⵇⴻⵙⵃⴻⵏ ⵅⴰⴼⵉ ⴰⵟⵟⴰⵙ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⵉⵏ ⵉ ⵅⴰⴽ ⵏⴻⵇⵇⴰⵔ ⵏⴻⵛⵛⵉⵏ?’ ");
INSERT INTO rift_vpl VALUES ("ML3_14","040_3_14","MAL","3","14","14","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⴰⵇⴰ ⴱⴰⵟⴻⵍ ⵉ ⵏⴻⵜⵜⵙⴻⵅⵅⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵣⵉ ⵏⴻⵃⴹⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⴰⵇⴰ ⵏⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⵔⵔⵓⴹ ⴰⴱⴰⵔⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ? ");
INSERT INTO rift_vpl VALUES ("ML3_15","040_3_15","MAL","3","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵏⵃⴻⵙⵙⴻⴱ ⴰⵢⵜ ⵏⵏⴼⴰⵅⴻⵜ ⴷ ⴰⵎⵉⵎⵓⵏ. ⵄⴰⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵜⵜⵡⴰⴱⴻⵏⵏⴰⵏ. ⵏⵉⵜⵏⵉ ⵜⵜⵊⴰⵔⵔⴰⴱⴻⵏ ⵄⴰⴷ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵏⴻⵊⵊⵎⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("ML3_16","040_3_16","MAL","3","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ ⵎⵎⵙⴰⵡⴰⵍⴰⵏ ⴰⵎⵎⵓ: ‘ⵙⵉⴷⵉ ⵉⵜⵜⴰⵔⵔⴰ ⵜⴰⵢⵏⵉⵜ ⵓ ⵉⵜⵜⴻⵙⵍⴰ. ⴰⴷ ⵉⵜⵜⵡⴰⵔⵉ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏ ⵍⵉⴷⴰⵔⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵙⵉⴷⵉ ⵓ ⵜⵜⵉⴷⴰⵔⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("ML3_17","040_3_17","MAL","3","17","17","ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵏⵏⴻⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⵄⵉⵣⵣⴻⵖ ⴰⵎ ⵉⵙⵙⵄⵉⵣⵣ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵎⵎⵉⵙ ⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("ML3_18","040_3_18","MAL","3","18","18","ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵓⵎⵙⴻⴳⴳⴻⴷ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵊⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("ML3_19","040_3_19","MAL","3","19","19","“ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵢⴰⵔⴻⵇⵇ ⴰⵎ ⵜⴻⴼⵇⵓⵏⵜ. ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⵏⵏⴼⴰⵅⴻⵜ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵓⵍⵓⵎ ⵓⵛⴰ ⴰⵙⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴰⵔⴻⵖ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵡⴻⵥⵡⴰⵔ ⵓⵍⴰ ⴷ ⵜⴰⵙⴻⵟⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("ML3_20","040_3_20","MAL","3","20","20","ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵓ ⴰⴷ ⵢⵉⵍⵉ ⵓⴳⴻⵏⴼⵓ ⵙⴰⴷⵓ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵏⴻⴳⴳⵉⵣⴻⵏ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⵎ ⵢⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵍⴽⵓⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("ML3_21","040_3_21","MAL","3","21","21","ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵄⴻⴼⵙⴻⵎ ⵅ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵖⵖⴻⴹ ⵙⴰⴷⵓ ⵜⵉⵙⵉ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("ML3_22","040_3_22","MAL","3","22","22","ⵅⴻⵎⵎⴻⵎ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵓⵎⵓⵔⴻⵖ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵏ ⵀⵓⵔⵉⴱ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ, ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵍⴼⴰⵔⴰⵢⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("ML3_23","040_3_23","MAL","3","23","23","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⴰⵏⴰⴱⵉ ⵉⵍⵉⵢⴰ, ⵇⴱⴻⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵉⵙⵙⵉⴳⴳⵯⵉⴷⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("ML3_24","040_3_24","MAL","3","24","24","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵔ ⵓⵍ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵖⴰⵔ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⵓⵍ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵖⴰⵔ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ- ⵜⵜⵉⵙⴻⵖ ⵓ ⴰⴷ ⵃⴰⵔⵔⵎⴻⵖ ⵜⴰⵎⵎⵓⵔⵜ ⵇⴰⵄ ⵉ ⵓⵜⴻⵃⵃⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT1_1","070_1_1","MAT","1","1","1","ⴰⴷⵍⵉⵙ ⵏ ⵓⵎⴻⵣⵔⵓⵢ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵎⵎⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MT1_2","070_1_2","MAT","1","2","2","ⵉⴱⵔⴰⵀⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵙⵃⴰⵇ, ⵉⵙⵃⴰⵇ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ, ⵢⴰⵄⵇⵓⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT1_3","070_1_3","MAT","1","3","3","ⵢⴰⵀⵓⴷⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴼⴰⵔⵉⵚ ⴷ ⵣⴰⵔⴰⵃ ⴰⴽ-ⴷ ⵜⴰⵎⴰⵔ, ⴼⴰⵔⵉⵚ ⵉⵊⵊⴰ-ⴷⴷ ⵃⴰⵚⵔⵓⵏ, ⵃⴰⵚⵔⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵔⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("MT1_4","070_1_4","MAT","1","4","4","ⴰⵔⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵏⴰⵃⵛⵓⵏ, ⵏⴰⵃⵛⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵙⴰⵍⵎⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("MT1_5","070_1_5","MAT","1","5","5","ⵙⴰⵍⵎⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⴱⵓⵄⴰⵣ ⵣⵉ ⵔⴰⵃⴰⴱ, ⴱⵓⵄⴰⵣ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⴱⵉⴷ ⴰⴽ-ⴷ ⵔⴰⵄⵓⵜ, ⵄⵓⴱⵉⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵙⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("MT1_6","070_1_6","MAT","1","6","6","ⵢⴰⵙⵙⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴷⴰⵡⵓⴷ, ⴰⵊⴻⴵⵉⴷ, ⵓⵛⴰ ⴷⴰⵡⵓⴷ ⵉⵊⵊⴰ-ⴷⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵔⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MT1_7","070_1_7","MAT","1","7","7","ⵙⵓⵍⵉⵎⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵔⴰⵃⴰⴱⵄⴰⵎ, ⵔⴰⵃⴰⴱⵄⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⴰⴱⵉⵢⴰ, ⴰⴱⵉⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("MT1_8","070_1_8","MAT","1","8","8","ⴰⵙⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵀⵓⵛⴰⴼⴰⵟ, ⵢⴰⵀⵓⵛⴰⴼⴰⵟ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵔⴰⵎ, ⵢⵓⵔⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵄⵓⵣⵣⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("MT1_9","070_1_9","MAT","1","9","9","ⵄⵓⵣⵣⵉⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵜⴰⵎ, ⵢⵓⵜⴰⵎ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵃⴰⵣ, ⴰⵃⴰⵣ ⵉⵊⵊⴰ-ⴷⴷ ⵃⵉⵣⵇⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("MT1_10","070_1_10","MAT","1","10","10","ⵃⵉⵣⵇⵉⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵏⴰⵙⵙⴰ, ⵎⴰⵏⴰⵙⵙⴰ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵎⵓⵏ, ⴰⵎⵓⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵛⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("MT1_11","070_1_11","MAT","1","11","11","ⵢⵓⵛⵉⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⴽⵓⵏⵢⴰ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵎⴻⵏⴼⴰ ⵏ ⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT1_12","070_1_12","MAT","1","12","12","ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵏⴼⴰ ⴷⵉ ⴱⴰⴱⵉⵍ, ⵢⴰⴽⵓⵏⵢⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ ⵉⵊⵊⴰ-ⴷⴷ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT1_13","070_1_13","MAT","1","13","13","ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ ⵉⵊⵊⴰ-ⴷⴷ ⴰⴱⵉⵀⵓⴷ, ⴰⴱⵉⵀⵓⴷ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵍⵢⴰⵇⵉⵎ, ⴰⵍⵢⴰⵇⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⵄⴰⵣⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("MT1_14","070_1_14","MAT","1","14","14","ⵄⴰⵣⵓⵔ ⵉⵊⵊⴰ-ⴷⴷ ⵚⴰⴷⵓⵇ, ⵚⴰⴷⵓⵇ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵅⵉⵎ, ⴰⵅⵉⵎ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵍⵉⵢⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("MT1_15","070_1_15","MAT","1","15","15","ⴰⵍⵉⵢⵓⴷ ⵉⵊⵊⴰ-ⴷⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⵍⵉⵄⴰⵣⴰⵔ ⵉⵊⵊⴰ-ⴷⴷ ⵎⴰⵜⵜⴰⵏ, ⵎⴰⵜⵜⴰⵏ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("MT1_16","070_1_16","MAT","1","16","16","ⵢⴰⵄⵇⵓⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵢⵓⵙⵓⴼ, ⴰⵔⵢⴰⵣ ⵏ ⵎⴰⵔⵢⴰⵎ, ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵊⵊⵉⵏ ⵢⴰⵙⵓⵄ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("MT1_17","070_1_17","MAT","1","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵣⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴰⵍ ⴷⴰⵡⵓⴷ ⵉⵡⴹⴻⵏ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ⵣⵉ ⴷⴰⵡⵓⴷ ⴰⵍ ⵍⵎⴻⵏⴼⴰ ⴷⵉ ⴱⴰⴱⵉⵍ ⴰⵔⴱⴻⵄⵜⴰⵛ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵓⵛⴰ ⵣⵉ ⵍⵎⴻⵏⴼⴰ ⴷⵉ ⴱⴰⴱⵉⵍ ⴰⵍ ⵍⵎⴰⵙⵉⵃ ⴰⵔⴱⴻⵄⵜⴰⵛ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT1_18","070_1_18","MAT","1","18","18","ⴰⵎⵎⵓ ⵉ ⵢⴻⵎⵙⴰⵔ ⵡⴻⵅⵍⴰⵇ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ⵓⵎⵉ ⵢⴻⵎⵎⴰⵙ ⵎⴰⵔⵢⴰⵎ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵏⴻⵅⴹⴻⴱⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵉⴹⵀⴰⵔ-ⴷⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴽⵙⵉ ⴰⵄⴻⴷⴷⵉⵙ ⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵎⴻⵍⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT1_19","070_1_19","MAT","1","19","19","ⵓⵎⵉ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵢⵓⵙⵓⴼ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⵏⵉⵛⴰⵏ, ⵡⴰⵔ ⵉⵅⵙ ⵛⴰ ⴰⴷ ⵜⵜ ⵉⵙⵙⴱⴻⵀⴷⴻⵍ, ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴰⵙ ⵉⴵⴻⴼ ⵙ ⵜⵏⵓⴼⴼⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT1_20","070_1_20","MAT","1","20","20","ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵉⴹⵀⴰⵔ ⴰⵙ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⴰⵔⵊⵉⵜ, ⵉⵏⵏⴰ: “ⴰ ⵢⵓⵙⵓⴼ, ⴰ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⴷ ⵎⴰⵔⵢⴰⵎ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉ ⴷⴰⵢⴻⵙ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT1_21","070_1_21","MAT","1","21","21","ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ ⴰⵃⴻⵏⵊⵉⵔ, ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜ ⵜⵙⴻⵎⵎⴰ ⵢⴰⵙⵓⵄ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT1_22","070_1_22","MAT","1","22","22","ⵎⴰⵔⵔⴰ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵏⴰⴱⵉ, ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT1_23","070_1_23","MAT","1","23","23","“ⵅⵥⴰⵔ, ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⴰⴷ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ, ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ ⴰⵃⴻⵏⵊⵉⵔ, ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ‘ⵄⵉⵎⵎⴰⵏⵓ-ⵉⵍ’ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("MT1_24","070_1_24","MAT","1","24","24","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴰⵇ ⵢⵓⵙⵓⴼ ⵣⴻⴳ ⵉⴹⴻⵚ, ⵉⴳⴳⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵢⵓⵎⵓⵔ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵓⵛⴰ ⵢⵉⵡⵢⵉ-ⴷⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT1_25","070_1_25","MAT","1","25","25","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵛⴰ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵔⵓⵡ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ, ⵓⵛⴰ ⵜⵙⴻⵎⵎⴰ ⵜ ‘ⵢⴻⵛⵛⵓ’. ");
INSERT INTO rift_vpl VALUES ("MT2_1","070_2_1","MAT","2","1","1","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ ⵢⴰⵙⵓⵄ ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵀⵉⵔⵓⴷⵓⵙ, ⵓⵙⵉⵏ-ⴷⴷ ⵛⴰ ⵏ ⵉⵎⵓⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MT2_2","070_2_2","MAT","2","2","2","ⵏⵏⴰⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ? ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⵉⵜⵔⵉ ⵏⵏⴻⵙ ⴷⵉ ⵛⵛⴰⵔⵇ, ⵏⵓⵙⴰ-ⴷⴷ ⴰⴷ ⴰⵙ ⵏⴻⵙⵊⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT2_3","070_2_3","MAT","2","3","3","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⵀⵉⵔⵓⴷⵓⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴻⵃⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⵇⴰⵄ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT2_4","070_2_4","MAT","2","4","4","ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⵣⵉ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⵅ ⵎⴰⵏⵉ ⵖⴰ ⵉⵅⵍⴻⵇ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("MT2_5","070_2_5","MAT","2","5","5","ⵏⵏⴰⵏ: “ⴷⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵢⵓⵔⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵏⴰⴱⵉ: ");
INSERT INTO rift_vpl VALUES ("MT2_6","070_2_6","MAT","2","6","6","‘ⵓⵍⴰ ⴷ ⵛⴻⵎ, ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵛⴻⵎ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵊⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⴻⵎ ⴷⴷ ⵖⴰ ⵉⴼⴼⴻⵖ ⵓⵊⴻⴵⵉⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵙⴻⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵉⵙⵔⴰⵉⵍ.’” ");
INSERT INTO rift_vpl VALUES ("MT2_7","070_2_7","MAT","2","7","7","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵀⵉⵔⵓⴷⵓⵙ ⵅ ⵉⵎⵓⵙⵏⴰⵡⴻⵏ ⵏ ⵉⵜⵔⴰⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴻⵏ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵉⵜⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("MT2_8","070_2_8","MAT","2","8","8","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵉⵏⵏⴰ: “ⵔⵓⵃⴻⵎ ⴷⵉⵏⵏⵉ, ⵜⴰⵔⵣⵓⵎ ⵎⵍⵉⵃ ⵅ ⵓⵃⴻⵏⵊⵉⵔ. ⵎⴰⵍⴰ ⵜⵓⴼⵉⵎ ⵜ, ⴰⵙⴻⵎ-ⴷⴷ, ⵅⴻⴱⴱⴰⵔⴻⵎ ⴰⵢⵉ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ, ⴰⴷ ⴰⵙ ⵙⴻⵊⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("MT2_9","070_2_9","MAT","2","9","9","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵔⵓⵃⴻⵏ ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵜⵔⵉ ⵉ ⵥⵔⵉⵏ ⴷⵉ ⵛⵛⴰⵔⵇ ⵉⴳⴳⵓⵔ ⵣⵣⴰⵜⵙⴻⵏ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("MT2_10","070_2_10","MAT","2","10","10","ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵉⵜⵔⵉ, ⴼⴰⵔⵃⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT2_11","070_2_11","MAT","2","11","11","ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵥⵔⵉⵏ ⴰⵃⴻⵏⵊⵉⵔ ⴰⴽ-ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ, ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏ ⴰⵙ. ⵅⴻⵏⵏⵉ ⴰⵔⴻⵣⵎⴻⵏ ⵍⴻⴽⵏⵓⵣ ⵏⵙⴻⵏ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵙ ⵜⵉⵔⵣⵉⴼⵉⵏ: ⵓⵔⴻⵖ, ⵎⵉⵔⵔⵓ ⴷ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("MT2_12","070_2_12","MAT","2","12","12","ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵡⴻⵃⵃⴰ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵄⵉⵇⵇⵉⴱⴻⵏ ⵖⴰⵔ ⵀⵉⵔⵓⴷⵓⵙ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT2_13","070_2_13","MAT","2","13","13","ⵓⵎⵉ ⵔⵓⵃⴻⵏ, ⵉⴹⵀⴰⵔ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵢⵓⵙⵓⴼ ⴷⵉ ⵜⴰⵔⵊⵉⵜ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⴰⵡⵉ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵢⴻⵎⵎⴰⵙ, ⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⵓ ⵇⵇⵉⵎ ⴷⵉⵏ ⴰⵍ ⵛⴻⴽ ⵉ ⵖⴰ ⵅⴻⴱⴱⴰⵔⴻⵖ, ⵎⵉⵏⵣⵉ ⵀⵉⵔⵓⴷⵓⵙ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⵓⵃⴻⵏⵊⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("MT2_14","070_2_14","MAT","2","14","14","ⵓⵛⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵢⵓⵙⵓⴼ, ⵢⵉⵡⵉ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵢⴻⵎⵎⴰⵙ ⵙ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT2_15","070_2_15","MAT","2","15","15","ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⴰⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵀⵉⵔⵓⴷⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⵉ ⵙⵉⴷⵉ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉ ⵉⵏⵏⴰⵏ: “ⵍⴰⵖⵉⵖ-ⴷⴷ ⵅ ⵎⵎⵉ ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵎⵉⵚⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT2_16","070_2_16","MAT","2","16","16","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵀⵉⵔⵓⴷⵓⵙ ⴱⴻⵍⵍⵉ ⵉⵎⵓⵙⵏⴰⵡⴻⵏ ⵛⴻⵎⵜⴻⵏ ⵜ, ⵉⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ, ⵉⵏⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⴷ ⵇⴰⵄ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⴷⵙⴻⵏ, ⵎⴰⵔⵔⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵙⵡⴰⴷⴷⴰⵢ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴻⵇⵜ ⵉ ⵢⵉⵡⴻⴹ ⴰⴷ ⵉⵙⵙⴻⵏ ⵣⴻⴳ ⵉⵎⵓⵙⵏⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT2_17","070_2_17","MAT","2","17","17","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉⵔⵎⵉⵢⴰ, ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT2_18","070_2_18","MAT","2","18","18","“ⵜⵎⵉⵊⵊⴰ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⴷⵉ ⵔⴰⵎⴰ, ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴰⵟⵟⴰⵙ. ⵔⴰⵀⵉⵍ ⵜᵉⵜⵜⵔⵓ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴻⵣⵣⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT2_19","070_2_19","MAT","2","19","19","ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⵀⵉⵔⵓⴷⵓⵙ, ⵉⴹⵀⴰⵔ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵉ ⵢⵓⵙⵓⴼ ⴷⵉ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("MT2_20","070_2_20","MAT","2","20","20","ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⴰⵡⵉ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵢⴻⵎⵎⴰⵙ ⵓⵛⴰ ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵏⵖⴻⵏ ⴰⵃⴻⵏⵊⵉⵔ, ⴰⵇⴰ ⵎⵎⵓⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT2_21","070_2_21","MAT","2","21","21","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ, ⵢⵉⵡⵉ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ ⴷ ⵢⴻⵎⵎⴰⵙ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT2_22","070_2_22","MAT","2","22","22","ⵎⴰⵛⴰ ⴰⵍⴰⵎⵉ ⵉⵙⵍⴰ ⴱⴻⵍⵍⵉ ⴰⵔⵅⵉⵍⴰⵡⵓⵙ ⵉⴷⵡⴻⵍ ⴷ ⴰⵊⴻⴵⵉⴷ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴱⴰⴱⴰⵙ ⵀⵉⵔⵓⴷⵓⵙ, ⵉⴳⴳⵯⴻⴷ ⴰⴷ ⵉⵔⴰⵃ ⴷⵉⵏⵏⵉ. ⵅⴻⵏⵏⵉ ⵉⵡⴻⵃⵃⴰ ⴰⵙ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT2_23","070_2_23","MAT","2","23","23","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ, ⵉⵣⴷⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⵏⴰⵚⵉⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉ ⵉⵏⵏⴰⵏ: “ⴰⴷ ⵜ ⵙⴻⵎⵎⴰⵏ ⵏⵏⴰⵚⵉⵔⵉ!” ");
INSERT INTO rift_vpl VALUES ("MT3_1","070_3_1","MAT","3","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ, ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("MT3_2","070_3_2","MAT","3","2","2","ⵉⵏⵏⴰ: “ⵜⵓⴱⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ⴰⵇⴰ ⵜⵓⴷⴻⵙ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT3_3","070_3_3","MAT","3","3","3","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⴰⵎ ⵉⵏⵏⴰ: “ⵜⵎⵉⵊⵊⴰ ⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ: ‘ⵙⵡⴻⵊⴷⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵙⴻⴳⴳⴻⵎ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ.’” ");
INSERT INTO rift_vpl VALUES ("MT3_4","070_3_4","MAT","3","4","4","ⵢⵓⵃⴰⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⵔⴻⴹ ⴰⵔⵔⵓⴹ ⵏ ⵜⴰⴹⵓⴼⵜ ⵏ ⵉⵍⴻⵖⵎⴰⵏ, ⵉⴱⴻⴽⴽⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵏ ⵢⵉⵍⴻⵎ. ⵓⵛⴰ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴷ ⵉⴱⵓⵔⴻⵅⵙⴻⵏ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵜⴰⵃⵓⵔⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MT3_5","070_3_5","MAT","3","5","5","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵇⴰⵄ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("MT3_6","070_3_6","MAT","3","6","6","ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵏⴻⵄⵎⴻⵏ ⵙ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT3_7","070_3_7","MAT","3","7","7","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵜⴰⵔⵡⴰ ⵏ ⵉⴼⵉⵖⵔⴰⵏ, ⵡⵉ ⴷ ⴰⵡⴻⵎ ⵉⵎⵍⴻⵏ, ⴰⵇⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ ⵣⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MT3_8","070_3_8","MAT","3","8","8","ⴳⴳⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵉ ⵖⴰ ⵉⵍⵉⵇⵇⴻⵏ ⵉ ⵜⵜⵓⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MT3_9","070_3_9","MAT","3","9","9","ⵡⴰⵔ ⵜⵜⵖⵉⵍⴻⵎ ⵛⴰ ⴰⴷ ⵜⵉⵏⵉⵎ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵡⴻⵎ: ‘ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ!’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⴻⴳ ⵉⵥⵔⴰ-ⵢⴰ ⵜⴰⵔⵡⴰ ⵉ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MT3_10","070_3_10","MAT","3","10","10","ⵅⵣⴰⵔ, ⵜⴰⵛⴰⵇⵓⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵖⴰⵔ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ. ⵙ ⵓⵢⴰ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵛⵏⴰ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⴹⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ.    ");
INSERT INTO rift_vpl VALUES ("MT3_11","070_3_11","MAT","3","11","11","ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵖⴻⴹⵚⴻⵖ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵉ ⵜⵜⵓⴱⴻⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⵏⴻⵜⵜⴰ ⵉⵊⵀⴻⴷ ⵅⴰⴼⵉ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴷⵉⵀⵉⴵⴻⵖ ⴰⴷ ⴽⵙⵉⵖ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵖⴹⴻⵚ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MT3_12","070_3_12","MAT","3","12","12","ⵜⴰⵣⵣⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵣⵣⵓⵣⴰⵔ ⴰⵏⴷⵔⴰⵔ ⵏⵏⴻⵙ ⵇⴰⵄ, ⴰⴷ ⵉⵢⵔⵓ ⵉⵔⴷⴻⵏ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵙⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵛⴰⵔⴼⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⵉ ⵡⴰⵔ ⵉⵅⴻⵙⵙⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT3_13","070_3_13","MAT","3","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵣⵉ ⵍⵊⴰⵍⵉⵍ ⵖⴰⵔ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⵢⵓⵃⴰⵏⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵖⴹⴻⵚ ⵣⵣⴰⵢⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("MT3_14","070_3_14","MAT","3","14","14","ⵎⴰⵛⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵢⵓⴳⵉ ⴰⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵃⴷⴰⵊⴻⵖ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵖ ⵣⵣⴰⵢⴻⴽ. ⵎⴰ ⴰⵇⴰ ⴷ ⵛⴻⴽ ⵉ ⵖⴰⵔⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT3_15","070_3_15","MAT","3","15","15","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⴻⵡⵛ ⵍⴻⵅⵅⵓ ⵜⵜⴻⵙⵔⵉⵃ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵍⵉⵇ ⵃⵉⵎⴰ ⴰⴷ ⵏⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⴳⴷⴰ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⴰⵎⵃ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT3_16","070_3_16","MAT","3","16","16","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵢⴰⵙⵓⵄ, ⵢⵓⵍⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⴷⴻⵖⵢⴰ, ⵓ ⵜⵜⵡⴰⵔⵣⵎⴻⵏ ⴰⵙ ⵉⵊⴻⵏⵡⴰⵏ, ⵓⵛⴰ ⵉⵥⵔⴰ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵀⵡⴰ-ⴷⴷ ⴰⵎ ⵜⴰⴷⴱⵉⵔⵜ, ⵜⴰⵔⵙⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT3_17","070_3_17","MAT","3","17","17","ⵅⵣⴰⵔ, ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵜⴻⵏⵏⴰ: “ⴷ ⵡⴰ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵉⵏⵓ.”   * ");
INSERT INTO rift_vpl VALUES ("MT4_1","070_4_1","MAT","4","1","1","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵊⴰⵔⵔⴻⴱ ⵣⴻⴳ ⵉⴱⵍⵉⵙ.    ");
INSERT INTO rift_vpl VALUES ("MT4_2","070_4_2","MAT","4","2","2","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵥⵓⵎⵎ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⴵⵢⴰⵍⵉ, ⵢⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵊⵊⵓⵄ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT4_3","070_4_3","MAT","4","3","3","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵎⵊⴰⵔⵔⴰⴱ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵉ ⵉ ⵉⵥⵔⴰ-ⵢⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵖⵔⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("MT4_4","070_4_4","MAT","4","4","4","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵙ ⵡⴻⵖⵔⵓⵎ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵣⵉ ⴽⵓⵍ ⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴰⵔⴻⴱⴱⵉ.’” ");
INSERT INTO rift_vpl VALUES ("MT4_5","070_4_5","MAT","4","5","5","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵉⵡⵢⵉ ⵜ ⵉⴱⵍⵉⵙ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⵣⴻⵇⵇⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("MT4_6","070_4_6","MAT","4","6","6","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵡⴰ, ⵏⴹⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⴰⴷ ⵢⵓⵎⵓⵔ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵅⴰⴽ, ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵏⵜ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵏⴻⴳⴳⴻⵃ ⵛⴰ ⴰⵥⵔⵓ.’” ");
INSERT INTO rift_vpl VALUES ("MT4_7","070_4_7","MAT","4","7","7","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵓⵔⴰ ⵄⴰⵡⴻⴷ: ‘ⵡⴰⵔ ⵜⵜⵊⴰⵔⵔⴰⴱ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ!’” ");
INSERT INTO rift_vpl VALUES ("MT4_8","070_4_8","MAT","4","8","8","ⵢⵉⵡⵢⵉ ⵜ ⵄⴰⵡⴻⴷ ⵉⴱⵍⵉⵙ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⵛⴻⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵓⵄⵓⴵⵉ ⵏⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("MT4_9","070_4_9","MAT","4","9","9","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵍⴰ ⵜⴻⵡⴹⵉⴷ ⴰⵢⵉ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ, ⴰⴷ ⴰⵢⵉ ⵜⵙⴻⵊⴷⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT4_10","070_4_10","MAT","4","10","10","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵔⵓⵃ, ⴰ ⵛⵛⵉⵟⴰⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵎⵉ ⵖⴰ ⵜⵙⴻⵊⴷⴻⴷ ⵓ ⵉ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ ⵓⵎⵉ ⵖⴰ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ.’”    ");
INSERT INTO rift_vpl VALUES ("MT4_11","070_4_11","MAT","4","11","11","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵉ-ⵜ ⵉⴱⵍⵉⵙ, ⵓ ⵅⵣⴰⵔ, ⵍⵎⴰⵍⴰⴽⴰⵜ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ, ⵜⵓⵖⴰ ⵙⴻⵅⵅⴰⵔⴻⵏⵜ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT4_12","070_4_12","MAT","4","12","12","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⴱⴻⵍⵍⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT4_13","070_4_13","MAT","4","13","13","ⵉⵊⵊⴰ ⵏⵏⴰⵚⵉⵔⴰ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵣⵉⴱⵓⵍⵓⵏ ⴷ ⵏⴰⴼⵜⴰⵍⵉ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⵉⵏ ");
INSERT INTO rift_vpl VALUES ("MT4_14","070_4_14","MAT","4","14","14","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT4_15","070_4_15","MAT","4","15","15","“ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵣⵉⴱⵓⵍⵓⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵍⵊⴰⵍⵉⵍ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MT4_16","070_4_16","MAT","4","16","16","ⵍⴳⴻⵏⵙ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵉⵥⵔⴰ ⵜⴰⴼⴰⵡⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⴰⵇⴰ ⵜⴻⵏⵇⴰⵔ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵜⴼⴰⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT4_17","070_4_17","MAT","4","17","17","ⵣⵉ ⵙⵙⵉⵏ ⵉⴱⴷⴰ ⵢⴰⵙⵓⵄ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ, ⵉⵏⵏⴰ: “ⵜⵓⴱⴻⵎ ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵇⴰ ⵜⵓⴷⴻⵙ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT4_18","070_4_18","MAT","4","18","18","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⵓⵔ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⵊⴰⵍⵉⵍ, ⵉⵥⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵛⵉⵎⵄⵓⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴷ ⴰⵥⵔⵓ’, ⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ ⵓⵎⴰⵙ, ⵜⵓⵖⴰ ⵏⴻⵟⵟⴰⵔⴻⵏ ⵜⵔⴰⵛⵛⴰⵡⵉⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT4_19","070_4_19","MAT","4","19","19","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴹⴼⴰⵔⴻⵎ ⴰⵢⵉ-ⴷⴷ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⵔⴻⵖ ⴷ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT4_20","070_4_20","MAT","4","20","20","ⵙⵙⴰⵔⵙⴻⵏ ⴷⴻⵖⵢⴰ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⵏⵙⴻⵏ, ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT4_21","070_4_21","MAT","4","21","21","ⵍⴰⵎⵉ ⵢⴻⵄⴷⵓ ⵙⵙⴻⵏⵏⵉ, ⵉⵥⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵢⴰⵄⵇⵓⴱ ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ ⴷ ⵓⵎⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵣⴰⴱⴷⵉ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵄⴻⴷⴷⵍⴻⵏ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT4_22","070_4_22","MAT","4","22","22","ⴷⴻⵖⵢⴰ ⵙⴻⵎⵃⴻⵏ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵓ ⴷⵉ ⴱⴰⴱⴰⵜⵙⴻⵏ, ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT4_23","070_4_23","MAT","4","23","23","ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵜⵜⴻⵏⵏⴻⴹ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵍⵉⵍ ⵎⴰⵔⵔⴰ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴽⵓⵍ ⵍⴻⵀⵍⴰⵛ ⴷ ⴽⵓⵍ ⵍⴻⵄⵢⵓⴱⴰⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MT4_24","070_4_24","MAT","4","24","24","ⵉⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ ⵅⴰⵙ ⴷⵉ ⵙⵓⵔⵉⵢⴰ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵀⵍⴰⵛ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵀⵍⴰⵛ ⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵍⴻⵃⵔⵉⵇ ⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⴽⵉⴽⴽⵉⴹⴻⵏ ⵓⵍⴰ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ, ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT4_25","070_4_25","MAT","4","25","25","ⴹⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵣⵉ ⵍⵊⴰⵍⵉⵍ, ⵣⵉ ⴷⵉⴽⴰⴱⵓⵍⵉⵙ, ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵓ ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_1","070_5_1","MAT","5","1","1","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍⵖⴰⵛⵉ, ⵢⵓⵍⵉ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT5_2","070_5_2","MAT","5","2","2","ⵓⵛⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT5_3","070_5_3","MAT","5","3","3","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⴰⵔⵔⵓⵃ ⵏⵙⴻⵏ ⵉⵣⵍⴻⴹ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵇⴰ-ⵜⵜ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT5_4","070_5_4","MAT","5","4","4","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵛⴹⵉⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵄⴻⵣⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_5","070_5_5","MAT","5","5","5","ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⵡⴰⴹⵄⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT5_6","070_5_6","MAT","5","6","6","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵍⴰⵥⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴼⴰⴷⴻⵏ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_7","070_5_7","MAT","5","7","7","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵃⵃⵎⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MT5_8","070_5_8","MAT","5","8","8","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵍ ⵉⵣⴷⵉⴳ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT5_9","070_5_9","MAT","5","9","9","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵀⵏⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⴻⵎⵎⴰⵏ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT5_10","070_5_10","MAT","5","10","10","ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⵏⴻⵃⵚⴰⵔⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("MT5_11","070_5_11","MAT","5","11","11","ⵙⵙⴻⵄⴷ ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵍⴰ ⵜⵜⵄⴰⵢⴰⵔⴻⵏ ⵓ ⵜⵜⴷⴰⵔⵔⴰⵛⴻⵏ ⵅⴰⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵏⵉⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⵡⴰⵍⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ, ⵡⴰⵅⵅⴰ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_12","070_5_12","MAT","5","12","12","ⴼⴰⵔⵃⴻⵎ, ⵙⵍⵉⵡⴻⵍⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵍⵎⵓⵏⴻⵜ ⵏⵡⴻⵎ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵜⵜⴷⴰⵔⵔⴰⵛⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵇⴱⴻⵍ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT5_13","070_5_13","MAT","5","13","13","“ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵉⵅⵙⴰⵔ ⵓⵍⴻⴷⴷⵉ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵏⴻⴳⴳ ⴰⴷ ⵜⵜ ⵏⴰⵔⵔ ⴷ ⵜⴰⵎⴻⴵⴰⵃⵜ? ⵡⴰⵔ ⵜⵏⴻⴼⴼⴻⵄ ⵄⴰⴷ ⵉ ⵡⴰⵍⵓ, ⵃⴰⵛⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⴰⴷ ⵅⴰⵙ ⵄⴻⴼⵙⴻⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT5_14","070_5_14","MAT","5","14","14","“ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵉⵜⵜⵡⴰⴱⵏⴰⵏ ⵅ ⵡⴻⴷⵔⴰⵔ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜᵉⵏⵏⵓⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT5_15","070_5_15","MAT","5","15","15","ⵡⴰⵔ ⵙⵙⵔⴻⵇⵇⵉⵏ ⵍⴻⴼⵏⴰⵔ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵙⴰⴷⵓ ⵍⵎⵓⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵅ ⵍⵎⴻⵔⴼⴻⵄ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵖ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT5_16","070_5_16","MAT","5","16","16","ⵊⵊⴻⵎ ⵜⴰⴼⴰⵡⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⴰⵔⵖ ⵉ ⵉⵡⴷⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵡⴻⵎ ⵉⵛⵏⴰⵏ, ⴰⴷ ⵙⵙⵓⵄⵍⴰⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT5_17","070_5_17","MAT","5","17","17","“ⴰⵇⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴱⴻⵟⵟⵍⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵉⵖ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴱⴻⵟⵟⵍⴻⵖ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("MT5_18","070_5_18","MAT","5","18","18","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴰⵍ ⵉ ⵖⴰ ⵉⵄⴷⵓ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵉⴱⴻⵟⵟⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵍⵃⴰⵔⴼ ⵏⵉⵖ ⴷ ⵉⵛⵜⴻⵏ ⵜⴰⵏⴻⵇⵇⵉⵟ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵍ ⵖⴰ ⵢⵉⵍⵉ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MT5_19","070_5_19","MAT","5","19","19","ⵙ ⵓⵢⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴱⴻⵟⵟⵍⴻⵏ ⵣⵉ ⵜⵡⴻⵚⵚⴰ-ⵢⴰ ⵉⵛⵜⴻⵏ, ⵡⴰⵅⵅⴰ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ, ⵓⵛⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉⵡⴷⴰⵏ ⴰⵎⵎⵓ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴳⴳⵉⵏ ⵓ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏⵜ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_20","070_5_20","MAT","5","20","20","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜⵎⴻⵇⵇⴰⵔ ⵛⴰ ⵅ ⵜⴻⵏⵏⵉ ⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵜⴻⵏⵏⵉ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⵛⴰ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT5_21","070_5_21","MAT","5","21","21","“ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵍⴻⵊⴷⵓⴷ: ‘ⵡⴰⵔ ⵏⴻⵇⵇ!’, ⵓ: ‘ⵡⴻⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵃⴰⵙⴻⴱ!’ ");
INSERT INTO rift_vpl VALUES ("MT5_22","070_5_22","MAT","5","22","22","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵢⵢⴰⵇⴻⵏ ⵅ ⵓⵎⴰⵙ ⴱⵍⴰ ⵙⵙⵉⴱⴱⴻⵜ, ⵏⵀⵍⴰ ⵎⴰ ⴰⴷ ⵅⴰⵙ ⵉⵜⵜⵡⴰⵃⴰⴽⴻⵎ, ⵓ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵉ ⵓⵎⴰⵙ: ‘ⴰⴷ ⵅⴰⴽ ⵙⵙⵓⵙⴼⴻⵖ!’, ⴰⴷ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵅⴰⵙ ⵣⵣⴰⵜ ⵉ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⴰ ⴰⴱⵓⵀⴰⵍⵉ!’ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴰⴽⴻⵎ, ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵏ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("MT5_23","070_5_23","MAT","5","23","23","ⵎⴰⵍⴰ ⵜⵇⴻⴷⴷⵎⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵛ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵎⵉⵏ ⵅⴻⴼ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ, ⵓⵛⴰ ⴷⵉⵏⵏⵉ ⵜⵄⴻⵇⵍⴻⴷ ⴱⴻⵍⵍⵉ ⵓⵎⴰⵛ ⴰⵇⴰ-ⵜ ⵛⴰ ⵅⴰⴽ, ");
INSERT INTO rift_vpl VALUES ("MT5_24","070_5_24","MAT","5","24","24","ⴻⵊⵊ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵛ ⴷⵉⵏ ⵣⵣⴰⵜ ⵉ ⵓⵄⴰⵍⵟⴰⵔ, ⵔⵓⵃ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵜⵚⴻⵍⵃⴻⴷ ⴰⴽ-ⴷ ⵓⵎⴰⵛ, ⵅⴻⵏⵏⵉ ⴷⵡⴻⵍ-ⴷⴷ, ⵓⵛⴰ ⴻⵡⵛ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MT5_25","070_5_25","MAT","5","25","25","ⵉⵍⵉ ⵜⵡⴻⵊⴷⴻⴷ ⵉ ⵡⴻⵚⵍⴰⵃ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵉⵎ ⵏⵏⴻⵛ ⵓⵎⵉ ⵛⴻⴽ ⵄⴰⴷ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⵖⵔⵉⵎ ⵏⵏⴻⵛ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵉⵡⵉ ⵖⴰⵔ ⵍⵇⴰⴹⵉ, ⵅⴻⵏⵏⵉ ⵍⵇⴰⴹⵉ ⴰⴷ ⵛⴻⴽ ⵢⴰⵡⵉ ⵖⴰⵔ ⵓⵎⵅⴰⵣⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⴷ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT5_26","070_5_26","MAT","5","26","26","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⵡⴰⵔ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⴷ ⵙⵙⴻⵏⵏⵉ, ⴰⵍ ⵖⴰ ⵜⵅⴻⴵⵚⴻⴷ ⴰⵚⵓⵍⴷⵉ ⴰⵏⴻⴳⴳⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("MT5_27","070_5_27","MAT","5","27","27","ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ: ‘ⵡⴰⵔ ⵣⴻⵏⵏⵉ ⵛⴰ!’, ");
INSERT INTO rift_vpl VALUES ("MT5_28","070_5_28","MAT","5","28","28","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⵏⵏⴻⵛⵡⴻⵜ, ⴰⵇⴰ ⵉⵣⵏⴰ ⴷⴻⵖⵢⴰ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT5_29","070_5_29","MAT","5","29","29","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⵜⴰⴼⵓⵙⴻⵛⵜ, ⵇⴻⵙⵙ ⵉ-ⵜⵜ, ⵏⴹⴰⵔ ⵉ-ⵜⵜ ⵅⴰⴽ. ⵉⵃⵍⴰ ⴰⵛ ⵎⴰⵍⴰ ⵉⵡⴻⴷⴷⴰⵔ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵅ ⵓⵡⴻⵟⵟⵓ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("MT5_30","070_5_30","MAT","5","30","30","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ, ⵇⴻⵙⵙ ⵉ-ⵜ, ⵏⴹⴰⵔ ⵉ-ⵜ ⵅⴰⴽ, ⵎⵉⵏⵣⵉ ⵉⵃⵍⴰ ⴰⵛ ⵎⴰⵍⴰ ⵉⵡⴻⴷⴷⴰⵔ ⵉⵊⵊ ⵏ ⵟⵟⴰⵔⴼ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵡⴰⵀⴰ ⵅ ⵓⵡⴻⵟⵟⵓ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT5_31","070_5_31","MAT","5","31","31","“ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵄⴰⵡⴻⴷ: ‘ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴵⴼⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵜⴰⴱⵔⴰⵜ ⵏ ⵡⴰⴵⴰⴼ!’ ");
INSERT INTO rift_vpl VALUES ("MT5_32","070_5_32","MAT","5","32","32","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴵⴼⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵉⵜⵜⴰⵔⵔⴰ ⵉ-ⵜⵜ ⴰⴷ ⵜⴻⵣⵏⴰ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⴻⵍⵛⴻⵏ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵉⴵⴼⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵣⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT5_33","070_5_33","MAT","5","33","33","“ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⵄⴰⵡⴻⴷ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵍⴻⵊⴷⵓⴷ: ‘ⵡⴰⵔ ⵜⴻⵊⵊⴰⴵⵉⴷ ⵥⵓⵔ, ⵎⴰⵛⴰ ⴻⴳⴳ ⵎⵉⵏ ⵜⴻⵊⵊⵓⴵⴻⴷ ⵉ ⵙⵉⴷⵉ!’ ");
INSERT INTO rift_vpl VALUES ("MT5_34","070_5_34","MAT","5","34","34","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⵜⴻⵊⵊⴰⴵⴰⵎ ⵄⴻⵎⵎⴰⵔⵚ, ⵓⵍⴰ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("MT5_35","070_5_35","MAT","5","35","35","ⵓⵍⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵍⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("MT5_36","070_5_36","MAT","5","36","36","ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵊⵊⴰⴵⴰⵎ ⵓⵍⴰ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⵔⵔⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵥⴻⵟⵟⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵏⵉⵖ ⴷ ⴰⴱⴰⵔⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_37","070_5_37","MAT","5","37","37","ⴰⴷ ⵉⵇⵇⵉⵎ ⵡⴰⵡⴰⵍ ⵏⵡⴻⵎ ‘ⵡⴰⵀ!’ ⴷ ‘ⵡⴰⵀ!’, ‘ⵍⵍⴰ!’ ⴷ ‘ⵍⵍⴰ!’. ⵎⴰⵏⴰ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT5_38","070_5_38","MAT","5","38","38","“ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ: ‘ⵜⵉⵟⵟ ⵙ ⵜⵉⵟⵟ ⴷ ⵜⵉⵖⵎⴻⵙⵜ ⵙ ⵜⴻⵖⵎⴻⵙⵜ!’, ");
INSERT INTO rift_vpl VALUES ("MT5_39","070_5_39","MAT","5","39","39","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵎⵄⴰⵍⴰⵎ ⵛⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⵇⵍⴻⵏ ⴰⵎⴻⴳⴳⵉⵣ ⵏⵏⴻⵛ ⴰⴼⵓⵙⵉ, ⵙⴻⵍⵇⴰ ⵢⴰⵙ ⵓⵍⴰ ⴷ ⴰⵎⴻⴳⴳⵉⵣ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT5_40","070_5_40","MAT","5","40","40","ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉⵅⵙ ⴰⴷ ⴽⵉⴽ ⵉⴳⴳ ⵛⵛⵔⴻⵄ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⴽ ⵉⴽⴽⴻⵙ ⵜⵛⴰⵎⵉⵔ ⵏⵏⴻⵛ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴽⵙⵉ ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MT5_41","070_5_41","MAT","5","41","41","ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⴳⴳⵉⵏ ⴱⴻⵣⵣⴻⵣ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵜⵓⵢⵓⵔⴻⴷ ⵉⵊⵊ ⵏ ⴽⵉⵍⵓⵎⵉⵜⵔ, ⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_42","070_5_42","MAT","5","42","42","ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴰⵛ ⵉ ⵖⴰ ⵉⵜⵜⴰⵔⴻⵏ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⴻⵡⵛ ⴰⵙ ⵜⵜ, ⵓ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵅⴰⴽ ⵢⴰⵔⴹⴻⵍ, ⵡⴰⵔ ⴷ ⵜ ⵜⵜⴰⵔⵔⴰ ⴰⵎⴻⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT5_43","070_5_43","MAT","5","43","43","“ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ: ‘ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵛⴰⵔⵀⴻⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵛ!’ ");
INSERT INTO rift_vpl VALUES ("MT5_44","070_5_44","MAT","5","44","44","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵅⵙⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ ⵓ ⴱⴰⵔⴽⴻⵎ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴻⵄⵄⵍⴻⵏ, ⴳⴳⴻⵎ ⵜⵛⵓⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⵥⴰⴵⴻⵎ ⵉ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴰⵡⵢⴻⵏ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⴷ ⵢⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵜⵜⴷⴰⵔⵔⴰⵛⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT5_45","070_5_45","MAT","5","45","45","ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵏⴻⵇⵇⴰⵔ ⵜⴰⴼⵓⵛⵜ ⵏⵏⴻⵙ ⵅ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵅⵅⵓ-ⴷⴷ ⵉ ⵡⴻⵏⵥⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵡⴻⵜ ⵅ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT5_46","070_5_46","MAT","5","46","46","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵎⴰⵏ ⴰⵔⴱⴻⵃ ⵉ ⵖⴰⵔⵡⴻⵎ? ⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⵓⵍⴰ ⴰⵎⵎⵓ?    ");
INSERT INTO rift_vpl VALUES ("MT5_47","070_5_47","MAT","5","47","47","ⵎⴰⵍⴰ ⵜⵙⴻⴵⵎⴻⵎ ⵅ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵡⴻⵎ ⵡⴰⵀⴰ, ⵎⵉⵏ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴽⵜⴰⵔ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ? ⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⵓⵍⴰ ⴰⵎⵎⵓ? ");
INSERT INTO rift_vpl VALUES ("MT5_48","070_5_48","MAT","5","48","48","ⵙ ⵓⵢⴰ ⵉⵍⵉⵎ ⵏⵉⵛⴰⵏ ⵇⴰⵄ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵉⴵⴰ ⵏⵉⵛⴰⵏ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("MT6_1","070_6_1","MAT","6","1","1","“ⵃⴹⴰⵎ, ⵡⴰⵔ ⵜⵚⴻⴷⴷⴰⵇⴻⵎ ⵣⵣⴰⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵏ. ⵎⴰⵍⴰ ⴰⵎⵢⴰ, ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⵍⴰⵊⴰⵔ ⵣⵉ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT6_2","070_6_2","MAT","6","2","2","ⵎⴰⵍⴰ ⵜⵚⴻⴷⴷⵇⴻⴷ, ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⴳⴳ ⴷⵉ ⵍⴱⵓⵇ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵎⵏⴰⴼⵇⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵓ ⴷⵉ ⵣⵣⵏⴰⵇⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵛⴻⵏⵏⵄⴻⵏ ⵉⵡⴷⴰⵏ. ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⵓⴼⵉⵏ ⵍⴰⵊⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⴱⴻⵄⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MT6_3","070_6_3","MAT","6","3","3","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵅⵎⵉ ⵖⴰ ⵜⵚⴻⴷⴷⵇⴻⴷ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴰⵣⴻⵍⵎⴰⴹ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("MT6_4","070_6_4","MAT","6","4","4","ⵃⵉⵎⴰ ⵚⵚⴻⴷⵇⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵓⵛⴰ ⴱⴰⴱⴰⵛ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⴰⴷ ⵛⴻⴽ ⵉⵅⴻⴵⴻⵚ ⵙ ⴱⵟⴰⵢⵟⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("MT6_5","070_6_5","MAT","6","5","5","“ⵎⴰⵍⴰ ⵜⴻⵥⵥⵓⴵⴻⴷ, ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⵛⴰ ⴰⵎ ⵢⵉⵎⵏⴰⴼⵇⴻⵏ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⵍⵃⴰⵍ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴰⵎ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⴷ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵣⵣⵏⴰⵇⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵥⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ. ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⵍⴰⵊⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⴱⴻⵄⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MT6_6","070_6_6","MAT","6","6","6","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵎⴰⵍⴰ ⵜⴻⵥⵥⵓⴵⴻⴷ, ⴰⴷⴻⴼ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏⵏⴻⵛ, ⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ, ⵥⵥⴰⴵ ⵉ ⴱⴰⴱⴰⵛ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⵓⵛⴰ ⴱⴰⴱⴰⵛ ⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵅⴻⴵⵚⴻⵏ ⵙ ⴱⵟⴰⵢⵟⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("MT6_7","070_6_7","MAT","6","7","7","ⵎⴰⵍⴰ ⵜⴻⵥⵥⵓⴵⴻⵎ ⵡⴰⵔ ⵜⵜⵄⴰⵡⴰⴷⴻⵎ ⵉ ⵡⴰⵡⴰⵍ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⵥⴰⴵⴰⵏ ⵍⴽⵓⴼⴼⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MT6_8","070_6_8","MAT","6","8","8","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⵅⴻⵏⵏⵉ ⴰⵎ ⵏⵉⵜⵏⵉ, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵜⴻⵃⴷⴰⵊⴻⵎ ⵇⴱⴻⵍ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT6_9","070_6_9","MAT","6","9","9","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴻⵥⵥⴰⴵⴻⵎ ⴽⴻⵏⵏⵉⵡ: ‘ⴰ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MT6_10","070_6_10","MAT","6","10","10","ⴻⵊⵊ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵢⵉⵍⵉ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT6_11","070_6_11","MAT","6","11","11","ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⵙⵙ-ⴰ ⴰⵖⵔⵓⵎ ⵉ ⵏⴻⵀⴷⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("MT6_12","070_6_12","MAT","6","12","12","ⵖⴼⴰⵔ ⴰⵏⴻⵖ ⵉⵎⴰⵔⵡⵓⵙⴰ ⵏⵏⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵙⴰⵎⴻⵃ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⴷⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵓⵔⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT6_13","070_6_13","MAT","6","13","13","ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵙⵉⴷⵉⴼ ⵛⴰ ⴷⴻⴳ ⵓⵊⴰⵔⵔⴻⴱ, ⵎⴰⵛⴰ ⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ. ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴷ ⵊⵊⴻⵀⴷ ⴷ ⵓⵄⵓⴵⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵛⴻⴽ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ!’ ");
INSERT INTO rift_vpl VALUES ("MT6_14","070_6_14","MAT","6","14","14","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵙⴰⵎⵃⴻⵎ ⵉ ⵉⵡⴷⴰⵏ ⵉ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ, ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⴰⵡⴻⵎ ⵉⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT6_15","070_6_15","MAT","6","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵙⵉⵎⵉⵃⴻⵎ ⵉ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵡⴰⵔ ⵉⵖⴻⴼⴼⴰⵔ ⵛⴰ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT6_16","070_6_16","MAT","6","16","16","“ⵍⴰⵎⵉ ⵜⵥⵓⵎⵎⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⴰⵖⴻⵎⴱⵓⴱ ⴰⴱⴰⵔⵛⴰⵏ ⴰⵎ ⵢⵉⵎⵏⴰⴼⵇⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵇⵍⴰⴱⴻⵏ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵥⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵥⵓⵎⵎⴻⵏ. ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⵍⴰⵊⴰⵔ ⵏⵙⴻⵏ ⵣⵉ ⴱⴻⵄⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MT6_17","070_6_17","MAT","6","17","17","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵎⴰⵍⴰ ⵜⵥⵓⵎⵎⴻⴷ, ⴷⵀⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵛ ⵓⵛⴰ ⵙⵉⵔⴻⴷ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("MT6_18","070_6_18","MAT","6","18","18","ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴱⵉⵏⵉⴷ ⵛⴰ ⵉ ⵉⵡⴷⴰⵏ ⴱⴻⵍⵍⵉ ⵜᵉⵜⵜⵥⵓⵎⵎⴻⴷ, ⵎⴰⵛⴰ ⵉ ⴱⴰⴱⴰⵛ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⵓⵛⴰ ⴱⴰⴱⴰⵛ ⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵅⴻⴵⵚⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT6_19","070_6_19","MAT","6","19","19","“ⵡⴰⵔ ⵙⵎⵓⵏⴰⵎ ⵛⴰ ⵍⴻⴽⵏⵓⵣ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷⴰ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵏⵉ ⵉ ⵜⴻⵏ ⵖⴰ ⵜⴻⵛⵛ ⵜⵛⵉⵏⴷⴰ ⴷ ⴷⴷⵔⴰ, ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⵏⵓⵇⵇⴱⴻⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ, ⴰⴷ ⵜⴻⵏ ⴰⵛⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT6_20","070_6_20","MAT","6","20","20","ⵎⴰⵛⴰ ⵙⵎⵓⵏⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵍⴻⴽⵏⵓⵣ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⴻⵜⵜ ⵛⴰ ⵜⵛⵉⵏⴷⴰ ⴷ ⴷⴷⵔⴰ, ⵓ ⵎⴰⵏⵉ ⵡⴰⵔ ⵙⵙⵏⵓⵇⵇⵓⴱⴻⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴰⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT6_21","070_6_21","MAT","6","21","21","ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵢⵉⵍⵉ ⵍⴽⴻⵏⵣ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵓⵍ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MT6_22","070_6_22","MAT","6","22","22","“ⵍⴻⴼⵏⴰⵔ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⴻⵜⵜⴰ ⴷ ⵜⵉⵟⵟ. ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⴰⵇⴰ ⵜⴻⵚⴼⴰ, ⴰⴷ ⵜⵉⵍⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⴷ ⵜⴰⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("MT6_23","070_6_23","MAT","6","23","23","ⵎⴰⵔⴰ ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⴷ ⵜⴰⴵⴻⵙⵜ. ⵎⴰⵍⴰ ⵜⴰⴼⴰⵡⵜ ⵜⴻⵏⵏⵉ ⴷⴰⵢⴻⴽ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵎⴻⵛⵃⴰⵍ ⵜⴻⵎⵖⴰⵔ ⵜⴰⴵⴻⵙⵜ! ");
INSERT INTO rift_vpl VALUES ("MT6_24","070_6_24","MAT","6","24","24","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵅⴷⴻⵎ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⵉⴷⵉⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵛⴰⵔⵀ ⵉⵊⵊⴻⵏ, ⴰⴷ ⵉⵅⵙ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵏⵉⵖ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⵉⵊⵊⴻⵏ, ⴰⴷ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴻⵏⵄⴰⵛⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT6_25","070_6_25","MAT","6","25","25","“ⵙ ⵓⵢⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ‘ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⴰⵎⵏⵓⵙ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ, ⵎⵉⵏ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⵏⵉⵖ ⵎⵉⵏ ⵖⴰ ⵜⴻⵙⵡⴻⵎ, ⵓⵍⴰ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵉ ⵖⴰ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⵎ. ⵅⵣⴰⵔⴻⵎ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵃⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵅ ⵎⴰⵛⵛⴰ ⵏⵉⵖ ⴰⵔⵔⵉⵎⴻⵜ ⵅ ⵡⴰⵔⵔⵓⴹ? ");
INSERT INTO rift_vpl VALUES ("MT6_26","070_6_26","MAT","6","26","26","ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴰⵔⵔⵄⴻⵏ, ⵡⴰⵔ ⵎⴻⵊⵊⴰⵔⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵅⴻⵎⵎⵉⵍⴻⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵙⵉ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵜⴻⵏ ⵉⵙⵙⴻⵛⵛⴰⵏ. ⵅⵣⴰⵔⴻⵎ, ⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⴻⴽⴽⵡⵉⵎ ⵛⴰ ⴽⵜⴰⵔ ⴰⵟⵟⴰⵙ ⵅⴰⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MT6_27","070_6_27","MAT","6","27","27","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵣⴻⵎⵎⴰⵔ ⵙ ⵡⴻⵎⵏⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⵏⵉ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MT6_28","070_6_28","MAT","6","28","28","ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵜⴽⴻⵙⵙⵉⵎ ⴰⵎⵏⵓⵙ ⵉ ⵡⴰⵔⵔⵓⴹ? ⵅⵣⴰⵔⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴻⵎⵎⵢⴻⵏⵜ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⵅⴻⴷⴷⵎⴻⵏⵜ, ⵡⴰⵔ ⵜⵜⵇⴰⵔⴹⵛⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("MT6_29","070_6_29","MAT","6","29","29","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵓⵍⴰ ⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵡⴰⵔ ⵢⴰⵔⴹ ⵛⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT6_30","070_6_30","MAT","6","30","30","ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵢⴰⵔⴹ ⴰⵎⵎⵓ ⴰⵔⴱⵉⵄ ⵏ ⵉⵢⵢⴰⵔ ⵉ ⵉⴵⴰⵏ ⴰⵙⵙ-ⴰ ⵓⵛⴰ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵢⵉⵔⵔⴻⴹ ⴰⵟⵟⴰⵙ ⵃⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⵉ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵍ’ⵉⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("MT6_31","070_6_31","MAT","6","31","31","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵛⴰ ⴰⵎⵏⵓⵙ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵎ: ‘ⵎⵉⵏ ⵖⴰ ⵏⴻⵛⵛ?’, ⵓ: ‘ⵎⵉⵏ ⵖⴰ ⵏⵙⵓ?’, ⵏⵉⵖ: ‘ⵎⵉⵏ ⵖⴰ ⵏⵢⴰⵔⴹ?’ ");
INSERT INTO rift_vpl VALUES ("MT6_32","070_6_32","MAT","6","32","32","ⵎⴰⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵔⴻⵣⵣⵓⵏ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⵜⴻⵃⴷⴰⵊⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT6_33","070_6_33","MAT","6","33","33","ⴰⵔⵣⵓⵎ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵉⵎⵎⴰⵔⵏⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT6_34","070_6_34","MAT","6","34","34","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⴰⵎⵏⵓⵙ ⵉ ⵎⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵜⵉⵡⴻⵛⵛⴰ, ⵎⵉⵏⵣⵉ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵜⴻⴽⵙⵉ ⴰⵎⵏⵓⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵉⵛⴼⴰ ⵉ ⴽⵓⵍ ⴰⵙⵙ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT7_1","070_7_1","MAT","7","1","1","“ⵡⴰⵔ ⵃⴻⴽⴽⵎⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⴰⵎⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT7_2","070_7_2","MAT","7","2","2","ⵎⵉⵏⵣⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵃⵓⴽⵎ ⵉ ⵣⵉ ⵖⴰ ⵜⵃⴻⴽⵎⴻⵎ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⵎⴻⵎ, ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵄⴱⴰⵔ ⵉ ⵣⵉ ⵖⴰ ⵜⴻⵄⴱⴰⵔⴻⵎ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵄⴱⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT7_3","070_7_3","MAT","7","3","3","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵖⴰⵔ ⵓⵅⴻⵛⵛⵉⵡ ⴷⵉ ⵜⵉⵟⵟ ⵏ ⵓⵎⴰⵛ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵃⴻⴽⴽⴰⵔⴻⴷ ⵛⴰ ⵉ ⵜⴻⵃⵏⴰⵛⵜ ⵜⴻⵏⵏⵉ ⴷⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("MT7_4","070_7_4","MAT","7","4","4","ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⴰⴷ ⵜⵉⵏⵉⴷ ⵉ ⵓⵎⴰⵛ: ‘ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵛ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⴰⵅⴻⵛⵛⵉⵡ ⵣⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ’, ⵓⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵜⴰⵃⵏⴰⵛⵜ ⴷⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("MT7_5","070_7_5","MAT","7","5","5","ⵛⴻⴽ, ⴰ ⴰⵎⵏⴰⴼⴻⵇ, ⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⴰⵃⵏⴰⵛⵜ ⵣⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ ⵎⵍⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵅⴻⵛⵛⵉⵡ ⵣⵉ ⵜⵉⵟⵟ ⵏ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("MT7_6","070_7_6","MAT","7","6","6","ⵡⴰⵔ ⵜⵜⵉⵛⴻⵎ ⵎⵉⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵢⵉⵟⴰⵏ, ⵡⴰⵔ ⵏⴻⵟⵟⴰⵔⴻⵎ ⵛⴰ ⵜⵉⵢⴰⵇⵓⵜⵉⵏ ⵏⵡⴻⵎ ⵉ ⵉⵍⴼⴰⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏⵜ ⵄⴻⴼⴼⵙⴻⵏ ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵏⵇⴻⵍⴱⴻⵏ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵎⴻⵣⵣⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT7_7","070_7_7","MAT","7","7","7","“ⵜⵜⴰⵔⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛ, ⴰⵔⵣⵓⵎ, ⴰⴷ ⵜⴰⴼⴻⵎ, ⵙⵇⴰⵔⵇⴱⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵔⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT7_8","070_7_8","MAT","7","8","8","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⴰⵔⴻⵏ, ⴰⴷ ⵉⵟⵟⴻⴼ ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⵣⵓⵏ ⴰⴷ ⵢⴰⴼ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵇⴰⵔⵇⴱⴻⵏ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵔⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT7_9","070_7_9","MAT","7","9","9","ⵏⵉⵖ ⵎⴰⵏ ⴱⵏⴰⴷⴻⵎ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵎⴰⵍⴰ ⵎⵎⵉⵙ ⵉⵜⵜⴰⵔ ⴰⵙ ⴰⵖⵔⵓⵎ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⵥⵔⵓ? ");
INSERT INTO rift_vpl VALUES ("MT7_10","070_7_10","MAT","7","10","10","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵜⵜⴰⵔ ⴰⵙ ⵜⴰⵙⵍⴻⵎⵜ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⴼⵉⵖⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("MT7_11","070_7_11","MAT","7","11","11","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⵡⵛⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⵢⴻⵡⵛ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵜⵜⴰⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("MT7_12","070_7_12","MAT","7","12","12","ⵇⴰⵄ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵏ ⵉⵡⴷⴰⵏ, ⴳⴳⴻⵎ ⴰⵎⵢⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⵏⵉⵜⵏⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT7_13","070_7_13","MAT","7","13","13","“ⴰⴷⴼⴻⵎ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵉⵃⵚⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴰⵡⵡⴰⵔⵜ ⵜⴻⵎⵖⴰⵔ ⵓⵍⴰ ⴷ ⴰⴱⵔⵉⴷ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵓⵀⴻⵍⵍⴻⴽ ⴷ ⵎⵉⵔⵉⵡ, ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴰⴷⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT7_14","070_7_14","MAT","7","14","14","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵃⵚⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵥⵉ ⵡⴻⴱⵔⵉⴷ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ! ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴰⴼⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT7_15","070_7_15","MAT","7","15","15","“ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵖⴰⵔⵡⴻⵎ ⵙ ⵜⵀⵉⴹⵓⵔⵜ ⵏ ⵉⵣⵎⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵉⵄⴻⴷⴷⵉⵙⴻⵏ ⵏⵙⴻⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵓⵛⵛⴰⵏⴻⵏ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT7_16","070_7_16","MAT","7","16","16","ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵏⴻⵎ. ⵎⴰ ⴰⴷ ⵍⴻⵇⴹⴻⵏ ⴰⴹⵉⵍ ⵣⴻⴳ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵏⵉⵖ ⵜⴰⵣⴰⵔⵜ ⵣⵉ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("MT7_17","070_7_17","MAT","7","17","17","ⴰⵎⵎⵓ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵚⴱⴻⵃ, ⵓⵛⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ.    ");
INSERT INTO rift_vpl VALUES ("MT7_18","070_7_18","MAT","7","18","18","ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵓⵛⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵡⵛ ⵍⵖⵉⴵⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT7_19","070_7_19","MAT","7","19","19","ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵚⴱⴻⵃ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MT7_20","070_7_20","MAT","7","20","20","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵏⴻⵎ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT7_21","070_7_21","MAT","7","21","21","“ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵏⵉⵏ: ‘ⴰ ⵙⵉⴷⵉ, ⴰ ⵙⵉⴷⵉ!’, ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵛⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT7_22","070_7_22","MAT","7","22","22","ⴰⵟⵟⴰⵙ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵏⵉⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ: ‘ⴰ ⵙⵉⴷⵉ, ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵏⴰⴱⴱ ⵛⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵎⴰ ⵡⴰⵔ ⵏⵓⵥⵥⵉⵍ ⵅ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵎⴰ ⵡⴰⵔ ⵏⴻⴳⴳⵉ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ?’ ");
INSERT INTO rift_vpl VALUES ("MT7_23","070_7_23","MAT","7","23","23","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵉⵏⵉⵖ ⵏⵉⵛⴰⵏ: ‘ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⵏⴻⵖ, ⴱⴻⵄⵄⴷⴻⵎ ⵅⴰⴼⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ!’” ");
INSERT INTO rift_vpl VALUES ("MT7_24","070_7_24","MAT","7","24","24","“ⵙ ⵓⵢⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵉⵜⵜⴻⴳⴳ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵎⵇⵓⴷⴷⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⵉⵖⵉⵙ ⵡⴻⵏⵏⵉ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵅ ⵙⵙⴻⴵⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("MT7_25","070_7_25","MAT","7","25","25","ⵅⴻⵏⵏⵉ ⵉⵡⵜⴰ ⵡⴻⵏⵥⴰⵔ, ⵃⴻⵎⵍⴻⵏ-ⴷⴷ ⵉⵖⴻⵣⵔⴰⵏ, ⵙⵓⴹⴻⵏ-ⴷⴷ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵓⵛⴰ ⵍⴻⵇⴼⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜⴻⵡⴹⵉ ⵛⴰ, ⵎⵉⵏⵣⵉ ⴷⵙⴰⵙ ⵏⵏⴻⵙ ⵉⵎⵎⴰⵔⵙ ⵅ ⵙⵙⴻⴵⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("MT7_26","070_7_26","MAT","7","26","26","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵜⵜⴻⴳⴳ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⴼⵖⵓⵍ ⵉ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵅ ⵉⵊⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("MT7_27","070_7_27","MAT","7","27","27","ⵅⴻⵏⵏⵉ ⵉⵡⵜⴰ ⵡⴻⵏⵥⴰⵔ, ⵃⴻⵎⵍⴻⵏ-ⴷⴷ ⵉⵖⴻⵣⵔⴰⵏ, ⵙⵓⴹⴻⵏ-ⴷⴷ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ, ⵍⴻⵇⴼⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵜⴻⵡⴹⴰ, ⵜⵓⵖⴰ ⴰⵡⴻⵟⵟⵓ ⵏⵏⴻⵙ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT7_28","070_7_28","MAT","7","28","28","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⴰⵙⵓⵄ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵍⵖⴰⵛⵉ ⵉⵇⵇⵉⵎ ⵉⵜⵜⴻⴱⵀⴻⵜ ⵙ ⵜⵖⵓⵔⵉ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MT7_29","070_7_29","MAT","7","29","29","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴰⵎ ⵢⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT8_1","070_8_1","MAT","8","1","1","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵀⵡⴰ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⴹⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MT8_2","070_8_2","MAT","8","2","2","ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ ⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ, ⵉⵙⵊⴻⴷ ⴰⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵣⴷⴻⴳⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT8_3","070_8_3","MAT","8","3","3","ⵢⴰⵙⵓⵄ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵃⴰⴷⴰ ⵜ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ, ⵣⴷⴻⴳ!” ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵣⵉ ⵍⴱⴰⵔⵚ ⵏⵏⴻⵙ ⵍⴻⵅⴷⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT8_4","070_8_4","MAT","8","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵅⵣⴰⵔ, ⵡⴰⵔ ⵜⵜⴻⵇⵇⴰⵔ ⵉ ⵃⴻⴷ, ⵎⴰⵛⴰ ⵔⵓⵃ, ⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴻⵡⵛ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵡⴻⵚⵚⴰ ⵎⵓⵙⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT8_5","070_8_5","MAT","8","5","5","ⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ, ⵉⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴰⵎⵎⵓ, ");
INSERT INTO rift_vpl VALUES ("MT8_6","070_8_6","MAT","8","6","6","ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵏⵓ ⵉⵣⵣⴻⵍ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⴰⵏⴻⵄⴹⴰⴱ, ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍⴻⵃⵔⵉⵇ ⴰⵟⵟⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("MT8_7","070_8_7","MAT","8","7","7","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ, ⴰⴷ ⵜ ⵙⵙⴳⴻⵏⴼⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("MT8_8","070_8_8","MAT","8","8","8","ⵓⵛⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴷⵉⵀⴻⴵⴻⵖ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵜⵣⴻⵇⵇⴰ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵉⵏⵉ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵡⴰⵀⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MT8_9","070_8_9","MAT","8","9","9","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⴷ ⴱⵏⴰⴷⴻⵎ ⵙⴰⴷⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵛⴰ ⵖⴰⵔⵉ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵇⵇⴰⵔⴻⵖ ⵉ ⵡⴰ: ‘ⵔⵓⵃ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵔⴰⵃ, ⵓ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: ‘ⴰⵙ-ⴷⴷ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵓ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ ⵇⵇⴰⵔⴻⵖ ⴰⵙ: ‘ⴻⴳⴳ ⵎⴰⵏ ⴰⵢⴰ!’, ⵓⵛⴰ ⴰⴷ ⵜ ⵉⴳⴳ.” ");
INSERT INTO rift_vpl VALUES ("MT8_10","070_8_10","MAT","8","10","10","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵜⵜⴻⴱⵀⴻⵜ, ⵉⵏⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵍ’ⵉⵎⴰⵏ ⴰⵎ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MT8_11","070_8_11","MAT","8","11","11","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⴰⵟⵟⴰⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵣⵉ ⵛⵛⴰⵔⵇ ⵓ ⵣⵉ ⵍⵖⴰⵔⴱ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("MT8_12","070_8_12","MAT","8","12","12","ⵎⴰⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴰⴷ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴰⴵⴻⵙⵜ. ⴷⵉⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT8_13","070_8_13","MAT","8","13","13","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ: “ⵔⵓⵃ, ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵎⵏⴻⴷ.” ⵓⵛⴰ ⵉⴳⴳⴻⵏⴼⴰ ⵓⵃⴻⵏⵊⵉⵔ ⵏⵏⴻⵙ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT8_14","070_8_14","MAT","8","14","14","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵉⵥⵔⴰ ⵜⴰⴹⴻⴽⴽⵡⴰⵍⵜ ⵏⵏⴻⵙ ⵜⴻⵣⵣⴻⵍ, ⴷⴰⵢⴻⵙ ⵜⵉⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MT8_15","070_8_15","MAT","8","15","15","ⵉⵃⴰⴷⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵔⵓⵃ ⴰⵙ ⵜⵎⴻⵙⵙⵉ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ, ⵜⵙⴻⵅⵅⴰⵔ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT8_16","070_8_16","MAT","8","16","16","ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴰⵔⵢⴰⵃⴻⵏ ⵉ ⴷⴰⵢⵙⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ. ⵉⵙⵙⵓⴼⴼⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵏⵙⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵡⴰⵀⴰ, ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵀⵍⴰⵛ, ");
INSERT INTO rift_vpl VALUES ("MT8_17","070_8_17","MAT","8","17","17","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ: “ⴰⴷ ⵉⴽⵙⵉ ⵍⴻⵃⵔⵉⵇ ⵏⵏⴻⵖ ⵓ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("MT8_18","070_8_18","MAT","8","18","18","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⵥⵡⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("MT8_19","070_8_19","MAT","8","19","19","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵖ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT8_20","070_8_20","MAT","8","20","20","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵉⵛⴻⵄⴱⴰⵏ ⵖⴰⵔⵙⴻⵏ ⵉⴼⵔⴰⵏ ⵓ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⵡⴰⵛⵛ, ⵎⴰⵛⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵢⵓⴼⵉ ⵛⴰ ⵎⴰⵏⵉ ⵖⴰ ⵉⵙⴻⵏⵏⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT8_21","070_8_21","MAT","8","21","21","ⵉⵏⵏⴰ ⴰⵙ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⴰⵢⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⴰⴷ ⵏⴻⴹⵍⴻⵖ ⴱⴰⴱⴰ!” ");
INSERT INTO rift_vpl VALUES ("MT8_22","070_8_22","MAT","8","22","22","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ, ⴻⵊⵊ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⴷ ⵏⴻⴹⵍⴻⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵏⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT8_23","070_8_23","MAT","8","23","23","ⵍⴰⵎⵉ ⵉⵏⵢⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵏⵢⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT8_24","070_8_24","MAT","8","24","24","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⴻⴽⴽⴰⵔ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵍ ⵎⴰⵏⵉ ⴷⵍⵉⵏⵜ ⵍⴻⵎⵡⴰⵊ ⴰⵖⴰⵔⵔⴰⴱⵓ, ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵟⵟⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("MT8_25","070_8_25","MAT","8","25","25","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⴼⴰⵇⴻⵏ ⵜ-ⵉ-ⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ, ⴰⵇⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("MT8_26","070_8_26","MAT","8","26","26","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⵉ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵍ’ⵉⵎⴰⵏ?” ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ, ⵉⵡⴻⴱⴱⴻⵅ ⴰⵙⴻⵎⵎⵉⴹ ⴷ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵍⵀⵓⴷⵏⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT8_27","070_8_27","MAT","8","27","27","ⵜⴱⴻⵀⵜⴻⵏ ⵉⵡⴷⴰⵏ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰ ⵓⵎⵉ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⴷ ⵍⴻⴱⵃⴰⵔ ⵜⵜᵉⵟⵟⴰⵄⴻⵏ ⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("MT8_28","070_8_28","MAT","8","28","28","ⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴳⴰⴷⴰⵔⵉⵏⵉⵙ, ⵍⵇⴰⵏ ⵜ-ⵉ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴰⵔⵢⴰⵃⴻⵏ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ, ⵜⵓⵖⴰ ⵎⵎⵓⵣⵣⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ ⴰⵍ ⵎⴰⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴻⴽⴽ ⴰⴱⵔⵉⴷ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT8_29","070_8_29","MAT","8","29","29","ⵙⵖⵓⵢⵢⴻⵏ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⴷ ⵛⴻⴽ, ⴰ ⵢⴰⵙⵓⵄ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵜⵓⵙⵉⴷ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⵄⴻⴷⴷⴱⴻⴷ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ?” ");
INSERT INTO rift_vpl VALUES ("MT8_30","070_8_30","MAT","8","30","30","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵉⵍⴼⴰⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⵉⴳⴳⵯⴻⵊ ⵅⴰⵙⴻⵏ, ⵜⵀⴻⴷⴷⴰ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT8_31","070_8_31","MAT","8","31","31","ⵓⵛⴰ ⵛⵛⵡⴰⵟⴻⵏ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵏⴻⵖ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵃⵉⵎⴰⵔⵜ ⵏ ⵢⴻⵍⴼⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT8_32","070_8_32","MAT","8","32","32","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ, ⵓⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵍⴼⴰⵏ. ⵓⵛⴰ ⵅⵣⴰⵔ, ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⵉⵍⴼⴰⵏ ⴰⵎⴻⵏ ⵜⵎⵓⵏ ⵜⴻⵃⴷⵓⴷⴷⴰⵔ ⵣⵉ ⵜⴻⵢⵙⴰⵔⵜ, ⵓⵛⴰ ⵉⵍⴼⴰⵏ ⵡⴹⴰⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵎⵎⵓⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT8_33","070_8_33","MAT","8","33","33","ⴰⵔⴻⵡⵍⴻⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵓⵛⴰ ⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵅ ⴽⵓⵍⵛⵉ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⵓⵍⴰ ⵅ ⵉⵎⴰⵔⵢⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT8_34","070_8_34","MAT","8","34","34","ⵓⵛⴰ ⵅⵣⴰⵔ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵉ ⵓⵎⵙⴰⴳⴰⵔ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ. ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ, ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT9_1","070_9_1","MAT","9","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵢⴰ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵉⵥⵡⴰ ⵍⴻⴱⵃⴰⵔ, ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT9_2","070_9_2","MAT","9","2","2","ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵏⴻⵄⴹⴰⴱ ⵉ ⵜⵓⵖⴰ ⵉⵣⵣⵍⴻⵏ ⴷⵉ ⵜⴰⵙⵙⵓⵜ. ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵓⵏⴻⵄⴹⴰⴱ: “ⴻⴳⴳ ⵓⵍ, ⴰ ⵎⵎⵉ, ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT9_3","070_9_3","MAT","9","3","3","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵛⴰ ⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵏⵏⴰⵏ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ: “ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⴷⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT9_4","070_9_4","MAT","9","4","4","ⵢⴰⵙⵓⵄ, ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵅⴻⵎⵎⴰⵎⴻⵎ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MT9_5","070_9_5","MAT","9","5","5","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵀⴻⵡⵏⴻⵏ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵡⴰⵏⵉⵜⴰ: ‘ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ!’, ⵏⵉⵖ ⴰⴷ ⵉⵏⵉⵖ: ‘ⴽⴽⴰⵔ, ⵓⵢⵓⵔ’? ");
INSERT INTO rift_vpl VALUES ("MT9_6","070_9_6","MAT","9","6","6","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ, ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵓⵏⴻⵄⴹⴰⴱ-ⴰ: “ⴽⴽⴰⵔ, ⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ, ⵜⴰⵔⴻⴽⴽⵡⴻⵃⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("MT9_7","070_9_7","MAT","9","7","7","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT9_8","070_9_8","MAT","9","8","8","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⵖⴰⵛⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵜⴱⴻⵀⵜⴻⵏ, ⵙⵙⵄⵓⴵⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵚⵚⵓⵍⵟⴰ ⴰⵎ ⵜⴰⵏⵉⵜⴰ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT9_9","070_9_9","MAT","9","9","9","ⵍⴰⵎⵉ ⵙⵙⴻⵏⵏⵉ ⵉⴽⴽⴰ ⵢⴰⵙⵓⵄ, ⵉⵥⵔⴰ ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵎⴰⵜⵜⴰ, ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ. ⵉⵏⵏⴰ ⴰⵙ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ⵓⵛⴰ ⵉⴽⴽⴰⵔ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT9_10","070_9_10","MAT","9","10","10","ⵍⴰⵎⵉ ⵇⵇⵉⵎⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT9_11","070_9_11","MAT","9","11","11","ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⴻⵜⵜ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ?” ");
INSERT INTO rift_vpl VALUES ("MT9_12","070_9_12","MAT","9","12","12","ⵓⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⵏⵉ ⵉⵚⴻⵃⵃⴻⵏ, ⵡⴰⵔ ⵃⴷⵉⵊⴻⵏ ⵛⴰ ⴰⴹⴱⵉⴱ, ⵎⴰⵛⴰ ⵉⵎⴻⵀⵍⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("MT9_13","070_9_13","MAT","9","13","13","ⵔⵓⵃⴻⵎ, ⴰⴷ ⵜⵍⴻⵎⴷⴻⵎ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵡⴰⵡⴰⵍ-ⴰ: ‘ⵅⵙⴻⵖ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⵜⴰⵖⴰⵔⵚⵜ!’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⵅ ⵉⵎⴻⴷⵏⴰⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT9_14","070_9_14","MAT","9","14","14","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵜⵜⵥⵓⵎⵎⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵜⵥⵓⵎⵎⵉⵏ ⵛⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT9_15","070_9_15","MAT","9","15","15","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵛⴻⴹⵏⴻⵏ ⵍⴻⵃⴱⴰⴱ ⵏ ⵓⵎⵓⵍⴰⵢ ⵓⵎⵉ ⴰⵎⵓⵍⴰⵢ ⵄⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ? ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵎⵎⴻⴽⵙⵉ ⵓⵎⵓⵍⴰⵢ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵥⵓⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT9_16","070_9_16","MAT","9","16","16","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵜⴰⵏⴻⵇⵇⵉⵍⵜ ⵏ ⵜⵛⵓⵇⵇⴻⵜ ⵏ ⵊⴷⵉⴷ ⵅ ⵡⴰⵔⵔⵓⴹ ⴰⵇⴷⵉⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵇⴻⴵⵉⵄ ⵜⵏⴻⵇⵇⵉⵍⵜ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵓⵛⴰ ⴰⴷ ⵉⵇⵇⴰⵔⵚ ⵡⴰⵔⵔⵓⴹ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT9_17","070_9_17","MAT","9","17","17","ⵓⵍⴰ ⴷ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳ ⵛⴰ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵜⵉⴱⵓⵍⴰⵢ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷⵓⵇⵇⵓⵣⴻⵏⵜ ⵜⵅⵓⵏⵛⴰⵢ, ⴰⴷ ⵉⵣⴻⴵⴻⵄ ⴱⵉⵏⵓ ⵓⵛⴰ ⵜⵉⵅⵓⵏⵛⴰⵢ ⴰⴷ ⴹⴻⵢⵢⵄⴻⵏⵜ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⴻⴳⴳⴻⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵊⴷⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵅⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT9_18","070_9_18","MAT","9","18","18","ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵊⴻⴷ ⴰⵙ, ⵉⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⵢⴻⴵⵉ ⴱⵃⵍⴰ ⵜⴻⵎⵎⵓⵜ, ⵎⴰⵛⴰ ⴰⵙ-ⴷⴷ, ⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT9_19","070_9_19","MAT","9","19","19","ⵢⴰⵙⵓⵄ ⵉⴽⴽⴰⵔ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT9_20","070_9_20","MAT","9","20","20","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⵓⵖⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵜⴻⴽⴽⴰ ⴰⵙ-ⴷⴷ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵓⵛⴰ ⵜⵃⴰⴷⴰ ⴰⴱⴻⵃⵍⵓⵍ ⵏ ⵓⵊⴻⴵⴰⴱ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MT9_21","070_9_21","MAT","9","21","21","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⵏⵏⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ: “ⵉⵛⴼⴰ ⵎⵖⵉⵔ ⴰⴷ ⵃⴰⴷⵉⵖ ⴰⵊⴻⴵⴰⴱ ⵏⵏⴻⵙ, ⴰⴷ ⴳⴳⴻⵏⴼⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("MT9_22","070_9_22","MAT","9","22","22","ⵎⴰⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵥⵔⴰ ⵉ-ⵜⵜ, ⵉⵏⵏⴰ: “ⴻⴳⴳ ⵓⵍ, ⴰ ⵢⴻⴵⵉ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵎ ⵉ ⵛⴻⵎ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ!” ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴳⴻⵏⴼⴰ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT9_23","070_9_23","MAT","9","23","23","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉⵥⵔⴰ ⵉⵖⴻⵢⵢⴰⴹⴻⵏ ⴷ ⵍⵖⴰⵛⵉ ⵙⵖⵓⵢⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MT9_24","070_9_24","MAT","9","24","24","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴼⴼⵖⴻⵎ ⵙⵙⴰ! ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵡⴰⵔ ⵜⴻⵎⵎⵓⵜ ⵛⴰ, ⴰⵇⴰ ⵜᵉⵟⵟⴻⵚ!” ⵏⵉⵜⵏⵉ ⴹⴻⵃⵛⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT9_25","070_9_25","MAT","9","25","25","ⴰⵍⴰⵎⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⵖⴰⵛⵉ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ ⵜⵃⴻⵏⵊⵉⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT9_26","070_9_26","MAT","9","26","26","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT9_27","070_9_27","MAT","9","27","27","ⵍⴰⵎⵉ ⵙⵙⴻⵏⵏⵉ ⵉⴽⴽⴰ ⵢⴰⵙⵓⵄ, ⴹⴼⴰⵔⴻⵏ ⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵜⵜⵍⴰⵖⴰⵏ, ⵇⵇⴰⵔⴻⵏ: “ⴰⵔⵃⴻⵎ ⴰⵏⴻⵖ, ⴰ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT9_28","070_9_28","MAT","9","28","28","ⴰⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵏⵏⵉ. ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵜⵓⵎⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("MT9_29","070_9_29","MAT","9","29","29","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵃⴰⴷⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ: “ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("MT9_30","070_9_30","MAT","9","30","30","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵃⴰⵔⵔⴻⵎ ⵉ-ⵜⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵖⴰⵔⵡⴻⵎ, ⵡⴰⵔ ⵙⵙⴰⵔⴳⴰⴱⴻⵎ ⵃⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT9_31","070_9_31","MAT","9","31","31","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ, ⴰⵍⴰⵎⵉ ⵔⵓⵃⴻⵏ, ⵙⵙⵓⴼⴼⵖⴻⵏ ⵅⴰⵙ ⵍⴻⵅⴱⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("MT9_32","070_9_32","MAT","9","32","32","ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵏⵉⵜⵏⵉ, ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵢⵏⴰⵡ, ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT9_33","070_9_33","MAT","9","33","33","ⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴼⴻⵖ ⵛⵛⵉⵟⴰⵏ ⵏⵏⵉ, ⵉⵙⵙⵉⵡⴻⵍ ⵡⴻⵢⵏⴰⵡ. ⵜⵓⵖⴰ ⵉⵜⵜⴻⴱⵀⴻⵜ ⵍⵖⴰⵛⵉ, ⵏⵏⴰⵏ: “ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵏⴻⵥⵔⵉ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⴷⵉ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("MT9_34","070_9_34","MAT","9","34","34","ⵎⴰⵛⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ: “ⵙ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT9_35","070_9_35","MAT","9","35","35","ⵢⴻⵛⵛⵓ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵏⵏⴻⴹ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷ ⴷⵛⵓⵔⴰⵜ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛⴰⵜ ⴷ ⵍⴻⵄⵢⵓⴱ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MT9_36","070_9_36","MAT","9","36","36","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍⵖⴰⵛⵉ, ⵉⵃⵉⵏⵏ ⵅⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵃⵍⴻⵏ ⵏⵏⵀⴻⵡⵍⴻⵏ ⴰⵎ ⵡⵓⴵⵉ ⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵓⵎⴻⴽⵙⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("MT9_37","070_9_37","MAT","9","37","37","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵜⴰⵎⴻⵢⵔⴰ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⴷⵔⵓⵙ ⵏ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT9_38","070_9_38","MAT","9","38","38","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⴰⵔⴻⵎ ⵉ ⴱⴰⴱ ⵏ ⵜⵎⴻⵢⵔⴰ, ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ ⵉ ⵜⵎⴻⵢⵔⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT10_1","070_10_1","MAT","10","1","1","ⵉⵍⴰⵖⴰ ⵢⴰⵙⵓⵄ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵏⴼⴰⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵢⵓⴱⴰⵜ ⴷ ⵍⴻⵀⵍⴰⵛⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("MT10_2","070_10_2","MAT","10","2","2","ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⴷ ⵢⵉⵏⴰ: ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵥⵔⵓ’, ⴷ ⵓⵎⴰⵙ ⴰⵏⴷⵔⴰⵡⵓⵙ, ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ, ⴷ ⵓⵎⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("MT10_3","070_10_3","MAT","10","3","3","ⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ ⴷ ⴱⴰⵔ-ⵜⵓⵍⵓⵎⴰⵡⵓⵙ, ⵜⵓⵎⴰ ⴷ ⵎⴰⵜⵜⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴱⵓ-ⴹⴹⴰⵔⵉⴱⴰ, ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵍⴼⴰ, ⴷ ⵍⴰⴱⴱⴰⵡⵓⵙ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵜⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("MT10_4","070_10_4","MAT","10","4","4","ⴷ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵄⴻⵙⵙⴰⴱ, ⴷ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⴻⵍⵍⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_5","070_10_5","MAT","10","5","5","ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⴽⴽ ⵜⴻⵏⵄⴰⵛ-ⴰ, ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⵔⵓⵃⴻⵎ ⵛⴰ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴽⵓⴼⴼⴰⵔ, ⵡⴰⵔ ⵜⵜⴰⴷⴼⴻⵎ ⵛⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT10_6","070_10_6","MAT","10","6","6","ⵎⴰⵛⴰ ⵃⵙⴻⵏ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⵖⴰⵔ ⵡⵓⴵⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT10_7","070_10_7","MAT","10","7","7","ⵅⵎⵉ ⵖⴰ ⵜⵔⴰⵃⴻⵎ, ⴱⴰⵔⵔⵃⴻⵎ ⴰⵎ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ!’ ");
INSERT INTO rift_vpl VALUES ("MT10_8","070_10_8","MAT","10","8","8","ⵙⴳⴻⵏⴼⴰⵎ ⵉⵎⴻⵀⵍⴰⵛ, ⵙⵉⵣⴷⴳⴻⵎ ⵉⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ, ⵙⵓⴼⴼⵖⴻⵎ ⵛⵛⵡⴰⵟⴻⵏ. ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⵙⵉⵎ ⴱⵍⴰ ⵛⴰ, ⵅⴻⵏⵏⵉ ⵡⵛⴻⵎ ⵜⵜ ⴱⵍⴰ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT10_9","070_10_9","MAT","10","9","9","ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵛⴰ ⵡⵓⵔⴻⵖ ⵓⵍⴰ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵍⴰ ⴷ ⵏⵏⵃⴰⵙ ⴷⴻⴳ ⵉⴱⵓⵢⴰⵙ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT10_10","070_10_10","MAT","10","10","10","ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵛⴰ ⵜⵜⴻⵙⵟⵉⵎ ⵉ ⵡⴻⴱⵔⵉⴷ ⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ ⵍⴰ ⴷ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵓⵍⴰ ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⵅⴻⴷⴷⴰⵎ ⵉⵙⴷⴰⵀⴻⴵ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT10_11","070_10_11","MAT","10","11","11","ⵎⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵉⵖ ⴷⵛⴰⵔ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ, ⴰⵔⵣⵓⵎ ⵡⵉ ⴷⴰⵢⴻⵙ ⵉⵙⴷⴰⵀⴻⴵ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵎ ⴷⵉⵏ ⴰⵍ ⴷ ⵜⵔⴰⵃⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT10_12","070_10_12","MAT","10","12","12","ⵎⴰⵍⴰ ⵜⵓⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵙⴻⴵⵎⴻⵎ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MT10_13","070_10_13","MAT","10","13","13","ⵎⴰⵍⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵙⴷⴰⵀⴻⴵ, ⵊⵊⴻⵎ ⵅⴰⵙ ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜ ⵜⴻⵙⴷⵉⵀⴻⴵ, ⵅⴻⵏⵏⵉ ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵄⵇⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("MT10_14","070_10_14","MAT","10","14","14","ⵎⴰⵍⴰ ⵜⵓⴼⵉⵎ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴻⴱⴱⴻⵍ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵡⴻⵎ, ⴼⴼⵖⴻⵎ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵏⵉⵖ ⵣⵉ ⴷⵛⴰⵔ ⵏⵏⵉ, ⵣⵣⴻⵔⵣⴻⵎ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT10_15","070_10_15","MAT","10","15","15","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴰⵍ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⵉⵀⵡⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT10_16","070_10_16","MAT","10","16","16","“ⵅⵣⴰⵔⴻⵎ, ⵍⴻⵅⵅⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵎ ⵓⴵⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⵓⵛⵛⴰⵏⴻⵏ. ⵉⵍⵉⵎ ⵜⴼⴻⵜⵜⵏⴻⵎ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴼⵉⵖⵔⴰⵏ ⵓ ⵖⴻⴼⴼⵍⴻⵎ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴷⴱⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_17","070_10_17","MAT","10","17","17","ⵎⴰⵛⴰ ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_18","070_10_18","MAT","10","18","18","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴻⴷⵀⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵣⵣⴰⵜ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MT10_19","070_10_19","MAT","10","19","19","ⵎⴰⵍⴰ ⵙⴻⵍⵍⵎⴻⵏ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵛⴰ ⵙ ⵡⴻⵎⵏⵓⵙ ⵎⴰⵎⵎⴻⵛ ⴷ ⵎⵉⵏ ⵖⴰ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MT10_20","070_10_20","MAT","10","20","20","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵎⴰⵛⴰ ⴷ ⴰⵔⵔⵓⵃ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴷⴰⵢⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_21","070_10_21","MAT","10","21","21","ⵓⵎⴰⵙ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵓⵎⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵡⴰⵏⴻⵖ ⵓ ⴱⴰⴱⴰⵙ ⵎⵎⵉⵙ, ⵓⵛⴰ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵜⴰⵔⵡⴰ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_22","070_10_22","MAT","10","22","22","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵛⴰⵔⵀⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵚⴱⴰⵔⴻⵏ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT10_23","070_10_23","MAT","10","23","23","ⵎⴰⵍⴰ ⴷⴰⵔⵔⵛⴻⵏ ⵅⴰⵡⴻⵎ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ, ⴰⵔⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴽⴽⴻⵎ ⵛⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT10_24","070_10_24","MAT","10","24","24","“ⵡⴰⵔ ⵉⴵⵉ ⵓⵎⴻⵃⴹⴰⵔ ⵢⵓⵄⵍⴰ ⵅ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵅ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT10_25","070_10_25","MAT","10","25","25","ⵉⴽⴼⴰ ⵉ ⵓⵎⴻⵃⴹⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵙ ⵓ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎ ⴱⴰⴱ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵍⴰⵖⴰⵏ ⴰⵙ ⵉ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ‘ⴱᵉⵄⴰⵍⵣⴰⴱⵓⵍ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵉⴱⵍⵉⵙ’, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ! ");
INSERT INTO rift_vpl VALUES ("MT10_26","070_10_26","MAT","10","26","26","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ. ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⴷⵍⵉⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⵉ, ⵓⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵙⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT10_27","070_10_27","MAT","10","27","27","“ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵉⵏⵉⵎ ⵜ ⴷⵉ ⵜⴼⴰⵡⵜ, ⵎⵉⵏ ⵜⴻⵙⵍⵉⵎ, ⵇⵇⴰⵔⴻⵏ ⵜ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ, ⴱⴰⵔⵔⵃⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵅ ⵜⵣⴻⵖⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_28","070_10_28","MAT","10","28","28","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵏⵖⴻⵏ ⵍⴻⵄⵎⴰⵔ. ⴳⴳⵯⴻⴷⴻⵎ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⵍⴻⵄⵎⴰⵔ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("MT10_29","070_10_29","MAT","10","29","29","ⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵏⵣⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵥⵥⴰⵡⴻⵛ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵚⵓⵍⴷⵉ ⵏ ⵏⵏⵃⴰⵙ? ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵡⴻⵟⵟⵉ ⵛⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴱⵍⴰ ⴱⴰⴱⴰⵜⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT10_30","070_10_30","MAT","10","30","30","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵥⵓⵟⵟⴰⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵡⴻⵎ ⵜⵜⵡⴰⵃⴻⵙⵙⴱⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT10_31","070_10_31","MAT","10","31","31","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵄⴷⵓⵎ ⵥⵥⴰⵡⴻⵛ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT10_32","070_10_32","MAT","10","32","32","ⵙ ⵓⵢⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵉⵛⴻⵀⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⴻⵀⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_33","070_10_33","MAT","10","33","33","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵏⴽⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵏⴽⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT10_34","070_10_34","MAT","10","34","34","“ⵡⴰⵔ ⵜⵜⵖⵉⵍⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵖ ⵍⴻⵀⵏⴰ ⵉ ⴷⴷⵓⵏⴻⵛⵜ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵖ ⵍⴻⵀⵏⴰ, ⵎⴰⵛⴰ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("MT10_35","070_10_35","MAT","10","35","35","ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴱⴹⵉⵖ ⴰⵔⵢⴰⵣ ⵅ ⴱⴰⴱⴰⵙ, ⴷ ⵢⴻⴵⵉⵙ ⵅ ⵢⴻⵎⵎⴰⵙ, ⴷ ⵜⴻⵙⵍⵉⵜ ⵅ ⵍⴰⵍⵍⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT10_36","070_10_36","MAT","10","36","36","ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT10_37","070_10_37","MAT","10","37","37","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⴷ ⵢⴻⵎⵎⴰⵙ ⵅⴰⴼⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⴷⵉⵀⴻⴵ ⵛⴰ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵎⵎⵉⵙ ⵏⵉⵖ ⴷ ⵢⴻⴵⵉⵙ ⵅⴰⴼⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⴷⵉⵀⴻⴵ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT10_38","070_10_38","MAT","10","38","38","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉⵏ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴹⴼⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⴷⵉⵀⴻⴵ ⵛⴰ.    ");
INSERT INTO rift_vpl VALUES ("MT10_39","070_10_39","MAT","10","39","39","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴼⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⵉⵅⵙⴰⵔ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⵙⴰⵔⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⴰⴷ ⵜⵜ ⵢⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("MT10_40","070_10_40","MAT","10","40","40","ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ, ⵉⵇⴻⴱⴱⴻⵍ ⴰⵢⵉ, ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ, ⵉⵇⴻⴱⴱⴻⵍ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT10_41","070_10_41","MAT","10","41","41","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ ⴰⵏⴰⴱⵉ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵏⴰⴱⵉ, ⴰⴷ ⵉⵟⵟⴻⴼ ⵍⵎⵓⵏⴻⵜ ⵏ ⵓⵏⴰⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ ⴰⵎⵙⴻⴳⴳⴰⴷ ⵙ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⴰⴷ ⵉⵟⵟⴻⴼ ⵍⵎⵓⵏⴻⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("MT10_42","070_10_42","MAT","10","42","42","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⴰ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⴷ ⴰⵙⴻⵎⵎⴰⴹ, ⵎⵖⵉⵔ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵉⵏⵓ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜᵉⵜⵜⵔⵉⵃ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("MT11_1","070_11_1","MAT","11","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⴰⵙⵓⵄ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵙ ⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ ⵙⵙⴻⵏⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵓ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT11_2","070_11_2","MAT","11","2","2","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⵜⵜⴻⵙⵍⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵅ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵉⵙⵙⴻⴽⴽ ⵛⴰ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT11_3","070_11_3","MAT","11","3","3","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⴷ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵏⵉⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵔⴰⵊⴰ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("MT11_4","070_11_4","MAT","11","4","4","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵜⵄⴰⵡⴷⴻⵎ ⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵎⵉⵏ ⵜⴻⵙⵍⴰⵎ ⴷ ⵎⵉⵏ ⵜⴻⵥⵔⵉⵎ! ");
INSERT INTO rift_vpl VALUES ("MT11_5","070_11_5","MAT","11","5","5","ⴰⵇⴰ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵜⵜⵡⴰⵍⴰⵏ, ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴳⴳⵓⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ ⵜⵜⵡⴰⵙⵙⵉⵣⴷⵉⴳⴻⵏ, ⵉⴷⴻⵀⵛⴰⵔ ⴷⴻⵡⵍⴻⵏ ⵜⵜⴻⵙⵍⴰⵏ, ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⵓ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴰⵃ ⵉ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("MT11_6","070_11_6","MAT","11","6","6","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵜⵜⴻⵏⴷⵔⵉⴼⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT11_7","070_11_7","MAT","11","7","7","ⵍⴰⵎⵉ ⵓⵢⵓⵔⴻⵏ ⵉⵏⴰ, ⵉⴱⴷⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵍⵖⴰⵛⵉ ⵅ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰⵔ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⵎ? ⵎⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵉⵙⵙⴻⵏⵀⴻⵣⵣⴰ ⵜ ⵓⵙⴻⵎⵎⵉⴹ? ");
INSERT INTO rift_vpl VALUES ("MT11_8","070_11_8","MAT","11","8","8","ⵎⴰⵍⴰ ⵍⵍⴰ, ⵎⵉⵏ ⵖⴰⵔ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⵎ? ⵎⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙ ⵡⴰⵔⵔⵓⴹ ⵢⴰⵔⴹⴻⴱ? ⵅⵣⴰⵔ, ⵉⵏⵏⵉ ⵢⴰⵔⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵉⵖⵍⴰⵏ ⵢⴰⵔⴹⴻⴱ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("MT11_9","070_11_9","MAT","11","9","9","ⵎⵉⵏ ⵖⴰⵔ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵅⴻⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⵎ? ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ? ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵄⴰⴷ ⵅ ⵓⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT11_10","070_11_10","MAT","11","10","10","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴷ ⵡⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵔⵉ ⵡⴰⵡⴰⵍ-ⴰ: ‘ⵅⵥⴰⵔ, ⴰⴷ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵣⵣⴰⵜⴻⴽ.’ ");
INSERT INTO rift_vpl VALUES ("MT11_11","070_11_11","MAT","11","11","11","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵊⴰⵔ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵡⴰⵔ ⴷⴷ-ⵉⴼⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⵎⴻⵥⵢⴰⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT11_12","070_11_12","MAT","11","12","12","ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ ⴰⵍ ⵉⴹⴰ ⵜⴻⵎⵎⴰⵔⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵍⵄⵓⵏⴼ, ⵓⵛⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵍⴻⵅⵛⵓⵏⴻⵜ ⴰⵔⴻⵣⵣⵓⵏ ⵜⵜᵉⵟⵟⴼⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("MT11_13","070_11_13","MAT","11","13","13","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⴰⵏ ⴰⵍ ⴷⴷ-ⵢⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MT11_14","070_11_14","MAT","11","14","14","ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ, ⵇⴻⴱⵍⴻⵎ ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⴷ ⵉⵍⵉⵢⴰ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT11_15","070_11_15","MAT","11","15","15","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MT11_16","070_11_16","MAT","11","16","16","“ⵡⵉ ⴰⴽ-ⴷ ⵉ ⵖⴰ ⵙⵙⴻⵎⵇⵓⴷⴷⴻⵖ ⵊⵊⵉⵍ-ⴰ? ⴰⵇⴰ-ⵜ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵍⴻⵙⵡⴰⵇ ⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT11_17","070_11_17","MAT","11","17","17","ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵇⴰ ⵏⵖⴻⵏⵏⴻⵊ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵛⴹⵉⵃⴻⵎ. ⴰⵇⴰ ⵏⴻⵡⵜⴰ ⴰⵡⴻⵎ ⴰⴳⴻⵊⴷⵓⵔ, ⵡⴰⵔ ⵜⴻⵛⴹⵉⵏⴻⵎ.’ ");
INSERT INTO rift_vpl VALUES ("MT11_18","070_11_18","MAT","11","18","18","ⵎⴰⵖⴰⵔ ⵢⵓⵙⴰ-ⴷⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ, ⵡⴰⵔ ⵉⵙⴻⵙⵙ, ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ: ‘ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("MT11_19","070_11_19","MAT","11","19","19","ⴰⵇⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⵜⵜᵉⵜⵜ, ⵉⵙⴻⵙⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵇⴰ ⴷⵉⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵍⵀⴻⴼ ⵅ ⵎⴰⵛⵛⴰ ⴷ ⴱⵉⵏⵓ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ!’ ⵎⴰⵛⴰ ⵜⵉⵖⵉⵜ ⵜᵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT11_20","070_11_20","MAT","11","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵉⵜⵜⵡⴻⴱⴱⴻⵅ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵉ ⴷⵉ ⵉⴳⴳⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⵡⴰⵔ ⵜⵓⴱⴻⵏⵜ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT11_21","070_11_21","MAT","11","21","21","“ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⵅⵓⵔⴰⵣⵉⵏ, ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ! ⵎⵍⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⴷⵉ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉⵊⴻⵀⴷⴻⵏ ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴰⵢⴽⴻⵏⵜ, ⵉⵍⵉ ⴰⵇⴰ ⵜⵓⴱⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵙ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵢⵉⵖⵖⴻⴹ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT11_22","070_11_22","MAT","11","22","22","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴰⵍ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ ⵉⵀⵡⴻⵏ ⵣⵉ ⵍⵃⴰⵍ ⵏⵡⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MT11_23","070_11_23","MAT","11","23","23","ⵉ ⵛⴻⵎ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⴰⵍ ⴰⵊⴻⵏⵏⴰ? ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ ⵉ ⵖⴰⵔ ⴷⴷ ⵖⴰ ⵜⴻⵀⵡⵉⴷ. ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⴷⵉ ⵙⴰⴷⵓⵎ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉⵊⴻⵀⴷⴻⵏ ⵉ ⴷⴰⵢⴻⵎ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵉⵍⵉ ⴰⵇⴰ ⵜⴻⵇⵇⵉⵎ ⴰⵍ ⴰⵙⵙ ⵏ ⵢⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("MT11_24","070_11_24","MAT","11","24","24","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵎ ⵉⵏⵉⵖ, ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴰⵍ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⴰⴷⵓⵎ ⵉⵀⵡⴻⵏ ⵣⵉ ⵍⵃⴰⵍ ⵏⵏⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT11_25","070_11_25","MAT","11","25","25","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⴱⴷⴰ ⵢⴰⵙⵓⵄ ⴰⴷ ⵢⵉⵏⵉ: “ⵃⴻⵎⴷⴻⵖ ⵛⴻⴽ ⴰ ⴱⴰⴱⴰ, ⵙⵉⴷⵉ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⴰⵢⴰ ⵅ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵉⵎⵓⵙⵏⴰⵡⴻⵏ, ⵎⴰⵛⴰ ⵜⴻⵙⵙⴰⵔⴻⴳⴱⴻⴷ ⴰⵢⴰ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT11_26","070_11_26","MAT","11","26","26","ⵡⴰⵀ, ⴰ ⴱⴰⴱⴰ, ⵎⵉⵏⵣⵉ ⴷ ⵡⴰ ⴷ ⴰⵔⴹⴰ ⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("MT11_27","070_11_27","MAT","11","27","27","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵎⵎⴻⵡⵛ ⴰⵢⵉ-ⴷⴷ ⵣⵉ ⴱⴰⴱⴰ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵎⵉⵙ ⵎⵖⵉⵔ ⴱⴰⴱⴰⵙ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⴱⴰⴱⴰⵙ ⵎⵖⵉⵔ ⵎⵎⵉⵙ ⵓ ⵡⵉ ⵓⵎⵉ ⵉⵅⵙ ⵎⵎⵉⵙ ⴰⴷ ⵜ ⵉⵙⵙⴰⵔⴳⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT11_28","070_11_28","MAT","11","28","28","“ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵢⵓⵃⵍⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴱⵓⵏ ⴷⴷⵇⴻⵍ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⴰⵔⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("MT11_29","070_11_29","MAT","11","29","29","ⴽⵙⵉⵎ-ⴷⴷ ⴰⵣⴰⵢⵍⵓ ⵉⵏⵓ ⵅⴰⵡⴻⵎ, ⵍⴻⵎⴷⴻⵎ ⵣⵣⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⵎⵀⵉⵏ ⴷ ⴰⵎⵡⴰⴹⴻⵄ ⵏ ⵡⵓⵍ ⵓⵛⴰ ⴰⴷ ⵜⴰⴼⴻⵎ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT11_30","070_11_30","MAT","11","30","30","ⵎⵉⵏⵣⵉ ⴰⵣⴰⵢⵍⵓ ⴷ ⵍⴻⵃⵎⴻⵍ ⵉⵏⵓ ⴼⵙⵓⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT12_1","070_12_1","MAT","12","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵛⵓⵇ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷⵉ ⵙⵙⴻⴱⵜ. ⵜⵓⵖⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴵⵓⵥⴻⵏ ⵓⵛⴰ ⴱⴷⴰⵏ ⵍⴻⵇⵇⴹⴻⵏ ⵜⵉⴷⵔⵉⵏ, ⵛⵛⵉⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT12_2","070_12_2","MAT","12","2","2","ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵥⵔⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵍⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ!” ");
INSERT INTO rift_vpl VALUES ("MT12_3","070_12_3","MAT","12","3","3","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵍⵉⵎ ⵛⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ ⵓⵎⵉ ⵉⴵⵓⵥ ⵏⴻⵜⵜⴰ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MT12_4","070_12_4","MAT","12","4","4","ⵎⴰⵎⵎⴻⵛ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵛⵛⴰ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵣⵉ ⵜⵣⴻⵡⴹⴰ ⵏ ⵙⵉⴷⵉ ⵉ ⵡⴰⵔ ⵉⵃⴻⴵⵍⴻⵏ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵉ ⵏⴻⵜⵜⴰ ⵓⵍⴰ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("MT12_5","070_12_5","MAT","12","5","5","ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵛⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴱⴻⵍⵍⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵅⴻⵟⵟⴰⵏ ⴷⵉ ⵜⴻⵡⵚⵉⵢⵢⴻⵜ ⵏ ⵙⵙⴻⴱⵜ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⴱⵉⵏ ⵍⵄⵉⴱ? ");
INSERT INTO rift_vpl VALUES ("MT12_6","070_12_6","MAT","12","6","6","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴰⵇⴰ-ⵜ ⴷⴰⵏⵉⵜⴰ! ");
INSERT INTO rift_vpl VALUES ("MT12_7","070_12_7","MAT","12","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴼⴻⵀⵎⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵃⴰⵙⴰⴱⴻⵎ ⵛⴰ ⵅ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT12_8","070_12_8","MAT","12","8","8","ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴱⴰⴱ ⵏ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT12_9","070_12_9","MAT","12","9","9","ⵢⴰⵙⵓⵄ ⵢⵓⵢⵓⵔ ⵙⵙⴻⵏⵏⵉ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_10","070_12_10","MAT","12","10","10","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵓⵛⵛⴻⵃ. ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵎⴰⵃⴻⵏⴷ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⴻⵜⵜⵛⴰⵏ, ⵏⵏⴰⵏ: “ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵓⵙⴳⴻⵏⴼⵉ ⴷⵉ ⵙⵙⴻⴱⵜ?” ");
INSERT INTO rift_vpl VALUES ("MT12_11","070_12_11","MAT","12","11","11","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⴷⵉⵏⵏⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵣⵎⴰⵔ ⵉ ⵉⵡⴹⴰⵏ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵟⵟⴻⴼ, ⵃⵉⵎⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("MT12_12","070_12_12","MAT","12","12","12","ⵎⴻⵛⵃⴰⵍ ⵉⵄⴷⵓ ⴱⵏⴰⴷⴻⵎ ⵅ ⵉⵣⵎⴰⵔ! ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT12_13","070_12_13","MAT","12","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ!” ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⴳⴳⴻⵏⴼⴰ ⴰⵎ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT12_14","070_12_14","MAT","12","14","14","ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵎⵛⴰⵡⴰⵔⴻⵏ ⵅⴰⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_15","070_12_15","MAT","12","15","15","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵏ ⴰⵢⴰ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵙⵙⴻⵏⵏⵉ. ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT12_16","070_12_16","MAT","12","16","16","ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵅⴰⵙ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵍⴻⵅⴱⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("MT12_17","070_12_17","MAT","12","17","17","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("MT12_18","070_12_18","MAT","12","18","18","“ⵅⵣⴰⵔ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⴼⴰⵔⵔⵣⴻⵖ, ⴰⵎⵄⵉⵣⵣ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵉⵏⵓ. ⴰⴷ ⵅⴰⵙ ⵙⵙⴰⵔⵙⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵍⵃⵓⴽⵎ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MT12_19","070_12_19","MAT","12","19","19","ⵡⴰⵔ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛ, ⵡⴰⵔ ⵉⵙⵖⵓⵢⵢⵓ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_20","070_12_20","MAT","12","20","20","ⴰⵖⴰⵏⵉⵎ ⵢⴰⵔⵥⴻⵏ ⵡⴰⵔ ⵜ ⵢⴰⵔⴻⵥⵥⵉ, ⵓⵍⴰ ⴷ ⵜⴰⴼⵜⵉⵍⵜ ⵉⴷⴷⵓⵅⵅⵓⵏⴻⵏ, ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵅⴻⵙⵙⵉ ⴰⵍ ⴷⴷ ⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⴻⵃⴽⴰⵎ ⵉ ⵖⴰ ⵉⵏⴻⴷⵀⴻⵏ ⵉ ⵓⵖⴻⵍⵍⴻⴱ, ");
INSERT INTO rift_vpl VALUES ("MT12_21","070_12_21","MAT","12","21","21","ⵓⵛⴰ ⴰⴷ ⵙⵙⵉⵜⵎⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT12_22","070_12_22","MAT","12","22","22","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵔⵢⴰⵃ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⴷ ⴰⵢⵏⴰⵡ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜ, ⴰⵍⴰⵎⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴷ ⴰⵢⵏⴰⵡ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⵉⴷⵡⴻⵍ ⵉⵙⵙⴰⵡⴰⵍ ⵓ ⵉⵜⵜⵡⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MT12_23","070_12_23","MAT","12","23","23","ⵉⵜⴻⴱⵀⴻⵜ ⵍⵖⴰⵛⵉ ⵎⴰⵔⵔⴰ, ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵏⵉⵜⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ?” ");
INSERT INTO rift_vpl VALUES ("MT12_24","070_12_24","MAT","12","24","24","ⵎⴰⵛⴰ ⵙⵍⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵎⵖⵉⵔ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⴱᵉⵄⴰⵍⵣⴰⴱⵓⴱ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵛⵛⵡⴰⵟⴻⵏ.”    ");
INSERT INTO rift_vpl VALUES ("MT12_25","070_12_25","MAT","12","25","25","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⵓⵍ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉⵜⵜⴻⵎⵙⴻⴱⴹⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ, ⵓ ⴽⵓⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵉⵖ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵜⵜⴻⵎⵙⴻⴱⴹⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT12_26","070_12_26","MAT","12","26","26","ⵎⴰⵍⴰ ⴰⵇⴰ-ⵜ ⴷ ⵛⵛⵉⵟⴰⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵉⵟⴰⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵎⵙⴻⴱⴹⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MT12_27","070_12_27","MAT","12","27","27","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⴱᵉⵄⴰⵍⵣⴰⴱⵓⴱ, ⵙ ⵎⵉⵏ ⵣⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ? ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⵇⵓⴹⴰⵜ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT12_28","070_12_28","MAT","12","28","28","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜⵓⴷⴻⵙ ⴰⵡⴻⵎ-ⴷⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT12_29","070_12_29","MAT","12","29","29","ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵛⴰⵔⴼ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵎⴻⵣⵡⴰⵔ? ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT12_30","070_12_30","MAT","12","30","30","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴰⴽⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴹⵉⴷⴷ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⵙⵙⵎⵓⵏⴰⵏ, ⴰⵇⴰ ⵉⵜⵜⵣⴻⴵⴰⵄ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("MT12_31","070_12_31","MAT","12","31","31","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⴷ ⵓⵛⴻⵇⵇⴻⴼ ⴰⴷ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵉ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⴰⵛⴻⵇⵇⴻⴼ ⴷⵉ ⴰⵔⵔⵓⵃ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵛⴰ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_32","070_12_32","MAT","12","32","32","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵉⵏ ⴰⵡⴰⵍ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵅ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵉⵏ ⴰⵡⴰⵍ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵅ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵛⴰ, ⵓⵍⴰ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⵓⵍⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_33","070_12_33","MAT","12","33","33","ⵃⴻⵙⴱⴻⵎ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵓⵍⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⵏⵉⵖ ⵃⴻⵙⴱⴻⵎ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵅⵙⴰⵔ ⵓⵍⴰ ⴷ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵅⵙⴰⵔ, ⵎⵉⵏⵣⵉ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ.”    ");
INSERT INTO rift_vpl VALUES ("MT12_34","070_12_34","MAT","12","34","34","“ⴰ ⵜⴰⵔⵡⴰ ⵏ ⵉⴼⵉⵖⵔⴰⵏ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵅ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵓⵄⴻⵎⵎⴰⵔ ⵏ ⵡⵓⵍ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵇⴻⵎⵎⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("MT12_35","070_12_35","MAT","12","35","35","ⴱⵏⴰⴷⴻⵎ ⴰⵚⴻⴱⵃⴰⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ-ⴷⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵣⵉ ⵍⴽⴻⵏⵣ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⴱⵏⴰⴷⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ-ⴷⴷ ⵣⵉ ⵍⴽⴻⵏⵣ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵏⴻⵙ ⵎⵉⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_36","070_12_36","MAT","12","36","36","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⴰⵡⴰⵍ ⵉⵅⵡⴰⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ ⵉⵡⴷⴰⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵃⴰⵙⴱⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MT12_37","070_12_37","MAT","12","37","37","ⵎⵉⵏⵣⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⴷ ⵓⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴰⵙⴱⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT12_38","070_12_38","MAT","12","38","38","ⵛⴰ ⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵏⵥⴰⵔ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵣⵣⴰⵢⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("MT12_39","070_12_39","MAT","12","39","39","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵊⵊⵉⵍ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵣⴻⵏⵏⴰⵏ ⵉⵜⵜⴻⵜⵜⴰⵔ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵎⴻⵡⵛⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵎⵖⵉⵔ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵢⵓⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MT12_40","070_12_40","MAT","12","40","40","ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵏⵓⵙ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵊⴰⵔ ⴵⵢⴰⵍⵉ ⴷ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵡⴻⵙⵍⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵊⴰⵔ ⴵⵢⴰⵍⵉ ⴷ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_41","070_12_41","MAT","12","41","41","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵏⵉⵏⵡⴰ ⴰⴷ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ ⴰⴽ-ⴷ ⵊⵊⵉⵍ-ⴰ, ⴰⴷ ⵜ ⵃⴰⵙⴱⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⴱⴻⵏ ⵙ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵢⵓⵏⵓⵙ, ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴷⴰ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵢⵓⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("MT12_42","070_12_42","MAT","12","42","42","ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ ⴰⴽ-ⴷ ⵊⵊⵉⵍ-ⴰ, ⴰⴷ ⵅⴰⵙ ⵜⴻⵃⴽⴻⵎ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⵍ ⵉ ⵜⵉⵖⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ, ⵓⵛⴰ ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴷⴰ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵙⵓⵍⵉⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT12_43","070_12_43","MAT","12","43","43","“ⴰⵍⴰⵎⵉ ⵉⴼⴼⴻⵖ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ ⵣⵉ ⴱⵏⴰⴷⴻⵎ, ⵉⴱⴷⴰ ⵉⵜⵜⵙⴰⵔⴰ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⴱⵓ ⵡⴰⵎⴰⵏ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⵔⵔⴰⵃⴻⵜ, ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("MT12_44","070_12_44","MAT","12","44","44","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵎⴰⵏⵉⵙ ⴷⴷ-ⴼⴼⵖⴻⵖ!’ ⵓⵛⴰ ⵉⵔⵓⵃ, ⵢⵓⴼⴰ ⵉ-ⵜⵜ ⵜⴻⵅⵡⴰ, ⵜⴼⴰⵔⴹ, ⵜⵙⴻⵜⵜⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("MT12_45","070_12_45","MAT","12","45","45","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵍⴰⵔⵢⴰⵃ ⵏⵏⴻⵖⵏⵉ, ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴽⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ, ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ, ⴰⴷ ⵔⴰⵃⴻⵏ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⴰⵢⴻⵙ, ⵓⵛⴰ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⵎⴰⵀⵓ ⵅ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵊⵊⵉⵍ-ⴰ ⴰⵄⴻⴼⴼⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT12_46","070_12_46","MAT","12","46","46","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵍⵖⴰⵛⵉ, ⵅⵣⴰⵔ, ⵢⴻⵎⵎⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ ⴱⴻⴷⴷⴻⵏ ⴱⴰⵔⵔⴰ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴽⵉⴷⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT12_47","070_12_47","MAT","12","47","47","ⵉⵏⵏⴰ ⴰⵙ ⵉⵊⵊⴻⵏ: “ⵅⵣⴰⵔ, ⵢⴻⵎⵎⴰⵛ ⴷ ⴰⵢⵜⵎⴰⵛ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⴱⴰⵔⵔⴰ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴽⵉⴷⴻⴽ ⵙⵙⵉⵡⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT12_48","070_12_48","MAT","12","48","48","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵜ ⵉⵏⵏⴰⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵢⴻⵎⵎⴰ ⴷ ⵎⵉⵏ ⵄⵏⴰⵏ ⴰⵢⵜⵎⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT12_49","070_12_49","MAT","12","49","49","ⵅⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵢⴻⵎⵎⴰ, ⵅⵣⴰⵔ, ⴰⵢⵜⵎⴰ! ");
INSERT INTO rift_vpl VALUES ("MT12_50","070_12_50","MAT","12","50","50","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰ ⴷ ⵓⵍⵜⵎⴰ ⴷ ⵢⴻⵎⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT13_1","070_13_1","MAT","13","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵔⵓⵃ ⵉⵇⵇⵉⵎ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT13_2","070_13_2","MAT","13","2","2","ⵉⵎⵓⵏ-ⴷⴷ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵓⵀⵉⵎⵓⵔ ⵏ ⵍⵖⴰⵛⵉ, ⴰⵍⴰⵎⵉ ⵢⴻⵏⵢⴰ ⴷⵉ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵉⵇⵇⵉⵎ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵍⵖⴰⵛⵉ ⵎⴰⵔⵔⴰ ⴱⴻⴷⴷⴻⵏ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT13_3","070_13_3","MAT","13","3","3","ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵙ ⵉⵎⴻⴷⵢⴰ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⴼⴻⴵⴰⵃ ⵉⴼⴼⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴰⵔⵄ. ");
INSERT INTO rift_vpl VALUES ("MT13_4","070_13_4","MAT","13","4","4","ⴰⵎ ⵜⵓⵖⴰ ⵉⵣⴰⵔⵔⴻⵄ, ⵜⴻⵡⴹⴰ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵅ ⵜⵎⴰ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵅⴻⵛⵛⴻⵏ-ⴷⴷ ⵉⵊⴹⴰⴹ, ⵏⴻⵇⴱⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("MT13_5","070_13_5","MAT","13","5","5","ⵜⴻⵡⴹⴰ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵥⵔⵓ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴵⵉ ⵓⵛⴰⵍ ⴰⵟⵟⴰⵙ. ⴷⴻⵖⵢⴰ ⵜⴻⵖⵎⵉ-ⴷⴷ ⵙ ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⵓⴵⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("MT13_6","070_13_6","MAT","13","6","6","ⵓⵎⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵉⵛⵎⴻⴹ ⵓⵖⴻⵎⵎⵓⵢ, ⵓⵛⴰ ⵉⵙⵍⴰⵡ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⴱⵓ ⵡⴻⵥⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT13_7","070_13_7","MAT","13","7","7","ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵜⴻⵡⴹⴰ ⵅ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ⵎⵖⴰⵔⴻⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵊⵉⵢⵢⴼⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("MT13_8","070_13_8","MAT","13","8","8","ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵜⴻⵡⴹⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⵜⵉⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⵛⴰ ⵎⵢⴰ, ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵙⴻⵜⵜⵉⵏ, ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵜⵍⴰⵜⵉⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT13_9","070_13_9","MAT","13","9","9","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MT13_10","070_13_10","MAT","13","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵙ ⵉⵎⴻⴷⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT13_11","070_13_11","MAT","13","11","11","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏⵣⵉ ⵉⵎⵎⴻⵡⵛ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵙⵉⵔⵔ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜ ⵉⵎⵎⴻⵡⵛ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT13_12","070_13_12","MAT","13","12","12","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT13_13","070_13_13","MAT","13","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵉⵎⴻⴷⵢⴰ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵍⴰⵏ ⴰⵎ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵓ ⵜⵜⴻⵙⵍⴰⵏ ⴰⵎ ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ, ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_14","070_13_14","MAT","13","14","14","ⴷⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵉ ⵉⵏⴻⴱⴱⴰ ⵉⵛⴰⵄⵢⴰ, ⵉⵏⵏⴰ: ‘ⵙ ⵓⵙⴻⴵⵉ ⴰⴷ ⵜⴻⵙⵍⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴼⴻⵀⵀⵎⴻⵏ, ⵙ ⵜⵎⵓⵖⵍⵉ ⴰⴷ ⵜⵥⴰⵔⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴼⴻⵜⵜⵏⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT13_15","070_13_15","MAT","13","15","15","ⵎⴰⵖⴰⵔ ⵓⵍ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵇⴰ ⵉⵇⴱⵓⴱⴱⴻⵣ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⴹⴻⵇⵍⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴵⵉ ⵓ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⵇⵇⵏⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵙⵍⴻⵏ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ, ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⴱⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴳⴻⵏⴼⵉⵖ.’ ");
INSERT INTO rift_vpl VALUES ("MT13_16","070_13_16","MAT","13","16","16","ⵎⴰⵛⴰ ⵙⵙⴻⵄⴷ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵓⵎⵉ ⵜⵜⵡⴰⵍⴰⵏⵜ, ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ ⵓⵎⵉ ⵜⵜⴻⵙⵍⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("MT13_17","070_13_17","MAT","13","17","17","ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⵉⵏ ⵜⴻⵥⵔⵉⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵥⵔⵉⵏ, ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵎⵉⵏ ⵜⴻⵙⵍⵉⵎ, ⵡⴰⵔ ⵜ ⵙⵍⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT13_18","070_13_18","MAT","13","18","18","“ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ, ⵙⵍⴻⵎ ⵉ ⵓⵎⴻⴷⵢⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_19","070_13_19","MAT","13","19","19","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵉⴼⵀⵉⵎ, ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⴰⵙ ⵓⵎⵄⴻⴼⴼⴰⵏ, ⴰⴷ ⵉⵅⴹⴻⴼ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵅ ⵜⵎⴰ ⵏ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("MT13_20","070_13_20","MAT","13","20","20","ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵅ ⵡⴻⵥⵔⵓ, ⴰⵇⴰ ⵡⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⴻⴵⴻⵏ ⴰⵡⴰⵍ, ⴰⴷ ⵜ ⵉⵇⴱⴻⵍ ⴷⴻⵖⵢⴰ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("MT13_21","070_13_21","MAT","13","21","21","ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵡⵜⵉ ⵛⴰ ⵡⴻⵥⵡⴰⵔ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵔⵓⵙ ⵡⴰⵀⴰ. ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵉⵖ ⴰⵎⴰⵔⵔⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵡⴰⵍ ⴰⴷ ⵉⵏⵏⴻⴷⵔⴻⴼ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MT13_22","070_13_22","MAT","13","22","22","ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵊⴰⵔ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴰⵇⴰ ⵡⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍ, ⵎⴰⵛⴰ ⴰⵎⵏⵓⵙ ⵏ ⵍⵡⴻⵇⵜ-ⴰ ⴷ ⵓⵖⴻⴽⴽⵡⵉ ⵏ ⵡⴰⴳⵍⴰ ⴰⴷ ⵊⵉⵢⵢⴼⴻⵏ ⴰⵡⴰⵍ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵡⵉ ⵛⴰ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MT13_23","070_13_23","MAT","13","23","23","ⵎⵉⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴰⵇⴰ ⵡⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⴼⵀⴻⵎ, ⴰⴷ ⵢⴰⵔⴱⵓ ⵓ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵅⴻⵏⵏⵉ ⵍⵖⵉⴵⴻⵜ: ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵍⵓ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙⴻⵜⵜⵉⵏ ⵓⵛⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵜⵍⴰⵜⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT13_24","070_13_24","MAT","13","24","24","ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵓⵖⴰ ⵉⵣⴰⵔⵔⴻⵄ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT13_25","070_13_25","MAT","13","25","25","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵡⴷⴰⵏ ⵟⵟⵚⴻⵏ, ⵢⵓⵙⴰ-ⴷⴷ ⵍⴻⵄⴷⵓ ⵏⵏⴻⵙ, ⵉⵣⴰⵔⵄ ⵍⵃⴰⵢⵢⴰⵔ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵢⵉⵔⴷⴻⵏ ⵓⵛⴰ ⵢⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("MT13_26","070_13_26","MAT","13","26","26","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵎⵖⴰⵔ ⵓⵖⴻⵎⵎⵓⵢ ⵓⵛⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵍⵃⴰⵢⵢⴰⵔ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT13_27","070_13_27","MAT","13","27","27","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵏⵏⴰⵏ ⴰⵙ: ‘ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰ ⵡⴰⵔ ⵜⵣⴰⵔⵄⴻⴷ ⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ? ⵎⴰⵏⵉⵙ ⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵅⴻⵏⵏⵉ ⵍⵃⴰⵢⵢⴰⵔ-ⴰ ⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ?’ ");
INSERT INTO rift_vpl VALUES ("MT13_28","070_13_28","MAT","13","28","28","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⴰⵇⴰ ⵍⴻⵄⴷⵓ ⵉⴳⴳⴰ ⵎⴰⵏ ⴰⵢⴰ’. ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ: ‘ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵏⵔⴰⵃ, ⴰⴷ ⵜ ⵏⴻⵢⵔⵓ?’ ");
INSERT INTO rift_vpl VALUES ("MT13_29","070_13_29","MAT","13","29","29","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵍⵍⴰ, ⵃⵉⵎⴰ ⵅⵎⵉ ⵖⴰ ⵜⵢⴰⵔⵔⵡⴻⵎ ⵍⵃⴰⵢⵢⴰⵔ ⵡⴰⵔ ⴽⵉⵙ ⵜⵇⴻⴵⵄⴻⵎ ⵓⵍⴰ ⴷ ⵉⵔⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_30","070_13_30","MAT","13","30","30","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵎⵖⴰⵔⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⴰⵍ ⵜⴰⵎⴻⵢⵔⴰ. ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵜⵎⴻⵢⵔⴰ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ: ‘ⵢⴰⵔⵡⴻⵎ ⴰⵎⴻⵣⵡⴰⵔ ⵍⵃⴰⵢⵢⴰⵔ, ⵛⴻⴷⴷⴻⵎ ⵜ ⴷⵉ ⵜⵇⴻⴱⴱⵉⵟⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵛⵎⴻⴹ, ⵎⴰⵛⴰ ⵉⵔⴷⴻⵏ, ⵢⴰⵔⵡⴻⵎ ⵜ ⴷⵉ ⵍⵎⴰⵔⵙⵉ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("MT13_31","070_13_31","MAT","13","31","31","ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⵅⴻⵔⴷⴻⵍ, ⵢⵉⵡⵢⵉ ⵜⵜ-ⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵣⴰⵔⵄ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT13_32","070_13_32","MAT","13","32","32","ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵇⴰⵄ ⵣⵉ ⵎⴰⵔⵔⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ, ⵅⵎⵉ ⵜⵎⴻⵇⵇⴰⵔ, ⵜᵉⴷⴷⴻⴽⴽⵡⴰⵍ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴱⴱⵉ ⵓⵛⴰ ⵜⴷⴻⴽⴽⵡⴰⵍ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⵢⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵄⵡⴰⵛⵛ ⵏⵙⴻⵏ ⵅ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT13_33","070_13_33","MAT","13","33","33","ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⵡⴻⵏⵜⵓⵏ, ⵜⵉⵡⵢⵉ ⵜ-ⵉ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵎⴷⵓⴷ ⵏ ⵡⴰⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⵙⵙⵎⴻⵎⵎ ⵡⴰⵔⴻⵛⵜⵉ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("MT13_34","070_13_34","MAT","13","34","34","ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵙⵓⵄ ⵉ ⵍⵖⴰⵛⵉ ⵙ ⵉⵎⴻⵜⵜⵉⵍⴻⵏ ⵓⵛⴰ ⴱⵍⴰ ⴰⵎⴻⴷⵢⴰ ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("MT13_35","070_13_35","MAT","13","35","35","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵏⴰⴱⵉ ⵉ ⵉⵏⵏⴰⵏ: “ⴰⴷ ⴰⵔⴻⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵙ ⵉⵎⴻⴷⵢⴰ, ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵙⴰⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT13_36","070_13_36","MAT","13","36","36","ⵍⴰⵎⵉ ⵉⵙⵎⴻⵃ ⵢⴰⵙⵓⵄ ⴷⵉ ⵍⵖⴰⵛⵉ ⴰⴷ ⵓⵢⵓⵔⴻⵏ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ. ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵇⵇⴰⵔⴻⵏ: “ⵉⵏⵉ ⴰⵏⴻⵖ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵓⵎⴻⴷⵢⴰ ⵏ ⵍⵃⴰⵢⵢⴰⵔ ⴷ ⵉⵢⵢⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("MT13_37","070_13_37","MAT","13","37","37","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT13_38","070_13_38","MAT","13","38","38","ⵉⵢⵢⴰⵔ ⴷ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵓⵛⴰ ⵍⵃⴰⵢⵢⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_39","070_13_39","MAT","13","39","39","ⵍⴻⵄⴷⵓ ⵡⴻⵏⵏⵉ ⵜ ⵉⵣⴰⵔⵄⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵛⵛⵉⵟⴰⵏ, ⵓⵛⴰ ⵚⵚⴰⴱⴻⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵇⴻⵟⵟⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵓ ⵉⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("MT13_40","070_13_40","MAT","13","40","40","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⵙⵎⵓⵏⴻⵏ ⵍⵃⴰⵢⵢⴰⵔ ⵓⵛⴰ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵜ ⵙ ⵜⵎⴻⵙⵙⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵖⴰⵔ ⵇⴻⵟⵟⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("MT13_41","070_13_41","MAT","13","41","41","ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵙⵙⵃⴻⵢⵢⴷⴻⵏⵜ ⵣⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵇⴰⵄ ⵜⵉⵄⴻⵏⴽⵍⵉⴼⵉⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_42","070_13_42","MAT","13","42","42","ⴰⴷ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵍⴽⵓⵛⵛⴻⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵎⴰⵏⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT13_43","070_13_43","MAT","13","43","43","ⵅⴻⵏⵏⵉ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⴰⴷ ⴰⵔⵖⴻⵏ ⴰⵎ ⵜⴼⵓⵛⵜ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ. ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MT13_44","070_13_44","MAT","13","44","44","“ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵄⴰⵡⴻⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⴽⴻⵏⵣ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵢⵓⴼⴰ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉ-ⵜ ⵓⵛⴰ ⴷⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ ⵢⵓⵢⵓⵔ, ⵉⵣⵣⴻⵏⵣ ⵇⴰⵄ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵙⵖⴰ ⵉⵢⵢⴰⵔ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT13_45","070_13_45","MAT","13","45","45","“ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵄⴰⵡⴻⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⴻⴱⴱⴰⴱ ⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⵉⵢⴰⵇⵓⵜⵉⵏ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_46","070_13_46","MAT","13","46","46","ⵍⴰⵎⵉ ⵢⵓⴼⴰ ⵉⵛⵜ ⵏ ⵜⵢⴰⵇⵓⵜ ⵜⵉⵖⵍⴰ ⴰⵟⵟⴰⵙ, ⵢⵓⵢⵓⵔ, ⵉⵣⵣⴻⵏⵣ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ, ⵅⴻⵏⵏⵉ ⵉⵙⵖⴰ ⵉ-ⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT13_47","070_13_47","MAT","13","47","47","“ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵄⴰⵡⴻⴷ ⴰⵎ ⵜⵔⴰⵛⵛⴰ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵜⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵜⴻⵢⵔⵓ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⵙⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT13_48","070_13_48","MAT","13","48","48","ⵅⵎⵉ ⵜⴻⵛⵛⵓⵔ, ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⵜ-ⵉ-ⴷⴷ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵇⵇⵉⵎⴻⵏ ⵓⵛⴰ ⴼⴰⵔⵣⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⴷⵉ ⵍⴻⵇⵛⵓⵄ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵏⴹⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT13_49","070_13_49","MAT","13","49","49","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⴷⵉ ⵇⴻⵟⵟⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏⵜ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⴰⴷ ⴼⴰⵔⵏⴻⵏⵜ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT13_50","070_13_50","MAT","13","50","50","ⴰⴷ ⵜⴻⵏ ⵏⴹⴰⵔⴻⵏⵜ ⴷⵉ ⵍⴽⵓⵛⵛⴻⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵎⴰⵏⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT13_51","070_13_51","MAT","13","51","51","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵜⴼⴻⵀⵎⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("MT13_52","070_13_52","MAT","13","52","52","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵓⵢⴰ ⴽⵓⵍ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⵇⴰ ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵣⵉ ⵍⴽⴻⵏⵣ ⵏⵏⴻⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵊⴷⵉⴷ ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵇⴷⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT13_53","070_13_53","MAT","13","53","53","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⴰⵙⵓⵄ ⵉⵎⴻⴷⵢⴰ-ⵢⴰ, ⵢⵓⵢⵓⵔ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT13_54","070_13_54","MAT","13","54","54","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵉⴽⴽⴰⵔ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵇⵇⵉⵎⴻⵏ ⵜⴱⴻⵀⵜⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵏⵉⵙ ⴷ ⴰⵙ ⴷⴷ-ⵜⴻⴽⴽⴰ ⵜⵉⵖⵉⵜ-ⴰ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("MT13_55","070_13_55","MAT","13","55","55","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵓⵏⴻⵊⵊⴰⵔ? ⵎⴰ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵉ ⵢⴻⵎⵎⴰⵙ ⵎⴰⵔⵢⴰⵎ, ⴷ ⴰⵢⵜⵎⴰⵙ ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵇⵇⴰⵔⴻⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⴰⵙⵉ ⴷ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⴰⵀⵓⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("MT13_56","070_13_56","MAT","13","56","56","ⵎⴰ ⵡⴰⵔ ⴵⵉⵏⵜ ⵙⵓⵢᵉⵜⵎⴰⵙ ⵇⴰⵄ ⵖⴰⵔⵏⴻⵖ? ⵎⴰⵏⵉⵙ ⴷ ⴰⵙ ⴷⴷ-ⵉⴽⴽⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT13_57","070_13_57","MAT","13","57","57","ⵓⵛⴰ ⵏⴷⴻⵔⴼⴻⵏ ⵣⵣⴰⵢⴻⵙ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵏⴰⴱⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴵⵉ ⴱⵍⴰ ⵛⵛⴰⵏ, ⵎⵖⵉⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT13_58","070_13_58","MAT","13","58","58","ⵓⵛⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⴷⵉⵀⴰ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴰⵟⵟⴰⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT14_1","070_14_1","MAT","14","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵙⵍⴰ ⵀⵉⵔⵓⴷⵓⵙ, ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵊⵊ ⵏ ⴰⵔⴱⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵍⴻⵅⴱⴰⵔ ⵅ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT14_2","070_14_2","MAT","14","2","2","ⵉⵏⵏⴰ ⵉ ⵢⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵡⴰⵏⵉⵜⴰ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ. ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT14_3","070_14_3","MAT","14","3","3","ⵎⵉⵏⵣⵉ ⵀⵉⵔⵓⴷⵓⵙ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵛⴰⵔⴼ ⵉ-ⵜ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵀⵉⵔⵓⴷⵉⵢⵢⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵡⴻⵏⵏⵉ ⴷ ⵓⵎⴰⵙ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("MT14_4","070_14_4","MAT","14","4","4","ⵎⵉⵏⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⴰⵙ: “ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ ⴰⵇⴰ ⵜⵉⵡⵢⴻⴷ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MT14_5","070_14_5","MAT","14","5","5","ⵙ ⵓⵢⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵏⴻⵖ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵜ ⴷ ⴰⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT14_6","070_14_6","MAT","14","6","6","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵡⴰⵙⵙ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵜⴻⵛⴹⴻⵃ ⵢⴻⴵⵉⵙ ⵏ ⵀⵉⵔⵓⴷⵉⵢⵢⴰ ⵣⵣⴰⵜ ⵉ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵉ ⴷⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵓⵛⴰ ⵜⴻⵄⵊⴻⴱ ⴰⵙ ⵉ ⵀⵉⵔⵓⴷⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MT14_7","070_14_7","MAT","14","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉ ⵖⴰ ⵜᵉⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT14_8","070_14_8","MAT","14","8","8","ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ, ⴰⵎ ⵜⵜ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵔⴻⵏ ⵣⴻⴳ ⵢⴻⵎⵎⴰⵙ, ⵜⴻⵏⵏⴰ: “ⴻⵡⵛ ⴰⵢⵉ ⴷⴰ ⵅ ⵟⵟⴻⴱⵚⵉ ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ!” ");
INSERT INTO rift_vpl VALUES ("MT14_9","070_14_9","MAT","14","9","9","ⵉⵛⴹⴻⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵊⵊⵓⴵ ⵓ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ, ⵢⵓⵎⵓⵔ ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("MT14_10","070_14_10","MAT","14","10","10","ⵉⵙⵙⴻⴽⴽ ⵃⴻⴷ ⵖⴰⵔⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⵙⵙ ⴰⵣⴻⴵⵉⴼ ⵉ ⵢⵓⵃⴰⵏⵏⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT14_11","070_14_11","MAT","14","11","11","ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⴻⴱⵚⵉ, ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵉ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵉⵡⵢⵉ-ⵜ ⵉ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT14_12","070_14_12","MAT","14","12","12","ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴽⵙⵉⵏ ⵍⵅⴻⵛⴱⴻⵜ, ⵏⴻⴹⵍⴻⵏ ⵜⵜ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT14_13","070_14_13","MAT","14","13","13","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⴼⴼⴻⵖ ⵙⵙⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰⵏ, ⵜⵓⵖⴰ-ⵜ ⴷⵉⵏ ⵡⴻⵃⵃⴷⴻⵙ. ⵉⵙⵍⴰ ⵍⵖⴰⵛⵉ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("MT14_14","070_14_14","MAT","14","14","14","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵣⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⵥⵔⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵓⵛⴰ ⵉⵃⵉⵏⵏ ⵅⴰⵙⴻⵏ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉⵎⴻⵀⵍⴰⵛ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT14_15","070_14_15","MAT","14","15","15","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴰⵎⵛⴰⵏ-ⴰ ⵉⵅⵍⴰ ⵓ ⵍⵡⴻⵇⵜ ⵜⴻⵄⴷⵓ. ⵣⴻⵄⵎⴰ ⵙⵇⴻⴱⴱⴻⴹ ⵍⵖⴰⵛⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵍⴻⴷⵛⵓⵔ, ⴰⴷ ⵙⵖⴻⵏ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT14_16","070_14_16","MAT","14","16","16","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⵀⵍⴰ ⵎⴰ ⵔⵓⵃⴻⵏ, ⵡⵛⴻⵎ ⴰⵙⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT14_17","070_14_17","MAT","14","17","17","ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⴷⴰ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT14_18","070_14_18","MAT","14","18","18","ⵉⵏⵏⴰ: “ⴰⵡⵢⴻⵎ ⵜⴻⵏ-ⴷⴷ ⴷⴰ ⵖⴰⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT14_19","070_14_19","MAT","14","19","19","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵍⵖⴰⵛⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵅ ⴰⵔⴱⵉⵄ. ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⴱⴰⵔⴻⴽ, ⵢⴰⵔⵥⴰ ⵉ-ⵜⴻⵏⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⵜⵉⵛⵏⵉⴼⵉⵏ ⵏⵏⵉ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵓ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⵛⵉⵏ ⵜⴻⵏⵜ ⵉ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MT14_20","070_14_20","MAT","14","20","20","ⵎⴰⵔⵔⴰ ⵛⵛⵉⵏ, ⵊⵊⵉⵡⵏⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵉⵛⴻⵟⵟⴻⵏ: ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵄⴻⵎⵎⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT14_21","070_14_21","MAT","14","21","21","ⵉⵏⵏⵉ ⵛⵛⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ ⴰⵍⴻⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴱⵍⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT14_22","070_14_22","MAT","14","22","22","ⴷⴻⵖⵢⴰ ⵉⵣⵉⵢⵢⴰⵔ ⵢⴰⵙⵓⵄ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵏⵢⴻⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ, ⴰⵎ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵏⴻⵜⵜⴰ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MT14_23","070_14_23","MAT","14","23","23","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵍⵖⴰⵛⵉ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵡⴻⵃⵃⴷⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ. ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ, ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT14_24","070_14_24","MAT","14","24","24","ⴰⵖⴰⵔⵔⴰⴱⵓ ⵜⵓⵖⴰ ⵜⵉⴳⴳⵯⴻⵊ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⵉⵀⴰ ⵙ ⵍⴻⵎⵡⴰⵊ, ⵎⵉⵏⵣⵉ ⴰⵙⴻⵎⵎⵉⴹ ⵢⵓⵙⴰ ⴰⵙⴻⵏ-ⴷⴷ ⴷⴻⴳ ⵡⵓⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT14_25","070_14_25","MAT","14","25","25","ⵎⴰⵛⴰ ⴷⴻⴳ ⵃⴻⵟⵟⵓ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⴵⵉⵍⴻⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴰⵎ ⵉⴳⴳⵓⵔ ⵅ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT14_26","070_14_26","MAT","14","26","26","ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⴳⴳⵓⵔ ⵅ ⵡⴰⵎⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵏⵏⵅⴻⵍⵄⴻⵏ, ⵏⵏⴰⵏ: “ⵡⴰ ⴷ ⵍⴻⵡⵃⵉⵢ ⴰⵖⴻⴷⴷⴰⵔ!”, ⵓⵛⴰ ⵙⵖⵓⵢⴻⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("MT14_27","070_14_27","MAT","14","27","27","ⴷⴻⵖⵢⴰ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⴳⴳⴻⵎ ⵓⵍ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("MT14_28","070_14_28","MAT","14","28","28","ⴱⵓⵟⵔⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰⵍⴰ ⴷ ⵛⴻⴽ, ⵡⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⵅ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT14_29","070_14_29","MAT","14","29","29","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵙ-ⴷⴷ!” ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⴱⵓⵟⵔⵓⵙ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵢⵓⵢⵓⵔ ⵅ ⵡⴰⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⴻⴹ ⵖⴰⵔ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT14_30","070_14_30","MAT","14","30","30","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵙⴻⵎⵎⵉⴹ ⵉⵊⵀⴻⴷ, ⵜⴻⵍⵇⴻⴼ ⵉ-ⵜ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵓⵛⴰ, ⴰⵎ ⵉⴱⴷⴰ ⵉⵖⴰⵔⵔⴻⵇ, ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("MT14_31","070_14_31","MAT","14","31","31","ⴷⴻⵖⵢⴰ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵟⵟⴻⴼ ⴷⴰⵢⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵍ’ⵉⵎⴰⵏ, ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰⵢⴻⴽ ⵢⵓⴷⴻⴼ ⵛⵛⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("MT14_32","070_14_32","MAT","14","32","32","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⵢⵉⵏ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵢⴰⵔⵙⴰ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("MT14_33","070_14_33","MAT","14","33","33","ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵙⴻⵊⴷⴻⵏ ⴰⵙ, ⵏⵏⴰⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("MT14_34","070_14_34","MAT","14","34","34","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵥⵡⴰⵏ ⵍⴻⴱⵃⴰⵔ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵏⵏⵉⵙⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MT14_35","070_14_35","MAT","14","35","35","ⵍⴰⵎⵉ ⵜ ⵄⴻⵇⵍⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ, ⵙⵙⵓⴼⴼⵖⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⵛⵓⵔⴰⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵀⴻⵍⵛⴻⵏ ⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("MT14_36","070_14_36","MAT","14","36","36","ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⴷ ⵜⴻⵏ ⵢⴻⵊⵊ ⴰⴷ ⵃⴰⴷⴰⵏ ⵎⵖⵉⵔ ⴰⴱⴻⵃⵍⵓⵍ ⵏ ⵓⵊⴻⴵⴰⴱ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵃⴰⴷⴰⵏ, ⴷⴻⵡⵍⴻⵏ ⴳⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT15_1","070_15_1","MAT","15","1","1","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("MT15_2","070_15_2","MAT","15","2","2","“ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⵄⴻⴷⴷⴰⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵅ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⴻⵖ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵔⵉⴷⴻⵏ ⵛⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("MT15_3","070_15_3","MAT","15","3","3","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⵜᵉⵜⵜⵄⴻⴷⴷⴰⵎ ⵅ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⴱⴱⴰⵔⵜ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MT15_4","070_15_4","MAT","15","4","4","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: ‘ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ!’ ⵓ: ‘ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⵣⴰⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵎⵎⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("MT15_5","070_15_5","MAT","15","5","5","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵢⵉⵏⵉⵏ ⵉ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵉ ⵢⴻⵎⵎⴰⵙ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵉ ⵜⵏⴻⴼⵄⴻⵎ, ⴰⵇⴰ ⴳⴳⵉⵖ ⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⴰⵔⴻⴱⴱⵉ! ⴰⵎⵎⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵃⴷⵉⵊ ⵄⴰⴷ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ ⵙ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ!’ ");
INSERT INTO rift_vpl VALUES ("MT15_6","070_15_6","MAT","15","6","6","ⴰⵎⵎⵓ ⵜⴱⴻⵟⵟⵍⴻⵎ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵓⴱⴱⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT15_7","070_15_7","MAT","15","7","7","ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ! ⵉⵛⴰⵄⵢⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴰⴱⴱⴰ ⵅⴰⵡⴻⵎ ⵙ ⵚⵚⴻⵃ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT15_8","070_15_8","MAT","15","8","8","‘ⵍⴳⴻⵏⵙ-ⴰ ⵉⵜⵜⵛⴻⵏⵏⴻⵄ ⴰⵢⵉ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵓⵍ ⵏⵙⴻⵏ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("MT15_9","070_15_9","MAT","15","9","9","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵛⴻⵏⵏⵄⴻⵏ ⴰⵢⵉ ⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵜⵉⵖⵓⵔⵉⵡⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵉⵡⴷⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("MT15_10","070_15_10","MAT","15","10","10","ⵍⴰⵎⵉ ⴷ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵍⵖⴰⵛⵉ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ ⵎⵍⵉⵃ, ⴼⴻⵀⵎⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("MT15_11","070_15_11","MAT","15","11","11","ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏ ⵉⵜⵜⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵙⵙⴻⵅⵎⴻⵊ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⵙⵙⴻⵅⵎⴰⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT15_12","070_15_12","MAT","15","12","12","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵏⴷⴻⵔⴼⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵍⴰⵎⵉ ⵜ ⵙⵍⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT15_13","070_15_13","MAT","15","13","13","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⵓⵍ ⴰⵖⴻⴷⴷⵓ, ⵡⴰⵔ ⵜ ⵉⵥⵥⵓ ⴱⴰⴱⴰ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⵍⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("MT15_14","070_15_14","MAT","15","14","14","ⴻⵊⵊ ⵉ-ⵜⴻⵏ! ⵏⵉⵜⵏⵉ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵏⴻⴷⴷⵀⴻⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ. ⵎⴰⵍⴰ ⴰⴷⴰⵔⵖⴰⵍ ⵉⵏⴻⴷⴷⴻⵀ ⴰⴷⴰⵔⵖⴰⵍ, ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ.” ");
INSERT INTO rift_vpl VALUES ("MT15_15","070_15_15","MAT","15","15","15","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⴼⴻⵙⵙⴰⵔ ⴰⵏⴻⵖ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("MT15_16","070_15_16","MAT","15","16","16","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⴱⵍⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴰⵍ ⵍⴻⵅⵅⵓ? ");
INSERT INTO rift_vpl VALUES ("MT15_17","070_15_17","MAT","15","17","17","ⵎⴰ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ, ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵓⵄⴻⴷⴷⵉⵙ ⵓⵛⴰ ⵙⵙⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵉ ⵓⵙⵉⵣⴷⴻⴳ? ");
INSERT INTO rift_vpl VALUES ("MT15_18","070_15_18","MAT","15","18","18","ⵎⴰⵛⴰ ⵎⵉⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵣⴻⴳ ⵡⵓⵍ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT15_19","070_15_19","MAT","15","19","19","ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵡⵓⵍ ⵏ ⵉⵡⴷⴰⵏ ⵉ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵣⵣⵉⵏⴰ, ⴰⵏⵖⴰⵢ, ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵜⵓⵛⴻⴼⴼⵔⴰ, ⵛⵛⵀⴰⴷⴰⵜ ⵙ ⵥⵓⵔ ⴷ ⵓⵛⴻⵇⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("MT15_20","070_15_20","MAT","15","20","20","ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵎⴰⵛⵛⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵡⴰⵔ ⵉⵙⵙⵉⵔⴷⴻⵏ ⵡⴰⵔ ⵜⴻⵙⵙⵅⴻⵎⵎⵉⵊ ⵛⴰ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT15_21","070_15_21","MAT","15","21","21","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵙⵙⴻⵏⵏⵉ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MT15_22","070_15_22","MAT","15","22","22","ⵓ ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴽⴻⵏⵄⴰⵏ ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⵉ ⵜⴻⵙⵖⵓⵢ, ⵜⴻⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⴰ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ! ⵢⴻⴵⵉ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵛⵛⵉⵟⴰⵏ ⵉⵙⵙⵏⴻⵅⵍⴰⵄⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT15_23","070_15_23","MAT","15","23","23","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵛⴰ, ⵓⵍⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ. ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵏⵏⴰⵏ: “ⴰⵥⵥⴻⵍ ⵅⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴹⴼⴰⵔ ⴰⵏⴻⵖ-ⴷⴷ ⵙ ⵉⵖⵓⵢⵢⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT15_24","070_15_24","MAT","15","24","24","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵡⵓⴵⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT15_25","070_15_25","MAT","15","25","25","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ, ⵜⴻⵙⵊⴻⴷ ⴰⵙ, ⵜⴻⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵄⴰⵡⴻⵏ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("MT15_26","070_15_26","MAT","15","26","26","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵉⵎⵎⴻⴽⵙⵉ ⵡⴻⵖⵔⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵉ ⵢⵉⵟⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT15_27","070_15_27","MAT","15","27","27","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵉⵟⴰⵏ ⵜⵜᵉⵜⵜⴻⵏ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵉ ⴷⴷ-ⵉⵡⴻⵟⵟⴰⵏ ⵣⵉ ⵟⵟⴰⴱⵍⴰ ⵏ ⵙⵉⴷⵉⵜⵙⴻⵏ ⵓⵛⴰ ⵜⵜⵖⵉⵎⴰⵏ ⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT15_28","070_15_28","MAT","15","28","28","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵎ ⵉⵎⵖⴰⵔ! ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵎ.” ⵓⵛⴰ ⵢⴻⴵⵉⵙ ⵜⴻⴳⴳⴻⵏⴼⴰ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT15_29","070_15_29","MAT","15","29","29","ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵢⴰⵙⵓⵄ ⵙⵙⴻⵏⵏⵉ, ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⵊⴰⵍⵉⵍ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ, ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT15_30","070_15_30","MAT","15","30","30","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵖⴰⵛⵉ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷ ⵉⴳⵏⴰⵡⴻⵏ ⴷ ⵉⵇⴻⵊⴷⴰⵃⴻⵏ ⴷ ⵉⵏⵏⴻⵖⵏⵉ ⴰⵟⵟⴰⵙ, ⵙⵙⴰⵔⵙⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT15_31","070_15_31","MAT","15","31","31","ⴰⵍⴰⵎⵉ ⵉⵜⴻⴱⵀⴻⵜ ⵍⵖⴰⵛⵉ, ⴰⵇⴰ ⵥⵔⵉⵏ ⵉⴳⵏⴰⵡⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⵉⵇⴻⵊⴷⴰⵃⴻⵏ ⴳⴳⴻⵏⴼⴰⵏ, ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴳⴳⵓⵔⴻⵏ, ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵜⵜⵡⴰⵍⴰⵏ, ⵓⵛⴰ ⵙⵙⵄⵓⴵⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT15_32","070_15_32","MAT","15","32","32","ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵃⵉⵏⵏⴻⵖ ⵅ ⵍⵖⴰⵛⵉ ⵎⵉⵏⵣⵉ ⵇⵇⵉⵎⴻⵏ ⴰⴽⵉⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ. ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵇⴻⴱⴱⴹⴻⵖ ⵜⵜⵥⵓⵎⴰⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴹⵄⵉⴼⴻⵏ ⵛⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT15_33","070_15_33","MAT","15","33","33","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰⵏⵉⵙ ⴷ ⵖⴰ ⵏⴰⵡⵉ ⴰⵖⵔⵓⵎ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ ⵉ ⵣⵉ ⵖⴰ ⵏⴻⵙⵙⴻⵛⵛ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⵡⴰⵏⵉⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT15_34","070_15_34","MAT","15","34","34","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴻⵛⵃⴰⵍ ⵖⴰⵔⵡⴻⵎ ⴷ ⴰⵖⵔⵓⵎ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵙⴻⴱⵄⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵛⴰ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT15_35","070_15_35","MAT","15","35","35","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵍⵖⴰⵛⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT15_36","070_15_36","MAT","15","36","36","ⵉⴽⵙⵉ ⵙⴻⴱⵄⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵉⵙⴻⵍⵎⴰⵏ ⵏⵏⵉ, ⵉⵇⴰⴷⴰ, ⵢⴰⵔⵥⴰ ⵉ-ⵜⴻⵏⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⵛⵉⵏ ⵜⴻⵏⵜ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT15_37","070_15_37","MAT","15","37","37","ⵎⴰⵔⵔⴰ ⵛⵛⵉⵏ, ⵊⵊⵉⵡⵏⴻⵏ. ⵅⴻⵏⵏⵉ ⵢⴰⵔⵡⴻⵏ-ⴷⴷ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵉⵛⴻⵟⵟⴻⵏ: ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵄⴻⵎⵎⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT15_38","070_15_38","MAT","15","38","38","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⴰⵔⴻⴱⵄⴰ ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴱⵍⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT15_39","070_15_39","MAT","15","39","39","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵇⴻⴱⴱⴻⴹ ⵍⵖⴰⵛⵉ, ⵉⵏⵢⴰ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵡⴻⵢⵎⵉⵔ ⵏ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵎⴰⴳⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("MT16_1","070_16_1","MAT","16","1","1","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵊⴰⵔⵔⴱⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵛⴻⵏ ⵛⴰ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MT16_2","070_16_2","MAT","16","2","2","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⵇⴰ ⵍⵃⴰⵍ ⵉⴼⴼⴻⵖ!’, ⵎⵉⵏⵣⵉ ⴰⵊⴻⵏⵏⴰ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("MT16_3","070_16_3","MAT","16","3","3","ⵓ ⵖⴰⵔ ⵍⴻⴼⵊⴰⵔ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⴰⴷ ⵉⵙⵓⴹ ⵓⵙⴻⵎⵎⵉⴹ!’, ⵎⵉⵏⵣⵉ ⴰⵊⴻⵏⵏⴰ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ ⴰⵍ ⴰⴱⴰⵔⵛⴰⵏ. ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴰⴷ ⵜⴼⴰⵔⵣⴻⵎ ⵓⴷⴻⵎ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏ ⵣⵣⵎⴰⵏ-ⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵏⵜ ⵜⴼⴰⵔⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT16_4","070_16_4","MAT","16","4","4","ⵊⵊⵉⵍ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵣⴻⵏⵏⴰⵏ ⵢⴰⵔⴻⵣⵣⵓ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜⵎⴻⵡⵛⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵎⵖⵉⵔ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵢⵓⵏⵓⵙ, ⴰⵏⴰⴱⵉ!” ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ, ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("MT16_5","070_16_5","MAT","16","5","5","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵜⵜⵓⵏ ⴰⴷ ⴽⵉⵙⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("MT16_6","070_16_6","MAT","16","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵡⴻⵏⵜⵓⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT16_7","070_16_7","MAT","16","7","7","ⵏⵉⵜⵏⵉ ⵎⵛⴰⵡⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⵏⵉⵡⵉ ⵛⴰ ⴰⵖⵔⵓⵎ!” ");
INSERT INTO rift_vpl VALUES ("MT16_8","070_16_8","MAT","16","8","8","ⵢⴰⵙⵓⵄ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⵉ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵍ’ⵉⵎⴰⵏ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵎⵛⴰⵡⴰⵔⴻⵎ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⴵⴰ ⵓⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵡⵢⴻⵎ ⴰⵖⵔⵓⵎ? ");
INSERT INTO rift_vpl VALUES ("MT16_9","070_16_9","MAT","16","9","9","ⵎⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵛⴰ? ⵎⴰ ⵡⴰⵔ ⵜⴻⵄⵇⵉⵍⴻⵎ ⵛⴰ ⵅ ⵅⴻⵎⵙⴰ ⵏ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ, ⵓ ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵉ ⵜⵢⴰⵔⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MT16_10","070_16_10","MAT","16","10","10","ⵏⵉⵖ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉ ⴰⵔⴻⴱⵄⴰ ⴰⵍⴰⴼ, ⵓ ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵉ ⵜⵢⴰⵔⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MT16_11","070_16_11","MAT","16","11","11","ⵎⴰ ⵄⴰⴷ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵏ ⵛⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵛⴰ ⵅ ⵡⴻⵖⵔⵓⵎ ⵓⵎⵉ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ: ‘ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵡⴻⵏⵜⵓⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ’?” ");
INSERT INTO rift_vpl VALUES ("MT16_12","070_16_12","MAT","16","12","12","ⵙⵙⴻⵏⵏⵉ ⴼⴻⵀⵎⴻⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵃⴹⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵏⵜⵓⵏ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵎⴰⵛⴰ ⵣⵉ ⵜⵖⵓⵔⵉ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT16_13","070_16_13","MAT","16","13","13","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ-ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵉⵙⵙⴻⵇⵙⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ, ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT16_14","070_16_14","MAT","16","14","14","ⵏⵏⴰⵏ ⴰⵙ: “ⵛⴰ ⵇⵇⴰⵔⴻⵏ ‘ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ’, ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ: ‘ⴷ ⵉⵍⵉⵢⴰ’, ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵄⴰⵡⴻⴷ: ‘ⴷ ⵉⵔⵎⵉⵢⴰ’ ⵏⵉⵖ ‘ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ’.” ");
INSERT INTO rift_vpl VALUES ("MT16_15","070_16_15","MAT","16","15","15","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⵎⵉⵏ ⵅⴰⴼⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("MT16_16","070_16_16","MAT","16","16","16","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵏⵏⴰ: “ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT16_17","070_16_17","MAT","16","17","17","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵙⴻⵄⴷ ⵏⵏⴻⵛ, ⴰ ⵛⵉⵎⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵢⵙⵓⵎ ⵏⵉⵖ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⴷ ⴰⵛ ⵉⵎⵍⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⴷ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT16_18","070_16_18","MAT","16","18","18","ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ‘ⴱⵓⵟⵔⵓⵙ’, ⴷ ⴰⵥⵔⵓ, ⵓ ⵅ ⵡⴻⵥⵔⵓ-ⵢⴰ ⴰⴷ ⴱⵏⵉⵖ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵉⵏⵓ ⵓⵛⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴰⵅⴰⵔⵜ ⵡⴰⵔ ⴷ ⴰⵙ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT16_19","070_16_19","MAT","16","19","19","ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵜⵉⵙⴰⵔⵓⵜⵉⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⵛⴻⴷⴷⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵛⴻⴷⴷ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴼⴻⵙⵢⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵉⴼⵙⵉ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT16_20","070_16_20","MAT","16","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵃⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("MT16_21","070_16_21","MAT","16","21","21","ⵙⵙⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵢⴰⵙⵓⵄ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MT16_22","070_16_22","MAT","16","22","22","ⵎⴰⵛⴰ ⴱⵓⵟⵔⵓⵙ ⵢⵉⵡⵢⵉ ⵜ ⵡⴻⵃⵃⴷⴻⵙ, ⵉⴱⴷⴰ ⵉⵜⵜⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ, ⴰ ⵙⵉⴷⵉ! ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("MT16_23","070_16_23","MAT","16","23","23","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵉⵏⵏⴰ ⵉ ⴱⵓⵟⵔⵓⵙ: “ⴼⴼⴻⵖ ⵅⴰⴼⵉ, ⴰ ⵛⵛⵉⵟⴰⵏ, ⵛⴻⴽ ⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⵏⴻⵛⵛ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵛⴻⴽ ⵉⵛⵇⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT16_24","070_16_24","MAT","16","24","24","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⵅⵙ ⴰⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔ, ⴰⴷ ⵉⵏⴽⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴽⵙⵉ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT16_25","070_16_25","MAT","16","25","25","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⵡⴻⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⴰⴷ ⵜⵜ ⵢⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("MT16_26","070_16_26","MAT","16","26","26","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵍⴰ ⵢⴰⵔⴱⴻⵃ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⴷⵔⵓⵛⵜ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ? ⵏⵉⵖ ⵎⵉⵏ ⵖⴰ ⵉⵡⵛ ⴱⵏⴰⴷⴻⵎ ⵉ ⵡⴻⵚⵍⴰⵃ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MT16_27","070_16_27","MAT","16","27","27","ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵓⵄⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("MT16_28","070_16_28","MAT","16","28","28","ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵛⴰ ⵣⴻⴳ ⵉⵏⴰ ⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ, ⵡⴰⵔ ⵜⵜⵇⵉⵙⵉⵏ ⵛⴰ ⵍⵎⴻⵡⵜ ⴰⵍ ⵖⴰ ⵥⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴰⵙ-ⴷⴷ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT17_1","070_17_1","MAT","17","1","1","ⴰⵡⴰⵔⵏⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵢⴰⵙⵓⵄ ⵢⵉⵡⵉ-ⴷⴷ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵓⵎⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ ⴰⴽⵉⴷⴻⵙ, ⵢⵉⵡⵢⵉ ⵉ-ⵜⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MT17_2","070_17_2","MAT","17","2","2","ⵓⵛⴰ ⵉⵜⵜⵡⴰⴱⴻⴷⴷⴻⵍ ⵡⴰⴷⴷⵓⴷ ⵏ ⵢⴰⵙⵓⵄ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ: ⵜⵓⵖⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵉⵜⵜⵛⴻⵄⵛⵉⵄ ⴰⵎ ⵜⴼⵓⵛⵜ, ⵉⴷⵡⴻⵍ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴰⵎ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("MT17_3","070_17_3","MAT","17","3","3","ⵓⵍⴰ ⴷ ⵎⵓⵙⴰ ⴷ ⵉⵍⵉⵢⴰ ⴹⵀⴰⵔⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT17_4","070_17_4","MAT","17","4","4","ⴱⵓⵟⵔⵓⵙ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵢⴰⵙⵓⵄ: “ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵎⵍⵉⵃ ⵓⵎⵉ ⵉ ⴷⴰ ⵏⴻⴵⴰ! ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⴰⴷ ⵏⴻⵡⵡⴻⵜ ⴷⴰⵏⵉⵜⴰ ⵜⵍⴰⵜⴰ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵏ ⵜⵙⴻⵟⵟⴰ, ⵉⵊⵊⴻⵏ ⵉ ⵛⴻⴽ, ⵉⵊⵊⴻⵏ ⵉ ⵎⵓⵙⴰ ⵓ ⵉⵊⵊⴻⵏ ⵉ ⵉⵍⵉⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT17_5","070_17_5","MAT","17","5","5","ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ, ⵉⴽⴽⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⵜⵜⵙⴻⵇⵙⵉⵇ, ⵉⵙⵙⴷⵓⵔⵉⵢ ⵜⴻⵏ ⵙ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵜⴻⵏⵏⴰ: “ⴷ ⵡⴰ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵉⵏⵓ, ⵙⵍⴻⵎ ⵖⴰⵔⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("MT17_6","070_17_6","MAT","17","6","6","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴹⴰⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT17_7","070_17_7","MAT","17","7","7","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵃⴰⴷⴰ ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("MT17_8","070_17_8","MAT","17","8","8","ⵍⴰⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵥⵔⵉⵏ ⵃⴻⴷ ⵎⵖⵉⵔ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT17_9","070_17_9","MAT","17","9","9","ⴰⵎ ⴷⴷ-ⵀⵡⴰⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵎ ⵅ ⵍⴻⵡⵃⵉⵢ-ⴰ ⴰⵎ ⵖⴰⵔⵡⴻⵎ ⵉⴵⴰ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ ⴰⵍ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT17_10","070_17_10","MAT","17","10","10","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴰⵇⴰ ⵉⵍⵉⵢⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ?” ");
INSERT INTO rift_vpl VALUES ("MT17_11","070_17_11","MAT","17","11","11","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵉⵍⵉⵢⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT17_12","070_17_12","MAT","17","12","12","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵅⵣⴰⵔ, ⵉⵍⵉⵢⴰ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵙⵜⴻⵄⵜⴰⵔⵉⴼⴻⵏ, ⵎⴰⵛⴰ ⴳⴳⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵎⵉⵏ ⵅⵙⴻⵏ. ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵡⴻⴷⴷⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT17_13","070_17_13","MAT","17","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴼⴻⵀⵎⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵅ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("MT17_14","070_17_14","MAT","17","14","14","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⵍⵖⴰⵛⵉ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵉⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("MT17_15","070_17_15","MAT","17","15","15","“ⴰ ⵙⵉⴷⵉ, ⵣⵣⵉⴵⴻⵣ ⵉ ⵎⵎⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴱⴰⵔⴽⵉⴽⴽⵉⴹ, ⵉⵎⵎⴰⵔⵏⵉ ⵅⴰⵙ ⵍⵃⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉⵡⴹⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵓ ⴷⴻⴳ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT17_16","070_17_16","MAT","17","16","16","ⵉⵡⵢⴻⵖ ⵜ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵙⵙⴳⴻⵏⴼⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT17_17","070_17_17","MAT","17","17","17","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⴰ ⵊⵊⵉⵍ ⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⴷ ⵉⵎⵓⴼⵔⵉⵖⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵖ ⵄⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵖ ⵚⴱⴰⵔⴻⵖ ⴰⵡⴻⵎ? ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵉ!” ");
INSERT INTO rift_vpl VALUES ("MT17_18","070_17_18","MAT","17","18","18","ⵅⴻⵏⵏⵉ ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ ⵛⵛⵉⵟⴰⵏ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵓⵃⴻⵏⵊⵉⵔ ⵉⴳⴳⴻⵏⴼⴰ ⵣⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT17_19","070_17_19","MAT","17","19","19","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⵙⵙⴳⴻⵏⴼⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT17_20","070_17_20","MAT","17","20","20","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ. ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵍⴰ ⴷⴰⵢⵡⴻⵎ ⵍ’ⵉⵎⴰⵏ ⴰⵏⴻⵛⵜ ⵏ ⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⵅⴻⵔⴷⴻⵍ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ ⵉ ⵡⴻⴷⵔⴰⵔ-ⴰ: ‘ⵎⵓⵟⵟⵉ ⵙⵙⴰ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⵓⵟⵟⵉ, ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("MT17_21","070_17_21","MAT","17","21","21","ⵎⴰⵛⴰ ⴷⴷⴰⵔⴱ-ⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵎⵖⵉⵔ ⵙ ⵜⵥⴰⴵⵉⵜ ⴷ ⵓⵥⵓⵎⵎⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT17_22","070_17_22","MAT","17","22","22","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴰⵔⴰⵏ ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT17_23","070_17_23","MAT","17","23","23","ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ.” ⵅⴻⵏⵏⵉ ⵛⴻⴹⵏⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT17_24","070_17_24","MAT","17","24","24","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ, ⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⴱⵢⴰⵙⵉⵏ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ‘ⵊⵊⵓⵣⵉⵏ’ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉ ⴽⵓⵍ ⵓⵣⴻⴵⵉⴼ ⵉ ⴹⴹⴰⵔⵉⴱⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵖⴰⵔ ⴱⵓⵟⵔⵓⵙ, ⵏⵏⴰⵏ: “ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵡⴻⵎ, ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⴵⵉⵚ ⵜⵏⴰⵢⴻⵏ ⵏ ‘ⵊⵊⵓⵣⵉⵏ’ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ?” ⵉⵏⵏⴰ: “ⵡⴰⵀ, ⴰⴷ ⵜⴻⵏ ⵉⵅⴻⴵⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("MT17_25","070_17_25","MAT","17","25","25","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⴱⵓⵟⵔⵓⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵣⵡⴰⵔ ⴰⵙ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵛⵉⵎⵄⵓⵏ, ⵎⴰⵎⵎⴻⵛ ⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ, ⵡⵉ ⵣⵉ ⵟⵟⴼⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵍⴻⵄⵛⵓⵔ ⴷ ⵜⴻⵏⵄⴰⵛⵉⵏ ⵉ ⵉⵣⴻⵎⵎⴻⵏ ⵉ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ? ⵎⴰ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ ⵏⵉⵖ ⵣⴻⴳ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT17_26","070_17_26","MAT","17","26","26","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⵣⴻⴳ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ!” ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵙ ⵓⵢⴰ ⴵⴰⵏ ⵜⴰⵔⵡⴰ ⴷ ⵉⵃⵓⵔⵔⵉⵢⵢⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("MT17_27","070_17_27","MAT","17","27","27","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵙⵙⴻⵏⴷⵔⵉⴼ ⴰⴷ ⴰⵛ ⵓⵎⵓⵔⴻⵖ: ⵔⵓⵃ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵏⴹⴰⵔ ⵜⴰⵚⴻⵏⵏⴰⵔⵜ ⵓⵛⴰ ⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵉ ⵜⴻⵙⵍⴻⵎⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴰⴼⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⴱⵢⵉⵙⵜ ⵏ ⵓⵚⵓⵍⴹⵉ ⵏ ‘ⵓⵙⵜⴰⵜⵉⵔ’. ⴽⵙⵉ ⵜⵜ ⵓⵛⴰ ⴻⵡⵛ ⵉ-ⵜⵜ ⵅⴰⴼⵉ ⵓ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MT18_1","070_18_1","MAT","18","1","1","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT18_2","070_18_2","MAT","18","2","2","ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵖⴰⵔⴻⵙ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT18_3","070_18_3","MAT","18","3","3","ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜⵓⴱⴻⵎ ⵓ ⵜⴷⴻⵡⵍⴻⵎ ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_4","070_18_4","MAT","18","4","4","ⵙ ⵓⵢⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵎⴻⵥⵢⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ, ⴰⵇⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("MT18_5","070_18_5","MAT","18","5","5","ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵉ ⵉⴵⴰⵏ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵉⵇⴻⴱⴱⴻⵍ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("MT18_6","070_18_6","MAT","18","6","6","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⵏⵇⴰⵔⴹⴻⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ-ⴰ ⵉ ⵣⵣⴰⵢⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ, ⵉⵃⵍⴰ ⴰⵙ ⴰⴷ ⴰⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵜⵙⵉⵔⵜ ⵜⴻⴷⵇⴻⵍ ⵖⴰⵔ ⵢⵉⵔⵉ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵖⴰⵔⴻⵇ ⴷⵉ ⵍⴰⴵⴰⵖ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT18_7","070_18_7","MAT","18","7","7","ⵓⵛⵜ ⵅ ⴷⴷⵓⵏⴻⵛⵜ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵄⴻⵏⴽⵔⵉⴼⵉⵏ. ⵉⵡⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏⵜ ⵜⵄⴻⵏⴽⵔⵉⴼⵉⵏ, ⵎⴰⵛⴰ ⴰⵎⵛⵓⵎ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("MT18_8","070_18_8","MAT","18","8","8","ⵎⴰⵍⴰ ⵉⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⵏⵉⵖ ⴰⴹⴰⵔ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵇⴻⵙⵙ ⵉ-ⵜ, ⵏⴹⴰⵔ ⵉ-ⵜ ⵅⴰⴽ. ⵉⵃⵍⴰ ⴰⵛ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⴷ ⴰⵇⴻⵊⴷⴰⵃ ⵏⵉⵖ ⴷ ⴰⵎⴻⵄⴹⵓⵍ ⵅ ⵓⵎⴻⵏⴹⴰⵔ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵉⵖ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MT18_9","070_18_9","MAT","18","9","9","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⵜⵉⵟⵟ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⵇⴻⵍⵄ ⵉ-ⵜⵜ, ⵏⴹⴰⵔ ⵉ-ⵜⵜ ⵅⴰⴽ, ⵉⵃⵍⴰ ⴰⵛ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵟⵟ ⵅ ⵓⵡⴻⵟⵟⵓ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_10","070_18_10","MAT","18","10","10","ⵖⴰⵔⵡⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⵎ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ-ⴰ. ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵇⴰ ⵍⴻⴱⴷⴰ ⵜⵜⵡⴰⵍⴰⵏⵜ ⵜⵉⴼⵔⴰⵙ ⵏ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_11","070_18_11","MAT","18","11","11","ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_12","070_18_12","MAT","18","12","12","ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ? ⵎⴰⵍⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵏ ⵡⵓⴵⵉ ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵡⴻⴷⴷⴰⵔ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵜⴻⵙⵄⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ, ⴰⴷ ⵉⵔⴰⵃ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵡⴻⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MT18_13","070_18_13","MAT","18","13","13","ⵓ ⵎⴰⵍⴰ ⵢⵓⴼⴰ ⵉ-ⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴼⴰⵔⵃ ⴽⵜⴰⵔ ⵣⵉ ⵎⵉⵏ ⵖⴰ ⵉⴼⴰⵔⵃ ⵣⵉ ⵜⴻⵙⵄⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_14","070_18_14","MAT","18","14","14","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT18_15","070_18_15","MAT","18","15","15","“ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵓⵎⴰⵛ ⴰⴽⵉⴷⴻⴽ, ⵔⵓⵃ ⵖⴰⵔⴻⵙ, ⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ ⵎⵖⵉⵔ ⵊⴰⵔ ⴰⵛ ⴷ ⵊⴰⵔ ⴰⵙ ⵡⴰⵀⴰ. ⵎⴰⵍⴰ ⵉⵙⵍⴰ ⵖⴰⵔⴻⴽ, ⴰⵇⴰ ⵜⴰⵔⴱⴻⵃⴻⴷ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("MT18_16","070_18_16","MAT","18","16","16","ⵎⴰⵍⴰ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉⵙⵍⵉ ⵛⴰ, ⴰⵡⵉ ⴰⴽⵉⴷⴻⴽ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵏⵉⵖ ⵜⵏⴰⵢⴻⵏ, ⵃⵉⵎⴰ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵡⴰⵡⴰⵍ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT18_17","070_18_17","MAT","18","17","17","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵉⵙⵍⵉ, ⵅⴻⵏⵏⵉ ⵉⵏⵉ ⵜⵜ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵍⵎⵓⵎⵉⵏⵉⵏ, ⵓⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵙⵍⵉ ⵓⵍⴰ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵅⴻⵏⵏⵉ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⴹⴹⴰⵔⵉⴱⴰ ⵏⵉⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴽⴰⴼⵔⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("MT18_18","070_18_18","MAT","18","18","18","ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⵛⴻⴷⴷⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵛⴻⴷⴷ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴼⴻⵙⵢⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵢⵉⵍⵉ ⵉⴼⵙⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MT18_19","070_18_19","MAT","18","19","19","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵄⴰⵡⴻⴷ, ⵎⴰⵍⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⵎⵎⵙⴻⵜⴼⴰⵇⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⵖⴰ ⵜⵜⴰⵔⴻⵏ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵙⴻⵏ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵣⵉ ⴱⴰⴱⴰ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_20","070_18_20","MAT","18","20","20","ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵎⵓⵏⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵏⴻⵛⵛ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT18_21","070_18_21","MAT","18","21","21","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴱⵓⵟⵔⵓⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵉ ⵖⴰ ⵉⵅⴹⴰ ⴰⴽⵉⴷⵉ ⵓⵎⴰ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵙⴰⵎⵃⴻⵖ? ⵎⴰ ⴰⵍ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT18_22","070_18_22","MAT","18","22","22","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵖ ⵛⴰ ⴰⵍ ⵙⴻⴱⵄⴰ, ⵎⴰⵛⴰ ⴰⵍ ⵙⴻⴱⵄⵉⵏ ⴷⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵓⵔⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵓⵔⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("MT18_23","070_18_23","MAT","18","23","23","ⵙ ⵓⵢⴰ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵊⴻⴵⵉⴷ ⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵢⴻⴳⴳ ⵍⴻⵃⵙⴰⴱ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT18_24","070_18_24","MAT","18","24","24","ⵓⵎⵉ ⵉⴱⴷⴰ ⴰⴷ ⵉⵎⵙⴻⵃⵙⴻⴱ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵓⵔⵙ ⴰⵙ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵜⴰⵍⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT18_25","070_18_25","MAT","18","25","25","ⴰⵎ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⴻⵙ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵢⴰⵔⵔ ⴰⵎⴰⵔⵡⴰⵙ, ⵢⵓⵎⵓⵔ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⵣ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT18_26","070_18_26","MAT","18","26","26","ⵉⵡⴹⴰ ⴰⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ, ⵉⵙⵊⴻⴷ ⴰⵙ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵚⴱⴰⵔ ⵅⴰⴼⵉ, ⴰⴷ ⴰⵛ ⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ.’ ");
INSERT INTO rift_vpl VALUES ("MT18_27","070_18_27","MAT","18","27","27","ⴰⵇⴰ ⵉⵣⵣⵉⴵⴻⵣ ⴰⵙ ⴱⴰⴱ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ, ⵉⴹⵍⴻⵇ ⴰⵙ ⵓⵛⴰ ⵉⵙⴰⵎⵃ ⴰⵙ ⴷⴻⴳ ⵓⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT18_28","070_18_28","MAT","18","28","28","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ, ⵢⵓⴼⴰ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵓⵔⵙ ⴰⵙ ⵎⵢⴰ ⴷⵉⵏⴰⵔ. ⵉⵟⵟⴻⴼ ⵉ-ⵜ, ⵉⵛⴻⴱⴱⴰⵔ ⴰⵙ ⴷⴻⴳ ⵢⵉⵔⵉ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⵅⴻⴵⴻⵚ ⴰⵢⵉ ⵎⵉⵏ ⴷ ⴰⵛ ⵜⵜⵓⵔⵙⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("MT18_29","070_18_29","MAT","18","29","29","ⵉⵡⴹⴰ ⵢⴰⵙ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ, ⵉⵏⵏⴰ: ‘ⵚⴱⴰⵔ ⵅⴰⴼⵉ, ⴰⴷ ⴰⵛ ⴰⵔⵔⴻⵖ ⵎⴰⵔⵔⴰ!’ ");
INSERT INTO rift_vpl VALUES ("MT18_30","070_18_30","MAT","18","30","30","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ, ⵉⵔⵓⵃ ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔ ⴰⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT18_31","070_18_31","MAT","18","31","31","ⵍⴰⵎⵉ ⵥⵍⵉⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⵛⴻⴹⵏⴻⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵔⵓⵃⴻⵏ, ⵏⵏⴰⵏ ⵜⵜ ⵉ ⴱⴰⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT18_32","070_18_32","MAT","18","32","32","ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ ⵙⵉⴷⵉⵙ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⴰ ⵛⴻⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵜⵜⵓⵔⵙⴻⵖ, ⵙⴰⵎⵃⴻⵖ ⴰⵛ, ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⴰⵔⴻⴷ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("MT18_33","070_18_33","MAT","18","33","33","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⴻⵄⵎⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵅⴰⴽ ⴰⴷ ⴰⵛ ⵉⵣⵣⵉⴵⴻⵣ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵣⵣⵉⴵⴻⴷ ⵛⴻⴽ?’ ");
INSERT INTO rift_vpl VALUES ("MT18_34","070_18_34","MAT","18","34","34","ⵅⴻⵏⵏⵉ ⵉⵅⴻⵢⵢⴻⵇ ⵙⵉⴷⵉⵙ, ⵉⵙⵙⴻⵄⴷⵓ ⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⵄⴰⴷⴷⴻⴱⴻⵏ ⴰⵍ ⵖⴰ ⵉⵅⴻⴵⴻⵚ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⴷ ⴰⵎⴰⵔⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT18_35","070_18_35","MAT","18","35","35","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵙⵉⵎⵉⵃⴻⵎ ⵙ ⵡⵓⵍ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵓⵎⴰⵙ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT19_1","070_19_1","MAT","19","1","1","ⴰⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⴰⵙⵓⵄ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⴼⴼⴻⵖ ⵣⵉ ⵍⵊⴰⵍⵉⵍ, ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MT19_2","070_19_2","MAT","19","2","2","ⴰⵇⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT19_3","070_19_3","MAT","19","3","3","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵍⴰ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵊⴰⵔⵔⴱⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⵉ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⴵⴻⴼ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵎⴽⵓⵍ ⵙⵉⴱⴱⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("MT19_4","070_19_4","MAT","19","4","4","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵉⵅⵍⴻⵇ ⵉ-ⵜⴻⵏ-ⴷⴷ ⴷ ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ, ");
INSERT INTO rift_vpl VALUES ("MT19_5","070_19_5","MAT","19","5","5","ⵓⵛⴰ ⴰⵇⴰ ⵉⵏⵏⴰ: ‘ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵎⴻⵃ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⴷⴷⴰⵜ’? ");
INSERT INTO rift_vpl VALUES ("MT19_6","070_19_6","MAT","19","6","6","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⴷ ⵜⵏⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵎⵉⵏ ⵉⵙⵙⵎⵓⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜ ⵉⴱⴻⵟⵟⵉ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT19_7","070_19_7","MAT","19","7","7","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⵅⴻⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⵜⴰⴱⵔⴰⵜ ⵏ ⵡⴰⴵⴰⴼ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴵⴻⴼ?” ");
INSERT INTO rift_vpl VALUES ("MT19_8","070_19_8","MAT","19","8","8","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵓⵙⴰ ⵉⵊⵊⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴵⴼⴻⵎ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⵎⵓ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("MT19_9","070_19_9","MAT","19","9","9","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴵⴼⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴱⵍⴰ ⵎⴰ ⵜⴻⵣⵏⴰ ⵏⴻⵜⵜⴰⵜ, ⵓⵛⴰ ⴰⴷ ⵢⵉⵡⵉ ⵉⵛⵜⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵣⴻⵏⵏⴰ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⵢⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵉ ⵉⴵⴼⴻⵏ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵣⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT19_10","070_19_10","MAT","19","10","10","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵍⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵊⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⵀⵍⴰ ⵎⴰ ⴰⴷ ⵉⵎⵍⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MT19_11","070_19_11","MAT","19","11","11","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵔⵔⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⴻⴱⵍⴻⵏ ⴰⵡⴰⵍ-ⴰ ⵎⵖⵉⵔ ⵉⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⴰⴷ ⵜ ⵉⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MT19_12","070_19_12","MAT","19","12","12","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⵎⵎⵓ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ, ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵇⴻⵙⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵉⵇⴱⴻⵍ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵜ ⵉⵇⴱⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MT19_13","070_19_13","MAT","19","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⴽⵙⵉ ⵙ ⵍⵎⴻⵄⵔⵓⴼ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴻⴱⴱⵅⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT19_14","070_19_14","MAT","19","14","14","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵊⵊⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵎⴻⵏⵏⵄⴻⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⴰⵎ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT19_15","070_19_15","MAT","19","15","15","ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙⴻⵏ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵔⵓⵃ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT19_16","070_19_16","MAT","19","16","16","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵉⵊⵊⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT19_17","070_19_17","MAT","19","17","17","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⵍⴰⵖⵉⴷ ‘ⴰⵚⴻⴱⵃⴰⵏ’? ⵡⴰⵔ ⵉⴵⵉ ⵃⴻⴷ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵎⵖⵉⵔ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ, ⵟⵟⴻⴼ ⴷⵉ ⵜⵡⴻⵚⵚⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT19_18","070_19_18","MAT","19","18","18","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏ ⵜⵉⵏⴰ?” ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵏⴻⵇⵇ, ⵡⴰⵔ ⵣⴻⵏⵏⵉ, ⵡⴰⵔ ⵜⵜⵉⵛⴰⵔ, ⵡⴰⵔ ⵛⴻⵀⵀⴻⴷ ⵙ ⵥⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("MT19_19","070_19_19","MAT","19","19","19","ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ ⵓⵛⴰ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MT19_20","070_19_20","MAT","19","20","20","ⴰⴱⵍⵉⵖ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⴹⴼⴰⵔⴻⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵎⴰⵔⵔⴰ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ. ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵜⵜⵅⵉⵚⵚⴻⵏ ⵄⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("MT19_21","070_19_21","MAT","19","21","21","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴽⴻⵎⵎⵍⴻⴷ, ⵔⵓⵃ, ⵣⴻⵏⵣ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ, ⴻⵡⵛ ⵉ-ⵜ ⵉ ⵉⵎⴻⵣⵍⴰⴹ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵍⴽⴻⵏⵣ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ⵅⴻⵏⵏⵉ ⴰⵙ-ⴷⴷ, ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT19_22","070_19_22","MAT","19","22","22","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵡⴻⴱⵍⵉⵖ ⴰⵡⴰⵍ-ⴰ, ⵉⵔⵓⵃ ⵉⵛⴹⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MT19_23","070_19_23","MAT","19","23","23","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵢⴻⵡⵄⴰⵔ ⵅ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT19_24","070_19_24","MAT","19","24","24","ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵉⵀⵡⴻⵏ ⵉ ⵡⴻⵍⵖⴻⵎ ⴰⴷ ⵢⴻⴽⴽ ⵣⵉ ⵜⵉⵟⵟ ⵏ ⵜⵙⵉⵏⴻⴼⵜ ⵅ ⴱⵓ ⵡⴰⴳⵍⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT19_25","070_19_25","MAT","19","25","25","ⵓⵎⵉ ⵜⵜ ⵙⵍⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⵅⴻⵍⵄⴻⵏ, ⵏⵏⴰⵏ: “ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⵓⴷⴰⵔⵜ ⵄⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("MT19_26","070_19_26","MAT","19","26","26","ⴰⵎ ⵜⵓⵖⴰ ⴷⴰⵢⵙⴻⵏ ⵉⵅⴻⵣⵣⴰⵔ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴽⵓⵍⵛⵉ ⴷⵉ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("MT19_27","070_19_27","MAT","19","27","27","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵓⵟⵔⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵊⵊⴰ ⴽⵓⵍⵛⵉ, ⵏⴻⴹⴼⴰⵔ ⵉ ⵛⴻⴽ. ⵎⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT19_28","070_19_28","MAT","19","28","28","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ, ⴰⵇⴰ ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵊⴷⵉⴷ, ⵅⵎⵉ ⵖⴰ ⵉⵇⵇⵉⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⴻⴽⵔⴰⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵃⴻⴽⵎⴻⵎ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT19_29","070_19_29","MAT","19","29","29","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵉⵖ ⴷⴻⴳ ⴰⵢⵜⵎⴰⵙ ⵏⵉⵖ ⴷⵉ ⵙⵓⵢᵉⵜⵎⴰⵙ ⵏⵉⵖ ⴷⵉ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⴷⴻⴳ ⵢⴻⵎⵎⴰⵙ ⵏⵉⵖ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷⴻⴳ ⵢⴻⵢⵢⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵉⴽⵙⵉ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵡⴰⵔⵜ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT19_30","070_19_30","MAT","19","30","30","ⵎⴰⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵓⵛⴰ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT20_1","070_20_1","MAT","20","1","1","“ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵔⴰ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵉ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT20_2","070_20_2","MAT","20","2","2","ⵍⴰⵎⵉ ⵉⴽⴽⴻⵙ ⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ ⵙ ⵢⵉⵊⵊⴻⵏ ⴷⵉⵏⴰⵔ ⵉ ⵢⵉⵊⵊⴻⵏ ⵡⴰⵙⵙ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MT20_3","070_20_3","MAT","20","3","3","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵖⴰⵔ ⵜⴻⵙⵄⴰ ⴷⵉ ⵚⵚⴱⴻⵃ, ⵉⵥⵔⴰ ⵉⵏⵏⴻⵖⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵎⴻⵡⵇⴻⴼ ⴱⵍⴰ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MT20_4","070_20_4","MAT","20","4","4","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⵔⵓⵃⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵓⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ, ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ!’, ⵓⵛⴰ ⵔⵓⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT20_5","070_20_5","MAT","20","5","5","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⴷ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT20_6","070_20_6","MAT","20","6","6","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵀⵉⵟⵄⴰⵛ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵖⴰⵔ ⵅⴻⵎⵙⴰ ⵏ ⵜⵎⴻⴷⴷⵉⵜ, ⵢⵓⴼⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵏⵏⴻⵖⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ ⴱⵍⴰ ⵍⵅⴻⴷⵎⴻⵜ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵜⴱⴻⴷⴷⴻⵎ ⴷⴰ ⴰⵙⵙ ⵉⴽⵎⴻⵍ ⴱⵍⴰ ⵍⵅⴻⴷⵎⴻⵜ?’ ");
INSERT INTO rift_vpl VALUES ("MT20_7","070_20_7","MAT","20","7","7","ⵏⵏⴰⵏ ⴰⵙ: ‘ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵛⵔⵉ ⵃⴻⴷ.’ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⵔⵓⵃⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵓⵎⴰⵔⵊⴻⵄ ⵉⵏⵓ ⵏ ⵓⴹⵉⵍ, ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MT20_8","070_20_8","MAT","20","8","8","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ, ⵉⵏⵏⴰ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵉ ⵓⵡⴻⵇⵇⴰⴼ ⵏⵏⴻⵙ: ‘ⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ, ⵅⴻⴵⴻⵚ ⴰⵙⴻⵏ ⵍⵎⵓⵏⴻⵜ, ⵙⵉⵣⵡⴰⵔ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵓⵛⴰ ⴰⵎⵎⵓ ⴰⵍ ⵉⵎⴻⵣⵡⵓⵔⴰ.’ ");
INSERT INTO rift_vpl VALUES ("MT20_9","070_20_9","MAT","20","9","9","ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵏⵏⵉ ⴷ ⵉⵛⵔⴰ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ, ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵟⵟⴻⴼ ⵉⵊⵊⴻⵏ ⴷⵉⵏⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT20_10","070_20_10","MAT","20","10","10","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⴽⵜⴰⵔ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT20_11","070_20_11","MAT","20","11","11","ⵍⴰⵎⵉ ⵜ ⵟⵟⴼⴻⵏ, ⴰⵇⴰ ⵅⴻⵢⵢⵇⴻⵏ ⵅ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("MT20_12","070_20_12","MAT","20","12","12","ⵏⵏⴰⵏ: ‘ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵅⴻⴷⵎⴻⵏ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵓ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵎⵇⵓⴷⴻⴷ ⵉ-ⵜⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⴷⴷⵇⴻⵍ ⵏ ⵡⴰⵙⵙ ⴷ ⵍⴻⵃⵎⵓ.’ ");
INSERT INTO rift_vpl VALUES ("MT20_13","070_20_13","MAT","20","13","13","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵉⵏⵏⴰ: ‘ⴰ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⴹⵍⵉⵎⴻⵖ, ⵎⴰ ⵡⴰⵔ ⴽⵉⴷⵉ ⵜⴻⴽⴽⵉⵙⴻⴷ ⴰⵡⴰⵍ ⵅ ⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("MT20_14","070_20_14","MAT","20","14","14","ⵟⵟⴻⴼ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵓⵢⵓⵔ. ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵡⵛⴻⵖ ⵉ ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⵏⴻⵛⵜ ⵎⵉⵏ ⴷ ⴰⵛ ⵡⵛⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("MT20_15","070_20_15","MAT","20","15","15","ⵏⵉⵖ ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵍⵃⴻⵇⵇ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵅⵙⴻⵖ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵏⵓ? ⵏⵉⵖ ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⵚⴻⴱⵃⴰⵏ?’ ");
INSERT INTO rift_vpl VALUES ("MT20_16","070_20_16","MAT","20","16","16","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵓⵛⴰ ⵉⵎⴻⵣⵡⵓⵔⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ, ⵎⴰⵛⴰ ⴷⵔⵓⵙ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT20_17","070_20_17","MAT","20","17","17","ⵍⴰⵎⵉ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵢⵉⵡⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MT20_18","070_20_18","MAT","20","18","18","“ⵅⵣⴰⵔ, ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙ ⵃⴻⴽⵎⴻⵏ ⵙ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("MT20_19","070_20_19","MAT","20","19","19","ⴰⴷ ⵜ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵜⴻⵀⵣⴰⵏ, ⴰⴷ ⵜ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⵓⵛⴰ ⴰⴷ ⵜ ⵚⴻⵍⵍⴱⴻⵏ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MT20_20","070_20_20","MAT","20","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵢⴻⵎⵎⴰⵙ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵣⴰⴱⴷⵉ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⴻⵙⵊⴻⴷ ⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⴰⵔ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MT20_21","070_20_21","MAT","20","21","21","ⵉⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ?” ⵜⴻⵏⵏⴰ ⴰⵙ ⵏⴻⵜⵜⴰⵜ: “ⵉⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ-ⴰ ⵉⵏⵓ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵛ, ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MT20_22","070_20_22","MAT","20","22","22","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵔⴻⵎ. ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵍⴽⴰⵙ ⵉ ⵖⴰ ⵙⵡⴻⵖ ⵏⴻⵛⵛ, ⵏⵉⵖ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵉ ⵣⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵖ ⵏⴻⵛⵛ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵏⵣⴻⵎⵎⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("MT20_23","070_20_23","MAT","20","23","23","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵍⴽⴰⵙ ⵉⵏⵓ ⴰⴷ ⵜ ⵜⴻⵙⵡⴻⵎ ⵓ ⴰⵙⴻⵖⴹⴻⵚ ⵉ ⵣⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵖ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ, ⵎⴰⵛⴰ ⴰⵖⵉⵎⵉ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵉⵏⵓ ⴷ ⵓⵣⴻⵍⵎⴰⴹ ⵉⵏⵓ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵏⴻⵛⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵡⵛⴻⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵜ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT20_24","070_20_24","MAT","20","24","24","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵅⴻⵢⵢⵇⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT20_25","070_20_25","MAT","20","25","25","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ ⵃⴻⴽⴽⵎⴻⵏ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵚⴻⵍⵍⴰⵟⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT20_26","070_20_26","MAT","20","26","26","ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵎⵎⵓ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⵙ ⵍⵎⴻⵇⵍⵓⴱ: ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT20_27","070_20_27","MAT","20","27","27","ⵓ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⴰⵡⴻⵎ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT20_28","070_20_28","MAT","20","28","28","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵙⴻⵅⵅⴰⵔ ⵓⵛⴰ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⴰⵚⵍⴰⵃ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT20_29","070_20_29","MAT","20","29","29","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵣⵉ ⴰⵔⵉⵃⴰ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MT20_30","070_20_30","MAT","20","30","30","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵇⵇⵉⵎⴻⵏ ⵅ ⵟⵟⴰⵔⴼ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴰⴷ ⵉⵄⴷⵓ, ⵍⴰⵖⴰⵏ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵃⴻⵎ ⴰⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("MT20_31","070_20_31","MAT","20","31","31","ⵎⴰⵛⴰ ⵍⵖⴰⵛⵉ ⵉⵣⵉⵢⵢⴰⵔ ⵅⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵇⴰⵔⴻⵏ. ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⴽⵜⴰⵔ, ⵏⵏⴰⵏ: “ⴰⵔⵃⴻⵎ ⴰⵏⴻⵖ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT20_32","070_20_32","MAT","20","32","32","ⵅⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("MT20_33","070_20_33","MAT","20","33","33","ⵏⵏⴰⵏ ⴰⵙ ⵏⵉⵜⵏⵉ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("MT20_34","070_20_34","MAT","20","34","34","ⵢⴰⵙⵓⵄ ⵉⵃⵉⵏⵏ ⵅⴰⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵃⴰⴷⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵍⴰⵏⵜ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴹⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MT21_1","070_21_1","MAT","21","1","1","ⵍⴰⵎⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴱⴰⵢⵜ-ⴼⴰⵊⵉ, ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ, ⵉⵙⵙⴻⴽⴽ ⵢⴰⵙⵓⵄ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MT21_2","070_21_2","MAT","21","2","2","“ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⴷⵛⴰⵔ ⵏⵏⵉ ⵇⵉⴱⴰⵍⵜ ⵏⵡⴻⵎ. ⴷⴻⵖⵢⴰ ⴰⴷ ⵜⴰⴼⴻⵎ ⵉⵛⵜ ⵏ ⵜⴻⵖⵢⵓⵍⵜ ⵜⴻⵇⵇⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵙⵏⵓⵙ ⴰⴽⵉⴷⴻⵙ. ⴼⴻⵙⵢⴻⵎ ⴰⵙⴻⵏ, ⵜⴰⵡⵢⴻⵎ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("MT21_3","070_21_3","MAT","21","3","3","ⵎⴰⵍⴰ ⵉⵏⵏⴰ ⴰⵡⴻⵎ ⵃⴻⴷ ⵛⴰ, ⴰⵔⵔⴻⵎ ⵅⴰⵙ ⴰⵎⵎⵓ: ‘ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵃⴷⴰⵊ ⵉ-ⵜⴻⵏ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵢⴰⵔⵔ ⴷⴻⵖⵢⴰ.’” ");
INSERT INTO rift_vpl VALUES ("MT21_4","070_21_4","MAT","21","4","4","ⵎⴰⵏ ⴰⵢⴰ ⵇⴰⵄ ⵉⵎⵙⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⴰⵎ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT21_5","070_21_5","MAT","21","5","5","“ⵉⵏⵉⵎ ⵉ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ: ‘ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵎ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵢⴰⵙ ⵙ ⵓⵡⴰⴹⴻⵄ, ⵢⴻⵏⵢⴰ ⵅ ⵡⴻⵖⵢⵓⵍ ⴷ ⵡⴻⵙⵏⵓⵙ, ⴰⵇⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵜⴻⵖⵢⵓⵍⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT21_6","070_21_6","MAT","21","6","6","ⵔⵓⵃⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT21_7","070_21_7","MAT","21","7","7","ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⵖⵢⵓⵍ ⴷ ⵡⴻⵙⵏⵓⵙ, ⵙⴰⵔⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵅ ⵡⴻⵙⵏⵓⵙ ⵓⵛⴰ ⵉⵏⵢⴰ ⵅⴰⵙ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT21_8","070_21_8","MAT","21","8","8","ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⵖⴰⵛⵉ ⵙⵙⵓⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⵇⴻⵙⵙⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵣⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ, ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("MT21_9","070_21_9","MAT","21","9","9","ⵓⵛⴰ ⴰⴱⴰⵔⵔⵓ ⵏ ⵍⵖⴰⵛⵉ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵣⵡⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵉⴹⴼⴰⵔⴻⵏ, ⵜⵓⵖⴰ ⵙⵖⵓⵢⵢⵓⵏ, ⵏⵏⴰⵏ: “ⵓⵚⴰⵏⵏⴰ ⵉ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ! ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ. ⵓⵚⴰⵏⵏⴰ, ⴷⵉ ⵍⵓⵄⵍⴰ ⵅ ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT21_10","070_21_10","MAT","21","10","10","ⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⵀⴰⵊ ⵜⴻⵏⴷⵉⵏⵜ ⵇⴰⵄ, ⵉⵡⴷⴰⵏ ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT21_11","070_21_11","MAT","21","11","11","ⵍⵖⴰⵛⵉ ⵉⵏⵏⴰ: “ⴷ ⵡⴰ ⴷ ⴰⵏⴰⴱⵉ ⵢⴰⵙⵓⵄ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ ⴷⵉ ⵍⵊⴰⵍⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("MT21_12","070_21_12","MAT","21","12","12","ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵣⵣⵏⵓⵣⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴰⵖⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵉⵇⵍⴻⴱ ⵟⵟⵡⴰⴱⴻⵍ ⵏ ⵉⵚⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵜⴻⵏⵄⴰⵛⵉⵏ ⴷ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⵣⵏⵓⵣⴰⵏ ⵉⴷⴱⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT21_13","070_21_13","MAT","21","13","13","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵥⴰⴵⵉⵜ’, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ ⵜⵜ ⴷ ⵉⴼⵔⵉ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("MT21_14","070_21_14","MAT","21","14","14","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT21_15","070_21_15","MAT","21","15","15","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉ ⵢⴻⴳⴳⴰ ⵓ ⴰⵇⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵜⵜⵍⴰⵖⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵇⵇⴰⵔⴻⵏ: “ⵓⵚⴰⵏⵏⴰ ⵉ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ!”, ⵅⴻⵢⵢⵇⴻⵏ ⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("MT21_16","070_21_16","MAT","21","16","16","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵜⴻⵙⵍⵉⴷ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ ⵢⵉⵏⴰ?” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵡⴰⵀ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵄⴻⵎⵎⴰⵔⵚ: ‘ⵣⴻⴳ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵉⵙⴻⵢⵎⴰⵏ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵛⴻⴽ ⵜⵜⴻⵙⴱⵉⵃ’?” ");
INSERT INTO rift_vpl VALUES ("MT21_17","070_21_17","MAT","21","17","17","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵎⴻⵃ ⴷⴰⵢⵙⴻⵏ, ⵉⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⵉⵏⵙⴰ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT21_18","070_21_18","MAT","21","18","18","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵍⴰⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("MT21_19","070_21_19","MAT","21","19","19","ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵡⴰⵔⵜⵓ ⵅ ⵡⴻⴱⵔⵉⴷ, ⵉⵔⵓⵃ ⵖⴰⵔⴻⵙ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⵓⴼⵉ ⵎⵖⵉⵔ ⵜⵉⴼⵔⴰⵢ ⵡⴰⵀⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵡⴰⵔⵜⵓ: “ⵡⴰⵔ ⵣⵣⴰⵢⴻⴽ ⵜⵜⴻⴼⴼⴻⵖ ⵍⵖⵉⴵⴻⵜ ⵄⴻⵎⵎⴰⵔⵚ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵥⴻⵖ ⵡⴰⵔⵜⵓ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MT21_20","070_21_20","MAT","21","20","20","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵜⴱⴻⵀⵜⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵡⴰⵔⵜⵓ ⵢⵓⵥⴻⵖ ⴷⴻⵖⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT21_21","070_21_21","MAT","21","21","21","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⴷⴰⵢⵡⴻⵎ ⵍ’ⵉⵎⴰⵏ ⵓ ⵡⴰⵔ ⵜⵛⴻⴽⴽⵉⵎ ⵛⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵡⴰⵔⵜⵓ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵍⴰ ⵜⴻⵏⵏⴰⵎ ⵉ ⵡⴻⴷⵔⴰⵔ-ⴰ: ‘ⵎⴻⴽⵙⵉ, ⵡⴹⴰ ⴷⵉ ⵍⴻⴱⵃⴰⵔ!’, ⴰⴷ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("MT21_22","070_21_22","MAT","21","22","22","ⴷ ⵇⴰⵄ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⴷⵉ ⵜⵥⴰⴵⵉⵜ ⵙ ⵍ’ⵉⵎⴰⵏ, ⴰⴷ ⵜ ⵜᵉⵟⵟⴼⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT21_23","070_21_23","MAT","21","23","23","ⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ, ⵏⵏⴰⵏ: “ⵙ ⵎⴰⵏ ⵚⵚⵓⵍⵟⴰ ⵉ ⵜⴻⴳⴳⵉⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ? ⵡⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⵚⵚⵓⵍⵟⴰ-ⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT21_24","070_21_24","MAT","21","24","24","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵇⵙⵉⵖ ⵉⵊⵊ ⵏ ⵓⵙⴻⵇⵙⵉ ⵓ ⵎⴰⵍⴰ ⵜⴰⵔⵔⵉⵎ-ⴷⴷ ⵅⴰⴼⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵙ ⵎⴰⵏ ⵚⵚⵓⵍⵟⴰ ⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("MT21_25","070_21_25","MAT","21","25","25","ⴰⵙⴻⵖⴹⴰⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵎⴰⵏⵉⵙ ⵏⴻⵜⵜⴰ? ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⵣⴻⴳ ⵉⵡⴷⴰⵏ?” ⵎⵛⴰⵡⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵏⴻⵏⵏⴰ: ‘ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ!’, ⴰⴷ ⴰⵏⴻⵖ ⵉⵏⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵎⵉⵏⴻⵎ?’, ");
INSERT INTO rift_vpl VALUES ("MT21_26","070_21_26","MAT","21","26","26","ⵓ ⵎⴰⵍⴰ ⵏⴻⵏⵏⴰ: ‘ⵣⴻⴳ ⵉⵡⴷⴰⵏ!’, ⵅⴻⵏⵏⵉ ⴷⴰⵢⵏⴻⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵃⴻⵙⵙⴱⴻⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⴰⵏⴰⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT21_27","070_21_27","MAT","21","27","27","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ.” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵏⴻⵜⵜⴰ: “ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⵙ ⵎⴰⵏ ⵚⵚⵓⵍⵟⴰ ⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT21_28","070_21_28","MAT","21","28","28","“ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ ⴽⴻⵏⵏⵉⵡ? ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ⵉⵍⴰⵖⴰ ⵅ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵉⵏⵏⴰ: ‘ⴰ ⵎⵎⵉ, ⵓⵢⵓⵔ, ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⵅⴻⴷⵎⴻⴷ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("MT21_29","070_21_29","MAT","21","29","29","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ!’, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⴷⴻⵎ ⵓⵛⴰ ⵉⵔⵓⵃ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT21_30","070_21_30","MAT","21","30","30","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ ⴰⵎⴻⵏⵏⵉ ⴱⴻⵄⴷⴰ. ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: ‘ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ!’, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵔⵓⵃ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("MT21_31","070_21_31","MAT","21","31","31","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵉⴳⴳⵉⵏ ⵍⵅⴰⴹⴰⵔ ⵉ ⴱⴰⴱⴰⵙ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ.” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⴷ ⴰⵡⴻⵎ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT21_32","070_21_32","MAT","21","32","32","ⵎⵉⵏⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵙⴻⴳⴷⴰ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵎⵉⵏⴻⵎ, ⵎⴰⵛⴰ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ. ⵍⴰⵎⵉ ⵜⴻⵥⵔⵉⵎ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵜᵉⵜⵓⴱⴻⵎ ⵛⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴰⵎⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT21_33","070_21_33","MAT","21","33","33","“ⵙⵍⴻⵎ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵏⵏⴻⵖⵏⵉ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ, ⵉⵥⵥⵓ ⴷⴰⵢⴻⵙ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ. ⵏⴻⵜⵜⴰ ⵉⵇⵓⵡⵡⴰⵔ ⴰⵙ-ⴷⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⴼⵔⴰⵢ, ⵉⵖⵣⴰ ⴷⴰⵢⴻⵙ ⵜⴰⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⵉⴱⵏⴰ ⴷⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵚⵚⵓⵎⵄⴻⵜ. ⵅⴻⵏⵏⵉ ⵢⴰⵔⵀⴻⵏ ⴰⵎⴰⵔⵊⴻⵄ ⵏⵏⵉ ⵏ ⵓⴹⵉⵍ ⵉ ⵛⴰ ⵏ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵙⴰⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT21_34","070_21_34","MAT","21","34","34","ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵏ ⵍⵖⵉⴵⴻⵜ, ⵉⵙⵙⴻⴽⴽ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT21_35","070_21_35","MAT","21","35","35","ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵟⵟⴼⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵡⵜⵉⵏ ⵉⵊⵊⴻⵏ, ⵏⵖⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⵔⴻⵊⵎⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT21_36","070_21_36","MAT","21","36","36","ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴽⵜⴰⵔ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵓⵛⴰ ⴳⴳⵉⵏ ⴷⴰⵢⵙⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT21_37","070_21_37","MAT","21","37","37","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⵙⵙⴻⴽⴽ ⴰⵙⴻⵏ-ⴷⴷ ⵎⵎⵉⵙ, ⵉⵏⵏⴰ: ‘ⵏⵉⵛⴰⵏ ⴰⴷ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵎⵎⵉ’. ");
INSERT INTO rift_vpl VALUES ("MT21_38","070_21_38","MAT","21","38","38","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵎⵎⵉⵙ, ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: ‘ⴰⵇⴰ ⴷ ⴰⵡⵔⵉⵜ, ⵣⵉⴷⴻⵎ, ⴰⴷ ⵜ ⵏⴻⵏⴻⵖ, ⴰⴷ ⴰⵙ ⵏⴻⴽⴽⴻⵙ ⵍⵡⴰⵔⵜ ⵉ ⵏⴻⵛⵛⵉⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MT21_39","070_21_39","MAT","21","39","39","ⵟⵟⴼⴻⵏ ⵜ, ⵏⴹⴰⵔⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT21_40","070_21_40","MAT","21","40","40","ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⵉ, ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ ⴷⴻⴳ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("MT21_41","070_21_41","MAT","21","41","41","ⵏⵏⴰⵏ ⴰⵙ: “ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵏⵏⵉ ⵇⴰⵄ, ⵓⵛⴰ ⴰⴷ ⵉⵡⵛ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵉ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT21_42","070_21_42","MAT","21","42","42","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵄⴻⵎⵎⴰⵔⵚ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ: ‘ⴰⵥⵔⵓ ⵉ ⵉⵄⵉⴼⴼⴻⵏ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵥⵔⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ. ⵡⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵄⵊⴻⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("MT21_43","070_21_43","MAT","21","43","43","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵡⴻⵎ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵖⴰ ⵉⵡⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT21_44","070_21_44","MAT","21","44","44","ⵡⵉ ⵖⴰ ⵉⵡⴹⴰⵏ ⵅ ⵡⴻⵥⵔⵓ-ⵢⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⵍⴱⴻⵣ, ⵓ ⵡⵉ ⵅⴻⴼ ⵉ ⵖⴰ ⵉⵡⴹⴰ, ⴰⴷ ⵜ ⵉⵍⴱⴻⵣ.” ");
INSERT INTO rift_vpl VALUES ("MT21_45","070_21_45","MAT","21","45","45","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵉⵎⴻⴷⵢⴰ ⵏⵏⴻⵙ, ⴼⴻⵀⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵙⵙⴰⵡⴰⵍ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT21_46","070_21_46","MAT","21","46","46","ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ, ⵎⴰⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵎⵉⵏⵣⵉ ⵍⵖⴰⵛⵉ ⵜⵓⵖⴰ ⵉⵃⴻⵙⵙⴻⴱ ⵉ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT22_1","070_22_1","MAT","22","1","1","ⵉⵟⵟⴻⴼ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵙ ⵉⵎⴻⴷⵢⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MT22_2","070_22_2","MAT","22","2","2","“ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵉⴳⴳⴰ ⵓⵔⴰⵔ ⵉ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("MT22_3","070_22_3","MAT","22","3","3","ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵍⴰⵖⴰⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ ⵖⴰⵔ ⵡⵓⵔⴰⵔ, ⵎⴰⵛⴰ ⵓⴳⵉⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT22_4","070_22_4","MAT","22","4","4","ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: ‘ⵉⵏⵉⵎ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ: ⴰⵇⴰ ⵙⵙⵡⴻⵊⴷⴻⵖ ⴰⵡⴻⵎ ⴰⵎⴻⵛⵍⵉ, ⵖⴰⵔⵚⴻⵖ ⵉ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⵉⵏⵓ ⴷ ⵍⵎⴰⵍ ⵉⵏⵓ ⵉⵚⴻⵃⵃⴻⵏ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵡⵊⴻⴷ, ⴰⵙⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵡⵓⵔⴰⵔ!’” ");
INSERT INTO rift_vpl VALUES ("MT22_5","070_22_5","MAT","22","5","5","ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⵡⵛⵉⵏ ⵛⴰ ⵜⴰⵢⵏⵉⵜ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵔⵓⵃⴻⵏ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵍⴻⵄⵔⴰⵚⵉ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵜⵜⵉⵊⴰⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT22_6","070_22_6","MAT","22","6","6","ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵟⵟⴼⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵖⴻⵣⵣⴰⵏ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT22_7","070_22_7","MAT","22","7","7","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵓⵊⴻⴵⵉⴷ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⴻⵢⵢⴻⴱ ⵉⵇⴻⵜⵜⴰⵍⴻⵏ ⵏⵏⵉ ⵓⵛⴰ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT22_8","070_22_8","MAT","22","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: ‘ⴰⵇⴰ ⵓⵔⴰⵔ ⵉⵡⵊⴻⴷ ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ ⵡⴰⵔ ⵜ ⵙⴷⵉⵀⵉⴵⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("MT22_9","070_22_9","MAT","22","9","9","ⵙ ⵓⵢⴰ ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵜⴻⵎⵙⴻⴱⴹⴰⵏ ⵉⴱⵔⵉⴷⴻⵏ, ⵍⴰⵖⴰⵎ-ⴷⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴰⴼⴻⵎ ⴷⵉⵏ ⵖⴰⵔ ⵡⵓⵔⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("MT22_10","070_22_10","MAT","22","10","10","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵓⴼⵉⵏ, ⴰⵎ ⵢⵉⵚⴻⴱⵃⴰⵏⴻⵏ ⴰⵎ ⵢⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵓⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⵓⵔⴰⵔ ⵜⴻⴷⵡⴻⵍ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT22_11","070_22_11","MAT","22","11","11","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵓⵊⴻⴵⵉⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵥⴰⵔ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ, ⵉⵃⴻⴽⴽⴰⵔ ⵉ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵢⴰⵔⴹ ⵛⴰ ⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT22_12","070_22_12","MAT","22","12","12","ⵉⵏⵏⴰ ⴰⵙ: ‘ⴰ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ, ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⵓⴷⴼⴻⴷ ⴷⴰⵏⵉⵜⴰ ⴱⵍⴰ ⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵔⴰⵔ?’ ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⵉⴳⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MT22_13","070_22_13","MAT","22","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵓⵊⴻⴵⵉⴷ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ: ‘ⵛⴰⵔⴼⴻⵎ ⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵎ ⵜ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴰⴵⴻⵙⵜ ⵎⴰⵏⵉ ⵖⴰ ⵉⵍⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ.’ ");
INSERT INTO rift_vpl VALUES ("MT22_14","070_22_14","MAT","22","14","14","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵎⴰⵛⴰ ⴷⵔⵓⵙ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT22_15","070_22_15","MAT","22","15","15","ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵎⵛⴰⵡⴰⵔⴻⵏ ⵎⴰⵎⵎⴻⵛ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT22_16","070_22_16","MAT","22","16","16","ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⵀⵍⴰ ⵎⴰ ⵜⴻⵙⵙⴻⵍⵇⵉⴷ ⵓⵍⴰ ⵅ ⵢⵉⵊⵊ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT22_17","070_22_17","MAT","22","17","17","ⵉⵡⴰ ⵉⵏⵉ ⴰⵏⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵡⴰⵍⵉⴷ ⵛⴻⴽ: ⵎⴰ ⵉⵃⴻⵇⵇ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⴹⴹⴰⵔⵉⴱⴰ ⵉ ⵇⴰⵢⵚⴰⵔ ⵏⵉⵖ ⵍⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT22_18","070_22_18","MAT","22","18","18","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵏ ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MT22_19","070_22_19","MAT","22","19","19","ⵙⴻⵛⵛⵏⴻⵎ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵓⵇⵉⵢⵢⴰ ⵏ ⴷⵉⵏⴰⵔ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⵅ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ!” ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT22_20","070_22_20","MAT","22","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵉ ⵢⵉⵍⴰⵏ ⵜⴰⵚⵡⵉⵔⵜ-ⴰ ⴷ ⵜⵉⵔⴰ-ⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT22_21","070_22_21","MAT","22","21","21","ⵏⵏⴰⵏ ⴰⵙ: “ⵏ ⵇⴰⵢⵚⴰⵔ!” ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵛⴻⵎ ⵉ ⵇⴰⵢⵚⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵇⴰⵢⵚⴰⵔ ⵓ ⵉ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT22_22","070_22_22","MAT","22","22","22","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵜⴱⴻⵀⵜⴻⵏ, ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵔⵓⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT22_23","070_22_23","MAT","22","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ: ‘ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵓⴷⴰⵔⵜ ⵉ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ!’, ⵓⵛⴰ ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ");
INSERT INTO rift_vpl VALUES ("MT22_24","070_22_24","MAT","22","24","24","ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵎⵓⵙⴰ ⴰⵇⴰ ⵉⵏⵏⴰ: ‘ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵃⴻⴷ ⵡⴰⵔ ⴷⴷ-ⵢⴻⵊⵊⵉ ⴱⵓ ⵜⴰⵔⵡⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵓⵎⴰⵙ ⴰⴷ ⵉⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⴽⵉⴷⴻⵙ ⴷⴷ-ⵢⴻⵊⵊ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵓⵎⴰⵙ.’ ");
INSERT INTO rift_vpl VALUES ("MT22_25","070_22_25","MAT","22","25","25","ⵜⵓⵖⴰ ⵖⴰⵔⵏⴻⵖ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ. ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵎⵍⴻⵛ, ⵉⵎⵎⵓⵜ. ⵓⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵢⴻⵊⵊⵉ ⵛⴰ ⵜⴰⵔⵡⴰ, ⴰⵇⴰ ⵉⵊⵊⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT22_26","070_22_26","MAT","22","26","26","ⴰⵎⵎⵓ ⵉ ⵉⵎⵎⵓⵜ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⵍ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("MT22_27","070_22_27","MAT","22","27","27","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴻⵎⵎⵓⵜ ⵜⴻⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT22_28","070_22_28","MAT","22","28","28","ⵉ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴷⵉ ⵜⵏⵓⴽⵔⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵡⵢⴻⵏ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("MT22_29","070_22_29","MAT","22","29","29","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵡⴻⴷⴷⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MT22_30","070_22_30","MAT","22","30","30","ⵎⵉⵏⵣⵉ ⴷⵉ ⵜⵏⵓⴽⵔⴰ ⵡⴰⵔ ⵜⵜⵉⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MT22_31","070_22_31","MAT","22","31","31","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵏⵓⴽⵔⴰ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵛⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MT22_32","070_22_32","MAT","22","32","32","‘ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ!’ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵎⴰⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT22_33","070_22_33","MAT","22","33","33","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵍⵖⴰⵛⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵜⴱⴻⵀⵜⴻⵏ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT22_34","070_22_34","MAT","22","34","34","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⴱⴻⵍⵍⴻⵄ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ, ⵎⵓⵏⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT22_35","070_22_35","MAT","22","35","35","ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵎⵍⵉⵃ, ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵊⴰⵔⵔⴻⴱ: ");
INSERT INTO rift_vpl VALUES ("MT22_36","070_22_36","MAT","22","36","36","“ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵎⴰⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT22_37","070_22_37","MAT","22","37","37","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MT22_38","070_22_38","MAT","22","38","38","ⴷ ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("MT22_39","070_22_39","MAT","22","39","39","ⵜⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵔⵡⴻⵙ ⴷⴰⵢⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ: ‘ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⴻⴼ ⵏⵏⴻⵛ’. ");
INSERT INTO rift_vpl VALUES ("MT22_40","070_22_40","MAT","22","40","40","ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴻⵚⵚⴰ-ⵢⴰ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT22_41","070_22_41","MAT","22","41","41","ⴰⵎ ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⵢⴰⵙⵓⵄ, ");
INSERT INTO rift_vpl VALUES ("MT22_42","070_22_42","MAT","22","42","42","ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵅ ⵍⵎⴰⵙⵉⵃ? ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⵎⵉⵙ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ!” ");
INSERT INTO rift_vpl VALUES ("MT22_43","070_22_43","MAT","22","43","43","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴷⴰⵡⵓⴷ ⴰⴷ ⴰⵙ ⵉⵙⴻⵎⵎⴰ ⵣⵉ ⴰⵔⵔⵓⵃ ‘ⵙⵉⴷⵉ’, ⴰⵎ ⵉⵇⵇⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("MT22_44","070_22_44","MAT","22","44","44","‘ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ⵇⵇⵉⵎ-ⴷⴷ ⵅ ⵓⴼⵓⵙⵉ ⵉⵏⵓ ⴰⵍ ⵖⴰ ⴳⴳⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("MT22_45","070_22_45","MAT","22","45","45","ⵎⴰⵍⴰ ⴷⴰⵡⵓⴷ ⵉⵍⴰⵖⴰ ⴰⵙ ‘ⵙⵉⴷⵉ’, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⴷ ⵎⵎⵉⵙ?” ");
INSERT INTO rift_vpl VALUES ("MT22_46","070_22_46","MAT","22","46","46","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔ ⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⵣⴻⵄⵄⴻⵎ ⵉⵜⵜⵙⴻⵇⵙⴰ ⵜ ⵛⴰ ⵄⴰⴷ ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT23_1","070_23_1","MAT","23","1","1","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵙⵓⵄ ⴰⴽ-ⴷ ⵍⵖⴰⵛⵉ ⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MT23_2","070_23_2","MAT","23","2","2","ⵉⵏⵏⴰ: “ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵙⵙⵖⵉⵎⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("MT23_3","070_23_3","MAT","23","3","3","ⵙ ⵓⵢⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵛⴻⴱⴱⴰⵔⴻⵎ, ⴳⴳⴻⵎ ⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵅⵅⴰ ⵇⵇⴰⵔⴻⵏ ⵜ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_4","070_23_4","MAT","23","4","4","ⵜⵜⵛⴻⴷⴷⴰⵏ ⵍⴻⵃⵎⴻⵍ ⵉⴹⴻⵇⵍⴻⵏ, ⵙⵙⵔⵓⵙⴰⵏ ⵜⴻⵏ ⵅ ⵜⵖⴰⵔⴷⵉⵏ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵏ ⵓⵍⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⴹⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("MT23_5","070_23_5","MAT","23","5","5","ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ, ⵜⵜⴻⴳⴳⴻⵏ ⵜⴻⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵥⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵃⴻⵣⵣⴰⵏⵉⵏ ⵏⵙⴻⵏ ⵏ ⵜⵥⴰⴵⵉⵜ ⴷ ⵉⵎⵉⵔⵉⵡⴻⵏ ⵓⵛⴰ ⵜⵉⵛⵔⵓⵔⵉⵏ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵓⴱⴻⵃⵍⵓⵍ ⵏ ⵍⴽⴰⵛⵏⵉ ⵏ ⵜⵥⴰⴵⵉⵜ ⵏⵙⴻⵏ, ⴳⴳⵉⵏ ⵜⴻⵏⵜ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_6","070_23_6","MAT","23","6","6","ⵏⵉⵜⵏⵉ ⵜⵜⴻⵅⵙⴻⵏ ⵉⵎⵓⵛⴰⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵖⴰⵔ ⵍⴻⴼⵔⵓⵃ ⵓ ⵍⴻⴽⵔⴰⵙⵉ ⵉⵚⴻⴱⵃⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("MT23_7","070_23_7","MAT","23","7","7","ⵓⵍⴰ ⴷ ⵙⵙⵍⴰⵎ ⴷⵉ ⵍⴻⵙⵡⴰⵇ, ⵓⵛⴰ ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵍⴰⵖⴰⵏ ⵉⵡⴷⴰⵏ ‘ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("MT23_8","070_23_8","MAT","23","8","8","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴰⵡⴻⵎ ⵍⴰⵖⴰⵏ ‘ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ!’, ⵎⵉⵏⵣⵉ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵡⴻⵎ ⴷ ⵉⵊⵊⴻⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⴷ ⴰⵡⵎⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_9","070_23_9","MAT","23","9","9","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴰⵡⴻⵎ ⵍⴰⵖⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ‘ⴰ ⴱⴰⴱⴰ!’, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_10","070_23_10","MAT","23","10","10","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴰⵡⴻⵎ ⵍⴰⵖⴰⵏ ‘ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ’, ⵎⵉⵏⵣⵉ ⵉⵊⵊⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴳⴻⵡⵡⴰⴷ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("MT23_11","070_23_11","MAT","23","11","11","ⵎⴰⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵡⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT23_12","070_23_12","MAT","23","12","12","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵓⵄⵍⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵥⵉ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵎⴻⵥⵢⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT23_13","070_23_13","MAT","23","13","13","“ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵜⵓⴷⵔⵉⵏ ⵏ ⵜⵉⵊⵊⴰⵍ ⴰⵎ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵥⴰⴵⴰⵜⵉⵏ ⵏⵡⴻⵎ ⵜⵉⵣⵉⵔⴰⵔⵉⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵍⵃⵓⴽⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_14","070_23_14","MAT","23","14","14","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴱⴻⵍⵍⵄⴻⵎ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵉⵡⴷⴰⵏ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜⵜ ⵜᵉⵜⵜⵉⴷⴼⴻⵎ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_15","070_23_15","MAT","23","15","15","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⴽⴻⵎ ⵅ ⵍⴱⴰⵔⵔ ⵓ ⵅ ⵍⴻⴱⵃⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⴻⵎ ⵉⵊⵊⴻⵏ ⴷ ⴰⵎⵄⴰⵛⴰⵔ ⵏ ⴷⴷⵉⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵓ ⵅⵎⵉ ⵉ ⴽⵉⴷⵡⴻⵎ ⵖⴰ ⵢⵉⵍⵉ, ⵜᵉⵜⵜⴰⵔⵔⴰⵎ ⵜ ⴷ ⵎⵎⵉⵙ ⵏ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵎⴰⵀⵓ ⵅ ⴽⴻⵏⵏⵉⵡ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT23_16","070_23_16","MAT","23","16","16","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵡⴻⵏⵏⵉ ⵉⵊⵊⵓⴵⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴰⵇⴰ ⵜⴰⵊⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⴻⵙⵙⴻⴽⴽⵡⵉ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵊⵊⵓⴵⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵉⵍⴻⵙ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("MT23_17","070_23_17","MAT","23","17","17","ⴰ ⵉⴼⵖⴰⵍ, ⴰ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵎⵉⵏ ⵉⵙⴻⴽⴽⵡⴰⵏ ⴽⵜⴰⵔ, ⵓⵔⴻⵖ ⵏⵉⵖ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴻⵏⵏⵉ ⵜⴻⵙⵙⵇⴻⴷⴷⴻⵙ ⵓⵔⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("MT23_18","070_23_18","MAT","23","18","18","ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ: ‘ⵡⴻⵏⵏⵉ ⵉⵊⵊⵓⴵⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⵜⴰⵊⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵙⴻⴽⴽⵡⵉ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵊⵊⵓⴵⴻⵏ ⵙ ⵜⵎⴻⵡⵛⵉ ⵉ ⵅⴰⵙ ⵉⵎⵎⴰⵔⵙⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵉⵍⴻⵙ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("MT23_19","070_23_19","MAT","23","19","19","ⴰ ⵉⴼⵖⴰⵍ, ⴰ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵎⵉⵏ ⵉⵙⴻⴽⴽⵡⴰⵏ ⴽⵜⴰⵔ, ⵜⴰⵎⴻⵡⵛⵉ ⵏⵉⵖ ⴰⵄⴰⵍⵟⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵜⴰⵎⴻⵡⵛⵉ? ");
INSERT INTO rift_vpl VALUES ("MT23_20","070_23_20","MAT","23","20","20","ⵙ ⵓⵢⴰ ⵡⵉ ⵖⴰ ⵉⵊⵊⴰⴵⴻⵏ ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ, ⴰⵇⴰ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_21","070_23_21","MAT","23","21","21","ⵓ ⵡⵉ ⵖⴰ ⵉⵊⵊⴰⴵⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵊⵊⵓⴵ ⵖⴰⵔⴻⵙ ⵓ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_22","070_23_22","MAT","23","22","22","ⵓ ⵡⵉ ⵖⴰ ⵉⵊⵊⴰⴵⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_23","070_23_23","MAT","23","23","23","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵉⵛⴻⵎ ⵜⴰⵄⵛⴰⵔⵜ ⵏ ⵏⵏⴻⵄⵏⴰⵄ ⴷ ⵙⵙⴰⵏⵓⴵ ⴷ ⵍⵛⴻⵎⵎⵓⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵛⵇⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵍⵃⵓⴽⵎ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍ’ⵉⵎⴰⵏ. ⵉⵏⴰ ⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⵙⴻⵎⵎⵃⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT23_24","070_23_24","MAT","23","24","24","ⴰ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵏⴻⵏ ⵜⵉⵣⵉⵜ, ⵎⴰⵛⴰ ⵜⴻⵙⵙⵖⴻⴵⴰⵢⴻⵎ ⴰⵍⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT23_25","070_23_25","MAT","23","25","25","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵉⵣⴷⴰⴳⴻⵎ ⴱⴰⵔⵔⴰ ⵏ ⵍⴽⴰⵙ ⴷ ⵟⵟⴻⴱⵚⵉ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴰⵇⴰ ⵛⵛⵓⵔⴻⵏ ⵙ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_26","070_23_26","MAT","23","26","26","ⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ, ⵙⵉⵣⴷⴻⴳⴻⵎ ⴰⵎⴻⵣⵡⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵍⴽⴰⵙ ⴷ ⵟⵟⴻⴱⵚⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉⵣⴷⵉⴳ ⵓⵍⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_27","070_23_27","MAT","23","27","27","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⴳⴳⵉⵎ ⴰⵎ ⵢⵉⵎⴻⴹⵍⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⵉⵢⵢⴰⵔⴻⵏ, ⵜⵜⴱⴰⵏⴻⵏ ⴷ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴰⵇⴰ ⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵖⵙⴰⵏ ⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("MT23_28","070_23_28","MAT","23","28","28","ⴰⵎⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵜⴻⴹⵀⴰⵔⴻⵎ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴰⵇⴰ ⵜⴻⵛⵛⵓⵔⴻⵎ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵓ ⵙ ⵏⵏⵉⴼⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("MT23_29","070_23_29","MAT","23","29","29","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴱⴻⵏⵏⴰⵎ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵜⵣⴻⵡⵡⵇⴻⵎ ⵍⵇⵓⴱⴱⴰⵜ ⵏ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT23_30","070_23_30","MAT","23","30","30","ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⵍⵉ ⵜⵓⵖⴰ ⵏⴻⴵⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵔ ⵏⵛⴰⵔⵔⴻⵛ ⴷⴻⴳ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MT23_31","070_23_31","MAT","23","31","31","ⵙ ⵓⵢⴰ ⵜⵛⴻⵀⵀⴷⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT23_32","070_23_32","MAT","23","32","32","ⵉⵡⴰ ⴽⴻⵎⵎⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⵍⴻⵇⵢⴰⵙ ⵏ ⵎⵉⵏ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("MT23_33","070_23_33","MAT","23","33","33","ⴰ ⵉⵍⴻⴼⵙⴰⵡⴻⵏ, ⵜⴰⵔⵡⴰ ⵏ ⵉⴼⵉⵖⵔⴰⵏ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵎ ⵣⵉ ⵍⵃⵓⴽⵎ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ? ");
INSERT INTO rift_vpl VALUES ("MT23_34","070_23_34","MAT","23","34","34","ⵙ ⵓⵢⴻⵏⵏⵉ ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ. ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵜⴻⵏⵖⴻⵎ, ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵜⵚⴻⵍⵍⴱⴻⵎ ⵓ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵜⵀⴻⵜⵜⴽⴻⵎ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵜⴰⵥⵥⵍⴻⵎ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("MT23_35","070_23_35","MAT","23","35","35","ⴰⵍⴰⵎⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵉ ⵉⵙⵙⵉⵣⵣⵍⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵀⴰⴱⵉⵍ ⴰⵎⵙⴻⴳⴳⴰⴷ ⴰⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵎⵉⵙ ⵏ ⴱⵉⵔⵉⵅⵢⴰ, ⵉ ⵜⴻⵏⵖⵉⵎ ⵊⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT23_36","070_23_36","MAT","23","36","36","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏⵜ ⵅ ⵊⵊⵉⵍ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT23_37","070_23_37","MAT","23","37","37","“ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵛⴻⵎ ⵉ ⵉⵏⴻⵇⵇⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵢⴰⵔⴻⵊⵊⵎⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵎ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵢⴰⵥⵉⴹⵜ ⵜⴻⴳⴳⴰ ⵉⴼⵉⴵⵓⵙⴻⵏ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT23_38","070_23_38","MAT","23","38","38","ⵅⵣⴰⵔ, ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵊⵊ ⵉ ⵛⴻⵎ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("MT23_39","070_23_39","MAT","23","39","39","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔⴻⵎ ⴰⵍ ⵖⴰ ⵜⵉⵏⵉⵎ: ‘ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ.’”   * ");
INSERT INTO rift_vpl VALUES ("MT24_1","070_24_1","MAT","24","1","1","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵓⵢⵓⵔ, ⵎⴰⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵙⵙⴻⵛⵏⴻⵏ ⴰⵙ ⵍⴻⴱⵏⵉⵢⵢⴰⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ.   * ");
INSERT INTO rift_vpl VALUES ("MT24_2","070_24_2","MAT","24","2","2","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵥⵔⵉⵎ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ? ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⴷⴰ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵅ ⵡⴻⵥⵔⵓ ⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴰⵔ ⵉⵜⵜⵏⴻⵀⴷⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT24_3","070_24_3","MAT","24","3","3","ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵇⵇⵉⵎ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⵜⵜⴻⵎⵙⴰⵡⴰⵍⴰⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵉⵏⵉ ⴰⵏⴻⵖ, ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ ⴰⵢⴰ ⵓ ⵎⴰⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵛ ⵓ ⵏ ⵇⴻⵟⵟⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ?” ");
INSERT INTO rift_vpl VALUES ("MT24_4","070_24_4","MAT","24","4","4","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴷⴷⴻⵄ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT24_5","070_24_5","MAT","24","5","5","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵍⵎⴰⵙⵉⵃ!’, ⵓⵛⴰ ⴰⴷ ⵅⴻⴷⵄⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_6","070_24_6","MAT","24","6","6","ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵅ ⴳⴰⵔⵔⴰⵜ ⵓ ⵅ ⵍⴻⵅⴱⵓⵔⴰⵜ ⵏ ⵉⵎⴻⵏⵖⴰⵏ. ⵖⴰⵔⵡⴻⵎ ⴰⵇⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⵙ ⵓⵖⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT24_7","070_24_7","MAT","24","7","7","ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵖⴻⵡⵡⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵓ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵍⴰⵥ ⴷ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵢⴻⵡⵄⴰⵔⴻⵏ ⴷ ⵉⵏⵀⴻⵣⵣⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴰ ⴷ ⴷⵉⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("MT24_8","070_24_8","MAT","24","8","8","ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("MT24_9","070_24_9","MAT","24","9","9","ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵎⴻⵃⵏⴻⵜ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⵖⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵛⴰⵔⵀⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MT24_10","070_24_10","MAT","24","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ ⵡⴰⵟⵟⴰⵙ, ⴰⴷ ⵛⴰⵔⵀⴻⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⵙⴻⵍⵍⵎⴻⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT24_11","070_24_11","MAT","24","11","11","ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⵡⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_12","070_24_12","MAT","24","12","12","ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⴷ ⵜⵓⴷⵔⵓⵙ ⵜⴰⵢⵔⵉ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ,    ");
INSERT INTO rift_vpl VALUES ("MT24_13","070_24_13","MAT","24","13","13","ⵎⴰⵛⴰ ⵡⵉ ⵖⴰ ⵉⵚⴱⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT24_14","070_24_14","MAT","24","14","14","ⵍⴻⵅⴱⴰⵔ-ⴰ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵏⴻⴳⴳⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MT24_15","070_24_15","MAT","24","15","15","“ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵏⵏⵄⵉ ⵏ ⵡⴰⵔⴻⵢⵢⴻⴱ, ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵏⴰⴱⵉ ⴷⴰⵏⵉⵢⴰⵍ, ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ - ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵖⴰⵔⴻⵏ ⴰⴷ ⵉⴼⵜⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("MT24_16","070_24_16","MAT","24","16","16","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵊⵊⴻⵎ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT24_17","070_24_17","MAT","24","17","17","ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⵉ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MT24_18","070_24_18","MAT","24","18","18","ⵓ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵯⵉⵍ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_19","070_24_19","MAT","24","19","19","ⵓⵛⵜ ⵅ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴷ ⵜⵉⵏⵏⵉ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("MT24_20","070_24_20","MAT","24","20","20","ⵥⴰⴵⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵏⵡⴻⵎ ⴷⵉ ⵍⵎⴻⵛⵜⴰ ⵏⵉⵖ ⴷⵉ ⵙⵙⴻⴱⵜ, ");
INSERT INTO rift_vpl VALUES ("MT24_21","070_24_21","MAT","24","21","21","ⵎⵉⵏⵣⵉ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵡⴰⵔ ⵉⵎⵙⴰⵔⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⴻⴵⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ ⵓ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("MT24_22","070_24_22","MAT","24","22","22","ⵎⵍⵉ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵎⴻⵥⵢⴻⵏ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵎⴻⵥⵢⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT24_23","070_24_23","MAT","24","23","23","ⵎⴰⵍⴰ ⵉⵏⵏⴰ ⴰⵡⴻⵎ ⵃⴻⴷ: ‘ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴷⴰ ⵍⵎⴰⵙⵉⵃ!’ ⵏⵉⵖ: ‘ⴰⵇⴰ-ⵜ ⴷⵉⵀⴰ!’ ⵡⴰⵔ ⵜ ⵜⵜⵉⵎⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT24_24","070_24_24","MAT","24","24","24","ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵎⴰⵙⵉⵃⴻⵏ ⵉⴼⴰⵍⵙⵓⵜⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵎⵖⴰⵔⴻⵏⵜ, ⵃⵉⵎⴰ, ⵎⵍⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ, ⴰⴷ ⵅⴻⴷⵄⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT24_25","070_24_25","MAT","24","25","25","ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MT24_26","070_24_26","MAT","24","26","26","ⵎⴰⵍⴰ ⵏⵏⴰⵏ ⴰⵡⴻⵎ: ‘ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⴻⵅⵍⴰ!’, ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⵎ ⵛⴰ ⴷⵉⵏ, ⵏⵉⵖ: ‘ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⴰⵅⴻⵍ ⵉ ⵡⴻⵅⵅⴰⵎ!’, ⵡⴰⵔ ⵜⵜ ⵜⵜⵉⵎⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT24_27","070_24_27","MAT","24","27","27","ⵎⵉⵏⵣⵉ ⴰⵎ ⵡⴰⵊⵊⴰⵊ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵛⵛⴰⵔⵇ ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⵜⴰⴼⴰⵡⵜ ⴰⵍ ⵍⵖⴰⵔⴱ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵡⴰⵙⵉⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT24_28","070_24_28","MAT","24","28","28","ⵎⴰⵏⵉ ⵖⴰ ⵜⵉⵍⵉ ⴰⵔⵔⵉⵎⴻⵜ ⴷⵉⵀⴰ ⴰⴷ ⵎⵓⵏⴻⵏ ⵉⴳⵉⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT24_29","070_24_29","MAT","24","29","29","“ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⴷ ⵜⴱⴰⵔⵛⴻⵏ ⵜⴼⵓⵛⵜ ⵓ ⵜⴰⵣⵉⵔⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵛ ⵄⴰⴷ ⵟⵟⵢⴰ ⵏⵏⴻⵙ ⵓ ⵉⵜⵔⴰⵏ ⴰⴷ ⴷⴷ-ⵡⴹⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵚⵚⵓⵍⴰⵟⴰⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT24_30","070_24_30","MAT","24","30","30","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵜⴻⴹⵀⴰⵔ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵡⵜⴻⵏⵜ ⴰⴳⴻⵊⴷⵓⵔ ⵓⵛⴰ ⴰⴷ ⵥⴰⵔⴻⵏⵜ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ ⵅ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵙ ⵊⵊⴻⵀⴷ ⵓ ⵙ ⵓⵄⵓⴵⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_31","070_24_31","MAT","24","31","31","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵙ ⵍⵃⴻⵙⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵙⵙⵎⵓⵏⴻⵏⵜ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵍ ⵡⴻⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT24_32","070_24_32","MAT","24","32","32","“ⵍⴻⵎⴷⴻⵎ ⵣⴻⴳ ⵓⵎⴻⴷⵢⴰ ⵏ ⵡⴰⵔⵜⵓ: ⵅⵎⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⴷ ⵉⵍⴻⵇⵇⴰⵖⴻⵏ, ⴰⴷ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⵉⴼⵔⴰⵢ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴰⵏⴻⴱⴷⵓ ⵢⵓⴷⴻⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MT24_33","070_24_33","MAT","24","33","33","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ, ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ, ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT24_34","070_24_34","MAT","24","34","34","“ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵊⵊⵉⵍ-ⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵓ ⴰⵍ ⵖⴰ ⵉⵎⵙⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MT24_35","070_24_35","MAT","24","35","35","ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵄⴷⵓⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⵄⴻⴷⴷⵓⵏ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("MT24_36","070_24_36","MAT","24","36","36","ⵎⴰⵛⴰ ⵅ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵉⵖ ⵅ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵓⵍⴰ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⵖⵉⵔ ⴱⴰⴱⴰ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_37","070_24_37","MAT","24","37","37","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴵⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⵓⵃ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵖⴰⵔ ⵜⵡⴰⵙⵉⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT24_38","070_24_38","MAT","24","38","38","ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵇⴱⴻⵍ ⵟⵟⵓⴼⴰⵏ, ⵜⵜᵉⵜⵜⴻⵏ, ⵙⴻⵙⵙⴻⵏ, ⵎⴻⴵⵛⴻⵏ ⵓ ⵙⵙⵎⴻⴵⴰⵛⴻⵏ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵢⵓⴷⴻⴼ ⵏⵓⵃ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ,    ");
INSERT INTO rift_vpl VALUES ("MT24_39","070_24_39","MAT","24","39","39","ⵓⵛⴰ ⵡⴰⵔ ⵓⵛⵉⵏ ⵡⴰⵍⵓ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵟⵟⵓⴼⴰⵏ, ⵉⵎⵃⴰ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵖⴰⵔ ⵜⵡⴰⵙⵉⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT24_40","070_24_40","MAT","24","40","40","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵜⵏⴰⵢⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵉⵊⵊⴻⵏ ⴰⴷ ⵜ ⴽⵙⵉⵏ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜ ⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT24_41","070_24_41","MAT","24","41","41","ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵃⴰⵔⵢⴻⵏⵜ ⵙ ⵜⵙⵉⵔⵜ, ⵉⵛⵜⴻⵏ ⴰⴷ ⵜⵜ ⴽⵙⵉⵏ ⵓ ⵜⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜⵜ ⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT24_42","070_24_42","MAT","24","42","42","ⵙ ⵓⵢⴰ ⵃⴹⴰⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴷⵉ ⵎⴰⵏ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉⵜⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT24_43","070_24_43","MAT","24","43","43","ⵎⴰⵛⴰ ⵙⵙⵏⴻⵎ ⴰⵢⴰ: ⵎⴰⵍⴰ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵙⵙⴻⵏ ⴷⵉ ⵎⴰⵏ ⵃⴻⵟⵟⵓ ⵏ ⴵⵉⵍⴻⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵛⴻⴼⴼⴰⵔ, ⵉⵍⵉ ⵉⵇⵇⵉⵎ ⵉⵃⴻⵟⵟⴰ, ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_44","070_24_44","MAT","24","44","44","ⵙ ⵓⵢⴰ, ⵉⵍⵉⵎ ⵜⵡⴻⵊⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⴰⵔ ⵜⵜ ⵜᵉⵜⵜⵔⵉⵊⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT24_45","070_24_45","MAT","24","45","45","“ⵡⵉ ⵉⴵⴰⵏ ⵅⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵜⵉⵇⵇⵉ ⴷ ⴰⵎⵉⵖⵉⵙ ⵉ ⵉⴳⴳⴰ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴹⴰ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MT24_46","070_24_46","MAT","24","46","46","ⵙⵙⴻⵄⴷ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴼⴻⵏ ⵙⵉⴷⵉⵙ ⵉⵍⵀⴰ ⴰⵎⵎⵓ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_47","070_24_47","MAT","24","47","47","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⴷ ⵜ ⵉⴳⴳ ⵅ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT24_48","070_24_48","MAT","24","48","48","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: ‘ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵄⴻⵟⵟⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ!’, ");
INSERT INTO rift_vpl VALUES ("MT24_49","070_24_49","MAT","24","49","49","ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵛⵛⴰⵜ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵛⵛ ⴰⴷ ⵉⵙⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵙⴽⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT24_50","070_24_50","MAT","24","50","50","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙⵉⴷⵉⵙ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵡⴰⵔ ⵜ ⵉⵜⵜⵔⵉⵊⵉ ⵓ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("MT24_51","070_24_51","MAT","24","51","51","ⴰⴷ ⵜ ⵉⵇⴻⵙⵙ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⵎⵏⴰⴼⵇⴻⵏ. ⴷⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT25_1","070_25_1","MAT","25","1","1","“ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵄⴻⵛⵔⴰ ⵏ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵉⵡⵢⴻⵏⵜ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵙⴻⵏⵜ, ⴼⴼⵖⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵍⵇⴻⵏⵜ ⴰⴽ-ⴷ ⵡⴻⵙⵍⵉ ⴷ ⵜⴻⵙⵍⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_2","070_25_2","MAT","25","2","2","ⵅⴻⵎⵙⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴷ ⵜⵉⵎⵉⵖⵉⵙⵉⵏ ⵓ ⵅⴻⵎⵙⴰ ⴷ ⵜⵉⴼⵖⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("MT25_3","070_25_3","MAT","25","3","3","ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⴼⵖⴰⵍ ⴽⵙⵉⵏⵜ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵙⴻⵏⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵡⵢⵉⵏⵜ ⵛⴰ ⵣⵣⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_4","070_25_4","MAT","25","4","4","ⵜⵉⵎⵉⵖⵉⵙⵉⵏ ⵉⵡⵢⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⵣⴻⵛⵜ ⴷⵉ ⵜⵣⵉⵢⵢⴰⵜⵉⵏ ⵏⵙⴻⵏⵜ ⴰⴽ-ⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_5","070_25_5","MAT","25","5","5","ⵍⴰⵎⵉ ⵉⵄⴹⴻⵍ ⵓⵎⵓⵍⴰⵢ, ⴱⴷⴰⵏⵜ ⵜⵜⵏⵓⴷⵓⵎⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⵟⵟⵚⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_6","070_25_6","MAT","25","6","6","ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴵⵉⵍⴻⵜ ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵖⵓⵢⵢⵉⵜ: ‘ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴰⵎⵓⵍⴰⵢ ⵢⵓⵙⴰ-ⴷⴷ, ⴼⴼⵖⴻⵎ-ⴷⴷ, ⴰⴷ ⵜ ⵜⴻⵍⵇⴰⵎ!’ ");
INSERT INTO rift_vpl VALUES ("MT25_7","070_25_7","MAT","25","7","7","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏⵜ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵏⵏⵉ, ⵙⵙⴻⵡⵊⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_8","070_25_8","MAT","25","8","8","ⵜⵉⴼⵖⴰⵍ ⵏⵏⴰⵏⵜ ⵉ ⵜⵎⵉⵖⵉⵙⵉⵏ: ‘ⵡⵛⴻⵏⵜ ⴰⵏⴻⵖ ⵣⵉ ⵣⵣⴻⵛⵜ ⵏⴽⴻⵏⵜ ⵎⵉⵏⵣⵉ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵏⴻⵖ ⵅⴻⵙⵢⴻⵏⵜ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_9","070_25_9","MAT","25","9","9","ⴰⵔⵔⵉⵏⵜ-ⵉ-ⴷⴷ ⵅⴰⵙⴻⵏⵜ ⵜⵎⵉⵖⵉⵙⵉⵏ, ⵏⵏⴰⵏⵜ: ‘ⵄⴻⵎⵎⴰⵔⵚ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵇⴻⴷⴷⵉ ⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⴽⴻⵏⵏⵉⵏⵜ. ⵔⵓⵃⴻⵏⵜ ⵖⴰⵔ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵖⴻⵏⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_10","070_25_10","MAT","25","10","10","ⵍⴰⵎⵉ ⵔⵓⵃⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⵃⵉⵎⴰ ⴰⴷ ⵙⵖⴻⵏⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⵓⵍⴰⵢ, ⵓ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴻⵊⴷⴻⵏ ⵓⴷⴼⴻⵏⵜ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵡⵓⵔⴰⵔ ⵓⵛⴰ ⵜⴱⴻⵍⵍⴻⵄ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_11","070_25_11","MAT","25","11","11","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵙⵉⵏⵜ ⵜⴻⵄⵣⴰⵔⵉⵢⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ, ⵇⵇⴰⵔⴻⵏⵜ: ‘ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵔⵣⴻⵎ ⴰⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("MT25_12","070_25_12","MAT","25","12","12","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⴽⴻⵏⵜ ⵉⵏⵉⵖ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵏⵜ ⵙⵙⵉⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_13","070_25_13","MAT","25","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵃⴹⴰⵎ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴰⵙⵙ ⵓⵍⴰ ⴷ ⵜⴰⵙⴰⵄⵄⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT25_14","070_25_14","MAT","25","14","14","“ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵙⴰⴼⴰⵔ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴽⴻⵍⵍⴻⴼ ⵉ-ⵜⴻⵏ ⵅ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT25_15","070_25_15","MAT","25","15","15","ⵉⵡⵛⴰ ⵉ ⵢⵉⵊⵊⴻⵏ ⵅⴻⵎⵙⴰ ⵜⴰⵍⵉⵏⵜ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵜⵏⴰⵢⴻⵏ, ⵉ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵛⵜⴻⵏ ⵏ ⵜⴰⵍⵉⵏⵜ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ, ⵉⵙⴰⴼⴰⵔ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MT25_16","070_25_16","MAT","25","16","16","ⵉⵔⵓⵃ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵅⴻⵎⵙⴰ ⵜⴰⵍⵉⵏⵜ, ⵉⵙⴻⴱⴱⴻⴱ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵢⴰⵔⴱⴻⵃ ⵅⴻⵎⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("MT25_17","070_25_17","MAT","25","17","17","ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵍⵉⵏⵜ, ⵢⴰⵔⴱⴻⵃ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT25_18","070_25_18","MAT","25","18","18","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ, ⵉⵔⵓⵃ, ⵉⵖⵣⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ⴱⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT25_19","070_25_19","MAT","25","19","19","ⵍⴰⵎⵉ ⵜⴻⵄⴷⵓ ⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ ⵢⵓⵙⴰ-ⴷⴷ ⴱⴰⴱ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MT25_20","070_25_20","MAT","25","20","20","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵅⴻⵎⵙⴰ ⵜⴰⵍⵉⵏⵜ, ⵢⵉⵡⵉ-ⴷⴷ ⵅⴻⵎⵙⴰ ⵜⴰⵍⵉⵏⵜ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵅⴻⵎⵙⴰ ⵜⴰⵍⵉⵏⵜ, ⴰⵇⴰ ⴷⴰ, ⴰⵔⴻⴱⵃⴻⵖ ⵅⴻⵎⵙⴰ ⵏⵏⴻⵖⵏⵉ ⴽⵜⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_21","070_25_21","MAT","25","21","21","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ‘ⵎⵍⵉⵃ ⵉ ⵜⴻⴳⴳⵉⴷ, ⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵅ ⴷⵔⵓⵙ, ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⵅ ⵡⴰⵟⵟⴰⵙ, ⴰⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_22","070_25_22","MAT","25","22","22","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵍⵉⵏⵜ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵜⴻⵡⵛⵉⴷ ⴰⵢⵉ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵍⵉⵏⵜ, ⴰⵇⴰ ⴰⵔⴻⴱⵃⴻⵖ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴽⵜⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_23","070_25_23","MAT","25","23","23","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ ⵏⵏⴻⵙ: ‘ⵎⵍⵉⵃ ⵉ ⵜⴻⴳⴳⵉⴷ, ⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵅ ⴷⵔⵓⵙ, ⴰⴷ ⴰⵛ ⴳⴳⴻⵖ ⵅ ⵡⴰⵟⵟⴰⵙ, ⴰⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵙⵉⴷⵉ ⵏⴻⴽⴽ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_24","070_25_24","MAT","25","24","24","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵉⵛⵜ ⵏ ⵜⴰⵍⵉⵏⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴱⵏⴰⴷⴻⵎ ⵜⵇⴻⵙⵃⴻⴷ, ⵜⵎⴻⵊⵊⴰⵔⴻⴷ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⵣⴰⵔⵔⵄⴻⴷ, ⵜⵢⴰⵔⵔⵡⴻⴷ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜᵉⵙⵙⴰⵔⵡⴰⵜⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT25_25","070_25_25","MAT","25","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ ⴳⴳⵯⴻⴷⴻⵖ ⵓⵛⴰ ⵔⵓⵃⴻⵖ, ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵖ ⵜⴰⵍⵉⵏⵜ ⵏⵏⴻⵛ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵖⴰⵛ ⵜⴻⵏⵏⵉ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_26","070_25_26","MAT","25","26","26","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙⵉⴷⵉ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ ⴰⵎⴻⵄⴳⵓⵣ, ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵎⵊⴰⵔⴻⵖ ⵎⴰⵏⵉ ⵡⴰⵔ ⵣⴰⵔⵄⴻⵖ ⵓ ⵢⴰⵔⵡⴻⵖ ⵎⴰⵏⵉ ⵡⴰⵔ ⵙⵙⴰⵔⵡⴻⵜⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("MT25_27","070_25_27","MAT","25","27","27","ⵅⴻⵏⵏⵉ ⵎⵍⵉ ⵜⵉⵡⵢⴻⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵏⵓ ⵖⴰⵔ ⵍⴱⴰⵏⴽⵓ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ, ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵏⵓ ⵙ ⴰⵔⵔⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("MT25_28","070_25_28","MAT","25","28","28","ⵙ ⵓⵢⴰ ⴽⴽⵙⴻⵎ ⴰⵙ ⵜⴰⵍⵉⵏⵜ ⵏⵏⵉ, ⴻⵡⵛ ⵉ-ⵜⵜ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⴻⵛⵔⴰ ⵜⴰⵍⵉⵏⵜ!’ ");
INSERT INTO rift_vpl VALUES ("MT25_29","070_25_29","MAT","25","29","29","ⵎⵉⵏⵣⵉ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ, ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT25_30","070_25_30","MAT","25","30","30","ⵏⴹⴰⵔⴻⵎ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⴱⴻⵟⵟⵍⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴰⴵⴻⵙⵜ ⵎⴰⵏⵉ ⵖⴰ ⵉⵍⵉⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT25_31","070_25_31","MAT","25","31","31","“ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵓ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT25_32","070_25_32","MAT","25","32","32","ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵎⵙⵙⴻⴱⴹⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⵎⴻⴽⵙⴰⵡ ⵉⵙⵙⴱⴻⵟⵟⴰ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵅ ⵉⵖⴰⵢⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT25_33","070_25_33","MAT","25","33","33","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵅ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵖⴰⵢⴹⴻⵏ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT25_34","070_25_34","MAT","25","34","34","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵉⵏⵉ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⵉⵏⵏⵉ ⵅ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ: ‘ⴰⵙⴻⵎ-ⴷⴷ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵣⵉ ⴱⴰⴱⴰ, ⵡⴰⵔⵜⴻⵎ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵡⴻⵊⴷⴻⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MT25_35","070_25_35","MAT","25","35","35","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⴰⵢⵉ ⵍⴰⵥ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴻⵛⵛⴻⵎ ⴰⵢⵉ. ⵜⵓⵖⴰ ⴼⴼⵓⴷⴻⵖ, ⵜⴻⵡⵛⵉⵎ ⴰⵢⵉ ⴰⴷ ⵙⵡⴻⵖ. ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵣⴻⴷⵖⴻⵎ ⴰⵢⵉ, ");
INSERT INTO rift_vpl VALUES ("MT25_36","070_25_36","MAT","25","36","36","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⵎ ⴰⵢⵉ, ⵜⵓⵖⴰ ⵀⴻⵍⵛⴻⵖ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵉⵊⴻⵎ-ⴷⴷ ⵅⴰⴼⵉ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⴽⴻⵏⵏⵉⵡ ⵜⵓⵙⵉⵎ-ⴷⴷ ⵖⴰⵔⵉ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_37","070_25_37","MAT","25","37","37","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵇⵇⴰⵔⴻⵏ: ‘ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴻⵍⵎⵉ ⵛⴻⴽ ⵏⴻⵥⵔⴰ ⵜⴵⵓⵥⴻⴷ ⵓⵛⴰ ⵏⴻⵙⵙⴻⵛⵛ ⵉ ⵛⴻⴽ, ⵏⵉⵖ ⵎⴻⵍⵎⵉ ⵛⴻⴽ ⵏⴻⵥⵔⴰ ⵜᵉⴼⴼⵓⴷⴻⴷ ⵓⵛⴰ ⵏⴻⵡⵛ ⴰⵛ ⴰⴷ ⵜⴻⵙⵡⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("MT25_38","070_25_38","MAT","25","38","38","ⵎⴻⵍⵎⵉ ⵛⴻⴽ ⵏⴻⵥⵔⴰ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵓⵛⴰ ⵏⴻⵙⵙⴻⵣⴷⴻⵖ ⵉ ⵛⴻⴽ, ⵏⵉⵖ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵓⵛⴰ ⵏⴻⵙⵙⵢⴰⵔⴹ ⵉ ⵛⴻⴽ? ");
INSERT INTO rift_vpl VALUES ("MT25_39","070_25_39","MAT","25","39","39","ⵎⴻⵍⵎⵉ ⵛⴻⴽ ⵏⴻⵥⵔⴰ ⵜⵀⴻⵍⵛⴻⴷ ⵏⵉⵖ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵓⵛⴰ ⵏⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⴽ?’ ");
INSERT INTO rift_vpl VALUES ("MT25_40","070_25_40","MAT","25","40","40","ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵓⵊⴻⴵⵉⴷ, ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵏⵉ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⵉⵏ ⵉ ⵜⴻⴳⴳⵉⵎ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵏⵓ, ⵉ ⵏⴻⵛⵛ ⵓⵎⵉ ⵜ ⵜⴻⴳⴳⵉⵎ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_41","070_25_41","MAT","25","41","41","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ: ‘ⴱⴻⵄⵄⴷⴻⵎ ⵅⴰⴼⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⵄⵍⴻⵏ, ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵏ ⵍⴻⴱⴷⴰ ⵉ ⵉⵡⴻⵊⴷⴻⵏ ⵉ ⵉⴱⵍⵉⵙ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT25_42","070_25_42","MAT","25","42","42","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⴰⵢⵉ ⵍⴰⵥ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵛⵛⴻⵎ, ⴼⴼⵓⴷⴻⵖ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⵎ ⴰⴷ ⵙⵡⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("MT25_43","070_25_43","MAT","25","43","43","ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵣⴻⴷⵖⴻⵎ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⵎ, ⵀⴻⵍⵛⴻⵖ ⵓ ⵜⵜⵡⴰⵃⴻⴱⵙⴻⵖ ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴻⵙⵙⵉⵊⴻⵎ ⵛⴰ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_44","070_25_44","MAT","25","44","44","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⴰⵔⵔⴻⵏ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴻⵍⵎⵉ ⵛⴻⴽ ⵏⴻⵥⵔⴰ ⵜⴻⴵⵓⵥⴻⴷ ⵏⵉⵖ ⵜᵉⴼⴼⵓⴷⴻⴷ ⵏⵉⵖ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵏⵉⵖ ⴷ ⴰⵄⴰⵔⵢⴰⵏ ⵏⵉⵖ ⵜⵀⴻⵍⵛⴻⴷ ⵏⵉⵖ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵅⴰⴽ ⵏⵙⴻⵅⵅⴰⵔ ⵛⴰ?’ ");
INSERT INTO rift_vpl VALUES ("MT25_45","070_25_45","MAT","25","45","45","ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵢⴰⵔⵔ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⵉⵏ ⵡⴰⵔ ⵜⴻⴳⴳⵉⵎ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵉⵏⵓ, ⵉ ⵏⴻⵛⵛ ⵓⵎⵉ ⵡⴰⵔ ⵜ ⵜⴻⴳⴳⵉⵎ ⵄⴰⵡⴻⴷ.’ ");
INSERT INTO rift_vpl VALUES ("MT25_46","070_25_46","MAT","25","46","46","ⴰⴷ ⵔⴰⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵍⴻⵄⴷⴰⴱ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT26_1","070_26_1","MAT","26","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵢⴰⵙⵓⵄ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("MT26_2","070_26_2","MAT","26","2","2","“ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵡⴰⵔⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵉⵍⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵓ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT26_3","070_26_3","MAT","26","3","3","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵇⴰⵢⴰⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("MT26_4","070_26_4","MAT","26","4","4","ⵓⵛⴰ ⵎⵛⴰⵡⴰⵔⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵟⵟⴼⴻⵏ ⵢⴰⵙⵓⵄ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT26_5","070_26_5","MAT","26","5","5","ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷⵉ ⵍⵄⵉⴷ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴽⴽⴰⵔ ⵓⵖⴻⵡⵡⴻⵖ ⴷⵉ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT26_6","070_26_6","MAT","26","6","6","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⴷⵉ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ, ");
INSERT INTO rift_vpl VALUES ("MT26_7","070_26_7","MAT","26","7","7","ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵙ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⴰⵍⴰⴱⴰⵙⵜⴻⵔ ⵉⵛⵛⵓⵔ ⵙ ⵉⵛⵜ ⵏ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵉⵖⵍⴰⵏ, ⵓⵛⴰ ⵜⴼⴰⵔⵔⴻⵖ ⵉ-ⵜⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵎ ⵉⵇⵇⵉⵎ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MT26_8","070_26_8","MAT","26","8","8","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵇⵇⴻⵙ ⴰⵙⴻⵏ ⵍⵃⴰⵍ ⴰⵟⵟⴰⵙ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵓⵎⵉ ⵜⴻⴵⴰ ⵜⵅⴻⵙⵙⴰⵔⵜ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("MT26_9","070_26_9","MAT","26","9","9","ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵣ ⵣⵣⴻⵛⵜ-ⴰ ⵏ ⵡⴻⴷⵀⴰⵏ ⵙ ⵜⵜⴰⵎⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⵉⵎⴻⵣⵍⴰⴹ.” ");
INSERT INTO rift_vpl VALUES ("MT26_10","070_26_10","MAT","26","10","10","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵣⵉⵢⵢⴰⵔⴻⵎ ⵅ ⵜⴻⵎⵖⴰⵔⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴻⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("MT26_11","070_26_11","MAT","26","11","11","ⵎⵉⵏⵣⵉ ⵉⵎⴻⵣⵍⴰⴹ ⴰⵇⴰ ⴰⵜⴻⵏ ⵍⴻⴱⴷⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⵜⵜⵉⵍⵉⵖ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MT26_12","070_26_12","MAT","26","12","12","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ, ⵎⴰⵍⴰ ⵜⴼⴰⵔⵔⴻⵖ-ⴷⴷ ⵣⵣⴻⵛⵜ-ⴰ ⵉ ⵡⴻⴷⵀⴰⵏ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ, ⴰⵇⴰ ⵜⴻⴳⴳⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵡⴻⵏⴹⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("MT26_13","070_26_13","MAT","26","13","13","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵣⵉ ⵍⴻⵅⴱⴰⵔ-ⴰ ⴰⵚⴻⴱⵃⴰⵏ ⵅⴰⴼⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵄⴰⵡⴻⴷ ⵅ ⵎⵉⵏ ⴷⴰⵢⵉ ⵜⴻⴳⴳⴰ, ⴷ ⵍⵉⴹⴰⵔⴻⵜ ⵉ ⵏⴻⵜⵜⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT26_14","070_26_14","MAT","26","14","14","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵍⵓⵃ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ, ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT26_15","070_26_15","MAT","26","15","15","ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⴻⵡⵛⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵙⴻⵍⵍⵎⴻⵖ ⵢⴰⵙⵓⵄ?” ⵓⵛⴰ ⵡⴰⵄⴷⴻⵏ ⵜ ⵙ ⵜⵍⴰⵜⵉⵏ ⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MT26_16","070_26_16","MAT","26","16","16","ⵙⵙⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⴻⵍⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT26_17","070_26_17","MAT","26","17","17","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ: “ⵎⴰⵏⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ ⵉ ⵛⴻⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ?” ");
INSERT INTO rift_vpl VALUES ("MT26_18","070_26_18","MAT","26","18","18","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴼⵍⴰⵏ, ⵉⵏⵉⵎ ⴰⵙ: ‘ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ ⵉⵇⵇⴰⵔ: ⴰⵇⴰ ⵍⵡⴻⵇⵜ ⵉⵏⵓ ⵜⵉⵡⴻⴹ-ⴷⴷ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴳⴳⴻⵖ ⴰⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ.’” ");
INSERT INTO rift_vpl VALUES ("MT26_19","070_26_19","MAT","26","19","19","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵉⵡⴻⵚⵚⴰ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵙⵙⴻⵡⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("MT26_20","070_26_20","MAT","26","20","20","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ, ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ ⴰⴽ-ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT26_21","070_26_21","MAT","26","21","21","ⴰⵎ ⵜⵜᵉⵜⵜⴻⵏ ⵏⵉⵜⵏⵉ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴰⵢⵉ ⵉⵖⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MT26_22","070_26_22","MAT","26","22","22","ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵛⴻⴹⵏⴻⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴱⴷⴰ ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ, ⴰ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("MT26_23","070_26_23","MAT","26","23","23","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⵙⵏⴻⵏ ⴰⴼⵓⵙ ⴰⴽⵉⴷⵉ ⴷⵉ ⵟⵟⴻⴱⵚⵉ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT26_24","070_26_24","MAT","26","24","24","ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵔⴰⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵜⵓⵔⴰ, ⵎⴰⵛⴰ ⵓⵛⵜ ⵅ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ⵉⵃⵍⴰ ⴰⵙ ⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵅⵍⵉⵇ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("MT26_25","070_26_25","MAT","26","25","25","ⵢⴰⵀⵓⴷⴰ, ⴰⵖⴻⴷⴷⴰⵔ, ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ, ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT26_26","070_26_26","MAT","26","26","26","ⴰⵎ ⵜⵓⵖⴰ ⵜⵜᵉⵜⵜⴻⵏ, ⵉⴽⵙⵉ ⵢⴰⵙⵓⵄ ⴰⵖⵔⵓⵎ ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴱⴰⵔⴻⴽ, ⵢⴰⵔⵥⴰ ⵉ-ⵜ, ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵉⵏⵏⴰ: “ⴽⵙⵉⵎ, ⵛⵛⴻⵎ, ⵜⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("MT26_27","070_26_27","MAT","26","27","27","ⵉⴽⵙⵉ ⵍⴽⴰⵙ, ⵉⵇⴰⴷⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜ, ⵉⵏⵏⴰ: “ⵙⵡⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MT26_28","070_26_28","MAT","26","28","28","ⵎⵉⵏⵣⵉ ⵡⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ ⵉ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("MT26_29","070_26_29","MAT","26","29","29","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵣⵉ ⵍⴻⵅⵅⵓ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵙⴻⵙⵙⴻⵖ ⵄⴰⴷ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵜⵜ ⵖⴰ ⵙⵡⴻⵖ ⵣⵉ ⵊⴷⵉⴷ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT26_30","070_26_30","MAT","26","30","30","ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵖⴻⵏⵏⵊⴻⵏ ⵉⵣⵍⵉ ⵏ ⵜⵜⴻⵙⴱⵉⵃ, ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MT26_31","070_26_31","MAT","26","31","31","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴰⵢⵉ ⵜⴻⵏⴷⴻⵔⴼⴻⵎ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⴰⴷ ⵡⵜⴻⵖ ⴰⵎⴻⴽⵙⴰⵡ, ⵓⵛⴰ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⴰⴷ ⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MT26_32","070_26_32","MAT","26","32","32","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵣⵡⴰⵔⴻⵖ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("MT26_33","070_26_33","MAT","26","33","33","ⵎⴰⵛⴰ ⴱⵓⵟⵔⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⴷⴰⵢⴻⴽ ⵉ ⵖⴰ ⵏⴷⴻⵔⴼⴻⵏ ⵎⴰⵔⵔⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵜⵜⴻⵏⴷⵔⵉⴼⴻⵖ ⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ!” ");
INSERT INTO rift_vpl VALUES ("MT26_34","070_26_34","MAT","26","34","34","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT26_35","070_26_35","MAT","26","35","35","ⴱⵓⵟⵔⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵎⵎⵜⴻⵖ ⴰⴽⵉⴷⴻⴽ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⴽⴽⴰⵔⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ.” ⴰⵎⵎⵓ ⵉ ⵏⵏⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT26_36","070_26_36","MAT","26","36","36","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵢⴰⵙⵓⵄ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵅⵉⵜⵙⵉⵎⴰⵏⵉⵢ, ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵇⵇⵉⵎⴻⵎ ⴷⴰⵏⵉⵜⴰ, ⴰⵎ ⵉ ⵖⴰ ⵥⵥⴰⴵⴻⵖ ⴷⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT26_37","070_26_37","MAT","26","37","37","ⴰⵎ ⴽⵉⵙ ⵢⵉⵡⵉ ⴱⵓⵟⵔⵓⵙ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵣⴰⴱⴷⵉ, ⵉⴱⴷⴰ ⵉⵜⵜⵏⴻⵅⵍⴰⵄ, ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT26_38","070_26_38","MAT","26","38","38","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵙⵙⵃⵉⵙⵙⵉⴼ ⴰⵟⵟⴰⵙ ⴰⵍ ⵍⵎⴻⵡⵜ. ⵇⵇⵉⵎⴻⵎ ⴷⴰ, ⵃⴹⴰⵎ ⴰⴽⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT26_39","070_26_39","MAT","26","39","39","ⵅⴻⵏⵏⵉ ⵉⵄⵣⴻⵍ ⵛⵡⴰⵢⵜ ⴽⵜⴰⵔ, ⵉⵡⴹⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵉⵜⵜⵥⴰⴵⴰ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⵎⴰⵍⴰ ⵉⵄⴻⴷⴷⴻⵍ, ⴻⵊⵊ ⴰⴷ ⵅⴰⴼⵉ ⵉⵄⴷⵓ ⵍⴽⴰⵙ-ⴰ! ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⵙⴻⵖ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("MT26_40","070_26_40","MAT","26","40","40","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⵟⵟⵚⴻⵏ. ⵉⵏⵏⴰ ⵉ ⴱⵓⵟⵔⵓⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⵃⴹⴰⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("MT26_41","070_26_41","MAT","26","41","41","ⵃⴹⴰⵎ, ⵥⵥⴰⴵⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⴷⴻⴳ ⵓⵊⴰⵔⵔⴻⴱ. ⴰⵔⵔⵓⵃ ⴰⵇⴰ ⵉⵡⵊⴻⴷ, ⵎⴰⵛⴰ ⴷⴷⴰⵜ ⵜⴻⴹⵄⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("MT26_42","070_26_42","MAT","26","42","42","ⵢⵓⵢⵓⵔ ⵄⴰⵡⴻⴷ ⵉ ⵓⵎⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵉⵥⵥⵓⴵ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⵎⴰⵍⴰ ⵍⴽⴰⵙ-ⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⴼⵉ ⵢⴻⴽⴽ ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵡⵉⵖ ⵜ, ⴰⵇⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("MT26_43","070_26_43","MAT","26","43","43","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ, ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⵟⵟⵚⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴹⴻⵇⵇⵍⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT26_44","070_26_44","MAT","26","44","44","ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ, ⵢⵓⵢⵓⵔ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵉⵥⵥⵓⴵ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵉⵇⵇⴰⵔ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT26_45","070_26_45","MAT","26","45","45","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵎⵎⵍⴻⵎ ⵅ ⵢⵉⴹⴻⵚ ⵏⵡⴻⵎ ⵍⴻⵅⵅⵓ, ⴰⵔⴻⵢⵢⵃⴻⵎ. ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⵜⵙⴰⵄⵄⴻⵜ ⵜⵉⵡⴻⴹ-ⴷⴷ ⴰⵇⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⴷⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MT26_46","070_26_46","MAT","26","46","46","ⴽⴽⴰⵔⴻⵎ, ⴰⴷ ⵏⵔⴰⵃ. ⵅⵣⴰⵔⴻⵎ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ, ⵢⵓⴷⴻⵙ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT26_47","070_26_47","MAT","26","47","47","ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ, ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵀⵓⴷⴰ, ⴰⵖⴻⴷⴷⴰⵔ, ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ, ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵍⴻⵙⵢⵓⴼ ⴷ ⵉⵄⵓⵎⴰⴷ, ⵓⵙⵉⵏ-ⴷⴷ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MT26_48","070_26_48","MAT","26","48","48","ⵢⴰⵀⵓⴷⴰ, ⴰⵖⴻⴷⴷⴰⵔ, ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵉⵏⵏⴰ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵓⴷⵎⴻⵖ ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ, ⵟⵟⴼⴻⵎ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT26_49","070_26_49","MAT","26","49","49","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵙⵍⴰⵎ ⵅⴰⴽ, ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ!”, ⵓⵛⴰ ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT26_50","070_26_50","MAT","26","50","50","ⵅⴰⵙ ⵓⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ, ⵎⵉⵏ ⵅⴻⴼ ⴷⴷ-ⵜⵓⵙⵉⴷ ⴷⴰ?” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵃⴰⵔⵜⴻⵏ ⵅ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MT26_51","070_26_51","MAT","26","51","51","ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ, ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵊⴱⴻⴷ ⵙⵙⵉⴼ ⵓⵛⴰ ⵉⵡⵜⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵇⴻⵙⵙ ⴰⵙ ⴰⵎⴻⵣⵣⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("MT26_52","070_26_52","MAT","26","52","52","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵔⵔ ⵙⵙⵉⴼ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴽⴻⵙⵙⵉⵏ ⵙⵙⵉⴼ ⴰⴷ ⵎⵎⵜⴻⵏ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("MT26_53","070_26_53","MAT","26","53","53","ⵏⵉⵖ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵉ ⴱⴰⴱⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵍⴻⵅⵅⵓ ⴽⵜⴰⵔ ⵣⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵍⵉⵅⵉⵢⵓⵏⴻⵏ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ? ");
INSERT INTO rift_vpl VALUES ("MT26_54","070_26_54","MAT","26","54","54","ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("MT26_55","070_26_55","MAT","26","55","55","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵙⵓⵄ ⴰⴽ-ⴷ ⵍⵖⴰⵛⵉ: “ⴰⵅⵎⵉ ⵅ ⵉⵊⵊ ⵏ ⵓⵇⵟⴰⵟⵄⵉⵢ ⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵙ ⵍⴻⵙⵢⵓⴼ ⴷ ⵉⵄⵓⵎⴰⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜᵉⵟⵟⴼⴻⵎ. ⴽⵓⵍ ⴰⵙⵙ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵖ ⵖⴰⵔⵡⴻⵎ, ⵙⵙⴻⵍⵎⴰⴷⴻⵖ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵟⵟⵉⴼⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MT26_56","070_26_56","MAT","26","56","56","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⴻⵎⵃⴻⵏ ⴷⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT26_57","070_26_57","MAT","26","57","57","ⵉⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵇⴰⵢⴰⴼⴰ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MT26_58","070_26_58","MAT","26","58","58","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⴰⵍⴰⵎⵉ ⴷ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓ ⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ, ⵉⵇⵇⵉⵎ ⵊⴰⵔ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜⴻⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("MT26_59","070_26_59","MAT","26","59","59","ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⵎⴰⵔⵔⴰ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵉⵛⴻⵀⵀⴰⴷⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵅ ⵢⴰⵙⵓⵄ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT26_60","070_26_60","MAT","26","60","60","ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜ ⴰⴼⴻⵏ, ⵡⴰⵅⵅⴰ ⵓⵙⵉⵏ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵛⵀⵓⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵓⵙⵉⵏ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ");
INSERT INTO rift_vpl VALUES ("MT26_61","070_26_61","MAT","26","61","61","ⵉ ⵉⵏⵏⴰⵏ: “ⵡⴰ ⴰⵇⴰ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵜ ⴱⵏⵉⵖ ⵄⴰⵡⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("MT26_62","070_26_62","MAT","26","62","62","ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⴰⵔⵔⵉⴷ ⵙ ⵡⴰⵍⵓ? ⵎⵉⵏ ⵅⴰⴽ ⵛⴻⵀⵀⴷⴻⵏ ⵉⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("MT26_63","070_26_63","MAT","26","63","63","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵇⴰⵔ. ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: “ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵊⵊⴻⵖ ⴰⴷ ⵜⴻⵊⵊⴰⴵⴻⴷ ⵙ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴰⴷ ⴰⵏⴻⵖ ⵜⵉⵏⵉⴷ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("MT26_64","070_26_64","MAT","26","64","64","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ ⵜ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ‘ⵣⵉ ⵙⵙⴰ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵇⵇⵉⵎ ⵅ ⵓⴼⵓⵙⵉ ⵏ ⵊⵊⴻⵀⴷ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵅ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT26_65","070_26_65","MAT","26","65","65","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵛⴻⵇⵇⴻⴼ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵃⴷⴰⵊ ⵄⴰⴷ ⵍⴻⵛⵀⵓⴷ? ⵅⵣⴰⵔⴻⵎ, ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⵉ ⵓⵛⴻⵇⵇⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT26_66","070_26_66","MAT","26","66","66","ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ ⴽⴻⵏⵏⵉⵡ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ, ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⵉⵙⴷⴰⵀⴻⴵ ⵍⵎⴻⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT26_67","070_26_67","MAT","26","67","67","ⵅⴻⵏⵏⵉ ⴱⴷⴰⵏ ⵙⵙⵓⵙⵓⴼⴻⵏ ⴰⵙ ⵅ ⵓⵖⴻⵎⴱⵓⴱ, ⵛⵛⴰⵜⴻⵏ ⵜ ⵙ ⵍⴱⵓⵏⵉⵢⵢⴰⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⵡⵜⵉⵏ ⵜ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("MT26_68","070_26_68","MAT","26","68","68","ⵏⵏⴰⵏ: “ⵏⴰⴱⴱ ⴰⵏⴻⵖ, ⴰ ⵛⴻⴽ, ⵍⵎⴰⵙⵉⵃ, ⵡⵉ ⵛⴻⴽ ⵉⵡⵜⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT26_69","070_26_69","MAT","26","69","69","ⴱⵓⵟⵔⵓⵙ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴷⵉ ⵍⴻⵎⵔⴰⵃ. ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ, ⵜⴻⵏⵏⴰ: “ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵜⵓⵖⴰ ⵛⴻⴽ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ, ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ.”    ");
INSERT INTO rift_vpl VALUES ("MT26_70","070_26_70","MAT","26","70","70","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴽⴰⵔ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("MT26_71","070_26_71","MAT","26","71","71","ⴰⵎ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵓⵙⵇⵉⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵜⴻⵥⵔⴰ ⵉ-ⵜ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵖⵏⵉ, ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ: “ⵓⵍⴰ ⴷ ⵡⴰ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT26_72","070_26_72","MAT","26","72","72","ⵏⴻⵜⵜⴰ ⵉⵏⴽⴰⵔ ⵄⴰⵡⴻⴷ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT26_73","070_26_73","MAT","26","73","73","ⵛⵡⴰⵢⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⴱⵓⵟⵔⵓⵙ, ⵏⵏⴰⵏ: “ⵏⵉⵛⴰⵏ, ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵛ ⵉⵙⵙⴱⴻⵢⵢⴻⵏ ⵉ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("MT26_74","070_26_74","MAT","26","74","74","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵉⵏⴻⵄⵄⴻⵍ, ⵉⵜⵜⵊⵊⴰⴵⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ ");
INSERT INTO rift_vpl VALUES ("MT26_75","070_26_75","MAT","26","75","75","ⵓⵛⴰ ⵉⵄⵇⴻⵍ ⴱⵓⵟⵔⵓⵙ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ⵓⵛⴰ ⵉⴼⴼⴻⵖ, ⵉⵔⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT27_1","070_27_1","MAT","27","1","1","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵎⵛⴰⵡⴰⵔⴻⵏ ⵅ ⵢⴰⵙⵓⵄ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵜ ⵖⴰ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT27_2","070_27_2","MAT","27","2","2","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵛⴰⵔⴼⴻⵏ ⵜ, ⵉⵡⵢⴻⵏ ⵜ ⵓⵛⴰ ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⵉ ⵍⵄⴰⵎⵉⵍ ⴰⵔⵓⵎⴰⵏⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴱⵉⵍⴰⵟⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_3","070_27_3","MAT","27","3","3","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵀⵓⴷⴰ, ⴰⵖⴻⴷⴷⴰⵔ, ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ, ⵉⵏⴷⴻⵎ, ⵓⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵜⵍⴰⵜⵉⵏ ⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_4","070_27_4","MAT","27","4","4","ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵅⴹⵉⵖ, ⴰⵇⴰ ⵖⴷⴰⵔⴻⵖ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ.” ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵔⵓⵃⴻⵏ? ⵅⵣⴰⵔ-ⴷⴷ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("MT27_5","070_27_5","MAT","27","5","5","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⴹⴰⵔ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⵉⵔⵓⵃ, ⵢⵓⵢⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_6","070_27_6","MAT","27","6","6","ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴽⵙⵉⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⴰⵔⵙ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵚⵚⴷⴰⵇⵉ, ⵎⵉⵏⵣⵉ ⵍⵡⴻⵣⵏⴰⵜ ⵏⵏⵉ ⴷ ⵜⵜⴰⵎⴰⵏ ⵏ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT27_7","070_27_7","MAT","27","7","7","ⴽⴽⵙⴻⵏ ⴰⵡⴰⵍ ⵊⴰⵔ ⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵖⴻⵏ ⵉⵢⵢⴰⵔ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵉ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("MT27_8","070_27_8","MAT","27","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ‘ⵉⵢⵢⴰⵔ ⵏ ⵉⴷⴰⵎⵎⴻⵏ’ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("MT27_9","070_27_9","MAT","27","9","9","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵉ ⵉⵏⵏⴰⵏ: “ⴽⵙⵉⵖ ⵜⵍⴰⵜⵉⵏ ⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵍⵇⴻⴷⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵖⵍⴰⵏ, ⵎⵉⵅⴻⴼ ⵉⵏⵏⵉ ⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⴽⴽⵙⴻⵏ ⴰⵡⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("MT27_10","070_27_10","MAT","27","10","10","ⵓⵛⴰ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵜⴻⵏⵜ ⵉ ⵉⵢⵢⴰⵔ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT27_11","070_27_11","MAT","27","11","11","ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵄⴰⵎⵉⵍ. ⵍⵄⴰⵎⵉⵍ ⵉⵙⵙⴻⵇⵙⴰ ⴰⵙ, ⵉⵏⵏⴰ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⴰⵇⴰ ⵜⴻⵏⵏⵉⴷ ⵜ!” ");
INSERT INTO rift_vpl VALUES ("MT27_12","070_27_12","MAT","27","12","12","ⵓⵛⴰ ⵍⴰⵎⵉ ⵜ ⵜⴻⵀⵎⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("MT27_13","070_27_13","MAT","27","13","13","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵍⵉⴷ ⵎⴻⵛⵃⴰⵍ ⵅⴰⴽ ⵛⴻⵀⵀⴷⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MT27_14","070_27_14","MAT","27","14","14","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵓⵍⴰ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⴰⵍⴰⵎⵉ ⵉⵇⵇⵉⵎ ⵍⵄⴰⵎⵉⵍ ⵉⵜⵜⴻⴱⵀⴻⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_15","070_27_15","MAT","27","15","15","ⵜⵓⵖⴰ ⵍⵄⴰⵎⵉⵍ ⵉⵏⵏⵓⵎ ⵢⴰⵔⴻⵅⵅⵓ ⴷⵉ ⴽⵓⵍ ⵍⵄⵉⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴱⵓⵙ ⵉ ⵍⵖⴰⵛⵉ, ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT27_16","070_27_16","MAT","27","16","16","ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴱⵓⵙ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_17","070_27_17","MAT","27","17","17","ⵍⴰⵎⵉ ⵎⵓⵏⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⵡⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵅⵓⵖ, ⴱⴰⵔ-ⴰⴱⴱⴰⵙ ⵏⵉⵖ ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵍⵎⴰⵙⵉⵃ?” ");
INSERT INTO rift_vpl VALUES ("MT27_18","070_27_18","MAT","27","18","18","ⵎⵉⵏⵣⵉ ⴱⵉⵍⴰⵟⵓⵙ ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⵣⵉ ⵍⴻⵃⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MT27_19","070_27_19","MAT","27","19","19","ⴰⵎ ⵜⵓⵖⴰ ⵍⵄⴰⵎⵉⵍ ⵉⵇⵇⵉⵎ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⵃⵓⴽⵎ, ⵜⴻⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ: “ⴱⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⴻⴳ ⵓⵎⵙⴻⴳⴳⴰⴷ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵜⵜⵡⴰⵄⴻⴷⴷⴱⴻⵖ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴰⵔⵊⵉⵜ ⵉⵏⵓ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT27_20","070_27_20","MAT","27","20","20","ⵎⴰⵛⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵙⵙⵇⴻⵏⵄⴻⵏ ⵍⵖⴰⵛⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT27_21","070_27_21","MAT","27","21","21","ⵍⵄⴰⵎⵉⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ-ⴰ ⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵔⵅⵓⵖ ⵉ ⴽⴻⵏⵏⵉⵡ?” ⵏⵏⴰⵏ: “ⴱⴰⵔ-ⴰⴱⴱⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("MT27_22","070_27_22","MAT","27","22","22","ⴱⵉⵍⴰⵟⵓⵙ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵍⵎⴰⵙⵉⵃ?” ⵏⵏⴰⵏ ⴰⵙ ⵎⴰⵔⵔⴰ: “ⵚⴻⵍⵍⴱ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("MT27_23","070_27_23","MAT","27","23","23","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵍⵄⴰⵎⵉⵍ: “ⵎⴰⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵉⴳⴳⴰ?” ⵙⵖⵓⵢⵢⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⴽⵜⴰⵔ, ⵏⵏⴰⵏ: “ⵚⴻⵍⵍⴱ ⵉ-ⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT27_24","070_27_24","MAT","27","24","24","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⴱⵉⵍⴰⵟⵓⵙ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵡⴰⵍⵓ, ⵎⴰⵀⵓ ⴰⴷ ⵉⴽⴽⴰⵔ ⵓⵖⵓⵡⵡⴻⵖ, ⵉⴽⵙⵉ ⴰⵎⴰⵏ, ⵉⵙⵙⵉⵔⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵖⴰⵛⵉ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵓⵔⵙⴻⵖ ⵛⴰ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ-ⴰ, ⵅⵣⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ!” ");
INSERT INTO rift_vpl VALUES ("MT27_25","070_27_25","MAT","27","25","25","ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⴻⵊⵊ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵍⵉⵏ ⵓ ⵅ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("MT27_26","070_27_26","MAT","27","26","26","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵅⵓ ⴰⵙⴻⵏ-ⴷⴷ ⵉ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵀⴻⵜⵜⴻⴽ ⵢⴰⵙⵓⵄ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("MT27_27","070_27_27","MAT","27","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏ ⵍⵄⴰⵎⵉⵍ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴰⵄ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴱⵔⵉⵜⵓⵔⵉⵢⵓⵎ’, ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⵍⴽⵓⵎⴱⴰⵏⵉⵢⵢⴻⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MT27_28","070_27_28","MAT","27","28","28","ⴽⴽⵙⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵔⵔⵓⴹ, ⵓⵛⴰ ⴰⵔⴹⴻⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⴰⴱ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ. ");
INSERT INTO rift_vpl VALUES ("MT27_29","070_27_29","MAT","27","29","29","ⵏⵉⵜⵏⵉ ⵎⵓⴷⴻⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵙ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ, ⵅⴻⵏⵏⵉ ⵡⴹⴰⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵣⵣⴰⵜⴻⵙ, ⵇⵇⵉⵎⴻⵏ ⵜⵜⴱⵓⵚⴰⵔⴻⵏ ⵅⴰⵙ, ⵏⵏⴰⵏ: “ⴰⵣⵓⵍ ⵅⴰⴽ, ⴰ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MT27_30","070_27_30","MAT","27","30","30","ⵙⵙⵓⵙⴼⴻⵏ ⴰⵙ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⴽⵙⵉⵏ ⴰⵖⴰⵏⵉⵎ ⵓⵛⴰ ⵡⵜⵉⵏ ⵜ ⵣⵣⴰⵢⴻⵙ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("MT27_31","070_27_31","MAT","27","31","31","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⴷⴻⴵⴻⵏ, ⴽⵙⵉⵏ ⵅⴰⵙ ⴰⵙⴻⵍⵀⴰⵎ, ⴰⵔⴹⴻⵏ ⴰⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵚⴻⵍⵍⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT27_32","070_27_32","MAT","27","32","32","ⴰⵎ ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⴼⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵇⴰⵢⵔⴰⵡⴰⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵎⵄⵓⵏ, ⵓⵛⴰ ⵣⵉⵢⵢⴰⵔⴻⵏ ⵅⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⴱⵓ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_33","070_27_33","MAT","27","33","33","ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵊⵓⵍⵊⵓⵜⴰ’, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵜⴰⵛⴻⵇⵇⵓⴼⵜ’, ");
INSERT INTO rift_vpl VALUES ("MT27_34","070_27_34","MAT","27","34","34","ⵡⵛⵉⵏ ⴰⵙ ⵍⵅⴻⴵ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵜⴰⵔⵣⵓⴳⵉ ⵓⵛⴰ ⵓⵎⵉ ⵜ ⵉⵇⵇⴰⵙ, ⵢⵓⴳⵉ ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("MT27_35","070_27_35","MAT","27","35","35","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵚⴻⵍⵍⴱⴻⵏ, ⴱⴹⴰⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵎⵉ ⵅⴰⵙ ⴳⴳⵉⵏ ⴰⴽⴻⵛⵛⵓⴹ, ");
INSERT INTO rift_vpl VALUES ("MT27_36","070_27_36","MAT","27","36","36","ⴰⵎ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ, ⵜⵜⵄⴻⵙⵙⴰⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_37","070_27_37","MAT","27","37","37","ⴳⴳⵉⵏ ⴰⵙ ⵙⴻⵏⵏⴻⵊ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⵉⵔⴰ ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⵙ ⵃⴻⴽⵎⴻⵏ ⵙ ⵍⵎⴻⵡⵜ: ‘ⵡⴰ ⴷ ⵢⴰⵙⵓⵄ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MT27_38","070_27_38","MAT","27","38","38","ⵅⴻⵏⵏⵉ ⵚⴻⵍⵍⴱⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ ⵓ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_39","070_27_39","MAT","27","39","39","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴽⴽⴰⵏ, ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴰⵢⴻⵙ, ⵜⵜⵀⴻⵣⵣⴰⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT27_40","070_27_40","MAT","27","40","40","ⵏⵏⴰⵏ: “ⴰ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵀⴻⴷⵎⴻⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵜ ⵜⴻⴱⵏⵉⴷ ⵄⴰⵡⴻⴷ, ⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵀⵡⴰ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵣⵉ ⵚⵚⴰⵍⵉⴱ.” ");
INSERT INTO rift_vpl VALUES ("MT27_41","070_27_41","MAT","27","41","41","ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵙⵜⴻⵀⵣⴰⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎⴻⵏⵏⵉ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("MT27_42","070_27_42","MAT","27","42","42","“ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵏⵏⴻⵖⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵅⴻⴼ ⵏⵏⴻⵙ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵣⵉ ⵚⵚⴰⵍⵉⴱ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴰⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT27_43","070_27_43","MAT","27","43","43","ⵉⵜⵜⵛⴻⵍ ⵅ ⴰⵔⴻⴱⴱⵉ. ⴻⵊⵊ ⵉ-ⵜ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵎⴰⵍⴰ ⵢⴰⵔⴹⴰ ⵅⴰⵙ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ’.” ");
INSERT INTO rift_vpl VALUES ("MT27_44","070_27_44","MAT","27","44","44","ⵓⵍⴰ ⴷ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵜⵓⵖⴰ ⵙⵙⴼⴻⵟⵟⴰⵃⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MT27_45","070_27_45","MAT","27","45","45","ⵣⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴹⴹⵀⵓⵔ, ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴰⵍ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵓⵄⴻⵛⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MT27_46","070_27_46","MAT","27","46","46","ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵉⵙⵖⵓⵢ ⵢⴰⵙⵓⵄ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵏⵏⴰ: “ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰⵢⵉ ⵜⵙⴻⵎⵃⴻⴷ?”    ");
INSERT INTO rift_vpl VALUES ("MT27_47","070_27_47","MAT","27","47","47","ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵙⵍⴰⵏ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵏⵏⴰⵏ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ: “ⵉⵜⵜⵍⴰⵖⴰ ⵅ ⵉⵍⵉⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("MT27_48","070_27_48","MAT","27","48","48","ⴷⴻⵖⵢⴰ ⵢⵓⵣⵣⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵉⴽⵙⵉ ⵙⴱⵓⵏⵅⴰ, ⵉⵙⵙⵓⴼⴼ ⵉ-ⵜⵜ ⵙ ⵍⵅⴻⴵ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵅ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("MT27_49","070_27_49","MAT","27","49","49","ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⴻⵊⵊ ⵉ-ⵜ, ⴰⴷ ⵏⵥⴰⵔ, ⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵍⵉⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT27_50","070_27_50","MAT","27","50","50","ⵉⵙⵖⵓⵢⵢ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵅⵓ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_51","070_27_51","MAT","27","51","51","ⵅⵣⴰⵔ, ⴰⵍⴻⵃⵃⴰⴼ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴻⴳ ⵅ ⵜⵏⴰⵢⴻⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⴰⵍ ⵙⵡⴰⴷⴷⴰⵢ, ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵏⵀⴻⵣⵣ, ⵜⵉⵚⵓⴹⴰⵔ ⴼⴻⴵⵇⴻⵏⵜ,    ");
INSERT INTO rift_vpl VALUES ("MT27_52","070_27_52","MAT","27","52","52","ⵉⵎⴻⴹⵍⴰⵏ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⴰⵔⵔⵉⵎⴰⵜ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⵚⴻⵏ ⴷⵉⵏ, ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏⵜ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MT27_53","070_27_53","MAT","27","53","53","ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵏⵓⴽⵔⴰ ⵏⵏⴻⵙ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴱⴰⵏⴻⵏ-ⴷⴷ ⵉ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT27_54","070_27_54","MAT","27","54","54","ⵍⴰⵎⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵃⴻⵟⵟⴰⵏ ⵢⴰⵙⵓⵄ, ⵥⵔⵉⵏ ⴰⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵏⵏⴰⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⵓⵖⴰ ⵡⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MT27_55","070_27_55","MAT","27","55","55","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⴹⴼⴰⵔⴻⵏⵜ ⵢⴰⵙⵓⵄ ⵣⵉ ⵍⵊⴰⵍⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MT27_56","070_27_56","MAT","27","56","56","ⵊⴰⵔⴰⵙⴻⵏⵜ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⴰⵙⵉ, ⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⴰⵢⵜ ⵏ ⵣⴰⴱⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("MT27_57","070_27_57","MAT","27","57","57","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵔⴰⵎⵜⴰ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵓⵙⵓⴼ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT27_58","070_27_58","MAT","27","58","58","ⵉⵔⵓⵃ ⵖⴰⵔ ⴱⵉⵍⴰⵟⵓⵙ, ⵉⵜⵜⴰⵔ ⴰⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵡⴻⵚⵚⴰ ⴱⵉⵍⴰⵟⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ");
INSERT INTO rift_vpl VALUES ("MT27_59","070_27_59","MAT","27","59","59","ⵢⵓⵙⵓⴼ ⵉⴽⵙⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵏⴻⴹ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵅⴻⵢⵢⴰⴹⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵚⴼⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("MT27_60","070_27_60","MAT","27","60","60","ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏ ⵊⴷⵉⴷ ⵉ ⵜⵓⵖⴰ ⵉⵖⵣⴰ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⴻⵇⵏⵓⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴼⴻⵍ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⴻⵏⴹⴻⵍ, ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("MT27_61","070_27_61","MAT","27","61","61","ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵎⴰⵔⵢⴰⵎ ⵏⵏⴻⵖⵏⵉⵜ ⵇⵇⵉⵎⴻⵏⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MT27_62","070_27_62","MAT","27","62","62","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙⵙ ⵏ ⵓⵙⴻⵡⵊⴻⴷ, ⵎⵓⵏⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵖⴰⵔ ⴱⵉⵍⴰⵟⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("MT27_63","070_27_63","MAT","27","63","63","ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵏⴻⵄⵇⴻⵍ ⴱⴻⵍⵍⵉ ⴰⵖⴻⵛⵛⴰⵛ-ⴰ, ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⴷⴷⴰⵔ, ⵉⵏⵏⴰ: ‘ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴽⴽⴰⵔⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("MT27_64","070_27_64","MAT","27","64","64","ⵙ ⵓⵢⴰ ⵓⵎⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴹⴻⵎⵏⴻⵏ ⴰⵏⴹⴻⵍ ⴰⵍ ⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵖ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⴻⵏ ⵙ ⴵⵉⵍⴻⵜ ⴰⴷ ⵜ ⴰⵛⴰⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵍⴳⴻⵏⵙ, ⴰⵇⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵡⴻⴷⴷⴰⵔ ⴰⵏⴻⴳⴳⴰⵔⵓ ⴽⵜⴰⵔ ⵅ ⵓⵎⴻⵣⵡⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MT27_65","070_27_65","MAT","27","65","65","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⴰⵇⴰ ⵖⴰⵔⵡⴻⵎ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵔⵓⵃⴻⵎ, ⴹⴻⵎⵏⴻⵏ ⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("MT27_66","070_27_66","MAT","27","66","66","ⵔⵓⵃⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵙⵙⴻⵏ ⵅ ⵡⴻⵏⴹⴻⵍ ⵓⵛⴰ ⴹⴻⵎⵏⴻⵏ ⴰⵥⵔⵓ, ⵏⵉⵜⵏⵉ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT28_1","070_28_1","MAT","28","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵄⴷⵓ ⵙⵙⴻⴱⵜ, ⵖⴰⵔ ⵍⴻⴼⵊⴰⵔ ⵏ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵙⵙⵉⵎⴰⵏⴰ, ⵜⵓⵙⴰ-ⴷⴷ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵎⴰⵔⵢⴰⵎ ⵏⵏⴻⵖⵏⵉⵜ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵊⵊⴻⵏⵜ ⵅ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MT28_2","070_28_2","MAT","28","2","2","ⵅⵣⴰⵔ, ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵎⵖⴰⵔ, ⵎⵉⵏⵣⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ, ⵉⵙⵙⴻⵇⵏⵓⵏⵏⵉ ⵜⴰⵚⴹⴰⵔⵜ ⵣⴻⴳ ⵡⴰⴷⴰⴼ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT28_3","070_28_3","MAT","28","3","3","ⵜⵓⵖⴰ ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵙ ⴰⵎ ⵡⴰⵊⵊⴰⵊ ⵓ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴰⵎ ⵡⴻⴷⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MT28_4","070_28_4","MAT","28","4","4","ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴼⴻⵛⵍⴻⵏ ⵣⵉ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵢⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT28_5","070_28_5","MAT","28","5","5","ⵍⵎⴰⵍⴰⴽ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏⵜ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵜⴰⵔⴻⵣⵣⵓⵏⵜ ⵅ ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT28_6","070_28_6","MAT","28","6","6","ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ. ⴰⵙⴻⵏⵜ-ⵉ-ⴷⴷ ⴷⴰ, ⵅⵣⴰⵔⴻⵏⵜ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴰⵔⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("MT28_7","070_28_7","MAT","28","7","7","ⵔⵓⵃⴻⵏⵜ ⴷⴻⵖⵢⴰ, ⵉⵏⵉⵏⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵓ ⵅⵣⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ⴷⵉⵏ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⵎ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("MT28_8","070_28_8","MAT","28","8","8","ⴼⴼⵖⴻⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⴷⴻⵖⵢⴰ ⵣⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵎⵖⴰⵔⴻⵏ, ⵜⵜⴰⵣⵣⵍⴻⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵅⴻⴱⴱⴰⵔⴻⵏⵜ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT28_9","070_28_9","MAT","28","9","9","ⵓⵛⴰ ⵅⵣⴰⵔ, ⵢⴰⵙⵓⵄ ⵉⵍⵇⴰ ⵜⴻⵏⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴰⵎ ⵅⴰⴽⴻⵏⵜ!” ⵏⵉⵜⴻⵏⵜⵉ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵟⵟⴼⴻⵏⵜ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏⵜ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MT28_10","070_28_10","MAT","28","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏⵜ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏⵜ ⵛⴰ, ⵙⵙⵉⵡⴹⴻⵏⵜ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵉ ⴰⵢⵜⵎⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ, ⴷⵉⵀⴰ ⴰⴷ ⴰⵢⵉ ⵥⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MT28_11","070_28_11","MAT","28","11","11","ⴰⵎ ⵔⵓⵃⴻⵏⵜ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵛⴰ ⵣⴻⴳ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT28_12","070_28_12","MAT","28","12","12","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵓⵏⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵎⵛⴰⵡⴰⵔⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵉ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵔⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("MT28_13","070_28_13","MAT","28","13","13","ⵏⵏⴰⵏ: “ⵉⵏⵉⵎ: ‘ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵙ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵓⵛⴰⵔⴻⵏ ⵜ ⴰⵎ ⵜⵓⵖⴰ ⵏⴻⵟⵟⴻⵚ!’ ");
INSERT INTO rift_vpl VALUES ("MT28_14","070_28_14","MAT","28","14","14","ⵎⴰⵍⴰ ⵉⵙⵍⴰ ⵉ-ⵜ ⵍⵄⴰⵎⵉⵍ, ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵇⵏⴻⵄ ⵓⵛⴰ ⴰⴷ ⵏⴻⴳⴳ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉⵎ ⴷⴻⴳ ⵉⵎⵓⵏⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MT28_15","070_28_15","MAT","28","15","15","ⵟⵟⴼⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵓⵛⴰ ⴳⴳⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵄⴻⵍⵎⴻⵏ. ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⴰⵍ ⴰⵙⵙ ⵏ ⵢⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("MT28_16","070_28_16","MAT","28","16","16","ⵃⵉⵟⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ, ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵎⴰⵏⵉ ⵜⴻⵏ ⵢⵓⵎⵓⵔ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MT28_17","070_28_17","MAT","28","17","17","ⴰⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵏ, ⵙⴻⵊⴷⴻⵏ ⴰⵙ, ⵎⴰⵛⴰ ⵛⴰ ⵛⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MT28_18","070_28_18","MAT","28","18","18","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵜⴻⵎⵎⴻⵡⵛ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵚⵚⵓⵍⵟⴰ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴱⴰⴱⴰ, ⴰⵎⵎⵓ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("MT28_19","070_28_19","MAT","28","19","19","ⵔⵓⵃⴻⵎ, ⴰⵔⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵓ ⵙⵙⵖⴻⴹⵚⴻⵎ ⵜⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰ ⴷ ⵎⵎⵉⵙ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MT28_20","070_28_20","MAT","28","20","20","ⵓ ⵙⵍⴻⵎⴷⴻⵎ ⴰⵙⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵓⵔⴻⵖ ⵣⵣⴰⵢⴻⵙ, ⵓ ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⴰⵍ ⵇⴻⵟⵟⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.” ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⵎⴰⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK1_1","071_1_1","MRK","1","1","1","ⴱⴻⴷⴷⵓ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MK1_2","071_1_2","MRK","1","2","2","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ... “ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵛ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MK1_3","071_1_3","MRK","1","3","3","“ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵖⵓⵢⵢⵓⵏ ⴷⵉ ⵍⴻⵅⵍⴰ: ‘ⵙⵡⴻⵊⴷⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵙⴻⴳⴳⵎⴻⵎ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵙ!’” ");
INSERT INTO rift_vpl VALUES ("MK1_4","071_1_4","MRK","1","4","4","... ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵜⵜⵓⴱⴻⵜ ⵉ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("MK1_5","071_1_5","MRK","1","5","5","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷ ⴰⵢⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵎ ⵏⴻⵄⵄⵎⴻⵏ ⵙ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_6","071_1_6","MRK","1","6","6","ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵢⴰⵔⴹ ⵜⴰⴹⵓⴼⵜ ⵏ ⵉⵍⴻⵖⵎⴰⵏ, ⵉⴱⴻⴽⴽⴻⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵏ ⵢⵉⵍⴻⵎ ⵅ ⵜⴻⵊⵄⵉⵏⵏⴰ ⵏⵏⴻⵙ, ⵓ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵜⵜ ⵉⴱⵓⵔⴻⵅⵙⴻⵏ ⴷ ⵜⴰⵎⵎⴻⵏⵜ ⵜⴰⵃⵓⵔⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MK1_7","071_1_7","MRK","1","7","7","ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ, ⵉⵇⵇⴰⵔ: “ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵅⴰⴼⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵙⴷⵉⵀⵉⴵⴻⵖ ⴰⴷ ⴰⴹⴰⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴼⴻⵙⵢⴻⵖ ⵉⴼⵉⵍⴰⵏ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK1_8","071_1_8","MRK","1","8","8","ⵏⴻⵛⵛ ⵙⵙⵖⴻⴹⵚⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵖⴹⴻⵚ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK1_9","071_1_9","MRK","1","9","9","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ, ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⴷⴻⴳ ⵢⴻⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_10","071_1_10","MRK","1","10","10","ⴷⴻⵖⵢⴰ, ⴰⵎ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ, ⵉⵥⵔⴰ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵔⵣⵎⴻⵏ ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⴰⵎ ⵜⴻⴷⴱⵉⵔⵜ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK1_11","071_1_11","MRK","1","11","11","ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ: “ⵛⴻⴽ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⴷⴰⵢⴻⴽ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("MK1_12","071_1_12","MRK","1","12","12","ⴷⴻⵖⵢⴰ ⵉⴳⴻⵡⵡⴻⴷ ⵉ-ⵜ ⴰⵔⵔⵓⵃ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MK1_13","071_1_13","MRK","1","13","13","ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵊⴰⵔⵔⴻⴱ ⵉ-ⵜ ⵛⵛⵉⵟⴰⵏ, ⵜⵓⵖⴰ-ⵜ ⴰⴽ-ⴷ ⵍⴻⵡⵃⵓⵛ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏⵜ ⵅⴰⵙ ⵍⵎⴰⵍⴰⴽⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("MK1_14","071_1_14","MRK","1","14","14","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵟⵟⴼⴻⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵢⵓⴷⴻⴼ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("MK1_15","071_1_15","MRK","1","15","15","ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵍⵡⴻⵇⵜ ⵜⵉⵡⴻⴹ-ⴷⴷ, ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⵓⴱⴻⵎ, ⴰⵎⵏⴻⵎ ⴷⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK1_16","071_1_16","MRK","1","16","16","ⴰⵎ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⵊⴰⵍⵉⵍ, ⵉⵥⵔⴰ ⵛⵉⵎⵄⵓⵏ ⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ ⵓⵎⴰⵙ, ⵏⴻⵟⵟⴰⵔⴻⵏ ⵜⵔⴰⵛⵛⴰ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_17","071_1_17","MRK","1","17","17","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⵙⴻⵎ-ⴷⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵔⵔⴻⵖ ⴷ ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵢⴻⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK1_18","071_1_18","MRK","1","18","18","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵊⵊⵉⵏ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK1_19","071_1_19","MRK","1","19","19","ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵄⴷⵓ ⵛⵡⴰⵢⵜ ⵙⵙⴻⵏⵏⵉ, ⵉⵥⵔⴰ ⵢⴰⵄⵇⵓⴱ ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ ⴷ ⵓⵎⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵄⴻⴷⵍⴻⵏ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_20","071_1_20","MRK","1","20","20","ⵉⵍⴰⵖⴰ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵊⵊⵉⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵣⴰⴱⴷⵉ ⴰⴽ-ⴷ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK1_21","071_1_21","MRK","1","21","21","ⵅⴻⵛⵛⴻⵏ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ ⵓⵛⴰ ⴷⴻⵖⵢⴰ ⵉⴱⴷⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵙⵙⴻⴱⵜ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MK1_22","071_1_22","MRK","1","22","22","ⵜⴱⴻⵀⵜⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜⴻⵏ ⴰⵎ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵢⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_23","071_1_23","MRK","1","23","23","ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵏⵙⴻⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵎⴻⵏⴳⵓⵙ, ⵉⵙⵖⵓⵢⵢⵓ, ");
INSERT INTO rift_vpl VALUES ("MK1_24","071_1_24","MRK","1","24","24","ⵉⵇⵇⴰⵔ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⵏⴻⵛⵛⵉⵏ ⴷ ⵛⴻⴽ ⴰ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ. ⵎⴰ ⵜⵓⵙⵉⴷ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵀⴻⵍⵍⴽⴻⴷ? ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵛⴻⴽ ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ: ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK1_25","071_1_25","MRK","1","25","25","ⵓⵛⴰ ⵉⵄⵍⴻⵎ ⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵇⴰⵔ! ⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("MK1_26","071_1_26","MRK","1","26","26","ⵉⵎⵎⴻⵏⴹⴰⵔ ⵉ-ⵜ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ, ⵉⵙⵖⵓⵢ ⵙ ⵉⵛⵜ ⵏ ⵜⵖⵓⵢⵢⵉⵜ ⵜⴻⵊⵀⴻⴷ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK1_27","071_1_27","MRK","1","27","27","ⵜⴱⴻⵀⵜⴻⵏ ⵎⴰⵔⵔⴰ, ⵎⵎⵙⴻⵇⵙⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵏⵏⴰⵏ: “ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰⵏⴰ ⵜⴰⵖⵓⵔⵉ-ⵢⴰ ⵏ ⵊⴷⵉⴷ? ⵎⵉⵏⵣⵉ ⵙ ⵚⵚⵓⵍⵟⴰ ⵢⵓⵎⵓⵔ ⵓⵍⴰ ⴷ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ ⵓⵛⴰ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵙ ⴰⵔⵔⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("MK1_28","071_1_28","MRK","1","28","28","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MK1_29","071_1_29","MRK","1","29","29","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ, ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ ⴰⴽ-ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK1_30","071_1_30","MRK","1","30","30","ⵜⵓⵖⴰ ⵜⴰⴹⴻⴽⴽⵡⴰⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⵜⴻⵣⵣⴻⵍ ⵙ ⵜⵎⴻⵙⵙⵉ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵅⴰⵙ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK1_31","071_1_31","MRK","1","31","31","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵛⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ. ⴷⴻⵖⵢⴰ ⵜⴻⵊⵊⴰ ⵅⴰⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴱⴷⴰ ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_32","071_1_32","MRK","1","32","32","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ, ⵜⴰⴼⵓⵛⵜ ⵜⵔⵓⵃ ⴰⴷ ⵜⴻⵖⵍⵉ, ⵉⵡⵢⴻⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵀⵍⴰⵛ ⴷ ⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_33","071_1_33","MRK","1","33","33","ⵜⵓⵖⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵎⵓⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK1_34","071_1_34","MRK","1","34","34","ⵉⵙⵙⴳⴻⵏⴼⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵃⵍⴰⵛ ⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵛⵛⵡⴰⵟⴻⵏ, ⵡⴰⵔ ⵉⵊⵊⵉ ⵛⵛⵡⴰⵟⴻⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK1_35","071_1_35","MRK","1","35","35","ⵜⵉⵡⴻⵛⵛⴰ ⵣⵉⵛ, ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⴵⵉⵍⴻⵜ, ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰⵏ, ⵜⵓⵖⴰ ⵉⵜⵜⵥⴰⴵⴰ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_36","071_1_36","MRK","1","36","36","ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ, ⴰⵔⵣⵓⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK1_37","071_1_37","MRK","1","37","37","ⵍⴰⵎⵉ ⵜ ⵓⴼⵉⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⴽ!” ");
INSERT INTO rift_vpl VALUES ("MK1_38","071_1_38","MRK","1","38","38","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⴷⵛⵓⵔⴰⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵢⵓⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⴱⴰⵔⵔⵃⴻⵖ ⵄⴰⵡⴻⴷ ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉ ⵓⵢⴰ ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("MK1_39","071_1_39","MRK","1","39","39","ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵊⴰⵍⵉⵍ, ⵓ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK1_40","071_1_40","MRK","1","40","40","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ ⴷⴰⵢⴻⵙ ⵍⴱⴰⵔⵚ, ⵉⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵜⵜⴰⵔ ⴰⵙ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵣⴷⴻⴳⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK1_41","071_1_41","MRK","1","41","41","ⵉⵣⵣⵉⴵⴻⵣ ⵉ ⵢⴰⵙⵓⵄ, ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵃⴰⴷⴰ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵙⴻⵖ! ⵉⵡⴰ, ⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵣⴷⴰⴳ!” ");
INSERT INTO rift_vpl VALUES ("MK1_42","071_1_42","MRK","1","42","42","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵅⴰⵙ ⵍⴱⴰⵔⵚ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("MK1_43","071_1_43","MRK","1","43","43","ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵄⵍⴻⵎ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵍⴻⵅⴷⴻⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("MK1_44","071_1_44","MRK","1","44","44","ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⵡⴰⵔ ⵜ ⵜⵜⵄⵉⵡⵉⴷ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊⴻⵏ, ⵎⴰⵛⴰ ⵔⵓⵃ, ⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⵓⴽⴻⵀⵀⴰⵏ ⵓⵛⴰ ⴻⵡⵛ ⵅ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵛ ⵎⵉⵏ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵛⴻⵀⴷⴻⴷ ⵉ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK1_45","071_1_45","MRK","1","45","45","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵉⵔⵓⵃ, ⵉⴱⴷⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵢⴰⵙⵓⵄ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ-ⵜ ⴱⴰⵔⵔⴰ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵉⵅⵍⴰⵏ, ⵜⵓⵖⴰ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵣⵉ ⴽⵓⵍ ⵊⵊⵡⴰⵢⴻⵀ. ");
INSERT INTO rift_vpl VALUES ("MK2_1","071_2_1","MRK","2","1","1","ⴰⵡⴰⵔⵏⵉ ⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ. ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("MK2_2","071_2_2","MRK","2","2","2","ⵎⵓⵏⴻⵏ ⵅⴰⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵡⴹⴻⵏ ⵓⵍⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵡⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("MK2_3","071_2_3","MRK","2","3","3","ⵓⵙⵉⵏ-ⴷⴷ ⵛⴰ ⵖⴰⵔⴻⵙ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵏⴻⵄⴹⴰⴱ ⵖⴰⵔⴻⵙ, ⴰⵔⴱⵓⵏ ⵜ-ⵉ-ⴷⴷ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK2_4","071_2_4","MRK","2","4","4","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵛⵉ, ⴳⴰⵄⵄⴷⴻⵏ ⵅ ⵜⵣⴻⵇⵇⴰ, ⴽⵙⵉⵏ ⵛⵡⴰⵢⵜ ⵣⵉ ⵜⵣⴻⵇⵇⴰ ⵙⴻⵏⵏⴻⵊ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⵙⵙⴻⵀⵡⴰⵏ-ⴷⴷ ⵜⴰⵙⵙⵓⵜ ⵎⵉⵏ ⵅⴻⴼ ⵉⵣⵣⴻⵍ ⵓⵏⴻⵄⴹⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MK2_5","071_2_5","MRK","2","5","5","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵓⵏⴻⵄⴹⴰⴱ: “ⴰ ⵎⵎⵉ, ⴰⵇⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK2_6","071_2_6","MRK","2","6","6","ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MK2_7","071_2_7","MRK","2","7","7","“ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰ ⵉ ⵉⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴰⵎⵎⵓ? ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ ⵎⵖⵉⵔ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵃⵃⴷⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("MK2_8","071_2_8","MRK","2","8","8","ⵢⵓⵛⴰ ⵢⴰⵙⵓⵄ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ ⴰⵎⵎⵓ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵅⴻⵎⵎⴰⵎⴻⵎ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MK2_9","071_2_9","MRK","2","9","9","ⵎⵉⵏ ⵉⵀⴻⵡⵏⴻⵏ ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵓⵏⴻⵄⴹⴰⴱ: ‘ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ’ ⵏⵉⵖ ⴰⴷ ⵉⵏⵉⵖ: ‘ⴽⴽⴰⵔ, ⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵓⵢⵓⵔ’? ");
INSERT INTO rift_vpl VALUES ("MK2_10","071_2_10","MRK","2","10","10","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ, ⵉⵏⵏⴰ ⵅⴻⵏⵏⵉ ⵉ ⵓⵏⴻⵄⴹⴰⴱ: ");
INSERT INTO rift_vpl VALUES ("MK2_11","071_2_11","MRK","2","11","11","‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⴽⴽⴰⵔ, ⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ, ⵜⵔⵓⵃⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ!’” ");
INSERT INTO rift_vpl VALUES ("MK2_12","071_2_12","MRK","2","12","12","ⴷⴻⵖⵢⴰ ⵉⴽⴽⴰⵔ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴰⵍⴰⵎⵉ ⵜⴱⴻⵀⵜⴻⵏ ⵎⴰⵔⵔⴰ, ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵏⵏⴰⵏ: “ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵏⴻⵥⵔⵉ ⵎⴰⵏ ⴰⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("MK2_13","071_2_13","MRK","2","13","13","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵍⵖⴰⵛⵉ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK2_14","071_2_14","MRK","2","14","14","ⴰⵎ ⵢⴻⵄⴷⵓ, ⵉⴱⴰⵔⵇ ⵍⴰⵡⵉ ⵎⵎⵉⵙ ⵏ ⵃⴰⵍⴼⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!”. ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK2_15","071_2_15","MRK","2","15","15","ⴰⵎ ⵉⵇⵇⵉⵎ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⴰⵟⵟⴰⵙ ⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⵇⵇⵉⵎⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK2_16","071_2_16","MRK","2","16","16","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴰⵇⴰ ⵉⵜⵜⴻⵜⵜ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⵏⵏⴰⵏ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⴻⵜⵜ, ⵉⵙⴻⵙⵙ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ?” ");
INSERT INTO rift_vpl VALUES ("MK2_17","071_2_17","MRK","2","17","17","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⵏⵉ ⵉⵚⴻⵃⵃⴻⵏ ⵡⴰⵔ ⵃⴷⵉⵊⴻⵏ ⵛⴰ ⴰⴹⴱⵉⴱ, ⵎⴰⵛⴰ ⵉⵎⴻⵀⵍⴰⵛ ⵡⴰⵀ. ⴰⵇⴰ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵃⵉⵎⴰ ⴰⴷ ⵍⴰⵖⵉⵖ ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵎⴰⵛⴰ ⵉ ⵉⵎⴻⴷⵏⴰⴱ.” ");
INSERT INTO rift_vpl VALUES ("MK2_18","071_2_18","MRK","2","18","18","ⵜⵓⵖⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵜⵜⵥⵓⵎⵎⴰⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⵥⵓⵎⵎⴰⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⵜⵥⵓⵎⵎⵉⵏ ⵛⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK2_19","071_2_19","MRK","2","19","19","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵜⴰⵔⵡⴰ ⵏ ⵓⵎⵓⵍⴰⵢ ⴰⴷ ⵥⵓⵎⵎⴻⵏ ⴷ ⵓⵎⵓⵍⴰⵢ ⵄⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ? ⵍⵍⴰ! ");
INSERT INTO rift_vpl VALUES ("MK2_20","071_2_20","MRK","2","20","20","ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵅⵎⵉ ⴷ ⵖⴰ ⵉⵎⵎⴻⴽⵙⵉ ⵓⵎⵓⵍⴰⵢ ⵅⴰⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵥⵓⵎⵎⴻⵏ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK2_21","071_2_21","MRK","2","21","21","ⵡⴰⵔ ⵉⴵⵉ ⵃⴻⴷ ⵉⵜⵜⵅⴻⵢⵢⴻⴹ ⵜⴰⵏⴻⵇⵇⵉⵍⵜ ⵣⵉ ⵜⵛⵓⵇⵇⴻⵜ ⵏ ⵊⴷⵉⴷ ⵅ ⵡⴰⵔⵔⵓⴹ ⴰⵇⴷⵉⵎ, ⵏⵉⵖ ⵅⴻⵏⵏⵉ ⵜⴰⵏⴻⵇⵇⵉⵍⵜ ⵏⵏⵉ ⵏ ⵊⴷⵉⴷ ⴰⴷ ⵜⴻⵇⵍⴻⵄ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⴰⴱⵓⵍⴰⵢ, ⵓⵛⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵓⵛⴰⵔⵔⴻⴳ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK2_22","071_2_22","MRK","2","22","22","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴼⴰⵔⵔⴻⵖ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵜⵉⵇⴷⵉⵎⵉⵏ, ⵃⵉⵎⴰ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵡⴰⵔ ⵉⵜⵜⵛⴰⵔⵔⵉⴳ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵓ ⵜⵉⵅⵓⵏⵛⴰⵢ ⴰⴷ ⴹⴻⵢⵢⵄⴻⵏⵜ ⵓⵛⴰ ⴱⵉⵏⵓ ⴰⴷ ⵉⵣⴻⴵⴻⵄ. ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴼⴰⵔⴻⵖ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵊⴷⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK2_23","071_2_23","MRK","2","23","23","ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵛⵓⵇ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵓⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴱⴷⴰⵏ ⵍⴻⵇⵇⴹⴻⵏ ⵜⵉⴷⵔⵉⵏ ⴰⵎ ⴳⴳⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK2_24","071_2_24","MRK","2","24","24","ⵏⵏⴰⵏ ⴰⵙ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ: “ⵅⵣⴰⵔ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵜⴻⴳⴳⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⴻⴵⵍⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK2_25","071_2_25","MRK","2","25","25","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵇⴰⵄ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⵚⴰⵔ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵍⴰⵥ, ⵏⴻⵜⵜⴰ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MK2_26","071_2_26","MRK","2","26","26","ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⴰⴱⵢⴰⵜⴰⵔ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⵉⵛⵛⴰ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵏ ⵙⵉⴷⵉ ⵉ ⵡⴰⵔ ⵉⵃⴻⴵⵍⴻⵏ ⴰⴷ ⵜ ⵛⵛⴻⵏ ⵎⵖⵉⵔ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵀⴰ, ⵓⵛⴰ ⵉⵡⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("MK2_27","071_2_27","MRK","2","27","27","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵉⵜⵜⵡⴰⴳⴳ ⵉ ⴱⵏⴰⴷⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴱⵏⴰⴷⴻⵎ ⵉ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("MK2_28","071_2_28","MRK","2","28","28","ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵍⴰ ⴷ ⴱⴰⴱ ⵏ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("MK3_1","071_3_1","MRK","3","1","1","ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵓⵛⵛⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("MK3_2","071_3_2","MRK","3","2","2","ⴱⴷⴰⵏ ⵃⴻⵟⵟⴰⵏ ⵜ, ⵎⴰ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵃⵉⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⴻⵜⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_3","071_3_3","MRK","3","3","3","ⵉⵏⵏⴰ ⴰⵙ ⵉ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴼⵓⵙ ⵉⵇⵓⵛⵛⴻⵃ: “ⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ.” ");
INSERT INTO rift_vpl VALUES ("MK3_4","071_3_4","MRK","3","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ: “ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⵉ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⵅⴰⵔ ⵏⵉⵖ ⵍⵖⴰⵔ, ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵉⵖ ⴰⴷ ⵜ ⵢⴰⵔⴻⴷⴷⴻⴵ?” ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵇⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_5","071_3_5","MRK","3","5","5","ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵙ ⵜⴻⴼⵇⴻⵃⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵡⴻⵔⵢⴰⵣ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ!” ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵉ-ⵜ-ⵉ-ⴷⴷ, ⵉⴷⵡⴻⵍ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵚⴻⵃⵃ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MK3_6","071_3_6","MRK","3","6","6","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴰⴽ-ⴷ ⵛⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵓⵛⴰ ⵎⵛⴰⵡⴰⵔⴻⵏ ⵅⴰⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵏ ⴰⴷ ⵜ ⴰⵔⴻⴷⴷⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_7","071_3_7","MRK","3","7","7","ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵉⴹⴻⴼⴼⴰⵔ ⵉ-ⵜ-ⴷⴷ ⵍⵖⴰⵛⵉ ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⵊⴰⵍⵉⵍ, ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("MK3_8","071_3_8","MRK","3","8","8","ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵣⵉ ⵉⴷⵓⵎⵉⵢⴰ, ⵣⴻⴳ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵣⵉ ⵚⵓⵔ ⵓ ⵣⵉ ⵚⴰⵢⴷⵓⵏ. ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("MK3_9","071_3_9","MRK","3","9","9","ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵖⴰⵔⴻⵙ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵛⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜ ⴷⴷⴻⵃⵃⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_10","071_3_10","MRK","3","10","10","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ, ⴰⵍⴰⵎⵉ ⵅⴰⵙ ⵡⴹⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵡⴹⴻⵏ ⴰⴷ ⵜ ⵃⴰⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_11","071_3_11","MRK","3","11","11","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⴻⵢⵢⵃⴻⵏ ⵣⵉ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ, ⵡⴹⴰⵏ ⵣⵣⴰⵜⴻⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵏ, ⵙⵖⵓⵢⴻⵏ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK3_12","071_3_12","MRK","3","12","12","ⵎⴰⵛⴰ ⵉⵡⴻⵚⵚⴰ ⵜⴻⵏ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵍⴻⵅⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK3_13","071_3_13","MRK","3","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵍⵉ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵏⵏⵉ ⵉⵅⵙ, ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK3_14","071_3_14","MRK","3","14","14","ⵉⴼⴰⵔⵣ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵍⵉⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⴽⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ");
INSERT INTO rift_vpl VALUES ("MK3_15","071_3_15","MRK","3","15","15","ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵚⵚⵓⵍⵟⴰ ⵅ ⵓⵙⴳⴻⵏⴼⵉ ⵏ ⵍⴻⵀⵍⴰⵛ ⵓ ⵅ ⵓⵙⵓⴼⴼⴻⵖ ⵏ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_16","071_3_16","MRK","3","16","16","ⵛⵉⵎⵄⵓⵏ ⵉⴳⴳⴰ ⴰⵙ ⴱⵓⵟⵔⵓⵙ, ⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵥⵔⵓ’, ");
INSERT INTO rift_vpl VALUES ("MK3_17","071_3_17","MRK","3","17","17","ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴱⴷⵉ, ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵓⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵉⵙⴻⵎⵎⴰ ⴰⵜⴻⵏ ‘ⴱⵓⵡⴰⵏⵉⵔⵊⵉⵙ’, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵢⵜ ⵏ ⵡⴰⵊⵊⴰⵊ’, ");
INSERT INTO rift_vpl VALUES ("MK3_18","071_3_18","MRK","3","18","18","ⵓⵛⴰ ⵉⴼⴰⵔⵣ ⵄⴰⵡⴻⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ ⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ ⴷ ⴱⴰⵔ-ⵜⵓⵍⵓⵎⴰⵡⵓⵙ ⴷ ⵎⴰⵜⵜⴰ ⴷ ⵜⵓⵎⴰ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵍⴼⴰ, ⴷ ⵜⴰⴷⴷⴰⵢ ⴷ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ⴰⵎⵄⴻⵙⵙⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("MK3_19","071_3_19","MRK","3","19","19","ⴷ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK3_20","071_3_20","MRK","3","20","20","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⵉⵏⵏⴻⵢⵔⵓ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵍⵖⴰⵛⵉ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵅ ⵎⴰⵛⵛⴰ ⵏ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("MK3_21","071_3_21","MRK","3","21","21","ⵓⵎⵉ ⵙⵍⵉⵏ ⵍⴰⴵ ⵏⵏⴻⵙ ⵎⴰⵏ ⴰⵢⴰ, ⴼⴼⵖⴻⵏ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⴱⴱⵓⵀⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK3_22","071_3_22","MRK","3","22","22","ⵎⴰⵛⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷⴰⵢⴻⵙ ‘ⴱᵉⵄⴰⵍⵣⴰⴱⵓⴱ’!” ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵙ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK3_23","071_3_23","MRK","3","23","23","ⵉⵍⴰⵖⴰ ⴰⵙⴻⵏ-ⴷⴷ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵉⵎⴻⴷⵢⴰ: “ⵎⴰⵎⵎⴻⵛ ⵉⵣⴻⵎⵎⴰⵔ ⵛⵛⵉⵟⴰⵏ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵛⵛⵉⵟⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("MK3_24","071_3_24","MRK","3","24","24","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵜⴻⵎⵙⴻⴱⴹⴰ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⵉ ⴰⴷ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MK3_25","071_3_25","MRK","3","25","25","ⵎⴰⵍⴰ ⵜⴻⵎⵙⴻⴱⴹⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⴰⴷ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MK3_26","071_3_26","MRK","3","26","26","ⵎⴰⵍⴰ ⵉⴽⴽⴰⵔ ⵛⵛⵉⵟⴰⵏ ⴹⵉⴷⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⵉⵊⵊⴻⵏ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴱⴻⴷⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK3_27","071_3_27","MRK","3","27","27","ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵍⴻⵇⵛⵓⵄ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵛⴰⵔⴼ ⵡⴻⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵎⴻⵣⵡⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴽⴻⵛⵛⴻⴹ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK3_28","071_3_28","MRK","3","28","28","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⴱⴻⵍⵍⵉ ⴰⴷ ⴰⵙⴻⵏ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷ ⴰⵛⴻⵇⵇⴻⴼ ⵉ ⵣⵉ ⵖⴰ ⵛⴻⵇⵇⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MK3_29","071_3_29","MRK","3","29","29","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵇⵇⴼⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵡⴻⵖⴼⴰⵔ ⵇⴰⵄ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵅⴰⵙ ⵙ ⵍⵃⵓⴽⵎ ⵉⵜⵜⴷⵓⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK3_30","071_3_30","MRK","3","30","30","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK3_31","071_3_31","MRK","3","31","31","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⵢⴻⵎⵎⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ, ⴱⴻⴷⴷⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵙⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵍⴰⵖⴰⵏ ⴰⵙ-ⴷⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK3_32","071_3_32","MRK","3","32","32","ⵓⵛⴰ ⵍⵖⴰⵛⵉ ⵇⵇⵉⵎⴻⵏ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ, ⵢⴻⵎⵎⴰⵛ ⴷ ⴰⵢⵜⵎⴰⵛ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⴱⴰⵔⵔⴰ, ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("MK3_33","071_3_33","MRK","3","33","33","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵜⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵢⴻⵎⵎⴰ ⵓ ⵎⴰⵏ ⵢⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵜⵎⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK3_34","071_3_34","MRK","3","34","34","ⵓⵛⴰ ⵓⵎⵉ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵢⴻⵎⵎⴰ ⴷ ⴰⵢⵜⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("MK3_35","071_3_35","MRK","3","35","35","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⵓⵎⴰ ⴷ ⵓⵍⵜⵎⴰ ⴷ ⵢⴻⵎⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK4_1","071_4_1","MRK","4","1","1","ⵉⴱⴷⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵓ ⵉⵎⵓⵏ-ⴷⴷ ⵅⴰⵙ ⵍⵖⴰⵛⵉ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⵢⴻⵏⵢⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⴰⵢⴻⵙ ⵅ ⵍⴻⴱⵃⴰⵔ, ⴰⵎ ⵍⵖⴰⵛⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ-ⵜ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵅ ⵍⴱⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("MK4_2","071_4_2","MRK","4","2","2","ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ ⵙ ⵉⵎⴻⴷⵢⴰ ⴰⵟⵟⴰⵙ. ⵉⵏⵏⴰ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("MK4_3","071_4_3","MRK","4","3","3","“ⵙⵍⴻⵎ! ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⴼⴻⴵⴰⵃ ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴰⵔⵄ. ");
INSERT INTO rift_vpl VALUES ("MK4_4","071_4_4","MRK","4","4","4","ⴰⵎ ⵜⵓⵖⴰ ⵉⵣⴰⵔⵔⴻⵄ, ⵜⴻⵡⴹⴰ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵅ ⵜⵎⴰ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵉⵅⴻⵛⵛ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵊⴹⵉⴹ, ⵉⵏⴻⵇⴱ ⵉ-ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("MK4_5","071_4_5","MRK","4","5","5","ⵜⴻⵡⴹⴰ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵥⵔⵓ ⵎⴰⵏⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵓⵖⵉ ⴱⵓ ⵓⵛⴰⵍ ⴰⵟⵟⴰⵙ. ⴷⴻⵖⵢⴰ ⵜⴻⵖⵎⵉ ⵙ ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵔ ⵜⵓⴵⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("MK4_6","071_4_6","MRK","4","6","6","ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⵜⴻⵛⵎⴻⴹ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⴱⵓ ⵡⴻⵥⵡⴰⵔ, ⵅⴻⵏⵏⵉ ⵜⵉⵙⵍⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("MK4_7","071_4_7","MRK","4","7","7","ⵜⴻⵡⴹⴰ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵊⴰⵔ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓⵛⴰ ⵎⵖⴰⵔⴻⵏ ⵅⴰⵙ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓⵛⴰ ⵊⴻⵢⵢⵃⴻⵏ ⵜⵜ, ⵡⴰⵔ ⵜⴻⵡⵛⵉ ⵛⴰ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK4_8","071_4_8","MRK","4","8","8","ⵜⴻⵡⴹⴰ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵚⴱⴻⵃ ⵓⵛⴰ ⵜⴻⵖⵎⵉ, ⵜⴻⴳⵎⴰ, ⵜⴻⵡⵛⴰ ⵍⵖⵉⴵⴻⵜ. ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵙ ⵜⵍⴰⵜⵉⵏ, ⵛⴰ ⵙ ⵙⴻⵜⵜⵉⵏ ⵓ ⵛⴰ ⵙ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MK4_9","071_4_9","MRK","4","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MK4_10","071_4_10","MRK","4","10","10","ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵜⴻⵏⵄⴰⵛ ⵅ ⵓⵎⴻⴷⵢⴰ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK4_11","071_4_11","MRK","4","11","11","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵙⵉⵔⵔ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⴷⵉ ⴱⴰⵔⵔⴰ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵍⵉ ⴽⵓⵍⵛⵉ ⵙ ⵉⵎⴻⴷⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("MK4_12","071_4_12","MRK","4","12","12","ⵃⵉⵎⴰ ⴰⵎ ⵜⵜⵡⴰⵍⴰⵏ, ⵜⵜⵡⴰⵍⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ, ⴰⵎ ⵜⵜⴻⵙⵍⴰⵏ, ⵜⵜⴻⵙⵍⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜᵉⵜⵓⴱⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("MK4_13","071_4_13","MRK","4","13","13","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵛⴰ ⵉ ⵓⵎⴻⴷⵢⴰ-ⵢⴰ? ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵜⵜⵉⵍⴻⵏ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("MK4_14","071_4_14","MRK","4","14","14","ⴰⴼⴻⴵⴰⵃ ⵏⵏⵉ ⵉⵣⴰⵔⵄⴻⵏ, ⵉⵣⴰⵔⵔⴻⵄ ⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("MK4_15","071_4_15","MRK","4","15","15","ⵉⵏⴰ ⴰⵇⴰ ⴷ ⵉⵏⵏⵉ ⵅ ⵡⴻⴱⵔⵉⴷ, ⴰⵇⴰ ⵢⵉⵏⴰ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⵣⴰⵔⵄ ⵡⴰⵡⴰⵍ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵙⵍⵉⵏ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵛⵛⵉⵟⴰⵏ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⴰⵡⴰⵍ ⵉ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK4_16","071_4_16","MRK","4","16","16","ⵓⵛⴰ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵃⴻⵊⵔⵉ, ⴰⵇⴰ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵅⵎⵉ ⵖⴰ ⵙⵍⴻⵏ ⴰⵡⴰⵍ, ⴰⴷ ⵜ ⵇⴻⴱⵍⴻⵏ ⴷⴻⵖⵢⴰ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("MK4_17","071_4_17","MRK","4","17","17","ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵊⵊⴰⴷⵉⵔⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵡⴰⵀⴰ. ⵎⴰⵍⴰ ⵜⴻⵎⵙⴰⵔ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵉⵖ ⵓⵎⴰⵔⵔⴻⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ, ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK4_18","071_4_18","MRK","4","18","18","ⵓⵛⴰ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵊⴰⵔ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⴰⵇⴰ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵅⵎⵉ ⵖⴰ ⵙⵍⴻⵏ ⴰⵡⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("MK4_19","071_4_19","MRK","4","19","19","ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⴰⴷⴼⴻⵏⵜ ⵜⵃⵉⵙⵙⴰⴼ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⴷ ⵓⵖⴻⴽⴽⵯⵉ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵏⵏⴻⵛⵡⴰⵜ ⵉⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵊⴻⵢⵢⴼⴻⵏⵜ ⴰⵡⴰⵍ, ⵅⴻⵏⵏⵉ ⵉⴷⴰⴽⴽⵯⴰⵍ ⵡⴰⵡⴰⵍ ⴱⵍⴰ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK4_20","071_4_20","MRK","4","20","20","ⵓⵛⴰ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴰⵔⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⵇⴰ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ, ⵅⵎⵉ ⵖⴰ ⵙⵍⴻⵏ ⴰⵡⴰⵍ, ⴰⴷ ⵜ ⵇⴻⴱⵍⴻⵏ, ⴰⴷ ⵡⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ, ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵍⴰⵜⵉⵏ, ⵉⵏⵏⴻⵖⵏⵉ ⵙⴻⵜⵜⵉⵏ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MK4_21","071_4_21","MRK","4","21","21","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵍⵇⴻⵏⴷⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⴰⵔⵙ ⵙⴰⴷⵓ ⵍⵎⵓⴷ ⵏ ⵉⵎⴻⵏⴷⵉ ⵏⵉⵖ ⵙⴰⴷⵓ ⵇⴰⵎⴰ? ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴰⵔⵙⵉ ⵛⴰ ⵅ ⵍⵎⴻⵔⴼⴻⵄ? ");
INSERT INTO rift_vpl VALUES ("MK4_22","071_4_22","MRK","4","22","22","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ, ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵡⴰⵔ ⵜᵉⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("MK4_23","071_4_23","MRK","4","23","23","ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MK4_24","071_4_24","MRK","4","24","24","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵃⴹⴰⵎ ⵎⵉⵏ ⵖⴰ ⵜⴻⵙⵍⴻⵎ. ⵙ ⵍⴻⵇⵢⴰⵙ ⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵜⴻⵄⴱⴰⵔⴻⵎ, ⵣⵣⴰⵢⴻⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵄⴱⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴰⵔⵏⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("MK4_25","071_4_25","MRK","4","25","25","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴷ ⴰⵙ ⵉⵎⵎⴰⵔⵏⵉ, ⵓ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ, ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK4_26","071_4_26","MRK","4","26","26","ⵉⵏⵏⴰ: “ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵏⴻⵟⵟⴰⵔ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("MK4_27","071_4_27","MRK","4","27","27","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵟⵟⴻⵚ, ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ, ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ. ⵓⵛⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴰⴷ ⵜⴳⴻⵄⵄⴻⴷ, ⴰⴷ ⵜⴻⴳⵎⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵎⵎⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("MK4_28","071_4_28","MRK","4","28","28","ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵜᵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ: ⴰⵎⴻⵣⵡⴰⵔ ⴰⵖⴻⵎⵎⵓⵢ, ⵅⴻⵏⵏⵉ ⵜⵉⴷⴰⵔⵜ, ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵔⴷⴻⵏ ⵉⴽⴻⵎⵎⵍⴻⵏ ⴷⵉ ⵜⵉⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK4_29","071_4_29","MRK","4","29","29","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵖⵉⴵⴻⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵎⵊⴰⵔ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⵢⵔⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK4_30","071_4_30","MRK","4","30","30","ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵏⴰⵔⵡⴻⵙ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵉⵖ ⵙ ⵎⴰⵏ ⴰⵎⴻⴷⵢⴰ ⵉ ⵣⵉ ⵜⵜ ⵉ ⵖⴰ ⵏⴰⵔⵛⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MK4_31","071_4_31","MRK","4","31","31","ⴰⵇⴰ-ⵜⵜ ⴰⵎ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⵅⴻⵔⴷⴻⵍ, ⵜⴻⵏⵏⵉ, ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵣⴰⵔⵄ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵃⴻⴱⴱⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK4_32","071_4_32","MRK","4","32","32","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵣⴰⵔⵄ, ⵜⴻⵖⵎⵉ-ⴷⴷ, ⵜⴻⵎⵖⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⴱⴱⵉ, ⴰⴷ ⵜⴻⴳⴳ ⵍⴻⴼⵔⵓⵄ ⵉⵎⵖⴰⵔⴻⵏ ⴰⵍⴰⵎⵉ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵄⵡⴰⵛⵛ ⴷⵉ ⵜⵉⵍⵉ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK4_33","071_4_33","MRK","4","33","33","ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴰⵡⴰⵍ ⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵉⵎⴻⴷⵢⴰ ⴰⵟⵟⴰⵙ ⴰⵎ ⵢⵉⵏⴰ, ⵙ ⵉⵎⴻⴷⵢⴰ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵍⴻⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK4_34","071_4_34","MRK","4","34","34","ⴱⵍⴰ ⵉⵎⴻⴷⵢⴰ ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ ⵛⴰ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⴼⵀⴰⵎ ⴽⵓⵍⵛⵉ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK4_35","071_4_35","MRK","4","35","35","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵍⴰⵎⵉ ⴷ ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK4_36","071_4_36","MRK","4","36","36","ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵍⵖⴰⵛⵉ, ⵉⵡⵢⴻⵏ ⵜ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK4_37","071_4_37","MRK","4","37","37","ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⵎⵖⴰⵔ, ⵍⴻⵎⵡⴰⵊ ⵛⵛⴰⵜⴻⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⴰⵍⴰⵎⵉ ⵜⴻⴱⴷⴰ ⵜᵉⵜⵜⵛⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK4_38","071_4_38","MRK","4","38","38","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵟⵟⴻⵚ ⵅ ⵉⵛⵜ ⵏ ⵜⵙⵓⵏⵜⴰ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ. ⵏⵉⵜⵏⵉ ⵙⵙⴼⴰⵇⴻⵏ ⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵏⴻⵛⵇⵉ ⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵍⴰ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("MK4_39","071_4_39","MRK","4","39","39","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ, ⵉⵡⴻⴱⴱⴻⵅ ⴰⵙⴻⵎⵎⵉⴹ, ⵉⵏⵏⴰ ⵉ ⵍⴻⴱⵃⴰⵔ: “ⴰⵔⵙ! ⵙⵇⴰⵔ!” ⵢⴰⵔⵙⴰ ⵓⵙⴻⵎⵎⵉⴹ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴽⵓⵍⵛⵉ ⵢⴰⵔⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("MK4_40","071_4_40","MRK","4","40","40","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⴰⵎⵎⵓ? ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵖⵉⵏ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⴱⵓ ⵍ’ⵉⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK4_41","071_4_41","MRK","4","41","41","ⵜⵓⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ, ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⴰⵙⴻⵎⵎⵉⴹ ⴷ ⵍⴻⴱⵃⴰⵔ ⵜⵜᵉⵟⵟⴰⵄⴻⵏ ⴰⵙ?” ");
INSERT INTO rift_vpl VALUES ("MK5_1","071_5_1","MRK","5","1","1","ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴳⴰⴷⴰⵔⵉⵏⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("MK5_2","071_5_2","MRK","5","2","2","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⵍⵇⴰ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵎⴻⵏⴳⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MK5_3","071_5_3","MRK","5","3","3","ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵜ ⵉⵛⴰⵔⴼ ⵓⵍⴰ ⵙ ⵙⵙⵏⴰⵙⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("MK5_4","071_5_4","MRK","5","4","4","ⵎⵉⵏⵣⵉ ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵛⴰⵔⴼⴻⵏ ⵜ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵙ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵓ ⵙ ⵙⵙⵏⴰⵙⴻⵍ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵇⴹⵓ ⵙⵙⵏⴰⵙⴻⵍ ⵏⵏⵉ, ⵢⴰⵔⵥⴰ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵓ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵜ ⵉⵇⴻⵎⵎⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("MK5_5","071_5_5","MRK","5","5","5","ⵜⵓⵖⴰ-ⵜ ⵍⴻⴱⴷⴰ, ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⴷⴻⴳ ⵉⴷⵓⵔⴰⵔ ⵓ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ, ⵉⵙⵖⵓⵢⵢⵓ, ⵉⵢⴻⵣⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵉⵥⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK5_6","071_5_6","MRK","5","6","6","ⵓⵎⵉ ⵉⵥⵔⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵙⵓⵄ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵢⵓⵣⵣⴻⵍ ⵓⵛⴰ ⵉⵙⵊⴻⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK5_7","071_5_7","MRK","5","7","7","ⵉⵙⵖⵓⵢ ⵙ ⵊⵊⴻⵀⴷ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ ⴰⴽⵉⴷⴻⴽ, ⴰ ⵢⴰⵙⵓⵄ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⵙ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⵎⴰⵔⵔⴰⵜ!” ");
INSERT INTO rift_vpl VALUES ("MK5_8","071_5_8","MRK","5","8","8","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴼⴼⴻⵖ ⵣⵉ ⴱⵏⴰⴷⴻⵎ-ⴰ, ⴰ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ!” ");
INSERT INTO rift_vpl VALUES ("MK5_9","071_5_9","MRK","5","9","9","ⵉⵙⵙⴻⵇⵙⴰ ⵜ: “ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ?” ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵉⵙⴻⵎ ⵉⵏⵓ ‘ⵍⵉⵅⵢⵓⵏ’, ⵎⴰⵏ ⴰⵢⴰ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⴱⴰⵔⵔⵓ’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK5_10","071_5_10","MRK","5","10","10","ⵉⵣⴰⵡⴳ ⵉ-ⵜ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK5_11","071_5_11","MRK","5","11","11","ⵜⵓⵖⴰ ⴷⵉⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⵜⴻⵎⵖⴰⵔ ⵏ ⵉⵍⴼⴰⵏ ⵜᵉⵜⵜⵀⴻⴷⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MK5_12","071_5_12","MRK","5","12","12","ⵣⴰⵡⴳⴻⵏ ⵜ ⵛⵛⵡⴰⵟⴻⵏ ⵏⵏⵉ, ⵏⵏⴰⵏ: “ⵙⴻⴽⴽ ⴰⵏⴻⵖ ⵖⴰⵔ ⵉⵍⴼⴰⵏ, ⵃⵉⵎⴰ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵏⴰⴷⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("MK5_13","071_5_13","MRK","5","13","13","ⵉⵙⴰⵎⵃ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ, ⵓⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵍⴼⴰⵏ, ⵓⵛⴰ ⵜⵓⵣⵣⴻⵍ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵏⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵊⵊⴰⵔⴼ ⵢⵓⵄⵍⴰⵏ ⵓⵛⴰ ⵜⴻⵡⴹⴰ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ⵜⵓⵖⴰ-ⵜⴻⵏ ⵄⵍⴰⵃⴰⵍ ⴷⴻⴳ ⵡⴰⵍⴼⴰⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵖⴰⵔⵇⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK5_14","071_5_14","MRK","5","14","14","ⵎⴰⵛⴰ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵏ ⵉⵍⴼⴰⵏ ⴰⵔⴻⵡⵍⴻⵏ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵅ ⵉⵢⵢⴰⵔⴻⵏ. ⵉⵡⴷⴰⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK5_15","071_5_15","MRK","5","15","15","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵜⵜⵡⴰⵍⴰⵏ ⴰⵎⴰⵔⵢⴰⵃ ⵉ ⴷⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵛⵛⵡⴰⵟⴻⵏ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ‘ⵍⵉⵅⵢⵓⵏ’, ⵉⵇⵇⵉⵎ, ⵢⴰⵔⴹ, ⵙ ⵍⴱⴰⵍ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK5_16","071_5_16","MRK","5","16","16","ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜⴻⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵓⵎⴰⵔⵢⴰⵃ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵛⵛⵡⴰⵟⴻⵏ, ⵓ ⵄⴰⵡⴻⴷ ⵅ ⵢⵉⵍⴼⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK5_17","071_5_17","MRK","5","17","17","ⵓⵛⴰ ⴱⴷⴰⵏ ⵜⵜⵣⴰⵡⴳⴻⵏ ⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳⵯⴻⵊ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK5_18","071_5_18","MRK","5","18","18","ⵍⴰⵎⵉ ⵉⵏⵢⴰ ⵏⴻⵜⵜⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⵣⴰⵡⴳ ⵉ-ⵜ ⵓⵎⴰⵔⵢⴰⵃ ⵉ ⴷⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵛⵛⵡⴰⵟⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK5_19","071_5_19","MRK","5","19","19","ⵡⴰⵔ ⵜ ⵉⵊⵊⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵍⴰⴵ ⵏⵏⴻⵛ, ⵅⴻⴱⴱⴰⵔ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⵎⴰⵎⵎⴻⵛ ⵅⴰⴽ ⵢⴰⵔⵃⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK5_20","071_5_20","MRK","5","20","20","ⵓⵛⴰ ⵉⵔⵓⵃ, ⵉⴱⴷⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴷⵉ ⴷⵉⴽⴰⴱⵓⵍⵉⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⴱⴻⵀⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK5_21","071_5_21","MRK","5","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵥⵡⴰ ⵢⴰⵙⵓⵄ ⵙ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ, ⵉⵎⵓⵏ-ⴷⴷ ⵅⴰⵙ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⴰⵎ ⵜⵓⵖⴰ-ⵜ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK5_22","071_5_22","MRK","5","22","22","ⵢⵓⵙⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵢⵔⵓⵙ. ⵓⵎⵉ ⵜ ⵉⵥⵔⴰ, ⵉⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK5_23","071_5_23","MRK","5","23","23","ⵉⵣⴰⵡⴳ ⵉ-ⵜ ⴰⵟⵟⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⴵⵉ ⵜⵎⴰⵥⵓⵥⵜ ⵜⵃⴻⵍⵛ ⴰⵟⵟⴰⵙ. ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ, ⴰⴷ ⵅⴰⵙ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵏⴼⴰ, ⴰⴷ ⵜⴻⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MK5_24","071_5_24","MRK","5","24","24","ⵉⵔⵓⵃ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵃⵃⵙⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK5_25","071_5_25","MRK","5","25","25","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("MK5_26","071_5_26","MRK","5","26","26","ⵓⵛⴰ ⵜⴻⴽⴽⴰ ⵅⴰⵙ ⵜⴰⵎⴰⵔⴰ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⴹⴱⵉⴱⴻⵏ ⵓⵎⵉ ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵙⵜⴻⵏⴼⵉⵄ ⵙ ⵡⴰⵍⵓ, ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⵄⴰⴷ ⵅⴰⵙ ⵍⵃⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("MK5_27","071_5_27","MRK","5","27","27","ⴰⵇⴰ ⵜⴻⵙⵍⴰ ⵅ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴰⵎ ⵜⴻⴽⴽⴰ ⵅ ⴷⴷⵃⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵃⴰⴷⴰ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MK5_28","071_5_28","MRK","5","28","28","ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰ: “ⵎⴰⵍⴰ ⵃⴰⴷⵉⵖ ⵎⵖⵉⵔ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴷⴷⴰⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("MK5_29","071_5_29","MRK","5","29","29","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵥⴻⵖ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵜⵓⵛⴰ ⴰⴽ-ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⵜⴻⴳⴳⴻⵏⴼⴰ ⵣⵉ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK5_30","071_5_30","MRK","5","30","30","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵛⴰ ⵢⴰⵙⵓⵄ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ ⵊⵊⴻⵀⴷ ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵖⴰⵔ ⵍⵖⴰⵛⵉ, ⵉⵏⵏⴰ: “ⵡⵉ ⵉⵃⴰⴷⴰⵏ ⴰⵔⵔⵓⴹ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("MK5_31","071_5_31","MRK","5","31","31","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵛⴻⴽ ⵜⵡⴰⵍⵉⴷ ⵍⵖⴰⵛⵉ ⵉⴷⴻⵃⵃⴻⵙ ⵉ ⵛⴻⴽ ⵓ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ: ‘ⵡⵉ ⴷ ⴰⵢⵉ ⵉⵃⴰⴷⴰⵏ?’” ");
INSERT INTO rift_vpl VALUES ("MK5_32","071_5_32","MRK","5","32","32","ⵎⴰⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵅⴻⵣⵣⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⵡⵉ ⵢⴻⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK5_33","071_5_33","MRK","5","33","33","ⵜⵓⵖⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵜⴻⴳⴳⵯⴻⴷ, ⵜᵉⵜⵜⴰⵔⵊⵉⵊⵉ, ⴰⵎ ⵜⴻⵙⵙⴻⵏ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵙⴰⵔⴻⵏ, ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ, ⵜⴻⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵜⵄⴰⵡⴻⴷ ⴰⵙ ⵜⵉⴷⴻⵜⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK5_34","071_5_34","MRK","5","34","34","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵢⴻⴵⵉ, ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵎ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵎ ⵜⵓⴷⴰⵔⵜ, ⵔⵓⵃ ⵙ ⵍⴻⵀⵏⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ ⵣⵉ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("MK5_35","071_5_35","MRK","5","35","35","ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵓⵙⵉⵏ-ⴷⴷ ⵛⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⵉⴵⵉⵛ ⵜⴻⵎⵎⵓⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵚⴻⴷⴷⴰⵄⴻⴷ ⵄⴰⴷ ⴰⵎⵙⴻⵖⵖⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("MK5_36","071_5_36","MRK","5","36","36","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵍⴰ ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵏⵏⴰⵏ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ! ⴰⵎⴻⵏ ⵡⴰⵀⴰ!” ");
INSERT INTO rift_vpl VALUES ("MK5_37","071_5_37","MRK","5","37","37","ⵡⴰⵔ ⵉⵙⵎⵉⵃ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊⴻⵏ ⴰⴷ ⵜ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⴻⵙ, ⵎⵖⵉⵔ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵓⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("MK5_38","071_5_38","MRK","5","38","38","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ ⵓⵛⴰ ⵉⵥⵔⴰ ⵉ-ⵜⴻⵏ ⵛⵛⴰⵜⴻⵏ ⴰⴳⴻⵊⴷⵓⵔ, ⵜⵜⵔⵓⵏ ⵓⵛⴰ ⵙⵖⵓⵢⵢⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MK5_39","071_5_39","MRK","5","39","39","ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵛⵛⴰⵜⴻⵎ ⴰⴳⴻⵊⴷⵓⵔ, ⵜᵉⵜⵜⵔⵓⵎ? ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵡⴰⵔ ⵜⴻⵎⵎⵓⵜ ⵛⴰ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵜᵉⵟⵟⴻⵚ.” ");
INSERT INTO rift_vpl VALUES ("MK5_40","071_5_40","MRK","5","40","40","ⵏⵉⵜⵏⵉ ⴹⴻⵃⵛⴻⵏ ⵣⵣⴰⵢⴻⵙ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⴽⵓⵍⵛⵉ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⴽⵉⴷⴻⵙ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ, ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵜⵃⴻⵏⵊⵉⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK5_41","071_5_41","MRK","5","41","41","ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⴰ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("MK5_42","071_5_42","MRK","5","42","42","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵓⵛⴰ ⵜⵓⵢⵓⵔ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵖⴰⵔⴻⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵜⴱⴻⵀⵜⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵜⴻⴱⵀⴻⵜ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK5_43","071_5_43","MRK","5","43","43","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵙ ⵊⵊⴻⵀⴷ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵎⴰⵏ ⴰⵢⴰ. ⵅⴻⵏⵏⵉ ⵉⵡⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("MK6_1","071_6_1","MRK","6","1","1","ⵉⴼⴼⴻⵖ ⵙⵙⴻⵏⵏⵉ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK6_2","071_6_2","MRK","6","2","2","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵙⵙⴻⴱⵜ, ⵉⴱⴷⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ. ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ, ⵜⴱⴻⵀⵜⴻⵏ, ⵏⵏⴰⵏ: “ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ? ⵎⴰⵏⴰ ⵜⵉⵖⵉⵜ-ⴰ ⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴰⵍⴰⵎⵉ ⵎⵙⴰⵔⴻⵏⵜ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴰⵎ ⵜⵉⵏⴰ? ");
INSERT INTO rift_vpl VALUES ("MK6_3","071_6_3","MRK","6","3","3","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰ ⴷ ⴰⵏⴻⵊⵊⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵔⵢⴰⵎ, ⴷ ⵓⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵙⵉⵙ ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵛⵉⵎⵄⵓⵏ? ⵎⴰ ⵡⴰⵔ ⴵⵉⵏⵜ ⵙⵓⵢᵉⵜⵎⴰⵙ ⴷⴰ ⴰⴽⵉⴷⵏⴻⵖ?” ⵓ ⵏⵉⵜⵏⵉ ⵏⴷⴻⵔⴼⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK6_4","071_6_4","MRK","6","4","4","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵏⴰⴱⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⴵⵉ ⴱⵍⴰ ⵛⵛⴰⵏ ⵎⵖⵉⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵊⴰⵔ ⵍⴰⴵ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK6_5","071_6_5","MRK","6","5","5","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵉⴳⴳ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵄⵊⴻⴱ, ⵉⵍⵍⴰ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⴷⵔⵓⵙ ⵏ ⵉⵎⴻⵀⵍⴰⵛ ⵡⴰⵀⴰ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_6","071_6_6","MRK","6","6","6","ⵜⵓⵖⴰ ⵉⵜⵜⴻⴱⵀⴻⵜ ⵣⵉ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ, ⵉⵜⵜⵙⴰⵔⴰ ⴷⵛⵓⵔⴰⵜ ⵢⵓⴷⵙⴻⵏ, ⵉⵙⵙⴻⵍⵎⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("MK6_7","071_6_7","MRK","6","7","7","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ, ⵉⴱⴷⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵜⵢⵓⵢⴰ ⵜⵢⵓⵢⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵅ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_8","071_6_8","MRK","6","8","8","ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵏ ⵡⴰⵍⵓ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⵖⵉⵔ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵡⴰⵀⴰ, ⵍⵍⴰ ⵜⵜⴻⵙⵟⵉⵎ, ⵍⵍⴰ ⴰⵖⵔⵓⵎ, ⵍⵍⴰ ⵜⵉⴱⵢⵉⵙⵉⵏ ⵏ ⵏⵏⵃⴰⵙ ⴷⵉ ⵜⴻⵛⵢⴰⵔⵉⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MK6_9","071_6_9","MRK","6","9","9","ⵎⴰⵛⴰ ⵉⵡⵛ ⴰⵙⴻⵏ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵏⴻⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⴰⵔⵔⴹⴻⵏ ⵜⵢⵓⵢⴰ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("MK6_10","071_6_10","MRK","6","10","10","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏⵉ ⵎⴰ ⵜⵓⴷⴼⴻⵎ ⵖⴰⵔ ⵛⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵇⵇⵉⵎⴻⵎ ⴷⴰⵢⴻⵙ, ⴰⵍ ⵙⵙⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⴼⴼⵖⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK6_11","071_6_11","MRK","6","11","11","ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴱⵉⵍⴻⵏ ⵓ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵜⵜⴻⵙⵍⵉⵏ, ⵣⵣⴻⵔⵣⴻⵎ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵏⵉⵜⵏⵉ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴰⵍ ⵉⵀⵡⴻⵏ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK6_12","071_6_12","MRK","6","12","12","ⵓⵛⴰ ⵔⵓⵃⴻⵏ, ⴱⴰⵔⵔⵃⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_13","071_6_13","MRK","6","13","13","ⵙⵙⵓⴼⴼⵖⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵛⵛⵡⴰⵟⴻⵏ, ⴷⴻⵀⵏⴻⵏ ⵉⵎⴻⵀⵍⴰⵛ ⴰⵟⵟⴰⵙ ⵙ ⵣⵣⴻⵛⵜ ⵓⵛⴰ ⵙⵙⴳⴻⵏⴼⴰⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_14","071_6_14","MRK","6","14","14","ⵉⵙⵍⴰ ⵅⴰⵙ ⵓⵊⴻⴵⵉⴷ ⵀⵉⵔⵓⴷⵓⵙ, ⵎⵉⵏⵣⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⵉⵛⵏⴻⵄ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵣⵣⴰⵢⴻⵙ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK6_15","071_6_15","MRK","6","15","15","ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ-ⵜ ⴷ ⵉⵍⵉⵢⴰ!”, ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ: “ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⴰⴱⵉ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK6_16","071_6_16","MRK","6","16","16","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵀⵉⵔⵓⴷⵓⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ: “ⵡⴰ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⴻⵙⵙⴻⵖ ⴰⵣⴻⴵⵉⴼ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK6_17","071_6_17","MRK","6","17","17","ⵎⵉⵏⵣⵉ ⵀⵉⵔⵓⴷⵓⵙ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵃⴻⴱⴱⴻⵙ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵛⴰⵔⴼ ⵉ-ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵀⵉⵔⵓⴷⵉⵢⵢⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵙ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵜⴻⵏⵏⵉ ⵉ-ⴽ-ⴷ ⵉⵎⵍⴻⵛ ⵀⵉⵔⵓⴷⵓⵙ.    ");
INSERT INTO rift_vpl VALUES ("MK6_18","071_6_18","MRK","6","18","18","ⵎⵉⵏⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵉ ⵀⵉⵔⵓⴷⵓⵙ: “ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵖⴰⵔⴻⴽ ⵜⵉⵍⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵓⵎⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("MK6_19","071_6_19","MRK","6","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵀⵉⵔⵓⴷⵉⵢⵢⴰ ⵜⴻⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵓⵛⴰ ⵜⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜ ⵜⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("MK6_20","071_6_20","MRK","6","20","20","ⵎⵉⵏⵣⵉ ⵀⵉⵔⵓⴷⵓⵙ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵓ ⵉⵃⴻⵟⵟⴰ ⵅⴰⵙ. ⵉⵙⵍⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ, ⵓⵛⴰ ⵉⴼⴰⵔⵃ ⴰⴷ ⴰⵙ ⵉⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MK6_21","071_6_21","MRK","6","21","21","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵉⴳⴳⴰ ⵀⵉⵔⵓⴷⵓⵙ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵍⴰⵍⵉⵜ ⵏⵏⴻⵙ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏⵏⴻⵙ ⵉ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵎⵖⴰⵔⴻⵜ ⴰⵟⵟⴰⵙ, ⵉ ⴰⵔⵔⵓⵢⴰⵙ ⵅ ⵡⴰⵍⴻⴼ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MK6_22","071_6_22","MRK","6","22","22","ⵓⵛⴰ ⵜⵓⴷⴻⴼ-ⴷⴷ ⵢⴻⴵⵉⵙ ⵏ ⵀⵉⵔⵓⴷⵉⵢⵢⴰ, ⵜⴻⵛⴹⴻⵃ, ⵜⴻⵄⵊⴻⴱ ⴰⵙ ⵉ ⵀⵉⵔⵓⴷⵓⵙ ⴷ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⵓⵊⴻⴵⵉⴷ ⵉ ⵜⵃⴻⵏⵊⵉⵔⵜ: “ⵜⵜⴰⵔ ⵣⵣⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ, ⴰⴷ ⴰⵎ ⵜ ⵡⵛⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("MK6_23","071_6_23","MRK","6","23","23","ⵉⵊⵊⵓⴵ ⴰⵙ: “ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⴷ, ⴰⴷ ⴰⵎ ⵜ ⵡⵛⴻⵖ, ⵡⴰⵅⵅⴰ ⴰⵍ ⴰⵣⵢⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("MK6_24","071_6_24","MRK","6","24","24","ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵏⴻⵜⵜⴰⵜ, ⵜⴻⵏⵏⴰ ⵉ ⵢⴻⵎⵎⴰⵙ: “ⵎⵉⵏ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵜⵜⴰⵔⴻⵖ?” ⵜⴻⵏⵏⴰ ⴰⵙ ⵜⴰⵏⵉⵜⴰ: “ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ.” ");
INSERT INTO rift_vpl VALUES ("MK6_25","071_6_25","MRK","6","25","25","ⵜⵓⴷⴻⴼ ⴷⴻⵖⵢⴰ ⵙ ⵜⴰⵣⵍⴰ ⵖⴰⵔ ⵓⵊⴻⴵⵉⴷ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵅⵙⴻⵖ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ-ⴰ ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⵅ ⵉⵊⵊ ⵏ ⵟⵟⴻⴱⵚⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK6_26","071_6_26","MRK","6","26","26","ⵉⵛⴹⴻⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵓ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ, ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜⵜ ⵉⵇⴻⵎⵎⴻⵄ, ");
INSERT INTO rift_vpl VALUES ("MK6_27","071_6_27","MRK","6","27","27","ⵓ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵓⵊⴻⴵⵉⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵖⴰⵔ ⵍⴻⵃⴱⴻⵙ ⵙ ⵙⵙⵉⴼ, ⵢⵓⵎⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵃⴰⵏⵏⴰ. ⵡⴰⵏⵉⵜⴰ ⵉⵔⵓⵃ, ⵉⵇⴻⵙⵙ ⴰⵙ ⴰⵣⴻⴵⵉⴼ ⵉ ⵢⵓⵃⴰⵏⵏⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK6_28","071_6_28","MRK","6","28","28","ⵅⴰⵙ ⵓⵛⴰ ⵢⵉⵡⵉ-ⴷⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵅ ⵟⵟⴻⴱⵚⵉ, ⵉⵡⵛⴰ ⴰⵙ ⵜ ⵉ ⵜⵃⴻⵏⵊⵉⵔⵜ ⵓ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ ⵜⴻⵡⵛ ⴰⵙ ⵜ ⵉ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK6_29","071_6_29","MRK","6","29","29","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵙⵉⵏ-ⴷⴷ, ⴽⵙⵉⵏ ⵍⵅⴻⵛⴱⴻⵜ ⵏⵏⴻⵙ, ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MK6_30","071_6_30","MRK","6","30","30","ⵎⵓⵏⴻⵏ ⵔⵔⵓⵙⵓⵍ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜ ⵅ ⴽⵓⵍⵛⵉ, ⵅ ⵎⵉⵏ ⴳⴳⵉⵏ ⴷ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("MK6_31","071_6_31","MRK","6","31","31","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵙⴻⵎ-ⴷⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵡⴻⵃⵃⴻⴷⵏⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⴻⵢⵢⵃⴻⵎ ⵛⵡⴰⵢⵜ!” ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵔⵓⵃⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵡⵉⴹⴻⵏ ⴰⴷ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_32","071_6_32","MRK","6","32","32","ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_33","071_6_33","MRK","6","33","33","ⵎⴰⵛⴰ ⵍⵖⴰⵛⵉ ⵉⵥⵔⴰ ⵉ-ⵜⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵉ-ⵜ ⵄⴻⵇⵍⴻⵏ. ⵓⵛⴰ ⵉⵣⵡⴰⵔⴻⵏ ⴰⵙ ⴰⵎ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵖⴰⵔ ⴷⵉⵏⵏⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("MK6_34","071_6_34","MRK","6","34","34","ⵓⵎⵉ ⴷⴷ-ⵉⴹⵔⴰ ⵢⴰⵙⵓⵄ, ⵉⵥⵔⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ, ⵣⵣⵉⴵⵣⴻⵏ ⴰⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⵎ ⵡⵓⴵⵉ ⴱⵍⴰ ⴰⵎⴻⴽⵙⴰⵡ. ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK6_35","071_6_35","MRK","6","35","35","ⵔⴰⵎⵉ ⵉⵔⵓⵃ ⵡⴰⵙⵙ ⴰⴷ ⵉⵇⴹⴰ, ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵎⵛⴰⵏ-ⴰ ⵉⵅⵍⴰ ⵓ ⵍⵡⴻⵇⵜ ⵜⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("MK6_36","071_6_36","MRK","6","36","36","ⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵍⴻⵄⵔⴰⵚⵉⵢⵢⴰⵜ ⵓ ⵖⴰⵔ ⴷⵛⵓⵔⴰⵜ ⵢⵓⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵖⴻⵏ ⴰⵖⵔⵓⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK6_37","071_6_37","MRK","6","37","37","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵛⴻⵎ ⴰⵙⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ!” ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⴰⴷ ⵏⵔⴰⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵏⵙⴻⵖ ⴰⵖⵔⵓⵎ ⵙ ⵎⵉⵜⴰⵢⴻⵏ ⴷⵉⵏⴰⵔ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵏⴻⵡⵛ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK6_38","071_6_38","MRK","6","38","38","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵅⵣⴰⵔⴻⵎ ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴰⵏⵉⵜⴰ!” ⵓⵎⵉ ⴰⵔⴳⴱⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK6_39","071_6_39","MRK","6","39","39","ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⵖⵉⵎⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵜⵄⵓⵔⵔⵉⵛⵉⵏ ⵅ ⴰⵔⴱⵉⵄ ⴰⵣⵉⵣⴰ. ");
INSERT INTO rift_vpl VALUES ("MK6_40","071_6_40","MRK","6","40","40","ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵄⵓⵔⵔⵉⵛⵉⵏ ⵏ ⵎⵢⴰ ⵓ ⴷⵉ ⵜⵄⵓⵔⵔⵉⵛⵉⵏ ⵏ ⵅⴻⵎⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_41","071_6_41","MRK","6","41","41","ⵓⵎⵉ ⵉⴽⵙⵉ ⵢⴻⵛⵛⵓ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵏⵏⵉ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⴱⴰⵔⴻⴽ ⵓⵛⴰ ⵢⴰⵔⵥⴰ ⵜⵉⵛⵏⵉⴼⵉⵏ, ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵣⵣⴰⵜⵙⴻⵏ. ⴰⵎⵎⵓ ⵉ ⴼⴰⵔⵇⴻⵏ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK6_42","071_6_42","MRK","6","42","42","ⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ, ⵊⵊⵉⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_43","071_6_43","MRK","6","43","43","ⵅⴻⵏⵏⵉ ⵍⴻⵇⴹⴻⵏ ⵉⵍⴻⵇⵇⵯⴰⵣ ⵉⵛⴻⵟⵟⴻⵏ, ⵛⵛⵓⵔⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ, ⵓⵍⴰ ⴷ ⵉⵙⴻⵍⵎⴰⵏ ⵉⵛⴻⵟⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_44","071_6_44","MRK","6","44","44","ⵉⵏⵏⵉ ⵉⵛⵛⵉⵏ ⵣⵉ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK6_45","071_6_45","MRK","6","45","45","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵣⵉⵢⵢⴰⵔ ⵅ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⴰⴷ ⴰⵙ ⵉⵣⵡⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ, ⵖⴰⵔ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ ⴰⵎ ⵉⵙⵇⴰⴷ ⵏⴻⵜⵜⴰ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MK6_46","071_6_46","MRK","6","46","46","ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏ ⵉⵙⵇⴰⴷ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ. ");
INSERT INTO rift_vpl VALUES ("MK6_47","071_6_47","MRK","6","47","47","ⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ ⵜⵓⵖⴰ ⵜⴰⵖⴰⵔⵔⴰⴱⵓⵜ ⴷⵉ ⵍⴱⵓⵖⴰⵣ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴻⵃⵃⴷⴻⵙ ⵅ ⵍⴱⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("MK6_48","071_6_48","MRK","6","48","48","ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵜⵜⴻⵎⵇⴻⵜⵎⴰⵔⴻⵏ ⵙ ⵓⵇⴻⴷⴷⴻⴼ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵎⵉⵏⵣⵉ ⴰⵙⴻⵎⵎⵉⴹ ⵢⵓⵙⴰ ⴰⵙⴻⵏ-ⴷⴷ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ. ⵖⴰⵔ ⵃⴻⵟⵟⵓ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⴵⵉⵍⴻⵜ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⴳⴳⵓⵔ ⵅ ⵡⴰⵡⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("MK6_49","071_6_49","MRK","6","49","49","ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ ⵉⴳⴳⵓⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴷ ⵍⴻⵅⵢⴰⵍ ⴰⵖⴻⴷⴷⴰⵔ ⵓⵛⴰ ⵙⵖⵓⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MK6_50","071_6_50","MRK","6","50","50","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵥⵔⵉⵏ ⵜ ⵓⵛⴰ ⵏⵏⵅⴻⵍⵄⴻⵏ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴳⴳⴻⵎ ⵓⵍ! ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("MK6_51","071_6_51","MRK","6","51","51","ⵉⵏⵢⵉ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵓⵛⴰ ⵢⴰⵔⵙⴰ ⵓⵙⴻⵎⵎⵉⴹ. ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴱⴻⵀⵜⴻⵏ, ⴰⵔⴻⵡⵡⵄⴻⵏ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MK6_52","071_6_52","MRK","6","52","52","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵡⴰⵍⵓ ⵉ ⵍⵎⵓⵄⵊⵉⵣⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ, ⵎⵉⵏⵣⵉ ⵓⵍ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵇⵙⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("MK6_53","071_6_53","MRK","6","53","53","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵥⵡⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⵉⵏⵏⵉⵙⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK6_54","071_6_54","MRK","6","54","54","ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵄⴻⵇⵍⴻⵏ ⵜ ⵉⵡⴷⴰⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK6_55","071_6_55","MRK","6","55","55","ⵓⵣⵣⵍⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⵉ ⵓⵛⴰ ⴱⴷⴰⵏ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵀⴻⵍⵛⴻⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴰⵙⵙⵓⵜ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵙⵍⵉⵏ ⴰⵇⴰ-ⵜ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK6_56","071_6_56","MRK","6","56","56","ⵎⴰⵏⵉ ⵎⴰ ⴷⴷ-ⵢⵓⵙⴰ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵉⵖ ⴷⵉ ⵍⴻⴷⵛⵓⵔ ⵏⵉⵖ ⴷⵉ ⵍⴻⵄⵔⴰⵚⵉⵢⵢⴰⵜ, ⵙⵙⵔⵓⵙⴰⵏ ⴰⵙ-ⴷⴷ ⵉⵎⴻⵀⵍⴰⵛ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵓⵛⴰ ⵜⵜⵣⴰⵡⴰⴳⴻⵏ ⵜ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵎⴻⵃ ⴰⴷ ⵃⴰⴷⴰⵏ ⵎⵖⵉⵔ ⴰⴱⴻⵃⵍⵓⵍ ⵏ ⵓⵊⴻⴵⴰⴱ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵃⴰⴷⴰⵏ, ⴳⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK7_1","071_7_1","MRK","7","1","1","ⵎⵓⵏⴻⵏ ⵖⴰⵔⴻⵙ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MK7_2","071_7_2","MRK","7","2","2","ⵓⵎⵉ ⵥⵔⵉⵏ ⴱⴻⵍⵍⵉ ⵛⴰ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵛⵛⵉⵏ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴳⴳⵉⵏ ⴰⴷ ⵙⵙⵉⵔⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵄⴻⵢⵢⴱⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK7_3","071_7_3","MRK","7","3","3","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵎⵖⵉⵔ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⵙⵉⵔⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵓⴹⵓ ⵎⵍⵉⵃ, ⵎⵉⵏⵣⵉ ⵜⵜⴻⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK7_4","071_7_4","MRK","7","4","4","ⵓ ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵣⵉ ⵙⵙⵓⵇ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵎⴰⵍⴰ ⵡⴰⵔ ⵙⵙⵖⴻⴹⵚⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴱⴰⵏⵢⵓⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵇⴻⴱⵍⴻⵏ ⵜⴻⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵟⵟⴼⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴱⴱⴰⵔⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵓⵙⴻⵖⴹⴰⵙ ⵏ ⵍⴽⵉⵙⴰⵏ ⴷ ⵜⴻⵢⴷⵓⵔⵉⵏ ⴷ ⵜⴻⴱⵔⵉⵇⵉⵏ ⵏ ⵏⵏⵃⴰⵙ ⴷ ⴷⴷⵓⵔⵉ ⵏ ⵍⴻⵛⵜⴰⵡⴰⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴱⴰⵏⵢⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("MK7_5","071_7_5","MRK","7","5","5","ⵅⴻⵏⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴹⴼⴰⵔⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵜⵜᵉⵜⵜⴻⵏ ⴰⵖⵔⵓⵎ ⴰⵎ ⵡⴰⵔ ⵙⵙⵉⵔⵉⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK7_6","071_7_6","MRK","7","6","6","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⵉⵛⴰⵏ ⵉⵏⴻⴱⴱⴰ ⵉⵛⴰⵄⵢⴰ ⵅⴰⵡⴻⵎ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: ‘ⵍⴳⴻⵏⵙ-ⴰ ⵉⵡⴻⵇⵇⴰⵔ ⴰⵢⵉ ⵙ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵓⵍ ⵏⵙⴻⵏ ⵉⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ! ");
INSERT INTO rift_vpl VALUES ("MK7_7","071_7_7","MRK","7","7","7","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵛⴻⵏⵏⵄⴻⵏ ⴰⵢⵉ ⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵜⵉⵖⵓⵔⵉⵡⵉⵏ ⵜⵉⵏⵏⵉ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵉⵡⴷⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MK7_8","071_7_8","MRK","7","8","8","ⵎⵉⵏⵣⵉ ⵜⴻⵊⵊⵉⵎ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵓⴱⴱⴰⵔⵜ ⵏ ⵉⵡⴷⴰⵏ, ⴰⵎ ⵓⵙⴻⵖⴹⴰⵙ ⵏ ⵍⴽⵉⵙⴰⵏ ⴷ ⵜⴻⵢⴷⵓⵔⵉⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴱⴰⵏⵢⵓⵜ ⵓ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵜⵉⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK7_9","071_7_9","MRK","7","9","9","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⵜⵏⴻⵟⵟⴰⵍⴻⵎ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵓⴱⴱⴰⵔⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK7_10","071_7_10","MRK","7","10","10","ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: ‘ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ!’, ⵓ: ‘ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⵣⴰⵏ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵎⵎⴻⵜ.’ ");
INSERT INTO rift_vpl VALUES ("MK7_11","071_7_11","MRK","7","11","11","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵏⵏⴰ ⵉ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵉ ⵢⴻⵎⵎⴰⵙ: ⵎⵉⵏ ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵉ ⵜⴻⵙⵜⴻⵏⴼⵄⴻⵎ, ⴰⵇⴰ ⴳⴳⵉⵖ ⵜ ⴷ ⵚⵚⴻⴷⵇⴻⵜ!’, ");
INSERT INTO rift_vpl VALUES ("MK7_12","071_7_12","MRK","7","12","12","ⴰⵎⵎⵓ ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⴻⵊⵊⵉⵎ ⵇⴰⵄ ⴰⴷ ⵉⴳⴳ ⵛⴰ ⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_13","071_7_13","MRK","7","13","13","ⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴰⵎ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵓⴱⴱⴰⵔⵜ ⵏⵡⴻⵎ ⵉ ⵜᵉⵜⵜⵙⴻⵍⵍⴰⵎⴻⵎ, ⵓ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵎ ⵜⵉⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK7_14","071_7_14","MRK","7","14","14","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⴼⴻⵀⵎⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵎⵍⵉⵃ: ");
INSERT INTO rift_vpl VALUES ("MK7_15","071_7_15","MRK","7","15","15","ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⴱⴰⵔⵔⴰ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ. ⵎⴰⵛⴰ ⵎⵉⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⴻⵅⵎⴰⵊ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK7_16","071_7_16","MRK","7","16","16","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("MK7_17","071_7_17","MRK","7","17","17","ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⴳⴳⵡⴻⵊ ⵅ ⵍⵖⴰⵛⵉ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵅ ⵓⵎⴻⴷⵢⴰ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK7_18","071_7_18","MRK","7","18","18","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⴱⵍⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⴱⴰⵔⵔⴰ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⴻⵅⵎⴻⵊ, ");
INSERT INTO rift_vpl VALUES ("MK7_19","071_7_19","MRK","7","19","19","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⴷⴻⴼ ⵛⴰ ⵖⴰⵔ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵄⴻⴷⴷⵉⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴰⵍ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳ ⵎⴰⵔⵔⴰ ⵎⴰⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK7_20","071_7_20","MRK","7","20","20","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⵅⴻⵎⵎⴰⵊ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK7_21","071_7_21","MRK","7","21","21","ⵎⵉⵏⵣⵉ ⵣⵉ ⴷⴰⵅⴻⵍ, ⵣⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵉⵏⵡⴰⵢⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ: ⵣⵣⵉⵏⴰ, ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵜⵓⴽⴽⴰⵔⴹⴰ, ⴰⵏⵖⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("MK7_22","071_7_22","MRK","7","22","22","ⵟⵟⵎⴻⵄ, ⵍⵖⴰⵔ, ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ, ⴰⴼⵓⵛⵛⴻⵃ, ⵜⵉⵟⵟ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⴰⵛⴻⵇⵇⴻⴼ, ⵜⵓⴼⴼⴻⵜ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK7_23","071_7_23","MRK","7","23","23","ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⵜⵜⴻⴼⴼⵖⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⵉ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵙⵙⵅⴻⵎⵎⴰⵊⴻⵏⵜ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK7_24","071_7_24","MRK","7","24","24","ⵉⴽⴽⴰⵔ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴻⵢⵎⵉⵔ ⵏ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ. ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏ ⵃⴻⴷ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵏⵏⵓⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK7_25","071_7_25","MRK","7","25","25","ⵎⵉⵏⵣⵉ ⵉⵛⵜ ⵏ ⵜⵎⴻⵟⵟⵓⵜ, ⵖⴰⵔⴻⵙ ⵢⴻⴵⵉⵙ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵎⴻⵏⴳⵓⵙ, ⵜⴻⵙⵍⴰ ⵅⴰⵙ ⴷⴻⵖⵢⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵜⴻⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_26","071_7_26","MRK","7","26","26","ⵜⵓⵖⴰ ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⴽⴰⴼⵔⵉⵡⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴼⵉⵏⵉⵇⵉⵢⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵙⵓⵔⵉⵢⴰ. ⵏⴻⵜⵜⴰⵜ ⵜⵣⴰⵡⴳ ⵉ-ⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵛⵛⵉⵟⴰⵏ ⵣⴻⴳ ⵢⴻⴵⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_27","071_7_27","MRK","7","27","27","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴻⵊⵊ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⵊⵊⵉⵡⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵇ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵡⴻⵖⵔⵓⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵉ ⵢⵉⵟⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK7_28","071_7_28","MRK","7","28","28","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵔⴰ-ⴷⴷ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵉⵟⴰⵏ ⵜⵜᵉⵜⵜⴻⵏ ⵉⵍⴻⵇⵇⵯⴰⵣ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵙⴰⴷⵓ ⵟⵟⴰⴱⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK7_29","071_7_29","MRK","7","29","29","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵓⵢⵓⵔ, ⵎⵉⵏⵣⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ-ⴰ ⵉ ⵜⴻⵏⵏⵉⴷ, ⴰⵇⴰ ⵉⴼⴼⴻⵖ ⵛⵛⵉⵟⴰⵏ ⵣⴻⴳ ⵢⴻⴵⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK7_30","071_7_30","MRK","7","30","30","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵜⵓⴼⴰ ⵢⴻⴵⵉⵙ ⵜⴻⵣⵣⴻⵍ ⴷⵉ ⵇⴰⵎⴰ ⵓ ⵛⵛⵉⵟⴰⵏ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_31","071_7_31","MRK","7","31","31","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ, ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⵊⴰⵍⵉⵍ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴷⵉⴽⴰⴱⵓⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_32","071_7_32","MRK","7","32","32","ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⴷⴻⵀⵛⵓⵔ, ⵉⵜⴻⵡⵜⴰⵡ, ⵓⵛⴰ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_33","071_7_33","MRK","7","33","33","ⵉⵙⵙⵉⴳⴳⵯⴻⵊ ⵉ-ⵜ ⵣⵉ ⵍⵖⴰⵛⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⵉⴹⴻⵡⴹⴰⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ, ⵉⵙⵙⵓⵙⴻⴼ ⵓⵛⴰ ⵉⵃⴰⴷⴰ ⵉⵍⴻⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK7_34","071_7_34","MRK","7","34","34","ⵅⴻⵏⵏⵉ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⵣⴻⵀⵀⴰⵔ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⵓⵔⵣⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("MK7_35","071_7_35","MRK","7","35","35","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⵓⵔⵣⵎⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴼⵙⵉ ⵜⴻⵙⵖⵓⵏⵜ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ, ⵉⴱⴷⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK7_36","071_7_36","MRK","7","36","36","ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵡⴰⵔ ⵜ ⵇⵇⴰⵔⴻⵏ ⵉ ⵃⴻⴷ, ⵎⴰⵛⴰ ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵜⴻⵏ ⵢⵓⵎⵓⵔ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵅⴰⵙ ⵍⴻⵅⴱⴰⵔ ⵎⴰⵀⵓ. ");
INSERT INTO rift_vpl VALUES ("MK7_37","071_7_37","MRK","7","37","37","ⵓⵛⴰ ⵜⴱⴻⵀⵜⴻⵏ ⵙ ⵓⵏⴻⵅⵍⵉⵄ ⴰⵍⴰⵎⵉ ⵏⵏⴰⵏ: “ⵎⴰⵔⵔⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵎⵍⵉⵃ! ⵢⴰⵔⵔⴰ ⵉⴷⴻⵀⵛⴰⵔ ⵜⵜⴻⵙⵍⴰⵏ ⴷ ⵉⴳⵏⴰⵡⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK8_1","071_8_1","MRK","8","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵎ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ, ⵉⵍⴰⵖⴰ ⵢⴰⵙⵓⵄ ⵅ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MK8_2","071_8_2","MRK","8","2","2","“ⴰⵇⴰ ⵣⵣⵉⴵⵣⴻⵏ ⴰⵢⵉ ⵍⵖⴰⵛⵉ, ⵎⵉⵏⵣⵉ ⵇⵇⵉⵎⴻⵏ ⴰⴽⵉⴷⵉ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK8_3","071_8_3","MRK","8","3","3","ⵎⴰⵍⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵜⴻⵏ ⵖⴰⵔ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ ⴰⵎ ⵄⴰⴷ ⴵⵓⵥⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵀⴻⵢⵢⴼⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵎⵉⵏⵣⵉ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ.” ");
INSERT INTO rift_vpl VALUES ("MK8_4","071_8_4","MRK","8","4","4","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵣⵉ ⵎⴰⵏⵉⵙ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵢⴰⴼ ⴰⵖⵔⵓⵎ ⴷⵉ ⵍⴻⵅⵍⴰ-ⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵊⵊⵉⵡⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK8_5","071_8_5","MRK","8","5","5","ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ: “ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵉ ⵖⴰⵔⵡⴻⵎ?” ⵏⵏⴰⵏ: “ⵙⴻⴱⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK8_6","071_8_6","MRK","8","6","6","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵍⵖⴰⵛⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵉⴽⵙⵉ ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴱⴰⵔⴻⴽ, ⵢⴰⵔⵥⴰ ⵉ-ⵜⴻⵏⵜ, ⵉⵡⵛⴰ ⵉ-ⵜⴻⵏⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵇⴻⴷⴷⵎⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵇⴻⴷⴷⵎⴻⵏ ⵜⴻⵏⵜ ⵉ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MK8_7","071_8_7","MRK","8","7","7","ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵛⵡⴰⵢⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ ⵄⴰⵡⴻⴷ, ⵉⵏⵏⴰ ⴰⴷ ⵇⴻⴷⴷⵎⴻⵏ ⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK8_8","071_8_8","MRK","8","8","8","ⵛⵛⵉⵏ, ⵊⵊⵉⵡⵏⴻⵏ, ⵓⵛⴰ ⵢⴰⵔⵡⴻⵏ ⵎⵉⵏ ⵉⵛⴻⵟⵟⴻⵏ, ⴰⵇⴰ ⵙⴻⴱⵄⴰ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MK8_9","071_8_9","MRK","8","9","9","ⵉⵏⵏⵉ ⵉⵛⵛⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵄⵍⴰⵃⴰⵍ ⴷⵉ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("MK8_10","071_8_10","MRK","8","10","10","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵢⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴷⴰⵍⵎⴰⵏⵓⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK8_11","071_8_11","MRK","8","11","11","ⴼⴼⵖⴻⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴱⴷⴰⵏ ⵜⵜⵇⴰⵛⴰⵃⴻⵏ ⴷⴰⵢⴻⵙ, ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵊⴰⵔⵔⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK8_12","071_8_12","MRK","8","12","12","ⵉⵣⴻⵀⵀⴰⵔ ⴷⵉ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⴻⵜⵜⴰⵔ ⵊⵊⵉⵍ-ⴰ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ? ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⵊⵊⵉⵍ-ⴰ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ!” ");
INSERT INTO rift_vpl VALUES ("MK8_13","071_8_13","MRK","8","13","13","ⵅⴻⵏⵏⵉ ⵉⵙⵎⴻⵃ ⴷⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵢⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵓⵛⴰ ⵔⵓⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("MK8_14","071_8_14","MRK","8","14","14","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵓⵏ ⴰⴷ ⴽⵉⵙⴻⵏ ⴽⵙⵉⵏ ⴰⵖⵔⵓⵎ, ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⵡⴰⵍⵓ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⴻⵛⵏⵉⴼⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("MK8_15","071_8_15","MRK","8","15","15","ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔⴻⵎ, ⵃⴹⴰⵎ ⵣⴻⴳ ⵡⴻⵏⵜⵓⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵡⴻⵏⵜⵓⵏ ⵏ ⵀⵉⵔⵓⴷⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK8_16","071_8_16","MRK","8","16","16","ⵎⵛⴰⵡⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK8_17","071_8_17","MRK","8","17","17","ⵎⴰⵛⴰ ⵢⴰⵔⴳⴻⴱ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵎⵛⴰⵡⴰⵔⴻⵎ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴱⵓ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ? ⵎⴰ ⵡⴰⵔ ⵜⵓⵛⵉⵎ, ⵎⴰ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ? ⵎⴰ ⵄⴰⴷ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵇⴻⵙⵃⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("MK8_18","071_8_18","MRK","8","18","18","ⵎⴰ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵍⵉⵎ? ⵎⴰ ⵖⴰⵔⵡⴻⵎ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉⵎ? ⵎⴰ ⵡⴰⵔ ⵜⵄⴻⵇⵇⵉⵍⴻⵎ ⵄⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("MK8_19","071_8_19","MRK","8","19","19","ⵓⵎⵉ ⴰⵔⵥⵉⵖ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ, ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵍⴻⵇⵇⵯⴰⵣ ⵉ ⵜⵢⴰⵔⵡⴻⵎ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵜⴻⵏⵄⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("MK8_20","071_8_20","MRK","8","20","20","“ⵓ ⵖⴰⵔ ⵙⴻⴱⵄⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⵉ ⴰⵔⴻⴱⵄⴰ-ⴰⵍⴰⴼ, ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵍⴻⵇⵇⵯⴰⵣ ⵉ ⵜⵢⴰⵔⵡⴻⵎ?” ⵏⵏⴰⵏ: “ⵙⴻⴱⵄⴰ!” ");
INSERT INTO rift_vpl VALUES ("MK8_21","071_8_21","MRK","8","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵎⵎⴻⵛ ⵄⴰⴷ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⴰⵍ ⵍⴻⵅⵅⵓ?” ");
INSERT INTO rift_vpl VALUES ("MK8_22","071_8_22","MRK","8","22","22","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⴷⴰⵔⵖⴰⵍ, ⵣⴰⵡⴳⴻⵏ ⵜ ⴰⴷ ⵉⵃⴰⴷⴰ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK8_23","071_8_23","MRK","8","23","23","ⵏⴻⵜⵜⴰ ⵉⵎⵏⴻⵄ ⴰⴷⴰⵔⵖⴰⵍ ⵣⴻⴳ ⵓⴼⵓⵙ, ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⴱⴰⵔⵔⴰ ⵉ ⴷⵛⴰⵔ ⵓⵛⴰ ⵉⵙⵙⵓⵙⴻⴼ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵇⵙⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MK8_24","071_8_24","MRK","8","24","24","ⵉⵙⴻⵡⴹ, ⵉⵏⵏⴰ: “ⵜⵜⵡⴰⵍⵉⵖ ⵉⵡⴷⴰⵏ ⴳⴳⵓⵔⴻⵏ ⴰⵎ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK8_25","071_8_25","MRK","8","25","25","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵙ ⵄⴰⵡⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⴳⴳⴻⵏⴼⴰ, ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("MK8_26","071_8_26","MRK","8","26","26","ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⴷ ⵜⵜⵉⴷⴻⴼ ⴷⵛⴰⵔ, ⵡⴰⵔ ⵜ ⵇⵇⴰⵔ ⵉ ⵃⴻⴷ ⴷⵉ ⴷⵛⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("MK8_27","071_8_27","MRK","8","27","27","ⵅⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵢⴰⵙⵓⵄ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⴷⵛⵓⵔ ⵏ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ-ⴼⵉⵍⵉⴱⴱⵓⵙ. ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉⵙⵙⴻⵇⵙⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("MK8_28","071_8_28","MRK","8","28","28","ⴰⵔⵔⵉⵏ-ⴷⴷ: “ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ!”, ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵉⵍⵉⵢⴰ!”, ⵉⵏⵏⴻⵖⵏⵉ ⵄⴰⵡⴻⴷ: “ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK8_29","071_8_29","MRK","8","29","29","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵅⴰⴼⵉ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK8_30","071_8_30","MRK","8","30","30","ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵎⵍⵉⵃ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜ ⵅⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵓⵍⴰ ⵉ ⵢⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("MK8_31","071_8_31","MRK","8","31","31","ⵉⴱⴷⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴰⵇⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK8_32","071_8_32","MRK","8","32","32","ⵉⵏⵏⴰ ⴰⵡⴰⵍ-ⴰ ⵙ ⴱⵟⴰⵢⵟⴰⵢ. ⵎⴰⵛⴰ ⵉⴽⵙⵉ ⵜ ⴱⵓⵟⵔⵓⵙ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵜⵜⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK8_33","071_8_33","MRK","8","33","33","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵉⵅⵣⴰⵔ ⴷⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵉ ⵛⵉⵎⵄⵓⵏ, ⵉⵇⵇⴰⵔ: “ⴰⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⴰ ⵛⵛⵉⵟⴰⵏ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵛⵇⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK8_34","071_8_34","MRK","8","34","34","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵉ ⵍⵖⴰⵛⵉ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔ, ⴰⴷ ⵉⵏⴽⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴽⵙⵉ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK8_35","071_8_35","MRK","8","35","35","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⵅⵙⴰⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⵙⴰⵔⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK8_36","071_8_36","MRK","8","36","36","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵍⴰ ⵢⴰⵔⴱⴻⵃ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵅⵙⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MK8_37","071_8_37","MRK","8","37","37","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵖⴰ ⵉⵡⵛ ⴱⵏⴰⴷⴻⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("MK8_38","071_8_38","MRK","8","38","38","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵉⵙⴻⴹⵃⴰⵏ ⵓ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴷⵉ ⵊⵊⵉⵍ-ⴰ ⵉⵣⴻⵏⵏⴰⵏ ⵉⵅⴹⴰⵏ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⴻⴹⵃⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙ ⵓⵄⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK9_1","071_9_1","MRK","9","1","1","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵡⴰⵔ ⵜⵜⵇⴰⵙⵉⵏ ⵛⴰ ⵍⵎⴻⵡⵜ ⴰⵍ ⵖⴰ ⵥⴰⵔⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵙ ⵊⵊⴻⵀⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK9_2","071_9_2","MRK","9","2","2","ⴰⵡⴰⵔⵏⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵢⴰⵙⵓⵄ ⵢⵉⵡⵉ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⵓⵛⴰ ⵉⴱⴻⴷⴷⴻⵍ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK9_3","071_9_3","MRK","9","3","3","ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⵢⴰⵍⴻⵇⵇ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴰⵟⵟⴰⵙ ⴰⵎ ⵡⴻⴷⴼⴻⵍ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵉⵙⵙⴻⵎⵍⴻⵍ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK9_4","071_9_4","MRK","9","4","4","ⵉⴹⵀⴰⵔ ⴰⵙⴻⵏ-ⴷⴷ ⵉⵍⵉⵢⴰ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⴰⵎ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MK9_5","071_9_5","MRK","9","5","5","ⵉⵏⵏⴰ ⴰⵙ ⴱⵓⵟⵔⵓⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⴰⵇⴰ ⵎⵍⵉⵃ ⵓⵎⵉ ⴷⴰ ⵏⴻⴵⴰ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⵡⴻⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵏ ⵜⵙⴻⵟⵟⴰ, ⵉⵊⵊⴻⵏ ⵉ ⵛⴻⴽ, ⵉⵊⵊⴻⵏ ⵉ ⵎⵓⵙⴰ ⵓ ⵉⵊⵊⴻⵏ ⵉ ⵉⵍⵉⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK9_6","071_9_6","MRK","9","6","6","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴰⵔ ⴰⵙ ⵎⵉⵏ ⵖⴰ ⵢⵉⵏⵉ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK9_7","071_9_7","MRK","9","7","7","ⵉⴽⴽⴰ-ⴷⴷ ⵓⵙⴻⵢⵏⵓ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵉ-ⵜⴻⵏ ⵙ ⵜⵉⵍⵉ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⵍⴰⵖⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵙⴻⵢⵏⵓ, ⵜⴻⵇⵇⴰⵔ: “ⵡⴰ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⵙⵍⴻⵎ ⵖⴰⵔⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("MK9_8","071_9_8","MRK","9","8","8","ⵓⵎⵉ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵛⵜⵉ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵡⴰⵍⴰⵏ ⵄⴰⴷ ⵃⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⵖⵉⵔ ⵢⴰⵙⵓⵄ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK9_9","071_9_9","MRK","9","9","9","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵀⵡⴰⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵄⵉⵡⵉⴷⴻⵏ ⵉ ⵃⴻⴷ ⵡⴰⵍⵓ ⵣⵉ ⵎⵉⵏ ⵥⵔⵉⵏ ⴰⵍ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK9_10","071_9_10","MRK","9","10","10","ⵅⴻⵎⵎⵍⴻⵏ ⴰⵡⴰⵍ-ⴰ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵇⵙⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵡⴰⵡⴰⵍ-ⴰ: ‘ⴰⵍ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ’? ");
INSERT INTO rift_vpl VALUES ("MK9_11","071_9_11","MRK","9","11","11","ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵍⵉⵢⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ?” ");
INSERT INTO rift_vpl VALUES ("MK9_12","071_9_12","MRK","9","12","12","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵉⵍⵉⵢⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵔ ⴽⵓⵍⵛⵉ, ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⵅ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK9_13","071_9_13","MRK","9","13","13","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵉⵍⵉⵢⴰ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⴳⴳⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵎⵉⵏ ⵅⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵜⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK9_14","071_9_14","MRK","9","14","14","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵜⵜⴻⵏⵏⴻⴹ ⴰⵙⴻⵏ-ⴷⴷ ⵓ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵜⵜⵇⴰⵛⴰⵃⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK9_15","071_9_15","MRK","9","15","15","ⴷⴻⵖⵢⴰ ⵉⵥⵔⴰ ⵉ-ⵜ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ, ⵜⴱⴻⵀⵜⴻⵏ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵓⵣⵣⵍⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵙⴻⴵⵎⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK9_16","071_9_16","MRK","9","16","16","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ: “ⵎⵉⵏ ⵅⴻⴼ ⴽⵉⴷⵙⴻⵏ ⵜᵉⵜⵜⵇⴰⵛⴰⵃⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("MK9_17","071_9_17","MRK","9","17","17","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵉⵏⵏⴰ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵉⵡⵢⴻⵖ-ⴷⴷ ⵎⵎⵉ ⵖⴰⵔⴻⴽ. ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍⴰⵔⵢⴰⵃ ⵏⵏⵉ ⵜ ⵢⴰⵔⵔⵉⵏ ⴷ ⴰⴳⵏⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("MK9_18","071_9_18","MRK","9","18","18","ⵍⴻⴱⴷⴰ ⵅⵎⵉ ⵜ ⵉⵜⵜⴻⵟⵟⴻⴼ, ⵉⵏⴻⵟⵟⴰⵔ ⵉ-ⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵜⵜⴻⴼⴼⴻⵖ ⴰⵙ-ⴷⴷ ⵓⴽⵓⴼⴼⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ, ⵉⵜⵜⵖⴻⵣⵣⴰ ⵜⵉⵖⵎⴰⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⴰⵥⴻⵖ. ⵏⵏⵉⵖ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵣⴻⵎⵎⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK9_19","071_9_19","MRK","9","19","19","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵊⵊⵉⵍ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⴽⵉⴷⵡⴻⵎ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵖ, ⵎⴻⵛⵃⴰⵍ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵢⴰⵔⴱⵓⵖ ⵄⴰⴷ? ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK9_20","071_9_20","MRK","9","20","20","ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⵙ. ⵓⵎⵉ ⵜ ⵉⵥⵔⴰ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵉ-ⵜ ⵍⴰⵔⵢⴰⵃ, ⴰⵍⴰⵎⵉ ⵉⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⴱⴷⴰ ⵉⵜⵜⴱⴰⵔⴽⵉⴽⴽⵉⴹ, ⵉⵜⵜⴻⴽⴽ ⴰⵙ-ⴷⴷ ⵓⴽⵓⴼⴼⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("MK9_21","071_9_21","MRK","9","21","21","ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵇⵙⴰ ⴱⴰⴱⴰⵙ: “ⵎⴻⵛⵃⴰⵍ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵃⴽⴻⵎ ⵓⵢⴰ?” ⵉⵏⵏⴰ ⴰⵙ: “ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK9_22","071_9_22","MRK","9","22","22","ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵓⵔⴻⵏ ⵉⵏⴻⵟⵟⴰⵔ ⵉ-ⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵓ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⵅ ⵛⴰ, ⵄⴰⵡⴻⵏ ⴰⵢⵉ ⵓ ⵃⵉⵏⵏ ⵅⴰⴼⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK9_23","071_9_23","MRK","9","23","23","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⵎⵏⴻⴷ, ⴰⵇⴰ ⴽⵓⵍⵛⵉ ⵉⵣⴻⵎⵎⴰⵔ ⵉ ⵡⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK9_24","071_9_24","MRK","9","24","24","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵖⵓⵢ ⴱⴰⴱⴰⵙ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵉⵏⵏⴰ: “ⵓⵎⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ! ⵄⴰⵡⴻⵏ ⵍ’ⵉⵎⴰⵏ ⵉⵏⴻⵇⵚⴻⵏ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("MK9_25","071_9_25","MRK","9","25","25","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍⵖⴰⵛⵉ ⵉⵜⵜⴰⵣⵣⴻⵍ ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵏⵉⵜⵏⵉ, ⵉⵡⴻⴱⴱⴻⵅ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵍⴰⵔⵢⴰⵃ ⴰⴳⵏⴰⵡ, ⵏⴻⵛⵛ ⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ: ⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ! ⵡⴰⵔ ⵜⵜⴷⴻⴽⴽⵡⵉⵍ ⴷⴰⵢⴻⵙ ⵄⴻⵎⵎⴰⵔⵚ!” ");
INSERT INTO rift_vpl VALUES ("MK9_26","071_9_26","MRK","9","26","26","ⵉⵙⵖⵓⵢ ⵛⵛⵉⵟⴰⵏ ⵏⵏⵉ ⴰⵟⵟⴰⵙ, ⵉⵊⴻⴱⴱⴻⴷ ⵉ-ⵜ ⴰⵟⵟⴰⵙ ⴰⵎⵎⵓ ⴷ ⵡⴰⵎⵎⵓ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵓⵃⴻⵏⵊⵉⵔ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵏⵏⴰⵏ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("MK9_27","071_9_27","MRK","9","27","27","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK9_28","071_9_28","MRK","9","28","28","ⵓⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵜ ⵏⴻⵙⵙⵓⴼⴼⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("MK9_29","071_9_29","MRK","9","29","29","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴷⴷⴻⴳⴳ-ⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⴼⴼⴻⵖ ⵓⵍⴰ ⵙ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵎⵖⵉⵔ ⵙ ⵓⵥⵓⵎⵎⵉ ⴷ ⵜⵥⴰⴵⵉⵜ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK9_30","071_9_30","MRK","9","30","30","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵛⵓⵇⴻⵏ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵄⵇⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK9_31","071_9_31","MRK","9","31","31","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵇⵇⴰⵔ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵖⴰ ⵏⵖⴻⵏ, ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK9_32","071_9_32","MRK","9","32","32","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵉ ⵡⴰⵡⴰⵍ-ⴰ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK9_33","071_9_33","MRK","9","33","33","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ: “ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵜⵃⴰⵔⵔⴹⴻⵎ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("MK9_34","071_9_34","MRK","9","34","34","ⵎⴰⵛⴰ ⵙⵇⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵎⵇⴰⵛⴰⵃⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷⵉ ⵡⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK9_35","071_9_35","MRK","9","35","35","ⵉⵇⵇⵉⵎ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵜⴻⵏⵄⴰⵛ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⵉⵅⵙ ⵃⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵏⴻⴳⴳⴰⵔ ⵓⵍⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK9_36","071_9_36","MRK","9","36","36","ⵉⴽⵙⵉ ⴰⵃⴻⵏⵊⵉⵔ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵉⴷⴰⵔⵔⴻⵄ ⴰⵙ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MK9_37","071_9_37","MRK","9","37","37","“ⵡⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⵇⴰ ⵉⵇⴱⴻⵍ ⴰⵢⵉ ⵓ ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵇⴻⴱⴱⴻⵍ, ⵎⴰⵛⴰ ⵉⵇⴻⴱⴱⴻⵍ ⵡⵉ ⴷ ⴰⵢⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK9_38","071_9_38","MRK","9","38","38","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵏⴻⵥⵔⴰ ⵉⵊⵊⴻⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⵏⴻⵎⵏⴻⵄ ⵉ-ⵜ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴷ ⴰⵏⴻⵖ ⵉⴹⴻⴼⴼⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MK9_39","071_9_39","MRK","9","39","39","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵜ ⵎⴻⵏⵏⵄⴻⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⵖⴰ ⵢⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴷⴻⵖⵢⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK9_40","071_9_40","MRK","9","40","40","ⵎⵉⵏⵣⵉ ⵡⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴹⵉⴷⴷ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK9_41","071_9_41","MRK","9","41","41","ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵙⵙⴻⵙⵡⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵡⴰⵀⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⵜⴻⴵⴰⵎ, ⴰⵇⴰ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⴻⵙⵙⴰⵔ ⵛⴰ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK9_42","071_9_42","MRK","9","42","42","ⵡⵉ ⵖⴰ ⵉⵙⵙⴻⵏⵇⵔⴰⴹⴻⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ-ⴰ ⵉ ⴷⴰⵢⵉ ⵢⵓⵎⵏⴻⵏ, ⵉⵃⵍⴰ ⴰⵙ ⴰⴷ ⴰⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵜⵙⵉⵔⵜ ⵜⴻⴷⵇⴻⵍ ⴷⴻⴳ ⵉⵔⵉ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK9_43","071_9_43","MRK","9","43","43","ⵎⴰⵍⴰ ⵉⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵇⴻⵙⵙ ⵉ-ⵜ. ⵉⵃⵍⴰ ⴰⵛ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⴷ ⴰⵎⴻⵄⴹⵓⵍ ⵅ ⵡⴰⴷⴰⴼ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("MK9_44","071_9_44","MRK","9","44","44","ⵎⴰⵏⵉ ⵜⵉⴽⴻⵛⵛⴰ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⵅⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MK9_45","071_9_45","MRK","9","45","45","ⵎⴰⵍⴰ ⵉⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⵓⴹⴰⵔ ⵏⵏⴻⵛ, ⵇⴻⵙⵙ ⵉ-ⵜ. ⵉⵃⵍⴰ ⴰⵛ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⴷ ⴰⵇⴻⵊⴷⴰⵃ ⵅ ⵓⵡⴻⵟⵟⵓ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴹⴰⵔⴻⵏ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("MK9_46","071_9_46","MRK","9","46","46","ⵎⴰⵏⵉ ⵜⵉⴽⴻⵛⵛⴰ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⵅⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MK9_47","071_9_47","MRK","9","47","47","ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵏⵇⴰⵔⴹ ⵛⴻⴽ ⵜⵉⵟⵟ ⵏⵏⴻⵛ, ⵇⴻⵍⵄ ⵉ-ⵜⵜ. ⵉⵃⵍⴰ ⴰⵛ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵟⵟ ⵅ ⵓⵡⴻⵟⵟⵓ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵏ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ, ");
INSERT INTO rift_vpl VALUES ("MK9_48","071_9_48","MRK","9","48","48","ⵎⴰⵏⵉ ⵜⵉⴽⴻⵛⵛⴰ ⵏⵙⴻⵏⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵎⴻⵜⵜⵉ ⵓ ⵜⵉⵎⴻⵙⵙⵉ ⵏⵙⴻⵏⵜ ⵡⴰⵔ ⵜⵅⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MK9_49","071_9_49","MRK","9","49","49","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵎⴻⴵⴻⵃ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓ ⴽⵓⵍ ⵜⴰⵖⴰⵔⵚⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⴻⴵⴻⵃ ⵙ ⵜⵎⴻⴵⴰⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("MK9_50","071_9_50","MRK","9","50","50","ⵜⴰⵎⴻⴵⴰⵃⵜ ⵜⴻⵚⴱⴻⵃ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴰⵎⴻⴵⴰⵃⵜ ⵉⵅⵙⴰⵔ ⵓⵍⴻⴷⴷⵉ ⵏⵏⴻⵙ, ⵙ ⵎⵉⵏ ⵣⵉ ⵜⵜ ⵉ ⵖⴰ ⵄⴻⴷⵍⴻⵏ. ⴰⴷ ⵜⵉⵍⵉ ⵜⵎⴻⴵⴰⵃⵜ ⴷⴰⵢⵡⴻⵎ ⵓⵛⴰ ⵃⴹⴰⵎ ⵍⴻⵀⵏⴰ ⵊⴰⵔ ⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK10_1","071_10_1","MRK","10","1","1","ⵉⴽⴽⴰⵔ, ⵢⵓⵢⵓⵔ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏ ⵓⵥⴻⴽⴽⵡⵉ ⵏ ⵍ’ⵓⵔⴷⵓⵏ. ⵎⵓⵏⴻⵏ-ⴷⴷ ⵅⴰⵙ ⵍⵖⴰⵛⵉ ⴰⵟⵟⴰⵙ ⵓ ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("MK10_2","071_10_2","MRK","10","2","2","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵊⴰⵔⵔⴱⴻⵏ: “ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⵉ ⵡⴻⵔⵢⴰⵣ ⴰⴷ ⵉⴵⴻⴼ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("MK10_3","071_10_3","MRK","10","3","3","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK10_4","071_10_4","MRK","10","4","4","ⵏⵏⴰⵏ: “ⵎⵓⵙⴰ ⵉⵡⵛⴰ ⵜⵜⴻⵙⵔⵉⵃ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⵉ ⵜⴻⴱⵔⴰⵜ ⵏ ⵡⴰⴵⴰⴼ ⵎⴰⵃⴻⵏⴷ ⴰⵔⵢⴰⵣ ⴰⴷ ⴰⵙ ⵉⴵⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("MK10_5","071_10_5","MRK","10","5","5","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⴰⵇⴰ ⵢⵓⵔⴰ ⴰⵡⴻⵎ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("MK10_6","071_10_6","MRK","10","6","6","ⵎⴰⵛⴰ ⵣⵉ ⴱⴻⴷⴷⵓ ⵣⵉ ⵎⴰⵏⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵅⵍⴻⵇ ⵉ-ⵜⴻⵏ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵡⵜⴻⵎ ⴷ ⵜⴻⵡⵜⴻⵎⵜ. ");
INSERT INTO rift_vpl VALUES ("MK10_7","071_10_7","MRK","10","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵎⴻⵃ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ, ⴰⴷ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MK10_8","071_10_8","MRK","10","8","8","ⵓⵛⴰ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⴷⴷⴰⵜ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⵄⴰⴷ ⴷ ⵜⵏⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK10_9","071_10_9","MRK","10","9","9","ⵙ ⵓⵢⴰ ⵎⵉⵏ ⵉⵙⵙⵎⵓⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜ ⵉⴱⴻⵟⵟⵉ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK10_10","071_10_10","MRK","10","10","10","ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK10_11","071_10_11","MRK","10","11","11","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵉ ⵖⴰ ⵉⴵⴼⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵣⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK10_12","071_10_12","MRK","10","12","12","ⵓ ⵎⴰⵍⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⴵⴻⴼ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵣⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK10_13","071_10_13","MRK","10","13","13","ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵃⴰⴷⴰ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⴻⴱⴱⵅⴻⵏ ⵉⵏⵏⵉ ⵜⴻⵏ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK10_14","071_10_14","MRK","10","14","14","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵅⴻⵢⵢⴻⵇ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵊⵊⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵎⴻⵏⵏⵄⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK10_15","071_10_15","MRK","10","15","15","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: “ⵡⵉ ⵡⴰⵔ ⵉⵇⴻⴱⴱⵍⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ, ⴰⵇⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⴷⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("MK10_16","071_10_16","MRK","10","16","16","ⵉⴷⴰⵔⵔⴻⵄ ⴰⵙⴻⵏ, ⵓⵛⴰ ⴰⵎ ⵅⴰⵙⴻⵏ ⵉⵙⵙⴰⵔⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK10_17","071_10_17","MRK","10","17","17","ⵓⵎⵉ ⵉⴼⴼⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵢⵓⵣⵣⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ, ⵉⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴼⴰⴷⴷⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜ, ⵉⵏⵏⴰ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵡⴰⵔⵜⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK10_18","071_10_18","MRK","10","18","18","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵍⴰⵖⵉⴷ: ‘ⴰⵚⴻⴱⵃⴰⵏ’? ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵖⵉⵔ ⵉⵊⵊⴻⵏ ⵡⴰⵀⴰ: ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("MK10_19","071_10_19","MRK","10","19","19","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵉⵡⴻⵚⵚⴰ: ‘ⵡⴰⵔ ⵣⴻⵏⵏⵉ, ⵡⴰⵔ ⵏⴻⵇⵇ, ⵡⴰⵔ ⵜⵜⵉⵛⴰⵔ, ⵡⴰⵔ ⵛⴻⵀⵀⴻⴷ ⵙ ⵥⵓⵔ, ⵡⴰⵔ ⵜⵜⵖⴻⵛⵛⴰ, ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ.’” ");
INSERT INTO rift_vpl VALUES ("MK10_20","071_10_20","MRK","10","20","20","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵀ, ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴰ ⵜⵓⵖⴰ ⴹⴻⴼⴼⴰⵔⴻⵖ ⵜⴻⵏⵜ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("MK10_21","071_10_21","MRK","10","21","21","ⵉⵅⵣⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⵙⵙⵄⵉⵣⵣ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵜⴻⵇⵇⵉⵎ ⵉⵛⵜⴻⵏ ⵄⴰⴷ: ⵓⵢⵓⵔ, ⵣⴻⵏⵣ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ, ⴻⵡⵛ ⵉ-ⵜ ⵉ ⵉⵎⴻⵣⵍⴰⴹ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵍⴽⴻⵏⵣ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵅⴻⵏⵏⵉ ⴽⵙⵉ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵛ, ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("MK10_22","071_10_22","MRK","10","22","22","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵃⵣⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏⵏⵉ, ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵛⴹⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("MK10_23","071_10_23","MRK","10","23","23","ⵉⵅⵣⴰⵔ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴻⵛⵃⴰⵍ ⵉⵡⵄⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴳⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK10_24","071_10_24","MRK","10","24","24","ⵜⴱⴻⵀⵜⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵄⴰⵡⴻⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵜⴰⵔⵡⴰ ⵉⵏⵓ, ⵎⴻⵛⵃⴰⵍ ⵉⵡⵄⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵛⴰⵍⴰⵏ ⵅ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("MK10_25","071_10_25","MRK","10","25","25","ⵉⵀⵡⴻⵏ ⴰⴷ ⵢⴰⴷⴻⴼ ⵡⴻⵍⵖⴻⵎ ⵣⵉ ⵜⵉⵟⵟ ⵏ ⵜⵙⵉⵏⴻⴼⵜ ⵣⴻⴳ ⵡⴰⴷⴰⴼ ⵏ ⴱⵓ-ⵡⴰⴳⵍⴰ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK10_26","071_10_26","MRK","10","26","26","ⵉⵎⵎⴰⵔⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵄⴰⴷ ⵓⵏⴻⵅⵍⵉⵄ, ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("MK10_27","071_10_27","MRK","10","27","27","ⵉⵅⵣⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴽⵓⵍⵛⵉ ⴷⵉ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK10_28","071_10_28","MRK","10","28","28","ⵉⴱⴷⴰ ⴱⵓⵟⵔⵓⵙ ⴰⴷ ⵢⵉⵏⵉ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵊⵊⴰ ⴽⵓⵍⵛⵉ, ⵏⴻⴹⴼⴰⵔ ⵉ ⵛⴻⴽ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK10_29","071_10_29","MRK","10","29","29","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵉⵖ ⴷⴻⴳ ⴰⵢⵜⵎⴰⵙ ⵏⵉⵖ ⴷⵉ ⵢⴻⵙⵙⵎⴰⵙ ⵏⵉⵖ ⴷⵉ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⴷⵉ ⵢⴻⵎⵎⴰⵙ ⵏⵉⵖ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵉⵖ ⴷⵉ ⵜⴰⵔⵔⴰⵡⵜ ⵓⵍⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("MK10_30","071_10_30","MRK","10","30","30","ⵉ ⵡⴰⵔ ⵉⴽⴻⵙⵙⵉⵏ ⵎⵢⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ⵍⴻⵅⵅⵓ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⴰⴷ ⵉⴽⵙⵉ ⵜⵓⴷⵔⵉⵏ ⴷ ⴰⵢⵜⵎⴰⵙ ⴷ ⵢⴻⵙⵙⵎⴰⵙ ⴷ ⵜⵢⴻⵎⵎⴰⵜⵉⵏ ⴷ ⵜⴰⵔⵔⴰⵡⵜ ⴷ ⵢⴻⵢⵢⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵓⵎⴰⵔⵔⴻⵜ, ⵓⵛⴰ ⴷⵉ ⵣⵣⵎⴰⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵉⴽⵙⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK10_31","071_10_31","MRK","10","31","31","ⵎⴰⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK10_32","071_10_32","MRK","10","32","32","ⵜⵓⵖⴰ-ⵜⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵣⵡⴰⵔ ⴰⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴱⴻⵀⵜⴻⵏ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵓⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⴹⴻⴼⴼⴰⵔⴻⵏ. ⵉⴽⵙⵉ ⵜⴻⵏⵄⴰⵛ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵇⵇⴰⵔ ⴰⵙⴻⵏ ⵅ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("MK10_33","071_10_33","MRK","10","33","33","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵅⴰⵙ ⵃⴻⴽⵎⴻⵏ ⵙ ⵍⵎⴻⵡⵜ, ⴰⴷ ⵜ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MK10_34","071_10_34","MRK","10","34","34","ⴰⴷ ⵜ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ, ⴰⴷ ⵜ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⴰⴷ ⵅⴰⵙ ⵙⵙⵓⵙⴼⴻⵏ, ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵉⴽⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MK10_35","071_10_35","MRK","10","35","35","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵜⴰⵔⵡⴰ ⵏ ⵣⴰⴱⴷⵉ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵏⴻⵅⵙ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵖⴰ ⵏⴻⵜⵜⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("MK10_36","071_10_36","MRK","10","36","36","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("MK10_37","071_10_37","MRK","10","37","37","ⵏⵏⴰⵏ ⴰⵙ: “ⴻⵡⵛ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵇⵇⵉⵎ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵛ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵛ, ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("MK10_38","071_10_38","MRK","10","38","38","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵔⴻⵎ. ⵎⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵍⴽⴰⵙ ⵉ ⵣⵉ ⵖⴰ ⵙⵡⴻⵖ ⵏⴻⵛⵛ ⵏⵉⵖ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵉ ⵣⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵖ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("MK10_39","071_10_39","MRK","10","39","39","ⵏⵏⴰⵏ ⴰⵙ: “ⵏⵣⴻⵎⵎⴰⵔ!” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵍⴽⴰⵙ ⵉ ⵖⴰ ⵙⵡⴻⵖ ⵏⴻⵛⵛ, ⴰⴷ ⵜ ⵜⴻⵙⵡⴻⵎ, ⵓ ⴰⵙⴻⵖⴹⴻⵚ ⵉ ⵣⵉ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵖ ⵏⴻⵛⵛ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ,    ");
INSERT INTO rift_vpl VALUES ("MK10_40","071_10_40","MRK","10","40","40","ⵎⴰⵛⴰ ⴰⵖⵉⵎⵉ ⵅ ⵢⴻⴼⵓⵙ ⵉⵏⵓ ⵏⵉⵖ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵉⵏⵓ, ⵡⴰⵔ ⵖⴰⵔⵉ ⵉⴵⵉ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵡⵛⴻⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK10_41","071_10_41","MRK","10","41","41","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵄⴻⵛⵔⴰ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵅⴻⵢⵢⵇⴻⵏ ⵅ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK10_42","071_10_42","MRK","10","42","42","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⴰⵙⴻⵏ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ, ⴰⵇⴰ ⵃⴻⴽⴽⵎⴻⵏ ⵅⴰⵙⴻⵏ, ⵓ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵜⵜⵚⴻⴵⴰⴹⴻⵏ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK10_43","071_10_43","MRK","10","43","43","ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴰⵎⵎⵓ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("MK10_44","071_10_44","MRK","10","44","44","ⵓ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⴰⵡⴻⵎ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK10_45","071_10_45","MRK","10","45","45","ⵎⵉⵏⵣⵉ ⵄⴰⵡⴻⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴷⴻⵎ, ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⴰⵚⵍⴰⵃ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK10_46","071_10_46","MRK","10","46","46","ⵉⵡⴹⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴰⵔⵉⵃⴰ. ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵣⵉ ⴰⵔⵉⵃⴰ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ, ⵜⵓⵖⴰ ⵜⵉⵎⴰⵡⵓⵙ, ⵎⵎⵉⵙ ⵏ ⵜⵉⵎⴰⵡⵓⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵜⵜⴻⵜⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK10_47","071_10_47","MRK","10","47","47","ⵓⵎⵉ ⵉⵙⵍⴰ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ ⴰⵇⴰ-ⵜ ⴷⵉⵏ, ⵉⴱⴷⴰ ⵉⵙⵖⵓⵢⵢⵓ, ⵉⵇⵇⴰⵔ: “ⴰ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK10_48","071_10_48","MRK","10","48","48","ⵡⴻⴱⴱⵅⴻⵏ ⵜ ⴰⵟⵟⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵇⴰⵔ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵉⵙⵖⵓⵢⵢⵓ ⴽⵜⴰⵔ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK10_49","071_10_49","MRK","10","49","49","ⵉⴱⴻⴷⴷ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵍⴰⵖⴰⵏ. ⵍⴰⵖⴰⵏ-ⴷⴷ ⵉ ⵓⴷⴰⵔⵖⴰⵍ, ⵏⵏⴰⵏ ⴰⵙ: “ⴻⴳⴳ ⵓⵍ! ⴽⴽⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⴽ!” ");
INSERT INTO rift_vpl VALUES ("MK10_50","071_10_50","MRK","10","50","50","ⵉⵏⴹⴰⵔ ⵓⴷⴰⵔⵖⴰⵍ ⴰⵊⴻⴵⴰⴱ ⵏⵏⴻⵙ, ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MK10_51","071_10_51","MRK","10","51","51","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵛ ⵜ ⴳⴳⴻⵖ?” ⵉⵏⵏⴰ ⴰⵙ ⵓⴷⴰⵔⵖⴰⵍ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("MK10_52","071_10_52","MRK","10","52","52","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵅⵣⴰⵔ, ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⵉⵡⵛⴰ ⴰⵛ ⵜⵓⴷⴰⵔⵜ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵍⴰ, ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("MK11_1","071_11_1","MRK","11","1","1","ⵓⵎⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⴱⴰⵢⵜ-ⴼⴰⵊⵉ ⴷ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⵣⵣⴰⵜ ⵉ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ, ⵉⵙⵙⴻⴽⴽ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MK11_2","071_11_2","MRK","11","2","2","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⴷⵛⴰⵔ ⵏⵏⵉ ⵇⵉⴱⴰⵍⵜ ⵏⵡⴻⵎ. ⵅⵎⵉ ⵖⴰⵔⴻⵙ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵙⵏⵓⵙ ⵉⵇⵇⴻⵏ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵏⵢⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ⴼⴻⵙⵢⴻⵎ ⴰⵙ-ⴷⴷ ⵓⵛⴰ ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("MK11_3","071_11_3","MRK","11","3","3","ⵎⴰⵍⴰ ⵉⵏⵏⴰ ⴰⵡⴻⵎ ⵃⴻⴷ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵢⴰ?’, ⵅⴻⵏⵏⵉ ⵉⵏⵉⵎ: ‘ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵃⴷⴰⵊ ⵉ-ⵜ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴷⴰ ⵄⴰⵡⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("MK11_4","071_11_4","MRK","11","4","4","ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ, ⵓⴼⵉⵏ ⴰⵙⵏⵓⵙ ⵏⵏⵉ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⴱⴰⵔⵔⴰ ⵅ ⵡⴻⴱⵔⵉⴷ. ⵍⴰⵎⵉ ⴷ ⴰⵙ ⴷⴷ-ⴰⵔⵅⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("MK11_5","071_11_5","MRK","11","5","5","ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ: “ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ, ⵜⴼⴻⵙⵙⵢⴻⵎ ⵉ ⵡⴻⵙⵏⵓⵙ?” ");
INSERT INTO rift_vpl VALUES ("MK11_6","071_11_6","MRK","11","6","6","ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵉⵡⴻⵚⵚⴰ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⵊⵊⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK11_7","071_11_7","MRK","11","7","7","ⵉⵡⵢⴻⵏ-ⴷⴷ ⴰⵙⵏⵓⵙ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵢⴰ ⵅⴰⵙ ⵢⴰⵙⵓⵄ ");
INSERT INTO rift_vpl VALUES ("MK11_8","071_11_8","MRK","11","8","8","ⴰⵟⵟⴰⵙ ⵙⵙⵓⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵅ ⵡⴻⴱⵔⵉⴷ, ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵇⴻⵙⵙⴻⵏ-ⴷⴷ ⵍⴻⴼⵔⵓⵄ ⴰⴽ-ⴷ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵣⵉ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵓⵛⴰ ⵙⵙⵓⵏ ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⵅ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("MK11_9","071_11_9","MRK","11","9","9","ⵉⵏⵏⵉ ⵜ ⵉⵣⵡⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ, ⵜⵓⵖⴰ ⵙⵖⵓⵢⵢⵓⵏ ⵙ ⵊⵊⴻⵀⴷ, ⵇⵇⴰⵔⴻⵏ: “ⵓⵚⴰⵏⵏⴰ! ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ! ");
INSERT INTO rift_vpl VALUES ("MK11_10","071_11_10","MRK","11","10","10","ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵜⴳⴻⵍⴷⵉⵜ ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ ⴷⴰⵡⵓⴷ. ⵓⵚⴰⵏⵏⴰ ⴷⵉ ⵍⵓⵄⵍⴰ ⵅ ⵍⵓⵄⵍⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK11_11","071_11_11","MRK","11","11","11","ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵉⵥⵔⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⵜⴻⵎ ⵍⵃⴰⵍ, ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ ⴰⴽ-ⴷ ⵜⴻⵏⵄⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("MK11_12","071_11_12","MRK","11","12","12","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵍⴰⵥ. ");
INSERT INTO rift_vpl VALUES ("MK11_13","071_11_13","MRK","11","13","13","ⵓⵎⵉ ⵉⵥⵔⴰ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵉⵊⵊ ⵏ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵖⴰⵔⴻⵙ ⵜⵉⴼⵔⴰⵢ, ⵢⵓⵢⵓⵔ ⴷⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵎⴰ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⴼ ⵛⴰ. ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵉⵡⴻⴹ, ⵡⴰⵔ ⵢⵓⴼⵉ ⵡⴰⵍⵓ ⵎⵖⵉⵔ ⵜⵉⴼⵔⴰⵢ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⴱⵓ ⵍⵡⴻⵇⵜ ⵏ ⵜⴰⵣⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK11_14","071_11_14","MRK","11","14","14","ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙ ⵉ ⵡⴰⵔⵜⵓ: “ⵣⵉ ⵍⴻⵅⵅⵓ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵎ ⵉⵜⵜⴻⵜⵜ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵄⴰⴷ ⵍⵖⵉⴵⴻⵜ.” ⵜⵓⵖⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⴻⵙⵍⴰⵏ ⵎⵉⵏ ⵉⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK11_15","071_11_15","MRK","11","15","15","ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⴱⴷⴰ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵉⵎⵙⴻⵡⵡⴰⵇⴻⵏ ⴷ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵙⵙⵏⴻⵇⵍⴰⴱ ⵟⵟⵡⴰⴱⴻⵍ ⵏ ⵉⵚⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⴷ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⵏⵓⵣⴰⵏ ⵉⴷⴱⵉⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("MK11_16","071_11_16","MRK","11","16","16","ⵓⵛⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵉⵄⴷⵓ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵍⴰ ⵙ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK11_17","071_11_17","MRK","11","17","17","ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⵓⵔⵉ: ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵥⴰⴵⵉⵜ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ?’ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ ⵜⵜ ⴷ ⵉⴼⵔⵉ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK11_18","071_11_18","MRK","11","18","18","ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴳⴳⴻⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵎⵉⵏⵣⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵍⵖⴰⵛⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴱⵀⴻⵜ ⵙ ⵓⵙⴻⵍⵎⴻⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK11_19","071_11_19","MRK","11","19","19","ⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MK11_20","071_11_20","MRK","11","20","20","ⴷⵉ ⵚⵚⴱⴻⵃ ⵣⵉⵛ, ⵍⴰⵎⵉ ⴷⵉⵏⵏⵉ ⵄⴷⵓⵏ, ⵥⵔⵉⵏ ⴱⴻⵍⵍⵉ ⵡⴰⵔⵜⵓ ⵏⵏⵉ ⵉⵙⵍⴰⵡ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK11_21","071_11_21","MRK","11","21","21","ⵛⵉⵎⵄⵓⵏ ⵉⴼⵜⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵅⵣⴰⵔ, ⴰⵔⵜⵓ ⵉ ⵜⵏⴻⵄⵍⴻⴷ, ⴰⵇⴰ ⵉⵙⵍⴰⵡ.” ");
INSERT INTO rift_vpl VALUES ("MK11_22","071_11_22","MRK","11","22","22","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵄⵍⵉⴽ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵢⵉⵍⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("MK11_23","071_11_23","MRK","11","23","23","ⵎⴰⵖⴰⵔ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵍⴰ ⵃⴻⴷ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵡⴻⴷⵔⴰⵔ-ⴰ: ‘ⵎⴻⴽⵙⵉ, ⵡⴹⴰ ⴷⵉ ⵍⴻⴱⵃⴰⵔ!’, ⵡⴰⵔ ⵉⵜⵜⵛⴻⴽⴽⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵛⴰ ⴰⴷ ⵢⴰⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⵉⵏⵏⴰ ⴰⴷ ⵉⴼⴼⴻⵖ, ⵉⵡⴰ ⴰⵇⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⵉ ⵏⴻⵜⵜⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK11_24","071_11_24","MRK","11","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⴰⵎ ⵜᵉⵜⵜⵥⴰⴵⴰⵎ, ⴰⵎⵏⴻⵏ ⴱⴻⵍⵍⵉ ⴰⴷ ⵜ ⵜⴽⴻⵙⴱⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("MK11_25","071_11_25","MRK","11","25","25","ⵓ ⵅⵎⵉ ⵖⴰ ⵜⴱⴻⴷⴷⴻⵎ ⵜᵉⵜⵜⵥⵥⴰⴵⴰⵎ, ⵖⴼⴰⵔⴻⵎ ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ ⵅ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵖⴼⴰⵔ ⵄⴰⵡⴻⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK11_26","071_11_26","MRK","11","26","26","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵖⴻⴼⴼⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵉⵖⴻⴼⴼⴰⵔ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK11_27","071_11_27","MRK","11","27","27","ⵓⵙⵉⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⵎ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MK11_28","071_11_28","MRK","11","28","28","ⵏⵏⴰⵏ ⴰⵙ: “ⵙ ⵎⴰⵏ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵣⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ? ⵡⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⵚⵚⵓⵍⵟⴰ-ⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK11_29","071_11_29","MRK","11","29","29","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵇⵙⵉⵖ ⵉⵊⵊ ⵏ ⵓⵙⴻⵇⵙⵉ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵔⵉⵎ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵙ ⵎⴰⵏ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵣⵉ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("MK11_30","071_11_30","MRK","11","30","30","ⴰⵙⴻⵖⴹⴰⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵎⴰ ⵉⴽⴽⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⵣⴻⴳ ⵉⵡⴷⴰⵏ? ⴰⵔⵔⴻⵎ-ⴷⴷ ⵅⴰⴼⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK11_31","071_11_31","MRK","11","31","31","ⵎⵛⴰⵡⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵏⴻⵏⵏⴰ: ‘ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ!’, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵎⵉⵏⴻⵎ?’ ");
INSERT INTO rift_vpl VALUES ("MK11_32","071_11_32","MRK","11","32","32","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵏⵏⴰ: ‘ⵣⴻⴳ ⵉⵡⴷⴰⵏ!’, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵍⴳⴻⵏⵙ!”, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵃⴻⵙⴱⴻⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⴰⵏⴰⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("MK11_33","071_11_33","MRK","11","33","33","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⵉ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ!” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⵣⵉ ⵎⴰⵏ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵣⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK12_1","071_12_1","MRK","12","1","1","ⵉⴱⴷⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵉⵎⴻⴷⵢⴰ: “ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ, ⵉⵥⵥⵓ ⴷⴰⵢⴻⵙ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ, ⵉⵇⴻⵡⵡⴰⵔ ⴰⵙ-ⴷⴷ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴼⵔⴰⵢ, ⵉⵖⵣⴰ ⵜⴰⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ, ⵉⴱⵏⴰ ⴷⴰⵢⴻⵙ ⵚⵚⵓⵎⵄⴻⵜ ⵓⵛⴰ ⵉⵡⴻⴽⴽⴻⵍ ⴰⵎⴰⵔⵊⵓⵄ ⵏⵏⵉ ⵉ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵙⴰⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK12_2","071_12_2","MRK","12","2","2","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵍⵃⴰⵍ, ⵉⵙⵙⴻⴽⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴻⵍⵇⴰⴹ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MK12_3","071_12_3","MRK","12","3","3","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⵜⵉⵏ ⵜ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜ ⵉⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("MK12_4","071_12_4","MRK","12","4","4","ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵖⵏⵉ, ⴰⵔⴻⵊⵎⴻⵏ ⵜ, ⵎⴰⵔⵥⴻⵏ ⴰⵙ, ⵓⵛⴰ ⵍⴰⵎⵉ ⵜ ⵙⵙⴱⴻⵃⵜⵍⴻⵏ, ⵓⵥⵥⵍⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK12_5","071_12_5","MRK","12","5","5","ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ. ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⴽⴽ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵀⴻⵜⵜⴽⴻⵏ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⴷ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵖⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK12_6","071_12_6","MRK","12","6","6","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⵙⴻⵏ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵉ ⵖⴰⵔⴻⵙ ⵉ ⵅⴰⵙ ⵉⵄⵉⵣⵣⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⴰ: ‘ⵏⵉⵛⴰⵏ ⴰⴷ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵎⵎⵉ!’ ");
INSERT INTO rift_vpl VALUES ("MK12_7","071_12_7","MRK","12","7","7","ⵎⴰⵛⴰ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ, ⵏⵏⵉ ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: ‘ⴰⵇⴰ ⴷ ⵡⴰ ⴷ ⴰⵡⵔⵉⵜ. ⵣⵉⴷⴻⵎ, ⴰⴷ ⵜ ⵏⴻⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵢⵉⵍⵉ ⵍⵡⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("MK12_8","071_12_8","MRK","12","8","8","ⵟⵟⴼⴻⵏ ⵜ, ⵏⵖⵉⵏ ⵜ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("MK12_9","071_12_9","MRK","12","9","9","ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ? ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⴷ ⵉⵏⴻⵖ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵡⵛ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵉ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK12_10","071_12_10","MRK","12","10","10","ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⴰⵡⴰⵍ-ⴰ ⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ? ... ‘ⴰⵥⵔⵓ ⵉ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵥⵔⵓ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK12_11","071_12_11","MRK","12","11","11","ⵡⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵙⵉⴷⵉ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴻⵄⵊⴻⴱ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ.’” ");
INSERT INTO rift_vpl VALUES ("MK12_12","071_12_12","MRK","12","12","12","ⵅⵙⴻⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵎⵉⵏⵣⵉ ⴼⴻⵀⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵅⴰⵙⴻⵏ ⵙ ⵓⵎⴻⴷⵢⴰ ⵏⵏⵉ. ⵏⵉⵜⵏⵉ ⵊⵊⵉⵏ ⵜ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK12_13","071_12_13","MRK","12","13","13","ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔⴻⵙ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵓ ⵛⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵟⵟⴼⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK12_14","071_12_14","MRK","12","14","14","ⵓⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵜⴻⴳⴳⵯⵉⴷⴻⴷ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵓ ⵡⴰⵔ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵛⴰ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ. ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵏⴻⵡⵛ ⴷⴷⴰⵔⵉⴱⴰ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵉ ⵇⴰⵢⵚⴰⵔ ⵏⵉⵖ ⵍⵍⴰ? ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⵅⴻⴵⴻⵚ ⴹⴹⴰⵔⵉⴱⴰ ⵏⵉⵖ ⵍⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK12_15","071_12_15","MRK","12","15","15","ⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴳⴻⴱ ⵅ ⵏⵏⵉⴼⴰⵇ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵎ? ⴰⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵥⴰⵔⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("MK12_16","071_12_16","MRK","12","16","16","ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵉ ⵢⵉⵍⴰⵏ ⵜⴰⵚⵡⵉⵔⵜ-ⴰ ⴷ ⵜⵉⵔⴰ-ⵢⴰ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵏ ⵇⴰⵢⵚⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("MK12_17","071_12_17","MRK","12","17","17","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵛⴻⵎ ⵅⴻⵏⵏⵉ ⵉ ⵇⴰⵢⵚⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵇⴰⵢⵚⴰⵔ, ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⴰⵔⴻⴱⴱⵉ.” ⵓⵛⴰ ⵜⵜⵄⴻⵊⴱⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK12_18","071_12_18","MRK","12","18","18","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵏⵓⴽⵔⴰ. ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("MK12_19","071_12_19","MRK","12","19","19","“ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⴰⵇⴰ ⵢⵓⵔⴰ ⴰⵏⴻⵖ ⵎⵓⵙⴰ, ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵉ ⵃⴻⴷ ⵓⵎⴰⵙ ⵓⵛⴰ ⵉⵊⵊⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵊⵊⵉ ⴱⵓ ⵜⴰⵔⵔⴰⵡⵜ, ⴰⴷ ⵢⴰⵡⵉ ⵓⵎⴰⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴻⵊⵊ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK12_20","071_12_20","MRK","12","20","20","ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ. ⴰⵎⴻⵣⵡⴰⵔⵓ ⵢⵉⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵊⵊⵉ ⴱⵓ ⴷⴷⵓⵔⵉⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK12_21","071_12_21","MRK","12","21","21","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵢⵉ ⵉ-ⵜⵜ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵓⵛⴰ ⵉⵎⵎⵓⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵊⵊⵉ ⴱⵓ ⴷⴷⵓⵔⵉⵢⴻⵜ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK12_22","071_12_22","MRK","12","22","22","ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵜⵜ, ⵡⴰⵔ ⴷⴷ-ⵊⵊⵉⵏ ⴱⵓ ⴷⴷⵓⵔⵉⵢⴻⵜ. ⴰⵏⴻⴳⴳⴰⵔ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴻⵎⵎⵓⵜ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MK12_23","071_12_23","MRK","12","23","23","ⵉⵡⴰ ⴷⵉ ⵜⵏⵓⴽⵔⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴽⴽⴰⵔⴻⵏ, ⵓⵎⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ? ⵎⵉⵏⵣⵉ ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵡⵢⴻⵏ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("MK12_24","071_12_24","MRK","12","24","24","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⵅⴻⵟⵟⵉⵎ ⵛⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("MK12_25","071_12_25","MRK","12","25","25","ⵎⴰⵖⴰⵔ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴽⴽⴰⵔⴻⵏ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵉⵡⵢⴻⵏ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵓ ⵡⴰⵔ ⵙⵙⵎⵉⴵⵉⵛⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK12_26","071_12_26","MRK","12","26","26","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ: ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵎⵓⵙⴰ, ⵎⴰⵎⵎⴻⵛ ⴰⴽⵉⴷⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵉⵏⵏⴰ: ‘ⴷ ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ’? ");
INSERT INTO rift_vpl VALUES ("MK12_27","071_12_27","MRK","12","27","27","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵎⴰⵛⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵅⴻⵟⵟⴰⵎ ⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK12_28","071_12_28","MRK","12","28","28","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵙⵍⴰ ⴰⵙⴻⵏ ⵜⵜⴻⵎⵀⴰⵔⵡⴰⴹⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵎⵍⵉⵃ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵜ: “ⵎⴰⵏ ⵜⴻⵏⵜ ⵉⴵⴰⵏ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵅ ⴽⵓⵍⵛⵉ?” ");
INSERT INTO rift_vpl VALUES ("MK12_29","071_12_29","MRK","12","29","29","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ: ⵙⴻⵍ ⴰ ⵉⵙⵔⴰⵉⵍ! ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵙⵉⴷⵉ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("MK12_30","071_12_30","MRK","12","30","30","ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ. ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("MK12_31","071_12_31","MRK","12","31","31","ⵓ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⴰⵎⴻⵛⵏⴰⵡ ⵜⴰⵏⵉⵜⴰ, ⴰⵇⴰ ⴷ ⵜⴰ: ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⴻⴼ ⵏⵏⴻⵛ. ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏⵏⴻⵖⵏⵉⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⵉⵏⴰ ⵙ ⵜⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK12_32","071_12_32","MRK","12","32","32","ⵉⵏⵏⴰ ⴰⵙ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ: “ⵏⵉⵛⴰⵏ, ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⴻⵏⵏⵉⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ ⵎⵖⵉⵔ ⵏⴻⵜⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("MK12_33","071_12_33","MRK","12","33","33","ⵓ ⴱⴻⵍⵍⵉ ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜ ⵉⵅⵙ ⵙ ⵡⵓⵍ ⵎⴰⵔⵔⴰ, ⵙ ⵍⴻⵄⵇⴻⵍ ⵎⴰⵔⵔⴰ, ⵙ ⵍⴻⵄⵎⴰⵔ ⵎⴰⵔⵔⴰ ⵓ ⵙ ⵊⵊⴻⵀⴷ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⴰⴷ ⵉⵅⵙ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵃⵙⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵏ ⵡⴻⵛⵎⴰⴹ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵏⵏⴻⵖⵏⵉⵜ.” ");
INSERT INTO rift_vpl VALUES ("MK12_34","071_12_34","MRK","12","34","34","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⴱⴻⵍⵍⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵙ ⵍⴻⵄⵇⴻⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⵉⴳⴳⵯⵉⵊⴻⴷ ⵛⴰ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⵡⵡⴻⵍ ⵃⴻⴷ ⴰⴷ ⵜ ⵉⵙⵙⴻⵇⵙⴰ ⵓⵍⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MK12_35","071_12_35","MRK","12","35","35","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵟⵟⴻⴼ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵇⵇⴰⵔⴻⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵎⴰⵙⵉⵃ ⴷ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ? ");
INSERT INTO rift_vpl VALUES ("MK12_36","071_12_36","MRK","12","36","36","ⵎⵉⵏⵣⵉ ⴷⴰⵡⵓⴷ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵏⵏⴰ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ: ‘ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ⵇⵇⵉⵎ-ⴷⴷ ⵅ ⵓⴼⵓⵙⵉ ⵉⵏⵓ ⴰⵍ ⴷⴷ ⵖⴰ ⴳⴳⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("MK12_37","071_12_37","MRK","12","37","37","ⵙ ⵓⵢⴰ ⵉⵜⵜⵍⴰⵖⴰ ⴰⵙ-ⴷⴷ ⴷⴰⵡⵓⴷ: ‘ⵙⵉⴷⵉ ⵉⵏⵓ!’ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵉⴽⴽⴰ ⴷ ⵎⵎⵉⵙ?” ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵜⵓⵖⴰ ⵉⵙⵍⴰ ⴰⵙ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK12_38","071_12_38","MRK","12","38","38","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵙ: “ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵙⴻⵏ ⵍⵃⴰⵍ ⵅⵎⵉ ⵖⴰ ⵓⵢⵓⵔⴻⵏ ⵙ ⵍⴻⵄⴱⴰⵢⴰⵜ ⵜⵉⵣⵉⵔⴰⵔⵉⵏ ⵓ ⵅⵎⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵙⴻⴵⵎⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵍⴻⵙⵡⴰⵇ, ");
INSERT INTO rift_vpl VALUES ("MK12_39","071_12_39","MRK","12","39","39","ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵙⴻⵏ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵣⵣⴰⵜ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ, ⵓⵍⴰ ⴷ ⵉⵎⵓⵛⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵖⴰⵔ ⵉⵎⴻⵏⵙⵉⵡⴻⵏ ⵏ ⵡⵓⵔⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK12_40","071_12_40","MRK","12","40","40","ⵏⵉⵜⵏⵉ ⵜⵜⴻⵜⵜⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵜⵉⵊⵊⴰⵍ ⴰⵎ ⵜⵜᵉⵜⵜⴰⵔⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵥⴰⴵⴰⵜⵉⵏ ⵏⵙⴻⵏ ⵜⵉⵣⵉⵔⴰⵔⵉⵏ. ⴰⵇⴰ ⵉⵏⴰ ⴰⴷ ⴽⵙⵉⵏ ⵍⵃⵓⴽⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK12_41","071_12_41","MRK","12","41","41","ⴰⵎ ⵉⵇⵇⵉⵎ ⵢⴰⵙⵓⵄ ⵇⵉⴱⴰⵍⵜ ⵉ ⵙⵙⴻⵏⴷⵓⵇ ⵏ ⵚⵚⴻⴷⵇⴻⵜ, ⵉⵥⵔⴰ ⵎⴰⵎⵎⴻⵛ ⵉⵏⴻⵟⵟⴰⵔ ⵍⵖⴰⵛⵉ ⵜⵉⵏⵄⴰⵛⵉⵏ ⴷⵉ ⵙⵙⴻⵏⴷⵓⵇ. ⴰⵟⵟⴰⵙ ⵏ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵜⵓⵖⴰ ⵏⴻⵟⵟⴰⵔⴻⵏ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK12_42","071_12_42","MRK","12","42","42","ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⴷ ⵍⵎⴻⵙⴽⵉⵏⴰ ⵜⴻⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ, ⵙⴻⵎⵎⴰⵏ ⵜⴻⵏⵜ ‘ⵛⴰⵎⵓⵏⴰⵜ’. ");
INSERT INTO rift_vpl VALUES ("MK12_43","071_12_43","MRK","12","43","43","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵜⴰⵊⵊⴰⵍⵜ-ⴰ ⵍⵎⴻⵙⴽⵉⵏⴰ ⴰⵇⴰ ⵜⴻⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⴽⵜⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵉⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵙⵙⴻⵏⴷⵓⵇ ⵏ ⵚⵚⴻⴷⵇⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("MK12_44","071_12_44","MRK","12","44","44","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵏⴹⴰⵔⴻⵏ ⴷⴰⵢⴻⵙ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵜⴰ ⵣⵉ ⴷⵔⵓⵙ ⵏⵏⴻⵙ ⵜⴻⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⴽⵓⵍⵛⵉ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⴰⵇⴰ ⵜⴻⵏⴹⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⴷ ⴰⴳⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK13_1","071_13_1","MRK","13","1","1","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵏⵏⴰ ⴰⵙ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵅⵣⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⵉⵥⵔⴰ-ⵢⴰ ⴷ ⵍⴻⴱⵏⵉ-ⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("MK13_2","071_13_2","MRK","13","2","2","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⴻⵥⵔⵉⴷ ⵍⴻⴱⵏⵉ-ⵢⴰ ⵉⵎⵖⴰⵔⴻⵏ? ⵡⴰⵔ ⴷⴰ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵅ ⵡⴻⵥⵔⵓ ⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴰⵔ ⵉⵜⵜⵏⴻⵀⴷⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK13_3","071_13_3","MRK","13","3","3","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ ⵍⴰⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("MK13_4","071_13_4","MRK","13","4","4","“ⵉⵏⵉ ⴰⵏⴻⵖ ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵓ ⵎⴰⵏ ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵏ-ⴰ ⴰⴷ ⴰⵡⴹⴻⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("MK13_5","071_13_5","MRK","13","5","5","ⵉⴱⴷⴰ ⵢⴰⵙⵓⵄ ⵉⵇⵇⴰⵔ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵖⴻⴽⴽⵡⵉ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MK13_6","071_13_6","MRK","13","6","6","ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ!’, ⵓⵛⴰ ⴰⴷ ⵖⵡⴰⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK13_7","071_13_7","MRK","13","7","7","ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵅ ⵉⵎⴻⵏⵖⴰⵏ ⴷ ⵍⴻⵅⴱⴰⵔ ⵏ ⴳⴰⵔⵔⴰⵜ, ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵙ ⵓⵖⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK13_8","071_13_8","MRK","13","8","8","ⵎⵉⵏⵣⵉ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⴽⴽⴰⵔ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵓ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴹⵉⴷⴷ ⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵀⴻⵣⵣⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵣⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵍⴰⵥ ⴷ ⵓⵖⴻⵡⵡⵓⵖ. ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("MK13_9","071_13_9","MRK","13","9","9","ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵜⵓⴷⵔⵉⵏ ⵏ ⵛⵛⵔⴻⵄ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ, ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK13_10","071_13_10","MRK","13","10","10","ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MK13_11","071_13_11","MRK","13","11","11","ⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⴳⴻⵡⵡⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵏ, ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵙ ⵡⴻⵎⵏⵓⵙ ⵇⴱⴻⵍ ⵣⵉ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⵎ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⵅⴰⵔⵔⵉⵚⴻⵎ ⵛⴰ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵎⴰ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ, ⵙⵉⵡⵍⴻⵎ ⵣⵣⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵎⴰⵛⴰ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK13_12","071_13_12","MRK","13","12","12","ⵓⵎⴰⵙ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵓⵎⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵓ ⴱⴰⴱⴰⵙ ⴰⴷ ⵉⵙⴻⵍⵍⴻⵎ ⵎⵎⵉⵙ, ⵓⵛⴰ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵜⴰⵔⵡⴰ ⵅ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK13_13","071_13_13","MRK","13","13","13","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵛⴰⵔⵀⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵚⴱⴰⵔⴻⵏ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK13_14","071_13_14","MRK","13","14","14","ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵏⵏⵄⵉ ⵏ ⵡⴰⵔⴻⵢⵢⴻⴱ, ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵓⵏⴰⴱⵉ ⴷⴰⵏⵉⵢⴰⵍ, ⵉⵜⵜⴱⴻⴷⴷⴰ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⴱⴻⴷⴷ - ⵡⴻⵏⵏⵉ ⵉⵖⵔⵉⵏ ⴰⴷ ⵉⴼⵀⴻⵎ! - ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("MK13_15","071_13_15","MRK","13","15","15","ⵓ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⵉ ⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴻⴼ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MK13_16","071_13_16","MRK","13","16","16","ⵓ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵄⵉⵇⵇⵉⴱ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⵙⴻⵍⵀⴰⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK13_17","071_13_17","MRK","13","17","17","ⵓⵛⵜ ⵅ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴷ ⵜⵉⵏⵏⵉ ⵉⵙⵙⵓⵟⵓⴹⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("MK13_18","071_13_18","MRK","13","18","18","ⵥⴰⴵⴻⵎ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⴰⵔⴻⵡⵍⴰ ⵏⵡⴻⵎ ⴷⵉ ⵍⵎⴻⵛⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("MK13_19","071_13_19","MRK","13","19","19","ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⵡⴰⵔ ⵜⵓⵖⵉ ⴰⵎ ⵏⴻⵜⵜⴰⵜ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ ⴰⵔⴻⴱⴱⵉ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵍ ⵍⴻⵅⵅⵓ, ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MK13_20","071_13_20","MRK","13","20","20","ⵎⴰⵍⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵙⵙⴻⵎⵥⵉ ⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵡⴰⵔ ⵜⵏⴻⵊⵊⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⴷⴷⴰⵜ, ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⵉⵙⵙⴻⵎⵥⵉ ⵓⵙⵙⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK13_21","071_13_21","MRK","13","21","21","ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵉⵏⵏⴰ ⴰⵡⴻⵎ ⵉⵊⵊⴻⵏ: ‘ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⴷⴰ!’, ⵏⵉⵖ: ‘ⴰⵇⴰ-ⵜ ⴷⵉⵀⴰ!’, ⵡⴰⵔ ⵜ ⵜⵜⴰⵎⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK13_22","071_13_22","MRK","13","22","22","ⵎⵉⵏⵣⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵉⵎⴰⵙⵉⵃⴻⵏ ⵉⴼⴰⵍⵙⵓⵜⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵃⵉⵎⴰ, ⵎⴰⵍⴰ ⵉⵣⴻⵎⵎⴰⵔ, ⴰⴷ ⵅⴻⴷⵄⴻⵏ ⵄⴰⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK13_23","071_13_23","MRK","13","23","23","ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ, ⵃⴹⴰⵎ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MK13_24","071_13_24","MRK","13","24","24","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵡⴰⵔⵏⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵏⵉ, ⴰⴷ ⵜⴻⴱⴱⴰⵔⵛⴻⵏ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⵜⴰⵣⵉⵔⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵛ ⵄⴰⴷ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("MK13_25","071_13_25","MRK","13","25","25","ⵉⵜⵔⴰⵏ ⴰⴷ ⴷⴷ-ⵡⴹⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵚⵚⵓⵍⴰⵟⴰⵜ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MK13_26","071_13_26","MRK","13","26","26","ⵅⴻⵏⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵙ ⵊⵊⴻⵀⴷ ⴷ ⵓⵄⵓⴵⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK13_27","071_13_27","MRK","13","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵢⵔⵓ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵓⵙⴻⵎⵎⵉⴹ, ⵣⵉ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵍ ⵟⵟⴰⵔⴼ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK13_28","071_13_28","MRK","13","28","28","ⵍⴻⵎⴷⴻⵎ ⵣⴻⴳ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⴰⵎⴻⵜⵜⵉⵍ-ⴰ: ⵅⵎⵉ ⵖⴰ ⴷⴻⵡⵍⴻⵏ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⴰⵔⴻⴹⴱⴻⵏ ⵓⵛⴰ ⵜⵉⴼⵔⴰⵢ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴰⵏⴻⴱⴷⵓ ⵢⵉⵡⴻⴹ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MK13_29","071_13_29","MRK","13","29","29","ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵜⴻⵎⵙⴰⵔⴰⵏⵜ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ, ⵅ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("MK13_30","071_13_30","MRK","13","30","30","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵊⵊⵉⵍ-ⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵓ ⵛⴰ ⴰⵍ ⴷ ⵖⴰ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK13_31","071_13_31","MRK","13","31","31","ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵄⴷⵓⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⵄⴻⴷⴷⵓⵏ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("MK13_32","071_13_32","MRK","13","32","32","ⵎⴰⵛⴰ ⴰⵙⵙ ⵏⵏⵉ ⴷ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ, ⵓⵍⴰ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ, ⵎⵖⵉⵔ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK13_33","071_13_33","MRK","13","33","33","ⵅⵥⴰⵔⴻⵎ, ⵃⴹⴰⵎ, ⵥⴰⴵⴻⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⴻⵍⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK13_34","071_13_34","MRK","13","34","34","ⴰⵇⴰ-ⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵙⴰⴼⴰⵔ, ⵉⵊⵊⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵡⴻⴽⴽⴻⵍ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵚⵚⵓⵍⵟⴰ, ⵉⵡⵛⴰ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵄⵍⴻⵎ ⴰⵙ ⵉ ⵓⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴷ ⵉⵃⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("MK13_35","071_13_35","MRK","13","35","35","ⵉⵡⴰ ⵃⴹⴰⵎ ⵅⴻⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⴻⵍⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵏⵉⵖ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵏⵉⵖ ⵖⴰⵔ ⵓⵙⵇⵓⵇⴻⵄ ⵏ ⵓⵢⴰⵥⵉⴹ ⵏⵉⵖ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ, ");
INSERT INTO rift_vpl VALUES ("MK13_36","071_13_36","MRK","13","36","36","ⵃⵉⵎⴰ, ⵎⴰⵍⴰ ⴷⴷ-ⵉⵜⵜⵉⵙ ⴷⴻⵖⵢⴰ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵉⴼ ⵜᵉⵜⵜⴻⵟⵟⵚⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK13_37","071_13_37","MRK","13","37","37","ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⵍⴻⵅⵅⵓ, ⵇⵇⴰⵔⴻⵖ ⵜ ⵉ ⵎⴰⵔⵔⴰ: ⴼⴰⵇⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("MK14_1","071_14_1","MRK","14","1","1","ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵓ ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_2","071_14_2","MRK","14","2","2","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷⵉ ⵍⵄⵉⴷ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵖⴻⵡⵡⵓⵖ ⴷⵉ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("MK14_3","071_14_3","MRK","14","3","3","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴷⵉ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ, ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⴰⵍⴰⴱⴰⵙⵜⴻⵔ ⴷⴰⵢⴻⵙ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵣⵉ ⵍⴻⵄⵟⵓⵔ ⵏ ⵚⵚⴻⵏⴱⴻⵍ ⵜⴻⵚⴱⴻⵃ, ⵜⵉⵖⵍⴰ. ⵜⴰⵔⵣⴻⵎ ⵜⴰⵣⵉⵢⵢⴰⵜ ⵏⵏⵉ, ⵜⴼⴰⵔⵔⴻⵖ ⵉ-ⵜⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MK14_4","071_14_4","MRK","14","4","4","ⵜⵓⵖⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵅⴻⵢⵢⵇⴻⵏ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⴰⴹⴻⵢⵢⴻⵄ ⵏ ⵣⵣⴻⵛⵜ-ⴰ ⵉ ⵡⴻⴷⵀⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("MK14_5","071_14_5","MRK","14","5","5","ⵎⵉⵏⵣⵉ ⵉⵍⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⵎⴻⵏⵣ ⵣⵣⴻⵛⵜ-ⴰ ⵙ ⴽⵜⴰⵔ ⵣⵉ ⵜⴻⵍⵜ-ⵎⵢⴰ ⴷⵉⵏⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵉ ⵉⵎⴻⵣⵍⴰⴹ.” ⵓⵛⴰ ⵅⴻⵢⵢⵇⴻⵏ ⵅⴰⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK14_6","071_14_6","MRK","14","6","6","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵊⵊⴻⵎ ⵜⵜ! ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⵙ ⵜᵉⵜⵜⵄⴻⴷⴷⴰⵎ? ⴰⵇⴰ ⵜⴻⴳⴳⴰ ⴷⴰⵢⵉ ⵉⵊⵊ ⵏ ⵛⵖⴻⵍ ⵉⵛⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK14_7","071_14_7","MRK","14","7","7","ⵎⵉⵏⵣⵉ ⵉⵎⴻⵣⵍⴰⴹ ⴰⵇⴰ ⴰⵜⴻⵏ ⵍⴻⴱⴷⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴽⵉⵙⴻⵏ ⵜⴻⴳⴳⴻⵎ ⵍⵅⴰⵔ ⵎⴻⵍⵎⵉ ⵎⴰ ⵜⴻⵅⵙⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⴷⵡⴻⵎ ⵜⵜⵖⵉⵎⵉⵖ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("MK14_8","071_14_8","MRK","14","8","8","ⵏⴻⵜⵜⴰⵜ ⵜⴻⴳⴳⴰ ⵎⵉⵏ ⵓⵎⵉ ⵜⵣⴻⵎⵎⴰⵔ. ⴰⵇⴰ ⵜⵉⵣⵣⴰⵔ ⵜⴻⵎⵙⴻⵃ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵙ ⵍⴻⵄⵟⵓⵔ ⵉ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MK14_9","071_14_9","MRK","14","9","9","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ-ⴰ ⴰⵚⴻⴱⵃⴰⵏ ⵣⵣⴰⵢⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵅ ⵎⵉⵏ ⵜⴻⴳⴳⴰ, ⴷ ⵍⵉⴷⴰⵔⴻⵜ ⵉ ⵏⴻⵜⵜⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("MK14_10","071_14_10","MRK","14","10","10","ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ, ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ, ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⴻⵍⵍⴻⵎ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MK14_11","071_14_11","MRK","14","11","11","ⵓⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴼⴰⵔⵃⴻⵏ ⵓⵛⴰ ⵡⴰⵄⴷⴻⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜ ⵉⵙⴻⵍⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("MK14_12","071_14_12","MRK","14","12","12","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵓⵎⵉ ⵜⵜⵏⵓⵎⴰⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰⵏⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵏⵔⴰⵃ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵛⵛⴻⴷ ⴰⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ?” ");
INSERT INTO rift_vpl VALUES ("MK14_13","071_14_13","MRK","14","13","13","ⵉⵙⵙⴻⴽⴽ ⵜⵏⴰⵢⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵓ ⵅⵣⴰⵔ, ⴰⴷ ⵜⴻⵎⵙⴰⴳⴰⵔⴻⵎ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵢⴰⵔⴱⵓ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵓⵛⵜ ⵏ ⵡⴰⵎⴰⵏ. ⴹⴼⴰⵔⴻⵎ ⵜ! ");
INSERT INTO rift_vpl VALUES ("MK14_14","071_14_14","MRK","14","14","14","ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⴷⴻⴼ, ⵉⵏⵉⵎ ⵉ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ: ‘ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ ⵉⵇⵇⴰⵔ: ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⵜⵖⵓⵔⴼⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵖ ⴰⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ?’ ");
INSERT INTO rift_vpl VALUES ("MK14_15","071_14_15","MRK","14","15","15","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵍ ⵉⵊⵊ ⵏ ⴰⵔⵡⴰ ⵉⵎⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⵉⵙⵙⵓ, ⵉⵄⴷⴻⵍ. ⴷⵉⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK14_16","071_14_16","MRK","14","16","16","ⴼⴼⵖⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵓⴼⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ, ⵅⴻⵏⵏⵉ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("MK14_17","071_14_17","MRK","14","17","17","ⵖⴰⵔ ⵓⵄⴻⵛⵛⵉ ⵢⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK14_18","071_14_18","MRK","14","18","18","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ, ⵜⵜᵉⵜⵜⴻⵏ, ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴻⵏⵏⵉ ⴽⵉⴷⵉ ⵉⵜⵜᵉⵜⵜⴻⵏ, ⴰⴷ ⴰⵢⵉ ⵉⵖⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("MK14_19","071_14_19","MRK","14","19","19","ⴱⴷⴰⵏ ⵜⵜⴻⵛⴹⵉⵏⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ ⵉⵊⵊⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵎⴰ ⴷ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("MK14_20","071_14_20","MRK","14","20","20","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ ⵉ ⵉⵙⵙⵉⵙⵏⴻⵏ ⴰⴽⵉⴷⵉ ⴰⵖⵔⵓⵎ ⴷⵉ ⵟⵟⴻⴱⵚⵉ. ");
INSERT INTO rift_vpl VALUES ("MK14_21","071_14_21","MRK","14","21","21","ⴰⵇⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵔⴰⵃ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵜⵓⵔⴰ. ⵎⴰⵛⴰ ⵓⵛⵜ ⵅ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵣⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵖⴷⴰⵔ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ⵉⵃⵍⴰ ⴰⵙ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵎⵍⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵅⵍⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("MK14_22","071_14_22","MRK","14","22","22","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜᵉⵜⵜⴻⵏ, ⵉⴽⵙⵉ ⵢⴰⵙⵓⵄ ⴰⵖⵔⵓⵎ, ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ, ⵢⴰⵔⵥⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜ, ⵉⵏⵏⴰ: “ⴽⵙⵉⵎ, ⵛⵛⴻⵎ, ⴰⵇⴰ ⵜⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("MK14_23","071_14_23","MRK","14","23","23","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵍⴽⴰⵙ, ⵉⵇⴰⴷⴰ, ⵉⴱⴰⵔⴻⴽ, ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜ, ⵓ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵙⵡⵉⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK14_24","071_14_24","MRK","14","24","24","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵉⵏⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵍⴻⵏ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_25","071_14_25","MRK","14","25","25","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴻⵙⵙⴻⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵜⵜ ⵖⴰ ⵙⵡⴻⵖ ⵊⴷⵉⴷ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK14_26","071_14_26","MRK","14","26","26","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵖⴻⵏⵏⵊⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵥⵍⵉ ⵏ ⵜⵜⴻⵙⴱⵉⵃ, ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_27","071_14_27","MRK","14","27","27","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴰⵢⵉ ⵜⴻⵏⴷⴻⵔⴼⴻⵎ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: ‘ⴰⵇⴰ ⴰⴷ ⵡⵜⴻⵖ ⴰⵎⴻⴽⵙⴰⵡ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("MK14_28","071_14_28","MRK","14","28","28","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵣⵡⴰⵔⴻⵖ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("MK14_29","071_14_29","MRK","14","29","29","ⵉⵏⵏⴰ ⴰⵙ ⴱⵓⵟⵔⵓⵙ: “ⵡⴰⵅⵅⴰ ⴰⴷ ⴷⴰⵢⴻⴽ ⵏⴷⴻⵔⴼⴻⵏ ⵎⴰⵔⵔⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⴽ ⵜⵜⵏⴻⴷⵔⵉⴼⴻⵖ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK14_30","071_14_30","MRK","14","30","30","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⴷⵉ ⴵⵉⵍⴻⵜ-ⴰ, ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK14_31","071_14_31","MRK","14","31","31","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵄⴰⴷ ⴰⵟⵟⴰⵙ: “ⵎⴰⵍⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵎⵎⵜⴻⵖ ⴰⴽⵉⴷⴻⴽ, ⵡⴰⵔ ⵛⴻⴽ ⵏⴻⴽⴽⴰⵔⴻⵖ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!” ⵓⵛⴰ ⴰⵎ ⵏⴻⵜⵜⴰ, ⴰⵎⵎⵓ ⵉ ⵏⵏⴰⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("MK14_32","071_14_32","MRK","14","32","32","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵅⵉⵜⵙⵉⵎⴰⵏⵉⵢ’. ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵇⵇⵉⵎⴻⵎ ⴷⴰ, ⴰⵍⴰⵎⵉ ⵥⵓⴵⴻⵖ ⵏⴻⵛⵛ” ");
INSERT INTO rift_vpl VALUES ("MK14_33","071_14_33","MRK","14","33","33","ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⴰⴽⵉⴷⴻⵙ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵜⵜⵏⴻⵅⵍⴰⵄ, ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK14_34","071_14_34","MRK","14","34","34","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵛⴹⴻⵏ ⴰⵍ ⵍⵎⴻⵡⵜ. ⵇⵇⵉⵎⴻⵎ ⴷⴰ, ⵜⴻⵃⴹⴰⵎ!” ");
INSERT INTO rift_vpl VALUES ("MK14_35","071_14_35","MRK","14","35","35","ⵢⵓⵢⵓⵔ ⵛⵡⴰⵢⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵓⵛⴰ ⵉⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵥⵥⵓⴵ ⵃⵉⵎⴰ, ⵎⴰⵍⴰ ⵉⵄⴻⴷⴷⴻⵍ, ⴰⴷ ⵅⴰⵙ ⵜⴻⵄⴷⵓ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK14_36","071_14_36","MRK","14","36","36","ⵉⵏⵏⴰ: “ⴱⴰⴱⴰ, ⴱⴰⴱⴰ ⵉⵏⵓ, ⴽⵓⵍⵛⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⵅⴰⵙ! ⴽⵙⵉ ⵅⴰⴼⵉ ⵍⴽⴰⵙ-ⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵎⵉⵏ ⵅⵙⴻⵖ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("MK14_37","071_14_37","MRK","14","37","37","ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ, ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⵟⵟⵚⴻⵏ. ⵉⵏⵏⴰ ⴰⵙ ⵉ ⴱⵓⵟⵔⵓⵙ: “ⴰ ⵛⵉⵎⵄⵓⵏ, ⵎⴰ ⴰⵇⴰ ⵛⴻⴽ ⵜᵉⵜⵜⴻⵟⵟⵚⴻⴷ? ⵎⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("MK14_38","071_14_38","MRK","14","38","38","ⵃⴹⴰⵎ, ⵥⴰⴵⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⴷⴻⴳ ⵓⵊⴰⵔⵔⴻⴱ. ⴰⵔⵔⵓⵃ ⴰⵇⴰ ⵉⵡⵊⴻⴷ, ⵎⴰⵛⴰ ⴷⴷⴰⵜ ⴰⵇⴰ ⵜⴻⴹⵄⴻⴼ.” ");
INSERT INTO rift_vpl VALUES ("MK14_39","071_14_39","MRK","14","39","39","ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵄⴰⵡⴻⴷ, ⵉⵥⵥⵓⴵ, ⵉⵄⴰⵡⴻⴷ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_40","071_14_40","MRK","14","40","40","ⵉⴷⵡⴻⵍ-ⴷⴷ ⵄⴰⵡⴻⴷ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⵟⵟⵚⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷⴻⵇⵍⴻⵏⵜ ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_41","071_14_41","MRK","14","41","41","ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵟⵟⵚⴻⵎ ⵍⴻⵅⵅⵓ, ⵜⴰⵔⴻⵢⵢⵃⴻⵎ! ⴰⵇⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ ⵓⵏⴻⴳⴳⴰⵔ, ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵙⴰⵄⵄⴻⵜ. ⵅⵣⴰⵔⴻⵎ, ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⴷⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("MK14_42","071_14_42","MRK","14","42","42","ⴽⴽⴰⵔⴻⵎ, ⴰⴷ ⵏⵔⴰⵃ. ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⴷⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⴻⵍⵍⵎⴻⵏ, ⴰⵇⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK14_43","071_14_43","MRK","14","43","43","ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵀⵓⴷⴰ, ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ. ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵟⵟⴰⵙ ⵙ ⵍⴻⵙⵢⵓⴼ ⴷ ⵉⵄⵓⵎⴰⴷ. ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("MK14_44","071_14_44","MRK","14","44","44","ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵉⵇⵇⴰⵔ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵓⴷⵎⴻⵖ ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ. ⵟⵟⴼⴻⵎ ⵜ ⵓⵛⴰ ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("MK14_45","071_14_45","MRK","14","45","45","ⴷⴻⵖⵢⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ!”, ⵓⵛⴰ ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK14_46","071_14_46","MRK","14","46","46","ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK14_47","071_14_47","MRK","14","47","47","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵉⵊⴱⴻⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⵉⵡⵜⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵇⴻⵙⵙ ⴰⵙ ⴰⵎⴻⵣⵣⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("MK14_48","071_14_48","MRK","14","48","48","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴰⵅⵎⵉ ⵅ ⵢⵉⵊⵊ ⵏ ⵓⵇⵟⴰⵟⵄⵉⵢ ⵉ ⵜⴻⴼⴼⵖⴻⵎ ⵅⴰⴼⵉ ⵙ ⵍⴻⵙⵢⵓⴼ ⴷ ⵉⵄⵓⵎⴰⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜᵉⵟⵟⴼⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("MK14_49","071_14_49","MRK","14","49","49","ⴽⵓⵍ ⴰⵙⵙ ⵜⵓⵖⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙⵙⴻⵍⵎⴰⴷⴻⵖ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵟⵟⵉⴼⴻⵎ. ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK14_50","071_14_50","MRK","14","50","50","ⵅⴻⵏⵏⵉ ⵊⵊⵉⵏ ⵜ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_51","071_14_51","MRK","14","51","51","ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵓⵄⴻⵣⵔⵉ, ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⵉⵛⵜ ⵏ ⵜⴻⵛⴹⴰⴹⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⵡⴰⵀⴰ ⵅ ⵜⵇⴻⴷⴷⵉⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("MK14_52","071_14_52","MRK","14","52","52","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵊⵊⴰ ⵜⴰⵛⴹⴰⴹⵜ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵍ ⵣⵣⴰⵢⵙⴻⵏ ⴷ ⴰⵄⴰⵔⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_53","071_14_53","MRK","14","53","53","ⵉⵡⵢⴻⵏ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵇⴰⵢⴰⴼⴰ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⵎⵓⵏⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_54","071_14_54","MRK","14","54","54","ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵊⴰⵔ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵉⵜⵜⵡⴻⵇⵇⴰⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("MK14_55","071_14_55","MRK","14","55","55","ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵔⴻⵣⵣⵓⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴹⵉⴷⴷ ⵉ ⵢⴰⵙⵓⵄ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵏ,    ");
INSERT INTO rift_vpl VALUES ("MK14_56","071_14_56","MRK","14","56","56","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵜⵓⵖⴰ ⵅⴰⵙ ⵛⴻⵀⵀⴷⴻⵏ ⵙ ⵥⵓⵔ, ⵎⴰⵛⴰ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⵜⵎⴻⵍⵇⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MK14_57","071_14_57","MRK","14","57","57","ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵛⴰ ⵓⵛⴰ ⵛⴻⵀⴷⴻⵏ ⵅⴰⵙ ⵙ ⵥⵓⵔ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("MK14_58","071_14_58","MRK","14","58","58","“ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⴰⵙ ⵓⵎⵉ ⵉⵏⵏⴰ: ‘ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵛⴰ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⴱⵏⵉⵖ ⵉⵛⵜⴻⵏ ⵏⵏⴻⵖⵏⵉⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("MK14_59","071_14_59","MRK","14","59","59","ⵎⴰⵛⴰ ⵓⵍⴰ ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⵜⵎⴻⵍⵇⵉⵏⵜ ⵛⴰ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_60","071_14_60","MRK","14","60","60","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⴰⵔⵔⵉⴷ ⵙ ⵛⴰ? ⵎⵉⵏ ⵅⴰⴽ ⵛⴻⵀⵀⴷⴻⵏ ⵢⵉⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("MK14_61","071_14_61","MRK","14","61","61","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵇⴰⵔ, ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵙ ⵛⴰ. ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⴰⵡⴻⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⵍⵎⵓⴱⴰⵔⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("MK14_62","071_14_62","MRK","14","62","62","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ! ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵖⵉⵎⴰ ⵅ ⵓⴼⵓⵙⵉ ⵏ ⵊⵊⴻⵀⴷ, ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵏ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK14_63","071_14_63","MRK","14","63","63","ⵉⵛⴰⵔⵔⴻⴳ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵛⴰⵎⵉⵔ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵃⴷⴰⵊ ⵄⴰⴷ ⵍⴻⵛⵀⵓⴷ! ");
INSERT INTO rift_vpl VALUES ("MK14_64","071_14_64","MRK","14","64","64","ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⴰⵛⴻⵇⵇⴻⴼ ⵏⵏⵉ! ⵎⵉⵏ ⴷⴷ ⴰⵡⴻⵎ ⵉⴹⵀⴰⵔⴻⵏ?” ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵃⴻⴽⵎⴻⵏ ⵅⴰⵙ ⴱⴻⵍⵍⵉ ⵉⵙⴷⴰⵀⴻⴵ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("MK14_65","071_14_65","MRK","14","65","65","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴱⴷⴰⵏ ⵙⵙⵓⵙⵓⴼⴻⵏ ⵅⴰⵙ, ⵜⵜⵍⴻⵃⵃⴰⴼⴻⵏ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵛⵛⴰⵜⴻⵏ ⵜ ⵙ ⵍⴱⵓⵏⵉⵢⵢⴰⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ: “ⵏⴰⴱⴱ!” ⵓⵛⴰ ⵡⵜⵉⵏ ⵜ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵅ ⵓⵇⴰⴱⵙⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK14_66","071_14_66","MRK","14","66","66","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⴷⵉ ⵍⴻⵎⵔⴰⵃ ⵙⵡⴰⴷⴷⴰⵢ, ⵜⵓⵙⴰ-ⴷⴷ ⴷⵉⵏ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵉⵢⵢⴰ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK14_67","071_14_67","MRK","14","67","67","ⵓⵎⵉ ⵜ ⵜⴻⵥⵔⴰ ⵉⵜⵜⵡⴻⵇⵇⴰⵃ, ⵜⴻⵅⵣⴰⵔ ⴷⴰⵢⴻⵙ, ⵜⴻⵏⵏⴰ: “ⴰⵇⴰ ⵜⵓⵖⴰ ⵛⴻⴽ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("MK14_68","071_14_68","MRK","14","68","68","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴽⴰⵔ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ, ⵡⴰⵔ ⴼⵀⵉⵎⴻⵖ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ.” ⵉⴼⴼⴻⵖ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵜⴻⵙⵇⵉⴼⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("MK14_69","071_14_69","MRK","14","69","69","ⵓⵎⵉ ⵜ ⵜⴻⵥⵔⴰ ⵜⴰⵢⵢⴰ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵏⵏⴻⵖⵏⵉ, ⵜⴻⴱⴷⴰ ⵜⴻⵇⵇⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ: “ⴰⵇⴰ ⵡⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK14_70","071_14_70","MRK","14","70","70","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴽⴰⵔ ⵉ ⵓⵎⵓⵔ ⵏⵏⴻⵖⵏⵉ. ⵛⵡⴰⵢⵜ ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵉ ⴱⵓⵟⵔⵓⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵛⴻⴽ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵉⵛⴰⵏ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵄⴰⵡⴻⴷ ⴷ ⴰⵊⴰⵍⵉⵍⵉ. ⵍⵃⴰⵔⴹ ⵏⵏⴻⵛ ⴰⵎ ⵡⴻⵏⵏⵉ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK14_71","071_14_71","MRK","14","71","71","ⵉⴱⴷⴰ ⵉⵏⴻⵄⵄⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵜⵜⵊⵊⴰⴵⴰ: “ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴱⵏⴰⴷⴻⵎ-ⴰ ⵎⵉⵅⴻⴼ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("MK14_72","071_14_72","MRK","14","72","72","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ ⵡⵉⵙⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ. ⵉⴼⴻⴽⴽⴰⵔ ⵛⵉⵎⵄⵓⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ ⵡⵉⵙⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵉⵜⵜⵔⵓ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_1","071_15_1","MRK","15","1","1","ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵏⵉⵜⵏⵉ ⵛⴰⵔⴼⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⵡⵢⴻⵏ ⵜ ⵓⵛⴰ ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⵉ ⴱⵉⵍⴰⵟⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_2","071_15_2","MRK","15","2","2","ⵉⵙⵙⴻⵇⵙⴰ ⵉ-ⵜ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵜⴻⵏⵏⵉⴷ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("MK15_3","071_15_3","MRK","15","3","3","ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵜⵛⴻⵜⵛⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("MK15_4","071_15_4","MRK","15","4","4","ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⴱⵉⵍⴰⵟⵓⵙ ⵄⴰⵡⴻⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⴰⵔⵉⴷ ⵙ ⵛⴰ? ⵅⵣⴰⵔ, ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⴽ ⵉⵜⵜⵛⴻⵜⵛⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK15_5","071_15_5","MRK","15","5","5","ⵡⴰⵔ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵢⴰⵙⵓⵄ ⵙ ⵡⴰⵍⵓ, ⴰⵍⴰⵎⵉ ⵉⵜⴻⴱⵀⴻⵜ ⴱⵉⵍⴰⵟⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_6","071_15_6","MRK","15","6","6","ⵉⵏⵏⵓⵎ ⵉⴹⴻⴵⴻⵇ ⵉ ⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴱⵓⵙ ⴷⵉ ⴽⵓⵍ ⵍⵄⵉⴷ, ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK15_7","071_15_7","MRK","15","7","7","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ, ⵃⴻⴱⴱⵙⴻⵏ ⵜ ⴰⴽ-ⴷ ⵉⵎⵖⴻⵡⵡⵖⴻⵏ, ⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵓⵖⴻⵡⵡⴻⵖ.    ");
INSERT INTO rift_vpl VALUES ("MK15_8","071_15_8","MRK","15","8","8","ⵉⵙⵖⵓⵢⵢ ⵍⵖⴰⵛⵉ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴱⴷⴰⵏ ⵜⵜᵉⵜⵜⴰⵔⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⵓⵎ ⵉⵜⵜⴻⴳⴳ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("MK15_9","071_15_9","MRK","15","9","9","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵉⵍⴰⵟⵓⵙ, ⵉⵏⵏⴰ: “ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵅⵓⵖ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK15_10","071_15_10","MRK","15","10","10","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵇⴰ ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⵣⵉ ⵍⴻⵃⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("MK15_11","071_15_11","MRK","15","11","11","ⵎⴰⵛⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⴰⵔⵏⴻⵏ ⵍⵖⴰⵛⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⴹⵍⴻⵇ ⵉ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_12","071_15_12","MRK","15","12","12","ⴱⵉⵍⴰⵟⵓⵙ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴳⴳⴻⵖ ⵙ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜᵉⵜⵜⵍⴰⵖⴰⵎ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("MK15_13","071_15_13","MRK","15","13","13","ⵙⵖⵓⵢⵢⴻⵏ ⵄⴰⵡⴻⴷ: “ⵚⴻⵍⵍⴱ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("MK15_14","071_15_14","MRK","15","14","14","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⴰⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵉⴳⴳⴰ?” ⵅⴻⵏⵏⵉ ⴰⵔⵏⵉⵏ ⴷⵉ ⵜⵖⵓⵢⵢⵉⵜ ⵄⴰⴷ ⴽⵜⴰⵔ: “ⵚⴻⵍⵍⴱ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("MK15_15","071_15_15","MRK","15","15","15","ⴰⵎ ⵜⵓⵖⴰ ⵉⵅⵙ ⴱⵉⵍⴰⵟⵓⵙ ⴰⴷ ⵉⵙⵙⴰⵔⴹⴰ ⵍⵖⴰⵛⵉ, ⵉⴹⵍⴻⵇ ⵉ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ, ⵎⴰⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵚⴻⵍⵍⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK15_16","071_15_16","MRK","15","16","16","ⴳⴻⵡⵡⴷⴻⵏ ⵜ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵍⴻⵎⵔⴰⵃ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴰⵄ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴱⵔⵉⵜⵓⵔⵉⵢⵓⵎ’, ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴽⵓⵎⴱⴰⵏⵉⵢⵢⴻⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK15_17","071_15_17","MRK","15","17","17","ⵙⵙⵢⴰⵔⴹⴻⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵔⵓⴹ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ, ⵎⵓⴷⴻⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵙ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓⵛⴰ ⵇⵇⵏⴻⵏ ⴰⵙ-ⵜ, ");
INSERT INTO rift_vpl VALUES ("MK15_18","071_15_18","MRK","15","18","18","ⴱⴷⴰⵏ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ: “ⴰⵣⵓⵍ ⵅⴰⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("MK15_19","071_15_19","MRK","15","19","19","ⵜⵓⵖⴰ ⵛⵛⴰⵜⴻⵏ ⵜ ⵖⴰⵔ ⵓⵣⴻⴵⵉⴼ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵄⵎⵓⴷ ⵏ ⵓⵖⴰⵏⵉⵎ, ⵙⵙⵓⵙⵓⴼⴻⵏ ⵅⴰⵙ ⵓⵛⴰ ⵓⴹⴰⵔⴻⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵙⴻⵏ, ⵄⴻⴱⴷⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK15_20","071_15_20","MRK","15","20","20","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ, ⴽⴽⵙⴻⵏ ⴰⵙ ⴰⵙⴻⵍⵀⴰⵎ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵓⵛⴰ ⵙⵙⵢⴰⵔⴹⴻⵏ ⴰⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵚⴻⵍⵍⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK15_21","071_15_21","MRK","15","21","21","ⵃⵚⴰⵔⴻⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴽⴽⵉⵏ ⵙⵙⴻⵏⵏⵉ ⴰⵎ ⴷⴷ-ⵢⵓⵙⴰ ⵣⴻⴳ ⵉⵢⵢⴰⵔ, ⵛⵉⵎⵄⵓⵏ ⵣⵉ ⵇⴰⵢⵔⴰⵡⴰⵏ, ⴱⴰⴱⴰⵙ ⵏ ⴰⵍⵉⴽⵙⴰⵏⴷⵉⵔ ⴷ ⵔⵓⴼⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵢⴰⵔⴱⵓ ⵚⵚⴰⵍⵉⴱ.    ");
INSERT INTO rift_vpl VALUES ("MK15_22","071_15_22","MRK","15","22","22","ⵉⵡⵢⴻⵏ ⵢⴻⵛⵛⵓ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵊⵓⵍⵊⵓⵜⴰ’, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵜⴰⵛⴻⵇⵇⵓⴼⵜ’. ");
INSERT INTO rift_vpl VALUES ("MK15_23","071_15_23","MRK","15","23","23","ⵡⵛⵉⵏ ⴰⵙ ⴱⵉⵏⵓ ⵉⵅⴻⴵⴹⴻⵏ ⵙ ⵎⵉⵔⵔⵓ ⴷ ⴰⵎⴰⵔⵣⴰⴳ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵙⵓⵡ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵙⵓⵡ. ");
INSERT INTO rift_vpl VALUES ("MK15_24","071_15_24","MRK","15","24","24","ⵓⵎⵉ ⵜ ⵚⴻⵍⵍⴱⴻⵏ, ⴱⴹⴰⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴳⴳⵉⵏ ⵅⴰⵙ ⴰⴽⴻⵛⵛⵓⴹ ⵅ ⵎⵉⵏ ⵖⴰ ⵉⴽⵙⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK15_25","071_15_25","MRK","15","25","25","ⵜⵓⵖⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⴷ ⵜⵍⴰⵜⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴻⵙⵄⴰ ⵏ ⵚⵚⴱⴻⵃ, ⵓⵎⵉ ⵜ ⵚⴻⵍⵍⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK15_26","071_15_26","MRK","15","26","26","ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵜⵉⵔⴰ-ⵢⴰ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ: ‘ⵡⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("MK15_27","071_15_27","MRK","15","27","27","ⵚⴻⵍⵍⴱⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ, ⵉⵊⵊⴻⵏ ⵅ ⵓⴼⵓⵙⵉ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_28","071_15_28","MRK","15","28","28","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK15_29","071_15_29","MRK","15","29","29","ⵉⵏⵏⵉ ⵙⵙⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴰⵢⴻⵙ, ⵜⵜⵀⴻⵣⵣⴰⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴰ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵀⴻⴷⵎⴻⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⴻⴱⵏⵉⴷ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("MK15_30","071_15_30","MRK","15","30","30","ⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵀⵡⴰ-ⴷⴷ ⵣⵉ ⵚⵚⴰⵍⵉⴱ!” ");
INSERT INTO rift_vpl VALUES ("MK15_31","071_15_31","MRK","15","31","31","ⴰⵎⵎⵓ ⵉ ⵜ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_32","071_15_32","MRK","15","32","32","ⴻⵊⵊ ⵍⵎⴰⵙⵉⵃ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵍⴻⵅⵅⵓ ⵣⵉ ⵚⵚⴰⵍⵉⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵥⴰⵔ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⴰⵎⴻⵏ.” ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⴽⴽⵡⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("MK15_33","071_15_33","MRK","15","33","33","ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵙⴰⵄⵄⴻⵜ ⵙⴻⵜⵜⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴹⴹⵀⵓⵔ, ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ ⴰⵍ ⵜⴻⵙⵄⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵓⵄⴻⵛⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("MK15_34","071_15_34","MRK","15","34","34","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵜⴻⵙⵄⴰ ⵉⵙⵖⵓⵢ ⵢⴰⵙⵓⵄ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ, ⵉⵏⵏⴰ: “ⵉⵍ, ⵉⵍ, ⵍⵎⴰⵏⴰ ⵛⴰⴱⴰⵇⵜⴰⵏⵉ?”, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: “ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰⵢⵉ ⵜⵙⴻⵎⵃⴻⴷ?”    ");
INSERT INTO rift_vpl VALUES ("MK15_35","071_15_35","MRK","15","35","35","ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵉ ⵉⵍⵉⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("MK15_36","071_15_36","MRK","15","36","36","ⵢⵓⵣⵣⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊⴻⵏ, ⵉⵙⵙⵓⴼⴼ ⵉⵛⵜ ⵏ ⵙⴱⵓⵏⵅⴰ ⵙ ⵍⵅⴻⴵ, ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵅ ⵓⵖⴰⵏⵉⵎ, ⵉⵡⵛⴰ ⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵓⵡ. ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵔⴰⵊⴰ! ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵥⴰⵔ ⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵉⵍⵉⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⵀⵡⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK15_37","071_15_37","MRK","15","37","37","ⵅⴻⵏⵏⵉ ⵉⵙⵖⵓⵢ ⵢⴰⵙⵓⵄ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⵓⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("MK15_38","071_15_38","MRK","15","38","38","ⴰⵍⴻⵃⵃⴰⴼ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴻⴳ ⵅ ⵜⵏⴰⵢⴻⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵖⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("MK15_39","071_15_39","MRK","15","39","39","ⵓⵎⵉ ⵉⵥⵔⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵎⵢⴰ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜⴻⵙ, ⵉⵙⵖⵓⵢⵢⵓ ⴰⵎⵎⵓ ⵙ ⵊⵊⴻⵀⴷ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵓⵙⵓⴼⴼⴻⵖ ⵏ ⵏⵏⴻⴼⵙ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⵓⵖⴰ ⴱⵏⴰⴷⴻⵎ-ⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("MK15_40","071_15_40","MRK","15","40","40","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵅⴻⵣⵣⴰⵔⴻⵏⵜ ⵉ-ⴷⴷ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ, ⵊⴰⵔ ⴰⵙⴻⵏⵜ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴰⵎⴰⵥⵓⵥ, ⵓ ⵏ ⵢⵓⵙⵉⵙ, ⴷ ⵙⴰⵍⵓⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("MK15_41","071_15_41","MRK","15","41","41","ⵜⵉⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ, ⵙⴻⵅⵅⴰⵔⴻⵏⵜ ⵅⴰⵙ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉⵜ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("MK15_42","071_15_42","MRK","15","42","42","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⴻⴷⴷⵉⵜ ⵏ ⵓⵙⴻⵡⵊⴻⴷ, ⵜⴰⵎⴻⴷⴷⵉⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⵉ ⵙⵙⴻⴱⵜ, ");
INSERT INTO rift_vpl VALUES ("MK15_43","071_15_43","MRK","15","43","43","ⵢⵓⵙⴰ-ⴷⴷ ⵢⵓⵙⵓⴼ ⵣⵉ ⵔⴰⵎⵜⴰ, ⵉⵊⵊ ⵏ ⵓⵎⵛⴰⵡⴰⵔ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵣⵄⴻⵎ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⴱⵉⵍⴰⵟⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵜⵜⴰⵔ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("MK15_44","071_15_44","MRK","15","44","44","ⵉⵜⴻⴱⵀⴻⵜ ⴱⵉⵍⴰⵟⵓⵙ ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⴰⵎⵎⵓ ⴷⴻⵖⵢⴰ. ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵎⵢⴰ, ⵉⵙⵙⴻⵇⵙⴰ ⵜ, ⵎⴰ ⵉⵎⵎⵓⵜ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("MK15_45","071_15_45","MRK","15","45","45","ⵓⵎⵉ ⵉⴼⵀⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵣⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵎⵢⴰ, ⵉⵡⵛⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵉ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("MK15_46","071_15_46","MRK","15","46","46","ⵉⵙⵖⴰ ⵢⵓⵙⵓⴼ ⵍⴻⵛⴼⴻⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵉⴽⵙⵉ ⵜ ⵣⵉ ⵚⵚⴰⵍⵉⴱ, ⵉⵛⴼⴻⵏ ⵉ-ⵜ ⴷⵉ ⵍⴻⵛⴼⴻⵏ ⵏⵏⵉ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵉ ⵅⴻⴱⵛⴻⵏ ⴷⵉ ⵙⵙⴻⴵⴰⵃ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵏⵓⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵅ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("MK15_47","071_15_47","MRK","15","47","47","ⵜⵓⵖⴰ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⵓⵙⵉ, ⵥⵔⵉⵏⵜ ⵎⴰⵏⵉ ⵜ ⵙⵙⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK16_1","071_16_1","MRK","16","1","1","ⵓⵎⵉ ⵉⵄⴷⵓ ⵙⵙⴻⴱⵜ, ⵜⴻⵙⵖⴰ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴷ ⵙⴰⵍⵓⵎⵉ ⵍⴻⵄⵟⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴷⴻⵀⵏⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MK16_2","071_16_2","MRK","16","2","2","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵉⵡⴹⴻⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("MK16_3","071_16_3","MRK","16","3","3","ⵏⵏⴰⵏⵜ ⵊⴰⵔ ⴰⵙⴻⵏⵜ: “ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⵏⵓⵏⵏⵢⴻⵏ ⵜⴰⵚⴹⴰⵔⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵡⴰⴷⴰⴼ ⵏ ⵡⴻⵏⴹⴻⵍ?” ");
INSERT INTO rift_vpl VALUES ("MK16_4","071_16_4","MRK","16","4","4","ⵍⴰⵎⵉ ⵅⵣⴰⵔⴻⵏⵜ, ⵥⵔⵉⵏⵜ ⴰⵇⴰ ⵜⴰⵚⴹⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵇⵏⵓⵏⵏⵉ ⵣⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("MK16_5","071_16_5","MRK","16","5","5","ⵍⴰⵎⵉ ⵓⴷⴼⴻⵏⵜ ⵖⴰⵔ ⵢⵉⴼⵍⵉ ⵏ ⵡⴻⵏⴹⴻⵍ, ⵥⵔⵉⵏⵜ ⵉⵊⵊ ⵏ ⵓⴱⵍⵉⵖ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ, ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵓⵛⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵏⵏⵅⴻⵍⵄⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MK16_6","071_16_6","MRK","16","6","6","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏⵜ: “ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵏⵜ ⵛⴰ! ⴽⴻⵏⵏⵉⵏⵜ ⵜⴰⵔⴻⵣⵣⵓⵏⵜ ⵅ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ, ⵅⵣⴰⵔⴻⵏⵜ, ⴰⵇⴰ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜ ⵙⵙⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK16_7","071_16_7","MRK","16","7","7","ⵎⴰⵛⴰ ⵔⵓⵃⴻⵏⵜ, ⵉⵏⵉⵏⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵍⴰ ⵉ ⴱⵓⵟⵔⵓⵙ, ⴰⵇⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵣⵡⴰⵔ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ⴷⵉⵏⵏⵉ ⴰⴷ ⵜ ⵜⵥⴰⵔⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("MK16_8","071_16_8","MRK","16","8","8","ⴼⴼⵖⴻⵏⵜ ⴷⴻⵖⵢⴰ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏⵜ ⵣⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵎⵉⵏⵣⵉ ⵜⵇⴻⴱⵙ ⵉ-ⵜⴻⵏⵜ ⵜⴰⵔⵊⵉⵊⵉⵜ ⴷ ⴷⴷⴻⵀⵛⴰⵏ, ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵏⵏⵉⵏⵜ ⵉ ⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴳⴳⵯⴻⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("MK16_9","071_16_9","MRK","16","9","9","ⵖⴰⵔ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵓⵛⴰ ⵉⴹⵀⴰⵔ-ⴷⴷ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⴻⴱⵄⴰ ⵏ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK16_10","071_16_10","MRK","16","10","10","ⵜⴰⵏⵉⵜⴰ ⵜⵔⵓⵃ ⵓⵛⴰ ⵜⵅⴻⴱⴱⴰⵔ ⴰⵢⴰ ⵉ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⴻⴹⵏⴻⵏ ⵓ ⵜⵜⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("MK16_11","071_16_11","MRK","16","11","11","ⵍⴰⵎⵉ ⵉⵏⴰ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⴷⴷⴰⵔ ⵓⵛⴰ ⵉⴱⴰⵏ ⴰⵙⴻⵏⵜ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵓⵎⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK16_12","071_16_12","MRK","16","12","12","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⴷⴷⵓⴷ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵏⴰⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴷⵛⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("MK16_13","071_16_13","MRK","16","13","13","ⵓⵍⴰ ⴷ ⵉⵏⴰ ⵔⵓⵃⴻⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⵓⵍⴰ ⴷ ⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("MK16_14","071_16_14","MRK","16","14","14","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵉⴱⴰⵏ-ⴷⴷ ⵉ ⵃⵉⵟⴰⵛ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵓⵛⴰ ⵉⵄⴰⵢⴰⵔ ⵉ-ⵜⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜ ⵉⵥⵔⵉⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("MK16_15","071_16_15","MRK","16","15","15","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ, ⴱⴰⵔⵔⵃⴻⵎ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("MK16_16","071_16_16","MRK","16","16","16","ⵡⴻⵏⵏⵉ ⵢⵓⵎⵉⵏⴻⵏ ⵓ ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ, ⴰⵇⴰ ⵉⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⴰⵙⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("MK16_17","071_16_17","MRK","16","17","17","ⵜⵉⵏⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵢⵓⵎⵉⵏⴻⵏ: ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏ ⵊⴷⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("MK16_18","071_16_18","MRK","16","18","18","ⴰⴷ ⴽⵙⵉⵏ ⵉⴼⵉⵖⵔⴰⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓ ⵎⴰⵍⴰ ⵙⵡⵉⵏ ⵎⵉⵏ ⵉⵏⴻⵇⵇⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵉⴹⴹⴰⵔⵔⵉ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵅ ⵉⵎⴻⵀⵍⴰⵛ, ⴰⴷ ⴳⴳⴻⵏⴼⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("MK16_19","071_16_19","MRK","16","19","19","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵎⵎⴻⴽⵙⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⵙⵙⵖⵉⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⵓⴼⵓⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("MK16_20","071_16_20","MRK","16","20","20","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵓⵛⴰ ⴱⴰⵔⵔⵃⴻⵏ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ, ⵓ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵜⵓⵖⴰ ⵉⵄⴰⵡⴻⵏ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵍⵅⴻⵟ ⵏⵏⴻⵙ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⵢⴻⴳⴳⵉⵏ. ⴰⵎⵉⵏ. ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⵎⴰⵔⴽⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("LK1_1","072_1_1","LUK","1","1","1","ⵓⵎⵉ ⴰⵟⵟⴰⵙ ⵉⴷⵙⴻⵏ ⵜⵓⵖⴰ ⵏⵡⴰⵏ ⴰⴷ ⴰⵔⵉⵏ ⵉⵎⴻⵣⵔⵓⵢⴻⵏ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵣⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵇⵏⴻⵄ ");
INSERT INTO rift_vpl VALUES ("LK1_2","072_1_2","LUK","1","2","2","- ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⴰⵡⴰⵍ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵓ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ - ");
INSERT INTO rift_vpl VALUES ("LK1_3","072_1_3","LUK","1","3","3","ⵉⴱⴰⵏ ⴰⵢⵉ-ⴷⴷ ⵓⵍⴰ ⵉ ⵏⴻⵛⵛ, ⵎⵉⵏⵣⵉ ⴹⴼⴰⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵎⵍⵉⵃ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵔⵉⵖ ⴽⵓⵍⵛⵉ ⵙ ⵓⵙⴻⵜⵜⴻⴼ, ⴰ ⵜⵉⵢⵓⴼⵉⵍⵉⵙ ⵉⵄⵉⵣⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK1_4","072_1_4","LUK","1","4","4","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ ⵜⵉⴷⴻⵜⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK1_5","072_1_5","LUK","1","5","5","ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ. ⵏⴻⵜⵜⴰ ⵣⵉ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⴱⵉⵢⴰ ⵓⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ-ⵜⵜ ⵣⵉ ⵜⴰⵔⵔⴰⵡⵜ ⵏ ⵀⴰⵔⵓⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⵍⵉⵚⴰⴱⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LK1_6","072_1_6","LUK","1","6","6","ⵜⵓⵖⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴹⴼⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵓ ⵓⵢⵓⵔⴻⵏ ⴷⵉ ⵍⴰⵜⴰⵔⴰⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏ ⵙⵉⴷⵉ ⴱⵍⴰ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("LK1_7","072_1_7","LUK","1","7","7","ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵓⵃⴻⵏⵊⵉⵔ ⵎⵉⵏⵣⵉ ⵉⵍⵉⵚⴰⴱⵉⵜ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵔⵓⵡ ⵛⴰ ⵓ ⵜⵓⵖⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵎⵖⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_8","072_1_8","LUK","1","8","8","ⴰⵇⴰ ⵉⵎⵙⴰⵔ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵏⵏⵓⴱⴻⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏⵏⴻⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK1_9","072_1_9","LUK","1","9","9","ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴷⴰⵢⴻⵙ ⵓⴽⴻⵛⵛⵓⴹ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴰⵄⵉⴷⴰ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⵅⵓⵔ, ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LK1_10","072_1_10","LUK","1","10","10","ⵜⵓⵖⴰ ⵇⴰⵄ ⴰⴱⴰⵔⵔⵓ ⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵥⴰⴵⴰ ⴱⴰⵔⵔⴰ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("LK1_11","072_1_11","LUK","1","11","11","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴹⵃⴰⵔ ⴰⵙ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵓⴼⵓⵙⵉ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵍⴻⴱⵅⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("LK1_12","072_1_12","LUK","1","12","12","ⵓⵎⵉ ⵜ ⵉⵥⵔⴰ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵉⵏⵏⴻⵅⵍⴻⵄ ⵓⵛⴰ ⵉⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK1_13","072_1_13","LUK","1","13","13","ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵡⴰⵇⴱⴻⵍ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵛ. ⴰⵇⴰ ⵉⵍⵉⵚⴰⴱⵉⵜ, ⵜⴰⵎⴻⵟⵟⵓⵜ ⵏⵏⴻⵛ, ⴰⴷ ⴰⵛ ⴷⴷ-ⵜⴰⵔⵓⵡ ⴰⵃⴻⵏⵊⵉⵔ, ⴰⴷ ⵜ ⵜⵙⴻⵎⵎⵉⴷ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_14","072_1_14","LUK","1","14","14","ⴰⴷ ⵜⴼⴰⵔⵃⴻⴷ ⵓ ⴰⴷ ⵜⴻⵙⵍⵉⵡⵍⴻⵡⴻⴷ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵉ ⵡⴻⵅⵍⴰⵇ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK1_15","072_1_15","LUK","1","15","15","ⵎⵉⵏⵣⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⴱⵉⵏⵓ ⵓⵍⴰ ⴷ ⵛⵛⵔⴰⴱ. ⴰⴷ ⵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("LK1_16","072_1_16","LUK","1","16","16","ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⴰⵟⵟⴰⵙ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_17","072_1_17","LUK","1","17","17","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵓⵢⵓⵔ ⵣⵣⴰⵜⴻⵙ ⵙ ⴰⵔⵔⵓⵃ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⵓⵏⴰⴱⵉ ⵉⵍⵉⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ ⵓⵍⴰⵡⴻⵏ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵖⴰⵔ ⵜⴰⵔⵔⴰⵡⵜ ⵏⵙⴻⵏ ⵓ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵖⴰⵔ ⵜⵓⵙⵙⵏⴰ ⵏ ⵓⵎⵙⴻⴳⴳⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⴽⵎⴻⵍ ⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK1_18","072_1_18","LUK","1","18","18","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵅ ⵍⵎⴰⵍⴰⴽ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ ⴰⴷ ⴼⴻⵀⵎⴻⵖ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉⵏⵓ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("LK1_19","072_1_19","LUK","1","19","19","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵊⵉⴱⵔⵉⵍ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴽ ⵙⵙⵉⵡⵍⴻⵖ, ⴰⴷ ⵛⴻⴽ ⵅⴻⴱⴱⴰⵔⴻⵖ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵡⴰⵏⵉⵜⴰ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_20","072_1_20","LUK","1","20","20","ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴻⴳⵏⵓⴷ ⵓ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⴰⵍ ⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ ⵓⵢⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⴷ ⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK1_21","072_1_21","LUK","1","21","21","ⵜⵓⵖⴰ ⵍⴳⴻⵏⵙ ⴷⵉ ⴱⴰⵔⵔⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵓⵛⴰ ⵉⵡⴷⴰⵏ ⵜⵜⴱⴻⵀⵜⴻⵏ ⵓⵎⵉ ⵉⵄⴻⵟⵟⴰⵍ ⴷⴰⵅⴻⵍ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK1_22","072_1_22","LUK","1","22","22","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⵙⵙⵉⵡⴻⵍ. ⵅⴻⵏⵏⵉ ⴼⴻⵀⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵛⴰ ⵏ ⵍⴻⵡⵃⵉⵢ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵜⵓⵖⴰ ⵉⵜⵜⵛⴻⵢⵢⴰⵔ ⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵉⵇⵇⵉⵎ ⵉⴳⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK1_23","072_1_23","LUK","1","23","23","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏⵏⴻⵙ, ⵉⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK1_24","072_1_24","LUK","1","24","24","ⴰⵡⴰⵔⵏⵉ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⴻⴽⵙⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵍⵉⵚⴰⴱⵉⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ. ⵜⴻⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵓⵛⴰ ⵜⴻⴱⴷⴰ ⵜⴻⵇⵇⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("LK1_25","072_1_25","LUK","1","25","25","“ⴰⵎⵎⵓ ⵉ ⵣⵣⴰⵢⵉ ⵉⴳⴳⴰ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵅⵣⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⴽⴽⴻⵙ ⴰⵙⴻⵃⵇⴰⵔ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK1_26","072_1_26","LUK","1","26","26","ⴷⴻⴳ ⵓⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵍⵎⴰⵍⴰⴽ ⵊⵉⴱⵔⵉⵍ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⵏⴰⵚⵉⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("LK1_27","072_1_27","LUK","1","27","27","ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⴷ ⵜⴰⵏⴻⵅⴹⴰⴱⵜ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⴰⵡⵓⴷ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵓⵙⵓⴼ. ⵜⵓⵖⴰ ⵉⵙⴻⵎ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵏⵏⵉ ⵎⴰⵔⵢⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("LK1_28","072_1_28","LUK","1","28","28","ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵍⵎⴰⵍⴰⴽ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵍⴰⵎ ⵅⴰⵎ, ⴰ ⵜⴰⵎⵉⵎⵓⵏⵜ! ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴽⵉⴷⴻⵎ! ⵛⴻⵎ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵊⴰⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK1_29","072_1_29","LUK","1","29","29","ⵓⵎⵉ ⵜ ⵜⴻⵥⵔⴰ, ⵜⴻⵏⵏⴻⵅⵍⴻⵄ ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵅⴰⵔⵔⴻⵚ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵙⵍⴰⵎ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_30","072_1_30","LUK","1","30","30","ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⵎⴰⵔⵢⴰⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⴼⵉⴷ ⴰⵔⴹⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK1_31","072_1_31","LUK","1","31","31","ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴷⴷⴻⵢⵙⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵡⴻⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⴰⴷ ⵜ ⵜⵙⴻⵎⵎⵉⴷ ‘ⵢⴻⵛⵛⵓ’. ");
INSERT INTO rift_vpl VALUES ("LK1_32","072_1_32","LUK","1","32","32","ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⴷ ⵅⴰⵙ ⵜⵜⵍⴰⵖⴰⵏ ⵎⵎⵉⵙ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵓ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵍⵄⴰⵔⵛ ⵏ ⵊⴻⴷⴷⵉⵙ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("LK1_33","072_1_33","LUK","1","33","33","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵄⵇⵓⴱ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵏⴻⴳⴳⴰⵔ ⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK1_34","072_1_34","LUK","1","34","34","ⵜⴻⵏⵏⴰ ⵎⴰⵔⵢⴰⵎ ⵉ ⵍⵎⴰⵍⴰⴽ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵢⴰ ⴰⵎ ⵡⴰⵔ ⵎⵍⵉⵛⴻⵖ ⵛⴰ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ?” ");
INSERT INTO rift_vpl VALUES ("LK1_35","072_1_35","LUK","1","35","35","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⵊⵊⴻⵀⴷ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⴰⴷ ⵅⴰⵎ ⵢⴰⵔⵙⴰ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵅⴻⵍⵇⴻⵏ ⵣⵣⴰⵢⴻⵎ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵓ ⴰⴷ ⵜ ⵙⴻⵎⵎⴰⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK1_36","072_1_36","LUK","1","36","36","ⵅⵣⴰⵔ, ⵉⵍⵉⵚⴰⴱⵉⵜ, ⵍⴰⴵ ⵏⵏⴻⵎ, ⵏⴻⵜⵜⴰⵜ ⵄⴰⵡⴻⴷ ⴰⵇⴰ-ⵜⵜ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴷⵉ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ. ⴰⵇⴰ ⴷ ⴰⵢⵓⵔ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉ ⵏⴻⵜⵜⴰⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵡⴰⵔ ⵜᵉⵜⵜⵉⵔⵓⵡ!’ ");
INSERT INTO rift_vpl VALUES ("LK1_37","072_1_37","LUK","1","37","37","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵢⴻⵡⵄⴰⵔⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK1_38","072_1_38","LUK","1","38","38","ⵜⴻⵏⵏⴰ ⵎⴰⵔⵢⴰⵎ: “ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴷ ⵜⴰⵢⵢⴰ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵢⵉ ⵉⵎⵙⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ.” ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵢⵓⵔ ⵅⴰⵙ ⵍⵎⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("LK1_39","072_1_39","LUK","1","39","39","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ ⵎⴰⵔⵢⴰⵎ, ⵜⵔⵓⵃ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_40","072_1_40","LUK","1","40","40","ⵜⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵜⵙⴻⴵⴻⵎ ⵅ ⵉⵍⵉⵚⴰⴱⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LK1_41","072_1_41","LUK","1","41","41","ⵓⵎⵉ ⵜⴻⵙⵍⴰ ⵉⵍⵉⵚⴰⴱⵉⵜ ⵉ ⵙⵍⴰⵎ ⵏ ⵎⴰⵔⵢⴰⵎ, ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵉⵏⵀⴻⵣⵣ ⵓⵙⴻⵢⵎⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵉⵍⵉⵚⴰⴱⵉⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_42","072_1_42","LUK","1","42","42","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵖⵓⵢ ⵙ ⵊⵊⴻⵀⴷ, ⵜⴻⵏⵏⴰ ⵉ ⵎⴰⵔⵢⴰⵎ: “ⵛⴻⵎ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⴷ ⵊⴰⵔ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵍⵖⵉⴵⴻⵜ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LK1_43","072_1_43","LUK","1","43","43","ⵣⵉ ⵎⴰⵏⵉⵙ ⵖⴰⵔⵉ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙ ⵢⴻⵎⵎⴰⵙ ⵏ ⵙⵉⴷⵉ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("LK1_44","072_1_44","LUK","1","44","44","ⵎⴰⵖⴰⵔ ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵎⵉⵊⵊⴰ ⵏ ⵙⵍⴰⵎ ⵏⵏⴻⵎ ⵖⴰⵔ ⵓⵎⴻⵣⵣⵓⵖ ⵉⵏⵓ, ⵉⵏⵀⴻⵣⵣ ⵓⵙⴻⵢⵎⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK1_45","072_1_45","LUK","1","45","45","ⵙⵙⴻⵄⴷ ⵏ ⵜⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴰⵇⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵣⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK1_46","072_1_46","LUK","1","46","46","ⵜⴻⵏⵏⴰ ⵎⴰⵔⵢⴰⵎ: “ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LK1_47","072_1_47","LUK","1","47","47","ⵉⴼⴰⵔⵃ ⴱⵓⵃⴱⴻⵍ ⵉⵏⵓ ⵙ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("LK1_48","072_1_48","LUK","1","48","48","ⵙ ⵎⵉⵏⵣⵉ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵎⴻⴷⴷⵓⵔ ⴰⵡⴰⴹⴻⵄ ⵏ ⵜⴰⵢⵢⴰ ⵏⵏⴻⵙ. ⵅⵣⴰⵔ, ⵣⵉ ⵍⴻⵅⵅⵓ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵡⴻⵏ ⴰⴷ ⴰⵢⵉ ⵙⴻⵎⵎⴰⵏ ‘ⴷ ⵜⴰⵎⵉⵎⵓⵏⵜ!’ ");
INSERT INTO rift_vpl VALUES ("LK1_49","072_1_49","LUK","1","49","49","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵉⴳⴳⴰ ⴷⴰⵢⵉ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵎⵖⴰⵔⴻⵏⵜ, ⴰⵇⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK1_50","072_1_50","LUK","1","50","50","ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵅ ⵜⴰⵔⵡⴰ ⴷ ⵊⵊⵉⵍⴰⵜ, ⵅ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_51","072_1_51","LUK","1","51","51","ⵙ ⵓⵖⵉⵍ ⵏⵏⴻⵙ ⴰⵇⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵍⴻⵖⵍⴻⴱ. ⵉⴼⴰⵔⵜⴻⴽ ⵉⵏⵏⵉ ⵉⵄⴻⴼⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_52","072_1_52","LUK","1","52","52","ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵉⵖⴹⴻⵍ ⵉ-ⵜⴻⵏ ⵣⵉ ⵍⴻⴽⵔⴰⵙⵉ ⵏⵙⴻⵏ, ⵉⵎⵡⴰⴹⵄⴻⵏ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_53","072_1_53","LUK","1","53","53","ⵉⵙⵙⵊⵉⵡⴻⵏ ⵙ ⵍⵅⴰⵔ ⵉⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ, ⵉⵙⵇⴰⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_54","072_1_54","LUK","1","54","54","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵉⵙⵔⴰⵉⵍ, ⵉⵄⴰⵡⴻⵏ ⵉ-ⵜ, ⴰⵇⴰ ⵉⵄⵇⴻⵍ ⵅ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK1_55","072_1_55","LUK","1","55","55","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴰⴽ-ⴷ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ, ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK1_56","072_1_56","LUK","1","56","56","ⵜⴻⴽⴽⴰ ⵎⴰⵔⵢⴰⵎ ⵄⵍⴰⵃⴰⵍ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵉⵍⵉⵚⴰⴱⵉⵜ, ⵅⴻⵏⵏⵉ ⵜⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK1_57","072_1_57","LUK","1","57","57","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵏ ⵉⵍⵉⵚⴰⴱⵉⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ, ⵜⴻⵊⵊ-ⴷⴷ ⴰⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("LK1_58","072_1_58","LUK","1","58","58","ⵙⵍⵉⵏ ⵊⵊⵉⵔⴰⵏ ⴷ ⵍⴰⴵ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ, ⴼⴰⵔⵃⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK1_59","072_1_59","LUK","1","59","59","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵓⵙⵉⵏ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⵜⵏⴻⵏ ⵉ ⵓⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵙⴻⵎⵎⴰⵏ ⵜ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰⵙ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_60","072_1_60","LUK","1","60","60","ⵎⴰⵛⴰ ⵜᵉⵟⵟⴻⴼ ⵢⴻⵎⵎⴰⵙ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵜⴻⵏⵏⴰ: “ⵍⵍⴰ. ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ⴰⵎⵎⵓ, ⵎⴰⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ⵢⵓⵃⴰⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK1_61","072_1_61","LUK","1","61","61","ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⵉⴵⵉ ⵃⴻⴷ ⵣⵉ ⵍⴰⴵ ⵏⵏⴻⵎ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵙ-ⴷⴷ ⵙ ⵢⵉⵙⴻⵎ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK1_62","072_1_62","LUK","1","62","62","ⵅⴻⵏⵏⵉ ⵛⵉⵢⵢⴰⵔⴻⵏ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵎⴰⵎⵎⴻⵛ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵙⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_63","072_1_63","LUK","1","63","63","ⵉⵜⵜⴰⵔ ⵜⴰⵍⵡⵉⵃⵜ ⵓⵛⴰ ⵢⵓⵔⴰ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵢⵓⵃⴰⵏⵏⴰ.” ⵓⵛⴰ ⵜⴱⴻⵀⵜⴻⵏ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_64","072_1_64","LUK","1","64","64","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴹⵍⴻⵇ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵄⴰⵡⴻⴷ, ⵉⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK1_65","072_1_65","LUK","1","65","65","ⵜⴻⵀⵡⴰ-ⴷⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⵉⵔⴰⵏ ⵏⵙⴻⵏ, ⵙⵙⵉⵡⵍⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⴽⵓⵍ ⵉⴷⵓⵔⴰⵔ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK1_66","072_1_66","LUK","1","66","66","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵅⴻⵎⵎⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵎⵉⵏ ⵖⴰ ⵢⵉⵍⵉ ⵓⵃⴻⵏⵊⵉⵔ-ⴰ?” ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK1_67","072_1_67","LUK","1","67","67","ⵉⵜⵜⵡⴰⵛⵛⵓⵔ ⴱⴰⴱⴰⵙ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵏⴻⴱⴱⴰ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LK1_68","072_1_68","LUK","1","68","68","“ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏⵣⵉ ⵉⴼⴻⴽⴽⴰⵔ ⴷⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵉⵡⵉ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK1_69","072_1_69","LUK","1","69","69","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵢⵉⵛⵛ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK1_70","072_1_70","LUK","1","70","70","- ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵏⴻⵖ ⵉⵏⵏⴰ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⴷⵉⵏ ⵜⵓⵖⴰ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ - ");
INSERT INTO rift_vpl VALUES ("LK1_71","072_1_71","LUK","1","71","71","ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⵉ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ, ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵛⴰⵔⵔⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK1_72","072_1_72","LUK","1","72","72","ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵉⵄⵇⴻⵍ ⵅ ⵍⵄⵓⵀⵓⴷ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK1_73","072_1_73","LUK","1","73","73","ⵅ ⵜⴰⵊⴰⴵⵉⵜ ⵜⴻⵏⵏⵉ ⵉⵊⵊⵓⴵ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⵊⴻⴷⴷⵉⵜⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛ, ");
INSERT INTO rift_vpl VALUES ("LK1_74","072_1_74","LUK","1","74","74","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵖ, ⴰⴷ ⴰⵙ ⵏⵙⴻⵅⵅⴰⵔ ⴱⵍⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("LK1_75","072_1_75","LUK","1","75","75","ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ ⴷ ⵜⵙⴻⴳⴷⴰ, ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LK1_76","072_1_76","LUK","1","76","76","ⵉ ⵛⴻⴽ, ⴰ ⴰⵃⴻⵏⵊⵉⵔ, ⴰⴷ ⴰⵛ ⵜⵜⵍⴰⵖⴰⵏ ⴰⵏⴰⴱⵉ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK1_77","072_1_77","LUK","1","77","77","ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵉ ⵉⴵⴰⵏ ⵙ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK1_78","072_1_78","LUK","1","78","78","ⵙ ⵍⴰⴵⴰⵖ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵉ ⵣⵉ ⵅⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵃⵉⵏⵏ ⵍⴻⴼⵊⴰⵔ ⵣⵉ ⵍⵓⵄⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("LK1_79","072_1_79","LUK","1","79","79","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵔⵖ ⵜⴼⴰⵡⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵎⴻⵡⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴻⵡⵡⴻⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵖ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK1_80","072_1_80","LUK","1","80","80","ⴰⵎ ⵉⴳⴳⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ, ⵢⴰⵔⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⴰⵔⵔⵓⵃ ⵓ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LK2_1","072_2_1","LUK","2","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵓⵎⵓⵔ ⵣⵉ ⵇⴰⵢⵚⴰⵔ ⵓⵖⵓⵙⵜⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_2","072_2_2","LUK","2","2","2","ⴰⵣⴻⵎⵎⴻⵎ-ⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵎⵉ ⵜⵓⵖⴰ ⵇⵉⵔⵉⵏⵉⵢⵓⵙ ⵉⵃⴻⴽⴽⴻⵎ ⴷⵉ ⵙⵓⵔⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_3","072_2_3","LUK","2","3","3","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉⵍⵓⵃ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK2_4","072_2_4","LUK","2","4","4","ⵉⴳⴻⵄⵄⴻⴷ ⵄⴰⵡⴻⴷ ⵢⵓⵙⵓⴼ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ⵖⴰⵔ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵓ ⵣⵉ ⵊⵊⵉⵍ ⵏ ⴷⴰⵡⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("LK2_5","072_2_5","LUK","2","5","5","ⴰⴽ-ⴷ ⵎⴰⵔⵢⴰⵎ, ⵜⴰⵏⴻⵅⴹⴰⴱⵜ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK2_6","072_2_6","LUK","2","6","6","ⵓⵛⴰ ⵉⵎⵙⴰⵔ, ⴰⵍⴰⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ, ⵇⴻⴼⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("LK2_7","072_2_7","LUK","2","7","7","ⵜⵓⵔⵓⵡ-ⴷⴷ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ, ⵜⴻⵙⵙⴻⵏⵏⴻⴹ ⵉ-ⵜ ⴷⵉ ⵜⴻⵃⵍⵓⵛⵉⵏ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⵙ ⵉ-ⵜ ⴷⵉ ⵍⴽⵓⵔⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_8","072_2_8","LUK","2","8","8","ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⵃⴻⵟⵟⴰⵏ ⵜⵉⵃⵉⵎⵔⵉⵡⵉⵏ ⵏⵙⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK2_9","072_2_9","LUK","2","9","9","ⵓ ⵅⵣⴰⵔ, ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⴰⵔⵖ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴻⴹ ⴰⵙⴻⵏ, ⵓⵛⴰ ⵜⵍⴻⵃⵃⴻⴼ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK2_10","072_2_10","LUK","2","10","10","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ, ⴰⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_11","072_2_11","LUK","2","11","11","ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ ⴰⵡⴻⵎ-ⴷⴷ ⴰⵙⵙ-ⴰ ⵓⵎⵙⴻⵏⵊⴻⵎ, ⵙⵉⴷⵉ, ⵍⵎⴰⵙⵉⵃ, ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("LK2_12","072_2_12","LUK","2","12","12","ⴷ ⵡⴰ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ: ⴰⴷ ⵜⴰⴼⴻⵎ ⴰⵙⴻⵢⵎⵉ ⵉⵜⵜⵡⴰⵏⵏⴻⴹ ⴷⵉ ⵜⴻⵃⵍⵓⵛⵉⵏ, ⵉⵎⵎⴰⵔⵙ ⴷⵉ ⵍⴽⵓⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK2_13","072_2_13","LUK","2","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴰⵏ-ⴷⴷ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵜⵜⵚⴻⴱⴱⴰⵃⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵇⵇⴰⵔⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("LK2_14","072_2_14","LUK","2","14","14","“ⴰⵄⵓⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵓⵄⵍⴰ, ⵍⴻⵀⵏⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⴰⵙⵉⵜⴻⵎ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵢⴻⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK2_15","072_2_15","LUK","2","15","15","ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⵓⵢⵓⵔⴻⵏⵜ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵙⵙⵉⵡⵍⴻⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵏⵏⴰⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵥⴰⵔ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK2_16","072_2_16","LUK","2","16","16","ⵓⵙⵉⵏ-ⴷⴷ ⵙ ⵜⴰⵣⵍⴰ, ⵓⴼⵉⵏ ⵎⴰⵔⵢⴰⵎ ⴷ ⵢⵓⵙⵓⴼ ⴷ ⵓⵙⴻⵢⵎⵉ ⵉⵎⵎⴰⵔⵙ ⴷⵉ ⵍⵎⴻⴷⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK2_17","072_2_17","LUK","2","17","17","ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ, ⵄⴰⵡⴷⴻⵏ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵅ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("LK2_18","072_2_18","LUK","2","18","18","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ, ⵜⴱⴻⵀⵜⴻⵏ ⵙ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵏⵏⴰⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_19","072_2_19","LUK","2","19","19","ⵎⴰⵛⴰ ⵎⴰⵔⵢⴰⵎ ⵜⵓⵖⴰ ⵜⵅⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵜᵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⴰⵢⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_20","072_2_20","LUK","2","20","20","ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ, ⵜⵜⵚⴻⴱⴱⴰⵃⴻⵏ ⵓ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵙⵍⵉⵏ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵥⵔⵉⵏ, ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_21","072_2_21","LUK","2","21","21","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ ⵓⵙⴻⵢⵎⵉ, ⵙⴻⵎⵎⴰⵏ ⵜ ‘ⵢⴰⵙⵓⵄ’, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜ ⵉⵙⴻⵎⵎⴰ ⵍⵎⴰⵍⴰⴽ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴽⵙⵉ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_22","072_2_22","LUK","2","22","22","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵇⴻⴷⴷⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ");
INSERT INTO rift_vpl VALUES ("LK2_23","072_2_23","LUK","2","23","23","- ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ: ‘ⴰⵇⴰ ⴽⵓⵍ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵉ ⵙⵉⴷⵉ!’ - ");
INSERT INTO rift_vpl VALUES ("LK2_24","072_2_24","LUK","2","24","24","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵃⴹⴰⵔⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵏⵏⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ: ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ ⵏⵉⵖ ⵜⵢⵓⵢⴰ ⵏ ⵉⵡⴰⵔⵔⵓⴹⴻⵏ ⵏ ⵉⴷⴱⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_25","072_2_25","LUK","2","25","25","ⵜⵓⵖⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵎⵄⵓⵏ. ⵜⵓⵖⴰ ⴰⵔⵢⴰⵣ-ⴰ ⵏⵉⵛⴰⵏ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ⵉⵜⵜⵔⴰⵊⴰ ⴰⴼⴻⵡⵡⴻⵊ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵜⵓⵖⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_26","072_2_26","LUK","2","26","26","ⵜⵓⵖⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵡⴻⵃⵃⴰ ⴰⵙ-ⴷⴷ ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵥⴰⵔ ⵍⵎⴰⵙⵉⵃ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LK2_27","072_2_27","LUK","2","27","27","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵎ ⵜ ⵉⵄⴰⵔⵔⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓⵎⵉ ⴷⴷ-ⵓⴷⴼⴻⵏ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵙ ⵓⵃⴻⵏⵊⵉⵔ ⵢⴰⵙⵓⵄ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴰⵄⵉⴷⴰ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_28","072_2_28","LUK","2","28","28","ⵉⴽⵙⵉ ⵜ ⴷⴻⴳ ⵉⵖⴰⴵⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("LK2_29","072_2_29","LUK","2","29","29","“ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵉⵔⴰⵃ ⴷⵉ ⵍⴻⵀⵏⴰ ⵍⴻⵅⵅⵓ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("LK2_30","072_2_30","LUK","2","30","30","ⵎⵉⵏⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵥⵔⵉⵏⵜ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("LK2_31","072_2_31","LUK","2","31","31","ⵉ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ: ");
INSERT INTO rift_vpl VALUES ("LK2_32","072_2_32","LUK","2","32","32","ⵜⴰⴼⴰⵡⵜ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⴰⵔⴳⴻⴱ ⵉ ⵍⴻⴳⵏⵓⵙ ⴷ ⵓⵄⵓⴵⵉ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("LK2_33","072_2_33","LUK","2","33","33","ⵉⵜⴻⴱⵀⴻⵜ ⵢⵓⵙⵓⴼ ⴷ ⵢⴻⵎⵎⴰⵙ ⵙ ⵎⵉⵏ ⵅⴰⵙ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_34","072_2_34","LUK","2","34","34","ⵅⴻⵏⵏⵉ ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵢⴰⵎ ⵢⴻⵎⵎⴰⵙ: “ⴰⵇⴰ ⵡⴰ ⵉⵎⵎⴰⵔⵙ ⵉ ⵓⵡⴻⵟⵟⵓ ⴷ ⵜⵏⵓⴽⵔⴰ ⵏ ⵡⴰⵟⵟⴰⵙ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵄⴻⴽⴽⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_35","072_2_35","LUK","2","35","35","ⴰⴷ ⵉⵛⵓⵇ ⵙⵙⵉⴼ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵍⴰⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK2_36","072_2_36","LUK","2","36","36","ⵉⵛⵜ ⵏ ⵜⵏⴰⴱⵉⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵃⴰⵏⵏⴰ, ⵢⴻⴵⵉⵙ ⵏ ⴼⴰⵏⵡⵉⵍ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ, ⵜⵓⵖⴰ-ⵜⵜ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵙⴰⵔ ⴰⵟⵟⴰⵙ. ⵜⴻⴷⴷⴰⵔ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("LK2_37","072_2_37","LUK","2","37","37","ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵜⵎⴰⵏⵢⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵡⴰⵔ ⵜᵉⵜⵜⴱⴻⵄⵄⵉⴷ ⵛⴰ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵜⵓⵖⴰ ⵜⵄⴻⴱⴱⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵙ ⵓⵥⵓⵎⵎⵉ ⴷ ⵜⵥⴰⴵⵉⵜ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_38","072_2_38","LUK","2","38","38","ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵜⴱⴻⴷⴷ ⵏⴻⵜⵜⴰⵜ ⵄⴰⵡⴻⴷ, ⵜᵉⵜⵜⵚⴻⴱⴱⴰⵃ ⵉ ⵙⵉⴷⵉ, ⵜⴻⵙⵙⴰⵡⴰⵍ ⵅⴰⵙ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵏ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK2_39","072_2_39","LUK","2","39","39","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⴽⵓⵍⵛⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵙⵉⴷⵉ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵙⴻⵏ ⵏⵏⴰⵚⵉⵔⴰ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LK2_40","072_2_40","LUK","2","40","40","ⵜⵓⵖⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵉⴳⴳⴰⵎ, ⵢⴰⵔⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⴰⵔⵔⵓⵃ, ⵉⴷⵡⴻⵍ ⵉⵛⵛⵓⵔ ⵙ ⵜⵉⵖⵉⵜ, ⵓ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_41","072_2_41","LUK","2","41","41","ⵜⵓⵖⴰ ⵍⴰⴵ ⵏⵏⴻⵙ ⵜⵜⵔⴰⵃⴻⵏ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("LK2_42","072_2_42","LUK","2","42","42","ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⵢⵉⵡⴻⴹ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵍⵄⵉⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵓⵎⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK2_43","072_2_43","LUK","2","43","43","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵄⵉⴷ, ⵄⴻⵇⴱⴻⵏ-ⴷⴷ, ⵎⴰⵛⴰ ⴰⵃⴻⵏⵊⵉⵔ, ⵢⴰⵙⵓⵄ, ⵉⵇⵇⵉⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵎⵉ ⵢⵓⵙⵓⴼ ⴷ ⵢⴻⵎⵎⴰⵙ ⵡⴰⵔ ⴰⵔⴳⵉⴱⴻⵏ ⵛⴰ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_44","072_2_44","LUK","2","44","44","ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⵉⵎⵙⴻⴱⵔⵉⴷⴻⵏ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵓⵢⵓⵔⴻⵏ ⵉⵛⵜ ⵏ ⵜⵉⵛⵍⵉ ⵏ ⵡⴰⵙⵙ, ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⵙ ⵊⴰⵔ ⵍⴰⴵ ⵏⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵙⵙⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_45","072_2_45","LUK","2","45","45","ⵓⵎⵉ ⵡⴰⵔ ⵜ ⵓⴼⵉⵏ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_46","072_2_46","LUK","2","46","46","ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵓⴼⵉⵏ ⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵜⵜⴻⵙⵍⴰ ⵖⴰⵔⵙⴻⵏ, ⵉⵜⵜⵙⴻⵇⵙⴰ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK2_47","072_2_47","LUK","2","47","47","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ ⵜⴱⴻⵀⵜⴻⵏ ⴷⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷ ⵡⴰⵡⴰⵍ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_48","072_2_48","LUK","2","48","48","ⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵏ, ⵜⴱⴻⵀⵜⴻⵏ. ⵜⴻⵏⵏⴰ ⴰⵙ ⵢⴻⵎⵎⴰⵙ: “ⴰ ⵎⵎⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵎⵓ? ⴰⵇⴰ, ⴱⴰⴱⴰⵛ ⴷ ⵏⴻⵛⵛ ⵏⴻⴷⵄⴻⵇ ⵙ ⵜⴰⵔⴻⵣⵣⵓⵜ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("LK2_49","072_2_49","LUK","2","49","49","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⵎ? ⵎⴰ ⵡⴰⵔ ⵜⴰⵔⴳⵉⴱⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵉⵍⵉⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK2_50","072_2_50","LUK","2","50","50","ⵎⴰⵛⴰ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK2_51","072_2_51","LUK","2","51","51","ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵏⵏⴰⵚⵉⵔⴰ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⴰⵙⴻⵏ ⴰⵔⵔⴰⵢ. ⵎⴰⵛⴰ ⵢⴻⵎⵎⴰⵙ ⵜⵅⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK2_52","072_2_52","LUK","2","52","52","ⵓⵛⴰ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵜⵉⴷⴷⵉ ⵏⵏⴻⵙ ⴷ ⵜⵉⵖⵉⵜ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⴰⵔⴹⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵢⴻⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK3_1","072_3_1","LUK","3","1","1","ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵡⵉⵙⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵣⵉ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏ ⵇⴰⵢⵚⴰⵔ ⵜⵉⴱⴰⵔⵢⵓⵙ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴱⵓⵏⵟⵉⵢⵓⵙ ⴱⵉⵍⴰⵟⵓⵙ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵓ ⵀⵉⵔⵓⴷⵓⵙ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵍⵊⴰⵍⵉⵍ, ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵓⵎⴰⵙ, ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵜⵓⵔⵉⵢⴰ ⴷ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵔⴰⵅⵓⵏⵉⵜⵉⵙ, ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵍⵉⵙⴰⵏⵢⵓⵙ ⴷ ⵍⵃⴰⴽⴻⵎ ⵅ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⴱⵉⵍⵉⵏⵉ, ⵜⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ,   * ");
INSERT INTO rift_vpl VALUES ("LK3_2","072_3_2","LUK","3","2","2","ⵓⵎⵉ ⵜⵓⵖⴰ ⵃⴰⵏⵏⴰⵏ ⴷ ⵇⴰⵢⴰⴼⴰ ⴷ ⴰⵔⵔⵓⵢⴰⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵢⵓⵃⴰⵏⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LK3_3","072_3_3","LUK","3","3","3","ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵍ’ⵓⵔⴷⵓⵏ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵜⵜⵓⴱⴻⵜ ⵉ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("LK3_4","072_3_4","LUK","3","4","4","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⵉ ⵉⵏⵏⴰⵏ: “ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵖⵓⵢⵢⵓⵏ ⴷⵉ ⵍⴻⵅⵍⴰ: ⵙⵡⴻⵊⴷⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵙⴻⴳⴳⵎⴻⵎ ⴰⵎⴻⵙⵔⴰⵇ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷⵉ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LK3_5","072_3_5","LUK","3","5","5","ⵎⴰⵔⵔⴰ ⵜⵉⴷⴷⴰⵖⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵏⵜ, ⵎⴰⵔⵔⴰ ⵉⴷⵓⵔⴰⵔ ⴷ ⵜⴻⵡⵔⵉⵔⵉⵏ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⵀⵡⴰⵏ, ⴷⴷⵎⴰⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⵎⴻⵏⵜ, ⵓ ⵉⵎⵓⵛⴰⵏ ⵉⵡⵄⴰⵔⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LK3_6","072_3_6","LUK","3","6","6","ⴽⵓⵍ ⴷⴷⴰⵜ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⴰⴷ ⵜⵥⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK3_7","072_3_7","LUK","3","7","7","ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵉ ⵍⵖⴰⵛⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ: “ⴰ ⵜⴰⵔⵡⴰ ⵏ ⵉⵍⴻⴼⵙⴰⵡⴻⵏ, ⵡⵉ ⴷ ⴰⵡⴻⵎ ⵉⵎⵍⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵔⵣⵓⵎ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⵎ ⵣⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LK3_8","072_3_8","LUK","3","8","8","ⵙ ⵓⵢⴰ ⴳⴳⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵉ ⵖⴰ ⵉⵍⵉⵇⵇⴻⵏ ⵉ ⵜⵜⵓⴱⴻⵜ. ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⴰⵎ ⴰⴷ ⵜⵉⵏⵉⵎ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵡⴻⵎ: ‘ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ!’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⴻⴳ ⵉⵥⵔⴰ-ⵢⴰ ⵜⴰⵔⵡⴰ ⵉ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK3_9","072_3_9","LUK","3","9","9","ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵜⵛⴰⵇⵓⵔⵜ ⵖⴰⵔ ⵉⵥⴻⵡⵔⴰⵏ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ. ⵙ ⵓⵢⴰ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵛⵏⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⴹⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ.”    ");
INSERT INTO rift_vpl VALUES ("LK3_10","072_3_10","LUK","3","10","10","ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵍⵖⴰⵛⵉ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ?” ");
INSERT INTO rift_vpl VALUES ("LK3_11","072_3_11","LUK","3","11","11","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵢⵓⵢⴰ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ, ⴰⴷ ⵉⵡⵛ ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵛⴰ, ⵓ ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵎⴰⵛⵛⴰ, ⴰⴷ ⵉⴳⴳ ⴰⵎⴻⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK3_12","072_3_12","LUK","3","12","12","ⵓⵙⵉⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ?” ");
INSERT INTO rift_vpl VALUES ("LK3_13","072_3_13","LUK","3","13","13","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵜⵜᵉⵟⵟⴼⴻⵎ ⴹⴹⴰⵔⵉⴱⴰ ⴽⵜⴰⵔ ⵣⵉ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵡⴻⵚⵚⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵜᵉⵟⵟⴼⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK3_14","072_3_14","LUK","3","14","14","ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵄⴰⵡⴻⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⵏⴻⵛⵛⵉⵏ?” ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵍⵖⴰⵔ ⵓⵍⴰ ⴷⴻⴳ ⵉⵊⵊ, ⵡⴰⵔ ⴷⴻⴵⵎⴻⵎ ⵃⴻⴷ, ⵇⴻⵏⵏⵄⴻⵎ ⵙ ⵍⵎⵓⵏⴻⵜ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK3_15","072_3_15","LUK","3","15","15","ⴰⵎ ⵉⴱⴷⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵉⵜⵜⵛⴻⵍ ⵅ ⵢⵓⵃⴰⵏⵏⴰ, ⵓ ⵅⴰⵔⵔⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵎⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("LK3_16","072_3_16","LUK","3","16","16","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵢⵓⵃⴰⵏⵏⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵙⵙⴻⵖⴹⴰⵚⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⵉ ⵉⵊⴻⵀⴷⴻⵏ ⵅⴰⴼⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴷⵉⵀⵉⴵⴻⵖ ⵓⵍⴰ ⴰⴷ ⴰⵙ ⴼⴻⵙⵢⴻⵖ ⵉⴼⵉⵍⴰⵏ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵖⴹⴻⵚ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴷⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LK3_17","072_3_17","LUK","3","17","17","ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵜⴰⵣⵣⴰⵔⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵉⵣⴷⴻⴳ ⴰⵏⴷⵔⴰⵔ ⵏⵏⴻⵙ. ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵉⵔⴷⴻⵏ ⵖⴰⵔ ⵍⵎⴰⵔⵙⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵛⴰⵔⴼⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵙ ⵜⵎⴻⵙⵙⵉ ⵡⴰⵔ ⵉⵅⵙⵉⵏ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("LK3_18","072_3_18","LUK","3","18","18","ⵙ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉⵡⴷⴰⵏ ⵓⵛⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("LK3_19","072_3_19","LUK","3","19","19","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵄⴰⵢⴰⵔ ⵢⵓⵃⴰⵏⵏⴰ ⵀⵉⵔⵓⴷⵓⵙ, ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵀⵉⵔⵓⴷⵉⵢⵢⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵓⵎⴰⵙ, ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⵉⴳⴳⴰ, ");
INSERT INTO rift_vpl VALUES ("LK3_20","072_3_20","LUK","3","20","20","ⴰⵇⴰ ⵢⴰⵔⵏⵉ ⵀⵉⵔⵓⴷⵓⵙ ⵄⴰⵡⴻⴷ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵃⴻⴱⴱⴻⵙ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("LK3_21","072_3_21","LUK","3","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⴻⵖⴹⴻⵚ ⵢⵓⵃⴰⵏⵏⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵉⵙⵙⴻⵖⴹⴻⵚ ⵄⴰⵡⴻⴷ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⴰⵎ ⵜⵓⵖⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵥⴰⴵⴰ, ⵉⵏⵏⵓⵔⵣⴻⵎ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("LK3_22","072_3_22","LUK","3","22","22","ⵓⵛⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵚⵚⵉⴼⴻⵜ ⵏ ⴷⴷⴰⵜ ⵏ ⵜⴻⴷⴱⵉⵔⵜ. ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵜⵓⵖⴰ ⵜⴻⵇⵇⴰⵔ: “ⵛⴻⴽ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⴷⴰⵢⴻⴽ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("LK3_23","072_3_23","LUK","3","23","23","ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵖⴰⵔⴻⵙ ⵄⵍⴰⵃⴰⵍ ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ⵎⵎⵉⵙ ⵏ ⵀⴰⵢⵍⵉ, ");
INSERT INTO rift_vpl VALUES ("LK3_24","072_3_24","LUK","3","24","24","ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⴽⵉ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵏⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ");
INSERT INTO rift_vpl VALUES ("LK3_25","072_3_25","LUK","3","25","25","ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵜⴰ, ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵓⵙ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⵓⵎ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵙⵍⵉ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵊⵊⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("LK3_26","072_3_26","LUK","3","26","26","ⵎⵎⵉⵙ ⵏ ⵎⴰⵄⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵜ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵉ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("LK3_27","072_3_27","LUK","3","27","27","ⵎⵎⵉⵙ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵎⵎⵉⵙ ⵏ ⵔⵉⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵣⴰⵔⵓⴱⴱⴰⴱⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵄⴰⵍⵜⵉⵢⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵏⵉⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("LK3_28","072_3_28","LUK","3","28","28","ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⴽⵉ, ⵎⵎⵉⵙ ⵏ ⴰⴷⴷⵉ, ⵎⵎⵉⵙ ⵏ ⵇⵓⵚⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵎⵓⴷⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵄⵉⵔ, ");
INSERT INTO rift_vpl VALUES ("LK3_29","072_3_29","LUK","3","29","29","ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵉ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵉⵜⴰ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵡⵉ, ");
INSERT INTO rift_vpl VALUES ("LK3_30","072_3_30","LUK","3","30","30","ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵍⵢⴰⵇⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("LK3_31","072_3_31","LUK","3","31","31","ⵎⵎⵉⵙ ⵏ ⵎⴰⵍⵉⵢⴰ, ⵎⵎⵉⵙ ⵏ ⵎⵉⵢⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵜⴰⵜⴰ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵜⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("LK3_32","072_3_32","LUK","3","32","32","ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ, ⵎⵎⵉⵙ ⵏ ⵄⵓⴱⵉⴷ, ⵎⵎⵉⵙ ⵏ ⴱⵓⵄⴰⵣ, ⵎⵎⵉⵙ ⵏ ⵙⴰⵍⵎⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⵛⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("LK3_33","072_3_33","LUK","3","33","33","ⵎⵎⵉⵙ ⵏ ⵄⴰⵎⵎⵉⵏⴰⴷⴰⴱ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵚⵔⵓⵏ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵔⵉⵚ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("LK3_34","072_3_34","LUK","3","34","34","ⵎⵎⵉⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵉⵙⵃⴰⵇ, ⵎⵎⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵎⵎⵉⵙ ⵏ ⵜⴰⵔⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵏⴰⵃⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("LK3_35","072_3_35","LUK","3","35","35","ⵎⵎⵉⵙ ⵏ ⵙⴰⵔⵓⵊ, ⵎⵎⵉⵙ ⵏ ⵔⴰⵄⵓⵡ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵍⴰⵊ, ⵎⵎⵉⵙ ⵏ ⵄⴰⴱⵉⵔ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵍⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("LK3_36","072_3_36","LUK","3","36","36","ⵎⵎⵉⵙ ⵏ ⵇⵉⵏⴰⵏ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴼⴰⴽⵛⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵛⴰⵎ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵃ, ⵎⵎⵉⵙ ⵏ ⵍⴰⵎⴰⴽ, ");
INSERT INTO rift_vpl VALUES ("LK3_37","072_3_37","LUK","3","37","37","ⵎⵎⵉⵙ ⵏ ⵎⴰⵜⵓⵛⴰⵍⴰⵃ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵏⵓⵅ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵔⴰⴷ, ⵎⵎⵉⵙ ⵏ ⵎⴰⵀⴰⵍⴰⵍ-ⵉⵍ, ⵎⵎⵉⵙ ⵏ ⵇⵉⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("LK3_38","072_3_38","LUK","3","38","38","ⵎⵎⵉⵙ ⵏ ⴰⵏⵓⵛ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵜ, ⵎⵎⵉⵙ ⵏ ⴰⴷⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK4_1","072_4_1","LUK","4","1","1","ⵢⴰⵙⵓⵄ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵣⵉ ⵍ’ⵓⵔⴷⵓⵏ ⴰⵎ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("LK4_2","072_4_2","LUK","4","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵊⴰⵔⵔⴻⴱ ⵣⴻⴳ ⵉⴱⵍⵉⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵡⴰⵔ ⵉⵛⵛⵉ ⵡⴰⵍⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵍⴰⵥ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK4_3","072_4_3","LUK","4","3","3","ⵉⵏⵏⴰ ⴰⵙ ⵉⴱⵍⵉⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵉ ⵉ ⵡⴻⵥⵔⵓ-ⵢⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵖⵔⵓⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK4_4","072_4_4","LUK","4","4","4","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵙ ⵡⴻⵖⵔⵓⵎ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵙ ⴽⵓⵍ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ.’” ");
INSERT INTO rift_vpl VALUES ("LK4_5","072_4_5","LUK","4","5","5","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜ ⵛⵛⵉⵟⴰⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⵢⵓⵄⵍⴰⵏ, ⵉⵙⵙⵛⴻⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴻⵍⴷⵉⵡⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷⴻⴳ ⵉⵊⵊⴻⵏ ⵡⴻⵔⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LK4_6","072_4_6","LUK","4","6","6","ⵉⵏⵏⴰ ⴰⵙ ⵉⴱⵍⵉⵙ: “ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⵚⵚⵓⵍⵟⴰ-ⵢⴰ ⵎⴰⵔⵔⴰ ⴷ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵉ ⵏⴻⵛⵛ ⵓⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⵓ ⵜⵜⵉⵛⴻⵖ ⵜⵜ ⵉ ⵓⵎⵉ ⵅⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LK4_7","072_4_7","LUK","4","7","7","ⵎⴰⵍⴰ ⵜⵄⴻⴱⴷⴻⴷ ⴰⵢⵉ, ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK4_8","072_4_8","LUK","4","8","8","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵓⵎⵉ ⵖⴰ ⵜⵙⴻⵊⴷⴻⴷ ⵓ ⵉ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ ⵓⵎⵉ ⵖⴰ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ.’” ");
INSERT INTO rift_vpl VALUES ("LK4_9","072_4_9","LUK","4","9","9","ⵢⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵜⵣⴻⵇⵇⴰ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⴹⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙⵙⴰ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("LK4_10","072_4_10","LUK","4","10","10","ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: ‘ⴰⴷ ⵢⵓⵎⵓⵔ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵅⴰⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴽ ⵃⴹⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("LK4_11","072_4_11","LUK","4","11","11","ⴰⵇⴰ ⵅ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏⵜ ⴰⴷ ⵛⴻⴽ ⴽⵙⵉⵏⵜ, ⵃⵉⵎⴰ ⴰⴹⴰⵔ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⵏⴻⴳⴳⴻⵃ ⵛⴰ ⴰⵥⵔⵓ.’” ");
INSERT INTO rift_vpl VALUES ("LK4_12","072_4_12","LUK","4","12","12","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ: ‘ⵡⴰⵔ ⵜⵜⵊⴰⵔⵔⴰⴱ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("LK4_13","072_4_13","LUK","4","13","13","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵉⴱⵍⵉⵙ ⵎⴰⵔⵔⴰ ⴰⵊⴰⵔⵔⴻⴱ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ ⵅⴰⵙ ⵛⴰ ⵏ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("LK4_14","072_4_14","LUK","4","14","14","ⵉⵄⵇⴻⴱ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⵔⵓⵃ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ, ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ ⵅⴰⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK4_15","072_4_15","LUK","4","15","15","ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵙⵙⵄⵓⴵⴰⵏ ⵜ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK4_16","072_4_16","LUK","4","16","16","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵏⵏⴰⵚⵉⵔⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵔⴻⴱⴱⴰ, ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵏⴰⵎⵉⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⴽⴽⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK4_17","072_4_17","LUK","4","17","17","ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵓⵛⴰ ⵢⴰⵔⵣⴻⵎ ⵢⴰⵙⵓⵄ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ, ⵢⵓⴼⴰ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("LK4_18","072_4_18","LUK","4","18","18","“ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⵅⴰⴼⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴷⵀⴻⵏ ⴰⵢⵉ ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵎⴻⵣⵍⴰⴹ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵏⴼⵉⵖ ⵉⵏⵏⵉ ⵓⵎⵉ ⵢⴰⵔⵥ ⵡⵓⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵉ ⵉⵎⴻⵃⴱⴰⵙ ⵙ ⵓⵙⴰⵔⵔⴻⵃ, ⵉ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵙ ⵍⵅⴻⵥⵔⴰⵜ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴼⴻⵡⵡⵊⴻⵖ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵥⴻⵏ ⵙ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK4_19","072_4_19","LUK","4","19","19","ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK4_20","072_4_20","LUK","4","20","20","ⵅⴻⵏⵏⵉ ⵢⴻⵏⵏⴻⴹ ⴰⴷⵍⵉⵙ, ⵉⵡⵛⴰ ⵉ-ⵜ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵉⵇⵇⵉⵎ, ⴰⵎ ⴷⴰⵢⴻⵙ ⵏⴹⴰⵔⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LK4_21","072_4_21","LUK","4","21","21","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵉⵇⵇⴰⵔ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ-ⵢⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK4_22","072_4_22","LUK","4","22","22","ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵛⴻⵀⵀⴷⴻⵏ ⵅⴰⵙ, ⵜⴱⴻⵀⵜⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴹⴰ ⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ?” ");
INSERT INTO rift_vpl VALUES ("LK4_23","072_4_23","LUK","4","23","23","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵏⵉⵛⴰⵏ ⴰⴷ ⴰⵢⵉ ⵜⵉⵏⵉⵎ ⵍⵎⴰⵜⴰⵍ-ⴰ: ‘ⴰ ⴰⴹⴱⵉⴱ, ⵙⴳⴻⵏⴼⴰ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ! ⵎⴻⵛⵃⴰⵍ ⵏⴻⵙⵍⴰ ⴱⴻⵍⵍⵉ ⵉⵊⵔⴰ ⴷⵉ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⴻⴳⴳ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⴻⵛ.’” ");
INSERT INTO rift_vpl VALUES ("LK4_24","072_4_24","LUK","4","24","24","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵏⴰⴱⵉ ⴷ ⴰⵎⴻⵇⴱⵓⵍ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK4_25","072_4_25","LUK","4","25","25","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵜⵓⵖⴰ ⴷⵉⵏ ⵜⵉⵊⵊⴰⵍ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵉⵍⵉⵢⴰ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ ⵓⵊⴻⵏⵏⴰ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵍⴰⵥ ⵉⵎⵖⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK4_26","072_4_26","LUK","4","26","26","ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵉⵍⵉⵢⴰ ⵓⵍⴰ ⵖⴰⵔ ⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⵎⵖⵉⵔ ⵖⴰⵔ ⵚⴰⵔⴼⴰⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵚⴰⵢⴷⵓⵏ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ. ");
INSERT INTO rift_vpl VALUES ("LK4_27","072_4_27","LUK","4","27","27","ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⵉⵙⵔⴰⵉⵍ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴰⴱⵉ ⵉⵍⵉⵛⴰⵄ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⴷⵉⴳ ⵎⵖⵉⵔ ⵏⴰⵄⵎⴰⵏ ⵣⵉ ⴰⵔⴰⵎ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK4_28","072_4_28","LUK","4","28","28","ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ, ⵙ ⵜⴻⴼⵇⴻⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("LK4_29","072_4_29","LUK","4","29","29","ⴽⴽⴰⵔⴻⵏ, ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵜⵇⵉⵛⵛⴻⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵜⴻⴱⵏⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴹⴰⵔⴻⵏ ⵣⵉ ⵊⵊⴰⵔⴼ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK4_30","072_4_30","LUK","4","30","30","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵓⵇ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("LK4_31","072_4_31","LUK","4","31","31","ⵉⵀⵡⴰ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("LK4_32","072_4_32","LUK","4","32","32","ⵜⴱⴻⵀⵜⴻⵏ ⵙ ⵓⵙⴻⵍⵎⴻⴷ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜ ⵙ ⵚⵚⵓⵍⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("LK4_33","072_4_33","LUK","4","33","33","ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⴰⵢⴻⵙ ⴱⵓⵃⴱⴻⵍ ⵏ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ ⴰⵎⴻⵏⴳⵓⵙ. ⵏⴻⵜⵜⴰ ⵉⵙⵖⵓⵢⵢⵓ ⵙ ⵊⵊⴻⵀⴷ ⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("LK4_34","072_4_34","LUK","4","34","34","ⵉⵏⵏⴰ: “ⵜⴻⵡⵡⴻⵊ ⵅⴰⴼⵉ! ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⴰⴽⵉⴷⴻⴽ, ⴰ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ? ⵎⴰ ⵜⵓⵙⵉⴷ-ⴷⴷ ⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜᵉⵜⴻⵃⵃⵉⴷ? ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK4_35","072_4_35","LUK","4","35","35","ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙⵇⴰⵔ, ⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ!” ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⵛⵛⵉⵟⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ, ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵙ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LK4_36","072_4_36","LUK","4","36","36","ⵢⴰⵔⵙⴰ ⵓⵜⴻⴱⵀⴻⵜ ⵅ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⴱⴷⴰⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵏⴰ ⴰⵡⴰⵍ-ⴰ? ⴰⵇⴰ ⵙ ⵚⵚⵓⵍⵟⴰ ⴷ ⵊⵊⴻⵀⴷ ⵉⵜⵜⴰⵎⴰⵔ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ, ⵓⵛⴰ ⴼⴼⵖⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK4_37","072_4_37","LUK","4","37","37","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵅⴰⵙ ⵍⴻⵅⴱⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK4_38","072_4_38","LUK","4","38","38","ⵍⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵉⵎⵄⵓⵏ. ⵜⵓⵖⴰ ⵜⴰⴹⴻⴽⴽⵯⴰⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵎⴻⵙⵙⵉ ⴰⵟⵟⴰⵙ ⵓ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK4_39","072_4_39","LUK","4","39","39","ⵉⵖⵏⴻⵙ ⵅⴰⵙ ⵓⵛⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵜⵉⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵜⴻⵊⵊⴰ ⵅⴰⵙ ⵜⵎⴻⵙⵙⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⴽⴽⴰⵔ, ⵜⴻⴷⵡⴻⵍ ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK4_40","072_4_40","LUK","4","40","40","ⵍⴰⵎⵉ ⵜⴻⵖⵍⵉ ⵜⴼⵓⵛⵜ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵀⵍⴰⵛ ⵉ ⴷⵉ ⵉⴵⴰ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵀⵍⴰⵛⴰⵜ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK4_41","072_4_41","LUK","4","41","41","ⵜⵓⵖⴰ ⵛⵛⵡⴰⵟⴻⵏ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵉⴷⵙⴻⵏ, ⵜⵓⵖⴰ ⵙⵖⵓⵢⵢⵓⵏ, ⵇⵇⴰⵔⴻⵏ: “ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ!” ⵎⴰⵛⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵉⵊⵊⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("LK4_42","072_4_42","LUK","4","42","42","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴷ ⴰⵣⵉⵍ, ⵉⴼⴼⴻⵖ-ⴷⴷ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰⵏ, ⵜⵓⵖⴰ ⵍⵖⴰⵛⵉ ⵢⴰⵔⴻⵣⵣⵓ ⵅⴰⵙ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵎⴻⵏⵏⵄⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵉⵜⵜⵔⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("LK4_43","072_4_43","LUK","4","43","43","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵄⴰⵡⴻⴷ ⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵖⵏⵉ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵎⵉ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("LK4_44","072_4_44","LUK","4","44","44","ⵓⵛⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LK5_1","072_5_1","LUK","5","1","1","ⴰⵍⴰⵎⵉ ⵅⴰⵙ ⵉⵎⵓⵏ ⵍⵖⴰⵛⵉ ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴻⴷⴷ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵊⵉⵏⵏⵉⵙⴰⵔⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("LK5_2","072_5_2","LUK","5","2","2","ⵉⵥⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵔⵔⵓⴱⴰ ⴱⴻⴷⴷⴻⵏⵜ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵉⵏⴻⵢⵎⴰⵔⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ, ⵜⵓⵖⴰ ⵙⵙⵉⵔⴷⴻⵏ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK5_3","072_5_3","LUK","5","3","3","ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ. ⵉⵏⵢⴰ ⵢⴰⵙⵓⵄ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⴰⴷ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵛⵡⴰⵢⵜ ⵅ ⵜⵎⴰ ⵏ ⵍⴱⴰⵍ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ. ⵅⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⵍⵖⴰⵛⵉ ⵣⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("LK5_4","072_5_4","LUK","5","4","4","ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵛⵉⵎⵄⵓⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⵍⴰⴵⴰⵖ, ⵏⴹⴰⵔⴻⵎ ⵜⵉⵔⴰⵛⵛⵉⵡⵉⵏ ⵏⵡⴻⵎ ⵉ ⵜⵏⴻⵢⵎⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK5_5","072_5_5","LUK","5","5","5","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⴰⵇⴰ ⵏⵓⵃⴻⵍ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ, ⵡⴰⵔ ⵏⴻⵢⵎⴰⵔ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵅ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵜⵔⴰⵛⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK5_6","072_5_6","LUK","5","6","6","ⵓⵎⵉ ⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵟⵟⴼⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴰⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵔⴰⵛⵛⵉⵡⵉⵏ ⵏⵙⴻⵏ ⵜⵜⵛⴰⵔⵔⴰⴳⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK5_7","072_5_7","LUK","5","7","7","ⴰⵇⴰ ⵛⵉⵢⵢⴰⵔⴻⵏ ⵖⴰⵔ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵙⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⵄⴰⵡⵏⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ, ⵓⵛⴰ ⵛⵛⵓⵔⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵖⴰⵔⵔⵓⴱⴰ ⴰⵍⴰⵎⵉ ⵄⵍⴰⵢⴻⵏ ⴰⴷ ⵖⴰⵔⵇⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK5_8","072_5_8","LUK","5","8","8","ⴰⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ, ⴰⴳⴳⵯⴻⵊ ⵅⴰⴼⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⴻⴷⵏⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("LK5_9","072_5_9","LUK","5","9","9","ⵉⵜⴻⴱⵀⴻⵜ ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ ⵅ ⵜⵏⴻⵢⵎⴰⵔⵜ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵉ ⵟⵟⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK5_10","072_5_10","LUK","5","10","10","ⵓⵍⴰ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵜⴰⵔⵡⴰ ⵏ ⵣⴰⴱⴷⵉ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵛⵔⵉⵛⴻⵏ ⵏ ⵛⵉⵎⵄⵓⵏ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⵉ ⵛⵉⵎⵄⵓⵏ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴷ ⵜⴰⴼⴻⴷ ⵜⵢⴻⵎⵎⴰⵔⴻⴷ ⵉⵡⴷⴰⵏ ⵉ ⵓⵙⴻⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK5_11","072_5_11","LUK","5","11","11","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵜⵉⵖⴰⵔⵔⵓⴱⴰ ⵖⴰⵔ ⵍⴱⴰⵔⵔ, ⵊⵊⵉⵏ ⴽⵓⵍⵛⵉ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK5_12","072_5_12","LUK","5","12","12","ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⵉ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵍⵇⴻⴼ ⵉ-ⵜ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⵚ. ⵓⵎⵉ ⵉⵥⵔⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵙⵓⵄ, ⵉⵡⴹⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵣⴰⵡⴻⴳ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵣⴷⴻⴳⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("LK5_13","072_5_13","LUK","5","13","13","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵢⴰⵙⵓⵄ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ, ⵉⵃⴰⴷⴰ ⵜ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵅⵙⴻⵖ, ⵉⵍⵉ ⵜⵉⵣⴷⵉⴳⴻⴷ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵅⴰⵙ ⵍⴱⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("LK5_14","072_5_14","LUK","5","14","14","ⵢⵓⵎⵓⵔ ⵉ-ⵜ: “ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔ ⵉ ⵃⴻⴷ, ⵎⴰⵛⴰ ⵔⵓⵃ, ⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⵓⴽⴻⵀⵀⴰⵏ, ⴻⵡⵛ ⵜⴰⵡⵀⵉⴱⵜ ⵅ ⵓⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵛ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵎⵓⵔ ⵎⵓⵙⴰ, ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK5_15","072_5_15","LUK","5","15","15","ⵛⵛⴻⵏⵄⴻⵜ ⵏⵏⴻⵙ ⵜⵓⵢⵓⵔ ⵎⴰⵏⵉ ⵎⴰ ⴽⵜⴰⵔ ⵄⴰⴷ ⵓⵛⴰ ⵉⵏⵏⴻⵢⵔⵓ ⵍⵖⴰⵛⵉ ⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ ⵣⵉ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK5_16","072_5_16","LUK","5","16","16","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵉⵜⵜⵥⴰⴵⴰ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK5_17","072_5_17","LUK","5","17","17","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⵎ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵍⵎⴰⴷ, ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⴷⵛⵓⵔⴰⵜ ⵏ ⵍⵊⴰⵍⵉⵍ ⴷ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵓ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵊⵊⴻⵀⴷ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⴳⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("LK5_18","072_5_18","LUK","5","18","18","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵏⴻⵄⴹⴰⴱ ⵅ ⵜⴰⵙⵙⵓⵜ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵙⴰⵔⵙⴻⵏ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK5_19","072_5_19","LUK","5","19","19","ⵓⵎⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⴰⵏⵉⵙ ⵜ ⵉ ⵖⴰ ⵙⵙⵉⴷⴼⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵛⵉ, ⴳⴻⵄⵄⴷⴻⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵓⵛⴰ ⵙⴻⵢⵢⴱⴻⵏ ⵜ ⵣⴻⴳ ⵓⵇⴰⵔⵎⵓⴷ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ ⴰⴽ-ⴷ ⵜⴰⵙⵙⵓⵜ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵍⵡⴻⵙⵟ, ⵣⵣⴰⵜ ⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK5_20","072_5_20","LUK","5","20","20","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵓⵏⴻⵄⴹⴰⴱ ⵏⵏⵉ: “ⴰ ⴱⵏⴰⴷⴻⵎ, ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK5_21","072_5_21","LUK","5","21","21","ⴱⴷⴰⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰ, ⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⴰⵎⵎⵓ. ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ ⵎⵖⵉⵔ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵃⵃⴷⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("LK5_22","072_5_22","LUK","5","22","22","ⵎⴰⵛⴰ ⵢⴰⵔⴳⴻⴱ ⵢⴰⵙⵓⵄ ⵅ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵜᵉⵜⵜⵅⴰⵔⵔⴰⵚⴻⵎ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("LK5_23","072_5_23","LUK","5","23","23","ⵎⵉⵏ ⵉⵀⴻⵡⵏⴻⵏ ⴰⴷ ⵉⵏⵉⵖ: ‘ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ!’ ⵏⵉⵖ ⴰⴷ ⵉⵏⵉⵖ: ‘ⴽⴽⴰⵔ, ⵓⵢⵓⵔ’? ");
INSERT INTO rift_vpl VALUES ("LK5_24","072_5_24","LUK","5","24","24","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ - ⵉⵏⵏⴰ ⵉ ⵓⵏⴻⵄⴹⴰⴱ - ⵉ ⵛⴻⴽ ⵓⵎⵉ ⵖⴰ ⵉⵏⵉⵖ, ⴽⴽⴰⵔ, ⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ ⵓⵛⴰ ⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK5_25","072_5_25","LUK","5","25","25","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵉⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK5_26","072_5_26","LUK","5","26","26","ⴰⵜⴻⴱⵀⴻⵜ ⵉⵀⵡⴰ-ⴷⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵓⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵏⴻⵥⵔⴰ ⵍⴻⵄⵊⴰⵢⴻⴱ!” ");
INSERT INTO rift_vpl VALUES ("LK5_27","072_5_27","LUK","5","27","27","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ, ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⴱⵓ-ⴹⴹⴰⵔⵉⴱⴰ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵍⴰⵡⵉ, ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⴹⴹⴰⵔⵉⴱⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("LK5_28","072_5_28","LUK","5","28","28","ⵉⵊⵊⴰ ⴽⵓⵍⵛⵉ, ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("LK5_29","072_5_29","LUK","5","29","29","ⵉⵙⵙⵏⴻⵡⵊⵉ ⴰⵙ ⵍⴰⵡⵉ ⵉⵊⵊ ⵏ ⵓⵙⵏⴻⵡⵊⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK5_30","072_5_30","LUK","5","30","30","ⵎⴰⵛⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵛⴻⵜⵛⴰⵏ, ⵏⵏⴰⵏ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ, ⵜⴻⵙⵙⴻⵙⵙⴻⵎ ⴰⴽ-ⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ?” ");
INSERT INTO rift_vpl VALUES ("LK5_31","072_5_31","LUK","5","31","31","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⵏⵉ ⵉⵚⴻⵃⵃⴻⵏ ⵡⴰⵔ ⵃⴷⵉⵊⴻⵏ ⵛⴰ ⴰⴹⴱⵉⴱ, ⵎⴰⵛⴰ ⵉⵎⴻⵀⵍⴰⵛ ⵡⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("LK5_32","072_5_32","LUK","5","32","32","ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⴰⴷ ⵍⴰⵖⵉⵖ ⵅ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⵅ ⵉⵎⴻⴷⵏⴰⴱ ⵖⴰⵔ ⵜⵜⵓⴱⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK5_33","072_5_33","LUK","5","33","33","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⵥⵓⵎⵎⴰⵏ ⵓ ⵜⵜⵥⴰⴵⴰⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵟⵟⴰⵙ, ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵏⵏⴻⵛ ⵜⵜᵉⵜⵜⴻⵏ, ⵙⴻⵙⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK5_34","072_5_34","LUK","5","34","34","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⴰⵢⵜ ⵏ ⵓⵎⵓⵍⴰⵢ ⴰⴷ ⵥⵓⵎⵎⴻⵏ ⵎⴰⵍⴰ ⴰⵎⵓⵍⴰⵢ ⴰⵇⴰ-ⵜ ⵄⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("LK5_35","072_5_35","LUK","5","35","35","ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⴰⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵅⵎⵉ ⵅⴰⵙⴻⵏ ⵖⴰ ⵉⵜⵜⵡⴰⵎⵎⴻⴽⵙⵉ ⵓⵎⵓⵍⴰⵢ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵥⵓⵎⵎⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK5_36","072_5_36","LUK","5","36","36","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ: “ⵡⴰⵔ ⴷⵉⵏ ⵃⴻⴷ ⵉⵛⴰⵔⵔⴻⴳ ⵜⴰⵏⴻⵇⵇⵉⵍⵜ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏ ⵊⴷⵉⴷ, ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⵜ ⵅ ⵡⴰⵔⵔⵓⴹ ⴰⴱⵓⵍⴰⵢ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⵔⵉ ⵜⵏⴻⵇⵇⵉⵍⵜ ⵏ ⵊⴷⵉⴷ ⴰⴷ ⵜⵛⴰⵔⵔⴻⴳ ⴰⴱⵓⵍⴰⵢ, ⵎⵉⵏⵣⵉ ⵜⴰⵏⴻⵇⵇⵉⵍⵜ ⵏ ⵊⴷⵉⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵍⵉⵇⵉ ⴰⴱⵓⵍⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("LK5_37","072_5_37","LUK","5","37","37","ⵓⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵃⴻⴷ ⵉⵜⵜⴻⴳⴳ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵜⵉⵇⴷⵉⵎⵉⵏ ⵏ ⵢⵉⵍⴻⵎ, ⵃⵉⵎⴰ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⵡⴰⵔ ⵉⵜⵜⵛⴰⵔⵔⵉⴳ ⵛⴰ ⵜⵉⵅⵓⵏⵛⴰⵢ ⵓⵛⴰ ⴰⴷ ⵉⵣⴻⴵⴻⵄ ⴱⵉⵏⵓ, ⴰⴷ ⴹⴻⵢⵢⵄⴻⵏⵜ ⵜⵅⵓⵏⵛⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("LK5_38","072_5_38","LUK","5","38","38","ⵎⴰⵛⴰ ⵜⵜⴻⴳⴳⴻⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵜⵅⵓⵏⵛⴰⵢ ⵏ ⵊⴷⵉⴷ ⵓⵛⴰ ⴰⴷ ⵅⴻⵎⵎⵍⴻⵏ ⵙ ⵜⵢⵓⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK5_39","072_5_39","LUK","5","39","39","ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⴰⵍⴰ ⵉⵙⵡⴰ ⴰⵇⴷⵉⵎ, ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙ ⵄⴰⴷ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵊⴷⵉⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵇⴷⵉⵎ ⵉⵜⵜⴼⵓⵃ!’” ");
INSERT INTO rift_vpl VALUES ("LK6_1","072_6_1","LUK","6","1","1","ⵉⵎⵙⴰⵔ ⴷⵉ ⵙⵙⴻⴱⵜ ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵢⵓⵢⵓⵔ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⵎⴻⵏⴷⵉ. ⵜⵓⵖⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵍⴻⵇⵇⴹⴻⵏ ⵜⵉⴷⵔⵉⵏ, ⵜⵜⵃⴻⴽⴽⴰⵏ ⵜⴻⵏⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ⵜⵜᵉⵜⵜⴻⵏ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK6_2","072_6_2","LUK","6","2","2","ⵛⴰ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⴻⴵⵍⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵉ ⵙⵙⴻⴱⵜ?” ");
INSERT INTO rift_vpl VALUES ("LK6_3","072_6_3","LUK","6","3","3","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵖⵔⵉⵎ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⴰⵡⵓⴷ ⵓⵎⵉ ⵉⴵⵓⵥ ⵏⴻⵜⵜⴰ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("LK6_4","072_6_4","LUK","6","4","4","ⵎⴰⵎⵎⴻⵛ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵣⴻⵡⴹⴰ ⵏ ⵙⵉⴷⵉ ⵉ ⵡⴰⵔ ⵉⵃⴻⴵⵍⴻⵏ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵡⴰⵀⴰ, ⵓⵛⴰ ⵉⵛⵛⴰ ⵣⵣⴰⵢⴻⵙ ⵓ ⵉⵡⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("LK6_5","072_6_5","LUK","6","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴱⴰⴱ ⵏ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK6_6","072_6_6","LUK","6","6","6","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵖⵏⵉ ⵢⵓⴷⴻⴼ ⵢⴻⵛⵛⵓ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ, ⵉⴱⴷⴰ ⵉⵙⵙⵖⴰⵔⴰ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵇⵓⵛⵛⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("LK6_7","072_6_7","LUK","6","7","7","ⵃⴹⴰⵏ ⵜ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵎⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⴰⴼⴻⵏ ⵛⴰ ⵏ ⵜⵜⵓⵀⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK6_8","072_6_8","LUK","6","8","8","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴳⴻⴱ ⵅ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵇⵓⵛⵛⴻⵃ ⵓⴼⵓⵙ ⵏⵏⴻⵙ: “ⴽⴽⴰⵔ, ⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵣⵉⴷⴰ.” ⵓⵎⵉ ⵉⴽⴽⴰⵔ ⵓ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ ⴷⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LK6_9","072_6_9","LUK","6","9","9","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵇⵙⵉⵖ ⵅ ⵎⵉⵏ ⵉⵃⴻⴵⵍⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵉ ⵙⵙⴻⴱⵜ. ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⵉ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⵅⴰⵔ ⵏⵉⵖ ⵍⵖⴰⵔ, ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵉⵖ ⴰⴷ ⵜ ⵢⴰⵔⴻⴷⴷⴻⴵ?” ");
INSERT INTO rift_vpl VALUES ("LK6_10","072_6_10","LUK","6","10","10","ⵜⵓⵖⴰ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵉⵏⵏⴰ ⴰⵙ ⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ: “ⵙⵡⵉⵥⵥⴻⴹ ⴰⴼⵓⵙ ⵏⵏⴻⵛ!” ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵏⴻⵜⵜⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵚⴻⵃⵃ ⴰⵎ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK6_11","072_6_11","LUK","6","11","11","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵣⵣⵄⴰⴼ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵅ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ ⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK6_12","072_6_12","LUK","6","12","12","ⵉⵎⵙⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵇⴰ ⵉⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ ⵓⵛⴰ ⵉⵙⵙⴻⵄⴷⵓ ⴷⵉⵏ ⴵⵉⵍⴻⵜ ⵜⴻⴽⵎⴻⵍ, ⵉⵜⵜⵥⴰⴵⴰ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK6_13","072_6_13","LUK","6","13","13","ⵓⵎⵉ ⵜⵓⵖⴰ ⴷ ⴰⵣⵉⵍ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵅⴹⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴻⵏⵄⴰⵛ, ⵉⵙⴻⵎⵎⴰ ⵜⴻⵏ ⵔⵔⵓⵙⵓⵍ.    ");
INSERT INTO rift_vpl VALUES ("LK6_14","072_6_14","LUK","6","14","14","ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⵏⵏⴰⵏ ⴱⵓⵟⵔⵓⵙ, ‘ⴰⵥⵔⵓ’, ⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ ⵓⵎⴰⵙ, ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ ⴷ ⴱⴰⵔ-ⵜⵓⵍⵓⵎⴰⵡⵓⵙ ");
INSERT INTO rift_vpl VALUES ("LK6_15","072_6_15","LUK","6","15","15","ⴷ ⵎⴰⵜⵜⴰ ⴷ ⵜⵓⵎⴰ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵎⵎⵉⵙ ⵏ ⵃⴰⵍⴼⴰ, ⴷ ⵛⵉⵎⵄⵓⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ‘ⴰⵎⵄⴻⵙⵙⴰⴱ’, ");
INSERT INTO rift_vpl VALUES ("LK6_16","072_6_16","LUK","6","16","16","ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴷ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵖⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK6_17","072_6_17","LUK","6","17","17","ⵉⵀⵡⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⴷⵉ ⵍⴻⵡⴹⴰ. ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵡⴷⴰⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵣⵉ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_18","072_6_18","LUK","6","18","18","ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ ⵓ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ ⵣⵉ ⵍⴻⵀⵍⴰⵛ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴻⵣⵣⴰⵏ ⵣⵉ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ, ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_19","072_6_19","LUK","6","19","19","ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⴰⴷ ⵜ ⵉⵃⴰⴷⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵊⵊⴻⵀⴷ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵏⴼⴰⵏ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LK6_20","072_6_20","LUK","6","20","20","ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵙⵙⴻⵄⴷ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⴻⵣⵍⴰⴹ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("LK6_21","072_6_21","LUK","6","21","21","ⵙⵙⴻⵄⴷ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⴵⵓⵥⴻⵏ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵊⵉⵡⵏⴻⵎ. ⵙⵙⴻⵄⴷ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵜⵜⵔⵓⵏ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴹⴻⵃⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK6_22","072_6_22","LUK","6","22","22","ⵙⵙⴻⵄⴷ ⵏⵡⴻⵎ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵛⴰⵔⵔⵀⴻⵏ ⵉⵡⴷⴰⵏ, ⵜⵜⴰⵥⵥⵍⴻⵏ ⵅⴰⵡⴻⵎ, ⵜⵜⴻⴽⴽⵡⴰⵔⴻⵏ ⴽⴻⵏⵏⵉⵡ, ⵓⵛⴰ ⵙⵙⴼⴻⵟⵟⴰⵃⴻⵏ ⵣⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵡⴻⵎ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK6_23","072_6_23","LUK","6","23","23","ⴼⴰⵔⵃⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵏⴻⴳⵣⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⵉⵏⵣⵉ, ⴰⵇⴰ ⵍⴰⵊⴰⵔ ⵏⵡⴻⵎ ⵉⵎⵖⴰⵔ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_24","072_6_24","LUK","6","24","24","ⵎⴰⵛⴰ ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜᵉⵟⵟⴼⴻⵎ ⴰⴼⴻⵡⵡⴻⵊ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK6_25","072_6_25","LUK","6","25","25","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵊⵊⵉⵡⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⴵⴰⵥⴻⵎ. ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴹⴻⵃⵃⵛⴻⵏ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜⵛⴻⴹⵏⴻⵎ, ⴰⴷ ⵜⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("LK6_26","072_6_26","LUK","6","26","26","ⵓⵛⵜ ⵅⴰⵡⴻⵎ ⵓⵎⵉ ⵉⵡⴷⴰⵏ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵏ ⵎⵍⵉⵃ, ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK6_27","072_6_27","LUK","6","27","27","“ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ: ⵅⵙⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ⵜⵀⵉⵍⵍⴰⵎ ⴷⴻⴳ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵛⴰⵔⵔⵀⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK6_28","072_6_28","LUK","6","28","28","ⴱⴰⵔⴽⴻⵎ ⵉ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴻⵄⵄⵍⴻⵏ ⵓ ⵥⴰⴵⴻⵎ ⵅ ⵢⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_29","072_6_29","LUK","6","29","29","ⵉ ⵡⴻⵏⵏⵉ ⵛⴻⴽ ⵉⵡⵜⵉⵏ ⵖⴰⵔ ⵓⵎⴻⴳⴳⵉⵣ, ⴰⵔⵔ ⴰⵙ-ⴷⴷ ⵙ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⴽⴽⵙⴻⵏ ⴰⵊⴻⴵⴰⴱ, ⵡⴰⵔ ⵜ ⵜⵜᵉⵟⵟⴻⴼ ⴰⴷ ⵉⴽⵙⵉ ⵓⵍⴰ ⴷ ⵜⵛⴰⵎⵉⵔ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LK6_30","072_6_30","LUK","6","30","30","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵖⴰ ⵉⵜⵜⴰⵔⴻⵏ, ⴻⵡⵛ ⴰⵙ ⵜ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴽⵙⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜ ⵜⵜᵉⵜⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK6_31","072_6_31","LUK","6","31","31","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵏ ⵉⵡⴷⴰⵏ, ⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴰⵢⵙⴻⵏ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK6_32","072_6_32","LUK","6","32","32","ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵎⴰⵏ ⵜⵛⵓⵏⵉ ⵉ ⵖⴰⵔⵡⴻⵎ. ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⵜⵜⴻⵅⵙⴻⵏ ⵉⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⵜⵜⴻⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_33","072_6_33","LUK","6","33","33","ⵎⴰⵍⴰ ⵜⴻⴳⴳⴻⵎ ⵍⵅⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵅⴰⵔ, ⵎⴰⵏ ⵜⵛⵓⵏⵉ ⵉ ⵖⴰⵔⵡⴻⵎ. ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⵜⵜⴻⴳⴳⴻⵏ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK6_34","072_6_34","LUK","6","34","34","ⵓ ⵎⴰⵍⴰ ⵜⴰⵔⴹⵍⴻⵎ ⵉ ⵉⵡⴷⴰⵏ ⵉ ⵣⵉ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵔⴻⵏ, ⵎⴰⵏ ⵜⵛⵓⵏⵉ ⵉ ⵖⴰⵔⵡⴻⵎ? ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⴰⵔⴹⵍⴻⵏ ⵉ ⵉⵎⴻⴷⵏⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⴷⵡⴻⵍ ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK6_35","072_6_35","LUK","6","35","35","ⵎⴰⵛⴰ ⵅⵙⴻⵎ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ, ⴳⴳⴻⵎ ⴷ ⴰⵙⴻⵏ ⵜⵛⵓⵏⵉ, ⴰⵔⴹⵍⴻⵎ, ⵡⴰⵔ ⵜⵇⴻⵟⵟⵄⴻⵎ ⵍⴰⵢⴰⵙ ⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⴰⵊⴰⵔ ⵏⵡⴻⵎ ⵉⵎⵖⴰⵔ, ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵓⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵜⵜⴻⴳⴳ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴰⴽ-ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵜ ⵉⵛⴻⴽⴽⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_36","072_6_36","LUK","6","36","36","ⴰⵔⴻⵃⵎⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴱⴰⴱⴰⵜⵡⴻⵎ ⴷ ⴰⵔⵃⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK6_37","072_6_37","LUK","6","37","37","ⵡⴰⵔ ⵃⴻⴽⴽⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⴰⵎⴻⵎ. ⵡⴰⵔ ⵜⵜⵃⴰⵙⴰⴱⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵃⴰⵙⴱⴻⵎ. ⵖⴼⴰⵔⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK6_38","072_6_38","LUK","6","38","38","ⵡⵛⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛ, ⴰⴷ ⵏⴹⴰⵔⴻⵏ ⵉⵊⵊ ⵏ ⵍⵎⵓⴷ ⵉⵛⵏⴰ, ⵉⴷⴻⵇⵇⴻⵙ, ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵀⴻⵣⵣ, ⵉⴼⴻⵢⵢⴻⴹ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵡⴻⵎ. ⵎⵉⵏⵣⵉ ⵙ ⵍⵎⵓⴷ ⵉ ⵣⵉ ⵖⴰ ⵜⵡⴻⵣⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⵡⴻⵣⵏⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("LK6_39","072_6_39","LUK","6","39","39","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ: “ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵓⴷⴰⵔⵖⴰⵍ ⴰⴷ ⵉⵏⴷⴻⵀ ⴰⴷⴰⵔⵖⴰⵍ? ⵎⴰ ⵡⴰⵔ ⵡⴻⵟⵟⵉⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ? ");
INSERT INTO rift_vpl VALUES ("LK6_40","072_6_40","LUK","6","40","40","ⴰⵎⴻⵃⴹⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵃⵙⴻⵏ ⵣⴻⴳ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴽⵓⵍ ⴰⵎⴻⵃⴹⴰⵔ ⵏⵉⵛⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK6_41","072_6_41","LUK","6","41","41","ⵎⴰⵢⴻⵎⵎⵉ ⵜⵅⴻⵣⵣⴰⵔⴻⴷ ⵖⴰⵔ ⵓⵅⴻⵛⵛⵉⵡ, ⵜⴻⵏⵏⵉ ⴷⵉ ⵜⵉⵟⵟ ⵏ ⵓⵎⴰⵛ, ⵎⴰⵛⴰ ⵜⴰⵃⵏⴰⵛⵜ, ⵜⴻⵏⵏⵉ ⴷⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ, ⵡⴰⵔ ⴽⵉⵙ ⵜⴻⵍⵀⵉⴷ? ");
INSERT INTO rift_vpl VALUES ("LK6_42","072_6_42","LUK","6","42","42","ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵉ ⵓⵎⴰⵛ: ‘ⵓⵎⴰ, ⴻⵊⵊ ⴰⵢⵉ ⴰⴷ ⴰⵛ ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ ⴰⵅⴻⵛⵛⵉⵡ ⵉ ⴷⴰⵢⴻⴽ ⴷⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ!’, ⵓ ⵅⵣⴰⵔ, ⵛⴻⴽ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵍⵉⴷ ⵛⴰ ⵜⴰⵃⵏⴰⵛⵜ ⵉ ⵖⴰⵔⴻⴽ ⴷⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ. ⵛⴻⴽ, ⴰ ⴰⵎⵏⴰⴼⴻⵇ, ⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵜⴰⵃⵏⴰⵛⵜ ⵏⵏⵉ ⵖⴰⵔⴻⴽ ⴷⵉ ⵜⵉⵟⵟ ⵏⵏⴻⵛ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⵍⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵓⴼⴼⵖⴻⴷ ⴰⵅⴻⵛⵛⵉⵡ ⵣⵉ ⵜⵉⵟⵟ ⵏ ⵓⵎⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK6_43","072_6_43","LUK","6","43","43","“ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵉ ⴷⴷ-ⵉⵙⵙⵖⴻⵎⵎⴰⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵅⵙⴰⵔ, ⵏⵉⵖ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵉⵅⵙⴰⵔⴻⵏ ⵉ ⴷⴷ-ⵉⵙⵙⵖⴻⵎⵎⴰⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ.    ");
INSERT INTO rift_vpl VALUES ("LK6_44","072_6_44","LUK","6","44","44","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵙ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵢⵔⵓⵏ ⵣⴻⴳ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵍⴱⴰⵛⵓⵔ, ⵓ ⵡⴰⵔ ⵍⴻⵇⵇⴹⴻⵏ ⴰⴹⵉⵍ ⵣⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK6_45","072_6_45","LUK","6","45","45","ⴱⵏⴰⴷⴻⵎ ⴰⵚⴻⴱⵃⴰⵏ ⵣⵉ ⵍⴽⴻⵏⵣ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵓⵛⴰ ⴱⵏⴰⴷⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵍⴽⴻⵏⵣ ⵏ ⵡⵓⵍ ⵏⵏⴻⵙ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ. ⵙ ⵎⵉⵏ ⵣⵉ ⵉⵛⵛⵓⵔ ⵡⵓⵍ, ⵣⵣⴰⵢⴻⵙ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK6_46","072_6_46","LUK","6","46","46","“ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵍⴰⵖⴰⵎ: ‘ⴰ ⵙⵉⴷⵉ, ⴰ ⵙⵉⴷⵉ!’ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵛⴰ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("LK6_47","072_6_47","LUK","6","47","47","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵉⵏ ⴷⵉ ⵢⴰⵔⵡⴻⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LK6_48","072_6_48","LUK","6","48","48","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵉⴱⵏⴰⵏ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ. ⵏⴻⵜⵜⴰ ⵉⵖⵣⴰ, ⵉⵃⴼⴰⵔ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ ⵅ ⵙⵙⴻⴵⴰⵃ. ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵙⵙⴻⵃⵍⴻⵜ, ⵜⵇⴻⴱⴱⴻⴹ ⵍⵃⴻⵎⵍⴻⵜ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵜⴻⵙⵙⴻⵏⵀⴻⵣⵣ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⵙⴰⵙ ⵏⵏⴻⵙ ⵅ ⵙⵙⴻⴵⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LK6_49","072_6_49","LUK","6","49","49","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ, ⵢⴰⵔⵡⴻⵙ ⴷⵉ ⴱⵏⴰⴷⴻⵎ ⵉ ⵉⴱⵏⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴱⵍⴰ ⴷⵙⴰⵙ. ⵓⵎⵉ ⵜⵜ-ⵉ-ⴷⴷ-ⵜⵇⴻⴱⴱⴻⴹ ⵍⵃⴻⵎⵍⴻⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ. ⵜⵓⵖⴰ ⴰⴼⴰⵔⵜⴻⴽ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK7_1","072_7_1","LUK","7","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⴷ ⴰⵙ ⵙⵍⴰⵏ ⵉⵡⴷⴰⵏ, ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("LK7_2","072_7_2","LUK","7","2","2","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵄⵉⵣⵣ ⴰⵟⵟⴰⵙ, ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵇⵇⵉⵎ ⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK7_3","072_7_3","LUK","7","3","3","ⵓⵎⵉ ⵉⵙⵍⴰ ⵅ ⵢⴰⵙⵓⵄ, ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⴻⵙ ⵛⴰ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⵜⵜⴰⵔ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK7_4","072_7_4","LUK","7","4","4","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵃⴻⵛⵛⵎⴻⵏ ⵜ ⴰⵟⵟⴰⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⵙⴷⴰⵀⴻⴵ ⴰⴷ ⴰⵙ ⵜⴻⴳⴳⴻⴷ ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("LK7_5","072_7_5","LUK","7","5","5","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵓ ⵉⴱⵏⴰ ⴰⵏⴻⵖ ⵜⴰⵎⵣⵉⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK7_6","072_7_6","LUK","7","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵔⵓⵃ ⵢⴰⵙⵓⵄ ⴰⴽⵉⴷⵙⴻⵏ. ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⴳⴳⵯⵉⵊ ⵄⴰⴷ ⵅ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵙⵙⴻⴽⴽ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵛⴰ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵖⴰⵔⴻⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵙⵙⵉⵃⵉⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴷⵉⵀⴻⴵⴻⵖ ⴰⴷ ⵜⴰⴷⴼⴻⴷ ⵙⴰⴷⵓ ⵜⴰⵣⴻⵇⵇⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK7_7","072_7_7","LUK","7","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⵙⴱⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵙⴷⴰⵀⴻⴵⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ, ⵎⴰⵛⴰ ⵉⵏⵉ ⴰⵡⴰⵍ ⵡⴰⵀⴰ ⵓⵛⴰ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK7_8","072_7_8","LUK","7","8","8","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵙⴰⴷⵓ ⵉⴼⴰⵙⵙⴻⵏ ⵉ ⴵⵉⵖ ⵓ ⵖⴰⵔⵉ ⵄⴰⵡⴻⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵓⴼⵓⵙ ⵉⵏⵓ. ⵇⵇⴰⵔⴻⵖ ⵉ ⵡⴰ: ‘ⵔⵓⵃ!’, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵔⴰⵃ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: ‘ⴰⵙ-ⴷⴷ!’, ⵅⴻⵏⵏⵉ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵓⵛⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ: ‘ⴻⴳⴳ ⴰⵢⴰ!’, ⵅⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK7_9","072_7_9","LUK","7","9","9","ⵓⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⴰⵢⴰ, ⵉⵜⵜⴻⴱⵀⴻⵜ ⴷⴰⵢⴻⵙ. ⵉⵏⵏⴻⵇⵍⴻⴱ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵍⵖⴰⵛⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⴹⴻⴼⴼⴰⵔⴻⵏ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⵍ’ⵉⵎⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⵍⵇⴻⴷⴷ ⵏ ⵡⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK7_10","072_7_10","LUK","7","10","10","ⴰⵍⴰⵎⵉ ⵄⴻⵇⴱⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵓⴼⵉⵏ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⴻⵀⵍⵓⵛ ⵉⴳⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("LK7_11","072_7_11","LUK","7","11","11","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵔⵓⵃ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⴰⵢⵉⵏ. ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴽⵉⴷⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_12","072_7_12","LUK","7","12","12","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵅⵣⴰⵔ, ⴽⵙⵉⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ ⵅ ⵍⵎⴻⵃⵎⴻⵍ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵢⴻⵎⵎⴰⵙ. ⵢⴻⵎⵎⴰⵙ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⴰⵊⵊⴰⵍⵜ ⵓ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK7_13","072_7_13","LUK","7","13","13","ⵓⵎⵉ ⵜⵜ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ, ⵜⴻⵣⵣⵉⴵⴻⵣ ⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵜⵜⵔⵓ!” ");
INSERT INTO rift_vpl VALUES ("LK7_14","072_7_14","LUK","7","14","14","ⵅⴻⵏⵏⵉ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ, ⵉⵃⴰⴷⴰ ⵍⵎⴻⵃⵎⴻⵍ, ⵓⵛⴰ ⴱⴻⴷⴷⴻⵏ ⵢⵉⵏⵏⵉ ⵜ ⵢⴰⵔⴱⵓⵏ, ⵉⵏⵏⴰ: “ⴰ ⴰⴱⵍⵉⵖ, ⵉ ⵛⴻⴽ ⵓⵎⵉ ⵖⴰ ⵉⵏⵉⵖ, ⴽⴽⴰⵔ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("LK7_15","072_7_15","LUK","7","15","15","ⵉⵇⵇⵉⵎ ⵓⵎⴻⵜⵜⵉⵏ, ⵉⴱⴷⴰ ⵉⵙⵙⴰⵡⴰⵍ, ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ ⴰⵙ ⵜ-ⵉ-ⴷⴷ ⵉ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK7_16","072_7_16","LUK","7","16","16","ⵜⵓⴷⴻⴼ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⴷⴰⵢⵏⴻⵖ ⵓⵏⴰⴱⵉ ⵉⵎⵖⴰⵔ!”, ⵓⵛⴰ: “ⴰⵇⴰ ⵉⵙⵙⵉⵊⵊ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK7_17","072_7_17","LUK","7","17","17","ⵉⴼⴼⴻⵖ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵅⴰⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_18","072_7_18","LUK","7","18","18","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⵄⴰⵡⴷⴻⵏ ⴰⵙ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK7_19","072_7_19","LUK","7","19","19","ⵉⵍⴰⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉ ⵜⵏⴰⵢⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵉⵇⵇⴰⵔ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ: “ⵎⴰ ⴷ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵏⵉⵖ ⴰⴷ ⵏⵔⴰⵊⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("LK7_20","072_7_20","LUK","7","20","20","ⵓⵎⵉ ⵔⵓⵃⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ ⴰⵙ: “ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵏⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵉⵏⵏⴰ: ‘ⵎⴰ ⴷ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵏⵉⵖ ⴰⴷ ⵏⵔⴰⵊⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ?’” ");
INSERT INTO rift_vpl VALUES ("LK7_21","072_7_21","LUK","7","21","21","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵣⵉ ⵍⴻⵀⵍⴰⵛⴰⵜ ⴷ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵙⴻⵏ ⵓ ⵣⵉ ⵍⴰⵔⵢⴰⵃ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵜⵜⵡⴰⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_22","072_7_22","LUK","7","22","22","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵄⴰⵡⴷⴻⵎ ⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵎⵉⵏ ⵜⴻⵥⵔⵉⵎ ⴷ ⵎⵉⵏ ⵜⴻⵙⵍⵉⵎ. ⴰⵇⴰ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵜⵜⵡⴰⵍⴰⵏ ⵓ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴳⴳⵓⵔⴻⵏ ⵓ ⵢⵉⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴱⴰⵔⵚ ⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵓ ⵉⴷⴻⵀⵛⴰⵔ ⵜⵜⴻⵙⵍⴰⵏ ⵓ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵜⵜⴻⴽⴽⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵜⵜᵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LK7_23","072_7_23","LUK","7","23","23","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵏⴷⵔⵉⴼⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK7_24","072_7_24","LUK","7","24","24","ⵓⵎⵉ ⴼⴼⵖⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⴱⴷⴰ ⵢⴰⵙⵓⵄ ⵉⵇⵇⴰⵔ ⵉ ⵍⵖⴰⵛⵉ ⵅ ⵢⵓⵃⴰⵏⵏⴰ: “ⵎⵉⵏ ⵖⴰⵔ ⵉ ⵖⴰ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⴰⴷ ⵜⵥⴰⵔⴻⵎ? ⵎⴰ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵉⵙⵙⴻⵏⵀⴻⵣⵣⴰ ⵜ ⵓⵙⴻⵎⵎⵉⴹ? ");
INSERT INTO rift_vpl VALUES ("LK7_25","072_7_25","LUK","7","25","25","ⵎⴰⵍⴰ ⵍⵍⴰ, ⵎⵉⵏ ⵖⴰⵔ ⵜⵓⵖⴰ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⴰⴷ ⵜⵥⴰⵔⴻⵎ? ⵎⴰ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵢⴰⵔⴹⴻⴱ? ⵅⵣⴰⵔ ⵉⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⵉⵖⵍⴰⵏ ⵢⴰⵔⴹⴻⴱ ⵓ ⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵓⴼⵓⵀⴰⵔⵜ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⴻⵇⵚⵓⵔ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_26","072_7_26","LUK","7","26","26","ⵎⴰⵛⴰ ⵎⵉⵏ ⵖⴰⵔ ⵜⵓⵖⴰ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⴰⴷ ⵜⵥⴰⵔⴻⵎ? ⵎⴰ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ? ⵡⴰⵀ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴽⵜⴰⵔ ⵣⴻⴳ ⵓⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK7_27","072_7_27","LUK","7","27","27","ⴰⵇⴰ ⴷ ⵡⴰ ⵉ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵔⵉ: ‘ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵛ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵛ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("LK7_28","072_7_28","LUK","7","28","28","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵊⴰⵔ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵏⴰⴱⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ, ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵇⴰⵄ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵖⴰⵔ ⵅⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK7_29","072_7_29","LUK","7","29","29","ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ, ⵓⵍⴰ ⴷ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⵛⴻⵀⴷⴻⵏ ⵉ ⵜⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK7_30","072_7_30","LUK","7","30","30","ⵎⴰⵛⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵓⴳⵉⵏ ⵅ ⵛⵛⵡⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⴳⵉⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_31","072_7_31","LUK","7","31","31","ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ: “ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵛⴻⴱⴱⵀⴻⵖ ⵉⵡⴷⴰⵏ ⵏ ⵊⵊⵉⵍ-ⴰ? ⵡⵉ ⴷⵉ ⵢⴰⵔⵡⴻⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LK7_32","072_7_32","LUK","7","32","32","ⵏⵉⵜⵏⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵙⵙⵓⵇ, ⵜⵜⵍⴰⵖⴰⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛⵉⵏ ⵏⴻⵡⵜⴰ ⴰⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵊⴰ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵛⴹⵉⵃⴻⵎ, ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⵖⴻⵏⵏⴻⵊ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵉ ⵏ ⵡⴻⵛⴹⴰⵏ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵔⵓⵎ ⵛⴰ.’ ");
INSERT INTO rift_vpl VALUES ("LK7_33","072_7_33","LUK","7","33","33","ⵎⵉⵏⵣⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⴰⵖⵔⵓⵎ, ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⴱⵉⵏⵓ ⵓⵛⴰ ⵜⴻⵏⵏⴰⵎ: ‘ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵛⵛⵉⵟⴰⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK7_34","072_7_34","LUK","7","34","34","ⵢⵓⵙⴰ-ⴷⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴻⵜⵜ, ⵉⵙⴻⵙⵙ, ⵜⴻⵏⵏⴰⵎ: ‘ⵅⵣⴰⵔ, ⴱⵏⴰⴷⴻⵎ-ⴰ ⵉⵍⵀⴻⴼ ⵅ ⵎⴰⵛⵛⴰ ⴷ ⴱⵉⵏⵓ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ.’ ");
INSERT INTO rift_vpl VALUES ("LK7_35","072_7_35","LUK","7","35","35","ⵎⴰⵛⴰ ⵜⵉⵖⵉⵜ ⵜᵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK7_36","072_7_36","LUK","7","36","36","ⵉⵄⴰⵔⴹ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵓⴼⴰⵔⵉⵙⵉ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙ ⵉⵛⵛ. ⵢⵓⴷⴻⴼ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⴼⴰⵔⵉⵙⵉ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LK7_37","072_7_37","LUK","7","37","37","ⵜⵓⵖⴰ ⵜⵣⴻⴷⴷⴻⵖ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴰⵎⴻⴷⵏⵓⴱⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ. ⵓⵎⵉ ⵜⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⴼⴰⵔⵉⵙⵉ, ⵜⵓⵙⴰ-ⴷⴷ ⵙ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⴰⵍⴰⴱⴰⵙⵜⴻⵔ ⴷⴰⵢⴻⵙ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("LK7_38","072_7_38","LUK","7","38","38","ⵓⵛⴰ ⵓⵎⵉ ⵜⴱⴻⴷⴷ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏⵏⴻⵙ, ⵜⵔⵓ ⵓⵛⴰ ⵜⴻⴱⴷⴰ ⵜⴻⵙⵙⵓⴼⴼⴰ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⴱⴷⴰ ⵜⴻⵙⵙⴰⵥⴰⵖ ⵉ-ⵜⴻⵏ ⵙ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵜⴻⵙⵙⵓⴷⴻⵎ ⴰⵙ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵜⴻⵎⵙⴻⵃ ⵉ-ⵜⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_39","072_7_39","LUK","7","39","39","ⵓⵎⵉ ⵉⵥⵔⴰ ⵓⴼⴰⵔⵉⵙⵉ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵄⴰⵔⴹⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵡⴰ ⴷ ⴰⵏⴰⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵉⵍⵉ ⴰⵇⴰ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⴰⵏⵉⵜⴰ ⵓ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵏⴻⵜⵜⴰⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⵉ ⵜ ⵉⵃⴰⴷⴰⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵎⴻⴷⵏⵓⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK7_40","072_7_40","LUK","7","40","40","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⵉⵎⵄⵓⵏ, ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴰⴷ ⴰⵛ ⵜⵜ ⵉⵏⵉⵖ.” ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵏⵉ ⵜⵜ, ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("LK7_41","072_7_41","LUK","7","41","41","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵉⵊⵊ ⵏ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵜⵓⵔⵙⴻⵏ ⴰⵙ. ⵉⵊⵊⴻⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵓⵔⵙ ⴰⵙ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⴷⵉⵏⴰⵔ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵅⴻⵎⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_42","072_7_42","LUK","7","42","42","ⴰⵎ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⵙⴻⵏ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⴰⵔⵔⴻⵏ ⴰⵎⴰⵔⵡⴰⵙ, ⵉⵙⴰⵎⵃ ⴰⵙⴻⵏ ⴰⵎⴰⵔⵡⴰⵙ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ. ⵉⵏⵉ ⴰⵢⵉ, ⵡⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵜ ⵖⴰ ⵉⵅⵙⴻⵏ ⴽⵜⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("LK7_43","072_7_43","LUK","7","43","43","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ: “ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵙⴰⵎⵃ ⴽⵜⴰⵔ.” ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵜⵃⴻⴽⵎⴻⴷ ⵙ ⵚⵚⴰⵃ.” ");
INSERT INTO rift_vpl VALUES ("LK7_44","072_7_44","LUK","7","44","44","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ, ⵉⵏⵏⴰ ⵉ ⵛⵉⵎⵄⵓⵏ: “ⵎⴰ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵜⴰⵎⵖⴰⵔⵜ-ⴰ? ⴰⵇⴰ ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ. ⴰⵎⴰⵏ ⵉ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵏ ⵜⴻⵡⵛⵉⴷ. ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵓⴼⴼ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵙⵙⵉⵥⴻⵖ ⵉ-ⵜⴻⵏ ⵙ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK7_45","072_7_45","LUK","7","45","45","ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵓⴷⵎⴻⴷ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ, ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵓⴷⴼⴻⵖ, ⵡⴰⵔ ⵜⴱⴻⴷⴷ ⵣⴻⴳ ⵓⵙⵓⴷⴻⵎ ⵏ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK7_46","072_7_46","LUK","7","46","46","ⵙ ⵣⵣⴻⵛⵜ ⵡⴰⵔ ⵜⵎⴻⵙⵃⴻⴷ ⵛⴰ ⴰⵣⴻⴵⵉⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵎⵙⴻⵃ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK7_47","072_7_47","LUK","7","47","47","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⴰⵇⴰ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⴰⵙ ⴰⵟⵟⴰⵙ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⴻⵅⵙ ⴰⵟⵟⴰⵙ. ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⴷⵔⵓⵙ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⴷⵔⵓⵙ ⵏ ⵜⴰⵢⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK7_48","072_7_48","LUK","7","48","48","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ, ⴰⵇⴰ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK7_49","072_7_49","LUK","7","49","49","ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴱⴷⴰⵏ ⵇⵇⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰⵏⵉⵜⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵖⴼⴰⵔ ⵓⵍⴰ ⵉ ⴷⴷⵏⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("LK7_50","072_7_50","LUK","7","50","50","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ ⵉ ⵜⵎⴻⵟⵟⵓⵜ ⵏⵏⵉ: “ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵎ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵎ ⵜⵓⴷⴰⵔⵜ. ⵔⵓⵃ ⴷⵉ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK8_1","072_8_1","LUK","8","1","1","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵉⵛⵓⵇ ⵢⴰⵙⵓⵄ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ ⴷ ⴷⵛⵓⵔⴰⵜ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK8_2","072_8_2","LUK","8","2","2","ⵓⵍⴰ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴰⵢⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ ⵣⵉ ⵍⴻⵃⵍⴰⵛⴰⵜ ⵓ ⵣⵉ ⵍⴰⵔⵢⴰⵃ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ: ⴰⵇⴰ-ⵜⵜ ⵎⴰⵔⵢⴰⵎ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵜⴻⵏⵏⵉ ⵏ ⵎⴰⵊⴷⴰⵍⴰ’, ⵉ ⵣⵉ ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵖⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵛⵛⵡⴰⵟⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK8_3","072_8_3","LUK","8","3","3","ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵅⵓⵣⴰ, ⴰⵡⴽⵉⵍ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⴷ ⵙⵓⵙⴰⵏⵏⴰ, ⴷ ⵜⵉⵏⵏⴻⵖⵏⵉ ⴰⵟⵟⴰⵙ ⵉ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏⵜ ⵅⴰⵙⴻⵏ ⵙ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_4","072_8_4","LUK","8","4","4","ⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵙⵙⵎⵓⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ, ⵉⵏⵏⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("LK8_5","072_8_5","LUK","8","5","5","“ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵎⵣⴰⵔⵔⴰⵄ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵣⴰⵔⵄ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ. ⴰⵎ ⵉⵣⴰⵔⵔⴻⵄ, ⵜⴻⵡⴹⴰ ⵛⵡⴰⵢⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵄⴼⴻⵙ ⵅⴰⵙ ⵓⵛⴰ ⵏⴻⵇⴱⴻⵏ ⵉ-ⵜⵜ ⵉⵊⴹⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("LK8_6","072_8_6","LUK","8","6","6","ⵜⴻⵡⴹⴰ ⵛⵡⴰⵢⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵥⵔⵓ, ⵓⵎⵉ ⴷⴷ-ⵜⴻⵖⵎⵉ ⴷⴻⵖⵢⴰ, ⵜⵓⵥⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵓⵖⵉ ⵜⵓⴼⴼⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_7","072_8_7","LUK","8","7","7","ⵜⴻⵡⴹⴰ ⵛⵡⴰⵢⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵓⵛⴰ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⵖⴻⵎⵢⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵊⴻⵢⵢⴼⴻⵏ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_8","072_8_8","LUK","8","8","8","ⵜⴻⵡⴹⴰ ⵛⵡⴰⵢⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵢⴰⵔⴻⴹⴱⴻⵏ ⴷ ⵍⴻⵎⵍⵉⵃ, ⵓⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵜⴻⵖⵎⵉ, ⵜⴻⴳⴳⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵎⵢⴰ ⵉⵎⵓⵔⴻⵏ.” ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵍⴰⵖⴰ: “ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("LK8_9","072_8_9","LUK","8","9","9","ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵓⵎⴻⴷⵢⴰ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK8_10","072_8_10","LUK","8","10","10","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵉ ⵉⵎⵎⴻⵡⵛ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵙⵉⵔⵔ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴰⵡⴰⵍ ⵙ ⵉⵎⴻⴷⵢⴰ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵍⴰⵏ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵓⵛⴰ ⵜⵜⴻⵙⵍⴰⵏ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_11","072_8_11","LUK","8","11","11","ⴷ ⵡⴰ ⴷ ⵍⵎⴻⵄⵏⴰ ⵏ ⵓⵎⴻⴷⵢⴰ: ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⴻⵜⵜⴰⵜ ⴷ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK8_12","072_8_12","LUK","8","12","12","ⵉⵏⴰ ⵅ ⵟⵟⴰⵔⴼ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍ, ⵎⴰⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵜⵜⴰⵙ-ⴷⴷ ⵉⴱⵍⵉⵙ, ⵉⵜⵜⴻⴽⴽⴻⵙ ⴰⵡⴰⵍ ⵣⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜⵜⵉⵎⵏⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_13","072_8_13","LUK","8","13","13","ⵉⵏⴰ ⵅ ⵡⴻⵥⵔⵓ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⵏⵉ ⵅⵎⵉ ⵖⴰ ⵙⵍⴻⵏ, ⴰⴷ ⵇⴻⴱⵍⴻⵏ ⴰⵡⴰⵍ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵡⴻⵥⵡⴰⵔ, ⵜⵜⴰⵎⵏⴻⵏ ⵖⴰⵔ ⵅⴻⵏⵏⵉⵜ, ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵓⵊⴰⵔⵔⴻⴱ ⴰⴷ ⵏⵇⴰⵔⴹⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_14","072_8_14","LUK","8","14","14","ⵉⵏⴰ ⵉ ⵉⵡⴹⴰⵏ ⴷⴻⴳ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍ, ⵅⴻⵏⵏⵉ ⵜⵜⵔⴰⵃⴻⵏ, ⵜⵜⴱⵓⵅⵙⵓⵢⴻⵏ ⴷⴻⴳ ⵉⵎⵏⵓⵙⴻⵏ ⴷ ⵡⴰⴳⵍⴰ ⴷ ⵟⵟⴰⵎⵓⵄ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵡⴰⵔ ⵙⵙⴻⵏⴷⴰⵢⴻⵏ ⵛⴰ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_15","072_8_15","LUK","8","15","15","ⵉⵏⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵢⴰⵔⴻⴹⴱⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍ, ⵅⴻⵎⵎⵍⴻⵏ ⵜ ⴷⴻⴳ ⵡⵓⵍ ⵏⵉⵛⴰⵏ, ⵉⵚⴱⴻⵃ, ⵓⵛⴰ ⵙⵙⴻⵏⴷⴰⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ ⵙ ⵚⵚⴱⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LK8_16","072_8_16","LUK","8","16","16","“ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵔⵓⵖⵉ ⵍⴻⴼⵏⴰⵔ ⵓⵛⴰ ⵉⵇⴻⴱⴱⴰⵔ ⵅⴰⵙ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵇⴻⴷⴷⵓⵃ ⵏⵉⵖ ⵉⵙⵙⵔⵓⵙⴰ ⵜ ⵙⴰⴷⵓ ⵇⴰⵎⴰ, ⵎⴰⵛⴰ ⵙ ⵍⴻⵎⵇⵍⵓⴱ ⵉⵙⵙⵔⵓⵙⴰ ⵜ ⵅ ⵍⵎⴻⵔⴼⴻⵄ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⴷⴼⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵜⴰⴼⴰⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK8_17","072_8_17","LUK","8","17","17","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⴷⵍⵉⵏ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵉⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵡⵉⵙⵙⵉⵏ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵉⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK8_18","072_8_18","LUK","8","18","18","ⵃⴹⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⴻⵙⵍⴰⵎ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴷ ⴰⵙ ⵉⵎⵎⴰⵔⵏⵉ, ⵓ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ, ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⵖⴰⵔⴻⵙ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK8_19","072_8_19","LUK","8","19","19","ⵢⴻⵎⵎⴰⵙ ⴷ ⴰⵢⵜⵎⴰⵙ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴽⵉⴷⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LK8_20","072_8_20","LUK","8","20","20","ⵏⵏⴰⵏ ⴰⵙ: “ⵢⴻⵎⵎⴰⵛ ⴷ ⴰⵢⵜⵎⴰⵛ ⴱⴻⴷⴷⴻⵏ ⴱⴰⵔⵔⴰ, ⵅⵙⴻⵏ ⴰⴷ ⵛⴻⴽ ⵥⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK8_21","072_8_21","LUK","8","21","21","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵢⴻⵎⵎⴰ ⴷ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵜⵜⴻⴳⴳⴻⵏ ⵣⵣⴰⵢⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK8_22","072_8_22","LUK","8","22","22","ⴷⴻⴳ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵏⵢⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵥⵡⴰ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹⵉⵏ ⵏ ⵍⴻⴱⵃⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("LK8_23","072_8_23","LUK","8","23","23","ⴰⵎ ⵜⴻⵏ ⵜⵓⵖⴰ ⵔⵓⵃⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵉⴽⴽⴰ ⵢⵉⴹⴻⵚ ⵅ ⵢⴰⵙⵓⵄ. ⵅⴻⵏⵏⵉ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵜⴻⴱⴷⴰ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵄⵍⴰⵢⴻⵏ ⴰⴷ ⵜⴻⵀⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("LK8_24","072_8_24","LUK","8","24","24","ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵙⵙⴼⴰⵇⴻⵏ ⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵏⵖⴰⵔⵔⴻⵇ.” ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⵉⵡⴻⴱⴱⴻⵅ ⴰⵙⴻⵎⵎⵉⴹ ⴷ ⵍⴻⵎⵡⴰⵊ ⵏ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵙⵙⵇⴰⵔⴻⵏ, ⵢⴰⵔⵙⴰ ⵍⵃⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LK8_25","072_8_25","LUK","8","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ?” ⴳⴳⵯⴻⴷⴻⵏ, ⵜⴱⴻⵀⵜⴻⵏ, ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰ, ⴰⵇⴰ ⵉⵜⵜⴰⵎⴰⵔ ⵓⵍⴰ ⴷ ⴰⵙⴻⵎⵎⵉⴹ ⴷ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⵜⵜᵉⵟⵟⴰⵄⴻⵏ ⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK8_26","072_8_26","LUK","8","26","26","ⵓⵢⵓⵔⴻⵏ ⵙ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴳⴰⴷⴰⵔⵉⵏⵓⵙ ⵜⴻⵏⵏⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LK8_27","072_8_27","LUK","8","27","27","ⵓⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵍⵇⴰ ⵜ-ⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ ⵓ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵔⴹ ⴰⵔⵔⵓⴹ, ⵡⴰⵔ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵛⴰ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_28","072_8_28","LUK","8","28","28","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ, ⵉⵙⵖⵓⵢ, ⵉⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⵙ ⵊⵊⴻⵀⴷ “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵏⴻⵖ ⵏⴻⵛⵛ ⴷ ⵛⴻⴽ ⴰ ⵢⴰⵙⵓⵄ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ? ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵛⴻⴽ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵄⴻⴷⴷⵉⴱⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("LK8_29","072_8_29","LUK","8","29","29","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⵓⵎⵓⵔ ⵉ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜ ⴷⴰⵢⴻⵙ ⵄⴰⴷ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵔ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵛⴰⵔⴼⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⴷ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⴻⵥⵥⴰ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵢⵓⵥⵥⴻⵍ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LK8_30","072_8_30","LUK","8","30","30","ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵢⴰⵙⵓⵄ: “ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵏ?” ⵉⵏⵏⴰ ⴰⵙ: “ⵍⵉⵅⵢⵓⵏ ”, ⵎⵉⵏⵣⵉ ⵛⵛⵡⴰⵟⴻⵏ ⴰⵟⵟⴰⵙ ⵜⵓⵖⴰ ⵓⴷⴼⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK8_31","072_8_31","LUK","8","31","31","ⵏⵉⵜⵏⵉ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⴰⵎⴰⵔ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵡⴻⵃⴼⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("LK8_32","072_8_32","LUK","8","32","32","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵉⵍⴼⴰⵏ, ⵜⵓⵖⴰ ⵜⵀⴻⴷⴷⴰ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ. ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵊⵊ ⴰⴷ ⴰⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵍⴼⴰⵏ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⴰⵎⵃ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_33","072_8_33","LUK","8","33","33","ⴼⴼⵖⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵣⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ, ⵓⴷⴼⴻⵏ ⴷⴻⴳ ⵉⵍⴼⴰⵏ. ⵅⴻⵏⵏⵉ ⵜⴻⵇⵏⵓⵏⵏⵉ ⵜⵃⵉⵎⴰⵔⵜ ⵣⵉ ⵊⵊⴰⵔⴼ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵜⵖⴰⵔⵇ. ");
INSERT INTO rift_vpl VALUES ("LK8_34","072_8_34","LUK","8","34","34","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⴰⵔⴻⵡⵍⴻⵏ ⵓⵛⴰ ⵄⴰⵡⴷⴻⵏ ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⴷⵉ ⴷⵛⵓⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_35","072_8_35","LUK","8","35","35","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉⵡⴷⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵓⴼⵉⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵣⵉ ⴼⴼⵖⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ, ⵢⴰⵔⴹ, ⵙ ⵍⴻⵄⵇⴻⵍ, ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_36","072_8_36","LUK","8","36","36","ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵄⴰⵡⴷⴻⵏ ⴰⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ ⵓⵎⴰⵔⵢⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LK8_37","072_8_37","LUK","8","37","37","ⵍⵖⴰⵛⵉ ⵏ ⵉⵊⴰⴷⴰⵔⵉⵢⵢⴻⵏ ⵣⴰⵡⴳⴻⵏ ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴳⴳⵯⴻⵊ, ⵎⵉⵏⵣⵉ ⵜⵓⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ. ⵅⴰⵙ ⵓⵛⴰ ⵢⴻⵏⵢⴰ ⵢⴰⵙⵓⵄ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵉⴳⴳⵯⴻⵊ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK8_38","072_8_38","LUK","8","38","38","ⴰⵔⵢⴰⵣ ⵉ ⵣⵉ ⴼⴼⵖⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ, ⵉⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ, ⵎⴰ ⴰⴷ ⵜⴰⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ, ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ, ⵉⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("LK8_39","072_8_39","LUK","8","39","39","“ⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵄⴰⵡⴻⴷ ⵉ ⴰⵢⵜ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵎⵉⵏ ⴷⴰⵢⴻⴽ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ.” ⵅⴰⵙ ⵓⵛⴰ ⵉⵔⵓⵃ, ⵉⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵇⴰⵄ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK8_40","072_8_40","LUK","8","40","40","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⵢⴰⵙⵓⵄ, ⵢⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵔⴰⵊⴰⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_41","072_8_41","LUK","8","41","41","ⵓ ⵅⵣⴰⵔ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵢⵔⵓⵙ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵉⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⵣⴰⵡⴳ ⵉ-ⵜ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK8_42","072_8_42","LUK","8","42","42","ⵎⵉⵏⵣⵉ ⴰⵢⴻⵏⵏⵉ ⵏ ⵢⴻⴵⵉⵙ ⵉ ⵖⴰⵔⴻⵙ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵜⵓⵖⴰ ⵄⵍⴰⵢⴻⵏ ⴰⴷ ⵜⴻⵎⵎⴻⵜ. ⴰⵎ ⴽⵉⴷⴻⵙ ⵉⴳⴳⵓⵔ ⵢⴰⵙⵓⵄ, ⵉⵙⵙⴷⴻⵃⵃⴻⵙ ⵉ-ⵜ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LK8_43","072_8_43","LUK","8","43","43","ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⵓⵖⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵍⵇⴻⴷⴷ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵜⵙⴻⵢⵢⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵡⴻⵍⵜ ⵏⵏⴻⵙ ⵅ ⵉⴹⴱⵉⴱⴻⵏ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵜⵜ ⵉⵙⵙⴳⴻⵏⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("LK8_44","072_8_44","LUK","8","44","44","ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵣⵉ ⴹⴻⴼⴼⴰⵔ, ⵜⵃⴰⴷⴰ ⴰⴱⴻⵃⵍⵓⵍ ⵏ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK8_45","072_8_45","LUK","8","45","45","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⵡⵉ ⴷ ⴰⵢⵉ ⵉⵃⴰⴷⴰⵏ?” ⵓⵎⵉ ⵏⴽⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ, ⵉⵏⵏⴰ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵍⵖⴰⵛⵉ ⵉⵙⵙⴷⴻⵃⵃⴻⵙ ⵉ-ⵛ ⵓ ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵡⵉ ⴷ ⴰⵢⵉ ⵉⵃⴰⴷⴰⵏ?’” ");
INSERT INTO rift_vpl VALUES ("LK8_46","072_8_46","LUK","8","46","46","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵉⵊⵊⴻⵏ ⵉⵃⴰⴷⴰ ⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵓⵛⵉⵖ ⵊⵊⴻⵀⴷ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK8_47","072_8_47","LUK","8","47","47","ⵓⵎⵉ ⵜⴻⵙⵙⴻⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵡⴰⵔ ⵜⴻⵎⵥⴰⵔ, ⵜⵓⵙⴰ-ⴷⴷ ⵙ ⵓⵇⴻⴼⵇⴻⴼ ⵓⵛⴰ ⵜⴻⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵉⵙⵊⴻⴷ ⴰⵙ. ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵜⵅⴻⴱⴱⴰⵔ ⵅ ⵎⴰⵏ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵣⵉ ⵜ ⵜⵃⴰⴷⴰ ⴷ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK8_48","072_8_48","LUK","8","48","48","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴻⴳⴳ ⵓⵍ, ⴰ ⵢⴻⴵⵉ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵎ ⵉⵡⵛⴰ ⴰⵎ ⵜⵓⴷⴰⵔⵜ. ⵔⵓⵃ ⴷⵉ ⵍⴻⵀⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK8_49","072_8_49","LUK","8","49","49","ⴰⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ, ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵢⴻⴵⵉⵛ ⵜⴻⵎⵎⵓⵜ, ⵡⴰⵔ ⵙⵙⴰⵃⴰⵍ ⵄⴰⴷ ⴰⵎⵙⴻⵖⵖⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LK8_50","072_8_50","LUK","8","50","50","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵍⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⵉ ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ: “ⵡⴰⵔ ⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ! ⴰⵎⴻⵏ ⵡⴰⵀⴰ, ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜⴻⴷⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("LK8_51","072_8_51","LUK","8","51","51","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵡⴰⵔ ⵉⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⴷⴻⴼ ⵎⵖⵉⵔ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ ⴷ ⵢⴻⵎⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK8_52","072_8_52","LUK","8","52","52","ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵔⵓ, ⵡⵜⵉⵏ ⵅⴰⵙ ⴰⴳⴻⵊⴷⵓⵔ. ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⵔⵓⵎ, ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⴻⵎⵎⵓⵜ ⵛⴰ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜᵉⵟⵟⴻⵚ.” ");
INSERT INTO rift_vpl VALUES ("LK8_53","072_8_53","LUK","8","53","53","ⵏⵉⵜⵏⵉ ⴹⴻⵃⵛⴻⵏ ⴷⴰⵢⴻⵙ, ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⵜⵓⵖⴰ ⵜⴻⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("LK8_54","072_8_54","LUK","8","54","54","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ, ⵉⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵜⴰⵃⴻⵏⵊⵉⵔⵜ, ⴽⴽⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("LK8_55","072_8_55","LUK","8","55","55","ⵉⴷⵡⴻⵍ-ⴷⴷ ⴷⴰⵢⴻⵙ ⴱⵓⵃⴱⴻⵍ ⵓⵛⴰ ⵜⴻⴽⴽⴰⵔ ⵍⴻⵅⴷⴻⵏⵏⵉ. ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵎⵉⵏ ⵖⴰ ⵜⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("LK8_56","072_8_56","LUK","8","56","56","ⵜⴱⴻⵀⵜⴻⵏ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵡⴻⵚⵚⴰ ⵉ-ⵜⴻⵏ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⵉ ⵃⴻⴷ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_1","072_9_1","LUK","9","1","1","ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵊⵊⴻⵀⴷ ⴷ ⵚⵚⵓⵍⵟⴰ ⵅ ⵎⴰⵔⵔⴰ ⵛⵛⵡⴰⵟⴻⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⵀⵍⴰⵛⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵏⴼⴰⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_2","072_9_2","LUK","9","2","2","ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴳⴻⵏⴼⴰⵏ ⵉⵎⴻⵀⵍⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("LK9_3","072_9_3","LUK","9","3","3","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵡⴰⵍⵓ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵉⵖ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏⵉⵖ ⵜⵜⴻⵙⵟⵉⵎ ⵏⵉⵖ ⴰⵖⵔⵓⵎ ⵓⵍⴰ ⴷ ⵏⵏⵓⵇⴰⵔⵜ, ⵓⵛⴰ ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵛⴰⵎⵉⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("LK9_4","072_9_4","LUK","9","4","4","ⵎⴰⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ, ⵇⵇⵉⵎⴻⵎ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⴼⴼⵖⴻⵎ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK9_5","072_9_5","LUK","9","5","5","ⵎⴰⵍⴰ ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵣⴻⵔⵣⴻⵎ ⵅⴻⵏⵏⵉ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵇⴻⴱⴱⵍⴻⵏ, ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵅⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK9_6","072_9_6","LUK","9","6","6","ⵅⴰⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵔⵔⵓⵙⵓⵍ, ⵜⵓⵖⴰ ⵜⵜⵛⵓⵇⴰⵏ ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⴷ ⵜⵏⴻⴷⴷⴰⵎ. ⵏⵉⵜⵏⵉ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵙⵙⴳⴻⵏⴼⴰⵏ ⵉⵎⴻⵀⵍⴰⵛ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_7","072_9_7","LUK","9","7","7","ⵀⵉⵔⵓⴷⵓⵙ, ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⵍⴰ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵢⴰⵔⵊⴻⴼ, ⵎⵉⵏⵣⵉ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ ⵏⵏⴰⵏ, ⴰⵇⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_8","072_9_8","LUK","9","8","8","ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ ⴰⵇⴰ ⵉⵍⵉⵢⴰ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵓ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵄⴰⵡⴻⴷ ⴰⵇⴰ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("LK9_9","072_9_9","LUK","9","9","9","ⵉⵏⵏⴰ ⵀⵉⵔⵓⴷⵓⵙ: “ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⵉⵇⴻⵙⵙⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵎⴰⵛⴰ ⵎⴰⵏⵉⵙ ⵡⴰ ⵉ ⵅⴻⴼ ⵙⵍⵉⵖ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ?” ⵓⵛⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜ ⵉⵥⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK9_10","072_9_10","LUK","9","10","10","ⵓⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵏ ⵔⵔⵓⵙⵓⵍ, ⵄⴰⵡⴷⴻⵏ ⵉ ⵢⴰⵙⵓⵄ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵏ. ⵅⴻⵏⵏⵉ ⵢⵉⵡⵢⵉ ⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK9_11","072_9_11","LUK","9","11","11","ⵓⵎⵉ ⵢⴰⵔⴳⴻⴱ ⵍⵖⴰⵛⵉ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⵙⴻⵏ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉⵏⵏⵉ ⵃⴷⴰⵊⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_12","072_9_12","LUK","9","12","12","ⵍⴰⵎⵉ ⵉⴱⴷⴰ ⵍⵃⴰⵍ ⵉⵙⵙⵓⵜⵓⵎ, ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵙⴻⴽⴽ ⵍⵖⴰⵛⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵍⴻⴷⵛⵓⵔ ⴷ ⵉⵢⵢⴰⵔⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⴰⴷ ⴷⵉⵏⵏⵉ ⴰⴼⴻⵏ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⵙⴻⵏ ⴷ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵅⵍⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK9_13","072_9_13","LUK","9","13","13","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵛⴻⵎ ⴰⵙⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ.” ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵎⵖⵉⵔ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⵏⵉⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵔⴰⵃ ⴰⴷ ⵏⵙⴻⵖ ⵎⴰⵛⵛⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK9_14","072_9_14","LUK","9","14","14","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵛⴰ ⵏ ⵅⴻⵎⵙⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵖⵉⵎⴻⵎ ⵜⴻⵏ ⴷⵉ ⵜⵄⵓⵔⵔⵉⵛⵉⵏ ⵏ ⵅⴻⵎⵙⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK9_15","072_9_15","LUK","9","15","15","ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴰⵎⴻⵏⵏⵉ ⵓⵛⴰ ⵙⵙⵖⵉⵎⴻⵏ ⵜⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK9_16","072_9_16","LUK","9","16","16","ⵉⴽⵙⵉ ⵢⴰⵙⵓⵄ ⵜⵉⵛⵏⵉⴼⵉⵏ ⵙ ⵅⴻⵎⵙⴰ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵏⵏⵉ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏⵜ, ⵢⴰⵔⵥⴰ ⵓⵛⴰ ⵉⵡⵛⴰ ⵣⵉ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏⵏⵉ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵏ ⵉ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LK9_17","072_9_17","LUK","9","17","17","ⵛⵛⵉⵏ, ⵊⵊⵉⵡⵏⴻⵏ ⵎⴰⵔⵔⴰ. ⴰⵍⴰⵎⵉ ⴷ ⵊⴰⵔⵡⴻⵏ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⴻⴳ ⵉⵍⴻⵇⵇⵡⴰⵣ, ⵜⵓⵖⴰ ⴷⵉⵏⵏⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_18","072_9_18","LUK","9","18","18","ⴰⵎ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵜⵜⵥⴰⴵⴰ ⵡⴻⵃⵃⴷⴻⵙ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵍⵖⴰⵛⵉ ⵎⵉⵏ ⵄⵏⵉⵖ?” ");
INSERT INTO rift_vpl VALUES ("LK9_19","072_9_19","LUK","9","19","19","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “‘ⵢⵓⵃⴰⵏⵏⴰ ⴰⵎⵙⴻⵖⴹⴰⵚ!’, ⵓ ⵉⵏⵏⴻⵖⵏⵉ: ‘ⵉⵍⵉⵢⴰ!’, ⵓ ⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ: ‘ⴰⵇⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ, ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ’.” ");
INSERT INTO rift_vpl VALUES ("LK9_20","072_9_20","LUK","9","20","20","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉ ⴽⴻⵏⵏⵉⵡ, ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⵎ ⵎⵉⵏ ⵄⵏⵉⵖ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ: “ⵍⵎⴰⵙⵉⵃ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK9_21","072_9_21","LUK","9","21","21","ⵅⴻⵏⵏⵉ ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵓⵛⴰ ⵉⵡⴻⵚⵚⴰ ⵜⴻⵏ, ⵡⴰⵔ ⵜ ⵇⵇⴰⵔⴻⵏ ⵉ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK9_22","072_9_22","LUK","9","22","22","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LK9_23","072_9_23","LUK","9","23","23","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵔⴰ: “ⵎⴰⵍⴰ ⵉⵅⵙ ⵃⴻⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵏⴽⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴽⵙⵉ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ ⴽⵓⵍ ⴰⵙⵙ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴹⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK9_24","072_9_24","LUK","9","24","24","ⵎⵉⵏⵣⵉ ⵡⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⵡⴻⴷⴷⴰⵔ. ⵎⴰⵛⴰ ⵡⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK9_25","072_9_25","LUK","9","25","25","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⴱⵏⴰⴷⴻⵎ ⵎⴰⵍⴰ ⵢⴰⵔⴱⴻⵃ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⴷ ⵜ ⵉⵡⴻⴷⴷⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("LK9_26","072_9_26","LUK","9","26","26","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⴻⴹⵃⴰⵏ ⵣⵣⴰⵢⵉ ⵓ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⴻⴹⵃⴰ ⵄⴰⵡⴻⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵓ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_27","072_9_27","LUK","9","27","27","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⴰ ⵉⵃⴹⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜⵇⵉⵙⵉⵏ ⵛⴰ ⵍⵎⴻⵡⵜ ⴰⵍ ⵖⴰ ⵥⴰⵔⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK9_28","072_9_28","LUK","9","28","28","ⵄⵍⴰⵃⴰⵍ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⵡⵢⵉ-ⴷⴷ ⵢⴰⵙⵓⵄ ⴰⴽⵉⴷⴻⵙ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ. ");
INSERT INTO rift_vpl VALUES ("LK9_29","072_9_29","LUK","9","29","29","ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵥⴰⴵⴰ, ⵉⴱⴻⴷⴷⴻⵍ ⵡⵓⴷⴻⵎ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵓ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_30","072_9_30","LUK","9","30","30","ⵅⵣⴰⵔ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵎⵓⵙⴰ ⴷ ⵉⵍⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("LK9_31","072_9_31","LUK","9","31","31","ⵉⵏⵏⵉ ⴷⴷ-ⵉⴹⵀⴰⵔⴻⵏ ⵙ ⵓⵄⵓⴵⵉ, ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵡⵓⴼⴼⵓⵖ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK9_32","072_9_32","LUK","9","32","32","ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ, ⵜⵓⵖⴰ ⵉⴽⴽⴰ ⵅⴰⵙⴻⵏ ⵢⵉⴹⴻⵚ, ⴰⵍⴰⵎⵉ ⵄⵍⴰⵢⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴼⴰⵇⴻⵏ. ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK9_33","072_9_33","LUK","9","33","33","ⴰⵍⴰⵎⵉ ⵅⴰⵙ ⴼⴰⵔⵇⴻⵏ ⵉⵏⴰ, ⵉⵏⵏⴰ ⵛⵉⵎⵄⵓⵏ ⵉ ⵢⴰⵙⵓⵄ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⴰⵇⴰ ⵎⵍⵉⵃ ⵓⵎⵉ ⵉ ⴷⴰ ⵏⴻⴵⴰ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⵡⴻⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵏ ⵜⵙⴻⵟⵟⴰ, ⵉⵊⵊⴻⵏ ⵉ ⵛⴻⴽ, ⵉⵊⵊⴻⵏ ⵉ ⵎⵓⵙⴰ ⵓ ⵉⵊⵊⴻⵏ ⵉ ⵉⵍⵉⵢⴰ.” ⵏⴻⵜⵜⴰ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK9_34","072_9_34","LUK","9","34","34","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⴽⴽⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵉⵙⵙⴷⵓⵔⵉⵢ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴳⴳⵯⴻⴷⴻⵏ ⵓⵎⵉ ⵥⵔⵉⵏ ⵎⵓⵙⴰ ⴷ ⵉⵍⵉⵢⴰ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵙⴻⵢⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK9_35","072_9_35","LUK","9","35","35","ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵇⵇⴰⵔ: “ⴷ ⵡⴰ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⵙⵍⴻⵎ ⵖⴰⵔⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("LK9_36","072_9_36","LUK","9","36","36","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵜⵎⵉⵊⵊⴰ, ⵓⴼⵉⵏ ⵢⴰⵙⵓⵄ ⵡⴻⵃⵃⴷⴻⵙ. ⵏⵉⵜⵏⵉ ⵙⵙⵇⴰⵔⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵃⴻⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵙ ⵎⵉⵏ ⵥⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_37","072_9_37","LUK","9","37","37","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵀⴻⴽⴽⵡⴰⵏ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ, ⵉⵍⵇⴰ ⵜⴻⵏ-ⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_38","072_9_38","LUK","9","38","38","ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵍⵖⴰⵛⵉ ⵉⵙⵖⵓⵢ, ⵉⵏⵏⴰ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ, ⵃⵉⵏⵏ ⵅⴰⴼⵉ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵉ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LK9_39","072_9_39","LUK","9","39","39","ⵅⵣⴰⵔ, ⵉⵜⵜⴻⵟⵟⴻⴼ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵍⴰⵔⵢⴰⵃ, ⵅⴻⵏⵏⵉ ⵉⵙⵖⵓⵢⵢⵓ ⴷⴻⵖⵢⴰ, ⵉⵜⵜⵖⴻⵥⵥⴰ ⵜⵉⵖⵎⴰⵙ ⵓ ⵉⵜⵜⴻⴽⴽ ⴰⵙ-ⴷⴷ ⴽⵓⴼⴼⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ, ⵄⵍⴰⵃⴰⵔ ⵡⴰⵔ ⴷ ⴰⵙ ⵢⴰⵔⴻⵅⵅⵓ ⴰⵎ ⵜ ⵉⵢⴻⵣⵣⴻⵎ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("LK9_40","072_9_40","LUK","9","40","40","ⵜⵜⴰⵔⴻⵖ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵜ ⵙⵙⵓⴼⴼⵖⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK9_41","072_9_41","LUK","9","41","41","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⴰ ⵊⵊⵉⵍ ⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵉⵎⵄⴻⵡⵡⵊⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⵖⴰⵔⵡⴻⵎ ⵉ ⵖⴰ ⴽⴽⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴽⵙⵉⵖ? ⴰⵡⵉ-ⴷⴷ ⵎⵎⵉⵛ ⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK9_42","072_9_42","LUK","9","42","42","ⴰⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵇⴰⵔⵔⴻⴱ, ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⵛⵛⵉⵟⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵎⴻⵣⵣⴻⵇ ⵉ-ⵜ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵡⴻⴱⴱⴻⵅ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⴰⵃⴻⵏⵊⵉⵔ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜ ⵉ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK9_43","072_9_43","LUK","9","43","43","ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⵜⵜⵄⴻⵊⵊⴱⴻⵏ ⴷⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵓⵛⴰ ⵓⵎⵉ ⵜⴱⴻⵀⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("LK9_44","072_9_44","LUK","9","44","44","“ⴳⴳⴻⵎ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK9_45","072_9_45","LUK","9","45","45","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵉ ⵡⴰⵡⴰⵍ-ⴰ, ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔ ⵅⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜ ⴼⴻⵀⵀⵎⴻⵏ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵡⴰⵡⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LK9_46","072_9_46","LUK","9","46","46","ⵢⵓⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⵛⵓⴱⴱⴻⵛ ⵅ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LK9_47","072_9_47","LUK","9","47","47","ⵎⴰⵛⴰ ⵉⵙⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴰⵅⴰⵔⵔⴻⵚ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK9_48","072_9_48","LUK","9","48","48","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ ⴰⵃⴻⵏⵊⵉⵔ-ⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵉⵇⴱⴻⵍ ⴰⵢⵉ ⵏⴻⵛⵛ, ⵓ ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ, ⵉⵇⴱⴻⵍ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵇⴰⵄ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK9_49","072_9_49","LUK","9","49","49","ⵉⵟⵟⴻⴼ ⵢⵓⵃⴰⵏⵏⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵏⴻⵥⵔⴰ ⵉⵊⵊⴻⵏ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⵏⴻⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⴹⴻⴼⴼⴰⵔ ⵊⵎⵉⵄ ⴰⴽⵉⴷⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("LK9_50","072_9_50","LUK","9","50","50","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵜ ⵙⴱⴻⴷⴷⴰⵎ, ⵎⵉⵏⵣⵉ ⵡⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴹⵉⴷⴷ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK9_51","072_9_51","LUK","9","51","51","ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⵎⴻⴽⵙⵉⵜ ⵏⵏⴻⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵢⴰⵔⵔⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK9_52","072_9_52","LUK","9","52","52","ⵉⵙⵙⴻⴽⴽ ⵣⵣⴰⵜⴻⵙ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵓⵛⴰ ⵉⵏⴰ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴷⵛⴰⵔ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵡⴻⵊⴷⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK9_53","072_9_53","LUK","9","53","53","ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵇⴱⵉⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵢⴰⵔⵔⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK9_54","072_9_54","LUK","9","54","54","ⵓⵎⵉ ⵥⵔⵉⵏ ⵢⴰⵄⵇⵓⴱ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵏⵓⵎⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⴰ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵜⴻⵛⵛ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ ⵉⵍⵉⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK9_55","072_9_55","LUK","9","55","55","ⵎⴰⵛⴰ ⴰⵎ ⴷⴷ-ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⴰⵏ ⴰⵔⵔⵓⵃ ⵉ ⵣⵉ ⵜⴻⴵⴰⵎ ⴽⴻⵏⵏⵉⵡ! ");
INSERT INTO rift_vpl VALUES ("LK9_56","072_9_56","LUK","9","56","56","ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ!” ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⴷⵛⵓⵔⴰⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK9_57","072_9_57","LUK","9","57","57","ⴰⵎ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵏⵏⴰ ⴰⵙ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵖ ⵎⴰⵏⵉ ⵎⴰ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("LK9_58","072_9_58","LUK","9","58","58","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵉⵛⴻⵄⴱⴰⵡⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵉⴼⵔⴰⵏ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⵡⴰⵛⵛ, ⵎⴰⵛⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵓⵍⴰ ⵎⴰⵏⵉ ⵖⴰ ⵉⵙⴻⵏⵏⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK9_59","072_9_59","LUK","9","59","59","ⵉⵏⵏⴰ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵢⵉ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⴰⵔⴻⴳⴳⵯⴻⵃⴻⵖ ⴰⴷ ⵏⴻⴹⵍⴻⵖ ⴱⴰⴱⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK9_60","072_9_60","LUK","9","60","60","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴻⵊⵊ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⴷ ⵏⴻⴹⵍⴻⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵔⵓⵃ, ⵜⴱⴰⵔⵔⵃⴻⴷ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK9_61","072_9_61","LUK","9","61","61","ⵉⵏⵏⴰ ⴰⵙ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⴰⴷ ⵛⴻⴽ ⴹⴼⴰⵔⴻⵖ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⴻⵊⵊ ⴰⵢⵉ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⴳⴳⴻⵖ ⴰⵍⵍⴰⵀ ⵉⵀⴻⵏⵏⵉⴽ ⵅ ⵢⵉⵏⵏⵉ ⵖⴰⵔⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("LK9_62","072_9_62","LUK","9","62","62","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⴰⵍⴰ ⵉⵙⵙⵔⵓⵙⴰ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵅ ⵓⵙⵖⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⴰⴷ ⵉⵚⵍⴻⵃ ⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK10_1","072_10_1","LUK","10","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵍⴻⵇⵇⴻⵎ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⵙⴻⴱⵄⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵜⵢⵓⵢⴰ ⵜⵢⵓⵢⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷ ⵊⵊⵡⴰⵢⴻⵀ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴷ ⵉⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LK10_2","072_10_2","LUK","10","2","2","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵜⴰⵎⴻⵢⵔⴰ ⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⴷⵔⵓⵙ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⴰⵔⴻⵎ ⵉ ⴱⴰⴱ ⵏ ⵜⵎⴻⵢⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⴽⴽ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵢⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_3","072_10_3","LUK","10","3","3","ⵔⵓⵃⴻⵎ! ⴰⵇⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵎ ⵡⵓⴵⵉ ⵊⴰⵔ ⵡⵓⵛⵛⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK10_4","072_10_4","LUK","10","4","4","ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⴽⴻⵙⵙⵉⵎ ⵜⵉⵛⵢⴰⵔⵉⵏ ⵍⴰ ⴷ ⵜⵜⴻⵙⵟⴰⵢⴻⵎ ⵓⵍⴰ ⴷ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ, ⵡⴰⵔ ⵜⵜⵙⴻⴵⴰⵎⴻⵎ ⵅ ⵃⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("LK10_5","072_10_5","LUK","10","5","5","ⵎⴰⵏ ⵎⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ, ⵉⵏⵉⵎ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ: ‘ⵍⴻⵀⵏⴰ ⵅ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ.’ ");
INSERT INTO rift_vpl VALUES ("LK10_6","072_10_6","LUK","10","6","6","ⵎⴰⵍⴰ ⴷⵉⵏ ⵎⵎⵉⵙ ⵏ ⵍⴻⵀⵏⴰ, ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵙⴰ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵍⴻⵀⵏⴰ ⵏⵡⴻⵎ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵄⵇⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("LK10_7","072_10_7","LUK","10","7","7","ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⵉ, ⵛⵛⴻⵎ, ⵙⵡⴻⵎ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵅⴻⴷⴷⴰⵎ ⵉⵙⴷⴰⵀⴻⴵ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ. ⵙ ⵓⵢⴰ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵎ ⵛⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK10_8","072_10_8","LUK","10","8","8","ⵎⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⴱⵍⴻⵏ, ⵛⵛⴻⵎ ⴷⵉⵏ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK10_9","072_10_9","LUK","10","9","9","ⵙⴳⴻⵏⴼⴰⵎ ⵉⵎⴻⵀⵍⴰⵛ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ, ⵉⵏⵉⵎ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK10_10","072_10_10","LUK","10","10","10","ⵎⴰⵏ ⵎⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵇⴱⵉⵍⴻⵏ, ⴼⴼⵖⴻⵎ ⵖⴰⵔ ⵣⵣⵏⴰⵇⵉ ⵏⵏⴻⵙ, ⵉⵏⵉⵎ: ");
INSERT INTO rift_vpl VALUES ("LK10_11","072_10_11","LUK","10","11","11","“ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵉ ⴷⴰⵢⵏⴻⵖ ⵉⵍⴻⵚⵇⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵜ ⵏⴻⵣⵣⴻⵔⵣ ⵅⴰⵡⴻⵎ. ⵎⴰⵛⴰ ⵙⵏⴻⵎ ⴰⵢⴰ, ⴰⵇⴰ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("LK10_12","072_10_12","LUK","10","12","12","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⴱⴻⵍⵍⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴰⵍ ⵏ ⵙⴰⴷⵓⵎ ⵉⵀⵡⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK10_13","072_10_13","LUK","10","13","13","ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⵅⵓⵔⴰⵣⵉⵏ, ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ! ⵎⵍⵉ ⵎⵙⴰⵔⴻⵏⵜ ⴷⵉ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⴰⵢⴽⴻⵏⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵓⴱⴻⵏⵜ ⵣⵉ ⵣⵣⵎⴰⵏ ⴰⵎ ⵇⵇⵉⵎⴻⵏⵜ ⴷⵉ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⴷ ⵢⵉⵖⵖⴻⴹ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK10_14","072_10_14","LUK","10","14","14","ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⴰⵍ ⵏ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ ⵉⵀⵡⴻⵏ ⵣⵉ ⵍⵃⴰⵍ ⵏⴽⴻⵏⵜ ⴷⵉ ⵍⵃⵉⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("LK10_15","072_10_15","LUK","10","15","15","ⵓ ⵛⴻⵎ, ⴰ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵀⵡⵉⴷ ⵖⴰⵔ ⵍⴰⵅⴰⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("LK10_16","072_10_16","LUK","10","16","16","ⵡⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⵙⵍⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⵙⴻⵍ, ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰ ⵢⴰⴳⵉⵏ, ⴰⴷ ⴰⵢⵉ ⵢⴰⴳⵉ, ⵓ ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⴰⴳⵉⵏ, ⴰⴷ ⵢⴰⴳⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK10_17","072_10_17","LUK","10","17","17","ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵏⵏⵉ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⵟⵟⴰⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓⵍⴰ ⴷ ⵛⵛⵡⴰⵟⴻⵏ ⵟⵟⴰⵄⴻⵏ ⴰⵏⴻⵖ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK10_18","072_10_18","LUK","10","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵥⵔⵉⵖ ⵛⵛⵉⵟⴰⵏ ⵉⵡⴹⴰ-ⴷⴷ ⴰⵎⴻⵛⵏⴰⵡ ⴰⵙⵙⴰⵎ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK10_19","072_10_19","LUK","10","19","19","ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⴼⵙⴻⵎ ⵅ ⵉⴼⵉⵖⵔⴰⵏ ⴷ ⵉⵖⴰⵔⴹⵎⵉⵡⴻⵏ ⵓⵍⴰ ⴷ ⵚⵚⵓⵍⵟⴰ ⵅ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏ ⵍⴻⵄⴷⵓ. ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴹⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LK10_20","072_10_20","LUK","10","20","20","ⵎⴰⵛⴰ ⵡⴰⵔ ⴼⴰⵔⵔⵃⴻⵎ ⵛⴰ ⵙ ⵓⵢⴰ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵛⵛⵡⴰⵟⴻⵏ ⴰⴷ ⴰⵡⴻⵎ ⵟⵟⴰⵄⴻⵏ, ⵎⴰⵛⴰ ⴼⴰⵔⵃⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK10_21","072_10_21","LUK","10","21","21","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵉⴼⴰⵔⵃ ⵢⴰⵙⵓⵄ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⵛⴻⴽ, ⴰ ⴱⴰⴱⴰ, ⴱⴰⴱ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵏⵓⴼⴼⴰⵔⴻⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵅ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵓ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵍⴻⵄⵇⴻⵍ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⴻⴳⴱⴻⴷ ⵜⴻⵏⵜ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ⵡⴰⵀ, ⴰ ⴱⴰⴱⴰ, ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK10_22","072_10_22","LUK","10","22","22","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴽⵓⵍⵛⵉ ⵉⵎⵎⴻⵡⵛ ⴰⵢⵉ ⵣⵉ ⴱⴰⴱⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏ ⵡⴻⵏ ⴷ ⵎⵎⵉⵙ ⵎⵖⵉⵔ ⴱⴰⴱⴰⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴱⴰⴱⴰⵙ ⵎⵖⵉⵔ ⵎⵎⵉⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵅⵙ ⵎⵎⵉⵙ ⴰⴷ ⵜ ⵉⵙⵙⴰⵔⴳⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("LK10_23","072_10_23","LUK","10","23","23","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵙⵙⴻⵄⴷ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("LK10_24","072_10_24","LUK","10","24","24","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵜⵜⵡⵉⵍⵉⵏ, ⵓⵍⴰ ⴰⴷ ⵙⵍⴻⵏ ⵎⵉⵏ ⵜᵉⵜⵜⴻⵙⵍⴰⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵙⵍⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK10_25","072_10_25","LUK","10","25","25","ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵊⴰⵔⵔⴻⴱ, ⵉⵏⵏⴰ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵡⴰⵔⵜⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK10_26","072_10_26","LUK","10","26","26","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜ ⵢⵓⵔⵉⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ? ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("LK10_27","072_10_27","LUK","10","27","27","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK10_28","072_10_28","LUK","10","28","28","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵜⴰⵔⵔⵉⴷ ⵏⵉⵛⴰⵏ. ⴻⴳⴳ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("LK10_29","072_10_29","LUK","10","29","29","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⴳⴳⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⵊⵊⴰⵔ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("LK10_30","072_10_30","LUK","10","30","30","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵀⵡⴰ-ⴷⴷ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴰⵔⵉⵃⴰ ⵓⵛⴰ ⵉⵡⴹⴰ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ, ⴽⴽⵙⴻⵏ ⴰⵙ ⴰⵔⵔⵓⴹ, ⵡⵜⵉⵏ ⵜ ⵙ ⵡⴻⵄⵎⵓⴷ, ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ, ⵊⵊⵉⵏ ⵜ ⵊⴰⵔ ⵍⵎⴻⵡⵜ ⴷ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LK10_31","072_10_31","LUK","10","31","31","ⵅⴻⵏⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ. ⵏⴻⵜⵜⴰ ⵉⵥⵔⴰ ⵉ-ⵜ, ⵎⴰⵛⴰ ⵉⴽⴽⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_32","072_10_32","LUK","10","32","32","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵍⴰⵡⵉ ⵉⵄⴷⵓ-ⴷⴷ ⵅ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⵉⵥⵔⴰ ⵉ-ⵜ, ⵎⴰⵛⴰ ⵉⴽⴽⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_33","072_10_33","LUK","10","33","33","ⵎⴰⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵙⴰⵎⵉⵔⵉ, ⵜⵓⵖⴰ-ⵜ ⴷⴻⴳ ⵓⵙⴰⴼⴰⵔ, ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵥⵔⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵃⵉⵏⵏ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_34","072_10_34","LUK","10","34","34","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵛⴻⴷⴷ ⴰⵙ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⴻⵙ, ⵉⵙⴻⵢⵢⴻⵃ ⵅⴰⵙⴻⵏ ⴱⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵏⵢⴰ ⵉ-ⵜ ⵅ ⵣⵣⴰⵢⵍⴻⵜ ⵏⵏⴻⵙ, ⵢⵉⵡⵢⵉ ⵉ-ⵜ ⵖⴰⵔ ⵡⴻⵏⵡⴰⵍ, ⵉⵜⵀⴻⵍⵍⴰ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_35","072_10_35","LUK","10","35","35","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵍⴰⵎⵉ ⵉⵔⵓⵃ, ⵉⵡⵛⴰ ⵜⵏⴰⵢⴻⵏ ⴷⵉⵏⴰⵔ ⵉ ⴱⴰⴱ ⵏ ⵡⴻⵏⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⵜⵀⵉⵍⵍⴰ ⴷⴰⵢⴻⵙ ⵓ ⵎⴰⵍⴰ ⵜⵅⴻⴵⵚⴻⴷ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵛⴻⴽ ⵅⴻⴵⵚⴻⵖ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵄⴻⵇⴱⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("LK10_36","072_10_36","LUK","10","36","36","ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵜⵍⴰⵜⴰ ⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⴷ ⵊⵊⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵉⵡⴹⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK10_37","072_10_37","LUK","10","37","37","ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵃⵉⵏⵏⴻⵏ!” ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵉⵡⴰ ⵓⵢⵓⵔ, ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵜⴻⴳⴳⴻⴷ ⴰⵎⴻⵏⵏⵉ!” ");
INSERT INTO rift_vpl VALUES ("LK10_38","072_10_38","LUK","10","38","38","ⴰⵎ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴷⵛⴰⵔ, ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵔⵜⴰ, ⵜⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_39","072_10_39","LUK","10","39","39","ⵜⵓⵖⴰ ⵖⴰⵔ ⵜⴰ ⵉⵛⵜ ⵏ ⵓⵍⵜⵎⴰⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵔⵢⴰⵎ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵃⴻⵙⵙⴰ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK10_40","072_10_40","LUK","10","40","40","ⵎⴰⵛⴰ ⵎⴰⵔⵜⴰ ⵜⵓⵖⴰ ⵜⴻⵛⵖⴻⵍ ⴰⵟⵟⴰⵙ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ. ⵏⴻⵜⵜⴰⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵛⵇⵉ ⴱⴻⵍⵍⵉ ⵓⵍⵜⵎⴰ ⵜⴻⵊⵊⴰ ⴰⵢⵉ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵖ ⵡⴻⵃⵃⴷⵉ? ⵉⵏⵉ ⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⵄⴰⵡⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK10_41","072_10_41","LUK","10","41","41","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵔⵜⴰ, ⵎⴰⵔⵜⴰ, ⵛⴻⵎ ⵜⵛⴻⵖⵍⴻⴷ ⵓ ⵜⵇⴻⴵⵉⵇⴻⴷ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LK10_42","072_10_42","LUK","10","42","42","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵀⴰ! ⴰⵇⴰ ⵎⴰⵔⵢⴰⵎ ⵜⵉⵅⴹⴰⵔ ⵜⴰⵙⵖⴰⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵜⵜⴻⴽⴽⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK11_1","072_11_1","LUK","11","1","1","ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵥⴰⴵⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ, ⵉⵎⵙⴰⵔ, ⵓⵎⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵏⴻⵜⵜⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵙⴻⵍⵎⴻⴷ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵥⵥⴰⴵ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵄⴰⵡⴻⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK11_2","072_11_2","LUK","11","2","2","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴻⵍⵎⵉ ⵎⴰ ⵜⴻⵥⵥⵓⴵⴻⵎ, ⵉⵏⵉⵎ: ‘ⴱⴰⴱⴰⵜⵏⴻⵖ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ, ⴰⵎ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LK11_3","072_11_3","LUK","11","3","3","ⴻⵡⵛ ⴰⵏⴻⵖ ⴽⵓⵍ ⴰⵙⵙ ⴰⵖⵔⵓⵎ ⵏⵏⴻⵖ ⵉ ⴽⵓⵍ ⴰⵙⵙ, ");
INSERT INTO rift_vpl VALUES ("LK11_4","072_11_4","LUK","11","4","4","ⵓⵛⴰ ⵖⴼⴰⵔ ⴰⵏⴻⵖ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵏⵙⴰⵎⴻⵃ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴰⵢⵏⴻⵖ ⵉⵜⵜⵓⵔⵙⴻⵏ. ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵙⵙⵉⴷⵉⴼ ⵛⴰ ⴷⴻⴳ ⵓⵊⴰⵔⵔⴻⴱ, ⵎⴰⵛⴰ ⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ.’” ");
INSERT INTO rift_vpl VALUES ("LK11_5","072_11_5","LUK","11","5","5","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵔⴰⵃ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵏⵉ: ‘ⴰ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ, ⴰⵔⴹⴻⵍ ⴰⵢⵉ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LK11_6","072_11_6","LUK","11","6","6","ⵎⵉⵏⵣⵉ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵉⵏⵓ, ⵉⵅⴻⵛⵛ-ⴷⴷ ⵖⴰⵔⵉ ⵣⴻⴳ ⵓⵙⴰⴼⴰⵔ, ⵡⴰⵔ ⵖⴰⵔⵉ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵇⴻⴷⴷⵎⴻⵖ!’, ");
INSERT INTO rift_vpl VALUES ("LK11_7","072_11_7","LUK","11","7","7","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ ⵣⵉ ⴷⴰⵅⴻⵍ, ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ: ‘ⵡⴰⵔ ⴷⴷ ⴰⵢⵉ ⵜⵜⵚⴻⴷⴷⴰⵄ, ⵜⴰⵡⵡⴰⵔⵜ ⵜⴱⴻⵍⵍⴻⵄ ⵓ ⵜⴰⵔⵡⴰ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⵉ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴽⴽⴰⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵛ ⵡⵛⴻⵖ ⴰⵖⵔⵓⵎ.’ ");
INSERT INTO rift_vpl VALUES ("LK11_8","072_11_8","LUK","11","8","8","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵉⵡⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵉⵃⴷⴰⵊ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵡⵄⴰⵔⴻⵜ ⵏ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK11_9","072_11_9","LUK","11","9","9","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵜⵜⴰⵔⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛ, ⴰⵔⵣⵓⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴰⴼⴻⵎ, ⵙⵙⵇⴰⵔⵇⴱⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⴰⵔⴻⵣⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK11_10","072_11_10","LUK","11","10","10","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵜⵜⴰⵔⴻⵏ ⴰⴷ ⵉⴽⵙⵉ, ⵓ ⵡⵉ ⵖⴰ ⵢⴰⵔⵣⵓⵏ ⴰⴷ ⵢⴰⴼ, ⵓ ⵡⵉ ⵖⴰ ⵉⵙⵙⵇⴰⵔⵇⴱⴻⵏ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵔⵣⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK11_11","072_11_11","LUK","11","11","11","ⵏⵉⵖ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴱⴰⴱⴰⵙ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵜⵜⴰⵔ ⵎⵎⵉⵙ ⴰⵖⵔⵓⵎ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⵥⵔⵓ? ⵏⵉⵖ ⵓⵎⵉ ⵖⴰ ⵉⵜⵜⴰⵔ ⴰⵙⵍⴻⵎ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⴰⴼⵉⵖⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵡⴻⵙⵍⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("LK11_12","072_11_12","LUK","11","12","12","ⵏⵉⵖ ⵎⴰⵍⴰ ⵉⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⴰⵎⴻⴵⴰⵍⵜ, ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵜⴰⵖⴰⵔⴹⴻⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("LK11_13","072_11_13","LUK","11","13","13","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵜⴻⵙⵙⵏⴻⵎ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⵉⵎⴻⵡⵛⴰ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵉ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ, ⵎⴻⵛⵃⴰⵍ ⵙ ⵡⴰⵟⵟⴰⵙ ⴰⴷ ⵉⵡⵛ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⵜ ⵉⵜⵜⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK11_14","072_11_14","LUK","11","14","14","ⵓⵎⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵏⴻⵜⵜⴰ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ ⴰⴳⵏⴰⵡ, ⵉⵎⵙⴰⵔ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵛⵛⵉⵟⴰⵏ ⵏⵏⵉ, ⴰⵇⴰ ⴰⴳⵏⴰⵡ ⵉⴱⴷⴰ ⵉⵙⵙⴰⵡⴰⵍ. ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵜⴻⴱⵀⴻⵜ ⵍⵖⴰⵛⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK11_15","072_11_15","LUK","11","15","15","ⵎⴰⵛⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⵉⵙⵙⵓⴼⴼⵓⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⴱᵉⵄⴰⵍⵣⴰⴱⵓⴱ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵛⵛⵡⴰⵟⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK11_16","072_11_16","LUK","11","16","16","ⵉⵏⵏⴻⵖⵏⵉ ⵊⴰⵔⵔⴱⴻⵏ ⵜ, ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK11_17","072_11_17","LUK","11","17","17","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⴳⴻⴱ ⵅ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⵓⵍ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉ ⵉⴱⴹⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵔⴻⴷⴷⴻⴵ ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⵉⴱⴹⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵡⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("LK11_18","072_11_18","LUK","11","18","18","ⵎⴰⵍⴰ ⵉⴱⴹⴰ ⵛⵛⵉⵟⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⵇⵇⵉⵎ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ? ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⴱᵉⵄⴰⵍⵣⴰⴱⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("LK11_19","072_11_19","LUK","11","19","19","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ ⵙ ⴱᵉⵄⴰⵍⵣⴰⴱⵓⴱ, ⵙ ⵎⵉⵏⵣⵉ ⵉ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ? ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵏⵉⵜⵏⵉ ⴷ ⵍⵇⵓⴹⴰⵜ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK11_20","072_11_20","LUK","11","20","20","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵙ ⵓⴹⴰⴹ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵣⵉ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK11_21","072_11_21","LUK","11","21","21","ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵡⴻⵔⵢⴰⵣ ⵉⵊⴻⵀⴷⴻⵏ ⵉⵃⴻⵣⵣⵎⴻⵏ ⵙ ⵍⴻⵙⵏⴰⵃ ⵉⵜⵜⵄⴻⵙⵙⴰ ⵅ ⵍⴻⵎⵔⴰⵃ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴷⵉ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK11_22","072_11_22","LUK","11","22","22","ⵎⴰⵛⴰ ⵎⴻⵍⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵊⵊⵉⵀⴻⵍ ⵅⴰⵙ, ⵓⵛⴰ ⴰⴷ ⵜ ⵉⵖⵍⴻⴱ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙ ⵉⴽⴽⴻⵙ ⵍⴻⵙⵏⴰⵃ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵜⵜⵛⴰⵍ, ⵓⵛⴰ ⴰⴷ ⵉⴱⴹⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵣⵣⴰⵢⴻⵙ ⵉⴽⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LK11_23","072_11_23","LUK","11","23","23","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴰⴽⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴹⵉⴷⴷ ⵉⵏⵓ ⵓ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴽⵉⴷⵉ ⵉⵙⵙⵎⵓⵏⵉⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵣⴻⴵⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("LK11_24","072_11_24","LUK","11","24","24","“ⵅⵎⵉ ⵖⴰ ⵉⴼⴼⴻⵖ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ ⵣⵉ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵉⵛⵓⵇ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⴱⵓ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵢⴰⵔⵣⵓ ⴰⵔⵔⴰⵃⴻⵜ ⵓⵛⴰ ⵅⵎⵉ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵉⴼ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⴷ ⵄⴻⵇⴱⴻⵖ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⵜⴻⵏⵏⵉ ⵣⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("LK11_25","072_11_25","LUK","11","25","25","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ, ⴰⴷ ⵜⵜ ⵢⴰⴼ, ⵜⴼⴰⵔⴹ, ⵜⴻⵄⴷⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LK11_26","072_11_26","LUK","11","26","26","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵔⴰⵃ, ⴰⴷ ⵉⴽⵙⵉ ⵙⴻⴱⵄⴰ ⵏ ⵍⴰⵔⵢⴰⵃ ⵏⵏⴻⵖⵏⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵅⴰⵙ, ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵓⵛⴰ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⴷⵉⵏⵏⵉ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴷⵡⴻⵍ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵎⴰⵀⵓ ⵅ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵓⵖⴰ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LK11_27","072_11_27","LUK","11","27","27","ⴰⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵓⵢⴰ, ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⵍⵖⴰⵛⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵙⵙⴻⵄⴷ ⵏ ⵓⵄⴻⴷⴷⵉⵙ ⵉ ⵛⴻⴽ ⵉⴽⵙⵉⵏ ⵓ ⵜⴰⴱⴱⵓⵛⵜ ⵉ ⵣⵉ ⵜᵉⵟⵟⴹⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("LK11_28","072_11_28","LUK","11","28","28","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵃⴻⴼⴼⴹⴻⵏ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK11_29","072_11_29","LUK","11","29","29","ⴰⵎ ⵜⵓⵖⴰ ⵉⵎⵓⵏ ⵍⵖⴰⵛⵉ, ⵉⴱⴷⴰ ⵉⵇⵇⴰⵔ: “ⵜⵜⴰⵚⵉⵍⴻⵜ-ⴰ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵜᵉⵜⵜᵉⵜⵜⴰⵔ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜᵉⵜⵜⵎⴻⵡⵛⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵎⵖⵉⵔ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏ ⵢⵓⵏⵓⵙ ⴰⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK11_30","072_11_30","LUK","11","30","30","ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵏⵓⵙ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵏⵉⵏⵡⴰ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵄⴰⵡⴻⴷ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵊⵊⵉⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LK11_31","072_11_31","LUK","11","31","31","ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⵍⵊⴰⵏⵓⴱ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏ ⵊⵊⵉⵍ-ⴰ, ⴰⴷ ⵜⴻⵏ ⵜⵃⴰⵙⴻⴱ. ⵎⵉⵏⵣⵉ ⵜⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵜⵏⴻⴳⴳⴰⵔⵓⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⵍ ⵉ ⵜⵉⵖⵉⵜ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵡⴻⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵅ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK11_32","072_11_32","LUK","11","32","32","ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵏⵉⵏⵡⴰ ⴰⴷ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ ⴰⴽ-ⴷ ⵊⵊⵉⵍ-ⴰ ⵓⵛⴰ ⴰⴷ ⵜ ⵃⴰⵙⴱⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⴱⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⴱⴰⵔⵔⴻⵃ ⵏ ⵢⵓⵏⵓⵙ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵡⴻⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ ⵅ ⵢⵓⵏⵓⵙ!” ");
INSERT INTO rift_vpl VALUES ("LK11_33","072_11_33","LUK","11","33","33","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵔⴻⵇⵇⵉ ⵍⵇⴻⵏⴷⵉⵍ ⵓⵛⴰ ⵉⵙⵙⵔⵓⵙⴰ ⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ ⵏⵉⵖ ⵙⴰⴷⵓ ⵍⵎⵓⴷ ⵏ ⵉⵎⴻⵏⴷⵉ, ⵎⴰⵛⴰ ⵉⵙⵙⵔⵓⵙⴰ ⵉ-ⵜ ⵅ ⵍⵎⴻⵔⴼⴻⵄ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⴰⴷ ⵥⴰⵔⴻⵏ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LK11_34","072_11_34","LUK","11","34","34","ⵍⵇⴻⵏⴷⵉⵍ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⴷ ⵜⵉⵟⵟ ⵏⵏⴻⵛ. ⵎⴰⵍⴰ ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⵜⴻⵚⴼⴰ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴼⴰⵡⵜ ⵓⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ. ⵎⴰⵍⴰ ⵜⵉⵟⵟ ⵏⵏⴻⵛ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵓⵍⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("LK11_35","072_11_35","LUK","11","35","35","ⵃⴹⴰ ⵅⴻⵏⵏⵉ, ⵃⵉⵎⴰ ⵜⴰⴼⴰⵡⵜ ⵉ ⴷⴰⵢⴻⴽ ⵉⴵⴰⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⴷ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("LK11_36","072_11_36","LUK","11","36","36","ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵛ ⵜⴻⵛⵛⵓⵔ ⵙ ⵜⴼⴰⵡⵜ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵉⴱⴰⵔⵔⵛⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵉⵍⵉ ⵜⴼⴰⵡⵜ ⴽⵓⵍⵛⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⵎⵉ ⵢⴰⵔⴻⵇⵇ ⵍⵇⴻⵏⴷⵉⵍ ⵙ ⵓⵛⴻⵄⵄⴰⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK11_37","072_11_37","LUK","11","37","37","ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵄⴰⵔⴹ ⵉ-ⵜ ⵉⵊⵊ ⵏ ⵓⴼⴰⵔⵉⵙⵉ ⵖⴰⵔ ⵓⵎⴻⵛⵍⵉ ⴰⴽⵉⴷⴻⵙ. ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ, ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LK11_38","072_11_38","LUK","11","38","38","ⵓⵎⵉ ⵜ ⵉⵥⵔⴰ ⵓⴼⴰⵔⵉⵙⵉ, ⵉⵜⴻⴱⵀⴻⵜ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵔⴷ ⵛⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵇⴱⴻⵍ ⵉ ⵓⵎⴻⵛⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("LK11_39","072_11_39","LUK","11","39","39","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵜⴻⵙⵙⵉⵣⴷⴰⴳⴻⵎ ⴱⴰⵔⵔⴰ ⵏ ⵍⴽⴰⵙ ⴷ ⵟⵟⴻⴱⵚⵉ, ⵎⴰⵛⴰ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵡⴻⵎ ⵜⵛⵓⵔⵔⴻⵎ ⵙ ⵟⵟⵎⴻⵄ ⵏ ⵜⴽⴻⵛⵛⴰⴹⵜ ⴷ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK11_40","072_11_40","LUK","11","40","40","ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴼⵖⴰⵍ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⴳⴳⴰ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("LK11_41","072_11_41","LUK","11","41","41","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ ⴷ ⵚⵚⴻⴷⵇⴻⵜ, ⵅⵣⴰⵔ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⵡⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("LK11_42","072_11_42","LUK","11","42","42","ⵎⴰⵛⴰ ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵄⴻⵛⵛⴰⵔⴰⵎ ⵏⵏⴻⵄⵏⴰⵄ ⴷ ⵡⴰⵣⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⴱⴱⵉ, ⵎⴰⵛⴰ ⵜⴻⵊⵊⵉⵎ ⵍⵃⵓⴽⵎ ⴷ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ. ⵉⵡⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵏⵀⵍⴰ ⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵓⵎ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK11_43","072_11_43","LUK","11","43","43","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵄⵊⴻⴱ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵅ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵣⵣⴰⵜ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵓ ⵉⵄⵊⴻⴱ ⴰⵡⴻⵎ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⴻⴵⵎⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵍⴻⵙⵡⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("LK11_44","072_11_44","LUK","11","44","44","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵎ ⵢⵉⵎⴻⴹⵍⴰⵏ ⵉⴷⴷⵓⵔⵢⴻⵏ ⵎⵉⵏ ⵅⴻⴼ ⴳⴳⵓⵔⴻⵏ ⵉⵡⴷⴰⵏ ⴰⵎ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK11_45","072_11_45","LUK","11","45","45","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⴰⵇⴰ ⵅⵎⵉ ⵜⴻⵇⵇⴰⵔⴻⴷ ⴰⵢⴰ, ⵜⴻⵙⵙⴼⴻⵟⵟⴰⵃⴻⴷ ⴰⵏⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK11_46","072_11_46","LUK","11","46","46","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⴰⵔⴻⴱⴱⵓⵎ ⵍⴻⵃⵎⵓⵍ ⵉⴹⴻⵇⵍⴻⵏ ⵉ ⵜⴽⴻⵙⵙⵉⵜ ⵅ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵃⵉⴷⵉⵎ ⵍⴻⵃⵎⵓⵍ ⵏⵏⵉ ⵓⵍⴰ ⵙ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴹⴻⵡⴹⴰⵏ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LK11_47","072_11_47","LUK","11","47","47","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴱⴻⵏⵏⴰⵎ ⵉⵎⴻⴹⵍⴰⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵏⵖⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK11_48","072_11_48","LUK","11","48","48","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⵏⴻⵄⵄⵎⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴻⵟⵟⴰⵎ ⵙ ⵎⵉⵏ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵏⵖⵉⵏ ⵜⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴱⴻⵏⵏⴰⵎ ⵉⵎⴻⴹⵍⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK11_49","072_11_49","LUK","11","49","49","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵏⵏⴰ: “ⴰⵇⴰ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵔⵔⵓⵙⵓⵍ. ⴰⴷ ⴰⵥⵥⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK11_50","072_11_50","LUK","11","50","50","ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵜⵜⴰⵔⴻⵏ ⵣⵉ ⵊⵊⵉⵍ-ⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵣⵍⴻⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ: ");
INSERT INTO rift_vpl VALUES ("LK11_51","072_11_51","LUK","11","51","51","ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵀⴰⴱⵉⵍ ⴰⵍ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵣⴰⴽⴰⵔⵉⵢⵢⴰ, ⵡⴻⵏⵏⵉ ⵏⵖⵉⵏ ⵊⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵓⵄⴰⵍⵟⴰⵔ! ⵡⴰⵀ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⴱⴻⵍⵍⵉ ⴳⴳⵓⵔ ⴰⴷ ⵜⵜⵡⴰⵜⵜⴰⵔⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵣⵉ ⵊⵊⵉⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LK11_52","072_11_52","LUK","11","52","52","ⵓⵛⵜ ⵅⴰⵡⴻⵎ, ⴰ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴽⴻⵙⵙⵉⵎ ⵜⵉⵙⴰⵔⵓⵜⵉⵏ ⵏ ⵜⵓⵙⵙⵏⴰ. ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⵓ ⵉⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ, ⵜᵉⵟⵟⴼⴻⵎ ⵜⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK11_53","072_11_53","LUK","11","53","53","ⴰⵎ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵓⵢⴰ, ⴱⴷⴰⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵜⵜⴹⴰⴷⴷⴰⵏ ⵜ ⴰⵟⵟⴰⵙ. ⴼⴼⵓⴳⵎⴻⵏ, ⵃⴻⵛⵛⴻⵏ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK11_54","072_11_54","LUK","11","54","54","ⵓⵛⴰ ⴳⴳⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵙ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ ⴰⵟⵟⴰⵙ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⵙ ⵛⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴹⴻⵍⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK12_1","072_12_1","LUK","12","1","1","ⵓⵎⵉ ⵎⵓⵏⴻⵏ ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵍⵖⴰⵛⵉ ⵙ ⵡⴰⵟⵟⴰⵙ, ⴰⵍⴰⵎⵉ ⴱⴷⴰⵏ ⵄⵍⴰⵢⴻⵏ ⵄⴻⴼⴼⵙⴻⵏ ⵉⵊⵊ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⴱⴷⴰ ⵉⵇⵇⴰⵔ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵡⴻⵏⵜⵓⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵉⴼⴰⵇ! ");
INSERT INTO rift_vpl VALUES ("LK12_2","072_12_2","LUK","12","2","2","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⴷⵍⵉⵏ, ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⵉⵙⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK12_3","072_12_3","LUK","12","3","3","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵏⵏⴰⵎ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍ ⴷⵉ ⵜⴼⴰⵡⵜ, ⵓ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⴷⴻⴳ ⵓⵎⴻⵣⵣⵓⵖ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⴷⴰⵅⴻⵍ, ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵣⵣⴰⵢⴻⵙ ⵅ ⵜⵣⴻⵖⵡⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK12_4","072_12_4","LUK","12","4","4","“ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ: ⵡⴰⵔ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⴽⵜⴰⵔ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LK12_5","072_12_5","LUK","12","5","5","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵡⴻⵏⵏⵉ ⵣⵉ ⵖⴰ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ: ⴳⴳⵯⴻⴷⴻⵎ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵚⵚⵓⵍⵟⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⴹⴰⵔ ⴷⵉ ⵊᵉⵀⴻⵏⵏⴰⵎⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵖⴰ. ⵡⴰⵀ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵣⴻⴳ ⵡⴰⵏⵉⵜⴰ ⵉ ⵖⴰ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LK12_6","072_12_6","LUK","12","6","6","ⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵏⵣⵉⵏ ⵅⴻⵎⵙⴰ ⵏ ⵥⵥⴰⵡⴻⵛ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵚⵓⵍⴷⵉⵢⵢⴻⵏ ⵏ ⵏⵏⵃⴰⵙ? ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⴰⵜⵜⵓ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK12_7","072_12_7","LUK","12","7","7","ⵎⴰⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ, ⵄⴰⴷ ⵉⵥⵓⵟⵟⴰⵏ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵡⴻⵎ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ, ⴽⴻⵏⵏⵉⵡ ⵃⵙⴻⵏ ⵣⵉ ⵥⵥⴰⵡⴻⵛ ⴰⵟⵟⴰⵙ!”    ");
INSERT INTO rift_vpl VALUES ("LK12_8","072_12_8","LUK","12","8","8","“ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵔⵔⴰ ⵡⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵉⵛⴻⵀⴷⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⵡⴷⴰⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵀⴻⴷ ⵄⴰⵡⴻⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK12_9","072_12_9","LUK","12","9","9","ⵎⴰⵛⴰ ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵏⴽⴰⵔⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴽⴰⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK12_10","072_12_10","LUK","12","10","10","ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵉⵏ ⴰⵡⴰⵍ ⴹⵉⴷⴷ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵎⴰⵏ ⴰⵢⴰ. ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵇⵇⴼⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵜⵜᵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK12_11","072_12_11","LUK","12","11","11","“ⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ, ⵣⵣⴰⵜ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ, ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵛⴰ ⵙ ⵡⴻⵎⵏⵓⵙ ⵎⵉⵏ ⵣⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵔⴻⵎ ⵏⵉⵖ ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("LK12_12","072_12_12","LUK","12","12","12","ⵎⵉⵏⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK12_13","072_12_13","LUK","12","13","13","ⵉⵏⵏⴰ ⴰⵙ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⵖⴰⵛⵉ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵉⵏⵉ ⴰⵙ ⵉ ⵓⵎⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵉ ⵉⴱⴹⴰ ⵍⵡⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK12_14","072_12_14","LUK","12","14","14","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴱⵏⴰⴷⴻⵎ, ⵡⵉ ⴷ ⴰⵢⵉ ⵢⴰⵔⵔⵉⵏ ⵅⴰⵡⴻⵎ ⴷ ⵍⵇⴰⴹⵉ ⵏⵉⵖ ⴷ ⵍⵄⴰⴷⴻⵍ?” ");
INSERT INTO rift_vpl VALUES ("LK12_15","072_12_15","LUK","12","15","15","ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵖⴰⵔⵡⴻⵎ, ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵉ ⵟⵟⵎⴻⵄ, ⵎⴰⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷⴻⴳ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵡⴰⴳⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK12_16","072_12_16","LUK","12","16","16","ⵅⴰⵙ ⵓⵛⴰ ⵉⵃⴰⵊⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ: “ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵜⵉⵡⵢⵉ ⴰⵙ-ⴷⴷ ⵚⵚⴰⴱⴻⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK12_17","072_12_17","LUK","12","17","17","ⵉⵅⴰⵔⵔⴻⵚ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ: ‘ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ?, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵍⵎⴰⵔⵙⵉ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("LK12_18","072_12_18","LUK","12","18","18","ⵉⵏⵏⴰ: ‘ⴰⵎⵎⵓ ⵉ ⵖⴰ ⴳⴳⴻⵖ: ⴰⴷ ⵀⴻⴷⵎⴻⵖ ⵍⴻⵎⵔⴰⵙⵉ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴱⵏⵉⵖ ⵍⴻⵎⵔⴰⵙⵉ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵅⴻⵣⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵍⵖⵉⴵⴻⵜ ⴷ ⵡⴰⴳⵍⴰ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK12_19","072_12_19","LUK","12","19","19","ⴰⴷ ⵉⵏⵉⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ: ‘ⴰ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ, ⵖⴰⵔⴻⴽ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ ⵉ ⵉⵜⵜⵡⴰⵅⵣⴻⵏ ⴷⵉⵏ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⴰⵔⴻⵢⵢⴻⵃ, ⵜⴻⵛⵛⴻⴷ, ⵜⴻⵙⵡⴻⴷ ⵓ ⵜⴼⴰⵔⵃⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("LK12_20","072_12_20","LUK","12","20","20","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⴻⴱⴱⵉ: ‘ⴰ ⴰⴼⵖⵓⵍ, ⴰⵇⴰ ⴵⵉⵍⴻⵜ-ⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵜⵜⵡⴰⵜⵜⴰⵔ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ. ⵅⴻⵏⵏⵉ ⵉ ⵓⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⵉⵏ ⵜⴻⵙⵙⵡⴻⵊⴷⴻⴷ?’ ");
INSERT INTO rift_vpl VALUES ("LK12_21","072_12_21","LUK","12","21","21","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ ⵉ ⵡⴻⵏⵏⵉ ⵉⵢⴰⵔⵔⵡⴻⵏ ⵍⴻⴽⵏⵓⵣ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK12_22","072_12_22","LUK","12","22","22","ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵙ ⵡⴻⵎⵏⵓⵙ ⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ ⵎⵉⵏ ⵖⴰ ⵜⴻⵛⵛⴻⵎ, ⵓⵍⴰ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵎⵉⵏ ⵖⴰ ⵜⵢⴰⵔⴹⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK12_23","072_12_23","LUK","12","23","23","ⵍⴻⵄⵎⴰⵔ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵛⵛⴰ ⵓ ⴰⵔⵔⵉⵎⴻⵜ ⴽⵜⴰⵔ ⵣⴻⴳ ⵡⴻⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("LK12_24","072_12_24","LUK","12","24","24","ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵉⴱⴰⵖⵍⵉⵡⴻⵏ! ⴰⵇⴰ ⵡⴰⵔ ⵣⴰⵔⵔⵄⴻⵏ, ⵡⴰⵔ ⵎⴻⵊⵊⴰⵔⴻⵏ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵙⵔⴰⴼⵉⵏ ⵏⵉⵖ ⴷ ⵍⴻⵎⵔⴰⵙⵉ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵛⵛⴰ ⵉ-ⵜⴻⵏ. ⵎⴻⵛⵃⴰⵍ ⴰⵟⵟⴰⵙ ⵜⵙⴻⴽⴽⵡⵉⵎ ⴽⴻⵏⵏⵉⵡ ⴽⵜⴰⵔ ⵅ ⵉⵊⴹⴰⴹ! ");
INSERT INTO rift_vpl VALUES ("LK12_25","072_12_25","LUK","12","25","25","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵣⴻⵎⵎⴰⵔ ⵙ ⵡⴻⵎⵏⵓⵙ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⵔⵏⵉ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⵉⵍ ⵡⴰⵀⴰ? ");
INSERT INTO rift_vpl VALUES ("LK12_26","072_12_26","LUK","12","26","26","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⵓⵍⴰ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵥⵢⴰⵏ ⵇⴰⵄ, ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⴽⵙⵉⵎ ⵙ ⵡⴻⵎⵏⵓⵙ ⵅ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK12_27","072_12_27","LUK","12","27","27","“ⵅⵣⴰⵔⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴻⵎⵎⵢⴻⵏⵜ ⵜⵍⵉⵍⵍⵉⵛⵉⵏ! ⵡⴰⵔ ⵅⴻⴷⴷⵎⴻⵏⵜ, ⵡⴰⵔ ⵜⵜⵇⴰⵔⴻⴹⵛⴻⵏⵜ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵙⵓⵍⵉⵎⴰⵏ ⴷⵉ ⵇⴰⵄ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵡⴰⵔ ⵢⴰⵔⴹ ⵛⴰ ⴰⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK12_28","072_12_28","LUK","12","28","28","ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵢⴰⵔⴹ ⴰⵎⵎⵓ ⴰⵔⴱⵉⵄ ⵉ ⵉⴵⴰⵏ ⴰⵙⵙ-ⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵜⴻⴼⵇⵓⵏⵜ, ⵎⴻⵛⵃⴰⵍ ⵉⵃⵍⴰ ⴰⵟⵟⴰⵙ ⴰⴷ ⵉⵙⵙⵢⴰⵔⴹ ⵏⴻⵜⵜⴰ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷⵉ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵍ’ⵉⵎⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK12_29","072_12_29","LUK","12","29","29","“ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵎ ⵛⴰ ⵅ ⵎⵉⵏ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⵓⵍⴰ ⵅ ⵎⵉⵏ ⵖⴰ ⵜⴻⵙⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵖⴻⴼⵍⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK12_30","072_12_30","LUK","12","30","30","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴷⴰⵢⵙⴻⵏⵜ ⵍⴻⴳⵏⵓⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⴱⴰⴱⴰⵜⵡⴻⵎ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵜⴻⵃⴷⴰⵊⴻⵎ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK12_31","072_12_31","LUK","12","31","31","ⵎⴰⵛⴰ ⴰⵔⵣⵓⵎ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵜⵡⴰⵎⵎⴰⵔⵏⵉⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK12_32","072_12_32","LUK","12","32","32","“ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵛⴻⵎ, ⴰ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ, ⵎⵉⵏⵣⵉ ⵢⴰⵔⴹⴰ ⴱⴰⴱⴰⵜⵡⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵜⴰⴳⴻⵍⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LK12_33","072_12_33","LUK","12","33","33","ⵣⴻⵏⵣⴻⵎ ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ, ⵡⵛⴻⵎ ⵚⵚⴻⴷⵇⴻⵜ! ⴳⴳⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵜⵉⵛⵢⴰⵔⵉⵏ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵛⵛⵉⵏ, ⵓⵛⴰ ⵅⴻⵎⵎⵍⴻⵎ ⵉⵊⵊ ⵏ ⵍⴽⴻⵏⵣ ⵉ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵉⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴻⴼ ⵓⵛⴻⴼⴼⴰⵔ ⵓⵍⴰ ⴷ ⵜⵛⵉⵏⴷⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳ ⵙⵙⵓⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("LK12_34","072_12_34","LUK","12","34","34","ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵖⴰ ⵢⵉⵍⵉ ⵍⴽⴻⵏⵣ ⵏⵡⴻⵎ, ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ ⵡⵓⵍ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK12_35","072_12_35","LUK","12","35","35","“ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵡⴻⵎ ⵃⴻⵣⵣⵎⴻⵎⵜ ⵙ ⵉⴱⵓⵢⴰⵙ ⵓ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵡⴻⵎ ⴰⵔⴻⵇⵇⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK12_36","072_12_36","LUK","12","36","36","ⵉⵍⵉⵎ ⴰⵎ ⵉⵡⴷⴰⵏ ⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⵙⵉⴷⵉ ⵏⵙⴻⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴻⵄⵇⴻⴱ ⵣⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵡⵓⵔⴰⵔ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ, ⴰⴷ ⵉⵙⵙⵇⴰⵔⵇⴻⴱ, ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⴰⵔⵣⵎⴻⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK12_37","072_12_37","LUK","12","37","37","ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉⵜⵙⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵢⴰⴼ ⴼⴰⵇⴻⵏ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴰⴷ ⵉⵃⴻⵣⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵖⵉⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK12_38","072_12_38","LUK","12","38","38","ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵃⴻⵟⵟⵓ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵏⵉⵖ ⵖⴰⵔ ⵃⴻⵟⵟⵓ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⴰⵎⵎⵓ, ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK12_39","072_12_39","LUK","12","39","39","ⵎⴰⵛⴰ ⵙⵙⵏⴻⵎ ⴰⵢⴰ: ⵎⴰⵍⴰ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵙⵙⴻⵏ ⴷⵉ ⵎⴰⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵖⴰ ⵉⵅⴻⵛⵛ ⵓⵛⴻⴼⴼⴰⵔ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⴼⴰⵇ, ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴷ ⵜⵜ ⴰⵛⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK12_40","072_12_40","LUK","12","40","40","ⵉⵍⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⵜⵡⴻⵊⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵔⵉⵊⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK12_41","072_12_41","LUK","12","41","41","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰ ⵉ ⵏⴻⵛⵛⵉⵏ ⵉ ⵜⵄⴰⵡⴷⴻⴷ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ ⵏⵉⵖ ⵉ ⵎⴰⵔⵔⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK12_42","072_12_42","LUK","12","42","42","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⵅⴻⵏⵏⵉ ⴷ ⴰⵡⴽⵉⵍ ⴰⵎⵉⵖⵉⵙ ⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵎⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵙⵉⴷⵉⵙ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵍⴻⵄⵡⴻⵍⵜ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("LK12_43","072_12_43","LUK","12","43","43","ⵙⵙⴻⵄⴷ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴼ ⵙⵉⴷⵉ ⵏⵏⴻⵙ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ, ⵉⵜⵜⴻⴳⴳ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("LK12_44","072_12_44","LUK","12","44","44","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⴰⴷ ⵜ ⵢⴻⴳⴳ ⵅ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK12_45","072_12_45","LUK","12","45","45","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⴰⴷ ⵢⵉⵏⵉ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: ‘ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉⵄⴻⵟⵟⴰⵍ ⵅ ⵡⴻⵄⵇⴰⴱ!’, ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵛⵛⴰⵜ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷ ⵜⵉⵢⵢⴰ, ⵉⵜⵜⴻⵜⵜ, ⵉⵙⴻⵙⵙ, ⵉⵙⵛⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("LK12_46","072_12_46","LUK","12","46","46","ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵙⵉⴷⵉ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵡⴰⵔ ⵉⵜⵜⵔⵉⵊⵉ ⵓ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏ. ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵜ ⵉⵇⴻⵟⵟⴻⵙ ⴷ ⵉⵛⴻⴵⵉⵇⴻⵏ, ⴰⴷ ⵉⴳⴳ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK12_47","072_12_47","LUK","12","47","47","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵍⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⴻⵙ, ⴰⴷ ⵉⴽⵙⵉ ⵜⵉⵢⵢⵉⵜⴰ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK12_48","072_12_48","LUK","12","48","48","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⴻⵙ ⴰⵎ ⵉⴳⴳⴰ ⵛⴰ ⵎⵉⵏ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵜⵉⵢⵢⵉⵜⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⵡⵡⴻⵜ ⵙ ⴷⵔⵓⵙ ⵏ ⵜⵉⵢⵢⵉⵜⴰ. ⵣⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵓⵎⵉ ⵉⵎⵎⴻⵡⵛ ⴰⵟⵟⴰⵙ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵜⵜⴰⵔ ⴰⵟⵟⴰⵙ, ⵓ ⵡⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴽⴻⵍⵍⴻⴼ ⴰⵟⵟⴰⵙ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵜⵜⴰⵔ ⴽⵜⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LK12_49","072_12_49","LUK","12","49","49","“ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵏⴹⴰⵔⴻⵖ ⵜⵉⵎⴻⵙⵙⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵔⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("LK12_50","072_12_50","LUK","12","50","50","ⵎⴰⵛⴰ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵓⵙⴻⵖⴹⴻⵚ ⵉ ⵣⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵖ, ⵓ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⴰⵟⵟⴰⵙ ⴰⵍ ⴷ ⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LK12_51","072_12_51","LUK","12","51","51","ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴱⴻⵍⵍⵉ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵍⴻⵀⵏⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ? ⵍⵍⴰ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴱⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("LK12_52","072_12_52","LUK","12","52","52","ⵎⵉⵏⵣⵉ ⵣⵉ ⵍⴻⵅⵅⵓ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴷ ⵎⵎⵙⴻⴱⴹⴰⵏ ⵅⴻⵎⵙⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵍⴰⵜⴰ ⴹⵉⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵓ ⵜⵏⴰⵢⴻⵏ ⴹⵉⴷⴷ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LK12_53","072_12_53","LUK","12","53","53","ⴱⴰⴱⴰⵙ ⴰⴷ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅ ⵎⵎⵉⵙ, ⵓ ⵎⵎⵉⵙ ⵅ ⴱⴰⴱⴰⵙ, ⵓ ⵢⴻⵎⵎⴰⵙ ⵅ ⵢⴻⴵⵉⵙ, ⵓ ⵢⴻⴵⵉⵙ ⵅ ⵢⴻⵎⵎⴰⵙ, ⵓ ⵍⴰⵍⵍⴰⵙ ⵅ ⵜⴻⵙⵍⵉⵜ, ⵓ ⵜⴰⵙⵍⵉⵜ ⵅ ⵍⴰⵍⵍⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK12_54","072_12_54","LUK","12","54","54","ⵉⵏⵏⴰ ⵉ ⵍⵖⴰⵛⵉ: “ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵍⵖⴰⵔⴱ, ⴷⴻⵖⵢⴰ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵏⵥⴰⵔ!’ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("LK12_55","072_12_55","LUK","12","55","55","ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵍⵊⴰⵏⵓⴱ ⵉⵜⵜⵙⵓⴹ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵃⵎⵓ!’, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK12_56","072_12_56","LUK","12","56","56","ⴰ ⵉⵎⵏⴰⴼⵇⴻⵏ, ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⴷ ⵜⵎⴻⵢⵢⵣⴻⵎ ⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵊⴻⵏⵏⴰ. ⵎⴰ ⵣⵣⵎⴰⵏ-ⴰ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵜⵎⴻⵢⵢⵣⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("LK12_57","072_12_57","LUK","12","57","57","“ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵃⴻⴽⴽⵎⴻⵎ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵚⵚⴰⵃ? ");
INSERT INTO rift_vpl VALUES ("LK12_58","072_12_58","LUK","12","58","58","ⵎⵉⵏⵣⵉ, ⵅⵎⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵍⵃⴰⴽⴻⵎ ⴰⴽ-ⴷ ⵡⴻⵖⵔⵉⵎ ⵏⵏⴻⵛ, ⴻⴳⴳ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴰⵎ ⵜⴻⴵⵉⴷ ⵄⴰⴷ ⴰⴽⵉⵙ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⴷ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⵊⴰⵔⵔⵉ ⵖⴰⵔ ⵍⵇⴰⴹⵉ ⵓⵛⴰ ⵍⵇⴰⴹⵉ ⴰⴷ ⵛⴻⴽ ⵉⵙⴻⵍⵍⴻⵎ ⵉ ⵡⴻⵎⵅⴰⵣⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵉⵏⴹⴰⵔ ⵓⵎⵅⴰⵣⵏⵉ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK12_59","072_12_59","LUK","12","59","59","ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⵛⴻⴽ ⵡⴰⵔ ⴷⴷ ⵙⵙⴻⵏⵏⵉ ⵜᵉⵜⵜⴻⴼⴼⵖⴻⴷ ⴰⵍ ⵖⴰ ⵜⵅⴻⴵⵚⴻⴷ ⴰⵚⵓⵍⴷⵉ ⴰⵏⴻⴳⴳⴰⵔⵓ!” ");
INSERT INTO rift_vpl VALUES ("LK13_1","072_13_1","LUK","13","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜ ⵅ ⵉⵊⴰⵍⵉⵍⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵅⴻⴵⴻⴹ ⴱⵉⵍⴰⵟⵓⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵖⴰⵔⵚⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK13_2","072_13_2","LUK","13","2","2","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴱⴻⵍⵍⵉ ⵉⵊⴰⵍⵉⵍⵉⵢⵢⴻⵏ-ⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵊⴰⵍⵉⵍⵉⵢⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴰⵔ ⵓⵡⴻⴷⴷⴻⴱ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("LK13_3","072_13_3","LUK","13","3","3","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵍⵍⴰ! ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵎ ⵏⵉⵜⵏⵉ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵓⴱⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK13_4","072_13_4","LUK","13","4","4","ⵓ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵡⴷⴰⵏ ⵉ ⵅⴻⴼ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵚⵚⵓⵎⵄⴻⵜ ⴷⵉ ⵙⵉⵍⵓⵡⴰⵎ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ? ");
INSERT INTO rift_vpl VALUES ("LK13_5","072_13_5","LUK","13","5","5","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵍⵍⴰ! ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵎ ⵏⵉⵜⵏⵉ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵓⴱⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("LK13_6","072_13_6","LUK","13","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ: “ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵊⵊ ⵏ ⵡⴰⵔⵜⵓ ⵉ ⵉⵜⵜⵡⴰⵥⵥⵓⵏ ⴷⴻⴳ ⵓⵎⴰⵔⵊⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⴹⵉⵍ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ, ⵢⴰⵔⴻⵣⵣⵓ ⴷⴰⵢⴻⵙ ⵜⴰⵣⴰⵔⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵢⵓⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("LK13_7","072_13_7","LUK","13","7","7","ⵉⵏⵏⴰ ⵉ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ: ‘ⴰⵇⴰ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵜⵜⴰⵙⴻⵖ-ⴷⴷ, ⴰⵔⴻⵣⵣⵓⵖ ⵜⴰⵣⴰⵔⵜ ⴷⴻⴳ ⵡⴰⵔⵜⵓ-ⵢⴰ, ⵡⴰⵔ ⵜⵜ ⵓⴼⵉⵖ. ⵇⴻⵙⵙ ⵉ-ⵜⵜ ⵅⴻⵏⵏⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵙⵙⴰⵃⴰⵍ ⵄⴰⴷ ⵜⴰⵎⵎⵓⵔⵜ?’ ");
INSERT INTO rift_vpl VALUES ("LK13_8","072_13_8","LUK","13","8","8","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵓⴼⴻⴵⴰⵃ: ‘ⴰ ⵙⵉⴷⵉ, ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⴱⴻⴷⴷ ⵄⴰⴷ ⴰⵙⴻⴳⴳⵯⴰⵙ-ⴰ. ⴰⴷ ⵜⵜ ⵖⵣⵉⵖ, ⵓ ⴰⴷ ⴰⵙ ⴳⴳⴻⵖ ⵍⴻⵖⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK13_9","072_13_9","LUK","13","9","9","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜⴰⵔⵔ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵍⴰ ⵍⵍⴰ, ⵅⴻⵏⵏⵉ ⵇⴻⵙⵙ ⵉ-ⵜⵜ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("LK13_10","072_13_10","LUK","13","10","10","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⴷⵉ ⵙⵙⴻⴱⵜ, ");
INSERT INTO rift_vpl VALUES ("LK13_11","072_13_11","LUK","13","11","11","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵉⴹⵄⴻⴼ ⴱⵓⵃⴱⴻⵍ ⵏⵏⴻⵙ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵜⵓⵖⴰ ⵜⴻⵇⵡⴻⵙ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵙⴻⴳⴳⴻⵎ ⴰⵄⵔⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("LK13_12","072_13_12","LUK","13","12","12","ⵓⵎⵉ ⵜⵜ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵙ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⴰⵇⴰ ⵛⴻⵎ ⵜⴻⵏⴼⴻⴽⴽⴻⴷ ⵣⵉ ⵜⵓⴹⵄⴻⴼⵜ ⵏⵏⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("LK13_13","072_13_13","LUK","13","13","13","ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⴷⵡⴻⵍ ⵜⵙⴻⴳⴳⴻⵎ ⵍⴻⵅⴷⴻⵏⵏⵉ, ⵜⴻⴱⴷⴰ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("LK13_14","072_13_14","LUK","13","14","14","ⵎⴰⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵓⵎⵉ ⵉⵅⴻⵢⵢⴻⵇ, ⵎⵉⵏⵣⵉ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉⵊⵊⴻⵏ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵍⵖⴰⵛⵉ: “ⴰⵇⴰ ⴷⵉ ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵍⵅⴻⴷⵎⴻⵜ, ⴰⵙⴻⵎ-ⴷⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ!” ");
INSERT INTO rift_vpl VALUES ("LK13_15","072_13_15","LUK","13","15","15","ⵎⴰⵛⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵛⴻⴽ, ⴰⵎⵏⴰⴼⴻⵇ! ⵎⴰ ⵡⴰⵔ ⵉⴼⴻⵙⵙⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴷⵉ ⵙⵙⴻⴱⵜ ⵉ ⵓⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ ⵏⵉⵖ ⵉ ⵡⴻⵖⵢⵓⵍ ⵏⵏⴻⵙ ⵣⵉ ⵍⵎⴻⴷⵡⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⵉⵏⴷⴻⵀ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵡⴰⵔⴷ? ");
INSERT INTO rift_vpl VALUES ("LK13_16","072_13_16","LUK","13","16","16","ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⴰⵇⴰ-ⵜⵜ ⴷ ⵢⴻⴵⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵜⴻⵏⵏⵉ ⵉⵛⴻⴷⴷ ⵉⴱⵍⵉⵙ, ⵅⵣⴰⵔ, ⵄⴰⴷ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵎⴻⵏⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⴻⴳ ⵓⵛⴻⴷⴷⵉ-ⵢⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ?” ");
INSERT INTO rift_vpl VALUES ("LK13_17","072_13_17","LUK","13","17","17","ⴰⵎ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵙⴻⴹⵃⴰⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵜⵜⴻⵎⵄⴰⵍⴰⵏ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵉⴼⴰⵔⵃ ⵣⵉ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK13_18","072_13_18","LUK","13","18","18","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷⵉ ⵜⴰⵔⵡⴻⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵎⵉⵏ ⵣⵉ ⵜⵜ ⵖⴰ ⵙⵙⴻⵎⵇⵓⴷⴷⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("LK13_19","072_13_19","LUK","13","19","19","ⴰⵇⴰ-ⵜⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⵅⴻⵔⴷⴻⵍ ⵉⴽⵙⵉ ⵜⵜ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵏⴹⴰⵔ ⵉ-ⵜⵜ ⴷⵉ ⵜⴻⵃⵡⵉⵛⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⴻⵖⵎⵉ-ⴷⴷ, ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵜⴻⵎⵖⴰⵔ ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ ⵍⴻⵄⵡⴰⵛⵛ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⴼⵔⵓⵄ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK13_20","072_13_20","LUK","13","20","20","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵙ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵙⵙⴻⵎⵇⵓⴷⴷⴻⵖ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("LK13_21","072_13_21","LUK","13","21","21","ⴰⵇⴰ-ⵜⵜ ⴰⵎ ⵡⴻⵏⵜⵓⵏ, ⵜⴻⵢⵙⵉ ⵜ ⵜⴻⵎⵖⴰⵔⵜ, ⵜⴻⴼⴼⴰⵔ ⵉ-ⵜ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵎⴷⵓⴷ ⵏ ⵡⴰⵔⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⵙⵙⵎⴻⵎⵎ ⵎⴰⵔⵔⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK13_22","072_13_22","LUK","13","22","22","ⵉⵥⵡⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴷ ⴷⵛⵓⵔⴰⵜ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ, ⵉⴳⴳⵓⵔ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ.    ");
INSERT INTO rift_vpl VALUES ("LK13_23","072_13_23","LUK","13","23","23","ⵉⵊⵊⴻⵏ ⵉⵙⵙⴻⵇⵙⴰ ⵉ-ⵜ, ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⴷⵔⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵟⵟⴼⴻⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LK13_24","072_13_24","LUK","13","24","24","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴳⴳⴻⵎ ⵊⵊⴻⵀⴷ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴷⴼⴻⵎ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵉⵃⵚⴰⵔⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵟⵟⴰⵙ ⴰⴷ ⴰⵔⵣⵓⵏ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK13_25","072_13_25","LUK","13","25","25","ⵣⴻⴳ ⵡⴰⵎⵉ ⵉ ⵖⴰ ⵉⴽⴽⴰⵔ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⴻⵍⵍⴻⵄ ⵜⴰⵡⵡⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⴷⵉ ⴱⴰⵔⵔⴰ, ⴰⴷ ⵜⴻⵙⵙⵇⴰⵔⴻⵇⴱⴻⵎ, ⴰⴷ ⵜⴻⴱⴷⴰⵎ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵔⵣⴻⵎ ⴰⵏⴻⵖ!’ ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵔⵔ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⵏⴻⵖ, ⵎⴰⵏⵉⵙ ⴽⴻⵏⵏⵉⵡ?’ ");
INSERT INTO rift_vpl VALUES ("LK13_26","072_13_26","LUK","13","26","26","ⴰⴷ ⵜⴻⴱⴷⴰⵎ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⵏⴻⵛⵛⵉⵏ ⴰⵃⴻⵇⵇⴰ ⵜⵓⵖⴰ ⵏⴻⵛⵛⴰ ⵏⴻⵙⵡⴰ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵛⴻⴽ ⵜⵓⵖⴰ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⴷⴻⴳ ⵉⵎⴻⵙⵔⴰⵇ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("LK13_27","072_13_27","LUK","13","27","27","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵏⵉ: ‘ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⵏⴻⵖ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵏⵉⵙ ⴽⴻⵏⵏⵉⵡ! ⴰⴳⴳⵯⴻⵊⴻⵎ ⵅⴰⴼⵉ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ!’ ");
INSERT INTO rift_vpl VALUES ("LK13_28","072_13_28","LUK","13","28","28","ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵜⵖⵓⵢⵢⵉⵜ ⴷ ⵓⵖⴻⵣⵣⵉ ⵏ ⵜⴻⵖⵎⴰⵙ, ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⵎ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK13_29","072_13_29","LUK","13","29","29","ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵓ ⵣⵉ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ ⵓⵍⴰ ⵣⵉ ⵛⵛⴰⵎⴰⵍ ⵓⵍⴰ ⵣⵉ ⵍⵊⴰⵏⵓⴱ, ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK13_30","072_13_30","LUK","13","30","30","ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷ ⵉⵏⴻⴳⴳⵓⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK13_31","072_13_31","LUK","13","31","31","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵇⴰⵔⵔⴱⴻⵏ-ⴷⴷ ⵛⴰ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴼⴼⴻⵖ, ⵔⵓⵃ ⵙⵙⴰ, ⵎⵉⵏⵣⵉ ⵀⵉⵔⵓⴷⵓⵙ ⵉⵅⵙ ⴰⴷ ⵛⴻⴽ ⵉⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("LK13_32","072_13_32","LUK","13","32","32","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵉⵏⵉⵎ ⴰⵙ ⵉ ⵡⴻⵛⵄⴻⴱ-ⴰ: ‘ⵅⵥⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⵛⵡⴰⵟⴻⵏ, ⵙⵙⴳⴻⵏⴼⵉⵖ ⴰⵙⵙ-ⴰ ⴷ ⵜⵉⵡⴻⵛⵛⴰ, ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK13_33","072_13_33","LUK","13","33","33","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵅⴻⴷⵎⴻⵖ ⴰⵙⵙ-ⴰ ⴷ ⵜⵉⵡⴻⵛⵛⴰ, ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⴰⴷ ⵔⴰⵃⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⴱⴰⵔⵔⴰ ⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK13_34","072_13_34","LUK","13","34","34","ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⴰ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴻⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵜⴻⵏⵏⵉ ⵢⴰⵔⴻⵊⵊⵎⴻⵏ ⵉⵏⵏⵉ ⵉ ⵖⴰⵔⴻⵎ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵖ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵎⵓⵏⴰ ⵜⵢⴰⵥⵉⴹⵜ ⵉⴼⵉⴵⵓⵙⴻⵏ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵅⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK13_35","072_13_35","LUK","13","35","35","ⵅⵣⴰⵔ, ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⵜⴻⵇⵇⵉⵎ ⴷ ⵍⵅⴰⵔⴱⴻⵜ. ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔⴻⵎ ⴰⵍ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⵉⵏⵉⵎ: ‘ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ’.” ");
INSERT INTO rift_vpl VALUES ("LK14_1","072_14_1","LUK","14","1","1","ⵍⴰⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛ ⴰⵖⵔⵓⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵜⵓⵖⴰ ⵃⴻⵟⵟⴰⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK14_2","072_14_2","LUK","14","2","2","ⵓ ⵅⵣⴰⵔ, ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵀⵍⴻⵛ ⵙ ⵜⵓⴼⴼⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK14_3","072_14_3","LUK","14","3","3","ⵉⵟⵟⴻⴼ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵉⵏⵏⴰ: “ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⵓⵙⴳⴻⵏⴼⵉ ⴷⵉ ⵙⵙⴻⴱⵜ?” ");
INSERT INTO rift_vpl VALUES ("LK14_4","072_14_4","LUK","14","4","4","ⵏⵉⵜⵏⵉ ⵙⵇⴰⵔⴻⵏ ⵡⴰⵀⴰ. ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵉ-ⵜ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵉⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LK14_5","072_14_5","LUK","14","5","5","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵏⵏⴰ: “ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰⵍⴰ ⵎⵎⵉⵙ ⵏⵉⵖ ⴰⴼⵓⵏⴰⵙ ⵏⵏⴻⵙ ⵉⵡⴹⴰ ⴰⵙ ⴷⴻⴳ ⵡⴰⵏⵓ, ⵡⴰⵔ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵓⴼⴼⵓⵖ ⵣⵣⴰⵢⴻⵙ ⴷⴻⵖⵢⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ?” ");
INSERT INTO rift_vpl VALUES ("LK14_6","072_14_6","LUK","14","6","6","ⵡⴰⵔ ⵓⴼⵉⵏ ⵙ ⵎⵉⵏ ⵣⵉ ⵅⴰⵙ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK14_7","072_14_7","LUK","14","7","7","ⵉⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵉ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵉⵃⴻⴽⴽⴰⵔ ⵉⵅⴹⴰⵔⴻⵏ ⵉⵎⵓⵛⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("LK14_8","072_14_8","LUK","14","8","8","“ⵎⴰⵍⴰ ⵉⵄⴰⵔⴹ ⵃⴻⴷ ⵉ ⵛⴻⴽ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⵓⵔⴰⵔ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵄⴰⵔⴹ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵅⴰⴽ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LK14_9","072_14_9","LUK","14","9","9","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⵄⴰⵔⴹⴻⵏ, ⴰⴷ ⴰⵛ ⵢⵉⵏⵉ: ‘ⴻⴳⴳ ⴰⵎⵛⴰⵏ ⵉ ⵡⴻⵔⵢⴰⵣ-ⴰ!’, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵙⴻⴹⵃⵉⴷ, ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⵎⵛⴰⵏ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("LK14_10","072_14_10","LUK","14","10","10","ⵎⴰⵍⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⴷ, ⵔⵓⵃ, ⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⴰⵏⴻⴳⴳⴰⵔⵓ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⴷⴻⴼ ⵡⴻⵏⵏⵉ ⵅⴰⴽ ⵉⵄⴰⵔⴹⴻⵏ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⴰⵛ ⵢⵉⵏⵉ: ‘ⴰ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ, ⴳⴻⵄⵄⴻⴷ, ⵇⵇⵉⵎ!’ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⵛⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK14_11","072_14_11","LUK","14","11","11","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵙⵙⵓⵄⵍⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵡⴰⴹⴻⵄ ⵓ ⵡⵉ ⵖⴰ ⵉⵙⵙⵡⴰⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK14_12","072_14_12","LUK","14","12","12","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⵄⴰⵔⴹⴻⵏ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵛⵍⵉ ⵏⵉⵖ ⴰⵎⴻⵏⵙⵉ, ⵡⴰⵔ ⵄⴰⵔⵔⴻⴹ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵛ ⵏⵉⵖ ⴰⵢⵜⵎⴰⵛ, ⵓⵍⴰ ⴷ ⵍⴰⴵ ⵏⵏⴻⵛ ⵏⵉⵖ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵛ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴳⵍⴰ, ⵏⵉⵖ ⴰⵇⴰ ⴰⴷ ⵛⴻⴽ ⵄⴰⵔⴹⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵍⴻⵅⵍⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("LK14_13","072_14_13","LUK","14","13","13","ⵎⴰⵍⴰ ⵜⵄⴰⵔⴹⴻⴷ ⵅ ⵉⵡⴷⴰⵏ, ⵅⴻⵏⵏⵉ ⵄⴰⵔⴹ ⵅ ⵉⵎⴻⵣⵍⴰⴹ ⴷ ⵉⵇⵉⵢⴷⴰⵔⴻⵏ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK14_14","072_14_14","LUK","14","14","14","ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⴻⵙⵄⵓⴷ ⵓⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵙ ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵅⴻⴵⵚⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵍⴻⵅⵔⴰⵚ ⵏⵏⴻⵛ ⴷⵉ ⵜⵏⵓⴽⵔⴰ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK14_15","072_14_15","LUK","14","15","15","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵢⴰ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ, ⵉⵏⵏⴰ ⴰⵙ ⵡⴰⵏⵉⵜⴰ: “ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("LK14_16","072_14_16","LUK","14","16","16","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵓⵛⴰ ⵉⵄⴰⵔⴹ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK14_17","072_14_17","LUK","14","17","17","ⵉⵙⵙⴻⴽⴽ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵣⵣⴰⵔⴷⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉ ⵉ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ: ‘ⵅⵣⴰⵔ, ⴽⵓⵍⵛⵉ ⴰⵇⴰ ⵉⵡⵊⴻⴷ ⵉ ⴽⴻⵏⵏⵉⵡ. ⴰⵔⴰⵃⴻⵎ-ⴷⴷ!’ ");
INSERT INTO rift_vpl VALUES ("LK14_18","072_14_18","LUK","14","18","18","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵉⴳⴳ ⵙⵙⵉⴱⴱⴻⵜ. ⵉⵏⵏⴰ ⴰⵙ ⵓⵎⴻⵣⵡⴰⵔ: ‘ⵙⵖⵉⵖ ⵉⵊⵊ ⵏ ⵉⵢⵢⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴷ ⵜ ⵥⴰⵔⴻⵖ. ⵜⵜⴰⵔⴻⵖ ⴰⵛ ⴰⴷ ⴰⵢⵉ ⵜⵙⴰⵎⵃⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("LK14_19","072_14_19","LUK","14","19","19","ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⴰ: ‘ⵙⵖⵉⵖ ⵅⴻⵎⵙⴰ ⵏ ⵜⵢⵓⵢⴰ ⵏ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴷ ⵜⴻⵏ ⵊⴰⵔⵔⴱⴻⵖ, ⵜⵜⴰⵔⴻⵖ ⴰⵛ ⴰⴷ ⴰⵢⵉ ⵜⵙⴰⵎⵃⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("LK14_20","072_14_20","LUK","14","20","20","ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⴰ: ‘ⴰⵇⴰ ⵎⴰⵎⵎⴻⵛ ⵎⴻⵍⵛⴻⵖ ⵜⴰⵎⵖⴰⵔⵜ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("LK14_21","072_14_21","LUK","14","21","21","ⵉⴷⵡⴻⵍ-ⴷⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⵓⵛⴰ ⵉⵅⴻⴱⴱⴰⵔ ⵙⵉⴷⵉ ⵏⵏⴻⵙ ⵙ ⵎⴰⵏ ⴰⵢⴰ. ⵅⴻⵏⵏⵉ ⵉⵅⴻⵢⵢⴻⵇ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵏⵏⴰ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: ‘ⵔⵓⵃ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵡⴰⵣⵣⴰⵢⴻⵏ ⴷ ⵣⵣⵏⴰⵇⵉ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵛⴰ ⵏⴷⴻⵀ-ⴷⴷ ⵉⵎⴻⵣⵍⴰⴹ ⴷ ⵉⵇⵉⵢⴷⴰⵔⴻⵏ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK14_22","072_14_22","LUK","14","22","22","ⵉⵏⵏⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ: ‘ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⵓⵎⵓⵔⴻⴷ, ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⴰⵎⵛⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK14_23","072_14_23","LUK","14","23","23","ⵉⵏⵏⴰ ⴱⴰⴱ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ: ‘ⴼⴼⴻⵖ ⵖⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⴷ ⵣⵣⵏⴰⵇⵉ ⵓⵛⴰ ⵃⵚⴰⵔ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⴰⵍ ⵖⴰ ⵜⴻⵛⵛⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("LK14_24","072_14_24","LUK","14","24","24","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵖⴰⵔ ⵣⵣⴰⵔⴷⴻⵜ ⵉⵏⵓ’” ");
INSERT INTO rift_vpl VALUES ("LK14_25","072_14_25","LUK","14","25","25","ⴰⵎ ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⵖⴰⵛⵉ ⵉⴳⴳⵓⵔ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("LK14_26","072_14_26","LUK","14","26","26","“ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵃⴻⴷ ⵖⴰⵔⵉ ⵓⵛⴰ ⵡⴰⵔ ⵉⵛⴰⵔⵔⴻⵀ ⴱⴰⴱⴰⵙ ⵏⵉⵖ ⵢⴻⵎⵎⴰⵙ, ⴰⵢⵜⵎⴰⵙ ⵏⵉⵖ ⵙⵓⵢᵉⵜⵎⴰⵙ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵏⵉⵖ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵓ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK14_27","072_14_27","LUK","14","27","27","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴽⵙⵉⵏ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵢⵉ ⴷⴷ-ⵉⴹⴼⴰⵔ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK14_28","072_14_28","LUK","14","28","28","ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⴱⵏⴰ ⵉⵛⵜ ⵏ ⵚⵚⵓⵎⵄⴻⵜ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴰⵎⴻⵣⵡⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ, ⵎⴰ ⵖⴰⵔⴻⵙ ⵎⵉⵏ ⵉⵅⴻⵚⵚⴻⵏ ⵉ ⵓⴽⴻⵎⵎⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("LK14_29","072_14_29","LUK","14","29","29","ⵃⵉⵎⴰ, ⵎⴰⵍⴰ ⵉⵙⵙⴰⵔⵙ ⴷⵙⴰⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵙ ⵉⴽⴻⵎⵎⴻⵍ, ⵡⴰⵔ ⵅⴰⵙ ⴹⴻⵃⵃⵛⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵥⵔⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("LK14_30","072_14_30","LUK","14","30","30","ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⵔⵢⴰⵣ-ⴰ ⵉⴱⴷⴰ ⵍⴻⴱⵏⵉ ⵓⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⴽⴻⵎⵎⴻⵍ.’ ");
INSERT INTO rift_vpl VALUES ("LK14_31","072_14_31","LUK","14","31","31","ⵏⵉⵖ ⵎⴰⵏ ⴰⵊⴻⴵⵉⴷ, ⵎⴰⵍⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴹⵉⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⵎⵛⴰⵡⴰⵔ ⴰⵎⴻⵣⵡⴰⵔ ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵇⵓⴷⴷⴰ ⵙ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵙ ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ? ");
INSERT INTO rift_vpl VALUES ("LK14_32","072_14_32","LUK","14","32","32","ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⴰⵎ ⵉⴵⴰ ⵓⵊⴻⴵⵉⴷ ⵏⵏⵉ ⵄⴰⴷ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴰⵔ ⴰⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("LK14_33","072_14_33","LUK","14","33","33","ⵙ ⵓⵢⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("LK14_34","072_14_34","LUK","14","34","34","“ⵜⴰⵎⴻⴵⴰⵃⵜ ⵜⴻⵃⵍⴰ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴰⵔ ⵜⵎⴻⴵⴰⵃⵜ ⴰⵍⴻⴷⴷⵉ ⵏⵏⴻⵙ, ⵙ ⵎⵉⵏ ⵣⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⵄⴻⴷⵍⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LK14_35","072_14_35","LUK","14","35","35","ⵡⴰⵔ ⵜⵚⴻⴵⴻⵃ ⵛⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⵉ ⵜⵣⵓⴱⴰⵍⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵏⴹⴰⵔⴻⵏ. ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("LK15_1","072_15_1","LUK","15","1","1","ⵅⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ ⵖⴰⵔⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK15_2","072_15_2","LUK","15","2","2","ⵜⵜⵎⴻⵄⵎⵉⵄⴻⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ: “ⴰⵇⴰ ⵡⴰ ⵢⴰⵔⴻⵃⵃⴻⴱ ⵙ ⵉⵎⴻⴷⵏⴰⴱ ⵓⵛⴰ ⵉⵜⵜⴻⵜⵜ ⴰⴽⵉⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK15_3","072_15_3","LUK","15","3","3","ⵅⴻⵏⵏⵉ ⵉⵃⴰⵊⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("LK15_4","072_15_4","LUK","15","4","4","“ⵎⴰⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵎⵢⴰ ⵏ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵡⴻⴷⴷⴰⵔ ⴰⵙ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵜⴻⵙⵄⴰ ⵓ ⵜⴻⵙⵄⵉⵏ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵡⴻⵏⵏⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴰⵍ ⵜ ⵖⴰ ⵢⴰⴼ? ");
INSERT INTO rift_vpl VALUES ("LK15_5","072_15_5","LUK","15","5","5","ⵓ ⵅⵎⵉ ⵜ ⵖⴰ ⵢⴰⴼ, ⴰⴷ ⵉⴼⵔⴰⵃ, ⴰⴷ ⵜ ⵉⵙⵙⴰⵔⵙ ⵅ ⵜⵖⴰⵔⴷⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK15_6","072_15_6","LUK","15","6","6","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴻⴹ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⴰⴷ ⵉⵍⴰⵖⴰ ⵅ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⴷ ⵊⵊⵉⵔⴰⵏ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵏⵉ: ‘ⴼⴰⵔⵃⴻⵎ ⴰⴽⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵓⴼⵉⵖ ⴰⵀⵓⵍⵉ ⵉⵏⵓ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK15_7","072_15_7","LUK","15","7","7","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵏⵓⴱ ⵉ ⵖⴰ ⵉⵜⵓⴱⴻⵏ ⴽⵜⴰⵔ ⵅ ⵜⴻⵙⵄⴰ ⵓ-ⵜⴻⵙⵄⵉⵏ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵉ ⵡⴰⵔ ⵉⵅⵙⴻⵏ ⴰⴷ ⵜⵓⴱⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK15_8","072_15_8","LUK","15","8","8","“ⵏⵉⵖ ⵎⴰⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⴻⵛⵔⴰ ⵏ ⵜⴻⴱⵢⵉⵙⵉⵏ ⵏ ⵉⵊⵊ ⵏ ‘ⵊⵊⵓⵣ’, ⵎⴰⵍⴰ ⵉⵡⴻⴷⴷⴰⵔ ⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵔⵓⵖⵉ ⵍⵇⴻⵏⴷⵉⵍ, ⴰⴷ ⵜⴼⴰⵔⴹ ⵜⴰⴷⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵣⵓ ⵎⵍⵉⵃ ⴰⵍ ⵜⵜ ⵖⴰ ⵜⴰⴼ? ");
INSERT INTO rift_vpl VALUES ("LK15_9","072_15_9","LUK","15","9","9","ⵎⴰⵍⴰ ⵜⵓⴼⵉ ⵜⵜ, ⴰⴷ ⵜⵍⴰⵖⴰ ⵅ ⵜⵎⴻⴷⴷⵓⴽⴰⵍ ⴷ ⵜⵉⵊⵊⴰⵔⵉⵏ, ⴰⴷ ⴰⵙⴻⵏⵜ ⵜⵉⵏⵉ: ‘ⴼⴰⵔⵃⴻⵏⵜ ⴰⴽⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵓⴼⵉⵖ ⵜⴰⴱⵢⵉⵙⵜ ⵏ ‘ⵊⵊⵓⵣ’ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵢⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK15_10","072_15_10","LUK","15","10","10","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵏⵓⴱ ⵉ ⵖⴰ ⵉⵜⵓⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK15_11","072_15_11","LUK","15","11","11","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ: “ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK15_12","072_15_12","LUK","15","12","12","ⵉⵏⵏⴰ ⵓⵎⴰⵥⵓⵥ ⵏⵙⴻⵏ ⵉ ⴱⴰⴱⴰⵙ: ‘ⴰ ⴱⴰⴱⴰ, ⴻⵡⵛ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⴻⴳ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵛ!’ ⵅⴰⵙ ⵓⵛⴰ ⵉⴱⴹⴰ ⴰⵙⴻⵏ ⴱⴰⴱⴰⵙ ⴰⴳⵍⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK15_13","072_15_13","LUK","15","13","13","ⴰⵡⴰⵔⵏⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵙⵙⵎⵓⵏ ⵎⵎⵉⵙ ⴰⵎⴰⵥⵓⵥ ⴽⵓⵍⵛⵉ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵙⴰⴼⴰⵔ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ. ⵉⵇⴰⵔⴹ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴰⵎ ⵉⵙⵙⴻⵄⴷⵓ ⴷⵉⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵓⴼⴻⵛⵛⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("LK15_14","072_15_14","LUK","15","14","14","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵇⴰⵔⴹ ⴽⵓⵍⵛⵉ, ⵉⵡⴹⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⴰⵥ ⵉⵡⵄⴰⵔ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵉⴱⴷⴰ ⴰⴷ ⵉⵃⵡⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("LK15_15","072_15_15","LUK","15","15","15","ⵉⵔⵓⵃ ⵓⵛⴰ ⵉⵍⵚⴻⵇ ⴷⴻⴳ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵖⴰⵔ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵙ ⵉⵍⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK15_16","072_15_16","LUK","15","16","16","ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⵉ ⴰⴷ ⵉⵛⵛⵓⵔ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵙ ⵙ ⵜⴻⵙⵔⵉⵖⵡⴰ, ⵜⴻⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵉⵍⴼⴰⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵡⵛⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LK15_17","072_15_17","LUK","15","17","17","ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⵍⴻⵄⵇⴻⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ‘ⵎⴻⵛⵃⴰⵍ ⵏ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏ ⴱⴰⴱⴰ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⵖⵔⵓⵎ ⴰⵟⵟⴰⵙ ⵓ ⵏⴻⵛⵛ ⴷⴰ ⵜⵜⵎⴻⵜⵜⵉⵖ ⵙ ⵍⴰⵥ! ");
INSERT INTO rift_vpl VALUES ("LK15_18","072_15_18","LUK","15","18","18","ⴰⴷ ⴽⴽⴰⵔⴻⵖ, ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵏⵉⵖ: ‘ⴰ ⴱⴰⴱⴰ, ⴰⵇⴰ ⵅⴹⵉⵖ ⴰⴽ-ⴷ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴽⵉⴷⴻⴽ! ");
INSERT INTO rift_vpl VALUES ("LK15_19","072_15_19","LUK","15","19","19","ⵡⴰⵔ ⵙⴷⵉⵀⴻⴵⴻⵖ ⴰⴷ ⴰⵢⵉ ⵜⵍⴰⵖⵉⴷ ⴷ ⵎⵎⵉⵛ. ⴻⴳⴳ ⴰⵢⵉ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("LK15_20","072_15_20","LUK","15","20","20","ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⴱⴰⴱⴰⵙ. ⴰⵎ ⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵉⴱⴰⵔⵇ ⵉ-ⵜ ⴱⴰⴱⴰⵙ, ⵉⵃⵉⵏⵏ ⵅⴰⵙ, ⵓⵛⴰ ⵢⵓⵣⵣⴻⵍ ⵖⴰⵔⴻⵙ, ⵉⵏⴳⴻⵣ ⴰⵙ ⵅ ⵢⵉⵔⵉ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK15_21","072_15_21","LUK","15","21","21","ⵉⵏⵏⴰ ⴰⵙ ⵎⵎⵉⵙ: ‘ⴰ ⴱⴰⴱⴰ, ⵅⴹⵉⵖ ⴰⴽ-ⴷ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴽⵉⴷⴻⴽ. ⵡⴰⵔ ⵙⴷⵉⵀⴻⴵⴻⵖ ⴰⴷ ⴰⵢⵉ ⵍⴰⵖⴰⵏ ⵎⵎⵉⵛ.’ ");
INSERT INTO rift_vpl VALUES ("LK15_22","072_15_22","LUK","15","22","22","ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⵉⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ: ‘ⵙⵓⴼⴼⵖⴻⵎ-ⴷⴷ ⴰⵔⵔⵓⴹ ⵉⵃⵍⴰⵏ ⴰⵟⵟⴰⵙ, ⵙⵢⴰⵔⴹⴻⵎ ⴰⵙ ⵜ, ⴳⴳⴻⵎ ⵜⵅⴰⴷⴻⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵇⵇⵏⴻⵎ ⴰⵙ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵉ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK15_23","072_15_23","LUK","15","23","23","ⴰⵡⵢⴻⵎ-ⴷⴷ ⴰⵢⴻⵏⴷⵓⵣ ⵉⵚⴻⵃⵃⴻⵏ, ⵜⵖⴰⵔⵚⴻⵎ ⴰⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵛⵛ, ⴰⴷ ⵏⴼⴰⵔⵃ, ");
INSERT INTO rift_vpl VALUES ("LK15_24","072_15_24","LUK","15","24","24","ⵎⵉⵏⵣⵉ ⵎⵎⵉ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ, ⵉⴷⴷⴰⵔ. ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵉⵜⵜⵡⴰⴼ.’ ⵅⴻⵏⵏⵉ ⴱⴷⴰⵏ ⴰⴷ ⴼⴰⵔⵃⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("LK15_25","072_15_25","LUK","15","25","25","ⵎⴰⵛⴰ ⵎⵎⵉⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵢⵢⴰⵔ. ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⴰⵔⴻⴳⴳⵯⴻⵃ, ⵉⴷⵡⴻⵍ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵅⴻⵏⵏⵉ ⵉⵙⵍⴰ ⵉ ⴵⵖⴰ ⴷ ⵓⵖⴻⵏⵏⴻⵊ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK15_26","072_15_26","LUK","15","26","26","ⵉⵍⴰⵖⴰ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵇⵙⴰ ⵜ: ‘ⵎⴰⵏ ⴰⵢⴰ?’ ");
INSERT INTO rift_vpl VALUES ("LK15_27","072_15_27","LUK","15","27","27","ⵡⴰⵏⵉⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: ‘ⵓⵎⴰⵛ ⵢⵓⵙⴰ-ⴷⴷ, ⴱⴰⴱⴰⵛ ⵉⵖⴰⵔⵚ ⵉ ⵓⵢⴻⵏⴷⵓⵣ ⵉⵚⴻⵃⵃⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⵍⵉⵃ!’ ");
INSERT INTO rift_vpl VALUES ("LK15_28","072_15_28","LUK","15","28","28","ⵎⴰⵛⴰ ⵎⵎⵉⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵅⴻⵢⵢⴻⵇ, ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⴰⴷⴻⴼ. ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⴱⴰⴱⴰⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵃⴻⵛⵛⴻⵎ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK15_29","072_15_29","LUK","15","29","29","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ ⵉ ⴱⴰⴱⴰⵙ: ‘ⴰⵇⴰ ⵏⴻⵛⵛ ⵅⴻⴷⵎⴻⵖ ⵖⴰⵔⴻⴽ ⵍⴻⵅⵅⵓ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵊⵊⵉⵖ ⵣⵉ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏⵏⴻⵛ. ⵎⴰⵛⴰ ⵛⴻⴽ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵉⵖⴰⵢⴹ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⴰⴽ-ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK15_30","072_15_30","LUK","15","30","30","ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵎⵎⵉⵛ ⵡⴰⵏⵉⵜⴰ ⵡⴻⵏⵏⵉ ⵉⵛⵛⴻⵏ ⴰⴳⵍⴰ ⵏⵏⴻⵛ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵜⵖⴰⵔⵚⴻⴷ ⴰⵙ ⵉ ⵓⵢⴻⵏⴷⵓⵣ ⵉⵚⴻⵃⵃⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK15_31","072_15_31","LUK","15","31","31","ⵉⵏⵏⴰ ⴰⵙ ⴱⴰⴱⴰⵙ: ‘ⴰ ⵎⵎⵉ, ⵜⵓⵖⴰ ⵛⴻⴽ ⴰⴽⵉⴷⵉ ⵍⴻⴱⴷⴰ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵏⵓ, ⴰⵇⴰ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("LK15_32","072_15_32","LUK","15","32","32","ⴰⵇⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴼⴰⵔⵃ ⴰⴷ ⵏⴻⵣⵀⵓ, ⵎⵉⵏⵣⵉ ⵓⵎⴰⵛ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ, ⵎⴰⵛⴰ ⵉⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ, ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴰⵔ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴼ!’” ");
INSERT INTO rift_vpl VALUES ("LK16_1","072_16_1","LUK","16","1","1","ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ, ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵡⴽⵉⵍ ⵏⵏⵉ ⵣⵉ ⵛⴻⵜⵛⴰⵏ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵣⵓⵣⵣⴰⵔ ⴰⴳⵍⴰ ⵏ ⵙⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK16_2","072_16_2","LUK","16","2","2","ⵉⵍⴰⵖⴰ ⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵅⴰⴽ ⵜⵜⴻⵙⵍⵉⵖ? ⴻⵡⵛ ⵍⴻⵃⵙⴰⴱ ⵉ ⵓⵡⴻⴽⴽⴻⵍ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵉⵍⵉⴷ ⵄⴰⴷ ⴷ ⴰⵡⴽⵉⵍ!’ ");
INSERT INTO rift_vpl VALUES ("LK16_3","072_16_3","LUK","16","3","3","ⵉⵏⵏⴰ ⵡⴻⵡⴽⵉⵍ ⴰⴽ-ⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ: ‘ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵓⵎⵉ ⵙⵉⴷⵉ ⵉⵏⵓ ⴰⴷ ⵅⴰⴼⵉ ⵉⴽⴽⴻⵙ ⴰⵡⴻⴽⴽⴻⵍ-ⴰ? ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵉ ⵓⵇⵇⴰⵣ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵜⵓⵜⵔⴰ! ");
INSERT INTO rift_vpl VALUES ("LK16_4","072_16_4","LUK","16","4","4","ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ ⵃⵉⵎⴰ, ⵅⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵃⵓⵣⴻⵖ ⵅ ⵓⵡⴻⴽⴽⴻⵍ, ⴰⴷ ⴰⵢⵉ ⵇⴻⴱⵍⴻⵏ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵏⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK16_5","072_16_5","LUK","16","5","5","ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵏ ⵙⵉⴷⴻⵙ. ⵉⵏⵏⴰ ⴰⵙ ⵉ ⵓⵎⴻⵣⵡⴰⵔ: ‘ⵎⴻⵛⵃⴰⵍ ⴷ ⴰⵛ ⵉⵜⵜⵓⵔⵙ ⵙⵉⴷⵉ?’ ");
INSERT INTO rift_vpl VALUES ("LK16_6","072_16_6","LUK","16","6","6","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵏⴻⵜⵜⴰ: ‘ⵎⵢⴰ ⵏ ⵉⴱⵉⴷⴰⵡⴻⵏ ⵏ ⵣⵣⴻⵛⵜ!’ ⵉⵏⵏⴰ ⴰⵙ: ‘ⴽⵙⵉ ⵍⵛⵉⵖⴻⴷ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵛ, ⵇⵇⵉⵎ ⴷⴻⵖⵢⴰ, ⵜⴰⵔⵉⴷ: ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⴱⵉⴷⴰⵡⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK16_7","072_16_7","LUK","16","7","7","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: ‘ⵉ ⵛⴻⴽ, ⵎⴻⵛⵃⴰⵍ ⴷ ⴰⵛ ⵉⵜⵜⵓⵔⵙ ⵙⵉⴷⵉ?’ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: ‘ⵎⵢⴰ ⵏ ⵜⵅⵓⵏⵛⴰⵢ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏ ⵢⵉⵔⴷⴻⵏ.’ ⵉⵏⵏⴰ ⴰⵙ: ‘ⴽⵙⵉ ⵍⵛⵉⵖⴻⴷ ⵏ ⵓⵎⴰⵔⵡⴰⵙ ⵏⵏⴻⵛ, ⵜⴰⵔⵉⴷ: ⵜⵎⴰⵏⵢⵉⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK16_8","072_16_8","LUK","16","8","8","ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⴳⴳⴰ ⵍⴼⴰⴵ ⴷⴻⴳ ⵡⴻⵡⴽⵉⵍ ⵉⵖⴻⵛⵛ, ⴰⵇⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵙ ⵜⵉⵖⵉⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵔⵡⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷⵉ ⵊⵊⵉⵍ ⵏⵙⴻⵏ ⵡⴰⵏⵉⵜⴰ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LK16_9","072_16_9","LUK","16","9","9","ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ‘ⴳⴳⴻⵎ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵡⴰⴳⵍⴰ-ⵢⴰ ⵏ ⵍⵖⴻⵛⵛ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⵖⴰ ⵉⵇⴹⴰ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⴱⵍⴻⵏ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⵏⵙⴻⵏ ⵏ ⵍⴻⴱⴷⴰ.’” ");
INSERT INTO rift_vpl VALUES ("LK16_10","072_16_10","LUK","16","10","10","“ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷⵉ ⴷⵔⵓⵙ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵓⵍⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⵓ ⵡⴻⵏⵏⵉ ⵉⵖⴻⵛⵛⴻⵏ ⴷⵉ ⴷⵔⵓⵙ, ⴰⵇⴰ ⵉⵖⴻⵛⵛ ⵓⵍⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK16_11","072_16_11","LUK","16","11","11","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴰⴳⵍⴰ ⵏ ⵍⵖⴻⵛⵛ, ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵡⴻⴽⴽⵍⴻⵏ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("LK16_12","072_16_12","LUK","16","12","12","ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵡⵉ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵡⵛⵉⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("LK16_13","072_16_13","LUK","16","13","13","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵅⴷⴻⵎ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⵉⴷⵉⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵖ ⴰⴷ ⵉⵛⴰⵔⵀ ⵉⵊⵊⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵄⵉⵣⵣ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵏⵉⵖ ⴰⴷ ⵉⵛⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵉⵊⵊⴻⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴰⴳⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LK16_14","072_16_14","LUK","16","14","14","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵏ ⵜⵎⴻⵏⵢⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("LK16_15","072_16_15","LUK","16","15","15","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵏⵏⵉ ⵉⵙⵙⴻⴳⴳⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵢⴰⵔⴳⴻⴱ ⵅ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵢⵓⵄⵍⴰⵏ ⵖⴰⵔ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK16_16","072_16_16","LUK","16","16","16","ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵍ ⵢⵓⵃⴰⵏⵏⴰ. ⵣⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵜⵜⴻⵎⵙⴻⴷⵃⴰⵙⴻⵏ ⵖⴰⵔⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⴰⴷⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK16_17","072_16_17","LUK","16","17","17","ⵎⴰⵛⴰ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵀⵡⴻⵏ ⵅ ⵓⵡⴻⵟⵟⵓ ⵏ ⵉⵛⵜ ⵏ ⵜⵏⴻⵇⵇⵉⵟ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK16_18","072_16_18","LUK","16","18","18","“ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⴵⴼⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ, ⴰⵇⴰ ⵉⵣⵏⴰ, ⵓ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵎⴻⵍⵛⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵉⴵⴼⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵣⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK16_19","072_16_19","LUK","16","19","19","“ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ, ⵢⴰⵔⴹ ⵍⴻⵇⵟⴻⵏ ⴰⵛⴻⵎⵍⴰⵍ ⴰⵣⴷⴰⴷ ⴷ ⵍⴻⵃⵔⵉⵔ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ. ⵉⵜⵜⵖⴻⴱⴱⴰ ⵣⵣⵀⵓ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("LK16_20","072_16_20","LUK","16","20","20","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵍⵉⵄⴰⵣⴰⵔ. ⵜⵓⵖⴰ ⵙⵙⴱⵓⵥⵥⵍⴻⵏ ⵜ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ, ⵉⵛⵛⵓⵔ ⵙ ⵍⵃⴻⴱⴱ. ");
INSERT INTO rift_vpl VALUES ("LK16_21","072_16_21","LUK","16","21","21","ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵎⴻⵥⵔⵉ ⴰⴷ ⵉⵊⵊⵉⵡⴻⵏ ⵙ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵉ ⴷⴷ-ⵉⵡⴻⵟⵟⴰⵏ ⵣⵉ ⵟⵟⴰⴱⵍⴰ ⵏ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ. ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵢⵉⵟⴰⵏ ⵄⴰⵡⴻⴷ, ⵍⴻⵙⵙⵃⴻⵏ ⵉⴱⵓⵄⵔⵓⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK16_22","072_16_22","LUK","16","22","22","ⵉⵎⵎⵓⵜ ⵓⵎⴻⵣⵍⵓⴹ, ⴽⵙⵉⵏⵜ ⵜ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵖⴰⵔ ⵡⴻⵃⵙⵉⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ⵓⵍⴰ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵉⵎⵎⵓⵜ, ⵏⴻⴹⵍⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK16_23","072_16_23","LUK","16","23","23","ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⴷⴷⴰⴱ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵎⵓⵖⵍⵉ ⵏⵏⴻⵙ, ⵉⵥⵔⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵓ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ-ⵜ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK16_24","072_16_24","LUK","16","24","24","ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ: ‘ⴰ ⴱⴰⴱⴰ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ. ⵙⴻⴽⴽ-ⴷⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵓⴼⴼ ⵉⵅⴻⴼ ⵏ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵙⵎⴻⴹ ⵉⵍⴻⵙ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵜⵄⴻⴷⴷⴰⴱⴻⵖ ⴷⵉ ⵜⵎⴻⵙⵙⵉ-ⵢⴰ.’ ");
INSERT INTO rift_vpl VALUES ("LK16_25","072_16_25","LUK","16","25","25","ⵉⵏⵏⴰ ⴰⵙ ⵉⴱⵔⴰⵀⵉⵎ: ‘ⴰ ⵎⵎⵉ, ⵄⵇⴻⵍ ⴰⵇⴰ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵏⵏⴻⵛ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵍⵖⴰⵔ. ⵍⴻⵅⵅⵓ ⵏⴻⵜⵜⴰ ⵉⵜⵜᵉⵜⵜⵡⴰⴼⴻⵡⵡⴻⵊ ⵓ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵄⴻⴷⴷⴰⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK16_26","072_16_26","LUK","16","26","26","ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵊⴰⵔ ⴰⵏⴻⵖ ⵏⴻⵛⵛⵉⵏ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵊⵊ ⵏ ⵜⵜⴰⵙⵉⵄ ⵉⵎⵖⴰⵔ, ⴰⵍⴰⵎⵉ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵥⵡⴰⵏ ⵙⵙⴰ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵥⵡⴰⵏ ⵙⵙⴻⵏⵏⵉ.’ ");
INSERT INTO rift_vpl VALUES ("LK16_27","072_16_27","LUK","16","27","27","ⵉⵏⵏⴰ ⴰⵙ: ‘ⵜⵜⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⵅⴻⵏⵏⵉ, ⴰ ⴱⴰⴱⴰ, ⴰⴷ ⵜ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("LK16_28","072_16_28","LUK","16","28","28","ⵎⵉⵏⵣⵉ ⵖⴰⵔⵉ ⵅⴻⵎⵙⴰ ⵏ ⴰⵢⵜⵎⴰ. ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵙⴻⵏ ⵉⵄⵍⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵏ ⵓⵄⴻⴷⴷⴻⴱ.’ ");
INSERT INTO rift_vpl VALUES ("LK16_29","072_16_29","LUK","16","29","29","ⵉⵏⵏⴰ ⴰⵙ ⵉⴱⵔⴰⵀⵉⵎ: ‘ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵎⵓⵙⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵙⵍⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK16_30","072_16_30","LUK","16","30","30","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: ‘ⵍⵍⴰ, ⴰ ⴱⴰⴱⴰ ⵉⴱⵔⴰⵀⵉⵎ, ⵎⴰⵍⴰ ⵉⵔⵓⵃ ⵖⴰⵔⵙⴻⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵓⴱⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK16_31","072_16_31","LUK","16","31","31","ⵉⵏⵏⴰ ⴰⵙ ⵉⴱⵔⴰⵀⵉⵎ: ‘ⵎⴰⵍⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ ⵖⴰⵔ ⵎⵓⵙⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⵄⴰⵡⴻⴷ, ⵄⴰⴷ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊⴻⵏ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("LK17_1","072_17_1","LUK","17","1","1","ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵡⴰⵔ ⵜⵄⴻⴷⴷⴻⵍ ⵉⵍⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵄⴻⵏⴽⵔⵉⴼⵉⵏ, ⵎⴰⵛⴰ ⵓⵛⵜ ⵅ ⵡⴻⵏⵏⵉ ⵣⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏⵜ! ");
INSERT INTO rift_vpl VALUES ("LK17_2","072_17_2","LUK","17","2","2","ⵉⵃⵍⴰ ⴰⵙ ⴰⴷ ⵅⴰⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵜⵙⵉⵔⵜ ⵜⴻⴷⵇⴻⵍ ⵖⴰⵔ ⵢⵉⵔⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵅ ⵎⵉⵏⵏⵉ ⵖⴰ ⵉⵙⵙⴻⵏⵇⴰⵔⴹ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LK17_3","072_17_3","LUK","17","3","3","ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ. ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵓⵎⴰⵛ, ⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ, ⵓ ⵎⴰⵍⴰ ⵉⵜⵓⴱ, ⵙⴰⵎⵃ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK17_4","072_17_4","LUK","17","4","4","ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⴰⴽⵉⴷⴻⴽ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵙⴻⴱⵄⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵉⵇⵇⴰⵔ: ‘ⴰⵇⴰ ⵜⵓⴱⴻⵖ!’, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙ ⵜⵙⴰⵎⵃⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("LK17_5","072_17_5","LUK","17","5","5","ⵏⵏⴰⵏ ⵔⵔⵓⵙⵓⵍ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵔⵏⵉ ⴰⵏⴻⵖ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("LK17_6","072_17_6","LUK","17","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵍⵉ ⵜⵓⵖⴰ ⴷⴰⵢⵡⴻⵎ ⵍ’ⵉⵎⴰⵏ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵃⴻⴱⴱⵓⵛⵜ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵓⵅⴻⵔⴷⴻⵍ ⵓⵛⴰ ⴰⴷ ⵜⵉⵏⵉⵎ ⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ-ⴰ ⵏ ⵜⵓⵜ: ‘ⵜⵡⴰⵇⵍⴻⵄ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵏⴻⵎ, ⵜⵡⴰⵥⵥⵓ ⴷⵉ ⵍⴻⴱⵃⴰⵔ!’, ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵜᵉⵟⵟⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("LK17_7","072_17_7","LUK","17","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵛⴰⵔⵔⴻⵣ ⵏⵉⵖ ⵢⴰⵔⴻⴽⴽⵡⴻⵙ ⵓⴵⵉ, ⴰⴷ ⴰⵙ ⵢⵉⵏⵉ ⴷⴻⵖⵢⴰ ⵎⴰⵍⴰ ⵉⵄⵇⴻⴱ-ⴷⴷ ⵣⴻⴳ ⵉⵢⵢⴰⵔ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ: ‘ⵇⴰⵔⵔⴻⴱ-ⴷⴷ, ⵜⴻⵇⵇⵉⵎⴻⴷ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ’? ");
INSERT INTO rift_vpl VALUES ("LK17_8","072_17_8","LUK","17","8","8","ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵇⵇⴰⵔ: ‘ⵙⴻⵡⵊⴻⴷ ⵎⵉⵏ ⵖⴰ ⵎⵎⵓⵏⴻⵙⵡⴻⵖ, ⵜⴱⴻⵢⵙⴻⴷ, ⵜⵙⴻⵅⵅⴰⵔⴻⴷ ⵅⴰⴼⵉ ⴰⵍ ⵖⴰ ⵛⵛⴻⵖ, ⵙⵡⴻⵖ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵛⵛⴻⴷ, ⴰⴷ ⵜⴻⵙⵡⴻⴷ ⵓⵍⴰ ⴷ ⵛⴻⴽ’? ");
INSERT INTO rift_vpl VALUES ("LK17_9","072_17_9","LUK","17","9","9","ⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⴰⵇⴰⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⴰⴷ ⵜ ⵢⴻⴳⴳ? ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ, ⵍⵍⴰ! ");
INSERT INTO rift_vpl VALUES ("LK17_10","072_17_10","LUK","17","10","10","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵅⵎⵉ ⵜⴻⴳⴳⵉⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵏⵉⵎ: ‘ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⴳⴳⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵅⴰⵏⴻⵖ’.” ");
INSERT INTO rift_vpl VALUES ("LK17_11","072_17_11","LUK","17","11","11","ⵔⴰⵎⵉ ⵉⵔⵓⵃ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵛⵓⵇ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵏ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LK17_12","072_17_12","LUK","17","12","12","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴷⵛⴰⵔ, ⵍⵇⴰⵏ ⵜ ⵄⴻⵛⵔⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴰⵢⵙⴻⵏ ⵍⴱⴰⵔⵚ, ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("LK17_13","072_17_13","LUK","17","13","13","ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵢⴰⵙⵓⵄ, ⴰⵔⵃⴻⵎ ⴰⵏⴻⵖ!’” ");
INSERT INTO rift_vpl VALUES ("LK17_14","072_17_14","LUK","17","14","14","ⵓⵎⵉ ⴷⴰⵢⵙⴻⵏ ⵉⵅⵣⴰⵔ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵙⴻⵛⵏⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ!” ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ, ⴰⵎ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK17_15","072_17_15","LUK","17","15","15","ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵄⵇⴻⴱ, ⵓⵎⵉ ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵉⴳⴳⴻⵏⴼⴰ, ⵓⵛⴰ ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK17_16","072_17_16","LUK","17","16","16","ⵉⵡⴹⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵉⵇⴰⴷⴰ ⵜ. ⵡⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵙⴰⵎⵉⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("LK17_17","072_17_17","LUK","17","17","17","ⵉⵟⵟⴻⴼ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵄⴻⵛⵔⴰ? ⵎⴰⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵜⴻⵙⵄⴰ? ");
INSERT INTO rift_vpl VALUES ("LK17_18","072_17_18","LUK","17","18","18","ⵎⴰⵢⴻⵎⵎⵉ ⵊⵊⵉⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵄⵓⴵⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵖⵉⵔ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵀⴰ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("LK17_19","072_17_19","LUK","17","19","19","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⵜⵔⵓⵃⴻⴷ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("LK17_20","072_17_20","LUK","17","20","20","ⵓⵎⵉ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵙⵙⴻⵇⵙⴰⵏ ⵢⴰⵙⵓⵄ: “ⵎⴻⵍⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ?”, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⵓⴷⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⵛⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK17_21","072_17_21","LUK","17","21","21","ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵇⴰ-ⵜⵜ ⴷⴰ!’, ⵏⵉⵖ: ‘ⴰⵇⴰ-ⵜⵜ ⴷⵉⵀⴰ!’, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK17_22","072_17_22","LUK","17","22","22","ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴰⴷ ⴷⴷ-ⴰⵡⴹⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵡⴰⵀⴰ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜ ⵜⵥⴰⵔⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK17_23","072_17_23","LUK","17","23","23","ⵎⴰⵍⴰ ⵏⵏⴰⵏ ⴰⵡⴻⵎ: ‘ⴰⵇⴰ-ⵜ ⴷⴰ!’ ⵏⵉⵖ: ‘ⴰⵇⴰ-ⵜ ⴷⵉⵀⴰ!’, ⵡⴰⵔ ⴷⵉⵏ ⵜⵜⵔⵉⵃⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK17_24","072_17_24","LUK","17","24","24","ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵛⴰⵜ ⵡⴰⵙⵙⴰⵎ ⵣⵉ ⵟⵟⴰⵔⴼ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏⵏⴻⵖⵏⵉ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK17_25","072_17_25","LUK","17","25","25","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ ⵣⵉ ⵊⵊⵉⵍ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("LK17_26","072_17_26","LUK","17","26","26","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⵓⵃ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK17_27","072_17_27","LUK","17","27","27","ⵜⵓⵖⴰ ⵜⵜᵉⵜⵜⴻⵏ, ⵙⴻⵙⵙⴻⵏ, ⵜⵜⴰⵡⵢⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵙⵎⴻⴵⴰⵛⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵢⵓⴷⴻⴼ ⵏⵓⵃ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵟⵟⵓⴼⴰⵏ, ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK17_28","072_17_28","LUK","17","28","28","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵉⵎⵙⴰⵔ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵓⵜ. ⵜⵓⵖⴰ ⵜⵜᵉⵜⵜⴻⵏ, ⵙⴻⵙⵙⴻⵏ, ⵙⵙⴰⵖⴻⵏ, ⵣⵣⵏⵓⵣⴰⵏ, ⵜⵜⴻⵥⵥⵓⵏ, ⴱⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK17_29","072_17_29","LUK","17","29","29","ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵍⵓⵜ ⵣⵉ ⵙⴰⴷⵓⵎ, ⵉⵊⵊⴰ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵜⴻⵃⵃⴰ ⵜⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK17_30","072_17_30","LUK","17","30","30","ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK17_31","072_17_31","LUK","17","31","31","ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵓ ⵍⵇⴻⵛⵛ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⵉ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴽⵙⵉ. ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵄⵉⵇⵉⴱ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LK17_32","072_17_32","LUK","17","32","32","ⵄⴻⵇⵍⴻⵎ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⵍⵓⵜ! ");
INSERT INTO rift_vpl VALUES ("LK17_33","072_17_33","LUK","17","33","33","ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⵅⵙⴰⵔ, ⵓ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉ ⵖⴰ ⵉⵅⵙⴰⵔⴻⵏ, ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK17_34","072_17_34","LUK","17","34","34","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵅ ⵉⵛⵜ ⵏ ⵜⴰⵙⵙⵓⵜ: ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴽⵙⵉ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("LK17_35","072_17_35","LUK","17","35","35","ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵃⴰⵔⵔⵢⴻⵏⵜ ⵊⵎⵉⵄ, ⵉⵛⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⵙⵉ, ⵜⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("LK17_36","072_17_36","LUK","17","36","36","ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵜⵏⴰⵢⴻⵏ ⴷⴻⴳ ⵉⵢⵢⴰⵔ: ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴽⵙⵉ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵊⵊ.” ");
INSERT INTO rift_vpl VALUES ("LK17_37","072_17_37","LUK","17","37","37","ⴰⵔⵔⵉⵏ-ⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏⵉ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⴰⵔⵔⵉⵎⴻⵜ ⴷⵉⵏ ⵉⵜⵜⵎⵓⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵉⴳⵉⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK18_1","072_18_1","LUK","18","1","1","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴷⵉ ⴽⵓⵍ ⵍⵡⴻⵇⵜ ⴱⵍⴰ ⴰⵎⴻⵍⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("LK18_2","072_18_2","LUK","18","2","2","“ⵜⵓⵖⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵊⵊ ⵏ ⵍⵇⴰⴹⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK18_3","072_18_3","LUK","18","3","3","ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: ‘ⴻⵡⵛ ⴰⵢⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵉⵏⵓ ⵅ ⵡⴻⵖⵔⵉⵎ ⵉⵏⵓ!’ ");
INSERT INTO rift_vpl VALUES ("LK18_4","072_18_4","LUK","18","4","4","ⴰⵟⵟⴰⵙ ⵉ ⵉⴽⴽⴰ ⵜⵓⵖⴰ ⵢⵓⴳⵉ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ: ‘ⵏⴻⵛⵛ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ ⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵓ ⵡⴰⵔ ⵜⵜⵡⴻⵇⵇⵉⵔⴻⵖ ⴱⵏⴰⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LK18_5","072_18_5","LUK","18","5","5","ⵇⴰⵄ ⴰⵎⵎⵓ, ⵎⵉⵏⵣⵉ ⵜⴰⵊⵊⴰⵍⵜ-ⴰ ⵜⵀⴻⴽⴽⵡⴻⵍ ⴰⵢⵉ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵄⵉⵇⵇⵉⴱ ⵍⴻⴱⴷⴰ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵜⴰⵔⵥ ⴰⵣⴻⴵⵉⴼ.’” ");
INSERT INTO rift_vpl VALUES ("LK18_6","072_18_6","LUK","18","6","6","ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵏⵏⴰ: “ⵙⵍⴻⵎ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵍⵇⴰⴹⵉ ⴰⵖⴻⵛⵛⴰⵛ! ");
INSERT INTO rift_vpl VALUES ("LK18_7","072_18_7","LUK","18","7","7","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵙⵖⴰⵔⵜ ⴽⵜⴰⵔ ⴰⵟⵟⴰⵙ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵙⵖⵓⵢⵢⵓⵏ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ? ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵏⴻⵜⵜⴰ ⴽⵜⴰⵔ ⴰⵟⵟⴰⵙ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵅⴰⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LK18_8","072_18_8","LUK","18","8","8","ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵜⴰⵙⵖⴰⵔⵜ ⴷⴻⵖⵢⴰ. ⵎⴰⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⵄⵇⴻⴱ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰ ⴰⴷ ⵢⴰⴼ ⵍ’ⵉⵎⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("LK18_9","072_18_9","LUK","18","9","9","ⵉⵏⵏⴰ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ ⵉ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵜⵉⵇⵇⴻⵜ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵓ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK18_10","072_18_10","LUK","18","10","10","“ⴳⴰⵄⵄⴷⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵥⵥⴰⴵⴻⵏ, ⵉⵊⵊⴻⵏ ⴷ ⴰⴼⴰⵔⵉⵙⵉ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⴹⴹⴰⵔⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("LK18_11","072_18_11","LUK","18","11","11","ⵉⴱⴻⴷⴷ ⵓⴼⴰⵔⵉⵙⵉ, ⵉⵜⵜⵥⴰⴵⴰ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ: ‘ⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⵜⵇⴰⴷⵉⵖ ⵛⴻⴽ ⵓⵎⵉ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⴰⵎ ⵉⵡⴷⴰⵏ ⵏⵏⴻⵖⵏⵉ: ⵉⵖⴻⵛⵛⴰⵛⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ, ⵓⵍⴰ ⴰⵎ ⴱⵓ-ⴹⴹⴰⵔⵉⴱⴰ ⵡⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("LK18_12","072_18_12","LUK","18","12","12","ⵏⴻⵛⵛ ⵜⵜⵥⵓⵎⵎⵉⵖ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵓⵔⴻⵏ ⴷⵉ ⵙⵙⵉⵎⴰⵏⴰ, ⵜⵜⵉⵛⴻⵖ ⵍⴻⵄⵛⵓⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵉ ⵉⴵⴰⵏ ⴷ ⴰⴳⵍⴰ.’ ");
INSERT INTO rift_vpl VALUES ("LK18_13","072_18_13","LUK","18","13","13","ⵎⴰⵛⴰ ⴱⵓ-ⴹⴹⴰⵔⵉⴱⴰ ⵡⴻⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵡⴰⵔ ⵉⵣⵄⵉⵎ ⵓⵍⴰ ⴰⴷ ⵉⵙⵙⵉⵍⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⵉⵡⵜⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴷⵎⴰⵔⴻⵏ, ⵉⵏⵏⴰ: ‘ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⴷⵏⵓⴱ!’ ");
INSERT INTO rift_vpl VALUES ("LK18_14","072_18_14","LUK","18","14","14","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵡⴰⵟⵟⴰⵙ ⵅ ⵓⴼⴰⵔⵉⵙⵉ ⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵉⵀⵡⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵓⵄⵍⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵡⴰⴹⴻⵄ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵡⴰⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK18_15","072_18_15","LUK","18","15","15","ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵍⵓⴼ. ⵓⵎⵉ ⵜⴻⵏ ⵥⵔⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵡⴻⴱⴱⵅⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK18_16","072_18_16","LUK","18","16","16","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵊⵊⴻⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⴰⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜᵉⵟⵟⴼⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⴰⵎ ⵢⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK18_17","072_18_17","LUK","18","17","17","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵇⴱⵉⵍⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ ⵡⴰⵔ ⵜⵜ ⵉⵜⵜⵉⴷⴻⴼ ⵄⴻⵎⵎⴰⵔⵚ!” ");
INSERT INTO rift_vpl VALUES ("LK18_18","072_18_18","LUK","18","18","18","ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵡⴰⵔⵜⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK18_19","072_18_19","LUK","18","19","19","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⵍⴰⵖⵉⴷ ⵙ ‘ⴰⵚⴻⴱⵃⴰⵏ’? ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵎⵖⵉⵔ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK18_20","072_18_20","LUK","18","20","20","ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵉⵡⴻⵚⵚⴰ: ⵡⴰⵔ ⵣⴻⵏⵏⵉ, ⵡⴰⵔ ⵏⴻⵇⵇ, ⵡⴰⵔ ⵜⵜⵉⵛⴰⵔ, ⵡⴰⵔ ⵛⴻⵀⵀⴻⴷ ⵙ ⵥⵓⵔ, ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK18_21","072_18_21","LUK","18","21","21","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴰ ⵃⴹⵉⵖ ⵜⴻⵏⵜ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("LK18_22","072_18_22","LUK","18","22","22","ⵓⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⴰⵢⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵛⵜ ⵜⴻⵇⵇⵉⵎ ⴰⵛ. ⵓⵢⵓⵔ, ⵣⴻⵏⵣ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⴽ, ⴼⴰⵔⵇ ⵉ-ⵜ ⵅ ⵉⵎⴻⵣⵍⴰⴹ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵍⴽⴻⵏⵣ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵅⴻⵏⵏⵉ ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("LK18_23","072_18_23","LUK","18","23","23","ⵓⵎⵉ ⵉⵙⵍⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵛⴹⴻⵏ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK18_24","072_18_24","LUK","18","24","24","ⵓⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵛⴹⴻⵏ, ⵉⵏⵏⴰ: “ⵎⴰⵎⵎⴻⵛ ⵢⴻⵡⵄⴰⵔ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK18_25","072_18_25","LUK","18","25","25","ⵎⵉⵏⵣⵉ ⴰⴷⴰⴼ ⵏ ⵡⴻⵍⵖⴻⵎ ⵣⵉ ⵜⵉⵟⵟ ⵏ ⵜⵙⵉⵏⴻⴼⵜ ⵉⵀⵡⴻⵏ ⵅ ⵡⴰⴷⴰⴼ ⵏ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK18_26","072_18_26","LUK","18","26","26","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("LK18_27","072_18_27","LUK","18","27","27","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵖⴰⵔ ⵉⵡⴷⴰⵏ, ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⵉⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK18_28","072_18_28","LUK","18","28","28","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵓⵟⵔⵓⵙ: “ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵊⵊⴰ ⴽⵓⵍⵛⵉ ⵓⵛⴰ ⵏⴻⴹⴼⴰⵔ ⵉ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("LK18_29","072_18_29","LUK","18","29","29","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵉ ⵉⵜⵜⴻⵊⵊⵉⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵉⵖ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵉⵖ ⵜⴰⵡⵎⴰⵜ, ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵉⵖ ⵜⴰⵔⵔⴰⵡⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("LK18_30","072_18_30","LUK","18","30","30","ⵉ ⵡⴰⵔ ⵉⴽⵙⵉⵏ ⴰⴹⴻⴼⴼⵓⵙ ⵅ ⵓⴹⴻⴼⴼⵓⵙ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⵓⵛⴰ ⴷⵉ ⵣⵣⵎⴰⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵉⴽⵙⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK18_31","072_18_31","LUK","18","31","31","ⵢⴰⵙⵓⵄ ⵉⴽⵙⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⴷ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵅ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴼⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LK18_32","072_18_32","LUK","18","32","32","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵜⴻⵀⵣⴰⵏ, ⴰⴷ ⵅⴰⵙ ⵙⵙⵓⵙⴼⴻⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK18_33","072_18_33","LUK","18","33","33","ⴰⴷ ⵜ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⴰⴷ ⵜ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ, ⴰⴷ ⵜ ⵏⵖⴻⵏ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("LK18_34","072_18_34","LUK","18","34","34","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵡⴰⵍⵓ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ. ⵜⵓⵖⴰ ⴰⵡⴰⵍ-ⴰ ⵉⵡⵄⴰⵔ ⵅⴰⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK18_35","072_18_35","LUK","18","35","35","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⴰⵔⵉⵃⴰ ⵜⵓⵖⴰ ⵉⵊⵊ ⵏ ⵓⴷⴰⵔⵖⴰⵍ ⵉⵇⵇⵉⵎ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵜⵜᵉⵜⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK18_36","072_18_36","LUK","18","36","36","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵉ ⵍⵃⴻⵙⵙ ⵏ ⵍⵖⴰⵛⵉ ⵉⵄⴷⵓ, ⵉⵙⵙⴻⵇⵙⴰ: “ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK18_37","072_18_37","LUK","18","37","37","ⵏⵏⴰⵏ ⴰⵙ: “ⵢⴻⵛⵛⵓ ⵏⵏⴰⵚⵉⵔⵉ ⵉⵄⴻⴷⴷⵓ.” ");
INSERT INTO rift_vpl VALUES ("LK18_38","072_18_38","LUK","18","38","38","ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⴰ ⵢⴰⵙⵓⵄ, ⴰ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("LK18_39","072_18_39","LUK","18","39","39","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵢⴰⵙⵓⵄ, ⵡⴻⴱⴱⵅⴻⵏ ⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵇⴰⵔ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴱⴷⴰ ⵉⵜⵜⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ ⴽⵜⴰⵔ: “ⴰ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵔⵃⴻⵎ ⴰⵢⵉ!” ");
INSERT INTO rift_vpl VALUES ("LK18_40","072_18_40","LUK","18","40","40","ⵉⴱⴻⴷⴷ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ ⵖⴰⵔⴻⵙ. ⵓⵎⵉ ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵇⴰⵔⵔⴻⴱ, ⵉⵙⵙⴻⵇⵙⴰ ⵜ, ");
INSERT INTO rift_vpl VALUES ("LK18_41","072_18_41","LUK","18","41","41","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵛ ⵜ ⴳⴳⴻⵖ?” ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵅⵙⴻⵖ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⵜⵜⵡⴰⵍⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("LK18_42","072_18_42","LUK","18","42","42","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵜⵡⴰⵍⴰ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("LK18_43","072_18_43","LUK","18","43","43","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰ ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ, ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵉ ⵉⵥⵔⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵙⵙⵄⵓⴵⴻⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK19_1","072_19_1","LUK","19","1","1","ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⴰⵔⵉⵃⴰ, ⵉⵛⵓⵇ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("LK19_2","072_19_2","LUK","19","2","2","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵣⴰⴽⴽⴰⵢⵓ. ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴷ ⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵓⵍⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴰⵢⵜ ⵏ ⴹⴹⴰⵔⵉⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("LK19_3","072_19_3","LUK","19","3","3","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵥⴰⵔ ⵢⴰⵙⵓⵄ ⴷ ⵎⵉⵏ ⵉⵄⵏⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵖⴰⵛⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵣⴰⴽⴽⴰⵢⵓ ⴷ ⴰⵇⵓⴹⴰⴹ ⵏ ⵜⵉⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("LK19_4","072_19_4","LUK","19","4","4","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵣⵡⴰⵔ ⵉ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵅ ⵉⵊⵊ ⵏ ⵡⴰⵔⵜⵓ ⵏ ⵍⴻⵅⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵥⴰⵔ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴰⴷ ⴷⴷ-ⵢⴻⴽⴽ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK19_5","072_19_5","LUK","19","5","5","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⴱⴰⵔⵇ ⵉ-ⵜ. ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵣⴰⴽⴽⴰⵢⵓ, ⵇⴻⴵⴻⵇ-ⴷⴷ, ⵀⵡⴰ-ⴷⴷ ⴷⴻⵖⵢⴰ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ-ⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK19_6","072_19_6","LUK","19","6","6","ⵉⵇⴻⴵⴻⵇ-ⴷⴷ, ⵉⵀⵡⴰ-ⴷⴷ ⴷⴻⵖⵢⴰ ⵓⵛⴰ ⵢⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⴻⵙ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK19_7","072_19_7","LUK","19","7","7","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴱⴷⴰⵏ ⵜⵜⵎⴻⵄⵎⵉⵄⴻⵏ ⵅⴰⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵎⴻⴷⵏⵓⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ!” ");
INSERT INTO rift_vpl VALUES ("LK19_8","072_19_8","LUK","19","8","8","ⵉⴽⴽⴰⵔ ⵣⴰⴽⴽⴰⵢⵓ, ⵉⵏⵏⴰ ⵉ ⵢⴰⵙⵓⵄ: “ⵅⵣⴰⵔ, ⵙⵉⴷⵉ, ⴰⴷ ⵡⵛⴻⵖ ⴰⵣⵢⴻⵏ ⵏ ⵡⴰⴳⵍⴰ ⵉⵏⵓ ⵉ ⵉⵎⴻⵣⵍⴰⴹ ⵓ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵣⵉ ⴽⴽⵙⴻⵖ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵙ ⵍⵖⴻⵛⵛ, ⴰⴷ ⴰⵙ ⵜ ⴰⵔⵔⴻⵖ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("LK19_9","072_19_9","LUK","19","9","9","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵙⵙ-ⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵡⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK19_10","072_19_10","LUK","19","10","10","ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵓ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵎⵉⵏ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK19_11","072_19_11","LUK","19","11","11","ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵜⴻⵙⵍⴰⵏ ⴰⵢⴰ, ⵢⴰⵔⵏⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵇⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴷⴷ-ⵜⴻⴹⵀⴰⵔ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK19_12","072_19_12","LUK","19","12","12","ⵉⵏⵏⴰ: “ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵍⴻⵊⵡⴰⴷ ⵉⵔⵓⵃ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵉⴳⴳⵯⴻⵊ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⴰⴳⴻⵍⴷⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK19_13","072_19_13","LUK","19","13","13","ⵉⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵄⴻⵛⵔⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵄⴻⵛⵔⴰ ⵏ ⵍⵎⵉⵏⴰⵜ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⴳⴳⴻⵎ ⵜⵜⵉⵊⴰⵔⴰ ⴰⵍ ⴷⴷ ⵖⴰ ⵄⴻⵇⴱⴻⵖ’. ");
INSERT INTO rift_vpl VALUES ("LK19_14","072_19_14","LUK","19","14","14","ⵎⴰⵛⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵛⴰⵔⵔⵀⴻⵏ ⵜ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵏⵏⴰⵏ: ‘ⵡⴰⵔ ⵏⴻⵅⵙ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("LK19_15","072_19_15","LUK","19","15","15","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⵉⴽⵙⵉ ⵜⴰⴳⴻⵍⴷⴰ, ⵢⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵍⴰⵖⴰⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⵓⵎⵉ ⵉⵡⵛⴰ ⵏⵏⵓⵇⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⴰⵔⴱⴻⵃ ⵉ ⴷⴷ-ⵢⵉⵡⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴷⵉ ⵜⵙⴻⴱⴱⴰⴱⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK19_16","072_19_16","LUK","19","16","16","ⵢⵓⵙⴰ-ⴷⴷ ⵓⵎⴻⵣⵡⴰⵔ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵍⵎⵉⵏⴰ ⵏⵏⴻⵛ ⵜⵉⵡⵉ-ⴷⴷ ⵄⴻⵛⵔⴰ ⵍⵎⵉⵏⴰⵜ’. ");
INSERT INTO rift_vpl VALUES ("LK19_17","072_19_17","LUK","19","17","17","ⵉⵏⵏⴰ ⴰⵙ: ‘ⵎⵍⵉⵃ ⵛⴻⴽ, ⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵅ ⴷⵔⵓⵙ, ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵄⴻⵛⵔⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ.’ ");
INSERT INTO rift_vpl VALUES ("LK19_18","072_19_18","LUK","19","18","18","ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵍⵎⵉⵏⴰ ⵏⵏⴻⵛ ⵜⵉⵡⵉ-ⴷⴷ ⵅⴻⵎⵙⴰ ⵍⵎⵉⵏⴰⵜ.’ ");
INSERT INTO rift_vpl VALUES ("LK19_19","072_19_19","LUK","19","19","19","ⵉⵏⵏⴰ ⵉ ⵡⴰⵏⵉⵜⴰ ⵄⴰⵡⴻⴷ: ‘ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵅⴻⵎⵙⴰ ⵏ ⵜⵏⴻⴷⴷⴰⵎ!’ ");
INSERT INTO rift_vpl VALUES ("LK19_20","072_19_20","LUK","19","20","20","ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: ‘ⴰ ⵙⵉⴷⵉ, ⵅⵣⴰⵔ ⵍⵎⵉⵏⴰ ⵏⵏⴻⵛ ⵉ ⵜⵓⵖⴰ ⵅⴻⵎⵎⵍⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵣⵣⵉⴼ ⵏ ⵍⴻⵇⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK19_21","072_19_21","LUK","19","21","21","ⵎⵉⵏⵣⵉ ⴳⴳⵯⴻⴷⴻⵖ ⵣⵣⴰⵢⴻⴽ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵜⵇⴻⵙⵃⴻⴷ. ⵛⴻⴽ ⵜⴽⴻⵙⵙⵉⴷ ⵎⵉⵏ ⵡⴰⵔ ⵜⴻⵙⵙⵔⵓⵙⵉⴷ ⵓ ⵜⵎⴻⵊⵊⴰⵔⴻⴷ ⵎⵉⵏ ⵡⴰⵔ ⵜⵣⴰⵔⵄⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("LK19_22","072_19_22","LUK","19","22","22","ⵉⵏⵏⴰ ⴰⵙ: ‘ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⴷ ⵅⴰⴽ ⵛⴰⵔⵔⵄⴻⵖ, ⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵄⴻⴼⴼⴰⵏ! ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉⵇⵙⴻⵃ, ⴽⴻⵙⵙⵉⵖ ⵎⵉⵏ ⵡⴰⵔ ⵙⵙⵔⵓⵙⵉⵖ, ⵎⴻⵊⵊⴰⵔⴻⵖ ⵎⵉⵏ ⵡⴰⵔ ⵣⴰⵔⵄⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LK19_23","072_19_23","LUK","19","23","23","ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵉⵏⵓ ⴷⵉ ⵍⴱⴰⵏⴽⵓ? ⵅⴻⵏⵏⵉ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ, ⴰⴷ ⵜⴻⵏⵜ ⴽⵙⵉⵖ ⵙ ⵍⴼⴰⵢⴷⴰ.’ ");
INSERT INTO rift_vpl VALUES ("LK19_24","072_19_24","LUK","19","24","24","ⵉⵏⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ: ‘ⴽⵙⵉⵎ ⵅⴰⵙ ⵍⵎⵉⵏⴰ ⵏⵏⴻⵙ, ⵡⵛⴻⵎ ⵜⵜ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵄⴻⵛⵔⴰ ⵏ ⵍⵎⵉⵏⴰⵜ.’” ");
INSERT INTO rift_vpl VALUES ("LK19_25","072_19_25","LUK","19","25","25","ⵏⵏⴰⵏ ⴰⵙ: ‘ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵍⵎⵉⵏⴰⵜ ⵄⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("LK19_26","072_19_26","LUK","19","26","26","“ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ‘ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ, ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ, ⴰⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK19_27","072_19_27","LUK","19","27","27","ⵎⴰⵛⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵉⵏⵓ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵅⵙⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵊⴻⴵⵉⴷ, ⴰⵡⵢⴻⵎ ⵜⴻⵏ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ ⵓⵛⴰ ⵖⴰⵔⵚⴻⵎ ⴰⵙⴻⵏ ⵣⵣⴰⵜⵉ.’” ");
INSERT INTO rift_vpl VALUES ("LK19_28","072_19_28","LUK","19","28","28","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵣⵡⴰⵔ ⴰⵙⴻⵏ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK19_29","072_19_29","LUK","19","29","29","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⴱⴰⵢⵜ-ⴼⴰⵊⵉ ⴷ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵡⴻⴷⵔⴰⵔ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ’, ⵉⵙⵙⴻⴽⴽ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK19_30","072_19_30","LUK","19","30","30","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ ⵖⴰⵔ ⴷⵛⴰⵔ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏⵡⴻⵎ. ⵅⵣⴰⵔ, ⵅⵎⵉ ⴷⵉⵏ ⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ, ⴰⴷ ⵜⴰⴼⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵙⵏⵓⵙ ⵉⵇⵇⴻⵏ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵏⵢⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵄⴰⴷ. ⴼⴻⵙⵢⴻⵎ ⴰⵙ ⵓⵛⴰ ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("LK19_31","072_19_31","LUK","19","31","31","ⵎⴰⵍⴰ ⵉⵙⵙⴻⵇⵙⴰ ⴽⴻⵏⵏⵉⵡ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵙ ⵜⴼⴻⵙⵢⴻⵎ?’, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ ⴰⵎⵎⵓ: ‘ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵃⵡⴰⵊ ⵉ-ⵜ!’” ");
INSERT INTO rift_vpl VALUES ("LK19_32","072_19_32","LUK","19","32","32","ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵔⵓⵃⴻⵏ ⵓⵛⴰ ⵓⴼⵉⵏ ⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK19_33","072_19_33","LUK","19","33","33","ⴰⵍⴰⵎⵉ ⴷ ⴼⴻⵙⵢⴻⵏ ⵉ ⵡⴻⵙⵏⵓⵙ, ⵙⵙⴻⵇⵙⴰⵏ ⵜⴻⵏ ⴰⵢⵜⴱⴰⴱ ⵏⵏⴻⵙ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴼⴻⵙⵙⵢⴻⵎ ⵉ ⵡⴻⵙⵏⵓⵙ?” ");
INSERT INTO rift_vpl VALUES ("LK19_34","072_19_34","LUK","19","34","34","ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵃⵡⴰⵊ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("LK19_35","072_19_35","LUK","19","35","35","ⵓⵙⵉⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⴹⴰⵔⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵅ ⵡⴻⵙⵏⵓⵙ, ⵙⵙⴻⵏⵢⴻⵏ ⵢⴰⵙⵓⵄ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK19_36","072_19_36","LUK","19","36","36","ⴰⵎ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ, ⵙⵙⵓⵏ ⵏⵉⵜⵏⵉ ⴰⴱⵔⵉⴷ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK19_37","072_19_37","LUK","19","37","37","ⵓⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵜⴻⵢⵙⴰⵔⵜ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ’, ⵉⴱⴷⴰ ⵍⵖⴰⵛⵉ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵏ, ⵜⵜⵙⴻⴱⴱⴰⵃⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⴰⵟⵟⴰⵙ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵥⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("LK19_38","072_19_38","LUK","19","38","38","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ! ⵍⴻⵀⵏⴰ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴷ ⵓⵄⵓⴵⵉ ⴷⵉ ⵍⵓⵄⵍⴰ ⵅ ⵍⵓⵄⵍⴰ ⵇⴰⵄ!” ");
INSERT INTO rift_vpl VALUES ("LK19_39","072_19_39","LUK","19","39","39","ⵎⴰⵛⴰ ⵛⴰ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵊⴰⵔ ⵍⵖⴰⵛⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵡⴻⴱⴱⴻⵅ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK19_40","072_19_40","LUK","19","40","40","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵍⴰ ⵙⵇⴰⵔⴻⵏ ⵉⵏⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵍⴰⵖⴰⵏ ⵢⴻⵥⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK19_41","072_19_41","LUK","19","41","41","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵓⵛⴰ ⵉⵥⵔⴰ ⵜⴰⵏⴷⵉⵏⵜ, ⵉⵔⵓ ⵅⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("LK19_42","072_19_42","LUK","19","42","42","ⵉⵏⵏⴰ: “ⵎⵍⵉ ⵜⴼⴻⵀⵎⴻⴷ ⵎⵉⵏ ⴷ ⴰⵎ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⵍⴻⵀⵏⴰ ⵏⵏⴻⵎ, ⵄⴰⴷ ⴷⴻⴳ ⵡⴰⵙⵙ-ⴰ ⵏⵏⴻⵎ! ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⵓⴼⴼⴰⵔ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK19_43","072_19_43","LUK","19","43","43","ⴰⵇⴰ ⴰⴷ ⵖⴰⵔⴻⵎ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷ ⴰⵎ ⴷⴷ ⵖⴰ ⵇⵓⵡⵡⴰⵔⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵎ ⵓ ⴰⴷ ⵛⴻⵎ ⵃⵚⴰⵔⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK19_44","072_19_44","LUK","19","44","44","ⴰⴷ ⵛⴻⵎ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⵛⴻⵎ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ ⴰⴽⵉⴷⴻⵎ, ⵡⴰⵔ ⴷⴰⵢⴻⵎ ⵜⵜⴻⵊⵊⵉⵏ ⴰⵥⵔⵓ ⵉⴱⴻⴷⴷ ⵅ ⵡⴻⵥⵔⵓ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⴼⵜⵉⵏⴻⴷ ⵉ ⵍⵡⴻⵇⵜ ⵏ ⵡⴰⵔⵣⴻⴼ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK19_45","072_19_45","LUK","19","45","45","ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⴱⴷⴰ ⵉⵙⵙⵓⴼⴼⵓⵖ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵖⴻⵏ ⵓ ⵉⵣⵣⵏⵓⵣⴰⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK19_46","072_19_46","LUK","19","46","46","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵜⵓⵔⴰ: ‘ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵥⴰⴵⵉⵜ!’, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⵔⵉⵎ ⵜⵜ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⵔⵉ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK19_47","072_19_47","LUK","19","47","47","ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵛⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK19_48","072_19_48","LUK","19","48","48","ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⵉⵏ ⵅⴰⵙ ⵖⴰ ⴳⴳⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵜⵓⵖⴰ ⵍⴻⵚⵇⴻⵏ ⴷⴰⵢⴻⵙ, ⵜⵜⴻⵙⵍⴰⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK20_1","072_20_1","LUK","20","1","1","ⴷⴻⴳ ⵉⵊⵊ ⵣⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⴰⵎ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵍⴳⴻⵏⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵅⴻⵏⵏⵉ ⵖⴻⵡⵡⵖⴻⵏ ⵅⴰⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("LK20_2","072_20_2","LUK","20","2","2","ⵙⵙⵉⵡⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵏⵏⴰⵏ: “ⵉⵏⵉ ⴰⵏⴻⵖ, ⵙ ⵎⴰⵏ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⴰⵢⴰ, ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ ⵜⵜⴻⵙⵔⵉⵃ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK20_3","072_20_3","LUK","20","3","3","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵇⵙⵉⵖ ⵉⵊⵊ ⵏ ⵓⵙⴻⵇⵙⵉ. ⵉⵏⵉⵎ ⴰⵢⵉ: ");
INSERT INTO rift_vpl VALUES ("LK20_4","072_20_4","LUK","20","4","4","ⵎⴰ ⴰⵙⴻⵖⴹⴻⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⵣⴻⴳ ⵉⵡⴷⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK20_5","072_20_5","LUK","20","5","5","ⵎⵛⴰⵡⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵏⴻⵏⵏⴰ: ‘ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ!’, ⴰⴷ ⵢⵉⵏⵉ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵎⵉⵏⴻⵎ?’ ");
INSERT INTO rift_vpl VALUES ("LK20_6","072_20_6","LUK","20","6","6","ⵎⴰⵍⴰ ⵏⴻⵏⵏⴰ: ‘ⵣⴻⴳ ⵉⵡⴷⴰⵏ!’, ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⵊⴻⵎ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⴱⴻⵍⵍⵉ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⴰⵏⴰⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK20_7","072_20_7","LUK","20","7","7","ⵏⵏⴰⵏ ⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵣⵉ ⵎⴰⵏⵉⵙ!” ");
INSERT INTO rift_vpl VALUES ("LK20_8","072_20_8","LUK","20","8","8","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⵙ ⵎⴰⵏ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵜⵜⴻⴳⴳⴻⵖ ⴰⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK20_9","072_20_9","LUK","20","9","9","ⵉⴱⴷⴰ ⵉⵜⵜⵄⴰⵡⴰⴷ ⵉ ⵍⴳⴻⵏⵙ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ: “ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ, ⵉⵥⵥⵓ ⴷⴰⵢⴻⵙ ⵜⵉⵣⴰⵢⴰⵔⵉⵏ, ⵉⵛⵔⴰ ⴰⵎⴰⵔⵊⴻⵄ ⵉ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ, ⵓⵛⴰ ⵉⵙⴰⴼⴰⵔ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⴰⵣⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK20_10","072_20_10","LUK","20","10","10","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵍⵃⴰⵍ, ⵉⵙⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵖⴰⵔ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵣⴻⴳ ⵓⴹⵉⵍ ⵏ ⵓⵎⴰⵔⵊⴻⵄ. ⵡⵜⵉⵏ ⵜ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵏⵉ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵉⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("LK20_11","072_20_11","LUK","20","11","11","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵖⵏⵉ, ⵡⵜⵉⵏ ⵜ ⵄⴰⵡⴻⴷ, ⴷⴻⴵⴻⵏ ⵜ, ⵅⴻⵏⵏⵉ ⵙⴻⴽⴽⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵉⵅⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("LK20_12","072_20_12","LUK","20","12","12","ⵉⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵢⴻⵣⵎⴻⵏ ⵜ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK20_13","072_20_13","LUK","20","13","13","ⵉⵏⵏⴰ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ: ‘ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ? ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ. ⵅⵎⵉ ⵜ ⵖⴰ ⵥⴰⵔⴻⵏ, ⴰⴷ ⵜ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵏⵉⵛⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK20_14","072_20_14","LUK","20","14","14","ⵓⵎⵉ ⵜ ⵥⵔⵉⵏ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ, ⵎⵛⴰⵡⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: ‘ⴰⵇⴰ ⴷ ⵡⴰ ⴷ ⴰⵡⵔⵉⵜ. ⵣⵉⴷ ⴰⴷ ⵜ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵍⵡⴰⵔⵜ.’ ");
INSERT INTO rift_vpl VALUES ("LK20_15","072_20_15","LUK","20","15","15","ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵓⵛⴰ ⵏⵖⵉⵏ ⵜ. ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵅⴻⵏⵏⵉ ⴱⴰⴱ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("LK20_16","072_20_16","LUK","20","16","16","ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⴷ ⵉⵏⴻⵖ ⵉⵅⴻⵎⵎⴰⵙⴻⵏ ⵏⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵉⵡⵛ ⴰⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ ⵉ ⵉⵏⵏⴻⵖⵏⵉ.” ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⵄⴻⵎⵎⴰⵔⵚ!” ");
INSERT INTO rift_vpl VALUES ("LK20_17","072_20_17","LUK","20","17","17","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵣⴰⵔ ⵖⴰⵔⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵅⴻⵏⵏⵉ ⵡⴰⵡⴰⵍ-ⴰ ⵉ ⵢⵓⵔⴰⵏ: ‘ⴰⵥⵔⵓ ⵉ ⵜⵓⵖⴰ ⵉⵄⵉⴼⴼⴻⵏ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵥⵔⵓ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ! ");
INSERT INTO rift_vpl VALUES ("LK20_18","072_20_18","LUK","20","18","18","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵡⴹⴰⵏ ⵅ ⵡⴻⵥⵔⵓ-ⵢⴰ, ⴰⴷ ⵉⴼⴰⵔⵜⴻⴽ, ⵓ ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵉ ⵖⴰ ⵉⵡⴹⴰ, ⴰⴷ ⵜ ⵉⵍⴱⴻⵣ’?” ");
INSERT INTO rift_vpl VALUES ("LK20_19","072_20_19","LUK","20","19","19","ⴰⵔⴻⵣⵣⵓⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴷ ⵅⴰⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_20","072_20_20","LUK","20","20","20","ⵃⴹⴰⵏ ⵜ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⴳⴳⴻⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵍⵇⴰⴹⵉ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⵍⵄⴰⵎⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("LK20_21","072_20_21","LUK","20","21","21","ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵓ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⵏⵉⵛⴰⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵛⴰ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵓ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⴰⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("LK20_22","072_20_22","LUK","20","22","22","ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⵛ ⵍⴻⵄⵛⵓⵔ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵓⵣⴻⴵⵉⴼ ⵉ ⵇⴰⵢⵚⴰⵔ ⵏⵉⵖ ⵍⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK20_23","072_20_23","LUK","20","23","23","ⵢⵓⵛⴰ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("LK20_24","072_20_24","LUK","20","24","24","ⵙⴻⵛⵏⴻⵎ ⴰⵢⵉ-ⴷⴷ ⴷⵉⵏⴰⵔ. ⵡⵉ ⵢⵉⵍⴰⵏ ⵜⴰⵚⵡⵉⵔⵜ-ⴰ ⴷ ⵜⵉⵔⴰ-ⵢⴰ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵏ ⵇⴰⵢⵚⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("LK20_25","072_20_25","LUK","20","25","25","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵡⵛⴻⵎ ⵅⴻⵏⵏⵉ ⵉ ⵇⴰⵢⵚⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵇⴰⵢⵚⴰⵔ ⵓ ⵉ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("LK20_26","072_20_26","LUK","20","26","26","ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵇⵇⵉⵎⴻⵏ ⵜⵜⴱⴻⵀⵜⴻⵏ ⵙ ⵜⴻⵎⵡⴰⵔⵔⵉⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵙⴻⵖⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_27","072_20_27","LUK","20","27","27","ⵓⵙⵉⵏ-ⴷⴷ ⵛⴰ ⵣⴻⴳ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ, ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵍⵎⴻⵡⵜ. ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ");
INSERT INTO rift_vpl VALUES ("LK20_28","072_20_28","LUK","20","28","28","ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵢⵓⵔⴰ ⴰⵏⴻⵖ ⵎⵓⵙⴰ, ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵉ ⵡⴻⵔⵢⴰⵣ ⵓⵎⴰⵙ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵓⵛⴰ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⴰⵡⵉ ⵓⵎⴰⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴻⵊⵊ ⴰⵃⴻⵏⵊⵉⵔ ⵉ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK20_29","072_20_29","LUK","20","29","29","ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ. ⴰⵎⴻⵣⵡⴰⵔ ⵢⵉⵡⵉ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_30","072_20_30","LUK","20","30","30","ⵢⵉⵡⵉ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_31","072_20_31","LUK","20","31","31","ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵢⵉⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉⵏⵏⴻⵖⵏⵉ ⴰⵍ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ. ⵎⵎⵓⵜⴻⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ, ⵡⴰⵔ ⴷⴷ-ⵊⵊⵉⵏ ⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_32","072_20_32","LUK","20","32","32","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵜⴻⵎⵎⵓⵜ ⵜⴻⵎⵖⴰⵔⵜ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("LK20_33","072_20_33","LUK","20","33","33","ⴷⵉ ⵜⵏⵓⴽⵔⴰ ⵉ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵖⴰⵔⵜ? ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵜⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("LK20_34","072_20_34","LUK","20","34","34","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⵢⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵉⵡⵢⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵜⵡⴰⵙⵙⵎⴻⴵⴰⵛⴻⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_35","072_20_35","LUK","20","35","35","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵙⴷⴰⵀⴻⴵⴻⵏ ⴰⴷ ⴰⵡⴹⴻⵏ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⵏⵏⵉ ⵓ ⵖⴰⵔ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⵡⵢⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵓ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_36","072_20_36","LUK","20","36","36","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵄⴰⴷ ⴰⴷ ⵎⵎⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⵎ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵓ ⵏⵉⵜⵏⵉ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⵏⵓⴽⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK20_37","072_20_37","LUK","20","37","37","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ, ⵜⵓⵖⴰ ⵉⵙⵙⴱⴻⵢⵢⴰⵏ ⵎⵓⵙⴰ ⵄⴰⵡⴻⴷ ⵓⵎⵉ ⵉⵃⴰⵊⴰ ⵅ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵙⵃⴰⵇ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ.’ ");
INSERT INTO rift_vpl VALUES ("LK20_38","072_20_38","LUK","20","38","38","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵎⴰⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⵙ ⵏⴻⵜⵜⴰ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK20_39","072_20_39","LUK","20","39","39","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵛⴰ ⵣⴻⴳ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("LK20_40","072_20_40","LUK","20","40","40","ⵓⵛⴰ ⵡⴰⵔ ⵣⵄⵉⵎⴻⵏ ⵄⴰⴷ ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LK20_41","072_20_41","LUK","20","41","41","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴰⴷ ⵉⵏⵉⵏ ⴱⴻⵍⵍⵉ ⵍⵎⴰⵙⵉⵃ ⴷ ⵎⵎⵉⵙ ⵏ ⴷⴰⵡⵓⴷ? ");
INSERT INTO rift_vpl VALUES ("LK20_42","072_20_42","LUK","20","42","42","ⴷⴰⵡⵓⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵇⵇⴰⵔ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ: ‘ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ⵇⵇⵉⵎ ⵅ ⵓⴼⵓⵙⵉ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("LK20_43","072_20_43","LUK","20","43","43","ⴰⵍ ⴷ ⵖⴰ ⵙⵙⴰⵔⵙⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("LK20_44","072_20_44","LUK","20","44","44","ⵎⴰⵍⴰ ⴷⴰⵡⵓⴷ ⵉⵙⴻⵎⵎⴰ ⵜ ‘ⵙⵉⴷⵉ’, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ?” ");
INSERT INTO rift_vpl VALUES ("LK20_45","072_20_45","LUK","20","45","45","ⴰⵎ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵍⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("LK20_46","072_20_46","LUK","20","46","46","“ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵙ ⵉⵊⴻⴵⴰⴱⴻⵏ ⵉⵣⵉⵔⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⴻⵄⵊⵉⴱ ⴰⵙⴻⵏ ⴰⴷ ⵅⴰⵙⴻⵏ ⵙⴻⴵⵎⴻⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵍⴻⵙⵡⴰⵇ ⵓ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵅ ⵍⴻⴽⵔⴰⵙⵉ ⵉⵚⴻⴱⵃⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵓ ⵅ ⵉⵎⵓⵛⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵖⴰⵔ ⵉⵎⴻⵏⵙⵉⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK20_47","072_20_47","LUK","20","47","47","ⵏⵉⵜⵏⵉ ⵜⵜᵉⵜⵜⴻⵏ ⵜⵓⴷⵔⵉⵏ ⵏ ⵜⵉⵊⵊⴰⵍ ⴰⵎ ⵜⵜᵉⵜⵜⴰⵔⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵥⴰⴵⴰⵜⵉⵏ ⵏⵙⴻⵏ ⵜⵉⵣⵉⵔⴰⵔⵉⵏ. ⴰⵇⴰ ⵉⵏⴰ ⴰⴷ ⴽⵙⵉⵏ ⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵇⵙⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("LK21_1","072_21_1","LUK","21","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵡⴻⴹ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⵙⵙⵔⵓⵙⴰⵏ ⵚⵚⴷⴰⵇⵉ ⵏⵙⴻⵏ ⴷⵉ ⵙⵙⴻⵏⴷⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("LK21_2","072_21_2","LUK","21","2","2","ⵉⵥⵔⴰ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵜⴰⵎⴻⵣⵍⵓⴹⵜ ⵜⴻⵙⵙⴰⵔⵙ ⴷⴰⵢⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵓⵇⵉⵢⵢⴰⵜ, ⵙⴻⵎⵎⴰⵏ ⵜⴻⵏⵜ ‘ⵛⴰⵎⵓⵏⴰⵜ’. ");
INSERT INTO rift_vpl VALUES ("LK21_3","072_21_3","LUK","21","3","3","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵜⴰⵊⵊⴰⵍⵜ-ⴰ ⵍⵎⴻⵙⴽⵉⵏⴰ ⵜⴻⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK21_4","072_21_4","LUK","21","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵣⵉ ⵣⵣⵉⵢⴰⴷⴰ ⵏ ⵡⴰⴳⵍⴰ ⵏⵙⴻⵏ ⵉⵛⵜ ⵏ ⵚⵚⴻⴷⵇⴻⵜ ⴷⴻⴳ ⵡⴻⵅⵅⴰⵎ ⵏ ⵚⵚⴷⴰⵇⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵣⵉ ⵍⴻⵅⵚⴻⵚ ⵏⵏⴻⵙ ⴰⵇⴰ ⵜⴻⵏⴹⴰⵔ ⴷⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK21_5","072_21_5","LUK","21","5","5","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⴻⵏⵏⵉ ⵜⵣⴻⵡⵡⴻⵇ ⵙ ⵉⵥⵔⴰ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⵚⵚⴷⴰⵇⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: ");
INSERT INTO rift_vpl VALUES ("LK21_6","072_21_6","LUK","21","6","6","“ⵎⴰ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ? ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵅ ⵡⴻⵥⵔⵓ ⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴰⵔ ⵉⵜⵜⴰⵔⴻⴷⴷⴵⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK21_7","072_21_7","LUK","21","7","7","ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵎⴻⵍⵎⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵢⴰ ⴷ ⵎⴰⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴰⵇⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵓⴷⵙⴻⵏⵜ-ⵉ-ⴷⴷ?” ");
INSERT INTO rift_vpl VALUES ("LK21_8","072_21_8","LUK","21","8","8","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵄⴻⵙⵙⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵉⵏⵉⵏ: ‘ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵍⵎⴰⵙⵉⵃ!’ ⵓ: ‘ⵍⵡⴻⵇⵜ ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ!’, ⵎⴰⵛⴰ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵎ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK21_9","072_21_9","LUK","21","9","9","ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵅ ⵍⴱⴰⵔⵓⴹ ⴷ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵙ ⵓⵖⵉⵍ ⴰⴷ ⵢⵉⵍⵉ ⵓⵢⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⴷⴻⵖⵢⴰ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK21_10","072_21_10","LUK","21","10","10","ⵎⴰⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⴹⵉⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖⵏⵉ ⵓ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⴹⵉⴷⴷ ⵏ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("LK21_11","072_21_11","LUK","21","11","11","ⴰⴷ ⵉⵍⵉⵏ ⵉⵏⵀⴻⵣⵣⵉⵢⵢⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⵖⴰⵔⴻⵏ ⴷⵉ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵎⵓⵛⴰⵏ ⴷ ⵍⴰⵥ ⴷ ⵊⵊⵔⴰⵢⴻⵃ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵓⵙⵏⴻⵅⵍⵉⵄ. ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴱⴰⵏⴻⵏⵜ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵎⵖⴰⵔⴻⵏⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵜⵃⴰⵔⵢⴰⴹⵉⵏ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK21_12","072_21_12","LUK","21","12","12","ⵎⴰⵛⴰ ⵇⴱⴻⵍ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⴷ ⵍⴻⵃⴱⵓⵙⴰⵜ, ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⴻⴷⵀⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK21_13","072_21_13","LUK","21","13","13","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵢⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵛⴻⵀⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK21_14","072_21_14","LUK","21","14","14","ⴳⴳⴻⵎ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴰⵔⴻⵣⵣⵓⵎ ⴰⴷ ⵜⵍⴻⵎⴷⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK21_15","072_21_15","LUK","21","15","15","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⴷ ⵜⵉⵖⵉⵜ ⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("LK21_16","072_21_16","LUK","21","16","16","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵎ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵡⴻⵎ ⴷ ⵜⴰⵡⵎⴰⵜ ⵏⵡⴻⵎ ⴷ ⵍⴰⴵ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⵏⵖⴻⵏ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LK21_17","072_21_17","LUK","21","17","17","ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⴰⵔⵀⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK21_18","072_21_18","LUK","21","18","18","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵥⴻⵟⵟⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴻⴷⴷⴰⵔⵉ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("LK21_19","072_21_19","LUK","21","19","19","ⵎⴰⵛⴰ ⵙ ⵚⵚⴱⴰⵔ ⵏⵡⴻⵎ ⴰⴷ ⵜⴰⵔⴻⴱⵃⴻⵎ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK21_20","072_21_20","LUK","21","20","20","“ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵇⴰ ⵉⵏⵏⴻⴹ ⴰⵙ-ⴷⴷ ⵍⵄⴻⵙⴽⴰⵔ, ⵅⴻⵏⵏⵉ ⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK21_21","072_21_21","LUK","21","21","21","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵖⴰⵔ ⵉⴷⵓⵔⴰⵔ, ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵙ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴼⴼⵖⴻⵏ, ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ, ⴷ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⵛⵓⵔⴰⵜ, ⵡⴰⵔ ⵜⵜ ⵜⵜⵉⴷⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("LK21_22","072_21_22","LUK","21","22","22","ⵎⵉⵏⵣⵉ ⵉⵏⴰ ⴷ ⵓⵙⵙⴰⵏ ⵏ ⵏⵏⴻⵇⵎⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⵉⵏ.    ");
INSERT INTO rift_vpl VALUES ("LK21_23","072_21_23","LUK","21","23","23","ⵓⵛⵜ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ ⴷ ⵜⵉⵏⵏⵉ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵡⴻⵖⴹⴰⴱ ⵅ ⵍⴳⴻⵏⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("LK21_24","072_21_24","LUK","21","24","24","ⵏⵉⵜⵏⵉ ⴰⴷ ⵡⴹⴰⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⴰⴷ ⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ ⴰⵎ ⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴷ ⵅⴰⵙ ⵄⴻⴼⵙⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵍ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏⵜ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK21_25","072_21_25","LUK","21","25","25","“ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷⵉ ⵜⴼⵓⵛⵜ, ⴷⵉ ⵜⵣⵉⵔⵉ ⵓ ⴷⴻⴳ ⵉⵜⵔⴰⵏ, ⵓⵛⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ ⴷⵉ ⵍⴻⴳⵏⵓⵙ, ⴰⵍ ⴷ ⴰⵙⴻⵏ ⵉⵡⴻⴷⴷⴰⵔ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ ⵣⴻⴳ ⵓⵏⴻⵅⵍⵉⵄ ⵏ ⵣⵣⵀⵉⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("LK21_26","072_21_26","LUK","21","26","26","ⵓ ⵣⴻⴳ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵉⵙⵙⵏⴻⵅⵍⵉⵄ ⵍⴻⵄⵎⴰⵔ ⵏ ⵉⵡⴷⴰⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓ ⵚⵚⵓⵍⴰⵟⴰⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵏⵀⴻⵣⵣⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK21_27","072_21_27","LUK","21","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⵙ ⵊⵊⴻⵀⴷ ⴷ ⵓⵄⵓⴵⵉ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK21_28","072_21_28","LUK","21","28","28","ⵅⵎⵉ ⵖⴰ ⴱⴷⴰⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴳⴳⴻⵎ ⵜⴰⵔⵢⴰⵙⵜ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵡⴻⵎ ⵎⵉⵏⵣⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵏⵡⴻⵎ ⴰⵇⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("LK21_29","072_21_29","LUK","21","29","29","ⵉⵄⴰⵡⴻⴷ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ: “ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵡⴰⵔⵜⵓ ⵏ ⵜⴰⵣⴰⵔⵜ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK21_30","072_21_30","LUK","21","30","30","ⵅⵎⵉ ⵖⴰ ⵙⵙⵏⴻⴹⵢⴻⵏⵜ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⴰⵏⴻⴱⴷⵓ ⵢⵉⵡⴻⴹ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("LK21_31","072_21_31","LUK","21","31","31","ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ, ⵅⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵜⴻⵎⵙⴰⵔⴰⵏⵜ, ⵙⵏⴻⵎ ⵅⴻⵏⵏⵉ ⴱⴻⵍⵍⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵓⴷⴻⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("LK21_32","072_21_32","LUK","21","32","32","ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵓ ⵊⵊⵉⵍ-ⴰ ⴰⵍ ⵖⴰ ⵢⵉⵍⵉ ⵓⵢⴰ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LK21_33","072_21_33","LUK","21","33","33","ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵄⴻⴷⴷⵓⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⵡⴰⵔ ⵄⴻⴷⴷⵓⵏ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("LK21_34","072_21_34","LUK","21","34","34","ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⴹⵇⵉⵍⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵣⴻⴳ ⵓⴼⵓⵛⵛⴻⵃ ⴷ ⵡⴻⵙⵛⴰⵔ ⴷ ⵉⵎⵓⵏⴰⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵓ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵡⴹⵉ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK21_35","072_21_35","LUK","21","35","35","ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵙⵙ ⵏⵏⵉ ⴰⵎ ⵍⴼⴻⵅ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LK21_36","072_21_36","LUK","21","36","36","ⵃⴹⴰⵎ ⵅⴻⵏⵏⵉ ⵍⴻⴱⴷⴰ, ⵥⴰⴵⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴻⵙⴷⴰⵀⴻⴵⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵏⴻⵊⵎⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK21_37","072_21_37","LUK","21","37","37","ⵙ ⵓⵣⵉⵍ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵛⴰ ⵙ ⴵⵉⵍⴻⵜ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴼⴼⴻⵖ, ⵉⵜⵜⵖⵉⵎⴰ ⵉⵜⵜⵏⵓⵙⴰ ⵅ ⵡⴻⴷⵔⴰⵔ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ’. ");
INSERT INTO rift_vpl VALUES ("LK21_38","072_21_38","LUK","21","38","38","ⴷⵉ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵜⵓⵖⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK22_1","072_22_1","LUK","22","1","1","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵍⵄⵉⴷ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵍⵄⵉⴷ ⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("LK22_2","072_22_2","LUK","22","2","2","ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_3","072_22_3","LUK","22","3","3","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵛⵛⵉⵟⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⴰ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_4","072_22_4","LUK","22","4","4","ⵉⵔⵓⵃ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉ ⵖⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK22_5","072_22_5","LUK","22","5","5","ⴼⴰⵔⵃⴻⵏ ⵓⵛⴰ ⵜⵜⴰⴼⵇⴻⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵜⵉⵏⵄⴰⵛⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LK22_6","072_22_6","LUK","22","6","6","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵡⴰⵍ ⵓⵛⴰ ⵢⴰⵔⵣⵓ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵜ ⵉⵙⴻⵍⵍⴻⵎ ⴱⴰⵔⵔⴰ ⵉ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("LK22_7","072_22_7","LUK","22","7","7","ⵢⵉⵡⴻⴹ-ⴷⴷ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("LK22_8","072_22_8","LUK","22","8","8","ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵔⵓⵃⴻⵎ, ⵜⴻⵙⵙⵡⴻⵊⴷⴻⵎ ⴰⵏⴻⵖ ⵉ ⵓⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK22_9","072_22_9","LUK","22","9","9","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("LK22_10","072_22_10","LUK","22","10","10","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔ, ⵅⵎⵉ ⵖⴰ ⵜⴰⴷⴼⴻⵎ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵍⵇⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵢⴰⵔⴱⵓ ⵉⵛⵜ ⵏ ⵜⴻⵇⴱⵓⵛⵜ ⵏ ⵡⴰⵎⴰⵏ. ⴹⴼⴰⵔⴻⵎ ⵜ! ");
INSERT INTO rift_vpl VALUES ("LK22_11","072_22_11","LUK","22","11","11","ⵉⵏⵉⵎ ⵉ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ: ‘ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ ⵉⵙⵙⴻⵇⵙⴰ: ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵅⵅⴰⵎ ⵏ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵛⵛⴻⵖ ⵓⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ?’ ");
INSERT INTO rift_vpl VALUES ("LK22_12","072_22_12","LUK","22","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵛⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⵓⵔⴼⴻⵜ ⵜⵎⵉⵔⵉⵡⵜ ⵙⴻⵏⵏⴻⵊ, ⵢⴻⵙⵙⵓ ⵙ ⵉⴱⴰⵢⴰⵙⴻⵏ. ⵙⵡⴻⵊⴷⴻⵎ ⴷⵉⵏ ⴽⵓⵍⵛⵉ!” ");
INSERT INTO rift_vpl VALUES ("LK22_13","072_22_13","LUK","22","13","13","ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ, ⵓⴼⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵓⵛⴰ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵙⵉ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("LK22_14","072_22_14","LUK","22","14","14","ⵓⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵜⵙⴰⵄⵄⴻⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK22_15","072_22_15","LUK","22","15","15","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵡⴻⵃⵃⵛⴻⵖ ⴰⵟⵟⴰⵙ ⴰⴷ ⵛⵛⴻⵖ ⴰⵎⴻⵏⵙⵉ-ⵢⴰ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⴽⵉⴷⵡⴻⵎ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵡⴻⴷⴷⴱⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("LK22_16","072_22_16","LUK","22","16","16","ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜⵜᵉⵜⵜⴻⵖ ⵄⴰⴷ ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK22_17","072_22_17","LUK","22","17","17","ⵅⴻⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵉⵊⵊ ⵏ ⵍⴽⴰⵙ ⵓⵛⴰ ⵉⵇⴰⴷⴰ, ⵉⵏⵏⴰ: “ⴽⵙⵉⵎ ⵡⴰ, ⴱⴹⴰⵎ ⵜ ⵊⴰⵔ ⴰⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("LK22_18","072_22_18","LUK","22","18","18","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵡⴰⵔ ⵙⴻⵙⵙⴻⵖ ⵛⴰ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴰⵍ ⴷⴷ ⵜⵓⵙⴰ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK22_19","072_22_19","LUK","22","19","19","ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ, ⵉⵇⴰⴷⴰ, ⵢⴰⵔⵥⴰ ⵉ-ⵜ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜ, ⵉⵏⵏⴰ: “ⵜⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵜⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛⴻⵏ. ⴳⴳⴻⵎ ⴰⵢⴰ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("LK22_20","072_22_20","LUK","22","20","20","ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵅ ⵍⴽⴰⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵎⴻⵏⵙⵉ: “ⵍⴽⴰⵙ-ⴰ ⴷ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ ⵉⵏⵏⵉ ⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵉⵣⵣⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_21","072_22_21","LUK","22","21","21","ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⴰ, ⴰⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("LK22_22","072_22_22","LUK","22","22","22","ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵔⴰⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ, ⵎⴰⵛⴰ ⵓⵛⵜ ⵅ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉ ⵜ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK22_23","072_22_23","LUK","22","23","23","ⴱⴷⴰⵏ ⵜⵜⴻⵎⵙⵙⴻⵇⵙⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK22_24","072_22_24","LUK","22","24","24","ⵜⵓⵖⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵎⵛⵓⴱⴱⴻⵛ ⵅ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("LK22_25","072_22_25","LUK","22","25","25","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵚⴻⵍⵍⵟⴻⵏ ⵅⴰⵙⴻⵏ, ⵓ ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵚⴻⵍⵍⵟⴻⵏ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ ‘ⵜⴰⵔⵡⴰ ⵏ ⵔⴻⵊⵡⴰⴷ!’    ");
INSERT INTO rift_vpl VALUES ("LK22_26","072_22_26","LUK","22","26","26","ⴽⴻⵏⵏⵉⵡ ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⴰⵎⵎⵓ, ⵎⴰⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⴰⵢⵡⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵓⵎⴰⵥⵓⵥ, ⵓ ⴰⵎⴻⵣⵡⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎ ⵓⵎⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK22_27","072_22_27","LUK","22","27","27","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ? ⵎⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ ⵏⵉⵖ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ? ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_28","072_22_28","LUK","22","28","28","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵉⵊⴰⵔⵔⵉⴱⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("LK22_29","072_22_29","LUK","22","29","29","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⴻⵄⴷⴻⵖ ⵉⵛⵜ ⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⵜ ⵉⵡⴰⵄⴷ ⴱⴰⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("LK22_30","072_22_30","LUK","22","30","30","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵅ ⵟⵟⴰⴱⵍⴰ ⵉⵏⵓ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵅ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵜⴳⴻⵍⴷⵉⵜ, ⴰⴷ ⵜⵃⴻⴽⵎⴻⵎ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("LK22_31","072_22_31","LUK","22","31","31","ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵛⵉⵎⵄⵓⵏ: “ⵛⵉⵎⵄⵓⵏ, ⵛⵉⵎⵄⵓⵏ, ⴰⵇⴰ ⵛⵛⵉⵟⴰⵏ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵣⵣⵓⵣⴰⵔ ⴰⵎ ⵢⵉⵔⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_32","072_22_32","LUK","22","32","32","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵥⵓⴵⴻⵖ ⵅⴰⴽ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ. ⵓⵍⴰ ⴷ ⵛⴻⴽ, ⵜⵓⴱ ⴷⵉ ⵍⵡⴻⵇⵜ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵙⵜⴻⴱⴱⴻⵜ ⴰⵢⵜⵎⴰⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK22_33","072_22_33","LUK","22","33","33","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⴰ ⵙⵉⴷⵉ, ⵏⴻⵛⵛ ⴰⵇⴰ ⵡⴻⵊⴷⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴽ ⵔⴰⵃⴻⵖ ⵓⵍⴰ ⵖⴰⵔ ⵍⴻⵃⴱⴻⵙ ⴷ ⵍⵎⴻⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK22_34","072_22_34","LUK","22","34","34","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⴰ ⵛⵉⵎⵄⵓⵏ, ⵡⴰⵔ ⵉⵙⵙⵇⵓⵇⵓⵄ ⵓⵢⴰⵥⵉⴹ ⴰⵙⵙ-ⴰ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK22_35","072_22_35","LUK","22","35","35","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵍⴰⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⴽⴽⴻⵖ ⴱⵍⴰ ⵜⴰⵛⵢⴰⵔⵜ, ⴱⵍⴰ ⵜⵜⴻⵙⵟⵉⵎ ⵏⵉⵖ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ, ⵎⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⵛⴰ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵍⵓ!” ");
INSERT INTO rift_vpl VALUES ("LK22_36","072_22_36","LUK","22","36","36","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴻⵛⵢⴰⵔⵜ, ⴰⴷ ⵜⵜ ⵉⴽⵙⵉ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⵜⴻⵙⵟⵉⵎ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵙⵙⵉⴼ, ⴰⴷ ⵉⵣⵣⴻⵏⵣ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⴻⵖ ⵙⵙⵉⴼ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK22_37","072_22_37","LUK","22","37","37","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ-ⵢⴰ ⴷⴰⵢⵉ: ‘ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ!’, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⴼⵉ ⵢⵓⵔⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("LK22_38","072_22_38","LUK","22","38","38","ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⴷⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵙⵢⵓⴼ!” ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⴽⴼⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK22_39","072_22_39","LUK","22","39","39","ⵉⴼⴼⴻⵖ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ’ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵏⵏⵓⵎ, ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵜ ⵄⴰⵡⴻⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK22_40","072_22_40","LUK","22","40","40","ⵓⵎⵉ ⵉⵅⴻⵛⵛ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵥⴰⴵⴻⵎ ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⴷⴻⴳ ⵓⵊⴰⵔⵔⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("LK22_41","072_22_41","LUK","22","41","41","ⵉⴼⴻⴽⴽ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⵙⴻⵏ ⵄⵍⴰⵃⴰⵍ ⵜⵉⵛⵜⵉ ⵏ ⵉⵊⵊ ⵏ ⵓⵃⴻⵊⵊⴰⵔ ⵏ ⵡⴻⵥⵔⵓ, ⵢⵓⴹⴰⵔ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵥⵥⵓⴵ, ");
INSERT INTO rift_vpl VALUES ("LK22_42","072_22_42","LUK","22","42","42","ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⴷ, ⴻⵊⵊ ⵍⴽⴰⵙ-ⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⵄⴷⵓ. ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵎⵉⵏ ⵅⵙⴻⵖ ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("LK22_43","072_22_43","LUK","22","43","43","ⵅⴻⵏⵏⵉ ⵉⴹⵀⴰⵔ ⴰⵙ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵡⵛⴰ ⴰⵙ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("LK22_44","072_22_44","LUK","22","44","44","ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⵡⴻⴷ ⴰⵟⵟⴰⵙ, ⵉⵜⵜⵥⴰⴵⴰ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⵉⴷⵉ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⴳⴳ ⴰⵎ ⵜⵏⴻⵇⵇⵉⴹⵉⵏ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴻⵟⵟⴰⵏⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("LK22_45","072_22_45","LUK","22","45","45","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵣⵉ ⵜⵥⴰⴵⵉⵜ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⴼⴰ ⵉ-ⵜⴻⵏ ⵟⵟⵚⴻⵏ ⵙ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_46","072_22_46","LUK","22","46","46","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵟⵟⵚⴻⵎ? ⴽⴽⴰⵔⴻⵎ, ⵜⴻⵥⵥⴰⴵⴻⵎ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⴷⴼⴻⵎ ⴷⴻⴳ ⵓⵊⴰⵔⵔⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("LK22_47","072_22_47","LUK","22","47","47","ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵣⵡⴰⵔ ⴰⵙⴻⵏ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵉⵙⵙⵓⴷⴻⵎ ⵉ-ⵜ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵙⵛⴰⵏ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵙⵙⵓⴷⵎⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK22_48","072_22_48","LUK","22","48","48","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰ ⵢⴰⵀⵓⴷⴰ, ⵎⴰ ⵙ ⵓⵙⵓⴷⴻⵎ ⴰⴷ ⵜⴻⵖⴷⴰⵔⴻⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("LK22_49","072_22_49","LUK","22","49","49","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰ ⴰⴷ ⵜ ⵏⴻⵡⵡⴻⵜ ⵙ ⵍⴻⵙⵢⵓⴼ?” ");
INSERT INTO rift_vpl VALUES ("LK22_50","072_22_50","LUK","22","50","50","ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵡⵜⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵇⴻⵙⵙ ⴰⵙ ⴰⵎⴻⵣⵣⵓⵖ ⴰⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("LK22_51","072_22_51","LUK","22","51","51","ⵉⵟⵟⴻⴼ ⵢⴰⵙⵓⵄ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ: “ⵚⴰⴼⵉ, ⴱⴰⵔⴰⴽⴰ!” ⵅⴻⵏⵏⵉ ⵉⵃⴰⴷⴰ ⴰⵙ ⴰⵎⴻⵣⵣⵓⵖ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK22_52","072_22_52","LUK","22","52","52","ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ: “ⵎⴰ ⵜⴻⴼⴼⵖⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ ⴰⵅⵎⵉ ⴷⴷ-ⵜⴻⴼⴼⵖⴻⵎ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴻⵡⵡⴰⵏ, ⵙ ⵍⴻⵙⵢⵓⴼ ⴷ ⵉⵄⵓⵎⴰⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴼⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("LK22_53","072_22_53","LUK","22","53","53","ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ ⵜⵓⵖⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵉ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ, ⵎⴰⵛⴰ ⵜⴰ ⴷ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏⵡⴻⵎ ⴷ ⵚⵚⵓⵍⵟⴰ ⵏ ⵜⴰⴵⴻⵙⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK22_54","072_22_54","LUK","22","54","54","ⵟⵟⴼⴻⵏ ⵜ, ⵏⴻⴷⵀⴻⵏ ⵜ ⵓⵛⴰ ⵙⵙⵉⴷⴼⴻⵏ ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ⵓⵛⴰ ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵛⵉⵎⵄⵓⵏ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("LK22_55","072_22_55","LUK","22","55","55","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵎⵔⴰⵃ, ⵅⴻⵏⵏⵉ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⴻⴹ ⵏⵏⴻⵙ. ⵓⵛⴰ ⵛⵉⵎⵄⵓⵏ ⵉⵇⵇⵉⵎ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_56","072_22_56","LUK","22","56","56","ⵜⴻⵥⵔⴰ ⵉ-ⵜ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ ⴰⵎ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵜⴻⵅⵣⴰⵔ ⴷⴰⵢⴻⵙ ⵎⵍⵉⵃ, ⵜⴻⵏⵏⴰ: “ⵓⵍⴰ ⴷ ⵡⴰ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK22_57","072_22_57","LUK","22","57","57","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⴽⴰⵔ ⵜ, ⵉⵏⵏⴰ: “ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("LK22_58","072_22_58","LUK","22","58","58","ⵡⴰⵔ ⴷⵉⵏ ⵎⵉⵏ ⵉⵄⴷⵓⵏ ⵉⵥⵔⴰ ⵉ-ⵜ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⴰ: “ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ.” ⵎⴰⵛⴰ ⴱⵓⵟⵔⵓⵙ ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵉⴵⵉ ⴱⵓ ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK22_59","072_22_59","LUK","22","59","59","ⵓⵎⵉ ⵜⴻⵄⴷⵓ ⵄⵍⴰⵃⴰⵍ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ, ⵉⴱⴷⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵇⴰⵛⴻⵃ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵓⵍⴰ ⴷ ⵡⴰ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴰⵍⵉⵍⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK22_60","072_22_60","LUK","22","60","60","ⵉⵏⵏⴰ ⴱⵓⵟⵔⵓⵙ: “ⴰ ⴱⵏⴰⴷⴻⵎ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ!” ⵍⴻⵅⴷⴻⵏⵏⵉ, ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵙⵙⴰⵡⴰⵍ, ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("LK22_61","072_22_61","LUK","22","61","61","ⵉⵏⵏⴻⵇⵍⴻⴱ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⴱⵓⵟⵔⵓⵙ. ⵓⵛⴰ ⵉⵄⵇⴻⵍ ⵛⵉⵎⵄⵓⵏ ⵅ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ: “ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK22_62","072_22_62","LUK","22","62","62","ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ ⴱⴰⵔⵔⴰ, ⵉⵔⵓ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_63","072_22_63","LUK","22","63","63","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵢⴰⵙⵓⵄ, ⵜⵓⵖⴰ ⵙⵜⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("LK22_64","072_22_64","LUK","22","64","64","ⴷⵍⵉⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵡⵜⵉⵏ ⵜ ⵖⴰⵔ ⵓⵖⴻⵎⴱⵓⴱ, ⵏⵏⴰⵏ: “ⵏⴰⴱⴱ, ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵛⴻⴽ ⵉⵡⵜⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK22_65","072_22_65","LUK","22","65","65","ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴰⵢⴻⵙ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⴹⵉⴷⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK22_66","072_22_66","LUK","22","66","66","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵣⵉⵍ, ⵎⵓⵏⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵓⵛⴰ ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵡⴻⵅⵅⴰⵎ ⵏ ⵊⵎⴰⵄⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK22_67","072_22_67","LUK","22","67","67","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵅⴻⵏⵏⵉ ⵉⵏⵉ ⴰⵏⴻⵖ ⵜ.” ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵜⵜⵉⵎⵏⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("LK22_68","072_22_68","LUK","22","68","68","ⵓ ⵎⴰⵍⴰ ⵙⵙⴻⵇⵙⵉⵖ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⵅⴰⴼⵉ ⴷⴷ-ⵜⴰⵔⵔⵉⵎ ⵏⵉⵖ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴰⵔⴻⵅⵅⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("LK22_69","072_22_69","LUK","22","69","69","ⵣⵉ ⵍⴻⵅⵅⵓ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴷ ⵉⵇⵇⵉⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("LK22_70","072_22_70","LUK","22","70","70","ⵏⵏⴰⵏ ⵎⴰⵔⵔⴰ: “ⵎⴰ ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ?” ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵜⴻⵇⵇⴰⵔⴻⵎ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK22_71","072_22_71","LUK","22","71","71","ⵏⵏⴰⵏ: “ⵓⵎⵉ ⵏⴻⵃⴷⴰⵊ ⵄⴰⴷ ⵍⴻⵛⵀⵓⴷ? ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵏⴻⵙⵍⴰ ⵜ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("LK23_1","072_23_1","LUK","23","1","1","ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏⵙⴻⵏ ⵜⴻⴽⴽⴰⵔ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⴱⵉⵍⴰⵟⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_2","072_23_2","LUK","23","2","2","ⴱⴷⴰⵏ ⴰⴷ ⵜ ⴹⴻⵍⵎⴻⵏ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⵓⴼⴰ ⴰⵇⴰ ⵡⴰ ⵉⵙⵙⴻⴼⵙⴻⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⴰⵎ ⵉⵎⴻⵏⵏⴻⵄ ⴰⴷ ⵡⵛⴻⵏ ⴹⴹⴰⵔⵉⴱⴰ ⵉ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ ⵉ ⵇⴰⵢⵚⴰⵔ, ⵉⵇⵇⴰⵔ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵍⵎⴰⵙⵉⵃ!” ");
INSERT INTO rift_vpl VALUES ("LK23_3","072_23_3","LUK","23","3","3","ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⴱⵉⵍⴰⵟⵓⵙ, ⵉⵏⵏⴰ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵛⴻⴽ ⵉ ⵜ ⵉⵇⵇⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK23_4","072_23_4","LUK","23","4","4","ⵉⵏⵏⴰ ⴱⵉⵍⴰⵟⵓⵙ ⵉ ⵍⵖⴰⵛⵉ ⵓ ⵉ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: “ⴰⵇⴰ ⵡⴰⵔ ⵓⴼⵉⵖ ⴱⵓ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ ⴷⵉ ⴱⵏⴰⴷⴻⵎ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK23_5","072_23_5","LUK","23","5","5","ⵎⴰⵛⴰ ⵙⵖⵓⵢⴻⵏ ⵏⵉⵜⵏⵉ, ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⵉⵙⵙⵖⴻⵡⵡⴰⵖ ⵍⴳⴻⵏⵙ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵉⴱⴷⴰ ⵣⵉ ⵍⵊⴰⵍⵉⵍ ⴰⵍ ⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK23_6","072_23_6","LUK","23","6","6","ⵓⵎⵉ ⵉⵙⵍⴰ ⴱⵉⵍⴰⵟⵓⵙ ‘ⵍⵊⴰⵍⵉⵍ’, ⵉⵙⵙⴻⵇⵙⴰ: “ⵎⴰ ⴰⵔⵢⴰⵣ-ⴰ ⴷ ⴰⵊⴰⵍⵉⵍⵉ?” ");
INSERT INTO rift_vpl VALUES ("LK23_7","072_23_7","LUK","23","7","7","ⵓⵎⵉ ⵉⴼⵀⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵖⴰⵔ ⵀⵉⵔⵓⴷⵓⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK23_8","072_23_8","LUK","23","8","8","ⴰⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵀⵉⵔⵓⴷⵓⵙ ⵢⴰⵙⵓⵄ, ⵉⴼⴰⵔⵃ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵥⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⵙⵍⴰ ⵅⴰⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ⵓ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵜⵉⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵥⴰⵔ ⵛⴰ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK23_9","072_23_9","LUK","23","9","9","ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵙ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("LK23_10","072_23_10","LUK","23","10","10","ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴽⴽⴰⵔⴻⵏ, ⴹⴻⵍⵎⴻⵏ ⵜ ⵙ ⵍⵃⴰⵔⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK23_11","072_23_11","LUK","23","11","11","ⵀⵉⵔⵓⴷⵓⵙ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔ ⵏⵏⴻⵙ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵜ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵜⴻⵀⵣⴰ ⵣⵣⴰⵢⴻⵙ, ⵢⴰⵔⴹ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⴰⴷⴻⵀⵎⴰⵏⵉ, ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵖⴰⵔ ⴱⵉⵍⴰⵟⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_12","072_23_12","LUK","23","12","12","ⴷⴻⵡⵍⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ ⴷ ⵀⵉⵔⵓⴷⵓⵙ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵇⴱⴻⵍ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⵄⴷⴰⵡⴻⵜ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK23_13","072_23_13","LUK","23","13","13","ⵅⴰⵙ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴱⵉⵍⴰⵟⵓⵙ ⵅ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("LK23_14","072_23_14","LUK","23","14","14","“ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⴱⵏⴰⴷⴻⵎ-ⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵄⵉⴵⴻⵏ ⵍⴳⴻⵏⵙ ⵏⵡⴻⵎ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵙⵙⴻⵇⵙⵉⵖ ⵜ ⵣⵣⴰⵜⵡⴻⵎ, ⵡⴰⵔ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵎⴰⵔⵔⴰ ⵉ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵛⴻⵜⵛⴰⵎ ⵅⴰⵙ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("LK23_15","072_23_15","LUK","23","15","15","ⵓⵍⴰ ⴷ ⵀⵉⵔⵓⴷⵓⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⵓⴼⵉ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ ⵜ ⵖⴰⵔⴻⵙ. ⵓ ⵅⵣⴰⵔ, ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⵉⴳⴳⴰ ⵜⴻⵙⴷⴰⵀⴻⴵ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("LK23_16","072_23_16","LUK","23","16","16","ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵀⴻⵜⵜⴽⴻⵖ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⴰⵔⵅⵓⵖ.” ");
INSERT INTO rift_vpl VALUES ("LK23_17","072_23_17","LUK","23","17","17","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵏⴰⵎⵉⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵢⴰⵔⵅⵓ ⵉ ⵢⵉⵊⵊⴻⵏ ⴷⵉ ⵍⵄⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("LK23_18","072_23_18","LUK","23","18","18","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵉⵙⵖⵓⵢ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ, ⵉⵏⵏⴰ: “ⴽⴽⵙⴻⵎ ⵡⴰ, ⴰⵔⵅⵓ ⴰⵏⴻⵖ-ⴷⴷ ⵉ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("LK23_19","072_23_19","LUK","23","19","19","ⵡⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵖⵓⵡⵡⴻⵖ ⵉ ⵉⵎⵙⴰⵔⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵓ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵏⵖⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("LK23_20","072_23_20","LUK","23","20","20","ⵉⵙⵙⵉⵡⴻⵍ ⴱⵉⵍⴰⵟⵓⵙ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵢⴰⵔⵅⵓ ⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK23_21","072_23_21","LUK","23","21","21","ⵎⴰⵛⴰ ⵙⵖⵓⵢⴻⵏ ⵏⵉⵜⵏⵉ, ⵏⵏⴰⵏ: “ⵚⴻⵍⵍⴱ ⵉ-ⵜ! ⵚⴻⵍⵍⴱ ⵉ-ⵜ!” ");
INSERT INTO rift_vpl VALUES ("LK23_22","072_23_22","LUK","23","22","22","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ: “ⵎⴰⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉⴳⴳⴰ ⵡⴰ ⵅⴻⵏⵏⵉ? ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⴱⵓ ⵓⵅⴻⵟⵟⵓ ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵍⵎⴻⵡⵜ? ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵀⴻⵜⵜⴽⴻⵖ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⴰⴷ ⴰⵙ ⴰⵔⵅⵓⵖ!” ");
INSERT INTO rift_vpl VALUES ("LK23_23","072_23_23","LUK","23","23","23","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵣⵉⵢⵢⴰⵔⴻⵏ ⵅⴰⵙ ⵙ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⵊⵊⴻⵀⴷⴻⵏⵜ, ⵜⵜⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵚⴻⵍⵍⴱⴻⵏ. ⵜⵉⵎⵉⵊⵊⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵜⴻⵏⵏⵉ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⴰⵔⴻⵏⵏⵢⴻⵏⵜ ⴷⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("LK23_24","072_23_24","LUK","23","24","24","ⵅⴻⵏⵏⵉ ⵉⵃⴽⴻⵎ ⴱⵉⵍⴰⵟⵓⵙ ⴰⴷ ⴰⵙⴻⵏ ⵉⵇⴹⴰ ⵛⵖⴻⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK23_25","072_23_25","LUK","23","25","25","ⵉⴹⵍⴻⵇ ⴰⵙⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵖⵓⵡⵡⴻⵖ ⴷ ⵡⴻⵏⵖⴰⵢ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵜⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵎⴰⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵢⴰⵙⵓⵄ ⵉ ⵏⵉⵜⵏⵉ ⵅ ⵍⴻⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK23_26","072_23_26","LUK","23","26","26","ⵓⵎⵉ ⵜ ⴳⴻⵡⵡⴷⴻⵏ ⵙⵙⴻⵏⵏⵉ, ⵟⵟⴼⴻⵏ ⵛⵉⵎⵄⵓⵏ ⵣⵉ ⵇⴰⵢⵔⴰⵡⴰⵏ, ⵜⵓⵖⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵍⴽⴰⵎⴱⵓ, ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵚⵚⴰⵍⵉⴱ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵢⴰⵔⴱⵓ ⴰⵡⴰⵔⵏⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK23_27","072_23_27","LUK","23","27","27","ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⵜⵉⵏ ⴰⴳⴻⵊⴷⵓⵔ, ⵜⵜⵔⵓⵏⵜ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_28","072_23_28","LUK","23","28","28","ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵖⴰⵔⵙⴻⵏⵜ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⴰ ⵢⴻⵙⵙⵉⵙ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵡⴰⵔ ⵜⵜⵔⵓⵏⵜ ⵛⴰ ⵅⴰⴼⵉ, ⵎⴰⵛⴰ ⵔⵓⵏⵜ ⵅ ⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ ⴷ ⵜⴰⵔⵡⴰ ⵏⴽⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK23_29","072_23_29","LUK","23","29","29","ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵏⵉⵏ: ‘ⵙⵙⴻⵄⴷ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵓⵔⵡⴻⵏⵜ ⵓ ⵙⵙⴻⵄⴷ ⵏ ⵉⵄⴻⴷⴷⵉⵙⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵔⵡⴻⵏ, ⴷ ⵜⵉⴱⴱⴰⵛ ⵜⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵓⵟⵟⵓⴹⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("LK23_30","072_23_30","LUK","23","30","30","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵉⴷⵓⵔⴰⵔ: ‘ⵡⴹⴰⵎ-ⴷⴷ ⵅⴰⵏⴻⵖ!’, ⵓ ⵉ ⵜⵉⵡⵔⵉⵔⵉⵏ: ‘ⴷⵍⴻⵏⵜ ⴰⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("LK23_31","072_23_31","LUK","23","31","31","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴳⴳⵉⵏ ⴰⵢⴰ ⵙ ⵓⴽⴻⵛⵛⵓⴹ ⴰⵣⵉⵣⴰ, ⵎⵉⵏ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⵅⴻⵏⵏⵉ ⵉ ⵓⴽⴻⵛⵛⵓⴹ ⵢⵓⵥⵖⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK23_32","072_23_32","LUK","23","32","32","ⵏⴻⴷⵀⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵄⴰⵡⴻⴷ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⴻⵟⵟⵄⴻⵏ ⴰⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_33","072_23_33","LUK","23","33","33","ⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵜⴰⵛⴻⵇⵇⵓⴼⵜ’, ⵚⴻⵍⵍⴱⴻⵏ ⵜ ⴷⵉⵏ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⴻⵟⵟⵄⴻⵏ ⴰⴱⵔⵉⴷ, ⵉⵊⵊⴻⵏ ⵅ ⵢⴻⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_34","072_23_34","LUK","23","34","34","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⵖⴼⴰⵔ ⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ!” ⵓⵛⴰ ⴱⴹⴰⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵏⴹⴰⵔⴻⵏ ⵅⴰⵙ ⴰⴽⴻⵛⵛⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("LK23_35","072_23_35","LUK","23","35","35","ⵜⵓⵖⴰ ⵉⵡⴷⴰⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ, ⵅⴻⵣⵣⴰⵔⴻⵏ. ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵙⵜⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⴻⵙ, ⵏⵏⴰⵏ: “ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵏⵏⴻⵖⵏⵉ, ⵍⴻⵅⵅⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("LK23_36","072_23_36","LUK","23","36","36","ⵓⵍⴰ ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵙⵜⴻⵀⵣⴰⵏ ⵣⵣⴰⵢⴻⵙ ⴰⵎ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵓⵛⴰ ⵡⵛⵉⵏ ⴰⵙ ⵍⵅⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("LK23_37","072_23_37","LUK","23","37","37","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵅⴻⵏⵏⵉ ⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("LK23_38","072_23_38","LUK","23","38","38","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵉⵔⴰ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ, ⵓⵔⵉⵏ ⵜⵜ ⵙ ⵍⵃⵓⵔⵓⴼ ⵏ ⵜⵢⵓⵏⴰⵏⵉⵜ ⴷ ⵜⵍⴰⵜⵉⵏⵉⵜ ⴷ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ: ‘ⵡⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("LK23_39","072_23_39","LUK","23","39","39","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵇⵟⴰⵟⵄⵉⵢⵢⴻⵏ ⵉ ⵢⵓⵢⵍⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵜⵓⵖⴰ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⴷⴰⵢⴻⵙ, ⵉⵇⵇⴰⵔ: “ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵙⴻⵏⵊⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK23_40","072_23_40","LUK","23","40","40","ⵎⴰⵛⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⵎⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴳⴳⵯⵉⴷⴻⴷ ⵛⴰ ⵄⴰⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵎⵉ ⵛⴻⴽ ⵉⵍⵇⴻⴼ ⵛⵛⵔⴻⵄ ⴷ ⵉⵊⵊⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LK23_41","072_23_41","LUK","23","41","41","ⵏⴻⵛⵛⵉⵏ ⵙ ⵍⵃⴻⵇⵇ ⵎⵉⵏⵣⵉ ⵏⴻⵟⵟⴻⴼ ⴰⵅⴻⴵⴻⵚ ⵏ ⵎⵉⵏ ⵏⴻⴳⴳⴰ. ⵎⴰⵛⴰ ⵡⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("LK23_42","072_23_42","LUK","23","42","42","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵉ ⵢⴰⵙⵓⵄ: “ⵄⵇⴻⵍ ⵅⴰⴼⵉ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("LK23_43","072_23_43","LUK","23","43","43","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⴰⴽⵉⴷⵉ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("LK23_44","072_23_44","LUK","23","44","44","ⵜⵓⵖⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵄⵍⴰⵃⴰⵍ ⴷ ⵙⴻⵜⵜⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴹⴹⵀⵓⵔ, ⵅⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ ⴰⵍⴰⵎⵉ ⴷ ⵜⴻⵙⵄⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵓⵄⴻⵛⵛⵉ.    ");
INSERT INTO rift_vpl VALUES ("LK23_45","072_23_45","LUK","23","45","45","ⵅⴻⵏⵏⵉ ⵜⴻⴱⴱⴰⵔⵛⴻⵏ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⴰⵍⴻⵃⵃⴰⴼ ⵏ ⵡⴰⴷⴰⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵜⵜⵡⴰⵛⴰⵔⵔⴻⴳ ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK23_46","072_23_46","LUK","23","46","46","ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ.” ⵓⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵙⴻⵍⵍⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_47","072_23_47","LUK","23","47","47","ⵓⵎⵉ ⵉⵥⵔⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ, ⵉⴱⴷⴰ ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ ⵜⵓⵖⴰ ⴱⵏⴰⴷⴻⵎ-ⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("LK23_48","072_23_48","LUK","23","48","48","ⵓⵎⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵉ ⴷ ⵉⵎⵓⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⴼⵓⵔⵔⴻⵊ-ⴰ, ⵥⵔⵉⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⵄⴻⵇⴱⴻⵏ ⴰⵎ ⵡⵜⵉⵏ ⴷⴻⴳ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK23_49","072_23_49","LUK","23","49","49","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵢⴰⵙⵓⵄ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⴽⵉⴷⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵍⵊⴰⵍⵉⵍ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK23_50","072_23_50","LUK","23","50","50","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵓⵙⵓⴼ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵛⴰⵡⴰⵔ ⴷⵉ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵏⴻⵜⵜⴰ ⵣⵉ ⵔⴰⵎⵜⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵢⴰⵀⵓⴷⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ.    ");
INSERT INTO rift_vpl VALUES ("LK23_51","072_23_51","LUK","23","51","51","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⴰⵔⴹⵉ ⵛⴰ ⵅ ⵛⵛⵡⴰⵔ ⵏⵙⴻⵏ ⵓ ⵅ ⵎⵉⵏ ⴳⴳⵉⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("LK23_52","072_23_52","LUK","23","52","52","ⵡⴰⵏⵉⵜⴰ ⵢⵓⵢⵓⵔ ⵖⴰⵔ ⴱⵉⵍⴰⵟⵓⵙ ⵓⵛⴰ ⵉⵜⵜⴰⵔ ⴰⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK23_53","072_23_53","LUK","23","53","53","ⵉⵙⵙⴻⵀⵡⴰ ⵜⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵚⵚⴰⵍⵉⴱ, ⵉⵏⵏⴻⴹ ⵉ-ⵜⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵅⴻⵢⵢⴰⴹⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵉ ⵉⵖⵣⴰ ⴷⵉ ⵙⵙⴻⴵⴰⵃ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵏⴹⵉⵍ ⵃⴻⴷ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("LK23_54","072_23_54","LUK","23","54","54","ⵜⵓⵖⴰ ⴷ ⴰⵙⵙ ⵏ ⵓⵙⴻⵡⵊⴻⴷ, ⴰⵇⴰ ⵙⵙⴻⴱⵜ ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("LK23_55","072_23_55","LUK","23","55","55","ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉ ⴽⵉⴷⴻⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵍⵊⴰⵍⵉⵍ, ⵇⴰⵔⵔⴱⴻⵏⵜ-ⵉ-ⴷⴷ, ⵥⵔⵉⵏⵜ ⴰⵏⴹⴻⵍ ⴷ ⵎⴰⵎⵎⴻⵛ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK23_56","072_23_56","LUK","23","56","56","ⵅⴰⵙ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏⵜ, ⵙⵙⴻⵡⵊⴷⴻⵏⵜ ⵍⴻⵄⵟⵓⵔ ⴷ ⵣⵣⴻⵛⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ, ⵎⴰⵛⴰ ⴷⵉ ⵙⵙⴻⴱⵜ ⴰⵔⴻⵢⵢⵃⴻⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⴷⵉ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("LK24_1","072_24_1","LUK","24","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵖⴰⵔ ⵚⵚⴱⴻⵃ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵔⵓⵃⴻⵏⵜ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⴽⵙⵉⵏⵜ ⵍⴻⵄⵟⵓⵔ ⵉ ⵜⵓⵖⴰ ⵙⵙⴻⵡⵊⴷⴻⵏⵜ, ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵏⴻⵖⵏⵉ ⴰⴽⵉⴷⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK24_2","072_24_2","LUK","24","2","2","ⴰⵇⴰ ⵓⴼⵉⵏⵜ, ⵜⴰⵚⴹⴰⵔⵜ ⵉ ⵜⵓⵖⴰ ⵅ ⵡⴻⵏⴹⴻⵍ, ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵇⵏⵓⵏⵉ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK24_3","072_24_3","LUK","24","3","3","ⵓⴷⴼⴻⵏⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵓⴼⵉⵏⵜ ⵛⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("LK24_4","072_24_4","LUK","24","4","4","ⴰⵎ ⵜⴱⴻⵀⵜⴻⵏⵜ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⴱⴻⴷⴷⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK24_5","072_24_5","LUK","24","5","5","ⵏⵉⵜⴻⵏⵜⵉ ⴳⴳⵯⴻⴷⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵇⴱⴰⵍⴻⵏⵜ ⴰⵣⴻⴵⵉⴼ ⵏⵙⴻⵏⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⵉⵜⵏⵉ ⵎⴰⵛⴰ ⵏⵏⴰⵏ ⴰⵙⴻⵏⵜ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜⴰⵔⴻⵣⵣⵓⵏⵜ ⵅ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("LK24_6","072_24_6","LUK","24","6","6","ⴰⵇⴰ ⵡⴰⵔ ⴷⴰ ⵉⴵⵉ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⴽⴽⴰⵔ! ⵄⴻⵇⵍⴻⵏⵜ ⵅ ⵎⵉⵏ ⴷ ⴰⴽⴻⵏⵜ ⵉⵏⵏⴰ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("LK24_7","072_24_7","LUK","24","7","7","ⵉⵏⵏⴰ: ‘ⴰⵇⴰ ⵜⵓⵔⴰ ⴱⴻⵍⵍⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵎⴻⴷⵏⴰⴱ, ⴰⴷ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ.’” ");
INSERT INTO rift_vpl VALUES ("LK24_8","072_24_8","LUK","24","8","8","ⵅⴻⵏⵏⵉ ⵄⴻⵇⵍⴻⵏⵜ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK24_9","072_24_9","LUK","24","9","9","ⵄⴻⵇⴱⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵃⵉⵟⴰⵛ ⵓ ⵉ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("LK24_10","072_24_10","LUK","24","10","10","ⵉⵏⴰ ⵜⵓⵖⴰ ⴷ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ, ⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵙⴻⵏⵜ, ⵃⴰⵊⴰⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("LK24_11","072_24_11","LUK","24","11","11","ⵏⵉⵜⵏⵉ ⵃⴻⵙⴱⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷ ⴰⵟⴻⵎⵎⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵉⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_12","072_24_12","LUK","24","12","12","ⵎⴰⵛⴰ ⵛⵉⵎⵄⵓⵏ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⵢⵓⵣⵣⴻⵍ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⵉⵅⴻⵣⵣⴰⵔ ⴷⴰⵅⴻⵍ, ⵉⵥⵔⴰ ⵜⴰⵅⴻⵢⵢⴰⴹⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵜᵉⵜⵜⵡⴰⵎⴰⵔⵙ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ. ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ, ⵉⵜⵜⴻⴱⵀⴻⵜ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_13","072_24_13","LUK","24","13","13","ⵓ ⵅⵣⴰⵔ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵏⴰⵢⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴷⵛⴰⵔ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵄⵉⵎⵡⴰⵙ, ⵉⴳⴳⵯⴻⵊ ⵙⴻⵜⵜⵉⵏ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’ ⵅ ⵓⵔⵛⴰⵍⵉⵎ, ⵄⵍⴰⵃⴰⵍ ⵃⵉⵟⴰⵛ ⴽⵉⵍⵓⵎⵉⵜⵔ. ");
INSERT INTO rift_vpl VALUES ("LK24_14","072_24_14","LUK","24","14","14","ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_15","072_24_15","LUK","24","15","15","ⴰⵎ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵏⵉⵜⵏⵉ, ⵜⵜⴻⵎⵙⴰⵡⴰⴹⴻⵏ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_16","072_24_16","LUK","24","16","16","ⵜⵜⵡⴰⵛⴻⴱⴱⴰⵔⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜ ⵄⵇⵉⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_17","072_24_17","LUK","24","17","17","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵉ ⵅⴻⴼ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⵎ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⵎ ⵜⴻⴳⴳⵓⵔⴻⵎ ⵓ ⵜⵜⴱⴰⵏⴻⵏⵜ ⵍⵅⴻⵥⵔⴰⵜ ⵏⵡⴻⵎ ⵛⴻⴹⵏⴻⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("LK24_18","072_24_18","LUK","24","18","18","ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴽⵍⵉⵢⵓⴱⴰⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵎⵉⵏ ⴷⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK24_19","072_24_19","LUK","24","19","19","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵢⴰⵙⵓⵄ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ, ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵏⴰⴱⵉ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵊⵊⴻⵀⴷ ⴷⵉ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ ⵓ ⴷⵉ ⵎⵉⵏ ⵉⵙⵙⴰⵡⴰⵍ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("LK24_20","072_24_20","LUK","24","20","20","ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵍⵃⵓⴽⵎ ⵙ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⵚⴻⵍⵍⴱⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK24_21","072_24_21","LUK","24","21","21","ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⴻⵙⵙⵉⵜⵉⵎ, ⴰⵇⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵉⵙⴻⵍⵍⴽⴻⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⴰⵙⵙ-ⴰ ⵄⴷⵓⵏ ⵄⴰⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⵎⵙⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("LK24_22","072_24_22","LUK","24","22","22","ⵎⴰⵛⴰ ⵛⴰ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵙⵙⵃⴻⵢⵢⴰⵔⴻⵏⵜ ⴰⵏⴻⵖ ⵄⴰⵡⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵔⵓⵃⴻⵏⵜ ⵣⵉⵛ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("LK24_23","072_24_23","LUK","24","23","23","ⵍⴰⵎⵉ ⵡⴰⵔ ⴷⵉⵏ ⵓⴼⵉⵏⵜ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ, ⵏⵏⴰⵏⵜ: “ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⴷⵉⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵓ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴰⵏⵜ ⵅⴰⵙ: ‘ⴰⵇⴰ ⵉⴷⴷⴰⵔ!’” ");
INSERT INTO rift_vpl VALUES ("LK24_24","072_24_24","LUK","24","24","24","ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵏⴻⵖ ⵉⴵⴰⵏ, ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⵓⴼⵉⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵏⵏⴰⵏⵜ ⵄⴰⵡⴻⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜ ⵥⵔⵉⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("LK24_25","072_24_25","LUK","24","25","25","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴻⵛⵃⴰⵍ ⴷ ⵉⴼⵖⴰⵍ ⴷ ⵉⵏⴻⴹⵇⴰⵍ ⵏ ⵡⵓⵍ ⵉ ⵜⴻⴵⴰⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵙⵙⵉⵡⵍⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("LK24_26","072_24_26","LUK","24","26","26","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⵍⵎⴰⵙⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("LK24_27","072_24_27","LUK","24","27","27","ⵅⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵣⵉ ⵎⵓⵙⴰ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵜⵜⴼⴻⵙⵙⴰⵔ ⴰⵙⴻⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_28","072_24_28","LUK","24","28","28","ⵓⵎⵉ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⴷⵛⴰⵔ ⵉ ⵖⴰⵔ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ, ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⴰⵅⵎⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵢⴰⵔⵏⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⴳⴳⵯⴻⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_29","072_24_29","LUK","24","29","29","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵅⴰⵙ ⴱⴻⵣⵣⴻⵣ, ⵏⵏⴰⵏ: “ⵇⵇⵉⵎ ⴰⴽⵉⴷⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⴻⴷⴷⵉⵜ ⴰⴷ ⵜⴻⵡⴹⴰ, ⴰⵇⴰ ⵉⵎⴻⵢⵢⴻⵍ ⵓⵣⵉⵍ.” ⵓⵛⴰ ⵢⵓⴷⴻⴼ, ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_30","072_24_30","LUK","24","30","30","ⵉⵎⵙⴰⵔ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ, ⵉⴱⴰⵔⴻⴽ ⵉ-ⵜ, ⵢⴰⵔⵥⴰ ⵉ-ⵜ, ⵅⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("LK24_31","072_24_31","LUK","24","31","31","ⴷⴻⵖⵢⴰ ⵏⵏⵓⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵄⴻⵇⵍⴻⵏ ⵜ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵎⵎⴻⴽⵙⵉ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_32","072_24_32","LUK","24","32","32","ⵏⵏⴰⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⴷⴻⵇⵇⴻⵍ ⵡⵓⵍ ⵏⵏⴻⵖ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵙⵙⴰⵡⴰⵍ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵙⵙⴻⴼⵀⴰⵎ ⴰⵏⴻⵖ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("LK24_33","072_24_33","LUK","24","33","33","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⵓⴼⵉⵏ ⵃⵉⵟⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⵎⵓⵏⴻⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_34","072_24_34","LUK","24","34","34","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴷ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵉⴱⴰⵏ-ⴷⴷ ⵉ ⵛⵉⵎⵄⵓⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK24_35","072_24_35","LUK","24","35","35","ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵙ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓ ⵎⴰⵎⵎⴻⵛ ⵜ ⵄⴻⵇⵍⴻⵏ ⴰⵍⴰⵎⵉ ⵢⴰⵔⵥⴰ ⴰⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("LK24_36","072_24_36","LUK","24","36","36","ⴰⵎ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵉⴱⴻⴷⴷ ⵢⴰⵙⵓⵄ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴰⵎ ⵅⴰⵡⴻⵎ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK24_37","072_24_37","LUK","24","37","37","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⵅⴻⵍⵄⴻⵏ ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵜⵡⴰⵍⴰⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("LK24_38","072_24_38","LUK","24","38","38","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("LK24_39","072_24_39","LUK","24","39","39","ⵅⵣⴰⵔⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵏⴻⵛⵛ. ⵃⴰⴷⴰⵎ ⴰⵢⵉ, ⵓ ⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵡⴻⵢⵙⵓⵎ ⵓⵍⴰ ⴷ ⵉⵖⵙⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("LK24_40","072_24_40","LUK","24","40","40","ⵓⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("LK24_41","072_24_41","LUK","24","41","41","ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⵄⴰⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵇⵇⵉⵎⴻⵏ ⵜⵜⴱⴻⵀⵜⴻⵏ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵖⴰⵔⵡⴻⵎ ⴷⴰ ⵛⴰ ⵏ ⵎⴰⵛⵛⴰ?” ");
INSERT INTO rift_vpl VALUES ("LK24_42","072_24_42","LUK","24","42","42","ⵡⵛⵉⵏ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⴻⵛⵡⵉⵃⵜ ⵏ ⵡⴻⵙⵍⴻⵎ ⵉⵛⴻⵏⵏⴼⴻⵏ ⴷ ⵛⴰ ⵏ ⵜⴻⵣⵍⴻⴼⵜ ⵏ ⵜⴰⵎⵎⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("LK24_43","072_24_43","LUK","24","43","43","ⵉⴽⵙⵉ ⵜⵜ ⵓⵛⴰ ⵉⵛⵛⴰ ⵉ-ⵜⵜ ⵇⵉⴱⴰⵍⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_44","072_24_44","LUK","24","44","44","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵉ ⵣⵉ ⴽⵉⴷⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⴼⵉ ⵢⵓⵔⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴷⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⴷⴻⴳ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("LK24_45","072_24_45","LUK","24","45","45","ⵅⴻⵏⵏⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵙⴻⵏ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_46","072_24_46","LUK","24","46","46","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵎⵎⵓ ⵉ ⵜⵓⵔⴰ ⵓ ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⴰⵔⵔⴻⵜ ⵍⵎⴰⵙⵉⵃ ⵓ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("LK24_47","072_24_47","LUK","24","47","47","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵜⵜⵓⴱⴻⵜ ⵉ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("LK24_48","072_24_48","LUK","24","48","48","ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("LK24_49","072_24_49","LUK","24","49","49","ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵍⵡⴰⵄⴷ ⵏ ⴱⴰⴱⴰ. ⵇⵇⵉⵎⴻⵎ ⵎⴰⵛⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵢⴰⵔⴹⴻⵎ ⵙ ⵊⵊⴻⵀⴷ ⵣⵉ ⵍⵓⵄⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("LK24_50","072_24_50","LUK","24","50","50","ⵅⴻⵏⵏⵉ ⵉⵏⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴱⴰⵔⴽ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("LK24_51","072_24_51","LUK","24","51","51","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⴰⴽ, ⵉⵎⵙⴰⵔ, ⴰⵇⴰ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("LK24_52","072_24_52","LUK","24","52","52","ⵙⴻⵊⴷⴻⵏ ⴰⵙ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("LK24_53","072_24_53","LUK","24","53","53","ⵜⵓⵖⴰ-ⵜⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵓ ⵜⵜⴱⴰⵔⴰⴽⴻⵏ ⴰⵔⴻⴱⴱⵉ. ⴰⵎⵉⵏ. ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⵍⵓⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("JN1_1","073_1_1","JHN","1","1","1","ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵜⵓⵖⴰ ⵉⴵⴰ ⵡⴰⵡⴰⵍ, ⴰⵡⴰⵍ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JN1_2","073_1_2","JHN","1","2","2","ⵡⴰⵏⵉⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JN1_3","073_1_3","JHN","1","3","3","ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ ⵉⴵⴰ ⴽⵓⵍⵛⵉ ⵓ ⴱⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_4","073_1_4","JHN","1","4","4","ⴷⴰⵢⴻⵙ ⵉ ⵜⴻⴵⴰ ⵜⵓⴷⴰⵔⵜ ⵓ ⵜⵓⴷⴰⵔⵜ ⵜⴻⴵⴰ ⵜⴰⴼⴰⵡⵜ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_5","073_1_5","JHN","1","5","5","ⵜⴰⴼⴰⵡⵜ ⵜⴰⵔⴻⵇⵇ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵜⴰⴵⴻⵙⵜ ⵡⴰⵔ ⵜⵜ ⵜᵉⵟⵟⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("JN1_6","073_1_6","JHN","1","6","6","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JN1_7","073_1_7","JHN","1","7","7","ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵎ ⵛⵛⴰⵀⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵀⴻⴷ ⵉ ⵜⴼⴰⵡⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵎⵏⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN1_8","073_1_8","JHN","1","8","8","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⵜⴰⴼⴰⵡⵜ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ-ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵀⴻⴷ ⵉ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JN1_9","073_1_9","JHN","1","9","9","ⵎⴰⵖⴰⵔ ⵜⴰⴼⴰⵡⵜ ⵏⵏⵉ, ⵜⵓⵖⴰ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏ ⵜⵉⴷⴻⵜⵜ ⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⴰⴼⴰⵡⵜ ⵉ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN1_10","073_1_10","JHN","1","10","10","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵓ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN1_11","073_1_11","JHN","1","11","11","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵡⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵇⴱⵉⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_12","073_1_12","JHN","1","12","12","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜ ⵉⵇⴻⴱⵍⴻⵏ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JN1_13","073_1_13","JHN","1","13","13","ⵉⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵅⵍⵉⵇⴻⵏ ⵓⵍⴰ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵍⴰ ⵣⵉ ⵎⵉⵏ ⵉⵅⵙ ⴷⴷⴰⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵍⴰ ⵣⵉ ⵎⵉⵏ ⵉⵅⵙ ⵡⴻⵔⵢⴰⵣ, ⵎⴰⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_14","073_1_14","JHN","1","14","14","ⴰⵡⴰⵍ ⵉⴷⵡⴻⵍ ⴷ ⴷⴷⴰⵜ, ⵉⵣⴷⴻⵖ ⵊⴰⵔ ⴰⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵥⵔⴰ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⴰⵄⵓⴵⵉ ⵏ ⵓⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵣⵉ ⵖⴰⵔ ⴱⴰⴱⴰⵙ ⵉ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⴹⴰ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN1_15","073_1_15","JHN","1","15","15","ⵉⵛⵀⴻⴷ ⵅⴰⵙ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⴷ ⵡⴰ ⵎⵉⵏ ⵅⴻⴼ ⵏⵏⵉⵖ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⵣⵣⴰⵜⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⵇⴱⴻⵍ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN1_16","073_1_16","JHN","1","16","16","ⵣⵉ ⵍⴻⴽⵎⴰⵍⴻⵜ ⵏⵏⴻⵙ ⵏⵉⵡⵉ-ⴷⴷ ⵎⴰⵔⵔⴰ, ⴰⵔⴹⴰ ⵅ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("JN1_17","073_1_17","JHN","1","17","17","ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵅ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ, ⵎⴰⵛⴰ ⴰⵔⴹⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("JN1_18","073_1_18","JHN","1","18","18","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵥⵔⵉ ⴰⵔⴻⴱⴱⵉ. ⴰⵢⴻⵏⵏⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵃⵙⵉⵏ ⵏ ⴱⴰⴱⴰⵙ, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⵅⴻⴱⴱⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_19","073_1_19","JHN","1","19","19","ⵜⴰ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵍⴰⵡⵉⵢⵢⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("JN1_20","073_1_20","JHN","1","20","20","ⵜⵓⵖⴰ ⵉⵛⵀⴻⴷ, ⵡⴰⵔ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵛⴰ, ⵉⵛⵀⴻⴷ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⴷ ⵍⵎⴰⵙⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("JN1_21","073_1_21","JHN","1","21","21","ⵙⵙⴻⵇⵙⴰⵏ ⵜ: “ⵉ ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ ⵅⴻⵏⵏⵉ? ⵎⴰ ⴷ ⵛⴻⴽ ⴷ ⴰⵏⴰⴱⵉ ⵉⵍⵉⵢⴰ?” ⵉⵏⵏⴰ: “ⵍⵍⴰ, ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵏⴻⵛⵛ!” “ⵎⴰ ⴷ ⵛⴻⴽ ⴷ ⴰⵏⴰⴱⵉ?” ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN1_22","073_1_22","JHN","1","22","22","ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ? ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⵔ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JN1_23","073_1_23","JHN","1","23","23","ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⵜⵎⵉⵊⵊⴰ ⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ: ‘ⵙⴻⴳⴳⵎⴻⵎ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵏⵉⵛⴰⵏ!’, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN1_24","073_1_24","JHN","1","24","24","ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_25","073_1_25","JHN","1","25","25","ⵏⵉⵜⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⵓⵍⴰ ⴷ ⵉⵍⵉⵢⴰ ⵓⵍⴰ ⴷ ⴰⵏⴰⴱⵉ, ⵉ ⵅⴻⵏⵏⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵙⵙⴻⵖⴹⴰⵚⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN1_26","073_1_26","JHN","1","26","26","ⵢⵓⵃⴰⵏⵏⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⵙⵙⴻⵖⴹⴰⵚⴻⵖ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN1_27","073_1_27","JHN","1","27","27","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⵏⴻⵜⵜⴰ ⵉⴵⴰ ⵇⴱⴻⵍ ⵉⵏⵓ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴷⵉⵀⴻⴵⴻⵖ ⴰⴷ ⴰⵙ ⴼⴻⵙⵢⴻⵖ ⵉⴼⵉⵍⴰⵏ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN1_28","073_1_28","JHN","1","28","28","ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴷⵉ ⴱⴰⵢⵜⵄⴰⵏⵢⴰ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("JN1_29","073_1_29","JHN","1","29","29","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵥⵔⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉⴳⴳⵓⵔ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵣⵎⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵜⵜⴻⴽⴽⵙⴻⵏ ⴷⴷⵏⵓⴱ ⵅ ⴷⴷⵓⵏⴻⵛⵜ! ");
INSERT INTO rift_vpl VALUES ("JN1_30","073_1_30","JHN","1","30","30","ⴷ ⵡⴰ ⵎⵉⵏ ⵅⴻⴼ ⵏⵏⵉⵖ: ‘ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⵇⴱⴻⵍ ⵉⵏⵓ.’ ");
INSERT INTO rift_vpl VALUES ("JN1_31","073_1_31","JHN","1","31","31","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ ⵛⴰ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵖⴻⴹⵚⴻⵖ ⴷⴻⴳ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN1_32","073_1_32","JHN","1","32","32","ⵢⵓⵃⴰⵏⵏⴰ ⵉⵛⵀⴻⴷ, ⵉⵏⵏⴰ: “ⵥⵔⵉⵖ ⴰⵔⵔⵓⵃ ⵉⵀⵡⴰ-ⴷⴷ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⴷⴱⵉⵔⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴰⵔⵙⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN1_33","073_1_33","JHN","1","33","33","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ ⵛⴰ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵖⴻⴹⵚⴻⵖ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵡⴻⵏⵏⵉ ⵜⴻⵥⵔⵉⴷ ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵢⴰⵔⵙⴰ ⵅⴰⵙ, ⴷ ⵡⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵖⴹⴰⵚⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("JN1_34","073_1_34","JHN","1","34","34","ⵓ ⵏⴻⵛⵛ ⵥⵔⵉⵖ, ⵛⴻⵀⴷⴻⵖ ⴱⴻⵍⵍⵉ ⵡⴰⵏⵉⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN1_35","073_1_35","JHN","1","35","35","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⴱⴻⴷⴷ ⴰⴽ-ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN1_36","073_1_36","JHN","1","36","36","ⴰⵎ ⵜⵓⵖⴰ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵢⴰⵙⵓⵄ ⵉ ⴷⵉⵏ ⵉⴳⴳⵓⵔⴻⵏ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔⴻⵎ, ⴷ ⵡⴰ ⴷ ⵉⵣⵎⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("JN1_37","073_1_37","JHN","1","37","37","ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙⵍⵉⵏ ⴰⵙ ⴰⵎ ⵜⵜ ⵉⵇⵇⴰⵔ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN1_38","073_1_38","JHN","1","38","38","ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵥⵔⴰ ⵉ-ⵜⴻⵏ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ, ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ: “ⵎⵉⵏ ⵅⴻⴼ ⵜⴰⵔⴻⵣⵣⵓⵎ?” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN1_39","073_1_39","JHN","1","39","39","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵔⴰⵃⴻⵎ-ⴷⴷ, ⴰⴷ ⵜⵥⴰⵔⴻⵎ!” ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⴻⵙ, ⵥⵔⵉⵏ ⵎⴰⵏⵉ ⵉⵣⴷⴻⵖ, ⵇⵇⵉⵎⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴰⵙⵙ ⵏⵏⵉ. ⵜⴰⵙⴰⵄⵄⴻⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵄⵍⴰⵃⴰⵍ ⴷ ⵄⴻⵛⵔⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵄⵍⴰⵃⴰⵍ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JN1_40","073_1_40","JHN","1","40","40","ⴰⵏⴷⵔⴰⵡⵓⵙ, ⵓⵎⴰⵙ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵜⵓⵖⴰ-ⵜ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴰⵢⴰ ⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵓⵛⴰ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN1_41","073_1_41","JHN","1","41","41","ⴷ ⵡⴰ ⵉ ⵉⵥⵔⵉⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵎⴰⵙ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⵏⵓⴼⴰ ⵍⵎⴰⵙⵉⵃ!” ");
INSERT INTO rift_vpl VALUES ("JN1_42","073_1_42","JHN","1","42","42","ⵉⵙⵙⵉⵡⴻⴹ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ. ⵉⵅⵣⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵛⴻⴽ ⴷ ⵛⵉⵎⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰ, ⴰⴷ ⴰⵛ ⵍⴰⵖⴰⵏ: ‘ⴽⵉⴼⴰ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵥⵔⵓ’ ”   ");
INSERT INTO rift_vpl VALUES ("JN1_43","073_1_43","JHN","1","43","43","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵅⵙ ⵢⴰⵙⵓⵄ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ⵉⵎⵎⴻⵍⵇⴰ ⴰⴽ-ⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN1_44","073_1_44","JHN","1","44","44","ⴼⵉⵍⵉⴱⴱⵓⵙ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵣⵉ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ ⵣⵉ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵏⴷⵔⴰⵡⵓⵙ ⴷ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JN1_45","073_1_45","JHN","1","45","45","ⴼⵉⵍⵉⴱⴱⵓⵙ ⵢⵓⴼⴰ ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⵏⵓⴼⴰ ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵢⵓⵔⴰ ⵎⵓⵙⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵍⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN1_46","073_1_46","JHN","1","46","46","ⵏⴰⵜⴰⵏⴰⵢⵉⵍ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⴰⴷ ⵜⴰⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ ⵛⴰ ⵏ ⵜⵛⵓⵏⵉ?” ⴼⵉⵍⵉⴱⴱⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵔⴰⵃ-ⴷⴷ, ⵜⴻⵅⵣⴰⵔⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN1_47","073_1_47","JHN","1","47","47","ⵢⴰⵙⵓⵄ ⵉⵥⵔⴰ ⵏⴰⵜⴰⵏⴰⵢⵉⵍ ⵉⴳⴳⵓⵔ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⵅⴰⵙ: “ⵅⵣⴰⵔ, ⵡⴰ ⴷ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⴷ ⵜⵉⴷⴻⵜⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵖⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("JN1_48","073_1_48","JHN","1","48","48","ⵏⴰⵜⴰⵏⴰⵢⵉⵍ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏⵉⵙ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵏⴻⴷ?” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵥⵔⵉⵖ ⵛⴻⴽ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵡⴰⵔⵜⵓ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⴰⵛ ⴷⴷ-ⵉⵍⴰⵖⴰ ⴼⵉⵍⵉⴱⴱⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN1_49","073_1_49","JHN","1","49","49","ⵏⴰⵜⴰⵏⴰⵢⵉⵍ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵛⴻⴽ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JN1_50","073_1_50","JHN","1","50","50","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⵓⵎⵏⴻⴷ ⵙ ⵎⵉⵏⵣⵉ ⴷ ⴰⵛ ⵏⵏⵉⵖ: ‘ⴰⵇⴰ ⵥⵔⵉⵖ ⵛⴻⴽ ⵙⵡⴰⴷⴷⴰⵢ ⵉ ⵡⴰⵔⵜⵓ’? ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴽⵜⴰⵔ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN1_51","073_1_51","JHN","1","51","51","ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⴰⵊⴻⵏⵏⴰ ⵉⵏⵏⵓⵔⵣⴻⵎ ⵓ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵜⴰⵍⵢⴻⵏⵜ ⵀⴻⴽⴽⵡⴰⵏⵜ ⵖⴰⵔ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("JN2_1","073_2_1","JHN","2","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵜⴻⵎⵙⴰⵔ ⵉⵛⵜ ⵏ ⵜⵎⴻⵖⵔⴰ ⴷⵉ ⵇⴰⵏⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN2_2","073_2_2","JHN","2","2","2","ⵓⵍⴰ ⴷ ⵢⴰⵙⵓⵄ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵜⵎⴻⵖⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN2_3","073_2_3","JHN","2","3","3","ⵍⴰⵎⵉ ⵉⵇⴹⴰ ⴱⵉⵏⵓ, ⵜⴻⵏⵏⴰ ⴰⵙ ⵢⴻⵎⵎⴰⵙ ⵉ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⴱⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("JN2_4","073_2_4","JHN","2","4","4","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵢⵉ ⴰⴽⵉⴷⴻⵎ, ⴰ ⵜⴰⵎⵖⴰⵔⵜ? ⵜⴰⵙⴰⵄⵄⴻⵜ ⵉⵏⵓ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵡⵉⴹ ⵄⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN2_5","073_2_5","JHN","2","5","5","ⵢⴻⵎⵎⴰⵙ ⵜⴻⵏⵏⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ: “ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵢⵉⵏⵉ, ⴳⴳⴻⵎ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN2_6","073_2_6","JHN","2","6","6","ⵜⵓⵖⴰ ⴷⵉⵏ ⵙⴻⵜⵜⴰ ⵏ ⵉⵇⴻⴷⴷⵡⴰⵃ ⵏ ⵡⴻⵥⵔⵓ ⴷⴰⵢⵙⴻⵏ ⴰⵎⴰⵏ, ⵎⵎⴰⵔⵙⴻⵏ ⴷⵉⵏⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵓⵎⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵍⵓⴹⵓ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔⴻⵙ ⵍⵇⴻⴷⴷ ⵏ ⵜⵏⴰⵢⴻⵏ ⴰⵍ ⵜⵍⴰⵜⴰ ⵏ ‘ⵉⵔⵉⴱⴰⵄⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("JN2_7","073_2_7","JHN","2","7","7","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵛⵛⵓⵔⴻⵎ ⵉⵇⴻⴷⴷⵡⴰⵃ ⵙ ⵡⴰⵎⴰⵏ!” ⵓⵛⴰ ⵛⵛⵓⵔⴻⵏ ⵜⴻⵏ ⵙ ⵡⴰⵎⴰⵏ ⴰⵍ ⴰⵇⴻⵎⵎⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JN2_8","073_2_8","JHN","2","8","8","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵍⴻⵅⵅⵓ ⵙⵙⴼⴰⵔⵔⵖⴻⵎ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⵙⴻⵏ, ⵡⵛⴻⵎ ⵜ ⵉ ⴱⴰⴱ ⵏ ⵡⵓⵔⴰⵔ.” ⵓⵛⴰ ⵙⵙⵉⵡⴹⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("JN2_9","073_2_9","JHN","2","9","9","ⵓⵎⵉ ⴱⴰⴱ ⵏ ⵡⵓⵔⴰⵔ ⵉⵇⴻⴵⴻⴱ ⴰⵎⴰⵏ ⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴱⵉⵏⵓ - ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵉⴽⴽⴰ, ⵎⴰⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵢⵎⴻⵏ ⴰⵎⴰⵏ, ⵙⵙⵏⴻⵏ - ⵉⵍⴰⵖⴰ-ⴷⴷ ⴱⴰⴱ ⵏ ⵜⵎⴻⵖⵔⴰ ⵅ ⵡⴻⵙⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("JN2_10","073_2_10","JHN","2","10","10","ⵉⵏⵏⴰ ⴰⵙ: “ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵇⴻⴷⴷⴰⵎ ⴱⵉⵏⵓ ⴰⵚⴻⴱⵃⴰⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ⵎⴰⵍⴰ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵙⵡⵉⵏ ⴰⵟⵟⴰⵙ, ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⴱⵉⵏⵓ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵅⴻⵎⵎⵍⴻⴷ ⴱⵉⵏⵓ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN2_11","073_2_11","JHN","2","11","11","ⴷ ⵜⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ, ⴷⵉ ⵇⴰⵏⴰ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ⵉⵙⵙⴻⴹⵀⴰⵔ-ⴷⴷ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN2_12","073_2_12","JHN","2","12","12","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⵏⴻⵜⵜⴰ ⴷ ⵢⴻⵎⵎⴰⵙ, ⴷ ⴰⵢⵜⵎⴰⵙ, ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN2_13","073_2_13","JHN","2","13","13","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵍⵄⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JN2_14","073_2_14","JHN","2","14","14","ⵢⵓⴼⴰ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵣⵣⵏⵓⵣⴰⵏ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⴷ ⵡⵓⴵⵉ ⴷ ⵉⴷⴱⵉⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵚⴰⵔⵔⴰⴼⴻⵏ ⵏ ⵜⴻⵏⵄⴰⵛⵉⵏ ⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN2_15","073_2_15","JHN","2","15","15","ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵓⵔⴻⴽⴽⵓⴹ ⵣⴻⴳ ⵉⵙⴻⵖⵡⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵢⵓⵥⵥⴻⵍ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵍⴰ ⴷ ⵓⴵⵉ ⴷ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⴷ ⵉⵚⴰⵔⵔⴰⴼⴻⵏ, ⵓⵛⴰ ⵉⵣⴻⴵⴻⵄ ⵉⵚⵓⵍⴷⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⴻⵇⵍⴻⴱ ⵟⵟⵡⴰⴱⴻⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN2_16","073_2_16","JHN","2","16","16","ⵉⵏⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵣⵣⵏⵓⵣⴰⵏ ⵉⴷⴱⵉⵔⴻⵏ: “ⴽⴽⵙⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵙⵙⴰ! ⵡⴰⵔ ⵜⵜⴰⵔⵔⵉⵎ ⵛⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵙⵙⵓⵇ!” ");
INSERT INTO rift_vpl VALUES ("JN2_17","073_2_17","JHN","2","17","17","ⵅⴻⵏⵏⵉ ⵄⴻⵇⵍⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⵜⵓⵔⴰ: “ⵛⴹⴰⵔⴻⵜ ⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ ⵉⵛⵛⴰ ⴰⵢⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN2_18","073_2_18","JHN","2","18","18","ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵖⴰ ⵜⴻⵎⵍⴻⴷ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵖⴰⵔⴻⴽ ⵍⵃⴻⵇⵇ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN2_19","073_2_19","JHN","2","19","19","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵀⴻⴷⵎⴻⵎ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴷ ⵜⵜ ⵙⵙⴱⴻⴷⴷⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN2_20","073_2_20","JHN","2","20","20","ⵏⵏⴰⵏ ⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ: “ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴰⵏⵉⵜⴰ ⵜⴻⴱⵏⴰ ⴷⵉ ⵙⴻⵜⵜⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰ ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵜⴻⵙⵙⴱⴻⴷⴷⴻⴷ ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN2_21","073_2_21","JHN","2","21","21","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN2_22","073_2_22","JHN","2","22","22","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵢⴰⵙⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵄⴻⵇⵍⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ, ⵓⵛⴰ ⵓⵎⵏⴻⵏ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN2_23","073_2_23","JHN","2","23","23","ⵓⵎⵉ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵓⵎⵏⴻⵏ ⵡⴰⵟⵟⴰⵙ ⴷⴰⵢⴻⵙ ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("JN2_24","073_2_24","JHN","2","24","24","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵉⵙⵙⵛⴻⵏ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JN2_25","073_2_25","JHN","2","25","25","ⵡⴰⵔ ⵉⵃⴷⵉⵊ ⵛⴰ ⴰⴷ ⴰⵙ ⵉⵛⵀⴻⴷ ⵃⴻⴷ ⵅ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN3_1","073_3_1","JHN","3","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵏⵉⴽⵓⴷⵉⵎⵓⵙ, ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN3_2","073_3_2","JHN","3","2","2","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵢⴰⵙⵓⵄ ⵙ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵉⵏⵓ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵖⵖⴰⵔ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⴳⴳ ⵍⴻⵄⵍⴰⵎⴰⵜ-ⴰ ⵉ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⴰⴽⵉⴷⴻⵙ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN3_3","073_3_3","JHN","3","3","3","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵥⴰⵔ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵣⵉ ⵊⴷⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN3_4","073_3_4","JHN","3","4","4","ⵏⵉⴽⵓⴷⵉⵎⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⵓⵡⴻⵙⵙⴰⵔ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⵍⴻⵇ ́́ⵄⴰⴷ? ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴷⴻⴼ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⵍⴻⵇ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN3_5","073_3_5","JHN","3","5","5","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵅⵍⵉⵇ ⵛⴰ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵓ ⵣⴻⴳ ⴰⵔⵔⵓⵃ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN3_6","073_3_6","JHN","3","6","6","ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴷⴷⴰⵜ, ⵏⴻⵜⵜⴰ ⴷ ⴷⴷⴰⵜ, ⵓ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⵔⵓⵃ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("JN3_7","073_3_7","JHN","3","7","7","ⵡⴰⵔ ⵜⴱⴻⵀⵜⴻⵎ ⵛⴰ ⵎⴰⵍⴰ ⵏⵏⵉⵖ ⴰⵛ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵎ ⵣⵉ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JN3_8","073_3_8","JHN","3","8","8","ⴰⵙⴻⵎⵎⵉⴹ ⵉⵜⵜⵙⵓⴹ ⵎⴰⵏⵉⵙ ⵉⵅⵙ, ⵜᵉⵜⵜⴻⵙⵍⵉⴷ ⵉ ⵓⵙⵓⴹⵉ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵓⵍⴰ ⵎⴰⵏⵉ ⵉⵜⵜⵔⴰⵃ. ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⵔⵓⵃ.” ");
INSERT INTO rift_vpl VALUES ("JN3_9","073_3_9","JHN","3","9","9","ⵏⵉⴽⵓⴷⵉⵎⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN3_10","073_3_10","JHN","3","10","10","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⵖⵖⴰⵔ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("JN3_11","073_3_11","JHN","3","11","11","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴰⵡⴰⵍ ⵅ ⵎⵉⵏ ⵏⴻⵙⵙⴻⵏ, ⵏⴻⵛⵀⴻⴷ ⵅ ⵎⵉⵏ ⵏⴻⵥⵔⴰ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵇⴱⵉⵍⴻⵎ ⵛⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN3_12","073_3_12","JHN","3","12","12","ⵎⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴻⵎ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵉⵎⵏⴻⵎ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⵎⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴻⵎ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ? ");
INSERT INTO rift_vpl VALUES ("JN3_13","073_3_13","JHN","3","13","13","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵢⵓⵍⵉ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JN3_14","073_3_14","JHN","3","14","14","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⵓⵙⴰ ⴰⴼⵉⵖⴰⵔ ⴷⵉ ⵍⴻⴼⵢⴰⴼⵉ, ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("JN3_15","073_3_15","JHN","3","15","15","ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵀⴻⵍⵍⵉⴽ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN3_16","073_3_16","JHN","3","16","16","ⴰⵎⵎⵓ ⵉ ⵢⴻⵅⵙ ⴰⵔⴻⴱⴱⵉ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵍ ⵎⴰⵏⵉ ⵉⵡⵛⴰ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵀⴻⵍⵍⵉⴽ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN3_17","073_3_17","JHN","3","17","17","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵛⴰ ⵎⵎⵉⵙ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴰⵙⴻⴱ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴷⴷⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN3_18","073_3_18","JHN","3","18","18","ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵃⴰⵙⴰⴱ ⵛⴰ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵎⵏⴻⵏ ⵛⴰ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⴰⵙⴻⴱ ⵣⵉ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵓⵎⵉⵏ ⵛⴰ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵓⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN3_19","073_3_19","JHN","3","19","19","ⴷ ⵡⴰ ⴷ ⵍⴻⵃⴽⴰⵎ, ⴰⵇⴰ ⵜⴰⴼⴰⵡⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⵉⵡⴷⴰⵏ ⵅⵙⴻⵏ ⵜⴰⴵⴻⵙⵜ ⵅ ⵜⴼⴰⵡⵜ, ⵎⵉⵏⵣⵉ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JN3_20","073_3_20","JHN","3","20","20","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵉⵛⴰⵔⵔⴻⵀ ⵜⴰⴼⴰⵡⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⴰ ⵖⴰⵔ ⵜⴼⴰⵡⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵡⴻⴱⴱⵅⴻⵏⵜ ⵛⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN3_21","073_3_21","JHN","3","21","21","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⵜⴼⴰⵡⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵏⴻⵏⵜ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⴷⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN3_22","073_3_22","JHN","3","22","22","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵉⵙⵙⴻⵄⴷⵓ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⵡⴻⵇⵜ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ. ");
INSERT INTO rift_vpl VALUES ("JN3_23","073_3_23","JHN","3","23","23","ⵓⵍⴰ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ ⴷⵉ ⵄⴰⵢⵏⵓⵏ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵟⵟⴰⵔⴼ ⵉ ⵙⴰⵍⵉⵎ, ⵎⵉⵏⵣⵉ ⴷⵉⵏⵏⵉ ⴰⵎⴰⵏ ⴰⵟⵟⴰⵙ. ⵓⵙⵉⵏ-ⴷⴷ ⵉⵡⴷⴰⵏ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JN3_24","073_3_24","JHN","3","24","24","ⵎⵉⵏⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵛⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN3_25","073_3_25","JHN","3","25","25","ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⵃⴰⵔⵡⴻⴹ ⵊⴰⵔ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⵓⴷⴰⵢ ⵅ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵍⵓⴹⵓ. ");
INSERT INTO rift_vpl VALUES ("JN3_26","073_3_26","JHN","3","26","26","ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵢⵓⵃⴰⵏⵏⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵅⵣⴰⵔ, ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⴵⴰⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵡⴻⵏⵏⵉ ⵎⵉⵏ ⵅⴻⴼ ⵜⵛⴻⵀⴷⴻⴷ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ ⵓ ⵎⴰⵔⵔⴰ ⵜⵜⴰⵙⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN3_27","073_3_27","JHN","3","27","27","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⴱⴻⵍ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵎⵎⴻⵡⵛ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JN3_28","073_3_28","JHN","3","28","28","ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵜⵛⴻⵀⵀⴷⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⴷ ⵍⵎⴰⵙⵉⵃ!’, ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN3_29","073_3_29","JHN","3","29","29","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵙⵍⵉⵜ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⵍⵉ. ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵡⴻⵙⵍⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴻⴷⴷⴰⵏ ⵣⵣⴰⵜⴻⵙ, ⵉⵜⵜⴻⵙⵍⴰ ⵖⴰⵔⴻⵙ, ⵉⴼⴰⵔⵔⴻⵃ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵙⵍⵉ. ⵙ ⵓⵢⴻⵏⵏⵉ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ ⵜⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JN3_30","073_3_30","JHN","3","30","30","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⴳⵎⴰ ⵏⴻⵜⵜⴰ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵏⴻⵇⵚⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN3_31","073_3_31","JHN","3","31","31","ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⵏⴻⵜⵜⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ. ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⵙⴰⵡⴰⵍ. ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵏⴻⵜⵜⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("JN3_32","073_3_32","JHN","3","32","32","ⵓ ⵏⴻⵜⵜⴰ ⵉⵛⴻⵀⵀⴻⴷ ⵣⵉ ⵎⵉⵏ ⵉⵥⵔⴰ ⴷ ⵣⵉ ⵎⵉⵏ ⵉⵙⵍⴰ, ⵎⴰⵛⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜ ⵉⵇⴻⴱⴱⵉⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN3_33","073_3_33","JHN","3","33","33","ⵡⴻⵏⵏⵉ ⵉⵇⴻⴱⴱⵍⴻⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵙⴻⵏ ⵟⵟⴰⴱⴻⵄ ⵏⵏⴻⵙ ⵏ ⵓⵛⴻⵎⵎⵉⵄ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN3_34","073_3_34","JHN","3","34","34","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴰⵔⴻⴱⴱⵉ, ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵛ ⵛⴰ ⴰⵔⵔⵓⵃ ⵙ ⵍⵎⵉⵣⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN3_35","073_3_35","JHN","3","35","35","ⴱⴰⴱⴰⵙ ⵉⵜⵜⴻⵅⵙ ⵎⵎⵉⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⴽⵓⵍⵛⵉ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN3_36","073_3_36","JHN","3","36","36","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ ⴷⵉ ⵎⵎⵉⵙ ⵖⴰⵔⴻⵙ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⵄ ⵛⴰ ⵎⵎⵉⵙ, ⵡⴰⵔ ⵉⵥⴰⵔⵔ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⴰⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵅⴰⵙ ⵉⵇⵇⵉⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN4_1","073_4_1","JHN","4","1","1","ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⴰⵇⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵓ ⵉⵙⵙⵖⴻⵟⵟⴰⵚ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴽⵜⴰⵔ ⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ");
INSERT INTO rift_vpl VALUES ("JN4_2","073_4_2","JHN","4","2","2","- ⵡⴰⵅⵅⴰ ⵢⴰⵙⵓⵄ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵙⵙⴻⵖⴹⵉⵚ ⵛⴰ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ - ");
INSERT INTO rift_vpl VALUES ("JN4_3","073_4_3","JHN","4","3","3","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵉⵔⵓⵃ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JN4_4","073_4_4","JHN","4","4","4","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵛⵓⵇ ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN4_5","073_4_5","JHN","4","5","5","ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵙⵓⵅⴰⵔ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵟⵟⴰⵔⴼ ⵏ ⵉⵢⵢⴰⵔ ⵉ ⵉⵡⵛⴰ ⵢⴰⵄⵇⵓⴱ ⵉ ⵎⵎⵉⵙ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("JN4_6","073_4_6","JHN","4","6","6","ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵏⵓ ⵏ ⵢⴰⵄⵇⵓⴱ. ⵢⵓⵃⴻⵍ ⵢⴰⵙⵓⵄ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵇⵇⵉⵎ ⴰⵎⴻⵏⵏⵉ ⵖⴰⵔ ⵡⴰⵏⵓ, ⵜⵓⵖⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⴷ ⵙⴻⵜⵜⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("JN4_7","073_4_7","JHN","4","7","7","ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⴳⴻⵎ ⴰⵎⴰⵏ. ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴰⵏ, ⴰⴷ ⵙⵡⴻⵖ!”, ");
INSERT INTO rift_vpl VALUES ("JN4_8","073_4_8","JHN","4","8","8","ⵎⵉⵏⵣⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵖⴻⵏ ⵎⴰⵛⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN4_9","073_4_9","JHN","4","9","9","ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵣⵣⴰⵢⵉ ⴰⴷ ⵜⴻⵙⵡⴻⴷ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵓⴷⴰⵢ ⵓ ⵏⴻⵛⵛ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ?” ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⵡⴰⵔ ⵏⵏⵓⵎⴻⵏ ⵜⵜⴻⵎⵚⵓⵔⵓⴼⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵙⴰⵎⴰⵔⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN4_10","073_4_10","JHN","4","10","10","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵄⵍⵉⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵜⵉⵎⴻⵡⵛⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⴻⵡⵛ ⴰⵢⵉ ⴰⴷ ⵙⵡⴻⵖ!’, ⵉⵍⵉ ⵛⴻⵎ ⵜᵉⵜⵜⴰⵔ ⵜⵜ ⵣⵣⴰⵢⴻⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵡⵛ ⴰⵎ ⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN4_11","073_4_11","JHN","4","11","11","ⵜⴻⵏⵏⴰ ⴰⵙ ⵜⴻⵎⵖⴰⵔⵜ: “ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵉ ⵣⵉ ⵖⴰ ⵜⴰⴳⵎⴻⴷ ⵓⵛⴰ ⴰⵏⵓ ⵢⵓⴵⴻⵖ, ⵎⴰⵏⵉⵙ ⵉ ⴷ ⵖⴰ ⵜⴰⵡⵢⴻⴷ ⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JN4_12","073_4_12","JHN","4","12","12","ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵉ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ ⵢⴰⵄⵇⵓⴱ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⴰⵏⵓ ⵡⴰⵏⵉⵜⴰ, ⵉⵙⵡⴰ ⵣⵣⴰⵢⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴷ ⵍⴻⴱⵀⴰⵢⴻⵎ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("JN4_13","073_4_13","JHN","4","13","13","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵡⴻⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ-ⴰ, ⴰⴷ ⵉⴼⵓⴷ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("JN4_14","073_4_14","JHN","4","14","14","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵡⴻⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵡⵛⴻⵖ ⵏⴻⵛⵛ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴼⴰⴷⵉ ⵄⴻⵎⵎⴰⵔⵚ. ⵎⵉⵏⵣⵉ ⴰⵎⴰⵏ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵡⵛⴻⵖ ⵏⴻⵛⵛ, ⴰⴷ ⴷⴰⵢⴻⵙ ⴷⴻⵡⵍⴻⵏ ⴷ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⵉ ⴷⴷ ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN4_15","073_4_15","JHN","4","15","15","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⴻⵡⵛ ⴰⵢⵉ ⴰⵎⴰⵏ-ⴰ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴼⵉⴷⴻⵖ, ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⵙⴻⵖ ⵄⴰⴷ ⴷⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⴳⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN4_16","073_4_16","JHN","4","16","16","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵔⵓⵃ, ⵍⴰⵖⴰ-ⴷⴷ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵎ ⵓⵛⴰ ⴷⵡⴻⵍ-ⴷⴷ ⴷⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN4_17","073_4_17","JHN","4","17","17","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵡⴻⵔⵢⴰⵣ!” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵏⵉⵛⴰⵏ ⵓⵎⵉ ⵜⴻⵏⵏⵉⴷ: ‘ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵡⴻⵔⵢⴰⵣ!’, ");
INSERT INTO rift_vpl VALUES ("JN4_18","073_4_18","JHN","4","18","18","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵎ ⵅⴻⵎⵙⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔⴻⵎ ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵉⴵⵉ ⴱⵓ ⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ. ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜⴻⵏⵏⵉⴷ ⴷ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN4_19","073_4_19","JHN","4","19","19","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵜⵜⵡⴰⵍⵉⵖ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴷ ⴰⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN4_20","073_4_20","JHN","4","20","20","ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵙⴻⵊⴷⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ-ⴰ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴱⴻⵍⵍⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷⵉ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵏⴻⵙⵊⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN4_21","073_4_21","JHN","4","21","21","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵜⵜⵉⵇⵇ ⴰⵢⵉ, ⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ, ⴰⵇⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵉ ⴷⵉ ⵡⴰⵔ ⵜⵄⴻⴱⴱⴷⴻⵎ ⴱⴰⴱⴰ ⵓⵍⴰ ⴷⴻⴳ ⵡⴻⴷⵔⴰⵔ-ⴰ ⵓⵍⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JN4_22","073_4_22","JHN","4","22","22","ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⴱⴱⴷⴻⵎ ⵎⵉⵏ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵄⴻⴱⴱⴻⴷ ⵎⵉⵏ ⵏⴻⵙⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN4_23","073_4_23","JHN","4","23","23","ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴻⴹ ⵜⵙⴰⵄⵄⴻⵜ, ⵏⴻⵜⵜⴰⵜ ⴰⵇⴰ-ⵜⵜ ⵍⴻⵅⵅⵓ, ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵏⵉⵛⴰⵏ, ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⴱⴰⴱⴰ ⴷⵉ ⴰⵔⵔⵓⵃ ⵓ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵉⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵄⴻⴱⴷⴻⵏ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("JN4_24","073_4_24","JHN","4","24","24","ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵔⵔⵓⵃ ⵓ ⵉⵏⵏⵉ ⵜ ⵉⵄⴻⴱⴱⴷⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⴷ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN4_25","073_4_25","JHN","4","25","25","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵍⵎⴰⵙⵉⵃ. ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵏⴻⵜⵜⴰ, ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴽⵓⵍⵛⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN4_26","073_4_26","JHN","4","26","26","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⴽⵉⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN4_27","073_4_27","JHN","4","27","27","ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ, ⵓⵙⵉⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵜⵄⴻⵊⴱⴻⵏ ⵍⴰⵎⵉ ⵜ ⵓⴼⵉⵏ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ. ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵏⵉ: “ⵎⵉⵏ ⵜⴰⵔⴻⵣⵣⵓⴷ?” ⵏⵉⵖ: “ⵎⴰⵢⴻⵎⵎⵉ ⴰⴽⵉⴷⴻⵙ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN4_28","073_4_28","JHN","4","28","28","ⵅⴰⵙ ⵓⵛⴰ ⵜⴻⵊⵊⴰ ⵜⴻⵎⵖⴰⵔⵜ ⴰⵇⴻⴷⴷⵓⵃ ⵏⵏⴻⵙ ⵙ ⵡⴰⵎⴰⵏ, ⵜⵓⵢⵓⵔ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⴻⵏⵏⴰ ⵉ ⵉⵡⴷⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("JN4_29","073_4_29","JHN","4","29","29","“ⴰⵔⴰⵃⴻⵎ-ⴷⴷ, ⴰⴷ ⵜⵥⴰⵔⴻⵎ ⴰⵔⵢⴰⵣ ⵉ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵖ. ⵎⴰ ⴰⴷ ⵜⴰⵖ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ?” ");
INSERT INTO rift_vpl VALUES ("JN4_30","073_4_30","JHN","4","30","30","ⵉⵡⴷⴰⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN4_31","073_4_31","JHN","4","31","31","ⵊⴰⵔ ⵓ ⵊⴰⵔ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("JN4_32","073_4_32","JHN","4","32","32","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⵖⴰⵔⵉ ⵉⵊⵊ ⵏ ⵎⴰⵛⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵛⵛ, ⵡⴰⵔ ⵜⵜ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴽⴻⵏⵏⵉⵡ.” ");
INSERT INTO rift_vpl VALUES ("JN4_33","073_4_33","JHN","4","33","33","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⵎⵙⴻⵇⵙⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵎⴰ ⵢⵉⵡⵢⵉ ⴰⵙ-ⴷⴷ ⵃⴻⴷ ⵛⴰ ⵏ ⵎⴰⵛⵛⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN4_34","073_4_34","JHN","4","34","34","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵛⵛⴰ ⵉⵏⵓ ⴰⵇⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⵅⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵓ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN4_35","073_4_35","JHN","4","35","35","ⵎⴰ ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵚⵚⴰⴱⴻⵜ’?’ ⵅⵣⴰⵔⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵙⴳⴻⵄⵄⴷⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵅⵣⴰⵔⴻⵎ ⴷⴻⴳ ⵉⵢⵢⴰⵔⴻⵏ, ⴰⵇⴰ ⵡⴰⵔⵖⴻⵏ, ⵡⴻⵊⴷⴻⵏ ⵉ ⵚⵚⴰⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN4_36","073_4_36","JHN","4","36","36","ⵡⴻⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ ⴰⴷ ⵉⴽⵙⵉ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ, ⵉⵢⵔⵓ ⵍⵖⵉⴵⴻⵜ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵊⵎⵉⵄ ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵎⴻⵊⵊⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN4_37","073_4_37","JHN","4","37","37","ⵎⵉⵏⵣⵉ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⴰⵡⴰⵍ-ⴰ ⴷ ⵜⵉⴷⴻⵜⵜ: ‘ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵣⴰⵔⵄ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵎⵊⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("JN4_38","073_4_38","JHN","4","38","38","ⵏⴻⵛⵛ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵊⴰⵔⴻⵎ ⵎⵉⵏ ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵅⴷⵉⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ. ⵉⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵅⴻⴷⴷⵎⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵜⵓⴷⴼⴻⵎ ⵖⴰⵔ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN4_39","073_4_39","JHN","4","39","39","ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵉ ⵜⵓⵖⴰ ⵉⵛⴻⵀⵀⴷⴻⵏ: “ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴳⴳⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN4_40","073_4_40","JHN","4","40","40","ⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵓⵙⵉⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⵉ, ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵃⵉⵎⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵇⵇⵉⵎ, ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN4_41","073_4_41","JHN","4","41","41","ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JN4_42","073_4_42","JHN","4","42","42","ⵏⵏⴰⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ: “ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵎⴻⵏ ⵛⴰ ⵄⴰⴷ ⵣⵉ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵜⴻⵏⵏⵉⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵉ-ⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN4_43","073_4_43","JHN","4","43","43","ⴰⵡⴰⵔⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵙⵙⴻⵏⵏⵉ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JN4_44","073_4_44","JHN","4","44","44","ⵎⵉⵏⵣⵉ ⵢⴰⵙⵓⵄ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⵇⴰ ⵉⵛⵀⴻⴷ ⴱⴻⵍⵍⵉ ⴰⵏⴰⴱⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵛⵛⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN4_45","073_4_45","JHN","4","45","45","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ, ⴰⵔⴻⵃⵃⴱⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵉⵊⴰⵍⵉⵍⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⵉ ⵍⵄⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵍⵄⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JN4_46","073_4_46","JHN","4","46","46","ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵇⴰⵏⴰ ⴷⵉ ⵍⵊⴰⵍⵉⵍ ⵎⴰⵏⵉ ⵢⴰⵔⵔⴰ ⴰⵎⴰⵏ ⴷ ⴱⵉⵏⵓ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⴷⵉ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ ⵖⴰⵔⴻⵙ ⵎⵎⵉⵙ ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JN4_47","073_4_47","JHN","4","47","47","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ, ⵉⵔⵓⵃ ⵖⴰⵔⴻⵙ, ⵉⵙⵙⴻⵇⵙⴰ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵎⵎⵉⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN4_48","073_4_48","JHN","4","48","48","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵜⵉⵎⵏⴻⵎ ⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵥⵔⵉⵎ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN4_49","073_4_49","JHN","4","49","49","ⵉⵏⵏⴰ ⴰⵙ ⵓⵅⴻⴷⴷⴰⵎ ⵏ ⵓⵊⴻⴵⵉⴷ: “ⴰ ⵙⵉⴷⵉ, ⵀⵡⴰ-ⴷⴷ ⵇⴱⴻⵍ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ ⵓⵃⴻⵏⵊⵉⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN4_50","073_4_50","JHN","4","50","50","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ ⴰⵇⴰ ⵎⵎⵉⵛ ⵉⴷⴷⴰⵔ!” ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉⵜⵜⵉⵇⵇ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("JN4_51","073_4_51","JHN","4","51","51","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵀⵡⴰ, ⵎⵎⴻⵍⵇⴰⵏ ⴰⴽⵉⴷⴻⵙ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵇⴰ ⵎⵎⵉⵛ ⵉⴷⴷⴰⵔ”. ");
INSERT INTO rift_vpl VALUES ("JN4_52","073_4_52","JHN","4","52","52","ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⵅ ⵜⵙⴰⵄⵄⴻⵜ ⵎⵉⵏ ⴷⵉ ⵉⴳⴳⴻⵏⴼⴰ. ⵏⵏⴰⵏ ⴰⵙ: “ⵉⴹⴻⵏⵏⴰⴹ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵓⵣⵉⵍ, ⵜⴻⵊⵊⴰ ⵅⴰⵙ ⵜⵎⴻⵙⵙⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN4_53","073_4_53","JHN","4","53","53","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵏ ⴱⴰⴱⴰⵙ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵎⵎⵉⵛ ⵉⴷⴷⴰⵔ!” ⵢⵓⵎⴻⵏ ⵏⴻⵜⵜⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN4_54","073_4_54","JHN","4","54","54","ⵜⴰ ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵖⴰⵔ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JN5_1","073_5_1","JHN","5","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵍⵄⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_2","073_5_2","JHN","5","2","2","ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⵓⴵⵉ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵢⴻⵍⵎⴰⵎⵜ ⵏ ⵓⵙⴻⵖⴹⴻⵚ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ‘ⴱⴰⵢⵜ-ⵅⵉⵙⴷⴰ’, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵉⵙⴻⵇⵇⵉⴼⴻⵏ ⴰⴽ-ⴷ ⵉⴽⵓⵍⵡⴰⵔⴻⵏ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_3","073_5_3","JHN","5","3","3","ⴷⴰⵢⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵎⴻⵀⵍⴰⵛ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷ ⵉⵇⴻⵊⴷⴰⵃⴻⵏ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ, ⵜⵜⵔⴰⵊⴰⵏ ⴰⵏⵀⴻⵣⵣⵉ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_4","073_5_4","JHN","5","4","4","ⵎⵉⵏⵣⵉ ⵣⵉ ⵍⵡⴻⵇⵜ ⵖⴰⵔ ⵍⵡⴻⵇⵜ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵖⴰⵔ ⵜⵢⴻⵍⵎⴰⵎⵜ-ⴰ ⵏ ⵓⵙⴻⵖⴹⴻⵚ, ⵉⵙⵙⴻⵏⵀⴻⵣⵣⴰ ⴰⵎⴰⵏ, ⵓ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵏⵀⴻⵣⵣⵉ ⵏ ⵡⴰⵎⴰⵏ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ, ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵉⴵⴰ ⵍⴻⵀⵍⴰⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN5_5","073_5_5","JHN","5","5","5","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴰⵢⴻⵙ ⵍⴻⵀⵍⴰⵛ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵎⴻⵏⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JN5_6","073_5_6","JHN","5","6","6","ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⴰⵔⵢⴰⵣ-ⴰ ⵉⵙⴻⵏⵏⴻⴷ ⴷⵉⵏⵏⵉ, ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵃⵍⴻⵛ ⴰⵎⵎⵓ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN5_7","073_5_7","JHN","5","7","7","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵓⵎⴻⵀⵍⵓⵛ, ⵉⵏⵏⴰ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⵉⵡⵢⴻⵏ ⵖⴰⵔ ⵜⵓⵢⴻⵍⵎⴰⵎⵜ ⵏ ⵓⵙⴻⵖⴹⴻⵚ ⵅⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⴻⵏⵀⴻⵣⵣⴻⵏ ⵡⴰⵎⴰⵏ. ⵅⵎⵉ ⵜⵜⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ, ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵜⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN5_8","073_5_8","JHN","5","8","8","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⵜⴻⴽⵙⵉⴷ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ, ⵜⵓⵢⵓⵔⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN5_9","073_5_9","JHN","5","9","9","ⴷⴻⵖⵢⴰ ⵉⴳⴳⴻⵏⴼⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵓⵛⴰ ⵉⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵙ, ⵢⵓⵢⵓⵔ. ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("JN5_10","073_5_10","JHN","5","10","10","ⵏⵏⴰⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ: “ⵡⴰ ⴷ ⵙⵙⴻⴱⵜ, ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("JN5_11","073_5_11","JHN","5","11","11","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴳⴻⵏⴼⴰⵏ, ⵉⵏⵏⴰ: ‘ⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ, ⵜⵔⴰⵃⴻⴷ!’” ");
INSERT INTO rift_vpl VALUES ("JN5_12","073_5_12","JHN","5","12","12","ⵅⴻⵏⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⵜ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵏⴰⴷⴻⵎ-ⴰ ⵉ ⴷ ⴰⵛ ⵉⵏⵏⴰⵏ: ‘ⴽⵙⵉ ⵜⴰⵙⵙⵓⵜ ⵏⵏⴻⵛ, ⵜⵔⴰⵃⴻⴷ’?” ");
INSERT INTO rift_vpl VALUES ("JN5_13","073_5_13","JHN","5","13","13","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵉⵄⵏⴰ ⵢⴰⵙⵓⵄ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴻⵊⵔⴰ ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN5_14","073_5_14","JHN","5","14","14","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⵓⴼⴰ ⵉ-ⵜ ⵢⴰⵙⵓⵄ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵏⵏⴰ ⴰⵙ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⵜⴻⴳⴳⴻⵏⴼⵉⴷ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴱⵓ ⴷⴷⵏⵓⴱ ⵄⴰⴷ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⴻⵎⵙⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵇⴱⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("JN5_15","073_5_15","JHN","5","15","15","ⴰⵔⵢⴰⵣ ⵉⵔⵓⵃ, ⵉⵅⴻⴱⴱⴰⵔ ⵓⴷⴰⵢⴻⵏ ⴱⴻⵍⵍⵉ ⴷ ⵢⴰⵙⵓⵄ ⵉ-ⵜ ⵉⵙⵙⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_16","073_5_16","JHN","5","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⴷⴰⵔⵔⵛⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵅ ⵢⴰⵙⵓⵄ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⴳⴳⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("JN5_17","073_5_17","JHN","5","17","17","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⴱⴰⴱⴰ ⵉⵅⴻⴷⴷⴻⵎ ⴰⵍ ⵢⵉⴹⴰ ⵓ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⴰⵇⴰ ⵅⴻⴷⴷⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN5_18","073_5_18","JHN","5","18","18","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵡⴰⵀⴰ ⵎⵉⵏⵣⵉ ⵉⵅⴰⵍⴻⴼ ⵙⵙⴻⴱⵜ, ⵎⴰⵛⴰ ⵓⵍⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⴱⴰⴱⴰⵙ, ⵉⵙⵙⵇⵓⴷⴷⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN5_19","073_5_19","JHN","5","19","19","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⵎⵉⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵉⵥⵔⴰ ⴱⴰⴱⴰⵙ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⵜ. ⵎⵉⵏ ⵎⴰ ⵉⵜⵜⴻⴳⴳ ⴱⴰⴱⴰⵙ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵉⵜⵜⴻⴳⴳ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN5_20","073_5_20","JHN","5","20","20","ⴱⴰⴱⴰⵙ ⵉⵜⵜⴻⵅⵙ ⵎⵎⵉⵙ, ⵉⵙⵙⵛⴻⵏ ⴰⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ, ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵙⵙⵛⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵅ ⵜⵉⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵀⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_21","073_5_21","JHN","5","21","21","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴱⴰⴱⴰⵙ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵓⵛⴰ ⵉⵜⵜⵉⵛ ⵜⵓⴷⴰⵔⵜ, ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵎⵎⵉⵙ ⵉⵜⵜⵉⵛ ⵜⵓⴷⴰⵔⵜ ⵉ ⵡⴻⵏⵏⵉ ⵉⵅⵙ. ");
INSERT INTO rift_vpl VALUES ("JN5_22","073_5_22","JHN","5","22","22","ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵉⵜⵜⵃⴰⵙⴰⴱ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⴰⵛⴰ ⵉⵡⵛⴰ ⵍⵃⵉⵙⴰⴱ ⵎⴰⵔⵔⴰ ⵉ ⵎⵎⵉⵙ ");
INSERT INTO rift_vpl VALUES ("JN5_23","073_5_23","JHN","5","23","23","ⵃⵉⵎⴰ ⴰⴷ ⵡⴻⵇⵇⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵎⵉⵙ ⴰⵎ ⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ ⴱⴰⴱⴰⵙ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵡⴰⵔ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⵛⴰ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_24","073_5_24","JHN","5","24","24","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵓⵛⴰ ⵢⵓⵎⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ, ⵖⴰⵔⴻⵙ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⴰ ⵖⴰⵔ ⵍⵃⵉⵙⴰⴱ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵎⵎⵓⵟⵟⵉ ⵣⵉ ⵍⵎⴻⵡⵜ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN5_25","073_5_25","JHN","5","25","25","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⵙⴰⵄⵄⴻⵜ, ⴰⵇⴰ-ⵜⵜ ⵍⴻⵅⵅⵓ, ⵉ ⴷⵉ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉⵏⵏⵉ ⵉ ⵜⵜ ⵖⴰ ⵉⵙⵍⴻⵏ, ⴰⴷ ⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_26","073_5_26","JHN","5","26","26","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴱⴰⴱⴰⵙ ⵖⴰⵔⴻⵙ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵎⵎⵓ ⵉ ⵉⵡⵛⴰ ⵓⵍⴰ ⵉ ⵎⵎⵉⵙ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JN5_27","073_5_27","JHN","5","27","27","ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴰⵙⴻⴱ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_28","073_5_28","JHN","5","28","28","ⵡⴰⵔ ⵜⵜⵄⴻⵊⵉⴱⴻⵎ ⵛⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ ⴰⴷ ⵙⵍⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JN5_29","073_5_29","JHN","5","29","29","ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ: ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵜⵏⵓⴽⵔⴰ ⵉ ⵜⵓⴷⴰⵔⵜ, ⵓ ⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴰⴷ ⴽⴽⴰⵔⴻⵏ, ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵜⵏⵓⴽⵔⴰ ⵉ ⵍⵃⵉⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("JN5_30","073_5_30","JHN","5","30","30","ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵛⴰ ⵣⴻⴳ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜⴻⵙⵍⵉⵖ, ⴰⴷ ⵃⴰⵙⴱⴻⵖ ⵓ ⵍⵃⵉⵙⴰⴱ ⵉⵏⵓ ⴷ ⵍⵃⴻⵇⵇ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵖ ⵎⵉⵏ ⵅⵙⴻⵖ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵅⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_31","073_5_31","JHN","5","31","31","ⵎⴻⵄⵍⵉⴽ ⵛⴻⵀⵀⴷⴻⵖ ⵉ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵉⵍⵉ ⴰⵇⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵉⵏⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_32","073_5_32","JHN","5","32","32","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵡⵉ ⵅⴰⴼⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ, ⵓ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵅⴰⴼⵉ ⵉⵛⴻⵀⵀⴻⴷ, ⴰⵇⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵉ ⵜⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("JN5_33","073_5_33","JHN","5","33","33","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴻⴽⴽⴻⵎ-ⴷⴷ ⵛⴰ ⵏ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ ⵖⴰⵔ ⵢⵓⵃⴰⵏⵏⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵛⵀⴻⴷ ⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN5_34","073_5_34","JHN","5","34","34","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵇⴻⴱⴱⵍⴻⵖ ⵛⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_35","073_5_35","JHN","5","35","35","ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⴻⴼⵏⴰⵔ ⵢⴰⵔⴻⵇⵇⴻⵏ, ⵉⵜⵜⵍⵉⵍⵍⵉⵛⴻⵏ, ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ ⵙ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN5_36","073_5_36","JHN","5","36","36","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⴻⵏⵏⵉ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵎⵉⵏⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⴱⴰⴱⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⴽⴻⵎⵎⵍⴻⵖ, ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⵉ ⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵛⴻⵀⵀⴷⴻⵏⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏⵜ ⴰⵇⴰ ⴷ ⴱⴰⴱⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_37","073_5_37","JHN","5","37","37","ⴱⴰⴱⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ-ⴷⴷ ⵉⵙⵙⴻⴽⴽⴻⵏ, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵅⴰⴼⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ. ⴽⴻⵏⵏⵉⵡ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵥⵔⵉⵎ ⵛⴰ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JN5_38","073_5_38","JHN","5","38","38","ⵓⵛⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵍⴻⴱⴷⴰ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵎⵏⴻⵏ ⵛⴰ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_39","073_5_39","JHN","5","39","39","ⴰⵔⵣⵓⵎ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵓ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵉⵏⵏⵉ ⵉ ⵅⴰⴼⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_40","073_5_40","JHN","5","40","40","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN5_41","073_5_41","JHN","5","41","41","ⵡⴰⵔ ⵇⴻⴱⴱⵍⴻⵖ ⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JN5_42","073_5_42","JHN","5","42","42","ⵎⴰⵛⴰ ⵙⵙⵏⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴱⵓ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_43","073_5_43","JHN","5","43","43","ⵏⴻⵛⵛ ⵓⵙⵉⵖ-ⴷⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵇⴻⴱⴱⵍⴻⵎ ⵛⴰ. ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵜⵇⴻⴱⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_44","073_5_44","JHN","5","44","44","ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴰⵎⵏⴻⵎ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⵄⵓⴵⵉ ⵏ ⵡⴰⵢⴰⵡⵢⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵛⴰ ⵅ ⵓⵄⵓⴵⵉ ⵏ ⵓⵢⴻⵏⵏⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JN5_45","073_5_45","JHN","5","45","45","ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵛⴻⵜⵛⵉⵖ ⵖⴰⵔ ⴱⴰⴱⴰ? ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⵛⴻⵜⵛⴰⵏ ⴷ ⵎⵓⵙⴰ ⵅ ⵡⴻⵏⵏⵉ ⵜⴻⵙⵙⵔⵓⵙⴰⵎ ⴰⵙⵉⵜⴻⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN5_46","073_5_46","JHN","5","46","46","ⵎⵉⵏⵣⵉ ⵎⴻⵄⵍⵉⴽ ⵜⵓⵎⵏⴻⵎ ⵣⵉ ⵎⵓⵙⴰ, ⵉⵍⵉ ⵜⵓⵎⵏⴻⵎ ⴷⴰⵢⵉ ⵄⴰⵡⴻⴷ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵢⵓⵔⴰ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JN5_47","073_5_47","JHN","5","47","47","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ ⵛⴰ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("JN6_1","073_6_1","JHN","6","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵔⵓⵃ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵍⵊⴰⵍⵉⵍ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⵉⴱⵉⵔⵉⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_2","073_6_2","JHN","6","2","2","ⵉⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⵉⵏⵣⵉ ⵥⵔⵉⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⵉⴳⴳⴰ ⵉ ⵉⵎⴻⵀⵍⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JN6_3","073_6_3","JHN","6","3","3","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_4","073_6_4","JHN","6","4","4","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_5","073_6_5","JHN","6","5","5","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ, ⵓⵎⵉ ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ: “ⵎⴰⵏⵉⵙ ⵉ ⵖⴰ ⵏⵙⴻⵖ ⴰⵖⵔⵓⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ ⵉⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN6_6","073_6_6","JHN","6","6","6","ⵉⵏⵏⴰ ⴰⵎⵎⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵊⴰⵔⵔⴻⴱ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⵢⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("JN6_7","073_6_7","JHN","6","7","7","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⴼⵉⵍⵉⴱⴱⵓⵙ: “ⴰⵖⵔⵓⵎ ⵙ ⵎⵉⵜⴰⵢⴻⵏ ⴷⵉⵏⴰⵔ ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⵇⴻⴷⴷⵉ, ⵄⴰⴷ ⵎⴰⵍⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵉⴽⵙⵉ ⵎⵖⵉⵔ ⴷⵔⵓⵙ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_8","073_6_8","JHN","6","8","8","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵏⴷⵔⴰⵡⵓⵙ, ⵓⵎⴰⵙ ⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("JN6_9","073_6_9","JHN","6","9","9","“ⴰⵇⴰ ⴷⴰ ⵉⵊⵊ ⵏ ⵓⵃⴻⵏⵊⵉⵔ ⵖⴰⵔⴻⵙ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⵍⵎⴰⵏ, ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵜⵜⵇⴻⴷⴷⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN6_10","073_6_10","JHN","6","10","10","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵖⵉⵎⴻⵎ ⵉⵡⴷⴰⵏ.” ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⴰⵔⴱⵉⵄ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⵉ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ ⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_11","073_6_11","JHN","6","11","11","ⵢⴰⵙⵓⵄ ⵉⴽⵙⵉ ⵜⵉⵛⵏⵉⴼⵉⵏ, ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴱⴰⵔⴻⴽ ⵉ ⵜⴻⵏⵜ, ⵉⴱⴹⴰ ⵉ-ⵜⴻⵏⵜ ⵅ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ. ⵉⴱⴹⴰ ⵏⴻⵜⵜⴰ ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉⵙⴻⵍⵎⴰⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵏⴻⵛⵜ ⵉⵅⵙⴻⵏ ⴰⴷ ⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_12","073_6_12","JHN","6","12","12","ⵍⴰⵎⵉ ⵊⵊⵉⵡⵏⴻⵏ, ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⵢⵔⵓⵎⴻⵎ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵉⵛⴻⵟⵟⴻⵏ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴹⴻⵢⵢⵉⵄ!” ");
INSERT INTO rift_vpl VALUES ("JN6_13","073_6_13","JHN","6","13","13","ⵢⵔⵓⵏ ⵜⴻⵏ ⵓⵛⴰ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵙⵓⴵⴰⵜⵉⵏ ⵙ ⵉⵍⴻⵇⵇⵡⴰⵣ ⵏⵏⵉ ⵉⵛⴻⵟⵟⴻⵏ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⵛⵛⵉⵏ ⵣⵉ ⵅⴻⵎⵙⴰ ⵏ ⵜⴻⵛⵏⵉⴼⵉⵏ ⵏ ⵉⵎⴻⵏⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JN6_14","073_6_14","JHN","6","14","14","ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵉⵡⴷⴰⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ: “ⵡⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⴰⵏⴰⴱⵉ ⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN6_15","073_6_15","JHN","6","15","15","ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⵢⴰⵙⵓⵄ, ⴱⴻⵍⵍⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴳⴳⴻⵏ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵅⴻⵏⵏⵉ ⵉⵏⵏⴻⵊⵔⴰ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ, ⵃⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_16","073_6_16","JHN","6","16","16","ⵍⴰⵎⵉ ⴷⴷ-ⵜⴻⵡⴹⴰ ⵜⵎⴻⴷⴷⵉⵜ, ⵀⵡⴰⵏ-ⴷⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("JN6_17","073_6_17","JHN","6","17","17","ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⵢⵉⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵇⴻⴹⵄⴻⵏ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ. ⵜⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵓ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵢⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JN6_18","073_6_18","JHN","6","18","18","ⵍⴻⴱⵃⴰⵔ ⵉⵏⵏⴻⵀⵡⴻⵍ ⵅⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵙⴻⵎⵎⵉⴹ ⵜⵓⵖⴰ ⵉⵜⵜⵙⵓⴹ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_19","073_6_19","JHN","6","19","19","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵇⴻⴷⴷⴼⴻⵏ ⵍⵇⴻⴷⴷ ⵏ ⵄⵍⴰⵃⴰⵍ ⵅⴻⵎⵙⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⴰⵍ ⵜⵍⴰⵜⵉⵏ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’, ⵄⵍⴰⵃⴰⵍ ⵅⴻⵎⵙⴰ ⴽⵉⵍⵓⵎⵉⵜⵔ, ⵥⵔⵉⵏ ⵢⴰⵙⵓⵄ ⵉⴳⴳⵓⵔ ⵅ ⵍⴻⴱⵃⴰⵔ, ⵉⵜⵜⵇⴰⵔⵔⴰⴱ-ⴷⴷ ⵖⴰⵔ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴳⴳⵯⴻⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_20","073_6_20","JHN","6","20","20","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_21","073_6_21","JHN","6","21","21","ⵏⵉⵜⵏⵉ ⵅⵙⴻⵏ ⴰⴷ ⵜ ⵙⵙⵇⴻⴱⵍⴻⵏ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵍⴱⴰⵔⵔ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵜⵔⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_22","073_6_22","JHN","6","22","22","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵥⵔⴰ ⵍⵖⴰⵛⵉ ⵏⵏⵉ ⵉⴱⴻⴷⴷ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⵓⵖⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵏⵏⴻⵖⵏⵉⵜ ⵎⵖⵉⵔ ⵉⵛⵜⴻⵏ, ⵜⴻⵏⵏⵉ ⵎⴰⵏⵉ ⴷⴰⵢⴻⵙ ⵓⴷⴼⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵛⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_23","073_6_23","JHN","6","23","23","ⵎⴰⵛⴰ ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵜⵉⴱⵉⵔⵉⵢⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵛⵛⵉⵏ ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⵉⴱⴰⵔⴻⴽ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN6_24","073_6_24","JHN","6","24","24","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⵖⴰⵛⵉ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵄⴰⴷ ⵓⵍⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵢⵉⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵉⵖⴰⵔⵔⵓⴱⴰ-ⵢⴰ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ, ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN6_25","073_6_25","JHN","6","25","25","ⵍⴰⵎⵉ ⵜ ⵓⴼⵉⵏ ⵅ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵎⴻⵍⵎⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⴷⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN6_26","073_6_26","JHN","6","26","26","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵅⴰⴼⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵓⵎⵉ ⵜⴻⵥⵔⵉⵎ ⵍⴻⵄⵍⴰⵎⴰⵜ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⴻⵛⵛⵉⵎ ⴰⵖⵔⵓⵎ ⵓⵛⴰ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN6_27","073_6_27","JHN","6","27","27","ⵡⴰⵔ ⵜⵜⵅⴻⴷⵎⴻⵎ ⵉ ⵎⴰⵛⵛⴰ ⵉⵅⴻⵙⵙⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵎⴰⵛⵛⴰ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵡⵛ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ, ⵉⵙⵙⴰⵔⵙ ⵟⵟⴰⴱⴻⵄ ⵏⵏⴻⵙ ⵅⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN6_28","073_6_28","JHN","6","28","28","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴳⴳ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("JN6_29","073_6_29","JHN","6","29","29","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵜⴰ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_30","073_6_30","JHN","6","30","30","ⵅⴰⵙ ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ ⵅⴻⵏⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵥⴰⵔ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵏⴰⵎⴻⵏ? ⵎⴰⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⵖⴰ ⵜⴻⴳⴳⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("JN6_31","073_6_31","JHN","6","31","31","ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵛⵛⵉⵏ ‘ⵎⴰⵏⵏⴰ’ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: ‘ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵖⵔⵓⵎ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵛⵛⴻⵏ’.” ");
INSERT INTO rift_vpl VALUES ("JN6_32","073_6_32","JHN","6","32","32","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵎⵓⵙⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉⵏ ⴰⵖⵔⵓⵎ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⴱⴰⴱⴰ ⵉⵜⵜⵉⵛ ⴰⵡⴻⵎ ⴰⵖⵔⵓⵎ ⵏ ⵜⵉⴷⴻⵜⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JN6_33","073_6_33","JHN","6","33","33","ⵎⵉⵏⵣⵉ ⴰⵖⵔⵓⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵏⴻⵜⵜⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵉⵜⵜⵉⵛ ⵜⵓⴷⴰⵔⵜ ⵉ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN6_34","073_6_34","JHN","6","34","34","ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴻⵡⵛ ⴰⵏⴻⵖ-ⴷⴷ ⵍⴻⴱⴷⴰ ⴰⵖⵔⵓⵎ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_35","073_6_35","JHN","6","35","35","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴻⵛⵛ ⴷ ⴰⵖⵔⵓⵎ ⵉⴷⴷⴰⵔⴻⵏ. ⵡⴻⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵍⵉⵥ ⵄⴻⵎⵎⴰⵔⵚ, ⵓ ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⴼⵉⴷⵉ ⵄⴰⴷ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("JN6_36","073_6_36","JHN","6","36","36","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵥⵔⵉⵎ ⴰⵢⵉ, ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN6_37","073_6_37","JHN","6","37","37","ⴽⵓⵍ ⵉⵊⵊ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵡⵛ ⴱⴰⴱⴰ, ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ ⵓ ⵡⴻⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵡⴰⵔ ⵜ ⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⴰ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN6_38","073_6_38","JHN","6","38","38","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵀⵡⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵅⵙⴻⵖ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵉⵅⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_39","073_6_39","JHN","6","39","39","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⵅⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵡⴻⴷⴷⴰⵔⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JN6_40","073_6_40","JHN","6","40","40","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⵅⵙ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ, ⴰⵇⴰ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵥⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⴰⵎⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN6_41","073_6_41","JHN","6","41","41","ⵓⴷⴰⵢⴻⵏ ⵛⴻⵜⵛⴰⵏ ⵣⵣⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⴰⵖⵔⵓⵎ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_42","073_6_42","JHN","6","42","42","ⵏⵏⴰⵏ: “ⵎⴰ ⴷ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴱⵓ ⴷ ⵢⴰⵙⵓⵄ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵙⵓⴼ? ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ! ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⵉⵏⵉ ⵡⴻⵔⵢⴰⵣ-ⴰ: ‘ⵏⴻⵛⵛ ⵀⵡⵉⵖ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ?’” ");
INSERT INTO rift_vpl VALUES ("JN6_43","073_6_43","JHN","6","43","43","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⵛⴻⵜⵛⴰⵎ ⵛⴰ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN6_44","073_6_44","JHN","6","44","44","ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵉⵊⴻⴱⴷ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JN6_45","073_6_45","JHN","6","45","45","ⴰⵇⴰ ⵜⵓⵔⴰ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ: ‘ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ!’ ⵙ ⵓⵢⴻⵏⵏⵉ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ ⵣⵉ ⴱⴰⴱⴰ ⵓ ⵉⵍⵎⴻⴷ ⵉ-ⵜ ⵣⵣⴰⵢⴻⵙ, ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_46","073_6_46","JHN","6","46","46","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵥⴰⵔ ⴱⴰⴱⴰ, ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⵉⵜⵜⵡⴰⵍⵉⵏ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN6_47","073_6_47","JHN","6","47","47","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_48","073_6_48","JHN","6","48","48","ⵏⴻⵛⵛ ⴷ ⴰⵖⵔⵓⵎ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_49","073_6_49","JHN","6","49","49","ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵛⵛⵉⵏ ‘ⵎⴰⵏⵏⴰ’ ⴷⵉ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JN6_50","073_6_50","JHN","6","50","50","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵖⵔⵓⵎ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵃⵉⵎⴰ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴻⵛⵛ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ: ");
INSERT INTO rift_vpl VALUES ("JN6_51","073_6_51","JHN","6","51","51","ⵏⴻⵛⵛ ⴷ ⴰⵖⵔⵓⵎ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵉⵛⵛⴰ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ-ⴰ, ⴰⴷ ⵉⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ. ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵏⴻⵛⵛ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN6_52","073_6_52","JHN","6","52","52","ⵓⴷⴰⵢⴻⵏ ⵎⵎⴻⵏⵖⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵢⴻⴳⴳ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵡⵛ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵏⴻⵛⵛ?” ");
INSERT INTO rift_vpl VALUES ("JN6_53","073_6_53","JHN","6","53","53","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⴻⵎ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵙⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴱⵓ ⵜⵓⴷⴰⵔⵜ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN6_54","073_6_54","JHN","6","54","54","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵉⵙⵓⵡ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JN6_55","073_6_55","JHN","6","55","55","ⵎⵉⵏⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⴷ ⵎⴰⵛⵛⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ ⴷ ⵜⵉⵙⵙⵉⵜ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN6_56","073_6_56","JHN","6","56","56","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵉⵙⵓ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ, ⴰⴷ ⴷⴰⵢⵉ ⵉⵇⵇⵉⵎ ⵓ ⵏⴻⵛⵛ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_57","073_6_57","JHN","6","57","57","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴱⴰⴱⴰ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴷⴷⴰⵔⴻⵖ ⵣⵉ ⴱⴰⴱⴰ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵉ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JN6_58","073_6_58","JHN","6","58","58","ⵡⴰ ⴷ ⴰⵖⵔⵓⵎ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⵛⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ‘ⵎⴰⵏⵏⴰ’ ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ-ⴰ, ⴰⴷ ⵉⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_59","073_6_59","JHN","6","59","59","ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⴽⴰⴼⴰⵔⵏⴰⵃⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JN6_60","073_6_60","JHN","6","60","60","ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ: “ⴰⵡⴰⵍ-ⴰ ⵉⵇⵙⴻⵃ. ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵙ ⵉⵙⴻⵍ?” ");
INSERT INTO rift_vpl VALUES ("JN6_61","073_6_61","JHN","6","61","61","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵏ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵛⴻⵜⵛⴰⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⴰⴷ ⵜⴻⵏⵇⴰⵔⴹⴻⵎ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("JN6_62","073_6_62","JHN","6","62","62","ⵉ ⵎⴰⵎⵎⴻⵛ ⵎⴰⵍⴰ ⵜⴻⵥⵔⵉⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵖⴰⵔ ⵎⴰⵏⵉ ⵉⵍⴰ ⵉⴵⴰ ⵇⴱⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("JN6_63","073_6_63","JHN","6","63","63","ⴰⵔⵔⵓⵃ ⴷ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴷⴷⴰⵔⴻⵏ, ⴰⵔⵔⵉⵎⴻⵜ ⵡⴰⵔ ⵜⵏⴻⴼⴼⴻⵄ ⵉ ⵡⴰⵍⵓ. ⴰⵡⴰⵍⴻⵏ ⵉ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⵔⵔⵓⵃ ⴷ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN6_64","073_6_64","JHN","6","64","64","ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ.” ⵎⵉⵏⵣⵉ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵎⴰⵏ ⵢⴻⵏ ⵉⴵⴰⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵓ ⵎⴰⵏ ⵡⴻⵏ ⵜ ⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN6_65","073_6_65","JHN","6","65","65","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵏⵉⵖ ⴰⵡⴻⵎ: ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵣⵉ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN6_66","073_6_66","JHN","6","66","66","ⵣⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵛⴰ ⴳⴳⵓⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN6_67","073_6_67","JHN","6","67","67","ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵜⴻⵏⵄⴰⵛ: “ⵎⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN6_68","073_6_68","JHN","6","68","68","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉ, ⵡⵉ ⵖⴰⵔ ⵉ ⵖⴰ ⵏⵔⴰⵃ? ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JN6_69","073_6_69","JHN","6","69","69","ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⵓⵎⴻⵏ ⵓ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN6_70","073_6_70","JHN","6","70","70","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵉⵅⴹⴰⵔⴻⵏ ⴷ ⵜⴻⵏⵄⴰⵛ? ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴷ ⵛⵛⵉⵟⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN6_71","073_6_71","JHN","6","71","71","ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵓⵏ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵙⴻⵍⵍⴻⵎ. ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("JN7_1","073_7_1","JHN","7","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⴳⴳⵓⵔ ⴷⵉ ⵍⵊⴰⵍⵉⵍ, ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⵓⵢⵓⵔ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_2","073_7_2","JHN","7","2","2","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵍⵄⵉⴷ ⵏ ⵉⵄⵓⵛⵛⵓⵜⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_3","073_7_3","JHN","7","3","3","ⵏⵏⴰⵏ ⴰⵙ ⴰⵢⵜⵎⴰⵙ: “ⴼⴼⴻⵖ ⵙⵙⴰⵏⵉⵜⴰ, ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ ⴰⴷ ⵥⴰⵔⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JN7_4","073_7_4","JHN","7","4","4","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵎⴰⵍⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵙⵙⴻⴹⵀⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⴱⵟⴰⵢⵟⴰⵢ. ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵙⵛⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN7_5","073_7_5","JHN","7","5","5","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⴰⵢⵜⵎⴰⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⵎⵉⵏⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN7_6","073_7_6","JHN","7","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵍⵡⴻⵇⵜ ⵉⵏⵓ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵡⵉⴹ, ⵎⴰⵛⴰ ⵍⵡⴻⵇⵜ ⵏⵡⴻⵎ ⴰⵇⴰ-ⵜⵜ ⵍⴻⴱⴷⴰ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN7_7","073_7_7","JHN","7","7","7","ⴷⴷⵓⵏⵏⵉⵜ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵛⴰⵔⵀ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⵛⴰⵔⵀ ⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵛⴻⵀⵀⴷⴻⵖ ⵅⴰⵙ ⴱⴻⵍⵍⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ ⴷ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_8","073_7_8","JHN","7","8","8","ⵔⵓⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵍⵄⵉⴷ-ⴰ. ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⵖ ⵛⴰ ⵖⴰⵔ ⵍⵄⵉⴷ-ⴰ, ⵎⵉⵏⵣⵉ ⵍⵡⴻⵇⵜ ⵉⵏⵓ ⵄⴰⴷ ⵡⴰⵔ ⵜⴽⴻⵎⵎⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("JN7_9","073_7_9","JHN","7","9","9","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵎⵎⵓ, ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("JN7_10","073_7_10","JHN","7","10","10","ⵎⴰⵛⴰ ⵓⵎⵉ ⴳⴻⵄⵄⴷⴻⵏ ⴰⵢⵜⵎⴰⵙ ⵖⴰⵔ ⵍⵄⵉⴷ, ⵉⵔⵓⵃ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵍⵄⵉⴷ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵎⴰⵛⴰ ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⵉⵏⵏⵓⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JN7_11","073_7_11","JHN","7","11","11","ⵓⴷⴰⵢⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⵙ ⴷⵉ ⵍⵄⵉⴷ, ⵏⵏⴰⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵡⴰⵏⵉⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN7_12","073_7_12","JHN","7","12","12","ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⵖⴰⵛⵉ ⵜⴻⵎⵜⵓⵎⴻⵏ ⵅⴰⵙ. ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⵏⴻⵜⵜⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ” ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵍⵍⴰ, ⵎⴰⵖⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵅ ⵍⵖⴰⵛⵉ!” ");
INSERT INTO rift_vpl VALUES ("JN7_13","073_7_13","JHN","7","13","13","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_14","073_7_14","JHN","7","14","14","ⵎⴰⵛⴰ ⴰⵍⴰⵎⵉ ⵉⵄⴷⵓ ⵡⴻⵣⵢⴻⵏ ⵏ ⵍⵄⵉⴷ, ⵉⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_15","073_7_15","JHN","7","15","15","ⵓⴷⴰⵢⴻⵏ ⴷⴻⵀⵛⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵉⵙⵙⴻⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴰⵎ ⵡⴰⵔ ⵉⵖⵔⵉ ⵛⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN7_16","073_7_16","JHN","7","16","16","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵜⴰⵖⵓⵔⵉ ⵉⵏⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_17","073_7_17","JHN","7","17","17","ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵉⵅⵙ ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰ ⴰⵇⴰ ⵜⴰⵖⵓⵔⵉ-ⵢⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵉⵖ ⴰⵇⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JN7_18","073_7_18","JHN","7","18","18","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵓⵅⴰⵔⵔⴻⵚ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⵄⵓⴵⵉ ⵏ ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵉⵙⵙⴻⴽⴽⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JN7_19","073_7_19","JHN","7","19","19","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵎⵓⵙⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ? ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⵛⴰⵔⵉⵄⴰ? ⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵜⴰⵔⴻⵣⵣⵓⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN7_20","073_7_20","JHN","7","20","20","ⵍⵖⴰⵛⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴷⴰⵢⴻⴽ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ, ⵡⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵛⴻⴽ ⵏⵖⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN7_21","073_7_21","JHN","7","21","21","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴳⴳⵉⵖ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴱⴻⵀⵜⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN7_22","073_7_22","JHN","7","22","22","ⵉ ⵓⵢⴰ ⵎⵓⵙⴰ ⵉⵡⵛⴰ ⴰⵡⴻⵎ-ⴷⴷ ⴰⵅⵜⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏⵣⵉ ⴰⵅⵜⴰⵏ ⵣⵉ ⵎⵓⵙⴰ ⵉ ⵢⴻⴵⴰ, ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⴰⵅⵜⴰⵏ ⵉⴵⴰ ⵣⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵓ ⵅⴻⵏⵏⵉ ⵜⵅⴻⵜⵜⵏⴻⵎ ⵉ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵙⵙⴻⴱⵜ. ");
INSERT INTO rift_vpl VALUES ("JN7_23","073_7_23","JHN","7","23","23","ⵎⴰⵍⴰ ⵉⵇⴱⴻⵍ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵔⴻⵥⵥⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵅⴰⴼⵉ ⵉ ⵖⴰ ⵜⵛⴻⵜⵛⴰⵎ ⵍⴰⵎⵉ ⵙⵙⴳⴻⵏⴼⵉⵖ ⴱⵏⴰⴷⴻⵎ ⵉⴽⵎⴻⵍ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ? ");
INSERT INTO rift_vpl VALUES ("JN7_24","073_7_24","JHN","7","24","24","ⵡⴰⵔ ⵃⴻⴽⴽⵎⴻⵎ ⵅ ⵜⴻⵇⵛⵓⵔⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵃⴻⴽⵎⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN7_25","073_7_25","JHN","7","25","25","ⵏⵏⴰⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰ ⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JN7_26","073_7_26","JHN","7","26","26","ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵡⴰⵔ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵡⴰⵍⵓ. ⴰⴷ ⵜⴰⵖ ⴰⵇⴰ ⵙⵙⵏⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵉⵛⴰⵏ ⴱⴻⵍⵍⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵏⵉⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ? ");
INSERT INTO rift_vpl VALUES ("JN7_27","073_7_27","JHN","7","27","27","ⵎⴰⵛⴰ ⵏⴻⵙⵙⴻⵏ ⵡⴰ, ⵎⴰⵏⵉⵙ ⵏⴻⵜⵜⴰ, ⵎⴰⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⵎⴰⵙⵉⵃ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏⵉⵙ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN7_28","073_7_28","JHN","7","28","28","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵙ ⵊⵊⴻⵀⴷ, ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵢⵉ ⵓ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵏⵉⵙ ⵏⴻⵛⵛ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵜⵉⴷⴻⵜⵜ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN7_29","073_7_29","JHN","7","29","29","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵣⵣⴰⵢⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ-ⴷⴷ ⵉⵙⵙⴻⴽⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN7_30","073_7_30","JHN","7","30","30","ⵅⴻⵏⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⴰⴼⵓⵙ, ⵎⵉⵏⵣⵉ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JN7_31","073_7_31","JHN","7","31","31","ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⵖⴰⵛⵉ ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵏⵏⴰⵏ: “ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍⵎⴰⵙⵉⵃ, ⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴽⵜⴰⵔ ⵣⵉ ⵜⵉⵏⴰ ⵉ ⵉⴳⴳⴰ ⵡⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN7_32","073_7_32","JHN","7","32","32","ⵙⵍⵉⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵉⵜⴻⵎⵜⴻⵏ ⵍⵖⴰⵛⵉ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵙⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_33","073_7_33","JHN","7","33","33","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵇⵇⵉⵎⴻⵖ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵄⴰⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_34","073_7_34","JHN","7","34","34","ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⵎ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵜⵜⵉⴼⴻⵎ, ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵉⵍⵉⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴷⴷ-ⵜⴰⴷⴼⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN7_35","073_7_35","JHN","7","35","35","ⵏⵏⴰⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵎⴰⵏⵉ ⵖⴰ ⵉⵔⴰⵃ ⵏⴻⵜⵜⴰ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴰⴼ. ⵎⴰ ⵅⴻⵏⵏⵉ ⵉⵅⵙ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⴰ ⵏ ⵍⴻⴳⵏⵓⵙ? ⵎⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉ ⵍⴽⵓⴼⴼⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JN7_36","073_7_36","JHN","7","36","36","ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴰⵡⴰⵍ-ⴰ ⵉ ⵉⵏⵏⴰ: ‘ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⵎ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵜⵜᵉⵟⵟⵉⴼⴻⵎ!’, ⵓ ‘ⵎⴰⵏⵉ ⵖⴰ ⵉⵍⵉⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴷⴷ-ⵜⴰⴷⴼⴻⵎ’?” ");
INSERT INTO rift_vpl VALUES ("JN7_37","073_7_37","JHN","7","37","37","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵍⵄⵉⴷ, ⵉⴽⴽⴰⵔ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵉⴼⵓⴷ ⵃⴻⴷ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ, ⴰⴷ ⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("JN7_38","073_7_38","JHN","7","38","38","ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴰⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ: ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵣⵣⵍⴻⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵏ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("JN7_39","073_7_39","JHN","7","39","39","ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵅ ⴰⵔⵔⵓⵃ ⵉ ⵖⴰ ⵇⴻⴱⵍⴻⵏ ⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⴰⵎⵏⴻⵏ. ⵎⵉⵏⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵎⵎⴻⵡⵛ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("JN7_40","073_7_40","JHN","7","40","40","ⴰⵟⵟⴰⵙ ⵣⵉ ⵍⵖⴰⵛⵉ, ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵡⴰⵍ-ⴰ, ⵏⵏⴰⵏ: “ⴷ ⵡⴰ ⴷ ⴰⵏⴰⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ!” ");
INSERT INTO rift_vpl VALUES ("JN7_41","073_7_41","JHN","7","41","41","ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵡⴰ ⴷ ⵍⵎⴰⵙⵉⵃ!”, ⵎⴰⵛⴰ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⵎⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵍⵊⴰⵍⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("JN7_42","073_7_42","JHN","7","42","42","ⵎⴰ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⴷⴰⵡⵓⴷ, ⵣⵉ ⴱⴰⵢⵜ-ⵍⴰⵃⵎ, ⵣⵉ ⴷⵛⴰⵔ ⵏ ⴷⴰⵡⵓⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN7_43","073_7_43","JHN","7","43","43","ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵙⴻⴱⴹⵉ ⵏ ⵍⵖⴰⵛⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN7_44","073_7_44","JHN","7","44","44","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵅⵙⴻⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵙⴰⵔⵙ ⵉⴼⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN7_45","073_7_45","JHN","7","45","45","ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ. ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜ-ⵉ-ⴷⴷ-ⵜⵉⵡⵢⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN7_46","073_7_46","JHN","7","46","46","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ: “ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵙⵙⵉⵡⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⵙⴰⵡⴰⵍ ⵡⴻⵔⵢⴰⵣ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN7_47","073_7_47","JHN","7","47","47","ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ: “ⵎⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵜⵡⴰⵅⴻⴷⵄⴻⵎ ⵣⵣⴰⵢⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JN7_48","073_7_48","JHN","7","48","48","ⵎⴰ ⵅⴻⵏⵏⵉ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵉⵖ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵢⵓⵎⴻⵏ ⵣⵣⴰⵢⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("JN7_49","073_7_49","JHN","7","49","49","ⵎⴰⵛⴰ ⵍⵖⴰⵛⵉ-ⵢⴰ ⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("JN7_50","073_7_50","JHN","7","50","50","ⵏⵉⴽⵓⴷⵉⵎⵓⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ ⵙ ⴵⵉⵍⴻⵜ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("JN7_51","073_7_51","JHN","7","51","51","“ⵎⴰ ⴰⴷ ⵜⴻⵃⴽⴻⵎ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵍⴻⵏ, ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⵉⵏ ⵉⴳⴳⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN7_52","073_7_52","JHN","7","52","52","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴰⴷ ⵜⴰⵖ ⵣⵉ ⵍⵊⴰⵍⵉⵍ? ⴰⵔⵣⵓ, ⵅⵣⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴽⴽ ⵛⴰ ⵣⵉ ⵍⵊⴰⵍⵉⵍ.” ");
INSERT INTO rift_vpl VALUES ("JN7_53","073_7_53","JHN","7","53","53","ⵅⴰⵙ ⵓⵛⴰ ⵉⵔⵓⵃ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵔⵓⵃ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵣⵣⵉⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JN8_1","073_8_1","JHN","8","1","1","... ");
INSERT INTO rift_vpl VALUES ("JN8_2","073_8_2","JHN","8","2","2","ⴷⵉ ⵚⵚⴱⴻⵃ ⵢⵓⵙⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ. ⵅⴻⵏⵏⵉ ⴰⵎ ⵉⵇⵇⵉⵎ, ⵉⴱⴷⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN8_3","073_8_3","JHN","8","3","3","ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵉⵡⵢⴻⵏ ⴰⵙ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵜᵉⵜⵜⴻⴳⴳ ⵣⵣⵉⵏⴰ. ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⵜ ⴷⵉ ⵍⵡⴻⵙⵟ, ");
INSERT INTO rift_vpl VALUES ("JN8_4","073_8_4","JHN","8","4","4","ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ, ⵜⴰⵎⵖⴰⵔⵜ-ⴰ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵜᵉⵜⵜⴻⴳⴳ ⵣⵣⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JN8_5","073_8_5","JHN","8","5","5","ⵉⵡⴻⵚⵚⴰ ⵎⵓⵙⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴰⴷ ⵏⴰⵔⵊⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⵎ ⵜⴰⵏⵉⵜⴰ. ⵎⵉⵏ ⵖⴰ ⵜⵉⵏⵉⴷ ⵛⴻⴽ?” ");
INSERT INTO rift_vpl VALUES ("JN8_6","073_8_6","JHN","8","6","6","ⵏⵏⴰⵏ ⴰⵙ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵊⴰⵔⵔⴱⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵎⵉⵏⵣⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵛⴻⵜⵛⴰⵏ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵢⵓⴹⴰⵔ ⵙⵡⴰⴷⴷⴰⵢ, ⵢⵓⵔⴰ ⵙ ⵓⴹⴰⴹ ⵏⵏⴻⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN8_7","073_8_7","JHN","8","7","7","ⵍⴰⵎⵉ ⵇⵇⵉⵎⴻⵏ ⴰⵎⵎⵓ ⵜ ⵜⵜⴻⵙⵙⴻⵇⵙⴰⵏ, ⵉⴱⴻⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉⴵⴰⵏ ⴱⵍⴰ ⴷⴷⵏⵓⴱ, ⴰⴷ ⵅⴰⵙ ⵉⵏⴹⴰⵔ ⴰⵥⵔⵓ ⴰⵎⴻⵣⵡⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN8_8","073_8_8","JHN","8","8","8","ⵅⴻⵏⵏⵉ ⵢⵓⴹⴰⵔ ⵄⴰⵡⴻⴷ ⵙⵡⴰⴷⴷⴰⵢ ⵓⵛⴰ ⵢⵓⵔⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN8_9","073_8_9","JHN","8","9","9","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴼⴼⵖⴻⵏ ⵉⵊⵊⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵊⵊⵉⵏ ⵜⵜ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN8_10","073_8_10","JHN","8","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵙⵓⵄ ⵉⴽⴽⴰⵔ, ⵉⵏⵏⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ: “ⵎⴰⵏⵉ ⴵⴰⵏ ⵏⵉⵜⵏⵉ? ⵎⴰ ⵡⴰⵔ ⵛⴻⵎ ⵉⵃⴰⴽⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN8_11","073_8_11","JHN","8","11","11","ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴰ: “ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⴰ ⵙⵉⴷⵉ!” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⵎ ⵜⵜⵃⴰⴽⴰⵎⴻⵖ ⵛⴰ. ⵔⵓⵃ, ⵡⴰⵔ ⵜⵜⵄⴰⵡⴰⴷ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⴷⴷⵏⵓⴱ ⵣⵉ ⵙⵙⴰ ⵜⵙⴰⵡⴻⵏⵜ!” ");
INSERT INTO rift_vpl VALUES ("JN8_12","073_8_12","JHN","8","12","12","ⵉⵙⵙⵉⵡⴻⵍ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵉⴳⴳⵓⵔ ⵄⴻⵎⵎⴰⵔⵚ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵢⴰⴼ ⵜⴼⴰⵡⵜ ⵏ ⵜⵓⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN8_13","073_8_13","JHN","8","13","13","ⵏⵏⴰⵏ ⴰⵙ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ: “ⵛⴻⴽ ⵜⵛⴻⵀⵀⴷⴻⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⴷ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN8_14","073_8_14","JHN","8","14","14","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵄⴰⴷ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵛⴻⵀⵀⴷⴻⵖ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵛⵛⵀⴰⴷⴻⵜ ⵉⵏⵓ ⴰⵇⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵖ ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵖ ⵓⵍⴰ ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN8_15","073_8_15","JHN","8","15","15","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵃⴰⴽⴰⵎⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⴷⴷⴰⵜ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵃⴰⴽⴰⵎⴻⵖ ⵓⵍⴰ ⵅ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN8_16","073_8_16","JHN","8","16","16","ⵓ ⵏⴻⵛⵛ, ⵎⴰⵍⴰ ⵃⴰⴽⵎⴻⵖ, ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵃⴽⴰⵎ ⵉⵏⵓ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴱⵓ ⵡⴻⵃⵃⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴷ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN8_17","073_8_17","JHN","8","17","17","ⵜⵓⵔⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵡⴻⵎ, ⴱⴻⵍⵍⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN8_18","073_8_18","JHN","8","18","18","ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ-ⴷⴷ ⵉⵙⵙⴻⴽⴽⴻⵏ, ⵉⵛⵀⴻⴷ ⵅⴰⴼⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN8_19","073_8_19","JHN","8","19","19","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⴱⴰⴱⴰⵛ?” ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵓ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⴱⴰⴱⴰ. ⵎⴻⵄⵍⵉⴽ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵙⵏⴻⵎ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN8_20","073_8_20","JHN","8","20","20","ⵉⵏⵏⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⵉ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵍⴻⵅⵣⴻⵏ ⵏ ⵚⵚⴻⴷⵇⴻⵜ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵡⴰⵔ ⵜ ⵉⵟⵟⵉⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⵉⵏⵣⵉ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵜⵉⵡⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("JN8_21","073_8_21","JHN","8","21","21","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ: “ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ, ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⵎ, ⴰⴷ ⵜⴻⵎⵎⵜⴻⵎ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ. ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN8_22","073_8_22","JHN","8","22","22","ⵓⴷⴰⵢⴻⵏ ⵏⵏⴰⵏ: “ⵎⴰ ⴰⴷ ⵉⵏⴻⵖ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵍⴻⵅⵅⵓ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ‘ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⵎ’?” ");
INSERT INTO rift_vpl VALUES ("JN8_23","073_8_23","JHN","8","23","23","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵙⵡⴰⴷⴷⴰⵢ, ⵏⴻⵛⵛ ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JN8_24","073_8_24","JHN","8","24","24","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ, ⴰⴷ ⵜⴻⵎⵎⵜⴻⵎ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ ⵛⴰ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⴰⴷ ⵜⴻⵎⵎⵜⴻⵎ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN8_25","073_8_25","JHN","8","25","25","ⵓⴷⴰⵢⴻⵏ ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ?” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴱⴷⵉⵖ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ - ");
INSERT INTO rift_vpl VALUES ("JN8_26","073_8_26","JHN","8","26","26","ⵓⵛⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵅⴻⴼ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵅⴰⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵓⵛⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵖ - ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵓⵛⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵙⵍⵉⵖ, ⴰⴷ ⵜ ⵉⵏⵉⵖ ⵉ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN8_27","073_8_27","JHN","8","27","27","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵛⴰ, ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵅ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN8_28","073_8_28","JHN","8","28","28","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ: “ⵅⵎⵉ ⵖⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵜⴼⴻⵀⵎⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵓ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⴻⴳ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN8_29","073_8_29","JHN","8","29","29","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ. ⴱⴰⴱⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵊⵊⵉ ⵛⴰ ⵡⴻⵃⵃⴷⵉ, ⵎⵉⵏⵣⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵍⴻⴱⴷⴰ ⵎⵉⵏ ⵜ ⵢⴰⵔⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN8_30","073_8_30","JHN","8","30","30","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵓⵎⵏⴻⵏ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN8_31","073_8_31","JHN","8","31","31","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵢⵓⵎⵏⴻⵏ: “ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵟⵟⴼⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⴰⴷ ⵜⵉⵍⵉⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JN8_32","073_8_32","JHN","8","32","32","ⵓⵛⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴰⵔⵔ.” ");
INSERT INTO rift_vpl VALUES ("JN8_33","073_8_33","JHN","8","33","33","ⵏⵏⴰⵏ ⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵏⴻⵄⴱⵉⴷ ⵃⴻⴷ ⵙ ⵜⴻⵙⵎⵓⵖⵉ. ⵎⴰⵎⵎⴻⵛ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵉⵏⵉⴷ: ‘ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴰⵔⵔⴻⵎ’?” ");
INSERT INTO rift_vpl VALUES ("JN8_34","073_8_34","JHN","8","34","34","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⵏⵓⴱ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("JN8_35","073_8_35","JHN","8","35","35","ⴰⵎⵙⴻⵅⵅⴰⵔ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵎⵎⵉⵙ ⴰⴷ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JN8_36","073_8_36","JHN","8","36","36","ⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵃⴰⵔⵔ ⵎⵎⵉⵙ, ⴰⴷ ⵜⵉⵍⵉⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵉⵃⵓⵔⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN8_37","073_8_37","JHN","8","37","37","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴻⵣⵣⵓⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ ⵉⵏⵓ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜ ⵜⴼⴻⵀⵎⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN8_38","073_8_38","JHN","8","38","38","ⵏⴻⵛⵛ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵙ ⵎⵉⵏ ⵥⵔⵉⵖ ⵣⵉ ⴱⴰⴱⴰ. ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵣⵉ ⵎⵉⵏ ⵜⴻⵥⵔⵉⵎ ⵣⵉ ⴱⴰⴱⴰⵜⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN8_39","073_8_39","JHN","8","39","39","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⴱⴰⴱⴰⵜⵏⴻⵖ ⴷ ⵉⴱⵔⴰⵀⵉⵎ.” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰⵄⵍⵉⴽ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⵉⵎ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵇⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JN8_40","073_8_40","JHN","8","40","40","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⴰⵔⴻⵣⵣⵓⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⵎ, ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⵉ ⵙⵍⵉⵖ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⵛⴰ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JN8_41","073_8_41","JHN","8","41","41","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ.” ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴷⴷ-ⵏⴻⵅⵍⵉⵇ ⵛⴰ ⵣⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN8_42","073_8_42","JHN","8","42","42","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰⵄⵍⵉⴽ ⴰⵔⴻⴱⴱⵉ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ, ⵉⵍⵉ ⴰⵇⴰ ⵜⴻⵅⵙⴻⵎ ⴰⵢⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴼⴼⵖⴻⵖ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵛⴰ ⵣⴻⴳ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JN8_43","073_8_43","JHN","8","43","43","ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ? ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JN8_44","073_8_44","JHN","8","44","44","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⴱⴰⴱⴰⵜⵡⴻⵎ, ⵉⴱⵍⵉⵙ, ⵓⵛⴰ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵉⵎⴻⵥⵔⴰⵏ ⵏ ⴱⴰⴱⴰⵜⵡⴻⵎ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⴻⵇⵇ ⵉⵡⴷⴰⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵓ ⵡⴰⵔ ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵜⵉⴷⴻⵜⵜ. ⵎⴻⵍⵎⵉ ⵎⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵓⵅⴰⵔⵔⵉⵇ, ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰⵙ ⵏ ⵓⵅⴰⵔⵔⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("JN8_45","073_8_45","JHN","8","45","45","ⵎⴰⵛⴰ ⵓⵎⵉ ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ ⴰⵡⴻⵎ ⵜⵉⴷⴻⵜⵜ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵜⵜⵉⵎⵏⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN8_46","073_8_46","JHN","8","46","46","ⵡⵉ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵇⵏⴻⵄ ⵅ ⴷⴷⵏⵓⴱ? ⵓⵎⵉ ⵇⵇⴰⵔⴻⵖ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜᵉⵜⵜⵉⵎⵏⴻⵎ ⵛⴰ? ");
INSERT INTO rift_vpl VALUES ("JN8_47","073_8_47","JHN","8","47","47","ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵉⵜⵜⴻⵙⵍⴰ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉⵎ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN8_48","073_8_48","JHN","8","48","48","ⵓⴷⴰⵢⴻⵏ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵛⴰⵏ ⵓⵎⵉ ⵏⴻⵏⵏⴰ, ⴰⵇⴰ ⵛⴻⴽ ⵣⵉ ⵙⴰⵎⴰⵔⵢⴰ ⵓ ⴷⴰⵢⴻⴽ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN8_49","073_8_49","JHN","8","49","49","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴻⵇⵇⴰⵔⴻⵖ ⴱⴰⴱⴰ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴰⵎ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JN8_50","073_8_50","JHN","8","50","50","ⵏⴻⵛⵛ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵖ ⵛⴰ ⴰⵄⵓⴵⵉ ⵉⵏⵓ. ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵉ ⵅⴰⵙ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN8_51","073_8_51","JHN","8","51","51","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵍⵎⴻⵡⵜ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN8_52","073_8_52","JHN","8","52","52","ⵏⵏⴰⵏ ⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ: “ⵍⴻⵅⵅⵓ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴷⴰⵢⴻⴽ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ. ⴰⵇⴰ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵎⵎⵓⵜⴻⵏ. ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵉⵇⵇⴰⵙ ⵍⵎⴻⵡⵜ ⵉ ⵍⴻⴱⴷⴰ!’ ");
INSERT INTO rift_vpl VALUES ("JN8_53","073_8_53","JHN","8","53","53","ⵎⴰ ⵛⴻⴽ ⵜⴻⵎⵖⴰⵔⴻⴷ ⵅ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ, ⵓⵍⴰ ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ? ⵎⵉⵏ ⵜⵃⴻⵙⴱⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JN8_54","073_8_54","JHN","8","54","54","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵙⵙⵄⵓⴵⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰⵍⵓ. ⴱⴰⴱⴰ, ⴰⵇⴰ ⵉⵙⵙⵄⵓⴵⴰ ⴰⵢⵉ, ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("JN8_55","073_8_55","JHN","8","55","55","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵜ. ⵎⴰⵍⴰ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵖ!’, ⴰⴷ ⵉⵍⵉⵖ ⵏⴻⵛⵛ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴰⵎ ⴽⴻⵏⵏⵉⵡ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵜ ⵓ ⵜⵜᵉⵟⵟⴼⴻⵖ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN8_56","073_8_56","JHN","8","56","56","ⵊⴻⴷⴷⵉⵜⵡⴻⵎ ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ ⴰⵙⵙ ⵉⵏⵓ, ⵓⵛⴰ ⵉⵥⵔⴰ ⵉ-ⵜ, ⵉⴼⴰⵔⵃ.” ");
INSERT INTO rift_vpl VALUES ("JN8_57","073_8_57","JHN","8","57","57","ⵏⵏⴰⵏ ⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ: “ⵄⴰⴷ ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴱⵓ ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵥⵔⵉⴷ ⵉⴱⵔⴰⵀⵉⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN8_58","073_8_58","JHN","8","58","58","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵇⴱⴻⵍ ⵎⴰ ⵜⵓⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ, ⵜⵓⵖⴰ ⵏⴻⵛⵛ ⴵⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN8_59","073_8_59","JHN","8","59","59","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵉⵥⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵔⴻⵊⵎⴻⵏ. ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⵏⵓⴼⴼⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵎ ⵉⵛⵓⵇ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("JN9_1","073_9_1","JHN","9","1","1","ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵉⴽⴽⴰ, ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵜⵓⵖⴰ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("JN9_2","073_9_2","JHN","9","2","2","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⵡⵉ ⵉⵅⴹⴰⵏ, ⵎⴰ ⴷ ⵡⴰ ⵏⵉⵖ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ ⴷ ⴰⴷⴰⵔⵖⴰⵍ?” ");
INSERT INTO rift_vpl VALUES ("JN9_3","073_9_3","JHN","9","3","3","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⴹⵉ ⵓⵍⴰ ⴷ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⵉⵎⵙⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴹⵀⴰⵔⴻⵏⵜ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN9_4","073_9_4","JHN","9","4","4","ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵅⴻⴷⵎⴻⵖ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵄⴰⴷ ⴷ ⴰⵣⵉⵍ. ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵜⴰⴵⴻⵙⵜ ⵎⴰⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵅⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN9_5","073_9_5","JHN","9","5","5","ⵎⵉⵏⵜⵔⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵏⴻⵛⵛ ⴷ ⵜⴰⴼⴰⵡⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN9_6","073_9_6","JHN","9","6","6","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵎⵎⵓ, ⵉⵙⵙⵓⵙⴻⴼ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⴳⴳⴰ ⴰⴱⴻⴵⴰⵄ ⵣⴻⴳ ⵉⴽⵓⴼⴼⴰⵏ ⵏⵏⵉ ⵓⵛⴰ ⵉⵃⴻⵏⵏⴻⵛ ⵣⵣⴰⵢⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵓⴷⴰⵔⵖⴰⵍ ⵙ ⵓⴱⴻⴵⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("JN9_7","073_9_7","JHN","9","7","7","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ, ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⴷⵉ ⵜⵓⵢⴻⵍⵎⴰⵎⵜ ⵏ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵙⵉⵍⵓⵡⴰⵎ!” ⵉⵔⵓⵃ, ⵉⵙⵙⵉⵔⴷ, ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JN9_8","073_9_8","JHN","9","8","8","ⵊⵊⵉⵔⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜ ⵉⵥⵔⵉⵏ ⵇⴱⴻⵍ ⵉⵜⵜⴻⵜⵜⴰⵔ, ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵉⵜⵜⴻⵜⵜⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("JN9_9","073_9_9","JHN","9","9","9","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷ ⵏⴻⵜⵜⴰ!” ⵏⵏⴰⵏ ⵉⵏⵏⴻⵖⵏⵉ: “ⵍⵍⴰ, ⵎⴰⵛⴰ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⴷⴰⵢⴻⵙ!” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("JN9_10","073_9_10","JHN","9","10","10","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵜⴻⵎⵙⴰⵔ ⵜⵜⵡⴰⵔⴻⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JN9_11","073_9_11","JHN","9","11","11","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴱⵏⴰⴷⴻⵎ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵢⴰⵙⵓⵄ, ⵉⴳⴳⴰ ⴰⴱⴻⴵⴰⵄ, ⵉⵃⴻⵏⵏⴻⵛ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵔⵓⵃ ⵖⴰⵔ ⵜⵓⵢⴻⵍⵎⴰⵎⵜ ⵏ ⵙⵉⵍⵓⵡⴰⵎ, ⵜⴻⵙⵙⵉⵔⴷⴻⴷ!’ ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵖ, ⵙⵙⵉⵔⴷⴻⵖ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵖ ⵜⵜⵡⴰⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN9_12","073_9_12","JHN","9","12","12","ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵏⴻⵜⵜⴰ?” ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN9_13","073_9_13","JHN","9","13","13","ⴰⵡⵢⴻⵏ-ⴷⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⵇⴱⴻⵍ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ⵖⴰⵔ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN9_14","073_9_14","JHN","9","14","14","ⵜⵓⵖⴰ ⴷ ⵙⵙⴻⴱⵜ ⵍⴰⵎⵉ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ ⴰⴱⴻⴵⴰⵄ ⵓ ⵢⴰⵔⵣⴻⵎ ⴰⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN9_15","073_9_15","JHN","9","15","15","ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵄⴰⵡⴻⴷ: “ⵎⴰⵎⵎⴻⵛ ⵜⴷⴻⵡⵍⴻⴷ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵉⴳⴳⴰ ⴰⴱⴻⴵⴰⵄ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵙⵙⵉⵔⴷⴻⵖ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵖ ⵜⵜⵡⴰⵍⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN9_16","073_9_16","JHN","9","16","16","ⵛⴰ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ: “ⴱⵏⴰⴷⴻⵎ-ⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⵛⴰ ⵙⵙⴻⴱⵜ.” ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵎⴰⵎⵎⴻⵛ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⴰⴷ ⵉⴳⴳ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴰⵎ ⵜⵉⵏⴰ?” ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵓⴱⴻⵟⵟⵓ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN9_17","073_9_17","JHN","9","17","17","ⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵉ ⵓⴷⴰⵔⵖⴰⵍ: “ⵎⵉⵏ ⵅⴰⵙ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ, ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ?” ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ-ⵜ ⴷ ⴰⵏⴰⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("JN9_18","073_9_18","JHN","9","18","18","ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵓⵎⵉⵏⴻⵏ ⵛⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵍⴰ, ⴰⵍⴰⵎⵉ ⴷ ⵍⴰⵖⴰⵏ ⵅ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏ ⵡⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵉⵜⵜⵡⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JN9_19","073_9_19","JHN","9","19","19","ⵙⵙⴻⵇⵙⴰⵏ ⵜⴻⵏ: “ⵎⴰ ⵡⴰ ⴷ ⵎⵎⵉⵜⵡⴻⵎ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⴷ ⴰⴷⴰⵔⵖⴰⵍ? ⵉ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵉⵜⵜⵡⴰⵍⴰ ⵍⴻⵅⵅⵓ?” ");
INSERT INTO rift_vpl VALUES ("JN9_20","073_9_20","JHN","9","20","20","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴰ ⴷ ⵎⵎⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("JN9_21","073_9_21","JHN","9","21","21","ⵎⴰⵛⴰ ⵎⴰⵎⵎⴻⵛ ⵉⴳⴳⴰ ⵉⵜⵜⵡⴰⵍⴰ ⵍⴻⵅⵅⵓ, ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ, ⵓ ⵡⵉ ⴷ ⴰⵙ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜ ⵏⴻⵙⵙⵉⵏ ⵛⴰ ⵄⴰⵡⴻⴷ. ⵙⴻⵇⵙⴰⵎ ⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⴷ ⴰⴱⵍⵉⵖ, ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN9_22","073_9_22","JHN","9","22","22","ⵏⵏⴰⵏ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ ⴰⵎⵎⵓ ⵎⵉⵏⵣⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⵎⵄⴰⵀⴰⴷⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴻⵀⴷⴻⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵜ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JN9_23","073_9_23","JHN","9","23","23","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵏⴰⵏ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ: “ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷ ⴰⴱⵍⵉⵖ, ⵙⴻⵇⵙⴰⵎ ⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN9_24","073_9_24","JHN","9","24","24","ⵅⴰⵙ ⵓⵛⴰ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵡⵉⵙⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ ⵅ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ⵏⵏⴰⵏ ⴰⵙ: “ⵙⵄⵓⴵⴰ ⴰⵔⴻⴱⴱⵉ! ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵔⵢⴰⵣ-ⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵏⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("JN9_25","073_9_25","JHN","9","25","25","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴷⵏⵓⴱ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ. ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ, ⴰⵇⴰ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ⵍⴻⵅⵅⵓ ⵜⵜⵡⴰⵍⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("JN9_26","073_9_26","JHN","9","26","26","ⵏⵏⴰⵏ ⴰⵙ ⵄⴰⵡⴻⴷ: “ⵎⵉⵏ ⵣⵣⴰⵢⴻⴽ ⵉⴳⴳⴰ? ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵛ ⵉⴳⴳⴰ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ?” ");
INSERT INTO rift_vpl VALUES ("JN9_27","073_9_27","JHN","9","27","27","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵍⵉⵎ. ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜ ⵜⴻⵙⵍⴻⵎ ⵉ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ? ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("JN9_28","073_9_28","JHN","9","28","28","ⴽⴽⵡⴰⵔⴻⵏ ⵜ, ⵏⵏⴰⵏ: “ⵛⴻⴽ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⴻⵙ! ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵎⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JN9_29","073_9_29","JHN","9","29","29","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ-ⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵛⴰ ⵎⴰⵏⵉⵙ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN9_30","073_9_30","JHN","9","30","30","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵡⴻⵔⵢⴰⵣ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵍⴻⵄⵊⴻⴱ, ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⴰⵏⵉⵙ ⵏⴻⵜⵜⴰ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵢⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JN9_31","073_9_31","JHN","9","31","31","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ ⵖⴰⵔ ⵉⵎⴻⴷⵏⴰⴱ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⵉ-ⵜ ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN9_32","073_9_32","JHN","9","32","32","ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵍⵉ ⵇⴰⵄ, ⴰⵇⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵊⵊⴻⵏ ⵉⵅⵍⴻⵇ-ⴷⴷ ⴷ ⴰⴷⴰⵔⵖⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JN9_33","073_9_33","JHN","9","33","33","ⵎⴻⵄⵍⵉⴽ ⵡⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⵎⴰⵏ ⴰⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN9_34","073_9_34","JHN","9","34","34","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵛⴻⴽ ⵜⵅⴻⵍⵇⴻⴷ-ⴷⴷ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴷⵉ ⴷⴷⵏⵓⴱ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ?” ⵅⴻⵏⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN9_35","073_9_35","JHN","9","35","35","ⵉⵙⵍⴰ ⵢⴰⵙⵓⵄ ⴱⴻⵍⵍⵉ ⵏⴹⴰⵔⴻⵏ ⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵓⵛⴰ ⵓⵎⵉ ⵜ ⵢⵓⴼⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⵓⵎⵏⴻⴷ ⴷⵉ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("JN9_36","073_9_36","JHN","9","36","36","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ, ⴰ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴰⵎⵏⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("JN9_37","073_9_37","JHN","9","37","37","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵥⵔⵉⴷ ⵜ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴽ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵏⴻⵜⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN9_38","073_9_38","JHN","9","38","38","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵓⵎⵏⴻⵖ, ⴰ ⵙⵉⴷⵉ!”. ⵓⵛⴰ ⵉⵄⴻⴱⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN9_39","073_9_39","JHN","9","39","39","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵉ ⵍⵃⵓⴽⵎ ⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ, ⵓ ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵏ ⴰⴷ ⴷⴰⵔⵖⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN9_40","073_9_40","JHN","9","40","40","ⵙⵍⵉⵏ ⵛⴰ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵉ ⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵄⴰⵡⴻⴷ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN9_41","073_9_41","JHN","9","41","41","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰⵄⵍⵉⴽ ⵜⴻⴵⴰⵎ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⴷⴷⵏⵓⴱ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⴻⵇⵇⴰⵔⴻⵎ: ‘ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵍⴰ!’ ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵉⴱⴻⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN10_1","073_10_1","JHN","10","1","1","“ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⴷⴼⴻⵏ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵖⴰⵔ ⵍⴽⵓⵔⵉ ⵏ ⵡⵓⴵⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵎⴰⵏⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵛⴻⴼⴼⴰⵔ ⴷ ⴰⵅⴻⵡⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN10_2","073_10_2","JHN","10","2","2","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⵏ ⵜⵃⵉⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN10_3","073_10_3","JHN","10","3","3","ⴰⵄⴻⵙⵙⴰⵙ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⴰⴷ ⴰⵙ ⵢⴰⵔⵣⴻⵎ ⵉ ⵡⴰⵏⵉⵜⴰ ⵓⵛⴰ ⴰⴷ ⵜⵙⴻⵍ ⵜⵃⵉⵎⴰⵔⵜ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵍⴰⵖⴰ ⵉ ⵡⵓⴵⵉ ⵏⵏⴻⵙ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN10_4","073_10_4","JHN","10","4","4","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵎⴰⵔⵔⴰ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵢⵓⵢⵓⵔ ⵣⵣⴰⵜⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴹⴼⴰⵔⴻⵏ ⵡⵓⴵⵉ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN10_5","073_10_5","JHN","10","5","5","ⵎⴰⵛⴰ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵡⴰⵔ ⵜ ⵜⴹⴻⴼⴼⴰⵔ ⵜⵃⵉⵎⴰⵔⵜ ⵄⴻⵎⵎⴰⵔⵚ, ⵎⴰⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴰⵔⵡⴻⵍ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN10_6","073_10_6","JHN","10","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴰⵎⴻⵜⵜⵉⵍ-ⴰ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵛⴰ ⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JN10_7","073_10_7","JHN","10","7","7","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵏⴻⵛⵛ ⴷ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN10_8","073_10_8","JHN","10","8","8","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵇⴱⴻⵍ ⵉⵏⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ ⴷ ⵉⵅⴻⵡⵡⴰⵏⴻⵏ. ⵎⴰⵛⴰ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵙⵍⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN10_9","073_10_9","JHN","10","9","9","ⵏⴻⵛⵛ ⴷ ⵜⴰⵡⵡⴰⵔⵜ. ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵢⴰⴷⴼⴻⵏ, ⴰⴷ ⵉⴷⴷⴰⵔ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⴷⴻⴼ, ⴰⴷ ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⴰⴷ ⵢⴰⴼ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN10_10","073_10_10","JHN","10","10","10","ⴰⵛⴻⴼⴼⴰⵔ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵎⵖⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵛⴰⵔ, ⴰⴷ ⵉⵏⴻⵖ ⵓ ⴰⴷ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ. ⵏⴻⵛⵛ ⵎⴰⵛⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⴷ ⵓⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("JN10_11","073_10_11","JHN","10","11","11","ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⴰⵚⴻⴱⵃⴰⵏ. ⴰⵎⴻⴽⵙⴰⵡ ⴰⵚⴻⴱⵃⴰⵏ ⵉⵙⵙⵔⵓⵙⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵜⵃⵉⵎⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN10_12","073_10_12","JHN","10","12","12","ⵎⴰⵛⴰ ⴰⵎⵛⴰⵔⴰⵢ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⴰⵎⴻⴽⵙⴰⵡ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴷ ⴱⴰⴱ ⵏ ⵡⵓⴵⵉ, ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵥⴰⵔ ⵓⵛⵛⴻⵏ ⵢⵓⵙⴰ-ⴷⴷ, ⴰⴷ ⵢⴻⵊⵊ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⵓⵛⵛⴻⵏ, ⴰⴷ ⵉⵅⴹⴻⴼ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵣⵣⵓⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JN10_13","073_10_13","JHN","10","13","13","ⴰⵎⵛⴰⵔⴰⵢ ⵢⴰⵔⵡⴻⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵛⴰⵔⴰⵢ, ⵡⴰⵔ ⵜ ⵉⵛⵇⵉ ⵜⴰⵃⵉⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN10_14","073_10_14","JHN","10","14","14","ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⴽⵙⴰⵡ ⴰⵚⴻⴱⵃⴰⵏ. ⵙⵙⵏⴻⵖ ⵓⴵⵉ ⵉⵏⵓ ⵓⵛⴰ ⵓⴵⵉ ⵉⵏⵓ ⵙⵙⵏⴻⵏ ⴰⵢⵉ, ");
INSERT INTO rift_vpl VALUES ("JN10_15","073_10_15","JHN","10","15","15","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵏ ⴱⴰⴱⴰ, ⴰⵎⵎⵓ ⵉ ⵙⵙⵏⴻⵖ ⵏⴻⵛⵛ ⴱⴰⴱⴰ. ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵉ ⵜⵃⵉⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN10_16","073_10_16","JHN","10","16","16","ⵖⴰⵔⵉ ⵄⴰⴷ ⵓⴵⵉ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⵣⵉ ⵍⴽⵓⵍⵉ-ⵢⴰ. ⵉⵛⵓⵡⵡⴰⵔ ⴰⵢⵉ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵙⵙⵎⵓⵏⴻⵖ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵓⵛⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⴽⵙⴰⵡ. ");
INSERT INTO rift_vpl VALUES ("JN10_17","073_10_17","JHN","10","17","17","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵢⵉ ⴱⴰⴱⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⴽⵙⵉⵖ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JN10_18","073_10_18","JHN","10","18","18","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜⵜ ⵉⴽⵙⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⵜⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ. ⵖⴰⵔⵉ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵡⵛⴻⵖ ⵓ ⵖⴰⵔⵉ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⴽⵙⵉⵖ ⵄⴰⵡⴻⴷ. ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ ⵟⵟⴼⴻⵖ ⵜⵜ ⵣⵉ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN10_19","073_10_19","JHN","10","19","19","ⵅⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⵄⴰⵡⴻⴷ ⵓⴱⴻⵟⵟⵓ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JN10_20","073_10_20","JHN","10","20","20","ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵟⴻⵎⵎⴻⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰⵔⴻⵙ ⵜᵉⵜⵜⴻⵙⵍⴰⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN10_21","073_10_21","JHN","10","21","21","ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⴰⵡⴰⵍⴻⵏ-ⴰ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵢⴰⵃ. ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉⵊⵊ ⵏ ⵛⵛⵉⵟⴰⵏ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN10_22","073_10_22","JHN","10","22","22","ⵢⵉⵡⴻⴹ-ⴷⴷ ⵍⵄⵉⴷ ⵏ ⵓⴷⴻⵛⵛⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵜⵓⵖⴰ ⴷ ⵍⵎⴻⵛⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JN10_23","073_10_23","JHN","10","23","23","ⵢⴰⵙⵓⵄ ⵉⴳⴳⵓⵔ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵓⵙⴻⵇⵇⵉⴼ ⴰⴽ-ⴷ ⵓⴽⵓⵍⵡⴰⵔ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN10_24","073_10_24","JHN","10","24","24","ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ ⵡⵓⴷⴰⵢⴻⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵍ ⵎⴻⵍⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵜⴻⵊⵊⴻⴷ ⵏⵓⵢⴻⵍ ⵄⴰⴷ? ⵎⴰⵍⴰ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵉⵏⵉ ⴰⵏⴻⵖ ⵜ ⵙ ⴱⵟⴰⵢⵟⴰⵢ.” ");
INSERT INTO rift_vpl VALUES ("JN10_25","073_10_25","JHN","10","25","25","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ. ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⴳⴳⵉⵖ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰ, ⵛⴻⵀⵀⴷⴻⵏⵜ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("JN10_26","073_10_26","JHN","10","26","26","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⵎ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⴷ ⵓⴵⵉ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JN10_27","073_10_27","JHN","10","27","27","ⵓⴵⵉ ⵉⵏⵓ ⵉⵙⵍⴰ ⵖⴰⵔ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ ⵓ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ-ⴷⴷ ⴹⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN10_28","073_10_28","JHN","10","28","28","ⴰⴷ ⴰⵙⴻⵏ ⵡⵛⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵇⴰⵄ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜⴻⵏ ⵉⵅⴻⵟⵟⴻⴼ ⵣⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JN10_29","073_10_29","JHN","10","29","29","ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵏ ⵉⵡⵛⵉⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⴽⵓⵍⵛⵉ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵉⵅⴹⴻⴼ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN10_30","073_10_30","JHN","10","30","30","ⵏⴻⵛⵛ ⴷ ⴱⴰⴱⴰ ⴷ ⵉⵊⵊⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN10_31","073_10_31","JHN","10","31","31","ⵅⴻⵏⵏⵉ ⴽⵙⵉⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵥⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⴰⵔⴻⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN10_32","073_10_32","JHN","10","32","32","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵡⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵣⵉ ⴱⴰⴱⴰ. ⵉ ⵎⴰⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴰⵔⴻⵊⵎⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN10_33","073_10_33","JHN","10","33","33","ⵏⵏⴰⵏ ⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ: “ⵡⴰⵔ ⵛⴻⴽ ⵏⴰⵔⴻⵊⵊⴻⵎ ⵅ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⴻⴽⴼⴰⵔⴻⴷ ⵓ ⵜⴰⵔⵔⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉ ⵜⴻⴵⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN10_34","073_10_34","JHN","10","34","34","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵡⴰⵔ ⵜⵓⵔⵉ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵡⴻⵎ: ‘ⵏⴻⵛⵛ ⵏⵏⵉⵖ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ’? ");
INSERT INTO rift_vpl VALUES ("JN10_35","073_10_35","JHN","10","35","35","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵙⴻⵎⵎⴰ ⵜⴻⵏ ‘ⵉⵔⴻⴱⴱⵉⵜⴻⵏ’, ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵔⵥⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JN10_36","073_10_36","JHN","10","36","36","ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⴱⴰⴱⴰ ⵓ ⵅ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ: ‘ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴽⴼⴰⵔⴻⴷ!’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ’? ");
INSERT INTO rift_vpl VALUES ("JN10_37","073_10_37","JHN","10","37","37","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴻⴷⴷⵎⴻⵖ ⵛⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴱⴰⴱⴰ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⵜⵉⵎⵏⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN10_38","073_10_38","JHN","10","38","38","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵅⴻⴷⵎⴻⵖ ⵜⴻⵏⵜ, ⴰⵎⵏⴻⵎ ⵅⴻⵏⵏⵉ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⵓⵎⵉⵏⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴱⴰⴱⴰ ⴷⴰⵢⵉ ⵓ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN10_39","073_10_39","JHN","10","39","39","ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⵉⵅⵜⵓⵜⵜⴻⵍ ⴰⵙⴻⵏ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN10_40","073_10_40","JHN","10","40","40","ⵉⵔⵓⵃ ⵖⴰⵔ ⵓⵊⴻⵎⵎⴰⴹ ⵏ ⵉⵖⵣⴰⵔ ⵏ ⵍ’ⵓⵔⴷⵓⵏ, ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵖⴻⵟⵟⴰⵚ ⵢⵓⵃⴰⵏⵏⴰ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN10_41","073_10_41","JHN","10","41","41","ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ, ⵏⵏⴰⵏ: “ⵢⵓⵃⴰⵏⵏⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵏⵏⴰ ⵅ ⵡⴻⵔⵢⴰⵣ-ⴰ ⴷ ⵜⵉⴷⴻⵜⵜ!” ");
INSERT INTO rift_vpl VALUES ("JN10_42","073_10_42","JHN","10","42","42","ⵓⵛⴰ ⵓⵎⵏⴻⵏ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⴷⵉⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JN11_1","073_11_1","JHN","11","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵀⵍⴻⵛ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵣⵉ ⴷⵛⴰⵔ ⵏ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵓⵎⴰⵙ ⵏ ⵎⴰⵔⵢⴰⵎ ⴷ ⵎⴰⵔⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JN11_2","073_11_2","JHN","11","2","2","ⵎⴰⵔⵢⴰⵎ ⵜⴰⵏⵉⵜⴰ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴻⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⴷⴻⵀⵏⴻⵏ ⵢⴰⵙⵓⵄ ⵙ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵎⵉⵔⵔⵓ ⵓ ⵜⴻⵎⵙⴻⵃ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ, ⵓ ⵓⵎⴰⵙ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JN11_3","073_11_3","JHN","11","3","3","ⵙⵙⴻⴽⴽⴻⵏⵜ-ⵉ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵓⵢᵉⵜⵎⴰⵙ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏⵜ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵅⵣⴰⵔ, ⵡⴻⵏⵏⵉ ⵜⴻⵅⵙⴻⴷ, ⴰⵇⴰ ⵉⵀⵍⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("JN11_4","073_11_4","JHN","11","4","4","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵍⴻⵀⵍⴰⵛ-ⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵉ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN11_5","073_11_5","JHN","11","5","5","ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵜⵜⴻⵅⵙ ⵎⴰⵔⵜⴰ ⴷ ⵎⴰⵔⵢⴰⵎ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JN11_6","073_11_6","JHN","11","6","6","ⴰⵍⴰⵎⵉ ⵉⵙⵍⴰ ⴰⵇⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵉⵀⵍⴻⵛ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜ ⵜⵓⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("JN11_7","073_11_7","JHN","11","7","7","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⵏⴰ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN11_8","073_11_8","JHN","11","8","8","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ, ⴷⵔⵓⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⵓⴷⴰⵢⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⵊⵎⴻⵏ, ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⴷⵉⵏⵏⵉ ⵄⴰⵡⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN11_9","073_11_9","JHN","11","9","9","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵙⴰⵄⵄⴻⵜⵉⵏ ⴷⴻⴳ ⵓⵣⵉⵍ? ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵢⵓⵢⵓⵔ ⵙ ⵓⵣⵉⵍ, ⵡⴰⵔ ⵉⵜⵜⵏⴻⵇⵔⵉⴹ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵍⴰ ⵜⴰⴼⴰⵡⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JN11_10","073_11_10","JHN","11","10","10","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⴷ ⵢⵓⵢⵓⵔ ⵙ ⴵⵉⵍⴻⵜ, ⴰⴷ ⵉⵏⵇⴰⵔⴻⴹ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵜⴼⴰⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN11_11","073_11_11","JHN","11","11","11","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵖ ⴰⵇⴰ ⵉⵟⵟⴻⵚ, ⵎⴰⵛⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN11_12","073_11_12","JHN","11","12","12","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⵚ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN11_13","073_11_13","JHN","11","13","13","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵅ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵅ ⴰⵔⵔⴰⵃⴻⵜ ⵏ ⵢⵉⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("JN11_14","073_11_14","JHN","11","14","14","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ ⵙ ⴱⵟⴰⵢⵟⴰⵢ: “ⴰⵇⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JN11_15","073_11_15","JHN","11","15","15","ⵓ ⵏⴻⵛⵛ ⴼⴰⵔⵃⴻⵖ ⴰⵡⴻⵎ ⵓⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⵉⵏ ⴵⵉⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵎⵏⴻⵎ. ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵔⴰⵃⴻⵎ ⴷⵉⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN11_16","073_11_16","JHN","11","16","16","ⵉⵏⵏⴰ ⵜⵓⵎⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵛⵏⵉⵡ’, ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵔⴰⵃ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵎⵎⴻⵜ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN11_17","073_11_17","JHN","11","17","17","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⵢⵓⴼⴰ ⴰⵇⴰ ⵄⴷⵓⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ-ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN11_18","073_11_18","JHN","11","18","18","ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ ⵜⵓⵖⴰ ⵜⵓⴷⴻⵙ ⵓⵔⵛⴰⵍⵉⵎ, ⵄⵍⴰⵃⴰⵍ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’, ⵄⵍⴰⵃⴰⵍ ⵜⵍⴰⵜⴰ ⴽⵉⵍⵓⵎⵉⵜⵔ. ");
INSERT INTO rift_vpl VALUES ("JN11_19","073_11_19","JHN","11","19","19","ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵜⴰ ⴷ ⵎⴰⵔⵢⴰⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵄⴻⵣⵣⴰⵏ ⵅ ⵓⵎⴰⵜⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JN11_20","073_11_20","JHN","11","20","20","ⵍⴰⵎⵉ ⵜⴻⵙⵍⴰ ⵎⴰⵔⵜⴰ, ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵢⵉⵡⴻⴹ-ⴷⴷ, ⵜⴻⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵍⵇⴰ, ⵎⴰⵛⴰ ⵎⴰⵔⵢⴰⵎ ⵜⴻⵇⵇⵉⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN11_21","073_11_21","JHN","11","21","21","ⵜⴻⵏⵏⴰ ⵎⴰⵔⵜⴰ ⵉ ⵢⴰⵙⵓⵄ: “ⴰ ⵙⵉⴷⵉ, ⵎⴻⵄⵍⵉⴽ ⵛⴻⴽ ⵜⵓⵖⴰ ⴷⴰ, ⵉⵍⵉ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ ⵓⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("JN11_22","073_11_22","JHN","11","22","22","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⵙⵙⵏⴻⵖ ⵄⴰⵡⴻⴷ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵜ ⵉⵡⵛ.” ");
INSERT INTO rift_vpl VALUES ("JN11_23","073_11_23","JHN","11","23","23","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵓⵎⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN11_24","073_11_24","JHN","11","24","24","ⵜⴻⵏⵏⴰ ⴰⵙ ⵎⴰⵔⵜⴰ: “ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⴷⵉ ⵜⵏⵓⴽⵔⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN11_25","073_11_25","JHN","11","25","25","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⵜⴰⵏⵓⴽⵔⴰ ⴷ ⵜⵓⴷⴰⵔⵜ. ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⴰⴷ ⵉⴷⴷⴰⵔ, ⵡⴰⵅⵅⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JN11_26","073_11_26","JHN","11","26","26","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵢⵓⵎⴻⵏ ⵣⵣⴰⵢⵉ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵉ ⵍⴻⴱⴷⴰ. ⵎⴰ ⵜⵓⵎⵏⴻⴷ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN11_27","073_11_27","JHN","11","27","27","ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵓⵎⵏⴻⵖ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⴷ ⵜⵜⴰⵙⴻⵏ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN11_28","073_11_28","JHN","11","28","28","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏⵏⴰ ⴰⵢⴰ, ⵜⵔⵓⵃ ⵜⵍⴰⵖⴰ ⵉ ⵓⵍⵜⵎⴰⵙ ⵎⴰⵔⵢⴰⵎ ⵙ ⵍⵃⴻⵙⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⵜⵜⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN11_29","073_11_29","JHN","11","29","29","ⵍⴰⵎⵉ ⵜⴻⵙⵍⴰ ⵎⴰⵔⵢⴰⵎ ⴰⵢⴰ, ⵜⴻⴽⴽⴰⵔ ⵙ ⵜⴰⵣⵍⴰ, ⵜⵔⵓⵃ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN11_30","073_11_30","JHN","11","30","30","ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵛⴰ ⵄⴰⴷ ⵖⴰⵔ ⴷⵛⴰⵔ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ-ⵜ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜ ⵜⴻⵍⵇⴰ ⵎⴰⵔⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JN11_31","073_11_31","JHN","11","31","31","ⵓⵍⴰ ⴷ ⵓⴷⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ, ⵜⵓⵖⴰ ⵜⵜⵄⴻⵣⵣⴰⵏ ⵜⵜ, ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜⵜ ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⴰⵇⴰ ⵎⴰⵔⵢⴰⵎ ⵜⴻⴽⴽⴰⵔ ⵙ ⵜⴰⵣⵍⴰ, ⵜⴻⴼⴼⴻⵖ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ ⵜⵔⵓⵃ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵃⵉⵎⴰ ⴰⴷ ⵜⵔⵓ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN11_32","073_11_32","JHN","11","32","32","ⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵎⴰⵔⵢⴰⵎ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⵜⴻⵥⵔⴰ ⵉ-ⵜ, ⵜⴻⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵎⴻⵄⵍⵉⴽ ⵜⵓⵖⴰ ⵛⴻⴽ ⴷⴰⵏⵉⵜⴰ, ⵉⵍⵉ ⵓⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN11_33","073_11_33","JHN","11","33","33","ⵍⴰⵎⵉ ⵜⵜ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵜᵉⵜⵜⵔⵓ, ⵓⵍⴰ ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽⵉⴷⴻⵙ ⵜⵜⵔⵓⵏ, ⵉⵏⵏⴻⵀⵡⴻⵍ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ, ⵉⵏⵀⴻⵣⵣ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN11_34","073_11_34","JHN","11","34","34","ⵉⵏⵏⴰ: “ⵎⴰⵏⵉ ⵜ ⵜⴻⵙⵙⴰⵔⵙⴻⵎ?” ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵔⴰⵃ-ⴷⴷ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN11_35","073_11_35","JHN","11","35","35","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏⵜ ⴰⵙ-ⴷⴷ ⵉ ⵢⴰⵙⵓⵄ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN11_36","073_11_36","JHN","11","36","36","ⵓⴷⴰⵢⴻⵏ ⵏⵏⴰⵏ: “ⵅⵣⴰⵔⴻⵎ, ⵎⴻⵛⵃⴰⵍ ⵜ ⵉⵜⵜⴻⵅⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN11_37","073_11_37","JHN","11","37","37","ⵎⴰⵛⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴰ, ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉ ⵓⴷⴰⵔⵖⴰⵍ, ⴰⴷ ⵉⴳⴳ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN11_38","073_11_38","JHN","11","38","38","ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵡⴰⵅⵅⴰⵎ ⵏ ⵡⴻⵏⴹⴻⵍ, ⵉⵏⵏⴻⵀⵡⴻⵍ ⵢⴰⵙⵓⵄ ⴰⵟⵟⴰⵙ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⴰⵅⵅⴰⵎ ⵏ ⵡⴻⵏⴹⴻⵍ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵉⴼⵔⵉ ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵜⵓⵖⴰ ⵜⴻⵎⵎⴰⵔⵙ ⵅ ⵡⴰⴷⴰⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN11_39","073_11_39","JHN","11","39","39","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⴽⵙⵉⵎ ⵜⴰⵚⴹⴰⵔⵜ-ⴰ.” ⵜⴻⵏⵏⴰ ⴰⵙ ⵎⴰⵔⵜⴰ, ⵓⵍⵜⵎⴰⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ: “ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵢⴰⵔⵚⵓⴹ, ⵎⵉⵏⵣⵉ ⵜⴻⵄⴷⵓ ⵅⴰⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN11_40","073_11_40","JHN","11","40","40","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵎ ⵏⵏⵉⵖ, ⵎⴰⵍⴰ ⵜⵓⵎⵏⴻⴷ, ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("JN11_41","073_11_41","JHN","11","41","41","ⴽⴽⵙⵉⵏ ⵜⴰⵚⴹⴰⵔⵜ. ⵅⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵢⴰⵙⵓⵄ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵙⴻⵏⵏⴻⵊ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⵄⴰⴼⴰⴽ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵍⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JN11_42","073_11_42","JHN","11","42","42","ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵍⴻⴱⴷⴰ ⵜᵉⵜⵜⴻⵙⵍⵉⴷ ⵖⴰⵔⵉ, ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵖⴰⵛⵉ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵏⵏⵉⵖ ⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵎⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴰⵢⵉ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN11_43","073_11_43","JHN","11","43","43","ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ: “ⴰⵍⵉⵄⴰⵣⴰⵔ, ⴼⴼⴻⵖ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN11_44","073_11_44","JHN","11","44","44","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⴻⵜⵜⵉⵏ, ⵜⵓⵖⴰ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵛⴰⵔⴼⴻⵏ ⵙ ⵍⴻⵛⴼⴻⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⵓ ⵜⵓⵖⴰ ⵉⵊⵊ ⵓⵎⴻⵏⴷⵉⵍ ⵏ ⵍⴻⵇⵟⴻⵏ ⵉⵜⵜⵡⴰⵛⴰⵔⴼ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴼⴻⵙⵢⴻⵎ ⴰⵙ-ⴷⴷ. ⵊⵊⴻⵎ ⵜ ⴰⴷ ⵉⵔⴰⵃ.” ");
INSERT INTO rift_vpl VALUES ("JN11_45","073_11_45","JHN","11","45","45","ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵎⴰⵔⵢⴰⵎ, ⵓⵛⴰ ⵥⵔⵉⵏ ⵎⵉⵏ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ, ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN11_46","073_11_46","JHN","11","46","46","ⵎⴰⵛⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⵎⵉⵏ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN11_47","073_11_47","JHN","11","47","47","ⵓⵛⴰ ⴳⴳⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ, ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ, ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ-ⴰ ⵉⵜⵜⴻⴳⴳ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JN11_48","073_11_48","JHN","11","48","48","ⵎⴰⵍⴰ ⵏⴻⵊⵊⴰ ⵉ-ⵜ ⴰⵎⵢⴰ, ⵎⴰⵔⵔⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵎⵏⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ, ⴰⴷ ⵣⵣⴰⵢⵏⴻⵖ ⴽⴽⵙⴻⵏ ⴰⵎⵛⴰⵏ ⵏⵏⴻⵖ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵡⴷⴰⵏ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN11_49","073_11_49","JHN","11","49","49","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵇⴰⵢⴰⴼⴰ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵡⴰⵍⵓ, ");
INSERT INTO rift_vpl VALUES ("JN11_50","073_11_50","JHN","11","50","50","ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵏⴻⴼⴼⴻⵄ ⵉ ⵏⴻⵛⵛⵉⵏ ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN11_51","073_11_51","JHN","11","51","51","ⵡⴰⵔ ⵉⵏⵉ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ, ⵜⵓⵖⴰ ⵉⵜⵜⵏⴻⴱⴱⴰ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴰⴷ ⵉⵎⵎⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JN11_52","073_11_52","JHN","11","52","52","ⵡⴰⵔ ⵉⴵⵉ ⵃⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵓⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵎⵓⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN11_53","073_11_53","JHN","11","53","53","ⵣⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵏⵡⴰⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN11_54","073_11_54","JHN","11","54","54","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵉⴳⴳⵓⵔ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵎⴰⵛⴰ ⵉⵔⵓⵃ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵓⴷⴻⵙ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⴼⵔⴰⵢⵉⵎ, ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN11_55","073_11_55","JHN","11","55","55","ⵜⵓⵖⴰ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵄⵍⴰⵢⴻⵏ ⵢⵉⵡⴻⴹ-ⴷⴷ. ⴰⵟⵟⴰⵙ ⵣⵉ ⴷⵛⵓⵔⴰⵜ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵟⴻⵀⵀⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵇⴱⴻⵍ ⵍⵄⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JN11_56","073_11_56","JHN","11","56","56","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵅ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ: “ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ? ⵎⴰ ⵣⴻⵄⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵖⴰⵔ ⵍⵄⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN11_57","073_11_57","JHN","11","57","57","ⵎⴰⵛⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵡⴻⵚⵚⴰⵏ ⴱⴻⵍⵍⵉ, ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵙⴻⵏ ⵎⴰⵏⵉ ⵉⴵⴰ, ⴰⴷ ⵜ ⵉⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵟⵟⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_1","073_12_1","JHN","12","1","1","ⵙⴻⵜⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵇⴱⴻⵍ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⴱⴰⵢⵜ-ⵄⴰⵏⵢⴰ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵢⴰⵙⵓⵄ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_2","073_12_2","JHN","12","2","2","ⴳⴳⵉⵏ ⴰⵙ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⵙⵉ. ⵎⴰⵔⵜⴰ ⵜⵓⵖⴰ ⵜⵙⴻⵅⵅⴰⵔ, ⵓ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵟⵟⴰⴱⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_3","073_12_3","JHN","12","3","3","ⵜⴻⴽⵙⵉ-ⴷⴷ ⵎⴰⵔⵢⴰⵎ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⵣⵣⴻⵛⵜ ⵉ ⵡⴻⴷⵀⴰⵏ ⵣⵉ ⵍⴻⵄⵟⵓⵔ ⵏ ⵚⵚⴻⵏⴱⴻⵍ ⵜⴻⵚⴼⴰ ⵜⵉⵖⵍⴰ, ⵜⴻⴷⵀⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵅⴻⵏⵏⵉ ⵜⴻⵎⵙⴻⵃ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ. ⵜⴰⴷⴷⴰⵔⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_4","073_12_4","JHN","12","4","4","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵢⴰⵀⵓⴷⴰ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("JN12_5","073_12_5","JHN","12","5","5","“ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵎⵎⴻⵏⵣ ⵛⴰ ⵍⴻⴼⵡⴰⵃⴻⵜ-ⴰ ⵏ ⵚⵚⴻⵏⴱⴻⵍ ⵙ ⵜⴻⵍⵜ ⵎⵢⴰ ⵏ ⴷⵉⵏⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⵉⵎⴻⵣⵍⴰⴹ?” ");
INSERT INTO rift_vpl VALUES ("JN12_6","073_12_6","JHN","12","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏⵣⵉ ⵛⵇⴰⵏ ⵜ ⵉⵎⴻⵣⵍⴰⴹ, ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵛⴻⴼⴼⴰⵔ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⵙⴻⵏⴷⵓⵇ, ⵓⵛⴰ ⵢⴰⵔⴱⵓ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵉⵎⵎⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_7","073_12_7","JHN","12","7","7","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ: “ⵊⵊⴻⵎ ⵜⵜ, ⴰⵇⴰ ⵜⵅⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ ⵉ ⵡⴰⵙⵙ ⵏ ⵡⴻⵏⴹⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JN12_8","073_12_8","JHN","12","8","8","ⵎⵉⵏⵣⵉ ⵉⵎⴻⵣⵍⴰⴹ ⴰⵇⴰ ⴰⵜⴻⵏ ⵍⴻⴱⴷⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴽⵉⴷⵡⴻⵎ ⴵⵉⵖ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN12_9","073_12_9","JHN","12","9","9","ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴰⵇⴰ-ⵜ ⴷⵉⵏⵏⵉ. ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵃⴰⵛⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⴰⵙⵓⵄ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵍⵉⵄⴰⵣⴰⵔ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_10","073_12_10","JHN","12","10","10","ⵎⵛⴰⵡⴰⵔⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵖⴻⵏ ⵓⵍⴰ ⴷ ⴰⵍⵉⵄⴰⵣⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("JN12_11","073_12_11","JHN","12","11","11","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵎⵏⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN12_12","073_12_12","JHN","12","12","12","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⵉⵏⵏⵉ ⴷⴷ ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵍⵄⵉⴷ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("JN12_13","073_12_13","JHN","12","13","13","ⴽⵙⵉⵏ ⵉⴼⴻⵜⵡⴰⵏ ⵏ ⵜⵉⵏⵉ ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵍⵇⴰⵏ, ⵍⴰⵖⴰⵏ: “ⵓⵚⴰⵏⵏⴰ! ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵉⵙⵔⴰⵉⵍ!” ");
INSERT INTO rift_vpl VALUES ("JN12_14","073_12_14","JHN","12","14","14","ⵢⵓⴼⴰ ⵢⴰⵙⵓⵄ ⵉⵊⵊ ⵏ ⵡⴻⵙⵏⵓⵙ ⵓⵛⴰ ⵉⵏⵢⴰ ⵅⴰⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("JN12_15","073_12_15","JHN","12","15","15","“ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⵢⴻⴵⵉⵙ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵅⵣⴰⵔ, ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵎ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⵉⵇⵇⵉⵎ ⵅ ⵡⴻⵙⵏⵓⵙ, ⴰⵃⴻⵏⵊⵉⵔ ⵏ ⵜⴻⵖⵢⵓⵍⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN12_16","073_12_16","JHN","12","16","16","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵛⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ. ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰ ⵢⴰⵙⵓⵄ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵄⴻⵇⵍⴻⵏ ⴱⴻⵍⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵔⴰ ⵅⴰⵙ ⵓⵛⴰ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_17","073_12_17","JHN","12","17","17","ⵍⵖⴰⵛⵉ ⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ, ⵜⵓⵖⴰ ⵉⵛⵀⴻⴷ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⴰⵍⵉⵄⴰⵣⴰⵔ ⵣⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵓⵛⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_18","073_12_18","JHN","12","18","18","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉⴼⴼⴻⵖ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵎⵎⴻⵍⵇⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵉⴳⴳⴰ ⵍⴻⵄⵍⴰⵎⴻⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_19","073_12_19","JHN","12","19","19","ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹⴻⵎ ⵖⴰⵔ ⵡⴰⵍⵓ, ⵅⵣⴰⵔⴻⵎ, ⴰⵇⴰ ⵇⴰⵄ ⴷⴷⵓⵏⴻⵛⵜ ⵜⴻⴹⴼⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN12_20","073_12_20","JHN","12","20","20","ⵜⵓⵖⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⴷⵉ ⵍⵄⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JN12_21","073_12_21","JHN","12","21","21","ⵉⵏⴰ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⵢⵜ-ⵚⴰⵢⴷⴰ ⴷⵉ ⵍⵊⴰⵍⵉⵍ. ⵙⵙⴻⵇⵙⴰⵏ ⵜ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⵏⴻⵅⵙ ⴰⴷ ⵏⵥⴰⵔ ⵢⴰⵙⵓⵄ.” ");
INSERT INTO rift_vpl VALUES ("JN12_22","073_12_22","JHN","12","22","22","ⵢⵓⵙⴰ-ⴷⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵉⵏⵏⴰ ⵜⵜ ⵉ ⴰⵏⴷⵔⴰⵡⵓⵙ, ⵓⵛⴰ ⴰⵏⴷⵔⴰⵡⵓⵙ ⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵏⵏⴰⵏ ⵜⵜ ⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN12_23","073_12_23","JHN","12","23","23","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN12_24","073_12_24","JHN","12","24","24","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵡⴹⵉ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵉⵎⵎⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⵇⵉⵎ ⵡⴻⵃⵃⴷⴻⵙ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵍⵖⵉⴵⴻⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN12_25","073_12_25","JHN","12","25","25","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵉⵅⵙⴰⵔ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⴰⵔⵀⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⴰⴷ ⵜⵜ ⵉⵅⴻⵎⵎⴻⵍ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_26","073_12_26","JHN","12","26","26","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵙⴻⵅⵅⴰⵔ ⴰⵢⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴰⵢⵉ ⵉⴹⴼⴰⵔ. ⵎⴰⵏⵉ ⵖⴰ ⵉⵍⵉⵖ ⵏⴻⵛⵛ, ⴷⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵉⵏⵓ. ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⵅⴷⴻⵎ ⴰⵢⵉ, ⴰⴷ ⵜ ⵉⵛⴻⵏⵏⴻⵄ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_27","073_12_27","JHN","12","27","27","ⵍⴻⵅⵅⵓ ⵓⵍ ⵉⵏⵓ ⵉⵏⵏⴻⵀⵡⴻⵍ, ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ? ⴰ ⴱⴰⴱⴰ, ⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⵉ ⵜⵙⴰⵄⵄⴻⵜ-ⴰ? ⵎⴰⵛⴰ ⵅ ⵓⵢⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_28","073_12_28","JHN","12","28","28","ⴰ ⴱⴰⴱⴰ, ⵙⵄⵓⴵⵉ ⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ⵅⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵏⵏⴰ: “ⵙⵄⵓⴵⴻⵖ ⵜ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⵄⵓⴵⴻⵖ ⵄⴰⵡⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN12_29","073_12_29","JHN","12","29","29","ⵍⵖⴰⵛⵉ ⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ ⵉⵙⵍⴰ ⵉ-ⵜⵜ, ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⵡⴰⵊⵊⴰⵊ.” ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⴰⴽⵉⴷⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN12_30","073_12_30","JHN","12","30","30","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵜⵎⵉⵊⵊⴰ-ⵢⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN12_31","073_12_31","JHN","12","31","31","ⵍⴻⵅⵅⵓ ⴰⴷ ⵢⵉⵍⵉ ⵍⵃⵓⴽⵎ ⵅ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵍⴻⵅⵅⵓ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_32","073_12_32","JHN","12","32","32","ⵓ ⵏⴻⵛⵛ, ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵊⴻⴱⴷⴻⵖ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN12_33","073_12_33","JHN","12","33","33","ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵖⴰⵔ ⵎⴰⵏ ⵍⵎⴻⵡⵜ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN12_34","073_12_34","JHN","12","34","34","ⵍⵖⴰⵛⵉ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ. ⵉ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵛⴻⴽ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ? ⵎⵉⵏ ⵉⵄⵏⴰ ⵎⵎⵉⵙ-ⴰ ⵏ ⴱⵏⴰⴷⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN12_35","073_12_35","JHN","12","35","35","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵜⴰⴼⴰⵡⵜ ⴰⴷ ⵜⵉⵍⵉ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵄⴰⴷ. ⵓⵢⵓⵔⴻⵎ, ⵍⴰⵎⵉ ⵖⴰⵔⵡⴻⵎ ⵜⴰⴼⴰⵡⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜᵉⵟⵟⴻⴼ ⵜⴰⴵⴻⵙⵜ. ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏⵉ ⵉⴳⴳⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("JN12_36","073_12_36","JHN","12","36","36","ⴰⵎⵏⴻⵎ ⴷⵉ ⵜⴼⴰⵡⵜ ⵎⴰⵃⴻⵏⴷ ⵜⴰⴼⴰⵡⵜ ⵄⴰⴷ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔⵡⴻⵎ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴰⵔⵡⴰ ⵏ ⵜⴼⴰⵡⵜ.” ⴰⵎⵎⵓ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵢⴰⵙⵓⵄ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵓⵛⴰ ⵉⵏⵏⵓⴼⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_37","073_12_37","JHN","12","37","37","ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ-ⴰ ⵣⵣⴰⵜⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵓⵎⵉⵏⴻⵏ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("JN12_38","073_12_38","JHN","12","38","38","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ ⵉ ⵉⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⵡⵉ ⵢⵓⵎⵏⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵖ ⵓ ⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ?” ");
INSERT INTO rift_vpl VALUES ("JN12_39","073_12_39","JHN","12","39","39","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵎⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵛⴰⵄⵢⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: ");
INSERT INTO rift_vpl VALUES ("JN12_40","073_12_40","JHN","12","40","40","“ⵏⵉⵜⵏⵉ ⵙⵙⴷⴰⵔⵖⵍⴻⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵙⵙⴻⵇⵙⴻⵃⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜᵉⵜⵡⵉⵍⵉⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ, ⴰⴷ ⵜⵓⴱⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴳⴻⵏⴼⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN12_41","073_12_41","JHN","12","41","41","ⵉⵏⵏⴰ ⵉⵛⴰⵄⵢⴰ ⴰⵎⵎⵓ, ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("JN12_42","073_12_42","JHN","12","42","42","ⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵛⴻⵀⴷⴻⵏ ⵛⴰ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JN12_43","073_12_43","JHN","12","43","43","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⵄⵓⴵⵉ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵅ ⵓⵄⵓⴵⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN12_44","073_12_44","JHN","12","44","44","ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵉⵍⴰⵖⴰ, ⵉⵏⵏⴰ: “ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵜⵜⵉⵎⴻⵏ ⵛⴰ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_45","073_12_45","JHN","12","45","45","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵥⵔⵉⵏ, ⵉⵥⵔⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN12_46","073_12_46","JHN","12","46","46","ⵏⴻⵛⵛ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⴷⵉ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("JN12_47","073_12_47","JHN","12","47","47","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵙⵍⴰ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜᵉⵟⵟⴻⴼ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵙ ⵃⴻⴽⴽⵎⴻⵖ ⵛⴰ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵖ ⵅ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵡⵛⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN12_48","073_12_48","JHN","12","48","48","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵇⴱⵉⵍ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ, ⵖⴰⵔⴻⵙ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ: ⴰⵡⴰⵍ ⵉ ⵏⵏⵉⵖ, ⴰⴷ ⵅⴰⵙ ⵉⵃⴽⴻⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JN12_49","073_12_49","JHN","12","49","49","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵛⴰ ⵣⵉ ⵖⴰⵔⵉ, ⵎⴰⵛⴰ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ ⵉⵡⵛⴰ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵅ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ ⴷ ⵎⵉⵏ ⵅⴻⴼ ⵖⴰ ⵙⵙⵉⵡⵍⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("JN12_50","073_12_50","JHN","12","50","50","ⵓ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ⵙ ⵓⵢⴰ, ⵎⵉⵏ ⵙⵙⴰⵡⴰⵍⴻⵖ, ⵙⵙⴰⵡⴰⵍⴻⵖ ⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN13_1","073_13_1","JHN","13","1","1","ⵇⴱⴻⵍ ⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴰⵇⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏⵏⴻⵙ ⵜⵉⵡⴻⴹ-ⴷⴷ ⴱⴻⵍⵍⵉ ⴰⴷ ⵉⴼⴼⴻⵖ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵖⴰⵔ ⴱⴰⴱⴰⵙ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜⴻⵏ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("JN13_2","073_13_2","JHN","13","2","2","ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ, ⵓⵎⵉ ⵉⵄⴰⵔⵏ ⵛⵛⵉⵟⴰⵏ ⵓⵍ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵓⵏ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⵙⴻⵍⵍⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JN13_3","073_13_3","JHN","13","3","3","ⵉⴽⴽⴰⵔ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵅ ⵓⵎⴻⵏⵙⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴱⴰⴱⴰⵙ ⵉⵡⵛⴰ ⴰⵙ ⴽⵓⵍⵛⵉ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⴱⴻⵍⵍⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉ ⵖⴰ ⵉⵔⴰⵃ, ");
INSERT INTO rift_vpl VALUES ("JN13_4","073_13_4","JHN","13","4","4","ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵓⵎⴻⵏⴷⵉⵍ ⵓⵛⴰ ⵉⴱⵢⴻⵙ ⵉ-ⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN13_5","073_13_5","JHN","13","5","5","ⵉⴼⴰⵔⵔⴻⵖ ⴰⵎⴰⵏ ⴷⵉ ⵜⴱⴰⵏⵢⵓⵜ ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵙⵙⵉⵔⵉⴷ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵉⵎⴻⵙⵙⴻⵃ ⴰⵙⴻⵏ ⵙ ⵓⵎⴻⵏⴷⵉⵍ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⴱⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN13_6","073_13_6","JHN","13","6","6","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ?” ");
INSERT INTO rift_vpl VALUES ("JN13_7","073_13_7","JHN","13","7","7","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎⴻⴷ ⵛⴰ ⵍⴻⵅⵅⵓ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵖ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴼⴻⵀⵎⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN13_8","073_13_8","JHN","13","8","8","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ: “ⵇⴰⵄ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷⴻⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ.” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⵙⵙⵉⵔⴷⴻⵖ, ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜᵉⵜⵜⵉⵍⵉ ⴱⵓ ⵜⴰⵙⵖⴰⵔⵜ ⴰⴽⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN13_9","073_13_9","JHN","13","9","9","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ: “ⴰ ⵙⵉⴷⵉ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵔⵉⴷ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴷ ⵓⵣⴻⴵⵉⴼ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN13_10","073_13_10","JHN","13","10","10","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵉⵔⴷⴻⵏ ⵇⴰⵄ ⴷⵉ ⵜⴱⴰⵏⵢⵓⵜ, ⵡⴰⵔ ⵉⵃⴷⵉⵊ ⵎⵖⵉⵔ ⴰⴷ ⵜⵜⵡⴰⵙⵉⵔⴷⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵎⵉⵏⵣⵉ ⵄⴰⴷ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵣⴷⵉⴳⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN13_11","073_13_11","JHN","13","11","11","ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⵡⵉ ⵜ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵏⴰ: “ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⴻⵣⴷⴰⴳ.” ");
INSERT INTO rift_vpl VALUES ("JN13_12","073_13_12","JHN","13","12","12","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵙⵙⵉⵔⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ, ⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ, ⵅⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵜⴼⴻⵀⵎⴻⵎ ⵎⵉⵏ ⴷⴰⵢⵡⴻⵎ ⴳⴳⵉⵖ? ");
INSERT INTO rift_vpl VALUES ("JN13_13","073_13_13","JHN","13","13","13","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵍⴰⵖⴰⵎ ⴰⵢⵉ ‘ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵏⴻⵖ!’ ⴷ ‘ⵙⵉⴷⵉⵜⵏⴻⵖ!’, ⵓⵛⴰ ⵜⵉⴷⴻⵜⵜ ⵉ ⵜⴻⵏⵏⴰⵎ, ⵎⵉⵏⵣⵉ ⵡⴰ ⴷ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JN13_14","073_13_14","JHN","13","14","14","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⴷ ⵙⵉⴷⵉ ⵏⵡⴻⵎ ⴷ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏⵡⴻⵎ, ⵓⵛⴰ ⵙⵙⵉⵔⴷⴻⵖ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵀⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵍⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵉⵔⴷⴻⵎ ⵉⴹⴰⵔⴻⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ! ");
INSERT INTO rift_vpl VALUES ("JN13_15","073_13_15","JHN","13","15","15","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵣⴻⵄⵎⴰ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⴰⵎⴻⴷⵢⴰ-ⵢⴰ, ⵃⵉⵎⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵖ ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN13_16","073_13_16","JHN","13","16","16","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵡⴻⵏⵏⵉ ⵢⵓⵄⵍⴰⵏ ⵅ ⵙⵉⴷⴻⵙ, ⵓⵍⴰ ⴷ ⴰⵔⴻⵇⵇⴰⵙ ⵢⵓⵄⵍⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN13_17","073_13_17","JHN","13","17","17","ⵎⴰⵍⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴰⴷ ⵜⵉⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵎ ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⵎ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JN13_18","073_13_18","JHN","13","18","18","ⵡⴰⵔ ⵜ ⵇⵇⴰⵔⴻⵖ ⵛⴰ ⵅⴰⵡⴻⵎ ⵎⴰⵔⵔⴰ, ⵎⴰⵖⴰⵔ ⵙⵙⵏⴻⵖ ⵉⵏⵏⵉ ⵉ ⵅⴹⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ ⴰⴽⵉⴷⵉ, ⴰⵇⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵅⴰⴼⵉ ⴰⵏⵉⵔⵣ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("JN13_19","073_13_19","JHN","13","19","19","ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵡⴻⵎ ⵜ ⵉⵏⵉⵖ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵎⵙⴰⵔ, ⵃⵉⵎⴰ, ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔ, ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JN13_20","073_13_20","JHN","13","20","20","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ, ⴰⴷ ⴰⵢⵉ ⵉⵇⴱⴻⵍ, ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵇⴻⴱⵍⴻⵏ, ⴰⴷ ⵉⵇⴱⴻⵍ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN13_21","073_13_21","JHN","13","21","21","ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴻⵀⵡⴻⵍ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⵉⵛⵀⴻⴷ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴷⴰⵢⵉ ⵉⵖⴷⴻⵔ!” ");
INSERT INTO rift_vpl VALUES ("JN13_22","073_13_22","JHN","13","22","22","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵅⵣⴰⵔⴻⵏ ⵖⴰⵔ ⵡⴰⵢⴰⵡⵢⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴷⵉ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("JN13_23","073_13_23","JHN","13","23","23","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵢⴰⵙⵓⵄ, ⵜⵓⵖⴰ ⵉⵙⴻⵏⵏⴻⴷ ⵖⴰⵔ ⵡⴻⵃⵙⵉⵏ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN13_24","073_13_24","JHN","13","24","24","ⵉⵙⵙⵛⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵖⴰⵔⴻⵙ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⵙⵙⴻⵇⵙⴰ ⵎⵉⵏ ⵉⵄⵏⴰ ⵡⴻⵏⵏⵉ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("JN13_25","073_13_25","JHN","13","25","25","ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⵉ ⵢⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵜⵜⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵎⵉⵏ ⵉⵄⵏⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN13_26","073_13_26","JHN","13","26","26","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⴷ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵙⵙⵉⵙⵏⴻⵖ ⴰⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ, ⴰⴷ ⴰⵙ ⵜ ⵡⵛⴻⵖ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵙⵙⵉⵙⴻⵏ ⴰⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵉⵡⵛⴰ ⴰⵙ ⵜ-ⵉ-ⴷⴷ ⵉ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵛⵉⵎⵄⵓⵏ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ. ");
INSERT INTO rift_vpl VALUES ("JN13_27","073_13_27","JHN","13","27","27","ⴰⵡⴰⵔⵏⵉ ⵉⵟⵟⴻⴼ ⵓⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵢⵓⴷⴻⴼ ⵉ-ⵜ ⵛⵛⵉⵟⴰⵏ. ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⴷ, ⴻⴳⴳ ⵉ-ⵜ ⴷⴻⵖⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN13_28","073_13_28","JHN","13","28","28","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN13_29","073_13_29","JHN","13","29","29","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⵉ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ, ⵓⵎⵉ ⵢⴰⵀⵓⴷⴰ ⴰⵇⴰ-ⵜ ⵅ ⵙⵙⴻⵏⴷⵓⵇ, ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵢⵓⵎⵓⵔ ⵉ-ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵖ ⵛⴰ ⵎⵉⵏ ⵃⴷⴰⵊⴻⵏ ⵏⵉⵜⵏⵉ ⵉ ⵍⵄⵉⴷ, ⵏⵉⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⵛⴰ ⵉ ⵉⵎⴻⵣⵍⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("JN13_30","073_13_30","JHN","13","30","30","ⵡⴰⵏⵉⵜⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵟⵟⴻⴼ ⴰⵍⴻⵇⵇⵉⵎ ⵏ ⵡⴻⵖⵔⵓⵎ, ⵉⴼⴼⴻⵖ ⴷⴻⵖⵢⴰ. ⵜⵓⵖⴰ ⴷ ⴵⵉⵍⴻⵜ ⵓⵎⵉ ⵉⴼⴼⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN13_31","073_13_31","JHN","13","31","31","ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN13_32","073_13_32","JHN","13","32","32","ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⴷⴰⵢⴻⵙ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⵄⵓⴵ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴰⵢⴻⵙ, ⵡⴰⵀ, ⴰⴷ ⵜ ⵉⵙⵙⵄⵓⴵ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN13_33","073_13_33","JHN","13","33","33","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ, ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵄⴰⴷ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵅⴰⴼⵉ ⵜⴰⵔⵣⵓⵎ, ⵓⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵉⵖ ⵉ ⵡⵓⴷⴰⵢⴻⵏ: ‘ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⵎ!’, ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵏⵉⵖ ⵄⴰⵡⴻⴷ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("JN13_34","073_13_34","JHN","13","34","34","ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵊⴷⵉⴷ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵡⵛⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN13_35","073_13_35","JHN","13","35","35","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ, ⵎⴰⵍⴰ ⴷⵉⵏ ⵖⴰⵔⵡⴻⵎ ⵜⴰⵢⵔⵉ ⵊⴰⵔ ⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN13_36","073_13_36","JHN","13","36","36","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵢⵉ ⵜⴻⴹⴼⴰⵔⴻⴷ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔⵓ ⴰⴷ ⵜⴰⵙⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN13_37","073_13_37","JHN","13","37","37","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴰⵙⴻⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⵍⴻⵅⵅⵓ? ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵉ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("JN13_38","073_13_38","JHN","13","38","38","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵛ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ? ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⵡⴰⵔ ⵉⵙⵇⵓⵇⵓⵄ ⵓⵢⴰⵥⵉⴹ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN14_1","073_14_1","JHN","14","1","1","“ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵉⵏⵏⴻⵀⵡⴻⵍ ⵓⵍ ⵏⵡⴻⵎ. ⴽⴻⵏⵏⵉⵡ ⵜⵓⵎⵏⴻⵎ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵏⴻⵎ ⵄⴰⵡⴻⴷ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JN14_2","073_14_2","JHN","14","2","2","ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵉⵏ. ⵎⴻⵄⵍⵉⴽ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵉⵍⵉ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⵡⴻⵊⴷⴻⵖ ⴰⵎⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN14_3","073_14_3","JHN","14","3","3","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵔⵓⵃⴻⵖ ⵓⵛⴰ ⵙⵙⵡⴻⵊⴷⴻⵖ ⴰⵡⴻⵎ ⴰⵎⵛⴰⵏ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵄⴻⵇⴱⴻⵖ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⴰⵡⵢⴻⵖ ⵖⴰⵔⵉ, ⵃⵉⵎⴰ, ⵎⴰⵏⵉ ⴵⵉⵖ ⵏⴻⵛⵛ, ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JN14_4","073_14_4","JHN","14","4","4","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵓⵛⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⴱⵔⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN14_5","073_14_5","JHN","14","5","5","ⵉⵏⵏⴰ ⴰⵙ ⵜⵓⵎⴰ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ ⵉ ⵎⴰⵎⵎⴻⵛ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⴰⴱⵔⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN14_6","073_14_6","JHN","14","6","6","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⴷ ⴰⴱⵔⵉⴷ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵜⵓⴷⴰⵔⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵖⴰⵔ ⴱⴰⴱⴰ ⵎⵖⵉⵔ ⵣⵣⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JN14_7","073_14_7","JHN","14","7","7","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵢⵉ, ⴰⴷ ⵜⵉⵍⵉ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ. ⵣⵉ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵜ, ⵜⴻⵥⵔⵉⵎ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN14_8","073_14_8","JHN","14","8","8","ⴼⵉⵍⵉⴱⴱⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵙⵛⴻⵏ ⴰⵏⴻⵖ ⴱⴰⴱⴰⵛ, ⵓⵛⴰ ⵉⴽⴼⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN14_9","073_14_9","JHN","14","9","9","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵏⴻⵛⵜ ⵓⵢⴰ ⵏ ⵍⵡⴻⵇⵜ ⵇⴰⵄ ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ, ⵎⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵄⴰⴷ, ⴰ ⴼⵉⵍⵉⴱⴱⵓⵙ? ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵥⵔⵉⵏ, ⵉⵥⵔⴰ ⴱⴰⴱⴰ. ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔⴻⴷ: ‘ⵙⵛⴻⵏ ⴰⵏⴻⵖ ⴱⴰⴱⴰⵛ’? ");
INSERT INTO rift_vpl VALUES ("JN14_10","073_14_10","JHN","14","10","10","ⵎⴰ ⵡⴰⵔ ⵜⵓⵎⵉⵏⴻⴷ ⵛⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⴱⴰⴱⴰ ⴷ ⴱⴰⴱⴰ ⴰⵇⴰ-ⵜ ⴷⴰⵢⵉ? ⴰⵡⴰⵍⴻⵏ ⵉ ⵇⵇⴰⵔⴻⵖ, ⵡⴰⵔ ⵜⴻⵏ ⵇⵇⴰⵔⴻⵖ ⵛⴰ ⵣⵉ ⵖⴰⵔⵉ, ⵎⴰⵛⴰ ⴱⴰⴱⴰ ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵅⴷⴰⵢⴻⵎ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("JN14_11","073_14_11","JHN","14","11","11","ⴰⵎⵏⴻⵎ ⴰⵢⵉ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⴱⴰⴱⴰ ⵓ ⴱⴰⴱⴰ ⴰⵇⴰ-ⵜ ⴷⴰⵢⵉ, ⵓ ⵎⴰⵍⴰ ⵍⵍⴰ, ⴰⵎⵏⴻⵎ ⴰⵢⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JN14_12","073_14_12","JHN","14","12","12","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵢⵓⵎⵏⴻⵏ, ⴰⵇⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⵜⵜⴻⴳⴳⴻⵖ, ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵉⴳⴳ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ, ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN14_13","073_14_13","JHN","14","13","13","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵜ ⴳⴳⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⴱⴰⴱⴰ ⴷⵉ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JN14_14","073_14_14","JHN","14","14","14","ⵎⴰⵍⴰ ⴷ ⴰⵢⵉ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⵜ ⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN14_15","073_14_15","JHN","14","15","15","ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ ⴰⵢⵉ, ⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("JN14_16","073_14_16","JHN","14","16","16","ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵉ ⴱⴰⴱⴰ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵚⵍⴰⵃ ⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ: ");
INSERT INTO rift_vpl VALUES ("JN14_17","073_14_17","JHN","14","17","17","ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⴷⴻⵜⵜ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜ ⵜⴻⵇⴱⴻⵍ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⵡⵉⵍⵉ, ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏ. ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⵉⵎⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵓ ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⴰⵢⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN14_18","073_14_18","JHN","14","18","18","“ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴻⵊⵊⵉⵖ ⵛⴰ ⴷ ⵉⵢⵓⵊⵉⵍⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵡⴰⵔⵏⵉ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JN14_19","073_14_19","JHN","14","19","19","ⴷⴷⵓⵏⴻⵛⵜ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵡⴰⵍⴰⵎ. ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴷⴷⴰⵔⴻⵖ, ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JN14_20","073_14_20","JHN","14","20","20","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⵉ ⴱⴰⴱⴰ, ⴽⴻⵏⵏⵉⵡ ⴷⴰⵢⵉ ⵓ ⵏⴻⵛⵛ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN14_21","073_14_21","JHN","14","21","21","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵉⵟⵟⴻⴼ, ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵓ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ ⴰⴷ ⵜ ⵉⵅⵙ ⵓ ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵅⵙⴻⵖ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN14_22","073_14_22","JHN","14","22","22","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵀⵓⴷⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵙⵅⴰⵔⵉⵢⵓⵟⵉ: “ⴰ ⵙⵉⴷⵉ, ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵉ ⴷⴷⵓⵏⴻⵛⵜ?” ");
INSERT INTO rift_vpl VALUES ("JN14_23","073_14_23","JHN","14","23","23","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵅⵙ ⴰⵢⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵏⵓ ⵓⵛⴰ ⴱⴰⴱⴰ ⴰⴷ ⵜ ⵉⵅⵙ, ⵓⵛⴰ ⵖⴰⵔⴻⵙ ⵉ ⴷⴷ ⵖⴰ ⵏⴰⵙ ⵓ ⵖⴰⵔⴻⵙ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN14_24","073_14_24","JHN","14","24","24","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵡⴰⵔ ⵉⵜⵜᵉⵟⵟⵉⴼ ⵛⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⵓⵛⴰ ⴰⵡⴰⵍ-ⴰ ⵉ ⵜⴻⵙⵍⵉⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵉ ⵖⴰⵔⵉ, ⵎⴰⵛⴰ ⵣⵉ ⴱⴰⴱⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN14_25","073_14_25","JHN","14","25","25","ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵓⵎⵉ ⵏⴻⵛⵛ ⵄⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN14_26","073_14_26","JHN","14","26","26","ⵎⴰⵛⴰ ⵓⵎⵙⴻⵚⵍⴰⵃ, ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵙⵙⴻⴽⴽ ⴱⴰⴱⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⴻⵍⵎⴻⴷ ⴽⵓⵍⵛⵉ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⴼⴻⴽⴽⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JN14_27","073_14_27","JHN","14","27","27","ⵍⴻⵀⵏⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜ ⵊⵊⴻⵖ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵍⴻⵀⵏⴰ ⵉⵏⵓ. ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵜ ⵡⵛⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜᵉⵜⵜⵉⵛ ⴷⴷⵓⵏⴻⵛⵜ. ⵡⴰⵔ ⵜⴻⵊⵊⵉⵎ ⴰⴷ ⵉⵏⵏⴻⵀⵡⴻⵍ ⵓⵍ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN14_28","073_14_28","JHN","14","28","28","ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵄⴰⵡⴻⴷ’. ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ ⴰⵢⵉ, ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰ ⵉⵎⵖⴰⵔ ⵅⴰⴼⵉ! ");
INSERT INTO rift_vpl VALUES ("JN14_29","073_14_29","JHN","14","29","29","ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜⵜ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵢⵉⵍⵉ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ, ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵢⴰ, ⴰⴷ ⵜⴰⵎⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN14_30","073_14_30","JHN","14","30","30","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵉⵍⴻⵖ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⴽⵜⴰⵔ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵡⴰⵍⵓ ⴷⴰⵢⵉ, ");
INSERT INTO rift_vpl VALUES ("JN14_31","073_14_31","JHN","14","31","31","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⴱⴰⴱⴰ ⵓⵛⴰ ⵜⵜⴻⴳⴳⴻⵖ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵡⴻⵚⵚⴰ ⴱⴰⴱⴰ. ⴽⴽⴰⵔⴻⵎ, ⴰⴷ ⵏⵓⵢⵓⵔ ⵙⵙⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN15_1","073_15_1","JHN","15","1","1","“ⵏⴻⵛⵛ ⴷ ⵜⴰⵣⴰⵢⴰⵔⵜ ⵏ ⵜⵉⴷⴻⵜⵜ, ⴱⴰⴱⴰ ⴷ ⴱⴰⴱ ⵏ ⵡⴻⵃⵡⵉⵛ ⵏ ⵜⵣⴰⵢⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN15_2","073_15_2","JHN","15","2","2","ⴽⵓⵍ ⵜⴰⵙⴻⵟⵟⴰ ⴷⴰⵢⵉ ⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵛⴻⵏ ⵍⵖⵉⴵⴻⵜ, ⴰⴷ ⵜⵜ ⵉⴽⴽⴻⵙ, ⵓⵛⴰ ⴽⵓⵍ ⵜⴰⵙⴻⵟⵟⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ, ⴰⴷ ⵜⵜ ⵉⵙⵙⵉⵣⴷⴻⴳ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵏⵉ ⴷⵉ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN15_3","073_15_3","JHN","15","3","3","ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JN15_4","073_15_4","JHN","15","4","4","ⵇⵇⵉⵎⴻⵎ ⴷⴰⵢⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⴷⴰⵢⵡⴻⵎ. ⴰⵎ ⵜⵙⴻⵟⵟⴰ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⵉ ⵍⵖⵉⴵⴻⵜ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⴷⵉ ⵜⵣⴰⵢⴰⵔⵜ, ⴰⵎⵢⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("JN15_5","073_15_5","JHN","15","5","5","ⵏⴻⵛⵛ ⴷ ⵜⴰⵣⴰⵢⴰⵔⵜ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⵉⵙⴻⴹⵡⵉⵏ. ⵡⴻⵏⵏⵉ ⴷⴰⵢⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⵏⴻⵛⵛ ⴷⴰⵢⴻⵙ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵍⵖⵉⴵⴻⵜ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⴱⵍⴰ ⵣⵣⴰⵢⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JN15_6","073_15_6","JHN","15","6","6","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵇⵇⵉⵎ, ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⴰⵎ ⵜⵙⴻⵟⵟⴰ ⵜⵓⵥⴻⵖ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵜ ⵢⴰⵔⵡⴻⵏ, ⴰⴷ ⵜⵜ ⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⴷ ⵢⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN15_7","073_15_7","JHN","15","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴷⴰⵢⵉ ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵇⵇⵉⵎⴻⵏ, ⵜⵜⴰⵔⴻⵎ ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("JN15_8","073_15_8","JHN","15","8","8","ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ ⴱⴰⴱⴰ, ⵅⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵡⵢⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JN15_9","073_15_9","JHN","15","9","9","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴱⴰⴱⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵢⵉ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜⴻⵅⵙⴻⵖ ⴽⴻⵏⵏⵉⵡ. ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵜⴰⵢⵔⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("JN15_10","073_15_10","JHN","15","10","10","ⵎⴰⵍⴰ ⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉⵏⵓ, ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵜⴰⵢⵔⵉ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜᵉⵟⵟⴼⴻⵖ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⴱⴰⴱⴰ ⵓⵛⴰ ⵜⵜⵖⵉⵎⴻⵖ ⴷⵉ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN15_11","073_15_11","JHN","15","11","11","ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵜⵉⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ ⵓⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN15_12","073_15_12","JHN","15","12","12","ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉⵏⵓ ⴷ ⵜⴰⵏⵉⵜⴰ: ⴰⵇⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JN15_13","073_15_13","JHN","15","13","13","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⴰⵢⵔⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵅ ⵜⴰⵏⵉⵜⴰ: ⴱⴻⵍⵍⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵉ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN15_14","073_15_14","JHN","15","14","14","ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵚⵚⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("JN15_15","073_15_15","JHN","15","15","15","ⵡⴰⵔ ⵜⵜⵄⵉⵡⵉⴷⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵙⴻⵎⵎⵉⵖ ‘ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ’, ⵎⵉⵏⵣⵉ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ ⵙⵉⴷⵉⵙ. ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵜⵜⵍⴰⵖⵉⵖ ⴰⵡⴻⵎ ⴷ ‘ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉⵏⵓ!’, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⴻⵛⵏⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵙⵍⵉⵖ ⵣⵉ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN15_16","073_15_16","JHN","15","16","16","ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉ ⴷ ⴰⵢⵉ ⵉⵅⴹⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵏⴻⵛⵛ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵃⵉⵎⴰ ⴰⴷ ⵜⵔⴰⵃⴻⵎ, ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵍⵖⵉⴵⴻⵜ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵣⵉ ⴱⴰⴱⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴰⵡⴻⵎ ⵜ ⵉⵡⵛ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JN15_17","073_15_17","JHN","15","17","17","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵓⵔⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN15_18","073_15_18","JHN","15","18","18","“ⵎⴰⵍⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵛⴰⵔⵀ, ⵙⵏⴻⵎ ⴰⵇⴰ ⵜⵛⴰⵔⵀ ⴰⵢⵉ ⵇⴱⴻⵍ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JN15_19","073_15_19","JHN","15","19","19","ⵎⴰⵍⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵍⵉ ⴰⵇⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵅⵙ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ. ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵉⵅⴹⴰⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵛⴰⵔⵔⴻⵀ ⴷⴷⵓⵏⴻⵛⵜ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JN15_20","073_15_20","JHN","15","20","20","ⵄⴻⵇⵍⴻⵎ ⴰⵡⴰⵍ ⵉ ⴷ ⴰⵡⴻⵎ ⵏⵏⵉⵖ: ‘ⴰⵎⵙⴻⵅⵅⴰⵔ ⵡⴰⵔ ⵢⵓⵄⵍⵉ ⵅ ⵙⵉⴷⵉⵙ!’ ⵎⴰⵍⴰ ⴷⴰⵔⵔⴰⵛⴻⵏ ⴰⵢⵉ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴰⵔⵔⵛⴻⵏ ⵄⴰⵡⴻⴷ. ⵎⴰⵍⴰ ⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵏⵓ, ⴰⴷ ⵟⵟⴼⴻⵏ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN15_21","073_15_21","JHN","15","21","21","ⵎⴰⵛⴰ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN15_22","073_15_22","JHN","15","22","22","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵓ ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵖ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⴷⴷⵏⵓⴱ. ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵙⵎⴰⵃⴻⵜ ⵅ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN15_23","073_15_23","JHN","15","23","23","ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ, ⴰⴷ ⵉⵛⴰⵔⵀ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN15_24","073_15_24","JHN","15","24","24","ⵎⴰⵍⴰ ⵡⴰⵔ ⴳⴳⵉⵖ ⵣⵣⴰⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⵡⴰⵔ ⵜⴻⵏⵜ ⵢⴻⴳⴳⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⴷⴷⵏⵓⴱ. ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵥⵔⵉⵏ ⵜⴻⵏⵜ, ⵛⴰⵔⵀⴻⵏ ⴰⵢⵉ ⵏⴻⵛⵛ ⵓⵍⴰ ⴷ ⴱⴰⴱⴰ. ");
INSERT INTO rift_vpl VALUES ("JN15_25","073_15_25","JHN","15","25","25","ⵙ ⵓⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵉ ⵢⵓⵔⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵙⴻⵏ: ‘ⵛⴰⵔⵀⴻⵏ ⴰⵢⵉ ⵅ ⵡⴰⵍⵓ’. ");
INSERT INTO rift_vpl VALUES ("JN15_26","073_15_26","JHN","15","26","26","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵎⵙⴻⵚⵍⴰⵃ, ⵡⴻⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴷ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵣⵉ ⴱⴰⴱⴰ, ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⴷⴻⵜⵜ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵖⴰⵔ ⴱⴰⴱⴰ, ⵅⴻⵏⵏⵉ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵛⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JN15_27","073_15_27","JHN","15","27","27","ⵓⵛⴰ ⴰⴷ ⵜⵛⴻⵀⴷⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴽⵉⴷⵉ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN16_1","073_16_1","JHN","16","1","1","“ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⴰⵢⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⵏⵇⴰⵔⴹⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN16_2","073_16_2","JHN","16","2","2","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ. ⵉⵡⴰ, ⵜⴰⵙⴰⵄⵄⴻⵜ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵓⵎⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵏⵖⴻⵏ, ⴰⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⵉⵡⵛⴰ ⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JN16_3","073_16_3","JHN","16","3","3","ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴱⴰⴱⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JN16_4","073_16_4","JHN","16","4","4","ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵜⵙⴰⵄⵄⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵄⴻⵇⵍⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵏⵏⵉⵖ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵇⴱⴻⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴰⵢⵉ ⵄⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN16_5","073_16_5","JHN","16","5","5","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵇⵙⵉ: ‘ⵎⴰⵏⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ?’ ");
INSERT INTO rift_vpl VALUES ("JN16_6","073_16_6","JHN","16","6","6","ⵎⴰⵖⴰⵔ ⵎⵉⵏⵣⵉ ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⴰⵛⴹⴰⵏ ⵉⵛⵛⵓⵔ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN16_7","073_16_7","JHN","16","7","7","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ ⵜⵉⴷⴻⵜⵜ: ⵃⵙⴻⵏ ⴰⵡⴻⵎ ⴰⴷ ⵔⴰⵃⴻⵖ, ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵡⴰⵔ ⵔⵓⵃⴻⵖ ⵛⴰ, ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵓⵎⵙⴻⵚⵍⴰⵃ. ⵎⴰⵍⴰ ⵔⵓⵃⴻⵖ, ⴰⴷ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN16_8","073_16_8","JHN","16","8","8","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵡⴰⵏⵉⵜⴰ, ⴰⴷ ⵉⵙⵙⴻⵇⵏⴻⵄ ⴷⴷⵓⵏⴻⵛⵜ ⵅ ⴷⴷⵏⵓⴱ, ⵅ ⵜⵙⴻⴳⴷⴰ ⵓ ⵅ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("JN16_9","073_16_9","JHN","16","9","9","ⵅ ⴷⴷⵏⵓⴱ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵓⵎⵉⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JN16_10","073_16_10","JHN","16","10","10","ⵅ ⵜⵙⴻⴳⴷⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("JN16_11","073_16_11","JHN","16","11","11","ⵓⵛⴰ ⵅ ⵍⵃⵓⴽⵎ, ⵎⵉⵏⵣⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⴰⵙⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("JN16_12","073_16_12","JHN","16","12","12","ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ ⵎⵉⵏ ⴷⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⵏⵉⵖ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("JN16_13","073_16_13","JHN","16","13","13","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⴷⴻⵜⵜ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴷⴻⵀ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴷⴻⵜⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵡⵉⵍ ⵛⴰ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵉⵙⵍⴰ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⵉⵡⴻⵍ, ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵛⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN16_14","073_16_14","JHN","16","14","14","ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵄⵓⴵ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⴽⵙⵉ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵉ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN16_15","073_16_15","JHN","16","15","15","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⴰⴱⴰ, ⴰⵇⴰ-ⵜ ⵉⵏⵓ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵏⵉⵖ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴽⵙⵉ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵉ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵜ ⵉⵙⵙⴰⵔⴳⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("JN16_16","073_16_16","JHN","16","16","16","“ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ, ⵓ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵜⵥⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN16_17","073_16_17","JHN","16","17","17","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵎⴰⵏⴰⵡⵢⴰ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵏⵏⴰ: ‘ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ ⵓ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵜⵥⴰⵔⴻⵎ!’ ⵓ: ‘ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ’?” ");
INSERT INTO rift_vpl VALUES ("JN16_18","073_16_18","JHN","16","18","18","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ: “ⵎⴰⵏⴰⵡⵢⴰ ⵎⵉⵏ ⵉⵇⵇⴰⵔ: ‘ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ’? ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵛⴰ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⴰⵡⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("JN16_19","073_16_19","JHN","16","19","19","ⵉⵙⵙⴻⵏ ⵢⴰⵙⵓⵄ ⵎⵉⵏ ⵅⵙⴻⵏ ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰ ⵜⴻⵎⵎⵙⴻⵇⵙⴰⵎ ⵎⵉⵏⵣⵉ ⵏⵏⵉⵖ: ‘ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵥⴰⵔⵔⴻⵎ ⵄⴰⴷ ⵓ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⵓⵛⴰ ⴰⴷ ⴰⵢⵉ ⵜⵥⴰⵔⴻⵎ’?” ");
INSERT INTO rift_vpl VALUES ("JN16_20","073_16_20","JHN","16","20","20","“ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵔⵓⵎ, ⴰⴷ ⵜⵄⴻⴱⴱⵙⴻⵎ, ⵎⴰⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜⴼⴰⵔⵃ. ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵛⴻⴹⵏⴻⵎ, ⵎⴰⵛⴰ ⴰⵛⴹⴰⵏ ⵏⵡⴻⵎ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN16_21","073_16_21","JHN","16","21","21","ⵜⴰⵎⵖⴰⵔⵜ, ⵅⵎⵉ ⵖⴰ ⵜⴰⵔⵓⵡ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵍⴻⵃⵔⵉⵇ, ⵎⵉⵏⵣⵉ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ. ⵎⴰⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵓⵡ ⵎⵎⵉⵙ, ⵡⴰⵔ ⵜⴼⴻⴽⴽⴰⵔ ⵛⴰ ⵄⴰⴷ ⴷⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵏⴻⵙ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵎⵉⵏⵣⵉ ⵜⴰⵔⵏⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN16_22","073_16_22","JHN","16","22","22","ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⴷⴰⵢⵡⴻⵎ ⴰⵛⴹⴰⵏ ⵍⴻⵅⵅⵓ, ⵎⴰⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JN16_23","073_16_23","JHN","16","23","23","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵛⴰ. ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵣⵉ ⴱⴰⴱⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴰⵡⴻⵎ ⵜ ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("JN16_24","073_16_24","JHN","16","24","24","ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵛⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ⵜⵜⴰⵔⴻⵎ, ⴰⴷ ⵜⴻⴽⵙⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN16_25","073_16_25","JHN","16","25","25","ⵙⵙⵉⵡⵍⴻⵖ ⴰⵡⴻⵎ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵉⵎⴻⴷⵢⴰ, ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⴻⴹ ⵜⵙⴰⵄⵄⴻⵜ ⵉ ⴷⵉ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵉ ⵖⴰ ⵙⵙⵉⵡⵉⵍⴻⵖ ⵄⴰⴷ ⵙ ⵉⵎⴻⵜⵜⵉⵍⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ ⵅ ⴱⴰⴱⴰ ⵙ ⴱⵟⴰⵢⵟⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("JN16_26","073_16_26","JHN","16","26","26","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⵛⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⵛⴰ ⵣⵉ ⴱⴰⴱⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("JN16_27","073_16_27","JHN","16","27","27","ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵜⵜⴻⵅⵙ ⴽⴻⵏⵏⵉⵡ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⵢⵉ ⵓⵛⴰ ⴰⵇⴰ ⵜⵓⵎⵏⴻⵎ ⴰⵇⴰ ⵏⴻⵛⵛ ⵣⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN16_28","073_16_28","JHN","16","28","28","ⴼⴼⵖⴻⵖ-ⴷⴷ ⵣⵉ ⴱⴰⴱⴰ, ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ. ⴰⴷ ⵊⵊⴻⵖ ⵄⴰⵡⴻⴷ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN16_29","073_16_29","JHN","16","29","29","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: “ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵜⴻⵙⵙⴰⵡⴰⵍⴻⴷ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵡⴰⵔ ⵜⴻⵙⵙⵉⵡⵉⵍⴻⴷ ⵛⴰ ⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN16_30","073_16_30","JHN","16","30","30","ⵍⴻⵅⵅⵓ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⵜⴻⵃⴷⵉⵊⴻⴷ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵇⵙⴰ ⵃⴻⴷ. ⵣⵉ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ ⵏⵓⵎⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⴼⴼⵖⴻⴷ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN16_31","073_16_31","JHN","16","31","31","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ: “ⵎⴰ ⵍⴻⵅⵅⵓ ⵜⵓⵎⵏⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JN16_32","073_16_32","JHN","16","32","32","ⴰⴷ ⴷⴷ-ⵜⴰⵡⴻⴹ ⵜⵙⴰⵄⵄⴻⵜ, ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ, ⵉ ⴷⵉ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵎ, ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵟⵟⴻⴼ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵢⵉ ⵜⴻⵊⵊⴻⵎ ⵡⴻⵃⵃⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⴱⵓ ⵡⴻⵃⵃⴷⵉ, ⵎⵉⵏⵣⵉ ⴱⴰⴱⴰ ⴰⵇⴰ-ⵜ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JN16_33","073_16_33","JHN","16","33","33","ⴰⵇⴰ ⵙⵙⵉⵡⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⴷⴰⵢⵉ. ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ, ⵎⴰⵛⴰ ⴳⴳⴻⵎ ⵓⵍ, ⵏⴻⵛⵛ ⴰⵇⴰ ⵖⴻⵍⵍⴱⴻⵖ ⵅ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN17_1","073_17_1","JHN","17","1","1","ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⵏⵏⴰ: “ⴰ ⴱⴰⴱⴰ, ⴰⵇⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵜⵉⵡⴻⴹ-ⴷⴷ. ⵙⵓⵄⵍⴰ ⵎⵎⵉⵛ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵎⵎⵉⵛ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⵓⵄⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("JN17_2","073_17_2","JHN","17","2","2","ⴰⵍⴰⵎⵉ ⴷ ⴰⵙ ⵜⴻⵡⵛⵉⴷ ⵚⵚⵓⵍⵟⴰ ⵅ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⴷ ⴰⵙ ⵜⴻⵡⵛⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("JN17_3","073_17_3","JHN","17","3","3","ⴷ ⵜⴰⵏⵉⵜⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⵏⴻⵏ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JN17_4","073_17_4","JHN","17","4","4","ⵏⴻⵛⵛ ⵙⵙⵓⵄⵍⵉⵖ ⵛⴻⴽ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵏⴻⵛⵛ ⴽⴻⵎⵎⵍⴻⵖ ⵍⵅⴻⴷⵎⴻⵜ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN17_5","073_17_5","JHN","17","5","5","ⵍⴻⵅⵅⵓ, ⵙⵄⵓⴵⵉ ⴰⵢⵉ, ⴰ ⴱⴰⴱⴰ, ⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵙ ⵓⵄⵓⴵⵉ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵉ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_6","073_17_6","JHN","17","6","6","ⵙⴻⵛⵏⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵉ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵏⵏⴻⵛ, ⵜⴻⵡⵛⵉⴷ ⵜⴻⵏ ⵉ ⵏⴻⵛⵛ, ⴰⵇⴰ ⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JN17_7","073_17_7","JHN","17","7","7","ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⴰⵇⴰ-ⵜ ⵣⵣⴰⵢⴻⴽ ⴷⴷ-ⵢⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("JN17_8","073_17_8","JHN","17","8","8","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵇⴻⴱⵍⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵙⵙⵏⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⴼⴼⵖⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⴽ, ⵓⵎⵏⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴰⵢⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JN17_9","073_17_9","JHN","17","9","9","ⵏⴻⵛⵛ ⵜⵜⴰⵔⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴰⵔⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("JN17_10","073_17_10","JHN","17","10","10","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉⵏⵓ ⴰⵇⴰ-ⵜ ⵏⵏⴻⵛ ⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵏⴻⵛ ⴰⵇⴰ-ⵜ ⵉⵏⵓ, ⵓ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵖ ⴷⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_11","073_17_11","JHN","17","11","11","ⵣⵉ ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵄⴰⴷ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ. ⴰ ⴱⴰⴱⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⴹⴰ ⵜⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⵉⵙⴻⵎ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_12","073_17_12","JHN","17","12","12","ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ, ⵃⴹⵉⵖ ⵜⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ. ⵏⴻⵛⵛ ⵄⴻⵙⵙⴻⵖ ⵅ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ. ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ, ⵎⵖⵉⵔ ⵎⵎⵉⵙ ⵏ ⵜⴻⵀⵍⵉⴽⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_13","073_17_13","JHN","17","13","13","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⵓ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ ⵜⴻⴽⵎⴻⵍ ⴷⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_14","073_17_14","JHN","17","14","14","ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵓⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵓⵖⴰ ⵜⵛⴰⵔⵔⴻⵀ ⵉ-ⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⵎ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_15","073_17_15","JHN","17","15","15","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴰⵔⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⴽⵙⵉⴷ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵃⴹⵉⴷ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_16","073_17_16","JHN","17","16","16","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵎ ⵏⴻⵛⵛ ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_17","073_17_17","JHN","17","17","17","ⴰ ⴱⴰⴱⴰ, ⵙⵇⴻⴷⴷⴻⵙ ⵉ-ⵜⴻⵏ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⴰⵡⴰⵍ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_18","073_17_18","JHN","17","18","18","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⵎⵎⵓ ⵉ ⵜⴻⵏ ⵙⵙⴻⴽⴽⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_19","073_17_19","JHN","17","19","19","ⵙⵙⵇⴻⴷⴷⴰⵙⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_20","073_17_20","JHN","17","20","20","ⵡⴰⵔ ⵜⵜⴰⵔⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵉ ⵢⵓⵎⵏⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_21","073_17_21","JHN","17","21","21","ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵊⵊⴻⵏ, ⴰ ⴱⴰⴱⴰ, ⴰⵎ ⵛⴻⴽ ⴷⴰⵢⵉ ⵓ ⵏⴻⵛⵛ ⴷⴰⵢⴻⴽ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵊⵊⴻⵏ ⴷⴰⵢⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵎⴻⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷ ⵛⴻⴽ ⵉ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_22","073_17_22","JHN","17","22","22","ⵏⴻⵛⵛ ⵡⵛⵉⵖ ⴰⵙⴻⵏ ⴰⵄⵓⴵⵉ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴵⴰ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN17_23","073_17_23","JHN","17","23","23","ⵏⴻⵛⵛ ⴷⴰⵢⵙⴻⵏ, ⵛⴻⴽ ⴷⴰⵢⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵖⴰⵔ ⵉⵊⵊⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴻⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴰⵢⵉ-ⴷⴷ ⵓ ⵜⴻⵅⵙⴻⴷ ⵜⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵅⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("JN17_24","073_17_24","JHN","17","24","24","ⴰ ⴱⴰⴱⴰ, ⵅⵙⴻⵖ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ ⴰⴷ ⵉⵍⵉⵏ ⴰⴽⵉⴷⵉ ⵎⴰⵏⵉ ⵎⴰ ⴵⵉⵖ ⵏⴻⵛⵛ, ⵓⵛⴰ ⴰⴷ ⵥⴰⵔⴻⵏ ⴰⵄⵓⴵⵉ ⵉⵏⵓ ⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵅⵙⴻⴷ ⴰⵢⵉ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("JN17_25","073_17_25","JHN","17","25","25","ⴰ ⴱⴰⴱⴰ ⵉⵏⵓ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵇⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵡⴰⵔ ⵛⴻⴽ ⵜⴻⵙⵙⵉⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵛⴻⴽ ⵓ ⵉⵏⴰ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⴻⴽⴽⴻⴷ ⴰⵢⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JN17_26","073_17_26","JHN","17","26","26","ⵏⴻⵛⵛ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵙⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ ⵓ ⴰⴷ ⵜ ⵙⵙⴻⵛⵏⴻⵖ, ⵃⵉⵎⴰ ⵜⴰⵢⵔⵉ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵉⵍⵉ ⴷⴰⵢⵙⴻⵏ ⵓ ⵏⴻⵛⵛ ⴷⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN18_1","073_18_1","JHN","18","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⴰⵢⴰ, ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵥⵡⴰⵏ ⵅ ⵢⴻⵖⵣⴰⵔ ⵏ ⵇⵉⴷⵔⵓⵏ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵃⵡⵉⵛ, ⵢⵓⴷⴻⴼ ⵖⴰⵔⴻⵙ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN18_2","073_18_2","JHN","18","2","2","ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵢⴰⵀⵓⴷⴰ, ⴰⵖⴻⴷⴷⴰⵔ, ⵉⵙⵙⴻⵏ ⴰⵎⵛⴰⵏ ⵏⵏⵉ ⵄⴰⵡⴻⴷ, ⵎⵉⵏⵣⵉ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵙⵙⵎⵓⵏⴰ ⴷⴰⵢⴻⵙ ⴰⵟⵟⴰⵙ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN18_3","073_18_3","JHN","18","3","3","ⵢⵉⵡⵉ-ⴷⴷ ⵢⴰⵀⵓⴷⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⵔⴱⵉⵄⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓⵍⴰ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉⵀⴰ ⵙ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ ⴷ ⵍⴻⵇⵏⴰⴷⴻⵍ ⴷ ⵍⴻⵙⵏⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("JN18_4","073_18_4","JHN","18","4","4","ⵢⴰⵙⵓⵄ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⵉⵏ ⵅⴻⴼ ⵜⴰⵔⴻⵣⵣⵓⵎ?” ");
INSERT INTO rift_vpl VALUES ("JN18_5","073_18_5","JHN","18","5","5","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ: “ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ!” ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴷ ⵏⴻⵛⵛ!” ⵜⵓⵖⴰ ⵢⴰⵀⵓⴷⴰ, ⴰⵖⴻⴷⴷⴰⵔ, ⵉⴱⴻⴷⴷ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN18_6","073_18_6","JHN","18","6","6","ⵍⴰⵎⵉ ⴷ ⴰⵙⴻⵏ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ: “ⴷ ⵏⴻⵛⵛ!”, ⴷⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵓⵛⴰ ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JN18_7","073_18_7","JHN","18","7","7","ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⵢⴰⵙⵓⵄ ⵄⴰⵡⴻⴷ: “ⵎⵉⵏ ⵅⴻⴼ ⵜⴰⵔⴻⵣⵣⵓⵎ?” ⵏⵏⴰⵏ: “ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ!” ");
INSERT INTO rift_vpl VALUES ("JN18_8","073_18_8","JHN","18","8","8","ⵢⴰⵙⵓⵄ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ. ⵎⴰⵍⴰ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵅⴰⴼⵉ, ⵊⵊⴻⵎ ⵉⵏⴰ ⴰⴷ ⵔⴰⵃⴻⵏ!”, ");
INSERT INTO rift_vpl VALUES ("JN18_9","073_18_9","JHN","18","9","9","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⴷ, ⵡⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴻⴷⴷⴰⵔⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ.” ");
INSERT INTO rift_vpl VALUES ("JN18_10","073_18_10","JHN","18","10","10","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⵙⵉⴼ, ⵉⵊⴱⴻⴷ ⵉ-ⵜ-ⵉ-ⴷⴷ, ⵉⵡⵜⴰ ⵣⵣⴰⵢⴻⵙ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵇⴻⵙⵙ ⴰⵙ ⴰⵎⴻⵣⵣⵓⵖ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ. ⵜⵓⵖⴰ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵍⵅⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("JN18_11","073_18_11","JHN","18","11","11","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⴱⵓⵟⵔⵓⵙ: “ⴰⵔⵔ ⵙⵙⵉⴼ ⵖⴰⵔ ⵡⴻⵖⵍⴰⴼ ⵏⵏⴻⵙ, ⵍⴽⴰⵙ ⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⴱⴰⴱⴰ, ⵎⴰ ⵡⴰⵔ ⵜ ⵙⴻⵙⵙⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("JN18_12","073_18_12","JHN","18","12","12","ⵜⴰⵔⴱⵉⵄⵜ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵟⵟⴼⴻⵏ ⵢⴰⵙⵓⵄ, ⵛⴰⵔⴼⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("JN18_13","073_18_13","JHN","18","13","13","ⵏⴻⴷⵀⴻⵏ ⵜ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵖⴰⵔ ⵃⴰⵏⵏⴰⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⴹⴻⴳⴳⵯⴰⵍ ⵏ ⵇⴰⵢⴰⴼⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN18_14","073_18_14","JHN","18","14","14","ⵇⴰⵢⴰⴼⴰ ⴷ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵡⴻⵚⵚⴰ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⴰⵇⴰ ⵃⵙⴻⵏ ⴰⴷ ⵉⵎⵎⴻⵜ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("JN18_15","073_18_15","JHN","18","15","15","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵉⴹⴼⴰⵔ ⵢⴰⵙⵓⵄ ⴰⴽ-ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ. ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵖⴰⵔ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵍⴻⵎⵔⴰⵃ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN18_16","073_18_16","JHN","18","16","16","ⵛⵉⵎⵄⵓⵏ ⵉⴱⴻⴷⴷ-ⴷⴷ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ. ⵉⴼⴼⴻⵖ-ⴷⴷ ⵓⵎⴻⵃⴹⴰⵔ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵖⴰⵔ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⵄⴻⵙⵙⴰⵙⵜ ⵜⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⴰⵡⵡⴰⵔⵜ ⵓⵛⴰ ⵉⵙⵙⵉⴷⴻⴼ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN18_17","073_18_17","JHN","18","17","17","ⵜⴰⴱⵍⵉⵖⵜ ⵜⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⴰⵡⵡⴰⵔⵜ, ⵜⴻⵏⵏⴰ ⵉ ⵛⵉⵎⵄⵓⵏ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ-ⴰ?” ⵉⵏⵏⴰ: “ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN18_18","073_18_18","JHN","18","18","18","ⵜⵓⵖⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴷⵉⵏ, ⵙⵙⴰⵔⵖⴻⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵙ ⵍⴻⴼⵃⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵎⴻⴹ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵜⵜⵡⴻⵇⵇⴰⵃⴻⵏ. ⵓⵍⴰ ⴷ ⵛⵉⵎⵄⵓⵏ ⵉⴱⴻⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵜⵜⵡⴻⵇⵇⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("JN18_19","073_18_19","JHN","18","19","19","ⵉⵙⵙⴻⵇⵙⴰ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵢⴰⵙⵓⵄ ⵅ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵅ ⵜⵖⵓⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN18_20","073_18_20","JHN","18","20","20","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ: “ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵉ ⵍⴳⴻⵏⵙ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵙⵙⵖⴰⵔⴻⵖ ⵍⴻⴱⴷⴰ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵓ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵎⴰⵏⵉ ⵜⵜⵎⵓⵏⴰⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵍⴻⴱⴷⴰ. ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN18_21","073_18_21","JHN","18","21","21","ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ? ⵙⴻⵇⵙⴰ ⵉⵏⵏⵉ ⵉⵙⵍⴰⵏ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵏⵏⵉⵖ. ⵅⵣⴰⵔ, ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ ⵎⵉⵏ ⵏⵏⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("JN18_22","073_18_22","JHN","18","22","22","ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵎⵎⵓ, ⵅⴻⵏⵏⵉ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ, ⵉⵡⵜⴰ ⵢⴰⵙⵓⵄ ⵅ ⵓⵎⴻⴳⴳⵉⵣ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⴰⵎⵎⵓ ⵉ ⴷⴷ ⵖⴰ ⵜⴰⵔⵔⴻⴷ ⵅ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN18_23","073_18_23","JHN","18","23","23","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ: “ⵎⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵛⵀⴻⴷ ⵅ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵎⵍⵉⵃ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵛⵛⴰⵜⴻⴷ ⵅⴻⵏⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("JN18_24","073_18_24","JHN","18","24","24","ⵅⴰⵙ ⵓⵛⴰ ⵃⴰⵏⵏⴰⵏ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵉⵜⵜⵡⴰⵛⴰⵔⴼ ⵖⴰⵔ ⵇⴰⵢⴰⴼⴰ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN18_25","073_18_25","JHN","18","25","25","ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵉⴱⴻⴷⴷ ⴷⵉⵏⵏⵉ ⵉⵜⵜⵡⴻⵇⵇⴰⵃ. ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ?” ⵏⴻⵜⵜⴰ ⵉⵏⴽⴰⵔ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⴵⵉⵖ ⵛⴰ ⴷ ⵏⴻⵛⵛ!” ");
INSERT INTO rift_vpl VALUES ("JN18_26","073_18_26","JHN","18","26","26","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵄⵏⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵇⴻⵙⵙ ⵛⵉⵎⵄⵓⵏ ⴰⵎⴻⵣⵣⵓⵖ, ⵉⵏⵏⴰ: “ⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵥⵔⵉⵖ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ?” ");
INSERT INTO rift_vpl VALUES ("JN18_27","073_18_27","JHN","18","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⴽⴰⵔ ⵛⵉⵎⵄⵓⵏ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴷⴻⵖⵢⴰ ⵉⵙⵙⵇⵓⵇⴻⵄ ⵓⵢⴰⵥⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("JN18_28","073_18_28","JHN","18","28","28","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵣⵉ ⵇⴰⵢⴰⴼⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴱⵔⵉⵜⵓⵔⵉⵢⵓⵎ’. ⵜⵓⵖⴰ ⴷ ⵣⵉⵛ ⴷⵉ ⵚⵚⴱⴻⵃ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵓⴷⵉⴼⴻⵏ ⵛⴰ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴻⵙⵙⵉⵅⴻⵏ ⵇⴱⴻⵍ ⵎⴰ ⵉ ⵖⴰ ⵛⵛⴻⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("JN18_29","073_18_29","JHN","18","29","29","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵏ ⴰⵛⴻⵜⵛⵉ ⵉ ⵖⴰⵔⵡⴻⵎ ⵅ ⵡⴻⵔⵢⴰⵣ-ⴰ?” ");
INSERT INTO rift_vpl VALUES ("JN18_30","073_18_30","JHN","18","30","30","ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰⵍⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⴷ ⵎⵎⵉⵙ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵡⴰⵔ ⴷ ⴰⵛ ⵜ-ⵉ-ⴷⴷ-ⵏⴻⵜⵜⵉⵡⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN18_31","073_18_31","JHN","18","31","31","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⵅⴻⵏⵏⵉ ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ, ⵜⵃⴻⴽⵎⴻⵎ ⵅⴰⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵡⴻⵎ.” ⵅⴻⵏⵏⵉ ⵏⵏⴰⵏ ⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ: “ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵏⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ!”, ");
INSERT INTO rift_vpl VALUES ("JN18_32","073_18_32","JHN","18","32","32","ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵢⴰⵙⵓⵄ ⵉ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵙⵙⵛⴰⵏⴻⵏ ⵉ ⵎⴰⵏ ⵍⵎⴻⵡⵜ ⵉ ⵖⴰ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("JN18_33","073_18_33","JHN","18","33","33","ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ-ⴷⴷ ⴱⵉⵍⴰⵟⵓⵙ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴰⵄ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⵔⵉⵜⵓⵔⵉⵢⵓⵎ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵢⴰⵙⵓⵄ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN18_34","073_18_34","JHN","18","34","34","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰ ⵜⴻⵇⵇⴰⵔⴻⴷ ⴰⵢⴰ ⵣⵉ ⵖⴰⵔⴻⴽ ⵏⵉⵖ ⵜⵓⵖⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵛ ⵜ ⵅⴰⴼⵉ?” ");
INSERT INTO rift_vpl VALUES ("JN18_35","073_18_35","JHN","18","35","35","ⵉⵏⵏⴰ ⴰⵙ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⴰ ⵏⴻⵛⵛ ⴷ ⵓⴷⴰⵢ? ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵡⵢⴻⵏ-ⴷⴷ ⵛⴻⴽ ⵖⴰⵔⵉ. ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("JN18_36","073_18_36","JHN","18","36","36","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ: “ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ⵎⴰⵍⴰ ⵜⴻⴵⴰ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵇⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵙⴻⵍⵍⴰⵎⴻⵖ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉⵏⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵙⵙⴰⵏⵉⵜⴰ.” ");
INSERT INTO rift_vpl VALUES ("JN18_37","073_18_37","JHN","18","37","37","ⵉⵏⵏⴰ ⴰⵙ ⴱⵉⵍⴰⵟⵓⵙ: “ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵉⵛⴰⵏ!” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ: “ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵊⴻⴵⵉⴷ. ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ ⵓ ⵉ ⵓⵢⴰ ⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵀⴷⴻⵖ ⵉ ⵜⵉⴷⴻⵜⵜ. ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⵉⴷⴻⵜⵜ, ⴰⴷ ⵉⵙⴻⵍ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN18_38","073_18_38","JHN","18","38","38","ⵉⵏⵏⴰ ⴰⵙ ⴱⵉⵍⴰⵟⵓⵙ: “ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴷ ⵜⵉⴷⴻⵜⵜ?” ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵎⵎⵓ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵅⴻⵟⵟⵓ. ");
INSERT INTO rift_vpl VALUES ("JN18_39","073_18_39","JHN","18","39","39","ⵎⴰⵛⴰ ⴰⵇⴰ ⵜⴻⵏⵏⵓⵎⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⵙⴰⵔⵔⵃⴻⵖ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ⵎⴰ ⵜⴻⵅⵙⴻⵎ ⵅⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵙⴰⵔⵔⵃⴻⵖ ⴱⵏⴰⴷⴻⵎ-ⴰ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN18_40","073_18_40","JHN","18","40","40","ⵙⵖⵓⵢⵢⴻⵏ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵡⴰⵏⵉⵜⴰ, ⵃⴰⵛⴰ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ!” ⵜⵓⵖⴰ ⴱⴰⵔ-ⴰⴱⴱⴰⵙ ⴷ ⴰⵇⵟⴰⵟⵄⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("JN19_1","073_19_1","JHN","19","1","1","ⵅⴻⵏⵏⵉ ⵉⵊⵊⴰ ⴱⵉⵍⴰⵟⵓⵙ ⴰⴷ ⵀⴻⵜⵜⴽⴻⵏ ⵢⴰⵙⵓⵄ ⵙ ⵓⵔⴻⴽⴽⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("JN19_2","073_19_2","JHN","19","2","2","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵎⵓⴷⴻⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵙ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ, ⵙⵙⴰⵔⵙⴻⵏ ⴰⵙ ⵜⵜ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⴰⵔⴹⴻⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("JN19_3","073_19_3","JHN","19","3","3","ⵏⵏⴰⵏ: “ⵙⵍⴰⵎ ⵅⴰⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ!”, ⵓⵛⴰ ⵡⵜⵉⵏ ⵜ ⵅ ⵉⴳⴻⵎⵎⵉⵣⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN19_4","073_19_4","JHN","19","4","4","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴱⵉⵍⴰⵟⵓⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰⴷ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⵓⴼⴼⵖⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵓⵛⴻⵜⵛⵉ, ⵓⵍⴰ ⴷ ⵉⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN19_5","073_19_5","JHN","19","5","5","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵙ ⵜⵜⴰⵊ ⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵓⵊⴻⴵⴰⴱ ⴰⵊⵓⵔⵡⴰⵏⵉ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⵅⵣⴰⵔⴻⵎ, ⴱⵏⴰⴷⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("JN19_6","073_19_6","JHN","19","6","6","ⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵙⵖⵓⵢⴻⵏ, ⵏⵏⴰⵏ: “ⵚⴻⵍⵍⴱ ⵉ-ⵜ, ⵚⴻⵍⵍⴱ ⵉ-ⵜ” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⴰⵡⵢⴻⵎ ⵜ-ⵉ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ, ⵚⴻⵍⵍⴱⴻⵎ ⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ.” ");
INSERT INTO rift_vpl VALUES ("JN19_7","073_19_7","JHN","19","7","7","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ: “ⵖⴰⵔⵏⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ, ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("JN19_8","073_19_8","JHN","19","8","8","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⴱⵉⵍⴰⵟⵓⵙ ⴰⵡⴰⵍ-ⴰ, ⵢⴰⵔⵏⵉ ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("JN19_9","073_19_9","JHN","19","9","9","ⵢⵓⴷⴻⴼ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ, ⵉⵏⵏⴰ ⵉ ⵢⴰⵙⵓⵄ: “ⵎⴰⵏⵉⵙ ⵛⴻⴽ?” ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵅⴰⵙ ⴷⴷ-ⵢⴰⵔⵔⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN19_10","073_19_10","JHN","19","10","10","ⵉⵏⵏⴰ ⴰⵙ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⴰ ⵡⴰⵔ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴽⵉⴷⵉ ⵜⴻⵙⵙⵉⵡⵉⵍⴻⴷ? ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⴰⵇⴰ ⵖⴰⵔⵉ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵛ ⵙⵙⴰⵔⵔⵃⴻⵖ ⵓ ⵖⴰⵔⵉ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵚⴻⵍⵍⴱⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("JN19_11","073_19_11","JHN","19","11","11","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵢⴰⵙⵓⵄ: “ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⵜᵉⵜⵜⵉⵍⵉ ⴱⵓ ⵚⵚⵓⵍⵟⴰ ⵅⴰⴼⵉ, ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵛ ⴷⴷ-ⵜⴻⵎⵎⴻⵡⵛ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ⵙ ⵓⵢⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵛⴻⴽ, ⴰⵇⴰ ⵅⴰⵙ ⴷⴷⴻⵏⴱ ⵉⵎⵖⴰⵔ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉ ⵉⴵⴰⵏ ⵅⴰⴽ.” ");
INSERT INTO rift_vpl VALUES ("JN19_12","073_19_12","JHN","19","12","12","ⵣⵉ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴱⵉⵍⴰⵟⵓⵙ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴰⵙ ⵉⵙⴰⵔⵔⴻⵃ, ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⵙⵖⵓⵢⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵜⵙⴰⵔⵔⵃⴻⴷ ⵉ ⵡⴻⵔⵢⴰⵣ-ⴰ, ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⵇⴰⵢⵚⴰⵔ. ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵉⵜⵜⵄⴻⴽⴽⴰⵙ ⵇⴰⵢⵚⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("JN19_13","073_19_13","JHN","19","13","13","ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⴱⵉⵍⴰⵟⵓⵙ ⵉ ⵡⴰⵡⴰⵍ-ⴰ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵢⴰⵙⵓⵄ, ⵉⵇⵇⵉⵎ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵣⵣⴰⵢ ⵏ ⵍⵓⵚⴰ’, ⵎⴰⵛⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ‘ⴳⴱⵉⴱⵜⴰ’. ");
INSERT INTO rift_vpl VALUES ("JN19_14","073_19_14","JHN","19","14","14","ⵜⵓⵖⴰ ⴷ ⴰⵙⵙ ⵏ ⵓⵙⴻⵡⵊⴻⴷ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ⵜⵓⵖⴰ ⵄⵍⴰⵃⴰⵍ ⴷ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵉ ⵡⵓⴷⴰⵢⴻⵏ: “ⵅⵣⴰⵔⴻⵎ, ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("JN19_15","073_19_15","JHN","19","15","15","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⴻⵏ: “ⴽⵙⵉ ⵜ, ⴽⵙⵉ ⵜ, ⵚⴻⵍⵍⴱ ⵉ-ⵜ!” ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⴰ ⴰⴷ ⵚⴻⵍⵍⴱⴻⵖ ⵅⴻⵏⵏⵉ ⴰⵊⴻⴵⵉⴷ ⵏⵡⴻⵎ?” ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ: “ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵓⵊⴻⴵⵉⴷ ⵎⵖⵉⵔ ⵇⴰⵢⵚⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("JN19_16","073_19_16","JHN","19","16","16","ⵅⴻⵏⵏⵉ ⵉⵙⴻⵍⵍⴻⵎ ⴰⵙⴻⵏ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵚⴻⵍⵍⴱⴻⵏ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵢⴰⵙⵓⵄ, ⵉⵡⵢⴻⵏ ⵜ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN19_17","073_19_17","JHN","19","17","17","ⵢⴰⵔⴱⵓ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵜⴰⵛⴻⵇⵇⵓⴼⵜ’, ⵎⴰⵛⴰ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵊⵓⵍⵊⵓⵜⴰ’.    ");
INSERT INTO rift_vpl VALUES ("JN19_18","073_19_18","JHN","19","18","18","ⵚⴻⵍⵍⴱⴻⵏ ⵜ ⴷⵉⵏⵏⵉ, ⵓⵛⴰ ⵚⴻⵍⵍⴱⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵖⵏⵉ, ⵓ ⵢⴰⵙⵓⵄ ⴷⵉ ⵍⵡⴻⵙⵟ. ");
INSERT INTO rift_vpl VALUES ("JN19_19","073_19_19","JHN","19","19","19","ⵢⵓⵔⴰ ⴱⵉⵍⴰⵟⵓⵙ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵉⵛⵜ ⵜⴻⵍⵡⵉⵃⵜ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵅ ⵚⵚⴰⵍⵉⴱ. ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⵔⵉ ⴷⴰⵢⴻⵙ: ‘ⵡⴰⵏⵉⵜⴰ ⴷ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("JN19_20","073_19_20","JHN","19","20","20","ⵜⵉⵔⴰ-ⵢⴰ ⵖⵔⵉⵏ ⵜⴻⵏⵜ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵚⴻⵍⵍⴱⴻⵏ ⵢⴰⵙⵓⵄ ⵢⵓⴷⴻⵙ-ⴷⴷ ⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⵜⵉⵔⴰ-ⵢⴰ ⵜⵜⵡⴰⵔⵉⵏⵜ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ⴷ ⵜⵍⴰⵜⵉⵏⵉⵜ ⴷ ⵜⵢⵓⵏⴰⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JN19_21","073_19_21","JHN","19","21","21","ⵏⵏⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⴱⵉⵍⴰⵟⵓⵙ: “ⵡⴰⵔ ⵜⵜⴰⵔⵉ ⵛⴰ: ‘ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ’, ⵎⴰⵛⴰ ⴰⵇⴰ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("JN19_22","073_19_22","JHN","19","22","22","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵉⵍⴰⵟⵓⵙ: “ⵎⵉⵏ ⵓⵔⵉⵖ, ⴰⵇⴰ ⵓⵔⵉⵖ ⵜ.” ");
INSERT INTO rift_vpl VALUES ("JN19_23","073_19_23","JHN","19","23","23","ⵍⴰⵎⵉ ⵚⴻⵍⵍⴱⴻⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵢⴰⵙⵓⵄ, ⴽⵙⵉⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⴱⴹⴰⵏ ⵜ ⵅ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ, ⵉ ⴽⵓⵍ ⴰⵄⴻⵙⴽⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ. ⵎⴰⵛⴰ ⵜⵛⴰⵎⵉⵔ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴱⵍⴰ ⵜⴰⵅⴻⵢⵢⴰⴹⵜ, ⵜᵉⵜⵜⵡⴰⵅⴻⵢⵢⴻⴹ ⵇⴰⵄ ⵣⵉ ⵙⴻⵏⵏⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("JN19_24","073_19_24","JHN","19","24","24","ⵏⵏⴰⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ: “ⵡⴰⵔ ⵜ ⵏⴻⵜⵜⵛⴰⵔⵔⵉⴳ ⵛⴰ, ⴰⴷ ⵅⴰⵙ ⵏⴻⴳⴳ ⴰⴽⴻⵛⵛⵓⴹ, ⴰⴷ ⵏⵥⴰⵔ ⵡⵉ ⵜ ⵖⴰ ⵢⴰⵡⵢⴻⵏ!” ⴰⵎⵎⵓ ⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⴱⴹⴰⵏ ⴰⵔⵔⵓⴹ ⵉⵏⵓ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓ ⵅ ⵜⵛⴰⵎⵉⵔ ⵉⵏⵓ ⴳⴳⵉⵏ ⴰⴽⴻⵛⵛⵓⴹ.” ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵉⴳⴳⵉⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN19_25","073_19_25","JHN","19","25","25","ⵖⴰⵔ ⵚⵚⴰⵍⵉⴱ ⵏ ⵢⴰⵙⵓⵄ ⵜⴱⴻⴷⴷ ⵢⴻⵎⵎⴰⵙ, ⴷ ⵓⵍⵜⵎⴰⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⴷ ⵎⴰⵔⵢⴰⵎ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴽⵍⵉⵢⵓⴱⴰⵙ, ⴷ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("JN19_26","073_19_26","JHN","19","26","26","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵢⴻⵎⵎⴰⵙ ⴷ ⵓⵎⴻⵃⴹⴰⵔ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ, ⵉⴱⴻⴷⴷ ⴷⵉⵏ, ⵉⵏⵏⴰ ⵉ ⵢⴻⵎⵎⴰⵙ: “ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵅⵣⴰⵔ, ⵎⵎⵉⵎ!” ");
INSERT INTO rift_vpl VALUES ("JN19_27","073_19_27","JHN","19","27","27","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵉ ⵓⵎⴻⵃⴹⴰⵔ ⵏⵏⵉ: “ⴰⵇⴰ-ⵛ ⵢⴻⵎⵎⴰⵛ!” ⵣⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵉⴽⵙⵉ ⵜⵜ ⵓⵎⴻⵃⴹⴰⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN19_28","073_19_28","JHN","19","28","28","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴰⵇⴰ ⴽⵓⵍⵛⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⵏⴻⵛⵛ ⴼⴼⵓⴷⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("JN19_29","073_19_29","JHN","19","29","29","ⵉⵜⵜⵡⴰⵎⴰⵔⵙ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵉⵛⵛⵓⵔ ⵙ ⵍⵅⴻⴵ. ⵙⵙⵖⴻⴹⵚⴻⵏ ⵉⵛⵜ ⵏ ⵙⴱⵓⵏⵅⴰ ⵏ ⵀⵉⵙⵓⴱ ⵙ ⵍⵅⴻⴵ ⵓⵛⴰ ⴳⴳⵉⵏ ⵜⵜ ⵅ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵏ ⵜⵄⴻⵍⴵⴻⵜ, ⵙⵙⵉⵡⴹⴻⵏ ⴰⵙ ⵜⵜ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN19_30","073_19_30","JHN","19","30","30","ⵍⴰⵎⵉ ⵉⵇⵇⴰⵙ ⵢⴰⵙⵓⵄ ⵍⵅⴻⴵ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ!” ⵓⵛⴰ ⵉⵙⵙⴰⴹⴰⵔ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵉⵙⴻⵍⵍⴻⵎ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN19_31","073_19_31","JHN","19","31","31","ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵙⵙ ⵏ ⵓⵙⴻⵡⵊⴻⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵏⵏⴰⵏ ⵡⵓⴷⴰⵢⴻⵏ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵙⴻⵏ ⵅ ⵚⵚⴰⵍⵉⴱ ⴷⵉ ⵙⵙⴻⴱⵜ, ⵎⵉⵏⵣⵉ ⵙⵙⴻⴱⵜ ⵢⵓⴷⴻⵙ-ⴷⴷ!”, ⵎⵉⵏⵣⵉ ⴰⵙⵙ ⵏⵏⵉ ⵏ ⵙⵙⴻⴱⵜ ⵜⵓⵖⴰ ⴷ ⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵙ ⵓⵢⴰ ⵜⵜⴰⵔⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵣⵉ ⴱⵉⵍⴰⵟⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵥⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ, ⴰⴷ ⵜⴻⵏ ⵙⵙⵉⴳⴳⵯⴻⵊⴻⵏ ⵙⵙⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JN19_32","073_19_32","JHN","19","32","32","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⴰⵔⵥⵉⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵓ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN19_33","073_19_33","JHN","19","33","33","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵡⴰⵔ ⴰⵔⵥⵉⵏ ⵛⴰ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵇⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JN19_34","073_19_34","JHN","19","34","34","ⵎⴰⵛⴰ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵙⵙⵏⵓⵇⵇⴻⴱ ⵉ-ⵜ ⵙ ⵉⵛⵜ ⵏ ⵍⴰⵏⵙⴰ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵡⴰⵎⴰⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN19_35","073_19_35","JHN","19","35","35","ⵡⴻⵏⵏⵉ ⵉⵥⵔⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵜⵓⵖⴰ ⵉⵛⵀⴻⴷ ⵓ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵉⵏⵏⴰ ⵜⵉⴷⴻⵜⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("JN19_36","073_19_36","JHN","19","36","36","ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵎⵙⴰⵔⴻⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴰⵔⴻⵥⵥⵉ ⵢⵉⵖⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN19_37","073_19_37","JHN","19","37","37","ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵇⵇⴰⵔ: “ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵙⵏⵓⵇⵇⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN19_38","073_19_38","JHN","19","38","38","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵢⵓⵙⵓⴼ ⵣⵉ ⵔⴰⵎⵜⴰ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴹⴰⵔ ⵏ ⵢⴰⵙⵓⵄ ⵎⴰⵛⴰ ⵙ ⵜⵏⵓⴼⴼⵔⴰ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⵜⵜⴰⵔ ⴰⵙ ⵉ ⴱⵉⵍⴰⵟⵓⵙ ⵜⵜⴻⵙⵔⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⵙⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⴱⵉⵍⴰⵟⵓⵙ ⵉⵙⴰⵔⵔⴻⵃ ⴰⵙ. ⵅⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ, ⵉⴽⵙⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN19_39","073_19_39","JHN","19","39","39","ⵢⵓⵙⴰ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵏⵉⴽⵓⴷⵉⵎⵓⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵇⴱⴻⵍ ⵖⴰⵔ ⵢⴰⵙⵓⵄ ⵙ ⴵⵉⵍⴻⵜ, ⵢⵉⵡⵉ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⴰⵅⴻⴵⴻⴹ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵎⵉⵔⵔⵓ ⴷ ⵡⴻⵛⴼⵉⵔ ⵄⵍⴰⵃⴰⵍ ⵎⵢⴰ ⵍⵉⵜⵔⵓ.    ");
INSERT INTO rift_vpl VALUES ("JN19_40","073_19_40","JHN","19","40","40","ⴽⵙⵉⵏ ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ, ⵍⴻⵃⵃⴼⴻⵏ ⵜⵜ ⴷⵉ ⵍⴻⵛⴼⵓⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⴰⴽ-ⴷ ⵍⴻⵄⵟⵓⵔ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵓⵎⴻⵏ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵜ ⵡⵓⴷⴰⵢⴻⵏ ⵉ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN19_41","073_19_41","JHN","19","41","41","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵃⵡⵉⵛ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵚⴻⵍⵍⴱⴻⵏ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⴷⴻⴳ ⵡⴻⵃⵡⵉⵛ ⵉⵊⵊ ⵏ ⵡⴻⵏⴹⴻⵍ ⵏ ⵊⴷⵉⴷ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵙⵙⴰⵔⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JN19_42","073_19_42","JHN","19","42","42","ⵙⵙⴰⵔⵙⴻⵏ ⵢⴰⵙⵓⵄ ⴷⵉⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵙⵙⴻⴱⵜ ⵓ ⵎⵉⵏⵣⵉ ⴰⵏⴹⴻⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN20_1","073_20_1","JHN","20","1","1","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⴷⵉ ⵚⵚⴱⴻⵃ ⵣⵉⵛ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⵜⴰⴵⴻⵙⵜ. ⵜⴻⵥⵔⴰ ⵜⴰⵚⴹⴰⵔⵜ ⴰⵇⴰ ⵜⴻⵎⵎⴻⴽⵙⵉ ⵅ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN20_2","073_20_2","JHN","20","2","2","ⵜⵓⵣⵣⴻⵍ-ⴷⴷ, ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵓ ⵖⴰⵔ ⵓⵎⴻⵃⴹⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵢⴰⵙⵓⵄ, ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⵙⵉⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵣⴻⴳ ⵡⴻⵏⴹⴻⵍ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵏⵉ ⵜ ⴳⴳⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN20_3","073_20_3","JHN","20","3","3","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ ⴷ ⵓⵎⴻⵃⴹⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN20_4","073_20_4","JHN","20","4","4","ⵏⵉⵜⵏⵉ ⵓⵣⵣⵍⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ, ⵎⴰⵛⴰ ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵉⵣⵡⴰⵔ ⵉ ⵛⵉⵎⵄⵓⵏ ⵓⵛⴰ ⵢⵉⵡⴻⴹ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JN20_5","073_20_5","JHN","20","5","5","ⵉⵅⵣⴰⵔ, ⵉⵥⵔⴰ ⵍⴻⵛⴼⵓⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵎⵎⴰⵔⵙⴻⵏ ⴷⵉⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN20_6","073_20_6","JHN","20","6","6","ⵉⴹⴼⴰⵔ ⵉ-ⵜ ⵛⵉⵎⵄⵓⵏ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⵉⵥⵔⴰ ⵄⴰⵡⴻⴷ ⵍⴻⵛⴼⵓⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵎⵎⴰⵔⵙⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JN20_7","073_20_7","JHN","20","7","7","ⴰⵎⴻⵏⴷⵉⵍ ⵏⵏⵉ ⵜⵓⵖⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⵎⵎⴰⵔⵙ ⵛⴰ ⴰⴽ-ⴷ ⵍⴻⵛⴼⵓⵏ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⴹⴼⴻⵚ, ⵉⵜⵜⵡⴰⴳⴳ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵡⴻⵃⵃⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN20_8","073_20_8","JHN","20","8","8","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵓⵍⴰ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⴻⵖⵏⵉ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ, ⵉⵥⵔⴰ ⵓⵛⴰ ⵢⵓⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN20_9","073_20_9","JHN","20","9","9","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⴽⴽⴰⵔ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN20_10","073_20_10","JHN","20","10","10","ⵅⴻⵏⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN20_11","073_20_11","JHN","20","11","11","ⵎⴰⵔⵢⴰⵎ ⵜⴻⵇⵇⵉⵎ ⵜⴱⴻⴷⴷ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⴱⴰⵔⵔⴰ, ⵜᵉⵜⵜⵔⵓ. ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⵔⵓ, ⵜⴻⵙⵡⴻⴹ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("JN20_12","073_20_12","JHN","20","12","12","ⵜⴻⵥⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵙ ⵡⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵇⵇⵉⵎⴻⵏⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵎⵎⴰⵔⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵜⵙⵓⵎⵎⵜⵉⵏ ⵏⵏⴻⵙ ⵏ ⵓⵣⴻⴵⵉⴼ, ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN20_13","073_20_13","JHN","20","13","13","ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵔⵓⴷ?” ⵜⴻⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵖⴰⵔ ⴽⴽⵙⴻⵏ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⴰⵏⵉ ⵜ ⵙⵙⴰⵔⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN20_14","073_20_14","JHN","20","14","14","ⵓⵎⵉ ⵜⴻⵏⵏⴰ ⴰⵢⴰ, ⵜⴻⵏⵏⴻⵇⵍⴻⴱ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ, ⵜⴻⵥⵔⴰ ⵢⴰⵙⵓⵄ ⵉⴱⴻⴷⴷ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏ ⵛⴰ ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN20_15","073_20_15","JHN","20","15","15","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵔⵓⴷ? ⵎⵉⵏ ⵅⴻⴼ ⵜⴰⵔⴻⵣⵣⵓⴷ?” ⵜᵉⵜⵜⵖⵉⵍ ⴰⵙ ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱ ⵏ ⵜⴻⵃⵡⵉⵛⵜ, ⵜⴻⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ ⵎⴰⵍⴰ ⵛⴻⴽ ⵉ-ⵜ ⵉⴽⵙⵉⵏ, ⵉⵏⵉ ⴰⵢⵉ ⵎⴰⵏⵉ ⵜ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵜ ⴽⵙⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN20_16","073_20_16","JHN","20","16","16","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵎⴰⵔⵢⴰⵎ!” ⵏⴻⵜⵜⴰⵜ ⵜⴻⵏⵏⴻⵇⵍⴻⴱ, ⵜⴻⵏⵏⴰ ⴰⵙ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ: “ⴰ ⵔⴰⴱⴱⵓⵍⵉ!”, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰ ⴰⵎⵙⴻⵖⵖⴰⵔ ⵉⵏⵓ’. ");
INSERT INTO rift_vpl VALUES ("JN20_17","073_20_17","JHN","20","17","17","ⵢⴰⵙⵓⵄ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵃⵉⴷⵉ ⵛⴰ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵄⴰⴷ ⵡⴰⵔ ⴳⴻⵄⵄⴷⴻⵖ ⵛⴰ ⵖⴰⵔ ⴱⴰⴱⴰ, ⵎⴰⵛⴰ ⵔⵓⵃ ⵖⴰⵔ ⴰⵢⵜⵎⴰ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⴷ ⴳⴻⵄⵄⴷⴻⵖ ⵖⴰⵔ ⴱⴰⴱⴰ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ, ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ.’” ");
INSERT INTO rift_vpl VALUES ("JN20_18","073_20_18","JHN","20","18","18","ⵜⴻⵄⵇⴻⴱ-ⴷⴷ ⵎⴰⵔⵢⴰⵎ ⵏ ⵎⴰⵊⴷⴰⵍⴰ ⵜⵅⴻⴱⴱⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵥⵔⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("JN20_19","073_20_19","JHN","20","19","19","ⵖⴰⵔ ⵜⵎⴻⴷⴷⵉⵜ ⵏ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵙⵙⵉⵎⴰⵏⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵇⵇⵏⴻⵏⵜ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ, ⵢⵓⴷⴻⴼ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⴱⴻⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵙⵍⴰⵎ ⵅⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("JN20_20","073_20_20","JHN","20","20","20","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵎⵎⴻⵍ ⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⴷ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ. ⴼⴰⵔⵃⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN20_21","073_20_21","JHN","20","21","21","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵢⴰⵙⵓⵄ: “ⵙⵍⴰⵎ ⵅⴰⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⴱⴰⴱⴰ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ.” ");
INSERT INTO rift_vpl VALUES ("JN20_22","073_20_22","JHN","20","22","22","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵙⵓⴹ ⴷⴰⵢⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵇⴻⴱⵍⴻⵎ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN20_23","073_20_23","JHN","20","23","23","ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵜⴻⵖⴼⴰⵔⴻⵎ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ. ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("JN20_24","073_20_24","JHN","20","24","24","ⵎⴰⵛⴰ ⵜⵓⵎⴰ, ⵉⵊⵊⴻⵏ ⵣⵉ ⵜⴻⵏⵄⴰⵛ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵛⵏⵉⵡ’, ⵡⴰⵔ ⵜⵓⵖⵉ ⵛⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN20_25","073_20_25","JHN","20","25","25","ⵏⵏⴰⵏ ⴰⵙ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ: “ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ!” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵥⵔⵉⵖ ⵍⵉⵎⴰⵍⵜ ⵏ ⵉⵎⴻⵙⵎⵉⵔⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴰⴹⴰⴹ ⵉⵏⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵉⵎⴻⵙⵎⵉⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⵜⵉⵎⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("JN20_26","073_20_26","JHN","20","26","26","ⴰⵡⴰⵔⵏⵉ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵜⵓⵖⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓ ⵜⵓⵎⴰ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ. ⵢⵓⴷⴻⴼ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵡⴰⵅⵅⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵜⵓⵖⴰ ⵇⵇⵏⴻⵏⵜ, ⵓⵛⴰ ⵉⴱⴻⴷⴷ-ⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵙⵍⴰⵎ ⵅⴰⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("JN20_27","073_20_27","JHN","20","27","27","ⵉⵏⵏⴰ ⵉ ⵜⵓⵎⴰ: “ⴰⵡⵉ-ⴷⴷ ⴰⴹⴰⴹ ⵏⵏⴻⵛ ⵓⵛⴰ ⵅⵣⴰⵔ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ, ⵙⴰⵔⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⴷⴰⵏⵉⵜⴰ ⵓ ⵙⵉⴷⴻⴼ ⵉ-ⵜ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵉⵏⵓ. ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⴷ ⴰⴽⴰⴼⵔⵉⵡ, ⵎⴰⵛⴰ ⴷ ⵍⵎⵓⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN20_28","073_20_28","JHN","20","28","28","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵜⵓⵎⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("JN20_29","073_20_29","JHN","20","29","29","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵓⵎⵉ ⵜⴻⵥⵔⵉⴷ ⴰⵢⵉ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵜⵓⵎⵏⴻⴷ, ⴰ ⵜⵓⵎⴰ! ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵥⵔⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JN20_30","073_20_30","JHN","20","30","30","ⵢⴰⵙⵓⵄ ⵉⴳⴳⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⴻⵖⵏⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵜⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵔⵉⵏⵜ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("JN20_31","073_20_31","JHN","20","31","31","ⵎⴰⵛⴰ ⵜⵉⵏⴰ ⵓⵔⴰⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⵜⴰⵎⵏⴻⵎ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN21_1","073_21_1","JHN","21","1","1","ⴰⵡⴰⵔⵏⵉ ⵓⵢⴰ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵎⵎⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⵉⴱⵉⵔⵉⵢⴰⵙ, ⵉⴹⵀⴰⵔ-ⴷⴷ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("JN21_2","073_21_2","JHN","21","2","2","ⵜⵓⵖⴰ ⴷⵉⵏ ⵊⵎⵉⵄ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⴷ ⵜⵓⵎⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵛⵏⵉⵡ’, ⴷ ⵏⴰⵜⴰⵏⴰⵢⵉⵍ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵉ ⵇⴰⵏⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵍⵊⴰⵍⵉⵍ, ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵣⴰⴱⴷⵉ ⵓⵍⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JN21_3","073_21_3","JHN","21","3","3","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ: “ⵏⴻⵛⵛ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴷ ⴳⵎⴰⵔⴻⵖ ⵉⵙⴻⵍⵎⴰⵏ.” ⵏⵏⴰⵏ ⴰⵙ: “ⴰⴷ ⴽⵉⴽ ⵏⵔⴰⵃ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ.” ⴼⴼⵖⴻⵏ-ⴷⴷ ⵓⵛⴰ ⵏⵢⵉⵏ ⴷⴻⵖⵢⴰ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ. ⴷⵉ ⴵⵉⵍⴻⵜ ⵏⵏⵉ ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JN21_4","073_21_4","JHN","21","4","4","ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ, ⵉⴱⴻⴷⴷ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴰⵇⴰ ⴷ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN21_5","073_21_5","JHN","21","5","5","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⴰ ⴰⴷ ⵜⴰⵖ ⵖⴰⵔⵡⴻⵎ ⵛⴰ ⵏ ⵎⴰⵛⵛⴰ?” ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ “ⵍⵍⴰ!” ");
INSERT INTO rift_vpl VALUES ("JN21_6","073_21_6","JHN","21","6","6","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵏⴹⴰⵔⴻⵎ ⵜⵔⴰⵛⵛⴰ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ, ⴰⴷ ⵜⴰⴼⴻⵎ.” ⵅⴻⵏⵏⵉ ⵏⴹⴰⵔⴻⵏ ⵜⵔⴰⵛⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⵜ-ⵉ-ⴷⴷ-ⵊⴻⴱⴷⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵙⴻⵍⵎⴰⵏ ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN21_7","073_21_7","JHN","21","7","7","ⵉⵏⵏⴰ ⵓⵎⴻⵃⴹⴰⵔ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵢⴰⵙⵓⵄ ⵉ ⴱⵓⵟⵔⵓⵙ: “ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ.” ⵍⴰⵎⵉ ⵉⵙⵍⴰ ⵛⵉⵎⵄⵓⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉ, ⵉⵟⵟⴻⴼ ⵜⵛⴰⵎⵉⵔ ⵏⵏⴻⵙ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⵉⵏⴹⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⴰⵍⴰⵎⵉ ⵖⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("JN21_8","073_21_8","JHN","21","8","8","ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵙ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⴳⴳⵯⵉⵊⴻⵏ ⵛⴰ ⵅ ⵍⴱⴰⵔⵔ ⵎⵖⵉⵔ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⵓⵛⴰ ⵊⴻⴱⴷⴻⵏ-ⴷⴷ ⵜⵔⴰⵛⵛⴰ ⴰⴽ-ⴷ ⵉⵙⴻⵍⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JN21_9","073_21_9","JHN","21","9","9","ⵍⴰⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵍⴱⴰⵔⵔ, ⵥⵔⵉⵏ ⴷⵉⵀⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ ⵉⵊⵊ ⵏ ⵓⴼⴻⵏⵏⵉⵛ ⵏ ⵍⴻⴼⵃⴻⵎ ⵎⵉⵅⴻⴼ ⵎⵎⴰⵔⵙⴻⵏ ⵉⵙⴻⵍⵎⴰⵏ ⴷ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JN21_10","073_21_10","JHN","21","10","10","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⵡⵢⴻⵎ-ⴷⴷ ⵣⴻⴳ ⵉⵙⴻⵍⵎⴰⵏ ⵉ ⵜⴻⴳⵎⴰⵔⴻⵎ ⵍⴻⵅⵅⵓ.” ");
INSERT INTO rift_vpl VALUES ("JN21_11","073_21_11","JHN","21","11","11","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵢⵓⵢⵓⵔ, ⵉⵊⴱⴻⴷ ⵜⵔⴰⵛⵛⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵉⵙⴻⵍⵎⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵖⴰⵔ ⵍⴱⴰⵔⵔ, ⴰⵇⴰ-ⵜⵜ ⴷⴰⵢⴻⵙ ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ. ⵡⴰⵅⵅⴰ ⴷⴰⵢⴻⵙ ⵙ ⵡⴰⵏⴻⵛⵜ ⵓⵢⴰ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⵛⴰⵔⵔⴻⴳ ⵛⴰ ⵜⵔⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JN21_12","073_21_12","JHN","21","12","12","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵢⴰⵙⵓⵄ: “ⴰⵔⴰⵃⴻⵎ-ⴷⴷ ⴷⴰ, ⴰⴷ ⵜⴰⵔⵉⵢⵢⵇⴻⵎ!” ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵡⴰⵔ ⵉⵣⵄⵉⵎ ⴰⴷ ⵜ ⵉⵙⵙⴻⵇⵙⴰ ‘ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ?’, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JN21_13","073_21_13","JHN","21","13","13","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ ⵢⴰⵙⵓⵄ, ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ ⴷ ⵉⵙⴻⵍⵎⴰⵏ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN21_14","073_21_14","JHN","21","14","14","ⵡⴰⵏⵉⵜⴰ ⴷ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵢⴰⵙⵓⵄ ⵉ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JN21_15","073_21_15","JHN","21","15","15","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴰⵔⵉⵢⵢⵇⴻⵏ, ⵉⵏⵏⴰ ⵢⴰⵙⵓⵄ ⵉ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ: “ⴰ ⵛⵉⵎⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰ, ⵎⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⵢⵉ ⴽⵜⴰⵔ ⵣⴻⴳ ⵢⵉⵏⴰ?” ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⴽ.” ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵔⵡⴻⵙ ⵉⵣⵎⴰⵔⴻⵏ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("JN21_16","073_21_16","JHN","21","16","16","ⵉⵏⵏⴰ ⴰⵙ ⵄⴰⵡⴻⴷ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: “ⴰ ⵛⵉⵎⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰ, ⵎⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⵢⵉ?” ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵀ ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⴽ.” ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵔⵡⴻⵙ ⵉⵛⴰⵔⵔⵉⵢⵢⴻⵏ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("JN21_17","073_21_17","JHN","21","17","17","ⵉⵏⵏⴰ ⴰⵙ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ: “ⴰ ⵛⵉⵎⵄⵓⵏ, ⵎⵎⵉⵙ ⵏ ⵢⵓⵏⴰ, ⵎⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⵢⵉ?” ⵉⵛⴹⴻⵏ ⴱⵓⵟⵔⵓⵙ ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ ⴰⵙ ⵜ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ: ‘ⵎⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ ⴰⵢⵉ?’, ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴽⵓⵍⵛⵉ, ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴻⴽ.” ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⴰⵔⵡⴻⵙ ⵜⵉⵅⵙⵉⵡⵉⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JN21_18","073_21_18","JHN","21","18","18","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵙ ⵜⵉⴷⴻⵜⵜ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ: ⵍⴰⵎⵉ ⵛⴻⴽ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵥⵢⴰⵏ, ⵜⴱⴻⵢⵙⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵜⵔⵓⵃⴻⴷ ⵎⴰⵏⵉ ⵜⴻⵅⵙⴻⴷ, ⵎⴰⵛⴰ ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴻⵡⵙⴰⵔⴻⴷ, ⴰⴷ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵛⴻⴽ ⵉⴱⵢⴻⵙ ⵓⵛⴰ ⴰⴷ ⵛⴻⴽ ⵢⴰⵡⵉ ⵖⴰⵔ ⵎⴰⵏⵉ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("JN21_19","073_21_19","JHN","21","19","19","ⵉⵏⵏⴰ ⴰⵎⵎⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⵎⴰⵏ ⵍⵎⴻⵡⵜ ⵉ ⵣⵉ ⵖⴰ ⵉⵙⵙⵄⵓⴵ ⴰⵔⴻⴱⴱⵉ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⴰⵎⵎⵓ, ⵉⵏⵏⴰ ⴰⵙ: “ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN21_20","073_21_20","JHN","21","20","20","ⵉⵏⵏⴻⵇⵍⴻⴱ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⵉⵥⵔⴰ ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⵢⴰⵙⵓⵄ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵎⴻⵢⵢⴻⵍ ⵖⴰⵔ ⵉⴷⵎⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ ⵉ ⵉⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵉⵖⴷⴰⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN21_21","073_21_21","JHN","21","21","21","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⴱⵓⵟⵔⵓⵙ ⵡⴰ, ⵉⵏⵏⴰ ⵉ ⵢⴰⵙⵓⵄ: “ⴰ ⵙⵉⴷⵉ, ⵉ ⵡⴰ, ⵎⵉⵏ ⴷ ⴰⵙ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN21_22","073_21_22","JHN","21","22","22","ⵉⵏⵏⴰ ⴰⵙ ⵢⴰⵙⵓⵄ: “ⵎⴰⵍⴰ ⵅⵙⴻⵖ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⵍ ⴷⴷ ⵖⴰ ⵄⴻⵇⴱⴻⵖ, ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵔⵓⵃⴻⵏ? ⵛⴻⴽ ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("JN21_23","073_21_23","JHN","21","23","23","ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵡⴰⵡⴰⵍ-ⴰ ⵊⴰⵔ ⵡⴰⵡⵎⴰⵜⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵎⴻⵃⴹⴰⵔ ⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ, ⵎⴰⵛⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵏⵏⵉ ⵛⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ, ⵎⴰⵛⴰ: “ⵎⴰⵍⴰ ⵅⵙⴻⵖ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⵍ ⴷⴷ ⵖⴰ ⵄⴻⵇⴱⴻⵖ, ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵔⵓⵃⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("JN21_24","073_21_24","JHN","21","24","24","ⴷ ⵡⴰ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("JN21_25","073_21_25","JHN","21","25","25","ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ. ⵎⴰⵍⴰ ⵜⵜⵡⴰⵔⵉⵏⵜ ⵉⵛⵜ ⴰⵡⴰⵔⵏⵉ ⵜⴻⵏⵏⴻⵖⵏⵉⵜ, ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ, ⴰⴷ ⵜⵉⵍⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵛⴰ ⵜⵜⴰⵙⵉⵄ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴽⵙⵉ ⵉⴷⵍⵉⵙⴻⵏ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵔⵉⵏ. ⴰⵎⵉⵏ! ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴱⴰⵔⵔⴻⵃ ⵢⵓⵃⴰⵏⵏⴰ. ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵜⵉⵔⴰ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⵍ’ⵉⵏⵊⵉⵍ. ⴰⵄⵓⴵⵉ ⵉ ⴱⴰⴱⴰⵙ, ⵉ ⵎⵎⵉⵙ ⵓ ⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵍⴻⵅⵅⵓ, ⵍⴻⴱⴷⴰ ⵓ ⵉ ⵍⴻⴱⴷⴰ ⵏ ⵍⴻⴱⴷⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("AC1_1","074_1_1","ACT","1","1","1","ⴰⴷⵍⵉⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵓⵔⵉⵖ, ⴰ ⵜⵉⵢⵓⴼⵉⵍⵉⵙ, ⵓⵔⵉⵖ ⵜ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴱⴷⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵉⴳⴳ ⵓ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("AC1_2","074_1_2","ACT","1","2","2","ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵉⵎⵎⴻⴽⵙⵉ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵡⴻⵚⵚⴰ ⵉ ⵔⵔⵓⵙⵓⵍ ⵉ ⵜⵓⵖⴰ ⵢⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("AC1_3","074_1_3","ACT","1","3","3","ⵉⵏⵏⵉ ⵓⵎⵉ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴻⴱ, ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⴷⴷⴰⵔ, ⴰⵎ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⴹⵀⴰⵔ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵙⵙⴰⵡⴰⵍ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC1_4","074_1_4","ACT","1","4","4","ⵍⴰⵎⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵛⵛⴰ ⴰⵖⵔⵓⵎ, ⵉⵡⴻⵚⵚⴰ ⵜⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⴻⴼⴼⵖⴻⵏ ⵛⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⴰⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵔⴰⵊⴰⵏ ⵍⵡⴰⵄⴷ ⵏ ⴱⴰⴱⴰ ⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ, ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ, “ⵜⴻⵙⵍⵉⵎ ⵣⵣⴰⵢⵉ, ");
INSERT INTO rift_vpl VALUES ("AC1_5","074_1_5","ACT","1","5","5","ⵎⵉⵏⵣⵉ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴷⵔⵓⵙ ⵏ ⵡⵓⵙⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC1_6","074_1_6","ACT","1","6","6","ⵅⴻⵏⵏⵉ ⵙⵙⴻⵇⵙⴰⵏ ⵜ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵎⵓⵏⴻⵏ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵔⵔⴻⴷ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉ ⵉⵙⵔⴰⵉⵍ ⵄⴰⵡⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("AC1_7","074_1_7","ACT","1","7","7","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵢⵓⵙⵉ ⴰⴷ ⵜⴰⵔⴻⴳⴱⴻⵎ ⵅ ⵣⵣⵎⴰⵏ ⴷ ⵣⵣⵎⴰⵏⴰⵜ ⵉ ⵉⴳⴳⴰ ⴱⴰⴱⴰ ⴷⵉ ⵚⵚⵓⵍⵟⴰ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC1_8","074_1_8","ACT","1","8","8","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵊⵊⴻⵀⴷ ⵅⵎⵉ ⵅⴰⵡⴻⵎ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵍⴻⵛⵀⵓⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⴷⵉ ⵙⴰⵎⴰⵔⵢⴰ, ⵡⴰⵀ, ⴰⵍ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC1_9","074_1_9","ACT","1","9","9","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵎⵎⴻⴽⵙⵉ ⵓⵛⴰ, ⴰⵎ ⵜ ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ, ⵉⴽⵙⵉ ⵜ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ, ⵉⴷⵡⴻⵍ ⵉⵏⵓⴼⴼⴰⵔ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC1_10","074_1_10","ACT","1","10","10","ⴰⵎ ⴷ ⴰⵙ ⵙⵙⴻⴹⴼⴰⵔⴻⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴰⵎ ⵉⵔⵓⵃ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("AC1_11","074_1_11","ACT","1","11","11","ⵓⵛⴰ ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⴰ, ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⵊⴰⵍⵉⵍ, ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵉⴷⴻⵄⵡⴻⵏ ⵜᵉⵜⵜⴱⴻⴷⴷⴰⵎ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ? ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵏⵉⵜⴰ, ⵡⴻⵏⵏⵉ ⵉⵎⵎⴻⴽⵙⵉⵏ ⵅⴰⵡⴻⵎ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴰⴷ ⴷⴷ-ⵉⵄⵇⴻⴱ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⴻⵥⵔⵉⵎ ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC1_12","074_1_12","ACT","1","12","12","ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵣⴻⴳ ⵡⴻⴷⵔⴰⵔ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵣⵣⵉⵜⵓⵏ’ ⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⴳⴳⵯⴻⵊ ⵅⴰⵙ ⵄⵍⴰⵃⴰⵍ ⵙⴻⴱⵄⴰ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵄⵍⴰⵃⴰⵍ ⵉⵊⵊ ⵏ ⴽⵉⵍⵓⵎⵉⵜⵔ ⵓ ⵜⵍⴰⵜⴰ ⵎⴻⵢⵢⴰ ⵎⵉⵜⵔ. ");
INSERT INTO rift_vpl VALUES ("AC1_13","074_1_13","ACT","1","13","13","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵜⵖⵓⵔⴼⴻⵜ ⵙⴻⵏⵏⴻⵊ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵖⵉⵎⴰⵏ ⵏⵉⵜⵏⵉ: ⴱⵓⵟⵔⵓⵙ, ⵢⵓⵃⴰⵏⵏⴰ, ⵢⴰⵄⵇⵓⴱ, ⴰⵏⴷⵔⴰⵡⵓⵙ, ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵜⵓⵎⴰ, ⵎⴰⵜⵜⴰ, ⴱⴰⵔ-ⵜⵓⵍⵓⵎⴰⵡⵓⵙ, ⵢⴰⵄⵇⵓⴱ ⵎⵎⵉⵙ ⵏ ⵃⴰⵍⴼⴰ, ⵛⵉⵎⵄⵓⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵎⵄⴻⵙⵙⴰⴱ’, ⴷ ⵢⴰⵀⵓⴷⴰ, ⵎⵎⵉⵙ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("AC1_14","074_1_14","ACT","1","14","14","ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵜⵓⵖⴰ ⵚⴱⴰⵔⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⴷⵎⴰⵎ ⵅ ⵜⵥⴰⴵⵉⵜ, ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⴰⵙⵓⵄ, ⵓ ⴰⴽ-ⴷ ⴰⵢⵜⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC1_15","074_1_15","ACT","1","15","15","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⴽⴽⴰⵔ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵊⴰⵔ ⴰⵙⴻⵏ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. ⵜⵓⵖⴰ ⴷⵉⵏ ⵎⵓⵏⴻⵏ ⵄⵍⴰⵃⴰⵍ ⵎⵢⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵡⴷⴰⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("AC1_16","074_1_16","ACT","1","16","16","“ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵏⵉⵛⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⴰⵡⴰⵍ ⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵇⴱⴻⵍ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴷⴰⵡⵓⴷ ⵅ ⵢⴰⵀⵓⴷⴰ, ⵡⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵃⴻⴱⴱⵙⴻⵏ ⵢⴰⵙⵓⵄ, ");
INSERT INTO rift_vpl VALUES ("AC1_17","074_1_17","ACT","1","17","17","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵣⵣⴰⵢⵏⴻⵖ, ⵣⵉ ⵜⴻⵏⵄⴰⵛ, ⵓ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC1_18","074_1_18","ACT","1","18","18","ⴰⵇⴰ ⵡⴰ ⵜⵓⵖⴰ ⵉⴽⴻⵙⵙⴻⴱ ⵉⵊⵊ ⵏ ⵉⵢⵢⴰⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵍⵎⵓⵏⴻⵜ ⵏ ⴷⴷⴻⵏⴱ ⵏⵏⴻⵙ ⵓⵛⴰ ⵓⵎⵉ ⵉⵡⴹⴰ ⵅ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵇⴰ ⵉⴼⴻⴵⴻⵇ ⵖⴰⵔ ⵜⴻⵊⵄⵉⵏⵏⴰⵜⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵎⴰⵔⵔⴰ ⴰⴷⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⴱⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC1_19","074_1_19","ACT","1","19","19","ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍⴰⵎⵉ ⵙⴻⵎⵎⴰⵏ ⵉⵢⵢⴰⵔ ⵏⵏⵉ ⴷⴻⴳ ⵉⵍⴻⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ‘ⵃⴰⵇⵍ-ⴷⴰⵎⴰ’, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵉⵢⵢⴰⵔ ⵏ ⵉⴷⴰⵎⵎⴻⵏ’. ");
INSERT INTO rift_vpl VALUES ("AC1_20","074_1_20","ACT","1","20","20","ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ ⵏ ⴷⴰⵡⵓⴷ: ‘ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵍⵅⴰⵔⴱⴻⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ!’ ⵓⵛⴰ: ‘ⴰⴷ ⵉⴽⵙⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("AC1_21","074_1_21","ACT","1","21","21","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵍⵉⵇ, ⴰⵇⴰ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ ⴽⵓⵍ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵉⵜⵜⴰⴷⴻⴼ ⵓ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵊⴰⵔ ⴰⵏⴻⵖ - ");
INSERT INTO rift_vpl VALUES ("AC1_22","074_1_22","ACT","1","22","22","ⵣⴻⴳ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵍ ⴰⵙⵙ ⵉ ⴷⵉ ⵉⵎⵎⴻⴽⵙⵉ ⵅⴰⵏⴻⵖ - ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵅ ⵜⵏⵓⴽⵔⴰ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC1_23","074_1_23","ACT","1","23","23","ⴰⵔⴻⵛⵛⵃⴻⵏ ⵜⵏⴰⵢⴻⵏ: ⵢⵓⵙⵓⴼ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⴰⵔ-ⵙⴰⴱⴰ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ⵢⵓⵙⵜⵓⵙ, ⴷ ⵎⴰⵜⵜⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC1_24","074_1_24","ACT","1","24","24","ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵥⴰⴵⴰⵏ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵓⵍⴰⵡⴻⵏ ⵏ ⵎⴰⵔⵔⴰ, ⵙⵛⴻⵏ ⴰⵏⴻⵖ ⵎⴰⵏ ⵡⴻⵏ ⵣⵉ ⵜⵏⴰⵢⴻⵏ-ⴰ ⵉ ⵜⵉⵅⴹⴰⵔⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("AC1_25","074_1_25","ACT","1","25","25","ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴰⵔⵛ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ-ⴰ ⵓ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵔⵔⵓⵙⵓⵍ ⵉ ⴷⵉ ⵉⵙⵎⴻⵃ ⵢⴰⵀⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC1_26","074_1_26","ACT","1","26","26","ⵅⴻⵏⵏⵉ ⴳⴳⵉⵏ ⴰⴽⴻⵛⵛⵓⴹ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⴽⴻⵛⵛⵓⴹ ⵅ ⵎⴰⵜⵜⵉⵢⴰ ⵓⵛⴰ ⴰⵔⵏⵉⵏ ⵜ ⵖⴰⵔ ⵃⵉⵟⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC2_1","074_2_1","ACT","2","1","1","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵍ ⵍⵄⵉⴷ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵊⵎⵉⵄ ⵎⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_2","074_2_2","ACT","2","2","2","ⵅ ⵉⵛⵜ ⵏ ⵍⵖⴻⴼⵍⴻⵜ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵣⵣⵀⵉⵔ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⴷ ⴰⵙⴻⵎⵎⵉⴹ ⵉⵊⴻⵀⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⵛⵛⵓⵔ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_3","074_2_3","ACT","2","3","3","ⵓⵛⴰ ⴹⵀⴰⵔⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ ⵉⵍⵙⴰⵡⴻⵏ ⴰⵎ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ ⵉⵜⵜⴻⵎⵙⴻⴱⴹⴰⵏ, ⴰⵔⵙⵉⵏ ⵅ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC2_4","074_2_4","ACT","2","4","4","ⵓ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴱⴷⴰⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⴰⵔⵔⵓⵃ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴻⵟⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_5","074_2_5","ACT","2","5","5","ⵜⵓⵖⴰ ⵜⵜⵖⵉⵎⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴻⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⴷⴰⵢⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC2_6","074_2_6","ACT","2","6","6","ⵓⵎⵉ ⵉⴽⴽⴰⵔ ⵣⵣⵀⵉⵔ-ⴰ, ⵉⵎⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⴷⵉⵏⵏⵉ ⵓⵛⴰ ⵜⴱⴻⵀⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⵉⵊⵊ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰ ⴰⵙⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵢⵉⵍⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵉⴼⴰⵔⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_7","074_2_7","ACT","2","7","7","ⴷⴻⵀⵛⴻⵏ, ⵜⴱⴻⵀⵜⴻⵏ ⵎⴰⵔⵔⴰ, ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴷ ⵉⵊⴰⵍⵉⵍⵉⵢⵢⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("AC2_8","074_2_8","ACT","2","8","8","ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵏⴻⵙⵍⴰ ⵏⴻⵛⵛⵉⵏ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵢⵉⵍⴻⵙ ⵉ ⵣⵉ ⴷⴷ-ⵏⴻⵜⵡⴰⵅⵍⴻⵇ? ");
INSERT INTO rift_vpl VALUES ("AC2_9","074_2_9","ACT","2","9","9","ⵉⴱⴰⵔⵜⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵉⴷⵉⵢⵢⴻⵏ ⴷ ⵉⵄⵉⵍⴰⵎⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ, ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵉⵏⵏⵉ ⵣⵉ ⴽⴰⴱⴱⴰⴷⵓⴽⵉⵢⴰ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴱⵓⵏⵟⵓⵙ ⴷ ⴰⵙⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("AC2_10","074_2_10","ACT","2","10","10","ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴼⵔⵉⵅⵉⵢⴰ, ⴱⴰⵎⴼⵉⵍⵉⵢⴰ ⴷ ⵎⵉⵚⵔⴰ ⵓ ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵍⵉⴱⵉⵢⴰ ⵖⴰⵔ ⵇⴰⵢⵔⴰⵡⴰⵏ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵔⵓⵎⴰ, ⴰⵎ ⵓⴷⴰⵢⴻⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏ ⴷⴷⵉⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC2_11","074_2_11","ACT","2","11","11","ⵉⵏⵏⵉⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⴽⵔⵉⵜⴰ ⵓ ⵣⵉ ⵄⴰⵔⴰⴱⵉⵢⵢⴰ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⴰⵙⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖ ⵅ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("AC2_12","074_2_12","ACT","2","12","12","ⵎⴰⵔⵔⴰ ⵜⴱⴻⵀⵜⴻⵏ ⵓⵛⴰ ⵏⵏⴰⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ: “ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("AC2_13","074_2_13","ACT","2","13","13","ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵙⵜⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵏⵏⴰⵏ: “ⵏⵉⵜⵏⵉ ⵙⵡⵉⵏ ⴱⵉⵏⵓ ⵏ ⵊⴷⵉⴷ.” ");
INSERT INTO rift_vpl VALUES ("AC2_14","074_2_14","ACT","2","14","14","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴽⴽⴰⵔ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⴰⴽ-ⴷ ⵃⵉⵟⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵓⴷⴰⵢⴻⵏ ⵓ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵙⵏⴻⵎ ⴰⵢⴰ, ⵙⵍⴻⵎ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("AC2_15","074_2_15","ACT","2","15","15","ⵉⵡⴷⴰⵏ-ⴰ ⵡⴰⵔ ⵙⵛⴰⵔⴻⵏ ⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵙⴰⵄⵄⴻⵜ ⴷ ⵜⵍⴰⵜⴰ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("AC2_16","074_2_16","ACT","2","16","16","ⵎⴰⵛⴰ ⴰⵢⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⴻⴳ ⵓⵏⴰⴱⵉ ⵢⵓⵡⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("AC2_17","074_2_17","ACT","2","17","17","‘ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴰⴷ ⴼⴰⵔⵔⵖⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⵅ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ. ⴰⴷ ⵏⴻⴱⴱⴰⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ ⵏⵡⴻⵎ, ⵉⴱⵍⵉⵖⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⵜⵡⴰⵍⴰⵏ ⵉⵡⴻⵃⵃⴰⵏ, ⵓⵛⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵡⴻⵎ ⴰⴷ ⴰⵔⵊⴰⵏ ⵜⵉⵔⵊⴰ. ");
INSERT INTO rift_vpl VALUES ("AC2_18","074_2_18","ACT","2","18","18","ⵓⵍⴰ ⵅ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⵓ ⵅ ⵜⵉⵢⵢⴰ ⵉⵏⵓ ⴰⴷ ⴼⴰⵔⵔⵖⴻⵖ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵏⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_19","074_2_19","ACT","2","19","19","ⴰⴷ ⵡⵛⴻⵖ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵍⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ: ⵉⴷⴰⵎⵎⴻⵏ ⴷ ⵜⵎⴻⵙⵙⵉ ⴷ ⵍⴻⴼⵡⴰⵔ ⵏ ⴷⴷⴻⵅⵅⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_20","074_2_20","ACT","2","20","20","ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴼⵓⵛⵜ ⵖⴰⵔ ⵜⴰⴵⴻⵙⵜ, ⴷ ⵜⵣⵉⵔⵉ ⵖⴰⵔ ⵉⴷⴰⵎⵎⴻⵏ, ⵇⴱⴻⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵡⴰⵙⵙ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵄⵓⴵⴻⵏ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AC2_21","074_2_21","ACT","2","21","21","ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵉⵍⴰⵖⴰⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ!’ ");
INSERT INTO rift_vpl VALUES ("AC2_22","074_2_22","ACT","2","22","22","ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵙⵍⴻⵎ ⴰⵡⴰⵍⴻⵏ-ⴰ: ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ, ⴰⵇⴰ-ⵜ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵛⴰⵏⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉ ⵢⴻⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("AC2_23","074_2_23","ACT","2","23","23","ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵓⵣⴻⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵏⴻⵜⵜⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵇⴱⴻⵍ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵙⴻⵍⵍⵎⴻⵎ ⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵓ ⵜⵚⴻⵍⵍⴱⴻⵎ ⵜ ⵓ ⵜⴻⵏⵖⵉⵎ ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC2_24","074_2_24","ACT","2","24","24","ⵎⴰⵛⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵅⵓ ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵍⴰⵅⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⴷⵉ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC2_25","074_2_25","ACT","2","25","25","ⵎⵉⵏⵣⵉ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵅⴰⵙ: ‘ⵜⵓⵖⴰ ⵜⵜⵡⴰⵍⵉⵖ ⵙⵉⴷⵉ ⵣⵣⴰⵜⵉ ⴷⵉ ⴽⵓⵍ ⴰⵎⵓⵔ, ⴰⵇⴰ-ⵜ ⵅ ⵢⴻⴼⵓⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵎⴻⵢⵢⵉⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC2_26","074_2_26","ACT","2","26","26","ⵙ ⵓⵢⴰ ⵉⴼⴰⵔⵔⴻⵀ ⵓⵍ ⵉⵏⵓ ⵓⵍⴰ ⴷ ⴰⵙⴻⵎⵖⴰⵔ ⵉⵏⵓ ⵉⴼⴻⵢⵢⴻⴹ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵓⵍⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⵃ ⵅ ⵓⵙⵉⵜⴻⵎ ⵡⴰⵏⵉⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("AC2_27","074_2_27","ACT","2","27","27","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵊⵊⵉⴷ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ⵓⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵊⵊⵉⴷ ⴰⵎⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵛ ⴰⴷ ⵉⴽⵉⵛⵛⵓ. ");
INSERT INTO rift_vpl VALUES ("AC2_28","074_2_28","ACT","2","28","28","ⵛⴻⴽ ⵜⴻⵙⵙⴻⵛⵏⴻⴷ ⴰⵢⵉ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵛⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵛⵛⵓⵔⴻⴷ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⵉ ⵍⵃⴰⴹⴰⵔ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("AC2_29","074_2_29","ACT","2","29","29","ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⴰⵇⴰ ⵜⴻⵄⴷⴻⵍ ⴰⵢⵉ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵅ ⴰⵔⵔⴰⵢⵙ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴷⴰⵡⵓⴷ, ⵡⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵎⵎⵓⵜ, ⵉⵜⵜⵡⴰⵏⴹⴻⵍ, ⵓⵛⴰ ⴰⵏⴹⴻⵍ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜ ⵖⴰⵔⵏⴻⵖ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC2_30","074_2_30","ACT","2","30","30","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵏⴰⴱⵉ, ⵉⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵊⵊⵓⴵ ⴰⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ: ‘ⴰⴷ ⵙⵙⵖⵉⵎⴻⵖ ⵉⵊⵊⴻⵏ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵄⴻⴷⴷⵉⵙⵜ ⵏⵏⴻⵛ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("AC2_31","074_2_31","ACT","2","31","31","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵣⵡⴰⵔ ⵉⵥⵔⴰ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵜⵏⵓⴽⵔⴰ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵊⵊⵉ ⵛⴰ ⴷⵉ ⵍⴰⵅⴰⵔⵜ ⵓⵛⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜᵉⵜⵜⴰⵛⵉ ⴰⴽⵉⵛⵛⵓ. ");
INSERT INTO rift_vpl VALUES ("AC2_32","074_2_32","ACT","2","32","32","ⵢⴰⵙⵓⵄ ⵡⴰⵏⵉⵜⴰ ⴰⵇⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴷ ⵍⴻⵛⵀⵓⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC2_33","074_2_33","ACT","2","33","33","ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵍ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵟⵟⴻⴼ ⵍⵡⴰⵄⴷ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⴱⴰⴱⴰⵙ. ⴰⵇⴰ ⵉⴼⴰⵔⵔⴻⵖ ⵜⴰⵡⵀⵉⴱⵜ-ⴰ ⵍⴻⵅⵅⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵓ ⵜᵉⵜⵜⴻⵙⵍⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("AC2_34","074_2_34","ACT","2","34","34","ⴷⴰⵡⵓⴷ ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴳⴻⵄⵄⴻⴷ ⵛⴰ ⵖⴰⵔ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⴰ: ‘ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⵉ ⵙⵉⴷⵉ ⵉⵏⵓ: ⵇⵇⵉⵎ ⵅ ⵢⴻⴼⵓⵙ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("AC2_35","074_2_35","ACT","2","35","35","ⴰⵍ ⴷ ⵖⴰ ⴳⴳⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("AC2_36","074_2_36","ACT","2","36","36","ⴰⴷ ⵜⴻⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵏⵉⵛⴰⵏ, ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵢⴰⵙⵓⵄ ⵡⴰⵏⵉⵜⴰ, ⵡⴻⵏⵏⵉ ⵜⵚⴻⵍⵍⴱⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴷ ⵙⵉⴷⵉ ⴷ ⵍⵎⴰⵙⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("AC2_37","074_2_37","ACT","2","37","37","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵜⵓⴷⴻⴼ ⴰⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ ⴷⴰⵅⴻⵍ, ⵏⵏⴰⵏ ⵉ ⵛⵉⵎⵄⵓⵏ ⵓ ⵉ ⵔⵔⵓⵙⵓⵍ ⵏⵏⴻⵖⵏⵉ: “ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ, ⴰ ⵜⴰⵡⵎⴰⵜ ⵏⵏⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("AC2_38","074_2_38","ACT","2","38","38","ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ: “ⵜⵓⴱⴻⵎ, ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵢⴰⵙⵓⵄ ⵉ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ, ⵓⵛⴰ ⴰⴷ ⵜⵇⴻⴱⵍⴻⵎ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC2_39","074_2_39","ACT","2","39","39","ⵎⵉⵏⵣⵉ ⵍⵡⴰⵄⴷ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵉ ⵜⴰⵔⵡⴰ ⵏⵡⴻⵎ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ, ⵉⵏⵏⵉ ⵅ ⵉ ⴷ ⵖⴰ ⵉⵍⴰⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC2_40","074_2_40","ACT","2","40","40","ⵓⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴰⵟⵟⴰⵙ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵇⵏⴻⵄ ⵓ ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵏⴻⵊⵎⴻⵎ ⵣⵉ ⵜⴰⵚⵉⵍⴻⵜ-ⴰ ⵉⴼⴰⵔⵖⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC2_41","074_2_41","ACT","2","41","41","ⵜⵓⵖⴰ ⵊⴰⵔ ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵡⴻⵊⴷⴻⵏ ⴰⴷ ⵇⴻⴱⵍⴻⵏ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵏⵉⵜⵏⵉ. ⵎⵎⴰⵔⵏⵉⵏ-ⴷⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⵄⵍⴰⵃⴰⵍ ⵜⴻⵍⵜ-ⴰⵍⴰⴼ ⵏ ⵍⴻⵄⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("AC2_42","074_2_42","ACT","2","42","42","ⵏⵉⵜⵏⵉ ⵇⵇⵉⵎⴻⵏ ⵚⴱⴰⵔⴻⵏ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵔⵔⵓⵙⵓⵍ ⵓ ⵛⴰⵔⵔⵛⴻⵏ ⴷⵉ ⵜⵥⴰⴵⵉⵜ ⵓ ⴷⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵡⴻⵖⵔⵓⵎ ⵏ ⵏⵏⵉⵄⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC2_43","074_2_43","ACT","2","43","43","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵜⵓⴷⴻⴼ ⵉ-ⵜ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵓⵛⴰ ⵎⵙⴰⵔⴻⵏⵜ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴰⵟⵟⴰⵙ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC2_44","074_2_44","ACT","2","44","44","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⵓⵏⴻⵏ ⵊⵎⵉⵄ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵛⴰⵔⵛ. ");
INSERT INTO rift_vpl VALUES ("AC2_45","074_2_45","ACT","2","45","45","ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⴳⵍⴰ ⵜⵓⵖⴰ ⵣⵣⵏⵓⵣⴰⵏ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴱⴻⵟⵟⴰⵏ ⴰⵔⴱⴻⵃ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵃⴷⴰⵊ ⴽⵓⵍ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("AC2_46","074_2_46","ACT","2","46","46","ⵜⵓⵖⴰ ⵜⵜⵎⵓⵏⴻⵏ ⴽⵓⵍ ⴰⵙⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙ ⴷⵎⴰⵎ ⴷ ⵉⵊⵊⴻⵏ, ⵜⵜⴰⵔⴻⵥⵥⴰⵏ ⴰⵖⵔⵓⵎ ⴷⵉ ⵜⵓⴷⵔⵉⵏ, ⴽⵙⵉⵏ ⵎⴰⵛⵛⴰ ⵏⵙⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵓ ⵙ ⵡⵓⵍ ⵉⵚⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("AC2_47","074_2_47","ACT","2","47","47","ⴰⵎ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⵙⵄⵉⵣⵣⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ⴽⵓⵍ ⴰⵙⵙ ⵜⵓⵖⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵔⴻⵏⵏⵉ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉⵏⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC3_1","074_3_1","ACT","3","1","1","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⵓⵎⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵊⵎⵉⵄ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵜⵥⴰⴵⵉⵜ ⵜⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴷ ⵜⵍⴰⵜⴰ ⴰⵡⴰⵔⵏⵉ ⴹⴹⵀⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("AC3_2","074_3_2","ACT","3","2","2","ⵅⵣⴰⵔ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⴰⵏⴻⵄⴹⴰⴱ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⴰⵔⴱⵓⵏ ⵜ ⵉⵏⵏⵉ ⵉⵏⵏⵓⵎⴻⵏ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⴰⵡⵢⴻⵏ, ⵙⵙⵖⵉⵎⴰⵏ ⵜ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵜⴰⵡⵡⴰⵔⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ’, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⴰⵔ ⵚⵚⴻⴷⵇⴻⵜ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC3_3","074_3_3","ACT","3","3","3","ⴰⵇⴰ ⵡⴰ, ⵓⵎⵉ ⵉⵥⵔⴰ ⴱⴻⵍⵍⵉ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵜⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵏ ⵉⵛⵜ ⵏ ⵚⵚⴻⴷⵇⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC3_4","074_3_4","ACT","3","4","4","ⵛⵉⵎⵄⵓⵏ ⴰⴽ-ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵏⴹⴰⵔⴻⵏ ⴷⴰⵢⴻⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵏⵏⴰⵏ ⴰⵙ: “ⵅⵣⴰⵔ ⴷⴰⵢⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("AC3_5","074_3_5","ACT","3","5","5","ⵏⴻⵜⵜⴰ ⵉⵇⵛⴻⵄ ⴷⴰⵢⵙⴻⵏ, ⵉⵜⵜⵔⴰⵊⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵟⵟⴻⴼ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("AC3_6","074_3_6","ACT","3","6","6","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵡⴰⵔ ⵖⴰⵔⵉ ⴵⵉⵏ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵖⴰⵔⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵡⵛⴻⵖ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴰⵚⵉⵔⵉ! ⴽⴽⴰⵔ, ⵜⵓⵢⵓⵔⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC3_7","074_3_7","ACT","3","7","7","ⵉⵟⵟⴻⴼ ⵉ-ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵓⵛⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⴻⵏⵄⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⵉⵛⴻⵄⴱⵉⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("AC3_8","074_3_8","ACT","3","8","8","ⵓⵛⴰ ⵉⵏⴳⴻⵣ ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⵅ ⵉⴹⴰⵔⴻⵏ, ⵉⴳⴳⵓⵔ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⴰⴽⵉⴷⵙⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⴳⴳⵓⵔ, ⵉⵏⴻⴳⴳⴻⵣ, ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC3_9","074_3_9","ACT","3","9","9","ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵥⵔⴰ ⵉ-ⵜ ⵉⴳⴳⵓⵔ, ⵉⵙⵙⴻⵎⵖⴰⵔⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC3_10","074_3_10","ACT","3","10","10","ⵙⵙⵏⴻⵏ ⵉⵡⴷⴰⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵎⴰⵏ ⵉⵜⵜⴻⵜⵜⴰⵔ ⴽⵓⵍ ⴰⵙⵙ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵜⴰⵚⴻⴱⵃⴰⵏⵜ’ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵡⴻⴷⵀⴰⵛ ⴷ ⵓⵜⴻⴱⵀⴻⵜ ⵅ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC3_11","074_3_11","ACT","3","11","11","ⴰⵎ ⵜⵓⵖⴰ ⴰⵔⵢⴰⵣ ⴰⵏⴻⵄⴹⴰⴱ ⵉⵜⵜⵛⴻⴱⴱⴰⵔ ⴷⵉ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⴷⴷⵓⵇⵇⵣⴻⵏ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵖⴰⵔ ⵓⵙⴻⵇⵇⵉⴼ ⴰⴽ-ⴷ ⵓⴽⵓⵍⵡⴰⵔ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵙⴻⵇⵇⵉⴼ ⵏ ⵙⵓⵍⵉⵎⴰⵏ’, ⵜⴱⴻⵀⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC3_12","074_3_12","ACT","3","12","12","ⵓⵎⵉ ⵉⵥⵔⴰ ⵛⵉⵎⵄⵓⵏ ⴰⵢⴰ, ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵉⴷⴻⵄⵡⴻⵏ ⵜᵉⵜⵜⴱⴻⵀⵜⴻⵎ ⵙ ⵓⵢⴰ? ⵎⴰⵢⴻⵎⵎⵉ ⴷⴰⵢⵏⴻⵖ ⵜⴻⵊⵄⴰⵔⴻⵎ ⴰⵅⵎⵉ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵏⵉⵖ ⵙ ⵚⵚⵓⵍⵟⴰ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵏⴰⵔⵔⴰ ⵉ-ⵜ ⵉⴳⴳⵓⵔ? ");
INSERT INTO rift_vpl VALUES ("AC3_13","074_3_13","ACT","3","13","13","ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵉⵙⵙⵄⵓⴵⴰ ⵎⵎⵉⵙ ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⵜⵙⴻⵍⵍⵎⴻⵎ ⵓ ⵜⵎⴻⵏⴹⴰⵔⴻⵎ ⵣⵣⴰⵜ ⵏ ⵡⵓⴷⴻⵎ ⵏ ⴱⵉⵍⴰⵟⵓⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⵉⵃⴽⴻⵎ ⵙ ⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⴰⵙ ⵢⴰⵔⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("AC3_14","074_3_14","ACT","3","14","14","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⵎ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⵜⵣⴰⵡⴳⴻⵎ ⴰⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛ ⴰⵔⵢⴰⵣ ⴰⵇⴻⵜⵜⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("AC3_15","074_3_15","ACT","3","15","15","ⴰⵇⴰ ⵜⴻⵏⵖⵉⵎ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC3_16","074_3_16","ACT","3","16","16","ⵙ ⵍ’ⵉⵎⴰⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵓ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵏⴻⵜⵜⴰ ⵡⴰ, ⵡⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ, ⵜⴻⵙⵙⵏⴻⵎ ⵜ. ⵍ’ⵉⵎⴰⵏ ⴷⴰⵢⴻⵙ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⴳⴻⵏⴼⵉ-ⵢⴰ ⵣⵣⴰⵜⵡⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC3_17","074_3_17","ACT","3","17","17","ⵍⴻⵅⵅⵓ, ⴰ ⴰⵢⵜⵎⴰ, ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵜⴻⴳⴳⵉⵎ ⴰⵢⴰ ⵙ ⵜⵇⵓⴱⴱⴰⵏⴻⵛⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴳⴳⵉⵏ ⵓⵍⴰ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("AC3_18","074_3_18","ACT","3","18","18","ⴰⵎⵎⵓ ⴰⵇⴰ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵣⵡⴰⵔ ⵉⵅⴻⴱⴱⴰⵔ ⵅⴰⵙ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵎⴰⵙⵉⵃ ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("AC3_19","074_3_19","ACT","3","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⴱⴻⵎ, ⵜⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵜⵡⴰⵎⴻⵙⵃⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("AC3_20","074_3_20","ACT","3","20","20","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵡⴻⵏⵏⵉ ⵉⵡⴻⵊⴷⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵎⴰⵏ ⴰⵢⴰ: ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("AC3_21","074_3_21","ACT","3","21","21","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⵜ ⵉⵇⴱⴻⵍ ⴰⵍ ⵓⴽⴻⵎⵎⴻⵍ ⵏ ⵣⵣⵎⴰⵏⴰⵜ, ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⵔⴻⴱⴱⵉ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉ ⵣⵣⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC3_22","074_3_22","ACT","3","22","22","ⵎⴰⵖⴰⵔ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: ‘ⵙⵉⴷⵉ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⴰⵎ ⵏⴻⵛⵛ ⵣⴻⴳ ⵡⴰⵡⵎⴰⵜⵡⴻⵎ. ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵖⴰ ⵜⴻⵙⵍⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵅⴻⴼ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ.’ ");
INSERT INTO rift_vpl VALUES ("AC3_23","074_3_23","ACT","3","23","23","ⴰⴷ ⵢⵉⵍⵉ ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵉ ⵡⴰⵔ ⵉⵙⵍⵉⵏ ⵖⴰⵔ ⵓⵏⴰⴱⵉ ⵏⵏⵉ, ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵀⴻⵍⵍⴻⴽ ⵣⴻⴳ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("AC3_24","074_3_24","ACT","3","24","24","ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵣⵉ ⵛⴰⵎⵡⵉⵍ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵅⴻⵍⴼⴻⵏ, ⴰⵇⴰ ⵉⵣⵡⴰⵔⴻⵏ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵅ ⵡⵓⵙⵙⴰⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC3_25","074_3_25","ACT","3","25","25","ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵢⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵓ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵉ ⵉⴱⵔⴰⵀⵉⵎ: ‘ⵙ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ!’ ");
INSERT INTO rift_vpl VALUES ("AC3_26","074_3_26","ACT","3","26","26","ⵣⵉⵛ ⵉⴳⴳⴰ ⵏⴻⵜⵜⴰ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵍⴻⵅⵅⵓ ⵎⵎⵉⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⵉⴱⴰⵔⴻⴽ, ⵎⴰⵍⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ, ⴰⴷ ⵜᵉⵜⵓⴱⴻⵎ ⵣⵉ ⵍⵖⴰⵔ ⵏⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC4_1","074_4_1","ACT","4","1","1","ⴰⵎ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ, ⵅⴻⵛⵛⴻⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⴽ-ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("AC4_2","074_4_2","ACT","4","2","2","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵅⴻⵢⵢⵇⴻⵏ ⵅⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ, ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵍⴳⴻⵏⵙ ⵓ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵜⴰⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵙ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC4_3","074_4_3","ACT","4","3","3","ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵛⴰ ⵃⴻⴱⴱⵙⴻⵏ ⵜⴻⵏ ⴰⵍ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("AC4_4","074_4_4","ACT","4","4","4","ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴰⵡⴰⵍ-ⴰ ⵓⵎⵏⴻⵏ ⵓ ⵍⵇⴻⴷⴷ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵄⵍⴰⵃⴰⵍ ⵅⴻⵎⵙⴰ-ⴰⵍⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("AC4_5","074_4_5","ACT","4","5","5","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵎⵓⵏⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("AC4_6","074_4_6","ACT","4","6","6","ⵓⵍⴰ ⴷ ⵃⴰⵏⵏⴰⵏ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴷ ⵇⴰⵢⴰⴼⴰ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴷ ⴰⵍⵉⴽⵙⴰⵏⴷⵉⵔ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⵉ ⵍⴰⴵ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC4_7","074_4_7","ACT","4","7","7","ⵓⵎⵉ ⵜⴻⵏ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ, ⵙⵙⴻⵇⵙⴰⵏ ⵜⴻⵏ: “ⵙ ⵎⴰⵏ ⵊⵊⴻⵀⴷ ⵏⵉⵖ ⵙ ⵎⴰⵏ ⵉⵙⴻⵎ ⵉ ⵜⴻⴳⴳⵉⵎ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("AC4_8","074_4_8","ACT","4","8","8","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⵙⵍⴻⵎ, ⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ! ");
INSERT INTO rift_vpl VALUES ("AC4_9","074_4_9","ACT","4","9","9","ⵎⴰⵍⴰ ⴰⵙⵙ-ⴰ ⵏⴻⵜⵜⵡⴰⵃⴽⴻⵎ ⵣⵣⴰⵢⵡⴻⵎ ⵅ ⵍⵅⴰⵔ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵓⵎⴻⵀⵍⵓⵛ, ⵙ ⵎⵉⵏ ⵣⵉ ⵉⴷⵡⴻⵍ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵉⴳⴳⴻⵏⴼⴰ, ");
INSERT INTO rift_vpl VALUES ("AC4_10","074_4_10","ACT","4","10","10","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴷ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ ⴱⴻⵍⵍⵉ ⴰⵔⵢⴰⵣ ⵡⴰⵏⵉⵜⴰ ⵉⴱⴻⴷⴷ ⵣⵣⴰⵜⵡⴻⵎ ⵉⵚⴻⵃⵃ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴰⵚⵉⵔⵉ, ⵡⴻⵏⵏⵉ ⵜⵚⴻⵍⵍⴱⴻⵎ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵡⴰⵀ, ⴰⵇⴰ ⵣⵣⴰⵢⴻⵙ ⵉⴱⴻⴷⴷ ⴰⵔⵢⴰⵣ-ⴰ ⵣⵣⴰⵜⵡⴻⵎ ⵉⵚⴻⵃⵃ. ");
INSERT INTO rift_vpl VALUES ("AC4_11","074_4_11","ACT","4","11","11","ⴷ ⵡⴰ ⴷ ⴰⵥⵔⵓ ⵏⵏⵉ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴱⴻⵏⵏⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵥⵔⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC4_12","074_4_12","ACT","4","12","12","ⴰⵙⴻⵏⵊⴻⵎ ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵉⵊⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵖⵏⵉ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ ⵉ ⵣⵉ ⵖⴰ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC4_13","074_4_13","ACT","4","13","13","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⴰⵡⴰⵍⴻⵏ ⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵓⵛⴰ ⵓⴼⵉⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵎⵓⵙⵏⴰⵡⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵏⵉⵖ ⴷ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⵍⴻⵎⴷⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵜⴱⴻⵀⵜⴻⵏ ⵓⵛⴰ ⵄⴻⵇⵍⴻⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("AC4_14","074_4_14","ACT","4","14","14","ⵏⵉⵜⵏⵉ ⵥⵔⵉⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵜⵓⵖⴰ ⴷ ⴰⵏⴻⵄⴹⴰⴱ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⴳⴳⴻⵏⴼⴰ, ⵉⴱⴻⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC4_15","074_4_15","ACT","4","15","15","ⵓ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵓⵎⵓⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⵓⴼⴼⵖⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵊⵎⴰⵄⴻⵜ ⵏⵙⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⵛⴰⵡⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("AC4_16","074_4_16","ACT","4","16","16","“ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⵙ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ? ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵎⵍⵉⵃ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵜⴻⵎⵙⴰⵔ ⵙ ⵓⴼⵓⵙ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵏⴻⵏⴽⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC4_17","074_4_17","ACT","4","17","17","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵍⴻⵅⴱⴰⵔ-ⴰ ⴽⵜⴰⵔ ⵊⴰⵔ ⵡⴻⵢⴷⵓⴷ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⵉⴳⴳⵯⴻⴷ ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ-ⴰ, ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC4_18","074_4_18","ACT","4","18","18","ⵅⴰⵙ ⵓⵛⴰ ⵍⴰⵖⴰⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵓⵎⵓⵔⴻⵏ ⵜⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⵡⴰⵔ ⵙⵙⴻⵍⵎⵉⴷⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("AC4_19","074_4_19","ACT","4","19","19","ⵎⴰⵛⴰ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙⴻⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵃⴻⴽⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵎⴰ ⵉⵃⵉⵇⵇ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵙⴻⵍ ⴽⵜⴰⵔ ⵉ ⴽⴻⵏⵏⵉⵡ ⵅ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("AC4_20","074_4_20","ACT","4","20","20","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵡⵉⵍ ⵅ ⵎⵉⵏ ⵏⴻⵥⵔⴰ ⵓ ⵅ ⵎⵉⵏ ⵏⴻⵙⵍⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC4_21","074_4_21","ACT","4","21","21","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏ ⵜⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ, ⵅⴻⵏⵏⵉ ⵊⵊⵉⵏ ⵜⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵎⵉⵏ ⵣⵉ ⵜⴻⵏ ⵉ ⵖⴰ ⵄⴰⵇⴱⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵡⴷⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵜⵓⵖⴰ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC4_22","074_4_22","ACT","4","22","22","ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴳⴳ ⵍⴻⵄⵍⴰⵎⴻⵜ-ⴰ ⵏ ⵓⴳⴻⵏⴼⵉ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴽⵜⴰⵔ ⵣⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("AC4_23","074_4_23","ACT","4","23","23","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙⴻⵏ ⴰⵔⵅⵓⵏ, ⵔⵓⵃⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵜⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵏⵏⴰⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("AC4_24","074_4_24","ACT","4","24","24","ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⴷⵎⴰⵎ ⴷ ⵉⵊⵊⴻⵏ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⴷ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⴱⵃⵓⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("AC4_25","074_4_25","ACT","4","25","25","ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵛ ⴷⴰⵡⵓⴷ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵖⴻⵡⵡⵖⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⵔⵔⵚⴻⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵎⵉⵏ ⵉⵅⵡⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("AC4_26","074_4_26","ACT","4","26","26","ⴰⵇⴰ ⴽⴽⴰⵔⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵎⵛⴰⵡⴰⵔⴻⵏ ⴹⵉⴷⴷ ⵏ ⵙⵉⴷⵉ ⵓ ⴹⵉⴷⴷ ⵏ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴻⵙ.’ ");
INSERT INTO rift_vpl VALUES ("AC4_27","074_4_27","ACT","4","27","27","ⵎⵉⵏⵣⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵀⵉⵔⵓⴷⵓⵙ ⴷ ⴱⵓⵏⵟⵉⵢⵓⵙ ⴱⵉⵍⴰⵟⵓⵙ ⴷ ⵍⴻⴳⵏⵓⵙ ⴷ ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵎⵓⵏⴻⵏ ⵅ ⵎⵎⵉⵛ ⵏⵏⴻⵛ ⴰⵎⵇⴻⴷⴷⴰⵙ ⵢⴰⵙⵓⵄ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵎⴻⵙⵃⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("AC4_28","074_4_28","ACT","4","28","28","ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵣⵡⴰⵔ ⵉⵏⴻⵢⵢⴻⵛ ⵓⴼⵓⵙ ⵏⵏⴻⵛ ⴷ ⵛⵛⵡⴰⵔ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("AC4_29","074_4_29","ACT","4","29","29","ⵄⴰⴷ ⵍⴻⵅⵅⵓ, ⴰ ⵙⵉⴷⵉ, ⵅⵣⴰⵔ ⵖⴰⵔ ⵓⵙⵉⴳⴳⵯⴻⴷ ⵏⵙⴻⵏ ⵓⵛⴰ ⴻⵡⵛ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⵙ ⵜⴰⵔⵢⴰⵙⵜ, ");
INSERT INTO rift_vpl VALUES ("AC4_30","074_4_30","ACT","4","30","30","ⴰⵎ ⵜⴻⵙⵙⵡⵉⵥⵥⴹⴻⴷ ⴰⴼⵓⵙ ⵏⵏⴻⵛ ⵉ ⵓⵙⴳⴻⵏⴼⵉ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏⵜ ⵜⵉⵎⴻⴳⴳⴰ ⵊⴻⵀⴷⴻⵏⵜ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵎⵎⵉⵛ ⵏⵏⴻⵛ ⴰⵎⵇⴻⴷⴷⴰⵙ: ⵢⴰⵙⵓⵄ.” ");
INSERT INTO rift_vpl VALUES ("AC4_31","074_4_31","ACT","4","31","31","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵜⴰⵥⴰⴵⵉⵜ ⴷ ⵜⴽⴻⵙⵙⵉⵜ ⵙ ⵍⵎⴻⵄⵔⵓⴼ, ⵉⵏⵀⴻⵣⵣ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ, ⵓ ⵎⴰⵔⵔⴰ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⴻⵔⵢⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("AC4_32","074_4_32","ACT","4","32","32","ⵓⵛⴰ ⵍⵖⴰⵛⵉ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵜⵓⵖⴰ ⵙ ⵍⴻⵄⵎⴰⵔ ⴷ ⵓⵅⴰⵔⵔⴻⵚ ⴷ ⵉⵊⵊⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵇⵇⴰⵔ ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵇⴰ ⵉ ⵏⴻⵜⵜⴰ ⵡⴻⵃⵃⴷⴻⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵛⴰⵔⵛⴻⵏ ⴷⵉ ⴽⵓⵍⵛⵉ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC4_33","074_4_33","ACT","4","33","33","ⵜⵓⵖⴰ ⵔⵔⵓⵙⵓⵍ ⵏⵏⵉ ⵛⴻⵀⵀⴷⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵊⵊⴻⵀⴷ ⵉⵎⵖⴰⵔ ⵅ ⵜⵏⵓⴽⵔⴰ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⴰⵔⴹⴰ ⵉⵎⵖⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC4_34","074_4_34","ACT","4","34","34","ⵡⴰⵔ ⵜⵓⵖⵉ ⵊⴰⵔ ⴰⵙⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷⴰⵢⴻⵙ ⵍⴻⵅⵚⴻⵚ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵉⵖ ⵜⵓⴷⵔⵉⵏ ⵣⵣⵏⵓⵣⴰⵏ ⵜⴻⵏ, ⵓⵛⴰ ⵜⵜⴰⵡⵢⴻⵏ-ⴷⴷ ⵜⵜⴰⵎⴰⵏ ⵏ ⵎⵉⵏ ⵣⵣⵏⵓⵣⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("AC4_35","074_4_35","ACT","4","35","35","ⵙⵙⵔⵓⵙⴰⵏ ⵜ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ. ⵏⵉⵜⵏⵉ ⴱⴹⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵃⵡⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("AC4_36","074_4_36","ACT","4","36","36","ⵢⵓⵙⵓⴼ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵍⴰⵖⴰⵏ ⵔⵔⵓⵙⵓⵍ ⴱⴰⵔ-ⵏⴰⴱⴰⵙ, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵎⵎⵉⵙ ⵏ ⵓⴼⴻⵡⵡⴻⵊ’, ⵏⴻⵜⵜⴰ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ, ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⵇⵓⴱⵔⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("AC4_37","074_4_37","ACT","4","37","37","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵉⵢⵢⴰⵔ, ⵉⵣⵣⴻⵏⵣ ⵉ-ⵜ ⵓⵛⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵜⵎⴻⵏⵢⴰⵜ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏⵜ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC5_1","074_5_1","ACT","5","1","1","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵏⴰⵏⵉⵢⴰⵙ, ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵙⴰⴼⴼⵉⵔⴰ, ⵉⵣⵣⴻⵏⵣ ⵉⵢⵢⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC5_2","074_5_2","ACT","5","2","2","ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵢⴻⵢⵢⴰⵔ, ⴰⵎ ⵜⴻⵙⵙⴻⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⵉⵙⵙⵏⵓⴼⴰⵔ ⵉ-ⵜ. ⵅⴰⵙ ⵓⵛⴰ ⵢⵉⵡⵉ-ⴷⴷ ⵛⴰ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵣⵣⴰⵢⴻⵙ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⵜ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC5_3","074_5_3","ACT","5","3","3","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⴰ ⴰⵏⴰⵏⵉⵢⴰⵙ, ⵎⴰⵢⴻⵎⵎⵉ ⵉⵛⵛⵓⵔ ⵛⵛⵉⵟⴰⵏ ⵓⵍ ⵏⵏⴻⵛ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵅⴰⵔⵇⴻⴷ ⵅ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵏⵓⴼⴼⴰⵔⴻⴷ ⵛⴰ ⵏ ⵜⵎⴻⵏⵢⴰⵜ ⴷⴻⴳ ⵉⵢⵢⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("AC5_4","074_5_4","ACT","5","4","4","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵢⵉⵢⵢⴰⵔ ⵏⵏⴻⵛ ⵇⴱⴻⵍ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⵣ? ⵓ ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⵣ, ⵜⵓⵖⴰ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⵜⴰⵎⴰⵏ ⵏⵏⴻⵙ ⵄⴰⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ! ⵎⵉⵏ ⵛⴻⴽ ⵉⴷⴻⵄⵡⴻⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ? ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵙⵅⴰⵔⵇⴻⴷ ⵛⴰ ⵅ ⵉⵡⴷⴰⵏ ⵎⴰⵛⴰ ⵅ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC5_5","074_5_5","ACT","5","5","5","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵏⴰⵏⵉⵢⴰⵙ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵉⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵎⵎⵓⵜ, ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC5_6","074_5_6","ACT","5","6","6","ⴽⴽⴰⵔⴻⵏ ⵉⴱⵍⵉⵖⴻⵏ, ⵛⴻⴼⵏⴻⵏ ⵜ, ⴰⵔⴱⵓⵏ ⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵏⴻⴹⵍⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC5_7","074_5_7","ACT","5","7","7","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏⵜ ⵄⵍⴰⵃⴰⵍ ⵜⵍⴰⵜⴰ ⵏ ⵜⵙⴰⵄⵄⴻⵜⵉⵏ, ⵜⵓⴷⴻⴼ-ⴷⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_8","074_5_8","ACT","5","8","8","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⵉⵏⵉ ⴰⵢⵉ, ⵎⴰ ⴰⵇⴰ ⵜⴻⵣⵣⴻⵏⵣⴻⵎ ⵉⵢⵢⴰⵔ ⵙ ⵡⴰⵏⴻⵛⵜ ⵓⵢⴰ?” ⵜⴻⵏⵏⴰ ⴰⵙ: “ⵡⴰⵀ, ⵙ ⵡⴰⵏⴻⵛⵜ ⵓⵢⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC5_9","074_5_9","ACT","5","9","9","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵉⴷⴻⵄⵡⴻⵏ ⵜᵉⵜⵜⴰⴼⵇⴻⵎ ⵊⴰⵔ ⴰⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵊⴰⵔⵔⴱⴻⵎ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ? ⵅⵣⴰⵔ, ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⴻⴹⵍⴻⵏ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⴰⴷ ⵛⴻⵎ ⴽⵙⵉⵏ ⴱⴰⵔⵔⴰ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("AC5_10","074_5_10","ACT","5","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵎⵎⵓⵜ. ⵓⴷⴼⴻⵏ-ⴷⴷ ⵉⴱⵍⵉⵖⴻⵏ ⵏⵏⵉ, ⵓⴼⵉⵏ ⵜⵜ ⵜⴻⵎⵎⵓⵜ, ⴽⵙⵉⵏ ⵜⵜ, ⴰⵔⴱⵓⵏ ⵜⵜ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵓⵛⴰ ⵏⴻⴹⵍⴻⵏ ⵜⵜ ⵣⵣⴰⵜ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("AC5_11","074_5_11","ACT","5","11","11","ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵓ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC5_12","074_5_12","ACT","5","12","12","ⵎⵙⴰⵔⴻⵏⵜ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵊⴰⵔ ⵉⵡⴷⴰⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ ⵙ ⵡⵓⵍ ⴷ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵓⵙⴻⵇⵇⵉⴼ ⴰⴽ-ⴷ ⵓⴽⵓⵍⵡⴰⵔ ⴷ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵙⵓⵍⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_13","074_5_13","ACT","5","13","13","ⵎⴰⵛⴰ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⵉⵣⵄⵉⵎ ⵃⴻⴷ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⴳⴳ ⴰⵣⴻⴵⵉⴼ, ⵎⴰⵛⴰ ⵍⴳⴻⵏⵙ ⵉⵡⴻⵇⵇⴰⵔ ⵜⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC5_14","074_5_14","ACT","5","14","14","ⵎⵎⴰⵔⴻⵏⵢⴻⵏ-ⴷⴷ ⴽⵜⴰⵔ ⵄⴰⴷ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵙⵉⴷⵉ, ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("AC5_15","074_5_15","ACT","5","15","15","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵙⵙⵉⵏ ⵉⵎⴻⵀⵍⴰⵛ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵣⵣⵏⴰⵇⵉ, ⵙⵙⵔⵓⵙⴰⵏ ⵜⴻⵏ ⵅ ⵜⴰⵙⵙⵓⵜ ⵃⵉⵎⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵛⵉⵎⵄⵓⵏ, ⴱⴰⵍⴰⴽ ⴰⴷ ⵜⴻⴽⴽ ⵎⵖⵉⵔ ⵜⵉⵍⵉ ⵏⵏⴻⵙ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_16","074_5_16","ACT","5","16","16","ⵓⵙⵉⵏ-ⴷⴷ ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⵏⴻⴷⴷⴰⵎ ⵏⵏⴻⵖⵏⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵎⴻⵀⵍⴰⵛ ⵏⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴳⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_17","074_5_17","ACT","5","17","17","ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⵃⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("AC5_18","074_5_18","ACT","5","18","18","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵅ ⵔⵔⵓⵙⵓⵍ, ⵟⵟⴼⴻⵏ ⵜⴻⵏ ⵓⵛⴰ ⴰⵔⵔⵉⵏ ⵜⴻⵏ ⴷⵉ ⵍⴻⵇⵢⵓⴷ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC5_19","074_5_19","ACT","5","19","19","ⵎⴰⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵢⴰⵔⵣⴻⵎ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴻⵃⴱⴻⵙ ⵙ ⴵⵉⵍⴻⵜ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("AC5_20","074_5_20","ACT","5","20","20","“ⵔⵓⵃⴻⵎ, ⵅⴻⵏⵏⵉ ⵜⴱⴻⴷⴷⴻⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙⵉⵡⵍⴻⵎ ⵉ ⵍⴳⴻⵏⵙ ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏ ⵜⵓⴷⴰⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("AC5_21","074_5_21","ACT","5","21","21","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵡⴻⵏⵇⴰⵔ ⵏ ⵜⴼⵓⵛⵜ, ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴱⴷⴰⵏ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ. ⵎⴰⵛⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ, ⵓⵛⴰ ⵍⴰⵖⴰⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⵅ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵍⴻⵃⴱⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⴰⵡⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_22","074_5_22","ACT","5","22","22","ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⴷⵉⵏⵏⵉ, ⵡⴰⵔ ⵜⴻⵏ ⵓⴼⵉⵏ ⵛⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("AC5_23","074_5_23","ACT","5","23","23","“ⴰⵇⴰ ⵏⵓⴼⴰ ⵍⴻⵃⴱⴻⵙ ⵉⴱⴻⵍⵍⴻⵄ ⵎⵍⵉⵃ ⵓ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⴱⴻⴷⴷⴻⵏ ⴱⴰⵔⵔⴰ ⵖⴰⵔ ⵜⴻⵡⵡⵓⵔⴰ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵏⴰⵔⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ, ⵡⴰⵔ ⴷⵉⵏ ⵏⵓⴼⵉ ⵃⴻⴷ ⴷⴰⵅⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("AC5_24","074_5_24","ACT","5","24","24","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵜⴱⴻⵀⵜⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⵡⴻⴷⴷⴰⵔ ⴰⵙⴻⵏ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_25","074_5_25","ACT","5","25","25","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵅⴻⴱⴱⴰⵔ ⵉ-ⵜⴻⵏ, ⵉⵇⵇⴰⵔ: “ⵅⵣⴰⵔ, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⴻⴳⴳⵉⵎ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⴰⵇⴰ ⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵡⴷⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC5_26","074_5_26","ACT","5","26","26","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⴷⵉⵏ ⵍⵇⵓⵢⴰⴷ ⴰⴽ-ⴷ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵉⵡⵢⴻⵏ ⵜⴻⵏ-ⴷⴷ, ⵡⴰⵔ ⵜ ⴳⴳⵉⵏ ⵙ ⵓⵖⵉⵍ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵇⴰ ⵍⴳⴻⵏⵙ ⴰⴷ ⵜⴻⵏ ⵉⵃⴻⵊⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC5_27","074_5_27","ACT","5","27","27","ⵓⵎⵉ ⵜⴻⵏ ⴷⴷ-ⵉⵡⵢⴻⵏ, ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵇⵇⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("AC5_28","074_5_28","ACT","5","28","28","“ⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵏⵓⵎⵓⵔ ⵙ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵙⵙⵖⴰⵔⴰⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵙ ⵢⵉⵙⴻⵎ-ⴰ? ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵛⵛⵓⵔⴻⵎ ⵓⵔⵛⴰⵍⵉⵎ ⵙ ⵜⵖⵓⵔⵉ ⵏⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⴰⵔⵔⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⴱⵏⴰⴷⴻⵎ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC5_29","074_5_29","ACT","5","29","29","ⵛⵉⵎⵄⵓⵏ ⴷ ⵔⵔⵓⵙⵓⵍ ⴰⵔⵔⵉⵏ-ⴷⴷ, ⵏⵏⴰⵏ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏᵉⵜⵜⴰⵄ ⴰⵔⴻⴱⴱⵉ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_30","074_5_30","ACT","5","30","30","ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⵜⴻⵏⵖⵉⵎ ⴽⴻⵏⵏⵉⵡ, ⵜⵓⵢⵍⴻⵎ ⵜ ⵅ ⵜⴻⴼⵍⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("AC5_31","074_5_31","ACT","5","31","31","ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓⴼⵓⵙⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⵜⵜⵓⴱⴻⵜ ⴷ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵉ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AC5_32","074_5_32","ACT","5","32","32","ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉ ⵢⴻⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵢⵓⵎⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC5_33","074_5_33","ACT","5","33","33","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⵀⴰⵊⴻⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⵜⴻⵎⵛⴰⵡⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_34","074_5_34","ACT","5","34","34","ⵎⴰⵛⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴳⴰⵎⴰⵍⵉⵢⴰⵍ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⵉ-ⵜ. ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⵀⴻⵏ ⵔⵔⵓⵙⵓⵍ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵉ ⵛⵡⴰⵢⵜ ⵏ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("AC5_35","074_5_35","ACT","5","35","35","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵅⵣⴰⵔⴻⵎ ⵎⵍⵉⵃ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⵙ ⵉⵡⴷⴰⵏ-ⴰ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("AC5_36","074_5_36","ACT","5","36","36","ⵎⵉⵏⵣⵉ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ-ⴰ ⵜⵓⵖⴰ ⵉⴽⴽⴰⵔ ⵜⵓⴷⴷⴰⵙ, ⵉⵏⵏⴰ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵛⴰ, ⵍⴻⵚⵇⴻⵏ ⴷⴰⵢⴻⵙ ⵄⵍⴰⵃⴰⵍ ⵛⴰ ⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ⴰⵇⴰ ⵏⵖⵉⵏ ⵜ ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ, ⵉⴽⴻⵎⵎⴻⵍ ⴰⵔⵔⴰⵢ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_37","074_5_37","ACT","5","37","37","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⴽⴽⴰⵔ ⵢⴰⵀⵓⴷⴰ ⴰⵊⴰⵍⵉⵍⵉ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵣⴻⵎⵎⴻⵎ ⵉ ⵓⵅⴻⴵⴻⵚ ⵏ ⴹⴹⴰⵔⵉⴱⴰ ⵉ ⴽⵓⵍ ⵓⵣⴻⴵⵉⴼ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⵉⵙⵙⴻⵖⵡⴰ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵍⴳⴻⵏⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ. ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_38","074_5_38","ACT","5","38","38","ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: “ⵙⴱⴻⵄⵄⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵅ ⵉⵡⴷⴰⵏ-ⴰ, ⵊⵊⴻⵎ ⵜⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴰⵅⴰⵔⵔⴻⵚ-ⴰ ⵏⵉⵖ ⵍⵅⴻⴷⵎⴻⵜ-ⴰ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵉ ⵢⴻⴵⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵇⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("AC5_39","074_5_39","ACT","5","39","39","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ-ⵜ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜ ⵜⴱⴻⵟⵟⵍⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵖ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⴼⵉⵎ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC5_40","074_5_40","ACT","5","40","40","ⴳⴳⵉⵏ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⵍⴰⵖⴰⵏ ⵅ ⵔⵔⵓⵙⵓⵍ, ⵊⵊⵉⵏ ⴰⴷ ⵜⴻⵏ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵄⴻⵍⵎⴻⵏ ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⵄⴰⴷ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ, ⵅⴻⵏⵏⵉ ⴰⵔⵅⵓⵏ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC5_41","074_5_41","ACT","5","41","41","ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⴼⴰⵔⵃⴻⵏ ⵍⴰⵎⵉ ⵓⴼⵉⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⴷ ⵙⴷⴰⵀⴻⴵⴻⵏ ⴰⴱⴻⵀⴷⴻⵍ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC5_42","074_5_42","ACT","5","42","42","ⵡⴰⵔ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵛⴰ ⵣⴻⴳ ⵓⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵎⴽⵓⵍ ⴰⵙⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⴷⵉ ⵜⵓⴷⵔⵉⵏ ⵓ ⵣⴻⴳ ⵓⴱⴰⵔⵔⴻⵃ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC6_1","074_6_1","ACT","6","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴽⵜⴰⵔⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵍⴻⵙ ⵏ ⵉⵢⵓⵏⴰⵏⵉⵢⵢⴻⵏ ⵄⴻⴽⵙⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵍⴻⵙ ⵏ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ⵎⵉⵏⵣⵉ ⵜⵉⵊⵊⴰⵍ ⵏⵙⴻⵏ ⴼⴰⵔⵔⴹⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵣⵣⴰⴷ ⵏ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("AC6_2","074_6_2","ACT","6","2","2","ⵙ ⵓⵢⴰ ⵍⴰⵖⴰⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵔⵔⵓⵙⵓⵍ ⵅ ⵎⴰⵔⵔⴰ ⴰⴳⵔⴰⵡ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵓⵏⴻⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ: “ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵏⵙⴻⵅⵅⴰⵔ ⵟⵟⵡⴰⴱⴻⵍ ⵉ ⵎⴰⵛⵛⴰ ⴰⵎ ⵏᵉⵜⵜⴻⵊⵊⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC6_3","074_6_3","ACT","6","3","3","ⴰⵔⵣⵓⵎ ⵅⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⵓ ⵅⴹⴰⵔⴻⵎ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵜⴻⵛⵏⴰ, ⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⵉⵖⵉⵜ, ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵜⴻⵏ ⵏⴽⴻⵍⵍⴻⴼ ⵅⴻⵏⵏⵉ ⵙ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC6_4","074_6_4","ACT","6","4","4","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵚⴱⴰⵔ ⴷⵉ ⵜⵥⴰⴵⵉⵜ ⵓ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵡⴰⵡⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("AC6_5","074_6_5","ACT","6","5","5","ⵉⵄⵊⴻⴱ ⵡⴰⵡⴰⵍ-ⴰ ⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵉⵅⴹⴰⵔⴻⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ ⴷ ⴱⵔⵓⵅⵓⵔⵓⵙ ⴷ ⵏⵉⴽⴰⵏⵓⵔ ⴷ ⵜⵉⵎⵓⵏ ⴷ ⴱⴰⵔⵎⵉⵏⴰⵙ ⴷ ⵏⵉⴽⵓⵍⴰⵙ, ⵉⵊⵊ ⵏ ⵓⵎⵄⴰⵛⴰⵔ ⵏ ⴷⴷⵉⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵣⵉ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC6_6","074_6_6","ACT","6","6","6","ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵔⵔⵓⵙⵓⵍ ⵓⵛⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵥⵥⵓⴵⴻⵏ, ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC6_7","074_6_7","ACT","6","7","7","ⵜⵓⵖⴰ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰⵎ ⵓ ⵍⵇⴻⴷⴷ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵜⵓⵖⴰ ⵉⵎⴻⵇⵇⴰⵔ ⴰⵟⵟⴰⵙ. ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵟⴰⵄ ⵉ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC6_8","074_6_8","ACT","6","8","8","ⵙⵜⵉⴼⴰⵏⵓⵙ, ⵉⵛⵛⵓⵔ ⵙ ⴰⵔⴹⴰ ⴷ ⵊⵊⴻⵀⴷ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵎⵖⴰⵔⴻⵏⵜ ⵊⴰⵔ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("AC6_9","074_6_9","ACT","6","9","9","ⴽⴽⴰⵔⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵍⵉⴱⴻⵔⵜⵉⵏⵓ’, ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵇⴰⵢⵔⴰⵡⴰⵏ ⴷ ⵉⵙⴽⴰⵏⴷⴰⵔⵉⵢⵢⴰ, ⵓⵍⴰ ⵣⵉ ⴽⵉⵍⵉⴽⵉⵢⴰ ⴷ ⴰⵙⵉⵢⴰ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵇⴰⵛⴰⵃⴻⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC6_10","074_6_10","ACT","6","10","10","ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵄⴻⴽⵙⴻⵏ ⵜⵉⵖⵉⵜ ⴷ ⴰⵔⵔⵓⵃ ⵉ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("AC6_11","074_6_11","ACT","6","11","11","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ, ⵄⴰⵔⵔⵏⴻⵏ ⵜⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⵉⵏ: “ⴰⵇⴰ ⵏⴻⵙⵍⴰ ⴰⵙⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵛⴻⵇⵇⴼⴻⵏ ⴷⵉ ⵎⵓⵙⴰ ⵓ ⴷⵉ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("AC6_12","074_6_12","ACT","6","12","12","ⴰⵇⴰ ⵙⵙⵖⴻⵡⵡⵖⴻⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵓⵛⴰ ⵓⵎⵉ ⵅⴰⵙ ⴷⴷ-ⴷⴷⵓⵇⵇⵣⴻⵏ, ⵟⵟⴼⴻⵏ ⵜ, ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC6_13","074_6_13","ACT","6","13","13","ⴳⴳⵉⵏ ⵍⴻⵛⵀⵓⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵉⵏⵏⵉ ⵉⵏⵏⴰⵏ: “ⴱⵏⴰⴷⴻⵎ-ⴰ ⵡⴰⵔ ⵉⵙⵙⴱⴻⴷⴷⵉ ⴰⴷ ⵉⵛⴻⵇⵇⴻⴼ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC6_14","074_6_14","ACT","6","14","14","ⵎⵉⵏⵣⵉ ⵏⴻⵙⵍⴰ ⴰⵙ ⵉⵇⵇⴰⵔ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵢⴰⵔⴻⴷⴷⴻⴵ ⴰⵎⵛⴰⵏ-ⴰ, ⴰⴷ ⵉⴱⴻⴷⴷⴻⵍ ⵟⵟⴱⴰⵢⴻⵄ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC6_15","074_6_15","ACT","6","15","15","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵍⴽⵓⵔⵙⵉ ⴷⵉ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵃⴻⴽⴽⴰⵔⴻⵏ ⴷⴰⵢⴻⵙ ⵓ ⵥⵔⵉⵏ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴰⵎ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("AC7_1","074_7_1","ACT","7","1","1","ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵏⵏⴰ: “ⵎⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵉⴷⴻⵜⵜ?” ");
INSERT INTO rift_vpl VALUES ("AC7_2","074_7_2","ACT","7","2","2","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵜⵉⴼⴰⵏⵓⵙ: “ⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⴰⵢⵜⵎⴰⵜⵏⴻⵖ ⴷ ⵉⴱⴰⴱⴰⵜⴻⵏ ⵏⵏⴻⵖ, ⵙⵍⴻⵎ! ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵄⵓⴵⵉ ⵉⴹⵀⴰⵔ ⵉ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⴰⵎ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⵉ ⵎⵉⵙⵓⴱⵓⵜⴰⵎⵢⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵎⵓⵔⵜ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⵔⴰⵏ, ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⵃⴰⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_3","074_7_3","ACT","7","3","3","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵙ: ‘ⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⴻⵛ ⵓ ⵣⵉ ⵍⴰⴵ ⵏⵏⴻⵛ, ⵔⵓⵃ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵖⴰ ⵙⵙⴻⵛⵏⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("AC7_4","074_7_4","ACT","7","4","4","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴽⴰⵍⴷⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵣⴷⴻⵖ ⴷⵉ ⵀⴰⵔⴰⵏ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ ⴱⴰⴱⴰⵙ, ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ-ⴰ ⵉ ⴷⵉ ⵜⵣⴻⴷⴷⵖⴻⵎ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC7_5","074_7_5","ACT","7","5","5","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵡⵛⵉ ⵛⴰ ⴷⴰⵢⴻⵙ ⵍⵡⴰⵔⵜ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵚⵓⵔⵉⴼ ⵏ ⵓⴹⴰⵔ, ⵎⴰⵛⴰ ⵉⵡⴰⵄⴷ ⴰⴷ ⴰⵙ ⵜⵜ ⵉⵡⵛ ⴷ ⵍⵡⴰⵔⵜ, ⵉ ⵏⴻⵜⵜⴰ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⵎ ⵡⴰⵔ ⵜⵓⵖⵉ ⵖⴰⵔⴻⵙ ⵄⴰⴷ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("AC7_6","074_7_6","ACT","7","6","6","ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⴻⵙ, ⵉⵏⵏⴰ ⴰⵙ: ‘ⴰⴷ ⵜⵉⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ ⴷ ⴰⵎⵄⴻⵣⵣⴻⴱ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴻⵖⵔⵉⴱⵜ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ, ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵖⴻⵣⵣⴰⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("AC7_7","074_7_7","ACT","7","7","7","ⵓⵛⴰ ⵍⴳⴻⵏⵙ ⵉ ⴷ ⴰⵙ ⵖⴰ ⵄⴻⴱⴷⴻⵏ ⴰⵎ ⵢⵉⵙⴻⵎⵖⴰⵏ, ⴰⴷ ⵜ ⵃⴰⵙⴱⴻⵖ.’ ⵓⵛⴰ ⵢⴰⵔⵏⵉ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ‘ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴼⴼⵖⴻⵏ, ⴰⴷ ⴰⵢⵉ ⵄⴻⴱⴷⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ-ⴰ’. ");
INSERT INTO rift_vpl VALUES ("AC7_8","074_7_8","ACT","7","8","8","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⵍⵄⴰⵀⴷ ⵏ ⵡⴻⵅⵜⴰⵏ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵊⵊⴰ-ⴷⴷ ⵉⵙⵃⴰⵇ ⵓⵛⴰ ⵉⵅⵜⴻⵏ ⵉ-ⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵓⵛⴰ ⵉⵙⵃⴰⵇ ⵉⵊⵊⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ, ⵢⴰⵄⵇⵓⴱ ⵉⵊⵊⴰ-ⴷⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC7_9","074_7_9","ACT","7","9","9","ⵍⴻⵊⴷⵓⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵖⴰⵔⵔⴻⵏ ⵣⵉ ⵢⵓⵙⵓⴼ ⵓⵛⴰ ⵣⵣⴻⵏⵣⴻⵏ ⵜ ⵖⴰⵔ ⵎⵉⵚⵔⴰ. ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("AC7_10","074_7_10","ACT","7","10","10","ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉ-ⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⵔⴹⴰ ⴷ ⵜⵉⵖⵉⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⴼⵉⵔⵄⵓⵏ, ⴰⵊⴻⴵⵉⴷ ⵏ ⵎⵉⵚⵔⴰ, ⵓⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵎⵉⵚⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC7_11","074_7_11","ACT","7","11","11","ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵍⴰⵥ ⴷ ⵉⵛⵜ ⵏ ⵍⵎⴻⵃⵏⴻⵜ ⵜⴻⵎⵖⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵡⴰⵔ ⵜⵓⵖⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵊⵉⵡⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_12","074_7_12","ACT","7","12","12","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵙⵍⴰ ⵢⴰⵄⵇⵓⴱ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵍⵃⴻⴱⴱ ⴷⵉ ⵎⵉⵚⵔⴰ, ⵉⵙⵙⴻⴽⴽ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴷⵉⵏⵏⵉ ⵉ ⵓⵎⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("AC7_13","074_7_13","ACT","7","13","13","ⵍⴰⵎⵉ ⴷⵉⵏ ⵔⵓⵃⴻⵏ ⵉ ⵓⵎⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵙⵙⴻⴹⵀⴰⵔ ⵢⵓⵙⵓⴼ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵢⴰⵢⵜⵎⴰⵙ ⵓⵛⴰ ⵢⴰⵔⴳⴻⴱ ⴼⵉⵔⵄⵓⵏ ⵅ ⵍⴰⴵ ⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("AC7_14","074_7_14","ACT","7","14","14","ⵉⵙⵙⴻⴽⴽ ⵢⵓⵙⵓⴼ, ⵢⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴱⴰⴱⴰⵙ ⵢⴰⵄⵇⵓⴱ ⴷ ⵎⴰⵔⵔⴰ ⵍⴰⴵ ⵏⵏⴻⵙ: ⵅⴻⵎⵙⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵍⴻⵄⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("AC7_15","074_7_15","ACT","7","15","15","ⵉⵀⵡⴰ-ⴷⴷ ⵢⴰⵄⵇⵓⴱ ⵖⴰⵔ ⵎⵉⵚⵔⴰ, ⵉⵎⵎⵓⵜ ⵏⴻⵜⵜⴰ ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC7_16","074_7_16","ACT","7","16","16","ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵛⴰⴽⵉⵎ, ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⵏⵏⵉ ⵉⵙⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵜⵜⴰⵎⴰⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵃⴰⵎⵓⵔ, ⴱⴰⴱⴰⵙ ⵏ ⵛⴰⴽⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC7_17","074_7_17","ACT","7","17","17","ⵎⴰⵛⴰ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵉⵡⴻⴹ ⵍⵡⴻⵇⵜ ⵉ ⵜⵓⵖⴰ ⵉⵡⴰⵄⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵜⵓⵖⴰ ⵉⴳⴰⵎ ⵍⴳⴻⵏⵙ, ⵉⴷⵡⴻⵍ ⵉⵊⵀⴻⴷ ⴷⵉ ⵎⵉⵚⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("AC7_18","074_7_18","ACT","7","18","18","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵏⵏⴻⵖⵏⵉ ⵅ ⵎⵉⵚⵔⴰ ⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵢⵓⵙⵓⴼ. ");
INSERT INTO rift_vpl VALUES ("AC7_19","074_7_19","ACT","7","19","19","ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⵙ ⵍⴻⵖⴷⴰⵔ ⴰⴽ-ⴷ ⵊⵊⴰⴷⵉⵔⴰ ⵏⵏⴻⵖ ⵓⵛⴰ ⵉⵖⴻⵣⵣⴰ ⵅ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ⵢⵓⵎⵓⵔ ⵉ-ⵜⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴹⴰⵔⴻⵏ ⵉⵙⴻⵢⵎⴰⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵖⵉⵎⵉⵏ ⴰⴷ ⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_20","074_7_20","ACT","7","20","20","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⵅⵍⴻⵇ-ⴷⴷ ⵎⵓⵙⴰ, ⵢⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵙⵙⴻⵢⵎⴻⵏ ⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_21","074_7_21","ACT","7","21","21","ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔ ⵣⴻⴳ ⵢⴻⵎⵎⴰⵙ ⴷⴻⴳ ⵉⵖⵣⴰⵔ, ⵜⵓⴼⴰ ⵉ-ⵜ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ, ⵜⴻⵙⵙⴻⵢⴻⵎ ⵉ-ⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC7_22","074_7_22","ACT","7","22","22","ⵉⵜⵜⵡⴰⵙⵙⵖⴰⵔ ⵎⵓⵙⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ ⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵇⴻⴷⴷⴰ ⵅ ⵡⴰⵡⴰⵍ ⵓ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("AC7_23","074_7_23","ACT","7","23","23","ⴰⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⴹⴰⵔ-ⴷⴷ ⵅⴰⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⴻⴼ ⴰⵢⵜⵎⴰⵙ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AC7_24","074_7_24","ACT","7","24","24","ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵇⴰ ⴹⴻⴵⴻⵏ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵙ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵏⴻⵙ, ⵉⵅⵍⴻⴼ ⵣⵣⴰⵢⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ⵉⴳⴳⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵍⵇⴰⴹⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵏⵖⴰ ⴰⵎⵉⵚⵔⵉ ⵏⵏⵉ ⵜ ⵉⴹⴻⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_25","074_7_25","ACT","7","25","25","ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰ ⴱⴻⵍⵍⵉ ⵜⴰⵡⵎⴰⵜ ⵏⵏⴻⵙ, ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⴷ ⴼⴻⵀⵎⴻⵏ ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵉⵡⵉⴹ ⴰⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_26","074_7_26","ACT","7","26","26","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴹⵀⴰⵔ ⴰⵙⴻⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵎⴻⵏⵖⴰⵏ. ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⴻⵙⵙⴻⵚⵍⴰⵃⴻⵏ, ⵉⵇⵇⴰⵔ: ‘ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵡⵎⴰⵜⴻⵏ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵄⴻⴷⴷⴰⵎ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ?’ ");
INSERT INTO rift_vpl VALUES ("AC7_27","074_7_27","ACT","7","27","27","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ ⵅ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵙ, ⵉⵄⴰⵔⵔⴻⵏ ⵉ-ⵜ, ⵉⵇⵇⴰⵔ: ‘ⵡⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ ⵅⴰⵏⴻⵖ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⵍⵇⴰⴹⵉ? ");
INSERT INTO rift_vpl VALUES ("AC7_28","074_7_28","ACT","7","28","28","ⵎⴰ ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵖⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏⵖⵉⴷ ⵉⴹⴻⵏⵏⴰⴹ ⴰⵎⵉⵚⵔⵉ?’ ");
INSERT INTO rift_vpl VALUES ("AC7_29","074_7_29","ACT","7","29","29","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⴰⵔⵡⴻⵍ ⵎⵓⵙⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍ-ⴰ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵄⴻⵣⵣⴻⴱ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⴷⵢⴰⵏ ⵎⴰⵏⵉ ⴷⴷ-ⵢⴻⵊⵊⴰ ⵜⵏⴰⵢⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_30","074_7_30","ACT","7","30","30","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵉ ⵏⴻⵜⵜⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵉⴱⴰⵏ ⴰⵙ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵍⴻⵅⵍⴰ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⴷⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_31","074_7_31","ACT","7","31","31","ⵓⵎⵉ ⵉⵥⵔⴰ ⵎⵓⵙⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵜⴻⴱⵀⴻⵜ ⵙ ⵍⴻⵡⵃⵉⵢ ⵉ ⵉⵥⵔⴰ, ⵓⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⴰⵔ, ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ: ");
INSERT INTO rift_vpl VALUES ("AC7_32","074_7_32","ACT","7","32","32","‘ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵏ ⵉⵙⵃⴰⵇ ⵓ ⵏ ⵢⴰⵄⵇⵓⴱ!’ ⵉⴱⴷⴰ ⵎⵓⵙⴰ ⵉⵜⵜⴰⵔⵊⵉⵊⵉ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵉⵣⵄⵉⵎ ⴰⴷ ⵉⵅⵣⴰⵔ ⵖⴰⵔ ⵍⴻⵡⵃⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("AC7_33","074_7_33","ACT","7","33","33","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉ: ‘ⴽⴽⴻⵙ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵛ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵎⵉⵅⴻⴼ ⵜⴱⴻⴷⴷⴻⴷ ⵜⵇⴻⴷⴷⴻⵙ ⵉ ⵜⴻⴵⴰ.’ ");
INSERT INTO rift_vpl VALUES ("AC7_34","074_7_34","ACT","7","34","34","ⴰⵇⴰ ⵥⵔⵉⵖ ⵍⵎⴻⵃⵏⴻⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⴷⵉ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵙⵍⵉⵖ ⵉ ⵓⵣⴻⵀⵀⴰⵔ ⵏⵙⴻⵏ, ⵀⵡⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵙⵙⵏⴻⵊⵎⴻⵖ. ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⴰⵙ-ⴷⴷ ⴷⴰ, ⴰⴷ ⴷⴷ ⵛⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⵎⵉⵚⵔⴰ.’ ");
INSERT INTO rift_vpl VALUES ("AC7_35","074_7_35","ACT","7","35","35","ⵎⵓⵙⴰ ⵡⴰⵏⵉⵜⴰ, ⵡⴻⵏⵏⵉ ⵉⵏⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵎⵉ ⵏⵏⴰⵏ: ‘ⵡⵉ ⵛⴻⴽ ⵉⴳⴳⵉⵏ ⵅⴰⵏⴻⵖ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⵍⵇⴰⴹⵉ?’, ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔⵙⴻⵏ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⵓⵎⵙⴻⵏⵊⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⴹⵀⴰⵔⴻⵏ ⴷⵉ ⵛⴱⴰⵔⵇ ⴰⴽ-ⴷ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_36","074_7_36","ACT","7","36","36","ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⴰⵎ ⵉⴳⴳⴰ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⴷ ⵜⵎⴻⴳⴳⴰ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⵏ ⵓⵖⴰⵏⵉⵎ ⵓ ⴷⵉ ⵍⴻⵅⵍⴰ ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("AC7_37","074_7_37","ACT","7","37","37","ⵡⴰ ⴷ ⵎⵓⵙⴰ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵡⴻⵎ, ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⴰⵎ ⵏⴻⵛⵛ ⵣⵉ ⵜⴰⵡⵎⴰⵜ ⵏⵡⴻⵎ. ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵍⴰⵎ!’ ");
INSERT INTO rift_vpl VALUES ("AC7_38","074_7_38","ACT","7","38","38","ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ-ⵜ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵍⴳⴻⵏⵙ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⴽ-ⴷ ⵍⵎⴰⵍⴰⴽ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⵓⵍⴰ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵟⵟⴻⴼ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⵏ ⵢⴻⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("AC7_39","074_7_39","ACT","7","39","39","ⵎⴰⵛⴰ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⴰⵙ ⵎⵎⴰⵔⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵙⵙⵜⴻⵡⵡⵊⴻⵏ ⵜ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵎⵉⵚⵔⴰ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_40","074_7_40","ACT","7","40","40","ⵎⴰⵖⴰⵔ ⵏⵏⴰⵏ ⵉ ⵀⴰⵔⵓⵏ: ‘ⴻⴳⴳ ⴰⵏⴻⵖ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵣⵡⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵡⴰⵏⵉⵜⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴻⵡⵡⴷⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵙⴰⵔⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AC7_41","074_7_41","ACT","7","41","41","ⴳⴳⵉⵏ ⵉⵊⵊ ⵏ ⵓⴼⵓⵏⴰⵙ ⵏ ⵚⵚⴰⵏⴰⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵉⵖⴰⵔⵚⴰ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵓⵛⴰ ⴼⴰⵔⵃⴻⵏ ⵙ ⵎⵉⵏ ⴳⴳⵉⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_42","074_7_42","ACT","7","42","42","ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵙ ⵡⴻⵄⵔⵓⵔ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵓⵔⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ: ‘ⵎⴰⵢⴻⵎⵎⵉ ⵜⵉⵡⵢⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵣⴻⵄⵎⴰ ⵉⵎⵎⵓⴷⴰⵔⴻⵏ ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ? ");
INSERT INTO rift_vpl VALUES ("AC7_43","074_7_43","ACT","7","43","43","ⴰⵇⴰ ⵜⵉⵡⵢⴻⵎ-ⴷⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵎⴰⵍⴽⵓⵎ, ⴷ ⵉⵜⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵔⵉⵎⴼⴰⵏ, ⵍⴻⵅⵢⴰⵍⴰⵜ ⵉ ⵜⴻⴳⴳⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵜⵄⴻⴱⴷⴻⵎ. ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴱⴻⵄⵄⴷⴻⵖ ⴰⵖⵉⵔⵉⵏ ⵇⴰⵄ ⵉ ⴱⴰⴱⵉⵍ.’ ");
INSERT INTO rift_vpl VALUES ("AC7_44","074_7_44","ACT","7","44","44","ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵜⵓⵖⴰ-ⵜⵜ ⴷⵉ ⵍⴻⵅⵍⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵏⴻⵜⵜⴰ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽ-ⴷ ⵎⵓⵙⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⵅ ⵓⵎⴻⴷⵢⴰ ⵉ ⴷ ⴰⵙ ⵉⵙⵙⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC7_45","074_7_45","ACT","7","45","45","ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⴰⴽ-ⴷ ⵢⴰⵛⵓⵡⴰ ⵙⵙⵉⴷⴼⴻⵏ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ-ⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⵡⴰⵔⵜ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⴰⵔⴱⵓⵏ ⵜⵜ ⴰⵍ ⵡⵓⵙⵙⴰⵏ ⵏ ⴷⴰⵡⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("AC7_46","074_7_46","ACT","7","46","46","ⵡⴰⵏⵉⵜⴰ ⵢⵓⴼⴰ ⴰⵔⴹⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵜⵜⴰⵔ ⴰⵙ ⴰⴷ ⵢⴰⴼ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵢⴰⵄⵇⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("AC7_47","074_7_47","ACT","7","47","47","ⵎⴰⵛⴰ ⵙⵓⵍⵉⵎⴰⵏ ⵉⴱⵏⴰ ⴰⵙ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC7_48","074_7_48","ACT","7","48","48","ⵎⴰⵛⴰ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ ⵡⴰⵔ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵇⵇⴰⵔ ⵓⵏⴰⴱⵉ: ");
INSERT INTO rift_vpl VALUES ("AC7_49","074_7_49","ACT","7","49","49","‘ⴰⵊⴻⵏⵏⴰ ⴷ ⵍⵄⴰⵔⵛ ⵉⵏⵓ ⵓ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵉⵏⵓ. ⵎⴰⵏⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵜⴻⴱⵏⴰⵎ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵏⵉⵖ ⵎⴰⵏⵉ ⴰⵎⵛⴰⵏ ⵏ ⴰⵔⵔⴰⵃⴻⵜ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("AC7_50","074_7_50","ACT","7","50","50","ⵎⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵓⴼⵓⵙ ⵉⵏⵓ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ?’ ");
INSERT INTO rift_vpl VALUES ("AC7_51","074_7_51","ACT","7","51","51","ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵏⵏⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵏ ⵡⵓⵍ ⴷ ⵓⵜⴻⵙⵍⵉ, ⵍⴻⴱⴷⴰ ⵜᵉⵜⵜⴻⵎⵄⴰⵍⴰⵎ ⵅ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("AC7_52","074_7_52","ACT","7","52","52","ⵎⴰⵏ ⵡⴻⵏ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵎⴰⵔⵔⵜⴻⵏ ⵓ ⵡⴰⵔ ⵜⴻⵏ ⵏⵖⵉⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵣⵡⴰⵔⴻⵏ ⴱⴰⵔⵔⵃⴻⵏ ⵅ ⵜⵡⴰⵙⵉⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ, ⵡⴻⵏⵏⵉ ⵜⵙⴻⵍⵍⵎⴻⵎ, ⵜⴻⵏⵖⵉⵎ ⵜ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("AC7_53","074_7_53","ACT","7","53","53","ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⵍⵓⵎⵓⵔ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵟⵟⵉⴼⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC7_54","074_7_54","ACT","7","54","54","ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⴷⴷⵓⵇⵇⵣⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵓⵅⴻⵢⵢⴻⵇ, ⵖⴻⵥⵥⴻⵏ ⵜⵉⵖⵎⴰⵙ ⵏⵙⴻⵏ ⵖⴰⵔⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC7_55","074_7_55","ACT","7","55","55","ⵎⴰⵛⴰ ⴰⵎ ⵜⵓⵖⴰ ⵉⵛⵛⵓⵔ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⴽⴻⵙⵙⵉ ⵏⴻⵜⵜⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵥⵔⴰ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵢⴰⵙⵓⵄ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("AC7_56","074_7_56","ACT","7","56","56","ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵜⵜⵡⴰⵍⵉⵖ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵔⵣⵎⴻⵏ ⵓ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC7_57","074_7_57","ACT","7","57","57","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ, ⴰⵎ ⵙⵖⵓⵢⵢⵓⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵇⵇⵏⴻⵏ ⵉⵎⴻⵊⵊⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵀⴻⵊⵎⴻⵏ ⵅⴰⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC7_58","074_7_58","ACT","7","58","58","ⵜⵟⴼⴻⵏ ⵜ, ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴱⴷⴰⵏ ⵜⵜⵃⴻⵊⵊⴰⵔⴻⵏ ⵜ ⵓ ⵍⴻⵛⵀⵓⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⴱⵍⵉⵖ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC7_59","074_7_59","ACT","7","59","59","ⵜⵓⵖⴰ ⵜⵜⵃⴻⵊⵊⴰⵔⴻⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ ⴰⵎ ⵉⵜⵜⵍⴰⵖⴰ, ⵉⵇⵇⴰⵔ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⵟⵟⴻⴼ ⴰⵔⵔⵓⵃ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("AC7_60","074_7_60","ACT","7","60","60","ⵅⴻⵏⵏⵉ ⵉⵡⴹⴰ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵙⵖⵓⵢ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ, ⵉⵏⵏⴰ: “ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⵜⵃⴰⵙⴰⴱ ⴷⴷⵏⵓⴱ-ⴰ!” ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵟⵟⴻⵚ ⵙ ⵢⵉⴹⴻⵙ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("AC8_1","074_8_1","ACT","8","1","1","ⵛⴰⵡⵓⵍ ⵢⴰⵔⴹⴰ ⵅ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵛⴰⵔⵛ ⴷⴻⴳ ⵓⵏⴻⵇⵇⵉ ⵏⵏⴻⵙ. ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵔⴻⵜ ⵉⵎⵖⴰⵔ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ ⵖⴰⵔ ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷ ⵙⴰⵎⴰⵔⵢⴰ, ⵎⵖⵉⵔ ⵔⵔⵓⵙⵓⵍ ⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("AC8_2","074_8_2","ACT","8","2","2","ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵢⵓⵎⵏⴻⵏ ⴽⵙⵉⵏ ⵜ, ⴰⵔⴱⵓⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ ⵖⴰⵔ ⵡⴻⵏⴹⴻⵍ ⵓⵛⴰ ⴳⴳⵉⵏ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵡⴻⵛⴹⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC8_3","074_8_3","ACT","8","3","3","ⵎⴰⵛⴰ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵉⵜⵜⴷⴰⵔⵔⴻⵛ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵅⵎⵉ ⵉⵜⵜⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵓⴷⵔⵉⵏ, ⵉⵜⵜⵊⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵉⵏⴻⴷⴷⴻⵀ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC8_4","074_8_4","ACT","8","4","4","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ, ⵜⵜⴻⵏⵏⴹⴻⵏ, ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC8_5","074_8_5","ACT","8","5","5","ⴰⵎⵓ ⵉⵀⵡⴰ-ⴷⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ, ⵉⴱⴰⵔⵔⴻⵃ ⵉ-ⵜⴻⵏ ⵙ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC8_6","074_8_6","ACT","8","6","6","ⵓⵎⵉ ⵙⵍⵉⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⵉⵡⴷⴰⵏ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵣⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵎⴰⵖⴰⵔ ⵥⵔⵉⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("AC8_7","074_8_7","ACT","8","7","7","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵣⵉ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ, ⵙⵖⵓⵢⵢⵓⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ⵉⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵓⵖⴰ ⴷ ⵉⵏⴻⵄⴹⴰⴱⴻⵏ ⴷ ⵉⵇⴻⵊⴷⴰⵃⴻⵏ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC8_8","074_8_8","ACT","8","8","8","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴻⵎⵖⴰⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC8_9","074_8_9","ACT","8","9","9","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵎⵓⵏ, ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⵖⴻⴽⴽⵡⴰ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ ⵙ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵜⵜⴱⴰⵔⵔⴻⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC8_10","074_8_10","ACT","8","10","10","ⵎⴰⵔⵔⴰ ⵙⵍⵉⵏ ⵖⴰⵔⴻⵙ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ, ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵏⵏⴰⵏ: “ⵡⴰⵏⵉⵜⴰ ⴷ ⵊⵊⴻⵀⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC8_11","074_8_11","ACT","8","11","11","ⵉⵙⵙⴻⵇⵏⴻⵄ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⵊⴻⴼ ⵉ-ⵜⴻⵏ ⵙ ⵙⵙⵃⵓⵔ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("AC8_12","074_8_12","ACT","8","12","12","ⵎⴰⵛⴰ ⵓⵎⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵎ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⵎ ⵜⴻⵎⵖⴰⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC8_13","074_8_13","ACT","8","13","13","ⵛⵉⵎⵓⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵄⴰⵡⴻⴷ ⵢⵓⵎⴻⵏ, ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⴹⴻⴼⴼⴰⵔ ⴼⵉⵍⵉⴱⴱⵓⵙ. ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉⵎⵖⴰⵔⴻⵏ ⵉ ⵉⵎⵙⴰⵔⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵜⴻⴱⵀⴻⵜ, ⵢⴰⵔⵊⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("AC8_14","074_8_14","ACT","8","14","14","ⵓⵎⵉ ⵙⵍⵉⵏ ⵔⵔⵓⵙⵓⵍ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵍⴳⴻⵏⵙ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵉⵇⴱⴻⵍ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ ⴷ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC8_15","074_8_15","ACT","8","15","15","ⵏⵉⵜⵏⵉ ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ, ⵥⵥⵓⴵⴻⵏ ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC8_16","074_8_16","ACT","8","16","16","ⵎⵉⵏⵣⵉ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵅ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ, ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵡⴰⵀⴰ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("AC8_17","074_8_17","ACT","8","17","17","ⵅⴻⵏⵏⵉ ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵟⵟⴼⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC8_18","074_8_18","ACT","8","18","18","ⵓⵎⵉ ⵉⵥⵔⴰ ⵛⵉⵎⵓⵏ ⴱⴻⵍⵍⵉ ⵙ ⵓⵙⴰⵔⵙⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ ⵉⵎⵎⴻⵡⵛ ⴰⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵅⵙ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵜⵎⴻⵏⵢⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("AC8_19","074_8_19","ACT","8","19","19","ⵉⵏⵏⴰ: “ⴻⵡⵛ ⴰⵢⵉ ⵄⴰⵡⴻⴷ ⵚⵚⵓⵍⵟⴰ-ⵢⴰ, ⵃⵉⵎⴰ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵅ ⵖⴰ ⵙⵙⴰⵔⵙⴻⵖ ⴰⴼⵓⵙ ⵉⵏⵓ, ⴰⴷ ⵉⵇⴱⴻⵍ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC8_20","074_8_20","ACT","8","20","20","ⵎⴰⵛⴰ ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ: “ⴰⴷ ⵜᵉⵜⵜⴻⵃⵃⴰ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵏⴻⵛ ⴰⴽⵉⴷⴻⴽ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵛ ⴰⴷ ⵜⴽⴻⵙⴱⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵡⴰⴳⵍⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ! ");
INSERT INTO rift_vpl VALUES ("AC8_21","074_8_21","ACT","8","21","21","ⵡⴰⵔ ⵖⴰⵔⴻⴽ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⵓⵍⴰ ⴷ ⵛⴰ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵏⵉⵜⴰ, ⵎⵉⵏⵣⵉ ⵓⵍ ⵏⵏⴻⵛ ⵡⴰⵔ ⵉⴵⵉ ⵉⵙⴻⴳⴳⴻⴷ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC8_22","074_8_22","ACT","8","22","22","ⵜⵓⴱ ⵣⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵏⴻⵛ ⵓⵛⴰ ⵜⵜⴰⵔ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴽ ⵜᵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ-ⴰ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("AC8_23","074_8_23","ACT","8","23","23","ⵎⵉⵏⵣⵉ ⵜⵜⵡⴰⵍⵉⵖ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵡⴹⵉⴷ-ⴷⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵃⵔⵉⵔ ⴷ ⴰⵎⴻⵔⵣⴰⴳ ⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵛⴻⴷⴷⵉ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC8_24","074_8_24","ACT","8","24","24","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵛⵉⵎⵓⵏ, ⵉⵏⵏⴰ: “ⵜⵜⴰⵔⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ ⵅⴰⴼⵉ ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵅⴰⴼⵉ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵜⴻⵏⵏⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC8_25","074_8_25","ACT","8","25","25","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵛⴻⵀⴷⴻⵏ ⵛⵉⵎⵄⵓⵏ ⴷ ⵢⵓⵃⴰⵏⵏⴰ ⵓ ⵙⵙⵍⴻⵎⴷⴻⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴷⵛⵓⵔ ⵏ ⵉⵙⴰⵎⴰⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC8_26","074_8_26","ACT","8","26","26","ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ, ⵜⵔⵓⵃⴻⴷ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⵍⴰ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⵖⴰⵣⵣⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC8_27","074_8_27","ACT","8","27","27","ⵉⴽⴽⴰⵔ ⵉⵔⵓⵃ, ⵓⵛⴰ ⵉⵎⵎⴻⵍⵇⴰ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⵉⵔ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⵓⵛ, ⵉⵊⵊ ⵏ ⵍⴻⵡⵣⵉⵔ ⵏ ⴽⴰⵏⴷⴰⴽⵉ, ⵜⴰⵊⴻⴵⵉⴷⵜ ⵏ ⴰⵢⵜ ⵏ ⴽⵓⵛ. ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴽⵏⵓⵣ ⵏⵏⴻⵙ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵉⵄⴱⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("AC8_28","074_8_28","ACT","8","28","28","ⵓⵎⵉ ⴷⴷ-ⵉⵄⵇⴻⴱ, ⵉⵇⵇⵉⵎ ⵅ ⵉⵊⵊ ⵏ ⵓⴽⴰⵔⵔⵓ, ⵉⵇⵇⴰⵔ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC8_29","074_8_29","ACT","8","29","29","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵔⵔⵓⵃ ⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ: “ⵣⵉⴷ, ⵜⵎⵓⵏⴻⴷ ⴰⴽ-ⴷ ⵓⴽⴰⵔⵔⵓ-ⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC8_30","074_8_30","ACT","8","30","30","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵉⵙⵍⴰ ⴰⵙ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵓⵏⴰⴱⵉ ⵉⵛⴰⵄⵢⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⴼⴻⵀⵎⴻⴷ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ?” ");
INSERT INTO rift_vpl VALUES ("AC8_31","074_8_31","ACT","8","31","31","ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰⵎⵎⴻⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴼⴻⵀⵎⴻⵖ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵃⴻⴷ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵙⴻⴼⵀⴻⵎⴻⵏ?” ⵓⵛⴰ ⵉⵜⵜⴰⵔ ⵣⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵏⵢⴰ ⵓⵛⴰ ⴰⴷ ⴽⵉⵙ ⵉⵇⵇⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC8_32","074_8_32","ACT","8","32","32","ⵓⴷⴻⵎ ⵉ ⵜⵓⵖⴰ ⵉⵇⵇⴰⵔ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⴷ ⵡⴰ: “ⴰⵎⴻⵛⵏⴰⵡ ⵉⵣⵎⴰⵔ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵖⴰⵔ ⵍⴳⵓⵔⵏⴻⵜ ⵉ ⵜⵖⴰⵔⵚⵜ, ⴰⵎⴻⵛⵏⴰⵡ ⵜⴻⵅⵙⵉ ⵜⴻⴳⵏⵓ ⵇⵉⴱⴰⵏⵏⵜ ⵉ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⴵⴰⵙⴻⵏ, ⵡⴰⵔ ⵢⴰⵔⵣⵉⵎ ⵏⴻⵜⵜⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC8_33","074_8_33","ACT","8","33","33","ⴷⴻⴳ ⵓⵙⴻⵃⵇⴰⵔ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵓ ⵣⵉ ⵍⵃⵓⴽⵎ. ⵡⵉ ⵖⴰ ⵉⵄⴰⵡⴷⴻⵏ ⵅ ⴷⴷⵓⵔⵉⵢⴻⵜ ⵏⵏⴻⵙ? ⵎⵉⵏⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC8_34","074_8_34","ACT","8","34","34","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵍⴻⵡⵣⵉⵔ ⵅ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵉⵏⵏⴰ: “ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⵇⵙⵉⵖ, ⵅ ⵡⵉ ⵅⴻⴼ ⵉⵙⵙⴰⵡⴰⵍ ⵓⵏⴰⴱⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵏⵉⵖ ⵅ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ?” ");
INSERT INTO rift_vpl VALUES ("AC8_35","074_8_35","ACT","8","35","35","ⵢⴰⵔⵣⴻⵎ ⴼⵉⵍⵉⴱⴱⵓⵙ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵙ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵙ ⵡⴰⵡⴰⵍ-ⴰ ⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC8_36","074_8_36","ACT","8","36","36","ⴰⵎ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⴵⴰⵏ ⵡⴰⵎⴰⵏ. ⵉⵏⵏⴰ ⵍⴻⵡⵣⵉⵔ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⴰⵎⴰⵏ. ⵎⵉⵏ ⴷⴰⵢⵉ ⵉⵟⵟⴼⴻⵏ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⴻⵖⴹⴰⵚⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("AC8_37","074_8_37","ACT","8","37","37","ⵉⵏⵏⴰ ⴼⵉⵍⵉⴱⴱⵓⵙ: “ⵎⴰⵍⴰ ⵜⵓⵎⵏⴻⴷ ⵙ ⵡⵓⵍ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ, ⵜⵃⴻⴵⴻⵍ!” ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵓⵎⵏⴻⵖ ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC8_38","074_8_38","ACT","8","38","38","ⵢⵓⵎⵓⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵓⴽⴰⵔⵔⵓ, ⵀⵡⴰⵏ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ ⵓⵛⴰ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵉⵙⵙⴻⵖⴹⴻⵚ ⵍⴻⵡⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AC8_39","074_8_39","ACT","8","39","39","ⴰⵍⴰⵎⵉ ⴷⴷ-ⴳⴻⵄⵄⴷⴻⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ, ⵉⵅⴹⴻⴼ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ ⴼⵉⵍⵉⴱⴱⵓⵙ. ⵓⵛⴰ ⵍⴻⵡⵣⵉⵔ ⵡⴰⵔ ⵜ ⵉⵥⵔⵉ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵉⵔⵓⵃ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵙ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC8_40","074_8_40","ACT","8","40","40","ⵎⴰⵛⴰ ⴼⵉⵍⵉⴱⴱⵓⵙ ⵉⵜⵜⵡⴰⴼ ⴷⵉ ⴰⵛⴷⵓⴷ ⵓ ⵙⵙⴻⵏⵏⵉ ⵉⵜⵜⵛⵓⵇⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC9_1","074_9_1","ACT","9","1","1","ⵎⴰⵛⴰ ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵜⵜⵙⵓⴹ ⵙ ⵓⵄⴻⴷⴷⵉ ⴷ ⵍⵎⴻⵡⵜ ⴹⵉⴷⴷ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC9_2","074_9_2","ACT","9","2","2","ⵉⵜⵜⴰⵔ ⵣⴻⴳ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏ ⴷⵉⵎⴰⵛⵇ, ⵎⴰⵃⴻⵏⴷ, ⵎⴰⵍⴰ ⵢⵓⴼⴰ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ‘ⴰⴱⵔⵉⴷ-ⴰ’, ⵉⵔⵢⴰⵣⴻⵏ ⵏⵉⵖ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵏ ⵉⵛⴻⴷⴷ ⵓ ⴰⴷ ⵜⴻⵏ ⴷⴷ-ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC9_3","074_9_3","ACT","9","3","3","ⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵔⵓⵃ, ⵉⵎⵙⴰⵔ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵇⴰⵔⵔⴰⴱ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ, ⵜⴰⵍⵖⴰ-ⴷⴷ ⵅⴰⵙ ⴷⴻⵖⵢⴰ ⵉⵛⵜ ⵏ ⵜⴼⴰⵡⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC9_4","074_9_4","ACT","9","4","4","ⵉⵡⴹⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵅⴻⵏⵏⵉ ⵉⵙⵍⴰ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵇⵇⴰⵔ ⴰⵙ: “ⵛⴰⵡⵓⵍ, ⵛⴰⵡⵓⵍ ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⴼⵉ ⵜⴷⴰⵔⵔⴰⵛⴻⴷ? ⵜⵣⴻⵢⵢⴰⵔⴻⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵎⵉ ⵜⴻⵛⵛⴰⵜⴻⴷ ⴷⵉ ⵙⵍⴻⴽ ⵏ ⴱⵓⵢⴽⵓⵛⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC9_5","074_9_5","ACT","9","5","5","ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ?” ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ: “ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⵅ ⵜⴷⴰⵔⵔⵛⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("AC9_6","074_9_6","ACT","9","6","6","ⴽⴽⴰⵔ, ⵜⵓⴷⴼⴻⴷ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⴰⴷ ⴰⵛ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴷⵉⵏⵏⵉ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⴳⴳⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC9_7","074_9_7","ACT","9","7","7","ⵓⵛⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⴽⵉⵙ ⵉⵙⴰⴼⴰⵔⴻⵏ, ⴱⴻⴷⴷⴻⵏ ⵜⵜⴱⴻⵀⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⵜⵎⵉⵊⵊⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵥⵔⵉⵏ ⵃⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("AC9_8","074_9_8","ACT","9","8","8","ⵉⴽⴽⴰⵔ-ⴷⴷ ⵛⴰⵡⵓⵍ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵅⵅⴰ ⴰⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵍⴰ, ⵓ ⵏⵉⵜⵏⵉ ⴳⴻⵡⵡⴷⴻⵏ ⵜ ⵣⴻⴳ ⵓⴼⵓⵙ, ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("AC9_9","074_9_9","ACT","9","9","9","ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ, ⵡⴰⵔ ⵉⵛⵛⵉ, ⵡⴰⵔ ⵉⵙⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("AC9_10","074_9_10","ACT","9","10","10","ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ ⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴹⴰⵔ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵏⴰⵏⵉⵢⴰⵙ. ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ: “ⴰ ⴰⵏⴰⵏⵉⵢⴰⵙ!” ⵉⵏⵏⴰ ⴰⵙ: “ⴰⵇⴰ ⴰⵢⵉ ⴷⴰ, ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("AC9_11","074_9_11","ACT","9","11","11","ⵉⵏⵏⴰ ⴰⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ: “ⴽⴽⴰⵔ, ⵜⵔⵓⵃⴻⴷ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⴱⵔⵉⴷ ⵉⵙⵙⴻⴳⴳⴷⴻⵏ’, ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵙⴻⵇⵙⴰ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴰⵔⵙⵓⵙ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⴰⵡⵓⵍ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⵥⴰⴵⴰ ⴷⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("AC9_12","074_9_12","ACT","9","12","12","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵏⴰⵏⵉⵢⴰⵙ ⵢⵓⴷⴻⴼ-ⴷⴷ, ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC9_13","074_9_13","ACT","9","13","13","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴰⵏⴰⵏⵉⵢⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵙⵍⵉⵖ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵅ ⵡⴻⵔⵢⴰⵣ-ⴰ, ⵎⴻⵛⵃⴰⵍ ⴷ ⵍⵖⴰⵔ ⵉ ⵉⴳⴳⴰ ⴷⴻⴳ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵛ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC9_14","074_9_14","ACT","9","14","14","ⴰⵇⴰ ⴷⴰ, ⵄⴰⵡⴻⴷ ⴷⴰⵏⵉⵜⴰ ⵖⴰⵔⴻⵙ ⵜⵜⴻⵙⵔⵉⵃ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴻⴱⴱⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("AC9_15","074_9_15","ACT","9","15","15","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ ⵎⵉⵏⵣⵉ ⵡⴰ ⴰⵇⴰ-ⵜ ⵖⴰⵔⵉ ⴷ ⵍⵇⴻⵛⵄⴻⵜ ⵉⴼⴰⵔⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⴱⵓ ⵉⵙⴻⵎ ⵉⵏⵓ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓ ⵖⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓ ⵊⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("AC9_16","074_9_16","ACT","9","16","16","ⵎⵉⵏⵣⵉ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵏⴻⵖ ⵎⴻⵛⵃⴰⵍ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("AC9_17","074_9_17","ACT","9","17","17","ⵉⵔⵓⵃ ⴰⵏⴰⵏⵉⵢⴰⵙ, ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⵓⵎⴰ ⵛⴰⵡⵓⵍ, ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⴷⴷ-ⵉⴹⵀⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉ ⵣⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ, ⵉⵙⵙⴻⴽⴽ ⴰⵢⵉ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵄⴰⵡⴻⴷ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵛⵓⵔⴻⴷ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC9_18","074_9_18","ACT","9","18","18","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵛⴰ ⴰⵎ ⵜⴻⵇⵛⵓⵔⵜ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵜⵜⵡⴰⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("AC9_19","074_9_19","ACT","9","19","19","ⵓⵎⵉ ⵉⵛⵛⴰ, ⵉⵎⵃⴻⴹ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("AC9_20","074_9_20","ACT","9","20","20","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴱⴷⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵅ ⵢⴰⵙⵓⵄ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC9_21","074_9_21","ACT","9","21","21","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰⵏ, ⵜⵜⴱⴻⵀⵜⴻⵏ, ⵇⵇⴰⵔⴻⵏ: “ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰⵏⵉⵜⴰ ⵉ ⵜⵓⵖⴰ ⵉⵎⴰⵔⵔⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ-ⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓ ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰⵏⵉⵜⴰ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵄⴰⴷ ⴷⴰⵏⵉⵜⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⴷ ⵉⵛⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵉⵛⴰⵔⴼ ⵓ ⴰⴷ ⵜⴻⵏ ⵉⴳⴻⵡⵡⴻⴷ ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("AC9_22","074_9_22","ACT","9","22","22","ⵛⴰⵡⵓⵍ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵊⵊⴻⵀⴷ, ⵉⵙⵙⴻⴷⵀⴻⵛ ⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵛⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴻⵛⵛⵓ ⵡⴰⵏⵉⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC9_23","074_9_23","ACT","9","23","23","ⵓⵎⵉ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ, ⴳⴳⵉⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵏⵡⴰⵢ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC9_24","074_9_24","ACT","9","24","24","ⵎⴰⵛⴰ ⵜⴰⵃⵉⵍⴻⵜ ⵏⵙⴻⵏ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ, ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵉ ⵛⴰⵡⵓⵍ. ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵃⴻⵟⵟⴰⵏ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵙ ⵓⵣⵉⵍ ⴷ ⴵⵉⵍⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC9_25","074_9_25","ACT","9","25","25","ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⵜ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⵓⴵⴻⵜ ⵓⵛⴰ ⵙⵙⴻⵀⵡⴰⵏ ⵜ ⵣⵉ ⵍⵃⵉⴹ ⵙ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC9_26","074_9_26","ACT","9","26","26","ⵢⵓⵢⵓⵔ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵢⴰⵔⵣⵓ ⴰⴷ ⵉⵎⵓⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴳⴳⵯⴻⴷⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵡⴰⵔ ⵜⵜⵉⵇⵇⴻⵏ ⵛⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵃⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC9_27","074_9_27","ACT","9","27","27","ⵎⴰⵛⴰ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵉⴽⵙⵉ ⵜ ⵖⴰⵔⴻⵙ ⵓⵛⴰ ⵉⵏⴷⴻⵀ ⵉ-ⵜ ⵖⴰⵔ ⵔⵔⵓⵙⵓⵍ ⵓⵛⴰ ⵛⴰⵡⵓⵍ ⵉⵅⴻⴱⴱⴰⵔ ⵉ-ⵜⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵉⵥⵔⴰ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓ ⵎⴰⵎⵎⴻⵛ ⴽⵉⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵓ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⴷⵉ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("AC9_28","074_9_28","ACT","9","28","28","ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵜⵜⴰⴷⴻⴼ ⵉⵜⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("AC9_29","074_9_29","ACT","9","29","29","ⵓⵛⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ, ⵉⵜⵜⵇⴰⵛⴰⵃ ⴰⴽ-ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵉⵍⴻⵙ ⵏ ⵜⵢⵓⵏⴰⵏⵉⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⵣⵓⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC9_30","074_9_30","ACT","9","30","30","ⵓⵎⵉ ⵙⵙⵏⴻⵏ ⵜⴰⵡⵎⴰⵜ ⵎⴰⵏ ⴰⵢⴰ, ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ ⴷⵉ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵙⴻⴽⴽⴻⵏ ⵜ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴰⵔⵙⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC9_31","074_9_31","ACT","9","31","31","ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷ ⵍⵊⴰⵍⵉⵍ ⴷ ⵙⴰⵎⴰⵔⵢⴰ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⴻⵀⵏⴰ, ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵜⴻⴳⴳⵓⵔ ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵔⵓⵃ ⴷⵉ ⵜⵢⵓⵎⵉ ⵙ ⵓⴼⴻⵡⵡⴻⵊ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC9_32","074_9_32","ACT","9","32","32","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⵉⴳⴳⵓⵔ ⴷⵉ ⵜⵏⴻⴷⴷⴰⵎ, ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵍⵉⴷⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("AC9_33","074_9_33","ACT","9","33","33","ⵢⵓⴼⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵏⵉⵢⴰⵙ, ⵉⵣⵣⴻⵍ ⵙ ⵜⴰⵙⵙⵓⵜ ⵓ ⵜⴻⵄⴷⵓ ⵅⴰⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⴰⵏⴻⵄⴹⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("AC9_34","074_9_34","ACT","9","34","34","ⵉⵏⵏⴰ ⴰⵙ ⵛⵉⵎⵄⵓⵏ: “ⴰ ⴰⵏⵉⵢⴰⵙ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴳⴻⵏⴼⴰ. ⴽⴽⴰⵔ, ⵜⴻⵙⵙⵓⴷ ⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵛ!” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC9_35","074_9_35","ACT","9","35","35","ⵓⵛⴰ ⵥⵔⵉⵏ ⵜ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵍⵉⴷⴷⴰ ⴷ ⵙⴰⵔⵓⵏ, ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC9_36","074_9_36","ACT","9","36","36","ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⴰⴼⴼⴰ ⵉⵛⵜ ⵏ ⵜⵎⴻⵃⴹⴰⵔⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⴰⴱⵉⵜⴰ, ⵎⴰⵛⴰ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵜⵢⵓⵏⴰⵏⵉⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴷⵓⵔⴽⴰ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⵖⴰⵣⴰⵍⴰ’. ⵜⴰ ⵜⵓⵖⴰ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵉ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⴳⴳ ⵓ ⵙ ⵚⵚⴷⴰⵇⵉ ⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⵓⴼⴼⵓⵖ. ");
INSERT INTO rift_vpl VALUES ("AC9_37","074_9_37","ACT","9","37","37","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵜⴻⵀⵍⴻⵛ ⵓⵛⴰ ⵜⴻⵎⵎⵓⵜ. ⵙⵉⵔⴷⴻⵏ ⵜⵜ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜ ⴷⵉ ⵜⵖⵓⵔⴼⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC9_38","074_9_38","ACT","9","38","38","ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵛⵉⵎⵄⵓⵏ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵍⵉⴷⴷⴰ, ⵜⴻⵏⵏⵉ ⵣⵣⴰⵜ ⵏ ⵢⴰⴼⴼⴰ. ⵅⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵏⵉⵜⵏⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵃⴻⵛⵛⵎⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵢⵓⵢⵓⵔ! ");
INSERT INTO rift_vpl VALUES ("AC9_39","074_9_39","ACT","9","39","39","ⵉⴽⴽⴰⵔ ⵛⵉⵎⵄⵓⵏ, ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵙⴻⵏ. ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ, ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵜⵖⵓⵔⴼⴻⵜ ⵙⴻⵏⵏⴻⵊ. ⴱⴻⴷⴷⴻⵏⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵊⵊⴰⵍ, ⵔⵓⵏⵜ, ⵙⵙⵛⴰⵏⴻⵏⵜ ⴰⵙ ⵜⵛⴰⵎⵉⵔⴰⵜ ⴷ ⵉⵊⴻⴵⴰⴱⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏⵜ ⵜⴻⵡⵛⴰ ⵜⴰⴱⵉⵜⴰ ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ-ⵜⵜ ⵄⴰⴷ ⵜⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC9_40","074_9_40","ACT","9","40","40","ⵎⴰⵛⴰ ⵛⵉⵎⵄⵓⵏ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵙⵊⴻⴷ, ⵉⵥⵥⵓⴵ ⵓⵛⴰ ⵉⵏⵏⴻⵇⵍⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵍⵅⴻⵛⴱⴻⵜ ⵉⵏⵏⴰ: “ⵜⴰⴱⵉⵜⴰ, ⴽⴽⴰⵔ!” ⵏⴻⵜⵜⴰⵜ ⵜⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵍⴰⵎⵉ ⵜⴻⵥⵔⴰ ⵛⵉⵎⵄⵓⵏ, ⵜⴻⵇⵇⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC9_41","074_9_41","ACT","9","41","41","ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵖⴰⵔⴻⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜⵜ-ⵉ-ⴷ, ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵜⵉⵊⵊⴰⵍ, ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵜⵜ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵜⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC9_42","074_9_42","ACT","9","42","42","ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ-ⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵓⵎⵏⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC9_43","074_9_43","ACT","9","43","43","ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵢⴰⴼⴼⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵔⵓⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵄⴻⴷⴷⴻⵍ ⵉⵍⵎⴰⵡⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("AC10_1","074_10_1","ACT","10","1","1","ⵜⵓⵖⴰ ⴷⵉ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ, ⵉⵏⵏⵉ ⵣⵉ ⵍⴽⵓⵎⴱⴰⵏⵉⵢⵢⴻⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⵟⴰⵍⵢⴰⵏ’. ");
INSERT INTO rift_vpl VALUES ("AC10_2","074_10_2","ACT","10","2","2","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴻⵇⵇⴰⵔ ⵓ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ, ⵉⵜⵜⵉⵛ ⴰⵟⵟⴰⵙ ⵏ ⵚⵚⴷⴰⵇⵉ ⵉ ⵉⵡⴷⴰⵏ ⵓⵛⴰ ⵉⴽⴻⵙⵙⵉ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⵉ ⴰⵔⴻⴱⴱⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("AC10_3","074_10_3","ACT","10","3","3","ⵡⴰ ⵉⵥⵔⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵉⵚⴼⴰ ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵡⴰⵙⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵓⵣⵉⵍ, ⵉⵏⵏⴰ ⴰⵙ: “ⴰ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ!” ");
INSERT INTO rift_vpl VALUES ("AC10_4","074_10_4","ACT","10","4","4","ⵓⵎⵉ ⴷⴰⵢⴻⵙ ⵉⵏⴹⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ, ⵉⴳⴳⵯⴻⴷ ⴰⵟⵟⴰⵙ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴷⵉⵏ, ⴰ ⵙⵉⴷⵉ?” ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ: “ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⵏⵏⴻⵛ ⴷ ⵚⵚⴷⴰⵇⵉ ⵏⵏⴻⵛ ⵉⵡⴹⴻⵏⵜ ⵖⴰⵔ ⵍⵉⴷⴰⵔⴻⵜ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC10_5","074_10_5","ACT","10","5","5","ⵙⵙⴻⴽⴽ ⵍⴻⵅⵅⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵖⴰⵔ ⵢⴰⴼⴼⴰ, ⵜⵄⴰⵔⴹⴻⴷ ⵅ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⴱⵓⵟⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_6","074_10_6","ACT","10","6","6","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⴼ ⵖⴰⵔ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵉⵍⵎⴰⵡⴻⵏ, ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("AC10_7","074_10_7","ACT","10","7","7","ⵓⵎⵉ ⵉⵔⵓⵃ ⵍⵎⴰⵍⴰⴽ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⴻⵙ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵉⵍⴰⵖⴰ ⵏⴻⵜⵜⴰ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓ ⵅ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵟⴰⵄ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_8","074_10_8","ACT","10","8","8","ⵉⵀⴰⵊⴰ ⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵥⵔⴰ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵢⴰⴼⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("AC10_9","074_10_9","ACT","10","9","9","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⴳⴻⵄⵄⴻⴷ ⵛⵉⵎⵄⵓⵏ ⵅ ⵜⵣⴻⵇⵇⴰ ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴹⴹⵀⵓⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵥⵥⴰⴵ. ");
INSERT INTO rift_vpl VALUES ("AC10_10","074_10_10","ACT","10","10","10","ⵉⴵⵓⵥ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⵉ ⴰⴷ ⵉⵛⵛ, ⵓⵛⴰ, ⴰⵎ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵙⵙⴻⵡⵊⴰⴷⴻⵏ, ⵉⵡⵢⵉ ⵜ ⵍⴻⵡⵃⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("AC10_11","074_10_11","ACT","10","11","11","ⵉⵥⵔⴰ ⴰⵊⴻⵏⵏⴰ ⵢⴰⵔⵣⴻⵎ ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⵛⵓⵇⵇⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⵉ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵙ, ⵜⴻⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC10_12","074_10_12","ACT","10","12","12","ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC10_13","074_10_13","ACT","10","13","13","ⵜⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ, ⵜⴻⵇⵇⴰⵔ ⴰⵙ-ⴷⴷ: “ⴰ ⵛⵉⵎⵄⵓⵏ, ⴽⴽⴰⵔ, ⵖⴰⵔⵚ, ⵜⴻⵛⵛⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC10_14","074_10_14","ACT","10","14","14","ⵎⴰⵛⴰ ⵛⵉⵎⵄⵓⵏ ⵉⵏⵏⴰ: “ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵛⵛⵉⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵃⵔⴰⵎ ⵓⵍⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵣⴷⵉⴳⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC10_15","074_10_15","ACT","10","15","15","ⵜⵎⵉⵊⵊⴰ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵜⴻⵇⵇⴰⵔ: “ⵎⵉⵏ ⵉⵙⵙⵉⵣⴷⴻⴳ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴷⴷ ⵜ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⵛⴰ ⵛⴻⴽ ⴷ ⵍⴻⵃⵔⴰⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC10_16","074_10_16","ACT","10","16","16","ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵍⴻⵏ, ⵓⵛⴰ ⴷⴻⵖⵢⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⴰⵊⴰⵔⵜⵉⵍⵜ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC10_17","074_10_17","ACT","10","17","17","ⴰⵎ ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⵄⴰⴷ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵍⴻⵡⵃⵉⵢ ⵉ ⵉⵥⵔⴰ, ⵅⵣⴰⵔ, ⵓⵙⵉⵏ-ⴷⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵣⵉ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ, ⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⵛⵉⵎⵄⵓⵏ. ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("AC10_18","074_10_18","ACT","10","18","18","ⵍⴰⵖⴰⵏ, ⵙⵙⴻⵇⵙⴰⵏ: “ⵎⴰ ⵛⵉⵎⵄⵓⵏ, ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ⴱⵓⵟⵔⵓⵙ, ⴰⵇⴰ-ⵜ ⴷⴰⵏⵉⵜⴰ?” ");
INSERT INTO rift_vpl VALUES ("AC10_19","074_10_19","ACT","10","19","19","ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⵄⴰⴷ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⴷⵉ ⵍⴻⵡⵃⵉⵢ ⵉ ⵉⵥⵔⴰ, ⵉⵏⵏⴰ ⴰⵙ ⴰⵔⵔⵓⵃ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⴽ! ");
INSERT INTO rift_vpl VALUES ("AC10_20","074_10_20","ACT","10","20","20","ⴽⴽⴰⵔ, ⵜⴻⵀⵡⵉⴷ-ⴷⴷ, ⵔⵓⵃ ⴰⴽⵉⴷⵙⴻⵏ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵜⵛⴻⴽⴽⴻⴷ ⴷⵉ ⵛⴰ, ⵎⵉⵏⵣⵉ ⴷ ⵏⴻⵛⵛ ⵉ-ⵜⴻⵏ-ⴷⴷ-ⵉⵙⵙⴻⴽⴽⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC10_21","074_10_21","ACT","10","21","21","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵀⵡⴰ ⵛⵉⵎⵄⵓⵏ ⵖⴰⵔ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵜⴰⵔⴻⵣⵣⵓⵎ. ⵎⵉⵏ ⵖⴰⵔ ⴷⴷ-ⵜⵓⵙⵉⵎ ⴷⴰ?” ");
INSERT INTO rift_vpl VALUES ("AC10_22","074_10_22","ACT","10","22","22","ⵏⵏⴰⵏ ⴰⵙ: “ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ, ⵉⵊⵊ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⴻⴳⴳⴻⴷ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵉⵛⴻⵀⵀⴻⴷ ⵎⵍⵉⵃ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵜⵓⵖⴰ ⵉⵄⵍⴻⵎ ⴰⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴷⴷ-ⴰⵢⵡⵢⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵉⵙⴻⵍ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC10_23","074_10_23","ACT","10","23","23","ⵛⵉⵎⵄⵓⵏ ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵉⴳⴳⴰ ⵜⴻⵏ ⴷ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ ⵎⴰⵏⵉ ⵉⵇⵇⵉⵎ. ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⴽⴽⴰⵔ, ⵉⵔⵓⵃ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⵛⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵢⴰⴼⴼⴰ ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_24","074_10_24","ACT","10","24","24","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ. ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵜⴻⵏ ⴰⵎ ⵙⵙⵎⵓⵏⴰⵏ ⵖⴰⵔⴻⵙ ⵎⴰⵔⵔⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵍⴰⴵ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵢⵓⴷⵙⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_25","074_10_25","ACT","10","25","25","ⵓⵎⵉ ⵢⵓⴷⴻⴼ ⵛⵉⵎⵄⵓⵏ, ⵉⵍⵇⴰ ⵜ-ⵉ-ⴷⴷ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ, ⵉⵡⴹⴰ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵙⵊⴻⴷ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_26","074_10_26","ACT","10","26","26","ⵎⴰⵛⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ ⴰⵙ: “ⴽⴽⴰⵔ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴷ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵛⴻⴽ!” ");
INSERT INTO rift_vpl VALUES ("AC10_27","074_10_27","ACT","10","27","27","ⴰⵎ ⴽⵉⴷⴻⵙ ⵉⵙⵙⴰⵡⴰⵍ, ⵢⵓⴷⴻⴼ ⵓⵛⴰ ⵢⵓⴼⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵜⵜⵎⵓⵏⴰⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC10_28","074_10_28","ACT","10","28","28","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵡⴰⵔ ⵉⵃⴻⴵⴻⵔ ⵅ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ ⴰⴷ ⵉⵎⵓⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵇⵇⴰⵔⵚⴻⵏ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵍⴰⵖⵉⵖ ⵓⵍⴰ ⵅ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵅⵎⴻⵊ ⵏⵉⵖ ⴷ ⵍⴻⵃⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("AC10_29","074_10_29","ACT","10","29","29","ⵙ ⵓⵢⴻⵏⵏⵉ ⵓⵙⵉⵖ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴷⴰ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵛⴻⴽⴽⴻⵖ ⴷⵉ ⵛⴰ ⵓⵎⵉ ⵅⴰⴼⵉ ⵜⵄⴰⵔⴹⴻⴷ. ⵎⴰⵛⴰ ⵅⵙⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵇⵙⵉⵖ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("AC10_30","074_10_30","ACT","10","30","30","ⵉⵏⵏⴰ ⴰⵙ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ: “ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵥⵓⵎⵎⴻⵖ, ⵓⵛⴰ ⵅⵣⴰⵔ, ⵖⴰⵔ ⵜⵙⴰⵄⵄⴻⵜ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵥⴰⴵⵉⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵇⵉⴱⴰⵍⵜ ⵉⵏⵓ ⵙ ⵡⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ! ");
INSERT INTO rift_vpl VALUES ("AC10_31","074_10_31","ACT","10","31","31","ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴰ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ, ⵜⴰⵥⴰⴵⵉⵜ ⵏⵏⴻⵛ ⵜᵉⵜⵜⵡⴰⵙⴻⵍ ⵓ ⵚⵚⴷⴰⵇⵉ ⵏⵏⴻⵛ ⵉⵡⴹⴻⵏⵜ ⵖⴰⵔ ⵍⵉⴷⴰⵔⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC10_32","074_10_32","ACT","10","32","32","ⵙⴻⴽⴽ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵢⴰⴼⴼⴰ, ⵜⵄⴰⵔⴹⴻⴷ ⵅ ⵛⵉⵎⵄⵓⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ⴱⵓⵟⵔⵓⵙ. ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵏⴻⵡⵊⵉⵡ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵡⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵍⴻⵏ ⵉⵍⵎⴰⵡⴻⵏ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("AC10_33","074_10_33","ACT","10","33","33","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵖⴰⵔⴻⴽ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓ ⵛⴻⴽ ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⵉⴷ ⴷⴰ. ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⵉ ⴷⴰ ⵏⴻⴵⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵛⴻⴽ, ⵏᵉⵜⵜⴻⵅⵙ ⴰⴷ ⵏⵙⴻⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵛⴻⴽ ⵢⵓⵎⵓⵔ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC10_34","074_10_34","ACT","10","34","34","ⵢⴰⵔⵣⴻⵎ ⵛⵉⵎⵄⵓⵏ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⵓⴼⵉⵖ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC10_35","074_10_35","ACT","10","35","35","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵣⵉ ⴽⵓⵍ ⵍⴳⴻⵏⵙ, ⵢⵓⵙⴰ-ⴷⴷ ⴰⵙ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_36","074_10_36","ACT","10","36","36","ⵎⴰⵖⴰⵔ ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵉ ⵉⵙⵙⴻⴽⴽ ⵖⴰⵔ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⴱⴰⵔⵔⴻⵃ: ⵍⴻⵀⵏⴰ ⴷ ⵍⵀⵓⴷⵏⴻⵜ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC10_37","074_10_37","ACT","10","37","37","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴰⵡⴰⵍ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴱⴷⴰ ⵣⵉ ⵍⵊⴰⵍⵉⵍ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵙⴻⵖⴹⴰⵚ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵢⵓⵃⴰⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("AC10_38","074_10_38","ACT","10","38","38","ⵍⴻⵅⴱⴰⵔ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵣⵉ ⵏⵏⴰⵚⵉⵔⴰ, ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⴷⵀⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵙ ⵊⵊⴻⵀⴷ. ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵉⴳⴳⴰ ⵍⵅⴰⵔ, ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴻⵣⵣⴰⵏ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ-ⵜ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_39","074_10_39","ACT","10","39","39","ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅⴰⵙ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⵇⴰ ⵓⵢⵍⴻⵏ ⵜ ⵡⵓⴷⴰⵢⴻⵏ ⵅ ⵜⴻⵃⵏⴰⵛⵜ, ⵏⵖⵉⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC10_40","074_10_40","ACT","10","40","40","ⵡⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵓⵛⴰ ⵉⵙⵙⴻⴹⵀⴰⵔ ⵉ-ⵜ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ");
INSERT INTO rift_vpl VALUES ("AC10_41","074_10_41","ACT","10","41","41","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵉ ⵍⴻⵛⵀⵓⴷ ⵉⵏⵏⵉ ⵉⵣⵡⴰⵔ ⵉⵅⴹⴰⵔ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉ ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵛⵛⵉⵏ ⵉⵙⵡⵉⵏ ⴰⵡⴰⵔⵏⵉ ⵜⴰⵏⵓⴽⵔⴰ ⵏⵏⴻⵙ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC10_42","074_10_42","ACT","10","42","42","ⵢⵓⵎⵓⵔ ⴰⵏⴻⵖ ⴰⴷ ⵏⴱⴰⵔⵔⴻⵃ ⵓ ⴰⴷ ⵏⴻⵛⵀⴻⴷ ⵉ ⵍⴳⴻⵏⵙ, ⴰⵇⴰ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC10_43","074_10_43","ACT","10","43","43","ⵛⴻⵀⵀⴷⴻⵏ ⵅⴰⵙ ⵎⴰⵔⵔⴰ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⴷ ⴰⵙ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC10_44","074_10_44","ACT","10","44","44","ⴰⵎ ⵜⵓⵖⴰ ⵛⵉⵎⵄⵓⵏ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ, ⵉⵀⵡⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("AC10_45","074_10_45","ACT","10","45","45","ⵜⴰⵡⵎⴰⵜ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽⵉⴷⴻⵙ, ⵜⴱⴻⵀⵜⴻⵏ, ⵓⵎⵉ ⵜⴰⵎⴻⵡⵛⵉ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ ⵄⴰⵡⴻⴷ ⵅ ⵢⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC10_46","074_10_46","ACT","10","46","46","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵏ ⵜⵜⴻⵙⵍⴰⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⵙⵙⵎⴻⵖⵖⴰⵔⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵇⵇⴰⵔ ⵛⵉⵎⵄⵓⵏ: ");
INSERT INTO rift_vpl VALUES ("AC10_47","074_10_47","ACT","10","47","47","“ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⴰⴷ ⵉⵇⴹⴻⵄ ⴰⵎⴰⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⴻⵖⴹⵉⵚⴻⵏ ⵉⵏⴰ? ⵎⴰⵖⴰⵔ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵇⴻⴱⵍⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵏⴻⵛⵛⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC10_48","074_10_48","ACT","10","48","48","ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴰⴷ ⵜⴻⵏ ⵙⵙⵖⴻⴹⵚⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴰⴷ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC11_1","074_11_1","ACT","11","1","1","ⵔⵔⵓⵙⵓⵍ ⴷ ⵜⴰⵡⵎⴰⵜ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⵓⵍⴰ ⴷ ⵍⴻⴳⵏⵓⵙ ⵇⴻⴱⵍⴻⵏ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC11_2","074_11_2","ACT","11","2","2","ⵍⴰⵎⵉ ⵉⴳⴻⵄⵄⴻⴷ ⵛⵉⵎⵄⵓⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵎⵛⵓⴱⴱⵛⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵡⴻⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC11_3","074_11_3","ACT","11","3","3","ⵏⵏⴰⵏ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⵉⵛⵛⴰ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC11_4","074_11_4","ACT","11","4","4","ⵎⴰⵛⴰ ⵛⵉⵎⵄⵓⵏ ⵉⵇⴹⴻⵄ ⴷⴰⵢⵙⴻⵏ ⵍⵀⴰⵔⴷ, ⵓⵛⴰ ⵉⴱⴷⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵄⴰⵡⴻⴷ ⴰⵡⴰⵍ ⵉⴹⴼⴰⵔ ⵓⵎⴰⵙ: ");
INSERT INTO rift_vpl VALUES ("AC11_5","074_11_5","ACT","11","5","5","“ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵢⴰⴼⴼⴰ ⵜⵜⵥⴰⴵⵉⵖ, ⵥⵔⵉⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⴰⵇⴰ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⴰⵎ ⵜⵛⵓⵇⵇⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏⵏⴻⵙ ⵜⴻⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("AC11_6","074_11_6","ACT","11","6","6","ⵅⵣⴰⵔⴻⵖ ⵎⵍⵉⵃ ⵓ ⵥⵔⵉⵖ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⵉⵊⴹⴰⴹ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC11_7","074_11_7","ACT","11","7","7","ⵙⵍⵉⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ, ⵜⴻⵏⵏⴰ ⴰⵢⵉ: ‘ⴰ ⵛⵉⵎⵄⵓⵏ, ⴽⴽⴰⵔ, ⵖⴰⵔⵚ, ⵜⴻⵛⵛⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("AC11_8","074_11_8","ACT","11","8","8","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ: ‘ⵍⵍⴰ, ⴰ ⵙⵉⴷⵉ, ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵄⴰⴷ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵎⵉⵏ ⵡⴰⵔ ⵉⵣⴷⵉⴳⴻⵏ ⵏⵉⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵍⴻⵃⵔⴰⵎ.’ ");
INSERT INTO rift_vpl VALUES ("AC11_9","074_11_9","ACT","11","9","9","ⵜⴻⵏⵏⴰ ⵅⴰⴼⵉ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵄⴰⵡⴻⴷ: ‘ⵎⵉⵏ ⵉⵙⵙⵉⵣⴷⴻⴳ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⴷⴷ ⵜ ⵜᵉⵜⵜⴰⵔⵔⵉⴷ ⵛⴰ ⵛⴻⴽ ⴷ ⵍⴻⵃⵔⴰⵎ!’ ");
INSERT INTO rift_vpl VALUES ("AC11_10","074_11_10","ACT","11","10","10","ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵊⴱⴻⴷ ⵎⴰⵔⵔⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC11_11","074_11_11","ACT","11","11","11","ⵓ ⵅⵣⴰⵔ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵣⵉ ⴽⵓⵔⵏⵉⵍⵉⵢⵓⵙ ⵣⵉ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ, ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ ⵎⴰⵏⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("AC11_12","074_11_12","ACT","11","12","12","ⵉⵏⵏⴰ ⴰⵢⵉ ⴰⵔⵔⵓⵃ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⵉⵙⴻⵏ ⵔⴰⵃⴻⵖ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵛⴻⴽⴽⴻⵖ. ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⵓⵍⴰ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵓ ⵏⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC11_13","074_11_13","ACT","11","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵏⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵉ ⵉⴱⴻⴷⴷⴻⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵏⵏⴰⵏ: ‘ⵙⴻⴽⴽ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵖⴰⵔ ⵢⴰⴼⴼⴰ, ⵜⵄⴰⵔⴹⴻⴷ ⵅ ⵛⵉⵎⵄⵓⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ⴱⵓⵟⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC11_14","074_11_14","ACT","11","14","14","ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵛ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵡⴰⵍⴻⵏ ⵉ ⵣⵉ ⵖⴰ ⵜᵉⵟⵟⴼⴻⴷ ⵜⵓⴷⴰⵔⵜ, ⵛⴻⴽ ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ.’ ");
INSERT INTO rift_vpl VALUES ("AC11_15","074_11_15","ACT","11","15","15","ⵓⵎⵉ ⵇⵇⵉⵎⴻⵖ ⵙⵙⵉⵡⵍⴻⵖ, ⵉⵀⵡⴰ-ⴷⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅⴰⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⵀⵡⴰ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("AC11_16","074_11_16","ACT","11","16","16","ⵜⵜⵡⴰⵙⵙⵄⴻⵇⵍⴻⵖ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ: ‘ⵢⵓⵃⴰⵏⵏⴰ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ ⵙ ⵡⴰⵎⴰⵏ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AC11_17","074_11_17","ACT","11","17","17","ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⵜⴰⵎⴻⵡⵛⵉ-ⵢⴰ ⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵜⵜ ⵉⵡⵛⴰ, ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵄⵏⵉⵖ ⵏⴻⵛⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("AC11_18","074_11_18","ACT","11","18","18","ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵀⴻⴷⴷⵏⴻⵏ, ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵏⴰⵏ: “ⴰⴷ ⵜⴰⵖ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵓⵍⴰ ⵉ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⴰⴷ ⵜⵓⴱⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC11_19","074_11_19","ACT","11","19","19","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⵓⵣⵣⴰⵔⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⵉⵎⵙⴰⵔⴻⵏ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ, ⵥⵡⴰⵏ ⵖⴰⵔ ⴼⵉⵏⵉⵇⵉⵢⴰ ⵓ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵇⵓⴱⵔⵓⵙ ⵓ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ⴰⵎ ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⴰⴽ-ⴷ ⵃⴻⴷ ⵙ ⵡⴰⵡⴰⵍ ⵎⵖⵉⵔ ⴰⴽ-ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("AC11_20","074_11_20","ACT","11","20","20","ⵜⵓⵖⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵇⵓⴱⵔⵓⵙ ⵓ ⵣⵉ ⵇⴰⵢⵔⴰⵡⴰⵏ ⵉⵏⵏⵉ, ⴰⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵉⵢⵓⵏⴰⵏⵉⵢⵢⴻⵏ, ⴱⴰⵔⵔⵃⴻⵏ ⴰⵙⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("AC11_21","074_11_21","ACT","11","21","21","ⵜⵓⵖⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⵓⵎⵏⴻⵏ, ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AC11_22","074_11_22","ACT","11","22","22","ⵉⴽⴽⴰ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ ⵅⴰⵙⴻⵏ ⵅ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⴰⵢⵜ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵏⵉⵜⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC11_23","074_11_23","ACT","11","23","23","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⴷⵉⵏ, ⵉⵥⵔⴰ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵉⴼⴰⵔⵃ, ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵜⵜⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC11_24","074_11_24","ACT","11","24","24","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵔⵢⴰⵣ ⵉⵙⴻⴳⴳⴻⴷ, ⵉⵛⵛⵓⵔ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵍ’ⵉⵎⴰⵏ, ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵡⴷⴰⵏ ⵉⵎⵎⴰⵔⵏⵉ-ⴷⴷ ⵖⴰⵔ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC11_25","074_11_25","ACT","11","25","25","ⵅⴻⵏⵏⵉ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⴰⵔⵙⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵛⴰⵡⵓⵍ, ");
INSERT INTO rift_vpl VALUES ("AC11_26","074_11_26","ACT","11","26","26","ⵓⵛⴰ ⴰⵍⴰⵎⵉ ⵜ ⵢⵓⴼⴰ, ⵢⵉⵡⵉ ⵉ-ⵜ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ. ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵎⵓⵏⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵉⴽⵎⴻⵍ ⵓⵛⴰ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵣⵉ  ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⵜⵡⴰⵙⴻⵎⵎⴰⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴷ ‘ⵉⵎⴰⵙⵉⵃⵉⵢⵢⴻⵏ’ ⵉ ⵓⵎⵓⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("AC11_27","074_11_27","ACT","11","27","27","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵀⵡⴰⵏ-ⴷⴷ ⵛⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC11_28","074_11_28","ACT","11","28","28","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵖⴰⴱⵓⵙ, ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⴱⴻⵍⵍⵉ ⵉⵊⵊ ⵏ ⵍⴰⵥ ⵉⵎⵖⴰⵔ ⴰⴷ ⵢⴻⴽⴽ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵍⴰⵥ-ⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵇⴰⵢⵚⴰⵔ ⴽⵍⵓⴷⵉⵢⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC11_29","074_11_29","ACT","11","29","29","ⵅⴻⵏⵏⵉ ⴳⴳⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴰⵇⴰ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵉⴳⴳ ⵛⴰ ⵏ ⵜⵡⵉⵣⴰ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC11_30","074_11_30","ACT","11","30","30","ⵓⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ, ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵜ ⴷⵉⵏ ⵖⴰⵔ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC12_1","074_12_1","ACT","12","1","1","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵄⵍⴰⵃⴰⵍ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⵀⵉⵔⵓⴷⵓⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴰⵔⴼⴻⵙ ⵅ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC12_2","074_12_2","ACT","12","2","2","ⵉⵏⵖⴰ ⵢⴰⵄⵇⵓⴱ ⵓⵎⴰⵙ ⵏ ⵢⵓⵃⴰⵏⵏⴰ ⵙ ⵙⵙⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("AC12_3","074_12_3","ACT","12","3","3","ⵓⵎⵉ ⵉⵥⵔⴰ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵄⵊⴻⴱ ⴰⵙⴻⵏ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⴽⴻⵎⵎⴻⵍ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵟⵟⴻⴼ ⵓⵍⴰ ⴷ ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ. ⵜⵓⵖⴰ ⴷ ⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("AC12_4","074_12_4","ACT","12","4","4","ⵍⴰⵎⵉ ⵜ ⵉⵟⵟⴻⴼ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵙ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵙⴻⵜⵜⴰ-ⵄⴻⵛⵔⴰ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵄⴻⵙⵙⴻⵏ. ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜ ⵉⵇⴻⴷⴷⴻⵎ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵄⵉⴷ ⵏ ⵜⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("AC12_5","074_12_5","ACT","12","5","5","ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴻⵙⵙⴻⵏ ⵅ ⵛⵉⵎⵄⵓⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵜⵓⵖⴰ ⵜⴻⵥⵥⴰⴵⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC12_6","074_12_6","ACT","12","6","6","ⴷⵉ ⴵⵉⵍⴻⵜ, ⵖⴰⵔ ⵜⵓⴼⴼⵓⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵣⵄⴻⵎ ⵀⵉⵔⵓⴷⵓⵙ ⴰⴷ ⵜ ⵉⵇⴻⴷⴷⴻⵎ, ⵓⵎⵉ ⵉⵟⵟⴻⵚ ⵛⵉⵎⵄⵓⵏ ⴰⵎ ⵜ ⵛⴻⴷⴷⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⵃⴻⵟⵟⴰⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵃⴱⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("AC12_7","074_12_7","ACT","12","7","7","ⵉⴱⴻⴷⴷ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ ⵙⴻⵏⵏⴻⵊ ⵏⵏⴻⵙ ⵓ ⵟⵟⵢⴰ ⵏ ⵜⴼⴰⵡⵜ ⵜᵉⵜⵜⵛⴻⵄⵛⵉⵄ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵅⵅⴰⵎ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵄⴰⵔⵏ ⵉ-ⵜ ⴷⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏⵏⴻⵙ, ⵉⵙⵙⴼⴰⵇ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ ⴷⴻⵖⵢⴰ!” ⴷⴻⵖⵢⴰ ⵡⴹⴰⵏⵜ ⵙⵙⵏⴰⵙⴻⵍ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC12_8","074_12_8","ACT","12","8","8","ⵉⵏⵏⴰ ⴰⵙ ⵍⵎⴰⵍⴰⴽ: “ⴱⵢⴻⵙ, ⵜⴻⵇⵇⵏⴻⴷ ⵜⵉⵙⵉⵍⴰ ⵏⵏⴻⵛ!” ⵉⴳⴳⴰ ⴰⵎⵎⵓ. ⵉⵏⵏⴰ ⴰⵙ ⵅⴻⵏⵏⵉ: “ⴰⵔⴹ ⴰⵊⴻⴵⴰⴱ ⵏⵏⴻⵛ, ⴹⴼⴰⵔ ⴰⵢⵉ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC12_9","074_12_9","ACT","12","9","9","ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ, ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵍⵎⴰⵍⴰⴽ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵉⵥⵔⴰ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ. ");
INSERT INTO rift_vpl VALUES ("AC12_10","074_12_10","ACT","12","10","10","ⴰⵍⴰⵎⵉ ⴽⴽⵉⵏ ⵅ ⵓⵄⴻⵙⵙⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵅ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵜⴻⵏⵏⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ, ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⴰⵙⴻⵏ ⵡⴻⵃⵃⴷⴻⵙ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⴼⴼⵖⴻⵏ, ⵇⴻⴹⵄⴻⵏ ⵉⵛⵜ ⵏ ⵣⵣⴻⵏⵇⴻⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵊⵊⴰ ⵉ-ⵜ ⵍⵎⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("AC12_11","074_12_11","ACT","12","11","11","ⵅⴻⵏⵏⵉ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵛⵉⵎⵄⵓⵏ ⵖⴰⵔ ⵍⴱⴰⵍ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⵙ ⵜⵉⴷⴻⵜⵜ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵀⵉⵔⵓⴷⵓⵙ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⴻⵄⵎⴻⵏ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC12_12","074_12_12","ACT","12","12","12","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵎⴰⵔⵢⴰⵎ, ⵢⴻⵎⵎⴰⵙ ⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⵏⵏⴰⵏ ⵎⴰⵔⴽⵓⵙ, ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵎⵓⵏⴰⵏ ⴰⵟⵟⴰⵙ, ⵜⵜⵥⴰⴵⴰⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC12_13","074_12_13","ACT","12","13","13","ⴰⵍⴰⵎⵉ ⵉⵙⵙⵇⴰⵔⵇⴻⴱ ⴷⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⴱⴰⵔⵔⴰ ⵏ ⵍⴻⵎⵔⴰⵃ, ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵔⵓⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⵍ ⵡⵉ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC12_14","074_12_14","ACT","12","14","14","ⵜⴻⵄⵇⴻⵍ ⵜⵎⵉⵊⵊⴰ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵓⵛⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵡⴰⵔ ⵜⴰⵔⵣⵉⵎ ⵛⴰ ⵜⴻⵡⵡⴰⵔⵜ, ⵎⴰⵛⴰ ⵜⴻⵄⵇⴻⴱ ⴷⴻⵖⵢⴰ ⵓⵛⴰ ⵜⵅⴻⴱⴱⴰⵔ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⵣⴰⵔ, ⵛⵉⵎⵄⵓⵏ, ⴰⵇⴰ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵍⴻⵎⵔⴰⵃ!” ");
INSERT INTO rift_vpl VALUES ("AC12_15","074_12_15","ACT","12","15","15","ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵇⴰ ⵛⴻⵎ ⵜⵅⴻⵍⴼⴻⴷ!” ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵇⵇⴰⵔ ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵏⵉⵛⴰⵏ. ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⴰⴷ ⵜⴰⵖ ⴷ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("AC12_16","074_12_16","ACT","12","16","16","ⵎⴰⵛⴰ ⵛⵉⵎⵄⵓⵏ, ⵉⵇⵇⵉⵎ ⵉⵙⵙⵇⴰⵔⵇⵓⴱ ⵓⵛⴰ ⴼⴼⵖⴻⵏ, ⵥⵔⵉⵏ ⵜ ⵓⵛⴰ ⵜⴱⴻⵀⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC12_17","074_12_17","ACT","12","17","17","ⵉⵛⴻⵢⵢⴰⵔ ⴰⵙⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵙⵇⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵄⴰⵡⴻⴷ ⴰⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵓⴼⴼⴻⵖ ⵙⵉⴷⵉ ⵣⵉ ⵍⴻⵃⴱⴻⵙ, ⵉⵏⵏⴰ: “ⵅⴻⴱⴱⴰⵔⴻⵎ ⵢⴰⵄⵇⵓⴱ ⴷ ⵜⴰⵡⵎⴰⵜ ⵅ ⵓⵢⴰ!” ⵅⴻⵏⵏⵉ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC12_18","074_12_18","ACT","12","18","18","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵣⵉⵍ, ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷⵔⵓⵙⵜ ⵊⴰⵔ ⵍⵄⴻⵙⴽⴰⵔ ⵅ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ ⵉ ⵛⵉⵎⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("AC12_19","074_12_19","ACT","12","19","19","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⵢⴰⵔⴻⵣⵣⵓ ⵀⵉⵔⵓⴷⵓⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵢⵓⴼⵉ, ⵉⵃⴽⴻⵎ ⵅ ⵉⵄⴻⵙⵙⴰⵙⴻⵏ ⵙ ⵍⵎⴻⵡⵜ, ⵉⴼⴼⴻⵖ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵉⵇⵇⵉⵎ ⵉⵣⴻⴷⴷⴻⵖ ⴷⵉ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC12_20","074_12_20","ACT","12","20","20","ⵓⵎⵉ ⵜⵓⵖⴰ ⵍⴻⵄⴷⴰⵡⴻⵜ ⴷⵉ ⵀⵉⵔⵓⴷⵓⵙ ⴹⵉⴷⴷ ⵉ ⴰⵢⵜ ⵏ ⵚⵓⵔ ⴷ ⵚⴰⵢⴷⵓⵏ, ⵎⵓⵏⴻⵏ ⵏⵉⵜⵏⵉ, ⵉⵡⴹⴻⵏ ⴰⴷ ⵙⵙⵇⴻⵏⵄⴻⵏ ⴱⵍⴰⵙⵜⵓⵙ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵓⵊⴻⴵⵉⴷ ⵓⵛⴰ ⵜⵜⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⵉⵊⵊ ⵏ ⵡⴻⵚⵍⴰⵃ, ⵎⵉⵏⵣⵉ ⵎⴰⵛⵛⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⵜⴻⴽⴽⴰ-ⴷⴷ ⵣⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵀⵉⵔⵓⴷⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC12_21","074_12_21","ACT","12","21","21","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏ ⵍⴼⴰⵔⵃ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵢⴰⵔⴹ ⵀⵉⵔⵓⴷⵓⵙ ⴰⵊⴻⴵⴰⴱ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵎ ⵉⵇⵇⵉⵎ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ, ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵉ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("AC12_22","074_12_22","ACT","12","22","22","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵉⵙⵖⵓⵢ ⵖⴰⵔⴻⵙ: “ⴰⵇⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵏ ⴱⵏⴰⴷⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC12_23","074_12_23","ACT","12","23","23","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵡⵜⴰ ⵉ-ⵜ ⵍⵎⴰⵍⴰⴽ ⵏ ⵙⵉⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵡⵛⵉ ⴰⵄⵓⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵓⵛⴰ ⴷⵍⴻⵏ ⵜ ⵉⴽⴻⵛⵛⴰⵡⴻⵏ, ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ ⴱⵓⵃⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("AC12_24","074_12_24","ACT","12","24","24","ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵣⵣⴰⵢⴻⵙ, ⵉⵎⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC12_25","074_12_25","ACT","12","25","25","ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⵛⴰⵡⵓⵍ ⵄⴻⵇⴱⴻⵏ-ⴷⴷ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⴽⵉⵢⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵜⴽⴻⵏⵏⴰⵏ ⵎⴰⵔⴽⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC13_1","074_13_1","ACT","13","1","1","ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ: ⴱⴰⵔ-ⵏⴰⴱⴰ, ⴷ ⵛⵉⵎⵄⵓⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⵏⵏⴰⵏ ⵏⵉⵊⴻⵔ, ⴷ ⵍⵓⴽⵉⵢⵓⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵇⴰⵢⵔⴰⵡⴰⵏ, ⴷ ⵎⴰⵏⴰⵄⵉⵏ ⵡⴻⵏⵏⵉ ⴷ ⵎⵎⵉⵙ ⵏ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⴰⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵍⵃⴰⴽⴻⵎ ⵅ ⵉⵊⵊ ⵏ ⴰⵔⴱⴰⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴷ ⵛⴰⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC13_2","074_13_2","ACT","13","2","2","ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵥⵓⵎⵎⴰⵏ, ⵜⵜⵣⴰⵡⴳⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⴼⴰⵔⵣⴻⵎ ⴰⵢⵉ-ⴷⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⵛⴰⵡⵓⵍ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵍⴰⵖⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC13_3","074_13_3","ACT","13","3","3","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵥⵓⵎⵎⴻⵏ, ⵥⵥⵓⴵⴻⵏ, ⵙⵙⴰⵔⵙⴻⵏ ⵅⴰⵙⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ, ⵙⴻⴽⴽⴻⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_4","074_13_4","ACT","13","4","4","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔ ⵙⴰⵍⵓⴽⵉⵢⴰ ⵓⵛⴰ ⵙⵙⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵇⵓⴱⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC13_5","074_13_5","ACT","13","5","5","ⵓⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵙⴰⵍⴰⵎⵉⵙ, ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_6","074_13_6","ACT","13","6","6","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵥⵡⴰⵏ ⵎⴰⵔⵔⴰ ⵜⴰⴳⵣⵉⵔⵜ, ⵉⵡⴹⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴱⴰⴼⵓⵙ. ⵏⵉⵜⵏⵉ ⵓⴼⵉⵏ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ, ⵜⵓⵖⴰ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵙⴻⵃⵃⴰⵔ, ⴷ ⴰⵏⴰⴱⵉ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴱⴰⵔ-ⵛⵓⵎⴰ.    ");
INSERT INTO rift_vpl VALUES ("AC13_7","074_13_7","ACT","13","7","7","ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⵓⵏⵜ ⵉⵎⵜⴻⵏ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⵉⵖⵉⵙ, ⵍⵄⴰⵎⵉⵍ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵙⴰⵔⵊⵉⵢⵓⵙ ⴱⵓⵍⵓⵙ. ⵉⵍⴰⵖⴰ-ⴷⴷ ⵍⵄⴰⵎⵉⵍ ⵉ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⵛⴰⵡⵓⵍ, ⵜⵓⵖⴰ ⵉⵎⵎⴻⵥⵔⵉ ⴰⴷ ⵉⵙⴻⵍ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_8","074_13_8","ACT","13","8","8","ⵎⴰⵛⴰ ⴰⵙⴻⵃⵃⴰⵔ ⴱⴰⵔ-ⵛⵓⵎⴰ, ⵉⵙⴻⵎ ⵡⴰⵏⵉⵜⴰ ⵉⵜⵜⵡⴰⵜⴰⵔⵊⴻⵎ ⵙ ‘ⵉⵍⵉⵎⴰⵙ’, ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⴽⴽⴰⵙ ⵉ-ⵜⴻⵏ, ⵢⴰⵔⵣⵓ ⴰⴷ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵍⵡⴰⵍⵉ ⵅ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_9","074_13_9","ACT","13","9","9","ⵎⴰⵛⴰ ⵛⴰⵡⵓⵍ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⴱⵓⵍⵓⵙ, ⵉⵜⵜⵡⴰⵛⵛⵓⵔ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵊⵄⴰⵔ ⴷⴰⵢⴻⵙ ⵎⵍⵉⵃ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("AC13_10","074_13_10","ACT","13","10","10","“ⴰ ⵛⴻⴽ, ⴰⵇⴰ ⵜⴻⵛⵛⵓⵔⴻⴷ ⵙ ⴽⵓⵍ ⵍⵖⴻⵛⵛ ⴷ ⴽⵓⵍ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ, ⴰ ⵛⴻⴽ ⵎⵎⵉⵙ ⵏ ⵉⴱⵍⵉⵙ ⴷ ⵍⴻⵄⴷⵓ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵙⴻⴳⴷⴰ. ⵎⴰ ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴱⴻⴷⴷⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⴻⵙⵙⵅⴰⵔⵡⴹⴻⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵙⵉⴷⵉ? ");
INSERT INTO rift_vpl VALUES ("AC13_11","074_13_11","ACT","13","11","11","ⵍⴻⵅⵅⵓ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⴰⴼⵓⵙ ⵏ ⵙⵉⴷⵉ ⴹⵉⴷⴷ ⵏⵏⴻⵛ, ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴰⴷⴰⵔⵖⴰⵍ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵍⵉⴷ ⵜⴰⴼⵓⵛⵜ ⵄⴰⴷ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ.” ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙ ⵜⴰⵢⵢⵓⵜ ⴷ ⵜⴰⴵⴻⵙⵜ ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⴷⴷⵓⵔⴰ ⵉⵜⵜⴼⴰⴼⴰ, ⵢⴰⵔⴻⵣⵣⵓ ⵡⵉ ⵜ ⵖⴰ ⵉⴳⴻⵡⵡⴷⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC13_12","074_13_12","ACT","13","12","12","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⵄⴰⵎⵉⵍ ⵎⵉⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⵉⵜⴻⴱⵀⴻⵜ ⵓⵛⴰ ⵢⵓⵎⴻⵏ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_13","074_13_13","ACT","13","13","13","ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴽⴽⵉⵏ ⵅ ⵍⴻⴱⵃⴰⵔ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⴰⴼⵓⵙ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⵉⵔⵅⴰ ⴷⵉ ⴱⴰⵎⴼⵉⵍⵉⵢⴰ. ⵙⵙⴻⵏⵏⵉ ⵢⵓⵢⵓⵔ ⵅⴰⵙⴻⵏ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵄⵇⴻⴱ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC13_14","074_13_14","ACT","13","14","14","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵔⵓⵃⴻⵏ ⵣⵉ ⴱⵉⵔⵅⴰ, ⴽⴽⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴱⵉⵙⵉⴷⵉⵢⴰ. ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_15","074_13_15","ACT","13","15","15","ⴰⵡⴰⵔⵏⵉ ⵜⵉⵖⵔⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵏⵏⴰⵏ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵖⴰⵔⵡⴻⵎ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵓⵛⴻⵊⵊⴻⵄ ⵉ ⵉⵡⴷⴰⵏ, ⴱⴰⵔⵔⵃⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵉ ⵍⴳⴻⵏⵙ!” ");
INSERT INTO rift_vpl VALUES ("AC13_16","074_13_16","ACT","13","16","16","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴱⵓⵍⵓⵙ ⵉⵛⴻⵢⵢⴰⵔ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: “ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵙⵍⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("AC13_17","074_13_17","ACT","13","17","17","ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵜⵓⵖⴰ ⵉⴼⴰⵔⵣ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⴻⵏ ⵓ ⵉⵎⵎⴰⵔⵏⵉ ⴷⴰⵢⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵍⴰⵎⵉ ⵜⴻⵏ ⵜⵓⵖⴰ ⴷ ⵉⵎⴻⵄⵣⴰⴱ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ ⵓⵛⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵢⵓⵄⵍⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("AC13_18","074_13_18","ACT","13","18","18","ⵉⵙⵙⴻⵛⵛⴰ ⵉ-ⵜⴻⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("AC13_19","074_13_19","ACT","13","19","19","ⵉⵜⴻⵃⵃⴰ ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴽⴻⵏⵄⴰⵏ, ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ ⴷ ⵍⵡⴰⵔⵜ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_20","074_13_20","ACT","13","20","20","ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵍⵇⵓⴹⴰⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵅⴻⵎⵙⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵓⵏⴰⴱⵉ ⵛⴰⵎⵡⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AC13_21","074_13_21","ACT","13","21","21","ⵅⴻⵏⵏⵉ ⵜⵜⴰⵔⴻⵏ ⵉⵊⵊ ⵏ ⵓⵊⴻⴵⵉⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵛⴰⵡⵓⵍ, ⵎⵎⵉⵙ ⵏ ⴽⵉⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵍⵎⵉⵊⴰⵍ ⵏ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("AC13_22","074_13_22","ACT","13","22","22","ⵅⴻⵏⵏⵉ ⵉⴽⴽⴻⵙ ⵉ-ⵜ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴰⵙⴻⵏ ⴷⴰⵡⵓⴷ ⴷ ⴰⵊⴻⴵⵉⴷ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵅ ⵉⵛⵀⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⴰⵎⵎⵓ: ‘ⵓⴼⵉⵖ ⴷⴰⵡⵓⴷ ⵎⵎⵉⵙ ⵏ ⵢⴰⵙⵙⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵢⵓⵙⴰ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⵙⴻⵖ ⵏⴻⵛⵛ.’ ");
INSERT INTO rift_vpl VALUES ("AC13_23","074_13_23","ACT","13","23","23","ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵙⵔⴰⵉⵍ ⵢⴰⵙⵓⵄ ⴰⵎⵙⴻⵏⵊⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵣⵣⴰⵢⴻⵙ ⵉⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("AC13_24","074_13_24","ACT","13","24","24","ⵉⵙⵙⴻⴽⴽ ⵢⵓⵃⴰⵏⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵓⵚⴻⵖⴹⴰⵚ ⵏ ⵜⵜⵓⴱⴻⵜ ⵇⴱⴻⵍ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ ⵉ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AC13_25","074_13_25","ACT","13","25","25","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵢⵓⵃⴰⵏⵏⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ‘ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ? ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵛⴰ, ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⴷⵉⵀⴻⴵⴻⵖ ⴰⴷ ⴰⵙ ⴼⴻⵙⵢⴻⵖ ⵉⴼⵉⵍⴰⵏ ⵏ ⵙⴰⵏⴷⴰⵍⵉⵢⴰⵜ ⵏⵏⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("AC13_26","074_13_26","ACT","13","26","26","ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⵜⴰⵔⵡⴰ ⵏ ⵊⵊⵉⵍ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ: ⵉ ⴽⴻⵏⵏⵉⵡ ⵓⵎⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵏⴻⵜⵜⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴰⵍ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_27","074_13_27","ACT","13","27","27","ⵎⵉⵏⵣⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⴼⵀⵉⵎⴻⵏ ⵓⵍⴰ ⴷ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴽⵓⵍ ⵙⵙⴻⴱⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵃⴻⴽⵎⴻⵏ ⵅⴰⵙ ⵓ ⴰⵎⵎⵓ ⴽⴻⵎⵎⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵎⵉⵏ ⵢⵓⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_28","074_13_28","ACT","13","28","28","ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵓⴼⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵙⴱⴰⴱ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵃⴻⴽⵎⴻⵏ ⵙ ⵍⵎⴻⵡⵜ, ⵜⵜⴰⵔⴻⵏ ⵣⵉ ⴱⵉⵍⴰⵟⵓⵙ ⵜⵜⴻⵙⵍⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_29","074_13_29","ACT","13","29","29","ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴰⵙ ⵢⵓⵔⴰⵏ, ⵙⵙⴻⵀⵡⴰⵏ ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴻⵃⵏⴰⵛⵜ ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("AC13_30","074_13_30","ACT","13","30","30","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_31","074_13_31","ACT","13","31","31","ⵉⴹⵀⴰⵔ ⴰⵙⴻⵏ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⵙ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵣⵉ ⵍⵊⴰⵍⵉⵍ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⴻⵛⵀⵓⴷ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("AC13_32","074_13_32","ACT","13","32","32","ⵅⵣⴰⵔ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵍⵡⴰⵄⴷ ⵉ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC13_33","074_13_33","ACT","13","33","33","ⵅⵣⴰⵔ, ⴰⵔⴻⴱⴱⵉ ⵉⴽⴻⵎⵎⴻⵍ ⵍⵡⴰⵄⴷ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏ, ⵓⵎⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵢⴰⵙⵓⵄ ⵣⵉ ⵍⵎⴻⵡⵜ. ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ ⴷⴻⴳ ⵓⵣⴻⵀⵀⵉⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: ‘ⵛⴻⴽ ⴷ ⵎⵎⵉ, ⴰⵙⵙ-ⴰ ⵊⵊⵉⵖ-ⴷⴷ ⵛⴻⴽ!’ ");
INSERT INTO rift_vpl VALUES ("AC13_34","074_13_34","ACT","13","34","34","ⵙ ⵓⵢⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵉⴷⴷⵉⴽⴽⵡⵉⵍ ⵄⴻⵎⵎⴰⵔⵚ ⴰⵍⴰⵎⵉ ⵖⴰ ⵉⴽⵉⵛⵛⵓ, ⴰⵎ ⵜ ⵉⵏⵏⴰ: ‘ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⴰⵔⴹⴰ ⵏ ⴷⴰⵡⵓⴷ ⵉ ⴷⴰⵢⵙⴻⵏⵜ ⵍⴰⵎⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AC13_35","074_13_35","ACT","13","35","35","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵇⵇⴰⵔ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖⵏⵉ: ‘ⵛⴻⴽ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵊⵊⵉⴷ ⴰⵎⵙⵉⵣⴷⴻⴳ ⵏⵏⴻⵛ ⴰⴷ ⵉⴽⵉⵛⵛⵓ.’ ");
INSERT INTO rift_vpl VALUES ("AC13_36","074_13_36","ACT","13","36","36","ⵎⵉⵏⵣⵉ ⴷⴰⵡⵓⴷ ⵉⵙⴻⵅⵅⴰⵔ ⵊⴰⵔ ⵊⵊⵉⵍ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵉⵎⵎⵓⵜ, ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏ ⵖⴰⵔ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵉⴽⵉⵛⵛⵓ. ");
INSERT INTO rift_vpl VALUES ("AC13_37","074_13_37","ACT","13","37","37","ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⵜⵜⴽⵉⵛⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_38","074_13_38","ACT","13","38","38","ⵙ ⵓⵢⴰ, ⴰ ⵜⴰⵡⵎⴰⵜ, ⵙⵏⴻⵎ ⴰⵇⴰ ⵙ ⵡⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵉ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("AC13_39","074_13_39","ACT","13","39","39","ⵓ ⵙⵏⴻⵎ ⴰⵇⴰ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵎ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⴰⵇⴰ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("AC13_40","074_13_40","ACT","13","40","40","ⵃⴹⴰⵎ ⵅⴻⵏⵏⵉ ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵡⴻⵟⵟⵉ ⵛⴰ ⵏ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("AC13_41","074_13_41","ACT","13","41","41","‘ⵅⵣⴰⵔⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵚⴰⵔⴻⵏ, ⵜⵄⴻⵊⴱⴻⵎ ⵓ ⵜⵡⴻⴷⴷⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵡⴻⵎ ⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵇⵇⵉⵎ ⵡⴰⵅⵅⴰ ⵉⵄⴰⵡⴻⴷ ⴰⵡⴻⵎ ⵜⵜ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("AC13_42","074_13_42","ACT","13","42","42","ⵍⴰⵎⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷ-ⴼⴼⵖⴻⵏ, ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙⴻⵏ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⴷ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵙⵙⴻⴱⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_43","074_13_43","ACT","13","43","43","ⵍⴰⵎⵉ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵓⵎⵓⵏⵉ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴹⴼⴰⵔⴻⵏ ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ. ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴽⵉⵙⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⵄⴻⵍⵎⴻⵏ ⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_44","074_13_44","ACT","13","44","44","ⴷⵉ ⵙⵙⴻⴱⵜ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵜⵓⵙⴰ-ⴷⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⵍ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC13_45","074_13_45","ACT","13","45","45","ⴰⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⴷⴻⵡⵍⴻⵏ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵙ ⵍⴻⵃⵙⴻⴷ, ⵄⴻⴽⵙⴻⵏ ⵎⵉⵏ ⵅⴻⴼ ⵉⵙⵙⵉⵡⴻⵍ ⴱⵓⵍⵓⵙ, ⵇⴰⵛⵃⴻⵏ ⵓ ⵛⴻⵇⵇⴼⴻⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC13_46","074_13_46","ACT","13","46","46","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵏⵏⴰⵏ ⵙ ⵜⴻⵔⵢⴰⵙⵜ: “ⵜⵓⵖⴰ ⵉⵜⵜⵍⵉⵇ ⴰⴷ ⴰⵡⴻⵎ ⵏⴻⵙⵙⵉⵡⴻⵍ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵜ ⵜⵓⴳⵉⵎ, ⵓ ⵜⴻⴽⴽⵙⴻⵎ ⴰⵡⴰⵍ ⴹⵉⴷⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵜⴻⵙⴷⵉⵀⴻⴵⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵡⴻⵊⵊⴻⵀ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC13_47","074_13_47","ACT","13","47","47","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⴷ ⴰⵏⴻⵖ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ ⵛⴻⴽ ⴷ ⵜⴰⴼⴰⵡⵜ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵉ ⵜⵓⴷⴰⵔⵜ ⴰⵍ ⵟⵟⵔⵓⴼⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.’” ");
INSERT INTO rift_vpl VALUES ("AC13_48","074_13_48","ACT","13","48","48","ⵓⵎⵉ ⵙⵍⵉⵏ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵏ ⴰⵢⴰ, ⴼⴰⵔⵃⴻⵏ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⵓⵎⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_49","074_13_49","ACT","13","49","49","ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏⵏⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC13_50","074_13_50","ACT","13","50","50","ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⵙⵙⵃⴰⵔⵔⵛⴻⵏ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏⵜ ⵛⵛⴰⵏ ⵓ ⵄⴻⴱⴱⴷⴻⵏⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⵙⴻⵏ. ⴰⵎⵎⵓ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵛⵜ ⵏ ⵓⵎⴰⵔⵔⴻⵜ ⵅ ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵓⵛⴰ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵜⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC13_51","074_13_51","ACT","13","51","51","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵣⵣⴻⵔⵣⴻⵏ ⵜⴰⵄⴻⵊⵊⴰⵊⵜ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵅⴰⵙⴻⵏ ⵓⵛⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⴽⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC13_52","074_13_52","ACT","13","52","52","ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_1","074_14_1","ACT","14","1","1","ⴷⴻⴳ ⵉⴽⵓⵏⵉⵢⴰ ⵓⴷⴼⴻⵏ ⵏⵉⵜⵏⵉ ⵊⵎⵉⵄ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵓⵛⴰ ⵙⵙⵉⵡⵍⴻⵏ ⴰⵍⴰⵎⵉ ⵓⵎⵏⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ, ⴰⵎ ⵡⵓⴷⴰⵢⴻⵏ ⴰⵎ ⵉⵢⵓⵏⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_2","074_14_2","ACT","14","2","2","ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉ ⵢⴻⴵⴰⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵄⵉⴵⵜⴻⵏ ⵜⴰⵡⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("AC14_3","074_14_3","ACT","14","3","3","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴽⴽⵉⵏ ⴷⵉⵏⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ, ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵙ ⵙⵉⴷⵉ. ⵓ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵉⵛ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉ ⵉⴳⴳⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_4","074_14_4","ACT","14","4","4","ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵎⵎⵙⴻⴱⴹⴰ. ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵔⵓⵃⴻⵏ ⴰⴽ-ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⴰⴽ-ⴷ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC14_5","074_14_5","ACT","14","5","5","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵄⵎⵓⵍⵜ ⵅⴰⵙⴻⵏ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵓ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⴰⴽ-ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⴽⴰⵔⴼⵙⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⴻⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_6","074_14_6","ACT","14","6","6","ⵍⴰⵎⵉ ⵙⵙⵏⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴼⴼⵖⴻⵏ-ⴷⴷ ⵓⵛⴰ ⴰⵔⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⵍⵉⴽⴰⵄⵓⵏⵢⴰ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵉⵙⵜⵔⴰ ⴷ ⴷⵉⵔⴱⵉ, ⵓ ⵖⴰⵔ ⴷⵛⵓⵔⴰⵜ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC14_7","074_14_7","ACT","14","7","7","ⵓⵛⴰ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⴷⵉⵏⵏⵉ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_8","074_14_8","ACT","14","8","8","ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷⵉ ⵍⵉⵙⵜⵔⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵄⴹⴰⴱ ⴷⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵇⴻⵊⴷⴰⵃ ⵣⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰⵙ, ⵡⴰⵔ ⵢⵓⵢⵓⵔ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("AC14_9","074_14_9","ACT","14","9","9","ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰ ⵉ ⴱⵓⵍⵓⵙ ⴰⵎ ⵉⵙⵙⴰⵡⴰⵍ ⵏⴻⵜⵜⴰ. ⵍⴰⵎⵉ ⵜ ⵉⵥⵔⴰ ⴱⵓⵍⵓⵙ, ⵢⵓⵛⴰ ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍ’ⵉⵎⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("AC14_10","074_14_10","ACT","14","10","10","ⵉⵏⵏⴰ ⴰⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ: “ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴽⴽⴰⵔ, ⵜⴱⴻⴷⴷⴻⴷ ⵏⵉⵛⴰⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ!” ⵉⵏⴳⴻⵣ, ⵉⴽⴽⴰⵔ, ⵓⵛⴰ ⵉⴳⴳⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("AC14_11","074_14_11","ACT","14","11","11","ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⵍⵖⴰⵛⵉ ⵎⵉⵏ ⵉⴳⴳⴰ ⴱⵓⵍⵓⵙ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ ⵙ ⵍⵀⴰⵔⴷ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ: “ⴰⵇⴰ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴰⵔⴻⵡⵙⴻⵏ ⴷⴻⴳ ⵉⵡⴷⴰⵏ, ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("AC14_12","074_14_12","ACT","14","12","12","ⵏⵉⵜⵏⵉ ⵙⴻⵎⵎⴰⵏ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵙ ⵢⵉⵙⴻⵎ ‘ⵙⵉⴷⵉ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ’, ⵓ ⴱⵓⵍⵓⵙ ⵙ ⵢⵉⵙⴻⵎ ‘ⵀⵉⵔⵎⵉⵙ’, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵣⵡⴰⵔ ⵖⴰⵔ ⵡⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("AC14_13","074_14_13","ACT","14","13","13","ⴰⴽⴻⵀⵀⴰⵏ ⵏ ‘ⵙⵉⴷⵉ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ’ ⵜⵓⵖⴰ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵢⵉⵡⵉ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⴷ ⵜⵙⴻⴷⴷⵉⵢⵉⵏ ⵏ ⵏⵏⵓⵡⵡⴰⵛ ⵖⴰⵔ ⵜⵉⵡⵡⵓⵔⴰ ⵏ ⵍⴻⵎⵔⴰⵃ ⵎⴰⵏⵉ ⵇⵇⵉⵎⴻⵏ, ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵇⴻⴷⴷⴻⵎ ⴷ ⵜⵖⴰⵔⵚⵜ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC14_14","074_14_14","ACT","14","14","14","ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⴱⵓⵍⵓⵙ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵛⴰⵔⵔⴳⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ, ⵏⴻⴳⵣⴻⵏ, ⴼⴼⵖⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵊⴰⵔ ⵍⵖⴰⵛⵉ, ⵙⵖⵓⵢⵢⵓⵏ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("AC14_15","074_14_15","ACT","14","15","15","“ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵎⵉⵏ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ? ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴱⴰⵛⴰⵔ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⴽⴻⵏⵏⵉⵡ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⵄⵄⴷⴻⵎ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉⴱⴻⵟⵟⵍⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⴱⴻⵎ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_16","074_14_16","ACT","14","16","16","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⴻⵊⵢⵓⵍ ⵉⵄⴷⵓⵏ ⵉⵊⵊⴰ ⵏⴻⵜⵜⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC14_17","074_14_17","ACT","14","17","17","ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴱⵍⴰ ⵛⵛⵀⴰⴷⴻⵜ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⵜⵛⵓⵏⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵉⵙⵙⴻⵀⵡⴰ-ⴷⴷ ⴰⵏⵥⴰⵔ ⵓ ⵉⵡⵛⴰ ⴰⵟⵟⴰⵙ ⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵓⵛⴰ ⵉⵙⵙⵊⵉⵡⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⵙ ⵎⴰⵛⵛⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC14_18","074_14_18","ACT","14","18","18","ⵡⴰⵅⵅⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵎⴻⵏⵏⵉ, ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵇⵙⴻⵃ ⵅⴰⵙⴻⵏ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵍⵖⴰⵛⵉ, ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵇⴻⴷⴷⵉⵎ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC14_19","074_14_19","ACT","14","19","19","ⵎⴰⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵣⵉ ⵉⴽⵓⵏⵉⵢⴰ ⴷ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ⵙⵙⵃⴰⵔⵔⵛⴻⵏ ⵅⴰⵙⴻⵏ ⵍⵖⴰⵛⵉ ⵓⵛⴰ ⴰⵔⴻⵊⵎⴻⵏ ⴱⵓⵍⵓⵙ, ⵊⴰⵔⵔⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("AC14_20","074_14_20","ACT","14","20","20","ⵎⴰⵛⴰ ⴰⵎ ⴷ ⴰⵙ ⴷⴷ-ⵏⵏⴹⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵉⴽⴽⴰⵔ ⵓⵛⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ. ⵅⴻⵏⵏⵉ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⴼⴼⴻⵖ ⴰⴽ-ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ, ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴷⵉⵔⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC14_21","074_14_21","ACT","14","21","21","ⵓⵎⵉ ⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ, ⴳⴳⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. ⵅⴻⵏⵏⵉ ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵍⵉⵙⵜⵔⴰ ⴷ ⵉⴽⵓⵏⵉⵢⴰ ⴷ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("AC14_22","074_14_22","ACT","14","22","22","ⴳⴳⵉⵏ ⵓⵍ ⴷⵉ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵄⴻⵍⵎⴻⵏ ⴰⵙⴻⵏ ⴰⴷ ⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵏⵏⴰⵏ ⴰⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵎⵃⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("AC14_23","074_14_23","ACT","14","23","23","ⴰⵔⴻⵛⵛⵃⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴽⵓⵍ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⵎ ⵜⵜⵥⵓⵎⴰⵏ ⵓ ⵜⵜⵥⴰⴵⴰⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵙⴻⵍⵍⵎⴻⵏ ⵜⴻⵏ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉ ⴷⵉ ⵓⵎⵏⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC14_24","074_14_24","ACT","14","24","24","ⵅⴰⵙ ⵓⵛⴰ ⵥⵡⴰⵏ ⴱⵉⵙⵉⴷⵉⵢⴰ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵎⴼⵉⵍⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC14_25","074_14_25","ACT","14","25","25","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⴱⵉⵔⵅⴰ, ⵀⵡⴰⵏ-ⴷⴷ ⵖⴰⵔ ⴰⵜⵜⴰⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC14_26","074_14_26","ACT","14","26","26","ⵙⵙⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ ⵎⵉⵏⵣⵉ ⵙⵙⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵉ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴻⵏⵏⵉ ⴰⵇⴰ ⴽⴻⵎⵎⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC14_27","074_14_27","ACT","14","27","27","ⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵡⴹⴻⵏ, ⵍⴰⵖⴰⵏ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵅⴻⴱⴱⴰⵔⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵢⴻⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵓ ⵎⴰⵎⵎⴻⵛ ⵢⴰⵔⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC14_28","074_14_28","ACT","14","28","28","ⵓⵛⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ ⵉⵛⵜ ⵍⵡⴻⵇⵜ ⴷ ⴰⵣⵉⵔⴰⵔ ⴰⴽ-ⴷ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. * ");
INSERT INTO rift_vpl VALUES ("AC15_1","074_15_1","ACT","15","1","1","ⵀⵡⴰⵏ-ⴷⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ ⵓⵛⴰ ⴱⴷⴰⵏ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉ ⵜⴰⵡⵎⴰⵜ, ⵏⵏⴰⵏ: “ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵏⴰⵎⵉⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC15_2","074_15_2","ACT","15","2","2","ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⵓⵏⴰⵇⴻⵛ ⴰⴽⵉⴷⵙⴻⵏ ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ. ⵉⵎⵙⴰⵔ ⴰⵇⴰ ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ, ⵓ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴰⴷ ⵉⵏⵏⴻⵖⵏⵉ, ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵏⴰⵇⴻⵛ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC15_3","074_15_3","ACT","15","3","3","ⵜⴻⵙⵙⵇⴻⴱⴱⴻⴹ ⵓ ⵜⴻⵙⵙⴻⴽⴽ ⵉ-ⵜⴻⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ. ⵏⵉⵜⵏⵉ ⵛⵓⵇⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴼⵉⵏⵉⵇⵉⵢⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵙⴰⵎⴰⵔⵢⴰ ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜⵓⴱⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵙⵙⴼⴰⵔⵃⴻⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵡⵎⴰⵜ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC15_4","074_15_4","ACT","15","4","4","ⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵓ ⵏⵉⵜⵏⵉ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵉ-ⵜⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC15_5","074_15_5","ACT","15","5","5","ⵎⴰⵛⴰ ⵛⴰ ⵣⵉ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵓⵎⵏⴻⵏ, ⴽⴽⴰⵔⴻⵏ, ⵏⵏⴰⵏ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵜⵅⴻⵜⵏⴻⵎ ⵓ ⴰⴷ ⵜⴻⵏ ⵓⵎⵓⵔⴻⵏ ⴰⴷ ⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC15_6","074_15_6","ACT","15","6","6","ⵎⵓⵏⴻⵏ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵎⵛⴰⵡⴰⵔⴻⵏ ⵅ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC15_7","074_15_7","ACT","15","7","7","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵇⴰⵛⴰⵃⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⴱⴻⴷⴷ ⵛⵉⵎⵄⵓⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵅⴹⴰⵔ ⴰⵇⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_8","074_15_8","ACT","15","8","8","ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ, ⵉⵛⵀⴻⴷ ⵅⴰⵙⴻⵏ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⵎ ⵉ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_9","074_15_9","ACT","15","9","9","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⴱⵓ ⵍⴼⴰⵔⵣ ⵊⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴷ ⵏⵉⵜⵏⵉ, ⴰⵎ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵙ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_10","074_15_10","ACT","15","10","10","ⵉⵡⴰ ⵍⴻⵅⵅⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵎ ⵄⴰⴷ ⴰⵔⴻⴱⴱⵉ ⵓ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵉⵊⵊ ⵏ ⵓⵣⴰⵢⵍⵓ ⵅ ⵉⵔⴰⵡⴻⵏ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵜ ⵏⴰⵔⴱⵓ? ");
INSERT INTO rift_vpl VALUES ("AC15_11","074_15_11","ACT","15","11","11","ⵎⴰⵛⴰ ⵙ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵏⵓⵎⴻⵏ ⴰⵇⴰ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⵜⵓⴷⴰⵔⵜ ⴰⵎ ⵏⵉⵜⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC15_12","074_15_12","ACT","15","12","12","ⵉⵙⵇⴰⵔ ⵍⵖⴰⵛⵉ, ⵏⵉⵜⵏⵉ ⵙⵍⴰⵏ ⵉ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⴱⵓⵍⵓⵙ ⵜⵜⵄⴰⵡⴰⴷⴻⵏ ⵅ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC15_13","074_15_13","ACT","15","13","13","ⵓⵎⵉ ⵇⵇⵉⵎⴻⵏ ⵙⵇⴰⵔⴻⵏ, ⵉⴽⴽⴰⵔ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⴰ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⵙⵍⴻⵎ-ⴷⴷ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("AC15_14","074_15_14","ACT","15","14","14","ⵛⵉⵎⵄⵓⵏ ⵉⵅⴻⴱⴱⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴷⴰⵔ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC15_15","074_15_15","ACT","15","15","15","ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⴰⵙ-ⴷⴷ ⴰⴽ-ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("AC15_16","074_15_16","ACT","15","16","16","“‘ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ ⵓⵛⴰ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵖ ⵄⴰⵡⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉⵡⴹⴰⵏ ⵏ ⴷⴰⵡⵓⴷ, ⵓ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⴰⴷ ⵜⵜ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⴰⵔⴻⵇⵇⵄⴻⵖ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("AC15_17","074_15_17","ACT","15","17","17","ⵃⵉⵎⴰ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⵙⵉⴷⵉ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉ ⵅⴻⴼ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵙ ⵢⵉⵙⴻⵎ ⵉⵏⵓ!’, ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC15_18","074_15_18","ACT","15","18","18","ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵏⵜ ⵣⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("AC15_19","074_15_19","ACT","15","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵡⴰⵍⵉⵖ ⵉⵛⵓⵡⵡⴰⵔ ⵡⴰⵔ ⵏⴻⵙⵙⴻⴹⵇⵉⵍ ⵛⴰ ⵅ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⴷⴷⴰⴽⴽⵡⴰⵍⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("AC15_20","074_15_20","ACT","15","20","20","ⵎⴰⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵏⴰⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵄⵄⴷⴻⵏ ⵅ ⵜⴻⵅⵎⵓⵊⵉ ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵓ ⵅ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵅ ⵊⵊⵉⵢⴼⴰⵜ ⵓ ⵅ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_21","074_15_21","ACT","15","21","21","ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵎⵅⴻⵟⵟⴰⴱⴻⵏ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⴷⵉ ⵍⴻⵊⵢⵓⵍ ⵉⵄⴷⵓⵏ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵇⵇⴰⵔⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC15_22","074_15_22","ACT","15","22","22","ⵅⴻⵏⵏⵉ ⵉⵅⴹⴰⵔⴻⵏ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ, ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⵢⴰⵀⵓⴷⴰ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⴱⴰⵔ-ⵙⴰⴱⴰ, ⴷ ⵙⵉⵍⴰ ⴰⴽ-ⴷ ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ. ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵊⴰⵔ ⵜⴰⵡⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("AC15_23","074_15_23","ACT","15","23","23","ⵓⵔⵉⵏ ⵙ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⴰⵎⵎⵓ: “ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵜⴰⵡⵎⴰⵜ. ⵉ ⵜⴰⵡⵎⴰⵜ ⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ ⴷ ⵙⵓⵔⵉⵢⴰ ⴷ ⴽⵉⵍⵉⴽⵉⵢⴰ, ⵉ ⵜⴰⵡⵎⴰⵜ ⵉ ⵢⴻⴵⴰⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ. ⵙⵍⴰⵎ ⵅⴰⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("AC15_24","074_15_24","ACT","15","24","24","ⵏⴻⵙⵍⴰ ⴱⴻⵍⵍⵉ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵏⴻⵖ, ⵚⴻⴷⵄⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ, ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵏ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵏⵡⴻⵎ, ⵇⵇⴰⵔⴻⵏ: ‘ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ ⵓ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ!’, ⵓⵎⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵏⵓⵎⵓⵔ ⵙ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC15_25","074_15_25","ACT","15","25","25","ⵙ ⵓⵢⴰ ⵏⴻⵎⵛⴰⵡⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⵎⵓⵏ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵏⴼⴰⵔⵣ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵏⴻⵙⵙⴻⴽⴽ ⵖⴰⵔⵡⴻⵎ ⴰⴽ-ⴷ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵏⵏⴻⵖ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC15_26","074_15_26","ACT","15","26","26","ⵏⵉⵜⵏⵉ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵟⵟⴻⵡⵡⵄⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC15_27","074_15_27","ACT","15","27","27","ⵏⴻⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵢⴰⵀⵓⴷⴰ ⴷ ⵙⵉⵍⴰ, ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵅⴻⴱⴱⴰⵔⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_28","074_15_28","ACT","15","28","28","ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴷⵉ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵏⴻⵙⵙⴻⴹⵇⵉⵍ ⵛⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵏⵏⵉ ⵍⴰⴱⵓⴷⴷⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("AC15_29","074_15_29","ACT","15","29","29","ⴰⵇⴰ ⴰⴷ ⵜⴰⴳⴳⵯⴻⵊⴻⵎ ⵅ ⵎⵉⵏ ⵡⴻⵀⵀⴱⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵍⴰ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵍⴰ ⵅ ⵊⵊⵉⵢⴼⴰⵜ ⵓⵍⴰ ⵅ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ! ⵎⴰⵍⴰ ⵜⴻⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵍⵉⵃ. ⵉⵍⵉⵎ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC15_30","074_15_30","ACT","15","30","30","ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ ⵓⵛⴰ ⵙⵙⵎⵓⵏⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⵡⵛⵉⵏ ⴰⵙⴻⵏ ⵜⴰⴱⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("AC15_31","074_15_31","ACT","15","31","31","ⵍⴰⵎⵉ ⵜⵜ ⵖⵔⵉⵏ, ⴼⴰⵔⵃⴻⵏ ⵏⵉⵜⵏⵉ, ⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_32","074_15_32","ACT","15","32","32","ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⴰⵟⵟⴰⵙ ⵙⵙⵊⴻⵀⴷⴻⵏ ⵏⵉⵜⵏ ⵜⴰⵡⵎⴰⵜ ⵓⵛⴰ ⵙⵙⵎⴻⵜⵏⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵢⴰⵀⵓⴷⴰ ⴷ ⵙⵉⵍⴰ, ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC15_33","074_15_33","ACT","15","33","33","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏⵏⵉ ⵛⴰ ⵏ ⵍⵡⴻⵇⵜ, ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵜⴻⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵙ ⵍⴻⵀⵏⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("AC15_34","074_15_34","ACT","15","34","34","ⵎⴰⵛⴰ ⵙⵉⵍⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC15_35","074_15_35","ACT","15","35","35","ⴱⵓⵍⵓⵙ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ⵙⵙⵖⴰⵔⴰⵏ, ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC15_36","074_15_36","ACT","15","36","36","ⴰⵡⴰⵔⵏⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵏⵏⴰ ⴱⵓⵍⵓⵙ ⵉ ⴱⴰⵔ-ⵏⴰⴱⴰ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵄⵇⴻⴱ ⵖⴰⵔ ⵜⴰⵡⵎⴰⵜ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵏⴰⵔⴳⴻⴱ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⴼⴼⴻⵖ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC15_37","074_15_37","ACT","15","37","37","ⴱⴰⵔ-ⵏⴰⴱⴰ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⵏⴷⴻⵀ ⵢⵓⵃⴰⵏⵏⴰ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴽⴻⵏⵏⴰⵏ ⵎⴰⵔⴽⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("AC15_38","074_15_38","ACT","15","38","38","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵜ ⵢⵉⵡⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⴽⵓⵙ ⵉⵙⵎⴻⵃ ⴷⴰⵢⵙⴻⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⴱⴰⵎⴼⵉⵍⵉⵢⴰ, ⵓ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴽⵉⵙⴻⵏ ⵉⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("AC15_39","074_15_39","ACT","15","39","39","ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵎⵎⵙⴻⴱⴹⴰⵏ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⴱⴰⵔ-ⵏⴰⴱⴰ ⵢⵉⵡⵉ ⵎⴰⵔⴽⵓⵙ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⴱⴻⵃⵃⴰⵔ ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⵇⵓⴱⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC15_40","074_15_40","ACT","15","40","40","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵉⵅⴹⴰⵔ ⵙⵉⵍⴰ ⵓⵛⴰ ⵉⴼⴼⴻⵖ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⴻⵍⵍⵎⴻⵏ ⵜ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵖⴰⵔ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC15_41","074_15_41","ACT","15","41","41","ⵉⵛⵓⵇ ⴷⵉ ⵙⵓⵔⵉⵢⴰ ⴷ ⴽⵉⵍⵉⴽⵉⵢⴰ, ⵉⵜⵜⵛⴻⵊⵊⴰⵄ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC16_1","074_16_1","ACT","16","1","1","ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵏ ⴷⵉⵔⴱⵉ ⴷ ⵍⵉⵙⵜⵔⴰ, ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴹⴰⵔ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⵉⵎⵓⵜⵉⵢⵓ. ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵜⵓⴷⴰⵛⵜ ⴷ ⵍⵎⵓⵎⵉⵏⴰ, ⵎⴰⵛⴰ ⴱⴰⴱⴰⵙ ⴷ ⴰⵔⴰⵎⵉⵢⵓ. ");
INSERT INTO rift_vpl VALUES ("AC16_2","074_16_2","ACT","16","2","2","ⵎⴰⵔⵔⴰ ⵜⴰⵡⵎⴰⵜ ⵏ ⵍⵉⵙⵜⵔⴰ ⴷ ⵉⴽⵓⵏⵉⵢⴰ ⵛⴻⵀⴷⴻⵏ ⵅⴰⵙ ⵙ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC16_3","074_16_3","ACT","16","3","3","ⴱⵓⵍⵓⵙ ⵜⵓⵖⴰ ⵉⵅⵙ ⵡⴰ ⴰⴷ ⵉⵙⴰⴼⴰⵔ ⴰⴽⵉⴷⴻⵙ. ⵅⴻⵏⵏⵉ ⵉⴽⵙⵉ ⵜ ⵓⵛⴰ ⵉⵅⵜⴻⵏ ⴰⵙ, ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⴱⴰⴱⴰⵙ ⴷ ⴰⵔⴰⵎⵉⵢⵓ. ");
INSERT INTO rift_vpl VALUES ("AC16_4","074_16_4","ACT","16","4","4","ⵓⵎⵉ ⴽⴽⵉⵏ ⵅ ⵜⵏⴻⴷⴷⴰⵎ, ⵜⵜⴱⴰⵔⵔⵃⴻⵏ, ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵜⴻⵏ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵉⵡⴻⵚⵚⴰ ⵉ ⵢⵓⵔⴰⵏ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC16_5","074_16_5","ACT","16","5","5","ⴰⵎⵎⵓ ⴷⴻⵡⵍⴻⵏⵜ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⴱⴻⴷⴷⴻⵏⵜ ⵎⵍⵉⵃ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵓⵛⴰ ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏⵜ ⵉⵎⴻⵇⵇⴰⵔ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_6","074_16_6","ACT","16","6","6","ⵓⵎⵉ ⵛⵓⵇⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴼⵔⵉⵅⵉⵢⴰ ⴷ ⴳⴰⵍⴰⵟⵉⵢⴰ, ⵉⵎⵏⴻⵄ ⵉ-ⵜⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴻⵛⵛⴰⵔⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⴰⵙⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC16_7","074_16_7","ACT","16","7","7","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⵉⵙⵢⴰ, ⴰⵔⵣⵓⵏ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⴱⵉⵜⵉⵏⵉⵢⴰ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵢⴰⵙⵓⵄ ⵡⴰⵔ ⵜⴻⵏ ⵉⵊⵊⵉ. ");
INSERT INTO rift_vpl VALUES ("AC16_8","074_16_8","ACT","16","8","8","ⵅⴻⵏⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵎⵉⵙⵢⴰ, ⵀⵡⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵜⵔⵓⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_9","074_16_9","ACT","16","9","9","ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ ⵙ ⴵⵉⵍⴻⵜ ⵉⴱⴰⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⵖⴰⵔ ⴱⵓⵍⵓⵙ, ⵉⴱⴻⴷⴷ ⴷⵉⵏⵏⵉ, ⵉⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ, ⵉⵏⵏⴰ: ‘ⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵡⵛⴻⴷ ⴰⴼⵓⵙ!’ ");
INSERT INTO rift_vpl VALUES ("AC16_10","074_16_10","ACT","16","10","10","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵥⵔⴰ ⴱⵓⵍⵓⵙ ⵍⴻⵡⵃⵉⵢ-ⴰ, ⵏⴻⴽⴽⴰⵔ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⴼⵀⴻⵎ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵍⴰⵖⴰ ⴰⵏⴻⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⵏⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC16_11","074_16_11","ACT","16","11","11","ⴰⵇⴰ ⵏⵓⵢⵓⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵣⵉ ⵜⵔⵓⵡⴰⵙ ⵓⵛⴰ ⵏⵔⵓⵃ ⵏⵉⵛⴰⵏ ⵖⴰⵔ ⵙⴰⵎⵓⵜⵔⴰⴽⵉ, ⵓ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵏⵔⵓⵃ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⵏⵉⵢⴰⴱⵓⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_12","074_16_12","ACT","16","12","12","ⵙⵙⴻⵏⵏⵉ ⵏⵔⵓⵃ ⵖⴰⵔ ⴼⵉⵍⵉⴱⴱⵉ, ⵜⴻⵏⵏⵉ ⴷ ⵍⵄⴰⵚⵉⵎⴰ ⵏ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵜⵓⵖⴰ ⵟⵟⴼⴻⵏ ⵜⵜ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵏⵉⵜⵏⵉ. ⵏⴻⵇⵇⵉⵎ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC16_13","074_16_13","ACT","16","13","13","ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵙⴻⴱⵜ ⵏⴻⴼⴼⴻⵖ ⵣⵉ ⵜⴻⵡⵡⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵉⵖⵣⴰⵔ ⵎⵉⵏⵣⵉ ⵏⴻⵥⵔⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵥⴰⴵⵉⵜ. ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⴻⵇⵇⵉⵎ ⴷⵉⵏ, ⵏⴻⵙⵙⵉⵡⴻⵍ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵎⵓⵏⴻⵏ ⴷⵉⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC16_14","074_16_14","ACT","16","14","14","ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⵉ ⵉⵣⵣⴻⵏⵣⴻⵏ ⵍⴻⵃⵔⴰⵔ, ⵇⵇⴰⵔⴻⵏⵜ ⴰⵙ ⵍⵓⴷⵉⵢⴰ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵜⵉⵢⴰⵜⵉⵔⴰ, ⵜⵓⵖⴰ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷ ⴰⵔⴻⴱⴱⵉ. ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵔⵣⴻⵎ ⴰⵙ ⵓⵍ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⵍ ⵎⵍⵉⵃ ⵎⵉⵅⴻⴼ ⵉⵙⵙⴰⵡⴰⵍ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_15","074_16_15","ACT","16","15","15","ⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵏⴻⵜⵜⴰⵜ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⴰⵔ ⵣⵣⴰⵢⵏⴻⵖ, ⵜⴻⵏⵏⴰ: “ⵎⴰⵍⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵓⵎⵏⴻⵖ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵉⵡⴰ ⴰⵔⴰⵃⴻⵎ-ⴷⴷ, ⵇⵇⵉⵎⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵏⵓ!” ⵜⵓⵖⴰ ⵜⵣⴰⵡⴳ ⴰⵏⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_16","074_16_16","ACT","16","16","16","ⴰⵎ ⵏⴻⴳⴳⵓⵔ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵜⵥⴰⴵⵉⵜ, ⵜⴻⵎⵎⵙⴻⵍⵇⴰ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵛⵜ ⵏ ⵜⴰⵢⵢⴰ, ⴷⴰⵢⴻⵙ ⵍⴰⵔⵢⴰⵃ ⵏ ⵜⴳⴻⵣⵣⴰⵏⵜ, ⵜⵉⵡⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⴻⴼⴹⴻⵍ ⵉⵎⵖⴰⵔ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏⵏⴻⵙ ⵙ ⵜⴳⴻⵣⵣⴰⵏⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC16_17","074_16_17","ACT","16","17","17","ⵏⴻⵜⵜⴰⵜ ⵜⴹⴻⴼⴼⴰⵔ ⴱⵓⵍⵓⵙ ⴷ ⵏⴻⵛⵛⵉⵏ, ⵜⴻⵙⵖⵓⵢⵢⵓ, ⵜⴻⵇⵇⴰⵔ: “ⵉⵡⴷⴰⵏ-ⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵏⵉⵜⵏⵉ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("AC16_18","074_16_18","ACT","16","18","18","ⴰⵎⵎⵓ ⵉ ⵜⴻⵇⵇⵉⵎ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵢⵢⴰⵇ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴻⵇⵍⴻⴱ, ⵉⵏⵏⴰ ⵉ ⵍⴰⵔⵢⴰⵃ: “ⵜⵜⵓⵎⵓⵔⴻⵖ ⵛⴻⴽ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ.” ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵍⴰⵔⵢⴰⵃ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC16_19","074_16_19","ACT","16","19","19","ⵓⵎⵉ ⵥⵔⵉⵏ ⴰⵢⵜⴱⴰⴱ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⴰⵙⵉⵜⴻⵎ ⵏ ⵍⴻⴼⴹⴻⵍ ⵏⵙⴻⵏ ⵉⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ, ⵟⵟⴼⴻⵏ ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⴰ, ⵊⴰⵔⵔⴻⵏ ⵜⴻⵏ, ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵖⴰⵔ ⵙⵙⵓⵇ. ");
INSERT INTO rift_vpl VALUES ("AC16_20","074_16_20","ACT","16","20","20","ⵏⵉⵜⵏⵉ ⵉⵡⵢⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵉⵎⵅⴰⵣⵏⵉⵢⵢⴻⵏ ⵓ ⵣⵣⴰⵜ ⵉ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵏⵏⴰⵏ: “ⵉⵡⴷⴰⵏ-ⴰ ⵜⵜⵅⴰⵔⵡⴰⴹⴻⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC16_21","074_16_21","ACT","16","21","21","ⵏⵉⵜⵏⵉ ⵜⵜⴱⴰⵔⵃⴻⵏ ⴰⵏⴻⵖ ⵙ ⵜⵜⴰⵇⴰⵍⵉⴷ ⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴻⴵⴻⵍ ⴰⴷ ⵜⴻⵏⵜ ⵏⴻⵇⴱⴻⵍ ⵏⵉⵖ ⴰⴷ ⵜⴻⵏⵜ ⵏⴻⴹⴼⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC16_22","074_16_22","ACT","16","22","22","ⵉⵙⵙⵎⵓⵏ ⵅⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵅⴻⵏⵏⵉ ⵛⴰⵔⵔⴳⴻⵏ ⵉⵎⵅⴰⵣⵏⵉⵢⵢⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ, ⵓⵎⵓⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("AC16_23","074_16_23","ACT","16","23","23","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵏ ⵀⴻⵜⵜⴽⴻⵏ ⴰⵟⵟⴰⵙ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵏⴹⴰⵔⴻⵏ ⵜⴻⵏ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵓⵎⵓⵔⴻⵏ ⵉ ⵓⵄⴻⵙⵙⴰⵙ ⵏ ⵍⴻⵃⴱⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵄⴻⵙⵙ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC16_24","074_16_24","ACT","16","24","24","ⵓ ⵏⴻⵜⵜⴰ, ⵓⵎⵉ ⵉⴽⵙⵉ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ, ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵇⴰⵄ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵉⵇⵇⴻⵏ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⵇⴰⵍⴻⴱ ⵏ ⴵⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("AC16_25","074_16_25","ACT","16","25","25","ⴷⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⴵⵉⵍⴻⵜ ⵜⵓⵖⴰ ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⴰ ⵜⵜⵥⴰⴵⴰⵏ ⵓ ⵜⵜⵙⴻⴱⴱⴰⵃⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵙⵍⵉⵏ ⵉⵎⴻⵃⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_26","074_16_26","ACT","16","26","26","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵏⵀⴻⵣⵣ ⴷⵙⴰⵙ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵓⵛⴰ ⴷⴻⵖⵢⴰ ⵏⵏⵓⵔⵣⵎⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴱⴰⵙ ⴼⴻⵙⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC16_27","074_16_27","ACT","16","27","27","ⵍⴰⵎⵉ ⴷ ⵉⴼⴰⵇ ⵓⵄⴻⵙⵙⴰⵙ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵉⵥⵔⴰ ⵜⵉⵡⵡⵓⵔⴰ ⴰⵔⵣⵎⴻⵏⵜ, ⵉⵊⴱⴻⴷ ⵙⵙⵉⴼ ⵏⵏⴻⵙ, ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⵏⴻⵖ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴱⴻⵍⵍⵉ ⵉⵎⴻⵃⴱⴰⵙ ⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC16_28","074_16_28","ACT","16","28","28","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ: “ⵡⴰⵔ ⵜⵜⴹⴰⵔⵔⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⴰ ⵎⴰⵔⵔⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC16_29","074_16_29","ACT","16","29","29","ⵅⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⴻⵖ ⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ, ⵉⵏⴳⴻⵣ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵉⵜⵜⴰⵔⵊⵉⵊⵉ, ⵉⵏⴹⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("AC16_30","074_16_30","ACT","16","30","30","ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵉⵏⵏⴰ: “ⴰ ⵍⴻⵊⵡⴰⴷ, ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴳⴳⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵖ ⵜⵓⴷⴰⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("AC16_31","074_16_31","ACT","16","31","31","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⴰⵎⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵜᵉⵟⵟⴼⴻⴷ ⵜⵓⴷⴰⵔⵜ, ⵛⴻⴽ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("AC16_32","074_16_32","ACT","16","32","32","ⵙⵙⵉⵡⵍⴻⵏ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ ⴰⴽⵉⴷⴻⵙ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_33","074_16_33","ACT","16","33","33","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵏ ⴵⵉⵍⴻⵜ ⵉⵡⵢⵉ ⵜⴻⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ, ⵉⵙⵙⵉⵔⴷ ⴰⵙⴻⵏ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴷⴻⵖⵢⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵏⴻⵜⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC16_34","074_16_34","ACT","16","34","34","ⵅⴻⵏⵏⵉ ⵉⵡⵢⵉ ⵜⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵙⴻⵏ ⵟⵟⴰⴱⵍⴰ, ⵉⴼⴰⵔⵃ ⵏⴻⵜⵜⴰ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵟⵟⴼⴻⵏ ⵍ’ⵉⵎⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC16_35","074_16_35","ACT","16","35","35","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵣⵉⵍ, ⵙⵙⴻⴽⴽⴻⵏ ⵉⵎⵅⴰⵣⵏⵉⵢⵢⴻⵏ ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵅ ⵍⴰⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⵉⵏ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏ ⵍⴻⵃⴱⴻⵙ: “ⴹⴻⵍⵇ ⴰⵙⴻⵏ-ⴷⴷ ⵉ ⵉⵡⴷⴰⵏ ⵏⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC16_36","074_16_36","ACT","16","36","36","ⵓⵎⵉ ⵉⵙⵍⴰ ⴰⵢⴰ ⵓⵣⴻⴵⵉⴼ ⵏ ⵍⴻⵃⴱⴻⵙ, ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵖⴰⵔ ⴱⵓⵍⵓⵙ, ⵉⵏⵏⴰ: “ⵉⵎⵅⴰⵣⵏⵉⵢⵢⴻⵏ ⵙⴻⴽⴽⴻⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⴹⴻⵍⵇⴻⵏ. ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴼⴼⵖⴻⵎ, ⵍⵓⵃⴻⵎ ⴷⵉ ⵍⴻⵀⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC16_37","074_16_37","ACT","16","37","37","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ, ⵊⵊⵉⵏ ⴰⴷ ⴰⵏⴻⵖ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⴰⵎ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵉⴵⵉ ⵍⵄⵉⴱ, ⵏⴹⴰⵔⴻⵏ ⴰⵏⴻⵖ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵓⵛⴰ ⵍⴻⵅⵅⵓ, ⵎⴰ ⵅⵙⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵏⴻⵖ ⴹⴻⵍⵇⴻⵏ ⵙ ⵜⵏⵓⴼⴼⵔⴰ? ⵍⵍⴰ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⴹⴻⵍⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC16_38","074_16_38","ACT","16","38","38","ⵉⵡⴻⵇⵇⴰⴼⴻⵏ ⵅ ⵍⴰⵎⴰⵏ ⵔⵓⵃⴻⵏ, ⵙⵙⵉⵡⴹⴻⵏ ⴰⵡⴰⵍⴻⵏ-ⴰ ⵏⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵯⴻⴷⴻⵏ ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC16_39","074_16_39","ACT","16","39","39","ⵅⴻⵏⵏⵉ ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ, ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵔⵓⵃⴻⵏ, ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC16_40","074_16_40","ACT","16","40","40","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵉ ⵍⴻⵃⴱⴻⵙ, ⵄⴻⵇⴱⴻⵏ ⵖⴰⵔ ⵍⵓⴷⵉⵢⴰ, ⵎⴰⵏⵉ ⵥⵔⵉⵏ ⵜⴰⵡⵎⴰⵜ. ⵙⵙⵛⴻⵊⵊⵄⴻⵏ ⵜⴻⵏ ⵓⵛⴰ ⵓⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_1","074_17_1","ACT","17","1","1","ⵥⵡⴰⵏ ⵅ ⴰⵎⴼⵉⴱⵓⵍⵉⵙ ⴷ ⴰⴱⵓⵍⵍⵓⵏⵉⵢⴰ, ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_2","074_17_2","ACT","17","2","2","ⴱⵓⵍⵓⵙ ⵢⵓⴷⴻⴼ-ⴷⴷ ⴷⵉⵏ ⵖⴰⵔⵙⴻⵏ, ⴰⵎ ⵜⵓⵖⴰ ⴷ ⵍⵇⴰⵄⵉⴷⴰ ⵏⵏⴻⵙ. ⴷⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_3","074_17_3","ACT","17","3","3","ⵉⴼⴼⴻⵙⵙⴰⵔ ⵓ ⵉⵙⵙⴱⴻⵢⵢⴻⵏ ⴰⵙⴻⵏ ⴰⵎⵎⵓ: “ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵉⵜⵜⵡⴰⵡⴻⴷⴷⴻⴱ ⵓ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵢⴰⵙⵓⵄ, ⵍⵎⴰⵙⵉⵃ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC17_4","074_17_4","ACT","17","4","4","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵎⵏⴻⵏ, ⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⴰ, ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵢⵓⵏⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵔⵓⵙⵜ ⵣⵣⴰⵢⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("AC17_5","074_17_5","ACT","17","5","5","ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⴷⴻⵡⵍⴻⵏ ⵜⵜⴰⵙⵎⴻⵏ, ⵏⴻⴷⵀⴻⵏ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵣⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⵖⴰⵛⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵖⴰⵔⵙⴻⵏ, ⵙⵙⵀⴰⵊⴰⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵙⵙⴻⴽⴽⴰⵔⴰⵏ ⵜⴻⵏ ⴹⵉⴷⴷ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵙⵓⵏ, ⴰⵔⵣⵓⵏ ⴰⴷ ⵜⴻⵏ ⵙⴻⵍⵍⵎⴻⵏ ⵉ ⵍⵖⴰⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("AC17_6","074_17_6","ACT","17","6","6","ⵓⵎⵉ ⵡⴰⵔ ⵜⴻⵏ ⵓⴼⵉⵏ ⴷⵉⵏ, ⵊⴰⵔⵔⴻⵏ ⵢⴰⵙⵓⵏ ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⵙⵖⵓⵢⵢⵓⵏ: “ⵅⵣⴰⵔ, ⵉⵏⴰ, ⵉⵏⵏⵉ ⵉⵙⵙⵖⴻⵡⵡⵖⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴷⴰ! ");
INSERT INTO rift_vpl VALUES ("AC17_7","074_17_7","ACT","17","7","7","ⵢⴰⵙⵓⵏ ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏ ⵖⴰⵔⴻⵙ ⴷ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⵄⴻⴽⴽⵙⴻⵏ ⵜⵉⵡⵚⴻⵢⵢⴰⵜ ⵏ ⵇⴰⵢⵚⴰⵔ, ⵇⵇⴰⵔⴻⵏ ⴰⵇⴰ ⴷⴰ ⴰⵊⴻⴵⵉⴷ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ.” ");
INSERT INTO rift_vpl VALUES ("AC17_8","074_17_8","ACT","17","8","8","ⵙⵙⴰⵔⴻⵊⴼⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷ ⵍⴳⴻⵏⵙ ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC17_9","074_17_9","ACT","17","9","9","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵟⵟⴼⴻⵏ ⵍⵄⴰⵔⴱⵓⵏⴰⵜ ⵣⵉ ⵢⴰⵙⵓⵏ ⴷ ⵢⵉⵏⵏⴻⵖⵏⵉ, ⴰⵔⵅⵓⵏ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_10","074_17_10","ACT","17","10","10","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵏ ⵜⴰⵡⵎⴰⵜ ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⴰ ⵖⴰⵔ ⴱⵉⵔⵉⵢⴰ ⵙ ⴵⵉⵍⴻⵜ. ⵓⵎⵉ ⴷⵉⵏ ⵉⵡⴹⴻⵏ, ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC17_11","074_17_11","ACT","17","11","11","ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⴷⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵅⴰⵔ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵉ ⵡⴰⵡⴰⵍ ⴽⵓⵍ ⴰⵙⵙ, ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵙⵙⵏⴻⵏ ⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵎⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵇⴰ ⵜⴻⵏⵜ ⴰⵎⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC17_12","074_17_12","ACT","17","12","12","ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵎⵏⴻⵏ, ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⴻⴳ ⵉⵢⵓⵏⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_13","074_17_13","ACT","17","13","13","ⵎⴰⵛⴰ, ⵓⵎⵉ ⵓⴷⴰⵢⴻⵏ ⵏ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⴱⵓⵍⵓⵙ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⴱⵉⵔⵉⵢⴰ, ⵓⵙⵉⵏ-ⴷⴷ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ ⴷⵉⵏ, ⵡⴰⵔ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵣⴻⴳ ⵓⵙⵖⴻⵡⵡⴻⵖ ⵓ ⵣⴻⴳ ⵓⵙⵅⴰⵔⵡⴻⴹ ⵊⴰⵔ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC17_14","074_17_14","ACT","17","14","14","ⵅⴰⵙ ⵓⵛⴰ ⵊⵊⵉⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⴰⴷ ⵉⵀⵡⴰ ⴱⵓⵍⵓⵙ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ, ⵎⴰⵛⴰ ⵙⵉⵍⴰ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ ⵇⵇⵉⵎⴻⵏ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_15","074_17_15","ACT","17","15","15","ⵉⵏⵏⵉ ⵉⵙⵙⵇⴻⴱⴹⴻⵏ ⴱⵓⵍⵓⵙ, ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵜⵉⵏⴰ. ⵅⴻⵏⵏⵉ, ⵓⵎⵉ ⵜ ⵊⵊⵉⵏ, ⵟⵟⴼⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⵉ ⵙⵉⵍⴰ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵙⴻⵏ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC17_16","074_17_16","ACT","17","16","16","ⴰⵎ ⵜⴻⵏ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰ ⴱⵓⵍⵓⵙ ⴷⵉ ⴰⵜⵉⵏⴰ, ⵜⵓⵖⴰ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉⵅⴻⵢⵢⴻⵇ ⵓⵎⵉ ⵉⵥⵔⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴻⵛⵛⵓⵔ ⵙ ⵍⴻⵅⵢⴰⵍⴰⵜ ⵏ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("AC17_17","074_17_17","ACT","17","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ ⴰⴽ-ⴷ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴷⵉ ⵙⵙⵓⵇ ⵓⵍⴰ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵎⵓⵏⴻⵏ ⴷⵉⵏⵏⵉ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("AC17_18","074_17_18","ACT","17","18","18","ⵄⴰⴷ ⵛⴰ ⵏ ⵉⴼⴰⵢⵍⴰⵙⵓⴼⴻⵏ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵉⴱⵉⴽⵓⵔⵓⵙ ⵓ ⵛⴰ ⵏⵏⴻⵖⵏⵉ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵉⵙⵜⵓⵡⴰⴽⵉⵢⵢⴻⵏ, ⵎⵏⴰⵇⴰⵛⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵏⴰⵏ: “ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵡⴰⵏⵉⵜⴰ ⵙ ⵍⵀⴰⵔⴷ-ⴰ ⵇⴰⵄ?” ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵉⴹⵀⴰⵔ-ⴷⴷ ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴱⴰⵔⵔⴻⵃ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⵉⵖⵔⵉⴱⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵙⴻⵏ ⵙ ⵢⴰⵙⵓⵄ ⴷ ⵜⵏⵓⴽⵔⴰ ⵏⵏⴻⵙ ⵣⴻⴳ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_19","074_17_19","ACT","17","19","19","ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ, ⵏⴻⴷⵀⴻⵏ ⵜ ⵖⴰⵔ ⵍⴻⴱⵏⵉ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴰⵔⵉⵢⵓⴱⴰⴳⵓⵙ, ⵏⵏⴰⵏ ⴰⵙ: “ⵎⴰ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵎⴰⵏ ⵜⴰⵖⵓⵔⵉ ⵏ ⵊⴷⵉⴷ ⵉ ⵜᵉⵜⵜⴱⴰⵔⵔⵃⴻⴷ?”, ");
INSERT INTO rift_vpl VALUES ("AC17_20","074_17_20","ACT","17","20","20","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⵉⵡⵢⴻⴷ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵖⵔⵉⴱⵉⵏ ⵉ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵖ, ⵓ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC17_21","074_17_21","ACT","17","21","21","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵣⵉ ⴰⵜⵉⵏⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⵙⵙⴻⵄⴷⵓⵏ ⵍⵡⴻⵇⵜ ⵎⵖⵉⵔ ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵍⴻⵏ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("AC17_22","074_17_22","ACT","17","22","22","ⵉⴽⴽⴰⵔ-ⴷⴷ ⴱⵓⵍⵓⵙ, ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴰⵔⵉⵢⵓⴱⴰⴳⵓⵙ’, ⵉⵏⵏⴰ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴰⵜⵉⵏⴰ, ⵓⴼⵉⵖ ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵄⴻⵎⵎⴰⵔⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⵟⵟⴰⵔⴼ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵣⵉ ⴽⵓⵍ ⴰⵖⴻⵣⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("AC17_23","074_17_23","ACT","17","23","23","ⵎⵉⵏⵣⵉ ⵓⵎⵉ ⵏⵏⴹⴻⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏⵡⴻⵎ, ⵥⵔⵉⵖ ⵜⵉⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵓⴼⵉⵖ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵣⴻⵎⵎⴻⵏ ⵅⴰⵙ: ‘ⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ’. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵜⵄⴻⴱⴱⴷⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴰⵎ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏⴻⵎ, ⴷ ⵡⴰ ⵉ ⵣⵉ ⴷ ⴰⵡⴻⵎ ⵜⵜⴱⴻⵛⵛⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC17_24","074_17_24","ACT","17","24","24","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵢⴻⵊⵊⵉⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴰⵢⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵙⵉⴷⵉ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵡⴰⵔ ⵉⵣⴻⴷⴷⴻⵖ ⵛⴰ ⴷⵉ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("AC17_25","074_17_25","ACT","17","25","25","ⵓⵍⴰ ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⵡⴰⵙⴻⵅⵅⴰⵔ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⵅⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵃⵡⴰⵊ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵡⵛⴰ ⵉ ⵎⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵜⵓⴷⴰⵔⵜ ⴷ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ. ");
INSERT INTO rift_vpl VALUES ("AC17_26","074_17_26","ACT","17","26","26","ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵏ ⴱⵏⴰⴷⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵣⴻⴷⵖⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ, ⵓ ⵙ ⵍⵓⵎⵓⵔ ⵏⵏⴻⵙ ⵉⴼⴰⵔⵣ ⴰⵙⴻⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉⵢⵎⵉⵔⴻⵏ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("AC17_27","074_17_27","ACT","17","27","27","ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵣⵓⵏ ⵅ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴰⵔⴻⵏ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜ ⴰⴼⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵯⵉⵊ ⵛⴰ ⴰⵟⵟⴰⵙ ⵅ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC17_28","074_17_28","ACT","17","28","28","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷⴰⵢⴻⵙ ⵉ ⵏⴻⴷⴷⴰⵔ ⵓ ⴷⴰⵢⴻⵙ ⵉ ⵏᵉⵜⵜⴻⵏⵀⴻⵣⵣⴰ ⵓ ⴷⴰⵢⴻⵙ ⵉ ⵏⴻⴵⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴰⵏ ⵛⴰ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵏⵡⴻⵎ: ‘ⴰⵇⴰ ⵏⴻⵇⵇⴰⵔⵚ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ!’ ");
INSERT INTO rift_vpl VALUES ("AC17_29","074_17_29","ACT","17","29","29","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰⵎ ⴷⴷ-ⵉⵇⵇⴰⵔⵚ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵏⵃⴻⵙⵙⴻⴱ ⵛⴰ ⴱⴻⵍⵍⵉ ⵓⵔⴻⵖ ⵏⵉⵖ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⴰⵥⵔⵓ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵍⴼⴻⵏⵏ ⵓ ⵙ ⵜⵣⴻⵎⵎⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴰⵎ ⴰⵔⴻⴱⴱⵉ ⵉ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_30","074_17_30","ACT","17","30","30","ⴰⵔⴻⴱⴱⵉ ⵉⵊⵊⴰ ⴰⴷ ⵄⴷⵓⵏⵜ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵓⵡⴻⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⴷⵉ ⵣⵣⵎⴰⵏ-ⴰ ⵉⵜⵜⴰⵎⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("AC17_31","074_17_31","ACT","17","31","31","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵃⴽⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵍⵃⴻⵇⵇ ⵙ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵉⴼⴰⵔⵣ. ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵢⴰⵎⴻⵏ, ⵍⴰⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC17_32","074_17_32","ACT","17","32","32","ⵓⵎⵉ ⵙⵍⵉⵏ ⵅ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴱⴷⴰⵏ ⵙⵜⵀⴻⵣⵣⴰⵏ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵏⵏⴰⵏ: “ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵏⴻⵅⵙ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵏⵙⴻⵍ ⴽⵜⴰⵔ ⵅ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC17_33","074_17_33","ACT","17","33","33","ⴰⵎⵎⵓ ⵉⴼⴼⴻⵖ ⴱⵓⵍⵓⵙ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC17_34","074_17_34","ACT","17","34","34","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⴹⴼⴰⵔⴻⵏ ⵜ, ⵓⵎⵏⴻⵏ. ⵜⵓⵖⴰ ⴷⵉⵢⵓⵏⵉⵙⵉⵢⵓⵙ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⵍⵇⵓⴹⴰⵜ ⵏ ⴰⵔⵉⵢⵓⴱⴰⴳⵓⵙ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴷⴰⵎⴰⵔⵉⵙ ⵓ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ. * ");
INSERT INTO rift_vpl VALUES ("AC18_1","074_18_1","ACT","18","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵊⵊⴰ ⴱⵓⵍⵓⵙ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⴰⵜⵉⵏⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴽⵓⵔⵉⵏⵜⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC18_2","074_18_2","ACT","18","2","2","ⵢⵓⴼⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⴽⵡⵉⵍⴰ. ⵡⴰⵏⵉⵜⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⴷⵉⵏ ⵣⵉ ⴱⵓⵏⵟⵓⵙ, ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⵉⵟⴰⵍⵢⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ, ⴰⴽ-ⴷ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵇⴰⵢⵚⴰⵔ ⴽⵍⵓⴷⵉⵢⵓⵙ ⵜⵓⵖⴰ ⵢⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⵉ ⵔⵓⵎⴰ. ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴱⵓⵍⵓⵙ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_3","074_18_3","ACT","18","3","3","ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵚⵚⴻⵏⵄⴻⵜ ⴷ ⵉⵛⵜⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵇⵇⵉⵎ ⵖⴰⵔⵙⴻⵏ, ⵉⵅⴻⴷⴷⴻⵎ ⴰⴽⵉⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵚⵚⴻⵏⵄⴻⵜ ⵏⵙⴻⵏ ⴷ ⵉⵎⵄⵉⵛⵡⴻⵏ, ⵜⵜⴻⴳⴳⴻⵏ ⵉⵇⵉⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_4","074_18_4","ACT","18","4","4","ⵜⵓⵖⴰ ⵉⵜⵜⵃⴻⴷⴷⴰⵜ ⴽⵓⵍ ⵙⵙⴻⴱⵜ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵙⵙⴻⵇⵏⴻⵄ ⵓⴷⴰⵢⴻⵏ ⴷ ⵉⴽⴰⴼⵔⵉⵡⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_5","074_18_5","ACT","18","5","5","ⵓⵎⵉ ⴷⴷ-ⵉⵀⵡⴰ ⵙⵉⵍⴰ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ ⵣⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴱⵓⵍⵓⵙ ⵣⴻⴳ ⵓⴱⴰⵔⵔⴻⵃ ⵏ ⵡⴰⵡⴰⵍ, ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⵜⵓⵖⴰ ⵜⵜⴹⴰⴷⴷⴰⵏ ⵜ, ⵜⵜⵛⴻⵇⵇⴼⴻⵏ ⴷⴰⵢⴻⵙ ⵓⵎⵉ ⵉⵛⵀⴻⴷ ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC18_6","074_18_6","ACT","18","6","6","ⵉⵣⵣⴻⵔⵣ ⵜⴰⵄⴻⵊⵊⴰⵛⵜ ⵣⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵣⵉ ⵍⴻⵅⵅⵓ ⵜⵜⴱⴰⵔⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵣⴰⵢⵡⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC18_7","074_18_7","ACT","18","7","7","ⵉⵔⵓⵃ ⵙⵙⴻⵏⵏⵉ ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⵉⵜⵓⵙ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵄⴻⴱⴱⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⵓⵖⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴻⵍⵚⴻⵇ ⴰⴽ-ⴷ ⵜⴻⵎⵣⵉⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("AC18_8","074_18_8","ACT","18","8","8","ⵓ ⴽⵔⵉⵙⴱⵓⵙ, ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵜⴻⵎⵣⵉⴷⴰ, ⵢⵓⵎⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⴽⵓⵔⵉⵏⵜⵉⵢⵢⴻⵏ ⵓⵎⵉ ⴷ ⴰⵙ ⵙⵍⵉⵏ, ⵓⵎⵏⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_9","074_18_9","ACT","18","9","9","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⵙⵉⴷⵉ ⵉ ⴱⵓⵍⵓⵙ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ, ⵙⵉⵡⴻⵍ, ⵡⴰⵔ ⵜⵜⵙⴻⵇⵇⴰⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("AC18_10","074_18_10","ACT","18","10","10","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴽⵉⴷⴻⴽ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵛⴻⴽ ⵉⴹⴰⵔⵔ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC18_11","074_18_11","ACT","18","11","11","ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ ⴷⵉ ⴽⵓⵔⵉⵏⵜⵓⵙ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⴰⵙⴻⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC18_12","074_18_12","ACT","18","12","12","ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵖⴰⵍⵉⵢⵓⵏ ⵍⵄⴰⵎⵉⵍ ⵅ ⴰⵅⴰⵢⴰ, ⴽⴽⴰⵔⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵅ ⴱⵓⵍⵓⵙ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ, ");
INSERT INTO rift_vpl VALUES ("AC18_13","074_18_13","ACT","18","13","13","ⵏⵏⴰⵏ: “ⵡⴰ ⵉⵙⵙⴻⵇⵏⴰⵄ ⵉⵡⴷⴰⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵍⵄⴻⴽⵙ ⵏ ⵛⵛⴰⵔⵉⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC18_14","074_18_14","ACT","18","14","14","ⵓⵎⵉ ⵉⵜⵜⴰⵔ ⴱⵓⵍⵓⵙ ⵜⵜⴻⵙⵔⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ ⵖⴰⵍⵉⵢⵓⵏ ⵉ ⵡⵓⴷⴰⵢⴻⵏ: “ⵎⴰⵍⴰ ⵜⵓⵙⵉⵎ-ⴷⴷ ⴷⴰ ⴰⴽ-ⴷ ⵉⵛⴻⵜⵛⵉⵢⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⴼⵜⵓⵔⵉ ⵏⵉⵖ ⵏ ⵉⵊⵊ ⵏ ⵍⵖⴻⵛⵛ ⵏⵉⵖ ⵏ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⴰ ⵓⴷⴰⵢⴻⵏ, ⵅⴻⵏⵏⵉ ⵉⵍⵉ ⴰⴷ ⵉⵍⵉⵇ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⴱⵍⴻⵖ ⵙ ⵍⵃⴻⵇⵇ. ");
INSERT INTO rift_vpl VALUES ("AC18_15","074_18_15","ACT","18","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵅⴰⵔⵡⵉⴹⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵏⵉⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵏ ⵛⴰ ⵏ ⵉⵙⵎⴰⵡⴻⵏ, ⵏⵉⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵡⴻⵎ, ⵃⴹⴰⵎ ⵜ ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC18_16","074_18_16","ACT","18","16","16","ⵓⵛⴰ ⵢⵓⵥⵥⴻⵍ ⵅⴰⵙⴻⵏ ⵣⵉ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("AC18_17","074_18_17","ACT","18","17","17","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴽⵓⴼⴼⴰⵔ ⵙⵓⵙⵜⵉⵏⵉⵙ, ⴰⵎⵖⴰⵔ ⵏ ⵜⴻⵎⵣⵉⴷⴰ, ⵡⵜⵉⵏ ⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ, ⵎⴰⵛⴰ ⵖⴰⵍⵉⵢⵓⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵛⵇⵉ ⵎⴰⵏ ⴰⵢⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("AC18_18","074_18_18","ACT","18","18","18","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵇⵇⵉⵎ ⴱⵓⵍⵓⵙ ⴷⵉⵏ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵡⴻⴷⴷⴻⵄ ⵜⴰⵡⵎⴰⵜ ⵓⵛⴰ ⵉⴱⴻⵃⵃⴰⵔ ⵖⴰⵔ ⵙⵓⵔⵉⵢⴰ ⵓ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ ⴷ ⴰⴽⵡⵉⵍⴰ ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⴻⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵃⴻⴼⴼ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷⵉ ⴽⵉⵏⵅⵔⵉⵢⵓⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵊⵊⴰⴵ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("AC18_19","074_18_19","ACT","18","19","19","ⵓⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⴰⴼⴰⵙⵓⵙ, ⵢⵓⴷⴻⴼ ⴱⵓⵍⵓⵙ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ, ⵜⵓⵖⴰ ⵉⵜⵜⵃⴻⴷⴷⴰⵜ ⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_20","074_18_20","ACT","18","20","20","ⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵜⵜⴰⵔⴻⵏ ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⵇⵇⵉⵎ ⴽⵜⴰⵔ, ⵡⴰⵔ ⵉⵊⵊⵉ ⴰⴷ ⵜ ⵙⵙⵇⴻⵏⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_21","074_18_21","ACT","18","21","21","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ: “ⵉⵜⵜⵅⴻⵚⵚⴰ ⵏⵉⵛⴰⵏ ⴰⴷ ⵄⴻⵢⵢⴷⴻⵖ ⵍⵄⵉⴷ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⵎⴰⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ ⵄⴰⵡⴻⴷ ⵎⴰⵍⴰ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ!” ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⴽⵡⵉⵍⴰ ⴷ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ ⴷⵉ ⴰⴼⴰⵙⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC18_22","074_18_22","ACT","18","22","22","ⵉⵛⵓⵇ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ, ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵍⵄⵉⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵙⴻⴵⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵅⴻⵏⵏⵉ ⵉⵙⴰⴼⴰⵔ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC18_23","074_18_23","ACT","18","23","23","ⴰⵍⴰⵎⵉ ⴷⵉⵏ ⵉⵙⵙⴻⵄⴷⵓ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⴼⴼⴻⵖ ⵓⵛⴰ ⵉⵛⵓⵇ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴳⴰⵍⴰⵟⵉⵢⴰ ⴷ ⴼⵔⵉⵅⵉⵢⴰ, ⵉⵙⵙⴻⵎⵃⴻⴹ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_24","074_18_24","ACT","18","24","24","ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⴱⵓⵍⵍⵓⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⵉⵙⴽⴰⵏⴷⴰⵔⵉⵢⵢⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴰⴼⴰⵙⵓⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉⵙⵙⴻⵏ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ, ⵉⵜⵜⵃⴰⴽⴰ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_25","074_18_25","ACT","18","25","25","ⵡⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵍⵎⴻⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ, ⵜⵓⵖⴰ-ⵜ ⵙ ⴰⵔⵔⵓⵃ ⵉⵎⴻⵃⴹⴻⵏ. ⵉⵙⵙⴰⵡⴰⵍ ⵓ ⵉⵙⵙⴻⵍⵎⴰⴷ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵙ ⵛⴹⴰⵔⴻⵜ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵖⵉⵔ ⴰⵙⴻⵖⴹⴻⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC18_26","074_18_26","ACT","18","26","26","ⵉⴱⴷⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ. ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵙⵍⵉⵏ ⴰⴽⵡⵉⵍⴰ ⴷ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ, ⵉⵡⵢⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⵙⴻⵏ ⵓⵛⴰ ⵙⵙⴼⴻⵀⵎⴻⵏ ⴰⵙ ⴰⴱⵔⵉⴷ ⵏ ⵙⵉⴷⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC18_27","074_18_27","ACT","18","27","27","ⴰⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⴰⴼⴰⵔ ⵖⴰⵔ ⴰⵅⴰⵢⴰ, ⵛⴻⵊⵊⵄⴻⵏ ⵜ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵓⵔⵉⵏ ⵖⴰⵔ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⴰⴷ ⵜ ⵇⴻⴱⵍⴻⵏ ⵎⵍⵉⵃ. ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵡⴰ ⵖⴰⵔ ⴷⵉⵏ, ⵉⵄⴰⵡⴻⵏ ⵙ ⴰⵔⴹⴰ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⵉⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC18_28","074_18_28","ACT","18","28","28","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵇⴰⵛⴰⵃ ⵙ ⵊⵊⴻⵀⴷ ⴹⵉⴷⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵣⵣⴰⵜ ⵉ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵡⴷⴰⵏ, ⵉⵙⵙⴱⴻⵢⵢⴻⵏ ⴰⵙⴻⵏ ⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC19_1","074_19_1","ACT","19","1","1","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⴱⵓⵍⵍⵓⵙ ⴷⵉ ⴽⵓⵔⵉⵏⵜⵓⵙ, ⵉⵛⵓⵇ ⴱⵓⵍⵓⵙ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵢⵓⵄⵍⴰⵏ, ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⴰⴼⴰⵙⵓⵙ, ⵓⵛⴰ ⵉⴱⴷⴰ ⵉⵜⵜⵙⴻⵇⵙⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉ ⴷⵉⵏ ⵢⵓⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("AC19_2","074_19_2","ACT","19","2","2","ⵉⵙⵙⴻⵇⵙⴰ ⵜⴻⵏ: “ⵎⴰ ⵜⵇⴻⴱⵍⴻⵎ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵍⴰⵎⵉ ⵜⵓⵎⵏⴻⵎ?” ⵏⵉⵜⵏⵉ ⴰⵔⵔⵉⵏ-ⴷⴷ ⵅⴰⵙ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵏⴻⵙⵍⵉ ⵇⴰⵄ ⴱⴻⵍⵍⵉ ⴷⵉⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC19_3","074_19_3","ACT","19","3","3","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ?” ⵏⵏⴰⵏ ⴰⵙ: “ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵢⵓⵃⴰⵏⵏⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC19_4","074_19_4","ACT","19","4","4","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴱⵓⵍⵓⵙ: “ⵜⵓⵖⴰ ⵢⵓⵃⴰⵏⵏⴰ ⵉⵙⵙⴻⵖⴹⴰⵚ ⵍⴳⴻⵏⵙ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⵏ ⵜⵜⵓⴱⴻⵜ. ⵉⵇⵇⴰⵔ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵎⵏⴻⵏ ⵙ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("AC19_5","074_19_5","ACT","19","5","5","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵙⵍⵉⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵢⴰ, ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC19_6","074_19_6","ACT","19","6","6","ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⵉⵙⵙⴰⵔⵙ ⴱⵓⵍⵓⵙ ⴰⴼⵓⵙ, ⵉⵀⵡⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓⵛⴰ ⴱⴷⴰⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴱⴷⴰⵏ ⵜⵜⵏⴰⴱⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_7","074_19_7","ACT","19","7","7","ⵜⵓⵖⴰ-ⵜⴻⵏ ⵇⴰⵄ ⵜⴻⵏⵄⴰⵛ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_8","074_19_8","ACT","19","8","8","ⵢⵓⴷⴻⴼ ⴱⵓⵍⵓⵙ ⵖⴰⵔ ⵜⴻⵎⵣⵉⴷⴰ, ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵜⴻⵍⵜ ⵏ ⵉⵢⵓⵔⴻⵏ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ⵉⵜⵜⵃⴻⴷⴷⴰⵜ ⵖⴰⵔⵙⴻⵏ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵇⵏⴰⵄ ⴷⵉ ⵎⵉⵏ ⵉⵜⵜⵀⴻⵎⵎⴰⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC19_9","074_19_9","ACT","19","9","9","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵏ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵇⴻⵙⵃⴻⵏ, ⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ, ⵛⴻⵇⵇⴼⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵎⵓⵏⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵅⴻⵏⵏⵉ ⵉⴳⴳⵯⴻⵊ ⴱⵓⵍⵓⵙ ⵅⴰⵙⴻⵏ, ⵓⵛⴰ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵅⴰⵙⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵉⴱⴷⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⴽⵓⵍ ⴰⵙⵙ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⵉⵔⴰⵏⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC19_10","074_19_10","ACT","19","10","10","ⴰⵎⵎⵓ ⵉ ⵢⴻⴳⴳⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵍⴰⵎⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴰⵙⵉⵢⴰ ⵙⵍⵉⵏ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉ, ⴰⵎ ⵓⴷⴰⵢⴻⵏ ⴰⵎ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_11","074_19_11","ACT","19","11","11","ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴱⵓⵍⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("AC19_12","074_19_12","ACT","19","12","12","ⴰⵍⴰⵎⵉ ⴽⵙⵉⵏ ⵍⴻⵎⵃⴰⵎⴰⵜ ⵏ ⵍⴻⵇⵟⴻⵏ ⴷ ⵡⴻⵙⵜⴰⵡⴻⵏ ⵏ ⵉⴱⵓⵢⴰⵙ ⵉ ⵉⴵⴰⵏ ⴰⵔⵔⵓⴹ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵙⵙⴰⵔⵙⴻⵏ ⵜⴻⵏ ⵅ ⵉⵎⴻⵀⵍⴰⵛ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵔⵓⵃⴻⵏ ⵅⴰⵙⴻⵏ ⵍⴻⵀⵍⴰⵛⴰⵜ ⵓⵛⴰ ⵛⵛⵡⴰⵟⴻⵏ ⴼⴼⵖⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_13","074_19_13","ACT","19","13","13","ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵛⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵓⵖⴰ ⵙⵙⵓⴼⴼⵓⵖⴻⵏ ⵛⵛⵡⴰⵟⴻⵏ. ⵏⵉⵜⵏⵉ ⵜⵜⵄⴻⵣⵣⵎⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵔⵢⴰⵃ ⴰⵄⴻⴼⴼⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⵇⵇⴰⵔⴻⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵄⴻⵣⵣⴻⵎ ⵅⴰⴽ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⵉ ⵣⵉ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴱⵓⵍⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC19_14","074_19_14","ACT","19","14","14","ⵉⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵙⴽⵉⵡⴰ, ⵡⴻⵏⵏⵉ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵓⴷⴰⵢ. ");
INSERT INTO rift_vpl VALUES ("AC19_15","074_19_15","ACT","19","15","15","ⵎⴰⵛⴰ ⵛⵛⵉⵟⴰⵏ ⴰⵄⴻⴼⴼⴰⵏ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵢⴻⵛⵛⵓ ⵙⵙⵏⴻⵖ ⵜ ⵓⵍⴰ ⴷ ⴱⵓⵍⵓⵙ ⵙⵙⵏⴻⵖ ⵜ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⴻⵄⵏⴰⵎ ⴽⴻⵏⵏⵉⵡ?” ");
INSERT INTO rift_vpl VALUES ("AC19_16","074_19_16","ACT","19","16","16","ⵓⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵔⵢⴰⵃ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵏⴳⴻⵣ ⵅⴰⵙⴻⵏ, ⵉⵖⴻⵍⴱ ⵉ-ⵜⴻⵏ, ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵍⴰⵎⵉ ⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⴷ ⵉⵄⴰⵔⵢⴰⵏⴻⵏ ⴷ ⵉⵢⴻⵣⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_17","074_19_17","ACT","19","17","17","ⵍⴻⵅⴱⴰⵔ-ⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴰⴼⴰⵙⵓⵙ. ⵜⴻⵡⴹⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC19_18","074_19_18","ACT","19","18","18","ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵓⵙⵉⵏ-ⴷⴷ, ⵙⵜⴻⵄⵜⴰⵔⴻⴼⴻⵏ ⵅ ⵉⵄⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ, ⵏⴻⵄⵎⴻⵏ ⵙ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⵜⴻⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_19","074_19_19","ACT","19","19","19","ⵓⵍⴰ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⵃⵃⴰⵔⴻⵏ ⵢⴰⵔⵡⴻⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵏⵙⴻⵏ, ⵙⵙⵛⴻⵎⵎⴹⴻⵏ ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ. ⵏⵉⵜⵏⵉ ⴳⴳⵉⵏ ⴰⵙⴻⵏ ⵍⴻⵃⵙⴰⴱ ⵓⵛⴰ ⵓⴼⵉⵏ ⴱⴻⵍⵍⵉ ⵙⵙⴻⴽⴽⵡⴰⵏ ⵅⴻⵎⵙⵉⵏ-ⴰⵍⴰⴼ ⵏ ⵍⵡⴻⵣⵏⴰⵜ ⵏ ⵏⵏⵓⵇⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC19_20","074_19_20","ACT","19","20","20","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵍ’ⵉⵎⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰⵎ, ⵢⴰⵔⴻⵏⵏⵉ ⴷⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("AC19_21","074_19_21","ACT","19","21","21","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵉⴳⴳⴰ ⴱⵓⵍⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵛⵓⵇ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⴷ ⴰⵅⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴰⴼⴰⵔ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵉⵏⵏⴰ: “ⵅⵎⵉ ⴷⵉⵏ ⵉ ⵖⴰ ⵔⴻⵃⵃⴳⴻⵖ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⵥⴰⵔⴻⵖ ⵔⵓⵎⴰ ⵄⴰⵡⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("AC19_22","074_19_22","ACT","19","22","22","ⵉⵙⵙⴻⴽⴽ ⵜⵏⴰⵢⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵉⵏⴰ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ ⴷ ⵉⵔⴰⵙⵜⵓⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵇⵇⵉⵎ ⴷⵉⵏ ⵄⴰⴷ ⵛⴰ ⵏ ⵍⵡⴻⵇⵜ ⴷⵉ ⴰⵙⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC19_23","074_19_23","ACT","19","23","23","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵉⴽⴽⴰⵔ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC19_24","074_19_24","ACT","19","24","24","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵙⵉⵢⴰⵖ ⵏ ⵏⵏⵓⵇⴰⵔⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴷⵉⵎⵉⵜⵔⵉⵢⵓ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵚⴻⵏⵏⴰⵄ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵏ ⵏⵏⵓⵇⴰⵔⵜ ⵏ ‘ⴰⵔⵜⵉⵎⵉⵙ’ ⴷⵉ ⵍⴻⵇⵡⴰⵍⴻⴱ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵢⴰⵔⴱⴻⵃ ⵉ ⴰⵢⵜ ⵏ ⵚⵚⴻⵏⵄⴻⵜ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵃ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_25","074_19_25","ACT","19","25","25","ⵉⵙⵙⵎⵓⵏ-ⴷⴷ ⴰⵢⵜ ⵏ ⵚⵚⴻⵏⵄⴻⵜ ⵏⵏⴻⵙ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⴰⵔⴱⴻⵃ ⵏⵏⴻⵖ ⵢⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵚⵚⴻⵏⵄⴻⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC19_26","074_19_26","ACT","19","26","26","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵍⵉⵎ ⵓ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴱⵓⵍⵓⵙ ⵡⴰⵏⵉⵜⴰ ⵉⵙⵙⴻⵇⵏⴰⵄ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⴰⴼⴰⵙⵓⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⴰⵙⵉⵢⴰ, ⴰⵇⴰ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵉ-ⵜⴻⵏ ⵅ ⵍⴻⵅⵢⴰⵍⴰⵜ-ⴰ, ⵉⵇⵇⴰⵔ: ‘ⵍⴻⵅⵢⴰⵍⴰⵜ-ⴰ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("AC19_27","074_19_27","ACT","19","27","27","ⵡⴰⵔ ⵜⴻⴵⵉ ⵜⵙⴻⴱⴱⴰⴱⵜ-ⴰ ⵡⴰⵀⴰ ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵓⵛⴰ ⵜⴻⴳⴳⵓⵔ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉⴱⴻⵟⵟⵍⴻⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ‘ⴰⵔⵜⵉⵎⵉⵙ’, ⵜⴰⵔⴻⴱⴱⵉⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴰⴷ ⵜⵜ ⵃⴻⵙⴱⴻⵏ ⴷ ⵡⴰⵍⵓ ⵓⵛⴰ ⴰⴷ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵜⴰⵔⴻⴱⴱⵉⵜ-ⴰ ⵉ ⵜⵄⴻⴱⴱⴻⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⴰⵙⵉⵢⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC19_28","074_19_28","ACT","19","28","28","ⵓⵎⵉ ⵙⵍⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴷⴻⵡⵍⴻⵏ ⵅⴻⵢⵇⵇⴻⵏ ⴰⵟⵟⴰⵙ. ⵙⵖⵓⵢⵢⵓⵏ, ⵏⵏⴰⵏ: “ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵜⴰⵔⴻⴱⴱⵉⵜ ‘ⴰⵔⵜⵉⵎⵉⵙ’ ⵏ ⵉⴼⴰⵙⵓⵙⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC19_29","074_19_29","ACT","19","29","29","ⵜⴰⵏⴷⵉⵏⵜ ⵇⴰⵄ ⵜⵅⴰⵔⵡⴻⴹ ⴰⵎ ⵜⴻⴽⵎⴻⵍ ⵓⵛⴰ ⵓⵣⵣⵍⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵖⴰⵔ ⵜⵉⵢⴰⵜⵉⵔ ⵏ ⵍⵎⴻⵙⵔⴰⵃ, ⵓⵛⴰ ⵅⴰⵢⵓⵙ ⴷ ⴰⵔⵉⵙⵜⴰⵔⵅⵓⵙ, ⵉⵔⵢⴰⵣⴻⵏ ⵣⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵉⵏⵏⵉ ⴷ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏ ⴱⵓⵍⵓⵙ ⴷⴻⴳ ⵓⵙⴰⴼⴰⵔ ⵏⵏⴻⵙ, ⵟⵟⴼⴻⵏ ⵜⴻⵏ ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏ-ⴷⴷ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_30","074_19_30","ACT","19","30","30","ⵓⵍⴰ ⴷ ⴱⵓⵍⵓⵙ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵉⵢⴰⵜⵉⵔ ⵏ ⵍⵎⴻⵙⵔⴰⵃ, ⵎⴰⵛⴰ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC19_31","074_19_31","ACT","19","31","31","ⵉⵣⴻⴵⵉⴼⴻⵏ ⵉⵎⴹⴻⴱⴱⴰⵔⴻⵏ ⵏ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⴰⵙⵉⵢⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ, ⵙⵙⴻⴽⴽⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵔⴻⵇⵇⴰⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⴰⵢⴻⵙ ⵜⵜⴰⵔⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵙⴻⴱⴱⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵜⵉⵢⴰⵜⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("AC19_32","074_19_32","ACT","19","32","32","ⵍⵖⴰⵛⵉ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵎⵓⵏⴻⵏ ⴷⵉ ⵜⵉⵢⴰⵜⵉⵔ, ⵜⵓⵖⴰ ⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵜ ⴰⵟⵟⴰⵙ. ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⵢⵓⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵖⴰⵔ ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵅⴻⴼ ⵜⵓⵖⴰ ⵎⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC19_33","074_19_33","ACT","19","33","33","ⵍⴳⴻⵏⵙ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ, ⵏⴻⴷⵀⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵉⵊⵊ ⵏ ⵡⵓⴷⴰⵢ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵍⵉⴽⵙⴰⵏⴷⵉⵔ. ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ, ⵉⵛⴻⵢⵢⴰⵔ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵓⴷⴰⴼⴻⵄ ⵏ ⴱⵓⵍⵓⵙ ⵣⵣⴰⵜ ⵉ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("AC19_34","074_19_34","ACT","19","34","34","ⵎⴰⵛⴰ ⵓⵎⵉ ⴼⴻⵀⵎⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ-ⵜ ⴷ ⵓⴷⴰⵢ, ⵙⵖⵓⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵜⵎⵉⵊⵊⴰ ⴷ ⵉⵛⵜⴻⵏ ⵄⵍⴰⵃⴰⵍ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴰⵄⵄⴻⵜⵉⵏ: “ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ‘ⴰⵔⵜⵉⵎⵉⵙ’ ⵏ ⵉⴼⴰⵙⵓⵙⵉⵢⵢⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC19_35","074_19_35","ACT","19","35","35","ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵙⵙⵀⴻⴷⴷⴻⵏ ⵍⵖⴰⵛⵉ, ⵉⵏⵏⴰ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵏ ⴰⴼⴰⵙⵓⵙ, ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵉⴼⴰⵙⵓⵙⵉⵢⵢⴻⵏ ⴷ ⵜⴰⴽⴻⵀⵀⴰⵏⵜ ⵜⵃⴻⵟⵟⴰ ⵏⵉⵛⴰⵏ ⵅ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ‘ⴰⵔⵜⵉⵎⵉⵙ’ ⵓ ⵅ ⵍⴻⵅⵢⴰⵍ ⵉ ⴷⴷ-ⵉⵡⴹⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ! ");
INSERT INTO rift_vpl VALUES ("AC19_36","074_19_36","ACT","19","36","36","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵓⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵄⴻⴽⴽⴻⵙ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵉⵛⵓⵡⵡⴰⵔ ⴰⵡⴻⵎ ⴰⴷ ⵜⴰⵔⵙⴻⵎ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵛⴰ ⵙ ⵓⵇⴻⴵⴻⵇ, ");
INSERT INTO rift_vpl VALUES ("AC19_37","074_19_37","ACT","19","37","37","ⵎⵉⵏⵣⵉ ⵜⵉⵡⵢⴻⵎ-ⴷⴷ ⵉⵔⵢⴰⵣⴻⵏ-ⴰ ⴷⴰⵏⵉⵜⴰ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ ⵏ ⵜⵣⴰⵡⵉⵢⵢⵉⵏ ⵓⵍⴰ ⵡⴰⵔ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⵉ ⵜⵔⴻⴱⴱⵉⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC19_38","074_19_38","ACT","19","38","38","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵖⴰⵔ ⴷⵉⵎⵉⵜⵔⵉⵢⵓ ⵓ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⴻⵙ ⴷⵉ ⵚⵚⴻⵏⵄⴻⵜ ⵛⴰ ⵏ ⵓⵛⴻⵜⵛⵉ ⵅ ⵢⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵄⴰⵎⵉⵍ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵓ ⴰⴷ ⵛⴰⵔⵔⵄⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC19_39","074_19_39","ACT","19","39","39","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵅⵙⴻⵎ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏⵏⴻⵖⵏⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉ ⵉⵜⵜⵡⴻⵚⵚⴰⵏ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("AC19_40","074_19_40","ACT","19","40","40","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⴰⴷ ⵅⴰⵏⴻⵖ ⴹⴻⵍⵎⴻⵏ ⴰⵙⵙ-ⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵖⵓⵡⵡⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵍⴻⵙⴱⴰⴱ ⵉ ⵣⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵏⴰⵔⵔ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵡⴻⴳⵔⴰⵡ-ⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⵎⵓⵏⴰ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⵓ ⵏⴻⵜⵜⵖⴻⵡⵡⴻⵖ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC19_41","074_19_41","ACT","19","41","41","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵙⵎⴻⵃ ⵉ ⵡⴻⴳⵔⴰⵡ ⴰⴷ ⵢⵓⵢⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("AC20_1","074_20_1","ACT","20","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵢⴰⵔⵙⴰ ⵓⵖⵓⵡⵡⴻⵖ, ⵉⵍⴰⵖⴰ-ⴷⴷ ⴱⵓⵍⵓⵙ ⵅ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵉⵡⴻⴷⴷⴻⵄ ⵉ-ⵜⴻⵏ ⵙ ⵓⵙⵓⴷⴻⵎ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC20_2","074_20_2","ACT","20","2","2","ⵍⴰⵎⵉ ⵉⵛⵓⵇ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⵉ, ⵉⵛⴻⵊⵊⴻⵄ ⵉ-ⵜⴻⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ, ⵅⴻⵏⵏⵉ ⵢⵉⵡⴻⴹ ⵖⴰⵔ ⵀⵉⵍⵍⴰⵙ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵖⴰⵔ ⵊⵊⵉⵀⴻⵜ ⴰⵅⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC20_3","074_20_3","ACT","20","3","3","ⴰⵍⴰⵎⵉ ⵉⵙⵙⴻⵄⴷⵓ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵙⵙⴻⵡⵊⴷⴻⵏ ⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⴰⴷ ⵉⴱⴻⵃⵃⴰⵔ ⵖⴰⵔ ⵙⵓⵔⵉⵢⴰ. ⵙ ⵓⵢⴰ ⵉⴳⴳⴰ ⴰⴷ ⵢⴻⵄⵇⴻⴱ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC20_4","074_20_4","ACT","20","4","4","ⵙⵓⴱⴰⵜⵔⵓⵙ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴱⵉⵔⵉⵢⴰ, ⴰⵔⵉⵙⵜⴰⵔⵅⵓⵙ ⴷ ⵙⵉⴽⵓⵏⴷⵓⵙ ⵣⵉ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ, ⵅⴰⵢⵓⵙ ⵣⵉ ⴷⵉⵔⴱⵉ, ⵜⵉⵎⵓⵜⵉⵢⵓ ⵣⵉ ⵍⵉⵙⵜⵔⴰ ⵓ ⵜⵉⵛⵉⴽⵓⵙ ⴷ ⵜⵔⵓⴼⵉⵎⵓⵙ ⵣⵉ ⴰⵙⵉⵢⴰ ⵓⵢⵓⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ ⴰⵍ ⴰⵙⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC20_5","074_20_5","ACT","20","5","5","ⵉⵏⴰ ⵉⵣⵡⴰⵔⴻⵏ ⴰⵏⴻⵖ, ⵜⵜⵔⴰⵊⴰⵏ ⴰⵏⴻⵖ ⴷⵉ ⵜⵔⵓⵡⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC20_6","074_20_6","ACT","20","6","6","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴼⴼⴻⵖ ⵣⵉ ⴼⵉⵍⵉⴱⴱⵉ, ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵡⴻⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵏⴻⴽⴽⴰ ⵅ ⵍⴻⴱⵃⴰⵔ ⵓ ⴷⵉ ⵅⴻⵎⵙⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵜⵔⵓⵡⴰⵙ ⵎⴰⵏⵉ ⵏⴻⵇⵇⵉⵎ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_7","074_20_7","ACT","20","7","7","ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵓⵎⵉ ⵎⵓⵏⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵔⵥⴻⵏ ⴰⵖⵔⵓⵎ ⵏ ⵜⵏⴻⵎⵎⵉⵔⵜ, ⵉⵙⵙⵉⵡⴻⵍ ⴱⵓⵍⵓⵙ ⴰⴽⵉⴷⵙⴻⵏ. ⵉⵙⵙⵣⵓⴳⴰⵔ ⴱⵓⵍⵓⵙ ⴷⵉ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ ⴰⵍ ⵍⵡⴻⵙⵟ ⵏ ⴵⵉⵍⴻⵜ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵏⵡⴰ ⴰⴷ ⵉⵙⴰⴼⴰⵔ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC20_8","074_20_8","ACT","20","8","8","ⴰⵇⴰ ⴰⵔⴻⵇⵇⴻⵏ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ ⴷⵉ ⵜⵖⵓⵔⴼⴻⵜ ⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵏⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_9","074_20_9","ACT","20","9","9","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴱⵍⵉⵖ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵓⵜⵉⵅⵓⵙ, ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⴽⴰⵣⵉ, ⵉⵜⵜⴻⵙⵍⴰ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⴽⴽⴰ ⵅⴰⵙ ⵢⵉⴹⴻⵚ ⵢⵓⴵⴻⵖ ⴰⵎ ⵜⵓⵖⴰ ⴱⵓⵍⵓⵙ ⵉⵙⵙⵣⵓⴳⴰⵔ ⴷⵉ ⵍⵀⴰⵔⴷ ⵏⵏⴻⵙ. ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴻⵚ, ⵉⵡⴹⴰ-ⴷⴷ ⵣⵉ ⵟⵟⴻⴱⵇⴻⵜ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵖⴰⵔ ⵡⴰⴷⴷⴰⵢ, ⴽⵙⵉⵏ ⵜ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("AC20_10","074_20_10","ACT","20","10","10","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵉⵀⵡⴰ, ⵉⵡⴹⴰ ⵅⴰⵙ, ⵉⴷⴰⵔⵔⴻⵄ ⴰⵙ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⴻⵏⵏⴻⵅⵍⵉⵄⴻⵎ ⵛⴰ, ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵜⵓⴷⴰⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC20_11","074_20_11","ACT","20","11","11","ⵅⴻⵏⵏⵉ ⵢⵓⵍⵉ ⵄⴰⵡⴻⴷ, ⵢⴰⵔⵥⴰ ⴰⵖⵔⵓⵎ, ⵉⵛⵛⴰ ⵛⵡⴰⵢⵜ ⵣⵣⴰⵢⴻⵙ, ⵅⴻⵏⵏⵉ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵄⴰⴷ ⴰⵟⵟⴰⵙ ⴰⵍⴰⵎⵉ ⴷ ⵍⴻⴼⵊⴰⵔ. ⵅⴰⵙ ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵙⴰⴼⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("AC20_12","074_20_12","ACT","20","12","12","ⴰⵎ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵃⴻⵏⵊⵉⵔ ⵉⴷⴷⴰⵔ, ⴼⴰⵔⵃⴻⵏ ⴰⵙ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC20_13","074_20_13","ACT","20","13","13","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵏⵢⴰ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵏⴱⴻⵃⵃⴰⵔ ⵖⴰⵔ ⵍⵎⴰⵔⵙⴰ ⵏ ⵜⵉⵙⵙⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⴷⴷ-ⵏⴰⵡⵉ ⴱⵓⵍⵓⵙ ⵙⵙⴻⵏⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴹⴻⴱⴱⴰⵔ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⴽⴽⴰ ⵖⴰⵔ ⴷⵉⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC20_14","074_20_14","ACT","20","14","14","ⴰⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵏⴰⵔⴻⵃⵃⴻⴱ ⴷⵉ ⵜⵉⵙⵙⵓⵙ, ⵏⴻⴽⵙⵉ ⵜ ⴷⵉ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵓⵛⴰ ⵏⵉⵡⴻⴹ-ⴹⴹ ⵖⴰⵔ ⵎⵉⵜⵉⵍⵉⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC20_15","074_20_15","ACT","20","15","15","ⵙⵙⴻⵏⵏⵉ ⵏⴻⵄⴷⵓ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⵅⵉⵢⵓⵙ ⵓ ⴼⴰⵔⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵏⵉⵡⴻⴷ ⵖⴰⵔ ⵙⴰⵎⵓⵙ, ⵏⴻⵇⵇⵉⵎ ⴷⵉ ⵜⵔⵓⵅⵉⵍⵉⵢⵓⵏ. ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵎⵉⵍⵉⵜⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("AC20_16","074_20_16","ACT","20","16","16","ⵎⵉⵏⵣⵉ ⴱⵓⵍⵓⵙ ⵉⴳⴳⴰ ⴰⴷ ⵉⵄⴷⵓ ⴰⴼⴰⵙⵓⵙ ⵅ ⵍⴻⴱⵃⴰⵔ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⴰⵍ ⴷⵉⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵇⴻⴵⴻⵇ ⵃⵉⵎⴰ, ⵎⴻⵄⵍⵉⴽ ⵉⵄⴻⴷⴷⴻⵍ, ⴰⴷ ⵉⵄⴻⵢⵢⴻⴷ ⵍⵄⵉⴷ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC20_17","074_20_17","ACT","20","17","17","ⵣⵉ ⵎⵉⵍⵉⵜⵓⵙ ⵉⵊⵊⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⴰⴼⴰⵙⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC20_18","074_20_18","ACT","20","18","18","ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵖⴰⵔⴻⵙ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵎⵉ ⴷⴷ-ⵓⴷⴼⴻⵖ ⵖⴰⵔ ⴰⵙⵉⵢⴰ, ⵎⴰⵎⵎⴻⵛ ⴵⵉⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵓⵙⵙⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("AC20_19","074_20_19","ACT","20","19","19","ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⴹⴻⵄ ⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ, ⵓⵍⴰ ⴷⴻⴳ ⵉⵖⴻⴽⴽⵡⴰⵏ ⵉ ⵅⴰⴼⵉ ⵉⴽⴽⵉⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⴻⵄⵎⴰⵍⵜ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_20","074_20_20","ACT","20","20","20","ⵡⴰⵔ ⵊⵊⵉⵖ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⵏⴻⴼⵄⴻⵏ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜ ⴱⴰⵔⵔⵃⴻⵖ, ⵡⴰⵔ ⵜ ⵙⵙⵍⴻⵎⴷⴻⵖ ⴷⵉ ⵍⴻⵙⵡⴰⵇ ⵓ ⴷⵉ ⵜⵓⴷⵔⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("AC20_21","074_20_21","ACT","20","21","21","ⴰⵎ ⵙⵙⵇⴻⵏⵄⴻⵖ ⵓⴷⴰⵢⴻⵏ ⴷ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⴰⵎⵏⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ.    ");
INSERT INTO rift_vpl VALUES ("AC20_22","074_20_22","ACT","20","22","22","ⵓ ⵍⴻⵅⵅⵓ ⴰⴷ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎ ⵜⵜⵡⴰⵛⴰⵔⴼⴻⵖ ⵣⵉ ⴰⵔⵔⵓⵃ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵜⵜⵔⴰⵊⴰⵏ ⴷⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("AC20_23","074_20_23","ACT","20","23","23","ⵎⵖⵉⵔ ⴰⵇⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵛⵀⴻⴷ ⴰⵢⵉ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ, ⵉⵇⵇⴰⵔ: ‘ⴰⵇⴰ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⴷ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵜⵜⵔⴰⵊⴰⵏ ⵛⴻⴽ!’ ");
INSERT INTO rift_vpl VALUES ("AC20_24","074_20_24","ACT","20","24","24","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⵙⵙⴱⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵛⴰ ⵜⵉⵖⵍⴰ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⵜⵉⵛⵍⵉ ⵉⵏⵓ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⴽⵙⵉⵖ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵀⴷⴻⵖ ⵅ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC20_25","074_20_25","ACT","20","25","25","ⵓ ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵥⴰⵔ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ ⵄⴰⴷ, ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⴳⴳⵓⵔⴻⵖ, ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC20_26","074_20_26","ACT","20","26","26","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵛⴻⵀⴷⴻⵖ ⴰⵙⵙ-ⴰ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵜⵜⴱⴰⵔⵔⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵡⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC20_27","074_20_27","ACT","20","27","27","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵄⴳⵉⵣⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⴻⵅⵙ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC20_28","074_20_28","ACT","20","28","28","ⵙ ⵓⵢⴻⵏⵏⵉ ⵃⴹⴰⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵓ ⵅ ⵜⵃⵉⵎⴰⵔⵜ ⵜⵎⵓⵏ ⵎⵉⵏ ⵅⴻⴼ ⵉⴳⴳⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⴻⵃⴹⴰⵢⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⵡⴻⵙⴻⵎ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⵜⴻⵏⵏⵉ ⴷ ⵉⴽⴻⵙⵙⴻⴱ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC20_29","074_20_29","ACT","20","29","29","ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⴰⵡⴰⵔⵏⵉ ⵜⵡⴰⵃⵉⵜ ⵉⵏⵓ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵡⵓⵛⵛⴰⵏⴻⵏ ⵉⵎⵓⵣⵣⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉⵏ ⵜⴰⵃⵉⵎⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC20_30","074_20_30","ACT","20","30","30","ⵄⴰⴷ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵍⵀⴰⵔⴷ ⵉⵄⴻⵡⵡⵊⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴰⴷ ⵜⴻⵏ ⵊⴰⵔⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_31","074_20_31","ACT","20","31","31","ⵙ ⵓⵢⴻⵏⵏⵉ ⴼⴰⵇⴻⵎ, ⵜⵄⴻⵇⵍⴻⵎ ⴱⴻⵍⵍⵉ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ, ⵡⴰⵔ ⴱⴻⴷⴷⴻⵖ ⴰⴷ ⵙⵙⵎⴻⵃⴷⴻⵖ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_32","074_20_32","ACT","20","32","32","ⵓ ⵍⴻⵅⵅⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⴻⵍⵍⵎⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ, ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴱⵏⴰ ⵓ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵍⵡⴰⵔⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_33","074_20_33","ACT","20","33","33","ⵡⴰⵔ ⴹⵎⵉⵄⴻⵖ ⴷⵉ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵉⵖ ⴷⴻⴳ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⴷⴻⴳ ⵡⴰⵔⵔⵓⴹ ⵓⵍⴰ ⵣⴻⴳ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC20_34","074_20_34","ACT","20","34","34","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⴱⴻⵍⵍⵉ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⴰⵇⴰ ⵅⴻⴷⵎⴻⵏ ⵉ ⵎⵉⵏ ⵃⵡⴰⵊⴻⵖ ⵓ ⵉ ⵎⵉⵏ ⵃⵡⴰⵊⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("AC20_35","074_20_35","ACT","20","35","35","ⴷⵉ ⴽⵓⵍⵛⵉ ⵙⵙⴻⵛⵏⴻⵖ ⴰⵡⴻⵎ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ, ⴰⵎ ⵏⵅⴻⴷⴷⴻⵎ ⴰⵎⵎⵓ, ⴰⴷ ⵏⴻⵡⵛ ⴰⴼⵓⵙ ⵉ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ ⵓⵛⴰ ⴰⴷ ⵏⴼⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⴱⴻⵍⵍⵉ ⵉⵏⵏⴰ: ‘ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("AC20_36","074_20_36","ACT","20","36","36","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵡⴹⴰ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⴻⵙ, ⵉⵥⵥⵓⴵ ⵓ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC20_37","074_20_37","ACT","20","37","37","ⴰⵇⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵓⵛⴰ ⴷⴰⵔⵔⵄⴻⵏ ⴰⵙ, ⵙⵙⵓⴷⵎⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC20_38","074_20_38","ACT","20","38","38","ⵛⴻⴹⵏⴻⵏ ⴰⵟⵟⴰⵙ, ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵅ ⵡⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵥⴰⵔⵔⴻⵏ ⵛⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵄⴰⴷ, ⵓⵛⴰ ⵙⵙⵇⴻⴱⴱⴹⴻⵏ ⵜ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ. * ");
INSERT INTO rift_vpl VALUES ("AC21_1","074_21_1","ACT","21","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵅⴰⵙⴻⵏ ⵏⴻⵎⵎⵙⴻⴱⴹⴰ, ⵏⴻⴱⴷⴰ ⵏⵥⴻⴽⴽⵡⴰ ⵍⴻⴱⵃⴰⵔ, ⵏⵔⵓⵃ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⴽⵓⵙ. ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵔⵓⴷⵓⵙ ⵓ ⵙⵙⴻⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵜⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC21_2","074_21_2","ACT","21","2","2","ⵏⵓⴼⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵉ ⵜⵓⵖⴰ ⴰⴷ ⵉⵥⵡⴰ ⵖⴰⵔ ⴼⵉⵏⵉⵇⵉⵢⴰ, ⵏⴻⵏⵢⴰ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵏⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("AC21_3","074_21_3","ACT","21","3","3","ⵍⴰⵎⵉ ⴷⴷ-ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⵇⵓⴱⵔⵓⵙ, ⵏⴻⵊⵊⴰ ⵉ-ⵜⵜ ⵅ ⵓⵣⴻⵍⵎⴰⴹ ⵓⵛⴰ ⵏⵔⵓⵃ ⵅ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵙⵓⵔⵉⵢⴰ ⵓⵛⴰ ⵙⵙⴻⵏⵏⵉ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵚⵓⵔ, ⵎⵉⵏⵣⵉ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴰⴷ ⵉⴼⴰⵔⵔⴻⵖ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵙ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC21_4","074_21_4","ACT","21","4","4","ⵓⵎⵉ ⵏⵓⴼⴰ ⴷⵉⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ, ⵏⴻⵇⵇⵉⵎ ⵖⴰⵔⵙⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⴽⵓⵍ ⴰⵙⵙ ⵏⵏⴰⵏ ⵏⵉⵜⵏⵉ ⵙ ⴰⵔⵔⵓⵃ ⵉ ⴱⵓⵍⵓⵙ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⴳⴻⵄⵄⵉⴷ ⵛⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC21_5","074_21_5","ACT","21","5","5","ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⵓⵙⵙⴰⵏ-ⴰ ⵏⴻⴼⴼⴻⵖ, ⵏⵓⵢⵓⵔ. ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵇⴻⴱⴹⴻⵏ ⴰⵏⴻⵖ, ⵏⵉⵜⵏⵉ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ, ⴰⵍ ⴱⴰⵔⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵡⴹⴰⵏ ⵅ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵥⵥⵓⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC21_6","074_21_6","ACT","21","6","6","ⵓⵎⵉ ⵏⵡⴻⴷⴷⴻⵄ ⴰⵢⴰⵡⵢⴰ ⵙ ⵓⵙⵓⴷⴻⵎ, ⵏⴻⵏⵢⴰ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵄⴻⵇⴱⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_7","074_21_7","ACT","21","7","7","ⵓⵎⵉ ⵏⴽⴻⵎⵎⴻⵍ ⵅ ⵓⵙⴰⴼⴰⵔ ⵣⵉ ⵚⵓⵔ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⴱⵜⵓⵍⵓⵎⴰⵢⵓ, ⵏⵙⴻⴵⵎⴻⵏ ⵅ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵓⵛⴰ ⵏⴻⵇⵇⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_8","074_21_8","ACT","21","8","8","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵏⴻⴼⴼⴻⵖ ⵙⵙⴻⵏⵏⵉ, ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ. ⵏⵓⴷⴻⴼ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵎⴱⴻⵛⵛⴰⵔ ⴼⵉⵍⵉⴱⴱⵓⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵓⵛⴰ ⵏⴻⵇⵇⵉⵎ ⵖⴰⵔⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("AC21_9","074_21_9","ACT","21","9","9","ⵜⵓⵖⴰ ⵖⴰⵔ ⵡⴰ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⵄⴰⴷ ⴷ ⵜⵉⵄⴻⵣⵔⵉⵢⵢⵉⵏ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC21_10","074_21_10","ACT","21","10","10","ⵓⵎⵉ ⵏⴻⵏⵏⵉⵡⵊⴻⵡ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵀⵡⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵏⴰⴱⵉ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵖⴰⴱⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_11","074_21_11","ACT","21","11","11","ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⴱⵢⴰⵙ ⵏ ⴱⵓⵍⵓⵙ, ⵉⵛⴰⵔⴼ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⴼⴰⵙⵙⴻⵏ ⴷ ⵉⴹⴰⵔⴻⵏ, ⵉⵏⵏⴰ: “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ: ‘ⴰⵔⵢⴰⵣ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴱⵢⴰⵙ-ⴰ, ⴰⵎⵎⵓ ⵉ ⵜ ⵖⴰ ⵛⴰⵔⴼⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵛⴰ ⴰⴷ ⵜ ⵙⴻⵍⵍⵎⴻⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ.’” ");
INSERT INTO rift_vpl VALUES ("AC21_12","074_21_12","ACT","21","12","12","ⵓⵎⵉ ⵏⴻⵙⵍⴰ ⴰⵡⴰⵍⴻⵏ-ⴰ, ⵏⴻⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ, ⴰⵎ ⵏⴻⵛⵛⵉⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵣⵉ ⵊⵊⵡⴰⵢⴻⵀ ⵏⵏⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⴳⴻⵄⵄⵉⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC21_13","074_21_13","ACT","21","13","13","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵎⵉⵏ ⴽⴻⵏⵏⵉⵡ ⵢⵓⵖⵉⵏ, ⵜᵉⵜⵜⵔⵓⵎ ⵓⵛⴰ ⵜⴻⵙⵙⴰⵔⴻⴹⴱⴻⵎ ⵓⵍ ⵉⵏⵓ? ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵢⵉ ⵡⴻⵊⴷⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵛⴰⵔⴼⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⵜⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ.” ");
INSERT INTO rift_vpl VALUES ("AC21_14","074_21_14","ACT","21","14","14","ⵓⵎⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵊⵊⵉ ⴰⴷ ⵜ ⵏⴻⵙⵙⴻⵇⵏⴻⵄ, ⵏⴻⵙⵇⴰⵔ, ⵏⴻⵇⵇⴰⵔ: “ⴰⴷ ⵢⵉⵍⵉ ⵎⵉⵏ ⵉⵅⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC21_15","074_21_15","ACT","21","15","15","ⴰⵡⴰⵔⵏⵉ ⵓⵙⵙⴰⵏ ⵏⵏⵉ ⵏⴻⵙⵙⴻⵡⵊⴻⴷ ⵓⵛⴰ ⵏⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC21_16","074_21_16","ACT","21","16","16","ⵔⵓⵃⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵛⴰ ⵏ ⵉⵔⵢⴰⵣⴻⵏ, ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵣⵉ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ, ⵉⵡⵢⴻⵏ-ⴷⴷ ⵉⵊⵊ ⵏ ⵜⴻⵡⵎⴰⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⵏⴰⵙⵓⵏ ⵣⵉ ⵇⵓⴱⵔⵓⵙ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵏⴻⵏⵏⵉⵡⵊⴻⵡ. ");
INSERT INTO rift_vpl VALUES ("AC21_17","074_21_17","ACT","21","17","17","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵜⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⵏⴻⵖ ⵜⴰⵡⵎⴰⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC21_18","074_21_18","ACT","21","18","18","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵢⵓⴷⴻⴼ ⴱⵓⵍⵓⵙ ⴰⴽⵉⴷⵏⴻⵖ ⵖⴰⵔ ⵢⴰⵄⵇⵓⴱ, ⵓⵎⵉ ⵃⴹⴰⵔⴻⵏ ⴷⵉⵏ ⴰⴽⵉⴷⴻⵙ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC21_19","074_21_19","ACT","21","19","19","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵅⴰⵙⴻⵏ ⵏⵙⴻⴵⴻⵎ, ⵉⴱⴷⴰ ⴱⵓⵍⵓⵙ ⴰⴷ ⵉⵄⴰⵡⴻⴷ ⵙ ⵓⵙⴻⵜⵜⴻⴼ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_20","074_21_20","ACT","21","20","20","ⵓⵎⵉ ⵙⵍⵉⵏ ⴰⵢⴰ, ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵏⴰⵏ ⴰⵙ: “ⴰ ⵓⵎⴰⵜⵏⴻⵖ, ⵜᵉⵜⵜⵡⴰⵍⵉⴷ ⵎⴻⵛⵃⴰⵍ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵉ ⵢⵓⵎⵏⴻⵏ, ⵓ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵜⵜⴰⵙⵎⴻⵏ ⵅ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("AC21_21","074_21_21","ACT","21","21","21","ⵎⴰⵛⴰ ⵢⵉⵡⴻⴹ ⴰⵙⴻⵏ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ ⵅⴰⴽ ⴱⴻⵍⵍⵉ ⵜⴻⵙⵙⴻⵍⵎⴰⴷⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵅⴻⵜⵜⵏⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("AC21_22","074_21_22","ACT","21","22","22","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵙⵍⵉⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵜⵓⵙⵉⴷ-ⴷⴷ ⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("AC21_23","074_21_23","ACT","21","23","23","ⴻⴳⴳ ⵎⵉⵏ ⴷ ⴰⵛ ⵖⴰ ⵏⵉⵏⵉ! ⵖⴰⵔⵏⴻⵖ ⴰⵔⴻⴱⵄⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵎⴰⵀⴻⵏⴷ ⴰⴷ ⵙⵙⵉⵣⴷⵉⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC21_24","074_21_24","ACT","21","24","24","ⴰⵡⵉ ⵉⵏⴰ ⴰⴽⵉⴷⴻⴽ, ⵜⴻⵙⵙⵉⵣⴷⴻⴳⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⴽⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⵅⴻⴵⴻⵚ ⵅⴰⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵃⴻⴼⴼⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ. ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵏ ⵎⴰⵔⵔⴰ ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⵅⴰⴽ ⵉⵜⵜⵡⴰⵏⵏⴰⵏ ⵡⴰⵔ ⵉⴵⵉ ⴱⵓ ⵏⵉⵛⴰⵏ, ⵓ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⵜᵉⵜⵜⴽⴻⵎⵎⵍⴻⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⵜᵉⵜⵜᵉⵟⵟⴼⴻⴷ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_25","074_21_25","ACT","21","25","25","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴰⵇⴰ ⵏⵓⵔⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⴱⴻⵄⵄⴷⴻⵏ ⵅ ⵎⵉⵏ ⵉⵖⴰⵔⵚⴻⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ, ⵅ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵅ ⵊⵊⵉⵢⴼⴰⵜ, ⵓⵍⴰ ⵅ ⵉⴷⴰⵎⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC21_26","074_21_26","ACT","21","26","26","ⵅⴻⵏⵏⵉ ⵢⵉⵡⵢⵉ ⴱⵓⵍⵓⵙ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵙⴻⵏ. ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴽⴻⵎⵎⵍⴻⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵙⵉⵣⴷⴻⴳ, ⴰⵍ ⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵣⵉ ⵎⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_27","074_21_27","ACT","21","27","27","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵡⴰⵙⵙ ⵙⴻⴱⵄⴰ, ⵥⵔⵉⵏ ⵜ ⵡⵓⴷⴰⵢⴻⵏ ⵏ ⴰⵙⵉⵢⴰ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵏ ⵍⴳⴻⵏⵙ ⵎⴰⵔⵔⴰ ⴹⵉⴷⴷ ⵏⵏⴻⵙ, ⵃⴰⵔⵜⴻⵏ ⵅⴰⵙ ⵙ ⵉⴼⴰⵙⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC21_28","074_21_28","ACT","21","28","28","ⵙⵖⵓⵢⵢⵓⵏ: “ⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵖⴰⵡⵍⴻⵎ ⵖⴰⵔ ⵜⵡⵉⵣⴰ! ⵡⴰ ⴷ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵖ ⵓ ⴹⵉⴷⴷ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⴹⵉⴷⴷ ⵉ ⵡⴻⵎⵛⴰⵏ-ⴰ. ⵄⴰⵡⴻⴷ ⵉⵙⵙⵉⴷⴻⴼ-ⴷⴷ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵉⵙⵙⴻⵅⵎⴻⵊ ⴰⵎⵛⴰⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵏⵉⵜⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC21_29","074_21_29","ACT","21","29","29","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵣⵡⴰⵔⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵥⵔⵉⵏ ⵜⵔⵓⴼⵉⵎⵓⵙ ⵣⵉ ⴰⴼⴰⵙⵓⵙ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⴽ-ⴷ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_30","074_21_30","ACT","21","30","30","ⵜⴰⵏⴷⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵀⴰⵊ ⵓⵛⴰ ⵉⵡⴷⴰⵏ ⴷⴷⵓⵇⵇⵣⴻⵏ-ⴷⴷ, ⵃⴰⵔⵜⴻⵏ ⵅ ⴱⵓⵍⵓⵙ, ⵊⴰⵔⵔⴻⵏ ⵜ ⴱⴰⵔⵔⴰ ⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴱⴻⵍⵍⵄⴻⵏⵜ ⵜⵉⵡⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC21_31","074_21_31","ACT","21","31","31","ⴰⵎ ⵢⴰⵔⴻⵣⵣⵓ ⵍⵖⴰⵛⵉ ⴰⴷ ⵜ ⵉⵏⴻⵖ, ⵢⵉⵡⴻⴹ ⵍⴻⵅⴱⴰⵔ ⵖⴰⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵏ ⵍⴽⵓⵎⴱⴰⵏⵉⵢⵢⴻⵜ, ⴰⵇⴰ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎⴻⵏ ⵜⴻⴽⵎⴻⵍ ⵜⵅⴰⵔⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("AC21_32","074_21_32","ACT","21","32","32","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵢⵉⵡⵢⵉ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵓⴱⴰⵔⵔⵓ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵓⵣⵣⵍⴻⵏ ⵖⴰⵔⵙⴻⵏ. ⴰⵍⴰⵎⵉ ⵥⵔⵉⵏ ⵏⵉⵜⵏⵉ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⴷ ⵍⵄⴻⵙⴽⴰⵔ, ⵙⵙⴱⴻⴷⴷⴻⵏ ⴰⴷ ⵡⵜⴻⵏ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC21_33","074_21_33","ACT","21","33","33","ⴰⵍⴰⵎⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵟⵟⴻⴼ ⵉ-ⵜ, ⵢⵓⵎⵓⵔ ⴰⴷ ⵜ ⵛⴰⵔⴼⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵙⵙⵏⴰⵙⴻⵍ, ⵅⴻⵏⵏⵉ ⵉⵙⵙⴻⵇⵙⴰ ⵎⵉⵏ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ ⴷ ⵎⵉⵏ ⵉⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("AC21_34","074_21_34","ACT","21","34","34","ⵊⴰⵔ ⵍⵖⴰⵛⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵉⵜⵜⵍⴰⵖⴰ ⴰⵎⵎⵓ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎⵎⵓ. ⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵏ ⵜⵉⴷⴻⵜⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵀⴰⵔⴰⵊ, ⵢⵓⵎⵓⵔ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵇⴻⵛⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("AC21_35","074_21_35","ACT","21","35","35","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⴱⵓⵍⵓⵙ ⵖⴰⵔ ⴷⴷⵔⵓⵊ, ⵉⵎⵙⴰⵔ ⴱⴻⵍⵍⵉ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⵔⴱⵓⵏ ⵜ ⵅ ⵙⵙⴱⴰⴱ ⵏ ⵍⵄⵓⵏⴼ ⵏ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("AC21_36","074_21_36","ACT","21","36","36","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵜⵓⵖⴰ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜ, ⵙⵖⵓⵢⵢⵓⵏ, ⵏⵏⴰⵏ: “ⴽⴽⵙⴻⵎ ⵜ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC21_37","074_21_37","ACT","21","37","37","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵍⵇⴻⵛⵍⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵉⵏⵏⴰ ⴱⵓⵍⵓⵙ ⵉ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ: “ⵎⴰ ⵉⵃⵉⵇⵇ ⴰⵢⵉ ⴰⴷ ⴰⵛ ⵉⵏⵉⵖ ⵛⴰ?” ⵉⵏⵏⴰ ⴰⵙ: “ⵎⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵜⴰⵢⵓⵏⴰⵏⵉⵜ? ");
INSERT INTO rift_vpl VALUES ("AC21_38","074_21_38","ACT","21","38","38","ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴻⴽ ⴷ ⴰⵎⵉⵚⵔⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵖⵓⵡⵡⴻⵖ ⵇⴱⴻⵍ ⵓⵙⵙⴰⵏ-ⴰ, ⵉⵏⴷⴻⵀ ⴰⴽⵉⴷⴻⵙ ⴰⵔⴻⴱⵄⴰ ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴷ ⵉⵇⴻⵜⵜⴰⵍⴻⵏ ⵖⴰⵔ ⵍⴻⵅⵍⴰ?” ");
INSERT INTO rift_vpl VALUES ("AC21_39","074_21_39","ACT","21","39","39","ⵉⵏⵏⴰ ⴰⵙ ⴱⵓⵍⵓⵙ: “ⵏⴻⵛⵛ ⴷ ⴰⵔⵢⴰⵣ ⴷ ⵓⴷⴰⵢ ⵣⵉ ⵜⴰⵔⵙⵓⵙ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⴷⵉ ⴽⵉⵍⵉⴽⵉⵢⴰ ⵎⴰⵏⵉ ⴷⴷ-ⵅⴻⵍⵇⴻⵖ. ⵏⴻⵛⵛ ⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵢⴻⴽ ⵜⵜⴻⵙⵔⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵖⴰⵔ ⵍⴳⴻⵏⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC21_40","074_21_40","ACT","21","40","40","ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵙⵎⴻⵃ, ⵉⴱⴻⴷⴷ ⴱⵓⵍⵓⵙ ⵅ ⴷⴷⵔⵓⵊ, ⵉⵛⴻⵢⵢⴰⵔ ⵙ ⵓⴼⵓⵙ ⵖⴰⵔⵙⴻⵏ, ⵓⵛⴰ ⵓⵎⵉ ⴰⵔⵙⵉⵏ ⵇⴰⵄ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵉⵍⴻⵙ ⵏ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ ... ");
INSERT INTO rift_vpl VALUES ("AC22_1","074_22_1","ACT","22","1","1","... “ⴰ ⵜⴰⵡⵎⴰⵜ ⴷ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵙⵍⴻⵎ ⵉ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵏⵉⵖ ⵅ ⵓⴷⴰⴼⴻⵄ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("AC22_2","074_22_2","ACT","22","2","2","ⵓⵎⵉ ⵙⵍⵉⵏ, ⴰⵇⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵢⵉⵍⴻⵙ ⵏ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ, ⵇⵇⵉⵎⴻⵏ ⵙⵇⴰⵔⴻⵏ ⵄⴰⴷ ⴽⵜⴰⵔ. ⵉⵏⵏⴰ ⴰⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("AC22_3","074_22_3","ACT","22","3","3","“ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⵓⴷⴰⵢ, ⵅⴻⵍⵇⴻⵖ-ⴷⴷ ⴷⵉ ⵜⴰⵔⵙⵓⵙ ⴷⵉ ⴽⵉⵍⵉⴽⵉⵢⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉⵖ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⴳⴰⵎⴰⵍⵉⵢⴰⵍ ⵓ ⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴷⴻⵜⵜ ⵏⵉⵛⴰⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ⵛⴻⵟⵟⴰⵔⴻⵖ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC22_4","074_22_4","ACT","22","4","4","ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴹⴻⴼⴼⴰⵔⴻⵖ ⴰⴱⵔⵉⴷ-ⴰ ⵙ ⵍⵎⴻⵡⵜ ⴰⵎ ⵛⴰⵔⵔⴼⴻⵖ ⵉⵔⵢⴰⵣⴻⵏ ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵜⵜⵙⴻⵍⵍⴰⵎⴻⵖ ⵜⴻⵏ ⵖⴰⵔ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC22_5","074_22_5","ACT","22","5","5","ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵛⴻⵀⴷⴻⵏ ⴱⴻⵍⵍⵉ ⴽⵙⵉⵖ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉ ⵜⴰⵡⵎⴰⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵔⵓⵃⴻⵖ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵖ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⵄⴰⵡⴻⴷ ⵙ ⵜⵛⴰⵔⴼⵉⵏ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵍⵄⵉⵇⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("AC22_6","074_22_6","ACT","22","6","6","ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵓⵛⴰ ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ, ⵜⴰⵍⵖⴰ ⵅⴰⴼⵉ ⵙ ⵍⵖⴻⴼⵍⴻⵜ ⵉⵛⵜ ⵏ ⵜⴼⴰⵡⵜ ⵜⴻⵎⵖⴰⵔ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC22_7","074_22_7","ACT","22","7","7","ⵡⴹⵉⵖ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ, ⵜⴻⵇⵇⴰⵔ ⴰⵢⵉ: ‘ⵛⴰⵡⵓⵍ, ⵛⴰⵡⵓⵍ, ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴷⴰⵔⵔⵛⴻⴷ?’ ");
INSERT INTO rift_vpl VALUES ("AC22_8","074_22_8","ACT","22","8","8","ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅⴰⵙ: ‘ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ?’ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵏⴻⵛⵛ ⴷ ⵢⴰⵙⵓⵄ, ⵏⵏⴰⵚⵉⵔⵉ, ⵡⴻⵏⵏⵉ ⵜᵉⵜⵜⴷⴰⵔⵔⴰⵛⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("AC22_9","074_22_9","ACT","22","9","9","ⵉⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵉ, ⵥⵔⵉⵏ ⵜⴰⴼⴰⵡⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵍⵉⵏ ⵛⴰ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC22_10","074_22_10","ACT","22","10","10","ⵏⵏⵉⵖ: ‘ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ, ⴰ ⵙⵉⴷⵉ?’ ⵉⵏⵏⴰ ⴰⵢⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ: ‘ⴽⴽⴰⵔ, ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ, ⴷⵉⵏ ⴰⴷ ⴰⵛ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵢⵓⵔⴰⵏ ⴰⴷ ⵜⴻⴳⴳⴻⴷ!’ ");
INSERT INTO rift_vpl VALUES ("AC22_11","074_22_11","ACT","22","11","11","ⵓⵎⵉ ⴷⴻⵡⵍⴻⵖ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵖ ⵣⵉ ⵜⵉⵙⵙⵉⵇⵜ ⵏ ⵜⴼⴰⵡⵜ ⵏⵏⵉ, ⴳⴻⵡⵡⴷⴻⵏ ⴰⵢⵉ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵓⴼⵓⵙ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("AC22_12","074_22_12","ACT","22","12","12","ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵡⴻⵔⵢⴰⵣ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴰⵏⴰⵏⵉⵢⴰⵙ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵅⴰⵙ ⵛⴻⵀⵀⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC22_13","074_22_13","ACT","22","13","13","ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵉ, ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴰ ⵓⵎⴰ ⵛⴰⵡⵓⵍ, ⴰⵔⵣⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ!’ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵜⵜⵡⴰⵔⵣⵎⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉⵏⵓ, ⵓⵛⴰ ⵥⵔⵉⵖ ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC22_14","074_22_14","ACT","22","14","14","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵉⵅⴹⴰⵔ ⵉ ⵛⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵥⴰⵔⴻⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⴰⴷ ⵜⴻⵙⵍⴻⴷ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC22_15","074_22_15","ACT","22","15","15","ⵛⴻⴽ ⴰⴷ ⴰⵙ ⵜⵉⵍⵉⴷ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵙ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵥⵔⵉⴷ ⵓ ⵙ ⵎⵉⵏ ⵜⴻⵙⵍⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("AC22_16","074_22_16","ACT","22","16","16","ⵉⵡⴰ ⵍⴻⵅⵅⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⴻⵣⵄⵉⵎⴻⴷ ⵄⴰⴷ? ⴽⴽⴰⵔ, ⴻⵊⵊ ⴰⴷ ⵛⴻⴽ ⵙⵙⵖⴻⴹⵚⴻⵏ, ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵉⵣⴻⴷⴳⴻⴷ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵛ ⴰⵎ ⵜᵉⵜⵜⵍⴰⵖⵉⴷ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ!’ ");
INSERT INTO rift_vpl VALUES ("AC22_17","074_22_17","ACT","22","17","17","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ, ⵉⵡⴹⴻⵖ ⴷⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⵥⴰⴵⵉⵖ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("AC22_18","074_22_18","ACT","22","18","18","ⵥⵔⵉⵖ ⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ, ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴰⵣⵣⴻⵍ, ⵜⴻⴼⴼⵖⴻⴷ ⴷⴻⵖⵢⴰ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵇⴻⴱⴱⵍⴻⵏ ⵛⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵛ ⵅⴰⴼⵉ!’ ");
INSERT INTO rift_vpl VALUES ("AC22_19","074_22_19","ACT","22","19","19","ⵏⵏⵉⵖ ⵏⴻⵛⵛ: ‘ⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵜⵜⵃⴻⴱⴱⵙⴻⵖ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵣⵣⴰⵢⴻⴽ, ⵀⴻⵜⵜⴽⴻⵖ ⵜⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("AC22_20","074_22_20","ACT","22","20","20","ⵓ ⵍⴰⵎⵉ ⵜⵜⵡⴰⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⵛⴻⵀⵀⴰⴷ ⵏⵏⴻⵛ ⵙⵜⵉⴼⴰⵏⵓⵙ, ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ, ⴰⵔⴹⵉⵖ ⵅ ⵢⵉⵏⵏⵉ ⵜ ⵏⵖⵉⵏ ⵓ ⵃⴹⵉⵖ ⴰⵔⵔⵓⴹ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵢⴰⵔⴻⵊⵎⴻⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AC22_21","074_22_21","ACT","22","21","21","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⵔⵓⵃ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴰⵔⵔⵃⴻⴷ ⵍ’ⵉⵏⵊⵉⵍ ⵉ ⵍⴻⴳⵏⵓⵙ!’” ");
INSERT INTO rift_vpl VALUES ("AC22_22","074_22_22","ACT","22","22","22","ⵜⵓⵖⴰ ⵜⵜⴻⵙⵍⴰⵏ ⴰⵙ ⴰⵍ ⴰⵡⴰⵍ-ⴰ, ⵅⴻⵏⵏⵉ ⴽⴽⴰⵔⴻⵏ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵙⴻⵏ, ⵇⵇⴰⵔⴻⵏ: “ⴽⴽⵙⴻⵎ ⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⵙⴷⵉⵀⴻⴵ ⴰⴷ ⵉⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("AC22_23","074_22_23","ACT","22","23","23","ⴰⵎ ⵜⵓⵖⴰ ⵙⵖⵓⵢⵢⵓⵏ, ⵏⴻⵟⵟⴰⵔⴻⵏ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵓⵛⴰ ⵣⵓⵣⵣⴰⵔⴰⵏ ⵓⵛⴰⵍ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC22_24","074_22_24","ACT","22","24","24","ⵢⵓⵎⵓⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵙⵙⵉⴷⴼⴻⵏ ⵖⴰⵔ ⵍⵇⴻⵛⵍⴰ, ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ ⴰⵎ ⵜ ⵜⵜⵀⴻⵜⵜⴰⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴼⵀⴻⵎ ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⵙ ⵙⵖⵓⵢⴻⵏ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("AC22_25","074_22_25","ACT","22","25","25","ⵓⵎⵉ ⵜ ⵊⴻⴱⴷⴻⵏ ⵙ ⵜⵃⴻⵣⵣⴰⵎⵉⵏ ⵉ ⵓⵀⴻⵜⵜⴻⴽ ⵙ ⵓⵔⴻⴽⴽⵓⴹ, ⵉⵏⵏⴰ ⴱⵓⵍⵓⵙ ⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵉ ⴷⵉⵏ ⵉⴱⴻⴷⴷⴻⵏ: “ⵎⴰ ⵉⵃⴻⴵⴻⵍ ⴰⵡⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵡⴻⵎ ⴰⴷ ⵜⵀⴻⵜⵜⴽⴻⵎ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵔⵓⵎⴰⵏⵉ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⴰⵎ ⵡⴰⵔ ⵅⴰⵙ ⵜⴻⵃⴽⵉⵎⴻⵎ ⵄⴰⴷ?” ");
INSERT INTO rift_vpl VALUES ("AC22_26","074_22_26","ACT","22","26","26","ⵓⵎⵉ ⵉⵙⵍⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⴷ? ⴰⵇⴰ ⴰⵔⵢⴰⵣ-ⴰ ⴷ ⴰⵔⵓⵎⴰⵏⵉ!” ");
INSERT INTO rift_vpl VALUES ("AC22_27","074_22_27","ACT","22","27","27","ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵏⵏⴰ ⴰⵙ: “ⵉⵏⵉ ⴰⵢⵉ, ⵎⴰ ⵛⴻⴽ ⴷ ⴰⵔⵓⵎⴰⵏⵉ?” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⴱⵓⵍⵓⵙ: “ⵡⴰⵀ!” ");
INSERT INTO rift_vpl VALUES ("AC22_28","074_22_28","ACT","22","28","28","ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵟⵟⴼⴻⵖ ⵍⵃⴻⵇⵇ-ⴰ ⵏ ⵓⵎⴻⵣⴷⴰⵖ ⴰⵔⵓⵎⴰⵏⵉ ⵙ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵜⵎⴻⵏⵢⴰⵜ!” ⴱⵓⵍⵓⵙ ⵉⵏⵏⴰ: “ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵅⴻⵍⵇⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("AC22_29","074_22_29","ACT","22","29","29","ⵍⴻⵅⴷⴻⵏⵏⵉ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵏⵡⴰⵏ ⴰⴷ ⵜ ⵀⴻⵜⵜⴽⴻⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴷ, ⵊⵊⵉⵏ ⵜ. ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵉⴷⵡⴻⵍ ⵉⴳⴳⵯⴻⴷ, ⵎⵉⵏⵣⵉ ⵉⴼⵀⴻⵎ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⵓⵎⴰⵏⵉ ⵓ ⵎⵉⵏⵣⵉ ⵉⵊⵊⴰ ⵉ-ⵜ ⴰⴷ ⵜ ⵛⴰⵔⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC22_30","074_22_30","ACT","22","30","30","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⴰⵎ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⵏ ⵜⵉⴷⴻⵜⵜ ⵎⵉⵏ ⵅⴻⴼ ⵜ ⴹⴻⵍⵎⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵉⴳⴳⴰ ⴰⴷ ⴼⴻⵙⵢⴻⵏ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴻⵀⵡⴰ-ⴷⴷ ⴱⵓⵍⵓⵙ ⵖⴰⵔ ⴷⵉⵏ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC23_1","074_23_1","ACT","23","1","1","ⴱⵓⵍⵓⵙ ⵉⵇⵛⴻⵄ ⴷⴻⴳ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵉⵏⵏⴰ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ! ⴰⵇⴰ ⵏⴻⵛⵛ ⵓⵢⵓⵔⴻⵖ ⵙ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵜⴻⵚⴼⴰ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵍ ⴰⵙⵙ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC23_2","074_23_2","ACT","23","2","2","ⴰⵏⴰⵏⵉⵢⴰⵙ, ⴰⴽⴻⵀⵀⴰⵏ, ⵢⵓⵎⵓⵔ ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⴽⵉⴷⴻⵙ ⵉⴱⴻⴷⴷⴻⵏ, ⴰⴷ ⵜ ⵡⵜⴻⵏ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("AC23_3","074_23_3","ACT","23","3","3","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙ ⴱⵓⵍⵓⵙ: “ⴰⴷ ⵛⴻⴽ ⵉⵡⵡⴻⵜ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⴽ ⴷ ⵍⵃⵉⴹ ⵉⵊⵉⵢⵢⴰⵔⴻⵏ! ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴷⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵜⵃⴻⴽⵎⴻⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵜⵅⴰⵍⴰⴼⴻⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⵎ ⵜⵓⵎⵓⵔⴻⴷ ⴰⴷ ⴰⵢⵉ ⵡⵜⴻⵏ!” ");
INSERT INTO rift_vpl VALUES ("AC23_4","074_23_4","ACT","23","4","4","ⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴽⵉⵙ ⵉⴱⴻⴷⴷⴻⵏ, ⵏⵏⴰⵏ: “ⵎⴰ ⵜⴷⴻⴵⵎⴻⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ?” ");
INSERT INTO rift_vpl VALUES ("AC23_5","074_23_5","ACT","23","5","5","ⵉⵏⵏⴰ ⴱⵓⵍⵓⵙ: “ⴰ ⵜⴰⵡⵎⴰⵜ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴰⵇⴰ-ⵜ ⴷ ⴰⴽⴻⵀⵀⴰⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: ‘ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵛ ⵡⴰⵔ ⵜ ⵏⴻⵄⵄⴻⵍ!’” ");
INSERT INTO rift_vpl VALUES ("AC23_6","074_23_6","ACT","23","6","6","ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⴱⵓⵍⵓⵙ, ⴰⵇⴰ ⴰⵣⵢⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⵓ ⴰⵣⵢⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵣⴻⴳ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵉⵍⴰⵖⴰ ⴷⵉ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⵏⴻⵛⵛ ⴷ ⴰⴼⴰⵔⵉⵙⵉ, ⵎⵎⵉⵙ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ, ⵏⴻⵛⵛ ⵜⵜᵉⵜⵜⵡⴰⵃⴰⴽⴰⵎⴻⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⵉⵜⴻⵎ ⴷ ⵜⵏⵓⴽⵔⴰ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC23_7","074_23_7","ACT","23","7","7","ⴰⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⵊⴰⵔ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴷ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴱⴹⴰ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("AC23_8","074_23_8","ACT","23","8","8","ⵎⵉⵏⵣⵉ ⵉⵚⴰⴷⵓⵇⵉⵢⵢⴻⵏ ⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⴷ ⵜⴰⵏⵓⴽⵔⴰ ⵏⵉⵖ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵓⵍⴰ ⴷ ⴱⵓⵃⴱⴻⵍ, ⵎⴰⵛⴰ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⵛⴻⵀⵀⴷⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC23_9","074_23_9","ACT","23","9","9","ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵛⴰ ⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵣⵢⴻⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ ⴽⴽⴰⵔⴻⵏ, ⵜⵜⴻⵎⵏⴰⵇⴰⵛⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵊⵊⴻⵀⴷ, ⵏⵏⴰⵏ: “ⵡⴰⵔ ⵏⵓⴼⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⴷⵉ ⴱⵏⴰⴷⴻⵎ-ⴰ. ⵎⴰⵍⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵉⵊⵊ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ, ⵎⴰⵏ ⵍⵄⵉⴱ ⵉ ⵢⴻⴵⴰ ⵅⴻⵏⵏⵉ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ?” ");
INSERT INTO rift_vpl VALUES ("AC23_10","074_23_10","ACT","23","10","10","ⵓⵎⵉ ⵉⴽⴽⴰⵔ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵡⴻⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⴳⴳⵯⴻⴷ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⴰⴷ ⵎⴻⵣⵣⵇⴻⵏ ⴱⵓⵍⵓⵙ. ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⴷ ⵜ ⵅⴻⴹⴼⴻⵏ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜ ⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⵇⴻⵛⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("AC23_11","074_23_11","ACT","23","11","11","ⴷⵉ ⴵⵉⵍⴻⵜ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉ ⴱⵓⵍⵓⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⴻⴳⴳ ⵓⵍ, ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⴼⵉ ⵜⵛⴻⵀⴷⴻⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵛⴻⵀⴷⴻⴷ ⵓⵍⴰ ⴷⵉ ⵔⵓⵎⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC23_12","074_23_12","ACT","23","12","12","ⴰⵍⴰⵎⵉ ⴷ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ, ⵎⵓⵏⴻⵏ ⵛⴰ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ, ⵇⵇⵏⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵡⴰⵔ ⵙⴻⵙⵙⴻⵏ ⴰⵍ ⴷ ⵏⵖⴻⵏ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC23_13","074_23_13","ACT","23","13","13","ⴽⵜⴰⵔ ⵣⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⴽⴽⵙⴻⵏ ⵡⴰⵡⴰⵍ-ⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("AC23_14","074_23_14","ACT","23","14","14","ⵉⵏⴰ ⵔⵓⵃⴻⵏ ⵖⴰⵔ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ, ⵏⵏⴰⵏ: “ⴰⵇⴰ ⵏⴻⵇⵇⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵙ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏᵉⵜⵜⴻⵜⵜ ⵡⴰⵍⵓ ⴰⵍ ⵖⴰ ⵏⴻⵏⵏⴻⵖ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC23_15","074_23_15","ACT","23","15","15","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵊⵎⴰⵄⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⴷ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵣⴻⴳ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵏⴷⴻⵀ ⵖⴰⵔⵡⴻⵎ ⴰⵅⵎⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵅⴻⴱⴱⵛⴻⵎ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ ⵎⵍⵉⵃ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵡⵊⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵏⴻⵏⵏⴻⵖ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵢⴰⵡⴻⴹ.” ");
INSERT INTO rift_vpl VALUES ("AC23_16","074_23_16","ACT","23","16","16","ⵉⵙⵍⴰ ⵎⵎⵉⵙ ⵏ ⵓⵍⵜⵎⴰⵙ ⵏ ⴱⵓⵍⵓⵙ ⵅ ⵜⵃⵉⵍⴻⵜ-ⴰ. ⵅⴻⵏⵏⵉ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵍⵇⴻⵛⵍⴰ ⵓⵛⴰ ⵉⵅⴻⴱⴱⴰⵔ ⴱⵓⵍⵓⵙ ⵅ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC23_17","074_23_17","ACT","23","17","17","ⵉⵍⴰⵖⴰ ⴱⵓⵍⵓⵙ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵍⵇⴻⴱⵟⴰⵏⴰⵜ ⵅ ⵎⵢⴰ, ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ ⵙ ⵓⴱⵍⵉⵖ-ⴰ ⵖⴰⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⵙ ⵛⴰ ⴰⴷ ⴰⵙ ⵜ ⵢⵉⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC23_18","074_23_18","ACT","23","18","18","ⵉⴽⵙⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⴰⴱⵍⵉⵖ, ⵓⵛⴰ ⵉⵡⵢⵉ ⵜ ⵖⴰⵔ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⵉⵏⵏⴰ: “ⴱⵓⵍⵓⵙ, ⴰⵎⴻⵃⴱⵓⵙ, ⵉⵍⴰⵖⴰ ⴰⵢⵉ-ⴷⴷ, ⵉⵜⵜⴰⵔ ⴰⵢⵉ ⴰⴷ ⴰⵛ ⴰⵡⵢⴻⵖ ⴰⴱⵍⵉⵖ-ⴰ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵛⴰ ⴰⴷ ⴰⵛ ⵜ ⵉⵏⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC23_19","074_23_19","ACT","23","19","19","ⵉⵟⵟⴻⴼ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ ⴰⴱⵍⵉⵖ ⵙ ⵓⴼⵓⵙ, ⵉⴷⴷⵓⵔ ⵣⵣⴰⵢⴻⵙ ⵡⴻⵃⵃⴷⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴻⵇⵙⴰ ⵜ: “ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜ ⵜⵉⵏⵉⴷ?” ");
INSERT INTO rift_vpl VALUES ("AC23_20","074_23_20","ACT","23","20","20","ⵉⵏⵏⴰ ⴰⵙ ⵓⴱⵍⵉⵖ: “ⴰⵇⴰ ⵓⴷⴰⵢⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵜⵜⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴷ-ⵜⴻⵙⵙⴻⵀⵡⵉⴷ ⴱⵓⵍⵓⵙ ⵜⵉⵡⴻⵛⵛⴰ ⵖⴰⵔ ⵊⵎⴰⵄⴻⵜ ⵏⵙⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴰⵅⵎⵉ ⵅⵙⴻⵏ ⴰⴷ ⵜ ⵙⵙⴻⵇⵙⴰⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("AC23_21","074_23_21","ACT","23","21","21","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵛⴻⴽ ⵙⵙⵇⴻⵏⵄⴻⵏ, ⵎⵉⵏⵣⵉ ⴽⵜⴰⵔ ⵣⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴳⴳⵉⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵇⵇⵏⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵉⵛⵜ ⵏ ⵏⵏⴻⵄⵍⴻⵜ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵏ ⵡⴰⵔ ⵙⴻⵙⵙⴻⵏ ⴰⵍ ⵜ ⵏⵖⴻⵏ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴻⵊⴷⴻⵏ ⵍⴻⵅⵅⵓ, ⵜⵜⵔⴰⵊⴰⵏ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵜⵜⴻⵙⵔⵉⵃ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("AC23_22","074_23_22","ACT","23","22","22","ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵉⵊⵊⴰ ⴰⴱⵍⵉⵖ ⴰⴷ ⵉⵔⴰⵃ, ⵉⵏⵏⴰ ⴰⵙ: “ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵜⴻⵙⵙⴰⵔⴻⴳⴱⴻⴷ ⴰⵢⵉ ⵅ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC23_23","074_23_23","ACT","23","23","23","ⵅⴻⵏⵏⵉ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵇⴻⴱⵟⴰⵏⴻⵏ ⵅ ⵎⵢⴰ, ⵉⵏⵏⴰ: “ⵙⵡⴻⵊⴷⴻⵎ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵔⴰⵃⴻⵏ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ ⵖⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⴵⵉⵍⴻⵜ, ⴰⴽⵉⴷⵙⴻⵏ ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⵉⵢⵙⴰⵏ ⵓ ⵎⵉⵜⴰⵢⴻⵏ ⵏ ⵉⵎⵊⴻⴱⴱⴰⴷⴻⵏ ⵏ ⵍⵇⴻⵡⵙ ⵙ ⵓⴼⵓⵙ ⵓⴼⵓⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("AC23_24","074_23_24","ACT","23","24","24","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵛⵜ ⵏ ⵣⵣⴰⵢⵍⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙ ⵙⵙⵖⵉⵎⴻⵏ ⴱⵓⵍⵓⵙ, ⴰⴷ ⵜ ⵏⴻⴷⵀⴻⵏ ⵖⴰⵔ ⵍⵄⴰⵎⵉⵍ ⴼⵉⵍⵉⴽⵙ ⴷⵉ ⵍⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC23_25","074_23_25","ACT","23","25","25","ⵅⴻⵏⵏⵉ ⵢⵓⵔⴰ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵜⵜ. ⴰⵎⵎⵓ ⵉ ⴷⴰⵢⴻⵙ ⵢⵓⵔⴰ: ");
INSERT INTO rift_vpl VALUES ("AC23_26","074_23_26","ACT","23","26","26","“ⴽⵍⵓⴷⵉⵢⵓⵙ ⵍⵉⵙⵉⵢⴰⵙ, ⵉ ⵍⵄⴰⵎⵉⵍ ⵢⵓⵄⵍⴰⵏ ⴼⵉⵍⵉⴽⵙ: ⵙⵍⴰⵎ ⵅⴰⴽ! ");
INSERT INTO rift_vpl VALUES ("AC23_27","074_23_27","ACT","23","27","27","ⵓⴷⴰⵢⴻⵏ ⴰⵇⴰ ⵟⵟⴼⴻⵏ ⴰⵔⵢⴰⵣ-ⴰ ⵓ ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ⵡⵛⵉⵖ ⴰⵙ ⴰⴼⵓⵙ ⴰⴽ-ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴼⴻⴽⴽⴻⵖ ⵜ ⵓⵎⵉ ⵙⵍⵉⵖ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⵓⵎⴰⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC23_28","074_23_28","ACT","23","28","28","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⵉⵏ ⵅⴻⴼ ⵜ ⴹⴻⵍⵎⴻⵏ, ⵉⵡⵢⴻⵖ ⵜ ⵖⴰⵔ ⵊⵎⴰⵄⴻⵜ ⵏⵙⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC23_29","074_23_29","ACT","23","29","29","ⵓⴼⵉⵖ ⴰⵇⴰ ⴹⴻⵍⵎⴻⵏ ⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵛⴰ ⵏ ⵉⵅⴰⵔⵡⵉⴹⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⴼⵉⵖ ⴰⴹⵍⴰⵎ ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("AC23_30","074_23_30","ACT","23","30","30","ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ, ⴱⴻⵍⵍⵉ ⵓⴷⴰⵢⴻⵏ ⴳⴳⵉⵏ ⴰⵙ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵙ ⵜⵏⵓⴼⴼⵔⴰ, ⵙⵙⴻⴽⴽⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵖⴰⵔⴻⴽ, ⵓⵎⵓⵔⴻⵖ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⴹⴻⵍⵎⴻⵏ ⴰⴷ ⵖⴰⵔⴻⴽ ⵔⵓⵃⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⵉⴷⴻⵙ ⵙⵙⵉⵡⵍⴻⵏ ⵣⵣⴰⵜⴻⴽ ⵎⵉ ⵅⴻⴼ ⵜ ⴹⴻⵍⵎⴻⵏ. ⵙ ⵜⵜⵉⵙⵉⵔ!” ");
INSERT INTO rift_vpl VALUES ("AC23_31","074_23_31","ACT","23","31","31","ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ ⴽⵙⵉⵏ ⴱⵓⵍⵓⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵢⵓⵎⵓⵔ, ⵓⵛⴰ ⵉⵡⵢⴻⵏ ⵜ ⵙ ⴵⵉⵍⴻⵜ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵏⵜⵉⴱⴰⵜⵔⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("AC23_32","074_23_32","ACT","23","32","32","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵊⵊⵉⵏ ⵉⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵢⴻⵢⵙⴰⵏ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵙⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵖⴰⵔ ⵍⵇⴻⵛⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("AC23_33","074_23_33","ACT","23","33","33","ⵅⴻⵏⵏⵉ ⵉⵡⵢⴻⵏ ⵜ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ, ⵡⵛⵉⵏ ⵜⴰⴱⵔⴰⵜ ⵉ ⵍⵄⴰⵎⵉⵍ ⵓⵛⴰ ⵙⵙⴱⴻⴷⴷⴻⵏ ⴱⵓⵍⵓⵙ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC23_34","074_23_34","ACT","23","34","34","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵖⵔⴰ ⵜⴰⴱⵔⴰⵜ ⵏⵏⵉ, ⵉⵙⵙⴻⵇⵙⴰ ⵅ ⵎⴰⵏ ⵊⵊⵉⵀⴻⵜ ⵉ ⵣⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵏⴻⵜⵜⴰ, ⵓⵛⴰ ⵍⴰⵎⵉ ⵢⵓⴼⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⴽⵉⵍⵉⴽⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("AC23_35","074_23_35","ACT","23","35","35","ⵉⵏⵏⴰ ⴰⵙ: “ⴰⴷ ⴰⵛ ⵙⵍⴻⵖ ⵎⴰⵍⴰ ⵓⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉⴹⴻⵍⵎⴻⵏ ⵉⵡⴹⴻⵏ-ⴷⴷ ⴷⴰ!” ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴰⴷ ⵜ ⵃⴹⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⵏ ⵀⵉⵔⵓⴷⵓⵙ, ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴱⵔⵉⵜⵓⵔⵉⵢⵓⵎ’. ");
INSERT INTO rift_vpl VALUES ("AC24_1","074_24_1","ACT","24","1","1","ⴰⵡⴰⵔⵏⵉ ⵅⴻⵎⵙⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵀⵡⴰ ⴰⵏⴰⵏⵉⵢⴰⵙ, ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵍⴳⴻⵏⵙ ⵓ ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵍⵀⴰⵔⴷ ⵉⵚⴻⴱⵃⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⴰⵔⵜⵓⵍⵓⵙ, ⵓⵛⴰ ⵅⴻⴱⴱⴰⵔⴻⵏ ⵍⵄⴰⵎⵉⵍ ⵅ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC24_2","074_24_2","ACT","24","2","2","ⵓⵎⵉ ⵅⴰⵙ ⴷⴷ-ⵍⴰⵖⴰⵏ, ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵜⴰⵔⵜⵓⵍⵓⵙ ⵖⴰⵔ ⵣⵣⴰⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴹⵍⴻⵎ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵣⵣⴰⵢⴻⴽ ⵖⴰⵔⵏⴻⵖ ⵍⴻⵀⵏⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓ ⵙⵙⵉⵢⴰⵙⴰ ⵏⵏⴻⵛ ⴰⵇⴰ ⵜⵉⵡⵉ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵡⴻⵄⴷⴻⵍ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⵉ ⴷⴷ-ⵢⵉⵡⵢⴻⵏ ⵙⵙⴰⵀⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("AC24_3","074_24_3","ACT","24","3","3","ⵓ ⴷⵉ ⴽⵓⵍ ⴰⵎⵛⴰⵏ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵇⴱⴻⵍ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵛ, ⴰ ⵙⵉⴷⵉ ⴼⵉⵍⵉⴽⵙ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC24_4","074_24_4","ACT","24","4","4","ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⵡⴰⵔ ⵛⴻⴽ ⵀⴻⴽⴽⵡⴻⵍⴻⵖ ⴰⵟⵟⴰⵙ, ⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵢⴻⴽ ⴰⴷ ⵜⴻⵙⵍⵉⴷ ⵎⵖⵉⵔ ⵛⵡⴰⵢⵜ ⵖⴰⵔ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵖ ⵉ ⵣⵣⴰⵢⴻⴽ ⵏⴻⵜⵜⴰⵔ ⵙ ⵓⵡⴰⴹⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("AC24_5","074_24_5","ACT","24","5","5","ⵎⵉⵏⵣⵉ ⵏⵓⴼⴰ ⴱⴻⵍⵍⵉ ⴱⵏⴰⴷⴻⵎ-ⴰ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⴰⵛ, ⵉⵜⵜⵙⴻⴱⴱⴻⴱ ⴰⵖⵓⵡⵡⴻⵖ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵎⴽⵓⵍ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵉⵏⴰⵚⵉⵔⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC24_6","074_24_6","ACT","24","6","6","ⵍⴰⵎⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵅⵎⴻⵊ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⵏⴻⵟⵟⴻⴼ ⵉ-ⵜ ⵓⵛⴰ ⵜⵓⵖⴰ ⵏⴻⵅⵙ ⴰⴷ ⵅⴰⵙ ⵏⴻⵃⴽⴻⵎ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC24_7","074_24_7","ACT","24","7","7","ⵎⴰⵛⴰ ⴰⴽⵓⵎⴰⵏⴷⴰⵔ ⵍⵉⵙⵉⵢⴰⵙ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵙ ⵓⵀⴻⵜⵜⴻⴽ ⴰⵟⵟⴰⵙ, ⵉⴽⵙⵉ ⵜ ⵊⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ, ⵉⵙⵙⴻⴽⴽ ⵉ-ⵜ ⵖⴰⵔⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("AC24_8","074_24_8","ACT","24","8","8","ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵎⴰⵃⴻⵏⴷ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵜ ⴹⴻⵍⵎⴻⵏ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵏ. ⵎⴰⵍⴰ ⵜ ⵜⴻⵙⵙⴻⵇⵙⵉⴷ, ⴰⴷ ⵜⴼⴻⵀⵎⴻⴷ ⵣⵣⴰⵢⴻⵙ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜ ⵏⴻⴹⵍⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC24_9","074_24_9","ACT","24","9","9","ⵛⵛⴻⵜⵛⴰⵏ ⵅⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⵄⴰⵡⴻⴷ, ⵏⵏⴰⵏ: “ⵎⴰⵏ ⴰⵢⴰ ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ!” ");
INSERT INTO rift_vpl VALUES ("AC24_10","074_24_10","ACT","24","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵉⵛⴻⵢⵢⴰⵔ ⵍⵄⴰⵎⵉⵍ ⵉ ⴱⵓⵍⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ. ⴱⵓⵍⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵛⴻⴽ ⴷ ⵍⵇⴰⴹⵉ ⵅ ⵍⴳⴻⵏⵙ-ⴰ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵡⵜⴻⵖ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC24_11","074_24_11","ACT","24","11","11","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ, ⴰⵇⴰ ⵄⴷⵓⵏ ⵎⵖⵉⵔ ⵜⴻⵏⵄⴰⵛ ⵏ ⵡⵓⵙⵙⴰⵏ ⵡⴰⵀⴰ ⵣⴻⴳ ⵡⴰⵎⵉ ⴳⴻⵄⵄⴷⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⴱⴷⴻⵖ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC24_12","074_24_12","ACT","24","12","12","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵓⴼⵉⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵏⵉⵖ ⵙⵙⵎⵓⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⴳⴻⵏⵙ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⴻⵎⵣⵉⴷⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("AC24_13","074_24_13","ACT","24","13","13","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴱⴻⵢⵢⵏⴻⵏ ⵎⵉⵏ ⵣⵉ ⴷ ⴰⵢⵉ ⴹⴻⵍⵎⴻⵏ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("AC24_14","074_24_14","ACT","24","14","14","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴰⵛ ⵏⴻⵄⵎⴻⵖ, ⴱⴻⵍⵍⵉ ⵄⴻⴱⴱⴷⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ ⵅ ⵍⴻⵃⵙⴰⴱ ⵜⵖⵓⵔⵉ ⵏⵏⵉ ⵅ ⵙⵙⴰⵡⴰⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵎⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵢⵓⵔⵉⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⴷⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC24_15","074_24_15","ACT","24","15","15","ⴰⵎ ⵖⴰⵔⵉ ⵙⵉⵎⴰⵏⵜ ⵏ ⵓⵙⵉⵜⴻⵎ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ, ⴰⵇⴰ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵜⴰⵏⵓⴽⵔⴰ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵓⵍⴰ ⴷ ⵜⴰⵏⵓⴽⵔⴰ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC24_16","074_24_16","ACT","24","16","16","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵜⵜⴻⴳⴳⴻⵖ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵍⴻⴱⴷⴰ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵜⴻⵚⴼⴰ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵣⵣⴰⵜ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC24_17","074_24_17","ACT","24","17","17","ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⵢⴻⵖ ⵚⵚⴷⴰⵇⵉ ⴷ ⵜⵖⴰⵔⵚⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC24_18","074_24_18","ACT","24","18","18","ⴰⵇⴰ ⵉⵡⴷⴰⵏ-ⴰ ⵓⴼⵉⵏ ⴰⵢⵉ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳⴻⵖ, ⴰⵎ ⵡⴰⵔ ⴷⵉⵏ ⵖⴰⵔⵉ ⵍⵖⴰⵛⵉ ⵏⵉⵖ ⴷ ⴰⵅⴰⵔⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("AC24_19","074_24_19","ACT","24","19","19","ⵎⴰⵛⴰ ⵓⴷⴰⵢⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⴰⵙⵉⵢⴰ, ⵉⵏⵏⵉ ⵉⵙⵙⴻⴽⴽⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵃⴹⴰⵔⴻⵏ ⴷⴰ ⴰⴽⵉⴷⵉ ⵣⵣⴰⵜⴻⴽ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⴹⴻⵍⵎⴻⵏ ⵣⵉ ⵎⵉⵏ ⵎⴰ ⵖⴰⵔⵙⴻⵏ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("AC24_20","074_24_20","ACT","24","20","20","ⵏⵉⵖ ⴰⴷ ⵉⵏⵉⵏ ⵉⵏⴰ ⵉ ⴷⴰ ⵉⴱⴻⴷⴷⴻⵏ ⵎⴰⵏ ⵍⵄⵉⴱ ⵉ ⴷⴰⵢⵉ ⵓⴼⵉⵏ ⵓⵎⵉ ⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵊⵎⴰⵄⴻⵜ ⵏⵙⴻⵏ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("AC24_21","074_24_21","ACT","24","21","21","ⵎⵖⵉⵔ ⴰⵡⴰⵍ-ⴰ ⵉ ⵜⵓⵖⴰ ⵍⴰⵖⵉⵖ ⵓⵎⵉ ⴱⴻⴷⴷⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ: ‘ⴰⵙⵙ-ⴰ ⵜⵜⵡⴰⵃⴻⴽⵎⴻⵖ ⵣⵣⴰⵜⵡⴻⵎ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵏⵓⴽⵔⴰ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ!’” ");
INSERT INTO rift_vpl VALUES ("AC24_22","074_24_22","ACT","24","22","22","ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵙⵙⴻⵏ ⴼⵉⵍⵉⴽⵙ ⴰⴱⵔⵉⴷ-ⴰ ⵎⵍⵉⵃ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ, ⵉⵏⵏⴰ: “ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⴽⵓⵎⴰⵏⴷⴰⵔ, ⴰⴷ ⴽⴻⵎⵎⵍⴻⵖ ⴰⵙⴻⴵⵉ ⵖⴰⵔ ⵎⵉⵏ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC24_23","074_24_23","ACT","24","23","23","ⵅⴰⵙ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵃⴹⴰ ⴱⵓⵍⵓⵙ ⵙ ⵛⵡⴰⵢⵜ ⵏ ⵍⵃⵓⵔⵔⵉⵢⴰ ⴽⵜⴰⵔ ⵓ ⵡⴰⵔ ⵉⵎⴻⵏⵏⴻⵄ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜ ⵉⵙⵙⵏⴻⵏ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC24_24","074_24_24","ACT","24","24","24","ⴰⵡⴰⵔⵏⵉ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵊⵊⴰ ⴼⵉⵍⵉⴽⵙ ⴷ ⴷⵔⵓⵙⵉⵍⵍⴰ, ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵓⴷⴰⵛⵜ, ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴱⵓⵍⵓⵙ ⵓⵛⴰ ⵙⵍⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵅ ⵍ’ⵉⵎⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC24_25","074_24_25","ACT","24","25","25","ⴰⵍⴰⵎⵉ ⵢⵉⵡⴻⴹ ⵍⵀⴰⵔⴷ ⵅ ⵜⵙⴻⴳⴷⴰ ⴷ ⴹⴹⴻⴱⵟ ⵏ ⵏⵏⴻⴼⵙ ⵓ ⵅ ⵍⵃⵉⵙⴰⴱ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵉⴳⴳⵯⴻⴷ ⴼⵉⵍⵉⴽⵙ, ⵉⵏⵏⴰ ⴰⵙ: “ⵔⵓⵃ ⵍⴻⵅⵅⵓ! ⵅⵎⵉ ⵖⴰⵔⵉ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵍⵡⴻⵇⵜ, ⴰⴷ ⴰⵛ ⴷⴷ-ⵍⴰⵖⵉⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC24_26","074_24_26","ACT","24","26","26","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵜⵉⵎ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴱⵓⵍⵓⵙ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵜⵎⴻⵏⵢⴰⵜ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⴹⵍⴻⵇ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙ ⴷⴷ-ⵉⵍⴰⵖⴰ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵙ ⵉⵙⵙⵉⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("AC24_27","074_24_27","ACT","24","27","27","ⵎⴰⵛⴰ ⵓⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵢⵓⵙⴰ-ⴷⴷ ⵍⵄⴰⵎⵉⵍ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵅⴻⵍⴼⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴱⵓⵔⴽⵉⵢⵓⵙ ⴼⴰⵙⵜⵓⵙ. ⵓⵎⵉ ⵜⵓⵖⴰ ⴼⵉⵍⵉⴽⵙ ⵉⵅⵙ ⴰⴷ ⵢⴰⵔⴹⴰ ⵓⴷⴰⵢⴻⵏ, ⵉⵊⵊⴰ ⴱⵓⵍⵓⵙ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC25_1","074_25_1","ACT","25","1","1","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⴼⴰⵙⵜⵓⵙ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ, ⵉⵔⵓⵃ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC25_2","074_25_2","ACT","25","2","2","ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵙⵙⴰⵔⴻⴳⴱⴻⵏ ⵜ ⴷⵉⵏⵏⵉ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⴹⴻⵍⵎⴻⵏ ⴱⵓⵍⵓⵙ ⵓⵛⴰ ⵇⴻⴷⴷⵎⴻⵏ ⴰⵙ ⵉⵛⵜ ⵏ ⵜⵓⵜⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC25_3","074_25_3","ACT","25","3","3","ⵜⵜⴰⵔⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵉⴳⴳ ⵙ ⵍⵅⴰⴹⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵉⵏⴷⴻⵀ ⴱⵓⵍⵓⵙ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵍⴰⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⵡⴻⵊⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⴼⴻⵅ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC25_4","074_25_4","ACT","25","4","4","ⵎⴰⵛⴰ ⴼⴰⵙⵜⵓⵙ ⵢⴰⵔⵔⴰ-ⴷⴷ: “ⴱⵓⵍⵓⵙ ⵉⵜⵜⵡⴰⵃⴹⴰ ⴷⵉ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ ⵓ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⴰⴷ ⴷⵉⵏ ⵔⴰⵃⴻⵖ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC25_5","074_25_5","ACT","25","5","5","ⴻⵊⵊ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴼⴻⵏ ⵜⴰⵡⵡⴰⵔⵜ ⴰⴷ ⵔⴰⵃⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ, ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜ ⴹⴻⵍⵎⴻⵏ ⵎⴰⵍⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵍⵄⵉⴱ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC25_6","074_25_6","ACT","25","6","6","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵇⵇⵉⵎ ⴷⵉⵏ ⵜⵎⴻⵏⵢⴰ ⵏⵉⵖ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵀⵡⴰ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ ⵓ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵉⵇⵇⵉⵎ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ ⵓⵛⴰ ⵢⵓⵎⵓⵔ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC25_7","074_25_7","ACT","25","7","7","ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ, ⵏⵏⴹⴻⵏ ⵅⴰⵙ ⵡⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵓⵛⴰ ⴳⴳⵉⵏ ⵅⴰⵙ ⴰⵟⵟⴰⵙ ⵏ ⵉⵛⴻⵜⵛⵉⵜⴻⵏ ⵉⴹⴻⵇⵍⴻⵏ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⵙⵙⴱⴻⵢⵢⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC25_8","074_25_8","ACT","25","8","8","ⵓⵎⵉ ⵉⵡⵜⴰ ⴱⵓⵍⵓⵙ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵡⴰⵔ ⵉⵅⴹⵉ ⵏⴻⵜⵜⴰ ⴷⵉ ⵡⴰⵍⵓ, ⵡⴰⵔ ⵜⴻⴵⵉ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵉⵖ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵍⴰ ⴷⵉ ⵇⴰⵢⵚⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("AC25_9","074_25_9","ACT","25","9","9","ⵉⵏⵏⴰ ⴼⴰⵙⵜⵓⵙ ⵉ ⴱⵓⵍⵓⵙ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⴳⴳ ⵍⵅⴰⴹⴰⵔ ⵉ ⵡⵓⴷⴰⵢⴻⵏ: “ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴳⴻⵄⵄⴷⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⵎⴻⴷ ⵣⵣⴰⵜⵉ?” ");
INSERT INTO rift_vpl VALUES ("AC25_10","074_25_10","ACT","25","10","10","ⵢⴰⵔⵔⴰ-ⴷⴷ ⴱⵓⵍⵓⵙ, ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴱⴻⴷⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ ⵏ ⵇⴰⵢⵚⴰⵔ ⵎⴰⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⴰⴼⵉ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ. ⵡⴰⵔ ⵅⴹⵉⵖ ⴷⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵙ ⵡⴰⵍⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("AC25_11","074_25_11","ACT","25","11","11","ⵎⴰⵍⴰ ⵅⴹⵉⵖ ⵏⵉⵖ ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵎⵉⵏ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵍⵎⴻⵡⵜ, ⵡⴰⵔ ⵜⵜⵔⵉⴽⴽⵯⵉⵍⴻⵖ ⵣⵉ ⵍⵎⴻⵡⵜ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵉⴷⴻⵜⵜ ⵏⵉⵛⴰⵏ ⵉ ⵣⵉ ⴷ ⴰⵢⵉ ⴹⴻⵍⵎⴻⵏ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⴰⵢⵉ ⵉⵙⴻⵍⵍⴻⵎ ⵖⴰⵔⵙⴻⵏ ⵉ ⴰⵔⴹⴰ ⵏⵙⴻⵏ. ⵏⴻⵛⵛ ⵓⵔⵉⵖ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("AC25_12","074_25_12","ACT","25","12","12","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵎⵛⴰⵡⴰⵔ ⴰⴽ-ⴷ ⵡⴻⴳⵔⴰⵡ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⴼⴰⵙⵜⵓⵙ: “ⴰⵇⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵛ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ, ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ ⵉ ⵖⴰ ⵜⵔⴰⵃⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC25_13","074_25_13","ACT","25","13","13","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ ⴷ ⴱⴰⵔⵏⵉⴽⵉ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔⵉⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⴵⵎⴻⵏ ⵅ ⴼⴰⵙⵜⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC25_14","074_25_14","ACT","25","14","14","ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⵙⵙⴻⵄⴷⵓⵏ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵄⴰⵡⴻⴷ ⴼⴰⵙⵜⵓⵙ ⵉ ⵓⵊⴻⴵⵉⴷ ⴷⴷⴻⵄⵡⴻⵜ ⵏ ⴱⵓⵍⵓⵙ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⴷⴰ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⴷⴰ ⵉⵊⵊⴰ ⴼⵉⵍⵉⴽⵙ ⴷ ⴰⵎⴻⵃⴱⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC25_15","074_25_15","ACT","25","15","15","ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ, ⵙⵙⴰⵔⴻⴳⴱⴻⵏ ⴰⵢⵉ ⵅⴰⵙ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⴰⵔⴻⵣⵣⵓⵏ ⵣⵣⴰⵢⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴰⴽⴻⵎ ⵣⵣⴰⵜⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC25_16","074_25_16","ACT","25","16","16","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅⴰⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵏⵏⵓⵎⵉⵏ ⴰⴷ ⵙⴻⵍⵍⵎⴻⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⵅⴰⴹⴰⵔ ⵉ ⵉⵡⴷⴰⵏ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵃⴹⴰⵔⴻⵏ ⵣⵣⴰⵜⴻⵙ ⵉⵏⵏⵉ ⵜ ⵉⴹⴻⵍⵎⴻⵏ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵜⵜⴰⵙⵉⵄ ⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴷⴰⴼⴻⵄ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵜⵓⵀⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC25_17","074_25_17","ACT","25","17","17","ⵓⵎⵉ ⴷⴰ ⴷⴷ-ⵉⵡⴹⴻⵖ, ⵡⴰⵔ ⵄⴳⵉⵣⴻⵖ, ⵓⵛⴰ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵇⵇⵉⵎⴻⵖ ⵅ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ, ⵓⵎⵓⵔⴻⵖ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵖⴰⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("AC25_18","074_25_18","ACT","25","18","18","ⵉⵏⵏⵉ ⵜ ⵉⴹⴻⵍⵎⴻⵏ ⵏⵏⴹⴻⵏ ⴰⵙ-ⴷⴷ, ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵜⵔⴰⵊⵉⵖ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⴰⵡⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵀⵎⴻⵜ ⵉ ⵜⵓⵖⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴱⴻⵢⵢⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC25_19","074_25_19","ACT","25","19","19","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵅⴰⵙ ⵛⴰ ⵏ ⵉⵅⴰⵔⵡⵉⴹⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵉⵏ ⵏⵙⴻⵏ ⵓ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵎⵎⵓⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⴱⵓⵍⵓⵙ ⵉⵇⵇⴰⵔ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC25_20","074_25_20","ACT","25","20","20","ⴰⵎ ⵜⵓⵖⴰ ⵛⴻⴽⴽⴻⵖ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⴰⵔⵣⵓⵖ, ⵏⵏⵉⵖ ⵉ ⴱⵓⵍⵓⵙ: ‘ⵎⴰ ⵣⴻⵄⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵔⴰⵃⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⵎⴻⴷ ⴷⵉⵏ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ?’ ");
INSERT INTO rift_vpl VALUES ("AC25_21","074_25_21","ACT","25","21","21","ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵃⴹⴰ ⴰⵍ ⵅⴰⵙ ⵖⴰ ⵉⵃⴽⴻⵎ ⵇⴰⵢⵚⴰⵔ, ⵓⵎⵓⵔⴻⵖ ⴰⴷ ⵜ ⵃⴹⴰⵏ ⴰⵍ ⵜ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("AC25_22","074_25_22","ACT","25","22","22","ⵉⵏⵏⴰ ⴰⵖⵔⵉⴱⴰⵙ ⵉ ⴼⴰⵙⵜⵓⵙ: “ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵙⵍⴻⵖ ⵉ ⴱⵏⴰⴷⴻⵎ-ⴰ!” ⵢⴰⵔⵔⴰ-ⴷⴷ ⵅⴰⵙ: “ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⴰⵙ ⵜⴻⵙⵍⴻⴷ!” ");
INSERT INTO rift_vpl VALUES ("AC25_23","074_25_23","ACT","25","23","23","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵖⵔⵉⴱⴰⵙ ⴷ ⴱⴰⵔⵏⵉⴽⵉ ⵙ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵏ ⵓⵛⴰ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵛⵛⵔⴻⵄ ⴰⴽ-ⴷ ⵉⴽⵓⵎⴰⵏⴷⴰⵔⴻⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ⵅⴻⵏⵏⵉ ⵢⵓⵎⵓⵔ ⴼⴰⵙⵜⵓⵙ, ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC25_24","074_25_24","ACT","25","24","24","ⵉⵏⵏⴰ ⴼⴰⵙⵜⵓⵙ: “ⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ ⵓ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⴷⴰ ⵉⵃⴹⴰⵔⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ: ⴰⵇⴰ ⵅ ⵡⴻⵔⵢⴰⵣ-ⴰ ⵏⵏⵉ ⵜⴻⵥⵔⵉⵎ ⴷⴰⵏⵉⵜⴰ, ⴰⵇⴰ ⵛⴻⵜⵛⴰⵏ ⵅⴰⵙ ⵖⴰⵔⵉ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵛⵉ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵓⵍⴰ ⴷⴰⵏⵉⵜⴰ, ⵙⵖⵓⵢⵢⵓⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵎⵉ ⴰⴷ ⵉⴷⴷⴰⵔ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("AC25_25","074_25_25","ACT","25","25","25","ⵎⴰⵛⴰ ⵓⴼⵉⵖ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵡⴰⵍⵓ ⵎⵉⵏ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ, ⵓⵎⵓⵔⴻⵖ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC25_26","074_25_26","ACT","25","26","26","ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏⵉⵛⴰⵏ ⵙⵙⵏⴻⵖ ⵜⵜ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴰⵔⵉⵖ ⵉ ⵇⴰⵢⵚⴰⵔ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴻⵃⴹⴰⵔⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵛⴻⴽ, ⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ, ⵃⵉⵎⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⵏⴽⴻⵎⵎⴻⵍ ⵜⴰⵔⴻⵣⵣⵓⵜ, ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵎⵉⵏ ⵖⴰ ⴰⵔⵉⵖ ⵉ ⵇⴰⵢⵚⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("AC25_27","074_25_27","ACT","25","27","27","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵊⵊ ⵏ ⵓⵎⴻⵃⴱⵓⵙ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴰⵔⵉⵖ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("AC26_1","074_26_1","ACT","26","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵖⵔⵉⴱⴰⵙ ⵉ ⴱⵓⵍⵓⵙ: “ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵜⵜⴻⵙⵔⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ!” ⵅⴻⵏⵏⵉ ⵉⵙⵙⵡⵉⵥⵥⴻⴹ ⴱⵓⵍⵓⵙ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵜⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("AC26_2","074_26_2","ACT","26","2","2","“ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⴷ ⴰⵢⵉ ⴹⴻⵍⵎⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ, ⵃⴻⵙⵙⴱⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⵉⵎⵓⵏ, ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵡⵜⴻⵖ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("AC26_3","074_26_3","ACT","26","3","3","ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙ ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵍⵉⵃ ⵎⴰⵔⵔⴰ ⵉⵅⴰⵔⵡⵉⴹⴻⵏ ⴷ ⵉⵣⴻⵔⴼⴰⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵢⴻⴽ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵍⴻⴷ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC26_4","074_26_4","ACT","26","4","4","ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ, ⵉⵡⴰ, ⵎⴰⵍⴰ ⵅⵙⴻⵏ ⴰⴷ ⵛⴻⵀⴷⴻⵏ ⵡⴰⵀⴰ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵙⵙⵏⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵎⵍⵉⵃ ⵣⵉ ⵜⴻⵎⵥⵉ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵓⵖⴰ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("AC26_5","074_26_5","ACT","26","5","5","ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ ⴰⵢⵉ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ, ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵜⵓⵖⴰ ⴷⴷⴰⵔⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵖⵓⵔⵉ ⵏⵉⵛⴰⵏ ⵏ ⵉⴼⴰⵔⵉⵙⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC26_6","074_26_6","ACT","26","6","6","ⵓ ⵍⴻⵅⵅⵓ ⴱⴻⴷⴷⴻⵖ ⴷⴰⵏⵉⵜⴰ, ⵜⵜⵡⴰⵃⴰⴽⴰⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵙⵉⵜⴻⵎ ⵏ ⵍⵡⴰⵄⴷ ⵉ ⵣⵉ ⵉⵡⴰⵄⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC26_7","074_26_7","ACT","26","7","7","ⵎⴰⵖⴰⵔ ⵡⴰ ⴷ ⴰⵙⵉⵜⴻⵎ ⵏⵏⵉ ⵜⵜⵔⴰⵊⴰⵏⵜ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏⵏⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵙ ⴷⴷ-ⴰⵡⴹⴻⵏⵜ, ⴰⵎ ⵙⵙⴳⴻⵄⵄⴷⴻⵏⵜ ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⵢⵓⴵⵖⴻⵏ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ. ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵓⵙⵉⵜⴻⵎ-ⴰ, ⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ, ⴹⴻⵍⵎⴻⵏ ⴰⵢⵉ ⵡⵓⴷⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC26_8","074_26_8","ACT","26","8","8","ⵎⴰⵎⵎⴻⵛ ⵜⵃⴻⴽⴽⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ? ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴰⵎⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("AC26_9","074_26_9","ACT","26","9","9","ⵣⵉⵛ ⵜⵓⵖⴰ ⵣⴻⵄⵎⴻⵖ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴳⴳⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⴹⵉⴷⴷ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⵏⵏⴰⵚⵉⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("AC26_10","074_26_10","ACT","26","10","10","ⵓⵛⴰ ⴰⵢⴰ ⵉ ⴳⴳⵉⵖ ⵄⴰⵡⴻⴷ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ⴰⵎ ⵟⵟⴼⴻⵖ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵃⴻⴱⴱⵙⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ⵓⵛⴰ ⵍⴰⵎⵉ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵔⴻⵟⵟⵉⵖ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵅⴰⵙ ⵉⵃⴻⴽⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC26_11","074_26_11","ACT","26","11","11","ⵄⴻⴷⴱⴻⵖ ⵜⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⵣⵉⴷⴰⵡⵉⵏ, ⴳⴳⵉⵖ ⵅⴰⵙⴻⵏ ⵓⵖⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⵇⵇⴼⴻⵏ ⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ. ⵜⵓⵖⴰ ⵜⵜⵀⴰⵊⴻⵖ ⵅⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵓ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ ⵖⴰⵔ ⵜⵏⴻⴷⴷⴰⵎ ⵉⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵎⴰⵔⵔⵜⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC26_12","074_26_12","ACT","26","12","12","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⵉ ⵙ ⵚⵚⵓⵍⵟⴰ ⴷ ⵜⵜⴻⵙⵔⵉⵃ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC26_13","074_26_13","ACT","26","13","13","ⵅⴻⵏⵏⵉ, ⴰ ⴰⵊⴻⴵⵉⴷ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵥⵔⵉⵖ ⵉⵛⵜ ⵏ ⵜⴼⴰⵡⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵖⴰⵔ ⵡⴻⵣⵢⴻⵏ ⵏ ⵡⴰⵙⵙ, ⵜᵉⵜⵜⵉⵙⵙⵉⵇⵇ ⴽⵜⴰⵔ ⵣⵉ ⵜⴼⵓⵛⵜ, ⵜⴻⵏⵏⴻⴹ ⴰⵢⵉ-ⴷⴷ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ ⵉⵎⵙⴰⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC26_14","074_26_14","ACT","26","14","14","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵡⴹⴰ ⵎⴰⵔⵔⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⵍⵉⵖ ⵉ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵙⵙⴰⵡⴰⵍ-ⴷⴷ ⴰⴽⵉⴷⵉ, ⵜⴻⵇⵇⴰⵔ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ: ‘ⵛⴰⵡⵓⵍ, ⵛⴰⵡⵓⵍ, ⵎⴰⵢⴻⵎⵎⵉ ⵅⴰⴼⵉ ⵜⴷⴰⵔⵔⵛⴻⴷ? ⴰⵇⴰ ⵜⴰⵔⴻⵏⵢⴻⴷ ⵜⵣⴻⵢⵢⴰⵔⴻⴷ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓⵎⵉ ⵛⴻⴽ ⵜⴻⵛⵛⴰⵜⴻⴷ ⴰⵡⴰⵔⵏⵉ ⴰⵛ ⴷⵉ ⵙⵍⴻⴽ ⵏ ⴱⵓⵢⴽⵓⵛⴹⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AC26_15","074_26_15","ACT","26","15","15","ⵏⵏⵉⵖ: ‘ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ?’ ⵉⵏⵏⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ: ‘ⵏⴻⵛⵛ ⴷ ⵢⴰⵙⵓⵄ ⴰⵏⵏⴰⵚⵉⵔⵉ, ⵡⴻⵏⵏⵉ ⵜⵎⴰⵔⵔⵜⴻⴷ.’ ");
INSERT INTO rift_vpl VALUES ("AC26_16","074_26_16","ACT","26","16","16","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: ‘ⴽⴽⴰⵔ, ⵜⴱⴻⴷⴷⴻⴷ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵉ ⵓⵢⴰ ⵉ ⴷ ⴰⵛ ⴷⴷ-ⴹⵀⴰⵔⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⴰⵔⴻⵛⵃⵃⴻⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴷ ⴰⵛⴻⵀⵀⴰⴷ, ⴰⵇⴰ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵥⵔⵉⴷ ⵓ ⴰⵇⴰ ⴰⴷ ⴰⵢⵉ ⵜⵥⴰⵔⴻⴷ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("AC26_17","074_26_17","ACT","26","17","17","ⴰⴷ ⴼⴻⴽⴽⴻⵖ ⵛⴻⴽ ⵣⴻⴳ ⵡⴻⵢⴷⵓⴷ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵓ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⴻⵖⵏⵉ ⵉ ⵖⴰⵔ ⵛⴻⴽ ⵖⴰ ⵙⵙⴻⴽⴽⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("AC26_18","074_26_18","ACT","26","18","18","ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵔⴻⵣⵎⴻⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⴱⴻⵏ ⵣⵉ ⵜⴰⴵⴻⵙⵜ ⵖⴰⵔ ⵜⴼⴰⵡⵜ ⵓ ⵣⵉ ⵚⵚⵓⵍⵟⴰ ⵏ ⵛⵛⵉⵟⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵍⵡⴰⵔⵜ ⵊⴰⵔ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵙ ⵍ’ⵉⵎⴰⵏ ⵉ ⴷⴰⵢⵉ ⵉⴵⴰⵏ.’ ");
INSERT INTO rift_vpl VALUES ("AC26_19","074_26_19","ACT","26","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ, ⵡⴰⵔ ⵄⴻⴽⴽⵙⴻⵖ ⵛⴰ ⵍⴻⵡⵃⵉⵢ ⵏⵏⵉ ⵥⵔⵉⵖ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("AC26_20","074_26_20","ACT","26","20","20","ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⴱⴷⵉⵖ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⵉⵎⴰⵛⵇ ⴷ ⵓⵔⵛⴰⵍⵉⵎ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⴷⵛⵓⵔⴰⵜ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴱⴰⵔⵔⵃⴻⵖ ⵄⴰⵡⴻⴷ ⵉ ⵍⴻⴳⵏⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⴱⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵜⵜⵓⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("AC26_21","074_26_21","ACT","26","21","21","ⵙ ⵓⵢⴻⵏⵏⵉ ⵟⵟⴼⴻⵏ ⴰⵢⵉ ⵡⵓⴷⴰⵢⴻⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC26_22","074_26_22","ACT","26","22","22","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵢⵉ ⴰⴼⵓⵙ ⴰⵍ ⴰⵙⵙ-ⴰ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴱⴻⴷⴷⴻⵖ ⴷⴰ ⵣⵣⴰⵜ ⵉ ⵓⵎⴻⵥⵢⴰⵏ ⴷ ⵓⵎⴻⵇⵇⵔⴰⵏ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵖ ⵡⴰⵍⵓ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵎⵖⵉⵔ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵡⴰⵀⴰ ⵏⵏⵉ ⵣⵉ ⵇⵇⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴰⴷ ⵉⵍⵉⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("AC26_23","074_26_23","ACT","26","23","23","ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⵓ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴼⴰⵡⵜ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵓ ⵉ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC26_24","074_26_24","ACT","26","24","24","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⴷⴰⴼⴻⵄ ⴱⵓⵍⵓⵙ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎⵎⵓ, ⵉⵏⵏⴰ ⴼⴰⵙⵜⵓⵙ ⵙ ⵊⵊⴻⵀⴷ: “ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⴱⵓⵀⴰⵍⵉ, ⴰ ⴱⵓⵍⵓⵙ. ⴰⵟⵟⴰⵙ ⵏ ⵜⵖⵓⵔⵉ ⵜⴻⵙⵙⴱⵓⵀⵍⵉ ⵉ ⵛⴻⴽ.” ");
INSERT INTO rift_vpl VALUES ("AC26_25","074_26_25","ACT","26","25","25","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵡⴰⵅⴻⵍⴼⴻⵖ ⵛⴰ, ⴰ ⵙⵉⴷⵉ ⴼⴰⵙⵜⵓⵙ ⵢⵓⵄⵍⴰⵏ, ⴰⵇⴰ ⵇⵇⴰⵔⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⴷⴻⵜⵜ, ⴷⴰⵢⵙⴻⵏ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC26_26","074_26_26","ACT","26","26","26","ⵓⵍⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ ⵉⵙⵙⴻⵏ ⵎⵍⵉⵃ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⵎⵉⵏⵣⵉ ⵉⵜⵜⵍⵉⵖ ⴰⵢⵉ ⴱⴻⵍⵍⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵇⴰ ⵜⴻⵏⵏⵓⴼⴼⴰⵔ ⵅⴰⵙ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵎⵙⴰⵔ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("AC26_27","074_26_27","ACT","26","27","27","ⵎⴰ ⵜⵓⵎⵏⴻⴷ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴰ ⴰⵊⴻⴵⵉⴷ ⴰⵖⵔⵉⴱⴰⵙ? ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵜⵓⵎⵏⴻⴷ ⵣⵣⴰⵢⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC26_28","074_26_28","ACT","26","28","28","ⵎⴰⵛⴰ ⴰⵖⵔⵉⴱⴰⵙ ⵉⵏⵏⴰ ⴰⵙ: “ⵎⵖⵉⵔ ⵙ ⴷⵔⵓⵙ ⵜⴻⵙⵙⵇⴻⵏⵄⴻⴷ ⴰⵢⵉ ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵎⴰⵙⵉⵃⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC26_29","074_26_29","ACT","26","29","29","ⵉⵏⵏⴰ ⴰⵙ ⴱⵓⵍⵓⵙ: “ⵜⵜⴰⵔⴻⵖ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⴷⴻⵖⵢⴰ ⵓ ⵉ ⵡⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴻⴽ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵙⵙ-ⴰ, ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵎ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC26_30","074_26_30","ACT","26","30","30","ⵉⴽⴽⴰⵔ ⵓⵊⴻⴵⵉⴷ ⴷ ⵍⵄⴰⵎⵉⵍ ⴷ ⴱⴰⵔⵏⵉⴽⵉ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵉⵇⵇⵉⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC26_31","074_26_31","ACT","26","31","31","ⵓⵛⴰ ⴼⴼⵖⴻⵏ ⵙⵙⴻⵏⵏⵉ ⴰⵎ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵏⵏⴰⵏ ⵊⴰⵔ ⴰⵙⴻⵏ: “ⴰⵔⵢⴰⵣ-ⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵛⴰ ⵎⵉⵏ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵍⵎⴻⵡⵜ ⵓⵍⴰ ⴷ ⵉⵛⴻⴷⴷⵉⵢⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC26_32","074_26_32","ACT","26","32","32","ⵉⵏⵏⴰ ⴰⵖⵔⵉⴱⴰⵙ ⵉ ⴼⴰⵙⵜⵓⵙ: “ⵎⴰⵄⵍⵉⴽ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ, ⵉⵍⵉ ⴰⵇⴰ ⵉⵜⵜⵡⴰⴹⵍⴻⵇ ⴱⵏⴰⴷⴻⵎ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC27_1","074_27_1","ACT","27","1","1","ⵅⴰⵙ ⵓⵛⴰ ⵉⴽⴽⴻⵙ ⴼⴰⵙⵜⵓⵙ ⴰⵡⴰⵍ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ ⵖⴰⵔ ⵉⵟⴰⵍⵢⴰ. ⵏⴻⵜⵜⴰ ⵉⵙⴻⵍⵍⴻⵎ ⴱⵓⵍⵓⵙ ⴷ ⵛⴰ ⵏ ⵉⵎⴻⵃⴱⴰⵙ ⵏⵏⴻⵖⵏⵉ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵢⵓⵍⵉⵢⵓⵙ, ⵜⵓⵖⴰ-ⵜ ⵣⵉ ⵍⴽⵓⵎⴱⴰⵏⵉⵢⵢⴻⵜ ⵏ ⵇⴰⵢⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_2","074_27_2","ACT","27","2","2","ⵍⴰⵎⵉ ⵏⴻⵏⵡⴰ ⴰⴷ ⵏⴱⴻⵃⵃⴰⵔ, ⵏⴻⵏⵢⴰ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵣⵉ ⴰⴷⵔⴰⵎⴰⵏⵜⵓⵙ, ⵜⵓⵖⴰ ⴰⴷ ⵉⴽⴽ ⵅ ⵊⵊⵡⴰⵢⴻⵀ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵎⴰ ⵏ ⴰⵙⵉⵢⴰ, ⵓⵛⴰ ⵏⵔⵓⵃ. ⵉⵏⵢⴰ ⴰⴽⵉⴷⵏⴻⵖ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴰⵔⵉⵙⵜⴰⵔⵅⵓⵙ, ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_3","074_27_3","ACT","27","3","3","ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵚⴰⵢⴷⵓⵏ. ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵜⵓⵖⴰ ⵉⴵⴰ ⵎⵍⵉⵃ ⴰⴽ-ⴷ ⴱⵓⵍⵓⵙ, ⵉⵙⴰⵎⵃ ⴰⵙ ⴰⴷ ⵉⵔⴰⵃ ⵖⴰⵔ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC27_4","074_27_4","ACT","27","4","4","ⵙⵙⴻⵏⵏⵉ ⵏⴻⴼⴼⴻⵖ, ⵏⴱⴻⵃⵃⴰⵔ ⵙ ⵉⵊⵊ ⵏ ⴷⴷⵓⵔⴰ, ⵏⴻⵄⴷⵓ ⵅ ⵇⵓⴱⵔⵓⵙ, ⵎⵉⵏⵣⵉ ⴰⵙⴻⵎⵎⵉⴹ ⵜⵓⵖⴰ ⵉⵛⵛⴰⵜ ⴷⴰⵢⵏⴻⵖ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("AC27_5","074_27_5","ACT","27","5","5","ⵏⴻⵥⵡⴰ ⵍⴻⴱⵃⴰⵔ ⵏ ⴽⵉⵍⵉⴽⵉⵢⴰ ⴷ ⴱⴰⵎⴼⵉⵍⵉⵢⴰ, ⵓⵛⴰ ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵎⵉⵔⴰ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵍⵉⴽⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_6","074_27_6","ACT","27","6","6","ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵢⵓⴼⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵣⵉ ⵉⵙⴽⴰⵏⴷⴰⵔⵉⵢⵢⴰ, ⵉⵜⵜⵔⴰⵃ ⵖⴰⵔ ⵉⵟⴰⵍⵢⴰ, ⵉⵙⵙⴻⵏⵢⴰ ⴰⵏⴻⵖ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC27_7","074_27_7","ACT","27","7","7","ⵎⴰⵖⴰⵔ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵡⴰⵔ ⵉⵔⵓⵃ ⵖⴰⵔ ⵣⵣⴰⵜ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵏⵉⵡⴻⴹ ⵙ ⵓⵖⵉⵍ ⵣⵣⴰⵜ ⵉ ⵜⴻⴳⵣⵉⵔⵜ ⵏ ⴽⵏⵉⴷⵓⵙ, ⵓ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵢⴻⵊⵊⵉ ⵓⵙⴻⵎⵎⵉⴹ ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵏⴱⴻⵃⵃⴰⵔ ⴷⴻⴳ ⵓⴷⴷⵓⵔⵉ ⵏ ⴽⵔⵉⵜⴰ ⵣⵣⴰⵜ ⵉ ⵙⴰⵍⵎⵓⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("AC27_8","074_27_8","ACT","27","8","8","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⵄⵍⴰⵢⴻⵏ ⴰⴷ ⵏⴻⵏⴷⴻⵀ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵏⵉⵡⴻⴹ, ⵍⴰⵎⵉ ⵏⴻⵡⵜⴰ ⵉⵛⵜ ⵏ ⴷⴷⵓⵔⴰ ⵜⴻⵎⵖⴰⵔ, ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵍⵎⵓⵢⵢⴰⵜ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ’, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵟⵟⴰⵔⴼ ⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵍⴰⵙⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_9","074_27_9","ACT","27","9","9","ⵏⴻⵇⵇⵉⵎ ⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ ⴷⵉⵏⵏⵉ ⴰⵍ ⴷⴷ-ⵉⵄⴷⵓ ⴰⵙⵙ ⵏ ⵓⵥⵓⵎⵎⵉ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⵓⵙⴰⴼⴰⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵢⴻⵡⵄⴰⵔ, ⵉⵄⵍⴻⵎ ⴰⵙⴻⵏ ⴱⵓⵍⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("AC27_10","074_27_10","ACT","27","10","10","ⵉⵏⵏⴰ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵜⵜⵡⴰⵍⵉⵖ ⴰⵙⴰⴼⴰⵔ ⴰⴷ ⵢⴰⵡⵉ ⴷⵔⵓⵛⵜ ⴷ ⵜⵅⴻⵙⵙⴰⵔⵜ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵜⴻⴵⵉ ⵉ ⵙⵙⴻⵍⵄⴻⵜ ⴷ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵏⵏⴻⵖ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("AC27_11","074_27_11","ACT","27","11","11","ⵎⴰⵛⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵜⵓⵖⴰ ⵉⵙⵍⴰ ⴽⵜⴰⵔ ⵖⴰⵔ ⵓⵎⴻⵏⴷⴰⵀ ⴷ ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵙⵍⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC27_12","074_27_12","ACT","27","12","12","ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵎⵛⴰⵏ ⵏ ⵍⵎⵓⵢⵢⵉ ⵡⴰⵔ ⵉⵃⵍⵉ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵏ ⵍⵎⴻⵛⵜⴰ ⴷⵉⵏ, ⵉⴱⴻⴷⴷ ⴰⵔⵔⴰⵢ ⵏ ⵡⴻⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ ⴰⴷ ⴼⴼⵖⴻⵏ ⵙⵙⴻⵏⵏⵉ, ⴱⴰⵍⴰⴽ ⴰⴷ ⴰⵡⴹⴻⵏ ⵖⴰⵔ ⴼⵉⵏⵉⴽⵙ, ⵉⵊⵊ ⵏ ⵍⵎⵓⵢⵢⵉ ⴷⵉ ⴽⵔⵉⵜⴰ, ⵉⵡⴰⵍⴰⵏ ⵍⵊⴰⵏⵓⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵙⵙⴻⵄⴷⵓⵏ ⵍⵎⴻⵛⵜⴰ. * ");
INSERT INTO rift_vpl VALUES ("AC27_13","074_27_13","ACT","27","13","13","ⵓⵎⵉ ⵉⵙⴰⵀⴰ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵍⵊⴰⵏⵓⴱ, ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵜⵜⵉⵎⴻⵏ ⴰⴷ ⴰⵡⴹⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵅⵙⴻⵏ, ⵓⵛⴰ ⵏⴻⴱⴷⴰ ⵜⵜⵛⵓⵇⴰⵏ ⵅ ⵟⵟⴰⵔⴼ ⵏ ⵜⵎⴰ ⵏ ⴽⵔⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_14","074_27_14","ACT","27","14","14","ⵎⴰⵛⴰ ⵛⵡⴰⵢⵜ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵜⴻⴽⴽⴰⵔ ⵉⵛⵜ ⵏ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵜⵜⵉⴼⵓⵏ ‘ⵓⵔⵓⴽⵍⵉⴷⵓⵏ’. ");
INSERT INTO rift_vpl VALUES ("AC27_15","074_27_15","ACT","27","15","15","ⵉⵜⵜⵡⴰⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵙ ⵊⵊⴻⵀⴷ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵉ ⵓⵙⴻⵎⵎⵉⴹ. ⵅⴻⵏⵏⵉ ⵏⴻⵙⵜⴻⵡⵟⴻⵄ ⵓⵛⴰ ⵏⴻⵜⵜⵡⴰⵏⴷⴻⵀ. ");
INSERT INTO rift_vpl VALUES ("AC27_16","074_27_16","ACT","27","16","16","ⴰⵎ ⵏⴻⴽⴽⴰ ⴷⴻⴳ ⵓⴷⴷⵓⵔⵉ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⴳⵣⵉⵔⵜ ⴷ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⵇⴰⵡⴷⴰ’, ⵙ ⵓⵖⵉⵍ ⵉ ⵏⴻⵎⵏⴻⵄ ⴹⵎⴰⵏ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵏ ⵓⵙⴻⵍⵍⴻⴽ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("AC27_17","074_27_17","ACT","27","17","17","ⵏⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⵜ, ⵓ ⵏⴻⵙⵙⴻⵊⵀⴻⴷ ⴰⵖⴰⵔⵔⴰⴱⵓ ⴰⵎ ⵜ ⵏⴻⴱⵢⴻⵙ ⵙⵡⴰⴷⴷⴰⵢ ⵙ ⵉⵃⴻⵣⵣⴰⵎⴻⵏ. ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵏⴻⴳⴳⵯⴻⴷ ⴰⵇⴰ ⴰⵖⴰⵔⵔⴰⴱⵓ ⴰⴷ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵅ ⵉⵛⵜ ⵏ ⵍⴳⴻⵄⵄⴷⴻⵜ ⵏ ⵉⵊⴷⵉ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵏⴻⵙⵙⴻⵀⵡⴰ-ⴷⴷ ⵍⴱⴰⵛⵛ ⵓⵛⴰ ⵏⴻⵜⵜⵡⴰⵏⴷⴻⵀ ⵙ ⵓⵙⴻⵎⵎⵉⴹ ⵓ ⴰⵎⵎⵓ ⵉ ⵏⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("AC27_18","074_27_18","ACT","27","18","18","ⵓⵛⴰ ⵓⵎⵉ ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵜⵀⴰⵊ ⵅⴰⵏⴻⵖ ⴰⵟⵟⴰⵙ, ⵅⴻⵏⵏⵉ ⵜⵉⵡⴻⵛⵛⴰ ⵏⵏⴻⵙ ⵏⴻⵏⴹⴰⵔ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵏⴻⵖ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_19","074_27_19","ACT","27","19","19","ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏⴻⵏⴹⴰⵔ ⵍⴻⵇⵛⵓⵄ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC27_20","074_27_20","ACT","27","20","20","ⵍⴰⵎⵉ ⵜⴰⵃⴰⵔⵢⴰⴹⵜ ⵜⴻⵇⵇⵉⵎ ⵜᵉⵜⵜⵙⵓⴹ ⴰⵟⵟⴰⵙ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵡⴰⵔ ⵜⴱⵉⵏ ⵜⴼⵓⵛⵜ ⵍⴰ ⴷ ⵜⴰⵣⵉⵔⵉ ⵓⵍⴰ ⴷ ⵉⵜⵔⴰⵏ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴹⴻⵄ ⵎⴰⵔⵔⴰ ⵍⴰⵢⴰⵙ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_21","074_27_21","ACT","27","21","21","ⵍⴰⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵚⴱⴰⵔ ⵄⴰⴷ, ⵉⴱⴻⴷⴷ ⴱⵓⵍⵓⵙ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⵉⵏⵏⴰ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴰⴷ ⵖⴰⵔⵉ ⵜⴻⵙⵍⴻⵎ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵏⴻⴼⴼⵉⵖ ⵛⴰ ⵣⵉ ⴽⵔⵉⵜⴰ ⵓ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵍⴻⵇⵇⴻⴼ ⴷⵔⵓⵛⵜ-ⴰ ⴷ ⵍⴻⵃⵚⴰⵔⴻⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_22","074_27_22","ACT","27","22","22","ⵍⴻⵅⵅⵓ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵛⴻⵊⵊⵄⴻⵖ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴻⴷⴷⴰⵔⵉ ⵛⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⵖⵉⵔ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵡⴰⵀⴰ ⴰⴷ ⵉⵖⴻⴱⴱⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("AC27_23","074_27_23","ACT","27","23","23","ⵎⵉⵏⵣⵉ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵖⴰⵔⵉ ⴵⵉⵍⴻⵜ-ⴰ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵄⴻⴱⴱⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("AC27_24","074_27_24","ACT","27","24","24","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ, ⴰ ⴱⵓⵍⵓⵙ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵛ ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵇⵉⴱⴰⵍⵜ ⵉ ⵇⴰⵢⵚⴰⵔ. ⵅⵣⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⴽ ⵉⵜⵜⴱⴻⵃⵃⴰⵔⴻⵏ, ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵛ ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("AC27_25","074_27_25","ACT","27","25","25","ⵙ ⵓⵢⴰ ⴳⴳⴻⵎ ⵜⴰⵔⵢⴰⵙⵜ, ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵜⵉⵇⵇⴻⵖ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴻⵍⵍⵉ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_26","074_27_26","ACT","27","26","26","ⵎⴰⵛⴰ ⴰⴷ ⵏⴻⵎⵎⴻⵏⴹⴰⵔ ⵅ ⵉⵛⵜ ⵏ ⵜⴻⴳⵣⵉⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("AC27_27","074_27_27","ACT","27","27","27","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⴻⵜⵜⵡⴰⵄⴰⵔⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⵉⵀⴰ ⵓ ⵏⴻⵙⵙⵉⵃⴻⵍ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵀⴰⴷⵔⵉⵢⵓⵙ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⵉ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⴵⵉⵍⴻⵜ, ⴰⵇⴰ ⵏⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵖⴰⵔ ⵍⴱⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_28","074_27_28","ACT","27","28","28","ⵏⵉⵜⵏⵉ ⵏⴹⴰⵔⴻⵏ ⴰⵢⵍⵉⵣⵉⵎ ⴷⵉ ⵔⴰⴵⴰⵖ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵄⴻⴱⴱⴰⵔⴻⵏ ⵄⵉⵛⵔⵉⵏ ⵏ ⵜⵉⴷⴷⵉⵡⵉⵏ. ⵓⵎⵉ ⵄⴷⵓⵏ ⵛⵡⴰⵢⵜ, ⵄⴻⴱⴱⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵜⵉⴷⴷⵉⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("AC27_29","074_27_29","ACT","27","29","29","ⴰⵎ ⵏⴻⴳⴳⵯⴻⴷ ⴰⴷ ⵏⴻⵍⵇⴻⴼ ⵉⵎⵓⵛⴰⵏ ⵏ ⵙⵙⴻⴵⴰⵃ, ⵏⴻⵏⴹⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵢⵍⵉⵣⴰⵎ ⵣⵉ ⴹⴻⴼⴼⴰⵔ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵓⵛⴰ ⵏⴻⵜⵜⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⵡⴻⴹ ⵓⵣⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("AC27_30","074_27_30","ACT","27","30","30","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵅⵙⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵙⵙⴹⴰⵔⴻⵏ ⵜⴰⵖⴰⵔⵔⴰⴱⵓⵜ ⵏ ⵓⵙⴻⵍⵍⴻⴽ ⵖⴰⵔ ⵍⴻⴱⵃⴰⵔ ⴰⵅⵎⵉ ⵅⵙⴻⵏ ⴰⴷ ⴷⴰⵢⴻⵙ ⵏⵢⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴷⴷⴻⵏ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("AC27_31","074_27_31","ACT","27","31","31","ⵓⵎⵉ ⵉⵥⵔⴰ ⴱⵓⵍⵓⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ ⵉ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵓ ⵉ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ: “ⵎⴰⵍⴰ ⵉⵏⴰ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC27_32","074_27_32","ACT","27","32","32","ⵅⴻⵏⵏⵉ ⵇⴻⵙⵙⴻⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵉⵙⴻⵖⵡⴰⵏ ⵏ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ ⵏ ⵓⵙⴻⵍⵍⴻⴽ ⵓⵛⴰ ⵊⵊⵉⵏ ⵜⵜ ⴰⴷ ⵜⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("AC27_33","074_27_33","ACT","27","33","33","ⴰⵍⴰⵎⵉ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ ⴰⴷ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ, ⵉⵣⵉⵢⵢⴰⵔ ⵉ-ⵜⴻⵏ ⴱⵓⵍⵓⵙ ⵎⴰⵔⵔⴰ ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ, ⵉⵏⵏⴰ: “ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⵛⵛⵉⵎ ⵡⴰⵍⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵅⴰⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_34","074_27_34","ACT","27","34","34","ⵙ ⵓⵢⴻⵏⵏⵉ ⵛⴻⵊⵊⵄⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵛⵛⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴻⴷⴷⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵡⴻⵟⵟⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵥⴻⵟⵟⵓ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("AC27_35","074_27_35","ACT","27","35","35","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⴰⵢⴰ, ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ, ⵉⵙⵙⴻⵎⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵎⴰⵔⵔⴰ, ⵢⴰⵔⵥⴰ ⵉ-ⵜ, ⵉⴱⴷⴰ ⴰⴷ ⵉⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("AC27_36","074_27_36","ACT","27","36","36","ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵛⴻⵊⵊⵄⴻⵏ ⵓ ⴽⵙⵉⵏ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("AC27_37","074_27_37","ACT","27","37","37","ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴷⵉ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⴱⵄⵉⵏ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC27_38","074_27_38","ACT","27","38","38","ⵍⴰⵎⵉ ⵊⵊⵉⵡⵏⴻⵏ ⵙ ⵎⴰⵛⵛⴰ, ⴱⴷⴰⵏ ⵙⵙⴻⴼⵙⴰⵙⴻⵏ ⴰⵖⴰⵔⵔⴰⴱⵓ, ⴰⵎ ⴽⵙⵉⵏ ⵍⵃⴻⴱⴱ ⵏ ⵢⵉⵔⴷⴻⵏ, ⵏⴹⴰⵔⴻⵏ ⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_39","074_27_39","ACT","27","39","39","ⴰⵍⴰⵎⵉ ⵉⵚⴱⴻⵃ ⵍⵃⴰⵍ, ⵜⵓⵖⴰ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⴰⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵉ ⵜⴻⴵⴰ, ⵎⴰⵛⴰ ⵥⵔⵉⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵙⵔⵓⵇ ⵏ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴱⴰⵔⵔ ⵓⵛⴰ ⵎⵛⴰⵡⴰⵔⴻⵏ, ⵎⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⵉⵏ ⵄⴰⵔⵏⴻⵏ ⴰⵖⴰⵔⵔⴰⴱⵓ. ");
INSERT INTO rift_vpl VALUES ("AC27_40","074_27_40","ACT","27","40","40","ⵓⵎⵉ ⵇⴻⴹⵡⴻⵏ ⵉⵢⵍⵉⵣⴰⵎ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵊⵊⵉⵏ ⵜⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⴼⴻⵙⵢⴻⵏ ⵉⵛⴻⴷⴷⴰⵏ ⵏ ⵍⴻⵎⵇⴰⴷⴻⴼ, ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵍⴱⴰⵛⵛ ⵏ ⵣⵣⴰⵜ ⵉ ⵓⵙⴻⵎⵎⵉⴹ ⵉⵜⵜⵙⵓⴹⴻⵏ, ⵡⴻⵊⵊⵀⴻⵏ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴱⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_41","074_27_41","ACT","27","41","41","ⵎⴰⵛⴰ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵉⵡⵜⴰ ⵉⵊⵊ ⵏ ⵓⵄⴰⵔⵔⵉⵛ ⵏ ⵢⴻⵊⴷⵉ ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⴻⴱⵃⴰⵔ ⵖⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵓⵛⴰ ⵏⵏⵓⵖⴻⵏ ⵙ ⵓⵖⴰⵔⵔⴰⴱⵓ. ⵢⴰⵔⵙⴰ ⵣⵣⴰⵜ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵅ ⵓⵄⴰⵔⵔⵉⵛ ⵏ ⵢⴻⵊⴷⵉ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵏⵀⴻⵣⵣ, ⵎⴰⵛⴰ ⴹⴻⴼⴼⴰⵔ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵉⵇⴻⵍⵄ ⵉ-ⵜ ⵊⵊⴻⵀⴷ ⵏ ⵍⴻⵎⵡⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("AC27_42","074_27_42","ACT","27","42","42","ⵜⵓⵖⴰ ⵏⴻⵡⵡⴰⵏ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⴰⴷ ⵏⵖⴻⵏ ⵉⵎⴻⵃⴱⴰⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵃⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵄⵓⵎⵎ, ⵓⵛⴰ ⴰⴷ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("AC27_43","074_27_43","ACT","27","43","43","ⵎⴰⵛⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴱⵓⵍⵓⵙ, ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏ, ⵢⵓⵎⵓⵔ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵄⵓⵎⵎⴻⵏ, ⴰⴷ ⵄⵓⵎⵎⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴱⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("AC27_44","074_27_44","ACT","27","44","44","ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵊⵊⴰ ⵉ-ⵜⴻⵏ ⴰⴷ ⵥⵡⴰⵏ ⵅ ⵜⴼⴻⵍⵡⵉⵏ ⵓ ⵅ ⵉⵣⴻⵢⵏⴰⵏ ⵏ ⵉⴽⴻⵛⵛⵓⴹⴻⵏ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵡⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴱⴰⵔⵔ, ⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC28_1","074_28_1","ACT","28","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⴼⵀⴻⵎ, ⴱⴻⵍⵍⵉ ⵜⴰⴳⵣⵉⵔⵜ-ⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵎⴰⵍⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("AC28_2","074_28_2","ACT","28","2","2","ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⴷⵉⵏ ⵉⵣⴻⴷⵖⴻⵏ ⴳⴳⵉⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ, ⴰⵎ ⵙⵙⵉⵖⴻⵏ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵍⴰⵖⴰⵏ ⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵥⵖⴻⵍ ⵎⵉⵏⵣⵉ ⴰⵏⵥⴰⵔ ⵜⵓⵖⴰ ⵉⵛⵛⴰⵜ ⴰⵟⵟⴰⵙ ⵓ ⵜⵓⵖⴰ ⵜⴻⵙⵎⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("AC28_3","074_28_3","ACT","28","3","3","ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵎⵓⵏ ⴱⵓⵍⵓⵙ ⴰⵄⵓⵔⵔⵉⵛ ⵏ ⵉⴽⴻⵛⵡⴰⴹ, ⵉⵙⵙⴰⵔⵙ ⵉ-ⵜⴻⵏ ⵅ ⵜⵎⴻⵙⵙⵉ, ⵅⴻⵏⵏⵉ ⵙ ⵍⴻⵃⵎⵓ ⵏⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⴼⵉⵖⴰⵔ ⵓⵛⴰ ⵉⵇⵇⴻⵙ ⴰⵙ ⴷⴻⴳ ⵓⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("AC28_4","074_28_4","ACT","28","4","4","ⵓⵎⵉ ⵥⵔⵉⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴰⵇⴰ ⵢⵓⵢⴻⵍ ⵓⴼⵉⵖⴰⵔ ⵖⴰⵔ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: “ⴰⴷ ⵜⴰⵖ ⴱⵏⴰⴷⴻⵎ-ⴰ ⴷ ⴰⵇⴻⵜⵜⴰⵍ, ⵡⴰⵔ ⵜ ⵜⴻⵊⵊⵉ ‘ⵍⴰⵍⵍⴰ ⵍⵃⴻⵇⵇ’ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵡⴰⵅⵅⴰ ⵉⵏⵊⴻⵎ-ⴷⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("AC28_5","074_28_5","ACT","28","5","5","ⵎⴰⵛⴰ ⴱⵓⵍⵓⵙ ⵉⵣⵣⴻⵔⵣ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵉⵎⵎⴻⵏⴹⴰⵔ ⴰⴼⵉⵖⴰⵔ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⴱⵍⴰ ⵎⴰ ⴷ ⴰⵙ ⵜⴻⵎⵙⴰⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⴷⵔⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("AC28_6","074_28_6","ACT","28","6","6","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵜⵜⵔⴰⵊⴰⵏ ⴰⴷ ⵢⵓⴼⴼ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵉⵡⴹⴰ ⴰⴷ ⵉⵎⵎⴻⵜ. ⵎⴰⵛⴰ ⵓⵎⵉ ⵥⵔⵉⵏ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵔⴰⵊⴰⵏ ⴰⵟⵟⴰⵙ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⴻⵎⵙⴰⵔ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵉⴱⴻⴷⴷⴻⵍ ⵍⵀⴰⵔⴷ ⵏⵙⴻⵏ, ⵏⵏⴰⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("AC28_7","074_28_7","ACT","28","7","7","ⵜⵓⵖⴰ ⴷ ⵊⵊⵉⵀⴻⵜ ⵏⵏⵉ ⵉⵢⵢⴰⵔⴻⵏ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⴰⴳⵍⴰ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴱⵓⴱⵍⵉⵢⵓⵙ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⴳⵣⵉⵔⵜ, ⵉⵙⵙⵏⴻⵡⵊⵓ ⴰⵏⴻⵖ ⵙ ⵍⵅⴰⵔ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("AC28_8","074_28_8","ACT","28","8","8","ⴱⴰⴱⴰⵙ ⵏ ⴱⵓⴱⵍⵉⵢⵓⵙ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵜⵉⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵃⵔⵉⵇ. ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵍⴻⵃⵍⴰⵛ ⵏ ⵜⴻⵇⵇⵔⵉⵏⵜ. ⵢⵓⴷⴻⴼ ⴱⵓⵍⵓⵙ ⵖⴰⵔⴻⵙ, ⵉⵥⵥⵓⴵ, ⵉⵙⵙⴰⵔⵙ ⵅⴰⵙ ⴰⴼⵓⵙ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵏⴼⴰ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("AC28_9","074_28_9","ACT","28","9","9","ⵓⵎⵉ ⵉⵎⵙⴰⵔ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵙⵉⵏ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⴳⵣⵉⵔⵜ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴻⵀⵍⴰⵛ ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC28_10","074_28_10","ACT","28","10","10","ⴽⴰⵔⵎⴻⵏ ⵅⴰⵏⴻⵖ ⵉⵏⴰ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵛⵛⴰⵏ. ⵓⵎⵉ ⵏⵔⵓⵃ ⵏⴱⴻⵃⵃⴰⵔ ⵙⵙⴻⵏⵏⵉ, ⵡⵛⵉⵏ ⴰⵏⴻⵖ ⵎⵉⵏ ⵜⵓⵖⴰ ⵏⴻⵃⵡⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("AC28_11","074_28_11","ACT","28","11","11","ⴰⵡⴰⵔⵏⵉ ⵜⴻⵍⵜ ⵏ ⵉⵢⵓⵔⴻⵏ ⵏⵔⵓⵃ, ⵏⴱⴻⵃⵃⴰⵔ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵣⵉ ⵉⵙⴽⴰⵏⴷⴰⵔⵉⵢⵢⴰ ⵉ ⵉⵙⵙⴻⵄⴷⵓⵏ ⵍⵎⴻⵛⵜⴰ ⴷⵉ ⵜⴻⴳⵣⵉⵔⵜ, ⵜⵓⵖⴰ ⵅⴰⵙ ⴰⵔⵛⴰⵎ ⵏ ‘ⵜⴻⵛⵏⵉⵡⵉⵏ’. ");
INSERT INTO rift_vpl VALUES ("AC28_12","074_28_12","ACT","28","12","12","ⵓⵎⵉ ⴷⴷ-ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵙⵉⵔⴰⴳⵓⵙⴰ, ⵏⴻⵇⵇⵉⵎ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC28_13","074_28_13","ACT","28","13","13","ⵙⵙⴻⵏⵏⵉ ⵏⴷⵓⵔ ⵓⵛⴰ ⵏⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔ ⵔⵉⵅⵉⵢⵓⵎ. ⴰⵡⴰⵔⵏⵉ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵓⵙⴻⵎⵎⵉⴹ ⵏ ⵜⵛⴰⵔⵎⵉⵏ ⵓⵛⴰ ⵏⵉⵡⴻⴹ-ⴷⴷ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵙⵙⴰⵏ ⵖⴰⵔ ⴱⵓⵜⵉⵢⵓⵍⵉ, ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⴷⵉ ⵉⵟⴰⵍⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("AC28_14","074_28_14","ACT","28","14","14","ⴷⵉⵏⵏⵉ ⵉ ⵏⵓⴼⴰ ⵜⴰⵡⵎⴰⵜ ⵏⵏⵉ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵜⵜⴰⵔⴻⵏ ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵏⴻⵇⵇⵉⵎ, ⵓⵛⴰ ⵏⴻⵇⵇⵉⵎ ⴰⴽⵉⴷⵙⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵅⴻⵏⵏⵉ ⵏⵔⵓⵃ ⵖⴰⵔ ⵔⵓⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("AC28_15","074_28_15","ACT","28","15","15","ⵓⵎⵉ ⵙⵍⵉⵏ ⵜⴰⵡⵎⴰⵜ ⴷⵉ ⵔⵓⵎⴰ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵏⴻⵖ, ⵓⵙⵉⵏ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵎⵎⴻⵍⵇⴰⵏ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ‘ⴰⴱⵉⵢⵓⵙ ⴼⵓⵔⵓⵙ’ ⵓ ⵖⴰⵔ ‘ⵜⵍⴰⵜⴰ ⵏ ⵜⵃⵓⵏⴰ’. ⵓⵎⵉ ⵜⴻⵏ ⵉⵥⵔⴰ ⴱⵓⵍⵓⵙ, ⵉⵛⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵛⴻⵊⵊⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("AC28_16","074_28_16","ACT","28","16","16","ⵓⵎⵉ ⴷⴷ-ⵏⵉⵡⴻⴹ ⵖⴰⵔ ⵔⵓⵎⴰ, ⵉⵡⵛⴰ ⵍⵇⴻⴱⵟⴰⵏ ⵅ ⵎⵢⴰ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⴱⵓⵍⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⴷⴻⵖ ⵎⴰⵏⵉ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⴰⴽ-ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⵙⴰⵙ ⵡⴻⵏⵏⵉ ⵜ ⵉ ⵖⴰ ⵉⵃⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("AC28_17","074_28_17","ACT","28","17","17","ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⵉⵍⴰⵖⴰ ⴱⵓⵍⵓⵙ ⵉ ⵉⵎⵛⴻⵏⵏⵄⴻⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ. ⴰⵍⴰⵎⵉ ⵎⵓⵏⴻⵏ, ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⴰ ⵉⵔⵢⴰⵣⴻⵏ ⵜⴰⵡⵎⴰⵜ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⴳⴳⵉⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴹⵉⴷⴷ ⵉ ⵍⴳⴻⵏⵙ ⵏⵉⵖ ⴹⵉⴷⴷ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⴻⵍⵍⵎⴻⵖ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵔⵓⵎⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("AC28_18","074_28_18","ACT","28","18","18","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⴱⴻⵇⵇⵛⴻⵏ, ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⴰⵢⵉ ⴰⵔⵅⵓⵏ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴰⵢⵉ ⵓⴼⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴻⵙⵙⴷⴰⵀⴻⴵ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("AC28_19","074_28_19","ACT","28","19","19","ⵎⴰⵛⴰ ⵓⵎⵉ ⵄⴻⴽⴽⵙⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵙ ⵓⵖⵉⵍ ⵅⴰⴼⵉ ⴰⴷ ⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⴷⴷⴻⵄⵡⴻⵜ ⵉⵏⵓ ⵖⴰⵔ ⵇⴰⵢⵚⴰⵔ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵛⴻⵜⵛⵉ ⵅ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("AC28_20","074_28_20","ACT","28","20","20","ⵅ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ ⵜⵜⴰⵔⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ ⵓⵛⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ. ⵎⵉⵏⵣⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⵉⵜⴻⵎ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⴰⵢⵉ ⵛⴰⵔⴼⴻⵖ ⵙ ⵙⵙⵏⴻⵙⵍⴻⵜ-ⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC28_21","074_28_21","ACT","28","21","21","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵙ: “ⵡⴰⵔ ⵅⴰⴽ ⵏⴻⵟⵟⵉⴼ ⵛⴰ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵣⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵜⴰⵡⵎⴰⵜ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⴷⴰ ⵡⵉ ⵉⵏⵏⴰⵏ ⵏⵉⵖ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵅⴰⴽ ⵙ ⵛⴰ ⵏ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("AC28_22","074_28_22","ACT","28","22","22","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵏⵙⴻⵍ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ, ⵎⵉⵏⵣⵉ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴻⴱⵔⵉⴷⵜ-ⴰ, ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵜⵜⵄⴻⴽⴽⵙⴻⵏ ⵜⵜ ⵎⴰⵏⵉ ⵎⴰ.” ");
INSERT INTO rift_vpl VALUES ("AC28_23","074_28_23","ACT","28","23","23","ⵏⵉⵜⵏⵉ ⵎⵄⴰⵀⴰⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵅ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⵓⵛⴰ ⵎⵓⵏⴻⵏ. ⴰⵟⵟⴰⵙ ⵉ-ⴷⴷ-ⵢⵓⵙⵉⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵉⵣⴻⴷⴷⴻⵖ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴼⴻⵙⵙⴰⵔ ⴰⵙⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵉⵛⴻⵀⵀⴻⴷ ⵓ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴻⵇⵏⴻⵄ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⴰⵙⵓⵄ, ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ ⵓ ⵣⴻⴳ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵣⵉ ⵍⴻⴼⵊⴰⵔ ⴰⵍⴰⵎⵉ ⴷ ⵜⴰⵎⴻⴷⴷⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("AC28_24","074_28_24","ACT","28","24","24","ⵛⴰ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("AC28_25","074_28_25","ACT","28","25","25","ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵅⴰⵙ ⴰⵎ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ. ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵙⴻⵏ ⴱⵓⵍⵓⵙ ⵄⴰⴷ ⴰⵡⴰⵍ-ⴰ: “ⵙ ⵍⵃⴻⵇⵇ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵛⴰⵄⵢⴰ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("AC28_26","074_28_26","ACT","28","26","26","‘ⵔⵓⵃ ⵖⴰⵔ ⵍⴳⴻⵏⵙ-ⴰ, ⵉⵏⵉ ⴰⵙⴻⵏ: ‘ⵙ ⵓⵙⴻⴵⵉ ⴰⴷ ⵜⴻⵙⵍⴻⵎ, ⵡⴰⵔ ⵜⴼⴻⵀⵀⴻⵎⴻⵎ, ⵙ ⵜⵎⵓⵖⵍⵉ ⴰⴷ ⵜⴻⵅⵣⴰⵔⴻⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵍⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("AC28_27","074_28_27","ACT","28","27","27","ⵎⵉⵏⵣⵉ ⵓⵍ ⵏ ⵍⴳⴻⵏⵙ-ⴰ ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⵉⵇⵙⴻⵃ, ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ ⵙⵙⴹⴻⵇⵍⴻⵏ ⵜⴻⵏ ⵉ ⵓⵙⴻⴵⵉ, ⵓ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵇⵇⵏⴻⵏ ⵜⴻⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵙⵍⵉⵏ ⵙ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⴼⴻⵀⵀⴻⵎⴻⵏ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴻⴽⴽⵡⵉⵍⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵖⴼⴰⵔⴻⵖ.’ ");
INSERT INTO rift_vpl VALUES ("AC28_28","074_28_28","ACT","28","28","28","ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ: ⴰⵔⴻⵇⵇⴰⵙ ⵏ ⵓⵙⴻⵏⵊⴻⵎ-ⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽ-ⴷⴷ ⵉ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⵙⵍⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("AC28_29","074_28_29","ACT","28","29","29","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵎⴰⵏ ⴰⵢⴰ, ⴼⴼⵖⴻⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⴰⵎ ⵜⵓⵖⴰ ⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("AC28_30","074_28_30","ACT","28","30","30","ⴱⵓⵍⵓⵙ ⵉⵛⵔⴰ ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ, ⵉⵅⴻⴵⴻⵚ ⵉ-ⵜⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ⵜⵓⵖⴰ ⵉⵜⵜⴰⵔⴻⵃⵃⴰⴱ ⵙ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("AC28_31","074_28_31","ACT","28","31","31","ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵙⵙⴻⵍⵎⴰⴷ ⵅ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵓ ⴱⵍⴰ ⵎⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⵏⴽⵔⵉⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("RM1_1","075_1_1","ROM","1","1","1","ⴱⵓⵍⵓⵙ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵔⵔⴰⵙⵓⵍ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷ ⵉⵜⵜⵡⴰⵙⴻⴽⴽⴻⵏ, ⵉⵜⵜⵡⴰⵃⵓⵣⴻⵏ ⵉ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ");
INSERT INTO rift_vpl VALUES ("RM1_2","075_1_2","ROM","1","2","2","- ⵍ’ⵉⵏⵊⵉⵍ ⵏⵏⵉ ⵉⵣⵣⴰⵔ ⵉⵡⴰⵄⴷ ⵣⵣⴰⵢⴻⵙ ⵣⴻⴳ ⵓⵎⴻⵡⴰⵔⵓ ⵙ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("RM1_3","075_1_3","ROM","1","3","3","ⵅ ⵎⵎⵉⵙ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴷⴰⵡⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("RM1_4","075_1_4","ROM","1","4","4","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM1_5","075_1_5","ROM","1","5","5","ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉ ⵏⴻⵟⵟⴻⴼ ⴰⵔⴹⴰ ⵓ ⵣⵣⴰⵢⴻⵙ ⵉ ⵏⴻⵜⵜⵡⴰⵍⴰⵖⴰ ⴷ ⵔⵔⵓⵙⵓⵍ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴰⵄⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵉ ⵍ’ⵉⵎⴰⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RM1_6","075_1_6","ROM","1","6","6","ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM1_7","075_1_7","ROM","1","7","7","ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵔⵓⵎⴰ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷ ⵉⵏⵏⵉ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ: ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM1_8","075_1_8","ROM","1","8","8","ⴰⵎⴻⵣⵡⴰⵔ ⵜⵜⵛⴻⴽⴽⴰⵔⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵡⴻⵎ ⵎⴰⵔⵔⴰ, ⵎⵉⵏⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴰⵇⴰ ⵙⵍⵉⵏ ⵅⴰⵙ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RM1_9","075_1_9","ROM","1","9","9","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵄⴻⴱⴱⴷⴻⵖ ⴷⵉ ⴰⵔⵔⵓⵃ ⴷⵉ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⵎⵎⵉⵙ, ⵉⵛⵀⴻⴷ ⵅⴰⴼⵉ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⵉⴷⴰⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴱⴷⴰ ⴷⵉ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RM1_10","075_1_10","ROM","1","10","10","ⵜⵜⵥⴰⴵⵉⵖ ⴰⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵡⴰⵔⵣⴻⵎ ⵣⵉ ⵍⴻⵅⵅⵓ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵙ ⴰⵔⵔⴰⵢ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM1_11","075_1_11","ROM","1","11","11","ⵎⵉⵏⵣⵉ ⵡⴻⵃⵃⵛⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ ⵓ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵛⴰ ⵏ ⵜⵎⴻⵡⵛⴰ ⵏ ⴰⵔⵔⵓⵃ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⴻⵜⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM1_12","075_1_12","ROM","1","12","12","ⴰⴷ ⵏⴻⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⴻⵊ ⵊⵎⵉⵄ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RM1_13","075_1_13","ROM","1","13","13","ⵎⴰⵛⴰ ⵅⵙⴻⵖ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵓⵔⴻⵏ ⴳⴳⵉⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ, ⵎⴰⵛⴰ ⴰⵍ ⴰⵙⵙ-ⴰ ⵜⵜⵡⴰⵎⴻⵏⵄⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵍⵖⵉⴵⴻⵜ ⴷⴰⵢⵡⴻⵎ ⵄⴰⵡⴻⴷ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("RM1_14","075_1_14","ROM","1","14","14","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍ’ⵉⵏⵊⵉⵍ ⵉ ⵉⵢⵓⵏⴰⵏⵉⵢⵢⴻⵏ ⵓ ⵉ ⵉⴱⴰⵔⴱⴰⵔⵉⵢⵢⴻⵏ, ⵉ ⴰⵢⵜ ⵏ ⵜⵉⵖⵉⵜ ⵓ ⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_15","075_1_15","ROM","1","15","15","ⴰⵎⵎⵓ ⵉ ⵜⵜⵡⴰⵊⴻⴱⴷⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵓⵍⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⵔⵓⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("RM1_16","075_1_16","ROM","1","16","16","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵛⴰ ⵙ ⵍ’ⵉⵏⵊⵉⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵢⵓⵎⵏⴻⵏ, ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵣⴻⴳ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_17","075_1_17","ROM","1","17","17","ⵎⵉⵏⵣⵉ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵜⴱⴰⵏ ⴷⴰⵢⴻⵙ ⴷⵉ ⵍ’ⵉⵏⵊⵉⵍ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵖⴰⵔ ⵍ’ⵉⵎⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: ‘ⴰⵎⵙⴻⴳⴳⴰⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⴰⴷ ⵉⴷⴷⴰⵔ.’ ");
INSERT INTO rift_vpl VALUES ("RM1_18","075_1_18","ROM","1","18","18","ⵎⵉⵏⵣⵉ ⴰⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴱⴰⵏ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ ⵜⵉⴷⴻⵜⵜ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("RM1_19","075_1_19","ROM","1","19","19","ⵎⵉⵏⵣⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴱⴰⵏ ⴷⴰⵢⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵙⴻⵏ ⵜ-ⵉ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("RM1_20","075_1_20","ROM","1","20","20","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵥⴰⵔ ⵙ ⵍⴻⵄⵇⴻⵍ ⵙ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⵎ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵏ ⵍⴻⴱⴷⴰ, ⴰⵎ ⵜⵉⴼⵔⴰⵙ ⵏⵏⴻⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵍⴰⵎⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵙⵎⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM1_21","075_1_21","ROM","1","21","21","ⵎⵉⵏⵣⵉ, ⵓⵎⵉ ⵙⵙⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜ ⵙⵙⵄⵓⴵⴻⵏ ⵏⵉⵖ ⵡⴰⵔ ⵜ ⵛⴻⴽⴽⴰⵔⴻⵏ ⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴷⴻⵡⵍⴻⵏ ⴱⴻⵟⵟⵍⴻⵏ ⴷⴻⴳ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵓⵍ ⵏⵙⴻⵏ ⵉⴱⴰⵔⵛⴻⵏ, ⴰⵍⴰⵎⵉ ⵉⴷⵡⴻⵍ ⴱⵍⴰ ⵄⴻⵇⵍ. ");
INSERT INTO rift_vpl VALUES ("RM1_22","075_1_22","ROM","1","22","22","ⵓⵎⵉ ⵃⴻⵙⵙⴱⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴼⵖⴰⵍ, ");
INSERT INTO rift_vpl VALUES ("RM1_23","075_1_23","ROM","1","23","23","ⴱⴻⴷⴷⵍⴻⵏ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⵙ ⵛⴰ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵚⵚⵉⴼⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⴼⴻⵏⵏⴰⵏ, ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵉⵊⴹⴰⴹ, ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⴹⴰⵔⴻⵏ ⵓ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.    ");
INSERT INTO rift_vpl VALUES ("RM1_24","075_1_24","ROM","1","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵏⵏⴻⵛⵡⴰⵜ ⵉⵅⴻⵎⵊⴻⵏ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴼⴻⴹⵃⴻⵏ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵙⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_25","075_1_25","ROM","1","25","25","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⵍⴻⵏ ⵜⵉⴷⴻⵜⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵓⵅⴰⵔⵔⵉⵇ, ⵄⴻⴱⴷⴻⵏ ⵓ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔ ⵉⴵⴰ ⵎⴰⵔⵔⴰ ⴰⵙⴻⵎⵖⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_26","075_1_26","ROM","1","26","26","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵛⵛⴻⵀⵡⴰⵜ ⵉⵏⴼⴻⴹⵃⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴱⴻⴷⴷⵍⴻⵏⵜ ⴰⴱⵔⵉⴷ ⵏ ⵟⵟⴱⵉⵄⴻⵜ, ⵜⵜⵏⵓⵎⴰⵏⵜ ⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⵟⵟⴱⵉⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM1_27","075_1_27","ROM","1","27","27","ⴰⵎⴻⵏⵏⵉ ⵉⵔⵢⴰⵣⴻⵏ ⵄⴰⵡⴻⴷ ⵊⵊⵉⵏ ⵜⴰⵎⵓⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵟⵟⴱⵉⵄⴻⵜ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⴷⴻⵄⵇⴻⵏ ⵙ ⵏⵏⴻⵛⵡⴰⵜ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ: ⵉⵔⵢⴰⵣⴻⵏ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴰⴽ-ⴷ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵓⵛⴰ ⵇⴻⴱⴱⵍⴻⵏ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵍⵎⵓⵏⴻⵜ ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵉ ⵓⵡⴻⴷⴷⴰⵔ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_28","075_1_28","ROM","1","28","28","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⴽⴽⵙⴻⵏ ⴰⵡⴰⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵍⴻⵄⵇⴻⵍ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵄⴻⴷⴷⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_29","075_1_29","ROM","1","29","29","ⵏⵉⵜⵏⵉ ⵄⴻⵎⵎⴰⵔⴻⵏ ⵙ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵜⴰⵔⵣⵓⴳⵉ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷ ⵟⵟⵎⴻⵄ, ⵙ ⵍⴻⵃⵙⴻⴷ ⴷ ⵡⴻⵏⵖⴰⵢ ⴷ ⵓⵎⴻⵏⵖⵉ ⴷ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⴷ ⵉⵏⵡⴰⵢⴻⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM1_30","075_1_30","ROM","1","30","30","ⵏⵉⵜⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵍⵖⴰⵔ, ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ, ⵛⴰⵔⵔⵀⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⴻⵖⵚⴰⴱⴻⵏ ⴷ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵓⵇⴻⵎⵎⵓⵎ ⴷ ⵉⵎⴻⵙⵓⴼⴼⵖⴻⵏ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵍⵄⵇⴻⵍ, ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵟⵟⵉⵄⴻⵏ ⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM1_31","075_1_31","ROM","1","31","31","ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵓⵍ ⵉⵎⵜⴻⵏ, ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⴰⵢⵔⵉ ⴷ ⵡⴻⵚⵍⴰⵃ ⵓⵍⴰ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM1_32","075_1_32","ROM","1","32","32","ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ ⵍⵃⵓⴽⵎ ⵏ ⴰⵔⴻⴱⴱⵉ - ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵢⴰ ⵙⴷⴰⵀⴻⴵⴻⵏ ⵍⵎⴻⵡⵜ - ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⵟⵟⴰⵏ ⵄⴰⵡⴻⴷ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("RM2_1","075_2_1","ROM","2","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵛⴻⴽ ⴱⵍⴰ ⵙⵎⴰⵃⴻⵜ, ⴰ ⴱⵏⴰⴷⴻⵎ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵢⵓⴷⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵎⵉⵏ ⵜⵃⴻⴽⴽⵎⴻⴷ ⵅ ⵓⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵃⴰⵙⴰⴱⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵍⴻⵙⵇⴻⵏⵜ ⵖⴰⵔⴻⴽ ⵓⵍⴰ ⴷ ⵙⵉⵎⴰⵏⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM2_2","075_2_2","ROM","2","2","2","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵃⵓⴽⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⵅ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵎ ⵜⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RM2_3","075_2_3","ROM","2","3","3","ⵎⴰⵛⴰ ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵛ ⵉⵜⵜⵖⵉⵍ, ⴰ ⴱⵏⴰⴷⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵎ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵜⴻⵏⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⴰⵔⴻⵡⵍⴻⴷ ⵣⵉ ⵍⵃⵓⴽⵎ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("RM2_4","075_2_4","ROM","2","4","4","ⵏⵉⵖ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴰⴷ ⴰⴳⵍⴰ ⵏ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵙ ⴷ ⵜⵜⴰⵙⵉⵄ ⵏ ⵓⵔⴰⵊⵉ ⵏⵏⴻⵙ ⴷ ⵜⵜⴰⵙⵉⵄ ⵉ ⴷ ⴰⵛ ⵉⵡⵛⵉⵏ, ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⴱⴻⵍⵍⵉ ⵜⵛⵓⵏⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵏⴻⴷⴷⴻⵀ ⵉ ⵛⴻⴽ ⵖⴰⵔ ⵜⵜⵓⴱⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("RM2_5","075_2_5","ROM","2","5","5","ⵎⴰⵛⴰ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⴷ ⵏⵏⵓⵇⵚⴰⵏ ⵏ ⵜⵜⵓⴱⴻⵜ ⵏ ⵡⵓⵍ ⵏⵏⴻⵛ, ⵜⵢⴰⵔⵡⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵉⵊⵊ ⵏ ⵍⴻⵇⴷⴰⵔ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉ ⵡⴰⵙⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵓ ⵉ ⵓⵙⴰⵔⴳⴻⴱ ⵏ ⵍⵃⵓⴽⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RM2_6","075_2_6","ROM","2","6","6","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⴻⴵⵚⴻⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("RM2_7","075_2_7","ROM","2","7","7","... ⵉ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⴰⵎ ⵜⵜⵚⴻⴱⴱⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⵇⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵅⴻⴵⴻⵚ ⵙ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("RM2_8","075_2_8","ROM","2","8","8","... ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵡⵡⵖⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵏⵓⵎⴻⵏ ⵜⵜᵉⵟⵟⴰⵄⴻⵏ ⵉ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵜⵜⵏⵓⵎⴻⵏ ⵜⵜᵉⵟⵟⴰⵄⴻⵏ ⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵇⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵅⴻⴵⴻⵚ ⵙ ⵡⴻⵖⴹⴰⴱ ⴷ ⵜⴻⴼⵇⴻⵃⵜ, ");
INSERT INTO rift_vpl VALUES ("RM2_9","075_2_9","ROM","2","9","9","... ⵓ ⵙ ⵍⵎⴻⵃⵏⴻⵜ ⴷ ⵍⴻⵃⵙⴰⵔⴻⵜ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ, ⵓⴷⴰⵢⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔ, ⵅⴻⵏⵏⵉ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM2_10","075_2_10","ROM","2","10","10","... ⵎⴰⵛⴰ ⴰⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵛⵓⵏⵉ, ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM2_11","075_2_11","ROM","2","11","11","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM2_12","075_2_12","ROM","2","12","12","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰ ⵉⵅⴹⴰⵏ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴰⴷ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰ ⵉⵅⴹⴰⵏ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⴰⴷ ⵜⵜⵡⴰⵃⴰⵙⴱⴻⵏ ");
INSERT INTO rift_vpl VALUES ("RM2_13","075_2_13","ROM","2","13","13","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵉⴵⵉ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM2_14","075_2_14","ROM","2","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⴱⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵟⵟⴱⵉⵄⴻⵜ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵢⵉⵏⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵛⵛⴰⵔⵉⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("RM2_15","075_2_15","ROM","2","15","15","ⵓⵛⴰ ⵙⵙⵛⴰⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵜⵓⵔⴰ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⴰⵎ ⵜⴻⵛⵀⴻⴷ ⵄⴰⵡⴻⴷ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ, ⴰⵎ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ ⴷⴻⴵⴻⵏ ⵓⵍⴰ ⵜⵜⴷⴰⴼⴰⵄⴻⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵊⴰⵔ ⴰⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("RM2_16","075_2_16","ROM","2","16","16","ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵉ ⵖⴰ ⵉⵃⴰⵙⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵉⵡⴷⴰⵏ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵄⵍⴰⵃⵙⴰⴱ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RM2_17","075_2_17","ROM","2","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴻⴽ, ⵓⵎⵉ ⵍⴰⵖⴰⵏ ⵓⴷⴰⵢ, ⵜⵙⴻⵏⵏⴰⴷⴻⴷ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵓ ⵜⴻⵙⵙⴻⵎⵖⴰⵔⴻⴷ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RM2_18","075_2_18","ROM","2","18","18","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⵜⴼⴰⵔⵔⵣⴻⴷ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⴷ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("RM2_19","075_2_19","ROM","2","19","19","ⵓ ⵜⵃⴰⵙⴱⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⴰⵎⴳⴻⵡⵡⴻⴷ ⵏ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷ ⵜⴼⴰⵡⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ");
INSERT INTO rift_vpl VALUES ("RM2_20","075_2_20","ROM","2","20","20","ⴷ ⴰⵎⵙⴻⴳⴳⴻⵎ ⵢⴰⵔⴻⴱⴱⴰⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⴷ ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵓ ⴰⵇⴰ ⵖⴰⵔⴻⴽ ⵚⵚⵉⴼⴻⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("RM2_21","075_2_21","ROM","2","21","21","ⵉⵡⴰ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵍⵎⵉⴷⴻⴷ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ? ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ‘ⵡⴰⵔ ⵜⵜⵉⵛⴰⵔ!’, ⵎⴰ ⵜᵉⵜⵜⴰⵛⴰⵔⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("RM2_22","075_2_22","ROM","2","22","22","ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ‘ⵡⴰⵔ ⵣⴻⵏⵏⵉ!’, ⵎⴰ ⵜⵣⴻⵏⵏⵉⴷ? ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵎⴰ ⵜⴰⵛⴰⵔⴻⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵙⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("RM2_23","075_2_23","ROM","2","23","23","ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰ ⵜⴼⴻⴹⵃⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵓⵎⵉ ⵜⴻⵅⴹⵉⴷ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ? ");
INSERT INTO rift_vpl VALUES ("RM2_24","075_2_24","ROM","2","24","24","ⵎⵉⵏⵣⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵡⴻⵎ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RM2_25","075_2_25","ROM","2","25","25","ⴰⵇⴰ ⴰⵅⵜⴰⵏ ⵉⵏⴻⴼⴼⴻⵄ ⵎⴰⵍⴰ ⵜⴹⴻⴼⴼⴰⵔⴻⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵉⵛⴰⵏ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜᵉⵜⵜⵄⴻⴷⴷⵉⴷ ⵅ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⴰⵅⵜⴰⵏ ⵏⵏⴻⵛ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴱⵍⴰ ⴰⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM2_26","075_2_26","ROM","2","26","26","ⵎⴰⵍⴰ ⵡⴻⵏⵏⵉ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⵉⵜⵜᵉⵟⵟⴻⴼ ⴷⵉ ⵍⵓⵎⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴻⵙⵙⴻⴱ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⵏⵏⴻⵙ ⴷ ⴰⵅⵜⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("RM2_27","075_2_27","ROM","2","27","27","ⵡⴻⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⵟⵟⴱⵉⵄⴻⵜ ⴰⵎ ⵉⴵⴰ ⴱⵍⴰ ⴰⵅⵜⴰⵏ, ⴰⴷ ⵛⴻⴽ ⵉⵃⴰⵙⴻⴱ, ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴻⴷⴷⴰⵏ ⵅ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⵜⵉⵔⴰ ⴷ ⵡⴻⵅⵜⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("RM2_28","075_2_28","ROM","2","28","28","ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵓⴷⴰⵢ ⵙ ⵡⵓⴷⴻⵎ, ⵓ ⴰⵅⵜⴰⵏ ⵙ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("RM2_29","075_2_29","ROM","2","29","29","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⵓⴷⴰⵢ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵍⵉⵏ ⴷ ⵓⴷⴰⵢ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⵓ ⴰⵅⵜⴰⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷⴻⴳ ⵡⵓⵍ, ⵙ ⴰⵔⵔⵓⵃ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⵔⴰ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵍⴰⵎⵉ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⴰ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵎⴰⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM3_1","075_3_1","ROM","3","1","1","ⵉ ⵅⴻⵏⵏⵉ, ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵖⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ, ⵏⵉⵖ ⵎⴰⵏ ⵜⵉⵣⵉ ⵏ ⵡⴻⵅⵜⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("RM3_2","075_3_2","ROM","3","2","2","ⴰⵟⵟⴰⵙ ⵅ ⴽⵓⵍ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ! ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵎⵎⴻⵡⵛⴻⵏ ⴰⵙⴻⵏ ‬ⵡⴰⵡⴰⵍⴻⵏ ⵏ‮ ‬ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM3_3","075_3_3","ROM","3","3","3","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⵛⴰ, ⵎⴰ ⵅⴻⵏⵏⵉ ⴱⴻⴹⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵍⴰⵎⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("RM3_4","075_3_4","ROM","3","4","4","ⵄⴻⵎⵎⴰⵔⵚ! ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵛⴻⴽ ⴰⴷ ⵜⴱⴰⵏⴻⴷ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵍⵉⴷ ⵜⴽⴻⵎⵎⵍⴻⴷ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵅⵎⵉ ⵛⴻⴽ ⵉ ⵖⴰ ⵃⴰⵙⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM3_5","075_3_5","ROM","3","5","5","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⵙⴻⴳⴳⴷⴻⵏ ⴷⴰⵢⵏⴻⵖ ⴰⵇⴰ ⵉⵙⵙⴱⴻⵢⵢⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵄⴰⴷ ⵅⴻⵏⵏⵉ? ⵎⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵍⵃⴻⵇⵇ ⵓⵎⵉ ⵅⴰⵏⴻⵖ ⵉⴳⴳⴰ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ? ⵏⴻⵛⵛ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷ ⴰⵎⴻⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("RM3_6","075_3_6","ROM","3","6","6","ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⵙⵙⵉⵡⵉⵍ! ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵃⴰⵙⴻⴱ ⴰⵔⴻⴱⴱⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵍⴻⵅⴷⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("RM3_7","075_3_7","ROM","3","7","7","ⵎⴰⵎⵎⴻⵛ ⵎⴰⵍⴰ ⵜⴼⴻⵢⵢⴻⴹ ⵜⵉⴷⴻⵜⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵙ ⵓⵅⴰⵔⵔⵉⵇ ⵉⵏⵓ, ⵎⴰⵢⴻⵎⵎⵉ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⵜⵡⴰⵃⴰⵙⴱⴻⵖ ⴰⵎ ⵓⵎⴻⴷⵏⵓⴱ? ");
INSERT INTO rift_vpl VALUES ("RM3_8","075_3_8","ROM","3","8","8","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⵇⴰ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜⴻⴵⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵇⵇⴰⵔⴻⵏ ⵉⵏⵏⵉ ⴷⴰⵢⵏⴻⵖ ⵉⵛⴻⵇⵇⴼⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵇⵇⴰⵔ: “ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴳⴳ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵢⴻⴽⴽ ⵎⵉⵏ ⵉⵛⵏⴰⵏ!”?, ⵉⵏⵏⵉ ⴰⵇⴰ ⵍⵃⵓⴽⵎ ⵅⴰⵙⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⵎⵎⴻⵍ ⴰⵍ ⵛⵛⵔⴻⵄ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM3_9","075_3_9","ROM","3","9","9","ⵉ ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ? ⵎⴰ ⵏⴻⵛⵛⵉⵏ ⵃⵙⴻⵏ? ⵇⴱⴻⵍ ⴰⵇⴰ ⵏⵓⴼⴰ ⴰⵇⴰ ⵓⴷⴰⵢⴻⵏ ⴷ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⴷⴷⴻⵏⴱ, ");
INSERT INTO rift_vpl VALUES ("RM3_10","075_3_10","ROM","3","10","10","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("RM3_11","075_3_11","ROM","3","11","11","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⴼⴻⵀⵀⴻⵎ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⵅ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM3_12","075_3_12","ROM","3","12","12","ⵎⴰⵔⵔⴰ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵎⵎⴻⵏⴹⴰⵔⴻⵏ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵜⵛⵓⵏⵉ, ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("RM3_13","075_3_13","ROM","3","13","13","ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⵏⵙⴻⵏ ⴷ ⵉⵎⴻⴹⵍⴰⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵛⴻⵎⵎⵜⴻⵏ, ⵙⵙⴻⵎ ⵏ ⵉⴼⵉⵖⵔⴰⵏ ⵙⴰⴷⵓ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM3_14","075_3_14","ROM","3","14","14","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵉⵛⵛⵓⵔ ⵙ ⵏⵏⴻⵄⵍⴻⵜ ⴷ ⵜⴰⵔⵣⵓⴳⵉ, ");
INSERT INTO rift_vpl VALUES ("RM3_15","075_3_15","ROM","3","15","15","ⵙ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵇⴻⴵⵉⵇⴻⵏ ⵖⴰⵔ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM3_16","075_3_16","ROM","3","16","16","ⴰⵔⴻⵢⵢⴻⴱ ⴷ ⵜⴰⵎⴰⵔⴰ ⴷⴻⴳ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM3_17","075_3_17","ROM","3","17","17","ⴰⴱⵔⵉⴷ ⵏ ⵍⴻⵀⵏⴰ ⵡⴰⵔ ⵜ ⵙⵙⵉⵏⴻⵏ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("RM3_18","075_3_18","ROM","3","18","18","ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM3_19","075_3_19","ROM","3","19","19","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵜⴻⵇⵇⴰⵔ ⵉ-ⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵇⵇⴻⵏ ⴽⵓⵍ ⴰⵇⴻⵎⵎⵓⵎ ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ ⴷⴰⵢⴻⵙ ⵍⵄⵉⴱ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RM3_20","075_3_20","ROM","3","20","20","ⵎⴰⵖⴰⵔ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("RM3_21","075_3_21","ROM","3","21","21","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵜⴻⴹⵀⴰⵔ-ⴷⴷ ⵜⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⵜⵛⴻⵀⵀⴻⴷ ⵅⴰⵙ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM3_22","075_3_22","ROM","3","22","22","ⴰⵇⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵢⵓⵎⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵍⴼⴰⵔⵣ. ");
INSERT INTO rift_vpl VALUES ("RM3_23","075_3_23","ROM","3","23","23","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵅⴹⴰⵏ ⵓⵛⴰ ⵉⵏⴻⵇⵚ ⵉ-ⵜⴻⵏ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RM3_24","075_3_24","ROM","3","24","24","ⵓⵛⴰ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ ⴱⴰⵟⴻⵍ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵙ ⵓⴼⴻⴽⴽⵉ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM3_25","075_3_25","ROM","3","25","25","ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵚⵍⴰⵃ ⵇⴱⴻⵍ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵏⵏⵉ ⵜⵓⵖⴰ ⵏⴻⴳⴳⴰ ⵣⵉⵛ ⴷⵉ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ");
INSERT INTO rift_vpl VALUES ("RM3_26","075_3_26","ROM","3","26","26","ⵎⴰⵃⴻⵏⴷ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⴰⴷ ⵢⴰⵔⵔ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ ⵡⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM3_27","075_3_27","ROM","3","27","27","ⵎⴰⵏⵉ ⵉⴵⴰ ⵅⴻⵏⵏⵉ ⵓⵙⴻⵎⵖⴰⵔ? ⵡⴰⵔ ⵅⴰⵙ ⵏⴻⵙⵙⵉⵡⵉⵍ. ⵙ ⵎⴰⵏ ⵛⵛⴰⵔⵉⵄⴰ? ⵙ ⵎⴰⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ? ⵄⴻⵎⵎⴰⵔⵚ, ⵎⴰⵛⴰ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM3_28","075_3_28","ROM","3","28","28","ⵙ ⵓⵢⴰ ⵏⴻⵃⵙⴻⴱ ⴱⴻⵍⵍⵉ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍ’ⵉⵎⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("RM3_29","075_3_29","ROM","3","29","29","ⵏⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵏ ⵍⴻⴳⵏⵓⵙ ⵄⴰⵡⴻⴷ? ⵡⴰⵀ, ⵓⵍⴰ ⵏ ⵍⴻⴳⵏⵓⵙ! ");
INSERT INTO rift_vpl VALUES ("RM3_30","075_3_30","ROM","3","30","30","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵙ ⵍ’ⵉⵎⴰⵏ, ⵓ ⵄⴰⵡⴻⴷ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⵜⵉⵏⴻⵏ ⵙ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM3_31","075_3_31","ROM","3","31","31","ⵎⴰ ⵏⴱⴻⵟⵟⴻⵍ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⵍ’ⵉⵎⴰⵏ? ⵡⴰⵢⵢⴰⵡ, ⵙ ⵍⴻⵎⵇⵍⵓⴱ, ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⴹⵎⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("RM4_1","075_4_1","ROM","4","1","1","ⵎⵉⵏ ⵉ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ ⵅ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵢⵓⴼⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵏ ⵡⴻⵢⵙⵓⵎ? ");
INSERT INTO rift_vpl VALUES ("RM4_2","075_4_2","ROM","4","2","2","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵛⵛⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM4_3","075_4_3","ROM","4","3","3","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ? “ⵢⵓⵎⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵙⴻⴳⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("RM4_4","075_4_4","ROM","4","4","4","ⵡⴻⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⵜᵉⵜⵜⵡⴰⵃⴻⵙⵙⴻⴱ ⵛⴰ ⵍⵎⵓⵏⴻⵜ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⴰⵔⴹⴰ, ⵎⴰⵛⴰ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⵓⵎⴰⵔⵡⴰⵙ, ⵎⵉⵏⵣⵉ ⵜⵜⵓⵔⵙⴻⵏ ⴰⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("RM4_5","075_4_5","ROM","4","5","5","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵅⴻⴷⴷⵎⴻⵏ, ⵎⴰⵛⴰ ⵢⵓⵎⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⴳⴳⴰⴷⴻⵏ ⵉⵎⴻⴷⵏⴰⴱ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⵜⴰⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM4_6","075_4_6","ROM","4","6","6","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⴷⴰⵡⵓⴷ ⵄⴰⵡⴻⴷ ⵅ ⵙⵙⴻⵄⴷ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ ⴰⵙ ⵉⵃⵙⴻⴱ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵙⴻⴳⴷⴰ ⴱⵍⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⵓⵎⵉ ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("RM4_7","075_4_7","ROM","4","7","7","“ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵖⴼⴰⵔ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵙⵙⴷⵓⵔⵉⵢ ⵏⴻⵜⵜⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM4_8","075_4_8","ROM","4","8","8","ⵙⵙⴻⵄⴷ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵎⵉ ⵡⴰⵔ ⴷⴷ ⴰⵙ ⵉⵃⴻⵙⵙⴻⴱ ⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RM4_9","075_4_9","ROM","4","9","9","ⵎⴰ ⵙⵙⴻⵄⴷ-ⴰ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵡⴰⵀⴰ ⵏⵉⵖ ⵄⴰⵡⴻⴷ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ? ⵙ ⵎⵉⵏⵣⵉ ⵏⴻⵇⵇⴰⵔ: “ⵍ’ⵉⵎⴰⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⴷⴷ ⴷ ⵜⴰⵙⴻⴳⴷⴰ!” ");
INSERT INTO rift_vpl VALUES ("RM4_10","075_4_10","ROM","4","10","10","ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵜ-ⵉ-ⴷⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ? ⵎⴰ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵙ ⵡⴻⵅⵜⴰⵏ ⵏⵉⵖ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴱⵍⴰ ⴰⵅⵜⴰⵏ? ⵡⴰⵔ ⵜⵓⵖⵉ ⵙ ⵡⴻⵅⵜⴰⵏ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴱⵍⴰ ⴰⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM4_11","075_4_11","ROM","4","11","11","ⵎⵉⵏⵣⵉ ⵉⴽⵙⵉ ⴰⵅⵜⴰⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷ ⵓⵛⴻⵎⵎⵉⵄ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵏⵉ ⵖⴰⵔⴻⵙ ⵓⵎⵉ ⵜ ⵜⵓⵖⴰ ⴱⵍⴰ ⴰⵅⵜⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵊⴻⴷⴷⵉⵜⵙⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⴱⵍⴰ ⴰⵅⵜⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM4_12","075_4_12","ROM","4","12","12","ⵏⴻⵜⵜⴰ ⴷ ⵊⴻⴷⴷⵉⵜⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵙ ⵡⴻⵅⵜⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵢⵓⵎⵏⴻⵏ ⵣⴻⴳ ⵡⴻⵅⵜⴰⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⴻⴳ ⵉⵚⵓⵔⴰⴼ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵎⵉ ⵜⵓⵖⴰ ⴱⵍⴰ ⴰⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM4_13","075_4_13","ROM","4","13","13","ⵎⵉⵏⵣⵉ ⵍⵡⴰⵄⴷ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵓ ⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵡⵔⵉⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⴰ ⵙ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM4_14","075_4_14","ROM","4","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵏⵏⵉ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵉⵡⵔⵉⵜⴻⵏ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵉⵅⴻⵙⵙⴰⵔⴻⵏ ⵓⵍⴰ ⴷ ⵍⵡⴰⵄⴷ ⵉⴱⴻⴹⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM4_15","075_4_15","ROM","4","15","15","ⵎⴰⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵜᵉⵜⵜⴰⵔⵓ ⴰⵖⴹⴰⴱ. ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵓⵍⴰ ⴷ ⴰⵄⴻⴷⴷⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("RM4_16","075_4_16","ROM","4","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍ’ⵉⵎⴰⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵙ ⴰⵔⴹⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵍⵡⴰⵄⴷ ⵏⵉⵛⴰⵏ ⵉ ⵇⴰⵄ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵡⴻⵏⵏⵉ ⴷ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ ⵏ ⵎⴰⵔⵔⴰ ⵉⴷⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("RM4_17","075_4_17","ROM","4","17","17","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵇⴰ ⴳⴳⵉⵖ ⵛⴻⴽ ⴷ ⵊⴻⴷⴷⵉⵜⵙⴻⵏ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ!”, ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵣⵉ ⵜⵓⵖⴰ ⵜⵓⵎⵏⴻⴷ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴰⵅⵎⵉ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM4_18","075_4_18","ROM","4","18","18","ⵡⴰⵅⵅⴰ ⵉⵇⴹⴻⵄ ⴰⵙ ⵍⴰⵢⴰⵙ, ⴰⵇⴰ ⵢⵓⵎⴻⵏ ⵙ ⵓⵙⵉⵜⴻⵎ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵊⴻⴷⴷⵉⵜⵙⴻⵏ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("RM4_19","075_4_19","ROM","4","19","19","ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⴹⵄⴻⴼ, ⵓⵎⵉ ⵉⵃⵙⴻⴱ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵎⵎⵓⵜ ⴰⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵎⵢⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵓ ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵙⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RM4_20","075_4_20","ROM","4","20","20","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵛⴻⴽⴽ ⵛⴰ ⴷⵉ ⵍⵡⴰⵄⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵅⵎⵉ ⵙ ⵏⵏⴻⵇⵚ ⵏ ⵍ’ⵉⵎⴰⵏ, ⵎⴰⵛⴰ ⵉⵎⵃⴻⴹ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ, ⵉⵡⵛⴰ ⴰⵄⵓⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM4_21","075_4_21","ROM","4","21","21","ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⵏⵉⵛⴰⵏ ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵖⴰ ⵉⵡⴰⵄⴷ ⴰⵔⴻⴱⴱⵉ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⴳⴳ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM4_22","075_4_22","ROM","4","22","22","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⴷⴷ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM4_23","075_4_23","ROM","4","23","23","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⵔⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⴷⴷ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ ⴷ ⵜⴰⵙⴻⴳⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("RM4_24","075_4_24","ROM","4","24","24","ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵜ-ⵉ-ⴷⴷ-ⵉⵃⵙⴻⴱ ⴷ ⵜⴰⵙⴻⴳⴷⴰ, ⵉ ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM4_25","075_4_25","ROM","4","25","25","ⵢⴻⵛⵛⵓ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⴻⵍⵍⵎⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵓⵛⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⴻⴳⴳⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM5_1","075_5_1","ROM","5","1","1","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ, ⴰⵎ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍ’ⵉⵎⴰⵏ, ⴰⵇⴰ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM5_2","075_5_2","ROM","5","2","2","ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⴷⵡⴻⵍ ⴰⵏⴻⵖ-ⴷⴷ ⴰⴷⴰⴼ ⵙ ⵍ’ⵉⵎⴰⵏ ⵖⴰⵔ ⴰⵔⴹⴰ-ⵢⴰ ⵎⵉⵏ ⴷⵉ ⵏⴱⴻⴷⴷ, ⵓ ⵏⴻⵙⵙⴻⵎⵖⴰⵔ ⴷⴻⴳ ⵓⵙⵉⵜⴻⵎ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM5_3","075_5_3","ROM","5","3","3","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵏⴻⵙⵙⴻⵎⵖⴰⵔ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⴻⵎⵃⴰⵢⴻⵎ, ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵜᵉⵜⵜⴰⵔⵓ-ⴷⴷ ⴷⴰⵢⵏⴻⵖ ⵚⵚⴱⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("RM5_4","075_5_4","ROM","5","4","4","ⴷ ⵚⵚⴱⴰⵔ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵇⴻⴵⴻⴱⵜ, ⵓⵛⴰ ⵜⴰⵇⴻⴵⴻⴱⵜ ⴰⴷ ⵜⴰⵡⵉ ⴰⵙⵉⵜⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("RM5_5","075_5_5","ROM","5","5","5","ⵓⵛⴰ ⴰⵙⵉⵜⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵙⴻⵃⵛⵉⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵎⵎⴻⵡⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM5_6","075_5_6","ROM","5","6","6","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⴹⵄⴻⴼⵜ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵉⵎⵎⵓⵜ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM5_7","075_5_7","ROM","5","7","7","ⵙ ⵍⵡⴻⵃⵍⴰⵏ ⴰⴷ ⵉⵎⵎⴻⵜ ⵃⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵊⵊ ⵏ ⵓⵄⴻⴼⴼⴰⵏ, ⵎⴰⵛⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵚⴻⴱⵃⴰⵏⴻⵏ ⴰⴷ ⵜⴰⵖ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵣⵄⴻⵎ ⵃⴻⴷ ⴰⴷ ⵉⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM5_8","075_5_8","ROM","5","8","8","ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵍⴰ ⴰⵏⴻⵖ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵉⵎⵎⵓⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵄⴰⴷ ⴷ ⵉⵎⴻⴷⵏⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("RM5_9","075_5_9","ROM","5","9","9","ⵎⴻⵛⵃⴰⵍ ⴽⵜⴰⵔ ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵍⴻⵅⵅⵓ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵣⴰⵢⴻⵙ ⵣⴻⴳ ⵡⴻⵖⴹⴰⴱ! ");
INSERT INTO rift_vpl VALUES ("RM5_10","075_5_10","ROM","5","10","10","ⵎⵉⵏⵣⵉ ⵍⴰⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⵓⵖⴰ ⴷ ⵍⵄⴻⴷⵢⴰⵏ, ⵉⵊⵊⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴽⵉⴷⵏⴻⵖ ⵙ ⵍⵎⴻⵡⵜ ⵏ ⵎⵎⵉⵙ, ⵎⴻⵛⵃⴰⵍ ⵇⴰⵄ ⵍⴻⵅⵅⵓ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵙ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵣⵣⴰⵢⴻⵙ ⵏⵓⴼⴰ ⴰⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("RM5_11","075_5_11","ROM","5","11","11","ⵓ ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵖⴰⵔ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵏⴻⴽⵙⵉ ⵍⴻⵅⵅⵓ ⴰⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("RM5_12","075_5_12","ROM","5","12","12","ⵎⴰⵖⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙ ⵢⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵢⵓⴷⴻⴼ-ⴷⴷ ⴷⴷⴻⵏⴱ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⵙ ⴷⴷⴻⵏⴱ ⵜⵓⴷⴻⴼ-ⴷⴷ ⵍⵎⴻⵡⵜ, ⴰⵎⵎⵓ ⴷⴷ-ⵜⵓⴷⴻⴼ ⵍⵎⴻⵡⵜ ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ, ⵎⵉⵏⵣⵉ ⵅⴹⴰⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RM5_13","075_5_13","ROM","5","13","13","ⵎⵉⵏⵣⵉ ⵇⴱⴻⵍ ⵎⴰ ⵜⵓⵖⴰ ⵜⴻⴵⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⵜⵓⵖⴰ ⴷⴷⴻⵏⴱ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⴷⴷⴻⵏⴱ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵃⵙⵉⴱ ⵛⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵜⴻⴵⵉ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("RM5_14","075_5_14","ROM","5","14","14","ⵎⴰⵛⴰ ⵍⵎⴻⵡⵜ ⵜⵓⵖⴰ ⵜⴻⵃⴽⴻⵎ ⵣⵉ ⴰⴷⴰⵎ ⴰⵍ ⵎⵓⵙⴰ ⵓⵍⴰ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵅⴹⵉⵏ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵓⵅⴻⵟⵟⵓ ⵉ ⵣⵉ ⵉⵅⴹⴰ ⴰⴷⴰⵎ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ. ⴰⴷⴰⵎ ⵡⴻⵏⵏⵉ ⴷ ⵚⵚⵉⴼⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM5_15","075_5_15","ROM","5","15","15","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵙ ⵓⵡⴻⵟⵟⵓ, ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⵙ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴹⴰ. ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵎⵎⵓⵜⴻⵏ ⴰⵟⵟⴰⵙ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⵓⵅⴻⵟⵟⵓ, ⵎⴻⵛⵃⴰⵍ ⵇⴰⵄ ⵉ ⵖⴰ ⵉⴼⴻⵢⵢⴻⴹ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⵡⴰⵟⵟⴰⵙ ⵙ ⵓⵢⴻⵏⵏⵉ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM5_16","075_5_16","ROM","5","16","16","ⵜⴰⵡⵀⵉⴱⵜ ⵙ ⴰⵔⴹⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⴰⵎ ⵓⵅⴻⵟⵟⵓ ⵏ ⵢⵉⵊⵊⴻⵏ. ⵙ ⵎⵉⵏⵣⵉ ⵍⵃⵓⴽⵎ ⵢⵉⵡⵉ-ⴷⴷ ⵍⵃⵉⵙⴰⴱ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵅⴻⵟⵟⵓ, ⵎⴰⵛⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴹⴰ ⵜⵉⵡⵉ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⴷⴷⵏⵓⴱ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM5_17","075_5_17","ROM","5","17","17","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵙ ⵓⵅⴻⵟⵟⵓ ⵏ ⵉⵊⵊⴻⵏ ⴰⵇⴰ ⵜⴻⵃⴽⴻⵎ ⵍⵎⴻⵡⵜ, ⵎⴻⵛⵃⴰⵍ ⵇⴰⵄ ⵉ ⵖⴰ ⵃⴻⴽⵎⴻⵏ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⴰⴼⴻⵢⵢⴻⴹ ⵏ ⴰⵔⴹⴰ ⴷ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵙ ⵓⵢⴻⵏⵏⵉ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM5_18","075_5_18","ROM","5","18","18","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ ⵙ ⵓⵅⴻⵟⵟⵓ ⵏ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⵍⵃⵓⴽⵎ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏ ⵢⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM5_19","075_5_19","ROM","5","19","19","ⵎⵉⵏⵣⵉ ⴰⵎ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⴻⵡⵍⴻⵏ ⴰⵟⵟⴰⵙ ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵙ ⵟⵟⴰⵄⴻⵜ ⵏ ⵉⵊⵊⴻⵏ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴰⵟⵟⴰⵙ ⴷ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM5_20","075_5_20","ROM","5","20","20","ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵎⵎⴰⵔⵏⵉ ⴷⴷⴻⵏⴱ, ⵓ ⵎⴰⵏⵉ ⵉⵎⵎⴰⵔⵏⵉ ⴷⴷⴻⵏⴱ, ⵉⵎⵎⴰⵔⵏⵉ ⴰⵔⴹⴰ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("RM5_21","075_5_21","ROM","5","21","21","ⵃⵉⵎⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵃⴽⴻⵎ ⴷⴷⴻⵏⴱ ⴰⵍ ⵍⵎⴻⵡⵜ, ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵔⴹⴰ ⵄⴰⵡⴻⴷ ⵙ ⵜⵙⴻⴳⴷⴰ ⴰⵍ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM6_1","075_6_1","ROM","6","1","1","ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ? ⵎⴰ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⴷⵉ ⴷⴷⴻⵏⴱ ⵃⵉⵎⴰ ⴰⴷ ⵉⵎⵎⴰⵔⵏⵉ ⴰⵔⴹⴰ? ");
INSERT INTO rift_vpl VALUES ("RM6_2","075_6_2","ROM","6","2","2","ⵄⴻⵎⵎⴰⵔⵚ! ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵉ ⴷⴷⴻⵏⴱ, ⵎⴰⵎⵎⴻⵛ ⵄⴰⴷ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⵏⴻⴷⴷⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("RM6_3","075_6_3","ROM","6","3","3","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵣⵣⴰⵢⵏⴻⵖ ⵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⴷⵉ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("RM6_4","075_6_4","ROM","6","4","4","ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵏⴹⴻⵍ ⴰⴽⵉⴷⴻⵙ ⵙ ⵓⵙⴻⵖⴹⴻⵚ ⴷⵉ ⵍⵎⴻⵡⵜ, ⵃⵉⵎⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏ ⴱⴰⴱⴰⵙ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⵓⵢⵓⵔ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("RM6_5","075_6_5","ROM","6","5","5","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⴻⵜⵜⵡⴰⵥⵥⵓ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵙ ⵜⴻⴼⵔⴰⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⵉⵍⵉ ⵄⴰⵡⴻⴷ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵙ ⵜⴻⴼⵔⴰⵙ ⵏ ⵜⵏⵓⴽⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM6_6","075_6_6","ROM","6","6","6","ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖ ⴰⵇⴷⵉⵎ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ ⴰⴽⵉⴷⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴱⴹⴻⵍ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵡⴰⵔ ⵏⴷⵉⴽⴽⵡⵉⵍ ⵄⴰⵡⴻⴷ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("RM6_7","075_6_7","ROM","6","7","7","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("RM6_8","075_6_8","ROM","6","8","8","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵎⵎⵓⵜ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵏⵓⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⴻⵙ, ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM6_9","075_6_9","ROM","6","9","9","ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵎⴰⵙⵉⵃ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉ ⵄⴰⵡⴻⴷ. ⴰⵇⴰ ⵍⵎⴻⵡⵜ ⵡⴰⵔ ⵅⴰⵙ ⵜⵃⴻⴽⴽⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("RM6_10","075_6_10","ROM","6","10","10","ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵎⴻⵡⵜ ⵉ ⵉⵎⵎⵓⵜ, ⴰⵇⴰ ⵉⵎⵎⵓⵜ ⵉ ⴷⴷⵏⵓⴱ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ, ⵎⴰⵛⴰ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⵉⴷⴷⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM6_11","075_6_11","ROM","6","11","11","ⴰⵎⵎⵓ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ: ⵃⴻⵙⴱⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵉ ⴷⴷⴻⵏⴱ, ⵎⴰⵛⴰ ⴷ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM6_12","075_6_12","ROM","6","12","12","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴷⴷⴻⵏⴱ ⴰⴷ ⵉⵃⴽⴻⵎ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵉⴼⴻⵏⵏⴰⵏ, ⴰⵍⴰⵎⵉ ⴰⴷ ⴰⵙ ⵜᵉⵟⵟⴰⵄⴻⵎ ⴷⵉ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RM6_13","075_6_13","ROM","6","13","13","ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴻⵡⵛⵉⵎ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⴰⵎ ⴷⴷⵓⵣⴰⵏ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵎⴰⵛⴰ ⵡⵛⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵣⴻⴳ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵓⵛⴰ ⵡⵛⴻⵎ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⴰⵎ ⴷⴷⵓⵣⴰⵏ ⵉ ⵜⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM6_14","075_6_14","ROM","6","14","14","ⴷⴷⴻⵏⴱ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵃⴻⴽⴽⴻⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ ⵎⴰⵛⴰ ⵙⴰⴷⵓ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("RM6_15","075_6_15","ROM","6","15","15","ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ? ⵎⴰ ⴰⴷ ⵏⴻⵅⴹⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⴻⴵⵉ ⵛⴰ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵙⴰⴷⵓ ⴰⵔⴹⴰ? ⵄⴻⵎⵎⴰⵔⵚ! ");
INSERT INTO rift_vpl VALUES ("RM6_16","075_6_16","ROM","6","16","16","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵡⵛⵉⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵙ ⵟⵟⴰⵄⴻⵜ, ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜᵉⵜⵜᵉⵟⵟⴰⵄⴻⵎ, ⵎⴰ ⵉ ⴷⴷⴻⵏⴱ ⵉ ⵜᵉⵜⵜᵉⵟⵟⴰⵄⴻⵎ ⵏⵉⵖ ⵉ ⵜⵙⴻⴳⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("RM6_17","075_6_17","ROM","6","17","17","ⵜⵇⴰⴷ ⴰⵙ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴷⴷⴻⵏⴱ, ⴰⵇⴰ ⵜⴷⴻⵡⵍⴻⵎ ⵜᵉⵜⵜᵉⵟⵟⴰⵄⴻⵎ ⵙ ⵡⵓⵍ ⵉ ⴷⴷⴰⴱ ⵉⵚⴼⴰⵏ ⵏ ⵓⵙⴻⵍⵎⴻⴷ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⴻⵍⵍⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM6_18","075_6_18","ROM","6","18","18","ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵎ ⵣⵉ ⴷⴷⴻⵏⴱ, ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM6_19","075_6_19","ROM","6","19","19","ⵙⵙⴰⵡⴰⵍⴻⵖ ⵅ ⵍⴻⵃⵙⴰⴱ ⵍⴻⵄⵇⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⴹⵄⴻⴼⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵡⵛⵉⵎ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵍⴻⵅⵎⴻⵊ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⵎⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵡⵛⴻⵎ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵜⵙⴻⴳⴷⴰ ⴷ ⵜⵇⴻⴷⴷⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("RM6_20","075_6_20","ROM","6","20","20","ⵎⵉⵏⵣⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴷⴷⴻⵏⴱ, ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵃⵓⵔⵔⵉⵢⵢⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM6_21","075_6_21","ROM","6","21","21","ⵎⴰⵏ ⵍⵖⵉⴵⴻⵜ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵡⴻⵎ ⵍⴻⵅⴷⴻⵏⵏⵉ? ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵣⵉ ⵜᵉⵜⵜⵙⴻⴹⵃⴰⵎ ⵍⴻⵅⵅⵓ? ⵙ ⵎⵉⵏⵣⵉ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵙⴻⵏⵜ ⴷ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RM6_22","075_6_22","ROM","6","22","22","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽⴻⵎ ⵣⵉ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵡⴻⵎ ⵜᵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵓⵛⴰ ⵓⵏⴻⴳⴳⴰⵔ ⵏⵏⴻⵙ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM6_23","075_6_23","ROM","6","23","23","ⵎⵉⵏⵣⵉ ⵍⴻⵅⵍⴰⵚ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM7_1","075_7_1","ROM","7","1","1","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵜⵚⴻⴵⴻⴹ ⵅ ⴱⵏⴰⴷⴻⵎ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵉⴷⴷⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("RM7_2","075_7_2","ROM","7","2","2","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵇⵇⴻⵏ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵉⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM7_3","075_7_3","ROM","7","3","3","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⴷ ⵜⴻⵇⵇⴻⵏ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵡⴻⵔⵢⴰⵣ ⵉⴷⴷⴰⵔ, ⵜᵉⵜⵜⵡⴰⵃⵙⴻⴱ ⵣⵣⴰⵢⴻⵙ ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵣⵏⴰ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⵓⵜ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴰⴼ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⵣⵏⵉ ⵎⴰⵍⴰ ⵜⴻⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RM7_4","075_7_4","ROM","7","4","4","ⵅⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴰⵇⴰ ⵜⴻⵎⵎⵓⵜⴻⵎ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM7_5","075_7_5","ROM","7","5","5","ⵎⵉⵏⵣⵉ ⵓⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵜⵓⵖⴰ ⵛⵛⴻⵀⵡⴰⵜ ⵏ ⴷⴷⵏⵓⴱ ⵅⴻⴷⴷⵎⴻⵏⵜ ⴷⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ ⴰⵎ ⵜⵜⵡⴰⵄⴰⵔⵏⴻⵏⵜ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵍⴰⵎⵉ ⵖⴰ ⴰⵡⵢⴻⵏⵜ ⵍⵖⵉⴵⴻⵜ ⵉ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RM7_6","075_7_6","ROM","7","6","6","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵏⴻⵎⵎⵓⵜ ⵅ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⵡⴰⵃⴱⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵄⴱⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⴻⵊⴷⵉⴷⴻⵜ ⵏ ⴰⵔⵔⵓⵃ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵜⴰⵇⴷⵉⵎⵜ ⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("RM7_7","075_7_7","ROM","7","7","7","ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ? ⵎⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⴷⴷⴻⵏⴱ? ⵄⴻⵎⵎⴰⵔⵚ! ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⴷⴷⴻⵏⴱ ⵎⵖⵉⵔ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵏⵏⴻⵛⵡⴻⵜ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵏⵏⵉ ⵛⵛⴰⵔⵉⵄⴰ: “ⵡⴰⵔ ⵜⵜⴰⵙⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("RM7_8","075_7_8","ROM","7","8","8","ⵎⴰⵛⴰ ⴷⴷⴻⵏⴱ ⵢⵓⴼⴰ ⵍⴼⵓⵔⵚⴰ ⵙ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵓⵛⴰ ⵜⴻⴳⵎⴰ ⴷⴰⵢⵉ ⴽⵓⵍ ⵏⵏⴻⵛⵡⴻⵜ, ⵎⵉⵏⵣⵉ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷⴷⴻⵏⴱ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("RM7_9","075_7_9","ROM","7","9","9","ⵣⵉⵛ ⵜⵓⵖⴰ ⴷⴷⴰⵔⴻⵖ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ, ⵉⴱⴷⴰ ⴷⴷⴻⵏⴱ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵓⵛⴰ ⵎⵎⵓⵜⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM7_10","075_7_10","ROM","7","10","10","ⵓⴼⵉⵖ ⴱⴻⵍⵍⵉ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉ ⵉⴵⴰⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵜⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RM7_11","075_7_11","ROM","7","11","11","ⵎⵉⵏⵣⵉ ⴷⴷⴻⵏⴱ ⴰⵎ ⵢⵓⴼⴰ ⵍⴼⵓⵔⵚⴰ ⵙ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ, ⵉⵛⵎⴻⵜ ⴰⵢⵉ ⵓⵛⴰ ⵉⵏⵖⴰ ⴰⵢⵉ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM7_12","075_7_12","ROM","7","12","12","ⵅⴻⵏⵏⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵜⴻⴵⴰ ⵓ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵜⴻⴵⴰ, ⵜⵙⴻⴳⴳⴻⴷ ⵓ ⵜⴻⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("RM7_13","075_7_13","ROM","7","13","13","ⵎⴰ ⵉⴷⵡⴻⵍ ⴰⵢⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⴷ ⵍⵎⴻⵡⵜ ⵉⵏⵓ? ⵄⴻⵎⵎⴰⵔⵚ! ⵎⴰⵛⴰ ⴷⴷⴻⵏⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵏ ⴷ ⴷⴷⴻⵏⴱ, ⵉⵙⵙⴻⴳⵎⴰ ⴷⴰⵢⵉ ⵍⵎⴻⵡⵜ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷⴷⴻⵏⴱ ⴷ ⴷⴷⴻⵏⴱ ⴽⵜⴰⵔ ⵙ ⵜⴻⵡⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM7_14","075_7_14","ROM","7","14","14","ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⵔⵓⵃ ⵉ ⵜⴻⴵⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴷ ⴰⵢⵙⵓⵎ, ⵎⵎⴻⵏⵣⴻⵖ ⵉ ⴷⴷⴻⵏⴱ, ");
INSERT INTO rift_vpl VALUES ("RM7_15","075_7_15","ROM","7","15","15","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵖ, ⵓⵛⴰ ⵎⵉⵏ ⵅⵙⴻⵖ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵖ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵛⴰⵔⵔⵀⴻⵖ ⴷ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ ⵉ ⵜⵜⴻⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM7_16","075_7_16","ROM","7","16","16","ⵎⴰⵍⴰ ⵜⵜⴻⴳⴳⴻⵖ ⵎⵉⵏ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ, ⴰⴷ ⵡⴰⴼⵇⴻⵖ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("RM7_17","075_7_17","ROM","7","17","17","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⴷ, ⵎⴰⵛⴰ ⴷⴷⴻⵏⴱ ⵉ ⴷ ⴰⵢⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("RM7_18","075_7_18","ROM","7","18","18","ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⵡⴰⵔ ⴷⴰⵢⵉ ⵉⵣⴻⴷⴷⴻⵖ ⵎⵉⵏ ⵉⵛⵏⴰⵏ, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵉⵏⵓ. ⵎⵉⵏⵣⵉ ⵉⵀⵡⴻⵏ ⵅⴰⴼⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⵙⴻⵖ ⵜⵛⵓⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜⵜ ⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM7_19","075_7_19","ROM","7","19","19","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵖ ⵜⵛⵓⵏⵉ ⵉ ⵅⵙⴻⵖ, ⵎⴰⵛⴰ ⵍⵖⴰⵔ ⵉ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ ⵛⴰ, ⴷ ⵎⴰⵏⴰⵡⴻⵏⵏⵉ ⵉ ⵜⵜⴻⴳⴳⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM7_20","075_7_20","ROM","7","20","20","ⵎⴰⵍⴰ ⵜⵜⴻⴳⴳⴻⵖ ⵎⵉⵏ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴷ ⵏⴻⵛⵛ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⴷⴷⴻⵏⴱ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM7_21","075_7_21","ROM","7","21","21","ⵅⴻⵏⵏⵉ ⵜⵜⴰⴼⴻⵖ ⵉⵛⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⴰⴽ-ⴷ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵉⵏⵓ, ⵜⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⴳⴳ ⵜⵛⵓⵏⵉ, ⴰⵎ ⵢⵓⴷⴻⵙ ⴰⵢⵉ-ⴷⴷ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM7_22","075_7_22","ROM","7","22","22","ⵎⵉⵏⵣⵉ ⴼⴰⵔⵃⴻⵖ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⴰⵅⴻⵍ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("RM7_23","075_7_23","ROM","7","23","23","ⵎⴰⵛⴰ ⵜⵜⵡⴰⵍⵉⵖ ⴷⵉⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ, ⵜᵉⵜⵜⵎⴻⵏⵖⴰ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵍⴻⵄⵇⴻⵍ ⵉⵏⵓ ⵓⵛⴰ ⵜⵃⴻⴱⴱⴻⵙ ⴰⵢⵉ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴷⴷⴻⵏⴱ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RM7_24","075_7_24","ROM","7","24","24","ⴰⵢⴻⵃⵃⴰⵜ ⵎⴰⵏⴰ ⵡⴻⵎⵛⵓⵎ-ⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉ ⴵⵉⵖ! ⵡⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ-ⴰ ⵏ ⵍⵎⴻⵡⵜ? ");
INSERT INTO rift_vpl VALUES ("RM7_25","075_7_25","ROM","7","25","25","ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵏⵊⵎⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ! ⴰⵎⵎⵓ ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵙ ⵍⴻⵄⵇⴻⵍ ⵉ ⵅⴻⴷⴷⵎⴻⵖ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵉⵏⵓ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("RM8_1","075_8_1","ROM","8","1","1","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⴱⵓ ⵍⵃⵓⴽⵎ ⵅ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM8_2","075_8_2","ROM","8","2","2","ⵎⵉⵏⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵜⴼⴻⴽⴽ ⴰⵛ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴷⴷⴻⵏⴱ ⴷ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RM8_3","075_8_3","ROM","8","3","3","ⵎⵉⵏⵣⵉ ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⴹⵄⴻⴼ ⵙ ⵜⵓⴹⵄⴻⴼⵜ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵔⴻⴱⴱⵉ ⵎⵎⵉⵙ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⴷⴷⴻⵏⴱ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⴻⵏⴱ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴰⵙⴻⴱ ⴷⴷⴻⵏⴱ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("RM8_4","075_8_4","ROM","8","4","4","ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏⴻⴳⴳⵓⵔ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵎⴰⵛⴰ ⴷⵉ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("RM8_5","075_8_5","ROM","8","5","5","ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵏ ⴰⵔⵔⵓⵃ ⵜⵜⴻⴳⴳⴻⵏ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("RM8_6","075_8_6","ROM","8","6","6","ⵎⵉⵏⵣⵉ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⴷ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⴰⵔⵔⵓⵃ ⴷ ⵜⵓⴷⴰⵔⵜ ⴷ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RM8_7","075_8_7","ROM","8","7","7","ⵎⵉⵏⵣⵉ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⵄⴷⴰⵡⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳ ⵛⴰ ⴰⵔⵔⴰⵢ ⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵣⴻⵎⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM8_8","075_8_8","ROM","8","8","8","ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵔⴹⴰⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM8_9","075_8_9","ROM","8","9","9","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵎⴰⵛⴰ ⴷⵉ ⴰⵔⵔⵓⵃ ⵎⴰⵍⴰ ⵉⵣⴷⴻⵖ ⴷⴰⵢⵡⴻⵎ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵃⴻⴷ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⴰⵔⵔⵓⵃ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM8_10","075_8_10","ROM","8","10","10","ⵎⴰⵍⴰ ⴷⴰⵢⵡⴻⵎ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵜⴻⵎⵎⵓⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵉⴷⴷⴰⵔ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM8_11","075_8_11","ROM","8","11","11","ⵎⴰⵍⴰ ⵉⵣⴷⴻⵖ ⴷⴰⵢⵡⴻⵎ ⴰⵔⵔⵓⵃ ⵏ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⴷ ⵉⵙⵙⴻⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵡⴻⵎ ⵉⴼⴻⵏⵏⴰⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM8_12","075_8_12","ROM","8","12","12","ⵅⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⴰⵏⴻⵖ ⵙ ⵓⵎⴰⵔⵡⴰⵙ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵡⴻⵢⵙⵓⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⵡⴻⵢⵙⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("RM8_13","075_8_13","ROM","8","13","13","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⵡⴻⵢⵙⵓⵎ, ⴰⴷ ⵜⴻⵎⵜⴻⵎ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜᵉⵜⵜⴰⵔⵔⵉⵎ ⴰⴷ ⵎⵎⵜⴻⵏⵜ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵙ ⴰⵔⵔⵓⵃ, ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM8_14","075_8_14","ROM","8","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵉⵜⵏⵉ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM8_15","075_8_15","ROM","8","15","15","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴽⵙⵉⵎ ⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵜⴻⵙⵎⵓⵖⵉ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵄⴰⵡⴻⴷ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵜⴻⴽⵙⵉⵎ ⴰⵔⵔⵓⵃ ⵉ ⵣⵉ ⵏⴻⵜⵜⵡⴰⵇⴱⴻⵍ ⴷ ⴰⵔⵔⴰⵡⴻⵏ, ⵉ ⵣⵉ ⵏⴻⵜⵜⵍⴰⵖⴰ: ‘ⵜⴰⴱⴰⴱⴰⵜ, ⴱⴰⴱⴰⵜⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("RM8_16","075_8_16","ROM","8","16","16","ⴰⵔⵔⵓⵃ ⵏⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵛⴻⵀⵀⴻⴷ ⴰⴽ-ⴷ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵖ, ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM8_17","075_8_17","ROM","8","17","17","ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵔⵔⴰⵡⴻⵏ, ⴰⵇⴰ ⴰⵏⴻⵖ ⵄⴰⵡⴻⴷ ⴷ ⵉⵡⵔⵉⵜⴻⵏ, ⵉⵡⵔⵉⵜⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵏⵡⴻⴷⴷⴻⴱ ⴰⴽⵉⴷⴻⵙ, ⴰⴷ ⵏⴻⵜⵜⵡⴰⵄⵓⴵⵉ ⴰⴽⵉⴷⴻⵙ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM8_18","075_8_18","ROM","8","18","18","ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵖ ⴱⴻⵍⵍⵉ ⴰⵡⴻⴷⴷⴻⴱ ⵉ ⵅⴰⵏⴻⵖ ⵉⵜⵜⴻⴽⴽⴻⵏ ⵉⴹⴰ, ⵡⴰⵔ ⵉⵙⴷⵉⵀⴻⴵ ⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴱⴰⵔ ⵙ ⵓⵄⵓⴵⵉ ⵉ ⴷⴷ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔⴻⵏ ⴷⴰⵢⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM8_19","075_8_19","ROM","8","19","19","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵉⵅⴻⵣⵣⴰⵔ ⵙ ⵓⵙⵉⵜⴻⵎ ⴷ ⵓⵔⴰⵊⵉ ⵖⴰⵔ ⵓⵙⴰⵔⴳⴻⴱ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM8_20","075_8_20","ROM","8","20","20","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⵇⴰ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵉ ⵍⴱⴰⵟⴻⵍ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵛⴰ ⵙ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ");
INSERT INTO rift_vpl VALUES ("RM8_21","075_8_21","ROM","8","21","21","ⵙ ⵓⵙⵉⵜⴻⵎ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴻⴽⴽ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⴻⵙⵎⵓⵖⵉ ⵉ ⵍⵖⴻⵛⵛ ⵖⴰⵔ ⵜⵉⵍⴻⵍⵍⵉ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵡⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM8_22","075_8_22","ROM","8","22","22","ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵉⵣⴻⵀⵀⴰⵔ ⵊⵎⵉⵄ ⵙ ⵓⵏⴻⵣⴱⴰⵔ ⵏ ⵜⴰⵔⵡⴰ ⴰⵍ ⴰⵙⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("RM8_23","075_8_23","ROM","8","23","23","ⵡⴰⵔ ⵉⴵⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⴷⴰⵢⵏⴻⵖ ⵍⵖⵉⴵⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⴰⵔⵔⵓⵃ, ⵏⵣⴻⵀⵀⴰⵔ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⵏⴻⵜⵜⵔⴰⵊⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵇⴱⴻⵍ ⴷ ⵎⵎⵉⵙ, ⵓⵍⴰ ⴷ ⴰⴼⴻⴽⴽⵉ ⵏ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM8_24","075_8_24","ROM","8","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⴷⴷⴰⵔ ⴷⴻⴳ ⵓⵙⵉⵜⴻⵎ ⵏⵏⵉ. ⵎⴰⵛⴰ ⴰⵙⵉⵜⴻⵎ ⵉⵜⵜⴱⴰⵏⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵙⵉⵜⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ ⵉ ⵃⴻⴷ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵙⵙⵉⵜⴻⵎ ⵄⴰⴷ? ");
INSERT INTO rift_vpl VALUES ("RM8_25","075_8_25","ROM","8","25","25","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵙⵙⵉⵜⵜⵉⵎ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵡⵉⵍⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⵔⴰⵊⴰ ⵜ ⵙ ⵚⵚⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM8_26","075_8_26","ROM","8","26","26","ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵄⴰⵡⴰⵏ ⴰⵏⴻⵖ ⴰⵔⵔⵓⵃ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⴹⵄⴻⴼⵜ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵛⴰ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵏⴻⵥⵥⴰⴵ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵥⴰⴵⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵙ ⵣⵣⵀⵉⵔ ⵡⴰⵔ ⵉⵏⴻⵟⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM8_27","075_8_27","ROM","8","27","27","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴻⵇⵇⵛⴻⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵉⵙⵙⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⴰⵔⵔⵓⵃ, ⴰⵇⴰ ⵉⵜⵜⵥⴰⴵⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM8_28","075_8_28","ROM","8","28","28","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵄⴰⵡⴻⵏ ⴷⵉ ⴽⵓⵍⵛⵉ ⵉ ⵍⵅⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⵉ ⵉⵄⴻⴵⴻⵎ ⵉ-ⵜⴻⵏ ⵇⴱⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⵍⴰⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM8_29","075_8_29","ROM","8","29","29","ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵉⵣⵡⴰⵔ ⵉⵙⵙⴻⵏ ⵉ-ⵜⴻⵏ, ⴰⵇⴰ ⵉⵣⵡⴰⵔ ⵉⵄⴻⴵⴻⵎ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵡⴻⵙⴻⵏ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵎⵎⵉⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵏⵣⵓ ⵊⴰⵔ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM8_30","075_8_30","ROM","8","30","30","ⵓⵛⴰ ⵉⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵉⵣⵣⴰⵔ ⵉⵄⴻⴵⴻⵎ ⵉ-ⵜⴻⵏ, ⴰⵇⴰ ⴷ ⵉⵏⵏⵉ ⵅ ⴷ ⵉⵍⴰⵖⴰ ⵄⴰⵡⴻⴷ, ⵓ ⵉⵏⵏⵉ ⵅ ⴷ ⵉⵍⴰⵖⴰ, ⴰⵇⴰ ⴷ ⵉⵏⵏⵉ ⵉⵙⴻⴳⴳⴻⴷ ⵄⴰⵡⴻⴷ, ⵓ ⵉⵏⵏⵉ ⵉⵙⴻⴳⴳⴻⴷ ⴰⵇⴰ ⴷ ⵉⵏⵏⵉ ⵉⵙⵙⵄⵓⴵⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM8_31","075_8_31","ROM","8","31","31","ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴽⵉⴷⵏⴻⵖ ⵡⵉ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⴹⴰⴷⴷⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("RM8_32","075_8_32","ROM","8","32","32","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵛⴻⵟⵟⴰⵔⴻⵏ ⵛⴰ ⵅ ⵎⵎⵉⵙ, ⵎⴰⵛⴰ ⵉⵡⵛⴰ ⵉ-ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵎⴰⵔⵔⴰ, ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛ ⴽⵓⵍⵛⵉ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵄⴰⵡⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("RM8_33","075_8_33","ROM","8","33","33","ⵡⵉ ⵖⴰ ⵉⴽⵙⵉⵏ ⵜⴰⵏⴼⵓⵍⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ? ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⴳⴳⴰⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM8_34","075_8_34","ROM","8","34","34","ⵡⵉ ⵖⴰ ⵉⵇⴹⴰⵏ ⵍⵃⵓⴽⵎ? ⵍⵎⴰⵙⵉⵃ ⵉⵎⵎⵓⵜ ⵓ ⵉⴽⴽⴰⵔ-ⴷⴷ ⵓ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵜⵜⵥⴰⴵⴰ ⵉ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM8_35","075_8_35","ROM","8","35","35","ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⴱⴹⴰⵏ ⵅ ⵜⴰⵢⵔⵉ ⵏ ⵍⵎⴰⵙⵉⵃ? ⵎⴰ ⵍⵎⴻⵃⵏⴻⵜ, ⵏⵉⵖ ⵍⵃⴻⴱⵙ, ⵏⵉⵖ ⴰⴷⴰⵔⵔⴻⵛ, ⵏⵉⵖ ⵍⴰⵥ, ⵏⵉⵖ ⵜⵓⵄⴰⵔⵢⴻⵏⵜ, ⵏⵉⵖ ⵍⵅⴰⵟⴰⵔ, ⵏⵉⵖ ⵙⵙⵉⴼ? ");
INSERT INTO rift_vpl VALUES ("RM8_36","075_8_36","ROM","8","36","36","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵇⴰ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵛ ⵏⴻⵜⵜⵎⴻⵜⵜⴰ ⴽⵓⵍ ⴰⵙⵙ, ⵏⴻⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵎ ⵉⵃⵓⵍⵉⵢⵢⴻⵏ ⵉ ⵜⵖⴰⵔⵚⵜ.” ");
INSERT INTO rift_vpl VALUES ("RM8_37","075_8_37","ROM","8","37","37","ⵎⴰⵛⴰ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵏⴻⴷⵡⴻⵍ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵖⴻⵍⵍⴰⴱⴻⵏ ⵙ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM8_38","075_8_38","ROM","8","38","38","ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵖ ⴱⴻⵍⵍⵉ ⵏⵉⵖ ⵍⵎⴻⵡⵜ, ⵏⵉⵖ ⵜⵓⴷⴰⵔⵜ, ⵏⵉⵖ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵏⵉⵖ ⵍⵃⵓⴽⴽⴰⵎ, ⵏⵉⵖ ⵚⵚⵓⵍⴰⵟⴰⵜ, ⵏⵉⵖ ⵎⵉⵏ ⵏ ⵢⵉⴹⴰ, ⵏⵉⵖ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM8_39","075_8_39","ROM","8","39","39","ⵏⵉⵖ ⵍⵓⵄⵍⴰ, ⵏⵉⵖ ⵔⴰⴵⴰⵖ, ⵏⵉⵖ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ, ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⴱⴹⴰ ⵅ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵏⵏⵉ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM9_1","075_9_1","ROM","9","1","1","ⵇⵇⴰⵔⴻⵖ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵖ ⵛⴰ, ⵓⵛⴰ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵉⵏⵓ ⵜⵛⴻⵀⵀⴻⴷ ⴷⴰⵢⵉ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM9_2","075_9_2","ROM","9","2","2","ⴱⴻⵍⵍⵉ ⵖⴰⵔⵉ ⴰⵛⴹⴰⵏ ⵉⵎⵖⴰⵔ ⴷ ⵍⴻⵃⵔⵉⵇ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RM9_3","075_9_3","ROM","9","3","3","ⵜⵓⵖⴰ ⵜⵜⵥⴰⴵⵉⵖ ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⵜⵜⵡⴰⵃⴰⵔⵔⵎⴻⵖ ⴷⵉ ⵎⵓⵎⵎⵓ ⵉⵏⵓ ⵅ ⵍⵎⴰⵙⵉⵃ ⵙ ⵉⵛⵜ ⵏⵏⴻⵄⵍⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵓ, ⵍⴰⴵ ⵉⵏⵓ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM9_4","075_9_4","ROM","9","4","4","ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⴱⵍⴻⵏ ⴷ ⵎⵎⵉⵙ. ⵖⴰⵔⵙⴻⵏ ⵉ ⵢⴻⴵⴰ ⵓⵄⵓⴵⵉ, ⵍⵄⵓⵀⵓⴷ, ⵛⵛⴰⵔⵉⵄⴰ, ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵖⴰⵔⴻⵙ ⴷⴷ-ⵉⵇⵇⵏⴻⵏ, ⵍⵡⵓⵄⵓⴷ ⴷ ⵍⴻⵊⴷⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("RM9_5","075_9_5","ROM","9","5","5","ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⴷⴷ-ⵉⴱⴰⵏ ⵍⵎⴰⵙⵉⵃ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴻⵏⵏⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⴰⵔⵔⴰ. ⵉ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⴰⵙⴻⵎⵖⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("RM9_6","075_9_6","ROM","9","6","6","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵍⴰⵎⵉ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵢⵉⵡⵉⴹ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵣⵉ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("RM9_7","075_9_7","ROM","9","7","7","ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ: “ⴷⵉ ⵉⵙⵃⴰⵇ ⴰⴷ ⴰⵛ ⵍⴰⵖⴰⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("RM9_8","075_9_8","ROM","9","8","8","ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⴰⵇⴰ ⵜⴰⵔⵡⴰ ⵄⵍⴰⵃⵚⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵍⵡⴰⵄⴷ ⴰⴷ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM9_9","075_9_9","ROM","9","9","9","ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ ⵏ ⵍⵡⴰⵄⴷ ⴷ ⵡⴰ: “ⵖⴰⵔ ⵍⵡⴻⵇⵜ-ⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵖⴰⵔ ⵙⴰⵔⴰ ⵎⵎⵉⵙ!” ");
INSERT INTO rift_vpl VALUES ("RM9_10","075_9_10","ROM","9","10","10","ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⵡⴰⵀⴰ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵙⴰⵔⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵔⵉⴼⵇⴰ, ⵓⵎⵉ ⵜⵎⵓⵏ ⴰⴽ-ⴷ ⵓⵢⴻⵏⵏⵉ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ, ⵊⴻⴷⴷⵉⵜⴻⵖ ⵉⵙⵃⴰⵇ, ");
INSERT INTO rift_vpl VALUES ("RM9_11","075_9_11","ROM","9","11","11","ⵜⵓⵖⴰ ⵜⵉⵣⵣⴰⵔ ⵜⴻⵜⵜⵡⴰⵙⵙⴻⵏ ⵍⵉⵅⴹⴰⵔⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵎⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵅⵍⵉⵇⴻⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵄⴰⴷ ⵍⵅⴰⵔ ⵏⵉⵖ ⵍⵖⴰⵔ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM9_12","075_9_12","ROM","9","12","12","ⵎⴰⵖⴰⵔ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵔⵉⴼⵇⴰ: “ⴰⵇⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⵉ ⵓⵎⴻⵥⵢⴰⵏ!”, ");
INSERT INTO rift_vpl VALUES ("RM9_13","075_9_13","ROM","9","13","13","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵢⴰⵄⵇⵓⴱ ⵉ ⵅⵙⴻⵖ, ⵎⴰⵛⴰ ⵛⴰⵔⵀⴻⵖ ⵉⵙⵓ.” ");
INSERT INTO rift_vpl VALUES ("RM9_14","075_9_14","ROM","9","14","14","ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ? ⵎⴰ ⵉⵇⴻⴷⴷ ⴰⴷ ⵢⵉⵍⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ? ⵄⴻⵎⵎⴰⵔⵚ! ");
INSERT INTO rift_vpl VALUES ("RM9_15","075_9_15","ROM","9","15","15","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⵉ ⵎⵓⵙⴰ: “ⴰⴷ ⴰⵔⴻⵃⵎⴻⵖ ⵡⵉ ⵅⵙⴻⵖ ⴰⴷ ⴰⵔⴻⵃⵎⴻⵖ, ⵓⵛⴰ ⴰⴷ ⵃⵉⵏⵏⴻⵖ ⵅ ⵡⵉ ⵅⵙⴻⵖ ⴰⴷ ⵃⵉⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("RM9_16","075_9_16","ROM","9","16","16","ⵅⴻⵏⵏⵉ ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵛⴰ ⵖⴰⵔ ⵡⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵍⴰ ⵖⴰⵔ ⵡⵉ ⵉⵜⵜⴰⵣⵣⵍⴻⵏ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⵃⵃⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM9_17","075_9_17","ROM","9","17","17","ⵎⵉⵏⵣⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⵉ ⴼⵉⵔⵄⵓⵏ: “ⴰⵇⴰ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵙⵙⵏⴻⴽⴽⴰⵔⴻⵖ-ⴷⴷ ⵛⴻⴽ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵙⵙⴻⵛⵏⴻⵖ ⵊⵊⴻⵀⴷ ⵉⵏⵓ, ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵉⵙⴻⵎ ⵉⵏⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("RM9_18","075_9_18","ROM","9","18","18","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵃⴻⵎ ⵡⵉ ⵉⵅⵙ, ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵇⵙⴻⵃ ⵡⵉ ⵉⵅⵙ. ");
INSERT INTO rift_vpl VALUES ("RM9_19","075_9_19","ROM","9","19","19","ⵉⵡⴰ, ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜⵉⵏⵉⴷ: ⵎⴰⵢⴻⵎⵎⵉ ⵉⵜⵜⵛⴻⵜⵛⴰ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⵡⵉ ⵖⴰ ⵉⵎⵎⵄⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ? ");
INSERT INTO rift_vpl VALUES ("RM9_20","075_9_20","ROM","9","20","20","ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ, ⴰ ⴱⵏⴰⴷⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵇⴰⵛⴰⵃⴻⵏ ⴰⵔⴻⴱⴱⵉ? ⵎⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ: “ⵎⴰⵢⴻⵎⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵎⵎⵓ?” ");
INSERT INTO rift_vpl VALUES ("RM9_21","075_9_21","ROM","9","21","21","ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⴱⵓ-ⵜⵍⴰⵅⵜ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⵍⴰⵅⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵍⵄⴻⵊⵏⴻⵜ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵉ ⵍⴽⴰⵔⴰⵎⴰ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉ ⵓⴱⴻⵀⴷⴻⵍ? ");
INSERT INTO rift_vpl VALUES ("RM9_22","075_9_22","ROM","9","22","22","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴰⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴷ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ⵉⵙⵙⵉⵡⴻⴹ ⵍⵖⴰⴹⴰⴱ ⵏⵏⴻⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵅ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⵎⴰⵔⵔⴰ ⵉ ⵓⵀⴻⵍⵍⴻⴽ, ");
INSERT INTO rift_vpl VALUES ("RM9_23","075_9_23","ROM","9","23","23","ⵓⵛⴰ ⵉⴼⴰⵔⵖ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ ⵅ ⵍⴻⵇⵛⵓⵄ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵉⵏⵏⵉ ⵉⵣⵡⴰⵔ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉ-ⵜⴻⵏ ⵉ ⵓⵄⵓⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("RM9_24","075_9_24","ROM","9","24","24","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵣⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RM9_25","075_9_25","ROM","9","25","25","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵃⵓⵛⵉⵄⴰ: “ⴰⴷ ⵙⴻⵎⵎⵉⵖ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ‘ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’, ⵓⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⴰⵎⵄⵉⵣⵣ ⴷ ‘ⴰⵎⵄⵉⵣⵣ!’” ");
INSERT INTO rift_vpl VALUES ("RM9_26","075_9_26","ROM","9","26","26","ⴰⴷ ⵢⵉⵍⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵎⴰⵏⵉ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ: ‘ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ!’, ⴱⴻⵍⵍⵉ ⴷⵉⵏⵏⵉ ⴰⴷ ⴰⵙⴻⵏ ⵍⴰⵖⴰⵏ: ‘ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ!’ ");
INSERT INTO rift_vpl VALUES ("RM9_27","075_9_27","ROM","9","27","27","ⵎⴰⵛⴰ ⵉⵛⴰⵄⵢⴰ ⵉⴱⴰⵔⵔⴻⵃ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: “ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⴰⵏⴻⵛⵜ ⵏ ⵉⵊⴷⵉ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵎⵖⵉⵔ ⵎⵉⵏ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵉⵏⵊⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("RM9_28","075_9_28","ROM","9","28","28","“ⵜⴰⵎⴻⵙⵍⴰⵛⵜ ⵜⴱⴻⴷⴷ ⵏⵉⵛⴰⵏ ⵓ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴼⴻⵍ, ⵙⵉⴷⵉ ⴰⴷ ⵜⵜ ⵉⴳⴳ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RM9_29","075_9_29","ROM","9","29","29","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵣⵡⴰⵔ ⵉⵛⴰⵄⵢⴰ ⵉⵏⵏⴰ: “ⵎⴰⵄⵍⵉⴽ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵊⵊⵉ ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⴷⴷⴰⵔⴻⵏ, ⵉⵍⵉ ⵏⴻⴷⵡⴻⵍ ⴰⵎ ⵙⴰⴷⵓⵎ ⵓ ⵏⴰⵔⵡⴻⵙ ⴷⵉ ⵄⴰⵎⵓⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("RM9_30","075_9_30","ROM","9","30","30","ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ? ⵎⴰ ⵅⴻⵏⵏⵉ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⴰⵇⴰ ⴽⵙⵉⵏ ⵜⴰⵙⴻⴳⴷⴰ? ⵉⵡⴰ, ⵎⴰⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵜⴻⵏⵏⵉ ⵙ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM9_31","075_9_31","ROM","9","31","31","ⵎⴰⵛⴰ ⵉⵙⵔⴰⵉⵍ ⵏⵏⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵡⴰⵔ ⵢⵉⵡⵉⴹ ⵛⴰ ⵖⴰⵔ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RM9_32","075_9_32","ROM","9","32","32","ⵎⴰⵢⴻⵎⵎⵉ? ⵎⵉⵏⵣⵉ ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵎⴰⵛⴰ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵏⴷⴻⵔⴼⴻⵏ ⴷⴻⴳ ⵡⴻⵥⵔⵓ ⵏ ⵓⵏⴻⴷⵔⴻⴼ, ");
INSERT INTO rift_vpl VALUES ("RM9_33","075_9_33","ROM","9","33","33","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵇⴰ ⴰⴷ ⴳⴳⴻⵖ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⴰⵥⵔⵓ ⵉ ⵓⵏⴻⴷⵔⴻⴼ ⴷ ⵡⴻⵥⵔⵓ ⵉ ⵓⵏⴻⵇⵔⴰⴷ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵙⴻⴹⵃⴰ.” ");
INSERT INTO rift_vpl VALUES ("RM10_1","075_10_1","ROM","10","1","1","ⴰ ⴰⵢⵜⵎⴰ, ⴰⵎⴻⵥⵔⵉ ⵏ ⵡⵓⵍ ⵉⵏⵓ ⵓ ⵜⴰⵥⴰⴵⵉⵜ ⵜⴻⵏⵏⵉ ⵥⵓⴵⴻⵖ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ-ⵜⵜ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RM10_2","075_10_2","ROM","10","2","2","ⴰⵇⴰ ⵛⴻⵀⵀⴷⴻⵖ ⵅⴰⵙⴻⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵛⴹⴰⵔⴻⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴱⵍⴰ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RM10_3","075_10_3","ROM","10","3","3","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵙⵙⵡⴰⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵜⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM10_4","075_10_4","ROM","10","4","4","ⵎⵉⵏⵣⵉ ⴰⴽⴻⵎⵎⴻⵍ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⵉ ⵜⵙⴻⴳⴷⴰ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM10_5","075_10_5","ROM","10","5","5","ⵎⵉⵏⵣⵉ ⵎⵓⵙⴰ ⵢⵓⵔⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ: “ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("RM10_6","075_10_6","ROM","10","6","6","ⵎⴰⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵜⴻⵏⵏⵉ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵜⴻⵇⵇⴰⵔ ⴰⵎⵎⵓ: “ⵡⴰⵔ ⵜⴻⵇⵇⴰⵔ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ: ‘ⵡⵉ ⵖⴰ ⵉⴳⴰⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⵀⵡⴰ ⵍⵎⴰⵙⵉⵃ?” ");
INSERT INTO rift_vpl VALUES ("RM10_7","075_10_7","ROM","10","7","7","ⵏⵉⵖ: “ⵡⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⴷⴻⴳ ⵡⴻⵃⴼⵓⵔ ⵏ ⵍⴰⵅⴰⵔⵜ, ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("RM10_8","075_10_8","ROM","10","8","8","ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵅⴻⵏⵏⵉ? “ⵜⴰⵎⵡⴰⵔⵔⵉⵜ ⵜⵓⴷⴻⵙ ⵉ ⵛⴻⴽ, ⴰⵇⴰ-ⵜ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵛ. ⵡⴰ ⴷ ⴰⵡⴰⵍ ⵏ ⵍ’ⵉⵎⴰⵏ ⵉ ⵣⵉ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ.” ");
INSERT INTO rift_vpl VALUES ("RM10_9","075_10_9","ROM","10","9","9","ⵎⴰⵍⴰ ⵜⵛⴻⵀⴷⴻⴷ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⵓⵛⴰ ⴰⴷ ⵜⴰⵎⵏⴻⴷ ⵙ ⵡⵓⵍ ⵏⵏⴻⵛ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵉ-ⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM10_10","075_10_10","ROM","10","10","10","ⵎⵉⵏⵣⵉ ⵓⵍ ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⴰⵎⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ, ⵓⵛⴰ ⴰⵇⴻⵎⵎⵓⵎ ⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵛⴻⵀⵀⴷⴻⵏ, ⴰⴷ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM10_11","075_10_11","ROM","10","11","11","ⵎⵉⵏⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⵇⴰⵔⴻⵏⵜ: “ⵎⴰⵔⵔⴰ ⵡⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵙⴻⴹⵃⵉ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("RM10_12","075_10_12","ROM","10","12","12","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⴱⵓ ⵍⴼⴰⵔⵣ ⵊⴰⵔ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊⴻⵏ, ⵙⵉⴷⵉ ⵏⵙⴻⵏ ⵎⴰⵔⵔⴰ ⵏⵏⵉ ⵉⵜⵜⴻⵏⴼⴻⵢⵢⴰⴹ ⵍⵅⴰⵔ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵅⴰⵙ ⴷⴷ-ⵉⵜⵜⵍⴰⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM10_13","075_10_13","ROM","10","13","13","“ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵍⴰⵖⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ, ⴰⴷ ⵉⴷⴷⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("RM10_14","075_10_14","ROM","10","14","14","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵍⴰⵖⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⴷⵉ ⵡⴰⵔ ⵓⵎⵉⵏⴻⵏ ⵛⴰ? ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴰⵎⵏⴻⵏ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⵎⵉⵅⴻⴼ ⵡⴰⵔ ⵙⵍⵉⵏ, ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵙⵍⴻⵏ, ⵎⴰⵍⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⴱⴰⵔⵔⴻⵃ ⵛⴰ? ");
INSERT INTO rift_vpl VALUES ("RM10_15","075_10_15","ROM","10","15","15","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴱⴰⵔⵔⵃⴻⵏ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ? ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵎⴻⵛⵃⴰⵍ ⴹⴰⵔⴼⴻⵏ ⵉⴹⴰⵔⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵍⴻⵀⵏⴰ, ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM10_16","075_10_16","ROM","10","16","16","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵔⵔⴰ ⵟⵟⴰⵄⴻⵏ ⵉ ⵓⴱⴰⵔⵔⴻⵃ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍ’ⵉⵏⵊⵉⵍ, ⵎⵉⵏⵣⵉ ⵉⵛⴰⵄⵢⴰ ⵉⵇⵇⴰⵔ: “ⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵡⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ ⴷⵉ ⵜⴻⴱⵔⴰⵜ ⵏⵏⴻⵖ?” ");
INSERT INTO rift_vpl VALUES ("RM10_17","075_10_17","ROM","10","17","17","ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵣⴻⴳ ⵓⵙⵃⴻⵙⵙⵉ ⵓⵛⴰ ⴰⵙⵃⴻⵙⵙⵉ ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM10_18","075_10_18","ROM","10","18","18","ⵎⴰⵛⴰ ⴰⴷ ⵉⵏⵉⵖ: “ⵎⴰ ⵣⴻⵄⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵍⵉⵏ?”, “ⵅⵣⴰⵔ, ⵍⵃⴻⵙⵙ ⵏⵙⴻⵏ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⵏⴻⴳⴳⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("RM10_19","075_10_19","ROM","10","19","19","ⵎⴰⵛⴰ ⴰⴷ ⵉⵏⵉⵖ: “ⵎⴰ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜⴻⴼⵀⵉⵎ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ?” ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵎⵓⵙⴰ ⵉⵏⵏⴰ: “ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⴳⴳⴻⵖ ⵜⵓⵙⵎⵉ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⴷ ⵍⴳⴻⵏⵙ, ⵓⵛⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵡⴰⵔ ⵉⵜⵜᵉⵟⵟⵉⵄⴻⵏ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⴳⴳⴻⵖ ⴰⵅⴻⵢⵢⴻⵇ.” ");
INSERT INTO rift_vpl VALUES ("RM10_20","075_10_20","ROM","10","20","20","ⵓⵛⴰ ⵉⵛⴰⵄⵢⴰ ⵉⵣⵄⴻⵎ ⴰⴷ ⵢⵉⵏⵉ: “ⴰⵇⴰ ⴱⴰⵏⴻⵖ-ⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ, ⴰⵇⴰ ⵓⴼⵉⵏ ⴰⵢⵉ ⵉⵏⵏⵉ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵙⵙⴻⵇⵙⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM10_21","075_10_21","ROM","10","21","21","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵉⵇⵇⴰⵔ: “ⴰⵙⵙ ⵉⴽⵎⴻⵍ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵉ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵜⵜⵄⴻⴽⴽⵙⴻⵏ, ⵉⵄⴻⵚⵚⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM11_1","075_11_1","ROM","11","1","1","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ: ⵎⴰ ⵢⵓⴳⵉ ⴰⵔⴻⴱⴱⵉ ⵅⴻⵏⵏⵉ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ? ⵄⴻⵎⵎⴰⵔⵚ! ⴰⵇⴰ ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵄⴰⵡⴻⴷ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵣⵉ ⵉⵙⵔⴰⵉⵍ, ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM11_2","075_11_2","ROM","11","2","2","ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵏⴻⵟⵟⴰⵔ ⵛⴰ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⵡⴻⴷⵍⵉⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵅ ⵉⵍⵉⵢⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴽⵙⵉ ⵜⴰⵏⴼⵓⵍⵜ ⵅ ⵉⵙⵔⴰⵉⵍ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⵏⴰ: ");
INSERT INTO rift_vpl VALUES ("RM11_3","075_11_3","ROM","11","3","3","“ⴰ ⵙⵉⴷⵉ, ⵏⵖⵉⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵛ, ⴰⵔⴻⴷⴷⴵⴻⵏ ⵉⵄⴰⵍⵟⴰⵔⴻⵏ ⵏⵏⴻⵛ. ⵇⵇⵉⵎⴻⵖ ⵏⴻⵛⵛ ⵡⴰⵀⴰ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("RM11_4","075_11_4","ROM","11","4","4","ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵙ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵡⵃⵉⵢ: “ⴰⵇⴰ ⵊⵊⵉⵖ ⵉ ⵢⵉⵅⴻⴼ ⵉⵏⵓ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⴹⵔⵉⵏ ⵛⴰ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵣⵣⴰⵜ ⵉ ⴱⴰⵄⴰⵍ, ⵡⴰⵔ ⵄⴻⴱⴷⴻⵏ ⵉ ⴱⴰⵄⴰⵍ.” ");
INSERT INTO rift_vpl VALUES ("RM11_5","075_11_5","ROM","11","5","5","ⴰⵎⵎⵓ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵢⵉⴹⴰ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵉⵇⵇⵉⵎ ⵢⵉⵊⵊ ⵏ ⵍⴱⴰⵇⵉ ⴰⵎ ⵜ ⵉⵅⴹⴰⵔ ⵏⴻⵜⵜⴰ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("RM11_6","075_11_6","ROM","11","6","6","ⵎⴰⵍⴰ ⵜⴻⴵⴰ ⵙ ⴰⵔⴹⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⵏⵉⵖ ⵅⴻⵏⵏⵉ ⴰⵔⴹⴰ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴷ ⴰⵔⴹⴰ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⵡⴰⵔ ⵜⴻⴵⵉ ⵄⴰⴷ ⴷ ⴰⵔⴹⴰ. ⵎⴰⵍⴰ ⵍⵍⴰ, ⴰⵇⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⵄⴰⴷ ⴷ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM11_7","075_11_7","ROM","11","7","7","ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅⴻⵏⵏⵉ? ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴰⵔⴻⵣⵣⵓ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵜ ⵜᵉⵟⵟⵉⴼ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵟⵟⴼⴻⵏ ⵜ ⵓⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵔⵖⴰⵍⴻⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM11_8","075_11_8","ROM","11","8","8","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵉⴹⴱⴰⵔⴻⵏ ⴷ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ, ⴷ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ, ⴰⵍ ⴰⵙⵙ ⵏ ⵢⵉⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("RM11_9","075_11_9","ROM","11","9","9","ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵏⵙⴻⵏ ⴷ ⵍⴼⴻⵅ ⵉ ⵏⵉⵜⵏⵉ, ⵓⵛⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵍⵎⵓⵏⴻⵜ ⵏⵙⴻⵏ ⴷ ⵜⵄⴻⵏⴽⵔⵉⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("RM11_10","075_11_10","ROM","11","10","10","ⴻⵊⵊ ⴰⴷ ⴷⴰⵔⵖⵍⴻⵏⵜ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⵉⵍⵉⵏ ⵏⵉⵜⵏⵉ, ⵓⵛⴰ ⴻⵊⵊ ⴰⴷ ⵇⴻⵡⵙⴻⵏ ⵉⵄⵓⵔⴰⵔ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("RM11_11","075_11_11","ROM","11","11","11","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵏⵉⵖ ⵅⴻⵏⵏⵉ: ⵎⴰ ⵏⴷⴻⵔⴼⴻⵏ, ⵎⴰⵖⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵡⴹⴰⵏ? ⵄⴻⵎⵎⴰⵔⵚ! ⵎⴰⵛⴰ ⵙ ⵓⵡⴻⵟⵟⵓ ⵏⵙⴻⵏ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⵜⵜⴰⵙⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM11_12","075_11_12","ROM","11","12","12","ⵎⴰⵍⴰ ⵉⴷⵡⴻⵍ ⵓⵏⴻⴷⵔⴻⴼ ⵏⵙⴻⵏ ⴷ ⴰⴳⵍⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⵍⵃⵓⴽⵎ ⵅⴰⵙⴻⵏ ⴷ ⴰⴳⵍⴰ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵎⴻⵛⵃⴰⵍ ⵇⴰⵄ ⵉ ⵖⴰ ⵢⵉⵡⴻⴹ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵙⴻⵏ ⴷ ⴰⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("RM11_13","075_11_13","ROM","11","13","13","ⴰⵇⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ, ⴰ ⵍⴻⴳⵏⵓⵙ, ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⵔⵔⴰⵙⵓⵍ ⵉ ⵍⴻⴳⵏⵓⵙ, ⴰⵇⴰ ⵜⵜⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉⵏⵓ:    ");
INSERT INTO rift_vpl VALUES ("RM11_14","075_11_14","ROM","11","14","14","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵙⵙⴻⴽⴽⴰⵔⴻⵖ ⵜⵓⵙⵎⵉ ⴷⴻⴳ ⴰⵢⵜ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ ⵓⵛⴰ ⴰⴷ ⵙⵙⵏⴻⵊⵎⴻⵖ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM11_15","075_11_15","ROM","11","15","15","ⵉⵡⴰ, ⵎⴰⵍⴰ ⴰⵎⴻⵏⴹⴰⵔ ⵏⵙⴻⵏ ⴰⵇⴰ-ⵜ ⴷ ⴰⵚⵍⴰⵃ ⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵡⴻⴷⵡⴰⵍ ⵏⵙⴻⵏ ⵎⵖⵉⵔ ⴷ ⵜⵓⴷⴰⵔⵜ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("RM11_16","075_11_16","ROM","11","16","16","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵚⵚⴰⴱⴻⵜ ⵜⵇⴻⴷⴷⴻⵙ, ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵍⵄⴻⵊⵏⴻⵜ ⵏ ⴰⵔⴻⵛⵜⵉ ⵜⵇⴻⴷⴷⴻⵙ! ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵥⵡⴰⵔ ⵉⵇⴻⴷⴷⴻⵙ, ⴰⵎⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵍⴻⴼⵔⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("RM11_17","075_11_17","ROM","11","17","17","ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵛⴰ ⵏ ⵍⴻⴼⵔⵓⵄ ⵓ ⵅⴻⵏⵏⵉ ⵛⴻⴽ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵣⴻⵎⵎⵓⵔ ⵏ ⵍⴻⵅⵍⴰ, ⵜᵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⴷ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵙⴻⵏ, ⵜⴷⴻⵡⵍⴻⴷ ⵜⵏⴻⴼⵄⴻⴷ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⴷ ⵣⵣⴻⵛⵜ ⵏ ⵜⵣⵉⵜⵓⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("RM11_18","075_11_18","ROM","11","18","18","ⵡⴰⵔ ⵜⵓⴼⴼ ⵛⴰ ⵅ ⵍⴻⴼⵔⵓⵄ. ⵎⴰⵍⴰ ⵜⵓⴼⴼⴻⴷ, ⵙⵙⴻⵏ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⴽⵙⵉⴷ ⵛⴰ ⴰⵥⵡⴰⵔ, ⵎⴰⵛⴰ ⴰⵥⵡⴰⵔ ⵉⴽⵙⵉ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("RM11_19","075_11_19","ROM","11","19","19","ⴰⴷ ⵜⴰⵖ ⴰⴷ ⵜⵉⵏⵉⴷ: “ⴰⵇⴰ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵍⴻⴼⵔⵓⵄ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⴰⴷ ⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("RM11_20","075_11_20","ROM","11","20","20","ⵉⵡⴰ, ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵛⴻⴽ ⵙ ⵍ’ⵉⵎⴰⵏ ⵜᵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⴷ ⵓⵛⴰ ⵜⴻⴽⵙⵉⴷ ⴰⵎⵛⴰⵏ ⵏⵙⴻⵏ. ⵡⴰⵔ ⵜⵓⴼⴼ ⵛⴰ, ⵎⴰⵛⴰ ⴳⴳⵯⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM11_21","075_11_21","ROM","11","21","21","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⵛⴻⵟⵟⴰⵔ ⵛⴰ ⵅ ⵍⴻⴼⵔⵓⵄ ⵏ ⵟⵟⴱⵉⵄⴻⵜ, ⵡⴰⵔ ⵅⴰⴽ ⵉⵜⵜⵛⴻⵟⵟⴰⵔ ⵛⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM11_22","075_11_22","ROM","11","22","22","ⴰⵇⴰ ⴷⴰ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵍⴻⵡⵄⴰⵔⴻⵜ ⵏⵏⴻⵙ: ⵍⴻⵡⵄⴰⵔⴻⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵡⴹⴰⵏ, ⵎⴰⵛⴰ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵅⴰⴽ ⵎⴰⵍⴰ ⵜᵉⵟⵟⴼⴻⴷ ⴷⵉ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM11_23","075_11_23","ROM","11","23","23","ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵜⵉⵣⴻⵎⵎⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⵍⴻⵇⵇⴻⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM11_24","075_11_24","ROM","11","24","24","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵛⴻⴽ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⵟⵟⴱⵉⵄⴻⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⵎⵎⵓⵔ ⵏ ⵍⴻⵅⵍⴰ, ⵜᵉⵜⵜⵡⴰⵇⴻⵙⵙⴻⴷ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⴷ ⴷⵉ ⵜⵣⵉⵜⵓⵏⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⵎⴻⵛⵃⴰⵍ ⵉⵀⴻⵡⵏⴻⵏ ⴽⵜⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵍⴻⵇⵇⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵜⵣⵉⵜⵓⵏⵜ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵟⵟⴱⵉⵄⴻⵜ ⵏⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("RM11_25","075_11_25","ROM","11","25","25","ⵎⵉⵏⵣⵉ ⵜⵜⴻⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵙⵉⵔⵔ-ⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵜⴻⵎⵙⴰⵔ ⵉⵛⵜ ⵏ ⵓⵙⴷⴰⵖⴻⵍ ⵏ ⵡⵓⵍ ⵅ ⵉⵙⵔⴰⵉⵍ ⵉ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⴷⴻⴼ ⵓⵄⴻⵎⵎⴰⵔ ⵏ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("RM11_26","075_11_26","ROM","11","26","26","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵙⵔⴰⵉⵍ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵎⵙⴻⵏⵊⴻⵎ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵣⵉ ⵚⵉⵀⵢⵓⵏ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵅ ⵢⴰⵄⵇⵓⴱ.” ");
INSERT INTO rift_vpl VALUES ("RM11_27","075_11_27","ROM","11","27","27","”ⵅⴻⵏⵏⵉ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵣⴰⵢⵉ, ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵖⴼⴰⵔⴻⵖ ⵉ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM11_28","075_11_28","ROM","11","28","28","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵏⵉⵜⵏⵉ ⴰⵇⴰ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵉⵅⴹⴰⵔⴻⵜ ⵉ ⵣⵉ ⵜⵜⵡⴰⵅⴹⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵊⴷⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("RM11_29","075_11_29","ROM","11","29","29","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⴰⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵏ ⴰⵔⴹⴰ ⵓⵍⴰ ⴷ ⵜⵍⴰⵖⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM11_30","075_11_30","ROM","11","30","30","ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵣⵉⵛ ⵡⴰⵔ ⵜᵉⵟⵟⵉⵄⴻⵎ ⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵜⴻⴽⵙⵉⵎ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵙ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM11_31","075_11_31","ROM","11","31","31","ⴰⵎⵎⵓ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵟⵟⵉⵄⴻⵏ ⵛⴰ ⵍⴻⵅⵅⵓ ⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵜⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵢⵓⵙⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵜⴰⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM11_32","075_11_32","ROM","11","32","32","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵃⴻⴱⴱⴻⵙ ⵉ-ⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵃⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RM11_33","075_11_33","ROM","11","33","33","ⴰ, ⵔⴰⴵⴰⵖ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴻⴳⴳ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵇⴻⴵⴻⴱ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⵢⴰⴼ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM11_34","075_11_34","ROM","11","34","34","“ⵎⵉⵏⵣⵉ ⵡⵉ ⵖⴰ ⵉⵙⵙⵏⴻⵏ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⵙⵉⴷⵉ?” ⵏⵉⵖ: “ⵡⵉ ⴷ ⴰⵙ ⵉⴵⴰⵏ ⴷ ⴰⵎⵛⴰⵡⴰⵔ?” ");
INSERT INTO rift_vpl VALUES ("RM11_35","075_11_35","ROM","11","35","35","ⵏⵉⵖ: “ⵡⵉ ⴷ ⴰⵙ ⵉⵣⵣⴰⵔⴻⵏ ⵉⵡⵛⴰ ⴰⵙ ⵛⴰ, ⵓⵎⵉ ⴷ ⴰⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵣⵣⴰⵢⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("RM11_36","075_11_36","ROM","11","36","36","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵣⵣⴰⵢⴻⵙ ⵉ ⵉⴵⴰ, ⵓ ⵎⴰⵔⵔⴰ ⴷⴰⵢⴻⵙ, ⵓ ⵎⴰⵔⵔⴰ ⴰⵇⴰ-ⵜ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ⵉ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⴰⵙⴻⵎⵖⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("RM12_1","075_12_1","ROM","12","1","1","ⵅ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵍⴰⵖⵉⵖ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵜⵇⴻⴷⴷⵎⴻⵎ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵡⴻⵎ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉⴷⴷⴰⵔⴻⵏ, ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵢⴰⵔⴹⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰ ⴷ ⴰⵄⴱⴰⴷ ⵏⵡⴻⵎ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_2","075_12_2","ROM","12","2","2","ⵡⴰⵔ ⵜⴻⵎⵇⵓⴷⴷⴰⵎ ⴰⴽ-ⴷ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵎⴰⵛⴰ ⴱⴻⴷⴷⵍⴻⵎ ⵙ ⵓⵍⴻⵇⵇⴻⵎ ⵏ ⵍⴻⵄⵇⴻⵍ ⵏⵡⴻⵎ ⵣⵉ ⵊⴷⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵇⴻⴵⴱⴻⵎ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ: ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⴷ ⵎⵉⵏ ⵢⴰⵔⴹⴰⵏ ⴷ ⵎⵉⵏ ⵉⴽⴻⵎⵎⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_3","075_12_3","ROM","12","3","3","ⴰⵇⴰ ⵙ ⴰⵔⴹⴰ ⵜⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵇⵇⴰⵔⴻⵖ ⴰⵡⴻⵎ ⵎⴰⵔⵔⴰ: ⵡⴰⵔ ⵜⵜⵅⴰⵔⵔⵉⵚⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⵉⵏ ⵉⵜⵜⵍⵉⵇ ⵓⵅⴰⵔⵔⴰⵚ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵅⴰⵔⵔⵚⴻⵎ ⵏⵉⵛⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵍ’ⵉⵎⴰⵏ ⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM12_4","075_12_4","ROM","12","4","4","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰⵔⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵍⵅⴻⴷⵎⴻⵜ ⴷ ⵉⵛⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RM12_5","075_12_5","ROM","12","5","5","ⴰⵎⵎⵓ ⵏⴻⵛⵛⵉⵏ, ⵡⴰⵅⵅⴰ ⴷ ⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RM12_6","075_12_6","ROM","12","6","6","ⵎⴰⵛⴰ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⵎⵎⵙⴻⴱⴹⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⴹⴰ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵎⵎⴻⵡⵛⴻⵏ: ⵉⵊⵊⴻⵏ ⵖⴰⵔⴻⵙ ⵜⴰⵡⵀⵉⴱⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵏⴻⴱⴱ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴻⴷⴷ ⵏ ⵍ’ⵉⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("RM12_7","075_12_7","ROM","12","7","7","ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔⴻⵙ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ, ⵏⵉⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵎⵙⴻⵖⵖⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵖⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("RM12_8","075_12_8","ROM","12","8","8","ⵏⵉⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴼⴻⵡⵡⴻⵊ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ, ⵏⵉⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵡⵛ ⵙ ⵜⴻⵛⵔⵉⵎⴻⵜ, ⵏⵉⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⴹⴻⴱⴱⴰⵔ ⵙ ⵡⴻⵎⵃⴰⴹ, ⵏⵉⵖ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM12_9","075_12_9","ROM","12","9","9","ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⴱⵍⴰ ⵏⵏⵉⴼⴰⵇ. ⵛⴰⵔⵀⴻⵎ ⵍⵖⴰⵔ, ⵜⵛⴻⴱⴱⴰⵔⴻⵎ ⴷⵉ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_10","075_12_10","ROM","12","10","10","ⵉⵍⵉⵎ ⵎⵍⵉⵃ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵜⴰⵡⵎⴰⵜ ⵏⵡⴻⵎ, ⵅⵙⴻⵎ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵣⵣⴰⵔⴻⵎ ⴰⴷ ⵜⵛⴻⵏⵏⵄⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RM12_11","075_12_11","ROM","12","11","11","ⵉⵍⵉⵎ ⴷ ⵉⵎⵃⴰⴹⴻⵏ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵉⴼⵉⵏⵢⴰⵏⴻⵏ. ⵉⵍⵉⵎ ⴷ ⵜⵉⵎⴻⵙⵙⵉ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵄⴻⴱⴷⴻⵎ ⵙⵉⴷⵉⵜⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("RM12_12","075_12_12","ROM","12","12","12","ⴼⴰⵔⵃⴻⵎ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⵙⵉⵜⴻⵎ ⵏⵡⴻⵎ, ⴷⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵡⴻⵎ ⵚⴱⴰⵔⴻⵎ ⵓⵛⴰ ⵟⵟⴼⴻⵎ ⵍⴻⴱⴷⴰ ⴷⵉ ⵜⵥⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("RM12_13","075_12_13","ROM","12","13","13","ⵡⵛⴻⵎ ⴰⴼⵓⵙ ⴷⵉ ⵎⵉⵏ ⵉⵃⴷⴰⵊⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ⴳⴳⴻⵎ ⵙ ⵍⴻⴹⵔⴰⴼⴻⵜ ⴰⴽ-ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_14","075_12_14","ROM","12","14","14","ⴱⴰⵔⴽⴻⵎ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴰⵔⵔⵜⴻⵏ, ⴱⴰⵔⴽⴻⵎ ⵡⴰⵔ ⵏⴻⵄⵄⵍⴻⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("RM12_15","075_12_15","ROM","12","15","15","ⴼⴰⵔⵃⴻⵎ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⴼⴰⵔⵃⴻⵏ, ⵔⵓⵎ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_16","075_12_16","ROM","12","16","16","ⵃⴻⵙⴱⴻⵎ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵃⴻⵙⵙⴱⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵔⵓⵃⴻⵎ ⴰⴽ-ⴷ ⵉⵎⵡⴰⴹⵄⴻⵏ. ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⵛⴰ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM12_17","075_12_17","ROM","12","17","17","ⵡⴰⵔ ⵜⵜⴰⵔⵔⵉⵎ ⵛⴰ ⵃⴻⴷ ⵅ ⵍⵖⴰⵔ ⵙ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵛⵏⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_18","075_12_18","ROM","12","18","18","ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ, ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ, ⵚⴻⵍⵃⴻⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM12_19","075_12_19","ROM","12","19","19","ⵡⴰⵔ ⵜⵜⴻⵏⵜⵉⵇⵉⵎⴻⵎ ⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ, ⵎⴰⵛⴰ ⵡⵛⴻⵎ ⴰⵎⵛⴰⵏ ⵉ ⵡⴻⵖⴹⴰⴱ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴰⵔⵔⵉⵎ ⵜⴰⵙⵖⴰⵔⵜ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵏⴻⵛⵛ ⴰⴷ ⴰⵔⵔⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⵏⴻⵡⴻⵎ, ⵉⵇⵇⴰⵔ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("RM12_20","075_12_20","ROM","12","20","20","ⵎⴰⵍⴰ ⵉⴵⵓⵥ ⵍⴻⵄⴷⵓ ⵏⵡⴻⵎ, ⵙⴻⵛⵛⴻⵎ ⵜ, ⵎⴰⵍⴰ ⵉⴼⵓⴷ, ⵡⵛⴻⵎ ⴰⵙ ⴰⴷ ⵉⵙⵓ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⴰⵢⴰ, ⴰⴷ ⵜⵢⴰⵔⵡⴻⴷ ⵍⴻⴼⵃⴻⵎ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM12_21","075_12_21","ROM","12","21","21","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵛⴰ ⵍⵖⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵖⵍⴻⴱ, ⵎⴰⵛⴰ ⵖⴻⵍⴱⴻⵎ ⵅ ⵍⵖⴰⵔ ⵙ ⵍⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM13_1","075_13_1","ROM","13","1","1","ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵡⴰⴹⴻⵄ ⵉ ⵚⵚⵓⵍⴰⵟⴰⵜ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⵍⵄⴰⴹⴰⵎⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵚⵚⵓⵍⵟⴰ ⵎⵖⵉⵔ ⵙ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵚⵚⵓⵍⴰⵟⴰⵜ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ, ⴰⵇⴰ ⵉⵙⵙⴱⴻⴷⴷ ⵉ-ⵜⴻⵏⵜ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM13_2","075_13_2","ROM","13","2","2","ⵙ ⵓⵢⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵎⵄⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵚⵚⵓⵍⵟⴰ, ⵉⵜⵜⴻⵎⵄⴰⵍⴰ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⵙⵙⴱⴻⴷⴷ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵎⵄⴰⵍⴰⵏ ⴰⴷ ⴽⵙⵉⵏ ⵍⵃⵓⴽⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM13_3","075_13_3","ROM","13","3","3","ⵎⵉⵏⵣⵉ ⵍⵇⵓⴹⴰⵜ ⵡⴰⵔ ⴵⵉⵏ ⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵅⴰⵔ, ⵎⴰⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ. ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⵉⵍⵉⴷ ⴱⵍⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⵚⵚⵓⵍⵟⴰ ⵏ ⵍⵇⵓⴹⴰⵜ? ⴻⴳⴳ ⵎⵉⵏ ⵉⵛⵏⴰⵏ, ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⵛⵛⴰⵏ ⵣⵣⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RM13_4","075_13_4","ROM","13","4","4","ⵎⵉⵏⵣⵉ ⵚⵚⵓⵍⵟⴰ ⴷ ⵜⴰⵎⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⴼⴹⴻⵍ ⵏⵏⴻⵛ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⵍⵖⴰⵔ, ⴳⴳⵯⴻⴷ, ⵎⵉⵏⵣⵉ ⵚⵚⵓⵍⵟⴰ ⵡⴰⵔ ⵜⴱⴻⴽⴽⴻⵙ ⵛⴰ ⵙⵙⵉⴼ ⴱⴰⵟⴻⵍ ⵓⵎⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵎⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜⵏⴻⵇⵇⴻⵎ ⵙ ⵡⴻⵖⴹⴰⴱ ⵉⵇⴻⵙⵃⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM13_5","075_13_5","ROM","13","5","5","ⵙ ⵓⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵟⵟⴰⵄ, ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("RM13_6","075_13_6","ROM","13","6","6","ⵅ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ ⵜᵉⵜⵜⵅⴻⴵⵚⴻⵎ ⴹⴹⴰⵔⵉⴱⴰ ⵉ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM13_7","075_13_7","ROM","13","7","7","ⵅ ⵓⵢⴰ, ⵡⵛⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ: ⴹⴹⴰⵔⵉⴱⴰ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⴹⴹⴰⵔⵉⴱⴰ ⵉ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ, ⵍⴻⵅⵍⴰⵚ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵍⴻⵅⵍⴰⵚ, ⴰⵡⴻⵇⵇⴰⵔ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵡⴻⵇⵇⴰⵔ, ⵛⵛⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵛⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM13_8","075_13_8","ROM","13","8","8","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⴰⵎⴰⵔⵡⴰⵙ ⵖⴰⵔ ⵃⴻⴷ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵏ ⵜⴰⵢⵔⵉ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ, ⴰⵇⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("RM13_9","075_13_9","ROM","13","9","9","ⵎⵉⵏⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⵇⵇⴰⵔ ⵄⴰⵡⴻⴷ: “ⵡⴰⵔ ⵣⴻⵏⵏⵉ, ⵡⴰⵔ ⵏⴻⵇⵇ, ⵡⴰⵔ ⵜⵜⵉⵛⴰⵔ, ⵡⴰⵔ ⵜⵜⴰⵙⴻⵎ!”, ⵓⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵎⵓⵏⴻⵏⵜ ⴷⴻⴳ ⵡⴰⵡⴰⵍ-ⴰ: “ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("RM13_10","075_13_10","ROM","13","10","10","ⵜⴰⵢⵔⵉ ⵡⴰⵔ ⵜⵜⴹⴰⵔⵔⵉ ⵛⴰ ⵊⵊⴰⵔ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴰⵢⵔⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵍⴻⴽⵎⴰⵍ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("RM13_11","075_13_11","ROM","13","11","11","ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵜⴰ ⴷ ⵍⵡⴻⵇⵜ ⴷ ⵜⵙⴰⵄⵄⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵏⴼⴰⵇ ⵣⴻⴳ ⵉⴹⴻⵚ, ⵎⵉⵏⵣⵉ ⵍⴻⵅⵅⵓ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵜⵓⴷⴻⵙ-ⴷⴷ ⴽⵜⴰⵔ ⵣⴻⴳ ⵡⴰⵎⵉ ⵏⴻⴷⵡⴻⵍ ⵏⵓⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM13_12","075_13_12","ROM","13","12","12","ⵍⴻⵅⵅⵓ ⵜⴻⵄⴷⵓ ⴵⵉⵍⴻⵜ, ⵢⵉⵡⴻⴹ-ⴷⴷ ⵓⵣⵉⵍ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⴰⵔⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵜⴰⴵⴻⵙⵜ, ⴰⴷ ⵏⴻⴽⵙⵉ ⵍⴻⵙⵏⴰⵃ ⵏ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RM13_13","075_13_13","ROM","13","13","13","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⵙ ⵓⵛⵓⵡⵡⴰⵔ ⴰⵅⵎⵉ ⴷ ⴰⵣⵉⵍ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵣⵣⵀⵓ ⴰⴱⴰⵔⵛⴰⵏ, ⵍⴰ ⴷⴻⴳ ⵓⵖⴻⵍⵍⵉ, ⵍⴰ ⴷⵉ ⵜⴻⵅⵎⵓⵊⵉ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷⵉ ⵇⴰⵎⴰ ⵓⵍⴰ ⴷⴻⴳ ⵓⵎⴻⵏⵖⵉ ⴷ ⵍⴻⵃⵙⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("RM13_14","075_13_14","ROM","13","14","14","ⵎⴰⵛⴰ ⴰⵔⴹⴻⵎ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵜⵜⵉⵛⴻⵎ ⵜⴰⵢⵏⵉⵜ ⵉ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM14_1","075_14_1","ROM","14","1","1","ⵡⵉ ⵉⴹⴻⵄⴼⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵡⵛⴻⵎ ⴰⵙ ⴰⴼⵓⵙ, ⵡⴰⵔ ⵜⵜⴻⵎⵙⴻⴱⴹⴰⵎ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM14_2","075_14_2","ROM","14","2","2","ⴰⵇⴰ ⴷⵉⵏ ⵃⴻⴷ ⵢⵓⵎⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵛⵛ ⴽⵓⵍⵛⵉ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ ⴰⴷ ⵉⵛⵛ ⵜⵉⴱⴱⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("RM14_3","075_14_3","ROM","14","3","3","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⵡⴰⵔ ⵉⵙⵙⴻⵃⵇⴰⵔⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⵡⴰⵔ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵇⴱⴻⵍ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("RM14_4","075_14_4","ROM","14","4","4","ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ ⵡⴻⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ? ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⴱⴻⴷⴷ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵍⴰ ⵉⵡⴹⴰ, ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴱⴰⴱ ⵏⵏⴻⵙ. ⵙⵉⴷⴻⵙ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⴱⴻⴷⴷ ⴷ ⴰⴱⴻⴷⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("RM14_5","075_14_5","ROM","14","5","5","ⴰⵇⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴰⵇⴰ ⴷⵉⵏ ⴰⵙⵙ ⵙⴻⵏⵏⴻⵊ ⵉ ⵡⴰⵙⵙ ⵏⵏⴻⵖⵏⵉ, ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴰⵇⴰ ⴽⵓⵍ ⴰⵙⵙ ⴽⵉⴼⴽⵉⴼ. ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵇⵏⴻⵄ ⴷⵉ ⵍⴱⴰⵍ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM14_6","075_14_6","ROM","14","6","6","ⵡⴻⵏⵏⵉ ⵉⵡⴻⵇⵇⴰⵔⴻⵏ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ, ⵉ ⵙⵉⴷⴻⵙ ⵉ ⵜ ⵖⴰ ⵉⵡⴻⵇⵇⴰⵔ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵡⴻⵇⵇⴰⵔⴻⵏ ⴰⵙⵙ, ⵉ ⵙⵉⴷⴻⵙ ⵉ ⵡⴰⵔ ⵜ ⵉⵡⴻⵇⵇⴰⵔ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ, ⵉⵜⵜⴻⵜⵜ ⵉ ⵙⵉⴷⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⵛⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵛⴰ, ⵉ ⵙⵉⴷⴻⵙ ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵛⴰ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵛⴻⴽⴽⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RM14_7","075_14_7","ROM","14","7","7","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵏⴻⵖ ⴰⵇⴰ ⵉⴷⴷⴰⵔ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵉⵎⵎⵓⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM14_8","075_14_8","ROM","14","8","8","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⴻⴷⴷⴰⵔ, ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵏⴻⵎⵎⵓⵜ ⴰⴷ ⵏⴻⵎⵎⴻⵜ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ⵙ ⵓⵢⴰ, ⵎⴰ ⵏⴻⴷⴷⴰⵔ ⵏⵉⵖ ⵏⴻⵎⵎⵓⵜ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM14_9","075_14_9","ROM","14","9","9","ⵎⵉⵏⵣⵉ ⵉ ⵓⵢⴰ ⵉ ⵉⵎⵎⵓⵜ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵙⵉⴷⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵓⵍⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM14_10","075_14_10","ROM","14","10","10","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵓⵎⴰⵛ? ⵏⵉⵖ ⵎⴰⵢⴻⵎⵎⵉ ⵄⴰⵡⴻⴷ ⵛⴻⴽ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴰⴷ ⵓⵎⴰⵛ? ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵏⴱⴻⴷⴷ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM14_11","075_14_11","ROM","14","11","11","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⴷⴷⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⴰⴷ ⴰⵢⵉ ⴰⴹⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴼⴰⴷⴷⴻⵏ ⵓ ⴽⵓⵍ ⵉⵍⴻⵙ ⴰⴷ ⵅⴰⴼⵉ ⵉⵛⵀⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("RM14_12","075_14_12","ROM","14","12","12","ⵅⴻⵏⵏⵉ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⴰⴷ ⵉⴳⴳ ⵍⴻⵃⵙⴰⴱ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM14_13","075_14_13","ROM","14","13","13","ⵣⵉ ⵍⴻⵅⵅⵓ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵃⴻⴽⴽⵎⴻⵎ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵃⵙⴻⵏ ⴰⴷ ⵜⴻⴽⵙⴻⴷ ⴰⵡⴰⵍ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵙⵙⴰⵔⵙⴻⴷ ⵛⴰ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵏⵇⴰⵔⴹ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("RM14_14","075_14_14","ROM","14","14","14","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵖ ⴷⵉ ⵙⵉⴷⵉ ⵢⴰⵙⵓⵄ, ⴱⴻⵍⵍⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴻⵅⵎⴻⵊ ⵉ ⵏⴻⵜⵜⴰ, ⵎⵖⵉⵔ ⵉ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵃⴻⵙⴱⴻⵏ ⴷ ⵍⴻⵅⵎⴻⵊ, ⴰⵇⴰ ⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ ⵓⵎⵉ ⵜⴻⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("RM14_15","075_14_15","ROM","14","15","15","ⵎⴰⵍⴰ ⵉⵅⴻⵢⵢⴻⵇ ⵓⵎⴰⵛ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵛⵛⴰ ⵉ ⵜⴻⵛⵛⵉⴷ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⵓⵢⵓⵔⴻⴷ ⴷⵉ ⵜⴰⵢⵔⵉ. ⵡⴰⵔ ⵜⵜⴻⵃⵃⵉ ⵛⴰ ⵙ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵛ ⵡⴻⵏⵏⵉ ⵉ ⵅⴻⴼ ⵉⵎⵎⵓⵜ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM14_16","075_14_16","ROM","14","16","16","ⵎⵉⵏ ⵏⵃⴻⵙⵙⴻⴱ ⴷ ⵍⵅⴰⵔ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM14_17","075_14_17","ROM","14","17","17","ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷⵉ ⵎⴰⵛⵛⴰ ⴷ ⵜⵉⵙⵙⵉⵜ, ⵎⴰⵛⴰ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⴷ ⵍⴻⵀⵏⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM14_18","075_14_18","ROM","14","18","18","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵢⴰⵔⴹⴰ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵇⴱⵓⵍ ⵖⴰⵔ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RM14_19","075_14_19","ROM","14","19","19","ⴰⴷ ⵏⴻⴹⴼⴰⵔ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵍⴻⵀⵏⴰ ⴷ ⵍⴻⴱⵏⵉ ⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RM14_20","075_14_20","ROM","14","20","20","ⵡⴰⵔ ⵜⵜⴰⵔⴻⴷⴷⴻⴵ ⵛⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵛⵛⴰ. ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵎⴻⵣⴷⴰⴳ, ⵎⴰⵛⴰ ⵓⵛⵜ ⵅ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴳⴳ ⴰⵥⵔⵓ ⵉ ⵓⵏⴻⴷⵔⴻⴼ ⵙ ⵎⴰⵛⵛⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RM14_21","075_14_21","ROM","14","21","21","ⵎⵍⵉⵃ ⵓⵎⵉ ⵡⴰⵔ ⵏᵉⵜⵜⴻⵜⵜ ⵛⴰ ⴰⵢⵙⵓⵎ ⵓ ⵡⴰⵔ ⵏⵙⴻⵙⵙ ⵛⴰ ⴱⵉⵏⵓ ⵏⵉⵖ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⴷⵉ ⵉ ⵖⴰ ⵉⵏⴷⴻⵔⴼ ⵓⵎⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("RM14_22","075_14_22","ROM","14","22","22","ⵎⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⴷ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ? ⴰⴷ ⴰⵛ ⵢⵉⵍⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⴽⴽⵡⵉⴹ ⵛⵛⵔⴻⵄ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM14_23","075_14_23","ROM","14","23","23","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴽⴽⴰⵏ ⵅⵎⵉ ⵉⵜⵜⴻⵜⵜ, ⵉⵜⵜⵡⴰⵃⴰⵙⴻⴱ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵍ’ⵉⵎⴰⵏ. ⵇⴰⵄ ⵎⵉⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⵉ ⵍ’ⵉⵎⴰⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("RM15_1","075_15_1","ROM","15","1","1","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴰⵔⴱⵓ ⵜⵓⴹⵄⴻⴼⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ, ⵡⴰⵔ ⵏⴻⵜⵜⵉⵡⵉ ⵛⴰ ⴰⵔⴹⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM15_2","075_15_2","ROM","15","2","2","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵙⵙⴰⵔⴹⴰ ⵊⵊⴰⵔ ⵏⵏⴻⵙ ⵉ ⵜⵛⵓⵏⵉ ⴷ ⵍⴻⴱⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RM15_3","075_15_3","ROM","15","3","3","ⵎⵉⵏⵣⵉ ⵍⵎⴰⵙⵉⵃ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵉⵙⵙⴰⵔⴹⵉ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵜⵉⴽⴽⵡⵓⵔⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵛⴻⴽ ⵉⴽⴽⵡⴰⵔⴻⵏ, ⵡⴹⴰⵏⵜ-ⵉ-ⴷⴷ ⵅⴰⴼⵉ.” ");
INSERT INTO rift_vpl VALUES ("RM15_4","075_15_4","ROM","15","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵔⴰ ⵣⵉⵛ, ⵜⵓⵔⴰ ⵉ ⵓⵙⴻⵍⵎⴻⴷ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵙ ⵚⵚⴱⴰⵔ ⴷ ⵓⵛⴻⵊⵊⴻⵄ ⵙ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵢⵉⵍⵉ ⵓⵙⵉⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM15_5","075_15_5","ROM","15","5","5","ⴰⵔⴻⴱⴱⵉ ⵏ ⵚⵚⴱⴰⵔ ⴷ ⵓⴼⴻⵡⵡⴻⵊ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵃⴻⵙⴱⴻⵎ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵖⴰⵔⴻⵙ ⵍⵇⵉⵎⴻⵜ ⴷ ⵉⵛⵜ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("RM15_6","075_15_6","ROM","15","6","6","ⵃⵉⵎⴰ ⵙ ⵉⵊⵊ ⵏ ⴰⵔⵔⴰⵢ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⴰⴷ ⵜⴻⵙⵙⵄⵓⴵⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM15_7","075_15_7","ROM","15","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵇⴻⴱⵍⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵚⴻⴱⵔⴻⵎ ⵉⵊⵊⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵉⵇⴱⴻⵍ ⵍⵎⴰⵙⵉⵃ ⵄⴰⵡⴻⴷ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM15_8","075_15_8","ROM","15","8","8","ⵎⴰⵖⴰⵔ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵡⴻⵅⵜⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵉⴷⴻⵜⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴹⵎⴻⵏ ⵍⵡⵓⵄⵓⴷ ⵉ ⵉⵡⴰⵄⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⵊⴷⵓⴷ, ");
INSERT INTO rift_vpl VALUES ("RM15_9","075_15_9","ROM","15","9","9","ⵓ ⵃⵉⵎⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵉ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵜⵓⵙⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵛⴻⴽ ⵛⴻⴽⴽⴰⵔⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵓⵛⴰ ⴰⴷ ⵚⴻⴱⴱⵃⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("RM15_10","075_15_10","ROM","15","10","10","ⵓⵛⴰ ⵉⵇⵇⴰⵔ ⵄⴰⵡⴻⴷ: “ⴼⴰⵔⵃⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴳⵏⵓⵙ, ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RM15_11","075_15_11","ROM","15","11","11","ⵓⵛⴰ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵃⴻⵎⴷⴻⵎ ⵙⵉⴷⵉ, ⴰ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵚⴻⴱⴱⵃⴻⵎ ⵜ, ⴰ ⵎⴰⵔⵔⴰ ⵛⵛⵓⵄⵓⴱ!” ");
INSERT INTO rift_vpl VALUES ("RM15_12","075_15_12","ROM","15","12","12","ⵄⴰⵡⴻⴷ ⵉⵛⴰⵄⵢⴰ ⵉⵇⵇⴰⵔ: “ⴰⴷ ⵢⵉⵍⵉ ⵡⴻⵥⵡⴰⵔ ⵏ ⵢⴰⵙⵙⴰ, ⵓ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵍⴻⴳⵏⵓⵙ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵓⵙⵉⵜⴻⵎ ⵏ ⵍⴻⴳⵏⵓⵙ.” ");
INSERT INTO rift_vpl VALUES ("RM15_13","075_15_13","ROM","15","13","13","ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵙⵉⵜⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵍⴻⵀⵏⴰ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴼⴻⵢⵢⴹⴻⵎ ⵙ ⵓⵙⵉⵜⴻⵎ ⵏⵏⴻⵙ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM15_14","075_15_14","ROM","15","14","14","ⵏⴻⵛⵛ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵜⵜⵡⴰⵙⵇⴻⵏⵄⴻⵖ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⵎⵎⴰⵔⴻⵎ ⵙ ⵜⵛⵓⵏⵉ, ⵜⴻⵛⵛⵓⵔⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵜⵓⵙⵙⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⵎ ⵄⴰⵡⴻⴷ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RM15_15","075_15_15","ROM","15","15","15","ⵎⴰⵛⴰ ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⴰⵇⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵄⴻⵇⵍⴻⵖ, ⵙ ⴰⵔⴹⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RM15_16","075_15_16","ROM","15","16","16","ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⵍⴻⴳⵏⵓⵙ, ⵓⵎⵉ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵖ ⵉ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⵖⴰⵔⵚⵜ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷ ⵜⴰⵎⴻⵇⴱⵓⵍⵜ, ⵜᵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM15_17","075_15_17","ROM","15","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RM15_18","075_15_18","ROM","15","18","18","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵄⵎⴻⵖ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⴷⴻⴳ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵍⴻⴳⵏⵓⵙ ⵅ ⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⵉ ⵜ ⵉⴳⴳⵉ ⵍⵎⴰⵙⵉⵃ ⵙ ⵡⴰⵡⴰⵍ ⴷ ⵍⵅⴻⴷⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RM15_19","075_15_19","ROM","15","19","19","ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵓⵛⴰ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ ⵜⵜⴻⵏⴹⴻⵖ ⵣⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴰⵍ ⵉⵍⵍⵉⵔⵉⴽⵓⵏ ⵓⵛⴰ ⴽⴻⵎⵎⵍⴻⵖ ⴰⴱⴰⵔⵔⴻⵃ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM15_20","075_15_20","ROM","15","20","20","ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ ⵇⴱⴻⵍ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴱⴻⵏⵏⵉⵖ ⵅ ⴷⵙⴰⵙ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("RM15_21","075_15_21","ROM","15","21","21","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵉⵏⵏⵉ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⵃⴻⵏ ⴰⴷ ⵜ ⵥⴰⵔⴻⵏ, ⵓ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵙ ⵉⵙⵍⵉⵏ, ⴰⴷ ⴰⵎⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RM15_22","075_15_22","ROM","15","22","22","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵡⵉⴹⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵓⵔⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM15_23","075_15_23","ROM","15","23","23","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵜⵜⴰⵙⵉⵄ ⵃⵉⵎⴰ ⴰⴷ ⴱⴻⵛⵛⴰⵔⴻⵖ ⵄⴰⴷ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵀ-ⴰ ⵓ ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⵅⵙⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("RM15_24","075_15_24","ROM","15","24","24","ⵅⵎⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵙⴻⴱⴱⴰⵏⵢⴰ, ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ, ⵓ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵜⵜⵡⴰⵙⵙⵇⴻⴱⴱⴹⴻⵖ ⵖⴰⵔ ⴷⵉⵏⵏⵉ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵉ ⵖⴰ ⴰⵔⵔⴻⵖ ⵎⴻⵥⵔⵉ ⵛⵡⴰⵢⵜ ⵓⵎⵉ ⵉ ⵖⴰ ⵥⵔⵉⵖ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("RM15_25","075_15_25","ROM","15","25","25","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵔⵓⵃⴻⵖ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵖ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM15_26","075_15_26","ROM","15","26","26","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴹⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⴷ ⴰⵅⴰⵢⴰ ⴰⴷ ⴳⴳⴻⵏ ⵛⴰ ⵏ ⵜⵡⵉⵣⴰ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("RM15_27","075_15_27","ROM","15","27","27","ⵜⵓⵖⴰ ⴰⵔⴹⴰⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵜ ⵄⴰⵡⴻⴷ ⴷⴰⵢⵙⴻⵏ ⴷ ⴰⵎⴰⵔⵡⴰⵙ. ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵍⴻⴳⵏⵓⵙ ⵛⴰⵔⵛⴻⵏ ⴷⵉ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴷ ⴰⴳⵍⴰ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⴰⵔⵔⵓⵃ, ⴰⵇⴰ-ⵜ ⵄⴰⵡⴻⴷ ⴷ ⴰⵎⴰⵔⵡⴰⵙ ⴷⵉ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵙ ⵎⵉⵏ ⵖⴰⵔⵙⴻⵏ ⴷ ⴰⴳⵍⴰ ⵅ ⵍⴻⵃⵙⴰⴱ ⴷⴷⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("RM15_28","075_15_28","ROM","15","28","28","ⵅⵎⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵖ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ-ⴰ ⵓⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵙⵙⵉⵡⴹⴻⵖ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵡⵉⵣⴰ-ⵢⴰ ⵙ ⵍⴰⵎⴰⵏ, ⴰⴷ ⴷⴷ ⵅⴰⵡⴻⵎ ⴽⴽⴻⵖ ⴷ ⴰⴱⵔⵉⴷ ⵅⵎⵉ ⵖⴰ ⵔⴰⵃⴻⵖ ⵖⴰⵔ ⵙⴻⴱⴱⴰⵏⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("RM15_29","075_15_29","ROM","15","29","29","ⵎⴰⵛⴰ ⵙⵙⵏⴻⵖ ⴱⴻⵍⵍⵉ, ⵎⴰⵍⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⵙ ⵍⵎⵓⴷ ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM15_30","075_15_30","ROM","15","30","30","ⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⵙ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⵔⵓⵃ, ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴰⴽⵉⴷⵉ ⴷⵉ ⵜⵥⴰⴵⵉⵜ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("RM15_31","075_15_31","ROM","15","31","31","ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵖ ⵣⴻⴳ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉⵏⵓ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⴷ ⵜⴰⵎⴻⵇⴱⵓⵍⵜ, ");
INSERT INTO rift_vpl VALUES ("RM15_32","075_15_32","ROM","15","32","32","ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵛⵛⵓⵔⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵙ ⴰⵔⵔⴰⵢ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴰⵔⴻⵢⵢⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM15_33","075_15_33","ROM","15","33","33","ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵎ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_1","075_16_1","ROM","16","1","1","ⵡⴻⴽⴽⵍⴻⵖ ⴰⵡⴻⵎ ⵓⵍⵜⵎⴰⵜⵏⴻⵖ ⴼⵓⴱⵉ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⴽⵉⵏⵅⵔⵉⵢⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("RM16_2","075_16_2","ROM","16","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴰⵔⴻⵃⵃⴱⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵍⵉⵇ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵜⵄⴰⵡⵏⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵜᵉⵜⵜⴰⵔ ⵏⴻⵜⵜⴰⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵄⴰⵡⴻⵏ ⴰⵟⵟⴰⵙ, ⵓⵍⴰ ⵍⴰ ⴷ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("RM16_3","075_16_3","ROM","16","3","3","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ ⴷ ⴰⴽⵡⵉⵍⴰ, ⵉⵏⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⴽⵉⴷⵉ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("RM16_4","075_16_4","ROM","16","4","4","ⵏⵉⵜⵏⵉ ⵙⴻⴱⴱⵍⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ. ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵏⴻⵛⵛ ⵡⴰⵀⴰ ⵡⴻⵏⵏⵉ ⵜⴻⵏ ⵉⵜⵜⵇⴰⴷⴰⵏ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RM16_5","075_16_5","ROM","16","5","5","ⵙⴻⴵⵎⴻⵎ ⵄⴰⵡⴻⴷ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜⴻⵏⵏⵉ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ. ⵙⴻⴵⵎⴻⵎ ⵅ ⵉⴱⴰⵏⵉⵜⵓⵙ, ⴰⵎⵄⵉⵣⵣ ⵉⵏⵓ, ⵙ ⵍⴻⵀⵏⴰ. ⵏⴻⵜⵜⴰ ⴷ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⴰⵅⴰⵢⴰ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RM16_6","075_16_6","ROM","16","6","6","ⵙⴻⴵⵎⴻⵎ ⵅ ⵎⴰⵔⵉⵢⴰ ⵙ ⵍⴻⵀⵏⴰ. ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴰⵎⴰⵔ ⴰⵟⵟⴰⵙ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM16_7","075_16_7","ROM","16","7","7","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴰⵏⴷⵔⵓⵏⵉⴽⵓⵙ ⴷ ⵢⵓⵏⵉⵢⴰⵙ ⵉⵏⵏⵉ ⴷ ⵔⴰⴵ ⵉⵏⵓ ⴷ ⵉⵎⴻⵃⴱⴰⵙ ⴰⴽⵉⴷⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵔⵢⴰⵣⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵖⴰⵔ ⵔⵔⵓⵙⵓⵍ, ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵇⴱⴻⵍ ⵅⴰⴼⵉ. ");
INSERT INTO rift_vpl VALUES ("RM16_8","075_16_8","ROM","16","8","8","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴰⵎⴱⵍⵉⵢⴰⵙ, ⴰⵎⵄⵉⵣⵣ ⵉⵏⵓ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM16_9","075_16_9","ROM","16","9","9","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⵓⵔⴱⴰⵏⵓⵙ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵅ ⴰⵙⵜⴰⵅⵉⵙ ⴰⵎⵄⵉⵣⵣ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RM16_10","075_16_10","ROM","16","10","10","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴰⴱⵉⵍⵍⵉⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⵉⵙⵜⵓⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RM16_11","075_16_11","ROM","16","11","11","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⵀⵉⵔⵓⴷⵉⵢⵓⵏ ⵡⴻⵏⵏⵉ ⴷ ⵍⴰⴵ ⵉⵏⵓ. ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵏⴰⵔⴽⵉⵙⵙⵓⵙ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM16_12","075_16_12","ROM","16","12","12","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⵜⴰⵔⵉⴼⵉⵏⴰ ⴷ ⵜⴰⵔⵉⴼⵓⵙⴰ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⴰⵎⴰⵔⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴱⴰⵔⵙⵉⵙ, ⴰⵎⵄⵉⵣⵣ ⵉⵏⵓ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵎⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RM16_13","075_16_13","ROM","16","13","13","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⵔⵓⴼⵓⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓⵍⴰ ⵅ ⵢⴻⵎⵎⴰⵙ ⵜⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵢⴻⵎⵎⴰ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("RM16_14","075_16_14","ROM","16","14","14","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴰⵙⵉⵏⴽⵔⵉⵜⵓⵙ, ⴼⵍⵉⴳⵓⵏ, ⵀⵉⵔⵎⴰⵙ, ⴱⴰⵜⵔⵓⴱⴰⵙ, ⵀⵉⵔⵎⵉⵙ ⵓⵛⴰ ⵅ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_15","075_16_15","ROM","16","15","15","ⵙⴻⴵⵎⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵅ ⴼⵉⵍⵓⵍⵓⵖⵓⵙ ⴷ ⵊⵓⵍⵉⵢⴰ ⴷ ⵏⵉⵔⵉⵢⵓⵙ ⴷ ⵓⵍⵜⵎⴰⵙ, ⴷ ⵓⵍⵉⵎⴱⴰⵙ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_16","075_16_16","ROM","16","16","16","ⵙⴻⴵⵎⴻⵎ ⵅ ⵡⴰⵢⴰⵡⵢⴰ ⵙ ⵓⵙⵓⴷⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵎⴰⵔⵔⴰ ⵜⵜⵙⴻⴵⴰⵎⴻⵏⵜ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RM16_17","075_16_17","ROM","16","17","17","ⵎⴰⵛⴰ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵣⵉ ⵡⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵎⵙⴻⴱⴹⵉ ⴷ ⵜⵄⵉⵏⴽⵔⵉⴼⵉⵏ, ⴱⴰⵔⵔⴰ ⵉ ⵜⵖⵓⵔⵉ ⵉ ⵜⴻⵖⵔⵉⵎ. ⴱⴻⵄⵄⴷⴻⵎ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_18","075_16_18","ROM","16","18","18","ⵎⵉⵏⵣⵉ ⴰⵎ ⵢⵉⵏⴰ ⵡⴰⵔ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵛⴰ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵛⴰ ⵉ ⵓⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏ. ⵙ ⵍⴻⵀⵔⵓⴷ ⵉⵚⴻⴱⵃⴻⵏ ⴷ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵅⴻⴷⴷⵄⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏ ⵉⵃⴰⴼⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_19","075_16_19","ROM","16","19","19","ⵎⵉⵏⵣⵉ ⵟⵟⴰⵄⴻⵜ ⵏⵡⴻⵎ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴼⴰⵔⵃⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰⵛⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷⵉ ⵜⵛⵓⵏⵉ ⵓⵍⴰ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵣⵉ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RM16_20","075_16_20","ROM","16","20","20","ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⵉⵜⴻⵃⵃⴰ ⵛⵛⵉⵟⴰⵏ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⴷⴻⵖⵢⴰ. ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_21","075_16_21","ROM","16","21","21","ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⴽⵉⴷⵉ, ⵉⵜⵜⵙⴻⴵⴰⵎ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵣⵉ ⵍⴰⴵ ⵉⵏⵓ: ⵍⵓⴽⵉⵢⵓⵙ ⴷ ⵢⴰⵙⵓⵏ ⴷ ⵙⵓⵙⵉⴱⴰⵜⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RM16_22","075_16_22","ROM","16","22","22","ⵏⴻⵛⵛ, ⵜⴰⵔⵜⵉⵢⵓⵙ, ⵡⴻⵏⵏⵉ ⵢⵓⵔⴰⵏ ⵜⴰⴱⵔⴰⵜ-ⴰ, ⵜⵜⵙⴻⴵⴰⵎⴻⵖ ⵅⴰⵡⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RM16_23","075_16_23","ROM","16","23","23","ⵉⵜⵜⵙⴻⴵⴰⵎ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵅⴰⵢⵓⵙ ⵙ ⵍⴻⵀⵏⴰ. ⵏⴻⵜⵜⴰ ⵢⴰⵔⴻⵃⵃⴻⴱ ⵣⵣⴰⵢⵉ ⵓⵍⴰ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵔⵔⴰ. ⵜⵜⵙⴻⴵⴰⵎⴻⵏ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵉⵔⴰⵙⵜⵓⵙ, ⵡⴻⵏⵏⵉ ⵅ ⵙⵙⴻⵏⴷⵓⵇ ⵏ ⵜⴻⵏⴷⵉⵏⵜ, ⴷ ⴽⵡⴰⵔⵜⵓⵙ, ⵜⴰⵡⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("RM16_24","075_16_24","ROM","16","24","24","ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴹⵎⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵏⵓ - ⵍ’ⵉⵏⵊⵉⵍ ⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⵃⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⴰⵔⴳⴰⴱ ⵏ ⵙⵙⵉⵔⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵣⵉⵛ, ");
INSERT INTO rift_vpl VALUES ("RM16_25","075_16_25","ROM","16","25","25","ⵎⴰⵛⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ-ⴷⴷ ⵍⴻⵅⵅⵓ ⵙ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⵛⴻⵏ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵉ ⵍⴻⴱⴷⴰ, ⴰⵍⴰⵎⵉ ⴷ ⴰⵙ ⵖⴰ ⵟⵟⴰⵄⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵙ ⵍ’ⵉⵎⴰⵏ - ");
INSERT INTO rift_vpl VALUES ("RM16_26","075_16_26","ROM","16","26","26","ⴰⵇⴰ ⵉ ⵏⴻⵜⵜⴰ ⵡⴻⵏⵏⵉ ⴷ ⴱⴰⴱ ⵏ ⵜⵉⵖⵉⵜ ⵡⴻⵃⵃⴷⴻⵙ, ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RM16_27","075_16_27","ROM","16","27","27","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C11_1","076_1_1","1CO","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷ ⵉⵜⵜⵡⴰⵙⴻⴽⴽⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵜⴰⵡⵎⴰⵜ ⵙⵓⵙⵜⵉⵏⵉⵙ, ");
INSERT INTO rift_vpl VALUES ("C11_2","076_1_2","1CO","1","2","2","ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⴽⵓⵔⵉⵏⵜⵓⵙ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷ ⵉⵏⵏⵉ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵎⴰⵏⵉ ⵎⴰ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⵙⵉⴷⵉⵜⵙⴻⵏ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C11_3","076_1_3","1CO","1","3","3","ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C11_4","076_1_4","1CO","1","4","4","ⵏⴻⵛⵛ ⵍⴻⴱⴷⴰ ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵅ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C11_5","076_1_5","1CO","1","5","5","ⵎⵉⵏⵣⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴷⴻⵡⵍⴻⵎ ⵣⵣⴰⵢⴻⵙ ⴷ ⵜⵜⵓⵊⵊⴰⵔ, ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵙⵙⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("C11_6","076_1_6","1CO","1","6","6","ⵎⴰⵖⴰⵔ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⵜᵉⵜⵜⵡⴰⴹⵎⴻⵏ ⴷⴰⵢⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C11_7","076_1_7","1CO","1","7","7","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵣⵣⵄⴰⴼ ⵏ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵉⵇⵇⵉⵎ, ⴰⵎ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ ⴰⵙⴰⵔⴳⴰⴱ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("C11_8","076_1_8","1CO","1","8","8","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴹⵎⴻⵏ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴱⵍⴰ ⵍⵄⵉⴱ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C11_9","076_1_9","1CO","1","9","9","ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵜⵎⵓⵏⵜ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C11_10","076_1_10","1CO","1","10","10","ⵎⴰⵛⴰ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵎⴰⵔⵔⴰ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵎⵙⴻⴱⴹⵉⵎ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⵉⵍⵉⵎ ⵜⵎⵓⵏⴻⵎ ⵏⵉⵛⴰⵏ ⵙ ⵏⵏⴻⵢⵢⴻⵜ ⴷ ⵉⵛⵜⴻⵏ ⴷ ⵓⵅⴰⵔⵔⴻⵚ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C11_11","076_1_11","1CO","1","11","11","ⵎⵉⵏⵣⵉ ⵙⵙⴰⵔⴳⴱⴻⵏ ⴰⵢⵉ ⵉⵏⵏⵉ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴽⵍⵓⵡⵉ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⴱⴻⵍⵍⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵎⴻⵏⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C11_12","076_1_12","1CO","1","12","12","ⵅⵙⴻⵖ ⴰⴷ ⵉⵏⵉⵖ, ⴰⵇⴰ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵣⵉ ⴱⵓⵍⵓⵙ!’ ⵓ ⵛⴰ ⵏⵏⴻⵖⵏⵉ: ‘ⵏⴻⵛⵛ ⵣⵉ ⴰⴱⵓⵍⵍⵓⵙ!’, ⵓ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵄⴰⵡⴻⴷ: ‘ⵏⴻⵛⵛ ⵣⵉ ⴽⵉⴼⴰ!’, ⵓ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛ ⵣⵉ ⵍⵎⴰⵙⵉⵃ!’ ");
INSERT INTO rift_vpl VALUES ("C11_13","076_1_13","1CO","1","13","13","ⵎⴰ ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵉⵜⵜⵡⴰⴱⴹⴰ ⴷ ⵉⵡⴻⵜⵡⵉⵜⴻⵏ? ⵎⴰ ⵜⵓⵖⴰ ⴱⵓⵍⵓⵙ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵡⴻⵎ? ⵏⵉⵖ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⴱⵓⵍⵓⵙ? ");
INSERT INTO rift_vpl VALUES ("C11_14","076_1_14","1CO","1","14","14","ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵡⴰⵔ ⵙⵙⵖⴻⴹⵚⴻⵖ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵎⵖⵉⵔ ⴽⵔⵉⵙⴱⵓⵙ ⴷ ⵅⴰⵢⵓⵙ ⵡⴰⵀⴰ, ");
INSERT INTO rift_vpl VALUES ("C11_15","076_1_15","1CO","1","15","15","ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⵉⵏⵉ ⴱⴻⵍⵍⵉ ⵙⵙⵖⴻⴹⵚⴻⵖ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C11_16","076_1_16","1CO","1","16","16","ⵄⴰⵡⴻⴷ ⵙⵙⵖⴻⴹⵚⴻⵖ ⵜⴰⵡⴰⵛⵓⵏⵜ ⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵛⴰ, ⵎⴰ ⵙⵙⵖⴻⴹⵚⴻⵖ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C11_17","076_1_17","1CO","1","17","17","ⵎⴰⵖⴰⵔ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵖⴻⴹⵚⴻⵖ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵜⵉⵖⵉⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜᵉⵜⵜⵡⴰⵙⵙⴱⴻⵟⵟⴻⵍ ⵚⵚⴰⵍⵉⴱ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C11_18","076_1_18","1CO","1","18","18","ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ ⵏ ⵚⵚⴰⵍⵉⴱ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C11_19","076_1_19","1CO","1","19","19","ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⴰⴷ ⴰⵔⴻⴷⴷⴵⴻⵖ ⵜⵉⵖⵉⵜ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⴽⵙⴻⵖ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵉⴼⴻⵀⵀⴰⵎⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("C11_20","076_1_20","1CO","1","20","20","ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵎⵉⵖⵉⵙ? ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ? ⵎⴰⵏⵉ ⵉⴵⴰ ⴱⵓ-ⵓⵎⵃⴰⵔⵡⴻⴹ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ? ⵎⴰ ⵡⴰⵔ ⵉⵙⵙⵛⴻⵏ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⵜⵉⵖⵉⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ? ");
INSERT INTO rift_vpl VALUES ("C11_21","076_1_21","1CO","1","21","21","ⵎⵉⵏⵣⵉ ⴷⵉ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷⴷⵓⵏⴻⵛⵜ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏ ⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⵖⵉⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴹⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏ ⵜⴱⴰⵔⵔⴻⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("C11_22","076_1_22","1CO","1","22","22","ⵎⵉⵏⵣⵉ ⵓⴷⴰⵢⴻⵏ ⵜⵜⴰⵔⴻⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵓ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⴰⵔⴻⵣⵣⵓⵏ ⵜⵉⵖⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("C11_23","076_1_23","1CO","1","23","23","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⵡⵓⴷⴰⵢⴻⵏ, ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵉ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C11_24","076_1_24","1CO","1","24","24","ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ, ⴰⵎ ⵡⵓⴷⴰⵢⴻⵏ ⴰⵎ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C11_25","076_1_25","1CO","1","25","25","ⵎⵉⵏⵣⵉ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵎⵉⵖⵉⵙⵜ ⵅ ⵉⵡⴷⴰⵏ, ⵓ ⵜⵓⴹⵄⴻⴼⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵊⵀⴻⴷ ⵅ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C11_26","076_1_26","1CO","1","26","26","ⵅⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⵅⵣⴰⵔⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰⵎ ⵖⴰⵔ ⵡⴰⵙⵙ ⵏ ⵜⵍⴰⵖⵉⵜ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴱⵏⴰⴷⴻⵎ, ⵏⵉⵖ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ, ⵏⵉⵖ ⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵚⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C11_27","076_1_27","1CO","1","27","27","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⴼⴰⵔⵣ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴻⵃⵛⴻⵎ ⵉⵎⵉⵖⵉⵙⴻⵏ, ⵓⵛⴰ ⵉⵎⵓⴹⵄⵉⴼⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵉⴼⴰⵔⵣ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵙⵙⴻⵃⵛⴻⵎ ⴰⵢⵜ ⵏ ⴱⵓ-ⵚⵚⵓⵍⵟⴰ. ");
INSERT INTO rift_vpl VALUES ("C11_28","076_1_28","1CO","1","28","28","ⵓⵛⴰ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴰⵎ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵛⴰ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵏ, ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴷ ⵛⴰ, ⴰⵇⴰ ⵉⴼⴰⵔⵣ ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴹⴻⵍ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("C11_29","076_1_29","1CO","1","29","29","ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏ ⵡⴻⵢⵙⵓⵎ, ⵡⴰⵔ ⵉⵜⵜⴼⴻⵢⵢⴻⵛ ⵛⴰ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C11_30","076_1_30","1CO","1","30","30","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰⵎ ⵣⵣⴰⵢⴻⵙ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴷⴻⵡⵍⴻⵏ ⴷ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷ ⵜⵓⵇⴻⴷⴷⵙⵉ ⴷ ⵓⵙⴻⵏⵊⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C11_31","076_1_31","1CO","1","31","31","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ, ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⴷⵉ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("C12_1","076_2_1","1CO","2","1","1","ⴰ ⴰⵢⵜⵎⴰ, ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵖ ⵖⴰⵔⵡⴻⵎ, ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵙⵙⵉⵔⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⴱⴻⵣⵣⴰⵃⵜ ⵏ ⵡⴰⵡⴰⵍ ⵏⵉⵖ ⵙ ⵜⵉⵖⵉⵜ, ");
INSERT INTO rift_vpl VALUES ("C12_2","076_2_2","1CO","2","2","2","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵓⵖⴰ ⵄⴻⵡⵡⵍⴻⵖ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⴻⵙⵙⵏⴻⵖ ⵛⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⵎⵖⵉⵔ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("C12_3","076_2_3","1CO","2","3","3","ⵜⵓⵖⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵓⵇⴷⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C12_4","076_2_4","1CO","2","4","4","ⵜⴰⴱⵔⴰⵜ ⵉⵏⵓ ⴷ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵉⵏⵓ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵏⵜ-ⵉ-ⴷⴷ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵣⴻⵡⵡⵇⴻⵏ ⵏ ⵜⵉⵖⵉⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵙ ⵡⴻⵙⵛⴰⵏ ⵏ ⴰⵔⵔⵓⵃ ⴷ ⵊⵊⴻⵀⴷ, ");
INSERT INTO rift_vpl VALUES ("C12_5","076_2_5","1CO","2","5","5","ⵃⵉⵎⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉ ⵛⴰ ⵅ ⵜⵉⵖⵉⵜ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵅ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C12_6","076_2_6","1CO","2","6","6","ⵎⴰⵛⴰ ⵏⴻⵙⵙⴰⵡⴰⵍ ⵙ ⵜⵉⵖⵉⵜ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵡⴹⴻⵏ, ⴰⵇⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵖⵉⵜ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵏⵉⵖ ⵏ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⵟⵟⵍⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C12_7","076_2_7","1CO","2","7","7","ⵎⴰⵛⴰ ⵏⴻⵙⵙⴰⵡⴰⵍ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵉⵊⵊ ⵏ ⵙⵙⵉⵔⵔ ⵉ ⵜⵓⵖⴰ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⵣⴰⵔ ⵉⴼⴰⵔⵣ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⵉ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵖ ⵇⴱⴻⵍ ⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵣⵣⵎⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("C12_8","076_2_8","1CO","2","8","8","ⵡⴰ ⴷ ⵙⵙⵉⵔⵔ ⵏⵏⵉ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵙⵙⵏⴻⵏ ⵜ, ⵉⵍⵉ ⵡⴰⵔ ⵚⴻⵍⵍⴱⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵙⵉⴷⵉ ⵏ ⵓⵄⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("C12_9","076_2_9","1CO","2","9","9","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵎⵉⵏ ⵡⴰⵔ ⵜⴻⵥⵔⵉ ⵜⵉⵟⵟ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⵍⵉ ⵓⵎⴻⵣⵣⵓⵖ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵢⵓⴷⵉⴼⴻⵏ ⵛⴰ ⵖⴰⵔ ⵡⵓⵍ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("C12_10","076_2_10","1CO","2","10","10","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵎⵎⴻⵍ ⴰⵏⴻⵖ ⵜ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⵔⵔⵓⵃ ⵜⴰⵔⴻⵣⵣⵓ ⴽⵓⵍⵛⵉ ⵓⵍⴰ ⴷ ⵍⴰⴵⴰⵖ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C12_11","076_2_11","1CO","2","11","11","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉ ⵉⵙⵙⵏⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⴱⵏⴰⴷⴻⵎ ⵎⵖⵉⵔ ⴰⵔⵔⵓⵃ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⴵⴰⵏ. ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵎⵖⵉⵔ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C12_12","076_2_12","1CO","2","12","12","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⴽⵙⵉ ⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C12_13","076_2_13","1CO","2","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵡⴰⵍⴻⵏ ⵉ ⵣⵉ ⵏⴻⵙⵙⴰⵡⴰⵍ, ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵜⵖⵓⵔⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⵖⵉⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⴷ ⵜⵖⵓⵔⵉ ⵣⵉ ⴰⵔⵔⵓⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵇⵓⴷⴷⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⵔⵓⵃ ⴰⴽ-ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("C12_14","076_2_14","1CO","2","14","14","ⵎⴰⵖⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵇⴻⴱⴱⴻⵍ ⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⵔⵓⵃ, ⵎⵉⵏⵣⵉ ⵉⵃⴻⵙⴱ ⵉ-ⵜ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⴼⵀⴻⵎ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴼⴰⵔⵣ ⵙ ⴰⵔⵔⵓⵃ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("C12_15","076_2_15","1CO","2","15","15","ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⴰⵔⵔⵓⵃⴰⵏⵉ ⴰⵇⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴼⴰⵔⵣ ⴽⵓⵍⵛⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵅⴰⵙ ⵉⵃⴻⴽⴽⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("C12_16","076_2_16","1CO","2","16","16","ⵎⵉⵏⵣⵉ ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵅⴻⵎⵎⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵍⴰⵎⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⴻⵍⵎⴻⴷ? ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⴰⵅⴻⵎⵎⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C13_1","076_3_1","1CO","3","1","1","ⴰ ⴰⵢⵜⵎⴰ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵎ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⵓⵃ, ⵎⴰⵛⴰ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵢⵙⵓⵎ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵀⴰ, ⴰⵎⴻⵛⵏⴰⵡ ⵉⵙⴻⵢⵎⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C13_2","076_3_2","1CO","3","2","2","ⴰⵇⴰ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⴰⵖⵉ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵍⴻⵇⵇⵉⵎ ⵉⵎⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ, ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ ⵓ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("C13_3","076_3_3","1CO","3","3","3","ⵙ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ. ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⴷⵉⵏ ⵄⴰⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵍⴻⵃⵙⴻⴷ ⴷ ⵉⵎⴻⵏⵖⴰⵏ ⴷ ⵓⵎⵙⴻⴱⴹⵉ, ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵄⴰⴷ ⵏ ⴷⴷⴰⵜ ⵏⵉⵖ ⵜⴻⴳⴳⵓⵔⴻⵎ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ? ");
INSERT INTO rift_vpl VALUES ("C13_4","076_3_4","1CO","3","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵣⵉ ⴱⵓⵍⵓⵙ!’ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵣⵉ ⴰⴱⵓⵍⵍⵓⵙ!’, ⵎⴰ ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⴷⴷⴰⵜ? ");
INSERT INTO rift_vpl VALUES ("C13_5","076_3_5","1CO","3","5","5","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⵉⵄⵏⴰ ⴰⴱⵓⵍⵍⵓⵙ ⵓ ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵓⵍⵓⵙ? ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⵖⵉⵔ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵣⵉ ⵜⴷⴻⵡⵍⴻⵎ ⵜⵓⵎⵏⴻⵎ, ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C13_6","076_3_6","1CO","3","6","6","ⴰⵇⴰ ⵏⴻⵛⵛ ⵥⵥⵓⵖ, ⴰⴱⵓⵍⵍⵓⵙ ⵉⵙⵙⵓ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵖⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("C13_7","076_3_7","1CO","3","7","7","ⵅⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵥⵥⵓⵏ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵛⴰ ⵓⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵙⵓⵏ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵖⴻⵎⵎⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C13_8","076_3_8","1CO","3","8","8","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵥⵥⵓⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵙⵙⵓⵏ ⴷ ⵉⵊⵊⴻⵏ, ⵡⴰⵅⵅⴰ ⴽⵓⵍ ⵉⵊⵊ ⵜⴻⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C13_9","076_3_9","1CO","3","9","9","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⴼⴻⴵⴰⵃⵜ ⴷ ⵍⴻⴱⵏⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴻⴵⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("C13_10","076_3_10","1CO","3","10","10","ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵏⴻⵛⵛ, ⴰⵎ ⵍⴻⵎⵄⴻⴵⴻⵎ ⴰⴱⴻⵏⵏⴰⵢ ⴰⵎⵉⵖⵉⵙ, ⴳⴳⵉⵖ ⴷⵙⴰⵙ ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵅⴰⵙ ⵉⴱⵏⴰ. ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵃⴹⴰ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⴱⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C13_11","076_3_11","1CO","3","11","11","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⴳⴳ ⴷⵙⴰⵙ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵏⵏⵉ ⵉⵎⵎⴰⵔⵙⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C13_12","076_3_12","1CO","3","12","12","ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⴱⵏⴰ ⵃⴻⴷ ⵅ ⴷⵙⴰⵙ ⵏⵏⵉ ⵙ ⵡⵓⵔⴻⵖ, ⵏⵏⵓⵇⴰⵔⵜ, ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ, ⵜⴻⴼⵍⴰⵡⵜ. ⵍⵓⵎ ⵏⵉⵖ ⵙ ⵓⵅⴻⵛⵅⵓⵛ, ");
INSERT INTO rift_vpl VALUES ("C13_13","076_3_13","1CO","3","13","13","ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵜⴱⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ ⴰⴷ ⵜⵜ ⵉⵙⵙⵛⴻⵏ. ⵎⵉⵏⵣⵉ ⵙ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⴽⵓⵍ ⵉⵊⵊ, ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⵜⵜ ⵜⴼⴰⵔⵣ. ");
INSERT INTO rift_vpl VALUES ("C13_14","076_3_14","1CO","3","14","14","ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵍⴻⴱⵏⵉ ⵉ ⵅⴰⵙ ⵜⵓⵖⴰ ⵉⴱⵏⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵟⵟⴻⴼ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("C13_15","076_3_15","1CO","3","15","15","ⵓ ⵎⴰⵍⴰ ⵜⴻⵛⵎⴻⴹ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⴱⵓ ⵜⴰⵅⴻⵙⵙⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵏⵊⴻⵎ ⴰⵅⵎⵉ ⵉⴽⴽⴰ ⵜⵉⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("C13_16","076_3_16","1CO","3","16","16","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵜⴻⴵⴰⵎ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴱⴻⵍⵍⵉ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("C13_17","076_3_17","1CO","3","17","17","ⵎⴰⵍⴰ ⵢⴰⵔⴻⵢⵢⴻⴱ ⵃⴻⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜ ⵢⴰⵔⴻⵢⵢⴻⴱ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵏⵏⵉ ⵜⴻⴵⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵜⵇⴻⴷⴷⴻⵙ ⵉ ⵜⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("C13_18","076_3_18","1CO","3","18","18","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵉⵅⴻⴷⴷⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ! ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵎⵉⵖⵉⵙ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵉⵖⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("C13_19","076_3_19","1CO","3","19","19","ⵎⵉⵏⵣⵉ ⵜⵉⵖⵉⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵜⴻⴵⴰ ⴷ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⵉⵟⵟⴻⴼ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ!”, ");
INSERT INTO rift_vpl VALUES ("C13_20","076_3_20","1CO","3","20","20","ⵓⵛⴰ ⵄⴰⵡⴻⴷ: “ⵙⵉⴷⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷ ⵍⴱⴰⵟⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("C13_21","076_3_21","1CO","3","21","21","ⵙ ⵓⵢⴰ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵙⵙⴻⵎⵖⴰⵔⵉ ⵛⴰ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C13_22","076_3_22","1CO","3","22","22","ⵎⴰ ⴷ ⴱⵓⵍⵓⵙ, ⵏⵉⵖ ⴷ ⴰⴱⵓⵍⵍⵓⵙ, ⵏⵉⵖ ⴷ ⴽⵉⴼⴰ, ⵏⵉⵖ ⴷ ⴷⴷⵓⵏⴻⵛⵜ, ⵏⵉⵖ ⴷ ⵜⵓⴷⴰⵔⵜ, ⵏⵉⵖ ⴷ ⵍⵎⴻⵡⵜ, ⵏⵉⵖ ⴷ ⵉⴹⴰ ⵏⵉⵖ ⴷ ⵜⵉⵡⴻⵛⵛⴰ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C13_23","076_3_23","1CO","3","23","23","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵏ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⵍⵎⴰⵙⵉⵃ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C14_1","076_4_1","1CO","4","1","1","ⴻⵊⵊ ⴰⵏⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵃⵙⴻⴱ ⵣⵣⴰⵢⵡⴻⵎ ⴰⵎ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵓ ⴰⵎ ⵉⵡⴽⵉⵍⴻⵏ ⵏ ⵍⴻⵙⵔⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C14_2","076_4_2","1CO","4","2","2","ⵅⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵎⴽⵓⵍ ⴰⵡⴽⵉⵍ ⴰⴷ ⵉⵜⵜⵡⴰⴼ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("C14_3","076_4_3","1CO","4","3","3","ⵏⴻⵛⵛ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵛⵇⵉ ⵛⴰ ⵎⴰⵍⴰ ⵜⵜⵡⴰⵃⴻⴽⵎⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ ⵏⵉⵖ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖⵏⵉ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⵃⴻⴽⴽⵎⴻⵖ ⵛⴰ ⵅ ⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C14_4","076_4_4","1CO","4","4","4","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵓⵛⵉⵖ ⵙ ⵛⴰ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⴷⴰⵢⵉ, ⵎⴰⵛⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵖ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵙⵉⴷⵉ ⴷ ⵍⵇⴰⴹⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C14_5","076_4_5","1CO","4","5","5","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵃⴻⴽⴽⵎⴻⵎ ⵛⴰ ⵅ ⵡⴰⵍⵓ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵖⴰⵔ ⵜⴼⴰⵡⵜ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⴹⵀⴰⵔⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍⴰⵡⴻⵏ. ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C14_6","076_4_6","1CO","4","6","6","ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⵉⵡⵢⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵅⴰⴼⵉ ⵓ ⵅ ⴰⴱⵓⵍⵍⵓⵙ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵏⴻⵖ ⵜⵍⴻⵎⴷⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵅⴰⵔⵔⵉⵚⴻⵎ ⵛⴰ ⴱⴰⵔⵔⴰ ⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⵉⵔⴰ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴹⵉⴷⴷ ⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C14_7","076_4_7","1CO","4","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴷⴰⵢⴻⴽ? ⵏⵉⵖ ⵎⵉⵏ ⵖⴰⵔⴻⴽ ⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵟⵟⵉⴼⴻⴷ? ⵓⵛⴰ ⵎⴰⵍⴰ ⵜᵉⵟⵟⴼⴻⴷ ⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⵛⴻⵏⵏⵄⴻⴷ ⴰⵅⵎⵉ ⵡⴰⵔ ⵜ ⵜᵉⵟⵟⵉⴼⴻⴷ ⵛⴰ? ");
INSERT INTO rift_vpl VALUES ("C14_8","076_4_8","1CO","4","8","8","ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵜⴻⵊⵊⵉⵡⵏⴻⵎ ⵓ ⵜⴷⴻⵡⵍⴻⵎ ⵜᵉⵜⵜⴻⵊⵊⴰⵔⴻⵎ, ⵓⵛⴰ ⴱⵍⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵜⵃⴻⴽⴽⵎⴻⵎ ⴰⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ. ⵎⴻⵄⵍⵉⴽ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⴽⴽⵎⴻⵎ ⴰⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⴰⴷ ⵢⵉⵍⵉ ⵏⴻⵛⵛⵉⵏ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵃⴽⴻⵎ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("C14_9","076_4_9","1CO","4","9","9","ⵎⵉⵏⵣⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵏⴻⵖ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵔⵔⵓⵙⵓⵍ, ⴰⵅⵎⵉ ⵅⴰⵏⴻⵖ ⵃⴻⴽⵎⴻⵏ ⵙ ⵍⵎⴻⵡⵜ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⴷⵡⴻⵍ ⴷ ⴰⴼⵓⵔⵔⴻⵊ ⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵓ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C14_10","076_4_10","1CO","4","10","10","ⵏⴻⵛⵛⵉⵏ ⵏⴻⴵⴰ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰⵎ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ⵏⴻⵛⵛⵉⵏ ⵏⵀⴻⵢⵢⴻⴼ, ⴽⴻⵏⵏⵉⵡ ⵜⵊⴻⵀⴷⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵛⴻⵏⵏⵄⴻⵎ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C14_11","076_4_11","1CO","4","11","11","ⴰⵍ ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛⵉⵏ ⴷⴰⵢⵏⴻⵢ ⵍⴰⵥ ⴷ ⵓⴼⴰⴷⵉ ⴷ ⵜⵓⵄⴰⵔⵢⴻⵏⵜ, ⵛⵛⴰⵜⴻⵏ ⴰⵏⴻⵖ, ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⵣⴻⴷⴷⵉⵖⵜ, ");
INSERT INTO rift_vpl VALUES ("C14_12","076_4_12","1CO","4","12","12","ⵏⴰⵔⴻⴱⴱⴻⵔ ⴰⵎ ⵏⵅⴻⴷⴷⴻⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ. ⵏⵉⵜⵏⵉ ⵙⵙⴻⵃⵇⴰⵔⴰⵏ ⴰⵏⴻⵖ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴱⴰⵔⴻⴽ, ⴷⴰⵔⵔⵛⴻⵏ ⵅⴰⵏⴻⵖ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴽⴻⵙⵙⵉ ⴰⵔⵎⴻⵃ, ");
INSERT INTO rift_vpl VALUES ("C14_13","076_4_13","1CO","4","13","13","ⵛⴻⵇⵇⴼⴻⵏ ⴷⴰⵢⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵜⵜⵃⴻⵛⵛⴻⵎ ⵉ-ⵜⴻⵏ ⴷⵉ ⵍⵅⵉⵔ. ⴰⵍ ⵍⴻⵅⵅⵓ ⵏⴻⴷⵡⴻⵍ ⴰⵎ ⵜⵣⵓⴱⴰⵍⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⵎ ⵉⴼⵓⵔⴰⴹ ⵏ ⵎⴰⵔⵔⴰ, ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("C14_14","076_4_14","1CO","4","14","14","ⵡⴰⵔ ⵜⵜⴰⵔⵉⵖ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴻⵃⵛⵉⵎⴻⵖ, ⵎⴰⵛⴰ ⵜⵜⵣⵉⵢⵢⴰⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵜⴰⵔⵡⴰ ⵉⵄⵉⵣⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C14_15","076_4_15","1CO","4","15","15","ⵡⴰⵅⵅⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵖⴰⵔⵡⴻⵎ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵢⵉⵏⵏⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵢⴰⵔⴻⴱⴱⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴰⵟⵟⴰⵙ ⵏ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵊⵊⵉⵖ-ⴷⴷ ⴽⴻⵏⵏⵉⵡ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵙ ⵍ’ⵉⵏⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("C14_16","076_4_16","1CO","4","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⴰⵔⵔⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ: ⴰⵔⴻⵡⵙⴻⵎ ⴰⵢⵉ! ");
INSERT INTO rift_vpl VALUES ("C14_17","076_4_17","1CO","4","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴷ ⴰⵡⴻⵎ ⵉⵙⵙⴼⴻⴽⴽⴰⵔ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵏ ⵙⵙⴻⵍⵎⴰⴷⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C14_18","076_4_18","1CO","4","18","18","ⵎⴰⵛⴰ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ ⴰⵇⴰ ⵜⵜⵏⴻⴼⴼⴰⵅⴻⵏ, ⴰⵅⵎⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵜⵜⵉⵡⵉⴹⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("C14_19","076_4_19","1CO","4","19","19","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵅⵙ ⵙⵉⴷⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ. ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵖ ⵣⴻⵄⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⴰⵡⴰⵍⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C14_20","076_4_20","1CO","4","20","20","ⵎⵉⵏⵣⵉ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ, ⵎⴰⵛⴰ ⴷⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("C14_21","076_4_21","1CO","4","21","21","ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ? ⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵙ ⵡⴻⵄⵎⵓⴷ ⵏⵉⵖ ⵙ ⵜⴰⵢⵔⵉ ⵓ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵜⴻⵎⵀⵉⵏⵜ? ");
INSERT INTO rift_vpl VALUES ("C15_1","076_5_1","1CO","5","1","1","ⵍⵃⴰⵙⵓⵍ, ⵉⵜⵜⵡⴰⵏⵏⴰ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵓ ⴰⵏⴻⵛⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵇⴰⵄ ⵊⴰⵔ ⵍⴽⵓⴼⴼⴰⵔ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵖⴰⵔⴻⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C15_2","076_5_2","1CO","5","2","2","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵓⴼⴼⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵡⴰⵅⵅⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⴰⴷ ⵜⵛⴻⴹⵏⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵃⴻⵢⵢⴹⴻⵎ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C15_3","076_5_3","1CO","5","3","3","ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴰⴳⴳⵯⴻⵊⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⵇⴰ ⴰⵢⵉ ⵃⴹⴰⵔⴻⵖ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵓⵛⴰ ⴰⵇⴰ ⵃⴻⴽⵎⴻⵖ ⴰⵅⵎⵉ ⵃⴹⴰⵔⴻⵖ ⵅ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C15_4","076_5_4","1CO","5","4","4","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵎⵓⵏⴻⵎ ⵎⴰⵔⵔⴰ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵏⴻⵛⵛ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("C15_5","076_5_5","1CO","5","5","5","ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜ ⵜⵙⴻⵍⵍⵎⴻⵎ ⵉ ⵛⵛⵉⵟⴰⵏ ⵉ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⴷⴰⵔ ⴷⵉ ⴰⵔⵔⵓⵃ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C15_6","076_5_6","1CO","5","6","6","ⵡⴰⵔ ⴷⴷ ⵅⴰⵡⴻⵎ ⵢⵓⵙⵉ ⵓⴼⴻⵢⵢⴻⵛ! ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵛⵡⴰⵢⵜ ⵏ ⵡⴻⵏⵜⵓⵏ ⵉⵙⵙⵎⴻⵎⵎ ⵎⴰⵔⵔⴰ ⵜⴰⵄⴻⴱⴱⵓⵣⵜ ⵏ ⵡⴰⵔⴻⵛⵜⵉ? ");
INSERT INTO rift_vpl VALUES ("C15_7","076_5_7","1CO","5","7","7","ⵙⵉⵣⴻⴷⴳⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵡⴻⵏⵜⵓⵏ ⴰⵇⴷⵉⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵛⵜ ⵏ ⵍⵄⴻⵊⵏⴻⵜ ⵏ ⵡⴰⵔⴻⵛⵜⵉ ⵏ ⵊⴷⵉⴷ. ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵖⵔⵓⵎ ⴱⵍⴰ ⴰⵏⵜⵓⵏ, ⵎⵉⵏⵣⵉ ⵜⴰⵖⴰⵔⵚⵜ ⵏⵏⴻⵖ ⵏ ⵓⵙⴻⵄⴷⵓ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵉ ⵏⴻⵛⵛⵉⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C15_8","076_5_8","1CO","5","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵄⴻⵢⵢⴻⴷ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵡⴻⵏⵜⵓⵏ ⴰⵇⴷⵉⵎ ⵏⵉⵖ ⵙ ⵡⴻⵏⵜⵓⵏ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⵙ ⵡⴻⵏⵜⵓⵏ ⵏ ⵍⴻⵚⴼⴰⵢⴻⵜ ⴷ ⵜⵇⴻⴷⴷⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("C15_9","076_5_9","1CO","5","9","9","ⴰⵇⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⴷⵉ ⵜⴻⴱⵔⴰⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⵜⵄⴰⵛⴰⵔⴻⵎ ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ");
INSERT INTO rift_vpl VALUES ("C15_10","076_5_10","1CO","5","10","10","ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵏⵉⵖ ⵅ ⵉⴹⴻⵎⵎⴰⵄⴻⵏ ⵏⵉⵖ ⵅ ⵉⴱⴻⵄⵄⴰⵊ ⵏⵉⵖ ⵅ ⵢⵉⵏⵏⵉ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵎⴰⵍⴰ ⴰⵎⵎⵓ, ⵉⵍⵉ ⴰⴷ ⵜⴻⴼⴼⵖⴻⵎ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("C15_11","076_5_11","1CO","5","11","11","ⵎⴰⵛⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵍⴻⵅⵅⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵄⴰⵛⴰⵔⴻⵎ ⵛⴰ ⵃⴻⴷ, ⵡⴰⵅⵅⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵓⵎⴰ, ⵎⴰⵛⴰ ⴰⵇⴰ-ⵜ ⴷ ⴱⵓ-ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵏⵉⵖ ⴷ ⴰⴹⴻⵎⵎⴰⵄ, ⵏⵉⵖ ⴷ ⵡⴻⵏⵏⵉ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵏⵉⵖ ⴷ ⴰⵎⵛⴻⵇⵇⴰⴼ, ⵏⵉⵖ ⴷ ⴰⵙⴽⴰⵔⵊⵉ, ⵏⵉⵖ ⴷ ⴰⵛⴻⴼⴼⴰⵔ. ⴰⴽ-ⴷ ⵃⴻⴷ ⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⴽⵉⵙ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵄⴰⴷ ⴰⵖⵔⵓⵎ! ");
INSERT INTO rift_vpl VALUES ("C15_12","076_5_12","1CO","5","12","12","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵍⵃⴻⵇⵇ ⵖⴰⵔⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵖ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴱⴰⵔⵔⴰ? ⵃⴻⴽⴽⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴰⵅⴻⵍ! ");
INSERT INTO rift_vpl VALUES ("C15_13","076_5_13","1CO","5","13","13","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴱⴰⵔⵔⴰ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵃⴽⴻⵎ. ⵙⵃⴻⵢⵢⴷⴻⵎ ⵅⴰⵡⴻⵎ ⴰⵄⴻⴼⴼⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("C16_1","076_6_1","1CO","6","1","1","ⵎⴰ ⵉⵣⵄⴻⵎ ⵃⴻⴷ ⵣⵣⴰⵢⵡⴻⵎ, ⵅⵎⵉ ⵖⴰⵔⴻⵙ ⵛⵛⵔⴻⵄ ⴰⴽ-ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵃⴽⴻⵎ ⵣⵣⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵣⴰⵜ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C16_2","076_6_2","1CO","6","2","2","ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⴷⴷⵓⵏⴻⵛⵜ? ⵓⵛⴰ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⵅⴻⵏⵏⵉ ⴰⴷ ⵜⵄⴻⴷⵍⴻⵎ ⴷⴷⵄⴰⵡⵉ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("C16_3","076_6_3","1CO","6","3","3","ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⵏⴻⵃⴽⴻⵎ ⵅ ⵍⵎⴰⵍⴰⴽⴰⵜ? ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⴽⵜⴰⵔ ⵉ ⵖⴰ ⵏⴻⵃⴽⴻⵎ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("C16_4","076_6_4","1CO","6","4","4","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵛⵜ ⵏ ⴷⴷⴻⵄⵡⴻⵜ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⵜⵓⴷⴰⵔⵜ-ⴰ, ⵎⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴷⵔⵓⵙ ⵏ ⵓⵡⴻⵇⵇⴰⵔ ⵡⴰⵀⴰ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵃⵉⵎⴰ ⴰⴷ ⵃⴻⴽⵎⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C16_5","076_6_5","1CO","6","5","5","ⵇⵇⴰⵔⴻⵖ ⴰⵡⴻⵎ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⵙⴻⴹⵃⴰⵎ. ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏⵏⵉ ⵃⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷ ⴰⵎⵉⵖⵉⵙ ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵃⴽⴻⵎ ⵊⴰⵔ ⵜⴰⵡⵎⴰⵜ ⴷ ⵓⵎⴰⵙ? ");
INSERT INTO rift_vpl VALUES ("C16_6","076_6_6","1CO","6","6","6","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵉⵊⵊ ⵏ ⵜⴰⵡⵎⴰⵜ ⴰⴷ ⵉⵛⴰⵔⵔⴻⵄ ⴰⴽ-ⴷ ⵓⵎⴰⵙ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("C16_7","076_6_7","1CO","6","7","7","ⵙ ⵓⵢⴰ ⵜⵃⴻⴽⴽⵎⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴻⵎⵛⴰⵔⵔⴰⵄⴻⵎ ⵊⴰⵔ ⴰⵡⴻⵎ. ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵇⴻⴱⴱⵍⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴹⴻⴵⴻⵏ? ⵎⴰⵢⴻⵎⵎⵉ ⵡⴰⵔ ⵜⵇⴻⴱⴱⵍⴻⵎ ⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴻⵛⵛⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C16_8","076_6_8","1CO","6","8","8","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓⵛⴰ ⵜᵉⵜⵜⵖⴻⵛⵛⴰⵎ ⵄⴰⴷ ⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C16_9","076_6_9","1CO","6","9","9","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵡⴰⵔ ⵡⴰⵔⵔⵜⴻⵏ ⵛⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵡⴰⵔ ⵜⵜⵔⴰⵃⴻⵎ ⵛⴰ ⴷⵉ ⵖⴰⵍⴰⵟ! ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵏⵉⵖ ⵉⵏⵏⵉ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵏⵉⵖ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵣⵣⵉⵏⴰ, ⵏⵉⵖ ⵉⵏⵏⵉ ⵉⵙⵙⴻⵅⵙⴰⵔⴰⵏ, ⵏⵉⵖ ⵣⵣⵡⴰⵎⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("C16_10","076_6_10","1CO","6","10","10","ⵏⵉⵖ ⵉⴹⴻⵎⵎⴰⵄⴻⵏ, ⵏⵉⵖ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ, ⵏⵉⵖ ⵉⵙⴽⴰⵔⵊⵉⵢⵢⴻⵏ, ⵏⵉⵖ ⵉⵎⵛⴻⵇⵇⴰⴼⴻⵏ ⵓⵍⴰ ⴷ ⵉⴱⴻⵄⵄⴰⵊⴻⵏ ⵡⴰⵔ ⵡⴰⵔⵔⵜⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C16_11","076_6_11","1CO","6","11","11","ⵜⵓⵖⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵍⴻⵙⵇⴻⵏⵜ ⵖⴰⵔ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵔⴷⴻⵎ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵎ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵎ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C16_12","076_6_12","1CO","6","12","12","ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵃⴻⴵⵍⴻⵏⵜ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵏⴻⴼⴼⵄⴻⵏⵜ. ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵃⴻⴵⵍⴻⵏⵜ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⴹⴻⴱⴱⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C16_13","076_6_13","1CO","6","13","13","ⵎⴰⵛⵛⴰ ⵉ ⵓⵄⴻⴷⴷⵉⵙ ⵓⵛⴰ ⴰⵄⴻⴷⴷⵉⵙ ⵉ ⵎⴰⵛⵛⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵜⴻⵏ ⵉⴱⴻⵟⵟⴻⵍ ⵙ ⵜⵢⵓⵢⴰ. ⵎⴰⵛⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵎⴰⵛⴰ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓⵛⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C16_14","076_6_14","1CO","6","14","14","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C16_15","076_6_15","1CO","6","15","15","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵡⴻⵎ ⴵⴰⵏⵜ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ? ⵎⴰ ⴰⴷ ⴽⵙⵉⵖ ⵅⴻⵏⵏⵉ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⴰⵖⴻⵣⴷⵉⵙ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ? ⵄⴻⵎⵎⴰⵔⵚ! ");
INSERT INTO rift_vpl VALUES ("C16_16","076_6_16","1CO","6","16","16","ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵡⵉ ⵉⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⴰⴽⵉⴷⴻⵙ? ⵎⵉⵏⵣⵉ ⵉⵇⵇⴰⵔ: ‘ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ.’ ");
INSERT INTO rift_vpl VALUES ("C16_17","076_6_17","1CO","6","17","17","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵎⵓⵏⴻⵏ ⴰⴽ-ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C16_18","076_6_18","1CO","6","18","18","ⴰⵔⴻⵡⵍⴻⵎ ⵣⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ. ⴽⵓⵍ ⵛⴰ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵉⵜⵜⴻⴳⴳ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⴱⴰⵔⵔⴰ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⴼⵙⴰⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵅⴻⵟⵟⴰ ⴹⵉⴷⴷ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C16_19","076_6_19","1CO","6","19","19","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴰⵢⵡⴻⵎ ⵉⴵⴰⵏ, ⵡⴻⵏⵏⵉ ⵉ ⵟⵟⴼⴻⵎ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("C16_20","076_6_20","1CO","6","20","20","ⴰⵇⴰ ⵜⴻⵎⵎⴻⵙⵖⴻⵎ-ⴷⴷ ⵙ ⵜⵜⴰⵎⴰⵏ. ⵙⴻⵎⵖⴰⵔⴻⵎ ⵅⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵓ ⴷⵉ ⴰⵔⵔⵓⵃ ⵏⵡⴻⵎ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C17_1","076_7_1","1CO","7","1","1","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵜⵓⵔⵉⵎ, ⴰⵇⴰ ⵎⵍⵉⵃ ⵉ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵃⵉⴷⵉ ⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C17_2","076_7_2","1CO","7","2","2","ⵎⴰⵛⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴽⵓⵍ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵜᵉⵟⵟⴻⴼ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_3","076_7_3","1CO","7","3","3","ⴻⵊⵊ ⴰⵔⵢⴰⵣ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵜⴰⵢⵔⵉ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵢⵓⵙⵉⵏ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_4","076_7_4","1CO","7","4","4","ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴹⴻⴱⴱⴰⵔⵉ ⵛⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ. ⵓⵛⴰ ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵜⵜⴹⴻⴱⴱⴰⵔⵉ ⵛⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_5","076_7_5","1CO","7","5","5","ⵡⴰⵔ ⵜⵜ ⵇⴻⵟⵟⵄⴻⵎ ⵛⴰ ⵅ ⵡⴰⵢⴰⵡⵢⴰ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵜⴻⴽⴽⵙⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵛⴰ ⵏ ⵓⵎⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵖⵍⴻⵎ ⵙ ⵓⵥⵓⵎⵎⵉ ⴷ ⵜⵥⴰⴵⵉⵜ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⵓⵏⴻⵎ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⴰⵔⵉⵇⵇⵉ ⵉ ⵍⴻⵎⵔⴰⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵊⴰⵔⵔⵉⴱ ⵛⵛⵉⵟⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴻⵥⵔⵉ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C17_6","076_7_6","1CO","7","6","6","ⵇⵇⴰⵔⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵍⵓⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("C17_7","076_7_7","1CO","7","7","7","ⵅⵙⴻⵖ ⵄⴰⴷ ⵎⵍⵉⵃ ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⵎ ⵏⴻⵛⵛ ⴷⵉ ⵜⴰⵣⴷⵓⴳⵉ, ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵖⴰⵔⴻⵙ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵉⵊⵊⴻⵏ ⴰⵎⵎⵓ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("C17_8","076_7_8","1CO","7","8","8","ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⵜⴻⵎⵖⴰⵔⵜ ⵓ ⵉ ⵜⵉⵊⵊⴰⵍ ⵇⵇⴰⵔⴻⵖ, ⴰⵇⴰ ⵎⵍⵉⵃ ⵉ ⵏⵉⵜⵏⵉ ⵎⴰⵍⴰ ⵇⵇⵉⵎⴻⵎ ⴰⵎ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("C17_9","076_7_9","1CO","7","9","9","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵟⵟⴼⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵎⴻⵍⵛⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⵃⵍⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵅ ⵡⴻⵛⵎⴰⴹ ⵏ ⵏⵏⴻⵛⵡⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C17_10","076_7_10","1CO","7","10","10","ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵢⵉⵡⵢⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵓⵎⵓⵔⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴱⴻⵍⵍⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜⴱⴻⵟⵟⵉ ⵅ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("C17_11","076_7_11","1CO","7","11","11","ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⴻⴱⴹⴰ, ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴱⵍⴰ ⴰⵔⵢⴰⵣ, ⵏⵉⵖ ⴰⴷ ⵜᵉⵎⵎⴻⵙⵙⴻⵚⵍⴻⵃ ⴰⴽ-ⴷ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_12","076_7_12","1CO","7","12","12","ⵅⴻⵏⵏⵉ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⵇⵇⴰⵔⴻⵖ ⵏⴻⵛⵛ, ⵡⴰⵔ ⵉⴵⵉ ⵙⵉⴷⵉ: ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵜⴰⵡⵎⴰⵜ ⵖⴰⵔⴻⵙ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵉⵜⵜⵉⵎⵏⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵇⴱⴻⵍ ⴰⴷ ⵜⴻⵣⴷⴻⵖ ⴰⴽⵉⴷⴻⵙ, ⵡⴰⵔ ⵜⵜ ⵉⵏⴻⵟⵟⴰⵔ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_13","076_7_13","1CO","7","13","13","ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⵅⵙ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵣⴷⴻⵖ, ⵡⴰⵔ ⵜⵙⴻⵎⵎⴻⵃ ⵛⴰ ⵏⴻⵜⵜⴰⵜ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_14","076_7_14","1CO","7","14","14","ⵙ ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ, ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵜᵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⴷⴻⴳ ⵡⴻⵔⵢⴰⵣ ⵉ ⵢⵓⵎⵏⴻⵏ, ⵎⴰⵍⴰ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵏⴳⴰⵙ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C17_15","076_7_15","1CO","7","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵎⵏⴻⵏ ⴰⴷ ⵉⴵⴻⴼ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴵⴻⴼ. ⵅⴻⵏⵏⵉ ⵜⴰⵡⵎⴰⵜ ⵏⵉⵖ ⵜⴰⵡⴻⵍⵜⵎⴰⵜ ⵡⴰⵔ ⵜⵜⵡⴰⵇⵇⵏⴻⵏ ⵛⴰ ⴷⵉ ⵍⵃⴰⵏⵏ ⵏⵏⵉ. ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵍⴰⵖⴰ ⴰⵏⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_16","076_7_16","1CO","7","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉⵙ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⵎ, ⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵎ? ⵏⵉⵖ ⵎⴰⵏⵉⵙ ⵜⴻⵙⵙⵏⴻⴷ ⵛⴻⴽ, ⴰ ⴰⵔⵢⴰⵣ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵊⵎⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵛ? ");
INSERT INTO rift_vpl VALUES ("C17_17","076_7_17","1CO","7","17","17","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⵉⵍⴰⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⵓⵍ ⵉⵊⵊ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴷⴷⴰⵔ ⴰⵎⵎⵓ. ⴰⵎⵎⵓ ⵉ ⵓⵎⵓⵔⴻⵖ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C17_18","076_7_18","1CO","7","18","18","ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵉ ⵡⴻⵔⵢⴰⵣ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵖⴰⵔ ⵓⵎⵓⵏⵉ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵖⴰⵔ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵉ ⵃⴻⴷ ⴱⵍⴰ ⴰⵅⵜⴰⵏ, ⴻⵊⵊ ⵉ-ⵜ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵜ ⵅⴻⵜⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C17_19","076_7_19","1CO","7","19","19","ⴰⵅⵜⴰⵏ ⴷ ⵡⴰⵍⵓ ⵓ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⴷ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⴰⵃⴻⵟⵟⵓ ⵏ ⵜⵡⴻⵚⵚⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵀ! ");
INSERT INTO rift_vpl VALUES ("C17_20","076_7_20","1CO","7","20","20","ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⵍⴰⵖⵉⵜ ⵉ ⵣⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵍⴰⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_21","076_7_21","1CO","7","21","21","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⵉⴷ-ⴷⴷ ⴷ ⵉⵙⵎⴻⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵃⵉⵙⵙⵉⴼⴻⴷ ⵛⴰ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵃⴻⴷ, ⵉⵅⴹⴰⵔ ⵅⴻⵏⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵙⴻⵅⵅⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("C17_22","076_7_22","1CO","7","22","22","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⵎ ⵜⵓⵖⴰ ⴷ ⵉⵙⵎⴻⵖ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵃⵓⵔⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷ ⴰⵃⵓⵔⵔⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵙⵎⴻⵖ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C17_23","076_7_23","1CO","7","23","23","ⴰⵇⴰ ⵜⴻⵎⵎⴻⵙⵖⴻⵎ-ⴷⴷ ⵙ ⵜⵜⴰⵎⴰⵏ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵜⵉⵍⵉⵎ ⵄⴰⴷ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C17_24","076_7_24","1CO","7","24","24","ⴰ ⴰⵢⵜⵎⴰ, ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵙⵉⵖⵉ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⵉ ⴷⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵍⴰⵖⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_25","076_7_25","1CO","7","25","25","ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⵓⵄⴻⵣⵔⵉⵢⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⴰⵔⵔⴰⵢ ⵉⵏⵓ, ⴰⵎ ⵡⵉ ⵢⵉⵡⴹⴻⵏ ⵙ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("C17_26","076_7_26","1CO","7","26","26","ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ ⵎⵍⵉⵃ ⵉ ⵍⴻⵖⴱⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵛⵏⴰ ⵉ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⵎ ⵉⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_27","076_7_27","1CO","7","27","27","ⵎⴰ ⵜⵍⴻⵚⵇⴻⴷ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ? ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓ ⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵏⵏⴼⴻⴽⴽⴻⴷ. ⵎⴰⵍⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⵍⴻⵚⵇⴻⴷ ⴷⵉ ⵜⴻⵎⵖⴰⵔⵜ? ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓ ⵅ ⵜⴻⵎⵖⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C17_28","076_7_28","1CO","7","28","28","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵉⵡⵢⴻⴷ ⵜⴰⵎⵖⴰⵔⵜ, ⵡⴰⵔ ⵜⵅⴻⵟⵟⵉⴷ. ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵜⴻⴷⵡⴻⵍ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ, ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜⵅⴻⵟⵟⵉ ⵛⴰ. ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵇⵇⵏⴻⵏ ⵉ ⵡⴰⵢⴰⵡⴰⵢⴰ ⵙ ⵍⴻⵎⵍⴰⵛ, ⵜᵉⵜⵜⵔⴰⵊⴰ ⵉ-ⵜⴻⵏ ⵍⵎⴻⵃⵏⴻⵜ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵓⵛⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜⵜ ⵅⴰⵡⴻⵎ ⴽⴽⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C17_29","076_7_29","1CO","7","29","29","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵇⵇⴰⵔⴻⵖ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵍⵃⴰⵍ ⵉⵎⵥⵉ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⴻⵎⵖⴰⵔⵜ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⵅⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⵉ, ");
INSERT INTO rift_vpl VALUES ("C17_30","076_7_30","1CO","7","30","30","ⵉⵏⵏⵉ ⵉⵜⵜⵔⵓⵏ ⴰⵅⵎⵉ ⵡⴰⵔ ⵜⵜⵔⵓⵏ, ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵃⴻⵏ ⴰⵅⵎⵉ ⵡⴰⵔ ⴼⵔⵉⵃⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⴰⵖⴻⵏ ⴰⵅⵎⵉ ⵡⴰⵔ ⵎⴻⵍⵍⴽⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C17_31","076_7_31","1CO","7","31","31","ⵓ ⵉⵏⵏⵉ ⵉⵙⵜⴻⵏⴼⴰⵄⴻⵏ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⵜⴰⴳⴳⵯⵉⵊⴻⵏ ⵅ ⵓⵙⵜⴻⵏⴼⴻⵄ ⵉ ⴷⴷ-ⵉⵜⵜⵍⵉⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⴷⴻⵎ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵢⴰ ⴰⴷ ⵉⵄⴷⵓ. ");
INSERT INTO rift_vpl VALUES ("C17_32","076_7_32","1CO","7","32","32","ⵙ ⵓⵢⴻⵏⵏⵉ ⵅⵙⴻⵖ ⴰⴷ ⵜⵉⵍⵉⵎ ⴱⵍⴰ ⴰⵎⵏⵓⵙ, ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴻⴵⵉ ⵜⴻⵎⵖⴰⵔⵜ, ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵙⵉⴷⴻⵙ ⴷ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴰⵔⴹⴰ ⵙⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_33","076_7_33","1CO","7","33","33","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵎⵖⴰⵔⵜ, ⴰⴷ ⵉⴽⵙⵉ ⵙ ⵡⴻⵎⵏⵓⵙ ⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵓ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴰⵔⴹⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_34","076_7_34","1CO","7","34","34","ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴼⴰⵔⵇ ⵊⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ. ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵡⴻⵔⵢⴰⵣ ⵄⴻⵎⵎⴰⵔⵚ, ⴰⴷ ⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵙⵉⴷⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⵇⴻⴷⴷⴻⵙ ⴰⵎ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⴰⵎ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵡⴻⵔⵢⴰⵣ, ⴰⴷ ⵜⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⴰⵔⴹⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_35","076_7_35","1CO","7","35","35","ⴷⴻⴳⴳⴰ ⵇⵇⴰⵔⴻⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵉ ⵜⵉⵣⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⵍⴼⴻⵅ, ⵎⴰⵛⴰ ⵏⵏⵉⵖ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵉ ⵙⵉⴷⵉⵜⵡⴻⵎ ⵅ ⵓⴱⵔⵉⴷ ⵏⵉⵛⴰⵏ, ⴰⵎ ⵡⴰⵔ ⵜⵙⴻⵍⵀⵉⵎ ⴰⴽ-ⴷ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("C17_36","076_7_36","1CO","7","36","36","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵅⴰⵔⵔⴻⵚ ⵃⴻⴷ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵙⵜⵀⴻⵣⵣⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⴻⴵⵉⵙ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵜⴻⵏⵏⵉ ⵅ ⵄⴷⵓⵏ ⵡⵓⵙⵙⴰⵏ ⵏ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵙ ⴰⵎ ⵡⴰⵔ ⵜⵜ ⵉⵙⵙⴻⵎⵍⴻⵛ ⵄⴰⴷ ⵉ ⵡⴻⵔⵢⴰⵣ, ⵓⵛⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⵏⵉⵛⴰⵏ ⴰⴷ ⵜⵜ ⵉⵙⵙⴻⵎⵍⴻⵛ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉ ⵛⴰ. ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⵎⴻⵍⵛ. ");
INSERT INTO rift_vpl VALUES ("C17_37","076_7_37","1CO","7","37","37","ⵎⴰⵛⴰ ⵡⵉ ⵉⴵⴰⵏ ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴱⵍⴰ ⵎⴰ ⵢⵓⵛⴰ ⵙ ⵓⵣⵉⵢⵢⴰⵔ, ⵓⵛⴰ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⴽⴽⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵢⴻⵊⵊ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵏⵏⴻⵙ ⵜⴻⵚⴼⴰ, ⵎⵍⵉⵃ ⵉ ⵢⴻⴳⴳⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_38","076_7_38","1CO","7","38","38","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵎⴻⵍⵛⴻⵏ ⵢⴻⴵⵉⵙ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ ⵉⴳⴳⴰ ⵎⵍⵉⵃ, ⵓ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵎⴻⴵⵉⵛⴻⵏ ⵢⴻⴵⵉⵙ ⵜⴰⵄⵣⴰⵔⴻⵛⵜ, ⵉⴳⴳⴰ ⵎⵍⵉⵃ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C17_39","076_7_39","1CO","7","39","39","ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵇⵇⴻⵏ ⵖⴰⵔ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵡⴻⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵔⵢⴰⵣ ⵏⵏⴻⵙ ⵉⵎⵎⵓⵜ, ⴰⵇⴰ-ⵜⵜ ⵜⵙⴰⵔⵔⴻⵃ ⵣⵣⴰⵢⴻⵙ, ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵎⵍⴻⵛ ⴰⴽ-ⴷ ⵡⵉ ⵜⴻⵅⵙ, ⵎⴰⵛⴰ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("C17_40","076_7_40","1CO","7","40","40","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰⵜ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴽⵜⴰⵔ ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎ ⴰⵎⴻⵏⵏⵉ. ⵓ ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴰⵍⵉⵖ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵅⴻⴷⴷⴻⵎ ⵄⴰⵡⴻⴷ ⴷⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("C18_1","076_8_1","1CO","8","1","1","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵖⴰⵔⵚⵉⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ, ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ, ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵖⴰⵔⵏⴻⵖ ⵜⵓⵙⵙⵏⴰ. ⵜⵓⵙⵙⵏⴰ ⵎⴰⵛⴰ ⵜᵉⵜⵜⴻⴳⴳ ⵜⵓⴼⴼⴻⵜ, ⵎⴰⵛⴰ ⵜⴰⵢⵔⵉ ⵜⴻⵙⵙⵢⴻⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("C18_2","076_8_2","1CO","8","2","2","ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴱⴻⵍⵍⵉ ⵉⵙⵙⴻⵏ ⵛⴰ, ⵄⴰⴷ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵡⴰⵍⵓ ⴰⵏⴻⵛⵜ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C18_3","076_8_3","1CO","8","3","3","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⴻⵅⵙ ⵃⴻⴷ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴷ ⵡⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C18_4","076_8_4","1CO","8","4","4","ⵅ ⵎⴰⵛⵛⴰ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ, ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵚⵚⴰⵏⴰⵎ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴰⵍⵓ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵓ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖⵏⵉ ⵎⵖⵉⵔ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C18_5","076_8_5","1CO","8","5","5","ⵅⴻⵏⵏⵉ, ⵡⴰⵅⵅⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ, ⵏⵉⵖ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ - ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴵⴰⵏ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵙⵉⴷⵉⵜⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("C18_6","076_8_6","1CO","8","6","6","ⵉ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉ ⴷⴷ-ⵓⵙⵉⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵓ ⴷⴰⵢⴻⵙ ⵉ ⵏⴻⴵⴰ, ⵓ ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵉⵊⵊ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴵⴰⵏⵜ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵉ ⵏⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("C18_7","076_8_7","1CO","8","7","7","ⵎⴰⵛⴰ ⵜⵓⵙⵙⵏⴰ-ⵢⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⴻⴵⵉ ⵎⴰⵔⵔⴰ, ⵎⵉⵏⵣⵉ ⴷⵉⵏ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⴷⵉ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ ⵜⵜᵉⵜⵜⴻⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵅⵎⴻⵊ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ ⵙ ⵎⴰⵏⴰⵢⴻⵏⵏⵉ, ⵎⵉⵏⵣⵉ ⵜⴻⴹⵄⴻⴼ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C18_8","076_8_8","1CO","8","8","8","ⵎⴰⵛⴰ ⵎⴰⵛⵛⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵉⵡⵉⴹ ⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⴻⵛⵛⴰ, ⴰⵇⴰ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵢⴰⵔⴻⵏⵏⵉ ⵛⴰ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵡⴰⵔ ⵏⴻⵛⵛⵉ, ⴰⵇⴰ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⴱⵓ ⵍⴻⵅⵚⴻⵚ. ");
INSERT INTO rift_vpl VALUES ("C18_9","076_8_9","1CO","8","9","9","ⵎⴰⵛⴰ ⵖⴰⵔⵡⴻⵎ, ⴰⵇⴰ ⵜⵜⴻⵙⵔⵉⵃ ⵏⵡⴻⵎ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C18_10","076_8_10","1CO","8","10","10","ⵙ ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵜⵜⵡⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵓⵙⵙⵏⴰ, ⵜᵉⵜⵜⵖⵉⵎⴰⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵎⴰⵏⵉ ⵄⴻⴱⴱⴷⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ, ⵎⴰ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴹⵄⴻⴼ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵊⴱⴻⴷ ⵛⴰ ⴰⴷ ⵜⴻⴽⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⴻⵛⵛ ⵎⵉⵏ ⵖⴰⵔⵚⴻⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ? ");
INSERT INTO rift_vpl VALUES ("C18_11","076_8_11","1CO","8","11","11","ⴰⵎⵎⵓ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏⵏⴻⵛ ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ, ⵡⴻⵏⵏⵉ ⵉ ⵅⴻⴼ ⵉⵎⵎⵓⵜ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C18_12","076_8_12","1CO","8","12","12","ⵅⵎⵉ ⵜⵅⴻⵟⵟⵉⵎ ⴰⵎⵎⵓ ⵅ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⵜⴻⵙⵙⵢⴻⵣⵣⵎⴻⵎ ⵜⵓⴹⵄⴻⴼⵜ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵜⵅⴻⵟⵟⵉⵎ ⵅ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C18_13","076_8_13","1CO","8","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵎⴰⵛⵛⴰ ⴰⵇⴰ ⵜⴰⵔⵔⴰ ⵓⵎⴰ ⴰⴷ ⵉⵏⵏⴻⴷⵔⴻⴼ, ⵡⴰⵔ ⵜⵜᵉⵜⵜⴻⵖ ⴰⵢⵙⵓⵎ ⵄⴻⵎⵎⴰⵔⵚ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⴻⵏⴷⵔⵉⴼⴻⵖ ⵛⴰ ⵓⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("C19_1","076_9_1","1CO","9","1","1","ⵎⴰ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴰⵃⵓⵔⵔⵉ? ⵎⴰ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵔⵔⴰⵙⵓⵍ? ⵎⴰ ⵡⴰⵔ ⵥⵔⵉⵖ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ? ⵎⴰ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵓ ⴷⵉ ⵙⵉⴷⵉ ⵉⵏⵓ? ");
INSERT INTO rift_vpl VALUES ("C19_2","076_9_2","1CO","9","2","2","ⵎⴰⵍⴰ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵔⵔⴰⵙⵓⵍ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉ ⴽⴻⵏⵏⵉⵡ ⵏⵉⵛⴰⵏ ⵄⵏⵉⵖ ⵜ, ⵡⴰⵀ, ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵛⴻⵎⵎⵉⵄ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵓ ⵏ ⵔⵔⴰⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("C19_3","076_9_3","1CO","9","3","3","ⵏⴻⵛⵛ ⴰⵔⵔⵉⵖ-ⴷⴷ ⵅ ⵢⵉⵏⵏⵉ ⵅⴰⴼⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴰⵎⵎⵓ: ");
INSERT INTO rift_vpl VALUES ("C19_4","076_9_4","1CO","9","4","4","ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵛⵛ, ⴰⴷ ⵏⵙⵓ? ");
INSERT INTO rift_vpl VALUES ("C19_5","076_9_5","1CO","9","5","5","ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ ⴰⴷ ⵏⴰⵡⵉ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵛⵜ ⵏ ⵜⵡⴻⵍⵜⵎⴰⵜ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⴰⵎ ⵄⴰⵡⴻⴷ ⵔⵔⵓⵙⵓⵍ ⵉⵏⵏⴻⵖⵏⵉ ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴽⵉⴼⴰ? ");
INSERT INTO rift_vpl VALUES ("C19_6","076_9_6","1CO","9","6","6","ⵏⵉⵖ ⵡⴰⵀⴰ ⴱⴰⵔ-ⵏⴰⴱⴰ ⴷ ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⵜⴻⵙⵔⵉⵃ ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⵅⴻⴷⴷⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("C19_7","076_9_7","1CO","9","7","7","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵍⵄⴻⵙⴽⴰⵔ ⴰⴷ ⵉⵅⴻⴵⴻⵚ ⵍⵎⵓⵏⴻⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ? ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵥⵥⵓⵏ ⵉⵛⵜ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵊⴻⵄ ⵏ ⵓⴹⵉⵍ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵛⴰ ⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ? ⵏⵉⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵢⴰⵔⴻⴽⴽⵡⴻⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⵃⵉⵎⴰⵔⵜ, ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⵛⴰ ⴰⵖⵉ ⵏ ⵜⵃⵉⵎⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("C19_8","076_9_8","1CO","9","8","8","ⵎⴰ ⵇⵇⴰⵔⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⴰⵎ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵀⴰ? ⵅⵣⴰⵔ, ⵓⵍⴰ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⵇⵇⴰⵔ ⴰⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("C19_9","076_9_9","1CO","9","9","9","ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵜⴰⵛⵎⴰⵏⵜ ⵉ ⵓⵢⴻⵏⴷⵓⵣ ⵉⵙⵙⴰⵔⵡⴰⵜⴻⵏ.” ⵎⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵃⴻⵟⵟⴰ ⵅ ⵉⵢⴻⵏⴷⵓⵣⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ? ");
INSERT INTO rift_vpl VALUES ("C19_10","076_9_10","1CO","9","10","10","ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵉⵏⵏⴰ ⵉ-ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵔⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵣⴻⵏ, ⴰⴷ ⵉⵛⴰⵔⵣ ⵙ ⵓⵙⵉⵜⴻⵎ ⵓ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵔⵡⴰⵜⴻⵏ, ⴰⴷ ⵉⵙⵙⴰⵔⵡⴰⵜ ⵙ ⵓⵙⵉⵜⴻⵎ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵚⵚⴰⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C19_11","076_9_11","1CO","9","11","11","ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⵣⴰⵔⵔⴻⵄ ⴷⴰⵢⵡⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⵔⵓⵃ, ⵅⴻⵏⵏⵉ ⵎⴰ ⴷ ⴰⵟⵟⴰⵙ ⵎⴰⵍⴰ ⵏⴻⵎⵊⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("C19_12","076_9_12","1CO","9","12","12","ⵎⴰⵍⴰ ⵉⵏⵏⴻⵖⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵜⵜⴻⵙⵔⵉⵃ-ⴰ ⵅⴰⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴰⵔⵛⴻⵏ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵡⴻⵎ, ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵛⵛⵉⵏ ⴽⵜⴰⵔ ⵍⵍⴰ? ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵙⵜⴻⵏⴼⵉⵄ ⵣⵉ ⵜⵜⴻⵙⵔⵉⵃ-ⴰ, ⵎⴰⵛⴰ ⵏⴻⴽⵙⵉ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C19_13","076_9_13","1CO","9","13","13","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ ⴰⴷ ⵜⵜⵡⴰⵔⴻⵣⵇⴻⵏ ⵣⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵇⴻⴷⴷⴰⵙ? ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("C19_14","076_9_14","1CO","9","14","14","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵢⵓⵎⵓⵔ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵙ ⴰⵚⴻⴱⵃⴰⵏ, ⴰⵇⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵣⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C19_15","076_9_15","1CO","9","15","15","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵜⴻⵏⴼⵉⵄⴻⵖ ⵣⴻⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ⵓ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵓⵔⵉⵖ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵏⴻⵛⵛ, ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⴷ ⵎⵎⵜⴻⵖ ⵅ ⵓⵙⴻⴱⴹⴻⵍ ⵏ ⵓⵙⴻⵎⵖⴰⵔ ⵉⵏⵓ ⵙ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C19_16","076_9_16","1CO","9","16","16","ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵏⴻⵛⵛ ⵡⴰⵔ ⵖⴰⵔⵉ ⵛⴰ ⵎⵉⵏ ⴷⵉ ⵖⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⵎⴰⵏ ⴰⵢⴰ. ⴰⵢⴻⵃⵃⴰⵜ ⵅⴰⴼⵉ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵛⴰ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("C19_17","076_9_17","1CO","9","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⴳⴳⵉⵖ ⵜⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ, ⴰⴷ ⵖⴰⵔⵉ ⵜⵉⵍⵉ ⵍⵎⵓⵏⴻⵜ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵜ ⵜⵜⴻⴳⴳⵉⵖ ⵙ ⵍⵅⴰⴹⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵓⵡⴻⴽⴽⴻⵍ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C19_18","076_9_18","1CO","9","18","18","ⵎⴰⵏ ⵜⴻⵏ ⵇⴰⵄ ⵉⴵⴰⵏ ⴷ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ? ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰ: ⴰⵎ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴰⴷ ⵙⵙⴻⵃⴹⴰⵔⴻⵖ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⴱⴰⵟⴻⵍ, ⵡⴰⵔ ⴽⴻⵙⵙⵉⵖ ⵛⴰ ⵜⵜⴻⵙⵔⵉⵃ ⵉⵏⵓ ⵉ ⴷⴰⵢⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍ’ⵉⵏⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("C19_19","076_9_19","1CO","9","19","19","ⵏⴻⵛⵛ, ⵓⵎⵉ ⵇⵇⵉⵎⴻⵖ ⵜⵜⵡⴰⵃⴰⵔⵔⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⴰⵔⵔⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵖ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C19_20","076_9_20","1CO","9","20","20","ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵡⵓⴷⴰⵢ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵖ ⵓⴷⴰⵢⴻⵏ, ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵢⵉⵏⵏⵉ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵖ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("C19_21","076_9_21","1CO","9","21","21","ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷⴻⵡⵍⴻⵖ ⴰⵎ ⵡⴻⵏⵏⵉ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ - ⵡⴰⵔ ⴵⵉⵖ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴰⵇⴰ-ⵢⵉ ⴷⴷⴰⵔⴻⵖ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵍⵎⴰⵙⵉⵃ - ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵖ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("C19_22","076_9_22","1CO","9","22","22","ⵜⵓⵖⴰ ⴰⵢⵉ ⴹⴻⵄⴼⴻⵖ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵖ ⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ. ⴰⵇⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⵎⴰⵔⵔⴰ ⵉ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⴱⴻⵄⴷⴰ ⴰⴷ ⵡⵛⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C19_23","076_9_23","1CO","9","23","23","ⵎⴰⵏ ⴰⵢⴰ ⵜⵜⴻⴳⴳⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵖ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C19_24","076_9_24","1CO","9","24","24","ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵃⴰⵎⴰⵜ ⵏ ⵜⴰⵣⵍⴰ ⴷⵉ ⵍⵎⴻⵍⵄⴻⴱ, ⵎⴰⵔⵔⴰ ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⵜⵜⴰⵣⵣⵍⴻⵏ, ⵎⴰⵛⴰ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉ ⵖⴰ ⵢⴰⵔⴻⴱⵃⴻⵏ ⵡⴰⵀⴰ? ⵅⴻⵏⵏⵉ ⴰⵣⵣⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⵎⵎⵓ ⴰⵍ ⴷ ⵖⴰ ⵜⴰⵔⴻⴱⵃⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C19_25","076_9_25","1CO","9","25","25","ⵎⴰⵛⴰ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵛⵜ ⵏ ⵜⵃⴰⵎⴻⵜ, ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ. ⵏⵉⵜⵏⵉ ⵓⵣⵣⵍⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵏ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵉⴼⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵔⴱⴻⵃ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C19_26","076_9_26","1CO","9","26","26","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵣⵣⵍⴻⵖ ⵛⴰ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⵉⵖ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵛⵛⴰⵜⴻⵏ ⴷⵉ ⵍⴻⵄⵡⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("C19_27","076_9_27","1CO","9","27","27","ⵎⴰⵛⴰ ⵜⵜⵎⴰⵔⵔⴰⵜⴻⵖ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ, ⴰⴷ ⴰⵙ ⵇⴻⵜⵎⴰⵔⴻⵖ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵓⴼⴼⵓⵖⴻⵖ ⵛⴰ ⴱⴰⵔⵔⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴱⴰⵔⵔⵃⴻⵖ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C110_1","076_10_1","1CO","10","1","1","ⴰ ⴰⵢⵜⵎⴰ, ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵓⵙⴻⵢⵏⵓ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵛⵓⵇⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("C110_2","076_10_2","1CO","10","2","2","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⴷⵉ ⵎⵓⵙⴰ ⴷⴻⴳ ⵓⵙⴻⵢⵏⵓ ⵓ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("C110_3","076_10_3","1CO","10","3","3","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵛⵛⵉⵏ ⵎⴰⵛⵛⴰ ⵜⴰⵔⵓⵃⴻⵛⵜ ⴷ ⵉⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("C110_4","076_10_4","1CO","10","4","4","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵙⵡⵉⵏ ⵜⵉⵙⴻⵙⵙⵉⵜ ⵜⴰⵔⵓⵀⴻⵛⵜ ⴷ ⵉⵛⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵡⵉⵏ ⵣⴻⴳ ⵡⴻⵥⵔⵓ ⵏ ⴰⵔⵔⵓⵃ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵙⴻⵏ, ⵓ ⴰⵥⵔⵓ ⵏⵏⵉ ⵜⵓⵖⴰ-ⵜ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C110_5","076_10_5","1CO","10","5","5","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵢⴰⵔⴹⵉ ⵅ ⵡⴻⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⵡⴹⴰⵏ ⴷⵉ ⵍⴻⵅⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("C110_6","076_10_6","1CO","10","6","6","ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ ⴷ ⵍⵎⵉⵜⴰⵍ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵉⵜⵜⵉⵍⵉ ⵎⵎⴻⵥⵔⵉ ⴷⵉ ⵎⵉⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵏⵉⵜⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵎⴻⵥⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("C110_7","076_10_7","1CO","10","7","7","ⴻⵊⵊ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏⴷⵉⴽⴽⵡⵉⵍ ⵛⴰ ⴰⴷ ⵏⴻⵄⴱⴻⴷ ⵍ’ⴰⵚⵏⴰⵎ, ⴰⵎ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵍⴳⴻⵏⵙ ⵉⵇⵇⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵛ ⴰⴷ ⵉⵙⵙⵓ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⵔⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("C110_8","076_10_8","1CO","10","8","8","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵏⴻⵙⵙⴻⴼⵙⴰⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⴰⵎ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ. ⴰⵇⴰ ⵎⵎⵓⵜⴻⵏ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ-ⴰⵍⴻⴼ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("C110_9","076_10_9","1CO","10","9","9","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵏⵊⴰⵔⵔⴻⴱ ⵍⵎⴰⵙⵉⵃ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵊⴰⵔⵔⴱⴻⵏ ⵜ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵀⴻⵍⴽⴻⵏ ⵙ ⵉⴼⵉⵖⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C110_10","076_10_10","1CO","10","10","10","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⵄⴰⵡⴻⴷ ⴰⴷ ⵏⴻⵙⵙⴼⵉⵅⴻⵅ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵙⵙⴼⵉⵅⵉⵅⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⵓⵎⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("C110_11","076_10_11","1CO","10","11","11","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴰⵔⴻⵏ, ⴰⵇⴰ ⵜ ⴷ ⵍⵎⵉⵜⴰⵍ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵓⵛⴰ ⵜⵓⵔⴰ ⴷ ⴰⵄⵍⴰⵎ ⵉ ⵏⴻⵛⵛⵉⵏ ⵎⵉⵅⴻⴼ ⴷⴷ-ⵢⵓⵙⴰ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵣⵣⵎⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("C110_12","076_10_12","1CO","10","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⵉⴱⴻⴷⴷ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵃⴹⴰ ⵡⴰⵔ ⵉⵡⴻⵟⵟⵉ. ");
INSERT INTO rift_vpl VALUES ("C110_13","076_10_13","1CO","10","13","13","ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵜⵜⴻⴽⴽ ⵓⵊⴰⵔⵔⴻⴱ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵡⴹⴻⵏ ⵖⴰⵔ ⵉⵡⴷⴰⵏ. ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵊⴰⵔⵔⴱⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⵉⵏ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵉⵛ ⵓⴼⴼⵓⵖ ⴰⴽ-ⴷ ⵓⵊⴰⵔⵔⴻⴱ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴰⵔⴱⵓⵎ ⴰⵖⴻⴽⴽⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("C110_14","076_10_14","1CO","10","14","14","ⵙ ⵓⵢⴰ, ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⴰⵔⴻⵡⵍⴻⵎ ⵣⴻⴳ ⵓⵄⴱⴰⴷ ⵉ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("C110_15","076_10_15","1CO","10","15","15","ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⴰⵅⵎⵉ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽ-ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ. ⵃⴻⴽⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵅⴻⵏⵏⵉ ⵅ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C110_16","076_10_16","1CO","10","16","16","ⵍⴽⴰⵙ ⵏ ⵓⵇⴰⴷⵉ ⵏⵏⵉ ⵏⴻⵜⵜⴱⴰⵔⴰⴽ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵜⴰⵎⵓⵏⵜ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ? ⴰⵖⵔⵓⵎ ⵏⵏⵉ ⵏⵜⴰⵔⴻⵥⵥⴰ, ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵜⴰⵎⵓⵏⵜ ⴰⴽ-ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ? ");
INSERT INTO rift_vpl VALUES ("C110_17","076_10_17","1CO","10","17","17","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⴰⵖⵔⵓⵎ ⴷ ⵉⵊⵊⴻⵏ, ⴰⵎⵎⵓ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵟⵟⴻⴼ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵖⵔⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("C110_18","076_10_18","1CO","10","18","18","ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵉⵙⵔⴰⵉⵍ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⵉⵎⴻⵜ! ⵎⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ ⵣⵉ ⵜⵖⴰⵔⵚⴰ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴰⵛⵔⴰⵛ ⴰⴽ-ⴷ ⵓⵄⴰⵍⵟⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("C110_19","076_10_19","1CO","10","19","19","ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ? ⵎⴰ ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵛⴰ, ⵏⵉⵖ ⴱⴻⵍⵍⵉ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵛⴰ? ⵍⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("C110_20","076_10_20","1CO","10","20","20","ⵎⵉⵏ ⵡⵛⵉⵏ ⵍⴽⵓⴼⴼⴰⵔ ⴷ ⵜⴰⵖⴰⵔⵚⵜ, ⵡⴻⵀⵀⴱⴻⵏ ⵜⵜ ⵉ ⵛⵛⵡⴰⵟⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵓⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵜⵛⴰⵔⵛⴻⵎ ⴰⴽ-ⴷ ⵛⵛⵡⴰⵟⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("C110_21","076_10_21","1CO","10","21","21","ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵍⴽⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓⵍⴰ ⴷ ⵍⴽⴰⵙ ⵏ ⵛⵛⵡⴰⵟⴻⵏ, ⵓⵛⴰ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵛⴰⵔⵛⴻⵎ ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓⵍⴰ ⴷ ⵜⴰⵣⴻⵡⴹⴰ ⵏ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C110_22","076_10_22","1CO","10","22","22","ⵏⵉⵖ ⴰⴷ ⵏⴻⵙⵙⴻⴽⴽⴰⵔ ⵜⵓⵙⵎⵉ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ? ⵎⴰ ⵏⴻⵊⵀⴻⴷ ⵅⴰⵙ ⵏⴻⵛⵛⵉⵏ? ");
INSERT INTO rift_vpl VALUES ("C110_23","076_10_23","1CO","10","23","23","ⵎⴰⵔⵔⴰ ⵉⵜⵜⵃⴻⴵⴻⵍ ⴰⵢⵉ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ. ⵎⴰⵔⵔⴰ ⵉⵜⵜⵀⴻⴵⴻⵍ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⵉⴱⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C110_24","076_10_24","1CO","10","24","24","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵢⴰⵔⴻⵣⵣⵓ ⵛⴰ ⵜⵉⵣⵉ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵢⴰⵔⵣⵓ ⵄⴰⵡⴻⴷ ⵜⴻⵏⵏⵉ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C110_25","076_10_25","1CO","10","25","25","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵎⴻⵏⵣⴰⵏ ⴷⵉ ⵙⵙⵓⵇ ⵏ ⵉⴳⴻⵣⵣⴰⵔⴻⵏ, ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜ ⵜⴻⵛⵛⴻⵎ ⴱⵍⴰ ⴰⵙⴻⵇⵙⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("C110_26","076_10_26","1CO","10","26","26","ⵎⵉⵏⵣⵉ ⵉ ⵙⵉⴷⵉ ⵓⵎⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵄⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C110_27","076_10_27","1CO","10","27","27","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵍⴽⵓⴼⴼⴰⵔ, ⵉⵄⴰⵔⴹ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⵔⴰⵃⴻⵎ, ⵛⵛⴻⵎ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉ ⴷ ⵖⴰ ⵉⵙⵙⴰⵔⵙ, ⵡⴰⵔ ⵜⴻⵙⵙⴻⵇⵙⵉⵎ ⵛⴰ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ.    ");
INSERT INTO rift_vpl VALUES ("C110_28","076_10_28","1CO","10","28","28","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵏⵏⴰ ⴰⵡⴻⵎ: “ⴷⴻⴳⴳⴰ ⵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵉ ⵍ’ⴰⵚⵏⴰⵎ!”, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵄⴻⵍⵎⴻⵏ ⵓⵍⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("C110_29","076_10_29","1CO","10","29","29","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ‘ⵜⵏⴻⴼⵙⴻⵛⵜ’, ⵡⴰⵔ ⵄⵏⵉⵖ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ⵎⵉⵏⵣⵉ ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⴻⵎ ⵜⵍⴻⵍⵍⵉ ⵉⵏⵓ ⵙ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("C110_30","076_10_30","1CO","10","30","30","ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵛⴰⵔⵛⴻⵖ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ, ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵛⴻⵇⵇⴼⴻⵖ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵎⵉⵅⴻⴼ ⵜⵜⵇⴰⴷⵉⵖ? ");
INSERT INTO rift_vpl VALUES ("C110_31","076_10_31","1CO","10","31","31","ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵏⵉⵖ ⵜⵙⴻⵙⵙⴻⵎ ⵏⵉⵖ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⴻⵖⵏⵉ, ⴳⴳⴻⵎ ⵜⵜ ⵎⴰⵔⵔⴰ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C110_32","076_10_32","1CO","10","32","32","ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵏⵉⵖ ⵉ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵓⵍⴰ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("C110_33","076_10_33","1CO","10","33","33","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴷⵉ ⴽⵓⵍⵛⵉ, ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵖ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵜⵉⵣⵉ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵜⵉⵣⵉ ⵏ ⵡⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C111_1","076_11_1","1CO","11","1","1","ⴹⴼⴰⵔⴻⵎ ⴰⵢⵉ-ⴷⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴹⴼⴰⵔⴻⵖ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C111_2","076_11_2","1CO","11","2","2","ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⴼⴻⴽⴽⴰⵔⴻⵎ ⴷⴰⵢⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⵜᵉⵜⵜⴻⵟⵟⴼⴻⵎ ⴷⵉ ⵜⴻⵡⵚⴻⵢⵢⴰⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵡⴻⵎ ⵜⴻⵏⵜ ⵡⵛⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("C111_3","076_11_3","1CO","11","3","3","ⵎⴰⵛⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵍⵎⴰⵙⵉⵃ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵓⵛⴰ ⴰⵔⵢⴰⵣ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C111_4","076_11_4","1CO","11","4","4","ⴽⵓⵍ ⴰⵔⵢⴰⵣ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵥⴰⴵⴰⵏ ⵏⵉⵖ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⴰⵎ ⵉⵍⴻⵃⵃⴻⴼ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵉⴼⴻⵟⵟⴻⵃ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C111_5","076_11_5","1CO","11","5","5","ⵎⴰⵛⴰ ⴽⵓⵍ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵥⴰⴵⴰⵏ ⵏⵉⵖ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⴰⵎ ⵜⴻⵙⵙⵄⴰⵔⵔⴰ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵜⴼⴻⵟⵟⴻⵃ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⴰⵎ ⵜⴻⵏⵏⵉ ⵉⵃⴻⴼⴼⴻⵏ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C111_6","076_11_6","1CO","11","6","6","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜⵍⴻⵃⵃⵉⴼ, ⴻⵊⵊ ⵉ-ⵜⵜ ⴰⴷ ⵜⵃⴻⴼⴼ ⵄⴰⵡⴻⴷ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⵎⴰⵍⴰ ⵜⵇⴻⵙⵙ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵉⵖ ⵜⵃⴻⴼⴼ, ⵃⵙⴻⵏ ⵎⴰⵍⴰ ⵜⵍⴻⵃⵃⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("C111_7","076_11_7","1CO","11","7","7","ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⵜⵜⴻⵃⵡⵉⵊⵉ ⵛⴰ ⴰⴷ ⵉⵍⴻⵃⵃⴻⴼ ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵚⵚⵉⴼⴻⵜ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵜⴻⴵⴰ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("C111_8","076_11_8","1CO","11","8","8","ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("C111_9","076_11_9","1CO","11","9","9","ⴰⵔⵢⴰⵣ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⴷⴷ-ⵉⵅⵍⵉⵇ ⵛⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵉ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("C111_10","076_11_10","1CO","11","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵚⵚⵓⵍⵟⴰ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("C111_11","076_11_11","1CO","11","11","11","ⵎⴰⵛⴰ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⵔⵢⴰⵣ ⵡⴰⵔ ⵉⴵⵉ ⴱⵍⴰ ⵜⴰⵎⵖⴰⵔⵜ, ⵓⵍⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⴱⵍⴰ ⴰⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("C111_12","076_11_12","1CO","11","12","12","ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴰⵎⵖⴰⵔⵜ ⵜⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵡⴻⵔⵢⴰⵣ, ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ ⵙ ⵜⴻⵎⵖⴰⵔⵜ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⵇⴰ-ⵜ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C111_13","076_11_13","1CO","11","13","13","ⵃⴻⴽⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ: ⵎⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⵥⵥⴰⴵ ⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵜⴻⵙⵙⵄⴰⵔⵔⴰ ⵉ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("C111_14","076_11_14","1CO","11","14","14","ⵎⴰ ⵜⵓⴱⴱⴰⵔⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⴻⵙⵙⵛⴰⵏ ⴱⴻⵍⵍⵉ ⴰⵛⵓⵡⵡⴰⴼ ⴷ ⴰⵣⵉⵔⴰⵔ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵡⴻⵔⵢⴰⵣ? ");
INSERT INTO rift_vpl VALUES ("C111_15","076_11_15","1CO","11","15","15","ⵎⴰⵛⴰ ⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⴰⵄⵓⴵⵉ ⵎⴰⵍⴰ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵛⵓⵡⵡⴰⴼ ⴷ ⴰⵣⵉⵔⴰⵔ, ⵎⵉⵏⵣⵉ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵓⵛⵓⵡⵡⴰⴼ ⴰⵎ ⵓⵍⴻⵃⵃⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("C111_16","076_11_16","1CO","11","16","16","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵅⵙ ⵃⴻⴷ ⴰⴷ ⵉⵅⴰⵔⵡⴻⴹ ⵎⴰⵏ ⴰⵢⴰ, ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵜⵏⴰⵎⵉⵜ ⵏⵏⵉ ⵓⵍⴰ ⴷ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C111_17","076_11_17","1CO","11","17","17","ⵡⴻⵚⵚⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⴻⴳⴳⴻⵖ ⵛⵛⴰⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵎⴰⵛⴰ ⵜⵓⵢⵓⵔⴻⵎ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C111_18","076_11_18","1CO","11","18","18","ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ, ⵎⴰⵍⴰ ⵜⵎⵓⵏⴻⵎ ⴰⵎ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵙⵍⵉⵖ ⴰⵇⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵎⵙⴻⴱⴹⵉ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜ ⴰⵎⵏⴻⵖ ⵉ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C111_19","076_11_19","1CO","11","19","19","ⵙ ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵎⵛⵓⴱⴱⵛⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵏ ⵎⴰⵏ ⵡⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⵇⴻⴵⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("C111_20","076_11_20","1CO","11","20","20","ⵅⵎⵉ ⵜⵜⵎⵓⵏⴰⵎ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⴷ ⵜⵙⴻⵙⵙⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵓⵡⵡⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ,    ");
INSERT INTO rift_vpl VALUES ("C111_21","076_11_21","1CO","11","21","21","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉⵜⵜⴻⵜⵜ ⴰⵎⴻⵏⵙⵉ ⵏⵏⴻⵙ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ ⴷⴰⵢⴻⵙ ⵍⴰⵥ ⵓⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵉⵙⵛⴰⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C111_22","076_11_22","1CO","11","22","22","ⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵜⵓⴷⵔⵉⵏ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⵓ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵙⵡⴻⵎ? ⵏⵉⵖ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴰⵎ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⴻⵙⵙⵃⴻⵛⵛⴰⵎⴻⵎ ⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵛⴰ? ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵉ ⵖⴰ ⵉⵏⵉⵖ? ⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⴳⴳⴻⵖ ⵛⵛⴰⵏ? ⵍⵍⴰ, ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⴻⴳⴳⴻⵖ ⵛⵛⴰⵏ! ");
INSERT INTO rift_vpl VALUES ("C111_23","076_11_23","1CO","11","23","23","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵟⵟⴼⴻⵖ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵙⵙⵉⵡⴹⴻⵖ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ, ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⴷⵉ ⴵⵉⵍⴻⵜ ⵉ ⴷⵉ ⵉⵜⵜⵡⴰⵖⴷⴰⵔ, ⵉⴽⵙⵉ ⴰⵖⵔⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("C111_24","076_11_24","1CO","11","24","24","ⵉⴱⴰⵔⴻⴽ, ⵢⴰⵔⵥⴰ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⴽⵙⵉⵎ, ⵜⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵉ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵔⵥⴻⵏ, ⴳⴳⴻⵎ ⴰⵢⴰ ⴰⵎⵎⵓ ⵉ ⵍⵉⴷⴰⵔⴻⵜ ⵅⴰⴼⵉ!” ");
INSERT INTO rift_vpl VALUES ("C111_25","076_11_25","1CO","11","25","25","ⵓⵛⴰ ⴰⵎⵎⵓ ⴰⵡⴰⵔⵏⵉ ⴰⵎⴻⵏⵙⵉ ⵉⵡⵛⴰ ⵍⴽⴰⵙ, ⵉⵏⵏⴰ: “ⵍⴽⴰⵙ-ⴰ ⴷ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵏⵓ. ⴳⴳⴻⵎ ⴰⵢⴰ, ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵣⵣⴰⵢⴻⵙ ⵜⴻⵙⵡⵉⵎ, ⵉ ⵍⵉⴹⴰⵔⴻⵜ ⵅⴰⴼⵉ.” ");
INSERT INTO rift_vpl VALUES ("C111_26","076_11_26","1CO","11","26","26","ⵙ ⵎⵉⵏⵣⵉ ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⵉ ⵖⴰ ⵜⴻⵛⵛⴻⵎ ⴰⵖⵔⵓⵎ-ⴰ ⵓ ⴰⴷ ⵜⴻⵙⵡⴻⵎ ⵣⵉ ⵍⴽⴰⵙ-ⴰ, ⴰⵇⴰ ⵜᵉⵜⵜⵉⴷⴰⵔⴻⵎ ⵍⵎⴻⵡⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C111_27","076_11_27","1CO","11","27","27","ⵙ ⵓⵢⴻⵏⵏⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵏ ⵙⵉⴷⵉ ⵓⵛⴰ ⴰⴷ ⵉⵙⵓ ⵣⵉ ⵍⴽⴰⵙ ⵏⵏⴻⵙ, ⴰⵎ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵙ ⵓⵙⴷⴰⵀⴻⴵⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵓⵎⴰⵔⵡⴰⵙ ⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵙⵉⴷⵉ ⵓ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C111_28","076_11_28","1CO","11","28","28","ⵙ ⵓⵢⴻⵏⵏⵉ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵇⴻⴵⴻⴱ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵛⵛ ⵅⴻⵏⵏⵉ ⵣⴻⴳ ⵡⴻⵖⵔⵓⵎ ⵓ ⴰⴷ ⵉⵙⵓ ⵣⵉ ⵍⴽⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C111_29","076_11_29","1CO","11","29","29","ⵎⵉⵏⵣⵉ ⵡⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⴷ ⵡⵉ ⵖⴰ ⵉⵙⵡⴻⵏ ⴰⵎ ⵡⴰⵔ ⵉⵙⴷⵉⵀⴻⴵ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵍⵃⵓⴽⵎ ⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵎ ⵉⵜⵜⴻⵜⵜ ⵓ ⴰⵎ ⵉⵙⴻⵙⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴼⴰⵔⵔⴻⵣ ⵛⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C111_30","076_11_30","1CO","11","30","30","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵀⴻⵍⵛⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵓⵛⴰ ⴰⵟⵟⴰⵙ ⴷⴻⵡⵍⴻⵏ ⵜⵜᵉⵟⵟⵚⴻⵏ ⵉⴹⴻⵚ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("C111_31","076_11_31","1CO","11","31","31","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵃⴽⴻⵎ ⵅ ⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵃⴰⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C111_32","076_11_32","1CO","11","32","32","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⵡⴰⵃⴽⴻⵎ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵔⴻⴱⴱⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵃⴰⴽⴻⵎ ⵛⴰ ⴰⴽ-ⴷ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("C111_33","076_11_33","1CO","11","33","33","ⵣⵉ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵢⵜⵎⴰ, ⵅⵎⵉ ⵖⴰ ⵜⵎⵓⵏⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ, ⵔⴰⵊⴰⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C111_34","076_11_34","1CO","11","34","34","ⵎⴰⵍⴰ ⵃⴻⴷ ⴷⴰⵢⴻⵙ ⵍⴰⵥ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵛⵛ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵎⵓⵏⴻⵎ ⵉ ⵛⵛⵔⴻⵄ. ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⴷ ⵜ ⵄⴻⴷⵍⴻⵖ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C112_1","076_12_1","1CO","12","1","1","ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⴰⵔⵔⵓⵃ, ⴰ ⴰⵢⵜⵎⴰ, ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C112_2","076_12_2","1CO","12","2","2","ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴽⵓⴼⴼⴰⵔ ⵓ ⵜᵉⵜⵜⵡⴰⵏⴻⴷⵀⴻⵎ ⵖⴰⵔ ⵍ’ⴰⵚⵏⴰⵎ ⵉⴳⵏⴰⵡⴻⵏ ⴱⵍⴰ ⵎⴰ ⵜⵓⵛⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("C112_3","076_12_3","1CO","12","3","3","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴰⵔⴻⴳⴱⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ ⵢⴰⵙⵓⵄ!’, ⵓ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⵉⵏⵉⵏ: ‘ⵢⴰⵙⵓⵄ ⴷ ⵙⵉⴷⵉ!’, ⵎⵖⵉⵔ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("C112_4","076_12_4","1CO","12","4","4","ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵉⴼⴰⵔⵣⴻⵏ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("C112_5","076_12_5","1CO","12","5","5","ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉⴼⴰⵔⵣⴻⵏ, ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("C112_6","076_12_6","1CO","12","6","6","ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉⴼⴰⵔⵣⴻⵏ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C112_7","076_12_7","1CO","12","7","7","ⵎⴰⵛⴰ ⴰⵙⴰⵔⴳⴻⴱ ⵏ ⴰⵔⵔⵓⵃ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵄⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C112_8","076_12_8","1CO","12","8","8","ⴰⵇⴰ ⵙ ⴰⵔⵔⵓⵃ ⵉⵎⵎⴻⵡⵛ ⵉ ⵢⵉⵊⵊⴻⵏ ⴰⵡⴰⵍ ⵏ ⵜⵉⵖⵉⵜ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵡⴰⵍ ⵏ ⵜⵓⵙⵙⵏⴰ ⵙ ⴰⵔⵔⵓⵃ ⴷ ⵉⵊⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C112_9","076_12_9","1CO","12","9","9","ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵍ’ⵉⵎⴰⵏ ⵙ ⴰⵔⵔⵓⵃ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⵓⵙⴳⴻⵏⴼⵉ ⵙ ⴰⵔⵔⵓⵃ ⴷ ⵉⵊⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C112_10","076_12_10","1CO","12","10","10","ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⴻⵄⵊⴰⵢⴻⴱ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵎⴰⵀⴻⵏⴷ ⴰⴷ ⵉⵏⴻⴱⴱ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵍⴼⴰⵔⵣ ⵏ ⴰⵔⵔⵓⵃⴰⵜ, ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵍⵙⴰⵡⴻⵏ ⵓⵛⴰ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⴼⴻⵙⵙⴰⵔ ⵏ ⵉⵍⵙⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C112_11","076_12_11","1CO","12","11","11","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜ ⴰⵔⵔⵓⵃ ⴷ ⵉⵊⵊⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴱⴻⵟⵟⴰⵏ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⴰⵏⴻⵛⵜ ⵎⴰⵎⵎⴻⵛ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("C112_12","076_12_12","1CO","12","12","12","ⵎⵉⵏⵣⵉ ⴰⵎ ⴰⵔⵔⵉⵎⴻⵜ ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵓ ⵖⴰⵔⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵄⴰⴷ ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵔⵔⴰ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴰⵀⴰ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵓⵍⴰ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C112_13","076_12_13","1CO","12","13","13","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵖⴹⴻⵚ ⵎⴰⵔⵔⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵏⵉⵖ ⵓⴷⴰⵢⴻⵏ ⵏⵉⵖ ⵉⵔⴰⵎⵉⵢⵢⴻⵏ ⵏⵉⵖ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵉⵖ ⵉⵃⵓⵔⵔⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵙⵓ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("C112_14","076_12_14","1CO","12","14","14","ⵓⵍⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵙ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C112_15","076_12_15","1CO","12","15","15","ⵎⴰⵍⴰ ⴰⴹⴰⵔ ⴰⴷ ⵉⵏⵉ: “ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⴰⴼⵓⵙ, ⵡⴰⵔ ⴵⵉⵖ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ!”, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ?” ");
INSERT INTO rift_vpl VALUES ("C112_16","076_12_16","1CO","12","16","16","ⵓⵛⴰ ⵎⴰⵍⴰ ⴰⵎⴻⵣⵣⵓⵖ ⵉⵏⵏⴰ: “ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵜⵉⵟⵟ, ⵡⴰⵔ ⴵⵉⵖ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ!”, ⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵣⵉ ⴰⵔⵔⵉⵎⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("C112_17","076_12_17","1CO","12","17","17","ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⵜⵉⵟⵟ, ⵎⴰⵏⵉⵙ ⴷ ⵉⴽⴽⴰ ⵓⵙⴻⴵⵉ? ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵜⵓⵖⴰ-ⵜⵜ ⴷ ⴰⵙⴻⴵⵉ, ⵎⴰⵏⵉⵙ ⴷ ⵉⴽⴽⴰ ⵓⵛⴻⵎⵎⵉ? ");
INSERT INTO rift_vpl VALUES ("C112_18","076_12_18","1CO","12","18","18","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("C112_19","076_12_19","1CO","12","19","19","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ, ⵎⴰⵏⵉ ⵜⴻⴵⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵅⴻⵏⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("C112_20","076_12_20","1CO","12","20","20","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("C112_21","076_12_21","1CO","12","21","21","ⵜⵉⵟⵟ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵉⵏⵉ ⵉ ⵓⴼⵓⵙ: “ⵡⴰⵔ ⵛⴻⴽ ⵃⵡⵉⵊⴻⵖ ⵛⴰ!”, ⵏⵉⵖ ⵄⴰⵡⴻⴷ ⴰⵣⴻⴵⵉⴼ ⵉ ⵉⴹⴰⵔⴻⵏ: “ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵃⵡⵉⵊⴻⵖ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("C112_22","076_12_22","1CO","12","22","22","ⵎⴰⵛⴰ ⵙ ⵍⵄⴻⴽⵙ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵏⵉ ⵏⵃⴻⵙⵙⴻⴱ ⴹⴻⵄⴼⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵃⴷⴰⵊⴻⵏ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C112_23","076_12_23","1CO","12","23","23","ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⵉ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵖⵉⵍⴻⵏ ⴷ ⵉⵎⵓⵇⵍⵉⵍⴻⵏ, ⵏᵉⵜⵜⴻⴳⴳ ⴰⵙⴻⵏ ⵛⵛⴰⵏ ⴽⵜⴰⵔ, ⵓⵛⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⴰⵙⴻⴹⵃⵉ, ⴰⴷ ⴰⵙⴻⵏ ⵏⴻⵙⵙⵃⵉⵏⵏⴻⴱ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵀⵣⵓⵟ. ");
INSERT INTO rift_vpl VALUES ("C112_24","076_12_24","1CO","12","24","24","ⵎⵉⵏⵣⵉ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵖ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⵀⵣⵓⵟ, ⵡⴰⵔ ⵃⴷⴰⵊⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⴰⵔⵔⵉⵎⴻⵜ, ⵓⵛⴰ ⵉ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵇⴻⵍⵍ, ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵛⵛⴰⵏ ⴽⵜⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("C112_25","076_12_25","1CO","12","25","25","ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⴱⴻⵟⵟⵓ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⵢⵏⵉⵜ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵓⵇⴰⵔⴻⵏ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C112_26","076_12_26","1CO","12","26","26","ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵜᵉⵜⵜⴻⴽⴽ ⵅⴰⵙ ⵜⴰⵎⴰⵔⴰ, ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴰⴷ ⴽⵙⵉⵏ ⵜⴰⵎⴰⵔⴰ ⴰⴽⵉⴷⴻⵙ, ⵓ ⵎⴰⵍⴰ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵉⴼⴰⵔⵃ, ⴰⴷ ⴼⴰⵔⵃⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C112_27","076_12_27","1CO","12","27","27","ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C112_28","076_12_28","1CO","12","28","28","ⵣⴻⵄⵎⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⴳⴳⴰ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵔⵔⵓⵙⵓⵍ, ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ, ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ, ⴰⵡⴰⵔⵏⵉ ⴰⵙⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵏⴼⵉ, ⵉⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⴼⵓⵙ, ⵉⵏⵏⵉ ⵉⴹⴻⴱⴱⴰⵔⴻⵏ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵍⵙⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C112_29","076_12_29","1CO","12","29","29","ⵎⴰ ⵣⴻⵄⵎⴰ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⴷ ⵔⵔⵓⵙⵓⵍ? ⵎⴰ ⵎⴰⵔⵔⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ? ⵎⴰ ⵎⴰⵔⵔⴰ ⴷ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ? ⵎⴰ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ? ");
INSERT INTO rift_vpl VALUES ("C112_30","076_12_30","1CO","12","30","30","ⵎⴰ ⵎⴰⵔⵔⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴳⴻⵏⴼⵉ? ⵎⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵎⴰⵔⵔⴰ ⵙ ⵉⵍⵙⴰⵡⴻⵏ? ⵎⴰ ⵜⵜⴼⴻⵙⵙⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⵍⵙⴰⵡⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C112_31","076_12_31","1CO","12","31","31","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴰⵔⵣⵓⵎ ⵅⴻⵏⵏⵉ ⴷⵉ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⵇⴰⵄ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴻⵛⵏⴻⵖ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵢⵓⵄⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C113_1","076_13_1","1CO","13","1","1","“ⵎⴰⵄⵍⵉⴽ ⵏⴻⵛⵛ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏ ⵉⵡⴷⴰⵏ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⴱⵓ ⵜⴰⵢⵔⵉ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⵏⵏⵃⴰⵙ ⵉⵜⵜⴻⵏⵜⵓⵏⴻⵏ, ⵏⵉⵖ ⴷ ⴰⴵⵓⵏ ⵉⴷⴷⴻⵏⴷⵓⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C113_2","076_13_2","1CO","13","2","2","ⵎⴰⵄⵍⵉⴽ ⵖⴰⵔⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴱⴱⴻⵖ, ⴼⴻⵀⵀⵎⴻⵖ ⵎⴰⵔⵔⴰ ⵍⴻⵙⵔⴰⵔ ⵓ ⵖⴰⵔⵉ ⵎⴰⵔⵔⴰ ⵜⵓⵙⵙⵏⴰ ⴷ ⵎⴰⵔⵔⴰ ⵍ’ⵉⵎⴰⵏ ⴰⵍ ⴷ ⵙⵙⵎⵓⵟⵟⵉⵢⴻⵖ ⵉⴷⵓⵔⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⴵⵉ ⵜⴰⵢⵔⵉ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴷ ⵡⴰⵍⵓ ⵉ ⴵⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("C113_3","076_13_3","1CO","13","3","3","ⵎⴻⵄⵍⵉⴽ ⴱⴹⵉⵖ ⵎⴰⵔⵔⴰ ⴰⴳⵍⴰ ⵉⵏⵓ ⴷ ⵎⴰⵛⵛⴰ ⵅ ⵉⵎⴻⵣⵍⴰⴹ, ⵎⴰⵄⵍⵉⴽ ⵡⵛⵉⵖ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷⴰⵢⵉ ⵜⴻⴵⵉ ⵜⴰⵢⵔⵉ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵏⴻⴼⴼⴻⵄ ⴷⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("C113_4","076_13_4","1CO","13","4","4","ⵜⴰⵢⵔⵉ ⵜⴻⴵⴰ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ, ⵜⴰⵢⵔⵉ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵜⵓⵙⵎⵉ, ⵜⴰⵢⵔⵉ ⵡⴰⵔ ⵜᵉⵜⵜⴼⴻⵢⵢⴻⵛ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵏⵏⴼⴰⵅⴻⵜ,    ");
INSERT INTO rift_vpl VALUES ("C113_5","076_13_5","1CO","13","5","5","ⵜⴰⵢⵔⵉ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳ ⴱⵓ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵡⴰⵔ ⵜⴰⵔⴻⵣⵣⵓ ⵜⵉⵣⵉ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⵣⴰⴳ, ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵅⴻⵎⵎⴰⵎ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C113_6","076_13_6","1CO","13","6","6","ⴰⵇⴰ ⵡⴰⵔ ⵜⴼⴰⵔⵔⴻⵃ ⵛⴰ ⵣⵉ ⵍⵖⴻⵛⵛ, ⵎⴰⵛⴰ ⵜⴼⴰⵔⵔⴻⵃ ⵣⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("C113_7","076_13_7","1CO","13","7","7","ⴰⵇⴰ ⵜⵚⴻⴱⴱⴻⵔ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵜᵉⵜⵜⴰⵎⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵜⴻⵙⵙⴰⵜⴻⵎ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵜⴰⵔⴻⴱⴱⵓ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C113_8","076_13_8","1CO","13","8","8","ⵜⴰⵢⵔⵉ ⵡⴰⵔ ⵜⴼⴻⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ, ⵎⴰⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏ ⵏⵏⵓⴱⵓⵡⴰⵜ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ ⵓⵏⴻⴳⴳⴰⵔ, ⵉⵍⵙⴰⵡⴻⵏ ⴰⴷ ⴳⵏⵓⵏ, ⵓ ⵜⵓⵙⵙⵏⴰ ⴰⴷ ⵜⴻⴱⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C113_9","076_13_9","1CO","13","9","9","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵡⴰⵀⴰ, ⵓⵛⴰ ⵏⴻⵜⵜⵏⴰⴱⴱ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C113_10","076_13_10","1CO","13","10","10","ⵎⴰⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⴰⴷ ⵉⴱⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C113_11","076_13_11","1CO","13","11","11","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵙⵙⵉⵡⵍⴻⵖ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ, ⴼⴻⴽⴽⴰⵔⴻⵖ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ, ⵅⴰⵔⵚⴻⵖ ⴰⵎ ⵓⵃⴻⵏⵊⵉⵔ, ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵔⵢⴰⵣ, ⵊⵊⵉⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵓⵃⴻⵏⵊⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("C113_12","076_13_12","1CO","13","12","12","ⵍⴻⵅⵅⵓ ⵏⴻⵜⵜⵡⴰⵍⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵉⵙⵉⵜ ⵉⴱⴰⵔⵛⵏⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴰⵔⵡⴰⵙ, ⵎⴰⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⵥⴰⵔ ⵜⵉⴼⵔⴰⵙ ⵖⴰⵔ ⵜⵉⴼⵔⴰⵙ. ⵍⴻⵅⵅⵓ ⵙⵙⵏⴻⵖ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵙⵙⵏⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⵖ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("C113_13","076_13_13","1CO","13","13","13","ⵎⴰⵖⴰⵔ ⵜⵍⴰⵜⴰ-ⵢⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ: ⵍ’ⵉⵎⴰⵏ, ⴰⵙⵉⵜⴻⵎ ⴷ ⵜⴰⵢⵔⵉ, ⵎⴰⵛⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵢⵔⵉ.” ");
INSERT INTO rift_vpl VALUES ("C114_1","076_14_1","1CO","14","1","1","ⴹⴼⴰⵔⴻⵎ ⵜⴰⵢⵔⵉ ⵓ ⵏⵊⴻⴱⴷⴻⵎ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⴰⵔⵔⵓⵃ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⵏⴻⴱⴱⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("C114_2","076_14_2","1CO","14","2","2","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵡⴰⵔ ⵉⵙⵙⵉⵡⵉⵍ ⵛⴰ ⵉ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⴼⴻⵀⵀⴻⵎ, ⵎⴰⵛⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵍⴻⵙⵔⴰⵔ ⵙ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("C114_3","076_14_3","1CO","14","3","3","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ, ⵉⵙⵙⴰⵡⴰⵍ ⵖⴰⵔ ⵢⴻⵡⴷⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵉⴱⵏⴰ, ⴰⴷ ⵜⴻⵏ ⵉⵙⴻⵊⵊⴻⵄ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("C114_4","076_14_4","1CO","14","4","4","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⵉⴱⴻⵏⵏⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⵉⴱⴻⵏⵏⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("C114_5","076_14_5","1CO","14","5","5","ⵉⵡⴰ ⵅⵙⴻⵖ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵎⵍⵉⵃ ⵄⴰⴷ ⴰⴷ ⵜⵏⴻⴱⴱⴰⵎ, ⵎⵉⵏⵣⵉ ⴰⵎⴻⵏⵣⵓ ⵡⵉ ⵉⵜⵜⵏⴻⴱⴱⴰⵏ ⵅ ⵡⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⵖⵉⵔ ⵎⴰⵍⴰ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵜ ⵉⴼⴻⵙⵙⴰⵔ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⴼⴻⵙⵙⴰⵔ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("C114_6","076_14_6","1CO","14","6","6","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵍⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵏ ⵏⵏⴼⴻⵄ ⵉ ⵖⴰⵔⵡⴻⵎ ⵉ ⵖⴰ ⵢⴰⵡⵢⴻⵖ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵛⴰ ⵙ ⵓⵙⴰⵔⴳⴻⴱ ⵏⵉⵖ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏⵉⵖ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⵖⴰ ⵏⴻⴱⴱⴻⵖ ⵏⵉⵖ ⵙ ⵓⵙⴻⵍⵎⴻⴷ? ");
INSERT INTO rift_vpl VALUES ("C114_7","076_14_7","1CO","14","7","7","ⵎⴰⵖⴰⵔ ⵓⵍⴰ ⴷ ⵍⴻⵃⵡⴰⵢⴻⵛ ⵡⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ ⴰⵎ ⵜⴰⵎⵊⴰ ⵏⵉⵖ ⵍⴳⴰⵎⴱⵔⵉ, ⴳⴳⵉⵏ ⵍⵃⴻⵙⵙ. ⵎⴰⵍⴰ ⵡⴰⵔ ⴳⴳⵉⵏ ⵍⴼⴰⵔⵣ ⵊⴰⵔ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⴷ ⵓⵎⴰⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵙⵙⵏⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵎⵉⵏ ⵜⵜⵉⵔⴰⵔⴻⵏ ⵙ ⵜⴰⵎⵊⴰ ⵏⵉⵖ ⵙ ⵍⵀⴰⵔⴱⴰ? ");
INSERT INTO rift_vpl VALUES ("C114_8","076_14_8","1CO","14","8","8","ⵉⵡⴰ, ⵎⴰⵍⴰ ⴰⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵉⵜⵜⴻⴳⴳ ⵍⵃⴻⵙⵙ ⵡⴰⵔ ⵉⵚⴼⵉ, ⵡⵉ ⵖⴰ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵅⴻⵏⵏⵉ ⵉ ⵓⵎⴻⵏⵖⵉ? ");
INSERT INTO rift_vpl VALUES ("C114_9","076_14_9","1CO","14","9","9","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵍⴰ ⵜⴻⵙⵙⵉⵡⵉⵍⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜⴼⴻⵙⵙⴰⵔⴻⵎ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⴼⴻⵀⵎⴻⵏ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⵎ? ⴰⴷ ⵜⴻⵙⵙⵉⵡⵍⴻⵎ ⵅⴻⵏⵏⵉ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴷⵉ ⵍⴻⵄⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C114_10","076_14_10","1CO","14","10","10","ⴰⵇⴰ ⴷⵉⵏ ⵡⵉ ⵉⵙⵙⵏⴻⵏ ⵎⴻⵛⵃⴰⵍ ⵏ ⵉⵍⵙⴰⵡⴻⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⴱⵍⴰ ⵍⵃⴻⵙⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C114_11","076_14_11","1CO","14","11","11","ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵍⴰⴵⴰⵖ ⵏ ⵍⵃⴻⵙⵙ, ⴰⴷ ⵉⵍⵉⵖ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⴱⴰⵔⵔⴰⵏⵉ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("C114_12","076_14_12","1CO","14","12","12","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ, ⵓⵎⵉ ⵜⴻⵏⵊⴻⴱⴷⴻⵎ ⵖⴰⵔ ⵜⴻⵡⵀⵉⴱⵉⵏ ⵏ ⴰⵔⵔⵓⵃ, ⴰⵔⵣⵓⵎ ⴰⴷ ⵜⴼⴻⵢⵢⴹⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("C114_13","076_14_13","1CO","14","13","13","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵛⴰ ⵏ ⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵉⵥⵥⴰⴵ ⵃⵉⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵉ ⵓⴼⴻⵙⵙⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C114_14","076_14_14","1CO","14","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵥⵥⵓⴵⴻⵖ ⵙ ⵛⴰ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⴰⵇⴰ ⵉⵥⵥⵓⴵ, ⵎⴰⵛⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵏⵓ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴱⵍⴰ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C114_15","076_14_15","1CO","14","15","15","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⴳⴳⴻⵖ? ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵙ ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴰⴷ ⵥⵥⴰⴵⴻⵖ ⵄⴰⵡⴻⴷ ⵙ ⵍⴻⵄⵇⴻⵍ ⵉⵏⵓ, ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵙ ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴰⴷ ⵖⴻⵏⵏⵊⴻⵖ ⵄⴰⵡⴻⴷ ⵙ ⵍⴻⵄⵇⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C114_16","076_14_16","1CO","14","16","16","ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵍⴰ ⵜⴱⴰⵔⴽⴻⵎ ⵙ ⴰⵔⵔⵓⵃ, ⵉⵣⴻⵎⵎⴰⵔ ⵃⴻⴷ ⵉ ⴷⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵎ ⵡⴰⵔ ⵉⴼⵀⵉⵎ, ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵎⵉⵏ!’ ⵉ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵇⴰⴷⵉ ⵏⵏⴻⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⵉⵏ ⵜⴻⵇⵇⴰⵔⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("C114_17","076_14_17","1CO","14","17","17","ⵎⵉⵏⵣⵉ ⵡⴰⵅⵅⴰ ⵛⴻⴽ ⵜⴱⴰⵔⴽⴻⴷ ⵎⵍⵉⵃ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵢⵓⴷⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴱⴻⵏⵏⵉ ⵛⴰ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C114_18","076_14_18","1CO","14","18","18","ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵙⵙⴰⵡⴰⵍⴻⵖ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ ⵎⴰⵔⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("C114_19","076_14_19","1CO","14","19","19","ⵎⴰⵛⴰ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⵇⴰ ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⴷ ⵉⵏⵉⵖ ⵅⴻⵎⵙⴰ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵙ ⵍⴻⵄⵇⴻⵍ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵍⴻⵎⴷⴻⵖ ⵄⴰⵡⴻⴷ ⵉⵏⵏⴻⵖⵏⵉ, ⵅ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C114_20","076_14_20","1CO","14","20","20","ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵜⴰⵔⵡⴰ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵉⵍⵉⵎ ⴷ ⵉⵙⴻⵢⵎⴰⵏ ⴷⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵓ ⵉⵍⵉⵎ ⵜⵉⵡⴹⴻⵎ ⴷⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C114_21","076_14_21","1CO","14","21","21","ⴰⵇⴰ ⵜⵓⵔⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ: “ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵉ ⵍⴳⴻⵏⵙ-ⴰ ⵙ ⵉⵊⵊ ⵏ ⵍⵀⴰⵔⴷ ⵏ ⵍⴱⴰⵔⵔⴰⵏⵉ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ. ⵡⴰⵅⵅⴰ ⴰⵎⵎⵓ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⵜⴻⵙⵍⵉⵏ ⵛⴰ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ.” ");
INSERT INTO rift_vpl VALUES ("C114_22","076_14_22","1CO","14","22","22","ⴰⵎⵎⵓ ⵅⴻⵏⵏⵉ ⵉⵍⵙⴰⵡⴻⵏ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ, ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵉ ⵉⵜⵜⵡⴰⵏⴰⴱⴱⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C114_23","076_14_23","1CO","14","23","23","ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵜⴻⵙⵙⵎⵓⵏ ⵓ ⵎⴰⵔⵔⴰ ⵜⵓⵖⴰ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵉⵍⵙⴰⵡⴻⵏ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵓⴷⴼⴻⵏ ⵉⵏⵏⵉ ⵉⵊⴻⵀⵍⴻⵏ ⵏⵉⵖ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⵎⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵡⴷⴰⵏ-ⴰ ⵜⵜⵅⴻⵍⴼⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C114_24","076_14_24","1CO","14","24","24","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵎⴰⵔⵔⴰ ⵜⵏⴻⴱⴱⴰⵎ ⵓⵛⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵃⴻⴷ ⵡⴰⵔ ⵢⵓⵎⵉⵏ ⵏⵉⵖ ⵃⴻⴷ ⵉⵊⵀⴻⵍ, ⵅⴻⵏⵏⵉ ⵡⴰⵏⵉⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵇⵏⴻⵄ ⵣⵉ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵡⴻⴱⴱⴻⵅ ⵣⵣⴰⵢⵡⴻⵎ ⵎⴰⵔⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("C114_25","076_14_25","1CO","14","25","25","ⵓⵛⴰ ⵎⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⴹⴰⵔ ⵙ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵊⴻⴷ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵢⵉⵏⵉ: “ⴰⵇⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⵊⴰⵔ ⴰⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("C114_26","076_14_26","1CO","14","26","26","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵜⵎⵓⵏⴻⵎ, ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵊⵊ ⵏ ⵓⵣⴻⵀⵀⵉⴷ ⵏⵉⵖ ⵉⵛⵜ ⵏ ⵜⵖⵓⵔⵉ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⵙⴰⵔⴳⴻⴱ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵢⵉⵍⴻⵙ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵓⴼⴻⵙⵙⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵏⵟⴻⵇ. ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵉ ⵍⴻⴱⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C114_27","076_14_27","1CO","14","27","27","ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵢⵉⵊⵊ ⵏ ⵉⵍⴻⵙ ⵏⵏⴻⵖⵏⵉ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵙ ⵡⴰⵟⵟⴰⵙ ⵙ ⵜⵍⴰⵜⴰ ⵢⵉⴷⵙⴻⵏ, ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵙ ⵏⵏⵓⴱⴻⵜ ⵏⵏⴻⵙ, ⵓ ⴻⵊⵊ ⵉⵊⵊ ⴰⴷ ⵜ ⵉⴼⴻⵙⵙⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C114_28","076_14_28","1CO","14","28","28","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⴼⴻⵙⵙⴰⵔ, ⴰⴷ ⵉⵙⵇⴰⵔ ⵏⴻⵜⵜⴰ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C114_29","076_14_29","1CO","14","29","29","ⵊⵊⴻⵎ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴷ ⵃⴻⴽⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C114_30","076_14_30","1CO","14","30","30","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵛⴰ ⵉ ⵃⴻⴷ ⴰⵎ ⵉⵇⵇⵉⵎ ⴷⵉⵏⵏⵉ, ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⵓⵙⴻⵎ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ");
INSERT INTO rift_vpl VALUES ("C114_31","076_14_31","1CO","14","31","31","ⵎⵉⵏⵣⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⵏⴻⴱⴱⴰⵎ ⵎⴰⵔⵔⴰ ⵉⵊⵊⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵃⵉⵎⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ ⵡⵓⵍ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C114_32","076_14_32","1CO","14","32","32","ⵎⴰⵖⴰⵔ ⴰⵔⵔⵓⵃ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⴰⵇⴰ-ⵜ ⵉⵎⵎⴰⵔⵙ ⵙⴰⴷⵓ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C114_33","076_14_33","1CO","14","33","33","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵅⴰⵔⵡⴻⴹ, ⵎⴰⵛⴰ ⵏ ⵍⴻⵀⵏⴰ, ⴰⵎⵎⵓ ⵉ ⵢⴻⴵⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C114_34","076_14_34","1CO","14","34","34","ⵜⵓⵙⴰ-ⴷⴷ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⴰⴷ ⵙⵙⵓⵙⵎⴻⵏⵜ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏⵜ ⵉⵙⵎⵉⵃ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏⵜ, ⵎⴰⵛⴰ ⵉⵛⵓⵡⵡⴰⵔ ⴰⵙⴻⵏⵜ ⴰⴷ ⵉⵍⵉⵏⵜ ⵜⵜⵡⴰⴹⵄⴻⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵇⵇⴰⵔ ⵄⴰⵡⴻⴷ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("C114_35","076_14_35","1CO","14","35","35","ⵓⵛⴰ ⵎⴰⵍⴰ ⵅⵙⴻⵏⵜ ⴰⴷ ⵍⴻⵎⴷⴻⵏⵜ ⵛⴰ, ⴰⴷ ⵙⵙⴻⵇⵙⴰⵏⵜ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵏⵜ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("C114_36","076_14_36","1CO","14","36","36","ⵎⴰ ⵣⴻⵄⵎⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵏⵉⵖ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵡⴰⵀⴰ? ");
INSERT INTO rift_vpl VALUES ("C114_37","076_14_37","1CO","14","37","37","ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴷ ⴰⵏⴰⴱⵉ ⵏⵉⵖ ⴷ ⴱⵏⴰⴷⴻⵎ ⴰⵔⵔⵓⵃⴰⵏⵉ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵄⵇⴻⵍ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵜⵜⴰⵔⵉⵖ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C114_38","076_14_38","1CO","14","38","38","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵅⵙ ⵃⴻⴷ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⵊⵀⴻⵍ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵊⵀⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C114_39","076_14_39","1CO","14","39","39","ⴰⵎⵎⵓ ⵅⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵏⵊⴻⴱⴷⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵜⵏⴻⴱⴱⴰⵎ, ⵡⴰⵔ ⵎⴻⵏⵏⵄⴻⵎ ⵛⴰ ⴰⵡⴰⵍ ⵙ ⵉⵍⵙⴰⵡⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C114_40","076_14_40","1CO","14","40","40","ⴰⴷ ⵉⵎⵙⴰⵔ ⵎⴰⵔⵔⴰ ⵙ ⵍⴰⴷⴰⴱ ⵓ ⵙ ⵓⵙⴻⵜⵜⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("C115_1","076_15_1","1CO","15","1","1","ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⴰⴷ ⴰⵡⴻⵎ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅ ⵍ’ⵉⵏⵊⵉⵍ ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵇⴻⴱⵍⴻⵎ ⵓ ⴷ ⵡⴻⵏⵏⵉ ⴷⵉ ⵜⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("C115_2","076_15_2","1CO","15","2","2","ⵉ ⵣⵉ ⵜᵉⵟⵟⴼⴻⵎ ⵜⵓⴷⴰⵔⵜ, ⵙ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ, ⵎⴰⵍⴰ ⵅⴰⵙ ⵜⵄⴻⵇⵍⴻⵎ ⵄⴰⴷ. ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⵖⵏⵉ, ⵣⴻⵄⵎⴰ ⵜⵓⵎⵏⴻⵎ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_3","076_15_3","1CO","15","3","3","ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⵙⵙⴻⵄⴷⵓⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵟⵟⴼⴻⵖ ⵙ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵉⵎⵎⵓⵜ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵢⵓⵔⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("C115_4","076_15_4","1CO","15","4","4","ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵍ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵢⵓⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_5","076_15_5","1CO","15","5","5","ⵏⴻⵜⵜⴰ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵖⴰⵔ ⴽⵉⴼⴰ, ⵅⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵎⴻⵃⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_6","076_15_6","1CO","15","6","6","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴱⴰⵏ-ⴷⴷ ⵉ ⵜⵉⵡⵡⴰ ⵏ ⵅⴻⵎⵙⴰ-ⵎⵢⴰ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⴷⴻⴳ ⵓⵎⵓⵔ ⴷ ⵉⵊⵊⴻⵏ, ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷⴰⵔⴻⵏ ⵄⴰⴷ ⴰⵍ ⵉ ⵍⴻⵅⵅⵓ, ⵎⴰⵛⴰ ⵉⵏⵏⴻⵖⵏⵉ ⴰⵇⴰ ⵟⵟⵚⴻⵏ ⵉⴹⴻⵚ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_7","076_15_7","1CO","15","7","7","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⴹⵀⴰⵔ-ⴷⴷ ⵉ ⵢⴰⵄⵇⵓⴱ, ⵅⴻⵏⵏⵉ ⵉ ⵎⴰⵔⵔⴰ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("C115_8","076_15_8","1CO","15","8","8","ⴰⵎ ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵎⴰⵔⵔⴰ, ⵉⴹⵀⴰⵔ ⴰⵢⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⵅⵍⵓⵇ ⴷⴷ-ⵉⵣⵡⴰⵔⴻⵏ ⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C115_9","076_15_9","1CO","15","9","9","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴵⵉⵖ ⴷ ⴰⵎⴰⵥⵓⵥ ⵇⴰⵄ ⵣⵉ ⵔⵔⵓⵙⵓⵍ, ⵡⴰⵔ ⵙⴷⵉⵀⵉⵊⴻⵖ ⴰⴷ ⴰⵢⵉ ⵍⴰⵖⴰⵏ ⵔⵔⴰⵙⵓⵍ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⴷⴰⵔⵔⵛⴻⵖ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C115_10","076_15_10","1CO","15","10","10","ⵎⴰⵛⴰ ⵙ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴵⵉⵖ ⵎⵉⵏ ⴵⵉⵖ ⵓⵛⴰ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵉ ⴷⴰⵢⵉ ⵉⴵⴰⵏ ⵡⴰⵔ ⵉⴵⵉ ⴱⴰⵟⴻⵍ, ⵎⵉⵏⵣⵉ ⵅⴻⴷⵎⴻⵖ ⵎⴰⵀⵓ ⵇⴰⵄ ⵅⴰⵙⴻⵏ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C115_11","076_15_11","1CO","15","11","11","ⵅⴻⵏⵏⵉ ⵎⴰ ⴷ ⵏⴻⵛⵛ ⵏⵉⵖ ⴷ ⵏⵉⵜⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ, ⴰⵎⵎⵓ ⵉ ⵜⵓⵎⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C115_12","076_15_12","1CO","15","12","12","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵎⴰⵎⵎⴻⵛ ⵅⴻⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵛⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⴷ ⵉⵏⵉⵏ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵓⴷⴰⵔⵜ ⵉ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C115_13","076_15_13","1CO","15","13","13","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵜⵓⴷⴰⵔⵜ ⵉ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵓⵍⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("C115_14","076_15_14","1CO","15","14","14","ⵓⵛⴰ ⵎⴰⵍⴰ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ, ⵅⴻⵏⵏⵉ ⴱⴰⵟⴻⵍ ⵉ ⵜⴻⴵⴰ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏⵏⴻⵖ, ⴱⴰⵟⴻⵍ ⵉ ⵢⴻⴵⴰ ⵅⴻⵏⵏⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C115_15","076_15_15","1CO","15","15","15","ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴱⴰⵏ ⵄⴰⵡⴻⴷ ⴷ ⵍⴻⵛⵀⵓⴷ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵀⴻⴷ ⵅ ⴰⵔⴻⴱⴱⵉ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ-ⴷⴷ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_16","076_15_16","1CO","15","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵜⵜᵉⵜⵡⴰⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵛⴰ, ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("C115_17","076_15_17","1CO","15","17","17","ⵓ ⵎⴰⵍⴰ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵛⴰ, ⴰⵇⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⵉⵅⵡⴰ, ⵓ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C115_18","076_15_18","1CO","15","18","18","ⵓⵛⴰ ⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⵚⴻⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵎⵎⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_19","076_15_19","1CO","15","19","19","ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵏⴻⵙⵙⵉⵜⵉⵎ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⵜⵓⴷⴰⵔⵜ-ⴰ ⵡⴰⵀⴰ, ⴰⵇⴰ ⴰⵏⴻⵖ ⵇⴰⵄ ⴷ ⵉⵎⵛⵓⵎⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_20","076_15_20","1CO","15","20","20","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵓⵎⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵏⵣⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵟⵟⵚⴻⵏ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C115_21","076_15_21","1CO","15","21","21","ⵓ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⵓⵙⴰ ⵍⵎⴻⵡⵜ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⴰⵏⵓⴽⵔⴰ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵜⴻⴵⴰ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C115_22","076_15_22","1CO","15","22","22","ⵎⵉⵏⵣⵉ ⴰⵎ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵎⵎⵜⴻⵏ ⴷⵉ ⴰⴷⴰⵎ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵉ ⵖⴰ ⴷⴷⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ ⵄⴰⵡⴻⴷ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C115_23","076_15_23","1CO","15","23","23","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⴷⵉ ⵏⵏⵓⴱⴻⵜ ⵏⵏⴻⵙ: ⵍⵎⴰⵙⵉⵃ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⵏⵣⵓ, ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵖⴰⵔ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C115_24","076_15_24","1CO","15","24","24","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ, ⵅⵎⵉ ⵖⴰ ⵉⵡⵛ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵅⵎⵉ ⵖⴰ ⵉⵙⵙⴻⴱⴹⴻⵍ ⵎⴰⵔⵔⴰ ⵍⴻⵃⴽⴰⵎⴻⵜ ⴷ ⵎⴰⵔⵔⴰ ⵚⵚⵓⵍⵟⴰ ⴷ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("C115_25","076_15_25","1CO","15","25","25","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⴰⵍ ⴷ ⵖⴰ ⵢⴻⴳⴳ ⵎⴰⵔⵔⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C115_26","076_15_26","1CO","15","26","26","ⵍⴻⵄⴷⵓ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴱⴻⴹⵍⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_27","076_15_27","1CO","15","27","27","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ⵎⴰⵛⴰ ⵅⵎⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ: “ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵏ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ!”, ⴰⵇⴰ ⵉⴱⴰⵏ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⴵⵉ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_28","076_15_28","1CO","15","28","28","ⵓⵛⴰ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⴳⴳ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵉ ⵏⴻⵜⵜⴰ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵙⴰⴷⵓ ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴷ ⴰⵙ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵉ ⵏⴻⵜⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵎⴰⵔⵔⴰ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_29","076_15_29","1CO","15","29","29","ⵏⵉⵖ, ⵎⵉⵏ ⵖⴰ ⴳⴳⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ? ⵎⴰⵖⴰⵔ ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⵄⴰⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C115_30","076_15_30","1CO","15","30","30","ⵓ ⵎⴰⵢⴻⵎⵎⵉ ⵏⴻⵛⵛⵉⵏ ⵄⴰⴷ ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⴷⵉ ⴽⵓⵍ ⵜⵙⴰⵄⵄⴻⵜ? ");
INSERT INTO rift_vpl VALUES ("C115_31","076_15_31","1CO","15","31","31","ⴰ ⴰⵢⵜⵎⴰ, ⵜⵜⵊⴰⴵⵉⵖ ⵖⴰⵔ ⵓⵙⴻⵎⵖⴰⵔ ⵏⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔⵉ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵜⵜⵎⴻⵜⵜⵉⵖ ⴽⵓⵍ ⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("C115_32","076_15_32","1CO","15","32","32","ⵓ ⵎⴰⵎⵎⴻⵛ, ⵎⴰⵍⴰ ⵜⵜⵡⴰⵎⴻⵏⴹⴰⵔⴻⵖ ⵣⵣⴰⵜ ⵉ ⵍⴻⵡⵃⵓⵛ ⴷⵉ ⴰⴼⴰⵙⵓⵙ ⵅ ⵍⴻⵃⵙⴰⴱ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵉ ⵖⴰⵔⵉ, ⵎⴰⵍⴰ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵛⴰ? ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵛⵛ ⴰⴷ ⵏⵙⵓ, ⵎⵉⵏⵣⵉ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵏⴻⵎⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_33","076_15_33","1CO","15","33","33","ⵡⴰⵔ ⵜⵜⵖⴻⵛⵛⵉⵎ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ: ⵍⵀⴰⵔⴷ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵜⵊⴻⵢⵢⴰⵃ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_34","076_15_34","1CO","15","34","34","ⵙⴼⴰⵇⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ, ⵡⴰⵔ ⵅⴻⵟⵟⵉⵎ ⵛⴰ. ⵎⵉⵏⵣⵉ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵉ ⵍⴻⵃⵢⴰ ⵏⵡⴻⵎ ⵇⵇⴰⵔⴻⵖ ⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_35","076_15_35","1CO","15","35","35","ⴰⴷ ⵉⵏⵉⵏ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ: “ⵎⴰⵎⵎⴻⵛ ⵉ ⴷⴷ ⵖⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ? ⵙ ⵎⴰⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ?” ");
INSERT INTO rift_vpl VALUES ("C115_36","076_15_36","1CO","15","36","36","ⴰ ⴰⴼⵖⵓⵍ, ⵎⵉⵏ ⵜⵣⴰⵔⵔⵄⴻⴷ ⵛⴻⴽ, ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵎⵎⵓⵜ ⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C115_37","076_15_37","1CO","15","37","37","ⵎⵉⵏ ⵜⵣⴰⵔⵔⵄⴻⴷ, ⵡⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ, ⵎⴰⵛⴰ ⵜⵣⴰⵔⵔⵄⴻⴷ ⵜⴰⵄⴻⵇⵇⴰⵛⵜ ⵉⵖⴻⵔⵢⴻⵏ ⵏ ⵢⵉⵔⴷⴻⵏ ⵏⵉⵖ ⵏ ⵉⵎⴻⵏⴷⵉ ⵏⵉⵖ ⵏ ⵛⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C115_38","076_15_38","1CO","15","38","38","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵙ ⴰⵔⵔⵉⵎⴻⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⵉ ⴽⵓⵍ ⴷⴷⴰⴱ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉⵡⵛⴰ ⴰⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⴽⵓⵍ ⵉⵛⵜⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_39","076_15_39","1CO","15","39","39","ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵉⵊⵊ, ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉ ⵏ ⵉⵡⴷⴰⵏ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅ ⵜⴻⵏⵏⵉ ⵏ ⵍⵎⴰⵍ, ⵓ ⵜⴻⵏⵏⵉ ⵏ ⵉⵊⴹⴰⴹ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵏ ⵜⴻⵏⵏⵉ ⵏ ⵉⵙⴻⵍⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_40","076_15_40","1CO","15","40","40","ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⵔⵉⵎⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⴷ ⴰⵔⵔⵉⵎⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⵢⵉⵏⵏⵉ ⵏ ⵓⵊⴻⵏⵏⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵏ ⵢⵉⵏⵏⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_41","076_15_41","1CO","15","41","41","ⵉⵊⵊⴻⵏ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵜⴼⵓⵛⵜ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵓⵢⵓⵔ, ⵓ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷ ⴰⵄⵓⴵⵉ ⵏ ⵉⵜⵍⴰⵏ, ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏ ⵉⵊⵊ ⵏ ⵉⵜⵍⵉ ⵉⵄⴻⴷⴷⵓⵏ ⵅ ⵓⵄⵓⴵⵉ ⵏ ⵉⵊⵊ ⵏ ⵉⵜⵍⵉ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C115_42","076_15_42","1CO","15","42","42","ⴰⵎⵎⵓ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⵉⵏⵏⵉ ⵎⵎⵓⵜⴻⵏ. ⴰⵇⴰ ⵜⵜⵡⴰⵣⴰⵔⵔⵄⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵎⵉⵏ ⵉⵖⴻⵛⵛⴻⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ-ⴷⴷ ⴱⵍⴰ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("C115_43","076_15_43","1CO","15","43","43","ⴰⵇⴰ ⵜⵜⵡⴰⵣⴰⵔⵔⵄⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵛⵏⵉⵄⴻⵏ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⴷⴻⴳ ⵓⵄⵓⴵⵉ. ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵣⴰⵔⵔⵄⴻⵏ ⴷⴻⴳ ⵡⴻⴹⵄⴰⴼ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⴷⵉ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("C115_44","076_15_44","1CO","15","44","44","ⴰⵇⴰ ⵜⵜⵡⴰⵣⴰⵔⵔⵄⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵟⵟⴱⵉⵄⴻⵜ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔ ⴱⵏⴰⴷⴻⵎ ⵙ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵜⴰⵔⵔⵓⵃⴰⵏⵉⵜ. ⴰⵇⴰ ⴷⵉⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵟⵟⴱⵉⵄⴻⵜ, ⴰⵎⵎⵓ ⴰⵇⴰ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("C115_45","076_15_45","1CO","15","45","45","ⴰⵎⵎⵓ ⵉ ⵜⵓⵔⴰ ⵄⴰⵡⴻⴷ: “ⴰⵔⵢⴰⵣ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⴷⴰⵎ, ⵉⴷⵡⴻⵍ ⴷ ⵍⴻⵄⵎⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ!”, ⴰⴷⴰⵎ ⴰⵏⴻⴳⴳⴰⵔⵓ ⵉⴷⵡⴻⵍ ⴷ ⴰⵔⵔⵓⵃ ⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C115_46","076_15_46","1CO","15","46","46","ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵉ ⴰⵔⵔⵓⵃ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ ⵛⴰ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵟⵟⴱⵉⵄⴻⵜ, ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵉ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("C115_47","076_15_47","1CO","15","47","47","ⴱⵏⴰⴷⴻⵎ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⴽⴽⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵛⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⴱⵏⴰⴷⴻⵎ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷ ⵙⵉⴷⵉ ⵉ ⴷⴷ-ⵉⴽⴽⵉⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_48","076_15_48","1CO","15","48","48","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵣⴻⴳ ⵓⵛⴰⵍ, ⴰⵎⵎⵓ ⵉ ⴵⴰⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵓⵛⴰⵍ, ⵓⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵡⴻⵏⵏⵉ ⵏ ⵓⵊⴻⵏⵏⴰ, ⴰⵎⵎⵓ ⵉ ⴵⴰⵏ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_49","076_15_49","1CO","15","49","49","ⵓⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴰⵔⴱⵓ ⵚⵚⵉⴼⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵣⴻⴳ ⵓⵛⴰⵍ, ⴰⵎⵎⵓ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴰⵔⴱⵓ ⵚⵚⵉⴼⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_50","076_15_50","1CO","15","50","50","ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⴷⴷⴻⴳⴳⴰ ⵅⵙⴻⵖ ⴰⴷ ⵉⵏⵉⵖ: ⴰⵇⴰ ⴰⵢⵙⵓⵎ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵡⴰⵔⵜⴻⵏ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⵉⵊⴻⵏⵡⴰⵏ, ⵓⵛⴰ ⵎⵉⵏ ⵉⴼⴻⵏⵏⴰⵏ ⵡⴰⵔ ⵉⵡⴰⵔⵔⴻⵜ ⵎⵉⵏ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_51","076_15_51","1CO","15","51","51","ⵅⵣⴰⵔⴻⵎ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴰⵔⴻⴳⴱⴻⵖ ⵅ ⵉⵊⵊ ⵏ ⵙⵙⵉⵔⵔ: ⴰⵇⴰ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏⴻⵜⵜᵉⵟⵟⴻⵚ ⵛⴰ ⵎⴰⵔⵔⴰ ⵙ ⵢⵉⴹⴻⵚ ⵏ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵎⴰⵔⵔⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴱⴻⴷⴷⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("C115_52","076_15_52","1CO","15","52","52","ⴷⴻⵖⵢⴰ, ⴷⴻⴳ ⵡⴻⵔⵎⴰⵛ ⵏ ⵡⴰⴱⵍⵉⵡⴻⵏ, ⵖⴰⵔ ⵍⵃⴻⵙⵙ ⵏ ⵓⵙⵓⴹⵉ ⴰⵏⴻⴳⴳⴰⵔⵓ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ: ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴰⴷ ⴷⴷ-ⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵖⴰⵔ ⵎⵉⵏ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴱⴻⴷⴷⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C115_53","076_15_53","1CO","15","53","53","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⴼⴻⵏⵏⴰⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵢⴰⵔⴹ ⵎⵉⵏ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⵓ ⵎⵉⵏ ⵖⴰ ⵉⵎⵎⵓⵜⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵢⴰⵔⴹ ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C115_54","076_15_54","1CO","15","54","54","ⵓⵛⴰ ⵅⵎⵉ ⵎⵉⵏ ⵉⴼⴻⵏⵏⴰⵏ ⴰⴷ ⵢⴰⵔⴹ ⵎⵉⵏ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⵓ ⵎⵉⵏ ⵖⴰ ⵉⵎⵎⵓⵜⴻⵏ ⴰⴷ ⵢⴰⵔⴹ ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵎⴻⵜⵜⵉⵏ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵉ ⵉⵜⵜⵡⴰⵔⵉⵏ: “ⵍⵎⴻⵡⵜ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵚⴰⵔⴹ ⴷⴻⴳ ⵍⴻⵖⵍⴻⴱ.” ");
INSERT INTO rift_vpl VALUES ("C115_55","076_15_55","1CO","15","55","55","“ⴰ ⵍⵎⴻⵡⵜ, ⵎⴰⵏⵉ ⵉⴵⴰ ⵓⵙⴻⵏⵏⴰⵏ ⵏⵏⴻⵎ? ⴰ ⵍⴰⵅⴰⵔⵜ, ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⴻⵖⵍⴻⴱ ⵏⵏⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("C115_56","076_15_56","1CO","15","56","56","ⴰⵇⴰ ⴰⵙⴻⵏⵏⴰⵏ ⵏ ⵍⵎⴻⵡⵜ ⴷ ⴷⴷⴻⵏⴱ, ⵓⵛⴰ ⵊⵊⴻⵀⴷ ⵏ ⴷⴷⴻⵏⴱ ⴰⵇⴰ-ⵜⵜ ⴷ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("C115_57","076_15_57","1CO","15","57","57","ⵎⴰⵛⴰ ⴰⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⵍⴻⵖⵍⴻⴱ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C115_58","076_15_58","1CO","15","58","58","ⵙ ⵓⵢⴰ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ, ⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⵓ ⴱⵍⴰ ⴰⵏⵀⴻⵣⵣⵉ, ⴰⵔⵏⵉⵎ ⵍⴻⴱⴷⴰ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵙⵉⴷⵉ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⴰⵎ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜⴻⴵⵉ ⴱⴰⵟⴻⵍ ⴷⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C116_1","076_16_1","1CO","16","1","1","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵙⵎⵓⵏⵉ ⵏ ⵚⵚⴷⴰⵇⵉ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⴳⴳⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴹⴻⴱⴱⵔⴻⵖ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⴳⴰⵍⴰⵟⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C116_2","076_16_2","1CO","16","2","2","ⴽⵓⵍ ⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵃⵓⵣ ⵛⴰ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵜⵜ ⵉⵅⴻⵎⵎⴻⵍ ⵄⵍⴰⵃⵙⴰⴱ ⵎⴰⵎⵎⴻⵛ ⵉⵡⴻⵙⵙⴻⵄ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴰⵡⴹⴻⵖ, ⵡⴰⵔ ⵉⴱⴻⴷⴷⵉ ⵄⴰⴷ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵡⴻⵙⵎⵓⵏⵉ ⵏ ⵚⵚⴷⴰⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("C116_3","076_16_3","1CO","16","3","3","ⵓⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴰⵡⴹⴻⵖ, ⴰⴷ ⵙⵙⴻⴽⴽⴻⵖ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵜⴼⴰⵔⵣⴻⵎ ⴽⴻⵏⵏⵉⵡ ⴰⴽ-ⴷ ⵜⴻⴱⵔⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⵢⴻⵏ ⵜⴰⵛⵔⵉⵎⴻⵜ ⵏ ⵚⵚⴷⴰⵇⵉ ⵏⵡⴻⵎ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("C116_4","076_16_4","1CO","16","4","4","ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵔⴰⵃⴻⵖ ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⴷⵉⵏⵏⵉ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵔⴰⵃⴻⵏ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C116_5","076_16_5","1CO","16","5","5","ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⴽⴽⴻⵖ ⵅ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⴽⴽⴻⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("C116_6","076_16_6","1CO","16","6","6","ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵏⵉⵖ ⴰⴷ ⵙⵙⴻⵄⴷⵓⵖ ⵍⵎⴻⵛⵜⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴻⴱⴱⴹⴻⵎ ⵎⴰⵏⵉ ⵖⴰ ⵔⴰⵃⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C116_7","076_16_7","1CO","16","7","7","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ ⵍⴻⵅⵅⵓ ⴰⵎ ⴷⴷ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⴽⴽⴻⵖ ⴰⴱⵔⵉⴷ ⵡⴰⵀⴰ, ⵎⵉⵏⵣⵉ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵛⴰ ⵏ ⵍⵡⴻⵇⵜ, ⵎⴰⵍⴰ ⵉⵙⵎⴻⵃ ⵙⵉⴷⵉ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C116_8","076_16_8","1CO","16","8","8","ⵎⴰⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵄⴰⴷ ⴷⵉ ⴰⴼⴰⵙⵓⵙ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵄⵉⴷ ⵏ ⵅⴻⵎⵙⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C116_9","076_16_9","1CO","16","9","9","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵜⴻⵡⵡⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵎⴰⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⵄⴻⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C116_10","076_16_10","1CO","16","10","10","ⵎⴰⵍⴰ ⵢⵉⵡⴻⴹ-ⴷⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ ⵖⴰⵔⵡⴻⵎ, ⵃⴹⴰⵎ ⵎⴰⵃⴻⵏⴷ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⴱⵍⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵙⵉⴷⵉ ⴰⵎ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("C116_11","076_16_11","1CO","16","11","11","ⵙ ⵓⵢⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵜ ⵉⵙⵙⴻⵃⵇⴰⵔ, ⵎⴰⵛⴰ ⵇⴻⴱⴱⴹⴻⵎ ⵜ ⴷⵉ ⵍⴻⵀⵏⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵢⴰⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵜⵜⵔⴰⵊⵉⵖ ⵜ ⴰⴽ-ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C116_12","076_16_12","1CO","16","12","12","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⴰⵡⵎⴰⵜ ⴰⴱⵓⵍⵍⵓⵙ, ⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ ⵣⴰⵡⴳⴻⵖ ⵜ ⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵢⴰⵙ ⴰⴽ-ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵄⴻⵡⵡⴻⵍ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵍⴻⵅⵅⵓ, ⵎⴰⵛⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵅⵎⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵙⴰⵔⵔⴻⵃ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("C116_13","076_16_13","1CO","16","13","13","ⵃⴹⴰⵎ, ⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵃⴻⵣⵎⴻⵎ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ⵉⵍⵉⵎ ⵜⵎⴻⵃⴹⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C116_14","076_16_14","1CO","16","14","14","ⵊⵊⴻⵎ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("C116_15","076_16_15","1CO","16","15","15","ⵜⵜⵣⴰⵡⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵡⴰⵛⵓⵏⵜ ⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ, ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⴰⵅⴰⵢⴰ, ⵓ ⵏⵉⵜⵏⵉ ⵟⴻⵡⵡⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C116_16","076_16_16","1CO","16","16","16","ⴰⵇⴰ ⴳⴳⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙⴰⴷⵓ ⵓⴼⵓⵙ ⵏ ⵢⵉⵏⵏⵉ ⴰⵎ ⵏⵉⵜⵏⵉ ⵓⵛⴰ ⵙⴰⴷⵓ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ ⵓ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵄⴰⵡⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C116_17","076_16_17","1CO","16","17","17","ⴰⵇⴰ ⴼⴰⵔⵃⴻⵖ ⵙ ⵜⵡⴰⵙⵉⵜ ⵏ ⵙⵜⵉⴼⴰⵏⵓⵙ ⴷ ⴼⵓⵔⵜⵓⵏⴰⵜⵓⵙ ⴷ ⴰⵅⴰⵢⵉⴽⵓⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⴷⴰⵢⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C116_18","076_16_18","1CO","16","18","18","ⵙ ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵏⵓ ⴷ ⵡⴻⵏⵏⵉ ⵏⵡⴻⵎ. ⵡⴻⵇⵇⴰⵔⴻⵎ ⵉⵔⵢⴰⵣⴻⵏ ⴰⵎ ⵢⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C116_19","076_16_19","1CO","16","19","19","ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⴰⵙⵉⵢⴰ ⵜⵜⵙⴻⴵⴰⵎⴻⵏⵜ-ⵉ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ. ⴰⴽⵡⵉⵍⴰ ⴷ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⴰⵟⵟⴰⵙ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C116_20","076_16_20","1CO","16","20","20","ⵜⵜⵙⴻⴵⴰⵎⴻⵏ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ ⵙ ⵍⴻⵀⵏⴰ. ⵜⵜⵙⴻⴵⴰⵎⴻⵎ-ⴷⴷ ⵅ ⵡⴰⵢⴰⵡⵢⴰ ⵙ ⵍⴻⵀⵏⴰ ⵙ ⵓⵙⵓⴷⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C116_21","076_16_21","1CO","16","21","21","ⵉⵊⵊ ⵏ ⵙⵍⴰⵎ ⵉ ⵜⵜⴰⵔⵉⵖ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵣⵉ ⴱⵓⵍⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("C116_22","076_16_22","1CO","16","22","22","ⵎⴰⵍⴰ ⵃⴻⴷ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵏⵄⵓⵍ. ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ! ");
INSERT INTO rift_vpl VALUES ("C116_23","076_16_23","1CO","16","23","23","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C116_24","076_16_24","1CO","16","24","24","ⵜⴰⵢⵔⵉ ⵉⵏⵓ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵢⴰⵙⵓⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C21_1","077_1_1","2CO","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵜⴰⵡⵎⴰⵜ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⴽⵓⵔⵉⵏⵜⵓⵙ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵅⴰⵢⴰ:    ");
INSERT INTO rift_vpl VALUES ("C21_2","077_1_2","2CO","1","2","2","ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C21_3","077_1_3","2CO","1","3","3","ⵍⴱⴰⵔⴰⴽⴰ ⴰⵇⴰ-ⵜⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴱⴰⴱⴰⵙ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏ ⵎⴰⵔⵔⴰ ⴰⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("C21_4","077_1_4","2CO","1","4","4","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴼⴻⵡⵡⴰⵊ ⴰⵏⴻⵖ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵏⵇⴻⴷⴷ ⴰⴷ ⵏⴻⵙⵙⴼⴻⵡⵡⴻⵊ ⵅ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴵⴰ ⵍⵎⴻⵃⵏⴻⵜ ⴰⵎ ⵏⴻⵛⵛⵉⵏ, ⵙ ⵓⴼⴻⵡⵡⴻⵊ ⵉ ⵣⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⴻⵊ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C21_5","077_1_5","2CO","1","5","5","ⵎⵉⵏⵣⵉ ⴰⵎⴻⵏ ⵉⴼⴻⵢⵢⴻⴹ ⴷⴰⵢⵏⴻⵖ ⴰⵡⴻⴷⴷⴻⴱ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⵎⵎⵓ ⵉⴼⴻⵢⵢⴻⴹ ⵄⴰⵡⴻⴷ ⵓⴼⴻⵡⵡⴻⵊ ⵏⵏⴻⵖ ⵙ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C21_6","077_1_6","2CO","1","6","6","ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵍⴰ ⵃⵚⴰⵔⴻⵏ ⴰⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵃⵙⴰⵔ ⵉ ⵓⴼⴻⵡⵡⴻⵊ ⵏⵡⴻⵎ ⵓ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ. ⵓ ⵎⴰⵍⴰ ⵏⴻⵜⵜⵡⴰⴼⴻⵡⵡⴻⵊ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⵊⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵚⵚⴰⴱⵔ ⴰⵍⴰⵎⵉ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⴰⵡⴻⴷⴷⴻⴱ ⴰⵎ ⵏⴻⴽⵙⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⵡⴻⴷⴷⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("C21_7","077_1_7","2CO","1","7","7","ⴰⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵎⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⴻⵏ ⵎⴰⵍⴰ ⵜⵛⴰⵔⵔⵛⴻⵎ ⴷⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ, ⴰⴷ ⵜⵛⴰⵔⵛⴻⵎ ⵓⵍⴰ ⴷⴻⴳ ⵓⴼⴻⵡⵡⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("C21_8","077_1_8","2CO","1","8","8","ⴰ ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵅⵙ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵅ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⴽⴽⵉⵏ ⴷⵉ ⴰⵙⵉⵢⴰ, ⴰⵇⴰ ⵜⴻⴽⴽⴰ-ⴷⴷ ⵅⴰⵏⴻⵖ ⵍⵎⴻⵃⵏⴻⵜ ⵙⴻⵏⵏⴻⵊ ⵅ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵖ, ⴰⵍⴰⵎⵉ ⵄⵍⴰⵃⴰⵍ ⵏⴻⵇⴹⴻⵄ ⵍⴰⵢⴰⵙ ⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C21_9","077_1_9","2CO","1","9","9","ⴰⵇⴰ ⵏⴻⵃⴽⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵙ ⵍⵎⴻⵡⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵇⵇⵉ ⵛⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴰⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C21_10","077_1_10","2CO","1","10","10","ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⴼⴻⴽⴽ ⴰⵏⴻⵖ ⵣⵉ ⵍⵎⴻⵡⵜ ⵉⵏⴻⵇⵇⴻⵏ ⵓⵛⴰ ⵏⴻⵜⵜⵔⴰⵊⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ");
INSERT INTO rift_vpl VALUES ("C21_11","077_1_11","2CO","1","11","11","ⵙ ⵓⵄⴰⵡⴻⵏ ⵏ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵏⵡⴻⵎ ⵅⴰⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵜⴰⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⵡⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ ⴰⵟⵟⴰⵙ ⴰⴷ ⴰⵙ ⵇⴰⴷⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C21_12","077_1_12","2CO","1","12","12","ⵎⵉⵏⵣⵉ ⵡⴰ ⴷ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵖ, ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵏⴻⵖ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴰⵏⴻⵖ ⵏⴻⴳⴳⵓⵔ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵙ ⵚⴼⴰ ⴷ ⵜⴰⵣⴷⵓⴳⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵜⵉⵖⵉⵜ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⴷⵉ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("C21_13","077_1_13","2CO","1","13","13","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵏⵓⵔⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵎⵖⵉⵔ ⵎⵉⵏ ⵜⴻⵙⵙⵏⴻⵎ ⵓ ⴰⴷ ⴰⵙ ⵜⴼⴻⵀⵎⴻⵎ, ⵉⵡⴰ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵜⴼⴻⵀⵎⴻⵎ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ, ");
INSERT INTO rift_vpl VALUES ("C21_14","077_1_14","2CO","1","14","14","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵄⴰⵡⴻⴷ ⵜⴼⴻⵀⵎⴻⵎ ⵣⵣⴰⵢⵏⴻⵖ ⴷⵔⵓⵙ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C21_15","077_1_15","2CO","1","15","15","ⴷⵉ ⵍⴰⵎⴰⵏ-ⴰ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵇⴱⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵔⴹⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵙⴻⵇⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C21_16","077_1_16","2CO","1","16","16","ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵓⵙⵉⵖ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵄⴻⵇⴱⴻⵖ ⵄⴰⵡⴻⴷ ⵣⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵙⵇⴻⴱⴱⴹⴻⵎ ⵖⴰⵔ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C21_17","077_1_17","2CO","1","17","17","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵄⴻⵡⵡⵍⴻⵖ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰ ⵇⴻⴵⵇⴻⵖ? ⵏⵉⵖ ⵎⵉⵏ ⵅⴰⵔⵚⴻⵖ ⴰⴷ ⵜ ⴳⴳⴻⵖ, ⵎⴰ ⵅⴰⵔⵚⴻⵖ ⵜ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵢⵙⵓⵎ ⵉⵏⵓ, ⴰⵍⴰⵎⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴼ ‘ⵡⴰⵀ, ⵡⴰⵀ!’ ⵓⵍⴰ ⴷ ‘ⵍⵍⴰ, ⵍⵍⴰ’? ");
INSERT INTO rift_vpl VALUES ("C21_18","077_1_18","2CO","1","18","18","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵉ ⵢⴻⴵⴰ, ⴰⵍⴰⵎⵉ ⴰⵡⴰⵍ ⵏⵏⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵉⴵⵉ ‘ⵡⴰⵀ!’ ⵓⵍⴰ ⴷ ‘ⵍⵍⴰ!’ ");
INSERT INTO rift_vpl VALUES ("C21_19","077_1_19","2CO","1","19","19","ⵎⵉⵏⵣⵉ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵉ ⵣⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵊⴰⵔ ⴰⵡⴻⵎ ⵣⵣⴰⵢⵏⴻⵖ, ⵣⵣⴰⵢⵉ ⵓ ⵣⵉ ⵙⵉⵍⵡⴰⵏⵓⵙ ⵓ ⵣⵉ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴵⵉ ⴷ ‘ⵡⴰⵀ!’ ⵓⵍⴰ ⴷ ‘ⵍⵍⴰ!’, ⵎⴰⵛⴰ ‘ⵡⴰⵀ’ ⴷⴰⵢⴻⵙ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("C21_20","077_1_20","2CO","1","20","20","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵡⵓⵄⵓⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ‘ⵡⴰⵀ!’ ⴷⴰⵢⴻⵙ, ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵇⵇⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵄⴰⵡⴻⴷ ‘ⴰⵎⵉⵏ!’ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C21_21","077_1_21","2CO","1","21","21","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴹⵎⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴻⴷⵀⵓⵏ, ⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⴷⵀⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C21_22","077_1_22","2CO","1","22","22","ⵉⴳⴳⴰ ⵅⴰⵏⴻⵖ ⴰⵛⴻⵎⵎⵉⵄ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⴰⵔⵔⵓⵃ ⴷ ⵍⵄⴰⵔⴱⵓⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C21_23","077_1_23","2CO","1","23","23","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵛⴻⵀⵀⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⵇⴰ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷ ⴰⵃⵏⵉⵏ ⵅⴰⵡⴻⵎ, ⵍⴰⵎⵉ ⵡⴰⵔ ⴷⴷ-ⵓⵙⵉⵖ ⵖⴰⵔ ⴽⵓⵔⵉⵏⵜⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("C21_24","077_1_24","2CO","1","24","24","ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⵚⴻⵍⵍⴻⵟ ⵅ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵜⴱⴻⴷⴷⴻⵎ ⵜⵎⴻⵜⵏⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C22_1","077_2_1","2CO","2","1","1","ⴷⴻⴳⴳⴰ ⴰⵇⴰ ⴳⴳⵉⵖ ⵜ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⴰⵇⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵜⵜⵉⵙⴻⵖ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⵙ ⵡⴻⵛⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C22_2","077_2_2","2CO","2","2","2","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵣⴻⵄⵎⴰ ⵏⴻⵛⵛ ⵙⵙⴼⴼⵓⴳⵎⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵡⵉ ⵅⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵙⵙⴼⴰⵔⵃⴻⵏ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⴷⵉ ⴳⴳⵉⵖ ⴰⴼⵓⴳⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("C22_3","077_2_3","2CO","2","3","3","ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⵏⴻⵛⵛ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴹⴻⵖ ⴷⵉⵏ, ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⴼⴼⵓⴳⵎⴻⵖ ⵛⴰ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴼⴰⵔⵃⴻⵖ. ⴰⵇⴰ ⵜⵜⵉⵇⵇⴻⵖ ⴷⴰⵢⵡⴻⵎ ⵎⴰⵔⵔⴰ, ⴱⴻⵍⵍⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C22_4","077_2_4","2CO","2","4","4","ⵎⵉⵏⵣⵉ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⴷⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵓⵍⴰ ⵙ ⵡⵓⵍ ⵢⴰⵔⴻⵊⴼⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴼⴼⵓⴳⵎⴻⵎ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵜⴰⵢⵔⵉ ⵉ ⵖⴰⵔⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵓⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("C22_5","077_2_5","2CO","2","5","5","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴼⴼⵓⴳⵎⴻⵏ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵙⵙⴼⴼⵓⴳⴻⵎ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵖⴻⵣⴷⵉⵙ ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ, ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴹⴻⵇⵍⴻⵖ ⵄⴰⴷ ⴽⵜⴰⵔ ⵙ ⵡⴰⵡⴰⵍ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("C22_6","077_2_6","2CO","2","6","6","ⵛⴼⴰ ⵢⴰⵙ ⵉ ⵡⴰⵏⵉⵜⴰ, ⴰⵇⴰ ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵜⵓⵖⴰ ⵉⵡⴻⴱⴱⴻⵅ ⵉ-ⵜ. ");
INSERT INTO rift_vpl VALUES ("C22_7","077_2_7","2CO","2","7","7","ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵏⴻⵖⵏⵉ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⵍⴻⵅⵅⵓ ⴰⴷ ⴰⵙ ⵜⵙⴰⵎⵃⴻⵎ ⵓⵛⴰ ⴰⴷ ⵅⴰⵙ ⵜⴻⵙⵙⴼⴻⵡⵡⵊⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙ ⵢⴰⵔⴻⵏⵏⵉ ⵓⴼⵓⴳⴻⵎ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("C22_8","077_2_8","2CO","2","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵜⴻⵙⵙⵜⴻⴱⴱⵜⴻⵎ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵉ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("C22_9","077_2_9","2CO","2","9","9","ⵎⵉⵏⵣⵉ ⵄⴰⵡⴻⴷ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵎⴰ ⵜᵉⵜⵜᵉⵟⵟⴰⵄⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C22_10","077_2_10","2CO","2","10","10","ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵜⵙⴰⵎⵃⴻⵎ, ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⴰⴷ ⴰⵙ ⵙⴰⵎⵃⴻⵖ. ⵎⵉⵏⵣⵉ ⵅ ⵎⵉⵅⴻⴼ ⵓⵎⵉ ⴷ ⴰⵙ ⵙⴰⵎⵃⴻⵖ, ⵙⴰⵎⵃⴻⵖ ⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("C22_11","077_2_11","2CO","2","11","11","ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵛⵛⵉⵟⴰⵏ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵣⴻⵎⵎⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C22_12","077_2_12","2CO","2","12","12","ⵍⴰⵎⵉ ⴷⴷ-ⵉⵡⴹⴻⵖ ⵖⴰⵔ ⵜⵔⵓⵡⴰⵙ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵜⴻⵡⵡⴰⵔⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("C22_13","077_2_13","2CO","2","13","13","ⵎⴰⵛⴰ ⵡⴰⵔ ⴰⵔⴻⵢⵢⵃⴻⵖ ⵛⴰ ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵓⴼⵉⵖ ⵛⴰ ⵓⵎⴰ ⵜⵉⵜⵓⵙ. ⵓⵛⴰ ⵎⵎⵙⴻⴱⴹⵉⵖ ⵅⴰⵙⴻⵏ, ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C22_14","077_2_14","2CO","2","14","14","ⵎⴰⵛⴰ ⴰⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴳⴳⴰ ⴰⴷ ⵏⵉⵍⵉ ⵏᵉⵜⵜⴱⴰⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵉⵙⵙⵛⴰⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C22_15","077_2_15","2CO","2","15","15","ⵎⵉⵏⵣⵉ ⵏⴻⴵⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵛⵏⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C22_16","077_2_16","2CO","2","16","16","ⵉ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⵇⴰ ⴰⵏⴻⵖ ⴷ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵍⵎⴻⵡⵜ ⵉ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⵉ ⵉⵎⴻⵣⵡⵓⵔⴰ ⴷ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵜⵓⴷⴰⵔⵜ. ⵓⵛⴰ ⵎⴰⵏ ⵡⴻⵏ ⴷ ⴰⵙ ⵉⵇⴻⴷⴷⴻⵏ ⵉ ⵙⵙⵓⵇ-ⴰ? ");
INSERT INTO rift_vpl VALUES ("C22_17","077_2_17","2CO","2","17","17","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⴵⵉ ⴰⵏⴻⵛⵜ ⵉⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵉⵙⵙⴼⴰⵔⵔⴰⵖⴻⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵏⴻⵙⵙⵉⵡⴻⵍ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴷⴻⵜⵜ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C23_1","077_3_1","2CO","3","1","1","ⵎⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵏⵡⴻⵚⵚⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵎⵉⵏ ⵏⴻⵄⵏⴰ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ? ⵏⵉⵖ ⵏⴻⵃⴷⴰⵊ, ⴰⵎ ⵉⵏⵏⴻⵖⵏⵉ, ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏ ⵓⵡⴻⵚⵚⵉ ⵉ ⴽⴻⵏⵏⵉⵡ? ⵏⵉⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⴰⵡⴻⵎ ⵏⴰⵔⵉ ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵏⴻⵖ ⵜⵡⴻⵚⵚⴰⵎ? ");
INSERT INTO rift_vpl VALUES ("C23_2","077_3_2","2CO","3","2","2","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⴱⵔⴰⵜ ⵏⵏⴻⵖ ⵉ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ, ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵓ ⵉⵜⵜⵡⴰⵙⵙⵖⴰⵔⴻⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C23_3","077_3_3","2CO","3","3","3","ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⴱⵔⴰⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵖ, ⵜⴰⴱⵔⴰⵜ ⵢⵓⵔⴰⵏ, ⵡⴰⵔ ⵜⴻⴵⵉ ⵙ ⵙⵙⵎⴻⵅ ⵎⴰⵛⴰ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⴻⴵⵉ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ, ⵎⴰⵛⴰ ⴷⵉ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("C23_4","077_3_4","2CO","3","4","4","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ ⵜⵜⵉⵇⵇⴻⵜ ⵉ ⵖⴰⵔⵏⴻⵖ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C23_5","077_3_5","2CO","3","5","5","ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⵃⵙⴻⴱ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴰⵅⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵣⵣⴰⵢⵏⴻⵖ, ⵎⴰⵛⴰ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵖ ⵜⵓⵙⴰ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C23_6","077_3_6","2CO","3","6","6","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵏⴻⵖ ⴰⵇⴰ ⵏⴻⵙⴷⴰⵀⴻⴵ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵜⵉⵔⴰ ⵙ ⵍⵃⵓⵔⵓⴼ, ⵎⴰⵛⴰ ⵙ ⵜⵉⵔⵔⴰ ⵏ ⴰⵔⵔⵓⵃ, ⵎⵉⵏⵣⵉ ⵜⵉⵔⴰ ⵙ ⵍⵃⵓⵔⵓⴼ ⵏⴻⵇⵇⴻⵏⵜ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵙⵙⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C23_7","077_3_7","2CO","3","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵍⵎⴻⵡⵜ ⵉ ⵉⵜⵜⵡⴰⵅⴻⴱⵛⴻⵏ ⵙ ⵜⵉⵔⴰ ⴷⴻⴳ ⵉⵥⵔⴰ ⵙ ⵡⴰⵏⴻⵛⵜ ⵓⵄⵓⴵⵉ ⵎⴰⵃⴻⵏⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⴻⵡⴹⴻⵏ ⵖⴰⵔ ⵡⵓⴷⴻⵎ ⵏ ⵎⵓⵙⴰ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ, ⵡⴰⵅⵅⴰ ⴰⵄⵓⴵⵉ ⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ, ");
INSERT INTO rift_vpl VALUES ("C23_8","077_3_8","2CO","3","8","8","ⵎⴻⵛⵃⴰⵍ ⴽⵜⴰⵔ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵔⵔⵓⵃ ⴷⴻⴳ ⵓⵄⵓⴵⵉ? ");
INSERT INTO rift_vpl VALUES ("C23_9","077_3_9","2CO","3","9","9","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵖⴰⵔ ⵍⵃⵉⵙⴰⴱ ⵜⵓⵖⴰ-ⵜⵜ ⵙ ⵓⵄⵓⴵⵉ, ⵎⴰⵀⵓ ⵄⴰⴷ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵉ ⴰⵄⵓⴵⵉ ⴰⵍ ⴰⴼⴻⵢⵢⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("C23_10","077_3_10","2CO","3","10","10","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⴻⵏ, ⵉⴱⴰⵏ-ⴷⴷ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵⵉ ⵛⴰ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵓⵄⵓⴵⵉ-ⵢⴰ ⵉ ⵅⴰⵙ ⵉⵄⵓⴵⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C23_11","077_3_11","2CO","3","11","11","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵎⵉⵏ ⵉⵄⴻⴷⴷⵓⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴰⵄⵓⴵⵉ, ⵎⴰⵀⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("C23_12","077_3_12","2CO","3","12","12","ⴻⵊⵊ ⴰⵏⴻⵖ ⵅⴻⵏⵏⵉ, ⵎⴰⵖⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴰⵙⵉⵜⴻⵎ ⴰⵎ ⵡⴰⵏⵉⵜⴰ, ⴰⴷ ⵏⵓⵢⵓⵔ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ");
INSERT INTO rift_vpl VALUES ("C23_13","077_3_13","2CO","3","13","13","ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵛⴰ ⴰⵎ ⵎⵓⵙⴰ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵍⵜⴰⵎ ⵅ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⵜⴰⵔⵡⴰ ⵏ ⵉⵙⵔⴰⵉⵍ ⵡⴰⵔ ⵙⴻⴽⴽⵡⴻⴹⴻⵏ ⵛⴰ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵎⵉⵏ ⵖⴰ ⵉⵄⴷⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("C23_14","077_3_14","2CO","3","14","14","ⵎⴰⵛⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⵙⵙⴷⴰⵔⴰⵖⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵍ ⴰⵙⵙ-ⴰ ⵉⵜⵜⵖⵉⵎⴰ ⵍⵍⵜⴰⵎ ⴷ ⵉⵊⵊⴻⵏ ⵅ ⵜⴻⵖⵔⵉ ⵏ ⵍⵄⴰⵀⴷ ⴰⵇⴷⵉⵎ ⴱⵍⴰ ⵎⴰ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ, ⴰⵇⴰ ⵍⵍⵜⴰⵎ ⵉⵜⵜⵡⴰⴱⴹⴻⵍ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C23_15","077_3_15","2CO","3","15","15","ⴰⵍ ⴰⵙⵙ-ⴰ, ⵅⵎⵉ ⴷ ⵖⴰ ⵖⴰⵔⴻⵏ ⵣⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⵎⵓⵙⴰ, ⵍⵍⵜⴰⵎ ⴰⵇⴰ-ⵜ ⵅ ⵡⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C23_16","077_3_16","2CO","3","16","16","ⵎⴰⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴷⵡⴻⵍ ⵃⴻⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔ ⵙⵉⴷⵉ, ⵍⵍⵜⴰⵎ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C23_17","077_3_17","2CO","3","17","17","ⴰⵇⴰ ⵙⵉⴷⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵎⴰⵏⵉ ⵉⴵⴰ ⴰⵔⵔⵓⵃ ⵏ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⵍⴻⵍⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("C23_18","077_3_18","2CO","3","18","18","ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵍⴰ ⴰⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉ ⵙ ⵉⵖⴻⵎⴱⴰⴱ ⵡⴰⵔ ⵉⵍⴻⵃⵃⴼⴻⵏ ⴰⵎⴻⵛⵏⴰⵡ ⴷⵉ ⵜⵉⵙⵉⵜ, ⵓⵛⴰ ⴰⴷ ⵏⴱⴻⴷⴷⴻⵍ ⵣⴻⴳ ⵓⵄⵓⴵⵉ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵖⴰⵔ ⵚⵚⵉⴼⴻⵜ ⴷ ⵉⵛⵜⴻⵏ, ⴰⵎ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏ ⵙⵉⴷⵉ, ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("C24_1","077_4_1","2CO","4","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵉⵃⴻⵍ ⵛⴰ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵉ ⵅⴰⵏⴻⵖ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C24_2","077_4_2","2CO","4","2","2","ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴻⵏⴹⴰⵔ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⵉⵙⵙⴻⵃⵛⵉⵎⴻⵏ, ⵡⴰⵔ ⵏⴻⴳⴳⵓⵔ ⵛⴰ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ. ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵏⴻⵜⵜⵥⵓⵡⵡⴰⵔ ⵛⴰ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴻⵙⵙⴰⵔⴳⴻⴱ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴰⵎ ⵏⴰⵔⴻⵣⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵜⵉⴷⴻⵜⵜ ⵉ ⵇⴰⵄ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵏ ⵉⵡⴷⴰⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C24_3","077_4_3","2CO","4","3","3","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵍ’ⵉⵏⵊⵉⵍ ⵏⵏⴻⵖ ⵄⴰⴷ ⵉⵍⴻⵃⵃⴻⴼ, ⴰⵇⴰ ⵉⵜⵜⵍⴻⵃⵃⴰⴼ ⵉ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C24_4","077_4_4","2CO","4","4","4","ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴷⴰⵔⵖⴻⵍ ⴰⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵜⴰⵔⴻⵇⵇ ⵟⵟⵢⴰ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C24_5","077_4_5","2CO","4","5","5","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⵢⴰⵙⵓⵄ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵡⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("C24_6","077_4_6","2CO","4","6","6","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ: “ⴰⴷ ⵜⴰⵔⴻⵇⵇ ⵜⴼⴰⵡⵜ ⵣⵉ ⵜⴰⴵⴻⵙⵜ!”, ⴰⵇⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵔⵓⵖⴰⵏ ⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴰⵔⵖ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C24_7","077_4_7","2CO","4","7","7","ⵎⴰⵛⴰ ⵖⴰⵔⵏⴻⵖ ⵍⴽⴻⵏⵣ-ⴰ ⴷⵉ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⵍⴰⵅⵜ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵊⵊⴻⵀⴷ ⴰⴷ ⵜⵉⵍⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⴻⴵⵉ ⵣⵣⴰⵢⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C24_8","077_4_8","2CO","4","8","8","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⵡⴰⵣⵉⵢⵢⴰⵔ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵊⴻⵢⵢⴻⴼ, ⴰⵇⴰ ⵛⵛⴰⵜⴻⵏ ⴰⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵃⴽⴻⵎ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("C24_9","077_4_9","2CO","4","9","9","ⵜⵜⴷⴰⵔⵔⴰⵛⴻⵏ ⵅⴰⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵙⵎⴻⵃ, ⴰⵇⴰ ⵏⴻⵎⵎⴻⵏⴹⴰⵔ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("C24_10","077_4_10","2CO","4","10","10","ⴰⵇⴰ ⵏⴰⵔⴻⴱⴱⵓ ⵍⵎⴻⵡⵜ ⵏ ⵢⴰⵙⵓⵄ ⵍⴻⴱⴷⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⴰⵙⵓⵄ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C24_11","077_4_11","2CO","4","11","11","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵙⴻⵍⵍⴻⵎ ⵉ ⵍⵎⴻⵡⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⴰⵙⵓⵄ, ⴰⴷ ⵜⴻⵙⵙⴻⴹⵀⴰⵔ ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⴰⵙⵓⵄ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ ⵉⵜⵜⵎⴻⵜⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C24_12","077_4_12","2CO","4","12","12","ⵍⴻⵅⵅⵓ ⵅⴻⵏⵏⵉ ⵜⵅⴻⴷⴷⴻⵎ ⵍⵎⴻⵡⵜ ⴷⴰⵢⵏⴻⵖ, ⵎⴰⵛⴰ ⵜⵓⴷⴰⵔⵜ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C24_13","077_4_13","2CO","4","13","13","ⴰⵎ ⵖⴰⵔⵏⴻⵖ ⴰⵔⵔⵓⵃ ⴷ ⵉⵊⵊ ⵏ ⵍ’ⵉⵎⴰⵏ - ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵇⴰ ⵓⵎⵏⴻⵖ, ⵙ ⵓⵢⴰ ⵙⵙⵉⵡⵍⴻⵖ ⵄⴰⵡⴻⴷ!” - ⴰⵇⴰ ⵏⴻⵜⵜⴰⵎⴻⵏ ⵏⴻⵛⵛⵉⵏ, ⵓ ⵙ ⵓⵢⴰ ⵏⴻⵙⵙⴰⵡⴰⵍ ⵄⴰⵡⴻⴷ ");
INSERT INTO rift_vpl VALUES ("C24_14","077_4_14","2CO","4","14","14","ⵓⵛⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵄⴰⵡⴻⴷ ⴰⴽ-ⴷ ⵢⴰⵙⵓⵄ ⵓⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴳⴳ ⴰⴽⵉⴷⵡⴻⵎ ⵣⵣⴰⵜⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C24_15","077_4_15","2CO","4","15","15","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵏⵉ ⴰⵔⴹⴰ ⵉ ⵡⴰⵟⵟⴰⵙ, ⵓⵛⴰ ⴰⴷ ⵉⴼⴻⵢⵢⴻⴹ ⵓⵇⴰⴷⵉ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C24_16","077_4_16","2CO","4","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵏⵅⴻⵙⵙⴰⵔ ⵛⴰ ⵓⵍⴰⵡⴻⵏ, ⵡⴰⵅⵅⴰ ⴱⵏⴰⴷⴻⵎ ⵏⵏⴻⵖ ⵏ ⴱⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⵀⴻⵍⵍⴰⴽ, ⴰⵇⴰ ⴱⵏⴰⴷⴻⵎ ⵏ ⴷⴰⵅⴻⵍ ⵉⴷⴷⴰⴽⴽⵡⴰⵍ ⴷ ⵊⴷⵉⴷ ⵣⴻⴳ ⵡⴰⵙⵙ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C24_17","077_4_17","2CO","4","17","17","ⵡⴰⵅⵅⴰ ⵍⵎⴻⵃⵏⴻⵜ ⵏ ⵍⵡⴻⵇⵜ-ⴰ ⵉⴼⵙⵓⵙⴻⵏ ⴷ ⵍⵎⵉⵊⴰⵍ ⵏⵏⴻⵙ ⴷⵔⵓⵙ ⵡⴰⵀⴰ, ⵄⴰⴷ ⵜᵉⵜⵜⴰⵡⵉ ⴰⵏⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵓⵄⵓⴵⵉ ⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⴵⵉ ⵓⵏⴻⴳⴳⴰⵔ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("C24_18","077_4_18","2CO","4","18","18","ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵏⴼⴰⵔⵔⴻⵃ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵍⴰⵏ ⵎⴰⵛⴰ ⵣⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ, ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵍⴰⵏ ⴰⵇⴰ ⵉ ⵢⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ ⴰⵇⴰ-ⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("C25_1","077_5_1","2CO","5","1","1","ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⴻⵏ, ⴱⴻⵍⵍⵉ, ⵅⵎⵉ ⵖⴰ ⵜⴻⴼⵏⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵍⴻⴱⵏⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵉⵛⵜ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴳⴳ ⵛⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C25_2","077_5_2","2CO","5","2","2","ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵏⵣⴻⵀⵀⴰⵔ ⵓ ⴷⴰⵢⵏⴻⵖ ⵎⴻⵥⵔⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵔⴹ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("C25_3","077_5_3","2CO","5","3","3","ⵎⴻⵄⵍⵉⴽ ⵇⴰⵄ ⵉ ⵖⴰ ⵏⵉⵍⵉ ⵏⵢⴰⵔⴹ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⵜⵉⴼⴻⵏ ⴷ ⵉⵄⴻⵔⵢⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C25_4","077_5_4","2CO","5","4","4","ⵎⴰⵛⴰ ⵎⵉⵏ ⵎⴰ ⵖⴰ ⵏⴻⴽⴽ ⵄⴰⴷ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ-ⴰ, ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏⵣⴻⵀⵀⴰⵔ ⵙ ⴷⴷⵇⴻⵍ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⴻⵅⵙ ⴰⴷ ⵜⵜ ⵏⴻⵊⵊ, ⵎⴰⵛⴰ ⵏⴻⵅⵙ ⴰⴷ ⵜⵜ ⵏⵢⴰⵔⴹ, ⵃⵉⵎⴰ ⵎⵉⵏ ⵉⴼⴻⵏⵏⴰⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵚⴰⵔⴷ ⵣⵉ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C25_5","077_5_5","2CO","5","5","5","ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⴷ ⵍⵄⴰⵔⴱⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("C25_6","077_5_6","2CO","5","6","6","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵙⵙⴻⵏ ⵓ ⵖⴰⵔⵏⴻⵖ ⵜⵜⵉⵇⵇⴻⵜ, ⴰⵇⴰ ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵖⴰ ⵏⴻⴽⴽ ⵏⵣⴻⴷⴷⴻⵖ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⴳⴳⵯⴻⵊ ⵅ ⵙⵉⴷⵉⵜⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("C25_7","077_5_7","2CO","5","7","7","ⵎⵉⵏⵣⵉ ⵙ ⵍ’ⵉⵎⴰⵏ ⵉ ⵏⴻⴳⴳⵓⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C25_8","077_5_8","2CO","5","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵜⵜⵉⵇⵇⴰ ⵓⵛⴰ ⴷⴰⵢⵏⴻⵖ ⵎⴻⵥⵔⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵙⵎⴻⵃ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵏⵉⵍⵉ ⴰⴽ-ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C25_9","077_5_9","2CO","5","9","9","ⵏⴻⵜⵜⵛⴻⵟⵟⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⴰⵔⴹⴰⵏ, ⵎⴰ ⵏⴻⴵⴰ ⵏⴻⴳⴳⵯⴻⵊ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵉⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("C25_10","077_5_10","2CO","5","10","10","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵏⴻⵖ ⴰⴷ ⵏⴻⴹⵀⴰⵔ ⵣⵣⴰⵜ ⵉ ⵍⴽⵓⵔⵙⵉ ⵏ ⵛⵛⵔⴻⵄ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵟⵟⴻⴼ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⴳⴳⴰ ⵙ ⴰⵔⵔⵉⵎⴻⵜ, ⵜⵛⵓⵏⵉ ⵏⵉⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C25_11","077_5_11","2CO","5","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰⵎ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴻⴳⴳⵯⴻⴷ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⵏⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵏⴻⵙⵙⴻⵇⵏⴻⵄ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔⴻⵙ, ⵓⵛⴰ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔⵡⴻⵎ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C25_12","077_5_12","2CO","5","12","12","ⵡⴰⵔ ⵏⴻⵜⵜⵡⴻⵚⵚⵉ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵎⴰⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵏⴻⵡⵛ ⵍⴼⵓⵔⵚⴰ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("C25_13","077_5_13","2CO","5","13","13","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵏᵉⵜⵜⴻⵅⵍⴻⴼ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵙ ⵍⴻⵄⵇⴻⵍ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("C25_14","077_5_14","2CO","5","14","14","ⵎⴰⵖⴰⵔ ⵜⴰⵢⵔⵉ ⵏ ⵍⵎⴰⵙⵉⵃ ⵜⵄⴰⵔⵔⴻⵏ ⴰⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵅⴰⵔⵔⴻⵚ ⴰⵎⵎⵓ: ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵉⵎⵎⵓⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵎⵓⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C25_15","077_5_15","2CO","5","15","15","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⴷⴷⴰⵔⴻⵏ ⵛⴰ ⵄⴰⴷ ⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C25_16","077_5_16","2CO","5","16","16","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵏⴻⵙⵙⵉⵏ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⵉⵎⴻⵜ. ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵏⴻⵙⵙⴻⵏ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵜ ⴰⵎⵎⵓ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("C25_17","077_5_17","2CO","5","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵃⴻⴷ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵉ ⵉⴵⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵊⴷⵉⴷ. ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵇⴷⵉⵎ ⵉⵄⴷⵓ ");
INSERT INTO rift_vpl VALUES ("C25_18","077_5_18","2CO","5","18","18","ⵓ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵍ ⴷ ⵊⴷⵉⴷ ⵙ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵚⵍⴻⵃ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("C25_19","077_5_19","2CO","5","19","19","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵚⵍⴻⵃ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴽ-ⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏⵏⴻⵙ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⵎⴰⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵃⵙⵉⴱ ⵛⴰ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴷⴰⵢⵏⴻⵖ ⴰⵡⴰⵍ ⵏ ⵡⴻⵚⵍⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("C25_20","077_5_20","2CO","5","20","20","ⵙ ⵓⵢⴰ ⵉ ⵏⴻⴵⴰ ⴷ ⵉⵎⵙⴻⴽⴽⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⵅⵎⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵍⴰⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵣⵣⴰⵢⵏⴻⵖ. ⵙ ⵓⵢⴰ ⵏⴻⵜⵜⵍⴰⵖⴰ ⵏⴻⵛⵛⵉⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ: “ⵔⵓⵃⴻⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵚⴻⵍⵃⴻⵎ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("C25_21","077_5_21","2CO","5","21","21","ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴷⴷⴻⵏⴱ, ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴷⴷⴻⵏⴱ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C26_1","077_6_1","2CO","6","1","1","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ, ⴰⵎ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵣⴰⵡⴻⴳ ⴽⴻⵏⵏⵉⵡ ⴰⵎⵎⵓ, ⵃⵉⵎⴰ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜᵉⵟⵟⴼⴻⵎ, ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⴱⴻⵟⵟⴻⵍ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("C26_2","077_6_2","2CO","6","2","2","ⵎⵉⵏⵣⵉ ⵉⵏⵏⴰ: “ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⴰⵔⴹⴰ ⵙⵍⵉⵖ ⴰⵛ, ⵓⵛⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵄⴰⵡⵏⴻⵖ ⵛⴻⴽ!” ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵍⴻⵅⵅⵓ ⴷ ⵍⵡⴻⵇⵜ ⵏ ⴰⵔⴹⴰ, ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⴰ ⵍⴻⵅⵅⵓ ⴷ ⴰⵙⵙ ⵏ ⵓⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C26_3","077_6_3","2CO","6","3","3","ⵎⴰⵢⴻⵎⵎⵉ ⵖⴰ ⵜⴻⵡⵛⴻⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵉⵏⴷⴻⵔⴼ? ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⴷⵉⵏ ⵉⵜⵜⵉⵍⵉ ⵛⴰ ⵏ ⵍⵄⵉⴱ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("C26_4","077_6_4","2CO","6","4","4","ⵎⴰⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵏⴻⵜⵜⵡⴻⵚⵚⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴰⵎ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ: ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵚⵚⴱⴰⵔ, ⴷⵉ ⵍⴻⵎⵃⴰⵢⴻⵎ, ⴷⵉ ⵍⴻⵖⴱⴻⵏ, ⴷⵉ ⵍⴻⵃⴱⵓⵙⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("C26_5","077_6_5","2CO","6","5","5","ⵙⴰⴷⵓ ⵜⵉⵢⵢⵉⵜⴰ, ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ, ⴷⴻⴳ ⵓⵖⵓⵡⵡⴻⵖ, ⴷⵉ ⵜⴰⵎⴰⵔⴰ, ⴷⵉ ⴵⵢⴰⵍⵉ ⴱⵍⴰ ⵉⴹⴻⵚ, ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵓⵥⵓⵎⵎⵉ, ");
INSERT INTO rift_vpl VALUES ("C26_6","077_6_6","2CO","6","6","6","ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ, ⴷⵉ ⵜⵓⵙⵙⵏⴰ, ⴷⵉ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⴷⵉ ⵍⴻⴹⵔⴰⴼⴻⵜ, ⴷⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴷⵉ ⵜⴰⵢⵔⵉ ⴱⵍⴰ ⵏⵏⵉⴼⴰⵇ, ");
INSERT INTO rift_vpl VALUES ("C26_7","077_6_7","2CO","6","7","7","ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵜⵉⴷⴻⵜⵜ, ⴷⵉ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵙ ⵍⴻⵙⵏⴰⵃ ⵏ ⵜⵙⴻⴳⴷⴰ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⴷ ⵓⵣⴻⵍⵎⴰⴹ, ");
INSERT INTO rift_vpl VALUES ("C26_8","077_6_8","2CO","6","8","8","ⵙ ⵓⵄⵓⴵⵉ ⴷ ⴷⴷⴻⴵ, ⵙ ⵛⵛⴻⵏⵄⴻⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⵓ ⵙ ⵛⵛⴻⵏⵄⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⴰⵎ ⵉⵖⴻⵛⵛⴰⵛⴻⵏ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("C26_9","077_6_9","2CO","6","9","9","ⴰⵅⵎⵉ ⵡⴰⵔ ⵏⴻⵜⵜⵡⵉⵙⵙⴻⵏ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏ, ⴰⵅⵎⵉ ⵏⴻⵜⵜⵎⴻⵜⵜⴰ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⴷⴷⴰⵔ, ⴰⵅⵎⵉ ⵏⴻⵜⵜⵡⴰⵄⴰⵇⴻⴱ ⵎⴰⵛⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵜⵜⵉ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("C26_10","077_6_10","2CO","6","10","10","ⴰⵅⵎⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴼⴼⵓⴳⴻⵎ, ⵎⴰⵛⴰ ⵏⴼⴰⵔⵔⴻⵃ ⵍⴻⴱⴷⴰ, ⴰⵅⵎⵉ ⵏⴻⵣⵍⴻⴹ, ⵡⴰⵅⵅⴰ ⵏᵉⵜⵜⴻⵊⵊⴰⵔ ⴰⵟⵟⴰⵙ, ⴰⵅⵎⵉ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵛⴰ, ⵡⴰⵅⵅⴰ ⵖⴰⵔⵏⴻⵖ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("C26_11","077_6_11","2CO","6","11","11","ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵖ ⵉⵏⵏⵓⵔⵣⴻⵎ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⴽⵓⵔⵉⵏⵜⵉⵢⵢⴻⵏ, ⵓⵍ ⵏⵏⴻⵖ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C26_12","077_6_12","2CO","6","12","12","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵎ ⵣⵣⴰⵢⵏⴻⵖ, ⵎⴰⵛⴰ ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵎ ⵙ ⵜⵡⴰⵛⵉⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⴰⵅⴻⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C26_13","077_6_13","2CO","6","13","13","ⵎⴰⵛⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⴰⵅⵎⵉ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⴽ-ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ: ⴰⵔⵔⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵙ ⵎⵉⵏ ⴷⴰⵢⵉ ⵜᵉⵜⵜⵓⵔⵙⴻⵎ ⵓ ⵙⵡⴻⵙⵙⵄⴻⵎ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵉ ⵏⴻⵛⵛ! ");
INSERT INTO rift_vpl VALUES ("C26_14","077_6_14","2CO","6","14","14","ⵡⴰⵔ ⵜⵜⵎⵓⵏⴻⵎ ⵛⴰ ⴷⴻⴳ ⵓⵣⴰⵢⵍⵓ ⴰⴽ-ⴷ ⵍⴽⵓⴼⴼⴰⵔ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵛⵔⴰⵛ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵖⴰⵔ ⵜⵙⴻⴳⴷⴰ ⴰⴽ-ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵓ ⵎⴰⵏ ⵜⴰⵎⵓⵏⵜ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵉ ⵜⴼⴰⵡⵜ ⴰⴽ-ⴷ ⵜⴰⴵⴻⵙⵜ? ");
INSERT INTO rift_vpl VALUES ("C26_15","077_6_15","2CO","6","15","15","ⵏⵉⵖ ⵎⴰⵏ ⴰⵔⵡⴰⵙ ⵉ ⴷⵉⵏ ⵉⴵⴰ ⵊⴰⵔ ⵍⵎⴰⵙⵉⵃ ⴷ ⵛⵛⵉⵟⴰⵏ? ⵏⵉⵖ ⵎⴰⵏ ⵜⴰⵙⵖⴰⵔⵜ ⵏ ⵍⵎⵓⵎⴻⵏ ⴰⴽ-ⴷ ⵓⴽⴰⴼⵔⵉⵡ? ");
INSERT INTO rift_vpl VALUES ("C26_16","077_6_16","2CO","6","16","16","ⵏⵉⵖ ⵎⴰⵏ ⵜⴰⵙⵖⵓⵏⵜ ⵉ ⴷⵉⵏ ⵊⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴻⵏⵏⵉ ⵏ ⵛⵛⵡⴰⵟⴻⵏ? ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⵏⴻⵛⵛ ⴰⴷ ⵣⴻⴷⵖⴻⵖ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ. ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C26_17","077_6_17","2CO","6","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴼⴼⵖⴻⵎ-ⴷⴷ ⵣⵉ ⵍⵡⴻⵙⵟ ⵏⵙⴻⵏ, ⴱⴹⴰⵎ ⵅⴰⵙⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ⵡⴰⵔ ⵜⵜⵃⴰⴷⴰⵎ ⵎⵉⵏ ⵉⵏⴻⴳⵙⴻⵏ, ⵓ ⵏⴻⵛⵛ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⴱⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C26_18","077_6_18","2CO","6","18","18","ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵍⵉⵖ ⴷ ⴱⴰⴱⴰⵜⵡⴻⵎ, ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵉⵍⵉⵎ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴷ ⵜⵃⴻⵏⵊⵉⵔⵉⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ.” ");
INSERT INTO rift_vpl VALUES ("C27_1","077_7_1","2CO","7","1","1","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ, ⴰⵍⴰⵎⵉ ⵖⴰⵔⵏⴻⵖ ⵍⵡⵓⵄⵓⴷ-ⴰ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⵉⵣⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵎⴻⵊ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓ ⵏ ⴰⵔⵔⵓⵃ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵙⵙⵇⴻⴷⴷⴻⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C27_2","077_7_2","2CO","7","2","2","ⵇⴻⴱⵍⴻⵎ ⴰⵏⴻⵖ, ⴽⴻⵏⵏⵉⵡ ⴰ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵏⴻⴳⴳⵉ ⵍⵖⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵜ ⵏⵖⴻⵛⵛ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵙⵜⴻⵏⴼⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("C27_3","077_7_3","2CO","7","3","3","ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵃⴻⴽⵎⴻⵖ, ⵎⵉⵏ ⵣⵉ ⵉⵣⵣⴰⵔⴻⵖ ⵏⵏⵉⵖ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵎⵎⴻⵜ ⵊⵎⵉⵄ ⵓⵛⴰ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵊⵎⵉⵄ. ");
INSERT INTO rift_vpl VALUES ("C27_4","077_7_4","2CO","7","4","4","ⵜⴰⵔⵢⴰⵙⵜ ⵉⵏⵓ ⵇⵉⴱⴰⵍⵜ ⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵎⵖⴰⵔ ⵓⵛⴰ ⴰⵙⴻⵎⵖⴰⵔ ⵉⵏⵓ ⵅⴰⵡⴻⵎ ⵉⵎⵖⴰⵔ. ⴰⵇⴰ ⴰⵢⵉ ⵛⵛⵓⵔⴻⵖ ⵙ ⵓⴼⴻⵡⵡⴻⵊ, ⴰⵇⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴼⴻⵢⵢⴻⴹ ⴷⴰⵢⵉ ⴰⵟⵟⴰⵙ ⴷⵉ ⴽⵓⵍⵛⵉ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C27_5","077_7_5","2CO","7","5","5","ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵡⴰⵎⵉ ⴷⴷ-ⵏⵓⵙⴰ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵡⴰⵔ ⵏⵓⴼⵉ ⴰⵔⵔⴰⵃⴻⵜ ⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵏⴻⵙⵙⵃⵉⵙⵙⵉⴼ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵣⵉ ⴱⴰⵔⵔⴰ ⴰⵇⴰ ⴷⵉⵏ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ, ⵣⵉ ⴷⴰⵅⴻⵍ ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C27_6","077_7_6","2CO","7","6","6","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴼⴻⵡⵡⴰⵊⴻⵏ ⵅ ⵉⵎⵡⴰⴹⵄⴻⵏ, ⵉⵙⵙⴼⴻⵡⵡⴻⵊ-ⴷⴷ ⵅⴰⵏⴻⵖ ⵙ ⵜⵡⴰⵙⵉⵜ ⵏ ⵜⵉⵜⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("C27_7","077_7_7","2CO","7","7","7","ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵙ ⵓⴼⴻⵡⵡⴻⵊ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⴻⵊ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰⵖⴰⵔ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵏⴻⵖ ⵅ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⴷ ⵡⴻⵛⴹⴰⵏ ⵏⵡⴻⵎ ⴷ ⵛⴹⴰⵔⴻⵜ ⵏⵡⴻⵎ ⵅⴰⵏⴻⵖ. ⵓⵎⵉ ⵙⵍⵉⵖ ⴰⵢⴰ, ⴼⴰⵔⵃⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C27_8","077_7_8","2CO","7","8","8","ⵎⵉⵏⵣⵉ ⵡⴰⵅⵅⴰ ⵙⵙⴼⵓⴳⵎⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ, ⵡⴰⵔ ⵏⴷⵉⵎⴻⵖ ⵛⴰ, ⵡⴰⵅⵅⴰ ⵏⴷⵉⵎⴻⵖ, ⵎⴰⵖⴰⵔ ⵜⵜⵡⴰⵍⵉⵖ ⴰⵇⴰ ⵜⴰⴱⵔⴰⵜ ⵏⵏⵉ ⵜⴻⵙⵙⴼⵓⴳⴻⵎ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("C27_9","077_7_9","2CO","7","9","9","ⵎⴰⵛⴰ ⴼⴰⵔⵃⴻⵖ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴼⵓⴳⵎⴻⵎ, ⵎⴰⵛⴰ ⵓⵎⵉ ⴰⴼⵓⴳⴻⵎ ⵏⵡⴻⵎ ⵢⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵜⵜⵓⴱⴻⵜ, ⵎⵉⵏⵣⵉ ⴰⴼⵓⴳⴻⵎ ⵏⵡⴻⵎ ⵢⵓⵙⴰ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵍⴻⵇⵇⴻⴼ ⵛⴰ ⵣⵣⴰⵢⵏⴻⵖ ⴷⵉ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("C27_10","077_7_10","2CO","7","10","10","ⵎⵉⵏⵣⵉ ⴰⴼⵓⴳⴻⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵏⴻⴷⴷⴻⵀ ⵖⴰⵔ ⵜⵜⵓⴱⴻⵜ ⵏ ⴱⵓⵃⴱⴻⵍ ⵓ ⵖⴰⵔ ⵡⴻⴷⵡⴰⵍ ⵉ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⴰⴼⵓⴳⴻⵎ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵉⵜⵜⴰⵡⵉ ⵖⴰⵔ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("C27_11","077_7_11","2CO","7","11","11","ⵎⴰⵛⴰ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉⵎⵙⴰⵔ, ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴼⴼⵓⴳⵎⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵎⴻⵛⵃⴰⵍ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵊⵊⴰⵏ ⵏ ⵛⴹⴰⵔⴻⵜ ⴷ ⵓⴷⴰⴼⴻⵄ ⵏ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷ ⵡⴰⵔⵣⴰⵎ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵢⵔⵉ ⴷ ⵜⵓⵙⵎⵉ ⴷ ⵓⵡⴻⴱⴱⴻⵅ! ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵎⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("C27_12","077_7_12","2CO","7","12","12","ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵓⵔⵉⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵉⵖ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉ ⴷⵉ ⵉⵜⵜⵡⴰⴳⴳ ⵍⵄⵉⴱ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴰⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵛⴹⴰⵔⴻⵜ ⵏⵡⴻⵎ ⵉ ⵏⴻⵛⵛⵉⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C27_13","077_7_13","2CO","7","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵙⵙⴼⴻⵡⵡⴻⵊ ⵓ ⵖⴰⵔ ⵓⴼⴻⵡⵡⴻⵊ ⵏⵏⴻⵖ ⴰⵇⴰ ⵏⴼⴰⵔⵔⴻⵃ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⴽⵜⴰⵔ ⵣⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⵜⵉⵜⵓⵙ ⵓⵎⵉ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C27_14","077_7_14","2CO","7","14","14","ⵎⵉⵏⵣⵉ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴷⴰⵢⵡⴻⵎ ⵖⴰⵔⴻⵙ, ⴰⵇⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵙⵙⵃⴻⵛⵎⴻⵖ ⵛⴰ, ⵎⴰⵖⴰⵔ ⴰⵎ ⴷ ⴰⵡⴻⵎ ⵏⴻⵏⵏⴰ ⵜⵉⴷⴻⵜⵜ ⴽⵓⵍⵛⵉ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵉⴱⴰⵏ-ⴷⴷ, ⴰⵇⴰ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵖ ⵖⴰⵔ ⵜⵉⵜⵓⵙ ⵉⴱⴻⴷⴷ ⵅ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("C27_15","077_7_15","2CO","7","15","15","ⴰⵇⴰ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⵏⵏⴻⵙ ⵅⴰⵡⴻⵎ ⵜⴻⵎⵎⴰⵔⵏⵉ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵉⵜⵜⴼⴻⴽⴽⴰⵔ ⴷⵉ ⵟⵟⴰⵄⴻⵜ ⵏⵡⴻⵎ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵜⵇⴻⴱⵍⴻⵎ ⵜ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵔⵊⵉⵊⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("C27_16","077_7_16","2CO","7","16","16","ⴼⴰⵔⵃⴻⵖ ⵓⵎⵉ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵅⴰⵡⴻⵎ ⵜⵜⴻⵛⵍⴻⵖ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵎⵎⴰ. ");
INSERT INTO rift_vpl VALUES ("C28_1","077_8_1","2CO","8","1","1","ⵏⴻⵙⵙⴰⵔⴳⴻⴱ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("C28_2","077_8_2","2CO","8","2","2","ⵎⴰⵖⴰⵔ ⵓⵎⵉ ⵅⴰⵙⴻⵏ ⴷⴷ-ⵉⴽⴽⴰ ⵓⵇⴻⴵⴻⴱ ⵉⵎⵖⴰⵔ ⵏ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵙⴻⵏ, ⵜⴼⴻⵢⵢⴻⴹ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵙⴻⵏ, ⵓ ⴰⵟⵟⴰⵙ ⵏ ⵡⴰⴳⵍⴰ ⵏ ⵜⴻⵛⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ ⵉⵄⴷⵓ ⵣⵣⴻⵍⴹ ⵏⵙⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C28_3","077_8_3","2CO","8","3","3","ⵎⵉⵏⵣⵉ ⵛⴻⵀⵀⴷⴻⵖ, ⴰⵇⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⵓ ⵄⴰⴷ ⵙⴻⵏⵏⴻⵊ ⵉ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ - ⵍⴰⵎⵉ ⵜⵜⴻⵅⵙⴻⵏ ⵙ ⵡⵓⵍ ⵏⵙⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("C28_4","077_8_4","2CO","8","4","4","ⴰⵇⴰ ⵣⴰⵡⴳⴻⵏ ⴰⵏⴻⵖ ⵙ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴰⵔⵛⴻⵏ ⴷⵉ ⴰⵔⴹⴰ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C28_5","077_8_5","2CO","8","5","5","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴳⴳⵉⵏ ⵎⵉⵏ ⵜⵓⵖⴰ ⵏⴻⵙⵙⵉⵜⵉⵎ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎⴻⵣⵡⴰⵔ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⵉ ⵏⴻⵛⵛⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("C28_6","077_8_6","2CO","8","6","6","ⴰⵍⴰⵎⵉ ⵏⵣⴰⵡⴻⴳ ⵜⵉⵜⵓⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴱⴷⴰ ⵇⴱⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵖⴰⵔⵡⴻⵎ ⵓⵍⴰ ⴷ ⵜⴻⵛⵔⵉⵎⴻⵜ-ⴰ ⵏ ⵚⵚⴷⴰⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("C28_7","077_8_7","2CO","8","7","7","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴼⴻⵢⵢⴹⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ - ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⴷⵉ ⵜⵓⵙⵙⵏⴰ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵛⴹⴰⵔⴻⵜ, ⵓ ⴷⵉ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵖ ⵉ ⵖⴰⵔⵡⴻⵎ ⵉⴵⴰⵏ - ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴼⴻⵢⵢⴹⴻⵎ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵛⵔⵉⵎⴻⵜ-ⴰ ⵏ ⵚⵚⴷⴰⵇⵉ. ");
INSERT INTO rift_vpl VALUES ("C28_8","077_8_8","2CO","8","8","8","ⵡⴰⵔ ⵜⵜⵓⵎⵓⵔⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⵇⴻⴵⴱⴻⵖ ⵜⵉⴷⴻⵜⵜ ⵏ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵙ ⵛⴹⴰⵔⴻⵜ ⵏ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏⵡⴻⵎ ⴷⵉ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C28_9","077_8_9","2CO","8","9","9","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴱⴻⵍⵍⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵣⵍⵓⴹ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ-ⵜ ⵙ ⵡⴰⴳⵍⴰ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵜⵡⴰⵊⵊⴰⵔ ⵙ ⵣⵣⴻⵍⴹ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C28_10","077_8_10","2CO","8","10","10","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵡⴻⵚⵚⵉⵖ ⵎⵍⵉⵃ - ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵏⵏⴼⴻⵄ ⵏⵡⴻⵎ - ⵎⴰⵃⴻⵏⴷ ⵎⵉⵏ ⵜⴻⴱⴷⴰⵎ ⴰⴷ ⵜⴻⵏⵡⴰⵎ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉⵄⴷⵓⵏ, ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("C28_11","077_8_11","2CO","8","11","11","ⴽⴻⵎⵎⵍⴻⵎ ⵍⴻⵅⵅⵓ ⵙ ⵜⵎⴻⴳⴳⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⴻⵏⵡⴰⵎ, ⴽⴻⵎⵎⵍⴻⵎ ⵙ ⵜⵎⴻⴳⴳⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵎⵎⴻⵥⵔⴻⵎ ⴰⴷ ⵜ ⵜⴻⴳⴳⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⴵⴰⵏ ⵖⴰⵔⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C28_12","077_8_12","2CO","8","12","12","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵎⴻⵥⵔⵉ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵊⴻⴱ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵖⴰⵔⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("C28_13","077_8_13","2CO","8","13","13","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⵍⵉⵇ ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⴻⴼⵙⴰⵙⴻⵜ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⵓ ⴰⴷ ⵅⴰⵡⴻⵎ ⵜⵉⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("C28_14","077_8_14","2CO","8","14","14","ⵎⴰⵛⴰ ⵃⴹⴰⵎ ⴰⴷ ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵍⵎⵉⵣⴰⵏ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⵓⵛⴰ ⴻⵊⵊ ⴰⴼⴻⵢⵢⴻⴹ ⵏⵡⴻⵎ ⴰⴷ ⵉⵄⴻⵎⵎⴰⵔ ⵍⴻⵖⴱⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ, ⴰⵍⴰⵎⵉ ⴰⴼⴻⵢⵢⴻⴹ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵉⵄⴻⵎⵎⴻⵔ ⵍⴻⵖⴱⴻⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵢⵉⵍⵉ ⵍⵎⵉⵣⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("C28_15","077_8_15","2CO","8","15","15","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⵡⴻⵏⵏⵉ ⵉⵙⵙⵎⵓⵏⴻⵏ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵛⴻⵟⵟ ⵛⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵢⴰⵔⵔⵡⴻⵏ ⴷⵔⵓⵙ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵇⵇⵉⵎ ⵍⴻⵅⵚⴻⵚ.” ");
INSERT INTO rift_vpl VALUES ("C28_16","077_8_16","2CO","8","16","16","ⵎⴰⵛⴰ ⴰⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵛⴹⴰⵔⴻⵜ-ⴰ ⵅⴰⵡⴻⵎ ⴷⴻⴳ ⵡⵓⵍ ⵏ ⵜⵉⵜⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("C28_17","077_8_17","2CO","8","17","17","ⵎⵉⵏⵣⵉ ⵉⵇⴱⴻⵍ ⵜⵓⵜⵔⴰ ⵏⵏⴻⵖ ⵓⵛⴰ, ⴰⵎ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⴰⵎⵏⵓⵙ ⵅⴰⵡⴻⵎ, ⵉⵟⵟⴻⵡⵡⴻⵄ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C28_18","077_8_18","2CO","8","18","18","ⵓⵛⴰ ⵏⴻⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⵄⴰⵡⴻⴷ ⵓⵎⴰⵜⵏⴻⵖ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵡⴻⵇⵇⴰⵔ ⴷⵉ ⵍ’ⵉⵏⵊⵉⵍ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("C28_19","077_8_19","2CO","8","19","19","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ ⵙ ⵊⵊⴻⵀⴷ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⴽⵉⴷⵏⴻⵖ ⴰⴽ-ⴷ ⵜⴻⵛⵔⵉⵎⴻⵜ-ⴰ ⵏ ⵚⵚⴷⴰⵇⵉ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵖ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉ ⵓⵛⴻⵊⵊⴻⵄ ⵉ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C28_20","077_8_20","2CO","8","20","20","ⵎⴰⵛⴰ ⵏⵃⴻⵟⵟⴰ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⴹⴻⴵⴻⵎ ⵃⴻⴷ ⵎⴰⵍⴰ ⵏⵙⴻⵢⵢⴰⵔ ⵜⴰⵛⵔⵉⵎⴻⵜ-ⴰ ⵏ ⵚⵚⴷⴰⵇⵉ ⵉⴼⴻⵢⵢⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C28_21","077_8_21","2CO","8","21","21","ⵃⵉⵎⴰ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵛⵇⴰⵏ ⴰⴷ ⵉⵄⴷⵓ ⵎⵍⵉⵃ, ⵡⴰⵔ ⵉⴵⵉ ⵡⴰⵀⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵣⵣⴰⵜ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C28_22","077_8_22","2CO","8","22","22","ⵏⴻⵙⵙⴻⴽⴽ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵓⵎⴰⵜⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵛⴰⵏⴻⵏ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴻⵟⵟⴰⵔ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵜⵜⵛⴻⵟⵟⴰⵔ ⴽⵜⴰⵔ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵛⴰⵍ ⵅⴰⵡⴻⵎ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C28_23","077_8_23","2CO","8","23","23","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵜⵉⵜⵓⵙ ⴷ ⴰⵎⵄⴰⵛⴰⵔ ⵉⵏⵓ ⴷ ⵓⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵓ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ ⵏⵏⴻⵖⵏⵉ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵔⵔⵓⵙⵓⵍ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("C28_24","077_8_24","2CO","8","24","24","ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⵜⴰⵇⴻⴵⴻⴱⵜ ⵏ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵓ ⵏ ⵓⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵖ ⴷⴰⵢⵡⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C29_1","077_9_1","2CO","9","1","1","ⵎⵉⵏⵣⵉ ⵃⴻⵙⴱⴻⵖ ⴱⴻⵍⵍⵉ ⵏⵀⵍⴰ ⵎⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵅ ⵜⵡⵉⵣⴰ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C29_2","077_9_2","2CO","9","2","2","ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵡⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ ⵎⵉⵅⴻⴼ ⵅⴰⵡⴻⵎ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵊⴰⵔ ⵉⵏⵏⵉ ⵏ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⴱⴻⵍⵍⵉ ⴰⵅⴰⵢⴰ ⵜⵓⵖⴰ ⵜⴻⵡⵊⴻⴷ ⵣⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵉⵄⴷⵓⵏ, ⵓⵛⴰ ⵛⴹⴰⵔⴻⵜ ⵏⵡⴻⵎ ⴰⵇⴰ ⵜⴻⵙⴼⴰⵇ ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C29_3","077_9_3","2CO","9","3","3","ⵎⴰⵛⴰ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⴰⵡⵎⴰⵜⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵏⴻⵖ ⴷⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵛⴰ ⴱⴰⵟⴻⵍ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⵃⴻⵣⵣⵎⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵉⵖ, ");
INSERT INTO rift_vpl VALUES ("C29_4","077_9_4","2CO","9","4","4","ⵃⵉⵎⴰ, ⵅⵎⵉ ⴽⵉⴷⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵉⵎⴰⴽⵉⴷⵓⵏⵉⵢⵢⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴼⴻⵏ ⵡⴰⵔ ⵜⵃⴻⵣⵣⵎⴻⵎ, ⵏⴻⵛⵛⵉⵏ - ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵖ ⵛⴰ ‘ⴽⴻⵏⵏⵉⵡ’ - ⵡⴰⵔ ⵏⵖⴻⵟⵟⴻⵔ ⵣⴻⴳ ⵓⵙⴻⵎⵖⴰⵔ ⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵏⴻⵙⵙⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C29_5","077_9_5","2CO","9","5","5","ⵙ ⵓⵢⴻⵏⵏⵉ ⴳⴳⵉⵖ ⴰⴷ ⵜⵜⴰⵔⴻⵖ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵓⵛⴰ ⴰⴷ ⵙⵙⴻⵡⵊⴷⴻⵏ ⵇⴱⴻⵍ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵚⵚⴷⴰⵇⵉ ⵜⵉⵏⵏⵉ ⵅ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵇⴱⴻⵍ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵍⵉ ⵚⵚⴻⴷⵇⴻⵜ ⵏⵏⵉ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⴱⴰⵔⴰⴽⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵅⵎⵉ ⵜⵜ-ⵉ-ⴷⴷ-ⴽⴽⵙⴻⵏ ⵣⵉ ⵜⴻⵍⵎⴻⵛⵜ ⵏⵡⴻⵎ ⵙ ⵟⵟⵎⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("C29_6","077_9_6","2CO","9","6","6","ⵎⴰⵛⴰ ⵙⵏⴻⵎ ⴷⴷⴻⴳⴳⴰ: “ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵣⴰⵔⵄⴻⵏ ⵙ ⵜⵛⴻⵟⵟⴰⵔⵜ, ⴰⴷ ⵉⵎⵊⴰⵔ ⵙ ⵜⴰⵛⴻⵟⵟⴰⵔⵜ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵣⴰⵔⵄⴻⵏ ⵙ ⵜⴻⵛⵔⵉⵎⴻⵜ, ⴰⴷ ⵉⵎⵊⴰⵔ ⵄⴰⵡⴻⴷ ⵙ ⵜⴻⵛⵔⵉⵎⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("C29_7","077_9_7","2CO","9","7","7","ⴰⴷ ⵉⴳⴳ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵡⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵉⵖ ⵙ ⵓⵖⵉⵍ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴻⵅⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C29_8","077_9_8","2CO","9","8","8","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴽⵓⵍ ⴰⵔⴹⴰ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⵃⵉⵎⴰ ⵍⴻⴱⴷⴰ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ⵎⵉⵏ ⵜⴻⵃⴷⴰⵊⴻⵎ ⵓⵛⴰ ⴰⴷ ⵜⴰⵔⵏⵉⵎ ⴰⵟⵟⴰⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C29_9","077_9_9","2CO","9","9","9","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⵇⴰ ⵉⴱⴻⵟⵟⴰ, ⵉⵡⵛⴰ ⵉ ⵉⵎⴻⵣⵍⴰⴹ, ⵜⴰⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("C29_10","077_9_10","2CO","9","10","10","ⵎⴰⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉ ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵄⴻⵏ ⵓⵍⴰ ⴷ ⴰⵖⵔⵓⵎ ⵉ ⵎⴰⵛⵛⴰ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ, ⴰⴷ ⵢⴰⵔⵏⵉ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴻⴳⵎⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C29_11","077_9_11","2CO","9","11","11","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⵜⴻⵊⵊⴰⵔⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵛⵔⵉⵎⴻⵜ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴻⴳⵎⴰⵏ ⴰⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C29_12","077_9_12","2CO","9","12","12","ⵎⵉⵏⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵜⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⵡⴰⵀⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⵉⵏ ⵉⵏⴻⵇⵚⴻⵏ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵜᵉⵜⵜⴰⵡⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴰⵟⵟⴰⵙ ⵏ ⵓⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("C29_13","077_9_13","2CO","9","13","13","ⵎⵉⵏⵣⵉ ⵙ ⵜⵇⴻⴵⴻⴱⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ-ⴰ, ⴰⵇⴰ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵎⵉⵏⵣⵉ ⵜⴻⵎⵎⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵎⵉⵏⵣⵉ ⵜⵛⴰⵔⵛⴻⵎ ⵙ ⵜⴻⵛⵔⵉⵎⴻⵜ ⴰⴽⵉⴷⵙⴻⵏ ⵓ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("C29_14","077_9_14","2CO","9","14","14","ⵏⵉⵜⵏⵉ ⴰⴷ ⴷⴷ-ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵙ ⵜⴰⵢⵔⵉ ⴰⵟⵟⴰⵙ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C29_15","077_9_15","2CO","9","15","15","ⵜⵇⴰⴷ ⴰⵙ ⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⴻⵡⵀⵉⴱⵜ ⵏⵏⴻⵙ ⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵏⵟⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("C210_1","077_10_1","2CO","10","1","1","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴱⵓⵍⵓⵙ ⵙⵉⵎⴰⵏⵜ ⵉⵏⵓ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⴻⵎⵀⵉⵏⵜ ⴷ ⵓⵡⴰⴹⴻⵄ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵙⴻⵅⵅⴰⵢ ⵅⵎⵉ ⵃⴹⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵅⵎⵉ ⵖⴰ ⵖⴰⴱⴻⵖ ⴰⵇⴰ ⴰⵢⵉ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ");
INSERT INTO rift_vpl VALUES ("C210_2","077_10_2","2CO","10","2","2","ⴰⵇⴰ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵅⵎⵉ ⵖⴰⵔⵡⴻⵎ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ, ⵏⵀⵍⴰ ⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵎⵎⵄⴰⵔⵔⵉⵖ - ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⵏⵏⵉ ⵃⴻⵙⵙⴱⴻⵖ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔⵉ - ⴰⴽ-ⴷ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵉⵃⴻⵙⵙⴱⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⴷⴷⴰⵔ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("C210_3","077_10_3","2CO","10","3","3","ⵎⵉⵏⵣⵉ ⵡⴰⵅⵅⴰ ⵏⴻⴳⴳⵓⵔ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵏⵖⵉ ⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵢⵙⵓⵎ, ");
INSERT INTO rift_vpl VALUES ("C210_4","077_10_4","2CO","10","4","4","ⵙ ⵎⵉⵏⵣⵉ ⵍⴻⵙⵏⴰⵃ ⵏ ⵓⵎⴻⵏⵖⵉ ⵏⵏⴻⵖ ⵡⴰⵔ ⴵⵉⵏ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵎⴰⵛⴰ ⵛⵛⵓⵔⴻⵏ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵣⵣⴰⵢⴻⵙ ⵉ ⵏⵜⴰⵔⵔⴰ ⵍⴱⵓⵔⵊⴰⵜ ⵉⵖⴻⵡⵡⵖⴻⵏ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C210_5","077_10_5","2CO","10","5","5","ⵏᵉⵜⵜⵔⴻⵥⵥⴰ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⵓⵄⵍⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵅ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⴰⴷ ⵏⵃⴻⴱⴱⴻⵙ ⵎⴰⵔⵔⴰ ⴰⵔⵔⴰⵢ ⵉ ⵟⵟⴰⵄⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C210_6","077_10_6","2CO","10","6","6","ⵓⵛⴰ ⵏⴻⴽⴽⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵡⴻⴱⴱⴻⵅ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜᵉⵟⵟⵉⵄⴻⵏ, ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉ ⵟⵟⴰⵄⴻⵜ ⵏⵡⴻⵎ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("C210_7","077_10_7","2CO","10","7","7","ⵎⴰ ⵜⵅⴻⵣⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵙ ⵡⵓⴷⴻⵎ? ⵎⴰⵍⴰ ⵉⵜⵜⵉⵇⵇ ⵃⴻⴷ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵅⴰⵔⵔⴻⵚ ⵄⴰⵡⴻⴷ, ⴱⴻⵍⵍⵉ ⴰⵎ ⵏⴻⵜⵜⴰ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛⵉⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⵏⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("C210_8","077_10_8","2CO","10","8","8","ⵎⴻⵄⵍⵉⴽ ⵏⴻⵛⵛ ⵎⴰⵍⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵙ ⵛⵡⴰⵢⵜ ⵏ ⵓⴼⴻⵢⵢⴻⴹ ⴽⵜⴰⵔ ⴷⵉ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵖ ⵜⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⴷ ⵢⵉⵍⵉ ⵏⴻⵀⵍⴰ ⵎⴰ ⴰⴷ ⵙⴻⴹⵃⵉⵖ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⵜ ⵉ ⵍⴻⴱⵏⵉ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵡⴰⵔⴻⴷⴷⴻⴵ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("C210_9","077_10_9","2CO","10","9","9","ⵎⴰⵛⴰ ⵙⵙⴱⴻⵄⵄⴷⴻⵖ ⴰⵢⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵖⵉⵍ ⵉ ⵛⴰ ⵏ ⵉⵊⵊ ⴰⵇⴰ ⵅⵙⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵉⴳⴳⵯⴻⴷⴻⵖ ⵙ ⵜⴻⴱⵔⴰⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C210_10","077_10_10","2CO","10","10","10","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏⵏⴻⵙ ⵇⴻⵙⵃⴻⵏⵜ ⵊⴻⵀⴷⴻⵏⵜ, ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵀⴻⵢⵢⴻⴼ, ⵓⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵙ ⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("C210_11","077_10_11","2CO","10","11","11","ⵡⴻⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵎⵎⵓ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵄⵇⴻⵍ, ⴰⵇⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⴵⴰ ⵏⴻⵛⵛⵉⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵙ ⵜⴻⴱⵔⴰⵜⵉⵏ ⵎⴰⵍⴰ ⵡⴰⵔ ⵏⴻⵃⴹⴰⵔ, ⴰⵎⵎⵓ ⵉ ⵏⴻⴵⴰ ⵙ ⵜⵎⴻⴳⴳⴰ ⵏⵏⴻⵖ ⵅⵎⵉ ⵖⴰ ⵏⴻⵃⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C210_12","077_10_12","2CO","10","12","12","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵏⴻⵣⵄⵉⵎ ⵛⴰ ⴰⴷ ⵏⴻⵃⵙⴻⴱ ⵏⵉⵖ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵇⵓⴷⴷⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴰⴽ-ⴷ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵓⵎⵉ ⵄⴱⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴼⵀⵉⵎⴻⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("C210_13","077_10_13","2CO","10","13","13","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⵙⵙⴻⵎⵖⴰⵔⵉ ⵛⴰ ⴱⴰⵔⵔⴰ ⵉ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵏⴰⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("C210_14","077_10_14","2CO","10","14","14","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵏⵉⵡⴻⴹ, ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⵡⵉⵥⵥⴻⴹ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵖⴰⵔⵡⴻⵎ ⵓⵛⴰ ⵏⵉⵡⴻⴹ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C210_15","077_10_15","2CO","10","15","15","ⴰⵇⴰ ⵡⴰⵔ ⵏⴻⵙⵙⴻⵎⵖⴰⵔ ⵛⴰ ⴰⵎ ⵏⴻⴽⴽⴰ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵖ, ⵎⴰⵏⵉ ⵅⴻⴷⵎⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⵏⴻⵙⵙⵉⵜⵉⵎ, ⵓⵎⵉ ⵉⵎⴻⵇⵇⴰⵔ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⴰⴷ ⵏⴻⵜⵜⵡⴰⵡⴻⵙⵙⴻⵄ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵡⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("C210_16","077_10_16","2CO","10","16","16","ⵃⵉⵎⴰ ⴰⴷ ⵏⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵓⵍⴰ ⴷⴻⴳ ⵉⵎⵓⵛⴰⵏ ⴰⵖⵉⵔⵉⵏ ⵅⴰⵡⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵙⵙⴻⵎⵖⴰⵔⵉ ⵛⴰ ⵅ ⵍⴻⵄⴱⴰⵔ ⵏ ⵜⴻⵙⵖⴰⵔⵜ ⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵅ ⵍⴻⵄⴱⴰⵔ ⴰⵍ ⵎⴰⵏⵉ ⵉⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("C210_17","077_10_17","2CO","10","17","17","ⵎⴰⵛⴰ ⵡⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⴷⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("C210_18","077_10_18","2CO","10","18","18","ⵙ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⴵⵉ ⵡⴻⵏⵏⵉ ⵉⵡⴻⵚⵚⴰⵏ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵡⴻⵚⵚⴰ ⵙⵉⴷⵉ, ⴰⵇⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴻⵏ ⴷ ⴰⵎⵇⴻⴵⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("C211_1","077_11_1","2CO","11","1","1","ⵜⵜⵣⴰⵡⴳⴻⵖ ⴰⴽⵉⴷⵉ ⵜⴻⵚⴱⴰⵔⴻⵎ ⵛⵡⴰⵢⵜ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⴱⵓⵀⴰⵍⵉ ⵉ ⵙⵙⴰⵡⴰⵍⴻⵖ, ⵉⵡⴰ ⵃⴻⵎⵍⴻⵎ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("C211_2","077_11_2","2CO","11","2","2","ⵎⵉⵏⵣⵉ ⵛⴻⵟⵟⴰⵔⴻⵖ ⵅⴰⵡⴻⵎ ⵙ ⵉⵛⵜ ⵏ ⵛⴹⴰⵔⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵅⴻⴹⴱⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵉ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵇⴰⵔⵔⴱⴻⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵄⵣⴰⵔⴻⵛⵜ ⵜⵉⵣⴷⵉⴳ ⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C211_3","077_11_3","2CO","11","3","3","ⵎⴰⵛⴰ ⵜⵜᵉⴳⴳⵯⴻⴷⴻⵖ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵖⵡⴰ ⵓⴼⵉⵖⴰⵔ ⵃⴰⵡⵡⴰ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵏⴻⵙ, ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉ ⵖⴰ ⵜⵜⵡⴰⵖⵡⴰⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ ⵣⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵔ ⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C211_4","077_11_4","2CO","11","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵃⴻⴷ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵡⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵢⴰⵙⵓⵄ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵏⵏⵉ ⵅ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵏⴻⵛⵛ, ⵏⵉⵖ ⵎⴰⵍⴰ ⵜⵇⴻⴱⵍⴻⵎ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵖⵏⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵇⴱⵉⵍⴻⵎ ⵛⴰ, ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵜᵉⵟⵟⵉⴼⴻⵎ ⵛⴰ, ⴰⴷ ⵜ ⵜⴻⴽⵙⵉⵎ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C211_5","077_11_5","2CO","11","5","5","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵏⴻⵛⵛ ⵃⴻⵙⵙⴱⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵡⴰⵔ ⴵⵉⵖ ⵇⴻⵍⵍ ⵉ ⵔⵔⵓⵙⵓⵍ ⵏⵏⵉ ‘ⵉⵎⵖⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ’. ");
INSERT INTO rift_vpl VALUES ("C211_6","077_11_6","2CO","11","6","6","ⵡⴰⵅⵅⴰ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⵉ ⵡⴰⵡⴰⵍ, ⵎⴰⵛⴰ ⵉ ⵜⵓⵙⵙⵏⴰ ⵣⴻⵎⵎⴰⵔⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_7","077_11_7","2CO","11","7","7","ⵏⵉⵖ ⵅⴹⵉⵖ ⵓⵎⵉ ⵜⵓⵖⴰ ⵙⵙⵡⴰⴹⵄⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰⵎ, ⴰⵎ ⴷ ⴰⵡⴻⵎ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵙ ⴱⵍⴰ? ");
INSERT INTO rift_vpl VALUES ("C211_8","077_11_8","2CO","11","8","8","ⴰⵇⴰ ‘ⴽⴻⵛⴹⴻⵖ’ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵅⴰⵙⴻⵏⵜ ⵟⵟⴼⴻⵖ ⵜⴰⵅⵍⵉⵚⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("C211_9","077_11_9","2CO","11","9","9","ⵓⵛⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵃⴹⴰⵔⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⵜⵓⵖⴰ ⴷⴰⵢⵉ ⵍⴻⵅⵚⴻⵚ, ⵡⴰⵔ ⴱⴻⵙⵙⵍⴻⵖ ⵓⵍⴰ ⵅ ⵃⴻⴷ ⵣⵣⴰⵢⵡⴻⵎ, ⵎⴰⵛⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵅⴻⵚⵚⴻⵏ, ⵄⴻⵎⵎⴰⵔⴻⵏ ⵜ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⴷⴷ ⵢⵓⵙⵉⵏ ⵣⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ. ⵏⴻⵛⵛ ⵃⴹⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⵜⴱⴻⵙⵙⵍⴻⵖ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵇⵇⵉⵎⴻⵖ ⵃⴹⵉⵖ ⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C211_10","077_11_10","2CO","11","10","10","ⵜⵉⴷⴻⵜⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⴰⵇⴰ-ⵜ ⴷⴰⵢⵉ, ⴰⵇⴰ ⴰⵙⴻⵎⵖⴰⵔ-ⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵎⴻⵏⵏⴻⵄ ⴷⵉ ⵊⵊⵡⴰⵢⴻⵃ ⵏ ⴰⵅⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("C211_11","077_11_11","2CO","11","11","11","ⵎⴰⵢⴻⵎⵎⵉ? ⵎⴰ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴻⵅⵙⴻⵖ? ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_12","077_11_12","2CO","11","12","12","ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵖ, ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⵜⵜⴻⴳⴳⴻⵖ ⵜ ⵅⴻⵏⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴽⵙⴻⵖ ⵜⵉⵣⵉ ⵏ ⵢⵉⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⵍⴼⵓⵔⵚⴰ, ⵎⴰⵃⴻⵏⴷ ⵏⵉⵜⵏⵉ, ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵙⵙⴻⵎⵖⴰⵔⴰⵏ, ⴰⴷ ⴱⴰⵏⴻⵏ ⴰⵎ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_13","077_11_13","2CO","11","13","13","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵔⵔⵓⵙⵓⵍ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵉⵛⴻⵎⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵅⵎⵉ ⴷ ⵔⵔⵓⵙⵓⵍ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C211_14","077_11_14","2CO","11","14","14","ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜⴻⵜⵜⴱⴻⵀⵜⴻⵎ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵛⵛⵉⵟⴰⵏ ⵉⵜⵜⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⴰⵍⴰⴽ ⵏ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("C211_15","077_11_15","2CO","11","15","15","ⵡⴰⵅⵅⴰ ⴰⵎⵎⵓ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⵎⴰⵍⴰ ⵜⵜⴰⵔⵔⴰⵏ ⵄⴰⵡⴻⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵉⵏⵏⵉ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⵉⵍⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_16","077_11_16","2CO","11","16","16","ⵇⵇⴰⵔⴻⵖ ⵉ ⵓⵎⵓⵔ ⵏⵏⴻⵖⵏⵉ, ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⴱⵓⵀⴰⵍⵉ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵃⴻⵙⴱⴻⵎ ⴰⵢⵉ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵎⴰⵃⴻⵏⴷ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵛⵡⴰⵢⵜ. ");
INSERT INTO rift_vpl VALUES ("C211_17","077_11_17","2CO","11","17","17","ⵎⵉⵏ ⵙⵙⴰⵡⴰⵍⴻⵖ, ⵡⴰⵔ ⵜ ⵇⵇⴰⵔⴻⵖ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵛⴰ ⴳⴳⵉⵖ ⵜ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵓⴼⵉⵖ ⵣⴻⵄⵎⴰ ⵍⴼⵓⵔⵚⴰ ⵉ ⵓⵙⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C211_18","077_11_18","2CO","11","18","18","ⵓⵎⵉ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵢⵙⵓⵎ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴳⴳⵓⵔ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C211_19","077_11_19","2CO","11","19","19","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴹⴰⵎ ⴰⴷ ⵜⴻⵙⵍⴻⵎ ⵉ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⵉⵖⵉⵙⴻⵏ ⵉ ⵜⴻⴵⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("C211_20","077_11_20","2CO","11","20","20","ⴰⵇⴰ ⵜᵉⵎⵎⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵃⴻⴷ ⵉ ⵉⵜⵜⴰⵔⵔⴰⵏ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵙⴻⵎⵖⴰⵏ, ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴻⴼⴼⵣⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴽⴽⵙⴻⵏ ⴰⵡⴻⵎ ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ, ⵓ ⵡⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵙⵙⵓⵄⵍⴰⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵎⴻⴷⴷⴰⵔⴹⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_21","077_11_21","2CO","11","21","21","ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⵅⵎⵉ ⵜⵜⵙⴻⴹⵃⵉⵖ, ⴰⵅⵎⵉ ⵏⴻⴹⵄⴻⴼ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵉⵖⵉⵜ ⵡⴰⵔ ⵉⴵⵉⵏ: ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵣⴻⵄⵄⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ, ⵏⴻⵛⵛ ⵄⴰⵡⴻⴷ ⵣⴻⵄⵄⵎⴻⵖ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C211_22","077_11_22","2CO","11","22","22","ⵎⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ? ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ. ⵎⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵙⵔⴰⵉⵍⵉⵢⵢⴻⵏ? ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ. ⵎⴰ ⵏⵉⵜⵏⵉ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ? ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("C211_23","077_11_23","2CO","11","23","23","ⵎⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵏⴻⵛⵛ ⵄⴰⴷ ⵎⴰⵀⵓ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵙⵙⴰⵡⴰⵍⴻⵖ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵍⴼⴻⵏ: ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵜⴰⵎⴰⵔⴰ ⵎⴰⵀⵓ, ⵛⵛⵉⵖ ⵜⵉⵢⵢⵉⵜⴰ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵓⵔⴻⵏ ⴽⵜⴰⵔ ⵣⵣⴰⵢⵙⴻⵏ ⵓⵛⴰ ⵥⵔⵉⵖ ⵍⵎⴻⵡⵜ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_24","077_11_24","2CO","11","24","24","ⵡⵜⵉⵏ ⴰⵢⵉ ⵡⵓⴷⴰⵢⴻⵏ ⵅⴻⵎⵙⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵙ ⵓⵔⴻⴽⴽⵓⴹ ⵙ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵜⵉⵢⵢⵉⵜⴰ ⵇⴻⵍⵍ ⵉⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("C211_25","077_11_25","2CO","11","25","25","ⵜⵍⴰⵜⴰ ⵏ ⵉⵎⵓⵔⴻⵏ ⵡⵜⵉⵏ ⴰⵢⵉ ⵙ ⵡⴻⵄⵎⵓⴷ, ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵃⴻⵊⵊⴰⵔⴻⵏ ⴰⵢⵉ, ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵜⵉⵏ ⵢⴰⵔⵔⴻⵥ ⵣⵣⴰⵢⵉ ⵓⵖⴰⵔⵔⴰⴱⵓ, ⴵⵉⵍⴻⵜ ⴷ ⵓⵣⵉⵍ ⴷ ⴰⵇⴻⵜⵜⵓⵙ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⴱⵓⵖⴰⵣ ⵏ ⵍⴻⴱⵃⴰⵔ ⴱⵍⴰ ⵜⵖⴰⵔⵔⴰⴱⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("C211_26","077_11_26","2CO","11","26","26","ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵏ ⵉⵖⴻⵣⵔⴰⵏ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵏ ⵉⵛⴻⴼⴼⴰⵔⴻⵏ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵏ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⵏⵏⴻⵖⵏⵉ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⴷⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⴷⵉ ⵍⴻⵅⵍⴰ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵅ ⵍⴻⴱⵃⴰⵔ, ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⵙ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C211_27","077_11_27","2CO","11","27","27","ⴷⵉ ⵍⵅⴰⵟⴰⵔ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ, ⴷⵉ ⵜⴰⵎⴰⵔⴰ, ⵓⵎⵉ ⴷⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⴵⵢⴰⵍⵉ ⴱⵍⴰ ⵉⴹⴻⵚ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⴷⵉ ⵍⴰⵥ ⴷ ⵓⴼⴰⴷⵉ, ⴷⴻⴳ ⵓⵥⵓⵎⵎⵉ ⴰⵟⵟⴰⵙ, ⵓⵎⵉ ⴷⴰⵢⵉ ⵜⵓⵖⴰ ⴷⵉ ⵜⴻⵙⵎⴻⴹ ⴷ ⵜⵓⵄⴰⵔⵢⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("C211_28","077_11_28","2CO","11","28","28","ⵓⵛⴰ ⵄⴰⴷ ⵡⴰⵔ ⵙⵙⵉⵡⵍⴻⵖ ⵛⴰ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉ, ⵏⵉⵖ ⵅ ⵍⵀⴻⵎⵎ ⵉⵏⵓ ⵏ ⴽⵓⵍ ⴰⵙⵙ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵓⵍⴰ ⵅ ⵡⴻⵎⵏⵓⵙ ⵏⵏⵉ ⵅⴰⴼⵉ ⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C211_29","077_11_29","2CO","11","29","29","ⵎⴰⵍⴰ ⵉⴹⵄⴻⴼ ⵃⴻⴷ, ⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴹⴻⵄⴼⴻⵖ? ⵎⴰⵍⴰ ⵉⵅⴻⵢⵢⴻⵇ ⵃⴻⴷ ⵣⵉ ⵛⴰ ⵏ ⵓⵏⴻⴷⵔⴻⴼ, ⵎⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⵎⵎⴹⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("C211_30","077_11_30","2CO","11","30","30","ⵎⴰⵍⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ, ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴷⵉ ⵜⵓⴹⵄⴻⴼⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C211_31","077_11_31","2CO","11","31","31","ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ - ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ - ⵉⵙⵙⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("C211_32","077_11_32","2CO","11","32","32","ⵍⵇⴻⴱⵟⴰⵏ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵓⵊⴻⴵⵉⴷ ⴰⵔⵉⵜⴰⵙ ⴷⵉ ⴷⵉⵎⴰⵛⵇ ⵜⵓⵖⴰ ⵉⵃⴻⵟⵟⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵉⴷⵉⵎⴰⵛⵇⵉⵢⵢⴻⵏ, ⵢⴰⵔⴻⵣⵣⵓ ⴰⴷ ⴰⵢⵉ ⵉⵟⵟⴻⴼ, ");
INSERT INTO rift_vpl VALUES ("C211_33","077_11_33","2CO","11","33","33","ⵎⴰⵛⴰ ⵙⵙⴻⴽⴽⴻⵏ ⴰⵢⵉ-ⴷⴷ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⴽⴰⵣⵉ, ⵙⵙⴻⵀⵡⴰⵏ ⴰⵢⵉ-ⴷⴷ ⵣⵉ ⵍⵃⵉⴹ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴱⵓⴱ, ⴰⵔⴻⵡⵍⴻⵖ ⵣⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("C212_1","077_12_1","2CO","12","1","1","ⵎⴰⵍⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵓⵙⴻⵎⵖⴰⵔ, ⵡⴰⵅⵅⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵏⴻⴼⴼⴻⵄ ⵛⴰ, ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵖ ⴰⴷ ⵉⵡⴹⴻⵖ ⵏⴻⵛⵛ ⵖⴰⵔ ⵉⵡⴻⵃⵃⴰⵏ ⴷ ⵉⵙⴰⵔⴳⴰⴱⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C212_2","077_12_2","2CO","12","2","2","ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵜⵓⵖⴰ ⴽⵜⴰⵔ ⵣⴻⴳ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵣⴻⴳ ⵡⴰⵎⵉ, ⵎⴰ ⵜⵓⵖⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵉⵖ ⴱⴰⵔⵔⴰ ⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵛⴰ, ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵏ! ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵎⵎⴻⴽⵙⵉ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("C212_3","077_12_3","2CO","12","3","3","ⵓⵛⴰ ⵙⵙⵏⴻⵖ ⴱⵏⴰⴷⴻⵎ-ⴰ, ⵎⴰ ⵜⵓⵖⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵉⵖ ⴱⵍⴰ ⴰⵔⵔⵉⵎⴻⵜ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵛⴰ, ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C212_4","077_12_4","2CO","12","4","4","ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⵎⵎⴻⴽⵙⵉ ⵖⴰⵔ ⵊⵊⴻⵏⵏⴻⵜ ⵎⴰⵏⵉ ⵉⵙⵍⴰ ⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜⵡⴰⵏⴻⵟⵇⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵃⴻⴵⵍⴻⵏ ⵉ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵜⴻⵏ ⵉⵏⵟⴻⵇ. ");
INSERT INTO rift_vpl VALUES ("C212_5","077_12_5","2CO","12","5","5","ⵣⴻⴳ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵙⵙⴻⵎⵖⴰⵔⵉⵖ ⵛⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⵖⵉⵔ ⴷⴻⴳ ⵡⴻⴹⵄⴰⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C212_6","077_12_6","2CO","12","6","6","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵅⵙⴻⵖ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⴷ ⴰⴱⵓⵀⴰⵍⵉ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⵏⵉⵖ ⵜⵉⴷⴻⵜⵜ. ⵎⴰⵛⴰ ⴰⴷ ⵜ ⵊⵊⴻⵖ ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵅⴰⴼⵉ ⵉⵜⵜⵅⴰⵔⵔⴰⵚ ⵎⴰⵎⵎⴻⵛ ⴵⵉⵖ ⵙⴻⵏⵏⴻⵊ ⵎⵉⵏ ⵣⵣⴰⵢⵉ ⵉⵥⵔⴰ ⵏⵉⵖ ⵙⴻⵏⵏⴻⵊ ⵎⵉⵏ ⵣⵣⴰⵢⵉ ⵉⵙⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("C212_7","077_12_7","2CO","12","7","7","ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⴳⵉⵄⵄⴷⴻⵖ ⵛⴰ ⵉⵅⴻⴼ ⵉⵏⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵟⵟⴱⵉⵄⴻⵜ ⵢⵓⵄⵍⴰⵏ ⵏ ⵉⵙⴰⵔⴳⴰⴱⴻⵏ ⵏⵏⵉ, ⵉⵎⵎⴻⵡⵛ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵓⵙⴻⵏⵏⴰⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⵇⴰ-ⵜ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⵛⵛⵉⵟⴰⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵛⵛⴰⵜⴻⵏ ⵙ ⵍⴱⵓⵏⵉⵢⵢⴰⵜ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⴻⵙⴳⴻⵄⵄⵉⴷⴻⵖ ⵛⴰ ⵉⵅⴻⴼ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("C212_8","077_12_8","2CO","12","8","8","ⵜⵍⴰⵜⴰ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵜⵜⴰⵔⴻⵖ ⵙⵉⴷⵉ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵅⴰⴼⵉ ⵉⵙⵙⴻⴳⴳⵯⴻⵊ, ");
INSERT INTO rift_vpl VALUES ("C212_9","077_12_9","2CO","12","9","9","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⵇⴰ ⴰⵔⴹⴰ ⵉⵏⵓ ⵉⵛⴼⴰ, ⵎⵉⵏⵣⵉ ⵊⵊⴻⵀⴷ ⵉⵏⵓ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⴷⵉ ⵜⵓⴹⵄⴻⴼⵜ!” ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵎⵍⵉⵃ ⵎⴰⵍⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴷⵉ ⵜⵓⴹⵄⴻⴼⵜ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⴼⵉ ⵢⴰⵔⵙⴰ ⵊⵊⴻⵀⴷ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("C212_10","077_12_10","2CO","12","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⴹⵉⵖ ⵙ ⵜⵓⴹⵄⴻⴼⵜ, ⵙ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⴷⵉ ⵍⴻⵖⴱⴻⵏ, ⴷⴻⴳ ⵓⴷⴰⵔⵔⴻⵛ, ⴷⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵎⵉⵏⵣⵉ ⵅⵎⵉ ⵜⵜⵉⵍⵉⵖ ⴹⴻⵄⴼⴻⵖ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵜⵜⵉⵍⵉⵖ ⵊⴻⵀⵀⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("C212_11","077_12_11","2CO","12","11","11","ⵅⵣⴰⵔ, ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⴱⵓⵀⴰⵍⵉ ⵓⵎⵉ ⴳⴳⵉⵖ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵉⵏⵓ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵃⵚⴰⵔⴻⵎ ⴰⵢⵉ ⵖⴰⵔⴻⵙ. ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵢⵉ ⵜⵇⴻⴷⴷⴰⵔⴻⵎ, ⴰⵇⴰ ⵡⴰⵔ ⴵⵉⵖ ⵇⴻⵍⵍ ⵓⵍⴰ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵔⵔⵓⵙⵓⵍ ⵏⵏⵉ ‘ⵉⵎⵖⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ’, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("C212_12","077_12_12","2CO","12","12","12","ⴳⴳⵉⵖ ⵊⴰⵔ ⴰⵡⴻⵎ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏ ⵔⵔⴰⵙⵓⵍ ⵙ ⵎⴰⵔⵔⴰ ⵚⵚⴱⴰⵔ, ⵙ ⵜⵎⴻⴳⴳⴰ ⵉⵊⵊⴻⵀⴷⴻⵏ, ⵙ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵓ ⵙ ⵍⴻⵄⵊⴰⵢⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("C212_13","077_12_13","2CO","12","13","13","ⵎⴰⵖⴰⵔ ⵎⵉⵏ ⴷⵉ ⵜⴷⴻⵡⵍⴻⵎ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵎⵖⵉⵔ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⴱⴻⵙⵙⵍⴻⵖ ⵡⴰⵀⴰ? ⵙⴰⵎⵃⴻⵎ ⴰⵢⵉ ⵅ ⵍⴼⴰⵔⵣ-ⴰ! ");
INSERT INTO rift_vpl VALUES ("C212_14","077_12_14","2CO","12","14","14","ⵅⵣⴰⵔ, ⵍⴻⵅⵅⵓ ⴷ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⵇⴰ ⴰⵢⵉ ⵡⴻⵊⴷⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⵓⵛⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⵜⴱⴻⵙⵙⵉⵍⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵖ ⵎⵉⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⴰⵔⴻⵣⵣⵓⵖ ⵅⴰⵡⴻⵎ ⴽⴻⵏⵏⵉⵡ. ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵓⵙⵉ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⴰⴷ ⵅⴻⵎⵎⵍⴻⵏ ⵍⴻⴽⵏⵓⵣ ⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C212_15","077_12_15","2CO","12","15","15","ⵡⴻⵊⴷⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⵍⴻⵃⵙⴰⴱ ⵎⴰⵔⵔⴰ, ⵓ ⴰⴷ ⵙⴻⴱⴱⵍⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ, ⵄⴰⴷ ⵎⴰⵍⴰ ⵟⵟⴼⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ ⵜⴰⵢⵔⵉ ⵇⴻⵍⵍ ⵎⴰⵍⴰ ⵡⵛⵉⵖ ⴰⵡⴻⵎ ⵜⴰⵢⵔⵉ ⵙ ⵡⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("C212_16","077_12_16","2CO","12","16","16","ⵎⴰⵛⴰ ⴰⴷ ⵜⴰⵖ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⵜⴱⴻⵙⵙⵉⵍⴻⵖ, ⴰⵇⴰ ⵟⵟⴼⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⴰⵇⴻⴷⴷⴰⵛ? ");
INSERT INTO rift_vpl VALUES ("C212_17","077_12_17","2CO","12","17","17","ⵏⵉⵖ ⴰⴷ ⵜⴰⵖ ⵎⴻⵥⵔⴻⵖ ⴷⵉ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ ⵙ ⵛⴰ ⵏ ⵉⵊⵊ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ? ");
INSERT INTO rift_vpl VALUES ("C212_18","077_12_18","2CO","12","18","18","ⵅⵎⵉ ⵜⵜⴰⵔⴻⵖ ⵜⵉⵜⵓⵙ ⵓ ⵙⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⵜⴰⵡⵎⴰⵜ, ⵎⴰ ⵢⴰⵔⵣⵓ ⵜⵉⵜⵓⵙ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ ⴷⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵙ? ⵎⴰ ⵡⴰⵔ ⵏⵓⵢⵓⵔ ⵛⴰ ⵙ ⴰⵔⵔⵓⵃ ⴷ ⵉⵊⵊⴻⵏ ⴷ ⵉⵚⵓⵔⴰⴼ ⴷ ⵉⵊⵊⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("C212_19","077_12_19","2CO","12","19","19","ⵎⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⵄⴰⵡⴻⴷ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴻⵇⵇⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ? ⴰⵇⴰ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵉ ⵏⴻⵙⵙⴰⵡⴰⵍ ⵓⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⴱⵏⵉ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C212_20","077_12_20","2CO","12","20","20","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵖ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴹⴻⵖ ⵖⴰⵔⵡⴻⵎ, ⴰⴷ ⵜⴰⵖ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⵉⴼⴻⵖ ⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⵙⴻⵖ, ⵓⵍⴰ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜᵉⵜⵜⵉⴼⴻⵎ ⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵅⵙⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⴱⴰⵍⴰⴽ ⴰⴷ ⵉⵍⵉⵏ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ, ⵍⴻⵃⵙⴻⴷ, ⵜⴰⴼⵇⴻⵃⵜ, ⵜⴰⵖⴻⵏⵏⴰⵏⵜ, ⵜⴰⵅⴱⴰⵔⵊⴻⵛⵜ, ⴰⵅⴻⵡⵡⴻⵊ, ⵏⵏⴼⴰⵅⴻⵜ ⵓⵍⴰ ⴷ ⵉⵅⴰⵔⵡⵉⴹⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("C212_21","077_12_21","2CO","12","21","21","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⴹⴻⵖ ⵖⴰⵔⵡⴻⵎ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵜⴰⵖ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵢⵉ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵓⵛⴰ ⴰⴷ ⵛⴻⴹⵏⴻⵖ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵢⵉⵏⵏⵉ ⵉⵅⴹⴰⵏ, ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵛⴰ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵓⴼⵓⵛⵛⴻⵃ ⵉ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("C213_1","077_13_1","2CO","13","1","1","ⴰⵇⴰ ⵜⴰ ⴷ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ. “ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵛⵀⵓⴷ ⴰⴷ ⵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵎⴰⵔⵔⴰ ⵡⴰⵡⴰⵍ!” ");
INSERT INTO rift_vpl VALUES ("C213_2","077_13_2","2CO","13","2","2","ⵏⵏⵉⵖ ⵜⵜ ⵇⴱⴻⵍ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵜⵜ ⵉⵏⵉⵖ ⵇⴱⴻⵍ ⵄⴰⵡⴻⴷ, ⴰⵅⵎⵉ ⵜⵜ ⵏⵏⵉⵖ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵡⴻⵎ ⵡⵉⵙⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵍⴻⵅⵅⵓ, ⵓⵎⵉ ⵖⴰⴱⴻⵖ, ⵜⵜⴰⵔⵉⵖ ⵜⵜ ⵉ ⵢⵉⵏⵏⵉ ⵉⵅⴹⴰⵏ ⵓ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ, ⵎⴰⵍⴰ ⵓⵙⵉⵖ-ⴷⴷ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵡⴰⵔ ⴰⵔⴻⵃⵃⵎⴻⵖ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("C213_3","077_13_3","2CO","13","3","3","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴰⵔⴻⵣⵣⵓⵎ ⵍⴱⵓⵔⵀⴰⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴹⵄⵉⴼⴻⵏ ⴷⴰⵢⵡⴻⵎ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵉⵊⵀⴻⴷ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C213_4","077_13_4","2CO","13","4","4","ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ ⴷⵉ ⵜⵓⴹⵄⴻⴼⵜ, ⴰⵇⴰ ⵉⴷⴷⴰⵔ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⴻⴹⵄⴻⴼ ⴰⴽⵉⴷⴻⵙ, ⵎⴰⵛⴰ ⴰⴷ ⴽⵉⵙ ⵏⴻⴷⴷⴰⵔ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷⴰⵢⵡⴻⵎ ⵉⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("C213_5","077_13_5","2CO","13","5","5","ⵇⴻⴵⴱⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵎⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴱⴻⴷⴷⴰⵎ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⴰⵔⵣⵓⵎ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ. ⵏⵉⵖ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⵇⴰ-ⵜ ⴷⴰⵢⵡⴻⵎ, ⵓ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵎⵎⴻⵏⴹⴰⵔⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("C213_6","077_13_6","2CO","13","6","6","ⵎⴰⵛⴰ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵏⴻⵎⵎⴻⵏⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C213_7","077_13_7","2CO","13","7","7","ⵜⵜᵉⵜⵜⴰⵔⴻⵖ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⴷⴰⵢⵡⴻⵎ ⵜᵉⵜⵜⵡⵉⴼ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴱⴰⵏ ⵜⵇⴻⴵⴻⴱⵜ ⵏⵏⴻⵖ ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴱⴰⵏ ⴰⵅⵎⵉ ⵏᵉⵎⵎⴻⵏⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("C213_8","077_13_8","2CO","13","8","8","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⵡⴰⵍⵓ ⴹⵉⴷⴷ ⵉ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵉ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("C213_9","077_13_9","2CO","13","9","9","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴼⴰⵔⵔⴻⵃ, ⵍⴰⵎⵉ ⵏⴻⴹⵄⴻⴼ ⵓ ⴽⴻⵏⵏⵉⵡ ⵜⵊⴻⵀⴷⴻⵎ. ⵓⵛⴰ ⵏⴻⵜⵜⵥⴰⴵⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴽⴻⵎⵎⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("C213_10","077_13_10","2CO","13","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⴰⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ ⴰⵎ ⵖⴰⴱⴻⵖ, ⵎⴰⵃⴻⵏⴷ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵜⵜⴻⵇⵙⵉⵃⴻⵖ ⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵚⵚⵓⵍⵟⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⵙⵉⴷⵉ ⵉⵏⵓ ⵉ ⵍⴻⴱⵏⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵡⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("C213_11","077_13_11","2CO","13","11","11","ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ, ⴰ ⴰⵢⵜⵎⴰ, ⵉⵍⵉⵎ ⵜⴼⴰⵔⵔⵃⴻⵎ ⴷ ⵜⴽⴻⵎⵎⵍⴻⵎ, ⵉⵍⵉⵎ ⵜᵉⵜⵜⴼⴻⵡⵡⵊⴻⵎ, ⵅⴰⵔⵔⵚⴻⵎ ⵙ ⵢⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵔⴻⵚ, ⵓⵛⴰ ⵊⵊⴻⵎ ⴰⴷ ⴷⵉⵏ ⵜⵉⵍⵉ ⵍⵀⵓⴷⵏⴻⵜ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵜⴰⵢⵔⵉ ⴷ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C213_12","077_13_12","2CO","13","12","12","ⵙⴻⴵⵎⴻⵎ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵍⴻⵀⵏⴰ ⵙ ⵓⵙⵓⴷⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("C213_13","077_13_13","2CO","13","13","13","ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("C213_14","077_13_14","2CO","13","14","14","ⵍⴻⵀⵏⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵎⵓⵏⵜ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GL1_1","078_1_1","GAL","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ - ⵡⴰⵔ ⵉⴵⵉ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵓⵍⴰ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵙ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ, ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ - ");
INSERT INTO rift_vpl VALUES ("GL1_2","078_1_2","GAL","1","2","2","ⵓ ⵎⴰⵔⵔⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⴽⵉⴷⵉ, ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⴳⴰⵍⴰⵟⵉⵢⴰ: ");
INSERT INTO rift_vpl VALUES ("GL1_3","078_1_3","GAL","1","3","3","ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("GL1_4","078_1_4","GAL","1","4","4","ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵜ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GL1_5","078_1_5","GAL","1","5","5","ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵄⵓⴵⵉ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GL1_6","078_1_6","GAL","1","6","6","ⵜⵜⴱⴻⵀⵜⴻⵖ ⵓⵎⵉ ⵜⵙⴻⵎⵃⴻⵎ ⴰⵎⵎⵓ ⴷⴻⵖⵢⴰ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵍⴰⵖⴰⵏ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ. ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("GL1_7","078_1_7","GAL","1","7","7","ⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ, ⵎⴰⵛⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵃⴻⵢⵢⴰⵔⴻⵏ ⵓⵛⴰ ⵅⵙⴻⵏ ⴰⴷ ⵙⵙⵄⴻⵡⵡⵊⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL1_8","078_1_8","GAL","1","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⴻⵖⵏⵉ ⵅ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵣⵉ ⵏⴱⴰⵔⵔⴻⵃ ⵉ ⴽⴻⵏⵏⵉⵡ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵏⵄⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("GL1_9","078_1_9","GAL","1","9","9","ⴰⵎ ⵉⵣⵣⴰⵔⴻⵖ ⵏⵏⵉⵖ, ⵇⵇⴰⵔⴻⵖ ⵜ ⵄⴰⵡⴻⴷ ⵍⴻⵅⵅⵓ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵏⵏⴻⵖⵏⵉ: ⵎⴰⵍⴰ ⵉⴱⴻⵛⵛⴰⵔ ⵃⴻⴷ ⵉ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵊⵊ ‘ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ’ ⵏⵏⴻⵖⵏⵉ ⵅ ⵡⴻⵏⵏⵉ ⵜⵇⴻⴱⵍⴻⵎ, ⴰⴷ ⵜⴰⴼ ⴰⴷ ⵉⵜⵜⵡⴰⵏⵄⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GL1_10","078_1_10","GAL","1","10","10","ⵎⴰ ⴰⵔⴻⵣⵣⵓⵖ ⵍⴻⵅⵅⵓ ⴰⴷ ⵙⵙⵇⴻⵏⵏⵄⴻⵖ ⵉⵡⴷⴰⵏ ⵏⵉⵖ ⴰⵔⴻⴱⴱⵉ? ⵏⵉⵖ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⴰⵔⴹⵉⵖ ⵉⵡⴷⴰⵏ? ⵎⴰⵍⴰ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⴰⵔⴹⵉⵖ ⵉⵡⴷⴰⵏ, ⵡⴰⵔ ⵜⵜⵉⵍⵉⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL1_11","078_1_11","GAL","1","11","11","ⵎⴰⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵎⵍⴻⵖ, ⴰ ⴰⵢⵜⵎⴰ, ⴱⴻⵍⵍⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⵃⴻⵏ ⵣⵣⴰⵢⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⴱⵏⴰⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("GL1_12","078_1_12","GAL","1","12","12","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜ ⵜⵜᵉⵟⵟⴼⴻⵖ ⵏⵉⵖ ⵡⴰⵔ ⵜ ⵍⵎⵉⴷⴻⵖ ⵣⵉ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵙ ⵓⵙⴰⵔⴳⴻⴱ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL1_13","078_1_13","GAL","1","13","13","ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴳⴳⵓⵔⴻⵖ ⵇⴱⴻⵍ ⴷⵉ ⴷⴷⵉⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ, ⵜⵓⵖⴰ ⴷⴰⵔⵔⵛⴻⵖ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵟⵟⴰⵙ, ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⵜⵜ ⴰⵔⴻⴷⴷⴵⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GL1_14","078_1_14","GAL","1","14","14","ⵜⵓⵖⴰ ⵉⵣⵣⴰⵔⴻⵖ ⴷⵉ ⴷⴷⵉⵏ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵇⵔⵉⵏⴻⵏ ⵣⵉ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵎⴻⵃⴹⴻⵖ ⴰⵟⵟⴰⵙ ⵅ ⵜⵖⵓⵔⵉ ⵏ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GL1_15","078_1_15","GAL","1","15","15","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴹⴰ ⵏⴻⵜⵜⴰ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵃⵓⵣⴻⵏ ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵏ ⵢⴻⵎⵎⴰ, ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵢⵉ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("GL1_16","078_1_16","GAL","1","16","16","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴷⴰⵢⵉ ⴷⴷ-ⵉⵙⵙⴻⴹⵀⴰⵔ ⵎⵎⵉⵙ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴱⴰⵔⵔⵃⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵙⵙⴰⵔⴳⵉⴱⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⴷⴻⵖⵢⴰ ⵉ ⵢⴻⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵉⴵⴰ ⴷⴷⴰⵜ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL1_17","078_1_17","GAL","1","17","17","ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵔⵓⵃⴻⵖ ⵛⴰ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ, ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⵉ ⵜⵓⵖⴰ ⴷ ⵔⵔⵓⵙⵓⵍ ⵇⴱⴻⵍ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵔⵓⵃⴻⵖ ⵖⴰⵔ ⵄⴰⵔⴰⴱⵉⵢⵢⴰ, ⵓⵛⴰ ⴷⴻⵡⵍⴻⵖ-ⴷⴷ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⴷⵉⵎⴰⵛⵇ. ");
INSERT INTO rift_vpl VALUES ("GL1_18","078_1_18","GAL","1","18","18","ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ, ⵔⵓⵃⴻⵖ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵍⵇⵉⵖ ⴰⴽ-ⴷ ⴽⵉⴼⴰ ⵓⵛⴰ ⵣⴻⴷⵖⴻⵖ ⴰⴽⵉⴷⴻⵙ ⵅⴻⵎⵎⴻⵙⵟⴰⵛ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL1_19","078_1_19","GAL","1","19","19","ⵡⴰⵔ ⵥⵔⵉⵖ ⵃⴻⴷ ⵏⵏⴻⵖⵏⵉ ⵣⵉ ⵔⵔⵓⵙⵓⵍ ⵎⵖⵉⵔ ⵢⴰⵄⵇⵓⴱ, ⵓⵎⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GL1_20","078_1_20","GAL","1","20","20","ⵎⵉⵏ ⴷ ⴰⵡⴻⵎ ⵜⵜⴰⵔⵉⵖ ⵍⴻⵅⵅⵓ, ⴰⵇⴰ ⴷⴰ ⵛⴻⵀⵀⴷⴻⵖ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ: ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵖ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("GL1_21","078_1_21","GAL","1","21","21","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵔⵓⵃⴻⵖ ⵖⴰⵔ ⵊⵊⵡⴰⵢⴻⵀ ⵏ ⵙⵓⵔⵉⵢⴰ ⴷ ⴽⵉⵍⵉⴽⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GL1_22","078_1_22","GAL","1","22","22","ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴰⵖⴻⵎⴱⵓⴱ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GL1_23","078_1_23","GAL","1","23","23","ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵙⵍⵉⵏ ⵅⴰⴼⵉ ⴰⵎⵎⵓ ⵡⴰⵀⴰ: “ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵏⴻⵖ ⵉⴷⴰⵔⵔⵛⴻⵏ ⵇⴱⴻⵍ, ⵍⴻⵅⵅⵓ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍ’ⵉⵎⴰⵏ ⵉ ⵜⵓⵖⴰ ⵢⴰⵔⴻⴷⴷⴻⴵ ⵣⵉⵛ!”, ");
INSERT INTO rift_vpl VALUES ("GL1_24","078_1_24","GAL","1","24","24","ⵓⵛⴰ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GL2_1","078_2_1","GAL","2","1","1","ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵄⴷⵓⵏ ⴰⵔⴱⴻⵄⵟⴰⵛ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⵔⵓⵃⴻⵖ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⴰⴽ-ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵓⵛⴰ ⵉⵡⵢⴻⵖ ⴰⴽⵉⴷⵉ ⵄⴰⵡⴻⴷ ⵜⵉⵜⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("GL2_2","078_2_2","GAL","2","2","2","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵔⵓⵃⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵉⵊⵊ ⵏ ⵓⵙⴰⵔⴳⴻⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵎⵍⴻⵖ ⴰⵙⴻⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵉ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵡⴻⵇⵇⴰⵔ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵣⵣⵍⴻⵖ ⵏⵉⵖ ⴰⴷ ⴰⵣⵣⵍⴻⵖ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("GL2_3","078_2_3","GAL","2","3","3","ⵄⴰⵡⴻⴷ ⵜⵉⵜⵓⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴰⵎⵉⵢⵓ, ⵡⴰⵔ ⵅⴰⵙ ⴳⴳⴻⵏ ⵙ ⵓⵖⵉⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵡⴰⵅⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL2_4","078_2_4","GAL","2","4","4","ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⵓⴷⴼⴻⵏ-ⴷⴷ ⴰⵡⵎⴰⵜⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵖⴰⵔⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽⴽⵎⴻⵏ ⵅ ⵜⵉⵍⴻⵍⵍⵉ ⵜⴻⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⴳⴳⴻⵏ ⴷ ⵉⵙⵎⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("GL2_5","078_2_5","GAL","2","5","5","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵏⵡⴰⴹⴻⵄ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵣⴻⵃⵣⵉⵃⵜ ⵉ ⵍⴻⵃⵚⴰⵔⴻⵜ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵜⵉⴷⴻⵜⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GL2_6","078_2_6","GAL","2","6","6","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵏⴻⵏ ⴷ ⵛⴰ ⵊⴰⵔ ⴰⵙⴻⵏ - ⵎⵉⵏ ⵎⴰ ⵄⵏⴰⵏ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵛⵇⵉ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ - ⴰⵇⴰ ⵡⴰⵔ ⵅⴰⴼⵉ ⵏⵏⴰⵏ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("GL2_7","078_2_7","GAL","2","7","7","ⵙ ⵍⵄⴻⴽⵙ, ⵎⴰⵖⴰⵔ ⵥⵔⵉⵏ, ⴱⴻⵍⵍⵉ ⵜⵜⴽⴻⵍⵍⴼⴻⵖ ⵅ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⴽⴻⵍⵍⴻⴼ ⴱⵓⵟⵔⵓⵙ ⵅ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⵙ ⵡⴻⵅⵜⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("GL2_8","078_2_8","GAL","2","8","8","- ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵄⴰⵔⵔⵏⴻⵏ ⴱⵓⵟⵔⵓⵙ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ ⴰⵎ ⵔⵔⴰⵙⵓⵍ ⵊⴰⵔ ⵉⵏⵏⵉ ⵉⵅⴻⵜⵏⴻⵏ, ⵉⵄⴰⵔⵔⴻⵏ ⴰⵢⵉ ⵄⴰⵡⴻⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵔⵔⴰⵙⵓⵍ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ - ");
INSERT INTO rift_vpl VALUES ("GL2_9","078_2_9","GAL","2","9","9","ⵓⵛⴰ ⵓⵎⵉ ⵢⴰⵄⵇⵓⴱ ⴷ ⴽⵉⴼⴰ ⴷ ⵢⵓⵃⴰⵏⵏⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ, ⵏⴻⵄⵎⴻⵏ ⵙ ⴰⵔⴹⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ, ⵡⵛⵉⵏ ⴰⵏⴻⵖ ⴰⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵜⵎⵓⵏⵜ ⵏ ⵜⴰⵡⵎⴰⵜ ⵉ ⵏⴻⵛⵛ ⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ, ⵃⵉⵎⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⵏᵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵊⴰⵔ ⵉⵏⵏⵉ ⵙ ⵡⴻⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL2_10","078_2_10","GAL","2","10","10","ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴼⴻⴽⴽⴰⵔ ⴷⴻⴳ ⵉⵎⴻⵣⵍⴰⴹ ⵡⴰⵀⴰ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵛⴹⴰⵔⴻⵖ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("GL2_11","078_2_11","GAL","2","11","11","ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⴽⵉⴼⴰ ⵖⴰⵔ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ, ⵎⵎⵄⴰⵍⵉⵖ ⴰⴽⵉⴷⴻⵙ ⵙ ⴱⵟⴰⵢⵟⴰⵢ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵏⵏⵇⴰⵔⴹⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GL2_12","078_2_12","GAL","2","12","12","ⵎⵉⵏⵣⵉ ⵇⴱⴻⵍ ⵎⴰ ⴷⴷ-ⵓⵙⵉⵏ ⵛⴰ ⵣⵉ ⵢⴰⵄⵇⵓⴱ, ⵜⵓⵖⴰ ⵉⵜⵜⴻⵜⵜ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵏⵉⵜⵏⵉ, ⵉⵄⵇⴻⴱ ⵓⵛⴰ ⵉⵙⵙⴱⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵣⴰⵢⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⴷ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵡⴻⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL2_13","078_2_13","GAL","2","13","13","ⵓⵍⴰ ⴷ ⵓⴷⴰⵢⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵜⵜⵡⴰⵊⴻⴱⴱⴷⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴱⴰⵔ-ⵏⴰⴱⴰ, ⴰⵇⴰ ⵏⴻⴷⵀⴻⵏ ⵜ ⴷⵉ ⵏⵏⵉⴼⴰⵇ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL2_14","078_2_14","GAL","2","14","14","ⵎⴰⵛⴰ ⵓⵎⵉ ⵥⵔⵉⵖ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴳⴳⵓⵔⴻⵏ ⵛⴰ ⵏⵉⵛⴰⵏ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵉⴷⴻⵜⵜ ⵏ ⵍ’ⵉⵏⵊⵉⵍ, ⵏⵏⵉⵖ ⵉ ⴽⵉⴼⴰ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ: “ⵎⴰⵍⴰ ⵛⴻⴽ, ⴰⵎ ⵜⴻⴵⵉⴷ ⴷ ⵓⴷⴰⵢ, ⵜⴻⴷⴷⴰⵔⴻⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴰⵔⴰⵎⵉⵢⵓ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵡⵓⴷⴰⵢ, ⵎⴰⵢⴻⵎⵎⵉ ⵜⴻⴳⴳⵉⴷ ⴰⵖⵉⵍ ⵅ ⵢⵉⵏⵏⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⴰⵎ ⵡⵓⴷⴰⵢⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("GL2_15","078_2_15","GAL","2","15","15","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵓⴷⴰⵢⴻⵏ ⵄⵍⴰⵃⵚⴰⴱ ⵟⵟⴱⵉⵄⴻⵜ, ⵡⴰⵔ ⵏⴻⴵⵉ ⵛⴰ ⴷ ⵉⵎⴻⴷⵏⴰⴱ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("GL2_16","078_2_16","GAL","2","16","16","ⵏⵓⵎⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵛⴰ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵍⴰⵎⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⵉⵏⵣⵉ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴰⴷ ⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ. ");
INSERT INTO rift_vpl VALUES ("GL2_17","078_2_17","GAL","2","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵛⵛⵉⵏ, ⴰⵎ ⵏⴰⵔⴻⵣⵣⵓ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍⵎⴰⵙⵉⵃ, ⵏⵓⴼⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛⵉⵏ ⵄⴰⵡⴻⴷ ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⵎⴰ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵅⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴷⴷⵏⵓⴱ? ⵡⴰⵢⵢⴰⵡ! ");
INSERT INTO rift_vpl VALUES ("GL2_18","078_2_18","GAL","2","18","18","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴱⵏⵉⵖ ⵄⴰⵡⴻⴷ ⵎⵉⵏ ⵀⴻⴷⵎⴻⵖ, ⴰⴷ ⵙⵙⴻⵛⵏⴻⵖ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵙ ⵉⵅⴻⴼ ⵉⵏⵓ ⴷ ⵡⴻⵏⵏⵉ ⵉⵄⴻⴷⴷⵓⵏ ⵅ ⵜⴻⵡⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("GL2_19","078_2_19","GAL","2","19","19","ⵎⵉⵏⵣⵉ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵇⴰ ⵏⴻⵛⵛ ⵎⵎⵓⵜⴻⵖ ⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GL2_20","078_2_20","GAL","2","20","20","ⵜⵜⵡⴰⵚⴻⵍⵍⴱⴻⵖ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵖ ⴷⴷⴰⵔⴻⵖ ⵄⴰⴷ ⵏⴻⵛⵛ, ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⵉⴷⴷⴰⵔ ⴷⴰⵢⵉ. ⵓⵛⴰ ⵎⵉⵏ ⴷⴷⴰⵔⴻⵖ ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⴷⴷⴰⵔⴻⵖ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⵉⵡⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅⴰⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GL2_21","078_2_21","GAL","2","21","21","ⵡⴰⵔ ⴱⴻⴹⵍⴻⵖ ⵛⴰ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵙ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵎⵓⵜ ⵍⵎⴰⵙⵉⵃ ⵅ ⵡⴰⵍⵓ.” ");
INSERT INTO rift_vpl VALUES ("GL3_1","078_3_1","GAL","3","1","1","ⴰ ⵉⴳⴰⵍⴰⵟⵉⵢⵢⴻⵏ ⵉⴼⵖⵓⵍⴻⵏ, ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵓⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ? ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵔⵛⴻⵎ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵅ ⵚⵚⴰⵍⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("GL3_2","078_3_2","GAL","3","2","2","ⴷⴻⴳⴳⴰ ⵡⴰⵀⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜ ⵙⵙⵏⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ: ⵎⴰ ⵜᵉⵟⵟⴼⴻⵎ ⴰⵔⵔⵓⵃ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵉⵖ ⵓⵎⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⵔⵔⴰⵢ ⵉ ⵍ’ⵉⵎⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("GL3_3","078_3_3","GAL","3","3","3","ⵎⴰ ⴰⵎⴻⵏⵏⵉ ⵜⴻⴵⴰⵎ ⴷ ⵉⴼⵖⵓⵍⴻⵏ, ⴰⵇⴰ ⵜⴻⴱⴷⴰⵎ ⵙ ⴰⵔⵔⵓⵃ, ⵎⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵙ ⴷⴷⴰⵜ? ");
INSERT INTO rift_vpl VALUES ("GL3_4","078_3_4","GAL","3","4","4","ⵎⴰ ⵜⴻⴽⵙⵉⵎ ⵜⴰⵎⴰⵔⴰ ⴰⵟⵟⴰⵙ ⵅ ⵡⴰⵍⵓ? ⵎⴰ ⵜⵓⵖⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵅ ⵡⴰⵍⵓ? ");
INSERT INTO rift_vpl VALUES ("GL3_5","078_3_5","GAL","3","5","5","ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵡⵛⵉⵏ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⵉⵜⵜⴻⴳⴳ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵎⴰ ⵉⵜⵜⴻⴳⴳ ⵉ-ⵜⴻⵏⵜ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⵉⵖ ⵓⵎⵉ ⵜᵉⵜⵜⴻⵙⵍⴰⵎ ⵜⴰⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍ’ⵉⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("GL3_6","078_3_6","GAL","3","6","6","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵢⵓⵎⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("GL3_7","078_3_7","GAL","3","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵍ’ⵉⵎⴰⵏ, ⵏⵉⵜⵏⵉ ⴷ ⴰⵢⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GL3_8","078_3_8","GAL","3","8","8","ⵎⵉⵏⵣⵉ ⵉⵙⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵇⴱⴻⵍ, ⴰⵇⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ ⵙ ⵍ’ⵉⵎⴰⵏ, ⵉⵣⵣⴰⵔ ⵉⴱⴻⵛⵛⴰⵔ ⵏⴻⵜⵜⴰ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵇⵇⴰⵔⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⴷⴰⵢⴻⴽ ⵉ ⵖⴰ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵔⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("GL3_9","078_3_9","GAL","3","9","9","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴰⴷ ⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⴰⴽ-ⴷ ⵍⵎⵓⵎⴻⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("GL3_10","078_3_10","GAL","3","10","10","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⴰⴷⵓ ⵏⵏⴻⵄⵍⴻⵜ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵇⵇⵉⵎⴻⵏ ⵉⵜⵜᵉⵟⵟⴻⴼ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵉⴳⴳ!” ");
INSERT INTO rift_vpl VALUES ("GL3_11","078_3_11","GAL","3","11","11","ⴰⵇⴰ ⵉⵜⵜⴱⴰⵏ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⵉⵏ ⵃⴻⴷ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⴰⵎⵙⴻⴳⴳⴰⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⴰⴷ ⵉⴷⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("GL3_12","078_3_12","GAL","3","12","12","ⵅⴻⵏⵏⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵔ ⵜⴽⴻⵎⵎⴻⵍ ⵛⴰ ⵙ ⵍ’ⵉⵎⴰⵏ, ⵎⴰⵛⴰ ⴱⵏⴰⴷⴻⵎ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵢⵓⵔⵉⵏ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GL3_13","078_3_13","GAL","3","13","13","ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⴰⵇⴰ ⵉⵅⴻⴵⴻⵚ ⵅⴰⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵣⵉ ⵏⵏⴻⵄⵍⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵢⵉⵏⵏⵉ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵎ ⴷ ⵉⴷⵡⴻⵍ ⵅⴰⵏⴻⵖ ⴷ ⴰⵎⴻⵏⵄⵓⵍ, ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⴷ ⴰⵎⴻⵏⵄⵓⵍ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵜ ⵖⴰ ⵢⵓⵢⵍⴻⵏ ⵅ ⵜⴻⵃⵏⴰⵛⵜ!”, ");
INSERT INTO rift_vpl VALUES ("GL3_14","078_3_14","GAL","3","14","14","ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵡⴻⴹ ⵍⴱⴰⵔⴰⴽⴰ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵃⴻⵏⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⵍⵡⴰⵄⴷ ⵏ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GL3_15","078_3_15","GAL","3","15","15","ⴰ ⴰⵢⵜⵎⴰ, ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵍⴻⵃⵙⴰⴱ ⵍⴻⵄⵇⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ: ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵊⴰⵔ ⵉⵡⴷⴰⵏ, ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵜ ⵉⴱⴹⴻⵍ ⵏⵉⵖ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⴱⴻⴷⴷⴻⵍ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GL3_16","078_3_16","GAL","3","16","16","ⴰⵇⴰ ⵍⵡⵓⵄⵓⴷ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵉ ⵉⴱⵔⴰⵀⵉⵎ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵢⵉⵏⵉ ⵛⴰ: “ⵉ ⵉⵄⴻⵇⵇⴰⵢⴻⵏ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵡⴻⵎ!”, ⴰⵎ ⵉ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ: “ⵉ ⵓⵄⴻⵇⵇⴰ ⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ!”, ⴰⵎ ⵉ ⵢⵉⵊⵊⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL3_17","078_3_17","GAL","3","17","17","ⵅⴻⵏⵏⵉ ⵇⵇⴰⵔⴻⵖ ⴰⵎⵎⵓ: ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵔⴻⴱⴱⵉ ⵣⵉⵛ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵜ ⵜⴱⴻⵟⵟⵉⵍ ⵛⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⵜⴻⵏⵏⵉ ⵜⵓⵙⴰ-ⴷⴷ ⴰⵔⴻⴱⵄⴰ-ⵎⵢⴰ ⵓ-ⵜⵍⴰⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳ ⵍⵡⴰⵄⴷ ⵉⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL3_18","078_3_18","GAL","3","18","18","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵍⵡⴰⵔⵜ ⵉⴵⴰ ⵙ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⵙ ⵍⵡⴰⵄⴷ ⵉ ⵉⴱⵔⴰⵀⵉⵎ. ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵙ ⵜ ⵙ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("GL3_19","078_3_19","GAL","3","19","19","ⵅⴻⵏⵏⵉ ⵉ ⵓⵎⵉ ⵜⵏⴻⴼⴼⴻⵄ ⵛⵛⴰⵔⵉⵄⴰ? ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵎⵎⴰⵔⵏⵉ ⵖⴰⵔ ⵍⵡⴰⵄⴷ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⴰⵍⴰⵎⵉ ⴷⴷ-ⵜⵓⵙⴰ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴳⴳ ⵍⵡⴰⵄⴷ. ⵓ ⵙ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵜⴻⵎⵎⴻⵡⵛ ⵛⵛⴰⵔⵉⵄⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵉⵊⵊ ⵏ ⵍⵡⴰⵙⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("GL3_20","078_3_20","GAL","3","20","20","ⵍⵡⴰⵙⵉⵜ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵍⵡⴰⵙⵉⵜ ⵏ ⵉⵊⵊⴻⵏ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL3_21","078_3_21","GAL","3","21","21","ⵎⴰ ⵅⴻⵏⵏⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴹⵉⴷⴷ ⵉ ⵍⵡⴰⵄⴷ ⵏ ⴰⵔⴻⴱⴱⵉ? ⵄⴻⵎⵎⴰⵔⵚ! ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵉⵛⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵙⵙⴻⴷⴷⴰⵔ, ⴷ ⵜⵉⴷⴻⵜⵜ ⵜⵓⵖⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵙ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GL3_22","078_3_22","GAL","3","22","22","ⵎⴰⵛⴰ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴱⴻⵍⵍⵄⴻⵏⵜ ⵅ ⵎⴰⵔⵔⴰ ⴷⵉ ⴷⴷⵏⵓⴱ, ⵃⵉⵎⴰ ⵍⵡⴰⵄⴷ ⴰⴷ ⵉⵎⵎⴻⵡⵛ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL3_23","078_3_23","GAL","3","23","23","ⵎⴰⵛⴰ ⵇⴱⴻⵍ ⵎⴰ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵍ’ⵉⵎⴰⵏ, ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵏᵉⵎⵎⴻⵃⴹⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵛⴰ ⵉⵜⵜⵡⴰⴱⴻⵍⵍⴻⵄ ⵅⴰⵏⴻⵖ ⵣⵉ ⵍ’ⵉⵎⴰⵏ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉ ⵖⴰ ⵉⴹⵀⴰⵔⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("GL3_24","078_3_24","GAL","3","24","24","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵎ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴰⵔⴻⴱⴱⴰⵏ ⴰⵍ ⵍⵎⴰⵙⵉⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL3_25","078_3_25","GAL","3","25","25","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵓⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵍ’ⵉⵎⴰⵏ, ⴰⵇⴰ ⵡⴰⵔ ⵏⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵙⴰⴷⵓ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⴱⴱⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL3_26","078_3_26","GAL","3","26","26","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL3_27","078_3_27","GAL","3","27","27","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⴰⵔⴹⴻⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL3_28","078_3_28","GAL","3","28","28","ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⴷⵉⵏ ⵓⴷⴰⵢ ⵏⵉⵖ ⴰⵔⴰⵎⵉⵢ, ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⵉⵙⵎⴻⵖ ⵏⵉⵖ ⴰⵃⵓⵔⵔⵉ, ⵡⴰⵔ ⴷⵉⵏ ⵄⴰⴷ ⴰⵔⵢⴰⵣ ⵏⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊⴻⵏ ⵉ ⵜⴻⴵⴰⵎ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL3_29","078_3_29","GAL","3","29","29","ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰⵎ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ ⵓⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴰⵄⴷ ⴷ ⵉⵡⵔⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL4_1","078_4_1","GAL","4","1","1","ⵅⵙⴻⵖ ⴰⴷ ⵉⵏⵉⵖ, ⵎⴻⵛⵃⴰⵍ ⵎⴰ ⴷ ⴰⵡⵔⵉⵜ ⴰⵇⴰ-ⵜ ⵄⴰⴷ ⴷ ⴰⵃⴻⵏⵊⵉⵔ, ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⵍⴼⴰⵔⵇ ⵅ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⴷ ⴱⴰⴱ ⵏ ⵎⴰⵔⵔⴰ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GL4_2","078_4_2","GAL","4","2","2","ⵏⴻⵜⵜⴰ ⵉⴵⴰ ⵄⴰⴷ ⵙⴰⴷⵓ ⵉⵎⴻⵃⴷⴰⵢⴻⵏ ⵓ ⵙⴰⴷⵓ ⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⵢⵢⴰⵔⴻⵏ ⵜⴰⴷⴷⴰⵔⵜ ⴰⵍ ⵍⵡⴻⵇⵜ ⵉ ⵢⴻⴳⴳⴰ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("GL4_3","078_4_3","GAL","4","3","3","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛⵉⵏ, ⵓⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⵓⵖⴰ ⵄⴰⴷ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵙⴰⴷⵓ ⵚⵚⵓⵍⵟⴰ ⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GL4_4","078_4_4","GAL","4","4","4","ⵎⴰⵛⴰ ⵓⵎⵉ ⴷⴷ-ⵢⵉⵡⴻⴹ ⵓⵄⴻⵎⵎⴰⵔ ⵏ ⵍⵡⴻⵇⵜ, ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵎⵎⵉⵙ ⵉ ⵢⴻⴵⴰⵏ ⵣⵉ ⵜⴻⵎⵖⴰⵔⵜ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("GL4_5","078_4_5","GAL","4","5","5","ⵃⵉⵎⴰ ⴰⴷ ⵉⴼⴷⵉ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⵍⴻⴼⴹⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵇⴱⴻⵍ ⴷ ⵎⵎⵉⵙ.    ");
INSERT INTO rift_vpl VALUES ("GL4_6","078_4_6","GAL","4","6","6","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰⵎ ⴷ ⴰⵔⵔⴰⵡⴻⵏ, ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⴻⴽⴽ ⴰⵔⵔⵓⵃ ⵏ ⵎⵎⵉⵙ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ: ‘ⴱⴰⴱⴰ, ⴱⴰⴱⴰⵜⵏⴻⵖ!’ ");
INSERT INTO rift_vpl VALUES ("GL4_7","078_4_7","GAL","4","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵄⴰⴷ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⵓ ⵎⴰⵍⴰ ⴰⵔⵔⴰⵡⴻⵏ ⵉ ⵜⴻⴵⴰⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL4_8","078_4_8","GAL","4","8","8","ⵎⴰⵛⴰ ⴷⵉ ⵣⵣⵎⴰⵏ ⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵜⵓⵖⴰ ⵜⵄⴻⴱⴱⴷⴻⵎ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵙ ⵜⴻⵡⵡⴰ ⴷ ⵉⵔⴻⴱⴱⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL4_9","078_4_9","GAL","4","9","9","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵔⴻⴱⴱⵉ, ⵄⴰⴷ ⵃⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ ⵢⴰⵔⴳⴻⴱ ⵅⴰⵡⴻⵎ, ⴰⵇⴰ ⵜⵄⴻⵇⴱⴻⵎ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵚⵚⵓⵍⵟⴰ ⵏ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵉⴹⴻⵄⴼⴻⵏ ⵉⵣⴻⵍⴹⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵜⴻⵅⵙⴻⵎ ⵄⴰⵡⴻⴷ ⴰⴷ ⴰⵙⴻⵏⵜ ⵜᵉⵎⵎⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴰⵎ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ! ");
INSERT INTO rift_vpl VALUES ("GL4_10","078_4_10","GAL","4","10","10","ⵜⵃⴻⵟⵟⴰⵎ ⵓⵙⵙⴰⵏ ⴷ ⵉⵢⵓⵔⴻⵏ ⴷ ⵣⵣⵎⴰⵏⴰⵜ ⴷ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("GL4_11","078_4_11","GAL","4","11","11","ⵜⵜᵉⴳⴳⵯⴻⴷⴻⵖ ⵅⴰⵡⴻⵎ ⴰⵇⴰ ⵜⵜⴰⵎⴰⵔⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵎ ⵅ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("GL4_12","078_4_12","GAL","4","12","12","ⴰ ⴰⵢⵜⵎⴰ, ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵉⵍⵉⵎ ⴰⵎ ⵏⴻⵛⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵎ ⴽⴻⵏⵏⵉⵡ. ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵜⴻⴳⴳⵉⵎ ⵡⴰⵍⵓ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("GL4_13","078_4_13","GAL","4","13","13","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴱⴰⵔⵔⵃⴻⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙ ⵜⵓⴹⵄⴻⴼⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GL4_14","078_4_14","GAL","4","14","14","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⵙⵙⴻⵃⵇⴰⵔⴻⵎ ⵏⵉⵖ ⵜⴻⵙⵙⵟⴻⵢⵢⵃⴻⵎ ⵣⴻⴳ ⵓⵎⴰⵔⵔⴻⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵜⵇⴻⴱⵍⴻⵎ ⴰⵢⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴰⵎ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL4_15","078_4_15","GAL","4","15","15","ⵎⴰⵏⵉ ⵜⵔⵓⵃ ⵅⴻⵏⵏⵉ ⵍⴱⴰⵔⴰⴽⴰ ⵏⵡⴻⵎ? ⵎⵉⵏⵣⵉ ⵛⴻⵀⵀⴷⴻⵖ ⵅⴰⵡⴻⵎ ⴱⴻⵍⵍⵉ, ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ, ⴰⴷ ⵜⵇⴻⵍⵄⴻⵎ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵜⴻⵏⵜ ⵜⴻⵡⵛⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GL4_16","078_4_16","GAL","4","16","16","ⵎⴰ ⴷⴻⵡⵍⴻⵖ ⴷ ⵍⴻⵄⴷⵓ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⴱⴰⵔⵔⵃⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⵉⴷⴻⵜⵜ? ");
INSERT INTO rift_vpl VALUES ("GL4_17","078_4_17","GAL","4","17","17","ⵏⵉⵜⵏⵉ ⵛⴹⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ ⵅⴰⵡⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵀⴰ, ⵎⴰⵖⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵃⴻⴱⴱⵙⴻⵏ, ⵃⵉⵎⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵛⴹⴰⵔⴻⵎ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL4_18","078_4_18","GAL","4","18","18","ⵡⴰⵀ, ⵎⵍⵉⵃ ⴰⴷ ⵜⵉⵍⵉⵎ ⵍⴻⴱⴷⴰ ⵜⵛⴻⵟⵟⴰⵔⴻⵎ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵅⵎⵉ ⴽⵉⵡⴻⵎ ⵉ ⵖⴰ ⵃⴹⴰⵔⴻⵖ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("GL4_19","078_4_19","GAL","4","19","19","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ ⴰⵇⴰ ⴰⵢⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⴷⴷⴻⵢⵙⴻⵜ ⵣⵣⴰⵢⵡⴻⵎ ⵙ ⵓⵏⴻⵣⴱⴰⵔ ⵏ ⵜⴰⵔⵡⴰ, ⴰⵍ ⴷⴰⵢⵡⴻⵎ ⵉ ⵖⴰ ⵉⵍⵉⵏⵜ ⵜⴻⴼⵔⴰⵙ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL4_20","078_4_20","GAL","4","20","20","ⵅⵙⴻⵖ ⵍⴻⵅⵅⵓ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴱⴻⴷⴷⵍⴻⵖ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵓⴳⵏⵓⵖ ⵣⵣⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GL4_21","078_4_21","GAL","4","21","21","ⵉⵏⵉⵎ ⴰⵢⵉ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵜⵉⵍⵉⵎ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰ ⵡⴰⵔ ⵜᵉⵟⵟⵉⵄⴻⵎ ⵛⴰ ⵛⵛⴰⵔⵉⵄⴰ? ");
INSERT INTO rift_vpl VALUES ("GL4_22","078_4_22","GAL","4","22","22","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵓⵔⴰ ⴱⴻⵍⵍⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵉⵊⵊⴻⵏ ⵏ ⵜⴰⵢⵢⴰ, ⵡⴻⵏⵏⴻⵖⵏⵉ ⵏ ⵜⵃⵓⵔⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("GL4_23","078_4_23","GAL","4","23","23","ⵡⴻⵏⵏⵉ ⵏ ⵜⴰⵢⵢⴰ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵄⵍⴰⵃⵙⴰⴱ ⴷⴷⴰⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵏ ⵜⵃⵓⵔⵔⴻⵛⵜ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("GL4_24","078_4_24","GAL","4","24","24","ⵜⵉⵏⴰ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⴻⴷⵢⴰ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⵄⵓⵀⵓⴷ, ⵉⵊⵊⴻⵏ ⵏ ⵡⴻⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ, ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵔⵡⴻⵏ ⵜⴰⵙⵎⵓⵖⵉ, ⴰⵇⴰ-ⵜ ⵀⴰⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GL4_25","078_4_25","GAL","4","25","25","ⵎⵉⵏⵣⵉ ⵀⴰⵊⴰⵔ ⴷ ⴰⴷⵔⴰⵔ ⵏ ⵙⵉⵏⴰ ⴷⵉ ⵄⴰⵔⴰⴱⵉⵢⵢⴰ, ⵜⴻⵏⵏⵉ ⵢⴰⵔⴻⵡⵙⴻⵏ ⴷⵉ ⵓⵔⵛⴰⵍⵉⵎ ⵏ ⵍⴻⵅⵅⵓ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵙⵎⵓⵖⵉ ⴰⴽ-ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GL4_26","078_4_26","GAL","4","26","26","ⵎⴰⵛⴰ ⵓⵔⵛⴰⵍⵉⵎ ⵏ ⵙⴻⵏⵏⴻⵊ ⴷ ⵜⴰⵃⵓⵔⵔⴻⵛⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵢⴻⵎⵎⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("GL4_27","078_4_27","GAL","4","27","27","ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⴼⴰⵔⵃ, ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵔⵡⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ! ⴷⵓⵇⵇⴻⵣ ⵙ ⵓⵙⵍⵉⵡⵍⴻⵡ, ⵙⵖⵓⵢⵢ ⵙ ⵊⵊⴻⵀⴷ, ⴰ ⵛⴻⵎ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵡⴰ, ⵎⴰⵖⴰⵔ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵏⵏⵉ ⴷⵉ ⵙⴻⵎⵃⴻⵏ ⴷ ⴰⵟⵟⴰⵙ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴻⵔⵢⴰⵣ.” ");
INSERT INTO rift_vpl VALUES ("GL4_28","078_4_28","GAL","4","28","28","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ, ⴰ ⴰⵢⵜⵎⴰ, ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵍⵡⴰⵄⴷ ⴰⵎ ⵉⵙⵃⴰⵇ. ");
INSERT INTO rift_vpl VALUES ("GL4_29","078_4_29","GAL","4","29","29","ⵎⴰⵛⴰ ⴰⵎ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵡⵉ ⴷⴷ-ⵉⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴷⴷⴰⵜ ⵜⵓⵖⴰ ⵉⵎⴰⵔⵔⴻⵜ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⵓⵃ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("GL4_30","078_4_30","GAL","4","30","30","ⵎⴰⵛⴰ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ? “ⵏⴹⴰⵔⴻⵎ ⴱⴰⵔⵔⴰ ⵜⴰⵢⵢⴰ ⴷ ⵎⵎⵉⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵎⵎⵉⵙ ⵏ ⵜⴰⵢⵢⴰ ⴷ ⴰⵡⵔⵉⵜ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵏ ⵜⵃⵓⵔⵔⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("GL4_31","078_4_31","GAL","4","31","31","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵏⴻⴵⵉ ⵛⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⵢⵢⴰ, ⵎⴰⵛⴰ ⵜⴰⵔⵡⴰ ⵏ ⵜⵃⵓⵔⵔⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("GL5_1","078_5_1","GAL","5","1","1","ⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵍⴻⵍⵍⵉ ⵜⴻⵏⵏⵉ ⵓⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⴷⴻⴽⴽⵡⵉⵍⴻⵎ ⵄⴰⵡⴻⴷ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⴰⵣⴰⵢⵍⵓ ⵏ ⵜⴻⵙⵎⵓⵖⵉ. ");
INSERT INTO rift_vpl VALUES ("GL5_2","078_5_2","GAL","5","2","2","ⴰⵇⴰ ⴰⵢⵉ ⵏⴻⵛⵛ ⴱⵓⵍⵓⵙ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ, ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ, ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴻⴼⴼⴻⵄ ⴷⴻⴳ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("GL5_3","078_5_3","GAL","5","3","3","ⵄⴰⵡⴻⴷ ⵛⴻⵀⵀⴷⴻⵖ ⵉ ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵙ ⵓⵎⴰⵔⵡⴰⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GL5_4","078_5_4","GAL","5","4","4","ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵎ ⵙ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵜⴷⴻⵡⵍⴻⵏ ⵜⴰⵔⵅⵓⵎ ⵣⵉ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵣⵉ ⴰⵔⴹⴰ ⵉ ⵣⵉ ⴷⴷ-ⵜⴻⵡⴹⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("GL5_5","078_5_5","GAL","5","5","5","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵔⴰⵊⴰ ⴰⵙⵉⵜⴻⵎ ⵏ ⵜⵙⴻⴳⴷⴰ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL5_6","078_5_6","GAL","5","6","6","ⵎⴰⵖⴰⵔ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵅⵜⴰⵏ ⵏⵉⵖ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵀⴰ ⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵙ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GL5_7","078_5_7","GAL","5","7","7","ⴽⴻⵏⵏⵉⵡ ⵜⵓⵣⵣⵍⴻⵎ ⵎⵍⵉⵃ! ⵡⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵎⴻⵏⵄⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵟⵟⵉⴼⴻⵎ ⵄⴰⴷ ⵙ ⵍⴰⵎⴰⵏ ⴷⵉ ⵜⵉⴷⴻⵜⵜ? ");
INSERT INTO rift_vpl VALUES ("GL5_8","078_5_8","GAL","5","8","8","ⵟⵡⴰⵄ-ⴰ ⵏⵡⴻⵎ ⵡⴰⵔ ⵉⴵⵉ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵍⴰⵖⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL5_9","078_5_9","GAL","5","9","9","ⵛⵡⴰⵢⵜ ⵏ ⵡⴻⵏⵜⵓⵏ ⵉⵙⵙⵎⴻⵎⵎ ⵎⴰⵔⵔⴰ ⵍⵄⴻⵊⵏⴻⵜ ⵏ ⵡⴰⵔⴻⵛⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("GL5_10","078_5_10","GAL","5","10","10","ⵏⴻⵛⵛ ⵜⵜⵉⵇⵇⴻⵖ ⴷⴰⵢⵡⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵏ ⵜⵉⵍⵉ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵏⴻⵖⵏⵉ. ⵓ ⵡⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵙⴻⴷⴷⴰⵄⴻⵏ, ⴰⵇⴰ ⴰⴷ ⵢⴰⵔⴱⵓ ⵍⵃⵓⴽⵎ, ⵎⴰⵏ ⵡⴻⵏ ⵎⴰ ⵉⵄⵏⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("GL5_11","078_5_11","GAL","5","11","11","ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵍⴰ ⵏⴻⵛⵛ ⵜⵜⴱⴰⵔⵔⵃⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⵙ ⵡⴻⵅⵜⴰⵏ, ⵎⴰⵢⴻⵎⵎⵉ ⵄⴰⴷ ⵉ ⵖⴰ ⵜⵜⵡⴰⵎⴰⵔⵔⵜⴻⵖ? ⵎⴰ ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⴱⴻⵟⵟⴻⵍ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵏ ⵚⵚⴰⵍⵉⴱ? ");
INSERT INTO rift_vpl VALUES ("GL5_12","078_5_12","GAL","5","12","12","ⵎⴻⵄⵍⵉⴽ ⵇⴰⵄ ⵜⵜⴻⵅⵙⴻⵖ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵇⴻⵙⵙⴻⵏ, ⴰⴷ ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL5_13","078_5_13","GAL","5","13","13","ⵉ ⵜⵉⵍⴻⵍⵍⵉ ⵓⵎⵉ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵇⴻⴵⴱⴻⵎ ⵜⵉⵍⴻⵍⵍⵉ ⴰⵎ ⵍⴼⵓⵔⵚⴰ ⵉ ⵡⴻⵢⵙⵓⵎ, ⵎⴰⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("GL5_14","078_5_14","GAL","5","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴽⴻⵎⵎⴻⵍ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ, ⴰⵇⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ: “ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵅⴻⴼ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("GL5_15","078_5_15","GAL","5","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵣⴻⵄⵄⴼⴻⵎ ⵓ ⵜᵉⵜⵜⴻⵜⵜⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵅⴻⵏⵏⵉ ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⴻⵎ ⵛⴰ ⴰⵢⴰⵡⵢⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("GL5_16","078_5_16","GAL","5","16","16","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵡⴰⵔ ⵜⵜⴽⴻⵎⵎⵍⴻⵏ ⵄⴻⵎⵎⴰⵔⵚ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("GL5_17","078_5_17","GAL","5","17","17","ⵎⵉⵏⵣⵉ ⴷⴷⴰⵜ ⵢⴰⵔⴻⵣⵣⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⴹⵉⴷⴷ ⵏ ⴰⵔⵔⵓⵃ, ⵓⵛⴰ ⴰⵔⵔⵓⵃ ⵢⴰⵔⴻⵣⵣⵓ ⵎⵉⵏ ⵉⴵⴰⵏ ⴹⵉⴷⴷ ⵏ ⵡⴻⵢⵙⵓⵎ. ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵜⵜⴱⴻⴷⴷⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵜⴻⵅⵙⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GL5_18","078_5_18","GAL","5","18","18","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴰⵔⵔⵓⵃ ⵉⵏⴷⴻⵀ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵄⴰⴷ ⵙⴰⴷⵓ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("GL5_19","078_5_19","GAL","5","19","19","ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵡⴻⵢⵙⵓⵎ ⴱⴰⵏⴻⵏⵜ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵣⵣⵉⵏⴰ ⴷ ⵍⴻⵅⵎⴻⵊ ⴷ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ    ");
INSERT INTO rift_vpl VALUES ("GL5_20","078_5_20","GAL","5","20","20","ⴷ ⵓⵄⴱⴰⴷ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵜⵙⴻⵃⵃⴰⵔⵜ ⴷ ⵍⴻⵄⴷⴰⵡⴻⵜ ⴷ ⵓⵎⵛⴻⴱⴱⴻⵛ ⴷ ⵍⴻⵃⵙⴻⴷ ⴷ ⵜⴻⴼⵇⴻⵃⵜ ⴷ ⵓⵖⴻⵡⵡⴻⵖ ⴷ ⵓⴱⴻⵟⵟⵓ ⴷ ⵜⵖⵓⵔⵉⵡⵉⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ");
INSERT INTO rift_vpl VALUES ("GL5_21","078_5_21","GAL","5","21","21","ⴷ ⵜⵓⵙⵎⵉ ⴷ ⵡⴻⵏⵖⴰⵢ ⴷ ⵓⵖⴻⵍⵍⵉ ⴷ ⵍⴻⴼⵙⴻⴷ ⵓⵍⴰ ⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⴻⵖⵏⵉⵜ ⴰⵎ ⵜⵉⵏⴰ. ⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⵖⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴰⵇⴰ ⵉⵣⵡⴰⵔⴻⵖ ⵏⵏⵉⵖ ⵜ, ⵓ ⴰⴷ ⵜ ⵉⵏⵉⵖ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵡⴰⵔⵔⵜⴻⵏ ⵛⴰ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GL5_22","078_5_22","GAL","5","22","22","ⵎⴰⵛⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⴰⵔⵔⵓⵃ ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵢⵔⵉ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷ ⵍⴻⵀⵏⴰ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ ⴷ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵜⵛⵓⵏⵉ ⴷ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴻⵎⵀⵉⵏⵜ ⵓⵍⴰ ⴷ ⵚⵚⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("GL5_23","078_5_23","GAL","5","23","23","ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⴹⵉⴷⴷ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("GL5_24","078_5_24","GAL","5","24","24","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍⵎⴰⵙⵉⵃ ⴰⵇⴰ ⵚⴻⵍⵍⴱⴻⵏ ⴰⵢⵙⵓⵎ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵛⵛⴻⵀⵡⴰⵜ ⴷ ⵏⵏⴻⵛⵡⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("GL5_25","078_5_25","GAL","5","25","25","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⵙ ⴰⵔⵔⵓⵃ ⵓ ⴰⴷ ⵏⵙⴻⵍⵍⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵉ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("GL5_26","078_5_26","GAL","5","26","26","ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵏⵡⴻⵇⵇⴰⵔ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵏⵏⵉⴼⴰⵇ, ⴰⵎ ⵏⴻⵙⵙⴻⵃⵇⴰⵔⴰ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵏⴻⵜⵜⴰⵙⴻⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("GL6_1","078_6_1","GAL","6","1","1","ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵍⴰ ⵃⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵡⴹⴰ-ⴷⴷ ⵅⴰⵙ ⴷⴷⴻⵏⴱ, ⴻⵊⵊ ⵅⴻⵏⵏⵉ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ ⴰⴷ ⵜ ⵙⴻⴳⴳⴷⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵜⴻⵎⵀⵉⵏⵜ. ⵃⴹⴰⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵊⴰⵔⵔⴱⴻⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ.    ");
INSERT INTO rift_vpl VALUES ("GL6_2","078_6_2","GAL","6","2","2","ⴽⵙⵉⵎ ⴷⴷⵇⴻⵍ ⵉⵊⵊⴻⵏ ⵅ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL6_3","078_6_3","GAL","6","3","3","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵜⵜⵖⵉⵍ ⴰⵙ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵛⴰ, ⴰⵎ ⵜ ⵡⴰⵔ ⵉⴵⵉ, ⵉⵅⴻⴷⴷⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GL6_4","078_6_4","GAL","6","4","4","ⵎⴰⵛⴰ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵇⴻⴵⴻⴱ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵙⴻⵎⵖⴰⵔ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⴷⴻⴳ ⵉⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("GL6_5","078_6_5","GAL","6","5","5","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⴽⵙⵉ ⴷⴷⵇⴻⵍ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("GL6_6","078_6_6","GAL","6","6","6","ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵙⵍⵉⵏ ⴰⵡⴰⵍ, ⴰⴷ ⵉⵛⴰⵔⵛ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵉ ⵖⴰⵔⴻⵙ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵜ ⵉⵙⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL6_7","078_6_7","GAL","6","7","7","ⵡⴰⵔ ⵜⵜⵅⴻⴷⴷⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵅⴰⵙ ⵉⵇⴻⵚⵚⴰⵔ. ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵎⴰ ⵉⵣⴰⵔⵄ ⴱⵏⴰⴷⴻⵎ, ⴰⴷ ⵜ ⵉⵎⵊⴰⵔ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("GL6_8","078_6_8","GAL","6","8","8","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ ⴰⴷ ⵉⵎⵊⴰⵔ ⵍⵖⴻⵛⵛ. ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵣⴰⵔⵔⵄⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵣⵉ ⴰⵔⵔⵓⵃ ⴰⴷ ⵉⵎⵊⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("GL6_9","078_6_9","GAL","6","9","9","ⴻⵊⵊ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏᵉⵜⵜⵉⵃⴻⵍ ⵛⴰ ⵓⵎⵉ ⵏᵉⵜⵜⴻⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵏⴻⵎⵊⴰⵔ, ⵓ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵉⵀⵉⵍ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("GL6_10","078_6_10","GAL","6","10","10","ⴻⵊⵊ ⴰⵏⴻⵖ ⵍⴻⵅⵅⵓ, ⴰⵍⴰⵎⵉ ⵖⴰⵔⵏⴻⵖ ⵄⴰⴷ ⵍⴼⵓⵔⵚⴰ, ⴰⴷ ⵏⴻⴳⴳ ⵜⵛⵓⵏⵉ ⵉ ⵎⴰⵔⵔⴰ, ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⵉⵛⵔⵉⵛⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("GL6_11","078_6_11","GAL","6","11","11","ⵅⵣⴰⵔⴻⵎ, ⵎⴰⵔⵔⴰ ⵜⵉⵔⴰ-ⵢⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵓⵔⵉⵖ, ⵓⵔⵉⵖ ⵜⵜ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GL6_12","078_6_12","GAL","6","12","12","ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴻⴳⴳⴻⵏ ⵅⴰⵡⴻⵎ ⴰⵖⵉⵍ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵡⴰⵎⴰⵔⵔⵜⴻⵏ ⵏⵉⵜⵏⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵚⵚⴰⵍⵉⴱ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("GL6_13","078_6_13","GAL","6","13","13","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵏ ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⵛⴰ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵅⵙⴻⵏ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⵉ ⵍⴻⵅⵜⴰⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("GL6_14","078_6_14","GAL","6","14","14","ⵎⴰⵛⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵅⴰⴼⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵖ ⵎⵖⵉⵔ ⴷⵉ ⵚⵚⴰⵍⵉⴱ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵙ ⵡⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵚⴻⵍⵍⴻⴱ ⴷⴷⵓⵏⴻⵛⵜ ⵉ ⵏⴻⵛⵛ ⵓ ⵏⴻⵛⵛ ⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("GL6_15","078_6_15","GAL","6","15","15","ⴰⵅⵜⴰⵏ ⵏⵉⵖ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵊⴷⵉⴷ ⵡⴰⵀ. ");
INSERT INTO rift_vpl VALUES ("GL6_16","078_6_16","GAL","6","16","16","ⵎⴰⵔⵔⴰ ⵡⵉ ⵖⴰ ⵢⵓⵢⵓⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⴱⵔⵉⴷ-ⴰ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵢⵉⵍⵉ ⵍⴻⵀⵏⴰ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵓⵍⴰ ⵅ ⵉⵙⵔⴰⵉⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("GL6_17","078_6_17","GAL","6","17","17","ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵙⴻⴷⴷⵉⵄ ⵃⴻⴷ, ⵎⵉⵏⵣⵉ ⵉⵡⵢⴻⵖ-ⴷⴷ ⵛⵛⴰⵎⴰⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("GL6_18","078_6_18","GAL","6","18","18","ⴰ ⴰⵢⵜⵎⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴽ-ⴷ ⴰⵔⵔⵓⵃ ⵏⵡⴻⵎ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EP1_1","079_1_1","EPH","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴰⴼⴰⵙⵓⵙ, ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ    ");
INSERT INTO rift_vpl VALUES ("EP1_2","079_1_2","EPH","1","2","2","ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP1_3","079_1_3","EPH","1","3","3","ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⴱⴰⵔⴽⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵍⴱⴰⵔⴰⴽⴰⵜ ⵏ ⴰⵔⵔⵓⵃ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP1_4","079_1_4","EPH","1","4","4","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵅⴹⴰⵔ ⴰⵏⴻⵖ ⴷⴰⵢⴻⵙ, ⴷⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵙⴰⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴱⵍⴰ ⵍⵄⵉⴱ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP1_5","079_1_5","EPH","1","5","5","ⴷⵉ ⵜⴰⵢⵔⵉ ⵉⵣⵡⴰⵔ ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⵛⴻⵎ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⵇⴰ ⵉⴳⴳⴰ ⴰⵏⴻⵖ ⴷ ⴰⵔⵔⴰⵡⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵉⵅⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EP1_6","079_1_6","EPH","1","6","6","ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵉ ⵅⴰⵏⴻⵖ ⵉⴼⴰⵔⵔⴻⵖ ⴷⴻⴳ ⵓⵎⵄⵉⵣⵣ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP1_7","079_1_7","EPH","1","7","7","ⴷⴰⵢⴻⵙ ⵖⴰⵔⵏⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⴷ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⴰⴳⵍⴰ ⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("EP1_8","079_1_8","EPH","1","8","8","ⵉ ⴷⴰⵢⵏⴻⵖ ⵉⴵⴰⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EP1_9","079_1_9","EPH","1","9","9","ⴰⵇⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵏⴻⵖ ⵅ ⵙⵙⵉⵔⵔ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⵉ ⵜⵓⵖⴰ ⵉⵣⵄⴻⵎ ⵇⴱⴻⵍ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵉⴽⴻⵎⵎⴻⵍ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EP1_10","079_1_10","EPH","1","10","10","ⵃⵉⵎⴰ, ⵉ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏ ⵓⵄⴻⵎⵎⴰⵔ ⵏ ⵣⵣⵎⴰⵏⴰⵜ, ⴰⴷ ⴷⴷ-ⵉⵅⵍⴻⵇ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵊⴷⵉⴷ ⵣⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵙ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP1_11","079_1_11","EPH","1","11","11","ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵅⴹⴰⵔ ⴷⴰⵢⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵉⵣⵡⴰⵔ ⴰⴷ ⵉⵎⵎⴰⵔⵙ ⵉ ⵏⴻⵛⵛⵉⵏ ⵓ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⴷ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴳⴳ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⴰⵔⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴰⵔⴰⵔ ⵏ ⴰⵔⵔⴰⵢ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EP1_12","079_1_12","EPH","1","12","12","ⵃⵉⵎⴰ ⵏⴻⵛⵛⵉⵏ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵉ ⵖⴰ ⵉⵙⵙⵉⵜⵉⵎⴻⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP1_13","079_1_13","EPH","1","13","13","ⴷⴰⵢⴻⵙ ⴰⵇⴰ ⵜⴻⵙⵍⵉⵎ ⴰⵡⴰⵍ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵏⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵜⵓⵎⵏⴻⵎ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵜⴻⴽⵙⵉⵎ ⴰⵛⴻⵎⵎⵉⵄ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⴰⵄⴷ, ");
INSERT INTO rift_vpl VALUES ("EP1_14","079_1_14","EPH","1","14","14","ⵡⴻⵏⵏⵉ ⴷ ⵍⵄⴰⵔⴱⵓⵏ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵖ ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP1_15","079_1_15","EPH","1","15","15","ⵅⵣⴰⵔ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ, ⵍⴰⵎⵉ ⵙⵍⵉⵖ ⵅ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓ ⵅ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP1_16","079_1_16","EPH","1","16","16","ⵡⴰⵔ ⴱⴻⴷⴷⴻⵖ ⵛⴰ ⴰⴷ ⵇⴰⴷⵉⵖ ⵉ ⴽⴻⵏⵏⵉⵡ ⵏⵉⵖ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⴼⴻⴽⴽⴰⵔⴻⵖ ⴷⵉ ⵜⵥⵉⴵⴰⵜⵉⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("EP1_17","079_1_17","EPH","1","17","17","ⵃⵉⵎⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴱⴰⴱⴰⵙ ⵏ ⵓⵄⵓⴵⵉ, ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⵖⵉⵜ ⴷ ⵓⵙⴰⵔⴳⴻⴱ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⴻⵙⵙⵏⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("EP1_18","079_1_18","EPH","1","18","18","ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵜⵉⴼⴰⵡⵜ ⴷⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵏ ⴰⵙⵉⵜⴻⵎ ⵏ ⵜⵍⴰⵖⵉⵜ ⵏⵏⴻⵙ ⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵖⴰⵔ ⴰⴳⵍⴰ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵍⵡⴰⵔⵜ ⵏⵏⴻⵙ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP1_19","079_1_19","EPH","1","19","19","ⵓ ⵎⴰⵎⵎⴻⵛ ⵉⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ ⵉ ⵢⴻⴵⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷⴰⵢⵏⴻⵖ, ⴷⴻⴳ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵇⴰⵔⵔⵓ ⵏ ⵊⵊⴻⵀⴷ ⵏ ⵚⵚⵓⵍⵟⴰ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("EP1_20","079_1_20","EPH","1","20","20","ⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵓⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴰⴼⵓⵙⵉ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EP1_21","079_1_21","EPH","1","21","21","ⵙⴻⵏⵏⴻⵊ ⵉ ⴽⵓⵍ ⴰⵣⴻⴵⵉⴼ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷ ⵊⵊⴻⵀⴷ ⴷ ⵍⴻⵃⴽⴰⵎⴻⵜ ⴷ ⵎⴰⵔⵔⴰ ⵉⵙⴻⵎ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP1_22","079_1_22","EPH","1","22","22","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴰⵙ-ⴷⴷ ⵎⴰⵔⵔⴰ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴰⵣⴻⴵⵉⴼ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("EP1_23","079_1_23","EPH","1","23","23","ⵜⴻⵏⵏⵉ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⴰⵄⴻⵎⵎⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵄⴻⵎⵎⴰⵔⴻⵏ ⴽⵓⵍⵛⵉ ⴷⵉ ⵎⴰⵔⵔⴰ.    ");
INSERT INTO rift_vpl VALUES ("EP2_1","079_2_1","EPH","2","1","1","ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜⴻⵎⵎⵓⵜⴻⵎ ⵙ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵓ ⵙ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏⵡⴻⵎ ");
INSERT INTO rift_vpl VALUES ("EP2_2","079_2_2","EPH","2","2","2","ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵜⵓⵢⵓⵔⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⴷⴰⵔⵜ ⵏ ⴽⵓⵍ ⴰⵙⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵚⵚⵓⵍⵟⴰ ⵅ ⵡⴰⵣⵣⴰⵢ ⵏ ⵍⴻⵄⵡⵉⵏ, ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⵔⵓⵃ ⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⵉ ⵜⴰⵔⵡⴰ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EP2_3","079_2_3","EPH","2","3","3","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵜⵓⵖⴰ ⵏⵔⵓⵃ ⵇⴱⴻⵍ ⴷⵉ ⵛⵛⵖⵓⵍⴰⵜ ⵏⵏⵉ, ⵓⵎⵉ ⵏⴻⴹⴼⴰⵔ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵖ, ⵏⴻⴳⴳⴰ ⵎⵉⵏ ⵉⵅⵙ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵖ ⴷ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵏⴻⵖ, ⵓ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵡⴻⵖⴹⴰⴱ ⵇⴰⵄ ⴰⵎ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EP2_4","079_2_4","EPH","2","4","4","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵛⵛⵓⵔ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵙ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵣⵉ ⵅⴰⵏⴻⵖ ⵉⵄⵉⵣⵣ. ");
INSERT INTO rift_vpl VALUES ("EP2_5","079_2_5","EPH","2","5","5","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵄⴰⴷ ⴷ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵢⴰⵔⵔ ⴰⵏⴻⵖ-ⴷⴷ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ");
INSERT INTO rift_vpl VALUES ("EP2_6","079_2_6","EPH","2","6","6","ⵓ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⴰⵏⴻⵖ-ⴷⴷ ⴰⴽⵉⴷⴻⵙ ⵓⵛⴰ ⵉⵙⵙⵖⵉⵎⴰ ⴰⵏⴻⵖ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP2_7","079_2_7","EPH","2","7","7","ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴰⴼⴻⵢⵢⴻⴹ ⵏ ⵡⴰⴳⵍⴰ ⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⴷ ⵜⵛⵓⵏⵉ ⵏⵏⴻⵙ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵡⴻⵏⵏⵉ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP2_8","079_2_8","EPH","2","8","8","ⵎⵉⵏⵣⵉ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵏⵊⴻⵎ, ⵙ ⵍ’ⵉⵎⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵣⴰⵢⵡⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("EP2_9","079_2_9","EPH","2","9","9","ⵡⴰⵔ ⵜⴻⴵⵉ ⵙ ⵍⵅⴻⴷⵎⴻⵜ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⵓⴼⴼ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("EP2_10","079_2_10","EPH","2","10","10","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵅⴻⵍⵇⵉ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴳⴳ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵇⴱⴻⵍ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⴰⵢⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EP2_11","079_2_11","EPH","2","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⵄⴻⵇⵍⴻⵎ, ⴰⵇⴰ ⵣⵉⵛ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⴳⵏⵓⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴰⴷⵉⵔⴰ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵜᵉⵜⵜⵡⴰⵙⴻⵎⵎⴰⵎ ‘ⵏⴱⵍⴰ ⴰⵅⵜⴰⵏ’ ⵣⴻⴳ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵙ ⵡⴻⵅⵜⴰⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("EP2_12","079_2_12","EPH","2","12","12","ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴱⵍⴰ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵉⵖⵔⵉⴱⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⴰⵇⴰ ⵜⵉⴳⴳⵯⵊⴻⵎ ⴰⵎ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵅ ⵍⵄⴰⵀⴷ ⵏ ⵍⵡⴰⵄⴷ. ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴱⵍⴰ ⴰⵙⵉⵜⴻⵎ ⵓ ⴱⵍⴰ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("EP2_13","079_2_13","EPH","2","13","13","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ, ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⵜⵓⴷⵙⴻⵎ-ⴷⴷ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP2_14","079_2_14","EPH","2","14","14","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⵍⴻⵀⵏⴰ ⵏⵏⴻⵖ ⴰⵎ ⴷ ⵢⴰⵔⵔⴰ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵢⵉⵊⵊ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵀⴷⴻⵎ ⴰⵖⴱⴰⵔ ⵏ ⵍⴻⵇⵡⴰⵔ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵏ ⵉⴱⴹⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EP2_15","079_2_15","EPH","2","15","15","ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵉⴱⴹⴻⵍ ⵏⴻⵜⵜⴰ ⵍⴻⵄⴷⴰⵡⴻⵜ ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⵡⴻⵚⵚⴰ ⴰⴽ-ⴷ ⵜⵡⴻⵚⵚⴰ ⵉ-ⴷⴷ-ⵉⴹⴼⴰⵔⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⵅⵍⴻⵇ ⴷⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏ ⵊⴷⵉⴷ ⴰⵎ ⵉⵜⵜⴻⴳⴳ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EP2_16","079_2_16","EPH","2","16","16","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵜⵏⴰⵢⴻⵏ ⵏⵏⵉ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓ ⵉⵏⵖⴰ ⵍⴻⵄⴷⴰⵡⴻⵜ ⵙ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP2_17","079_2_17","EPH","2","17","17","ⵢⵓⵙⴰ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⴻⵀⵏⴰ ⵏⵏⵉ, ⵉ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴳⵯⴻⵊⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵢⵓⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP2_18","079_2_18","EPH","2","18","18","ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⴻⵙ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴰⴷⴻⴼ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵏⴻⵖ ⵙ ⵢⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EP2_19","079_2_19","EPH","2","19","19","ⵙ ⵓⵢⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⵎⴻⵄⵣⴰⴱ, ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EP2_20","079_2_20","EPH","2","20","20","ⵜᵉⵜⵜⵡⴰⴱⵏⴰⵎ ⵅ ⴷⵙⴰⵙ ⵏ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵥⵔⵓ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ.    ");
INSERT INTO rift_vpl VALUES ("EP2_21","079_2_21","EPH","2","21","21","ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴱⵏⴰ ⵍⴻⴱⵏⵉ ⵎⴰⵔⵔⴰ, ⴰⴷ ⵉⵢⵎⴰ ⵓⵛⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⵉⵛⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("EP2_22","079_2_22","EPH","2","22","22","ⴰⵎ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⴱⵏⴰⵎ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("EP3_1","079_3_1","EPH","3","1","1","ⵅ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵛⵛ, ⴱⵓⵍⵓⵙ, ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵍⴻⴳⵏⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("EP3_2","079_3_2","EPH","3","2","2","ⵎⴰⵍⴰ ⵣⴻⵄⵎⴰ ⴰⵇⴰ ⵜⴻⵙⵍⴰⵎ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("EP3_3","079_3_3","EPH","3","3","3","ⴱⴻⵍⵍⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⴰⵢⵉ-ⴷⴷ ⵙⵙⵉⵔⵔ, ⴰⵎ ⵉⵣⵣⴰⵔⴻⵖ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵙ ⴷⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("EP3_4","079_3_4","EPH","3","4","4","ⵅⵎⵉ ⵖⴰ ⵜⵖⴰⵔⴻⵎ ⵎⴰⵏ ⴰⵢⴰ, ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴼⴻⵀⵎⴻⵎ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵉⵏⵓ ⵏ ⵙⵙⵉⵔⵔ ⵏ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP3_5","079_3_5","EPH","3","5","5","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵛⴰ ⴷⵉ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵍⴻⵊⵢⵓⵍ ⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰ ⵅⴰⵙ ⵍⴻⵅⵅⵓ ⵙ ⴰⵔⵔⵓⵃ ⵉ ⵔⵔⵓⵙⵓⵍ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ ⵓ ⵉ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EP3_6","079_3_6","EPH","3","6","6","ⴰⵃⴻⵇⵇⴰ ⵉⵏⵏⵉ ⵣⵉ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵉⵛⵔⵉⵛⴻⵏ ⵏ ⵍⵡⴰⵄⴷ ⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵍ’ⵉⵏⵊⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("EP3_7","079_3_7","EPH","3","7","7","ⵉ ⵣⵉ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉ ⴷⴰⵢⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP3_8","079_3_8","EPH","3","8","8","ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵢⵉ ⴰⵔⴹⴰ-ⵢⴰ, ⵉ ⵏⴻⵛⵛ ⴷ ⴰⵎⵓⵇⵍⵉⵍ ⵇⴰⵄ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵉⵡⴰ ⴰⴳⵍⴰ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⴼⵀⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("EP3_9","079_3_9","EPH","3","9","9","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵓⴼⴼⵖⴻⵖ ⵖⴰⵔ ⵜⴼⴰⵡⵜ ⵉ ⵎⴰⵔⵔⴰ, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵓⵡⴻⴽⴽⴻⵍ ⵏ ⵙⵙⵉⵔⵔ ⵉ ⵜⵓⵖⴰ ⵉⵏⵓⴼⴼⴰⵔⴻⵏ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵣⵉⵛ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴽⵓⵍⵛⵉ, ");
INSERT INTO rift_vpl VALUES ("EP3_10","079_3_10","EPH","3","10","10","ⵃⵉⵎⴰ ⵜⵉⵖⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜⵉⵍⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⵙ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵖⴰⵔ ⵍⴻⵃⴽⴰⵎⴰⵜ ⴷ ⵚⵚⵓⵍⴰⵟⴰⵜ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("EP3_11","079_3_11","EPH","3","11","11","ⵜⵉⵖⵉⵜ ⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⵏⴻⵜⵜⴰ ⵣⵉ ⵣⵣⵎⴰⵏ ⵓⵛⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵉ-ⵜⵜ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP3_12","079_3_12","EPH","3","12","12","ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵜⴰⵔⵢⴰⵙⵜ ⴷ ⵡⴰⴷⴰⴼ ⴰⴽ-ⴷ ⵜⵜⵉⵇⴻⵜ ⵙ ⵍ’ⵉⵎⴰⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP3_13","079_3_13","EPH","3","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵉⵃⵍⴻⵎ ⵛⴰ ⵙ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ. ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵓⵄⵓⴵⵉ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("EP3_14","079_3_14","EPH","3","14","14","ⴰⴷ ⴰⴷⴰⵔⴻⵖ ⵙ ⵉⴼⴰⴷⴷⴻⵏ ⵉⵏⵓ ⵣⵣⴰⵜ ⵉ ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP3_15","079_3_15","EPH","3","15","15","ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵙⴻⵎⵎⴰⵏ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⵜⴱⴰⴱⴰⵜ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("EP3_16","079_3_16","EPH","3","16","16","ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵄⵍⴰⵃⵙⴰⴱ ⴰⴳⵍⴰ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵎ ⵙ ⵊⵊⴻⵀⴷ ⵙ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⴷⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵡⴻⵎ ⵏ ⴷⴰⵅⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("EP3_17","079_3_17","EPH","3","17","17","ⵃⵉⵎⴰ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵙ ⵍ’ⵉⵎⴰⵏ, ⵙ ⵜⴰⵢⵔⵉ, ⵅ ⵎⵉⵏⵏⵉ ⵜⴻⵛⵛⴰⵜⴻⵎ ⵉⵥⴻⵡⵔⴰⵏ ⵓ ⴷⵙⴰⵙ ⵏⵡⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP3_18","079_3_18","EPH","3","18","18","ⵃⵉⵎⴰ ⴰⴷ ⵜⵣⴻⵎⵎⴰⵔⴻⵎ ⴰⴷ ⵜⴼⴻⵀⵎⴻⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⵉⵔⵓ ⴷ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⴷ ⵍⵓⵄⵍⴰ ⴷ ⵍⴰⴵⴰⵖ, ");
INSERT INTO rift_vpl VALUES ("EP3_19","079_3_19","EPH","3","19","19","ⵓ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵄⴰⵡⴻⴷ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⴰⵢⵔⵉ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⵄⴻⵎⵎⴰⵔⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⴰⵄⴻⵎⵎⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EP3_20","079_3_20","EPH","3","20","20","ⵎⴰⵛⴰ ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵖⴰⵔⴻⵙ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⵉⵏ ⵏⴻⵜⵜᵉⵜⵜⴰⵔ ⵏⵉⵖ ⵏⴻⵜⵜⵅⴰⵔⵔⴻⵚ, ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⴰⵢⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("EP3_21","079_3_21","EPH","3","21","21","ⵉ ⵏⴻⵜⵜⴰ ⵉⴽⴽⴰⵔ ⴰⵙ-ⴷⴷ ⵓⵄⵓⴵⵉ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏⵏⴻⵙ, ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵊⵢⵓⵍ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_1","079_4_1","EPH","4","1","1","ⴰⵎ ⵓⵎⴻⵃⴱⵓⵙ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵣⵉⵢⵢⴰⵔⴻⵖ ⵅⴰⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⵓⵙⴰ ⴰⴽ-ⴷ ⵜⵍⴰⵖⵉⵜ ⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("EP4_2","079_4_2","EPH","4","2","2","ⵙ ⵎⴰⵔⵔⴰ ⴰⵡⴰⴹⴻⵄ ⵏ ⴱⵓⵃⴱⴻⵍ, ⵙ ⵜⴻⵎⵀⵉⵏⵜ ⵓ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵜⵇⴻⴱⴱⵍⴻⵎ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵜⴰⵢⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("EP4_3","079_4_3","EPH","4","3","3","ⴰⴷ ⵜⴻⵛⴹⴰⵔⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⵎⵓⵏⴻⵎ ⴷ ⵉⵊⵊ ⴷⵉ ⴰⵔⵔⵓⵃ ⵙ ⵜⵙⴻⵖⵡⵉⵏ ⵏ ⵍⴻⵀⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("EP4_4","079_4_4","EPH","4","4","4","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵓ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ ⴷⴻⴳ ⵓⵙⵉⵜⴻⵎ ⵏ ⵜⵍⴰⵖⵉⵜ ⵏⵡⴻⵎ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_5","079_4_5","EPH","4","5","5","ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⵉⵊⵊⴻⵏ, ⴷ ⵍ’ⵉⵎⴰⵏ ⴷ ⵉⵊⵊⴻⵏ ⵓⵍⴰ ⴷ ⴰⵙⴻⵖⴹⴻⵚ ⴷ ⵉⵊⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP4_6","079_4_6","EPH","4","6","6","ⵓ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊⴻⵏ, ⴱⴰⴱⴰⵜⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵓ ⴷⴰⵢⵏⴻⵖ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EP4_7","079_4_7","EPH","4","7","7","ⵎⴰⵛⴰ ⴰⵔⴹⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ ⵉⴷⵏⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵎⵉⵊⴰⵍ ⵏ ⵎⵉⵏ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP4_8","079_4_8","EPH","4","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ: “ⵉⴳⴻⵄⵄⴻⴷ ⵖⴰⵔ ⵍⵓⵄⵍⴰ, ⵢⵉⵡⵢⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵎⴻⵃⴱⴰⵙ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵉⵡⵛⴰ ⵜⵉⵔⵣⵉⴼⵉⵏ ⵉ ⵉⵡⴷⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("EP4_9","079_4_9","EPH","4","9","9","ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵄⵏⴰ ⵄⴰⵡⴻⴷ ⵡⴰⵡⴰⵍ-ⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴻⵄⵄⴻⴷ ⵙⴻⵏⵏⴻⵊ, ⵎⵖⵉⵔ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔ ⵟⵟⵔⵓⴼⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵡⴰⴷⴷⴰⵢ ⵇⴰⵄ?! ");
INSERT INTO rift_vpl VALUES ("EP4_10","079_4_10","EPH","4","10","10","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵀⵡⴰⵏ, ⵏⴻⵜⵜⴰ ⵄⴰⵡⴻⴷ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴳⴻⵄⵄⴷⴻⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴻⵏⵡⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵡⴻⴹ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EP4_11","079_4_11","EPH","4","11","11","ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⵛⴰ ⴷ ⵔⵔⵓⵙⵓⵍ, ⵛⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵛⴰ ⴷ ⵉⵎⴱⴻⵛⵛⴰⵔⴻⵏ, ⵛⴰ ⴷ ⵉⵎⴻⴽⵙⴰⵡⴻⵏ ⵓ ⵛⴰ ⴷ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP4_12","079_4_12","EPH","4","12","12","ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵉ ⵍⴻⴱⵏⵉ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP4_13","079_4_13","EPH","4","13","13","ⴰⵍ ⵉ ⵖⴰ ⵏⴰⵡⴻⴹ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵓⵎⵓⵏⵉ ⴷ ⵉⵊⵊⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵓ ⴷⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⴽⵎⴻⵍ ⵙ ⵍⴻⵄⴱⴰⵔ ⵏ ⵚⵚⵉⴼⴻⵜ ⵜⵎⵓⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP4_14","079_4_14","EPH","4","14","14","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵉⵍⵉ ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⴰⵏ ⵣⵉ ⵟⵟⴰⵔⴼ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵉⴳⴳⵯⵊⴻⵏ ⵣⵉ ⴽⵓⵍ ⴰⵙⴻⵎⵎⵉⴹ ⵏ ⵓⵙⴻⵍⵎⴻⴷ ⴷ ⴰⵃⵔⴰⵢⵎⵉ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴰⴷ ⴰⵏⴻⵖ ⵖⴰⵔⵔⴻⵏ ⵙ ⵜⴻⵃⵔⴰⵢⵎⴻⵛⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP4_15","079_4_15","EPH","4","15","15","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴱⴻⴷⴷ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⵏⴻⵖ ⵉⴵⴰⵏ ⴰⴷ ⵉⴳⵎⴰ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⴷ ⴰⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("EP4_16","079_4_16","EPH","4","16","16","ⵣⵣⴰⵢⴻⵙ ⵜⴻⵏⵏⴻⵊⵔⵓ ⵓ ⵜᵉⵜⵜⵡⴰⵙⵙⵎⵓⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵎⴰⵔⵔⴰ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵎⴼⴰⵚⴻⵍ, ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵙ ⵍⴻⵄⴱⴰⵔ ⵉ ⵎⴽⵓⵍ ⴰⵖⴻⵣⴷⵉⵙ ⵉ ⵜⵢⵓⵎⵉ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵍⴻⴱⵏⵉ ⵏⵏⴻⵙ ⴷⵉ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("EP4_17","079_4_17","EPH","4","17","17","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ ⵓ ⵛⴻⵀⵀⴷⴻⵖ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵙⵉⴷⵉ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴻⴳⴳⵓⵔⴻⵎ ⵄⴰⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵢⵓⵔⴻⵏ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴱⴰⵟⴻⵍ ⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP4_18","079_4_18","EPH","4","18","18","ⴱⴰⵔⵛⵏⴻⵏ ⴷⵉ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ ⵓ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵜⵓⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⴱⵓ ⵜⵓⵙⵙⵏⴰ, ⵓ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵇⵓⴱⴱⴰⵏⴻⵛⵜ ⵉ ⴷⴰⵢⵙⴻⵏ ⵉⴵⴰⵏ, ⵓ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵇⵙⴰⵃⴻⵜ ⵏ ⵡⵓⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_19","079_4_19","EPH","4","19","19","ⵏⵉⵜⵏⵉ ⵇⴻⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⴻⴳ ⵓⵙⵉⵜⴻⵎ, ⵙⴻⵍⵍⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⴼⵓⵛⵛⴻⵃ ⵓ ⵉ ⵡⴻⴹⴼⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵎⴰⵔⴽⴰⵜ ⵏ ⵍⴻⵅⵎⴻⵊ ⵄⵍⴰⵃⵚⴰⴱ ⵎⴻⵥⵔⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_20","079_4_20","EPH","4","20","20","ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⵎⵓ ⵉ ⵜⴻⵙⵙⵏⴻⵎ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("EP4_21","079_4_21","EPH","4","21","21","ⵍⴰⵎⵉ ⵣⴻⵄⵎⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜⴻⵙⵍⴰⵎ ⵖⴰⵔⴻⵙ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⵜⵍⴻⵎⴷⴻⵎ ⵣⵣⴰⵢⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⴷⴻⵜⵜ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("EP4_22","079_4_22","EPH","4","22","22","ⵎⴰⵛⴰ ⵙ ⵍⵄⴻⴽⵙ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵏⴹⴰⵔⴻⵎ ⵜⵉⵛⵍⵉ ⵏⵡⴻⵎ ⵏ ⵣⵉⵛ, ⴰⴷ ⵜⴻⵊⵊⴻⵎ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴷⵉⵎ ⵉ ⵉⵜⵜⵡⴰⵙⵙⴻⵅⵙⴰⵔⴻⵏ ⵙ ⵏⵏⴻⵛⵡⴰⵜ ⵉⵖⴻⵛⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_23","079_4_23","EPH","4","23","23","ⵜⵜⵡⴰⵄⴻⴷⵍⴻⵎ ⵣⵉ ⵊⴷⵉⴷ ⵙ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⵍⴻⵄⵇⴻⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EP4_24","079_4_24","EPH","4","24","24","ⴰⵔⴹⴻⵎ ⴱⵏⴰⴷⴻⵎ ⵏ ⵊⴷⵉⴷ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵓ ⴷⵉ ⵜⴰⵇⴻⴷⴷⴰⵙⵜ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EP4_25","079_4_25","EPH","4","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ ⵊⵊⴻⵎ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵙⵉⵡⵍⴻⵎ ⵜⵉⴷⴻⵜⵜ ⴽⵓⵍ ⵉⵊⵊ ⴰⴽ-ⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵅⴼⴰⵡⴻⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("EP4_26","079_4_26","EPH","4","26","26","ⵅⴻⵢⵢⵇⴻⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵛⴰ ⴷⴷⵏⵓⴱ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⵜⴻⵖⵔⵉ ⵜⴼⵓⵛⵜ ⵅ ⵉⵊⵊ ⵏ ⵓⴷⵓⵇⵇⴻⵣ ⵏ ⵓⵅⴻⵢⵢⴻⵇ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EP4_27","079_4_27","EPH","4","27","27","ⵡⴰⵔ ⵜⵜⵉⵛⴻⵎ ⵛⴰ ⴰⵎⵛⴰⵏ ⵉ ⵉⴱⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EP4_28","079_4_28","EPH","4","28","28","ⵡⴰⵔ ⵜⴻⵊⵊⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴰⵛⴰⵔⴻⵏ ⴰⴷ ⵢⴰⵛⴰⵔ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵃⵙⴻⵏ ⴰⴷ ⵢⴰⵔⴱⴻⵔ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉⵛⵜ ⴷ ⵍⵃⴰⵊⵊⴻⵜ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⵉⵡⵛ ⵉ ⵢⵉⵏⵏⵉ ⵉⵃⴷⴰⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_29","079_4_29","EPH","4","29","29","ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴽⴽ ⵛⴰ ⵡⴰⵡⴰⵍ ⵏ ⵡⴻⵛⵔⴰⵀ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵓ ⵎⵉⵏ ⵉⵏⴻⴼⴼⵄⴻⵏ ⵉ ⵍⴻⴱⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵉⵡⴹⴻⵎ ⴰⵔⴹⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EP4_30","079_4_30","EPH","4","30","30","ⵡⴰⵔ ⵜⵜⴻⵙⵙⴼⴼⵓⴳⵎⴻⵎ ⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵛⴻⵎⵎⵄⴻⵎ ⴰⵍ ⴰⵙⵙ ⵏ ⵓⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EP4_31","079_4_31","EPH","4","31","31","ⵊⵊⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵜᵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵣⵓⴳⵉ ⴷ ⵜⴻⴼⵇⴻⵃⵜ ⴷ ⵡⴻⵖⴹⴰⴱ ⴷ ⵓⵚⴻⴷⴷⴻⵄ ⴷ ⵓⵛⴻⵇⵇⴻⴼ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("EP4_32","079_4_32","EPH","4","32","32","ⵉⵍⵉⵎ ⵜⴹⴰⵔⴼⴻⵎ ⵓ ⴳⴳⴻⵎ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⴷⴻⴳ ⵡⴰⵢⴰⵡⴰ. ⵙⴰⵎⵃⴻⵎ ⵉ ⵡⴰⵢⴰⵡⵢⴰ ⴰⵎ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⴰⵇⴰ ⵉⵖⴼⴰⵔ ⴰⵏⴻⵖ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP5_1","079_5_1","EPH","5","1","1","ⵙ ⵓⵢⴰ ⵉⵍⵉⵎ ⴷ ⵉⵎⴻⴹⴼⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP5_2","079_5_2","EPH","5","2","2","ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵜⴰⵢⵔⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵏⴻⵖ, ⵉⵡⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅⴰⵏⴻⵖ ⴷ ⵜⴰⵡⵀⵉⴱⵜ ⴷ ⵜⵖⴰⵔⵚⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EP5_3","079_5_3","EPH","5","3","3","ⵎⴰⵛⴰ ⵅ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵅⵎⴻⵊ ⴷ ⵟⵟⵎⴻⵄ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⵡⴰⵡⴰⵍ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵓⵡⵡⴰⵔ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP5_4","079_5_4","EPH","5","4","4","ⵓⵍⴰ ⵅ ⵍⵀⴰⵔⴷ ⵉⵙⵙⴱⴻⵀⴷⵍⴻⵏ ⵏⵉⵖ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ ⵏⵉⵖ ⵅ ⵜⵇⴻⵚⵚⴰⵔⵜ ⵏⵉⵖ ⵅ ⵍⴻⴼⴹⵉⵃⴻⵜ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵡⴰⵔ ⵏⴻⴼⴼⵄⴻⵏⵜ ⴷⵉ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵇⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EP5_5","079_5_5","EPH","5","5","5","ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵍⴻⵅⵎⴻⵊ ⵏⵉⵖ ⵟⵟⵎⴻⵄ, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵄⴻⴱⴱⴻⴷ ⵍ’ⴰⵚⵏⴰⵎ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⴻⵙⵖⴰⵔⵜ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⵓ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EP5_6","079_5_6","EPH","5","6","6","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵖⴻⴽⴽⵡⵉ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ, ⴰⵇⴰ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷⴷ-ⵉⵀⴻⴽⴽⵡⴰ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⴰⵔⵡⴰ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EP5_7","079_5_7","EPH","5","7","7","ⵡⴰⵔ ⵛⴰⵔⵔⵛⴻⵎ ⵛⴰ ⴰⴽⵉⴷⵙⴻⵏ! ");
INSERT INTO rift_vpl VALUES ("EP5_8","079_5_8","EPH","5","8","8","ⵎⵉⵏⵣⵉ ⵣⵉⵛ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⴵⴻⵙⵜ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵍⴻⵅⵅⵓ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⴼⴰⵡⵜ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵓⵢⵓⵔⴻⵎ ⴰⵎ ⵜⴰⵔⵡⴰ ⵏ ⵜⴼⴰⵡⵜ, ");
INSERT INTO rift_vpl VALUES ("EP5_9","079_5_9","EPH","5","9","9","ⵎⵉⵏⵣⵉ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴼⴰⵡⵜ ⵜᵉⵜⵜⵉⵍⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵛⵓⵏⵉ ⴷ ⵜⵙⴻⴳⴷⴰ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("EP5_10","079_5_10","EPH","5","10","10","ⴼⴰⵔⵣⴻⵎ ⵎⵉⵏ ⵖⴰ ⵢⴰⵔⴹⴰⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EP5_11","079_5_11","EPH","5","11","11","ⵡⴰⵔ ⵛⴰⵔⵔⵛⴻⵎ ⵛⴰ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⴱⴰⵔⵛⴰⵏⵉⵏ ⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵡⵢⴻⵏ ⵍⵖⵉⴵⴻⵜ, ⵎⴰⵛⴰ ⵡⴻⴱⴱⵅⴻⵎ ⵜⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EP5_12","079_5_12","EPH","5","12","12","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ ⴷⵉ ⵜⵏⵓⴼⴼⵔⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⵄⵉ ⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⵓⵍⴰ ⴰⴷ ⵜ ⵜⵄⴰⵡⴷⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("EP5_13","079_5_13","EPH","5","13","13","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⵜⴼⴰⵡⵜ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵙ ⵜⴼⴰⵡⵜ ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⵙⴰⵔⴳⴰⴱⴻⵏ ⴷ ⵜⵉⴼⴰⵡⵜ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("EP5_14","079_5_14","EPH","5","14","14","ⵙ ⵓⵢⴻⵏⵏⵉ ⵇⵇⴰⵔⴻⵏ: “ⴼⴰⵇ ⵛⴻⴽ, ⴰ ⴱⵓ ⵢⵉⴹⴻⵚ. ⴽⴽⴰⵔ-ⴷⴷ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵅⴰⴽ ⵉⴳⴳ ⵍⵎⴰⵙⵉⵃ ⵜⴰⴼⴰⵡⵜ.” ");
INSERT INTO rift_vpl VALUES ("EP5_15","079_5_15","EPH","5","15","15","ⵃⴹⴰⵎ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵙ ⵓⵡⴻⵇⵇⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⴰⵎ ⵉⵎⵉⵖⵉⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP5_16","079_5_16","EPH","5","16","16","ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵔⵉⵇⵇⵉ ⵉ ⵍⵡⴻⵇⵜ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵙⵙⴰⵏ-ⴰ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP5_17","079_5_17","EPH","5","17","17","ⵅ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵎ ⴷ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ, ⵎⴰⵛⴰ ⴼⴻⵀⵎⴻⵎ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EP5_18","079_5_18","EPH","5","18","18","ⵡⴰⵔ ⵙⴻⵛⵛⴰⵔⴰⵎ ⵛⴰ ⵙ ⴱⵉⵏⵓ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵍⴻⵇⵊⴰⵃⴻⵜ, ⵎⴰⵛⴰ ⵉⵍⵉⵎ ⵜⵄⴻⵎⵎⴰⵔⴻⵎ ⵙ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("EP5_19","079_5_19","EPH","5","19","19","ⵙⵉⵡⵍⴻⵎ ⴷⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵙ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ ⴷ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⴷ ⵉⵣⵍⴰⵏ ⵏ ⴰⵔⵔⵓⵃ, ⵖⴻⵏⵏⵊⴻⵎ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵉ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("EP5_20","079_5_20","EPH","5","20","20","ⵇⴰⴷⴰⵎ ⵍⴻⴱⴷⴰ ⴰⵔⴻⴱⴱⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵅ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP5_21","079_5_21","EPH","5","21","21","ⵡⴰⴹⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵡⴰⵢⴰⵡⵢⴰ ⴷⵉ ⵜⴰⵢⵔⵉ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP5_22","079_5_22","EPH","5","22","22","ⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵡⴰⴹⴹⵄⴻⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⴽⴻⵏⵜ ⴰⵎ ⵜᵉⵜⵜⵡⴰⴹⴹⵄⴻⵏⵜ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("EP5_23","079_5_23","EPH","5","23","23","ⵎⵉⵏⵣⵉ ⴰⵔⵢⴰⵣ ⴰⵇⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵎⵖⴰⵔⵜ ⴰⵎ ⵓⵍⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("EP5_24","079_5_24","EPH","5","24","24","ⴰⵎ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵜᵉⵜⵜⵡⴰⴹⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵡⴰⴹⴹⵄⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ ⴷⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("EP5_25","079_5_25","EPH","5","25","25","ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵅⵙⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵅⵙ ⵍⵎⴰⵙⵉⵃ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵓⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("EP5_26","079_5_26","EPH","5","26","26","ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⵢⴰⵔⵔ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵓ ⴰⴷ ⴰⵙ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵙ ⵓⵙⵉⵔⴷ ⵏ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵙ ⵡⴰⵡⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("EP5_27","079_5_27","EPH","5","27","27","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵓⵄⵓⴵⵉ, ⴱⵍⴰ ⴰⴱⴻⵇⵇⵉⴹ ⵏⵉⵖ ⴰⵛⴻⴱⵔⵉⵇ, ⴱⵍⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⴷ ⵜⴰⵎⵇⴻⴷⴷⴰⵙⵜ ⵓ ⴱⵍⴰ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("EP5_28","079_5_28","EPH","5","28","28","ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵅⵙⴻⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵙⴻⵏ ⴰⵎ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ. ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵜⵜⴻⵅⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP5_29","079_5_29","EPH","5","29","29","ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵛⴰⵔⵀ ⵄⴻⵎⵎⴰⵔⵚ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵙⵙⴻⵛⵛⴰ ⵉ-ⵜ, ⵉⵜⵜⵃⴰⵡⴰⵍ ⵅⴰⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵃⴰⵡⴰⵍ ⵄⴰⵡⴻⴷ ⵍⵎⴰⵙⵉⵃ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("EP5_30","079_5_30","EPH","5","30","30","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵅⴼⴰⵡⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ ⵓ ⵏ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP5_31","079_5_31","EPH","5","31","31","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⵢⴰⵣ ⴰⴷ ⵢⴻⵊⵊ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⵇⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵍⵉⵏ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("EP5_32","079_5_32","EPH","5","32","32","ⵙⵙⵉⵔⵔ-ⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ ⵜ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⴷ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("EP5_33","079_5_33","EPH","5","33","33","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⵡⴻⴷ ⵉ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵅⵙ ⴰⵎⴻⵏⵏⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⵡⴻⵇⵇⴰⵔ ⴰⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("EP6_1","079_6_1","EPH","6","1","1","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵟⴰⵄⴻⵎ ⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵏⵉⵛⴰⵏ ⵉ ⵢⴻⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("EP6_2","079_6_2","EPH","6","2","2","ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ: ‘ⵡⴻⵇⵇⴰⵔ ⴱⴰⴱⴰⵛ ⴷ ⵢⴻⵎⵎⴰⵛ, ");
INSERT INTO rift_vpl VALUES ("EP6_3","079_6_3","EPH","6","3","3","ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ ⵓ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⴷ ⴰⵟⵟⴰⵙ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("EP6_4","079_6_4","EPH","6","4","4","ⴰ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵡⴰⵔ ⵙⵄⴰⵔⴻⵎ ⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⴰⵎ ⵜⴻⵏ ⵙ ⵓⵙⴻⵜⵜⴻⴼ ⵓ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EP6_5","079_6_5","EPH","6","5","5","ⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵟⴰⵄⴻⵎ ⴰⵢⵜⴱⴰⴱ ⵏⵡⴻⵎ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵔⵊⵉⵊⵉⵜ, ⵓ ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⴰⵅⵎⵉ ⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP6_6","079_6_6","EPH","6","6","6","ⵡⴰⵔ ⵉⴵⵉ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⴰⵅⵎⵉ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴰⵔⴹⴰⵎ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⴰⵎ ⵢⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵢⴰⵔⴻⵟⵟⴰⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EP6_7","079_6_7","EPH","6","7","7","ⵅⴻⴷⵎⴻⵎ ⴰⵙⴻⵏ ⵙ ⵎⴰⵔⵔⴰ ⵓⵍ ⵏⵡⴻⵎ ⴷⵉ ⵜⴰⵢⵔⵉ, ⴰⵎ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EP6_8","079_6_8","EPH","6","8","8","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ, ⵉⵙⵎⴻⵖ ⵏⵉⵖ ⴷ ⴰⵃⵓⵔⵔⵉ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴳⴳⵉⵏ ⵛⴰ ⴷ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ, ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⴰⵔⵔ. ");
INSERT INTO rift_vpl VALUES ("EP6_9","079_6_9","EPH","6","9","9","ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⴱⴰⴱ, ⴳⴳⴻⵎ ⴰⵎⴻⵏⵏⵉ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵡⴻⵎ. ⵙⴰⵎⵃⴻⵎ ⴰⵙⴻⵏ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⵏⴻⵎ, ⴰⵇⴰ ⵙⵉⴷⵉⵜⵡⴻⵎ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵢⴻⴵⴰ, ⵓ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("EP6_10","079_6_10","EPH","6","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵓ, ⵎⴻⵃⴹⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏ ⵜⵣⴻⵎⵎⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("EP6_11","079_6_11","EPH","6","11","11","ⴰⵔⴹⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵙⵏⴰⵃ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴱⴻⴷⴷⴻⵎ ⵉⴱⵔⵉⴷⴻⵏ ⵏ ⵜⵃⵔⴰⵢⵎⴻⵛⵜ ⵏ ⵉⴱⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("EP6_12","079_6_12","EPH","6","12","12","ⴰⵇⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵎⴻⵏⵖⵉ ⵛⴰ ⴰⴽ-ⴷ ⵡⴻⵢⵙⵓⵎ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵎⴰⵛⴰ ⴰⴽ-ⴷ ⵍⴻⵃⴽⴰⵎⴰⵜ, ⴰⴽ-ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⴷ ⵚⵚⵓⵍⴰⵟⴰⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ ⵓ ⴰⴽ-ⴷ ⵍⴰⵔⵢⴰⵃ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EP6_13","079_6_13","EPH","6","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⴹⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵙⵏⴰⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵎⵎⵄⴰⵍⴰⵎ ⴰⴽ-ⴷ ⵓⵎⵄⴻⴼⴼⴰⵏ. ⵅⵎⵉ ⵖⴰ ⵜⵉⵍⵉⵎ ⵜⵡⴻⵊⴷⴻⵎ ⴽⵓⵍⵛⵉ, ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⴱⴻⴷⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("EP6_14","079_6_14","EPH","6","14","14","ⵙ ⵓⵢⴻⵏⵏⵉ ⴱⴻⴷⴷⴻⵎ, ⵜⴱⴻⵢⵙⴻⵎ ⵙ ⵜⵉⴷⴻⵜⵜ ⵓ ⵙⴷⵓⵔⵢⴻⵎ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵙ ⵜⵙⴻⴳⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("EP6_15","079_6_15","EPH","6","15","15","ⴰⴷ ⵉⵍⵉⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵜⵜⵡⴰⵇⵇⵏⴻⵏ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("EP6_16","079_6_16","EPH","6","16","16","ⴰⴽ-ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴽⵙⵉⵎ ⵜⴰⵙⴻⴷⴷⴰⵔⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵡⴻⵎ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵅⴻⵙⵢⴻⵎ ⵎⴰⵔⵔⴰ ⴼⵍⵉⵜⵛⴰⵜ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵏ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("EP6_17","079_6_17","EPH","6","17","17","ⴳⴳⴻⵎ ⵍⴽⴰⵙⴽ ⵏ ⵓⵙⴻⵏⵊⴻⵎ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵡⴻⵎ ⵓⵛⴰ ⵟⵟⴼⴻⵎ ⵙⵙⵉⴼ ⵏ ⴰⵔⵔⵓⵃ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("EP6_18","079_6_18","EPH","6","18","18","ⵥⵥⴰⴵⴰⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵥⴰⴵⴰ ⴷ ⵜⵓⵜⵔⴰ ⵏⵡⴻⵎ ⵍⴻⴱⴷⴰ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵓ ⵃⴹⴰⵎ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⴷⵉ ⵜⵥⴰⴵⵉⵜ, ⴰⵎ ⵜᵉⵜⵜⵥⴰⴵⴰⵎ ⵓ ⵜⴽⴻⵙⵙⵉⵎ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⵍⴻⴱⴷⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("EP6_19","079_6_19","EPH","6","19","19","ⵓⵍⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛ ⴰⵡⴰⵍ ⵅⵎⵉ ⵖⴰ ⴰⵔⵣⵎⴻⵖ ⴰⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵙⵙⵉⵔⵔ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵙ ⵜⴻⵔⵢⴰⵙⵜ, ");
INSERT INTO rift_vpl VALUES ("EP6_20","079_6_20","EPH","6","20","20","ⵉ ⵣⵉ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⴽⴽⵉ ⵙ ⵙⵙⵏⴰⵙⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⵙⵉⵡⵍⴻⵖ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("EP6_21","079_6_21","EPH","6","21","21","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵓⵎⴻⴷⴷⵓⵔ ⵉⵏⵓ ⵓ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵖ, ⵅⵣⴰⵔ, ⵜⵉⵛⵉⴽⵓⵙ, ⵉⵊⵊ ⵏ ⵓⵎⴰⵜⵏⴻⵖ ⵉⵄⵉⵣⵣⴻⵏ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵜⵉⵇⵇⵉ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴱⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("EP6_22","079_6_22","EPH","6","22","22","ⴰⵇⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵎⴻⴷⴷⵓⵔ ⵉⵏⵓ, ⵓⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵢⴻⴳⴳ ⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("EP6_23","079_6_23","EPH","6","23","23","ⵍⴻⵀⵏⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽ-ⴷ ⵜⴰⵡⵎⴰⵜ ⵏⵏⴻⵖ ⵓⵍⴰ ⴷ ⵜⴰⵢⵔⵉ ⴰⴽ-ⴷ ⵍ’ⵉⵎⴰⵏ, ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("EP6_24","079_6_24","EPH","6","24","24","ⴰⴷ ⵢⵉⵍⵉ ⴰⵔⴹⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴱⵍⴰ ⵍⵖⴻⵛⵛ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PP1_1","080_1_1","PHP","1","1","1","ⴱⵓⵍⵓⵙ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴼⵉⵍⵉⴱⴱⵉ, ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ: ");
INSERT INTO rift_vpl VALUES ("PP1_2","080_1_2","PHP","1","2","2","ⴰⵔⴹⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ, ⵓⵍⴰ ⴷ ⵍⴻⵀⵏⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP1_3","080_1_3","PHP","1","3","3","ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵍⴰⵎⵉ ⴷⴰⵢⵡⴻⵎ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵖ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PP1_4","080_1_4","PHP","1","4","4","ⵎⴰⵖⴰⵔ ⴷⵉ ⴽⵓⵍ ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⵉⵏⵓ ⵅⴰⵡⴻⵎ, ⴰⵇⴰ ⴽⵙⵉⵖ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ");
INSERT INTO rift_vpl VALUES ("PP1_5","080_1_5","PHP","1","5","5","ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⵓⵏⵜ ⵏⵡⴻⵎ ⴰⴽ-ⴷ ⵍ’ⵉⵏⵊⵉⵍ, ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴰⵍ ⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PP1_6","080_1_6","PHP","1","6","6","ⴰⵇⴰ ⵜⵜⵉⵇⵇⴻⵖ ⴱⴻⵍⵍⵉ ⵡⴻⵏⵏⵉ ⴷⴰⵢⵡⴻⵎ ⵉⴱⴷⴰⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⴷ ⵜⴻⵏⵜ ⵉⴽⴻⵎⵎⴻⵍ ⴰⵍ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP1_7","080_1_7","PHP","1","7","7","ⵉⵛⵏⴰ ⴰⵢⵉ ⴰⴷ ⴼⴻⴽⴽⴰⵔⴻⵖ ⴷⴰⵢⵡⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵎⵎⵓ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⵉ ⴷⴻⴳ ⵡⵓⵍ ⵉⵏⵓ, ⵅⵎⵉ ⴵⵉⵖ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵓⵍⴰ ⵅⵎⵉ ⵖⴰ ⴰⵡⵜⴻⵖ ⵅ ⵜⵉⴷⴻⵜⵜ ⵏ ⵍ’ⵉⵏⵊⵉⵍ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵛⴰⵔⵛⴻⵎ ⴰⴽⵉⴷⵉ ⴷⵉ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("PP1_8","080_1_8","PHP","1","8","8","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵉⵏⵓ ⵎⴻⵛⵃⴰⵍ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴻⵅⵙⴻⵖ ⵙ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⵢⵓⴵⵖⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP1_9","080_1_9","PHP","1","9","9","ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜⵜⵥⴰⴵⵉⵖ, ⴰⵇⴰ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⴰⴷ ⵜⴼⴻⵢⵢⴻⴹ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⴷⵉ ⵜⵓⵙⵙⵏⴰ ⴷ ⵇⴰⵄ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵜⴰⵔⵓⵃⴰⵏⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("PP1_10","080_1_10","PHP","1","10","10","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴼⴰⵔⵣⴻⵎ ⵎⵉⵏ ⵉⵜⵜⵍⵉⵇⴻⵏ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴻⵇⵇⵓⵔⴻⵎ ⵓ ⴱⵍⴰ ⵍⵄⵉⴱ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PP1_11","080_1_11","PHP","1","11","11","ⵜⴻⵛⵛⵓⵔⴻⵎ ⵙ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⵓⵄⵓⴵⵉ ⴷ ⵓⵙⴻⵎⵖⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PP1_12","080_1_12","PHP","1","12","12","ⴰ ⴰⵢⵜⵎⴰ, ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵔⵏⵉⵏⵜ ⵄⴰⴷ ⴷⵉ ⵜⵓⵣⵣⴻⴳⴳⴰⵔⵜ ⵏ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍ’ⵉⵏⵊⵉⵍ, ");
INSERT INTO rift_vpl VALUES ("PP1_13","080_1_13","PHP","1","13","13","ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵉⵏⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⵇⴰⵄ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴻⵇⵚⴰⵔ ⵏ ⵇⴰⵢⵚⴰⵔ ⵓ ⵉ ⵇⴰⵄ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PP1_14","080_1_14","PHP","1","14","14","ⴰⵣⵢⴻⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓⵎⵉ ⴵⵉⵖ ⴷⵉ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⵉⴷⵡⴻⵍ ⵖⴰⵔⵙⴻⵏ ⵜⵜⵉⵇⵇⴻⵜ ⴽⵜⴰⵔ ⵓⵛⴰ ⴷⴻⵡⵍⴻⵏ ⵣⴻⵄⵄⵎⴻⵏ ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⴽⵜⴰⵔ, ⴱⵍⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PP1_15","080_1_15","PHP","1","15","15","ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵍⵎⴰⵙⵉⵃ ⵣⵉ ⵍⴻⵃⵙⴻⴷ ⴷ ⵓⵎⵄⴰⵏⴻⴷ, ⵎⴰⵛⴰ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵄⴰⵡⴻⴷ ⵣⵉ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴻⵛⵏⴰ ⵓ ⵙ ⵜⴰⵢⵔⵉ, ");
INSERT INTO rift_vpl VALUES ("PP1_16","080_1_16","PHP","1","16","16","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵏⴻⵏ ⴰⵇⴰ ⵜⵜⵡⴰⴳⴳⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵜⴻⵖ ⵅ ⵍ’ⵉⵏⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PP1_17","080_1_17","PHP","1","17","17","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵙ ⵍⵎⴰⵙⵉⵃ ⵙ ⵓⵎⵄⴰⵏⴻⴷ, ⵡⴰⵔ ⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴻⵛⵏⴰ, ⵎⴰⵛⴰ ⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵅⴰⴼⵉ ⴰⵔⵏⵉⵏ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PP1_18","080_1_18","PHP","1","18","18","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴼⴰⵔⵔⵀⴻⵖ, ⵡⴰⵀ, ⴰⴷ ⴼⴰⵔⵃⴻⵖ: ⴰⵇⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵍⵎⴰⵙⵉⵃ ⵙ ⵉⴱⵔⵉⴷⴻⵏ ⵉⴼⴰⵔⵣⴻⵏ, ⵎⴰ ⵙ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔⴰⴹ ⵏⵏⴻⵖⵏⵉ, ⵏⵉⵖ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("PP1_19","080_1_19","PHP","1","19","19","ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉ ⵏⴻⵛⵛ ⵙ ⵜⵥⴰⴵⵉⵜ ⵏⵡⴻⵎ ⵓ ⵙ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PP1_20","080_1_20","PHP","1","20","20","ⵎⴰⵃⴻⵏⴷ ⵏⴻⵛⵛ, ⴰⵎ ⵙⵉⵜⵉⵎⴻⵖ ⵓ ⵜⵜⵔⴰⵊⵉⵖ, ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵛⴰ ⵅ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⴰⵎ ⵍⴻⴱⴷⴰ, ⵓⵍⴰ ⴷ ⵍⴻⵅⵅⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⵎⵖⴰⵔ ⵍⵎⴰⵙⵉⵃ ⵙ ⴱⵟⴰⵢⵟⴰⵢ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ, ⵎⴰ ⵙ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⵏⵉⵖ ⵙ ⵍⵎⴻⵡⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PP1_21","080_1_21","PHP","1","21","21","ⵎⵉⵏⵣⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵏⵓ ⴷ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⵍⵎⴻⵡⵜ ⴷ ⴰⵔⴱⴻⵃ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PP1_22","080_1_22","PHP","1","22","22","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⵓⴷⴰⵔⵜ-ⴰ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵏⵓ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⵅⴹⴰⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PP1_23","080_1_23","PHP","1","23","23","ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⴰⵢⵉ ⵊⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ: ⴷⴰⵢⵉ ⵎⴻⵥⵔⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵔⴰⵃⴻⵖ ⴰⴷ ⵉⵍⵉⵖ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵇⴰⵄ ⵃⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PP1_24","080_1_24","PHP","1","24","24","ⵎⴰⵛⴰ ⴰⵖⵉⵎⵉ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⴷ ⴽⵜⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP1_25","080_1_25","PHP","1","25","25","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵙⵙⵏⴻⵖ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵖ, ⵡⴰⵀ, ⴰⴷ ⵇⵇⵉⵎⴻⵖ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⵎⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("PP1_26","080_1_26","PHP","1","26","26","ⵃⵉⵎⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ ⵖⴰⵔⵡⴻⵎ ⵄⴰⵡⴻⴷ, ⴰⵇⴰ ⴰⵙⴻⵎⵖⴰⵔ ⵏⵡⴻⵎ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵀⴰ ⴰⴷ ⵉⴼⴻⵢⵢⴻⴹ, ⵓⵎⵉ ⵏⴻⵛⵛ ⵇⵇⵉⵎⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PP1_27","080_1_27","PHP","1","27","27","ⵓⵢⵓⵔⴻⵎ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ ⵓⵍⴰ ⵅⵎⵉ ⵖⴰ ⵖⴰⴱⴻⵖ, ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵙⵍⴻⵖ, ⴰⵇⴰ ⵜⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⵓ ⵙ ⵉⵊⵊ ⵏ ⵍⴻⵄⵎⴰⵔ, ⵓⵛⴰ ⵜᵉⵜⵜⵖⴻⵍⵍⴱⴻⵎ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷⵉ ⵍ’ⵉⵏⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PP1_28","080_1_28","PHP","1","28","28","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵎ ⵛⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵣⴻⴳ ⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ. ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵄⴻⴵⴻⵎ ⵉ ⵏⵉⵜⵏⵉ ⵖⴰⵔ ⵓⵀⴻⵍⵍⴻⴽ, ⵎⴰⵛⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔ ⵓⵙⴻⵏⵊⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP1_29","080_1_29","PHP","1","29","29","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵡⴻⵎ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⴵⵉ ⴰⴷ ⵜⴰⵎⵏⴻⵎ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵎⴰⵔⵔⵜⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PP1_30","080_1_30","PHP","1","30","30","ⵓ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⴰⵎⴻⵏⵖⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵢⵉ ⵜ ⵜⴻⵥⵔⵉⵎ ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵅⴰⴼⵉ ⵜⴻⵙⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("PP2_1","080_2_1","PHP","2","1","1","ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⵖⴰⵔⵡⴻⵎ ⵛⴰ ⵏ ⵓⴼⴻⵡⵡⴻⵊ ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵡⴰⵍⴻⵏ ⵙ ⵜⴰⵢⵔⵉ ⵉ ⵡⵓⵍ, ⵏⵉⵖ ⵜⴰⵎⵓⵏⵜ ⵏ ⴰⵔⵔⵓⵃ, ⵏⵉⵖ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⴷⵉ ⴷⴰⵅⴻⵍ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("PP2_2","080_2_2","PHP","2","2","2","ⴽⴻⵎⵎⵍⴻⵎ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ ⵓⵎⵉ ⵖⴰ ⵉⵎⵓⵏ ⴰⵔⵔⴰⵢ ⵏⵡⴻⵎ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵜⴰⵢⵔⵉ ⴷ ⵉⵛⵜⴻⵏ, ⴷ ⵍⴻⵄⵎⴰⵔ ⴷ ⵉⵊⵊⴻⵏ ⵓⵍⴰ ⴷ ⵓⵅⴰⵔⵔⴰⵚ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PP2_3","080_2_3","PHP","2","3","3","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵙ ⵓⵎⵄⴰⵏⴻⴷ ⵏⵉⵖ ⵣⵉ ⵜⵓⴼⴼⴻⵜ ⵉⵅⵡⴰⵏ, ⵎⴰⵛⴰ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵡⴻⵇⵇⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴽⵜⴰⵔ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵙ ⵓⵡⴰⴹⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("PP2_4","080_2_4","PHP","2","4","4","ⵡⴰⵔ ⵉⵅⴻⵣⵣⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵖⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵅⵣⴰⵔ ⵄⴰⵡⴻⴷ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PP2_5","080_2_5","PHP","2","5","5","ⴻⵊⵊ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵜⵉⵍⵉ ⵏⵏⴻⵢⵢⴻⵜ ⵉ ⵜⵓⵖⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PP2_6","080_2_6","PHP","2","6","6","ⵡⴻⵏⵏⵉ, ⴰⵎ ⵉⴵⴰ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⵃⵙⵉⴱ ⵛⴰ ⴷ ⵜⴰⴽⴻⵛⵛⴰⴹⵜ ⵓⵎⵉ ⵉⵎⵇⵓⴷⴷⴰ ⴰⴽ-ⴷ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("PP2_7","080_2_7","PHP","2","7","7","ⵎⴰⵛⴰ ⵉⵙⵙⴻⵅⵡⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⴽⵙⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ. ⵏⴻⵜⵜⴰ ⵉⴷⵡⴻⵍ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⴼ ⴷⵉ ⴼⵓⵔⵎⴰ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP2_8","080_2_8","PHP","2","8","8","ⵏⴻⵜⵜⴰ ⵉⵙⵙⵡⴰⴹⴻⵄ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵟⵟⴰⵄ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵡⴰⵀ, ⴰⵍ ⵍⵎⴻⵡⵜ ⵏ ⵚⵚⴰⵍⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("PP2_9","080_2_9","PHP","2","9","9","ⵙ ⵓⵢⴰ ⵉⵙⵙⵓⵄⵍⴰ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⵇⴰⵄ ⵙⴻⵏⵏⴻⵊ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⵉⵙⴻⵎ ⵙⴻⵏⵏⴻⵊ ⵉ ⴽⵓⵍ ⵉⵙⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("PP2_10","080_2_10","PHP","2","10","10","ⵃⵉⵎⴰ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵢⴰⵙⵓⵄ ⴰⴷ ⴰⴹⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("PP2_11","080_2_11","PHP","2","11","11","ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⵀⴻⴷ ⴽⵓⵍ ⵉⵍⴻⵙ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵙⵉⴷⵉ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PP2_12","080_2_12","PHP","2","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜᵉⵟⵟⴰⵄⴻⵎ ⵍⴻⴱⴷⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵅⵎⵉ ⴰⴽⵉⴷⵡⴻⵎ ⴵⵉⵖ ⵡⴰⵀⴰ, ⵍⴻⵅⵅⵓ ⵄⴰⴷ ⴽⵜⴰⵔ ⵅⵎⵉ ⵅⴰⵡⴻⵎ ⵉ ⵖⴰ ⴰⴳⴳⵯⵊⴻⵖ, ⵅⴻⴷⵎⴻⵎ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴰⵔⵊⵉⵊⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("PP2_13","080_2_13","PHP","2","13","13","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵡⴻⵏⵏⵉ ⴷⴰⵢⵡⴻⵎ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴰⵍ ⵖⴰ ⵜⴻⵅⵙⴻⵎ ⵓ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⴷⵉ ⵜᵉⵎⵎⴻⵥⵍⴻⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("PP2_14","080_2_14","PHP","2","14","14","ⴳⴳⴻⵎ ⵎⴰⵔⵔⴰ ⴱⵍⴰ ⵍⴻⵄⴽⴰⵙⴻⵜ ⵓ ⴱⵍⴰ ⴰⵎⵛⵓⴱⴱⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("PP2_15","080_2_15","PHP","2","15","15","ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴱⵍⴰ ⵍⵄⵉⴱ, ⴰⵎ ⵜⴰⵔⵡⴰ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵊⵊⵉⵍ ⵉⵄⴻⵡⵡⵊⴻⵏ ⴷ ⵉⴼⴰⵔⵖⴻⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴰⵏⴻⵎ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⵎ ⵜⴼⴰⵡⵉⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("PP2_16","080_2_16","PHP","2","16","16","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⵢⵉⵍⵉ ⵓⵙⴻⵎⵖⴰⵔ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵓⵢⵓⵔⴻⵖ ⴱⴰⵟⴻⵍ ⵏⵉⵖ ⵅⴻⴷⵎⴻⵖ ⵙ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("PP2_17","080_2_17","PHP","2","17","17","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⵜᵉⵜⵜⵡⴰⵔⵓⵛⵛⴻⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵅ ⵜⵖⴰⵔⵚⵜ ⵓ ⵅ ⵜⵙⴻⵅⵅⴰⵔⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⴰⴷ ⴼⴰⵔⵃⴻⵖ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⴰⴷ ⴰⵔⴻⵛⵇⴻⵖ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("PP2_18","080_2_18","PHP","2","18","18","ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⴼⴰⵔⵃⴻⵎ ⵓⵛⴰ ⴼⴰⵔⵃⴻⵎ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PP2_19","080_2_19","PHP","2","19","19","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⵜⵉⵎⵓⵜⵉⵢⵓ ⴷⴻⵖⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⵅ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ ⵅⵎⵉ ⵖⴰ ⵙⵙⵏⴻⵖ ⴰⵎⴻⴷⴷⵓⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP2_20","080_2_20","PHP","2","20","20","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵉ ⴷⴰⵏⵉⵜⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⵉⴽⴻⵙⵙⵉⵏ ⵙ ⵡⴻⵎⵏⵓⵙ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⴼⴼⴻⵖ ⵓⵎⴻⴷⴷⵓⵔ ⵏⵡⴻⵎ ⵙ ⵛⴹⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("PP2_21","080_2_21","PHP","2","21","21","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵢⴰⵔⴻⵣⵣⵓⵏ ⴷⵉ ⵎⵉⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP2_22","080_2_22","PHP","2","22","22","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵜⴰⵇⴻⴵⴻⴱⵜ ⵏⵏⴻⵙ, ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵅⴻⴷⴷⴻⵎ ⴰⴽⵉⴷⵉ ⴷⵉ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵖⴰⵔ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PP2_23","080_2_23","PHP","2","23","23","ⵏⴻⵛⵛ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ-ⵙⵙⴻⴽⴽⴻⵖ ⴷⴻⵖⵢⴰ, ⵅⵎⵉ ⵖⴰ ⵥⴰⵔⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⴼⴼⴻⵖ ⵓⵎⴻⴷⴷⵓⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PP2_24","080_2_24","PHP","2","24","24","ⵎⴰⵛⴰ ⵜⵜⵉⵇⵇⴻⵖ ⴷⵉ ⵙⵉⴷⵉ ⵉⵏⵓ, ⴱⴻⵍⵍⵉ ⵄⴰⵡⴻⴷ ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("PP2_25","080_2_25","PHP","2","25","25","ⵎⴰⵛⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴷ-ⴰⵡⴻⵎ ⵙⵙⴻⴽⴽⴻⵖ ⵓⵎⴰ ⵉⴱⴰⴼⵔⵓⴷⵉⵜⵓⵙ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⴽⵉⴷⵉ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵄⴰⵡⴻⴷ ⴷ ⵔⵔⴰⵙⵓⵍ ⵏⵡⴻⵎ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏⵡⴻⵎ ⴷⵉ ⵎⵉⵏ ⵃⴷⴰⵊⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PP2_26","080_2_26","PHP","2","26","26","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵡⴻⵃⵃⴻⵛ ⴰⵟⵟⴰⵙ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵥⴰⵔ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⴽⵙⵉ ⵙ ⵡⴻⵎⵏⵓⵙ ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵍⵉⵎ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PP2_27","080_2_27","PHP","2","27","27","ⵙ ⵜⵉⴷⴻⵜⵜ, ⵜⵓⵖⴰ ⵉⵀⵍⴻⵛ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵃⴻⵎ ⵉ-ⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ, ⴰⵃⴻⵇⵇⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵉ ⵉⵜⵜⵉⵍⵉ ⵓⴼⴻⵇⵇⵓⵚ ⵅ ⵓⴼⴻⵇⵇⵓⵚ. ");
INSERT INTO rift_vpl VALUES ("PP2_28","080_2_28","PHP","2","28","28","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴻⴽⴽⴻⵖ ⵜ ⵙ ⵜⴰⵣⵍⴰ ⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⵜ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ, ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵉ ⵢⵉⵍⵉ ⴷⵔⵓⵙ ⵏ ⵡⴻⵎⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PP2_29","080_2_29","PHP","2","29","29","ⵙ ⵓⵢⴻⵏⵏⵉ ⵇⴻⴱⵍⴻⵎ ⵜ ⴷⵉ ⵙⵉⴷⵉ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵡⴻⵇⵇⴰⵔⴻⵎ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎ ⵡⴰⵏⵉⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("PP2_30","080_2_30","PHP","2","30","30","ⵎⵉⵏⵣⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵜⵓⵖⴰ ⵉⵇⴰⵔⵔⴻⴱ ⵖⴰⵔ ⵍⵎⴻⵡⵜ ⴰⵎ ⵉⵙⴻⴱⴱⴻⵍ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵏⴻⵇⵚⴻⵏ ⴷⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵡⴻⵎ ⵉ ⵏⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("PP3_1","080_3_1","PHP","3","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴼⴰⵔⵃⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ⵡⴰⵔ ⵅⴰⴼⵉ ⵢⴻⵡⵄⴰⵔ ⴰⴷ ⴰⵡⴻⵎ ⴰⵔⵉⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵜᵉⵜⵜⵡⴰⵃⴹⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("PP3_2","080_3_2","PHP","3","2","2","ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵢⵉⵟⴰⵏ, ⵃⴹⴰⵎ ⵣⴻⴳ ⵉⵅⴻⴷⴷⴰⵎⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵃⴹⴰⵎ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵇⴻⵟⵟⵄⴻⵏ ⴰⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("PP3_3","080_3_3","PHP","3","3","3","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⴷ ⴰⵅⵜⴰⵏ, ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⴰⵔⵔⵓⵃ, ⵉⵏⵏⵉ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵡⴰⵔ ⵜⵜⵉⵇⵇⴻⵏ ⵛⴰ ⴷⴻⴳ ⵡⴻⵅⵜⴰⵏ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP3_4","080_3_4","PHP","3","4","4","ⵏⴻⵛⵛ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵜⵜⵉⵇⵇⴻⵖ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵉⵏⵓ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵜⵜⵖⵉⵍ ⵉ ⵃⴻⴷ ⴰⴷ ⵉⵜⵜⵉⵇⵇ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ, ⵏⴻⵛⵛ ⴽⵜⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("PP3_5","080_3_5","PHP","3","5","5","ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⵎⴻⵅⵜⴰⵏ ⵣⴻⴳ ⵡⴰⵎⵉ ⵖⴰⵔⵉ ⵜⵎⴻⵏⵢⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵣⵉ ⵍⴳⴻⵏⵙ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵣⴻⴳ ⴰⵢⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ, ⵏⴻⵛⵛ ⴷ ⴰⵄⵉⴱⵔⴰⵏⵉ ⵣⴻⴳ ⵉⵄⵉⴱⵔⴰⵏⵉⵢⵢⴻⵏ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏⴻⵛⵛ ⴷ ⴰⴼⴰⵔⵉⵙⵉ, ");
INSERT INTO rift_vpl VALUES ("PP3_6","080_3_6","PHP","3","6","6","ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵛⴹⴰⵔⴻⵜ ⵜⵓⵖⴰ ⴷⴰⵔⵔⵛⴻⵖ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵣⴻⴳ ⵓⵖⴻⵣⴷⵉⵙ ⵏ ⵜⵙⴻⴳⴷⴰ ⵜⴻⵏⵏⵉ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵇⴰ ⴰⵢⵉ ⴱⵍⴰ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("PP3_7","080_3_7","PHP","3","7","7","ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⵉ ⴰⵔⴱⴻⵃ, ⴰⵇⴰ ⴳⴳⵉⵖ ⵜ ⴷ ⵜⴰⵅⴻⵙⵙⴰⵔⵜ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP3_8","080_3_8","PHP","3","8","8","ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⴰⵅⴻⵙⵙⴰⵔⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ ⵅⵙⴰⵔⴻⵖ ⴽⵓⵍⵛⵉ, ⴳⴳⵉⵖ ⵜ ⴰⵎⴻⵛⵏⴰⵡ ⵡⴻⴼⵔⴰⴹ ⵢⵓⵔⵚⵓⴹⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⴻⴱⵃⴻⵖ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PP3_9","080_3_9","PHP","3","9","9","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴰⴼⴻⵖ ⴷⴰⵢⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏ ⵉⵅⴻⴼ ⵉⵏⵓ ⵜⴻⵏⵏⵉ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ - ⵎⴰⵛⴰ ⴰⴽ-ⴷ ⵜⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵜⴻⵏⵏⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ - ");
INSERT INTO rift_vpl VALUES ("PP3_10","080_3_10","PHP","3","10","10","ⵃⵉⵎⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵙⵙⵏⴻⵖ ⵢⴰⵙⵓⵄ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⵜⵏⵓⴽⵔⴰ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴰⵔⵛⴻⵖ ⴷⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵏⴻⵙ, ⴰⴷ ⴷⴻⵡⵍⴻⵖ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("PP3_11","080_3_11","PHP","3","11","11","ⵃⵉⵎⴰ ⵙ ⵛⴰ ⵏ ⵡⴻⴱⵔⵉⴷ ⴰⴷ ⴰⵡⴹⴻⵖ ⵖⴰⵔ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PP3_12","080_3_12","PHP","3","12","12","ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⵉⵡⵉⴹⴻⵖ ⵏⵉⵖ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵖ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵢⴻⵎⵎⴰⵔⴻⵖ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ, ⵎⴰⵍⴰ ⵉⵄⴻⴷⴷⴻⵍ, ⴰⴷ ⵟⵟⴼⴻⵖ ⵎⵉⵏ ⵅⴻⴼ ⵉ ⴷ ⴰⵢⵉ ⵉⵟⵟⴻⴼ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP3_13","080_3_13","PHP","3","13","13","ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⵟⵟⴼⴻⵖ ⵜ, ⵎⴰⵛⴰ ⵜⵜⴻⴳⴳⴻⵖ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ: ⵜⵜⵓⵖ ⵎⵉⵏ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵓⵛⴰ ⴰⴷ ⵙⵙⵡⵉⵥⵥⴹⴻⵖ ⵉⵅⴻⴼ ⵉⵏⵓ ⵖⴰⵔ ⵎⵉⵏ ⴷⵉⵏ ⵣⵣⴰⵜⵉ. ");
INSERT INTO rift_vpl VALUES ("PP3_14","080_3_14","PHP","3","14","14","ⵜⵜⵉⵣⵣⴰⵔⴻⵖ ⵖⴰⵔ ⵍⵖⴰⵔⴰⴹ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵖ ⵜⵜⴰⵊ ⵏ ⵓⵖⴻⵍⵍⴻⴱ ⵏ ⵜⵍⴰⵖⵉⵜ ⵢⵓⵄⵍⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP3_15","080_3_15","PHP","3","15","15","ⴻⵊⵊ ⵉⵏⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ, ⴰⴷ ⵔⴻⴽⴽⵣⴻⵏ ⵅⴻⵏⵏⵉ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ⵓⵛⴰ ⵎⴰⵍⴰ ⵖⴰⵔⵡⴻⵎ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵛⴰ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵛⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("PP3_16","080_3_16","PHP","3","16","16","ⵎⴰⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⵡⴻⴹ ⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⴷ ⵉⵊⵊⴻⵏ ⵙ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵏⵏⴻⵖ ⴷ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PP3_17","080_3_17","PHP","3","17","17","ⴹⴼⴰⵔⴻⵎ ⴰⵢⵉ-ⴷⴷ, ⴰ ⴰⵢⵜⵎⴰ, ⴽⵙⵉⵎ ⵜⵉⵡⴻⵚⵚⴰⴼ ⵉ ⵉⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵎⴻⴷⵢⴰ ⵉ ⵣⵣⴰⵢⵏⴻⵖ ⵜⴻⵥⵔⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("PP3_18","080_3_18","PHP","3","18","18","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵉⵏⵏⵉ ⵢⵓⵢⵓⵔⴻⵏ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⵏⵏⵉⵖ ⴰⵡⴻⵎ ⵜⵜ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⵓⵔⴻⵏ - ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⴰⴷ ⵜⵜ ⵉⵏⵉⵖ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ - ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⵏ ⵚⵚⴰⵍⵉⴱ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP3_19","080_3_19","PHP","3","19","19","ⴰⵏⴻⴳⴳⴰⵔⵓ ⵏⵙⴻⵏ ⴷ ⴰⵀⴻⵍⵍⴻⴽ, ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ ⴷ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵄⵓⴵⵉ ⵏⵙⴻⵏ ⴷ ⴰⴱⴻⵀⴷⴻⵍ ⵏⵙⴻⵏ, ⵓ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵙⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("PP3_20","080_3_20","PHP","3","20","20","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏᵉⵜⵜⵙⴻⵅⵅⴰⵔ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⵔⴰⵊⴰ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PP3_21","080_3_21","PHP","3","21","21","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴱⴻⴷⴷⵍⴻⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ ⵉⵃⴻⴱⴹⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵉⵄⵓⴵⴻⵏ, ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵣⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PP4_1","080_4_1","PHP","4","1","1","ⵙ ⵓⵢⴰ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ ⴷ ⵉⵖⵍⴰⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵏⵓ ⴷ ⵜⵜⴰⵊ ⵉⵏⵓ, ⴱⴻⴷⴷⴻⵎ ⵅⴻⵏⵏⵉ ⴰⵎⵎⵓ ⵏⵉⵛⴰⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("PP4_2","080_4_2","PHP","4","2","2","ⵏⴻⵛⵛ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵣⴻⴳ ⵓⵡⵓⴷⵉⵢⴰ ⴷ ⵙⵉⵏⵜⵉⵛⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵓⵏ ⴰⵔⵔⴰⵢ ⵏⵙⴻⵏⵜ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("PP4_3","080_4_3","PHP","4","3","3","ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵄⴰⵡⴻⴷ ⵣⵣⴰⵢⴻⴽ, ⴰ ⴰⵎⵄⴰⵛⴰⵔ ⴰⵎⵜⵉⵇⵇⵉ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⴰⴼⵓⵙ ⵉ ⵜⵉⵏⵏⵉ ⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴰⴽⵉⴷⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍ’ⵉⵏⵊⵉⵍ, ⵓⵍⴰ ⴰⴽ-ⴷ ⴽⵍⵉⵎⵉⵏⵙ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ ⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⵉ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("PP4_4","080_4_4","PHP","4","4","4","ⴼⴰⵔⵃⴻⵎ ⵍⴻⴱⴷⴰ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵏⴻⵛⵛ ⵇⵇⴰⵔⴻⵖ ⵄⴰⵡⴻⴷ: ⴼⴰⵔⵃⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("PP4_5","080_4_5","PHP","4","5","5","ⴰⴷ ⵢⵉⵍⵉ ⵓⵡⴰⴹⴻⵄ ⵏⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ. ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⵇⴰ ⵢⵓⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PP4_6","080_4_6","PHP","4","6","6","ⵡⴰⵔ ⴽⴻⵙⵙⵉⵎ ⵛⴰ ⵙ ⵡⴻⵎⵏⵓⵙ ⵅ ⵡⴰⵍⵓ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴰⵔⴻⵎ ⵍⴻⴱⴷⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵥⴰⴵⵉⵜ ⴷ ⵜⴽⴻⵙⵙⵉⵜ ⵏ ⵍⵎⴻⵄⵔⵓⴼ ⴰⴽ-ⴷ ⵓⵇⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("PP4_7","080_4_7","PHP","4","7","7","ⵓⵛⴰ ⵍⴻⵀⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵄⴷⵓⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴰⴷ ⵉⵃⴹⴰ ⵓⵍⴰⵡⴻⵏ ⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP4_8","080_4_8","PHP","4","8","8","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵇⵇⵓⵔⴻⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵣⴷⵉⴳⴻⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵄⵉⵣⵣⴻⵏ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔ ⵉⴵⴰ ⵍⵃⴻⵙⵙ ⴰⵚⴻⴱⵃⴰⵏ, ⵓ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⵛⵛⴰⵏ ⴷ ⵓⵙⴻⵎⵖⴰⵔ, ⵅⴰⵔⵚⴻⵎ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PP4_9","080_4_9","PHP","4","9","9","ⵎⵉⵏ ⵜⴻⵖⵔⵉⵎ ⵓ ⵜⵇⴻⴱⵍⴻⵎ, ⵎⵉⵏ ⵜⴻⵙⵍⵉⵎ ⵓ ⵜⴻⵥⵔⵉⵎ ⵣⵣⴰⵢⵉ, ⴳⴳⴻⵎ ⵜ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ! ");
INSERT INTO rift_vpl VALUES ("PP4_10","080_4_10","PHP","4","10","10","ⴰⵇⴰ ⴼⴰⵔⵃⴻⵖ ⴰⵟⵟⴰⵙ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓⵎⵉ ⴷⴰⵢⵡⴻⵎ ⵉⴵⴰ ⵡⴻⵎⵏⵓⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵢⵉ ⵜᵉⵜⵀⵉⵍⵍⴰⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴰⵢⵡⴻⵎ ⵜ ⵜⵓⵖⴰ ⵇⴱⴻⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵓⴼⵉⵎ ⵎⴰⵎⵎⴻⵛ ⴰⴷ ⵜⴻⴳⴳⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP4_11","080_4_11","PHP","4","11","11","ⵡⴰⵔ ⵜⵜ ⵏⵏⵉⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⵃⵡⴰⵊⴻⵖ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵍⴻⵎⴷⴻⵖ ⴰⴷ ⵇⴻⵏⵄⴻⵖ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⴷⴷ-ⵜⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("PP4_12","080_4_12","PHP","4","12","12","ⵏⴻⵛⵛ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴷⴷⴻⴵ, ⵓⵛⴰ ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⴰⴼⴻⵢⵢⴻⴹ. ⵎⴰⵏⵉ ⵎⴰ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵇⴰ ⵍⴻⵎⴷⴻⵖ, ⴰⵎ ⴷⵉ ⵜⵢⴰⵡⴰⵏⵜ, ⴰⵎ ⴷⵉ ⵍⴰⵥ ⴰⵎ ⴷⴻⴳ ⵓⴼⴻⵢⵢⴻⴹ ⵓⵍⴰ ⴷⵉ ⵍⴻⵖⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PP4_13","080_4_13","PHP","4","13","13","ⵇⴻⴷⴷⴻⵖ ⵇⴰⵄ ⵣⵉ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⵉⵏ ⵊⵊⴻⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("PP4_14","080_4_14","PHP","4","14","14","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵎⵍⵉⵃ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵜⴻⵡⵛⵉⵎ ⴰⴼⵓⵙ ⴷⵉ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("PP4_15","080_4_15","PHP","4","15","15","ⵜⴻⵙⵙⵏⴻⵎ ⵄⴰⵡⴻⴷ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ, ⴰ ⵉⴼⵉⵍⵉⴱⴱⵉⵢⵢⴻⵏ, ⴱⴻⵍⵍⵉ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵓⵎⵉ ⴷⴷ-ⴼⴼⵖⴻⵖ ⵣⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ, ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵡⴰⵔ ⵜⴻⴳⴳⵉ ⴰⴽⵉⴷⵉ ⵍⴻⵃⵙⴰⴱ ⵅ ⵎⵉⵏ ⵡⵛⵉⵏ ⴷ ⵎⵉⵏ ⴽⵙⵉⵏ, ⵎⵖⵉⵔ ⵜⴻⵏⵏⵉ ⵏⵡⴻⵎ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("PP4_16","080_4_16","PHP","4","16","16","ⵎⵉⵏⵣⵉ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ ⵜᵉⵙⵙⴻⴽⴽⴻⵎ ⴰⵢⵉ-ⴷⴷ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ, ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵓ ⵉⵊⵊ ⵏ ⵓⵎⵓⵔ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("PP4_17","080_4_17","PHP","4","17","17","ⵡⴰⵔ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⴷⴰⵢⵉ ⵜⴻⵡⵛⴻⵎ ⵛⴰ, ⵎⴰⵛⴰ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⵜⵡⴻⵙⵙⴻⵄ ⵍⵖⵉⴵⴻⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PP4_18","080_4_18","PHP","4","18","18","ⵏⴻⵛⵛ ⵟⵟⴼⴻⵖ ⴽⵓⵍⵛⵉ ⵓ ⵖⴰⵔⵉ ⴽⵓⵍⵛⵉ ⵙ ⵣⵣⵢⴰⴷⴰ, ⴰⵇⴰ ⵊⵊⵉⵡⵏⴻⵖ. ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷ ⴰⵢⵉ ⴷⴷ-ⵜᵉⵙⵙⴻⴽⴽⴻⵎ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⴱⴰⴼⵔⵓⴷⵉⵜⵓⵙ: ⵉⵛⵜ ⵏ ⵍⴻⴼⵡⴰⵃⴻⵜ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵢⴰⵔⴹⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("PP4_19","080_4_19","PHP","4","19","19","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴰⴷ ⵉⵙⵙⵢⵉⵡⴻⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⴻⵃⴷⴰⵊⴻⵎ ⵄⵍⴰⵃⵙⴰⴱ ⴰⴳⵍⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵉ ⵉⴵⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PP4_20","080_4_20","PHP","4","20","20","ⴰⵇⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PP4_21","080_4_21","PHP","4","21","21","ⵙⴻⴵⵎⴻⵎ ⵅ ⴽⵓⵍ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵙ ⵍⴻⵀⵏⴰ. ⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⴰⴽⵉⴷⵉ, ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("PP4_22","080_4_22","PHP","4","22","22","ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ, ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵇⴰⵢⵚⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PP4_23","080_4_23","PHP","4","23","23","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("CL1_1","081_1_1","COL","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵜⴰⵡⵎⴰⵜ ⵜⵉⵎⵓⵜⵉⵢⵓ. ");
INSERT INTO rift_vpl VALUES ("CL1_2","081_1_2","COL","1","2","2","ⵉ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴽⵓⵍⵓⵙⵙⵉ, ⴰⵡⵎⴰⵜⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ: ⵍⴻⵀⵏⴰ ⴷ ⴰⵔⴹⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("CL1_3","081_1_3","COL","1","3","3","ⵍⴻⴱⴷⴰ ⵏⴻⵜⵜⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓⵛⴰ ⵏⴻⵜⵜⵥⴰⴵⴰ ⵅⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("CL1_4","081_1_4","COL","1","4","4","ⵅⵣⴰⵔ, ⵏⴻⵙⵍⴰ ⵅ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓ ⵅ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("CL1_5","081_1_5","COL","1","5","5","ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵙⵉⵜⴻⵎ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵉ ⵅ ⵜⵉⵣⵣⴰⵔⴻⵎ ⵜⴻⵙⵍⴰⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵜⵉⴷⴻⵜⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("CL1_6","081_1_6","COL","1","6","6","ⴰⵡⴰⵍ-ⴰ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⴰⵡⴻⵎ ⵓ ⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵉⴳⴻⵎⵎⴰ ⵓⵛⴰ ⵉⵜⵜⴰⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵢⴻⴳⴳⴰ ⵡⴰⵡⴰⵍ-ⴰ ⵄⴰⵡⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵣⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵜ ⵜⴻⵙⵍⵉⵎ ⵓ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("CL1_7","081_1_7","COL","1","7","7","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜ ⵜⵍⴻⵎⴷⴻⵎ ⵣⵉ ⵉⴱⴰⴼⵔⴰⵙ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵖ ⵉⵄⵉⵣⵣⴻⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("CL1_8","081_1_8","COL","1","8","8","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵏⴻⵖ-ⴷⴷ ⵅ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⴷⵉ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("CL1_9","081_1_9","COL","1","9","9","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ, ⵣⴻⴳ ⵡⴰⵙⵙ ⵓⵎⵉ ⵏⴻⵙⵍⴰ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵡⴰⵔ ⵏⴻⵙⵙⴱⴻⴷⴷⵉ ⵛⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵅⴰⵡⴻⵎ, ⵏⴻⵜⵜᵉⵜⵜⴰⵔ ⴰⴷ ⵜⴷⴻⵡⵍⴻⵎ ⵜⴻⵛⵛⵓⵔⴻⵎ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ ⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⴰⵔⵔⵓⵃ, ");
INSERT INTO rift_vpl VALUES ("CL1_10","081_1_10","COL","1","10","10","ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⴷⴰⵀⴻⴵ, ⴰⴷ ⵜⴰⵔⴹⴰⵎ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵡⵢⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵢⵎⴰⵎ ⴷⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⴰⵔⴻⴱⴱⵉ,    ");
INSERT INTO rift_vpl VALUES ("CL1_11","081_1_11","COL","1","11","11","ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵊⴻⵀⴷⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ, ⵙ ⵎⴰⵔⵔⴰ ⵚⵚⴱⴰⵔ ⴷ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("CL1_12","081_1_12","COL","1","12","12","ⵇⴰⴷⴰⵎ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴷⴰⵀⴻⴵ ⴰⴷ ⵏⵛⴰⵔⵛ ⴷⵉ ⵍⵡⴰⵔⵜ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷⵉ ⵜⴼⴰⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("CL1_13","081_1_13","COL","1","13","13","ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵏⴻⵖ ⵣⵉ ⵚⵚⵓⵍⵟⴰ ⵏ ⵜⴰⴵⴻⵙⵜ ⵓ ⵉⵙⵙⵎⵓⵟⵟⵉⵢ ⴰⵏⴻⵖ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵎⵎⵉⵙ ⵏⵏⴻⵙ ⵉⵄⵉⵣⵣⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("CL1_14","081_1_14","COL","1","14","14","ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵖⴰⵔⵏⴻⵖ ⴰⵙⴻⵏⵊⴻⵎ ⴷ ⵡⴻⵖⴼⴰⵔ ⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("CL1_15","081_1_15","COL","1","15","15","ⵡⴰⵏⵉⵜⴰ ⴷ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵡⴰⵔ ⵏⴻⵜⵜⵡⵉⵍⵉ ⵛⴰ, ⴰⵎⴻⵏⵣⵓ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("CL1_16","081_1_16","COL","1","16","16","ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⵍⴻⵇ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏ ⵏⴻⵜⵜⵡⴰⵍⴰ ⴷ ⵎⵉⵏ ⵡⴰⵔ ⵏⴻⵜⵜⵡⵉⵍⵉ ⵛⴰ: ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏⵉⵖ ⵜⵉⵚⴻⴵⴰⴹⵉⵏ ⵏⵉⵖ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵓⵍⴰ ⴷ ⵚⵚⵓⵍⴰⵟⴰⵜ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵓ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("CL1_17","081_1_17","COL","1","17","17","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ-ⵜ ⵇⴱⴻⵍ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⵇⴰ-ⵜ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("CL1_18","081_1_18","COL","1","18","18","ⵏⴻⵜⵜⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⴷ ⵎⵎⵉⵙ ⴰⵎⴻⵏⵣⵓ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⴷⵉ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("CL1_19","081_1_19","COL","1","19","19","ⵎⵉⵏⵣⵉ ⵜⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵍⵅⴰⴹⴰⵔ ⵉ ⵎⴰⵔⵔⴰ ⴰⵄⴻⵎⵎⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⴰⵢⴻⵙ,    ");
INSERT INTO rift_vpl VALUES ("CL1_20","081_1_20","COL","1","20","20","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵙⴻⵚⵍⴻⵃ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⴽ-ⴷ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴳⴳ ⵍⴻⵀⵏⴰ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ, ⴰⵎ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("CL1_21","081_1_21","COL","1","21","21","ⵓⵍⴰ ⵉ ⴽⴻⵏⵏⵉⵡ - ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵍⵄⴻⴷⵢⴰⵏ ⴷⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵡⴻⵎ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵡⴻⵎ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ - ⵉⵡⵛⴰ ⵍⴻⵅⵅⵓ ⵍⴻⵀⵏⴰ ");
INSERT INTO rift_vpl VALUES ("CL1_22","081_1_22","COL","1","22","22","ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ ⵓ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴱⴻⴷⴷ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ, ⴱⵍⴰ ⵎⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⴼ ⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⵅⵎⴻⵊ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⵄⵉⴱ, ");
INSERT INTO rift_vpl VALUES ("CL1_23","081_1_23","COL","1","23","23","ⵎⴰⵍⴰ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⴰⵎ ⴷⵙⴰⵙ ⵏⵡⴻⵎ ⵉⵇⵇⵉⵎ ⵉⵎⵜⴻⵏ, ⵡⴰⵔ ⵜⵙⴻⵎⵎⵃⴻⵎ ⵛⴰ ⴷⴻⴳ ⵓⵙⵉⵜⴻⵎ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵉ ⵜⴻⵙⵍⵉⵎ, ⵡⴻⵏⵏⵉ ⵣⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴰⵃ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵓⵊⴻⵏⵏⴰ, ⵡⴻⵏⵏⵉ ⵣⵉ ⴷⴻⵡⵍⴻⵖ ⵏⴻⵛⵛ, ⴱⵓⵍⵓⵙ, ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("CL1_24","081_1_24","COL","1","24","24","ⴰⵇⴰ ⴰⵢⵉ ⴼⴰⵔⵃⴻⵖ ⴰⵎ ⴽⴻⵙⵙⵉⵖ ⵜⴰⵎⴰⵔⴰ ⵅⴰⵡⴻⵎ ⵓ ⵜⵜⴽⴻⵎⵎⵍⴻⵖ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("CL1_25","081_1_25","COL","1","25","25","ⵉ ⵣⵉ ⴷⴻⵡⵍⴻⵖ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴻⴽⴽⴻⵍ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵅⴰⵡⴻⵎ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵉⵡⴹⴻⵖ ⵜⴰⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("CL1_26","081_1_26","COL","1","26","26","ⵙⵙⵉⵔⵔ ⵉ ⵜⵓⵖⴰ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⴷ ⵍⵊⵉⵍⴰⵜ ⵏ ⵣⵉⵛ, ⵎⴰⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵍⴻⵅⵅⵓ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("CL1_27","081_1_27","COL","1","27","27","ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵛⴻⵏ ⵉⴳⴻⵍⵡⴰⵏ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⵙⵙⵉⵔⵔ-ⴰ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵍⵎⴰⵙⵉⵃ ⴷⴰⵢⵡⴻⵎ, ⴰⵙⵉⵜⴻⵎ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("CL1_28","081_1_28","COL","1","28","28","ⴰⵇⴰ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵣⵣⴰⵢⴻⵙ, ⵓ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ ⵏⴻⵙⵙⴻⵍⵎⴰⴷ ⵓ ⵏⵄⴻⴵⴻⵎ ⵉ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴱⴻⴷⴷ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵛⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL1_29","081_1_29","COL","1","29","29","ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵎⵉ ⵊⴻⵀⵀⴷⴻⵖ ⵓ ⵜⵜⵎⴻⵏⵖⵉⵖ ⵙ ⵓⴼⵓⵙ ⵏ ⵊⵊⴻⵀⴷ ⵉ ⴷ ⴰⵢⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL2_1","081_2_1","COL","2","1","1","ⵎⵉⵏⵣⵉ ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴻⵛⵃⴰⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎⴻⵏⵖⵉ ⵉ ⵜⵜⴻⴳⴳⴻⵖ ⵅⴰⵡⴻⵎ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⴷⵉ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵥⵔⵉⵏ ⵛⴰ ⵙ ⴰⵔⵔⵉⵎⴻⵜ ⴷ ⵡⵓⴷⴻⵎ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("CL2_2","081_2_2","COL","2","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⴷⴻⴼ ⵓⴼⴻⵡⵡⴻⵊ ⵖⴰⵔ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴰⵡⴹⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵜⴰⵢⵔⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵡⴰⴳⵍⴰ ⵏ ⵍⴰⵎⴰⵏ, ⵓ ⵖⴰⵔ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵏ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵙⵉⵔⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵏ ⵍⵎⴰⵙⵉⵃ ");
INSERT INTO rift_vpl VALUES ("CL2_3","081_2_3","COL","2","3","3","ⵏⵏⵉ ⴷⵉ ⵏⵏⵓⴼⴼⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴽⵏⵓⵣ ⵏ ⵜⵉⵖⵉⵜ ⴷ ⵜⵓⵙⵙⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("CL2_4","081_2_4","COL","2","4","4","ⵎⴰⵏ ⴰⵢⴰ ⵇⵇⴰⵔⴻⵖ ⵜ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵖⴻⴽⴽⵡⵉ ⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵣⴻⵡⵡⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL2_5","081_2_5","COL","2","5","5","ⵎⴰⵖⴰⵔ ⵡⴰⵅⵅⴰ ⴰⵇⴰ ⴰⵢⵉ ⵖⴰⴱⴻⵖ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⴰⵢⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴰⵔⵔⵓⵃ ⵓⵛⴰ ⴼⴰⵔⵔⵃⴻⵖ ⴰⵎ ⵜⵜⵡⴰⵍⵉⵖ ⴰⵙⴻⵜⵜⴻⴼ ⴷ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL2_6","081_2_6","COL","2","6","6","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵇⴻⴱⵍⴻⵎ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓⵢⵓⵔⴻⵎ ⴷⴰⵢⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("CL2_7","081_2_7","COL","2","7","7","ⴰⵎ ⵜⴻⵡⵜⵉⵎ ⵉⵥⴻⵡⵔⴰⵏ ⵓ ⵜᵉⵜⵜⵡⴰⴱⵏⴰⵎ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⴹⵎⴻⵎ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵉ ⴷⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵍⵎⴰⴷⴻⵎ, ⴰⵎ ⵜᵉⵜⵜⴼⴻⵢⵢⴹⴻⵎ ⵙ ⵓⵇⴰⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("CL2_8","081_2_8","COL","2","8","8","ⵃⴹⴰⵎ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵖⴻⴽⴽⵡⵉ ⵛⴰ ⵓⵎⵉ ⵉⵜⵜⴻⵅⵅⵙ ⵜⵉⵖⵉⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⵛⵎⴰⵜ ⵉⵅⵡⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⴰⵖⵓⵔⵉ ⵏ ⵉⵡⴷⴰⵏ ⵓ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL2_9","081_2_9","COL","2","9","9","ⵎⵉⵏⵣⵉ ⴷⴰⵢⴻⵙ ⵉⵣⴻⴷⴷⴻⵖ ⵇⴰⵄ ⴰⵄⴻⵎⵎⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("CL2_10","081_2_10","COL","2","10","10","ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵜⴻⴵⴰⵎ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵄⴰⵡⴻⴷ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵣⴻⴵⵉⴼ ⵅ ⵇⴰⵄ ⵍⴻⵃⴽⴰⵎⴰⵜ ⴷ ⵚⵚⵓⵍⴰⵟⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("CL2_11","081_2_11","COL","2","11","11","ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵅⴻⵜⵏⴻⵎ ⴷⴰⵢⴻⵙ ⵄⴰⵡⴻⴷ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴻⵅⵜⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴻⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵙ ⵡⴻⵅⵜⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL2_12","081_2_12","COL","2","12","12","ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵏⴻⴹⵍⴻⵎ ⴰⴽⵉⴷⴻⵙ ⴷⴻⴳ ⵓⵙⴻⵖⴹⴻⵚ, ⵓ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵎ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⴻⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵎⵏⴻⵎ ⴷⵉ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL2_13","081_2_13","COL","2","13","13","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵙ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵓ ⵙ ⴱⵍⴰ ⴰⵅⵜⴰⵏ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵡⴻⵎ, ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⴰⴽⵉⴷⴻⵙ, ⵓⵛⴰ ⵉⵖⴼⴰⵔ ⴰⵏⴻⵖ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("CL2_14","081_2_14","COL","2","14","14","ⴰⵇⴰ ⵉⵎⵙⴻⵃ ⵜⴰⴱⵔⴰⵜ ⵏⵏⴻⵖ ⵏ ⵜⴻⵏⴼⵓⵍⵜ, ⵜⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵀⵎⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⴽⵙⵉ ⵜⵜ ⵣⵉ ⵍⵡⴻⵙⵟ ⴰⵎ ⵜⵜ ⵉⵙⴻⵎⵎⴰⵔ ⵅ ⵚⵚⴰⵍⵉⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("CL2_15","081_2_15","COL","2","15","15","ⴰⵎ ⵉⵙⵙⴰⵔⵙ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵉⵙⵙⵄⴰⵔⵔⴰ ⵍⴻⵃⴽⴰⵎⴰⵜ ⴷ ⵚⵚⵓⵍⴰⵟⴰⵜ ⴱⵟⴰⵢⵟⴰⵢ ⵓⵛⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⵙⴻⴹⵃⴰⵏⵜ ⵙ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵎⵓⵎⵎⵓ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("CL2_16","081_2_16","COL","2","16","16","ⵡⴰⵔ ⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵀⵡⴻⵍ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵏⵉⵖ ⴷⵉ ⵎⴰⵛⵛⴰ ⵍⴰ ⴷⵉ ⵜⵉⵙⵙⵉⵜ, ⵏⵉⵖ ⴷⵉ ⵍⴼⴰⵔⵣ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⵄⵢⵓⴷⴰⵜ ⵍⴰ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵢⵓⵔ ⵏ ⵊⴷⵉⴷ ⵓⵍⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵙⵙⴻⴱⵜ, ");
INSERT INTO rift_vpl VALUES ("CL2_17","081_2_17","COL","2","17","17","ⵎⴰⵖⴰⵔ ⵜⵉⵏⴰ ⴷ ⵜⵉⵍⵉⵡⵉⵏ ⵏ ⵎⵉⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵉ ⴷ ⴰⵙⴻⵏⵜ ⴷⴷ-ⵉⵜⵜⵍⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL2_18","081_2_18","COL","2","18","18","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵃⴻⴷ ⴰⴷ ⵢⴰⵔⵣⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⴻⴳⴳ ⴱⴻⵣⵣⴻⵣ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵙⵙⵡⴰⴹⵄⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵡⴻⵄⴱⴰⴷ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵏⵉⵄⵎⵉⵍ ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵍⴱⴰⵍ ⵉⵎⵎⴰⵔⵙ, ⵎⴰⵛⴰ ⵙ ⵜⵉⴷⴻⵜⵜ ⵢⴰⵔⴻⵣⵣⵓ ⵙ ⵣⵣⴰⵄⵎⴻⵜ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵥⵔⵉ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵅⵡⴰ ⴷⵉ ⵜⵓⴼⴼⴻⵜ ⵏⵏⴻⵙ ⵙ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵏⴻⵙ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⴱⵏⴰⴷⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("CL2_19","081_2_19","COL","2","19","19","ⴰⵎ ⵡⴰⵔ ⵉⵜⵜⵛⴻⴱⴱⴰⵔ ⴷⴻⴳ ⵓⵣⴻⴵⵉⴼ ⵉ ⵣⵉ ⵜⵢⴻⵎⵎⴰ ⵇⴰⵄ ⴰⵔⵔⵉⵎⴻⵜ ⵙ ⵍⴻⵎⵖⴰⵔⴻⵜ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵉⵛ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵓ ⵜᵉⵜⵜⵡⴰⵙⴻⵏⵏⴻⴷ ⵙ ⵍⴻⵎⴼⴰⵚⴻⵍ ⴷ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("CL2_20","081_2_20","COL","2","20","20","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵜⴻⵎⵎⵓⵜⴻⵎ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ ⵉ ⵍⴼⴰⵔⴰⵢⵉⴹ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⵡⴰⵃⴰⴽⴰⵎⴻⵎ ⴰⵅⵎⵉ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵄⴰⴷ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ? ");
INSERT INTO rift_vpl VALUES ("CL2_21","081_2_21","COL","2","21","21","‘ⵡⴰⵔ ⵜⵃⴰⴷⴰ!’, ‘ⵡⴰⵔ ⵜⵇⴰⵙⴰ!’, ⵓ ‘ⵡⴰⵔ ⵜⵜᵉⵟⵟⴻⴼ!’, ");
INSERT INTO rift_vpl VALUES ("CL2_22","081_2_22","COL","2","22","22","ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵏⴰⵎⵉⵜⵉⵏ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏⵜ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⴷ ⵜⵖⵓⵔⵉ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("CL2_23","081_2_23","COL","2","23","23","ⴰⵇⴰ-ⵜⴻⵏⵜ ⵜⵜⴱⴰⵏⴻⵏⵜ ⴰⵅⵎⵉ ⵖⴰⵔⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⵖⵓⵔⵉ ⵜⴰⵎⵉⵖⵉⵙⵜ, ⵙ ⵡⵓⴷⴻⵎ ⵏ ⵓⵡⴰⴹⴻⵄ ⴷ ⵏⵏⴻⵢⵢⴻⵜ ⵜⴰⴷⵉⵢⴰⵏⴻⵛⵜ, ⵏⵀⵍⴰ ⴰⵛⴻⵟⵟⴰⵔ ⵅ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵎⵉⵏ ⵉⵛⴻⵏⵏⵄⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵜⵢⴰⵡⴰⵏⵜ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL3_1","081_3_1","COL","3","1","1","ⵎⴰⵍⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵎ-ⴷⴷ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ, ⵅⴻⵏⵏⵉ ⴰⵔⵣⵓⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ, ⵎⴰⵏⵉ ⵉⵇⵇⵉⵎ ⵍⵎⴰⵙⵉⵃ ⵅ ⵓⴼⵓⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("CL3_2","081_3_2","COL","3","2","2","ⵄⴻⵇⵍⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⵙⴻⵏⵏⴻⵊ, ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("CL3_3","081_3_3","COL","3","3","3","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜⴻⵎⵎⵓⵜⴻⵎ ⵓⵛⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ ⵜⴻⵏⵏⵓⴼⴼⴰⵔ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("CL3_4","081_3_4","COL","3","4","4","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴹⵀⴰⵔ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴽⵉⴷⴻⵙ ⴷⴷ-ⵜⴻⴹⵀⴰⵔⴻⵎ ⴷⴻⴳ ⵓⵄⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("CL3_5","081_3_5","COL","3","5","5","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⵖⴻⵎ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⵉⵏⵏⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ: ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵍⴻⵅⵎⴻⵊ, ⴰⵛⴰⵀⵉ, ⵏⵏⴻⵛⵡⴰⵜ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⴷ ⵟⵟⵎⴻⵄ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵄⴱⴰⴷ ⵉ ⵍ’ⴰⵚⵏⴰⵎ, ");
INSERT INTO rift_vpl VALUES ("CL3_6","081_3_6","COL","3","6","6","ⵙ ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⴰⵢⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("CL3_7","081_3_7","COL","3","7","7","ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵓⵔⴻⵎ ⴰⵎⵎⵓ ⵣⵉⵛ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜⴻⴷⴷⴰⵔⴻⵎ ⵄⴰⴷ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("CL3_8","081_3_8","COL","3","8","8","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵙⴰⵔⵙⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⵅ ⵓⵖⴻⵣⴷⵉⵙ: ⴰⵖⴹⴰⴱ ⴷ ⵜⴻⴼⵇⴻⵃⵜ ⴷ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴷ ⵓⵛⴻⵇⵇⴻⴼ ⴷ ⵍⵀⴰⵔⴷ ⵉⵅⵎⴻⵊ. ");
INSERT INTO rift_vpl VALUES ("CL3_9","081_3_9","COL","3","9","9","ⵡⴰⵔ ⵙⵅⴰⵔⵔⵉⵇⴻⵎ ⵛⴰ ⵅ ⵡⴰⵢⴰⵡⵢⴰ, ⵎⴰⵛⴰ ⵙⴰⵔⵙⴻⵎ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⴱⵏⴰⴷⴻⵎ ⴰⵇⴷⵉⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("CL3_10","081_3_10","COL","3","10","10","ⵓ ⵜⵢⴰⵔⵔⴹⴻⵎ ⴱⵏⴰⴷⴻⵎ ⵏ ⵊⴷⵉⴷ, ⵡⴻⵏⵏⵉ ⵉⴷⴷⴻⴽⴽⵡⴰⵍⴻⵏ ⵊⴷⵉⴷ ⵙ ⵜⵓⵙⵙⵏⴰ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ, ⵖⴰⵔ ⵚⵚⵉⴼⴻⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL3_11","081_3_11","COL","3","11","11","ⴷⴰⵢⴻⵙ ⵡⴰⵔ ⵉⴵⵉ ⵡⵓⴷⴰⵢ ⵍⴰ ⴷ ⴰⵔⴰⵎⵉ, ⵍⴰ ⴷ ⴰⵅⵜⴰⵏ, ⵍⴰ ⴱⵍⴰ ⴰⵅⵜⴰⵏ, ⵍⴰ ⴷ ⴰⵢⵓⵏⴰⵏⵉⵢ, ⵍⴰ ⵍⴱⴰⵔⵔⴰⵏⵉ, ⵍⴰ ⴷ ⵉⵙⵎⴻⵖ ⵓⵍⴰ ⴷ ⵃⵓⵔⵔ, ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⴷ ⴽⵓⵍⵛⵉ ⵓ ⴷⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL3_12","081_3_12","COL","3","12","12","ⵅ ⵓⵢⴻⵏⵏⵉ, ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴹⴻⵎ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍⴻⵃⵏⵓⵏⴻⵛⵜ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ ⴷ ⵓⵡⴰⴹⴻⵄ ⵏ ⴰⵔⵔⵓⵃ ⴷ ⵜⴻⵎⵀⵉⵏⵜ ⴷ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("CL3_13","081_3_13","COL","3","13","13","ⵇⴻⴱⵍⴻⵎ ⵓ ⵙⴰⵎⵃⴻⵎ ⵉ ⵡⴰⵢⴰⵡⵢⴰ. ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵖⴰⵔⴻⵙ ⴰⵛⴻⵜⵛⵉ ⵅ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ, ⵖⴼⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵖⴼⴰⵔ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL3_14","081_3_14","COL","3","14","14","ⵓⵛⴰ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⴰ, ⴰⵔⵏⵉⵎ ⵜⴰⵢⵔⵉ ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵅⴰⴷⴻⵏⵜ ⵏ ⵍⴻⴽⵎⴰⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("CL3_15","081_3_15","COL","3","15","15","ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵍⴻⵀⵏⴰ ⵏ ⵍⵎⴰⵙⵉⵃ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵍⴻⵀⵏⴰ ⵏⵏⵉ ⵖⴰⵔ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵓⵛⴰ ⵇⴰⴷⴰⵎ ⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL3_16","081_3_16","COL","3","16","16","ⵊⵊⴻⵎ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵣⴷⴻⵖ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⵖⵉⵜ. ⵙⵍⴻⵎⴷⴻⵎ, ⵙⴻⵊⵊⵄⴻⵎ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵓⵖⴻⵏⵏⴻⵊ ⵏ ⵉⵣⴻⵀⵀⵉⴷⴻⵏ ⴷ ⵜⴻⵙⴱⵉⵃ ⴷ ⵉⵣⵍⴰⵏ ⵏ ⴰⵔⵔⵓⵃ, ⵓ ⵖⴻⵏⵏⵊⴻⵎ ⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵛⵛⵓⵔⴻⵏ ⵙ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("CL3_17","081_3_17","COL","3","17","17","ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵡⴰⵡⴰⵍ ⵏⵉⵖ ⵙ ⵜⵎⴻⴳⴳⴰ, ⴳⴳⴻⵎ ⵜ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓ ⵛⴻⴽⴽⴰⵔⴻⵎ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("CL3_18","081_3_18","COL","3","18","18","ⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⴷⴻⵡⵍⴻⵏⵜ ⵙⴰⴷⵓ ⵉⵔⵢⴰⵣⴻⵏ ⵏⴽⴻⵏⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵉⵜⵜⴰⵙ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL3_19","081_3_19","COL","3","19","19","ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵅⵙⴻⵎ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵜⵜⵇⴻⵙⵃⴻⵎ ⴷⴰⵢⵙⴻⵏⵜ ⵙ ⵜⴰⵔⵣⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("CL3_20","081_3_20","COL","3","20","20","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵟⴰⵄⴻⵎ ⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵡⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵢⴰⵔⴻⵟⵟⴰ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("CL3_21","081_3_21","COL","3","21","21","ⴰ ⵍⵡⴰⵍⵉⴷⵉⵏ, ⵡⴰⵔ ⴷⴰⵔⵔⴰⵛⴻⵎ ⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⵔⴰⵃ ⵜⴻⵔⵢⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("CL3_22","081_3_22","COL","3","22","22","ⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ, ⵟⴰⵄⴻⵎ ⵉ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵛⴰ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵡⴷⴰⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴰⵔⴹⴰⵏ ⵉⵡⴷⴰⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵎ ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ ⵏ ⵡⵓⵍ ⵓ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("CL3_23","081_3_23","COL","3","23","23","ⵇⴰⵄ ⵎⵉⵏ ⵖⴰ ⵜⴻⴳⴳⴻⵎ, ⴳⴳⴻⵎ ⵜ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ, ⴳⴳⴻⵎ ⵜ ⴰⵅⵎⵉ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("CL3_24","081_3_24","COL","3","24","24","ⵙⵏⴻⵎ ⴰⵇⴰ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵍⴻⵅⵍⴰⵚ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷⵉ ⵍⵡⴰⵔⵜ, ⵎⴰⵖⴰⵔ ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵙⵉⴷⵉ, ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("CL3_25","081_3_25","COL","3","25","25","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵖⴻⵛⵛ, ⴰⴷ ⵉⵜⵜⵡⴰⵅⵍⴻⴼ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵖⴻⵛⵛ ⵉ ⵢⴻⴳⴳⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵍⴼⴰⵔⵣ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("CL4_1","081_4_1","COL","4","1","1","ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⴱⴰⴱ, ⴳⴳⴻⵎ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⴷ ⵜⵙⴻⴳⴷⴰ ⴰⴽ-ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵡⴻⵎ. ⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⵡⴻⵎ ⵄⴰⵡⴻⴷ ⵙⵉⴷⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("CL4_2","081_4_2","COL","4","2","2","ⵚⴱⴰⵔⴻⵎ ⴷⵉ ⵜⵥⴰⴵⵉⵜ, ⵃⴹⴰⵎ ⴷⴰⵢⴻⵙ ⵓ ⵡⵛⴻⵎ ⴰⵇⴰⴷⵉ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("CL4_3","081_4_3","COL","4","3","3","ⵥⴰⴵⴻⵎ ⵄⴰⵡⴻⴷ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵃⵉⵎⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵏⴻⵖ ⵢⴰⵔⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ ⵏ ⵡⴰⵡⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵅ ⵙⵙⵉⵔⵔ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⴵⵉⵖ ⵄⴰⵡⴻⴷ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("CL4_4","081_4_4","COL","4","4","4","ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵙⵙⴰⵔⴻⴳⴱⴻⵖ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵙⵙⵉⵡⵍⴻⵖ ⵏⵉⵛⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵅⴰⴼⵉ ⵉⵛⵓⵡⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("CL4_5","081_4_5","COL","4","5","5","ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵜⵉⵖⵉⵜ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵏ ⴱⴰⵔⵔⴰ, ⴰⵔⴻⴱⵃⴻⵎ ⵍⵡⴻⵇⵜ ⵉ ⵢⴻⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("CL4_6","081_4_6","COL","4","6","6","ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵡⴰⵍ ⵏⵡⴻⵎ ⵍⴻⴱⴷⴰ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵎⴻⴵⵃⴻⵎ ⵜ ⵙ ⵜⵎⴻⴵⴰⵃⵜ, ⵓ ⵙⵙⵏⴻⵎ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⴷⴷ-ⵜⴰⵔⵔⴻⵎ ⵏⵉⵛⴰⵏ ⵅ ⴽⵓⵍ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("CL4_7","081_4_7","COL","4","7","7","ⵜⵉⵛⵉⴽⵓⵙ, ⵓⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ ⴷ ⵓⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵜⵉⵇⵇⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵖ ⴷⵉ ⵙⵉⴷⵉ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵅ ⵓⵎⴻⴷⴷⵓⵔ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("CL4_8","081_4_8","COL","4","8","8","ⵙⵙⴻⴽⴽⴻⵖ ⵜ ⵖⴰⵔⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜⴻⴵⴰⵎ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("CL4_9","081_4_9","COL","4","9","9","ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵏⵉⵙⵉⵎⵓⵙ, ⵓⵎⴰⵜⵏⴻⵖ ⴰⵎⵜⵉⵇⵇⵉ ⵉⵄⵉⵣⵣⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ. ⵏⵉⵜⵏⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴰⵔⴻⴳⴱⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵏⴻⴵⴰ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("CL4_10","081_4_10","COL","4","10","10","ⴰⵔⵉⵙⵜⴰⵔⵅⵓⵙ ⵡⴻⵏⵏⵉ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴰⴽⵉⴷⵉ, ⵉⵜⵜⵙⴻⴵⴰⵎ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵙⴻⴵⴰⵎ ⵓⵍⴰ ⴷ ⵎⴰⵔⴽⵓⵙ, ⴰⵢⵢⴰⵡ ⵏ ⴱⴰⵔ-ⵏⴰⴱⴰ ⵡⴻⵏⵏⵉ ⵅ ⵜⴻⴽⵙⵉⵎ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⴻⵚⵚⴰ - ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ, ⵇⴻⴱⵍⴻⵎ ⵜ - ");
INSERT INTO rift_vpl VALUES ("CL4_11","081_4_11","COL","4","11","11","ⴷ ⵢⴰⵙⵓⵄ, ⵓⵎⵉ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵢⵓⵙⵜⵓⵙ. ⵏⵉⵜⵏⵉ ⴵⴰⵏ ⵣⴻⴳ ⵡⴻⵅⵜⴰⵏ. ⵏⵉⵜⵏⵉ ⵡⴻⵃⵃⴻⴷⵙⴻⵏ ⵄⴰⵡⵏⴻⵏ ⴰⵢⵉ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵙⵙⴼⴻⵡⵡⵊⴻⵏ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("CL4_12","081_4_12","COL","4","12","12","ⵉⵜⵜⵙⴻⴵⴰⵎ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵉⴱⴰⴼⵔⴰⵙ ⵙ ⵍⴻⵀⵏⴰ. ⵏⴻⵜⵜⴰ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵉⵜⵜⴻⴷⵄⴰ ⴰⵡⴻⵎ ⵍⴻⴱⴷⴰ ⴷⵉ ⵜⵥⴰⴵⵉⵜ ⵏⵏⴻⵙ ⵙ ⵊⵊⴻⵀⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ, ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴽⴻⵎⵎⵍⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("CL4_13","081_4_13","COL","4","13","13","ⵎⵉⵏⵣⵉ ⵛⴻⵀⵀⴷⴻⵖ ⵅⴰⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⵟⵟⴰⵙ ⵉ ⵅⴰⵡⴻⵎ ⵉⴽⵙⵉ ⵓⵍⴰ ⵅ ⵢⵉⵏⵏⵉ ⴷⵉ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ ⴷ ⵢⵉⵏⵏⵉ ⴷⵉ ⵀⵉⵔⴰⴱⵓⵍⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("CL4_14","081_4_14","COL","4","14","14","ⵍⵓⴽⴰ, ⴰⴹⴱⵉⴱ ⵏⵏⴻⵖ ⵉⵄⵉⵣⵣⴻⵏ, ⴷ ⴷⵉⵎⴰⵙ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("CL4_15","081_4_15","COL","4","15","15","ⵙⴻⴵⵎⴻⵎ ⵅ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ ⵙ ⵍⴻⵀⵏⴰ, ⵅ ⵏⵉⵎⴼⴰⵙ ⵓ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("CL4_16","081_4_16","COL","4","16","16","ⵅⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴰⵔ ⵜⴻⴱⵔⴰⵜ-ⴰ ⵊⴰⵔ ⴰⵡⴻⵎ, ⵅⴻⵏⵏⵉ ⵃⴹⴰⵎ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴰⵔ ⵄⴰⵡⴻⴷ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ ⵓⵛⴰ ⴰⴷ ⵜⵖⴰⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⵜⴻⵏⵏⵉ ⵣⵉ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("CL4_17","081_4_17","COL","4","17","17","ⵉⵏⵉ ⵉ ⴰⵔⵅⵉⴱⴱⵓⵙ: “ⵃⴹⴰ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵉ ⵜⴻⴽⵙⵉⴷ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ!” ");
INSERT INTO rift_vpl VALUES ("CL4_18","081_4_18","COL","4","18","18","ⵙⵍⴰⵎ ⵡⴰⵏⵉⵜⴰ ⵓⵔⵉⵖ ⵜ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ, ⵣⵉ ⴱⵓⵍⵓⵙ. ⵄⴻⵇⵍⴻⵎ ⵅ ⵙⵙⵏⴰⵙⴻⵍ ⵉⵏⵓ. ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵔⴹⴰ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("H11_1","082_1_1","1TH","1","1","1","ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⵡⴰⵏⵓⵙ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⵉ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ: ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("H11_2","082_1_2","1TH","1","2","2","ⴰⵇⴰ ⵏⴻⵜⵜⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵍⴻⴱⴷⴰ, ⵓ ⵏⵜⵉⴷⴰⵔ ⴽⴻⵏⵏⵉⵡ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⴷⵉ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H11_3","082_1_3","1TH","1","3","3","ⵇⵉⴱⴰⵍⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵏⴻⵜⵜⴼⴻⴽⴽⴰⵔ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⴷⴻⴳ ⵓⵜⴰⵎⴰⵔ ⵏ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵓ ⴷⵉ ⵚⵚⴱⴰⵔ ⵏ ⵓⵙⵉⵜⴻⵎ ⵏⵡⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("H11_4","082_1_4","1TH","1","4","4","ⵎⴰⵖⴰⵔ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⵉⵎⵄⵉⵣⵣⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("H11_5","082_1_5","1TH","1","5","5","ⵎⵉⵏⵣⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⴻⵖ ⵡⴰⵔ ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵡⵉⴹ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵓⵍⴰ ⵙ ⵊⵊⴻⵀⴷ, ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵙ ⵍⴻⵇⵏⴰⵄⴻⵜ ⴷ ⵜⵉⴷⴻⵜⵜ. ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵏⴻⵖ ⵜⵓⵖⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H11_6","082_1_6","1TH","1","6","6","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⴻⴹⴼⴰⵔⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ ⵓⵍⴰ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵎⴰⵖⴰⵔ ⵓⵎⵉ ⵅⴰⵡⴻⵎ ⵜⴻⴽⴽⴰ ⵍⵎⴻⵃⵏⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜᵉⵟⵟⴼⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H11_7","082_1_7","1TH","1","7","7","ⴰⵎⵎⵓ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⴰⵎⴻⴷⵢⴰ ⵉ ⵇⴰⵄ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⵓ ⴷⵉ ⴰⵅⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("H11_8","082_1_8","1TH","1","8","8","ⵎⵉⵏⵣⵉ ⵍⴻⵅⴱⴰⵔ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⵇⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵡⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⴷ ⴰⵅⴰⵢⴰ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵜⴰⵏⵢⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵓⵛⴰⵏ, ⴰⵍⴰⵎⵉ ⵏⴻⵀⵍⴰ ⵎⴰ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵅⴰⵙ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("H11_9","082_1_9","1TH","1","9","9","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵄⴰⵡⴷⴻⵏ ⴰⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵜⴰⵔⴻⵣⵎⴻⵎ ⴰⵏⴻⵖ ⵜⴰⵡⵡⴰⵔⵜ, ⵓⵛⴰ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⴷⴻⵡⵍⴻⵎ ⵣⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⴱⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("H11_10","082_1_10","1TH","1","10","10","ⴰⵎ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ ⵎⵎⵉⵙ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵢⴰⵙⵓⵄ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉ ⵖⴰ ⵉⵙⵙⵏⴻⵊⵎⴻⵏ ⵣⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H12_1","082_2_1","1TH","2","1","1","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⴷⴰⴼ ⵏⵏⴻⵖ ⵏⵏⵉ ⴷ ⵖⴰⵔⵡⴻⵎ ⵏⴻⴳⴳⴰ, ⵡⴰⵔ ⵜⵓⵖⵉ ⵉⴵⵉ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("H12_2","082_2_2","1TH","2","2","2","ⵜⵓⵖⴰ ⵅⴰⵏⴻⵖ ⵉⴽⴽⴰ ⵓⵡⴻⴷⴷⴻⴱ ⴷ ⵍⵃⴰⴳⵔⴰ ⴷⵉ ⴼⵉⵍⵉⴱⴱⵉ ⵇⴱⴻⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵏⴻⵎ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵏⴱⴰⵔⵔⴻⵃ ⴰⵡⴻⵎ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵙ ⵜⴻⵔⵢⴰⵙⵜ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓ ⵙ ⵓⵎⴻⵏⵖⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("H12_3","082_2_3","1TH","2","3","3","ⵙ ⵎⵉⵏⵣⵉ ⴰⴼⴻⵡⵡⴻⵊ ⵏⵏⴻⵖ ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⴻⴳ ⵓⵖⴻⴽⴽⵡⵉ ⵏⵉⵖ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏⵉⵖ ⵣⵉ ⵍⵖⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("H12_4","082_2_4","1TH","2","4","4","ⵎⴰⵛⴰ ⵏⴻⵙⵙⴰⵡⴰⵍ ⴰⵎ ⵉⵡⴷⴰⵏ ⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵏⵉⵛⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵍⴰⵎⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⴻⴽⴽⴻⵍ ⵜⴰⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⵏⵏⴻⵙ ⴷ ⴰⵚⴻⴱⵃⴰⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⴰⵔⴹⴰ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵉ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵇⴻⴵⴱⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H12_5","082_2_5","1TH","2","5","5","ⵎⵉⵏⵣⵉ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵜⵓⵖⵉ ⵏᵉⵜⵜⴻⴳⴳ ⵜⵉⵇⴻⴷⴷⵓⵃⵉⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵜⵜ, ⵓ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴳⴳ ⵄⴻⵎⵎⴰⵔⵚ ⵉⵊⵊ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵅ ⵟⵟⵎⴻⵄ ⵏⵏⴻⵖ, ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⴷⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("H12_6","082_2_6","1TH","2","6","6","ⵡⴰⵔ ⵏⴰⵔⴻⵣⵣⵓ ⴰⵄⵓⴵⵉ ⵏ ⵉⵡⴷⴰⵏ, ⵓⵍⴰ ⵣⵣⴰⵢⵡⴻⵎ ⵓⵍⴰ ⵣⴻⴳ ⵉⵏⵏⴻⵖⵏⵉ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵊⴰⵔ ⴰⵡⴻⵏ ⴰⵎ ⵔⵔⵓⵙⵓⵍ ⵏ ⵍⵎⴰⵙⵉⵃ.    ");
INSERT INTO rift_vpl VALUES ("H12_7","082_2_7","1TH","2","7","7","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷ ⵉⵃⵏⵉⵏⴻⵏ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵜⴻⴱⵍⵉⵖⵜ ⵜᵉⵜⵜⵀⵉⵍⵍⴰ ⴷⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("H12_8","082_2_8","1TH","2","8","8","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⵏᵉⵜⵜⴻⵅⵙ ⴽⴻⵏⵏⵉⵡ ⵓ ⵜⵓⵖⴰ ⴷⴰⵢⵏⴻⵖ ⵎⴻⵥⵔⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵛⴰⵔⵛ ⴰⴽⵉⴷⵡⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵀⴰ, ⴰⵃⴻⵇⵇⴰ ⵓⵍⴰ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵖⴰⵔⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H12_9","082_2_9","1TH","2","9","9","ⵄⴻⵇⵍⴻⵎ ⵅⴻⵏⵏⵉ, ⴰ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ, ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵏᵉⵜⵜⴰⵎⴰⵔ ⵓ ⵏⵅⴻⴷⴷⴻⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵏᵉⵜⵜⴻⴳⴳ ⴷⴷⵇⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("H12_10","082_2_10","1TH","2","10","10","ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⴷ ⵍⴻⵛⵀⵓⴷ ⵅ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵡⴻⵎ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ ⴷ ⵜⵏⵉⵛⴰⵏⵜ ⵏ ⵡⵓⵍ, ⵓ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵏⴻⴳⴳⵓⵔ ⴱⵍⴰ ⵍⵄⵉⴱ ⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H12_11","082_2_11","1TH","2","11","11","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵄⴰⵡⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵏⵄⴻⴵⴻⵎ ⵉⵊⵊ-ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ, ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⴰⴱⴰⵙ ⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵎⵎⴻⵛ ⵏⴻⴳⴳⴰ ⴷⴰⵢⵡⴻⵎ ⵓⵍ ⵓ ⵏⴻⵛⵀⴻⴷ ⵉ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("H12_12","082_2_12","1TH","2","12","12","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵙⴷⴰⵀⴻⴵ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⵓ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("H12_13","082_2_13","1TH","2","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵜⵜⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵇⴻⴱⵍⴻⵎ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜᵉⵟⵟⴼⴻⵎ ⵣⵣⴰⵢⵏⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⴰⵎ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵢⴻⴵⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵓ ⴰⵡⴰⵍ-ⴰ ⵉⵅⴻⴷⴷⴻⵎ ⴷⴰⵢⵡⴻⵎ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H12_14","082_2_14","1TH","2","14","14","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵎⴻⴹⴼⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵀⵓⴷⵉⵢⵢⴰ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴽⵙⵉⵎ ⵄⴰⵡⴻⴷ ⴰⵔⵔⵎⴻⵃ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴳⴻⵏⵙ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⵙⵉⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴰⵔⵔⵎⴻⵃ ⵣⴻⴳ ⵡⵓⴷⴰⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("H12_15","082_2_15","1TH","2","15","15","ⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓⵍⴰ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉ ⵣⵣⴰⵢⵙⴻⵏ ⴷⴷ-ⴼⴼⵖⴻⵏ, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⴷⴰⵔⵔⵛⴻⵏ ⵅⴰⵏⴻⵖ. ⴰⵇⴰ ⴰⵜⴻⵏ ⵡⴰⵔ ⴰⵔⴻⵟⵟⵉⵏ ⵛⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴷⴻⵡⵍⴻⵏ ⴹⵉⴷⴷ ⵏ ⵉⵡⴷⴰⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("H12_16","082_2_16","1TH","2","16","16","ⵎⴰⵖⴰⵔ ⵎⴻⵏⵄⴻⵏ ⴰⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵖⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⵃⵉⵎⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵓⴷⴰⵔⵜ. ⴰⵎⵎⵓ ⵉ ⵜⵜⵄⴻⵎⵎⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵍⵎⵉⵣⴰⵏ ⵏ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⵡⴻⵖⴹⴰⴱ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("H12_17","082_2_17","1TH","2","17","17","ⴰ ⴽⴻⵏⵏⵉⵡ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⵖⴰⵔ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵏⴻⴷⵡⴻⵍ ⵏⴻⵛⵛⵉⵏ ⴷ ⵉⵢⵓⵊⵉⵍⴻⵏ ⵏⵡⴻⵎ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⵖⴻⵎⴱⵓⴱ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⵓⵍ. ⵙ ⵓⵢⴰ ⵜⵓⵖⴰ ⵏⴰⵔⴻⵣⵣⵓ ⵙ ⵎⴻⵥⵔⵉ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵏⵥⴰⵔ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H12_18","082_2_18","1TH","2","18","18","ⵜⵓⵖⴰ ⵏⴻⵅⵙ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵏⴰⵙ, ⵏⴻⵛⵛ ⴱⵓⵍⵓⵙ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ ⵄⴰⴷ, ⵎⴰⵛⴰ ⵛⵛⵉⵟⴰⵏ ⵉⴱⴻⴷⴷ ⴰⵢⵉ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("H12_19","082_2_19","1TH","2","19","19","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ, ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵖ ⵏⵉⵖ ⴷ ⵜⵜⴰⵊ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵖ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ, ⵉⵍⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵀⴰ? ");
INSERT INTO rift_vpl VALUES ("H12_20","082_2_20","1TH","2","20","20","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵖ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H13_1","082_3_1","1TH","3","1","1","ⵓⵎⵉ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵏⴻⵚⴱⴰⵔ ⴽⵜⴰⵔ, ⵜⵓⵖⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵏⴻⵖ ⵎⵍⵉⵃ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⴷⵉ ⴰⵜⵉⵏⴰ ⵡⴻⵃⵃⴻⴷⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("H13_2","082_3_2","1TH","3","2","2","ⵓⵛⴰ ⵏⴻⵙⵙⴻⴽⴽ ⴰⵡⴻⵎ-ⴷⴷ ⵓⵎⴰⵜⵏⴻⵖ ⵜⵉⵎⵓⵜⵉⵢⵓ. ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵏⵏⴻⵖ ⴷⵉ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⵍⴰⵎⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵊⵀⴻⴷ ⵓ ⴰⴷ ⵉⵇⴻⴵⴻⴱ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("H13_3","082_3_3","1TH","3","3","3","ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵇⴻⵟⵟⴻⵄ ⵍⴰⵢⴰⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵎⵃⴰⵢⴻⵎ-ⴰ. ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⵡⴰⴳⴳ ⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("H13_4","082_3_4","1TH","3","4","4","ⵎⴰⵖⴰⵔ ⵍⴰⵎⵉ ⴷ ⴰⵏⴻⵖ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⵏⵉⵣⵣⴰⵔ ⵏⴻⵏⵏⴰ, ⴱⴻⵍⵍⵉ ⴰⴷ ⵅⴰⵏⴻⵖ ⵜⴻⴽⴽ ⵍⴻⵃⵚⴰⵔⴻⵜ, ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵉⵎⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵏⴻⵎ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("H13_5","082_3_5","1TH","3","5","5","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵓⵎⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵖ ⴰⴷ ⵚⴱⴰⵔⴻⵖ ⴽⵜⴰⵔ, ⴰⵇⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵜ-ⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⵅ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⵎⴰ ⴰⴷ ⵜⴰⵖ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵏ ⴰⵇⴰ ⵉⵊⴰⵔⵔⴻⴱ ⴽⴻⵏⵏⵉⵡ ⵓⵛⴰ ⴰⴷ ⵉⴼⴼⴻⵖ ⴰⵔⴱⴻⵔ ⵏⵏⴻⵖ ⴷ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("H13_6","082_3_6","1TH","3","6","6","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⵏⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ ⵜⵉⵎⵓⵜⵉⵢⵓ ⵓⵛⴰ ⵉⵙⵙⵉⵡⴻⴹ ⴰⵏⴻⵖ-ⴷⴷ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴷ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴱⴷⴰ ⵜᵉⵜⵜⵉⴷⴰⵔⴻⵎ ⴰⵏⴻⵖ ⵙ ⵍⵅⴰⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵓ ⴷⴰⵢⵡⴻⵎ ⵎⴻⵥⵔⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵜⵥⴰⵔⴻⵎ, ⴰⵎ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⴷⴰⵢⵏⴻⵖ ⵎⴻⵥⵔⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⵥⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("H13_7","082_3_7","1TH","3","7","7","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵜⵜⵡⴰⴼⴻⵡⵡⴻⵊ ⵣⵣⴰⵢⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴰⵔⴰ ⵏⵏⴻⵖ ⴷ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵏⵏⴻⵖ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("H13_8","082_3_8","1TH","3","8","8","ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵏⴻⵜⵜⵡⴰⵏⵄⴻⵛⵛ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵖⵉⵎⴰⵎ ⵜᵉⵜⵜⴱⴻⴷⴷⴰⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H13_9","082_3_9","1TH","3","9","9","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⴰⴷ ⵏⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵡⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵣⵉ ⵏⴼⴰⵔⵔⴻⵃ ⵣⵣⴰⵢⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("H13_10","082_3_10","1TH","3","10","10","ⵎⵖⵉⵔ ⵓⵎⵉ ⵏⴻⵜⵜᵉⵜⵜⴰⵔ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ ⵙ ⵡⴰⵟⵟⴰⵙ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵏⵥⴰⵔ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵓⵛⴰ ⴰⴷ ⵏⴽⴻⵎⵎⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⵄⴰⴷ ⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H13_11","082_3_11","1TH","3","11","11","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵉⵙⴻⴳⴳⴻⵎ ⴰⴱⵔⵉⴷ ⵏⵏⴻⵖ ⵖⴰⵔⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H13_12","082_3_12","1TH","3","12","12","ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⴰⵔⵏⵉ ⴷⵉ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵏ ⵉⵊⵊⴻⵏ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵓ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ ⵉ ⵎⴰⵔⵔⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏᵉⵜⵜⴻⵅⵙ ⵏⴻⵛⵛⵉⵏ ⵓⵍⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("H13_13","082_3_13","1TH","3","13","13","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵙⵎⴻⵃⵃⴻⴷ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴱⵍⴰ ⵍⵄⵉⴱ ⴷⵉ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵅ ⵎⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("H14_1","082_4_1","1TH","4","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⵣⴰⵡⴻⴳ ⴽⴻⵏⵏⵉⵡ ⵓ ⵏⴻⵜⵜⵥⴰⴵⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⵃⵉⵎⴰ, ⴰⵎ ⵣⵣⴰⵢⵏⴻⵖ ⵜⵍⴻⵎⴷⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵓ ⴰⴷ ⵜⴰⵔⴹⴰⵎ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵜⴻⵢⵎⴰⵎ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴽⵜⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("H14_2","082_4_2","1TH","4","2","2","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵏⴻⵡⵛⴰ ⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("H14_3","082_4_3","1TH","4","3","3","ⴰⵇⴰ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴰⴷ ⵜⴻⵢⵎⴰⵎ ⴷⵉ ⵜⵇⴻⴷⴷⴰⵙⵜ, ⴰⴷ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("H14_4","082_4_4","1TH","4","4","4","ⵓ ⵎⴰⵃⴻⵏⴷ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⴰⵡⵉ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ ⴷ ⵛⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("H14_5","082_4_5","1TH","4","5","5","ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵛⵛⴻⵀⵡⴰⵜ ⵏ ⵏⵏⴻⵛⵡⴻⵜ, ⴰⵎ ⵍⴻⴳⵏⵓⵙ ⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("H14_6","082_4_6","1TH","4","6","6","ⴻⵊⵊ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵣⵄⴻⵎ ⴰⴷ ⵉⵙⵙⴻⵀⵍⴻⵛ ⵓⵎⴰⵙ ⵏⵉⵖ ⴰⴷ ⵜ ⵉⵖⴻⵛⵛ ⴷⵉ ⵜⵎⴻⵙⵍⴰⵛⵜ-ⴰ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⵉⵏⴻⵇⵇⴻⵎ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵉⵣⵣⴰⵔ ⵏⴻⵏⵏⴰ ⵓ ⵏⴻⵛⵀⴻⴷ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H14_7","082_4_7","1TH","4","7","7","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⵍⴰⵖⴰ ⵉ ⵍⴻⵅⵎⴻⵊ, ⵎⴰⵛⴰ ⵉ ⵜⵇⴻⴷⴷⴰⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("H14_8","082_4_8","1TH","4","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵙⵙⴷⴻⴵⴻⵏ, ⵡⴰⵔ ⵉⵙⵙⴷⴻⴵⵉ ⵛⴰ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H14_9","082_4_9","1TH","4","9","9","ⵏⵀⵍⴰ ⵎⴰ ⵏⵓⵔⴰ ⴰⵡⴻⵎ-ⴷⴷ ⵅ ⵜⴰⵢⵔⵉ ⵜⴻⵏⵏⵉ ⵊⴰⵔ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵙ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⵎ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("H14_10","082_4_10","1TH","4","10","10","ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⴰⵡⵎⴰⵜⴻⵏ ⴷⵉ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⵜⵎⵓⵏ. ⵎⴰⵛⴰ ⵜⵜⴰⵔⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴼⴻⵢⵢⴹⴻⵎ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("H14_11","082_4_11","1TH","4","11","11","ⴰⵔⵣⵓⵎ ⴰⴷ ⵜⴻⴷⴷⴰⵔⴻⵎ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⴰⵢⵏⵉⵜ ⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏⵡⴻⵎ, ⴰⴷ ⵜⵅⴻⴷⵎⴻⵎ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴽⴻⵏⵏⵉⵡ ⵏⵓⵎⵓⵔ, ");
INSERT INTO rift_vpl VALUES ("H14_12","082_4_12","1TH","4","12","12","ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⴰⴽ-ⴷ ⵢⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⵔⵔⴰ, ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵀⴷⴰⵊⴻⵎ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵣⵉ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H14_13","082_4_13","1TH","4","13","13","ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⵉ ⴰⴷ ⵜⴻⴽⵙⵉⵎ ⵙ ⵡⴻⵎⵏⵓⵙ ⵅ ⵢⴻⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵟⵟⵚⴻⵏ, ⴰⵎ ⵜ ⵜⵜⴻⴳⴳⴻⵏ ⵉⵡⴷⴰⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵇⴹⴻⵄ ⵍⴰⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("H14_14","082_4_14","1TH","4","14","14","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⵓⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ ⵓⵛⴰ ⵉⴽⴽⴰⵔ-ⴷⴷ, ⵅⴻⵏⵏⵉ ⴰⴷ ⴽⵉⴷⴻⵙ ⵢⵉⵡⵉ ⴰⵔⴻⴱⴱⵉ ⵄⴰⵡⴻⴷ ⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵟⵟⵚⴻⵏ ⴰⵎⵎⵓ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ ⴷⵉ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("H14_15","082_4_15","1TH","4","15","15","ⵎⴰⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵏⵉⵏⵉ ⴰⵢⴰ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵉⵏⵏⵉ ⵄⴰⴷ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴰⵔ ⵏᵉⵜⵜⵉⵣⵣⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⴰⴷ ⵟⵟⵚⴻⵏ ⴷⴻⴳ ⵡⴻⵏⴹⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("H14_16","082_4_16","1TH","4","16","16","ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⴷⴷ-ⵉⵀⵡⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴼⴼⴻⵖ ⵍⵓⵎⵓⵔ ⴷ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵣⴻⴵⵉⴼ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵓ ⵅⵎⵉ ⵉ ⵖⴰ ⵜⵉⵍⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵙⵓⴹⵉ ⵙ ⵓⵢⵉⵛⵛ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵉⵎⴻⵜⵜⴰⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴷⴷ-ⴽⴽⴰⵔⴻⵏ ⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("H14_17","082_4_17","1TH","4","17","17","ⵅⴰⵙ ⵓⵛⴰ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵓ ⵄⴰⴷ ⴷⴷⴰⵔⴻⵏ, ⴰⴷ ⴽⵉⴷⵙⴻⵏ ⵏⴻⵜⵜⵡⴰⴽⴽⴻⵙ ⴷⴻⴳ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵍⵇⵉ ⴰⴽ-ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵏⵉⵍⵉ ⵍⴻⴱⴷⴰ ⴰⴽ-ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H14_18","082_4_18","1TH","4","18","18","ⵙ ⵓⵢⴰ ⴳⴳⴻⵎ ⵓⵍ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("H15_1","082_5_1","1TH","5","1","1","ⵎⴰⵛⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⴷ ⵜⵙⴰⵄⵄⴻⵜⵉⵏ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵏⵀⵍⴰ ⵎⴰ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("H15_2","082_5_2","1TH","5","2","2","ⴽⴻⵏⵏⵉⵡ ⵙⵉⵎⴰⵏⵜ ⵏⵡⴻⵎ ⵜⴻⵙⵙⵏⴻⵎ ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵎ ⵓⵛⴻⴼⴼⴰⵔ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("H15_3","082_5_3","1TH","5","3","3","ⵅⵎⵉ ⵖⴰ ⵉⵏⵉⵏ ⵏⵉⵜⵏⵉ: ‘ⴰⵇⴰ ⵍⴻⵀⵏⴰ ⴷ ⵍⵀⵓⴷⵏⴻⵜ!’, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⴽⴽ ⵡⴰⵔⴻⵢⵢⴻⴱ ⴷⴻⵖⵢⴰ, ⴰⵎ ⵜⵜⴻⴽⴽⴻⵏ ⵍⴻⵡⵊⴻⵄ ⵏ ⵜⴰⵔⵓⵜ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵙ ⴷⴷⴻⵢⵙⴻⵜ, ⵓⵛⴰ ⵡⴰⵔ ⴷⵉⵏ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⵔⴻⵡⵍⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H15_4","082_5_4","1TH","5","4","4","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵡⴻⵎ-ⴷⴷ ⵉⵡⴹⴰ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⵎ ⵓⵛⴻⴼⴼⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("H15_5","082_5_5","1TH","5","5","5","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵜⴼⴰⵡⵜ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵡⴰⵙⵙ, ⵡⴰⵔ ⵜⴻⴵⵉⵎ ⵛⴰ ⵏ ⴵⵉⵍⴻⵜ ⵏⵉⵖ ⵏ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("H15_6","082_5_6","1TH","5","6","6","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏᵉⵜⵜⴻⵟⵟⴻⵚ ⴰⵎ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵛⴰ ⴰⴷ ⵏⵉⵍⵉ ⵏⴼⴰⵇ, ⵏⴻⵃⴹⴰ, ");
INSERT INTO rift_vpl VALUES ("H15_7","082_5_7","1TH","5","7","7","ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⵚⴻⵏ, ⴰⵇⴰ ⵜⵜᵉⵟⵟⵚⴻⵏ ⴷⵉ ⴵⵉⵍⴻⵜ, ⵓ ⵉⵏⵏⵉ ⵉⵜⵜⵖⴻⵍⵍⴰⵏ, ⴰⵇⴰ ⵜⵜⵖⴻⵍⵍⴰⵏ ⵙ ⴵⵉⵍⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("H15_8","082_5_8","1TH","5","8","8","ⵎⴰⵛⴰ ⴻⵊⵊ ⴰⵏⴻⵖ, ⵏⴻⵛⵛⵉⵏ ⵉ ⵢⴻⴵⴰⵏ ⴷ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵡⴰⵙⵙ, ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵃⴹⴰ ⴷⴻⴳ ⵉⵅⴰⵔⵉⵚⵚⴻⵏ ⵏⵏⴻⵖ, ⴰⴷ ⵏⵃⴻⵣⵣⴻⵎ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵏⴻⵖ ⵙ ⵡⴰⵔⵔⵓⴹ ⵏ ⵡⵓⵣⵣⴰⵍ ⵏ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵢⵔⵉ, ⵓ ⴰⴷ ⵏⴻⵙⵙⴰⵔⵙ ⵍⴽⴰⵙⴽ ⵏ ⵓⵙⵉⵜⴻⵎ ⵏ ⵜⵓⴷⴰⵔⵜ ⵅ ⵓⵣⴻⴵⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("H15_9","082_5_9","1TH","5","9","9","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵢⴻⴳⴳⵉ ⵉ ⵡⴻⵖⴹⴰⴱ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("H15_10","082_5_10","1TH","5","10","10","ⵡⴻⵏⵏⵉ ⵅⴰⵏⴻⵖ ⵉⵎⵎⵓⵜⴻⵏ, ⵃⵉⵎⴰ ⵏⴻⵛⵛⵉⵏ, ⵎⴰ ⵏⴼⴰⵇ ⵏⵉⵖ ⵏⴻⵟⵟⴻⵚ, ⴰⴷ ⴽⵉⴷⴻⵙ ⵏⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("H15_11","082_5_11","1TH","5","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⴳⴳⴻⵎ ⵓⵍ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ, ⴱⵏⴰⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵜ ⵜⴻⴳⴳⵉⵎ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("H15_12","082_5_12","1TH","5","12","12","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵔ ⵣⵣⴰⵢⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵣⴻⵎⵎⴰⵔ ⴰⵟⵟⴰⵙ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷ ⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⴵⴰⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵍⵎⴰⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("H15_13","082_5_13","1TH","5","13","13","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜⵡⴻⵇⵇⴰⵔⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⵜᵉⵜⵜⴻⵎⵎⵍⴻⵎ ⵜⴰⵢⵔⵉ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵓⵛⴰ ⴰⴷ ⵜⴻⵃⴹⴰⵎ ⵍⴻⵀⵏⴰ ⴰⴽⵉⴷⵙⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H15_14","082_5_14","1TH","5","14","14","ⵏⴻⵄⵍⴻⵎ ⴰⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⴷ ⵜⵙⴻⴳⴳⵎⴻⵎ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⴳⴳⴻⵎ ⵓⵍ ⴷⴻⴳ ⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⵉ ⵜⴻⵔⵢⴰⵙⵜ, ⴰⵔⴱⵓⵎ ⴷⴷⵇⴻⵍ ⵏ ⵢⵉⵏⵏⵉ ⵉⴹⴻⵄⴼⴻⵏ, ⵉⵍⵉⵎ ⴷ ⵉⵚⴻⴱⴱⴰⵔⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("H15_15","082_5_15","1TH","5","15","15","ⵃⴹⴰⵎ ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⴻⵏⵜⵉⵇⵉⵎ ⵍⵖⴰⵔ ⵙ ⵍⵖⴰⵔ, ⵎⴰⵛⴰ ⴰⵔⵣⵓⵎ ⵍⴻⴱⴷⴰ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ ⵓⵛⴰ ⵉ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("H15_16","082_5_16","1TH","5","16","16","ⴼⴰⵔⵃⴻⵎ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("H15_17","082_5_17","1TH","5","17","17","ⵥⵥⴰⴵⴻⵎ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ");
INSERT INTO rift_vpl VALUES ("H15_18","082_5_18","1TH","5","18","18","ⵇⴰⴷⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ, ⵎⵉⵏⵣⵉ ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("H15_19","082_5_19","1TH","5","19","19","ⵡⴰⵔ ⵙⵙⵅⴻⵙⵙⵢⴻⵎ ⵛⴰ ⴰⵔⵔⵓⵃ, ");
INSERT INTO rift_vpl VALUES ("H15_20","082_5_20","1TH","5","20","20","ⵡⴰⵔ ⵙⵙⴻⵃⵇⴰⵔⴰⵎ ⴰⵡⴰⵍⴻⵏ ⵏ ⵏⵏⵓⴱⵓⵡⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("H15_21","082_5_21","1TH","5","21","21","ⵡⴻⵣⵏⴻⵎ ⵇⴰⵄ ⵎⵉⵏ ⵉⴵⴰⵏ ⵓⵛⴰ ⵟⵟⴼⴻⵎ ⵖⴰⵔ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H15_22","082_5_22","1TH","5","22","22","ⴰⴳⴳⵯⴻⵊⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴷⴰⴱ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("H15_23","082_5_23","1TH","5","23","23","ⵉⵍⵉ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵀⵏⴰ ⵎⴰⵔⵔⴰ ⵓⵛⴰ ⴰⴷ ⵉⵃⴹⴰ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵓⵃ ⴷ ⵍⴻⵄⵎⴰⵔ ⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵡⴻⵎ ⴱⵍⴰ ⵍⵄⵉⴱ ⴰⵍ ⵜⴰⵡⴰⵙⵉⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("H15_24","082_5_24","1TH","5","24","24","ⴰⵇⴰ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⵍⴰⵖⴰⵏ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜ ⵉⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("H15_25","082_5_25","1TH","5","25","25","ⴰ ⴰⵢⵜⵎⴰ, ⴽⵙⵉⵎ ⴰⵏⴻⵖ ⵍⵎⴻⵄⵔⵓⴼ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("H15_26","082_5_26","1TH","5","26","26","ⵙⴻⴵⵎⴻⵎ ⵅ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ ⵙ ⵓⵙⵓⴷⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H15_27","082_5_27","1TH","5","27","27","ⵏⴻⵛⵛ ⵙⵙⵊⵓⴵⴻⵖ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵖⴰⵔⴻⵎ ⵜⴰⴱⵔⴰⵜ-ⴰ ⵉ ⵎⴰⵔⵔⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H15_28","082_5_28","1TH","5","28","28","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("H21_1","083_1_1","2TH","1","1","1","ⴱⵓⵍⵓⵙ ⴷ ⵙⵉⵍⵡⴰⵏⵓⵙ ⴷ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⵉⵢⵢⴻⵏ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("H21_2","083_1_2","2TH","1","2","2","ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴽⵉⵡⴻⵎ ⵉⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("H21_3","083_1_3","2TH","1","3","3","ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵏⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵍⴻⴱⴷⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵍⵉⵇ, ⵎⵉⵏⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⵉⵎⴻⵇⵇⴰⵔ ⴰⵟⵟⴰⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵜⴰⵢⵔⵉ ⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵎⴰⵔⵔⴰ ⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ ⵜⴰⵔⴻⵏⵏⵉ ⵜⵎⴻⵇⵇⴰⵔ ⴽⵜⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("H21_4","083_1_4","2TH","1","4","4","ⴰⵍ ⵏⴻⵜⵜⴼⴻⵢⵢⴻⵛ ⵅⴰⵡⴻⵎ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⴷ ⵚⵚⴱⴰⵔ ⵏⵡⴻⵎ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⴷⴰⵔⵔⴻⵛ ⵏⵡⴻⵎ ⴷ ⵍⴻⵎⵃⴰⵢⴻⵎ ⵏⵡⴻⵎ ⵏⵏⵉ ⵜⴻⴽⵙⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("H21_5","083_1_5","2TH","1","5","5","ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴱⵓⵔⵀⴰⵏ ⵏ ⵍⵃⵓⴽⵎ ⵉⵙⵙⴻⴳⴳⴷⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵃⴰⵙⴱⴻⵎ ⵜⴻⵙⴷⴰⵀⴻⴵⴻⵎ ⵜⴰⴳⴻⵍⴷⵉⵜ, ⵜⴻⵏⵏⵉ ⵅⴻⴼ ⵜⴻⴽⵙⵉⵎ ⴰⵎⴰⵔⵔⴻⵜ.    ");
INSERT INTO rift_vpl VALUES ("H21_6","083_1_6","2TH","1","6","6","ⵓ ⵎⴰⵍⴰ ⵅⴻⵏⵏⵉ ⴷ ⵍⵃⴻⵇⵇ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵎⵉ ⵖⴰ ⵉⵅⴻⴵⴻⵚ ⵙ ⵍⵎⴻⵃⵏⴻⵜ ⵉ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵃⴻⵚⵚⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("H21_7","083_1_7","2TH","1","7","7","ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵉⵙⵙⴻⴷⴷⴰⵔ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵡⴰⵀ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⴷⴷⴰⵔ ⴰⴽⵉⴷⵡⴻⵎ ⵖⴰⵔ ⵓⵙⴰⵔⴳⴻⴱ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("H21_8","083_1_8","2TH","1","8","8","ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵏⵜⴰⵇⴻⵎ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵅⵙⴻⵏ ⴰⴷ ⵛⴻⵀⴷⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("H21_9","083_1_9","2TH","1","9","9","ⵎⵉⵏⵣⵉ ⵉⵏⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴰⵇⴱⴻⵏ ⴷⵉ ⵍⵃⵓⴽⵎ ⵙ ⵓⵀⴻⵍⵍⴻⴽ ⵉ ⵍⴻⴱⴷⴰ ⴰⵎ ⵢⴰⴳⴳⵡⴻⵊⴻⵏ ⵅ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓ ⵅ ⵓⵄⵓⴵⵉ ⵏ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("H21_10","083_1_10","2TH","1","10","10","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵏⴻⵜⵜⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵄⵓⴵⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵏⵏⴻⵙ ⵙ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵢⵓⵎⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵎⵏⴻⵎ ⵣⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵖ ⵉ ⴽⴻⵏⵏⵉⵡ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("H21_11","083_1_11","2TH","1","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴽⴻⵙⵙⵉ ⴰⵡⴻⵎ ⵍⵎⴻⵄⵔⵓⴼ ⵍⴻⴱⴷⴰ, ⵃⵉⵎⴰ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵢⴻⴳⴳ ⴰⴷ ⵜⴻⵙⴷⴰⵀⴻⴵⴻⵎ ⵜⴰⵍⴰⵖⵉⵜ ⵏⵡⴻⵎ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵛⵛⵓⵔ ⵙ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⵡⴻⵊⴷⴻⵎ ⵇⴰⵄ ⵉ ⵜⵎⴻⴳⴳⴰ ⵏ ⵜⵛⵓⵏⵉ ⵓ ⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵍ’ⵉⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("H21_12","083_1_12","2TH","1","12","12","ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵜⵜⵡⴰⵄⵓⴵⵉ ⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴰⵢⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("H22_1","083_2_1","2TH","2","1","1","ⴰⵇⴰ ⵏᵉⵜⵜⵣⴰⵡⴻⴳ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵜⵡⴰⵙⵉⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵡⴻⵙⵎⵓⵏⵉ ⵏⵏⴻⵖ ⵖⴰⵔⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("H22_2","083_2_2","2TH","2","2","2","ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵏⵉⵖ ⵜⴻⵙⵃⵉⵙⵙⴼⴻⵎ ⵛⴰ ⴷⴻⵖⵢⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵏⵉⵖ ⵙ ⵛⴰ ⵏ ⴰⵔⵔⵓⵃ ⵏⵉⵖ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⴱⵔⴰⵜ ⴰⵅⵎⵉ ⵣⵣⴰⵢⵏⴻⵖ, ⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵅⵣⴰⵔ, ⴰⵙⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⵓⵙⴰ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("H22_3","083_2_3","2TH","2","3","3","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵖⵡⴰ ⵙ ⵛⴰ ⵏ ⵡⴻⴱⵔⵉⴷ, ⵎⵉⵏⵣⵉ ⴰⵙⵙ ⵏⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵓⵖⴻⵡⵡⴻⵖ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⴱⵏⴰⴷⴻⵎ ⵏ ⴷⴷⵏⵓⴱ, ⴰⵇⴰ-ⵜ ⴷ ⵎⵎⵉⵙ ⵏ ⵜⴻⵀⵍⵉⴽⴻⵜ.    ");
INSERT INTO rift_vpl VALUES ("H22_4","083_2_4","2TH","2","4","4","ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵎⵄⴰⵍⴰ ⵓ ⵉⵙⵙⵄⵓⴵⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵙⴻⵎⵎⴰⵏ ‘ⴰⵔⴻⴱⴱⵉ’ ⵏⵉⵖ ‘ⴰⵄⴱⴰⴷ’, ⴰⵍ ⵖⴰ ⵉⵇⵇⵉⵎ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵛⵏⴰⵡ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⴻⴵⴰ, ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⵅⵎⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("H22_5","083_2_5","2TH","2","5","5","ⵎⴰ ⵡⴰⵔ ⵜⴻⵄⵇⵉⵍⴻⵎ ⵛⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵢⵉ ⴽⵉⵡⴻⵎ, ⴰⵇⴰ ⵏⵏⵉⵖ ⴰⵡⴻⵎ-ⵜ? ");
INSERT INTO rift_vpl VALUES ("H22_6","083_2_6","2TH","2","6","6","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜⵉⵡⴹⴻⵎ ⵜⴻⵙⵙⵏⴻⵎ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⴱⴻⴷⴷⴻⵏ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⴱⴰⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("H22_7","083_2_7","2TH","2","7","7","ⵙⵙⵉⵔⵔ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⵇⴰ ⵉⵅⴻⴷⴷⴻⵎ ⵍⴻⵅⵅⵓ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵎⵎⴻⴽⵙⵉ ⵣⵉ ⵍⵡⴻⵙⵟ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵙⵙⴱⴻⴷⴷⴻⵏ ⵄⴰⴷ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵍⴻⵅⵅⵓ, ");
INSERT INTO rift_vpl VALUES ("H22_8","083_2_8","2TH","2","8","8","ⴰⴷ ⴷⴷ-ⵉⴹⵀⴰⵔ ⴱⴰⴱ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵡⴻⵏⵏⵉ ⵖⴰ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵙ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵏⵏⴻⴼⵙ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵜ ⵉⵙⵙⴻⴱⴹⴻⵍ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴱⴰⵏ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("H22_9","083_2_9","2TH","2","9","9","ⵎⴰⵖⴰⵔ ⵜⴰⵡⴰⵙⵉⵜ ⵏ ⴱⴰⴱ ⵏⵏⵉ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴰⴷ ⵜⵔⴰⵃ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵛⵛⵉⵟⴰⵏ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ ⴷ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("H22_10","083_2_10","2TH","2","10","10","ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵍⵖⴻⵛⵛ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷⴻⴳ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵀⴻⵍⵍⴽⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵇⴱⵉⵍⴻⵏ ⵛⴰ ⵜⴰⵢⵔⵉ ⵏ ⵜⵉⴷⴻⵜⵜ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⴰⴼⴻⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("H22_11","083_2_11","2TH","2","11","11","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⴷⴷ-ⵉⵙⵙⴻⴽⴽ ⵎⵉⵏ ⵜⴻⵏ ⵖⴰ ⵢⴰⵔⵔ ⵙ ⵊⵊⴻⵀⴷ ⵖⴰⵔ ⵓⵡⴻⴷⴷⴰⵔ, ⴰⵍ ⵖⴰ ⵢⴰⵎⵏⴻⵏ ⴷⴻⴳ ⵓⵅⴰⵔⵔⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("H22_12","083_2_12","2TH","2","12","12","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵉⵅⵙⴻⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴽⵜⴰⵔ, ⴰⴷ ⵜⵜⵡⴰⵃⴰⴽⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H22_13","083_2_13","2TH","2","13","13","ⵎⴰⵛⴰ ⵉⵛⵓⵡⵡⴰⵔ ⴰⵏⴻⵖ ⴰⴷ ⵏⵇⴰⴷⴰ ⴰⵔⴻⴱⴱⵉ ⵍⴻⴱⴷⴰ ⵅⴰⵡⴻⵎ, ⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ, ⵉⵏⵏⵉ ⵅⴻⴼ ⵉⵄⵉⵣⵣ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵅⴹⴰⵔ ⵉ ⴽⴻⵏⵏⵉⵡ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵜⵓⴷⴰⵔⵜ, ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵣⵉ ⴰⵔⵔⵓⵃ ⵓ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("H22_14","083_2_14","2TH","2","14","14","ⴰⵇⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵓⴱⴰⵔⵔⴻⵃ ⵏⵏⴻⵖ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵉ ⵓⵄⵓⴵⵉ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("H22_15","083_2_15","2TH","2","15","15","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⵟⵟⴼⴻⵎ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⵏ ⵣⵣⴰⵢⵏⴻⵖ, ⵎⴰ ⵙ ⵡⴰⵡⴰⵍ ⵏⵉⵖ ⵙ ⵜⴻⴱⵔⴰⵜ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("H22_16","083_2_16","2TH","2","16","16","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ, ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵅⵙⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴻⵏ ⴰⴼⴻⵡⵡⴻⵊ ⵉⵜⵜⴷⵓⵎⴰⵏ ⴷ ⵓⵙⵉⵜⴻⵎ ⵉⵛⵏⴰⵏ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("H22_17","083_2_17","2TH","2","17","17","ⴰⴷ ⵉⵙⵙⴼⴻⵡⵡⴻⵊ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵊⵀⴻⴷ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵡⴰⵍ ⵓ ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("H23_1","083_3_1","2TH","3","1","1","ⴰ ⴽⴻⵏⵏⵉⵡ, ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ, ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⴽⵙⵉⵎ ⴰⵏⴻⵖ ⵍⵎⴻⵄⵔⵓⴼ ⵃⵉⵎⴰ ⴰⵡⴰⵍ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⴷⴻⵖⵢⴰ ⵓ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⵄⵓⴵ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵎⵙⴰⵔ ⵊⴰⵔ ⴰⵡⴻⵎ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("H23_2","083_3_2","2TH","3","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⴼⴻⴽⴽ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("H23_3","083_3_3","2TH","3","3","3","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ. ⵏⴻⵜⵜⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵃⴹⴰ ⵓⵛⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴼⴻⴽⴽ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("H23_4","083_3_4","2TH","3","4","4","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵉⵇⵇ ⴷⴰⵢⵡⴻⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴱⴻⵍⵍⵉ ⵎⵉⵏ ⵅⴻⴼ ⵏⵡⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ, ⴰⵇⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵜ ⵓⵛⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵜ. ");
INSERT INTO rift_vpl VALUES ("H23_5","083_3_5","2TH","3","5","5","ⴰⴷ ⵉⵏⴷⴻⵀ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵖⴰⵔ ⵓⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("H23_6","083_3_6","2TH","3","6","6","ⵏⵡⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵜⵃⴻⵢⵢⴷⴻⵎ ⵉ ⴽⵓⵍ ⵓⵎⴰ ⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵉ ⵣⵣⴰⵢⵏⴻⵖ ⵉⴽⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("H23_7","083_3_7","2TH","3","7","7","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⴰⵏⴻⵖ ⵜⴻⴹⴼⴰⵔⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⵓⵢⵓⵔ ⵊⴰⵔ ⴰⵡⴻⵎ ⴷⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("H23_8","083_3_8","2TH","3","8","8","ⵡⴰⵔ ⵏⴻⵛⵛⵉ ⴰⵖⵔⵓⵎ ⴰⴽ-ⴷ ⵃⴻⴷ ⴱⴰⵟⴻⵍ, ⵎⴰⵛⴰ ⵙ ⵍⵅⴻⴷⵎⴻⵜ ⴷ ⵜⴰⵎⴰⵔⴰ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵏⵅⴻⴷⴷⴻⵎ ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵏⴻⵜⵜⵉⵙ ⵏⴻⴷⵇⴻⵍ ⵅ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H23_9","083_3_9","2TH","3","9","9","ⵡⴰⵔ ⵉⴵⵉ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵜⵜⴻⵙⵔⵉⵃ ⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴷ ⵍⵎⵉⵜⴰⵍ ⵉ ⵖⴰ ⵜⴻⴹⴼⴰⵔⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("H23_10","083_3_10","2TH","3","10","10","ⵎⵉⵏⵣⵉ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⵏⴻⴵⴰ ⴰⴽⵉⴷⵡⴻⵎ, ⴰⵇⴰ ⵏⵡⴻⵚⵚⴰ ⴰⵎⵎⵓ: ⵎⴰⵍⴰ ⵃⴻⴷ ⵡⴰⵔ ⵉⵅⵙ ⴰⴷ ⵉⵅⴷⴻⵎ, ⵡⴰⵔ ⵉⵜⵜⴻⵜⵜ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("H23_11","083_3_11","2TH","3","11","11","ⵎⵉⵏⵣⵉ ⵏⴻⵙⵍⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵎⵉⵏ ⵉⵄⴻⴼⴼⵏⴻⵏ, ⵡⴰⵔ ⵅⴻⴷⴷⵎⴻⵏ ⵇⴰⵄ, ⵎⴰⵛⴰ ⵜⵜⴻⴳⴳⴻⵏ ⵎⵖⵉⵔ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴽⴽⵡⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("H23_12","083_3_12","2TH","3","12","12","ⴰⵇⴰ ⵏⵓⵎⵓⵔ ⵓ ⵏⵣⵉⵢⵢⴰⵔ ⵉ-ⵜⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴷⵎⴻⵏ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⴰⴷ ⵛⵛⴻⵏ ⴰⵖⵔⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("H23_13","083_3_13","2TH","3","13","13","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⵜⵓⵃⵉⵍⴻⵎ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵛⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("H23_14","083_3_14","2TH","3","14","14","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵟⴰⵄ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵢⵓⵔⴰⵏ ⴷⵉ ⵜⴻⴱⵔⴰⵜ-ⴰ, ⴱⴹⴰⵎ ⵅⴰⵙ, ⵡⴰⵔ ⵜⵜⵅⴻⴵⴰⴹⴻⵎ ⵛⴰ ⴰⴽⵉⴷⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵜⵜⵙⴻⴹⵃⴰ, ");
INSERT INTO rift_vpl VALUES ("H23_15","083_3_15","2TH","3","15","15","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜ ⵜᵉⵜⵜⵃⴻⵙⵙⴱⴻⵎ ⴷ ⵍⴻⵄⴷⵓ ⵎⴰⵛⴰ ⵏⴻⴷⵀⴻⵎ ⵜ ⵖⴰⵔ ⵡⴻⴱⵔⵉⴷ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵜⴰⵡⵎⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("H23_16","083_3_16","2TH","3","16","16","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵏ ⵍⴻⵀⵏⴰ ⴰⴷ ⴰⵡⴻⵎ ⵉⵡⵛ ⵍⴻⵀⵏⴰ ⵉ ⵍⴻⴱⴷⴰ ⵅ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("H23_17","083_3_17","2TH","3","17","17","ⵉⵊⵊ ⵏ ⵓⵙⴻⴵⴻⵎ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ. ⵏⴻⵛⵛ, ⴱⵓⵍⵓⵙ, ⵓⵔⵉⵖ ⴰⵢⴰ. ⵜⴰ ⴷ ⵍⴻⵄⵍⴰⵎⴻⵜ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵉⵏⵓ. ⴰⵎⵎⵓ ⵉ ⴷ ⵓⵔⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("H23_18","083_3_18","2TH","3","18","18","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⴰⴽⵉⴷⵡⴻⵎ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ, ⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵓ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_1","084_1_1","1TI","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ⵓ ⵏ ⵍⵎⴰⵙⵉⵃ ⵢⴰⵙⵓⵄ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ.    ");
INSERT INTO rift_vpl VALUES ("T11_2","084_1_2","1TI","1","2","2","ⵉ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵎⵎⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷⵉ ⵍ’ⵉⵎⴰⵏ: ⴰⵔⴹⴰ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴰⵛ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵍⵎⴰⵙⵉⵃ ⵢⴰⵙⵓⵄ, ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("T11_3","084_1_3","1TI","1","3","3","ⵍⴰⵎⵉ ⵔⵓⵃⴻⵖ ⵖⴰⵔ ⵎⴰⴽⵉⴷⵓⵏⵉⵢⴰ ⵣⴰⵡⴳⴻⵖ ⵛⴻⴽ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⴷ ⴷⵉ ⴰⴼⴰⵙⵓⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵓⵎⵓⵔⴻⴷ ⵉ ⵛⴰ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵃⵉⵎⴰ ⵡⴰⵔ ⵙⵙⴻⵍⵎⵉⴷⴻⵏ ⵛⴰ ⵉⵙⴻⵍⵎⴰⴷⴻⵏ ⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("T11_4","084_1_4","1TI","1","4","4","ⵓ ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵛⴻⵏ ⵛⴰ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵃⵓⵊⴰ ⵉⵅⵡⴰⵏ ⴷ ⵜⴰⵚⵉⵍⴰⵜ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵉⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵉⵎⵃⴰⵔⵡⴰⴹⴻⵏ ⴽⵜⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⵖⴰⵔ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⵍⴻⴱⵏⵉ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("T11_5","084_1_5","1TI","1","5","5","ⵙⵙⵓⵎ ⵏ ⵜⵡⴻⵚⵚⴰ ⴰⵇⴰ ⴷ ⵜⴰⵢⵔⵉ ⵣⴻⴳ ⵡⵓⵍ ⴰⵎⴻⵣⴷⴰⴳ ⴷ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵉⵛⵏⴰⵏ ⵓ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T11_6","084_1_6","1TI","1","6","6","ⴰⵇⴰ ⴷⵉⵏⵏⵉ ⵛⴰ ⵉⵏⵏⵉ ⵉⵀⴻⵢⵢⴹⴻⵏ ⵅ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵏⵏⵇⴻⵍⴱⴻⵏ ⵖⴰⵔ ⵍⵀⴰⵔⴷ ⵉⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_7","084_1_7","1TI","1","7","7","ⵏⵉⵜⵏⵉ ⵅⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⴱⵍⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷⵉ ⵎⵉⵏ ⵇⵇⴰⵔⴻⵏ ⵓ ⵅ ⵎⵉⵏ ⵅⴻⴼ ⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_8","084_1_8","1TI","1","8","8","ⵎⴰⵛⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⵚⴱⴻⵃ ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵊⵊⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵣⵣⴰⵢⴻⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ, ");
INSERT INTO rift_vpl VALUES ("T11_9","084_1_9","1TI","1","9","9","ⴰⵎ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵔ ⵜⴻⵎⵎⴻⵡⵛ ⵛⴰ ⵉ ⵓⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵓ ⵉ ⵉⵎⵖⴻⵡⵡⴰⵖⴻⵏ, ⵉ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⵉⵎⴻⴷⵏⴰⴱ, ⵉ ⵉⵎⴻⵇⵊⴰⵃ, ⵉ ⵉⵎⴻⵅⵎⵓⵊⴻⵏ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵡⵜⵉⵏ ⴱⴰⴱⴰⵜⵙⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵡⵜⵉⵏ ⵢⴻⵎⵎⴰⵜⵙⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("T11_10","084_1_10","1TI","1","10","10","ⵉ ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵣⵣⵡⴰⵎⴻⵍ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴷⴻⴳ ⵉⵡⴷⴰⵏ, ⵉ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⵥⵥⴰⵏ ⵜⴰⵊⴰⴵⵉⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⵣⴻⵄⵎⴰ ⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙⴻⵏ ⵛⴰ ⴰⴽ-ⴷ ⵓⵙⴻⵍⵎⴻⴷ ⵉⵚⴻⵃⵃⴻⵏ ");
INSERT INTO rift_vpl VALUES ("T11_11","084_1_11","1TI","1","11","11","ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵡⴻⴽⴽⵍⴻⵏ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_12","084_1_12","1TI","1","12","12","ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⵊⴻⵀⴷⴻⵏ, ⴰⵇⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓⵎⵉ ⵉⵃⵙⴻⴱ ⴰⵢⵉ-ⴷⴷ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵍⴰⵎⵉ ⴷ ⴰⵢⵉ ⵉⴳⴳⴰ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("T11_13","084_1_13","1TI","1","13","13","ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴵⴰⵏ ⵇⴱⴻⵍ ⴷ ⴰⵎⵛⴻⵇⵇⴰⴼ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴰⵔⵔⴰⵜ ⵏ ⵉⵎⴰⵙⵉⵃⵉⵢⵢⴻⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵓ-ⵍⵄⵓⵏⴼ. ⵎⴰⵛⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵢⵉ-ⴷⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⵎⵉⵏⵣⵉ ⴳⴳⵉⵖ ⵜ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵖ, ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵜⵓⵖⴰ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_14","084_1_14","1TI","1","14","14","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵜⵓⵖⴰ ⵉⴼⴻⵢⵢⴻⴹ ⴷⴰⵢⵉ ⵙ ⵡⴰⵟⵟⴰⵙ, ⵓⵍⴰ ⴷ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵢⵔⵉ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T11_15","084_1_15","1TI","1","15","15","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ, ⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵉⴳⴳⵓⵔ, ⴰⵇⴰ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵉⵎⴻⴷⵏⴰⴱ, ⵉⵏⵏⵉ ⵣⵣⴰⵢⵙⴻⵏ ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("T11_16","084_1_16","1TI","1","16","16","ⵎⴰⵛⴰ ⵅ ⵓⵢⴰ ⴽⵙⵉⵖ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵎⴰⵃⴻⵏⴷ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴷⴰⵢⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵎⴰⵔⵔⴰ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⴷ ⵍⵎⵉⵜⴰⵍ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⵖⴰ ⵢⴰⵎⵏⴻⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_17","084_1_17","1TI","1","17","17","ⴰⵇⴰ ⵉ ⵓⵊⴻⴵⵉⴷ ⵏ ⵣⵣⵎⴰⵏⴰⵜ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊ, ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵛⵛⴰⵏ ⴷ ⵓⵄⵓⴵⵉ ⵉ ⵣⵣⵎⴰⵏ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_18","084_1_18","1TI","1","18","18","ⵜⴰⵙⴻⵅⵅⴰⵔⵜ-ⴰ, ⴰ ⵎⵎⵉ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵙⵙⵡⴻⴽⴽⵍⴻⵖ ⵛⴻⴽ ⵅⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵏⵖⴻⴷ ⴰⵎⴻⵏⵖⵉ ⴰⵚⴻⴱⵃⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵅⴰⴽ ⵉⵜⵜⵡⴰⵏⴰⴱⴱⴻⵏ ⵇⴱⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("T11_19","084_1_19","1TI","1","19","19","ⵙ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵉⵛⵏⴰⵏ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵓⴳⵉⵏ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵙⵙⴻⵅⵡⴰⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵉ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T11_20","084_1_20","1TI","1","20","20","ⵊⴰⵔ ⴰⵙⴻⵏ ⵀⵉⵎⵉⵏⵉⵢⵓⵙ ⴷ ⴰⵍⵉⴽⵙⴰⵏⴷⵉⵔ, ⵉⵏⵏⵉ ⵙⴻⵍⵍⵎⴻⵖ ⵉ ⵛⵛⵉⵟⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T12_1","084_2_1","1TI","2","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵇⴰⵔⵔⴱⴻⵎ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵓⵜⵔⴰ ⴷ ⵜⵥⴰⴵⵉⵜⵉⵏ ⴷ ⵜⴽⴻⵙⵙⵉⵜ ⵙ ⵍⵎⴻⵄⵔⵓⴼ ⴷ ⵓⵇⴰⴷⵉ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("T12_2","084_2_2","1TI","2","2","2","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⴷⵉ ⵍⴻⵀⵏⴰ ⴷ ⵍⵀⵓⴷⵏⴻⵜ ⵓ ⵙ ⵎⴰⵔⵔⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵜⴻⵣⴷⵓⴳⵉ ⵣⵣⴰⵜ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("T12_3","084_2_3","1TI","2","3","3","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⴰⵚⴻⴱⵃⴰⵏ ⵓ ⵢⵓⵙⴰ ⴰⵙ-ⴷⴷ ⵉ ⵍⵅⴰⴹⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("T12_4","084_2_4","1TI","2","4","4","ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴷⴻⵡⵍⴻⵏ ⵖⴰⵔ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T12_5","084_2_5","1TI","2","5","5","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊ ⵏ ⵍⵡⴰⵙⵉⵜ ⵊⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵡⴷⴰⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("T12_6","084_2_6","1TI","2","6","6","ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⴰⵚⵍⴰⵃ ⵉ ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T12_7","084_2_7","1TI","2","7","7","ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵜⵡⴰⴳⴳⴻⵖ ⴷ ⴰⵎⴱⴰⵔⵔⴻⵃ ⴷ ⵔⵔⴰⵙⵓⵍ, ⴰⵇⴰ ⵇⵇⴰⵔⴻⵖ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵖ ⵛⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵎⵙⴻⵖⵖⴰⵔ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T12_8","084_2_8","1TI","2","8","8","ⵙ ⵓⵢⴰ ⵅⵙⴻⵖ ⴱⴻⵍⵍⵉ ⵉⵔⵢⴰⵣⴻⵏ ⴰⴷ ⵥⵥⴰⴵⴻⵏ ⴷⵉ ⵎⴽⵓⵍ ⴰⵎⵛⴰⵏ, ⴰⵎ ⵙⵙⴳⴻⵄⵄⴰⴷⴻⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⵙ ⵜⴻⵣⴷⵓⴳⵉ, ⴱⵍⴰ ⴰⵅⴻⵢⵢⴻⵇ ⴷ ⵓⵎⵛⵓⴱⴱⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("T12_9","084_2_9","1TI","2","9","9","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⴷ ⵢⴰⵔⴹⴻⵏⵜ ⵙ ⵓⵡⴻⵇⵇⴰⵔ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵣⴻⵀⵀⵊⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵔⵉⴷ ⵏ ⵍⴻⵃⵢⴰ ⵓ ⵏ ⵜⵙⴻⵅⵅⴰⵢⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵎⵓⴷⵉ ⵏ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵉⵖ ⵙ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⵙ ⵜⵢⴰⵇⵓⵜⵉⵏ ⵏⵉⵖ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵖⵍⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("T12_10","084_2_10","1TI","2","10","10","ⵎⴰⵛⴰ ⴰⴷ ⵣⴻⵀⵀⵊⴻⵏⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏⵜ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵢⵓⵙⴰ ⵅ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵏⴻⵊⴱⴰⴷⴻⵏ ⵖⴰⵔ ⵓⵡⴻⵇⵇⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("T12_11","084_2_11","1TI","2","11","11","ⴻⵊⵊ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⵍⵎⴻⴷ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ, ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵡⴰⴹⴻⵄⵜ, ");
INSERT INTO rift_vpl VALUES ("T12_12","084_2_12","1TI","2","12","12","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⵜⴰⵎⵖⴰⵔⵜ ⴰⴷ ⵜⴻⵙⵙⴻⵍⵎⴻⴷ ⵏⵉⵖ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵊⵊⴻⵀⴷ ⵅ ⵡⴻⵔⵢⴰⵣ, ⵎⴰⵛⴰ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("T12_13","084_2_13","1TI","2","13","13","ⵎⵉⵏⵣⵉ ⴰⴷⴰⵎ ⵉⵜⵜⵡⴰⴳⴳ ⴷ ⴰⵎⴻⵣⵡⴰⵔ, ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵃⴰⵡⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("T12_14","084_2_14","1TI","2","14","14","ⵓⵛⴰ ⴰⴷⴰⵎ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵖⴰⵔⵔ ⵛⴰ, ⵎⴰⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵔ, ⵅⴻⵏⵏⵉ ⵜⴻⵅⴹⴰ ⵅ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T12_15","084_2_15","1TI","2","15","15","ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴷⴷⴰⵔ ⵙ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵎⴰⵍⴰ ⵜⵜⵖⵉⵎⴰⵏ ⵏⵉⵜⵏⵉ ⵜⵜⵛⴻⴱⴱⴰⵔⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵢⵔⵉ ⴷ ⵜⵇⴻⴷⴷⴰⵙⵜ ⴷ ⵍⴻⵃⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("T13_1","084_3_1","1TI","3","1","1","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ: ⵎⴰⵍⴰ ⵉⵅⵙ ⵃⴻⴷ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵖⴰⵔ, ⴰⵇⴰ ⵉⵜⵜⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴻⵛⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("T13_2","084_3_2","1TI","3","2","2","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵓⵎⵖⴰⵔ ⴰⴷ ⵉⵜⵡⴰⴼ ⴱⵍⴰ ⵍⵄⵉⴱ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵔⵢⴰⵣ ⵏ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵖⴰⵔⴻⵙ ⴰⵎⴻⴽⴽⴻⵏ ⵏ ⵏⵏⴻⴼⵙ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵙⴻⵅⵅⴰⵢ, ⴰⴷ ⵉⴳⴳ ⵙ ⵓⵙⴻⵜⵜⴻⴼ, ⴰⴷ ⵢⴰⵔⴻⵃⵃⴻⴱ ⵙ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("T13_3","084_3_3","1TI","3","3","3","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⴰⵎⴻⵙⵛⴰⵔ ⵏⵉⵖ ⵉⵡⵡⴻⵜ ⴷⴻⵖⵢⴰ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵡⴰⴹⴻⵄ, ⵡⴰⵔ ⵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⴰⵇⴻⵣⵣⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("T13_4","084_3_4","1TI","3","4","4","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⴳⴳⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⵎⵍⵉⵃ ⵓⵛⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵚⴼⴰⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T13_5","084_3_5","1TI","3","5","5","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⵙⵓⵢⵓⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⴳⴳ ⴰⴷ ⵉⵃⴹⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("T13_6","084_3_6","1TI","3","6","6","ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⴰⵎⴻⵃⴹⴰⵔ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵓⴼⴼ ⵙ ⵍⴻⴼⵢⵓⵛ ⵓⵛⴰ ⴰⴷ ⵉⵡⴹⴰ ⴷⵉ ⵛⵛⵔⴻⵄ ⵏ ⵛⵛⵉⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T13_7","084_3_7","1TI","3","7","7","ⵄⴰⵡⴻⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⵚⵚⵓⵎⵄⴻⵜ ⵜⴻⵛⵏⴰ ⵖⴰⵔ ⵢⵉⵏⵏⵉ ⴷⵉ ⴱⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵅⴰⵙ ⵜⵜⵄⴻⵢⵢⵉⴱⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵡⴻⵟⵟⵉ ⵛⴰ ⴷⵉ ⵍⴻⴼⵅⵓⵅ ⵏ ⵛⵛⵉⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T13_8","084_3_8","1TI","3","8","8","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵄⴰⵡⴻⴷ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ, ⵡⴰⵔ ⵙⵙⵉⵡⵉⵍⴻⵏ ⵛⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵍⵙⴰⵡⴻⵏ, ⵡⴰⵔ ⵅⴻⵣⵣⴰⵔⴻⵏ ⵛⴰ ⵖⴰⵔ ⴱⵉⵏⵓ ⴰⵟⵟⴰⵙ, ⵡⴰⵔ ⴹⴻⵎⵎⵄⴻⵏ ⴷⵉ ⴰⵔⵔⴱⴻⵃ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T13_9","084_3_9","1TI","3","9","9","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙⴻⵏ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵙⵙⵉⵔⵔ ⵏ ⵍ’ⵉⵎⴰⵏ ⵙ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵜⴻⵚⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("T13_10","084_3_10","1TI","3","10","10","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴵⴱⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵍⴻⵅⴷⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵉⴱⴰⵏ-ⴷⴷ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜⵉⵍⵉ ⴱⵓ ⵍⵄⵉⴱ, ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T13_11","084_3_11","1TI","3","11","11","ⴰⵎⵎⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵓⵍⴰ ⵉ ⵜⵉⵎⵖⴰⵔⵉⵏ ⴰⴷ ⴰⵔⵙⵉⵏⵜ ⵙ ⵜⵙⴻⵅⵅⴰⵢⵜ, ⴰⴷ ⵃⴹⴰⵏⵜ ⴷⵉ ⵍⴻⵄⵇⵓⵍ ⵏⵙⴻⵏⵜ, ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵉⵍⵉ ⵍⵎⴰⵏⴻⵜ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵡⴰⵔ ⴷ ⵜⵜⵉⵍⵉⵏⵜ ⴷ ⵜⵉⵎⵛⴻⵇⵇⴰⴼⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T13_12","084_3_12","1TI","3","12","12","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⴰⵇⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵓⵛⴰ ⵉⵜⵜⵅⴻⵙⵚⴰ ⴰⵙ ⴰⴷ ⵉⵙⵙⵓⵢⵓⵔ ⵎⵍⵉⵃ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T13_13","084_3_13","1TI","3","13","13","ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⵢⵢⴰⵔⵜ ⵏⵙⴻⵏ ⵎⵍⵉⵃ, ⴰⴷ ⵟⵟⴼⴻⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵛⵏⴰ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⴻⵔⵢⴰⵙⵜ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T13_14","084_3_14","1TI","3","14","14","ⵓⵔⵉⵖ ⴰⵛ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("T13_15","084_3_15","1TI","3","15","15","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵄⴻⵟⵟⴰⵍⴻⵖ ⵅⴰⴽ, ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⴱⵉⵍⴰⵔ ⴷ ⴷⵙⴰⵙ ⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T13_16","084_3_16","1TI","3","16","16","ⵙⵙⵉⵔⵔ ⵡⴰⵏⵉⵜⴰ ⵏ ⵜⵙⴻⴳⴷⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵜⵉⴷⴻⵜⵜ! “ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴱⴻⵏ ⴷⵉ ⴷⴷⴰⵜ, ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴷⴻⵏ ⴷⵉ ⴰⵔⵔⵓⵃ, ⵉⴹⵃⴰⵔⴻⵏ-ⴷⴷ ⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵉⵜⵜⵡⴰⴱⴰⵔⵔⵃⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ, ⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵎⵎⴻⴽⵙⵉⵏ ⴷⴻⴳ ⵓⵄⵓⴵⵉ.” ");
INSERT INTO rift_vpl VALUES ("T14_1","084_4_1","1TI","4","1","1","ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵇⵇⴰⵔ ⵏⵉⵛⴰⵏ ⴱⴻⵍⵍⵉ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵛⴰ ⴰⴷ ⵃⴻⵢⵢⴷⴻⵏ ⵅ ⵍ’ⵉⵎⴰⵏ ⵓⵎⵉ ⵖⴰ ⴹⴼⴰⵔⴻⵏ ⵍⴰⵔⵢⴰⵃ ⵉⵙⵙⵖⴻⴽⴽⵡⴰⵏ ⴷ ⵜⵖⵓⵔⵉ ⵏ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T14_2","084_4_2","1TI","4","2","2","ⵏⵉⵜⵏⵉ ⵙⵖⴻⴽⴽⵡⴰⵏ ⴰⵎ ⵙⵙⵏⵉⵄⵎⵉⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵓ ⵜⵜⴻⵇⵇⴷⴻⵏ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T14_3","084_4_3","1TI","4","3","3","ⵏⵉⵜⵏⵉ ⵜⵜᵉⵟⵟⴼⴻⵏ ⵍⴻⵎⵍⴰⵛ ⵓⵛⴰ ⵜⵜⴰⵎⴰⵔⴻⵏ ⴰⵙⴱⴻⵄⵄⴻⴷ ⵅ ⵎⴰⵛⵛⴰ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵏⵏⴼⴻⵄ ⴷ ⵓⵇⴰⴷⵉ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵓ ⵙⵙⵏⴻⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T14_4","084_4_4","1TI","4","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵚⴱⴻⵃ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵎⵉⵏ ⵖⴰ ⵏⴰⴳⵉ ⵎⴰⵍⴰ ⵏⴻⵇⴱⴻⵍ ⵣⵣⴰⵢⴻⵙ ⵙ ⵓⵇⴰⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("T14_5","084_4_5","1TI","4","5","5","ⵎⵉⵏⵣⵉ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵥⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("T14_6","084_4_6","1TI","4","6","6","ⵎⴰⵍⴰ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵛ, ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵔⴻⴱⴱⵉⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵍ’ⵉⵎⴰⵏ ⵓ ⵜᵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⴷ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵚⵚⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("T14_7","084_4_7","1TI","4","7","7","ⵎⴰⵛⴰ ⴰⴳⴳⵯⴻⵊ ⵅ ⵜⵃⵓⵊⴰ ⵉⵅⵡⴰⵏ ⵏ ⵜⵡⴻⵙⵙⵓⵔⴰ ⵓ ⵎⴰⵔⵔⴻⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("T14_8","084_4_8","1TI","4","8","8","ⵎⵉⵏⵣⵉ ⴰⵔⵔⵉⵢⴰⴹⴰ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵜᵉⵜⵜⴰⵡⵉ ⵖⴰⵔ ⵏⵏⴼⴰⵄ ⵉ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵜⵏⴻⴼⴼⴻⵄ ⵍⴻⴱⴷⴰ, ⵓⵛⴰ ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵍⵡⴰⵄⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⵉⴹⴰ ⵓ ⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T14_9","084_4_9","1TI","4","9","9","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ, ⵉⵙⴷⴰⵀⴻⴵ ⴰⴷ ⵉⵜⵜⵡⴰⵇⴱⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("T14_10","084_4_10","1TI","4","10","10","ⵎⵉⵏⵣⵉ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵎⵉ ⵏⵅⴻⴷⴷⴻⵎ ⵓ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵃⵇⴰⵔⴰ ⵄⴰⵡⴻⴷ, ⵎⵉⵏⵣⵉ ⴰⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ ⴰⵇⴰ-ⵜ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T14_11","084_4_11","1TI","4","11","11","ⵙⴻⵍⵎⴻⴷ, ⵜⵓⵎⵓⵔⴻⴷ ⵙ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("T14_12","084_4_12","1TI","4","12","12","ⴻⵊⵊ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵛⴻⴽ ⵉⵙⵙⴻⵃⵇⵉⵔⵉ ⵛⴰ ⵅ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⵉⵍⵉ ⴷ ⵍⵎⵉⵜⴰⵍ ⵉ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ, ⵙ ⵡⴰⵡⴰⵍ, ⵙ ⵡⴻⵏⴷⴰⵀ, ⵙ ⵜⴰⵢⵔⵉ, ⵙ ⵍ’ⵉⵎⴰⵏ ⵓ ⵙ ⵜⴰⵣⴷⵓⴳⵉ. ");
INSERT INTO rift_vpl VALUES ("T14_13","084_4_13","1TI","4","13","13","ⵉⵍⵉ ⵜⴻⵛⴹⴰⵔⴻⴷ ⴷⵉ ⵜⵖⵓⵔⵉ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⴷⵉ ⵟⵥⴰⴵⵉⵜ ⵓ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("T14_14","084_4_14","1TI","4","14","14","ⵡⴰⵔ ⵙⵃⴻⵇⵇⴰⵔⴰ ⵛⴰ ⵜⴰⵡⵀⵉⴱⵜ ⵉ ⴷⴰⵢⴻⴽ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵛ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⴻⵏ ⵓ ⵙⵙⴰⵔⵙⴻⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵅⴰⴽ ⵉⴼⴰⵙⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T14_15","084_4_15","1TI","4","15","15","ⵄⵇⴻⵍ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵛⴻⴱⴱⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ, ⵃⵉⵎⴰ ⵜⵉⵛⵍⵉ ⵏⵏⴻⵛ ⵖⴰⵔ ⵣⵣⴰⵜ ⴰⴷ ⵜⴱⴰⵏ ⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("T14_16","084_4_16","1TI","4","16","16","ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵓ ⵃⴹⴰ ⵅ ⵓⵙⴻⵍⵎⴻⴷ, ⵚⴱⴰⵔ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⴷ ⴷⴷⴻⴳⴳⴰ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⴷ ⴰⵛ ⵉⵜⵜⴻⵙⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T15_1","084_5_1","1TI","5","1","1","ⵡⴰⵔ ⵜⵉⵍⵉⴷ ⵜⴻⵡⵄⴰⵔⴻⴷ ⵉ ⵓⵡⴻⵙⵙⴰⵔ, ⵎⴰⵛⴰ ⵏⴻⵙⵃ ⵉ-ⵜ ⴰⵎ ⴱⴰⴱⴰⵛ, ⵓⵛⴰ ⵉⴱⵍⵉⵖⴻⵏ ⴰⵎ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵛ, ");
INSERT INTO rift_vpl VALUES ("T15_2","084_5_2","1TI","5","2","2","ⵜⵉⵡⴻⵙⵙⵓⵔⴰ ⴰⵎ ⵜⵉⵢⴻⵎⵎⴰⵜⵉⵏ, ⵓⵛⴰ ⵜⵉⵄⴻⵣⵔⵉⵢⵢⵉⵏ ⴰⵎ ⵙⵓⵢᵉⵜⵎⴰⵛ ⵏⵏⴻⵛ, ⵙ ⵎⴰⵔⵔⴰ ⵍⴻⵚⴼⴰⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T15_3","084_5_3","1TI","5","3","3","ⵡⴻⵇⵇⴰⵔ ⵜⵉⵊⵊⴰⵍ, ⵜⵉⵏⵏⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⴵⴰⵏⵜ ⴷ ⵜⵉⵊⵊⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("T15_4","084_5_4","1TI","5","4","4","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵖⴰⵔⴻⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵉⵖ ⴰⵢⵢⴰⵡⴻⵏ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵍⴻⵎⴷⴻⵏ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵜⵜⵍⵉⵇⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍⴰⴵ ⵏⵙⴻⵏ, ⴰⴷ ⴷⴷ-ⴰⵔⵔⴻⵏ ⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵎⵉⵏ ⵜⵜⵓⵔⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⴷⴻⴳⴳⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵅ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("T15_5","084_5_5","1TI","5","5","5","ⵎⴰⵛⴰ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵉⵛⴰⵏ ⴷ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵡⴻⵃⵃⴷⴻⵙ, ⵜⴻⵙⵙⵉⵜⵉⵎ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵜⵚⴻⴱⴱⴰⵔ ⴷⵉ ⵜⵓⵜⵔⴰ ⴷ ⵜⵥⴰⴵⵉⵜⵉⵏ, ⴵⵉⵍⴻⵜ ⴷ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("T15_6","084_5_6","1TI","5","6","6","ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉ ⵉⵡⴹⴰⵏ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⵏⵏⴻⵛⵡⴻⵜ, ⴰⵇⴰ ⵜⴻⵎⵎⵓⵜ ⵡⴰⵅⵅⴰ ⵜⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("T15_7","084_5_7","1TI","5","7","7","ⵡⴻⵚⵚⴰ ⵉ-ⵜⴻⵏⵜ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏⵜ ⴱⵍⴰ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("T15_8","084_5_8","1TI","5","8","8","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵀⵉⵍⵍⵉ ⵛⴰ ⴷⵉ ⵡⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ, ⴷ ⴰⵎⴻⵡⴰⵔⵓ ⴷⴻⴳ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴼⴰⵎⵉⵍⵢⴰ ⵏ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵍ’ⵉⵎⴰⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵎⴰⵀⵓ ⵅ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("T15_9","084_5_9","1TI","5","9","9","ⵉⵅⴹⴰⵔ ⵅⴻⵏⵏⵉ ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵉⵍⵍⴰ ⵎⴰⵍⴰ ⵖⴰⵔⴻⵙ ⵣⵉ ⵙⴻⵜⵜⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵍ ⵜⵙⴰⵡⴻⵏⵜ, ⵉⵛⵜ ⵏ ⵜⴰⵊⵊⴰⵍⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ, ");
INSERT INTO rift_vpl VALUES ("T15_10","084_5_10","1TI","5","10","10","ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵛⵛⵀⴰⴷⴻⵜ ⴰⵇⴰ ⵜⴻⴳⴳⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ: ⵏⵉⵖ ⵜⴻⵙⵙⴻⵢⵎⵉ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵏⵉⵖ ⵜⴰⵔⴻⵃⵃⴻⴱ ⵙ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⵏⵉⵖ ⵜⴻⵙⵙⵉⵔⴻⴷ ⵉⴹⴰⵔⴻⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵏⵉⵖ ⵜⴻⵡⵛⴰ ⴼⵓⵙ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵡⴰⵀ, ⴰⵇⴰ ⵜⴻⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("T15_11","084_5_11","1TI","5","11","11","ⵎⴰⵛⴰ ⵡⴰⵔ ⵇⴻⴱⴱⴻⵍ ⵜⵉⵊⵊⴰⵍ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⵜⵜⴻⵅⵙⴻⵏⵜ ⴰⴷ ⵙⵙⴰⵔⵅⵓⵏⵜ ⵉ ⵍⵎⴰⵙⵉⵃ ⵙ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵙⴻⵏⵜ, ⴰⵔⴻⵣⵣⵓⵏⵜ ⵅ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ. ");
INSERT INTO rift_vpl VALUES ("T15_12","084_5_12","1TI","5","12","12","ⴰⵇⴰ ⵛⵛⵔⴻⵄ ⵏⵙⴻⵏⵜ ⵉⵎⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵙⵙⴰⵔⵙⴻⵏⵜ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏⵜ ⴰⵎⴻⵣⵡⴰⵔ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("T15_13","084_5_13","1TI","5","13","13","ⵎⴰⵖⴰⵔ ⵏⵉⵜⴻⵏⵜⵉ ⵙⵙⵍⴻⵎⴷⴻⵏⵜ ⵉⵏⵏⴻⵖⵏⵉ ⵍⴻⵄⵇⴻⵣ ⴰⵎ ⴳⴳⵓⵔⴻⵏⵜ ⵅ ⵜⵓⴷⵔⵉⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵙⵙⵍⴻⵎⴷⴻⵏⵜ ⵡⴰⵀⴰ ⵍⴻⵄⴳⴻⵣ, ⵎⴰⵛⴰ ⵏⵉⵜⴻⵏⵜⵉ ⵜⵜⵄⴰⵡⴰⴷⴻⵏⵜ ⵍⴻⵅⴱⵓⵔⴰⵜ, ⵜⵜⴰⴷⴼⴻⵏⵜ ⴷⵉ ⵛⵖⵓⵍⴰⵜ ⵏ ⵎⵉⴷⴷⴻⵏ, ⵇⵇⴰⵔⴻⵏⵜ ⵎⵉⵏ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T15_14","084_5_14","1TI","5","14","14","ⵙ ⵓⵢⴻⵏⵏⵉ ⵅⵙⴻⵖ ⴰⴷ ⵎⴻⵍⵛⴻⵏⵜ ⵜⵉⵊⵊⴰⵍ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⴰⴷ ⴷⴷ-ⵊⵊⴻⵏⵜ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⴰⴷ ⵙⵙⵓⵢⵓⵔⴻⵏⵜ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏⵜ ⵛⴰ ⵉ ⵍⴻⵄⴷⵓ ⵙⵙⵉⴱⴱⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴻⵇⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("T15_15","084_5_15","1TI","5","15","15","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴱⴷⴰⵏⵜ ⴰⴷ ⴼⴼⵖⴻⵏⵜ ⴰⴱⵔⵉⴷ, ⴹⴻⴼⴼⴰⵔⴻⵏⵜ ⵛⵛⵉⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T15_16","084_5_16","1TI","5","16","16","ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵉⵖ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵢⵓⵎⵏⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵊⵊⴰⵍ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵜⵀⵉⵍⵍⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷⴷⵇⴻⵍ ⵄⴰⴷ ⵅ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵃⵉⵎⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵄⴰⵡⴻⵏ ⵜⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⵊⵊⴰⵍ ⵙ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T15_17","084_5_17","1TI","5","17","17","ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⵉ ⵉⵜⵜⴹⴻⴱⴱⴰⵔⴰⵏ ⵎⵍⵉⵃ, ⵙⴷⴰⵀⴵⴻⵏ ⴰⵡⴻⵇⵇⴰⵔ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵎⵓⵔⴻⵏ, ⴰⴱⴻⵄⴷⴰ ⵉⵏⵏⵉ ⵉⵅⴻⴷⴷⵎⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵓ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("T15_18","084_5_18","1TI","5","18","18","ⵎⵉⵏⵣⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⵇⴰⵔⴻⵏⵜ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵜⴰⵛⵎⴰⵏⵜ ⵉ ⵓⵢⴻⵏⴷⵓⵣ ⵉⵙⵙⴰⵔⵡⴰⵜⴻⵏ!”, ⵓ: “ⴰⵅⴻⴷⴷⴰⵎ ⵉⵙⴷⴰⵀⴻⴵ ⵍⵎⵓⵏⴻⵜ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("T15_19","084_5_19","1TI","5","19","19","ⵡⴰⵔ ⵇⴻⴱⴱⴻⵍ ⵛⴰ ⵜⴰⵏⴼⵓⵍⵜ ⴹⵉⴷⴷ ⵉ ⵓⵎⵖⴰⵔ, ⵎⵖⵉⵔ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵛⵀⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("T15_20","084_5_20","1TI","5","20","20","ⵉⵏⵏⵉ ⵉⵅⴹⴰⵏ, ⵄⴻⵢⵢⴻⴱ ⵉ-ⵜⴻⵏ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⵉⵏⵏⴻⵖⵏⵉ ⴰⴷ ⴳⴳⵯⴻⴷⴻⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("T15_21","084_5_21","1TI","5","21","21","ⵣⵉⵢⵢⴰⵔⴻⵖ ⵅⴰⴽ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵎⴰⵏ ⴰⵢⴰ ⴱⵍⴰ ⵍⴼⴰⵔⵣ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T15_22","084_5_22","1TI","5","22","22","ⵡⴰⵔ ⵙⵙⵔⵓⵙⴰ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ ⵅ ⵃⴻⴷ ⵙ ⵓⵇⴻⴵⴻⵇ, ⵡⴰⵔ ⵛⴰⵔⵔⴻⵛ ⴷⵉ ⴷⴷⵏⵓⴱ ⵏ ⵉⵏⵏⴻⵖⵏⵉ, ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵍⴻⵚⴼⴰⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T15_23","084_5_23","1TI","5","23","23","ⵡⴰⵔ ⵙⴻⵙⵙ ⴰⵎⴰⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵙⵓ ⴷⵔⵓⵙ ⵏ ⴱⵉⵏⵓ ⵉ ⵙⵜⵓⵎⴰⵖⵓ ⵏⵏⴻⵛ ⵓ ⵉ ⵍⴻⵃⵍⴰⵛ ⵏⵏⴻⵛ ⴰⵣⵉⵔⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("T15_24","084_5_24","1TI","5","24","24","ⴰⵇⴰ ⴷⵉⵏ ⵉⵡⴷⴰⵏ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⴱⴰⵏⴻⵏ ⵎⵍⵉⵃ ⴷⴻⵖⵢⴰ, ⴰⵇⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵜⵜⵉⵣⵣⴰⵔⴻⵏ ⴰⵙⴻⵏ ⵖⴰⵔ ⵛⵛⵔⴻⵄ, ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵜⴻⵏ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T15_25","084_5_25","1TI","5","25","25","ⴰⵎⵎⵓ ⴷⴷ-ⴱⴰⵏⴻⵏⵜ ⵓⵍⴰ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ, ⵎⴰⵛⴰ ⵓⵍⴰ ⴷ ⵜⵉⵏⵏⵉ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴰⵎⵎⵓ, ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⵏⵏⵓⴼⴼⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("T16_1","084_6_1","1TI","6","1","1","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⴰⵣⴰⵢⵍⵓ ⵏ ⵜⴻⵙⵎⵓⵖⵉ ⴰⴷ ⵡⴻⵇⵇⴰⵔⴻⵏ ⴰⵢⵜⴱⴰⴱ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵓⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T16_2","084_6_2","1TI","6","2","2","ⴻⵊⵊ ⵉⵙⴻⵎⵖⴰⵏ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵎⴰⵙⴻⵏ ⵓⵎⵏⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵙⵙⴻⵃⵇⵉⵔⵉⵏ ⵛⴰ, ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴷ ⴰⵡⵎⴰⵜⴻⵏ ⵉ ⵉⴵⴰⵏ. ⵎⴰⵛⴰ ⵙ ⵍⵄⴻⴽⵙ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵎⵍⵉⵃ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵓⵎⵏⴻⵏ ⵓ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⴰⵡⵎⴰⵜⴻⵏ ⵉⵄⵉⵣⵣⴻⵏ, ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵅⴻⴷⴷⵎⴻⵏ ⵏⵉⵜⵏⵉ ⴷⵉ ⵍⴰⵎⴰⵏ. ⵙⴻⵍⵎⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⵓ ⵣⴻⵢⵢⴰⵔ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T16_3","084_6_3","1TI","6","3","3","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵏⵏⴻⵖⵏⵉ ⵓⵛⴰ ⵡⴰⵔ ⵢⴰⵔⴻⴷⴷⴻⴼ ⵛⴰ ⴰⵡⴰⵍⴻⵏ ⵉⵚⴻⵃⵃⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵜⵖⵓⵔⵉ ⵅ ⵎⴰⵎⵎⴻⵛ ⵉⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵏⴻⵄⴱⴻⴷ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("T16_4","084_6_4","1TI","6","4","4","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵓⴼⴼ ⴰⵎ ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵡⴰⵍⵓ, ⵉⵡⴻⴷⴷⴰⵔ ⴷⴻⴳ ⵉⵎⵃⴰⵔⵡⴰⴹⴻⵏ ⴷ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⵉ-ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⵍⴻⵃⵙⴻⴷ ⴷ ⵓⵎⴻⵏⵖⵉ ⴷ ⵓⵛⴻⵇⵇⴻⴼ ⴷ ⵉⵛⵜ ⵏ ⵏⵏⴻⵢⵢⴻⵜ ⴷ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ ");
INSERT INTO rift_vpl VALUES ("T16_5","084_6_5","1TI","6","5","5","ⵓⵍⴰ ⴷ ⵜⴰⵎⴰⵔⴰ ⵉ ⴷⴷ-ⵢⴻⴽⴽⵉⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴻⵛⵛⴻⵏ ⴷⵉ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⵜⵡⴻⴷⴷⴰⵔ ⴰⵙⴻⵏ ⵜⵜⵉⴷⴻⵜ, ⵉⵜⵜⵖⵉⵍ ⴰⵙⴻⵏ ⴰⵇⴰ ⴰⵔⴱⴻⵃ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⴱⴻⵄⵄⴻⴷ ⵅⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T16_6","084_6_6","1TI","6","6","6","ⵎⴰⵛⴰ ⴰⵔⴱⴻⵃ ⵏⵏⴻⵖ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⴰⵇⴰ-ⵜ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵖⴰⵔⵏⴻⵖ ⵎⵉⵏ ⵏⴻⵃⴷⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("T16_7","084_6_7","1TI","6","7","7","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⴷ-ⵏⵉⵡⵉ ⵡⴰⵍⵓ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⵡⴰⵔ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ ⵏⴻⴽⵙⵉ ⵡⴰⵍⵓ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T16_8","084_6_8","1TI","6","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵖⴰⵔⵏⴻⵖ ⵍⵎⴻⵄⵜⴻⵇ ⴷ ⴷⴷⵓⵔⵉ, ⴰⵇⴰ ⵏⴻⵇⵏⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("T16_9","084_6_9","1TI","6","9","9","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⴰⴳⵍⴰ, ⴰⴷ ⵡⴹⴰⵏ ⴷⴻⴳ ⵉⵊⴰⵔⵔⵉⴱⴻⵏ ⵓ ⴷⵉ ⵍⴻⴼⵅⵓⵅ ⵓ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵏⵏⴻⵛⵡⴰⵜ ⵜⵉⴼⵖⴰⵍ ⵉⵜⵜⴹⴰⵔⵔⴰⵏ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⴻⵊⵊⴰⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⵖⴰⵔⵇⴻⵏ ⴷⴻⴳ ⵓⵜⴻⵃⵃⵉ ⴷ ⵍⴻⴽⵃⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("T16_10","084_6_10","1TI","6","10","10","ⵎⵉⵏⵣⵉ ⴰⵥⵡⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⴰⵇⴰ ⵜ ⴷ ⵟⵟⵎⴻⵄ ⵏ ⵜⵎⴻⵏⵢⴰⵜ. ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵎⴻⵥⵍⵉⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵡⴻⴷⴷⴰⵔ ⴰⵙⴻⵏ ⵍ’ⵉⵎⴰⵏ ⵓⵛⴰ ⵊⴻⴱⴱⴷⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⴰⵎⴰⵔⴰ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T16_11","084_6_11","1TI","6","11","11","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴰ ⴱⵏⴰⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⵡⴻⵍ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⴰⵔⵣⵓ ⵅ ⵜⵙⴻⴳⴷⴰ, ⵅ ⵜⵏⵉⵛⴰⵏⵜ, ⵅ ⵍ’ⵉⵎⴰⵏ, ⵅ ⵜⴰⵢⵔⵉ, ⵅ ⵚⵚⴱⴰⵔ ⵓ ⵅ ⵜⴻⵎⵀⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("T16_12","084_6_12","1TI","6","12","12","ⵎⵏⴻⵖ ⴰⵎⴻⵏⵖⵉ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⵍ’ⵉⵎⴰⵏ, ⵛⴻⴱⴱⴰⵔ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵏⵏⵉ ⵓⵎⵉ ⵖⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵡⴰⵍⴰⵖⵉⴷ, ⵎⵉⵏ ⵅⴻⴼ ⵜⵛⴻⵀⴷⴻⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵣⵣⴰⵜ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵛⵀⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("T16_13","084_6_13","1TI","6","13","13","ⵛⴻⵀⵀⴷⴻⵖ ⵉ ⵛⴻⴽ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵎⴰⵔⵔⴰ, ⵓ ⵣⵣⴰⵜ ⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵜ ⵉ ⴱⵓⵏⵟⵉⵢⵓⵙ ⴱⵉⵍⴰⵟⵓⵙ, ");
INSERT INTO rift_vpl VALUES ("T16_14","084_6_14","1TI","6","14","14","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵃⴹⵉⴷ ⵜⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⴱⵍⴰ ⵙⵙⵓⵙⵙ ⵏⵉⵖ ⵍⵄⵉⴱ ⴰⵍ ⴷⴷ ⵖⴰ ⵉⴱⴰⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T16_15","084_6_15","1TI","6","15","15","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ: ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⴽⵓⵍⵛⵉ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ, ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵙⵉⴷⵉ ⵏ ⵉⵙⵉⴷⵉⵜⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("T16_16","084_6_16","1TI","6","16","16","ⵡⴻⵏⵏⵉ ⵡⴻⵃⵃⴷⴻⵙ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴼⴰⵡⵜ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⴰⴷⴻⴼ ⵃⴻⴷ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵥⵔⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵉⵖ ⵉⵣⴻⵎⵎⴰⵔ ⵄⴰⴷ ⴰⴷ ⵜ ⵉⵥⴰⵔ, ⵉ ⵏⴻⵜⵜⴰ ⵓⵎⵉ ⵖⴰⵔ ⵉⴵⴰ ⵛⵛⴰⵏ ⴷ ⵚⵚⵓⵍⵟⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T16_17","084_6_17","1TI","6","17","17","ⵄⵍⴻⵎ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⴷ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜⵛⴰⵍⴻⵏ ⵅ ⵡⴰⴳⵍⴰ ⵡⴰⵔ ⵢⴰⵔⴻⴽⴽⵏⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵜⵜⴻⵛⵍⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⴼⴻⵡⵡⴻⵊ, ");
INSERT INTO rift_vpl VALUES ("T16_18","084_6_18","1TI","6","18","18","ⵓⵛⴰ ⵄⵍⴻⵎ ⵉ-ⵜⴻⵏ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵍⵉⵏⵜ ⵜⵎⴻⴳⴳⴰ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ, ⴰⴷ ⵡⴻⵊⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵡⵛⴻⵏ ⵓ ⴰⴷ ⵛⴰⵔⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T16_19","084_6_19","1TI","6","19","19","ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⴰⵔⵙⴻⵏ ⴰⵎⵎⵓ ⴷⵙⴰⵙ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵍⵡⴻⵇⵜ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵜⵓⴷⴰⵔⵜ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T16_20","084_6_20","1TI","6","20","20","ⴰ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵃⴹⴰ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵜⵜⵡⴰⵡⴻⴽⴽⵍⴻⵏ, ⴰⴳⴳⵯⴻⵊ ⵅ ⵍⵀⴰⵔⴷ ⵉⵅⵡⴰⵏ ⵓⵍⴰ ⵅ ⵍⵄⴻⴽⴰⵙⴰⵜ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵜⵓⵙⵙⵏⴰ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T16_21","084_6_21","1TI","6","21","21","ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ ⵍⴰⵎⵉ ⵙⴻⵄⴼⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵙⴻⵎⵃⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ. ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ ⴰⵔⴹⴰ! ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T21_1","085_1_1","2TI","1","1","1","ⴱⵓⵍⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴰⵄⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⴷⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T21_2","085_1_2","2TI","1","2","2","ⵉ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵎⵎⵉ ⵉⵄⵉⵣⵣⴻⵏ: ⴰⵔⴹⴰ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍⴻⵀⵏⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("T21_3","085_1_3","2TI","1","3","3","ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵄⴻⴱⴷⴻⵖ ⴰⵎ ⵍⴻⵊⴷⵓⴷ ⵉⵏⵓ ⵙ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵜⴻⵣⴷⴻⴳ, ⴰⵎ ⵜⵜⵉⴷⴰⵔⴻⵖ ⵛⴻⴽ ⴱⵍⴰ ⵇⴻⵟⵟⵓ ⴷⵉ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵉⵏⵓ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T21_4","085_1_4","2TI","1","4","4","ⵡⴻⵃⵃⵛⴻⵖ ⴰⴷ ⵛⴻⴽ ⵥⴰⵔⴻⵖ, ⵅⵎⵉ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵖ ⴷⴻⴳ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵏⵏⴻⵛ ⵓ ⵜⵜⵡⴰⵛⵛⵓⵔⴻⵖ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("T21_5","085_1_5","2TI","1","5","5","ⵓⵎⵉ ⵜⵜⵉⴷⴰⵔⴻⵖ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⴱⵍⴰ ⵏⵏⵉⴼⴰⵇ, ⵍ’ⵉⵎⴰⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴰⵎⴻⵣⵡⴰⵔ ⴷⵉ ⵃⴻⵏⵏⴰⵛ ⵍⵓⵡⵉⵙ ⵓ ⴷⴻⴳ ⵢⴻⵎⵎⴰⵛ ⵓⵏⵉⴽⵉ, ⵓⵛⴰ, ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵏⵉⵛⴰⵏ ⴱⴻⵍⵍⵉ ⵉⵣⴷⴻⵖ ⴷⴰⵢⴻⴽ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("T21_6","085_1_6","2TI","1","6","6","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⵄⴻⵇⵍⴻⵖ ⵛⴻⴽ ⴰⴷ ⵜⴻⵙⵙⴻⴽⴽⴰⵔⴻⴷ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵏⵏⵉ ⴷⴰⵢⴻⴽ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⵡⴻⵙⵔⵓⵙⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵉⵏⵓ ⵅⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("T21_7","085_1_7","2TI","1","7","7","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉ ⴰⵔⵔⵓⵃ ⵏ ⵍⵄⵓⵔⵔⴻⵜ, ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵏ ⵊⵊⴻⵀⴷ ⴷ ⵜⴰⵢⵔⵉ ⴷ ⵓⵜⴻⴱⴱⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T21_8","085_1_8","2TI","1","8","8","ⵙ ⵓⵢⴰ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵡⵛⴻⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵅ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵓ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉ ⵣⵣⴰⵢⵉ ⵏⴻⵛⵛ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴽⵙⵉⵎ ⵎⴰⵔⵔⴰ ⵍⵖⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵍ’ⵉⵏⵊⵉⵍ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("T21_9","085_1_9","2TI","1","9","9","ⵡⴻⵏⵏⵉ ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⴰⵏⴻⵖ-ⴷⴷ ⵙ ⵜⵍⴰⵖⵉⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ ⴷ ⴰⵔⴹⴰ ⵏⵏⵉ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵇⴱⴻⵍ ⵍⵡⴻⵇⵜ ⵏ ⵣⵣⵎⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("T21_10","085_1_10","2TI","1","10","10","ⴰⵇⴰ ⴰⵔⴹⴰ-ⵢⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ ⵍⴻⵅⵅⵓ ⵙ ⵓⵅⴻⵛⵛⵉ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⴱⴻⴹⵍⴻⵏ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⵉⵙⵙⴻⴹⵀⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⵙ ⵍ’ⵉⵏⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("T21_11","085_1_11","2TI","1","11","11","ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴷⴻⵖ ⵏⴻⵛⵛ ⴷ ⴰⵎⴱⴰⵔⵔⴻⵃ ⴷ ⵔⵔⴰⵙⵓⵍ ⴷ ⵓⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("T21_12","085_1_12","2TI","1","12","12","ⵅ ⵙⵙⵉⴱⴱⴻⵜ-ⴰ ⵄⴰⵡⴻⴷ ⴽⵙⵉⵖ ⴰⵔⵎⴻⵃ ⵓ ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵖ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵣⵉ ⵜⵜⴰⵎⵏⴻⵖ ⵓⵛⴰ ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵖ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵃⴹⴰ ⵉ ⵏⴻⵛⵛ ⴰⴹⵎⴰⵏ ⵉⵏⵓ ⴰⵍ ⴰⵙⵙ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("T21_13","085_1_13","2TI","1","13","13","ⴻⵊⵊ ⴰⴷ ⵖⴰⵔⴻⴽ ⵉⵇⵇⵉⵎ ⵍⵎⵉⵜⴰⵍ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵚⴻⵃⵃⴻⵏ ⵉ ⵣⵣⴰⵢⵉ ⵜⴻⵙⵍⵉⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵢⵔⵉ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T21_14","085_1_14","2TI","1","14","14","ⵃⴹⴰ ⴰⴹⵎⴰⵏ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⴷ ⴰⵛ ⵉⵜⵜⵡⴰⵡⴻⴽⴽⵍⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⴷⴰⵢⵏⴻⵖ ⵉⵣⴻⴷⴷⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T21_15","085_1_15","2TI","1","15","15","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⴷ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴰⵙⵉⵢⴰ ⵊⵊⵉⵏ ⴰⵢⵉ, ⵣⵣⴰⵢⵙⴻⵏ ⴼⵉⵅⵉⵍⵓⵙ ⴷ ⵀⵉⵔⵎⵓⵅⵉⵏⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("T21_16","085_1_16","2TI","1","16","16","ⴰⴷ ⵢⴰⵔⵣⴻⴼ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵏⵉⵙⵉⴼⵓⵔⵓⵙ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵔⴻⵢⵢⴻⵃ ⴰⵢⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵙⴻⴹⵃⵉ ⵛⴰ ⵣⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵜⵎⴻⵃⴱⴰⵙⵜ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("T21_17","085_1_17","2TI","1","17","17","ⵎⴰⵖⴰⵔ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⵙⴰ ⵖⴰⵔ ⵔⵓⵎⴰ, ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵅⴰⴼⵉ ⵙ ⵛⴹⴰⵔⴻⵜ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵢⵓⴼⴰ ⴰⵢⵉ. ");
INSERT INTO rift_vpl VALUES ("T21_18","085_1_18","2TI","1","18","18","ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⴰⵇⴰ ⴰⴷ ⵢⴰⴼ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵖⴰⵔ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ. ⵓⵛⴰ ⵎⴻⵛⵃⴰⵍ ⵉⵙⴻⵅⵅⴰⵔ ⴰⵢⵉ ⴷⵉ ⴰⴼⴰⵙⵓⵙ, ⵛⴻⴽ ⵜⴻⵙⵙⵏⴻⴷ ⴽⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("T22_1","085_2_1","2TI","2","1","1","ⵛⴻⴽ ⵅⴻⵏⵏⵉ, ⴰ ⵎⵎⵉ, ⵉⵍⵉ ⵜⵎⴻⵃⵃⴹⴻⴷ ⴷⵉ ⴰⵔⴹⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("T22_2","085_2_2","2TI","2","2","2","ⵓ ⵎⵉⵏ ⵣⵣⴰⵢⵉ ⵜⴻⵙⵍⵉⴷ ⵣⵣⴰⵜ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⵛⵀⵓⴷ, ⵡⴻⴽⴽⴻⵍ ⵉ-ⵜ ⵉ ⵉⵡⴷⴰⵏ ⵉⵎⵜⵉⵇⵇⴰⵏ, ⵉⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵍⴻⵎⴷⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("T22_3","085_2_3","2TI","2","3","3","ⴰⵔⴱⵓ ⵍⵖⴰⵔ ⴰⴽ-ⴷ ⵉⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵛⵏⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T22_4","085_2_4","2TI","2","4","4","ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⵙⴽⴰⵔⵉ ⵉⵍⴻⵀⵀⴰ ⴰⴽ-ⴷ ⵍⴻⵙⵡⴰⵇ ⵏ ⵜⵓⴷⴰⵔⵜ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵢⴰⵔⴹⴰ ⵡⴻⵏⵏⵉ ⵜ ⵉⴳⴳⵉⵏ ⴷ ⴰⵄⴻⵙⴽⴰⵔⵉ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("T22_5","085_2_5","2TI","2","5","5","ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵎⵃⵉⵣⵡⴰⵔⴻⵏ ⴰⵎ ⴱⵓ-ⵓⵎⵃⵉⵣⵡⴰⵔ, ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵛⴻⵏ ⵜⵜⴰⵊ ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⵎⵎⵏⵉⵖ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵇⴰⵏⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("T22_6","085_2_6","2TI","2","6","6","ⴰⴼⴻⴵⴰⵃ ⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵇⴻⵙⵃⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⴽⵙⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵣⵉ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("T22_7","085_2_7","2TI","2","7","7","ⵅⴰⵔⵔⴻⵚ ⴷⵉ ⵎⵉⵏ ⴷ ⴰⵛ ⵇⵇⴰⵔⴻⵖ. ⴰⴷ ⴰⵛ ⵉⵡⵛ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵍⴻⴼⵀⴰⵎⴻⵜ ⴷⵉ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("T22_8","085_2_8","2TI","2","8","8","ⵄⵇⴻⵍ ⵍⴻⴱⴷⴰ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⴰⵇⴰ-ⵜ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⴷⴰⵡⵓⴷ ⵄⵍⴰⵃⵙⴰⴱ ⵍ’ⵉⵏⵊⵉⵍ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("T22_9","085_2_9","2TI","2","9","9","ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏⵏⵉ ⵅⴻⴼ ⴽⵙⵉⵖ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵄⴰⴷ ⵙⵙⵏⴰⵙⴻⵍ ⴰⵅⵎⵉ ⴵⵉⵖ ⵏⴻⵛⵛ ⴷ ⵉⵊⵊ ⵏ ⵓⵄⴻⴼⴼⴰⵏ! ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵇⵇⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("T22_10","085_2_10","2TI","2","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵜⵃⴻⵎⵍⴻⵖ ⵎⴰⵔⵔⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⴰⴼⴻⵏ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴽ-ⴷ ⵓⵄⵓⴵⵉ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T22_11","085_2_11","2TI","2","11","11","ⵡⴰ ⴷ ⴰⵡⴰⵍ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵏⴻⵎⵎⵓⵜ ⴰⴽⵉⴷⴻⵙ, ⴰⴷ ⴽⵉⵙ ⵏⴻⴷⴷⴰⵔ ⵄⴰⵡⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("T22_12","085_2_12","2TI","2","12","12","ⵓ ⵎⴰⵍⴰ ⵏⵚⴻⴱⴱⴰⵔ, ⴰⴷ ⴽⵉⵙ ⵏⴻⵃⴽⴻⵎ ⵄⴰⵡⴻⴷ ⴰⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵏⴽⴰⵔ ⵉ-ⵜ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵏⴽⴰⵔ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("T22_13","085_2_13","2TI","2","13","13","ⵎⴰⵍⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵏⴻⵜⵜⵉⵇⵇ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⵉⵎⴰ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵏⴽⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T22_14","085_2_14","2TI","2","14","14","ⵙⴻⵄⵇⴻⵍ ⴰⵙⴻⵏ ⵎⴰⵏ ⴰⵢⴰ, ⵄⵍⴻⵎ ⴰⵙⴻⵏ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⵜⵎⴻⵏⵖⵉⵏ ⵛⴰ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ, ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵡⵢⴻⵏ ⴰⵔⴻⴷⴷⴻⴵ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵚⴻⵏⵏⴰⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T22_15","085_2_15","2TI","2","15","15","ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵔⵔⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴰⵎ ⵜⴽⴻⵎⵍⴻⴷ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵓⵅⴻⴷⴷⴰⵎ ⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵎⵉⵏ ⵣⵉ ⵖⴰ ⵉⵙⴻⴹⵃⴰ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴱⴰⵔⵔⵃⴻⵏ ⵏⵉⵛⴰⵏ ⴰⵡⴰⵍ ⵏ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("T22_16","085_2_16","2TI","2","16","16","ⴰⴳⴳⵯⴻⵊ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ ⵉ ⵡⴰⵔ ⵉⵏⴻⴼⴼⵄⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵏⵉⵏ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⴻⵇⵊⴰⵃⴻⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵛⴻⵖⵍⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("T22_17","085_2_17","2TI","2","17","17","ⴰⵡⴰⵍ ⵏⵙⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵖⵉⵢⵢⴻⵣ ⴰⵎ ⵓⵅⵙⴰⵙ. ⴰⵇⴰ ⵀⵉⵎⵉⵏⵉⵢⵓⵙ ⴷ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵓ ⴼⵉⵍⵉⵜⵓⵙ ⴷ ⵉⵊⵊⴻⵏ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("T22_18","085_2_18","2TI","2","18","18","ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵜⴰⵏⵓⴽⵔⴰ ⴰⵇⴰ ⵜⴻⵎⵙⴰⵔ, ⵓⵛⴰ ⵇⴻⵍⴱⴻⵏ ⵍ’ⵉⵎⴰⵏ ⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("T22_19","085_2_19","2TI","2","19","19","ⵎⴰⵛⴰ ⴷⵙⴰⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴱⴻⴷⴷ ⵏⵉⵛⴰⵏ ⵓⵛⴰ ⵡⴰ ⴷ ⴰⵛⴻⵎⵎⵉⵄ ⵏⵏⴻⵙ: “ⵙⵉⴷⵉ ⵉⵙⵙⴻⵏ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵏⵏⴻⵙ!”, ⵓⵛⴰ” ‘ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵙⵉⴷⵉ ⴰⴷ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ.” ");
INSERT INTO rift_vpl VALUES ("T22_20","085_2_20","2TI","2","20","20","ⵎⴰⵛⴰ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵍⴻⵇⵛⵓⵄ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵏ ⵓⴽⴻⵛⵛⵓⴹ ⴷ ⵜⵍⴰⵅⵜ, ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵏ ⵛⵛⴰⵏ ⵓ ⵛⴰ ⵏ ⵓⴱⴻⵀⴷⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("T22_21","085_2_21","2TI","2","21","21","ⵅⴻⵏⵏⵉ ⵎⴰⵍⴰ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵃⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⴷⴷⴻⴳⴳⴰ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵉⵛⵜ ⵏ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵛⵛⴰⵏ, ⵜᵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⵉ ⵜⴻⴵⴰ ⵓⵛⴰ ⵜⴻⴷⵡⴻⵍ ⵜⵏⴻⴼⴼⴻⵄ ⵉ ⵙⵉⴷⴻⵙ, ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T22_22","085_2_22","2TI","2","22","22","ⴰⵔⵡⴻⵍ ⵣⵉ ⵎⴰⵔⵔⴰ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⵜⴻⵎⵥⵉ ⵓⵛⴰ ⴰⵔⴷⴻⴼ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵢⵔⵉ ⴷ ⵍⴻⵀⵏⴰ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵍⴰⵖⴰⵏ ⵅ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵣⴻⴳ ⵡⵓⵍ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("T22_23","085_2_23","2TI","2","23","23","ⴱⴻⵄⵄⴻⴷ ⵅ ⵉⵎⵃⴰⵔⵡⴰⴹⴻⵏ ⵉⴱⵓⵀⴰⵍⵉⵢⵢⴻⵏ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵉ ⵍⴻⴱⵏⵉ, ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⵏⴻⴷ ⴰⵇⴰ ⵏⴻⴷⴷⵀⴻⵏ ⵖⴰⵔ ⵉⵎⵛⵓⴱⴱⴰⵛ. ");
INSERT INTO rift_vpl VALUES ("T22_24","085_2_24","2TI","2","24","24","ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⵉⵎⵛⵓⴱⴱⴻⵛ, ⵎⴰⵛⴰ ⵉⵛⵓⵡⵡⴰⵔ ⴰⵙ ⴰⴷ ⵢⵓⵢⵓⵔ ⵙ ⵜⴻⵎⵀⵉⵏⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ, ⵉⵙⵙⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("T22_25","085_2_25","2TI","2","25","25","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵙ ⵜⴻⵎⵀⵉⵏⵜ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⵄⴻⴽⴽⴰⵙⴻⵏ. ⴰⴷ ⵜⴰⵖ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⵡⵛ ⴰⴷ ⵜⵓⴱⴻⵏ ⴰⴷ ⵙⵙⵏⴻⵏ ⵜⵉⴷⴻⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("T22_26","085_2_26","2TI","2","26","26","ⵓⵛⴰ ⴰⴷ ⴷⴷ ⴰⵙⴻⵏ-ⵢⴰⵔⵔ ⵍⴱⴰⵍ, ⴰⴷ ⵏⴼⴻⴽⴽⴻⵏ ⵣⵉ ⵍⴼⴻⵅ ⵏ ⵛⵛⵉⵟⴰⵏ, ⵡⴻⵏⵏⵉ ⵉ-ⵜⴻⵏ ⵉⵃⴻⴱⴱⵙⴻⵏ ⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T23_1","085_3_1","2TI","3","1","1","ⵎⴰⵛⴰ ⵙⵙⴻⵏ ⴷⴷⴻⴳⴳⴰ, ⴰⵇⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵍⵎⵉⵊⴰⵍⴰⵜ ⵏ ⵍⵡⴻⵇⵜ ⵉⵡⵄⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T23_2","085_3_2","2TI","3","2","2","ⵎⵉⵏⵣⵉ ⵉⵡⴷⴰⵏ ⴰⴷ ⵅⵙⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵛⴻⵟⵟⴰⵔⴻⵏ, ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵏⵏⴼⴰⵅⴻⵜ ⴷ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴷ ⵉⵎⵛⴻⵇⵇⴰⴼⴻⵏ, ⵡⴰⵔ ⵜⵜᵉⵟⵟⵉⵄⵉⵏ ⵛⴰ ⵉ ⵉⵡⴷⴰⵏ ⵏⵙⴻⵏ, ⴰⴷ ⵏⴹⴰⵔⴻⵏ ⴰⵔⴹⴰ, ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("T23_3","085_3_3","2TI","3","3","3","ⴰⴷ ⵛⴻⵇⵇⴼⴻⵏ, ⴰⴷ ⵎⴻⵥⵍⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵄⵍⴰⵎ ⴽⵓⵍ ⵏⵏⴻⵛⵡⴰⵜ, ⴰⴷ ⵉⵍⵉⵏ ⵇⴻⵙⵃⴻⵏ, ⵛⴰⵔⵔⵀⴻⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("T23_4","085_3_4","2TI","3","4","4","ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵖⴻⴷⴷⴰⵔⴻⵏ ⴷ ⵉⴼⴻⵏⵜⵔⵓⵙⴻⵏ, ⴷⴰⵢⵙⴻⵏ ⵏⵏⴼⴰⵅⴻⵜ, ⴰⴷ ⵅⵙⴻⵏ ⵏⵏⴻⵛⵡⴰⵜ ⴽⵜⴰⵔ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("T23_5","085_3_5","2TI","3","5","5","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵓⴷⴻⵎ ⵏ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴱⴻⴷⴷⴻⵏ ⴰⴳⴳⵯⴻⵊⴻⵏ ⵅ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ. ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴰⵎⴻⵏⵏⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵏ ⵜⴻⵙⵙⵉⴳⴳⵯⴻⵊⴻⴷ ⵅⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("T23_6","085_3_6","2TI","3","6","6","ⵣⵣⴰⵢⵙⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵃⴰⵎⴰⵏ ⵜⵓⴷⵔⵉⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵓⵙⵓⵎⴻⵏ ⵜⵉⵎⵖⴰⵔⵉⵏ ⵜⵉⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⴷⴷⵏⵓⴱ, ⵜⵜⵡⴰⵄⴰⵔⵔⴻⵏⵜ ⵙ ⵓⴱⴰⵔⵔⵓ ⵏ ⵏⵏⴻⵛⵡⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("T23_7","085_3_7","2TI","3","7","7","ⵜⵉⵏⵏⵉ ⵅⵙⴻⵏⵜ ⴰⴷ ⵍⴻⵎⴷⴻⵏⵜ ⵍⴻⴱⴷⴰ. ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴰⵡⴹⴻⵏ ⴷⴷⴰⴱ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵏⵉ ⵖⴰⵔ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⵉⴷⴻⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("T23_8","085_3_8","2TI","3","8","8","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵢⴰⵏⵏⵉⵙ ⴷ ⵢⴰⵎⴱⵔⵉⵙ ⵜⵜⴻⵎⵄⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵎⵓⵙⴰ, ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵉⵏⴰ ⵜⵜⴻⵎⵄⴰⵍⴰⵏ ⴰⴽ-ⴷ ⵜⵉⴷⴻⵜⵜ: ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⵉⵡⴷⴰⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴻⵛⵛ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵣⵉ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T23_9","085_3_9","2TI","3","9","9","ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜⵔⵉⵃⴻⵏ ⵛⴰ ⴽⵜⴰⵔ ⵖⴰⵔ ⵣⵣⴰⵜ, ⵎⵉⵏⵣⵉ ⴰⴼⵖⵓⵍ ⵏⵙⴻⵏ ⵉⴱⴰⵏ-ⴷⴷ ⵉ ⵎⴰⵔⵔⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⵏ ⵓⵍⴰ ⴷ ⴰⴼⵖⵓⵍ ⵏ ⵢⵉⵏⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T23_10","085_3_10","2TI","3","10","10","ⵎⴰⵛⴰ ⵛⴻⴽ ⵜⵙⵉⵖⵉⴷ ⴰⴽⵉⴷⵉ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ ⵉⵏⵓ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵓⵔⴻⵖ, ⵜⵙⵉⵖⵉⴷ ⴰⴽⵉⴷⵉ ⴷⵉ ⵍⵖⴰⵔⴰⴹ ⵉⵏⵓ, ⵍ’ⵉⵎⴰⵏ ⵉⵏⵓ, ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵉⵏⵓ, ⵜⴰⵢⵔⵉ ⵉⵏⵓ ⴷ ⵚⵚⴱⴰⵔ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("T23_11","085_3_11","2TI","3","11","11","ⴷⵉ ⵍⴻⵃⵚⴰⵔⴰⵜ ⴷ ⵓⵡⴻⴷⴷⴻⴱ ⵉⵏⵓ. ⵜⴻⵙⵙⵏⴻⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵅⴰⴼⵉ ⵉⴽⴽⵉⵏ ⴷⵉ ⴰⵏⵜⵉⵢⵓⵅⵉⵢⴰ ⴷ ⵉⴽⵓⵏⵉⵢⴰ ⴷ ⵍⵉⵙⵜⵔⴰ, ⵎⴰⵏ ⵎⴰⵔⴽⴰⵜ ⵏ ⵓⴷⴰⵔⵔⴻⵛ ⵉ ⴽⵙⵉⵖ, ⵓⵛⴰ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵙⵙⴻⵏⵊⴻⵎ ⴰⵢⵉ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("T23_12","085_3_12","2TI","3","12","12","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵜⵜⵡⴰⴷⴰⵔⵔⵛⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T23_13","085_3_13","2TI","3","13","13","ⵎⴰⵛⴰ ⵉⵡⴷⴰⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ ⴷ ⵉⵛⴻⵎⵎⴰⵜⴻⵏ ⴰⴷ ⴰⵔⵏⵉⵏ ⴷⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵙⴻⵏ, ⴰⴷ ⵖⵡⴰⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵖⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T23_14","085_3_14","2TI","3","14","14","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵇⵇⵉⵎ ⴷⵉ ⵎⵉⵏ ⵜⵓⵖⴰ ⵜⵍⴻⵎⴷⴻⴷ ⵓ ⴷⵉ ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⴷ, ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⵏⴻⴷ ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵣⵉ ⵜ ⵜⵍⴻⵎⴷⴻⴷ, ");
INSERT INTO rift_vpl VALUES ("T23_15","085_3_15","2TI","3","15","15","ⵓ ⴰⵇⴰ ⵣⵉ ⵜⴻⵎⵥⵉ ⵏⵏⴻⵛ ⵜᵉⵜⵜⵡⴰⵙⵙⵍⴻⵎⴷⴻⴷ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⵛⴻⴽ ⴰⵔⵔⴻⵏⵜ ⴷ ⴰⵎⵉⵖⵉⵙ ⴰⵍ ⵖⴰ ⵜᵉⵟⵟⴼⴻⴷ ⵜⵓⴷⴰⵔⵜ ⵙ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("T23_16","085_3_16","2TI","3","16","16","ⴽⵓⵍ ⵜⵉⵔⴰ ⵉ ⵢⵓⵔⴰⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⵉⵏⴻⴼⴼⴻⵄ ⵄⴰⵡⴻⴷ ⵉ ⵓⵙⴻⵍⵎⴻⴷ, ⵉ ⵓⵚⴻⵃⵃⵉ, ⵉ ⵡⴻⵄⴷⴰⵍ ⵓⵛⴰ ⵉ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⴷⵉ ⵜⵙⴻⴳⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("T23_17","085_3_17","2TI","3","17","17","ⵃⵉⵎⴰ ⴱⵏⴰⴷⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵢⵉⵍⵉ ⵉⵄⴻⵙⵙ, ⵉⵃⴻⵣⵣⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T24_1","085_4_1","2TI","4","1","1","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜⵜⵄⴻⵡⵡⵍⴻⵖ ⵅⴰⴽ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵖⴰⵔ ⵓⵅⴻⵛⵛⵉ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("T24_2","085_4_2","2TI","4","2","2","ⴱⴰⵔⵔⴻⵃ ⵙ ⵡⴰⵡⴰⵍ, ⵉⵍⵉ ⵜⴼⴰⵇⴻⴷ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵉⵖ ⴱⴰⵔⵔⴰ ⵉ ⵍⵡⴻⵇⵜ, ⵚⴻⵃⵃ, ⵄⴰⵇⴻⴱ, ⵄⵍⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵓ ⵙ ⵓⵙⴻⵍⵎⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("T24_3","085_4_3","2TI","4","3","3","ⵎⵉⵏⵣⵉ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⵉⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵅⵎⵉ ⵉⵡⴷⴰⵏ ⵡⴰⵔ ⵇⴻⴱⴱⵉⵍⴻⵏ ⵄⴰⴷ ⵜⴰⵖⵓⵔⵉ ⵉⵚⴻⵃⵃⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵙⵙⵎⵓⵏⴻⵏ ⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵣⵉ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T24_4","085_4_4","2TI","4","4","4","ⴰⴷ ⵊⴻⵎⴷⴻⵏ ⵜⵉⴷⴻⵜⵜ ⵅ ⵉⵎⴻⵊⵊⴰⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵖⴰⵔ ⵜⵃⵓⵊⴰ ⵉⵅⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T24_5","085_4_5","2TI","4","5","5","ⵎⴰⵛⴰ ⵛⴻⴽ, ⴼⴰⵇ ⴷⵉ ⴽⵓⵍⵛⵉ, ⴽⵙⵉ ⴰⵔⵎⴻⵃ, ⴻⴳⴳ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵓⵎⴱⴻⵛⵛⴰⵔ ⵓⵛⴰ ⴽⴻⵎⵎⴻⵍ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("T24_6","085_4_6","2TI","4","6","6","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⵇⴰ ⵜⵜⵡⴰⵣⴻⴵⵄⴻⵖ ⴰⵎ ⵜⴻⵡⵀⵉⴱⵜ ⵏ ⵓⵙⴻⵢⵢⴻⴱ ⵓ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⵡⴰⵃⵉⵜ ⵉⵏⵓ ⵢⵉⵡⴻⴹ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("T24_7","085_4_7","2TI","4","7","7","ⵏⴻⵛⵛ ⵎⴻⵏⵖⴻⵖ ⴰⵎⴻⵏⵖⵉ ⴰⵚⴻⴱⵃⴰⵏ, ⴰⵇⴰ ⴽⴻⵎⵎⵍⴻⵖ ⵜⴰⵣⵣⵍⴰ ⵉⵏⵓ, ⵃⴹⵉⵖ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("T24_8","085_4_8","2TI","4","8","8","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⵜⵜⴰⵊ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵜⴻⵏⵏⵉ ⵉ ⴷ ⴰⵢⵉ ⵖⴰ ⵉⵡⵛ ⵙⵉⴷⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ, ⵅⵎⵉ ⵖⴰ ⵉⵃⴽⴻⵎ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⴰⵇⴰ ⵉⵡⵊⴻⴷ. ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵏⴻⵛⵛ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵅⴻⵛⵛⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T24_9","085_4_9","2TI","4","9","9","ⵛⴹⴰⵔⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙⴻⴷ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("T24_10","085_4_10","2TI","4","10","10","ⵎⵉⵏⵣⵉ ⴷⵉⵎⴰⵙ ⵉⵙⵎⴻⵃ ⴷⴰⵢⵉ, ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⴷⴷⵓⵏⴻⵛⵜ ⵏ ⵢⵉⴹⴰ ⵓⵛⴰ ⵉⵔⵓⵃ ⵖⴰⵔ ⵜⵉⵙⵙⴰⵍⵓⵏⵉⴽⴰ, ⵓ ⴽⵔⵉⵙⴽⵉⵙ ⵉⵔⵓⵃ ⵖⴰⵔ ⴳⴰⵍⴰⵟⵉⵢⴰ ⵓ ⵜⵉⵜⵓⵙ ⵖⴰⵔ ⴷⴰⵍⵎⴰⵜⵉⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("T24_11","085_4_11","2TI","4","11","11","ⵎⵖⵉⵔ ⵍⵓⴽⴰ ⵉ ⴽⵉⴷⵉ ⵉⵇⵇⵉⵎⴻⵏ. ⴰⵡⵉ-ⴷⴷ ⵎⴰⵔⴽⵓⵙ ⵓⵛⴰ ⴳⴻⵡⵡⴻⴷ ⵉ-ⵜ ⴰⴽⵉⴷⴻⴽ, ⵎⵉⵏⵣⵉ ⵉⵏⴻⴼⴼⴻⵄ ⴰⵢⵉ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("T24_12","085_4_12","2TI","4","12","12","ⵙⴻⴽⴽⴻⵖ-ⴷⴷ ⵜⵉⵛⵉⴽⵓⵙ ⵖⴰⵔ ⴰⴼⴰⵙⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("T24_13","085_4_13","2TI","4","13","13","ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵜⴰⵙⴻⴷ, ⴰⵡⵉ-ⴷⴷ ⴰⴽⵉⴷⴻⴽ ⴰⵇⵔⴰⴱ ⵉ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏⵏⵉ ⵊⵊⵉⵖ ⴷⵉ ⵜⵔⵓⵡⴰⵙ ⵖⴰⵔ ⴽⴰⵔⴱⵓⵙ ⵓⵍⴰ ⴷ ⵉⴷⵍⵉⵙⴻⵏ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵍⴻⵎⵚⴰⵃⴻⴼ ⵏ ⵛⵛⴰⵔⴽ. ");
INSERT INTO rift_vpl VALUES ("T24_14","085_4_14","2TI","4","14","14","ⴰⵍⵉⴽⵙⴰⵏⴷⵉⵔ, ⴰⵎⵣⵉⵍ ⵏ ⵏⵏⵃⴰⵙ, ⵜⵓⵖⴰ ⵉⴳⴳⴰ ⴷⴰⵢⵉ ⴰⵟⵟⴰⵙ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ. ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⵜ ⵉⵅⴻⴵⴻⵚ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("T24_15","085_4_15","2TI","4","15","15","ⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵣⵣⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵄⴻⴽⴽⴰⵙ ⴰⵡⴰⵍⴻⵏ ⵏⵏⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("T24_16","085_4_16","2TI","4","16","16","ⵓⵎⵉ ⴽⴽⴰⵔⴻⵖ ⴰⴷ ⵡⵜⴻⵖ ⵅ ⵉⵅⴻⴼ ⵉⵏⵓ ⵜⵡⴰⵍⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴽⵉⴷⵉ ⴷⴷ-ⵢⵓⵙⵉ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵙⴻⵎⵃⴻⵏ ⴷ ⴰⵢⵉ. ⴻⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⴰⵅⴻⴵⴻⵚ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("T24_17","085_4_17","2TI","4","17","17","ⵎⴰⵛⴰ ⵙⵉⴷⵉ ⵜⵓⵖⴰ-ⵜ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ ⵉⵏⵓ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵢⵉ ⵊⵊⴻⵀⴷ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵣⵣⴰⵢⵉ ⵉ ⵖⴰ ⵜⴽⴻⵎⵎⴻⵍ ⵜⴱⴰⵔⵔⴻⵃⵜ, ⵓ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵙⵍⴻⵏ, ⴰⵇⴰ ⵏⴻⵛⵛ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵓⵅⴻⵏⴼⵓⵛ ⵏ ⵡⴰⵢⵔⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("T24_18","085_4_18","2TI","4","18","18","ⵙⵉⴷⵉ ⴰⴷ ⴰⵢⵉ ⵉⴼⴻⴽⴽ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵎⴻⵄⵎⵓⵍⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⴷⵉ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵖⴰⵔ ⵉ ⵏⴻⵜⵜⴰ ⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("T24_19","085_4_19","2TI","4","19","19","ⵙⴻⴵⴻⵎ ⵅ ⴱⵔⵉⵙⴽⵉⵍⵍⴰ ⴷ ⴰⴽⵡⵉⵍⴰ ⵓ ⵅ ⴰⵢⵜⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵓⵏⵉⵙⵉⴼⵓⵔⵓⵙ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("T24_20","085_4_20","2TI","4","20","20","ⵉⵔⴰⵙⵜⵓⵙ ⵉⵇⵇⵉⵎ ⴷⵉ ⴽⵓⵔⵉⵏⵜⵓⵙ ⵓ ⵜⵔⵓⴼⵉⵎⵓⵙ ⵊⵊⵉⵖ ⵜ ⴷⵉ ⵎⵉⵍⵉⵜⵓⵙ ⵉⵀⵍⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("T24_21","085_4_21","2TI","4","21","21","ⵛⴹⴰⵔⴻⵜ ⴰⴷ ⴷⴷ-ⵜⴰⵙⴻⴷ ⵇⴱⴻⵍ ⵜⴰⴳⵔⵉⵙⵜ. ⵉⵡⴱⵓⵍⵓⵙ ⴷ ⴱⵓⴷⵉⵏⵙ ⴷ ⵍⵉⵏⵓⵙ ⴷ ⴽⵍⵓⴷⵉⵢⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⴽ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("T24_22","085_4_22","2TI","4","22","22","ⴰⴷ ⵢⵉⵍⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴽ-ⴷ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵛ. ⴰⵔⴹⴰ ⴰⴷ ⴽⵉⴷⴻⴽ ⵢⵉⵍⵉ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("TT1_1","086_1_1","TIT","1","1","1","ⴱⵓⵍⵓⵙ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("TT1_2","086_1_2","TIT","1","2","2","ⵅ ⵓⵙⵉⵜⴻⵎ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵡⴰⵄⴷ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵇⴱⴻⵍ ⵣⵣⵎⴰⵏⴰⵜ ⵏ ⵍⵡⴻⵇⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("TT1_3","086_1_3","TIT","1","3","3","ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵙ ⵜⴱⴰⵔⵔⴻⵃⵜ ⵏⵏⴻⵖ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵡⴰⵡⴻⴽⴽⵍⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵓⵎⵓⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("TT1_4","086_1_4","TIT","1","4","4","ⵉ ⵜⵉⵜⵓⵙ, ⵎⵎⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵖ ⵉⵛⴰⵔⵛⴻⵏ: ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("TT1_5","086_1_5","TIT","1","5","5","ⵙ ⵓⵢⴻⵏⵏⵉ ⵊⵊⵉⵖ ⵛⴻⴽ ⴷⵉ ⴽⵔⵉⵜⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⴷⵍⴻⴷ ⵎⵉⵏ ⵜⵓⵖⴰ ⵄⴰⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵄⵄⴷⴻⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴽⵓⵍ ⵜⴰⵏⴷⵉⵏⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("TT1_6","086_1_6","TIT","1","6","6","ⴰⵎⵖⴰⵔ ⴷ ⵉⵊⵊⴻⵏ ⵏⵏⵉ ⵡⴰⵔ ⴷⵉ ⵉⴵⵉ ⵍⵄⵉⴱ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⵢⴰⵣ ⵉ ⵖⴰⵔⴻⵙ ⵎⵖⵉⵔ ⵉⵛⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵜ, ⵖⴰⵔⴻⵙ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵜⵜⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⵜⵜᵉⴽⴽⵡⴰⵔⴻⵏ, ⵡⴰⵔ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵛⵛⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("TT1_7","086_1_7","TIT","1","7","7","ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵓⵎⵖⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⴱⵍⴰ ⵍⵄⵉⴱ ⴰⵎ ⵡⴻⵡⴽⵉⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵉⵜⵜⵅⴻⵚⵚⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵓⵄⴻⴼⴼⴰⵔ ⵏⵉⵖ ⵣⵣⵄⴰⴼ, ⵡⴰⵔ ⵉⵙⴻⵙⵙ ⵛⵛⵔⴰⴱ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⵇⴻⴷⴷ, ⵡⴰⵔ ⵉⵛⵛⵉⵜ ⵙ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴷⴻⵖⵢⴰ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙ ⴰⵔⴱⴻⵃ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("TT1_8","086_1_8","TIT","1","8","8","ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵢⴰⵔⴻⵃⵃⴻⴱ ⵙ ⵉⵏⴻⵡⵊⵉⵡⴻⵏ, ⴰⴷ ⵉⵅⵙ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵙⴻⵅⵅⴰⵢ, ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("TT1_9","086_1_9","TIT","1","9","9","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵃⴹⴰ ⵜⵖⵓⵔⵉ ⵏ ⵚⵚⴰⵃ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵍ’ⵉⵎⴰⵏ, ⵃⵉⵎⴰ ⵉⵇⴻⴷⴷ ⴰⴷ ⵉⴳⴳ ⵡⵓⵍ ⴷⴻⴳ ⵢⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⵙ ⵜⵖⵓⵔⵉ ⵏⵏⴻⵙ ⵏ ⵚⵚⴰⵃ ⵓ ⴰⴷ ⵉⵙⴻⴳⴳⴻⵎ ⵜⴰⵔⵡⴰ ⵏ ⴱⵓ-ⵜⵖⴻⵏⵏⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("TT1_10","086_1_10","TIT","1","10","10","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵅⵙⴻⵏ ⴰⴷ ⵙⵙⵡⴰⴹⴹⵄⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵉⵅⵡⴰⵏ. ⵏⵉⵜⵏⵉ ⵙⵙⵅⴰⵔⵡⴰⴹⴻⵏ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵉⵡⴷⴰⵏ, ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ ⵏⵙⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵡⴻⵅⵜⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("TT1_11","086_1_11","TIT","1","11","11","ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵇⵇⴻⵏ ⵓⵇⴻⵎⵎⵓⵎ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵇⴻⵍⵄⴻⵏ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴰⴵⴰⵜ, ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴼⴻⵏ ⴰⵔⴱⴻⵃ ⵡⴰⵔ ⵉⵃⵍⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("TT1_12","086_1_12","TIT","1","12","12","ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵏⴰⴱⵉ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⵉⵏⵏⴰ: “ⵉⴽⵔⵉⵜⵉⵢⵢⴻⵏ ⵙⵙⵅⴰⵔⵉⵇⵇⴻⵏ ⵍⴻⴱⴷⴰ, ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⵍⴻⵡⵃⵓⵛ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵉⵎⴻⵄⴳⴰⵣⴻⵏ ⵉ ⴷⴰⵢⵙⴻⵏ ⴰⵄⴻⴷⴷⵉⵙ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("TT1_13","086_1_13","TIT","1","13","13","ⵛⵛⵀⴰⴷⴻⵜ-ⴰ ⴷ ⵜⵉⴷⴻⵜⵜ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴻⴱⴱⴻⵅ ⴰⵙⴻⵏ ⵙ ⵊⵊⴻⵀⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵚⵃⴰⵃⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("TT1_14","086_1_14","TIT","1","14","14","ⵡⴰⵔ ⵜⵜⵉⵛⴻⵏ ⵛⴰ ⵜⴰⵢⵏⵉⵜ ⵉ ⵜⵃⵓⵊⴰ ⵏ ⵡⵓⴷⴰⵢⴻⵏ ⴷ ⵜⵉⵡⴻⵚⵚⴰ ⵏ ⵉⵡⴷⴰⵏ ⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵙ ⵡⴻⵄⵔⵓⵔ ⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("TT1_15","086_1_15","TIT","1","15","15","ⵉ ⵓⵎⴻⵣⴷⴰⴳ ⵎⴰⵔⵔⴰ ⴷ ⵜⴰⵣⴷⵓⴳⵉ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵎⵊⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⵉ ⵏⵉⵜⵏⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵡⴰⵔ ⵜⵉⵣⴷⵉⴳ, ⵎⵉⵏⵣⵉ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏⵙⴻⵏ ⴷ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ ⵅⴻⵎⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("TT1_16","086_1_16","TIT","1","16","16","ⵏⵉⵜⵏⵉ ⵛⴻⵀⵀⴷⴻⵏ ⴰⵇⴰ ⵙⵙⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵏⴹⴰⵔⴻⵏ ⵜ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ. ⵢⴰⵄⵄⵓⵜ ⵎⵉⵏ ⵜⵜⴻⴳⴳⴻⵏ, ⴰⵇⴰ ⵡⴰⵔ ⵜⵜᵉⵟⵟⵉⵄⴻⵏ ⵛⴰ, ⵡⴰⵔ ⵏⴻⴼⴼⵄⴻⵏ ⵓⵍⴰ ⵉ ⵢⵉⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("TT2_1","086_2_1","TIT","2","1","1","ⵎⴰⵛⴰ ⵛⴻⴽ, ⵙⵉⵡⴻⵍ ⵎⵉⵏ ⵉⵜⵜⵍⵉⵇⴻⵏ ⵉ ⵜⵖⵓⵔⵉ ⵏ ⵚⵚⴰⵃ. ");
INSERT INTO rift_vpl VALUES ("TT2_2","086_2_2","TIT","2","2","2","ⵙⴻⵍⵎⴻⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵍⵉⵏ ⴼⴰⵇⴻⵏ, ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵙ ⵜⵙⴻⵅⵅⴰⵢⵜ ⴷ ⵜⴰⵣⴷⵓⴳⵉ ⴷ ⵍ’ⵉⵎⴰⵏ ⵏ ⵚⵚⴰⵃ ⵓ ⵙ ⵜⴰⵢⵔⵉ ⴷ ⵚⵚⴱⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("TT2_3","086_2_3","TIT","2","3","3","ⵙⴻⵍⵎⴻⴷ ⵜⵉⵡⴻⵙⵙⵓⵔⴰ ⵄⴰⵡⴻⴷ ⴰⵎⵎⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⵓⵔⴻⵏⵜ ⴰⵎ ⴷⴷ-ⵉⵜⵜⵍⵉⵇ ⴰⴽ-ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵜⵜⵛⴻⵇⵇⵉⴼⴻⵏⵜ ⵛⴰ, ⵡⴰⵔ ⵡⵛⵉⵏⵜ ⵉ ⴱⵉⵏⵓ, ⵎⴰⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏⵜ ⴰⴷ ⵙⵙⵍⴻⵎⴷⴻⵏⵜ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("TT2_4","086_2_4","TIT","2","4","4","ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⵊⵊⵄⴻⵏⵜ ⵜⵉⴱⵍⵉⵖⵉⵏ ⴰⴷ ⵓⵢⵓⵔⴻⵏⵜ ⵙ ⵓⵡⴻⵇⵇⴰⵔ, ⴰⴷ ⵅⵙⴻⵏⵜ ⵉⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ ⴷ ⵜⴰⵔⵡⴰ ⵏⵙⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("TT2_5","086_2_5","TIT","2","5","5","ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵢⵉⵍⵉ ⵓⵜⴻⴱⴱⴻⵜ ⴷ ⵜⵇⴻⴷⴷⴰⵙⵜ, ⴰⴷ ⵡⵛⴻⵏⵜ ⵜⴰⵢⵏⵉⵜ ⵉ ⴰⵢⵜ ⴱⴰⴱ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵙⴻⵏⵜ, ⴰⴷ ⴳⴳⴻⵏⵜ ⴰⵔⵔⴰⵢ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⵛⴰ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("TT2_6","086_2_6","TIT","2","6","6","ⵛⴻⵊⵊⵄⴻⵜ ⵄⴰⵡⴻⴷ ⵉⴱⵍⵉⵖⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵙ ⵜⵙⴻⵅⵅⴰⵢⵜ. ");
INSERT INTO rift_vpl VALUES ("TT2_7","086_2_7","TIT","2","7","7","ⴻⴳⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷⵉ ⵎⴰⵔⵔⴰ ⴷ ⵍⵎⵉⵜⴰⵍ, ⴷⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ, ⵓ ⵅⵎⵉ ⵜⴻⵙⵙⵍⴻⵎⴷⴻⴷ, ⵃⴹⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵍⵉ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵛ ⴷ ⵚⵚⴻⵃ, ");
INSERT INTO rift_vpl VALUES ("TT2_8","086_2_8","TIT","2","8","8","ⵙ ⵍⴻⵚⴼⴰⵢⴻⵜ ⴱⵍⴰ ⵍⵖⴻⵛⵛ, ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵉⵙⵙⴻⵃⵇⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⴰⵍ ⵖⴰ ⵉⵙⴻⴹⵃⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵄⴻⴽⴽⴰⵙⴻⵏ ⵓⵎⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵅⴰⵏⴻⵖ ⵉⵙⵙⵉⵡⴻⵍ ⵙ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵉⵙⵙⴼⴻⵟⵟⴰⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("TT2_9","086_2_9","TIT","2","9","9","ⵉⵜⵜⵅⴻⵚⵚⴰ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵟⵟⴰⵄⴻⵏ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ, ⴰⴷ ⴰⵙⴻⵏ ⴰⵔⴹⴰⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⵄⴻⴽⴽⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("TT2_10","086_2_10","TIT","2","10","10","ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⴰⵛⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵏ ⵍⵎⴰⵏⴻⵜ ⵏⵙⴻⵏ ⵉⵛⵏⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⵛⵛⴰⵏ ⵉ ⵜⵖⵓⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("TT2_11","086_2_11","TIT","2","11","11","ⵎⵉⵏⵣⵉ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵙⵙⴰⴽⴽⵡⴰⴹⴻⵏ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵎⴰⵔⵔⴰ, ⴰⵇⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("TT2_12","086_2_12","TIT","2","12","12","ⴰⵔⴹⴰ ⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⴱⴱⴰ ⴰⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏᵉⵜⵜⴻⵊⵊ ⵍⴻⵇⵊⴰⵃⴻⵜ ⴷ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⵙ ⵜⵙⴻⵅⵅⴰⵢⵜ ⴷ ⵜⵙⴻⴳⴷⴰ ⵓ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("TT2_13","086_2_13","TIT","2","13","13","ⴰⵎⵎⵓ ⵉ ⵏⴻⵜⵜⵔⴰⵊⴰ ⴰⵙⵉⵜⴻⵎ ⵉⵜⵜⵡⴰⴱⴰⵔⴽⴻⵏ ⵓⵍⴰ ⴷ ⴰⵙⴰⵔⴳⴻⴱ ⵏ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ: ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("TT2_14","086_2_14","TIT","2","14","14","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵅⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⴻⵍⵍⴻⴽ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵎⴻⵃⵃⴹⴻⵏ ⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("TT2_15","086_2_15","TIT","2","15","15","ⵙⵉⵡⴻⵍ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵣⵉⵢⵢⴰⵔ ⵓ ⵡⴻⴱⴱⴻⵅ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⴻⵀⴷ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⴰⴷ ⵛⴻⴽ ⵉⵙⵙⴻⵃⵇⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("TT3_1","086_3_1","TIT","3","1","1","ⵙⴻⵄⵇⴻⵍ ⵉ-ⵜⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵟⵟⴰⵄⴻⵏ ⵉ ⵍⵃⵓⴽⴽⴰⵎ ⵓ ⵉ ⵚⵚⵓⵍⴰⵟⴰⵜ, ⴰⴷ ⴰⵙⴻⵏ ⴳⴳⴻⵏ ⴰⵔⵔⴰⵢ, ⴰⴷ ⵉⵍⵉⵏ ⵡⴻⵊⴷⴻⵏ ⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⵎⴰⵎⵎⴻⵛ ⵎⴰ ⵜⴻⴳⴳⴰ, ");
INSERT INTO rift_vpl VALUES ("TT3_2","086_3_2","TIT","3","2","2","ⵡⴰⵔ ⵜⵜⵛⴻⵇⵇⵉⴼⴻⵏ ⴷⵉ ⵃⴻⴷ, ⵡⴰⵔ ⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵏ, ⴰⴷ ⵉⵍⵉⵏ ⵜⵜⴻⴱⵜⴻⵏ ⵓⵛⴰ ⴰⴷ ⵙⵙⴻⵛⵏⴻⵏ ⵍⴻⴹⵔⴰⴼⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("TT3_3","086_3_3","TIT","3","3","3","ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵣⵉⵛ ⵜⵓⵖⴰ ⴰⵏⴻⵖ ⴷ ⵉⴼⵖⴰⵍ, ⵙ ⵡⵓⵍ ⵡⴰⵔ ⵉⵎⵜⵉⵏⴻⵏ, ⵏⵡⴻⴷⴷⴰⵔ, ⴰⵇⴰ ⴰⵏⴻⵖ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵏⵏⴻⵛⵡⴰⵜ ⴷ ⵛⵛⴻⵀⵡⴰⵜ, ⵜⵓⵖⴰ ⵏⴻⴷⴷⴰⵔ ⴷⵉ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵓⵍⴰ ⴷⵉ ⵍⴻⵃⵙⴻⴷ, ⴷⴰⵢⵏⴻⵖ ⴰⵛⵔⴰⵀ ⵓⵛⴰ ⵏⵛⴰⵔⵀ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("TT3_4","086_3_4","TIT","3","4","4","ⵎⴰⵛⴰ ⵅⵎⵉ ⵜⴱⴰⵏ ⵜⵛⵓⵏⵉ ⴷ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("TT3_5","086_3_5","TIT","3","5","5","ⴰⵇⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⵓⴷⴰⵔⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵜⵙⴻⴳⴷⴰ ⵉ ⵏⴻⴳⴳⴰ, ⵎⴰⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ, ⵄⵍⴰⵃⵙⴰⴱ ⴰⵙⵉⵔⴷ ⵏ ⵡⴻⵅⵍⴰⵇ ⵏ ⵊⴷⵉⴷ ⴷ ⵜⴰⵊⴷⵉⴷⴻⵜ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ");
INSERT INTO rift_vpl VALUES ("TT3_6","086_3_6","TIT","3","6","6","ⵉ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⴼⴰⵔⵔⴻⵖ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵉⵛⴻⵏ ⵜⵓⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("TT3_7","086_3_7","TIT","3","7","7","ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵙ ⴰⵔⴹⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵏⴻⴷⵡⴻⵍ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⵙ ⵓⵙⵉⵜⴻⵎ ⴷⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("TT3_8","086_3_8","TIT","3","8","8","ⴰⵡⴰⵍ-ⴰ ⴷⴰⵢⴻⵙ ⵍⵎⴰⵏⴻⵜ, ⵓⵛⴰ ⵏⴻⵛⵛ ⵅⵙⴻⵖ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜⴻⴽⴽⴰⵔⴻⴷ ⴰⴷ ⵜⴱⴻⴷⴷⴻⴷ ⵙ ⵊⵊⴻⵀⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵛⵍⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵎⴻⵃⴹⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵛⴻⴱⴱⴰⵔⴻⵏ ⵍⴻⴱⴷⴰ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ. ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵛⵏⴰⵏⵜ ⵓ ⴷⴰⵢⵙⴻⵏⵜ ⵏⵏⴼⴰⵄ ⵉ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("TT3_9","086_3_9","TIT","3","9","9","ⵎⴰⵛⴰ ⴱⴻⵄⵄⴻⴷ ⵅ ⵓⵎⵃⴰⵔⵡⴻⴹ ⴰⴱⵓⵀⴰⵍⵉ, ⵅ ⵜⵀⵓⵊⴰ ⵏ ⵜⴰⵚⵉⵍⴰⵜ, ⵅ ⵓⵎⴻⵏⵖⵉ ⵓ ⵅ ⵉⵎⵛⵓⴱⴱⴰⵛ ⵏ ⵉⵎⵙⴻⵍⵎⴰⴷⴻⵏ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵏⵏⴼⴰⵄ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵍⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("TT3_10","086_3_10","TIT","3","10","10","ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵉⵙⵙⴱⴻⵟⵟⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⴰⵙ ⵜⴰⴳⵉⵎ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜ ⵜⵡⴻⴱⴱⵅⴻⵎ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵓ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("TT3_11","086_3_11","TIT","3","11","11","ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵎⴼⴰⵔⵢⴰⴹ, ⴰⵇⴰ ⴷ ⴰⵎⴻⴷⵏⵓⴱ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵃⴰⵙⴻⴱ ⵣⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("TT3_12","086_3_12","TIT","3","12","12","ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰⵔⴻⴽ ⴷⴷ ⵖⴰ ⵙⵙⵇⴰⴷⴻⵖ ⴰⵔⵜⵉⵎⴰⵙ ⵏⵉⵖ ⵜⵉⵛⵉⴽⵓⵙ, ⴻⴳⴳ ⵜⵉⵣⴻⵎⵎⴰⵔ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵉ ⴷⴷ-ⵜⴰⵙⴻⴷ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⵏⵉⴽⵓⴱⵓⵍⵉⵙ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴳⴳⵉⵖ ⴰⴷ ⴷⵉⵏ ⵙⵙⴻⵄⴷⵓⵖ ⵍⵎⴻⵛⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("TT3_13","086_3_13","TIT","3","13","13","ⵣⴻⵏⴰⵙ, ⴰⵎⵙⴻⵍⵎⴰⴷ ⵏ ⵉⴷⵍⵉⵙⴻⵏ, ⴷ ⴰⴱⵓⵍⵍⵓⵙ, ⴰⵡⵢⴻⵎ ⵜⴻⵏ-ⴷⴷ ⵎⵍⵉⵃ ⴷⴻⴳ ⵡⴻⴱⵔⵉⴷ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("TT3_14","086_3_14","TIT","3","14","14","ⵏⵉⵜⵏⵉ ⴰⴷ ⵙⵙⴻⵍⵎⴰⴷⴻⵏ ⵉⵏⵏⵉ ⵏⵏⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ ⵎⴰⵍⴰ ⴷⵉⵏ ⵍⴻⵃⵡⴻⵊ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⴱⵍⴰ ⵍⵖⵉⴵⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("TT3_15","086_3_15","TIT","3","15","15","ⵎⴰⵔⵔⴰ ⵡⵉ ⴽⵉⴷⵉ ⴷⴰⵏⵉⵜⴰ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⴽ ⵙ ⵍⴻⵀⵏⴰ. ⵙⴻⴵⴻⵎ ⵙ ⵍⴻⵀⵏⴰ ⵄⴰⵡⴻⴷ ⵅ ⵢⵉⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ. ⴰⵔⴹⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵎ! ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("PM1_1","087_1_1","PHM","1","1","1","ⴱⵓⵍⵓⵙ, ⴰⵎⴻⵃⴱⵓⵙ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵜⴰⵡⵎⴰⵜ ⵜⵉⵎⵓⵜⵉⵢⵓ, ⵉ ⴼⵉⵍⵉⵎⵓⵏ ⵉⵄⵉⵣⵣⴻⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ,    ");
INSERT INTO rift_vpl VALUES ("PM1_2","087_1_2","PHM","1","2","2","ⵉ ⵓⵍⵜⵎⴰⵜⵏⴻⵖ ⴰⴱⴼⵉⵢⴰ ⵉⵄⵉⵣⵣⴻⵏ, ⵉ ⴰⵔⵅⵉⴱⴱⵓⵙ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⴽⵉⴷⵏⴻⵖ, ⵓ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵛ: ");
INSERT INTO rift_vpl VALUES ("PM1_3","087_1_3","PHM","1","3","3","ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PM1_4","087_1_4","PHM","1","4","4","ⵏⴻⵛⵛ ⵜⵜⵇⴰⴷⵉⵖ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⵍⴻⴱⴷⴰ ⵓ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵖ ⴷⴰⵢⴻⴽ ⴷⵉ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵉⵏⵓ, ");
INSERT INTO rift_vpl VALUES ("PM1_5","087_1_5","PHM","1","5","5","ⵅⵣⴰⵔ, ⵄⴰⴷ ⵣⴻⴳ ⵡⴰⵎⵉ ⵏⴻⵛⵛ ⵙⵍⵉⵖ ⵅ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵛ ⵉ ⴷⴰⵢⴻⴽ ⵉⴵⴰⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵓ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PM1_6","087_1_6","PHM","1","6","6","ⵃⵉⵎⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵉⵊⵊ ⵏ ⵓⵇⴰⵔⵔⵉ ⵢⵓⴵⵖⴻⵏ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⴰⵍ ⵖⴰ ⵜⴰⵡⵢⴻⴷ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵓ ⴷⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵎⴰⵔⵔⴰ ⵍⵅⴰⵔ ⵉ ⵖⴰⵔⵡⴻⵎ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PM1_7","087_1_7","PHM","1","7","7","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵓⴼⴻⵡⵡⴻⵊ, ⵎⵉⵏⵣⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵛ ⵜⵜⵡⴰⵙⵙⴰⵔⴻⵢⵢⵃⴻⵏ ⵓⵍⴰⵡⴻⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("PM1_8","087_1_8","PHM","1","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵡⴰⵅⵅⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵜⴰⵔⵢⴰⵙⵜ ⴰⵟⵟⴰⵙ ⴷⵉ ⵍⵎⴰⵙⵉⵃ ⵃⵉⵎⴰ ⴰⴷ ⵛⴻⴽ ⵓⵎⵓⵔⴻⵖ ⵎⵉⵏ ⵉⵛⵓⵡⵡⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("PM1_9","087_1_9","PHM","1","9","9","ⴰⵇⴰ ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵃⵙⴻⵏ, ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⴰⵢⵔⵉ, ⴰⴷ ⵣⵣⴰⵢⴻⴽ ⵜⵜⴰⵔⴻⵖ. ⵏⴻⵛⵛ ⴱⵓⵍⵓⵙ, ⴰⵇⴰ ⴰⵢⵉ ⴷ ⴰⵡⴻⵙⵙⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴻⵙⵙⵏⴻⴷ, ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵄⴰⵡⴻⴷ ⴷ ⴰⵎⴻⵃⴱⵓⵙ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("PM1_10","087_1_10","PHM","1","10","10","ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⵓⵜⵔⴰ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⵎⵉ ⵓⵏⵉⵙⵉⵎⵓⵙ, ⵡⴻⵏⵏⵉ ⴷⴷ-ⵊⵊⵉⵖ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⴷⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("PM1_11","087_1_11","PHM","1","11","11","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵛⴻⴽ ⵉⵏⴻⴼⴼⴻⵄ ⵣⵉⵛ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⵉⵏⴻⴼⴼⴻⵄ ⵛⴻⴽ ⴷ ⵏⵏⴻⵛ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("PM1_12","087_1_12","PHM","1","12","12","ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵔⵔⵉⵖ ⴰⵛ ⵜ-ⵉ-ⴷⴷ ⵖⴰⵔⴻⴽ, ⵎⴰⵛⴰ ⵇⴱⴻⵍ ⵉ-ⵜ ⴰⵎ ⵎⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("PM1_13","087_1_13","PHM","1","13","13","ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⵎⵍⵉ ⵓⴼⵉⵖ ⵉⵍⵉ ⴰⵇⴰ ⵊⵊⵉⵖ ⵜ ⴷⴰⵏⵉⵜⴰ ⴰⴽⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵉⵙⴻⵅⵅⴰⵔ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵛ ⵎⵉⵏ ⴷⴰ ⵖⴰ ⴽⴽⴻⵖ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍ’ⵉⵏⵊⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("PM1_14","087_1_14","PHM","1","14","14","ⵎⴰⵛⴰ ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵡⴰⵍⵓ ⴱⵍⴰ ⵎⴰ ⵉ ⵖⴰ ⵎⵛⴰⵡⴰⵔⴻⵖ ⴰⴽⵉⴷⴻⴽ, ⵃⵉⵎⴰ ⵜⵛⵓⵏⵉ ⵉ ⵜⴻⴳⴳⵉⴷ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵙ ⵓⵖⵉⵍ, ⵎⴰⵛⴰ ⵙ ⵍⵅⴰⴹⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("PM1_15","087_1_15","PHM","1","15","15","ⵎⵉⵏⵣⵉ ⵏⵉⵛⴰⵏ ⵜⵓⵖⴰ ⵉⵎⵎⵙⴻⴱⴹⴰ ⵅⴰⴽ ⵉ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵖⴰⵔⴻⴽ ⵢⵉⵍⵉ ⵄⴰⵡⴻⴷ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("PM1_16","087_1_16","PHM","1","16","16","ⵣⵉ ⵙⵙⴰ ⴷ ⵜⵙⴰⵡⴻⵏⵜ ⵡⴰⵔ ⵉⴵⵉ ⵄⴰⴷ ⴰⵎ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵎⴰⵛⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉ ⵉⴵⴰⵏ ⴽⵜⴰⵔ ⵣⴻⴳ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⴰⵎ ⵡⵓⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ, ⵉ ⵏⴻⵛⵛ ⴱⴻⵄⴷⴰ, ⵎⴰⵀⵓ ⵉ ⵛⴻⴽ, ⴰⵎ ⴷⵉ ⴷⴷⴰⵜ ⴰⵎ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ! ");
INSERT INTO rift_vpl VALUES ("PM1_17","087_1_17","PHM","1","17","17","ⵎⴰⵍⴰ ⵜⴻⴵⵉⴷ ⴷ ⴰⵎⵄⴰⵛⴰⵔ ⴰⴽⵉⴷⵉ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⵇⴻⴱⵍ ⵉ-ⵜ ⴰⵎ ⵡⴻⵏⵏⵉ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PM1_18","087_1_18","PHM","1","18","18","ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⴹⴹⴰⵔⵔⵉ ⵛⴻⴽ ⵏⵉⵖ ⵣⴻⵄⵎⴰ ⴷⴰⵢⴻⵙ ⴰⵎⴰⵔⵡⴰⵙ, ⴻⴳⴳ ⵉ-ⵜ ⵅⴰⴼⵉ! ");
INSERT INTO rift_vpl VALUES ("PM1_19","087_1_19","PHM","1","19","19","ⵏⴻⵛⵛ, ⴱⵓⵍⵓⵙ, ⵓⵔⵉⵖ ⵙ ⵓⴼⵓⵙ ⵉⵏⵓ, ⴰⵇⴰ ⴰⴷ ⵜ ⵅⴻⴵⵚⴻⵖ! ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵇⵇⴰⵔⴻⵖ ⵛⴰ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵛⴻⴽ ⵜᵉⵜⵜⵓⵔⵙⴻⴷ ⴰⵢⵉ ⵉⵅⴻⴼ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("PM1_20","087_1_20","PHM","1","20","20","ⵡⴰⵀ, ⴰ ⵜⴰⵡⵎⴰⵜ ⵉⵏⵓ, ⴰⵇⴰ ⵜⵜⵡⴰⵙⵙⴰⵔⴻⵢⵢⵃⴻⵖ ⵣⵣⴰⵢⴻⴽ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵙⴰⵔⴻⵢⵢⴻⵃ ⵜⴰⵢⵔⵉ ⵉⵏⵓ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("PM1_21","087_1_21","PHM","1","21","21","ⵏⴻⵛⵛ ⵜⵜⵉⵇⵇⴻⵖ ⴰⴷ ⴰⵢⵉ ⵜⴻⵙⵍⵉⴷ. ⵓⵔⵉⵖ ⴰⵛ-ⴷⴷ, ⵓⵛⴰ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵛⴻⴽ ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵀⵓ ⵎⵉⵏ ⴷ ⴰⵛ ⵉⵏⵉⵖ. ");
INSERT INTO rift_vpl VALUES ("PM1_22","087_1_22","PHM","1","22","22","ⵙⴻⵡⵊⴻⴷ ⴰⵢⵉ ⴰⵎⵛⴰⵏ ⵎⴰⵏⵉ ⵖⴰ ⵙⵙⴻⵏⵙⴻⵖ, ⵎⵉⵏⵣⵉ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵔⴻⵣⴼⴻⵖ ⵙ ⵜⵥⴰⴵⵉⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("PM1_23","087_1_23","PHM","1","23","23","ⵉⴱⴰⴼⵔⴰⵙ, ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵉ ⴷⴰ ⴷⵉ ⵍⴻⵃⴱⴻⵙ ⴷⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵉⵙⴻⴵⴻⵎ ⵅⴰⴽ ⵙ ⵍⴻⵀⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("PM1_24","087_1_24","PHM","1","24","24","ⵓⵍⴰ ⴷ ⵎⴰⵔⴽⵓⵙ ⴷ ⴰⵔⵉⵙⵜⴰⵔⵅⵓⵙ ⴷ ⴷⵉⵎⴰⵙ ⴷ ⵍⵓⴽⴰ ⵉⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵉⵛⴻⵏ ⴰⴼⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("PM1_25","087_1_25","PHM","1","25","25","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽ-ⴷ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ. ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("HB1_1","088_1_1","HEB","1","1","1","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵄⴷⵓⵏ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⴽⵓⵍ ⵍⵡⴻⵇⵜ ⵓ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⴱⵔⵉⴷⴻⵏ ⴰⴽ-ⴷ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵙ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB1_2","088_1_2","HEB","1","2","2","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ-ⴰ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⵇⴰ ⵉⵙⵙⵉⵡⴻⵍ-ⴷⴷ ⴰⴽⵉⴷⵏⴻⵖ ⵙ ⵎⵎⵉⵙ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴰ ⴷ ⴰⵡⵔⵉⵜ ⵏ ⴽⵓⵍⵛⵉ, ⵙ ⵡⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉⴳⴳⴰ ⵣⵣⵎⴰⵏⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("HB1_3","088_1_3","HEB","1","3","3","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵜⴰⵍⴻⵍⵍⴻⵛⵜ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵜⵜⴻⵙⵡⵉⵔⵜ ⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⴻⴱⴱⵓⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ. ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵉⵣⴷⴻⴳ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⴷⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵉⵔⵓⵃ ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏ ⵍⵄⴰⴹⵉⵎ ⴷⵉ ⵍⵓⵄⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("HB1_4","088_1_4","HEB","1","4","4","ⵏⴻⵜⵜⴰ ⵢⵓⵄⵍⴰ ⴰⵟⵟⴰⵙ ⵅ ⵍⵎⴰⵍⴰⴽⴰⵜ ⴰⵎ ⵉⵙⴻⵎ ⵉ ⵉⵟⵟⴻⴼ ⴷ ⵍⵡⴰⵔⵜ, ⴰⵇⴰ ⵉⵛⵏⴰ ⵅ ⵡⴻⵏⵏⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB1_5","088_1_5","HEB","1","5","5","ⵎⵉⵏⵣⵉ ⵉ ⵎⴰⵏ ⵜⴻⵏ ⵣⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉⵏⵏⴰ ⴰⵔⴻⴱⴱⵉ: “ⵎⵎⵉ ⵉ ⵜⴻⴵⵉⴷ ⵛⴻⴽ, ⴰⵙⵙ-ⴰ ⵏⴻⵛⵛ ⵊⵊⵉⵖ-ⴷⴷ ⵛⴻⴽ!”, ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵉⵍⵉⵖ ⴷ ⴱⴰⴱⴰⵙ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵢⵉ ⵢⵉⵍⵉ ⴷ ⵎⵎⵉ”? ");
INSERT INTO rift_vpl VALUES ("HB1_6","088_1_6","HEB","1","6","6","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵅⵎⵉ ⴷⴷ-ⵉⵙⵙⵉⴷⴻⴼ ⴰⵎⴻⵏⵣⵓ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵏⵏⴰ: “ⴰⴷ ⴰⵙ ⵙⴻⵊⴷⴻⵏⵜ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("HB1_7","088_1_7","HEB","1","7","7","ⵎⴰⵛⴰ ⵅ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉⵏⵏⴰ: “ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ, ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵃⴷⵓⴷⵓⵇⴻⵏ”, ");
INSERT INTO rift_vpl VALUES ("HB1_8","088_1_8","HEB","1","8","8","ⵎⴰⵛⴰ ⵅ ⵎⵎⵉⵙ: “ⵍⵄⴰⵔⵛ ⵏⵏⴻⵛ, ⴰ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵉⴵⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵣⴻⴵⴰⴹ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵏⵏⴻⵛ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴰⵣⴻⴵⴰⴹ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB1_9","088_1_9","HEB","1","9","9","ⴰⵇⴰ ⵜⴻⵅⵙⴻⴷ ⵜⴰⵙⴻⴳⴷⴰ, ⵜⵛⴰⵔⵀⴻⴷ ⵍⵖⴰⵔ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵉⴷⵀⴻⵏ ⵉ ⵛ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵛ, ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵙⴻⵏⵏⴻⵊ ⵉ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("HB1_10","088_1_10","HEB","1","10","10","ⵓⵛⴰ ⵅⴻⵏⵏⵉ: “ⵣⴻⴳ ⵓⴱⴻⴷⴷⵓ ⵜⴻⴳⴳⵉⴷ ⵛⴻⴽ ⴷⵙⴰⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵊⴻⵏⵡⴰⵏ ⴵⴰⵏ ⴷ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HB1_11","088_1_11","HEB","1","11","11","ⵉⵏⴰ ⴰⴷ ⵜⵜⵡⴰⵜⴻⵃⵃⴰⵏ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⴷⵓⵎⴻⴷ, ⵓⵛⴰ ⵉⵏⴰ ⵎⴰⵔⵔⴰ ⴰⴷ ⴰⵔⵛⴰⵏ ⴰⵎ ⵡⴰⵔⵔⵓⴹ. ");
INSERT INTO rift_vpl VALUES ("HB1_12","088_1_12","HEB","1","12","12","ⴰⵎⴻⵛⵏⴰⵡ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⴰⴷ ⵜⴻⵏ ⵜⵜⴹⴻⴼⵙⴻⴷ. ⴰⴷ ⵜⵜⵡⴰⴱⴻⴷⴷⵍⴻⵏ ⴰⵎ ⵡⴰⵔⵔⵓⴹ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴰⴷ ⵜⵉⵍⵉⴷ ⴷ ⵡⴻⵏⵏⵉ ⵓⵛⴰ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵏⵏⴻⵛ ⵡⴰⵔ ⵇⴻⵟⵟⵉⵏ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("HB1_13","088_1_13","HEB","1","13","13","ⵎⴰⵛⴰ ⵉ ⵎⴰⵏ ⵜⴻⵏ ⵣⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉⵏⵏⴰ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ: “ⵇⵇⵉⵎ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵉⵏⵓ ⴰⵍ ⴷ ⵖⴰ ⴳⴳⴻⵖ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵛ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ”? ");
INSERT INTO rift_vpl VALUES ("HB1_14","088_1_14","HEB","1","14","14","ⵎⴰ ⵡⴰⵔ ⴵⵉⵏⵜ ⵏⵉⵜⴻⵏⵜⵉ ⴷ ⴰⵔⵔⵓⵃⴰⵜ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ, ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏⵜ-ⵉ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵅⵅⴰⵔⴻⵏⵜ ⵉ ⵢⵉⵏⵏⵉ ⵖⴰ ⵉⵡⴰⵔⵜⴻⵏ ⵜⵓⴷⴰⵔⵜ? ");
INSERT INTO rift_vpl VALUES ("HB2_1","088_2_1","HEB","2","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵡⵛ ⵜⴰⵢⵏⵉⵜ ⴽⵜⴰⵔ ⵉ ⵎⵉⵏ ⵏⴻⵙⵍⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏᵉⵜⵜⴻⴼⴼⴻⵖ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("HB2_2","088_2_2","HEB","2","2","2","ⵎⵉⵏⵣⵉ, ⵎⴰⵍⴰ ⴰⵡⴰⵍ ⵉ ⵉⵏⵏⴰⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵜⵓⵖⴰ ⵜⴱⴻⴷⴷ ⵓ ⵎⴰⵔⵔⴰ ⵡⵉ ⵜ ⵉⵙⵍⵉⵏ, ⵎⴰⵛⴰ ⵉⵄⴷⵓ ⵅⴰⵙ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⴻⴵⴻⵚ ⵙ ⵍⵃⴻⵇⵇ, ");
INSERT INTO rift_vpl VALUES ("HB2_3","088_2_3","HEB","2","3","3","ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⴰⴷ ⵏⴰⵔⵡⴻⵍ ⵏⴻⵛⵛⵉⵏ, ⵎⴰⵍⴰ ⵏⴻⵙⵙⴻⵃⵇⴰⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵉⴵⴰⵏ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵜⵜⵡⴰⴹⴻⵎⵏⴻⵏⵜ ⴰⵏⴻⵖ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵊⴰⵔⴰⵏⴻⵖ ⵉ ⵜⵓⵖⴰ ⵜⴻⵏⵜ ⵣⵣⴰⵢⴻⵙ ⵉⵙⵍⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("HB2_4","088_2_4","HEB","2","4","4","ⵓⵎⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵛⵀⴻⴷ ⴰⴽⵉⴷⵙⴻⵏ ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⴷ ⵍⵎⵓⵄⵊⵉⵣⴰⵜ ⴷ ⵍⴻⵄⵊⴰⵢⴻⴱ ⵉⴼⴰⵔⵣⴻⵏ ⵓ ⵙ ⵜⵎⴻⵡⵛⵉ ⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵜⵉⵏⵏⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("HB2_5","088_2_5","HEB","2","5","5","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵙⵙⴰⵔⵙ ⵛⴰ ⵣⵣⵎⴰⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵅ ⵜⴻⵏⵏⵉ ⵏⴻⵙⵙⵉⵡⴻⵍ, ⵙⴰⴷⵓ ⵍⵓⵎⵓⵔ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("HB2_6","088_2_6","HEB","2","6","6","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵛⴻⵀⵀⴷⴻⵏⵜ ⵓ ⵇⵇⴰⵔⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⵎⵉⵏ ⵉⵄⵏⴰ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵛⴻⴽ ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵅⴰⵔⵔⴰⵚⴻⵏ, ⵓ ⵎⵉⵏ ⵉⵄⵏⴰ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵛⴻⴽ ⵉ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵀⵉⵍⵍⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("HB2_7","088_2_7","HEB","2","7","7","ⵛⴻⴽ ⵜⴻⴳⴳⵉⴷ ⵜ ⵛⵡⴰⵢⵜ ⵙⴰⴷⵓ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵜⴻⴳⴳⵉⴷ ⴰⵙ ⴰⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⵅ ⵓⵅⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵜⴻⵡⵛⵉⴷ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("HB2_8","088_2_8","HEB","2","8","8","ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⴻⴳⴳⵉⴷ ⵜⴻⵏⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ.” ⵓⵎⵉ ⵉⴳⴳⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵉⵊⵊⵉ ⵡⴰⵍⵓ ⵡⴰⵔ ⵜ ⵉⴳⴳⵉ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ. ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵡⴰⵔ ⵏⵥⴰⵔ ⵄⴰⴷ ⵎⴰⵔⵔⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ, ");
INSERT INTO rift_vpl VALUES ("HB2_9","088_2_9","HEB","2","9","9","ⵎⴰⵛⴰ ⵏⴻⵜⵜⵡⴰⵍⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ, ⴰⵇⴰ-ⵜ ⴷ ⵢⴰⵙⵓⵄ, ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴳⴳ ⵛⵡⴰⵢⵜ ⵙⴰⴷⵓ ⵍⵎⴰⵍⴰⴽⴰⵜ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵡⴻⴷⴷⴻⴱ ⵏ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⵡⴰⵍⴰ ⵉ-ⵜ ⵙ ⵜⵜⴰⵊ ⵏ ⵓⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ, ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵇⵇⴰⵙ ⵍⵎⴻⵡⵜ ⵉ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⴹⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB2_10","088_2_10","HEB","2","10","10","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵍⵉⵇ ⴰⵙ ⵉ ⵏⴻⵜⵜⴰ ⵙ ⵡⴻⵏⵏⵉ ⵓ ⵉ ⵡⴻⵏⵏⵉ ⴵⴰⵏⵜ ⵎⴰⵔⵔⴰ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ - ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵡⵢⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵖⴰⵔ ⵓⵄⵓⴵⵉ - ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴽⴻⵎⵎⴻⵍ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⵙ ⵓⵡⴻⴷⴷⴻⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB2_11","088_2_11","HEB","2","11","11","ⵎⵉⵏⵣⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ, ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷ ⵉⵊⵊⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵙⴻⴹⵃⵉ ⵛⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⴰⵖⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("HB2_12","088_2_12","HEB","2","12","12","ⵓⵎⵉ ⵉⵏⵏⴰ: “ⴰⴷ ⴱⴰⵔⵔⵃⴻⵖ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵉⵏⵓ ⵙ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⴰⴷ ⵛⴻⴽ ⵚⴻⴱⴱⵃⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("HB2_13","088_2_13","HEB","2","13","13","ⵓⵛⴰ ⵄⴰⵡⴻⴷ: “ⵏⴻⵛⵛ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⵜⵉⵇⵇⴻⵖ!” ⵓⵛⴰ ⵄⴰⵡⴻⴷ: “ⴰⵇⴰ ⴷⴰ, ⵏⴻⵛⵛ ⴷ ⵜⴰⵔⵡⴰ ⵉ ⴷ ⴰⵢⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("HB2_14","088_2_14","HEB","2","14","14","ⵎⵉⵏⵣⵉ ⵜⴰⵔⵡⴰ ⵛⴰⵔⵛⴻⵏ ⴷⴻⴳ ⵡⴻⵢⵙⵓⵎ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵉⵛⴰⵔⵛ ⴰⵎⵎⵓ ⴽⵉⴼⴽⵉⴼ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴻⵟⵟⴻⵍ ⵙ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵅ ⵍⵎⴻⵡⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵛⵛⵉⵟⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("HB2_15","088_2_15","HEB","2","15","15","ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⴼⴻⴽⴽ ⵉⵏⵏⵉ ⵉⵙⵙⴻⵄⴷⴷⵓⵏ ⵇⴰⵄ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⴰⵎ ⵉⵙⴻⵎⵖⴰⵏ ⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵏ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("HB2_16","088_2_16","HEB","2","16","16","ⵎⵉⵏⵣⵉ ⵍⵎⴻⵡⵜ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⴻⴵⵉ ⵚⵚⵓⵍⵟⴰ ⵅ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵎⴰⵛⴰ ⵍⵎⴻⵡⵜ ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("HB2_17","088_2_17","HEB","2","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴰⵎ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵙ ⵣⵉ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴰⵔⵃⵉⵎ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷⵉ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴱⵍⴰ ⵍⵄⵉⴱ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴷⴷⵏⵓⴱ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("HB2_18","088_2_18","HEB","2","18","18","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⴷⵉ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵉⵡⴻⴷⴷⴻⴱ ⵓ ⵉⵜⵜⵡⴰⵊⴰⵔⵔⴻⴱ, ⴰⵇⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵄⴰⵡⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⴰⵔⵔⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB3_1","088_3_1","HEB","3","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵙ ⵜⵍⴰⵖⵉⵜ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵅⵣⴰⵔⴻⵎ ⵖⴰⵔ ⵔⵔⴰⵙⵓⵍ ⵡⴰⵏⵉⵜⴰ, ⵖⴰⵔ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ,    ");
INSERT INTO rift_vpl VALUES ("HB3_2","088_3_2","HEB","3","2","2","ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉ-ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵎⵓⵙⴰ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB3_3","088_3_3","HEB","3","3","3","ⵎⵉⵏⵣⵉ ⴰⵄⵓⴵⵉ ⵏ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙ ⵡⴰⵟⵟⴰⵙ ⵅ ⵡⴻⵏⵏⵉ ⵏ ⵎⵓⵙⴰ, ⴰⵎ ⵛⵛⴰⵏ ⵏ ⵓⴱⴻⵏⵏⴰⵢ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵉⵎⵖⴰⵔ ⵅ ⵛⵛⴰⵏ ⵏ ⵍⴻⴱⵏⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB3_4","088_3_4","HEB","3","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵜᵉⵜⵜⵡⴰⴱⵏⴰ ⵣⴻⴳ ⵉⵊⵊⴻⵏ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⴱⴻⵏⵏⴰⵏ ⵎⴰⵔⵔⴰ ⴷ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB3_5","088_3_5","HEB","3","5","5","ⵜᵉⵜⵜⵡⴰⵡⴻⴽⴽⴻⵍ ⵉ ⵎⵓⵙⴰ ⵎⴰⵔⵔⴰ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵓⵎⵙⴻⵅⵅⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵛⵀⴻⴷ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵎⵉⵏ ⵅⴻⴼ ⵖⴰ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("HB3_6","088_3_6","HEB","3","6","6","ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⴰⵎ ⵎⵎⵉⵙ ⵉⵜⵜⵡⴰⴳⴳ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵓ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵏⴻⵛⵛⵉⵏ, ⵎⴰⵍⴰ ⵏⴻⵇⵇⵉⵎ ⵏᵉⵜⵜⴻⵟⵟⴻⴼ ⴷⵉ ⵍⴰⵎⴰⵏ ⵓ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏ ⵓⵙⵉⵜⴻⵎ ⵏⵏⴻⵙ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB3_7","088_3_7","HEB","3","7","7","ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉⵏⵏⴰ ... “ⴰⵇⴰ ⴰⵙⵙ-ⴰ ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("HB3_8","088_3_8","HEB","3","8","8","ⵡⴰⵔ ⵜⵜᵉⵙⵙⴻⵇⵙⵉⵃⴻⵎ ⵛⴰ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵙⵄⴰⵔⴻⵎ, ⴰⵎ ⵉⵏⵏⵉ ⵉⵖⴻⵡⵡⵖⴻⵏ, ⴰⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵊⴰⵔⵔⴻⴱ ⴷⵉ ⵍⴻⵅⵍⴰ, ");
INSERT INTO rift_vpl VALUES ("HB3_9","088_3_9","HEB","3","9","9","ⵓⵎⵉ ⴷ ⴰⵢⵉ ⵊⴰⵔⵔⴱⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ⵇⴻⴵⴱⴻⵏ ⴰⵢⵉ, ⴰⵎ ⵥⵔⵉⵏ ⵜⵉⵎⴻⴳⴳⴰ ⵉⵏⵓ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("HB3_10","088_3_10","HEB","3","10","10","... ⵙ ⵓⵢⴰ ⵄⵉⴼⴼⴻⵖ ⵣⵉ ⵊⵊⵉⵍ ⵏⵏⵉ, ⵏⵏⵉⵖ: ‘ⵡⴰ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉ ⵉⵡⴻⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵛⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵉⵏⵓ!’, ");
INSERT INTO rift_vpl VALUES ("HB3_11","088_3_11","HEB","3","11","11","ⴰⵍⴰⵎⵉ ⵊⵊⵓⴵⴻⵖ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ: ‘ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴷⴼⴻⵏ ⵛⴰ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵉⵏⵓ!’” ");
INSERT INTO rift_vpl VALUES ("HB3_12","088_3_12","HEB","3","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⵃⴹⴰⵎ ⵃⵉⵎⴰ ⵄⴻⵎⵎⴰⵔⵚ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵃⴻⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵖⴰⵔⴻⵙ ⵓⵍ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵉ ⵡⴰⵔ ⵉⵜⵜⵉⵎⵏⴻⵏ ⵓⵎⵉ ⵖⴰ ⵜⴰⴳⴳⵯⴻⵊⴻⵎ ⵅ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB3_13","088_3_13","HEB","3","13","13","ⵎⴰⵛⴰ ⵇⴻⴵⴱⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⴽⵓⵍ ⴰⵙⵙ, ⴰⵍ ⴰⵙⵙ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ: ‘ⴰⵙⵙ-ⴰ!’, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ ⵡⴰⵔ ⵉⵜⵜⴻⵇⵙⵉⵃ ⵛⴰ ⵙ ⵓⵖⴻⴽⴽⵡⵉ ⵏ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("HB3_14","088_3_14","HEB","3","14","14","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⵡⴰⵙⵙⵎⵓⵏ ⴰⵟⵟⴰⵙ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ ⵎⴰⵍⴰ ⵏⴻⵇⵇⵉⵎ ⵏⵛⴻⴱⴱⴰⵔ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ ⴷⵉ ⵍⵄⴰⵀⴷ-ⴰ ⵉ ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB3_15","088_3_15","HEB","3","15","15","ⵙ ⵓⵢⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵎⵎⵓ: “ⴰⵇⴰ ⴰⵙⵙ-ⴰ, ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵍⵃⴻⵙⵙ ⵏ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵜⴻⵙⵙⴻⵇⵙⵉⵃⴻⵎ ⵛⴰ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜ ⵜⴻⵙⵄⴰⵔⴻⵎ.” ");
INSERT INTO rift_vpl VALUES ("HB3_16","088_3_16","HEB","3","16","16","ⵅⴻⵏⵏⵉ ⵎⵉⵏ ⵉⵄⵏⴰⵏ ⵏⵉⵜⵏⵉ ⵉⵏⵏⵉ ⵉⵙⵍⵉⵏ ⵜ, ⵅⴻⵏⵏⵉ ⵖⴻⵡⵡⵖⴻⵏ? ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⴷ ⵉⵏⵏⵉ ⴷⴷ-ⵉⴼⴼⵖⴻⵏ ⵣⵉ ⵎⵉⵚⵔⴰ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ? ");
INSERT INTO rift_vpl VALUES ("HB3_17","088_3_17","HEB","3","17","17","ⵣⵉ ⵎⴰⵏ ⵡⴻⵏ ⵉⵄⵉⴼⴼ ⵏⴻⵜⵜⴰ ⵅⴻⵏⵏⵉ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵅⴹⴰⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵡⴹⴰⵏ ⵉⵖⵙⴰⵏ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰ? ");
INSERT INTO rift_vpl VALUES ("HB3_18","088_3_18","HEB","3","18","18","ⵉ ⵓⵎⵉ ⵉⵊⵊⵓⴵ ⵏⴻⵜⵜⴰ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴷⴼⴻⵏ ⵛⴰ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ? ⵎⴰ ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵜⵜⵉⵇⵇⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("HB3_19","088_3_19","HEB","3","19","19","ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵍⴰ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⴷⴼⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB4_1","088_4_1","HEB","4","1","1","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵃⴹⴰ ⵅⴻⵏⵏⵉ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵣⵣⴰⵢⵡⴻⵎ, ⵓⵎⵉ ⵄⴰⴷ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⵡⴰⵄⴷ ⵏ ⵡⴰⴷⴰⴼ ⴷⵉ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ, ⴰⴷ ⵉⴹⵀⴰⵔ ⵉⵜⵜⵖⵉⵎⴰ ⵖⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵖⴰⵔ ⵡⴰⴷⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("HB4_2","088_4_2","HEB","4","2","2","ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵄⴰⵡⴻⴷ ⵉ ⵏⴻⵛⵛⵉⵏ, ⴰⵎ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵓⵍⴰ ⵉ ⵏⵉⵜⵏⵉ, ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵏⴼⵉⵄ ⵉ ⵢⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⴰ ⴰⴽ-ⴷ ⵍ’ⵉⵎⴰⵏ ⴷⴻⴳ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB4_3","088_4_3","HEB","4","3","3","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ, ⵉⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ, ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ. ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ: “ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵊⵊⵓⴵⴻⵖ ⴷⴻⴳ ⵡⴻⵖⴹⴰⴱ ⵉⵏⵓ: ‘ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴷⴼⴻⵏ ⵛⴰ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵉⵏⵓ!’” ⵓ ⵅⵣⴰⵔ, ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏⵜ ⵣⴻⴳ ⵡⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ, ");
INSERT INTO rift_vpl VALUES ("HB4_4","088_4_4","HEB","4","4","4","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵅ ⵙⵙⴻⴱⵜ: “ⵢⴰⵔⴻⵢⵢⴻⵃ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵎⴰⵔⵔⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴰⵙⵙ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ.” ");
INSERT INTO rift_vpl VALUES ("HB4_5","088_4_5","HEB","4","5","5","ⴰⵎⵎⵓ ⵉ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⴰⵡⴰⵍ-ⴰ ⵡⴰⵏⵉⵜⴰ: “ⵡⴰⵔ ⴷⴷ-ⵜⵜⵉⴷⴼⴻⵏ ⵛⴰ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵉⵏⵓ!” ");
INSERT INTO rift_vpl VALUES ("HB4_6","088_4_6","HEB","4","6","6","ⵓⵎⵉ ⵜⴻⵇⵇⵉⵎ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ-ⴰ, ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵡⴰⵔ ⵓⴷⵉⴼⴻⵏ ⵛⴰ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB4_7","088_4_7","HEB","4","7","7","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⴰ ⵄⴰⵡⴻⴷ, ⴰⵡⴰⵔⵏⵉ ⴰⵟⵟⴰⵙ ⵏ ⵍⵡⴻⵇⵜ, ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏⵏⴻⵖⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵔⵉ ⵇⴱⴻⵍ ⴰⵇⴰ ⴷⴰⵡⵓⴷ ⵉⵏⵏⴰ: “ⴰⵙⵙ-ⴰ ⵎⴰⵍⴰ ⵜⴻⵙⵍⵉⵎ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ, ⵡⴰⵔ ⵙⴻⵇⵙⵉⵃⴻⵎ ⵛⴰ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ!” ");
INSERT INTO rift_vpl VALUES ("HB4_8","088_4_8","HEB","4","8","8","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵢⴰⵛⵓⵡⴰ, ⵎⵎⵉⵙ ⵏ ⵏⵓⵏ, ⵉⵙⵙⵉⴷⴻⴼ ⵉ-ⵜⴻⵏ ⴷⵉ ⴰⵔⵔⴰⵃⴻⵜ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵍⵀⴰⵔⴷ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴷⴰⵡⵓⴷ ⵅ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⵏⵏⴻⵖⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("HB4_9","088_4_9","HEB","4","9","9","ⵙ ⵓⵢⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴰⵇⴰ ⴷⵉⵏ ⵄⴰⴷ ⴰⵔⵔⴰⵃⴻⵜ ⵏ ⵙⵙⴻⴱⵜ ⵉ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB4_10","088_4_10","HEB","4","10","10","ⵎⵉⵏⵣⵉ ⵡⵉ ⵢⵓⴷⴼⴻⵏ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⴻⵙ, ⵢⴰⵔⴻⵢⵢⴻⵃ ⵄⴰⵡⴻⴷ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵜⵉⵏⵏⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB4_11","088_4_11","HEB","4","11","11","ⵙ ⵓⵢⴰ ⵊⵊⴻⵎ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵎⴽⴰⴱⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⴰⵔⵔⴰⵃⴻⵜ ⵏⵏⵉ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵏⵡⴻⵟⵟⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵡⴹⴰⵏ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB4_12","088_4_12","HEB","4","12","12","ⵎⵉⵏⵣⵉ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔ, ⵉⵅⴻⴷⴷⴻⵎ ⵎⴰⵏⵉ ⵎⴰ, ⵉⵇⴹⴻⵄ ⴽⵜⴰⵔ ⵣⵉ ⴽⵓⵍ ⵙⵙⵉⴼ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ, ⵉⵜⵜⴰⴽⴽⵡⴰⴹ ⴰⵍ ⴰⴱⴻⵟⵟⵓ ⵏ ⵍⴻⵄⵎⴰⵔ ⴷ ⴰⵔⵔⵓⵃ, ⴰⵍ ⵜⵜⴰⵙⵉⵄ ⵊⴰⵔ ⵍⴻⵎⴼⴰⵚⴻⵍ, ⴰⵍ ⴰⵢⵎⵉⵔ ⵊⴰⵔ ⵡⴰⴹⵓⴼ ⴷ ⵉⵖⵙⴰⵏ, ⵓⵛⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵜⵏⴰⵡⵉ ⴷ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⵡⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("HB4_13","088_4_13","HEB","4","13","13","ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔ ⵛⴰ, ⵎⴰⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵜⵜⵡⴰⵄⴰⵔⵔⵢⴻⵏⵜ, ⵜⵜⵡⴰⵔⴻⵣⵣⵎⴻⵏⵜ ⵖⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉ-ⴽ-ⴷⴷ ⵉ ⵖⴰ ⵏⴻⴳⴳ ⵍⴻⵃⵙⴰⴱ. ");
INSERT INTO rift_vpl VALUES ("HB4_14","088_4_14","HEB","4","14","14","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰⵎ ⵖⴰⵔⵏⴻⵖ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵎⵖⴰⵔ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵛⴻⴱⴱⴰⵔ ⴷⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB4_15","088_4_15","HEB","4","15","15","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵛⴰ ⴰⴽ-ⴷ ⵜⵓⴹⵄⴻⴼⵜ ⵏⵏⴻⵖ, ⵎⴰⵛⴰ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵊⴰⵔⵔⴱⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵎ ⵏⴻⵛⵛⵉⵏ, ⵎⴰⵛⴰ ⴱⵍⴰ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("HB4_16","088_4_16","HEB","4","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⴷⴷ-ⵏⵇⴰⵔⵔⴻⴱ ⵅⴻⵏⵏⵉ ⵙ ⵜⵜⵉⵇⵇⴻⵜ ⵖⴰⵔ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴹⴰ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴽⵙⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵓⵛⴰ ⴰⴷ ⵏⴰⴼ ⴰⵔⴹⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏ ⵍⵎⴻⵃⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HB5_1","088_5_1","HEB","5","1","1","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ-ⴷⴷ ⵣⴻⴳ ⵉⵡⴷⴰⵏ, ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵡⴷⴰⵏ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷ ⵜⵖⴰⵔⵚⵉⵏ ⵅ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("HB5_2","088_5_2","HEB","5","2","2","ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵎⵎⴰⵔⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵃⵉⵏⵏ ⵅ ⵉⵇⵓⴱⴱⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵡⴻⴷⴷⴰⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⵢⴰⵔⴹ ⵜⵓⴹⵄⴻⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("HB5_3","088_5_3","HEB","5","3","3","ⵎⴰⵖⴰⵔ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵉⵛⵜⴻⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵍⴳⴻⵏⵙ ⵓⵛⴰ ⵄⴰⵡⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB5_4","088_5_4","HEB","5","4","4","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⴽⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵛⵛⴰⵏ-ⴰ, ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵍⴰⵖⴰ ⵀⴰⵔⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("HB5_5","088_5_5","HEB","5","5","5","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⵉⵙⵙⵄⵓⴵⵉ ⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵎⵉ ⵉⴷⵡⴻⵍ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⵉⵙⵙⵄⵓⴵⴰ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰⵔⴻⵙ ⵉⵙⵙⵉⵡⵍⴻⵏ: “ⵛⴻⴽ ⴷ ⵎⵎⵉ, ⵏⴻⵛⵛ ⵊⵊⵉⵖ-ⴷⴷ ⵛⴻⴽ ⴰⵙⵙ-ⴰ!” ");
INSERT INTO rift_vpl VALUES ("HB5_6","088_5_6","HEB","5","6","6","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ ⴷⵉ ⵎⴰⵏⵉ ⵏⵏⴻⵖⵏⵉ: “ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵍⴻⴱⴷⴰ, ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("HB5_7","088_5_7","HEB","5","7","7","ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵢⴰⵔⵔⴻⴹ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ, ⵉⵇⴻⴷⴷⴻⵎ ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⴷ ⵜⵓⵜⵔⴰ ⵙ ⵉⵖⵓⵢⵢⴰⵏ ⴰⵟⵟⴰⵙ ⵓ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵣⵉ ⵍⵎⴻⵡⵜ ⵉ ⵜⵓⴷⴰⵔⵜ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵍⴰ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("HB5_8","088_5_8","HEB","5","8","8","ⵏⴻⵜⵜⴰ, ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ-ⵜ ⴷ ⵎⵎⵉⵙ, ⴰⵇⴰ ⵉⵍⵎⴻⴷ ⵟⵟⴰⵄⴻⵜ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵓ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ ⵉ ⵉⴽⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("HB5_9","088_5_9","HEB","5","9","9","ⴰⵎⵎⵓ ⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⵉⴽⴻⵎⵎⴻⵍ, ⵉⴷⵡⴻⵍ ⴷ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉ ⵖⴰ ⵉⵟⵟⴰⵄⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB5_10","088_5_10","HEB","5","10","10","ⵓⵛⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("HB5_11","088_5_11","HEB","5","11","11","ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⴰⵟⵟⴰⵙ ⵎⵉⵏ ⵖⴰ ⵏⵉⵏⵉ ⵅ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ ⵡⴰⵏⵉⵜⴰ, ⵎⴰⵛⴰ ⵉⵡⵄⴰⵔ ⴰⴷ ⵜ ⵏⴼⴻⵙⵙⴰⵔ, ⵎⵉⵏⵣⵉ ⵜⴷⴻⵡⵍⴻⵎ ⵜⴻⵡⵄⴰⵔⴻⵎ ⴰⴷ ⵜⴻⵙⵍⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HB5_12","088_5_12","HEB","5","12","12","ⵎⴰⵖⴰⵔ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ ⵉ ⵜⴹⴻⴼⴼⴰⵔⴻⵎ ⵜⵖⵓⵔⵉ-ⵢⴰ. ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵡⴻⵎ ⵄⴰⴷ ⴰⴷ ⵜⵍⴻⵎⴷⴻⵎ ⵍⵃⵓⵔⵓⴼ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⴱⴻⴷⴷⵓ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴽⴻⵏⵏⵉⵡ ⵜⴻⵃⴷⴰⵊⴻⵎ ⵄⴰⴷ ⴰⵖⵉ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏ ⵎⴰⵛⵛⴰ ⵉⵊⴻⵀⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB5_13","088_5_13","HEB","5","13","13","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵛⴻⵏ ⴷⴻⴳ ⵓⵖⵉ, ⵡⴰⵔ ⵉⵇⴻⴷⴷ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⴻⵢⵎⵉ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("HB5_14","088_5_14","HEB","5","14","14","ⵎⴰⵛⴰ ⵎⴰⵛⵛⴰ ⵉⵊⴻⵀⴷⴻⵏ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⵎⵖⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⴰⵇⴰ ⵏⵏⵓⵎⴻⵏ ⴰⴷ ⴷⴰⵔⵔⴱⴻⵏ ⵜⴰⵛⵉⵜ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴼⴰⵔⵣⴻⵏ ⵍⵅⴰⵔ ⵅ ⵍⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB6_1","088_6_1","HEB","6","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵊⵊ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⵍⵎⴰⵙⵉⵃ, ⴰⴷ ⵏⵓⵢⵓⵔ ⵣⵣⴰⵜ ⵖⴰⵔ ⵓⴽⴻⵎⵎⴻⵍ. ⵎⴰⵢⴻⵎⵎⵉ ⵅⴻⵏⵏⵉ ⵜⴻⵅⵙⴻⵎ ⴰⴷ ⵜⴻⵙⵙⴰⵔⵙⴻⵎ ⵄⴰⵡⴻⴷ ⴷⵙⴰⵙ ⵏⵏⴻⵖⵏⵉ ⵉ ⵜⵜⵓⴱⴻⵜ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵎⵎⵓⵜⴻⵏ ⵓ ⵉ ⵍ’ⵉⵎⴰⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("HB6_2","088_6_2","HEB","6","2","2","ⵓ ⵉ ⵜⵖⵓⵔⵉ ⵏ ⵓⵙⴻⵖⴹⴻⵚ ⴷ ⵓⵙⴰⵔⵙⵉ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵓⵍⴰ ⵉ ⵜⵏⵓⴽⵔⴰ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴷ ⵍⵃⵉⵙⴰⴱ ⵉ ⵍⴻⴱⴷⴰ? ");
INSERT INTO rift_vpl VALUES ("HB6_3","088_6_3","HEB","6","3","3","ⵎⴰⵍⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵎⴻⵃ ⵙⵉⴷⵉ ⵎⴰⵏ ⴰⵢⴰ, ⴰⴷ ⵜ ⵏⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("HB6_4","088_6_4","HEB","6","4","4","ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵣⴻⵎⵎⴰⵔ ⵉ ⵢⵉⵏⵏⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵉ ⵓⵙⴻⵖⴹⴻⵚ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵓⵛⴰ ⵇⵇⴰⵙⴻⵏ ⵜⴰⵡⵀⵉⴱⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⵓⵛⴰ ⵟⵟⴼⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB6_5","088_6_5","HEB","6","5","5","ⵓⵛⴰ ⵇⵇⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵡⴰⵍ ⵉⵛⵏⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵊⵊⴻⵀⴷ ⵏ ⵣⵣⵎⴰⵏ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB6_6","088_6_6","HEB","6","6","6","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴹⴰⵏ ⵄⴰⵡⴻⴷ, ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⴼⴰⵇⴻⵏ ⵉ ⵜⵜⵓⴱⴻⵜ ⵣⵉ ⵊⴷⵉⴷ, ⵓⵛⴰ ⴰⴷ ⵚⴻⵍⵍⴱⴻⵏ ⵓ ⴰⴷ ⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("HB6_7","088_6_7","HEB","6","7","7","ⵎⵉⵏⵣⵉ ⵜⴰⵎⵎⵓⵔⵜ, ⵜⴻⵏⵏⵉ ⵉⵙⴻⵙⵙⴻⵏ ⴰⵏⵥⴰⵔ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵛⵛⴰⵜⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ, ⵜⴻⵙⵙⵖⴻⵎⵎⵉ ⴰⵖⴻⵎⵎⵓⵢ ⵉⵛⵏⴰ ⵉ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⴼⴻⴵⴻⵃ, ⴰⵇⴰ ⵜⴻⴽⵙⵉ ⵍⴱⴰⵔⴰⴽⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB6_8","088_6_8","HEB","6","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⵙⵙⴻⵖⵎⵉ-ⴷⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷ ⵜⵣⴻⴳⴳⵯⴰⵔⵜ, ⴰⵇⴰ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵓ ⵜⵓⴷⴻⵙ ⵉ ⵏⵏⴻⵄⵍⴻⵜ ⵓⵛⴰ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵛⵎⴰⴹ. ");
INSERT INTO rift_vpl VALUES ("HB6_9","088_6_9","HEB","6","9","9","ⵎⴰⵛⴰ ⵡⴰⵅⵅⴰ ⵏⴻⵙⵙⴰⵡⴰⵍ ⴰⵎⵎⵓ, ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏⵡⴻⵎ ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵇⵏⴻⵄ ⴰⵇⴰ ⴷⵉⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵛⵏⴰⵏ ⵉⵜⵜⵔⴰⵃⴻⵏ ⵏⵉⵛⴰⵏ ⴰⴽ-ⴷ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("HB6_10","088_6_10","HEB","6","10","10","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵜⵜⵓ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵡⴻⵎ ⴷ ⵜⴰⵢⵔⵉ ⵏⵡⴻⵎ, ⵜⵉⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⴻⵛⵏⴻⵎ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⵉ ⵣⵣⴰⵢⴻⵙ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓⵛⴰ ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⴰⵙⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("HB6_11","088_6_11","HEB","6","11","11","ⵎⴰⵛⴰ ⴷⴰⵢⵏⴻⵖ ⵎⴻⵥⵔⵉ ⵃⵉⵎⴰ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⴰⵎⵃⴰⴹ ⴷ ⵉⵊⵊ ⵉ ⵓⴽⴻⵎⵎⴻⵍ ⵏ ⵓⵙⵉⵜⴻⵎ ⴰⵍ ⴰⵏⴻⴳⴳⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("HB6_12","088_6_12","HEB","6","12","12","ⴰⵇⴰ ⵡⴰⵔ ⵜᵉⴷⴷⴻⴽⴽⵡⴰⵍⴰⵎ ⴷ ⵉⵎⴻⵄⴳⴰⵣ, ⵎⴰⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⵎⴻⴹⴼⴰⵔⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵙ ⵍ’ⵉⵎⴰⵏ ⴷ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⵏ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("HB6_13","088_6_13","HEB","6","13","13","ⵎⵉⵏⵣⵉ ⵍⴰⵎⵉ ⵉⵡⴰⵄⴷ ⴰⵔⴻⴱⴱⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⵉⵊⵊⵓⴵ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵉⵎⵖⴰⵔ ⵅⴰⵙ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵉⵊⵊⴰⴵ, ");
INSERT INTO rift_vpl VALUES ("HB6_14","088_6_14","HEB","6","14","14","ⵉⵏⵏⴰ: “ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⴷ ⴰⵛ ⴱⴰⵔⴽⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵛ ⴰⵔⵏⵉⵖ ⴰⵟⵟⴰⵙ ⵙ ⵡⴰⵟⵟⴰⵙ.” ");
INSERT INTO rift_vpl VALUES ("HB6_15","088_6_15","HEB","6","15","15","ⵓⵛⴰ ⴰⵎⵎⵓ, ⴰⵎ ⵉⵜⵜⵚⴻⴱⴱⴰⵔ ⵉⴱⵔⴰⵀⵉⵎ, ⴰⵇⴰ ⵉⴽⵙⵉ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("HB6_16","088_6_16","HEB","6","16","16","ⵎⴰⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵊⵊⵓⴵⴻⵏ ⵖⴰⵔ ⵎⵉⵏ ⵅⴰⵙⴻⵏ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵎⴰⵔⵔⴰ ⴰⵎⵛⵓⴱⴱⴻⵛ ⵊⴰⵔ ⴰⵙⴻⵏ ⴰⴷ ⵉⵇⴹⴰ ⵏⵉⵛⴰⵏ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("HB6_17","088_6_17","HEB","6","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵙ ⵓⴼⴻⵢⵢⴻⴹ ⵉ ⵉⵡⵔⵉⵜⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⴱⴻⴷⴷⵉⵍ ⵛⴰ, ⵓⵛⴰ ⵉⴹⵎⴻⵏ ⵉ-ⵜ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("HB6_18","088_6_18","HEB","6","18","18","ⵃⵉⵎⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵡⴰⵔ ⵜⵜⴱⴻⴷⴷⵉⵍⴻⵏⵜ ⵛⴰ - ⴰⵎ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵅⴻⵏⵏⵉ ⴰⴷ ⵉⵙⵙⵅⴰⵔⵔⴻⵇ ⴰⵔⴻⴱⴱⵉ - ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵉⵜⵜⵡⴰⴳⴳ ⵓⵍ ⵙ ⵡⴰⵟⵟⴰⵙ, ⴰⵇⴰ ⴷⴰⵢⵏⴻⵖ ⴷⵉ ⵏⴻⵛⵛⵉⵏ ⵉⵏⵏⵉ ⵖⴰⵔⴻⵙ ⴰⵔⴻⵡⵍⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⴷⴻⴳ ⵓⵙⵉⵜⴻⵎ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵡⴰⵡⴰⵄⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB6_19","088_6_19","HEB","6","19","19","ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵍⴻⵢⵣⵉⵎ ⵉⵛⴻⴱⴱⴰⵔⴻⵏ ⵙ ⵍⵎⴻⵜⵏⴻⵜ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ, ⵉⵊⵊ ⵏ ⵓⵍⴻⵢⵣⵉⵎ ⵉ ⴷⴷ-ⵉⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵏ ⵡⴰⴷⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("HB6_20","088_6_20","HEB","6","20","20","ⵎⴰⵏⵉ ⵢⵓⴷⴻⴼ ⵢⴰⵙⵓⵄ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵣⵡⴰⵔⴻⵏ ⵅ ⵜⵉⵣⵉ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("HB7_1","088_7_1","HEB","7","1","1","ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ ⵡⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏ ⵙⴰⵍⵉⵎ, ⴰⴽⴻⵀⵀⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵄⵓⴵⵉ ⵅ ⴽⵓⵍⵛⵉ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵇⴰ ⵉⴱⵔⴰⵀⵉⵎ ⵍⴰⵎⵉ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵣⵉ ⵜⴰⵔⴻⵥⵥⵉⵜ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵓ ⵏⴻⵜⵜⴰ ⵉⴱⴰⵔⴻⴽ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("HB7_2","088_7_2","HEB","7","2","2","ⵉⴱⵔⴰⵀⵉⵎ ⵉⴽⵙⵉ ⵉⵊⵊ ⵏ ⵍⴻⵄⵛⵓⵔ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵖⴰⵔⴻⵙ ⵉ ⵏⴻⵜⵜⴰ. ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ: ‘ⴰⵊⴻⴵⵉⴷ ⵏ ⵜⵙⴻⴳⴷⴰ’, ⵓ ⵄⴰⵡⴻⴷ: ‘ⴰⵊⴻⴵⵉⴷ ⵏ ⵙⴰⵍⵉⵎ’, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ‘ⴰⵊⴻⴵⵉⴷ ⵏ ⵍⴻⵀⵏⴰ’. ");
INSERT INTO rift_vpl VALUES ("HB7_3","088_7_3","HEB","7","3","3","ⵏⵃⵍⴰ ⵎⴰ ⵜⵜⵡⴰⵣⴻⵎⵎⴻⵏ ⴱⴰⴱⴰⵙ ⴷ ⵢⴻⵎⵎⴰⵙ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵏ ⵊⵊⴰⴷⵉⵔⴰ, ⵓ ⵏⵃⵍⴰ ⴱⴻⴷⴷⵓ ⵏ ⵡⵓⵙⵙⴰⵏ ⵏⵏⴻⵙ ⵏⵉⵖ ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵜⴻⵇⵇⵉⵎ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏⵏⴻⵙ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB7_4","088_7_4","HEB","7","4","4","ⵅⵣⴰⵔⴻⵎ ⵍⴻⵅⵅⵓ, ⵎⴻⵛⵃⴰⵍ ⵜⵓⵖⴰ ⵉⵎⵖⴰⵔ ⵡⴰⵏⵉⵜⴰ ⵅ ⴰⵔⵔⴰⵢⵙ ⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⵉ ⵜ ⵉⵡⵛⵉⵏ ⵍⴻⵄⵛⵓⵔ ⵣⵉ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ ⵇⴰⵄ! ");
INSERT INTO rift_vpl VALUES ("HB7_5","088_7_5","HEB","7","5","5","ⵎⴰⵖⴰⵔ ⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵣⴻⴳ ⴰⵢⵜ ⵏ ⵍⴰⵡⵉ, ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵃⵉⵎⴰ ⴰⴷ ⴽⵙⵉⵏ ⵍⴻⵄⵛⵓⵔ ⵣⵉ ⵍⴳⴻⵏⵙ, ⵉⵄⵏⴰ ⵣⴻⴳ ⴰⵢⵜⵎⴰⵜⵙⴻⵏ, ⵓⵎⵉ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵄⴰⵡⴻⴷ ⵣⵉ ⴷⵡⴰⵅⴻⵍ ⵏ ⵉⴱⵔⴰⵀⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("HB7_6","088_7_6","HEB","7","6","6","ⵎⴰⵛⴰ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ ⵡⴰⵏⵉⵜⴰ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴻⵏ ⴷⴻⴳ ⵉⴷⵍⵉⵙⴻⵏ ⵏⵙⴻⵏ ⵏ ⵊⵊⴰⴷⵉⵔⴰ, ⵉⴽⵙⵉ ⵣⵉ ⵉⴱⵔⴰⵀⵉⵎ ⵍⴻⵄⵛⵓⵔ ⵓⵛⴰ ⵉⴱⴰⵔⴻⴽ ⵉ ⵡⴻⵏⵏⵉ ⵉⵟⵟⴼⴻⵏ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("HB7_7","088_7_7","HEB","7","7","7","ⴰⵇⴰ ⴱⵍⴰ ⴰⵡⴰⵍ, ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵇⴻⵍⵍ, ⴰⵇⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴱⴰⵔⴻⴽ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵃⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB7_8","088_7_8","HEB","7","8","8","ⴰⵇⴰ ⴷⴰⵏⵉⵜⴰ ⵉⵡⴷⴰⵏ ⵉⴼⴻⵏⵏⴰⵏ ⴽⴻⵙⵙⵉⵏ ⵍⴻⵄⵛⵓⵔ, ⵎⴰⵛⴰ ⴷⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵟⵟⴻⴼ ⵏⴻⵜⵜⴰ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵅ ⵛⴻⵀⵀⴷⴻⵏⵜ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⵉⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB7_9","088_7_9","HEB","7","9","9","ⴰⵎⵎⵓ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵉⵏⵉ ⴱⴻⵍⵍⵉ ⵍⴰⵡⵉ, ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵍⴻⵄⵛⵓⵔ, ⴰⵇⴰ ⵉⵄⴻⵛⵛⴰⵔ ⵄⴰⵡⴻⴷ ⵙ ⵓⴼⵓⵙ ⵏ ⵉⴱⵔⴰⵀⵉⵎ, ");
INSERT INTO rift_vpl VALUES ("HB7_10","088_7_10","HEB","7","10","10","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ-ⵜ ⵄⴰⴷ ⴷⵉ ⴷⵡⴰⵅⴻⵍ ⵏ ⴱⴰⴱⴰⵙ ⴰⵍⴰⵎⵉ ⵉⵎⵙⴰⴳⴰⵔ ⵡⴰⵏⵉⵜⴰ ⴰⴽ-ⴷ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ. ");
INSERT INTO rift_vpl VALUES ("HB7_11","088_7_11","HEB","7","11","11","ⵎⴰⵍⴰ ⵍⴻⴽⵎⴰⵍⴻⵜ ⵜⵓⵖⴰ-ⵜⵜ ⵙ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏ ⵍⴰⵡⵉ, ⵎⵉⵏⵣⵉ ⵜⴰⵏⵉⵜⴰ ⵜᵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵉ ⵍⴳⴻⵏⵙ ⵙ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵢⴻⵎⵎⵉ ⵄⴰⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ? ⵎⴰⵍⴰ ⴰⵎⵎⵓ ⵉ ⵜⴻⴵⴰ, ⵣⴻⵄⵎⴰ ⵉⵏⵏⴰ ⵏⴻⵜⵜⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⵢⵉⵍⵉ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵀⴰⵔⵓⵏ! ");
INSERT INTO rift_vpl VALUES ("HB7_12","088_7_12","HEB","7","12","12","ⵎⴰⵛⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⴱⴻⴷⴷⴻⵍ ⵏ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ, ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⴱⴻⴷⴷⴻⵍ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("HB7_13","088_7_13","HEB","7","13","13","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵎⵉⵅⴻⴼ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵢⴰ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏⵏⴻⵖⵏⵉⵜ, ⵉ ⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⴻⵅⵅⴰⵔ ⵄⴻⵎⵎⴰⵔⵚ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB7_14","088_7_14","HEB","7","14","14","ⴰⵇⴰ ⴱⴰⵢⴻⵏ ⴱⴻⵍⵍⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵢⴰⵀⵓⴷⴰ, ⵣⵉ ⵜⴰⵇⴱⵉⵍⵜ ⵉ ⵡⴰⵔ ⵅ ⵉⵙⵙⵉⵡⴻⵍ ⵎⵓⵙⴰ ⵓⵍⴰ ⵙ ⵢⵉⵊⵊ ⵏ ⵡⴰⵡⴰⵍ ⵅ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("HB7_15","088_7_15","HEB","7","15","15","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵄⴰⵡⴻⴷ ⵜⴱⴰⵏ ⵇⴰⵄ ⵎⵍⵉⵃ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⴷⴷ-ⵉⴽⴽⴰⵔ ⵓⴽⴻⵀⵀⴰⵏ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ, ");
INSERT INTO rift_vpl VALUES ("HB7_16","088_7_16","HEB","7","16","16","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⵡⴻⵚⵚⴰ ⵉ ⵉⵜⵜⵀⵉⵎⴰⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵏ ⵜⵓⴷⴰⵔⵜ ⵡⴰⵔ ⵉⴼⴻⵏⵏⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB7_17","088_7_17","HEB","7","17","17","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵛⵀⴻⴷ ⵅⴰⵙ: “ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⴷⴻⴳ ⵡⴰⵔⵡⴰⵙ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ!” ");
INSERT INTO rift_vpl VALUES ("HB7_18","088_7_18","HEB","7","18","18","ⵎⵉⵏⵣⵉ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵇⴱⴻⵍ ⵜᵉⵜⵜⵡⴰⵅⵍⴻⴼ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵓⴹⵄⴻⴼⵜ ⵏⵏⴻⵙ ⴷ ⴱⵍⴰ ⵏⵏⴼⴰⵄ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB7_19","088_7_19","HEB","7","19","19","ⵎⵉⵏⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵡⵉ ⵇⴰⵄ ⴰⴽⴻⵎⵎⴻⵍ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵙⵉⵜⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵣⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⴰⴷⴻⵙ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("HB7_20","088_7_20","HEB","7","20","20","ⵓ ⵏⴻⵜⵜⴰ ⵉⴹⵎⴻⵏ ⵎⴰⵏ ⴰⵢⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("HB7_21","088_7_21","HEB","7","21","21","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴱⵍⴰ ⵜⴰⵊⴰⴵⵉⵜ, ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵙ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵓⵎⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵙ ⵉⵏⵏⴰ ⵙ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⴷⴰⵡⵓⴷ: “ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵊⵊⵓⴵ, ⵡⴰⵔ ⵉⵙⵙⵅⴰⵔⵔⵉⵇ ⵄⴻⵎⵎⴰⵔⵚ: ‘ⵛⴻⴽ ⴷ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⵎⴰⵍⴽⵉⵚⴰⴷⵉⵇ.’” ");
INSERT INTO rift_vpl VALUES ("HB7_22","088_7_22","HEB","7","22","22","ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⴵⴰ ⵍⵄⴰⵀⴷ-ⴰ, ⵉ ⵣⵉ ⵉⴷⵡⴻⵍ ⵢⴰⵙⵓⵄ ⴷ ⴰⴹⵎⴰⵏ, ⵇⴰⵄ ⵃⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB7_23","088_7_23","HEB","7","23","23","ⵜⵓⵖⴰ ⴷⵉⵏ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵄⴰⵡⴻⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵎⵎⵓⵜⴻⵏ, ⵜⵜⵡⴰⵎⴻⵏⵄⴻⵏ ⴰⴷ ⵇⵇⵉⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB7_24","088_7_24","HEB","7","24","24","ⵎⴰⵛⴰ ⵅ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵅⴰⵙ ⵜⵄⴻⴷⴷⵓ ⵜⵓⴽⴻⵀⵀⴰⵏⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB7_25","088_7_25","HEB","7","25","25","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉ ⴷⴷ ⵖⴰ ⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⴷⴷⴰⵔ ⵉ ⵍⴻⴱⴷⴰ ⵓⵛⴰ ⵉⵡⴻⵀⵀⴻⴱ ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HB7_26","088_7_26","HEB","7","26","26","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵍⵉⵇ ⴰⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⴰⵎ ⵡⴰⵏⵉⵜⴰ: ⴰⵎⴻⵣⴷⴰⴳ, ⴱⵍⴰ ⵍⵖⴻⵛⵛ ⴷ ⵜⴰⵅⵎⵓⵊⵉ, ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵣⴻⴳ ⵉⵎⴻⴷⵏⴰⴱ, ⵢⵓⵄⵍⴰⵏ ⵅ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("HB7_27","088_7_27","HEB","7","27","27","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵍⵅⴻⵚⵚ ⴰⵙⵙ ⵅ ⵡⴰⵙⵙ ⴰⵎ ⵉⵔⵔⵓⵢⴰⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⴰⵎⴻⵣⵡⴰⵔ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵅ ⴷⴷⵏⵓⴱ ⵏ ⵍⴳⴻⵏⵙ, ⵎⵉⵏⵣⵉ ⴰⵢⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ, ⵍⴰⵎⵉ ⵉⵡⵛⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴷ ⵜⴰⵖⴰⵔⵚⵜ. ");
INSERT INTO rift_vpl VALUES ("HB7_28","088_7_28","HEB","7","28","28","ⴰⵇⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵡⴷⴰⵏ ⵉⴹⴻⵄⴼⴻⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵏ ⵜⵊⴰⴵⵉⵜ, ⵡⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵎⵎⵉⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB8_1","088_8_1","HEB","8","1","1","ⵍⵎⵓⴼⵉⴷ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⴰⵏ ⴰⵢⴰ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵢⴻⴼⵓⵙ ⵏ ⵍⵄⴰⵔⵛ ⵏ ⵍⵄⴰⴹⵉⵎ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB8_2","088_8_2","HEB","8","2","2","ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⵢⵢⴰⵔ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵜⵉⴷⴻⵜⵜ ⵏⵏⵉ ⵉⴱⵏⴰ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HB8_3","088_8_3","HEB","8","3","3","ⵎⵉⵏⵣⵉ ⴽⵓⵍ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵄⵄⴻⴷ ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⵜⵉⵡⵀⵉⴱⵉⵏ ⴷ ⵜⵖⴰⵔⵚⵉⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵉ ⵡⴰⵏⵉⵜⴰ ⵄⴰⵡⴻⴷ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵛⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("HB8_4","088_8_4","HEB","8","4","4","ⵎⴻⵄⵍⵉⴽ ⵉⴵⴰ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⴷ ⴰⴽⴻⵀⵀⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴷⵉⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵄⴰⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("HB8_5","088_8_5","HEB","8","5","5","ⵏⵉⵜⵏⵉ ⵙⴻⵅⵅⴰⵔⴻⵏ ⵉ ⵓⵎⴻⴷⵢⴰ ⴷ ⵜⵉⵍⵉ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵎⵓⵙⴰ ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵍⵀⴰ ⴰⴽ-ⴷ ⵓⵇⵉⴹⵓⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⵃⴹⴰⵜ, ⴰⴷ ⵜⴻⴳⴳⴻⴷ ⵎⴰⵔⵔⴰ ⴰⵎ ⵍⵎⵉⵜⴰⵍ ⵡⴻⵏⵏⵉ ⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵅ ⵡⴻⴷⵔⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("HB8_6","088_8_6","HEB","8","6","6","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉⴽⵙⵉ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵜⴻⵛⵏⴰ ⵅⴰⵙ, ⵎⵉⵏⵣⵉ ⵍⵄⴰⵀⴷ ⵉ ⵣⵉ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⵍⵡⴰⵙⵉⵜ, ⴰⵇⴰ ⵃⵙⴻⵏ ⵇⴰⵄ, ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⵙ ⵍⵡⵓⵄⵓⴷ ⵉⵛⵏⴰⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉ ⴷⴷ-ⵉⵜⵜⴰⵙⴻⵏ ⴰⴽ-ⴷ ⵍⵄⴰⵀⴷ ⴰⵇⴷⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("HB8_7","088_8_7","HEB","8","7","7","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵍⵄⴰⵀⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴱⵍⴰ ⵍⵄⵉⴱ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵡⴻⵎⵛⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB8_8","088_8_8","HEB","8","8","8","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵢⵓⴼⴰ ⴷⴰⵢⵙⴻⵏ ⵍⵄⵉⴱ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵡⵓⵙⵙⴰⵏ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⵅⵎⵉ ⵖⴰ ⴳⴳⴻⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ ⴷⵉ ⵍⴻⴽⵎⴰⵔⴻⵜ, ⵉ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓ ⵉ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("HB8_9","088_8_9","HEB","8","9","9","ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵍⵄⴰⵀⴷ ⵏⵏⵉ ⵡⵛⵉⵖ ⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵙⴻⵏ, ⴷⴻⴳ ⵡⴰⵙⵙ ⵎⵉⵏ ⴷⵉ ⵜⴻⵏ ⵟⵟⴼⴻⵖ ⵣⴻⴳ ⵓⴼⵓⵙ, ⴳⴻⵡⵡⴷⴻⵖ ⵜⴻⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ. ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵇⵇⵉⵎⴻⵏ ⵛⴰ ⴷⵉ ⵍⵄⴰⵀⴷ ⵉⵏⵓ, ⵏⴹⴰⵔⴻⵖ ⵜⴻⵏ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("HB8_10","088_8_10","HEB","8","10","10","ⵎⴰⵛⴰ ⴷ ⵡⴰ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⵖⴰ ⵡⵛⴻⵖ ⵉ ⵍⴰⴵ ⵏ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵙⵔⴰⵉⵍ: ‘ⴰⵡⴰⵔⵏⵉ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵉⵏⵏⴰ ⵙⵉⴷⵉ, ⴰⴷ ⴳⴳⴻⵖ ⵉⵣⴻⵔⴼⴰⵏ ⵉⵏⵓ ⴷⵉ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⴰⵔⵉⵖ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙⴻⵏ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ, ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵢⵉ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("HB8_11","088_8_11","HEB","8","11","11","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵎⵎⵉⵙ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⵓⵎⴰⵙ, ⴰⴷ ⵢⵉⵏⵉ: ⵙⵙⴻⵏ ⵙⵉⴷⵉ!, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴰⴷ ⴰⵢⵉ ⵙⵙⵏⴻⵏ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⵏⵙⴻⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB8_12","088_8_12","HEB","8","12","12","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛ ⴰⴷ ⵜⴻⵏ ⵙⵙⴻⵚⴼⵉⵖ ⵣⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵙⴻⵏ, ⵓⵛⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⵜⵜⴼⴻⴽⴽⴰⵔⴻⵖ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("HB8_13","088_8_13","HEB","8","13","13","ⵍⴰⵎⵉ ⵉⵏⵏⴰ: ‘ⵊⴷⵉⴷ!’, ⴰⵇⴰ ⵉⴳⴳⴰ ⵍⵄⴰⵀⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⴰⵇⴷⵉⵎ, ⵓⵛⴰ ⵎⵉⵏ ⵢⴰⵔⵛⴰⵏ ⵓ ⵉⴷⴷⵓⵢⵙⴰⵔ, ⴰⵇⴰ ⴰⴷ ⵉⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HB9_1","088_9_1","HEB","9","1","1","ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔ ⵜⵓⵖⴰ ⴷⵉⵏ ⵍⴻⴼⵔⵓⴹ ⵉ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("HB9_2","088_9_2","HEB","9","2","2","ⵎⵉⵏⵣⵉ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ, ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵍⵇⴻⵏⴷⵉⵍ ⴷ ⵜⵣⴻⵡⴹⴰ ⴷ ⵡⴻⵖⵔⵓⵎ ⵏ ⵡⴻⵙⵛⴰⵏ ⵓⵛⴰ ⵇⵇⴰⵔⴻⵏ ⴰⵙ: ‘ⴰⵇⴻⴷⴷⴰⵙ’. ");
INSERT INTO rift_vpl VALUES ("HB9_3","088_9_3","HEB","9","3","3","ⵎⴰⵛⴰ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏ ⴷⴰⵅⴻⵍ, ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵍⴻⵃⵃⴰⴼ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴰⵇⴷⴰⵙ ⵅ ⵓⵇⴻⴷⴷⴰⵙ’. ");
INSERT INTO rift_vpl VALUES ("HB9_4","088_9_4","HEB","9","4","4","ⴰⵇⴰ ⴷⴰⵢⴻⵙ ⵍⵇⴻⵛⵄⴻⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵍⴻⴱⵅⵓⵔ ⵓⵍⴰ ⴷ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵉⵖⴻⴵⴼⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ. ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵉⵊⵊ ⵏ ⵓⵣⴻⵏⴱⵉⵍ ⵏ ⵡⵓⵔⴻⵖ ⴷⴰⵢⴻⵙ ‘ⵎⴰⵏⵏⴰ’, ⵓ ⴷⴰⵢⴻⵙ ⵓⵍⴰ ⴷ ⵜⴰⵖⵖⴰⵔⵛⵜ ⵏ ⵀⴰⵔⵓⵏ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵓⵡⵡⵛⴻⵏ ⴷ ⵜⴻⵍⵡⵉⵃⵉⵏ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("HB9_5","088_9_5","HEB","9","5","5","ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⴷⵉⵏ ‘ⵉⵅⵉⵔⵓⴱⴻⵏ’ ⵏ ⵍⵄⴻⵣⵣ, ⵉⵏⵏⵉ ⵉⴷⴷⵍⵉⵏ ⵜⴰⵇⴻⴱⴱⴰⵔⵜ ⵏ ⵡⴻⵚⵍⴰⵃ ⵉ ⵉⴵⴰⵏ ⵅ ⵜⵜⴰⴱⵓⵜ ⵙ ⵜⵉⵍⵉ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ. ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴱⵓ ⵍⵡⴻⵇⵜ ⵍⴻⵅⵅⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵅ ⴽⵓⵍ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("HB9_6","088_9_6","HEB","9","6","6","ⵎⴰⵛⴰ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⵜⵜⴰⴷⴼⴻⵏ ⵍⴻⴱⴷⴰ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏⵏⵉ ⵖⴰⵔ ⴱⴰⵔⵔⴰ, ⵜⴻⵏⵏⵉ ⴷ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⴽⴻⵎⵎⵍⴻⵏ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB9_7","088_9_7","HEB","9","7","7","ⵎⴰⵛⴰ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵜⵓⵖⴰ ⵉⵜⵜⴰⴷⴻⴼ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷⴻⴳ ⵓⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⴷⴰⵅⴻⵍ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵉ ⵉⵇⴻⴷⴷⴻⵎ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵍⴰ ⵅ ⵓⵡⴻⴷⴷⴰⵔ ⵏ ⵍⴳⴻⵏⵙ. ");
INSERT INTO rift_vpl VALUES ("HB9_8","088_9_8","HEB","9","8","8","ⵙ ⵜⴻⴱⵔⵉⴷⵜ-ⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⴰⴱⵔⵉⴷ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵡⴰⵎⵎⴻⴹⵀⴰⵔ, ⵓⵎⵉ ⵄⴰⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵜⴱⴻⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("HB9_9","088_9_9","HEB","9","9","9","ⵜⴰⵏⵉⵜⴰ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⴷⵢⴰ ⵉ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⴷⵉ ⵜⵓⵖⴰ ⵜⵜⵇⴻⴷⴷⴰⵎⴻⵏ ⵚⵚⴷⴰⵇⵉ ⴷ ⵜⵖⴰⵔⵚⵉⵏ ⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⴰⴷ ⴰⵡⵢⴻⵏⵜ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵖⴰⵔ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉ-ⵜⴻⵏⵜ ⵉⵇⴻⴷⴷⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB9_10","088_9_10","HEB","9","10","10","ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵜⵓⵖⴰ ⵜⵜⵀⵉⵎⵎⴰⵏⵜ ⵎⵖⵉⵔ ⵎⴰⵛⵛⴰ ⴷ ⵜⵙⴻⵙⵙⵉ ⴷ ⵉⴱⵔⵉⴷⴻⵏ ⵉⴼⴰⵔⵣⴻⵏ ⵏ ⵓⵙⴻⵖⴹⴰⵙ ⴷⴻⴳ ⵡⴰⵎⴰⵏ, ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷ ⵍⴻⴼⵔⵓⴹ ⵉ ⵉⵜⵜⵀⵉⵎⵎⴰⵏ ⴷⴷⴰⵜ ⵡⴰⵀⴰ, ⵜⵜⵡⴰⵎⵓⵔⴻⵏⵜ ⴰⵍ ⵍⵡⴻⵇⵜ ⵏ ⵡⴻⵄⴷⴰⵍ ⵏ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB9_11","088_9_11","HEB","9","11","11","ⵎⴰⵛⴰ ⵍⵎⴰⵙⵉⵃ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ, ⴰⵇⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵅ ⵍⵅⴰⵔ ⵉ ⵉⴳⴳⴰ. ⵏⴻⵜⵜⴰ ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⴽⴻⵎⵎⵍⴻⵏ, ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵛⴰ ⵙ ⵉⴼⴰⵙⵙⴻⵏ, ⵡⴰⵔ ⵜⴻⴵⵉ ⵣⵉ ⵎⵉⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB9_12","088_9_12","HEB","9","12","12","ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵛⴰ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵉⵄⴻⵊⵎⵉⵢⵢⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵢⵓⴷⴻⴼ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴰⴽ-ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⴰⵎⵎⵓ ⵉ ⴷⴷ-ⵢⵉⵡⵉ ⴰⵙⴻⵏⵊⴻⵎ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB9_13","088_9_13","HEB","9","13","13","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵖⴰⵢⴹⴻⵏ ⴷ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵖⵖⴻⴹ ⵏ ⵓⵄⴻⵊⵎⵉ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉ ⵉⵜⵜⵡⴰⵔⵓⵛⵛⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵅⴻⵎⵊⴻⵏ, ⴰⵇⴰ ⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵙⵙⵉⵣⴷⵉⴳⴻⵏ ⵜⴻⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("HB9_14","088_9_14","HEB","9","14","14","ⵎⴻⵛⵃⴰⵍ ⵄⴰⴷ ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵎⴰⵙⵉⵃ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵏⵏⴻⵖ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵎⵎⵓⵜⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵅⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⴰⵇⴰ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵍⴻⴱⴷⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵄⵉⴱ! ");
INSERT INTO rift_vpl VALUES ("HB9_15","088_9_15","HEB","9","15","15","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⵡⴰⵙⵉⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵖⴰⵔ ⵙ ⵍⵎⴻⵡⵜ ⵏⵏⴻⵙ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵙⴻⵏⵊⴻⵎ ⵉ ⵢⵉⵏⵏⵉ ⵉⵅⴻⵟⵟⴰⵏ ⴹⵉⴷⴷ ⵍⵄⴰⵀⴷ ⴰⵎⴻⵣⵡⴰⵔ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⵉ ⵍⵡⴰⵔⵜ ⵏ ⵍⴻⴱⴷⴰ, ⴰⴷ ⵟⵟⴼⴻⵏ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("HB9_16","088_9_16","HEB","9","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⵄⴰⵀⴷ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⵍⵎⴻⵡⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("HB9_17","088_9_17","HEB","9","17","17","ⵎⵉⵏⵣⵉ ⵍⵄⴰⵀⴷ ⴰⴷ ⵉⴷⵡⴻⵍ ⵉⵚⵍⴻⵃ ⵡⴰⵀⴰ ⵅⵎⵉ ⵖⴰ ⵉⵎⵎⴻⵜ ⵃⴻⴷ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵛⴰ ⵏⵉⵛⴰⵏ ⵎⵉⵏ ⵖⴰ ⵢⴻⴽⴽ ⵉⴷⴷⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵍⵄⴰⵀⴷ. ");
INSERT INTO rift_vpl VALUES ("HB9_18","088_9_18","HEB","9","18","18","ⵙ ⵓⵢⴰ ⵓⵍⴰ ⴷ ⵍⵄⴰⵀⴷ ⴰⵎⴻⵣⵡⴰⵔ ⵡⴰⵔ ⵉⵜⵜⵡⴰⴹⵎⴻⵏ ⵛⴰ ⴱⵍⴰ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB9_19","088_9_19","HEB","9","19","19","ⵎⵉⵏⵣⵉ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴽⵓⵍ ⵜⴰⵡⵚⵉⵢⵢⴻⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵇⴰ ⵉⵡⴻⵚⵚⴰ ⵉ ⵍⴳⴻⵏⵙ ⵙ ⵓⴼⵓⵙ ⵏ ⵎⵓⵙⴰ, ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵓⴼⵓⵏⴰⵙ ⴰⵎⴻⵥⵢⴰⵏ ⴰⴽ-ⴷ ⵡⴰⵎⴰⵏ ⵓⵍⴰ ⴷ ⵜⴰⴹⵓⴼⵜ ⵜⴰⵣⴻⴳⴳⵡⴰⵖⵜ ⴷ ⵜⵄⴻⵍⴵⴻⵜ, ⵓⵛⴰ ⵉⵔⵓⵛⵛ ⵉ-ⵜⴻⵏ ⵅ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵍⴳⴻⵏⵙ, ");
INSERT INTO rift_vpl VALUES ("HB9_20","088_9_20","HEB","9","20","20","ⵉⵏⵏⴰ ⴰⵙⴻⵏ: “ⵉⵏⴰ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵄⴰⵀⴷ, ⵉ ⴷ ⴰⵡⴻⵎ ⵢⵓⵎⵓⵔ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("HB9_21","088_9_21","HEB","9","21","21","ⵜⵓⵖⴰ ⵉⵔⵓⵛⵛ ⵄⴰⵡⴻⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵍⴻⵇⵛⵓⵄ ⵏ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵙ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB9_22","088_9_22","HEB","9","22","22","ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏⵜ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵓⵛⴰ ⴱⵍⴰ ⴰⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴰⵔ ⴷⵉⵏ ⵉⴵⵉ ⵛⴰ ⵡⴻⵖⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB9_23","088_9_23","HEB","9","23","23","ⵜⵓⵖⴰ ⵇⴰⵄ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳⴻⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵙ ⵜⵖⴰⵔⵚⴰ ⵉ ⵉⴵⴰⵏ ⴷ ⵍⴻⵎⵜⵓⵍ ⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵎⴰⵛⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⵙ ⵜⵖⴰⵔⵚⵉⵏ ⵉⵛⵏⴰⵏ ⵣⵉ ⵜⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HB9_24","088_9_24","HEB","9","24","24","ⵎⵉⵏⵣⵉ ⵍⵎⴰⵙⵉⵃ ⵡⴰⵔ ⵢⵓⴷⵉⴼ ⵛⴰ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⵙ ⵉⴼⴰⵙⵙⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵜⴰ ⴷ ⵍⵎⵉⵜⴰⵍ ⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴷⴷ-ⵉⴹⵀⴰⵔ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB9_25","088_9_25","HEB","9","25","25","ⵡⴰⵔ ⵉⴵⵉ ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⵜⵜⴰⴷⴻⴼ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵡⴰⵔ ⵉⴵⵉⵏ ⵏⵏⴻⵙ ");
INSERT INTO rift_vpl VALUES ("HB9_26","088_9_26","HEB","9","26","26","- ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴰⵎⵎⵓ ⵉ ⵉⴵⴰ, ⵉⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⵢⴻⵛⵛⵓ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵣⵉ ⴱⴻⴷⴷⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ - ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ, ⵖⴰⵔ ⵇⴻⵟⵟⵓ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵡⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴻⵟⵟⴻⵍ ⴷⴷⵏⵓⴱ ⵙ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB9_27","088_9_27","HEB","9","27","27","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵙ ⵉ ⵉⵡⴷⴰⵏ ⴰⴷ ⵎⵎⵜⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⵡⴰⵔⵏⵉ ⵉ ⵍⵎⴻⵡⵜ ⵏⵙⴻⵏ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵍⵃⵓⴽⵎ, ");
INSERT INTO rift_vpl VALUES ("HB9_28","088_9_28","HEB","9","28","28","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⵉⵎⵎⴻⵡⵛ ⵍⵎⴰⵙⵉⵃ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⴷ ⵜⴰⵖⴰⵔⵚⵜ, ⵉⵡⵛⴰ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⵡⴰⵟⵟⴰⵙ, ⵎⴰⵛⴰ ⵖⴰⵔ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ ⵉ ⵜⵡⴰⵍⴰ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴰⴷ ⵉⵜⵜⵡⴰⵥⴰⵔ ⴱⵍⴰ ⴷⴷⴻⵏⴱ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⵔⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_1","088_10_1","HEB","10","1","1","ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵛⵛⴰⵔⵉⵄⴰ ⴷ ⵜⵉⵍⵉ ⵏ ⵍⵅⴰⵔ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏⵜ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏⵜ ⵜⵖⴰⵔⵚⴰ ⵏⵏⵉ, ⵡⴰⵅⵅⴰ ⵉⵡⵢⴻⵏ ⵜⴻⵏⵜ-ⵉ-ⴷⴷ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ, ⴰⴷ ⴰⵡⵢⴻⵏⵜ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵅ ⵢⵉⵏⵏⵉ ⵜⴻⵏⵜ ⴷⴷ-ⵉⵜⵜⵇⴰⵔⵔⴰⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_2","088_10_2","HEB","10","2","2","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⴱⴰⵏ-ⴷⴷ ⴰⵇⴰ ⵜᵉⵜⵜⴰⵡⵢⴻⵏⵜ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⵜⵡⴰⵙⵙⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵣⴻⴳ ⵓⵡⴻⵀⵀⴻⴱ ⵏ ⵜⵖⴰⵔⵚⴰ ⵏⵙⴻⵏ ⴰⵟⵟⴰⵙ ⵣⴻⴳ ⵡⴰⵎⵉ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴽⴽⵯⵓⵔ ⵄⴰⴷ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵏⵙⴻⵏ ⵙ ⴷⴷⴻⵏⴱ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵜⵜⵡⴰⵙⵙⵉⵣⴻⴷⴳⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("HB10_3","088_10_3","HEB","10","3","3","ⵎⴰⵛⴰ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⵜⵡⴰⵙⵙⴼⴻⴽⴽⴰⵔⴻⵏ ⴰⵙⴻⵏ-ⴷⴷ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⴽⵓⵍ ⴰⵙⴻⴳⴳⵯⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("HB10_4","088_10_4","HEB","10","4","4","ⵎⵉⵏⵣⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⴼⵓⵏⴰⵙⴻⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵖⴰⵢⴹⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵣⵉ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("HB10_5","088_10_5","HEB","10","5","5","ⵙ ⵓⵢⴻⵏⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵏⵏⴰ: “ⵜⵉⵖⴰⵔⵚⴰ ⵏⵉⵖ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵅⵙⴻⴷ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵜⴻⵙⵙⵢⴰⵔⴹⴻⴷ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HB10_6","088_10_6","HEB","10","6","6","ⵜⵉⵖⴰⵔⵚⵉⵏ ⵏ ⵡⴻⵛⵎⴰⴹ ⴰⴽ-ⴷ ⵜⵉⵖⴰⵔⵚⴰ ⵏ ⵍⴻⵀⵏⴰ ⵉ ⴷⴷⵏⵓⴱ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜᵉⵜⵜⴰⵔⴻⴷ.” ");
INSERT INTO rift_vpl VALUES ("HB10_7","088_10_7","HEB","10","7","7","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵏⵏⵉⵖ: “ⵅⵣⴰⵔ, ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ! - ⵎⵉⵏⵣⵉ ⵢⵓⵔⴰ ⵅⴰⴼⵉ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ - ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("HB10_8","088_10_8","HEB","10","8","8","ⵜⵓⵖⴰ ⵉⵏⵏⴰ ⵇⴱⴻⵍ: “ⵜⵉⵖⴰⵔⵚⵉⵏ ⴷ ⵜⴻⵡⵀⵉⴱⵉⵏ ⴷ ⵜⵖⴰⵔⵚⵉⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷ ⵜⵖⴰⵔⵚⵉⵏ ⵉ ⴷⴷⵏⵓⴱ ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⴻⵅⵙⴻⴷ!”, ⵡⴰⵅⵅⴰ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⵜⵜⵡⴰⵇⴻⴷⴷⵎⴻⵏⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("HB10_9","088_10_9","HEB","10","9","9","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵓⵙⵉⵖ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵖ ⵎⵉⵏ ⵜⴻⵅⵙⴻⴷ ⵛⴻⴽ, ⴰ ⴰⵔⴻⴱⴱⵉ.” ⵙ ⵓⵢⴰ ⵉⴽⴽⴻⵙ ⴰⵎⴻⵣⵡⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_10","088_10_10","HEB","10","10","10","ⵎⴰⵖⴰⵔ ⵙ ⵎⴰⵏ ⴰⵢⴰ, ⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵙ ⵜⵖⴰⵔⵚⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("HB10_11","088_10_11","HEB","10","11","11","ⵎⴰⵖⴰⵔ ⴽⵓⵍ ⴰⴽⴻⵀⵀⴰⵏ ⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⴽⵓⵍ ⴰⵙⵙ, ⴰⵇⴰ ⵉⵡⴻⵀⵀⴻⴱ ⴰⵟⵟⴰⵙ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ ⵙⵉⵎⴰⵏⵜ ⵏ ⵜⵖⴰⵔⵚⴰ, ⵜⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵙⵙⵉⵣⴻⴷⴳⴻⵏⵜ ⵣⵉ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("HB10_12","088_10_12","HEB","10","12","12","ⵎⴰⵛⴰ ⵡⴰⵏⵉⵜⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵅ ⴷⴷⵏⵓⴱ, ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⵉⵇⵇⵉⵎ ⵅ ⵢⴻⴼⵓⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB10_13","088_10_13","HEB","10","13","13","ⵣⵉ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜⵔⴰⵊⴰ ⴰⵍ ⴷ ⴰⵙ ⵜⵜⵡⴰⴳⴳⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵏⴻⵙ ⴷ ⵜⴰⵏⴻⴱⴷⴰⵜ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB10_14","088_10_14","HEB","10","14","14","ⵎⵉⵏⵣⵉ ⵙ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⴰⵇⴰ ⵢⵉⵡⵉ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB10_15","088_10_15","HEB","10","15","15","ⵎⴰⵛⴰ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵄⴰⵡⴻⴷ ⵉⵛⵀⴻⴷ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵉⵇⵇⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("HB10_16","088_10_16","HEB","10","16","16","“ⴷ ⵡⴰ ⴷ ⵍⵄⴰⵀⴷ ⵉ ⴷ ⴰⵙⴻⵏ ⵖⴰ ⵡⵛⴻⵖ ⴰⵡⴰⵔⵏⵉ ⵉ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ: ‘ⴰⴷ ⴳⴳⴻⵖ ⵛⵛⴰⵔⵉⵄⴰ ⵉⵏⵓ ⴷⵉ ⵍⴻⵄⵇⴻⵍ ⵏⵙⴻⵏ, ⴰⴷ ⵜⵜ ⴰⵔⵉⵖ ⵄⴰⵡⴻⴷ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB10_17","088_10_17","HEB","10","17","17","ⵓⵛⴰ ⴷⴷⵏⵓⴱ ⵏⵙⴻⵏ ⴷ ⵉⵅⴻⵟⵟⴰⵏ ⵏⵙⴻⵏ, ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⴼⴻⴽⴽⴰⵔⴻⵖ ⵄⴰⴷ.’” ");
INSERT INTO rift_vpl VALUES ("HB10_18","088_10_18","HEB","10","18","18","ⵎⴰⵏⵉ ⵉⵜⵜⵉⵍⵉ ⵅⴻⵏⵏⵉ ⵡⴻⵖⴼⴰⵔ ⵉ ⴷⴷⵏⵓⴱ, ⵡⴰⵔ ⴷⵉⵏ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⵜⵖⴰⵔⵚⵜ ⵅ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("HB10_19","088_10_19","HEB","10","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵜⵜⵉⵇⵇⴻⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ");
INSERT INTO rift_vpl VALUES ("HB10_20","088_10_20","HEB","10","20","20","ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵊⴷⵉⴷ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵎ ⵡⴻⴱⵔⵉⴷ ⵏ ⵊⴷⵉⴷ ⵉ ⴷⴷ-ⵉⵜⵜⴰⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵏ ⵜⴻⵡⵡⴰⵔⵜ, ⵡⴻⵏⵏⵉ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("HB10_21","088_10_21","HEB","10","21","21","ⵓⵛⴰ ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵄⴰⵡⴻⴷ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵅ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB10_22","088_10_22","HEB","10","22","22","ⴻⵊⵊ ⴰⵏⴻⵖ ⵅⴻⵏⵏⵉ ⴰⴷ ⴷⴷ-ⵏⵇⴰⵔⵔⴻⴱ ⵙ ⵡⵓⵍ ⵏ ⵜⵉⴷⴻⵜⵜ, ⴷⵉ ⵜⵜⵉⵇⵇⴻⵜ ⵏ ⵍ’ⵉⵎⴰⵏ, ⴰⵎ ⵜⵜⵡⴰⵔⵓⵛⵛⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⵓ ⵜⵜⵡⴰⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵜⴰⵄⴻⴼⴼⴰⵏⵜ, ⵓ ⴰⵎ ⵜᵉⵜⵜⵡⴰⵙⵙⵉⵔⴷ ⵄⴰⵡⴻⴷ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵖ ⵙ ⵡⴰⵎⴰⵏ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_23","088_10_23","HEB","10","23","23","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵛⴻⴱⴱⴰⵔ ⴷⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵓⵙⵉⵜⴻⵎ ⵏⵏⴻⵖ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵏⴰⵔⵊⵉⵊ, ⵎⵉⵏⵣⵉ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⵉⵏ ⵍⵡⴰⵄⴷ, ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_24","088_10_24","HEB","10","24","24","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵃⴹⴰ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴳⴳ ⵓⵍ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ ⵖⴰⵔ ⵜⴰⵢⵔⵉ ⵓ ⵖⴰⵔ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_25","088_10_25","HEB","10","25","25","ⵡⴰⵔ ⵏᵉⵜⵜⴻⵊⵊⵉ ⵛⴰ ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵏⵏⴻⵖ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⵓⵎⴻⵏ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵃⴻⴹ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⴰⵀⵓ ⵄⴰⴷ ⵅⵎⵉ ⵖⴰ ⵜⵥⴰⵔⴻⵎ ⴰⵇⴰ ⴰⵙⵙ ⵏⵏⵉ ⵢⵉⵡⴻⴹ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("HB10_26","088_10_26","HEB","10","26","26","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵛⴰ ⵏ ⵉⵊⵊ ⵏⴻⵄⵎⴰⴷⴰ ⴰⵡⴰⵔⵏⵉ ⵎⴰ ⵉⵟⵟⴻⴼ ⵜⵓⵙⵙⵏⴰ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵄⴰⴷ ⵜⵖⴰⵔⵚⵜ ⵅ ⴷⴷⵏⵓⴱ, ");
INSERT INTO rift_vpl VALUES ("HB10_27","088_10_27","HEB","10","27","27","ⵎⴰⵛⴰ ⵎⵖⵉⵔ ⴰⵔⴰⵊⵉ ⵏ ⵍⵃⵉⵙⴰⴱ ⵉⵙⵙⵏⴻⵅⵍⵄⴻⵏ ⴷ ⵍⵄⴰⴱⵓⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵛⵛⴻⵏ ⵍⵄⴻⴷⵢⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_28","088_10_28","HEB","10","28","28","ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵃⴻⴷ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵎⵓⵙⴰ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵎⵓⵜ ⴱⵍⴰ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵅ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⵏⴰⵢⴻⵏ ⵏⵉⵖ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵛⵀⵓⴷ. ");
INSERT INTO rift_vpl VALUES ("HB10_29","088_10_29","HEB","10","29","29","ⵎⴻⵛⵃⴰⵍ ⴽⵜⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵀⵡⴰ ⵍⵄⵉⵇⴰⴱ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏ ⵡⴻⵏⵏⵉ ⵉⵄⴻⴼⴼⵙⴻⵏ ⵅ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⵙⵙⴱⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵇⴻⴷⴷⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵙⵙⴻⵃⵇⴰⵔⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴹⴰ? ");
INSERT INTO rift_vpl VALUES ("HB10_30","088_10_30","HEB","10","30","30","ⵎⵉⵏⵣⵉ ⵏⴻⵙⵙⴻⵏ ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ: “ⴰⵏⵜⴰⵇⴻⵎ ⵉ ⵏⴻⵛⵛ ⵓⵎⵉ ⵉⴵⴰ, ⵏⴻⵛⵛ ⴰⴷ ⵜ ⵅⴻⴵⵚⴻⵖ!” ⵓⵛⴰ ⵄⴰⵡⴻⴷ: “ⵙⵉⴷⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("HB10_31","088_10_31","HEB","10","31","31","ⵙⵙⴻⵄⴷ ⴷ ⴰⴱⴰⵔⵛⴰⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵡⴹⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_32","088_10_32","HEB","10","32","32","ⵙ ⵓⵢⴰ ⴼⴻⴽⴽⴰⵔⴻⵎ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵎⴻⵣⵡⵓⵔⴰ ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⵖⴻⴹⵚⴻⵎ ⵓ ⵜⵓⵖⴰ ⵜⴰⵔⴻⴱⴱⵓⵎ ⴰⵎⴻⵏⵖⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵡⴻⵎ ⵜⴻⴽⴽⴰ ⵍⴻⴼⴹⵉⵃⴻⵜ ⴷ ⵍⵎⴻⵃⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HB10_33","088_10_33","HEB","10","33","33","ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵉⵊⵊ ⵏ ⴰⴼⵓⵔⵔⴻⵊ ⵓ ⵜⵛⴰⵔⵛⴻⵎ ⴰⴽ-ⴷ ⵉⵏⵏⴻⵖⵏⵉ ⵓⵎⵉ ⴷⴰⵢⵙⴻⵏ ⵉⵜⵜⵡⴰⴳⴳ ⴰⵎⵎⵓ ⴽⵉⴼⴽⵉⴼ. ");
INSERT INTO rift_vpl VALUES ("HB10_34","088_10_34","HEB","10","34","34","ⵎⵉⵏⵣⵉ ⵜⴻⴽⵙⵉⵎ ⴰⵎⵏⵓⵙ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⴱⴱⵙⴻⵏ, ⵓⵛⴰ ⵜⵇⴻⴱⵍⴻⵎ ⴰⴽⴻⵛⵛⴻⴹ ⵏ ⵡⴰⴳⵍⴰ ⵏⵡⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵖⴰⵔⵡⴻⵎ ⴰⴳⵍⴰ ⵉⵎⵖⴰⵔ ⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB10_35","088_10_35","HEB","10","35","35","ⵡⴰⵔ ⵏⴻⵟⵟⴰⵔⴻⵎ ⵛⴰ ⵜⴰⵔⵢⴰⵙⵜ ⵏⵡⴻⵎ ⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵉⵛⵜ ⵏ ⵍⵎⵓⵏⴻⵜ ⵜⴻⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB10_36","088_10_36","HEB","10","36","36","ⵎⵉⵏⵣⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⵚⵚⴱⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵍⵡⴰⵄⴷ. ");
INSERT INTO rift_vpl VALUES ("HB10_37","088_10_37","HEB","10","37","37","“ⵎⵉⵏⵣⵉ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵉ ⴷⵉⵏⵏⵉ, ⵡⴰⵀ ⴷⵔⵓⵙ, ⴰⵍ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⴰⴷ ⵉⵅⴻⵛⵛ, ⵡⴰⵔ ⵉⵜⵜⵄⴻⵟⵟⴰⵍ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("HB10_38","088_10_38","HEB","10","38","38","ⵎⴰⵛⴰ ⴰⵎⵙⴻⴳⴳⴰⴷ ⵙ ⵍ’ⵉⵎⴰⵏ ⵉⵏⵓ ⴰⴷ ⵉⴷⴷⴰⵔ, ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵙⵎⴻⵃ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵢⴰⵔⴻⵟⵟⵉ ⵍⴻⵄⵎⴰⵔ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("HB10_39","088_10_39","HEB","10","39","39","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⵎⵉⵏ ⵖⴰ ⵏⴻⴳⴳ ⵙ ⵜⴰⵔⴻⵅⵅⵓⵜ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵜⵅⴻⵙⵙⴰⵔⵜ, ⵎⴰⵛⴰ ⵖⴰⵔⵏⴻⵖ ⵍ’ⵉⵎⴰⵏ ⵉ ⵉⵜⵜⴰⵡⵢⴻⵏ ⵖⴰⵔ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HB11_1","088_11_1","HEB","11","1","1","ⵍ’ⵉⵎⴰⵏ ⵍⴻⵅⵅⵓ ⴷ ⴰⴹⵎⴰⵏ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⴷⵉ ⵉⵙⵙⵉⵜⵉⵎ ⴱⵏⴰⴷⴻⵎ, ⴰⵅⵎⵉ ⵜⵉⵏⴰ ⵄⴰⴷ ⵅⴻⴷⴷⵎⴻⵏⵜ, ⵓⵍⴰ ⴷ ⴰⵙⴰⵔⴳⴻⴱ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_2","088_11_2","HEB","11","2","2","ⵎⵉⵏⵣⵉ ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵅ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_3","088_11_3","HEB","11","3","3","ⵙ ⵍ’ⵉⵎⴰⵏ ⵏⴻⴼⵀⴻⵎ ⴱⴻⵍⵍⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴱⴻⵍⵍⵉ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵉ ⴷⴷ-ⵉⵜⵜⴱⴰⵏⴻⵏ ⴰⵇⴰ ⵜⵜⵡⴰⴳⴳⴻⵏⵜ ⵣⵉ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉⵏⵏⵓⴼⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_4","088_11_4","HEB","11","4","4","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵀⴰⴱⵉⵍ ⵉⵇⴻⴷⴷⴻⵎ ⵉⵛⵜ ⵏ ⵜⵖⴰⵔⵚⵜ ⵜⴻⵛⵏⴰ ⴰⵟⵟⴰⵙ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⵉⵇⴻⴷⴷⴻⵎ ⵇⴰⵢⵉⵏ ⵉ ⴰⵔⴻⴱⴱⵉ. ⵙ ⵓⵢⴰ ⵉ ⴷⵉⵏ ⵜⴻⴵⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵅⴰⵙ ⴱⴻⵍⵍⵉ ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ. ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵛⵀⴻⴷ ⵉ ⵜⵖⴰⵔⵚⵜ ⵏⵏⴻⵙ ⵓ ⵙ ⵓⵢⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵄⴰⴷ, ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("HB11_5","088_11_5","HEB","11","5","5","ⵙ ⵍ’ⵉⵎⴰⵏ ⵉⵎⵎⴻⴽⵙⵉ ⵉⵏⵓⵅ ⴱⵍⴰ ⵎⴰ ⵉⵇⵇⴰⵙ ⵍⵎⴻⵡⵜ. ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵄⴰⴷ, ⵎⵉⵏⵣⵉ ⵉⴽⵙⵉ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ. ⵎⵉⵏⵣⵉ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵜ ⵉⴽⵙⵉ, ⵜⵓⵖⴰ ⵅⴰⵙ ⵛⵛⵀⴰⴷⴻⵜ-ⴰ: ⴰⵇⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵟⵟⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB11_6","088_11_6","HEB","11","6","6","ⵎⴰⵛⴰ ⴱⵍⴰ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵢⴰⵔⴹⴰ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⴷⴷ-ⵉⵇⴰⵔⵔⴱⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⴰⴷ ⵢⴰⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⵉⵏ, ⵓ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵅⴻⴵⴰⵚ ⵏ ⵢⵉⵏⵏⵉ ⵅⴰⵙ ⵢⴰⵔⴻⵣⵣⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_7","088_11_7","HEB","11","7","7","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵏⵓⵃ ⵉⵜⵜⴻⴳⴳⵯⴻⴷ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴱⵉⵏⴻⵏ, ⵓⵛⴰ ⵉⴳⴳⴰ ⴰⵖⴰⵔⵔⴰⴱⵓ ⵉ ⵓⵙⴻⵏⵊⴻⵎ ⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵜⵡⴰⵛⵓⵏⵜ ⵏⵏⴻⵙ. ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⵉⵃⴽⴻⵎ ⵅ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷ ⴰⵡⵔⵉⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵏⵏⵉ ⵉⴵⴰⵏ ⵙ ⵍ’ⵉⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_8","088_11_8","HEB","11","8","8","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵉⴱⵔⴰⵀⵉⵎ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵍⴰⵖⴰ, ⵉⵟⵟⴰⵄ ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵉ ⵖⴰ ⵉⵟⵟⴻⴼ ⴷ ⵍⵡⴰⵔⵜ, ⵓⵛⴰ ⵉⴼⴼⴻⵖ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵏ ⵎⴰⵏⵉ ⵖⴰ ⵢⴰⵡⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("HB11_9","088_11_9","HEB","11","9","9","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴰⵎ ⵓⵎⵄⴻⵣⵣⴻⴱ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵉ ⴷ ⴰⵙ ⵉⵜⵜⵡⴰⵡⴰⵄⴷⴻⵏ, ⴰⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ⵏⴻⵜⵜⴰ ⵉⵣⴷⴻⵖ ⴷⴻⴳ ⵉⵇⵉⴹⴰⵏ ⴰⴽ-ⴷ ⵉⵙⵃⴰⵇ ⴷ ⵢⴰⵄⵇⵓⴱ, ⵉⵏⵏⵉ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⴰⴽⵉⴷⴻⵙ ⵏ ⵍⵡⴰⵄⴷ ⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("HB11_10","088_11_10","HEB","11","10","10","ⵎⵉⵏⵣⵉ ⵉⵜⵜⵔⴰⵊⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⴷⵙⵓⵙⴰ ⵉ ⵣⵉ ⵉⴵⴰ ⴰⵔⴻⴱⴱⵉ ⴷ ⴱⴰⴱ ⵏ ⵍⴻⴱⵏⵉ ⴷ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_11","088_11_11","HEB","11","11","11","ⵙ ⵍ’ⵉⵎⴰⵏ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵉ ⵙⴰⵔⴰ ⵊⵊⴻⵀⴷ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ - ⵡⴰⵅⵅⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵔⵓⵡ, ⵓⵛⴰ ⴰⵎ ⵜⵜ ⵜⵓⵖⴰ ⵄⴰⴷ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⵉⵊⴰⵍ ⵏ ⵜⴻⵡⵙⴰⵔ ⵏⵏⴻⵙ - ⵜⵓⵔⵓⵡ-ⴷⴷ ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵙⴻⵏ ⵏⵉⵛⴰⵏ ⴱⴻⵍⵍⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⵡⴰⵄⴷⴻⵏ, ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_12","088_11_12","HEB","11","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵣⴻⴳ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴱⴹⴻⵍ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⵙ ⵜⴻⵡⵙⴰⵔ, ⵜⵜⵡⴰⵍⵡⴻⵏ ⴰⵙ-ⴷⴷ ⴰⵎ ⵢⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵙ ⵓⴱⴰⵔⵔⵓ ⵏⵙⴻⵏ ⵓ ⴰⵎ ⵢⵉⵊⴷⵉ ⵅ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("HB11_13","088_11_13","HEB","11","13","13","ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵎⵎⵓⵜⴻⵏ ⵢⵉⵏⴰ ⵎⴰⵔⵔⴰ ⴱⵍⴰ ⵎⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵎⵉⵏ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵡⴰⵡⴰⵄⴷⴻⵏ, ⵎⴰⵛⴰ ⵥⵔⵉⵏ ⵜ ⵣⵉ ⵍⴰⴳⴳⵯⴰⵊ ⵓⵛⴰ ⴼⴰⵔⵃⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵓⵛⴰ ⵏⴻⵄⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵄⵣⴰⴱ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("HB11_14","088_11_14","HEB","11","14","14","ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⴰⵎ ⵜⵉⵏⴰ, ⵙⵙⴻⵛⵏⴻⵏ ⵎⵍⵉⵃ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⴰⵔⴻⵣⵣⵓⵏ ⵜⴰⵏⴷⵉⵏⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_15","088_11_15","HEB","11","15","15","ⵎⴻⵄⵍⵉⴽ ⴰⵔⵣⵓⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵏⵉⵙ ⴷⴷ-ⴼⴼⵖⴻⵏ, ⵉⵍⵉ ⴰⵇⴰ ⵓⴼⵉⵏ ⵍⴼⵓⵔⵚⴰ ⵃⵉⵎⴰ ⴰⴷ ⵄⴻⵇⴱⴻⵏ ⴷⵉⵏ ⵄⴰⵡⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("HB11_16","088_11_16","HEB","11","16","16","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⴱⴰⵏ-ⴷⴷ ⵎⵍⵉⵃ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⵎⴻⵥⵔⵉ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵏⵉ ⵃⵙⴻⵏ, ⵎⵉⵏ ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵖⴰⵔ ⵜⴻⵏⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵙⴻⴹⵃⵉ ⵛⴰ ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ‘ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ’, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⵙⴻⵏ ⵉⵛⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("HB11_17","088_11_17","HEB","11","17","17","ⵙ ⵍ’ⵉⵎⴰⵏ ⵉⵡⵛⴰ ⵉⴱⵔⴰⵀⵉⵎ, ⵍⴰⵎⵉ ⵉⵜⵜⵡⴰⵇⴻⴵⴻⴱ, ⵉⵙⵃⴰⵇ ⴷ ⵜⴰⵖⴰⵔⵚⵜ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⵙ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵏⵏⵉ ⵉⵟⵟⴻⴼ ⵙ ⵍⵡⴰⵄⴷ, ⵅ ⵓⵄⴰⵍⵟⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("HB11_18","088_11_18","HEB","11","18","18","ⵎⴰⵛⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵙ: “ⴷⵉ ⵉⵙⵃⴰⵇ ⴰⴷ ⴰⵛ ⵍⴰⵖⴰⵏ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("HB11_19","088_11_19","HEB","11","19","19","ⵜⵓⵖⴰ ⵉⵅⴰⵔⵔⴻⵚ ⴰⴽ-ⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⵎⵎⴰⵔ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔ ⵊⴰⵔ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ. ⵙ ⵓⵢⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵖⴰⵔⴻⵙ ⵄⴰⵡⴻⴷ ⵙ ⵡⴻⴱⵔⵉⴷ ⵏ ⵢⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ, ⴰⵎ ⵙ ⵜⵏⵓⴽⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HB11_20","088_11_20","HEB","11","20","20","ⵙ ⵍ’ⵉⵎⴰⵏ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⴷ-ⵉⴳⴳⵓⵔⴻⵏ ⵄⴰⴷ, ⵉⴱⴰⵔⴻⴽ ⵉⵙⵃⴰⵇ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ, ⵢⴰⵄⵇⵓⴱ ⴷ ⵄⵉⵙⵓ. ");
INSERT INTO rift_vpl VALUES ("HB11_21","088_11_21","HEB","11","21","21","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵢⴰⵄⵇⵓⴱ, ⵍⴰⵎⵉ ⵉⵎⵎⵓⵜ, ⵉⴱⴰⵔⴻⴽ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏ ⵢⵓⵙⵓⴼ ⴰⵎ ⵜⵓⵖⴰ ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏ ⵜⴻⵖⵖⴰⵔⵛⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB11_22","088_11_22","HEB","11","22","22","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵢⵓⵙⵓⴼ, ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ, ⵉⵙⵙⵉⵡⴻⵍ ⵅ ⵡⵓⴼⴼⵓⵖ ⵏ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ ⵓⵛⴰ ⵉⵡⴻⵚⵚⴰ ⵜⴻⵏ ⵅ ⵉⵖⵙⴰⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB11_23","088_11_23","HEB","11","23","23","ⵙ ⵍ’ⵉⵎⴰⵏ ⵜⵓⵖⴰ ⵎⵓⵙⴰ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⵅⵍⴻⵇ, ⵉⵜⵜⵡⴰⵙⵙⵏⵓⴼⴼⴰⵔ ⵣⵉ ⵍⵡⴰⵍⵉⴷⵉⵏ ⵏⵏⴻⵙ ⵜⵍⴰⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵍⴰⵎⵉ ⵥⵔⵉⵏ ⴰⵃⴻⵏⵊⵉⵔ ⵉⵚⴱⴻⵃ, ⵓⵛⴰ ⵙ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵔ ⴳⴳⵯⵉⴷⴻⵏ ⵛⴰ ⵣⴻⴳ ⵍⵓⵎⵓⵔ ⵏ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("HB11_24","088_11_24","HEB","11","24","24","ⵙ ⵍ’ⵉⵎⴰⵏ ⵢⵓⴳⵉ ⵎⵓⵙⴰ, ⵍⴰⵎⵉ ⵉⵎⵖⴰⵔ ⵏⴻⵜⵜⴰ, ⴰⴷ ⴰⵙ ⵍⴰⵖⴰⵏ ⵄⴰⴷ ⵎⵎⵉⵙ ⵏ ⵢⴻⴵⵉⵙ ⵏ ⴼⵉⵔⵄⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_25","088_11_25","HEB","11","25","25","ⵎⵍⵉ ⵢⵓⴼⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵜⵜⵡⴰⵣⴻⵢⵢⴰⵔ ⴰⴽ-ⴷ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵍⴰ ⴷ ⵜⴰⵔⵔⵉⵜ ⵏ ⵎⴻⵥⵔⵉ ⴷⵉ ⴷⴷⵏⵓⴱ ⵉ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("HB11_26","088_11_26","HEB","11","26","26","ⵜⵓⵖⴰ ⵉⵃⴻⵙⵙⴻⴱ ⴰⵙⴻⵃⵇⴰⵔ ⵏ ⵍⵎⴰⵙⵉⵃ ⴷ ⴰⴳⵍⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵙⴻⵏⵏⴻⵊ ⵉ ⵍⴻⴽⵏⵓⵣ ⵏ ⵎⵉⵚⵔⴰ, ⵎⵉⵏⵣⵉ ⵜⵓⵖⴰ ⵉⵅⴻⵣⵣⴰⵔ ⵖⴰⵔ ⵣⵣⴰⵜ ⵖⴰⵔ ⵍⵎⵓⵏⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HB11_27","088_11_27","HEB","11","27","27","ⵙ ⵍ’ⵉⵎⴰⵏ ⵉⵊⵊⴰ ⵎⵉⵚⵔⴰ, ⵡⴰⵔ ⵉⴳⴳⵯⵉⴷ ⵛⴰ ⵣⴻⴳ ⵓⵅⴻⵢⵢⴻⵇ ⵏ ⵓⵊⴻⴵⵉⴷ, ⵎⵉⵏⵣⵉ ⵉⵣⵉⵢⵢⴰⵔ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵥⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_28","088_11_28","HEB","11","28","28","ⵙ ⵍ’ⵉⵎⴰⵏ ⵉⴳⴳⴰ ⵜⴰⵖⴰⵔⵚⵜ ⵏ ⵓⵙⴻⵄⴷⵓ, ⵓⵛⴰ ⵉⵔⵓⵛⵛ ⵉⴷⴰⵎⵎⴻⵏ, ⵃⵉⵎⴰ ⴰⵎⴽⴻⵃⵃⴰⴹ ⵏ ⵉⵎⴻⵏⵣⴰ ⵏⵙⴻⵏ ⵡⴰⵔ ⵜⴻⵏ ⵉⵜⵜⵃⵉⴷⵉ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("HB11_29","088_11_29","HEB","11","29","29","ⵙ ⵍ’ⵉⵎⴰⵏ ⵥⵡⴰⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵓⵖⴰⵏⵉⵎ ⴰⵅⵎⵉ ⴽⴽⵉⵏ ⴷⵉ ⵍⴱⴰⵔⵔ, ⴰⵎ ⵜⵜⵡⴰⵚⴰⵔⴹⴻⵏ ⵉⵎⵉⵚⵔⵉⵢⵢⴻⵏ ⵣⵉ ⵍⴻⴱⵃⴰⵔ ⵓⵎⵉ ⵜⵓⵖⴰ ⵅⵙⴻⵏ ⴰⴷ ⴷⴰⵢⴻⵙ ⵛⵓⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_30","088_11_30","HEB","11","30","30","ⵙ ⵍ’ⵉⵎⴰⵏ ⵡⴹⴰⵏ ⵍⴻⵃⵢⵓⴹ ⵏ ⴰⵔⵉⵃⴰ ⵓⵎⵉ ⴽⴽⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⵓⵙⵙⴰⵏ, ⵜⵜⴻⵏⵏⴹⴻⵏ ⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("HB11_31","088_11_31","HEB","11","31","31","ⵙ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵔ ⵜⵀⴻⵍⵍⵉⴽ ⵛⴰ ⵔⴰⵃⴰⴱ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⵄⴻⵏ, ⴰⵎ ⵜⵓⵖⴰ ⵜⴰⵔⴻⵃⵃⴻⴱ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HB11_32","088_11_32","HEB","11","32","32","ⵓⵛⴰ ⵎⵉⵏ ⵖⴰ ⵉⵏⵉⵖ ⵄⴰⴷ? ⵎⵉⵏⵣⵉ ⵍⵡⴻⵇⵜ ⵡⴰⵔ ⵜⵇⴻⴷⴷⵉ ⴰⴷ ⵙⵙⵉⵡⵍⴻⵖ ⵅ ⵊⵉⴷⵄⵓⵏ ⴷ ⴱⴰⵔⴰⴽ ⴷ ⵛⴰⵎⵛⵓⵏ ⴷ ⵢⵉⴼⵜⴰ ⴷ ⴷⴰⵡⵓⴷ ⴷ ⵛⴰⵎⵡⵉⵍ ⵓ ⵅ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵏⴻⵖⵏⵉ, ");
INSERT INTO rift_vpl VALUES ("HB11_33","088_11_33","HEB","11","33","33","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⵅ ⵜⴳⴻⵍⴷⵉⵡⵉⵏ ⵙ ⵍ’ⵉⵎⴰⵏ, ⴳⴳⵉⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⵟⵟⴼⴻⵏ ⵍⵡⵓⵄⵓⴷ, ⵇⵇⵏⴻⵏ ⵉⵅⴻⵏⴼⵓⵛⴻⵏ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB11_34","088_11_34","HEB","11","34","34","ⵙⵙⵅⴻⵙⵢⴻⵏ ⵊⵊⴻⵀⴷ ⵏ ⵜⵎⴻⵙⵙⵉ, ⴰⵔⴻⵡⵍⴻⵏ ⵣⵉ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⴽⵙⵉⵏ ⵊⵊⴻⵀⴷ ⴷⵉ ⵜⵓⴹⵄⴻⴼⵜ, ⴷⴻⵡⵍⴻⵏ ⵊⴻⵀⴷⴻⵏ ⴷⴻⴳ ⵉⵎⴻⵏⵖⴰⵏ ⵓ ⵇⴻⵍⵄⴻⵏ ⵅ ⵍⴻⵎⵔⴰⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_35","088_11_35","HEB","11","35","35","ⴰⵔⵔⵉⵏ-ⴷⴷ ⵉ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵙⴻⵏⵜ ⵙ ⵜⵏⵓⴽⵔⴰ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⵎⵎⵓⵜⴻⵏ ⵙ ⵍⴻⵄⴷⴰⴱ, ⵜⵓⵖⴰ ⵡⴰⵔ ⵜⵜⵔⵉⵊⵉⵏ ⴰⴷ ⵜⵜⵡⴰⴼⴻⴽⴽⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵏⵓⴽⵔⴰ ⵉⵛⵏⴰⵏ ⵃⵙⴻⵏ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ, ");
INSERT INTO rift_vpl VALUES ("HB11_36","088_11_36","HEB","11","36","36","ⵛⴰ ⵏⵏⴻⵖⵏⵉ ⴽⵙⵉⵏ ⴰⴱⴻⵀⴷⴻⵍ ⴷ ⵓⵔⴻⴽⴽⵓⴹ, ⵓ ⵄⴰⴷ ⵉⵏⵏⴻⵖⵏⵉ ⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵓ ⴷⵉ ⵍⴻⵃⴱⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB11_37","088_11_37","HEB","11","37","37","ⵉⵏⵏⴻⵖⵏⵉ ⵜⵜⵡⴰⵔⴻⵊⵎⴻⵏ, ⵜⵜⵡⴰⵇⴻⵙⵙⴻⵏ ⴷⵉ ⵜⵏⴰⵢⴻⵏ, ⵉⵏⵏⴻⵖⵏⵉ ⵎⵎⵓⵜⴻⵏ ⵙ ⵍⴻⵇⴹⴻⵄ ⵏ ⵙⵙⵉⴼ, ⵜⴻⵍⵄⴻⵏ ⴰⵎ ⴰⵔⴹⴻⵏ ⵉⵍⵎⴰⵡⴻⵏ ⵏ ⵡⵓⴵⵉ ⴷ ⵉⵖⴰⵢⴹⴻⵏ, ⴷⴰⵢⵙⴻⵏ ⵍⴻⵖⴱⴻⵏ, ⵜⵜⵡⴰⵃⵚⴰⵔⴻⵏ, ⵜⵜⵡⴰⴹⴻⵍⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB11_38","088_11_38","HEB","11","38","38","ⵏⵉⵜⵏⵉ ⴷ ⵉⵡⴷⴰⵏ ⵉ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵜⴻⵙⵙⴷⴰⵀⴻⴵ ⴷⴷⵓⵏⵏⵉⵜ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⴻⵙ ⵣⴻⴷⵖⴻⵏ. ⵏⵉⵜⵏⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⴻⵍⵄⴻⵏ ⴷⵉ ⵍⴻⵅⵍⴰⵡⴰⵜ, ⵅ ⵉⴷⵓⵔⴰⵔ ⵓ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⴷ ⵉⵅⴻⵔⴷⵓⵙⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("HB11_39","088_11_39","HEB","11","39","39","ⵎⴰⵔⵔⴰ ⵉⵏⴰ ⵎⵉⵅⴻⴼ ⵜᵉⵜⵜⵡⴰⴼ ⵉⵛⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⵛⴰ ⴷⵉ ⵍⵡⴰⵄⴷ, ");
INSERT INTO rift_vpl VALUES ("HB11_40","088_11_40","HEB","11","40","40","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵉⵣⵡⴰⵔ ⵉⵥⵔⴰ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⵉⴽⴽⵯⵉⴹⴻⵏ ⵛⴰ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ ⴱⵍⴰ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("HB12_1","088_12_1","HEB","12","1","1","ⵙ ⵓⵢⴰ ⵏⴻⵛⵛⵉⵏ ⵄⴰⵡⴻⴷ, ⵓⵎⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵏⵏⴹⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⵛⵀⵓⴷ-ⴰ ⴰⵎ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⴰⴷ ⵏⴻⵏⴹⴰⵔ ⵎⴰⵔⵔⴰ ⴷⴷⵇⴻⵍ ⵏ ⴷⴷⴻⵏⴱ ⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⵉ ⵍⴻⴱⴷⴰ. ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⵓⵢⵓⵔ ⵙ ⵚⵚⴱⴰⵔ ⴰⵎⵃⵉⵣⵡⴰⵔ ⵏⵏⵉ ⵅⴰⵏⴻⵖ ⴷⴷ-ⵉⵎⵎⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB12_2","088_12_2","HEB","12","2","2","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵏⴹⴰⵔ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷⵉ ⵢⴰⵙⵓⵄ, ⴰⵎⴳⴻⵡⵡⴰⴷ ⴷ ⵓⵎⴽⴻⵎⵎⴻⵍ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵖ, ⵡⴻⵏⵏⵉ, ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⵖⴰⵔⴻⵙ, ⵢⴰⵔⴱⵓ ⵚⵚⴰⵍⵉⴱ, ⵡⴰⵔ ⵜ ⵉⵛⵇⵉ ⵓⴱⴻⵀⴷⴻⵍ, ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵅ ⵢⴻⴼⵓⵙ ⵏ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴻⴱⴱⵉ.    ");
INSERT INTO rift_vpl VALUES ("HB12_3","088_12_3","HEB","12","3","3","ⵅⵣⴰⵔⴻⵎ ⵎⵍⵉⵃ, ⵎⴻⵛⵃⴰⵍ ⵉ ⵉⴽⵙⵉ ⵏⴻⵜⵜⴰ ⵣⴻⴳ ⵉⵎⴻⴷⵏⴰⴱ, ⵉⵏⵏⵉ ⴷ ⵉⵖⵔⵉⵎⴻⵏ ⵏ ⵍⴻⵄⵎⴰⵔ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵃⵍⴻⵎ ⵓ ⵡⴰⵔ ⵜⴰⵔⴻⵅⵅⵓⵎ ⵛⴰ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HB12_4","088_12_4","HEB","12","4","4","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ, ⵡⴰⵔ ⵜⵔⵓⵃⴻⵎ ⵛⴰ ⵜⵉⴳⴳⵯⴻⵊⴻⵎ ⴰⴽ-ⴷ ⴷⴷⴻⵏⴱ, ⵡⴰⵔ ⵜⴻⵎⵎⵄⴰⵍⵉⵎ ⵛⴰ ⴰⵍ ⵓⵙⵉⵣⵣⴻⵍ ⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HB12_5","088_12_5","HEB","12","5","5","ⵜᵉⵜⵜⵓⵎ ⵜⴰⵖⵓⵔⵉ ⵉ ⵅⴰⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ: “ⵎⵎⵉ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵙ ⵡⴻⵄⵔⵓⵔ ⵅ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵏ ⵙⵉⴷⵉ, ⵡⴰⵔ ⵜⵜⵉⵍⵉ ⵛⴰ ⴷ ⴰⵎⴰⵔⵅⵓ ⴷⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ, ⵅⵎⵉ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵡⴻⴱⴱⵅⴻⴷ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB12_6","088_12_6","HEB","12","6","6","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙ ⵙⵉⴷⵉ, ⵢⴰⵔⴻⴱⴱⴰ ⵉ-ⵜ ⵙ ⵓⵇⴻⵙⵙⴰⵃ, ⵓⵛⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵅⴰⵙ ⵉⵄⵉⵣⵣⴻⵏ, ⵉⴽⵙⵉ ⵜⴻⵏ ⴽⵓⵍ ⵉⵊⵊ ⵣⵣⴰⵢⵙⴻⵏ ⵖⴰⵔ ⵓⵖⴻⵣⴷⵉⵙ.” ");
INSERT INTO rift_vpl VALUES ("HB12_7","088_12_7","HEB","12","7","7","ⵅ ⵓⵢⴰ, ⴽⵙⵉⵎ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴻⴳⴳ ⴰⵡⴻⵎ ⴰⵎ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵏⵏⴻⵙ. ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⵎⵎⵉⵙ ⵡⴻⵏⵏⵉ ⴱⴰⴱⴰⵙ ⵡⴰⵔ ⵜ ⵢⴰⵔⴻⴱⴱⵉ ⵛⴰ ⵙ ⵓⵇⴻⵙⵙⴰⵃ? ");
INSERT INTO rift_vpl VALUES ("HB12_8","088_12_8","HEB","12","8","8","ⵎⴰⵍⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴱⵍⴰ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵉ ⴷⵉ ⵛⴰⵔⵛⴻⵏ ⵎⴰⵔⵔⴰ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵎ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⵉ ⵜⴻⴵⴰⵎ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⴰⵔⵔⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB12_9","088_12_9","HEB","12","9","9","ⵎⴰⵍⴰ ⵏⴻⴽⵙⵉ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵣⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵔⵔⵉⵎⴻⵜ ⵓⵛⴰ ⵏⵡⴻⵇⵇⴰⵔ ⵉ-ⵜⴻⵏ, ⵎⴻⵛⵃⴰⵍ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⵟⴰⵄ ⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵏ ⴰⵔⵔⵓⵃⴰⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⴷⴷⴰⵔ! ");
INSERT INTO rift_vpl VALUES ("HB12_10","088_12_10","HEB","12","10","10","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵡⴻⴱⴱⵅⴻⵏ ⴰⵏⴻⵖ ⵛⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵖⵉⵍ ⵎⵍⵉⵃ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⴳⴳⴰ ⵉ-ⵜⵜ ⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵛⴰⵔⵛ ⴷⵉ ⵜⵇⴻⴷⴷⴰⵙⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB12_11","088_12_11","HEB","12","11","11","ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⴰⵔⴱⵉⵢⵢⴻⵜ ⵙ ⵓⵇⴻⵙⵙⴰⵃ ⵉ ⵉⵜⵜⴱⴰⵏⴻⵏ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ ⴷⴻⵖⵢⴰ, ⵎⴰⵛⴰ ⴷ ⵍⴻⵃⵔⵉⵇ, ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵜⵉⵡⵉ-ⴷⴷ ⵍⵖⵉⴵⴻⵜ ⵏ ⵍⴻⵀⵏⴰ ⴷ ⵜⵙⴻⴳⴷⴰ ⵉ ⵢⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⴷⴰⵔⵔⴱⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB12_12","088_12_12","HEB","12","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵙⵊⴻⵀⴷⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ ⵢⴰⵔⵅⵓⵏ ⴷ ⵉⴼⴰⴷⴷⴻⵏ ⵏⵡⴻⵎ ⵢⴰⵔⴻⵀⴼⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("HB12_13","088_12_13","HEB","12","13","13","ⵓⵛⴰ ⴳⴳⴻⵎ ⵏⵉⵛⴰⵏ ⵉⵚⵓⵔⴰⴼ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵇⴻⵊⴷⴰⵃ ⵡⴰⵔ ⵉⵜⵜⴻⴼⵔⵉⵖ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵉⴳⴳⴻⵏⴼⴰ. ");
INSERT INTO rift_vpl VALUES ("HB12_14","088_12_14","HEB","12","14","14","ⴹⴼⴰⵔⴻⵎ-ⴷⴷ ⵍⴻⵀⵏⴰ ⴷ ⵜⵓⵇⴻⴷⴷⵙⵉ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ, ⵜⴻⵏⵏⵉ ⴱⵍⴰ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵔ ⵉⵥⴰⵔ ⵃⴻⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HB12_15","088_12_15","HEB","12","15","15","ⵖⴰⵔⵡⴻⵎ ⴰⵇⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⴷ ⵉⵜⵜⵡⴰⴼ ⵉⵏⵇⴻⵚ ⴰⵙ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵏⵉⵖ ⴰⵇⴰ ⴰⴷ ⵉⵖⵎⵉ ⵡⴻⵥⵡⴰⵔ ⵏ ⵜⴰⵔⵣⵓⴳⵉ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴹⴰⵔⵔ ⵓⵛⴰ ⵅⴻⵏⵏⵉ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⵜⵡⴰⵅⴻⵎⵊⴻⵏ ⴰⵟⵟⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("HB12_16","088_12_16","HEB","12","16","16","ⵓⵛⴰ ⵃⴹⴰⵎ, ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼⴼⵉ ⵃⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵡⴻⵏⵏⵉ ⴷ ⴱⵓ-ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵉⵖ ⴷ ⴰⵎⴻⵇⵊⵓⵃ ⴰⵎ ⵄⵉⵙⵓ ⵏⵏⵉ ⵉⵣⵣⴻⵏⵣⴻⵏ ⵍⵃⴻⵇⵇ ⵏ ⵓⵎⴻⵏⵣⵓ ⵏⵏⴻⵙ ⵅ ⵉⵊⵊ ⵏ ⵎⴰⵛⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("HB12_17","088_12_17","HEB","12","17","17","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜⵓⵖⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵄⴰⴷ ⴰⴷ ⵉⵡⴰⵔⵜ ⵍⴱⴰⵔⴰⴽⴰ, ⵎⴰⵛⴰ ⵢⵓⴳⵉ ⴰⵙ, ⵎⴰⵖⴰⵔ ⵡⴰⵔ ⵢⵓⴼⵉ ⵛⴰ ⵜⵜⴰⵙⵉⵄ ⵉ ⵡⴻⵄⴷⴰⵍ, ⵡⴰⵅⵅⴰ ⵢⴰⵔⴻⵣⵣⵓ ⵜ ⵙ ⵉⵎⴻⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB12_18","088_12_18","HEB","12","18","18","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜⵉⵡⵉⴹⴻⵎ ⵛⴰ ⵖⴰⵔ ⵜⵎⴻⵙⵙⵉ ⵢⴰⵔⵖⵉⵏ ⵏⵉⵖ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵉ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵏⵃⴰⴷⴰ, ⵓⵍⴰ ⵖⴰⵔ ⵜⴰⵢⵢⵓⵜ ⵜⴱⴰⵔⵛⴰⵏⵜ ⴷ ⵜⵃⴰⵔⵢⴰⴹⵜ, ");
INSERT INTO rift_vpl VALUES ("HB12_19","088_12_19","HEB","12","19","19","ⵏⵉⵖ ⵖⴰⵔ ⵣⵣⵀⵉⵔ ⵏ ⵓⵚⵓⴷⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵓⵍⴰ ⵖⴰⵔ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵙⴻⵏ ⵣⴰⵡⴳⴻⵏ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵉⵙⵍⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵏ ⴽⵉⵙⴻⵏ ⵉⵙⵙⵉⵡⵉⵍ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("HB12_20","088_12_20","HEB","12","20","20","ⵙ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⵅ ⴷⴷⵇⴻⵍ ⵏ ⵜⵡⴻⵚⵚⴰ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵇⴰⵔⵔⴻⴱ-ⴷⴷ ⵎⵖⵉⵔ ⵉⵊⵊ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⴰⴷⵔⴰⵔ, ⴰⴷ ⵉⵜⵜⵡⴰⵔⵊⴻⵎ ⵏⴻⵜⵜⴰ.    ");
INSERT INTO rift_vpl VALUES ("HB12_21","088_12_21","HEB","12","21","21","ⵎⵉⵏ ⵥⵔⵉⵏ ⵜⵓⵖⴰ ⵉⵙⵙⴰⴳⴳⵯⴰⴷ ⴰⵟⵟⴰⵙ, ⴰⵍⴰⵎⵉ ⵉⵏⵏⴰ ⵎⵓⵙⴰ: “ⴰⵇⴰ ⴳⴳⵯⴻⴷⴻⵖ ⵓ ⵜⵜⴰⵔⵊⵉⵊⵉⵖ!” ");
INSERT INTO rift_vpl VALUES ("HB12_22","088_12_22","HEB","12","22","22","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵉⵡⴹⴻⵎ ⵖⴰⵔ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵖⴰⵔ ⵓⵔⵛⴰⵍⵉⵎ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ ⵓ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼⴰⵜ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ");
INSERT INTO rift_vpl VALUES ("HB12_23","088_12_23","HEB","12","23","23","ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵉⵎⴻⵏⵣⴰ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ⵓ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵍⵇⴰⴹⵉ ⵅ ⵎⴰⵔⵔⴰ ⵓ ⵖⴰⵔ ⴰⵔⵔⵓⵃⴰⵜ ⵏ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ ⵏⵏⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵍⴻⴽⵎⴰⵔⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("HB12_24","088_12_24","HEB","12","24","24","ⵓ ⵖⴰⵔ ⵢⴰⵙⵓⵄ, ⵍⵡⴰⵙⵉⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ, ⵓ ⵖⴰⵔ ⵓⵔⵓⵛⵛⵉ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵃⵙⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵏ ⵀⴰⴱⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("HB12_25","088_12_25","HEB","12","25","25","ⵖⴰⵔⵡⴻⵎ ⵡⴰⵔ ⵜⴰⴳⵉⵎ ⵛⴰ ⵅ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵡⴻⵎ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵏ ⵓⴳⵉⵏ ⵡⴻⵏⵏⵉ ⴽⵉⴷⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⴰⵀⵓ ⵄⴰⴷ ⵏⴻⵛⵛⵉⵏ, ⵎⴰⵍⴰ ⵏⵃⴻⵢⵢⴻⴷ ⵅ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⵏⴻⵖ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵣⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("HB12_26","088_12_26","HEB","12","26","26","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵙ ⵜⴻⵙⵙⴻⵏⵀⴻⵣⵣⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⵉⵡⴰⵄⴷ, ⵉⵏⵏⴰ: “ⴰⴷ ⵙⵙⴻⵏⵀⴻⵣⵣⴻⵖ ⵄⴰⵡⴻⴷ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ, ⵡⴰⵔ ⵉⴵⵉ ⵜⴰⵎⵎⵓⵔⵜ ⵡⴰⵀⴰ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⴰⵊⴻⵏⵏⴰ.” ");
INSERT INTO rift_vpl VALUES ("HB12_27","088_12_27","HEB","12","27","27","ⴰⵡⴰⵍ-ⴰ: ‘ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ!’, ⴰⵇⴰ ⵉⵎⵍⴰ ⴱⴻⵍⵍⵉ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴽⴻⵙ ⵎⵉⵏ ⵉⵜⵜⴻⵏⵀⴻⵣⵣⴰⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⴳⴳ, ⵃⵉⵎⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵡⴰⵔ ⵜⵜⴻⵏⵀⴻⵣⵣⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("HB12_28","088_12_28","HEB","12","28","28","ⵙ ⵓⵢⴰ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵏⴻⵟⵟⴻⴼ ⵜⴰⴳⴻⵍⴷⵉⵜ ⵢⴰⵔⴻⴽⴽⵏⴻⵏ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵇⵇⵉⵎ ⵏᵉⵜⵜⴻⵟⵟⴻⴼ ⴷⵉ ⴰⵔⴹⴰ ⵉ ⵣⵉ ⵏⴻⵜⵜⵙⴻⵅⵅⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏⴻⵙⵙⴰⵔⴹⴰ ⵉ-ⵜ ⵙ ⵓⵡⴻⵇⵇⴰⵔ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("HB12_29","088_12_29","HEB","12","29","29","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⵉⵎⴻⵙⵙⵉ ⵉⵜⵜⴻⵜⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB13_1","088_13_1","HEB","13","1","1","ⴻⵊⵊ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⵜⴰⵢⵔⵉ ⵏ ⵜⴰⵡⵎⴰⵜ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("HB13_2","088_13_2","HEB","13","2","2","ⵡⴰⵔ ⵜᵉⵜⵜⵓⵎ ⵛⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜⴻⵛⵏⴰⵎ ⴰⴽ-ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ⴰⵇⴰ ⵣⴻⵄⵎⴰ ⵙ ⵓⵢⴰ ⴰⵔⴻⵃⵃⴱⴻⵏ ⵛⴰ ⵙ ⵍⵎⴰⵍⴰⴽⴰⵜ ⴰⵎ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB13_3","088_13_3","HEB","13","3","3","ⵅⴰⵔⵔⵚⴻⵎ ⴷⴻⴳ ⵉⵎⴻⵃⴱⴰⵙ ⴰⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵃⴻⴱⴱⵙⴻⵎ ⴰⴽⵉⴷⵙⴻⵏ, ⵅⴰⵔⵔⵚⴻⵎ ⴷⴻⴳ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⵙⴰⵔⴻⵏ, ⴰⵎ ⵉⵡⴷⴰⵏ ⴰⵎ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⴰⵢⵙⵓⵎ ⵏ ⴰⵔⵔⵉⵎⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("HB13_4","088_13_4","HEB","13","4","4","ⴻⵊⵊ ⴰⴷ ⵢⵉⵍⵉ ⵍⴻⵎⵍⴰⵛ ⴷ ⴰⵡⴻⵇⵇⴰⵔ ⵖⴰⵔ ⵎⴰⵔⵔⴰ, ⴷ ⵇⴰⵎⴰ ⵏⵙⴻⵏ ⵏ ⵍⴻⵎⵍⴰⵛ ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵃⴽⴻⵎ ⵅ ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵣⵣⵉⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HB13_5","088_13_5","HEB","13","5","5","ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵡⴻⵎ ⴷⵉ ⵜⴻⵏⵄⴰⵛⵉⵏ, ⵎⴰⵛⴰ ⵇⴻⵏⵄⴻⵎ ⵙ ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⵉⵏⵏⴰ: “ⵏⴻⵛⵛ ⵡⴰⵔ ⵛⴻⴽ ⵜⵜⴻⵊⵊⵉⵖ ⵏⵉⵖ ⴰⴷ ⵙⴻⵎⵎⵃⴻⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("HB13_6","088_13_6","HEB","13","6","6","ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵡⴰⵏⵏⴰ ⵉ ⵏⴻⵛⵛⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⵉⵏⵉ ⵙ ⵜⴻⵔⵢⴰⵙⵜ: “ⵙⵉⴷⵉ ⴷ ⴰⵎⵄⴰⵡⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴷⴻⵖ ⵛⴰ, ⵎⵉⵏ ⴷ ⴰⵢⵉ ⵖⴰ ⵢⴻⴳⴳ ⴱⵏⴰⴷⴻⵎ?” ");
INSERT INTO rift_vpl VALUES ("HB13_7","088_13_7","HEB","13","7","7","ⵄⴻⵇⵍⴻⵎ ⵅ ⵉⵎⴳⴻⵡⵡⴰⴷⴻⵏ ⵏⵡⴻⵎ, ⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ. ⴱⴻⵇⵇⵛⴻⵎ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⴻⵛⵔⵉ ⵏⵙⴻⵏ ⵓⵛⴰ ⴹⴼⴰⵔⴻⵎ ⵍ’ⵉⵎⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB13_8","088_13_8","HEB","13","8","8","ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⵏⴻⵜⵜⴰ ⵏⴻⵜⵜⴰ ⵉⴹⴻⵏⵏⴰⴹ ⴷ ⵢⵉⴹⴰ, ⵓ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("HB13_9","088_13_9","HEB","13","9","9","ⵡⴰⵔ ⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵖⴰⵔⵔⴻⵏ ⵙ ⵜⵖⵓⵔⵉⵡⵉⵏ ⵉⵜⵜⴱⴻⴷⴷⴰⵍⴻⵏ ⵏ ⴷⴻⵖⵢⴰ, ⵎⵉⵏⵣⵉ ⵍⵃⴰⵊⵊⴻⵜ ⵏ ⵍⴻⵎⵍⵉⵃ ⵎⴰⵍⴰ ⵛⴻⴱⴱⴰⵔⴻⵏ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⴷⵉ ⴰⵔⴹⴰ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵎⴰⵛⵛⴰ, ⵎⵉⵏⵣⵉ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴷⴰⵢⴻⵙ ⵢⴻⵍⵀⴰⵏ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵏ ⴱⵓ ⵏⵏⴼⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("HB13_10","088_13_10","HEB","13","10","10","ⵖⴰⵔⵏⴻⵖ ⵉⵊⵊ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵉ ⵓⵎⵉ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵛⵛⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ. ");
INSERT INTO rift_vpl VALUES ("HB13_11","088_13_11","HEB","13","11","11","ⵎⵉⵏⵣⵉ ⵣⴻⴳ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵙⴻⵏ ⵜⵜⵡⴰⴽⵙⵉⵏ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⵓⴼⵓⵙ ⵏ ⴰⵔⵔⴰⵢⵙ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ, ⵉⵜⵜⵡⴰⵙⵙⴰⵔⵖ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ ⴱⴰⵔⵔⴰ ⵉ ⵍⵎⴰⵔⴳⴻⵃ.    ");
INSERT INTO rift_vpl VALUES ("HB13_12","088_13_12","HEB","13","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵢⴰⵙⵓⵄ ⵉⵎⴰⵔⵔⴻⵜ ⵄⴰⵡⴻⴷ ⴱⴰⵔⵔⴰ ⵉ ⵜⴻⵏⴷⵉⵏⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵇⴻⴷⴷⴻⵙ ⵍⴳⴻⵏⵙ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB13_13","088_13_13","HEB","13","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⴼⴼⴻⵖ ⵖⴰⵔ ⴱⴰⵔⵔⴰ ⵏ ⵍⵎⴰⵔⴳⴻⵃ, ⴰⵎ ⵏⴰⵔⴻⴱⴱⵓ ⵍⵄⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB13_14","088_13_14","HEB","13","14","14","ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵏⴻⵖ ⴷⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵏ ⵍⴻⴱⴷⴰ, ⵎⴰⵛⴰ ⵏⴰⵔⴻⵣⵣⵓ ⵅ ⵜⴻⵏⵏⵉ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("HB13_15","088_13_15","HEB","13","15","15","ⴻⵊⵊ ⴰⵏⴻⵖ ⵍⴻⴱⴷⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⵇⴻⴷⴷⴻⵎ ⵜⵉⵡⵀⵉⴱⵉⵏ ⵏ ⵓⵙⴻⵎⵖⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵍⵖⵉⴵⴻⵜ ⵏ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵢⴻⵏ ⴰⵇⴰⴷⵉ ⵉ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB13_16","088_13_16","HEB","13","16","16","ⵡⴰⵔ ⵜⵜᵉⵜⵜⵓⵎ ⵛⴰ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵓⵍⴰ ⴷ ⵜⴻⵛⵔⵉⵎⴻⵜ ⵉ ⵉⵎⴻⵥⵍⴰⴹ, ⵎⵉⵏⵣⵉ ⵙ ⵜⴻⵡⵀⵉⴱⵉⵏ-ⴰ ⴰⴷ ⵢⴰⵔⴹⴰ ⴱⵏⴰⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("HB13_17","088_13_17","HEB","13","17","17","ⵉⵍⵉⵎ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴳⴻⵡⵡⴰⴷⴻⵏ, ⵟⴰⵄⴻⵎ ⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵄⴻⵙⵙⴰⵏ ⵅ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵃⵙⴰⴱ ⵅⴰⵡⴻⵎ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴳⴳⴻⵏ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵡⴻⵃⵡⴻⵃ, ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴻⴼⴼⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("HB13_18","088_13_18","HEB","13","18","18","ⵥⴰⴵⴻⵎ ⵅⴰⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⵏⴻⵢ ⵜⵜⵉⵇⵇⴻⵜ ⴱⴻⵍⵍⵉ ⵖⴰⵔⵏⴻⵖ ⵜⴰⵏⴻⴼⵙⴻⵛⵜ ⵜⴻⵛⵏⴰ, ⴰⵎ ⴷⴰⵢⵏⴻⵖ ⵎⴻⵥⵔⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵓⵢⵓⵔ ⵏⵉⵛⴰⵏ ⴷⵉ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("HB13_19","088_13_19","HEB","13","19","19","ⵜⵜⵣⴰⵡⴳⴻⵖ ⴽⴻⵏⵏⵉⵡ ⵙ ⵊⵊⴻⵀⴷ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⴰⵎⵎⵓ ⵖⴰⵔ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⵃⵉⵎⴰ ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴷⴻⵖⵢⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴷⴻⵡⵍⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("HB13_20","088_13_20","HEB","13","20","20","ⴰⵔⴻⴱⴱⵉ ⵏ ⵍⴻⵀⵏⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⴰⵎⴻⴽⵙⴰⵡ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⵓⴵⵉ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵍⵄⴰⵀⴷ ⵉ ⵍⴻⴱⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("HB13_21","088_13_21","HEB","13","21","21","ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⴽⴻⵎⵎⴻⵍ ⴷⵉ ⴽⵓⵍ ⵍⵅⴻⴷⵎⴻⵜ ⵉⵛⵏⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ. ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵉⴳⴳ ⵎⵉⵏ ⵉⴵⴰⵏ ⵉ ⴰⵔⴹⴰ ⵏⵏⴻⵙ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵄⵓⴵⵉ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("HB13_22","088_13_22","HEB","13","22","22","ⵅⴻⵏⵏⵉ ⵜⵜⵣⴰⵡⴰⴳⴻⵖ ⵣⵣⴰⵢⵡⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵏⵓ, ⵇⴻⴱⵍⴻⵎ ⴰⵡⴰⵍ-ⴰ ⵏ ⵓⵙⴻⵊⵊⴻⵄ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⵎⵉⵏⵣⵉ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵙ ⴷⵔⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("HB13_23","088_13_23","HEB","13","23","23","ⵙⵏⴻⵎ ⴰⵇⴰ ⴰⵔⵅⵓⵏ ⵉ ⵓⵎⴰⵜⵏⴻⵖ ⵜⵉⵎⵓⵜⵉⵢⵓ. ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴷⴻⵖⵢⴰ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵥⴰⵔⴻⵖ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("HB13_24","088_13_24","HEB","13","24","24","ⵙⴻⴵⵎⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⴳⴻⵡⵡⴰⴷⴻⵏ ⵙ ⵍⴻⵃⵏⴰ ⵓ ⵅ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ⵎⴰⵔⵔⴰ ⴰⵡⵎⴰⵜⴻⵏ ⵏ ⵉⵟⴰⵍⵢⴰ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ-ⴷⴷ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("HB13_25","088_13_25","HEB","13","25","25","ⴰⵔⴹⴰ ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JM1_1","089_1_1","JAS","1","1","1","ⵢⴰⵄⵇⵓⴱ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵉ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⴵⵄⴻⵏ ⵊⴰⵔ ⵍⴻⴳⵏⵓⵙ: ⵍⴻⵀⵏⴰ ⵅⴰⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("JM1_2","089_1_2","JAS","1","2","2","ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵍⴰ ⴰⴷ ⵅⴰⵡⴻⵎ ⴽⴽⴻⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵊⴰⵔⵔⵉⴱⴻⵏ, ⵃⴻⵙⴱⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵔⵔⴰ ⴷ ⵍⴻⴼⵔⴰⵃⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("JM1_3","089_1_3","JAS","1","3","3","ⵎⴰⵖⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵜⴰⵇⴻⴵⴻⴱⵜ ⵏ ⵍ’ⵉⵎⴰⵏ, ⴰⴷ ⴷⴷ-ⵜⴻⵊⵊ ⵚⵚⴱⴰⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JM1_4","089_1_4","JAS","1","4","4","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⵚⵚⴱⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴰⵡⴹⴻⵎ ⵓ ⴰⴷ ⵜⴽⴻⵎⵎⵍⴻⵎ, ⵓⵛⴰ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ. ");
INSERT INTO rift_vpl VALUES ("JM1_5","089_1_5","JAS","1","5","5","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⵜⴻⵇⵇⵉⵎ ⴰⵙ ⵄⴰⴷ ⵜⵉⵖⵉⵜ, ⴰⴷ ⵜⵜ ⵉⵜⵜⴰⵔ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵉⵛⴻⵏ ⵙ ⵜⴻⵛⵔⵉⵎⴻⵜ ⵉ ⵎⴰⵔⵔⴰ ⴱⵍⴰ ⴰⵣⴰⵡⴰⵔ, ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⴻⵎⵎⴻⵡⵛ. ");
INSERT INTO rift_vpl VALUES ("JM1_6","089_1_6","JAS","1","6","6","ⵎⴰⵛⴰ ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵜⵜⴰⵔ ⵙ ⵍ’ⵉⵎⴰⵏ, ⴱⵍⴰ ⴰⵛⴻⴽⴽⵉ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵛⴻⴽⴽⴰⵏ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⵎ ⵍⴻⵎⵡⴰⵊ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ. ");
INSERT INTO rift_vpl VALUES ("JM1_7","089_1_7","JAS","1","7","7","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⴰⴷ ⴰⵙ ⵉⵜⵜⵖⵉⵍ ⵉ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⴰⴷ ⵉⴽⵙⵉ ⵛⴰ ⵣⵉ ⵙⵉⴷⵉ, ");
INSERT INTO rift_vpl VALUES ("JM1_8","089_1_8","JAS","1","8","8","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ, ⵡⴰⵔ ⵢⴰⵔⵙⵉ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JM1_9","089_1_9","JAS","1","9","9","ⴻⵊⵊ ⵓⵎⴰⵜⵡⴻⵎ ⵉⵡⴰⴹⵄⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵎⵖⴰⵔ ⴷⵉ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JM1_10","089_1_10","JAS","1","10","10","ⵓ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴷⴻⴳ ⵓⵡⴰⴹⴻⵄ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⵎ ⵜⵡⴰⵔⴷⴻⵛⵜ ⴷⵉ ⴰⵔⴱⵉⵄ ⴰⴷ ⵉⴼⵏⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("JM1_11","089_1_11","JAS","1","11","11","ⵎⴰⵖⴰⵔ ⴰⴷ ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵙ ⵍⴻⵃⵎⵓ ⵏⵏⴻⵙ, ⴰⴷ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⴰⵔⴱⵉⵄ ⵓⵛⴰ ⵜⴰⵡⴰⵔⴷⴻⵛⵜ ⴰⴷ ⵜⵉⵙⵍⴰⵡ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵉⵔⴰⵃ ⵡⴰⵥⵔⵉ ⵏ ⵡⵓⴷⴻⵎ ⵏⵏⴻⵙ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵉⴼⵏⴰ ⵄⴰⵡⴻⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵉⴱⵔⵉⴷⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JM1_12","089_1_12","JAS","1","12","12","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⵎⵍⴻⵏ ⴰⵊⴰⵔⵔⴻⴱ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵇⴻⴵⴻⴱ, ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⵜⴰⵊ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴰⵄⴷ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM1_13","089_1_13","JAS","1","13","13","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉ ⵃⴻⴷ ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⵊⵊⴰⵔⴻⴱ, ⴰⴷ ⵢⵉⵏⵉ: “ⴰⵔⴻⴱⴱⵉ ⵉ ⴷ ⴰⵢⵉ ⵉⵜⵜⵊⴰⵔⵔⴰⴱⴻⵏ!” ⴰⵇⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵜⵜⵡⴰⵊⴰⵔⵔⴻⴱ ⵣⵉ ⵍⵖⴰⵔ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵡⴰⵔ ⵉⵜⵜⵊⵊⴰⵔⵔⵉⴱ ⵓⵍⴰ ⴷ ⵉⵊⵊ. ");
INSERT INTO rift_vpl VALUES ("JM1_14","089_1_14","JAS","1","14","14","ⵎⴰⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⴰⴷ ⵉⵜⵜⵡⴰⵖⵡⴰ ⵣⵉ ⵏⵏⴻⵛⵡⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵏⵏⴻⵛⵡⴻⵜ ⴰⴷ ⵜ ⵜᵉⵟⵟⴻⴼ ⵓⵛⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵖⵡⴰ. ");
INSERT INTO rift_vpl VALUES ("JM1_15","089_1_15","JAS","1","15","15","ⵎⴰⵍⴰ ⵏⵏⴻⵛⵡⴻⵜ ⵜⴻⴽⵙⵉ ⵙ ⵓⵄⴻⴷⴷⵉⵙ, ⴰⴷ ⴷⴷ-ⵜⴰⵔⵓⵡ ⴷⴷⴻⵏⴱ, ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⵉⵎⵖⴰⵔ ⴷⴷⴻⵏⴱ, ⴰⴷ ⴷⴷ-ⵢⴰⵡⵉ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("JM1_16","089_1_16","JAS","1","16","16","ⴰ ⴰⵢⵜⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ, ⵡⴰⵔ ⵜⵜⵡⴻⴷⴷⴰⵔⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("JM1_17","089_1_17","JAS","1","17","17","ⴽⵓⵍ ⵜⴰⵡⵀⵉⴱⵜ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ ⴷ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵜⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⵣⵉ ⴱⴰⴱⴰⵜⵙⴻⵏⵜ ⵏ ⵜⴼⴰⵡⵉⵏ ⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵓⴱⴻⴷⴷⴻⵍ ⵏⵉⵖ ⵜⵉⵍⵉ ⵏ ⴷⴷⴻⵡⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JM1_18","089_1_18","JAS","1","18","18","ⵢⵓⵙⴰ-ⴷⴷ ⴰⵙ ⵅ ⵍⵅⴰⴹⴰⵔ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴻⵊⵊ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM1_19","089_1_19","JAS","1","19","19","ⵙⵏⴻⵎ ⴰⵢⴰ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ, ⴻⵊⵊ ⴽⵓⵍ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵇⴻⴵⴻⵇ ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⴻⵍ, ⵡⴰⵔ ⵜⵇⴻⴵⵉⵇⴻⵎ ⵛⴰ ⵖⴰⵔ ⵡⴰⵡⴰⵍ ⵏⵉⵖ ⵖⴰⵔ ⵜⴻⴼⵇⴻⵃⵜ. ");
INSERT INTO rift_vpl VALUES ("JM1_20","089_1_20","JAS","1","20","20","ⵎⵉⵏⵣⵉ ⵜⴰⴼⵇⴻⵃⵜ ⵏ ⵡⴻⵔⵢⴰⵣ ⵡⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⵉⵡⵉ ⵛⴰ ⵜⴰⵙⴻⴳⴷⴰ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JM1_21","089_1_21","JAS","1","21","21","ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴱⴻⵄⵄⴷⴻⵎ ⵅⴰⵡⴻⵎ ⵇⴰⵄ ⵜⴰⵅⵎⵓⵊⵉ ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵓⵛⴰ ⵇⴻⴱⵍⴻⵎ ⵙ ⵜⴻⵎⵀⵉⵏⵜ ⴰⵡⴰⵍ ⵉ ⵉⵜⵜⵡⴰⵥⵥⵓⵏ ⴷⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏⵏⴻⵖ, ⴰⵡⴰⵍ ⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JM1_22","089_1_22","JAS","1","22","22","ⵉⵍⵉⵎ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴰⵡⴰⵍ, ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵡⴰⵀⴰ, ⵡⴰⵔ ⵛⴻⵎⵜⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ! ");
INSERT INTO rift_vpl VALUES ("JM1_23","089_1_23","JAS","1","23","23","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵙⵍⴰ ⵃⴻⴷ ⵉ ⵡⴰⵡⴰⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⴳⴳⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵉ ⵉⵅⴻⵣⵣⴰⵔⴻⵏ ⴷⵉ ⵜⵉⵙⵉⵜ ⴷⴻⴳ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JM1_24","089_1_24","JAS","1","24","24","ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵍⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⵉⵔⵓⵃ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⵉⵜⵜⵓ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴵⴰ. ");
INSERT INTO rift_vpl VALUES ("JM1_25","089_1_25","JAS","1","25","25","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⵣⴰⵔⴻⵏ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵉⴽⴻⵎⵎⵍⴻⵏ ⵏ ⵜⵉⵍⴻⵍⵍⵉ ⵓⵛⴰ ⵉⵇⵇⵉⵎ ⵉⵅⴻⵣⵣⴰⵔ ⴷⴰⵢⴻⵙ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵉⵜⵜⴻⵙⵍⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵜⵜᵉⵜⵜⵓ ⴷⴻⵖⵢⴰ, ⵎⴰⵛⴰ ⴰⵎ ⵢⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵜⵜ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ, ⴰⵇⴰ ⵡⴰⵏⵉⵜⴰ ⴷ ⴰⵎⵉⵎⵓⵏ ⴷⵉ ⵎⵉⵏ ⵉⵜⵜⴻⴳⴳ. ");
INSERT INTO rift_vpl VALUES ("JM1_26","089_1_26","JAS","1","26","26","ⵎⴰⵍⴰ ⴷⵉⵏ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵖⵉⵍ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵡⴰⵔ ⵉⵃⴻⵟⵟⵉ ⵉⵍⴻⵙ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵉⵅⴻⴷⴷⴻⵄ ⵓⵍ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⴰⵇⴰ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵙ ⴱⴰⵟⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JM1_27","089_1_27","JAS","1","27","27","ⵎⴰⵖⴰⵔ ⵜⴰⵙⴻⵅⵅⴰⵔⵜ ⵜⴰⵎⴻⵣⴷⴰⴳⵜ ⴷ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴰⵇⴰ-ⵜ ⴷ ⵜⴰ: ⴰⵜⵀⵉⵍⵉ ⴷⴻⴳ ⵉⵢⵓⵊⵉⵍⴻⵏ ⴷ ⵜⵉⵊⵊⴰⵍ ⴷⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵙⴻⵏⵜ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴱⵏⴰⴷⴻⵎ ⴰⴷ ⵉⵃⴻⵢⵢⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ ⴱⵍⴰ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("JM2_1","089_2_1","JAS","2","1","1","ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⵜⴻⴳⴳⴻⵎ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵉⵄⵓⴵⴻⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("JM2_2","089_2_2","JAS","2","2","2","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵢⵓⴷⴻⴼ-ⴷⴷ ⵖⴰⵔ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏⵡⴻⵎ ⵉⵊⵊ ⵏ ⵡⴻⵔⵢⴰⵣ ⵙ ⵜⵅⴰⴷⴻⵏⵜ ⵏ ⵡⵓⵔⴻⵖ ⵓ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ, ⴰⵎ ⴷⴷ-ⵢⵓⴷⴻⴼ ⵄⴰⵡⴻⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⵣⵍⵓⴹ ⵙ ⵡⴰⵔⵔⵓⴹ ⵉⵅⴻⵎⵊⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("JM2_3","089_2_3","JAS","2","3","3","ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⴰⵢⵏⵉⵜ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴰⵔⵔⵓⴹ ⵉⵛⵏⴰⵏ, ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ: “ⴰⵇⴰ ⴷⴰ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⵚⴻⴱⵃⴻⵏ!”, ⵎⴰⵛⴰ ⵉ ⵓⵎⴻⵣⵍⵓⴹ ⴰⴷ ⴰⵙ ⵜⵉⵏⵉⵎ: “ⵛⴻⴽ ⴱⴻⴷⴷ ⴷⵉⵀⴰ!” ⵏⵉⵖ: “ⵇⵇⵉⵎ ⵣⵣⴰⵜ ⵉ ⵜⵏⴻⴱⴷⴰⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵖ!”, ");
INSERT INTO rift_vpl VALUES ("JM2_4","089_2_4","JAS","2","4","4","ⵎⴰ ⵡⴰⵔ ⵜⵜⴻⵎⵚⵓⵔⵔⵓⴼⴻⵎ ⵅⴻⵏⵏⵉ ⵊⴰⵔ ⴰⵡⴻⵎ ⵙ ⵉⵖⴻⵎⴱⴰⴱ ⵓⵛⴰ ⵜⴷⴻⵡⵍⴻⵎ ⴷ ⵍⵃⵓⴽⴽⴰⵎ ⵙ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JM2_5","089_2_5","JAS","2","5","5","ⵙⵍⴻⵎ, ⴰ ⴰⵢⵜⵎⴰ ⵉⵄⵉⵣⵣⴻⵏ, ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⵉⵎⴻⵣⵍⴰⴹ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ ⴷⵉ ⵍ’ⵉⵎⴰⵏ? ⴰⵇⴰ ⵉⵅⴹⴰⵔ-ⵉ-ⵜⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⵡⵔⵉⵜⴻⵏ ⵏ ⵜⴳⴻⵍⴷⵉⵜ ⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵡⴰⵄⴷ ⴰⵔⴻⴱⴱⵉ ⵉ ⵢⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM2_6","089_2_6","JAS","2","6","6","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵖⴻⵟⵟⵔⴻⵎ ⵣⴻⴳ ⵉⵎⴻⵣⵍⴰⴹ! ⵅⵣⴰⵔ, ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵉⵏⵏⵉ ⵙ ⵡⴰⴳⵍⴰ ⴷ ⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵃⴻⴽⴽⵎⴻⵏ ⵓ ⴷ ⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵖⴰⵔ ⵍⴼⵓⵙⵉⵏⴰ? ");
INSERT INTO rift_vpl VALUES ("JM2_7","089_2_7","JAS","2","7","7","ⵅⵣⴰⵔ, ⵎⴰ ⵡⴰⵔ ⴵⵉⵏ ⴷ ⵏⵉⵜⵏⵉ ⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵚⴻⴱⵃⴻⵏ ⵡⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ? ");
INSERT INTO rift_vpl VALUES ("JM2_8","089_2_8","JAS","2","8","8","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴽⴻⵎⵎⵍⴻⵎ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵔⴰ: “ⴰⴷ ⵜⴻⵅⵙⴻⴷ ⵊⵊⴰⵔ ⵏⵏⴻⵛ ⴰⵎ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵛ!”, ⴰⵇⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵍⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("JM2_9","089_2_9","JAS","2","9","9","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵜⴻⴳⴳⵉⵎ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ, ⴰⵇⴰ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴷⴷⵏⵓⴱ ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵃⴻⴽⵎⴻⵎ ⵙ ⵛⵛⴰⵔⵉⵄⴰ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵅⴹⴰⵏ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JM2_10","089_2_10","JAS","2","10","10","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⴹⴼⴰⵔⴻⵏ ⵎⴰⵔⵔⴰ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵢⴰⵔⵥⴰ ⵉⵛⵜ ⵏ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴱⵓ-ⵓⵎⴰⵔⵡⴰⵙ ⵣⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JM2_11","089_2_11","JAS","2","11","11","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⵏⵏⴰⵏ: “ⵡⴰⵔ ⵣⴻⵏⵏⵉ!”, ⵉⵏⵏⴰ ⵄⴰⵡⴻⴷ: “ⵡⴰⵔ ⵏⴻⵇⵇ!” ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⴻⵣⵏⵉⴷ, ⵎⴰⵛⴰ ⵜⴻⵏⵖⵉⴷ, ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⵅⴻⵟⵟⴰⵢ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JM2_12","089_2_12","JAS","2","12","12","ⵙⵉⵡⵍⴻⵎ ⵓⵛⴰ ⴳⴳⴻⵎ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵃⴻⴽⵎⴻⵏ ⵙ ⵜⴻⴱⵔⵉⴷⵜ ⵏ ⵛⵛⴰⵔⵉⵄⴰ ⵏ ⵜⵉⵍⴻⵍⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("JM2_13","089_2_13","JAS","2","13","13","ⵎⵉⵏⵣⵉ ⵍⵃⵓⴽⵎ ⵡⴰⵔ ⵢⴰⵔⴻⵃⵃⴻⵎ ⵛⴰ ⵅ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵢⴰⵔⴻⵃⵃⵎⴻⵏ, ⵎⴰⵛⴰ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴰⴷ ⵜⵉⵍⵉⵎ ⵜᵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰⵎ ⵅ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("JM2_14","089_2_14","JAS","2","14","14","ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵏ ⵍⴻⴼⴹⴻⵍ ⵎⴰⵍⴰ ⵉⵊⵊⴻⵏ ⵉⵇⵇⴰⵔ: “ⵏⴻⵛⵛ ⴰⵇⴰ ⴰⵢⵉ ⵖⴰⵔⵉ ⵍ’ⵉⵎⴰⵏ!”, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵍⴻⵅⴷⴰⵢⴻⵎ? ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ ⴰⴷ ⵜ ⵉⵙⵙⴻⵏⵊⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JM2_15","089_2_15","JAS","2","15","15","ⵎⴰⵍⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵙ ⵉ ⵢⵉⵊⵊ ⵏ ⵜⴻⵡⵎⴰⵜ ⵏⵉⵖ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵡⴻⵍⵜⵎⴰⵜ ⵎⵉⵏ ⵖⴰ ⵢⴰⵔⴹⴻⵏ ⵏⵉⵖ ⵎⵉⵏ ⵖⴰ ⵛⵛⴻⵏ ⴽⵓⵍ ⴰⵙⵙ, ");
INSERT INTO rift_vpl VALUES ("JM2_16","089_2_16","JAS","2","16","16","ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴰⵙⴻⵏ ⵢⵉⵏⵉ: “ⵓⵢⵓⵔⴻⵎ ⴷⵉ ⵍⴻⵀⵏⴰ, ⴰⵔⴹⴻⵎ ⵎⵉⵏ ⵉⵙⵙⴻⵃⵎⴰⵏ, ⵊⵊⵉⵡⵏⴻⵎ ⵎⴰⵛⵛⴰ!”, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵡⵛⵉ ⵡⴰⵍⵓ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰⵏ ⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵏ ⵏⵏⴼⴰⵄ? ");
INSERT INTO rift_vpl VALUES ("JM2_17","089_2_17","JAS","2","17","17","ⴰⵇⴰ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵍ’ⵉⵎⴰⵏ ⴱⵍⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⴰⵇⴰ ⵉⵎⵎⵓⵜ ⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JM2_18","089_2_18","JAS","2","18","18","ⵎⴰⵍⴰ ⴰⴷ ⴰⵛ ⵉⵏⵏⴰ ⵉⵊⵊⴻⵏ: “ⵛⴻⴽ ⵖⴰⵔⴻⴽ ⵍ’ⵉⵎⴰⵏ, ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ!” ⵙⵛⴻⵏ ⴰⵢⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⴱⵍⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵍ’ⵉⵎⴰⵏ ⵉⵏⵓ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵏⵓ! ");
INSERT INTO rift_vpl VALUES ("JM2_19","089_2_19","JAS","2","19","19","ⵎⴰ ⵛⴻⴽ ⵜⵓⵎⵏⴻⴷ ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵉⵊⵊⴻⵏ? ⴰⵇⴰ ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ. ⵓⵍⴰ ⴷ ⵛⵛⵡⴰⵟⴻⵏ ⵓⵎⵏⴻⵏ ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵛⴰ ⵜⵜⴰⵔⵊⵉⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM2_20","089_2_20","JAS","2","20","20","ⵎⴰ ⵜⴻⵅⵙⴻⴷ ⴰⴷ ⵜⴻⵙⵙⵏⴻⴷ, ⴰ ⴱⵏⴰⴷⴻⵎ ⵉⴹⴻⵄⴼⴻⵏ, ⴱⴻⵍⵍⵉ ⵍ’ⵉⵎⴰⵏ ⴱⵍⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵎⵎⵓⵜ? ");
INSERT INTO rift_vpl VALUES ("JM2_21","089_2_21","JAS","2","21","21","ⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵊⴻⴷⴷⵉⵜⵏⴻⵖ ⵉⴱⵔⴰⵀⵉⵎ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵓⵎⵉ ⵉⴽⴽⴰⵔ ⴰⴷ ⵉⵖⴰⵔⵚ ⵉ ⵎⵎⵉⵙ ⵉⵙⵃⴰⵇ ⵅ ⵓⵄⴰⵍⵟⴰⵔ? ");
INSERT INTO rift_vpl VALUES ("JM2_22","089_2_22","JAS","2","22","22","ⴰⵇⴰ ⵜⴻⵥⵔⵉⵎ ⴱⴻⵍⵍⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵉⵅⴷⴻⵎ ⴰⴽ-ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵍ’ⵉⵎⴰⵏ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JM2_23","089_2_23","JAS","2","23","23","ⴰⵎⵎⵓ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵡⴰⵡⴰⵍ ⵏ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵉⴱⵔⴰⵀⵉⵎ ⵢⵓⵎⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴰⵙ-ⵜ-ⵉ-ⴷⴷ ⴷ ⵜⴰⵙⴻⴳⴷⴰ!”, ⵓⵛⴰ ⵍⴰⵖⴰⵏ ⴰⵙ ‘ⴰⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ’. ");
INSERT INTO rift_vpl VALUES ("JM2_24","089_2_24","JAS","2","24","24","ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⵅⴻⵏⵏⵉ, ⴱⴻⵍⵍⵉ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵍ’ⵉⵎⴰⵏ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("JM2_25","089_2_25","JAS","2","25","25","ⵎⴰ ⵡⴰⵔ ⵜⵓⵖⵉ ⵔⴰⵃⴰⴱ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵜᵉⵜⵜⵡⴰⵙⴻⴳⴳⴻⴷ ⴰⵎⵎⵓ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵓⵎⵉ ⵜⴰⵔⴻⵃⵃⴻⴱ ⵣⴻⴳ ⵉⴱⴻⵔⴳⴰⴳⴻⵏ, ⵜⴻⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵏⵏⴻⵖⵏⵉ? ");
INSERT INTO rift_vpl VALUES ("JM2_26","089_2_26","JAS","2","26","26","ⵙ ⵓⵢⴰ, ⴰⵎ ⴰⵔⵔⵉⵎⴻⵜ ⴱⵍⴰ ⴱⵓⵃⴱⴻⵍ ⵜⴻⵎⵎⵓⵜ, ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵍ’ⵉⵎⴰⵏ ⴱⵍⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("JM3_1","089_3_1","JAS","3","1","1","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⵟⵟⴰⵙ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ, ⴰ ⴰⵢⵜⵎⴰ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⴷ ⵏⴻⴽⵙⵉ ⵍⵃⵓⴽⵎ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JM3_2","089_3_2","JAS","3","2","2","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵏⴻⵛⵛⵉⵏ ⵏᵉⵏⵏⴻⴷⵔⴻⴼ ⴷⴻⴳ ⵡⴰⵟⵟⴰⵙ. ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵏⴻⴷⵔⴰⴼ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉⴽⵎⴻⵍ, ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵇⴻⵎⵎⴻⵄ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JM3_3","089_3_3","JAS","3","3","3","ⵅⵣⴰⵔ, ⵏᵉⵜⵜⴻⴳⴳ ⵙⵍⵉⵎⴰⵜ ⴷⴻⴳ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵎⵎⴰⵔⵙⴻⵏ, ⴰⵇⴰ ⵏⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵏⴻⵙⵙⵓⵢⵓⵔ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵙⴻⵏ ⵜⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("JM3_4","089_3_4","JAS","3","4","4","ⵓⵍⴰ ⴷ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵣⴻⴳ ⵓⵙⴻⵎⵎⵉⴹ ⵉⵊⴻⵀⴷⴻⵏ, ⵜⵜⵡⴰⵏⴻⴷⴷⵀⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⵍⴳⵉⴷⵓⵏ ⴰⵎⴻⵥⵢⴰⵏ, ⵎⴰⵏⵉ ⵎⴰ ⵉⵅⵙ ⵍⵅⴰⴹⴰⵔ ⵏ ⵍⵇⴻⴱⵟⴰⵏ ⴰⴷ ⵉⵏⴷⴻⵀ. ");
INSERT INTO rift_vpl VALUES ("JM3_5","089_3_5","JAS","3","5","5","ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⵉⵍⴻⵙ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵉⵅⴻⴼ ⴰⵎⴻⵥⵢⴰⵏ, ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵅⵣⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⵜⵉⵎⴻⵙⵙⵉ ⵜⴰⵎⴻⵥⵢⴰⵏⵜ ⴰⴷ ⵜⴻⵙⵙⴻⵛⵎⴻⴹ ⵍⵖⴰⴱⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JM3_6","089_3_6","JAS","3","6","6","ⵉⵍⴻⵙ ⴷ ⵉⵛⵜ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓ ⴷⴷⵓⵏⴻⵛⵜ ⵏ ⴷⴷⴻⵏⴱ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵡⴻⵣⵖⴰⵔ. ⵉⵍⴻⵙ-ⴰ ⵊⴰⵔ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵏⴻⵖ ⴰⵎ ⵢⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴻⵙⵙⴻⵅⵎⴻⵊ ⴰⵔⵔⵉⵎⴻⵜ ⵎⴰⵔⵔⴰ, ⵉⵙⵙⴰⵔⵖ ⵊⵊⵉⵍⴰⵜ ⵉ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵏⵏⵉ ⵉⵇⵏⵓⵏⵏⵉⵢⴻⵏ ⴰⵎ ⵜⵊⴰⵔⵔⴰⵔⵉⵏ. ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵢⵉⵍⴻⵙ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴻⵖ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JM3_7","089_3_7","JAS","3","7","7","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵔⴱ ⵏ ⵍⵎⴰⵍ, ⵏ ⵉⵊⴹⴰⴹ ⵓ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴱⵓⵄⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⵜⵡⴰⵎⴰⵔⵙⴻⵏ ⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JM3_8","089_3_8","JAS","3","8","8","ⵎⴰⵛⴰ ⵉⵍⴻⵙ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜ ⵉⵙⵙⵇⴻⵎⵎⴻⵄ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵍⵖⴰⵔ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵇⴻⵎⵎⵄⴻⵏ, ⴰⵇⴰ ⵉⵛⵛⵓⵔ ⵙ ⵙⵙⴻⵎ ⵉⵏⴻⵇⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM3_9","089_3_9","JAS","3","9","9","ⵣⵣⴰⵢⴻⵙ ⵉ ⵏⴱⴰⵔⴻⴽ ⵙⵉⴷⵉ ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵓⵛⴰ ⵣⵣⴰⵢⴻⵙ ⵏᵉⵏⴻⵄⵄⴻⵍ ⵅ ⵉⵡⴷⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JM3_10","089_3_10","JAS","3","10","10","ⴰⵇⴰ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵜᵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵏⵏⴻⵄⵍⴻⵜ. ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵏ ⴰⵢⴰ ⵡⴰⵔ ⵉⵄⴻⴷⴷⴻⵍ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⵎⵓ! ");
INSERT INTO rift_vpl VALUES ("JM3_11","089_3_11","JAS","3","11","11","ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵊⵊ ⵏ ⵍⵄⵓⵏⵚⴰⵔ ⵡⴰⵎⴰⵏ ⵉⵎⵉⵥⵉⴷⴻⵏ ⴷ ⵡⴰⵎⴰⵏ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("JM3_12","089_3_12","JAS","3","12","12","ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰ ⵉⵣⴻⵎⵎⴰⵔ ⵡⴰⵔⵜⵓ ⴰⴷ ⵉⵡⵛ ⵣⵣⵉⵜⵓⵏ ⵏⵉⵖ ⵜⵣⴰⵢⴰⵔⵜ ⵍⴱⴰⵛⵓⵔ? ⴰⵎⵎⵓ ⵓⵍⴰ ⴷ ⴰⵎⴰⵏ ⵉⵎⴻⴵⴰⵃⴻⵏ ⵡⴰⵔ ⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵏ ⴷ ⵉⵎⵉⵥⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM3_13","089_3_13","JAS","3","13","13","ⵡⵉ ⵣⵣⴰⵢⵡⴻⵎ ⵉⴵⴰⵏ ⴷ ⴰⵎⵉⵖⵉⵙ ⵓ ⵙ ⵍⴻⵄⵇⴻⵍ? ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵡⴰⵏⵉⵜⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ ⵣⵉ ⵜⵉⵛⵍⵉ ⵏⵏⴻⵙ ⵉⵚⴻⴱⵃⴻⵏ ⵙ ⵜⵉⵖⵉⵜ ⴰⴽ-ⴷ ⵜⴻⵎⵀⵉⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JM3_14","089_3_14","JAS","3","14","14","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴷⵉⵏ ⵍⴻⵃⵙⴻⴷ ⴰⵎⴻⵔⵣⴰⴳ ⴷ ⵓⵎⵛⵓⴱⴱⴻⵛ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵙⴳⵉⵄⵄⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⵅ ⵜⵉⴷⴻⵜⵜ ⵓ ⵡⴰⵔ ⵙⵅⴰⵔⵔⵉⵇ ⵛⴰ! ");
INSERT INTO rift_vpl VALUES ("JM3_15","089_3_15","JAS","3","15","15","ⵜⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵜⴻⴵⵉ ⴷ ⵜⵉⵖⵉⵜ ⵉ ⴷⴷ-ⵉⵀⵡⴰⵏ ⵣⵉ ⵙⴻⵏⵏⴻⵊ, ⴰⵇⴰ-ⵜⵜ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵣⴻⴳ ⵉⵅⴰⵔⵔⵉⵚⴻⵏ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓ ⵣⵉ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM3_16","089_3_16","JAS","3","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⴻⵃⵙⴻⴷ ⴷ ⵓⵎⵛⵓⴱⴱⴻⵛ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵅⴰⵔⵡⵉⴹⴻⵏ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵜⵓⵄⴻⴼⴼⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JM3_17","089_3_17","JAS","3","17","17","ⵎⴰⵛⴰ ⵜⵉⵖⵉⵜ ⵣⵉ ⵙⴻⵏⵏⴻⵊ ⵜⴻⵣⴷⴻⴳ, ⵅⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵍⴻⵀⵏⴰ ⴷ ⵍⴻⴹⵔⴰⴼⴻⵜ, ⵜᵉⵜⵜⴻⴳⴳ ⴰⵔⵔⴰⵢ, ⵜⴻⵛⵛⵓⵔ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍⵖⵉⴵⴻⵜ ⵉⵚⴻⴱⵃⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵙ ⵍⴻⵃⵣⴰⴱ ⵏⵉⵖ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM3_18","089_3_18","JAS","3","18","18","ⵎⴰⵛⴰ ⵍⵖⵉⴵⴻⵜ ⵏ ⵜⵙⴻⴳⴷⴰ ⵜᵉⵜⵜⵡⴰⵣⴰⵔⵔⴻⵄ ⴷⵉ ⵍⵀⵓⴷⵏⴻⵜ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("JM4_1","089_4_1","JAS","4","1","1","ⵎⴰⵏⵉⵙ ⴷⴷ-ⵉⴽⴽⴰ ⵓⵎⴻⵏⵖⵉ ⴷ ⵉⵎⵛⵓⴱⴱⴻⵛⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ? ⵎⴰ ⵣⴻⵄⵎⴰ ⵣⴻⴳ ⵛⵛⴻⵀⵡⴰⵜ ⵉ ⵉⵎⵎⴻⵏⵖⴻⵏ ⴷⴻⴳ ⵉⵖⴻⵣⴷⵉⵙⴻⵏ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JM4_2","089_4_2","JAS","4","2","2","ⴽⴻⵏⵏⵉⵡ ⵜⴻⵎⵎⴻⵥⵔⴻⵎ ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵡⴰⵍⵓ. ⴽⴻⵏⵏⵉⵡ ⵜⵏⴻⵇⵇⴻⵎ ⵓ ⵜᵉⵜⵜⴰⵙⵎⴻⵎ ⵓⵛⴰ ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵡⴰⵔ ⴷⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵉⴽⴽⵡⵉⴹ ⵡⴰⵍⵓ. ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⵎⵛⵓⴱⴱⵓⵛⴻⵎ ⵓ ⵜᵉⵜⵜⵎⴻⵏⵖⴰⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⵡⴰⵍⵓ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⴰⵔⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JM4_3","089_4_3","JAS","4","3","3","ⵏⵉⵖ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜᵉⵜⵜⴰⵔⴰⵎ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⴽⵙⵉⵎ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵜᵉⵜⵜᵉⵜⵜⴰⵔⴻⵎ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵖⴰⵔ ⵛⵛⴻⵀⵡⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JM4_4","089_4_4","JAS","4","4","4","ⴰ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵣⴻⵏⵏⴰⵏ! ⵎⴰ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⴱⴻⵍⵍⵉ ⵜⴰⵎⴻⵅⵙⵉⵡⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵇⴰ-ⵜⵜ ⴷ ⵍⴻⵄⴷⴰⵡⴻⵜ ⵅ ⴰⵔⴻⴱⴱⵉ? ⴰⵃⴻⵇⵇⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⴷⴷⵓⴽⴽⴻⵍ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵍⴻⵄⴷⵓ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("JM4_5","089_4_5","JAS","4","5","5","ⵏⵉⵖ ⵉⵜⵜⵖⵉⵍ ⴰⵡⴻⵎ ⴱⴻⵍⵍⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏⵜ ⵍⵎⴻⵄⵏⴰ: “ⴰⵔⵔⵓⵃ ⵉ ⴷⴰⵢⵏⴻⵖ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵉⵜⵜⴰⵙⴻⵎ ⵙ ⵜⵓⵙⵎⵉ!”? ");
INSERT INTO rift_vpl VALUES ("JM4_6","089_4_6","JAS","4","6","6","ⵎⴰⵛⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵉⵜⵜⵉⵛ ⴰⵏⴻⵖ ⴰⵔⴹⴰ ⴽⵜⴰⵔ, ⵎⴰⵖⴰⵔ ⵉⵏⵏⴰ: “ⴰⵔⴻⴱⴱⵉ ⵉⵙⵙⵡⴰⴹⴹⴻⵄ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉ ⵉⵎⵡⴰⴹⵄⴻⵏ ⵉⵜⵜⵉⵛ ⴰⵙⴻⵏ ⴰⵔⴹⴰ.” ");
INSERT INTO rift_vpl VALUES ("JM4_7","089_4_7","JAS","4","7","7","ⵙ ⵓⵢⴰ ⵎⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⵄⴰⵍⴰⵎ ⴰⴽ-ⴷ ⵛⵛⵉⵟⴰⵏ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵢⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("JM4_8","089_4_8","JAS","4","8","8","ⴰⴷⵙⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⴷⴷ-ⵢⴰⴷⴻⵙ. ⵙⵉⵔⴷⴻⵎ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵡⴻⵎ, ⴰ ⵉⵎⴻⴷⵏⴰⴱ, ⵇⴻⴷⴷⵙⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⴰ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM4_9","089_4_9","JAS","4","9","9","ⵎⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵛⴻⴹⵏⴻⵎ! ⵊⵊⴻⵎ ⵜⴰⴹⴻⵃⵃⴰⵛⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⴰⵛⴹⴰⵏ ⵓ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵡⴻⵎ ⴰⴷ ⵜⴻⴷⵡⴻⵍ ⴷ ⵍⴻⵃⵣⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM4_10","089_4_10","JAS","4","10","10","ⵎⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⵣⴰⵜ ⵉ ⵙⵉⴷⵉ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵄⵓⴵ. ");
INSERT INTO rift_vpl VALUES ("JM4_11","089_4_11","JAS","4","11","11","ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴰⵢⴰⵡⵢⴰ! ⵡⴻⵏⵏⵉ ⵉⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴻⴳ ⵓⵎⴰⵙ ⵏⵉⵖ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵓⵎⴰⵙ, ⴰⵇⴰ ⵡⴰ ⵉⵜⵜⵛⴻⵇⵇⴰⴼ ⴷⵉ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵛⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵅ ⵛⵛⴰⵔⵉⵄⴰ. ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⵃⴻⴽⵎⴻⴷ ⵅ ⵛⵛⴰⵔⵉⵄⴰ, ⴰⵇⴰ ⵡⴰⵔ ⵜⴻⴵⵉⴷ ⵛⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵎⴰⵛⴰ ⵜⴰⵔⵔⵉⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵛ ⴷ ⵍⵇⴰⴹⵉ ⵏ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("JM4_12","089_4_12","JAS","4","12","12","ⵉⵊⵊⴻⵏ ⵡⴰⵀⴰ ⵉ ⵉⴵⴰⵏ ⴷ ⴱⴰⴱ ⵏ ⵛⵛⴰⵔⵉⵄⴰ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⵣⴻⵎⵎⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵡⵛ ⵜⵓⴷⴰⵔⵜ ⵏⵉⵖ ⴰⴷ ⵜⵜ ⵢⴰⵔⴻⵢⵢⴻⴱ. ⵎⴰⵛⴰ ⵎⵉⵏ ⵜⴻⵄⵏⵉⴷ ⵛⴻⴽ ⵓⵎⵉ ⵜⵃⴻⴽⴽⵎⴻⴷ ⵅ ⵊⵊⴰⵔ ⵏⵡⴻⵎ? ");
INSERT INTO rift_vpl VALUES ("JM4_13","089_4_13","JAS","4","13","13","ⵎⴰ ⵅⴻⵏⵏⵉ ⵉ ⵖⴰ ⵏⵉⵏⵉ ⵅ ⵢⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⴰⵙⵙ-ⴰ ⵏⵉⵖ ⵜⵉⵡⴻⵛⵛⴰ ⴰⴷ ⵏⵔⴰⵃ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ-ⵉⵏ, ⴰⴷ ⴷⵉⵏ ⵏⴻⴳⴳ ⵜⴰⵙⴻⴱⴱⴰⴱⵜ ⵍⵎⵉⵊⴰⵍ ⵏ ⵉⵊⵊ ⵏ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⴰⴷ ⵏⵙⴻⵖ ⴰⴷ ⵏⴻⵣⵣⴻⵏⵣ ⴰⴷ ⵏⴰⵔⴱⴻⵃ!”? ");
INSERT INTO rift_vpl VALUES ("JM4_14","089_4_14","JAS","4","14","14","ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵜⵉⵍⵉ ⵜⵉⵡⴻⵛⵛⴰ. ⵎⵉⵏ ⵜⴻⵄⵏⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ? ⴰⵇⴰ-ⵜⵜ ⵎⵖⵉⵔ ⴷ ⵉⵊⵊ ⵏ ⵍⴻⴼⵡⴰⵔ ⵉ ⵖⴰ ⴷⴷ-ⵉⴹⵀⴰⵔ, ⴰⴷ ⵉⴷⵓⵔⵔⴻⵇ, ⴰⴷ ⵜⴻⴼⵙⵉ ⵍⴻⵅⴷⴻⵏⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("JM4_15","089_4_15","JAS","4","15","15","ⵙ ⵓⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵏⵉⵏ: “ⵎⴰⵍⴰ ⵉⵅⵙ ⵙⵉⴷⵉ, ⴰⴷ ⵏⴻⴷⴷⴰⵔ, ⴰⴷ ⵏⴻⴳⴳ ⵜⴰ ⴷ ⵜⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("JM4_16","089_4_16","JAS","4","16","16","ⵉⵡⴰ ⵏⵉⵜⵏⵉ ⵜⵜⴼⴻⵢⵢⵛⴻⵏ ⴷⴻⴳ ⵓⵄⴻⴼⴼⴰⵔ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵇⴰⵄ ⴰⴼⴻⵢⵢⴻⵛ-ⴰ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JM4_17","089_4_17","JAS","4","17","17","ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⴳⴳ ⵍⵅⴰⵔ ⵓⵛⴰ ⵡⴰⵔ ⵜ ⵉⵜⵜⴻⴳⴳ, ⴰⴷ ⴰⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵃⵙⴻⴱ ⴷ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("JM5_1","089_5_1","JAS","5","1","1","ⵉⵡⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ, ⵙⵃⵉⵙⵙⴼⴻⵎ, ⵔⵓⵎ ⵉ ⵍⵎⵓⵚⵉⴱⴰⵜ ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵜⵜⵔⴰⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JM5_2","089_5_2","JAS","5","2","2","ⵎⵉⵏⵣⵉ ⴰⴳⵍⴰ ⵏⵡⴻⵎ ⴰⵇⴰ ⵉⵖⵓⵎⵎ, ⵢⴰⵔⵚⵓⴹ, ⵓⵛⴰ ⴰⵔⵔⵓⴹ ⵏⵡⴻⵎ ⵛⵛⵉⵏ ⵜ ⵜⵛⵉⵏⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("JM5_3","089_5_3","JAS","5","3","3","ⵓⵔⴻⵖ ⵏⵡⴻⵎ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⵏⵡⴻⵎ ⴰⵇⴰ ⴰⵔⵛⴰⵏ ⵓⵛⴰ ⴰⵔⴻⵛⵛⵉ ⵏⵙⴻⵏ ⴰⴷ ⵅⴰⵡⴻⵎ ⵜⴻⵛⵀⴻⴷ, ⴰⴷ ⵉⵛⵛ ⴷⴷⴰⵜ ⵏⵡⴻⵎ ⴰⵎ ⵜⵎⴻⵙⵙⵉ. ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵢⵔⵓⵎ ⵜⵉⵎⴻⵙⵙⵉ ⵉ ⵢⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵉ ⵡⵓⵙⵙⴰⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("JM5_4","089_5_4","JAS","5","4","4","ⵅⵣⴰⵔ, ⵍⵎⵓⵏⴻⵜ ⵏ ⵉⵛⴻⵡⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⴻⵙⵙⵄⵉⵣⵣⴻⵎ ⵅ ⵢⴻⵏⵏⵉ ⵉⵎⵊⴰⵔⴻⵏ ⵉⵢⵢⴰⵔⴻⵏ ⵏⵡⴻⵎ ⵜⴻⵙⵖⵓⵢⵢⵓ, ⵓⵛⴰ ⵜⵖⵓⵢⵢⵉⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵎⵊⴰⵔⴻⵏ ⵜⵉⵡⴻⴹ ⴰⵙ-ⴷⴷ ⴰⵍ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏ ⵙⵉⴷⵉ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("JM5_5","089_5_5","JAS","5","5","5","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴼⴻⵢⵢⵛⴻⵎ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⴹⴼⴰⵔⴻⵎ ⵎⴻⵥⵔⵉ ⵏⵡⴻⵎ. ⴰⵇⴰ ⵜⴻⵙⵙⵊⵉⵡⵏⴻⵎ ⴰⵔⵔⵉⵎⴰⵜ ⵏⵡⴻⵎ ⴰⵎ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵜⵖⴰⵔⵚⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("JM5_6","089_5_6","JAS","5","6","6","ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵃⴻⴽⵎⴻⵎ ⵅ ⵓⵎⵙⴻⴳⴳⴰⴷ ⵙ ⵍⵎⴻⵡⵜ, ⴰⵎ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵉⵎⵎⵄⴰⵍⴰ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JM5_7","089_5_7","JAS","5","7","7","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⴰⵢⵜⵎⴰ, ⵚⴱⴰⵔⴻⵎ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙ ⵙⵉⴷⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵔⴰⵊⴰ ⵓⴼⴻⴵⴰⵃ ⵖⴰⵔ ⵍⵖⵉⴵⴻⵜ ⵉⵖⵍⴰⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵚⴱⴰⵔ ⵙ ⵍⵅⴰⴹⴰⵔ ⴰⵍ ⵅⴰⵙ ⵉⵡⵡⴻⵜ ⵡⴻⵏⵥⴰⵔ ⵏ ⵣⵉⵛ ⴷ ⵓⵏⴻⴳⴳⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("JM5_8","089_5_8","JAS","5","8","8","ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ, ⵚⴱⴰⵔⴻⵎ, ⵙⵎⴻⵃⵃⴷⴻⵎ ⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⴰⵇⴰ ⵜⴰⵡⴰⵙⵉⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵜⵓⴷⴻⵙ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("JM5_9","089_5_9","JAS","5","9","9","ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⵙⵓⴹⴻⵎ ⵅ ⵡⴰⵢⴰⵡⵢⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⵉⴽⴽⵡⵉⴹ ⵍⵃⵓⴽⵎ. ⵎⴰⵖⴰⵔ ⵅⵣⴰⵔ, ⵍⵇⴰⴹⵉ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("JM5_10","089_5_10","JAS","5","10","10","ⴰ ⴰⵢⵜⵎⴰ, ⵎⵇⵓⴷⴷⴰⵎ ⴰⴽ-ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵚⴱⴰⵔⴻⵎ ⴷⵉ ⵍⴻⵃⵚⴰⵔⴰⵜ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("JM5_11","089_5_11","JAS","5","11","11","ⵅⵣⴰⵔⴻⵎ, ⴰⴷ ⵏⴱⴰⵔⴻⴽ ⵉⵏⵏⵉ ⵉⵜⵜⵚⴻⴱⴱⴰⵔⴻⵏ. ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵍⴰⵎ ⵅ ⵚⵚⴱⴰⵔ ⵏ ⴰⵢⵓⴱ ⵓⵛⴰ ⵜⵡⴰⵍⴰⵎ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵏⵏⵉ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⵙⵉⴷⵉ, ⵎⴰⵖⴰⵔ ⵙⵉⴷⵉ ⴷ ⴰⵔⵃⵉⵎ ⴷ ⴰⵃⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("JM5_12","089_5_12","JAS","5","12","12","ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵎⴰⵔⵔⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⵡⴰⵔ ⵜⵜⵊⴰⴵⴰⵎ ⵛⴰ, ⵍⴰ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵍⴰ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵜⵊⴰⴵⵉⵜ ⵏⵏⴻⵖⵏⵉ. ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵢⵉⵍⵉ ‘ⵡⴰⵀ!’ ⵏⵡⴻⵎ ⴷ ‘ⵡⴰⵀ!’, ⴷ ‘ⵍⵍⴰ!’ ⵏⵡⴻⵎ ⴷ ‘ⵍⵍⴰ!’, ⵏⵉⵖ ⴰⵇⴰ ⴰⴷ ⵜⵉⵍⵉⵎ ⵙⴰⴷⵓ ⵍⵃⵓⴽⵎ. ");
INSERT INTO rift_vpl VALUES ("JM5_13","089_5_13","JAS","5","13","13","ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⵡⴻⴷⴷⴻⴱ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵜⵜⴰⵔ. ⵎⴰ ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⴼⴰⵔⵃ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵖⴻⵏⵏⴻⵊ ⵙ ⵉⵣⵍⴰⵏ ⵏ ⵓⵚⴻⴱⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("JM5_14","089_5_14","JAS","5","14","14","ⵎⴰ ⴷⵉⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⵃⴻⴷ ⵉⵀⵍⴻⵛ? ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵉⵍⴰⵖⴰ ⵅ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵖⴰⵔⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⴽⵙⵉⵏ ⵙ ⵍⵎⴻⵄⵔⵓⴼ, ⴰⴷ ⵜ ⵔⴻⵜⴼⴻⵏ ⵙ ⵣⵣⴻⵛⵜ ⵏ ⵡⴻⴷⵀⴰⵏ ⵙ ⵢⵉⵙⴻⵎ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("JM5_15","089_5_15","JAS","5","15","15","ⵓⵛⴰ ⵜⴰⵥⴰⴵⵉⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⴰⴷ ⵜⴻⵙⵙⴳⴻⵏⴼⴰ ⴰⵎⴻⵀⵍⵓⵛ ⵓⵛⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴰⴷ ⵜ ⵉⵙⵙⵏⴻⴽⴽⴰⵔ. ⵓⵛⴰ ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⴳⴳ ⴷⴷⵏⵓⴱ, ⴰⴷ ⴰⵙ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM5_16","089_5_16","JAS","5","16","16","ⵏⴻⵄⵎⴻⵎ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵉⵄⴻⴷⵉⵢⵢⴻⵏ ⵏⵡⴻⵎ ⵓ ⵥⴰⴵⴻⵎ ⵉ ⵡⴰⵢⴰⵡⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵎ, ⵎⴰⵖⴰⵔ ⵊⵊⴻⵀⴷ ⵏ ⵜⵥⴰⴵⵉⵜ ⵏ ⵓⵎⵙⴻⴳⴳⴰⴷ ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JM5_17","089_5_17","JAS","5","17","17","ⵉⵍⵉⵢⴰ ⵜⵓⵖⴰ ⴷ ⴱⵏⴰⴷⴻⵎ ⵉⵜⵜⴰⵛⴰ ⴰⵎ ⵏⴻⵛⵛⵉⵏ. ⵉⵥⵥⵓⴵ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵛⵛⵉⵜ ⵡⴻⵏⵥⴰⵔ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵅⴻⵏⵏⵉ ⴰⵏⵥⴰⵔ ⵡⴰⵔ ⵉⵡⵜⵉ ⵛⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵜⵍⴰⵜⴰ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴷ ⵙⴻⵜⵜⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JM5_18","089_5_18","JAS","5","18","18","ⵓⵛⴰ ⵜⵓⵖⴰ ⵉⵥⵥⵓⴵ ⵄⴰⵡⴻⴷ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⵊⴻⵏⵏⴰ ⵉⵡⵜⴰ ⴰⵏⵥⴰⵔ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⵡⵛⴰ ⵚⵚⴰⴱⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JM5_19","089_5_19","JAS","5","19","19","ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵊⴰⵔ ⴰⵡⴻⵎ ⵉⴼⴼⴻⵖ ⵅ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵢⴰⵔⵔ ⵉ-ⵜ-ⵉ-ⴷⴷ ⴰⴷ ⴷⴷ-ⵉⴷⵡⴻⵍ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JM5_20","089_5_20","JAS","5","20","20","ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⵙⴻⵏ, ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵔⵔⴻⵏ ⴰⵎⴻⴷⵏⵓⴱ ⵣⴻⴳ ⵓⵡⴻⴷⴷⴰⵔ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵍⴻⵄⵎⴰⵔ ⵣⵉ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴷⵓⵔⵉⵢ ⴰⵟⵟⴰⵙ ⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("P11_1","090_1_1","1PE","1","1","1","ⴱⵓⵟⵔⵓⵙ, ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷ ⵉⵎⴻⵄⵣⴰⴱ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵥⴻⴵⵄⴻⵏ ⴷⵉ ⴱⵓⵏⵟⵓⵙ, ⴳⴰⵍⴰⵟⵉⵢⴰ, ⴽⴰⴱⴱⴰⴷⵓⴽⵉⵢⴰ, ⴰⵙⵉⵢⴰ ⴷ ⴱⵉⵜⵉⵏⵉⵢⴰ,    ");
INSERT INTO rift_vpl VALUES ("P11_2","090_1_2","1PE","1","2","2","ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵓⵙⵙⵏⴰ ⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵇⴱⴻⵍ, ⵙ ⵜⵓⵇⴻⴷⴷⵙⵉ ⵏ ⴰⵔⵔⵓⵃ, ⵉ ⵟⵟⴰⵄⴻⵜ ⵓ ⵉ ⵓⵔⵓⵛⵛⵉ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ: ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵎⵎⴰⵔⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("P11_3","090_1_3","1PE","1","3","3","ⵍⴱⴰⵔⴰⴽⴰ ⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵢⴻⵊⵊⵉⵏ ⵣⵉ ⵊⴷⵉⴷ ⵙ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙ ⵜⵏⵓⴽⵔⴰ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⴰⵙⵉⵜⴻⵎ ⵉⴷⴷⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("P11_4","090_1_4","1PE","1","4","4","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵉⵛⵜ ⵏ ⵍⵡⴰⵔⵜ ⵡⴰⵔ ⵜⴼⴻⵏⵏⵉ, ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴱⴻⵇⵇⴻⴹ, ⵡⴰⵔ ⵜᵉⵜⵜⴻⵙⵍⵉⵡ, ⵡⴻⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⵡⴻⵊⴷⴻⵏ ⴷⴻⴳ ⵉⵊⴻⵏⵡⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("P11_5","090_1_5","1PE","1","5","5","ⴰⵎ ⵜᵉⵜⵜⵡⴰⵃⴹⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵙ ⵍ’ⵉⵎⴰⵏ ⵉ ⵜⵓⴷⴰⵔⵜ ⵉ ⵉⵡⴻⵊⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ ⴷⵉ ⵍⵡⴻⵇⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("P11_6","090_1_6","1PE","1","6","6","ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⵜⴼⴰⵔⵃⴻⵎ ⵉ ⵍⴻⴱⴷⴰ, ⵡⴰⵅⵅⴰ ⵜⵃⴻⵣⵏⴻⵎ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⴷⵔⵓⵙ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⵉⵊⴰⵔⵔⵉⴱⴻⵏ ⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⴻⴽⴽⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("P11_7","090_1_7","1PE","1","7","7","ⵃⵉⵎⴰ ⵜⴰⵇⴻⴵⴻⴱⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⵜⴻⵏⵏⵉ ⵜⵉⵖⵍⴰ ⵅ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵚⴼⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵙⵉ, ⴰⴷ ⵜⵉⵍⵉ ⵉ ⵓⵙⴻⵎⵖⴰⵔ ⴷ ⵛⵛⴰⵏ ⴷ ⵓⵄⵓⴵⵉ ⵅ ⵎⵉⵏⵏⵉ ⴷⴷ-ⵖⴰ ⵉⴹⵀⴰⵔ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("P11_8","090_1_8","1PE","1","8","8","ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵜ ⵜⴻⵥⵔⵉⵎ, ⵡⴰⵅⵅⴰ ⵜᵉⵜⵜⴻⵅⵙⴻⵎ ⵜ. ⵙ ⵍ’ⵉⵎⴰⵏ ⵣⵣⴰⵢⴻⵙ ⵜⴼⴰⵔⵔⵃⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵉⵛⵜ ⵏ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉⵄⵓⴵⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵏⵟⴻⵇ ⵉⵍⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("P11_9","090_1_9","1PE","1","9","9","ⵎⴰⵖⴰⵔ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⵍⵎⵓⵏⴻⵜ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⵓⴷⴰⵔⵜ ⵏ ⴱⵓⵃⴱⴻⵍ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P11_10","090_1_10","1PE","1","10","10","ⵜⵓⴷⴰⵔⵜ-ⴰ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵅⴰⵙ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵏⴰⴱⴱⴻⵏ ⵅ ⴰⵔⴹⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⴽⴽⴰⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("P11_11","090_1_11","1PE","1","11","11","ⵓⵎⵉ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ ⵎⴰⵏ ⵍⵡⴻⵇⵜ ⵉ ⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵛⴻⵏ ⴰⵔⵔⵓⵃ ⵏ ⵍⵎⴰⵙⵉⵃ ⵉ ⴷⴰⵢⵙⴻⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ, ⵓ ⵎⴰⵏ ⵍⵡⴻⵇⵜ ⵉ ⵅⴻⴼ ⵜⵓⵖⴰ ⵉⵛⴻⵀⵀⴻⴷ, ⴰⵇⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵓⵡⴻⴷⴷⴻⴱ ⵉ ⵖⴰ ⵉⴽⴽⴻⵏ ⵅ ⵍⵎⴰⵙⵉⵃ ⵓⵍⴰ ⴷ ⴰⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("P11_12","090_1_12","1PE","1","12","12","ⴰⵇⴰ ⵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ ⴰⵙⴻⵏ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜⵓⵖⴰ ⴰⵔⴻⵣⵣⵓⵏ, ⴰⵇⴰ ⵡⴰⵔ ⵜ ⴰⵔⵣⵓⵏ ⴷⵉ ⵜⵉⵣⵉ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵜⵜⵏⴰⴱⴱⴻⵏ ⴷⵉ ⵜⵉⵣⵉ ⵏⵏⴻⵖ ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵏⴻⵖ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵜⵜⵡⴰⵙⵙⵙⴰⵔⴳⴱⴻⵏ ⵍⴻⵅⵅⵓ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⴱⴻⵛⵛⴰⵔⴻⵏ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⵙⴻⴽⴽⴻⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⴷⵉ ⵜⵜⵎⴻⵥⵥⵔⴻⵏⵜ ⵓⵍⴰ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⴰⴷ ⴷⴰⵢⵙⴻⵏⵜ ⵅⵣⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("P11_13","090_1_13","1PE","1","13","13","ⵙ ⵓⵢⴻⵏⵏⵉ ⵃⴻⵣⵎⴻⵎ ⵍⵅⴰⵏⵙⵔⴰ ⵏ ⵍⴻⵄⵇⴻⵍ ⵏⵡⴻⵎ, ⵉⵍⵉⵎ ⵜᵉⵜⵜⴼⴰⵇⴻⵎ ⵏⵉⵛⴰⵏ, ⵓⵛⴰ ⵙⵎⵓⵏⴻⵎ ⵎⴰⵔⵔⴰ ⴰⵙⵉⵜⴻⵎ ⵏⵡⴻⵎ ⴷⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵢⴰⵡⴹⴻⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴹⵀⴰⵔ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P11_14","090_1_14","1PE","1","14","14","ⵉⵍⵉⵎ ⴰⵎ ⵜⴰⵔⵡⴰ ⵉⵜⵜᵉⵟⵟⴰⵄⴻⵏ, ⵡⴰⵔ ⴷⴷ-ⵜⴷⴻⴽⴽⵡⵉⵍⴻⵎ ⵜⵛⴰⵔⵔⵛⴻⵎ ⴷⵉ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵡⴻⵎ ⵜⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⴹⴼⴰⵔⴻⵎ ⵇⴱⴻⵍ ⵙ ⵏⵏⴻⵛⵡⴻⵜ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⴷ ⵉⵇⵓⴱⴱⴰⵏⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P11_15","090_1_15","1PE","1","15","15","ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⴻⵜⵜⴰ ⵡⴻⵏⵏⵉ ⵅⴰⵡⴻⵎ ⴷⴷ-ⵉⵍⴰⵖⴰⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ, ");
INSERT INTO rift_vpl VALUES ("P11_16","090_1_16","1PE","1","16","16","ⵎⵉⵏⵣⵉ ⵜⵓⵔⴰ: “ⵉⵍⵉⵎ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("P11_17","090_1_17","1PE","1","17","17","ⵓ ⵎⴰⵍⴰ ⵜᵉⵜⵜⵍⴰⵖⴰⵎ ⵉ ⵜⴰⴱⴰⴱⴰⵜ, ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵉⵃⴻⴽⴽⵎⴻⵏ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ, ⵅⴻⵏⵏⵉ ⵓⵢⵓⵔⴻⵎ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷⵉ ⵍⵡⴻⵇⵜ-ⴰ ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵄⴰⴷ ⴷ ⵉⵎⴻⵄⵣⴰⴱ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("P11_18","090_1_18","1PE","1","18","18","ⵎⴰⵖⴰⵔ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⴼⴷⵉⵎ ⵙ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵡⵓⵔⴻⵖ ⵉⴼⴻⵏⵏⴰⵏ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵡⴻⵎ ⵉⴱⴻⴹⵍⴻⵏ ⵜⵉⵏⵏⵉ ⵜᵉⵟⵟⴼⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵣⵉ ⵍⴻⵊⴷⵓⴷ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("P11_19","090_1_19","1PE","1","19","19","ⵎⴰⵛⴰ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵉⵖⵍⴰⵏ ⵏ ⵉⵣⵎⴰⵔ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⵄⵉⴱ, ⵡⴰⵔ ⵉⴱⴻⵇⵇⴹⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P11_20","090_1_20","1PE","1","20","20","ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⴼⴰⵔⵣ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵇⴱⴻⵍ ⵎⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵙⴰⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ ⴰⵡⴻⵎ-ⴷⴷ ⵍⴻⵅⵅⵓ ⴷⵉ ⵣⵣⵎⴰⵏⴰⵜ ⵉⵏⴻⴳⴳⵓⵔⴰ ⵏ ⵍⵡⴻⵇⵜ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("P11_21","090_1_21","1PE","1","21","21","ⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⴰⵎⵏⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵙⵙⵏⴻⴽⴽⴰⵔⴻⵏ ⵣⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵙ ⴰⵄⵓⴵⵉ, ⵃⵉⵎⴰ ⵍ’ⵉⵎⴰⵏ ⴷ ⵓⵙⵉⵜⴻⵎ ⵏⵡⴻⵎ ⴰⴷ ⵉⵍⵉⵏ ⵅ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P11_22","090_1_22","1PE","1","22","22","ⴷ ⵎⴰⵏ ⴰⵢⴰ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴷⴷⵙⴻⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ ⵙ ⵟⵟⴰⵄⴻⵜ ⵉ ⵜⵉⴷⴻⵜⵜ, ⴰⴷ ⵜⵜⵡⴰⵄⴻⵎⵎⴰⵔⴻⵏ ⵙ ⵜⴰⵢⵔⵉ ⴱⵍⴰ ⵍⴼⴰⵔⵣ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵓⵛⴰ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⴰⵢⴰⵡⵢⴰ ⵙ ⵡⵓⵍ ⵉⵣⴷⵉⴳ ⵉⴽⵎⴻⵍ, ");
INSERT INTO rift_vpl VALUES ("P11_23","090_1_23","1PE","1","23","23","ⴰⵎ ⵉⵡⴷⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴷ ⵊⴷⵉⴷ, ⵡⴰⵔ ⵉⴵⵉ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵉⴼⴻⵏⵏⴰⵏ, ⵎⴰⵛⴰ ⵣⵉ ⵜⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ, ⴰⵇⴰ ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵉⴷⴷⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("P11_24","090_1_24","1PE","1","24","24","“ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴷⴷⴰⵜ ⴰⵎ ⴰⵔⴱⵉⵄ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⴰⵥⵔⵉ ⵏⵏⴻⵙ ⴰⵎ ⵜⴰⵡⴰⵔⴷⴻⵛⵜ ⴷⴻⴳ ⵢⴻⵢⵢⴰⵔ ⵙ ⴰⵔⴱⵉⵄ, ⴰⵔⴱⵉⵄ ⴰⴷ ⵉⵙⵍⴰⵡ, ⵜⴰⵡⴰⵔⴷⴻⵛⵜ ⴰⴷ ⵜⴻⵡⴹⴰ, ");
INSERT INTO rift_vpl VALUES ("P11_25","090_1_25","1PE","1","25","25","ⵎⴰⵛⴰ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵉⵜⵜⵖⵉⵎⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ.” ⴰⵡⴰⵍ-ⴰ ⵏⴻⵜⵜⴰ ⴷ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵉⵜⵜⵡⴰⴱⴰⵔⵔⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P12_1","090_2_1","1PE","2","1","1","ⵙ ⵓⵢⴻⵏⵏⵉ ⴱⴻⵄⵄⴷⴻⵎ ⵅ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⵅ ⵄⵍⴰⵎ ⴽⵓⵍ ⵜⴰⵃⵔⴰⵢⵎⴻⵛⵜ ⴷ ⵏⵏⵉⴼⴰⵇ ⴷ ⵍⴻⵃⵙⴻⴷ ⵓ ⵅ ⵓⵛⴻⵇⵇⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("P12_2","090_2_2","1PE","2","2","2","ⵉⵍⵉⵎ ⴰⵎ ⵉⵙⴻⵢⵎⴰⵏ ⵉⵜⵜⴻⵟⵟⴹⴻⵏ, ⵡⴻⵃⵃⵛⴻⵎ ⴰⵡⴰⵍ ⴰⵎ ⵓⵖⵉ ⵉⵣⴷⵉⴳⴻⵏ ⴷ ⴰⵔⵔⵓⵃⴰⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜⴻⴳⵎⴰⵎ ⵉ ⵜⵓⴷⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("P12_3","090_2_3","1PE","2","3","3","ⵎⴰⵍⴰ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵇⵇⴰⵙⴻⵎ ⵓ ⵜᵉⵜⵜⵡⴰⵍⴰⵎ ⴰⵇⴰ ⵙⵉⴷⵉ ⵉⵚⴱⴻⵃ. ");
INSERT INTO rift_vpl VALUES ("P12_4","090_2_4","1PE","2","4","4","ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴷⴷ-ⵜᵉⵜⵜⴰⴽⴽⵡⴰⴹⴻⵎ, ⴰⵥⵔⵓ ⵉⴷⴷⴰⵔⴻⵏ, ⵡⴻⵏⵏⵉ ⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜ ⵉⵜⵜⵡⴰⴼⴰⵔⵣ ⵉⵖⵍⴰ. ");
INSERT INTO rift_vpl VALUES ("P12_5","090_2_5","1PE","2","5","5","ⴰⵎⵎⵓ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ, ⴰⵎ ⵢⵉⵥⵔⴰ ⵉⴷⴷⴰⵔⴻⵏ, ⵊⵊⴻⵎ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⵜᵉⵜⵜⵡⴰⴱⵏⴰⵏⵜ ⵜⵉⵣⴰⵡⵉⵢⵢⵉⵏ ⵏ ⴰⵔⵔⵓⵃ, ⴰⴷ ⵜⵉⵍⵉⵎ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵡⵛⴻⵎ ⵜⵉⵖⴰⵔⵚⵉⵏ ⵏ ⴰⵔⵔⵓⵃ ⵉ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P12_6","090_2_6","1PE","2","6","6","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴷⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ: “ⴰⵇⴰ ⴷⴰ, ⴰⴷ ⵙⵙⴰⵔⵙⴻⵖ ⴷⵉ ⵚⵉⵀⵢⵓⵏ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⵉⵖⵍⴰ ⴰⵎ ⵓⵣⴻⴵⵉⴼ ⵏ ⵜⴻⵖⵎⴰⵔⵜ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉ ⵣⵣⴰⵢⴻⵙ ⵖⴰ ⵢⴰⵎⵏⴻⵏ, ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵉⵜⵜⵉⴷⴻⴼ ⵓⵙⴻⴹⵃⵉ ⵄⴻⵎⵎⴰⵔⵚ.” ");
INSERT INTO rift_vpl VALUES ("P12_7","090_2_7","1PE","2","7","7","ⵉ ⴽⴻⵏⵏⵉⵡ, ⵉⵏⵏⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ, ⴰⵇⴰ ⵜⴻⵎⵎⴻⵡⵛ ⵛⵛⴻⵏⵄⴻⵜ-ⴰ, ⵎⴰⵛⴰ ⵉ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰⵚⴹⴰⵔⵜ ⵏ ⵓⵏⴻⵇⵔⴰⴹ ⴷ ⴰⵥⵔⵓ ⵏ ⵓⵏⴻⴷⵔⴻⴼ. ");
INSERT INTO rift_vpl VALUES ("P12_8","090_2_8","1PE","2","8","8","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵏⴻⵇⵔⴰⴹⴻⵏ ⴷⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⵜⵉⵎⵏⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵢⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("P12_9","090_2_9","1PE","2","9","9","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴵⴰⵎ ⴷ ⵉⵊⵊ ⵏ ⵊⵊⵉⵍ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵜᵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵎ ⴰⵎ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵉ ⵜⴳⴻⵍⴷⵉⵜ, ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⵊⵊ ⵏ ⵍⴳⴻⵏⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵉⵊⵊ ⵏ ⵓⵎⵓⵏⵉ ⵉⵜⵜⵡⴰⴼⴷⵉⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴱⴰⵔⵔⵃⴻⵎ ⴰⵙⴻⵎⵖⴰⵔ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵍⴰⵖⴰⵏ ⵣⵉ ⵜⴰⴵⴻⵙⵜ ⵖⴰⵔ ⵓⴼⴻⵢⵢⴻⴹ ⵏ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P12_10","090_2_10","1PE","2","10","10","ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⵃⵙⵉⴱⴻⵎ ⴰⵎ ⵍⴳⴻⵏⵙ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵍⴳⴻⵏⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵄⴰⵡⴻⴷ ⵜⵓⵖⴰ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵍⴻⵃⵃⴻⴼ, ⵎⴰⵛⴰ ⵍⴻⵅⵅⵓ ⵜᵉⵜⵜⵡⴰⴼⴰⵔⵔⴻⵖ-ⴷⴷ ⵅⴰⵡⴻⵎ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P12_11","090_2_11","1PE","2","11","11","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴷ ⵉⵎⴻⵄⵣⴰⴱ, ⵅ ⵓⵢⴻⵏⵏⵉ ⵣⵉⵢⵢⴰⵔⴻⵖ ⵅⴰⵡⴻⵎ, ⵡⴰⵔ ⴹⴻⴼⴼⴰⵔⴻⵎ ⵛⴰ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⵉ ⵉⵜⵜⵎⴻⵏⵖⴰⵏ ⴰⴽ-ⴷ ⵍⴻⵄⵎⴰⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P12_12","090_2_12","1PE","2","12","12","ⵓⵢⵓⵔⴻⵎ ⵏⵉⵛⴰⵏ ⵣⵣⴰⵜ ⵉ ⵎⴰⵔⵔⴰ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵜⵜⵄⴰⵡⴰⴷⴻⵏ ⵍⴻⵅⴱⵓⵔⴰⵜ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ, ⴰⵍⴰⵎⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵡⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ, ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵓⵇⴻⴵⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("P12_13","090_2_13","1PE","2","13","13","ⵟⵟⴰⵄⴻⵎ ⵉ ⵎⴰⵔⵔⴰ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⴰⵔⴻⴱⴱⵉ: ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵚⵚⵓⵍⵟⴰ ⵉ ⵖⴰⵔⵙⴻⵏ ⵜⴻⴵⴰ, ");
INSERT INTO rift_vpl VALUES ("P12_14","090_2_14","1PE","2","14","14","ⵓ ⵉ ⵍⵇⵓⴹⴰⵜ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵄⴰⵇⴱⴻⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵎⵖⴰⵔⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵚⴻⴱⵃⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("P12_15","090_2_15","1PE","2","15","15","ⵎⵉⵏⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⴻⵅⵙ ⵉ-ⵜ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ, ⵅⵎⵉ ⵖⴰ ⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⴷ ⵜⴻⵙⵙⴻⵖⴷⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏ ⵉⵡⴷⴰⵏ ⵉⴼⵖⴰⵍ ⵉ ⵡⴰⵔ ⵉⵙⵙⵉⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("P12_16","090_2_16","1PE","2","16","16","ⴰⵎ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵏⵉⵛⴰⵏ ⴷⵉ ⵜⵉⵍⴻⵍⵍⵉ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵉⵍⴻⵍⵍⵉ ⵏⵙⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵍⴻⵃⵃⴰⴼ ⵅ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⴰⵎ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P12_17","090_2_17","1PE","2","17","17","ⵡⴻⵇⵇⴰⵔⴻⵎ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ, ⵙⵄⵉⵣⵣⴻⵎ ⵜⴰⵡⵎⴰⵜ, ⴳⴳⵯⴻⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ, ⵛⴻⵏⵏⵄⴻⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P12_18","090_2_18","1PE","2","18","18","ⵊⵊⴻⵎ ⵉⵏⵏⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ ⴰⴷ ⵟⵟⴰⵄⴻⵏ ⵉ ⴰⵢⵜⴱⴰⴱ ⵏⵙⴻⵏ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵡⴰⵔ ⵉⴵⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵚⴻⴱⵃⴻⵏ ⵉⴹⴰⵔⴼⴻⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵉⵇⴻⵙⵃⴻⵏ ⴷ ⵢⴻⵡⵄⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P12_19","090_2_19","1PE","2","19","19","ⵎⵉⵏⵣⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵎ ⵉⵏⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵖⴰⵔ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴽⵙⵉⵏ ⵜⴰⵎⴰⵔⴰ ⵏⵏⵉ ⵡⴰⵔ ⵜⵜ ⵉⵙⴷⵉⵀⵉⴵⴻⵏ, ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵜⴻⵛⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("P12_20","090_2_20","1PE","2","20","20","ⵎⴰⵏ ⵛⵛⴰⵏ ⵉ ⴷⵉⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵜⴰⵎⴰⵔⴰ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵉⵄⴻⴷⴷⵉⵢⴻⵏ ⵏⵙⴻⵏ? ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴳⴳⵉⵎ ⵜⵛⵓⵏⵉ, ⴰⵎ ⴷⴰⵢⵡⴻⵎ ⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵙⴻⵎⵖⴰⵔ ⵛⵛⴰⵏ ⵏⵡⴻⵎ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P12_21","090_2_21","1PE","2","21","21","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ-ⴷⴷ ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵓⵎⵉ ⵉⵎⵎⵓⵜ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵖ ⵓⵛⴰ ⵉⵊⵊⴰ ⴰⵏⴻⵖ-ⴷⴷ ⵍⵎⵉⵜⴰⵍ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵓⵢⵓⵔ ⴷⵉ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ: ");
INSERT INTO rift_vpl VALUES ("P12_22","090_2_22","1PE","2","22","22","ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⴳⴳⵉ ⵛⴰ ⴷⴷⵏⵓⴱ ⵓ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵛⴰ ⵏ ⵍⵖⴻⵛⵛ, ");
INSERT INTO rift_vpl VALUES ("P12_23","090_2_23","1PE","2","23","23","ⵡⴻⵏⵏⵉ, ⵎⴰⵍⴰ ⵣⴰⵡⴰⵔⴻⵏ ⵜ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⴰⵡⴰⵍ, ⵓ ⵎⴰⵍⴰ ⵉⵡⴻⴷⴷⴻⴱ, ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴰⵔⵔⵉ ⵛⴰ ⴷⴷⴻⵏⴼ, ⵎⴰⵛⴰ ⵉⵜⵜⴰⵔⵔⴰ ⴷⴷⴻⵄⵡⴻⵜ ⵏⵏⴻⵙ ⵖⴰⵔ ⵍⵇⴰⴹⵉ ⵏ ⵜⵙⴻⴳⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("P12_24","090_2_24","1PE","2","24","24","ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉ-ⵜⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ ⵏⵏⴻⵙ ⵅ ⵚⵚⴰⵍⵉⴱ. ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵏⴻⵎⵎⵓⵜ ⵉ ⴷⴷⵏⵓⴱ, ⴰⴷ ⵏⴻⴷⴷⴰⵔ ⴷⵉ ⵜⵙⴻⴳⴷⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰⵎ ⵙ ⵉⵢⴻⵣⵣⵉⵎⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P12_25","090_2_25","1PE","2","25","25","ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜⵡⴻⴷⴷⴰⵔⴻⵎ ⴰⵎ ⵢⵉⵃⵓⵍⵉⵢⵢⴻⵏ, ⵍⴻⵅⵅⵓ ⵎⴰⵛⴰ ⵜⴷⴻⵡⵍⴻⵎ-ⴷⴷ ⵖⴰⵔ ⵓⵎⴻⴽⵙⴰⵡ ⴷ ⵓⵎⴻⵃⴹⴰⵢ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P13_1","090_3_1","1PE","3","1","1","ⴰⵎⵎⵓ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵏⵜ, ⴰ ⵜⵉⵎⵖⴰⵔⵉⵏ, ⵎⴰⵔⵙⴻⵏⵜ ⵉⵅⴻⴼ ⵏⴽⴻⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⴽⴻⵏⵜ ⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⵄⴻⵏ ⵉ ⵡⴰⵡⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⴻⴱⵃⴻⵏⵜ ⴱⵍⴰ ⴰⵔⴱⴰⵔ ⵙ ⵜⵉⵛⵍⵉ ⵏⴽⴻⵏⵜ ⵉⵛⵏⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("P13_2","090_3_2","1PE","3","2","2","ⵅ ⵎⵉⵏⵏⵉ ⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵜⵜⴻⴳⴳⵓⵔⴻⵏⵜ ⵙ ⵜⵉⴳⴳⵯⵓⴷⵉ ⴷ ⵍⴻⵀⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("P13_3","090_3_3","1PE","3","3","3","ⵡⴰⵔ ⵜⵜⵣⴻⵀⵀⵊⴻⵏⵜ ⵙ ⵎⵉⵏ ⵉⵜⵜⴱⴰⵏⴻⵏ ⵖⴰⵔ ⴱⴰⵔⵔⴰ: ⴰⵎⵓⴷⵉ ⵏ ⵓⵛⵓⵡⵡⴰⴼ, ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵡⵓⵔⴻⵖ ⵏⵉⵖ ⵜⵢⴰⵔⴹⵉ ⵏ ⵡⴰⵔⵔⵓⴹ ⵉⵚⴻⴱⵃⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("P13_4","090_3_4","1PE","3","4","4","ⵎⴰⵛⴰ ⵣⴻⵀⵀⵊⴻⵏⵜ ⵙ ⴱⵏⴰⴷⴻⵎ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⴷⴻⴳ ⵡⵓⵍ, ⵙ ⴰⵔⵔⵓⵃ ⵏ ⵜⴻⵎⵀⵉⵏⵜ ⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵖⴻⵛⵛⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵉⵊⵊ ⵏ ⵓⵣⴻⵀⵀⴻⵊ ⵉⵚⴻⴱⵃⴻⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P13_5","090_3_5","1PE","3","5","5","ⴰⵇⴰ ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵣⴻⵀⵀⵊⴻⵏⵜ ⵣⵉⵛ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵜⵉⵎⵇⴻⴷⴷⴰⵙⵉⵏ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵉⵜⵉⵎⴻⵏ ⵅ ⴰⵔⴻⴱⴱⵉ, ⵍⴻⵄⵎⵓⵔ ⵏⵙⴻⵏⵜ, ⵓⵛⴰ ⵜⵓⵖⴰ ⵟⵟⴰⵄⴻⵏⵜ ⵉ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("P13_6","090_3_6","1PE","3","6","6","ⴰⵎⵎⵓ ⵜⵓⵖⴰ ⵙⴰⵔⴰ ⵜᵉⵎⵎⴰⵔⵙ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵉ ⵉⴱⵔⴰⵀⵉⵎ, ⵜⵍⴰⵖⴰ ⴰⵙ: “ⵙⵉⴷⵉ!”, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵏⵜ ⵜⴷⴻⵡⵍⴻⵏⵜ ⴷ ⵢⴻⵙⵙⵉⵙ ⴰⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⵏⵜ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("P13_7","090_3_7","1PE","3","7","7","ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵔⵢⴰⵣⴻⵏ, ⵣⴻⴷⵖⴻⵎ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏⵡⴻⵎ ⵙ ⵍⴻⵄⵇⴻⵍ ⵓ ⵡⴻⵇⵇⴰⵔⴻⵎ ⵜⴻⵏⵜ ⴰⵎ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵢⴰⵔⴻⵅⴼⴻⵏ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⴰⵎⴻⵏⵄⴻⵏⵜ ⵛⴰ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵏⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⴻⵏⵜⵉ ⴰⴷ ⵡⴰⵔⵜⴻⵏⵜ ⵜⵉⵎⴻⵡⵛⴰ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⴰⴽⵉⴷⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P13_8","090_3_8","1PE","3","8","8","ⵖⴰⵔ ⵓⵏⴻⴳⴳⴰⵔ, ⵎⵓⵏⴻⵎ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⴰⵔⵔⴰⵢ ⴷ ⵉⵊⵊⴻⵏ, ⵡⴻⴷⴷⴱⴻⵎ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵡⴻⴷⴷⴱⴻⵏ, ⵅⵙⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵜⴰⵢⵔⵉ, ⴰⵔⴻⵃⵎⴻⵎ, ⵉⵍⵉⵎ ⵜⴹⴰⵔⴼⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P13_9","090_3_9","1PE","3","9","9","ⵡⴰⵔ ⴷⴷ-ⵜⵜⴰⵔⵔⵉⵎ ⵅ ⵍⵖⴰⵔ ⵙ ⵍⵖⴰⵔ, ⵏⵉⵖ ⵜⵉⴽⴽⵡⵓⵔⴰ ⵙ ⵜⵉⴽⴽⵡⵓⵔⴰ, ⵎⴰⵛⴰ ⵙ ⵍⵄⴻⴽⵙ ⴱⴰⵔⴽⴻⵎ, ⵎⵉⵏⵣⵉ ⴽⴻⵏⵏⵉⵡ ⴰⵇⴰ ⵜᵉⵜⵜⵡⴰⵍⴰⵖⴰⵎ-ⴷⴷ ⵃⵉⵎⴰ ⴰⴷ ⵜⵡⴰⵔⵜⴻⵎ ⵍⴱⴰⵔⴰⴽⴰ. ");
INSERT INTO rift_vpl VALUES ("P13_10","090_3_10","1PE","3","10","10","ⵙ ⵓⵢⴰ, ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵅⵙⴻⵏ ⵜⵓⴷⴰⵔⵜ ⴷ ⵡⵓⵙⵙⴰⵏ ⵉⵛⵏⴰⵏ, ⴰⴷ ⵉⵃⴹⴰ ⵉⵍⴻⵙ ⵏⵏⴻⵙ ⵣⵉ ⵎⵉⵏ ⵡⴰⵔ ⵉⵃⵍⵉⵏ ⵓⵍⴰ ⴷ ⵉⵢⴻⵏⵛⵉⵛⴻⵏ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴰⵡⴰⵍ ⵉⵛⴻⵎⵎⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P13_11","090_3_11","1PE","3","11","11","ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⴳⴳⵯⴻⵊ ⵅ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ, ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⴰⴷ ⵢⴰⵔⵣⵓ ⵅ ⵍⴻⵀⵏⴰ ⵓⵛⴰ ⴰⴷ ⵜ ⵉⴹⴼⴰⵔ ⵙ ⵛⴹⴰⵔⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("P13_12","090_3_12","1PE","3","12","12","ⵎⵉⵏⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵙⵉⴷⵉ ⵅ ⵉⵎⵙⴻⴳⴳⴰⴷⴻⵏ, ⵓ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ ⵏⵏⴻⵙ ⴰⵇⴰ ⴰⵜⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙⴻⵏ ⵙⵍⴻⵏ, ⵎⴰⵛⴰ ⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⴰⵇⴰ-ⵜ ⴹⵉⴷⴷ ⵉ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("P13_13","090_3_13","1PE","3","13","13","ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⴳⴳ ⵍⵖⴰⵔ, ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⴹⴼⴰⵔⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ? ");
INSERT INTO rift_vpl VALUES ("P13_14","090_3_14","1PE","3","14","14","ⵎⴰⵍⴰ ⵜⵡⴻⴷⴷⴱⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵙⴻⴳⴷⴰ, ⴰⵇⴰ ⵙⵙⴻⵄⴷ ⵏⵡⴻⵎ. ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷⴻⵎ ⵣⴻⴳ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵉⴳⴳⵯⴻⴷⴻⵏ, ⵡⴰⵔ ⵜⵜⵏⴻⵅⵍⵉⵄⴻⵎ ⵛⴰ, ");
INSERT INTO rift_vpl VALUES ("P13_15","090_3_15","1PE","3","15","15","ⵎⴰⵛⴰ ⵇⴻⴷⴷⵙⴻⵎ ⵙⵉⴷⵉ, ⵍⵎⴰⵙⵉⵃ, ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ, ⵓ ⵉⵍⵉⵎ ⵍⴻⴱⴷⴰ ⵜⵡⴻⵊⴷⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⵔⵔⴻⵎ ⵙ ⵜⴻⵎⵀⵉⵏⵜ ⴷ ⵓⵡⴻⵇⵇⴰⵔ ⵅ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉ ⵖⴰ ⵉⵙⵙⴻⵇⵙⴰⵏ ⵅ ⵓⵙⵉⵜⴻⵎ ⵏ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("P13_16","090_3_16","1PE","3","16","16","ⵣⵉ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵉⵛⵏⴰⵏ, ⵃⵉⵎⴰ ⵉⵏⵏⵉ ⵅⴰⵡⴻⵎ ⵉⵄⴰⵡⴷⴻⵏ ⴰⵅⵎⵉ ⵅ ⵉⵡⴷⴰⵏ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴰⴷ ⵙⴻⴹⵃⴰⵏ ⵓⵎⵉ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⵉ ⵜⴻⵛⵔⵉ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏⵡⴻⵎ ⵉⵛⵏⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P13_17","090_3_17","1PE","3","17","17","ⴰⵇⴰ ⵉⵏⴻⴼⴼⴻⵄ ⴰⴷ ⵜⵡⴻⴷⴷⴱⴻⵎ, ⵎⴰⵍⴰ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⴵⵉ ⵎⴰⵍⴰ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷ ⴰⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("P13_18","090_3_18","1PE","3","18","18","ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⵜⵓⵖⴰ ⵉⵎⵎⵓⵜ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵉ ⴷⴷⵏⵓⴱ, ⴰⵇⴰ ⴰⵎⵙⴻⴳⴳⴰⴷ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵉⵎⴻⴷⵏⴰⴱ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵉⵡⴻⴹ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⵏⴻⵜⵜⴰ ⴷ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵉⴷⴷⴰⵔ ⴷⵉ ⴰⵔⵔⵓⵃ, ");
INSERT INTO rift_vpl VALUES ("P13_19","090_3_19","1PE","3","19","19","ⴷ ⵡⴻⵏⵏⵉ ⵉⴱⴰⵔⵔⵃⴻⵏ ⵉ ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⴷⵉ ⵍⴰⵅⴰⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("P13_20","090_3_20","1PE","3","20","20","ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⵙⵇⴻⵏⵄⴻⵏ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⵓⵃ, ⵓⵎⵉ ⵜⵓⵎⵓⵔ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⴰⴷ ⴷⵉⵏ ⵢⵉⵍⵉ ⵓⵖⴰⵔⵔⴰⴱⵓ ⴰⵎ ⵜⵓⵖⴰ ⵉⵜⵜⵔⴰⵊⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⵓⴱⴻⵏ ⵏⵉⵜⵏⵉ. ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⵓⵖⴰⵔⵔⴰⴱⵓ ⵎⵖⵉⵔ ⵜⵎⴻⵏⵢⴰ ⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴹⴰⵏ ⴷⴷⴰⵔⴻⵏ ⴷⴻⴳ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("P13_21","090_3_21","1PE","3","21","21","ⵄⵍⴰⵃⵙⴰⴱ ⴰⵎⴻⴷⵢⴰ ⵏⵏⵉ, ⴰⵇⴰ ⵓⵍⴰ ⴷ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵡⴰⵙⵙⵏⴻⵊⵎⴻⵎ ⵙ ⵓⵙⴻⵖⴹⴻⵚ - ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⴰⵙⵉⵔⴷ ⵏ ⵍⴻⵅⵎⴻⵊ ⵏ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⵎⴰⵍⴰ ⵜⵛⴻⵀⵀⴷⴻⵎ ⵅ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵏⴻⴼⵙⴻⵛⵜ ⵉⵛⵏⴰⵏ - ⵓ ⵙ ⵜⵏⵓⴽⵔⴰ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("P13_22","090_3_22","1PE","3","22","22","ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵓⵄⵍⴰⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵉⵇⵇⵉⵎ ⵖⴰⵔ ⵓⴼⵓⵙⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⴷ ⴰⵙ ⵜⵜⵡⴰⵎⵎⴰⵔⵙⴻⵏⵜ ⵍⵎⴰⵍⴰⴽⴰⵜ ⴷ ⵚⵚⵓⵍⴰⵟⴰⵜ ⴷ ⵊⵊⴻⵀⴷ ⵙⴰⴷⵓ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("P14_1","090_4_1","1PE","4","1","1","ⵍⴰⵎⵉ ⵅⴰⵡⴻⵎ ⵉⴽⵙⵉ ⵍⵎⴰⵙⵉⵃ ⴰⵔⵎⴻⵃ ⴷⵉ ⴷⴷⴰⵜ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴰⴷ ⵜᵉⵟⵟⴼⴻⵎ ⴷⴻⴳ ⵓⵅⴰⵔⵔⴰⵚ-ⴰ: ⴰⵇⴰ ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵡⴰⵏⵉⵜⴰ ⴰⵇⴰ ⵉⵙⵙⴱⴻⴷⴷ ⴷⴷⴻⵏⴱ. ");
INSERT INTO rift_vpl VALUES ("P14_2","090_4_2","1PE","4","2","2","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵏⵉⵜⴰ ⵡⴰⵔ ⵉⴷⴷⴰⵔ ⵄⴰⴷ ⵄⵍⴰⵃⵚⴰⴱ ⵏⵏⴻⵛⵡⴰⵜ ⵏ ⴱⵏⴰⴷⴻⵎ ⴰⵎ ⵜ ⵉⴳⴳⴰ ⵇⴱⴻⵍ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ, ⵎⴰⵛⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P14_3","090_4_3","1PE","4","3","3","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵛⴼⴰ ⴰⵡⴻⵎ ⵍⵡⴻⵇⵜ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵄⴻⴱⴱⴷⴻⵎ ⵉ ⵎⵉⵏ ⵅⵙⴻⵏ ⵍⴽⵓⴼⴼⴰⵔ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⵓⵖⴰ ⵜⴻⴳⴳⵓⵔⴻⵎ ⴷⴻⴳ ⵓⴼⵓⵛⵛⴻⵃ, ⵙⵙⴻⴽⵔⴰⵏ, ⵍⴻⴼⵙⴰⴷ ⴷ ⴼⵉⵛⵜⴰⵜ ⵏ ⵓⵖⴻⵍⵍⵉ ⵓ ⴷⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵙⵡⴰⴷⴷⴰⵢ ⵙⵡⴰⴷⴷⴰⵢ ⵏ ⵛⵛⵡⴰⵟⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P14_4","090_4_4","1PE","4","4","4","ⵓ ⵅⵣⴰⵔ, ⵍⴻⵅⵅⵓ ⵜⵜⴱⴻⵀⵜⴻⵏ ⵏⵉⵜⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵣⵣⵍⴻⵎ ⵄⴰⴷ ⴰⴽⵉⴷⵙⴻⵏ ⴷⴻⴳ ⵡⴻⵣⵇⴰⵇ ⵏ ⵍⴻⵇⵊⴰⵃⴻⵜ ⴷ ⵉⵊⵊⴻⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P14_5","090_4_5","1PE","4","5","5","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵔⵔⴻⵏ ⵍⴻⵃⵙⴰⴱ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ ⵅ ⵢⵉⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓ ⵅ ⵢⵉⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P14_6","090_4_6","1PE","4","6","6","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⴱⴰⵔⵔⴻⵃ ⵄⴰⵡⴻⴷ ⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ, ⵃⵉⵎⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵜⵜⵡⴰⵃⴰⵙⴱⴻⵏ ⴰⵎ ⵜⴰⵔⵡⴰ ⵏ ⴱⵏⴰⴷⴻⵎ ⵣⵉ ⵊⵊⵉⵀⴻⵜ ⵏ ⴷⴷⴰⵜ, ⵎⴰⵛⴰ ⴰⴷ ⴷⴷⴰⵔⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("P14_7","090_4_7","1PE","4","7","7","ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵎⴰⵔⵔⴰ ⴰⵇⴰ ⵢⵓⴷⴻⵙ-ⴷⴷ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵍⵉⵎ ⵙ ⵍⴻⵄⵇⴻⵍ, ⵔⴻⴽⴽⵣⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵅⵎⵉ ⵜⴻⵥⵥⴰⴵⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("P14_8","090_4_8","1PE","4","8","8","ⵙⴻⵏⵏⴻⵊ ⵉ ⵎⴰⵔⵔⴰ, ⵅⵙⴻⵎ ⴰⵢⴰⵡⵢⴰ ⴱⵍⴰ ⵇⴻⵟⵟⵓ, ⵎⵉⵏⵣⵉ ⵜⴰⵢⵔⵉ ⵜⴻⵙⵙⴷⵓⵔⵔⵓⵢ ⵅ ⵓⴱⴰⵔⵔⵓ ⵏ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("P14_9","090_4_9","1PE","4","9","9","ⴰⵔⴻⵃⵃⴱⴻⵎ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ ⴱⵍⴰ ⵍⴻⵄⴽⴰⵙⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("P14_10","090_4_10","1PE","4","10","10","ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⵙⴻⵅⵅⴰⵔ ⵉⵏⵏⵉ ⴷ ⴰⵙ ⵢⵓⴷⵙⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⵡⴻⴽⴽⵍⴻⵏ ⵎⵍⵉⵃ ⵅ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P14_11","090_4_11","1PE","4","11","11","ⴻⵊⵊ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⴰⴷ ⵉⵙⵙⵉⵡⴻⵍ ⵄⵍⴰⵃⵙⴰⴱ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵓ ⴻⵊⵊ ⴽⵓⵍ ⵉⵊⵊ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵙⴻⵅⵅⴰⵔⴻⵏ, ⵉⵜⵜⵙⴻⵅⵅⴰⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵊⵊⴻⵀⴷ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⵎ ⴰⴷ ⵉⴷⵡⴻⵍ ⵓⵙⴻⵎⵖⴰⵔ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("P14_12","090_4_12","1PE","4","12","12","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ, ⵡⴰⵔ ⴷⴻⵀⵀⵛⴻⵎ ⵛⴰ ⵣⴻⴳ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵊⴰⵔⵔⵉⴱⴻⵏ ⵉ ⵅⴰⵡⴻⵎ ⵉ ⴷⴷ ⵖⴰ ⵉⴽⴽⵉⵏ, ⴰⵅⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵍⵇⴻⴼ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴷ ⵜⴰⵖⵔⵉⴱⵜ, ⵎⴰⵖⴰⵔ ⵎⴰⵏ ⴰⵢⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵜⵜⵡⴰⵇⴻⴵⴱⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P14_13","090_4_13","1PE","4","13","13","ⵎⴰⵛⴰ ⴼⴰⵔⵃⴻⵎ ⵓⵎⵉ ⵜⵛⴰⵔⵛⴻⵎ ⴷⴻⴳ ⵓⵡⴻⴷⴷⴻⴱ ⵉ ⵉⴽⴽⵉⵏ ⵅ ⵍⵎⴰⵙⵉⵃ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴼⴰⵔⵃⴻⵎ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵄⴰⵡⴻⴷ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴹⵀⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P14_14","090_4_14","1PE","4","14","14","ⵎⴰⵍⴰ ⵄⴻⵢⵢⴱⴻⵏ ⴽⴻⵏⵏⵉⵡ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵙⵙⴻⵄⴷ ⵏⵡⴻⵎ ⵎⵉⵏⵣⵉ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵅⴰⵡⴻⵎ ⵢⴰⵔⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("P14_15","090_4_15","1PE","4","15","15","ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⵃⴻⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴰⴷ ⵉⵡⴻⴷⴷⴻⴱ ⴰⵎ ⵓⵇⴻⵜⵜⴰⵍ ⵏⵉⵖ ⴰⵎ ⵓⵛⴻⴼⴼⴰⵔ ⵏⵉⵖ ⴰⵎ ⵓⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("P14_16","090_4_16","1PE","4","16","16","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵉⵡⴻⴷⴷⴻⴱ ⵃⴻⴷ ⴰⵎ ⵓⵎⴰⵙⵉⵃⵉ, ⵡⴰⵔ ⵉⵜⵜⵙⴻⴹⵃⵉ ⵛⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵉⴽⴽⴰⵔ ⴰⴷ ⵉⵙⵙⵓⵄⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("P14_17","090_4_17","1PE","4","17","17","ⵎⴰⵖⴰⵔ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵍⵡⴻⵇⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⴱⴷⴰ ⵍⵃⵓⴽⵎ ⵖⴰⵔ ⵜⴰⴷⴷⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵍⵃⵓⴽⵎ ⵣⵣⴰⵢⵏⴻⵖ ⵉ ⵖⴰ ⵉⵙⵙⵉⵣⵡⴰⵔ, ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⵉⵍⵉ ⵓⵏⴻⴳⴳⴰⵔⵓ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵟⵟⵉⵄⴻⵏ ⵛⴰ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ? ");
INSERT INTO rift_vpl VALUES ("P14_18","090_4_18","1PE","4","18","18","ⵓⵛⴰ ⵎⴰⵍⴰ ⴰⵎⵙⴻⴳⴳⴰⴷ ⵢⵉⵡⴻⴹ ⴰⴷ ⵉⵟⵟⴻⴼ ⵜⵓⴷⴰⵔⵜ ⵙ ⵍⵡⴻⵃⵍⴰⵏ, ⵎⴰⵏⵉ ⵄⴰⴷ ⵉ ⴷⴷ ⵖⴰ ⵉⴹⵀⴰⵔ ⵓⴽⴰⴼⵔⵉⵡ ⴷ ⵓⵎⴻⴷⵏⵓⴱ? ");
INSERT INTO rift_vpl VALUES ("P14_19","090_4_19","1PE","4","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴻⴷⴷⴰⴱⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⴻⵊⵊ ⵉ-ⵜⴻⵏ ⴰⴷ ⴰⵙ ⵙⴻⵍⵍⵎⴻⵏ ⵍⴻⵄⵎⵓⵔ ⵏⵙⴻⵏ ⴰⵎ ⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴽⵓⵍⵛⵉ, ⵡⴻⵏⵏⵉ ⴷⵉ ⵉⴵⴰ ⵍⴰⵎⴰⵏ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵚⴻⴱⵃⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P15_1","090_5_1","1PE","5","1","1","ⵜⵜⵣⴰⵡⴳⴻⵖ ⵉⵏⵏⵉ ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵏ, ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵖⴰⵔ ⴰⴽⵉⴷⵡⴻⵎ ⴷ ⴰⵛⴻⵀⵀⴰⴷ ⵏ ⵓⵡⴻⴷⴷⴻⴱ ⵉ ⵉⴽⴽⵉⵏ ⵅ ⵍⵎⴰⵙⵉⵃ ⵓⵍⴰ ⴷ ⴰⵎⵄⴰⵛⴰⵔ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵉ ⴷⴷ ⵖⴰ ⵉⵜⵜⵡⴰⵙⵙⴻⴹⵀⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("P15_2","090_5_2","1PE","5","2","2","ⴰⵔⴻⵡⵙⴻⵎ ⵜⴰⵃⵉⵎⴰⵔⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵏⵏⵉ ⵜⵃⴻⵟⵟⴰⵎ, ⵡⴰⵔ ⵉⴵⵉ ⵙ ⵓⵖⵉⵍ ⵎⴰⵛⴰ ⵙ ⵍⵅⴰⴹⴰⵔ, ⵡⴰⵔ ⵉⴵⵉ ⴷⵉ ⵟⵟⵎⴻⵄ ⵏ ⴰⵔⴱⴻⵃ ⵡⴰⵔ ⵉⵃⵍⵉⵏ, ⵎⴰⵛⴰ ⵙ ⵎⴰⵔⵔⴰ ⵡⵓⵍ ⵏⵡⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("P15_3","090_5_3","1PE","5","3","3","ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵅ ⵜⵃⵉⵎⴰⵔⵜ, ⵎⴰⵛⴰ ⵓⵎⵉ ⵜⴻⴵⴰⵎ ⴷ ⵉⵊⵊ ⵏ ⵓⵎⴻⴷⵢⴰ ⵉⵛⵏⴰ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("P15_4","090_5_4","1PE","5","4","4","ⵓⵛⴰ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴹⵀⴰⵔ ⵓⵎⴻⴽⵙⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵟⵟⴼⴻⵎ ⵜⵜⴰⵊ ⵏ ⵓⵄⵓⴵⵉ ⵉ ⵡⴰⵔ ⵉⴼⴻⵏⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("P15_5","090_5_5","1PE","5","5","5","ⵓ ⴽⴻⵏⵏⵉⵡ, ⵉⴱⵍⵉⵖⴻⵏ, ⵙⴰⵔⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙⴰⴷⵓ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵡⴻⵎ, ⴱⴻⵢⵙⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙ ⵓⵡⴰⴹⴻⵄ ⵏ ⴰⵔⵔⵓⵃ ⵉⵊⵊ ⵉ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⵄⴻⴽⴽⴰⵙ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ, ⵎⴰⵛⴰ ⵉⵎⵡⴰⴹⵄⴻⵏ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴰⵔⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("P15_6","090_5_6","1PE","5","6","6","ⵙⴻⵎⵥⴰⵢⴻⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵙⴰⴷⵓ ⴰⴼⵓⵙ ⵉⵊⴻⵀⴷⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⵓⵄⵍⴰ ⴷⵉ ⵍⵡⴻⵇⵜ ⵏⵏⴻⵙ ⵏⵉⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("P15_7","090_5_7","1PE","5","7","7","ⵎⴰⵔⵔⴰ ⵉⵎⵏⵓⵙⴻⵏ ⵏⵡⴻⵎ ⴰⵔⵔⴻⵎ ⵜⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵀⵉⵍⵍⴰ ⴷⴰⵢⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P15_8","090_5_8","1PE","5","8","8","ⴰⵔⵔⴻⵎ-ⴷⴷ ⵍⴱⴰⵍ, ⵃⴹⴰⵎ, ⵎⵉⵏⵣⵉ ⵍⴻⵄⴷⵓ ⵏⵡⴻⵎ, ⵛⵛⵉⵟⴰⵏ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵜⵜⵣⴻⵀⵀⴰⵔ ⴰⵎ ⵡⴰⵢⵔⴰⴷ ⵓ ⵉⵜⵜⵃⴰⵎⴰ, ⵢⴰⵔⴻⵣⵣⵓ ⵎⵉⵏ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⴰⵔⴹ. ");
INSERT INTO rift_vpl VALUES ("P15_9","090_5_9","1PE","5","9","9","ⵎⵄⴰⵍⴰⵎ ⵜ, ⵜⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ ⴷⵉ ⵍ’ⵉⵎⴰⵏ, ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⴰⵢⵜⵎⴰⵜⵡⴻⵎ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵍⴰ ⴷ ⵏⵉⵜⵏⵉ ⴽⴻⵙⵙⵉⵏ ⴰⵡⴻⴷⴷⴻⴱ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("P15_10","090_5_10","1PE","5","10","10","ⵎⴰⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵏ ⴰⵔⴹⴰ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ, ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⵏⵡⴻⴷⴷⴻⴱ ⵍⴻⵃⵚⴰⵔⴰⵜ-ⴰ ⵜⵉⵎⵓⵇⵍⵉⵍⵉⵏ, ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⴻⵊⵀⴻⴷ, ⴰⴷ ⴰⵏⴻⵖ ⵉⴹⵎⴻⵏ ⵓ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⴻⴷⴷ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("P15_11","090_5_11","1PE","5","11","11","ⵖⴰⵔⴻⵙ ⵏⴻⵜⵜⴰ ⴰⵄⵓⴵⵉ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷ ⵍⵄⴻⵣⵣ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("P15_12","090_5_12","1PE","5","12","12","ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⴷⵉ ⵜⵉⵔⴰ ⵜⴰⵇⵓⴹⴰⴹⵜ ⵙ ⵓⴼⵓⵙ ⵏ ⵙⵉⵍⵡⴰⵏⵓⵙ, ⵓⵎⴰ ⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⵓ ⵏⴻⵛⵛ ⵇⴻⵏⵄⴻⵖ ⵓ ⵛⴻⵀⵀⴷⴻⵖ, ⴰⵇⴰ ⵎⴰⵏ ⴰⵢⴰ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵜⴱⴻⴷⴷⴻⵎ ⵏⵉⵛⴰⵏ, ⴰⵇⴰ-ⵜ ⴷ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("P15_13","090_5_13","1PE","5","13","13","ⵜⴰⵎⴻⵙⵎⵓⵏⵜ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⴱⴰⴱⵉⵍ, ⵜⵙⴻⴵⴰⵎ ⵅⴰⵡⴻⵎ ⵙ ⵍⴻⵀⵏⴰ, ⵓⵍⴰ ⴷ ⵎⵎⵉ ⵎⴰⵔⴽⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("P15_14","090_5_14","1PE","5","14","14","ⵙⴻⴵⵎⴻⵎ ⵅ ⵡⴰⵢⴰⵡⵢⴰ ⵙ ⵍⴻⵀⵏⴰ ⵓ ⵙ ⵓⵙⵓⴷⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ. ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵢⵉⵍⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵡⴻⵎ ⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵎⴰⵙⵉⵃ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("P21_1","091_1_1","2PE","1","1","1","ⵛⵉⵎⵄⵓⵏ ⴱⵓⵟⵔⵓⵙ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⴷ ⵔⵔⴰⵙⵓⵍ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵉ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴰⵎ ⵏⴻⵛⵛⵉⵏ ⵙⵙⴷⴰⵀⴻⴵⴻⵏ ⵍ’ⵉⵎⴰⵏ ⵙ ⵜⵙⴻⴳⴷⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⵓⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵄⵍⴰⵃⵙⴰⴱ ⵛⵛⴰⵏ ⴷ ⵉⵊⵊⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("P21_2","091_1_2","2PE","1","2","2","ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵎⵎⴰⵔⴻⵏⵢⴻⵏ ⵅⵎⵉ ⵉ ⵖⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("P21_3","091_1_3","2PE","1","3","3","ⴰⵎ ⵡⴻⵏⵏⵉ ⵉⵡⵛⵉⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵡⵉ ⵜⵓⴷⴰⵔⵜ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⴷⴷ-ⵉⵍⴰⵖⴰⵏ ⵖⴰⵔ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⴷ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("P21_4","091_1_4","2PE","1","4","4","ⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵡⴻⵎ ⵍⵡⵓⵄⵓⴷ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵛⴰⵔⵛⴻⵎ ⴷⵉ ⵟⵟⴱⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵜᵉⵜⵜⵔⴰⴽⴽⵯⴰⵔⴻⵎ ⵣⵉ ⵏⵏⴻⵛⵡⴰⵜ ⵉⵖⴻⵛⵛⴻⵏ ⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("P21_5","091_1_5","2PE","1","5","5","ⴰⵎ ⵜⴻⴵⴰ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴰⵎⵎⵓ, ⴰⵔⵏⵉⵎ ⵙ ⵎⴰⵔⵔⴰ ⵛⴹⴰⵔⴻⵜ ⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⵜⵛⵓⵏⵉ ⵉⴼⴻⵢⵢⴹⴻⵏ, ⵉ ⵜⵛⵓⵏⵉ ⵏⵡⴻⵎ ⵉⴼⴻⵢⵢⴹⴻⵏ ⵜⵓⵙⵙⵏⴰ, ");
INSERT INTO rift_vpl VALUES ("P21_6","091_1_6","2PE","1","6","6","ⵉ ⵜⵓⵙⵙⵏⴰ ⵍⴻⵡⵄⴰⵔⴻⵜ, ⵉ ⵍⴻⵡⵄⴰⵔⴻⵜ ⵚⵚⴱⴰⵔ, ⵉ ⵚⵚⴱⴰⵔ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("P21_7","091_1_7","2PE","1","7","7","ⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵢⵔⵉ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵓ ⵉ ⵜⴰⵢⵔⵉ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("P21_8","091_1_8","2PE","1","8","8","ⵎⴰⵍⴰ ⵜⵜⵡⴰⴼⴻⵏⵜ ⴷⴰⵢⵡⴻⵎ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⵓⵛⴰ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⴼⴻⵢⵢⴹⴻⵏⵜ, ⵡⴰⵔ ⴽⴻⵏⵏⵉⵡ ⵜⵜⴻⵊⵊⵉⵏⵜ ⵜⴻⵅⵡⴰⵎ ⵏⵉⵖ ⴱⵍⴰ ⵍⵖⵉⴵⴻⵜ ⴷⵉ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P21_9","091_1_9","2PE","1","9","9","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⴵⵉⵏⵜ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⴰⵇⴰ ⵉⴷⴷⴰⵔⵖⴻⵍ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ ⵉⵍⵍⴰ ⵉⵜⵜⵓ ⴰⵙⵉⵣⴷⴻⴳ ⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("P21_10","091_1_10","2PE","1","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⴰⵢⵜⵎⴰ, ⵛⴹⴰⵔⴻⵎ ⴽⵜⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜⴹⴻⵎⵏⴻⵎ ⵜⴰⵍⴰⵖⵉⵜ ⴷ ⵓⵙⵉⵅⴹⴰⵔ ⵏⵡⴻⵎ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵚⴻⴱⵃⴰⵏⵉⵏ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵜⴻⴳⴳⴻⵎ ⴰⵢⴰ, ⵅⴻⵏⵏⵉ ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⵜⴻⵏⵇⴰⵔⴹⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P21_11","091_1_11","2PE","1","11","11","ⵎⵉⵏⵣⵉ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⵉⵎⵎⴰⵔⵏⵉ ⵙ ⵡⴰⵟⵟⴰⵙ ⵡⴰⴷⴰⴼ ⵉⵛⵏⴰⵏ ⵖⴰⵔ ⵜⴳⴻⵍⴷⵉⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⵓⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P21_12","091_1_12","2PE","1","12","12","ⵙ ⵓⵢⴻⵏⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵄⴻⵇⵍⴻⵖ ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵍⴻⴱⴷⴰ, ⵡⴰⵅⵅⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵓ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴱⴻⴷⴷⴻⵎ ⵅ ⴷⵙⴰⵙ ⵏ ⵜⵉⴷⴻⵜⵜ ⵜⴰⵏⵉⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("P21_13","091_1_13","2PE","1","13","13","ⵎⴰⵛⴰ ⵉⵜⵜⵖⵉⵍ ⴰⵢⵉ ⵏⵉⵛⴰⵏ ⵎⵉⵏ ⵖⴰ ⴽⴽⴻⵖ ⵄⴰⴷ ⴷⵉ ⴰⵔⵔⵉⵎⴻⵜ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⴼⴰⵇⴻⵖ ⴰⵎ ⵙⵙⵄⴻⵇⵍⴻⵖ ⴽⴻⵏⵏⵉⵡ, ");
INSERT INTO rift_vpl VALUES ("P21_14","091_1_14","2PE","1","14","14","ⵎⵉⵏⵣⵉ ⵙⵙⵏⴻⵖ ⴰⵇⴰ ⵜⴰⴽⴻⵙⵙⵉⵜ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵓ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⴷⴻⵖⵢⴰ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵢⵉ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("P21_15","091_1_15","2PE","1","15","15","ⵎⴰⵛⴰ ⴰⴷ ⴳⴳⴻⵖ ⵜⵉⵣⴻⵎⵎⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵄⴻⵇⵍⴻⵎ ⵅ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⵡⴰⵔⵏⵉ ⵓⴼⴼⵓⵖ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("P21_16","091_1_16","2PE","1","16","16","ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⵏⴻⴹⴼⴰⵔ ⵛⴰ ⵜⵉⵃⵓⵊⴰ ⵉⵙⴰⵢⵙⴻⵏ, ⵓⵎⵉ ⵜⵓⵖⴰ ⴷ ⴰⵡⴻⵎ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⵊⵊⴻⵀⴷ ⴷ ⵜⵡⴰⵙⵉⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⴰⵛⴰ ⴰⵇⴰ ⵏⴻⵛⵀⴻⴷ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ ⵅ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P21_17","091_1_17","2PE","1","17","17","ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴰⵇⴰ ⵉⵟⵟⴻⴼ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴱⴰⴱⴰⵙ ⵛⵛⴰⵏ ⴷ ⵓⵄⵓⴵⵉ ⵓⵎⵉ ⴷ ⴰⵙ ⴷⴷ-ⵜⵓⵙⴰ ⵜⵎⵉⵊⵊⴰ-ⵢⴰ ⵣⴻⴳ ⵓⵄⵓⴵⵉ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵍⵄⴰⴹⴰⵎⴰ ⵏⵏⴻⵙ: “ⵡⴰ ⴷ ⵎⵎⵉ ⵉⵏⵓ ⵉⵄⵉⵣⵣⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵓⴼⵉⵖ ⴰⵔⴹⴰ ⵉⵏⵓ.” ");
INSERT INTO rift_vpl VALUES ("P21_18","091_1_18","2PE","1","18","18","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵍⴰ ⵜⵎⵉⵊⵊⴰ-ⵢⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⴰⴽⵉⴷⴻⵙ, ⵍⴰⵎⵉ ⵏⴻⴵⴰ ⴰⴽⵉⴷⴻⵙ ⵅ ⵡⴻⴷⵔⴰⵔ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P21_19","091_1_19","2PE","1","19","19","ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵖⴰⵔⵏⴻⵖ ⴰⵡⴰⵍ ⴷ ⵜⵉⴷⴻⵜⵜ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⴳⴳⴻⵎ ⵎⵍⵉⵃ ⵎⴰⵍⴰ ⵜⴻⵡⵛⵉⵎ ⵜⴰⵢⵏⵉⵜ ⵉ ⵡⴰⵡⴰⵍ ⵏⵏⵉ ⴰⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⴻⴼⵏⴰⵔ ⵢⴰⵔⴻⵇⵇⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⵎⵛⴰⵏ ⵉⴱⴱⵓⴱⴱⴻⵙ, ⴰⵍ ⵖⴰ ⵉⴷⴷⵓⵇⵇⴻⵣ ⵡⴰⵙⵙ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏⵇⴰⵔ ⵜⴼⵓⵛⵜ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("P21_20","091_1_20","2PE","1","20","20","ⴰⵎⴻⵣⵡⴰⵔ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵇⴰ ⵡⴰⵔ ⴷⵉⵏ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵏⵏⵓⴱⵓⵡⴰ ⵜᵉⵏⵏⵓⴼⵙⴻⵍ ⵅ ⵜⵉⵔⴰ ⵏⵏⴻⵙ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P21_21","091_1_21","2PE","1","21","21","ⵎⵉⵏⵣⵉ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⴰⴱⴱⴻⵏ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵉⵖ ⵄⴻⵎⵎⴰⵔⵚ ⵣⵉ ⵎⵉⵏ ⵉⵅⵙ ⴱⵏⴰⴷⴻⵎ, ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵉⵙⵙⵉⵡⵍⴻⵏ ⴰⵎ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵏⴷⴻⵀ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_1","091_2_1","2PE","2","1","1","ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵊⴰⵔ ⵍⴳⴻⵏⵙ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵍⵉⵏ ⵓⵍⴰ ⴷ ⵉⵎⴻⵙⵖⴰⵔⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵊⴰⵔ ⴰⵡⴻⵎ, ⴰⴷ ⵙⵙⵉⴷⴼⴻⵏ ⵜⵉⴱⵔⵉⴷⵉⵏ ⵉⵜⵜⴰⵔⴻⴷⴷⴵⴻⵏ, ⴰⴷ ⵏⴽⴰⵔⴻⵏ ⵙⵉⴷⵉ ⵉ ⵜⴻⵏ ⵉⵙⵖⵉⵏ, ⴰⴷ ⵙⵙⵉⵡⴹⴻⵏ ⴰⵎⵎⵓ ⴰⵔⴻⵢⵢⴻⴱ ⴷⴻⵖⵢⴰ ⵅ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_2","091_2_2","2PE","2","2","2","ⴰⵟⵟⴰⵙ ⵉ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ ⵜⴰⵅⵎⵓⵊⵉ ⵏⵙⴻⵏ ⴰⵍ ⵖⴰ ⵉⵜⵜⵡⴰⵛⴻⵇⵇⴻⴼ ⵡⴻⴱⵔⵉⴷ ⵏ ⵜⵉⴷⴻⵜⵜ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_3","091_2_3","2PE","2","3","3","ⵙ ⵟⵟⵎⴻⵄ ⵓ ⵙ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵜⵜⵡⴰⴳⴳⴻⵏ ⴰⴷ ⵣⵣⴰⵢⵡⴻⵎ ⴳⴳⴻⵏ ⴰⵎ ⵣⵉ ⵙⵙⴻⵍⵄⴻⵜ, ⵎⴰⵛⴰ ⵍⵃⵓⴽⵎ ⵅⴰⵙⴻⵏ ⵣⴻⴳ ⵡⴻⵛⵃⴰⵍ ⵓⵢⴰ ⵡⴰⵔ ⵉⴱⴹⵉⵍ ⵛⴰ ⵓⵛⴰ ⴰⵀⴻⵍⵍⴻⴽ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵏⵓⴷⵓⵎ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("P22_4","091_2_4","2PE","2","4","4","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⵉⵙⵙⴰⵔ ⵅ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉ ⵢⴻⴳⴳⵉⵏ ⴷⴷⵏⵓⴱ, ⵎⴰⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜⴻⵏ ⴷⵉ ⵙⵙⵏⴰⵙⴻⵍ ⵏ ⵜⴰⴵⴻⵙⵜ ⴷⵉ ⵍⴰⴵⴰⵖ ⵢⵓⴵⵖⴻⵏ ⵓⵛⴰ ⵉⵙⴻⵍⵍⴻⵎ ⵉ-ⵜⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵅⴻⵎⵎⵍⴻⵏ ⴰⵍ ⵍⵃⵓⴽⵎ ⵏ ⵓⵄⴻⴷⴷⴻⴱ, ");
INSERT INTO rift_vpl VALUES ("P22_5","091_2_5","2PE","2","5","5","ⵓ ⵄⴰⵡⴻⴷ ⵡⴰⵔ ⵉⵙⵙⴰⵔ ⵅ ⴷⴷⵓⵏⴻⵛⵜ ⵏ ⵣⵉⵛ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵉⵃⴹⴰ ⵏⵓⵃ, ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⴰⵎⴱⴰⵔⵔⴻⵃ ⵏ ⵜⵙⴻⴳⴷⴰ, ⵍⴰⵎⵉ ⴷⴷ-ⵉⴹⵍⴻⵇ ⵍⵃⴻⵎⵍⴻⵜ ⵅ ⴷⴷⵓⵏⴻⵛⵜ ⵏ ⵍⴽⵓⴼⴼⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("P22_6","091_2_6","2PE","2","6","6","ⵓ ⵄⴰⵡⴻⴷ ⵍⴰⵎⵉ ⵉⵙⵙⴻⵛⵎⴻⴹ ⵏⴻⵜⵜⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⵓ ⵉⵃⴽⴻⵎ ⵅⴰⵙⴻⵏⵜ ⵙ ⵓⵏⴻⵇⵍⴻⴱ, ⴰⵇⴰ ⵢⴰⵔⵔⴰ ⵉ-ⵜⴻⵏⵜ ⴷ ⵍⵎⵉⵜⴰⵍ ⵉ ⵍⴽⵓⴼⴼⴰⵔ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("P22_7","091_2_7","2PE","2","7","7","ⵄⴰⵡⴻⴷ ⵉⵙⵙⴻⵏⵊⴻⵎ ⵏⴻⵜⵜⴰ ⵍⵓⵜ, ⴰⵎⵙⴻⴳⴳⴰⴷ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴻⴷⴷⴱⴻⵏ ⴰⵟⵟⴰⵙ ⵣⵉ ⵜⵉⵛⵍⵉ ⵉⵅⴻⵎⵊⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵜⴻⴵⵉ ⵛⵛⴰⵔⵉⵄⴰ. ");
INSERT INTO rift_vpl VALUES ("P22_8","091_2_8","2PE","2","8","8","ⵎⴰⵖⴰⵔ ⵓⵎⵉ ⴰⵎⵙⴻⴳⴳⴻⴷ ⵡⴰⵏⵉⵜⴰ ⵉⵥⵔⴰ ⴷ ⵉⵙⵍⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏⵙⴻⵏ ⵉ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉⵏ ⴰⴽ-ⴷ ⵛⵛⴰⵔⵉⵄⴰ, ⵉⵜⵜⵡⴰⵄⴻⴷⴷⴰⴱ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵙ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵣⴻⴳ ⵡⴰⵙⵙ ⴰⵍ ⵡⴰⵙⵙ, ⴰⵎ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⴻⵖ ⵊⴰⵔ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_9","091_2_9","2PE","2","9","9","ⴰⵎⵎⵓ ⵉ ⵉⵙⵙⴻⵏ ⵙⵉⴷⵉ ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉⵏⵏⵉ ⵜ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵣⵉ ⵍⵎⴻⵃⵏⴻⵜ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵃⴻⵟⵟⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴻⴷⴷⴱⴻⵏ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ, ");
INSERT INTO rift_vpl VALUES ("P22_10","091_2_10","2PE","2","10","10","ⵎⴰⵀⵓ ⵇⴰⵄ ⵉⵏⵏⵉ ⵉⴹⴼⴰⵔⴻⵏ ⴷⴷⴰⵜ ⵏⵙⴻⵏ ⴰⵎ ⵜⵜⵎⴻⵥⵥⵔⴻⵏ ⴷⵉ ⵎⵉⵏ ⵉⵅⴻⵎⵊⴻⵏ, ⵓ ⵙⴻⵃⵇⴰⵔⵔⴰⵏ ⵚⵚⵓⵍⵟⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ. ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⵄⴻⴼⴼⴰⵔⴻⵏ ⴷ ⵉⵎⵏⴻⴼⴼⵅⴻⵏ, ⵡⴰⵔ ⵜⵜⴰⵔⵊⵉⵊⵉⵏ ⵣⵣⴰⵜ ⵎⵉⵏ ⵉⵄⵓⴵⴻⵏ ⴰⵎ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_11","091_2_11","2PE","2","11","11","ⵡⴰⵅⵅⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵓⵊⴰⵔⴻⵏⵜ ⵜⴻⵏ ⴷⵉ ⵚⵚⵓⵍⵟⴰ ⴷ ⵊⵊⴻⵀⴷ, ⵡⴰⵔ ⵅⴰⵙⴻⵏ ⵙⵙⵉⵡⵉⴹⴻⵏⵜ ⵍⵃⵓⴽⵎ ⵏ ⵙⵉⴷⵉ ⴷⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵓⵛⴻⵇⵇⴰⴼ. ");
INSERT INTO rift_vpl VALUES ("P22_12","091_2_12","2PE","2","12","12","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙ ⵍⵄⴻⴽⵙ ⴵⴰⵏ ⴰⵎ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⴳⵏⴰⵡⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵟⵟⴱⵉⵄⴻⵜ, ⵉⵏⵏⵉ ⵢⵓⵔⴰⵏ ⵉ ⵜⵖⴰⵔⵚⵜ ⵙ ⵍⵎⵓⵙ ⴷ ⵜⴰⵊⴻⵢⵢⴰⴼⵜ ⴰⵎ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⵉ ⵎⵉⵏ ⴷⵉ ⵡⴰⵔ ⴼⴻⵀⵀⵎⴻⵏ. ⴰⴷ ⵜⵜⵡⴰⵊⴻⵢⵢⴼⴻⵏ ⴷⵉ ⵜⵊⴻⵢⵢⴰⴼⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("P22_13","091_2_13","2PE","2","13","13","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵅ ⵜⴻⴵⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⴷ ⵍⵎⵓⵏⴻⵜ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ⵏⵉⵜⵏⵉ ⵃⴻⵙⴱⴻⵏ ⵜⴰⵡⴰⵔⵔⵉⵜ ⵏ ⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵏⵏⴻⵛⵡⴰⵜ ⵙ ⵓⵣⵉⵍ ⴷ ⴰⴱⴰⵔⵔⴻⵄ ⴰⵎ ⵛⵛⵓⵔⴻⵏ ⵏⵉⵜⵏⵉ ⵙ ⵉⴱⴻⵇⵇⵉⴹⴻⵏ ⵏ ⵍⴻⵡⵙⴻⵅ. ⵅⵎⵉ ⵜⵜⴰⵔⵔⴰⵏ ⵏⵏⵉⵜⵏⵉ ⵎⴻⵥⵔⵉ ⴷⴻⴳ ⵓⵔⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵏ ⵓⵖⴻⴱⴱⵉ, ⵙⴻⵍⵍⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⵡⴰⵔⵔⵉⵜ ⵏ ⵎⴻⵥⵔⵉ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("P22_14","091_2_14","2PE","2","14","14","ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵣⵣⵉⵏⴰ ⵓ ⵙ ⴷⴷⴻⵏⴱ ⵡⴰⵔ ⵉⵇⴻⵟⵟⵉⵏ, ⵅⵎⵉ ⵖⴻⴽⴽⵡⴰⵏ ⵏⵉⵜⵏⵉ ⵍⴻⵄⵎⵓⵔ ⵏ ⵢⵉⵏⵏⵉ ⵡⴰⵔ ⵉⴱⴻⴷⴷⴻⵏ ⵏⵉⵛⴰⵏ. ⴰⵇⴰ ⵖⴰⵔⵙⴻⵏ ⵓⵍ ⵉⵜⵜⵡⴰⵔⴻⴱⴱⴰⵏ ⵅ ⵟⵟⵎⴻⵄ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵏⵏⴻⵄⵍⴻⵜ, ");
INSERT INTO rift_vpl VALUES ("P22_15","091_2_15","2PE","2","15","15","ⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵡⴻⴱⵔⵉⴷ ⵉⵙⴻⴳⴳⵎⴻⵏ, ⵡⴻⴷⴷⴰⵔⴻⵏ, ⵓⵛⴰ ⴹⴼⴰⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏⵏⵉ ⵉⴽⴽⴰ ⴱⴰⵍⵄⴰⵎ, ⵎⵎⵉⵙ ⵏ ⴼⴰⵖⵓⵔ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵍⵎⵓⵏⴻⵜ ⵏ ⵍⵖⴻⵛⵛ. ");
INSERT INTO rift_vpl VALUES ("P22_16","091_2_16","2PE","2","16","16","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴽⵙⵉ ⴰⵡⴻⴱⴱⴻⵅ ⵉ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵢⵍⴻⵜ ⵜⴰⴳⵏⴰⵡⵜ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵖⴰⵔⴻⵙ ⵙ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵏ ⵉⵡⴷⴰⵏ, ⵜⴻⵎⵏⴻⵄ ⵜⵓⴱⴱⵓⵀⴻⵍⵢⴰ ⵏ ⵓⵏⴰⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("P22_17","091_2_17","2PE","2","17","17","ⵏⵉⵜⵏⵉ ⴷ ⵍⵄⵓⵏⵚⴰⵔⴰⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵡⴰⵎⴰⵏ, ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵙ ⵜⵃⴰⵔⵢⴰⴹⵜ, ⴰⵇⴰ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ ⵏ ⵜⴰⴵⴻⵙⵜ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ ⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_18","091_2_18","2PE","2","18","18","ⵎⴰⵖⴰⵔ ⵎⴰⵍⴰ ⵙⵙⵉⵡⵍⴻⵏ ⵙ ⵏⵏⵄⵉ ⵏ ⵍⵀⴰⵔⴷ ⵏⵙⴻⵏ ⵉⵅⵡⴰⵏ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵖⴻⴽⴽⵯⴰⵏ ⵙ ⵏⵏⴻⵛⵡⴰⵜ ⵉⵅⴻⵎⵊⴻⵏ ⵏ ⴰⵔⵔⵉⵎⴻⵜ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴰⴷ ⴰⵔⴻⵡⵍⴻⵏ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵙⴻⵍⵍⵎⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵉ ⵓⵖⴻⴽⴽⵡⵉ. ");
INSERT INTO rift_vpl VALUES ("P22_19","091_2_19","2PE","2","19","19","ⵡⴰⵄⴷⴻⵏ ⵜⴻⵏ ⵙ ⵜⵉⵍⴻⵍⵍⵉ, ⵡⴰⵅⵅⴰ ⵏⵉⵜⵏⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵙⴻⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ ⵏ ⵍⵖⴻⵛⵛ. ⵎⵉⵏⵣⵉ ⵡⵉ ⵣⵉ ⵉⵜⵜⵡⴰⵖⴻⵍⵍⴻⴱ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ ⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("P22_20","091_2_20","2PE","2","20","20","ⵎⴰⵖⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⴰⵔⴻⵡⵍⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵉ ⵍⴻⵅⵎⴻⵊ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵙ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⴷⴻⵡⵍⴻⵏ-ⴷⴷ ⵖⴰⵔ ⵍⴻⵅⵎⴻⵊ ⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵓⵛⴰ ⵜⵜⵡⴰⵖⴻⵍⵍⴱⴻⵏ ⵣⵣⴰⵢⴻⵙ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵅⴻⵏⵏⵉ ⴰⵏⴻⴳⴳⴰⵔ ⵏⵙⴻⵏ ⴰⴷ ⴰⵙⴻⵏ ⵢⵓⵔⴰ ⵎⴰⵀⵓ ⵅ ⵓⵎⴻⵣⵡⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("P22_21","091_2_21","2PE","2","21","21","ⴰⵇⴰ ⵃⵙⴻⵏ ⴰⵙⴻⵏ ⵎⴻⵄⵍⵉⴽ ⵇⵇⵉⵎⴻⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵜⵙⴻⴳⴷⴰ ⵣⵉ ⵎⵉⵏ ⵙⵙⵏⴻⵏ, ⵓⵛⴰ ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⴼⴼⵖⴻⵏ ⵄⴰⵡⴻⴷ ⵅ ⵜⴻⵡⵚⴻⵢⵢⴻⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⴻⵍⵍⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P22_22","091_2_22","2PE","2","22","22","ⴰⵇⴰ ⵜⴻⵎⵙⴰⵔ ⴰⵙⴻⵏ ⴰⵎ ⵜⵜ ⵉⵇⵇⴰⵔ ⵡⴰⵡⴰⵍ-ⴰ ⵏ ⵜⵉⴷⴻⵜⵜ: “ⴰⵇⵣⵉⵏ ⴰⵇⴰ ⵉⴷⵡⴻⵍ-ⴷⴷ ⵅ ⵎⵉⵏ ⵜⵓⵖⴰ ⴷⴷ-ⵉⵄⵓⵇⵇ!” ⵏⵉⵖ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙ ⵇⵇⴰⵔⴻⵏ ⵏⵏⴻⵖⵏⵉ: “ⵜⵉⵍⴻⴼⵜ ⵜⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⵉⵔⴷⴻⵏ ⵇⴰⵄ, ⵜⴻⴷⵡⴻⵍ-ⴷⴷ ⵜᵉⵜⵜⵎⴰⵔⵔⴰⵖ ⴷⴻⴳ ⵓⴱⴰⵔⵢⵓⴹ ⵏⵏⴻⵙ!” ");
INSERT INTO rift_vpl VALUES ("P23_1","091_3_1","2PE","3","1","1","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵜⴰ ⴷ ⵜⴰⴱⵔⴰⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵉ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵓⵔⵉⵖ ⵍⴻⵅⵅⵓ, ⵓ ⴷⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⴻⴱⵔⴰⵜⵉⵏ-ⴰ ⴰⵔⴻⵣⵣⵓⵖ ⴰⴷ ⵙⵙⴼⴰⵇⴻⵖ ⵏⵏⴻⵢⵢⴻⵜ ⵏⵡⴻⵎ ⵉⵚⴼⴰⵏ ⴰⵎ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵄⴻⵇⵍⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("P23_2","091_3_2","2PE","3","2","2","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵏ ⵜᵉⵜⵜⴼⴻⴽⴽⴰⵔⴻⵎ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵏⵏⴰⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵣⵉⵛ, ⵓⵍⴰ ⴷⵉ ⵜⴻⵡⵚⴻⵢⵢⴰⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵜⵉⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⴷⴷ-ⵢⵉⵡⴹⴻⵏ ⵙ ⵔⵔⵓⵙⵓⵍ. ");
INSERT INTO rift_vpl VALUES ("P23_3","091_3_3","2PE","3","3","3","ⵎⴰⵏ ⴰⵢⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⴰⵇⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ ⵉⵏⵏⵉ ⵉⵙⵜⴻⵀⵣⴰⵏ ⴰⵎ ⵓⵢⵓⵔⴻⵏ ⵖⴰⵔ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("P23_4","091_3_4","2PE","3","4","4","ⴰⴷ ⵉⵏⵉⵏ: “ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⵡⴰⵄⴷ ⵏ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ? ⵣⴻⴳ ⵡⴰⵎⵉ ⵟⵟⵚⴻⵏ ⵍⴻⵊⴷⵓⴷ ⵏⵏⴻⵖ, ⴰⵎⵎⵓ ⵉ ⵢⴻⵇⵇⵉⵎ ⴽⵓⵍⵛⵉ ⴰⵎ ⵜⵓⵖⴰ ⵉⴵⴰ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔ ⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⴳⴳ ⴷⴷⵓⵏⴻⵛⵜ.” ");
INSERT INTO rift_vpl VALUES ("P23_5","091_3_5","2PE","3","5","5","ⵎⴻⵄⵍⵉⴽ ⵓⴼⵉⵏ ⴰⴷ ⵜⵜⵓⵏ ⴱⴻⵍⵍⵉ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵊⴻⵏⵡⴰⵏ ⵉⵣⵡⴰⵔⴻⵏ ⴰⴷ ⵉⵍⵉⵏ, ⵓ ⴰⵇⴰ ⵍⴱⴰⵔⵔ ⵉⴳⴻⵄⵄⴻⴷ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵓ ⵙ ⵓⴼⵓⵙ ⵏ ⵡⴰⵎⴰⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("P23_6","091_3_6","2PE","3","6","6","ⴰⵎⴰⵏ ⵉ ⵣⵉ ⵜᵉⵜⵜⵡⴰⵀⴻⵍⵍⴻⴽ ⴷⴷⵓⵏⴻⵛⵜ ⵏ ⵍⵡⴻⵇⵜ ⵏⵏⵉ ⵓⵎⵉ ⴷⴷ ⵅⴰⵙ ⵙⵙⴻⴼⵢⴻⵏ ⵡⴰⵎⴰⵏ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵏⵓⵃ, ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵎⵃⴰ. ");
INSERT INTO rift_vpl VALUES ("P23_7","091_3_7","2PE","3","7","7","ⵎⴰⵛⴰ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵢⵉⴹⴰ ⴰⵇⴰ ⵜⵜⵡⴰⵃⴻⴼⴹⴻⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⵅⴻⵎⵎⵍⴻⵏ ⵉ ⵜⵎⴻⵙⵙⵉ ⴰⵍ ⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ ⴷ ⵓⵡⴻⴷⴷⴰⵔ ⵏ ⵍⴽⵓⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("P23_8","091_3_8","2PE","3","8","8","ⵎⴰⵛⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴽⴻⵏⵏⵉⵡ ⵡⴰⵔ ⵜᵉⵜⵜᵉⵜⵜⵓⵎ ⵉⵛⵜ ⵏ ⵍⵃⴰⵊⵊⴻⵜ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ, ⴰⵇⴰ-ⵜⵜ ⴷ ⵜⴰ: ⵖⴰⵔ ⵙⵉⴷⵉ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴰⵎ ⴰⵍⴻⴼ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⵓⵛⴰ ⴰⵍⴻⴼ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵡⴰⵙⵙ. ");
INSERT INTO rift_vpl VALUES ("P23_9","091_3_9","2PE","3","9","9","ⴰⵇⴰ ⵙⵉⴷⵉ ⵡⴰⵔ ⵉⵙⵙⵄⵉⵣⵣⵉ ⴷⴻⴳ ⵓⵙⵓⴼⴼⴻⵖ ⵏ ⵍⵡⵓⵄⵓⴷ ⵏⵏⴻⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷ ⴰⵙⴻⵏ ⵉⵜⵜⵖⵉⵍ ⵉ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⴳⴳⵓⵔ ⴰⴽⵉⴷⵡⴻⵎ ⵙ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙ ⵛⴰ ⴰⴷ ⵢⴰⵔⴻⵢⵢⴻⴱ ⵓⵍⴰ ⴷ ⵉⵊⵊ, ⵎⴰⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵓⴱⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("P23_10","091_3_10","2PE","3","10","10","ⵎⴰⵛⴰ ⴰⵙⵙ ⵏ ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⵎ ⵓⵅⴻⵡⵡⴰⵏ ⵙ ⴵⵉⵍⴻⵜ. ⴷⴻⴳ ⵡⴰⵙⵙ ⵏⵏⵉ ⴰⴷ ⵡⴻⴷⴷⴰⵔⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙ ⵍⵖⴻⴼⵍⴻⵜ ⵓ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⴷ ⴼⴻⵙⵢⴻⵏⵜ ⴷⵉ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⵅⴰⵙ ⵉⴵⴰⵏ ⴰⴷ ⵜⵜⵡⴰⴼⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("P23_11","091_3_11","2PE","3","11","11","ⴰⵎ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ ⴰⴷ ⴼⴻⵙⵢⴻⵏⵜ ⴰⵎⵎⵓ, ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵛⵓⵡⵡⴰⵔ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵙ ⵜⵇⴻⴷⴷⴰⵙⵜ ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("P23_12","091_3_12","2PE","3","12","12","ⴰⵎ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ ⵜⴰⵡⴰⵙⵉⵜ ⵏ ⵡⴰⵙⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎ ⵜᵉⵜⵜⵎⴻⵥⵔⴻⵎ ⴷⴰⵢⴻⵙ, ⵅⵎⵉ ⵖⴰ ⴼⵏⴰⵏ ⵉⵊⴻⵏⵡⴰⵏ ⴰⵎ ⵜⵜⵡⴰⵇⴻⴵⴱⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⴰⴷ ⴼⴻⵙⵢⴻⵏⵜ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵙ ⵍⵄⴰⴱⵓⵇ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P23_13","091_3_13","2PE","3","13","13","ⵎⴰⵛⴰ ⵏⴻⵛⵛⵉⵏ ⴰⵇⴰ ⵏⴻⵜⵜⵔⴰⵊⴰ ⵉⵊⴻⵏⵡⴰⵏ ⵏ ⵊⴷⵉⴷ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⴷⵉⴷ ⵎⴰⵏⵉ ⵖⴰ ⵜⴻⵣⴷⴻⵖ ⵜⵙⴻⴳⴷⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵍⵡⴰⵄⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("P23_14","091_3_14","2PE","3","14","14","ⵙ ⵓⵢⴻⵏⵏⵉ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵓⵎⵉ ⴽⴻⵏⵏⵉⵡ ⵜᵉⵜⵜⵔⴰⵊⴰⵎ ⵎⴰⵏ ⴰⵢⴰ, ⵛⴹⴰⵔⴻⵎ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⴼⴻⵎ ⴱⵍⴰ ⵍⴻⵅⵎⴻⵊ ⵓ ⴱⵍⴰ ⵍⵄⵉⴱ ⵣⵣⴰⵜⴻⵙ ⴷⵉ ⵍⴻⵀⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("P23_15","091_3_15","2PE","3","15","15","ⵃⴻⵙⴱⴻⵎ ⵜⵜⴰⵙⵉⵄ ⵏ ⵍⵅⴰⴹⴰⵔ ⵏ ⵙⵉⴷⵉ ⴷ ⵜⴰⵡⵡⴰⵔⵜ ⵉ ⵡⴻⵚⵍⴰⵃ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵓⵍⴰ ⴷ ⵓⵎⴰⵜⵏⴻⵖ ⵉⵄⵉⵣⵣⴻⵏ ⴱⵓⵍⵓⵙ ⴷ ⴰⵡⴻⵎ ⴷⴷ-ⵢⵓⵔⴰ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵖⵉⵜ ⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("P23_16","091_3_16","2PE","3","16","16","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵉⵙⵙⵉⵡⴻⵍ ⵏⴻⵜⵜⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⵜⵉⴱⵔⴰⵜⵉⵏ ⵏⵏⴻⵙ. ⴰⵇⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉⵡⵄⴰⵔⴻⵏ ⵉ ⵍⴻⴼⵀⴰⵎⴻⵜ, ⵜⵉⵏⵏⵉ ⵉ ⵙⵙⴼⴰⵔⵔⴰⵖⴻⵏ ⵍⵊⵓⵀⵀⴰⵍ ⴷ ⵢⴻⵡⴷⴰⵏ ⵡⴰⵔ ⵉⵎⵜⵉⵏⴻⵏ ⴷⴻⴳ ⵡⵓⵍ ⵏⵙⴻⵏ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴳⴳⵉⵏ ⵓⵍⴰ ⵉ ⵜⵉⵔⴰ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵏⵏⴻⵖⵏⵉ ⵉ ⵡⴰⵔⴻⵢⵢⴻⴱ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("P23_17","091_3_17","2PE","3","17","17","ⵙ ⵓⵢⴻⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⴰⵎ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵇⴱⴻⵍ, ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⴹⴻⴼⴼⴰⵔⴰⵎ ⴰⵡⴰⵔⵏⵉ ⵉ ⵓⵡⴻⴷⴷⴰⵔ ⵏ ⵢⵉⵏⵏⵉ ⵉⴵⴰⵏ ⴱⵍⴰ ⵛⵛⴰⵔⵉⵄⴰ ⵓⵛⴰ ⴰⴷ ⵜⴻⵡⴹⴰⵎ ⵡⴰⵅⵅⴰ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴱⴻⴷⴷⴰⵎ ⵏⵉⵛⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("P23_18","091_3_18","2PE","3","18","18","ⵎⴰⵛⴰ ⵙ ⵍⵄⴻⴽⵙ ⵃⴹⴰⵎ ⴰⴷ ⵜⴻⵢⵎⴻⵎ ⴷⴻⴳ ⴰⵔⴹⴰ ⴷ ⵜⵓⵙⵙⵏⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵓ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵙ, ⵉ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵖⴰ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ, ⴰⵎ ⵍⴻⵅⵅⵓ ⴰⵎ ⵍⴻⴱⴷⴰ, ⴰⵍ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⴻⴱⴷⴰ! ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("J11_1","092_1_1","1JN","1","1","1","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷⵉⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⴷ ⵏⴻⵜⵜⴰ ⵉ ⴷ ⴰⵡⴻⵎ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ: ⵡⴻⵏⵏⵉ ⵏⴻⵙⵍⴰ ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵥⵔⴰ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵖ, ⴷ ⵡⴻⵏⵏⵉ ⵏⴻⵜⵡⴰⵍⴰ ⵓ ⵏⵃⴰⴷⴰ ⵜ ⵙ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵖ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⴰⵡⴰⵍ ⵉⴷⴷⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("J11_2","092_1_2","1JN","1","2","2","ⴰⵇⴰ ⵜⵓⴷⴰⵔⵜ ⵜⴻⴹⵀⴰⵔ-ⴷⴷ, ⵏⴻⵛⵛⵉⵏ ⵏⴻⵥⵔⴰ ⵉ-ⵜⵜ, ⵓⵛⴰ ⵏⵛⴻⵀⵀⴻⴷ ⵓ ⵏⴻⵜⵜⴱⴰⵔⵔⴻⵃ ⴰⵡⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵜⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵙⵙⴰⵔⴳⴻⴱ-ⴷⴷ ⵉ ⵏⴻⵛⵛⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("J11_3","092_1_3","1JN","1","3","3","ⵎⵉⵏ ⵏⴻⵥⵔⴰ ⴷ ⵎⵉⵏ ⵏⴻⵙⵍⴰ, ⴰⴷ ⴰⵡⴻⵎ ⵜ-ⵉ-ⴷⴷ-ⵏⴻⵙⵙⵛⴻⵏ, ⵃⵉⵎⴰ ⵄⴰⵡⴻⴷ ⴽⴻⵏⵏⵉⵡ ⴰⴷ ⵜⵉⵍⵉⵎ ⴷⴻⴳ ⵓⵎⵓⵏⵉ ⴰⴽⵉⴷⵏⴻⵖ, ⵓⵛⴰ ⴰⵎⵓⵏⵉ ⵏⵏⴻⵖ ⴰⴽ-ⴷ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵓ ⴰⴽ-ⴷ ⵎⵎⵉⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("J11_4","092_1_4","1JN","1","4","4","ⴰⵇⴰ ⵏⴻⵜⵜⴰⵔⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵖ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("J11_5","092_1_5","1JN","1","5","5","ⴷ ⵡⴰ ⴷ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⵏⴻⵙⵍⴰ ⵓⵛⴰ ⴰⴷ ⴰⵡⴻⵎ ⵏⴱⴰⵔⵔⴻⵃ: ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⴼⴰⵡⵜ, ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⵜⴰⴵⴻⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("J11_6","092_1_6","1JN","1","6","6","ⵎⴰⵍⴰ ⵏⴻⵇⵇⴰⵔ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⴰⵎⵓⵏⵉ ⴰⴽⵉⴷⴻⵙ, ⵓⵛⴰ ⵏⴻⴳⴳⵓⵔ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⴰⵇⴰ ⵏⴻⵙⵙⵅⴰⵔⵔⵉⵇ, ⵡⴰⵔ ⵏⴹⴻⴼⴼⴰⵔ ⵛⴰ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J11_7","092_1_7","1JN","1","7","7","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⵓⵢⵓⵔ ⴷⵉ ⵜⴼⴰⵡⵜ, ⴰⵎ ⵏⴻⵜⵜⴰ ⴷⵉ ⵜⴼⴰⵡⵜ, ⵖⴰⵔⵏⴻⵖ ⴰⵎⵓⵏⵉ ⴰⴽ-ⴷ ⵡⴰⵢⴰⵡⵢⴰ, ⵓⵛⴰ ⴰⴷ ⵜⴰⴼ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⴰⵙⵓⵄ, ⵎⵎⵉⵙ, ⴰⴷ ⴰⵏⴻⵖ ⵙⵙⵉⵣⴷⴻⴳⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J11_8","092_1_8","1JN","1","8","8","ⵎⴰⵍⴰ ⵏⴻⵇⵇⴰⵔ, ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⴱⵓ ⴷⴷⵏⵓⴱ, ⴰⵇⴰ ⵏⴻⵙⵙⵅⴰⵔⵔⵉⵇ ⵅ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵖ ⵓⵛⴰ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵜⴻⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("J11_9","092_1_9","1JN","1","9","9","ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏⴻⵏⵄⴻⵎ ⵙ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ ⵃⵉⵎⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵖⴼⴰⵔ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵓⵛⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("J11_10","092_1_10","1JN","1","10","10","ⵎⴰⵍⴰ ⵏⴻⵇⵇⴰⵔ: ‘ⵏⴻⵛⵛⵉⵏ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⴱⵓ ⴷⴷⵏⵓⴱ!’, ⵏⴻⵜⵜⴰⵔⵔⴰ ⵉ-ⵜ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⴰⵡⴰⵍ ⵏⵏⴻⵙ ⵡⴰⵔ ⴷⴰⵢⵏⴻⵖ ⵉⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("J12_1","092_2_1","1JN","2","1","1","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵓⵔⵉⵖ ⴰⵢⴰ ⵉ ⴽⴻⵏⵏⵉⵡ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵅⴻⵟⵟⵉⵎ ⵛⴰ. ⵓⵛⴰ ⵎⴰⵍⴰ ⵉⵅⴹⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵓⵎⵙⴻⵚⵍⴰⵃ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵎⵙⴻⴳⴳⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("J12_2","092_2_2","1JN","2","2","2","ⵎⴰⵖⴰⵔ ⵏⴻⵜⵜⴰ ⴷ ⴰⵚⵍⴰⵃ ⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ, ⵡⴰⵔ ⵉⴵⵉ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵉ ⵢⵉⵏⵏⵉ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("J12_3","092_2_3","1JN","2","3","3","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵏⴻⵜⵜⵡⴰⵍⴰ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⵉ-ⵜ, ⵎⴰⵍⴰ ⵏⴻⵟⵟⴻⴼ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_4","092_2_4","1JN","2","4","4","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: “ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵜ!”, ⵎⴰⵛⴰ ⵡⴰⵔ ⵉⵟⵟⵉⴼ ⵛⴰ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵏⴻⵜⵜⴰ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⴻⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("J12_5","092_2_5","1JN","2","5","5","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍ ⵏⵏⴻⵙ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴽⴻⵎⵎⴻⵍ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ. ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵙⵙⴻⵏ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_6","092_2_6","1JN","2","6","6","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ: ‘ⵏⴻⵛⵛ ⴷⴰⵢⴻⵙ!’, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵢⵓⵢⵓⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⵓⵖⴰ ⵉⴳⴳⵓⵔ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("J12_7","092_2_7","1JN","2","7","7","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵜⵜⴰⵔⵉⵖ ⵛⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵛⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵜⴰⵇⴷⵉⵎⵜ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵡⴻⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ ⵜⴰⵇⴷⵉⵎⵜ ⴷ ⴰⵡⴰⵍ ⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵍⵉⵎ. ");
INSERT INTO rift_vpl VALUES ("J12_8","092_2_8","1JN","2","8","8","ⵡⴰⵅⵅⴰ ⴰⵎⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵊⴷⵉⴷ, ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷⴰⵢⴻⵙ ⵓ ⴷⴰⵢⵡⴻⵎ, ⵎⵉⵏⵣⵉ ⵜⴰⴵⴻⵙⵜ ⵜⴻⵄⴷⵓ ⵓⵛⴰ ⵜⴰⴼⴰⵡⵜ ⵏ ⵜⵉⴷⴻⵜⵜ ⴰⵇⴰ ⵜᵉⵜⵜⴻⴹⵀⴰⵔ-ⴷⴷ ⵍⴻⵅⵅⵓ. ");
INSERT INTO rift_vpl VALUES ("J12_9","092_2_9","1JN","2","9","9","ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴼⴰⵡⵜ, ⵎⴰⵛⴰ ⵉⵛⴰⵔⵔⴻⵀ ⵓⵎⴰⵙ, ⵏⴻⵜⵜⴰ ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⴰⵍ ⵉⴹⴰ. ");
INSERT INTO rift_vpl VALUES ("J12_10","092_2_10","1JN","2","10","10","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵎⴰⵙ, ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵜⴼⴰⵡⵜ ⵓⵛⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵉ ⵣⵉ ⵖⴰ ⵉⵏⵇⴰⵔⴷ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_11","092_2_11","1JN","2","11","11","ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵓⵎⴰⵙ, ⴰⵇⴰ-ⵜ ⴷⵉ ⵜⴰⴵⴻⵙⵜ ⵓⵛⴰ ⵉⴳⴳⵓⵔ ⴷⵉ ⵜⴰⴵⴻⵙⵜ, ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵎⴰⵏⵉ ⵖⴰ ⵉⵔⴰⵃ, ⵎⵉⵏⵣⵉ ⵜⴰⴵⴻⵙⵜ ⵜⴻⵙⵙⴷⴰⵔⵖⴻⵍ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_12","092_2_12","1JN","2","12","12","ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ, ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ, ⵎⵉⵏⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵡⴻⵎ ⵜⵜⵡⴰⵖⴼⴰⵔⴻⵏ ⴰⵡⴻⵎ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_13","092_2_13","1JN","2","13","13","ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ, ⴰ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⴻⵙⵙⵏⴻⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ, ⴰ ⵉⴱⵍⵉⵖⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜⵖⴻⵍⵍⴱⴻⵎ ⵅ ⵓⵎⵄⴻⴼⴼⴰⵏ. ⴰⵇⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ, ⴰ ⵉⵃⵓⴷⵔⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴰⴱⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J12_14","092_2_14","1JN","2","14","14","ⴰⵇⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ, ⴰ ⵉⴱⴰⴱⴰⵜⴻⵏ, ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵏⴻⵎ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⴰⵇⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ, ⴰ ⵉⴱⵍⵉⵖⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⴽⴻⵏⵏⵉⵡ ⵜⵊⴻⵀⴷⴻⵎ ⵓⵛⴰ ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⵡⴻⵎ ⵓⵛⴰ ⵜⵖⴻⵍⵍⴱⴻⵎ ⵅ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("J12_15","092_2_15","1JN","2","15","15","ⵡⴰⵔ ⵜⵜⴻⵅⵙⴻⵎ ⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵍⴰ ⴷ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⵜⵜⴻⵅⵙ ⴷⴷⵓⵏⴻⵛⵜ, ⵜⴰⵢⵔⵉ ⵏ ⴱⴰⴱⴰⵜⵏⴻⵖ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜⴻⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("J12_16","092_2_16","1JN","2","16","16","ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ - ⴰⵇⴰ-ⵜ ⴷ ⵏⵏⴻⵛⵡⴻⵜ ⵏ ⴷⴷⴰⵜ ⴷ ⵏⵏⴻⵛⵡⴻⵜ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴷ ⵜⵓⴼⴼⴻⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ - ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⵉⵙ ⵛⴰ ⵣⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵎⴰⵛⴰ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("J12_17","092_2_17","1JN","2","17","17","ⵓⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵄⴻⴷⴷⵓ ⵓⵍⴰ ⴷ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵏⴻⵙ, ⵎⴰⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵉⵇⵇⵉⵎ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("J12_18","092_2_18","1JN","2","18","18","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⴰⵇⴰ ⵍⵡⴻⵇⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⵜⵉⵡⴻⴹ-ⴷⴷ, ⵓⵛⴰ ⴰⵎ ⵜⴻⵙⵍⵉⵎ ⴱⴻⵍⵍⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⵍⵎⴰⵙⵉⵃ ⴰⴼⴰⵍⵙⵓ, ⴰⵎⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ ⴹⵀⴰⵔⴻⵏ-ⴷⴷ ⴰⵟⵟⴰⵙ ⵏ ⵉⵎⴰⵙⵉⵃⴻⵏ ⵉⴼⴰⵍⵙⵓⵜⴻⵏ. ⵙ ⵓⵢⴻⵏⵏⵉ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵍⵡⴻⵇⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ.    ");
INSERT INTO rift_vpl VALUES ("J12_19","092_2_19","1JN","2","19","19","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⵏⴻⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⴻⵏ ⵜⵓⵖⵉ ⵣⵣⴰⵢⵏⴻⵖ. ⵎⴻⵄⵍⵉⴽ ⵏⵉⵜⵏⵉ ⵜⵓⵖⴰ ⵣⵣⴰⵢⵏⴻⵖ, ⴰⴷ ⵉⵍⵉ ⵇⵇⵉⵎⴻⵏ ⴰⴽⵉⴷⵏⴻⵖ. ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⵏⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴱⴰⵏ ⴱⴻⵍⵍⵉ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⵣⵣⴰⵢⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J12_20","092_2_20","1JN","2","20","20","ⴰⵇⴰ ⵖⴰⵔⵡⴻⵎ ⴰⴷⵀⴰⵏ ⵏ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵓⵛⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴰⴷ ⵜⴼⴰⵔⵣⴻⵎ ⴽⵓⵍ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("J12_21","092_2_21","1JN","2","21","21","ⵡⴰⵔ ⴷ ⴰⵡⴻⵎ ⵓⵔⵉⵖ ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⵎ ⵛⴰ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵜᵉⵜⵜⴻⵙⵙⵏⴻⵎ ⵜⵜ, ⵓ ⵜⴻⵙⵙⵏⴻⵎ ⵄⴰⵡⴻⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵏ ⵓⵅⴰⵔⵔⵉⵇ ⵡⴰⵔ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⴻⵖ ⵛⴰ ⵣⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J12_22","092_2_22","1JN","2","22","22","ⵡⵉ ⵉⴵⴰⵏ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵉⵏⴽⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴷ ⵍⵎⴰⵙⵉⵃ! ⴷ ⵡⴰ ⴷ ⵍⵎⴰⵙⵉⵃ ⴰⴼⴰⵍⵙⵓ, ⵡⴻⵏⵏⵉ ⵉⵏⴽⴰⵔⴻⵏ ⴱⴰⴱⴰⵙ ⴷ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_23","092_2_23","1JN","2","23","23","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵏⴽⴰⵔⴻⵏ ⵎⵎⵉⵙ ⵡⴰⵔ ⵢⵓⵎⵉⵏ ⵄⴰⵡⴻⴷ ⴷⵉ ⴱⴰⴱⴰⵙ. ⵡⴻⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵉ ⵎⵎⵉⵙ, ⵉⵛⴻⵀⵀⴻⴷ ⵄⴰⵡⴻⴷ ⵉ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_24","092_2_24","1JN","2","24","24","ⴻⵊⵊ ⴰⴷ ⴷⴰⵢⵡⴻⵎ ⵉⵇⵇⵉⵎ ⵎⵉⵏ ⵜⴻⵙⵍⵉⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⵎⴰⵍⴰ ⵉⵇⵇⵉⵎ ⴷⴰⵢⵡⴻⵎ ⵎⵉⵏ ⵜⴻⵙⵍⵉⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⴰⴷ ⵜⴻⵇⵇⵉⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ ⵄⴰⵡⴻⴷ ⴷⵉ ⴱⴰⴱⴰⵙ ⵓ ⴷⵉ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_25","092_2_25","1JN","2","25","25","ⵜⴰ ⴷ ⵜⵉⴽⴽⴻⵙⵜ ⵏ ⵡⴰⵡⴰⵍ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ: ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("J12_26","092_2_26","1JN","2","26","26","ⵎⴰⵏ ⴰⵢⴰ ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⵜ-ⵉ-ⴷⴷ ⵅ ⵢⵉⵏⵏⵉ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴻⴷⴷⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("J12_27","092_2_27","1JN","2","27","27","ⵎⴰⵍⴰ ⴰⴷⵀⴰⵏ ⵉ ⵣⵣⴰⵢⴻⵙ ⵜᵉⵟⵟⴼⴻⵎ ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⴰⵢⵡⴻⵎ, ⵡⴰⵔ ⵜⴻⵃⴷⴰⵊⴻⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵃⴻⴷ. ⵎⵉⵏⵣⵉ ⴰⴷⵀⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵙⵙⴻⵍⵎⴰⴷ ⴷⵉ ⵎⴰⵔⵔⴰ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴵⵉⵏ ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ⵅⴻⵏⵏⵉ ⵇⵇⵉⵎⴻⵎ ⴷⴰⵢⴻⵙ, ⴷⵉ ⵍⵎⴰⵙⵉⵃ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵡⴻⵎ ⵉⵙⵙⴻⵍⵎⴻⴷ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("J12_28","092_2_28","1JN","2","28","28","ⵅⴻⵏⵏⵉ ⵍⴻⵅⵅⵓ, ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵇⵇⵉⵎⴻⵎ ⴷⴰⵢⴻⵙ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵏⴻⵜⵜⵙⴻⴹⵃⵉ ⵛⴰ ⵇⵉⴱⴰⵍⵜ ⵏⵏⴻⵙ ⵅ ⵎⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵉⴹⵀⴰⵔ, ⵎⴰⵛⴰ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵍⵉ ⵜⵜⵉⵇⵇⴻⵜ ⵖⴰⵔ ⵜⵡⴰⵙⵉⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J12_29","092_2_29","1JN","2","29","29","ⵎⴰⵍⴰ ⵜⴻⵙⵙⵏⴻⵎ, ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⵙⵏⴻⵎ ⵄⴰⵡⴻⴷ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J13_1","092_3_1","1JN","3","1","1","ⵅⵣⴰⵔ, ⵎⴻⵛⵃⴰⵍ ⵜⴻⵎⵖⴰⵔ ⵜⴰⵢⵔⵉ ⵉ ⵣⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵅⵙ ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴰⵍⴰⵎⵉ ⵉⵍⴰⵖⴰ ⵓ ⵉⴳⴳⴰ ⴰⵏⴻⵖ ⵜⴰⵔⵡⴰ. ⵙ ⵓⵢⴻⵏⵏⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵜⴻⵙⵙⵉⵏ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵜ ⵜⴻⵙⵙⵉⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("J13_2","092_3_2","1JN","3","2","2","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵍⴻⵅⵅⵓ ⵏⴻⵛⵛⵉⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⴻⴵⴰ, ⵡⴰⵔ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵄⴰⴷ ⵎⵉⵏ ⵖⴰ ⵏⵉⵍⵉ. ⴰⵇⴰ ⵏⴻⵙⵙⴻⵏ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵉⴱⴰⵏ ⵏⴻⵜⵜⴰ, ⴰⴷ ⵏⵉⵍⵉ ⴷⵉ ⵚⵚⵉⴼⴻⵜ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴰⴷ ⵜ ⵏⵥⴰⵔ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("J13_3","092_3_3","1JN","3","3","3","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵙⵉⵜⴻⵎ-ⴰ ⴷⴰⵢⴻⵙ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ, ⴰⴷ ⵉⵙⵙⵉⵣⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⴻⵣⴷⴰⴳ. ");
INSERT INTO rift_vpl VALUES ("J13_4","092_3_4","1JN","3","4","4","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⵏⵓⴱ, ⵉⵜⵜⴻⴳⴳ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⵎⵉⵏⵣⵉ ⵎⴰⵔⵔⴰ ⴷⴷⴻⵏⴱ ⴷ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("J13_5","092_3_5","1JN","3","5","5","ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⴱⴰⵏ-ⴷⴷ, ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ: ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⴱⵓ ⴷⴷⵏⵓⴱ. ");
INSERT INTO rift_vpl VALUES ("J13_6","092_3_6","1JN","3","6","6","ⵎⴰⵔⵔⴰ ⵡⵉ ⴷⴰⵢⴻⵙ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⴷⴷⵏⵓⴱ. ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⵏⵓⴱ, ⵡⴰⵔ ⵜ ⵉⵥⵔⵉ, ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("J13_7","092_3_7","1JN","3","7","7","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵎ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵉⵅⴰⵔⵡⴻⴹ ⵃⴻⴷ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵏⴻⵜⵜⴰ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵄⴰⵡⴻⴷ ⵍⵎⴰⵙⵉⵃ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("J13_8","092_3_8","1JN","3","8","8","ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴷⴷⵏⵓⴱ ⴷ ⵏⴻⵜⵜⴰ ⵣⵉ ⵛⵛⵉⵟⴰⵏ, ⵎⵉⵏⵣⵉ ⵛⵛⵉⵟⴰⵏ ⵜⵓⵖⴰ ⴷ ⴰⵎⴻⴷⵏⵓⴱ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ. ⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⴷⴷ-ⵉⴹⵀⴰⵔ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ: ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⴻⵅⵙⴰⵔ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⵛⵛⵉⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("J13_9","092_3_9","1JN","3","9","9","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳ ⵛⴰ ⴷⴷⵏⵓⴱ, ⵎⵉⵏⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⴰⵇⴰ-ⵜⵜ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵅⴹⴰ, ⵎⵉⵏⵣⵉ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J13_10","092_3_10","1JN","3","10","10","ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴷⴷ-ⴹⵀⴰⵔⴻⵏ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⵛⵛⵉⵟⴰⵏ: ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⴰⵙⴻⴳⴷⴰ ⵓ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵎⴰⵙ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J13_11","092_3_11","1JN","3","11","11","ⵎⴰⵖⴰⵔ ⵜⴰ ⴷ ⵜⴰⵡⵚⵉⵢⵢⴻⵜ ⵉ ⵜⵓⵖⴰ ⵜⴻⵙⵍⵉⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴱⴻⵍⵍⵉ ⴰⴷ ⵜⴻⵅⵙⴻⵎ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ!’ ");
INSERT INTO rift_vpl VALUES ("J13_12","092_3_12","1JN","3","12","12","ⵡⴰⵔ ⵉⴵⵉ ⴰⵎ ⵇⴰⵢⵉⵏ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵣⴻⴳ ⵓⵎⵄⴻⴼⴼⴰⵏ ⵓⵛⴰ ⵉⵏⵖⴰ ⵓⵎⴰⵙ. ⵎⴰⵢⴻⵎⵎⵉ ⵉⵏⵖⴰ ⵓⵎⴰⵙ? ⵙ ⵎⵉⵏⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵄⴻⴼⴼⵏⴻⵏⵜ ⵓⵛⴰ ⵜⵉⵏⵏⵉ ⵏ ⵓⵎⴰⵙ ⵙⴻⴳⴳⴷⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("J13_13","092_3_13","1JN","3","13","13","ⵡⴰⵔ ⵜⴻⴷⵀⵉⵛⴻⵎ ⵛⴰ, ⴰ ⴰⵢⵜⵎⴰ, ⵎⴰⵍⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵛⴰⵔⵀ ⵉ ⴽⴻⵏⵏⵉⵡ. ");
INSERT INTO rift_vpl VALUES ("J13_14","092_3_14","1JN","3","14","14","ⵏⴻⵛⵛⵉⵏ ⵏⴻⵙⵙⴻⵏ, ⴰⵇⴰ ⵏⴻⵥⵡⴰ ⵣⵉ ⵍⵎⴻⵡⵜ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵅⵙ ⴰⵡⵎⴰⵜⴻⵏ ⵏⵏⴻⵖ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵎⴰⵙ, ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("J13_15","092_3_15","1JN","3","15","15","ⵎⴰⵔⵔⴰ ⵡⵉ ⵉⵛⴰⵔⵔⵀⴻⵏ ⵓⵎⴰⵙ ⴷ ⴰⵇⴻⵜⵜⴰⵍ, ⵓⵛⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⴻⵇⵇⵉⵎ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵓⵇⴻⵜⵜⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("J13_16","092_3_16","1JN","3","16","16","ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵙⵙⴻⵏ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ ⵉ ⵏⴻⵛⵛⵉⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵙ ⴷⴻⴳ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵖ. ⵄⴰⵡⴻⴷ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⵏⵉⵛⴰⵏ ⴰⴷ ⵏⴻⵙⵙⴰⵔⵙ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵅ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J13_17","092_3_17","1JN","3","17","17","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⴰⴳⵍⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⵉⵜⵜⵡⴰⵍⴰ ⵓⵎⴰⵙ ⵉⵣⵍⴻⴹ, ⵅⴻⵏⵏⵉ ⵉⵇⵇⴻⵏ ⵅⴰⵙ ⵓⵍ ⵏⵏⴻⵙ, ⵎⴰⵎⵎⴻⵛ ⵉ ⵖⴰ ⵜⴻⵣⴷⴻⵖ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷⴰⵢⴻⵙ? ");
INSERT INTO rift_vpl VALUES ("J13_18","092_3_18","1JN","3","18","18","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⵡⴰⵔ ⵏᵉⵜⵜⴻⵅⵙ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⴻⵖⵏⵉ ⵙ ⵡⴰⵡⴰⵍ ⵏⵉⵖ ⵙ ⵉⵍⴻⵙ, ⵎⴰⵛⴰ ⵙ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵓ ⴷⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J13_19","092_3_19","1JN","3","19","19","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵙⵙⴻⵏ ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵣⵉ ⵜⵉⴷⴻⵜⵜ ⵓⵛⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵇⵏⴻⵄ ⵓⵍⴰⵡⴻⵏ ⵏⵏⴻⵖ ⵇⴱⴻⵍ ⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("J13_20","092_3_20","1JN","3","20","20","ⵎⵉⵏⵣⵉ ⵎⴰⵍⴰ ⵉⵃⴽⴻⵎ ⵡⵓⵍ ⵏⵏⴻⵖ ⵅⴰⵏⴻⵖ, ⵎⴻⵛⵃⴰⵍ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵡⵓⵍ ⵏⵏⴻⵖ! ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴻⵏ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("J13_21","092_3_21","1JN","3","21","21","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵓⵍ ⵏⵏⴻⵖ ⵡⴰⵔ ⵅⴰⵏⴻⵖ ⵉⵃⴽⴻⵎ, ⴰⵇⴰ ⵖⴰⵔⵏⴻⵖ ⵜⵜⵉⵇⵇⴻⵜ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("J13_22","092_3_22","1JN","3","22","22","ⵓⵛⴰ ⵎⴰⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵉ ⵖⴰ ⵏⴻⵜⵜⴰⵔ, ⴰⴷ ⵜⵜ ⵏⴻⴽⵙⵉ ⵣⵣⴰⵢⴻⵙ, ⵎⵉⵏⵣⵉ ⵏⴻⵛⵛⵉⵏ ⵏⵃⴻⵟⵟⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴷ ⵏⴻⴳⴳ ⵎⵉⵏ ⵖⴰ ⵢⴰⵔⴹⴰⵏ ⵇⵉⴱⴰⵍⵜ ⵏⴻⵜⵜⴰ. ");
INSERT INTO rift_vpl VALUES ("J13_23","092_3_23","1JN","3","23","23","ⴷ ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏⵏⴻⵙ ⴱⴻⵍⵍⵉ ⴰⴷ ⵏⴰⵎⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵎⵎⵉⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⴰⴷ ⵏⴻⵅⵙ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⴷ ⴰⵏⴻⵖ ⵢⵓⵎⵓⵔ. ");
INSERT INTO rift_vpl VALUES ("J13_24","092_3_24","1JN","3","24","24","ⵡⴻⵏⵏⵉ ⵉⵃⴻⵟⵟⴰⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵃⴹⴰ ⵓ ⵏⴻⵜⵜⴰ ⵉⵣⴻⴷⴷⴻⵖ ⴷⴰⵢⴻⵙ. ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵖⵉⵎⴰ ⴷⴰⵢⵏⴻⵖ, ⵣⵉ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ ⵉ ⴷ ⴰⵏⴻⵖ ⵉⵡⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("J14_1","092_4_1","1JN","4","1","1","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵡⴰⵔ ⵜⵜⵉⵇⵇⴻⵎ ⵛⴰ ⴷⵉ ⵎⴰⵔⵔⴰ ⴰⵔⵔⵓⵃⴰⵜ, ⵎⴰⵛⴰ ⵇⴻⴵⴱⴻⵎ ⴰⵔⵔⵓⵃⴰⵜ, ⵎⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉ ⵉⴵⴰⵏ, ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⴰⵇⴰ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("J14_2","092_4_2","1JN","4","2","2","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴰⵔⵔⵓⵃ ⵏ ⴰⵔⴻⴱⴱⵉ: ⵎⴰⵔⵔⴰ ⴰⵔⵔⵓⵃ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉ ⴷⴷⴰⵜ ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_3","092_4_3","1JN","4","3","3","ⵎⴰⵔⵔⴰ ⴰⵔⵔⵓⵃ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵛⴻⵀⵀⴷⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⵢⵓⵙⴰ-ⴷⴷ ⴷⵉ ⴷⴷⴰⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵛⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⵣⵉ ⴰⵔⵔⵓⵃ ⵏ ⵍⵎⴰⵙⵉⵃ ⴰⴼⴰⵍⵙⵓ ⵡⴻⵏⵏⵉ ⵉ ⵅⴻⴼ ⵜⴻⵙⵍⴰⵎ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷⴰ ⵍⴻⵅⵅⵓ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ.    ");
INSERT INTO rift_vpl VALUES ("J14_4","092_4_4","1JN","4","4","4","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ ⴷ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉ ⵜⴻⴵⴰⵎ, ⴰⵇⴰ ⵜⵖⴻⵍⵍⴱⴻⵎ ⵅⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⴰⵢⵡⴻⵎ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵅ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("J14_5","092_4_5","1JN","4","5","5","ⵏⵉⵜⵏⵉ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ, ⵙ ⵓⵢⴻⵏⵏⵉ ⵙⵙⴰⵡⴰⵍⴻⵏ ⵣⵉ ⴷⴷⵓⵏⴻⵛⵜ ⵓⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵜᵉⵜⵜⴻⵙⵍⴰ ⴰⵙⴻⵏ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("J14_6","092_4_6","1JN","4","6","6","ⴰⵇⴰ ⴰⵏⴻⵖ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⵡⴻⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⵉⵜⵜⴻⵙⵍⴰ ⴰⵏⴻⵖ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵙⵍⵉ ⵛⴰ. ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵖⴰ ⵏⴻⵙⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵏ ⵜⵉⴷⴻⵜⵜ ⴷ ⴰⵔⵔⵓⵃ ⵏ ⵓⵡⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("J14_7","092_4_7","1JN","4","7","7","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵅⵙ ⴰⵢⴰⵡⵢⴰ, ⵎⵉⵏⵣⵉ ⵜⴰⵢⵔⵉ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⴷ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵙⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_8","092_4_8","1JN","4","8","8","ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⵢⵔⵉ, ⵓ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙⴻⵏ, ⵡⴰⵔ ⵉⵙⵙⵉⵏ ⵛⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_9","092_4_9","1JN","4","9","9","ⵙ ⵎⴰⵏ ⴰⵢⴰ ⵜⴻⴹⵀⴰⵔ ⴰⵏⴻⵖ-ⴷⴷ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵢⴻⵏⵏⵉ ⵏ ⵎⵎⵉⵙ ⵉ ⵖⴰⵔⴻⵙ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵏⴻⴷⴷⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("J14_10","092_4_10","1JN","4","10","10","ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉ ⵜⴻⴵⴰ ⵜⴰⵢⵔⵉ, ⵡⴰⵔ ⵉⴵⵉ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛⵉⵏ ⵏᵉⵜⵜⴻⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⵎⴰⵛⴰ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵏⴻⵖ ⵓⵛⴰ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵎⵎⵉⵙ ⴷ ⴰⵚⵍⴰⵃ ⵅ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J14_11","092_4_11","1JN","4","11","11","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵎⴰⵍⴰ ⵜⵓⵖⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵜⵜⴻⵅⵙ ⴰⵏⴻⵖ ⴰⵎⵎⵓ, ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵏⴻⵖ ⵄⴰⵡⴻⴷ ⴰⴷ ⵏⴻⵅⵙ ⵉⵊⵊ ⵡⴻⵏⵏⴻⵖⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_12","092_4_12","1JN","4","12","12","ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵎⴰ ⵉⵥⵔⴰ ⴰⵔⴻⴱⴱⵉ. ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵏᵉⵜⵜⴻⵅⵙ ⴰⵢⴰⵡⵢⴰ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴷⴰⵢⵏⴻⵖ ⵉⵇⵇⵉⵎ, ⵓⵛⴰ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ ⴰⵇⴰ ⵜⴻⴷⵡⴻⵍ ⵜⴻⴽⵎⴻⵍ ⴷⴰⵢⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J14_13","092_4_13","1JN","4","13","13","ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⵖⵉⵎⴰ ⴷⴰⵢⴻⵙ ⵓ ⵏⴻⵜⵜⴰ ⴷⴰⵢⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵣⵉ ⴰⵔⵔⵓⵃ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J14_14","092_4_14","1JN","4","14","14","ⴰⵇⴰ ⵏⴻⵥⵔⴰ ⵓ ⵏⵛⴻⵀⵀⴻⴷ ⴱⴻⵍⵍⵉ ⴱⴰⴱⴰⵙ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⵎⵎⵉⵙ ⴷ ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("J14_15","092_4_15","1JN","4","15","15","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵣⴷⴻⵖ ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵣⴷⴻⵖ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_16","092_4_16","1JN","4","16","16","ⴰⵇⴰ ⵏⴻⵛⵛⵉⵏ ⵏⵓⵎⴻⵏ ⵓ ⵏⴻⵙⵙⴻⵏ ⵜⴰⵢⵔⵉ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉ ⵏⴻⵛⵛⵉⵏ. ⴰⵔⴻⴱⴱⵉ ⴷ ⵜⴰⵢⵔⵉ ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⴰⵢⵔⵉ, ⴰⴷ ⵉⵇⵇⵉⵎ ⴷⵉ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_17","092_4_17","1JN","4","17","17","ⴷⵉ ⵎⴰⵏ ⴰⵢⴰ ⵜᵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵙ ⴷⴰⵢⵏⴻⵖ, ⴰⵍⴰⵎⵉ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵜⵉⵍⵉ ⵜⵜⵉⵇⵇⴻⵜ ⴷⴻⴳ ⵡⴰⵙⵙ ⵏ ⵍⵃⵉⵙⴰⴱ, ⵎⵉⵏⵣⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⴵⴰ ⵏⴻⵜⵜⴰ, ⴰⴷ ⵏⵉⵍⵉ ⵏⴻⵛⵛⵉⵏ ⵄⴰⵡⴻⴷ ⴷⵉ ⴷⴷⵓⵏⴻⵛⵜ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("J14_18","092_4_18","1JN","4","18","18","ⴷⵉ ⵜⴰⵢⵔⵉ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵎⴰⵛⴰ ⵜⴰⵢⵔⵉ ⵏⵉⵛⴰⵏ ⵜⴻⵙⵙⵓⴼⴼⵓⵖ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵎⵉⵏⵣⵉ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜᵉⵜⵜⴰⵙ-ⴷⴷ ⴰⴽ-ⴷ ⵓⵏⴻⵅⵍⵉⵄ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⵡⴰⵔ ⵉⵜⵜⵉⵍⵉ ⵉⴽⵎⴻⵍ ⴷⵉ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_19","092_4_19","1JN","4","19","19","ⵅ ⵓⵢⴰ ⴰⴷ ⵏⴻⵅⵙ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵜⵓⵖⴰ ⵉⵜⵜⴻⵅⵙ ⴰⵏⴻⵖ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ. ");
INSERT INTO rift_vpl VALUES ("J14_20","092_4_20","1JN","4","20","20","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⵇⵇⴰⵔ: “ⵏⴻⵛⵛ ⵜⵜⴻⵅⵙⴻⵖ ⴰⵔⴻⴱⴱⵉ!”, ⴰⵎ ⵉⵛⴰⵔⵔⴻⵀ ⵓⵎⴰⵙ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓⵎⴰⵙ ⵡⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰ, ⵅⴻⵏⵏⵉ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵢⴻⴳⴳ ⴰⴷ ⵉⵅⵙ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("J14_21","092_4_21","1JN","4","21","21","ⴰⵇⴰ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ-ⴰ ⵏⴻⵟⵟⴻⴼ ⵉ-ⵜⵜ ⵣⵣⴰⵢⴻⵙ, ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵉⵅⵙ ⵓⵍⴰ ⴷ ⵓⵎⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("J15_1","092_5_1","1JN","5","1","1","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴷ ⵍⵎⴰⵙⵉⵃ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵜⵜⵡⴰⵅⵍⴻⵇ-ⴷⴷ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵜ-ⵉ-ⴷⴷ ⵢⴻⵊⵊⵉⵏ, ⴰⴷ ⵉⵅⵙ ⵄⴰⵡⴻⴷ ⵡⴻⵏⵏⵉ ⵣⵣⴰⵢⴻⵙ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("J15_2","092_5_2","1JN","5","2","2","ⵣⵉ ⵎⴰⵏ ⴰⵢⴰ ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵏᵉⵜⵜⴻⵅⵙ ⵜⴰⵔⵡⴰ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵅⵎⵉ ⵏᵉⵜⵜⴻⵅⵙ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏᵉⵜⵜⴻⴳⴳ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J15_3","092_5_3","1JN","5","3","3","ⵎⵉⵏⵣⵉ ⵜⴰ ⴷ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⴷ ⵏⴻⵃⴹⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵡⵄⴰⵔⴻⵏⵜ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("J15_4","092_5_4","1JN","5","4","4","ⵎⴰⵖⴰⵔ ⵎⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵖⴻⵍⵍⴻⴱ ⵅ ⴷⴷⵓⵏⴻⵛⵜ. ⴷ ⵡⴰ ⴷ ⴰⵖⵍⴰⴱ ⵉ ⵉⵜⵜⵖⴻⵍⵍⴰⴱⴻⵏ ⵅ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⵇⴰ-ⵜ ⴷ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J15_5","092_5_5","1JN","5","5","5","ⵎⴰⵏ ⵡⴻⵏ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⵅ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴱⴻⵍⵍⵉ ⵢⴰⵙⵓⵄ ⴷ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ! ");
INSERT INTO rift_vpl VALUES ("J15_6","092_5_6","1JN","5","6","6","ⴷ ⵡⴰ ⵉ ⴷⴷ-ⵉⴽⴽⵉⵏ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ⵡⴰⵔ ⴷⴷ-ⵢⴻⴽⴽⵉ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵣⴻⴳ ⵡⴰⵎⴰⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("J15_7","092_5_7","1JN","5","7","7","ⴰⵔⵔⵓⵃ ⴷ ⵡⴻⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵔⵔⵓⵃ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J15_8","092_5_8","1JN","5","8","8","ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ: ⴰⵔⵔⵓⵃ ⴷ ⵡⴰⵎⴰⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙ ⵜⵍⴰⵜⴰ ⴷⴻⴳ ⵉⵊⵊⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("J15_9","092_5_9","1JN","5","9","9","ⵎⴰⵍⴰ ⵏⴻⵇⴱⴻⵍ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵉⵡⴷⴰⵏ, ⵎⴻⵛⵃⴰⵍ ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ⵜⴰ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⴻⵏⵏⵉ ⵉⵛⵀⴻⴷ ⵅ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("J15_10","092_5_10","1JN","5","10","10","ⵡⴻⵏⵏⵉ ⵢⵓⵎⵏⴻⵏ ⴷⵉ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵖⴰⵔⴻⵙ ⵛⵛⵀⴰⴷⴻⵜ-ⴰ ⴷⴻⴳ ⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵇⴰ ⵉⴳⴳⴰ ⵉ-ⵜ ⴷ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⵡⴰⵔ ⵢⵓⵎⵉⵏ ⵛⴰ ⴷⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵜⴻⵏⵏⵉ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵅ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("J15_11","092_5_11","1JN","5","11","11","ⵓⵛⴰ ⵜⴰ ⴷ ⵛⵛⵀⴰⴷⴻⵜ: ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵏⴻⵖ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ ⵓⵛⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵏⵉ ⴰⵇⴰ-ⵜⵜ ⴷⵉ ⵎⵎⵉⵙ. ");
INSERT INTO rift_vpl VALUES ("J15_12","092_5_12","1JN","5","12","12","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵎⵎⵉⵙ, ⵖⴰⵔⴻⵙ ⵜⵓⴷⴰⵔⵜ. ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("J15_13","092_5_13","1JN","5","13","13","ⵓⵔⵉⵖ ⴰⵡⴻⵎ-ⴷⴷ ⵎⴰⵏ ⴰⵢⴰ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵖⴰⵔⵡⴻⵎ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⴽⴻⵏⵏⵉⵡ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵎⵏⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J15_14","092_5_14","1JN","5","14","14","ⴷ ⵜⴰ ⴷ ⵜⵜⵉⵇⵇⴻⵜ ⵜⴻⵏⵏⵉ ⵖⴰⵔⵏⴻⵖ ⴷⴰⵢⴻⵙ, ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵎⵉⵏ ⵉⵅⵙ ⵏⴻⵜⵜⴰ, ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⵏⴻⵖ ⵉⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("J15_15","092_5_15","1JN","5","15","15","ⵎⴰⵍⴰ ⵏⴻⵜⵜⵡⴰⵙⵙⴻⵇⵏⴻⵄ ⵏⵉⵛⴰⵏ ⴰⵇⴰ ⴰⴷ ⴰⵏⴻⵖ ⵉⵙⴻⵍ ⵎⵉⵏ ⵎⴰ ⴷ ⴰⵙ ⵏⴻⵜⵜⴰⵔ, ⵅⴻⵏⵏⵉ ⵏⴻⵜⵜⵉⵇⵇ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⴰⵏⴻⵖ ⵎⵉⵏ ⴷ ⴰⵙ ⵏⴻⵜⵜⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("J15_16","092_5_16","1JN","5","16","16","ⵎⴰⵍⴰ ⵃⴻⴷ ⵉⵥⵔⴰ ⵓⵎⴰⵙ ⵉⵅⴻⵟⵟⴰ, ⵉⵊⵊ ⵏ ⵓⵅⴻⵟⵟⵓ ⵡⴰⵔ ⵉⵀⴷⵉⵊⴻⵏ ⵛⴰ ⵍⵎⴻⵡⵜ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵥⵥⴰⴵ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵜⴻⵎⵎⴻⵡⵛ ⵜⵓⴷⴰⵔⵜ, ⵉ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉⵏ ⵛⴰ ⴰⵍ ⵍⵎⴻⵡⵜ. ⴰⵇⴰ ⴷⵉⵏ ⴰⵅⴻⵟⵟⵓ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵡⴰⵔ ⵇⵇⴰⵔⴻⵖ ⵛⴰ ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵥⵥⴰⴵ ⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("J15_17","092_5_17","1JN","5","17","17","ⵎⴰⵔⵔⴰ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ, ⴰⵇⴰ-ⵜⵜ ⴷ ⴷⴷⴻⵏⴱ ⵓⵛⴰ ⴰⵇⴰ ⴷⵉⵏ ⴷⴷⴻⵏⴱ ⵉ ⵡⴰⵔ ⵉⴵⵉⵏ ⵛⴰ ⴰⵍ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("J15_18","092_5_18","1JN","5","18","18","ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵉⵅⴻⵟⵟⵉ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵉⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵓ ⴰⵎⵄⴻⴼⴼⴰⵏ ⵡⴰⵔ ⵜ ⵉⵜⵜⵃⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("J15_19","092_5_19","1JN","5","19","19","ⵏⴻⵙⵙⴻⵏ, ⴰⵇⴰ ⴰⵏⴻⵖ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴷⴷⵓⵏⴻⵛⵜ ⵎⴰⵔⵔⴰ ⴰⵇⴰ-ⵜⵜ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏ ⵓⵎⵄⴻⴼⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("J15_20","092_5_20","1JN","5","20","20","ⵏⴻⵙⵙⴻⵏ ⴱⴻⵍⵍⵉ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵉⵡⵛⴰ ⴰⵏⴻⵖ-ⴷⴷ ⵍⴻⴼⵀⴰⵎⴻⵜ ⵃⵉⵎⴰ ⴰⴷ ⵏⴻⵙⵙⴻⵏ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵏⵉⵍⵉ ⴷⴻⴳ ⵡⴻⵏⵏⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ⴷⵉ ⵎⵎⵉⵙ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ⴷ ⵡⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵙ ⵜⵉⴷⴻⵜⵜ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("J15_21","092_5_21","1JN","5","21","21","ⴰ ⵉⵃⴻⵏⵊⵉⵔⴻⵏ ⵉⵏⵓ, ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ ⵣⴻⴳ ⵡⴻⵄⴱⴻⴷ ⵏ ⵍ’ⴰⵚⵏⴰⵎ! ");
INSERT INTO rift_vpl VALUES ("J21_1","093_1_1","2JN","1","1","1","ⴰⵎⵖⴰⵔ, ⵉ ⵜⵎⴻⵟⵟⵓⵜ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ, ⵉⵏⵏⵉ ⵜⵜⴻⵅⵙⴻⵖ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⵡⴰⵔ ⵉⴵⵉ ⵏⴻⵛⵛ ⵡⴰⵀⴰ, ⵎⴰⵛⴰ ⵄⴰⵡⴻⴷ ⵇⴰⵄ ⵉⵏⵏⵉ ⵉⵙⵙⵏⴻⵏ ⵜⵉⴷⴻⵜⵜ, ");
INSERT INTO rift_vpl VALUES ("J21_2","093_1_2","2JN","1","2","2","ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵜⵉⴷⴻⵜⵜ ⵉ ⴷⴰⵢⵏⴻⵖ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵓⵛⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵜⵉⵍⵉ ⵉ ⵍⴻⴱⴷⴰ: ");
INSERT INTO rift_vpl VALUES ("J21_3","093_1_3","2JN","1","3","3","ⴰⵔⴹⴰ ⴷ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍⴻⵀⵏⴰ ⴰⴷ ⴽⵉⴷⵏⴻⵖ ⵉⵍⵉⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⵓ ⵣⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⵎⵎⵉⵙ ⵏ ⴱⴰⴱⴰⵙ, ⴷⵉ ⵜⵉⴷⴻⵜⵜ ⵓ ⴷⵉ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("J21_4","093_1_4","2JN","1","4","4","ⴰⵇⴰ ⴼⴰⵔⵃⴻⵖ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵓⴼⵉⵖ ⵊⴰⵔ ⵜⴰⵔⵡⴰ ⵏⵏⴻⵎ ⵛⴰ ⵉⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⵉⴷⴻⵜⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏⵏⵉ ⵏⴻⴽⵙⵉ ⵣⵉ ⴱⴰⴱⴰⵜⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("J21_5","093_1_5","2JN","1","5","5","ⵓⵛⴰ ⵍⴻⵅⵅⵓ ⵜⵜᵉⵜⵜⴰⵔⴻⵖ ⴰⵎ, ⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ, ⵡⴰⵔ ⵉⴵⵉ ⴰⵅⵎⵉ ⴷ ⴰⵎ ⵓⵔⵉⵖ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵛⴰ ⵜⴻⵏⵏⵉ ⴰⵇⴰ-ⵜⵜ ⵖⴰⵔⵏⴻⵢ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ: ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵅⵙ ⴰⵢⴰⵡⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("J21_6","093_1_6","2JN","1","6","6","ⵜⴰ ⴷ ⵜⴰⵢⵔⵉ, ⴰⵇⴰ ⴰⴷ ⵏⵓⵢⵓⵔ ⵄⵍⴰⵃⵙⴰⴱ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ⵜⴰ ⴷ ⵜⴰⵡⵚⴻⵢⵢⴻⵜ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜⴻⵙⵍⵉⵎ ⵣⴻⴳ ⵓⵎⴻⵣⵡⴰⵔⵓ, ⴰⵇⴰ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵜⵓⵢⵓⵔⴻⵎ ⴷⴰⵢⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("J21_7","093_1_7","2JN","1","7","7","ⵎⵉⵏⵣⵉ ⴰⵟⵟⴰⵙ ⵏ ⵉⵅⴻⴷⴷⴰⵄⴻⵏ ⵓⴷⴼⴻⵏ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵛⴰ ⵉ ⵜⵡⴰⵙⵉⵜ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷⵉ ⴷⴷⴰⵜ. ⴷ ⵡⴰ ⴷ ⴰⵅⴻⴷⴷⴰⵄ ⴷ ⴰⵎⴹⵉⴷⴷ ⵏ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("J21_8","093_1_8","2JN","1","8","8","ⵃⴹⴰⵎ ⵉⵅⴻⴼ ⵏⵡⴻⵎ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵅⴻⵙⵙⴰⵔⴻⵎ ⵛⴰ ⵎⵉⵏ ⵅⴻⴼ ⵜⵅⴻⴷⵎⴻⵎ ⴽⴻⵏⵏⵉⵡ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴰⵡⵢⴻⵎ ⵍⵎⵓⵏⴻⵜ ⵜⵎⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("J21_9","093_1_9","2JN","1","9","9","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵅⴹⴰⵏ ⵓⵛⴰ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵛⴰ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵍⵎⴰⵙⵉⵃ, ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⴱⵓ ⴰⵔⴻⴱⴱⵉ ⴷⴻⴳ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ. ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏⵏⴻⵙ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⴱⴰⴱⴰⵙ ⴷ ⵎⵎⵉⵙ ");
INSERT INTO rift_vpl VALUES ("J21_10","093_1_10","2JN","1","10","10","ⵎⴰⵍⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵓⵛⴰ ⵡⴰⵔ ⴷⴷ-ⵢⵉⵡⵉ ⵛⴰ ⵜⴰⵖⵓⵔⵉ-ⵢⴰ, ⵅⴻⵏⵏⵉ ⵡⴰⵔ ⵜ ⵇⴻⴱⴱⵍⴻⵎ ⴷⵉ ⵜⴰⴷⴷⴰⵔⵜ ⵏⵡⴻⵎ, ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⴰⵔⴻⵃⵃⴱⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("J21_11","093_1_11","2JN","1","11","11","ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵢⴰⵔⴻⵃⵃⴱⴻⵏ, ⵖⴰⵔⴻⵙ ⴰⵎⵓⵏⵉ ⴰⴽ-ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("J21_12","093_1_12","2JN","1","12","12","ⴰⵇⴰ ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ ⵉ ⴷ ⴰⵡⴻⵎ ⵖⴰ ⴰⵔⵉⵖ, ⵎⴰⵛⴰ ⵜⵓⵖⴰ ⵡⴰⵔ ⵅⵙⴻⵖ ⴰⴷ ⵜ ⴰⵔⵉⵖ ⴷⵉ ⵜⴻⵡⵔⵉⵇⵜ ⵙ ⵙⵙⵎⴻⵅ, ⵎⴰⵛⴰ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⴽⵉⵡⴻⵎ ⵙⵙⵉⵡⵍⴻⵖ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵖⴰⵔ ⵓⵇⴻⵎⵎⵓⵎ, ⵃⵉⵎⴰ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵏⵏⴻⵖ ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⴽⵎⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("J21_13","093_1_13","2JN","1","13","13","ⵜⴰⵔⵡⴰ ⵏ ⵓⵍⵜⵎⴰⵎ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ, ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⵎ ⵙ ⵍⴻⵀⵏⴰ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("J31_1","094_1_1","3JN","1","1","1","ⴰⵎⵖⴰⵔ, ⵉ ⵅⴰⵢⵓⵙ ⵉⵄⵉⵣⵣⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵜⴻⵅⵙⴻⵖ ⴷⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J31_2","094_1_2","3JN","1","2","2","ⴰ ⴰⵎⵄⵉⵣⵣ ⵏⵏⴻⵖ, ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵜⵉⵍⵉⴷ ⵎⵍⵉⵃ ⴷⵉ ⵎⴰⵔⵔⴰ ⵓ ⴰⴷ ⵜⵉⵍⵉ ⵓⵍⴰ ⴷ ⵚⵚⴻⵃⵃⴻⵜ ⵏⵏⴻⵛ ⵎⵍⵉⵃ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉⵜⵜⵉⵍⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵛ ⴷ ⵍⴻⵎⵍⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("J31_3","094_1_3","3JN","1","3","3","ⵎⵉⵏⵣⵉ ⴼⴰⵔⵃⴻⵖ ⴰⵟⵟⴰⵙ, ⵍⴰⵎⵉ ⴷⴷ-ⵓⵙⵉⵏ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵛⴻⵀⴷⴻⵏ ⵅ ⵍⴰⵎⴰⵏ ⵉ ⴷⴰⵢⴻⴽ, ⵎⴰⵎⵎⴻⵛ ⵜⴻⴳⴳⵓⵔⴻⴷ ⴷⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J31_4","094_1_4","3JN","1","4","4","ⵡⴰⵔ ⵖⴰⵔⵉ ⵍⴻⴼⵔⴰⵃⴻⵜ ⵜⴻⵎⵖⴰⵔ ⵅ ⵜⴰ: ⴰⵇⴰ ⵙⵍⵉⵖ ⵜⴰⵔⵡⴰ ⵉⵏⵓ ⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J31_5","094_1_5","3JN","1","5","5","ⴰ ⴰⵎⵄⵉⵣⵣ ⵏⵏⴻⵖ, ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵉ ⵡⴰⵡⵎⴰⵜⴻⵏ, ⵜᵉⵜⵜⴻⴳⴳⴻⴷ ⵜ ⵙ ⵍ’ⵉⵎⴰⵏ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵉ ⵉⴱⴰⵔⵔⴰⵏⵉⵢⵢⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("J31_6","094_1_6","3JN","1","6","6","ⵉⵏⵏⵉ ⵉⵛⴻⵀⴷⴻⵏ ⵅ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵛ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵎⴰⵔⵔⴰ. ⵜⴻⴳⴳⵉⴷ ⵎⵍⵉⵃ ⵓⵎⵉ ⴷ ⴰⵙⴻⵏ ⵜⴻⵡⵛⵉⴷ ⴰⴼⵓⵙ ⴷⵉ ⵎⵉⵏ ⵀⴷⴰⵊⴻⵏ ⵏⵉⵜⵏⵉ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵢⴰⵔⴹⴰ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("J31_7","094_1_7","3JN","1","7","7","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴼⴼⵖⴻⵏ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵎ ⵡⴰⵔ ⴽⵙⵉⵏ ⵡⴰⵍⵓ ⵣⵉ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("J31_8","094_1_8","3JN","1","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵏⴻⵇⴱⴻⵍ ⵉⵡⴷⴰⵏ ⴰⵎ ⵏⵉⵜⵏⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵉⵍⵉ ⴷ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⴽⵉⴷⵙⴻⵏ ⵉ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J31_9","094_1_9","3JN","1","9","9","ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⴰⵔⵉⵖ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ, ⵎⴰⵛⴰ ⴷⵉⵢⵓⵜⵔⵉⴼⵓ, ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⵅⵙⴻⵏ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵊⴰⵔ ⴰⵙⴻⵏ, ⵡⴰⵔ ⴷ ⴰⵏⴻⵖ ⵉⵇⴱⵉⵍ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("J31_10","094_1_10","3JN","1","10","10","ⵙ ⵓⵢⴻⵏⵏⵉ ⵅⵎⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ, ⴰⴷ ⵜ ⵙⵙⵄⴻⵇⵍⴻⵖ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉ ⵉⵜⵜⴻⴳⴳ, ⵓⵎⵉ ⵅⴰⵏⴻⵖ ⵉⵜⵜⵃⴰⵔⵔⴻⴹ ⵍⴻⵀⵔⵓⴷ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ. ⵓ ⵍⴰⵎⵉ ⵡⴰⵔ ⴷ ⴰⵙ ⵉⵄⵊⵉⴱ ⵍⵃⴰⵔ ⵄⴰⴷ, ⵡⴰⵔ ⵉⵇⴱⵉⵍ ⴰⵡⵎⴰⵜⴻⵏ, ⵓ ⵉⵏⵏⵉ ⵜⴻⵏ ⵇⴻⴱⵍⴻⵏ, ⵉⵎⵎⵄⴰⵍⴰ ⴰⴽⵉⴷⵙⴻⵏ, ⵉⵙⵙⵓⴼⴼⴻⵖ ⵉ-ⵜⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("J31_11","094_1_11","3JN","1","11","11","ⴰ ⴰⵎⵄⵉⵣⵣ, ⵡⴰⵔ ⴹⴻⴼⴼⴰⵔ ⵛⴰ ⵜⵓⵄⴻⴼⴼⵏⴰ ⵎⴰⵛⴰ ⵜⵛⵓⵏⵉ! ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵛⵓⵏⵉ, ⵏⴻⵜⵜⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ. ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵡⴰⵔ ⵉⵥⵔⵉ ⵛⴰ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("J31_12","094_1_12","3JN","1","12","12","ⵎⴰⵔⵔⴰ ⵛⴻⵀⴷⴻⵏ ⵎⵍⵉⵃ ⵅ ⴷⵉⵎⵉⵜⵔⵉⵢⵓ ⵍⴰ ⴷ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵓⵍⴰ ⴷ ⵜⵉⴷⴻⵜⵜ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵏⴻⵛⵛⵉⵏ ⵏⵛⴻⵀⵀⴻⴷ ⵅⴰⵙ ⵎⵍⵉⵃ ⵓⵛⴰ ⵜⴻⵙⵙⵏⴻⵎ ⴱⴻⵍⵍⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵖ ⴷ ⵜⵉⴷⴻⵜⵜ. ");
INSERT INTO rift_vpl VALUES ("J31_13","094_1_13","3JN","1","13","13","ⴰⵇⴰ ⵖⴰⵔⵉ ⴰⵟⵟⴰⵙ ⵉ ⴷ ⴰⵛ ⴷⴷ ⵖⴰ ⴰⵔⵉⵖ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵅⵙⴻⵖ ⵛⴰ ⴰⴷ ⴰⵛ ⴷⴷ-ⴰⵔⵉⵖ ⵙ ⵙⵙⵎⴻⵅ ⴷ ⵍⴻⵇⵍⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("J31_14","094_1_14","3JN","1","14","14","ⵎⴰⵛⴰ ⵙⵙⵉⵜⵉⵎⴻⵖ ⴰⴷ ⵛⴻⴽ ⵥⴰⵔⴻⵖ ⴷⴻⵖⵢⴰ, ⵅⴻⵏⵏⵉ ⴰⴷ ⵏⴻⵙⵙⵉⵡⴻⵍ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵖⴰⵔ ⵡⵓⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("J31_15","094_1_15","3JN","1","15","15","ⵍⴻⵀⵏⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⴽⵉⴷⴻⴽ. ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵜⵜⵙⴻⴵⴰⵎⴻⵏ ⵅⴰⴽ ⵙ ⵍⴻⵀⵏⴰ. ⵙⴻⴵⴻⵎ ⵅ ⵉⵎⴻⴷⴷⵓⴽⴽⴰⵍ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JD1_1","095_1_1","JUD","1","1","1","ⵢⴰⵀⵓⴷⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴷ ⵓⵎⴰⵙ ⵏ ⵢⴰⵄⵇⵓⴱ. ⵉ ⵍⴻⴳⵏⵓⵙ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⵉⵣⵣⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ, ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵃⴹⴰⵏ ⵣⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("JD1_2","095_1_2","JUD","1","2","2","ⵉⵍⵉ ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜᵉⵎⵎⴰⵔⵏⵉ ⴰⵔⵔⴻⵃⵎⴻⵜ ⴷ ⵍⴻⵀⵏⴰ ⴷ ⵜⴰⵢⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("JD1_3","095_1_3","JUD","1","3","3","ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵓⵎⵉ ⵛⴻⵟⵟⴰⵔⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ ⵅ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵉⵎⵓⵏⴻⵏ, ⴰⵇⴰ ⵓⴼⵉⵖ ⴱⴻⵍⵍⵉ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⵢⵉ ⴰⴷ ⴰⵡⴻⵎ ⴷⴷ-ⴰⵔⵉⵖ ⵙ ⵓⵣⵉⵢⵢⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵎⵎⴻⵏⵖⴻⵎ ⵙ ⵊⵊⴻⵀⴷ ⵅ ⵍ’ⵉⵎⴰⵏ ⵉ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵉ ⵍⴻⴱⴷⴰ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JD1_4","095_1_4","JUD","1","4","4","ⵎⵉⵏⵣⵉ ⵛⴰ ⵏ ⵉⵡⴷⴰⵏ ⵅⵜⵓⵜⵜⵍⴻⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ, ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵉ ⵍⵃⵓⴽⵎ-ⴰ ⵇⴱⴻⵍ: ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⵉⵏⵏⵉ ⵉⴱⴻⴷⴷⵍⴻⵏ ⴰⵔⴹⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵏⵏⵄⵉ ⵏ ⵓⴼⵓⵛⵛⴻⵃ, ⵓⵛⴰ ⵏⴻⴽⴽⴰⵔⴻⵏ ⴰⵢⴻⵏⵏⵉ ⵏ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("JD1_5","095_1_5","JUD","1","5","5","ⵎⴰⵛⴰ ⵅⵙⴻⵖ ⴰⴷ ⴽⴻⵏⵏⵉⵡ ⵙⵙⵄⴻⵇⵍⴻⵖ, ⴰⵇⴰ ⵎⴰⵔⵔⴰ ⴽⴻⵏⵏⵉⵡ ⵜⴻⵙⵙⵏⴻⵎ ⵎⴰⵏ ⴰⵢⴰ ⵎⵍⵉⵃ, ⴱⴻⵍⵍⵉ ⴰⵔⴻⴱⴱⵉ, ⵓⵎⵉ ⵉⴼⴻⴽⴽ ⵍⴳⴻⵏⵙ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵎⵉⵚⵔⴰ, ⵜⵓⵖⴰ ⵉⵙⵙⵀⴻⵍⵍⴻⴽ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵢⵓⵎⵉⵏⴻⵏ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("JD1_6","095_1_6","JUD","1","6","6","ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵡⴰⵔ ⵃⴹⵉⵏⵜ ⴰⵡⴻⵇⵇⴰⵔ ⵏⵙⴻⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵛⴰ ⵊⵊⵉⵏⵜ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵉⵃⴹⴰ ⵅⴰⵙⴻⵏ ⵙ ⵙⵙⵏⴰⵙⴻⵍ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ ⵙⴰⴷⵓ ⵜⴰⴵⴻⵙⵜ ⵉ ⵍⵃⵓⴽⵎ ⵏ ⵡⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("JD1_7","095_1_7","JUD","1","7","7","ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵙⴰⴷⵓⵎ ⴷ ⵄⴰⵎⵓⵔⵔⴰ ⴷ ⵜⵏⴻⴷⴷⴰⵎ ⵉ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵎⴰⵏⵉ ⴳⴳⵉⵏ ⵏⵉⵜⵏⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵙ ⵡⴻⴱⵔⵉⴷ ⴷ ⵉⵊⵊⴻⵏ ⴰⵎ ⴳⴳⵉⵏⵜ ⵜⵉⵏⴰ ⵙ ⵜⵏⴰⵢⴻⵏ ⵓ ⴹⴼⴰⵔⴻⵏⵜ ⴷⴷⴰⵜ ⵏⵏⴻⵖⵏⵉ, ⴰⵇⴰ ⵜⵜⵡⴰⵎⵎⴰⵔⵙⴻⵏⵜ ⴷ ⵉⵎⴻⴷⵢⴰ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⴷⵓⵎⴰⵏ, ⵜⵜⵡⴰⵃⴻⴽⵎⴻⵏⵜ ⵖⴰⵔ ⵛⵛⵔⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("JD1_8","095_1_8","JUD","1","8","8","ⴰⵎⴻⵏⵏⵉ ⵄⴰⵡⴻⴷ ⵉ ⵖⴰ ⵀⴻⵍⵍⴽⴻⵏ ⵉⵏⴰ, ⵉⵏⵏⵉ ⵉⵙⵙⴻⵅⵎⴰⵊⴻⵏ ⴷⴷⴰⵜ ⴰⵎ ⴷⴷ-ⵜⵜⴰⴷⴼⴻⵏ ⴷⵉ ⵜⵉⵔⵊⴰ, ⵉⵏⵏⵉ ⵉⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵓⵛⴰ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⴻⴳ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("JD1_9","095_1_9","JUD","1","9","9","ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵜⵓⵖⴰ ⵉⵙⵙⴰⵡⴰⵍ ⵎⵉⵅⴰⵢⵉⵍ, ⴰⵣⴻⴵⵉⴼ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⴰⴽ-ⴷ ⵉⴱⵍⵉⵙ ⵅ ⴰⵔⵔⵉⵎⴻⵜ ⵏ ⵎⵓⵙⴰ, ⵡⴰⵔ ⵅⴰⵙ ⵉⵃⴽⵉⵎ ⵙ ⵉⵊⵊ ⵏ ⵍⵃⵓⴽⵎ ⵉⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ, ⵎⴰⵛⴰ ⵉⵏⵏⴰ: “ⵙⵉⴷⵉ ⴰⴷ ⵛⴻⴽ ⵉⵅⴻⴵⴻⵚ!” ");
INSERT INTO rift_vpl VALUES ("JD1_10","095_1_10","JUD","1","10","10","ⵎⴰⵛⴰ ⵉⵏⴰ ⵜⵜⵛⴻⵇⵇⴰⴼⴻⵏ ⴷⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ, ⵓⵛⴰ ⵙ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵉ ⵖⴰⵔ ⵜⵜⵡⴰⵊⴻⴱⴱⴷⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵎ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⴳⵏⴰⵡⴻⵏ ⵄⵍⴰⵃⵙⴰⴱ ⵟⵟⴱⵉⵄⴻⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴰⵔⴻⴷⴷⴵⴻⵏ ⵏⵉⵜⵏⵉ ⵉⵅⴻⴼ ⵏⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("JD1_11","095_1_11","JUD","1","11","11","ⵓⵛⵜ ⵅⴰⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵓⵢⵓⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵇⴰⵢⵉⵏ ⵓⵛⴰ ⵓⵎⵉ ⵜⵜⵎⴻⵥⵔⴻⵏ ⴷⵉ ⵍⵎⵓⵏⴻⵜ ⴹⴼⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵖⴻⴽⴽⵡⵉ ⵏ ⴱⴰⵍⵄⴰⵎ ⵓ ⵜⵜⵡⴰⵀⴻⵍⴽⴻⵏ ⴷⴻⴳ ⵓⵖⴻⵡⵡⴻⵖ ⵏ ⴽⵓⵔⴰⵅ. ");
INSERT INTO rift_vpl VALUES ("JD1_12","095_1_12","JUD","1","12","12","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⵙⵙⴼⴻⵟⵟⴰⵃⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵙ ⵓⵏⴻⵛⵡⴻⵜ ⵏⵙⴻⵏ, ⵡⴰⵔ ⵜⵜⵙⴻⴹⵃⵉⵏ ⵛⴰ ⴰⴷ ⵖⴻⴱⴱⴰⵏ. ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⴱⵍⴰ ⴰⵏⵥⴰⵔ, ⵜⵜⵡⴰⵄⴰⵔⵔⵏⴻⵏ ⵣⵉ ⵙⵙⴰ ⵖⴰⵔ ⴷⵉⵀⴰ ⵙ ⵓⵙⴻⵎⵎⵉⴹ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⵏⵏⵉ ⴷⵉ ⵜⴻⴵⴰ ⵍⵖⵉⴵⴻⵜ ⵏⵙⴻⵏⵜ ⵜⵡⴻⴷⴷⴰⵔ, ⴰⵇⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏⵜ ⵜⴻⴵⵉ ⴱⵓ ⵍⵖⵉⴵⴻⵜ, ⵎⵎⵓⵜⴻⵏⵜ ⵡⵉⵙⵙ ⵎⴰⵔⵜⴰⵢⴻⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵇⴻⵍⵄⴻⵏⵜ ⵣⴻⴳ ⵉⵥⴻⵡⵔⴰⵏ ⵏⵙⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("JD1_13","095_1_13","JUD","1","13","13","ⵏⵉⵜⵏⵉ ⴷ ⵍⴻⵎⵡⴰⵊ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉⵀⴰⵊⴻⵏ, ⵉⵏⵏⵉ ⵉⵙⵙⵓⵙⵓⴼⴻⵏ ⵉⴽⵓⴼⴼⴰⵏ ⵏ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏⵙⴻⵏ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵉⵜⵔⴰⵏ ⵡⴻⴷⴷⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵡⵊⴻⴷ ⵜⵓⴱⴱⴰⵔⵛⴻⵏⵜ ⵏ ⵜⴰⴵⴻⵙⵜ ⵉ ⵍⴻⴱⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("JD1_14","095_1_14","JUD","1","14","14","ⵎⴰⵛⴰ ⵃⴰⵏⵓⵅ, ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵣⵉ ⴰⴷⴰⵎ, ⵉⵏⴻⴱⴱⴰ ⵅⴰⵙⴻⵏ, ⵉⵏⵏⴰ: “ⵅⵣⴰⵔ, ⵙⵉⴷⵉ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴽ-ⴷ ⵍⵓⵍⵓⴼ ⵏ ⵍⵓⵍⵓⴼ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("JD1_15","095_1_15","JUD","1","15","15","ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⵍⵃⵓⴽⵎ ⵏⵏⴻⵙ ⵅ ⵎⴰⵔⵔⴰ ⵉⵡⴷⴰⵏ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⴳⴳⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⵓⵄⴻⴼⴼⵏⴰ, ⵓ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ ⵉⵇⴻⵙⵃⴻⵏ ⵉ ⵣⵉ ⵙⵙⵉⵡⵍⴻⵏ ⵉⵎⴻⴷⵏⴰⴱ ⵉⵖⴻⵛⵛⴰⵛⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("JD1_16","095_1_16","JUD","1","16","16","ⵉⵏⴰ ⵜⵜⵄⴻⴽⴽⴰⵙⴻⵏ, ⵜⵜⵛⴻⵜⵛⴰⵏ ⵅ ⴽⵓⵍ ⴷⴷⴰⴱ ⵏ ⵙⵙⵉⴱⴱⴻⵜ, ⴰⵎ ⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵙⴻⵏ, ⴰⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵉⵙⵙⴰⵡⴰⵍ ⵙ ⵜⵎⴻⵙⵍⴰⵢⵉⵏ ⵜⵉⵄⴻⴼⴼⴰⵏⵉⵏ ⴰⵍ ⵟⵟⴰⵔⴼ, ⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵇⴻⴷⴷⵓⵃⵉⵏ ⵉ ⵉⵡⴷⴰⵏ ⵉ ⵜⵉⵣⵉ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JD1_17","095_1_17","JUD","1","17","17","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵄⴻⵇⵍⴻⵎ ⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵣⵣⴰⵔ ⵙⵙⵉⵡⵍⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵔⵔⵓⵙⵓⵍ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ");
INSERT INTO rift_vpl VALUES ("JD1_18","095_1_18","JUD","1","18","18","ⵉⵏⵏⵉ ⴷ ⴰⵡⴻⵎ ⵉⵏⵏⴰⵏ, ⴰⵇⴰ ⴷⴻⴳ ⵓⵏⴻⴳⴳⴰⵔ ⵏ ⵣⵣⵎⴰⵏⴰⵜ ⴰⴷ ⴷⵉⵏ ⵉⵍⵉⵏ ⵉⵎⴻⵙⵜⴻⵀⵣⴰⵢⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⴹⴼⴰⵔⴻⵏ ⵍⴻⵇⵊⴰⵀⴻⵜ ⵄⵍⴰⵃⵙⴰⴱ ⵏⵏⴻⵛⵡⴰⵜ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("JD1_19","095_1_19","JUD","1","19","19","ⴰⵇⴰ ⴷ ⵢⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵉⴼⴰⵔⵔⵣⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⵎ ⵉⵡⴷⴰⵏ ⵉⴹⴻⴼⴼⴰⵔⴻⵏ ⵟⵟⴱⵉⵄⴻⵜ ⵏ ⵢⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵡⴰⵔ ⵖⴰⵔⵙⴻⵏ ⴱⵓ ⴰⵔⵔⵓⵃ. ");
INSERT INTO rift_vpl VALUES ("JD1_20","095_1_20","JUD","1","20","20","ⵎⴰⵛⴰ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵄⵉⵣⵣⴻⵏ ⵉⵏⵓ, ⵜⵜⵡⴰⴱⵏⴰⵎ ⵣⴻⴳ ⵓⵣⴻⴵⵉⴼ ⴷⵉ ⵍ’ⵉⵎⴰⵏ ⵏⵡⴻⵎ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵙ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵎ ⵜⴻⵥⵥⴰⴵⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("JD1_21","095_1_21","JUD","1","21","21","ⴻⵊⵊ ⴰⵏⴻⵖ ⴰⴷ ⵏⴻⵃⴹⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵖ ⴷⵉ ⵜⴰⵢⵔⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵎ ⵏᵉⵜⵜⵔⴰⵊⴰ ⴰⵔⵔⴻⵃⵎⴻⵜ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⵜⵓⴷⴰⵔⵜ ⵏⵏⴻⵖ ⵉⵜⵜⴷⵓⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("JD1_22","095_1_22","JUD","1","22","22","ⵇⴻⵍⵄⴻⵎ ⵛⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵣⵉ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("JD1_23","095_1_23","JUD","1","23","23","ⵎⴰⵍⴰ ⵜⵓⴱⴻⵏ ⵏⵉⵜⵏⵉ, ⵙⴻⵛⵏⴻⵎ ⴰⵙⴻⵏ ⴰⵔⵔⴻⵃⵎⴻⵜ, ⵎⴰⵛⴰ ⴰⴽ-ⴷ ⵜⵉⴳⴳⵯⵓⴷⵉ, ⵡⴰⵀ, ⵄⵉⴼⴼⴻⵎ ⵄⴰⴷ ⵣⵉ ⵜⵛⴰⵎⵉⵔ ⵉ ⵉⵜⵜⵡⴰⵙⵙⵅⴻⵎⵊⴻⵏ ⵣⴻⴳ ⵡⴻⵢⵙⵓⵎ. ");
INSERT INTO rift_vpl VALUES ("JD1_24","095_1_24","JUD","1","24","24","ⵎⴰⵛⴰ ⵉ ⵏⴻⵜⵜⴰ, ⵡⴻⵏⵏⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴰⵏⴻⵖ ⵉⵃⴹⴰ ⴱⵍⴰ ⴰⵏⴻⵇⵍⴰⴹ ⵓ ⴱⵍⴰ ⵍⴻⵅⵎⴻⵊ ⵓ ⵡⴻⵏⵏⵉ ⴰⴷ ⴰⵏⴻⵖ ⵢⴻⴳⴳ ⴰⴷ ⵏⴱⴻⴷⴷ ⵏⵉⵛⴰⵏ ⴱⵍⴰ ⵍⵄⵉⴱ ⵣⵣⴰⵜ ⵉ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵙ ⵍⴻⴼⵔⴰⵃⴻⵜ ");
INSERT INTO rift_vpl VALUES ("JD1_25","095_1_25","JUD","1","25","25","- ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⴷ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵃⵃⴷⴻⵙ, ⴰⵎⵙⴻⵏⵊⴻⵎ ⵏⵏⴻⵖ - ⴰⵇⴰ ⵉ ⵏⴻⵜⵜⴰ ⴷⴷ-ⵉⵜⵜⴰⵙ ⵓⵙⴻⵎⵖⴰⵔ ⴷ ⵍⵄⴻⵣⵣ ⴷ ⵛⵛⴰⵏ ⴷ ⵍⵄⴰⴹⴰⵎⴰ, ⴰⵎ ⵍⴻⵅⵅⵓ ⴰⵎ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RV1_1","096_1_1","REV","1","1","1","ⴰⵙⴰⵔⴳⴰⴱ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵉ ⴷ ⴰⵙ ⵉⵡⵛⴰ ⴰⵔⴻⴱⴱⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⵉⵏ ⵉⵜⵜⵅⴻⵚⵚⴰ ⴰⴷ ⵉⵎⵙⴰⵔ ⴷⴻⵖⵢⴰ, ⵓⵛⴰ ⵉⵙⵙⴰⵔⴳⴻⴱ ⵉ-ⵜ ⴰⵎ ⵜ ⵉⵙⵙⴻⴽⴽ ⵙ ⵓⴼⵓⵙ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ ⵉ ⵓⵎⵙⴻⵅⵅⴰⵔ ⵏⵏⴻⵙ ⵢⵓⵃⴰⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RV1_2","096_1_2","REV","1","2","2","ⵡⴰⵏⵉⵜⴰ ⵉⵛⵀⴻⴷ ⵅ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵣⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵉⵥⵔⴰ, ");
INSERT INTO rift_vpl VALUES ("RV1_3","096_1_3","REV","1","3","3","ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⵏⵏⵓⴱⵓⵡⴰ-ⵢⴰ ⵓ ⵇⵇⵉⵎⴻⵏ ⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⵉ ⵎⵉⵏ ⴷⴰⵢⵙⴻⵏ ⵢⵓⵔⴰⵏ, ⵎⴰⵖⴰⵔ ⴰⵇⴰ ⵍⵡⴻⵇⵜ ⵜⵉⵡⴻⴹ-ⴷⴷ. ");
INSERT INTO rift_vpl VALUES ("RV1_4","096_1_4","REV","1","4","4","ⵢⵓⵃⴰⵏⵏⴰ, ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⴷⵉ ⴰⵙⵉⵢⴰ: ⴰⴷ ⴽⵉⴷⵡⴻⵎ ⵢⵉⵍⵉ ⴰⵔⴹⴰ ⴷ ⵍⴻⵀⵏⴰ ⵣⴻⴳ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⵓⵍⴰ ⵣⵉ ⵙⴻⴱⵄⴰ ⵏ ⴰⵔⵔⵓⵃⴰⵜ ⵏⵏⵉ ⵉⴵⴰⵏ ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RV1_5","096_1_5","REV","1","5","5","ⵓ ⵣⵉ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ, ⴰⵛⴻⵀⵀⴰⴷ ⴰⵎⵜⵉⵇⵇⵉ, ⴰⵎⴻⵏⵣⵓ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵉ ⵡⴻⵏⵏⵉ ⴷ ⴰⵏⴻⵖ ⵉⵜⵜⴻⵅⵙⴻⵏ ⵓ ⴷ ⴰⵏⴻⵖ ⵉⴼⴻⴽⴽⴻⵏ ⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵖ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RV1_6","096_1_6","REV","1","6","6","ⴷ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵔ ⴰⵏⴻⵖ ⴷ ⵉⵛⵜ ⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⴷ ⴱⴰⴱⴰⵙ, ⵉ ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⴻⵙ ⵢⵉⵍⵉ ⵓⵄⵓⴵⵉ ⴷ ⵚⵚⵓⵍⵟⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("RV1_7","096_1_7","REV","1","7","7","ⵅⵣⴰⵔ, ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ ⴰⴽ-ⴷ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ, ⴽⵓⵍ ⵜⵉⵟⵟ ⴰⴷ ⵜ ⵜⵥⴰⵔ, ⵓⵍⴰ ⴷ ⵉⵏⵏⵉ ⵜ ⵉⵙⵙⵏⵓⵇⵇⴱⴻⵏ. ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵅⴰⵙ ⵡⵜⴻⵏⵜ ⴰⴳⴻⵊⴷⵓⵔ. ⵡⴰⵀ, ⴰⵎⵉⵏ! ");
INSERT INTO rift_vpl VALUES ("RV1_8","096_1_8","REV","1","8","8","ⵏⴻⵛⵛ ⴷ ⴰⵍⵉⴼ ⴷ ⵜⴰⵡ, ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵓⵏⴻⴳⴳⴰⵔⵓ, ⵉⵇⵇⴰⵔ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("RV1_9","096_1_9","REV","1","9","9","ⵏⴻⵛⵛ, ⵢⵓⵃⴰⵏⵏⴰ, ⵓⵎⴰⵜⵡⴻⵎ ⴷ ⵓⵎⵄⴰⵛⴰⵔ ⵏⵡⴻⵎ ⴷⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵓ ⴷⵉ ⵚⵚⴱⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵢⴰⵙⵓⵄ, ⵜⵓⵖⴰ ⴰⵢⵉ ⴷⵉ ⵜⴻⴳⵣⵉⵔⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⴱⴰⵜⵎⵓⵙ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ. ");
INSERT INTO rift_vpl VALUES ("RV1_10","096_1_10","REV","1","10","10","ⵓⵙⵉⵖ-ⴷⴷ ⴷⵉ ⴰⵔⵔⵓⵃ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵙⵙⵉⵎⴰⵏⴰ ⵓⵛⴰ ⵙⵍⵉⵖ ⴰⵡⴰⵔⵏⵉ ⴰⵢⵉ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⴰⵎ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵓⵛⴰⵔⵔⵉ,    ");
INSERT INTO rift_vpl VALUES ("RV1_11","096_1_11","REV","1","11","11","ⵜⴻⵇⵇⴰⵔ: “ⵎⵉⵏ ⵜᵉⵜⵜⵡⴰⵍⵉⴷ, ⴰⵔⵉ ⵜ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ, ⵙⵙⴻⴽⴽ ⵉ-ⵜⵜ-ⵉ-ⴷⴷ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ: ⵖⴰⵔ ⴰⴼⴰⵙⵓⵙ, ⵖⴰⵔ ⵙⵎⵉⵔⵏⴰ, ⵖⴰⵔ ⴱⵉⵔⵖⴰⵎⵓⵙ, ⵖⴰⵔ ⵜⵉⵢⴰⵜⵉⵔⴰ, ⵖⴰⵔ ⵙⴰⵔⴷⵉⵙ, ⵖⴰⵔ ⴼⵉⵍⴰⴷⵉⵍⴼⵉⵢⴰ ⵓⵛⴰ ⵖⴰⵔ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV1_12","096_1_12","REV","1","12","12","ⵅⴻⵏⵏⵉ ⵏⵏⵇⴻⵍⴱⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⵏⴻⵖ ⵡⵉ ⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ. ⴰⵍⴰⵎⵉ ⵏⵏⵇⴻⵍⴱⴻⵖ, ⵥⵔⵉⵖ ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV1_13","096_1_13","REV","1","13","13","ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵉⵊⵊⴻⵏ ⴰⵎ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⴰⴱⴰⵍⵟⵓ ⵏ ⵓⴽⴻⵀⵀⴰⵏ ⵓ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵉⴷⵎⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV1_14","096_1_14","REV","1","14","14","ⴰⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴷ ⵓⵛⵓⵡⵡⴰⴼ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ ⴰⵎ ⵜⴰⴹⵓⴼⵜ, ⴰⵎ ⵡⴻⴷⴼⴻⵍ, ⵓⵛⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ, ");
INSERT INTO rift_vpl VALUES ("RV1_15","096_1_15","REV","1","15","15","ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵏⵏⵃⴰⵙ ⵣⵉ ⵍⵓⴱⵏⴰⵏ, ⵉⵃⵎⴰⵏ ⴷⴻⴳ ⵓⴼⴰⵔⵔⴰⵏ, ⵓ ⵍⵃⴻⵙⵙ ⵏⵏⴻⵙ ⴰⵎ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV1_16","096_1_16","REV","1","16","16","ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵜⵔⴰⵏ ⵓⵛⴰ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵉⵜⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵍⴰⵏⵙⴰ ⵉⵇⴹⴻⵄ ⵓⵛⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴰⵎ ⵜⴼⵓⵛⵜ ⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV1_17","096_1_17","REV","1","17","17","ⴰⵍⴰⵎⵉ ⵜ ⵥⵔⵉⵖ, ⵡⴹⵉⵖ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵎⵎⵓⵜⴻⵖ ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⴰⵔⵙ ⵅⴰⴼⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ, ⵉⵏⵏⴰ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ! ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵓⵏⴻⴳⴳⴰⵔⵓ, ");
INSERT INTO rift_vpl VALUES ("RV1_18","096_1_18","REV","1","18","18","ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ, ⵓ ⵏⴻⵛⵛ ⵜⵓⵖⴰ ⵎⵎⵓⵜⴻⵖ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ! ⴰⵇⴰ ⵖⴰⵔⵉ ⵜⵙⴰⵔⵓⵜ ⵏ ⵍⵎⴻⵡⵜ ⴷ ⵍⴰⵅⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV1_19","096_1_19","REV","1","19","19","ⵙ ⵓⵢⴻⵏⵏⵉ ⴰⵔⵉ ⵎⵉⵏ ⵜⴻⵥⵔⵉⴷ ⵓⵍⴰ ⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵎⵙⴰⵔⴻⵏ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("RV1_20","096_1_20","REV","1","20","20","ⴰⵇⴰ ⵙⵙⵉⵔⵔ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵜⵔⴰⵏ ⵉ ⵜⴻⵥⵔⵉⴷ ⴷⴻⴳ ⵓⴼⵓⵙ ⵉⵏⵓ ⴰⴼⵓⵙⵉ ⵓ ⵙⵙⵉⵔⵔ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵡⴰ: ⵙⴻⴱⵄⴰ ⵏ ⵉⵜⵔⴰⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ ⵓⵛⴰ ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV2_1","096_2_1","REV","2","1","1","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴰⴼⴰⵙⵓⵙ! “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵙⴻⴱⵄⴰ ⵏ ⵉⵜⵔⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵓⵔⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵙⴻⴱⵄⴰ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵏ ⵡⵓⵔⴻⵖ: ");
INSERT INTO rift_vpl VALUES ("RV2_2","096_2_2","REV","2","2","2","‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⴷ ⵡⴰⵔⴱⴰⵔ ⵏⵏⴻⵛ ⴷ ⵚⵚⴱⴰⵔ ⵏⵏⴻⵛ, ⴱⴻⵍⵍⵉ ⵡⴰⵔ ⵜⵣⴻⵎⵎⴰⵔⴻⴷ ⴰⴷ ⵜⵃⴻⵎⵍⴻⴷ ⵉⵏⵏⵉ ⵉⵄⴻⴼⴼⵏⴻⵏ ⵓⵛⴰ ⵜⵇⴻⴵⴱⴻⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷ ⵔⵔⵓⵙⵓⵍ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ, ⵓⵛⴰ ⵜⵓⴼⵉⴷ ⵜⴻⵏ ⴷ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV2_3","096_2_3","REV","2","3","3","ⵛⴻⴽ ⵜⵚⴻⴱⴱⴰⵔⴻⴷ ⵓ ⵜⴻⴽⵙⵉⴷ ⴰⵔⵎⴻⵃ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓ ⵡⴰⵔ ⵜⵓⵃⵉⵍⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("RV2_4","096_2_4","REV","2","4","4","ⵎⴰⵛⴰ ⵖⴰⵔⵉ ⵅⴰⴽ ⵛⴰ, ⴱⴻⵍⵍⵉ ⵜⴻⵊⵊⵉⴷ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵛ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("RV2_5","096_2_5","REV","2","5","5","ⵄⵇⴻⵍ ⵎⴰⵏⵉⵙ-ⴷⴷ ⵜⴻⵡⴹⵉⴷ ⵓⵛⴰ ⵜⵓⴱ, ⵅⴻⵏⵏⵉ ⴻⴳⴳ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ! ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ, ⴰⴷ ⴽⴻⵙⵙⴻⵖ ⵍⵇⴻⵏⴷⵉⵍ ⵏⵏⴻⵛ, ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵓⴱⴻⴷ ⵛⴰ. ");
INSERT INTO rift_vpl VALUES ("RV2_6","096_2_6","REV","2","6","6","ⵎⴰⵛⴰ ⵎⴰⵏ ⴰⵢⴰ ⵜⵉⵡⴹⴻⴷ, ⴰⵇⴰ ⵜⵛⴰⵔⵔⵀⴻⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏ ⴰⵢⵜ ⵏ ⵉⵏⵉⴽⵓⵍⴰⵢⵉⵜⴻⵏ, ⵜⵉⵏⵏⵉ ⵛⴰⵔⵔⵀⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ.    ");
INSERT INTO rift_vpl VALUES ("RV2_7","096_2_7","REV","2","7","7","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ. ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⴰⴷ ⵜ ⵙⵙⴻⵛⵛⴻⵖ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵉ ⵢⴻⴵⴰⵏ ⴷⵉ ⵊⵊⴻⵏⵏⴻⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.’”    ");
INSERT INTO rift_vpl VALUES ("RV2_8","096_2_8","REV","2","8","8","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⵎⵉⵔⵏⴰ! “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵓⵏⴻⴳⴳⴰⵔⵓ, ⵡⴻⵏⵏⵉ ⵉⵎⵎⵓⵜⴻⵏ ⵓⵛⴰ ⵉⴷⴷⴰⵔ: ");
INSERT INTO rift_vpl VALUES ("RV2_9","096_2_9","REV","2","9","9","‘ⴰⵇⴰ ⵙⵙⵏⴻⵖ ⵍⵎⴻⵃⵏⴻⵜ ⵏⵏⴻⵛ ⴷ ⵡⴻⵣⵍⴰⴹ ⵏⵏⴻⵛ, ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵛⴻⴽ ⵜᵉⵜⵜⴻⵊⵊⴰⵔⴻⴷ, ⵓ ⴰⵇⴰ-ⵢⵉ ⵙⵙⵏⴻⵖ ⵓⵍⴰ ⴷ ⴰⵛⴻⵇⵇⴻⴼ ⵏ ⵢⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵓⴷⴰⵢⴻⵏ ⵙ ⵜⵉⴷⴻⵜⵜ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴷ ⵓⴷⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⴷ ⵜⴰⵎⵣⵉⴷⴰ ⵏ ⵛⵛⵉⵟⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV2_10","096_2_10","REV","2","10","10","ⵡⴰⵔ ⵜⵜⴻⴳⴳⵯⴻⴷ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⵖⴰ ⵜᵉⵜⵜⵡⴰⵄⴻⴷⴷⴱⴻⴷ. ⴰⵇⴰ ⵉⴱⵍⵉⵙ ⴰⴷ ⵉⵏⴹⴰⵔ ⵛⴰ ⵣⵣⴰⵢⵡⴻⵎ ⴷⵉ ⵍⴻⵃⴱⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵊⴰⵔⵔⴱⴻⵎ. ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⵜⵉⵍⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵏ ⵄⴻⵛⵔⴰ ⵏ ⵡⵓⵙⵙⴰⵏ. ⵉⵍⵉⵎ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵍⴻⵅⴷⴻⵏⵏⵉ ⴰⴷ ⴰⵡⴻⵎ ⵡⵛⴻⵖ ⵜⵜⴰⵊ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV2_11","096_2_11","REV","2","11","11","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ. ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⵡⴰⵔ ⴷ ⴰⵙ ⴷⴷ-ⵜᵉⵜⵜⵉⵡⵉ ⵛⴰ ⵜⵅⴻⵙⵙⴰⵔⵜ ⵣⵉ ⵍⵎⴻⵡⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RV2_12","096_2_12","REV","2","12","12","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴱⵉⵔⵖⴰⵎⵓⵙ! “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵙⵙⵉⴼ ⵉⵇⴹⴻⵄ ⵅ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⴷⵎⴰⵡⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("RV2_13","096_2_13","REV","2","13","13","‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵎⴰⵏⵉ ⵜⵣⴻⴷⴷⵖⴻⴷ, ⴷⵉⵀⴰ ⵎⴰⵏⵉ ⵉⵜⵜⴱⴻⴷⴷⴰ ⵍⵄⴰⵔⵛ ⵏ ⵛⵛⵉⵟⴰⵏ. ⴰⵇⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵜᵉⵟⵟⴼⴻⴷ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵉⵏⵓ ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵛⴰ ⵍ’ⵉⵎⴰⵏ ⴷⴰⵢⵉ, ⵓⵛⴰ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵓⵎⵉ ⵜⵓⵖⴰ ⵛⴻⴽ ⵜᵉⵜⵜⵎⴻⵏⵖⴻⴷ ⵊⵎⵉⵄ ⴰⴽ-ⴷ ⵓⵛⴻⵀⵀⴰⴷ ⴰⵎⵜⵉⵇⵇⵉ ⵉⵏⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵎⴰⵔⵔⴰ ⵉⵛⴻⵀⵀⴰⴷⴻⵏ ⵉⵏⵓ ⵉⵎⵜⵉⵇⵇⴰⵏ, ⴰⵇⴰ ⵉⵜⵜⵡⴰⵏⴻⵖ ⵏⴻⵜⵜⴰ ⵊⴰⵔ ⴰⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RV2_14","096_2_14","REV","2","14","14","ⵎⴰⵛⴰ ⵖⴰⵔⵉ ⵅⴰⴽ ⵛⴰ, ⵎⵉⵏⵣⵉ ⵖⴰⵔⴻⴽ ⴷⵉⵏⵏⵉ ⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ ⵏ ⴱⴰⵍⵄⴰⵎ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵙⵙⵍⴻⵎⴷⴻⵏ ⵉ ⴱⴰⵍⴰⴽ ⵎⴰⵎⵎⴻⵛ ⵖⴰ ⵉⵏⴹⴰⵔ ⵜⴰⵄⴻⵏⴽⵔⵉⴼⵜ ⵉ ⴰⵢⵜ ⵏ ⵉⵙⵔⴰⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵛⵛⴻⵏ ⵣⵉ ⵎⵉⵏ ⵖⴰⵔⵚⴻⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ ⵓⵛⴰ ⴰⴷ ⵙⴻⴼⵙⵙⴰⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV2_15","096_2_15","REV","2","15","15","ⵖⴰⵔⴻⴽ ⴷⵉⵏ ⵄⴰⵡⴻⴷ ⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵖⵓⵔⵉ ⵏ ⵉⵏⵉⴽⵓⵍⴰⵢⵉⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV2_16","096_2_16","REV","2","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ ⵜⵓⴱ! ⵎⴰⵍⴰ ⵡⴰⵔ ⵉⴵⵉ ⴰⵎⴻⵏⵏⵉ, ⴰⴷ ⵖⴰⵔⵡⴻⵎ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ, ⴰⴷ ⴽⵉⵙⴻⵏ ⵎⵎⴻⵏⵖⴻⵖ ⵙ ⵙⵙⵉⴼ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RV2_17","096_2_17","REV","2","17","17","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ. ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵛⴻⵖ ‘ⵎⴰⵏⵏⴰ’ ⵉⵏⵏⵓⴼⴰⵔⴻⵏ ⵓⵛⴰ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵉⵊⵊ ⵏ ⵓⵇⴰⵢⴰⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵓⵛⴰ ⵅ ⵓⵇⴰⵢⴰⵙ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵔⵉ ⵅⴰⵙ ⵉⵊⵊ ⵏ ⵉⵙⴻⵎ ⵏ ⵊⴷⵉⴷ, ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ ⵃⴻⴷ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵜ ⵉⵟⵟⴼⴻⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RV2_18","096_2_18","REV","2","18","18","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵜⵉⵢⴰⵜⵉⵔⴰ! “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⴰⵎ ⵢⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵏⵏⵃⴰⵙ ⵣⵉ ⵍⵓⴱⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("RV2_19","096_2_19","REV","2","19","19","‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵓⵍⴰ ⴷ ⵜⴰⵢⵔⵉ ⵏⵏⴻⵛ ⴷ ⵍ’ⵉⵎⴰⵏ ⵏⵏⴻⵛ ⴷ ⵜⵙⴻⵅⵅⴰⵔⵜ ⵏⵏⴻⵛ ⴷ ⵚⵚⴱⴰⵔ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ ⵉⵎⵖⴰⵔⴻⵏ ⵅ ⵜⵎⴻⵣⵡⵓⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RV2_20","096_2_20","REV","2","20","20","ⵎⴰⵛⴰ ⵖⴰⵔⵉ ⵅⴰⴽ ⴰⵟⵟⴰⵙ, ⵎⵉⵏⵣⵉ ⵜⴻⵊⵊⵉⴷ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵏⵏⴻⵛ ⵉⵣⴰⴱⵉⵍ, ⵜⴻⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵏⴰⴱⵉⵜ, ⵜⴻⵙⵙⴻⵍⵎⴰⴷ ⵓⵛⴰ ⵜⴻⵙⵙⵖⴻⴽⴽⵯⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵏⵓ, ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵛⵛⴻⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⵏ ⵉ ⵍ’ⴰⵚⵏⴰⵎ. ");
INSERT INTO rift_vpl VALUES ("RV2_21","096_2_21","REV","2","21","21","ⴰⵇⴰ ⵡⵛⵉⵖ ⴰⵙ ⵛⴰ ⵏ ⵍⵡⴻⵇⵜ ⵃⵉⵎⴰ ⴰⴷ ⵜᵉⵜⵓⴱ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰⵜ ⵡⴰⵔ ⵜᵉⵜⵜⴻⵅⵙ ⵛⴰ ⴰⴷ ⵜᵉⵜⵓⴱ ⵣⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV2_22","096_2_22","REV","2","22","22","ⵅⵣⴰⵔ, ⴰⴷ ⵜⵜ ⵖⴻⴹⵍⴻⵖ ⴷⵉ ⵜⴰⵙⵙⵓⵜ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵃⵍⴻⵛ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵓⵛⴰ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⵣⴻⵏⵏⴰⵏ, ⴰⴷ ⵜⴻⵏ ⵏⴻⴷⵀⴻⵖ ⴷⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵛⴰ ⵣⵉ ⵎⵉⵏ ⴳⴳⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RV2_23","096_2_23","REV","2","23","23","ⵜⴰⵔⵡⴰ ⵏⵏⴻⵙ ⴰⴷ ⵜⴻⵏ ⵡⵜⴻⵖ ⵙ ⵍⵎⴻⵡⵜ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵎⵓⵏⵉⵏ ⴰⴷ ⴼⴻⵀⵎⴻⵏⵜ ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⵡⴻⵏⵏⵉ ⵉⵇⴻⴵⴱⴻⵏ ⵜⵉⵥⵥⴰⵍ ⴷ ⵡⵓⵍⴰⵡⴻⵏ ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵖ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵡⴻⵎ ⴰⵏⴻⵛⵜ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵡⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RV2_24","096_2_24","REV","2","24","24","ⵎⴰⵛⴰ ⵉ ⴽⴻⵏⵏⵉⵡ ⵓ ⵉ ⵉⵏⵏⴻⵖⵏⵉ ⴷⵉ ⵜⵉⵢⴰⵜⵉⵔⴰ - ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵜⴻⴵⵉ ⵛⴰ ⵜⴰⵖⵓⵔⵉ-ⵢⴰ, ⵡⴰⵔ ⵙⵙⵉⵏⴻⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵏⵉⵜⵏⵉ ‘ⵍⴰⴵⴰⵖ ⵏ ⵛⵛⵉⵟⴰⵏ’ - ⴰⴷ ⴰⵡⴻⵎ ⵉⵏⵉⵖ: ⵏⴻⵛⵛ ⵡⴰⵔ ⵅⴰⵡⴻⵎ ⵜⵜⴷⴰⵔⵔⴰⵛⴻⵖ ⵛⴰ ⵜⴰⵖⵔⴰⵔⵜ ⵏⵏⴻⵖⵏⵉⵜ. ");
INSERT INTO rift_vpl VALUES ("RV2_25","096_2_25","REV","2","25","25","ⵎⴰⵛⴰ ⵎⵉⵏ ⵖⴰⵔⵡⴻⵎ, ⵟⵟⴼⴻⵎ ⴷⴰⵢⴻⵙ ⴰⵍ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV2_26","096_2_26","REV","2","26","26","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⵓ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⴷⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵏⵓ, ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵚⵚⵓⵍⵟⴰ ⵅ ⵍⴻⴳⵏⵓⵙ ");
INSERT INTO rift_vpl VALUES ("RV2_27","096_2_27","REV","2","27","27","ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵡⴻⵙ ⵙ ⵓⵣⴻⴵⴰⴹ ⵏ ⵡⵓⵣⵣⴰⵍ, ⴰⴷ ⵜⴻⵏ ⵜⴰⵔⵥⵉⵎ ⴰⵎ ⵉⵖⴰⵔⵔⴰⴼⴻⵏ ⵏ ⴱⵓ-ⵜⵍⴰⵅⵜ, ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵉ ⵜᵉⵟⵟⴼⴻⵖ ⵓⵍⴰ ⴷ ⵏⴻⵛⵛ ⵣⵉ ⴱⴰⴱⴰ, ");
INSERT INTO rift_vpl VALUES ("RV2_28","096_2_28","REV","2","28","28","ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⵉⵜⵔⵉ ⵏ ⵍⴻⴼⵊⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV2_29","096_2_29","REV","2","29","29","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RV3_1","096_3_1","REV","3","1","1","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⴷⵉ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵙⴰⵔⴷⵉⵙ! “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵙⴻⴱⵄⴰ ⵏ ⴰⵔⵔⵓⵃⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵢⴻⵜⵔⴰⵏ: ‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵖⴰⵔⴻⴽ ⵉⵙⴻⵎ, ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵜⴻⴷⴷⴰⵔⴻⴷ, ⵎⴰⵛⴰ ⵛⴻⴽ ⴰⵇⴰ ⵜᵉⵜⵜⵎⴻⵜⵜⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("RV3_2","096_3_2","REV","3","2","2","ⵃⴹⴰ, ⵙⴻⵊⵀⴻⴷ ⵎⵉⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵏⵏⵉ ⵜⴻⵏⵡⵉⴷ ⵛⴻⴽ ⴰⴷ ⵜⴻⵏ ⵜᵉⵜⵜⴻⵊⵊⵉⴷ ⴰⴷ ⵜᵉⵎⵎⵜⴻⵎ, ⵎⴰⵖⴰⵔ ⵓⴼⵉⵖ ⴰⵇⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⵡⴰⵔ ⴽⴻⵎⵎⵍⴻⵏⵜ ⵛⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV3_3","096_3_3","REV","3","3","3","ⵄⵇⴻⵍ ⵎⵍⵉⵃ, ⵎⴰⵎⵎⴻⵛ ⵅⴰⵙ ⵜⴻⵙⵍⵉⴷ ⵓ ⵎⴰⵎⵎⴻⵛ ⵜᵉⵟⵟⴼⴻⴷ, ⵃⴹⴰ ⵓⵛⴰ ⵜⵓⴱ! ⵎⴰⵛⴰ ⵎⴰⵍⴰ ⵡⴰⵔ ⵜᵉⵜⵜⴼⵉⵇⴻⴷ, ⴰⴷ ⵖⴰⵔⴻⴽ ⴷⴷ-ⴰⵙⴻⵖ ⴰⵎ ⵓⵛⴻⴼⴼⴰⵔ, ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⴷⵉ ⵎⴰⵏ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵉ ⵅⴰⴽ ⴷⴷ ⵖⴰ ⴱⴻⴷⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV3_4","096_3_4","REV","3","4","4","ⵎⴰⵛⴰ ⵖⴰⵔⵉ ⵛⴰ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⴷⵉ ⵙⴰⵔⴷⵉⵙ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⵅⴻⵎⵊⴻⵏ ⵛⴰ ⴰⵔⵔⵓⴹ ⵏⵙⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴳⵓⵔⴻⵏ ⵣⵣⴰⵜⵉ ⵙ ⵡⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⴷⴰⵀⴻⴵⴻⵏ ⵜ. ");
INSERT INTO rift_vpl VALUES ("RV3_5","096_3_5","REV","3","5","5","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⴰⵎⵎⵓ, ⴰⴷ ⴰⵙ ⵢⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ. ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴽⴽⵙⴻⵖ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵣⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵎⴰⵛⴰ ⴰⴷ ⵛⴻⵀⴷⴻⵖ ⵅ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵣⵣⴰⵜ ⵉ ⴱⴰⴱⴰ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV3_6","096_3_6","REV","3","6","6","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RV3_7","096_3_7","REV","3","7","7","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⴼⵉⵍⴰⴷⵉⵍⴼⵉⵢⴰ! “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵡⴻⵏⵏⵉ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵜⵙⴰⵔⵓⵜ ⵏ ⴷⴰⵡⵓⴷ ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵢⴰⵔⴻⵣⵎⴻⵏ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵉⴱⴻⵍⵍⴻⵄ, ⴷ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⴱⴻⵍⵍⵄⴻⵏ, ⵅⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⴰⴷ ⵢⴰⵔⵣⴻⵎ: ");
INSERT INTO rift_vpl VALUES ("RV3_8","096_3_8","REV","3","8","8","‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ. ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴳⴳⵉⵖ ⵣⵣⴰⵜⴻⵛ ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⴰⵔⵣⴻⵎ, ⵜⴻⵏⵏⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵜⵜ ⵉⴱⴻⵍⵍⴻⵄ, ⵎⵉⵏⵣⵉ ⵡⴰⵅⵅⴰ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⴷ ⴰⵎⴻⵥⵢⴰⵏ, ⵇⴰⵄ ⴰⵎⴻⵏⵏⵉ ⵜⴻⵃⴹⵉⴷ ⴰⵡⴰⵍ ⵉⵏⵓ ⵓⵛⴰ ⵡⴰⵔ ⵜⴻⵏⴽⴰⵔⴻⴷ ⵛⴰ ⵉⵙⴻⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RV3_9","096_3_9","REV","3","9","9","ⵅⵣⴰⵔ, ⴰⴷ ⵡⵛⴻⵖ ⵛⴰ ⵣⵉ ⵜⴻⵎⵣⵉⴷⴰ ⵏ ⵛⵛⵉⵟⴰⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⴰⵔⴻⵏ ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⴷ ⵓⴷⴰⵢⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⴵⵉⵏ ⵛⴰ ⴰⵎⴻⵏⵏⵉ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ. ⵅⵣⴰⵔ, ⴰⴷ ⵜⴻⵏ ⴰⵔⵔⴻⵖ ⴰⴷ ⴰⵛ ⵡⴹⴰⵏ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵛ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵏⴻⵄⵎⴻⵏ ⴱⴻⵍⵍⵉ ⵏⴻⵛⵛ ⵙⵙⵄⵉⵣⵣⴻⵖ ⵛⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("RV3_10","096_3_10","REV","3","10","10","ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵛⴻⴽ ⵜⴻⵃⴹⵉⴷ ⴰⵡⴰⵍ ⵉⵏⵓ ⵏ ⵚⵚⴱⴰⵔ, ⴰⴷ ⵅⴰⴽ ⵃⴹⵉⵖ ⵄⴰⵡⴻⴷ ⵣⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏ ⵓⵊⴰⵔⵔⴻⴱ ⵜⴻⵏⵏⵉ ⵉ ⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵎⴰⵔⵔⴰ ⵉ ⵓⵊⴰⵔⵔⴻⴱ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV3_11","096_3_11","REV","3","11","11","ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ. ⵟⵟⴻⴼ ⴷⵉ ⵎⵉⵏ ⵖⴰⵔⴻⴽ, ⵃⵉⵎⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⴷ ⴰⵛ ⵉⵜⵜⴻⴽⴽⴻⵙ ⵛⴰ ⵜⵜⴰⵊ ⵏⵏⴻⵛ. ");
INSERT INTO rift_vpl VALUES ("RV3_12","096_3_12","REV","3","12","12","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⴰⴷ ⵜ ⴳⴳⴻⵖ ⴷ ⴰⴱⵉⵍⴰⵔ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵡⴰⵔ ⵣⵣⴰⵢⴻⵙ ⵉⵜⵜⵡⴰⵎⵎⴻⴽⵙⵉ ⵄⴻⵎⵎⴰⵔⵚ. ⵏⴻⵛⵛ ⴰⴷ ⵅⴰⵙ ⴰⵔⵉⵖ ⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ ⴷ ⵢⵉⵙⴻⵎ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵏ ⵊⴷⵉⴷ, ⵓⵔⵛⴰⵍⵉⵎ ⵉ ⴷⴷ ⵖⴰ ⵉⵀⵡⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵓ, ⵓⵍⴰ ⴷ ⵉⵙⴻⵎ ⵉⵏⵓ ⵏ ⵊⴷⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("RV3_13","096_3_13","REV","3","13","13","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ.’” ");
INSERT INTO rift_vpl VALUES ("RV3_14","096_3_14","REV","3","14","14","ⴰⵔⵉ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵜⵎⴻⵙⵎⵓⵏⵜ ⵏ ⵍⴰⵢⵓⴷⵉⴽⵉⵢⴰ “ⴰⵎⵎⵓ ⵉ ⵉⵇⵇⴰⵔ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⵉⵏ, ⴰⵛⴻⵀⵀⴰⴷ ⴰⵎⵜⵉⵇⵇⵉ ⴷ ⵜⵉⴷⴻⵜⵜ, ⵡⴻⵏⵏⵉ ⴷ ⴱⴻⴷⴷⵓ ⵏ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⴷⴷ-ⵉⵅⵍⴻⵇ ⴰⵔⴻⴱⴱⵉ: ");
INSERT INTO rift_vpl VALUES ("RV3_15","096_3_15","REV","3","15","15","‘ⵏⴻⵛⵛ ⵙⵙⵏⴻⵖ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ, ⴰⵇⴰ ⵛⴻⴽ ⵡⴰⵔ ⵜⴻⵙⵎⵉⴹⴻⴷ ⵡⴰⵔ ⵜⴻⵃⵎⵉⴷ. ⵎⴻⵄⵍⵉⴽ ⴱⴻⵄⴷⴰ ⵜⵙⴻⵎⴹⴻⴷ ⵏⵉⵖ ⵜⴻⵃⵎⵉⴷ! ");
INSERT INTO rift_vpl VALUES ("RV3_16","096_3_16","REV","3","16","16","ⵙ ⵓⵢⴻⵏⵏⵉ, ⵓⵎⵉ ⵛⴻⴽ ⵜⴻⵎⵍⵓⴷⴻⴷ, ⵡⴰⵔ ⵜⴻⵃⵎⵉⴷ, ⵡⴰⵔ ⵜⴻⵙⵎⵉⴹⴻⴷ, ⴰⴷ ⵛⴻⴽ ⵄⵓⵇⵇⴻⵖ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RV3_17","096_3_17","REV","3","17","17","ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴻⵇⵇⴰⵔⴻⴷ: ⵏⴻⵛⵛ ⵖⴰⵔⵉ ⴰⴳⵍⴰ ⵓⵛⴰ ⵉⵎⵎⴰⵔⵏⵉ-ⴷⴷ ⵖⴰⵔⵉ ⵡⴰⴳⵍⴰ, ⵡⴰⵔ ⴷ ⴰⵢⵉ ⵉⵜⵜⵅⴻⵚⵚⵉ ⵡⴰⵍⵓ, ⴰⵎ ⵡⴰⵔ ⵜⴻⵙⵙⵉⵏⴻⴷ ⵛⴰ ⴱⴻⵍⵍⵉ ⴰⵇⴰ ⵛⴻⴽ ⵜⵃⴻⵍⵛⴻⴷ ⵓ ⴷⴰⵢⴻⴽ ⵍⴻⵖⴱⴻⵏ ⴷ ⵣⵣⴻⵍⴹ ⵓ ⴰⵇⴰ ⵛⴻⴽ ⴷ ⴰⴷⴰⵔⵖⴰⵍ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("RV3_18","096_3_18","REV","3","18","18","ⴰⴷ ⵛⴻⴽ ⵏⴻⵚⵃⴻⵖ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⴼⵉ ⵜⴻⵙⵖⴻⴷ ⵡⵓⵔⴻⵖ ⵉⵇⵇⵓⵔⴻⵏ, ⵉⴽⴽⵉⵏ ⵜⵉⵎⴻⵙⵙⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴷⴻⵡⵍⴻⴷ ⴷ ⴱⵓ-ⵡⴰⴳⵍⴰ, ⵓⵍⴰ ⴷ ⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵜⵢⴰⵔⴹⴻⴷ ⵓ ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⵜⴹⴻⵀⵀⴰⵔ ⵄⴰⴷ ⵍⴻⴼⴹⵉⵃⴻⵜ ⵏ ⵜⵓⵄⵄⴰⵔⵢⴻⵏⵜ ⵏⵏⴻⵛ. ⵓ ⴷⵀⴻⵏ ⵄⴰⵡⴻⴷ ⴷⴷⵀⴻⵏ ⵅ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵛ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴰⴼ ⵜⴻⵜⵜⵡⴰⵍⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("RV3_19","096_3_19","REV","3","19","19","ⵎⴰⵔⵔⴰ ⵡⴻⵏⵏⵉ ⵙⵙⵄⵉⵣⵣⴻⵖ, ⵜⵜⵡⴻⴱⴱⵅⴻⵖ ⵜ ⵓ ⴰⵔⴻⴱⴱⵉⵖ ⵜ. ⵅⴻⵏⵏⵉ ⵛⴹⴰⵔ, ⵜⵓⴱ! ");
INSERT INTO rift_vpl VALUES ("RV3_20","096_3_20","REV","3","20","20","ⴰⵇⴰ ⴷⴰ, ⵏⴻⵛⵛ ⴱⴻⴷⴷⴻⵖ ⵖⴰⵔ ⵜⴻⵡⵡⴰⵔⵜ, ⵙⵙⵇⴰⵔⵇⵓⴱⴻⵖ-ⴷⴷ. ⵎⴰⵍⴰ ⵉⵙⵍⴰ ⵃⴻⴷ ⵉ ⵜⵎⵉⵊⵊⴰ ⵉⵏⵓ, ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⵜⴰⵡⵡⴰⵔⵜ, ⵏⴻⵛⵛ ⴰⴷ ⵖⴰⵔⴻⵙ ⴰⴷⴼⴻⵖ ⵓⵛⴰ ⴰⴷ ⴽⵉⵙ ⵎⵎⵓⵏⴻⵙⵡⴻⵖ ⴷ ⵏⴻⵜⵜⴰ ⴰⴽⵉⴷⵉ. ");
INSERT INTO rift_vpl VALUES ("RV3_21","096_3_21","REV","3","21","21","ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵇⵇⵉⵎ ⴰⴽⵉⴷⵉ ⵅ ⵍⵄⴰⵔⵛ ⵉⵏⵓ, ⴰⵎ ⵏⴻⵛⵛ ⵖⴻⵍⵍⴱⴻⵖ ⵓⵛⴰ ⵇⵇⵉⵎⴻⵖ ⴰⴽ-ⴷ ⴱⴰⴱⴰ ⵅ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV3_22","096_3_22","REV","3","22","22","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ ⵎⵉⵏ ⵉⵇⵇⴰⵔ ⴰⵔⵔⵓⵃ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ.’” * ");
INSERT INTO rift_vpl VALUES ("RV4_1","096_4_1","REV","4","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ, ⵅⵣⴰⵔ, ⵉⵛⵜ ⵏ ⵜⴻⵡⵡⴰⵔⵜ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵓⵛⴰ ⵜⵎⵉⵊⵊⴰ ⵉ ⵙⵍⵉⵖ ⴰⴽⵉⴷⵉ ⴷⴷ-ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⵜⴻⵏⵏⴰ: “ⴳⴻⵄⵄⴻⴷ ⴷⴰ, ⵅⴻⵏⵏⵉ ⵏⴻⵛⵛ ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵎⵉⵏ ⴳⴳⵓⵔ ⴰⴷ ⵉⵎⵙⴰⵔ ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV4_2","096_4_2","REV","4","2","2","ⵍⴻⵅⴷⴻⵏⵏⵉ ⵉⵔⴻⵃⵃⴻⴼ ⴰⵢⵉ-ⴷⴷ ⴰⵔⵔⵓⵃ, ⵓ ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ ⵉⴱⴻⴷⴷ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰ ⵉⵇⵇⵉⵎ ⵅⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("RV4_3","096_4_3","REV","4","3","3","ⵓ ⵜⵉⴼⵔⴰⵙ ⵏ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵇⵇⵉⵎⴻⵏ ⴰⵎ ⵡⴻⵥⵔⵓ ⵏ ⵢⴰⵙⴱⵉⵙ ⴷ ⵙⴰⵔⴷⵉⵢⵓⵙ, ⵓⵛⴰ ⵜⴰⵙⵍⵉⵜ ⵏ ⵡⴻⵏⵥⴰⵔ ⵏ ⵉⵙⴻⵢⵏⵓⵜⴻⵏ ⵉ-ⴷⴷ-ⵉⵜⵜⴻⵏⵏⴹⴻⵏ ⵉ ⵍⵄⴰⵔⵛ ⵉⴹⵀⴰⵔ ⴰⵎ ⵡⴻⵥⵔⵓ ⵏ ⵙⵎⴰⵔⴰⵅⵜ. ");
INSERT INTO rift_vpl VALUES ("RV4_4","096_4_4","REV","4","4","4","ⵇⵓⵡⵡⴰⵔⴻⵏ ⴰⵙ ⵉ ⵍⵄⴰⵔⵛ ⴰⵔⴻⴱⵄⴰ ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵍⴻⴽⵔⴰⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ ⵓⵛⴰ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵇⵇⵉⵎⴻⵏ ⵅ ⵍⴻⴽⵔⴰⵙⵉ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⴰⵔⴹⴻⵏ ⴰⵔⵔⵓⴹ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵖⴰⵔⵙⴻⵏ ⵅ ⵓⵣⴻⴵⵉⴼ ⵜⵜⵉⵊⴰⵏ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV4_5","096_4_5","REV","4","5","5","ⵓⵛⴰ ⵣⵉ ⵍⵄⴰⵔⵛ ⵏⵏⵉ ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴷ ⴰⵙⵙⴰⵎⴻⵏ ⴷ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ. ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ ⴰⵔⴻⵇⵇⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵉⵚⴻⴼⴹⴰⵡⴻⵏ, ⵜⵉⵏⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⴰⵔⵔⵓⵃⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV4_6","096_4_6","REV","4","6","6","ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵍⵄⴰⵔⵛ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵍⴻⴱⵃⴰⵔ ⵏ ⵣⵣⴰⵊ, ⵉⴳⴳⴰ ⴰⵎ ⴰⴽⵔⵉⵙⵜⴰⵍ. ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵄⴰⵔⵛ ⴷ ⵎⵉⵏ ⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ ⵜⵓⵖⴰ ⴷⵉⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵄⴻⵎⵎⴰⵔⴻⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵎⴰⵔⵔⴰ ⵖⴰⵔ ⵣⵣⴰⵜ ⴷ ⴹⴻⴼⴼⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV4_7","096_4_7","REV","4","7","7","ⴰⵎⵓⴷⴷⴰⵔ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵡⴰⵢⵔⴰⴷ, ⴰⵎⴻⴷⴷⴰⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵓⵄⴻⵊⵎⵉ, ⴰⵎⴻⴷⴷⴰⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵜⵓⵖⴰ ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⴰⵅⵎⵉ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⴰⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵓⴳⵉⴷⴻⵔ ⵉⵟⵟⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV4_8","096_4_8","REV","4","8","8","ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵜⵓⵖⴰ ⵉⴱⴻⴷⴷ, ⵜⵜⴻⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵡⴰⵛⵛⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴷ ⵙⴻⵏⵏⴻⵊ ⵙⴻⵜⵜⴰ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵉ ⴷⴷ ⴰⵙ ⴷⴷ-ⵉⵏⵏⴹⴻⵏ, ⵄⴻⵎⵎⴰⵔⴻⵏ ⵙ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵖⴰⵔ ⴷⴰⵅⴻⵍ. ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵥⵔⵉⵏ ⴰⵔⵔⴰⵃⴻⵜ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ, ⵏⵏⴰⵏ: “ⴰⵎⵇⴻⴷⴷⴰⵙ, ⴰⵎⵇⴻⴷⴷⴰⵙ, ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV4_9","096_4_9","REV","4","9","9","ⵓⵛⴰ ⵅⵎⵉ ⵖⴰ ⵡⵛⴻⵏ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⴰⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⴷ ⵓⵇⴰⴷⵉ ⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ, ⴷ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ - “ⴰⵎⵉⵏ!” - ");
INSERT INTO rift_vpl VALUES ("RV4_10","096_4_10","REV","4","10","10","ⵅⴻⵏⵏⵉ ⴰⵔⴻⴱⵄⴰ ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ, ⵙⴻⵊⴷⴻⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ - “ⴰⵎⵉⵏ!” - ⵓⵛⴰ ⵙⵙⴰⵔⵙⴻⵏ ⵜⵜⵉⵊⴰⵏ ⵏⵙⴻⵏ ⵖⴰⵔ ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ, ⵏⵏⴰⵏ: ");
INSERT INTO rift_vpl VALUES ("RV4_11","096_4_11","REV","4","11","11","“ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉⵜⵏⴻⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵜⴻⵙⴷⴰⵀⴻⴵⴻⴷ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⴷ ⵊⵊⴻⵀⴷ, ⵎⴰⵖⴰⵔ ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵎⴰⵔⵔⴰ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵓ ⴰⵇⴰ ⴰⵜⴻⵏⵜ ⴷⵉⵏ ⵓ ⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏⵜ ⵙ ⵍⵅⴰⴹⴰⵔ ⵏⵏⴻⵛ!” ");
INSERT INTO rift_vpl VALUES ("RV5_1","096_5_1","REV","5","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ ⵖⴰⵔ ⵓⴼⵓⵙ ⴰⴼⵓⵙⵉ ⵏ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ, ⵜⵓⵖⴰ ⵅⴰⵙ ⵜⵉⵔⴰ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⴷ ⴱⴰⵔⵔⴰ, ⵓⵛⴰ ⴰⴷⵍⵉⵙ ⵜⵓⵖⴰ ⵉⵜⵜⵡⴰⵛⴻⵎⵎⴻⵄ ⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV5_2","096_5_2","REV","5","2","2","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵉⵊⵀⴻⴷ ⵏⵏⴻⵖⵏⵉ, ⵉⵜⵜⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ: “ⵎⴰⵏ ⵡⴻⵏ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ ⵏⵏⴻⵙ?” ");
INSERT INTO rift_vpl VALUES ("RV5_3","096_5_3","REV","5","3","3","ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵏⵉⵖ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵏⵉⵖ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓ ⴰⴷ ⵉⴽⴽⴻⵙ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ ⵏⵏⴻⵙ, ⴰⴷ ⴷⴰⵢⴻⵙ ⵉⵅⵣⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV5_4","096_5_4","REV","5","4","4","ⵏⴻⵛⵛ ⵔⵓⵖ ⴰⵟⵟⴰⵙ ⵓⵎⵉ ⵡⴰⵔ ⵓⴼⵉⵏ ⵡⵉ ⵉⵙⴷⴰⵀⴻⴵⴻⵏ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵓ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV5_5","096_5_5","REV","5","5","5","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵡⴰⵔ ⵜⵜⵔⵓ ⵛⴰ! ⵅⵣⴰⵔ, ⴰⵢⵔⴰⴷ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⴰⵥⵡⴰⵔ ⵏ ⴷⴰⵡⵓⴷ, ⴰⵇⴰ ⵉⵖⴻⵍⵍⴻⴱ, ⵃⵉⵎⴰ ⴰⴷ ⵢⴰⵔⵣⴻⵎ ⴰⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴷ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RV5_6","096_5_6","REV","5","6","6","ⵓⵛⴰ ⵥⵔⵉⵖ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵄⴰⵔⵛ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⵉⵊⵊ ⵏ ⵉⵣⵎⴰⵔ ⵉⴱⴻⴷⴷ, ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⴷ ⵜⴰⵖⴰⵔⵚⵜ. ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵜⵉⵟⵟⴰⵡⵉⵏ, ⵏⵉⵜⵏⵉ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⴰⵔⵔⵓⵃⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⵏⵏⵉ ⴷⴷ-ⵉⵜⵜⵡⴰⵙⵙⴻⴽⴽⴻⵏ ⵖⴰⵔ ⴷⴷⵓⵏⴻⵛⵜ ⵜⵎⵓⵏ.    ");
INSERT INTO rift_vpl VALUES ("RV5_7","096_5_7","REV","5","7","7","ⴰⵇⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⵛⴰ ⵉⴽⵙⵉ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ. ");
INSERT INTO rift_vpl VALUES ("RV5_8","096_5_8","REV","5","8","8","ⴰⵍⴰⵎⵉ ⵉⵟⵟⴻⴼ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⵡⴹⴰⵏ-ⴷⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⴷ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵣⵣⴰⵜ ⵉ ⵢⴻⵣⵎⴰⵔ. ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵉⴷⵙⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵉⵛⵜ ⵏ ⵍⵀⴰⵔⴱⴰ ⴷ ⵉⵊⵊ ⵏ ⵟⵟⴻⴱⵚⵉ ⵏ ⵡⵓⵔⴻⵖ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⴱⵅⵓⵔ: ⵎⴰⵏ ⴰⵢⴰ ⴷ ⵜⵉⵥⴰⴵⵉⵜⵉⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV5_9","096_5_9","REV","5","9","9","ⵓⵛⴰ ⵜⵜⵖⴻⵏⵏⴰⵊⴻⵏ ⵉⵊⵊ ⵏ ⵉⵣⵍⵉ ⵏ ⵊⴷⵉⴷ, ⵇⵇⴰⵔⴻⵏ: “ⵛⴻⴽ ⵜⴻⵙⴷⴰⵀⴻⴵⴻⴷ ⴰⴷ ⵜⴻⴽⵙⵉⴷ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ, ⴰⴷ ⵜⴻⴽⴽⵙⴻⴷ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜᵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⴷ ⵓⵛⴰ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵛ ⵜⴻⵙⵖⵉⴷ ⴰⵏⴻⵖ ⵉ ⴰⵔⴻⴱⴱⵉ, ⵣⵉ ⴽⵓⵍ ⵜⴰⵇⴱⵉⵍⵜ ⴷ ⵍⴳⴻⵏⵙ ⴷ ⵛⵛⴻⵄⴱ.” ");
INSERT INTO rift_vpl VALUES ("RV5_10","096_5_10","REV","5","10","10","”ⵛⴻⴽ ⵜⴰⵔⵔⵉⴷ ⵜⴻⵏ ⴷ ⵉⵛⵜ ⵏ ⵜⴳⴻⵍⴷⴰ ⵏ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵓ ⵏⵉⵜⵏⵉ ⴰⴷ ⵃⴻⴽⵎⴻⵏ ⴰⵎ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV5_11","096_5_11","REV","5","11","11","ⵅⴻⵏⵏⵉ ⵥⵔⵉⵖ, ⵓⵛⴰ ⵙⵍⵉⵖ ⵜⵎⵉⵊⵊⴰ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴹⴻⵏⵜ ⵉ ⵍⵄⴰⵔⵛ ⵓⵍⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ, ⵓⵛⴰ ⵜⵓⵖⴰ ⴰⵜⴻⵏⵜ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⴷⵉ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ ⵓ ⴰⵍⴰⴼ ⴷⵉ ⵍⵓⵍⵓⴼ, ");
INSERT INTO rift_vpl VALUES ("RV5_12","096_5_12","REV","5","12","12","ⵇⵇⴰⵔⴻⵏ ⵙ ⵜⵎⵉⵊⵊⴰ ⵉⵊⴻⵀⴷⴻⵏ: “ⵉⵣⵎⴰⵔ ⵏⵏⵉ ⵉⵜⵜⵡⴰⵖⴰⵔⵚⴻⵏ ⵉⵙⴷⴰⵀⴻⴵ ⴰⴷ ⵉⵟⵟⴻⴼ ⵚⵚⵓⵍⵟⴰ ⴷ ⵡⴰⴳⵍⴰ ⴷ ⵜⵉⵖⵉⵜ, ⴷ ⵊⵊⴻⵀⴷ ⴷ ⵛⵛⴰⵏ ⴷ ⵓⵄⵓⴵⵉ, ⴷ ⵍⴱⴰⵔⴰⴽⴰ!” ");
INSERT INTO rift_vpl VALUES ("RV5_13","096_5_13","REV","5","13","13","ⵓⵛⴰ ⴽⵓⵍ ⵉⵊⵊ ⵉ ⴷⴷ-ⵉⵅⴻⵍⵇⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵓ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵅ ⵍⴻⴱⵃⴰⵔ, ⵡⴰⵀ, ⵇⴰⵄ ⵎⵉⵏ ⵉⴵⴰⵏ ⴷⴰⵢⵙⴻⵏ, ⵙⵍⵉⵖ ⴰⵙⴻⵏ, ⵇⵇⴰⵔⴻⵏ: “ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵛⵛⴰⵏ ⴷ ⵓⵄⵓⴵⵉ ⴷ ⵚⵚⵓⵍⵟⴰ ⴰⴷ ⵉⵍⵉⵏ ⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵓ ⵉ ⵢⴻⵣⵎⴰⵔ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ!” ");
INSERT INTO rift_vpl VALUES ("RV5_14","096_5_14","REV","5","14","14","ⵓⵛⴰ ⵓⵎⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵏⵏⴰⵏ: “ⴰⵎⵉⵏ!”, ⵡⴹⴰⵏ ⵉⵎⵖⴰⵔⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⴻⵊⴷⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV6_1","096_6_1","REV","6","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ ⵓⵎⵉ ⵉⵣⵎⴰⵔ ⵉⴼⵙⵉ ⵉⵊⵊⴻⵏ ⵣⵉ ⵙⴻⴱⵄⴰ ⵏ ⵉⵛⴻⵎⵎⵉⵄⴻⵏ, ⵓⵛⴰ ⵙⵍⵉⵖ ⵉ ⵢⵉⵊⵊⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵇⵇⴰⵔ ⵙ ⵜⵎⵉⵊⵊⴰ ⴰⵎ ⵡⴰⵊⵊⴰⵊ: “ⴰⵙ-ⴷⴷ, ⵅⵣⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("RV6_2","096_6_2","REV","6","2","2","ⵅⴻⵏⵏⵉ ⵙⵍⵉⵖ ⵓ ⵥⵔⵉⵖ, ⵓ ⵅⵣⴰⵔ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵍⵇⴻⵡⵚ ⵏ ⴼⵍⵉⵜⵛⴰ ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ, ⵉⵖⵍⴻⴱ, ⵉⵜⵜⵖⴻⵍⵍⴰⴱ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵖⵍⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("RV6_3","096_6_3","REV","6","3","3","ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵛⴻⵎⵎⵉⵄ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵙⵍⵉⵖ ⵉ ⵓⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⵇⵇⴰⵔ: “ⴰⵙ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("RV6_4","096_6_4","REV","6","4","4","ⵓⵛⴰ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⴷ ⴰⵣⴻⴳⴳⵯⴰⵖ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ, ⴳⴳⵉⵏ ⵜ ⵃⵉⵎⴰ ⴰⴷ ⵉⴽⴽⴻⵙ ⵍⴻⵀⵏⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ ⴰⴷ ⵖⴰⵔⵚⴻⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵉⵊⵊ ⵏ ⵙⵙⵉⴼ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV6_5","096_6_5","REV","6","5","5","ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵛⴻⵎⵎⵉⵄ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵙⵍⵉⵖ ⵉ ⵓⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵉⵇⵇⴰⵔ: “ⴰⵙ-ⴷⴷ!” ⵅⵣⴰⵔ, ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⴷ ⴰⴱⴰⵔⵛⴰⵏ, ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵍⵎⵉⵣⴰⵏ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV6_6","096_6_6","REV","6","6","6","ⵣⵉ ⵍⵡⴻⵙⵟ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵙⵍⵉⵖ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵇⵇⴰⵔ: “ⵉⵊⵊ ⵏ ⵍⵎⵓⴷ ⵏ ⵢⵉⵔⴷⴻⵏ ⵙ ⵢⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ ⵓ ⵜⵍⴰⵜⴰ ⵏ ⵍⴻⵎⴷⵓⴷ ⵏ ⵉⵎⴻⵏⴷⵉ ⵙ ⵢⵉⵊⵊ ⵏ ⴷⵉⵏⴰⵔ, ⵓ ⵣⵣⴻⵛⵜ ⴷ ⴱⵉⵏⵓ ⵡⴰⵔ ⵜⴻⵏ ⵜⵜⴹⵉⵢⵢⵉⵄⴻⵎ ⵛⴰ!” ");
INSERT INTO rift_vpl VALUES ("RV6_7","096_6_7","REV","6","7","7","ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵛⴻⵎⵎⵉⵄ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ, ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⵎⵓⴷⴷⴰⵔ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵜⴻⵇⵇⴰⵔ: “ⴰⵙ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("RV6_8","096_6_8","REV","6","8","8","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⴷ ⴰⵙⵏⴰⴱⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵍⵎⴻⵡⵜ’, ⵓⵛⴰ ⵜⴻⴹⴼⴰⵔ ⵉ-ⵜ ⵍⴰⵅⴰⵔⵜ. ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵉⵊⵊ ⵏ ⴰⵔⴱⴻⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵃⵉⵎⴰ ⴰⴷ ⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ, ⵙ ⵍⴰⵥ, ⵙ ⵍⵎⴻⵡⵜ ⵓ ⵙ ⵍⴻⵡⵃⵓⵛ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV6_9","096_6_9","REV","6","9","9","ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵛⴻⵎⵎⵉⵄ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ, ⵥⵔⵉⵖ ⵙⴰⴷⵓ ⵓⵄⴰⵍⵟⴰⵔ ⵍⴻⵄⵎⵓⵔ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵉ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV6_10","096_6_10","REV","6","10","10","ⵏⵉⵜⵏⵉ ⵍⴰⵖⴰⵏ ⵙ ⵊⵊⴻⵀⴷ, ⵏⵏⴰⵏ: “ⴰ ⵙⵉⴷⵉ, ⴰ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴷ ⴱⴰⴱ ⵏ ⵜⵉⴷⴻⵜⵜ, ⵎⴻⵛⵃⴰⵍ ⵉ ⵖⴰ ⵜⴻⵇⵇⵉⵎⴻⴷ ⵡⴰⵔ ⵜⵃⴻⴽⴽⵎⴻⴷ, ⵡⴰⵔ ⵜᵉⵜⵜⵏⴻⵇⵎⴻⴷ ⵛⴰ ⵉ ⵉⴷⴰⵎⵎⴻⵏ ⵏⵏⴻⵖ ⵣⴻⴳ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ?” ");
INSERT INTO rift_vpl VALUES ("RV6_11","096_6_11","REV","6","11","11","ⵓⵛⴰ ⵡⵛⵉⵏ ⵉ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵍⴻⵄⴱⴰⵢⴰⵜ ⴷ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ, ⵓ ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵙⴻⵏ ⴱⴻⵍⵍⵉ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⴰⵍ ⵖⴰ ⵉⴽⴻⵎⵎⴻⵍ ⵍⵄⴰⴷⴰⴷ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵉⵎⵄⴰⵛⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴷ ⵡⴰⵡⵎⴰⵜⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵄⴰⵡⴻⴷ ⴰⵎ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RV6_12","096_6_12","REV","6","12","12","ⵓⵛⴰ ⵥⵔⵉⵖ ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⴰⵛⴻⵎⵎⵉⵄ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ, ⴰⵇⴰ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵓ ⵜⴰⴼⵓⵛⵜ ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⴱⴰⵔⵛⴰⵏⵜ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵛⵜ ⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ ⵓⵛⴰ ⵜⴰⵣⵉⵔⵉ ⵜⵎⵓⵏ ⵜⴻⴳⴳⴰ ⴰⵎⴻⵛⵏⴰⵡ ⵉⴷⴰⵎⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV6_13","096_6_13","REV","6","13","13","ⵓⵛⴰ ⵉⵜⵔⴰⵏ ⵏ ⵓⵊⴻⵏⵏⴰ ⵡⴹⴰⵏ-ⴷⴷ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵎ ⵡⴰⵔⵜⵓ ⵉⵎⵎⴻⵏⴹⴰⵔ ⵉⵇⵓⵔⵔⴰⵄ ⵏⵏⴻⵙ ⵅⵎⵉ ⵜ-ⵉ-ⴷⴷ-ⵉⵖⴻⵟⵟⴻⵍ ⵉⵊⵊ ⵏ ⵓⵙⴻⵎⵎⵉⴹ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV6_14","096_6_14","REV","6","14","14","ⵉⵜⵜⵡⴰⴼⴻⴵⵇⴻⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵓⵛⴰ ⵜⵜⵡⴰⵏⴹⴻⵏ ⵏⵉⵜⵏⵉ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⵏⵏⴻⴹⴻⵏ ⵉⴷⵍⵉⵙⴻⵏ. ⵓⵛⴰ ⴽⵓⵍ ⴰⴷⵔⴰⵔ ⴷ ⵎⴰⵔⵔⴰ ⵜⵉⴳⵣⵉⵔⵉⵏ ⵜⵜⵡⴰⴽⴽⵙⴻⵏ ⵣⴻⴳ ⵉⵎⵓⵛⴰⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV6_15","096_6_15","REV","6","15","15","ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⴷ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵢⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⴷ ⴽⵓⵍ ⵉⵙⵎⴻⵖ ⴷ ⴰⵃⵓⵔⵔⵉ, ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵎⴰⵔⵔⴰ ⵙⵙⵏⵓⴼⴼⴰⵔⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴷⴻⴳ ⵉⴼⵔⴰⵏ ⵓ ⵊⴰⵔ ⵍⴻⵊⵔⵓⴼ ⵏ ⵉⴷⵓⵔⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("RV6_16","096_6_16","REV","6","16","16","ⵏⵏⴰⵏ ⵉ ⵉⴷⵓⵔⴰⵔ ⴷ ⵍⴻⵊⵔⵓⴼ: “ⵡⴹⴰⵎ-ⴷⴷ ⵅⴰⵏⴻⵖ, ⴼⴼⴰⵔⴻⵎ ⴰⵏⴻⵖ ⵣⴻⴳ ⵡⵓⴷⴻⵎ ⵏ ⵉⵣⵎⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("RV6_17","096_6_17","REV","6","17","17","ⵎⵉⵏⵣⵉ ⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ, ⵎⴰⵏ ⵡⴻⵏ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴱⴻⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("RV7_1","096_7_1","REV","7","1","1","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵥⵔⵉⵖ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⴱⴻⴷⴷⴻⵏⵜ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵟⵟⴼⴻⵏⵜ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵙⴻⵎⵎⵉⴹⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵙⵓⴹⵉ ⵓⵙⴻⵎⵎⵉⴹ ⵍⴰ ⵅ ⵍⴱⴰⵔⵔ ⵍⴰ ⵅ ⵡⴰⵎⴰⵏ ⵓⵍⴰ ⵅ ⵛⴰ ⵏ ⵜⵛⴻⵊⵊⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV7_2","096_7_2","REV","7","2","2","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵢⵓⵍⵉ-ⴷⴷ ⵎⴰⵏⵉⵙ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ, ⴰⵇⴰ ⵖⴰⵔⴻⵙ ⴰⵛⴻⵎⵎⵉⵄ ⵏ ⴰⵔⴻⴱⴱⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵓⵎⵉ ⵜⴻⵎⵎⴻⵡⵛ ⵜⵣⴻⵎⵎⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵅⵙⴰⵔⴻⵏⵜ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵍⴻⴱⵃⴰⵔ, ");
INSERT INTO rift_vpl VALUES ("RV7_3","096_7_3","REV","7","3","3","ⵉⵇⵇⴰⵔ: “ⵡⴰⵔ ⵜⵜⵙⴻⵅⵙⴰⵔⴻⵎ ⵜⴰⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⵍⴻⴱⵃⴰⵔ ⵓⵍⴰ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ ⴰⵍ ⵖⴰ ⵏⴻⴳⴳ ⴰⵛⴻⵎⵎⵉⵄ ⵅ ⵜⴻⵏⵢⴰⵔⵉⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("RV7_4","096_7_4","REV","7","4","4","ⵓⵛⴰ ⵙⵍⵉⵖ ⵍⵇⴻⴷⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵛⴻⵎⵎⵄⴻⵏ, ⵎⵢⴰ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ ⴰⵇⴰ ⵜⵜⵡⴰⵛⴻⵎⵎⵄⴻⵏ ⵣⵉ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ: ");
INSERT INTO rift_vpl VALUES ("RV7_5","096_7_5","REV","7","5","5","ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⴰⵀⵓⴷⴰ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵔⵓⴱⵉⵏ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵊⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("RV7_6","096_7_6","REV","7","6","6","ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴰⵛⵉⵔ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵏⴰⴼⵜⴰⵍⵉ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵎⴰⵏⴰⵙⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("RV7_7","096_7_7","REV","7","7","7","ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵛⵉⵎⵄⵓⵏ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵉⵙⵙⴰⴽⴰⵔ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵍⴰⵡⵉ, ");
INSERT INTO rift_vpl VALUES ("RV7_8","096_7_8","REV","7","8","8","ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵣⵉⴱⵓⵍⵓⵏ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⵢⵓⵙⵓⴼ, ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵣⵉ ⵜⴻⵇⴱⵉⵍⵜ ⵏ ⴱⵉⵏⵢⴰⵎⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RV7_9","096_7_9","REV","7","9","9","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⵇⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⵖⴰⵛⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⴰⴷ ⵜ ⵉⵃⵙⴻⴱ, ⵣⵉ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⴷ ⵜⴻⵇⴱⵉⵍⵜ ⵓ ⵣⵉ ⵎⴰⵔⵔⴰ ⵛⵛⵓⵄⵓⴱ ⴷ ⵉⵍⵙⴰⵡⴻⵏ. ⵏⵉⵜⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ ⴷ ⵢⴻⵣⵎⴰⵔ, ⴰⵔⴹⴻⵏ ⵍⴻⵄⴱⴰⵢⴰⵜ ⵜⵉⵣⵉⵔⴰⵔⵉⵏ ⴷ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ, ⵓⵛⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵙⴻⴹⵡⵉⵏ ⵏ ⵜⵉⵏⵉ ⴷⴻⴳ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV7_10","096_7_10","REV","7","10","10","ⵜⵜⵍⴰⵖⴰⵏ ⵙ ⵊⵊⴻⵀⴷ: “ⴰⵙⴻⵏⵊⴻⵎ ⴰⵇⴰ ⵙ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⵓ ⵙ ⵢⴻⵣⵎⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("RV7_11","096_7_11","REV","7","11","11","ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵜⵓⵖⴰ ⴱⴻⴷⴷⴻⵏⵜ ⵏⵏⴹⴻⵏⵜ ⵉ ⵍⵄⴰⵔⵛ ⴰⴽ-ⴷ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ, ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵡⵓⴷⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵄⴰⵔⵛ, ");
INSERT INTO rift_vpl VALUES ("RV7_12","096_7_12","REV","7","12","12","ⵇⵇⴰⵔⴻⵏ “ⴰⵎⵉⵏ! ⴰⵄⵓⴵⵉ ⴷ ⵍⴱⴰⵔⴰⴽⴰ ⴷ ⵜⵉⵖⵉⵜ ⴷ ⵓⵇⴰⴷⵉ ⴷ ⵛⵛⴰⵏ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷ ⵊⵊⴻⵀⴷ ⴰⵇⴰ-ⵜⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⴰⵎⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("RV7_13","096_7_13","REV","7","13","13","ⵉⵟⵟⴻⴼ ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵎⵖⴰⵔⴻⵏ ⵏⵏⵉ ⴷⴻⴳ ⵡⴰⵡⴰⵍ, ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵎⵉⵏ ⵄⵏⴰⵏ ⵉⵏⴰ, ⵉⵏⵏⵉ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵄⴱⴰⵢⴰⵜ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ, ⵎⵉⵏ ⵄⵏⴰⵏ ⵓ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵓⵙⵉⵏ?” ");
INSERT INTO rift_vpl VALUES ("RV7_14","096_7_14","REV","7","14","14","ⵏⴻⵛⵛ ⵏⵏⵉⵖ ⴰⵙ: “ⴰ ⵙⵉⴷⵉ, ⵛⴻⴽ ⵉ ⵉⵙⵙⵏⴻⵏ.” ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵉⵏⴰ ⴰⵇⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵣⵉ ⵍⵎⴻⵃⵏⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ. ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵙⵉⵣⴷⵉⴳⴻⵏ ⵍⴻⵄⴱⴰⵢⴰⵜ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⵔⵔⵉⵏ ⵜⴻⵏⵜ ⴷ ⵜⵉⵛⴻⵎⵍⴰⵍⵉⵏ ⴷⴻⴳ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵣⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV7_15","096_7_15","REV","7","15","15","ⵙ ⵓⵢⴻⵏⵏⵉ ⴱⴻⴷⴷⴻⵏ ⵏⵉⵜⵏⵉ ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵙⴻⵅⵅⴰⵔⴻⵏ ⴰⵙ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵡⵡⴻⵜ ⴰⵇⵉⴹⵓⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV7_16","096_7_16","REV","7","16","16","ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ ⴰⴷ ⴵⴰⵥⴻⵏ ⵏⵉⵖ ⴰⴷ ⴼⴼⴰⴷⴻⵏ, ⵡⴰⵔ ⵜⴻⵏ ⵜᵉⵜⵜⵇⴻⴷⴷⵉ ⵓⵍⴰ ⴷ ⵜⴰⴼⵓⵛⵜ ⵓⵍⴰ ⴷ ⵉⵛⵜ ⵏ ⵊⵊⵓⵔⵔⴻⵜ ⵏ ⵍⴻⵃⵎⵓ, ");
INSERT INTO rift_vpl VALUES ("RV7_17","096_7_17","REV","7","17","17","ⵎⵉⵏⵣⵉ ⵉⵣⵎⴰⵔ ⵏⵏⵉ ⵉⴵⴰⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵍⵄⴰⵔⵛ ⴰⴷ ⵜⴻⵏ ⵢⴰⵔⵡⴻⵙ, ⴰⴷ ⵜⴻⵏ ⵉⵏⴷⴻⵀ ⵖⴰⵔ ⵜⵓⴷⴰⵔⵜ ⵓ ⵖⴰⵔ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴰⵙⴻⵏ ⵉⵎⵙⴻⵃ ⴽⵓⵍ ⴰⵎⴻⵟⵟⴰ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV8_1","096_8_1","REV","8","1","1","ⴰⵍⴰⵎⵉ ⵢⴰⵔⵣⴻⵎ ⵏⴻⵜⵜⴰ ⴰⵛⴻⵎⵎⵉⵄ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵜⵓⵖⴰ ⴰⵊⴻⵏⵏⴰ ⵢⴰⵔⵙⴰ ⵄⵍⴰⵃⴰⵍ ⴰⵣⵢⴻⵏ ⵏ ⵜⵙⴰⵄⵄⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RV8_2","096_8_2","REV","8","2","2","ⵓⵛⴰ ⵥⵔⵉⵖ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ. ");
INSERT INTO rift_vpl VALUES ("RV8_3","096_8_3","REV","8","3","3","ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵢⵓⵙⴰ-ⴷⴷ, ⵢⵓⵢⵓⵔ ⴰⴷ ⵉⴱⴻⴷⴷ ⵖⴰⵔ ⵓⵄⴰⵍⵟⴰⵔ ⵙ ⵉⵛⵜ ⵏ ⵜⴻⵇⴷⵓⵃⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵍⴻⴱⵅⵓⵔ. ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴱⵅⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵉⵡⴻⵀⵀⴻⴱ ⴰⴽ-ⴷ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵏ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵅ ⵓⵄⴰⵍⵟⴰⵔ ⵇⵉⴱⴰⵍⵜ ⵉ ⵍⵄⴰⵔⵛ. ");
INSERT INTO rift_vpl VALUES ("RV8_4","096_8_4","REV","8","4","4","ⵓⵛⴰ ⴰⵔⵔⵉⵃⴻⵜ ⵏ ⵍⴻⴱⵅⵓⵔ ⴰⴽ-ⴷ ⵜⵥⴰⴵⵉⵜⵉⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵜⵓⵖⴰ ⵜᵉⵜⵜⴳⴻⵄⵄⴰⴷ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵎⴰⵍⴰⴽ ⵖⴰⵔ ⵣⵣⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV8_5","096_8_5","REV","8","5","5","ⵍⵎⴰⵍⴰⴽ ⵉⴽⵙⵉ ⵜⴰⵇⴷⵓⵃⵜ ⵏ ⵍⴻⴱⵅⵓⵔ, ⵉⵛⵛⵓⵔ ⵉ-ⵜⵜ ⵙ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴷ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⴷ ⵡⴰⵙⵙⴰⵎⴻⵏ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV8_6","096_8_6","REV","8","6","6","ⵓⵛⴰ ⵃⴻⵣⵣⵎⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵜⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ ⵃⵉⵎⴰ ⴰⴷ ⴷⴰⵢⵙⴻⵏ ⵙⵓⴹⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("RV8_7","096_8_7","REV","8","7","7","ⵓⵛⴰ ⵉⵙⵓⴹ ⵓⵎⴻⵣⵡⴰⵔⵓ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⴻⴱⵔⵓⵔⵉ ⴷ ⵜⵎⴻⵙⵙⵉ ⵅⴻⴵⴹⴻⵏⵜ ⴰⴽ-ⴷ ⵡⴰⵎⴰⵏ, ⵜⵜⵡⴰⵎⴻⵏⴹⴰⵔⴻⵏⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵓⵛⴰ ⵜⴻⵛⵎⴻⴹ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵜⵛⴻⵊⵊⵓⵔⴰ ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⴰⵔⴱⵉⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵛⵎⴻⴹ. ");
INSERT INTO rift_vpl VALUES ("RV8_8","096_8_8","REV","8","8","8","ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵛⴰ ⵏ ⵜⵎⴻⵙⵍⴰⵛⵜ ⴰⵎ ⵡⴻⴷⵔⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉⵛⴻⵎⵎⴹⴻⵏ, ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵍⴻⴱⵃⴰⵔ ⵉⴷⵡⴻⵍ ⴷ ⵉⴷⴰⵎⵎⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV8_9","096_8_9","REV","8","9","9","ⵓ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵍⴻⵄⵎⴰⵔ, ⵎⵎⵓⵜⴻⵏ, ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⵜⴰⵔⴻⴷⴷⴻⴵ. ");
INSERT INTO rift_vpl VALUES ("RV8_10","096_8_10","REV","8","10","10","ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵡⴹⴰ-ⴷⴷ ⵉⵊⵊ ⵏ ⵉⵜⵔⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵢⵓⵔⵖⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵄⴻⵛⵛⴰⵍ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵉⵡⴹⴰ-ⴷⴷ ⵅ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵖⴻⵣⵔⴰⵏ ⵓ ⵅ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV8_11","096_8_11","REV","8","11","11","ⵉⵜⵔⵉ-ⵢⴰ ⵇⵇⴰⵔⴻⵏ-ⴰⵙ ‘ⴰⴱⵙⵉⵏⵜⴰ’, ⵏⵉⵖ ‘ⵛⵛⵉⵃ’. ⵓⵛⴰ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵡⴰⵎⴰⵏ ⵜⴻⴷⵡⴻⵍ ⵜⴰⵔⵣⴻⴳ ⴰⵎ ‘ⴰⴱⵙⵉⵏⵜ’, ⵓⵛⴰ ⵎⵎⵓⵜⴻⵏ ⴰⵟⵟⴰⵙ ⵏ ⵢⴻⵡⴷⴰⵏ ⵙ ⵡⴰⵎⴰⵏ ⵓⵎⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⵎⴻⵔⵣⴰⴳⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV8_12","096_8_12","REV","8","12","12","ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵜⴼⵓⵛⵜ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵜⵣⵉⵔⵉ ⴷ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵜⵔⴰⵏ, ⴰⵍⴰⵎⵉ ⵜⴱⴱⴰⵔⵛⴻⵏ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵣⵣⴰⵢⵙⴻⵏ, ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵜⴼⴰⵡⵜ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵓⵣⵉⵍ ⵓⵛⴰ ⴰⵎⵎⵓ ⵓⵍⴰ ⴷⵉ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RV8_13","096_8_13","REV","8","13","13","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵊⵊ ⵏ ⵓⴳⵉⴷⴻⵔ ⵉⵟⵟⴰⵡ-ⴷⴷ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵉⵇⵇⴰⵔ: “ⵓⵛⵜ, ⵓⵛⵜ, ⵓⵛⵜ ⵅ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵅ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⵉⵏⵏⴻⵖⵏⵉ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵉⵛⴰⵔⵔⵉ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉ ⵖⴰ ⵉⵙⵓⴹⴻⵏ ⵄⴰⴷ ⴷⵉ ⵍⴱⵓⵇ!” ");
INSERT INTO rift_vpl VALUES ("RV9_1","096_9_1","REV","9","1","1","ⵅⴻⵏⵏⵉ ⵉⵙⵓⴹ ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵢⴻⵜⵔⵉ ⵉⵡⴹⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵜⴰⵙⴰⵔⵓⵜ ⵏ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵢⵓⴵⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV9_2","096_9_2","REV","9","2","2","ⵓⵛⴰ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⴷⴷⴻⵅⵅⴰⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵜⴻⵙⵔⴰⴼⵜ, ⴰⵎ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵜⴻⴼⵇⵓⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉⵃⵎⴰⵏ, ⵓⵛⴰ ⵜⴼⵓⵛⵜ ⴷ ⵍⴻⵄⵡⵉⵏ ⴱⴱⴰⵔⵛⵏⴻⵏ ⵙ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵜⴻⵙⵔⴰⴼⵜ. ");
INSERT INTO rift_vpl VALUES ("RV9_3","096_9_3","REV","9","3","3","ⵣⵉ ⴷⴷⴻⵅⵅⴰⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴱⵓⵔⴻⵅⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⴰⵎ ⵜⴻⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV9_4","096_9_4","REV","9","4","4","ⵉⵜⵜⵡⴰⵏⵏⴰ ⴰⵙⴻⵏ, ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵊⴻⵢⵢⵃⴻⵏ ⴰⵔⴱⵉⵄ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵍⴰ ⴷ ⵇⴰⵄ ⴰⵖⴻⵎⵎⵓⵢ ⴰⵣⵉⵣⴰ ⵓⵍⴰ ⴷ ⵜⵉⵛⴻⵊⵊⵓⵔⴰ, ⵎⵖⵉⵔ ⵉⵡⴷⴰⵏ ⵡⴰⵀⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵖⴰⵔ ⵉⴵⵉ ⵓⵛⴻⵎⵎⵉⵄ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵙⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("RV9_5","096_9_5","REV","9","5","5","ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙⴻⵏ ⵜⵣⴻⵎⵎⴰⵔ ⵎⴰⵃⴻⵏⴷ ⵡⴰⵔ ⵜⴻⵏ ⵏⴻⵇⵇⴻⵏ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⵏ ⵄⴻⴷⴷⴱⴻⵏ ⵍⵇⴻⴷⴷ ⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵢⵓⵔⴻⵏ, ⵓⵛⴰ ⴰⵄⴻⴷⴷⴻⴱ ⵏⵙⴻⵏ ⴰⵎ ⵓⵄⴻⴷⴷⴻⴱ ⵏ ⵜⵖⴰⵔⴹⴻⵏⵜ ⵅⵎⵉ ⵜᵉⵜⵜⴻⵇⵇⴻⵙ ⵉ ⴱⵏⴰⴷⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RV9_6","096_9_6","REV","9","6","6","ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴰⴷ ⴰⵔⵣⵓⵏ ⵉⵡⴷⴰⵏ ⵅ ⵍⵎⴻⵡⵜ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵜ ⵜⵜᵉⵟⵟⵉⴼⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵜⵜⴰⵔⴻⵏ ⴰⴷ ⵎⵎⵜⴻⵏ, ⵎⴰⵛⴰ ⵍⵎⴻⵡⵜ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⴰⵔⵡⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("RV9_7","096_9_7","REV","9","7","7","ⵉⴱⵓⵔⴻⵅⵙⴻⵏ ⴳⴳⵉⵏ ⴰⵎ ⵢⵉⵢⵙⴰⵏ ⵉⵡⴻⵊⴷⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵓ ⵖⴰⵔⵙⴻⵏ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵛⴰ ⴰⵎ ⵜⵜⵉⵊⴰⵏ ⴰⵅⵎⵉ ⵜⴻⵏⵜ ⴳⴳⵉⵏ ⵙ ⵡⵓⵔⴻⵖ, ⵓ ⵉⵖⴻⵎⴱⴰⴱ ⵏⵙⴻⵏ ⴰⵎ ⵉⵖⴻⵎⴱⴰⴱ ⵏ ⵉⵡⴷⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("RV9_8","096_9_8","REV","9","8","8","ⵓ ⴰⵛⵓⵡⵡⴰⴼ ⵏⵙⴻⵏ ⴰⵎ ⵓⵛⵓⵡⵡⴰⴼ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵓ ⵜⵉⵖⵎⴰⵙ ⵏⵙⴻⵏ ⴰⵎ ⵜⵉⵏⵏⵉ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV9_9","096_9_9","REV","9","9","9","ⵓ ⵜⵓⵖⴰ ⵖⴰⵔⵙⴻⵏ ⵜⵛⴰⴱⴱⴰⵜ ⵅ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⵜⵛⴰⴱⴱⴰⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵉ ⵓⵙⴻⵍⵇⵉ, ⵓ ⴷⴷⵔⵉⵣ ⵏ ⵡⴰⴼⵔⵉⵡⴻⵏ ⵏⵙⴻⵏ ⴰⵎ ⴷⴷⵔⵉⵣ ⵏ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⴰⴽ-ⴷ ⵡⴰⵟⵟⴰⵙ ⵏ ⵉⵢⵙⴰⵏ ⵉⵜⵜⴻⵇⵏⵓⵏⵏⵓⵢⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵖⵉ, ");
INSERT INTO rift_vpl VALUES ("RV9_10","096_9_10","REV","9","10","10","ⵓ ⵖⴰⵔⵙⴻⵏ ⵉⴽⴻⵏⵏⴰⵙⴻⵏ ⴰⵎ ⵢⵉⵏⵏⵉ ⵏ ⵜⵖⴰⵔⴹⵎⵉⵡⵉⵏ ⵓ ⵜⵓⵖⴰ ⴷⵉⵏ ⵉⵙⴻⵏⵏⴰⵏⴻⵏ ⴷⴻⴳ ⵉⴽⴻⵏⵏⴰⵙⴻⵏ ⵏⵙⴻⵏ. ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵙⵙⴻⵀⵡⴰⵏ ⴷⵔⵓⵛⵜ ⵅ ⵉⵡⴷⴰⵏ, ⵍⵎⵉⵊⴰⵍ ⵏ ⵅⴻⵎⵙⴰ ⵏ ⵉⵢⵓⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV9_11","096_9_11","REV","9","11","11","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵍⵎⴰⵍⴰⴽ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵅⴰⵙⴻⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ‘ⴰⴱⴰⴷⴷⵓ’ ⵓ ⵙ ⵜⵔⴰⵎⵉⵜ ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵛⴰⵔⴰ’. ");
INSERT INTO rift_vpl VALUES ("RV9_12","096_9_12","REV","9","12","12","ⵓⵛⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵜⴻⵄⴷⵓ, ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏⵜ ⵄⴰⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵛⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("RV9_13","096_9_13","REV","9","13","13","ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⵉⵙⵓⴹ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⵙⵍⵉⵖ ⵜⵎⵉⵊⵊⴰ ⵉ ⴷⴷ-ⵢⵓⵙⵉⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏ ⵓⵄⴰⵍⵟⴰⵔ ⵏ ⵡⵓⵔⴻⵖ ⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵇⵉⴱⴰⵍⵜ ⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RV9_14","096_9_14","REV","9","14","14","ⵜⴻⵏⵏⴰ ⵉ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵉ ⵖⴰⵔ ⵉⴵⴰ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ: “ⴼⵙⵉⵢ ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵉⵛⴰⵔⴼⴻⵏ ⵟⵟⴰⵔⴼ ⵏ ⵉⵖⵣⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵍⴼⵓⵔⴰⵟ.” ");
INSERT INTO rift_vpl VALUES ("RV9_15","096_9_15","REV","9","15","15","ⵓⵛⴰ ⴰⵔⵅⵓⵏ ⴰⵙⴻⵏ ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵡⴻⵊⴷⴻⵏ ⴷⵉⵏⵏⵉ ⵖⴰⵔ ⵡⴰⵙⵙ ⴷ ⵓⵢⵓⵔ ⴷ ⵓⵙⴻⴳⴳⵯⴰⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵏⵖⴻⵏⵜ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV9_16","096_9_16","REV","9","16","16","ⵜⵓⵖⴰ ⵍⵇⴻⴷⴷ ⵏ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵉⵢⵙⴰⵏ ⵜⵢⵓⵢⴰ ⵏ ⵄⴻⵛⵔⴰ-ⴰⵍⴰⴼ ⵙ ⵄⴻⵛⵔⴰ ⵏ ⵍⵓⵍⵓⴼ, ⵓⵛⴰ ⵙⵍⵉⵖ ⵎⴻⵛⵃⴰⵍ ⴷⵉ ⴵⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV9_17","096_9_17","REV","9","17","17","ⴰⵎⵎⵓ ⵉ ⵥⵔⵉⵖ ⵉⵢⵙⴰⵏ ⴷⵉ ⵍⴻⵡⵃⵉⵢ, ⴰⵇⴰ ⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵏⵢⵉⵏ ⵜⵓⵖⴰ ⵙⵙⴷⵓⵔⵔⵓⵢⴻⵏ ⵉⴷⵎⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵙ ⵜⵛⴰⴱⴱⴰⵜ ⵏ ⵡⵓⵣⵣⴰⵍ ⵉ ⵓⵙⴻⵍⵇⵉ ⴷ ⵜⵉⵣⴻⴳⴳⵯⴰⵖⵉⵏ ⴰⵎ ⵜⵎⴻⵙⵙⵉ, ⵛⴰⴱⴻⵏⵜ, ⴷ ⵜⵉⵡⵔⴰⵖⵉⵏ ⴰⵎ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ. ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵉⵢⵙⴰⵏ ⵏⵏⵉ ⴰⵎ ⵢⵉⵣⴻⴵⵉⴼⴻⵏ ⵏ ⵡⴰⵢⵔⴰⴷⴻⵏ ⵓⵛⴰ ⵣⴻⴳ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⵏⵙⴻⵏ ⵜⴻⴼⴼⴻⵖ-ⴷⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵜⵎⴻⵙⵙⵉ ⴷ ⴷⴷⴻⵅⵅⴰⵏ ⴷ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RV9_18","096_9_18","REV","9","18","18","ⴰⵇⴰ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵡⴷⴰⵏ ⵜᵉⵜⵜⵡⴰⵏⴻⵖ ⵙ ⵜⵍⴰⵜⴰ-ⵢⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ: ⵙ ⵜⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ ⴷ ⴷⴷⴻⵅⵅⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV9_19","096_9_19","REV","9","19","19","ⵎⵉⵏⵣⵉ ⵚⵚⵓⵍⵟⴰ ⵏⵙⴻⵏ ⴰⵇⴰ-ⵜⵜ ⴷⴻⴳ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⴷ ⵉⴽⴻⵏⵏⴰⵙⴻⵏ ⵏⵙⴻⵏ, ⵎⵉⵏⵣⵉ ⵉⴽⴻⵏⵏⴰⵙⴻⵏ ⵏⵙⴻⵏ ⴳⴳⵉⵏ ⴰⵎ ⵉⴼⵉⵖⵔⴰⵏ ⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵣⴻⴵⵉⴼⴻⵏ, ⵓⵛⴰ ⵜⵜⵊⴻⵢⵢⵃⴻⵏ ⵣⵣⴰⵢⵙⴻⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV9_20","096_9_20","REV","9","20","20","ⵉⵡⴷⴰⵏ ⵉⵇⵇⵉⵎⴻⵏ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⵛⴰ ⵙ ⵊⵊⵔⴰⵢⴻⵃ-ⴰ, ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵛⴰ ⵣⵉ ⵍⵅⴻⴷⵎⴻⵜ ⵏ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵙⴻⵏ ⴰⵍⴰⵎⵉ ⵡⴰⵔ ⵄⴻⴱⴱⴷⴻⵏ ⵄⴰⴷ ⵛⵛⵡⴰⵟⴻⵏ ⴷ ⵍ’ⴰⵚⵏⴰⵎ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵡⴻⵥⵔⵓ ⴷ ⵓⴽⴻⵛⵛⵓⴹ, ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵜⵜⵡⵉⵍⵉⵏ, ⵡⴰⵔ ⵉⵜⵜⴻⵙⵍⵉⵏ, ⵡⴰⵔ ⵉⴳⴳⵓⵔⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV9_21","096_9_21","REV","9","21","21","ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵛⴰ ⵣⴻⴳ ⵡⴻⵏⵖⴰⵢ ⵏⵙⴻⵏ, ⵍⴰ ⵣⵉ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵍⴰ ⵣⵉ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV10_1","096_10_1","REV","10","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⴰⵙⴻⵢⵏⵓ ⵓⵛⴰ ⵜⴰⵙⵍⵉⵜ ⵏ ⵡⴻⵏⵥⴰⵔ ⵏ ⵓⵊⴻⵏⵏⴰ ⵜⴱⴻⴷⴷ ⴰⵙ ⵅ ⵓⵣⴻⴵⵉⴼ. ⴰⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵎ ⵜⴼⵓⵛⵜ, ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵉⴱⵉⵍⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("RV10_2","096_10_2","REV","10","2","2","ⵉⵟⵟⴻⴼ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴰⵎⴻⵥⵢⴰⵏ ⵢⴰⵔⵣⴻⵎ. ⵉⵙⵙⴰⵔⵙ ⴰⴹⴰⵔ ⵏⵏⴻⵙ ⴰⴼⵓⵙⵉ ⵅ ⵍⴻⴱⵃⴰⵔ, ⴰⴹⴰⵔ ⵏⵏⴻⵙ ⴰⵣⴻⵍⵎⴰⴹ ⵅ ⵜⴻⵎⵎⵓⵔⵜ, ");
INSERT INTO rift_vpl VALUES ("RV10_3","096_10_3","REV","10","3","3","ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ, ⴰⵎ ⵡⴰⵢⵔⴰⴷ ⵉⵜⵜⵣⴻⵀⵀⴰⵔⴻⵏ, ⵓⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵍⴰⵎⵉ ⴷⴷ-ⵉⵍⴰⵖⴰ, ⵊⵊⵉⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴰⴷ ⵙⵍⴻⵏ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV10_4","096_10_4","REV","10","4","4","ⵍⴰⵎⵉ ⴽⴻⵎⵎⵍⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ ⵏⵏⵉ ⴰⵡⴰⵍ ⵏⵙⴻⵏ, ⵜⵓⵖⴰ ⵅⵙⴻⵖ ⴰⴷ ⵜ ⴰⵔⵉⵖ, ⵎⴰⵛⴰ ⵙⵍⵉⵖ ⵉ ⵢⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⵍⴰⵖⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ: “ⴻⴳⴳ ⴰⵛⴻⵎⵎⵉⵄ ⵅ ⵎⵉⵏ ⵏⵏⴰⵏ ⵙⴻⴱⵄⴰ ⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ, ⵡⴰⵔ ⵜ ⵜⵜⴰⵔⵉ ⵛⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV10_5","096_10_5","REV","10","5","5","ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⵜⵓⵖⴰ ⵥⵔⵉⵖ ⵉⴱⴻⴷⴷ ⵅ ⵍⴻⴱⵃⴰⵔ ⴷ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⴽⵙⵉ ⴰⴼⵓⵙ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ");
INSERT INTO rift_vpl VALUES ("RV10_6","096_10_6","REV","10","6","6","ⵓⵛⴰ ⵉⵊⵊⵓⴵ ⵖⴰⵔ ⵡⴻⵏⵏⵉ ⵉⴷⴷⴰⵔⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵓ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵎⵉⵏ ⴷⴰⵢⴻⵙ ⵓⵍⴰ ⴷ ⵍⴻⴱⵃⴰⵔ ⴷ ⵎⵉⵏ ⴷⴰⵢⴻⵙ: “ⵡⴰⵔ ⵜⴻⵇⵇⵉⵎ ⴱⵓ ⵍⵡⴻⵇⵜ ⵄⴰⴷ!” ");
INSERT INTO rift_vpl VALUES ("RV10_7","096_10_7","REV","10","7","7","ⵎⴰⵖⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ, ⵅⵎⵉ ⵖⴰ ⵉⵙⵓⴹ ⵏⴻⵜⵜⴰ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ, ⴳⴳⵓⵔ ⴰⴷ ⵉⴽⵎⴻⵍ ⵙⵙⵉⵔⵔ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵜⵜⴱⴰⵔⵔⴻⵃ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV10_8","096_10_8","REV","10","8","8","ⵓⵛⴰ ⵜⵎⵉⵊⵊⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉ ⵙⵍⵉⵖ ⵜⴻⵙⵙⵉⵡⴻⵍ ⵖⴰⵔⵉ ⵉⵛⵜ ⵏ ⵜⵡⴰⵍⴰ ⵏⵏⴻⵖⵏⵉⵜ, ⵜⴻⵏⵏⴰ: “ⵓⵢⵓⵔ, ⴽⵙⵉ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴰⵎⴻⵥⵢⴰⵏ ⵢⴰⵔⴻⵣⵎⴻⵏ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵅ ⵍⴻⴱⵃⴰⵔ ⴷ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV10_9","096_10_9","REV","10","9","9","ⵓⵛⴰ ⵓⵢⵓⵔⴻⵖ ⵖⴰⵔ ⵍⵎⴰⵍⴰⴽ, ⵜⵜⴰⵔⴻⵖ ⴰⵙ ⴰⴷ ⴰⵢⵉ ⵉⵡⵛ ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⴰⵎⴻⵥⵢⴰⵏ. ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴽⵙⵉ ⴰⴷⵍⵉⵙ-ⴰ ⴰⵎⴻⵥⵢⴰⵏ, ⵜⴻⵛⵛⵉⴷ ⵜ ⵓⵛⴰ ⴰⴷ ⵉⵙⵙⴰⵔⵣⴻⴳ ⴰⵄⴻⴷⴷⵉⵙ ⵏⵏⴻⵛ, ⵎⴰⵛⴰ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵛ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵎⵉⵥⵉⴷ ⴰⵎ ⵜⴰⵎⵎⴻⵏⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV10_10","096_10_10","REV","10","10","10","ⵏⴻⵛⵛ ⴽⵙⵉⵖ ⴰⴷⵍⵉⵙ ⴰⵎⴻⵥⵢⴰⵏ ⵉⵜⵜⵡⴰⵏⵏⴹⴻⵏ ⵣⴻⴳ ⵓⴼⵓⵙ ⵏ ⵍⵎⴰⵍⴰⴽ ⵓⵛⴰ ⵛⵛⵉⵖ ⵜ. ⵜⵓⵖⴰ-ⵜ ⴷ ⴰⵎⵉⵥⵉⴷ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵉⵏⵓ, ⵎⴰⵛⴰ ⵍⴰⵎⵉ ⵜ ⵛⵛⵉⵖ, ⵢⴰⵔⵣⴻⴳ ⴷⴻⴳ ⵓⵄⴻⴷⴷⵉⵙ ⵉⵏⵓ. ");
INSERT INTO rift_vpl VALUES ("RV10_11","096_10_11","REV","10","11","11","ⵅⴻⵏⵏⵉ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵄⴰⵡⴻⴷ ⵍⵡⴻⵇⵜ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵏⴻⴱⴱⵉⴷ ⵉ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⴻⴳⵏⵓⵙ ⴷ ⵜⴻⵎⵎⵓⵔⴰ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV11_1","096_11_1","REV","11","1","1","ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ, ⵉⴳⴳⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵇⴻⵟⵟⴰⴱ ⵏ ⵍⴻⵄⴱⴰⵔ, ⵓⵛⴰ ⵉⴱⴻⴷⴷ ⴷⵉⵏ ⵍⵎⴰⵍⴰⴽ, ⵉⵏⵏⴰ: “ⴽⴽⴰⵔ ⵓⵛⴰ ⵄⴱⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⴷ ⵓⵄⴰⵍⵟⴰⵔ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⴻⵙ ⵉⵄⴻⴱⴱⴷⴻⵏ,    ");
INSERT INTO rift_vpl VALUES ("RV11_2","096_11_2","REV","11","2","2","ⵎⴰⵛⴰ ⵍⴻⵎⵔⴰⵃ ⵏⵏⵉ ⵖⴰⵔ ⴷⴰⵅⴻⵍ ⵏ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴻⵊⵊ ⵉ-ⵜ, ⵡⴰⵔ ⵜ ⵜⵜⵄⴻⴱⴱⴰⵔ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵉⵎⵎⴻⵡⵛ ⵉ ⵍⴻⴳⵏⵓⵙ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵄⴻⴼⵙⴻⵏ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵜⵏⴰⵢⴻⵏ ⵓ ⴰⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵢⵓⵔⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("RV11_3","096_11_3","REV","11","3","3","ⵏⴻⵛⵛ ⴰⴷ ⵡⵛⴻⵖ ⵚⵚⵓⵍⵟⴰ ⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵛⵀⵓⴷ ⵉⵏⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵏⴻⴱⴱⴰⵏ ⵙ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵍⴻⴼ ⵓ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ, ⴰⵎ ⵢⴰⵔⴹⴻⵏ ⵜⵅⴰⵏⵛⴻⵜ ⵏ ⵡⴻⵛⴹⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV11_4","096_11_4","REV","11","4","4","ⵏⵉⵜⵏⵉ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵜⵣⵉⵜⵓⵏⵉⵏ ⴷ ⵜⵏⴰⵢⴻⵏ ⵏ ⵍⴻⵇⵏⴰⴷⴻⵍ ⵉ ⵉⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵡⵓⴷⴻⵎ ⵏ ⵙⵉⴷⵉ ⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV11_5","096_11_5","REV","11","5","5","ⵎⴰⵍⴰ ⴷⵉⵏ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ ⵉⵅⵙ ⴰⴷ ⵜⴻⵏ ⵉⵀⵡⴻⵍ, ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⴻⵛⵛ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ. ⴰⵎⵎⵓ ⵉ ⵖⴰ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵉⵏⵏⵉ ⵉⵅⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⴹⴰⵔⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV11_6","096_11_6","REV","11","6","6","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵇⵇⵏⴻⵏ ⴰⵊⴻⵏⵏⴰ, ⵃⵉⵎⴰ ⵡⴰⵔ ⴷⴷ-ⵉⵡⴻⵟⵟⵉ ⵡⴻⵏⵥⴰⵔ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⵏⵉ ⴷⵉ ⵖⴰ ⵏⴻⴱⴱⴰⵏ ⵏⵉⵜⵏⵉ, ⵓ ⵖⴰⵔⵙⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⴰⵔⵔⴻⵏ ⴰⵎⴰⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵙⴻⵢⵢⵃⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ ⵙ ⵎⴰⵔⵔⴰ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵎⴻⵍⵎⵉ ⵎⴰ ⵅⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV11_7","096_11_7","REV","11","7","7","ⵅⵎⵉ ⵖⴰ ⴽⴻⵎⵎⵍⴻⵏ ⵛⵛⵀⴰⴷⴰⵜ ⵏⵙⴻⵏ, ⴰⴷ ⴷⴷ-ⵉⴳⴻⵄⵄⴻⴷ ⵍⵡⴻⵃⵛ ⵣⵉ ⵍⴰⴵⴰⵖ, ⴰⴷ ⴽⵉⵙⴻⵏ ⵉⵎⵎⵏⴻⵖ, ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵖⴻⵍⵍⴻⴱ ⵓⵛⴰ ⴰⴷ ⵜⴻⵏ ⵉⵏⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV11_8","096_11_8","REV","11","8","8","ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷⴻⴳ ⵡⴰⵣⵣⴰⵢ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵙ ⵍⵎⴻⵄⵏⴰ ⴰⵔⵔⵓⵃⵉ ⵏⵏⴻⵙ ‘ⵙⴰⴷⵓⵎ’ ⴷ ‘ⵎⵉⵚⵔⴰ’, ⵎⴰⵏⵉ ⵏⵖⵉⵏ ⵙⵉⴷⵉⵜⵙⴻⵏ ⵅ ⵚⵚⴰⵍⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("RV11_9","096_11_9","REV","11","9","9","ⵓⵛⴰ ⵣⵉ ⵛⵛⵓⵄⵓⴱ ⴷ ⵜⵇⴻⴱⴱⴰⵍ ⴷ ⵉⵍⵙⴰⵡⴻⵏ ⴷ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵥⴰⵔⴻⵏ ⵉⵡⴷⴰⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ, ⵍⵇⴻⴷⴷ ⵏ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⵡⴻⵣⵢⴻⵏ, ⵡⴰⵔ ⵜⵜⴻⵊⵊⵉⵏ ⵍⵅⴻⵛⴱⴰⵜ ⵏⵙⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵎⵎⴰⵔⵙⴻⵏⵜ ⴷⴻⴳ ⵉⵎⴻⴹⵍⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV11_10","096_11_10","REV","11","10","10","ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⴼⴰⵔⵃⴻⵏ, ⴰⴷ ⵄⴻⵢⵢⴷⴻⵏ, ⴰⴷ ⴰⵔⴻⵣⴼⴻⵏ ⵉⵊⵊⴻⵏ ⵖⴰⵔ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⴰⴷ ⵙⵙⴻⴽⴽⴻⵏ ⵉⴽⴰⴷⵓⵜⴻⵏ ⵉ ⵡⴰⵢⴰⵡⵢⴰ, ⵎⵉⵏⵣⵉ ⵜⵏⴰⵢⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ-ⴰ ⵜⵓⵖⴰ ⵖⴻⵣⵣⴰⵏ ⴷⴻⴳ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV11_11","096_11_11","REV","11","11","11","ⵎⴰⵛⴰ ⴰⵡⴰⵔⵏⵉ ⵜⵍⴰⵜⴰ ⵏ ⵡⵓⵙⵙⴰⵏ ⴷ ⵡⴻⵣⵢⴻⵏ ⵢⵓⴷⴻⴼ ⴷⴰⵢⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵉⴷⴷⴰⵔⴻⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ, ⴱⴻⴷⴷⴻⵏ ⵅ ⵉⴹⴰⵔⴻⵏ ⵏⵙⴻⵏ ⵓ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅⴰⵙⴻⵏ ⴰⵔⵔⵓⵃ ⵏ ⵜⵓⴷⴰⵔⵜ ⵓⵛⴰ ⵜⵉⴳⴳⵯⵓⴷⵉ ⵜⴻⵎⵖⴰⵔ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⴻⵏ ⵉⵥⵔⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RV11_12","096_11_12","REV","11","12","12","ⵏⵉⵜⵏⵉ ⵙⵍⵉⵏ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⵜᵉⵜⵜⵍⴰⵖⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵇⵇⴰⵔ ⴰⵙⴻⵏ: “ⴳⴻⵄⵄⴷⴻⵎ-ⴷⴷ ⴷⴰ!” ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⴳⴻⵄⵄⴷⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⴷⴻⴳ ⵓⵙⴻⵢⵏⵓ ⵓⵛⴰ ⵍⵄⴻⴷⵢⴰⵏ ⵏⵙⴻⵏ ⵥⵔⵉⵏ ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV11_13","096_11_13","REV","11","13","13","ⴷⵉ ⵜⵙⴰⵄⵄⴻⵜ ⵏⵏⵉ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ. ⵉⵛⵜ ⵏ ⵜⵄⴻⵛⵛⴰⵔⵜ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴻⵀⴷⴻⵎ ⵓⵛⴰ ⵙⴻⴱⵄⴰ-ⴰⵍⴰⴼ ⵏ ⵢⴻⵔⵢⴰⵣⴻⵏ ⵖⴰⵔⵙⴻⵏ ⵉⵙⴻⵎ ⵉⵛⴻⵏⵏⵄⴻⵏ ⵎⵎⵓⵜⴻⵏ ⵙ ⵡⴻⵏⵀⴻⵣⵣⵉ-ⵢⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ. ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ, ⴷⴻⵡⵍⴻⵏ ⴳⴳⵯⴻⴷⴻⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵙⵙⵓⵄⵍⴰⵏ ⵣⵉ ⴰⵔⴻⴱⴱⵉ ⵏ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RV11_14","096_11_14","REV","11","14","14","‘ⵅⵣⴰⵔ, ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⵓⵛⵜⴰⵜ ⵄⴷⵓⵏⵜ, ⵓⵛⴰ ⵅⵣⴰⵔ ‘ⵓⵛⵜ!’ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⴰⴷ ⴷⴷ-ⵜⴰⵙ ⴷⴻⵖⵢⴰ. ");
INSERT INTO rift_vpl VALUES ("RV11_15","096_11_15","REV","11","15","15","ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵉⵙⵓⴹ ⴷⵉ ⵍⴱⵓⵇ ⵏⵏⴻⵙ ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏⵜ-ⵉ-ⴷⴷ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⵜⵍⴰⵖⴰⵏⵜ: “ⵜⴰⴳⴻⵍⴷⴰ ⵏ ⴷⴷⵓⵏⴻⵛⵜ ⴰⵇⴰ-ⵜⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵓ ⵏ ⵍⵎⴰⵙⵉⵃ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴽⴻⵎ ⴰⵎ ⵓⵊⴻⴵⵉⴷ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ.” ");
INSERT INTO rift_vpl VALUES ("RV11_16","096_11_16","REV","11","16","16","ⴰⵔⴻⴱⵄⴰ ⵓ ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ, ⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵅ ⵍⴻⴽⵔⴰⵙⵉ ⵏⵙⴻⵏ ⵉⴳⴻⵍⵍⴷⴻⵏ, ⵡⴹⴰⵏ ⵙ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵙⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RV11_17","096_11_17","REV","11","17","17","ⵏⵏⴰⵏ: “ⵏⴻⵛⵛⵉⵏ ⵏⴻⵜⵜⵇⴰⴷⴰ ⵛⴻⴽ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ, ⴰⵇⴰ ⵜⴻⴽⵙⵉⴷ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵛ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵜⴻⴱⴷⵉⴷ ⴰⴷ ⵜⵃⴻⴽⵎⴻⴷ ⴰⵎ ⵓⵊⴻⴵⵉⴷ. ");
INSERT INTO rift_vpl VALUES ("RV11_18","096_11_18","REV","11","18","18","ⵍⴻⴳⵏⵓⵙ ⵜⵓⵖⴰ ⵅⴻⵢⵢⵇⴻⵏ ⵅⴰⴽ, ⵎⴰⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵛ, ⵓⵛⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ ⵍⵡⴻⵇⵜ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⵜⵡⴰⵃⴰⵙⴱⴻⵏ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵍⵎⵓⵏⴻⵜ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵛ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓ ⵉ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ, ⴰⵎ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⵎ ⵢⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵓ ⵛⴻⴽ ⴰⴷ ⵜⴰⵔⴻⵢⵢⴱⴻⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴰⵔⴻⴷⴵⴻⵏ ⵜⴰⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV11_19","096_11_19","REV","11","19","19","ⵜᵉⵏⵏⵓⵔⵣⴻⵎ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⴰⵍⴰⵎⵉ ⵜᵉⵜⵜⵡⴰⵥⴰⵔ ⵜⵜⴰⴱⵓⵜ ⵏ ⵍⵄⴰⵀⴷ ⵏⵏⴻⵙ ⴷⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⴽⴽⴰⵔⴻⵏ ⵡⴰⵙⵙⴰⵎⴻⵏ ⴷ ⵡⴰⵊⵊⴰⵊⴻⵏ ⴷ ⵜⵎⵉⵊⵊⴰⵡⵉⵏ ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓ ⵡⴹⴰⵏ ⵉⴱⵇⵓⵇⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ.    ");
INSERT INTO rift_vpl VALUES ("RV12_1","096_12_1","REV","12","1","1","ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵥⴰⵔ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ: ⵉⵛⵜ ⵏ ⵜⵎⴻⵟⵟⵓⵜ ⵜⵢⴰⵔⴹ ⵜⴰⴼⵓⵛⵜ, ⵓ ⵜⴰⵣⵉⵔⵉ ⵙⴰⴷⵓ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵓⵛⴰ ⵖⴰⵔⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵜⵜⴰⵊ ⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵜⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV12_2","096_12_2","REV","12","2","2","ⵜⵓⵖⴰ ⵜⴻⴽⵙⵉ ⴷⴷⴻⵢⵙⴻⵜ, ⵜⴻⵙⵖⵓⵢⵢⵓ ⵙ ⵍⴻⵡⵊⴻⵄ, ⵜᵉⵜⵜⵡⴰⵃⵚⴰⵔ ⵙ ⵓⵏⴻⵣⴱⴰⵔ ⵏ ⵜⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("RV12_3","096_12_3","REV","12","3","3","ⵅⴻⵏⵏⵉ ⵜᵉⵜⵜⵡⴰⵥⴰⵔ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⴻⵖⵏⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵛⵜ ⵏ ⵍⵀⴰⵢⵛⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴰⵣⴻⴳⴳⵡⴰⵖⵜ ⴰⵎ ⵜⵎⴻⵙⵙⵉ, ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ, ⵓⵛⴰ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵜⵜⵉⵊⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV12_4","096_12_4","REV","12","4","4","ⵓⵛⴰ ⴰⴽⴻⵏⵏⴰⵙ ⵏⵏⴻⵙ ⵉⴼⴰⵔⴹ ⵉⵛⵜ ⵏ ⵜⵜⵓⵍⵓⵜ ⵏ ⵉⵜⵔⴰⵏ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵙⵙⵥⴰⵔⴻⵢⵢⴻⴹ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ⵓⵛⴰ ⵍⵀⴰⵢⵛⴻⵜ ⵜⵓⵖⴰ ⵜⴱⴻⴷⴷ ⵣⵣⴰⵜ ⵉ ⵜⵎⴻⵟⵟⵓⵜ ⵉ ⵖⴰ ⵢⴰⵔⵡⴻⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵚⴰⵔⴹ ⵎⵎⵉⵙ ⵅⵎⵉ ⵜ-ⵉ-ⴷⴷ ⵉ ⵖⴰ ⵜⴰⵔⵓⵡ. ");
INSERT INTO rift_vpl VALUES ("RV12_5","096_12_5","REV","12","5","5","ⵓⵛⴰ ⵜⵓⵔⵓⵡ-ⴷⴷ ⵎⵎⵉⵙ, ⴰⵔⵢⴰⵣ ⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ ⵅ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵙ ⵓⵣⴻⴵⴰⴹ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵓⵛⴰ ⵎⵎⵉⵙ ⵉⵎⵎⴻⴽⵙⵉ ⴷⴻⵖⵢⴰ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵓ ⵖⴰⵔ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV12_6","096_12_6","REV","12","6","6","ⵎⴰⵛⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵜⴰⵔⵡⴻⵍ ⵖⴰⵔ ⵍⴻⵅⵍⴰ, ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵓⵖⴰ ⴷ ⴰⵙ ⵉⴳⴳⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵎⵛⴰⵏ ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵙⵙⴻⵛⵛⴻⵏ, ⵍⵇⴻⴷⴷ ⵏ ⵡⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⵏ ⵓ-ⵙⴻⵜⵜⵉⵏ ⵏ ⵡⵓⵙⵙⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV12_7","096_12_7","REV","12","7","7","ⵓⵛⴰ ⵉⴽⴽⴰⵔ ⵓⵎⴻⵏⵖⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ⵎⵉⵅⴰⵢⵉⵍ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵎⵎⴻⵏⵖⴻⵏⵜ ⴰⴽ-ⴷ ⵍⵀⴰⵢⵛⴻⵜ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⵀⴰⵢⵛⴻⵜ ⴷ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵎⵎⴻⵏⵖⴻⵏⵜ, ");
INSERT INTO rift_vpl VALUES ("RV12_8","096_12_8","REV","12","8","8","ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵊⵀⵉⴷⴻⵏ ⵛⴰ ⵓⵛⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼ ⵄⴰⴷ ⵡⴻⵎⵛⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉ ⵏⵉⵜⵏⵉ. ");
INSERT INTO rift_vpl VALUES ("RV12_9","096_12_9","REV","12","9","9","ⵜⴻⵎⵎⴻⵏⴹⴰⵔ-ⴷⴷ ⵍⵀⴰⵢⵛⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵓⴼⵉⵖⴰⵔ ⵏⵏⵉ ⵜⵓⵖⴰ ⵣⵉⵛ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⵉⴱⵍⵉⵙ’ ⵏⵉⵖ ‘ⵛⵛⵉⵟⴰⵏ’, ⵡⴻⵏⵏⵉ ⵉⵖⴻⴽⴽⵡⴰⵏ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ, ⵡⴰⵀ, ⴰⵇⴰ ⵉⵎⵎⴻⵏⴹⴰⵔ-ⴷⴷ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⴻⵙ ⵎⵎⴻⵏⴹⴰⵔⴻⵏⵜ-ⵉ-ⴷⴷ ⵄⴰⵡⴻⴷ ⴰⴽⵉⴷⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV12_10","096_12_10","REV","12","10","10","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵜⴻⵇⵇⴰⵔ ⵙ ⵊⵊⴻⵀⴷ: “ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵓⴼⴻⴽⴽⵉ ⴷ ⵚⵚⵓⵍⵟⴰ ⴷ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⵎⵉⵏⵣⵉ ⵡⴻⵏⵏⵉ ⵉⴹⴻⵍⵎⴻⵏ ⴰⵢⵜⵎⴰⵜⵏⴻⵖ, ⴰⵇⴰ ⵉⵎⵎⴻⵏⴹⴰⵔ, ⵡⴻⵏⵏⵉ ⵉ ⵜⴻⵏ ⵉⴹⴻⵍⵎⴻⵏ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RV12_11","096_12_11","REV","12","11","11","ⵖⴻⵍⵍⴱⴻⵏ ⵅⴰⵙ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵣⵎⴰⵔ, ⴷ ⵡⴰⵡⴰⵍ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵙⵙⵄⵉⵣⵣⴻⵏ ⵛⴰ ⵜⵓⴷⴰⵔⵜ ⵏⵙⴻⵏ ⴰⵍ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RV12_12","096_12_12","REV","12","12","12","ⵅ ⵓⵢⴻⵏⵏⵉ, ⴼⴰⵔⵃⴻⵎ, ⴰ ⵉⵊⴻⵏⵡⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵉⵣⴻⴷⴷⵖⴻⵏ! ⵓⵛⵜ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⴱⵃⴰⵔ, ⵉⴱⵍⵉⵙ ⴰⵇⴰ ⵉⵀⵡⴰ-ⴷⴷ ⵖⴰⵔⵡⴻⵎ ⵙ ⵜⴻⴼⵇⴻⵃⵜ ⵏⵏⴻⵙ ⵉⵎⵖⴰⵔⴻⵏ ⴰⵟⵟⴰⵙ, ⵉⵙⵙⴻⵏ ⴰⴷ ⵖⴰⵔⴻⵙ ⵉⵇⵇⵉⵎ ⴷⵔⵓⵙⵜ ⵏ ⵍⵡⴻⵇⵜ ⵡⴰⵀⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV12_13","096_12_13","REV","12","13","13","ⴰⵍⴰⵎⵉ ⵍⵀⴰⵢⵛⴻⵜ ⵜⵓⴼⴰ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵜⴻⵎⵎⴻⵏⴹⴰⵔ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵜⴻⴹⴼⴰⵔ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵉ ⴷⴷ-ⵢⵓⵔⵡⴻⵏ ⵎⵎⵉⵙ ⴷ ⴰⵡⵜⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RV12_14","096_12_14","REV","12","14","14","ⵎⵎⴻⵡⵛⴻⵏ ⴰⵙ ⵉ ⵜⵎⴻⵟⵟⵓⵜ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴻⴼⵔⵉⵡⴻⵏ ⵏ ⵓⴳⵉⴷⴻⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⴹⵡⵓ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⵅⵍⴰ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵙⵙⴻⵛⵛ ⴷⵉⵏⵏⵉ, ⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ ⴷ ⵍⴻⵡⵇⴰⵜ ⴷ ⵉⵊⵊ ⵏ ⵡⴻⵣⵢⴻⵏ ⵏ ⵢⵉⵊⵊ ⵏ ⵍⵎⵉⵊⴰⵍ ⵏ ⵍⵡⴻⵇⵜ, ⵎⴰⵏⵉ ⵡⴰⵔ ⵜⵜ ⵉⵥⴰⵔⵔ ⵓⴼⵉⵖⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("RV12_15","096_12_15","REV","12","15","15","ⴰⴼⵉⵖⴰⵔ ⵉⵙⵙⵓⵙⴻⴼ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⴰⵡⴰⵔⵏⵉ ⵉ ⵜⵎⴻⵟⵟⵓⵜ, ⵉⴳⴳⴰ ⵉⵛⵜ ⵏ ⵍⵃⴻⵎⵍⴻⵜ ⵏ ⵡⴰⵎⴰⵏ ⴰⵎ ⵢⴻⵖⵣⴰⵔ, ⵃⵉⵎⴰ ⴰⴷ ⵜⵜ ⴰⵡⵢⴻⵏ ⵡⴰⵎⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV12_16","096_12_16","REV","12","16","16","ⵜⴰⵎⵎⵓⵔⵜ ⵜⵄⴰⵡⴻⵏ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵓⵛⴰ ⵜⴰⵔⵣⴻⵎ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ, ⵜⴻⵃⵔⵓⵡ ⵉⵖⵣⴰⵔ ⵡⴻⵏⵏⵉ ⴷⴷ-ⵉⵙⵙⵓⵙⴼⴻⵏ ⵍⵀⴰⵢⵛⴻⵜ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV12_17","096_12_17","REV","12","17","17","ⵓⵛⴰ ⵍⵀⴰⵢⵛⴻⵜ ⵜⵅⴻⵢⵢⴻⵇ ⴰⵟⵟⴰⵙ ⵅ ⵜⵎⴻⵟⵟⵓⵜ ⵓⵛⴰ ⵜⵓⵢⵓⵔ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵢⵉⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵣⵉ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⴰⴽ-ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⴷⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ");
INSERT INTO rift_vpl VALUES ("RV13_1","096_13_1","REV","13","1","1","ⵓⵛⴰ ⴷⴻⵡⵍⴻⵖ ⴱⴻⴷⴷⴻⵖ ⵅ ⵉⵊⴷⵉ ⵖⴰⵔ ⵜⵎⴰ ⵏ ⵍⴻⴱⵃⴰⵔ, ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⵉⴳⴻⵄⵄⴻⴷ-ⴷⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ, ⵖⴰⵔⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ. ⵅ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵏⵏⴻⵙ ⵄⴻⵛⵔⴰ ⵏ ⵜⵜⵉⵊⴰⵏ ⵓⵛⴰ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵙ ⵉⵜⵜⵡⴰⵔⵉ ⵅⴰⵙⴻⵏ ⵉⵊⵊ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵜⵜⴻⴽⴼⵉⵔ. ");
INSERT INTO rift_vpl VALUES ("RV13_2","096_13_2","REV","13","2","2","ⵍⵡⴻⵃⵛ ⵉ ⵥⵔⵉⵖ, ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵓⵖⵉⵍⴰⵙ, ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⵎ ⵢⵉⴹⴰⵔⴻⵏ ⵏ ⴷⴷⵓⴱ, ⴰⵅⴻⵏⴼⵓⵛ ⵏⵏⴻⵙ ⴰⵎ ⵓⵅⴻⵏⴼⵓⵛ ⵏ ⵡⴰⵢⵔⴰⴷ. ⵍⵀⴰⵢⵛⴻⵜ ⵜⴻⵡⵛⴰ ⴰⵙ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ ⴷ ⵍⵄⴰⵔⵛ ⵏⵏⴻⵙ ⵓⵍⴰ ⴷ ⵚⵚⵓⵍⵟⴰ ⵉⵎⵖⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV13_3","096_13_3","REV","13","3","3","ⵉⵊⵊⴻⵏ ⵣⴻⴳ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵏⴻⵙ ⵉⴳⴳⴰ ⴰⵅⵎⵉ ⵜ ⵡⵜⵉⵏ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵅⴻⵏⵏⵉ ⵉⵜⵜⵡⴰⵙⵙⴳⴻⵏⴼⴰ ⵓⵢⴻⵣⵣⵉⵎ ⵏⵏⴻⵙ ⵉ ⵉⴳⴳⵉⵏ ⴰⵅⵎⵉ ⵉⵢⵣⴻⵎ ⴰⵍ ⵍⵎⴻⵡⵜ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⴰⵎⵎⵓⵔⵜ ⵜⴻⴹⴼⴰⵔ ⵍⵡⴻⵃⵛ ⵙ ⵓⵜⴻⴱⵀⴻⵜ ⴰⵎⴻⵇⵇⵔⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV13_4","096_13_4","REV","13","4","4","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵄⴻⴱⴷⴻⵏ ⵍⵀⴰⵢⵛⴻⵜ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵡⵛⴰ ⵚⵚⵓⵍⵟⴰ ⵉ ⵍⵡⴻⵃⵛ, ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵄⴻⴱⴷⴻⵏ ⵍⵡⴻⵃⵛ, ⵏⵏⴰⵏ: “ⵡⵉ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⵉ ⵍⵡⴻⵃⵛ?” ⵓ: “ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⴽⵉⴷⴻⵙ ⵉⵎⵎⵄⴰⵍⴰⵏ?” ");
INSERT INTO rift_vpl VALUES ("RV13_5","096_13_5","REV","13","5","5","ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵉ ⵍⵡⴻⵃⵛ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ ⵙ ⵓⴽⴻⴱⴱⴰⵔ ⵓ ⵙ ⵓⵛⴻⵇⵇⴻⴼ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⵃⵉⵎⴰ ⴰⴷ ⵉⵅⴷⴻⵎ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵜⵏⴰⵢⴻⵏ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵢⵓⵔⴻⵏ.    ");
INSERT INTO rift_vpl VALUES ("RV13_6","096_13_6","REV","13","6","6","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⴰⵔⵣⴻⵎ ⴰⵇⴻⵎⵎⵓⵎ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴻⵇⵇⴻⴼ ⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⵛⴻⵇⵇⴻⴼ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ ⵓ ⴷⵉ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ. ");
INSERT INTO rift_vpl VALUES ("RV13_7","096_13_7","REV","13","7","7","ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⴰⴽ-ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵖⴻⵍⵍⴻⴱ. ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵚⵚⵓⵍⵟⴰ ⵅ ⵎⴰⵔⵔⴰ ⵜⵉⵇⴻⴱⴱⴰⵍ ⴷ ⵛⵛⵓⵄⵓⴱ ⴷ ⵢⵉⵍⵙⴰⵡⴻⵏ ⴷ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RV13_8","096_13_8","REV","13","8","8","ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵜ ⵄⴻⴱⴷⴻⵏ, ⵉⵏⵏⵉ ⵓⵎⵉ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏⵙⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵏ ⵢⴻⵣⵎⴰⵔ ⵡⴻⵏⵏⵉ ⵓⵎⵉ ⵉⵜⵜⵡⴰⵖⴰⵔⵚ ⵇⴱⴻⵍ ⵜⴰⵎⴰⵔⵙⵉⵡⵜ ⵏ ⴷⴷⵓⵏⴻⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("RV13_9","096_13_9","REV","13","9","9","ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏ ⵉⵎⴻⵣⵣⵓⵖⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵙⴻⵍ. ");
INSERT INTO rift_vpl VALUES ("RV13_10","096_13_10","REV","13","10","10","ⵎⴰⵍⴰ ⴷⵉⵏ ⵉⵊⵊⴻⵏ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵉⴷⴼⴻⵏ ⵖⴰⵔ ⵜⵎⴻⵃⴱⴰⵙⵜ, ⴰⴷ ⵉⵜⵜⵡⴰⵏⴷⴻⵀ ⵏⴻⵜⵜⴰ ⵙ ⵢⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⵎⴻⵃⴱⴰⵙⵜ. ⵉⵏⵏⵉ ⵉⵏⵖⵉⵏ ⵙ ⵙⵙⵉⴼ, ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵙⵙⵉⴼ: ⴰⵇⴰ ⴷⴰ ⵉⵜⵜⴱⴰⵏ-ⴷⴷ ⵍ’ⵉⵎⴰⵏ ⴷ ⵚⵚⴱⴰⵔ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV13_11","096_13_11","REV","13","11","11","ⵅⴻⵏⵏⵉ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⵏⵏⴻⵖⵏⵉ ⵉⵜⵜⴳⴻⵄⵄⴰⴷ-ⴷⴷ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵓⵛⴰ ⵢⴰⵔⵡⴻⵙ ⴷⴻⴳ ⵉⵣⵎⴰⵔ, ⵎⴰⵛⴰ ⵉⵙⵙⵉⵡⴻⵍ ⴰⵎ ⵍⵀⴰⵢⵛⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RV13_12","096_13_12","REV","13","12","12","ⵜⵓⵖⴰ ⵉⵃⴻⴽⴽⴻⵎ ⵙ ⵎⴰⵔⵔⴰ ⵚⵚⵓⵍⵟⴰ ⵏ ⵍⵡⴻⵃⵛ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵣⵣⴰⵜⴻⵙ, ⵢⴰⵔⵔⴰ-ⴷⴷ ⵜⴰⵎⵎⵓⵔⵜ ⴷ ⵉⵎⴻⵣⴷⴰⵖ ⵏⵏⴻⵙ ⵎⴰⵔⵔⴰ ⴰⴷ ⵄⴻⴱⴷⴻⵏ ⵍⵡⴻⵃⵛ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⴻⵏⴼⴰⵏ ⵣⴻⴳ ⵓⵢⴻⵣⵣⵉⵎ ⵉ ⵉⴳⴳⵉⵏ ⴰⵅⵎⵉ ⵉⵢⵣⴻⵎ ⴰⵍ ⵍⵎⴻⵡⵜ. ");
INSERT INTO rift_vpl VALUES ("RV13_13","096_13_13","REV","13","13","13","ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⴳⴳ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴰⵍⴰⵎⵉ ⵉ ⵖⴰ ⵢⴰⵔⵔ ⵜⵉⵎⴻⵙⵙⵉ ⴰⴷ ⴷⴷ-ⵜⴻⵀⵡⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵜⴻⵎⵎⵓⵔⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV13_14","096_13_14","REV","13","14","14","ⴰⴷ ⵉⵖⵡⴰ ⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵏⵜ ⵉⴳⴳ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⵡⴻⵃⵛ ⴰⵎⴻⵣⵡⴰⵔⵓ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵢⵉⵏⵉ ⵉ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⴽⴽⴰⵔⴻⵏ ⴰⴷ ⵙⵙⴱⴻⴷⴷⴻⵏ ⵉⵊⵊ ⵏ ⵍⴻⵅⵢⴰⵍ ⵉ ⵍⵡⴻⵃⵛ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵉⵢⵣⴻⵎ ⵙ ⵙⵙⵉⴼ, ⵎⴰⵛⴰ ⵉⴷⴷⴰⵔ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("RV13_15","096_13_15","REV","13","15","15","ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙ ⴰⴷ ⵉⴳⴳ ⵉⵊⵊ ⵏ ⴰⵔⵔⵓⵃ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏ ⵍⵡⴻⵃⵛ ⵓ ⵃⵉⵎⴰ ⴰⴷ ⵉⴳⴳ ⴱⴻⵍⵍⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵍⵡⴻⵃⵛ, ⴰⴷ ⵜⵜⵡⴰⵏⵖⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV13_16","096_13_16","REV","13","16","16","ⵓⵛⴰ ⴰⴷ ⵉⴳⴳ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵎⵎⴻⵡⵛ ⵉ ⵎⴰⵔⵔⴰ, ⵉ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ, ⵉ ⴰⵢⵜⴱⴰⴱ ⵏ ⵡⴰⴳⵍⴰ ⴷ ⵉⵎⴻⵣⵍⴰⴹ, ⵉ ⴰⵢⵜ ⵏ ⵛⵛⴰⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ, ⵉⵛⵜ ⵏ ⵍⵎⴰⵔⴽⴰ ⵅ ⵓⴼⵓⵙ ⵏⵙⴻⵏ ⴰⴼⵓⵙⵉ ⵏⵉⵖ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵙⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV13_17","096_13_17","REV","13","17","17","ⵎⴰⵃⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵙⴻⵖ ⵏⵉⵖ ⴰⴷ ⵉⵣⵣⴻⵏⵣ ⵎⵖⵉⵔ ⵡⴻⵏⵏⵉ ⵅ ⵜⴻⴵⴰ ⵍⵎⴰⵔⴽⴰ ⵏ ⵢⵉⵙⴻⵎ ⵏ ⵍⵡⴻⵃⵛ ⵏⵉⵖ ⵏⵏⵓⵎⵔⵓ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV13_18","096_13_18","REV","13","18","18","ⴷⴰⵏⵉⵜⴰ ⵜⴻⴵⴰ ⵜⵉⵖⵉⵜ: ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵍⴻⵄⵇⴻⵍ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⵉⵃⵙⴻⴱ ⵏⵏⵓⵎⵔⵓ ⵏ ⵍⵡⴻⵃⵛ, ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵏⵏⵓⵎⵔⵓ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ ⵓⵛⴰ ⵏⵏⵓⵎⵔⵓ ⵏⵏⴻⵙ ⴷ ⵙⴻⵜⵜⴰ-ⵎⵢⴰ ⵓ-ⵙⴻⵜⵜⴰ ⵓ-ⵙⴻⵜⵜⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RV14_1","096_14_1","REV","14","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ, ⴰⵇⴰ ⵉⵣⵎⴰⵔ ⵉⴱⴻⴷⴷ-ⴷⴷ ⵅ ⵡⴻⴷⵔⴰⵔ ⵏ ⵚⵉⵀⵢⵓⵏ, ⵓⵛⴰ ⴰⴽⵉⴷⴻⵙ ⵎⵢⴰ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ, ⵉⵏⵏⵉ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵙⴻⵏ ⵢⵓⵔⴰ ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴷ ⵢⵉⵙⴻⵎ ⵏ ⴱⴰⴱⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("RV14_2","096_14_2","REV","14","2","2","ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⴰⵎ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ ⵓ ⴰⵎ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵊⵊⴰⵊ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵓⵛⴰ ⵍⵃⴻⵙⵙ ⵉ ⵙⵍⵉⵖ ⵜⵓⵖⴰ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⴱⵓ-ⵍⵀⴰⵔⴱⴰ ⵉⵜⵜⵉⵔⴰⵔⴻⵏ ⴷⵉ ⵍⵀⴰⵔⴱⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV14_3","096_14_3","REV","14","3","3","ⴰⵇⴰ ⵏⵉⵜⵏⵉ ⵖⴻⵏⵏⵊⴻⵏ ⵎⵉⵏ ⵉⴵⴰⵏ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵢⴻⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⴷ ⵊⴷⵉⴷ ⵇⴰⵄ ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ ⵓ ⵣⵣⴰⵜ ⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⴷ ⵉⵎⵖⴰⵔⴻⵏ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⵉⵍⵎⴻⴷ ⵉⵣⵍⵉ ⴰⵢⴰ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵎⵖⵉⵔ ⵎⵢⴰ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ-ⴰⵍⴻⴼ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴷⵉⵏ ⵣⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV14_4","096_14_4","REV","14","4","4","ⵉⵏⴰ ⴷ ⵉⵏⵏⵉ ⵡⴰⵔ ⵉⵙⵙⴻⴼⵙⴻⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⴰⴽ-ⴷ ⵜⴻⵎⵖⴰⵔⵉⵏ, ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⴷ ⵉⵄⴻⵣⵔⵉⵢⵢⴻⵏ ⵉⵎⴻⵣⴷⴰⴳⴻⵏ. ⵏⵉⵜⵏⵉ ⴹⴻⴼⴼⴰⵔⴻⵏ ⵉⵣⵎⴰⵔ ⵎⴰⵏⵉ ⵎⴰ ⵉⴽⴽⴰ. ⴰⵇⴰ ⵉⵏⴰ ⵉⵜⵜⵡⴰⴼⴷⵉⵏ ⵣⴻⴳ ⵉⵡⴷⴰⵏ ⴰⵎ ⵚⵚⴰⴱⴻⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⴰⵔⴻⴱⴱⵉ ⵓ ⵉ ⵢⴻⵣⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV14_5","096_14_5","REV","14","5","5","ⴰⵇⴰ ⵡⴰⵔ ⵉⵜⵜⵡⵉⴼⴼⵉ ⵛⴰ ⵍⵖⴻⵛⵛ ⴷⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏⵙⴻⵏ, ⴰⵇⴰ ⵡⴰⵔ ⴷⴰⵢⵙⴻⵏ ⴱⵓ ⵍⵄⵉⴱ. ");
INSERT INTO rift_vpl VALUES ("RV14_6","096_14_6","REV","14","6","6","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵜⵓⵖⴰ ⵉⵟⵟⴰⵡ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵊⴻⵏⵏⴰ, ⵖⴰⵔⴻⵙ ⵍⴻⵅⴱⴰⵔ ⴰⵚⴻⴱⵃⴰⵏ ⵉ ⵍⴻⴱⴷⴰ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⴱⴰⵔⵔⴻⵃ ⵉ ⵢⵉⵏⵏⵉ ⵉⵣⴻⴷⴷⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⵉ ⴽⵓⵍ ⵍⴳⴻⵏⵙ ⴷ ⵛⵛⴻⵄⴱ ⴷ ⵜⴻⵇⴱⵉⵍⵜ ⴷ ⵢⵉⵍⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RV14_7","096_14_7","REV","14","7","7","ⵓⵛⴰ ⵉⵏⵏⴰ ⵙ ⵊⵊⴻⵀⴷ: “ⴳⴳⵯⴻⴷⴻⵎ ⴰⵔⴻⴱⴱⵉ, ⵡⵛⴻⵎ ⴰⵙ-ⴷⴷ ⴰⵄⵓⴵⵉ, ⴰⵇⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏ ⵍⵃⵉⵙⴰⴱ ⵏⵏⴻⵙ ⵜⵉⵡⴻⴹ-ⴷⴷ. ⵙⴻⵊⴷⴻⵎ ⵉ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⴰⵊⴻⵏⵏⴰ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵍⴻⴱⵃⴰⵔ ⴷ ⵜⴰⵍⴰⵡⵉⵏ ⵏ ⵡⴰⵎⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV14_8","096_14_8","REV","14","8","8","ⵓⵛⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ, ⵉⴹⴼⴰⵔ ⵉ-ⵜ, ⵉⵏⵏⴰ: “ⴰⵇⴰ ⵜⴻⵡⴹⴰ, ⴰⵇⴰ ⵜⴻⵡⴹⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴱⴰⴱⵉⵍ, ⵉ ⵢⴻⵊⵊⵉⵏ ⴰⴷ ⵙⵡⴻⵏ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵣⵉ ⴱⵉⵏⵓ ⵏ ⵜⴻⴼⵇⴻⵃⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RV14_9","096_14_9","REV","14","9","9","ⵓⵛⴰ ⵡⴻⵏⵏⴻⵖⵏⵉ, ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ, ⵉⴹⴼⴰⵔ ⵉ-ⵜⴻⵏ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ: “ⵡⴻⵏⵏⵉ ⵉⵄⴻⴱⴷⴻⵏ ⵍⵡⴻⵃⵛ ⴷ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ ⴷ ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵍⵎⴰⵔⴽⴰ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵏⵉⵖ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RV14_10","096_14_10","REV","14","10","10","ⴷ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵙⵓ ⵄⴰⵡⴻⴷ ⵣⵉ ⴱⵉⵏⵓ ⵏ ⵜⴻⴼⵇⴻⵃⵜ ⵏ ⵙⵉⴷⵉ, ⵡⴻⵏⵏⵉ ⵉⵙⵙⵡⴻⵊⴷⴻⵏ ⴱⵍⴰ ⴰⵅⴻⴵⴻⴹ ⴷⵉ ⵍⴽⴰⵙ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⴷ ⵉⵜⵜⵡⴰⵄⴻⴷⴷⴻⴱ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ ⵓ ⵇⵉⴱⴰⵍⵜ ⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏ ⵢⴻⵣⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV14_11","096_14_11","REV","14","11","11","ⵓⵛⴰ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵓⵄⴻⴷⴷⴻⴱ ⵏⵙⴻⵏ ⴰⴷ ⵉⵇⵇⵉⵎ ⵉⴳⴻⵄⵄⴻⴷ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ⵡⴰⵔ ⴷⵉⵏ ⴱⵓ ⴰⵔⵔⴰⵃⴻⵜ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵉ ⵡⴻⵏⵏⵉ ⵉⵙⴻⵊⵊⴷⴻⵏ ⵉ ⵍⵡⴻⵃⵛ ⴷ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ ⵓ ⵉ ⵡⴻⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵍⵎⴰⵔⴽⴰ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV14_12","096_14_12","REV","14","12","12","ⴰⵇⴰ ⴷⴰ ⵉⵜⵜⴱⴰⵏ-ⴷⴷ ⵚⵚⴱⴰⵔ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⴻⵟⵟⴼⴻⵏ ⴷⵉ ⵜⵡⴻⵚⵚⴰ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵃⴻⵟⵟⴰⵏ ⵍ’ⵉⵎⴰⵏ ⵏ ⵢⴰⵙⵓⵄ.” ");
INSERT INTO rift_vpl VALUES ("RV14_13","096_14_13","REV","14","13","13","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜᵉⵜⵜⵍⴰⵖⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵜⴻⵇⵇⴰⵔ: “ⴰⵔⵉ: ⵙⵙⴻⵄⴷ ⵏ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵉⵏⵏⵉ ⵉ ⵖⴰ ⵎⵎⵜⴻⵏ ⴷⵉ ⵙⵉⴷⵉⵜⵏⴻⵖ, ⵣⵉ ⵍⴻⵅⵅⵓ ⵜⵙⴰⵡⴻⵏⵜ!” “ⵡⴰⵀ, ⵉⵏⵏⴰ ⴰⵔⵔⵓⵃ, ⵎⴰⵖⴰⵔ ⴰⴷ ⴰⵔⴻⵢⵢⵃⴻⵏ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ!”, ⴰⵇⴰ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ ⴰⴷ ⵜⴻⵏ ⴹⴼⴰⵔⴻⵏⵜ. ");
INSERT INTO rift_vpl VALUES ("RV14_14","096_14_14","REV","14","14","14","ⵓⵛⴰ ⵥⵔⵉⵖ, ⴰⵇⴰ ⵉⵊⵊ ⵏ ⵓⵙⴻⵢⵏⵓ ⴷ ⴰⵛⴻⵎⵍⴰⵍ, ⵓⵛⴰ ⵅ ⵓⵙⴻⵢⵏⵓ ⵉⵇⵇⵉⵎ ⵅⴰⵙ ⵡⴻⵏⵏⵉ ⵢⴰⵔⵡⴻⵙⴻⵏ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵎⵎⵉⵙ ⵏ ⴱⵏⴰⴷⴻⵎ, ⵖⴰⵔⴻⵙ ⵜⵜⴰⵊ ⵏ ⵡⵓⵔⴻⵖ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⵓ ⴰⵎⵊⴰⵔ ⵉⵇⴹⴻⵄ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV14_15","096_14_15","REV","14","15","15","ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵓⵛⴰ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ ⵅ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵙⴻⵢⵏⵓ: “ⵙⴻⴽⴽ-ⴷⴷ ⴰⵎⵊⴰⵔ ⵏⵏⴻⵛ, ⵎⵊⴰⵔ! ⴰⵇⴰ ⵜⴰⵙⴰⵄⵄⴻⵜ ⵏ ⵜⵎⴻⵢⵔⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ!” ");
INSERT INTO rift_vpl VALUES ("RV14_16","096_14_16","REV","14","16","16","ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵓⵙⴻⵢⵏⵓ, ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵎⵊⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵎⵊⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV14_17","096_14_17","REV","14","17","17","ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵉⴵⴰⵏ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵏⴻⵜⵜⴰ ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵡⴻⵎⵊⴰⵔ ⵉⵇⴹⴻⵄ. ");
INSERT INTO rift_vpl VALUES ("RV14_18","096_14_18","REV","14","18","18","ⵓⵛⴰ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⵎⴻⵙⵙⵉ, ⵉⴼⴼⴻⵖ-ⴷⴷ ⵣⴻⴳ ⵓⵄⴰⵍⵟⴰⵔ, ⵓⵛⴰ ⵉⵍⴰⵖⴰ-ⴷⴷ ⵙ ⵊⵊⴻⵀⴷ ⵅ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵡⴻⵎⵊⴰⵔ ⵉⵇⴹⴻⵄ, ⵉⵏⵏⴰ: “ⵙⴻⴽⴽ-ⴷⴷ ⴰⵎⵊⴰⵔ ⵏⵏⴻⵛ ⵉⵇⴻⴹⵄⴻⵏ, ⵍⵇⴻⴹ ⵉⵣⴻⴽⴽⵓⵏⴻⵏ ⵏ ⵜⵣⴰⵢⴰⵔⵉⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⴰⴹⵉⵍ ⵏⵏⴻⵙ ⴰⵇⴰ ⵢⵉⵡⴻⴹ.” ");
INSERT INTO rift_vpl VALUES ("RV14_19","096_14_19","REV","14","19","19","ⵓⵛⴰ ⵍⵎⴰⵍⴰⴽ ⵉⵙⵙⴻⴽⴽ-ⴷⴷ ⴰⵎⵊⴰⵔ ⵏⵏⴻⵙ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵍⵇⴻⴹ ⴰⴹⵉⵍ ⵏ ⵜⵣⴰⵢⴰⵔⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⴷⵉ ⵜⵙⵉⵔⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV14_20","096_14_20","REV","14","20","20","ⵃⴰⵔⵢⴻⵏ ⴷⵉ ⵜⵙⵉⵔⵜ ⵏ ⵓⴹⵉⵍ ⴰⵍ ⴱⴰⵔⵔⴰ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵓⵛⴰ ⵔⵓⵛⵛⴻⵏ-ⴷⴷ ⵉⴷⴰⵎⵎⴻⵏ ⵣⵉ ⵜⵙⵉⵔⵜ ⴰⵍⴰⵎⵉ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵙⵍⵉⵎⴰⵜ ⵏ ⵢⴻⵢⵙⴰⵏ, ⵍⵇⴻⴷⴷ ⵏ ⴰⵍⴻⴼ ⵓ-ⵎⵉⵜⴰⵢⴻⵏ ⵏ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’, ⵉⵅⵙ ⴰⴷ ⵢⵉⵏⵉ ⵄⵍⴰⵃⴰⵍ ⵎⵉⵜⴰⵢⴻⵏ ⵓ-ⵄⵉⵛⵔⵉⵏ ⴽⵉⵍⵓⵎⵉⵜⵔ.    ");
INSERT INTO rift_vpl VALUES ("RV15_1","096_15_1","REV","15","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵉⵛⵜ ⵏ ⵍⴻⵄⵍⴰⵎⴻⵜ ⵏⵏⴻⵖⵏⵉ, ⴷ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷ ⵜⴰⵏⴻⴱⵀⴻⵜ: ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ, ⵎⵉⵏⵣⵉ ⵉⴽⵎⴻⵍ ⵣⵣⴰⵢⵙⴻⵏⵜ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV15_2","096_15_2","REV","15","2","2","ⵓⵛⴰ ⵥⵔⵉⵖ ⵛⴰ ⵉⵜⵜⴻⵎⵛⴰⴱⴻⵀ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵣⵣⴰⵊ, ⵡⴻⵏⵏⵉ ⵉⵅⴻⴵⴹⴻⵏ ⴰⴽ-ⴷ ⵜⵎⴻⵙⵙⵉ, ⵓⵛⴰ ⵉⵏⵏⵉ ⵉⵖⴻⵍⵍⴱⴻⵏ ⵅ ⵍⵡⴻⵃⵛ ⴷ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ ⴷ ⵏⵏⵓⵎⵔⵓ ⵏ ⵢⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴱⴻⴷⴷⴻⵏ ⵅ ⵍⴻⴱⵃⴰⵔ ⵏ ⵣⵣⴰⵊ, ⵖⴰⵔⵙⴻⵏ ⵍⵀⴰⵔⴱⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV15_3","096_15_3","REV","15","3","3","ⵏⵉⵜⵏⵉ ⵖⴻⵏⵏⵊⴻⵏ ⵉⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵏ ⵎⵓⵙⴰ, ⴰⵎⵙⴻⵅⵅⴰⵔ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴷ ⵢⴻⵣⵍⵉ ⵏ ⵓⵚⴻⴱⴱⴻⵃ ⵏ ⵢⴻⵣⵎⴰⵔ, ⵇⵇⴰⵔⴻⵏ: “ⴷ ⵜⵉⵎⴻⵇⵇⵔⴰⵏⵉⵏ ⴷ ⵜⵚⴻⴱⵃⴰⵏⵉⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ, ⴰ, ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵛ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⴷ ⵜⵉⴷⴻⵜⵜ, ⴰ ⴰⵊⴻⴵⵉⴷ ⵏ ⵏ ⵣⵣⵎⴰⵏⴰⵜ! ");
INSERT INTO rift_vpl VALUES ("RV15_4","096_15_4","REV","15","4","4","ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵛⴻⴽ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ, ⴰ ⵙⵉⴷⵉ, ⵎⴰⵏ ⵡⴻⵏ ⵡⴰⵔ ⵉⵙⵙⴻⵎⵖⴰⵔⴰⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵛ? ⵛⴻⴽ ⵡⴻⵃⵃⴷⴻⴽ ⵉ ⵉⴵⴰⵏ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵇⴰⵄ, ⵎⴰⵖⴰⵔ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵏ, ⴰⴷ ⵙⴻⵊⴷⴻⵏ ⵣⵣⴰⵜⴻⴽ, ⵎⵉⵏⵣⵉ ⵛⴻⴽ ⵜⴱⴰⵏⴻⴷ ⴷ ⴰⵎⵙⴻⴳⴳⴻⴷ ⴷⵉ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ.” ");
INSERT INTO rift_vpl VALUES ("RV15_5","096_15_5","REV","15","5","5","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵥⵔⵉⵖ, ⴰⵇⴰ ⵜⴻⵏⵏⵓⵔⵣⴻⵎ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏ ⵜⵣⴻⴷⴷⵉⵖⵜ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ ");
INSERT INTO rift_vpl VALUES ("RV15_6","096_15_6","REV","15","6","6","ⵓⵛⴰ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵖⴰⵔ ⴵⴰⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ ⴼⴼⵖⴻⵏⵜ-ⵉ-ⴷⴷ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵢⴰⵔⴹⴻⵏⵜ ⵍⴻⵇⵟⴻⵏ ⴰⵣⴷⴰⴷ ⵉⵣⴷⵉⴳⴻⵏ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⵓⵛⴰ ⵖⴰⵔⵙⴻⵏ ⵅ ⵉⴷⵎⴰⵔⴻⵏ ⵉⵊⵊ ⵏ ⵡⴻⴱⵢⴰⵙ ⵏ ⵡⵓⵔⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV15_7","096_15_7","REV","15","7","7","ⵓⵛⴰ ⵉⵊⵊⴻⵏ ⵣⵉ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⵉ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵙⴻⴱⵄⴰ ⵏ ⵟⵟⴰⵡⵢⴰⵜ, ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴻⵏⵏⵉ ⴷ ⵜⵓⴷⴰⵔⵜ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. “ⴰⵎⵉⵏ!” ");
INSERT INTO rift_vpl VALUES ("RV15_8","096_15_8","REV","15","8","8","ⵓⵛⴰ ⵜᵉⵜⵜⵡⴰⵄⴻⵎⵎⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵙ ⴷⴷⴻⵅⵅⴰⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵣⵉ ⵊⵊⴻⵀⴷ ⵏⵏⴻⵙ. ⵓⵍⴰ ⴷ ⵉⵊⵊⴻⵏ ⵡⴰⵔ ⵉⵣⴻⵎⵎⴰⵔ ⴰⴷ ⴷⴷ-ⵢⴰⴷⴻⴼ ⵖⴰⵔ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴰⵍ ⵖⴰ ⴽⴽⴻⵏⵜ ⵇⴰⵄ ⵙⴻⴱⵄⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ ⵜⵉⵏⵏⵉ ⴷⴷ-ⵉⵡⵢⴻⵏ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("RV16_1","096_16_1","REV","16","1","1","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜᵉⵜⵜⵍⴰⵖⴰ ⵅ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ, ⵜⴻⵏⵏⴰ: “ⵓⵢⵓⵔⴻⵏⵜ, ⵜⵜⴼⴰⵔⵔⵖⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵟⵟⴰⵡⵢⴰⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ ⵅ ⵜⴻⵎⵎⵓⵔⵜ!” ");
INSERT INTO rift_vpl VALUES ("RV16_2","096_16_2","REV","16","2","2","ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵢⵓⵢⵓⵔ, ⵉⴼⴰⵔⵔⴻⵖ ⵟⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⵅ ⵜⴻⵎⵎⵓⵔⵜ. ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵉⵊⵊ ⵏ ⵓⴱⵓⵄⵔⵓⵙ ⴷ ⴰⵄⴻⴼⴼⴰⵏ ⵉⵇⴱⴻⵃ ⵖⴰⵔ ⵉⵡⴷⴰⵏ ⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⵎⴰⵔⴽⴰ ⵏ ⵍⵡⴻⵃⵛ, ⵉⵏⵏⵉ ⵉⵙⴻⵊⴷⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ.    ");
INSERT INTO rift_vpl VALUES ("RV16_3","096_16_3","REV","16","3","3","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵟⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵓⵛⴰ ⵉⴷⵡⴻⵍ ⵍⴻⴱⵃⴰⵔ ⴰⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵊⵊ ⵏ ⵓⵎⴻⵜⵜⵉⵏ, ⵓⵛⴰ ⴽⵓⵍ ⵍⴻⵄⵎⴰⵔ ⵉⴷⴷⴰⵔⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵉⵎⵎⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("RV16_4","096_16_4","REV","16","4","4","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵟⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⵅ ⵉⵖⴻⵣⵔⴰⵏ ⴷ ⵜⴰⵍⴰⵡⵉⵏ, ⵓⵛⴰ ⴰⵎⴰⵏ ⵏⵙⴻⵏ ⴷⴻⵡⵍⴻⵏ ⴷ ⵉⴷⴰⵎⵎⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV16_5","096_16_5","REV","16","5","5","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉ ⵍⵎⴰⵍⴰⴽ ⵏ ⵡⴰⵎⴰⵏ ⵉⵇⵇⴰⵔ: “ⵛⴻⴽ ⴷ ⴰⵎⵙⴻⴳⴳⴰⴷ, ⵛⴻⴽ ⴷ ⵡⴻⵏⵏⵉ ⵉⴵⴰⵏ ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ, ⴷ ⵡⴻⵏⵏⵉ ⴷ ⴰⵎⴻⵣⴷⴰⴳ ⵇⴰⵄ, ⵓⵎⵉ ⵜⴽⴻⵎⵎⵍⴻⴷ ⵍⴻⵃⴽⴰⵎⴰⵜ-ⴰ ⴰⵎⵎⵓ. ");
INSERT INTO rift_vpl VALUES ("RV16_6","096_16_6","REV","16","6","6","ⵎⵉⵏⵣⵉ ⵏⵉⵜⵏⵉ ⵙⵙⵉⵣⵣⵍⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵜⴻⵡⵛⵉⴷ ⴰⵙⴻⵏ ⵄⴰⵡⴻⴷ ⴰⴷ ⵙⵡⴻⵏ ⵉⴷⴰⵎⵎⴻⵏ, ⵎⴰⵖⴰⵔ ⴰⵎⵎⵓ ⵉ ⴷ ⴰⵙⴻⵏ ⴷⴷ-ⵉⴼⴼⴻⵖ.” ");
INSERT INTO rift_vpl VALUES ("RV16_7","096_16_7","REV","16","7","7","ⵓⵛⴰ ⵙⵍⵉⵖ ⴰⵇⴰ ⴰⵄⴰⵍⵟⴰⵔ ⵉⵇⵇⴰⵔ: “ⵡⴰⵀ, ⴰ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵛ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵜⴰⵙⴻⴳⴷⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV16_8","096_16_8","REV","16","8","8","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵟⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⵅ ⵜⴼⵓⵛⵜ ⵓⵛⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⵉ ⵜⴼⵓⵛⵜ, ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵏⴻⴼ ⵉⵡⴷⴰⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("RV16_9","096_16_9","REV","16","9","9","ⵓⵛⴰ ⵛⴻⵎⴹⴻⵏ ⵉⵡⴷⴰⵏ ⵙ ⵍⵄⴰⴱⵓⵇ ⵉⵎⵖⴰⵔⴻⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵓⵛⴰ ⵛⴻⵇⵇⴼⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵚⵚⵓⵍⵟⴰ ⵅ ⵊⵊⵔⴰⵢⴻⵃ-ⴰ ⵓⵛⴰ ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵛⴰ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⴰⵙ ⵡⵛⵉⵏ ⴰⵄⵓⴵⵉ. ");
INSERT INTO rift_vpl VALUES ("RV16_10","096_16_10","REV","16","10","10","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⵅ ⵍⵄⴰⵔⵛ ⵏ ⵍⵡⴻⵃⵛ ⵓⵛⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⴰⴵⴻⵙⵜ ⵅ ⵜⴳⴻⵍⴷⵉⵜ ⵏ ⵍⵡⴻⵃⵛ. ⵓⵛⴰ ⵣⴻⵄⴼⴻⵏ ⴷⴻⴳ ⵉⵍⴻⵙ ⵏⵙⴻⵏ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵃⵔⵉⵇ ");
INSERT INTO rift_vpl VALUES ("RV16_11","096_16_11","REV","16","11","11","ⵓⵛⴰ ⵛⴻⵇⵇⴼⴻⵏ ⴷⴻⴳ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ ⵏ ⵉⵊⴻⵏⵡⴰⵏ ⵙ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵍⴻⵃⵔⵉⵇ ⴷ ⵉⴱⵓⵄⵔⵓⵙⴻⵏ ⵏⵙⴻⵏ, ⵎⴰⵛⴰ ⵡⴰⵔ ⵜⵓⴱⴻⵏ ⵛⴰ ⵣⵉ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV16_12","096_16_12","REV","16","12","12","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵟⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⴷⴻⴳ ⵉⵖⵣⴰⵔ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵉⵖⵣⴰⵔ ⵏ ⵍⴼⵓⵔⴰⵟ ⵓⵛⴰ ⵓⵥⵖⴻⵏ ⵡⴰⵎⴰⵏ ⵏⵏⴻⵙ, ⴰⵍⴰⵎⵉ ⵉⵙⵙⴻⵡⵊⴻⴷ ⴰⴱⵔⵉⴷ ⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵉⵏⵏⵉ ⴷⴷ ⵖⴰ ⵢⴰⵙⴻⵏ ⵣⵉ ⵎⴰⵏⵉⵙ ⴷⴷ-ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("RV16_13","096_16_13","REV","16","13","13","ⵅⴻⵏⵏⵉ ⵥⵔⵉⵖ, ⴰⵇⴰ ⵜⵍⴰⵜⴰ ⵏ ⵍⴰⵔⵢⴰⵃ ⵉⵎⴻⵏⴳⴰⵙ ⴰⵎ ⵉⵇⴰⵔⵇⵔⵉⵡⴻⵏ ⴼⴼⵖⴻⵏ-ⴷⴷ ⵣⴻⴳ ⵓⵅⴻⵏⴼⵓⵛ ⵏ ⵍⵀⴰⵢⵛⴻⵜ ⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵍⵡⴻⵃⵛ ⵓ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵓⵏⴰⴱⵉ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV16_14","096_16_14","REV","16","14","14","ⵎⴰⵖⴰⵔ ⵏⵉⵜⵏⵉ ⴷ ⵍⴰⵔⵢⴰⵃ ⵏ ⵛⵛⵡⴰⵟⴻⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵉ ⴷ ⵉⴳⴳⵓⵔⴻⵏ ⵖⴰⵔ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⴻⵏ ⵙⵙⵎⵓⵏⴻⵏ ⵉ ⵓⵎⴻⵏⵖⵉ ⴷⴻⴳ ⵡⴰⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("RV16_15","096_16_15","REV","16","15","15","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴰⵎ ⵢⵉⵊⵊ ⵏ ⵓⵛⴻⴼⴼⴰⵔ! ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵇⵇⵉⵎⴻⵏ ⵉⴼⴰⵇ, ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵃⴹⴰⵏ ⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⴳⴳⵓⵔ ⴷ ⴰⵄⴰⵔⵢⴰⵏ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵥⴰⵔ ⵓⵙⴻⴹⵃⵉ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RV16_16","096_16_16","REV","16","16","16","ⵓⵛⴰ ⵉⵙⵙⵎⵓⵏ ⵉ-ⵜⴻⵏ ⵖⴰⵔ ⵡⴻⵎⵛⴰⵏ ⵓⵎⵉ ⵜⵜⵍⴰⵖⴰⵏ ⵙ ⵜⵄⵉⴱⵔⴰⵏⵉⵜ ‘ⵎⴻⴳⵉⴷⴷⵓ’. ");
INSERT INTO rift_vpl VALUES ("RV16_17","096_16_17","REV","16","17","17","ⵅⴻⵏⵏⵉ ⵉⴼⴰⵔⵔⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵟⵟⴰⵡⵢⴰ ⵏⵏⴻⵙ ⵅ ⵍⴻⵄⵡⵉⵏ ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ ⵣⵉ ⵣⵣⴰⵡⴻⵛⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵣⵉ ⵣⵣⴰⵜ ⵏ ⵍⵄⴰⵔⵛ, ⵜⴻⵇⵇⴰⵔ: “ⴰⵇⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ!” ");
INSERT INTO rift_vpl VALUES ("RV16_18","096_16_18","REV","16","18","18","ⵓⵛⴰ ⵓⵙⵉⵏ-ⴷⴷ ⵡⴰⵙⵙⴰⵎⴻⵏ ⴷ ⵡⴰⵊⵊⴰⵊⴻⵏ, ⵓⵛⴰ ⵉⵎⵙⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⵏⵀⴻⵣⵣⵉ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ, ⵡⴰⵔ ⵜⴻⵎⵙⴰⵔ ⴰⵎⵎⵓ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⴵⴰ ⴱⵏⴰⴷⴻⵎ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ, ⴰⵎⵎⵓ ⵉ ⵉⵎⵖⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV16_19","096_16_19","REV","16","19","19","ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵜⴻⵡⴹⴰ ⵜⴻⴱⴹⴰ ⵅ ⵜⵍⴰⵜⴰ ⵏ ⵜⵙⴻⵇⵇⴰⵔ ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵜⵉⵏⴻⴷⴷⴰⵎ ⵏ ⵍⴻⴳⵏⵓⵙ ⵀⴻⴷⵎⴻⵏⵜ ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵉⵄⵇⴻⵍ ⵅ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴱⴰⴱⵉⵍ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵉⵡⵛ ⵍⴽⴰⵙ ⵏ ⴱⵉⵏⵓ ⵏ ⵜⴻⴼⵇⴻⵃⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV16_20","096_16_20","REV","16","20","20","ⵓⵛⴰ ⴽⵓⵍ ⵜⴰⴳⵣⵉⵔⵜ ⵜⴰⵔⵡⴻⵍ, ⵡⴰⵔ ⵜⵜⵡⵉⴼⵉⵏ ⵛⴰ ⵉⴷⵓⵔⴰⵔ ⵄⴰⴷ, ");
INSERT INTO rift_vpl VALUES ("RV16_21","096_16_21","REV","16","21","21","ⵡⴹⴰⵏ-ⴷⴷ ⵉⴱⵇⵓⵇⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⴱⵔⵓⵔⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵅ ⵉⵡⴷⴰⵏ, ⵜⵓⵖⴰ ⴷⴷⵇⴻⵍ ⵏⵙⴻⵏ ⴰⵏⴻⵛⵜ ⵏ ⵉⵛⵜ ⵏ ‘ⵜⴰⵍⵉⵏⵜ’, ⵓⵛⴰ ⵉⵡⴷⴰⵏ ⵛⴻⵇⵇⴼⴻⵏ ⴷⵉ ⴰⵔⴻⴱⴱⵉ ⵣⵉ ⵙⵙⵉⴱⴱⴻⵜ ⵏ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏ ⵜⴻⴱⵔⵓⵔⵉ, ⵎⵉⵏⵣⵉ ⵊⵊⵔⵉⵃⴻⵛⵜ ⵏⵏⴻⵙ ⵜⵓⵖⴰ ⵜⴻⵎⵖⴰⵔ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("RV17_1","096_17_1","REV","17","1","1","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵜⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵙⴻⴱⵄⴰ ⵏ ⵟⵟⴰⵡⵢⴰⵜ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰⵙ-ⴷⴷ, ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵍⵃⵓⴽⵎ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ, ");
INSERT INTO rift_vpl VALUES ("RV17_2","096_17_2","REV","17","2","2","ⵜⴻⵏⵏⵉ ⵣⵉ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵙⵛⴰⵔⴻⵏ ⵙ ⴱⵉⵏⵓ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RV17_3","096_17_3","REV","17","3","3","ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⵉ ⴰⵔⵔⵓⵃ ⵖⴰⵔ ⵍⴻⵅⵍⴰ ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⴻⵟⵟⵓⵜ ⵜⴻⵏⵢⴰ ⵅ ⵉⵊⵊ ⵏ ⵍⵡⴻⵃⵛ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ, ⵉⵛⵛⵓⵔⴻⵏ ⵙ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⵜⴻⴽⴼⵉⵔ, ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV17_4","096_17_4","REV","17","4","4","ⵜⵓⵖⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵜⵢⴰⵔⴹ ⵜⴰⵇⴻⵏⴷⵓⵔⵜ ⵜⵓⵔⵊⵓⵡⴰⵏⵉⵜ ⴷ ⵜⴰⵣⴻⴳⴳⵡⴰⵖⵜ ⵉⵃⴻⴷⵇⴻⵏ ⵜⴻⵇⵇⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ ⴷ ⵜⵢⴰⵇⵓⵜⵉⵏ. ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⴰⵔⵔⴰⴼ ⵏ ⵡⵓⵔⴻⵖ ⵉⵛⵛⵓⵔ ⵙ ⵍⴻⵅⵎⴻⵊ ⵓ ⵙ ⵏⵏⵄⵉ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV17_5","096_17_5","REV","17","5","5","ⵉⵜⵜⵡⴰⵔⵉ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵏⴻⵙ ⵉⵊⵊ ⵏ ⵉⵙⴻⵎ: ‘ⵙⵙⵉⵔⵔ ⵏ ⴱⴰⴱⵉⵍ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵢⴻⵎⵎⴰⵜⵙⴻⵏⵜ ⵏ ⵜⴻⵎⵖⴰⵔⵉⵏ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵎⴰⵔⵔⴰ ⵏⵏⵄⴰⵡⴰⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ’. ");
INSERT INTO rift_vpl VALUES ("RV17_6","096_17_6","REV","17","6","6","ⵓⵛⴰ ⵥⵔⵉⵖ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵜⴻⵙⵛⴰⵔ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵓ ⵙ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵢⵉⵏⵏⵉ ⵉⵛⴻⵀⵀⴷⴻⵏ ⵅ ⵢⴰⵙⵓⵄ. ⴰⵍⴰⵎⵉ ⵜⵜ ⵥⵔⵉⵖ, ⵜⵜⴱⴻⵀⵜⴻⵖ ⴰⵟⵟⴰⵙ. ");
INSERT INTO rift_vpl VALUES ("RV17_7","096_17_7","REV","17","7","7","ⵉⵏⵏⴰ ⴰⵢⵉ ⵍⵎⴰⵍⴰⴽ: “ⵎⴰⵢⴻⵎⵎⵉ ⵜᵉⵜⵜⴱⴻⵀⵜⴻⴷ? ⵏⴻⵛⵛ ⴰⴷ ⵛⴻⴽ ⵙⵙⴰⵔⴳⴱⴻⵖ ⵅ ⵙⵙⵉⵔⵔ ⵏ ⵜⵎⴻⵟⵟⵓⵜ ⴷ ⵍⵡⴻⵃⵛ ⵙ ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ, ⵡⴻⵏⵏⵉ ⵜⵜ ⵢⴰⵔⴻⴱⴱⵓⵏ. ");
INSERT INTO rift_vpl VALUES ("RV17_8","096_17_8","REV","17","8","8","ⵍⵡⴻⵃⵛ ⵉ ⵜⴻⵥⵔⵉⴷ, ⴷ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ, ⴰⴷ ⵉⴳⴻⵄⵄⴻⴷ ⵣⵉ ⵍⴻⴱⵃⴰⵔ, ⴰⴷ ⵉⵡⴻⴷⴷⴰⵔ. ⵓⵛⴰ ⴰⴷ ⵜⴱⴻⵀⵜⴻⵏ ⵉⵎⴻⵣⴷⴰⵖ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⵉⵙⴻⵎ ⵏⵙⴻⵏ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⵛⴰ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ ⵣⴻⴳ ⵡⴰⵎⵉ ⵉⵜⵜⵡⴰⴳⴳ ⴷⵙⴰⵙ ⵏ ⴷⴷⵓⵏⴻⵛⵜ, ⴰⴷ ⵜⴱⴻⵀⵜⴻⵏ ⵅⵎⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⵍⵡⴻⵃⵛ ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ, ⴷ ⵡⴻⵏⵏⵉ ⵡⴰⵔ ⵉⴵⵉⵏ, ⵄⴰⴷ ⴰⴷ ⴷⴷ-ⵉⵇⴰⵔⵔⴻⴱ. ");
INSERT INTO rift_vpl VALUES ("RV17_9","096_17_9","REV","17","9","9","ⴰⵇⴰ ⴷⴰ ⵍⵎⴻⵄⵏⴰ ⵏⵏⴻⵙ ⵉ ⵡⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵍⴻⴼⵀⴰⵎⴻⵜ: ⵙⴻⴱⵄⴰ ⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⴰⵇⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⴷⵓⵔⴰⵔ ⵎⵉⵏ ⵅⴻⴼ ⵜⴻⵇⵇⵉⵎ ⵜⵎⴻⵟⵟⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("RV17_10","096_17_10","REV","17","10","10","ⴰⵇⴰ-ⵜⴻⵏ ⵓⵍⴰ ⴷ ⵙⴻⴱⵄⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵅⴻⵎⵙⴰ ⵣⵣⴰⵢⵙⴻⵏ ⵡⴹⴰⵏ, ⵉⵊⵊⴻⵏ ⴰⵇⴰ ⵉⴵⴰ ⵄⴰⴷ, ⴷ ⵡⴻⵏⵏⴻⵖⵏⵉ ⴰⵇⴰ-ⵜ ⵄⴰⴷ ⵡⴰⵔ ⴷⴷ-ⵢⵓⵙⵉ. ⵎⴰⵍⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⴷ ⴰⵙ ⵉⵎⵎⴻⵡⵛ ⴷⵔⵓⵙ ⵏ ⵍⵡⴻⵇⵜ ⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("RV17_11","096_17_11","REV","17","11","11","ⵓⵛⴰ ⵍⵀⴰⵢⵛⴻⵜ ⴷ ⵍⵡⴻⵃⵛ ⵏⵏⵉ ⴷⴷ-ⵢⵉⵡⵉ ⵓ ⵡⴰⵔ ⵉⴵⵉ ⴷ ⵡⴻⵏⵏⵉ, ⵍⵀⴰⵢⵛⴻⵜ ⵏⵏⵉ ⴰⵇⴰ-ⵜⵜ ⴷ ⴰⵊⴻⴵⵉⴷ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ, ⵎⴰⵛⴰ ⴰⴷ ⵜⴻⴼⴼⴻⵖ ⵣⵉ ⵙⴻⴱⵄⴰ ⵏⵏⵉ ⵓⵛⴰ ⴰⴷ ⵜⵀⴻⵍⵍⴻⴽ. ");
INSERT INTO rift_vpl VALUES ("RV17_12","096_17_12","REV","17","12","12","ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉ ⵜⴻⵥⵔⵉⴷ, ⴰⵇⴰ ⴷ ⵄⴻⵛⵔⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵄⴰⴷ, ⵎⴰⵛⴰ ⴰⴷ ⵟⵟⴼⴻⵏ ⵚⵚⵓⵍⵟⴰ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵍⵇⴻⴷⴷ ⵏ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⴰⴽ-ⴷ ⵍⵡⴻⵃⵛ. ");
INSERT INTO rift_vpl VALUES ("RV17_13","096_17_13","REV","17","13","13","ⵏⵉⵜⵏⵉ ⵖⴰⵔⵙⴻⵏ ⴰⵔⵔⴰⵢ ⴷ ⵉⵊⵊⴻⵏ, ⴰⴷ ⵡⵛⴻⵏ ⵊⵊⴻⵀⴷ ⵏⵙⴻⵏ ⴷ ⵚⵚⵓⵍⵟⴰ ⵏⵙⴻⵏ ⵉ ⵍⵡⴻⵃⵛ. ");
INSERT INTO rift_vpl VALUES ("RV17_14","096_17_14","REV","17","14","14","ⵉⵏⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵉⵣⵎⴰⵔ ⵓⵛⴰ ⵉⵣⵎⴰⵔ ⴰⴷ ⵅⴰⵙⴻⵏ ⵉⵖⵍⴻⴱ ⵎⵉⵏⵣⵉ ⵏⴻⵜⵜⴰ ⴷ ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵉⵙⵉⴷⵉⵜⴻⵏ ⴷ ⵓⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ, ⵓ ⵉⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ ⵉⴵⴰⵏ ⴰⵇⴰ-ⵜⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵍⴰⵖⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⴼⴰⵔⵣⴻⵏ ⴷ ⵉⵎⵜⵉⵇⵇⴰⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV17_15","096_17_15","REV","17","15","15","ⵉⵏⵏⴰ ⴰⵢⵉ ⵄⴰⵡⴻⴷ: “ⴰⵎⴰⵏ ⵉ ⵜⴻⵥⵔⵉⴷ ⵉ ⵅ ⵜⴻⵇⵇⵉⵎ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⴰⵇⴰ ⴰⵜⴻⵏ ⴷ ⵍⴻⴳⵏⵓⵙ, ⴷ ⵉⴱⴰⵔⵔⵓⵜⴻⵏ ⵏ ⵍⵖⴰⵛⵉ, ⴷ ⵛⵛⵓⵄⵓⴱ, ⴷ ⵉⵍⵙⴰⵡⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV17_16","096_17_16","REV","17","16","16","ⵓⵛⴰ ⵄⴻⵛⵔⴰ ⵏ ⵡⴰⵛⵛⴰⵡⴻⵏ ⵉ ⵜⴻⵥⵔⵉⴷ ⵅ ⵍⵡⴻⵃⵛ, ⵏⵉⵜⵏⵉ ⴰⴷ ⵛⴰⵔⵀⴻⵏ ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴰⴷ ⵜⵜ ⴰⵔⴻⴷⴷⴵⴻⵏ, ⴰⴷ ⵜⵜ ⴰⵔⵔⴻⵏ ⴷ ⵜⴰⵄⴻⵔⵢⴰⵏⵜ, ⴰⴷ ⵛⵛⴻⵏ ⴰⵢⵙⵓⵎ ⵏⵏⴻⵙ, ⴰⴷ ⵜⵜ ⵙⵙⵛⴻⵎⴹⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("RV17_17","096_17_17","REV","17","17","17","ⵎⴰⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵉⵡⵛⴰ ⴰⵙⴻⵏ ⴷⴻⴳ ⵡⵓⵍⴰⵡⴻⵏ ⵏⵙⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⴳⴳⴻⵏ ⵏⵏⴻⵢⵢⴻⵜ ⵏ ⵍⵡⴻⵃⵛ, ⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵜⵜ ⴳⴳⴻⵏ ⵙ ⴰⵔⵔⴰⵢ ⴷ ⵉⵊⵊⴻⵏ, ⵓⵛⴰ ⴰⴷ ⵡⵛⴻⵏ ⵜⴰⴳⴻⵍⴷⴰ ⵏⵙⴻⵏ ⵉ ⵍⵡⴻⵃⵛ ⴰⵍ ⵖⴰ ⵜⵜⵡⴰⴽⴻⵎⵎⵍⴻⵏ ⴰⵡⴰⵍⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV17_18","096_17_18","REV","17","18","18","ⵓⵛⴰ ⵜⴰⵎⴻⵟⵟⵓⵜ ⵉ ⵜⴻⵥⵔⵉⴷ, ⵏⴻⵜⵜⴰⵜ ⴷ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵜⴻⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵜⴳⴻⵍⴷⴰ ⵅ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV18_1","096_18_1","REV","18","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⵀⴻⴽⴽⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵖⴰⵔⴻⵙ ⵚⵚⵓⵍⵟⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⵓⵛⴰ ⵟⵟⵢⴰ ⵏ ⵓⵄⵓⴵⵉ ⵏⵏⴻⵙ ⵜⴻⴳⴳⴰ ⵜⴰⴼⴰⵡⵜ ⴽⵓⵍⵛⵉ ⵉ ⵜⴻⵎⵎⵓⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV18_2","096_18_2","REV","18","2","2","ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵙ ⵜⵎⵉⵊⵊⴰ ⵜⴻⵊⵀⴻⴷ, ⵉⵇⵇⴰⵔ: “ⴰⵇⴰ ⵜⴻⵡⴹⴰ, ⵜⴻⵡⴹⴰ ⵜⴻⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴱⴰⴱⵉⵍ, ⵜⴻⴷⵡⴻⵍ ⴷ ⵜⴰⵣⴻⴷⴷⵉⵖⵜ ⵉ ⵛⵛⵡⴰⵟⴻⵏ ⴷ ⵍⴻⵃⴱⴻⵙ ⵉ ⴽⵓⵍ ⵍⴰⵔⵢⴰⵃ ⴰⵎⴻⵏⴳⵓⵙ ⴰⵎⴻⵏⵄⵉ, ");
INSERT INTO rift_vpl VALUES ("RV18_3","096_18_3","REV","18","3","3","ⵎⵉⵏⵣⵉ ⵜⴻⵙⵙⵅⴻⴵⴻⴹ ⴱⵉⵏⵓ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ ⵉ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ, ⵓ ⵎⵉⵏⵣⵉ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⵇⴰ ⵙⵙⴼⴻⵙⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵣⵣⴰⵢⴻⵙ, ⵓ ⵎⵉⵏⵣⵉ ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⵡⴰⵊⵊⴰⵔ ⵙ ⵊⵊⴻⵀⴷ ⵏ ⵓⵟⴻⵎⵎⴻⵙ ⵏⵏⴻⵙ ⵏ ⵡⴰⴳⵔⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV18_4","096_18_4","REV","18","4","4","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉ ⵜⵎⵉⵊⵊⴰ ⵏⵏⴻⵖⵏⵉ ⵜⵍⴰⵖⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ: “ⴼⴼⴻⵖ ⵣⵣⴰⵢⴻⵙ, ⴰ ⵍⴳⴻⵏⵙ ⵉⵏⵓ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵜⵜⵉⵍⵉⵏ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⵅ ⵢⵉⵔⵉ ⵏⵏⴻⵛ ⵓⵛⴰ ⵡⴰⵔ ⵜⴽⴻⵙⵙⵉⴷ ⵣⵉ ⵊⵊⵔⴰⵢⴻⵃ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RV18_5","096_18_5","REV","18","5","5","ⵎⵉⵏⵣⵉ ⴷⴷⵏⵓⴱ ⵏⵏⴻⵙ ⴰⵇⴰ ⵉⵡⴹⴻⵏ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵄⵇⴻⵍ ⵅ ⵍⵎⵓⵄⵚⵉⵢⵢⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV18_6","096_18_6","REV","18","6","6","ⴰⵔⵔⴻⵎ-ⴷⴷ ⵅⴰⵙ ⴰⵎ ⵎⴰⵎⵎⴻⵛ ⴷⴷ-ⵜⴰⵔⵔⴰ ⵏⴻⵜⵜⴰⵜ, ⴰⵔⵔⴻⵎ-ⴷⴷ ⵅⴰⵙ ⵙ ⵓⴹⴻⴼⴼⵓⵙ ⵄⵍⴰⵃⵙⴰⴱ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ, ⵅⴻⴵⴻⴹ ⴰⵙ ⵙ ⵓⴹⴻⴼⴼⵓⵙ ⴷⴻⴳ ⵓⵖⴰⵔⵔⴰⴼ ⵏⵏⵉ ⵜⵓⵖⴰ ⵜⵅⴻⴵⴻⴹ ⵏⴻⵜⵜⴰⵜ. ");
INSERT INTO rift_vpl VALUES ("RV18_7","096_18_7","REV","18","7","7","ⵅⴻⵍⴼⴻⵎ ⴰⵙ-ⴷⴷ ⴰⵄⴻⴷⴷⴻⴱ ⴷ ⵡⴻⵛⴹⴰⵏ ⴰⵏⴻⵛⵜ ⵜⵓⵖⴰ ⵏⴻⵜⵜⴰⵜ ⵜⴻⵙⵙⵄⵓⴵⵉ ⵓ ⵜⴻⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵅⴻⴼ ⵏⵏⴻⵙ ⵎⵉⵏⵣⵉ ⵜⴻⵏⵏⴰ ⴷⴻⴳ ⵡⵓⵍ ⵏⵏⴻⵙ: ‘ⴰⵇⴰ ⵇⵇⵉⵎⴻⵖ ⴰⵎ ⵜⵊⴻⴵⵉⴷⵜ, ⵡⴰⵔ ⴵⵉⵖ ⴷ ⵜⴰⵊⵊⴰⵍⵜ, ⵓⵛⴰ ⴰⵛⴹⴰⵏ ⵡⴰⵔ ⵜ ⵥⴰⵔⵔⴻⵖ ⵛⴰ!’ ");
INSERT INTO rift_vpl VALUES ("RV18_8","096_18_8","REV","18","8","8","ⵙ ⵓⵢⴻⵏⵏⵉ ⴷⴻⴳ ⵉⵊⵊ ⵏ ⵡⴰⵙⵙ ⴰⴷ ⵅⴰⵙ ⵡⴹⴰⵏⵜ ⵎⴰⵔⵔⴰ ⵊⵊⵔⴰⵢⴻⵃ ⵏⵏⴻⵙ: ⵍⵎⴻⵡⵜ, ⴰⵛⴹⴰⵏ ⴷ ⵍⴰⵥ, ⵓⵛⴰ ⴰⴷ ⵜᵉⵜⵜⵡⴰⵛⵎⴻⴹ ⴷⵉ ⵜⵎⴻⵙⵙⵉ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ, ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉ ⵖⴰ ⵉⵃⴻⴽⵎⴻⵏ, ⴰⵇⴰ ⵉⵊⵀⴻⴷ. ");
INSERT INTO rift_vpl VALUES ("RV18_9","096_18_9","REV","18","9","9","ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⵏⵏⵉ ⴽⵉⴷⴻⵙ ⵉⴳⴳⵉⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵓ ⵙⵙⴳⴻⵄⵄⴷⴻⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ, ⴰⴷ ⵅⴰⵙ ⵔⵓⵏ, ⴰⴷ ⵅⴰⵙ ⵡⵜⴻⵏ ⴰⴳⴻⵊⴷⵓⵔ ⵅⵎⵉ ⵖⴰ ⵥⴰⵔⴻⵏ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV18_10","096_18_10","REV","18","10","10","ⵏⵉⵜⵏⵉ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵣⵉ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵏ ⵓⵄⴻⴷⴷⴻⴱ ⵏⵏⴻⵙ, ⵇⵇⴰⵔⴻⵏ: ‘ⵓⵛⵜ, ⵓⵛⵜ, ⵓⵛⵜ, ⵅⴰⵎ, ⴰ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ, ⴱⴰⴱⵉⵍ, ⵜⴰⵏⴷⵉⵏⵜ ⵉⵊⴻⵀⴷⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵇⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵍⵃⵓⴽⵎ ⵏⵏⴻⵎ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ!’” ");
INSERT INTO rift_vpl VALUES ("RV18_11","096_18_11","REV","18","11","11","ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵅⴰⵙ ⵔⵓⵏ, ⴰⴷ ⵛⴻⴹⵏⴻⵏ, ⵎⵉⵏⵣⵉ ⵓⵍⴰ ⴷ ⵉⵊⵊ ⵡⴰⵔ ⵉⵙⵙⵉⵖ ⵄⴰⴷ ⵙⵙⴻⵍⵄⴻⵜ ⵏⵙⴻⵏ: ");
INSERT INTO rift_vpl VALUES ("RV18_12","096_18_12","REV","18","12","12","ⵙⵙⴻⵍⵄⴻⵜ ⵏ ⵡⵓⵔⴻⵖ ⴷ ⵏⵏⵓⵇⴰⵔⵜ ⴷ ⵢⴻⵥⵔⴰ ⵢⵉⵖⵍⴰⵏ ⴷ ⵜⵢⴰⵇⵓⵜⵉⵏ ⴷ ⵍⴻⵇⵟⴻⵏ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉ ⴷ ⵍⴻⵃⵔⵉⵔ ⴰⵣⴻⴳⴳⵯⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⴽⴻⵛⵛⵓⴹ ⵉⵜⵜⴼⵓⵃⴻⵏ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵇⵛⵓⵄ ⵣⵉ ⵍⵄⴰⵊ ⴷ ⵄⵍⴰⵎ ⴽⵓⵍ ⵍⴻⵇⵛⵓⵄ ⵣⴻⴳ ⵓⴽⴻⵛⵛⵓⴹ ⵉⵖⵍⴰⵏ ⴷ ⵏⵏⵃⴰⵙ ⴷ ⵡⵓⵣⵣⴰⵍ ⴷ ⵍⵎⴰⵔⵎⵓⵔ ");
INSERT INTO rift_vpl VALUES ("RV18_13","096_18_13","REV","18","13","13","ⴷ ⵍⵇⴰⵔⴼⴰ ⴷ ⵍⴻⴱⵅⵓⵔ ⴷ ⵎⵉⵔⵔⵓ ⴷ ⵊⵊⴰⵡⵉ ⴷ ⴱⵉⵏⵓ ⴷ ⵣⵣⴻⵛⵜ ⵏ ⵣⵣⵉⵜⵓⵏ ⴷ ⴰⵔⴻⵏ ⵏ ⵙⵙⵎⵉⴷ ⴷ ⵡⵓⴵⵉ ⴷ ⵢⴻⵢⵙⴰⵏ ⴷ ⵉⴽⴰⵔⵔⵓⵜⴻⵏ ⵓⵍⴰ ⴷ ⴰⵔⵔⵉⵎⴰⵜ ⴷ ⵍⴻⵄⵎⵓⵔ ⵏ ⵉⵡⴷⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV18_14","096_18_14","REV","18","14","14","ⴰⵇⴰ ⵍⵖⵉⴵⴻⵜ ⵉ ⴷⵉ ⵜⵓⵖⴰ ⵉⵜⵜⵎⴻⵥⵔⵉ ⵍⴻⵄⵎⴰⵔ ⵏⵏⴻⵎ, ⴰⵇⴰ ⵜⵉⴳⴳⵯⴻⵊ ⵅⴰⵎ, ⵓⵍⴰ ⴷ ⵎⴰⵔⵔⴰ ⵎⵉⵏ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵎ ⴷ ⴰⴳⵍⴰ ⴷ ⵎⵉⵏ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⴰⵇⴰ ⵉⵡⴻⴷⴷⴰⵔ, ⵡⴰⵔ ⵜ ⵜⵥⴰⵔⵔⴻⴷ ⵄⴻⵎⵎⴰⵔⵚ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("RV18_15","096_18_15","REV","18","15","15","ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏ ⵍⴻⵃⵡⴰⵢⴻⵊ-ⴰ, ⵉⵏⵏⵉ ⵉⴷⴻⵡⵍⴻⵏ ⵣⵣⴰⵢⵙⴻⵏⵜ ⴷ ⵜⵡⴰⵊⵊⴰⵔ, ⵡⴰⵔ ⵜⴻⵏⵜ ⵜⵜⵉⴼⴻⵏ ⵄⴰⴷ, ⵓⵛⴰ ⴰⴷ ⵇⵇⵉⵎⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ ⵣⵉ ⵜⴻⴳⴳⵯⵓⴷⵉ ⵏ ⵓⵄⴻⴷⴷⴻⴱ ⵏⵏⴻⵙ, ⴰⵎ ⵜⵜⵔⵓⵏ ⵓ ⴰⵎ ⵛⴻⵟⵟⵏⴻⵏ, ");
INSERT INTO rift_vpl VALUES ("RV18_16","096_18_16","REV","18","16","16","ⴰⴷ ⵉⵏⵉⵏ: “ⵓⵛⵜ, ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⵛⴻⵎ, ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵉ ⵢⴰⵔⴹⴻⵏ ⵍⴻⵇⵟⴻⵏ ⴷ ⴰⵔⵊⵓⵡⴰⵏⵉ ⴷ ⴰⵣⴻⴳⴳⵡⴰⵖ ⵉⵃⴻⴷⵇⴻⵏ ⵉⵇⵇⴻⵏ ⵙ ⵡⵓⵔⴻⵖ ⴷ ⵢⴻⵥⵔⴰ ⵉⵖⵍⴰⵏ ⴷ ⵜⵢⴰⵇⵓⵜⵉⵏ, ");
INSERT INTO rift_vpl VALUES ("RV18_17","096_18_17","REV","18","17","17","ⵙ ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⴰⵇⴰ ⵉⵡⴻⴷⴷⴰⵔ ⵡⴰⴳⵍⴰ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏⵏⵉ!” ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵏⴻⴷⴷⵀⴻⵏ ⵉⵖⴰⵔⵔⵓⴱⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴽⴽⴻⵏ ⵅ ⵍⴻⴱⵃⴰⵔ ⴷⴻⴳ ⵉⵖⴰⵔⵔⵓⴱⴰ ⴷ ⵎⴰⵔⵔⴰ ⵉⴱⴻⵃⵔⵉⵢⵢⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⴱⴱⴰⴱⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵇⵇⵉⵎⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵖⴰⵔ ⵍⴰⴳⴳⵯⴰⵊ. ");
INSERT INTO rift_vpl VALUES ("RV18_18","096_18_18","REV","18","18","18","ⵏⵉⵜⵏⵉ ⵙⵖⵓⵢⵢⴻⵏ ⵓⵎⵉ ⵥⵔⵉⵏ ⴷⴷⴻⵅⵅⴰⵏ ⵏ ⵜⵎⴻⵙⵙⵉ ⵏⵏⴻⵙ, ⵏⵏⴰⵏ: “ⵡⵉ ⵉⵣⴻⵎⵎⴰⵔⴻⵏ ⴰⴷ ⵉⵎⵇⵓⴷⴷⴰ ⴰⴽ-ⴷ ⵜⴻⵏⴷⵉⵏⵜ-ⴰ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ?” ");
INSERT INTO rift_vpl VALUES ("RV18_19","096_18_19","REV","18","19","19","ⵙⵙⵓⵢⵓⵙⴻⵏ ⵓⵛⴰⵍ ⵅ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⵓⵛⴰ ⵙⵖⵓⵢⴻⵏ, ⴰⵎ ⵜⵜⵔⵓⵏ ⵓ ⴰⵎ ⵜⵜⴻⵛⴹⵉⵏⴻⵏ, ⵏⵏⴰⵏ: “ⵓⵛⵜ, ⵓⵛⵜ ⵅⴰⵎ, ⴰ ⵛⴻⵎ, ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⵏⵏⵉ ⴷⵉ ⴷⴻⵡⵍⴻⵏ ⴷ ⵜⵡⴰⵊⵊⴰⵔ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵖⴰⵔ ⵉⴵⴰ ⵉⵖⴰⵔⵔⵓⴱⴰ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵙ ⵓⴱⴰⵔⵔⵓ ⵏ ⵡⴰⴳⵍⴰ ⵏⵏⴻⵙ, ⵎⵉⵏⵣⵉ ⴷⴻⴳ ⵉⵛⵜ ⵏ ⵜⵙⴰⵄⵄⴻⵜ ⵜⵡⴻⴷⴷⴰⵔ!” ");
INSERT INTO rift_vpl VALUES ("RV18_20","096_18_20","REV","18","20","20","“ⴼⴰⵔⵃⴻⵜ ⵣⵣⴰⵢⴻⵙ, ⴰ ⴰⵊⴻⵏⵏⴰ, ⵓ ⴽⴻⵏⵏⵉⵡ, ⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵔⵔⵓⵙⵓⵍ ⴷ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵎⵉⵏⵣⵉ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ ⵉⵙⵙⵓⴼⴼⴻⵖ-ⴷⴷ ⵍⴻⵃⴽⴰⵎⴻⵜ ⵏⵏⴻⵙ ⵅⴰⵙ!” ");
INSERT INTO rift_vpl VALUES ("RV18_21","096_18_21","REV","18","21","21","ⵓⵛⴰ ⵉⵊⵊ ⵣⵉ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵏⵏⵉ ⵉⵙⵙⴳⴻⵄⵄⴻⴷ ⵉⵊⵊ ⵏ ⵡⴻⵥⵔⵓ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴰⵏⴻⵛⵜ ⵏ ⵜⴻⵚⴹⴰⵔⵜ ⵏ ⵜⵙⵉⵔⵜ, ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ, ⵉⵇⵇⴰⵔ: “ⴰⵎⵎⵓ ⵙ ⵊⵊⴻⵀⴷ ⴰⴷ ⵜᵉⵎⵎⴻⵏⴹⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴱⴰⴱⵉⵍ ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵡⵉⴼⵉ ⵄⴰⴷ ⵄⴻⵎⵎⴰⵔⵚ! ");
INSERT INTO rift_vpl VALUES ("RV18_22","096_18_22","REV","18","22","22","ⵍⵃⴻⵙⵙ ⵏ ⵍⵀⴰⵔⴱⴰ ⴷ ⵓⵙⵓⴹⵉ ⴷⴻⴳ ⵓⵢⵉⵛⵛ ⵏ ⵉⵛⴰⵔⵔⵉ, ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵄⵍⴰⵎ ⴽⵓⵍ ⴰⵖⴻⵏⵏⴻⵊ ⵓ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵙⵓⴹⴻⵏ ⴷⵉ ⵍⴱⵓⵇ, ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵄⴰⴷ ⴷⴰⵢⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RV18_23","096_18_23","REV","18","23","23","ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴷⴰⵢⴻⵎ ⵜᵉⵜⵜⵡⴰⵥⴰⵔ ⵄⴰⴷ ⵟⵟⵢⴰ ⵏ ⵍⴻⴼⵏⴰⵔ, ⵓⵛⴰ ⵓⵍⴰ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵡⴻⵙⵍⵉ ⴷ ⵍⵃⴻⵙⵙ ⵏ ⵜⴻⵙⵍⵉⵜ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵙⴻⵍ ⵄⴰⴷ ⴷⴰⵢⴻⵎ. ⵉⵙⴻⴱⴱⴰⴱⴻⵏ ⵏⵏⴻⵎ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵎⵉⵏⵣⵉ ⵙ ⵜⵙⴻⵃⵃⴰⵔⵜ ⵏⵏⴻⵎ, ⴰⵇⴰ ⵜⵅⴻⴷⵄⴻⴷ ⵍⴻⴳⵏⵓⵙ ⵎⴰⵔⵔⴰ. ");
INSERT INTO rift_vpl VALUES ("RV18_24","096_18_24","REV","18","24","24","ⴰⵇⴰ ⵉⵜⵜⵡⴰⴼ ⴷⴰⵢⴻⵎ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⴷ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵏⵖⴻⵏ ⴷⵉ ⵜⴻⵎⵎⵓⵔⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV19_1","096_19_1","REV","19","1","1","ⴰⵡⴰⵔⵏⵉ ⴰⵙ ⵙⵍⵉⵖ ⵉⵊⵊ ⵏ ⵍⵃⴻⵙⵙ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵍⵖⴰⵛⵉ ⴷⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵏⵏⴰⵏ: “ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ! ⴰⵙⴻⵏⵊⴻⵎ ⴷ ⵓⵄⵓⴵⵉ ⴷ ⵊⵊⴻⵀⴷ ⴰⵇⴰ ⴰⵜⴻⵏ ⵖⴰⵔ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ");
INSERT INTO rift_vpl VALUES ("RV19_2","096_19_2","REV","19","2","2","ⵎⵉⵏⵣⵉ ⵍⴻⵃⴽⴰⵎⴰⵜ ⵏⵏⴻⵙ ⵎⵖⵉⵔ ⴷ ⵜⵉⴷⴻⵜⵜ ⴷ ⵍⵃⴻⵇⵇ, ⵓⵎⵉ ⵉⵃⴰⵙⴻⴱ ⵅ ⵜⴻⵎⵖⴰⵔⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ, ⵜⴻⵏⵏⵉ ⵢⴰⵔⴻⴷⴷⴵⴻⵏ ⴷⴷⵓⵏⴻⵛⵜ ⵙ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⵏⵏⴻⵙ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵢⵓⵖⴰ ⵜⴰⵙⵖⴰⵔⵜ ⵅ ⵉⴷⴰⵎⵎⴻⵏ ⵏ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵉ ⵢⵓⵎⵙⴻⵏ ⵖⴰⵔ ⵉⴼⴰⵙⵙⴻⵏ ⵏⵏⴻⵙ.” ");
INSERT INTO rift_vpl VALUES ("RV19_3","096_19_3","REV","19","3","3","ⵏⵏⴰⵏ ⵉ ⵓⵎⵓⵔ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ: “ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ!” ⵓⵛⴰ ⴰⴷ ⵢⴰⵍⵉ ⴷⴷⴻⵅⵅⴰⵏ ⵏⵏⴻⵙ ⵖⴰⵔ ⵓⵊⴻⵏⵏⴰ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("RV19_4","096_19_4","REV","19","4","4","ⵓⵛⴰ ⴰⵔⴻⴱⵄⴰ ⵓ-ⵄⵉⵛⵔⵉⵏ ⵏ ⵉⵎⵖⴰⵔⴻⵏ ⴷ ⴰⵔⴻⴱⵄⴰ ⵏ ⵉⵎⵓⴷⴷⴰⵔⴻⵏ ⵡⴹⴰⵏ ⵖⴰⵔ ⵜⴻⵎⵎⵓⵔⵜ, ⵙⴻⵊⴷⴻⵏ ⵉ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ, ⵏⵏⴰⵏ: “ⴰⵎⵉⵏ, ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ!” ");
INSERT INTO rift_vpl VALUES ("RV19_5","096_19_5","REV","19","5","5","ⵓⵛⴰ ⵜⵓⵙⴰ-ⴷⴷ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵣⵉ ⵍⵄⴰⵔⵛ, ⵜⴻⵏⵏⴰ: “ⵙⴻⵎⵖⴰⵔⴻⵎ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵖ, ⴰ ⴽⴻⵏⵏⵉⵡ ⵎⴰⵔⵔⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ, ⵓ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⵯⴻⴷⴻⵏ ⵉⵙⴻⵎ ⵏⵏⴻⵙ, ⴰⵎ ⵓⵎⴻⵥⵢⴰⵏ ⴰⵎ ⵓⵎⴻⵇⵇⵔⴰⵏ!” ");
INSERT INTO rift_vpl VALUES ("RV19_6","096_19_6","REV","19","6","6","ⵓⵛⴰ ⵙⵍⵉⵖ ⴰⵇⴰ ⵏⵏⴰⵏ ⴰⵎ ⵙ ⵜⵎⵉⵊⵊⴰ ⵏ ⵓⴱⴰⵔⵔⵓ ⵏ ⵍⵖⴰⵛⵉ, ⴰⵎ ⵙ ⵍⵃⴻⵙⵙ ⵏ ⵡⴰⵟⵟⴰⵙ ⵏ ⵡⴰⵎⴰⵏ, ⴰⵎ ⵙ ⵣⵣⵀⵉⵔ ⵏ ⵡⴰⵊⵊⴰⵊⴻⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ: “ⵀⴰⵍⵍⵉⵍⵓ-ⵢⴰⵀ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⴰⵇⴰ ⵉⵃⴻⴽⴽⴻⵎ. ");
INSERT INTO rift_vpl VALUES ("RV19_7","096_19_7","REV","19","7","7","ⴻⵊⵊ ⴰⴷ ⵏⴼⴰⵔⵃ, ⴰⴷ ⵏⴻⵙⵍⵉⵡⵍⵉⵡ, ⴰⴷ ⴰⵙ ⵏⴻⴳⴳ ⴰⵄⵓⴵⵉ, ⵎⴰⵖⴰⵔ ⵓⵔⴰⵔ ⵏ ⵢⴻⵣⵎⴰⵔ ⵢⵉⵡⴻⴹ-ⴷⴷ, ⵓⵛⴰ ⵜⴰⵎⵖⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵇⴰ ⵜⵃⴻⵣⵣⴻⵎ, ");
INSERT INTO rift_vpl VALUES ("RV19_8","096_19_8","REV","19","8","8","ⵓⵛⴰ ⵜⴻⵎⵎⴻⵡⵛ ⴰⵙ ⴰⴷ ⵜⵢⴰⵔⴹ ⴰⵔⵔⵓⴹ ⵣⵉ ⵍⵇⴻⵟⵟⴰⵏ ⵉⴼⵙⵓⵙⴻⵏ ⵉⵣⴷⵉⴳⴻⵏ ⵉⵜⵜⵉⵙⵙⵉⵇⴻⵏ, ⵎⵉⵏⵣⵉ ⵍⵇⴻⵟⵟⴰⵏ ⵏⵏⵉ ⴷ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵉⵙⴻⴳⴳⴷⴻⵏ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV19_9","096_19_9","REV","19","9","9","ⵏⵉⵜⵏⵉ ⵏⵏⴰⵏ ⴰⵢⵉ: “ⴰⵔⵉ: ⵙⵙⴻⵄⴷ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵄⴰⵔⴹⴻⵏ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ ⵏ ⵡⵓⵔⴰⵔ ⵏ ⵉⵣⵎⴰⵔ.’ ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ ⵛⴰ ⵏ ⵢⵉⵊⵊⴻⵏ: “ⵉⵏⴰ ⴷ ⴰⵡⴰⵍⴻⵏ ⵏ ⵜⵉⴷⴻⵜⵜ ⵏ ⴰⵔⴻⴱⴱⵉ.” ");
INSERT INTO rift_vpl VALUES ("RV19_10","096_19_10","REV","19","10","10","ⵓⵛⴰ ⵡⴹⵉⵖ ⴰⵙ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵃⵉⵎⴰ ⴰⴷ ⵜ ⵄⴻⴱⴷⴻⵖ, ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵍⵍⴰ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵛⴰ ⵎⴰⵏ ⴰⵢⴰ! ⴰⵇⴰ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵄⴰⵛⴰⵔ ⴰⵎ ⵛⴻⴽ ⴷ ⴰⵢⵜⵎⴰⵛ ⵉⵏⵏⵉ ⵖⴰⵔ ⵜⴻⴵⴰ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ. ⵄⴻⴱⴷⴻⵜ ⴰⵔⴻⴱⴱⵉ, ⵎⵉⵏⵣⵉ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⵏⴻⵜⵜⴰⵜ ⴷ ⴰⵔⵔⵓⵃ ⵏ ⵎⵉⵏ ⵉⵜⵜⵡⴰⵏⴰⴱⴱⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV19_11","096_19_11","REV","19","11","11","ⴰⵡⴰⵔⵏⵉ ⴰⵢⴰ ⵥⵔⵉⵖ ⴰⵊⴻⵏⵏⴰ ⵉⵏⵏⵓⵔⵣⴻⵎ, ⵓ ⵅⵣⴰⵔ, ⴰⵇⴰ ⴷⵉⵏ ⵉⵊⵊ ⵏ ⵓⵢⵉⵙ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵏⵢⵉⵏ, ⵇⵇⴰⵔⴻⵏ ⴰⵙ ‘ⴷⴰⵢⴻⵙ ⵍⴰⵎⴰⵏ!’, ‘ⴷⴰⵢⴻⵙ ⵜⵉⴷⴻⵜⵜ!’, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵉⵃⴰⵙⴻⴱ ⵓ ⴰⴷ ⵉⵎⵎⵏⴻⵖ ⵙ ⵜⵙⴻⴳⴷⴰ. ");
INSERT INTO rift_vpl VALUES ("RV19_12","096_19_12","REV","19","12","12","ⵜⵓⵖⴰ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵏⴻⵙ ⴰⵎⴻⵛⵏⴰⵡ ⵉⵃⵓⴷⴰⵇ ⵏ ⵜⵎⴻⵙⵙⵉ, ⵓⵛⴰ ⵖⴰⵔⴻⵙ ⵅ ⵓⵣⴻⴵⵉⴼ ⵏⵏⴻⵙ ⴰⵟⵟⴰⵙ ⵏ ⵜⵜⵉⵊⴰⵏ, ⵓⵛⴰ ⵢⵓⵔⴰ ⵅⴰⵙ ⵉⵙⴻⵎ ⵉ ⵡⴰⵔ ⵜ ⵉⵙⵙⵉⵏ ⵃⴻⴷ ⵎⵖⵉⵔ ⵏⴻⵜⵜⴰ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("RV19_13","096_19_13","REV","19","13","13","ⵜⵓⵖⴰ ⵢⴰⵔⴹ ⵉⵊⵊ ⵏ ⵓⵙⴻⵍⵀⴰⵎ ⵉⵜⵜⵡⴰⵔⵓⵛⵛⴻⵏ ⵙ ⵉⴷⴰⵎⵎⴻⵏ, ⵓⵛⴰ ⵡⴰ ⴷ ⵉⵙⴻⵎ ⵏⵏⴻⵙ: ‘ⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ’. ");
INSERT INTO rift_vpl VALUES ("RV19_14","096_19_14","REV","19","14","14","ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏ ⵓⵊⴻⵏⵏⴰ ⴹⴼⴰⵔⴻⵏ ⵜ-ⵉ-ⴷⴷ ⵅ ⵢⴻⵢⵙⴰⵏ ⵉⵛⴻⵎⵍⴰⵍⴻⵏ, ⴰⵔⴹⴻⵏ ⵍⵇⴻⵟⵟⴰⵏ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⵉⵣⴷⵉⴳ. ");
INSERT INTO rift_vpl VALUES ("RV19_15","096_19_15","REV","19","15","15","ⴼⴼⵖⴻⵏ-ⴷⴷ ⵍⴻⵙⵢⵓⴼ ⵉⵇⴻⴹⵄⴻⵏ ⵣⴻⴳ ⵉⵇⴻⵎⵎⵓⵎⴻⵏ ⵏⵙⴻⵏ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵣⵣⴰⵢⵙⴻⵏ ⵏⵖⴻⵏ ⵍⴻⴳⵏⵓⵙ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵜⴻⵏ ⵉⵃⴹⴰ ⵙ ⵓⵣⴻⴵⴰⴹ ⵏ ⵡⵓⵣⵣⴰⵍ, ⵓ ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵉⵄⴼⴻⵙ ⴷⵉ ⵜⵙⵉⵔⵜ ⵏ ⵡⴻⵖⴹⴰⴱ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ. ");
INSERT INTO rift_vpl VALUES ("RV19_16","096_19_16","REV","19","16","16","ⵅ ⵡⴰⵔⵔⵓⴹ ⵏⵏⴻⵙ ⵓ ⵅ ⵜⵎⴻⵚⵚⴰⴹⵉⵏ ⵏⵏⴻⵙ ⵢⵓⵔⴰ ⵅⴰⵙⴻⵏ ⵉⵙⴻⵎ-ⴰ: ‘ⴰⵊⴻⴵⵉⴷ ⵅ ⵎⴰⵔⵔⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ’, ‘ⵙⵉⴷⵉ ⵅ ⵎⴰⵔⵔⴰ ⵍⵃⵓⴽⴽⴰⵎ’. ");
INSERT INTO rift_vpl VALUES ("RV19_17","096_19_17","REV","19","17","17","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⴱⴻⴷⴷ ⴷⵉ ⵜⴼⵓⵛⵜ. ⵏⴻⵜⵜⴰ ⵉⵍⴰⵖⴰ ⵙ ⵊⵊⴻⵀⴷ, ⵉⵏⵏⴰ ⵉ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵉⵟⵟⴰⵡⴻⵏ ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵓⵊⴻⵏⵏⴰ: “ⴰⵙⴻⵜⵜⵉⵡ-ⴷ, ⵎⵓⵏⴻⵜⵜⵉⵡ-ⴷⴷ ⵖⴰⵔ ⵓⵎⴻⵏⵙⵉ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵏ ⴰⵔⴻⴱⴱⵉ, ");
INSERT INTO rift_vpl VALUES ("RV19_18","096_19_18","REV","19","18","18","ⵃⵉⵎⴰ ⴰⴷ ⵜⴻⵛⵛⴻⵎ ⴰⵢⵙⵓⵎ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⵅ ⵡⴰⵍⴻⴼ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏ ⵢⵉⵏⵏⵉ ⵉⵊⴻⵀⴷⴻⵏ ⴷ ⵡⴻⵢⵙⵓⵎ ⵏ ⵉⵢⵙⴰⵏ ⴷ ⵢⵉⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉⵏⵢⵉⵏ, ⴷ ⵡⴻⵢⵙⵓⵎ ⵏ ⵉⵃⵓⵔⵔⵉⵢⵢⴻⵏ ⴷ ⵉⵙⴻⵎⵖⴰⵏ, ⴰⵎ ⵏ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ ⴰⵎ ⵏ ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV19_19","096_19_19","REV","19","19","19","ⵓⵛⴰ ⵥⵔⵉⵖ ⵍⵡⴻⵃⵛ ⴰⴽ-ⴷ ⵍⵄⴻⵙⴽⴰⵔⴰⵜ ⵏⵏⴻⵙ ⴷ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵄⴻⵙⴽⴰⵔⵔⵉⵢⵢⴻⵏ ⵏⵙⴻⵏ, ⵉⵏⵏⵉ ⵉⵎⵓⵏⴻⵏ ⵃⵉⵎⴰ ⴰⴷ ⵎⵎⴻⵏⵖⴻⵏ ⴰⴽ-ⴷ ⵡⴻⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵓⵢⵉⵙ, ⵓ ⴰⴽ-ⴷ ⵉⵄⴻⵙⴽⴰⵔⵉⵢⵢⴻⵏ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV19_20","096_19_20","REV","19","20","20","ⴰⵇⴰ ⵉⵜⵜⵡⴰⵟⵟⴻⴼ ⵍⵡⴻⵃⵛ ⴰⴽ-ⴷ ⵓⵏⴰⴱⵉ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵣⵣⴰⵜⴻⵙ ⵍⴻⵄⵍⴰⵎⴰⵜ ⵏⵏⵉ ⵣⵉ ⵜⵓⵖⴰ ⵉⵖⴻⵛⵛ ⵉⵏⵏⵉ ⵉⴽⵙⵉⵏ ⵍⵎⴰⵔⴽⴰ ⵏ ⵍⵡⴻⵃⵛ ⵓⵛⴰ ⵙⴻⵊⴷⴻⵏ ⵉ ⵍⴻⵅⵢⴰⵍ ⵏⵏⴻⵙ. ⵏⵉⵜⵏⵉ ⵙ ⵜⵏⴰⵢⴻⵏ ⵉⴷⵙⴻⵏ ⵜⵜⵡⴰⵎⵎⴻⵏⴹⴰⵔⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⵛⴻⴼⵛⵓⴼⴻⵏ ⵄⴰⵡⴻⴷ ⵙ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ. ");
INSERT INTO rift_vpl VALUES ("RV19_21","096_19_21","REV","19","21","21","ⵎⴰⵛⴰ ⵡⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵜⵜⵡⴰⵏⵖⴻⵏ ⵙ ⵡⵓⵣⵣⴰⵍ ⵉ ⴷⴷ-ⵉⴽⴽⵉⵏ ⵣⴻⴳ ⵓⵇⴻⵎⵎⵓⵎ ⵏ ⵡⴻⵏⵏⵉ ⵉⵏⵢⵉⵏ ⵅ ⵓⵢⵉⵙ. ⵓⵛⴰ ⵎⴰⵔⵔⴰ ⵉⵊⴹⴰⴹ ⵉⵜⵜⴽⴻⵛⵛⴰⴹⴻⵏ ⵊⵊⵉⵡⵏⴻⵏ ⵙ ⵡⴻⵢⵙⵓⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV20_1","096_20_1","REV","20","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵖⵏⵉ ⵉⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵖⴰⵔⴻⵙ ⵜⴰⵙⴰⵔⵓⵜ ⵏ ⵜⴻⵙⵔⴰⴼⵜ ⵉ ⵉⴵⴰⵏ ⵙⴰⴷⵓ ⵉ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵉⵛⵜ ⵏ ⵙⵙⵏⴻⵙⵍⴻⵜ ⵜⴰⵎⴻⵇⵇⵔⴰⵏⵜ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV20_2","096_20_2","REV","20","2","2","ⵏⴻⵜⵜⴰ ⵉⵟⵟⴻⴼ ⵍⵀⴰⵢⵛⴻⵜ, ⴰⴼⵉⵖⴰⵔ ⴰⵡⴻⵙⵙⴰⵔ, ⵡⴻⵏⵏⵉ ⴷ ⵉⴱⵍⵉⵙ ⴷ ⵛⵛⵉⵟⴰⵏ ⵓⵛⴰ ⵉⵛⴰⵔⴼ ⵉ-ⵜ ⵉ ⵢⵉⵊⵊ ⵏ ⵍⵇⴻⴷⴷ ⵏ ⵡⴰⵍⴻⴼ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ");
INSERT INTO rift_vpl VALUES ("RV20_3","096_20_3","REV","20","3","3","ⵓⵛⴰ ⵉⵏⴹⴰⵔ ⵉ-ⵜ ⴷⵉ ⵜⴻⵙⵔⴰⴼⵜ ⵙⴰⴷⵓ ⵜⴻⵎⵎⵓⵔⵜ, ⵉⴱⴻⵍⵍⴻⵄ ⵅⴰⵙ ⵓⵛⴰ ⵉⴳⴳⴰ ⵅⴰⵙ ⴰⵛⴻⵎⵎⵉⵄ, ⵃⵉⵎⴰ ⵡⴰⵔ ⵉⵜⵜⵖⴻⵛⵛⵉ ⵄⴰⴷ ⵍⴻⴳⵏⵓⵙ. ⴰⵡⴰⵔⵏⵉ ⵎⴰⵏ ⴰⵢⴰ ⴰⴷ ⵉⵜⵜⵡⴰⴹⵍⴻⵇ ⵖⴰⵔ ⵛⵡⴰⵢⵜ ⵏ ⵍⵡⴻⵇⵜ. ");
INSERT INTO rift_vpl VALUES ("RV20_4","096_20_4","REV","20","4","4","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵍⴻⴽⵔⴰⵙⵉ ⵏ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵙⵙⵖⵉⵎⵉⵏ ⵉⵅⴻⴼ ⵏⵙⴻⵏ ⵅⴰⵙⴻⵏ, ⵓⵛⴰ ⵉⵎⵎⴻⵡⵛ ⴰⵙⴻⵏ ⵍⵃⵓⴽⵎ. ⴰⵇⴰ ⵍⴻⵄⵎⵓⵔ-ⴰ - ⵏ ⵢⵉⵏⵏⵉ ⵓⵎⵉ ⴽⴽⵙⴻⵏ ⵉⵣⴻⴵⵉⴼⴻⵏ ⵏⵙⴻⵏ ⴷⵉ ⵟⵟⵡⴻⵄ ⵏ ⵛⵛⵀⴰⴷⴻⵜ ⵏ ⵢⴰⵙⵓⵄ ⴷ ⵡⴰⵡⴰⵍ ⵏ ⴰⵔⴻⴱⴱⵉ, ⵡⴰⵔ ⵙⴻⵊⴷⴻⵏ ⵉ ⵍⵡⴻⵃⵛ ⵓⵍⴰ ⵉ ⵍⴻⵅⵢⴰⵍ, ⵡⴰⵔ ⵟⵟⵉⴼⴻⵏ ⵛⴰ ⵍⵎⴰⵔⴽⴰ ⵅ ⵜⴻⵏⵢⴰⵔⵜ ⵏⵙⴻⵏ ⵓⵍⴰ ⴷⴻⴳ ⵓⴼⵓⵙ ⵏⵙⴻⵏ - ⴰⵇⴰ ⵍⴻⵄⵎⵓⵔ-ⴰ ⴷⴷⴰⵔⴻⵏ ⵓ ⵃⴻⴽⵎⴻⵏ ⴰⴽ-ⴷ ⵍⵎⴰⵙⵉⵃ ⴰⵍⴻⴼ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("RV20_5","096_20_5","REV","20","5","5","ⵜⴰ ⴷ ⵜⴰⵏⵓⴽⵔⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ");
INSERT INTO rift_vpl VALUES ("RV20_6","096_20_6","REV","20","6","6","ⵙⵙⴻⵄⴷ ⴷ ⵓⵎⵇⴻⴷⴷⴰⵙ ⵏ ⵡⴻⵏⵏⵉ ⵉ ⵖⴰ ⵉⵟⵟⴼⴻⵏ ⵜⴰⵙⵖⴰⵔⵜ ⴷⵉ ⵜⵏⵓⴽⵔⴰ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ. ⵍⵎⴻⵡⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵡⴰⵔ ⵖⴰⵔⴻⵙ ⵜⵉⵍⵉ ⴱⵓ ⵚⵚⵓⵍⵟⴰ ⵅⴰⵙⴻⵏ, ⵎⴰⵛⴰ ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵉⴽⴻⵀⵀⴰⵏⴻⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏ ⵍⵎⴰⵙⵉⵃ ⵓⵛⴰ ⴰⴷ ⴽⵉⵙ ⵃⴻⴽⵎⴻⵏ ⴰⵍⴻⴼ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ. ");
INSERT INTO rift_vpl VALUES ("RV20_7","096_20_7","REV","20","7","7","ⵅⵎⵉ ⵖⴰ ⵉⵇⴼⴻⵍ ⴰⵍⴻⴼ ⵏ ⵉⵙⴻⴳⴳⵯⵓⵙⴰ, ⴰⴷ ⵉⵜⵜⵡⴰⴹⵍⴻⵇ ⵛⵛⵉⵟⴰⵏ ⵣⵉ ⵍⴻⵃⴱⴻⵙ ⵏⵏⴻⵙ, ");
INSERT INTO rift_vpl VALUES ("RV20_8","096_20_8","REV","20","8","8","ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⵉⴼⴼⴻⵖ ⵃⵉⵎⴰ ⴰⴷ ⵉⵖⴻⵛⵛ ⵎⴰⵔⵔⴰ ⵍⴻⴳⵏⵓⵙ ⵉⵏⵏⵉ ⵉⴵⴰⵏ ⵖⴰⵔ ⴰⵔⴻⴱⵄⴰ ⵏ ⵜⵖⴻⵎⵎⵓⵔⴰ ⵏ ⵜⴻⵎⵎⵓⵔⵜ, ⵀⴰⵊⵓⵊ ⴷ ⵎⴰⵊⵓⵊ, ⴰⴷ ⵜⴻⵏ ⵉⵙⵙⵎⵓⵏ ⵉ ⵓⵎⴻⵏⵖⵉ, ⵓ ⵍⵇⴻⴷⴷ ⵏⵙⴻⵏ ⴰⵎ ⵢⴻⵊⴷⵉ ⵏ ⵍⴻⴱⵃⴰⵔ.    ");
INSERT INTO rift_vpl VALUES ("RV20_9","096_20_9","REV","20","9","9","ⵃⴰⵔⵔⵛⴻⵏ-ⴷⴷ ⵣⵉ ⵟⵟⴰⵔⴼ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵓⵛⴰ ⵏⵏⴹⴻⵏ ⴰⵙ ⵉ ⵍⵎⴰⵔⴳⴻⵃ ⵏ ⵍⵄⴻⵙⴽⴰⵔ ⵏ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵄⵉⵣⵣⴻⵏ, ⵓⵛⴰ ⵜⴻⵡⴹⴰ-ⴷⴷ ⵜⵎⴻⵙⵙⵉ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵣⵉ ⵣⵣⴰⵜ ⴰⵔⴻⴱⴱⵉ, ⵓⵛⴰ ⵜⴻⵛⵛⴰ ⵉ-ⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV20_10","096_20_10","REV","20","10","10","ⵓⵛⴰ ⵉⴱⵍⵉⵙ, ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⵜⴻⵏ ⵉⵖⵡⴰⵏ, ⴰⵇⴰ ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⵎⴻⵙⵙⵉ ⵉⵜⵜⵛⴻⴼⵛⵓⴼⴻⵏ ⵙ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ ⵎⴰⵏⵉ ⵉⴵⴰ ⵍⵡⴻⵃⵛ ⴷ ⵓⵏⴰⴱⵉ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ ⵓⵛⴰ ⴰⴷ ⵜⵜⵡⴰⵄⴻⴷⴷⴱⴻⵏ ⴰⵙⵙ ⴷ ⴵⵉⵍⴻⵜ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("RV20_11","096_20_11","REV","20","11","11","ⵓⵛⴰ ⵥⵔⵉⵖ ⵉⵊⵊ ⵏ ⵍⵄⴰⵔⵛ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⴷ ⴰⵛⴻⵎⵍⴰⵍ ⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙ ⵉⵇⵇⵉⵎⴻⵏ, ⴰⵇⴰ ⵣⵉ ⴰⵔⴻⵏⴷⴰⴷ ⵏ ⵓⵖⴻⵎⴱⵓⴱ ⵏⵏⴻⵙ ⵜⴰⵔⵡⴻⵍ ⵜⴻⵎⵎⵓⵔⵜ ⴷ ⵓⵊⴻⵏⵏⴰ, ⵎⴰⵛⴰ ⵡⴰⵔ ⴷ ⴰⵙⴻⵏ ⵉⵇⵇⵉⵎ ⴱⵓ ⵡⴻⵎⵛⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV20_12","096_20_12","REV","20","12","12","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⴱⴻⴷⴷⴻⵏ ⵣⵣⴰⵜ ⵉ ⵍⵄⴰⵔⵛ, ⵉⵎⴻⵇⵇⵔⴰⵏⴻⵏ ⴷ ⵉⵎⴻⵥⵢⴰⵏⴻⵏ. ⴰⵇⴰ ⵏⵏⵓⵔⵣⵎⴻⵏ ⵉⴷⵍⵉⵙⴻⵏ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵓⵛⴰ ⵉⵏⵏⵓⵔⵣⴻⵎ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏⵏⴻⵖⵏⵉ, ⴰⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵍⵃⵓⴽⵎ. ⵓⵛⴰ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵅ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵣⵉ ⵎⵉⵏ ⵢⵓⵔⴰⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵅ ⵍⴻⵃⵙⴰⴱ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV20_13","096_20_13","REV","20","13","13","ⵓⵛⴰ ⵍⴻⴱⵃⴰⵔ ⵉⵡⵛⴰ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴰⵢⴻⵙ, ⵓⵛⴰ ⵍⵎⴻⵡⵜ ⴷ ⵍⴰⵅⴰⵔⵜ ⵡⵛⵉⵏⵜ ⵉⵎⴻⵜⵜⵉⵏⴻⵏ ⵉⵏⵏⵉ ⵜⵓⵖⴰ ⴰⵜⴻⵏ ⴷⴰⵢⵙⴻⵏⵜ, ⵓⵛⴰ ⵉⵜⵜⵡⴰⵃⴽⴻⵎ ⵅⴰⵙⴻⵏ, ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⵏⴻⵛⵜ ⵏ ⵍⴻⵅⴷⴰⵢⴻⵎ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV20_14","096_20_14","REV","20","14","14","ⵍⵎⴻⵡⵜ ⴷ ⵍⴰⵅⴰⵔⵜ ⵎⵎⴻⵏⴹⴰⵔⴻⵏⵜ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⵎⴻⵙⵙⵉ. ⵜⴰ ⴷ ⵍⵎⴻⵡⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV20_15","096_20_15","REV","20","15","15","ⵎⴰⵍⴰ ⵉⵜⵜⵡⴰⴼ ⵃⴻⴷ ⵡⴰⵔ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵜⵓⴷⴰⵔⵜ, ⵉⵎⵎⴻⵏⴹⴰⵔ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵏ ⵜⵎⴻⵙⵙⵉ. ");
INSERT INTO rift_vpl VALUES ("RV21_1","096_21_1","REV","21","1","1","ⵓⵛⴰ ⵥⵔⵉⵖ ⴰⵊⴻⵏⵏⴰ ⵏ ⵊⴷⵉⴷ ⴷ ⵉⵛⵜ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⵏ ⵊⴷⵉⴷ, ⵎⴰⵖⴰⵔ ⴰⵊⴻⵏⵏⴰ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⵜⴻⵎⵎⵓⵔⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵜⵓⵖⴰ ⵄⴷⵓⵏ, ⵍⴻⴱⵃⴰⵔ ⵡⴰⵔ ⵉⵇⵇⵉⵎ ⵄⴰⴷ. ");
INSERT INTO rift_vpl VALUES ("RV21_2","096_21_2","REV","21","2","2","ⵏⴻⵛⵛ ⵥⵔⵉⵖ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓⵔⵛⴰⵍⵉⵎ ⵏ ⵊⴷⵉⴷ, ⵜⴻⵀⵡⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵣⵉ ⵣⵣⴰⵜ ⴰⵔⴻⴱⴱⵉ, ⵜⴻⴳⴳⴰ ⴰⵎ ⵜⴻⵙⵍⵉⵜ ⵉⵣⴻⵀⵀⵊⴻⵏ ⵉ ⵡⴻⵙⵍⵉ. ");
INSERT INTO rift_vpl VALUES ("RV21_3","096_21_3","REV","21","3","3","ⵓⵛⴰ ⵙⵍⵉⵖ ⵉⵛⵜ ⵏ ⵜⵎⵉⵊⵊⴰ ⵜᵉⵜⵜⵍⴰⵖⴰ-ⴷⴷ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ ⵙ ⵊⵊⴻⵀⴷ: “ⵅⵥⴰⵔ, ⴰⵇⵉⴹⵓⵏ ⵏ ⴰⵔⴻⴱⴱⵉ ⴰⵇⴰ-ⵜⵜ ⵊⴰⵔ ⵉⵡⴷⴰⵏ, ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵉⵣⴷⴻⵖ. ⵏⵉⵜⵏⵉ ⴰⴷ ⵉⵍⵉⵏ ⴷ ⵍⴳⴻⵏⵙ ⵏⵏⴻⵙ, ⵓⵛⴰ ⴰⵔⴻⴱⴱⵉ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵢⵉⵍⵉ, ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV21_4","096_21_4","REV","21","4","4","ⴰⴷ ⴰⵙⴻⵏ ⵉⵙⵙⵉⵥⴻⵖ ⴽⵓⵍ ⵉⵎⴻⵟⵟⴰⵏ ⵣⵉ ⵜⵉⵟⵟⴰⵡⵉⵏ ⵏⵙⴻⵏ, ⵓⵛⴰ ⵡⴰⵔ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵍⵎⴻⵡⵜ ⴷ ⵡⴻⵛⴹⴰⵏ ⴷ ⵓⵛⴻⵜⵛⵉ ⴷ ⵍⴻⵃⵔⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("RV21_5","096_21_5","REV","21","5","5","ⵓ ⵅⵎⵉ ⴳⴳⵓⵔⴻⵖ, ⵉⵏⵏⴰ ⴰⵢⵉ ⵡⴻⵏⵏⵉ ⵉⵇⵇⵉⵎⴻⵏ ⵅ ⵍⵄⴰⵔⵛ: “ⵅⵥⴰⵔ, ⴰⴷ ⴳⴳⴻⵖ ⵎⴰⵔⵔⴰ ⴷ ⵊⴷⵉⴷ!” ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⵔⵉ: ⴰⵡⴰⵍⴻⵏ-ⴰ ⴰⵇⴰ ⴷⴰⵢⵙⴻⵏ ⵍⴰⵎⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ.” ");
INSERT INTO rift_vpl VALUES ("RV21_6","096_21_6","REV","21","6","6","ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⵇⴰ ⵉⵜⵜⵡⴰⴽⴻⵎⵎⴻⵍ. ⵏⴻⵛⵛ ⴷ ⴰⵍⵉⴼ ⵓ ⵏⴻⵛⵛ ⴷ ⵜⴰⵡ, ⵏⴻⵛⵛ ⴷ ⴱⴻⴷⴷⵓ ⴷ ⴰⴽⴻⵎⵎⴻⵍ. ⵡⴻⵏⵏⵉ ⵉⴼⴼⵓⴷⴻⵏ ⴰⴷ ⴰⵙ ⵡⵛⴻⵖ ⴰⴷ ⵉⵙⵓ ⴱⴰⵟⴻⵍ ⵣⵉ ⵍⵄⵓⵏⵚⴰⵔ ⵏ ⵡⴰⵎⴰⵏ ⵏ ⵜⵓⴷⴰⵔⵜ. ");
INSERT INTO rift_vpl VALUES ("RV21_7","096_21_7","REV","21","7","7","ⵡⵉ ⵖⴰ ⵉⵖⴻⵍⵍⴱⴻⵏ ⴰⴷ ⵉⵡⴰⵔⵜ ⵎⴰⵏ ⴰⵢⴰ, ⵓⵛⴰ ⵏⴻⵛⵛ ⴰⴷ ⵉⵍⵉⵖ ⴷ ⴰⵔⴻⴱⴱⵉ ⵏⵏⴻⵙ, ⵓ ⵏⴻⵜⵜⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⵎⵎⵉ. ");
INSERT INTO rift_vpl VALUES ("RV21_8","096_21_8","REV","21","8","8","ⵎⴰⵛⴰ ⵉⵏⵏⵉ ⵉⵜⵜⵛⴻⴽⴽⴰⵏ, ⴷ ⵍⴽⵓⴼⴼⴰⵔ, ⴷ ⵉⵄⴻⴼⴼⴰⵏⴻⵏ, ⴷ ⵉⵎⴻⵅⵎⴰⵊ, ⴷ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ, ⴷ ⵢⵉⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵜⴰⵙⴻⵃⵃⴰⵔⵜ, ⴷ ⴰⵢⵜ ⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵢⵉⵏⵏⵉ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵎⴰⵔⵔⴰ ⴰⵢⵜ ⵏ ⴱⵓ-ⵉⵅⴰⵔⵔⵉⵇⴻⵏ, ⴰⴷ ⵜⵉⵍⵉ ⵜⴻⵙⵖⴰⵔⵜ ⵏⵙⴻⵏ ⴷⵉ ⵍⴻⴱⵃⴰⵔ ⵉⵜⵜⵛⴻⴼⵛⵓⴼⴻⵏ ⵙ ⵜⵎⴻⵙⵙⵉ ⴷ ⵍⴻⵛⴱⴰⵔⴻⵢⵢⴻⵜ, ⵜⴰ ⴷ ⵍⵎⴻⵡⵜ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV21_9","096_21_9","REV","21","9","9","ⵓⵛⴰ ⵢⵓⵙⴰ-ⴷⴷ ⵉⵊⵊⴻⵏ ⵣⵉ ⵙⴻⴱⵄⴰ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ, ⵜⵉⵏⵏⵉ ⵖⴰⵔⵙⴻⵏⵜ ⵙⴻⴱⵄⴰ ⵏ ⵟⵟⴰⵡⵢⴰⵜ ⵛⵛⵓⵔⴻⵏⵜ ⵙ ⵙⴻⴱⵄⴰ ⵏ ⵊⵊⵔⴰⵢⴻⵃ ⵜⵉⵏⴻⴳⴳⵓⵔⴰ, ⵉⵙⵙⵉⵡⴻⵍ ⴰⴽⵉⴷⵉ, ⵉⵏⵏⴰ: “ⴰⵙ-ⴷⴷ, ⴰⴷ ⴰⵛ ⵙⵙⴻⵛⵏⴻⵖ ⵜⴰⵙⵍⵉⵜ, ⵜⴰⵎⵖⴰⵔⵜ ⵏ ⵢⴻⵣⵎⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("RV21_10","096_21_10","REV","21","10","10","ⵉⵏⴷⴻⵀ ⴰⵢⵉ ⴷⵉ ⴰⵔⵔⵓⵃ ⵖⴰⵔ ⵉⵊⵊ ⵏ ⵡⴻⴷⵔⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵢⵓⵄⵍⴰⵏ ⴰⵟⵟⴰⵙ ⵓⵛⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵜⴰⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⵓⵔⵛⴰⵍⵉⵎ, ⴰⵎ ⴷⴷ-ⵜⴻⵀⵡⴰ ⵣⴻⴳ ⵓⵊⴻⵏⵏⴰ, ⵣⵉ ⵣⵣⴰⵜ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV21_11","096_21_11","REV","21","11","11","ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵜⵓⵖⴰ ⵖⴰⵔⴻⵙ, ⵓⵛⴰ ⵟⵟⵢⴰ ⵏⵏⴻⵙ ⵜᵉⵜⵜⵉⵙⵙⵉⵇ ⴰⵎ ⵢⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ ⴰⵟⵟⴰⵙ, ⴰⵎ ⵡⴻⵥⵔⵓ ⵏ ⵢⴰⵙⴱⵉⵙ ⵏⵏⵉ ⴷⴷ-ⵉⴹⵀⴰⵔⴻⵏ ⴰⵎ ⵓⴽⵔⵉⵙⵜⴰⵍ. ");
INSERT INTO rift_vpl VALUES ("RV21_12","096_21_12","REV","21","12","12","ⵉⵇⵓⵡⵡⴰⵔ ⴰⵙ ⴷⴷ ⵉⵊⵊ ⵏ ⵡⴻⵖⴱⴰⵔ ⴷ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵢⵓⵄⵍⴰ, ⵖⴰⵔⴻⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵓ ⵜⴻⵏⵄⴰⵛ ⵏ ⵍⵎⴰⵍⴰⴽⴰⵜ ⵜⵓⵖⴰ ⵜⵜⴱⴻⴷⴷⴰⵏⵜ ⵖⴰⵔ ⵜⵉⵡⵡⵓⵔⴰ. ⵓ ⵜⵜⵡⴰⵔⵉⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵅ ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⵉ, ⴰⵇⴰ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵇⴻⴱⴱⴰⵍ ⵏ ⵉⵙⵔⴰⵉⵍ. ");
INSERT INTO rift_vpl VALUES ("RV21_13","096_21_13","REV","21","13","13","ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵖⴰⵔ ⵎⴰⵏⵉⵙ ⴷ ⵜⵏⴻⵇⵇⴰⵔ ⵜⴼⵓⵛⵜ ⵓ ⵖⴰⵔ ⵛⵛⴰⵎⴰⵍ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵓ ⵖⴰⵔ ⵍⵊⴰⵏⵓⴱ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵓ ⴰⵇⴰ ⴷⵉⵏ ⵜⵍⴰⵜⴰ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⵖⴰⵔ ⵎⴰⵏⵉ ⵜⵖⴻⴵⵉ ⵜⴼⵓⵛⵜ. ");
INSERT INTO rift_vpl VALUES ("RV21_14","096_21_14","REV","21","14","14","ⴰⵖⴱⴰⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵉⴱⴻⴷⴷ ⵅ ⵜⴻⵏⵄⴰⵛ ⵏ ⴷⵙⵓⵙⴰ ⵜⵜⵡⴰⵔⵉⵏ ⵅⴰⵙⴻⵏ ⵜⴻⵏⵄⴰⵛ ⵏ ⵉⵙⵎⴰⵡⴻⵏ ⵏ ⵔⵔⵓⵙⵓⵍ ⵏ ⵎⵎⵉⵙ ⵏ ⴰⵔⴻⴱⴱⵉ. ");
INSERT INTO rift_vpl VALUES ("RV21_15","096_21_15","REV","21","15","15","ⵡⴻⵏⵏⵉ ⵜⵓⵖⴰ ⴰⴽⵉⴷⵉ ⵉⵙⵙⴰⵡⴰⵍⴻⵏ, ⵖⴰⵔⴻⵙ ⵉⵊⵊ ⵏ ⵓⵖⴰⵏⵉⵎ ⵏ ⵍⴻⵄⴱⴰⵔ ⵃⵉⵎⴰ ⴰⴷ ⵣⵣⴰⵢⴻⵙ ⵉⵄⴱⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⴷ ⵡⴻⵖⴱⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV21_16","096_21_16","REV","21","16","16","ⵜⴰⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵜⴻⵎⵎⴰⵔⵙ ⴷⵉⵏ ⴰⵎ ⵉⵊⵊ ⵏ ⵓⴽⵡⴰⴷⵔⵓⵏ, ⵜⴰⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴰⵎ ⵜⵉⵔⵓ ⵏⵏⴻⵙ. ⵏⴻⵜⵜⴰ ⵉⵄⴱⴰⵔ ⵜⴰⵏⴷⵉⵏⵜ ⵙ ⵓⵖⴰⵏⵉⵎ ⵏⵏⴻⵙ ⵏ ⵍⴻⵄⴱⴰⵔ: ⵜⴻⵏⵄⴰⵛ-ⴰⵍⴻⴼ ⵏ ‘ⵉⵙⵜⴰⴷⵉⵢⵢⴻⵏ’, ⵄⵍⴰⵃⴰⵍ ⴰⵍⴼⴰⵢⴻⵏ ⵓ ⵎⵉⵜⴰⵢⴻⵏ ⴽⵉⵍⵓⵎⵉⵜⵔ. ⵜⴰⵣⵓⴳⴳⴰⵔⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⵔⵓ ⵏⵏⴻⵙ ⴷ ⵍⵓⵄⵍⴰ ⵏⵏⴻⵙ ⴷ ⵉⵛⵜⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV21_17","096_21_17","REV","21","17","17","ⵉⵄⴱⴰⵔ ⴰⵖⴱⴰⵔ ⵏⵏⴻⵙ: ⵎⵢⴰ ⵓ-ⴰⵔⴻⴱⵄⴰ ⵓ-ⵔⴻⴱⵄⵉⵏ ⵏ ⵉⵖⴰⴵⴻⵏ, ⴰⵇⴰ-ⵜ ⴷ ⵍⵇⴻⴷⴷ ⵏ ⵉⵊⵊ ⵏ ⴱⵏⴰⴷⴻⵎ, ⴰⵇⴰ-ⵜ ⵏ ⵍⵎⴰⵍⴰⴽ. ");
INSERT INTO rift_vpl VALUES ("RV21_18","096_21_18","REV","21","18","18","ⴰⵖⴱⴰⵔ ⵏⵏⴻⵙ ⴳⴳⵉⵏ ⵜ ⵙ ⵢⴰⵙⴱⵉⵙ, ⵓ ⵜⴰⵏⴷⵉⵏⵜ ⴳⴳⵉⵏⵜ ⵙ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⵉⵜⵜⴱⴰⵏ ⴰⵎ ⵣⵣⴰⵊ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV21_19","096_21_19","REV","21","19","19","ⴷⵙⵓⵙⴰ ⵏ ⵡⴻⵖⴱⴰⵔ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ ⵜⵜⵡⴰⵣⴻⵡⵡⵇⴻⵏ ⴽⵓⵍⵛⵉ ⵙ ⵉⵥⵔⴰ ⵉⵖⵍⴰⵏ. ⵜⵓⵖⴰ ⴷⵙⴰⵙ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵢⴰⵙⴱⵉⵙ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵏⴰⵢⴻⵏ ⵏ ⵚⴰⴼⴼⵉⵔ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵍⴰⵜⴰ ⵏ ⵅⴰⵍⵛⵉⴷⵓⵏ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⴰⵔⴻⴱⵄⴰ ⵏ ⵙⵎⵉⵔⴰⵍⴷⴰ, ");
INSERT INTO rift_vpl VALUES ("RV21_20","096_21_20","REV","21","20","20","ⵡⴻⵏⵏⵉ ⴷ ⵡⵉⵙⵙ ⵅⴻⵎⵙⴰ ⵏ ⵙⴰⵔⴷⵓⵏⵉⴽⵙ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵙⴻⵜⵜⴰ ⵏ ⵙⴰⵔⴷⵉⵢⵓⵙ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵙⴻⴱⵄⴰ ⵏ ⵡⴻⵥⵔⵓ ⵏ ⵡⵓⵔⴻⵖ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⵎⴻⵏⵢⴰ ⵏ ⴱⵉⵔⵉⵍ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⴻⵙⵄⴰ ⵏ ⵜⵓⴱⴰⵙ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵄⴻⵛⵔⴰ ⵏ ⴽⵔⵉⵙⵓⴱⵔⴰⵙ, ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵃⵉⵟⴰⵛ ⵏ ⵢⴰⵣⵉⵏⵜ ⵓⵛⴰ ⵡⴻⵏⵏⵉ ⵡⵉⵙⵙ ⵜⴻⵏⵄⴰⵛ ⵏ ⵓⵎⴻⵜⵉⵙⵜ. ");
INSERT INTO rift_vpl VALUES ("RV21_21","096_21_21","REV","21","21","21","ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⴻⵡⵡⵓⵔⴰ ⴷ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵢⴰⵇⵓⵜⵉⵏ, ⵉⵛⵜ ⵉⵛⵜ. ⴽⵓⵍ ⵉⵛⵜⴻⵏ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⵉ ⵜⵓⵖⴰ ⵣⴻⴳ ⵉⵛⵜ ⵏ ⵜⵢⴰⵇⵓⵜ. ⵎⴰⵛⴰ ⴰⴱⵔⵉⴷ ⵢⵉⵔⵉⵡⴻⵏ ⵏ ⵜⴻⵏⴷⵉⵏⵜ ⵜⵓⵖⴰ-ⵜ ⵏ ⵡⵓⵔⴻⵖ ⵉⵚⴼⴰⵏ, ⴰⵎ ⵣⵣⴰⵊ ⵉⵚⴼⴰⵏ. ");
INSERT INTO rift_vpl VALUES ("RV21_22","096_21_22","REV","21","22","22","ⵡⴰⵔ ⵥⵔⵉⵖ ⵛⴰ ⵣⵣⴰⵡⴻⵛⵜ ⴷⴰⵢⴻⵙ ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ, ⴰⵎⵣⴻⵎⵎⴰⵔ ⵅ ⴽⵓⵍⵛⵉ, ⵏⴻⵜⵜⴰ ⵙⵉⵎⴰⵏⵜ ⵏⵏⴻⵙ ⴷ ⵣⵣⴰⵡⴻⵛⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV21_23","096_21_23","REV","21","23","23","ⵉⵣⵎⴰⵔ ⴷ ⵜⴻⵏⴷⵉⵏⵜ ⵡⴰⵔ ⵃⴷⴰⵊⴻⵏ ⵛⴰ ⵜⴰⴼⵓⵛⵜ ⵓⵍⴰ ⴷ ⵜⴰⵣⵉⵔⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴰⵙ ⵙⵙⴰⵔⵖⴻⵏⵜ, ⵎⵉⵏⵣⵉ ⴰⵄⵓⴵⵉ ⵏ ⴰⵔⴻⴱⴱⵉ ⵢⴰⵔⴻⵇⵇ ⴷⴰⵢⴻⵙ ⵓⵛⴰ ⵉⵣⵎⴰⵔ ⴷ ⵍⴻⴼⵏⴰⵔ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV21_24","096_21_24","REV","21","24","24","ⵍⴻⴳⵏⵓⵙ ⴰⴷ ⵓⵢⵓⵔⴻⵏ ⵙ ⵜⴼⴰⵡⵜ ⵏⵏⴻⵙ ⵓⵛⴰ ⵉⵊⴻⴵⵉⴷⴻⵏ ⵏ ⵜⴻⵎⵎⵓⵔⵜ ⴰⴷ ⵖⴰⵔⴻⵙ ⵙⵙⵉⴷⴼⴻⵏ ⴰⵄⵓⴵⵉ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV21_25","096_21_25","REV","21","25","25","ⵜⵉⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ ⵡⴰⵔ ⵜⵜⵡⴰⵇⵇⵏⴻⵏⵜ ⵄⴻⵎⵎⴰⵔⵚ ⵙ ⵓⵣⵉⵍ, ⵎⵉⵏⵣⵉ ⴵⵉⵍⴻⵜ ⵡⴰⵔ ⵜᵉⵜⵜⵖⵉⵎⵉ ⵛⴰ ⴷⵉⵏ. ");
INSERT INTO rift_vpl VALUES ("RV21_26","096_21_26","REV","21","26","26","ⵏⵉⵜⵏⵉ ⴰⴷ ⴰⵡⵢⴻⵏ ⵖⴰⵔⴻⵙ ⴰⵄⵓⴵⵉ ⴷ ⵛⵛⴰⵏ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RV21_27","096_21_27","REV","21","27","27","ⵄⴻⵎⵎⴰⵔⵚ ⴰⴷ ⴷⴰⵢⴻⵙ ⵜⴰⴷⴻⴼ ⵛⴰ ⵏ ⵍⵃⴰⵊⵊⴻⵜ ⵜⴰⵎⴻⵏⴳⵓⵙⵜ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⴳⴳⵉⵏ ⵏⵏⵄⴰⵡⴰⵜ ⵏⵉⵖ ⵡⴻⵏⵏⵉ ⵉⵙⵙⵅⴰⵔⵔⵉⵇⴻⵏ, ⵎⵖⵉⵔ ⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵢⴻⵣⵎⴰⵔ ⵡⴰⵀⴰ. ");
INSERT INTO rift_vpl VALUES ("RV22_1","096_22_1","REV","22","1","1","ⵓⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵙⵙⵛⴻⵏ ⴰⵢⵉ ⵉⵊⵊ ⵏ ⵉⵖⵣⴰⵔ ⵉⵣⴷⵉⴳ ⵏ ⵡⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ, ⴷ ⴰⵎⴻⵣⴷⴰⴳ, ⵉⵚⴼⴰ ⴰⵎ ⵓⴽⵔⵉⵙⵜⴰⵍ, ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⵉ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏ ⵢⴻⵣⵎⴰⵔ. ");
INSERT INTO rift_vpl VALUES ("RV22_2","096_22_2","REV","22","2","2","ⴷⵉ ⵍⵡⴻⵙⵟ ⵏ ⵡⴰⵣⵣⴰⵢ ⵏⵏⴻⵙ, ⵅ ⵜⵎⴰ-ⵢⴰ ⵓ ⵅ ⵜⵎⴰ ⵏⵏⵉ ⵏ ⵉⵖⵣⴰⵔ, ⵜⵓⵖⴰ ⵜⴰⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵜⴻⵏⵏⵉ ⵜⴻⵙⵙⴻⵏⴹⴰⵢ ⵍⵖⵉⴵⴻⵜ ⵜⴻⵏⵄⴰⵛ ⵏ ⵜⵡⴰⵍⴰⵡⵉⵏ. ⴷⵉ ⵎⴽⵓⵍ ⴰⵢⵓⵔ ⵜⴻⵜⵜⵉⵛ ⵍⵖⵉⴵⴻⵜ ⵏⵏⴻⵙ ⴷ ⵜⵉⴼⵔⴰⵢ ⵏⵏⴻⵙ ⵉ ⵓⵙⴳⴻⵏⴼⵓ ⵏ ⵍⴻⴳⵏⵓⵙ. ");
INSERT INTO rift_vpl VALUES ("RV22_3","096_22_3","REV","22","3","3","ⵡⴰⵔ ⴷⴰⵢⴻⵙ ⵜᵉⵜⵜⵉⵍⵉ ⵄⴰⴷ ⵏⵏⴻⵄⵍⴻⵜ. ⴰⴷ ⴷⴰⵢⴻⵙ ⵢⵉⵍⵉ ⵍⵄⴰⵔⵛ ⵏ ⴰⵔⴻⴱⴱⵉ ⵓ ⵏ ⵢⴻⵣⵎⴰⵔ ⵓⵛⴰ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⴰⴷ ⵅⴰⵙ ⵙⴻⵅⵅⴰⵔⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV22_4","096_22_4","REV","22","4","4","ⵏⵉⵜⵏⵉ ⴰⴷ ⵥⴰⵔⴻⵏ ⵓⴷⴻⵎ ⵏⵏⴻⵙ, ⵉⵙⴻⵎ ⵏⵏⴻⵙ ⴰⴷ ⵢⵉⵍⵉ ⵅ ⵜⴻⵏⵢⴰⵔⵉⵏ ⵏⵙⴻⵏ. ");
INSERT INTO rift_vpl VALUES ("RV22_5","096_22_5","REV","22","5","5","ⵡⴰⵔ ⴷⵉⵏ ⵜᵉⵜⵜⵉⵍⵉ ⴵⵉⵍⴻⵜ ⵓⵛⴰ ⵏⵉⵜⵏⵉ ⵡⴰⵔ ⵜⵜⴻⵃⴷⵉⵊⴻⵏ ⵄⴰⴷ ⵟⵟⵢⴰ ⵏ ⵍⴻⴼⵏⴰⵔⴰⵜ ⵏⵉⵖ ⵏ ⵜⴼⴰⵡⵉⵏ ⵏⵉⵖ ⵏ ⵜⴼⴰⵡⵜ ⵏ ⵜⴼⵓⵛⵜ, ⵎⵉⵏⵣⵉ ⵙⵉⴷⵉ ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⴰⵙⴻⵏ ⵉⴳⴳ ⵜⴰⴼⴰⵡⵜ ⵓⵛⴰ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵊⴻⴵⵉⴷ ⵏⵙⴻⵏ ⵉ ⵍⴻⴱⴷⴰ ⵇⴰⵄ. ");
INSERT INTO rift_vpl VALUES ("RV22_6","096_22_6","REV","22","6","6","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⴰⵡⴰⵍⴻⵏ-ⴰ ⴷⴰⵢⵙⴻⵏ ⵍⴰⵎⴰⵏ ⴷ ⵜⵉⴷⴻⵜⵜ! ⵙⵉⴷⵉ, ⴰⵔⴻⴱⴱⵉ ⵏ ⴰⵔⵔⵓⵃ ⵏ ⵉⵏⴰⴱⵉⵢⵢⴻⵏ ⵉⵇⴻⴷⴷⵙⴻⵏ, ⴰⵇⴰ ⵉⵙⵙⴻⴽⴽ ⵍⵎⴰⵍⴰⴽ ⵏⵏⴻⵙ, ⵃⵉⵎⴰ ⴰⴷ ⵉⵙⵙⵛⴻⵏ ⵉ ⵉⵎⵙⴻⵅⵅⴰⵔⴻⵏ ⵏⵏⴻⵙ ⵎⵉⵏ ⵉ ⵖⴰ ⵢⵉⵍⵉⵏ ⴷⴻⵖⵢⴰ.” ");
INSERT INTO rift_vpl VALUES ("RV22_7","096_22_7","REV","22","7","7","“ⵅⵣⴰⵔ ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ! ⵙⵙⴻⵄⴷ ⵏ ⵡⴻⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵏⵏⵓⴱⵓⵡⴰⵜ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV22_8","096_22_8","REV","22","8","8","ⵏⴻⵛⵛ, ⵢⵓⵃⴰⵏⵏⴰ, ⴰⵇⴰ ⵥⵔⵉⵖ ⵓ ⵙⵍⵉⵖ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ. ⵓⵛⴰ ⵍⴰⵎⵉ ⵜⴻⵏⵜ ⵥⵔⵉⵖ ⵓ ⵙⵍⵉⵖ, ⵡⴹⵉⵖ ⵖⴰⵔ ⵉⴹⴰⵔⴻⵏ ⵏ ⵍⵎⴰⵍⴰⴽ ⵡⴻⵏⵏⵉ ⴷ ⴰⵢⵉ ⵉⵙⵙⴻⵛⵏⴻⵏ ⵜⵉⵎⴻⵙⵍⴰⵢⵉⵏ-ⴰ, ⵃⵉⵎⴰ ⴰⴷ ⴰⵙ ⵄⴻⴱⴷⴻⵖ. ");
INSERT INTO rift_vpl VALUES ("RV22_9","096_22_9","REV","22","9","9","ⵎⴰⵛⴰ ⵏⴻⵜⵜⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵃⴹⴰ, ⵍⵍⴰ, ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⵎⴰⵏ ⴰⵢⴰ, ⵎⴰⵖⴰⵔ ⵏⴻⵛⵛ ⴷ ⴰⵎⵙⴻⵅⵅⴰⵔ ⴰⵎⵄⴰⵛⴰⵔ ⵏⵏⴻⵛ, ⵓ ⵏ ⴰⵢⵜⵎⴰⵛ, ⵉⵏⴰⴱⵉⵢⵢⴻⵏ, ⵓⵍⴰ ⵏ ⵢⵉⵏⵏⵉ ⵉⵜⵜᵉⵟⵟⴼⴻⵏ ⴷⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ. ⵄⴻⴱⴷⴻⵜ ⴰⵔⴻⴱⴱⵉ!” ");
INSERT INTO rift_vpl VALUES ("RV22_10","096_22_10","REV","22","10","10","ⵅⴰⵙ ⵓⵛⴰ ⵉⵏⵏⴰ ⴰⵢⵉ: “ⵡⴰⵔ ⵜⵜⴻⴳⴳ ⴰⵛⴻⵎⵎⵉⵄ ⵅ ⵡⴰⵡⴰⵍⴻⵏ ⵉ ⵉⵜⵜⵡⴰⵏⴰⴱⴱⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ, ⵎⵉⵏⵣⵉ ⵍⵡⴻⵇⵜ ⴰⵇⴰ ⵜⵉⵡⴻⴹ-ⴷⴷ.” ");
INSERT INTO rift_vpl VALUES ("RV22_11","096_22_11","REV","22","11","11","“ⵡⴻⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ, ⴰⴷ ⵉⴳⴳ ⵎⵉⵏ ⵡⴰⵔ ⵉⵙⴻⴳⴳⴷⴻⵏ ⴽⵜⴰⵔ, ⴰⵎⴻⵏⴳⵓⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⴻⵏⴳⵓⵙ ⴽⵜⴰⵔ, ⴰⵎⵙⴻⴳⴳⴰⴷ ⴰⴷ ⵉⴳⴳ ⵜⴰⵙⴻⴳⴷⴰ ⴽⵜⴰⵔ ⵓⵛⴰ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴰⴷ ⵉⴷⵡⴻⵍ ⴷ ⴰⵎⵇⴻⴷⴷⴰⵙ ⴽⵜⴰⵔ.” ");
INSERT INTO rift_vpl VALUES ("RV22_12","096_22_12","REV","22","12","12","“ⵅⵣⴰⵔ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ ⵓⵛⴰ ⵍⵎⵓⵏⴻⵜ ⵉⵏⵓ ⴰⵇⴰ-ⵜⵜ ⴰⴽⵉⴷⵉ, ⵃⵉⵎⴰ ⴰⴷ ⵅⴻⴵⵚⴻⵖ ⴽⵓⵍ ⵉⵊⵊⴻⵏ ⴰⵏⴻⵛⵜ ⵏ ⵍⵅⴻⴷⵎⴻⵜ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV22_13","096_22_13","REV","22","13","13","ⵏⴻⵛⵛ ⴷ ⴰⵍⵉⴼ ⵓ ⵏⴻⵛⵛ ⴷ ⵜⴰⵡ, ⴷ ⴰⵎⴻⵣⵡⴰⵔⵓ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ, ⴷ ⴱⴻⴷⴷⵓ ⴷ ⴰⴽⴻⵎⵎⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("RV22_14","096_22_14","REV","22","14","14","“ⵙⵙⴻⵄⴷ ⵏⵙⴻⵏ ⵉ ⵢⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵜⵉⵡⴻⵚⵚⴰ ⵏⵏⴻⵙ. ⴰⴷ ⵖⴰⵔⵙⴻⵏ ⵜⵉⵍⵉ ⵚⵚⵓⵍⵟⴰ ⵅ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵓⵛⴰ ⴰⴷ ⴷⴷ-ⴰⴷⴼⴻⵏ ⵖⴰⵔ ⵜⴻⵏⴷⵉⵏⵜ ⵣⵉ ⵜⴻⵡⵡⵓⵔⴰ ⵏⵏⴻⵙ. ");
INSERT INTO rift_vpl VALUES ("RV22_15","096_22_15","REV","22","15","15","ⴱⴰⵔⵔⴰ ⵉⴵⴰⵏ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⴼⴰⵔⵇ-ⵛⵛⵖⴻⵍ ⴷ ⵢⵉⵏⵏⵉ ⵉⵏⴻⵇⵇⴻⵏ ⴷ ⵢⵉⵏⵏⵉ ⵉⵄⴻⴱⴱⴷⴻⵏ ⵍ’ⴰⵚⵏⴰⵎ ⴷ ⵢⵉⵏⵏⵉ ⴷⴰⵢⵙⴻⵏ ⵍⴻⵅⵎⴻⵊ ⴷ ⵢⵉⵏⵏⵉ ⵉⵜⵜⵙⴻⵃⵃⴰⵔⴻⵏ ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵡⴰⵍⴰⵡⴻⵏ ⴷ ⵉⵏⵏⵉ ⵉⵜⵜⴻⴳⴳⴻⵏ ⵎⵉⵏ ⵉ ⴷⴷ-ⵉⵜⵜⴻⴼⴼⵖⴻⵏ ⵣⴻⴳ ⵓⵅⴰⵔⵔⵉⵇ.” ");
INSERT INTO rift_vpl VALUES ("RV22_16","096_22_16","REV","22","16","16","“ⵏⴻⵛⵛ, ⵢⴰⵙⵓⵄ, ⴰⵇⴰ ⵙⵙⴻⴽⴽⴻⵖ ⵍⵎⴰⵍⴰⴽ ⵉⵏⵓ ⵎⴰⵃⴻⵏⴷ ⴰⴷ ⵅⴰⵡⴻⵎ ⵉⵛⵀⴻⴷ ⵎⴰⵏ ⴰⵢⴰ ⵣⵣⴰⵜ ⵉ ⵜⵎⴻⵙⵎⵓⵏⵉⵏ. ⴰⵇⴰ ⴷ ⵏⴻⵛⵛ, ⴷ ⴰⵥⵡⴰⵔ ⴷ ⵣⵣⴰⵔⵉⵄⴻⵜ ⵏ ⴷⴰⵡⵓⴷ, ⴷ ⵡⴻⵏⵏⵉ ⴰⴽⵉⴷⴻⵙ, ⴷ ⵉⵜⵔⵉ ⵏ ⵍⴻⴼⵊⴰⵔ ⵢⴰⵔⴻⵇⵇⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV22_17","096_22_17","REV","22","17","17","ⴰⵔⵔⵓⵃ ⴷ ⵜⴻⵙⵍⵉⵜ ⵇⵇⴰⵔⴻⵏ: “ⴰⵙ-ⴷⴷ!” ⵓⵛⴰ ⴻⵊⵊ ⵡⴻⵏⵏⵉ ⵜ ⵉⵙⵍⵉⵏ, ⴰⴷ ⵢⵉⵏⵉ: “ⴰⵙ-ⴷⴷ!” “ⴷ ⵡⴻⵏⵏⵉ ⵉⴼⵓⴷⴻⵏ, ⴻⵊⵊ ⵉ-ⵜ ⴰⴷ ⴷⴷ-ⵢⴰⵙ, ⴰⴷ ⵉⵙⵓ ⴰⵎⴰⵏ ⵉⴷⴷⴰⵔⴻⵏ ⴱⴰⵟⴻⵍ.” ");
INSERT INTO rift_vpl VALUES ("RV22_18","096_22_18","REV","22","18","18","“ⵏⴻⵛⵛ ⵛⴻⵀⵀⴷⴻⵖ ⵉ ⵎⴰⵔⵔⴰ ⵉⵏⵏⵉ ⵉⵜⵜⴻⵙⵍⴰⵏ ⵉ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵏⵏⵓⴱⵓⵡⴰ ⵏ ⵡⴻⴷⵍⵉⵙ-ⴰ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ: ⵎⴰⵍⴰ ⴷⵉⵏ ⵃⴻⴷ ⵡⴻⵏⵏⵉ ⵅⴰⵙⴻⵏ ⵉ ⵖⴰ ⵢⴰⵔⵏⵉⵏ, ⴰⵔⴻⴱⴱⵉ ⴰⴷ ⵅⴰⵙ ⵢⴰⵔⵏⵉ ⵊⵊⵔⴰⵢⴻⵃ, ⵜⵉⵏⵏⵉ ⵉⵜⵜⵡⴰⵣⴻⵎⵎⴻⵎⴻⵏ ⴷⴻⴳ ⵡⴻⴷⵍⵉⵙ-ⴰ. ");
INSERT INTO rift_vpl VALUES ("RV22_19","096_22_19","REV","22","19","19","ⵎⴰⵍⴰ ⵛⴰ ⵏ ⵉⵊⵊⴻⵏ ⵉⴽⴽⴻⵙ ⵣⴻⴳ ⵡⴰⵡⴰⵍⴻⵏ ⵏ ⵡⴻⴷⵍⵉⵙ ⵉⵜⵜⵡⴰⵏⴹⴻⵏ ⵏ ⵏⵏⵓⴱⵓⵡⴰ-ⵢⴰ, ⴰⴷ ⴰⵙ ⵉⴽⴽⴻⵙ ⴰⵔⴻⴱⴱⵉ ⵜⴰⵙⵖⴰⵔⵜ ⵏⵏⴻⵙ ⵣⵉ ⵜⵛⴻⵊⵊⴰⵔⵜ ⵏ ⵜⵓⴷⴰⵔⵜ ⵓ ⵣⵉ ⵜⴻⵏⴷⵉⵏⵜ ⵉⵇⴻⴷⴷⵙⴻⵏ.” ");
INSERT INTO rift_vpl VALUES ("RV22_20","096_22_20","REV","22","20","20","ⵅⵎⵉ ⵏⴻⵜⵜⴰ ⵉⵛⵀⴻⴷ ⵅ ⵎⴰⵏ ⴰⵢⴰ, ⵉⵏⵏⴰ: “ⵡⴰⵀ, ⵏⴻⵛⵛ ⴰⴷ ⴷⴷ-ⴰⵙⴻⵖ ⴷⴻⵖⵢⴰ!” “ⴰⵙ-ⴷⴷ, ⴰ ⵙⵉⴷⵉ ⵢⴰⵙⵓⵄ!” ");
INSERT INTO rift_vpl VALUES ("RV22_21","096_22_21","REV","22","21","21","ⴰⵔⴹⴰ ⵏ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴰⵇⴰ-ⵜ ⴰⴽ-ⴷ ⵎⴰⵔⵔⴰ ⵉⵎⵇⴻⴷⴷⴰⵙⴻⵏ ⵏⵏⴻⵙ. “ⴰⵎⵉⵏ!” ⴰⵏⴻⴳⴳⴰⵔ ⵏ ⵍⵄⴰⵀⴷ ⵏ ⵊⴷⵉⴷ. ⴰⵄⵓⴵⵉ ⵉ ⵢⵉⵙⴻⵎ ⵏ ⴰⵔⴻⴱⴱⵉ, ⴱⴰⴱⴰⵜⵏⴻⵖ ⴷ ⵙⵉⴷⵉⵜⵏⴻⵖ ⵢⴰⵙⵓⵄ ⵍⵎⴰⵙⵉⵃ ⴷ ⴰⵔⵔⵓⵃ ⵉⵇⴻⴷⴷⵙⴻⵏ. ");
ALTER TABLE rift_vpl ADD FULLTEXT(verseText);
UNLOCK TABLES;
