# verses

text:
ᎾᏍᎩᏃ ᏂᎦᏛ ᏄᎾᏓᏁᏟᏴᏒ ᎡᏆᎭᎻ ᏤᎮ ᎾᎯᏳ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏕᏫᏃ ᏤᎮ ᏅᏛᏍᏘ ᏂᎦᏚ ᏄᎾᏓᏁᏟᏴᏎᎢ; ᏕᏫᏃ ᏤᎮ ᎾᎯᏳ ᏅᎵᎬᏩᏓᎴᏅᏛ ᏓᏗᎶᏂᏃ ᏥᏫᏗᎨᎦᏘᏅᏍᏔᏁ ᎾᎯᏳ ᏅᏛᏍᏘ ᏂᎦᏚ ᏄᎾᏓᏁᏟᏴᏎᎢ; ᏓᏗᎶᏂᏃ ᎾᎯᏳ ᏥᏫᏗᎨᎦᏘᏅᏍᏔᏁ ᎤᏓᏳᏓᎴᏅᏛ ᏥᏌᏃ ᏧᏕᏁ ᎾᎯᏳ ᏅᏛᏍᏘ ᏂᎦᏚ ᏄᎾᏓᏁᏟᏴᏎᎢ.


text:
ᎠᏎᏃ ᎠᏏᏉ ᎯᎠ ᎾᏍᎩ ᏄᏍᏕᎠᏓᏅᏖᏍᎨᎢ, ᎬᏂᏳᏉ ᏗᎧᎿᏩᏗᏙᎯ ᏱᎰᏩ ᎤᏅᏏᏛ ᎬᏂᎨᏒ ᏄᏛᏁᎴ ᎠᏍᎩᏓᏍᎬᎢ, ᎯᎠ ᏂᎦᏪᏍᎨᎢ; ᏦᏩ, ᏕᏫ ᎤᏪᏥ, ᏞᏍᏗ ᏣᏍᎦᎸ ᎯᏯᏅᏗᏱ ᎺᎵ ᏣᏓᏴᏍᏗ, ᎾᏍᎩᏰᏃ Ꮎ ᏥᎦᏁᎵ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎤᏓᏅᏖᎸᎯ;


text:
ᎤᎾᏛᎦᏃᏁᎸᏃ ᎤᎬᏫᏳᎯ ᎤᎾᏂᎩᏎᎢ, ᎬᏂᏳᏉᏃ ᏃᏈᏏ, ᎾᏍᎩ ᎤᏂᎪᎲᎯ ᏗᎧᎸᎬ ᎢᏗᏢ, ᎢᎬᏱ ᎤᏁᏅᎡᎴᎢ, ᎬᏂ ᏭᎷᏥᎸ ᎠᎴ ᎤᎴᏫᏍᏔᏅ ᎦᎸᎳᏗᏢ ᎾᎿ ᎠᏥᎵ ᎡᎲᎢ.


text:
ᎠᏓᏁᎸᏃ ᎤᏂᏴᎸ ᎤᏂᎪᎮ ᎠᏲᏝ ᎠᎴ ᎤᏥ ᎺᎵ, ᎠᎴ ᎡᎳᏗ ᏚᎾᏓᏅᏁᎢ, ᎤᎾᏓᏙᎵᏍᏓᏁᎴᎢ, ᎠᎴ ᏧᎬᏩᎶᏗ ᎤᏂᎳᏅᏛ ᏚᏂᏍᏚᎢᏒ ᎤᏂᏁᎸᏁ ᏅᎾᎵᏍᎪᎸᏔᏅᎯ, ᎠᏕᎸ-ᏓᎶᏂᏛ, ᎠᎴ ᎤᎦᎾᏍᏛ ᎦᏩᏒᎩ ᎠᏜ, ᎠᎴ ᎻᎳ.


text:
ᎤᎾᏂᎩᏒᏃ ᎬᏂᏳᏉ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏅᏏᏛ ᏱᎰᏩ ᎬᏂᎨᏒ ᏄᏛᏁᎴ ᏦᏩ ᎠᏍᎩᏓᏍᎬᎢ, ᎯᎠ ᏄᏪᏎᎴᎢ; ᏔᎴᎲᎦ, ᎠᎴ ᏔᏘᏄᎦ ᎠᏲᎵ ᎠᎴ ᎤᏥ ᎠᎴ ᎭᎵᏘ, ᎢᏥᏈ ᏫᎶᎯ, ᎾᎿᏃ ᏪᎮᏍᏗ ᎬᏂ ᏫᎬᏁᏤᎸᎭ, ᎡᎶᏛᏰᏃ ᎠᏎ ᏛᏲᎵ ᎤᏍᏗ ᎠᏲᎵ ᎤᎯᏍᏗᏱ.


text:
ᎿᏉᏃ ᎡᎶᏛ ᎤᏙᎴᎰᏒ ᎠᏂᎦᏔᎿᎢ ᎬᏩᎵᏓᏍᏔᏅᎢ, ᎤᏣᏔᏅᎯ ᎤᏔᎳᏬᏎᎢ, ᎠᎴ ᎤᏓᏅᏎ ᏫᏚᏂᎰᏁ ᏂᎦᏛ ᏗᏂᏲᎵ ᎦᏚᏱ ᎠᏁᎯ, ᎠᎴ ᏂᎦᏛ ᏂᎬᎾᏛ ᎾᎿᏂ, ᏔᎵ ᎢᏳᎾᏕᏘᏴᏛ ᏩᏍᏘ, ᎾᎯᏳ ᏅᏓᏳᏓᎴᏅᏛ ᏥᏓᎵᏏᎾᎯᏍᏓᏁᎮ ᏥᏓᏛᏛᎮᎸᎥᏍᎨ ᎠᏂᎦᏔᎿᎢ.


text:
ᎴᎹᏱ ᎧᏁᎬ ᎤᎾᏛᎦᏅᎩ, ᏓᏂᏴᎬᎢ, ᎠᎴ ᏓᎾᏠᏱᎲᎢ, ᎠᎴ ᎤᏣᏘ ᎤᏁᎷᎬᎢ; ᎴᏥᎵ ᏓᏍᎪᏂᎲ ᏧᏪᏥ, ᎠᎴ ᏄᏚᎵᏍᎬᎾ ᎨᏒ ᎤᏄᏬᎯᏍᏗᏱ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎾᏁᎲᎾᏉ ᎨᏒᎢ.


text:
ᎠᏎᏃ ᎤᏛᎦᏅ ᎠᏥᎳ ᎤᎬᏫᏳᎯ ᎨᏒ ᏧᏗᏱ ᎤᏙᏓ ᎡᎶᏛ ᎤᏓᏁᏟᏴᏍᏓᏁᎸᎢ, ᎤᏍᎦᎴ ᎾᎿ ᏭᎶᎯᏍᏗᏱ; ᎠᏎᏃ ᎤᏁᎳᏅᎯ ᎤᏪᏯᏔᏅᎯ ᎨᏒ ᎠᏍᎩᏓᏍᎬᎢ, ᎨᎵᎵ ᏭᎪᎸᏍᏔᏁᎢ;


text:
ᎠᏴ ᎤᏙᎯᏳᎯ ᎠᎹ ᏕᏨᏯᏬᏍᏗᎭ ᏗᏥᏁᏟᏴᏍᏗᏱ ᏕᏣᏓᏅᏛ ᎤᎬᏩᎵ; ᎠᏎᏃ ᎾᏍᎩ Ꮎ ᎣᏂ ᏨᏓᏯᎢ ᎤᏟᎯᏳ ᎤᎵᏂᎩᏗᏳ ᎡᏍᎦᏉ ᎠᏴ, ᏧᎳᏑᎶ ᎥᏝ ᏰᎵ ᏱᏂᎪᎢ ᏗᎩᏂᏓᏍᏗᏱ; ᎾᏍᎩᏍᎩᏂ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎠᎴ ᎠᏥᎸ ᏙᏓᏣᏬᏍᏔᏂ.


text:
ᏥᏌᏃ ᎠᎦᏬᎥ, ᎩᎳᏉ ᎢᏴᏛ ᎤᎿᎷᏎᎢ, ᎠᎹᏱ ᎤᏓᏅᏎᎢ, ᎠᎴ ᎬᏂᏳᏉ ᎦᎸᎳᏗ ᏣᏥᏍᏚᎩᎡᎴᎢ, ᎠᎴ ᏭᎪᎮ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏙ ᎡᎳᏗ ᏅᏧᏛᎿᏗᏎ ᎫᎴ-ᏗᏍᎪᏂᎯ ᏗᏤᎵᏛ; ᎠᎴ ᎤᏪᏯᎸᏤᎢ.


text:
ᎯᎠᏃ ᏄᏪᏎᎴᎢ; ᎢᏳᏃ ᏂᎯ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎨᏎᏍᏗ, ᎭᏓᎶᎥᏓ ᏨᏒ; ᎯᎠᏰᏃ ᏂᎬᏅ ᎢᎪᏪᎳ; ᎠᏎ ᏙᏓᎧᏁᏤᎵ ᎫᏤᎵ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏂᏌ ᎨᏒ ᎤᎬᏩᎵ, ᎠᎴ ᏧᏃᏰᏂ ᎨᏣᏌᎳᏙᏕᏍᏗ ᎾᏍᎩ ᎢᎸᎯᏳ ᏅᏲᎯ ᏣᎾᏍᏆᎶᏍᏙᏗᏱ ᏂᎨᏒᎾ.


text:
ᏥᏌᏃ ᏂᎬᎾᏛ ᎨᎵᎵ ᎡᏙᎮᎢ ᏓᏕᏲᎲᏍᎨ ᏧᏂᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᎠᎵᏥᏙᎲᏍᎨ ᎣᏍᏛ ᎧᏃᎮᏛ, ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎧᏃᎮᏍᎨᎢ, ᎠᎴ ᏕᎧᏅᏫᏍᎨ ᏧᎵᎴᏅᏛ ᏚᏂᏢᎬᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᎥᏳᎩ ᏴᏫ ᎤᏁᎲᎢ.


text:
ᏕᎦᏃᏣᎸᏃ ᏂᎬᎾᏛ ᏏᎵᏱ ᎤᏰᎵᏎᎢ; ᏕᎬᏩᏘᏃᎮᎴᏃ ᏂᎦᏛ ᏧᏂᏢᎩ, ᏧᏓᎴᏅᏛ ᎥᏳᎩ ᎠᎴ ᎡᎯᏍᏗ ᎤᏂᏱᎵᏙᎯ, ᎠᎴ ᎾᏍᏉ ᎠᏂᏍᎩᎾ ᏗᎬᏩᏂᏯᎢ, ᎠᎴ ᎾᏍᏉ ᏧᏂᎸᏃᏘᏍᎩ, ᎠᎴ ᎾᏍᏉ ᏧᏂᎾᏫᏍᎩ; ᏚᏅᏩᏁᏃ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎩᎶ ᎠᏲᏍᏗᏍᎨᏍᏗ ᏌᏉ ᎯᎠ ᎤᏍᏗᎧᏂ ᎤᎵᏁᏨᎢ, ᎠᎴ ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᏴᏫ ᏕᎨᏲᎲᏍᎨᏍᏗ, ᎾᏍᎩ ᎤᏍᏗᎧᏂ ᎠᎪᏎᎮᏍᏗ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒᎢ; ᎩᎶᏍᎩᏂ ᏓᎧᎿᏩᏕᎨᏍᏗ, ᎠᎴ ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᏓᏕᏲᎲᏍᎨᏍᏗ, ᎦᎸᏉᏗᏳ ᎠᎪᏎᎮᏍᏗ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒᎢ.


text:
ᎠᏎᏃ ᎠᏴ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎩᎶ ᏗᎾᏓᏅᏟ ᎠᏍᎦᎨᏍᏗ ᎪᎱᏍᏗ ᏄᏍᏛᏗᏍᎬᎾ ᎢᎨᏎᏍᏗ, ᎬᏩᏍᏛᏗᏍᏗ ᎨᏎᏍᏗ ᏗᏄᎪᏗᏍᎩᏱ; ᎩᎶᏃ ᏗᎾᏓᏅᏟ ᏂᏣᏓᏅᏛᎾ ᎢᎪᏎᎮᏍᏗ, ᏕᎦᎳᏫᎥ ᎬᏩᏍᏛᏗᏍᏗ ᎨᏎᏍᏗ; ᎩᎶᏃ ᏣᏁᎫ ᎢᎪᏎᎮᏍᏗ, ᎬᏩᏍᏛᏗᏍᏗ ᎨᏎᏍᏗ ᏨᏍᎩᏃ ᎠᏥᎸᏱ.


text:
ᎢᏳᏃ ᎯᎦᏙᎵ ᎯᎦᏘᏏ ᏕᏦᏕᏍᏗᏍᎨᏍᏗ, ᎭᏓᎦᏖᏙᎢᏍᎨᏍᏗ, ᎠᎴ ᏣᏕᎨᏍᏗ; ᎣᏏᏳᏰᏃ ᎢᏣᎵᏍᏓᏁᏗ ᏌᏉᏉ ᏣᎵᎬᎭᎸᏛ ᏱᏣᏲᎱᏎᎭ, ᎠᏃ ᎤᏃᏍᏛ ᎯᏰᎸ ᏨᏍᎩᏃ ᏫᏰᏣᏓᎢᏁᎭ.


text:
ᎢᏳᏃ ᏦᏰᏂ ᎯᎦᏘᏏ ᏕᏦᏕᏍᏗᏍᎨᏍᏗ, ᎯᏍᏆᎵᏍᎨᏍᏗ, ᎠᎴ ᏣᏕᎨᏍᏗ; ᎣᏏᏳᏰᏃ ᎢᏣᎵᏍᏓᏁᏗ ᏌᏉᏉ ᏣᎵᎬᎭᎸᏛ ᏱᏣᏲᎱᏎᎭ, ᎠᏃ ᎤᏃᏍᏛ ᎯᏰᎸ ᏨᏍᎩᏃ ᏫᏰᏣᏓᎢᏁᎭ.


text:
ᎠᏎᏃ ᎠᏴ ᎯᎠ ᏂᏨᏪᏎᎭ; ᏕᏥᎨᏳᏎᏍᏗ ᎨᏥᏍᎦᎩ; ᎣᏍᏛ ᏕᏥᏁᏤᎮᏍᏗ ᎨᏥᏍᎩᏅᏗᏍᎩ, ᎣᏍᏛ ᏂᏕᏣᏛᏁᎮᏍᏗ ᎨᏥᏂᏆᏘᎯ, ᎠᎴ ᎣᏍᏛ ᎢᏳᎾᎵᏍᏓᏁᏗᏱ ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ ᎦᏰᎪᎩ ᎨᏥᏃᎮᏍᎩ ᎠᎴ ᎤᏲ ᎢᎨᏨᏁᎯ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᎭᏓᏁᎮᏍᏗ ᏞᏍᏗ ᎠᏤᎷᎩ ᎢᎬᏱ ᏫᏱᏃᏴᎵᏍᏗᏍᎨᏍᏗ ᎾᏍᎩ ᏥᎾᎾᏛᏁᎰ ᎤᎾᏠᎾᏍᏗ ᏧᎳᏫᎢᏍᏗᏱ ᎠᎴ ᎡᎾᎢᏓᏍᏗᏱ ᏕᎦᎳᏅᏛᎢ, ᏴᏫᏉ ᎬᏩᏂᎸᏉᏙᏗᏱ ᏧᏂᏰᎸᏐᎢ; ᎤᏙᎯᏳᎯᏯ ᎢᏨᏲᏎᎭ, ᎨᎦᎫᏴᎡᎸ.


text:
ᎢᏳ ᎠᎴ ᎭᏓᏙᎵᏍᏗᏍᎨᏍᏗ, ᎠᎭ ᏞᏍᏗ ᏄᎾᏍᏛ ᎤᎾᏠᎾᏍᏗ ᏱᏂᏣᏍᏕᏍᏗ; ᎾᏍᎩᏰᏃ ᎣᏐ ᎤᏂᏰᎸᏐ ᎤᎾᏓᏙᎵᏍᏙᏗᏱ ᎤᎾᎴᏗᏱ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᎴ ᏚᏅᏏᏯᏅ ᏕᎦᎳᏅᏛ ᎡᎾᎢᏓᏍᏗᏱ, ᏴᏫᏉ ᎬᏩᏂᎪᏩᏛᏗᏱ ᎤᎾᏚᎵᏍᎪᎢ. ᎤᏙᎯᏳᎯᏯ ᎢᏨᏲᏎᎭ, ᎨᎦᎫᏴᎡᎸ.


text:
ᏂᎯᏍᎩᏂ ᎢᏳᏃ ᏔᏓᏙᎵᏍᏔᏂᏎᏍᏗ ᏫᏴᎯᎮᏍᏗ ᎧᏅᏑᎸᎢ, ᎿᏉᏃ ᏣᏍᏚᏁᏍᏗ ᎦᎶᎯᏍᏗᏱ, ᎯᏯᏓᏙᎵᏍᏓᏁᎮᏍᏗ ᏣᏙᏓ ᎤᏕᎵᏒ ᎡᎯ, ᏣᏙᎵᏃ ᎤᏕᎵᏒ ᎠᎪᏩᏘᏍᎩ ᎠᏎ ᏣᎫᏴᎡᏗ ᎨᏎᏍᏗ ᎬᏂᎨᏒᎢ.


text:
ᎠᎴ ᏞᏍᏗ ᎤᏓᎪᎵᏰᏗᏱ ᎨᏒ ᏫᏗᏍᎩᏯᏘᏅᏍᏔᏅᎩ, ᏍᎩᏳᏓᎴᏍᎨᏍᏗᏉᏍᎩᏂ ᎤᏥ ᎨᏒᎢ. ᏣᏤᎵᎦᏰᏃ ᏣᎬᏫᏳᎯ ᎨᏒᎢ, ᎠᎴ ᏣᎵᏂᎩᏗᏱ ᎨᏒᎢ, ᎠᎴ ᎡᏣᎸᏉᏗᏳ ᎨᏒ ᏂᎪᎯᎸᎢ. ᎡᎺᏅ.


text:
ᎠᎴ ᎾᏍᏉ ᎠᎹᏟ ᎢᏨᏍᎨᏍᏗ, ᏞᏍᏗ ᏅᎾᏠᎾᏍᏗ ᏄᎾᏍᏛ ᏱᏂᏣᏍᏕᏍᏗ, ᎤᎾᏓᏙᎵᏍᏗ ᏥᎨᏐ ᏗᎧᏃᏗᏱ, ᏂᏓᏤᎸᎾᏰᏃ ᏂᏓᏅᏁᎰ ᏚᎾᎧᏛᎢ, ᏴᏫᏉ ᎤᎾᏙᎴᎰᎯᏍᏗᏱ ᎤᎾᏚᎵᏍᎪ ᎠᎹᏟ ᎠᏅᏍᎬᎢ. ᎤᏙᎯᏳᎯᏯ ᏂᏨᏪᏎᎭ ᎨᎦᎫᏴᎡᎸ.


text:
ᎥᏝ ᎩᎶ ᏰᎵ ᎠᏂᏔᎵ ᎬᏩᎾᏝᎢ ᎪᎱᏍᏗ ᏱᏙᎬᏛᏂᏏ, ᏱᎠᏍᎦᎦᏰᏃ ᏌᏉ ᏱᏅᎨᏳᎭᏃ ᏐᎢ, ᎠᎴ ᏱᏙᎤᏂᏴᎭ ᏌᏉ ᏱᎦᏂᏆᏘᎭᏃ ᏐᎢ. ᏝᏍᎩᏂ ᏰᎵ ᎤᏁᎳᏅᎯ ᎠᎴ ᎹᎹᏂ ᎪᎱᏍᏗᏱᏙᎨᏣᏛᏂᏏ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᎠ ᏂᏨᏪᏎᎭ, ᏞᏍᏗ ᏱᏤᎵᎯᏍᎨᏍᏗ ᏕᏨᏅᎢ, ᎢᏳᏍᏗ ᎢᏥᎩᏍᏗᏱ ᎠᎴ ᎢᏳᏍᏗ ᎢᏣᏗᏔᏍᏗᏱ, ᏞᏍᏗ ᎠᎴ ᏗᏥᏰᎸᎢ ᏱᏤᎵᎯᏍᎨᏍᏗ ᎢᏳᏍᏗ ᏗᏣᏄᏬᏍᏗᏱ. ᏝᏍᎪ ᎠᎬᏅ ᎤᏟᎯᏳ ᏱᎩ ᎡᏍᎦᏉ ᎠᎵᏍᏓᏴᏗ? ᎠᎴ ᏝᏍᎪ ᎠᏰᎸᎢ ᎡᏍᎦᏉ ᏗᏄᏬ?


text:
ᏗᏣᎧᏅᎦ ᏥᏍᏆ ᎦᎸᎶᎢ ᎠᏁᎯ, ᏝᏰᏃ ᏯᏂᏫᏍᎪᎢ, ᎠᎴ Ꮭ ᏯᏂᏁᏣᎢᏍᎪᎢ, Ꮭ ᎠᎴ ᏓᏓᏁᎸ ᏯᏂᏟᏏᏍᎪᎢ, ᎠᏎᏃ ᎢᏥᏙᏓ ᎦᎸᎳᏗ ᎡᎯ ᏙᎨᎶᎰᎢ. ᏝᏍᎪ ᏂᎯ ᎤᏟ ᏱᏁᏥᎸᏉᏗ ᎡᏍᎦᏉ ᎾᏍᎩ?


text:
ᎢᏳᏰᏃ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᏱᏂᎬᏁᎭ ᏱᎦᏄᏬᎭ ᎧᏁᏍᎦ ᏠᎨᏏ ᎡᎯ, ᎪᎯ ᎢᎦ ᏤᎭ, ᎤᎩᏨᏅᏃ ᏗᎦᏚᏗᏱ ᏭᎾᏗᏅᏗ ᏥᎩ, ᏝᏍᎪ ᎤᏟᎯᏳ ᏱᏂᏙᎨᏥᏄᏬᏣ, ᎤᏍᏗ ᎢᏦᎯᏳᎯ?


text:
ᎾᎯᏳ ᎢᎦ ᎨᏎᏍᏗ ᎤᏂᏣᏘᏍᏗ ᎯᎠ ᏅᏓᎬᎩᏪᎭᎵ; ᏣᎬᏫᏳᎯ, ᏣᎬᏫᏳᎯ, ᏝᏍᎪ ᏕᏣᏙᎥ ᏲᏨᏗᏍᎨ ᏲᏣᏙᎴᎰᏍᎨᎢ? ᎠᎴ ᏝᏍᎪ ᏕᏣᏙᎥ ᏲᏨᏗᏍᎨ ᎠᏂᏍᎩᎾ ᏱᏙᏥᏄᎪᏫᏍᎨᎢ? ᎠᎴ ᏝᏍᎪ ᏕᏣᏙᎥ ᏲᏨᏗᏍᎨ ᎤᏣᏘ ᎤᏍᏆᏂᎪᏗ ᏱᏙᎩᎸᏫᏍᏓᏁᎮᎢ?


text:
ᎠᏴᏰᏃ ᏗᏆᏓᏁᎶᏗᏉ, ᎠᎴ ᏓᎩᎧᎭ ᎠᏂᏯᏫᏍᎩ ᎾᏍᎩ ᏕᎬᏆᏁᎶᏙᎢ, ᎩᎶᏃ ᎮᎾ ᏥᏲᏏ, ᎡᎪᎢ; ᏅᏩᏓᎴᏃ ᎡᎮᎾ ᏥᏲᏏ, ᏗᎡᎪᎢ; ᏥᏅᏏᏓᏍᏗᏃ, ᎯᎠ ᎿᏛᎦ ᏥᏲᏏ, ᎾᏍᎩ ᎾᏛᏁᎰᎢ.


text:
ᎠᎴ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎤᏂᏣᏘ ᏗᎧᎸᎬ ᎠᎴ ᏭᏕᎵᎬ ᎢᏗᏢ ᏗᏂᎶᏍᎨᏍᏗ, ᎠᎴ ᎢᏧᎳᎭ ᎠᎾᏅᎥᏍᎨᏍᏗ ᎡᏆᎭᎻ, ᎠᎴ ᎡᏏᎩ, ᎠᎴ ᏤᎦᏈ, ᎦᎸᎳᏗ ᎡᎯ ᎾᎿ ᎤᎬᏫᏳᎯ ᎨᏒᎢ,


text:
ᎢᏍᎪᏂᏗᏢᏃ ᏭᎷᏨ ᎦᎩᏏᏂ ᎤᎾᏤᎵᎪᎯ, ᎠᏂᏔᎵ ᎠᏂᏍᎩᎾ ᏗᎬᏩᏂᏯᎢ ᏕᎬᏩᏠᏎᎢ, ᏓᏓᏂᏌᎲ ᏧᏂᏄᎪᏤᎢ, ᎤᏣᏔᏅᎯ ᎤᏂᎿᎸᎯᏳ ᎨᏎᎢ, ᎾᏍᎩ ᎥᏝ ᎩᎶ ᎾᎿ ᎬᏩᎶᎯᏍᏗ ᏱᎨᏎᎢ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ; ᏍᏕᎾ. ᎤᏂᏄᎪᏨᏃ, ᏏᏆ ᏑᎾᏓᏡᎩ ᏫᏚᏂᏴᎴᎢ. ᎠᎴ ᎬᏂᏳᏉ ᏂᎦᏛ ᏑᎾᏓᏡᎩ ᏏᏆ ᎠᏯᏄᎵᏳ ᎤᎾᎵᏎᎢ, ᏭᏂᎦᏐᎠᏎ ᎦᏁᏡᎩ ᎬᏒᎢ, ᎥᏓᏝ ᏭᎾᎵᏔᏗᏅᏎᎢ, ᎠᎴ ᎠᎹᏱ ᏚᏂᎵᏬᏤᎢ.


text:
ᎬᏂᏳᏉᏃ ᎬᏩᏘᏃᎮᎴ ᎠᏍᎦᏯ ᎤᏢᎩ ᎤᎸᏓᎸᎥᏍᎩ ᎦᏅᎨ ᎠᏤᏍᏙᎩᎯ; ᏥᏌᏃ ᎤᏙᎴᎰᏒ ᎠᏃᎯᏳᎲᏍᎬᎢ, ᎯᎠ ᏄᏪᏎᎴ ᎤᎸᏓᎸᎥᏍᎩ; ᎠᏇᏥ, ᎤᎦᎵᏍᏘᏳᏉ ᎭᏓᏅᏓᏓ, ᏣᏍᎦᏅᏨ ᎡᏣᏙᎵᎩ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏅᎩ, ᎦᏅᎬ <n>[ᎠᎵᏍᏓᏴᎲᏍᎬ]</n> ᎦᎵᏦᏕ, ᎬᏂᏳᏉ ᎤᏂᏣᏛᎩ ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᎦᎾ ᎤᏂᎷᏨ ᎤᎾᏂᏢᏅᎩ ᎠᏂᏅᏜᎥ ᏥᏌ ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ.


text:
ᎢᏤᎾᏍᎩᏂ, ᏫᏣᏕᎶᏆ ᎦᏛᎬ ᎯᎠ ᎾᏍᎩ ᏥᏂᎦᏪᎭ; ᎠᏓᏙᎵᏍᏗ ᎨᏒ ᎠᏆᏚᎵᎭ, ᎥᏝᏃ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎨᏒᎢ. ᎥᏝᏰᏃ ᎾᏂᏍᎦᏅᎾ ᏱᏗᏥᏯᏅᎯᎸ, ᎠᏂᏍᎦᎾᏍᎩᏂ ᏧᏂᏁᏟᏴᏍᏗᏱ ᏚᎾᏓᏅᏛᎢ.


text:
ᎿᏉᏃ ᏣᏂ ᎬᏩᏍᏓᏩᏗᏙᎯ <n>[ᏥᏌ]</n> ᎬᏩᎷᏤᎸᎩ, ᎯᎠ ᏂᎬᏩᏪᏎᎸᎩ; ᎦᏙᏃ ᎠᏴ ᎠᏂᏆᎵᏏᏃ ᏯᏃ ᎠᎹᏟ ᏦᏨᏍᎦ, ᏂᎯᏃ ᎨᏣᏍᏓᏩᏗᏙᎯ ᎠᎹᏟ ᎾᏅᏍᎬᎾ ᏥᎩ?


text:
ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏥᎪ ᏰᎵ ᏕᎨᎦᏨᏍᏗᏍᎬ ᎠᏂᎦᏔᎯ ᏱᏓᎾᏠᏱᎦ ᎠᏏᏉ ᎤᏕᏒᏂᎸᎯ ᎤᏁᎳᏗᏙᎲᎢ? ᎠᏎᏃ ᎢᎦ ᏛᎵᏱᎶᎵ ᏓᎨᏥᏯᏅᎡᎵ ᎤᏕᏒᏂᎸᎯ, ᎩᎳ ᎿᏉ ᎠᎹᏟ ᏛᏅᏂ.


text:
ᎥᏝ ᎠᎴ ᎢᏤ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᏧᏪᏘ ᏗᏑᏢᏛ ᏱᏓᏂᏟᏍᏗᏍᎪᎢ; ᏗᏑᏢᏛᏰᏃ ᏱᏓᏓᏣᎦᎸ, ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᏯᏤᏬᎩ, ᏗᏑᏢᏛᏃ ᏱᏓᏲᎩ. ᎢᏤᏍᎩᏂ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᏗᏤ ᏗᏑᏢᏛ ᏓᏂᏟᏍᏗᏍᎪᎢ, ᎢᏧᎳᏃ ᏚᏂᏍᏆᏂᎪᏙᎢ.


text:
ᎠᏏᏉ ᎾᏍᎩ ᏂᏕᎦᏪᏎᎲᎩ, ᎬᏂᏳᏉ ᎩᎶ ᎢᏳᏍᏗ ᏄᎬᏫᏳᏌᏕᎩ ᎤᎷᏨ ᎤᏓᏙᎵᏍᏓᏁᎸᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᎠᏇᏥ ᎠᎨᏳᏣ ᎦᏳᎳ ᎤᏲᎱᏏᏕᎾ. ᎠᏗᎾ ᎮᎾ, ᎯᏯᏒᏂᎸᎭ, ᎠᎭ ᏛᎠᏛᏂᏗᏉ.


text:
ᏥᏌᏃ ᏂᎦᎥ ᏧᏛᎾ ᏕᎦᏚᎲ ᎠᎴ ᏧᏍᏗ ᏕᎦᏚᎲ ᎤᏪᏙᎸᎩ, ᏓᏕᏲᎲᏍᎬᎩ ᏧᏂᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᎠᎵᏥᏙᎲᏍᎬᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎧᏃᎮᏍᎬᎩ, ᎠᎴ ᏕᎧᏅᏫᏍᎬ ᏂᎦᎥ ᏚᏂᏢᎬ ᎠᎴ ᏂᎦᎥ ᎥᏳᎩ ᏴᏫ ᎤᏂᏱᎵᏕᎲᎢ.


text:
ᎢᏳᏃ ᎾᎿ ᎠᏂᏁᎳ ᎤᏩᏙᎯᏯᏛ ᏗᎬᏩᎾᏓᏂᎸᎢᏍᏗ ᎢᎨᏎᏍᏗ, ᎾᏍᎩ ᎤᏩᏙᎯᏯᏛ ᎢᏣᏤᎵ ᎤᏂᎷᏤᏗ ᎨᏎᏍᏗ; ᎢᏳᏃ ᏗᎬᏩᎾᏓᏂᎸᎢᏍᏗ ᏂᎨᏒᎾ ᎢᎨᏎᏍᏗ, ᎾᏍᎩ ᏅᏩᏙᎯᏯᏛ ᎢᏨᏒᏉ ᎢᏥᎷᏤᏗ ᎢᎨᏎᏍᏗ.


text:
ᎠᎴ ᎿᏉ ᎤᏲ ᏂᎨᏨᎿᏕᎨᏍᏗ ᎢᎸᎯᏢ ᎦᏚᎲᎢ, ᎢᎶᎵᏍᎨᏍᏗ ᏅᏩᎵᎴ ᏗᎦᏚᎲ ᏫᏥᎶᏍᎨᏍᏗ. ᎤᏙᎯᏳᎯᏯᏰᏃ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎥᏝ ᎢᏏᎵᏱ ᏕᎦᏚᎲᎢ ᏱᎨᏤᏙᏁᏍᏗ ᎿᏉ ᏴᏫ ᎤᏪᏥ ᏓᎦᎷᏥ.


text:
ᏰᎵᏉᏰᏃ ᏗᏕᎶᏆᏍᎩ ᏧᏪᏲᎲᏍᎩ ᎢᏧᎳᎭᏉ ᏱᎩ, ᎠᎴ ᎠᏥᏅᏏᏓᏍᏗ ᎤᏅᏏᏙᎯ ᎢᏧᎳᎭᏉ ᏱᎩ. ᎢᏳᏰᏃ ᏧᏓᏘᎿᎢ ᎠᏓᏁᎸ ᏇᎵᏥᏆ ᏳᏃᏎᎸ, ᎤᏟ ᎠᎯᏗᏳ ᎾᏍᎩ ᎢᏧᏂᏪᏎᏗᏱ ᏚᏓᏘᎿᎥᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏞᏍᏗ ᏱᏗᏥᏍᎦᎢᎮᏍᏗ. ᎥᏝᏰᏃ ᎪᎱᏍᏗ ᏱᎬᏍᎦᎳ ᎾᏍᎩ ᎬᏂᎨᏒ ᎢᏳᎵᏍᏙᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᎪᎱᏍᏗ ᎤᏕᎵᏛ ᏱᎩ ᎾᏍᎩ ᎠᏙᎴᎰᎯᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎠᎴ ᏞᏍᏗ ᏱᏗᏥᏍᎦᎢᎮᏍᏗ ᎠᏰᎸᎢ ᎠᏂᎯᎯ, ᎠᏎᏃ ᎠᏓᏅᏙ ᎬᏩᏂᎯᏍᏗ ᏂᎨᏒᎾ ᏥᎩ. ᎤᎬᏫᏳᏎᏍᏗᏍᎩᏂ ᎡᏥᏍᎦᎢᎮᏍᏗ ᎾᏍᎩ ᏗᎬᏩᎯᏍᏗ ᏥᎩᎠᏰᎸᎢ ᎠᎴ ᎠᏓᏅᏙ ᎢᏧᎳ ᏨᏍᎩᏃᎢ.


text:
ᎩᎶᏃ ᎤᏟ ᏄᎨᏳᏎᏍᏗ ᎤᏙᏓ ᎠᎴ ᎤᏥ ᎡᏍᎦᏉ ᎠᏴ ᎾᎩᎨᏳᏎᏍᏗ, ᎥᏝ ᏰᎵ ᎾᏍᎩ ᎠᏴ ᎠᏆᏤᎵ ᎢᎬᏩᎵᏍᏙᏗ ᏱᎨᏎᏍᏗ. ᎩᎶᏃ ᎤᏟ ᏄᎨᏳᏎᏍᏗ ᎤᏪᏥ ᎠᏍᎦᏯ ᎠᎴ ᎤᏪᏥ ᎠᎨᏴ ᎡᏍᎦᏉ ᎠᏴ ᎾᎩᎨᏳᏎᏍᏗ, ᎥᏝ ᏰᎵ ᎾᏍᎩ ᎠᏴ ᎠᏆᏤᎵ ᎢᎬᏩᎵᏍᏙᏗ ᏱᎨᏎᏍᏗ.


text:
ᎩᎶᏃ ᏓᏓᏂᎸᎨᏍᏗ ᎠᏙᎴᎰᏍᎩ ᎠᏙᎴᎰᏍᎩ ᎨᏒ ᎤᏗᎦᎵᏍᏙᏗᎨᏍᏗ, ᎠᏙᎴᎰᏍᎩ ᎠᎦᎫᏴᏓᏁᏗ ᎨᏒ ᎾᏍᎩ ᎠᎦᎫᏴᏓᏁᎮᏍᏗ; ᎩᎶᏃ ᏓᏓᏂᎸᎨᏍᏗ ᎤᏓᏅᏘ ᎠᏍᎦᏯ ᎤᏓᏅᏘ ᎨᏒ ᎤᏗᎦᎵᏍᏙ ᏗᏍᎨᏍᏗ, ᎤᏓᏅᏘ ᎠᏍᎦᏯ ᎠᎦᎫᏴᏓᏁᏗ ᎨᏒ ᎾᏍᎩ ᎠᎦᎫᏴᏓᏁᎮᏍᏗ.


text:
ᎩᎶᏃ ᏌᏉ ᎯᎠ ᏧᎾᏍᏗ ᎨᏒᎢ ᎤᎵᏍᏈᏗᏉ ᎠᎧᎵᎢ ᎤᏴᏜ ᎠᎹ ᎠᎱᎥᏍᎨᏍᏗ ᎠᎩᏍᏓᏩᏗᏙᎯ ᎨᏒ ᎤᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎤᏙᎯᏳᎯᏯ ᏂᏨᏪᏎᎭ, ᎥᏝ ᎾᏍᎩ ᎤᏲᎱᏎᏗ ᏱᎨᏎᏍᏗ ᎠᎦᎫᏴᎡᏗ ᎨᏒᎢ.


text:
ᏗᏂᎨᏫ ᎠᏂᎪᏩᏖᎭ, ᏗᏂᏲᎤᎵᏃ ᎠᏁᏙᎭ, ᎠᏓᏰᏍᎩ ᏧᏂᏢᎩ ᏚᎾᏗᏩᏍᎦ, ᏧᏂᎵᎡᎾᏃ ᎠᎾᏛᎩᎭ, ᏧᏂᏲᏞᏒᎯᏃ ᏕᎨᎦᎴᏗᎭ ᎤᏲᏃ ᎢᏳᎾᏛᎿᏕᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎢᎨᎦᎵᏥᏙᏁᎭ.


text:
ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎠᏂᎨᏴ ᎬᏩᏂᎾᏄᎪᏫᏒᎯ ᏥᎩ ᎥᏝ ᎩᎶ ᏳᎾᏄᎪᏨ ᎬᏩᏓᎵᏁᎯᏕᏗ ᏣᏂ ᏗᏓᏬᏍᎩ; ᎠᏎᏃ ᎤᏍᏗᎧᏂ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᎡᏍᎦᏉ ᏣᏂ.


text:
ᏴᏫ ᎤᏪᏥ ᎤᎷᏨ ᎠᎵᏍᏓᏴᎲᏍᎦ ᎠᎴ ᎠᏗᏔᏍᎦ, ᎯᎠᏃ ᏂᎠᏂᏪᎭ; ᎬᏂᏳᏉ ᎠᏍᎦᏯ ᎤᎬᎥᏍᎩ ᎠᎵᏍᏓᏴᏗ ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ, ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᏕᎾ ᎤᎾᎵᎢ. ᎠᏎᏃ ᎠᎦᏔᎿᎢ ᏧᏪᏥ ᎣᏏᏳ ᎢᎬᏩᏰᎸᎭ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᎪᎴᏏᏂ, ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏇᏣᏱᏗ; ᎢᏳᏰᏃ ᎤᏍᏆᏂᎪᏗ ᏕᎦᎸᏫᏍᏓᏁᎸ ᏂᎯ ᎢᏤᎲ ᏱᏙᎦᎸᏫᏍᏓᏁᎴ ᏔᏯ ᎠᎴ ᏌᏙᏂ, ᎪᎯᎩ ᏗᎬᏩᏂᏁᏟᏴᏛ ᏱᎨᏎ ᏚᎾᏓᏅᏛᎢ, ᏧᏏᏕᎾ ᏱᏚᎾᏄᏬᎡ ᎠᎴ ᎪᏍᏚ ᏳᎾᏓᏅᎵᏰᎡᎢ.


text:
ᏂᎯᏃ ᎨᏆᏂ ᎦᎸᎳᏗ ᎢᏴᏛ ᏤᏣᏌᎳᏓ, ᏨᏍᎩᏃᎢ ᏴᏓᏰᎶᎥᏔᏂ; ᎢᏳᏰᏃ ᎤᏍᏆᏂᎪᏗ ᏕᎦᎸᏫᏍᏓᏁᎸ ᏂᎯ ᎢᏤᎲ ᏱᏙᎦᎸᏫᏍᏓᏁᎴ ᏐᏓᎻᏱ, ᎠᏏ ᎪᎯ ᎨᏒ ᏱᏂᎬᏩᏍᏕᏉ.


text:
ᎾᎯᏳ ᏥᏌ ᎤᏁᏨ ᎯᎠ ᏄᏪᏒᎩ; ᎬᏯᎵᎡᎵᏤᎭ ᎡᏙᏓ, ᏣᎬᏫᏳᎯ ᎦᎸᎳᏗ ᎠᎴ ᎡᎶᎯ, ᎾᏍᎩ ᎯᎠ ᏥᏕᎲᏍᎦᎳᏁᎸ ᎠᏂᏏᎾᏌᏂ ᎠᎴ ᎠᏁᏯᏔᎯ, ᏗᏂᏲᎵᏃ ᏥᏕᎯᎾᏄᎪᏫᏎᎸ.


text:
ᏂᎦᎥ ᎪᎱᏍᏗ ᏓᎩᏲᎯᏎᎸ ᎡᏙᏓ, ᎠᎴ ᎥᏝ ᎩᎶ ᏯᎦᏔᎭ ᎤᏪᏥ ᎤᏙᏓᏉ ᎤᏩᏒ; ᎥᏝ ᎠᎴ ᎩᎶ ᏯᎦᏔᎭ ᎠᎦᏴᎵᎨᎢ ᎤᏪᏥ ᎤᏩᏒ, ᎩᎶᏃ ᎾᏍᎩ ᏥᎾᏄᎪᏫᏏ ᎡᎳ ᎤᏪᏥ.


text:
ᎠᎴᏥᏌ ᎠᎦᏔᎲᏄᏍᏛ ᎠᎾᏓᏅᏖᏍᎬᎢ, ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏂᎦᎥ ᎠᏰᎵ ᎪᏢᏒᎢ ᏔᎵ ᏥᎾᏓᏗᏍᎪ ᎤᏩᏒᏉ ᏣᏓᏡᏗᏍᎪ ᎠᏥᎪᏉ; ᎠᎴ ᏂᎦᎥ ᎦᏚᎲ ᎠᎴ ᎠᏓᏁᎸ ᏔᎵ ᏥᎾᏓᏗᏍᎪ ᎤᏩᏒᏉ ᏣᏓᏡᏗᏍᎪ ᎥᏝ ᏱᏂᎬᏩᏍᏙᏉ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᎠ ᏂᏨᏪᏎᎭ; ᏂᎦᎥ ᏄᏓᎴᏒ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᎠᎴ ᎠᏐᏢᏙᏗ ᎨᏒ ᎨᏥᏙᎵᏍᏗᏉ ᎨᏎᏍᏗ ᏴᏫ; ᎦᎸᏉᏗᏳᏍᎩᏂ ᎠᏓᏅᏙ ᎠᏐᏢᏙᏗ ᎨᏒ ᎥᏝ ᎨᏥᏙᎵᏍᏗ ᏱᎨᏎᏍᏗ ᏴᏫ.


text:
ᎠᎴ ᎩᎶ ᎦᏬᏂᏍᎬ ᎠᏡᏗᏍᎨᏍᏗ ᏴᏫ ᎤᏪᏥ, ᎠᏥᏙᎵᏍᏗᏉ ᎨᏎᏍᏗ; ᎩᎶᏍᎩᏂ ᎦᏬᏂᏍᎬ ᎠᏡᏗᏍᎨᏍᏗ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ, ᎥᏝ ᎠᏥᏙᎵᏍᏗ ᏱᎨᏎᏍᏗ ᎪᎯ ᎨᏒ ᎠᎴ ᎾᏍᏉ ᏐᎢᏱ ᏗᎨᏒᎢ.


text:
ᏴᏫ ᏂᏂᏫ ᏣᏁᎲᎩ ᏙᏛᎾᎴᏂ ᏓᎬᏩᎾᏡᏔᏂ ᎪᎯ ᏣᏁᎭ, ᏗᎫᎪᏙᏗᏱ ᎢᎦ ᎨᏒᎢ, ᎠᎴ ᎤᏂᏍᎦᏅᏨ ᎬᏂᎨᏒ ᎤᏛᏅᏁᎵ; ᎾᏍᎩᏰᏃ ᏚᎾᏓᏅᏃ ᏚᎾᏓᏅᏛ ᏚᏂᏁᏟᏴᏒᎩ ᏦᎾ ᎠᎵᏥᏙᎲᏍᎬ ᏄᏩᏂᏌᏅᎩ, ᎬᏂᏳᏉᏃ ᎠᏂ ᎡᏙᎭ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᎡᏍᎨᏉ ᏦᎾ.


text:
ᎤᎬᏫᏳᎯ ᎠᎨᏴ ᏧᎦᎾᏴ ᏤᎮᎢ ᏙᏛᎴᏂ ᏓᏳᎾᏡᏔᏂ ᎪᎯ ᏣᏁᎭ ᏗᎫᎪᏙᏗᏱ ᎢᎦ ᎨᏒᎢ, ᎠᎴ ᎤᏂᏍᎦᏅᏨ Ꭼ Ꮒ ᎨᏒ ᎤᏓᎬᏁᎵ; ᎾᏍᎩᏰᏃ ᎦᏙᎯ ᏩᏍᏛ ᎢᏴᏛ ᏧᏪᏅᏎ ᎤᏛᎦᏂᎴ ᏐᎵᎼᏅ ᎠᎦᏔᎿᎢᏳ ᎨᏒᎢ, ᎬᏂᏳᏉᏃ ᎠᏂ ᎡᏙᎭᎤᏟ ᎠᏥᎸᏉᏗᏳ ᎡᏍᎦᏉ ᏐᎵᎼᏅ.


text:
ᎿᏉᏃ ᎢᎡᎪᎢ ᏫᏓᏯᏂᏍᎪ ᎤᏩᎾᏓᎴ ᎦᎵᏉᎩ ᎠᏂᏍᎩᎾ ᎤᏟ ᎢᏳᏂᏁᎫᏥᏛ ᎡᏍᎦᏉ ᎤᏩᏒ, ᎾᎿᏃ ᎠᏂᏴᎯᎰᎢ ᎠᎴ ᎠᎾᏁᎳᏗᏍᎪᎢ, ᎣᏂᏃ ᏄᏍᏛ Ꮎ ᎠᏍᎦᏯ ᎤᏟ ᎤᏲᎢᏳ ᎨᏐᎢ ᎡᏍᎦᏉ ᎢᎬᏱᏱ. ᎾᏍᎩᏍᎩᏂ ᏄᎾᏍᏕᏍᏗ ᎪᎯ ᎤᏂᏁᎫᏥᏛ ᏣᏁᎭ.


text:
ᎠᎴ ᎠᏁᎲ ᎤᏙᎯᏳᏅ ᎢᏌᏯ ᏧᏙᎴᎰᏎᎢ, ᎯᎠ ᏥᏄᏪᏎᎢ; ᎢᏣᏛᎩᏍᎬ ᎢᏣᏛᎩᏍᎨᏍᏗ, ᎠᏎᏃ ᎥᏝ ᏱᏦᎵᎨᏍᏗ; ᎠᎴ ᎢᏥᎪᏩᏘᏍᎬ ᎢᏥᎪᏩᏘᏍᎨᏍᏗ, ᎠᏎᏃ ᎥᏝ ᏱᏣᏙᎴᎰᏍᎨᏍᏗ.


text:
ᎯᎠᏰᏃ ᏴᏫ ᏧᏂᎾᏫ ᏚᎵᏦᎲᏒ, ᎠᎴ ᏓᏂᎵᎷᎬ <n>[ᎦᏲᎵᏳ ᏓᏛᎩᎭ, ᎠᎴ ᏗᏂᎦᏙᎵ ᏚᏂᏍᏚᏅ; ᎾᏍᎩ ᏗᏂᎦᏙᎵ ᏗᎬᏩᏂᎪᏩᏛᏙᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᏓᏂᎵᎷᎬ ᏗᎬᏩᎾᏛᎪᏙᏗᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᏧᏂᎾᏫ ᏗᎬᏩᏃᎵᏍᏙᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᏗᎬᏩᎾᏓᏁᏟᏴᎡᏗ]</n> ᏂᎨᏒᎾ ᏚᎾᏓᏅᏛ, ᎠᎴ ᏗᎦᎦᏥᏅᏬᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎤᏙᎯᏳᎯᏯᏰᏃ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎤᏂᏣᏘ ᎠᎾᏙᎴᎰᏍᎩ ᎠᎴ ᎤᎾᏓᏅᏘ ᎤᎾᏚᎸᏛ ᎤᏥᎪᏩᏛᏗᏱ ᎯᎠ ᎾᏍᎩ ᏥᏥᎪᏩᏘᎭ, ᎠᏎᏃ ᎥᏝ ᎤᏂᎪᎲᎯ ᏱᎩ; ᎠᎴ ᎤᎾᏛ ᎪᏗᏱ ᎯᎠ ᎾᏍᎩ ᏥᏣᏛᎩᎭ, ᎠᏎᏃ ᎥᏝ ᎤᎾᏛᎦᏅᎯ ᏱᎩ.


text:
ᎢᏳᏃ ᎩᎶ ᎠᏛᎬᎦ ᎧᏃᎮᏛ ᎦᎸᎳᏗ ᎡᎯᎤᎬᎾᏳᎯ ᎨᏒ ᎤᎬᏩᎵ, ᏂᎪᎵᎬᎾᏃ ᏥᎨᏐᎢ, ᎿᏉ ᎤᏁᎫᏥᏛ ᎦᎷᎪᎢ ᎠᎴ ᎤᎩᎡᎰ ᎠᏫᏒ ᎤᎾᏫᏱ. ᎾᏍᎩ ᎯᎠ ᎤᏃᎱᎶᏗ ᏣᏫᏎᎢ.


text:
ᎯᎠᏃ ᎾᏍᏉ ᎠᏄᎦᎸᎯ ᏣᏫᏎᎢ, ᎾᏯᎩ ᏣᏛᎩᏯᎪ ᎧᏃᎮᏛ, ᎡᎶᎯᏃ ᎤᏪᎵᎯᏍᏗ ᎨᏒ ᎠᎴ ᎨᏅᎢᏍᏗ ᎨᏒ ᎤᏓᎵᏓᏍᏛ ᎠᏂᏁᏄᎳᏍᏗᏍᎪ ᎧᏃᎮᏛ, ᎾᏍᎩᏃ ᎾᎦᏔᏛᎬᎾᏉ ᎨᏐᎢ.


text:
ᎾᏍᎩᏍᎩᏂ Ꮎ ᎣᏒ ᎦᏙᎯ ᏣᏫᏎᎢ; ᎾᏍᎩ ᏣᏛᎩᏍᎪ ᎧᏃᎮᏛ ᎠᎴ ᏥᎪᎵᎪᎢ, ᎠᎴ ᎾᏍᏉ ᏣᎦᏔᏛᏍᎪᎢ, ᎠᎴ ᏥᎦᎾᏄᎪᏫᏍᎪᎢ, ᎢᎦᏛ ᎠᏍᎪᎯᏧᏈ ᎤᏁᏉᏨ Ꭿ, ᎢᎦᏛᏃ ᏑᏓᎳᏍᎪᎯ, ᎢᎦᏛᏃ ᏦᎠᏍᎪᎯ.


text:
ᎤᏁᎳᎩ ᎢᎫᎳᎭ ᏫᏓᏛᎯ ᎬᏂ ᎠᎦᏛᎾᏨᎭ; ᎿᏉᏃ ᎠᎦᏛᎾᏨ ᎯᎠ ᏅᏓᎦᏥᏪᏎᎵ ᎠᏂᏍᎫᏕᏍᎩ; ᎢᎬᏱ ᎢᏥᏟᏌ ᎤᏲ, ᎠᎴ ᏗᏦᏛᏣ ᏗᎪᎲᏍᏙᏗ, ᎤᏣᎴᏍᏗᏍᎩᏂ ᎢᏥᏟᏌ ᎠᎩᏍᏆᏂᎪᏙᏗᏱ.


text:
ᏅᏩᏓᎴ ᏚᏟᎶᏍᏓᏁᎸᎩ, ᎯᎠ ᏄᏬᏒᎩ; ᎦᎸᎳᏗᎡᎯ ᎤᎬᏫᏳᎯᎨᏒ ᎾᏍᎩᏯᏉ ᎠᎪᏙᏗ, ᎾᏍᎩ ᎠᎨᏴ ᏧᎩᏎ ᎠᎴ ᏧᏑᏴᏁ ᏦᎢ ᎢᏳᏟᎶᏛ ᎢᏒ ᎦᎸᎢ, ᎬᏂ ᏂᎦᏛ ᎤᎪᏐᏅ.


text:
ᎠᎴ ᎾᏍᎩ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎾᏍᎩᏯᏉ ᏧᎬᏩᎶᏗ ᎤᏕᎵᏛ ᏠᎨᏏ ᏣᎰᎢ, ᎾᏍᎩ ᎢᏳ ᎠᏍᎦᏯ ᎠᏩᏛ, ᏣᏕᎸᏍᎪᎢ, ᎠᎵᎮᎵᎬᏃ ᎢᏳᏍᏘ ᏤᎪᎢ ᏥᏫᎦᎾᏕᎪᏂᎦᏛ ᎤᏍᏆᏂᎪᏛᎢ, ᎠᎴ ᏥᏭᏩᏍᎪ ᎾᏍᎩ ᏠᎨᏏ.


text:
ᎿᏉᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎩᎶ ᏗᎪᏪᎵᏍᎩ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎤᎬᏩᎵ ᎠᎨᏲᏅᎯ ᏥᎨᏐᎢ, ᎾᏍᎩᏯᏉ ᎠᏍᎦᏯ ᎦᏁᎳ ᏥᏙᏗᎦᎾᏄᎪᏫᏍᎪ ᏧᎬᏩᎶᏗ ᎤᏍᏆᏂᎪᏛ ᏧᏓᎴᏅᏛ ᏗᏤ ᎠᎴ ᏧᏪᏘ.


text:
ᎿᏉᏃ ᎤᏩᏒ ᎤᏤᎵᎪᎯ ᎤᎷᏨ ᏧᏂᎳᏫᎢᏍᏗᏱ ᏚᏪᏲᏅᎩ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏂᏍᏆᏂᎪᏒᎩ, ᎠᎴ ᎯᎠᏄᏂᏪᏒᎩ; ᎦᏙ ᎤᎵᏍᏙᏔᏅ ᎯᎠ ᎾᏍᎩ ᎠᏍᎦᏯ ᏣᎦᎳ ᎿᎠ ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᏥᏚᎸᏫᏍᏓᏁᎭ?


text:
ᎤᏒᏃ ᏄᎵᏍᏔᏅ ᎬᏩᏍᏓᏩᏙᎯ ᎬᏩᎷᏤᎸᎩ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎠᏂ ᎢᎾᎨᏉ, ᎠᎴ ᎢᎦ ᎤᎶᏐᏂᏗ, ᏥᏤᎾᏉᏃ ᎩᏲᏏᎯᎠ ᎤᏂᏣᏘ ᏴᏫ, ᎠᎴ ᏙᏗᎦᏚᎲ ᏫᎠᏂᎶᎯ, ᎾᎿ ᎤᏅᏒ ᎤᎾᎵᏍᏓᏴᏗ ᎤᏂᏩᏒᎭ.


text:
ᏚᏁᏤᎸᏃ ᎤᏂᏣᏘ ᎧᏁᏍᎪᎯ ᎨᏒ ᎤᎾᏅᏗᏱ, ᏚᎩᏒᏃ ᎯᏍᎩ ᎦᏚ ᎠᎴ ᏔᎵ ᎠᏣᏗ ᏚᏁᏒ, ᎦᎸᎳᏗᏃ ᏫᏚᎧᎾᏅ ᎤᎵᎮᎵᏨᎩ, ᎠᎴ ᏚᎬᎭᎷᏴ ᏚᏁᎸᎩ ᎦᏚ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎾᏍᎩᏃ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎤᏂᏣᏘ ᏫᏚᏂᏁᎸᎩ.


text:
ᏂᎦᎸᏉᏗᏍᎬᎾᏃ ᎢᎨᏎᏍᏗ ᎤᏙᏓ, ᎠᎴ ᎤᏥ, <n>[ᎥᏝ ᎤᏍᎦᏅᏨᎯ ᏱᎨᏎᏍᏗ,]</n> ᎢᏣᏗᏍᎪᎢ. ᎾᏍᎩ ᎯᎠ ᎡᏘ ᎠᏁᎯ ᎤᏂᏃᎮᎸᎯ ᎢᏨᏔᏅ ᎠᏎᏉ ᏂᏨᏁᎸ ᎤᏁᎳᏅᎯ ᎤᏁᏨᎯ.


text:
ᎣᎾᏫᏱᏰᏃ ᏗᏓᎴᎲᏍᎪ ᎤᏐᏅ ᎠᏓᏅᏖᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏓᎯᏍᏗᏱ ᎨᏒᎢ, ᎠᎴ ᎠᏓᏲ ᏁᏗᏱ ᎨᏒᎢ, ᎠᎴ ᎤᏕᎵᏛ ᏗᏂᏏᏗᏱ ᎬᏒᎢ, ᎠᎴ ᎦᏃᏍᎩᏍᏗᏱ ᎨᏒᎢ, ᎠᎴ ᎠᏥᎪᏗᏱ ᏓᎾᏓᏱᎵᏙᎲᎢ, ᎠᎴ ᎠᏐᏢᎢᏍᏙᏗᏱ ᎨᏒᎢ.


text:
ᎤᏂᏣᏘᏃ ᏴᏫ ᎬᏩᎷᏤᎸᎩ, ᏓᎾᏘᏁᎲ ᏗᏂᏲᏅᎵ, ᎠᎴ ᏗᏂᎨᏫ, ᎠᎴ ᏧᏅᎨᏫ, ᎠᎴ ᎪᎱᏍᏗ ᎤᏍᏛ ᏗᏂᏰᎸ ᏧᏂᏲᎱᏎᎸᎯ, ᎠᎴ ᎤᏂᏣᏘ ᏅᏩᎾᏓᎴᎢ, ᎠᎴ ᏥᏌ ᏚᎳᏍᎬ ᎾᎥ ᏚᏂᏅᏅᎩ, ᏚᏅᏩᏅᎩᏃ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏂᏣᏘ ᎨᏒ ᎤᏂᏍᏆᏂᎪᏒᎩ, ᏚᏂᎪᎲ ᏧᏅᎨᏫ ᎠᏂᏬᏂᏍᎪᎢ, ᎠᎴ ᎠᎱᏍᏗ ᎤᏍᏛ ᏗᏂᏰᎸ ᏧᏂᏲᎱᏎᎸᎯ ᎤᏂᏃᏍᏛ ᏄᎾᎵᏍᏔᏅᎢ, ᎠᎴ ᏗᏗᏲᏅᎵ, ᎬᏩᏁᏓᏍᏗ ᏄᎵᏍᏔᏅᎢ ᎠᎴ ᏗᏂᎨᏫ ᎬᏩᏂᎪᏩᏛᏗ ᏄᎵᏍᏔᏅᎢ; ᎤᏂᎸᏉᏔᏅᎩᏃ ᎤᏁᎳᏅᎯ ᎢᏏᎵ ᎤᎾᏤᎵᎦ.


text:
ᏥᏌᏃ ᏫᏚᏯᏅᎲ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎯᎠ ᏄᏪᏒᎩ; ᎦᏥᏯᏙᎵᎦ ᎯᎠ ᎤᏂᏣᏘ ᎨᏒᎢ, ᏦᎢᏰᏃ ᎾᏙᏓᏆ ᎠᏂ ᎨᏙᎲ ᎠᏁᏙᎭ, ᎠᎴ ᎥᏝ ᏱᏂᏰᎭ ᎤᎾᎵᏍᏓᏴᏗ. ᎠᎴ ᎢᏝ ᏯᏆᏚᎵᎭ ᏙᎤᏁᏅᏍᏗᏱ ᏗᎬᏩᏂᏲᏏᏍᎩ, ᏩᎾᏰᏃ ᏱᏓᏂᏩᏂᎦᎶᎩ ᏩᎾᎢᏒᎢ.


text:
ᎠᎴ ᏗᏍᏚᎢᏍᏗ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᏧᏤᎵ ᏙᏓᎬᏕᎵ, ᏂᎦᎥᏃ ᎪᎱᏍᏗ ᎭᎸᎢᎮᏍᏗ ᎡᎶᎯ, ᎦᎸᏍᏗ ᎨᏎᏍᏗ ᎦᎸᎳᏗ, ᏂᎦᎥᏃ ᎪᎱᏍᏗ ᎭᎸᎩᏍᎨᏍᏗ ᎡᎶᎯ ᎦᎸᎩᏍᏗ ᎨᏎᏍᏗ ᎦᎸᎳᏗ.


text:
ᎿᏉᏃ ᏥᏌ ᎤᎴᏅᎲᎩ ᏚᏃᏁᎸᎩ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎠᏎ ᎤᏪᏅᏍᏗᏱ ᎨᏒ ᏥᎷᏏᎵᎻ, ᎠᎴ ᏧᏓᎴᏅᏛ ᏧᎩᎵᏲᏤᏗᏱ ᏗᏂᎳᏫᎩ ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ; ᎠᎴ ᎠᏥᎢᏍᏗᏱ, ᎠᎴ ᏦᎢᏁ ᎢᎦ ᏧᎴᏗᏱ.


text:
ᏈᏓᏃ ᎤᏁᏨ ᎯᎠ ᏄᏪᏎᎴ ᏥᏌ; ᏣᎬᏫᏳᎯ, ᎣᏏᏳ ᎠᏂ ᏥᏕᏙᎭ, ᎢᏳᏃ ᎣᏏᏳ ᏱᏣᏰᎸᏅ, ᎠᏂ ᏦᎢ ᏱᏙᏥᎵᏦᏛᎦ, ᏌᏉ ᏂᎯ ᏣᏤᎵᎦ, ᏐᎢᏃ ᎼᏏ ᎤᏤᎵᎦ, ᏐᎢᏃ ᎢᎳᏯ ᎤᏤᎵᎦ.


text:
ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏅᏗᎦᎵᏍᏙᏗᎭ ᏂᏦᎯᏳᏒᎾ ᎨᏒᎢ. ᎤᏙᎯᏳᎯᏯᏰᏃ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎢᏳᏃ ᏱᏦᎯᏳᎭ ᎾᏍᏉ ᎠᏥᎸᏉ ᎤᎦᏔ ᎢᎩᏛ, ᎯᎠ ᏱᏂᏥᏪᏏ ᎯᎠ ᏦᏓᎸ, ᎭᏓᏅᎾ ᎢᏢ ᏫᎶᎯ, ᎠᎭ ᎤᏓᏅᏍᏗ; ᎥᏝ ᎠᎴ ᎪᎱᏍᏗ ᏱᎨᏥᏄᎸᎲᏍᎦ.


text:
ᎥᎥ, ᎤᏛᏁᎢ. ᎠᏓᏁᎸᏃ ᎤᎷᏨ ᏥᏌ ᎤᏲᏍᏙᏓᏁᎸᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᎦᏙ ᎮᎵᎭ, ᏌᏩᏂ; ᎦᎪ ᎠᏰᎵ ᎬᏩᎾᏓᏴᎡᎰ ᎤᏂᎬᏫᏳᎯ ᎡᎶᎯ ᎠᏁᎯ; ᏧᏁᏥᏍᎪ, ᏅᏩᎾᏓᎴᎨ?


text:
ᎠᏎᏃ ᏗᏂᎿᎸᏙᏍᏗᏱ ᏂᎨᏒᎾ, ᎥᏓᎵ ᎮᎾ, ᎠᏑᏗᏃ ᏫᏣᏓᎡᏒᎭ, ᎢᎬᏱᏱᏃ ᎯᏴᎩᏛ ᎠᏣᏗ ᎯᏁᏒᎭ, ᎠᎴ ᎯᏍᏚᎢᏒ ᎠᎰᎵ ᎠᏰᎵ-ᎠᏕᎸ ᏘᏩᏛᎯ; ᎾᏍᎩ ᎯᎩᏒᎭ ᎠᎴ ᏕᎯᏁᎸᎭ ᎠᏴ ᎩᎾᎫᏴᏗ.


text:
ᎤᏂᎢᏳ ᎢᏳᎵᏍᏓᏁᏗ ᎨᏎᏍᏗ ᎡᎶᎯ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏗᎾᏓᏙᏕᏍᏗᏍᎩ, ᎠᏎᏰᏃ ᏗᎾᏓᏙᏕᏍᏗᏍᎩ ᎤᏂᎾᏄᎪᎢᏍᏗ; ᎠᏎᏃ ᎤᏲᎢᏳ ᎢᏳᎵᏍᏓᏁᏗ ᎾᏍᎩ Ꮎ ᎠᏍᎦᏯ ᏗᏓᏙᏕᏍᏗᏍᎩ ᎤᎾᏄᎪᏫᏒᎯ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᏦᏰᏂ ᎠᎴ ᏣᎳᏏᏕᏂ ᏕᏦᏕᏍᏗᏍᎨᏍᏗ, ᎯᏍᏆᎵᏍᎨᏍᏗ ᎠᎴ ᏫᏣᏕᎨᏍᏗ; ᎤᏟ ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏦᏰᏂ ᎠᎴ ᏣᎳᏏᏕᏂ ᏣᏲᎱᎮᎸᎯ ᏱᎩ ᎬᏂᏛ ᏗᎨᏒ ᏫᏱᏣᏴᎸ, ᎠᏃ ᎢᏧᎳ ᏱᏘᏰᏌᏓ ᎠᎴ ᎢᏧᎳ ᏗᏣᎳᏏᏕᏂ ᏫᏰᏣᏓᏅ ᏂᎬᏠᏍᎬᎾ ᎨᏒ ᎠᏥᎸᏱ.


text:
ᎢᏳ ᎠᎴ ᎯᎦᏙᎵ ᏕᏦᏕᏍᏗᏍᎨᏍᏗ, ᎭᏓᎦᏖᏙᎢᏍᎨᏍᏗ ᎠᎴ ᏫᏣᏕᎨᏍᏗ; ᎤᏟ ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏌᏉ ᏱᎧᎿ ᎬᏂᏛ ᏗᎨᏒ ᏫᏱᏣᏴᎸ, ᎠᏃ ᎢᏧᎳ ᏱᏘᎧᎿ ᏨᏍᎩᏃᎢ ᎠᏥᎸᏱ ᏫᏰᏣᏓᎢᏅ.


text:
ᎦᏙ ᎢᏤᎵᎭ; ᎢᏳᏃ ᎩᎶ ᎠᏍᎦᏯ ᎠᏍᎪᎯᏧᏈ ᎠᏫ ᏱᏚᎾᏝᎠ, ᏌᏉᏃ ᏳᎴᏲᎡᎸ, ᏝᏍᎪ ᏐᎣᏁᎳᏍᎪᎯ ᏐᎣᏁᎳᎦᎵ ᎢᏯᏂᏛ ᏱᏗᎬᏕᎪᎢ, ᎠᎴ ᏱᏗᎧᎾᎷᏏᏙᎰ ᎦᏚᏏ ᏳᏲᎰ ᎤᎴᏲᎡᎸᎯ?


text:
ᎢᏳᏃ ᎾᏍᎩ ᏂᏓᏛᏓᏍᏓᏁᎲᎾᏉ ᎢᎨᏎᏍᏗ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎯᏃᎲᏍᎨᏍᏗ; ᎢᏳᏍᎩᏂᏃ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏂᏓᏛᏓᏍᏓᏁᎲᎾ ᎢᎨᏎᏍᏗ, ᏅᏩᏓᎴᏉ ᏴᏫ ᎠᎴ ᎠᏰᎵᏉ-ᎠᏕᎸ ᎠᎩᏏᏙᎯ ᎾᏍᎩᏯ ᎯᏯᏓᏅᏖᏍᎨᏍᏗ.


text:
ᎠᏎᏃ ᎾᏍᎩ Ꮎ ᎠᏥᏅᏏᏓᏍᏗ ᎤᏄᎪᏨ, ᎤᏩᏛᎮ ᎠᏏᏴᏫ ᎢᏧᎳᎭ ᎨᏥᏅᏏᏓᏍᏗ ᎾᏍᎩ ᎤᏁᏨᎯ ᎤᎫᏴᎡᏗᏱ ᎠᏍᎪᎯᏧᏈ ᎠᎩᏏ ᏧᎾᎬᏩᎶᏗ; ᎤᏂᏴᎮᏃ, ᎠᎴ ᎤᏴᏍᎩᏴᎮᎢ; ᏍᏆᎫᏴᏏ ᏥᎬᏚᎦ, ᎤᏛᏁᎢ.


text:
ᎠᏎᏃ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎩᎶ ᎤᏓᎵᎢ ᎢᎠᎨᎯᏙᎮᏍᏗ ᏧᏂᏏᏅᎯᏍᎩᏂᏃᏅ ᎢᎨᏎᏍᏗ, ᏅᏩᏓᎴᏃ ᎢᎠᏓᏰᎨᏍᏗ, ᎠᏓᏲᏁᎮᏍᏗ. ᎩᎶᏃ ᎠᏥᎨᎯᏙᎸᎯ ᎠᏓᏰᎨᏍᏗ ᎠᏓᏲᏁᎮᏍᏗ.


text:
ᎠᏁᎭᏰᏃ ᎠᏂᎾᎵ ᏅᏩᎾᏍᏙ ᏧᏂᏥ ᎬᏩᏂᎾᏄᎪᏫᏒ, ᎠᎴ ᎠᏁᎭ ᎠᏂᎾᎵ ᏴᏫ ᎬᏩᏂᎾᎵᏛᎯ, ᎠᎴ ᎠᏁᎭ ᎠᏂᎾᎵ ᎤᏅᏒ ᎤᎾᏓᎾᎵᏛᎯ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᏗᎵᏰᎢᎸᏍᏗᏍᎬᎢ. ᎩᎶ ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᎨᏎᏍᏗ ᎾᏍᎩ ᏓᏓᏂᎸᎨᏍᏗ.


text:
ᎯᎠᏃ ᏄᏪᏎᎸᎩ; ᎦᏙᏃ ᎰᏍᏛ ᎢᏍᏉᏎᎭ? ᎥᏝ ᎩᎶ ᎣᏍᏛ ᏱᎩ ᏌᏉ ᎤᏩᏒᎯᏳ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ. ᎠᏎᏃ ᏣᏚᎵᏍᎨᏍᏗ ᎬᏂᏛ ᏗᎨᏒ ᏫᏣᎾᏄᎪᎢᏍᏗᏱ ᏘᏍᏆᏂᎪᏓ ᏗᎧᎿᏩᏛᏍᏗ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎢᏳᏃ ᏣᏍᏆᏗᏍᏗᏱ ᏣᏚᎵᏍᎨᏍᏗ, ᎮᎾ, ᏫᎾᏚᎦ ᏣᎿᎥᎢ, ᎠᎴ ᏘᎲᏏ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ, ᎦᎸᎳᏗᏃ ᏫᏣᎮᏍᏗ ᏧᎬᏩᎶᏗ; ᎠᎴ ᏖᏒ ᏍᎩᏍᏓᏩᏕᏒᎭ.


text:
ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎠᏓᏁᏟᏴᏒᎢ, ᏴᏫ ᎤᏪᏥ ᎦᏅᎭ ᎦᎸᏉᏗᏳ ᎤᏪᏍᎩᎸᎢ, ᏂᎯ ᏍᎩᏍᏓᏩᏛᏛ ᎾᏍᏉ ᎢᏥᏁᏍᏗ ᏔᎳᏚ ᏕᎦᏍᎩᎸᎢ, ᏕᏧᎪᏓᏁᎮᏍᏗ ᏔᎳᏚ ᎾᏂᎳᏍᏓᎸ ᎢᏏᎵ.


text:
ᎠᎴ ᎾᏂᎥ ᎩᎶ ᏧᏅᏕᏨᎯ ᏓᏂᏁᎸᎢ, ᎠᎴ ᎠᎾᎵᏅᏟ ᎠᎴ ᏧᏂᏙ, ᎠᎴ ᏧᏂᏙᏙᏓ, ᎠᎴ ᏧᏂᏥ, ᎠᎴ ᏧᎾᏓᎵᎢ, ᎠᎴ ᏧᏁᏥ, ᎠᎴ ᎦᏙᎯ, ᏓᏆᏙᎥ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎤᏂᏩᏛᏗ ᎨᏎᏍᏗ ᎠᏍᎪᎯᏧᏈ ᎤᏁᏉᏨᎯ, ᎠᎴ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗ ᎨᏎᏍᏗ ᎬᏂᏛ ᏫᎾᏍᏛᎾ.


text:
ᎯᏍᎩᏁᏃ ᎢᏳᏟᎶᏛ ᎧᎳᏩᏗᏒ ᏔᎵᏁ ᎢᎤᏪᏅᏎᎢ, ᎠᎴ ᏚᏩᏛᎮ ᏅᏩᎾᏓᎴ ᎠᏂᏙᎾᎡ ᎪᎱᏍᏗ ᎾᎾᏛᏁᎲᎾ, ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ; ᎦᏙᏃ ᎠᏂ ᎢᏥᏙᎾᎠ ᎤᏙᏓᏆᏛ ᎪᎱᏍᏗ ᏂᏣᏛᏁᎲᎾ?


text:
ᎤᏒᏃ ᏄᎵᏍᏔᏅ, ᏖᎸᎳᏗ ᏓᏫᏒ ᎤᏤᎵᎦ ᎯᎠ ᏄᏪᏎᎴ ᎠᏕᎸ ᎤᎦᏘᏕᎯ, ᏫᏘᏯᏅ ᎪᎱᏍᏗ ᎠᎾᏛᎾᎯ ᎠᎴ ᏔᎫᏴᏏ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ, ᎣᏂᏱ ᎨᏥᏅᏒᎯ ᏔᎴᏅᏓ ᎢᎬᏱᏱᏃ ᎨᏥᏅᏒᎯ ᏘᏍᏆᎸᏓ


text:
ᏥᏌᏃ ᎤᏁᏨ ᎯᎠ ᏄᏪᏒᎩ; ᏝᏱᏥ ᎦᏔᎭ ᏄᏍᏛ ᎢᏥᎳᏲᎯᎲᎢ. ᏥᎪᏰᎵᏉ ᎨᏣᏗᏔᏍᏗ ᎤᎵᏍᏈᏗ ᎠᏟᏍᏛ ᎠᏴ ᏨᏓᎦᏗᏔᎯ, ᎠᎴᏍᎪ ᏰᎵᏉ ᏱᏕᏣᏬᏍᏓ ᎠᏴ ᎾᏍᎩ ᏨᏓᏴᏆᏬᏍᏔᏂ? ᏰᎵᏉ, ᎤᎾᏛᏅᎩ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯ ᎠᏆᏤᎵ ᎤᎵᏍᏈᏗ ᎠᏟᏍᏛ ᏓᏣᏗᏔᎯ, ᎠᎴ ᎠᏴ ᎥᏆᏬᏍᏙᏗ ᎨᏒ ᏙᏓᏰᏣᏬᏍᏔᏂ. ᏥᎦᏘᏏᏍᎩᏂ ᎠᎴ ᏥᎦᏍᎦᏂ ᎩᎶ ᎤᏪᏗᏱ ᎥᏝ ᎠᏴ ᎠᏆᏓᏁᏗ ᏱᎩ, ᎨᏥᏁᏗᏍᎩᏂᏃᏅ ᎨᏎᏍᏗ ᎾᏍᎩ ᎡᏙᏓ ᏧᏓᏁᎳᏁᎸᎯ.


text:
ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎢᏍᏕᎾ ᎢᏢ Ꮎ ᏨᏗᎦᏚᎭ, ᎩᎳᏉᏃ ᎢᏴᏛ ᏓᏰᏍᏗᏩᏛᎯ ᏐᏈᎵ-ᏗᎦᎵᎠᏅᎯᏛ ᎨᎵᏌᏕᏍᏗ, ᎠᎴ ᎠᎩᎾ ᎠᏘᏁᎮᏍᏗ, ᏕᏍᏕᎵᏌᏕᏒᎭ, ᎠᎴ ᏕᏍᎩᎾᏘᏃᎮᎸᎭ.


text:
ᏥᏌᏃ ᏭᏴᎸᎩ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎠᎴ ᏚᏄᎪᏫᏒᎩ ᏂᎦᏛ ᎠᏂᎾᏕᎩ ᎠᎴ ᎤᏂᏩᏍᎩ ᎾᎿ ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᏚᎷᏆᏗᏅᏒᎩ ᏚᏂᏍᎩᎸ ᎠᏕᎸ ᏗᏂᏁᏟᏴᏍᎩ, ᎠᎴ ᎫᎴ ᏗᏂᏍᎪᏂᎯ ᏗᏂᎾᏕᎩ ᎤᎾᏅᏗᏱ.


text:
ᎿᏉᏃ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ ᎤᎾᏙᎴᎰᏒ ᎤᏍᏆᏂᎪᏗᏳ ᏚᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᏗᏂᏲᎵ ᎤᏁᎷᎬ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎯᎠ ᎾᏂᏪᏍᎬᎢ, ᎰᏌᎾ ᏕᏫ ᎤᏪᏥ! ᎤᏣᏘ ᎤᏂᏐᏅᏤᎸᎩ;


text:
ᎠᎴ ᎯᎠ ᏂᎬᏩᏪᏎᎸᎩ; ᎭᏛᎩᏍᎪ ᎯᎠ ᏥᎾᏂᏪᎭ? ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎥᎥ, ᏝᏍᎪ ᎯᎸᎯᏳ ᎯᎠ ᏱᏥᎪᎵᏰᎣᎢ; ᏧᎾᏍᏗ ᏗᏂᏲᎵ ᎠᎴ ᏗᏂᏍᏓᎢ ᎠᏂᎰᎵ ᎤᏄᎪᏨᎯ ᏣᏩᏛᏙᏔᏅ ᎡᏣᎸᏉᏙᏗᏱ?


text:
ᎤᎪᎲᏃ ᏒᎦᏔ-ᎢᏳᏍᏗ ᏡᎬ ᏅᏃᎱᎶᏗ, ᎾᎿ ᏭᎷᏨᎩ; ᎠᏎᏃ ᎥᏝ ᎪᎱᏍᏗ ᏳᏩᏛᎮᎢ, ᎤᎳᏍᏚᏒ ᎤᏩᏒ; ᎯᎠᏃ ᏄᏪᏎᎸᎩ; ᏞᏍᏗ ᎢᎸᎯᏳ ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᏱᏣᏓᏔᏁᏍᏗ. ᎩᎳᏉᏃ ᎢᏴᏛ ᏒᎦᏔ-ᎢᏳᏍᏗ ᏡᎬ ᎤᏩᏴᏒᎩ.


text:
ᏥᏌ ᎤᏁᏨ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎢᏳᏃ ᏱᏦᎯᏳᎭ, ᎠᎴ ᏂᏣᏜᏏᏛᎡᎲᎾ ᏱᎩ, ᎥᏝ ᎯᎠᏉ ᏒᎦᏔ-ᎢᏳᏍᏗ ᏡᎬ ᏥᎾᎬᎦ ᏱᏅᎨᏣᏛᎦ, ᎾᏍᏉᏍᎩᏂ ᎯᎠ ᏱᏂᏥᏪᏎᎸ ᎯᎠ ᏦᏓᎸ, ᎭᏓᏅᎾ, ᎠᎴ ᎠᎺᏉᎯ ᏪᏣᏚᎦ, ᎠᏎ ᎾᏍᎩ ᎢᏳᎵᏍᏙᏗ.


text:
ᎤᏛᎾᏃ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎤᎷᏨ, ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᏧᎾᏛᏐᏅᎯ ᏴᏫ ᎠᏁᎲ ᎬᏩᎷᏤᎸᎩ ᏓᏕᏲᎲᏍᎬᎢ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᎦᏙ ᏣᎵᏍᎦᏍᏙᏗ ᎯᎠ ᎾᏍᎩ ᏥᏕᏣᎸᏫᏍᏓᏁᎭ? ᎠᎴ ᎦᎪ ᏣᏁᏤᎸᎯ?


text:
ᏥᏌᏃ ᎤᏁᏨ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎠᏴ ᎾᏍᎩ ᏑᏓᎴᎩ ᏓᏨᏯᏛᏛᏂ, ᎢᏳᏃ ᎾᏍᎩ ᎢᏍᎩᏃᏁᎸ ᎾᏍᎩ ᎠᏴ ᏓᏨᏃᏁᎵ ᎢᏳᏍᏗ ᎠᏆᎵᏍᎦᏍᏙᏛᎢ, ᎯᎠ ᎾᏍᎩ ᏥᏓᎩᎸᏫᏍᏓᏁᎭ.


text:
ᏣᏂ ᏥᏓᏓᏬᏍᎬᎩ ᎭᏢ ᏧᏓᎴᏁᎢ? ᎦᎸᎳᏗᏍᎪ, ᏴᏫᏉᎨ ᎠᏁᎲ ᏧᏓᎴᏁᎢ? ᎡᎳᏪᏱᏃ ᎤᎾᏓᏅᏖᎸᎩ, ᎯᎠ ᎾᏂᏪᏍᎬᎩ; ᎢᏳᏃ ᎦᎸᎳᏗ, ᏲᎦᏛᏅ, ᎦᏙᏃ Ꮭ ᏱᎡᏦᎢᏳᏁᎢ? ᏲᎪᏏ.


text:
ᎦᎪ ᎯᎠ ᎠᏂᏔᎵ ᎤᏙᏓ ᎤᏁᏨ ᏄᏛᏁᎴᎢ? ᎢᎬᏱ ᏭᎷᏤᎸᎯ, ᎥᎬᏪᏎᎸᎩ. ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᏧᎾᏤᏌᏘ ᎠᏂᎨᏴ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᏩᏂᏴᎯᎭ ᏕᎨᏥᎪᏂᎭ.


text:
ᏣᏂᏰᏃ ᏚᏳᎪᏛ ᏚᎸᏫᏍᏓᏁᎲ ᎢᏥᎷᏤᎸᎩ, ᎠᎴ ᎥᏝ ᏰᏦᎢᏳᏁᎢ, ᎠᏕᎸᏍᎩᏂ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᎨᏴ ᏧᎾᏤᏌᏘ ᏥᎬᏪᎯᏳᏅᎩ; ᏂᎯᏃ ᎢᏣᏙᎴᎰᏒ ᎥᏝ ᎣᏂ ᏱᏗᏥᏁᏟᏴᏎ ᏕᏣᏓᏅᏛ ᎡᏦᎢᏳᏗᏱ.


text:
ᏅᏩᏓᎴ ᏓᏟᎶᏍᏛ ᎢᏣᏛᎬᎦ; ᎡᎮ ᎩᎶ ᎠᏍᎦᏯ ᎦᏁᎳ, ᎾᏍᎩ ᏖᎸᎳᏗ ᏚᏫᏎᎢ, ᎠᎴ ᎤᏐᏲᎴ ᎬᏩᏚᏫᏛ, ᎠᎴ ᎤᏍᎪᏎ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎪᏢᏗᏱ, ᎠᎴ ᎤᏁᏍᎨᎮ ᎢᏅ ᎢᎦᏘ, ᎠᎴ ᏚᏙᎳᏍᏔᏁ ᏠᎨᏏ ᏧᏂᎸᏫᏍᏓᏁᎯ, ᎢᏅᏃ ᏭᎶᏎᎢ.


text:
ᏥᏌᏃ ᎯᎠ ᏂᏑᏪᏎᎸᎩ; ᏝᏍᎪ ᎢᎸᎯᏳ ᏱᏥᎪᎵᏰᎣ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ? ᎠᎾᏁᏍᎨᏍᎩ ᎤᏂᏲᎢᏎᎸᎯ ᏅᏯ ᏄᎬᏫᏳᏒ ᎤᏅᏏᏴ ᎠᏗ ᏄᎵᏍᏔᏅ; ᎾᏍᎩ ᎯᎠ ᏱᎰᏩ ᏄᏛᏁᎸ, ᎠᎴ ᎤᏍᏆᏂᎪᏗᏳ ᏕᏓᎧᏂᏍᎬᎢ.


text:
ᏔᎵᏁᏃ ᏅᏩᎾᏓᎴ ᏧᏅᏏᏓᏍᏗ ᏚᏅᏎᎢ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎯᎠ ᏫᏂᏗᏥᏪᏏ ᏫᎨᏥᏯᏅᏛ; ᎬᏂᏳᏉ ᎠᏆᏛᏅᎢᏍᏗ ᎠᎵᏍᏓᏴᏗ, ᏗᏆᏤᎵ ᏩᎦ ᎠᎴ ᏗᎦᎵᏦᏔᏅᎯ ᏚᏂᎸ, ᏂᎦᏗᏳᏃ ᎠᏛᏅᎢᏍᏔᏃᏅᎯ; ᏕᎨᎦᏨᏍᏗᏍᎬ ᎢᏥᎷᎩ.


text:
ᎿᏉᏃ ᎤᎬᏫᏳᎯ ᎯᎠ ᏂᏚᏪᏎᎴ ᎨᏥᏅᏏᏓᏍᏗ; ᎡᏣᎸᏣ ᏧᏪᏰᏂ ᎠᎴ ᏧᎳᏏᏕᏂ; ᎠᎴ ᎡᏥᎾᏫᏛ, ᎠᎴ ᎥᏙᏱᏗᏢ ᏧᎵᏏᎬ ᏪᏣᏓᎤᎦ. ᎾᎿ ᏓᏂᏴᎨᏍᏗ ᎠᎴ ᏓᏂᎸᏓᎩᏍᎨᏍᏗ ᏓᏂᏄᏙᎬᎢ.


text:
ᏚᏂᏅᏒᎩᏃ ᏤᏙᎲ ᎬᏩᏂᏍᏓᏩᏗᏙᎯ ᎠᎴ ᎡᎶᏛ ᎨᏩᏍᏕᎵᏍᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᏔᏕᏲᎲᏍᎩ, ᎣᏥᎦᏔᎭ ᎤᏙᎯᏳᎩᏯ ᎨᏒ ᏂᎯ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᏚᏳᎪᏛ ᏕᎭᏕᏲᎲᏍᎬᎢ, ᎥᏝ ᎠᎴ ᏴᏫ ᏱᏘᎾᏰᏍᎦ, ᎥᏝᏰᏃ ᏄᎾᏍᏛᏉ ᏴᏫ ᏱᏘᎸᏉᏙᎢ.


text:
ᎯᎠ ᏄᏂᏪᏒᎩ; ᏔᏕᏲᎲᏍᎩ, ᏱᏏ ᎤᏁᏤ ᎯᎠ ᏄᏪᏎᎢ; ᎢᏳᏃ ᎠᏍᎦᏯ ᎠᏲᎱᏍᎨᏍᏗ ᏧᏪᏥ ᎾᏁᎲᎾ ᎨᏎᏍᏗ, ᏗᎾᏓᏅᏟ ᎠᏓᏰᎨᏍᏗ ᎤᏓᏴᏛ, ᎾᏍᎩᏃ ᏓᏛᎯᏍᏓᏁᎮᏍᏗ ᏗᏂᏲᎵ ᏗᎾᏓᏅᏟ.


text:
ᎾᏍᎩ ᎯᏳᏍᏗ ᏂᎦᎥ ᎪᎱᏍᏗ ᏗᏥᎧᎿᏩᏚᎦ ᎨᏦᏎᎮᏍᏗ ᏕᏥᎧᎿᏩᏕᎨᏍᏗ ᎠᎴ ᎾᏍᎩ ᏂᏣᏛᏁᎮᏍᏗ; ᎠᏎᏃ ᎾᏍᎩ ᎾᎾᏛᏁᎲᎢ ᏞᏍᏗ ᏱᏂᏣᏛᏁᎮᏍᏗ; ᎠᏂᏁᎪᏰᏃ ᎠᏎᏃ ᎥᏝ ᎾᏍᎩ ᏱᎾᎾᏛᏁᎰᎢ


text:
ᏂᎯᏍᎩᏂ ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏗᏦᏪᎵᏍᎩ ᎠᎴ ᎢᏥᏆᎵᏏ ᎢᏣᏠᎾᏍᏗ! ᏕᏥᏍᏚᏁᎰᏰᏃ ᏴᏫ ᎦᎸᎳᏗ ᎤᏤᎵᎪᎯ; ᎥᏝᏰᏃ ᎢᏨᏒ ᏱᏥᏴᎯᎰᎢ, ᎠᎴ ᎥᏝ ᎤᎾᏁᎳᎩ ᏩᏂᏴᎭ ᏱᏗᏤᎵᏎᎰ ᏩᏂᏴᎯᎯ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏗᏦᏪᎵᏍᎩᎠᎴ ᎢᏥᏆᎵᏏ ᎢᏣᏠᎾᏍᏗ! ᏕᏥᏒᏁᎰᏰᏃ ᏧᏃᏑᎶᏨᎯ ᏓᏂᏁᎸᎢ, ᎠᎴ ᎢᏣᏠᎾᏍᏛ ᎪᎯᏗᏳ ᎢᏣᏓᏙᎵᏍᏗᏍᎪᎢ. ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏟᎯᏳ ᎢᎦᎢ ᎢᏥᎩᎵᏲᎢᏍᏗ ᎨᏎᏍᏗ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏗᏦᏪᎵᏍᎩ ᎠᎴ ᎢᏥᏆᎵᏏ ᎢᏣᏠᎾᏍᏗ! ᏕᏣᏕᏲᎰᏰᏃ ᎠᎺᏉᎯ ᎠᎴ ᎦᏙᎯ ᎡᏥᏲᎰ ᎠᏏᏴᏫ ᏄᏍᏛ ᎢᏦᎯᏳᏒ ᎪᎯᏳᎲᏍᎩ ᎢᏰᏨᏁᏗᏱ, ᎠᎴ ᎾᏍᎩ ᏁᏨᎦ ᏔᎵ ᎢᏳᏩᎫᏗ ᎤᏟ ᏨᏍᎩᏃᎢ ᎤᏪᏥ ᏁᏨᏁᎰ ᎡᏍᎦᏉ ᎢᏨᏒ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ, ᏗᏥᎨᏫ ᏗᏣᏓᏘᏂᏙᎯ! ᎯᎠ ᎢᏥᏪᏍᎩ; ᎩᎶ ᎢᎠᏎᎵᏛᏍᎨᏍᏗ ᎢᎧᏁᎢᏍᏗᏍᎨᏍᏗ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᏎᏉᏉ ᎾᏍᎩ; ᎩᎶᏍᎩᏂ ᎢᎧᏁᎢᏍᏗᏍᎨᏍᏗ ᎠᏕᎸ ᏓᎶᏂᎨ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᎲᎢ, ᎾᏍᎩ ᎠᏍᏓᏱᏳ ᎤᏚᏓᎳ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏗᏦᏪᎵᏍᎩ ᎠᎴ ᎢᏥᏆᎵᏏ ᎢᏣᏠᎾᏍᏗ! ᎠᏍᎪᎯᏁᏰᏃ ᎢᏣᎫᏱᏍᎪ ᏒᏟ ᎠᎴ ᎡᏒ ᎠᎴ ᎦᎻᏂ; ᏕᏥᏃᎯᏯᏍᎪᏃ ᎤᏟ ᎤᎵᏍᎨᏛᏯ ᎨᏒ ᏗᎧᎿᏩᏛᏍᏗ, ᏚᏳᎪᏛ ᎨᏒᎢ, ᎠᎴ ᎠᏓᏙᎵᏍᏗᏱ, ᎠᎴ ᎪᎯᏳᏗᏱ. ᎾᏍᎩᏍᎩᏂ ᎯᎠ ᏱᏂᏣᏛᏁᎴᎢ, ᎠᎴ ᏐᎢ ᏂᏥᏃᎯᏴᎾᏉ ᏱᎨᏎᎢ.


text:
ᎤᏂᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏗᏦᏪᎵᏍᎩ ᎠᎴ ᎢᏥᏆᎵᏏ ᎢᏣᏠᎾᏍᏗ! ᎢᏦᏑᎴᏍᎪᏰᏃ ᎦᏚᎢᏗᏢ ᎤᎵᏍᏈᏗ ᎠᎴ ᎠᏖᎵᏙ, ᎠᏎᏃ ᎠᏫᏂᏗᏢ ᎤᎧᎵᏨᎯ ᎨᏐ ᎠᏎᏉ ᎠᏓᎩᎡᏗ ᎨᏒᎢ ᎠᎴ ᏚᏳᎪᏛ ᏂᎨᏒᎾ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏗᏦᏪᎵᏍᎩ ᎠᎴ ᎠᏥᏆᎵᏏ ᎢᏣᏠᎾᏍᏗ! ᎾᏍᎩᏯᏉᏰᏃ ᏂᎯ ᏧᏁᎬ ᎢᏗᎬᏁᎸᎯ ᏓᏤᎵᏍᏛᎢ, ᎾᏍᎩ ᎦᏚᎢᏗᏢ ᎤᏙᎯᏳᎯ ᏧᏬᏚᎯᏳ ᏥᎨᏐᎢ, ᎠᏎᏃ ᎠᏫᏂᏗᏢ ᏧᎧᎵᏨᎯ ᏥᎨᏐ ᏧᏂᏲᎱᏒᎯ ᏧᏂᎪᎳ ᎠᎴ ᏂᎦᎥ ᎦᏓᎭ ᎨᏒᎢ


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎬᏂᏳᏉ ᏕᏥᏅᎵ ᎾᎿ ᏗᏤᎲ ᎠᎾᏙᎴᎰᏍᎩ ᎠᎴ ᎠᏂᎦᏔᎿᎢ ᎠᎴ ᏗᏃᏪᎵᏍᎩ; ᎢᎦᏛᏃ ᏙᏓᏥᎵ ᎠᎴ ᏙᏓᏣᏛᏂ ᏓᏓᎿᏩᏍᏛᎢ, ᎢᎦᏛᏃ ᏙᏓᏥᎵᎥᏂᎵ ᏗᏥᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᎤᏲ ᏂᏙᏓᏨᏁᎵ ᏕᎦᏚᎿᎥᎢ;


text:
ᎾᏍᎩ ᎢᏥᎷᏤᏗᏱ ᏂᎦᏛ ᎣᏍᏛ ᎩᎬ ᎡᎶᎯ ᎤᏤᏪᏨᎯ, ᎤᏓᏅᏘ ᎡᏈᎵ ᎤᎩᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᏤᎦᎳᏯ ᎤᎩᎬ ᏇᎵᎦᏯ ᎤᏪᏥ ᎤᏛᏍᏗ, ᎾᏍᎩ ᏤᏥᎸ ᎤᏜᏅᏛ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᏥᎸᏃ-ᎨᎳᏍᏗᏱ.


text:
ᏥᎷᏏᎵᎻ! ᏥᎷᏏᎵᎻ! ᎠᎾᏙᎴᎰᏍᎩ ᏘᎯᎯ, ᎠᎴ ᎨᏣᎷᏤᏗᏱ ᎨᏥᏅᏒᎯ ᏅᏯ ᏛᏂᏍᏗᏍᎩ! ᏯᏃᎩᏳ ᎠᏆᏚᎵᏍᎬ ᎦᏥᏯᏟᏐᏗᏱ ᏗᏤᏥ, ᎾᏍᎩᏯ ᏣᏔᎦ ᏣᏕᎦᏟᏏᏍᎪ ᏧᏪᏥ ᎠᏂᏛ ᏗᎧᏃᎨᏂ ᎭᏫᏂᏗᏢ; ᎠᏎᏃ ᎥᏝ ᏱᏣᏚᎵᏍᎨᎢ.


text:
ᎣᎵᏩᏲᏃ ᎤᏌᎯᎸ ᎤᏬᎸᎢ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎤᏅᏒ ᎨᏒ ᎬᏩᎷᏤᎸᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᏍᎩᏃᎲᏏ ᎯᎳᎪ ᎢᏳ ᎯᎠ ᎾᏍᎩ ᏅᏓᎦᎵᏍᏔᏂ; ᎠᎴ ᎦᏙ ᎤᏍᏗ ᎤᏰᎸᏛ ᎨᏎᏍᏗ ᏣᎷᎯᏍᏗᏱ, ᎠᎴ ᎪᎯ ᎨᏒ ᎤᎵᏍᏆᏗᏍᏗᏱ?


text:
ᎠᎴ ᎢᏣᏛᎩᏍᎨᏍᏗ ᏓᎿᏩ ᎠᎴ ᎠᏂᏃᎮᎵᏙᎲ ᏓᎿᏯ; ᎢᏤᏯᏔᎮᏍᏗ ᏞᏍᏗ ᎤᏪᎵᎯᏍᏗ ᏱᏂᏣᎵᏍᏓᏁᎴᏍᏗ; ᎾᏍᎩᏰᏃ ᏂᎦᏗᏳ ᎠᏎ ᎢᏳᎵᏍᏙᏗ, ᎠᏎᏃ ᎤᎵᏍᏆᏗᏍᏗᏱ ᎨᏒ ᎠᏏ ᎨᏎᏍᏗ.


text:
ᏧᎾᏓᎴᏅᏛᏰᏃ ᏴᏫ ᏙᏛᎾᎴᏂ ᏙᏛᎾᏓᏡᏔᏂ, ᎠᎴ ᎠᏰᎵ ᏚᏃᏢᏩᏗᏒ ᏙᏛᎾᏓᏡᏔᏂ, ᎠᎴ ᏓᎪᏄᎶᏏᏙᎮᏍᏗ, ᎠᎴ ᎥᏳᎩᎯᏳ ᏂᎦᎵᏍᏔᏂᏙᎮᏍᏗ, ᎠᎴ ᎦᏙᎯ ᏓᎵᏖᎸᏂᏙᎮᏍᏗ.


text:
ᏛᏂᎾᏄᎪᏥᏰᏃ ᎤᎾᏠᎾᏍᏗ ᎦᎶᏁᏛ ᎠᎴ ᎤᎾᏠᎾᏍᏗ ᎠᎾᏙᎴᎰᏍᎩ, ᎠᎴ ᎠᏂᎾᏄᎪᏫᏍᎨᏍᏗ ᎦᎸᏉᏗᏳ ᎤᏰᎸᏛ ᎠᎴ ᎤᏍᏆᏂᎪᏗ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᏰᎵ ᎢᎬᏩᎵᏍᏙᏗ ᏱᎩ ᏱᏓᏂᎶᏄᎲᎵ ᎾᏍᏉ ᎨᎦᏑᏰᏛ.


text:
ᎢᎬᏪᏅᏓᏉ ᎣᏂ ᎾᏍᎩ ᎾᎯᏳ ᎠᎩᎵᏯ ᎦᎶᏐᏅᎭ, ᏅᏙ ᎢᎦ ᎡᎯ ᏛᎵᏏᎲᏏ, ᎠᎴ ᏅᏙ ᏒᏃᏱ ᎡᎯ ᎥᏝᎢᎦ ᏳᏘᏍᏕᏍᏗ, ᎠᎴ ᏃᏈᏏ ᏛᏂᏅᎪᎠᏏ, ᎠᎴ ᎤᏂᏣᏘ ᎦᎸᎶᎢ ᏣᏂᎧᎳ ᏛᎾᎵᏖᎸᏂ.


text:
ᎿᏉᏃ ᎦᎸᎶᎢ ᏓᎦᎾᏄᎪᏥ ᏴᏫ ᎤᏪᏥ ᎤᏤᎵ ᎤᏰᎸᏛᎢ, ᎠᎴ ᎿᏉ ᏂᎦᏛ ᏓᏂᎳᏍᏓᎸ ᎡᎶᎯ ᏙᏛᏂᏴᎳᏏ, ᎠᎴ ᏛᏂᎪᎯ ᏴᏫ ᎤᏪᏥ ᏣᎢᏎᏍᏗ ᎤᎶᎩᎸ ᎦᎸᎶᎢ, ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎠᎴ ᎤᏣᏘ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏄᏬᏍᏕᏍᏗ.


text:
ᎯᏍᎩᏃ ᎢᏯᎦᏴᎵ ᏣᏥᏁᎸᎯ ᎤᎷᏤᎢ, ᎠᎴ ᏚᏲᎴ ᏅᏩᎾᏓᎴ ᎯᏍᎩ ᎢᏯᎦᏴᎵ ᎠᏕᎸ, ᎯᎠ ᏄᏪᏎᎢ; ᏍᎩᎾᏝᎢ, ᎯᏍᎩ ᎢᏯᎦᏴᎵ ᎠᏕᎸ ᏕᏍᎩᏲᎯᏎᎸᎩ; ᎬᏂᏳᏉ ᏅᏩᎾᏓᎴ ᎯᏍᎩ ᎢᏯᏕᏴᎵ ᎬᎩᏁᏉᏤᎸ.


text:
ᎤᎾᏝᎢᏃ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎣᏏᏳ! ᎰᏍᏛ ᎠᎴ ᎯᎦᎵᏯ ᎡᏣᏅᏏᏓᏍᏗ! ᏚᏳᎪᏛ ᏂᏣᏛᏁᎸ ᎤᏍᏗ ᏧᏓᎴᏅᏛ ᏕᏣᎸᏫᏍᏓᏁᎸᎢ; ᎤᏣᏘ ᏧᏓᎴᏅᏛ ᏣᎬᏫᏳᏌᏕᎩ ᏅᏓᎬᏴᏁᎵ; ᎯᏴᎭ ᎣᏍᏛ ᎠᏓᏅᏓᏗᏍᏗᏱ ᏣᎾᏝᎢ ᎤᏤᎵᎪᎯ.


text:
ᎤᎾᏝᎢ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎣᏏᏳ! ᎰᏍᏛ ᎠᎴ ᎯᎦᎵᏯ ᎡᏣᏅᏏᏓᏍᏗ! ᏚᏳᎪᏛ ᏂᏣᏛᏁᎸ ᎤᏍᏗ ᏧᏓᎴᏅᏛ ᏕᏣᎸᏫᏍᏓᏁᎸᎢ; ᎤᏣᏘ ᏧᏓᎴᏅᏛ ᏣᎬᏫᏳᏌᏕᎩ ᏅᏓᎬᏴᏁᎵ; ᎯᏴᎭ ᎣᏍᏛ ᎠᏓᏅᏓᏗᏍᏗᏱ ᏣᎾᏝᎢ ᎤᏤᎵᎪᎯ.


text:
ᎿᏉᏃ ᏌᏉ ᎢᏯᏕᏴᎵ ᏣᏥᏁᎸᎯ ᎤᎷᏨ ᎯᎠ ᏄᏪᏎᎢ; ᏍᎩᎾᏝᎢ, ᎬᎦᏔᎲᎩ, ᎯᏍᏓᏱᏳ ᎨᏒᎢ, ᎠᎴ ᎯᏍᎫᏕᏍᎬᎢ ᎾᎿ ᏂᏣᏫᏒᎾ ᎨᏒᎢ, ᎠᎴ ᎱᏖᏍᎬᎢ ᎾᎿ ᏂᏣᎴᎳᏛᏅᎾ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᎤᎬᏫᏳᎯ ᎯᎠ ᏂᏙᏓᎦᏪᏎᎵ ᎠᎦᏘᏏ ᎢᏗᏢ ᎠᏂᏙᎾᎢ; ᎡᏤᎾ, ᎡᏙᏓ ᎢᏥᎸᏉᏔᏅᎯ, ᎢᏣᏤᎵ ᏫᏂᎦᎵᏍᏓ ᎤᏤᎵᎪᎯ ᎡᏣᎵᏍᎪᎸᏓᏁᎸᎯ ᎡᎶᎯ ᏧᏙᏢᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ.


text:
ᎯᎠᏃ ᎾᏍᏉ ᏂᏙᏓᎦᏪᏎᎵ ᎠᎦᏍᎦᏂ ᎢᏗᏢ ᎠᏂᏙᎾᎢ; ᏍᎩᏯᏓᏅᏏ, ᎡᏥᏍᎦᏨᎯ, ᏫᎾᏍᏛᎾ ᎠᏥᎸᏱ ᏗᎨᏒ ᏫᏥᎶᎯ, ᎾᏍᎩ ᎠᏍᎩᎾ ᎠᎴ ᏧᏤᎵ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎨᎪᏢᎾᏁᎸᎯ.


text:
ᎾᏍᏉᏃ ᎾᏍᎩ ᏛᏂᏁᏥ, ᎯᎠ ᏅᏓᎬᏩᏪᏎᎵ, ᏣᎬᏫᏳᎯ, ᎢᎳᎩᏳ ᎢᏨᎪᎡ ᏣᏲᏏᏍᎨᎢ, ᎠᎴ ᏣᏔᏕᎩᏍᎨᎢ, ᎠᎴ ᏁᏣᎦᏔᎲᎾ ᎨᏎᎢ, ᎠᎴ ᏣᏰᎸᎭ ᎨᏎᎢ, ᎠᎴ ᏣᏢᎨᎢ, ᎠᎴ ᏗᏓᏍᏚᏗᏱ ᎡᏣᏍᏚᎮᎢ, ᏂᏨᏍᏕᎸᎲᎾᏃ ᎨᏎᎢ?


text:
ᎯᎠᏃ ᏄᏪᏒᎩ; ᎢᏤᎾ ᏗᎦᏚᎲᎢ, ᎾᎿ ᏤᎲ ᎠᏍᎦᏯ, ᎯᎠᏃ ᎾᏥᏪᏎᎸᎭ; ᏗᏕᏲᎲᏍᎩ ᎯᎠ ᏂᎦᏪᎭ; ᎿᏉ ᎠᎩᏍᏆᎸᎡᎵᏗ, ᎬᎩᏍᏓᏩᏗᏙᎯ ᎯᏁᎸ ᏓᏲᏥᏍᏆᏂᎪᏔᏂ ᎧᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏂᎯ ᏂᏥᎥ ᏙᏓᏦᏕᎵ ᎪᎯ ᏒᏃᏱ ᏥᎩ, ᎠᏴ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ. ᎯᎠᏰᏃ ᏂᎬᏅ ᎢᎪᏪᎳ, ᏓᏥᏴᏂᎵ ᎠᏫ-ᏗᎦᏘᏯ, ᎠᏫᏃ ᎤᎾᏓᏡᎬ ᏛᎾᏗᎦᎴᏲᏥ.


text:
ᎤᏍᏗᏱᏛᏃ ᎤᏗᏗᏢᏍᏙᏗ ᎢᏴᏛ ᏭᎷᏤᎢ, ᎠᎴ ᎤᎵᏯᏍᏚᏁᎢ, ᎠᎴ ᎤᏓᏙᎵᏍᏔᏁᎢ, ᎯᎠ ᏄᏪᏎᎢ; ᎡᏙᏓ, ᎢᏳᏃ ᏰᎵ ᎢᎬᏩᎵᏍᏙᏗ ᎨᏎᏍᏗ ᏩᎩᎶᎯᏏᏉ ᎯᎠ ᎤᎵᏍᏈᏗ; ᎢᏝᏍᎩᏂᏃᏅ ᎠᏴ ᏄᏍᏛ ᎦᏓᏅᏖᏍᎬᎢ, ᏂᎯᏍᎩᏂ.


text:
ᎿᏉᏃ ᏗᎤᎷᏨ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎠᏂᏅᎢ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎿᏉ ᎢᏥᎵᏅᎩ ᎠᎴ ᎢᏥᏯᏪᏐᎸᎦ; ᎬᏂᏳᏉ ᎢᏳ ᎨᏒ ᎤᏍᏆᎸᎯᏗ, ᏴᏫᏃ ᎤᏪᏥ ᎠᎦᏡᏔᏅ ᎤᏂᏁᎫᏥᏛ ᏴᏫ ᏕᎨᏥᏲᎯᏎᎸ.


text:
ᎠᏏᏉᏃ ᎦᏬᏂᏍᎬᎢ ᎬᏂᏳᏉ ᏧᏓᏏ ᎠᏏᏴᏫ ᏔᎳᏚ ᎢᏯᏂᏛ ᎨᏒ ᎤᎷᏨᎩ, ᎠᎴ ᏓᏘᏁᎲᎩ ᎤᏂᏣᏘ ᏴᏫ, ᎠᏰᎳᏍᏗ-ᏗᎦᏅᎯᏛ ᎠᎴ ᎠᏓ ᏗᏂᏁᎯ, ᏅᏓᎬᏂᏅᏏᏛ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸᎠᏁᎶᎯ ᏗᏂᎳᏫᎩ ᎠᏁᎲ ᏴᏫ.


text:
ᎾᎯᏳᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎸᎩ ᎤᏂᏣᏘ; ᏥᎪ ᎦᏃᏍᎩᏍᎩ ᏥᏥᏲᎰ ᎾᏍᎩᏯ ᎢᏥᎷᎩ ᏍᎩᏂᏴᎯᎦ, ᎠᏰᎳᏍᏗᏗᎦᏅᎯᏛ ᎠᎴ ᎠᏓ ᏗᏥᏁᎯ? ᏂᏚᎩᏨᏂᏒ ᎢᏧᎳᎭ ᎢᏗᏅᎩ ᏕᎦᏕᏲᎲᏍᎬᎩ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎥᏝᏃ ᏱᏍᎩᏂᏱᏍᎨᎢ.


text:
ᎠᏎᏃ ᏥᏌ ᎡᎳᏪᏱᏉ ᎨᏎᎢ. ᏄᎬᏫᏳᏒᏃ ᎠᏥᎸ-ᎨᎶᎯ ᎢᎤᏁᏨ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎬᎳᏲᏏ ᎤᏁᎳᏅᎯ ᎬᏂᏛ ᎯᏁᎢᏍᏙᏗᏱ, ᏍᎩᏃᎲᏏ, ᏥᎪ ᏂᎯ ᎦᎶᏁᏛ ᎤᏁᎳᏅᎯ ᎤᏪᏥ?


text:
ᎿᏉᏃ ᏧᏓᏏ ᎾᏍᎩ ᎤᎶᏄᎮᎸᎯ ᎤᏙᎴᎰᏒ ᏓᎫᎪᏓᏁᎸᎢ ᎤᏁᏟᏴᏎ ᎤᏓᏅᏛᎢ, ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᏧᎾᏛᏐᏅᎯ ᏙᎤᏲᎮᎴ ᏦᎠᏍᎪᎯ ᎠᏰᎵ-ᎠᏕᎸ ᏧᎾᎬᏩᎶᏗ,


text:
ᎿᏉᏃ ᎤᏙᎯᏳᏁ ᏧᏁᏤ ᏤᎵᎹᏯ ᎠᏙᎴᎰᏍᎩ, ᎯᎠ ᏥᏄᏪᏎᎢ; ᎠᎴ ᏚᏂᎩᏒᎩ ᏦᎠᏍᎪᎯ ᎠᏰᎵ-ᎠᏕᎸ ᎾᏍᎩ ᎾᏧᎬᏩᏔᏅᎯ, ᎾᏍᎩ ᏣᏥᎬᏩᎶᏔᏅᎯ, ᎢᏏᎵ ᏧᏪᏥ ᏧᏂᎬᏩᎶᏔᏅᎯ,


text:
ᎤᏬᎸᏃ ᏗᎫᎪᏙᏗᏱ ᎦᏍᎩᎸᎢ ᎤᏓᎵᎢ ᏧᏓᏅᏎᎢ, ᎯᎠ ᏅᏧᏪᏎᎴᎢ; ᏞᏍᏗ ᏂᎯ ᎪᎱᏍᏗ Ꮎ ᎾᏍᎦᏅᎾ ᎠᏍᎦᏯ ᎤᎬᏩᎵ ᏱᏗᏣᎸᏫᏍᏓᏁᎴᏍᏗ, ᎤᏣᏘᏰᏃ ᏥᎩᎵᏲᎩ ᎪᎯ ᎢᎦ ᎦᏍᎩᏓᏍᎬᎢ ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᏍᎬᎢ.


text:
ᏆᎴᏗ ᎤᏙᎴᎰᏒ ᏗᎬᏩᏎᎪᎩᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏓᏑᏰᏛ ᎤᎾᎵᏔᎸᏅᎩ, ᎠᎹ ᏬᏁᎩᏎᎢ, ᎠᎴ ᏚᏑᎴᎮ ᎤᏂᏣᏘ ᎠᏂᎦᏔᎲᎢ, ᎯᎠ ᏄᏪᏎᎢ; ᎠᏴ ᎥᏝ ᎠᎩᏍᎦᏅᏨᎯ ᏱᎩ ᎯᎠ ᏄᏍᎦᏅᏨᎾ ᏴᏫ ᎤᎩᎬ. ᏂᎯ ᎢᏣᎦᏌᏯᏍᏓ.


text:
ᎠᎴ ᎤᏂᏍᏕᏲᏅ ᎠᎵᏍᏚᎶ ᏧᏣᏲᏍᏗ ᎪᏢᏔᏅᎯ, ᎤᏂᏍᏚᎳᏁᎢ, ᎠᎴ ᎦᎾᏍᏓ ᎠᎦᏘᏏ ᎢᏗᏢ ᎤᎾᏒᎦᎳᏗᏍᏔᏁᎢ; ᎠᎴ ᏓᎾᎵᏂᏆᏅᏁᎮ ᎠᎴ ᎠᎾᏕᎰᏗᏍᎨᎢ, ᎯᎠ ᎾᏂᏪᏍᎨᎢ; ᎢᏨᏲᎵᎦ, ᏣᎬᏫᏳᎯ ᎠᏂᏧᏏ ᎤᎾᏤᎵᎦ.


text:
ᎯᎠ ᎾᏂᏪᏍᎨᎢ; ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎯᏲᏍᏗᏍᎩ, ᏦᎢᏉᏃ ᎢᎦ ᎯᏰᎢᎵᏙᎯ ᎭᏁᏍᎨᏍᎩ, ᎭᎵᏍᏕᎸ ᏨᏒ; ᎢᏳᏃ ᏂᎯ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎨᏎᏍᏗ, ᏓᏓᎿᏩᏍᏛ ᎡᎭᏠᎠᎯ.


text:
ᏦᎢᏁᏃ ᎢᏳᏟᎶᏛ ᎢᏴ ᎧᏔᏩᏗᏒ ᎤᏒᎯᏰᏱ ᎢᏗᏢ ᏥᏌ ᎤᏁᏤ ᎠᏍᏓᏯ, ᎯᎠ ᏄᏪᏎᎢ; ᎢᎳ, ᎢᎳ, ᎳᎹ ᏌᏆᏓᏂ? ᎾᏍᎩ ᎯᎠ ᏄᏍᏗ ᎦᏛᎬᎢ, ᎤᏁᎳᏅᎯ ᎠᏆᏤᎵᎦ, ᎤᏁᎳᏅᎯ ᎠᏆᏤᎵᎦ, ᎦᏙᏃ ᎢᏍᏮᏕᏨᏉ?


text:
ᎿᏉᏃ ᎠᏍᎪᎯᏧᏈ ᏗᏓᏘᏂᏙᎯ ᎠᎴ ᎾᏍᎩ ᎾᎢᏧᎳᎭ ᏥᏌ ᎬᏩᏯᏫᏍᎩ, ᎤᎾᏙᎴᎰᏒ ᎦᏙᎯ ᎠᎵᏖᎸᎲᏍᎬᎢ, ᎠᎴ ᎾᏍᎩ ᏄᎵᏍᏔᏂᏙᎸᎢ, ᎤᏣᏖ ᎤᏂᏍᎦᎴᎢ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᎤᏙᎯᏳᎯᏯ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎨᏎ ᎯᎠ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᏁᎩ ᎠᏍᏓᏯ ᎢᏳᏅᏁᏗᏱ ᎠᏤᎵᏍᏛᎢ ᏦᎢᏁ ᎢᎦ ᎢᎪᎯᏛ, ᎬᏩᏍᏓᏩᏗᏙᎯᏰᏃ ᏒᏃᏱ ᏯᏂᎷᎩ ᏱᎬᏩᏃᏍᎩ, ᎯᎠᏃ ᏱᏂᏓᏂᏪᏏ ᏴᏫ; ᏧᏲᎱᏒ ᏙᎤᎴᏅ; ᎣᏂᏱᏃ ᎤᎾᏠᏄᎮᎸᎢ ᎤᏟ ᎤᏲᎢᏳ ᏱᎩ ᎡᏍᎦᏉ ᎢᎬᏱᏱ.


text:
ᏂᎦᏛᏃ ᎤᏂᏍᏆᏂᎪᏎᎢ; ᎠᎴ ᎤᏅᏒ ᎨᏒ ᏚᎾᏓᏛᏛᏁᎢ, ᎯᎠ ᎾᏂᏪᏍᎨᎢ; ᎦᏙ ᎤᏰᎸᏗ ᎯᎠ? ᎦᏙ ᎤᏍᏗ ᎯᎠ ᎢᏤ ᏗᏕᏲᏗ ᎨᏒᎢ? ᎤᎵᏂᎩᏛᏰᏃ ᎤᎲ ᎬᏗ ᏕᎧᏁᏤᎰ ᎠᏂᎦᏓᎭ ᏗᏓᏅᏙ, ᎠᎴ ᎬᏬᎯᏳᎲᏍᎪᎢ.


text:
ᎠᎴ ᎯᎠ ᏄᏪᏎᎴᎢ, ᎮᏯᏔᎮᏍᏗ ᏞᏍᏗ ᎩᎶ ᎪᎱᏍᏗ ᏥᎯᏃᏁᎵ; ᎮᎾᏉᏍᎩᏂ, ᎬᏂᎨᏒ ᏫᏂᏯᏛᏂᏏ ᎠᏥᎸᎨᎶᎯ, ᎠᎴ ᏩᎵᏍᎪᎸᏓ ᏣᏓᏅᎦᎸᎲ ᎤᎬᏩᎵ, ᎾᏍᎩ ᏱᏏ ᎤᏁᏨ ᎠᎵᏍᎪᎸᏙᏗᏱ, ᎾᏍᎩ ᎤᎾᏙᎯᏳᎾᏁᏗᏱ.


text:
ᎠᏎᏃ ᎤᏄᎪᏨ, ᎤᎴᏅᎮ ᎤᏣᏘ ᏚᏰᎵᎯᏍᏔᏁᎢ, ᎠᎴ ᏚᏃᏣᎳᏁ ᎾᏍᎩ, ᎾᏍᎩᏃ ᎢᏳᏍᏗ ᏥᏌ ᎥᏝ ᎿᏉ ᎬᏂᎨᏒ ᏫᎬᏩᏴᏍᏗ ᏱᎨᏎ ᎦᏚᎲᎢ, ᏙᏱᏗᏢᏉᏍᎩᏂ ᎢᎾᎨ ᏕᎨᏌᏗᏒ ᎡᏙᎮᎢ; ᏂᎬᎾᏛᏉᏃ ᏂᏙᏓᏳᏂᎶᏒᎯ ᎬᏩᎷᏤᎮᎢ.


text:
ᎩᎳᏉᏃ ᎢᏴᏛ ᏚᎴᏁᎢ, ᎤᏁᏒᏃ ᎠᏤᏍᏙ, ᎤᏄᎪᏤ ᏂᎦᏛ ᎠᏂᎦᏔᎲᎢ; ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᎦᏛ ᎤᏂᏍᏆᏂᎪᏎᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᏂᎸᏉᎳᏁ ᎯᎠ ᏄᏂᏪᏎᎢ; ᎥᏝ ᎢᎸᎯᏳ ᎾᏍᎩ ᎢᏳᏍᏗ ᏲᎩᎪᎰᎢ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ <n>[ᏥᏌ]</n> ᎦᏅᎬ ᎠᎵᏍᏓᏴᎲᏍᎬ ᎾᏍᎩ ᎦᏁᎸᎢ, ᎤᏂᏣᏖ ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᎦᎾ ᎢᏧᎳᎭ ᏓᏂᏅᎨ ᏥᏌ ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ; ᎤᏂᏣᏖᏰᏃ, ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎮᎢ.


text:
ᏗᏃᏪᎵᏍᎩᏃ ᎠᎴ ᎠᏂᏆᎵᏏ ᎬᏩᎪᎲ ᎢᏧᎳᎭ ᎠᎾᎵᏍᏓᏴᎲᏍᎬ ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᎦᎾ, ᎯᎠ ᏂᏚᏂᏪᏎᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎦᏙᏃ ᎢᏧᎳᎭ ᏣᎾᎵᏍᏓᏴᎲᏍᎦ ᎠᎴ ᎢᏧᎳᎭ ᏣᎾᏗᏔᏍᎦ ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᎦᎾᎢ.


text:
ᏥᏌᏃ ᎾᏍᎩ ᎤᏛᎦᏅ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎾᏍᎩ ᏂᏚᏂᏢᎬᎾ Ꮭ ᎤᏚᎸᏗ ᏱᏄᎾᎵᏍᏓᏁᎰ ᏗᏓᏅᏫᏍᎩ, ᏧᏂᏢᎩᏍᎩᏂ; ᎢᏝ ᎤᎾᏓᏅᏘ ᏱᏗᏥᏯᏅᎯᎸ, ᎠᏂᏍᎦᎾᏍᎩᏂ ᏚᎾᏓᏅᏛ ᏧᏂᏁᏟᏴᏍᏗᏱ.


text:
ᏣᏂᏃ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎠᎴ ᎠᏂᏆᎵᏏ ᎬᏩᏂᏍᏓᏩᏗᏙᎯ ᎠᎹᏟ ᎠᏅᏍᎩ ᎨᏎᎢ; ᎤᏂᎷᏤᏃ ᎠᎴ ᎯᎠ ᏂᎬᏩᏪᏎᎴᎢ, ᎦᏙᏃ ᏣᏂ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎠᎴ ᎠᏂᏆᎵᏏ ᎬᏩᏂᏍᏓᏩᏗᏙᎯ ᎠᎹᏟ ᏣᏅᏍᎪᎢ, ᏂᎯᏃ ᎨᏣᏍᏓᏩᏗᏙᎯ ᎠᎹᏟ ᎾᏅᏍᎬᎾ ᏥᎨᏐᎢ?


text:
ᎥᏝ ᎠᎴ ᎩᎶ ᎢᏎ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᏧᏪᏘ ᏗᏑᏢᏛ ᏱᏓᏟᏍᏗᏍᎪᎢ; ᎢᏤᏰᏃ ᎩᎦᎨ-ᎠᏕᏔᏍᏗ ᏱᏙᎦᏣᎦᎸ ᏗᏑᏢᏛ, ᎠᎴ ᏗᎦᎨ-ᎠᏗᏔᏍᏗ ᏯᏤᏬᎩ, ᎠᎴ ᏗᏑᏢᏛ ᏱᏓᏲᎩ; ᎢᏤᏍᎩᏂ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ, ᏗᏤ ᏗᏑᏢᏛ ᏗᏟᏍᏙᏗ ᎨᏐᎢ.


text:
ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸ ᏧᏴᎴ ᎾᎯᏳ ᏤᎮ ᎡᏆᏱᏓ. ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ, ᎠᎴ ᏧᎨ ᎠᎦᏙᏗ ᎦᏚ, ᎾᏍᎩ ᎬᎩᏍᏗ ᏂᎨᏒᎾ ᏥᎨᏎ ᎠᏥᎸᎠᏁᎶᎯ ᎤᏅᏒ, ᎠᎴ ᎾᏍᏉ ᏥᏚᏁᎴ ᎾᏍᎩ ᎠᏁᎯ.


text:
ᎤᏐᏅᏤᎯᏃ ᏕᎤᎧᎿᏅ ᎾᏍᎩ ᎬᏩᏚᏫᏛ ᏄᎾᏛᏅ, ᎤᏕᏯᏔᏁᎲ ᏗᏍᏓᏱᏳ ᎨᏒ ᏧᏂᎾᏫ, ᎯᎠ ᏄᏪᏎᎴ ᎠᏍᎦᏯ; ᎭᏙᏯᏅᎯᏛ. ᎤᏙᏯᏅᎯᏕᏃ, ᎤᏪᏰᏂᏃ ᎬᏩᏃᏍᏛ ᏄᎵᏍᏔᏁ ᎾᏍᎩᏯ ᏐᎢ ᏄᏍᏛᎢ.


text:
ᎠᎴ ᏥᎷᏏᎵᎻ, ᎠᎴ ᎢᏙᎻᏱ, ᎠᎴ ᏦᏓᏂ ᎢᏍᎪᏂᏗᏢ; ᎠᎴ ᏓᏯ ᎠᎴ ᏌᏙᏂ ᎾᎥ ᏗᏁᎯ, ᎤᏣᏘ ᎠᏂᎪᏗᏳ, ᎾᏍᎩ ᎤᎾᏛᎦᏅ ᏂᎦᎥ ᎤᏍᏆᏂᎪᏗ ᏕᎤᎸᏫᏍᏓᏁᎸ, ᎬᏩᎷᏤᎴᎢ.


text:
ᏔᎵᏁᏃ ᎤᎴᏅᎮ ᏚᏕᏲᏁ ᎥᏓᎷᎶᏗ; ᎤᏂᏣᏘᏃ ᎬᏩᏓᏡᏫᏍᏔᏁᎢ, ᎾᏍᎩ ᎢᏳᏍᏗ ᏥᏳᎯ ᎤᏣᏁᎢ, ᎠᎴ ᎥᏓᎵ ᎠᏔᎸ ᎤᏪᏁᎢ; ᏂᎦᏛᏃ ᎤᏂᏣᏘ ᎨᏒ ᎥᏓᎷᎶᏗ ᏙᏱ ᎨᏒ ᎠᏂᏙᎾᎡᎢ.


text:
ᎢᎦᏛᏃ ᎣᏒ ᎦᏙᎯ ᎤᎳᎨᏯᏛᏤᎢ, ᎠᎴ ᎤᎵᏰᏁᎢ, ᎠᎴ ᎠᏛᏍᎨᎢ, ᎠᎴ ᎧᏁᏉᎨᎢ, ᎠᎴ ᎤᎦᏔᏔᏁᎢ, ᎢᎦᏛ ᏦᎠᏍᎪᎯ ᎢᏳᏩᎫᏗ, ᎢᎦᏛᏃ ᏑᏓᎵᏍᎪᎯ, ᎢᎦᏛᏃ ᎠᏍᎪᎯᏧᏈ.


text:
ᎾᏍᎩ ᎠᏂᎪᏩᏗᏍᎬ ᎤᏂᎪᏩᏛᏗᏱ, ᎠᎴ ᎬᏩᎾᏙᎴᎰᎯᏍᏗ ᏂᎨᏒᎾᎢᏳᎵᏍᏙᏗᏱ; ᎠᎴ ᎠᎾᏛᎩᏍᎬ ᎤᎾᏛᎪᏗᏱ, ᎠᎴ ᎬᏩᏃᎵᏍᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ; ᎾᏍᎩ ᏧᎾᏓᏁᏟᏴᎡᏗᏱ ᏂᎨᏒᎾ ᏚᎾᏓᏅᏛ, ᎠᎴ ᎤᏂᏍᎦᏅᏨ ᎦᎨᏥᏁᏗᏱ ᏂᎨᏒᎾ.


text:
ᎤᏪᎵᎯᏍᏗᏃ ᎡᎶᎯ ᎡᎯ, ᎠᎴ ᎨᏅᎢᏍᏗ ᎨᏒ ᎤᏓᎵᏓᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᎪᎱᏍᏗ ᎠᏚᎸᏗ ᎨᏒ, ᎠᏂᏴᎯᎲ ᎠᏂᏁᏄᎳᏍᏗᏍᎪ ᎧᏃᎮᏛ, ᎠᎴ ᎾᏍᎩ ᎾᎦᏔᏛᏍᎬᎾᏉ ᎨᏐᎢ.


text:
ᎯᎠᏃ ᎾᏍᎩ ᎣᏒ ᎦᏙᎯ ᏥᎨᏥᏫᏎᎴᎢ; ᎾᏍᎩ ᎠᎾᏛᎩᏍᎩ ᎧᏃᎮᏛ, ᎠᎴ ᏗᎾᏓᏂᎸᎩ, ᎠᎴ ᎠᏂᎦᏔᏛᏍᎩ, ᎢᎦᏛ ᏦᎠᏍᎪᎯ ᎢᏳᏩᏓᏗ, ᎢᎦᏛᏃ ᏑᏓᎳᏍᎪᎯ, ᎢᎦᏛᏃ ᎠᏍᎪᎯᏧᏈ.


text:
ᎠᏎᏃ ᎠᏫᏒᎯ ᏥᎨᏐᎢ, ᏗᏛᏍᎪᎢ, ᎠᎴ ᎤᏟ ᎡᏉᎯᏳ ᏂᎦᎵᏍᏗᏍᎪ ᎡᏍᎦᏉ ᏂᎦᎥ ᎤᏰᎿᎥᎢ, ᎠᎴ ᏤᏉᎯᏳ ᏓᏱᏢᏍᎪᎢ; ᎠᎴ ᏥᏍᏆ ᎤᏜᏅᏛ ᎠᏂᏃᎯᎵᏙᎯ ᏰᎵᏉ ᎤᏓᏩᏗᏍᏛ ᎭᏫᏂᏗᏢ ᎠᎾᎭᏗᏍᎪᎢ.


text:
ᎠᎴ ᎠᏍᏓᏯ ᎤᏪᎷᏁ ᎯᎠ ᏄᏪᏎᎢ; ᎦᏙ ᏗᎩᎾᏓᏛᏙᏗ ᏂᎯ ᏥᏌ, ᏩᏍᏛ ᎦᎸᎳᏗᏳ ᎡᎯ ᎤᏁᎳᏅᎯ ᎤᏪᏥ? ᎬᏁᏤᎭ, ᎤᏁᎳᏅᎯ ᎬᏁᎢᏍᏓᏁᎭ, ᎾᏍᎩ ᏍᎩᎩᎵᏲᎢᏍᏙᏗᏱ ᏂᎨᏒᎾ.


text:
ᎩᎳᏉᏃ ᎢᏴᏛ ᏥᏌ ᏚᎵᏍᎪᎸᏓᏁᎴᎢ. ᏗᎦᏓᎭᏃ ᏗᏓᏅᏙ ᎤᏂᏄᎪᏨ, ᏏᏆ ᏫᏚᏂᏴᏎᎴᎢ; ᏑᎾᏓᏡᎩᏃ ᎤᎾᏁᎷᎩᏎ ᎤᏂᎦᏐᎠᏎ ᎦᏁᏡᎩ ᎨᏒ ᎥᏓᎵ ᏭᎾᎵᏔᏗᏅᏎᎢ, (ᏔᎵ ᎢᏯᎦᏴᎵ ᎢᏴᏛ ᎾᏂᎡᎢ,) ᎠᎴ ᎥᏓᎵ ᏚᏂᎬᏤᎢ.


text:
ᎠᏎᏃ ᎥᏝ ᏳᎵᏍᎪᎸᏓᏁᎴᎢ ᏥᏌ, ᎯᎠᏉᏍᎩᏂ ᏄᏪᏎᎴᎢ, ᏥᎮᎾ ᏗᏤᏅᏒ ᎪᎱᏍᏗ ᏗᏨᎾ ᏗᏁᎲᎢ, ᎠᎴ ᏫᏗᏃᎲᏏ ᏂᎦᎥ ᎤᏍᏆᏂᎪᏗ ᎤᎬᏫᏳᎯ ᏂᏣᏛᏁᎸᎢ, ᎠᎴ ᏣᏙᎵᏨᎢ.


text:
ᎤᏂᎩᏎᏃ, ᎠᎴ ᎤᎴᏅᎮ ᏚᏃᏣᎳᏁ ᎠᏍᎪᎯ-ᎢᎦᏚᎩᏱ, ᏂᎦᎥ ᎤᏍᏆᏂᎪᏗ ᏥᏌ ᏄᏛᏁᎸᎢ; ᎠᎴ ᏂᎦᏛ ᏴᏫ ᎤᏂᏍᏆᏂᎪᏎᎤᏂᎩᏎᏃ, ᎠᎴ ᎤᎴᏅᎮ ᏚᏃᏣᎳᏁ ᎠᏍᎪᎯ-ᎢᎦᏚᎩᏱ, ᏂᎦᎥ ᎤᏍᏆᏂᎪᏗ ᏥᏌ ᏄᏛᏁᎸᎢ; ᎠᎴ ᏂᎦᏛ ᏴᏫ ᎤᏂᏍᏆᏂᎪᏎᎢ


text:
ᎤᎾᏙᏓᏆᏍᎬᏃ ᎤᎵᏰᎶᎸ, ᎤᎴᏅᎮ ᏚᏕᏲᏁ ᏗᎦᎳᏫᎢᏍᏗᏱ; ᎤᏂᏣᏘᏃ ᎬᏩᏛᎦᏁᎸ ᎤᏂᏍᏆᏂᎪᏎᎢ, ᎯᎠ ᎾᏂᏪᏍᎨᎢ, ᎭᏢ ᎠᎩᎭ ᎯᎠ ᎠᏍᎦᏯ ᎯᎠ ᎾᏍᎩ ᎢᎬᏩᏛᏁᏗ ᏥᎩ? ᎠᎴ ᎦᏙ ᎤᏍᏗ ᎠᎦᏙᎥᎯᏍᏗ ᎾᏍᎩ ᎠᏥᏁᎸᎯ ᏥᎩ, ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏍᏆᏂᎪᏗ ᏥᏚᎸᏫᏍᏓᏁᎭ?


text:
ᎠᎴ ᎩᎶ ᏂᏗᏣᏓᏂᎸᎬᎾ ᎠᎴ ᏂᏣᏛᏓᏍᏓᏁᎲᎾ ᎢᎨᏎᏍᏗ, ᎿᏉ ᎾᎿ ᎢᏣᏂᎩᏍᎨᏍᏗ, ᏗᏣᎳᏏᏕᏂ ᎪᏍᏚ ᏕᏥᏅᎪᎥᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎪᎯᏳᏗᏍᎩ ᎤᎾᏡᏗᏍᎩ. ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎡᏍᎦᏉ ᎢᎦᎢ ᎤᏂᎩᎵᏲᎢᏍᏗ ᎨᏎᏍᏗ ᏐᏓᎻ, ᎠᎴ ᎪᎹᎵ, ᏗᎫᎪᏙᏗᏱ ᎢᎦ ᎨᏎᏍᏗ, ᎤᏟᎯᏳ ᎾᎿ ᎦᏚᎲᎢ.


text:
ᎡᎶᏛᏃ ᎤᎬᏫᏳᎯ ᎤᏛᎦᏁ ᎾᏍᎩ ᎠᏥᏃᎮᏍᎬᎢ; ᏚᏃᏣᎶᏤᏰᏃ ᎾᏍᎩ ᏚᏙᎥᎢ; ᎠᎴ ᎯᎠ ᏄᏪᏎ ᎡᎶᏛ, ᏣᏂ ᏗᏓᏬᏍᎩ ᏓᎴᎯᏌ ᎤᏲᎱᏒᎢ, ᎠᎴ ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏍᏆᏂᎪᏗ ᏥᏕᎤᎸᏫᏍᏓᏁᎭ.


text:
ᎡᎶᏛᏰᏃ ᎤᎸᏉᏗᏳ ᎨᏎ ᏣᏂ, ᎠᎦᏔᎮᏰᏃ ᎤᏓᏅᏘᏳ ᎠᎴ ᎾᏍᎦᏅᎾ ᎨᏒ ᎠᏍᎦᏯ, ᎠᎴ ᎤᎦᏌᏯᏍᏗᏳ ᎨᏎᎢ; ᎾᏍᎩᏃ ᎤᏛᎦᏅ <n>[ᎠᏓᏥᏙᎲᏍᎬ,]</n> ᎤᏣᏖ ᏚᎸᏫᏍᏓᏁᎴᎢ, ᎠᎴ ᎤᎵᎮᎵᏨᎯ ᎠᏛᏓᏍᏓᏁᎮᎢ.


text:
ᎠᎯᏛᏃ ᎾᏍᎩ ᎢᎬᏛᏁᏗ ᎨᏒ ᎤᏍᏆᎸᎲ, ᎾᏍᎩ ᎡᎶᏛ ᎤᏕᏅ ᎢᏳ ᎢᎦ ᎤᏛᏅᎢᏍᏔᏁ ᎬᏩᎵᏍᏓᏴᎾᏁᏗᏱ ᏧᏤᎵ ᎤᏂᎬᏫᏳᎯ, ᎠᎴ ᎠᏂᏍᎦᏰᎬᏍᏓ, ᎠᎴ ᏗᎨᎦᏁᎶᏗ ᎨᎵᎵ ᎠᏁᎯ,


text:
ᎾᏍᎩᏃ ᎡᎶᏗᏏ ᎤᏪᏥ ᎠᏛ ᎤᏴᎵᎸ, ᎠᎴ ᎤᎵᏍᎩᏒ, ᎠᎴ ᎡᎶᏛ ᎠᎴ ᎾᏍᎩ ᎢᏧᎳᎭ ᎠᏂᏂᏜᎢ ᎣᏏᏳ ᎤᏂᏰᎸᏅ, ᎤᎬᏫᏳᎯ ᎯᎠ ᏄᏪᏎᎴ ᎠᏛ, ᏍᎩᏔᏲᏏ ᎢᏳᏍᏗᏉ ᎮᎵᏍᎬᎢ, ᏓᎬᏁᎵᏃ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎢᏕᎾ ᎢᏨᏒᏉ ᎢᏴᏛ ᏫᏗᎶᎯ ᎢᎾᎨ ᏗᎨᏒᎢ, ᎠᎴ ᏞᎦ ᎢᏣᏣᏪᏐᎸᏍᏓ; ᎤᏂᏣᏖᏰᏃ ᎠᏂᎷᎨ ᎠᎴ ᏓᏁᎨᎢ, ᎥᏞᏃ ᏯᏜᏅᏓᏗᏍᎨ ᎾᏍᏉ ᎤᎾᎵᏍᏓᏴᏗᏱ ᎢᎪᎯᏛ.


text:
ᏴᏫᏃ ᎬᏩᏂᎪᎮ ᎠᎾᏂᎩᏍᎬᎢ, ᎠᎴ ᎤᏂᏣᏖ ᎬᏬᎵᎨᎢ, ᎠᎴ ᎡᎳᏗᏉ ᏚᏂᏍᏆᎸᏔᏁ ᎾᎿ ᎢᏗᏢ ᏭᏂᎶᏎ ᏕᎦᏚᏩᏗᏒ ᏂᏙᏓᏳᏂᎶᏒᎯ, ᏕᎬᏩᏂᎩᏰᏃ, ᎠᎴ ᏫᎬᏩᏓᏟᏌᏁᎴᎢ.


text:
ᎯᏍᎩᏃ ᎦᏚ ᏚᎩᏒ ᎠᎴ ᏔᎵ ᎠᏣᏗ ᏚᏁᏒ, ᎦᎸᎳᏗ ᏫᏚᎧᎿᏁᎢ, ᎠᎴ ᎤᎵᎮᎵᏤᎢ, ᎠᎴ ᏚᎬᎭᎷᏰ ᎦᏚ, ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ ᏚᏁᎴ ᏧᏂᏁᏗᏱ; ᏔᎵᏃ ᎠᏣᏗ ᏂᎦᏛ ᏚᏯᏙᎮᎴᎢ.


text:
ᎠᎴ ᎢᎸᎯᏢ ᏫᎦᎷᎩ, ᏧᏍᏗ ᏕᎦᏚᎲ, ᎠᎴ ᏧᏛᎾ ᏕᎦᏚᎲ, ᎠᎴ ᎢᏴᏛ ᏗᏓᏁᎶᎯ ᎨᏒᎢ, ᏧᏂᏢᎩ ᏕᎦᎳᏅᏛ ᏓᏂᏅᎥᏍᎨᎢ, ᎠᎴ ᎬᏩᏔᏲᏎᎮ ᎤᎾᏒᏂᏍᏗᏱ, ᎦᏓᎷᏯᏛᏉ ᎾᏍᏉ ᎤᏄᏴᎢ; ᎾᏂᎥᏃ ᎾᏍᎩ ᎬᏩᏒᏂᎸᎯ ᏚᎾᏗᏩᏍᎨᎢ.


text:
ᎠᎴ ᎦᏃᏙᏗᏱ ᏛᏂᎶᎯ, ᎢᏳᏃ ᏂᏚᎾᏑᎴᎲᎾ ᏱᎩ, ᎥᏝ ᏴᎬᎾᎵᏍᏓᏴᎲᎦ. ᎠᎴ ᎤᏣᏔ ᏄᏓᎴ ᎪᎱᏍᏗ ᏧᏂᎧᎿᏩᏛᏍᏗ ᏄᏅᏁᎸ, ᎾᏍᎩ ᏧᎵᏍᏈᏗ ᏗᎫᎯᎶᎥᎢ ᎠᎴ ᏗᏖᎵᏙ, ᎠᎴ ᎥᏣᏱᏗᎪᏢᏔᏅᎯ ᏗᏖᎵᏙ, ᎠᎴ ᏗᏂᏢᏗᏱ.


text:
ᎿᏉᏃ ᎠᏂᏆᎵᏏ ᎠᎴ ᏗᏃᏪᎵᏍᎩ ᎢᎬᏩᏛᏛᏁ ᎯᎠ ᏂᎬᏩᏪᏎᎴᎢ; ᎦᏙᏃ ᎨᏣᏍᏓᏩᏗᏙᎯ ᎥᏝ ᏱᏓᏂᎧᎿᏩᏕᎦ ᎡᏘ ᎤᎾᏕᏅᎯ ᎤᏂᏁᏨᎢ, ᎾᏍᎩ ᏂᏚᎾᏑᎴᎲᎾᏉ ᏣᎾᎵᏍᏓᏴᎲᏍᎦ?


text:
ᏚᏁᏤᎸᏃ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎢᏌᏯ ᏰᎵᏉ ᏄᏪᏒ ᎤᏙᎴᎰᏒ ᏂᎯ ᎢᏣᏠᎾᏍᏗ ᎢᏥᏁᎢᏍᏗᏍᎬᎢ, ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᎯᎠ ᎾᏍᎩ ᏴᏫ ᎬᎩᎸᏉᏗᎭ ᏚᏂᎭᏁᎦᎸ ᏓᏅᏗᎭ, ᏧᏂᎾᏫᏍᎩᏂ ᎢᏅᎯᏳ ᏂᏚᏅᎿᏕᎦ ᎠᏴ ᎾᏆᏛᏅᎢ.


text:
ᎢᏴᏛᏰᏃ ᏂᏨᏁ ᎤᏁᎳᏅᎯ ᎤᏁᏨᎯ, ᏴᏫ ᎤᏂᏁᏨ ᏗᎧᎿᏩᏛᏍᏗ ᏂᏨᏁᎭ, ᎾᏍᎩ ᏗᏖᎵᏙ ᎠᎴ ᏧᎵᏍᏈᏗ ᏗᎫᎯᎶᎥᎢ; ᎠᎴ ᎤᏣᏔ ᏄᏓᎴᎭ ᎾᏍᎩᏯ ᎤᏠᏱ ᏕᏥᎸᏫᏍᏓᏁᎰᎢ.


text:
ᏂᎯᏍᎩᏂ ᎯᎠ ᏂᏥᏪᎭ, ᎢᏳᏃ ᎩᎶ ᎯᎠ ᏂᎦᏪᏎᎮᏍᏗ ᎤᏙᏓ ᎠᎴ ᎤᏥ, ᎪᏆᏂ, (ᎾᏍᎩ ᎦᏛᎬ, ᎠᏆᎵᏍᎪᎸᏔᏅᎯ,) ᏂᎦᎥ ᎨᏣᎵᏍᏕᎸᏙᏗ ᎨᏒ ᎠᏴ ᎬᏍᏕᎵᏍᎬᎢ; <n>[ᎾᏍᎩ ᎤᏚᏓᎴᏛ ᎨᏎᏍᏗ.]</n>


text:
ᎦᏃᏍᎩᏛ ᎨᏒᎢ, ᏧᎬᏩᎶᏗ ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ, ᎤᏲ ᎢᏯᏛᏁᏗ ᎨᏒᎢ, ᎦᎶᏄᎮᏛ ᎨᏒᎢ, ᎠᎵᏐᏢᎢᏍᏙᏗ ᎨᏒᎢ, ᎠᏛᏳᎨᏗ ᎨᏒᎢ, ᎠᏓᏐᏢᎢᏍᏙᏗᏱ, ᎠᏢᏉᏙᏗᏱ, ᎠᎵᏍᎦᎿᏫᏍᏗ ᎨᏒᎢ.


text:
ᏚᏁᏤᎴᏃ ᎤᏂᏣᏘ ᎦᏙᎯ ᎤᎾᏂᏢᏗᏱ; ᎦᎵᏉᎩᏃ ᎦᏚ ᏚᎩᏒ, ᎠᎴ ᎤᎵᎮᎵᏨ, ᏚᎬᎭᎷᏰᎢ, ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ ᏚᏁᎴ ᎾᏍᎩ ᎢᎬᏱᏗᏢ ᏧᏂᏁᏗᏱ; ᎢᎬᏱᏗᏢᏃ ᏚᏂᏁᎴ ᎤᏂᏣᏘ ᏴᏫ.


text:
ᎤᏓᏅᏙᎩᎯᏃ ᎭᏫᏂ ᎤᎵᏰᏔᏁᎢ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎢ, ᎦᏙᏃ ᎪᎯ ᎯᎠ ᏣᏁᎭ ᎤᏰᎸᏛ ᎤᏂᏲᎭ? ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎥᏝ ᎬᏂᎨᏒ ᎢᎨᎬᏁᏗ ᏱᎨᏎᏍᏗ ᎤᏰᎸᏛ ᎯᎠ ᎪᎯ ᏣᏁᎭ.


text:
ᏥᏌᏃ ᎤᏙᎴᎰᏒ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎦᏙᏃ ᎢᏣᎵᏃᎮᎭ ᎦᏚ ᏂᏗᏥᏰᎲᎾ ᎨᏒ ᎢᏳᏍᏗ? ᎠᏏᏉᏍᎪ ᏂᏣᏙᎴᎰᏍᎬᎾ ᎢᎩ, ᎠᎴ ᏂᏦᎵᎬᎾ ᎢᎩ? ᎠᏏᏉᏍᎪ ᎠᏍᏓᏯ ᏂᏕᏨᏅ ᏗᏥᎾᏫ?


text:
ᎤᎴᏅᎮᏃ ᏚᏪᏲᏁᎢ, ᎾᏍᎩ ᏴᏫ ᎤᏪᏥ ᎤᏣᏘ ᏧᏓᎴᏅᏛ ᎤᎩ ᎵᏲᎢᏍᏗᏱ; ᎠᎴ ᎬᏩᏲᎢᏎᏗ ᎨᏒ ᏗᏂᎳᏫᎩ, ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ, ᎠᎴ ᎠᏥᎢᏍᏗᏱ ᎨᏒᎢ, ᏦᎢᏁᏃ ᎢᎦ ᏧᎴᎯᏐᏗ ᎨᏒᎢ.


text:
ᎠᏎᏃ ᎤᎦᏔᎲᏒ, ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ ᏚᎧᎿᏅ, ᏈᏓ ᎤᎬᏍᎪᎸᏁᎢ, ᎯᎠ ᏄᏪᏎᎢ, ᎠᏆᏐᎭᏛ ᎭᎴᎲᎦ ᏎᏓᏂ; ᎥᏝᏰᏃ ᎤᏁᏪᏅᎯ ᎤᏤᎵ ᎨᏒ ᎣᏏᏳ ᏱᏣᏰᎸᎭ, ᏴᏫᏍᎩᏂ ᎤᎾᏤᎵ ᎨᏒᎢ.


text:
ᏫᏚᏯᏅᎲᏃ ᏴᏫ, ᎠᎴ ᎾᏍᏉ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎩᎶ ᎤᏚᎵᏍᎨᏍᏗ ᎠᎩᏍᏓᏩᏛᏍᏗᏱ, ᎤᏩᏒ ᎠᏓᏓᏱᎮᏍᏗ, ᎠᎴ ᎤᏩᏒ ᎤᏤᎵ ᏧᏓᎾᏩᏛ ᎠᏱᏍᎨᏍᏗ, ᎠᎴ ᎠᎩᏍᏓᏩᏕᎨᏍᏗ.


text:
ᎩᎶᏰᏃ ᎠᏆᏕᎰᏍᎨᏍᏗ ᎠᏴ, ᎠᎴ ᎠᏴ ᏥᏁᎬᎢ, ᎤᏓᏑᏴ ᎠᏂ ᏗᎾᏓᏲᏁᎯ ᎠᎴ ᎠᏂᏍᎦᎾ ᎠᏁᎲᎢ, ᎾᏍᎩ ᎾᏍᏉ ᏴᏫ ᎤᏪᏥ ᎤᏕᎰᎯᏍᏗ ᎨᏎᏍᏗ, ᎦᎷᏨᎭ ᎤᏄᏬᏍᏕᏍᏗ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏙᏓ ᎤᏤᎵᎦ, ᎠᏁᎮᏍᏗ ᎨᏥᎸᏉᏗ ᏗᏂᎧᎿᏩᏗᏙᎯ.


text:
ᎤᏁᏨᏃ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎢᎳᏯ ᎤᏙᎯᏳᎯ ᎢᎬᏴ ᎤᎷᎯᏍᏗ, ᎠᎴ ᏂᎦᏛ ᎤᏬᏢᎯᏐᏗ; ᎠᎴ ᎾᏍᏉ ᎯᎠ ᏂᎬᏅᎪᏪᎳ ᏴᏫ ᎤᏪᏥ ᎠᏥᏃᎮᏍᎬᎢ, ᎾᏍᎩ ᎤᏣᏘ ᏧᏓᎴᏅᏛ ᎤᎩᎵᏲᎢᏍᏗ ᎨᏎᏍᏗ, ᎠᎴ ᎠᏎᏉ ᏓᏰᏥᏰᎸᏂ.


text:
ᏥᏌᏃᎤᎪᎲ ᎾᏍᎩ ᎤᏂᏣᏘ ᎠᎾᏁᎷᎩᏍᎬ ᎠᎾᏓᏟᏏᏍᎬᎢ, ᎤᏍᎦᏤ ᎦᏓᎭ ᎠᏓᏅᏙ, ᎯᎠ ᏄᏪᏎᎴᎢ, ᏨᎨᏩᎠᎴ ᏗᏣᎵᎡᎾ ᎠᏓᏅᏙ, ᎬᏁᏤᎭ, ᎡᎯᏄᎪᎢ, ᎠᎴ ᏞᏍᏗ ᎿᏉ ᎢᎸᎯᏳ ᏥᎯᏴᎵ.


text:
ᎤᏪᏅᏃ, ᏔᎳᏚ ᎢᏯᏂᏛ ᏫᏚᏯᏅᎮᎢ, ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎢᏳᏃ ᎩᎶ ᎢᎬᏱ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏚᎵᏍᎨᏍᏗ, ᎾᏍᎩ ᎣᏂᏱ ᎠᎦᎴᏙᏗ ᎨᏎᏍᏗ ᎾᏂᎥᎢ, ᎠᎴ ᎾᏂᎥ ᎬᏩᏅᏏᏙᎯ ᎨᏎᏍᏗ.


text:
ᎩᎶ ᎠᏏᏴᏫ ᎯᎠ ᎢᏳᎾᏍᏗ ᏗᏂᏲᎵ ᏓᏓᏂᎸᎨᏍᏗ ᎠᏴ ᎠᏴ ᏓᏆᏙᎥ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎠᏴ ᏓᏆᏓᏂᎸᎨᏍᏗ; ᎩᎶᏃ ᎠᏴ ᏓᏆᏓᏂᎸᎨᏍᏗ, ᎥᏝ ᎠᏴ ᏱᏓᏆᏓᏂᎸᎨᏍᏗ, ᏅᏛᎩᏅᏏᏛᏍᎩᏂ ᏓᏓᏂᎸᎨᏍᏗ.


text:
ᏣᏂᏃ ᎤᏁᏤᎴᎢ, ᎯᎠ ᏄᏪᏎᎢ, ᏔᏕᏲᎲᏍᎩ, ᎣᏥᎪᎲᎩ ᎠᏏᏴᏫ ᎠᏂᏍᎩᎾ ᏕᎦᏄᎪᏫᏍᎬᎩ ᏕᏣᏙᎥ ᎬᏗᏍᎬᎩ; ᎥᏝᏃ ᏱᎩᏍᏓᏩᏗᏙᎭ; ᎣᏥᏅᏍᏓᏕᎸᎩᏃ ᏂᎩᏍᏓᏩᏕᎬᎾ ᎨᏒ ᎢᏳᏍᏗ.


text:
ᎩᎶᏰᏃ ᎠᎹ ᎤᎵᏍᏈᏗ ᎠᎧᎵᎢ ᎢᏣᏗᏔᏍᏗ ᎢᏥᏁᏁᎯ ᎠᏴ ᏓᏆᏙᎥᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎦᎶᏁᏛ ᎡᏣᏤᎵ ᎨᏒ ᎢᏳᏍᏗ, ᎤᏙᎯᏳᎯᏯ ᎢᏨᏲᏎᎭ, ᎥᏝ ᎤᏲᎱᏎᏗ ᏱᎨᏎᏍᏗ ᎠᎦᎫᏴᎡᏗ ᎨᏒᎢ.


text:
ᎢᏳ ᎠᎴ ᏦᏰᏂ ᏕᏦᏕᏍᏗᏍᎨᏍᏗ, ᎯᏍᏆᎵᏍᎨᏍᏗ; ᎤᏟ ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏣᎪᎳᏂ ᎬᏂᏛ ᏗᎨᏒ ᏱᏫᏣᏴᎸ, ᎠᏃ ᎢᏧᎳ ᏗᎨᎰᏯᏗ ᏨᏍᎩᏃ ᏱᏫᏣᏴᎸ, ᎾᎿ ᎠᏥᎸᏱ ᎦᎬᏜᏗᏍᏗ ᏂᎨᏒᎾ;


text:
ᎢᏳ ᎠᎴ ᏣᎳᏏᏕᏂ ᏙᏦᏕᏍᏗᏍᎨᏍᏗ, ᎯᏍᏆᎵᏍᎨᏍᏗ; ᎤᏟᏰᏃ ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᎯᏲᎤᎵ ᎬᏂᏛ ᏗᎨᏒ ᏱᏫᏣᏴᎸ, ᎠᏃ ᎢᏧᎳ ᏗᎨᏣᎳᏍᎩ ᏨᏍᎩᏃ ᏱᏪᏣᏓᎢᏅ, ᎾᎿ ᎠᏥᎸᏱ ᎦᎬ ᏜᏗᏍᏗ ᏂᎨᏒᎾ;


text:
ᎢᏳ ᎠᎴ ᎯᎦᏙᎵ ᏙᏦᏕᏍᏗᏍᎨᏍᏗ, ᎭᏓᎦᏖᏙᎢᏍᎨᏍᏗ; ᎤᏟᏰᏃ ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏌᏉᏉ ᏱᎧᏅ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ ᏱᏫᏣᏴᎸ ᎠᏃ ᎢᏧᎳ ᏱᏘᎧᏅ ᏨᏍᎩᏃ ᎠᏥᎸᏱ ᏱᏪᏣᏓᎢᏅ;


text:
ᎾᎿᏃ ᏚᎴᏅ, ᏧᏗᏱ ᎦᏓ ᎠᎲᎢ ᎤᎷᏤᎢ, ᏦᏓᏂ ᎠᏍᎪᏂᏗᏢ ᏧᎶᎯᏍᏔᏁᎢ; ᎠᎴ ᎤᏂᏣᏘ ᏴᏫ ᏔᎵᏁ ᎢᎬᏩᏓᏟᏌᏁᎴᎢ; ᎠᎴ ᎢᏳᏛᏁᏗ ᎨᏒ ᏄᏛᏁᎴᎢ, ᏔᎵᏁ ᏚᏪᏲᏁᎢ.


text:
ᏥᏌᏍᎩᏂ ᎤᎪᎲ ᎤᏣᏘ ᏒᏍᎦ ᎤᏰᎸᏁᎢ, ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎤᏁᎳᎩ ᏕᏤᎵᏎᎮᏍᏗ ᏧᎾᏍᏗ ᏗᏂᏲᎵ ᎬᎩᎷᏤᏗᏱ, ᎠᎴ ᏞᏍᏗ ᏱᏗᏥᏅᏍᏓᏕᎮᏍᏗ; ᎾᏍᎩᏰᏃ ᏄᎾᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ.


text:
ᎤᏂᎩᏒᏃ ᎦᏅᏅ ᏭᎷᏨ, ᎩᎶ ᎢᏳᏍᏗ ᎤᏗᏠᎡᎸᎩ, ᎠᎴ ᏚᎵᏂᏆᏅᏁᎸᎩ, ᎤᏛᏛᏁ ᎯᎠ ᏄᏪᏎᎴᎢ, ᎰᏍᏛ ᏔᏕᏲᎲᏍᎩ, ᎦᏙ ᏓᎦᏛᏁᎵ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎬᏂᏛ ᎠᏆᏤᎵ ᎢᏳᎵᏍᏙᏗᏱ?


text:
ᏕᎯᎦᏔᎭ ᏗᎧᎿᏩᏛᏍᏗ, ᎾᏍᎩ, ᏞᏍᏗ ᏣᏓᏲᏁᎸᎩ, ᏞᏍᏗ ᏣᏓᎸᎩ, ᏞᏍᏗ ᏣᏃᏍᎩᏒᎩ, ᏞᏍᏗ ᎦᏰᎪᎩ ᏣᏃᎮᎸᎩ, ᏞᏍᏗ ᏣᏓᎶᏄᎮᎸᎩ, ᏣᏙᏓ ᎠᎴ ᏣᏥ ᏕᎯᎸᏉᏕᏍᏗ.


text:
ᏥᏌᏃ ᏚᎧᎿᏅ, ᎤᎨᏳᎯᏳ ᏄᎵᏍᏔᏁᎢ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎴᎢ, ᏑᏓᎵᎩ ᏣᎷᎳ; ᏫᎾᏚᎦ ᏂᎦᎥ ᎪᎱᏍᏗ ᏣᎾᎥᎢ, ᎠᎴ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ ᎩᏁᎸᎭ, ᏦᏒᏃ ᏫᏣᎮᏍᏗ ᏧᎬᏩᎶᏗ; ᎠᎴ ᏖᏒᎭ, ᏧᏓᎿᏩᏛ ᎪᏣᎮᏍᏗ ᏧᎬᏩᎶᏗ; ᎠᎴ ᏖᏒᎭ, ᏧᏓᎿᏩᏛ ᎯᏴᎲᎭ, ᎠᎴ ᏍᎩᏍᏓᏩᏕᏒᎭ.


text:
ᎬᏩᏍᏓᏩᏗᏙᎯᏃ ᎬᎧᏍᏆᏂᎪᏎᎴ ᎾᏍᎩ ᏄᏪᏒᎢ. ᎠᏎᏃ ᏥᏌ ᏔᎵᏁ ᎢᎤᏁᏨ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᏗᏥᏲᎵ. ᎾᏍᏓᏯ ᎾᏍᎩ ᎨᏅᎢᏍᏗ ᎨᏒ ᎠᎾᎵᏍᎦᏍᏙᏗᏍᎩ, ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ ᏭᏂᏴᏍᏗᏱ.


text:
ᏥᏌᏃ ᎤᏁᏨ ᎯᎠ ᏄᏪᏎᎢ; ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎥᏝ ᎩᎶ ᏰᎭᎾᏍᎩ ᎤᏮᏕᏨᎯ ᎢᎨᏎᏍᏗ ᎠᏓᏁᎸᎢ, ᎠᎴ ᎠᎾᎵᏅᏟ, ᎠᎴ ᏧᏙ, ᎠᎴ ᎤᏙᏓ, ᎠᎴ ᎤᏥ, ᎠᎴ ᎤᏓᎵᎢ, ᎠᎴ ᏧᏪᏥ, ᎠᎴ ᏚᎶᎨᏒᎢ, ᎠᏴ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎠᎴ ᎣᏍᏛ ᎧᏃᎮᏛ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ,


text:
ᎾᏍᎩ ᎪᎯ ᎨᏒ ᎠᏥᏁᏗ ᏂᎨᏒᎾ ᎨᏒ ᎠᏍᎪᎯᏧᏈ ᎢᏳᏩᎫᏗ ᎤᎶᏒᏍᏗ ᏓᏓᏁᎸᎢ, ᎠᎴ ᎠᎾᎵᏅᏟ, ᎠᎴ ᏧᏙ, ᎠᎴ ᏧᏥ, ᎠᎴ ᏧᏪᏥ, ᎠᎴ ᏕᎦᎶᎨᏒᎢ, ᎠᎩᎵᏲᎢᏍᏗ ᎨᏒ ᏔᎵ ᎤᏛᏗ; ᏐᎢᏱᏃ ᏗᎨᏒ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎬᏂᏛ.


text:
ᎦᏅᏅᏃ ᎠᎾᎢᏎ ᏥᎷᏏᎵᎻ ᏣᏂᎦᏖᎢ; ᏥᏌᏃ ᎢᎬᏱ ᏚᏪᏅᎡᎴᎢ; ᎤᏂᏍᏆᏂᎪᏎᏃ; ᎾᏍᎩᏃ ᎠᎾᎵᏍᏓᏩᏗᏒ ᎠᏂᏍᎦᎢᎮᎢ. ᏔᎵᏁᏃ ᏚᏯᏅᎲ ᏔᎳᏚ ᎢᏯᏂᏛ, ᎤᎴᏅᎮ ᏚᏃᏁᎴ ᎾᏍᎩ ᎢᏳᎵᏍᏓᏁᎵᏓᏍᏗ ᎨᏒᎢ.


text:
<n>[ᎯᎠ ᏂᎦᏪᏍᎨᎢ;]</n> ᎬᏂᏳᏉ ᏥᎷᏏᎵᎻ ᏫᏗᎦᏘ; ᎠᎴ ᏴᏫ ᎤᏪᏥ ᏙᏓᏰᏥᏲᏏ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ ᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ ᏙᏓᎨᏥᏲᎯᏎᎵ; ᎠᎴ ᏙᏓᎬᏭᎪᏓᏁᎵ ᎤᏲᎱᎯᏍᏗᏱ, ᎠᎴ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏫᏙᏛᏂᏲᎯᏎᎵ;


text:
ᎠᏎᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎥᏝ ᏱᏍᏗᎦᏔᎭ ᏄᏍᏛ ᎢᏍᏗᏔᏲᎯᎲᎢ. ᏥᏌ ᏰᎵᏉ ᎨᏍᏓᏗᏔᏍᏗ ᎤᎵᏍᏈᏗ ᎾᏍᎩ ᎠᏆᏗᏔᏍᏗ ᏥᎩ? ᎠᎴ ᏗᎦᏰᏍᏓᏬᏍᏗ ᎾᏍᎩ ᏗᏓᏬᏍᏗ ᎨᏒ ᎾᏍᎩ ᎥᏆᏬᏍᏙᏗ ᏥᎩ?


text:
ᎯᎠᏃ ᏂᎬᏩᏪᏎᎴᎢ, ᏰᎵᏉ ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎤᏙᎯᏳᎯ ᏓᏍᏓᏗᏔᎯ ᎤᎵᏍᏈᏗ ᎾᏍᎩ ᎠᏴ ᎠᏆᏗᏔᏍᏗ ᏥᎩ, ᎠᎴ ᏗᏓᏬᏍᏗ ᎨᏒ ᎠᏴ ᎥᏆᏬᏍᏙᏗ ᏥᎩ, ᎾᏍᎩ ᏙᏓᏰᏍᏓᏬᏍᏔᏂ;


text:
ᎠᏎᏃ ᏥᏌ ᏫᏚᏯᏅᎲ ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎢᏥᎦᏔᎭ ᎾᏍᎩ ᎤᏂᎬᏫᏳᎯ ᎨᏥᏰᎸᎢ ᎨᏒ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ, ᏗᎬᏩᎾᏁᎶᏙᏗᏱ ᎾᏅᏁᎰᎢ; ᏧᏂᎸᏉᏗᏃ ᎨᏒ ᎬᏩᎾᏓᎵᏁᎯᏕᎰᎢ.


text:
ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎢᏍᏕᎾ Ꮎ ᏕᏍᏗᏙᎬ ᏧᏳᎪᏗ ᏨᏗᎦᏚᎭ ᏫᏍᏗᏣᎯ; ᏫᏍᏗᏴᎸᏉᏃ ᎾᎿᏂ, ᏓᏰᏍᏗᏩᏛᎯ ᏗᎦᎵᎠᏅᎯᏛ ᎠᎩᎾ ᎨᎵᏌᏕᏍᏗ, ᎾᏍᎩ ᎥᏝ ᎩᎶ ᏴᏫ ᎤᎩᎸᏔᏅᎯ ᏱᎩ; ᎡᏍᏕᎵᏌᏕᏒᎭ ᎠᎴ ᏤᏍᏓᏘᏁᏒᎭ.


text:
ᏥᏌᏃ ᏣᎷᏏᎵᎻ ᏭᏴᎴᎢ, ᎠᎴ ᎤᏔᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᏭᏴᎴᎢ; ᎿᏉᏃ ᎬᏩᏚᏫᏛ ᏚᎧᎿᏂᏙᎸ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᏚᎧᎿᏅ, ᎠᎴ ᎿᏉ ᎤᏒᎯᏴᏱ ᎨᏎᎢ, ᎤᏄᎪᏤ ᏇᏗᏂᏱ ᏭᎶᏎ ᎠᏁᎮ ᏔᎳᏚ ᎢᏯᏂᏛ.


text:
ᏭᎪᎮᏃ Ꭸ ᎢᏴᏛ ᏗᏡᎨ ᏒᎦᎳᎢᏳᏍᏗ, ᎤᎵᏍᏚᏎᎢ, ᏭᎷᏤᎢ, ᏯᏎᎦᎩ ᏱᏥᏩᏛ ᎪᏞᏍᏗ ᏳᏔ ᎤᏪᎵᏎᎢ; ᎾᎿᏃ ᏭᎷᏨ ᎥᏝ ᎪᏞᏍᏗ ᏳᏩᏛᎮ ᎤᎵᏍᏚᏒᏉ ᎤᏩᏒ; ᎥᏞᏰᏃ ᎠᏏ ᏳᏍᏆᎸᎮ ᏒᎦᏔᎢᏳᎾᏍᏗ ᎤᏅᏂᏍᏗᏱ.


text:
ᏥᎷᏏᎵᎻᏃ ᎤᏂᎷᏤᎢ; ᏥᏌᏃ ᎤᏔᏅ-ᏗᎦᏔᏫᎢᏍᏗᏱ ᏭᏏᎸ, ᎤᎴᏅᎮ ᏚᏄᎪᏫᏎ ᎠᏂᎾᏕᎩ ᎠᎴ ᎤᏂᏩᏒᎥᏍᎩ ᎾᎿ ᎤᏔᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᏚᎷᏆᏗᏅᏎ ᏚᏂᏍᎩᎸ ᎠᏕᎸ ᏗᏂᏟᏴᏍᎩ, ᎠᎴ ᎤᎾᏅᏗᏱ ᎫᎴ-ᏗᏂᏍᎪᏂᎯ ᏗᏂᎾᏕᎩ;


text:
ᏚᏕᏲᏁᏃ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᏝᏍᎪ ᎯᎠ ᏱᏂᎬᏅ ᏱᎪᏪᎳ, ᎠᏆᏤᎵ ᎠᏓᏁᎸ ᏂᎦᏗᏳ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᎾᏓᏙᎵᏍᏙᏗᏱ ᏚᏙᎡᏍᏗ? ᏂᎪᏍᎩᏂ ᎠᏂᏃᏍᎩᏍᎩ ᎤᏂᏴᏍᏗᏱ ᎤᏍᏓᎦᎸ ᏂᏨᏁᎸ.


text:
ᏗᏃᏪᎵᏍᎩᏃ ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎤᎾᏛᎦᏁᎢ, ᎠᎴ ᎤᏂᏲᎴ ᎢᏳᏅᏁᏗᏱ ᎤᏂᎯᏍᏗᏱ; ᎬᏩᎾᏰᏍᎨᏰᏃ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏂᎦᏛ ᏴᏫ ᎤᏂᏍᏆᏂᎪᏍᎬ ᏄᏍᏛ ᏓᏕᏲᎲᏍᎬᎢ.


text:
ᎤᏙᎯᏳᎯᏯᏰᏃ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎩᎶ ᎯᎠ ᏂᎦᏪᏎᎮᏍᏗ ᎯᎠ ᏦᏓᎸ, ᏪᏣᎲᎾ, ᎠᎴ ᎠᎺᏉᎯ ᏪᏣᏚᎦ; ᎠᎴ ᏄᏜᏏᏛᎡᎲᎾ ᎢᎨᏎᏍᏗ ᎤᎾᏫᏱ, ᎪᎯᏳᎲᏍᎬᏍᏗᏉᏍᎩᏂ ᎾᏍᎩ ᏂᎦᏪᏍᎬ ᎠᏎ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ; ᎾᏍᎩ ᎤᎨᏍᏗ ᏂᎦᎥ ᏄᏪᏒᎢ.


text:
ᎢᏳᏃ ᎢᏣᎴᎲᏍᎨᏍᏗ ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ, ᎨᏣᏓᏁᎮᏍᏗ ᎡᏥᏍᎦᏅᏤᎸᎢ, ᎢᏳᏃ ᎪᎱᏍᏗ ᎡᏤᎵᏎᎮᏍᏗ ᎩᎶᎢ; ᎾᏍᎩ ᎾᏍᏉ ᎢᏥᏙᏓ ᎦᎸᏔᏗ ᏤᎭ ᎦᎨᏥᏁᏗᏱ ᎯᎠ ᎢᏥᏍᎦᏅᏨᎢ.


text:
ᎤᎴᏅᎮᏃ ᏚᏬᏁᏔᏁ ᏓᏟᎶᏍᏗᏍᎬᎢ. ᎩᎶ ᎢᏳᏍᏗ ᏖᎸᎳᏗ ᏚᏫᏎᎢ, ᎠᎴ ᎤᏐᏱᎴ ᎬᏩᏚᏫᏛ, ᎠᎴ ᎤᏍᎪᏎ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎪᏢᏗᏱ, ᎠᎴ ᎤᏁᏍᎨᎮ ᎢᏅ ᎢᎦᏘ, ᎠᎴ ᏚᏙᎳᏍᏔᏁ ᏠᎨᏏ ᏧᏂᎸᏫᏍᏓᏁᎯ, ᎠᎴ ᎢᏅ ᏭᎶᏎᎢ.


text:
ᎤᏂᎷᏨᏃ, ᎯᎠ ᏂᎬᏩᏪᏎᎴᎢ, ᏔᏕᏲᎲᏍᎩ, ᎣᏥᎦᏔᎭ ᏚᏳᎦᎲ ᎯᏬᏂᏍᎬ ᎨᏒᎢ, ᎠᎴ ᎩᎶ ᏂᏖᎾᏰᏍᎬᎾ ᎨᏒᎢ; ᎥᏝᏰᏃ ᏄᎾᏍᏛ ᏴᏫ ᏱᏖᎸᏉᏙᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎤᏅᏅ ᎤᏙᎯᏳᏒ ᏕᎭᏕᏲᎲᏍᎪᎢ; ᏚᏳᎪᏗᏍᎪ ᎠᏰᎵ ᎠᎾᏓᏱᏍᎬ ᏏᏌ ᎠᎫᏴᎡᏗᏱ, ᏝᎨ?


text:
ᏔᏕᏲᎲᏍᎩ, ᎼᏏ ᎣᎪᏪᎳᏁᎸᎩ ᎯᎠ ᏃᎩᏪᏎᎸᎩ, ᎠᎾᎵᏅᏟ ᎩᎶ ᎠᏲᎱᏍᎨᏍᏗ, ᎠᎴ ᎤᏓᎵᎢ ᎢᎦᎧᎯᏯᏍᎨᏍᏗ, ᏧᏪᏥᏃ ᏂᏗᎦᎧᎯᏯᏍᎬᎾ ᎢᎨᏎᏍᏗ, ᎠᎾᎵᏅᏟ ᎠᏯᏂᏍᎨᏍᏗ ᎤᏓᎵᎢ, ᎠᎴ ᎾᏍᎩ ᎠᎾᎵᏅᏟ ᏧᏪᏥ ᏓᏛᎯᏍᏓᏁᎮᏍᏗ.


text:
ᏧᏂᏲᎱᏒᎯᏃ ᎾᏍᎩ ᏧᎾᎴᎯᏐᏗ ᎨᏒᎢ; ᏝᏍᎪ ᏱᏥᎪᎵᏰᎣ ᎼᏏ ᎤᏤᎵ ᎪᏪᎵᎯ, ᎾᏍᎩ ᎤᏪᏲᏓᏛ ᎤᏁᎳᏅᎯ ᎤᎵᏃᎮᏔᏅᎢ, ᎯᎠ ᏄᏪᏎᎸᎢ, ᎠᏴ ᎠᏆᏁᎳᏅᎯ ᎡᏆᎭᎻ ᎤᏤᎵᎦ, ᎠᎴ ᎠᏆᏁᎳᏅᎯ ᎡᏏᎩ ᎤᏤᎵᎦ, ᎠᎴ ᎠᏆᏁᎳᏅᎯ ᏤᎦᏈ ᎤᏤᎵᎦ.


text:
ᏗᏃᏪᎵᏍᎩᏃ ᎨᏒ ᎠᏏᏴᏫ ᎤᎷᏤᎸ, ᎤᏛᎦᏅ ᎠᎾᎵᏃᎮᏍᎬᎢ, ᎠᎴ ᎤᏙᎴᎰᏒ ᎣᏏᏳ ᏄᏪᏒ ᏚᏁᏤ ᎸᎢ, ᎤᏛᏛᏁᎢ, ᎦᏙ ᎤᏍᏗ ᎤᏟ ᎦᎸᏉᏗᏳ ᏂᎦᏛ ᏗᎧᎿᏩᏛᏍᏗ ᎨᏒᎢ? ᎤᏛᏁᎢ.


text:
ᎠᎴ ᎯᎨᏳᏎᏍᏗ ᏱᎰᏩ ᏣᏁᎳᏅᎯ ᎲᏗᏍᎨᏍᏗ ᏂᎬ ᏣᎾᏫ, ᎠᎴ ᏂᎬᏣᏓᏅᏙ, ᎠᎴ ᏂᎬ ᏣᏓᏅᏖᏗᏱ, ᎠᎴ ᏂᎦᎥ ᏣᎵᏂᎬᎬᎢ. ᎯᎠ ᎾᏍᎩ ᏭᏓᎪᎾᏛᏛ ᎦᎸᏉᏗ ᏗᎧᎿᏩᏛᏍᏗ.


text:
ᏔᎵᏁᏃ ᎨᏒᎢ, ᎾᏍᎩᏯᏉ, ᎯᎠ ᎾᏍᎩ ᏄᏍᏗ, ᏨᏒ ᏂᏣᏓᎨᏳᏒ ᎾᏍᎩᏯ ᏂᎨᏳᏎᏍᏗ ᎾᎥ ᎢᏗᏍᏓᏓᎳ. ᎥᏝ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏛᏍᏗ. ᏯᎭ ᎤᏟ ᎢᎦᎸᏉᏗ ᎡᏍᎦᏉ ᎾᏍᎩ.


text:
ᎾᏍᎩᏃ ᏓᎨᏳᏗᏱ ᎬᏙᏗᏱ ᏂᎬ ᎣᎾᏫᏱ, ᎠᎴ ᏂᎬ ᎠᏓᏅᏖᏗᏱ, ᎠᎴ ᏂᎬ ᎠᏓᏅᏙ, ᎠᎴ ᏂᎦᎥ ᏃᎵᏂᎬᎬᎢ, ᎠᎴ ᎾᎥ ᎢᏳᎾᏓᎳ ᎤᏩᏒ ᎤᏓᎨᏳᏒ ᎾᏍᎩᏯ ᎤᎨᏳᏗᏱ, ᎤᏟ ᎦᎸᏉᏗᏳ ᎡᏍᎦᏉ ᏂᎦᏛ ᏗᎬᏩᏃᏍᏛ ᎠᏥᎸ ᏗᎨᎳᏍᏙᏗ, ᎠᎴ ᎠᎵᏍᎪᎸᏙᏗ.


text:
ᏥᏌᏃ ᎤᎪᎲ ᎠᎦᏔᎿᎢ ᎢᏳᏪᏍᏗ ᏁᏪᏒ ᎤᏁᏨᎢ, ᎯᎠ ᏄᏪᏎᎴᎢ, ᎥᏝ ᎢᏅᎯᏳ ᏱᏂᏣᏛᎿᏕᎦ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ ᎨᏒᎢ. ᎾᎪᏳᏃ ᎢᏳᏓᎴᏅᏛ ᎥᏝ ᎩᎶ ᎪᎱᏍᏗ ᎬᏩᏛᏛᏗ ᏱᎨᏎᎢ.


text:
ᏕᏫᏰᏃ ᎤᏩᏒ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎤᏪᏲᎲᏍᎬ ᎯᎠ ᏄᏪᏎᎢ, Ᏹ-ᎰᏩ ᎯᎠ ᏁᏪᏎᎴ ᎠᏆᏤᎵ ᎤᎬᏫᏳᎯ, ᏥᎦᏗᏏ ᎢᏗᏢ ᏦᎴᏍᏗ ᎬᏂ ᎨᏣᏍᎦᎩ ᏗᏣᎳᏏᏗᏱ ᎦᏍᎩᎶ ᏂᎦᏥᏴᏁᎸᎭ.


text:
ᏫᏚᏯᏅᎲᏃ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎯᎠ ᎾᏍᎩ ᎤᏲ ᎢᏳᏛᎿᏕᎩ ᎤᏬᏑᎶᏨᎯ ᎤᏟ ᎢᎦᎢ ᎠᎲᎦ ᎡᏍᎦᏉ ᏂᎦᏛ ᎾᏍᎩ ᎠᏕᎸ-ᏗᏗᏱ ᏣᏂᎲᎦ.


text:
ᏧᎾᏓᎴᏛᏰᏃ ᏴᏫ ᏙᏛᎾᎴᏂ ᏙᏛᎾᏓᏡᏔᏂ, ᎠᎴ ᎠᏰᎵ ᏕᎪᏢᏩᏗᏒ ᏙᏛᎾᏓᏡᏔᏂ; ᎠᎴ ᎦᏙᎯ ᏓᎵᏖᎸᏂᏙᎮᏍᏗ, ᎠᎴ ᏓᎪᏄᎶᏏᏙᎮᏍᏗ ᎠᎴ ᎤᏕᏯᏙᏗ ᏂᎦᎵᏍᏔᏂᏙᎮᏍᏗ; ᎯᎠ ᎾᏍᎩ ᎠᏓᎴᏂᏍᎬ ᎠᎩᎵᏯ.


text:
ᎠᏗᎾ ᎢᏤᏯᏔᎮᏍᏗ; ᏓᏂᎳᏫᎥᏰᏃ ᏕᎨᏥᏲᏍᏗ; ᏧᏂᏔᏫᎢᏍᏗᏱᏃ ᏕᏥᎵᎥᏂᎮᏍᏗ; ᎠᎴ ᏄᏂᎬᏫᏳᏌᏕᎩ ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎠᏂᏅ ᏤᏣᏖᏃᎯᏍᏗ ᎨᏎᏍᏗᎠᏴ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎪᎯᏳᏗᏍᎩ ᏧᏂᏕᏖᎴᎩ.


text:
ᎠᎴ ᎿᏉ ᏕᏣᏗᏁᎨᏍᏗ, ᎠᎴ ᏕᏥᏲᏍᎨᏍᏗ, ᏞᏍᏗ ᎢᎬᏱ ᎦᏰᎯ ᏱᏤᎵᎯᏍᎨᏍᏗ ᎢᏥᏪᏍᏗᏱ ᎢᏥᏁᎢᏍᏗᏱ, ᎠᎴ ᏞᏍᏗ ᎢᎬᏱ ᎦᏰᎯ ᏱᏣᏓᏅᏖᏍᎨᏍᏗ; ᏄᏍᏛᏍᎩᏂ ᏫᎯᏳ ᎨᏒ ᎡᏥᏁᎸ ᎾᏍᎩ ᎢᏥᏁᎨᏍᏗ; ᎥᏝᏰᏃ ᏂᎯ ᏱᏣᏁᎪᎢ, ᎦᎸᏉᏗᏳᏍᎩᏂ ᎠᏓᏅᏙ.


text:
ᎠᎾᎵᏅᏟᏃ ᏚᏲᏍᎨᏍᏗ ᎠᎾᎵᏅᏟ ᎤᏲᏞᎯᎯᏍᏗᏱ; ᎠᏍᎦᏯᏃ ᎤᏪᏥ ᏚᏲᏍᎨᏍᏗ; ᎠᎴ ᏗᎨᎦᏅᎩ ᏓᎾᎴᎲᏍᎨᏍᏗ ᏧᏂᎦᏴᎵᎨ ᏓᎾᏡᏗᏍᎨᏍᏗ, ᎠᎴ ᎾᏍᎩ ᎾᏅᏂᏏᏍᎨᏍᏗ ᏕᎨᏥᎢᎮᏍᏗ.


text:
ᎢᏥᎪᏩᏖᏍᎨᏍᏗᏍᎩᏂ ᎤᏍᎦᎢᏍᏗ ᎠᏛᏗᏍᎩ ᏕᏂᎵ ᎠᏙᎴᎰᏍᎩ ᎤᏁᎢᏍᏔᏅᎯ, ᎦᏙᎨᏍᏗ ᎾᎿ ᎬᏩᎴᏗ ᏂᎨᏒᎾ, (ᎩᎶ ᎠᎪᎵᏰᏍᎨᏍᏗ ᎪᎵᎨᏍᏗ,) ᎿᏉ ᏧᏗᏱ ᎠᏂᏂ ᎠᎾᎵᏒᎭ ᏙᏦᏓᎸ ᏩᏂᎶᏒᎭ.


text:
ᎦᎶᏁᏛᏰᏃ ᎤᎾᏤᎸᎯ ᎠᎴ ᎠᎾᏙᎴᎱᏍᎩ ᎤᎾᏤᎸᎯ ᏛᏂᎾᏄᎪᏥ, ᎠᎴ ᎠᏂᎾᏄᎪᏫᏍᎨᏍᏗ ᎤᏰᎸᏛ ᎠᎴ ᎤᏍᏆᏂᎪᏗ, ᎾᏍᎩ ᏧᏂᎶᏄᎮᏗᏱ, ᎢᏳᏃ ᏰᎵᏱᎩ, ᎾᏍᏉ ᎨᎦᏑᏰᏛ.


text:
ᎿᏉᏃ ᏙᏓᎦᏅᏏ ᏧᏤᎵ ᏗᏂᎧᎿᏩᏗᏙᎯ, ᎠᎴ ᏙᏓᎦᏟᏌᏂ ᎨᎦᏑᏰᏛ ᏧᏤᎵᎦ ᏫᏙᏛᏯᏅᎯ ᏅᎩ ᏂᏙᏗᎨᎶᏍᎬ ᎤᏃᎴ, ᎡᎶᎯ ᏭᎵᏍᏘᏂᎸ ᏅᏓᏳᏓᎴᏛ ᎦᎸᎳᏃ ᏭᎵᏍᏘᏂᎸ ᏫᎦᎷᎩ.


text:
<n>[ᏴᏫᏰᏃ ᎤᏪᏥ ᎾᏍᎩᏯᏉ ᎠᏍᎦᏯ ᏣᏂᎩᏍᎪ ᎢᎸᎯᏢ ᏤᎪᎢ, ᎾᏍᎩ ᏥᎬᏕᎪ ᎦᏁᎸᎢ, ᎠᎴ ᎠᏂᎦᏘᏯ ᏥᏂᏕᎬᏁᎰ ᏧᏅᏏᏓᏍᏗ, ᎠᎴ ᎠᏂᏏᏴᏫᎭ ᏧᏂᎸᏫᏍᏓᏁᏗ ᏥᏓᏁᎰᎢ, ᎠᎴ ᎦᎶᎯᏍᏗᏱ ᎠᎦᏘᏯ ᏥᎧᏁᏤᎰ ᎤᏯᏫᏗᏱ.


text:
ᏔᎵᏃ ᏫᏄᏒᎸ ᎧᏃᎯᏴᎩ ᏗᎵᏍᏓᏴᏗᏱ ᎠᎴ ᎾᎪᏔᏅᎾ ᎦᏚ ᎠᎩᏍᏗᏱ ᎤᏍᏆᎸᏗ ᎨᏎᎢ, ᏄᏂᎬᏫᏒᏃ ᎠᏥᎸᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ ᎤᏂᏲᎴ ᎢᏳᎾᏛᏁᏗᏱ ᎦᎶᏄᎮᏛ ᎤᏅᏙᏗᏱ ᎤᏂᏂᏴᏗᏱ, ᎠᎴ ᎤᏂᎯᏍᏗᏱ.


text:
ᏇᏗᏂᏱᏃ ᎡᏙᎮᎢ, ᏌᏩᏂ ᎠᏓᏰᏍᎩ ᎤᏢᏨᎯ ᎦᏁᎸᎢ, ᎦᏅᎨᏃ ᎠᎵᏍᏓᏴᎲᏍᎨᎢ, ᎠᎨᏴ ᎤᎷᏤ ᎠᏰᎮ ᎫᎫ ᏅᏯ ᎤᏁᎬ ᎠᏢᏔᏅᎯ ᎠᏟᏍᏕ ᎠᏠᏁᏗ ᎾᏓ ᏧᏙᎢᏛ, ᎤᏣᏘ ᏧᎬᏩᎶᏗ; ᎠᎴ ᎤᎶᏒ ᎫᎫ, ᎠᎴ ᎤᎶᏁᏔᏁ ᎠᏍᎪᎵ.


text:
ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎢᎸᎯᏢ ᎯᎠ ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎠᎵᏥᏙᏗ ᏂᎦᎵᏍᏗᏍᎨᏍᏗ ᎡᎶᎯ ᏂᎬᎾᏛᎢ, ᎯᎠ ᎾᏍᎩ ᏥᎾᏛᎦ ᎾᏍᏉ ᎤᏂᏃᎮᏗ ᎨᏎᏍᏗ ᎾᏍᎩ ᎠᎦᏅᏓᏗᏍᏙᏗ.


text:
ᎢᎬᏱᏱᏃ ᎢᎦ ᎾᎪᏔᏅᎾ ᎦᏚ ᎠᎩᏍᏗᏱ, ᎾᎯᏳ ᎤᏂᎸ ᎧᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ, ᎬᏩᏍᏓᏩᏗᏙᎯ ᎯᎠ ᏂᎬᏩᏪᏎᎴᎢ, ᎭᏢ ᏣᏚᎵ ᏬᎦᏛᏅᎢᏍᏙᏗᏱ, ᎧᏃᎯᏰᎩ ᏣᎵᏍᏓᏴᏗᏱ?


text:
ᏴᏫ ᎤᏪᏥ ᎤᏙᎯᏳᎯ ᎤᏪᏅᏍᏗ ᎾᏍᎩᏯ ᏂᎬᏅ ᎪᏪᎸ ᎠᏥᏃᎮᏍᎬᎢ; ᎠᏎᏃ ᎤᏲᎢᏳ ᎢᏳᎵᏍᏓᏁᏗ ᎾᏍᎩ ᎠᏍᎦᏯ ᏴᏫ ᎤᏪᏥ ᎠᏡᏗᏍᎩ! ᎣᏏᏳ ᏱᎨᏎ ᎢᏳᏃ ᎾᏍᎩ ᎠᏍᎦᏯ ᏄᏕᏅᎾᏉ ᏱᎨᏎᎢ.


text:
ᏥᏌᏃ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᏂᏥᎥ ᏂᎯ ᏙᏓᏦᏕᎵ ᎪᎯ ᏒᏃᏱ ᏥᎩ, ᎠᏴ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ; ᎯᎠᏰᏃ ᏂᎬᏅᎢᎪᏪᎳ, ᎠᏫ ᏗᎦᏘᏯ ᏓᏥᏴᏂᎵ, ᎤᏂᏃᏕᎾᏃ ᏛᎾᏗᎦᎴᏲᏥ.


text:
ᎠᎴ ᎯᎠ ᏁᏪᏎᎢ, ᎠᏆ, ᎡᏙᏓ, ᏂᎯ, ᎨᏒ ᏰᎵᎦᏍᏉ ᎢᎨᏣᏛᏁᏗ ᏂᎦᎥᎢ; ᏍᎩᎲᏏᏉ ᎯᎠ ᎾᏍᎩ ᎤᎵᏍᏈᏗ; ᎥᏝᏍᎩᏂᏃᏅ ᎠᏴ ᎠᏆᏚᎵᏍᎬᎢ, ᏂᎯᏍᎩᏂ ᏣᏚᎵᏍᎬᎢ.


text:
ᏦᎢᏁᏃ ᏫᏚᎷᏤᎴᎢ, ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎨᏥᎵᏁᏍᏗᏉ ᎿᏉ, ᎠᎴ ᎢᏣᏣᏪᏐᎸᏍᏓ; ᎿᏉ ᎦᎶᏐᎾ-ᎿᏉ ᎠᏍᏆᎸ ᎾᎯᏳ ᎨᏒᎢ; ᎬᏂᏳᏉ ᏴᏫ ᎤᏪᏥ ᎠᏂᏍᎦᎾ ᏕᎨᏥᏲᎯᏏ.


text:
ᎩᎳᏉᏃ ᎢᏴᏛ ᎠᏏᏉ ᎦᏪᏂᏍᎨᎢ, ᏧᎾᎸᎪᏤ, ᏧᏓᏏ, ᎠᏏᏴᏫ ᏔᎳᏚ ᎢᏯᏂᏛ ᎨᏒ, ᏓᏘᏁᎮ ᎤᏂᏣᏘ, ᎠᏰᎳᏍᏗ-ᏗᎦᏅᎯᏛ ᎠᎴ ᎠᏓ ᏗᏂᏁᎯ, ᏅᏓᎬᏩᏂᏅᏏᏛ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ, ᎠᎴ ᏗᏃᏪᎵᏍᎩ, ᎠᎴ ᏗᏂᎳᏫᎩ.


text:
ᎤᏡᏗᏍᎩᏃ ᎬᏂᎨᏒ ᎢᏧᏩᏁᎸᎯ ᎨᏎ ᎤᎾᏙᎴᎰᎯᏍᏙᏗ, ᎯᎠ ᎢᏳᏪᏒᎯ ᎨᏎᎢ, ᎩᎶ ᏥᏯᏚᏣᎳᏅᎭ, ᎾᏍᎩ ᎨᏎᏍᏗ, ᏒᏥᏏᏴᎲᎭ, ᎡᏣᏘᎾᏫᏛᎲᎭ ᎬᏩᏚᏓᎴᏍᏗ ᏂᎨᏒᎾ ᏁᏨᏁᏍᏗ.


text:
ᎣᎦᏛᎦᏅᎩ ᎯᎠ ᏂᎧᏪᏍᎬᎩ, ᏓᏥᏲᏍᏔᏂ ᎯᎠ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎾᏍᎩ ᏗᎪᏱ ᏗᎬᏔᏅᎯ ᎪᏢᏅᎯ, ᏦᎢᏉᏃ ᏧᏒᎯᏛ ᏛᏥᏱᎵᏙᎵ ᏛᎦᏁᏍᎨᎯ ᏅᏩᏓᎴ ᏗᎪᏱ ᏗᎬᏔᏅᎯ ᏂᎨᏒᎾ.


text:
ᎩᎳᏉᏃ ᎢᏴᏛ ᏭᎩᏨᏅ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ, ᎠᎴ ᏧᎾᏛᏐᏅᎯ, ᎠᎴ ᏗᏃᏪᎵᏍᎩ, ᎠᎴ ᏂᎦᏛ ᏗᏂᎳᏫᎩ ᎤᎾᎵᏃᎮᎸ ᎤᎾᎸᎴ ᏥᏌ, ᎠᎴ ᎤᎾᏖᎾᏫᏛᎮᎢ, ᎠᎴ ᏆᎴᏗ ᏫᏚᏂᏲᎯᏎᎴᎢ.


text:
ᏦᎢᏁ ᎢᏳᏟᎶᏛ ᎤᎵᏰᎢᎶᎸ ᏥᏌ ᎠᏍᏓᏯ ᎤᏪᎷᏁᎢ, ᎯᎠ ᏄᏪᏎᎢ, ᎢᎶᎢ, ᎢᎶᎢ, ᎳᎹ ᏌᏆᏓᏂ? ᎾᏍᎩ ᎠᏁᏢᏔᏅᎯ ᎯᎠ ᏄᏍᏗ ᎦᏛᎦ, ᎠᏆᏁᎳᏅᎯ, ᎠᏆᏁᎳᏅᎯ, ᎦᏙᏃ ᎥᏍᏋᏕᎩ?


text:
ᎠᏎᏴᏫᏃ ᏚᏍᏆᎸᏔᏅ, ᎠᎴ ᏚᏬᎵ ᏧᏂᏦᏯᏍᏗ ᏭᎧᎵᎢᏍᏔᏅ, ᎠᎴ ᎦᎾᏍᏙᎯ ᎤᏪᏆᏔᏅ, ᎤᏁᏁᎸ ᎤᏗᏔᏍᏗ; ᎯᎠ ᏄᏪᏎᎢ, ᎤᏁᎳᎩ, ᎢᏓᏙᎴᎰᎯ, ᏥᎪᏃ ᎢᏔᏯ ᏓᎦᎷᏥ ᏓᏳᏠᎥᏔᏂᎵ.


text:
ᏦᏩ ᎠᎵᎹᏗᏱ ᎡᎯ ᎠᏥᎸᏉᏗ ᏗᎦᎳᏫᎩ, ᎾᏍᎩ ᎾᏍᏉ ᎠᎦᏘᏰ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎤᎷᎯᏍᏗᏱ, ᎾᏍᎩ ᎤᎷᏤᎢ, ᎠᎴ ᎾᏍᎦᎢᎲᎾ ᏭᏴᎴ ᏆᎴᏗᏱ, ᎠᎴ ᎤᏔᏲᎴ ᏥᏌ ᎠᏰᎸᎢ.


text:
ᎤᏩᏒᏃ ᎤᏏᏙᎵ ᏙᎴᏛ ᎠᏄᏬ, ᎠᎴ ᎤᏕᏒ ᎠᏰᎸᎢ, ᎠᎴ ᎠᏄᏬᎩᎯ ᏙᎴᏛ ᎤᏪᏣᎸᎳᏅ, ᎠᏤᎵᏍᏛ ᎤᏅᏁ ᎾᏍᎩ ᏅᏲᎯ ᎠᏍᎪᏒᎢ, ᎠᎴ ᏅᏲᎯ ᎠᏍᎪᏒᎢ, ᎠᎴ ᏅᏯ ᎤᏪᏌᏉᎴᎴᎢ ᎠᏤᎵᏍᏛ ᎦᎶᎯᏍᏗᏱ ᎤᏁᎢ.


text:
ᎣᏂᏃ ᎬᏂᎨᏒ ᏂᏚᏛᏁᎴ ᏌᏚ ᎢᏯᏂᏛ ᎠᎾᎵᏍᏓᏴᎲᏍᎬᎢ, ᎠᎴ ᏚᎬᏍᎪᎸᏁ ᏂᎦᎵᏍᏙᏗᏍᎨ ᏄᏃᎯᏳᏒᎾ ᎨᏒ ᎠᎴ ᏗᏍᏓᏱᏳ ᎨᏒ ᏧᏂᎾᏫ, ᏂᏚᏃᎯᏳᏅᎾ ᎨᏎ ᎢᏳᏍᏗ ᎾᏍᎩ ᎬᏩᎪᎲᎯ ᏧᎴᎯᏌᏅᎯ ᏂᎨᏎᎢ.


text:
ᎾᎯᏳ ᎡᎶᏛ ᎤᎬᏫᏳᎯ ᎨᏎ ᏧᏗᏱ, ᎩᎶ ᎢᏳᏍᏗ ᎡᎮ ᎠᏥᎸ-ᎨᎶᎯ ᏤᎦᎳᏯ ᏧᏙᎢᏛ, ᎾᏍᎩ ᎡᏆᏯ ᎠᎦᏘᏅᏔᏅ ᎨᎳ ᎨᏎᎢ, ᎤᏓᎵᎢᏃ ᎡᎳᏂ ᏧᏪᏥᏛᎯ ᎨᏒ ᎤᏓᏳᏓᎴᏅᎯ ᎨᏎᎢ, ᎠᎴ ᎵᏏ ᏚᏙᎡᎢ.


text:
ᎠᎴ ᎢᏧᎳ ᏚᏳᎪᏛ ᏧᏂᎸᏫᏍᏓᏁᎯ ᎨᏎ ᎤᏁᎳᏅᎯ ᏙᏗᎧᏅᎢ, ᏓᏂᎧᎿᏩᏗᎭ ᏂᎦᏛ ᏗᎧᎿᏩᏛᏍᏗ ᎠᎴ ᎤᎵᏁᏨ ᎢᏯᏛᏁᎵᏓᏍᏗ ᎨᏒ ᏱᎰᏩ ᏧᏤᎵᎦ, ᎤᏐᏅ ᏂᎨᏥᎳᎾᏎᎲᎾ.


text:
ᎠᎴ ᎠᏥᎸᏉᏗᏳ ᎨᏎᏍᏗ ᏱᎰᏩ ᏙᏗᎧᏅᎢ, ᎥᏝ ᎠᎴ ᎤᏗᏔᏍᏗ ᏱᎨᏎᏍᏗ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎠᎴ ᎠᏓᏴᏍᏕᏍᏗᏍᎩ; ᎠᎴ ᎤᎧᎵᏨᎯ ᎨᏎᏍᏗ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ, ᎤᏥ ᎤᎾᏅᎪᏫᏒ ᎤᏓᎬᏩᏓᎴᏅᏛ.


text:
ᎠᎴ ᎢᎬᏱ ᏓᏳᏪᏅᎡᎵ <n>[ᎤᎬᏫᏳᎯ]</n> ᎢᎳᏯ ᎾᏍᎩᏯ ᎨᏎᏍᏗ ᎤᏓᏅᏙᎩ ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎨᏒᎢ, ᏔᎦᏔᎲᏍᏗᏱ ᏧᏂᎾᏫ ᎠᏂᎦᏴᎵᎨᎢ ᏗᏂᏲᎵ ᎢᏗᏢ ᏫᏚᎦᏔᎲᏍᏙᏗᏱ, ᎠᎴ ᏄᏃᎯᏳᏒᎾ ᏧᎦᏔᎲᏍᏗᏱ ᎤᎾᏓᏅᏘ ᎠᏂᎦᏔᎿᎥ ᎢᏗᏢ ᏫᏚᎦᏔᎲᏍᏙᏗᏱ; ᏧᏛᏅᎢᏍᏙᏗᏱ ᏴᏫ, ᎤᎬᏫᏳᎯ ᏧᏛᏅᎢᏍᏓᏁᏗᏱ.


text:
ᎠᎴ ᎬᏂᏳᏉ ᏨᎨᏫ ᎨᏎᏍᏗ, ᎠᎴ ᎨᏣᏁᎢᏍᏗ ᏂᎨᏒᎾ ᎨᏎᏍᏗ ᎬᏂ ᎾᎯᏳ ᎢᎦ ᎾᏍᎩ ᎯᎠ ᏂᎦᎵᏍᏔᏅᎭ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᏂᏦᎯᏳᏅᎾ ᎨᏒ ᏥᏁᎬᎢ, ᎾᏍᎩ ᎠᏎ ᎢᏳᎵᏍᏙᏗ ᏥᎩ ᎢᏳᎵᏍᏙᏗᏱ ᎠᏍᏆᎸᎲᎭ.


text:
ᏗᎧᎿᏩᏗᏙᎯᏃ ᎤᏁᏨ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏧᏣᎷᏤᎵ ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᏩᏍᏛ ᎦᎸᎳᏗᏳ ᎡᎯ ᏓᏣᏓᏩᏗᏍᏙᏔᏂ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᏉ ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᏨᏓᏣᏕᏁᎵ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎠᎪᏎᎮᏍᏗ.


text:
ᎠᎴ ᏦᏩ ᎾᏍᏉ ᎨᎵᎵ ᎤᏂᎩᏎᎢ ᎤᏄᎪᏤ ᎠᏎᎵᏗ ᎦᏑᎲᎢ, ᏭᎷᏤ ᏧᏗᏱ, ᏕᏫ ᏧᏪᏚᎲᎢ, ᎦᏚᏱ ᏧᏙᎢᏛ, ᏕᏫᏰᏃ ᎤᏁᏢᏔᏅᏛ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ ᎨᏎᎢ ᎤᎦᏴᎵᎨ ᎨᏎᎢ ᎠᎴ ᏕᏫ,


text:
ᎿᏉᏃ ᎯᎠ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎬᏩᎾᏓᏅᎡᎸ, ᎦᎸᎳᏗ ᎾᎤᏂᎶᏒ, ᎯᎠ ᏂᏚᎾᏓᏪᏎᎴ ᎠᏫ-ᏗᏂᎦᏘᏯ; Ꭷ, ᎿᏉ ᎦᏚᏱ ᎢᏕᎾ, ᎠᎴ ᏫᏓᏙᎴᎰᎯ ᎾᏍᎩ ᎯᎠ ᏄᎵᏍᏔᏅᎢ, ᎾᏍᎩ ᎣᎰᏩ ᎬᏂᎨᏒ ᏥᏂᎬᏂᏏ.


text:
ᎠᎴ ᎬᏂᏳᏉ ᎩᎶ ᎢᏳᏍᏗ ᎠᏯᎦᏯ ᏥᎷᏏᎵᎻ ᎡᎮ ᏏᎻᏯᏂ ᏧᏙᎢᏛ; ᎠᎴ ᎾᏍᎩ ᏚᏳᎪᏛ ᎢᏯᏛᏁᎯ ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᎧᎿᏩᏎᎩ ᎨᏎᎢ, ᎠᎦᏘᏰ ᎢᏏᎵ ᎨᏥᏄᏬᎯᏍᏙᏗᏱ; ᎦᎸᏉᏗᏳᏃ ᎠᏓᏅᏙ ᏔᎵ ᎤᏛᏗᏕᎨᎢ.


text:
ᏏᎻᏯᏂᏃ ᎣᏍᏛ ᏚᏁᏤᎴᎢ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎴ ᎺᎵ ᎠᏲᎵ ᎤᏥ, ᎬᏂᏳᏉ ᎯᎠ ᎾᏍᎩ ᎠᏲᎵ ᎠᏥᎧᏅ ᎾᏍᎩ ᎢᏏᎵ ᎠᏁᎯ ᎤᏂᏣᏘ ᏧᏂᏅᎢᏍᏗᏱ ᎠᎴ ᏧᎾᎴᎯᏐᏙᏗᏱ; ᎠᎴ ᎤᏰᎸᏛ ᎤᎾᏡᏙᏗ ᎠᏂᏬᏂᏍᎬᎢ.


text:
ᎠᎴ ᎩᎶ ᎢᏳᏍᏗ ᎠᎨᏴ ᎡᏂᏧᏙᎢᏛ ᎠᏙᎴᎰᏍᎩ ᎡᎮᎢ, ᎾᏍᎩ ᏆᏄᎡᎵ ᎤᏪᏥ ᎨᏎᎢ, ᎡᏌ ᎠᏂᎳᏍᏓᎸ ᎤᏠᏱ, ᎾᏍᎩ ᎤᏣᏘ ᎠᎦᏴᎵᎨ ᎨᏎᎢ, ᎠᎴ ᎦᎵᏉᎩ ᎢᎫᏕᏘᏴᏛ ᎤᎾᏁᎳᏛᎯ ᎨᏎ ᎠᏍᎦᏯ ᎠᏛᏉ ᎨᏒ ᏧᎾᏨᏛ;


text:
ᎠᎴ ᎤᏪᏑᎶᏨᎯ ᎨᏎ ᏁᎳᏍᎪᎯ ᏅᎩᎦᎵ ᎢᏴᏛ ᎢᏳᏕᏘᏴᏛ, ᎾᏍᎩ ᎥᏝ ᏱᏓᏅᏍᎨ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎤᏁᎳᏅᎯᏉ ᏓᎧᎿᏩᏗᏎᎢ ᎠᎹᏟ ᎬᏍᎬ ᎠᎴ ᎠᏓᏙᎵᏍᏗᏍᎬ ᏂᏚᎵᏏᏂᏒ ᎠᎴ ᏂᏚᎩᏨᏂᏒᎢ.


text:
ᎯᏍᎩᎦᏏᏁᏃ ᎤᏕᏘᏴᏌᏗᏒ ᏓᏈᎵᏯ ᏏᏌ ᎤᎬᏫᏳᎯ ᎨᏒᎢ, ᏋᏗᏯ ᏆᎴᏗ ᏧᏗᏱ ᏣᎦᏁᎶᏗ ᎨᏎᎢ, ᎠᎴ ᎡᎶᏛ ᎨᎵᎵ ᏍᎦᏚᎩ ᎨᎡ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏎᎢ, ᎤᏅᏟᏃ ᏈᎵᎩ ᎢᏚᎵ ᎠᎴ ᏝᎪᏂᏗ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏎᎢ, ᎵᏌᏂᏯᏃ ᎠᏈᎵᏂ ᎠᏥᎦᏘᏗᏍᏗ ᎨᏎᎢ;


text:
ᎾᏍᎩᏯ ᏂᎬᏅ ᎪᏪᎸ ᎪᏪᎵᎯ ᎢᏌᏯ ᎠᏙᎴᎰᏍᎩ ᎤᏪᏂᏒᎯ, ᎯᎠ ᏥᏂᎦᏪᎭ; ᎤᏪᎷᎦ ᎩᎶ ᎢᎾᎨᎢ, ᎯᎠ ᏂᎦᏪᎭ; ᎡᏣᏛᏅᎢᏍᏓᏏ ᏱᎰᏩ ᎤᎶᎯᏍᏗᏱ, ᏚᏅᏅ ᏗᏥᏥᏃᎯᏍᏓ.


text:
ᏚᎨᏓᎵᏴᏅ ᏂᎦᏗᏳ ᏗᎧᎵᎢᏍᏗ ᎨᏎᏍᏗ, ᏙᏓᎸᏃ ᎠᎴ ᏚᏌᎯᎸ ᏂᎦᏗᏳ ᎡᎳᏗᎭ ᎢᏗᎬᏁᏗ ᎨᏎᏍᏗ, ᏧᏓᏥᏃᏍᏈᏗᏰᏛᏃ ᎨᏒ ᏗᎦᏥᏃᎯᏍᏙᏗ ᎨᏎᏍᏗ, ᎤᏲᏃ ᏕᎦᏅᏅ ᎬᎾᏕᏍᎩ ᎢᏗᎬᏁᏗ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏥᎾᏄᎪᏩ ᎠᏙᎴᎰᎯᏍᏙᏗ ᏕᏥᏁᏟᏴᏒ ᏕᏣᏓᏅᏛᎢ; ᎠᎴ ᏞᏍᏗ ᎢᏣᎴᏅᎲ ᎯᎠ ᎢᏥᏪᏒ ᏕᏣᏓᏅᏛᎢ; ᎡᏆᎭᎻ ᎣᎩᏙᏓ ᎠᏴ; ᎢᏨᏲᏎᏰᏃ ᎤᏁᎳᏅᎯ ᏰᎵᏉ ᎯᎠ ᏅᏯ ᏱᏕᎬᏓ ᏱᏕᎪᏢᎾ ᎡᏆᎭᎻ ᏧᏪᏥ.


text:
ᎠᏂᏯᏫᏍᎩᏃ ᎾᏍᏉ ᎢᎬᏩᏛᏛᏁ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᎠᏴ ᎾᏃ ᎦᏙ ᏓᏲᏣᏛᏁᎵ? ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ; ᏞᏍᏗ ᎩᎶ ᎬᏍᎦᎢᏍᏓᎩ ᎢᏰᏨᏁᎸᎩ, ᎠᎴ ᏞᏍᏗ ᎦᏰᎪᎩ ᏱᏣᏓᎳᏫᏎᎮᏍᏗ; ᎠᎴ ᏰᎵᏉ ᎢᏥᏰᎸᏎᏍᏗ ᎡᏣᎫᏴᎡᎲᎢ.


text:
ᏣᏂ ᎤᏁᏤ ᎯᎠ ᏂᏚᏪᏎᎴ ᏂᎦᏛ, ᎠᏴ ᎤᏙᎯᏳᎯ ᎠᎹ ᏕᏨᏯᏬᏍᏗᎭ; ᏓᏯᎢᏍᎩᏂ ᎤᏟ ᎤᎵᏂᎩᏗᏳ ᎡᏍᎦᏉ ᎠᏴ, ᎾᏍᎩ ᏓᎧᏁᏌᏛ ᏧᎳᏑᎶᎩ ᎥᏝ ᏰᎵ ᏱᏂᎪᎢ ᏗᎩᎧᏁᏴᏗᏱ; ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎠᎴ ᎠᏥᎸ ᏙᏓᏣᏪᏍᏔᏂ;


text:
ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏧᏠᎠᏎ ᎾᏍᎩ ᎤᏪᏯᎸᏤᎢ, ᎠᏰᎸ ᏧᎴ-ᏗᏍᎪᏂᎯ ᎾᏍᎩᏯ ᎨᏌ ᎤᏙᏢᏒᎢ; ᎧᏁᎬᏃ ᎦᎸᎳᏗ ᏧᎶᏎᎯᎠ ᏅᏧᏪᏎᎢ; ᏂᎯ ᎬᎨᏳᎢ ᎠᏇᏥ; ᎣᏏᏳ ᎬᏰᎸᎢ ᏂᎯ.


text:
ᎠᏓᏅᏙ ᏱᎰᏩ ᎤᏤᎵ ᏔᎵ ᎠᏆᏛᏓᏁᎵᏕᎦ ᏅᏗᎦᎵᏍᏙᏗ ᏣᎩᎶᏁᎥ ᎦᏥᏯᎵᏥᎣᏁᏗᏱ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ; ᏗᎩᏅᏒ ᏗᎦᏥᏅᏬᏗᏱ ᎤᏲ ᎤᎾᏓᏅᏔᏩᏕᎩ, ᎦᏥᏃᏁᏗᏱ ᎠᏂᏴᎩ ᎬᏩᎾᏚᏓᎴᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏗᏂᎨᏫ ᎬᏩᏂᎪᏩᏛᏗ ᎨᏒᎢ, ᎠᎴ ᏗᎦᏥᏯᎪᏗᏱ ᏗᎨᏥᏂᏆᎶᏔᏅᎯ,


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ; ᎠᏎ ᏓᏍᎩᏁᎢᏍᏓᏁᎵ ᎯᎠ ᎢᎦᏪᏍᏗ ᏥᎩ; ᏔᏓᏅᏫᏍᎩ, ᏨᏒ ᎭᏓᏅᏮᎦ; ᏂᎦᎥ ᏄᏍᏛ ᎣᎦᏛᎦᏅ ᏕᏣᎸᏫᏍᏓᏁᎸ ᎨᏆᏂ, ᎾᏍᎩ ᎾᏍᏉ ᎿᏛᎦ ᎠᏂ ᏣᏤᎵᎪᎯ.


text:
ᎠᏎᏃ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎤᏂᏣᏖ ᏧᏃᏑᎶᏨᎯ ᎢᏏᎵᏱ ᎾᎯᏳ ᎢᎳᏯ ᏤᎮᎢ, ᎦᎸᎶᎢ ᏧᎵᏍᏚᎯ ᏦᎢ ᏧᏕᏘᏴᏛ ᏑᏓᎵᏃ ᎢᏯᏅᏙ, ᎾᎯᏳ ᎤᏣᏘ ᏥᏚᎪᏄᎶᎭ ᏂᎬᎾᏛᎢ.


text:
ᏂᎦᏛᏃ ᎤᏂᏍᏆᏂᎪᏎᎢ, ᎠᎴ ᎤᎾᎵᏃᎮᎴ ᎤᏅᏒ ᎨᏒ ᎯᎠ ᏂᏚᎾᏓᏪᏎᎴᎢ; ᎦᏙ ᎤᏍᏗ ᎧᏁᎢᏍᏗ ᎯᎠ? ᎤᏤᎵᎦᏯᏰᏃ ᎠᎴ ᎤᎵᏂᎩᏛ ᎨᏒ ᏕᎬᏗᎭ ᏕᎧᏁᏤ ᎠᏂᎦᏓᎭ ᏗᏓᏅᏙ, ᎠᎴ ᎠᏂᏄᎪᎦ.


text:
ᎠᎴ ᎠᏂᏍᎩᎾ ᎾᏍᏉ ᎬᏩᏂᏄᎪᎨ ᎤᏂᏣᏖᎢ, ᎠᏁᎷᎲᏍᎨ ᎯᎠ ᎾᏂᏪᏍᎨᎢ; ᏂᎯ ᎦᎶᏁᏛ ᎤᏁᎳᏅᎯ ᎤᏪᏥ. ᏚᏍᎦᏤᏃ ᏚᏅᏍᏓᏕᎴ ᎤᏂᏁᎢᏍᏗᏱ; ᎠᏂᎦᏔᎮᏰᏃ ᎾᏍᎩ ᎦᎶᏁᏛ ᎨᏒᎢ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁ ᎢᎸᎯᏢ ᎦᏚᎲ ᎡᏙᎲᎢ, ᎬᏂᏳᏉ ᎠᏍᎦᏯ ᏂᎬ ᎠᏓᏰᏍᎩ ᎤᏢᎩ ᎾᎿ ᎡᏙᎮᎢ; ᎾᏍᎩ ᏥᏌᎤᎪᎲ ᎤᏯᏍᏚᏎᎢ, ᎠᎴ ᎤᏔᏲᏎᎴ ᎯᎠ ᏄᏪᏎᎢ, ᏣᎬᏫᏳᎯ, ᎢᏳᏃ ᎣᏏᏳ ᏱᏣᏰᎸᏅ ᏰᎵᏉ ᏱᏍᎩᏅᎦᎸ.


text:
ᎤᏁᏤᎴᏃ ᎩᎶ ᎤᏃᏁᏗᏱ ᏂᎨᏒᎾ; ᎮᎾᏉᏍᎩᏂ, <n>[ᎤᏬᏎᎴᎢ,]</n> ᏫᏯᏓᎾᏄᎪᏫᏏ ᎠᏥᎸ-ᎨᎶᎯ, ᎠᎴ ᎼᏏ ᎤᏁᏨ ᏣᏓᏅᎦᎸᎲ ᎠᎵᏍᎪᎸᏙᏗ ᏫᎲᎦ, ᎾᏍᎩ ᎤᎾᏙᎴᎰᎯᏍᏙᏗ.


text:
ᎢᎸᎯᏳᏃ ᎯᎠ ᏄᎵᏍᏔᏁᎢ, ᎾᎯᏳ ᏓᏕᏲᎲᏍᎨᎢ, ᎾᎿ ᎠᏂᏁ ᎠᏂᏆᎵᏏ ᎠᎴ ᏗᎧᎿᏩᏛᏍᏗ ᏗᏃᏏᏏᏍᎩ ᏕᎦᏚᏩᏗᏒ ᎨᎵᎵ ᏅᏓᏩᏂᎶᏒᎯ, ᎠᎴ ᏧᏗᏱ, ᎠᎴ ᏥᎷᏏᎵᎻ; ᎤᎬᏫᏳᎯᏃ ᎤᎵᏂᎬᎬ ᏚᎾᏗᏫᏍᏗᏍᎨᎢ.


text:
ᎤᎾᏠᏨᏃ ᎢᏳᎾᏛᏁᏗᏱ ᎤᏂᏴᏔᏂᎯᏍᏗᏱ ᎤᏂᏣᏘ ᎨᏒ ᎢᏳᏍᏗ, ᎦᏌᎾᎵ ᎤᎾᎩᎳᏫᏎᎢ, ᎾᎿᏃ ᏧᏂᎦᏛᎴᎯᏍᏔᏁ ᎤᎾᏠᎥᏔᏂᎴ ᎤᏤᏍᏙ ᎬᏩᏠᏯᏍᏗ ᎤᎾᏓᏡᎬ ᎠᏰᎵ, ᏥᏌ ᎢᎬᏱᏢ ᎤᏂᏅᏁᎴᎢ.


text:
ᎠᏎᏃ ᎢᏣᏙᎴᎰᎯᏍᏗᏱ ᏴᏫ ᎤᏪᏥ ᏰᎵᏉ ᎠᏂ ᎡᎶᎯ ᎬᏩᏓᏙᎵᏍᏗ ᎨᏒ ᎣᏍᎦᏅᏨᎢ, (ᎯᎠ ᏄᏪᏎᎴ ᎤᎸᏓᎸᎥᏍᎩ;) ᎯᎠ ᏂᎬᏪᏎᎭ; ᏔᎴᎲᎦ, ᏣᏤᏍᏙ ᎯᎾᎩ, ᎠᎴ ᏗᏤᏅᏒ ᎮᎾ.


text:
ᏗᏃᏪᎵᏍᎩᏂ ᏧᎾᏤᎵ ᎠᎴ ᎠᏂᏆᎵᏏ ᏚᏂᏔᎳᏬᎯᏎᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᎦᏙᏃ ᎢᏧᎳᎭ ᎢᏣᎵᏍᏓᏴᎲᏍᎦ ᎠᎴ ᎢᏣᏗᏔᏍᎦ ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᎦᎾᎢ?


text:
ᎯᎠᏃ ᏂᎬᏩᏪᏎᎴᎢ; ᎦᏙᏃ ᏣᏂ ᎬᏩᏍᏓᏩᏗᏙᎯ ᏯᏃᎩᏳ ᎠᎹᏟ ᎠᏅᏍᎪᎢ ᎠᎴ ᎠᎾᏓᏙᎵᏍᏗᏍᎪᎢ, ᎠᎴ ᎾᏍᏉ ᎠᏂᏆᎵᏏ ᎬᏩᏂᏍᏓᏩᏗᏙᎯ; ᏂᎯᏍᎩᏂ ᎨᏣᏍᏓᏩᏗᏙᎯ ᎠᎾᎵᏍᏓᏴᎲᏍᎪ ᎠᎴ ᎠᎾᏗᏔᏍᎪᎢ.


text:
ᏚᏟᎶᏍᏓᏁᎴᏃ ᎾᏍᏉ <n>[ᎯᎠ ᏄᏪᏎᎢ; ᎥᏝ ᎩᎶ ᎢᏤ ᎠᏄᏬ ᎤᏪᏘᎯ ᏱᎦᎳᏍᏢᎥᏍᎪᎢ; ᎢᏳᏰᏃ ᎾᏍᎩ ᏱᏄᏛᏁᎸ, ᎢᏤ ᎠᏄᏬ ᎦᏣᎦᎵᏍᎪ ᎤᏪᏘ, ᎠᎴ ᎾᏍᏉ ᎢᏤ ᎠᎬᎭᎸᏛ ᎥᏝ ᏱᏓᎾᏙᎵᎪ ᎤᏪᏘ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁ ᏔᎵᏁ ᎤᎾᏙᏓᏆᏍᎬ ᎢᎬᏱᏱ ᏄᎵᏐᏃᎢ, ᎾᏍᎩ ᏠᎨᏏ ᎤᏣᎴᏍᏗ ᏓᏫᏒ ᎤᎶᏎᎢ, ᎬᏩᏍᏓᏩᏗᏙᎯᏃ ᏚᏂᏍᎫᏕᏎ ᎤᏣᎴᏍᏗ, ᎠᎴ ᎤᏂᏍᏗᎨ ᎠᎾᏍᎪᎵᏰᏍᎨ ᏧᏃᏰᏂ.


text:
ᎾᏍᎩ ᏧᏴᎴ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸᎢ, ᎠᎴ ᏧᎩᏎ ᎠᎴ ᏧᎨ ᎦᏚ ᎠᎦᎩᏗ, ᎠᎴ ᎾᏍᏉ ᏥᏚᏁᎴ ᎾᏍᎩ ᏣᏁᎮᎢ; ᎾᏍᎩ ᏂᎦᏳᎪᏛᎾ ᏥᎩ ᎩᎶ ᎤᎩᏍᏗᏱ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎤᏅᏒ.


text:
ᎿᏉᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᏑᏓᎴᎩ ᏓᏨᏯᏛᏛᏂ; ᎦᏙ ᏚᏳᎪᏗ ᎤᎾᏙᏓᏆᏍᎬᎢ? ᎣᏍᏛᏍᎪ ᏗᎦᎸᏫᏍᏓᏁᏗᏱ, ᎤᏲᎨ ᏗᎦᎸᏫᏍᏓᏁᏗᏱ? ᎬᏅ ᎠᏍᏕᎸᏗᏱ, ᎠᏓᎯᏍᏗᏱᎨ?


text:
ᎾᏍᎩᏃ ᎢᏧᎳᎭ ᏧᏂᎦᏐᎠᏒ ᎤᏬᏓᎸ ᎤᎴᏁᎢ. ᎠᎴ ᎤᏂᏣᏘ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎠᎴ ᎤᏂᏧᏈᏍᏗ ᏴᏫ ᏂᎬᎾᏛ ᏧᏗᏱ ᎠᎴ ᏥᎷᏏᎵᎻ ᏅᏓᏳᏂᎶᏒᎯ, ᎠᎴ ᏔᏯ ᎠᎴ ᏌᏙᏂ ᎠᎺᏉᎯ ᎤᏣᏗ ᏅᏓᏳᏂᎶᏒᎯ, ᎾᏍᎩ ᏧᏂᎷᏤ ᎬᏩᏛᎦᏁᏗᏱ, ᎠᎴ ᏗᎨᏥᏅᏬᏗᏱ ᏚᏂᏢᎬᎢ.


text:
ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᎢᏳᏃ ᏴᏫ ᎨᏥᏂᏆᏘᎮᏍᏗ, ᎠᎴ ᎨᏣᏓᏓᎴᏗᏍᎨᏍᏗ, ᎠᎴ ᎦᎨᏥᏐᏢᏕᏍᏗ, ᎠᎴ ᎠᏂᏍᎦᎩᏳ ᎨᏎᏍᏗ ᏕᏣᏙᎥ ᎪᎱᏍᏗ ᎤᏲ ᎾᏍᎩᏯᎢ, ᏴᏫ ᎤᏪᏥ ᎤᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ.


text:
ᏂᎯᏍᎩᏂ ᏕᏥᎨᏳᏎᏍᏗ ᎨᏥᏍᎦᎩ, ᎠᎴ ᎣᏍᏛ ᏕᏥᎸᏫᏍᏓᎡᎮᏍᏗ, ᎠᎴ ᎢᏣᏓᏙᎳᏍᏗᏍᎨᏍᏗ ᎤᏚᎩ ᏂᏨᏒᎾ ᎥᎡᏥᏂᏗᏱ ᎪᎱᏍᏗ; ᎤᏣᏘᏃ ᎡᏣᎫᏴᎡᏗ ᎨᏎᏍᏗ, ᏩᏍᏛᏃ ᎦᎸᎳᏗᏳ ᎡᎯ ᏧᏪᏥ ᎨᏎᏍᏗ ᏂᎯ; ᎾᏍᎩᏰᏃ ᎣᏍᏛ ᏂᏓᏛᏁᎰ ᏄᎾᎵᎮᎵᏣᏛᎾ ᎠᎴ ᎤᏂᏲᎢ.


text:
ᎢᏣᏓᏁᎮᏍᏗ, ᏂᎯᏃ ᎠᏎ ᎡᏥᏁᏗ ᎨᏎᏍᏗ; ᎣᏍᏛ ᎠᏟᎶᏛ, ᎠᏍᏓᏲᏔᏅᎯ, ᎠᎴ ᎠᏖᎸᏅᎯ, ᎠᎴ ᎬᏤᏪᎩ, ᎨᏥᏁᏗ ᎨᏎᏍᏗ ᏴᏫ ᏕᏣᏓᏠᎲᎢ. ᏄᏍᏛᏰᏃ ᎢᏣᏓᏟᎶᎡᎸ ᎾᏍᎩᏯ ᎾᏍᏉ ᎡᏣᏟᎶᎡᏗ ᎨᏎᏍᏗ;


text:
ᎠᎴ ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᎯᎠ ᏱᏂᏪᏏ ᏗᏍᏓᏓᏅᏟ; ᏗᎾᏓᏅᏟ ᎬᎸᏏ ᎤᏢᏓᎸᏛ ᏣᎦᏑᎲᎢ, ᏨᏒᏃ ᏂᎪᏩᏘᏍᎬᎾ ᎤᏃᏍᏛ ᎠᏓ ᏨᏒ ᏣᎦᏑᎲᎢ? ᏣᏠᎾᏍᏗ! ᎢᎬᏱ ᎯᎸ ᎤᏃᏍᏛ ᎠᏓ ᏨᏒ ᏣᎦᏑᎲᎢ, ᎿᏉᏃ ᎬᏂᎨᏒᎢᏳ ᏣᎪᏩᏛᏗᏱ ᎨᏎᏍᏗ ᎯᎸᎡᏗᏱ ᎤᏢᏓᎸᏛ ᏗᏍᏓᏓᏅᏟ ᎤᎦᏑᎲᎢ.


text:
ᎣᏍᏛ ᏴᏫ ᎣᏍᏛ ᎤᏍᏆᏂᎪᏛ ᎤᎾᏫᏱ ᎣᏍᏛ ᎨᏒ ᎦᎾᏄᎪᏫᏍᎪᎢ; ᎤᏲᏃ ᏴᏫ ᎤᏲ ᎤᏍᏆᏂᎪᏛ ᎤᎾᏫᏱ ᎤᏲᎨᏒ ᎦᎾᏄᎪᏫᏍᎪᎢ; ᎤᏣᏛᏰᏃ ᎤᎾᏫ ᎤᏪᎲ ᎠᎰᎵ ᎧᏁᎪᎢ.


text:
ᎠᏍᎦᏯ ᏓᏤᎸ ᎾᏍᎩ ᎾᏧᏁᏍᎨᎮᎢ, ᎠᎴ ᎭᏫᏂ ᏧᏍᎪᏎᎢ, ᎠᎴ ᎦᎫᏍᏛᏗ ᏅᏲᎯ ᏧᏝᏁᎢ; ᎤᏃᎱᎦᏅᏃ ᎡᏉᏂ ᎾᎿ ᎠᏓᏁᎸ ᎠᏍᏓᏱᏳ ᎬᏂᎵᎯᎮᎢ, ᎠᎴ ᎥᏝ ᎬᏩᏖᎸᏗ ᏱᎨᏎᎢ; ᏅᏲᎯᏰᏃ ᎦᎧᎮᎠᏍᎦᏯ ᏓᏤᎸ ᎾᏍᎩ ᎾᏧᏁᏍᎨᎮᎢ, ᎠᎴ ᎭᏫᏂ ᏧᏍᎪᏎᎢ, ᎠᎴ ᎦᎫᏍᏛᏗ ᏅᏲᎯ ᏧᏝᏁᎢ; ᎤᏃᎱᎦᏅᏃ ᎡᏉᏂ ᎾᎿ ᎠᏓᏁᎸ ᎠᏍᏓᏱᏳ ᎬᏂᎵᎯᎮᎢ, ᎠᎴ ᎥᏝ ᎬᏩᏖᎸᏗ ᏱᎨᏎᎢ; ᏅᏲᎯᏰᏃ ᎦᎧᎮᎢ.


text:
ᎾᏍᎩᏍᎩᏂ Ꮎ ᎤᏛᎦᏅᎯ, ᏄᏛᏁᎸᎾᏃ, ᎾᏍᎩ ᎠᏍᎦᏯ ᏓᏤᎸ ᏂᏚᎫᏍᏓᎥᎾ ᎦᏙᎯᏉ ᎠᏓᏁᎸ ᏧᏁᏍᎨᎮᎢ; ᎡᏉᏂᏃ ᎾᎿ ᎤᎵᏂᎩᏗᏳ ᎡᏂᎵᎯᎮᎢ, ᎩᎳᏉᏃ ᎢᏴᏛ ᎤᏪᏇᏴᏎᎢ; ᎤᏍᎦᏎᏗᏳᏃ ᏄᎵᏍᏔᏁ ᎤᏲᏨ ᎾᏍᎩ ᎠᏓᏁᎸᎢ.


text:
ᏥᏌᏃ ᏚᏍᏓᏩᏛᏎᎢ. ᎿᏉᏃ ᎾᎥᏉ ᎤᎷᎴ ᏗᏓᏁᎸ, ᎠᏍᎪᎯᏧᏈ ᎠᏂᏯᏫᏍᏍᎩ ᏗᏘᏂᏙᎯ ᏙᏧᏅᏎ ᏧᎵᎢ ᏂᏙᏓᎬᏩᏠᎯᏍᏗᏱ, ᎯᎠ ᏅᏧᏪᏎᎴᎢ; ᏣᎬᏫᏳᎯ, ᏞᏍᏗ ᏨᏒ ᏣᏓᏕᏯᏙᏔᏅᎩ; ᎥᏝᏰᏃ ᏰᎵ ᏱᏂᎪᎯ ᏣᏴᏍᏗᏱ ᏥᏁᎸᎢ ᏥᎾᏆᏍᏗᏉ;


text:
ᎠᏴᏰᏃ ᎾᏍᏉ ᏗᏆᏓᏁᎶᏗᏉ, ᎠᎴ ᏗᎩᎧᎭ ᎠᏂᏯᏫᏍᎩ ᎠᎴ ᎠᏴ ᏕᎬᏆᏁᎶᏙᎢ, ᎩᎶᏃ ᎮᎾ ᏥᏲᏏ, ᎡᎪᎢ; ᏅᏩᏓᎴᏃ ᎡᎮᎾ ᏥᏲᏏ, ᏗᎡᎪᎢ; ᏥᏅᏏᎠᏍᏗᏃ ᎯᎠ ᎿᏛᏏ ᏥᏲᏏ, ᎾᏍᎩ ᎾᏛᏁᎰᎢ.


text:
ᏥᏌᏃ ᎾᏍᎩ ᎯᎠ ᎤᏛᎦᏅ, ᎤᏍᏆᏂᎪᏎᎴᎢ, ᎠᎴ ᎤᎦᏔᎲᏎᎢ, ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎵ ᏴᏫ ᎾᏍᎩ ᏅᏓᎬᏩᏍᏓᏩᏛᏛ; ᎯᎠ ᏂᏨᏪᏎᎭ; ᎥᏝ ᎾᏍᏉ ᎢᏏᎵ ᎠᏁᎲ ᎾᏍᎩ ᎢᎦᎢ ᎪᎯᏳᏗ ᎨᏒ ᏯᎩᏩᏛᎲ.


text:
ᎿᏉᏃ ᎦᎶᎯᏍᏗᏱ ᎪᏢᏒ ᎦᏚᎲ ᎾᎥ ᎤᎷᏨ, ᎬᏂᏳᏉ ᎠᏍᎦᏯ ᎤᏲᎱᏒᎯ ᎠᏂᏄᎪᏫᏍᎨ ᎠᏂᏂᏎᎢ, ᎤᏩᏒᎯᏳ ᎤᏪᏥ ᎨᏎ ᎤᏥ, ᎠᎴ ᎾᏍᎩ ᎤᏬᏑᎶᏨᎯ ᎨᏎᎢ; ᎤᏂᏣᏖᏃ ᏴᏫ ᎦᏚᎲ ᎠᏁᎯ ᎬᏩᏍᏓᏩᏗᏎᎢ.


text:
ᎿᏉᏃ ᏥᏌ ᎤᏁᏨ ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᏥᏍᏕᎾ ᎠᎴ ᏣᏂ ᏪᏍᏗᏃᎲᏏ ᏄᏍᏛ ᎢᏍᏗᎪᎲ ᎠᎴ ᏄᏍᏛ ᎢᏍᏓᏛᎦᏅᎢ; ᎾᏍᎩ ᏗᏂᎨᏫ ᎠᏂᎪᏩᏘᏍᎬᎢ, ᏗᏂᏲᎤᎵ ᎠᏁᏙᎲᎢ, ᎠᏓᏰᏍᎩ ᏧᏂᏢᎩ ᎨᏥᏅᎦᎵᏍᎬᎢ, ᏧᏂᎵᎡᏅ ᎠᎾᏛᎩᏍᎬᎢ, ᏧᏂᏲᎱᏒᎯ ᏕᎨᎦᎴᏗᏍᎬᎢ, ᎤᏲᏃ ᎢᏳᎾᏛᎿᏕᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎨᎦᎵᏥᏙᏁᎲᎢ.


text:
ᎯᎠᏰᏃ ᏂᏨᏪᏎᎭ; ᎠᏂᎨᏴ ᎬᏩᏂᎾᏄᎪᏫᏒᎯ ᏥᎩ ᎥᏝ ᏳᏜᏍᏗ ᎩᎶ ᎠᏙᎴᎰᏍᎩ ᎤᏟ ᎢᏯᏥᎷᏉᏗ ᎡᏍᎦᏉ ᏣᏂ ᏗᏓᏬᏍᎩ; ᎠᏎᏃ ᎤᏍᏗᎧᏂ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ ᎨᎳ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᎡᏍᎦᏉ ᏣᏂ.


text:
ᏗᏂᏲᎵᏉ ᎾᏍᎩᏯ ᎦᏃᏙᏗᏱ ᏣᏂᏃᎢ, ᎠᎴ ᏥᏫᏓᎾᏓᏯᏂᏍᎪᎢ, ᎯᎠ ᏥᏫᎾᏂᏪᏍᎪᎢ; ᎠᏤᎷᎩ ᎣᎬᏔᏅ ᏕᏨᏃᎩᎡᎸ, ᎠᏎᏃ ᎥᏝ ᏱᏣᎵᏍᎩᏎᎢ; ᏙᏥᏴᎬ ᎢᏣᏛᎪᏗ, ᎠᏎᏃ ᎥᏝ ᏱᏗᏣᏠᏱᎴᎢ.


text:
ᏴᏫ ᎤᏪᏥ ᎤᎷᏨ ᎠᎵᏍᏓᏴᎲᏍᎦ ᎠᎴ ᎠᏗᏔᏍᎦ; ᎯᎠᏃ ᏂᏥᏪᏎ; ᎬᏂᏳᏉ ᎠᏍᎦᏯ ᎤᎬᎥᏍᎩ ᎠᎵᏍᏓᏴᏗ ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎠᏗᏔᏍᎩ, ᎠᏕᎸ ᎠᏂᎩᏏᏙᎯ ᎠᎴ ᎠᏂᏍᎦᎾ ᎤᎾᎵᎢ.


text:
ᎠᎴ ᎤᎴᏁ ᏚᏜᏌᏛ ᎣᏂᏗᏢ ᏓᏠᏱᎮᎢ, ᎠᎴ ᎤᎴᏅᎮ ᏧᎳᏏᏕᏂ ᏚᏬᏑᎴᏔᏁ ᏧᎦᏌᏬᎸᎯ, ᎠᎴ ᏚᎧᏲᏙᏔᏁ ᎤᏍᏗᏰᎬᎢ, ᎠᎴ ᏚᏚᏣᎳᏁ ᏧᎳᏏᏕᏂ, ᎠᎴ ᏚᎶᏁᏔᏁ ᎠᏠᏁᏗ.


text:
ᎠᏆᎵᏏᏃ ᎾᏍᎩ ᏭᏯᏅᏛ ᎤᎪᎲ, ᎤᏁᏤ ᏧᏓᏅᏛ ᎯᎠ ᏂᎦᏪᏍᎨᎢ; ᎯᎠ ᎠᏍᎦᏯ ᎢᏳᏃ ᎠᏙᎴᎰᏍᎩ ᏱᎨᏎ ᏳᏙᎴᎰᏎ ᎾᏍᎩ ᎨᏒ ᎠᎴ ᎢᏳᏍᏗᏉ ᎨᏒ ᎯᎠ ᎠᎨᏴ ᏧᏃᏟᏍᏗᎭ, ᎠᏍᎦᎾᏰᏃ.


text:
ᎠᎨᏴᏃ ᎦᏙᎬ ᎢᏗᏢ ᏭᎦᏔᎲᏍᏔᏅ ᎯᎠ ᎾᏥᏪᏎᎴ ᏌᏩᏂ; ᎯᎪᏩᏘᏍᎪ ᎯᎠ ᎠᎨᏴ? ᎯᏁᎸ ᎠᎩᏴᎸᎩ, ᎠᎹ ᎥᏝ ᏱᏍᎩᏁᏁᎴ ᏗᏉᏑᎴᏗ ᏗᏆᎳᏏᏕᏂ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᏓᏉᏑᎵᏏ ᏗᏆᎳᏗᏕᏂ ᏧᎦᏌᏬᎸᎯ ᎬᏓ, ᎠᎴ ᏓᎩᎧᏲᏙᏓᏏ ᎤᏍᏘᏰᎬᎢ.


text:
ᎣᏂᏃ ᎢᏴᏛ ᎯᎠ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ ᏕᎦᏚᏩᏗᏒ ᏧᏛᎾ ᎠᎴ ᏧᏍᏗ ᎤᏪᏙᏁᎢ, ᎠᎵᏥᏙᎲᏍᎨ ᎠᎴ ᎬᏂᎨᏒ ᏂᎬᏁᎮ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎧᏃᎮᏍᎩ, ᏔᎳᏚᏃ ᎢᏯᏂᏛ ᎤᎾᎵᎪᏩᏕᎨᎢ;


text:
ᎠᎴ ᎩᎶ ᎢᏳᎾᏍᏗ ᎠᏂ ᎨᏴ ᏗᎨᏥᏅᏩᏅᎯ ᎤᏂᏲ ᏗᏓᏅᏙ ᎬᏩᎾᏕᏯᏙᏗᏍᎬ ᎠᎴ ᏚᏂᏢᎬᎢ, ᎾᏍᎩ ᎺᎵ ᎹᎦᏕᎵ ᎡᎯ ᏣᏃᏎᎰᎢ, ᎾᏍᎩ ᎦᎵᏉᎩ ᎠᏂᏍᎩᎾ ᎬᏩᏄᎪᏤᎸᎯ,


text:
ᎢᎦᏛᏃ ᎣᏒ ᎦᏙᎯ ᎤᎳᎨᏯᏛᏤᎢ, ᎠᎴ ᏧᏛᏎᎢ, ᎠᎴ ᎤᎦᏔᏔᏁᎢ ᎤᏁᏉᏤ ᎠᏍᎪᎯᏧᏈ ᎢᏳᏩᎫᏗ. ᎾᏍᎩᏃ ᎯᎠ ᏄᏪᏒ, ᎤᎵᏍᏔᏁᎢ, ᎯᎠ ᏄᏪᏎᎢ, ᎩᎶ ᏕᎦᎵᎷᎨᏍᏗ ᎤᏛᎪᏗᏱ ᏩᏛᎬᎦ


text:
ᎯᎠᏃ ᏄᏪᏎᎢ; ᏂᎯ ᎡᏥᏁᎸᎯ ᎢᏦᎵᏍᏗᏱ ᎤᏕᎵᏛ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒᎢ; ᎠᏂᏐᎢᏍᎩᏂ ᏗᎨᎦᏟᎶᏍᏓᏁᏗ; ᎾᏍᎩ ᎠᏂᎪᏩᏘᏍᎬ ᎬᏩᏂᎪᏩᏛᏗ ᏂᎨᏒᎾ, ᎠᎴ ᎠᎾᏛᎩᏍᎬ ᎬᏩᏃᎵᏍᏗ ᏂᎨᏒᎾ.


text:
ᏅᏃᎱᎶᏗ-Ꮓ ᏧᎳᎨᏯᏛᏤᎢ ᎾᏍᎩ ᎠᎾᏛᎩᏍᎩ ᎨᏥᏛᎦ; ᎿᏉᏃ ᎠᏍᎩᎾ ᎦᎷᎪᎢ, ᎠᎴ ᎠᎩᏍᎪ ᎦᏄᎪᏫᏍᎪ ᎧᏃᎮᏛ ᏧᏂᎾᏫᏱ, ᎦᎬᏩᏃᎯᏳᏗ ᎠᎴ ᎦᎨᏥᏍᏕᎸᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎾᏃ ᎠᏄᎦᎸᎯ ᏧᎳᎨᏯᏛᏤᎢ ᎨᏥᏛᎦ ᎾᏍᎩ ᎠᎾᏛᎬᎦ. ᎢᎸᎯᏢ ᏥᏩᏂᎶᏍᎪᎢ, ᎡᎶᎯᏃ ᎡᎯ ᎤᏪᎵᎯᏍᏗ ᎠᎴ ᎨᏅᎢᏍᏗ ᎨᏒ, ᎠᎴ ᎣᏍᏛ ᎠᏰᎸᏗ ᎨᏒ ᎠᏂᏁᏄᎳᏍᏗᏍᎪᎢ, ᎠᎴ ᎥᏝ ᏯᏂᎾᏄᎪᏫᏍᎪ ᎤᎦᏛᎾᏨᎯ.


text:
ᎾᏃ ᎣᏒ ᎦᏙᎯ ᏧᎳᎨᏯᏛᏤᎢ ᎨᏥᏛᎦ ᎾᏍᎩ ᏄᏠᎾᏍᏛᎾ ᎠᎴ ᎣᏍᏛ ᎨᏒ ᎤᏂᎾᏫ ᎬᏗ ᎠᎾᏛᎬᎦ ᎧᏃᎮᏛ, ᎠᏂᏍᏆᏂᎪᏗᏍᎪᎢ, ᎠᎴ ᎠᏂᎾᏄᎪᏫᏍᎪ ᎤᎦᏔᏔᏅᎯ ᎠᏅᏂᏗᏳ ᎨᏐᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏤᏯᏔᎮᏍᏗ ᏄᏍᏛ ᎢᏣᏛᎩᏍᎬᎢ, ᎩᎶᏰᏃ ᎤᎮᏍᏗ, ᎾᏍᎩ ᎠᏥᏁᏗ ᎨᏎᏍᏗ; ᎩᎶᏃ ᏄᎲᎾ ᎨᏎᏍᏗ, ᎾᏍᎩ ᎠᏥᎩᏒᏗ ᎨᏎᏍᏗ ᎾᏍᎩ ᎾᏧᎰ ᏥᏅᏩᏍᏙᎢ.


text:
ᎬᏩᎷᏤᎴᏃ ᎠᎴ ᎬᏩᏰᏍᏔᏁᎢ, ᎯᎠ ᎾᏂᏪᏍᎨᎢ; ᏔᏕᏲᎲᏍᎩ, ᏔᏕᏲᎲᏍᎩ, ᏓᏲᏩᏗᏒᏂ! ᎿᏉᏃ ᎤᏗᏛᎮ ᎠᎴ Ꮪ-ᏍᎦᏤ ᎦᏃᎸᎥᏍᎬ ᎠᎴ ᏓᎵᏍᏗᎳᏁᎬ ᎠᎹ; ᎤᏂᏑᎵᎪᏤᏃ ᎠᎴ ᎤᏓᏥᎾᏍᏛᎯ ᏄᎵᏍᏔᏁᎢ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎭᏝ ᎢᏦᎯᏳᏒᎢ? ᎾᏍᎩᏃ ᎠᏂᏍᎦᎢᎲ ᎤᏂᏍᏆᏂᎪᏎᎢ, ᎯᎠ ᏂᏚᎾᏓᏪᏎᎴᎢ; ᎦᏙ ᎤᏍᏗ ᎯᎠ ᎠᏍᎦᏯ? ᏕᎧᏁᏤᏰᏃ ᎤᏃᎴ ᎠᎴ ᎠᎹ, ᎠᎴ ᎢᎬᏬᎯᏳᎲᏍᎦ.


text:
Ꮽ-ᏣᎢᏒᏃ, ᏚᏠᏎ ᎩᎶ ᎢᏳᏍᏗ ᎠᏍᎦᏯ ᎦᏚᎲ ᏅᏓᏳᏄᎪᏨᎯ, ᎪᎯᏗᏳ ᎠᏂᏍᎩᎾ ᎬᏩᏯᎢ ᏂᎨᏎᎢ, ᎠᎴ ᎥᏝ ᏱᏓᏄᏬᏍᎨᎢ, ᎥᏝ ᎠᎴ, ᎠᏓᏁᎸ ᏯᏕᎲᏍᎨᎢ, ᏓᏤᎵᏍᏛᏉᏍᎩᏂ.


text:
ᎤᎪᎲᏃ ᏥᏌ, ᎤᏪᎷᏁᎢ, ᎠᎴ ᎤᏓᏅᏁ ᎦᏙᎬ ᎢᎬᏱᏗᏢ, ᎠᎴ ᎠᏍᏓᏯ ᎯᎠ ᏄᏪᏎᎢ; Ꭶ-Ꮩ Ꮧ-ᎩᎾᏓ-ᏛᏙᏗ, ᏥᏌ, ᎤᏁᎳᏅᎯ ᏩᏍᏛ ᎦᎸᎳᏗᏳ ᎡᎯ ᎤᏪᏥ? ᎬᏔᏲᏎᎭ ᏞᏍᏗ ᏍᎩᎩᎸᏅᎩ.


text:
ᏄᏁᏤᎶᏰᏃ ᎦᏓᎭ ᎠᏓᏅᏙ ᎤᏄᎪᎢᏍᏗᏱ ᎠᏍᎦᏯ. ᏯᏃᏉᏰᏃ ᎤᏂᏱᏍᎨᎢ; ᏧᏓᏕᏒᏛᏃ ᎠᎴ ᏗᎵᏰᏌᎾᎶ ᏓᎦᎸᏍᏗᏍᎨᎢ; ᏓᎦᎵᏍᎨᏁ ᏚᏓᎸᏍᏛᎢ, ᎠᎴ ᎠᏍᎩᎾ ᎢᎾᎨ ᏭᏱᎸᏍᏗᏍᎨᎢ.


text:
ᎤᏁᏅᏎᏃ ᎤᎾᎦᏔᏅᏎ ᏄᎵᏍᏔᏅᎢ; ᏥᏌᏃ ᏭᏂᎷᏤᎴᎢ, ᎠᎴ ᎤᏂᏩᏛᎮ ᎠᏍᎦᏯ, ᎾᏍᎩ ᎬᏩᏄᎯᏨᎯ ᎠᏂᏍᎩᎾ, ᎤᏬᎴ ᏥᏌ ᏚᎳᏍᎬᎢ, ᏚᏄᏩᎡᎢ, ᎠᎴ ᎤᏓᏅᏘᏌᏅᎯ ᎨᏎᎢ; ᎤᏂᏍᎦᎴᏃ.


text:
ᏥᏌᏃ ᎯᎠ ᏄᏪᏎᎢ; ᎦᎪ ᎠᏆᏒᏂᎦ? ᏂᎦᏛᏃ ᎤᎾᏓᏱᎸ, ᏈᏓ ᎠᎴ ᎾᏍᎩ ᎠᏁᎯ ᎯᎠ ᏄᏂᏪᏎᎢ; ᏔᏕᏲᎬᏍᎩ, ᎤᏂᏣᏘ ᎨᏣᏓᏡᏫᏍᏗᏕᎦ ᎠᎴ ᎨᏣᏁᏄᎳᏍᏗᎭ, ᏥᎪᏃ ᎦᎪ ᎠᏆᏒᏂᎦ ᎢᎭᏗᎭ?


text:
ᎠᎨᏰᏃ ᎤᏙᎴᎰᏒ ᏄᏗᏍᎦᎸᎾ ᎨᏒᎢ, ᎤᎷᏤ ᎤᏪᎾᏫᏍᎨᎢ, ᎠᎴ ᎢᎬᏱᏢ ᎤᏓᏅᏁᎴᎢ, ᏂᎦᏛᏃ ᏴᏫ ᎠᏂᎦᏔᎲ ᎤᏃᏁᎴ ᎤᏧᎵᏍᏙᏔᏅ ᎤᏒᏂᎸᎢ, ᎠᎴ ᎾᏍᎩ ᎩᎳᏉ ᎢᏴᏛ ᎤᏗᏩᏒᎢ.


text:
ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᏞᏍᏗ ᎪᎱᏍᏗ ᎢᏣᏓᏁᎳᏅᎩ ᎢᏣᎵᏍᏕᎸᏙᏗ ᎢᏣᎢᏒᎢ, ᏞᏍᏗ ᏗᏙᎳᏅᏍᏗ, ᎠᎴ ᏕᎦᎶᏗ, ᎠᎴ ᎦᏚ, ᎠᎴ ᎠᏕᎸ; ᎠᎴ ᎢᏥᏏᏴᏫᎭ ᏞᏍᏗ ᏔᎵ ᏗᏣᏄᏬ ᏱᏗᏥᏁᎮᏍᏗ.


text:
ᎢᎦᏃ ᎿᏉ ᎦᎶᏐᎲᏍᎨᎢ ᎬᏩᎷᏎᎴ ᏔᎳᏚ ᎢᏯᏂᏛ ᎠᎴ ᎯᎠ ᏂᎬᏩᏪᏤᎴᎢ, ᏘᏰᎵᎯᏍᏓ ᎤᏂᏣᏘ, ᎾᏍᎩ ᏩᏁᎾ ᏙᏗᎦᏚᎲ ᎠᎴ ᏙᏗᎦᎶᎨᏒ ᎠᏂ ᎬᏩᏚᏫᏛ Ꮻ-ᏚᏂᏒᏍᏗᏱ, ᎠᎴ ᎤᎾᎵᏍᏓᏴᏗ ᏭᏂᏩᏛᏗᏱ; ᎠᏂᏰᏃ ᎢᎾᎨᏉ ᎨᏒ ᎢᏕᏙᎭ.


text:
ᎯᎠ ᏂᎦᏪᏍᎨᎢ, ᏴᏫ ᎤᏪᏥ ᎠᏎ ᎤᏣᏘ ᏧᏓᎴᏅᏛ ᏧᎩᎵᏳᏤᏗ ᎨᏎᏍᏗ, ᎠᎴ ᏗᎬᏩᏲᎯᏍᏗ ᎨᏎᏍᏗ ᏗᏂᎳᏫᎩ ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ, ᎠᎴ ᎠᏥᎢᏍᏗ ᎨᏎᏍᏗ, ᎠᎴ ᏦᎢᏁ ᎢᎦ ᏣᎦᎴᏙᏗ ᎨᏎᏍᏗ.


text:
ᎩᎶᏰᏃ ᎠᏆᏕᎰᏍᎨᏍᏗ ᎠᏴ ᎠᎴ ᎠᎩᏁᏨᎢ, ᎾᏍᎩ ᏴᏫ ᎤᏪᏥ ᎤᏕᎰᎯᏍᏗ ᎨᏎᏍᏗ ᎾᎯᏳ ᎦᎷᏨᎭ ᎤᏄᏬᏍᏕᏍᏗ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏩᏒ ᎤᏤᎵᎦ, ᎠᎴ ᎤᏙᏓ ᎤᏤᎵᎦ, ᎠᎴ ᎨᏥᎸᏉᏗ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎤᎾᏤᎵᎦ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ ᎿᏉ ᎬᏩᏓᏅᎡᎮᎢ, ᏈᏓ ᎯᎠ ᏄᏪᏎᎴ ᏥᏌ, ᏔᏕᏲᎲᏍᎩ, ᎣᏏᏳ ᎠᏂ ᏥᏕᏙᎭ; ᎠᎴ ᏦᎢ ᏫᏙᏥᎵᏦᏛᎦ; ᏌᏉ ᏂᎯ ᏣᏤᎵᎦ, ᏌᏉᏃ ᎼᏏ ᎤᏤᎵᎦ, ᏌᏉᏃ ᎢᎳᏯ ᎤᏤᎵᎦ, ᎥᏝ ᏯᎦᏔᎮ ᏂᎦᏪᏍᎬᎢ.


text:
ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎩᎶ ᏓᏓᏂᎸᎨᏍᏗ ᎯᎠ ᎠᏲᎵ ᎠᏴ ᏓᏆᏙᎥ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ, ᎠᏴ ᏓᏆᏓᏂᎸᎨᏍᏗ; ᎩᎶᏃ ᎠᏴ ᏓᏆᏓ-ᏂᎸᎨᏍᏗ, ᏓᏓᎸᎨᏍᏗ ᏅᏛᎩᏅᎢ, ᎾᏍᎩ ᎠᏥᎸᏉᏗᏳ ᎨᏎᏍᏗ.


text:
ᎬᏩᏍᏓᏩᏗᏙᎯᏃ ᏥᎻ ᎠᎴ ᏣᏂ ᎾᏍᎩ ᎤᏂᎪᎲ, ᎯᎠ ᏄᏂᏪᏎᎢ, ᏣᎬᏫᏳᎯ, ᎣᏏᏉᏍᎪ ᏱᏰᎸᎾ ᏲᎩᏂᏁᏨ ᎠᏥᎸ ᎦᎸᎳᏗ ᏅᏓᏳᎶᎯᏍᏗᏱ ᎠᎴ ᎤᎾᎪᎲᏍᏙᏗᏱ ᎾᏍᎩᏯ ᎢᎳᏯ ᏄᏛᏁᎸᎢ?


text:
ᎾᏍᎩᏃ ᏄᎵᏍᏔᏂᏙᎸ, ᎤᎬᏫᏳᎯ ᏅᏩᎾᏓᎴ ᎦᎵᏆᏍᎪᎯ ᎢᏯᏂᏛ ᎾᏍᏉ ᏚᏑᏰᏎᎢ ᎠᎴ ᏚᏅᏎ ᏔᎵ ᏧᎾᎵᎪᏅᏛ ᎢᎬᏱ ᏄᏁᏅᏍᏗᏱ ᏂᎦᏛ ᏕᎦᏚᏩᏗᏒ ᎠᎴ ᏂᎬᎾᏛ, ᎾᎿ ᎤᏩᏒ ᏭᎷᎯᏍᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎤᎦᏛᎾᏨᎯ ᎤᏙᎯᏳᎯ ᎤᏣᏔ, ᏧᏂᎸᏫᏍᏓᏁᎯᏍᎩᏂ ᎠᏂᎦᏲᎵᏳ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎡᏣᏓᏙᎵᏍᏓᏏ ᎤᎬᏫᏳᎯ ᎤᎦᏛᎾᏨᎯ ᎤᏤᎵᎦ, ᏂᏙᏓᏳᏅᏍᏗᏱ ᏧᏂᎸᏫᏍᏓᏁᎯ ᎾᎿ ᎤᎦᏛᎾᏤᎸᎢ.


text:
ᎠᎴ ᎾᎿᏉ ᎠᏓᏁᎸ ᎢᏥᏁᏍᏗ, ᎢᏣᎵᏍᏓᏴᏗᏍᎨᏍᏗ ᎠᎴ ᎢᏣᏗᏔᏍᎨᏍᏗ ᏄᏍᏛ ᎡᏥᏁᎲᎢ; ᏧᎸᏫᏍᏓᏁᎯᏰᏃ ᏚᏳᎪᏗ ᎠᎫᏴᎡᏗᏱ ᏚᎸᏫᏍᏓᏁᎸᎢ. ᏞᏍᏗ ᏓᏓᏁᎳᏗᏒ ᏱᏤᏙᎵᏙᎮᏍᏗ


text:
ᏥᏌᏃ ᏧᏁᏨ ᎯᎠ ᏄᏪᏎᎴᎢ, ᎩᎶ ᎢᏳᏍᏗ ᏥᎷᏏᎵᎻ ᎤᏂᎩᏎ ᏤᎵᎪ ᎤᏪᏅᏎᎢ, ᏗᎾᏓᎾᏌᎲᏍᎩᏃ ᏚᎾᏓᏩᏛᏔᏁᎢ, ᎾᏍᎩ ᏕᎬᏩᏄᏪᏎ ᏚᏄᏩᎥᎢ, ᎠᎴ ᎬᏩᎵᎥᏂᎴᎢ, ᎠᎴ ᎤᎾᏓᏅᏎ ᎬᏩᏕᏤ ᎠᏰᎵ ᎢᏴᏛ ᎤᏲᎱᏒᎯ ᎨᏎᎢ.


text:
ᎤᏲᏂᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏂᎯ ᎪᎴᏏᏂ! ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏂᎯ ᏇᏣᏱᏗ! ᎢᏳᏰᏃ ᎤᏍᏆᏂᎪᏗ ᏱᏙᎦᎸᏫᏍᏓᏁᎴ ᏔᏯ ᎠᎴ ᏌᏙᏂ ᏂᎯ ᎢᏤᎲ ᏕᎦᎸᏫᏍᏓᏁᎸᎢ, ᎪᎯᎩ ᏗᎬᏩᏂᏁᏟᏴᏛ ᏱᎨᏎ ᏚᎾᏓᏅ-ᏛᎢ, ᏧᏏᏕᎾ ᏱᏚᎾᏄᏩᎡ ᎠᎴ ᎪᏍᏚᎯ ᏳᎾᏅᏁᎢ.


text:
ᎬᏂᏳᏉ ᎢᏨᏯᎵᏍᎪᎸᏓᏏ ᏗᏣᎳᏍᏓᎡᏗᏱ ᎢᎾᏛ ᎠᎴ ᏗᏂᏙᎬ ᏗᎾᏓᏨᏯᏍᏗᏍᎩ, ᎠᎴ ᎢᏣᏓᎵᏁᎯᏕᏗᏱ ᏂᎦᎥ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎠᎦᏍᎩ; ᎥᏝ ᎠᎴ ᎪᎱᏍᏗ ᏰᎵ ᎤᏲ ᎢᎨᏨᏁᏗ ᏱᎨᏎᏍᏗ.


text:
ᎾᎯᏳ ᏥᏌᎤᎵᎮᎵᏤ ᎤᏓᏅᏙᎩᎯ, ᎯᎠ ᏄᏪᏎᎢ, ᎬᏯᎵᎡᎵᏤᎭ ᎡᏙᏓ ᏣᎬᏫᏳᎯ ᎦᎸᎳᏗ ᎠᎴ ᎡᎶᎯ, ᎾᏍᎩ ᎯᎠ ᏥᏕᎲᏍᎦᎳᏁᎸ ᎠᏂᏏᎾᏌᏂ ᎠᎴ ᎠᏁᏯᏔᎯ, ᏗᏂᏲᎵᏃ ᏥᏕᎯᎾᏄᎪᏫᏎᎸ; ᎥᎥ, ᎡᏙᏓ; ᎾᏍᎩᏰᏃ ᎤᏏᏳ ᏣᏰᎸᏅᎯ.


text:
ᏂᎦᎥ ᎪᎱᏍᏗ ᏓᎩᏲᎯᏎᎸ ᎡᏙᏓ; ᎥᏝ ᎠᎴ ᎩᎶ ᏯᎦᏔᎭ ᎾᏍᎩ ᎨᏒ ᎤᏪᏥ, ᎠᎦᏴᎵᎨ ᎤᏩᏒ; ᎠᎴ ᎾᏍᎩ ᎠᎦᏴᎵᎨ ᎨᏒ ᎤᏪᏥ ᎤᏩᏒ, ᎠᎴ ᎩᎶ ᏥᎾᏄᎪᏫᏏ ᎡᎳ ᎤᏪᏥ.


text:
ᎢᏳᏲᏎᏰᏃ ᎤᏂᏣᏛᎩ ᎠᎾᏙᎴᎰᏍᎩ ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎤᎾᏚᎸᎲᎩ ᏂᎯ ᏥᏥᎪᏩᏘ ᎤᏂᎪᏩᏛᏗᏱ, ᎠᏎᏃ ᎥᏝ ᏳᏂᎪᎮᎢ; ᎠᎴ ᎤᎾᏛᎪᏗᏱ ᎾᏍᎩ ᏂᎯ ᏥᏣᏛᎩᎭ, ᎠᏎᏃ ᎥᏝ ᏳᎾᏛᎦᏁᎢ


text:
ᎬᏂᏳᏉᏃ, ᎩᎶ ᎢᏳᏍᏗ ᏗᎧᎿᏩᏛᏍᏗ ᏗᎪᏏᏏᏍᎩ ᏚᎴᏁᎢ, ᎠᎴ ᎤᎪᎵᏰᏍᎬ ᎯᎠ ᏄᏪᏎᎢ, ᏔᏕᏲᎲᏍᎩ, ᎦᏙ ᏯᏆᏛᏁᎸ ᎠᏆᏤᎵ ᏱᏂᎦᎵᏍᏓ ᎬᏂᏛ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ?


text:
ᏧᏁᏨᏃ ᎯᎠ ᏄᏪᏎᎢ, ᎯᎨᏳᏎᏍᏗ ᏱᎰᏩ ᏣᏁᎳᏅᎯ, ᎲᏗᏍᎨᏍᏗ ᏂᎦᎥ ᏣᎾᏫ ᏣᎸᎢ, ᎠᎴ ᏂᎦᎥ ᏣᏓᏅᏙᎩ, ᎠᎴ ᏂᎦᎥ ᏣᎵᏂᎬᎬᎢ, ᎠᎴ ᏂᎦᎥ ᏣᏓᏅᏖᏗ ᎨᏒᎢ; ᎾᎥᏃ ᎢᏗᏍᏓᏓᎳ ᏨᏒ ᏂᏣᏓᎨᏳᏒ ᎾᏍᎩᏯ ᏂᎨᏳᏎᏍᏗ.


text:
ᎠᎴ ᏭᎷᏤ ᎠᎴ ᏚᎸᎡᎴ ᏓᏥᏐᏅᏅᎢ, ᎠᎴ ᎪᎢ ᎩᎦᎨᏃ-ᎠᏗᏔᏍᏗ ᏓᏍᏚᏞᎮᎢ, ᎠᎴ ᎤᏩᏒ ᎤᎩᎸᏙᏗ ᎤᎩᎸᎳᏁᎢ, ᏧᏂᏒᏍᏗᏱᏃ ᎠᏓᏁᎸ ᎤᏘᏃᎴᎢ, ᎠᎴ ᎤᏍᏆᏂᎪᏔᏁᎢ.


text:
ᎤᎩᏨᏛᏃ ᎿᏉ ᎤᏂᎩᏒ, ᏔᎵ ᎠᏂᎩᏏ ᏧᎾᎬᏩᎶᏗ ᏑᎴᏎᎢ, ᎠᎴ ᏚᏁᎴ ᎦᏁᎳ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎴᎢ, ᎯᏍᏆᏂᎪᏕᏍᏗ, ᎢᎦᎢᏃ ᏫᎦᎶᏒᏍᏗᏍᎬ ᏣᎫᏴᎯᏙᎸᎢ, ᎢᏥᎷᏨᎭ ᎢᎬᏯᎫᏴᎡᎸᎭ.


text:
ᎹᏗᏍᎩᏂ ᎤᏪᎵᎯᏍᏗᏍᎨ ᎤᏣᏘ ᏚᎸᏫᏍᏓᏁ-ᎲᎢ, ᎠᎴ ᎤᎷᏤᎴ ᎯᎠ ᏄᏪᏎᎴᎢ, ᏣᎬᏫᏳᎯ, ᏝᏍᎪ ᎪᎱᏍᏗ ᏰᎵᎭ ᎥᎩᎸ ᏣᏋᏕᏨ ᏣᎩᎯᏯᏍᏓᏁᎸ ᎠᏋᏒᏉ ᎪᎱᏍᏗ ᎢᏨᏯᏛᏁᏗᏱ? ᎾᏍᎩᎢᏳᏍᏗ ᏘᏁᏥ ᏓᎩᏍᏕᎸᏗᏱ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ ᎠᏓᏙᎵᏍᏗᏍᎬ ᎢᎸᎯᏢ, ᎤᏑᎵᎪᏨ, ᎠᏏᏴᏫ ᎤᏍᏓᏩᏗᏙᎯ ᎯᎠ ᏄᏪᏎᎴᎢ, ᏣᎬᏫᏳᎯ, ᏍᎩᏰᏲᎲᎦ ᎣᎦᏓᏙᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᏣᏂ ᏥᏄᏛᏁᎴ ᏥᏚᏪᏲᏁ ᎬᏩᏍᏓᏩᏗᏙᎯ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ ᎯᎠ ᏂᏥᏪᏍᎨᏍᏗ, ᎣᎩᏙᏓ ᎦᎸᎳᏗ ᎮᎯ, ᎦᎸᏉᏗᏳ ᎨᏎᏍᏗ ᏕᏣᏙᎥᎢ; ᏨᎬᏫᏳᎯ ᎨᏒ ᏫᎦᎾᏄᎪᎢ; ᎭᏓᏅᏖᏍᎬ ᏫᏂᎦᎵᏍᏓ ᎡᎶᎯ ᎾᏍᎩᏯ ᎦᎸᎳᏗ ᏥᏂᎦᎵᏍᏗᎭ.


text:
ᎠᏎᏃ ᎠᎦᏔᎮ ᏄᏍᏛ ᏓᎾᏓᏅᏖᏍᎬ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᏂᎦᎥ ᎠᏰᎵ ᏕᎪᏢᏒᎢ ᏔᎵ ᏥᎾᏓᏗᏍᎪ ᎤᏩᏒ ᏣᏓᏡᏗᏍᎪᎢ, ᎠᏲᎪᏉ; ᎠᎴ ᏏᏓᏁᎸ ᏔᎵ ᏥᏄᏓᎣ ᎤᏩᏒ ᏣᏓᏡᏗᏍᎪ ᎠᏲᎪᎢ.


text:
ᎿᏉᏃ ᎡᎪᎢ, ᎠᎴ ᏫᏓᏯᏂᏍᎪ ᎦᎵᏉᎩ ᏗᏓᏅᏙ ᏅᏩᎾᏓᎴ ᎤᏟ ᎢᏳᏂᏁᎫᏥᏛ ᎡᏍᎦᏉ ᎤᏩᏒ; ᎾᏍᎩᏃ ᎠᏂᏴᎯᎰ ᎠᎴ ᎾᎿ ᎠᎾᏁᎳᏗᏍᎪᎢ; ᎣᏂᏱᏃ ᏄᏍᏛ Ꮎ ᎠᏍᎦᏯ ᎤᏟ ᎤᏲᎢᏳ ᎨᏐᎢ ᎡᏍᎦᏉ ᎢᎬᏱᏱ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎠᏏᏉ ᎾᏍᎩ ᎯᎠ ᏂᎦᏪᏍᎨᎢ, ᎩᎶ ᎢᏳᏍᏗ ᎠᎨᏴ ᎨᎳ ᎤᎾᏓᏡᎬ ᎤᏌᎳᏓᏁ ᎧᏁᎬ ᎠᎴ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎣᏏᏳ ᎢᏳᎵᏍᏓᏁᏗ ᏂᎯ ᏣᎾᏄᎪᏫᏒᎯ ᎠᎴ ᎾᏍᎩ ᏣᏍᏛᏅᎯ.


text:
ᎿᏉᏃ ᏴᏫ ᎦᏁᏄᎵ ᎤᎾᏓᏟᏌᏅ, ᎤᎴᏅᎮ ᎯᎠ ᏄᏪᏎᎢ; ᎤᏂᏲ ᎪᎯ ᏣᏁᎭ; ᎤᏂᏲᎭ ᎤᏰᎸᏛᎢ; ᎠᏎᏃ ᎥᏝ ᎨᏥᎾᏄᎪᏫᏎᏗ ᏱᎨᏎᏍᏗ ᎤᏰᎸᏛᎢ, ᏦᎾ ᎠᏙᎴᎰᏍᎩ ᎤᏤᎵ ᎤᏰᎸᏛ ᎤᏩᏒ.


text:
ᎤᎬᏫᏳᎯ ᎠᎨᏴ ᏧᎦᎾᏮ ᏤᎮᎢ ᏙᏛᎾᎴᏂ ᎪᎯ ᏣᏁᎭ ᏗᎫᎪᏙᏗᏱ ᎨᏎᏍᏗ, ᎠᎴ ᏧᎾᏚᎪᏓᏁᏗᏱ ᏂᏙᏓᎬᏁᎵ; ᎾᏍᎩᏰᏃ ᏩᏍᏛ ᎢᏴᏛ ᎦᏙᎯ ᏧᏅᏎ ᎤᏛᎦᏂᎴ ᏐᎵᎹᏅ ᎠᎦᏔᎾᎥᎢ; ᎬᏂᏳᏉᏃ ᎠᏂ ᎡᏙᎭ ᎤᏟ ᎢᏯᏥᎸᏉᏗ ᎡᏍᎦᏉ ᏐᎵᎹᏅ.


text:
ᏴᏫ ᏂᏂᏫ ᏣᏁᎮ ᏙᏛᎾᎴᏂ ᎪᎯ ᏣᏁᎭ ᏗᎫᎪᏗᏱ ᎨᏎᏍᏗ, ᎠᎴ ᏧᎾᏚᎪᎵᏁᏗᏱ ᏅᏛᏅᏁᎵ; ᏚᏂᏁᏟᏴᏎᏰᏃ ᏚᎾᏓᏅᏛ ᏦᎾ ᏚᎵᏥᏙᏁᎸ; ᎬᏂᏳᏉᏃ ᎠᏂ ᎡᏙᎭ ᎤᏟ ᎢᏯᏥᎸᏉᏗ ᎡᏍᎦᏉ ᏦᎾ.


text:
ᎠᎦᏔ ᎠᏰᎸ ᎢᎦ ᎠᏘᏍᏓᏁᎯ; ᎾᏍᎩ ᎢᏳᏍᏗ, ᎢᏳᏃ ᎪᎱᏍᏗ ᏄᏍᏛᎾ ᎨᏎᏍᏗ ᎯᎦᏙᎵ, ᏂᎬ ᎯᏰᎸ ᎾᏍᏉ ᎧᎵᏬᎯ ᎨᏎᏍᏗ ᎢᎦ ᎦᏘ; ᎢᏳᏍᎩᏂ ᎯᎦᏙᎵ ᎤᏲ ᎨᏎᏍᏗ ᏂᎬ ᎯᏰᎸ ᎾᏍᏉ ᎧᎵᏬᎯ ᎨᏎᏍᏗ ᎤᎵᏏᎩ.


text:
ᎢᏳᏃ ᏂᎬ ᎯᏰᎸ ᎧᎵᏬᎯ ᎨᏎᏍᏗ ᎢᎦ ᎦᏘ, ᎢᎸᎯᏢ ᏄᏓᏓᎸᎾ ᎤᎵᏏᎩ, ᏂᎬ ᎤᎧᎵᏨᎯ ᎨᏎᏍᏗ ᎢᎦ ᎦᏘ, ᎾᏍᎩᏯ ᎠᏨᏍᏙᏗ ᎣᏍᏛ ᎠᏓᏪᎵᎩᏍᎬ ᎢᎦ ᏥᏣᏘᏍᏓᏁᎰᎢ.


text:
ᏂᎯᏍᎩᏂ ᎢᏥᏆᎵᏏ ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ! ᎠᏍᎪᎯᏁᏰᏃ ᎪᏣᎴᏛ ᎢᏣᎫᏱᏍᎪ ᏒᏟ ᎠᏟ ᎷᏫ ᎠᎴ ᏂᎦᎥ ᎤᏰᎿᎥᎢ, ᎢᏥᏃᎯᏯᏍᎪᏃ ᏚᏳᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ ᎠᎴ ᎤᏁᎳᏅᎯ ᎠᎨᏳᏗ ᎨᏒᎢ; ᎾᏍᎩᏍᎩᏂ ᏱᏂᏣᏛᏁᎴᎢ, ᎠᎴ ᏐᎢ ᏂᏥᏃᎯᏴᎾᏉ ᏱᎨᏎᎢ.


text:
ᎯᎠᏃ ᏄᏪᏎᎢ; ᏂᎯ ᎾᏍᏉ ᏗᎧᎿᏩᏛᏍᏗ ᏗᏦᏏᏏᏍᎩ ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ! ᏕᏥᏐᏈᎸᏍᎪᏰᏃ ᏴᏫ ᏗᎵᏒᏍᏗ ᎤᏕᏯᏙᏗ ᏗᎵᏒᏍᏗᏱ, ᎢᏨᏒᏍᎩᏂ ᎥᏝ ᏴᎨᏥᏃᏟᏍᏓ ᏗᎵᏒᏍᏗ ᏴᎨᏨᏓ ᏌᏉ ᎢᏥᏰᏌᏛᎢ.


text:
ᎡᏈᎵ ᎤᎩᎬ ᏅᏛᎴᏅᏛ, ᏤᎩᎳᏯ ᎤᎬᎬ ᏩᏍᏗ, ᎾᏍᎩ ᏧᎵᏍᏆᏕᎴ ᎠᏰᎵ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎤᏛᏅᏃ-ᏗᎦᎳᏫᎢᏍᏗᏱ; ᎤᏙᎯᏳᎯᏯ ᎢᏨᏲᏎᎭ, ᎨᏥᏔᏲᏎᏗ ᎨᏎᏍᏗ ᎪᎯ ᏣᏁᎭ.


text:
ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᏂᎯ ᏗᎧᎿᏩᏛᏍᏗ ᏗᏦᏏᏏᏍᎩ! ᎢᏥᏴᏫᏛᎲᏰᏃ ᎠᏍᏚᎢᏍᏗ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒᎢ; ᎥᏝᏰᏃ ᎢᏨᏒ ᏱᏥᏴᎸ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎠᏂᏴᎯᎯ ᏕᏥᏲᏍᏙᏓᏁᎸ.


text:
ᎾᎯᏳᏉᏃ ᏕᎠᏂᎳᏫᎡ ᎤᏂᏧᏈᏍᏗ ᏴᏫ, ᎾᏍᎩ ᎢᏳᏍᏗ ᏕᎠᎾᏓᎳᏍᏛᏗᏍᎨᎢ, ᎾᏍᎩ ᎤᎴᏅᎮ ᎯᎠ ᎢᎬᏴ ᏂᏚᏪᏎᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎢᏤᏯᏔᎮᏍᏗ ᎠᎪᏙᏗ ᎠᏂᏆᎵᏏ ᎤᎾᏤᎵᎦ, ᎾᏍᎩ ᎠᏠᎾᏍᏗ ᏥᎩ.


text:
ᎯᎠᏃ ᏅᏓᏥᏪᏎᎵ ᎠᏆᏓᏅᏙ; ᎠᏆᏓᏅᏙᎩ, ᎤᏣᏔ ᏣᏍᏆᏂᎪᏗ ᏧᎬᏩᎶᏗ ᎤᏣᏘ ᎢᏧᏕᏘᏴᏗ ᏣᎵᏍᏕᎸᏙᏗ; ᎭᏣᏪᏐᎸᏍᏓ, ᎭᎵᏍᏓᏴᎲᏍᎨᏍᏗ, ᎭᏗᏔᏍᏏᏍᏗ, ᎭᎵᎮᎵᎨᏍᏗ.


text:
ᎪᎳᏅ ᏗᏣᏓᏅᏛᎵ; ᎥᏝᏰᏃ ᏯᏂᏫᏍᎪᎢ, ᎥᏝ ᎠᎴ ᏯᏂᏍᎫᏕᏍᎪᎢ; ᎥᏝ ᎠᎴ ᏧᎾᏓᎾᏅᏗᏱ ᎠᎴ ᎤᏂᏅᏗᏱ ᏱᏓᏓᏁᎸ; ᎠᎴ ᎤᏁᎳᏅᎯ ᏕᎨᎶᎰᎢ. ᏂᎦᎥᎤᏟ ᏁᏥᎸᏉᏗ ᏂᎯ ᎡᏍᎦᏉ ᏥᏍᏆ.


text:
ᎢᏣᏓᏅᏛᎵ ᏧᏥᎸᎯ ᏓᏛᏍᎬᎢ; ᎥᏝ ᏱᏚᏂᎸᏫᏍᏓᏁᎰᎢ, ᎥᏝ ᎠᎴ ᏯᏂᏍᏙᎰᎢ; ᎠᏎᏃ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎾᏍᏉ ᏐᎵᎹᏅ ᏂᎦᎥ ᎤᏬᏚᎯᏳ ᎨᏒ ᎥᏝ ᎾᏍᎩ ᏱᏄᏍᏕ ᏚᏄᏩᎥᎢ ᎯᎠ ᎾᏍᎩ ᏌᏉ ᏄᏍᏛᎢ.


text:
ᎢᏳᏰᏃ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᏱᏂᎬᏁᎭ ᏱᎦᏄᏬᎭ ᎧᏁᏍᎦ, ᎾᏍᎩ ᎪᎯ ᎢᎦ ᏠᎨᏏ ᏤᎭ, ᎤᎩᏨᏅᏃ ᏗᎦᏚᏗᏱ ᏬᎾᏗᏅᏗ ᏥᎩ, ᎤᏟᎯᏳᏍᎩᏂ ᏂᎯ ᏂᏙᏓᏥᏄᏬᎢ ᎤᏍᏗ ᎢᏦᎯᏳᎯ!


text:
ᎢᏥᎾᏕᎨᏍᏗ ᎢᏥᎿᎥᎢ ᎠᎴ ᎢᏣᏓᏁᎸᎥᏍᎨᏍᏗ; ᎢᏣᏓᏁᎴᏍᏗ ᏕᎦᎶᏗ ᏂᏚᏪᏔᎬᎾ, ᏧᎬᏩᎶᏗ ᎦᎸᎳᏗ ᏫᏥᏟᏏᏍᎨᏍᏗ ᎠᏗᏒᎲᏍᎩ ᏂᎨᏒᎾ, ᎾᎿ ᏫᎬᏩᎷᎯᏍᏗ ᏂᎨᏒᎾ ᎦᏃᏍᎩᏍᎩ, ᎠᎴ ᏥᏍᎪᏯ ᏫᎬᏩᏲᏍᏙᏗ ᏂᎨᏒᎾ.


text:
ᎢᏨᏒᏃ ᏕᏣᏤᎴᏍᏗ ᎠᏂᏍᎦᏯ ᎾᏍᎩ ᏣᏂᎦᏘᏲ ᎤᏂᏅᏏᏙᎯ, ᎢᏳᏉ ᎤᎷᎯᏍᏗᏱ ᏕᎨᎦᏨᏍᏗᏍᎬ ᏭᏪᏙᎸᎯ; ᎾᏍᎩᏃ ᏳᎷᏨ ᎠᎴ ᏳᏩᏂᎸ, ᎾᏍᎩ ᎩᎳᏉ ᎢᏴᏛ ᏫᎬᏩᏍᏚᎢᎡᏗᏱ.


text:
ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎾᏍᎩ ᎨᏥᏅᏏᏓᏍᏗ, ᎤᏂᏅᏏᏙᎯ ᎦᎷᏨᎭ ᏓᏩᏛᎲᎭ ᎠᏂᏯᏫᏍᎬᎢ; ᎤᏙᎯᏳᎯᏯ ᎢᏣᏲᏎᎭ ᏛᏓᏠᎵ ᎤᏩᏒ, ᎠᎴ ᏙᏓᎧᏁᏤᎵ ᎤᎾᏂᏢᏗᏱ <n>[ᎤᎾᎵᏍᏓᏴᏗᏱ,]</n> ᎠᎴ ᏓᎦᎷᏥ ᏙᏛᏍᏕᎸᎯ.


text:
ᎤᎬᏫᏳᎯᏃ ᎯᎠ ᏄᏪᏎᎢ, ᎦᎪᏃ ᎾᏍᎩ Ꮎ ᎣᏍᏛ ᎠᎴ ᎠᎦᏔᎾᎢ ᎠᏓᏁᎸ ᎠᏥᎦᏘᏗᏍᏗ, ᎾᏍᎩ ᎤᏅᏏᏙᎯ ᏄᎬᏫᏳᏌᏕᎩ ᏅᏓᏳᏩᏁᎵ ᎦᏁᎸᎢ, ᎾᏍᎩ ᏧᏁᏗᏱ ᎤᎾᎵᏍᏓᏴᏗ ᏂᏓᏍᏆᎸᎯᏒᎢ?


text:
ᎢᏳᏍᎩᏂ ᎾᏍᎩ Ꮎ ᎠᏥᏅᏏᏓᏍᏗ ᎯᎠ ᏂᎦᏪᏒ ᎤᎾᏫᏱ, ᎠᎩᏅᏏᏙᎯ ᎪᎯᏗᎭ ᎤᎷᎯᏍᏗᏱ; ᎠᎴ ᎠᎴᏅᎲᎭ ᏙᎦᎵᎥᏂᎮᏍᏗ ᎠᏂᏍᎦᏯ ᎠᎴ ᎠᏂᎨᏴ ᎨᏥᏅᏏᏓᏍᏗ, ᎠᎴ ᎠᎵᏍᏓᏴᎲᏍᎨᏍᏗ ᎠᎴ ᎠᏗᏔᏍᎨᏍᏗ, ᎠᎴ ᎤᏴᏍᏕᏍᎨᏍᏗ;


text:
ᎾᏍᎩ Ꮎ ᎠᏥᏅᏏᏓᏍᏗ ᎤᏅᏏᏙᎯ ᏓᎦᎷᏥ ᎢᏳᏉ ᎢᎦ ᎾᏓᎦᏖᏃᎲᎾ ᎨᏒᎢ, ᎠᎴ ᎢᏳᏉ ᎠᎵᏰᎵᏒ ᏁᎵᏍᎬᎾ ᎨᏒᎢ, ᎠᎴ ᏙᏓᏳᎦᎵᏏ, ᎠᎴ ᏮᏓᏳᏎᎮᎵ ᏄᏃᎯᏳᏒᎾ ᏗᏁᎲᎢ.


text:
ᎾᏍᎩᏃ Ꮎ ᎠᏥᏅᏏᏓᏍᏗ ᎠᎦᏔᎯ ᏄᏍᏛ ᎤᏚᎵᏍᎬ ᎤᏅᏏᏙᎯ, ᎠᎴ ᏄᏛᏅᎢᏍᏔᏅᎾ ᎢᎨᏎᏍᏗ, ᎠᎴ ᎾᏍᎩᏯ ᏄᏍᏛ ᎤᏚᎵᏍᎬ ᏄᏛᏁᎸᎾ ᎢᎨᏎᏍᏗ, ᎤᏣᏘ ᎢᏯᎬᏂᏍᏗ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩᏂ ᎾᎦᏔᎲᎾ ᎨᏒ ᎠᎴ ᏰᎵᏉ ᎦᏰᏥᎵᎥᏂᏍᏗ ᎢᏳᏛᏁᎸᎯ ᎨᏎᏍᏗ ᎾᏍᎩ ᎦᏲᎵᏉ ᎢᏯᎬᏂᏍᏗ ᎨᏎᏍᏗ. ᏱᎶᏃ ᎤᏣᏘ ᎠᏥᏁᎸᎯ, ᎤᏣᏘ ᎠᏥᏔᏲᏎᏗ ᎨᏎᏍᏗ; ᎠᎴ ᎩᎶ ᎤᏣᏘ ᏗᎬᏩᏲᎯᏎᎸᎯ ᏴᏫ, ᎾᏍᎩ ᎤᏟ ᎢᎦᎢ ᎬᏩᏔᏲᏎᏗ ᎨᏎᏍᏗ.


text:
ᎠᎦᏴᎵᎨᎢ ᏔᎵ ᏄᎾᏓᎡᏍᏗ ᎠᏍᎦᏯ ᎤᏪᏥ, ᎠᎦᏅᎩᏃ ᎠᏍᎦᏯ ᏔᎵ ᏄᎾᏓᎡᏍᏗ ᎤᏙᏓ; ᎠᎴ ᎠᎨᏴ ᏔᎵ ᏄᎾᏓᎡᏍᏗ ᎠᎨᏴ ᎤᏪᏥ, ᎠᎴ ᎠᎦᏅᎩ ᎠᎨᏴ ᏔᎵ ᏄᎾᏓᎡᏍᏗ ᎤᏥ; ᎤᏦᎯᏃ ᏔᎵ ᏄᎾᏓᎡᏍᏗ ᎤᏓᏦᎯᏯ, ᎠᎴ ᎤᏓᏦᎯᏯ ᏔᎵ ᏄᎾᏓᎡᏍᏗ ᎤᏦᎯ.


text:
ᎢᏳᏃ ᏣᏱᎵᏙᎯ ᏗᏓᎪᏗᏍᎩᏱ ᏍᏓᎢᏎᏍᏗ, ᎠᏏᏉ ᏫᏍᏓᎢᏒᎢ, ᎭᏟᏂᎬᏁᎸᎭ ᎯᏯᏚᎵᏔᎡᏗᏱ; ᏗᏓᎪᏗᏍᎩᏱ ᎾᏏ ᏫᏱᏣᏘᏃᎦ, ᏗᏓᎪᏗᏍᎩᏃ ᏗᏓᏂᏱᏍᎩᏱ ᏫᏱᏕᏣᏲᎯ, ᏗᏓᏂᏱᏍᎩᏃ ᏗᏓᏍᏚᏗᏱ ᏫᏱᏣᏴᏓ.


text:
ᏥᏌᏃ ᏚᏁᏤᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎢᏣᏓᏅᏖᏍᎬᏍᎪ ᎯᎠ ᎾᏍᎩ ᎨᎵᎵ ᎠᏁᎯ ᏧᏂᎪᎾᏛᏔᏅᎯ ᎨᏎ ᎠᏂᏍᎦᎾᎯᏳ ᎨᏒ ᏂᎦᏛ ᎨᎵᎵ ᎠᏁᎯ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎾᏍᎩ ᏥᏄᎾᎵᏍᏓᏁᎴᎢ?


text:
ᎿᏉᏃ ᎯᎠ ᏄᏪᏎᎴ ᎣᏍᏛ ᎢᏳᏩᎿᏕᎩ ᏖᎸᎳᏗ ᏚᏫᏒᎢ, ᎬᏂᏳᏉ, ᎿᏉ ᏦᎢ ᎾᏕᏘᏴ ᏥᎷᎬᎩ ᎠᎩᏲᎲᎩ ᎤᏓ-ᏔᏅᎯ ᎯᎠ ᎾᏍᎩ ᎡᎦᏔ-ᎢᏳᏍᏗ ᏡᎬᎢ, ᎠᎴ ᎥᏝ ᏱᏥᏩᏘᎭ; ᎯᎴᏴᏍᏓ; ᎦᏙᏃ ᎢᎤᎨᏗ ᎦᏙᎯ?


text:
ᏗᎦᎳᏫᎢᏍᏗᏱᏃ ᏄᎬᏫᏳᏌᏕᎩ ᎤᎿᎸᎯ ᎤᏁᏤᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏥᏌ ᎤᏓᏅᏩᏅ ᎤᎾᏙᏓᏆᏍᎬ ᎢᎦ ᏚᏳᎪᏗ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ ᏴᏫ; ᎾᎯᏳᏍᎩᏂ ᎢᏥᎷᎨᏍᏗ ᎠᎴ ᏕᏥᏅᏫᏍᎨᏍᏗ, ᏞᏍᏗᏃ ᎤᎾᏙᏓᏆᏍᎬ ᎢᎦ.


text:
ᎤᎬᏫᏳᎯᏃ ᎿᏉ ᎤᏁᏤᎴ ᎯᎠ ᏄᏪᏎᎴᎢ, ᏣᏠᎾᏍᏗ! ᏝᏍᎪ ᏂᎯ ᎢᏥᏏᏴᏫᎭ ᎨᏒ ᎤᎾᏙᏓᏆ-ᏍᎬ ᏰᏤᎵᏌᏕᏍᎪ ᏗᎨᎳᏍᏗᏱ ᎢᏣᏤᎵ ᏩᎪ ᎠᎴ ᏐᏈᎵᏗᎦᎵᎠᏅ-ᎯᏛ, ᎠᎴ ᏰᏣᏘᏁᎪ ᎠᎹ ᏰᏣᏗᏔᏍᏔᏁᎪᎢ?


text:
ᎠᏥᎸ-ᎤᎦᏔ ᏓᏤᎸ, ᎾᏍᎩ ᎠᏍᎦᏯ ᏧᎩᏎ ᎠᎴ ᎤᏫᏒᏗᏱ ᏥᏭᏗᏅᏎᎢ; ᎠᎴ ᎤᏛᏎᎢ, ᎠᎴ ᎡᏉᎯᏳ ᏄᎵᏍᏔᏁ ᏡᎬᎢ; ᎠᎴ ᏥᏍᏆ ᎦᎸᎶ ᎠᏂᏃᎯᎵᏙᎯ ᏚᏩᏂᎦᎸ ᎤᎾᎭᏓᏕᎢ.


text:
ᎢᏳᏃ ᎿᏉ ᎠᏍᎦᏯ ᎦᏁᎳ ᏓᎴᏅᎭ ᎠᎴ ᎠᏍᏚᏅᎭ ᎦᎶᎯᏍᏗᏱ, ᏂᎯᏃ ᎢᏣᎴᏅᎲ ᏙᏱᏗᏢ ᎢᏥᏙᎾᎥᎢ, ᎠᎴ ᎢᏨᏂᎮᏍᏗ ᎦᎶᎯᏍᏗᏱ ᎯᎠ ᏂᏤᏪᏍᎨᏍᏗ, ᏣᎬᏫᏳᎯ, ᏣᎬᏫᏳᎯ, ᎡᏍᎩᏍᏚᎢᏏ; ᎠᎴ ᏗᎧᏁᏨ ᎯᎠ ᏅᏗᏥᏪᏎᎸᎭ, ᎥᏝ ᏱᏥᎦᏔᎭ ᏗᏣᏓᎴᏅᎢ;


text:
ᎾᎿ ᏓᏂᏴᎨᏍᏗ ᎠᎴ ᏓᏂᎸᏓᎩᏍᎨᏍᏗ ᏓᏂᏄᏙᎬᎢ, ᎾᎯᏳ ᏕᏥᎪᎲᎭ ᎡᏆᎭᎻ ᎠᎴ ᎡᏏᎩ ᎠᎴ ᏤᎦᏈ ᎠᎴ ᏂᎦᏛ ᎠᎾᏙᎴᎰᏍᎩ, ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎾᎿ ᎠᏂᏯᎡᏍᏗ, ᎢᏨᏒᏃ ᎡᏥᏄᎪᏫᏒᎯ ᎨᏎᏍᏗ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎢᏤ-Ꮎ, ᎠᎴ ᎯᎠ ᏫᏁᏥᏪᏏ Ꮎ ᎫᎳ, ᎬᏂᏳᏉ ᎠᏂᏍᎩᎾ ᏕᏥᏄᎪᏫᏍᎦ, ᎠᎴ ᏕᎦᏓᏅᏫᎭ ᎪᎯ ᎢᎦ ᎠᎴ ᎤᎩᏨᏅᎢ, ᏦᎢᏁᏃ ᎢᎦ ᎠᎩᏍᏆᏛᎯ ᎨᏎᏍᏗ.


text:
ᏥᎷᏏᎵᎻ! ᏥᎷᏏᎵᎻ! ᎠᎾᏙᎴᎰᏍᎩ ᏘᎯᎯ, ᎠᎴ ᏅᏯ ᏛᏂᏍᏗᏍᎩ ᎨᏣᎷᏤᏗᏱ ᎨᏥᏅᏒᎯ; ᏯᏃᎩᏳ ᎠᏆᏚᎵᏍᎬ ᎦᏥᏯᏟᏐᏗᏱ ᏗᏤᏥ, ᎾᏍᎩᏯ Ꮳ-ᏔᎦ ᏥᏕᎦᏟᏏᏍᎪ ᏧᏪᏥ ᎠᏂᏛ ᎠᏫᏂᏗᏢ ᏗᎧᏃᎨᏂ, ᎠᏎᏃ ᎥᏝ ᏱᏣᏚᎵᏍᎨᎢ!


text:
ᎬᏂᏳᏉ ᎢᏥᏁᎸ ᏅᏔ ᏁᏨᏁᎸ; ᎠᎴ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎥᏝ ᏴᎨᏍᎩᎪᏩᏛ ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᎬᏂ ᎯᎠ ᎢᏥᏪᏍᏗᏱ ᎠᏍᏆᎸᎲᎭ, ᎠᏥᎸᏉᏗᏳ ᎾᏍᎩ Ꮎ ᏱᎰᏩ ᏕᏅᏙᎥ ᏥᎦᎷᎯᏍᏗᎭ.


text:
ᎡᏣᏯᏂᏍᎨᏍᏗᏍᎩᏂ, ᎮᎨᏍᏗ ᎠᎴ ᏣᏂᏏᎲᏍᎨᏍᏗ ᎡᎳᏗ ᎨᏒ ᏗᏂᏢᏗᏱ; ᎾᏍᎩᏃ ᏫᏣᏯᏅᏛ ᎦᎷᎨᏍᏗ, ᎯᎠ ᎢᏳᏣᏪᏎᏗ ᏱᎩ, ᎩᎾᎵᎢ, ᎦᎸᎳᏗᏢᏍᏙᏗ ᏫᎶᎯ; ᎿᏉ ᎡᏣᎸᏉᏗᏳ ᎨᏎᏍᏗ ᎠᏂᎦᏔᎲ ᎢᏧᎳᎭ ᎢᏥᏂᏜᎢ <n>[ᏗᎵᏍᏓᏴᏗᏱ.]</n>


text:
ᎯᎠᏃ ᎾᏍᏉ ᏄᏪᏎᎴ ᏭᏯᏅᏛ, ᎢᏳᏃ ᏕᎭᏕᎳᏍᏗᏍᎨᏍᏗ ᎢᎦ ᎡᎯ ᎠᎴ ᎤᏒ ᎡᎯ, ᏞᏍᏗ ᏱᏫᏘᏯᏂᏍᎨᏍᏗ ᏗᏣᎵᎢ, ᎠᎴ ᎢᏣᎵᏅᏟ, ᎠᎴ ᎪᎱᏍᏗ ᏗᏨᏅ, ᎠᎴ ᏧᏁᎾᎢ ᎾᎥ ᎢᏣᏓᎳ; ᎾᏍᏉᏰᏃ ᏂᎯ ᏱᏮᎨᏣᏯᏅ ᎠᎴ ᏴᎨᏣᏓᏴᏏ.


text:
ᏂᎦᏛᏃ ᎤᏠᏱ ᏧᎾᏢᏫᏍᏙᏗ ᎤᎾᎴᏅᎮ ᎤᏂᏲᎴᎢ. ᎢᎬᏱᏱ ᎯᎠ ᏄᏪᏎᎴᎢ, ᏠᎨᏏ ᎠᎩᏩᏒ, ᎠᎴ ᎠᏎ ᎠᏇᏅᏍᏗ ᎠᎴ ᎠᏆᎦᏔᏅᏍᏗ ᏂᎦᎵᏍᏗᎭ; ᎬᏔᏲᏎ ᎤᏁᎳᎩ ᏍᏇᎵᏎᏗᏱ.


text:
ᎾᏍᎩᏃ Ꮎ ᎠᏥᏅᏏᏓᏍᏗ ᎢᎤᎷᏨ ᎤᎾᏄᎪᏫᏎᎴ ᎤᏅᏏᏙᎯ ᎾᏍᎩ ᎯᎠ ᏄᎵᏍᏔᏂᏙᎸᎢ. ᎦᏁᎳᏃ ᎤᎾᎸᎯᏳ ᎨᏒ ᎯᎠ ᏄᏪᏎᎴ ᎤᏅᏏᏓᏍᏗ, ᎮᎾ ᏄᎳ ᏫᏴᎲ ᎡᎾᎢᏓᏍᏗᏱ ᎠᎴ ᏧᏍᏗ ᏕᎦᎳᏅᏛᎢ ᎦᏚᎲᎢ, ᎠᎴ ᏕᎭᏘᏃᎸᎭ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ, ᎠᎴ ᎪᎱᏍᏗ ᎤᏍᏛ ᏗᏂᏰᎸ ᎤᏂᏲᎱᏎᎸᎯ, ᎠᎴ ᏗᏂᏲᎤᎵ, ᎠᎴ ᏗᏂᎨᏫ.


text:
ᎩᎶ ᎠᏴ ᎠᎩᎷᏤᎮᏍᏗ ᏂᏗᎦᏂᏆᏘᎲᎾᏃ ᎢᎨᏎᏍᏗ ᎤᏙᏓ, ᎠᎴ ᎤᏥ, ᎠᎴ ᎤᏓᎵᎢ, ᎠᎴ ᏧᏪᏥ, ᎠᎴ ᎠᎾᎵᏅᏟ, ᎠᎴ ᏧᏙ, ᎥᎥ, ᎠᎴ ᎤᏩᏒ ᎾᏍᏉ ᎬᏅᎢ, ᎥᏝ ᏰᎵ ᎠᎩᏍᏓᏩᏗᏙᎯ ᏱᏅᎦᎵᏍᏓ.


text:
ᎦᎪᏰᏃ ᎯᎠ ᏥᏂᏣᏛᏅ, ᏯᏓᏅᏖ ᎢᏅ ᎢᎦᏘ ᎤᏁᏍᎨᏗᏱ, ᎥᏝ ᎢᎬᏱ ᏱᎦᎲᏍᎪ ᏯᏎᎯᎰ ᎢᎦᎢ ᏧᎬᏩᏔᏂᎯᏍᏗ ᎨᏒᎢ, ᎤᏙᎴᎰᎯᏍᏗᏱ ᏰᎵ ᎬᏩᏍᏆᏗᏍᏙᏗ ᎢᎦᎢ ᎤᎲᎢ.


text:
ᎠᎴ ᎦᎪ ᎢᏳᏍᏗ ᎤᎬᏫᏳᎯ, ᏓᎿᏩ ᏱᏅᏛᏅᏁᎵ ᏅᏩᏓᎴ ᎤᎬᏫᏳᎯ, ᎥᏝ ᎢᎬᏱ ᏱᎦᎲᏍᎪ ᎠᎴ ᏯᏓᏅᏖᏍᎪ ᏰᎵᏉ ᎠᏍᎪᎯ ᎢᏯᎦᏴᎵ ᏓᏘᏁᎲ ᏗᎬᏩᎾᏟᏴᏗ ᎨᏒ ᏧᎦᏘᎴᎩ ᏔᎳᏍᎪᎯ ᎢᏯᎦᏴᎵ ᏓᏘᏁᎲᎢ.


text:
ᎦᎪ ᎯᎠ ᏘᏂᏣᏛᏅ, ᎠᏍᎪᎯᏧᏈ ᏱᏚᎾᏝᎠ ᎤᏂᏃᏕᎾ, ᎢᏳᏃ ᏌᏉ ᏳᏲᎱᏎᎸ, ᎥᏝ ᏱᏗᎬᏕᎪ ᎢᎾᎨ ᎠᏁᏙᎲ ᏐᎣᏁᎳᏍᎪᎯ ᏐᎣᏁᎳᎦᎵ ᎢᏯᏂᏛ, ᎠᎴ ᏳᏲᎴᎪ ᎤᏲᎱᏎᎸᎯ, ᎬᏂ ᎠᏩᏛ?


text:
ᎢᏨᏲᏎᎭ, ᎾᏍᏉᏍᎩᏂ ᎤᏟᎯᏳ ᎾᎾᎵᎮᎵᎨᏍᏗ ᎦᎸᎳᏗ ᏦᏒ ᏌᏉ ᎠᏍᎦᎾ ᎦᏁᏟᏴᏍᎨᏍᏗ ᎤᏓᏅᏛᎢ, ᎡᏍᎦᏉ ᎢᏴᏛ ᏐᏱᏁᎳᏍᎪᎯ ᏐᏱᏁᎳᎦᎵ ᎢᏯᏂᏛ ᎤᎾᏓᏅᏘ ᎠᏂᏍᎦᏯ ᏧᏂᏁᏟᏴᏍᏗ ᏄᎾᎵᏍᏓᏁᎲᎾ ᏚᎾᏓᏅᏛᎢ.


text:
ᎠᎴ ᎦᎪ ᎢᏳᏍᏗ ᎠᎨᏴ ᎠᏍᎪᎯ ᏱᏚᎭ ᎠᎩᏏ ᏧᎾᎬᏩᎶᏗ, ᎢᏳᏃ ᏌᏉ ᏳᏲᎱᏎᎸ, ᎥᏝ ᏯᏨᏍᏛᏍᎪ ᎠᏨᏍᏙᏗ ᎠᎴ ᏱᎬᏃᏌᏍᎪ ᎦᎵᏦᏕ, ᎠᎴ ᎤᎵᏏᎾᎯᏍᏗ ᏳᏲᎰ ᎬᏂ ᎠᏩᏛ?


text:
ᎤᏁᏨᏃ ᎯᎠ ᏄᏪᏎᎴ ᎤᏙᏓ; ᎬᏂᏳᏉ ᎤᏣᏔ ᎾᏕᏘᏴ ᎬᏍᏕᎸᎯᏓ, ᎠᎴᎥᏝ ᎢᎸᎯᏳ ᎾᏉᎯᏳᏅᎾ ᏱᎩ ᏣᏁᏨᎢ, ᎠᏎᏃ ᎥᏝ ᎢᎸᎯᏳ ᎠᏫ-ᎠᎩᎾ ᎠᏎᏄᎸᎯ ᏱᏍᎩᎧᏁᎶᎢ, ᎣᏍᏛ ᎣᎦᏓᏅᏓᏗᏍᏙᏗ ᏗᏆᎵᎢ.


text:
ᎠᎴ ᎾᏍᏉ ᎯᎠ ᏂᏚᏪᏎᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ, ᎩᎶ ᎢᏳᏍᏗ ᎡᎮ ᎤᏪᎿᎢ ᎠᏍᎦᏯ ᎾᏍᎩ ᎤᏪᎧᎮ ᎤᎦᏌᏯᏍᏗᏕᎩ ᎤᎿᎥᎢ; ᎠᎴ ᎾᏍᎩ ᎠᏥᎳᏫᏎᎲ ᏧᎬᏩᎶᏗ ᎤᏓᏤᏪᎸ ᎠᏥᏃᏁᎴᎢ.


text:
ᏭᏯᏅᎮᏃ ᎯᎠ ᏄᏪᏎᎴᎢ, ᎦᏙ ᏗᎦᎵᏍᏙᏗᎭ ᏥᏄᏍᏗ ᏥᎬᏯᏛᎩᎭ? ᎬᏂᎨᏒ ᏅᎦ ᏄᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎸ ᏣᎦᏌᏯᏍᏗᏕᎩ ᎨᏒᎢ; ᎪᎯᏰᏃ ᎢᏳᏓᎴᏅᏛ ᎥᏝ ᎿᏉ ᏣᎦᏌᏯᏍᏗᏕᎩ ᏱᎨᏎᏍᏗ.


text:
ᎤᎦᏌᏯᏍᏗᏕᎩᏃ ᎯᎠ ᏄᏪᏎ ᎤᏩᏒ ᏧᏓᏅᏛᎢ, ᎦᏙ ᏓᎦᏛᏁᎵ, ᎠᎩᏅᏏᏙᎯᏰᏃ ᎠᎩᎩᎡᎭ ᎠᏆᎦᏌᏯᏍᏗᏕᎩ ᎨᏒᎢ? ᏝᏃ ᏰᎵ ᎬᏆᏍᎪᏍᏗ ᏱᎩ; ᎠᏆᏚᎳᏗᏓᏍᏗᏱᏃ ᎢᎦᏕᎣᏍᎦ.


text:
ᏅᏩᏓᎴᏃ ᎯᎠ ᏄᏪᏎᎴᎢ, ᏂᎯᎾ ᎢᎳᎪ ᎡᏣᏚᎦ? ᎯᎠᏃ ᏄᏪᏎᎢ, ᎠᏍᎪᎯᏧᏈ ᎢᏳᏟᎶᏛ ᎤᏣᎴᏍᏗ. ᎯᎠᏃ ᏄᏪᏎᎴᎢ, ᎯᎾᎩ ᎪᏪᎵ ᎡᏣᏚᎬᎢ, ᎠᎴ ᏁᎳᏍᎪᎯ ᎰᏪᎸᎦ.


text:
ᎥᏝ ᎩᎶ ᎠᏥᏅᏏᏓᏍᏗ ᏰᎵ ᎠᏂᏔᎵ ᎬᏩᏅᏏᏙᎯ ᎪᎱᏍᏗ ᏱᏙᎬᏛᏂᏏ; ᏱᎠᏍᎦᎦᏰᏃ ᏌᏉ ᏱᎤᎨᏳᎭᏃ ᏐᎢ; ᏱᏃᎤᏂᏴᏆᎴ ᏌᏉ ᏱᎦᏂᏆᏘᎭᏃ ᏐᎢ. ᏝᏍᎩᏂ ᏰᎵ ᎤᏁᎳᏅᎯ ᎠᎴ ᎹᎹᏂ ᎪᎱᏍᏗ ᏱᏙᎨᏣᏛᏂᏏ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᏂᎯ ᎧᏂ ᏚᏳᎪᏛ ᎢᏣᏛᏁᎯ ᏅᏩᏍᏙᎢ ᏴᏫ ᎠᏂᎦᏔᎲᎢ; ᎤᏁᎳᏅᎯᏍᎩᏂ ᏓᎦᏔᎭ ᏗᏥᎾᏫ; ᎾᏍᎩᏰᏃ ᎦᎸᏉᏗᏳ ᏧᏂᏰᎸᏐ ᏴᏫ, ᎤᏂᏆᏘᏍᏗᏳ ᎤᏁᎳᏅᎯ ᏓᎧᏂᏍᎬᎢ.


text:
ᏗᎧᎿᏩᏛᏍᏗ ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ ᏕᏤᎲᎩ ᏣᏂ ᎤᎾᏄᎪᏥᎸ ᎢᏯᏍᏗ; ᎾᎯᏳ ᏅᏓᎬᏓᎴᏅᏛ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎠᏂᏃᎮᎭ ᎠᎾᎵᏥᏙᎲᏍᎦ, ᎠᎴ ᎾᏂᎥ ᏴᏫ ᎠᎾᏁᎷᎩ ᎠᏂᏴᎯᎭ.


text:
ᎠᎴ ᎤᏪᎷᏁ ᎯᎠ ᏄᏪᏎᎢ; ᎡᏙᏓ ᎡᏆᎭᎻ, ᏍᎩᏙᎵᎩ, ᎠᎴ ᎡᎯᏅᎵ ᎳᏏᎳ, ᎠᎴ ᎾᏍᎩ ᎤᏍᎪᎵ ᎦᏰᏌᏛ ᎠᎼᎯ ᏩᎱᏓ, ᎠᎴ----ᏩᎩᏙᎣᎸᏍᏓᏏ ᏥᏃᎪᎢ; ᏥᎩᎵᏲᎦᏰᏃ ᎠᏂ ᎠᏓᏪᎵᎩᏍᎬᎢ.


text:
ᎠᏎᏃ ᎡᏆᎭᎻ ᎯᎠ ᏄᏪᏎᎢ; ᎠᏇᏥ, ᎭᏅᏓᏓ,. ᏂᎯ ᎠᏏ ᏣᎴᏂᏙᎲᎩ ᎯᏩᏘᏍᎬ ᏣᏤᎵᎦ ᎣᏍᏛ, ᎠᎴ ᎳᏏᎳ ᎾᏍᏉ ᎠᏩᏘᏍᎬᎩ ᎤᏤᎵᎦ ᎤᏲᎢ. ᎠᏎᏃ ᎿᏉ ᎠᏥᏄᏬᎯᏍᏔᏅ, ᏂᎯᏃ ᎢᎯᎩᎵᏲᎦ.


text:
ᎠᎴᏃ ᎾᏍᏉ ᎠᏴ ᎣᏤᎲ ᏂᎯᏃ ᎢᏤᎲ ᎾᎿ ᎠᏰᎵ ᎨᏒ ᎡᏉᎯᏳ ᎤᏜᏅᏛᎢ ᎪᏢᎭ, ᎾᏍᎩ ᎢᏳᏍᏗ ᎩᎶ ᏳᎾᏚᎵᎭ ᎠᏂ ᎤᎾᏓᎴᏍᏗᏱ ᏗᏤᎲ ᏭᏂᎶᎯᏍᏗᏱ, ᎥᏝ ᏰᎵ ᏱᏅᎬᎾᏛᎦ, ᎠᎴ ᎾᏍᏉ ᎠᏂ ᎣᏤᎲᎢ ᎥᏝ ᏴᎬᏂᎷᎩ ᎾᎿ ᏅᏓᏳᏂᎶᎯᏍᏗᏱ ᏳᎾᏚᎵᎭ.


text:
ᎤᎬᏫᏳᎯᏃ ᎯᎠ ᏄᏪᏎᎢ, ᎢᏳᏃ ᎠᏥᎸ-ᎤᎦᏔ ᏥᏂᎬ ᎢᎩᏛ ᎪᎯᏛ ᎪᎯᏳᏗ ᎨᏒ ᏱᏥᎭ, ᎯᎠ ᏱᏂᏥᏪᏏ ᎯᎠ ᎫᏩ-ᏧᏁᎬ ᏥᏡᎦ, ᏫᏕᏣᎾᏍᏕᏢᏓ, ᎠᎴ ᎠᎺᏉᎯ ᏪᏣᎧᎲᎦ, ᎠᎴ ᏱᏦᎯᏳᎲᎦ.


text:
ᏝᏍᎪ ᎯᎠ ᏱᎬᏩᎬᏫᏳ ᏱᏅᎦᏰᏥᏪᏏ, ᎭᏛᏅᎢᏍᏓ ᎠᏆᎵᏍᏓᏴᏗᏱ, ᎠᎴ ᎭᏓᏠᎦ, ᎠᎴ ᏍᎩᏍᏕᎸᎯᏓ ᎦᎵᏍᏓᏴᎲᏍᎬ ᎠᎴ ᎦᏗᏔᏍᎬ ᎢᎬᎯᏛ; ᎣᏂᏃ ᏨᏒ ᎭᎵᏍᏓᏴᏅᎭ ᎠᎴ ᎭᏗᏔᎲᎭ?


text:
ᎾᏍᎩᏯᏰᏃ ᎠᎾᎦᎵᏍᎩ ᏌᏉ ᎢᏗᏢ ᎦᎸᎶᎢ ᏨᏗᎦᎵᏍᎪᎢ, ᎤᏣᏘᏂᏃ ᎢᏗᏢ ᎦᎸᎶᎢ ᏥᏫᏗᎦᎵᏍᎪᎢ, ᎤᏣᏘᏂᏃ ᎢᏗᏢ ᎦᎸᎶᎢ ᏥᏫᏗᎦᎸᏌᏓᏗᏍᎪᎢ; ᎾᏍᎩ ᎾᏍᏉ ᏄᏍᏕᏍᏗ ᏴᏫ ᎤᏪᏥ ᎤᏤᎵ ᎢᎦ ᎠᎵᏱᎶᎸᎭ.


text:
ᎠᏆᎵᏏ ᎤᎴᏁ ᎤᏩᏒ ᎨᏒᎢ ᎤᏓᏙᎵᏍᏔᏁ ᎯᎠ ᏄᏪᏎᎢ; ᏣᏁᎳᏅᎯ ᎬᏯᎵᎡᎵᏤᎭ ᎠᏂᏐᎢ ᏴᏫ ᏄᎾᏍᏛᎢ ᎾᏍᎩ ᎾᏆᏍᏛᎾ ᏥᎩ, ᎾᏍᎩ ᎠᏎᏉ ᎠᎾᏓᎩᎡᎯ ᏥᎩ, ᎠᎴ ᏂᏚᏳᎪᏛᎾ ᎢᏯᎾᏛᏁᎯ, ᎠᎴ ᏗᎾᏓᏲᏁᎯ, ᎠᎴ ᎾᏍᏉ ᎯᎠ ᎠᏕᎸ--ᎠᎩᏏᏙᎯ ᎾᏍᎩ ᏄᏍᏛ ᎾᏆᏍᏛᎾ ᏥᎩ.


text:
ᎢᏨᏲᏎᎭ, ᎯᎠ ᎾᏍᎩ ᎠᏍᎦᏯ ᎤᏚᏓᎴᏛ ᏧᏪᏅᏒ ᏭᎶᏎᎢ, ᏐᎢᏃ ᎥᏝ. ᎩᎶᏰᏃ ᎤᏩᏒ ᎢᎠᏓᏌᎳᏗᏍᎨᏍᏗ ᎡᎳᏗ ᎢᏯᎬᏁᏗ ᎨᏎᏍᏗ, ᎩᎶᏃ ᎤᏩ-Ꮢ ᎡᎳᏗ ᏂᎠᏓᏛᏁᎮᏍᏗ ᎠᏥᏌᎳᏙᏗ ᎨᏎᏍᏗ.


text:
ᏥᏌᏃ ᎾᏍᎩ ᎯᎠ ᎤᏛᎦᏅ, ᎯᎠ ᏄᏪᏎᎴᎢ, ᎠᏏ ᏑᏓᎴᎩ ᏣᎷᎳ; ᎯᎾᏚᎦ ᏂᎦᏛ ᏣᎾᎥᎢ, ᎠᎴ ᏘᏯᏙᎯᏏ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ, ᎦᎸᎳᏗᏃ ᏫᏣᎮᏍᏗ ᏧᎬᏩᎶᏗ; ᏖᏒᏃ ᏍᎩᏍᏓᏩᏕᏒᎭ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ, ᎥᏝ ᎩᎶ ᏧᏮᏕᏨᎯ ᏱᎩ ᎦᏁᎸᎢ, ᎠᎴ ᏧᎦᏴᎵᎨᎢ, ᎠᎴ ᎠᎾᎵᏅᏟ, ᎠᎴ ᎤᏓᎵᎢ, ᎠᎴ ᏧᏪᏥ, ᏅᏓᏳᎵᏍᏙᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒᎢ,


text:
ᎿᏉᏃ ᏔᎳᏚ ᎢᏯᏂᏛ ᎢᏴᏛ ᏫᏚᏘᏅᏍᏔᏁᎢ, ᎠᎴ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎬᏂᏳᏉ ᏥᎷᏏᎵᎻ ᏫᏗᎦᏘ, ᎠᎴ ᏂᎦᎥ ᏚᏃᏪᎸ ᎠᎾᏙᎴᎰᏍᎩ ᏴᏫ ᎤᏪᏥ ᎠᏥᏃᎮᏍᎬ ᎾᏍᎩ ᎢᏳᎵᏍᏙᏗ ᎨᏎᏍᏗ.


text:
ᏌᎩᏯᏃ ᎤᎴᏁ ᎯᎠ ᏄᏪᏎᎴ ᎤᎬᏫᏳᎯ, ᎬᏂᏳᏉ, ᏣᎬᏫᏳᎯ, ᎠᏰᎵ ᎢᎦᎢ ᏧᎬᏩᎶᏗ ᎠᎩᎲ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ ᏕᏥᎥᏏ; ᎢᏳ ᎠᎴ ᎦᏰᎪᎩ ᎠᏋᏔᏅᎯ ᏱᎩ ᎩᎶ ᎪᎱᏍᏗ ᏱᏥᎬᎡᎸ, ᏅᎩ ᎢᏳᏩᎫᏗ ᎢᎦᎢ ᏥᎥᏏ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᎤᎾᏛᎦᏅ ᎤᏁᏉᎡᏚᏟᎶᏍᏓᏁᎴᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏥᎷᏏᎵᎻ ᎾᎥ ᎤᎷᏥᏗᏒᎢ, ᎠᎴ ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎢᎬᏪᏅᏛ ᏓᎦᎾᏄᎪᏥ ᎠᏁᎵᏍᎬᎢ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎢᎤᎷᏥᎸ, ᎤᎬᏫᏳᎯ ᎢᏯᎬᏁᎸᎯ ᎨᏎᎢ, ᎤᏁᏤ ᎾᏍᎩ ᎨᏥᏅᏏᏓᏍᏗ ᏫᎨᏥᏯᏅᏗᏱ ᎬᏩᎷᏤᏗᏱ, ᎾᏍᎩ Ꮎ ᎠᏕᎸ ᏧᎨᏅᏛᎯ, ᎾᏍᎩ ᎤᏙᎴᎰᎯᏍᏗᏱ ᎢᎦᎢ ᎠᏂᏏᏴᏫ ᎤᏂᏁᏉᏤᎸ ᎠᏂᏃᏗᏍᎬᎢ.


text:
ᎯᎠᏃ ᏄᏪᏎᎴᎢ, ᏨᏒ ᏂᏣᏪᏒ ᏓᎬᏔᏂ ᏙᏓᎬᏳᎪᏓᏁᎵ ᏣᏲ ᎡᏣᏅᏏᏓᏍᏗ. ᎯᎦᏔᎲᎩ ᏥᏍᏓᏱᏳ ᎨᏒᎢ, ᏥᎩᏍᎬ ᎾᏍᎩ ᎠᎩᏅᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᎴ ᏥᏍᎫᏕᏍᎬ ᎾᏍᎩ ᎠᎩᏫᏒᎯ ᏂᎨᏒᎾ ᎨᏒᎢ;


text:
ᎯᎠ ᏄᏪᏎᎢ, ᎢᏍᏕᎾ ᎢᏢ ᎾᏨᏗᎦᏚᎭ, ᎾᎿᏃ ᏫᏍᏗᎷᏨᎭ ᏓᏰᏍᏗᏩᏛᎯ ᎠᎩᎾ ᎨᎵᏌᏕᏍᏗ, ᎾᏍᎩ ᎥᏝ ᎠᏏ ᎩᎶ ᎤᎩᎸᏔᏅᎯ ᏱᎩ; ᎡᏍᏕᎵᏌᏕᏒᎭ ᎠᎴ ᏣᏍᏓᏘᏁᏒᎭ.


text:
ᎾᎥᏃ ᏭᎷᏨ, ᎾᎿ ᎠᎦᏐᎠᏍᎬ ᎢᏴᏛ ᎣᎵᏩᏲ ᎤᏌᎯᎸᎢ, ᏂᎦᏛ ᎤᏂᏥᏘ ᎨᏒ ᎠᎾᏓᏍᏓᏩᏗᏙᎯ ᎤᎾᎴᏅᎮ ᎠᎾᎵᎮᎵᎨ ᎠᎴ ᎠᏂᎸᏉᏗᏍᎨ ᎤᏁᎳᏅᎯ ᎠᏍᏓᏯ ᎠᏂᏁᎨᎢ. ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏂᎦᏛ ᎤᏍᏆᏂᎪᏗ ᏕᎦᎸᏫᏍᏓᏁᎸ ᎤᏂᎪᎲᎢ;


text:
ᎠᎴ ᎦᏙᎯ ᏓᎨᏣᏡᏂ, ᎠᎴ ᏗᏤᏥ ᎬᏂᏯᎢ ᎨᏎᏍᏗ; ᎠᎴ ᎥᏝ ᎨᏣᎯᏰᏗ ᏱᎨᏎᏍᏗ ᏌᏉ ᏅᏯ ᏱᏚᏓᏌᏝᎮᏍᏗ; ᏅᏗᎦᎵᏍᏙᏗᎭ ᏂᎦᏔᎲᎾ ᏥᎨᏒ ᎢᏳ ᎡᏣᏩᏛᎯᎯᏍᏗ ᎨᏒᎢ.


text:
ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ ᏌᏉ ᎢᎦ ᎾᎯᏳ ᎨᏒ, ᏕᎨᏲᎲᏍᎨ ᏴᏫ ᎤᏛᎾᏗᎦᎳᏫᎢᏍᏗᏱ, ᎣᏍᏛ ᎧᏃᎮᏛ ᎠᎵᏥᏙᎲᏍᎨᎢ, ᎾᏍᎩ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸᎠᏁᎶᎯ, ᎠᎴ ᏗᏃᏪᎵᏍᎩ ᎬᏩᏃᎴᎢ, ᎤᎾᎵᎪᏎ ᏗᏂᎳᏫᎩ,


text:
ᎾᎯᏳᏃ ᎤᏅᏂᏍᏗᏱ ᎨᏒ ᎤᏅᏏᏓᏍᏗ ᎤᏅᏎ ᏠᎨᏏ ᏧᏂᎸᏫᏍᏓᏁᎯ ᏗᎡᎲᎢ, ᎾᏍᎩ ᏂᏙᏓᎬᏩᏅᏁᏗᏱ ᎤᎾᏓᏛᏅᎯ ᏖᎸᎳᏗ ᏓᏫᏒᎢ; ᎠᏎᏃ ᏠᎨᏏ ᏧᏂᎸᏫᏍᏓᏁᎯ ᎤᏂᎵᎥᏂᎸ ᎠᏒᎭ ᎤᏂᎨᎯᏙᎴᎢ.


text:
ᎠᏎᏃ ᏠᎨᏏ ᏧᏂᎸᏫᏍᏓᏁᎯ ᎤᏂᎪᎲ, ᎤᏅᏒ ᎨᏒ ᎤᎾᎵᏃᎮᎴ ᎯᎠ ᏂᏚᎾᏓᏪᏎᎴᎢ, ᎯᎠ ᎾᏍᎩ ᎤᏘᏰᏗ ᏥᎩ ᏧᎬᏩᎶᏗ, Ꭷ, ᎡᏗᎷᎦ, ᎾᏍᎩᏃ ᏧᎬᏩᎶᏗ ᎤᏘᏯᏍᏓᏁᏗ ᎨᏒ ᎢᎦᏤᎵ ᏱᏂᎦᎵᏍᏓ.


text:
ᎬᏩᏛᏛᏁᏃ ᎯᎠ ᏄᏂᏪᏎᎢ, ᏔᏕᏲᎲᏍᎩ, ᎣᏥᎦᏔᎭ ᎯᏬᏂᏍᎬ ᎠᎴ ᏕᎭᏕᏲᎲᏍᎬ ᏚᏳᎪᏛ ᎨᏎᎢ, ᎠᎴ ᏂᏘᎸᏉᏙᏛᎾ ᎨᏒ ᏄᎾᏍᏛ ᏴᏫ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎤᏤᎵ ᎦᏅᏅ ᎤᏙᎯᏳᎯᏯ ᏕᎭᏕᏲᎲᏍᎬᎢ;


text:
ᎯᎠ ᏄᏂᏪᏎᎢ, ᏔᏕᏲᎲᏍᎩ, ᎼᏏ ᎣᎪᏪᏁᎸ-Ꭹ ᎯᎠ ᏃᎩᏪᏎᎸᎩ, ᎩᎶ ᏗᎾᏓᏅᏟ ᎠᏲᎱᏍᎨᏍᏗ ᎤᏓᎵᎢ ᎤᏪᎧᎮᏍᏗ, ᎠᎴ ᏧᏪᏥ ᎾᏁ-ᎲᎾ ᎠᏲᎱᏍᎨᏍᏗ, ᎾᏍᎩ ᏗᎾᏓᏅᏟ ᎠᏓᏰᎨᏍᏗ ᎤᏓᏴᏛ, ᎠᎴ ᏓᏛᎯᏍᏓᏁᎮᏍᏗ ᏧᏪᏥᏗᎾᏓ-ᏅᏟ.


text:
ᎥᏝ ᎠᎴ ᎿᏉ ᏗᎬᏩᏂᏲᎱᎯᏍᏗ ᏱᎨᏎᏍᏗ; ᏗᏂᎧᎿᏩᏗᏙᎯᏍᎩᏂ ᎦᎸᎳᏗ ᎠᏁᎯ ᏄᎾᏍᏛ ᎾᏍᎩᏯ ᏄᎾᏍᏕᏍᏗ; ᎠᎴ ᎤᏁᎳᏅᎯ ᏧᏪᏥ ᎾᏍᎩ, ᎠᏲᎱᏒ ᏗᎴᎯᏐᏗ ᎨᏒ ᏧᏪᏥ ᎨᏒ ᎢᏳᏍᏗ.


text:
ᎾᏃ ᏧᏂᏲᎱᏒᎯ ᏧᎾᎴᎯᏐᏗ ᎨᏒ, ᏱᏏ ᎬᏂᎨᏒ ᏄᏩᏁᎴ ᎤᏪᏲᏓᏛᎢ, ᎾᎯᏳ ᏱᎰᏩ ᎤᏁᎳᏅᎯ ᎡᏆᎭᎻ ᎤᏤᎵᎦ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎡᏏᎩ ᎤᏤᎵᎦ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏤᎦᏈ ᎤᏤᎵᎦ, ᏧᏬᏎᎴᎢ.


text:
ᏕᏯᏙᏤᎮᏍᏗ ᏗᏃᏪᎵᏍᎩ, ᎾᏍᎩ ᏧᎾᏚᎵᏍᎪ ᏗᎦᏅᎯᏛ ᏧᎾᏄᏩᎢ ᎤᏁᏓᏍᏗᏱ, ᎠᎴ ᎣᏏᏳ ᏧᏂᏰᎸᎭ ᎨᏥᏲᎵᏍᏗᏱ ᏗᎦᏃᏙᏗᏱ, ᎠᎴ ᏄᎬᏫᏳᏒ ᏕᎦᏍᏗᎸ ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᏄᎬᏫᏳᏒ ᏗᎾᏢᏗᏱ ᏓᎾᎵᏍᏓᏴᎲᏍᎬᎢ;


text:
ᎯᎠᏃ ᏄᏪᏎᎢ, ᎢᏤᏯᏔᎮᏍᏗ ᏞᏍᏗ ᏥᎡᏥᎶᎾᏍᏔᏂ; ᎤᏂ-ᏣᏖᏍᏗᏰᏃ ᎠᏴ ᏓᏆᏙᎥ ᎠᏂᎷᎯᏍᏗᏍᎨᏍᏗ, ᎠᏴ ᎦᎶᏁᏛ]</n> ᎠᎾᏗᏍᎨᏍᏗ, ᎠᎴ ᎿᏉ ᎤᏍᏆᎸᎯᏗ; ᎾᏍᎩ ᎢᏳᏍᏗ ᏞᏍᏗ ᏗᏥ-ᏍᏓᏩᏛᏒᎩ.


text:
ᎠᏎᏃ ᎢᏣᏛᎩᏍᎨᏍᏗ ᏓᏅᏩ ᎠᎴ ᏧᏓᎴᏅᏛ ᏂᎦᎵᏍᏔᏂᏙᎲᎢ, ᏞᏍᏗ ᏱᏥᏍᎦ-ᎢᎮᏍᏗ; ᎯᎠᏰᏃ ᎾᏍᎩ ᎠᏎ ᎢᎬᏱ ᎢᏳ-ᎵᏍᏙᏗ, ᎥᏝᏍᎩᏂ ᎢᎬᏪᏅᏛᏉ ᎤᎵᏍᏆᏗᏍᏗ ᏱᎨᏎᏍᏗ.


text:
ᎠᏎᏃ ᎠᏏ ᎾᏍᎩ ᎯᎠ ᏂᎦᏛ ᏄᎵᏍᏔᏅᎾ ᎨᏎᏍᏗ ᏙᏓᎨᏥᏂᏴᎯ ᎠᎴ ᎤᏲᏅᏓᎨᏨᏁᎵ, ᏕᎨᏥᏲ-ᏍᎨᏍᏗ ᏧᏂᎳᏫᎢ-ᏍᏗᏱ, ᎠᎴ ᏗᏓᏍᏚᏗᏱ, ᎠᎴ ᏕᏣᏗᏃᎯᎮᏍᏗ ᎤᏂᎬᏫᏳᎯ ᎠᎴ ᏄᏂᎬᏫᏳᏌᏕᎩ ᏚᏃᎸ ᎢᎬᏱᏗᏢ ᎠᏴ ᏓᏆᏙᎥ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ.


text:
ᏗᏂᏁᎵᏛᏍᎩᏂ ᎠᎴ ᏧᏂᏍᏓᎢ ᎤᏲᎢᏳ ᎢᏳ-ᎾᎵᏍᏓᏁᏗ ᎨᏎᏍᏗ ᎾᎯᏳ ᎨᏒᎢ! ᎤᏣᏘᏰᏃ ᎠᎩᎵᏯ ᎡᎮᏍᏗ ᎠᏂ ᎦᏙᎯ, ᎠᎴ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏂᎷᏤᏗ ᎨᏎᏍᏗ ᎯᎠ ᏴᏫ.


text:
ᎠᏰᎳᏍᏗᏃ-ᎦᏅᎯᏛ ᏧᏂᏅᎢᏍᏙᏗ ᎨᏎᏍᏗ, ᎠᎴ ᏗᎨᏥᏴᎩᏅᎯ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒ ᏫᏗᎨᎦᏘᏅᏍᏛᏗ ᎨᏎᏍᏗ; ᏥᎷᏏᎵᎻᏃ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᎾᎳᏍᏓᎡᏗ ᎨᏎᏍᏗ, ᎬᏂ ᎠᏍᏆᏛᎭ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎨᎦᏓᏁᎳᏁᎸᎯ ᎨᏒᎢ.


text:
ᎤᏰᎸᏛᏃ ᎠᎪ-ᏩᏛᏗ ᎨᏎᏍᏗ ᏅᏙ ᎢᎦ ᎡᎯ ᎧᎸᎢ, ᎠᎴ ᏅᏙ ᏒᏃᏱ ᎡᎯ ᎧᎸᎢ, ᎠᎴ ᏃᏈᏏ ᎠᏂᎧᎸᎢ; ᎠᎴ ᎡᎶᎯ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏁᎲ ᎤᏪᎵᎯᏍᏗ, ᎠᎴ ᎤᏕᏯᏙᏗ ᏅᏓᏳᎾᎵᏍᏓᏁᎵ; ᎠᎺᏉᎯ ᎠᎴ ᎠᎹ ᏓᎵᏍᏗᎳᏁᎬ ᎤᏍᏆᏃᏴᎨᏍᏗ;


text:
ᎠᎴ ᎢᏣᏓᎦᏌᏯᏍᏕᏍᏗ ᎢᏨᏒ ᎨᏒᎢ, ᏞᏍᏗ ᎢᎸᎯᏳ ᏕᏣᏓᏅᏛ ᎦᎨᏛ ᏱᏂᏣᎵᏍᏓᏁᎮᏍᏗ ᏱᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎢᏥᎶᏒᏍᏗᏍᎬ ᎢᏣᎵᏍᏓᏴᎲᏍᎬᎢ, ᎠᎴ ᏕᏥᏴᏍᏕᏍᎬᎢ, ᎠᎴ ᎡᎶᎯ ᎠᏓᏅᏖᏗ ᎨᏒᎢ, ᎾᏍᎩᏃ ᎾᎯᏳ ᎢᎦ ᏂᏤᎵᏍᎬᎾ ᎢᏥᎷᏤᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏥᏯᏫᏍᎨᏍᏗ ᏂᎪᎯᎸᎢ, ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ, ᎾᏍ-ᎩᏃ ᏰᎵᏉ ᎯᎠ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᎤᎵᏰᎢᎶᎯᏍᏗ ᏥᎩ ᎬᏩᎾᏗᏫᏎᏗ, ᎠᎴ ᏴᏫ ᎤᏪᏤ ᎤᏬᎸ ᎢᎬᏱᏗᏢ ᎬᏩᎾᎴᏗ ᎦᏰᏤᎵᏎᏗ ᏱᏂᎦᎵᏍᏓ


text:
ᎦᏚᏃ ᎤᎩᏎᎢ, ᎠᎴ ᎤᎵᎮᏟᏨ, ᎤᎬᎭᎷᏰᎢ, ᎠᎴ ᏚᏁᎴᎢ, ᎯᎠ ᏄᏪᏎᎢ, ᎯᎠ ᎾᏍᎩ ᎠᏴ ᏥᏰᎸᎢ, ᎾᏍᎩ ᏂᎯ ᎡᏣᎫᏴᏔᏅᎯ ᏥᎩ, ᎯᎠ ᎾᏍᎩ ᏂᏣᏛᏁᎮᏍᏗ ᎠᏴ ᏍᎩᏯᏅᏓᏗᏍᎨᏍᏗ.


text:
ᏂᎯᏍᎩᏂ ᎥᏞᏍᏗ ᎾᏍᎩ ᏱᏂᏨᏁᏍᏗ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᏂᎯ ᏂᏣᏛᏅ ᎤᏟ ᎢᏯᏥᎸᏉᏗ; ᎾᏍᎩ ᎠᏫᎾᎨ ᎾᏍᎩᏯ ᎨᏎᏍᏗ; ᎾᏍᎩᏯ Ꮎ ᏄᎬᏫᏳᏌᏕᎩ ᏗᏍᏕᎸᎯᏙᎯ ᎾᏍᎩᏯ ᎨᏎᏍᏗ.


text:
ᎿᏉᏃ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎪᎯᏍᎩᏂ ᏥᎩ, ᎩᎶ ᎠᏕᎸ-ᏗᎦᎶᏗ ᎤᎾᎡᏍᏗ, ᎦᏁᎨᏍᏗ, ᎠᎴ ᎾᏍᏉ ᏕᎦᎶᏗ; ᎩᎶᏃ ᎠᏰᎳᏍᏗ ᎦᏅᎯᏛ ᏄᏩᏴᎾ ᎨᏎᏍᏗ, ᏫᎦᎾᏚᎦ ᎤᏄᏬ ᎠᎴ ᏭᏩᎯ.


text:
ᎢᏨᏲᏎᎭᏰᏃ, ᎯᎠ ᎾᏍᎩ ᏥᎪᏪᎳ ᎠᏎ ᎠᏏ ᏛᏙᎯᏳᏂ ᎠᏴ ᏅᏓᎬᏂᏌᏂ; "ᎠᎴ ᎠᏂᏍᎦᎾ ᎨᎦᏎᎸᎢ ᎾᏍᎩ ᎠᎦᏠᏯᏍᏔᏅᎩ;" ᎠᏴᏰᏃ ᎠᎩᏃᎮᏍᎬ ᎠᏎ ᎾᏍᎩ ᏅᏓᎦᎵᏍᏔᏂ.


text:
ᎿᏉᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ, ᎠᎴ ᎣᏍᏛ ᎢᏳᏅᎿᏕᎩ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᏗᏂᎳᏫᎩ, ᎾᏍᎩ ᎬᏩᏂᏴᎯᎸᎯ, ᎢᏥᎷᎩᏍᎪ ᎠᏓᎾᏌᎲᏍᎩ ᏤᏥᏲᎰ ᎾᏍᎩᏯᎢ, ᎠᏰᎳᏍᏗ-ᏗᎦᏅᎯᏛ ᎠᎴ ᎠᏓ ᏥᏕᏥᏁᎭ?


text:
ᎢᎦᏉᏃ ᏄᎵᏍᏔᏅ ᏗᏂᎳᏫᎩ ᏴᏫ ᎠᏁᎲ ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸᎠᏁᎶᎯ ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸᎠᏁᎶᎯ ᎠᎴ ᏗᏃᏪᎵᏍᎩ ᏚᏂᎳᏫᏤᎢ, ᎠᎴ ᏓᏂᎳᏫᎥ ᎬᏩᏘᏃᎴ ᎯᎠ ᏄᏂᏪᏎᎢ;


text:
ᎠᎴ ᎤᎾᎴᏅᎮ ᎬᏭᎯᏍᏗᏍᎨ ᎯᎠ ᎾᏂᏪᏍᎨᎢ, ᎯᎠ ᎾᏍᎩ ᏙᏥᏩᏛᎲᎩ ᏕᏂᏪᏍᎨᎢ, ᎯᎠ ᎾᏍᎩ ᏙᏥᏩᏛᎲᎩ ᏕᏓᎴᎾᏍᏗᏍᎬᎩ ᏴᏫ, ᎠᎴ ᏕᎧᏅᎡᏗᏱ, ᎯᎠ ᏂᎧᏪᏍᎬᎩ, ᎠᏴ ᎠᎩᎬᏫᏳᎯ, ᎦᎶᏁᏛ.


text:
ᎡᎶᏛᏃ ᎤᎪᎲ ᏥᏌ, ᎤᏣᏘ ᎣᏎ ᎤᏰᎸᏁᎢ; ᎪᎯᏗᏳᏰᏃ ᏅᏩᏚᎵᏍᎨ ᎤᎪᏩᏛᏗᏱ, ᏅᏗᎦᎵᏍᏗᏙᏗᏍᎨ ᎤᏣᏘ ᏧᏓᎴᏅᏛ ᎠᏥᏃᎮᏍᎬ ᎤᏛᎦᏅᎢ, ᎠᎴ ᎤᏚᎩ ᎤᏩᏎ ᎤᎪᏩᏛᏗᏱ ᎪᎱᏍᏗ ᎤᏍᏆᏂᎪᏗ ᏚᎸᏫᏍᏓᏁᎲᎢ.


text:
ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᏍᎩᏯᏘᏃᎮᎸ ᎯᎠ ᎠᏍᎦᏯ ᏴᏫ ᏚᎾᏓᏅᏛ ᏗᎴᎾᏍᏗᏍᎩ ᎾᏍᎩᏯᎢ; ᎬᏂᏳᏉᏃ ᏥᎪᎵᏰᎥᎯ ᏥᎩ ᎢᏥᎦᏔᎲᎢ, ᎥᏝ ᎪᎱᏍᏗ ᏱᏥᏩᏘ ᎤᏍᎦᏅᏨ ᎯᎠ ᎠᏍᎦᏯ ᎾᏍᎩ ᏄᏍᏛ ᎡᏧᎢᏍᏗᏍᎬᎢ;


text:
ᏴᏫᏃ ᎤᎾᎴᎾᏫᏍᏕ ᏚᎾᎦᏙᏍᏕᎢ. ᏄᏂᎬᏫᏳᏌᏕᎩᏃ ᎾᏍᏉ ᏚᎾᎵᎪᏁᎴ ᎢᎬᏩᏕᎨᏔᏁᎢ, ᎯᎠ ᎾᏂᏪᏍᎨᎢ, ᎠᏂᏐᎢ ᏓᏍᏕᎵᏍᎬᎩ; ᎤᏩᏒ ᏩᎵᏍᏕᎸ ᎢᏳᏃ ᎦᎶᏁᏛ ᎤᏁᎳᏅᎯ ᎤᏑᏰᏛ ᎨᏎᏍᏗ.


text:
ᎠᎴ ᎾᏍᏉ ᎪᏪᎴ ᎤᎵᏍᏓᏛ ᎦᎸᎳᏗᏢ ᎠᏂᎪᎢ ᎤᏂᏬᏂᎯᏍᏗ, ᎠᎴ ᎠᏂᎶᎻ ᎤᏂᏬᏂᎯᏍᏗ, ᎠᎴ ᎠᏂᏈᎷ ᎤᏂᏬᏂᎯᏍᏗ ᎪᏪᎴ ᎯᎠ ᏂᎬᏁᎢ; ᎯᎠ ᎤᎬᏫᏳᎯ ᎠᏂᏧᏏ ᎤᎾᏤᎵᎦ.


text:
(ᎾᏍᎩ ᎥᏝ ᎣᏏᏳ ᏳᏰᎸᏁ ᎾᏍᎩ ᏄᏍᏛ ᏚᏄᎪᏔᏅ ᎠᎴ ᏄᎾᏛᏁᎸᎢ,) ᎠᎵᎹᏗᏱ ᎡᎯ ᎨᏎᎢ, ᎾᏍᎩ ᎠᏂᏧᏏ ᎤᏂᏚᎲᎢ, ᎾᏍᎩ ᎾᏍᏉ ᎠᎦᏘᏰ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒᎢ,--


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎦᏙ ᎤᏍᏗ? ᎯᎠᏃ ᏂᎬᏩᏪᏎᎴᎢ, ᏥᏌ ᎾᏎᎵᏗ ᏤᎲᎩ ᏄᎵᏍᏓᏁᎸᎢ, ᎾᏍᎩ ᎠᏙᎴᎰᏍᎩ ᏥᎨᏒᎩ, ᎤᎵᏂᎩᏛ ᏚᎸᏫᏍᏓᏁᎸ ᎠᎴ ᏓᏕᏲᎲᏍᎬ ᏥᎨᏎ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲ ᎠᎴ ᏂᎦᏛ ᏴᏫ ᎠᏂᎦᏔᎲᎢ.


text:
ᏗᏣᎧᏅᎦ ᏗᏉᏰᏂ ᎠᎴ ᏗᏆᎳᏏᏕᏂ, ᎠᏋᏒᏉ ᎯᎠ ᏥᎾᏆᏛᏅ; ᏍᎩᏯᏒᏂᎦ ᎠᎴ ᎢᏣᏙᎴᎰᎯ; ᎠᏓᏅᏙᏰᏃ ᎥᏝ ᏳᏇᏓᎳ, ᎠᎴ ᎥᏝ ᏧᎪᎳ ᏱᏚᎸ ᎾᏍᎩᏯ ᏥᏥᎪᏩᏘᎭ ᎠᏴ ᏂᏓᏋᏅᎢ.


text:
ᎯᎠᏃ ᏂᏚᏪᏎᎴᎢ, ᎯᎠ ᎾᏍᎩ ᏥᏂᏨᏪᏎᎸᎩ, ᎠᏏᏉ ᏥᏨᏰᎳᏗᏙᎲᎩ, ᎾᏍᎩ ᏂᎦᎥ ᎾᏍᎩ ᎠᏎ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ ᎪᏪᎳᏅᎯ ᎨᏒ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎼᏏ ᎤᏤᎵᎦ, ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ ᏚᏃᏪᎸᎢ, ᎠᎴ ᏗᎧᏃᎩᏍᏗᏱ, ᎠᏴ ᎬᎩᏃᎮᏍᎬᎢ.


text:
ᎠᎴ ᎧᏃᎮᏛ ᎤᏇᏓᎵ ᏄᎵᏍᏔᏅᎩ, ᎠᎴ ᎢᏕᎲ ᎤᎴᏂᏙᎸᎩ, ᎤᎧᎵᏨᎯ ᎨᏒᎩ ᎤᏓᏙᎵᏣᏛ ᎠᎴ ᏚᏳᎪᏛᎢ; ᎠᎴ ᎢᏗᎪᏩᏘᏍᎬᎩ ᎤᏤᎵᎦ ᎦᎸᏉᏗᏳ ᎨᏒᎢ, ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎨᏒ ᎠᎦᏴᎵᎨ ᎤᏩᏒᎯᏳ ᎤᏕᏁᎸᎯ ᎤᏤᎵᎦ ᎾᏍᎩᏯ ᎨᏒᎩ.


text:
ᏣᏂ ᎧᏃᎮᏍᎬᎩ ᎾᏍᎩ <n>[ᎧᏃᎮᏛ,]</n> ᎠᎴ ᎤᏪᎷᏅᎩ ᎯᎠ ᏄᏪᏒᎩ; ᎯᎠ ᎾᏍᎩ ᏥᏥᏃᎮᏍᎬᎩ, ᎯᎠ ᏥᏂᏥᏪᏍᎬᎩ, ᎣᏂ ᏨᏓᏯᎢ ᎢᎬᏱ ᎠᎦᎴᏗ, ᎾᏍᎩᏰᏃ ᎡᎲᎩ ᎠᏏ ᏂᎨᎥᎾ ᏥᎨᏒᎩ.


text:
ᎠᎴ ᎠᏴᎥᏝ ᏱᏥᎦᏔᎮᎢ; ᎠᏎᏃ ᎾᏍᎩ ᎾᏅᏛᎩᏅᏏᏛ ᎠᎹ ᏗᏆᏓᏬᏍᏙᏗᏱ ᎾᏍᎩ ᎯᎠ ᎾᎩᏪᏎᎸᎩ; ᎩᎶ ᎯᎪᎥᎭ ᎠᏓᏅᏙ ᎠᏁᏡᎲᏍᎬᎢ ᏚᎩᎸᏨᎭ, ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏗᏓᏬᏍᏗᏍᎩ.


text:
ᏈᎵᏃ ᎤᏩᏛᎲᎩ ᏁᏓᏂᎵ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎤᏥᏩᏛᎲ ᎾᏍᎩ ᎼᏏ ᎫᏬᏪᎳ ᏥᎧᏃᎮᎭ ᏗᎧᎿᏩᏛᏍᏗ ᎪᏪᎵᎯ, ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ ᏣᏂᏃᎮᎭ, ᎾᏍᎩ ᏥᏌ ᎾᏎᎵᏗ ᎡᎯ ᏦᏩ ᎤᏪᏥ.


text:
ᏁᏓᏂᎵᎯᎠ ᏄᏪᏎᎸᎩ; ᎦᏙ ᏗᎦᎵᏍᏙᏗ ᎢᏍᎩᎦᏔᎭ? ᏥᏌ ᎤᏁᏨ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎠᏏᏉ ᏈᎵᎩ ᏫᏂᏣᏯᏂᏍᎬᎾ ᏥᎨᏒᎩ, ᎡᎦᏔ-ᎢᏳᏍᏗ ᏡᎬᎢ ᎭᏫᏂᏗᏢ ᏥᏦᎸᎩ, ᏫᎬᎪᎥᎩ.


text:
ᏥᏌ ᎤᏁᏨ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏥᎪᎯᎠ ᏥᏂᎬᏪᏏ, ᎬᎪᎥᎩ ᎭᏫᏂᏗᏢ ᏒᎦᏔ-ᎢᏳᏍᏗ ᏡᎬᎢ, ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎰᎯᏳᎲᏍᎦ? ᎤᏟ ᎢᏳᏍᏆᏂᎪᏗ ᎯᎪᏩᏘᏍᎨᏍᏗ, ᎡᏍᎦᏉ ᎾᏍᎩ.


text:
ᎠᎴᏬ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯᏩ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᎢᏥᎪᏩᏘᏍᎨᏍᏗ ᎦᎸᎳᏗ ᎤᎵᏍᏚᎢᏛ ᎨᏎᏍᏗ, ᎠᎴ ᏕᏥᎪᏩᏘᏍᎨᏍᏗ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ ᎠᎾᎵᏌᎳᏗᏍᎨᏍᏗ ᎠᎴ ᎡᎳᏗ ᎾᎾᏛᏁᎮᏍᏗ ᎬᏩᎷᏤᎮᏍᏗ ᏴᏫ ᎤᏪᏥ.


text:
ᎤᎬᏫᏳᏌᏕᎩ ᎤᏚᎩᏒ ᎠᎹ ᎩᎦᎨᎠᏗᏔᏍᏗ ᎢᏳᎵᏍᏔᏅᎯ, ᎠᎴ ᎾᎦᏔᎲᎾ ᎨᏎ ᏧᎶᏒᎢ, ᎨᏥᏅᏏᏓᏍᏗᏍᎩᏂ ᎠᎹ ᎤᏂᏢᏛ ᎠᏂᎦᏔᎲᎩ, ᎤᎬᏫᏳᏌᏕᎩ ᏭᏯᏅᎲᎩ ᎠᏍᎦᏯ ᏣᎦᏨᏍᏗᏍᎩ,


text:
ᎠᎴ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎾᏂᎥ ᏴᏫ ᎠᎾᎴᏅᏗᏍᎪ ᎠᏂᏝᎲᏍᎪ ᎣᏌᏂ ᎩᎦᎨᎠᏗᏔᏍᏗ, ᎿᏉᏃ ᎤᏣᏘ ᎤᎾᏗᏔᎲᎯ ᏥᎨᏐᎢ ᎩᎳ ᎤᏐᏅ ᎠᏂᏝᎲᏍᎪᎢ; ᏂᎯᏍᎩᏂ ᏣᏍᏆᏂᎪᏕ ᎣᏍᏛ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎪᎯ ᎢᏯᏍᏗ.


text:
ᎦᏩᏍᏛᏂᏍᏗᏃ ᎤᏪᏢᏅ, ᏂᎦᏛ ᎤᏛᎾ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᏚᏄᎪᏫᏒᎩ, ᎠᎴ ᎾᏍᏉ ᎠᏫ, ᎠᎴ ᏩᎩ; ᏚᏤᏮᎩᏃ ᎠᏕᎸ ᏚᏂᎲ ᎠᏕᎸ ᏗᏂᏁᏟᏴᏍᎩ, ᎠᎴ ᏚᎷᏆᏗᏅᏒᎩ ᏕᎦᏍᎩᎸᎢ.


text:
ᎾᏍᎩ ᏥᏌ ᎤᎷᏤᎸᎩ ᏒᏃᏱ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏗᏍᏇᏲᎲᏍᎩ, ᎣᏥᎦᏔᎭ ᏔᏕᏲᎲᏍᎩ ᎨᏒ ᎤᏁᎳᏅᎯ ᏅᏓᏣᏅᏏᏛ ᎨᏒᎢ: ᎥᏝᏰᏃ ᎩᎶ ᎾᏍᎩ ᎯᎠ ᎤᏍᏆᏂᎪᏗ ᏥᏕᏣᎸᏫᏍᏓᏁᎭ ᏱᏙᎬᏩᎸᏫᏍᏓᏏ, ᎤᏁᎳᏅᎯ ᏂᏚᎧᎿᏩᏗᏙᎲᎾᏱᎩ.


text:
ᎤᏃᎴ ᎤᏚᎵᏍᏛᏉ ᎢᏘᏢ ᏫᎦᏃᎸᏗᏍᎪᎢ, ᎠᎴ ᎤᏃᏴᎬ ᎭᏛᎩᏍᎪᎢ, ᎠᏎᏃ ᎥᏝ ᏱᎦᏔᎰ ᏗᎦᏛᎢ ᎠᎴ ᏩᎦᏛᎢ; ᎾᏍᎩᏯᏍᎩᏂ ᏄᏍᏗ ᎾᏂᎥ ᎩᎶ ᎾᏍᎩ ᎠᏓᏅᏙ ᏧᎾᏄᎪᏫᏒᎯ.


text:
ᎩᎶ ᎾᏍᎩ Ꮎ ᏥᎪᎯᏳᎲᏍᎪᎢ, ᎥᏝ ᎤᏍᎦᏅᏨᎯ ᏧᏚᎪᏔᏅᎯ ᏱᎨᏐᎢ, ᎾᏍᎩᏍᎩᏂ Ꮎ ᏂᎪᎯᏳᎲᏍᎬᎾ ᎾᏍᎩ ᎦᏳᎳ ᎤᏍᎦᏅᏨᎯ ᏧᏚᎪᏔᏅᎯ ᎨᏐᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᏄᏬᎯᏳᏅᎾ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᏕᎤᏙᎥ ᎾᏍᎩ ᎤᏩᏒᎯᏳ ᎤᏕᏁᎸᎯ.


text:
ᎠᎴ ᎾᏍᎩ ᎯᎠ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏂᏍᎦᏅᏨ ᏥᏚᎾᏚᎦᏓᏁᎭ, ᎾᏍᎩ ᎢᎦᎦᏘ ᎡᎶᎯ ᎤᎾᏄᎪᏥᎸ, ᎠᎴ ᏴᏫ ᎤᏟ ᎤᏂᏰᎸᏅ ᎤᎵᏏᎩ ᎡᏍᎦᏉ ᎢᎦᎦᏘ, ᏚᏂᎸᏫᏍᏓᏁᎲᏰᏃ ᎤᏲᎢᏳ ᎨᏒᎦᎴ ᎾᏍᎩ ᎯᎠ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏂᏍᎦᏅᏨ ᏥᏚᎾᏚᎦᏓᏁᎭ, ᎾᏍᎩ ᎢᎦᎦᏘ ᎡᎶᎯ ᎤᎾᏄᎪᏥᎸ, ᎠᎴ ᏴᏫ ᎤᏟ ᎤᏂᏰᎸᏅ ᎤᎵᏏᎩ ᎡᏍᎦᏉ ᎢᎦᎦᏘ, ᏚᏂᎸᏫᏍᏓᏁᎲᏰᏃ ᎤᏲᎢᏳ ᎨᏒᎩ.


text:
ᎤᏓᏴᏍᏗ ᎤᏪᎧᎯ ᎾᏍᎩ ᎠᏕᏒᎲᏍᎩ; ᎠᏎᏃ ᎠᏕᏒᎲᏍᎩ ᎤᎾᎵᎢ, ᎾᏍᎩ ᏥᎦᏙᎯ ᏧᏛᎦᏁᎰᎢ, ᎤᏣᎳᏅᎯ ᎠᎵᎮᎵᎪ ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᎠᏕᏒᎲᏍᎩ ᎧᏁᎬᎢ. ᎾᏍᎩᏍᎩᏂ ᎠᏴ ᎦᎵᎡᎵᎬ ᎤᎧᎵᏨ.


text:
ᎦᎸᎳᏗ ᏅᏓᏳᎶᏒᎯ ᎤᏟᎠᏥᎸᏉᏗᏳ ᎡᏍᎦᏉ ᎾᏂᎥᎢ. ᎡᎶᎯ ᎤᎾᏄᎪᏨᎯ ᎡᎶᎯᏉ ᎡᎯ ᎨᏐᎢ, ᎠᎴ ᎦᏬᏂᏍᎬ ᎡᎶᎯᏉ ᎡᎯ ᎨᏐᎢ, ᎦᎸᎳᏗᏍᎩᏂ ᏅᏓᏳᎶᏒᎯ ᎤᏟ ᎦᎸᏉᏗᏳ ᎡᏍᎦᏉ ᎾᏂᎥᎢ.


text:
ᎾᏍᎩ ᎾᎪᎯᏳᎲᏍᎩ <n>[ᎤᏁᎳᏅᎯ ᎤᏪᏥ, ᎾᏍᎩ ᎬᏂᏛ ᎠᎵᏍᏆᏗᏍᎩ ᏁᎨᏒᎾ ᎤᏤᎵᎦ, ᎾᏍᎩᏍᎩᏂ ᎤᏪᏥ ᎪᎯᏳᎲᏍᎩ ᏂᎨᏒᎾ ᎥᏝ ᎬᏂᏛ ᎤᎪᏩᏛᏗ ᏱᎩ; ᎤᏁᎳᏅᎯᏉᏍᎩᏂ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᎵᏃᎯᏰᎭ.


text:
ᎿᏉᏃ ᎾᏍᎩ ᎠᎨᏴ ᏌᎺᎵᏱ ᎡᎯ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎦᏙ ᏗᎦᎵᏍᏙᏗᎭ ᏂᎯ ᎯᏧᏏ ᎠᏗᏔᏍᏗ ᎢᏍᎩᏔᏲᏎᎭ ᏥᎨᏴ ᏌᎺᎵᏱ ᎨᎢ. (ᎠᏂᏧᏏᏰᏃ ᎠᎴ ᏌᎺᎵᏱ ᎠᏁᎯ ᎥᏝ ᏱᏚᎾᏓᎦᏌᏯᏍᏙᎢ.)


text:
ᏥᏌ ᎤᏁᏤᎢ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎢᏳᏃ ᏱᎯᎦᏔᎮ ᎤᏁᎳᏅᎯ ᎤᏓᏁᏗ ᏥᎩ, ᎠᎴ ᏱᎯᎦᏔᎮ ᎯᎠ ᎾᏍᎩ ᏥᏂᏣᏪᏎᎭ, ᎠᏆᏗᏔᏍᏗ ᏍᎩᏁᎲᏏ; ᏨᏒ ᏱᏔᏲᏎᎴᎢ, ᎠᎴ ᏱᏣᏁᏁᎴ ᎬᏂᏛ ᎠᎹ.


text:
ᎩᎶᏍᎩᏂ ᏳᏗᏔᎲ ᎾᏍᎩ ᎠᎹ ᎠᏴ ᏥᏁᏁᏗ ᏥᎩ ᎥᏝ ᎢᏳᎯᏳ ᎤᏔᏕᎪᏗ ᏱᎩ, ᎠᏴᏍᎩᏂ ᏥᏁᏁᏗ ᏥᎩ ᎠᎹ, ᎭᏫᏂ ᎠᏰᎸ ᎠᎹ ᎦᏄᎪᎬ ᎨᏎᏍᏗ, ᏫᎦᎾᏄᎪᎨᏍᏗ ᎬᏂᏛ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᏗᎨᏒᎢ.


text:
ᎠᏎᏃ ᏛᏍᏆᎸᎯ, ᎠᎴ ᎿᏉ ᎤᏍᏆᎸᎲ, ᎾᏍᎩ ᎤᏙᎯᏳᏒ ᎠᎾᏓᏙᎵᏍᏗᏍᎩ ᏛᎾᏓᏙᎵᏍᏓᏁᎵ ᎠᎦᏴᎵᎨ ᏙᏛᏅᏔᏂ ᏧᎾᏓᏅᏙ ᎠᎴ ᏚᏳᎪᏛᎢ; ᎠᎦᏴᎵᎨᏰᏃ ᏚᏲᎰ ᎾᏍᎩ ᎢᏳᎾᏍᏗ ᎬᏩᏓᏙᎵᏍᏓᏁᎯ.


text:
ᏝᏍᎪ ᎯᎠ ᎢᏤᏥᏪᏍᏗ ᏱᎩ; ᎠᏏ ᏅᎩ ᎢᏯᏅᏙ ᎩᎳ ᏛᎦᏛᎾᏥ? ᎬᏂᏳᏉ ᎯᎠ ᏂᏨᏪᏎᎭ; ᏗᏥᎦᏙᎵ ᏗᏥᏌᎳᏛᎦ, ᎠᎴ ᏕᎦᎶᎨᏒ ᏗᏣᎧᏅᎦ, ᎿᏉᏰᏃ ᏧᏁᎩᏳ, ᎠᎴ ᎤᏍᏆᎸᎲ ᎠᏍᎫᏕᏍᏗᏱ.


text:
ᎠᎴ ᎯᎠ ᏄᏂᏪᏎᎸᎩ ᎠᎨᏴ; ᎿᏉ ᎣᏦᎯᏳᎲᏍᎦ ᎥᏝ ᏂᎯᏉ ᏣᏁᏨ ᏱᏅᏗᎦᎵᏍᏙᎭ ᏦᏦᎯᏳᎲᏍᎦ, ᎣᎬᎡᏰᏃ ᎣᏣᏛᎦᏏ, ᎠᎴ ᎣᏥᎦᏔᎭ ᎾᏍᎩ ᎯᎠ ᎤᏙᎯᏳᎯᏯ ᎦᎶᏁᏛ ᎨᏒ ᎡᎶᎯ ᎠᏍᏕᎵᏍᎩ.


text:
ᎿᏉᏃ ᎨᎵᎵ ᏭᎷᏨ, ᎨᎵᎵ ᎠᏁᎯ ᏕᎬᏩᏓᏂᎸᏨᎩ, ᎤᏂᎪᎲᎯᏰᏃ ᎨᏒᎩ ᎾᏍᎩ ᏂᎦᏛ ᏚᎸᏫᏍᏓᏁᎸ ᏥᎷᏏᎵᎻ ᎾᎯᏳ ᏓᎾᎵᏍᏓᏴᎲᏍᎬᎢ; ᎾᏍᏉᏰᏃ ᎤᏁᏅᏒᎩ ᏙᏗᎾᎵᏍᏓᏴᎲᏍᎬᎢ.


text:
ᎢᏴᏛᎭᏰᏃ ᏗᎧᎿᏩᏗᏙᎯ ᎦᎷᏥᎯᎲᎩ ᎠᏓᏬᏍᏗᏱ, ᎠᎴ ᎠᏖᎸᎲᏍᎬᎩ ᎠᎹ, ᎩᎶᏃ ᎾᏍᎩ ᏧᏌᎴᏅᏔᏅᎯ ᎤᏚᏅᎯ ᎿᏉ ᎠᏖᎸᏅᎯ ᏥᎨᏐ ᎠᎹ, ᎤᏗᏩᏍᎬᎩ ᏂᎦᎥ ᎪᎱᏍᏗ ᎥᏳᎩ ᎤᏱᎵᏙᎲᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏂᏧᏏ ᎤᏟ ᎢᎦᎢ ᎤᎾᏚ-ᎸᎲᎩ ᎤᏂᎯᏍᏗᏱ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎥᏝ ᎤᎾᏙᏓᏆᏍᎬᏉ ᎤᏩᏒ ᎤᏲᏍᏔᏅᎢ, ᎾᏍᏉᏍᎩᏂ ᎤᏁᎳᏅᎯ ᎤᏙᏓ ᎤᏛᏅᎢ, ᎢᏧᎳᎭ ᎤᏁᎳᏅᎯ ᎾᏓᏛᏁᎲᎢ.


text:
ᎿᏉᏃ ᏥᏌ ᎤᏁᏨ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; <n>[ᎤᏁᎳᏅᎯ]</n> ᎤᏪᏥ ᎥᏝ ᏰᎵᎦ ᎪᎱᏍᏗ ᎤᏩᏒ ᎨᏒ ᏱᏙᎬᏩᎸᏫᏍᏓᏏ, ᎠᎪᏩᏘᏍᎬᏍᎩᏂ ᎤᏙᏓ ᏚᎸᏫᏍᏓᏁᎲᎢ; ᎾᏍᎩᏰᏃ ᏄᏍᏛ ᏚᎸᏫᏍᏓᏁᎲᎢ ᎾᏍᎩ ᎾᏍᏉ ᎤᏪᏥ ᏚᎸᏫᏍᏓᏁᎰᎢ.


text:
ᎠᎦᏴᎵᎨᏰᏃ ᎤᎨᏳᎯᏳ ᎤᏪᏥ, ᎠᎴ ᎦᎾᏄᎪᏫᏎᎰ ᏂᎦᏛ ᎤᏩᏒ ᏚᎸᏫᏍᏓᏁᎲᎢ; ᎠᎴ ᎤᏟ ᎢᎦᎢ ᏗᎦᎸᏫᏍᏓᏁᏗ ᏓᎦᎾᏄᎪᏫᏎᎵ ᎡᏍᎦᏉ ᎯᎠ; ᎾᏍᎩ ᎢᏥᏍᏆᏂᎪᎯᏍᏗᏱ.


text:
ᎤᏙᎯᏳᎯᏯ, ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎠᏛᎩᏍᎩ ᏥᏁᎬᎢ, ᎠᎴ ᎪᎯᏳᎲᏍᎩ ᏅᏛᎩᏅᏏᏛ ᎾᏍᎩ ᎤᎭ ᎬᏂᏛ ᎾᎵᏍᏆᏗᏍᎬᎾ, ᎠᎴ ᎾᏍᎩ ᎥᏝ ᏧᏚᎪᏙᏗ ᏱᎩ ᎤᏍᎦᏅᏨᎢ, ᎠᏲᎱᎯᏍᏗᏍᎩᏂ ᎨᏒ ᎤᏓᏅᏒ, ᎬᏂᏛ ᏗᎨᏒ ᏬᎶᏒ.


text:
ᎥᏝ ᎪᎱᏍᏗ ᎠᏋᏒ ᏰᎵ ᏱᏙᎬᎩᎸᏫᏍᏓᏏ; ᎦᏛᎩᏍᎬ ᎾᏍᎩᏯ ᏕᎫᎪᏗᏍᎪᎢ, ᎠᎴ ᏓᏉᎪᏔᏅ ᏚᏳᎪᏛ ᎨᏐᎢ; ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᎾᎩᏲᎲᎾ ᎨᏒ ᎠᏋᏒ ᎦᏓᏅᏖᏍᎬᎢ, ᎠᎩᏲᎲᏍᎩᏂ ᎠᏓᏅᏖᏍᎬ ᎡᏙᏓ ᎾᏍᎩ ᏅᏛᎩᏅᏏᏛ.


text:
ᎠᏎᏃ ᎤᏟ ᎦᎸᏉᏗᏳ ᎠᎩᏃᎮᏍᎩ ᎠᏇᎭ ᎡᏍᎦᏉ ᏣᏂ; ᏗᎦᎸᏫᏍᏓᏁᏗᏰᏃ ᎠᎦᏴᎵᎨ ᎠᎩᏁᎸᎯ ᎠᎩᏍᏆᏗᏍᏗᏱ, ᎾᏍᎩ ᏥᏓᎩᎸᏫᏍᏓᏁᎭ, ᎠᎩᏃᎮᏍᎪ ᎠᏴ ᎠᎦᏴᎵᎨᎢ ᏅᏛᎩᏅᏏᏛ ᎨᏒᎢ;


text:
ᎠᎴ ᏥᏳᎯ ᎤᎾᏣᏅᎩ ᎨᏆᏂ ᎢᏗᏢ ᏫᏚᏂᏐᎯᏍᏔᏅᎩ. ᎠᎴ ᎿᏉ ᎤᎵᏏᎬᎩ, ᎠᎴ ᏥᏌ ᎥᏝ ᏳᏂᎷᏤᎮᎠᎴ ᏥᏳᎯ ᎤᎾᏣᏅᎩ ᎨᏆᏂ ᎢᏗᏢ ᏫᏚᏂᏐᎯᏍᏔᏅᎩ. ᎠᎴ ᎿᏉ ᎤᎵᏏᎬᎩ, ᎠᎴ ᏥᏌ ᎥᏝ ᏳᏂᎷᏤᎮᎢ.


text:
ᎤᎩᏨᏛᏃ ᎤᏂᏣᏘ ᎥᏓᎵ ᎢᏍᎪᎾ ᏅᏛᏂᏙᎾᎢ, ᎤᎾᏙᎴᎰᏒ ᏅᏩᏓᎵ ᏥᏳ ᎾᏔᎸᎾ ᎨᏒᎢ, ᎾᏍᎩ Ꮎ ᎤᏩᏒ ᎬᏩᏍᏓᏗᏙᎯ ᎤᎾᏦᏔᏅᎯ, ᎠᎴ ᏥᏌ ᏂᏚᎵᎪᏁᎸᎾ ᎨᏒ ᎬᏩᏍᏓᏩᏗᏙᎯ ᏥᏳᎯ ᎤᎾᏣᏅ, ᎠᎴ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎤᏅᏒ ᎤᎾᏂᎩᏒᎢ;--


text:
ᏥᏌ ᏚᏁᏤᎸ ᎯᎠ ᏄᏪᏒᎩ; ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᏍᎩᏲᎭ ᎥᏝ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏍᏆᏂᎪᏗ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎢᏥᎪᎲᎢ, ᏅᏗᎦᎵᏍᏙᏗᏉᏍᎩᏂ ᎦᏚ ᏕᏥᎬᎢ, ᎠᎴ ᏕᏦᎸᏒᎢ.


text:
ᏞᏍᏗ ᏱᏗᏥᎸᏫᏍᏓᏁᎮᏍᏗ ᎢᏥᏩᏛᏗᏱ ᎠᎵᏍᏓᏴᏗ ᎠᏲᎵ, ᎾᏍᎩᏍᎩᏂ Ꮎ ᎠᎵᏍᏓᏴᏗ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᏗᎨᏒᎢ ᎢᎬᏂᏛ ᏥᎩ, ᎾᏍᎩ ᏴᏫ ᎤᏪᏥ ᎢᏥᏁᏗ ᏥᎩ, ᎾᏍᎩᏰᏃ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨ ᎤᏍᏓᏱᏛ.


text:
ᎿᏉᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎥᏝ ᎼᏏ ᏱᏥᏁᎴ ᎾᏍᎩ Ꮎ ᎦᏚ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ; ᎡᏙᏓᏍᎩᏂ ᎢᏥᏁᎭ ᎦᏚ ᎤᏙᎯᏳᎯᏯ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ


text:
ᎠᎴ ᎾᏍᎩ ᎯᎠ ᏄᏍᏗ ᎠᏓᏅᏖᏍᎬ ᎠᎦᏴᎵᎨᎢ ᎾᏍᎩ ᏅᏛᎩᏅᏏᏛ, ᎾᏍᎩ ᏂᎦᏛ ᏗᎩᏲᎯᏎᎸᎯ ᎨᏒᎢ, ᎪᎱᏍᏗ ᎠᎩᏲᎮᏎᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᏗᎦᎴᏙᏗᏱᏍᎩᏂ ᎤᎵᏍᏆᎸᏗ ᎢᎦ ᎨᏎᏍᏗ.


text:
ᎠᎴ ᎾᏍᎩ ᎯᎠ ᏄᏍᏗ ᎠᏓᏅᏖᏍᎬ ᎠᎦᏴᎵᎨ ᏅᏛᎩᏅᏏᏛ, ᎾᏍᎩ ᎩᎶ ᎠᎪᏩᏘᏍᎩ, ᎾᎵᏍᏆᏗᏍᎬᎾ ᎬᏂᏛ ᎤᏤᎵᎦ ᎢᏳᎵᏍᏙᏗᏱ; ᎠᎴ ᎾᏍᎩ ᎠᏴ ᏙᏓᏥᏯᎴᏔᏂ ᎤᎵᏍᏆᎸᏗ ᎢᎦ ᎨᏎᏍᏗ.


text:
ᎠᏴ ᎾᏍᎩ Ꮎ ᎦᏚ ᎬᏂᏛ ᎦᎸᎳᏗ ᏅᏓᏳᎶᏒᎯ. ᎢᏳᏃ ᎩᎶ ᎠᎩᏍᎨᏍᏗ ᎾᏍᎩ ᎯᎠ ᎦᏚ, ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎬᏁᏍᏗ. ᎠᎴ ᎾᏍᎩ Ꮎ ᎦᏚ ᏨᏓᏥᏁᎵ ᎾᏍᎩ ᎠᏴ ᎠᎩᏫᏯ, ᎾᏍᎩ ᏥᏙᏛᎩᏲᏏ ᎡᎶᎯ ᎤᏛᏂᏗᏍᏙᏗ.


text:
ᎢᏳᏃ ᎩᎶ ᎤᏚᎵᏍᎨᏍᏗ ᎾᏍᎩ ᏄᏍᏛ ᎤᏚᎵᏍᎬ ᏧᎸᏫᏍᏓᏁᏗᏱ, ᎠᏎ ᎤᏙᎴᎰᎯᏍᏗ ᎾᏍᎩ ᎯᎠ ᏥᏕᎦᏕᏲᎲᏍᎦ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᎨᏎᏍᏗ, ᎠᎴ ᏥᏬᏂᏍᎬ ᎠᏋᏒᏉ ᎠᏆᏓᏅᏖᎸᎯ ᎢᎨᏎᏍᏗ.


text:
ᎩᎶ ᎤᏩᏒ ᎤᏓᏅᏖᏛ ᏥᎦᏬᏂᏍᎪᎢ, ᎤᏩᏒᏉ ᎠᏥᎸᏉᏗᏳ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏲᎰᎢ; ᎩᎶᏍᎩᏂ ᏅᏓᏳᏅᏏᏛ ᎠᏥᎸᏉᏗᏳ ᎢᏳᎵᏍᏙᏗᏱ ᏧᏲᎰᎢ, ᎾᏍᎩ ᏚᏳᎪᏛ ᎨᏐᎢ, ᎠᎴ ᎥᏝ ᎠᏠᎾᏍᏗ ᎨᏒ ᏳᏓᏑᏲᎢ.


text:
ᎢᏳᏃ ᎠᏍᎦᏯ ᎤᎾᏙᏓᏆᏍᎬ ᎢᎦ ᏯᏥᏅᏍᏕᏎᎭ, ᏱᏅᏗᎦᎵᏍᏙᏗᎭ ᏗᎧᎿᏩᏛᏍᏗ ᎼᏏ ᎤᏤᎵ ᎤᏲᎢᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏥᎪ ᎢᏍᎩᏍᎦᎦ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᏍᎦᏯ ᏂᎬ ᎠᏰᎸ ᏥᏥᏅᏩᏅ ᎤᎾᏙᏓᏆᏍᎬ ᎢᎦ?


text:
ᎿᏉᏃ ᏥᏌ ᎤᏪᎷᏅᎩ ᎤᏛᏅᏗᎦᎳᏫᎢᏍᏗᏱ ᏓᏕᏲᎲᏍᎬᎢ, ᎯᎠ ᏄᏪᏒᎩ; ᏍᎩᎦᏔᎭ, ᎠᎴ ᎾᏍᏉ ᎢᏥᎦᏔᎭ ᏗᏆᏓᎴᏅᎢ; ᎠᎴ ᎥᏝ ᎠᏋᏒᏉ ᎠᏆᏓᏅᏖᏛ ᏯᎩᎷᏨ, ᏅᏛᎩᏅᏏᏛᏍᎩᏂ ᏚᏳᎪᏛᎢ, ᎾᏍᎩ ᏁᏥᎦᏔᎲᎾ ᏥᎩ.


text:
ᎿᏉᏃ ᎠᏂᏧᏏ ᎯᎠ ᏂᏚᎾᏓᏪᏎᎸᎩ, ᎭᏢ ᏮᏓᎦᎶᏏ, ᎦᏰᏗᏩᏛᏗ ᏂᎨᏒᎾ ᎢᎨᏎᏍᏗ? ᏧᎾᏓᎴᏅᏛᏍᎪ ᏴᏫ ᏓᏁᏩᏗᏒ ᎤᎾᏗᎦᎴᏲᏨᎯ ᏙᏛᏩᏛᎮᏏ, ᎠᎴ ᏫᏙᏓᎨᏲᏂ ᏧᎾᏓᎴᏅᏛ ᏴᏫ?


text:
ᎾᏍᎩ ᎯᎠ ᏄᏪᏒ, ᎤᏪᏛᏨᎩ ᎠᏓᏅᏙ, ᎾᏍᎩ ᎬᏬᎯᏳᎲᏍᎩ ᎨᏥᏁᏗ ᎨᏒᎢ; ᏝᏰᏃ ᎠᏏ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏱᎦᎾᏄᎪᎨᎢ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏥᏌ ᎠᏏ ᎾᏥᎸᏉᏗᏍᎬᎾ ᎨᏒᎢ.


text:
ᎾᏍᎩᏃ ᎤᎾᏛᎦᏅ, ᎠᎴ ᏧᎾᏓᏅᏙ ᎬᏩᏄᎯᏍᏔᏅ, ᎤᏂᏄᎪᏨᎩ ᏌᏉ ᎤᏛᏂᏛ ᎤᏓᏂᎵᎨ ᏚᏓᎴᏅᏔᏅᎩ, ᎣᏂᏱ ᏫᎬᏩᏛᏅᎩ; ᏥᏌᏃ ᎤᏩᏒ ᏄᎵᏍᏔᏅᎩ, ᎠᎨᏴᏃ ᎠᏰᎵ ᎦᏙᎬᎩ.


text:
ᏥᏌ ᎤᏁᏨᎩ, ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎠᏋᏒᏉ ᎾᏍᏉ ᏱᎦᏓᏃᎮᎭ, ᎠᏎ ᏥᏃᎮᏍᎬ ᎤᏙᎯᏳᎭ; ᏥᎦᏔᎭᏰᏃ ᏗᏆᏓᎴᏅᎢ ᎠᎴ ᏫᏥᎦᏛᎢ. ᏂᎯᏍᎩᏂ ᎥᏝ ᏱᏥᎦᏔᎭ ᏗᏆᏓᎴᏅᎢ ᎠᎴ ᏫᏥᎦᏛᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏴᏫ ᎤᏪᏥ ᎡᏥᏌᎳᏓᏅᎭ, ᎿᏉ ᏓᏣᏙᎴᎰᏏ ᎠᏴ ᎾᏍᎩ ᎨᏒᎢ, ᎠᎴ ᎠᏋᏒᏉ ᎠᏆᏓᏅᏖᏛ ᎪᎱᏍᏗ ᏂᏓᎩᎸᏫᏍᏓᏁᎲᎾ ᎨᏒᎢ, ᎡᏙᏓᏉᏍᎩᏂ ᎠᏇᏲᏅ ᎾᏍᎩ ᏥᏃᎮᏍᎬᎢ.


text:
ᎢᏥᏙᏓ ᎠᏍᎩᎾ ᏅᏓᏣᏓᎴᏅᎯ ᏂᎯ, ᎠᎴ ᎢᏥᏙᏓ ᎤᏲ ᏚᎸᏫᏍᏓᏁᎲ ᎢᏣᏛᏁᏗᏱ ᎢᏣᏚᎵᎭ. ᎾᏍᎩ ᏴᏫ ᏗᎯᎯ ᏂᎨᏐ ᏗᏓᎴᏂᏍᎬᎢ, ᎠᎴ ᎤᏙᎯᏳᎯ ᎨᏒ ᎥᏝ ᏱᏚᎴᏂᏍᎬᎢ, ᎠᎴ ᎤᏙᎯᏳᎯ ᎨᏒ ᎥᏝ ᏱᏚᎧᎿᏩᏛᏎᎢ, ᎥᏝᏰᏃ ᎤᏙᎯᏳᎯ ᎨᏒ ᏳᏪᎭ. ᎦᏰᎪᎩ ᎧᏁᎩ ᎤᏤᎵᎦᏉ ᎧᏁᎪᎢ; ᎦᏰᎪᎩᏰᏃ ᎾᏍᎩ, ᎠᎴ ᎤᎦᏴᎵᎨ ᎦᏰᎪᎩ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᎠᏂᏧᏏ ᎯᎠ ᏅᎬᏩᏪᏎᎸᎩ; ᎿᏉ ᎣᏣᏙᎴᎰᎯ ᎠᏍᎩᎾ ᏣᏯᎥᎢ. ᎡᏆᎭᎻ ᎤᏲᎱᏒ, ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ, ᏂᎯᏃ ᎯᎠ ᏂᎯᏪᎭ; ᎢᏳᏃ ᎩᎶ ᎠᏍᏆᏂᎪᏗᏍᎨᏍᏗ ᏥᏁᎬᎢ, ᎾᏍᎩ ᎥᏝ ᎢᎸᎯᏳ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎤᏙᎴᎰᏍᏗ ᏱᎨᏎᏍᏗ.


text:
ᎤᏁᏨᎯᎠ ᏄᏪᏒᎩ; ᎠᏍᎦᏯ ᏥᏌ ᏥᏚᏙᎥ ᏝᏬᏔ ᎤᏬᏢᏅᎩ, ᎠᎴ ᏚᏅᎵᏰᎥ ᏗᏥᎦᏙᎵ; ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ; ᏌᎶᎻ ᏨᏓᎸᎢ ᎮᎾ ᎠᎴ ᏩᏙᏑᎵ; ᎠᏇᏅᏃ ᎠᎴ ᏩᏆᏙᏑᎴᎢ ᏰᎵ ᎬᎩᎪᏩᏛᏗ ᏄᎵᏍᏔᏅᎩ.


text:
ᎿᏉᏃ ᎢᎦᏛ ᎠᏂᏆᎵᏏ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎾᏍᎩ ᎯᎠ ᎠᏍᎦᏯ ᎥᏝ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᏱᎩ, ᏝᏰᏃ ᏯᏍᏆᏂᎪᏗᎭ ᎤᎾᏙᏓᏆᏍᎬᎢ. ᎢᎦᏛᏃ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᏴᏫ ᎠᏍᎦᎾᎢ ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏍᏆᏂᎪᏗ ᏱᏚᎸᏫᏍᏓᏏ? ᏔᎵᏃ ᏄᎾᏓᏛᎩ.


text:
ᎠᏎᏃ ᏅᏧᎵᏍᏙᏔᏅᎢ ᎪᎯ ᏣᎪᏩᏘᎭ ᎥᏝ ᏲᏍᏗᎦᏔᎭ; ᎠᎴ ᎠᏴ ᎥᏝ ᏲᏍᏗᎦᏔᎭ ᎾᏍᎩ Ꮎ ᏧᏍᏚᎢᎡᎸᎯ ᎨᏒ ᏗᎦᏙᎵ. ᎿᏉ ᎠᏗᏃᎾ ᎤᏛᎾ, ᎡᏣᏛᏛᎲᎦ, ᎤᏩᏒ ᏓᎧᏃᎮᎵ.


text:
ᎾᏍᎩ ᏄᏂᏪᏒᎩ ᏧᎦᏴᎵᎨᎢ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏓᏂᏍᎦᎢᎲ ᎠᏂᏧᏏ; ᎦᏳᎳᏰᏃ ᎠᏂᏧᏏ ᏧᏄᎪᏔᏅᎯ ᎨᏒᎩ, ᎾᏍᎩ ᎢᏳ ᎩᎶ ᏳᏁᏨ ᎾᏍᎩ ᎦᎶᏁᏛ ᎨᏒ ᎠᏥᏄᎪᏫᏍᏗᏱ ᏗᎦᎳᏫᎢᏍᏗᏱ.


text:
ᎤᏙᎯᏳᎯᏯ, ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎾᏍᎩ Ꮎ ᎦᎶᎯᏍᏗᏱ ᎠᏴᏍᏗᏍᎩ ᏂᎨᏒᎾ ᎠᏫ ᎤᏂᏃᏕᎾ ᎤᏂᏴᏍᏗᏱ, ᎤᏣᏘᏂᏉᏍᎩᏂ ᎦᎸᏍᏗᏍᎩ, ᎾᏍᎩ ᎦᏃᏍᎩᏍᎩ ᎠᎴ ᎠᏓᎾᏌᎲᏍᎩ.


text:
ᎠᎴ ᏄᎾᏓᎴ ᎠᏫ ᏓᎩᎧᎭ, ᎾᏍᎩ ᎥᏝ ᎯᎠ ᎤᏂᏴᏍᏗᏱ ᏯᏂᏯᎠ; ᎾᏍᎩ ᎾᏍᏉ ᎠᏎ ᏙᏓᎦᏘᏃᎵ, ᎠᎴ ᏛᎾᏛᎦᏂ ᏥᏁᎬᎢ; ᎠᎴ ᏑᎾᏓᏡᎩ ᏅᏛᎾᎵᏍᏔᏂ; ᎠᎴ ᏌᏉ ᎨᏎᏍᏗ ᎠᏫᏗᎦᏘᏯ.


text:
ᎥᏝ ᎩᎶ ᎠᏛᎩᎩᎡᎵ, ᎠᏋᏒᏉᏍᎩᏂ ᎠᏆᏓᏅᏖᏛ ᎡᎳᏗ ᏓᏥᏂ. ᎠᎩᎭ ᏰᎵᏉ ᎡᎳᏗ ᎬᎩᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎩᎭ ᏰᎵᏉ ᎬᎩᎩᏏᏐᏗ ᎨᏒᎢ. ᎾᏍᎩ ᎯᎠ ᏄᏍᏗ ᎡᏙᏓ ᎠᎩᏁᏤᎸ.


text:
ᏥᏌ ᎤᏁᏨᎩ ᎯᎠ ᏚᏂᏪᏎᎸᎩ, ᎤᏣᏔ ᏱᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎡᏙᏙᏱ ᏅᏓᏳᏓᎴᏅᎯ ᎬᏂᎨᏒ ᏂᏨᏴᏁᎸ; ᎦᏙ ᎤᏍᏗ ᎾᏍᎩ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎠᎩᏍᏛᏗᎠ ᏅᏯ ᏥᏕᏍᎩᏴᏂᏍᏗᎭ?


text:
ᎢᏳᏍᎩᏃᏂ ᎾᏍᎩ ᎤᏤᎵ ᏱᏓᎩᎸᏫᏍᏓᏁᎭ, ᎾᏍᏉ ᎠᏴ ᏂᏍᎩᏲᎢᏳᎲᏍᎬᎾ ᏱᎩ, ᎠᏎ ᎢᏦᎯᏳᎲᏍᎨᏍᏗ ᎾᏍᎩ Ꮎ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ; ᎾᏍᎩᏃ ᏰᎵ ᎨᏣᏙᎴᎰᎯᏍᏗ ᎠᎴ ᎨᏦᎯᏳᏗ ᏱᎩ ᎠᎦᏴᎵᎨᎢ, ᎠᎩᏯᎥᎢ ᎠᎴ ᎾᏍᎩ ᎠᏴᏥᏯᎥᎢ


text:
ᎿᏉᏃ ᎠᏂᏧᏏ ᎦᎵᏦᏕ ᎤᏪᎸ ᎠᏂᏂ, ᎠᎴ ᎬᏩᏄᏬᎯᏍᏗᏍᎩ, ᎤᏂᎪᎲ ᎺᎵ ᎤᎵᏍᏗᏳ ᏚᎴᏅ ᎠᎴ ᎤᏄᎪᏨ ᎬᏩᏍᏓᏩᏛᏒᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᏗᎦᏂᏌᎲ ᏩᎦᏘ ᎾᎿ ᏮᏛᏍᎪᏂᎵ.


text:
ᎠᏂᏧᏏᏃ ᎤᎾᏤᎵᎦ ᎧᏃᎯᏰᎩ ᏗᎵ ᏍᏓᏴᏗᏱ ᎤᏍᏆᎸᎯᏗᏒᎩ; ᎤᏂᏣᏛᎩᏃ ᎾᎿ ᎤᎾᏂᎩᏒᎩ ᏥᎷᏏᎵᎻ ᏭᏂᎶᏒᎩ ᎠᏏᏉ ᎾᏍᏆᎵᏍᎬᎾ ᏫᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ, ᎤᎾᏓᏅᎦᎸᏗᏱ ᎤᏂᏰᎸᏒᎩ.


text:
ᎿᏉᏃ ᎺᎵ ᎤᎩᏒᎩ ᏑᏓᎨᏛ ᎠᏠᏁᏗ ᎾᏓ ᏧᏙᎢᏛ ᎪᎱᏍᏗ ᎾᏑᏴᎾ, ᎤᏣᏘ ᏧᎬᏩᎶᏗ, ᎠᎴ ᏚᏅᎵᏰᎥᎩ ᏥᏌ ᏧᎳᏏᏕᏂ, ᎠᎴ ᎤᏍᏘᏰᎬ ᎤᏩᏔᏅᎩ ᏚᏅᎦᎸᎲᎩ ᏧᎳᏏᏕᏂ. ᎠᎴ ᎦᎵᏦᏕ ᎤᎧᎵᏨᎩ ᎦᏩᏒᎬ ᎠᏠᏁᏗ.


text:
ᎾᏍᎩ ᎯᎠ ᏄᏪᏒᎩ, ᎥᏝ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ ᎣᏍᏛ ᎢᏳᎾᎵᏍᏓᏁᏗᏱ ᎤᏚᎵᏍᎬ ᏱᏅᏧᎵᏍᏙᏔᏁᎢ, ᎦᏃᏍᎩᏍᎩᏍᎩᏂ ᎨᏒ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ, ᎠᎴ ᏕᎦᎶᏗ ᎦᏁᎲᎢ ᎠᎴ ᎾᎿ ᎦᎳᏅᎯ ᎦᏃᏍᎩᏍᎬᎢ.


text:
ᎤᏂᏣᏛᎩᏃ ᎠᏂᏧᏏ ᎤᎾᏛᎦᏅᎯ ᎨᏒᎩ ᎾᎿ ᎡᏙᎲᎢ, ᎠᎴ ᎤᏂᎷᏨᎩ ᎥᏝ ᏥᏌ ᎤᏩᏒ ᎨᏒ ᏱᏅᏧᎵᏍᏙᏔᏁᎢ, ᎾᏍᏉᏍᎩᏂ ᎳᏏᎳ ᎤᏂᎪᏩᏛᏗᏱ ᎤᏂᏰᎸᏒᎩ, ᎾᏍᎩ ᎤᏲᎱᏒ ᏧᎴᏔᏅᎯ.


text:
ᏚᏂᏴᎲᎩ ᏧᏪᏲᏔ ᏧᎦᏄᏓᏅᎯᏛ ᎠᎴ ᎤᏂᏄᎪᏨᎩ ᏚᎾᏠᏒᏒᎩ, ᎠᎴ ᎯᎠ ᏄᏂᏪᏒ ᎤᏁᎷᏅᎩ, ᎰᏌᎾ! ᎠᏥᎸᏉᏗᏳ ᏫᏂᎦᎵᏍᏓ ᏱᎰᏩ ᏚᏙᏍᏛ ᏨᏓᏯᎢ, ᎤᎬᏫᏳᎯ ᎢᏏᎵ ᎤᎾᏤᎵᎦ.


text:
ᎢᏳᏃ ᎩᎶ ᏥᏅᏏᏓᏍᏗ ᏂᎦᎵᏍᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎠᎩᏍᏓᏩᏕᎨᏍᏗ; ᎨᎥᏃ ᎾᎿ ᎾᏍᏉ ᏥᏅᏏᏓᏍᏗ ᎡᎮᏍᏗ. ᎢᏳᏃ ᎩᎶ ᏥᏅᏏᏓᏍᏗ ᏂᎦᎵᏍᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎡᏙᏓ ᎤᎸᏉᏙᏗ ᎨᏎᏍᏗ.


text:
ᎿᏉ ᎠᏆᏓᏅᏙ ᎡᏕᏯᏔᏁᎭ; ᎦᏙᏃ ᏓᎦᏛᏂ? <n>[ᎯᎠᏍᎪ ᏅᏓᏥᏪᏏ,]</n> ᎡᏙᏓ, ᏍᏊᏓᎳᎩ ᎪᎯ ᎨᏒᎢ? ᎠᏎᏃ ᎾᏍᎩ ᎢᏳᏍᏗ ᏣᎩᏍᏆᎸᎡ ᎪᎯ ᎠᎩᏍᏆᎸᎡᏗᏱ ᎠᎩᎷᏥᎸ.


text:
ᏴᏫ ᎤᏂᏁᏨ ᎯᎠ ᏂᎬᏩᏪᏎᎸᎩ, ᎠᏴ ᎣᎦᏛᎦᏅ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎾᏍᎩ ᎦᎶᏁᏛ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎡᎲᎢ; ᎦᏙᏃ ᏴᏫ ᎤᏪᏥ ᎠᏎ ᏓᏰᏥᏌᎳᏓᏂ ᎢᎭᏗᎭ? ᎦᎪ ᎾᏍᎩ Ꮎ ᏴᏫ ᎤᏪᏥ?


text:
ᎿᏉᏃ ᏥᏌ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎠᏏᏞᎦ ᎢᎦ ᏚᎸᏌᏛ ᎢᏤᏙᎲᎢ; ᎢᏤᏙᎮᏍᏗ ᏂᎪᎯᎸ ᎢᎦ ᏕᏥᎸᏌᏓᏕᎲᎢ; ᎤᎵᏏᎩᎾᏏ ᏱᏧᏢᏓ; ᎩᎶᏰᏃ ᎤᎵᏏᎬ ᏤᏙᎰᎢ, ᎥᏝ ᏯᎦᏔᎰ ᏩᎦᏛᎢ.


text:
"ᏚᏍᏚᏁᎸ ᏗᏂᎦᏙᎵ, ᎠᎴ ᏚᏍᏓᏱᏕᎸ ᏧᏂᎾᏫ; ᏗᎬᏩᏂᎪᏩᏛᏙᏗ ᏂᎨᏒᎾ ᏗᏂᎦᏙᎵ, ᎠᎴ ᎬᏩᏃᎵᏍᏙᏗ ᏂᎨᏒᎾ ᎤᏂᎾᏫ, ᎠᎴ ᎾᏍᎩ ᏗᎬᏩᎾᏓᏁᏟᏴᎡᏗ ᏂᎨᏒᎾ, ᎠᎴ ᏗᎦᎦᏥᏅᏬᏗ ᏂᎨᏒᎾ."


text:
ᎠᏏᏃ ᎤᏃᏒᎩ ᎧᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ, ᏥᏌ ᎠᎦᏔᎯᏳ ᎨᏒᎩ ᎤᏍᏆᎸᎡᏱ ᎠᏂ ᎡᎶᎯ ᎤᏓᏅᏍᏗᏱ, ᎠᎦᏴᎵᎨᏍᏛᏱ ᏭᎶᎯᏍᏗᏱ, ᏧᎨᏳᎯᏳ ᎢᏳᎵᏍᏔᏅᎯ ᎨᏒᎩ ᏧᏤᎵᎦ ᎡᎶᎯ ᎠᏁᎯ, ᎬᎵᏍᏆᏗᏍᎩ ᏧᎨᏳᎯᏳ ᎨᏒᎩ.


text:
ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎠᏥᎾᏝᎢ ᎥᏝ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᏱᎨᏐᎢ, ᎡᏍᎦᏉ ᎤᎾᏝᎢ; ᎠᎴ ᎥᏝ ᎠᏥᏅᏏᏛ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᏱᎨᏐᎢ, ᎡᏍᎦᏉ ᏅᏓᏳᏅᏏᏛ.


text:
ᏧᏓᏏᏰᏃ ᏕᎦᎶᏗ ᎦᏁᎲ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎢᎦᏛ, ᎯᎠ ᏥᏌ ᏂᎦᏪᏏ ᎤᏁᎵᏒᎩ; ᎪᎱᏍᏗ ᏣᏩᎯ ᏗᎵᏍᏓᏴᏗᏱ ᎨᏒ ᎢᏳ ᎪᎱᏍᏗ ᎢᎬᏙᏗ; ᎠᎴ ᎯᎠ ᏱᎩ; ᎪᎱᏍᏗ ᏘᎲᏏ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ.


text:
ᏗᏥᏲᎵ, ᎠᏏ ᏞᎦ ᎢᏨᏰᎳᏗᏙᎭ; ᏍᎩᏲᎮᏍᏗ; ᎠᎴ ᎾᏍᎩᏯ ᎠᏂᏧᏏ ᏥᏂᎦᏥᏪᏎᎸᎩ, "ᏫᏥᎦᏛ ᎥᏝ ᏫᏴᎨᏥᎶᎯ," ᏥᎦᏥᏲᏎᎸᎩ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎿᏉ ᏂᎯ ᏂᏨᏪᏎᎭ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏥᎪ ᏴᎪᎯᎩ ᎢᏧᎳᎭ ᎢᏁᏓ, ᎠᏏᏍᎪᏃ ᎥᏝ ᏱᏍᎩᎦᏙᎥᏍᎦ, ᏈᎵᎩ; ᎩᎶ ᎠᏴ ᎠᎩᎪᎲᎯ ᏥᎨᏐᎢ, ᎤᎪᎲᎯ ᎨᏐ ᎠᎦᏴᎵᎨᎢ; ᎦᏙᏃ ᎯᎠ ᏂᎯᏪᎠ; ᏍᎩᎾᏄᎪᏫᏏ ᎠᎦᏴᎵᎨᎢ?


text:
ᏝᏍᎪ ᏲᎯᏳᎲᏍᎦ ᎠᏴ ᎠᎦᏴᎵᎨᎢ ᏥᏯᎥᎢ, ᎠᎴ ᎠᎦᏴᎵᎨ ᎠᏴ ᎠᎩᏯᎥᎢ? ᎧᏃᎮᏛ ᏥᏨᏃᎮᎮᎰᎢ, ᎥᏝ ᎠᏋᏒᏉ ᎠᏆᏓᏅᏖᏛ ᏱᏥᏁᎪᎢ, ᎠᎦᏴᎵᎨᎢᏍᎩᏂ ᏣᎩᏯᎠ ᎾᏍᎩ ᏚᎸᏫᏍᏓᏁᎰᎢ.


text:
ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᎠᏉᎯᏳᎲᏍᎩ, ᎠᏴ ᏥᏓᎩᎸᏫᏍᏓᏁᎭ ᎾᏍᏉᎾᏍᎩ ᏙᏓᏳᎸᏫᏍᏓᏁᎵ, ᎠᎴ ᎤᏟ ᎤᏍᏆᏂᎪᏗᏳ ᏙᏓᏳᎸᏫᏍᏓᏁᎵ ᎡᏍᎦᏉ ᎯᎠ; ᎡᏙᏙᏱᏰᏃ ᎦᎢ,


text:
ᎾᏍᎩ Ꮎ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎠᏓᏅᏙ, ᎾᏍᎩ ᎡᎶᎯ ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᏂᎨᏒᎾ ᏥᎩ, ᎾᏍᎩ ᏳᎪᏩᏘᎭ ᎠᎴ ᎥᏝ ᏳᎦᏔᎭ; ᏂᎯᏍᎩᏂ ᎡᏥᎦᏔᎭ, ᎢᏤᎳᏗᏙᎭᏰᏃ, ᎠᎴ ᎾᏍᎩ ᎢᏥᏯᎡᏍᏗ.


text:
ᎾᏍᎩ Ꮎ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏆᏤᎵᎦ ᎤᏍᏆᏂᎬᏗ ᎠᎴ ᏗᎧᎿᏩᏕᎩ, ᎾᏍᎩ ᎠᏴ ᎠᎩᎨᏳᎯ, ᎠᎴ ᎠᏴ ᎠᎩᎨᏳᎯ ᎤᎨᏳᎯ ᎨᏎᏍᏗ ᎡᏙᏓ, ᎠᎴ ᎠᏴ ᏥᎨᏳᎢᏳ ᎨᏎᏍᏗ, ᎠᎴ ᎬᏂᎨᏒ ᏅᏓᏥᏯᏛᏁᎵ.


text:
ᏥᏌ ᎤᏁᏨᎩ, ᎯᎠ ᏄᏪᏎᎸᎩ; ᎢᏳᏃ ᎩᎶ ᎠᎩᎨᏳᎯ ᏱᎩ, ᎾᏍᎩ ᏧᎧᎿᏩᏛᏍᏗ ᎠᎩᏁᏨᎢ; ᎡᏙᏓᏃ ᎤᎨᏳᎯ ᎢᏳᎵᏍᏙᏗ, ᎠᎴ ᏓᏲᏍᏗᎷᏤᎵ, ᎠᎴ ᎦᏁᎸᎢ ᏓᏲᏍᏓᏁᎳᏗ.


text:
ᎢᏣᏛᎦᏅᎯ, ᏛᎨᏏ ᎠᎴ ᏛᏨᎷᏤᎵ, ᏥᏨᏲᏎᎸᎩ. ᎢᏳᏃ ᏍᎩᎨᏳᎢᏳ ᏱᎩ, ᏳᏣᎵᎮᎵᎦ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᎦᏴᎵᎨᏍᏛᏱ ᏫᏥᎦᏘ ᏣᏆᏛᏅᎩ; ᎡᏙᏓᏰᏃ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᎡᏍᎦᏉ ᎠᏴ.


text:
ᏍᎩᏯᎡᏍᏗ, ᎠᏎᏃ ᎢᏨᏯᎡᏍᏗ. ᎾᏍᎩᏯ ᎤᏩᏂᎦᎸᎢ ᎡᏩᏒ ᏰᎵ ᎬᏩᏓᏛᏗ ᏂᎨᏒᎾ ᏥᎨᏐ ᎬᏂ ᎤᏖᎸᎳᏛ ᏧᏩᏂᎦᎶᎢ, ᎾᏍᏉᏍᎩᏂ ᏂᎯ ᎥᏝ ᏰᎵᎦ ᎬᏂ ᎠᏴ ᏱᏍᎩᏯᎠ.


text:
ᎢᏳᏃ ᏱᏥᏍᏆᏂᎪᏗ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏆᏤᎵᎦ, ᏱᏅᏩᏍᏗᏗᏉ ᎢᏨᎨᏳᎢᏳ ᎨᏒᎢ; ᎾᏍᎩᏯ ᏣᎩᏍᏆᏂᎪᏔᏅ ᏗᎧᎿᏩᏛᏍᏗ ᎡᏙᏓ ᎤᏤᎵᎦ, ᎠᎴ ᏥᏅᏩᏍᏗᏗᏉ ᎠᎩᎨᏳᎯᏳ ᎨᏒᎢ.


text:
ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᎥᏝ ᎢᏨᏅᏏᏓᏍᏗ ᏱᏨᏲᏎᎭ; ᎠᏥᏅᏏᏓᏍᏗᏰᏃ ᎥᏝ ᏯᎦᏔᎰ ᎤᎾᏞᎢ ᎾᏛᏁᎲᎢ. ᏂᎯᏍᎩᏂ ᎢᎦᎵᎢ ᎢᏨᏲᏎᎭ; ᏂᎦᎥᏰᏃ ᎪᎱᏍᏗ ᎡᏙᏓ ᏥᏯᏛᎦᏁᎸᎢ ᎾᏍᎩ ᎢᏨᎾᏄᎪᏫᏎᎸ.


text:
ᎥᏝ ᏂᎯ ᎠᏴ ᏍᎩᏯᏑᏰᏛ ᏱᎩ, ᎠᏴᏍᎩᏂ ᏂᎯ ᎢᏨᏯᏑᏰᏛ, ᎠᎴ ᏕᏨᏯᎧᏅ ᎢᏤᏅᏍᏗᏱ ᎤᏁᏉᏨᎯ ᎢᏥᎾᏄᎪᏫᏍᏗᏱ, ᎠᎴ ᎤᏁᏉᏨᎯ ᎢᏣᏤᎵᎦ ᎦᎶᏐᎲᏍᎩ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᏂᎦᎥᏃ ᎪᎱᏍᏗ ᎡᏥᏔᏲᏎᎮᏍᏗ ᎠᎦᏴᎵᎨᎢ, ᎠᏴ ᏓᏆᏙᎥ ᎢᏥᏔᏲᏍᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎢᏥᏁᏗᏱ.


text:
ᎢᏳᏃ ᎡᎶᎯ ᎢᏣᎵᎪᎯ ᏱᎨᏎᎢ, ᎡᎶᎯ ᏧᎨᏳᎯᏳ ᏱᎨᏎ ᏧᏤᎵᎦ. ᎠᏎᏃ ᎡᎶᎯ ᎢᏣᎵᎪᎯ ᏂᎨᏒᎾ ᏥᎩ, ᎢᏨᏯᏑᏰᏛᏍᎩᏂ ᎡᎶᎯ ᏥᎩ, ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎡᎶᎯ ᎢᏥᏍᎦᎦ.


text:
ᎢᏣᏅᏖᏍᏗ ᎯᎠ ᏥᏂᏨᏪᏎᎸᎩ; ᎠᏥᎾᏝᎢ ᎥᏝ ᎤᏟ ᎠᏥᎸᏉᏗᏳ ᏱᎨᏐ ᎡᏍᎦᏉ ᎤᎾᏝᎢ. ᎢᏳᏃ ᎠᏴ ᎬᎩᏐᏢᏔᏅᎯ ᏱᎩ, ᏂᎯ ᎾᏍᏉ ᏓᎨᏥᏐᏢᏔᏂ. ᎢᏳᏃ ᎠᏴ ᎠᎩᏁᏨ ᎤᏂᏍᏆᏂᎪᏔᏅᎯ ᏱᎩ, ᏂᎯ ᎾᏍᏉ ᎢᏥᏁᏨ ᏛᏂᏍᏆᏂᎪᏔᏂ.


text:
ᎢᏳᏃ ᎠᏁᎲ ᏂᏓᎩᎸᏫᏍᏓᏁᎲᎾ ᏱᎨᏎᎢ ᎩᎶ ᏧᎸᏫᏍᏓᏁᎸᎯ ᏂᎨᏒᎾ ᏥᎩ, ᎥᏝ ᎠᏍᎦᏂ ᏱᎬᏩᏁᎮᎢ; ᎠᏎᏃ ᎿᏉ ᎢᏧᎳ ᎪᎩᏂᎪᎲ ᎠᎴ ᎪᎩᏂᏍᎦᎩᏳ ᏄᎵᏍᏔᏅ ᎢᏧᎳ ᎠᏴ ᎡᏙᏓᏃ.


text:
ᎠᏎᏃ ᎠᏓᏅᏬᎯᏍᏗᏍᎩ ᎦᎷᏨᎭ, ᎾᏍᎩ ᎠᎦᏴᎵᎨᏍᏛᏱ ᏅᏓᏥᏅᏍᏗ ᏥᎩ ᏂᎯ ᎢᏥᎷᏤᏗᏱ, ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎠᏓᏅᏙ ᎠᎦᏴᎵᎨᏍᏛᏱ ᏅᏛᏓᎴᎲᏍᎩ, ᎾᏍᎩ ᏛᎩᏃᎮᎵ ᎬᏂᎨᏒ ᏅᏛᏋᏁᎵ.


text:
ᎦᎷᏨᎭᏍᎩᏂ ᎾᏍᎩ Ꮎ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎠᏓᏅᏙ, ᏂᎦᎥ ᎤᏙᎯᏳᎯ ᎨᏒ ᏙᏓᏣᏘᏂᏙᎵ, ᎥᏝᏰᏃ ᎤᏩᏒᏉ ᎤᏓᏅᏖᏛ ᏱᎧᏁᎨᏍᏗ, ᏂᎦᎥᏍᎩᏂ ᎠᏛᎩᏍᎨᏍᏗ ᎾᏍᎩ ᎧᏁᎨᏍᏍᏗ; ᎠᎴ ᏓᏥᎾᏄᎪᏫᏎᎵ ᏧᏓᎴᏅᏛ ᎣᏂ ᎢᏳᎵᏍᏔᏂᏓᏍᏗ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᎢᎦᏛ ᎬᏩᏍᏓᏩᏗᏐᎯ ᎯᎠ ᏂᏚᎾᏓᏪᏎᎸᎩ; ᎦᏙ ᎦᏛᎦ ᎯᎠ ᏥᏂᎩᏪᏎᎭ; ᏂᎪᎯᎸᎾᏉ ᎿᏉ ᎥᏝ ᏱᏍᎩᎪᏩᏘᏍᎨᏍᏗ, ᎠᎴ ᎿᏉ ᏔᎵᏁ ᏂᎪᎯᎸᎾᏉ ᎢᏍᎩᎪᏩᏘᏍᎨᏍᏗ? ᎠᎴ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᎦᏴᎵᎨᏍᏛᏱ ᏫᏥᎦᏛᎢ?


text:
ᏥᏌᏃ ᎠᎦᏔᎲᎩ ᎤᎾᏚᎵᏍᎬ ᎬᏩᏛᏛᏗᏱ, ᎯᎠᏃ ᏂᏚᏪᏎᎸᎩ; ᏥᎪᏕᏣᏓᏛᏛᎲᏍᎦ ᎦᏛᎬᎢ ᎯᎠ ᏥᎾᎩᏪᏒᎩ; ᏂᎪᎯᎸᎾᏉ ᎿᏉ ᎥᏝ ᏱᏍᎩᎪᏩᏘᏍᎨᏍᏗ, ᎠᎴ ᎿᏉ ᏔᎵᏁ ᏂᎪᎯᎸᎾᏉ ᎢᏍᎩᎪᏩᏘᏍᎨᏍᏗ?


text:
ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᏂᎯ ᏕᏥᏴᎨᏍᏗ ᎠᎴ ᎢᏥᏍᎪᏂᎮᏍᏗ, ᎡᎶᎯᏍᎩᏂ ᎠᎵᎮᎵᎨᏍᏗ; ᏂᎯᏃ ᎤᏲ ᎢᏣᏓᏅᏖᏍᏗ, ᎠᏎᏃ ᎤᏲᎢᏣᏓᏅᏛ ᎤᎵᎮᎵᏍᏗ ᏮᏛᏓᏁᏟᏴᏍᏔᏂ.


text:
ᎠᎨᏴ ᎤᏲ ᎤᏓᏅᏙ ᏣᏕᎲᏍᎪ ᎠᏲᎵ, ᎤᏍᏆᎸᎡᎸ ᏅᏗᎦᎵᏍᏙᏗᏍᎪᎢ; ᎠᏎᏃ ᎿᏉ ᎦᎾᏄᎪᏩ ᎠᏲᎵ, ᎥᏝ ᎿᏉ ᏯᏅᏓᏗᏍᎪ ᎡᎯᏍᏗ ᎤᏓᏅᏓᏛᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᎠᎵᎮᎵᎬ ᏴᏫ ᎤᎾᏄᎪᏫᏒ ᏒᎶᎯ.


text:
ᎾᎯᏳᏃ ᎢᎦ ᎥᏝ ᎪᎱᏍᏗ ᏱᏍᎩᏯᏛᏛᎲᏍᎨᏍᏗ. ᎤᏙᎯᏳᎯᏯ ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᏨᏪᏎᎭ; ᏂᎦᎥ ᎪᎱᏍᏗ ᎠᎦᏴᎵᎨ ᎡᏥᏔᏲᏎᎮᏍᏗ, ᏓᏉᏙᎥ ᎢᏨᏗᏍᎨᏍᏗ, ᎠᏎ ᎡᏥᏁᏗ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎯᎠ ᏄᏍᏗ ᎢᏨᏃᎮᎮᎸ ᎤᏦᏍᏗ ᎪᎵᏍᏗᏱ ᎠᏋᏔᏅ; ᎠᏎᏃ ᏛᏍᏆᎸᎯ ᎿᏉ ᎥᏝ ᏱᏨᏯᎵᏃᎮᏗᏍᎨᏍᏗ ᎤᏦᏍᏗ ᎪᎵᏍᏗᏱ ᎬᏗ, ᎬᏂᎨᏒᎢᏳᏍᎩᏂ ᏓᏨᎾᏄᎪᏫᏎᎵ ᎠᎦᏴᎵᎨᎢ.


text:
ᎬᏂᏳᏉ ᏛᏍᏆᎸᎯ, ᎥᎥ, ᎿᏉᎤᏍᏆᎸᎲ, ᎢᏣᏗᎦᎴᏲᎢᏍᏗᏱ, ᏂᏥᎥ ᎢᏥᏏᏴᏫᎭ ᏙᏗᏤᏅᏒ ᎢᏗᏢ, ᎠᎴ ᏓᏍᎩᏴᏕᏥ ᎠᏋᏒᏉ ᎨᏎᏍᏗ; ᎥᏝᏍᎩᏂᏃᏅ ᎠᏋᎡ ᏱᎩ, ᎠᎦᏴᎵᎨᏰᏃ ᏔᎵ ᏅᏛᏗᏕᎦ.


text:
ᏕᏥᏁᎸᏰᏃ ᎧᏃᎮᏛ ᎾᏍᎩ ᏍᎩᏁᎸᎯ ᏥᎩ; ᎠᎴ ᎾᏍᎩ ᏚᎾᏓᏂᎸᏨ, ᎠᎴ ᎤᏂᎦᏙᎥᏒ ᎤᏙᎯᏳᏒ ᏂᎯ ᏖᎲ ᏅᏛᏆᏓᎴᏅᎯ ᎨᏒᎯ; ᎠᎴ ᎤᏃᎯᏳᏅ ᏂᎯ ᏅᏓᏍᎩᏅᏏᏛ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᎠᏴ ᎥᏝ ᎡᎶᎯ ᏱᎨᎠ, ᎯᎠᏍᎩᏂ ᎡᎶᎯ ᎠᏁᎭ, ᎠᏴᏃ ᏗᏦᎸ ᏫᏥᎦᏘ. ᎡᏣᎸᏉᏗᏳ ᎡᏙᏓ, ᏨᏒ ᏕᏣᏗᎥ ᎲᏗᏍᎨᏍᏗ ᏕᎯᏍᏆᏂᎪᏕᏍᏗ ᏗᏍᎩᎧᏁᎸᎯ, ᏌᏉᏉ ᎢᏳᎾᎵᏍᏙᏗᏱ, ᎾᏍᎩᏯ ᏂᎯ ᎠᏴᏃ ᏌᏉᏉ ᏥᎩ.


text:
ᎠᏏ ᎡᎶᎯ ᏥᎦᏥᏰᎳᏗᏙᎲᎩ, ᏕᏣᏙᎥ ᏕᏥᏍᏆᏂᎪᏙᏛᎩ; ᎾᏍᎩ ᏗᏍᎩᎧᏁᎸᎯ ᎦᏥᏍᏆᏂᎪᏔᏅ, ᎠᎴ ᎥᏝ ᎠᏏᏴᏫ ᏳᏲᎱᏒ Ꮎ ᎤᏩᏒ ᎠᏲᎱᎯᏍᏗ ᎤᏪᏥ, ᎤᏙᎯᏳᏗᏱ ᎪᏪᎸᎢ.


text:
ᎾᏍᎩ ᏂᎦᏛ ᏌᏉᏉ ᎢᏳᎾᎵᏍᏙᏗᏱ, ᎾᏍᎩᏯ ᏂᎯ ᎡᏙᎠ ᏥᏍᎩᏯᎠ, ᎠᎴ ᎠᏴ ᏥᎬᏯᎠ, ᎾᏍᎩ ᎾᏍᏉ ᏌᏉᏉ ᎢᎦᎵᏍᏙᏗᏱ; ᎾᏍᎩᏃ ᎡᎶᎯ ᎤᏬᎯᏳᏗᏱ ᏂᎯ ᏅᏓᏍᎩᏅᏏᏛ ᎨᏒᎢ.


text:
ᎠᏴᎾᏍᎩ ᎦᏥᏯᎥᎢ, ᎠᎴ ᏂᎯ ᎠᏴ ᏍᎩᏯᎥᎢ, ᎾᏍᎩ ᏧᏳᏙᏗᏯ ᏌᏉᏉ ᎢᏳᎾᎵᏍᏙᏗᏱ, ᎾᏍᎩᏃ ᎡᎶᎯ ᎤᎦᏙᎥᎯᏍᏗᏱ ᏅᏓᏍᎩᏅᏏᏛ ᎨᏒᎢ, ᎠᎴ ᎾᏍᎩ ᏘᎨᏳᎯᏳ ᎨᏒᎢ, ᎾᏍᎩᏯ ᏍᎩᎨᏳᎢᏳ ᏥᎩ.


text:
ᎡᏙᏓ, ᎠᏆᏚᎵ ᎾᏍᏉ ᏗᏍᎩᎧᏁᎸᎯ ᎠᏴ ᎨᎥᎢ ᎾᏍᎩ ᎢᏧᎳᎭ ᎣᎦᏕᏗᏱ, -ᎾᏍᎩᏃ ᎤᏂᎪᏩᏛᏗᏱ ᎥᎩᎸᏉᏛᎢ, ᎾᏍᎩ ᏍᎩᏁᎸᎯ ᏥᎩ; ᏍᎩᎨᏳᎯᏳᏰᏃ ᎨᏒᎩ ᎠᏏ ᎡᎶᎯ ᎾᏓᎴᏂᏍᎬᎾ ᏥᎨᏒᎩ.


text:
ᎿᏉᏃ ᏧᏓᏏ ᏚᏘᏁᏅ ᏑᎾᏓᏡᎩ ᎠᏂᏯᏫᏍᎩ, ᎠᎴ ᏗᎾᏓᏂᏱᏍᎩ, ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᎠᏂᏉᎵᏏ ᏅᏓᏳᎾᏓᎴᏅᎯ, ᎾᎿ ᎤᎷᏨᎩ, ᏓᏂᏁᎲᎩ ᏗᏨᏍᏙᏗ ᎠᎴ ᏗᎵᏍᎦᏍᏙᏙᎢ.


text:
ᎿᏉᏃ ᏌᏩᏂ ᏈᏓ ᎠᏰᎳᏍᏗᎦᏅᎯᏛ ᎦᏁᎲᎢ, ᎤᎸᎲᎩ, ᎠᎴ ᎤᎷᏏᎩ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎤᏅᏏᏓᏍᏗ, ᎠᎴ ᎾᏍᎩ ᎠᎦᏘᏏ ᎦᎴᏂ ᎤᎵᏍᏕᏍᏔᏅᎩ. ᎾᏍᎩ ᎠᏥᏅᏏᏓᏍᏗ ᎹᎵᎦ ᏧᏙᎢᏛ ᎨᏒᎩ.


text:
ᏌᏩᏂᏃ ᏈᏓ ᎤᏍᏓᏩᏛᏒᎩ ᏥᏌ, ᎠᎴ ᎾᏍᏉ ᏅᏩᏓᎴ ᎠᏓᏍᏓᏩᏗᏙᎯ. ᎾᏍᎩ ᎠᏓᏍᏓᏩᏗᏙᎯ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎤᎦᏔᎯ ᎨᏒᎩ; ᎢᏧᎳᎭᏃ ᏥᏌ ᎤᏂᏴᎸᎩ ᎤᏜᏅᏛᎢ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎦᏁᎸᎢ.


text:
ᏈᏓᏍᎩᏂ ᏙᏱᏗᏢᏉ ᎦᎶᎯᏍᏗᏱ ᎤᎴᏅᎩ. ᎿᏉᏃ ᎾᏍᎩ Ꮎ ᏐᎢ ᎠᏓᏍᏓᏩᏗᏙᎯ, ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎤᎦᏔᎯ, ᎤᏄᎪᏨᎩ, ᏭᎵᏃᎮᏔᏅᎩ ᎠᏛ ᎦᎶᎯᏍᏗᏱ ᎠᎦᏘᏯ, ᎠᎴ ᎤᏴᏔᏅᎩ ᏈᏓ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎬᏂᎨᏒ ᎦᏥᏬᏁᏗᏍᎬᎩ ᎡᎶᎯ; ᏯᏃᎩᏳ ᏕᎦᏕᏲᎲᏍᎬ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏕᎪᏢᏩᏗᏒᎢ. ᎠᎴ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎾᎿ ᎠᏂᏧᏏ ᏂᎪᎯᎸ ᏧᏂᎳᏫᏦᎯᏍᏗᏱ ᏥᎩ, ᎤᏕᎵᏛᏃ ᎥᏝ ᎪᎱᏍᏗ ᎠᏆᏛᏅᎯ ᏱᎩ.


text:
ᎿᏉ ᎧᏱᏆ ᎦᏁᎸ ᎤᎾᏘᎿᏫᏛᎲᎩ ᏥᏌ, ᏗᎫᎪᏙᏗᏱ ᏭᎾᏘᏅᏍᏔᏅᎩ; ᎠᎴ ᏑᎾᎴ ᎨᏒᎩ. ᎤᏅᏒᏍᎩᏂ ᎥᏝ ᏗᎫᎪᏙᏗᏱ ᏳᏁᏅᏎᎢ, ᎦᏓᎭ ᏱᏃᏣᎵᏍᏓ ᎠᏁᎵᏍᎬᎩ, ᎧᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ ᏧᎾᎵᏍᏓᏴᏗᏱ ᎤᏂᏰᎸᏒᎩ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏒᎩ; ᎠᎩᎬᏫᏳᎯ ᎨᏒ ᎥᏝ ᎠᏂ ᎡᎶᎯ ᎡᎯᏱᎩ. ᎢᏳᏃ ᎠᎩᎬᏫᏳᎯ ᎨᏒ ᎠᏂ ᎡᎶᎯ ᎡᎯ ᏱᎨᏎᎢ, ᏗᏆᏤᎵᎦ ᏱᏚᎾᏟᏴᎨᎢ, ᏞᏍᏗ ᎠᏂᏧᏏ ᏗᎨᏥᏲᎯᏎᎸᎩ, ᏳᏁᎵᏎᎢ. ᎠᏎᏃ ᎥᏝ ᎠᏂ ᎤᏓᎴᏅᎯ ᏱᎩ ᎠᎩᎬᏫᏳᎯ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᏆᎴᏗ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏣᎬᏫᏳᎯᏰᎧᏂ? ᏥᏌ ᎯᎠ ᏄᏪᏒᎩ; ᏰᎵ ᏂᏫ, ᎠᎩᎬᏫᏳᎯᏰᏃ ᎠᏴ. ᏥᏃᎮᏍᎩ ᎤᏙᎯᏳᏒ ᎢᏯᏆᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏆᏕᏅᎩ, ᎠᎴ ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎡᎶᎯ ᎠᎩᎾᏄᎪᏥᎸᎩ. ᎾᏂᎥ ᎤᏙᎯᏳᏒ ᎤᏂᎨᏳᎯ ᎠᎾᏛᎩᏍᎪ ᏥᏁᎬᎢ.


text:
ᏆᎴᏗ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎦᏙ ᎤᏍᏗ ᎤᏙᎯᏳᏒ ᎨᏒᎢ? ᎾᏍᎩᏃ ᎯᎠ ᏄᏪᏒ, ᏔᎵᏁ ᎤᏄᎪᏨᎩ ᎠᏂᏧᏏ ᎠᏂᏙᎾᎥ ᏭᎶᏒᎩ, ᎠᎴ ᎯᎠ ᏫᏂᏚᏪᏎᎸᎩ; ᎥᏝ ᏱᏥᏩᏘᎭ ᎤᏍᎦᏅᏨᎢ.


text:
ᎿᏉᏃ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᎴ ᏗᎾᏓᏂᏱᏍᎩ ᎬᏩᎪᎲ, ᎤᏁᎷᏅᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᎯᏯᏛᎥᎦ! ᎯᏯᏛᎥᎦ! ᏆᎴᏗ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏂᎯ ᎡᏣᏗᎿᏫᏛ, ᎠᎴ ᎡᏣᏛᎥᎦ; ᎠᏴᏰᏃ ᎥᏝ ᏱᏥᏩᏘᎭ ᎤᏍᎦᏅᏨᎢ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎥᏝ ᏱᎨᏣᎭ ᏰᎵ ᎠᏴ ᎪᎱᏍᏗ ᏍᏋᏁᏗᏱ, ᎦᎸᎳᏗ ᏅᏓᏰᏣᎵᏍᎪᎸᏓᏁᎸᎯ ᏂᎨᏒᎾ ᏱᎩ. ᎾᏍᎩ ᎢᏳᏍᏗ, ᎠᏴ ᏗᎩᏲᏒᎯ ᏂᎯ ᏗᏣᏲᎯᏎᎸᎯ ᎤᏟ ᎡᏉᎯᏳ ᎤᏍᎦᏅᏨ.


text:
ᎾᎯᏳᏃ ᎢᏳᏓᎴᏅᏛ ᏆᎴᏗ ᎤᏲᎸᎩ ᎥᎤᏪᎪᏗᏱ. ᎠᏎᏃ ᎠᏂᏧᏏ ᎤᏁᎷᏅᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᎢᏳᏃ ᎯᎠ ᎠᏍᎦᏯ ᎢᎯᏯᎧᏅᎭ ᎥᏝ ᏏᏌ ᎢᏍᏓᎵᎢ ᏱᎦᎨᏎᏍᏗ. ᎩᎶ ᎤᎬᏫᏳᎯ ᎠᏤᎸᏍᎩ, ᎧᏁᎬ ᏏᏌ ᎠᏡᏗᏍᎪᎢ.


text:
ᎠᏎᏃ ᎤᏁᎷᏅᏉ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎯᎷᎦ! ᎯᎷᎦ! ᎯᏯᏛᎥᎦ! ᏆᎴᏗ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏓᏥᏯᏛᏂᏍᎪ ᎢᏣᏤᎵᎦ ᎤᎬᏫᏳᎯ? ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎯᎠ ᏄᏂᏪᏎᎸᎩ; ᎥᏝ ᏲᎩᎧᎭ ᎤᎬᏫᏳᎯ, ᏏᏌ ᎤᏩᏒ!


text:
ᎿᏉᏃ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎠᏂᏧᏏ ᏧᎾᏤᎵᎦ ᎯᎠ ᏄᏂᏪᏎᎸᎩ ᏆᎴᏗ; ᏞᏍᏗ ᎯᎠ ᎢᏨᏁᎸ ᏦᏪᎳᏅᎩ; ᎤᎬᏫᏳᎯ ᎠᏂᏧᏏ ᎤᎾᏤᎵᎦ; ᎯᎠᏍᎩᏂ; ᎠᎩᎬᏫᏳᎯ ᎠᏂᏧᏏ ᎤᎾᏤᎵᎦ ᎠᏗᏍᎬᎩ.


text:
ᎿᏉᏃ ᎠᏂᏯᏫᏍᎩ, ᏥᏌ ᎬᏩᏛᏅ, ᏚᏂᏁᏒᎩ ᏧᏄᏬ, ᏅᎩ ᏂᏚᏂᏛᎩ, ᏌᏉ ᎢᎦᏛᎯ ᎠᏏᏴᏫ ᎠᏯᏫᏍᎩ ᎤᏤᎵᎦ ᏄᏅᏁᎸᎩ; ᎠᎴ ᎾᏍᏉ ᎭᏫᏂ ᎤᏄᏬᎥᎯ. ᎾᏍᎩ ᎭᏫᏂ ᎠᏄᏬ ᎥᏝ ᎦᏰᏫᏛ ᏱᎨᏎᎢ, ᏂᎬ ᎬᏅᎯ ᎨᏒᎩ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᎠ ᏂᏚᎾᏓᏪᏎᎸᎩ; ᏞᏍᏗ ᎢᎩᏣᎦᎸᎢᏒᎩ, ᎢᏓᏎᎯᏉᏍᎩᏂ ᎢᏓᏙᎴᎰᎯ ᎤᏤᎵᎦ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ; ᎤᏙᎯᏳᏗᏱ ᎪᏪᎸ ᎯᎠ ᏥᏂᎬᏅ; ᏚᏂᏯᏙᎸᎩ ᏗᏆᏄᏬ, ᎠᎴ ᎠᏆᏄᏬᏍᏗ ᎤᎾᏌᏍᏔᏅᎩ. ᎯᎠ ᎾᏍᎩ ᎠᏂᏯᏫᏍᎩ ᏄᎾᏛᏁᎸᎩ.


text:
ᎠᏂᏧᏏᏃ ᎤᏂᏔᏲᏎᎸᎩ ᏆᎴᏗ ᏗᏂᏅᏍᎨᏂ ᏗᎨᏥᏍᏆᎵᏎᏗᏱ ᎠᎴ ᏗᎨᏥᏁᏍᏗᏱ, ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎠᏛᏅᎢᏍᏙᏗᏱ ᎢᎦ ᎨᏒᎢ, ᏞᏍᏗ ᎤᎾᏙᏓᏆᏍᎬ ᏱᏗᎦᏕᏍᏗ ᎠᏁᎵᏍᎬᎩ, ᎾᏍᎩᏰᏃ ᎤᎾᏙᏓᏆᏍᎬ ᎢᎦ ᎦᎸᏉᏗᏳ ᎨᏒᎩ.


text:
ᎾᏍᎩᏃ ᏄᎵᏍᏔᏂᏙᎸ ᎣᏂ ᏦᏩ ᎠᎵᎹᏗᏱ ᎡᎯ, ᏥᏌ ᎠᏍᏓᏩᏗᏙᎯ ᎨᏒᎩ, ᎠᏎᏃ ᎤᏕᎵᏛᏉ ᎠᏂᏧᏏ ᏓᏍᎦᎢᎲᎢ ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ, ᎾᏍᎩ ᏦᏩ ᎤᏔᏲᏎᎸᎩ ᏆᎴᏗ ᎤᏁᏍᏗᏱ ᏥᏌ ᎠᏰᎸᎢ. ᏆᎴᏗᏃ ᎤᎵᏍᎪᎸᏓᏁᎸᎩ. ᎰᏩᏃ ᎤᎷᏨᎩ ᎤᏁᏒᎩ ᏥᏌ ᎠᏰᎸᎢ.


text:
ᎿᏉᏃ ᏚᏍᏆᎸᏔᏅᎩ, ᏌᏩᏂ ᏈᏓ ᏭᎷᏤᎸᎩ, ᎠᎴ ᎾᏍᏉ ᏐᎢ ᎠᏓᏍᏓᏩᏗᏙᎯ, ᎾᏍᎩ ᏥᏌ ᎤᎨᏳᎯ, ᎯᎠ ᏫᏂᏚᏪᏎᎸᎩ; ᎤᏂᏁᏒ ᎤᏂᏄᎪᏫᏒ ᎤᎬᏫᏳᎯ ᎠᏤᎵᏍᏛᎢ, ᎠᎴ ᎥᏝ ᏲᏥᎦᏔᎭᏭᏂᏅᏅᎢ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎯᎨᏴ, ᎦᏙᏃ ᏙᎭᏠᏱᎭ? ᎦᎪ ᎯᏲᎭ? ᎠᏫᎡᏗᏱ ᎣᏍᏛ ᎢᏳᏩᎿᏕᎩ ᎤᏪᎵᏒᎩ, ᎯᎠ ᏄᏪᏎᎸᎩ; ᎯᏍᎦᏯ, ᎢᏳᏃ ᏂᎯ ᎯᎾᏫᏛᎮᏍᏗ, ᏍᎩᏃᎲᏏ ᏫᏅᏅᎢ, ᎠᏴᏃ ᏓᏥᎾᏫᏛᎯ.


text:
ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏞᏍᏗ ᏍᏆᏒᏂᎸᎩ, ᏝᏰᏃ ᎠᏏ ᎡᏙᏙᏱ ᏫᏯᏆᎵᏌᎳᏓᏅ; ᎮᎾᏉᏍᎩᏂ ᎣᏣᎵᏅᏟ ᏗᏂᏅᎢ, ᎯᎠᏃ ᏫᏂᎩᏪᏏ; ᎡᏙᏙᏱ ᎠᏆᎵᏌᎳᏓᏂᏗ ᎠᎴ ᏂᎯ ᎢᏥᏙᏙᏱ; ᎠᏆᏤᎵᎦ ᎤᏁᎳᏅᎯᏱ, ᎠᎴ ᎢᏣᏤᎵᎦ ᎤᏁᎳᏅᎯᏱ.


text:
ᎿᏉᏃ ᎾᎯᏳ ᎢᎦ ᎤᏒᎢ, ᎠᎴᏂᏍᎬ ᏑᎾᏙᏓᏆᏍᏗ ᎨᏒᎢ, ᎦᎶᎯᏍᏗᏱ ᏓᏍᏚᎲᎩ ᎠᎾᏓᏍᏓᏩᏗᏙᎯ ᏓᏂᎳᏫᎥᎢ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬ ᏓᏂᏍᎦᎢᎲ ᎠᏂᏧᏏ, ᎤᎷᏨᎩ ᏥᏌ, ᎠᏰᎵ ᎤᎴᏅᎩ, ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏅᏩᏙᎯᏯᏛ ᎢᏣᏤᎵᎦ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏂᏐᎢ ᎠᎾᏓᏍᏓᏩᏗᏙᎯ ᎯᎠ ᏂᎬᏩᏪᏎᎸᎩ; ᎣᏥᎪᎥ ᎤᎬᏫᏳᎯ. ᎠᏎᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎥᏝ ᏴᎦᎪᎢᏳᎲᎦ ᎬᏂ ᏧᏪᏰᏂ ᏴᎩ ᏚᏰᎸᏒ ᏱᏓᎩᎪᎲ, ᎠᎴ ᏥᏰᏌᏛ ᏯᏋᏔᏅ ᏯᎩᏃᏟᏍᏔᏅ ᏴᎩ ᏚᏰᎸᏒᎢ, ᎠᎴ ᎠᏍᏆᎨᏂ ᏯᏆᏐᎾᏛ.


text:
ᏧᏁᎵᏁᏃ ᎢᎦ ᏔᎵᏁ ᎬᏩᏍᏓᏩᏗᏙᎯ ᎠᏂᏯᎥᎩ ᎦᎵᏦᏕ, ᎠᎴ ᏓᎻ ᎨᎸᎩ. ᏥᏌ ᎤᎷᏨᎩ, ᏗᎦᎶᎯᏍᏗᏱ ᏓᏍᏚᎲᎩ, ᎠᏰᎵ ᎤᎴᏅᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᏅᏩᏙᎯᏯᏛ ᎢᏣᏤᎵᎦ ᎨᏎᏍᏗ.


text:
ᎿᏉᏃ ᎯᎠ ᏄᏪᏎᎸᎩ ᏓᎻ; ᎡᏍᎦ ᎡᏅᎦ ᎯᏰᏌᏛᎢ, ᏘᎪᎵᏯ ᏗᏉᏰᏂ, ᎠᎴ ᎡᏍᎦ ᎡᏅᎦ ᏦᏰᏂ ᏥᏍᏆᎨᏂ ᏩᏐᎾᏓ, ᎠᎴ ᏞᏍᏗ ᏃᎯᏳᎲᏍᎬᎾ ᏱᎨᏎᏍᏗ, ᎰᎯᏳᎲᏍᎩᏍᎩᏂ ᎨᏎᏍᏗ.


text:
ᏌᏩᏂ ᏈᏓ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᏥᎦᏯᎷᏂ. ᎯᎠ ᏅᎬᏩᏪᏎᎸᎩ; ᎠᏴ ᎾᏍᏉ ᏓᏕᏏ. ᎤᏁᏅᏒᎩ, ᎩᎳᏉᏃ ᎢᏴᏛ ᏥᏳᎯ ᎤᎾᏣᏅᎩ; ᎾᎯᏳᏃ ᏒᏃᏱ ᎥᏝ ᎪᎱᏍᏗ ᏳᏂᏂᏴᎮᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏓᏍᏓᏩᏗᏙᎯ ᏥᏌ ᎤᎨᏳᎯ ᎯᎠ ᏄᏪᏎᎸᎩ ᏈᏓ; ᎤᎬᏫᏳᎯ ᎾᏍᎩ. ᎿᏉᏃ ᏌᏩᏂ ᏈᏓ ᎤᏛᎦᏅ ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᎨᏒᎢ, ᎦᏚᎢ ᎤᏄᏬᏍᏗ ᎤᏓᏠᏍᏔᏅᎩ ᎨᏒᎢ, ᎦᏚᎢ ᎤᏄᏬᏍᏗ ᎤᏓᏠᏍᏔᏅᎩ, ᏂᏚᏄᏩᎥᎾᏰᏃ ᎨᏒᎩ, ᎠᎴ ᎥᏓᎵ ᏭᎵᏔᏗᏅᏒᎩ.


text:
ᎠᏂᏐᎢᏃ ᎠᎾᏓᏍᏓᏩᏗᏙᎯ ᏥᏳ ᎤᎾᏦᏛᎩ, ᎤᏂᎷᏨᎩ, ᎥᏝᏰᏃ ᎢᏅᎯᏳ ᏱᎨᏎ ᏙᏱ, ᏔᎵᏧᏈᏉ ᎢᏯᎵᎩᏳᏍᏈᏛ ᎢᏴᏛ ᏅᏩᏍᏛᎩ, ᎠᎦᏯᎷᏗ ᎠᏣᏗ ᎠᎧᎵᏬᎯ ᎠᏂᎾᏏᏁᎲᎩ.


text:
ᏌᏩᏂ ᏈᏓᏭᏣᏅᎩ, ᎠᎴ ᎪᏱ ᏭᎾᏏᏃᎸᎩ ᎠᎦᏯᎷᏗ ᎠᎧᎵᏬᎯ ᏣᏁᏆ ᎠᏣᏗ, ᏍᎪᎯᏧᏈ ᎯᏍᎩᏍᎪᎯ ᏦᎢᎦᎵ ᎤᏂᎥᎩ. ᎾᏍᎩᏒᎦᏃ ᎾᏂᎥᎩ ᎠᏎᏃ ᎠᎦᏯᎷᏗ ᎥᏝ ᏳᏲᏤᎢ.


text:
ᎿᏉᏃ ᎤᎾᎵᏍᏓᏴᏃᏅ, ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ ᏌᏩᏂ ᏈᏓ; ᏌᏩᏂ, ᏦᎾ ᎤᏪᏥ, ᏂᎯ ᎤᏟ ᏂᏍᎩᎨᏳᎭ ᎡᏍᎦᏉ ᎯᎠ? ᎯᎠ ᏄᏪᏎᎸᎩ; ᎥᎥ, ᏣᎬᏫᏳᎯ, ᎯᎦᏔᎭ ᎬᎨᏳᎢᏳ ᎨᏒᎢ. ᎯᎠ ᏄᏪᏎᎸᎩ; ᎨᎮᎶᎮᏍᏗ ᏗᏆᏤᎵᎦ ᎤᏂᏃᏕᎾ ᎠᏂᎩᎾ.


text:
ᏔᎵᎾ ᎯᎠ ᏅᎤᏪᏎᎸᎩ; ᏌᏩᏂ, ᏦᎾ ᎤᏪᏥ, ᏍᎩᎨᏳᎭᏧ? ᎯᎠ ᏄᏪᏎᎸᎩ; ᎥᎥ ᏣᎬᏫᏳᎯ, ᎯᎦᏔᎭ ᎬᎨᏳᎢᏳ ᎨᏒᎢ. ᎯᎠ ᏄᏪᏎᎸᎩ; ᏕᎮᎶᎮᏍᏗ ᏗᏆᏤᎵᎦ ᎤᏂᏃᏕᎾ.


text:
ᏦᎢᏁ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏌᏩᏂ, ᏦᎾ ᎤᏪᏥ, ᏍᎩᎨᏳᎭᏧ? ᏈᏓ ᎤᏲᎢᏳ ᎤᏓᏅᏓᏛᎩ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᏦᎢᏁ ᏍᎩᎨᏳᎭᏧ ᎤᏬᏎᎸᎢ. ᎯᎠᏃ ᏄᏪᏎᎸᎩ; ᏣᎬᏫᏳᎯ ᏂᎦᎥ ᎪᎱᏍᏗ ᎯᎦᏔᎭ, ᎯᎦᏔᎭ ᎬᎨᏳᎢᏳ ᎨᏒᎢ. ᏥᏌ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏕᎮᎶᎮᏍᏗ ᏗᏆᏤᎵᎦ ᎤᏂᏃᏕᎾ.


text:
ᎤᏙᎯᏳᎯᏯ, ᎤᏙᎯᏳᎯᏯ ᎯᎠ ᏂᎬᏪᏎᎭ; ᎯᏫᏅ ᏥᎨᏒᎩ ᏨᏒ ᎭᏓᏠᎯᎲᎩ, ᎠᎴ ᏣᏚᎵᏍᎬ ᎮᏙᎲᎩ; ᏣᏛᏐᏅᎯᏍᎩᏂ ᎨᏎᏍᏗ ᏙᏔᏐᎸᏔᏂ, ᏅᏩᏓᎴᏃ ᏓᏣᏠᎵ, ᎠᎴ ᏂᏣᏚᎵᏍᎬᎾ ᎨᏒ ᏮᏓᏣᏘᏅᏍᏔᏂ.


text:
ᏈᏓᏃ ᎤᎦᏔᎲᏒ ᎤᎪᎲᎩ ᎠᏓᏍᏓᏩᏗᏒᎩ ᏥᏌ ᎤᎨᏳᎯ ᎠᏓᏍᏓᏩᏗᏙᎯ, ᎾᏍᎩ ᎤᏍᏛᎦᎸᏅᎯ ᏥᏌ ᎦᏁᏥᏱ ᎠᎾᎵᏍᏓᏴᎲᏍᎬᎢ, ᎠᎴ ᎯᎠ ᎢᏳᏪᏛ ᏥᎩ; ᏣᎬᏫᏳᎯ, ᎦᎪ ᎾᏍᎩ ᏣᏡᏗᏍᎩ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᎾᏓᏅᏟ ᎠᏁᎲ ᎤᏰᎵᏒᎩ ᎯᎠ ᎾᏂᏪᏍᎬᎢ, ᎾᏍᎩ ᎠᏓᏍᏓᏩᏗᏙᎯ ᎥᏝ ᎠᏛᏲᎱᏏ. ᎠᏎᏃ ᏥᏌ ᎥᏝ ᎠᏛᏲᎱᏏ ᎥᏝ ᏳᏬᏎᎴᎢ, ᎯᎠᏉᏍᎩᏂ ᏄᏪᏎᎸᎩ; ᎢᏳᏃ ᏥᎷᏨᎭ ᎬᏗᏍᎩ ᎡᎮᏍᏗ ᏯᏇᎵᏒ, ᎦᏙ ᎾᏍᎩ ᏨᏙᏗ.


text:
ᎾᏍᎩ ᎾᏍᏉ ᎬᏃᏛ ᎬᏂᎨᏒ ᏂᏚᏛᏁᎴᎢ, ᎤᎩᎵᏲᏨᎯ ᏂᎨᏎᎢ, ᎤᏣᏘ ᏄᏜᏏᏛᏒᎾ ᎠᏙᎵᏲᏨᎯ ᏂᎨᏎᎢ, ᎤᏣᏘ ᏄᏜᏏᏛᏒᎾ ᎠᏙᎴᎰᎯᏍᏙᏗ ᎬᏗᏍᎬᎢ, ᏅᎦᏍᎪᎯ ᏧᏒᎯᏛ ᎬᏩᎪᎲᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎬᏩᎪᎲᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒ ᎤᎬᏩᎵ ᎤᏃᎮᎸᎯ ᏂᎨᏎᎢ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏄᏂᏪᏎᎢ; ᎢᏥᏍᎦᏯ ᎨᎵᎵ ᎢᏤᎯ, ᎦᏙᏃ ᎢᏥᏙᎾᎠ ᎦᎸᎳᏗ ᏫᏙᏥᎧᎿ? ᎾᏍᎩ ᎯᎠ ᏥᏌ ᏤᏥᏯᏅᏏ ᎦᎸᎳᏗ ᏥᏫᎦᎶᎯ ᎾᏍᎩᏯ ᏅᏛᏛᏁᎵ ᏓᎦᎷᏥ ᏤᏥᎪᏩᏛ ᎦᎸᎳᏗ ᏥᏫᎦᎶᎯ.


text:
ᎤᏂᏴᎸᏃ, ᎤᎾᎩᎳᏫᏎ ᎦᎸᎳᏗ ᎧᏅᏑᎸ ᏭᏂᏴᎴᎢ, ᎾᎿᏃ ᎠᏂᏁ ᏈᏓ ᎠᎴ ᏥᎻ ᎠᎴ ᏣᏂ ᎠᎴ ᎡᏂᏗ, ᏈᎵᎩᏃ ᎠᎡ ᏓᎻ, ᏆᏓᎳᎻ ᎠᎴ ᎹᏚ, ᏥᎻᏃ ᎡᎵᏈ ᎤᏪᏥ ᎠᎴ ᏌᏩᏂ ᎠᏏᎶᏗ, ᏧᏓᏏᏃ ᏥᎻ ᏗᎾᏓᏅᏟ.


text:
ᎢᏥᏍᎦᏯ ᏗᏓᏓᏅᏟ, ᎯᎠ ᎪᏪᎸ ᎠᏎ ᎤᏙᎯᏳᏗ ᎨᏒᎩ, ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏕᏫ ᎠᎰᎵ ᏧᏩᏔᏁ ᏧᏁᏤ ᏧᏓᏏ ᎠᏥᏃᎮᏍᎬᎢ, ᎾᏍᎩ ᏧᏘᏂᏙᎸᎯ ᏥᏌ ᏥᎬᏩᏂᏱᏍᎬᎩ;


text:
ᎯᎠᏰᏃ ᏂᎬᏅ ᎪᏪᎳ ᏗᎧᏃᎩᏍᏗ ᎪᏪᎵᎯ, "ᎦᏁᎸᎢ ᏅᏔ ᏫᏂᎦᎵᏍᏓ, ᎠᎴ ᏞᏍᏗ ᎩᎶ ᎾᎿ ᏳᏁᎳᏕᏍᏗ;" ᎠᎴ ᎾᏍᏉ ᎯᎠ ᏂᎬᏅ, "ᏧᎸᏫᏍᏓᏁᏗ ᎨᏒ ᏅᏩᏓᎴ ᏩᎩᏍᏓ."


text:
ᏣᏂ ᏥᏓᏓᏬᏍᎬᎢ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᎬᏂ ᎾᎯᏳ ᎢᎦ ᏣᏥᏌᎳᏓᏅ ᏤᎩᏯᏅᎡᎸᎩ, ᎾᏍᎩ ᎯᎠ ᎠᏂᏍᎦᏯ ᎠᏎ ᏌᏉ ᎠᏑᏰᏍᏍᏗ, ᎾᏍᎩ ᎢᎨᎳᏗᏓᏍᏗᏱ ᎤᏃᎮᏗᏱ ᏥᏌ ᏕᎤᎴᎯᏌᏅ ᎢᏗᏃᎮᏍᎬᎢ.


text:
ᎿᏉᏃ ᏈᏓ ᏌᏚ ᎢᏯᏂᏛ ᎠᏂᏙᎾᎥ ᎦᏙᎬᎢ, ᎠᏍᏓᏯ ᎤᏁᏤ ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎢᏥᏍᎦᏯ ᎢᏥᏧᏏ, ᎠᎴ ᏂᎦᏛ ᏥᎷᏏᎵᎻ ᎢᏤᎯ, ᎯᎠ ᎾᏍᎩ ᎢᏣᏅᏖᏍᏗ, ᎠᎴ ᎢᏣᏛᏓᏍᏓ ᏥᏁᎬᎢ.


text:
"ᎯᎠᏃ ᏅᏓᎦᎵᏍᏔᏂ ᎤᎵᏍᏆᎸᏗ ᎨᏎᏍᏗ ᎠᏗᎭ ᎤᏁᎳᏅᎯ, ᎾᎦᎥ ᎤᏇᏓᎵ ᎨᏒ ᎠᏆᏓᏅᏙ ᏓᏥᏯᏐᏅᏰᎵ, ᏗᏤᏥᏃ ᎠᏂᏍᎦᏯ ᎠᎴ ᏗᏤᏥ ᎠᏂᎨᏴ ᎠᎾᏙᎴᎰᏍᎨᏍᏗ, ᎠᏂᏫᏅᏃ ᏗᏣᏤᎵ ᎤᎾᏁᎳᏫᏎᎮᏍᏗ, ᏧᎾᏛᏐᏅᎯᏃ ᏗᏣᏤᎵ ᎠᎾᏍᎩᏓᏒᎥᏍᎨᏍᏗ;


text:
ᎢᏥᏍᎦᏯ ᎢᏏᎵ ᏧᏪᏥ ᎢᏣᏛᏓᏍᏓ ᎯᎠ ᏥᏁᎬᎢ. ᏥᏍ ᎾᏎᎵᏗ ᎡᎯ ᏥᎨᏒᎩ ᎤᏁᎳᏅᎯ ᎬᏂᎨᏒ ᎢᏳᏩᏁᎸᎯ ᎢᏤᎲᎢ, ᎾᏍᎩ ᎤᏩᏗᏍᎬ ᎤᏓᎴᎯ ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᎠᎴ ᎤᏰᎸᏛᎢ ᏥᏚᎸᏫᏍᏓᏁᎸᎩ ᎢᏤᎲᎢ, ᎾᏍᎩ ᏂᎯ ᎾᏍᏉ ᏥᏥᎦᏔᎭ,


text:
ᎾᏍᎩ ᎯᎠ ᎠᏙᎴᎰᏍᎬᎢ ᏅᏧᎵᏍᏙᏔᏁᎢ, ᎦᎶᏁᏛ ᏧᎴᎯᏐᏗ ᎨᏒ ᎤᏃᎮᎴᎢ, ᎾᏍᎩ ᎤᏓᏅᏙ ᏫᏂᏓᏥᏲᎯᏎᎸᎾ ᎨᏒ ᏧᏂᏲᎱᏒᎯ ᎤᎾᏤᎵᎪᎯ, ᎠᎴ ᎾᏍᎩ ᎤᏇᏓᎵ ᏄᎪᏒᎾ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎠᎦᏘᏏ ᎤᏬᏰᏂ ᎤᏩᏔᏅᎯ ᎤᏌᎳᏓᏅᎯ ᎨᏒᎢ, ᎠᎴ ᎠᎦᏴᎵᎨ ᎤᏚᎢᏍᏓᏁᎸᎯ ᎨᏒ ᏧᏁᏗᏱ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎤᏪᏐᏅᏴ ᎯᎠ ᎪᎯ ᏥᏥᎪᏩᏘᎭ ᎠᎴ ᏥᏣᏛᎩᎭ.


text:
ᏂᏚᎩᏨᏂᏒᏃ ᏌᏉ ᎢᎦᎦᏛ ᎠᏁᏙᎮ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᎦᏚ ᎠᏂᎬᎭᎷᏯᏍᎨ ᏓᏓᏁᎳᏗᏒᎢ, ᏓᎾᎵᏍᏓᏴᎲᏍᎨ ᎠᎾᎵᎮᎵᎨ ᎠᎴ ᎤᏠᎾᏍᏗ ᏄᏓᏑᏴᎾ ᎨᏎ ᏧᏂᎾᏫᏱ,


text:
ᎩᎶᏃ ᎢᏳᏍᏗ ᎠᏍᎦᏯ ᎠᏲᏅᎵ ᏂᎨᏎ ᎤᏕᏅ -ᎠᏥᏁᎨᎢ, ᎾᏍᎩ ᏂᏚᎩᏨᏂᏒ ᎠᏂᎧᎲᏍᎨ ᎦᎶᎯᏍᏗᏳᎶᏗ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎾᏍᎩ ᎦᎶᎯᏍᏗᏱ ᎤᏬᏚᎯ ᏥᏕᎤᏙᎥ, ᏧᏚᎳᏕᏗᏱ ᎤᏂᏰᎸᏎ ᎠᏂᏴᎯᎯ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ.


text:
ᏈᏓᏃ ᎤᏙᎴᎰᏒ ᎯᎠ ᏂᏚᏪᏎᎴ ᏴᏫ; ᎢᏥᏍᎨᏯ ᎢᏏᎵ ᏧᏪᏥ, ᎦᏙᏃ ᎢᏥᏍᏆᏂᎪᏍᎦ ᎯᎠ, ᎠᎴ ᎦᏙᏃ ᎤᏯᏅᏒᎯ ᏙᏍᎩᎾᎦᏂᎭ, ᎾᏍᎩᏯ ᎣᎩᏅᏒ ᏙᎩᎾᎵᏂᎬᎬ ᎠᎴ ᎣᏍᏙᏏᏳ ᎨᏒ ᏦᎩᏅᏔᏃᎢ ᎯᎠ ᎬᏪᏓᏍᏗ ᏥᏃᏍᏛᏁᎶᎢ.


text:
ᎤᏁᎳᏅᎯ ᎡᏆᎭᎻ ᎤᏤᎵᎦ, ᎠᎴ ᎡᏏᎩ ᎤᏤᎵᎦ, ᎠᎴ ᏤᎦᏈ ᎤᏤᎵᎦ, ᎤᏁᎳᏅᎯ ᏗᎩᎦᏴᎵᎨ ᎤᎾᏤᎵᎦ, ᎤᎸᏉᏔᏅ ᎤᏪᏥ ᏥᏌ, ᎾᏍᎩ ᏂᎯ ᏥᏕᏥᏲᏒᎩ ᎠᎴ ᏤᏣᏓᏱᎸᎩ ᎠᎦᏔᎲ ᏆᎴᏗ, ᎾᏍᎩ ᎤᏪᎪᏗᏱ ᏧᏰᎸᏒᎩ.


text:
ᎠᎴ ᎾᏍᎩ ᏚᏙᎥ ᎪᎯᏳᏗ ᎨᏒ ᎤᏧᎵᏍᏙᏔᏅ ᎾᏍᎩ ᏚᏙᎢ ᎤᎵᏂᎪᎯᏍᏔᏅ ᎯᎠ ᎠᏍᎦᏯ, ᎾᏍᎩ ᏤᏥᎪᏩᏘᎭ ᎠᎴ ᏤᏥᎦᏔᎭ; ᎥᎥ, ᎪᎯᏳᏗ ᎨᏒ ᎾᏍᎩ ᎤᏤᎵᎦ ᎯᎠ ᎤᏃᏍᏛᏯ ᏄᏩᏁᎸ ᎢᏥᎦᏔᎲ ᏂᎦᏛ.


text:
ᎾᏍᎩ ᎦᎸᎳᏗ ᏭᏕᏗ ᏥᎩ ᎬᏂ ᎾᎯᏳ ᎠᎵᏱᎶᎸᎭ ᎤᏓᏁᏟᏴᏍᏗ ᎨᏒ ᏂᎦᎥᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏁᏨᎯ ᏥᎩ ᏧᏤᎵ ᎨᏥᎸᏉᏗ ᎠᎾᏙᎵᎰᏍᎩ ᏗᏂᎰᎵ ᏧᏩᏔᏅᎯ ᏥᎩ, ᎡᎶᎯ ᏧᏙᏢᏅᎢ ᏅᏓᎬᏩᏓᎴᏅᏛ.


text:
ᎼᏏᏰᏃ ᎯᎠ ᏂᏕᎤᏪᏎᎴ ᏗᎩᏙᏓ; "ᏱᎰᏩ ᎢᏣᏁᎳᏅᎯ ᏓᏥᎾᏄᎪᏫᏎᎵ ᎠᏙᎴᎰᏍᎩ ᎢᏣᎵᏅᏟ ᎨᏒ ᏓᎦᎾᏄᎪᏥ, ᎠᏴ ᎾᏍᎩᏯᎢ; ᎾᏍᎩ ᏓᏰᏣᏛᏓᏍᏓᏁᎵ ᏂᎦᎥ ᎢᏥᏁᏤᏗ ᎨᏒᎢ.


text:
ᏂᎯ ᎠᎾᏙᎴᎰᏍᎩ ᏧᏁᏥ, ᎠᎴ ᎾᏍᏉ ᏧᏪᏥ ᎠᏚᎢᏍᏛᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᏗᎩᎦᏴᎵᎨ ᏚᏚᎢᏓᏁᎸᎢ, ᎯᎠ ᏥᏄᏪᏎᎴ ᎡᏆᎭᎻ; "ᎠᎴ ᏂᎯ ᏣᏁᏢᏔᏅᎯ ᎨᏒ ᏅᏓᎦᎵᏍᏙᏔᏂ ᏄᎾᏓᎴᏒ ᏴᏫ ᎡᎶᎯ ᎠᏁᎯ ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎨᏎᏍᏗ."


text:
ᎢᏥᎦᏔᎮᏍᏗ ᏂᎦᏛ, ᎠᎴ ᏂᎦᏛ ᎢᏏᎵ ᎠᏁᎯ ᎠᏂᎦᏔᎮᏍᏗ ᎾᏍᎩ ᏕᎤᏙᎥ ᏥᏌ ᎦᎶᏁᏛ ᎾᏎᎵᏗ ᏤᎲᎩ, ᎾᏍᎩ ᏓᏓᎿᏩᏍᏛ ᏤᏣᏛᏅᎩ, ᎤᏁᎳᏅᎯ ᏥᏕᎤᎴᏔᏅ ᎤᏲᎱᏒᎢ, ᎾᏍᎩ ᏄᏩᏂᏌᏅ ᎯᎠ ᎠᏍᎦᏯ ᎤᏗᏩᏒᎯ ᏥᎦᏙᎦ ᏕᏥᎧᏅᎢ.


text:
ᎤᎾᏙᎴᎰᏒᏃ ᏈᏓ ᎠᎴ ᏣᏂ ᎾᏂᏯᎦᎢᎲᎾ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏓᏅᏖᎸ ᎪᏪᎵ ᏂᏓᏂᏏᎾᏒᎾ ᎠᎴ ᎾᏂᎦᏔᎿᎥᎾ ᎨᏒᎢ, ᎤᏂᏍᏆᏂᎪᏎᎢ, ᎠᎴ ᏚᏃᎵᏤ ᎾᏍᎩ ᏥᏌ ᎤᏁᏙᎸᎯ ᎨᏒᎢ.


text:
ᎠᏏᏃ ᏙᎤᏂᏍᎦᏨ, ᏚᏂᎧᏁᎢ, ᎤᎾᏠᏤ ᎪᎱᏍᏗ ᎬᏩᏂᏍᏛᏗᏍᏗ ᎨᏒᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᎤᏂᏣᏘ ᏴᏫ, ᏂᎦᏛᏰᏃ ᎠᏂᎸᏉᏗᏍᎨ ᎤᏁᎳᏅᎯ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᎾᏍᎩ ᏄᎵᏍᏔᏅᎢ.


text:
ᎾᏍᎩᏃ ᎤᎾᏛᎦᏅ ᏌᏉ ᎢᎦᎦᏛ ᎤᏁᎳᏅᎯ ᎤᏂᏌᎳᏓᏁᎴ ᎠᏂᏁᎬᎢ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᏣᎬᏫᏳᎯ, ᏂᎯ ᏣᏁᎳᏅᎯ, ᏗᏦᏢᏅᎯ ᎦᎸᎶᎢ ᎠᎴ ᎡᎶᎯ ᎠᎴ ᎠᎺᏉᎯ ᎠᎴ ᏂᎦᏛ ᎾᎿ ᎠᏁᎯ;


text:
ᏥᏅᏩᏍᏛᏉ ᏝᏍᎪ ᏣᏤᎵᎦᏯ ᏱᎨᏎᎢ? ᏣᎾᏗᏅᏃ ᏝᏍᎪ ᏱᏣᎮ ᎭᏓᏅᏖᏍᎬᏉ ᎢᏨᏁᏗᏱ? ᎦᏙᏃ ᎯᎠ ᎾᏍᎩ ᏂᎤᏍᏗ ᎢᏦᏢᏅ ᏣᎾᏫᏱ? ᎥᏝᏍᎩᏂ ᏴᏫᏉ ᏱᎩᏯᏥᎪᏁᎸ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎯᏯᏥᎪᏁᎸ.


text:
ᎿᏉᏃ ᏈᏓ ᎯᎠ ᏄᏪᏎᎴᎢ; ᎦᏙᏃ ᏥᏍᏓᎵᎪᏅ ᎡᏍᏗᎪᎵᏰᏗᏱ ᎤᎬᏫᏳᎯ ᎤᏤᎵ ᎠᏓᏅᏙ? ᎬᏂᏳᏉ ᎠᏉ ᎦᎶᎯᏍᏗᏱ ᏧᎾᎳᏏᏕᏂ ᏣᏰᎯ ᎬᏩᏂᏌᏅᎯ, ᎾᏍᎩᏃ ᏂᎯ ᏛᎨᏣᎾᏫᏛᎯ.


text:
ᎾᏍᎩᏃ ᎤᎾᏛᎦᏅ ᎩᎳ ᏧᎩᏥᏍᎪᎢ ᏭᏂᏴᎴ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᎴ ᏚᎾᏕᏲᏁᎢ. ᎠᏎᏃ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎤᎷᏨ, ᎠᎴ ᎾᏍᎩ ᎬᏩᎵᎪᏁᎯ, ᏚᏂᏟᏌᏁ ᏗᏂᎳᏫᎩ, ᎠᎴ ᏂᎦᏛ ᏄᏂᎬᏫᏳᏌᏕᎩ ᎢᏏᎵ ᏧᏪᏥ ᏧᎾᏤᎵᎦ, ᎠᎴ ᏫᏓᏯᏅᎲ ᎤᎾᏓᏅᏎ ᏗᏓᏍᏚᏗᏱ.


text:
ᎯᎠ ᏄᏂᏪᏎᎢ; ᏗᏓᏍᏚᏗᏱ ᎤᏙᎯᏳᎯ ᎣᎩᏩᏛᎲ ᎤᎵᏂᎩᏗᏳ ᎠᏍᏚᎲᎩ, ᎠᎴ ᎠᏂᎦᏘᏯ ᎠᏂᏙᎾᎥ ᏙᏱᏗᏢ ᎦᎶᎯᏍᏗᏳᎶᏗ, ᎠᏎᏃ ᎣᎩᏍᏚᎢᏒ ᎥᏝ ᎩᎶ ᏲᏥᏩᏛᎮ ᏱᏯᎡᎢ.


text:
ᎿᏉᏃ ᎠᏥᎸ-ᎨᎶᎯ ᎠᎴ ᎣᏍᏛ ᎢᏳᏩᎿᏕᎩ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ, ᎾᏍᎩ ᎯᎠ ᏄᏂᏪᏒ ᎤᎾᏛᎦᏅ, ᎾᏍᎩ ᎤᎾᏓᏅᏖᏔᏁᎢ, ᎭᏢ ᏮᏛᏍᏗᏥ ᎯᎠ, ᎤᏁᎵᏎᎢ.


text:
ᎯᎠ ᏄᏪᏎᎢ; ᏝᏍᎪ ᎤᎵᏂᎩᏛᏯ ᏱᏨᏅᏍᏓᏕᎴ ᏗᏣᏕᏲᏗᏱ ᎯᎠ ᎾᏍᎩ ᏕᎤᏙᎥ ᎢᏨᏙᏗᏱ? ᎬᏂᏳᏉᏃ ᏕᏣᏕᏲᎲᏍᎬ ᏥᎷᏏᎵᎻ ᎢᏥᎧᎵᎢᏍᏔᏅ, ᎠᎴ ᎾᏍᎩ ᎠᏍᎦᏯ ᎤᎩᎬ ᎣᎩᏍᏛᏗᏍᏗᏱ, ᎢᏥᏰᎸᎭ.


text:
ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏌᎳᏓᏅ ᎠᎦᏘᏏ ᎤᏪᏰᏂ ᎤᏩᏔᏅ, ᎤᎬᏫᏳᎯ ᎠᎴ ᎠᏓᏍᏕᎵᏍᎩ ᎢᏳᎵᏍᏙᏗᏱ, ᎢᏏᎵ ᏧᏁᏗᏱ ᏧᏂᏁᏟᏴᏍᏗᏱ ᏚᎾᏓᏅᏛᎢ, ᎠᎴ ᎦᎨᏥᏁᏗᏱ ᎤᏂᏍᎦᏅᏨᎢ.


text:
ᎢᎸᎯᏳᏰᏃ ᏧᎾᏄᎪᏤ ᏚᏓᏏ ᎩᎶ ᏧᏤᎸᏎᎢ, ᎠᏂᏍᎦᏯ ᏅᎩᏧᏈ ᎢᏴᏛ ᎢᏯᏂᏛ ᏥᎬᏩᎵᎪᏁᎴᎢ, ᎾᏍᎩ ᏣᏥᎴᎢ, ᎠᎴ ᏂᎦᏛ ᎾᏍᎩ ᎬᏬᎯᏳᏅᎯ ᏧᎾᏗᎦᎴᏲᏤ ᎠᎴ ᏥᏫᎬᏩᏂᏲᏙᎴᏉ.


text:
ᎿᏉᏃ ᎯᎠ ᏂᏨᏪᏎᎭ, ᏞᏍᏗ ᏗᏣᎵᏌᎳᏁᎸ ᎯᎠ ᎠᏂᏍᎦᏯ, ᎤᎾᏁᎳᎩ ᏗᏤᎵᏏ, ᎢᏳᏰᏃ ᎯᎠ ᎠᎾᏓᏅᏖᏍᎬ ᎠᎴ ᏚᏂᎸᏫᏍᏓᏁᎲ ᏴᏫᏉ ᏅᏓᏳᏓᎴᏅᎯ ᎢᎨᏎᏍᏗ, ᎤᏲᏥᏓᏍᏗᏉ;


text:
ᎾᎯᏳᏃ ᎠᏃᎯᏳᎲᏍᎩ ᎤᏂᏣᏔᏅ, ᎠᏂᎪᎢ ᎤᏂᏬᏂᎯᏍᏗ ᎠᏂᏬᏂᏍᎩ ᎪᎱᏍᏗ ᏓᏃᏎᎮ ᎠᏂᏈᎷ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏂᎨᎦᎦᏌᏯᏍᏛᎾ ᎨᏒ ᏧᎾᏤᎵ ᎠᏂᎨᏴ ᏧᏃᏑᎶᏨᎯ ᏂᏚᎩᏨᏂᏒ ᎠᏂᏯᏙᎯᎲᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎢᏓᏓᏅᏟ, ᎢᏨᏒ ᎢᏣᏓᏡᎬ ᏗᏣᏑᏯᎩ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᎠᏂᏍᎦᏯ ᎣᏍᏛ ᎨᏥᏃᎮᏍᎩ ᎤᏂᎧᎵᏨᎯ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎠᎴ ᎠᏂᎦᏔᎾᎢ, ᎾᏍᎩ ᎯᎠ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ ᏗᎦᏲᏥᏁᏤᏗ.


text:
ᎾᏍᎩᏃ ᏄᏂᏪᏒᎢ ᎣᏏᏳ ᎤᏂᏰᎸᏁ ᏂᎦᏛ ᎤᏂᏣᏘ ᎨᏒᎢ; ᎠᎴ ᎤᎾᏑᏰᏎ ᏍᏗᏫ, ᎠᏍᎦᏯ ᎤᎧᎵᏨᎯ ᎤᏬᎯᏳᏒ ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ, ᎠᎴ ᏈᎵᎩ ᎠᎴ ᏉᎪᎳ ᎠᎴ ᎾᎨᎾ ᎠᎴ ᏔᎹᏂ ᎠᎴ ᏆᎻᎾ ᎠᎴ ᏂᎩ ᎥᏘᎣᎩ ᎡᎯ ᎠᏂᏧᏏ ᏧᎵᎪᏁᎸᎯ;


text:
ᎿᏉᏃ ᏚᎾᎴᏁ ᎩᎶ ᎢᏳᎾᏍᏗ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᏁᎳ ᎠᏂᎵᏆᏗᏂ ᏥᏂᎳᏫᎢᏍᏗᏱ ᏥᏚᏙᎥ, ᎠᎴ ᏌᎵᏂ ᎠᏂᎯ, ᎠᎴ ᎡᎵᏱᎩ ᎠᏁᎯ, ᎠᎴ ᏏᎵᏏᏱ ᎠᏁᎯ, ᎠᎴ ᎡᏗᏱ ᎠᏁᎯ, ᎤᎾᎵᏃᎮᏔᏁᏍᏗᏫ.


text:
<n>[ᏍᏗᏫᏃ]</n> ᎯᎠ ᏄᏪᏎᎢ; ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ ᎠᎴ ᏗᎩᏙᏓ, ᎢᏣᏛᏓᏍᏓ. ᎤᏁᎳᏅᎯ ᎠᏥᎸᏉᏗ ᎬᏂᎨᏒ ᏄᏛᏁᎴ ᎢᎩᏙᏓ ᎡᏆᎭᎻ ᎾᏍᎩ ᎾᎯᏳ ᎺᏌᏆᏕᎻ ᏤᎮᎢ, ᎠᏏᏉ ᎨᎳᏂ ᎾᏁᎳᏗᏍᎬᎾ ᏥᎨᏎᎢ;


text:
ᎠᎴ ᎤᏭᏓᎴᏍᎨ ᏂᎦᏛ ᎤᏲ ᏄᎵᏍᏓᏁᎵᏕᎬᎢ, ᎠᎴ ᎤᏁᎴ ᎣᏏᏳ ᎠᎦᏓᏅᏖᏗᏱ ᎠᎴ ᎠᎦᏔᎿᎢᏳ ᎨᏒ ᎠᎦᏔᎲ ᏇᎵᏲ ᎤᎬᏫᏳᎯ ᎢᏥᏈᏱ, ᎠᎴ ᏄᎬᏫᏳᏌᏕᎩ ᏄᏩᏁᎴ ᎢᏥᏈᏱ, ᎠᎴ ᏂᎦᏛ ᎦᏁᎸᎢ.


text:
"ᎠᏴ ᎤᏁᎳᏅᎯ ᏗᏣᎦᏴᎵᎨ ᎤᎾᏤᎵᎦ, ᎤᏁᎳᏅᎯ ᎡᏆᎭᎻ ᎤᏤᎵᎦ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎡᏏᎩ ᎤᏤᎵᎦ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏤᎦᏈ ᏅᏤᎵᎦ." ᎣᏏᏃ ᎤᏪᎿᏪᎢ, ᎠᎴ ᎤᏍᎦᎴ ᎤᎪᎵᏰᏗᏱ.


text:
ᎾᏍᎩ ᎯᎠ ᎼᏏ ᏧᏂᏲᎢᏎᎴ ᎯᎠ ᏥᏄᏂᏪᏎᎢ, ᎦᎪ ᏂᏣᎬᏫᏳᏌᏕᎩ ᎠᎴ ᏚᎪᏗᏍᎩ ᏣᎧᏅ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏅᏎ ᏄᎬᏫᏳᏌᏕᎩ ᎠᎴ ᎤᏄᏓᎴᏍᎩ ᏄᏩᏁᎴ ᎤᏩᏔᏁ ᏗᎧᎿᏩᏗᏙᎯ ᎬᏂᎨᏒ ᎢᏳᏛᏁᎸᎯ ᎤᏪᏲᏓᏛᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᎼᏏ ᎾᏍᎩ ᎯᎠ ᏥᏂᏚᏪᏎᎴ ᎢᏏᎵ ᏧᏪᏥ; ᎤᎬᏫᏳᎯ ᎢᏣᏁᎳᏅᎯ ᏓᏥᎾᏄᎪᏫᏎᎵ ᎠᏙᎴᎰᏍᎩ ᎢᏣᎵᏅᏟ ᎨᏒ ᏓᎦᎾᏄᎪᏥ ᎠᏴ ᎾᏍᎩᏯᎢ; ᎾᏍᎩ ᏓᏰᏣᏛᎦᏁᎵ.


text:
ᎯᎠ ᎾᏍᎩ Ꮎ ᏥᎨᎳᏗᏙᎮ ᎤᎾᏓᏡᏩᏕᎬ ᎢᎾᎨᎢ, ᏔᎵ ᏧᏛᏗᏕᎨ ᏗᎧᎿᏩᏗᏙᎯ ᎾᏍᎩ ᏧᏁᏤᎴ ᎣᏓᎸ ᏌᎾᏱ, ᏥᎨᎳᏗᏙᎮ ᎠᏁᏙᎲ ᏗᎩᎦᏴᎵᎨᎢ, ᎾᏍᎩ ᎾᏍᏉ ᏥᏓᏥᏲᎯᏎᎴ ᎠᏛᏂᏗᏍᏙᏗ ᎧᏃᎮᏛ ᎠᏴ ᎢᎩᏁᏗ.


text:
ᎿᏉᏃ ᎤᏁᎳᏅᎯ ᎤᎦᏔᎲᏎᎢ, ᎠᎴ ᎤᎾᏁᎳᎩ ᏫᏓᏂᎸᏉᏓ ᎤᏂᏣᏘ ᎦᎸᎶ ᎠᏁᎯ ᏚᏪᎵᏎᎴᎢ, ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ ᎠᎾᏙᎴᎰᏍᎩ ᏧᏃᏪᎳᏅᎯ; "ᏂᎯ ᎢᏏᎵ ᏏᏓᏁᎸᎯ ᎨᏒᎢ, ᏥᎪ ᏕᏍᎩᏃᎮᎸ ᏗᎸᎯ ᎦᎾᏝᎢ ᎠᎴ ᎠᏥᎸ-ᎨᎳᏍᏗ ᏅᎦᏍᎪᎯ ᏥᎾᏕᏘᏴ ᎢᎾᎨᎢ?


text:
ᎢᏥᎲᏒᏰᏃ ᎦᎵᏦᏙᏗ ᎼᎳᎩ ᎤᏤᎵᎦ ᎠᎴ ᎤᏁᎳᏅᎯ ᎢᏥᏰᎸᎯ ᎴᎻᏈᏂ ᎤᏤᎵᎦ ᏃᏈᏏ, ᏗᏟᎶᏍᏔᏅᎯ ᎾᏍᎩ ᏗᏦᏢᏅᎯ ᏗᏣᏓᏙᎵᏍᏓᏁᏗ; ᏓᏗᎶᏂᏃ ᎤᏗᏗᏢ ᏫᏙᏓᏨᏯᎧᏂ."


text:
ᎦᏙ ᎤᏍᏗ ᎾᏍᎩ Ꮎ ᎠᎾᏙᎴᎰᏍᎩ ᎨᏒ ᏗᏥᎦᏴᎵᎨ ᎥᏝ ᎤᏲ ᎢᏳᏅᏁᎸᎯ ᏱᎩ? ᎠᎴ ᏕᎤᏂᎸ ᎤᎾᏙᎴᎰᏛᎯ ᎬᏂᎨᏒ ᎢᏳᏅᏁᎸᎯ ᎤᎷᎯᏍᏗᏱ ᎾᏍᎦᏅᎾ ᎾᏍᎩ ᏂᎯ ᎡᏥᎶᏄᎡᎸᎯ ᎠᎴ ᎡᏥᎸᎯ ᏥᏄᎵᏍᏔᏅ;


text:
ᏐᎳᏃ ᎣᏏᏳᎠᏰᎸᏍᎨ ᎠᏥᎸᎢ. ᎾᎯᏳᏃ ᎤᎶᏘ ᎤᏲ ᏂᎨᎬᎾᏕᎨ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏈᎬ ᏘᎷᏏᎵᎻ; ᎠᎴ ᏂᎦᏛ ᎤᎾᏗᎦᎵᏲᏤ ᏂᎬᎾᏛ ᏧᏗᏱ ᎠᎴ ᏌᎺᎵᏱ, ᎨᏥᏅᏏᏛ ᎤᏅᏒ.


text:
ᎩᎶᏍᎩᏂᏃᏅ ᎢᏳᏍᏗ ᎠᏍᎦᏯ ᎾᎿ ᎡᎮ ᏌᏩᏂ ᏧᏙᎢᏛ ᎾᏍᎩ ᎾᎿ ᎦᏚᎲ ᎠᏙᏅᏗ ᏧᎸᏫᏍᏓᏁᎸᎯ ᎨᏎᎢ, ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᏧᏓᏅᏓᏗᏍᏔᏅᎯ ᎨᏎ ᏌᎺᎵᏱ ᎠᏁᎯ, ᎩᎶ ᎢᏳᏍᏗ ᎠᏥᎸᏉᏗ ᎠᏤᎸᏍᎨᎢ.


text:
ᏚᎴᏅᏃ ᎤᏪᏅᏎᎢ; ᎬᏂᏳᏉᏃ ᎠᏍᎦᏯ ᎢᏘᏱᏈ ᎡᎯ ᎠᏳᎾᎦ ᎠᏥᎸᏉᏗ ᎤᏁᏤᎸᎯ ᎬᏗᏏ ᎠᎨᏴ ᎤᎬᏫᏳᎯ ᎢᏗᎣᏈ ᎠᏁᎯ ᎤᎾᏤᎵᎦ, ᎾᏍᎩ ᏂᎦᏛ ᎠᏕᎸ ᎤᎦᏘᏕᎯ, ᎾᏍᎩ ᎤᏓᏙᎵᏍᏔᏂᎸᎯ ᎨᏎ ᏥᎷᏏᎵᎻ,


text:
ᎯᎠ ᎾᏍᎩ ᎪᏪᎸ ᎠᎪᎵᏰᏍᎨᎢ; "ᎠᎦᏘᏃᎸᎩ ᎠᏫ ᎤᏃᏕᎾ ᎾᏍᎩᏯ ᏗᎯᏍᏗᏱ, ᎠᎴ ᎾᏍᎩᏯ ᎠᎩᎾ ᎠᏫ ᎡᎳᏪ ᏥᎨᏐ ᎬᏩᏍᏰᏍᎩ ᎠᏂᎦᏔᎲᎢ, ᎾᏍᎩᏯ ᎥᏝ ᏳᏍᏚᎢᏎ ᎠᎰᎵ.


text:
ᎠᎴ ᏚᏔᏲᏎᎴ ᎪᏪᎵ ᏧᏅᏍᏗ ᏕᎹᏍᎦ ᏗᎦᏚᎲ ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎾᏍᎩᏃ ᎢᏳ ᏱᏚᏩᏛᎲ ᎩᎶ ᎾᏍᎩ ᎢᏳᏍᏗ ᏗᏂᎧᎿᏩᏕᎩ, ᎠᏂᏍᎦᏯ ᎠᎴ ᎠᏂᎨᏴ, ᎾᏍᎩ ᏗᎨᎦᎸᎢᏛ ᏧᏘᏃᎯᏍᏗᏱ ᏥᎷᏏᎵᎻ.


text:
ᎡᏂᎾᏯᏃ ᎤᏪᏅᏎᎢ, ᎠᎴ ᎠᏓᏁᎸ ᎤᏴᎴᎢ, ᏚᏏᏔᏛᏃ ᎯᎠ ᏄᏪᏎᎢ; ᏐᎳ ᎥᎩᏅᏟ, ᎤᎬᏫᏳᎯ ᏥᏌ, ᎾᏍᎩ ᎬᏂᎨᏒ ᏥᏂᏣᏛᏁᎴ ᏔᎢᏒᎢ ᏗᎩᏅᏒ ᎥᏣᎪᏩᏛᏗᏱ ᎠᎴ ᏣᎧᎵᎢᏍᏗᏱ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ.


text:
ᏂᎦᏛᏃ ᎤᎾᏛᎦᏅᎯ ᎤᏂᏍᏆᏂᎪᏎᎢ, ᎠᎴ ᎯᎠ ᏄᏂᏪᏎᎢ; ᏝᏍᎪ ᎾᏍᎩ ᎯᎠ ᏱᎩ ᏥᏓᎩᎵᏲᎢᏍᏙᏗᏍᎬ ᏥᎷᏏᎵᎻ ᎯᎠ ᏕᏅᏙᎥ ᎠᏂᏁᎢᏍᏗᏍᎩ? ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏂ ᎤᎷᏨᎩ, ᎾᏍᎩ ᏧᎸᏍᏗ ᏫᏚᏘᏃᎮᏗᏱ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ.


text:
ᎿᏉᏃ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡ Ꭼ ᏅᏩᏙᎯᏯᏛ ᏄᎾᎵᏍᏓᏁᎴ ᏂᎬᎾᏛ ᏧᏗᏱ ᎠᎴ ᎨᎵᎵ ᎠᎴ ᏌᎺᎵᏱ, ᎠᎴ ᎨᎦᎵᏂᎪᎯᏍᏔᏁᎢ, ᎠᎴ ᎠᎾᎢᏎ ᎾᎿ ᎦᎾᏰᎯᏍᏗ ᎨᏒ ᎤᎬᏫᏳᎯ, ᎠᎴ ᎣᏍᏛ ᎤᏂᎦᎵᏍᏓᏗᏍᎬ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ, ᎠᏂᏁᏉᎨᎢ.


text:
ᏈᏓᏃ ᏚᎴᏅ ᏚᏍᏓᏩᏛᏎᎢ; ᎤᎷᏨᏃ ᎦᎸᎳᏗ ᎧᏅᏑᎸ ᏫᎬᏩᏴᏔᏁᎢ; ᏂᎦᏛᏃ ᎠᏂᎨᏴ ᏧᏃᏑᎶᏨᎯ ᎦᏙᎬ ᎾᎥ ᎠᏂᏙᎾᎡ ᏓᏂᏴᎨᎢ, ᎠᎴ ᏓᏂᎾᏄᎪᏫᏍᎨ ᎭᏫᏂ ᏗᏄᏬ ᎠᎴ ᏧᏓᎴᏅᏛ ᏗᏄᏬ ᎾᏍᎩ ᏓᎩ ᏧᏪᏰᏫᏒᎯ ᎠᏏ ᎤᏁᎳᏗᏙᎮᎢ.


text:
ᏈᏓᏃ ᏂᎦᏛ ᏚᏄᎪᏫᏒ ᏚᎵᏂᏆᏅᏁ ᎠᎴ ᎤᏓᏙᎵᏍᏔᏁᎢ, ᏕᏛᏅᏃ ᎢᏗᏢ ᏭᎦᏔᎲᏍᏔᏅ, ᏓᏈᏗ ᏔᎴᎲᎦ, ᎤᏛᏁᎢ. ᏚᏍᏚᎢᏎᏃ ᏗᎦᏙᎵ, ᏈᏓᏃ ᎤᎪᎲ, ᎤᏗᏛᎮ ᎤᏪᏁᎢ.


text:
ᏚᎧᎿᏅᏃ ᎠᎴ ᎤᏍᎦᎸ ᎯᎠ ᏄᏪᏎᎢ; ᎦᏙᎢ, ᏣᎬᏫᏳᎯ. ᎯᎠᏃ ᏄᏪᏎᎴᎢ; ᎭᏓᏙᎵᏍᏗᏍᎬ ᎠᎴ ᎭᏓᏁᎸᎥᏍᎬ ᏚᎵᏌᎳᏓᏅ ᎠᏅᏓᏗᏍᏙᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ.


text:
ᏗᎧᎿᏩᏗᏙᎯᏃ ᎤᏓᏅᏒ ᎾᏍᎩ ᎧᏂᎵᏯ ᎤᏬᏁᏔᏅᎯ, ᎠᏂᏔᎵ ᏫᏚᏯᏅᎮ ᎠᏓᏁᎸ ᏧᏅᏏᏓᏍᏗ ᎠᎴ ᏌᏉ ᎠᏯᏫᏍᎩ ᎤᏁᎳᏅᎯ ᎠᏓᏙᎵᏍᏓᏁᎯ ᏂᎪᎯᎸ ᎬᏩᎦᏘᏗᏍᎩ ᎨᏒ ᎨᎳ.


text:
ᎤᎪᎮᏃ ᎦᎸᎳᏗ ᎤᎵᏍᏚᎢᏛ ᎨᏎᎢ, ᎠᎴ ᎪᎱᏍᏗ ᎢᏳᏍᏗ ᎠᏖᎵᏙ ᎡᎳᏗ ᏅᏧᏍᏗᏗᏎ, ᎾᏍᎩᏯ ᎡᏆ ᎠᏄᏬ, ᏅᎩ ᏚᏅᏏᏴ ᏥᏕᎦᎸᎣᎢ, ᎾᏍᎩᏃ ᎡᎳᏗ ᎢᎬᏁᎸᎯ ᏥᎨᏐ ᎡᎶᎯ ᎢᏴᏛ.


text:
ᎠᏏᏉᏃ ᏈᏓ ᎠᏓᏅᏖᏍᎨ ᏄᏍᏛ ᎦᏛᎬ ᎾᏍᎩ ᎤᏁᎳᏫᏎᎸᎢ, ᎬᏂᏳᏉ ᎠᏂᏫᏅ ᎾᏍᎩ ᎧᏂᎵᏯ ᏂᏙᏓᏳᏅᏒᎯ ᎤᎾᏓᏛᏛᏅᎯ ᎨᏎ ᏌᏩᏂ ᎦᏁᎸᎢ, ᎠᎴ ᎠᏂᏙᎾᎡ ᎦᎶᎯᏍᏗᏳᎶᏗ;


text:
ᎯᎠᏃ ᏄᏂᏪᏎᎢ; ᎧᏂᎵᏯ ᎠᏍᎪᎯᏧᏈ ᏗᏘᏂᏙᎯ, ᏚᏳᎯᏛ ᎢᏯᏛᏁᎯ ᎠᏍᎦᏯ ᎠᎴ ᎤᏁᎳᏅᎯ ᎦᎾᏰᏍᎩ, ᎠᎴ ᎣᏍᏛ ᎬᏩᏃᎮᏍᎩ ᎾᏂᎥ ᏑᎾᏓᎴᎩ ᎨᏒ ᎠᏂᏧᏏ, ᎤᏁᏤᎸᎩ ᎦᎸᏉᏗ ᏗᎧᎿᏩᏗᏙᎯ, ᎤᏓᏅᏍᏗᏱ ᏧᏪᏅᏒ ᏫᏣᎷᎯᏍᏗᏱ ᎠᎴ ᎯᏬᏂᏍᎬ ᎤᏛᎪᏗᏱ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎢᏥᎦᏔᎭᏉ ᎤᏓᏅᏍᏙᏒᎯ ᎨᏒ ᎩᎶ ᎠᏧᏏ ᎤᏁᏓᏍᏗᏱ ᎠᎴ ᎤᏩᏛᏗᏱ ᎩᎶ ᏅᏩᏓᎴ ᏴᏫ; ᎠᏎᏃ ᎤᏁᎳᏅᎯ ᎬᏂᎨᏒ ᎾᏋᏁᎸ ᎠᏴᎩᎶ ᏴᏫ ᎦᏓᎭ ᎠᎴ ᎾᏥᏅᎦᎸᎥᎾ ᏥᏲᏎᏗ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎧᏂᎵᏯᏃ ᎯᎠ ᏄᏪᏎᎢ; ᏅᎩ ᏄᏒᎭ ᎠᎹᏟ ᎬᏍᎬᎩ ᎯᎠ ᎢᏳ ᎧᎳᏩᏗᏒ ᎢᏯᏍᏗ, ᏦᎢᏃ ᎢᏳᏟᎶᏛ ᎧᎳᏩᏗᏒ ᎦᏓᏙᎵᏍᏗᏍᎬ ᏥᏁᎸᎢ, ᎬᏂᏳᏉᏃ ᎠᏍᎦᏯ ᏗᎬᏩᎸᏌᏓ ᏧᏄᏫ ᎢᎬᏱᏢ ᎠᏆᎴᏁᎸᎩ.


text:
ᎰᏩᏃ ᎩᎳᏉ ᎢᏴᏛ ᎠᏆᏓᏅᏒᎩ ᏪᏣᏯᏅᏗᏱ; ᎣᏏᏳᏃ ᏂᏣᏛᏁᎸ ᏥᎷᎩ. ᎿᏉᏃ ᏂᎦᏛ ᎠᏂ ᎣᏤᏙᎭ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ, ᎣᎦᏛᏅᎢᏍᏗ ᎣᎦᏛᎪᏗᏱ ᏂᎦᎥ ᎤᏁᎳᏅᎯ ᏣᏁᏤᎸᎯ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎤᎾᎳᏅᎯ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎠᎴ ᎤᎵᏂᎩᏛ ᎨᏒ ᏥᏚᎶᏁᏔᏁ ᏥᏌ ᎾᏎᎵᏗ ᎡᎯ, ᎾᏍᎩ ᏤᏙᎲ ᎣᏍᏛ ᏚᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᏕᎧᏅᏫ-Ꭼ ᏂᎦᏛ ᎤᏲ ᎢᏳᏅᎿᏕᎩ ᎠᏍᎩᎾ; ᎤᏁᎳᏅᎯᏰᏃ ᏚᎧᎿᏩᏗᏙᎲᎩ.


text:
ᎥᏝ ᏂᎦᏛ ᏴᏫ, ᎠᏂᏃᎮᏍᎩᏉᏍᎩᏂ ᎤᏅᏒ ᎤᏁᎳᏅᎯ ᎦᏳᎳ ᏗᎬᏩᏑᏰᏛ ᏥᎨᏒᎩ, ᎾᏍᎩ ᎠᏴ ᎢᏧᎳᎭ ᎣᎦᎵᏍᏓᏴᏅᎯ ᎠᎴ ᏦᎦᏗᏔᎲᎯ ᎾᏍᎩ ᎤᏲᎱᏒ ᏧᎴᎯᏌᏅᎯ ᏥᏂᎨᏎᎢ.


text:
ᏦᏈ ᎦᏚᎲ ᎨᏙᎲᎩ ᎦᏓᏙᎵᏍᏗᏍᎬᎩ; ᏩᎦᎵᎰᏃ ᎾᏍᎩᏯ ᎾᏆᎵᏍᏓᏁᎸ ᎠᏆᏁᎳᏫᏎᎸᎩ, ᎠᏖᎵᏙ ᎠᎩᎪᎲᎩ ᎡᎳᏗ ᏅᏓᏳᏍᏗᏗᏒᎩ, ᎡᏆ ᎠᏄᏬ ᎾᏍᎩᏯᎢ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ, ᏅᎩ ᏂᏚᏅᏏᏴ ᏥᏚᏂᏂᏴᏐᎢ; ᎠᎴ ᎠᏴ ᎠᎩᎷᏤᎸᎩ.


text:
ᎤᎾᏛᎦᏅᏃ ᎾᏍᎩ ᎡᎳᏪ ᎤᏅᏁᎢ, ᎠᎴ ᎤᏂᎸᏉᏔᏁ ᎤᏁᎳᏅᎯ, ᎯᎠ ᏄᏂᏪᏎᎢ: ᎾᏍᏉᎧᏂ ᎤᏁᎳᏅᎯ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏕᎤᏁᎸ ᏚᎾᏓᏅᏛ ᏧᏂᏁᏟᏴᏍᏗᏱ ᎬᏂᏛ ᏩᎵᏱᎶᎯᎯ.


text:
ᎤᏩᏛᎲᏃ ᎥᏖᎣᎩ ᎤᏘᏃᎴᎢ. ᎯᎠᏃ ᏄᎵᏍᏔᏁᎢ, ᎾᏍᎩ ᏑᏕᏘᏴᏛ ᎾᎿ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏓᏂᎳᏫᎨᎢ, ᎠᎴ ᎤᏂᏣᏖ ᏴᏫ ᏚᏁᏲᏁᎢ. ᎥᏖᎣᎩᏃ ᎢᎬᏱᏱ ᎠᏂᎦᎶᏁᏛ ᎨᎪᏎᎴ ᎠᏃᎯᏳᎲᏍᎩ.


text:
ᎠᏏᏴᏫᏃ ᎾᏍᎩ ᎡᎩᏩ ᏧᏙᎢᏛ ᏕᎤᎶᏁᎢ, ᎠᏓᏅᏙ ᎤᏩᏔᏁ ᎬᏂᎨᏒ ᏄᏩᏁᎴ ᎤᏣᏘ ᎤᎪᏄᎶᎯᏍᏗᏱ ᏂᎬᎾᏛᎢ; ᎾᏍᎩᏃ ᏄᎵᏍᏔᏅᎩ ᎾᎯᏳ ᎦᎶᏗ ᏏᏌ ᎤᎬᏫᏳᎯ ᏥᎨᏒᎩ.


text:
ᎤᏂᏴᎲᏃ ᏗᏓᏍᏚᏗᏱ ᎤᏴᏔᏁᎢ, ᎠᎴ ᏚᏲᎯᏎᎴ ᏅᎩ ᎢᏗᏂᎢᏛ ᏅᎩ ᏄᎾᏓᏡᎬ ᎠᏂᏯᏫᏍᎩ ᎬᏩᎦᏘᏗᏍᎩ, ᎧᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ ᎤᎶᏐᏅᎯ ᏴᏫ ᏧᎾᏄᎪᏫᏎᏗᏱ ᎤᏰᎸᏎᎢ.


text:
ᎾᎯᏳᏃ ᎡᎶᏛ ᎤᎾᏄᎪᏫᏏᏗᏎᎢ, ᎾᎯᏳ ᏒᏃᏱ ᏈᏓ ᎦᎵᎮ ᎠᏰᎵ ᎠᏂᏔᎵ ᎠᏂᏯᏫᏍᎩ ᏓᏂᏅᎬᎢ, ᏔᎵ ᏧᏓᏕᏒᏛ ᏓᎦᎸᏍᏕᎢ, ᎠᏂᎦᏘᏯᏃ ᎦᎶᎯᏍᏗᏳᎶᏗ ᎠᏂᏂ ᎠᏂᏯᏫᏍᎨ ᏗᏓᏍᏚᏗᏱ.


text:
ᎬᏂᏳᏉᏃ ᏗᎧᎿᏩᏗᏙᎯ ᎤᎬᏫᏳᎯ ᎤᏤᎵ ᎤᎴᏂᎴ ᎦᏅᎬᎢ, ᎢᎦᏃ ᎤᏙᏤ ᏗᏓᏍᏚᏗᏱ; ᎤᏩᏂᎸᏃ ᏈᏓ ᎠᏍᏆᎨᏂ, ᏕᎤᎴᏔᏁᎢ, ᎯᎠ ᏄᏪᏎᎢ; ᏔᎴᎲᎦ ᏞᎩᏳ. ᏧᏓᏕᏒᏛᏃ ᏚᏓᏕᏛᏃ ᏚᏙᎠᏎ ᏧᏬᏰᏂ.


text:
ᎢᎬᏱᏱᏃ ᎠᎴ ᏔᎵᏁ, ᎠᏂᏯᏫᏍᎬ ᎤᏂᎶᏒ ᏭᏂᎷᏤ ᏔᎷᎩᏍᎩ ᏗᏍᏚᏛ ᏗᎦᏚᎲ ᏫᎦᎾᏄᎪᎢᏍᏗᏍᎬᎢ, ᎾᏍᎩ ᎤᏩᏒᏉ ᎤᎾᎵᏍᏚᎢᎡᎴᎢ. ᎤᏂᏄᎪᏨᏃ ᏌᏉ ᎦᎳᏅᏛ ᎤᏂᎶᏎᎢ, ᎩᎳᏉᏃ ᎢᏴᏛ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏓᏓᎴᏔᏁᎢ.


text:
ᏈᏓᏃ ᎤᏓᏅᏘᏌᏅ ᎯᎠ ᏄᏪᏎᎢ; ᎿᏉ ᎦᏙᎴᎣᎯ ᎤᏙᎯᏳᎯ ᎤᎬᏫᏳᎯ ᏧᏅᏒ ᎤᏤᎵ ᏗᎧᎿᏩᏗᏙᎯ, ᎠᎴ ᎠᏇᏓᎴᏒ ᎡᎶᏛ ᏥᏓᎩᏂᏴᏒᎢ, ᎠᎴ ᏂᎦᎥ ᎤᏚᎩ ᏧᏅᏒ ᎠᏂᏧᏏ.


text:
ᎠᏎᏃ ᎤᏪᏰᏂ ᎤᏖᎸᏅ ᎡᎳᏪ ᎤᏅᏗᏱ, ᏚᏃᏁᎴ ᏄᎵᏍᏔᏅ ᎤᎬᏫᏳᎯ ᎤᏄᎪᏫᏒ ᏗᏓᏍᏚᏗᏱ. ᎠᎴ ᎯᎠ ᏄᏪᏎᎢ; ᎯᎠ ᎾᏍᎩ ᏫᏗᏥᏃᎲᏏ ᏥᎻ ᎠᎴ ᏦᏣᏓᏅᏟ. ᎤᏄᎪᏤᏃ ᎢᎸᎯᏢ ᏭᎶᏎᎢ.


text:
ᎡᎶᏛᏃ ᏚᏔᎳᏬᎯᏎᎴ ᏓᏯ ᎠᎴ ᏌᏙᏂ ᎠᏁᎯ; ᎠᏎᏃ ᏌᏉ ᎢᎦᎦᏛ ᎬᏩᎷᏤᎴᎢ, ᎤᎾᎵᎢᏛᏃ ᏆᎳᏍᏓ ᎤᎬᏫᏳᎯ ᎤᏂᏏᏗᏱ ᎠᏥᎦᏘᏗᏍᏗ, ᏙᎯᏱ ᎢᏳᏅᏁᏗᏱ ᎤᏂᏔᏲᏎᎴᎢ; ᎤᎾᏤᎵᎪᎯᏰᏃ ᎤᎵᏍᏕᎸᏙᏕ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎪᎯ.


text:
ᏧᎾᏁᎶᏗᏃ ᎥᏘᎣᎩ ᏧᎾᏓᏡᎬ ᎠᏁᎲᎩ ᎩᎶ ᎢᏳᎾᏍᏗ ᎠᎾᏙᎴᎰᏍᎩᎩ ᎠᎴ ᏗᎾᏕᏲᎲᏍᎩ, ᎾᏍᎩ ᏆᏂᏆ, ᎠᎴ ᏏᎻᏂ ᎾᎦ ᏧᏙᎢᏛ, ᎠᎴ ᎷᏏᏯ ᏌᎵᏂ ᎡᎯ, ᎠᎴ ᎹᏁᏂ ᎾᏍᎩ ᎢᏧᎳᎭ ᏧᎾᏛᏒᎯ ᎡᎶᏛ ᏅᎩ ᎢᎦᏚᎩ ᎨᏒ ᏍᎦᏚᎩ ᎠᏥᎦᏘᏗᏍᏗ, ᎠᎴ ᏐᎳ.


text:
ᎯᎠ ᏄᏪᏎᎢ; ᎦᎶᏄᎮᏛ ᎠᎴ ᎤᏁᎫᏥᏛ ᏣᎧᎵᏨᎯ, ᎠᏍᎩᎾ ᎤᏪᏥ, ᎭᏡᏗᏍᎩ ᏂᎦᎥ ᏚᏳᎪᏛ ᎨᏒᎢ, ᏝᏍᎪ ᏴᏘᏑᎵᎪᏥ ᎤᏣᏘᏂ ᏂᏕᎲᏁᎲ ᏚᏳᎪᏛ ᏅᏃᎯ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ?


text:
ᏚᏂᎪᎵᏰᎥᏃ ᏗᎧᎿᏩᏛᏍᏗ ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ, ᏗᎦᎳᏫᎢᏍᏗᏱ ᎨᏥᎦᏘᏗᏍᏗ ᎤᎾᏓᏅᏎ ᎯᎠ ᏫᏂᏚᏂᏪᏎᎴᎢ; ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ, ᎢᏳᏃ ᏗᎨᏥᏬᏁᏙᏗ ᎨᏎᏍᏗ ᏴᏫ, ᎢᏥᏁᎩ.


text:
ᎾᏍᎩᏃ ᎤᏪᎧᎲᏒ, ᏚᎾᏄᎪᏫᏎᎴ ᏕᏫ ᎤᎾᏤᎵ ᎤᎬᏫᏳᎯ ᎢᏳᎵᏍᏙᏗᏱ; ᎾᏍᎩ ᎾᏍᏉ ᏧᏁᎢᏍᏔᏁ ᎯᎠ ᏥᏁᏪᏎᎢ; ᏥᏩᏛᎲ ᏕᏫ ᏤᏏ ᎤᏪᏥ, ᎠᏍᎦᏯ ᎣᏍᏛ ᏥᏰᎸᎢ, ᎾᏍᎩ ᏅᏛᏛᏁᎵ ᏂᎦᎥ ᎦᏓᏅᏖᏍᎬᎢ.


text:
ᏣᏂᏃ ᎿᏉ ᎠᎧᎵᎢᎮ ᏧᎳᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎯᎠ ᏄᏪᏎᎢ; ᎦᎪ ᏍᎩᏰᎵᏎᎭ? ᎥᏝ ᎠᏴ ᎾᏍᎩ ᏱᎩ, ᎠᏎᏃ ᎬᏂᏳᏉ ᎣᏂ ᏓᏯᎢ ᎾᏍᎩ ᏚᎳᏑᎸ ᎥᏝ ᎠᏴ ᏰᎵ ᏗᎬᎩᎧᏁᏴᏗ ᏱᎩ.


text:
ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ, ᎡᏆᎭᎻ ᏅᏓᏳᏁᏢᏔᏅᏛ, ᎠᎴ ᎩᎶ ᎢᏣᏓᏑᏰᏍᏗ ᎡᏥᎾᏰᏍᎩ ᎤᏁᎳᏅᎯ, ᏂᎯ ᎢᏣᏛᎪᏗ ᎡᏥᏰᎸᎾᏁᎸ ᎧᏃᎮᏛ ᎾᏍᎩ ᎯᎠ ᎠᎵᏍᏕᎸᏙᏗ ᎨᏒ ᎧᏃᎮᏍᎩ.


text:
ᏥᎷᏏᎵᎻᏰᏃ ᎠᏁᎯ, ᎠᎴ ᏧᎾᏤᎵ ᎤᏂᎬᏫᏳᏌᏕᎩ, ᎾᏍᎩ ᏂᎬᏩᎦᏔᎲᎾ ᎨᏒ ᎢᏳᏍᏗ ᎠᎴ ᎾᏍᏉ ᎾᏂᎦᏔᎲᎾ ᎨᏒ ᎢᏳᏍᏗ ᎠᏂᏁᎬ ᎠᎾᏙᎴᎲᏍᎩ ᏄᎾᏙᏓᏈᏒ ᏥᏓᏂᎪᎵᏰᎠ, ᎾᏍᎩ ᏚᏃᎯᏳᏔᏅ ᏥᏚᏄᎪᏓᏁᎴᎢ.


text:
ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏙᎯᏳᎯ ᏂᎬᏁᎸ ᎠᏴ ᎾᏍᎩ ᏧᏁᏥ, ᎾᏍᎩ ᏥᏌ ᏕᎤᎴᏔᏅᎢ; ᎾᏍᎩᏯ ᎾᏍᏉ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ ᏗᎧᏃᎩᏍᏗᏱ ᏔᎵᏁᎢ; "ᎠᏇᏥ ᏂᎯ, ᎪᎯ ᎢᎦ ᏍᏆᏕᏁᎸ."


text:
"ᏗᏣᎧᏅᎦ, ᎢᏥᏂᏆᏘᎯ, ᎠᎴ ᎢᏥᏍᏆᏂᎪᎯ ᎠᎴ ᎢᏣᏗᏒᏅ; ᎠᏴᏰᏃ ᎪᎯ ᎢᏤᎲ ᏓᎩᎸᏫᏍᏓᏁ ᏗᎦᎸᏫᏍᏓᏁᏗ, ᎾᏍᎩ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎥᏝ ᏴᎨᏦᎯᏳᎲᎦ ᎾᏍᏉ ᎠᏎ ᎩᎶ ᏱᏥᏁᎮᎮᎸ."


text:
ᏓᏂᎳᏫᎥᏃ ᏚᏂᏰᎵᏒ ᎤᏂᏣᏖ ᎠᏂᏧᏏ ᎠᎴ ᎤᏁᎳᏅᎯ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ ᎠᏂᏧᏏ ᏓᎾᎵᎪᏁᎸᎯ ᏚᏂᏍᏓᏩᏛᏎ ᏉᎳ ᎠᎴ ᏆᏂᏆ, ᎾᏍᎩᏃ ᏚᏂᏬᏁᏔᏁ ᏚᏂᏔᏲᏎᎴ ᏧᏂᏲᎯᏍᏗᏱ ᏂᎨᏒᎾ ᎤᏁᎳᏅᎯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ.


text:
ᎾᏉᏃ ᏉᎳ ᎠᎴ ᏆᏂᏆ ᎧᏁᏉᎨ ᎾᏂᏍᎦᎢᎲᎾ ᎨᏒᎢ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᏂᎯ ᎢᎬᏱ ᎠᏎ ᎡᏥᏃᎮᎮᏗ ᎨᏒᎩ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎧᏃᎮᏛ; ᎠᏎᏃ ᎢᏢᏉ ᏥᏂᏨᏁᎭ ᎠᎴ ᎢᏨᏒ ᎢᏣᏓᏅᏖᏍᎬ ᏰᎵ ᎦᏰᏥᏁᏗ ᏂᎨᏒᎾ ᏥᏥᏰᎸ ᎬᏂᏛ, ᎬᏂᏳᏉ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏗᏁᎲ ᏬᏍᏓᎦᏔᎲᏍᏓ.


text:
ᎠᏎᏃ ᎠᏂᏧᏏ ᏚᏂᏖᎸᏁ ᎨᏥᎸᏉᏗ ᎠᏂᎨᏴ ᎤᏁᎳᏅᎯ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ, ᎠᎴ ᎾᎿ ᎦᏚᎲ ᏗᎨᎦᏁᎶᏗ ᎠᏂᏍᎦᏯ, ᎠᎴ ᎾᏍᎩ ᏄᏅᏂᏌᏁ ᎦᎨᏥᏐᏢᏙᏗᏱ ᏉᎳ ᎠᎴ ᏆᏂᏆ, ᎠᎴ ᏚᏂᎨᎯᏙᎴ ᎤᎾᏤᎵᎪᎯ ᎨᏒᎢ.


text:
ᎤᏬᎯᏤᏃ ᎾᎿ ᎤᏁᏙᎴᎢ, ᎾᏂᏍᎦᎢᎲᎾ ᎠᏂᏬᏂᏍᎨ ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᎤᎾᎵᏍᎦᏍᏙᏛ ᎤᎬᏫᏳᎯ, ᎾᏍᎩ ᎠᏍᏓᏱᏗᏍᎨ ᎧᏃᎮᏛ ᎤᏩᏒ ᎤᏓᏙᎵᏣᏛ ᎧᏃᎮᏍᎩ, ᏓᏁᎮ ᏧᏃᏰᏂ ᏧᏅᏙᏗᏱ ᎤᏰᎸᏛ ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ.


text:
ᎤᏂᏣᏘᏃ ᎤᏂᎪᎲ ᏄᏛᏁᎸ ᏉᎳ ᎤᏂᏌᎳᏓᏁ ᎠᏂᏁᎬᎢ, ᎵᎨᎣᏂᏯ ᎠᏁᎯ ᎤᏂᏬᏂᎯᏍᏗ ᎤᏅᏔᏁ ᎯᎠ ᏄᏂᏪᏎᎢ; ᎦᎸᎳᏗ ᎠᏁᎯ ᎠᎾᏠᎠᏏᎦ ᏴᏫ ᏄᎾᏍᏛ ᎾᏍᎩᏯ ᎢᏳᎾᏍᏗ.


text:
ᎿᏉᏃ ᎠᏥᎸ-ᎨᎶᏎᎯ ᏧᏈᏓ ᎾᏍᎩ ᎦᏚᎲ ᎢᎬᏱᏗᏢ ᎪᏢᏒᎢ, ᎦᎶᎯᏍᏗᏳᎶᏗ ᏚᏘᏃᎴ ᏩᎦ ᎠᎴ ᏗᎪᏛᎢᏛ ᎤᏂᏥᎸᏅᎯ ᏕᎤᏃᎴᎢ, ᎾᏍᎩ ᎤᏩᏒ ᎠᎴ ᎤᏂᏣᏘ ᎨᏒ ᎠᏥᎸ-ᎤᏁᎳᏍᏗᏱ ᎤᏰᎸᏎᎢ.


text:
ᎯᎠ ᎾᏂᏪᏍᎨᎢ; ᎢᏥᏍᎦᏯ, ᎦᏙᏃ ᎾᏍᎩ ᎯᎠ ᏂᏣᏛᏁᎭ? ᎠᏴ ᎾᏍᏉ ᏴᏫᏉ ᎾᏍᎩᏯ ᏂᏣᎵᏍᏓᏁᎲ ᎢᏲᎩᎾᎵᏍᏓᏁᎯ, ᎠᎴ ᎢᏨᏯᎵᏥᏙᏁᎭ ᏗᏥᏲᎯᏍᏗᏱ ᎯᎠ ᎠᏎᏉᏉ ᏂᏣᏛᏁᎲᎢ, ᏫᏣᎦᏔᎲᏍᏗᏱᏃ ᎬᏂᏛ ᎤᏁᎳᏅᎯ ᎢᏗᏢ, ᎾᏍᎩ ᎤᏬᏢᏅᎯ ᏥᎩ ᎦᎸᎶᎢ ᎠᎴ ᎦᏙᎯ ᎠᎴ ᎠᎺᏉᎯ ᎠᎴ ᎾᏂᎥ ᎾᎿ ᎠᏁᎯ;


text:
ᎥᏝᏍᎩᏂᏃᏅ ᏩᎩᏂᎪᎯ ᎬᏂᎨᏒ ᎢᏯᏋᏁᎯ ᏳᏪᎵᏎᎢ, ᎾᏍᎩ ᎣᏍᏛ ᏚᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᎢᎩᎦᏃᏓᏁᎲᎢ ᎦᎸᎳᏗ ᏗᎦᎶᏍᎬᎢ, ᎠᎴ ᎢᎦᎵᏍᎪᎸᏓᏁᎲ ᎤᏣᏘ ᎪᎱᏍᏗ ᎤᏛᎯᏍᏗᏱ ᏂᏓᏕᏘᏴᎯᏒᎢ, ᏗᎩᎾᏫ ᏓᎧᎵᎢᏍᏗᏍᎬ ᎠᎵᏍᏓᏴᏗ ᎠᎴ ᎤᎵᎮᎵᏍᏗ.


text:
ᎠᏎᏃ ᎤᏂᎷᏤ ᎠᏂᏧᏏ ᎥᏘᎣᎩ ᎠᎴ ᎢᎪᏂᏯ ᏅᏓᏳᏂᎶᏒᎯ, ᎾᏍᎩ ᏚᏂᏔᏲᏎᎴ ᎤᏂᏣᏘ, ᏉᎳᏃ ᏅᏯ ᏕᎬᏩᏂᏍᏔᏅ ᎬᏩᎾᏌᎾᏫᏛᎮ ᎦᏚᎲ ᎬᏩᏄᎯᏎᎢ, ᎤᏲᎱᏒ ᎠᏁᎵᏍᎨᎢ.


text:
ᏓᎾᎵᏂᎪᎯᏍᏗᏍᎨ ᏚᎾᏓᏅᏛ ᎠᏃᎯᏳᎲᏍᎩ, ᏓᏂᏔᏲᏎᎮ ᏧᏂᏲᎯᏍᏗᏱ ᏂᎨᏒᎾ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎠᎴ ᏓᏂᏃᏁᎮ ᎤᏣᏘ ᎠᎩᎵᏴ ᎢᎩᎶᎯᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ ᏫᎩᏴᏍᏗᏱ.


text:
ᏉᎳᏃ ᎠᎴ ᏆᏂᏆ ᎤᏤᏘ ᎤᏂᏲᏠᎯᏎᎸ ᎠᎴ ᎤᎾᏗᏒᎸ ᎠᏂᏬᏂᏍᎬ ᎾᏍᎩ, ᏚᏄᎪᏔᏁ ᏉᎳ ᎠᎴ ᏆᏂᏆ ᎠᎴ ᎩᎶ ᎢᏳᎾᏍᏗ ᏅᏩᎾᏓᎴ ᏥᎷᏏᎵᎻ ᎤᏁᏅᏍᏗᏱ ᏧᎾᏛᏛᏅᏍᏗᏱ ᎨᏥᏅᏏᏛ ᎠᎴ ᏗᎨᎦᏁᎶᏗ ᎾᏍᎩ ᎯᎠ ᎠᏂᏱᎵᏙᎲ ᎤᎬᏩᎵ.


text:
ᎤᏣᏘᏃ ᎤᏂᏬᏂᏒ ᏈᏓ ᏕᎤᎴᏁᎢ, ᎯᎠ ᏂᏚᏪᏎᎴᎢ; ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ, ᏂᎯ ᎢᏥᎦᏔᎭ ᎿᏉ ᏰᎵ ᎪᎯᎩ ᎤᏁᎳᏅᎯ ᎠᏴ ᎠᏆᏑᏰᏒ ᎢᎦᏓᏡᎬ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏴ ᎬᏆᏛᎦᏁᏗᏱ ᎣᏍᏛ ᎧᏃᎮᏛ, ᎾᏍᎩᏃ ᎤᏃᎯᏳᏗᏱ.


text:
ᎿᏉᏃ ᏂᎦᏛ ᎤᏂᏣᏘ ᎨᏒ ᎡᎳᏪ ᎤᏅᏁᎢ, ᎠᎴ ᏚᎾᏛᏓᏍᏓᏁᎴ ᏆᏂᏆ ᎠᎴ ᏉᎳ ᎠᏂᏃᎮᏍᎬ ᏂᎦᎥ ᎤᏰᎸᏛ ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎤᏅᏗᏍᎬ ᏚᎸᏫᏍᏓᏁᎸ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ.


text:
ᎾᏍᎩ ᏄᎾᏓᎴ ᏴᏫ ᎬᏩᏂᏯᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎤᎬᏫᏳᎯ, ᎠᎴ ᎾᏍᏉ ᏂᎦᏛ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏆᏙᎥ ᏗᎨᎪᏍᏔᏅᎯ ᏥᎩ, ᎠᏗᎭ ᎤᎬᏫᏳᎯ, ᎾᏍᎩ ᎯᎠ ᏂᎦᏛ ᏧᎸᏫᏍᏓᏁᎯ ᏥᎩ."


text:
ᎿᏉᏃ ᎣᏏᏳ ᎤᏂᏰᎸᏁ ᎨᏥᏅᏏᏛ ᎠᎴ ᏗᎨᎦᏁᎶᏗ ᎠᎴ ᏂᎦᏛ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏧᏂᏅᏍᏗᏱ ᎠᏂᏍᎦᏯ ᏧᎾᏑᏰᏛ ᎤᏅᏒ ᎤᎾᏓᏡᎬᎢ, ᎾᏍᎩ ᏧᏓᏏ ᏆᏏᏆ ᏧᏙᎢᏛ ᎠᎴ ᏌᏱᎳ ᎨᏥᎸᏉᏗ ᎠᎾᏓᏅᏢᎢ, ᏉᎳ ᎠᎴ ᏆᏂᏆᎢᏧᎳᎭ ᎤᏁᏅᏍᏗᏱ ᎥᏘᏍᎩ,


text:
ᎣᎬᏛᎦᏅ ᎩᎶ ᎢᏳᎾᏍᏗ ᎪᎦᏓᏑᏰᏛ ᎠᏂᏬᏂᏍᎬ ᎨᏣᏕᏯᏙᏔᏅᎢ ᏕᎨᏥᎦᏔᎲᎡᎲ ᏗᏣᏓᏅᏙ, ᎯᎠ ᎾᏂᏪᏍᎬᎢ; ᎠᏎ ᏤᏥᎤᏍᏕᏎᏗ ᎠᎴ ᏗᎧᎿᏩᏛᏍᏗ ᎢᏥᏍᏆᏂᎪᏙᏗ; ᎾᏍᎩ ᎢᏳᏍᏗ ᏦᏥᏁᏤᎸᎯ ᏂᎨᏒᎾ;


text:
ᎾᏍᎩ ᏗᏥᏲᎯᏍᏗᏱ ᎠᎵᏍᏓᏴᏗ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ, ᎠᎴ ᎩᎬ, ᎠᎴ ᎪᎱᏍᏗ ᎬᏬᏍᏔᏅᎯ, ᎠᎴ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒᎢ. ᎢᏳᏃ ᎾᏍᎩ ᏱᏗᏤᏯᏙᏤᎸ ᎣᏏᏳ ᏱᏂᏣᏛᎦ. ᏙᎯᏱ ᏂᏣᏛᎿᏕᎨᏍᏗ.


text:
ᎢᎸᏍᎩᏃ ᏫᏄᏒᎸ ᏉᎳ ᎯᎠ ᏄᏪᏎᎸᎩ ᏆᏂᏆ; Ꭷ ᏔᎵᏁ ᏥᏙᏂᏩᏛᎱᎦ ᎢᏓᏓᏅᏟ ᏂᎦᎥ ᏕᎦᏚᏩᏗᏒ ᎾᎿ ᎩᎾᎵᏥᏙᏂᏙᎸ ᎧᏃᎮᏛ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ, ᏫᎾᏙᎴᎰᎯ ᏄᎾᏛᎿᏕᎬᎢ.


text:
ᎩᎶᏃ ᎢᏳᏍᏗ ᎠᎨᏴ ᎵᏗ ᏧᏙ-Ꮫ, ᎩᎦᎨ ᏗᏄᏬ ᎦᏃᏗᏍᎩ, ᏓᏱᏓᎵ ᎦᏚᎲ ᎡᎯ, ᎤᏁᎳᏅᎯ ᎠᏓᏙᎵᏍᏔᏁᎯ, ᎤᏛᏓᏍᏔᏅᎩ. ᎾᏍᎩ ᎤᎾᏫᏱ ᎤᎬᏫᏳᎯ ᎤᏍᏚᎢᏒᎩ, ᎤᏛᏓᏍᏙᏗᏱ ᏉᎳ ᎧᏁᎬᎢ.


text:
ᎠᎦᏬᎥᏃ ᎤᏩᏒ ᎠᎴ ᎾᏍᎩ ᏚᏓᏘᎾᎥᎢ, ᎣᎩᏔᏲᏎᎸᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᎢᏳᏃ ᎤᏙᎯᏳᏒ ᎤᎬᏫᏳᎯ ᎪᎯᏳᎲᏍᎩ ᏍᎩᏰᎵᏎᎮᏍᏗ, ᏥᏁᎸ ᎢᏥᏴᎭ ᎠᎴ ᎾᎿ ᎢᏥᏁᏍᏗ. ᎣᎩᏍᏗᏰᏗᏍᎬᏃ ᎣᎩᏎᎪᎩᏒᎩ.


text:
ᎾᏍᎩ ᎣᎩᏍᏓᏩᏗᏒ ᏉᎳ ᎠᎴ ᎠᏴ, ᎤᏪᎷᏅᎩ ᎯᎠ ᏄᏪᏒᎩ; ᎯᎠ ᎠᏂᏍᎦᏯ ᎤᏁᎳᏅᎯ ᏩᏍᏛ ᎦᎸᎳᏗᏳ ᎡᎯ ᏧᏅᏏᏓᏍᏗ, ᎾᏍᎩ ᎬᏂᎨᏒ ᏥᏂᎨᎬᏁᎭ ᏅᏃᎯ ᎠᎵᏍᏕᎸᏙᏗ ᎨᏒᎢ.


text:
ᎠᎴ ᎤᏣᏛ ᏄᏒᎸᎩ ᎾᏍᎩ ᎾᏛᏁᎲᎩ; ᎠᏎᏃ ᏉᎳ ᎤᏕᏯᏔᏁᎸ ᎤᎦᏔᎲᏒᎩ, ᎯᎠ ᏄᏪᏎᎸᎩ ᎾᏍᎩ ᎠᏓᏅᏙ; ᎬᏁᏥ ᏥᏌ ᎦᎶᏁᏛ ᏕᎤᏙᎥ ᎬᏗᎭ, ᎾᏍᎩ ᎪᎱᎪᏤᏗᏱ. ᎾᎯᏳᏉᏃ ᎤᏄᎪᏨᎩ.


text:
ᏗᏓᏍᏚᏗᏱᏃ ᎠᎦᏘᏯ, ᎤᏰᏨ ᎠᎴ ᎤᏙᎴᎰᏒ ᎦᎶᎯᏍᏗᏱ ᏗᏓᏍᏚᏗᏱ ᏧᎵᏍᏚᎢᏛ ᎨᏒᎢ, ᎤᎸᎮ ᎠᏰᎳᏍᏗ ᎦᏅᎯᏛ, ᎠᎴ ᎤᏩᏒ ᏗᏓᎵᏎᎢ, ᏗᎨᏥᏍᏚᎯ ᎤᎾᎵᏒ ᎡᎵᏍᎨᎢ.


text:
ᎠᏎᏃ ᏉᎳ ᎯᎠ ᏂᏚᏪᏎᎴᎢ, ᎬᏂᎨᏒ ᏕᎪᎩᏂᎵᎥᏂᎸ ᏧᏚᎪᏔᏅᎯ ᏂᎨᏒᎾ ᎣᎩᏂᏍᎦᏅᏨᎢ, ᎣᏍᏗᎶᎻ, ᎠᎴ ᏗᏓᏍᏚᏗᏱ ᏕᎪᎩᏂᏴᏔᏅ, ᏥᎪᏃ ᎿᏉ ᎤᏕᎵᏛ ᎢᎪᎩᏂᏄᎪᏫᏍᎦ? ᎤᏙᎯᏳᎯ ᎥᏝ, ᎤᏅᏒᏍᎩᏂ ᏩᏂᎷᎩ ᏫᎪᎩᏂᏄᎪᏩ.


text:
ᏕᎪᏏᏏᏍᎬᎩ ᎠᎴ ᎬᏂᎨᏒ ᏂᎬᏁᎲᎩ ᎦᎶᏁᏛ ᎠᏎ ᎤᎩᎵᏲᎢᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏲᎱᏒ ᏧᎵᎯᏐᏗ ᎨᏒᎢ; ᎠᎴ ᎯᎠ ᎾᏍᎩ ᏥᏌ ᎠᏴ ᏥᏨᏯᎵᏥᏙᏁᎭ ᎾᏍᎩ ᎪᎶᏁᏛ, ᎠᏗᏍᎬᎩ.


text:
ᎢᎦᏛᏃ ᎤᎾᏓᏑᏴ ᎤᏃᎯᏳᏅᎩ, ᎠᎴ ᏚᎾᎵᎪᏁᎸᎩ ᏉᎳ ᎠᎴ ᏌᏱᎳ, ᎠᎴ ᎤᏂᏣᏔᏅᎯ ᎠᏂᎪᎢ ᎤᏁᎳᏅᎯ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ, ᎠᎴ ᎠᏂᎦᏲᎵᏉ ᏂᎨᏒᎾ ᏄᏂᎬᏫᏳᏒ ᎠᏂᎨᏴ.


text:
ᎠᏎᏃ ᎠᏂᏧᏏ ᏄᏃᎯᏳᏒᎾ, ᎠᏅᏳᎬ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ, ᏫᏚᏂᏯᏅᎲᎩ ᎩᎶ ᎢᏳᎾᏍᏗ ᎤᏂᏁᎫᏥᏛ ᎤᏁᏙᎯ, ᏚᏂᏟᏌᏅᏃ ᎤᏂᏖᎸᏅᎩ ᎦᏚᎲᎢ; ᏚᏂᎦᏘᎴᏅᏃ ᏤᏌᏂ ᎦᏁᎸᎢ, ᏴᏫ ᏧᏂᏄᎪᏫᏎᏗᏱ ᎤᎾᏁᎶᏔᏅᎩ.


text:
ᏫᏚᎾᏠᏨᏃ ᏫᏚᏂᎾᏌᏁᏒᎩ ᏤᏌᏂ ᎠᎴ ᎩᎶ ᎢᏳᎾᏍᏗ ᎠᎾᏓᏅᏟ, ᎦᏚᎲ ᎨᏥᎦᏘᏗᏍᏗ ᏫᏚᎾᏘᏃᎮᎸᎩ, ᎤᏁᎷᎬᎩ ᎯᎠ ᎾᏂᏪᏍᎬᎩ; ᎯᎠ ᎡᎶᎯ ᏧᏂᎷᏆᏗᏅᏛ, ᎾᏍᏉ ᎠᏂ ᎢᎤᏂᎷᏨ;


text:
ᎾᏍᎩ ᎯᎠ ᎤᏟ ᎠᏃᏏᏳ ᎨᏒᎩ ᎡᏍᎦᏉ ᏕᏏᎶᏂᎦ ᎠᏁᎯ, ᏚᎾᏓᏂᎸᏨᎩᏰᏃ ᎧᏃᎮᏛ ᎠᎴ ᏂᏚᎩᏨᏂᏒ ᏓᏂᎪᎵᏰᏍᎬᎩ ᎪᏪᎵ, ᎾᏍᎩ ᏄᏍᏛ ᎠᎴ ᎾᏍᎩ ᏄᏍᏛᎾ ᎨᏒ ᎤᎾᏙᎴᎰᎯᏍᏗᏱ.


text:
ᎩᎶᏃ ᎢᏳᎾᏍᏗ ᎠᏂᎦᏔᎿᎢ ᎠᏂᏈᎫᎳ ᎠᎴ ᎠᏂᏍᏙᎢᎦ ᎬᏩᎵᏃᎮᏔᏅᎩ; ᎢᎦᏛᏃ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎦᏙ ᎤᏚᎵ ᎤᏛᏗᏱ ᎯᎠ ᏄᏪᎸᏛᎾ ᎦᏬᏂᏍᎩ; ᎠᏂᏐᎢᏃ ᎯᎠ; ᏅᏩᎾᏓᎴ ᏴᏫ ᏧᎾᏤᎵ ᎦᎸᎳᏗ ᎠᏁᎯ ᏗᎦᎾᏄᎪᏫᏍᎩ ᏅᏩᏍᏗ; ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏓᎵᏥᏙᏁᎲᎢ ᏥᏌ ᎠᎴ ᏗᎴᎯᏐᏗ ᎨᏒ ᎤᎬᏩᎵ.


text:
ᎦᎢᏒᏰᏃ ᎠᎴ ᏓᎩᎪᎲ ᏓᎩᎪᎲ ᎦᎸᏉᏗᏳ ᏗᏥᏰᎸᎯ, ᎠᎩᏩᏛᎲᎩ ᎾᏍᏉ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎯᎠ ᏅᎬᏅ ᎥᎪᏪᎸᎩ; "ᎾᏥᎦᏔᎲᎾ ᎦᎸᎳᏗ ᎡᎯ ᎤᏤᎵᎦ." ᎾᏍᎩᏃ ᎰᏩ ᏁᏥᎦᏔᎲᎾ ᏤᏣᏓᏙᎵᏍᏓᏁᎭ ᎾᏍᎩ ᎬᏂᎨᏒ ᏂᏨᏴᏁᎭ.


text:
ᎤᏁᎳᏅᎯ ᎤᏬᏢᏅᎯ ᏥᎩ ᎡᎳᏂᎬᎢ ᎠᎴ ᏂᎦᏛ ᎾᎿ ᎠᏁᎯ, ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᎦᎸᎳᏗ ᎠᎴ ᎡᎶᎯ ᎤᎾᏤᎵᎦ, ᎥᏝ ᏱᎦᏁᎸ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎩᎶ ᏧᏬᏱ ᏧᏮᏔᏅᎯ ᏧᏁᏍᎨᎲᎯ.


text:
ᎠᎴ ᏌᏉ ᎩᎬ ᏚᏬᏢᏔᏅ ᎾᏂᎥ ᏄᎾᏓᎴᏒ ᏴᏫ ᎾᏍᎩ ᏧᎾᏁᎳᏗᏍᏗᏱ ᏂᎬᎾᏛ ᎦᏚᎢᏗᏢ ᎡᎶᎯ, ᎠᎴ ᏕᎤᏚᎪᏔᏅ ᎢᏳᎵᏍᏔᏂᏓᏍᏗᏱ, ᎠᎴ ᏫᏚᏍᏖᏅ ᎾᎿ ᏕᎨᏌᏗᏒ ᏧᎾᏁᎳᏗᏍᏗᏱ.


text:
ᎾᏍᎩᏰᏃ ᏄᏩᏅ ᏥᏕᏛᏅ, ᎠᎴ ᏥᏓᎵᏖᎸᎲᏍᎦ, ᎠᎴ ᏥᏕᎭ; ᎾᏍᎩ ᎾᏍᏉ ᎩᎶ ᎢᏳᎾᏍᏗ ᏗᎧᏃᎩᏍᏗ ᏗᏃᏪᎵᏍᎩ ᏗᏣᏤᎵᎦ ᎯᎠ ᏄᏂᏪᏒ; "ᎠᏴᏰᏃ ᎾᏍᏉ ᎾᏍᎩ ᏧᏪᏥ."


text:
ᎾᏍᎩᏃ ᎢᏳᏍᏗ, ᎠᏴ ᎤᏁᎳᏅᎯ ᏧᏪᏥ ᏥᎩ, ᎥᏝ ᎯᎠᏉ ᏱᏂᎨᏕᎵᎭ; ᎤᏁᎳᏅᎯ ᎾᏍᎩᏯᏉ ᎠᏕᎸ ᏓᎶᏂᎨ ᎠᎴ ᎠᏕᎸ ᎤᏁᎬ ᎠᎴ ᏅᏯ, ᏴᏫ ᎠᏂᏏᎾᏌᏅ ᎠᎴ ᎤᎾᏓᏅᏖᎸᎯ ᎬᏔᏅᎯ ᎪᏢᏅᎯ.


text:
ᎤᏩᏛᎲᏃ ᎩᎶ ᎢᏳᏍᏗ ᎠᏧᏏ ᎡᏈᎳ ᏧᏙᎢᏛ, ᏋᏗᏱ ᎤᏕᏅᎯ, ᎩᎳᎢ ᎤᎷᏦᏅᎯ ᎢᏓᎵ ᏅᏓᏳᎶᏒᎯ, ᎠᎴ ᎾᏍᏉ ᎤᏓᎵᎢ ᏈᏏᎳ ᏧᏙᎢᏛ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬ ᏠᏗᏯ ᎤᏁᏨ ᏂᎦᏛ ᎠᏂᏧᏏ ᎶᎻ ᎤᎾᏓᏅᏍᏗᏱ, ᎾᏍᎩ ᏚᏩᏛᎯᎸᎩ.


text:
ᎾᏍᎩᏃ ᎤᏂᏲᏍᏙᏔᏅ ᎠᎴ ᎤᏂᏐᏢᎢᏍᏔᏅ, ᎤᏄᏬ ᎤᏩᏣᎬᏅᎩ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎢᏥᎩᎬ ᏗᏥᏍᎪᎵ ᎢᏨᏒ ᏕᏣᏓᏅᎵᏰᎡᏍᏗ, ᎠᏴ ᎥᏝ ᏯᏆᏓᏅᎵᏰᎥ; ᎿᏉ ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏗᏁᎲ ᏮᏓᏥᎶᏏ.


text:
ᎿᏉᏃ ᏂᎦᏛ ᎠᏂᎪᎢ ᎤᏂᏂᏴᎲ ᏐᏍᏗᏂ ᎠᏂᏧᏏ ᏧᏂᎳᏫᎢᏍᏗᏱ ᏄᎬᏫᏳᏒ ᎠᏥᎦᏘᏗᏍᏗ, ᎤᏂᎵᎥᏂᎸᎩ ᎢᎬᏱᏢ ᏗᎫᎪᏙᏗᏱ ᎦᏍᎩᎸᎢ. ᎨᎵᏲᏃ ᎥᏝ ᏳᎦᏌᏯᏍᏔᏁ ᎾᏍᎩ ᏄᏍᏗᏕᎬᎢ.


text:
ᏉᎳᏃ ᎠᏏ ᎤᏬᎯᏨᎩ ᎤᏪᏙᎸᎩ; ᎿᏉᏃ ᏚᏲᎵᎸ ᎠᎾᏓᏅᏟ, ᏥᏳᎯ ᏭᏣᏅᎩ ᏏᎵᏱ ᏭᎶᏒᎩ; ᎠᎴ ᎾᏍᏉ ᏈᏏᎳ ᎠᎴ ᎡᏈᎳ ᎬᏩᏍᏓᏩᏛᏒᎩ, ᎤᎵᏍᏙᏰᎲᎯ ᎨᏒᎩ ᏒᏟᏯ ᎢᏴᏛ, ᎤᏁᎳᏅᎯᏰᏃ ᎤᏚᎢᏍᏓᏁᎸᎯ ᎨᏒᎩ.


text:
ᏚᏲᎵᎸᏉᏍᎩᏂ ᎯᎠ ᏄᏪᏒᎩ; ᎠᏎ ᎠᎩᏍᏆᏂᎪᏙᏗ ᏥᎷᏏᎵᎻ ᎯᎠ ᏗᎵᏍᏓᏴᏗᏱ ᏨᏛᏍᏆᎸᎯ. ᎠᏎᏃ ᏔᎵᏁ ᏛᏨᏩᏛᎯᎵ, ᎢᏳᏃ ᎤᏁᎳᏅᎯ ᎤᏏᏳ ᏳᏰᎸᏅ. ᎡᏈᏌᏃ ᏥᏳᎯ ᏭᏣᏅᎩ.


text:
ᎾᏍᎩ ᎯᎠ ᎠᎨᏲᏅᎯ ᎨᏒᎩ ᎤᎬᏫᏳᎯ ᎤᏅᏅᎢ, ᎠᎴ ᎤᎵᏂᎩᏛ ᎨᏒ ᎤᏓᏅᏛᎢ, ᎧᏃᎮᏍᎬᎩ ᎠᎴ ᏓᏕᏲᎲᏍᎬᎩ ᎾᏑᎵᎪᎬᎾ ᎤᎬᏫᏳᎯ ᎤᏤᎵ ᎤᎬᏩᎵ ᎨᏒᎢ, ᏣᏂ ᎤᏤᎵ ᏗᏓᏬᏍᏗ ᎤᏩᏒ ᎠᎦᏔᎲᎩ.


text:
ᎤᏚᎸᎲᏃ ᎡᎧᏯ ᎤᏪᏅᏍᏗᏱ, ᎠᎾᏓᏅᏟ ᎤᏃᏪᎳᏅᎩ ᏗᏂᏔᏲᏎᎸᎩ ᎠᏃᎯᏳᎲᏍᎩ ᏗᎬᏩᏓᏂᎸᎢᏍᏗᏱ; ᎾᏍᎩᏃ ᏭᎷᏨ, ᎤᏣᏘ ᏚᏍᏕᎸᎲᎩ ᎤᏁᎳᏅᎯ ᎤᏓᏙᎵᏣᏛ ᎢᏳᏩᏂᏌᏛ ᎤᏃᎯᏳᏅᎯ.


text:
ᏉᎳᏃ ᎯᎠ ᏄᏪᏒᎩ; ᏣᏂ ᎤᏙᎯᏳᎯ ᏓᏓᏬᏍᏗᏍᎬᎩ ᏗᏓᏬᏍᏙᏗ ᎦᏁᏟᏴᏍᏗ ᎨᏒ ᎣᏓᏅᏛ ᎤᎬᏩᎵ, ᏕᎧᏁᏤᎲ ᏴᏫ, ᎤᏃᎯᏳᏗᏱ ᎣᏂ ᏅᏓᏰᎩ, ᎾᏍᎩ ᎦᎶᏁᏛ ᏥᏌ ᏕᎪᏎᎲᎩ.


text:
ᎩᎶᏃ ᎢᏳᎾᏍᏗ ᎤᏂᏍᏓᏲᏒ ᎠᎴ ᏄᏃᎯᏳᏅᎾ ᏄᎵᏍᏔᏅ, ᎠᎴ ᎣᏐᏅᏉ ᎤᏂᏃᎮᎸ ᎾᏍᎩ ᎦᏅᏅ ᎤᎬᏩᎵ ᎤᏂᏣᏘ ᎠᏂᎦᏔᎲᎢ, ᏚᏓᏅᎡᎸᎩ, ᎠᎴ ᏚᏓᏓᎴᏔᏅᎩ ᎠᏃᎯᏳᎲᏍᎩ ᏕᎦᏬᏁᏗᏍᎬᎩ ᏂᏚᎩᏨᏂᏒ ᎩᎶ ᎢᏳᏍᏗ ᏓᎳᎾ ᏧᏙᎢᏛ ᏧᏕᏲᏗᏱ.


text:
ᎩᎶᏃ ᎢᏳᎾᏍᏗ ᎠᏂᏧᏏ ᏅᏁᏙᎯ, ᎠᏂᏍᎩᎾ ᏗᏂᏄᎪᏫᏍᎩ, ᎤᎾᏓᏅᏖᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᏕᎤᏙᎥ ᏧᏂᏁᎢᏍᏓᏁᏗᏱ ᎤᏂᏲ ᏗᏓᏅᏙ ᏧᏂᏯᎢ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᎢᏨᏁᎢᏍᏓᏏ ᏥᏌ, ᎾᏍᎩ ᏉᎳ ᎠᎵᏥᏙᎲᏍᎬ ᏥᎦᏃᎮᎭ.


text:
ᎾᏍᏉ ᎤᏂᏣᏛᎩ ᎤᏍᏆᏂᎪᏗ ᎠᎾᏛᏁᎵᏍᎩ ᏚᏂᏟᏌᏅᎩ ᎪᏪᎵ, ᎠᎴ ᏚᎾᎪᎲᏍᏔᏅᎩ ᏂᎦᏛ ᎠᏂᎦᏔᎲᎢ. ᎤᎾᏎᎸᏃ ᏧᎬᏩᎶᏗᎯ ᎤᎾᏙᎴᎰᏒᎩ ᎯᏍᎦᏍᎪᎯ ᎢᏯᎦᏴᎵ ᎨᏒ ᎤᏂᏁᎬ ᎠᏕᎸ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏄᎵᏍᏔᏂᏙᎸ, ᏉᎳ ᎤᏓᏅᏖᎸᎩ ᎤᏓᏅᏛᎢ, ᎿᏉ ᎹᏏᏙᏂ ᎠᎴ ᎡᎧᏯ ᎤᎶᏐᏅᎯ, ᏥᎷᏏᎵᎻ ᏭᎶᎯᏍᏗᏱ , ᎯᎠ ᏄᏪᏒᎩ; ᎾᎿ ᎬᏇᏙᏅᎯ ᎨᏎᏍᏗ ᎶᎻ ᎾᏍᏉ ᎠᏎ ᏛᏥᎪᎢ.


text:
ᎠᎴ ᎢᏥᎪᏩᏘᎭ ᎠᎴ ᎢᏣᏛᎩᎭ, ᎥᏝ ᎡᏈᏌᏉ ᎤᏩᏒ, ᎾᏍᏉᏍᎩᏂ ᎠᎴᏉ ᏂᎬᎾᏛ ᎡᏏᏱ, ᎯᎠ ᏉᎳ ᏓᏍᏗᏰᏗᏍᎬ ᏚᎦᏔᎲᏒ ᎤᏂᏣᏘ ᏴᏫ, ᎯᎠ ᏂᏕᎦᏪᏎᎲᎢ, ᎥᏝ ᎦᎸᎳᏗ ᎠᏁᎯ ᏱᎩ ᎩᎶ ᏧᏬᏰᏂᏉ ᏧᏬᏢᏔᏅᎯ ᏥᎩ.


text:
ᎠᎴ ᎥᏝ ᎯᎠᏉ ᏗᎩᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎤᏩᏒ ᎤᏁᎳᎩ ᏫᎬᏩᏲᏥᏓᏍᏗ ᏱᎩ; ᎾᏍᏉᏍᎩᏂ ᎠᏓᏁᎸ ᎦᎸᏉᏗᏳ ᎦᎸᎳᏗ ᎡᎯ ᏓᏰᏂ ᎤᏤᎵᎦ ᎠᏎᏉᏉ ᎢᎬᏩᎵᏍᏔᏂᏓᏍᏗ, ᎠᎴ ᎾᏍᎩ ᎠᏥᎸᏉᏗᏳ ᎨᏒ ᏫᎬᏩᏲᏥᏓᏍᏗ, ᎾᏍᎩ ᏂᎦᏛ ᎠᎴ ᏂᎬᎾᏛ ᎡᎶᎯ ᏥᎬᏩᎸᏉᏗᎭ.


text:
ᏗᎪᏪᎵᏍᎩᏃ ᏚᏲᏍᏙᏓᏁᎸ ᏴᏫ, ᎯᎠ ᏄᏪᏒᎩ; ᎢᏥᏍᎦᏯ ᎡᏈᏌ ᎢᏤᎯ, ᎦᎪ ᎡᎭ ᎾᎦᏔᎲᎾ ᎦᏚᎲ ᎡᏈᏌ ᎾᏍᎩ ᎡᏓᏓᏙᎵᏍᏓᏁᎯ ᎨᏒ ᎦᎸᏉᏗᏳ ᎦᎸᎳᏗ ᎡᎯ ᏓᏰᏂ, ᎠᎴ ᏧᏉᏙ ᏅᏓᏳᎶᎣᏒᎯ ᏗᏟᎶᏍᏔᏅᎯ?


text:
ᎢᎬᏱᏱᏃ ᎢᎦ ᏑᎾᏙᏓᏆᏍᏗ ᎨᏒᎢ ᎦᏚ ᎠᎬᎭᎷᏯᏍᏗᏱ ᎤᎬᏩᎵ ᎠᏃᎯᏳᎲᏍᎩ ᎤᎾᏓᏟᏌᏅ, ᏉᎳ ᏚᎵᏥᏙᏁᎸᎩ, ᎤᎩᏨᏛᏉ ᎤᏪᏅᏍᏗ ᎨᏒᎢ; ᎠᎴ ᎡᏃᏱ ᎠᏰᎵ ᏫᎬᏩᏛᏅᎩ ᎦᏬᏂᏍᎬᎩ.


text:
ᎩᎶᏃ ᎢᏳᏍᏗ ᎠᏫᏄᏣ ᏳᏘᎦ ᏧᏙᎢᏛ ᎠᏦᎳᏅ ᎤᏪᎸᎩ, ᎠᏍᏓᏯ ᎦᎵᎲᎩ; ᏉᎳᏃ ᎪᎯᏗᏳ ᎠᎵᏥᏙᎲᏍᎬ ᎢᏳᏍᏗ, ᎦᎵᎲ ᎤᏪᏇᏴᏒᎩ ᎠᎴ ᏦᎢᏁ ᏗᏲᏓᏞᎲ ᏓᏳᏙᎣᏒᎩ, ᎠᎴ ᎠᏥᏁᏒᎩ ᎤᏲᎱᏒᎯ ᎨᏒᎩ.


text:
ᎠᎴ ᎠᏴ ᎢᎬᏱ ᏃᎨᏅᏒᎩ ᏥᏳ ᏗᏔᎸᎢ, ᎠᎴ ᎣᎦᏣᏅ, ᎡᏐᏏ ᏬᎩᎶᏒᎩ; ᎾᎿ ᏉᎳ ᎣᏥᏲᏗᏱ ᎣᎩᏰᎸᏒᎩ, ᎾᏍᎩᏰᏃ ᎢᏳᏪᏛ ᎨᏒᎩ, ᎤᏩᏒ ᎡᎳᏗᏉ ᏭᎶᎯᏍᏗᏱ ᎤᏰᎸᏒᎩ.


text:
ᏉᎳᏰᏃ ᏧᏭᎪᏔᏅᎯ ᎨᏒᎩ ᎤᎶᎯᏍᏗᏱᏉ ᎡᏈᏌ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏄᏚᎵᏍᎬᎾ ᎨᏒ ᎡᏏᏱ ᎤᏪᏓᏍᏗᏱ; ᎤᏩᏅᎬᎩᏰᏃ, ᎢᏳᏃ ᏰᎵ ᎾᏍᎩ ᎢᎬᏩᏛᏁᏗ ᏱᎩ, ᏥᎷᏏᎵᎻ ᏭᎷᎯᏍᏗᏱ ᎭᏍᎦᏍᎪᎯᏁ ᎢᎦ ᎠᏍᏆᎵᏍᎬᎢ.


text:
ᏕᏥᎧᎿᏩᏛᎡᎲ ᎤᎬᏫᏳᎯ ᏂᎦᎥ ᎪᎱᏍᏗ ᎾᏆᎵᏍᎦᏍᏛᎾ ᎨᏒᎢ, ᎠᎴ ᏕᏥᎦᏌᏬᎢᎲᎢ, ᎠᎴ ᎠᎩᎪᎵᏰᏍᎩ ᎠᏆᎵᏩᏛᎡᎲᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎠᏂᏧᏏ ᎪᎱᏍᏗ ᎬᏋᏁᏗᏱ ᏚᏄᎪᏔᏅᎢ.


text:
ᎠᏎᏃ ᎾᏍᎩ ᎯᎠ ᏧᏓᎴᏅᏛ ᎥᏝ ᎪᎱᏍᏗ ᏯᎩᏖᎸᎲᏍᎦ, ᎠᎴ ᎾᏍᏉ ᎬᏅ ᎥᏝ ᎤᏣᏘ ᏯᎩᎸᏉᏗ, ᎢᏳᏃ ᎤᎵᎮᎵᏍᏗ ᏯᏆᏓᏅᏔ ᏯᎩᏍᏆᏛ ᎦᎴᏂᏙᎲᎢ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎠᎩᏁᎸᎯ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎬᏂᎨᏒ ᏂᎬᏁᎲ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎧᏃᎮᏍᎩ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏣᏓᎦᏌᏯᏍᏕᏍᏗ ᎢᏨᏒ, ᎠᎴ ᏕᏥᎦᏌᏯᏍᏕᏍᏗ ᏂᎦᏛ ᏑᎾᏓᏡᎩ ᎨᏒᎢ, ᎾᏍᎩ ᏗᏥᎦᏘᏯ ᎢᏨᏁᎸᎯ ᏥᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ, ᏗᏤᎳᏍᏗᏱ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ, ᎾᏍᎩ ᎤᏩᏒ ᎤᎩᎬ ᏧᎫᏴᏔᏅᎯ ᏥᎩ.


text:
Ꭷ, ᎢᏓᏓᏅᏟ, ᎿᏉ ᏕᏨᏲᎯ ᎤᏁᎳᏅᎯ ᎢᏥᏙᎵᏍᏗᏱ, ᎤᏮᏙᏗᏱ, ᎧᏃᎮᏛ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎧᏃᎮᏍᎩ, ᎾᏍᎩ ᏰᎵ ᎨᏣᏁᏍᎨᏗ ᏥᎩ, ᎠᎴ ᎢᏣᏤᎵ ᏰᎵ ᎢᎨᏨᏁᏗ ᏥᎩ ᎾᏍᎩ ᏂᎦᏛ ᎤᎾᏓᏅᏘ ᎢᎨᎬᏁᎸᎯ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ.


text:
ᏂᎦᏛ ᎬᏂᎨᏒ ᏂᏨᏴᏁᎸ ᎾᏍᎩ ᎢᏣᏛᏁᏗᏱ ᏕᏥᎸᏫᏍᏓᏁᎲ ᏗᏥᏍᏕᎸᏗᏱ ᏗᏂᏩᎾᎦᎳᎢ, ᎠᎴ ᎢᏣᏅᏓᏗᏍᏗᏱ ᏧᏁᏤ ᎤᎬᏫᏳᎯ ᏥᏌ, ᎯᎠ ᏥᏄᏪᏎᎢ, "ᎤᏟ ᎣᏏᏳ ᎠᏓᏅᏓᏗᏍᏗ ᏴᏓᏁᎭ, ᎡᏍᎦᏉ ᏴᏓᏗᏁᎭ."


text:
ᎾᏍᎩᏃ ᎦᎵᏉᎩ ᏧᏙᏓᏆᏛ ᎤᎶᏐᏅ, ᎣᎦᏂᎩᏒᎩ, ᏬᏥᎦᏛ ᎢᏗᏢ ᏬᎩᎶᏒᎩ; ᏂᎦᏛᏃ ᎾᏍᎩ, ᎠᎴ ᏧᎾᏓᎵᎢ ᎠᎴ ᏧᏁᏥ ᏗᎬᎾᏘᏁᎯ ᎦᏚᎲ ᏫᏚᎾᏄᎪᎬ ᏫᏕᎪᎩᎧᏅᎩ. ᎠᎹᏳᎶᏗᏃ ᏙᎦᎵᏂᏆᏅᏅ ᎣᎦᏓᏙᎵᏍᏔᏅᎩ.


text:
ᎾᏍᎩᏃ ᎤᎷᏨ ᎣᏤᏙᎲ, ᎠᎴ ᎤᏁᏒ ᏉᎳ ᎤᏓᏠᏍᏗ, ᎠᎴ ᏚᎸᎸ ᎤᏩᏒ ᏧᏬᏰᏂ, ᎠᎴ ᏧᎳᏏᏕᏂ, ᎯᎠ ᏄᏪᏒᎩ; ᎯᎠ ᏂᎦᏪᎠ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ; ᎾᏍᎩ ᎯᎠ ᏅᏛᏅᏁᎵ ᎠᏂᏧᏏ ᏥᎷᏏᎵᎻ ᏛᎾᎸᎵ ᎠᏍᎦᏯ ᎯᎠ ᎠᏓᏠᏍᏗ ᎤᏤᎵᎦ, ᎠᎴ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏫᏙᏛᏂᏲᎯᏎᎵ.


text:
ᎠᏎᏃ ᏉᎳ ᎤᏁᏨ ᎯᎠ ᏄᏪᏒᎩ ᎦᏙ ᎢᏥᏰᎸᏗ, ᏥᏕᏥᏴᎦ ᎠᎴ ᏥᏥᏓᏬᏗᎭ ᎠᎩᎾᏫ; ᎠᏆᏛᏅᎢᏍᏗᏰᏃ, ᎥᏝ ᎥᏆᎸᏍᏗᏱᏉ ᎤᏩᏒ, ᎾᏍᏉᏍᎩᏂ ᎠᎩᏲᎱᎯᏍᏗᏱ ᏥᎷᏏᎵᎻ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᏚᏙᎥ ᎤᎬᏫᏳᎯ ᏥᏌ.


text:
ᎾᏍᏉᏃ ᎥᎪᎩᏍᏓᏩᏛᏒᎩ ᎢᎸᏍᎩ ᎢᏯᏂᏛ ᎠᏃᎯᏳᎲᏍᎩ ᏏᏌᎵᏱ ᎠᏁᎯ, ᎠᎴ ᎤᎾᏘᏅᏒᎩ ᎩᎶ ᎢᏳᏍᏗ ᏁᏌᏂ ᏧᏙᎢᏛ ᏌᏈ ᎡᎯ, ᎢᎸᎯᏳ ᎬᏬᎯᏳᏅᎯ, ᎾᏍᎩ ᎦᏁᎸ ᎣᎦᏅᏗᏱ ᎤᏂᏰᎸᏒᎩ.


text:
ᎠᎴ ᎨᏣᏛᎦᏁᎸ ᏕᎮᏲᎲᏍᎬᎢ ᏂᎦᏛ ᎠᏂᏧᏏ, ᎾᏍᎩ ᏧᎾᏓᏑᏯ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ, ᏧᏂᏲᎯᏍᏗᏱ ᎼᏏ, ᎯᎠ ᏂᏪᏍᎬᎢ; ᏞᏍᏗ ᏱᏗᏥᎱᏍᏕᏎᎮᏍᏗ ᏗᏂᏲᎵ, ᎠᎴ ᏞᏍᏗ ᏗᎧᎿᏩᏛᏍᏗ ᏱᏥᏍᏓᏩᏕᎨᏍᏗ.


text:
ᎾᏍᎩ ᏔᏘᏄᎦ, ᎠᎴ ᎢᏧᎳᎭ ᎢᏣᏓᏅᎦᎸ, ᎠᎴ ᎢᏧᎳᎭ ᎢᏣᎫᏴ, ᎾᏍᎩᏃ ᏗᏂᏍᎪᎵ ᏕᎠᎾᎵᏍᏙᏰᎲᎭ; ᎠᎴ ᏂᎦᏛ ᎠᎾᏙᎴᎰᏒᎭ ᏄᏍᏛ ᎨᏣᏛᎦᏁᎸᎢ ᎠᏎᏉᏉ ᎨᏒᎢ, ᎠᎴ ᎠᎾᏙᎴᎰᏒᎭ ᏨᏒ ᎾᏍᏉ ᏚᏳᎪᏛ ᎭᎴᏂᏙᎲᎢ, ᏗᎧᎿᏩᏛᏍᏗ ᎯᏍᏓᏩᏕᎬᎢ.


text:
ᏧᎾᏓᎴᏅᏛᏍᎩᏂ ᏴᏫ ᎤᏃᎯᏳᏅᎯ ᏥᎩ, ᏙᏦᏪᎳᏁᎸ ᏙᎫᎪᏔᏅ ᎤᏂᏍᏆᏂᎪᏙᏗᏱ ᏂᎨᏒᎾ ᎪᎱᏍᏗ ᎾᏍᎩ ᎢᏳᏍᏗ ᏧᏁᏯᏙᏤᏗᏉᏍᎩᏂ ᎤᏩᏒ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ, ᎠᎴ ᎩᎬ ᎠᎴ ᎪᎱᏍᏗ ᎬᏬᏍᏔᏅᎯ ᎠᎴ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᏉᎳ ᏚᏯᏅᎲᎩ ᎠᏂᏍᎦᏯ, ᎤᎩᏨᏛᏃ ᎢᏧᎳᎭ ᎤᎾᏓᏅᎦᎸᎲᎩ, ᏗᎦᎳᏫᎢᏍᏗᏱ ᏭᏂᏴᎸᎩ, ᎧᏃᎲᏍᎬᎩ ᎤᎵᏍᏆᏛ ᎢᎪᎯᏛ ᎠᏓᏅᎦᎸᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎠᎵᏍᏆᏗᏍᎬᎢ ᎠᏓᏁᏗ ᎨᏒ ᎠᏂᏏᏴᏫᎭ ᎤᎾᎵᏍᎪᎸᏙᏗ ᎨᏒᎢ.


text:
ᎤᏁᎷᏅᎩ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎢᏥᏍᎦᏯ, ᎢᏏᎵ ᏧᏪᏥ, ᏍᎩᏍᏕᎸ! ᎯᎠ ᎾᏍᎩ ᎠᏍᎦᏯ ᎾᏍᎩ ᏥᏕᎨᏲᎲᏍᎦ ᎾᏂᎥ ᏴᏫ ᏂᎬᎾᏛᎢ, ᏥᏓᏡᏗᎭ ᎯᎠ ᏴᏫ ᎠᎴ ᏗᎧᎿᏩᏛᏍᏗ ᎠᎴ ᎠᏂ ᎨᏒᎢ, ᎠᎴ ᎾᏍᏉ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏥᏚᏴᏔᏂᎸ ᎠᏂᎪᎢ, ᎠᎴ ᎦᏓᎭ ᏥᏄᏩᏁᎸ ᎠᏂ ᎦᎸᏉᏗᏳ ᎨᏒᎢ.


text:
ᎾᏍᎩ Ꮎ ᎩᎳᏉ ᎢᏴᏛ ᏫᏚᏯᏅᎲ ᎠᏂᏯᏫᏍᎩ ᎠᎴ ᎠᏍᎪᎯᏧᏈ ᏗᎾᏘᏂᏙᎯ, ᎠᎴ ᏗᏁᏙᎲ ᏭᏗᏢᏍᏔᏅᎩ. ᏚᏂᎪᎲᏃ ᏄᎬᏫᏳᏒ ᏗᏓᏘᏂᏙᎯ ᎠᎴ ᎠᏂᏯᏫᏍᎩ, ᎤᏂᏑᎵᎪᏨᎩ ᎠᏂᎸᏂᎲ ᏉᎳ.


text:
ᎿᏉᏃ ᏉᎳ ᏗᏐᏴ ᏮᏓᏰᏥᏴᏔᏂᏒᎢ, ᎯᎠ ᏄᏪᏎᎸᎩ ᏄᎬᏫᏳᏒ ᏗᏓᏘᏂᏙᎯ; ᏥᏌ ᏰᎵ ᎪᎱᏍᏗ ᎦᎬᏲᏎᏗ? ᎾᏍᎩᏃ ᎯᎠ ᏄᏪᏒᎩ; ᏥᎪ ᎠᏂᎪᎢ ᎤᏂᏬᏂᎯᏍᏗ ᎨᏒ ᏰᎵ ᎨᏣᏬᏂᎯᏍᏗ??


text:
ᏝᏍᎪ ᏂᎯ ᏱᎩ Ꮎ ᎢᏥᏈᏱ ᏤᎲᎩ, ᎢᎸᎯᏳ ᎤᏓᏑᏰᏛ ᎤᎾᎵᏖᎸᏗᏱ ᏥᏄᏩᏁᎸᎩ, ᎠᎴ ᏥᏚᏘᎿᏫᏛᎲᎩ ᎢᎾᎨ ᏥᏫᏚᏘᏅᏍᏔᏅᎩ ᏅᎩ ᎢᏯᎦᏴᎵ ᎢᏯᏂᏛ ᎠᏂᏍᎦᏯ ᏴᏫ ᏗᏂᎯᎯ?


text:
ᎠᏴ ᏥᏧᏏ ᏏᎵᏏᏱ ᎠᏆᏕᏅᎯ ᏓᏌ ᎦᏚᎲᎢ, ᎠᏎᏃ ᎠᏂ ᎦᏚᎲ ᎠᏆᏛᏒᎯ, ᎨᎺᎵ ᏚᎳᏍᎬᎢ ᎥᏇᏲᏅᎯ ᏭᏂᎫᏛ ᏗᎧᎿᏩᏛᏍᏗ ᎨᏒ ᏗᎩᎦᏴᎵᎨ ᎨᏥᏁᎸᎯ, ᎤᎵᏂᎩᏗᏳᏃ ᎠᏆᏓᏅᏛᎩ ᏕᏥᎦᎿᏩᏗᏒ ᎤᏁᎳᏅᎯ ᎾᏍᎩᏯ ᏂᏥᎥ ᏂᎯ ᏥᏄᏍᏗ ᏥᏣᏓᏅᏔ ᎪᎯ ᎢᎦ ᏥᎩ.


text:
ᏄᎬᏫᏳᏒᏃ ᎠᏥᎸ-ᎨᎶᎯ ᎾᏍᏉ ᎬᏂᎨᏒ ᎾᏋᏁᎭ, ᎠᎴ ᎾᎦᏛ ᏗᎨᎦᏁᎶᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎾᏍᏉ ᎪᏪᎵ ᏕᎬᎩᏅᏁᎸᎩ ᎢᏓᎵᏅᏟ ᏧᏂᎪᏩᏛᏗ, ᎠᎴ ᏕᎹᏍᎦ ᏩᎩᎶᏒᎩ, ᏕᏥᏯᏅᎲᏒ ᎾᎿ ᎠᏁᎯ ᏗᎨᎦᎸᎢᏛ ᏗᎦᏥᏯᏘᏃᎯᏍᏗᏱ ᏥᎷᏏᎵᎻ, ᎨᏥᎩᎵᏲᎢᏍᏙᏗᏱ.


text:
ᎯᎠᏃ ᏄᏪᏒᎩ; ᎤᏁᎳᏅᎯ ᏗᎩᎦᏴᎵᎨ ᎤᎾᏤᎵᎦ ᏣᏑᏰᏒ, ᏣᎦᏙᎥᎯᏍᏗᏱ ᏄᏍᏛ ᎠᏓᏅᏖᏍᎬᎢ, ᎠᎴ ᎯᎪᏩᏛᏗᏱ ᎾᏍᎩ Ꮎ ᎾᏍᎦᏅᎾ, ᎠᎴ ᎠᎰᎵ ᎦᎾᏄᎪᎬ ᎧᏁᎬ ᏣᏛᎪᏗᏱ.


text:
ᎬᏩᏛᏓᏍᏓᏁᎲᎩᏃ ᎬᏂ ᎾᏍᎩ ᎯᎠ ᏄᏪᏒ, ᎿᏉᏃ ᎤᏂᏌᎳᏓᏅᎩ ᎠᏂᏁᎬ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎡᎶᎯ ᏩᎦᏘᎿᏫᏛ ᎾᏍᎩᏉ ᎢᏳᏍᏗ ᏴᏫ; ᎥᏝᏰᏃ ᏰᎵ ᎬᏁᏍᏗ ᎦᏰᎵᏍᏗ ᏱᎩ.


text:
ᎬᏩᎵᎥᏂᏍᏗᏱᏃ ᎬᏩᏘᏃᎸ, ᏉᎳ ᎯᎠ ᏄᏪᏎᎸᎩ ᎾᎥ ᎦᏙᎩ ᎠᏍᎪᎯᏧᏈ ᏗᏘᏂᏙᎯ; ᏰᎵᏉᏍᎪ ᏗᎧᎾᏩᏛᏍᏗ ᏂᎬᏅ ᎦᏰᏥᎵᎥᏂᏍᏗ ᎠᏍᎦᏯ ᎠᎶᎻ, ᎤᏍᎦᏅᏨ ᏧᏚᎪᏔᏅᎯ ᏂᎨᏒᎾ ᏱᎩ?


text:
ᎤᎩᏨᏛᏃ ᎤᏚᎵᏍᎬ ᎢᏳᏍᏗ ᏚᏳᎪᏛ ᎤᏙᎴᎰᎯᏍᏗᏱ ᏅᏓᎦᎵᏍᏙᏗᏍᎬ ᎠᏂᏧᏏ ᎬᏭᎯᏍᏗᏍᎬᎢ, ᎤᎸᏒᎲᎩ, ᎠᎴ ᎤᏁᏨᎩ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸᎠᏁᎶᎯ ᎠᎴ ᏂᎦᏛ ᏗᏂᎳᏫᎩ, ᎤᎾᏓᏟᏐᏗᏱ, ᎠᎴ ᎤᏘᏃᎸᎩ ᏉᎳ, ᎠᏂᏅᎢᎬᏱᏢ ᎤᏪᎧᏅᎩ.


text:
ᏉᎳᏃ ᎤᏯᏅᏒᎯ ᏚᎧᎿᏅ ᏗᏂᎳᏫᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ, ᎪᎯ ᎢᎦ ᎢᏯᏍᏗ, ᎠᏆᏓᏅᏙ ᎠᏆᏎᎮᎲ ᏓᎩᎸᏫᏍᏓᏁᎲᎩ ᏂᎦᎥ ᏚᏳᎪᏛ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ.


text:
ᏉᎳᏃ ᎯᎠ ᏄᏪᏎᎸᎩ; ᎤᏁᎳᏅᎯ ᏓᏨᏂᎵ ᏂᎯ, ᎠᏐᏱ ᎤᏁᎬᎢᎬᏁᎸᎯ; ᏦᎳᏰᏃ ᎨᎵ ᏗᏍᏇᎪᏓᏁᏗᏱ ᎾᏍᎩᏬ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬᎢ? ᏥᎪᏃ ᎢᎯᏁᎦ ᎥᏋᏂᏍᏗᏱ ᏗᎧᎿᏩᏛᏍᏗ ᏙᎯᎦᏘᎴᎦ?


text:
ᏉᎳᏃ ᎯᎠ ᏄᏪᏒᎩ; ᎢᏓᏓᏅᏟ, ᎥᏝ ᏱᎨᎵᏍᎨ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎨᏒᎢ; ᎯᎠᏰᏃ ᏥᏂᎬᏅ ᏥᎪᏪᎳ; "ᏞᏍᏗ ᎤᏐᏅ ᏱᏁᏤᎮᏍᏗ ᏣᎦᏁᎶᏗ ᏗᏣᏤᎵ ᏴᏫ ᎤᎾᏤᎵᎦ."


text:
ᏉᎳᏃ ᎤᏙᎴᎰᏒ ᎢᎦᏛ ᎠᏂᏌᏚᏏ ᎨᏒᎢ, ᎢᎦᏛᏃ ᎠᏂᏆᎵᏏ, ᎤᏪᎷᏅᎩ ᏕᎦᎳᏫᎥᎢ ᎯᎠ ᏄᏪᏒᎩ; ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ, ᎠᏴ ᏥᏆᎵᏏ, ᎠᏆᎵᏏ ᎤᏪᏥ; ᎤᏚᎩ ᎬᏗ ᎨᏒ ᎠᎴ ᎠᏲᎱᏒ ᏗᎴᎯᏐᏗ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᏆᎵᏱᎵᏕᎭ.


text:
ᎤᏣᏘᏃ ᎤᏁᎷᏅᎩ; ᏗᏃᏪᎵᏍᎩᏃ ᎠᏂᏆᎵᏏ ᎤᎾᎵᎪᏒ ᎤᎾᎵᎪᎯ ᏚᎾᎴᏅᎤᎾᏗᏒᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᎥᏝ ᎪᎱᏍᏗ ᎤᏲ ᏲᏥᏩᏛᎡᎭ ᎯᎠ ᎠᏍᎦᏯ, ᎢᏳᏍᎩᏂ ᎠᏓᏅᏙ ᎠᎴ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏁᏤᎸᎯ ᎨᏎᏍᏗ, ᏞᏍᏗ ᎤᏁᎳᏅᎯ ᏤᏓᏟᏴᎡᎸᎩ.


text:
ᎤᏣᏘᏃ ᎤᏂᏲᏠᎯᏎᎸ, ᏄᎬᏫᏳᏒ ᏗᏓᏘᏂᏙᎯ ᎠᏍᎦᎢᎲᎢ ᏉᎳ ᏱᎬᏪᏓᎦᎸᎥᎦ ᎡᎵᏍᎬᎢ, ᏚᏁᏤᎸᎩ ᎠᏂᏯᏫᏍᎩ ᎤᏁᏅᏍᏗᏱ ᎠᎴ ᏫᏚᎾᏑᎦᎸᏙᏗᏱ, ᎠᎴ ᎤᏂᏴᏔᏂᎯᏍᏗᏱ ᏗᏐᏴᎢ.


text:
ᎾᎯᏳᏃ ᏒᏃᏱ ᏫᏄᎵᏍᏔᏅ, ᎤᎬᏫᏳᎯ ᎾᎥ ᎤᎴᏁᎴᎢ, ᎯᎠ ᏄᏪᏎᎢ; ᎤᎦᎵᏍᏗ ᏣᏓᏅᏖᏍᏗ, ᏉᎳ, ᎬᏂᎨᏒᏰᏃ ᏥᏂᏍᏋᏁᎸ ᏥᎷᏏᎵᎻ, ᎾᏍᏉ ᎬᏂᎨᏒ ᏅᏓᏍᏋᏁᎵ ᏣᏂ.


text:
ᏑᎾᎴᏃ ᏄᎵᏍᏔᏅ ᎩᎶ ᎢᏳᎾᏍᏗ ᎠᏂᏧᏏ ᎤᎾᎵᎪᏁᎢ, ᎤᎾᏎᎵᏔᏁ ᏚᎾᏓᏁᏤᎴ ᎨᏥᏍᎩᏅᏗᏍᏗᏱ, ᎯᎠ ᏄᏂᏪᏎᎢ; ᎥᏝ ᎪᎱᏍᏗ ᏴᎨᏗᎦ ᎠᎴ ᏴᎨᏓᏗᏔ, ᎬᏂ ᏉᎳ ᎡᏗᎸᎯ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩᏃ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ ᎠᏁᎶᎯ ᎠᎴ ᏗᏂᎳᏫᎩ, ᏚᏂᎷᏨᎸᎩ ᎯᎠ ᏄᏂᏪᏒᎩ; ᎣᎦᏎᎵᏔᏅ ᏙᎦᏓᏁᏤᎸ ᎣᎩᏍᏛᏗᏍᏗᏱ, ᎪᎱᏍᏗ ᎣᎦᏅᏍᎦᎶᏗᏱ ᎠᎴ ᎣᎦᏚᎩᏍᏗᏱ ᏂᎨᏒᎾ ᎬᏂ ᏉᎳ ᎣᏥᎸᎯ ᎨᏎᏍᏗ.


text:
Ꭷ ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᎯ ᎠᎴ ᏗᏂᎳᏫᎩ ᎢᏣᎵᎪᎲᎦ, ᎡᏥᏔᏂᏲᏏ ᏄᎬᏫᏳᏒ ᏗᏓᏘᏂᏙᎯ, ᎤᎩᏨᏅ ᎢᏣᏘᏃᎮᏗᏱ ᏥᏣᏚᎵᏍᎪ ᎾᏍᎩᏯᎢ ᎯᎠ ᎾᏍᎩ ᎠᎫᎢᏍᏗᏍᎬᎢ, ᎠᏴᏃ ᎠᏏᏉ ᎾᎥ ᏂᎦᎷᎬᎾ ᎨᏎᏍᏗ, ᎣᎦᏛᏅᎢᏍᏗ ᎣᏥᎢᏍᏗᏱ.


text:
ᎠᏎᏃ ᏞᏍᏗ ᏙᎯᏳᏅᎩ; ᏅᎦᏍᎪᎯᏰᏃ ᎤᏗᏢᏍᏙᏗ ᎢᏯᏂᏛ ᎠᏂᏍᎦᏯ ᎬᏩᎭᎷᎦ, ᎾᏍᎩ ᎤᎾᏎᎵᏔᏅᎯ ᏚᎾᏓᏁᏤᎸ ᎤᎾᎵᏍᏓᏴᏗᏱ ᎠᎴ ᎤᎾᏗᏔᏍᏗᏱ ᏂᎨᏒᎾ, ᎬᏂ ᎤᏂᎸᎯ ᎨᏎᏍᏗ; ᎿᏉᏃ ᎤᎾᏛᏅᎢᏍᏗ ᎠᏂᎦᏘᏴ ᎤᎾᏛᎪᏗᏱ ᏣᏚᎢᏍᏔᏅᎢ.


text:
ᏫᏑᏯᏅᎲᏃ ᎠᏂᏔᎵ ᎠᏍᎪᎯᏧᏈ ᏗᎾᏓᏘᏂᏙᎯ, ᎯᎠ ᏄᏪᏒᎩ; ᏗᏍᏓᏛᏅᎢᏍᏓ ᏔᎵᏧᏈ ᎠᏂᏯᏫᏍᎩ, ᎠᎴ ᎦᎵᏆᏍᎪᎯ ᏧᎾᎩᎸᏗ, ᎠᎴ ᏗᏓᏘᏍᏗ ᏗᏂᏂᏙᎯ ᏔᎵᏧᏈ, ᏏᏌᎵᏱ ᎠᏁᏒᎭ ᏐᎣᏁᎵᏁ ᎢᏳᏟᎶᏛ ᏒᏃᏱ;


text:
ᎠᎴ ᎥᎩᏃᏁᎸ ᎠᏂᏧᏏ ᎤᏂᎭᎷᎬ ᎾᏍᎩ ᎠᏍᎦᏯ, ᎩᎳᏉ ᎢᏴᏛ ᎠᏆᏓᏅᏒ ᏗᏦᎸᎢ, ᎠᎴ ᎾᏍᏉ ᎦᏥᏁᏤᎸ ᎬᏬᎯᏍᏗᏍᎩ ᎯᎦᏔᎲ ᎤᏂᏃᎮᏗᏱ ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎠᏄᎯᏍᏗᏍᎬᎢ. ᏙᎯᏱ ᏂᏣᏛᎿᏕᎨᏍᏗ."


text:
ᎯᏍᎩᏃ ᏫᏄᏒᎳ ᎡᏂᎾᏯ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎤᎷᏨᎩ, ᎠᏁᎲ ᏗᎨᎦᏁᎶᏗ, ᎠᎴ ᎩᎶ ᎢᏳᏍᏗ ᏗᏘᏲᎯ-Ꭿ, ᏔᏓᎳ ᏧᏙᎢᏛ, ᎾᏍᎩ ᎤᏂᏃᏁᎸᎩ ᎤᎬᏫᏳᎯ, ᎠᏄᎯᏍᏗᏍᎬ ᏉᎳ.


text:
ᏩᏥᏯᏅᎲᏃ ᏔᏓᎳ ᎤᎴᏅᎲᎩ ᎤᏬᎯᏍᏔᏅᎩ, ᎯᎠ ᏄᏪᏒᎩ; "ᏂᎯ ᎢᏣᏂᏌᏅᎯ ᎤᏣᏘ ᏅᏩᏙᎯᏯᏛ ᏦᏤᎭ, ᎠᎴ ᎣᏍᏛ ᏥᏄᎾᎵᏍᏓᏁᎭ ᏴᏫ ᎣᎦᏤᎵᎪᎯ ᏣᎦᏌᏯᏍᏗᏳ ᎨᏒ ᏥᏅᏗᎦᎵᏍᏙᏗᎭ,


text:
ᎣᎦᏙᎴᎰᏒᏰᏃ ᎯᎠ ᎾᏍᎩ ᎠᏍᎦᏯ ᎤᏣᏔᏅᎯ ᎤᏕᏯᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎦᏂᎳᏗᏍᎩ ᏧᏓᎴᏅᏛ ᏂᎦᏛ ᎠᏂᏧᏏ ᎠᏁᎲ ᏂᎬᎾᏛ ᎡᎶᎯ, ᎠᎴ ᏄᎬᏫᏳᏒ ᏗᏓᏘᏂᏙᎯ ᎤᎾᎵᎪᏒ ᎾᏎᎵᏂ ᏧᎾᏙᎢᏛ.


text:
ᎿᏉᏃ ᏉᎳ, ᎤᎬᏫᏳᎯ ᎤᎵᏍᎫᏫᏎᎸ ᎤᏁᎢᏍᏗᏱ ᎤᎵᏍᎪᎸᏓᏁᎸ, ᎯᎠ ᏄᏪᏒᎩ; "ᏏᎦᏔᎯᏳ ᏥᎩ ᎢᎸᏍᎩ ᏧᏕᏘᏴᏛ ᏚᎪᏓᏁᎯ ᎢᎬᏩᎵᏍᏔᏅᎯ ᎨᏒ ᎯᎠ ᏑᎾᏓᎴᎩ ᏴᏫ, ᎾᏍᎩ ᏅᏓᎦᎵᏍᏙᏓ ᎤᏟ ᎤᎦᎵᏍᏗᏳ ᏴᏫ, ᎾᏍᎩ ᏅᏓᎦᎵᏍᏙᏓ ᎤᏟ ᎤᎦᎵᏍᏗᏳ ᎦᏓᏅᏓᏓ, ᎠᏋᏒ ᎦᎵᏍᏕᎵᏍᎬ ᎬᎩᏁᎢᏍᏗ ᏥᏂᎦᎵᏍᏓ.


text:
ᎠᎴ ᎥᏝ ᏱᎬᎩᏩᏛᎮ ᎩᎶ ᏲᏍᏓᏗᏒᎯᎮ ᎣᏍᏗᏬᏂᏍᎬᎢ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᎥᏝ ᏱᏗᏥᏖᎸᎲᏍᎨ ᏚᎾᏓᏅᏛ ᏴᏫ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏕᎨᏌᏗᏒᎢ ᎠᎴ ᎢᎸᎯᏢ ᎦᏚᎲᎢ.


text:
ᎯᎠᏍᎩᏂᏃᏅ ᎬᏃᎲᏏ, ᎾᏍᎩ ᎤᎾᏓᏤᎵᏛ ᎤᎾᎵᎪᎯ ᏥᏓᏃᏎᎭ, ᎾᏍᎩ ᎦᏥᏍᏓᏩᏗᏒ ᏥᏯᏓᏙᎵᏍᏓᏁᎲ ᎤᏁᎳᏅᎯ ᏗᎩᎦᏴᎵᎨ ᎤᎾᏤᎵᎦ, ᎪᎢᏳᎲᏍᎬᎢ ᏂᎦᏛ ᎪᏪᎵ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ ᏚᏃᏪᎸᎢ;


text:
ᎾᏍᎩᏃ ᏂᎦᏛᏁᎲᎢ ᎩᎶ ᎢᏳᎾᏍᏗ ᎠᏂᏧᏏ ᎡᏏᏱ ᎠᏁᎯ ᎬᎩᏩᏛᎲᎩ ᎠᏆᏓᏅᎦᎵᏌᏛ ᎨᏒᎩ ᏥᏯᎥᎩ ᎤᏛᏅᏗᎦᎳᏫᎢᏍᏗᏱ, ᎥᏝ ᏱᎨᎳᏗᏙᎮ ᎤᏂᏣᏘ ᎠᏁᏙᎲᎢ, ᎠᎴ ᎤᎾᏓᏑᏰᏛ ᎨᏒᎢ;


text:
ᎤᏁᏤᎸᎩᏃ ᎠᏍᎪᎯᏧᏛ ᏗᏘᏂᏙᎯ ᏧᎧᎿᏩᏗᏓᏍᏗᏱ ᏉᎳ, ᎠᎴ ᎤᏁᎳᎩ ᏪᏓ ᎤᏪᎵᏎᏗᏱ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎸᎩ; ᏞᏍᏗ ᏣᏅᏍᏙᏒᎩ ᎩᎶ ᎢᏳᏍᏗ ᎤᎾᎵᎢ ᎤᏍᏕᎸᎯᏓᏍᏗᏱ ᎠᎴ ᎤᏩᏛᎯᎯᏍᏗᏱ.


text:
ᎠᏏᏉᏃ ᎧᏃᎮᏍᎬ ᏚᏳᎪᏛ ᎨᏒᎢ, ᎠᎴ ᎠᎵᏏᎾᎯᏍᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏧᏬᎪᏙᏗᏱ ᎤᎵᏱᎶᎯᏍᏗ ᎨᏒᎢ, ᏈᎵᏏ ᎤᏪᎾᏮᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᏁᏗ ᏂᎦᎵᏍᏔᏅᎭ ᏫᎬᏯᏅᎲᎭ.


text:
ᎤᏩᏒᏃ ᎠᎵᏍᏕᎵᏍᎬ ᎤᏁᏨᎩ ᎯᎠ ᏄᏪᏒᎩ; ᎥᏝ ᎤᏍᏗᎤᏅ ᎠᎩᏍᎦᏅᏨᎯ ᏱᎩ ᎠᏂᏧᏏ ᏧᏂᎧᎿᏩᏛᏍᏗ ᎤᏂᎲᎢ, ᎥᏝ ᎠᎴ ᎤᏛᏅ-ᏗᎦᎳᏫᎢᏍᏗᏱ ᏥᏍᎦᏅᏤᎸᎯ ᏱᎩ, ᎥᏝ ᎠᎴ ᏏᏌ ᎪᎱᏍᏗ ᏥᏍᎦᏅᏤᎸᎯ ᏱᎩ.


text:
ᎠᏎᏃ ᏇᏍᏓ ᎤᏚᎵᏍᎬᎢ ᎠᏂᏧᏏ ᎣᏍᏛ ᏧᏓᏅᏓᏗᏍᏙᏗᏱ ᏅᏓᏳᎵᏍᏙᏔᏅ, ᎤᏁᏤᎸᎩ ᏉᎳᎯᎠ ᏄᏪᏎᎸᎩ; ᏣᏚᎵᏍᎪ ᏥᎷᏏᎵᎻ ᏤᏅᏍᏗᏱ ᎠᎴ ᎾᎿ ᎯᎠ ᎾᏍᎩ ᏗᎬᏳᎪᏓᏁᏗᏱ?


text:
ᎢᏳᏰᏃ ᏥᏍᎦᎾ ᏱᎩ, ᎠᎴ ᎬᎩᏲᎱᎯᏍᏗ ᎢᎦᎢ ᎠᎩᏍᎦᏅᏨᎯ ᏱᎩ, ᎥᏝ ᏱᏙᎬᏆᎵᏢᏫᏏ ᎠᎩᏲᎱᎯᏍᏗᏱ; ᎢᏳᏍᎩᏂ ᏄᏙᎯᏳᏒᎾ ᏱᎩ ᎯᎠ ᎾᏍᎩ ᏥᎬᏇᎯᏍᏗᎭ, ᎥᏝ ᎩᎶ ᏰᎵ ᏗᎬᏩᏂᏲᎯᏎᏗ ᏱᎩ ᎠᏴ. ᏏᏐᎢ ᏫᏥᎥᏍᏓ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏂᎦᏥᏪᏎᎸᎩ; ᎠᏂᎶᎻ ᎥᏝ ᎾᏍᎩ ᏱᏄᏅᏅ, ᎾᏍᎩ ᏧᏂᏲᎯᏍᏗᏱ ᎩᎶ ᎤᏲᎱᎯᏍᏗᏱ, ᎬᏂ ᎠᎫᎢᏍᏗᏍᎩ ᎩᎶ ᎤᏲᎱᎯᏍᏗᏱ, ᎬᏂ ᎠᎫᎢᏍᏗᏍᎩ ᎬᏭᎯᏍᏗᏍᎩ ᏚᎾᎧᏛ ᏧᎪᎲᎯ ᏥᎨᏐ ᎠᎴ ᎠᎦᎵᏍᎪᎸᏓᏁᎸᎯ ᏥᎨᏐ ᎤᏩᏒ ᎠᎵᏍᏕᎵᏍᎬ ᎤᏁᎢᏍᏗᏱ ᎤᏃᎮᏗᏱ ᎤᏍᎦᏅᏨ ᎠᎫᎢᏍᏗᏍᎬ ᎤᎬᏩᎵ.


text:
ᎠᏄᎯᏍᏗᏍᎬᏍᎩᏂ ᎪᎱᏍᏗᏉ ᎤᏍᏗ ᎾᏍᎩ ᎧᏃᎮᏗ ᎨᏒ ᎤᏅᏒᏉ ᎤᎾᏤᎵᏛ ᎤᏁᎳᏅᎯ ᏧᏂᎧᎿᏩᏛᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎩᎶ ᎢᏳᏍᏗ ᏥᏌ, ᎤᏲᎱᏒᎯ, ᎾᏍᎩ ᎡᎭ ᎠᏗᏍᎨ ᎨᎵ ᏉᎳ.


text:
ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗ ᎧᏃᎮᏛ ᎨᏒ ᏓᏆᏢᏫᏎᎲᎢ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ, ᎯᎠ ᏅᏥᏪᏎᎸᎩ <n>[ᏉᎳ]</n>; ᏣᏚᎵᏍᎪ ᏥᎷᏏᎵᎻ ᏤᏅᏍᏗᏱ ᎾᎿᏃ ᎯᎠ ᎾᏍᎩ ᏂᎦᏛ ᏤᏧᎪᏓᏁᏗᏱ.


text:
ᎰᏩᏃ ᎤᎩᏨᏛ ᎤᏣᏘ ᎤᎾᏣᏅᎯ ᎤᏂᎷᏨ ᎡᎩᎵᏈ ᎠᎴ ᏆᏂᏏ, ᎾᏍᎩᏃ ᏗᏓᏱᎵᏓᏍᏗᏱ ᎤᏂᏴᎸ, ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᏗᎾᏓᏘᏂᏙᎯ, ᎠᎴ ᎨᏥᎸᏉᏗ ᎾᎿ ᎦᏚᎲ ᎠᏁᎯ, ᏇᏍᏓ ᎤᏁᏨ, ᏉᎳ ᏩᏥᏯᏅᎲᎩ.


text:
ᏇᏍᏓᏃ ᎯᎠ ᏄᏪᏒᎩ; Ꮳ-ᎬᏫᏳᎯ ᎡᎩᎵᏈ, ᎠᎴ ᎾᏍᏉ ᏂᎦᏛ ᎢᏥᏍᎦᏯ ᎠᏂ ᏥᏗᎾ; ᎡᏥᎪᏩᏗᎭ ᎯᎠ ᎠᏍᎦᏯ, ᎾᏍᎩ; ᎡᏄᎯᏍᏗᏍᎬ ᏂᎦᏛ ᎤᏂᏣᏘ ᎠᏂᏧᏏ ᏥᎬᎩᎷᏤᎸᎩ ᏥᎷᏏᎵᎻ, ᎠᎴ ᎾᏍᏉ ᎠᏂ, ᎯᎠ ᏥᎾᏂᏪᏍᎬᎩ; ᎥᏝ ᎣᏏᏳ ᏱᎦᎩ ᎠᏏᏉ ᏱᎬᏅ.


text:
ᎾᏍᎩ ᏥᏃᎮᏍᎬᎢ, ᎥᏝ ᎪᎱᏍᏗ ᎤᏍᏆᏂᎪᏗ ᏯᎩᎭ ᎦᏥᏲᏪᎳᏁᏗ ᎤᎬᏫᏳᎯ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏨᏯᏘᏃᎯᏏ, ᎠᎴ ᏂᎯ Ꮀ ᎤᎬᏫᏳᎭ ᎬᏩᏘᏃᎯᏏ, ᏣᎬᏫᏳᎯ ᎡᎩᎵᏈ, ᎾᏍᎩᏃ ᎡᏗᎪᎵᏰᎥᎯ ᎨᏎᏍᏗ, ᎪᎱᏍᏗ ᏰᎵ ᎬᏉᏪᎶᏗ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎬᎩᎦᏔᎲᎩ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᎢᏳᏃ ᏳᏂᏃ-ᎮᎸ, ᎠᏂᎦᏔᎯᏳᏰᏃ ᎠᏆᎵᏏ ᎤᎴᏂᏓᏍᏗ ᎠᏆᎴᏂᏙᎸᎢ, ᏕᏥᏍᏓᏩᏗᏒ ᎤᎾᏓᏤᎵᏛ ᎤᎾᎵᎪᎯ ᏭᏂᎫᏛ ᏗᏂᎧᎿᏩᏕᎩ ᎣᎦᏤᎵ ᎤᏁᎳᏅᎯ ᏦᏥᎧᎿᏩᏛᏍᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎨᏥᏚᎢᏍᏓᏁᎸ ᎤᎾᎵᏱᎶᎯᏍᏗᏱ ᎤᏚᎩ ᎤᏅᎭ ᏔᎳᏚ ᏃᏥᎳᏍᏓᎸᎢ, ᎤᎵᏂᎩᏗᏳ ᏥᏓᏂᎧᎿᏩᏗ ᎤᏁᎳᏅᎯ ᏗᎬᏩᎩᏨᏗ. ᎾᏍᎩ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᎭ, ᏣᎬᏫᏳᎯ ᎡᎩᎵᏈ, ᎠᏂᏧᏏ ᎬᏇᎯᏍᏗᎭ.


text:
ᎰᏩᏃ ᎾᏍᎩ ᎾᏆᏛᏁᎸᎩ ᏥᎷᏏᎵᎻ; ᎠᎴ ᎤᏂᏣᏛᎩ ᎤᎾᏓᏅᏘ ᏕᏥᏍᏚᏅᎩ ᏗᏓᏍᏚᏗᏱ, ᎬᎩᏁᏤᎸᎯ ᎨᏒᎩ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ; ᏕᎨᏥᎷᎦᏃ ᏥᏁᎬᎩ ᎦᏥᏯᏡᏗᏍᎬᎢ.


text:
ᎠᎴ ᏯᏃᎩᏳ ᎤᏲ ᏂᎦᏥᏴᏁᎲ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏕᎨᏌᏗᏒᎢ,ᎠᎴ ᎤᏂᏐᏢᎢᏍᏙᏗᏱ ᏂᎦᏥᏴᏁᎲᎩ; ᎤᏣᏔᏅᎯᏃ ᎦᏥᏂᏆᏘᎲ ᎾᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎤᏲ ᏂᎦᏥᏴᏁᎲ ᏅᏩᏓᎴ ᏙᏗᎦᏚᎲ ᏫᎦᏥᎨᎰᎢᎲᎩ.


text:
ᏂᎦᏛᏃ ᎡᎳᏗ ᏙᎩᏅᏨ, ᎾᏁᎬ ᎠᏆᏛᎦᏅᎩ ᎠᎩᏁᏤᎲᎩ, ᎠᏂᏧᏏ ᎤᏂᏬᏂᎯᏍᏗ ᎬᏗᏍᎬᎩ; ᎯᎠ ᏂᎦᏪᏍᎬᎩ ᏐᎳ, ᏐᎳ, ᎦᏙᏃ ᎤᏲ ᏂᏍᏋᏁᎭ? ᎤᏕᏯᏙᏗᏳ ᏗᏣᎲᏖᏍᏗᏱ ᏗᎪᏍᏓᏯ.


text:
ᎠᏎᏃ ᏔᎴᎲᎦ, ᎠᎴ ᎭᎴᎲᎦ, ᎯᎠᏰᏃ ᏅᏗᎦᎵᏍᏙᏖᎭ ᎬᏂᎨᏒ ᏥᏂᎬᏯᏛᏂᏏ, ᎭᎵᏥᏙᎲᏍᎩ ᎢᎬᏴᏁᏗᏱ ᎠᎴ ᎯᏃᎮᏍᎩᎯᎠ ᎾᏍᎩ ᏥᎪᏩᏛ, ᎠᎴ ᎠᏏ ᎬᎾᏄᎪᏫᏎᏗ ᏥᎩ.


text:
ᏘᏍᏚᎢᎡᏗᏱ ᏗᏂᎦᏙᎵ, ᎠᎴ ᎤᎵᏏᎬ ᏄᎾᏛᏅ ᏘᎪᎸᏍᏗᏱ ᎢᎦᎦᏛ ᎢᏗᏢ ᏫᏘᎦᏔᎲᏍᏗᏱ, ᎠᎴ ᏎᏓᏂ ᎤᏤᎵᎪᎯ ᏄᎾᏛᏅ ᏘᎪᎸᏍᏗᏱ ᏙᏘᎦᏔᎲᏍᏗᏱ ᎤᏁᎳᏅᎯ ᎢᏗᏢ ᏫᏘᎦᏔᎲᏍᏙᏗᏱ; ᎾᏍᎩ ᏗᎦᎨᏥᏁᏗᏱ ᎤᏁᏍᎦᏅᏨᎢ, ᎠᎴ ᎬᏩᏂᏩᏛᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎤᎾᏤᎵᎦ ᎢᏳᎵᏍᏙᏗ ᎨᏒ ᎨᏥᏅᎦᎸᏛ ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎥᏉᎯᏳᏗ ᎨᏒᎢ.


text:
ᎦᏥᏃᏁᎸᎩᏰᏃ ᎢᎬᏱ ᏕᎹᏍᎦ ᎠᏁᎯ, ᎠᎴ ᏥᎷᏏᎵᎻ ᎠᏁᎯ, ᎠᎴ ᏂᎬᎾᏛ ᏧᏗᏱ ᎠᎴ ᎾᏍᏉ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᏧᏂᏁᏟᏴᏍᏗᏱ ᏚᎾᏓᏅᏛᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎢᏗᏢ ᏭᎾᎦᏔᎲᏍᏙᏗᏱ, ᎠᎴ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ ᎠᏙᎴᎰᎯᏍᏙᏗ ᎨᏒ ᏚᏂᏁᏟᏴᏒ ᏚᎾᏓᏅᏛᎢ.


text:
ᎤᏁᎳᏅᎯᏃ ᎠᎩᏍᏕᎸᎲᎢ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᏏ ᎦᎴᏂᏙᎭ ᎪᎯ ᎢᎦ ᏥᎩ, ᎬᏂᎨᏒ ᏂᎦᏥᏴᏁᎭ ᏂᎨᏥᎸᏉᏛᎾ ᎠᎴ ᎾᏍᏉ ᎨᏥᎸᏉᏗ, ᎪᎱᏍᏗ ᏂᏥᏃᎮᏍᎬᎾ Ꮎ ᎤᏩᏒ ᎠᎾᏙᎴᎰᏍᎩ ᎠᎴ ᎼᏏ ᎤᎾᏄᎪᎢᏍᏗ ᎤᎾᏛᏅᎯ ᏥᎩ;


text:
ᎤᎬᏫᏳᎯᏃ ᎾᏍᎩ ᎯᎠ ᎠᎦᏔᎭ, ᎾᏍᎩ ᎾᏍᏉ ᎤᏛᏓᏍᏛ ᏂᏥᏍᎦᎢᎲᎾ ᏥᏥᏁᎦ; ᏥᎦᏔᎭᏰᏃ ᎯᎠ ᎾᏍᎩ ᎪᎱᏍᏗ ᎠᎬᏍᎦᎳᏁᎸᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏞᏰᏃ ᎤᏅᏏᏴ ᎯᎠ ᏗᎦᎸᏫᏍᏓᏁᎸᎯ ᏱᎩ.


text:
ᏉᎳᏃ ᎯᎠ ᏄᏪᏒᎩ; ᎤᏁᎳᏅᎯ ᏥᏯᏚᎸᎡᎭ, ᎥᏝ ᏂᎯᏉ ᏨᏒ, ᎾᏍᏉᏍᎩᏂ ᏂᎦᏛ ᏥᎬᏆᏛᎦᏁᎭ ᎪᎯ ᎢᎦ ᏥᎩ, ᎾᏍᎩ, ᎥᏝ ᎠᎴᏉ ᎾᏆᏍᏛᎢ, ᎾᏍᎩᏯᏍᎩᏂ ᎾᏆᏍᏛ ᎢᏣᎵᏍᏙᏗᏱ, ᎯᎠ ᎾᏍᎩ ᏨᏆᎸᎥ ᎤᏩᏒ.


text:
ᎿᏉᏃ ᏚᏚᎪᏔᏅ ᎢᏓᎵ ᏭᎩᏅᏍᏙᏗᏱ ᏥᏳ, ᏚᏂᏲᏒᎩ ᏉᎳ ᎠᎴ ᎩᎶ ᎢᏳᎾᏍᏗ ᏅᏩᎾᏓᎴ ᎠᏂᏴᎩ, ᎾᏍᎩ ᏚᏂᏲᎯᏎᎸ ᎩᎶ ᎢᏳᏍᏗ ᎠᏍᎪᎯᏧᏈ ᏗᏘᏂᏙᎯ, ᏧᎵᏯᏏ ᏧᏐᎢᏛ, ᎨᎳ ᏑᎾᏓᏡᎩ ᎨᏒ ᎣᎦᏍᏓ ᏧᏤᎵᎦ.


text:
ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎢᏥᏍᎦᏯ, ᎦᏙᎴᎣᏍᎦ ᎯᎠ ᎾᏍᎩ ᏥᏳ ᏥᏗᏂ ᎪᎱᏍᏗ ᏗᎦᎵᏍᏓᏁᎵᏒᎢ,ᎠᎴ ᎤᏣᏛ ᏗᎩᏲᎱᏎᎵᏒᎢ, ᎥᏝ ᎠᎵᏁᏌᎸᏉ ᎠᎴ ᏥᏳ ᎤᏩᏒ, ᎾᏍᏉᏍᎩᏂ ᏕᏛᏅᎢ.


text:
ᏗᏔᎳᏗᏍᏗᏱᏃ ᏃᏒᎾ ᎨᏒ ᎾᎿ ᎤᎪᎳᏗᏴᏗᏱ, ᎤᏟ ᎢᏯᏂᎢ ᎤᏂᏁᏨᎩ ᎾᏍᏉ ᎾᎿ ᎤᏂᏴᏫᏛᏗᏱ, ᏰᎵ ᏈᏂᏏ ᏫᎦᏲᎩᏃᎯᏍᏗ ᎠᎴ ᏫᎦᏲᎦᎪᎳᏗᏴᏗ ᏱᎩ ᎠᏁᎵᏍᎬᎩ, ᎾᏍᎩ ᎾᎿ ᏟᏗ ᏗᏔᎳᏗᏍᏗᏱ, ᎠᎴ ᎾᏍᎩ ᏭᏕᎵᎬ ᎢᏗᏢ ᏭᎦᏘ.


text:
ᎾᏍᎩᏃ ᎤᏂᏌᎳᏓᏅ, ᏗᎵᏍᏕᎸᏙᏗ ᏚᏅᏔᏅᎩ, ᎤᎾᎸᎸᎩ ᏥᏳ; ᎠᏂᏍᎦᎢᎲᏃ ᎤᏍᏓᎾᎸ ᎤᏂᏃᏠᎯᏍᏗᏱ ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎡᎳᏗ ᏂᏚᏅᏁᎸᎩ ᏓᏰᏙᎳᏛᎢ, ᎤᏂᏄᎯᏒᏉᏃ.


text:
ᎿᏉᏃ ᎪᎯᏗᏳ ᎦᏲᎦᎵᏍᏓᏴᏅᎯ ᏄᎵᏍᏔᏅ ᏉᎳ ᏚᎴᏅᎩ ᎠᏰᎵ ᎤᎾᏣᎥᎢ, ᎠᎴ ᎯᎠ ᏄᏪᏒᎩ; ᎢᏥᏍᎦᏯ, ᏱᏍᎩᏲᎢᏳᏁᎢ, ᎠᎴ ᏅᏗᏥᎧᏙᏴᎾᏉ ᏱᎨᏎ ᏟᏗ, ᎥᏝ ᎾᏍᎩ ᎯᎠ ᎤᏐᏅ ᏱᏂᎨᏣᎵᏍᏓᏁᎴ ᎠᎴ ᏱᎨᏥᎪᎶᎯᏎᎴᎢ.


text:
ᎿᏉᏃ ᏚᏂᎦᎵᏒ ᏕᎦᏙᏌᏗᏍᏛ ᏔᎷᎩᏍᎩ ᏥᏳ ᏗᎦᎾᎯᏍᏙᏗ, ᎠᎺᏉ-Ꭿ ᏚᏂᏲᎯᏎᎸᎩ, ᎠᎴ ᏚᏂᎧᏁᏴᎲᎩ ᎦᏌᏛᏍᏗ ᏕᎦᎸᏍᏛᎢ, ᎠᎴ ᎦᏃᎸᎥᏍᎬᎢ ᎤᏂᏰᏙᎳᏛᏅᎩ ᎤᏍᏗ ᎠᏰᏙᎳᏛᏗ; ᏙᏱᏃ ᏫᏚᏄᎪᏔᏅᎩ.


text:
ᏔᎵᏃ ᎠᎺᏉᎯ ᏕᎨᏒ ᏭᎾᎵᏱᎶᎸ, ᏥᏳ ᎤᏂᏝᏗᏤᎸᎩ ᎦᏙᎯ; ᎢᎬᏱᏗᏢᏃ ᎠᏍᏓᏱᏳ ᏄᎵᏍᏔᏅ, ᎥᏝ ᏰᎵ ᎬᏩᎵᏖᎸᏗ ᏱᎨᏎᎢ, ᎣᏂᏗᏢᏍᎩᏂ ᎤᏲᏨᎩ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎤᎵᏂᎩᏗᏳ ᏓᎵᏍᏗᎳᏁᎬ ᎠᎺᏉᎯ.


text:
ᎠᏎᏃ ᎠᏍᎪᎯᏧᏈ ᏗᏘᏂᏙᎯ ᏚᏲᏍᏙᏓᏁᎸᎩ ᏄᏍᏛ ᎠᎾᏓᏅᏖᏍᎬ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎤᏚᎵᏍᎬ ᎤᏍᏕᎸᏗᏱ ᏉᎳ, ᎠᎴ ᏚᏁᏤᎸᎩ ᏰᎵ ᎬᏩᎾᏴᎢᏅᏍᏗ ᎨᏒ, ᎢᎬᏱ ᎤᎾᎵᏔᏗᏅᏗᏱ ᎠᎴ ᏭᎾᏚᎩᏍᏗᏱ,


text:
ᎾᏍᎩᏃ ᎤᏩᎾᏓᎴ ᏴᏫ ᎤᏂᎪᎲ ᎢᎾᏛ ᎦᏖᎳᏛ ᎤᏬᏰᏂ, ᎯᎠ ᏂᏚᎾᏓᏪᏎᎸᎩ; ᎥᏝ ᏳᏝᏏᏛᎭ ᎯᎠ ᎠᏍᎦᏯ ᏴᏫ ᏗᎯᎯ ᎨᏒᎢ; ᎤᏙᎯᏳᎯᏍᎩᏂᏃᏅ ᎾᏍᎩ ᎠᎺᏉᎯ ᎠᏗᏫᏏ, ᎠᏎᏃ ᎤᏞᎩ ᎥᏝ ᎬᏁᏍᏗ ᏳᏪᎵᏎᎭ.


text:
ᎠᏎᏃ ᎤᎾᎦᏙᏍᏔᏅᎩ, ᏓᎪᏘᏏ ᎠᎴ ᎤᏲᎱᏒᎯ ᏓᎦᏅᏥ ᏛᏰᎶᎢᏍᏔᏂ, ᎠᏁᎵᏍᎬᎩ; ᎠᏎᏃ ᎤᏬᎯᏨ ᎤᎾᎦᏙᏍᏔᏅ, ᎠᎴ ᎤᎾᏙᎴᎰᏒ ᎪᎱᏍᏗ ᏄᎵᏍᏓᏁᎸᎾ ᎨᏒᎢ, ᎤᏂᏁᏟᏴᏒᎩ ᏄᏍᏛ ᎠᎾᏓᏅᏖᏍᎬᎢ, ᎠᎴ ᎦᎸᎳᏗ ᎡᎯ, ᎤᎾᏛᏅᎩ.


text:
ᎶᎻᏃ ᏬᎩᎷᏨ, ᎠᏍᎪᎯᏧᏈ ᏗᏘᏂᏙᎯ ᎠᏂᏴᎩ ᏚᏲᎯᏎᎸᎩ ᎤᎬᏫᏳᎯᎠᏂᎦᏘᏯ ᏗᏘᏂᏙᎯ; ᏉᎳᏍᎩᏂ ᎠᎦᎵᏍᎪᎸᏁᎸᎩ ᎤᏁᎳᎩ ᎤᏩᏒ ᎤᏕᏗᏱ, ᎠᎴ ᎠᏯᏫᏍᎩ ᎤᎦᏘᏗᏍᏗᏱ.


text:
ᏦᎢᏃ ᏫᏄᏒᎸ ᎯᎠ ᏄᎵᏍᏔᏅᎩ; ᏉᎳ ᏚᏪᏟᏌᏅᎩ ᏄᏂᎬᏫᏳᏒ ᎠᏂᏧᏏ; ᎤᎾᏓᏟᏌᏅᏃ ᎯᎠ ᏂᏚᏪᏎᎸᎩ; ᎢᏥᏍᎦᏯ ᎢᏓᏓᏅᏟ, ᎠᏴ ᎥᏝ ᎪᎱᏍᏗ ᎦᏥᏍᎦᏅᏤᎸᎯ ᏱᎩ ᏗᎦᏤᎵ ᏴᏫ, ᎥᏝ ᎠᎴ ᎠᎩᏲᏍᏔᏅᎯ ᏱᎩ ᏗᎧᎿᏩᏛᏍᏗ ᏗᎩᎦᏴᎵᎨ ᎨᎩᏁᎸᎯ; ᎠᏎᏃ ᏥᎷᏏᎵᎻ ᏥᏴᎩ ᏗᎬᏆᏘᎾᏫᏛᎲᎩ ᏕᎬᎩᏲᏒᎩ ᎠᏂᎶᎻᏱ.


text:
ᎯᎠᏃ ᏅᎬᏩᏪᏎᎸᎩ; ᎥᏝ ᏂᎯ ᎡᏣᏃᎮᏍᎬ ᎪᏪᎵ ᏧᏗᏱ ᏂᏙᏓᏳᏃᏪᎳᏅᎯ ᏱᏙᎩᏃᎮᎭ, ᎥᏝ ᎠᎴ ᎩᎶ ᎢᏓᏓᏅᏟ ᎾᎿ ᏅᏓᏳᏂᎶᏒᎯ ᎬᏂᎨᏒ ᏱᏂᎨᏨᏁᎴᎢ, ᎥᏝ ᎠᎴ ᎤᏐᏅ ᏱᎨᏣᏃᎮᎴᎢ.


text:
ᏕᎬᏩᏒᏍᏓᏁᎸᏃ, ᎤᏂᏣᏛ ᎬᏩᎷᏤᎸᎩ ᎤᏪᏗᏱ; ᎾᏍᎩ ᎬᏂᎨᏒ ᏂᏚᏩᏁᎸᎩ, ᏚᏃᎮᎮᎸᎩ ᎤᏁᎳᏅᎯ ᎤᎬᏫᏳᎯ ᎨᏒᎢ, ᏑᎾᎴ ᎤᎴᏅᏛ ᎤᏒᎢ ᎬᏗᏍᎩ, ᏓᏍᏗᏰᏗᏍᎬ ᏥᏌ ᎧᏃᎮᏍᎬᎢ; ᏕᎬᏗᏍᎬ ᏗᎧᎿᏩᏛᏍᏗ ᎼᏏ ᎤᏤᎵᎦ ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ.


text:
ᏚᎾᎦᎴᏅᎲᏃ ᏓᎾᏓᏅᏖᏍᎬᎢ ᏙᎤᏁᏅᏒᎩ, ᏉᎳᏍᎩᏂᏃᏅ ᎠᏏ ᏌᏉ ᎢᎧᏁᏨᎯ ᎤᏁᏨᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᏰᎵᏉ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏥᏚᏁᏤᎴ ᏗᎩᎦᏴᎵᎨᎢ, ᎢᏌᏯ ᎠᏙᎴᎰᏍᎩ ᏧᏩᏔᏁᎢ,


text:
ᎯᎠ ᏥᏄᏪᏎᎢ; "ᎯᎠ ᏴᏫ ᏘᏩᏛᎱᎦ, ᎠᎴ ᎯᎠ ᏫᏂᏫ; ᎢᏣᏛᎩᏍᎬᎢ ᎢᏣᏛᎩᏍᎨᏍᏗ, ᎠᏎᏃ ᎥᏝ ᏱᏦᎵᎨᏍᏗ, ᎠᎴ ᎢᏥᎪᏩᏘᏍᎬᎢ ᎢᏥᎪᏩᏘᏍᎨᏍᏗ ᎠᏎᏃ ᎥᏝ ᏱᏣᏙᎴᎰᏍᎨᏍᏗ.


text:
ᎯᎠᏰᏃ ᏴᏫ ᎤᏂᎾᏫ ᎤᎵᏦᎲᏒ, ᎠᎴ ᏓᏂᎵᎷᎬ ᎦᏂᎵᏳ ᎠᎾᏛᎩᎠ, ᎠᎴ ᏗᏂᎦᏙᎵ ᏚᏂᏍᏚᎭ; ᎾᏍᎩ ᏗᏂᎦᏙᎵ ᏗᎬᏩᏂᎪᏩᏛᏙᏗ ᏂᎨᏒᎾ, ᎠᎴ ᏓᏂᎵᎷᎬ ᏗᎬᏩᎾᏛᎪᏙᏗ ᏂᎨᏒᎾ, ᎠᎴ ᎤᏂᎾᏫ ᎬᏩᏃᎵᏍᏙᏗ ᏂᎨᏒᎾ, ᎠᎴ ᏚᎾᏓᏅᏛ ᏧᏏᏁᏟᏴᏍᏗᏱ ᏂᎨᏒᎾ ᎠᎴ ᏗᎦᎦᏥᏅᏬᏗ ᏂᎨᏒᎾ."


text:
ᎾᏍᎩ ᎣᎩᏁᎸᎯ ᏥᎩ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᎣᎩᏅᏏᏛ ᎨᏒᎢ, ᎾᏍᎩ ᏧᎾᏓᏂᎸᎢᏍᏗᏱ ᎪᎯᏳᏗ ᎨᏒ ᎾᏂᎥ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᏚᏙᎩ ᏚᏙᎥ ᏅᏗᎦᎵᏍᏙᏗᏍᎬᎢ;


text:
ᏂᏥᎥ ᎶᎻ, ᎤᏁᎳᏅᎯ ᎢᏥᎨᏳᎯ, ᎡᏥᏯᏅᏛ ᎢᏣᏓᏅᏘ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏍᏛ ᎨᏤᎳᏗᏙᎮᏍᏗ, ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎢᎩᏙᏓ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎠᏉᎯᏳᏓᏁᎯ, ᎾᏍᎩ ᎪᎱᏍᏗ ᏥᏥᏯᏛᏁᎭ ᎠᏆᏓᏅᏙ ᏥᎬᏗᎭ ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏪᏥ ᎤᏤᎵᎦ ᎬᏂᎨᏒ ᏂᎬᏁᎲᎢ, ᎾᏍᎩ ᏂᏥᏲᎯᏍᏗᏍᎬᎾ ᎢᏨᏁᎢᏍᏗᏍᎬᎢ, ᏂᎪᎯᎸ ᎦᏓᏙᎵᏍᏗᏍᎬ.


text:
ᎾᏍᎩᏃ ᎢᏓᎵᏅᏟ ᎥᏝ ᎾᏂᎦᏔᎲᎾᏉ ᎨᏎᏍᏗ ᏱᏨᏰᎵᏎᎭ, ᎾᏍᎩ ᎤᏣᏘ ᎢᏳᏩᎫᏗ ᏓᏇᎪᏔᏅ ᏫᏨᎷᏤᏗᏱ, ᎾᏍᎩ ᎪᎱᏍᏗ ᎤᎦᏔᏔᏅᎯ ᏂᎯ ᎾᏍᏉ ᎢᏤᎲ ᎠᎩᎪᏩᏛᏗᏱ ᎠᎩᏰᎸᏒᎩ, ᎾᏍᎩᏯ ᏄᏍᏛ ᎠᏂᏐᎢ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ; ᎠᏎᏃ ᎪᎯ ᎢᏯᏍᏗ ᎠᏆᏓᏄᎴᎭ.


text:
ᎥᏝᏰᏃ ᏱᎦᏕᎣᏍᎦ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ; ᎾᏍᎩᏰᏃ ᎤᏁᎳᏅᎯ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎬᏂᎨᏒ ᎢᎬᏁᎯ, ᎾᏍᎩ ᎾᎿ ᎠᎾᎵᏍᏕᎸᏙᏗᏍᎬ ᎾᏂᎥ ᎠᏃᎯᏳᎲᏍᎩ; ᎠᏂᏧᏏ ᎢᎬᏱ, ᎠᎴ ᎾᏍᏉ ᎠᏂᎪᎢ.


text:
ᎾᎿᏰᏃ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ ᏄᏍᏛ ᎤᏓᏚᏓᎴᏍᏙᏗ ᎨᏒ ᎤᏁᎳᏅᎯ, ᎪᎯᏳᏗ ᎨᏒ ᏩᏍᏆᏗᏍᏗᏍᎩ; ᎾᏍᎩᏯ ᏂᎬᏅᎪᏪᎸᎢ, ᏚᏳᎪᏛᏍᎩᏂ ᎢᏯᏛᏁᎯ ᎪᎯᏳᏗ ᎨᏒ ᎤᏛᏂᏗᏍᏕᏍᏗ.


text:
ᎤᎾᎳᏅᎯᏰᏃ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ ᎦᎸᎶᎢ ᏨᏗᏓᎴᎲᏍᎦ ᏥᏓᎦᏘᎴᎦ ᏄᏓᎴᏒ ᎤᏁᎳᏅᎯ ᏄᏂᎸᏉᏛᎾ ᎨᏒ, ᎠᎴ ᏂᏚᏳᎪᏛᎾ ᎢᏳᎾᏛᏁᏗ ᎨᏒ ᏴᏫ, ᎾᏍᎩ ᏚᏳᎪᏛ ᏣᏂᎾᎯᏍᏗᎭ ᎤᏲ ᏚᏂᎸᏫᏍᏓᏁᎲᎢ;


text:
ᎾᏍᎩᏰᏃ ᏗᎬᎪᏩᏛᏗ ᏂᎨᏒᎾ ᎨᏒ ᏧᏤᎵᎦ ᎬᏂᎨᏒᎢᏳ ᏗᎬᎪᏩᏛᏗ ᎢᎩ ᎡᎶᎯ ᏧᏙᏢᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᏗᎦᎪᎵᏍᏙᏗ ᎢᎩ ᏧᏓᎴᏅᏛ ᏗᎪᏢᏅᎯ ᎨᏒᎢ, ᎾᏍᎩ ᏅᏧᏓᎴᏅᎲᎾ ᎤᎵᏂᎩᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎨᏒᎢ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎥᏝ ᏳᏂᎭ ᏧᎾᏢᏫᏍᏙᏗ;


text:
ᎤᏂᎦᏙᎥᏒᏰᏃ ᎤᏁᎳᏅᎯ, ᎥᏝ ᎤᏁᎳᏅᎯ ᎦᎸᏉᏙᏗ ᎨᏒ ᏳᏂᎸᏉᏙᏔᏁᎢ, ᎥᏝ ᎠᎴ ᏯᎾᎵᎮᎵᎨᎢ, ᎠᎾᏓᏅᏖᏍᎬᏍᎩᏂ ᎠᏎᏉᏉ ᏄᎵᏍᏔᏁᎢ, ᎠᎴ ᏧᏁᎫ ᏧᏂᎾᏫ ᏚᎵᏏᎲᏎᎢ;


text:
ᎠᎴ ᎤᏂᏁᏟᏴᏎ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᏲᎱᏍᎩ ᏂᎨᏒᎾ ᎤᏤᎵᎦ, ᎠᏲᎱᏍᎩ ᏴᏫ ᏗᏟᎶᏍᏔᏅᎯ ᎾᏍᎩᏯ ᏄᏅᏁᎴᎢ, ᎠᎴ ᏥᏍᏆ, ᎠᎴ ᏅᎩ ᏗᏂᏅᏌᏗ, ᎠᎴ ᎠᎾᏓᎾᏏᏂᏙᎯ.


text:
ᎾᏍᎩ ᎤᏙᎯᏳᏒ ᎤᏁᎳᏅᎯ ᎤᏃᎮᏍᎩ ᎤᏂᏁᏟᏴᏍᏔᏁ ᎦᏰᎪᎩ ᎨᏒᎢ, ᎠᎴ ᎤᏟ ᎢᎦᎢ ᎤᎾᏓᏙᎵᏍᏓᏁᎴ ᎠᎴ ᎪᎱᏍᏗ ᎤᎾᏛᏁᎴ ᎠᎪᏢᏅᎯᏉ ᎨᏒ ᎡᏍᎦᏉ ᎢᎦᎢ ᎤᏬᏢᏅᎯ, ᎾᏍᎩ ᎦᎸᏉᏙᏗ ᏥᎩ ᏂᎪᎯᎸᎢ. ᎡᎺᏅ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᏕᎤᏲᏒᎩ ᎤᏕᎰᎯᏍᏗ ᎤᎾᏚᎸᏅᏗᏱ; ᎾᏍᏉᏰᏃ ᎠᏂᎨᏴ ᏧᎾᏤᎵᎦ ᎾᏍᎩ ᎠᎲ ᎢᏳᎾᏛᏁᏗ ᎨᏒ ᎤᏂᏁᏟᏴᏍᏔᏁ ᎾᏍᎩ ᎠᎲ ᎢᏳᎾᏛᏁᏗ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎠᎴ ᎾᏍᏉ ᎠᏂᏍᎦᏯ ᏚᏂᏲᏍᎨ ᎢᏳᎾᏛᏁᏗ ᎨᏒ ᎾᏍᎩ ᎠᏂᎨᏴ ᎨᎦᏁᎳᏅᎯ ᎤᎬᏩᎵ ᎨᏒᎢ, ᎤᏤᏘ ᏓᎾᏓᏕᎳᏲᏍᎨ ᎤᏅᏒᏉ ᎨᏒᎢ; ᎠᏂᏍᎦᏯ ᎠᏂᏍᎦᏯᏉ ᎪᎱᏍᏗ ᏓᎾᏓᏛᏗᏍᎨ ᏚᏂᎸᏫᏍᏓᏁᎮ ᎾᏍᎩ ᎤᏕᎰᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏅᏒ ᎨᏒ ᎤᎾᎵᏩᏛᎡᎮ ᏚᏳᎪᏛ ᎨᎦᎫᏴᎡᏗ ᎨᏒ ᎾᏍᎩ ᎤᏂᎵᏓᏍᏗᏍᎬᎢ.


text:
ᎠᎴ ᎾᏍᎩ ᎣᏏ ᏄᏂᏰᎸᏒᎾ ᏥᎨᏎ ᏄᏍᏛ ᎤᏁᎳᏅᎯ ᎤᏂᎦᏙᎥᏒ ᎤᏂᏍᏆᏂᎪᏙᏗᏱ, ᎤᏁᎳᏅᎯ ᏕᎤᏲᏎ ᎨᏥᏐᏅᎢᏍᏔᏅᎯ ᎢᏳᎾᎵᏍᏙᏗᏱ ᏚᎾᏓᏅᏛᎢ, ᎾᏍᎩ ᎢᎬᏛᏁᏗ ᏂᎨᏒᎾ ᎨᏒ ᎢᏳᎾᏛᏁᏗᏱ;


text:
ᎤᏂᎧᎵᏨᎯ ᎨᏒ ᏄᏓᎴᏒ ᏂᏚᏳᎪᏛᎾ ᎨᏒᎢ, ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒᎢ, ᎤᏲ ᎢᏯᏓᏛᏁᏗ ᎨᏒᎢ, ᏧᎬᏩᎶᏗ ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ, ᎤᏂᏲ ᎨᏒᎢ; ᎤᏂᎧᎵᏨᎯ ᎠᏛᏳᎨᏗ ᎨᏒᎢ, ᏗᏓᎯᏍᏗ ᎨᏒᎢ, ᏗᏘᏲᏍᏗ ᎨᏒᎢ, ᎠᏠᏄᎮᏛ, ᎤᏲ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ; ᎠᎾᏙᏅᎢᎯ,


text:
ᎾᏍᎩ ᏣᏂᎦᏔᎭ ᏄᏍᏛ ᏕᎫᎪᏗᏍᎬ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎩᎶ ᎾᏍᎩ ᎢᏳᏍᏗ ᏧᎸᏫᏍᏓᏁᎯ ᏰᎵᏉ ᏗᎬᏩᏂᏲᎱᎯᏍᏗ ᎨᏒᎢ, ᎥᏝ ᎾᏍᎩᏉ ᎾᎾᏛᏁᎲ ᎤᏩᏒ ᏱᎩ, ᎣᏏᏳᏍᎩᏂ ᏚᏂᏰᎸᎭ ᎾᏍᎩ ᎢᏯᎾᏛᏁᎯ.


text:
ᏥᎪᎨ ᏅᎵᏌᎵᏉ ᎯᏰᎸᏍᎦ ᏄᏧᏈᏍᏛ ᎤᏓᏅᏘᏳ ᎨᏒ ᎠᎴ ᎬᏂᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎪᎯᏗᏳ ᎤᏁᎳᎩ ᎡᎵᏍᎬᎢ, ᏒᎢ, ᎠᎴ ᎪᎯᏗᏳ ᎤᏁᎳᎩ ᎡᎵᏍᎬᎢ, ᏂᎦᏔᎲᎾᏉ ᎨᏒ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏘᏳ ᎨᏒ ᏣᏘᏁᎬ ᏣᏁᏟᏴᏍᏗ ᎨᏒ ᏣᏓᏅᏛᎢ?


text:
ᎾᏍᎩᏯᏍᎩᏂ ᎯᏍᏓᏱᏳ ᎨᏒ ᎠᎴ ᏣᏁᏟᏴᏛ ᏂᎨᏒᎾ ᏣᎾᏫ ᎯᏟᏏᎭ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᏣᏤᎵ ᎢᏳᎵᏍᏙᏗ ᎾᎯᏳ ᎢᎦ ᎠᎵᏱᎶᎸᎭ ᎤᏓᎳᏬᎯᏍᏗ ᎨᏒ ᎠᎴ ᎤᏁᎳᏅᎯ ᏚᏳᎪᏛ ᏧᏭᎪᏙᏗ ᎨᏒ ᎦᎾᏄᎪᏫᏒᎭ;


text:
ᎾᏍᎩ ᎣᏍᏛ ᏚᏂᎸᏫᏍᏓᏁᎲ ᏗᏅᏂᏗᏳ ᎬᎾᎢᏒ ᏧᏂᏯᏍᏗᎭ ᏗᎬᏩᎸᏌᏛ ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏒ ᎠᎴ ᎠᏲᎱᎯᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎬᏂᏛ ᏧᎫᏴᏁᏗ ᏥᎩ;


text:
Ꮎ-ᏍᎩᏂ <n>[ᎤᏁᎳᏅᎯ]</n> ᏗᏂᎦᏘᎴᎩ ᏥᎩ, ᎠᎴ ᎾᏃᎯᏳᎲᏍᎬᎾ ᏥᎩ ᏚᏳᎪᏛ ᎨᏒᎢ, ᏂᏚᏳᎪᏛᎾᏍᎩᏂ ᎨᏒ ᎠᏃᎯᏳᎲᏍᎩ ᏥᎩ; ᎤᏔᎳᏬᎯᏍᏗ ᎠᎴ ᎤᎿᎸᎯ ᎨᏒ ᎤᏂᎷᏤᏗ ᎨᏎᏍᏗ.


text:
ᎾᏂᎥᏰᏃ ᎩᎶ ᎤᏂᏍᎦᏅᏨᎯ ᏗᎧᎿᏩᏛᏍᏗ ᏄᏂᎲᎾ ᎾᏍᏉ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎬᏔᏅᎾ ᎤᏂᎩᎵᏲᎢᏍᏗ; ᎠᎴ ᎾᏂᎥ ᎩᎶ ᎤᏂᏍᎦᏅᏨᎯ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏂᎯ, ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎨᎬᏓᏁᏗ ᏗᎨᎫᎪᏓᏁᏗ ᎨᏎᏍᏗ,


text:
ᏧᎾᏓᎴᏅᏛᏰᏃ ᏴᏫ ᏗᎧᎿᏩᏗᏍᏗ ᏄᏂᎲᎾ ᏥᎩ, ᎤᏅᏒ ᎤᎾᏓᏅᏖᏛ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᏱᎾᎾᏛᏁᎭ, ᎾᏍᎩ ᎯᎠ, ᏗᎧᎿᏩᏛᏍᏗ ᏄᏂᎲᎾ ᏥᎩ, ᎤᏅᏒᏉ ᎨᏒ ᏗᎧᎿᏩᏛᏍᏗ ᎾᎾᎵᏍᏗᎭ;


text:
ᎾᏍᎩ ᎬᏂᎨᏒ ᎾᏅᏁᎭ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᎢᏯᏛᏁᏗ ᎨᏒ ᏧᏂᎠᏫᏱ ᎪᏪᎸᎢ, ᏚᎾᏓᏅᏛ ᎾᏍᏉ ᎪᎯᏳᏙᏗᏍᎬᎢ, ᎠᎴ ᎠᎾᏓᏅᏖᏍᎬ ᏓᎾᏓᏚᎯᏍᏗᏍᎬ, ᎠᎴ ᏓᎾᏓᏚᏓᎴᏍᎬᎢ.


text:
ᎠᎱᏍᏕᏍᏗᏰᏃ ᎨᏒ ᎤᏙᎯᏳᎯ ᏣᏍᏕᎵᎭ ᎢᏳᏃ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᏱᎿᏛᏁᎭ; ᎢᏳᏍᎩᏂ ᎯᏲᏍᏗᏍᎩ ᏱᎩ ᏗᎧᎿᏩᏛᏍᏗ, ᎡᏣᎱᏍᏕᏎᎸᎯ ᎨᏒ ᎡᏣᎱᏍᏕᏎᎸᎯᏉ ᏂᎨᏒᎾ ᏂᎦᎵᏍᏗᎭ.


text:
ᎠᎴ ᏝᏍᎪ ᎠᏥᎤᏍᏕᏎᎸᎯ ᏂᎨᏒᎾ, ᎾᏍᎩ ᎤᏕᏅᏉ ᏄᏍᏛ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏍᏆᏂᎪᏗᏍᎩ ᏱᏙᎨᏧᎪᏓᏏ ᏂᎯ, ᎪᏪᎵ ᎠᎴ ᎠᎱᏍᏕᏍᏗ ᎨᏒ ᏗᎬᏗ ᏗᎧᎿᏩᏛᏍᏗ ᎯᏲᏍᏗᏍᎩ?


text:
ᎾᏍᎩᏍᎩᏂ Ꮎ ᎠᏧᏏ, ᎾᏍᎩ ᎭᏫᏂᏗᏢ ᎠᏧᏏ ᏥᎩ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎠᎱᏍᏕᏍᏗ ᎨᏒ ᎤᎾᏫᏱ ᎡᎯ ᏥᎩ, ᎤᏓᏅᏙᎩᎯ ᎡᎯ, ᎥᏝᏃ ᎪᏪᎵᏉ ᏂᎦᏪᏍᎬ ᏗᎧᎿᏩᏕᎩ; ᎾᏍᎩ ᎥᏝ ᏴᏫᏉ ᎬᏩᎸᏉᏙᏗ ᏱᎩ, ᎤᏁᎳᏅᎯᏍᎩᏂ.


text:
ᎬᏩᏟᏍᏗ; ᎥᎥ, ᎤᏁᎳᏅᎯ ᏚᏳᎪᏛ ᎧᏁᎩ ᎨᏎᏍᏗ, ᎾᏂᎥᏃ ᏴᏫ ᎠᏂᏰᎪᎩ ᎨᏎᏍᏗ; ᎾᏍᎩᏯ ᎯᎠ ᏂᎬᏅ ᎪᏪᎸᎢ, ᎾᏍᎩ ᏂᏍᎦᏅᎾ ᎢᏳᎵᏍᏙᏗᏱ ᎯᏁᎬᎢ, ᎠᎴ ᏣᏓᏎᎪᎩᏍᏗᏱ ᎿᏉ ᏕᎱᎪᏔᏅᎭ.


text:
ᎠᏎᏃ ᎢᏳᏃ ᏂᏚᏳᎪᏛᎾ ᏃᎦᏛᏁᎸ ᎬᏂᎨᏒ ᏱᏂᎬᏁᎭ ᏚᏳᎪᏛ ᎢᏯᏛᏁᎯ ᎨᏒ ᎤᏁᎳᏅᎯ, ᎦᏙ ᏓᏓᏛᏂ? ᎠᏍᎦᏅᎦᏍᎪ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᏥᏓᏍᏛᏗᏍᏙᏗᎭ? (ᏴᏫᏉ ᎢᏳᏪᏍᏗ ᏂᏥᏪᎭ).


text:
ᎢᏳᏰᏃ ᏚᏳᎪᏛ ᎧᏁᎩ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏟ ᎢᎦᎢ ᎤᏁᏉᏨᎯ ᏱᎩ ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᏄᏩᏁᎲᎢ ᎠᏴ ᎦᏥᎪᎲᏍᎬ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ, ᎦᏙᏃ ᎠᏴ ᎾᏍᏉ ᎠᏏᏉ ᏛᏊᎪᏓᏁᎭ ᏥᏍᎦᎾ ᎾᏍᎩᏯᎢ?


text:
ᎠᎴᏍᎪ ᎥᏝ ᎾᏍᎩ ᎯᎠ ᏳᎬᏫᏳᎭ, (ᎾᏍᎩ ᎦᏲᎩᏐᏢᏛ ᏥᎪᎩᏃᎮᎭ, ᎠᎴ ᎩᎶ ᎾᏍᎩ ᎾᏂᏪ ᏥᎪᎪᏎᎭ,) ᎤᏲ ᏕᎩᎸᏫᏍᏓᏁᎮᏍᏗ ᎾᏍᎩ ᎣᏍᏛ ᎨᏒ ᎤᎵᏰᎢᎸᏍᏗᏱ? ᎾᏍᎩ ᎤᏂᏍᎦᏅᏨ ᏧᎾᏚᎪᏓᏁᏗᏱ ᏚᏳᎪᏗ.


text:
ᎠᎴ ᎢᏗᎦᏔᎭ ᎾᏍᎩ ᏂᎦᎥ ᏂᎦᏪᏍᎬ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏂᏁᏤᎭ ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎨᏥᏁᏄᎯ; ᎾᏍᎩ ᎾᏂᎥ ᏗᏂᎰᎵ ᏗᎨᏥᏍᏚᏁᏗᏱ, ᎠᎴ ᎡᎳᏂᎬ ᎠᏁᎯ ᎤᏂᏍᎦᏅᏨᎯ ᏧᏚᎪᏔᏅᎯ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ.


text:
ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏓᎦᏓᎴᏍᏗ ᎨᏒᎢ, ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᎪᎯᏳᏗ ᏨᏗᏓᎴᎲᏍᎦ, ᎠᎴ ᎾᏍᎩ ᎾᏂᎥ ᎠᏃᎯᏳᎲᏍᎩ ᎤᏂᎷᏤᏗ ᎠᎴ ᎾᏍᎩ ᎾᏂᎥ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗ ᏥᎩ; ᎥᏝᏰᏃ ᏧᎾᏓᎴᎿᎢ ᏱᎩ;


text:
ᎾᏍᎩ <n>[ᏥᏌ ᎦᎶᏁᏛ]</n> ᎤᏁᎳᏅᎯ ᎬᏂᎨᏒ ᏥᏄᏩᏁᎸ ᎠᎵᏍᎪᎸᏔᏅᎯ ᎪᎯᏍᏙᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎪᎯᏳᏗᏱ ᎤᎩᎬ; ᏧᎾᏄᎪᏫᏎᏗᏱ ᎾᏍᎩ ᏚᏳᎪᏛ ᎢᏯᏛᏁᎯ ᎨᏒᎢ, ᎾᏍᎩ ᎦᏳᎳ ᎠᏍᎦᏅᏨᎯ ᎨᏒ ᎦᎬᏩᏓᏁᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎬᏂᏗᏳ ᎨᏒ ᎢᏳᏩᏂᏌᏅᎯ;


text:
ᎭᏢᎨᏃ ᎠᏢᏆᏍᏗ ᎨᏒᎢ? ᎢᏴᏛ ᎢᎬᏁᎸᎯ. ᎦᏙ ᎤᏍᏗ ᏗᎧᎿᏩᏛᏍᏗ ᎦᏔᏅᎯ? ᏗᎦᎸᏫᏍᏓᏁᏗᏱᏍᎪ ᎠᏓᏁᏤᎯ? ᎥᏝ; ᏗᎧᎿᏩᏛᏍᏗᏍᎩᏂ ᎬᏔᏅᎯ ᎪᎯᏳᏗ ᎨᏒ ᎠᏓᏁᏤᎯ.


text:
ᎯᎠᏃ ᎾᏍᎩ ᎣᏏᏳ ᎢᏳᏓᎵᏍᏓᏁᏗ ᎨᏒ ᏗᎨᏥᎤᏍᏕᏎᎸᎯᏉᏍᎪ ᎤᏂᎷᏤᎭ, ᏥᎪᎨ ᎾᏍᏉ ᏗᎨᏥᎤᏍᏕᏎᎸᎯ ᏂᎨᏒᎾ? ᎪᎯᏳᏗᏰᏃ ᎨᏒ ᏚᏳ-ᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ ᎠᏥᏰᎸᎾᏁᎴ ᎡᏆᎭᎻ ᎢᏓᏗᎭ.


text:
ᎢᎳᎩᏳᏃ ᎾᏍᎩ ᏄᏍᏕ ᎠᏥᏰᎸᎾᏁᎴᎢ? ᏥᎪ ᎠᏥᎤᏍᏕᏎᎸᎯ ᏥᎨᏎᎢ? ᏥᎪᎨ ᎠᏥᎤᏍᏕᏎᎸᎯ ᏂᎨᏒᎾ ᏥᎨᏎᎢ? ᎥᏝ ᎠᏥᎤᏍᏕᏎᎸᎯ ᏥᎨᏎᎢ, ᎠᏥᎤᏍᏕᏎᎸᎯᏍᎩᏂ ᏂᎨᏒᎾ ᏥᎨᏎᎢ.


text:
ᎠᎴ ᎠᏥᏁᎴ ᎠᎱᏍᏕᏍᏗ ᎨᏒ ᎤᏰᎸᏛᎢ, ᎠᏍᏓᏱᏗᏍᎩ ᏚᏳᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ ᎠᏥᏰᎸᎾᏁᎲᎢ ᏅᏓᏳᏓᎴᏅᎯ ᎤᏬᎯᏳᏒ ᎠᏏ ᎾᏥᎤᏍᏕᏎᎸᎾ ᏥᎨᏎᎢ; ᎾᏍᎩ ᎤᏂᏙᏓ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏂᎥ ᎠᏃᎯᏳᎲᏍᎩ, ᏂᏗᎨᏥᎤᏍᏕᏎᎸᎾ ᎨᏒᎢ; ᎾᏍᎩ ᏚᏳᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ ᎾᏍᎩ ᎾᏍᏉ ᎨᏥᏰᎸᎾᏁᏗᏱ;


text:
ᎠᎴ ᎾᏍᏉ ᏗᎨᏥᎤᏍᏕᏎᎸᎯ ᎤᏂᏙᏓ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᏗᎨᏥᎤᏍᏕᏎᎸᎯ ᎤᏩᏒ ᏂᎨᏒᎾ ᏥᎩ, ᎾᏍᏉᏍᎩᏂ ᎠᏂᏍᏓᏪᏕᎩ ᏥᎩ ᏚᎳᏏᏅᏒ ᎢᎩᏙᏓ ᎡᏆᎭᎻ, ᎾᏍᎩ ᏧᏬᎯᏳᏎ ᎠᏥᎤᏍᏕᏎᎸᎯ ᎠᏏ ᏂᎨᏒᎾ ᏥᎨᏎᎢ.


text:
ᏣᏥᏚᎢᏍᏓᏁᎴᏰᏃ ᎤᏤᎵ ᎢᏳᎵᏍᏙᏗᏱ ᎡᎶᎯ, ᎥᏝ ᎡᏆᎭᎻ ᎠᎴ ᎾᏍᎩ ᎤᏁᏢᏔᏅᏛ ᎨᏒ ᏗᎧᎿᏩᏛᏍᏗ ᏅᏓᏳᏓᎴᏅᎯ ᏱᎨᏎᎢ, ᎪᎯᏳᏗᏍᎩᏂ ᎠᏚᏓᎴᏍᏙᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ ᎨᏎᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎪᎯᏳᏗ ᎨᏒ ᎠᎵᏍᎦᏍᏙᏗᎭ, ᎾᏍᎩ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏗᏱ; ᎾᏍᎩ ᎠᏚᎢᏍᏔᏅᎯ ᎨᏒ ᎤᎵᏂᎩᏗᏳ ᎢᏳᎾᎵᏓᏁᏗᏱ ᎾᏂᎥ ᎤᏁᏢᏔᏅᏛ ᎨᏒᎢ; ᎥᏝ ᎾᏍᎩ ᎤᏅᏒ ᏧᏁᏢᏔᏅᏛ ᎨᏒ ᎾᏍᎩᏯ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎬᏅᎢ, ᎾᏍᏉᏍᎩᏂ ᎾᏍᎩ ᏧᏁᏢᏔᏅᏛ ᎨᏒ ᎡᏆᎭᎻ ᎤᏬᎯᏳᏒ ᎾᏍᎩᏯ ᎤᏃᎯᏳᏅᎯ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᎡᏆᎭᎻ ᏂᏗᎥ ᎢᎩᏙᏓ ᏥᎩ,


text:
(ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᎤᏂᏣᏘ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏂᏙᏓ ᏂᎬᏴᎦ,) ᎠᎦᏔᎲ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᏥᎪᎯᏳᎲᏍᎨᎢ, ᎾᏍᎩ ᏗᎬᏂᏗᏍᎩ ᏥᎩ ᏧᏂᏲᎱᏒᎯ, ᎠᎴ ᏗᏯᏂᏍᎩ ᏥᎩ ᏧᎾᏓᎴᏅᏛ ᎾᏍᎩ ᎾᏁᎲᎾ ᎨᏒᎢ, ᎾᏍᎩ ᏣᏁᎰ ᎾᏍᎩᏯᎢ;


text:
ᎾᏍᎩ ᎤᏚᎩ ᎦᎬᏗ ᏂᎨᏒᎾ ᏥᎨᏎᎢ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᏧᏬᎯᏳᏁᎢ, ᎾᏍᎩ ᎤᏂᏣᏘ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏂᏙᏓ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩᏯ ᎯᎠ ᎢᎦᏪᏛ ᏥᎩ, ᎾᏍᎩᏯ ᏄᏂᏧᏈᏍᏕᏍᏗ ᏣᏁᏢᏔᏅᎯ;


text:
ᎠᎴ ᏩᎾᎦᎳ ᏂᎨᏒᎾ ᎨᏒ ᎤᏬᎯᏳᏒᎢ, ᎥᏝ ᏳᏓᏅᏖᎴ ᎤᏩᏒ ᎠᏰᎵ ᎤᎵᏬᏨᎯ ᎨᏒᎢ, ᎿᏉ ᎠᏍᎪᎯᏧᏈ ᎢᏴᏛ ᎢᏳᏕᏘᏴᏛ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᏳᏓᏅᏖᎴ ᎤᎶᏒᏍᏓᏁᎸᎯ ᎨᏒ ᏎᎵ ᏧᏓᎾᏄᎪᏫᏍᏗᏱ;


text:
ᎠᏴᏍᎩᏂ ᎨᏒ ᎾᏍᏉ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᎢ, ᎾᏍᎩ <n>[ᏚᏳᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ]</n> ᎡᎩᏰᎸᎾᏁᏗ ᏥᎩ, ᎡᏙᎯᏳᎲᏍᎩ ᎾᏍᎩ ᏧᎴᏔᏅᎯ ᎤᏲᎱᏒ ᏥᏌ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ;


text:
ᎾᏍᎩ ᎾᏍᏉ ᎢᏳᏩᏂᏌᏛ ᎪᎯᏳᏗ ᎢᏛᏗᏍᎬ ᎨᎩᎷᎯᏍᏗ ᏥᏄᎵᏍᏔᏅ ᎯᎠ ᎾᏍᎩ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎾᎿ ᏥᏕᏗᏙᎦ, ᎠᎴ ᏥᏓᎵᎮᎵᎦ ᎤᏚᎩ ᎢᎬᏒ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎡᎩᏁᏗᏱ.


text:
ᎾᏍᎩᏃ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᎥᏝ ᎠᏕᎰᎯᏍᏗᏱ ᏴᎬᏓᏩᏛᏗ; ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏁᎳᏅᎯ ᎠᎨᏳᏗ ᎨᏒ ᎡᎩᏐᏅᏰᎸ ᏗᎩᎾᏫᏱ, ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᎡᎩᏁᎸᎯ ᏥᎩ.


text:
ᎢᏳᏰᏃ, ᎠᏏ ᎡᏗᏍᎦᎩ ᏥᎨᏒᎩ ᎡᏙᎢᏍᏓᏁᎸᎯ ᏱᎩ ᎤᏁᎳᏅᎯ ᎬᏔᏅᎯ ᎤᏪᏥ ᎤᏲᎱᏒᎢ, ᎿᏉ ᎪᎯ ᎡᏙᎢᏍᏓᏁᎸᎯ ᏥᎩ, ᎤᏟᎯ ᎤᏙᎯᏳᎯᏯ ᎡᎩᏍᏕᎸᏗ ᎨᏎᏍᏗ ᎾᏍᎩ ᎬᏃᏛ ᎨᏒ ᎢᏳᏍᏗ.


text:
ᎥᏝ ᎠᎴ ᎾᏍᎩᏉ ᏱᏂᎦᎥ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎾᏍᏉ ᎡᏓᎵᎡᎵᎦ, ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᎪᎯ ᎨᏒ ᎢᎩᏁᎸᎯ ᏥᎩ ᎪᎯᏍᏙᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩᏃ, ᏌᏉ ᎠᏍᎦᏯ ᎢᏳᏩᏂᏌᏛ ᎠᏍᎦᏂ ᎡᎶᎯ ᏧᎾᏄᎪᏨ, ᎠᎴ ᎠᏲᎱᎯᏍᏗ ᎨᏒ <n>[ᏧᎾᏄᎪᏨ;]</n> ᎠᏍᎦᏂ ᎢᏳᏩᏂᏌᏛ ᎠᎴ ᎾᏍᎩ ᏥᏂᎦᎵᏍᏙᏗᎭ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᏂᎦᏗᏳ ᏴᏫ ᏧᏂᎷᏤᎸ, ᏂᎦᏗᏳᏰᏃ ᎤᏂᏍᎦᏅᏨ


text:
ᎠᏎᏍᎩᏂᏃᏅ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎡᎲᎩ ᎠᏓᏫ ᏤᎮ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎼᏏᏃ ᏤᎮ ᏫᎬᏍᏘ, ᎾᏍᎩ ᎾᏍᏉ ᎠᏁᎲ ᏄᏂᏍᎦᏅᏨᎾ ᎨᏒ ᎾᏍᎩᏯ ᏄᏛᏁᎸ ᎤᏍᎦᏅᏨ ᎠᏓᏫ, ᎾᏍᎩ ᎤᎷᎯᏍᏗ ᏥᎨᏒ ᏣᎦᏟᎶᏍᏙᏗ ᏥᎨᏎᎢ.


text:
ᎠᏎᏃ ᎥᏝ ᎾᏍᎩᏯ ᏥᏄᏍᏕ ᎠᏍᎦᏅᏨᎢ, ᎾᏍᎩ ᎾᏍᏉ ᏱᏄᏍᏕ ᎬᏩᎦᏘᏯ ᎠᏓᏁᏗ ᎨᏒᎢ. ᎢᏳᏍᏕ ᎬᏩᎦᏘᏯ ᎠᏓᏁᏗ ᎨᏒᎢ. ᎢᏳᏰᏃ ᎠᏏᏴᏫ ᎤᏍᎦᏅᏨ ᎤᏂᏣᏘ ᏧᏂᏲᎱᎯᏍᏔᏅᎯ ᏱᎩ; ᎤᏟᎯᏳ ᎢᎦᎢ ᎤᏂᏣᏘ ᎤᏣᏘ ᎤᏂᎷᏤᎸ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ, ᎠᎴ ᎤᏓᏁᏗ ᎨᏒ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ ᏥᎩ, ᎾᏍᎩ ᎠᏏᏴᏮ ᎠᏍᎦᏯ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎠᎴ ᎥᏝ ᎾᏍᎩᏯ ᎠᏏᏴᏫᏉ ᎤᏍᎦᏅᏨᎯ ᎢᏳᏩᏂᏌᏛ <n>[ᏗᎨᎫᎪᏓᏁᏗ ᏥᏄᎵᏍᏔᏁ]</n> ᎾᏍᎩᏯ ᏱᏄᏍᏗ ᎤᏓᏁᏗ ᎨᏒᎢ; ᎠᏍᎦᏅᏨᏰᏃ ᏗᎫᎪᏙᏗ ᎨᏒ ᏌᏉᏉ ᎢᏯᏍᎦᏅᏨᎯ ᏅᏓᏳᏓᎴᏅᎯ; ᎬᏩᎦᏘᏯᏍᎩᏂ ᎤᏓᏁᏗ ᎨᏒ ᎤᏣᏘ ᎢᏯᏍᎦᏅᏨᎯ ᎠᏚᏓᎴᏍᏙᏗ ᎤᎬᏩᎳ.


text:
ᎢᏳᏰᏃ ᏌᏉ ᏴᏫ ᎤᏍᎦᏅᏨ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᏰᎭ ᎾᏍᎩ ᎠᏏᏴᏫ ᎢᏳᏩᏂᏌᏛ; ᎤᏟᎯᏳ ᏄᏓᎷᎸᎾ ᎾᏍᎩ ᎤᏣᏘ ᎨᏥᏁᎸᎯ ᏥᎩ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᎬᏩᎦᏘᏯ ᎠᏚᏓᎴᏍᏙᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎬᏂᏛ ᏗᎨᏒ ᎤᏂᎬᏫᏳᎯ ᎨᏎᏍᏗ ᎠᏏᏴᏫ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᎩ ᎠᏏᏴᏫ ᎤᏍᎦᏅᏨ ᎢᏳᏩᏂᏌᏛ ᎠᏍᎦᏅᏨ ᏗᎫᎪᏙᏗ ᎨᏒ ᏂᎦᏗᏳ ᏴᏫ ᏧᏂᎷᏤᎸ; ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏏᏴᏫ ᏚᏳᎪᏛ ᏄᏛᏁᎸ ᎢᏳᏩᏂᏌᏛ ᎬᏩᎦᏘᏯ ᎤᏓᏁᏗ ᎨᏒ ᎤᏂᎷᏤᎸ ᏂᎦᏗᏳ ᏴᏫ ᎨᎫᏓᎴᏍᏗᏱ ᎬᏂᏛ ᎤᏂᏩᏛᏗᏱ ᎤᎬᏩᎳ.


text:
ᎠᏏᏴᏫᏰᏃ ᏴᏫ ᏄᏬᎯᏳᏅᎾ ᎨᏒ ᎢᏳᏩᏂᏌᏛ ᎤᏂᏣᏘ ᎠᏂᏍᎦᎾ ᏥᏄᎾᎵᏍᏔᏅ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏏᏴᏫ ᎤᏬᎯᏴᏅ ᏅᏓᎦᎵᏍᏙᏔᏂ ᎤᏂᏣᏘ ᎠᏂᏍᎦᎾ ᏂᎨᏒᎾ ᏅᏛᎾᎵᏍᏔᏂ.


text:
ᎾᏍᎩᏃ ᎠᏍᎦᏂ ᏧᎬᏫᏳᏌᏕᎬᎩ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎦᎾᏄᎪᏫᏍᎬᎢ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᎬᏫᏳᏌᏕᎩ ᎢᏳᎵᏍᏙᏗᏱ ᎬᏂᏛ ᎦᎾᏄᎪᏫᏍᎬ ᎬᏔᏅᎯ ᎠᏚᏓᎴᏍᏙᏗ ᎨᏒ ᏥᏌ ᎦᎶᏁᏛ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵ ᎢᏳᏩᏂᏌᏛ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᎩ ᏤᎦᏬᎥᎯ ᏥᎩ, ᎦᎶᏁᏛ ᎢᏧᎳᎭ ᏕᎩᏂᏌᏅᎩ, ᎠᎴ ᎾᏍᎩ ᏗᎩᏲᎱᏒᎯ ᏄᎵᏍᏔᏅᎩ; ᎾᏍᎩ ᎦᎶᏁᏛ ᎤᏲᎱᏒ ᏥᏓᎦᎴᏔᏁᎢ ᎠᎦᏴᎵᎨ ᎦᎸᏉᏗᏳ ᎨᏒ ᎬᏔᏅᎯ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏴ ᎢᏓᎴᏂᏙᎲ ᎢᏤ ᏱᏓᎴᏂᏙᎭ.


text:
ᎯᎠᏰᏃ ᎾᏍᎩ ᎢᏗᎦᏔᎭ, ᎾᏍᎩ ᎢᎦᏤᎵ ᎤᏪᏥ ᎠᏍᎦᏯ ᏓᏓᎿᏩᏍᏛ ᎠᎦᏛᏅ ᎢᏧᎳᎭ ᎾᏍᎩ <n>[ᎦᎶᏁᏛ]</n> ᎠᎦᏛᏅᎢ, ᎾᏍᎩ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᎠᏰᎸ ᎡᎲ ᎤᏲᎱᎯᏍᏗᏱ, ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᎠᏍᎦᏂ ᏗᎩᎾᏢᏗᏱ ᏂᎨᏒᎾ.


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᏂᎯ ᎢᏨᏒ ᎨᏒ ᎤᏙᎯᏳᎯ ᏗᏥᏲᎱᏒᎯ ᎨᏒ ᎢᏣᏓᏓᏅᏖᏍᎨᏍᏗ ᎠᏍᎦᏂ ᎤᎬᏩᎵ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎤᏤᎵ ᎤᎬᏩᎵ ᏗᏨᏃᏛ ᎨᏒ ᏥᏌ ᎦᎶᏁᏛ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᎢᏳᏩᏂᏌᏛ.


text:
ᎠᎴ ᏞᏍᏗ ᎠᏍᎦᏂ ᏤᏥᏲᎯᏎᎸᎩ ᏗᏥᏰᎸ ᎤᏚᏓᏕᏫᏒᎢ, ᎾᏍᎩ ᏗᏨᏙᏗᏱ ᏂᏚᏳᎪᏛᎾ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ; ᎤᏁᎳᏅᎯᏍᎩᏂ ᎢᏨᏒ ᏤᏣᏓᏲᎯᏏ, ᎾᏍᎩ ᎢᏳᎾᏛᏁᏗ ᎤᎾᏛᏂᏛᎯ ᏧᏂᏲᎱᏒᎯ ᎨᏒ ᎠᎴ ᏗᏥᏰᎸ ᎤᏚᏓᏕᏫᏒ ᎤᏁᎳᏅᎯ ᏕᏥᏲᎯᏎᎸᎩ ᎾᏍᎩ ᏗᏨᏙᏗᏱ ᏚᏳᎪᏛ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ,


text:
ᏝᏍᎪ ᏱᏥᎦᏔᎭ, ᎾᏍᎩ ᎩᎶ ᏱᏕᏣᏓᏲᎯᏎᎸ ᎢᏥᏅᏏᏙᎲ ᎡᏦᎢᏳᏗᏱ, ᎾᏍᎩ ᎢᏥᎾᏝᎢ ᎨᏒ ᎡᏦᎢᏳᎲᏍᎩ; ᎾᏍᏉ ᎠᏍᎦᏂ ᏱᎩ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎬᏗᏍᎩ ᏱᎩ, ᎠᎴ ᎪᎯᏳᏗ ᎨᏒ ᏱᎩ, ᎠᏚᏓᎴᏍᏗ ᎨᏒ ᎬᏗᏍᎩ?


text:
ᎠᏗᎾ ᎤᏁᎳᏅᎯ ᎠᎵᎮᎵᏤᏗ ᎨᏎᏍᏗ, ᎾᏍᎩ ᎤᏙᎯᏳᎯ ᎠᏍᎦᏂ ᏗᏥᎾᏝᎢ ᏥᎨᏒᎩ, ᎠᏎᏃ ᏗᏥᎾᏫ ᎬᏗ ᎢᏦᎯᏳᏅ ᎾᏍᎩ ᏄᏍᏛ ᏗᏕᏲᏗ ᎨᏒ ᎾᏍᎩ ᏤᏥᏲᎯᏎᎸᎯ ᎨᏒᎢ.


text:
ᏴᏫ ᎢᏳᏂᏪᏍᏗ ᏂᏥᏪᎭ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎢᏥᏇᏓᎸ ᏩᎾᎦᎳᎯᏳ ᎨᏒᎢ; ᏗᏥᏰᎸᏰᏃ ᎢᏣᏚᏓᏕᏫᏒ ᏥᏕᏥᏲᏒᎩ ᎦᏓᎭ ᎠᎴ ᎤᏲ ᎨᏒ ᎤᏂᎾᏝᎢ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᎤᏲ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ; ᎾᏍᎩᏯ ᎾᏍᏉ ᎪᎯ ᎨᏒᎢ, ᏗᏥᏰᎸ ᎢᏣᏚᏓᏕᏫᏒ ᏗᏥᏲᎯ ᎤᏂᎾᏝᎢ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᎢᏥᏍᎦᎾ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎠᎨᏴᏰᏃ ᏥᏓᏤᎰᎢ, ᏗᎧᎿᏩᏛᏍᏗ ᎤᏚᏓᎸᏙ ᎤᏰᎯᎤᎾᏁᎳᏗᏍᏗᏱ ᎢᎩᎯᏛ ᎠᎴᏂᏙᎲ ᎤᏰᎯ; ᎤᏰᎯᏍᎩᏂ ᎤᏲᎱᏒᎯ ᏱᎩ, ᎤᏚᏓᎴᏛ ᎨᏐ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏚᏓᎸᏛ ᎤᏰᎯ ᎤᎾᏁᎳᏗᏍᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎢᏳᏃ ᎠᏏᏉ ᎡᎲ ᎤᏰᎯ, ᏅᏩᏓᎴ ᎠᏍᎦᏯ ᏱᏚᎾᏤᏅ, ᎠᏓᏲᏁᎯ ᎠᎪᏎᎮᏍᏗ; ᎢᏳᏍᎩᏂ ᎤᏰᎯ ᎤᏲᎱᏒᎯ ᏱᎩ, ᎤᏚᏓᎴᏛ ᎨᏐ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏚᏓᎸᏛᎢ; ᎾᏍᎩᏃ ᎥᏝ ᎠᏓᏲᏁᎯ ᏱᎩ, ᎤᏁᎳᎩ ᏅᏩᏓᎴ ᎠᏍᎦᏯ ᏱᏓᎾᏤᎭ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏓᎵᏅᏟ ᏂᎯ ᎾᏍᏉ ᏗᏥᏲᎱᏒᎯ ᏂᏣ-ᎵᏍᏔᏅ ᏗᎧᎿᏩᏛᏍᏗ ᎤᎬᏩᎵ, ᎦᎶᏁᏛ ᎠᏰᎸ ᎢᏳᏩᏂᏌᏛ; ᎾᏍᎩ ᏅᏩᏓᎴ ᏗᏣᏨᏍᏗᏱ ᎠᏰᎸᏒᎩ, ᎾᏍᎩ ᎠᏲᎱᏒ ᏣᎦᎴᏔᏅᎯ ᎨᏒᎢ, ᎾᏍᎩ ᎤᎦᏔᏔᏅᎯ ᎡᏗᎾᏄᎪᏫᏎᏍᏱ ᎤᏁᎳᏅᎯ.


text:
ᎤᏇᏓᎸᏉᏰᏃ ᎠᏏ ᏥᏕᎲᎢ, ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᎤᏚᎸᏅᎥᏍᎬᎢ, ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎢᏳᏩᏂᏌᏛ ᎨᏒᎢ, ᎾᏍᎩ ᏚᎸᏫᏍᏓᏁᎲᎩ ᏗᏗᏰᎸ ᎤᏚᏓᏕᏫᏒᎢ ᎤᎦᏔᏔᏅᎯ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎡᏗᎾᏄᎪᏫᏎᏗᏱ.


text:
ᎪᎯᏍᎩᏂ ᎨᏒ ᏗᎧᎿᏩᏛᏍᏗ ᎡᏓᏚᏓᎳᎡᎸ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏲᎱᏒᎯ ᎨᏒ ᏗᎩᎾᏢᏅᎯ ᎨᏒᎢ; ᎾᏍᎩ ᎢᏤ ᎠᏓᏅᏙ ᎢᎬᏙᏗᏱ ᎪᎱᏍᏗ ᎡᏓᏛᏁᏗᏱ, ᎥᏝᏃ ᎪᏪᎸᏉ ᎢᎬᏙᏗᏱ ᎾᏍᎩᏯ ᏂᎦᏛᏁᎸ ᏧᏩᎫᏔᏅᏒᎢ.


text:
ᎦᏙᎨᏃ ᏓᏓᏛᏂ? ᏥᎪ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏍᎦᏂᏉ? ᎬᏩᏟᏍᏗ. ᎥᏝᏍᎩᏂ ᎠᏍᎦᏂ ᏱᎬᎩᎦᏙᎥᏎ ᎥᏝ ᏗᎧᎿᏩᏛᏍᏗ; ᎥᏝᏰᏃ ᏱᎦᏥᎦᏔᎮ ᎤᏲ ᎠᏚᎸᏅᏗ ᎨᏒᎢ, ᎢᏳᏃ ᏗᎧᎿᏩᏛᏍᏗ ᎯᎠ ᏄᏪᏒᎾ ᏱᎨᏎᎢ, ᏞᏍᏗ ᏣᏓᏚᎸᎡᎸᎩ.


text:
ᏥᎪᏃ ᎾᏍᎩ Ꮎ ᎣᏍᏛ ᎨᏒ ᎠᎩᎯᎯᏉ ᏄᎵᏍᏔᏁᎢ? ᎬᏩᏟᏍᏗ. ᎠᏍᎦᏂᏍᎩᏂ, ᎾᏍᎩ ᎬᏂᎨᏒ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏍᎩ ᏄᏍᏛ ᎠᏍᎦᏂ, ᏚᎸᏫᏍᏓᏁᎲᎩ ᎠᎩᎯᏍᏗᏱ ᎬᏗᏍᎬᎩ ᎾᏍᎩ Ꮎ ᎣᏍᏛ ᎨᏒᎢ; ᎾᏍᎩ ᎠᏍᎦᏂ ᎤᎵᏁᏨ ᎢᏳᏩᏂᏌᏛ ᎤᏣᏘ ᎠᏍᎦᎾᎯᏳ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᏥᎦᏔᎭᏰᏃ ᎾᏍᎩ ᎠᏴ ᎨᏒᎢ, (ᎾᏍᎩ ᎠᎩᏇᏓᎸ ᏯᏛᏅ,) ᎪᎱᏍᏗ ᎣᏍᏛ ᏄᎵᏠᏯᏍᏛᎾ ᎨᏒᎢ; ᎠᏚᎸᏗᏱᏰᏃ ᎠᎩᎭ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᎣᏍᏛ ᎨᏒ ᎢᏯᏛ-ᏁᏗᏱ ᎥᏝ ᏱᏥᏩᏘᎭ.


text:
ᎠᏎᏃ ᎢᏥᎪᏩᏘᎭ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏛᏍᏗ ᏥᏰᎸ ᎠᏆᏚᏓᏕᏫᏒᎢ, ᎾᏍᎩ ᏗᎦᏘᎴᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏆᏓᏅᏙᎩᎯ ᎠᎲᎢ, ᎠᎴ ᏥᏴᎩ ᎢᏯᏋᏁᎯ ᎠᏇᏓᎸᎥᏍᎩ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎠᏍᎦᏂ ᎤᏤᎵᎦ, ᎾᏍᎩ ᏥᏰᎸ ᎠᏆᏚᏓᏕᏫᏒ ᎠᎲᎢ.


text:
ᎤᏁᎳᏅᎯ ᏥᏯᎵᎡᎵᏤᎭ ᏥᏌ ᎦᎶᏁᏛ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ ᎢᏳᏩᏂᏌᏛ. ᎾᏍᎩᏃ ᎠᏆᏓᏅᏖᏗᏱ ᎬᏗᎭ, ᎠᏴᏉ ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᏕᏥᎦᎾᏩᏕᎦ, ᎠᎩᏇᏓᎸᏍᎩᏂ ᎨᏒ ᎬᏗ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏍᎦᏂ ᎤᏤᎵ ᏕᏥᎦᎿᏩᏕᎦ.


text:
ᎠᏓᏅᏙᏰᏃ ᎬᏂᏛ ᎠᏓᏁᎯ, ᎾᏍᎩ ᎬᏂᏛ ᎦᎶᏁᏛ ᏥᏌ ᏨᏗᏓᎴᎲᏍᎦ, ᎾᏍᎩ ᎠᏓᏅᏙ ᎤᏤᎵ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏇᏓᎴᏒ ᎠᏍᎦᏂ ᎠᎴ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎤᎾᏤᎵ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎠᏆᏚᏓᎸᎢ.


text:
ᏗᎧᎿᏩᏛᏍᏗᏰᏃ ᎢᎬᏩᏛᏁᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎠᏩᎾᎦᎳᎯᏳ ᎨᏒ ᎤᏪᏓᎵ ᎢᏳᏩᏂᏌᏛ, - ᎤᏁᎳᏅᎯ ᎤᏩᏒ ᎤᏪᏥ ᏧᏅᏎ ᎾᏍᎩᏯ ᏗᏟᎶᏍᏔᏅᎯ ᎠᏍᎦᎾ ᎤᏇᏓᎵ, ᎠᎴ ᎠᏍᎦᏂ ᏧᎬᏩᎴᎢ, ᏚᏭᎦᏓᏁᎴ ᎤᏎᎪᎩᏎ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᎤᏇᏓᎸ ᎠᏯᎥᎢ;


text:
ᏂᎯᏍᎩᏂ ᎥᏝ ᎤᏇᏓᎵ ᏗᏣᏘᏂᏙᎯ ᏱᎩ, ᎠᏓᏅᏙᏍᎩᏂ ᏗᏣᏘᏂᏙᎯ, ᎢᏳᏃ ᎰᏩ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏙ ᏱᏥᏯᎠ. ᎠᎴ ᎢᏳ ᎩᎶ ᎦᎶᏁᏛ ᎤᏓᏅᏙ ᏄᏪᎲᎾ ᎢᎨᏎᏍᏗ, ᎾᏍᎩ ᎾᎥᏝ <n>[ᎦᎶᏁᏛ]</n> ᎤᏤᎵ ᏱᎦᎩ.


text:
ᎠᎴ ᎢᏳ ᏧᏪᏥ ᏱᎩ, ᎿᏉ ᎢᎦᏘᏰᎯ ᏧᎬᏩᎶᏗ; ᎢᎦᏘᏰᏗ ᏧᎬᏩᎶᏗ ᎤᏁᎳᏅᎯ ᎤᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎦᎶᏁᏛ ᎢᏧᎳᎭ ᎢᎦᏘᏰᏗ; ᎢᏳᏃ ᎰᏩ ᏱᎦᏠᏯᏍᏗᎭ ᎠᎩᎵᏲᎬᎢ, ᎾᏍᏉ ᎢᎦᏠᏯᏍᏙᏗ ᎨᏎᏍᏗ ᎠᏥᎸᏉᏗᏍᎬᎢ.


text:
ᎥᏝ ᎠᎴ ᎡᏅᏒᏉ, ᎢᎬᏒᏍᎩᏂ ᎾᏍᏉ ᎢᎬᏱᏱ ᎤᎾᏄᎪᏫᏒᎯ ᎠᏓᏅᏙ ᏥᎨᎭ, ᎠᏴ ᎾᏍᏉ ᎢᎬᏒ ᎨᏒ ᎭᏫᏂ ᏕᎩᎵᏰᏗᎭ, ᎢᏗᎦᏘᏴ ᏧᏪᏥ ᎢᎨᎬᏁᏗ, ᎾᏍᎩ ᏗᏗᏰᎸ ᏧᎫᏴᏗᏱ ᏧᏭᏓᎴᏍᏗᏱ.


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏓᏅᏙ ᎢᎩᏍᏕᎵᎭ ᏗᏗᏩᎾᎦᎳᎯᏳ ᎨᏒᎢ; ᎥᏝᏰᏃ ᏱᏗᎦᏔᎭ ᎢᏳᏍᏗ ᏚᏳᎪᏛ ᎨᏒ ᎢᎩᏔᏲᏍᏗᏱ ᎢᏓᏓᏙᎵᏍᏗᏍᎬᎢ; ᎠᏓᏅᏙᏍᎩᏂ ᎤᏩᏒ ᎢᎦᎵᏍᏗᏰᏓᏁᎭ ᎤᎵᏰᏗᏍᎬ ᎬᏗᎭ ᎾᏍᎩ ᎦᏁᎢᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎠᎴ ᎢᏗᎦᏔᎭ ᎾᏍᎩ ᏂᎦᎥ ᏂᎦᎵᏍᏔᏂᏙᎲ ᎤᎾᏖᏆᎶᏒ ᎣᏍᏛ ᎢᏳᎾᎵᏍᏓᏁᏗᏱ ᏚᏂᏖᏆᎶᏒ ᎣᏍᏛ ᎢᏳᎾᎵᏍᏓᏁᏗᏱ ᏚᏂᎸᏫᏍᏓᏁᎲ ᎤᏁᎳᏅᎯ ᎤᏂᎨᏳᎯ, ᎾᏍᎩ Ꮎ ᎨᏥᏯᏅᏛ ᏥᎩ ᎾᏍᎩᏯ ᎤᏓᏅᏖᎸᎢ.


text:
ᎾᏍᎩᏃ ᎦᏳᎳ ᏥᏂᏚᏑᏰᏐᎢ ᎾᏍᎩ ᎾᏍᏉ ᏚᏯᏅᎮᎢ; ᎠᎴ ᎾᏍᎩ ᏧᏯᏅᏛ ᎨᏒᎢ, ᎾᏍᎩ ᎾᏍᏉ ᏚᏭᏓᎴᏎᎢ; ᎠᎴ ᎾᏍᎩ ᏧᏭᏓᎴᏛ ᎨᏒ, ᎾᏍᎩ ᎾᏍᏉ ᎦᎸᏉᏗᏳ ᏂᏚᏩᏁᎴᎢ.


text:
ᎾᏍᎩ Ꮎ ᏄᎨᏳᏅᎾ ᏥᎨᏎ ᎤᏩᏒ ᎤᏪᏥ, ᏥᏚᏲᏎᏉᏍᎩᏂ ᎠᏴ ᏂᏗᎥ ᎢᎩᏍᏕᎵᏍᎬᎢ, ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᎾᏍᎩ ᏕᎩᏲᎯᏎᎲ ᎠᏎᏉ ᏗᎨᎩᏲᎯᏎᏗ ᏂᎨᏒᎾ ᏱᏂᎦᎵᏍᏓ ᏂᎦᏗᏳ ᎪᎱᏍᏗ?


text:
ᎦᎪ ᎢᏴᏛ ᏅᏓᎬᏁᎵ ᎦᎶᏁᏛ ᎢᎩᎨᏒᎢ? ᏥᏌ ᎠᎩᎵᏲᎢᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏪᎵᎯᏍᏗ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏲ ᎢᏴᏓᏛᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏓᎪᏄᎶᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏗᎩᏰᎸᎭ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏰᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏰᎳᏍᏗ-ᎦᏅᎯᏛ?


text:
ᎤᎵᏂᎩᏛᏰᏃ ᎠᏉᎯᏳᎭ, ᎾᏍᎩ ᎥᏝ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏛᏂᏗᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏗᏂᎧᎿᏩᏗᏙᎯ, ᎠᎴ ᏄᏂᎬᏫᏳᏌᏕᎩ, ᎠᎴ ᎨᏥᎸᏉᏗ, ᎠᎴ ᎪᎱᏍᏗ ᎪᎯ ᏤᎭ, ᎠᎴ ᎪᎱᏍᏗ ᎠᏎ ᎤᎾᏄᎪᎢᏍᏗ ᏥᎩ,


text:
ᎥᏝ ᎠᎴ ᎦᎸᎳᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎭᏫᏂᏳ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᏅᏩᏓᎴ ᎠᏁᎳᏅᎯ ᎨᏒᎢ, ᏰᎵ ᎢᏴᏛ ᎢᎬᏩᏁᏗ ᏱᎨᏎᏍᏗ ᎤᏁᎳᏅᎯ ᎢᎩᎨᏳᏒᎢ, ᎾᏍᎩ ᎦᎶᏁᏛ ᏥᏌ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵ ᏅᏓᏳᏓᎴᏅᎯ ᏥᎩ.


text:
ᎾᏍᎩ ᎢᏏᎵ ᏧᏁᏢᏔᏅᏛ ᏥᎩ; ᎾᏍᎩ ᎤᎾᏤᎵᎦ ᏥᎩ <n>[ᎤᏁᎳᏅᎯ]</n> ᏧᏪᏥ ᎢᎨᎬᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛᎢ, ᎠᎴ ᏗᎧᎿᏩᏛᏍᏗ ᎨᏥᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏚᎢᏍᏙᏗ ᎨᏒᎢ;


text:
ᏗᏂᏲᎵᏰᏃ ᎠᏏ ᎾᎾᏕᎲᏍᎬᎾ ᎨᏎᎢ, ᎠᎴ ᎠᏏ ᎪᎱᏍᏗ ᎣᏍᏛ ᎠᎴ ᎤᏲᎢ ᎾᎾᏛᏁᎲᎾ ᎨᏎᎢ, ᎾᏍᎩ ᎤᏓᏅᏖᎸ ᎤᏁᎳᏅᎯ ᎾᏍᎩᏯ ᏧᏑᏰᏍᏗ ᎨᏒ ᎤᏲᎢᏍᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎥᏝ ᏚᏂᎸᏫᏍᏓᏁᎲ ᏅᏗᎦᎵᏍᏙᏗᏍᎬᎢ, ᎾᏍᎩᏯᏍᎩᏂ ᏗᏯᏂᏍᎩ ᎤᏓᏅᏖᎸᎢ;


text:
ᎪᏪᎵᎯᏰᏃ ᎯᎠ ᎾᏥᏪᏎ ᏇᏓᏲ, ᎾᏍᎩ ᎯᎠ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏕᎬᏯᎴᏔᏅ, ᎾᏍᎩ ᎠᎩᎾᏄᎪᏫᏍᏗᏱ ᎠᏆᎵᏂᎩᏗᏳ ᎨᏒ ᏂᎯ ᎬᏴᏗᏍᎬᎢ, ᎠᎴ ᎾᏍᎩ ᎠᏴ ᏓᏆᏙᎥ ᏧᏃᏣᎶᎢᏍᏗᏱ ᎡᎶᎯ ᏂᎬᎾᏛᎢ.


text:
<n>[ᎦᏙᏃ ᏳᏍᏗ,]</n> ᎢᏳᏃ ᎤᏁᎳᏅᎯ ᎤᏚᎵᏍᎬ ᎬᏂᎨᏒ ᎢᏳᏩᏁᏗᏱ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᎵᏂᎬᎬ ᎤᎾᏄᎪᏫᏍᏗᏱ, ᎬᏂᏗᏳ ᎨᏒ ᎬᏗᏍᎬ ᎪᎯᏗᏳ ᎤᏁᎳᎩ ᏱᏚᏪᎵᏎᎸ ᏗᏖᎵᏙ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᏗᏟᏍᏗ, ᏗᏛᏅᎢᏍᏔᏅᎯ ᏗᏛᏙᏗᏱ;


text:
ᎠᎴ ᎾᏍᎩ <n>[ᎤᏚᎵᏍᎬ]</n> ᎬᏂᎨᏒ ᎢᏳᏩᏁᏗᏱ ᎤᏤᎵ ᎤᏣᏔᏅᎯ ᎦᎸᏉᏗᏳ ᎨᏒ ᏕᎬᏗᏍᎬ ᏗᏖᎵᏙ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏗᏟᏍᏗ, ᎾᏍᎩ ᏧᏛᏅᎢᏍᏔᏅᎯ ᏥᏂᎨᏎ ᎦᎸᏉᏗᏳ ᏗᎨᏒ ᏭᎾᏕᏗᏱ,


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᎯᎠ ᏥᏂᎦᏪ ᎰᏏᎠ ᎤᏬᏪᎸᎢ; ᏗᏆᏤᎵ ᏴᏫ ᎦᏥᏲᏎᎮᏍᏗ ᎾᏍᎩ Ꮎ ᏗᏆᏤᎵ ᏴᏫ ᏂᎨᏒᎾ ᏥᎨᏒᎩ; ᎠᎴ ᏥᎨᏳᎢ (ᏥᏲᏎᎮᏍᏗ,) ᎾᏍᎩ Ꮎ ᏥᎨᏳᎢ ᏂᎨᏒᎾ ᏥᎨᏒᎩ.


text:
ᎾᏍᎩᏃ ᏥᏄᏍᏗ ᎦᏙ ᏓᏓᏛᏂ? ᎾᏍᎩ Ꮎ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᎠᏚᏓᎴᏍᏗ ᎨᏒ ᏄᏂᏍᏓᏩᏛᏒᎾ ᎨᏒ, ᎾᏍᎩ ᎠᏚᏓᎴᏍᏗ ᎨᏒ ᎤᏂᏩᏛᎲ, ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᎠᏚᏓᎴᏍᏙᏗ ᏥᎩ.


text:
ᎾᏂᎦᏔᎲᎾᏰᏃ ᎨᏒ ᏄᏍᏛ ᎤᏁᎳᏅᎯ ᎤᏓᏚᏓᎴᏍᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎾᏟᏂᎬᏁᎲ ᎤᏂᏍᏓᏱᏗᏍᏗᏱ ᎤᏅᏒ ᎤᎾᏤᎵ ᎤᎾᏚᏓᎴᏍᏙᏗ ᎨᏒᎢ, ᎥᏝ ᏧᎾᏓᏲᎯᏎᎸᎯ ᏱᎩ ᎤᏁᎳᏅᎯ ᎤᏓᏚᏓᎴᏍᏙᏗ ᎨᏒᎢ.


text:
ᎦᏙᏃ ᏱᎦᎵᏍᏙᏓ ᏯᎾᏓᏙᎵᏍᏓᏏ ᎩᎶ ᏄᏃᎯᏳᏒᎾ ᏱᎩ ᎡᎲᎢ? ᎠᎴ ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᏯᏃᎯᏳᎲᎦ ᎩᎶ ᎡᎲ ᎾᏍᎩ ᎤᎾᏛᎦᏅᎯ ᏂᎨᏒᎾ ᏱᎩ ᎡᎲᎢ? ᎠᎴ ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᏯᎾᏛᎬᎦ ᎩᎶ ᎠᎵᏥᏙᎲᏍᎩ ᏄᏁᎲᎾ ᏱᎩ?


text:
ᎠᎴ ᎦᏙ ᏱᎦᎵᏍᏙᏗ ᏯᎾᎵᏥᏙᎲᎦ ᎢᏳᏃ ᏂᎨᏥᏅᏒᎾ ᏱᎩ? ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᏂᏚᏬᏚᎭ ᏧᎾᎳᏏᏕᏂ ᎾᏍᎩ Ꮎ ᎣᏍᏛ ᎧᏃᎮᏛ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏁᎯ ᎠᎾᎵᏥᏙᎲᏍᎩ, ᎣᏍᏛ ᎧᏃᎮᏛ ᎠᎾᎵᏥᏙᎲᏍᎩ ᎾᏍᎩ ᎣᏍᏛ ᎤᎬᏩᎵ ᎨᏒᎢ.


text:
ᎠᏎᏃ ᎠᏴ ᏂᏥᏪᎭ, ᏝᏍᎪ ᏯᏂᎦᏔᎮ ᎢᏏᎵ? ᎢᎬᏱ ᎨᏒ ᎼᏏ ᎯᎠ ᏂᎦᏪᎭ, ᎢᏣᏛᏳᎨᏗᏱ ᏅᏓᏨᏴᏁᎵ ᏓᎦᏥᏴᏔᏂ ᎾᏍᎩ Ꮎ ᎠᏰᎵ ᎤᏃᏢᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᎴ ᏄᎾᏓᏅᏛᎾ ᏴᏫ ᎦᏥᏴᏗᏍᎬ ᏓᏨᎾᎸᏍᏔᏂ.


text:
ᎠᏎᏃ ᎢᏌᏯ ᏂᎦᎾᏰᏍᎬᎾ ᎯᎠ ᏂᎦᏪᎭ, ᎬᎩᏩᏛᎲᎩ ᎾᏍᎩ Ꮎ ᏂᎬᎩᏲᎸᎾ, ᎬᎩᏩᏛᎲᎩ ᎾᏍᎩ Ꮎ ᏂᎬᎩᏲᎸᎾ ᎨᏒᎢ; ᎬᏂᎨᏒ ᏂᎬᏋᏁᎸᎩ ᎠᏁᎲ ᎾᏍᎩ Ꮎ ᎾᎾᏛᏛᎲᏍᎬᎾ ᎨᏒ ᎨᎥᎢ.


text:
ᎤᏁᎳᏅᎯ ᎥᏝ ᎢᏴᏛ ᏱᏂᏚᏩᏁᎸ ᏧᏤᎵ ᏴᏫ ᎾᏍᎩ ᎦᏳᎳ ᏥᏂᏓᎦᏔᎰᎢ. ᏝᏍᎪ ᏱᏥᎦᏔᎭ ᏂᎦᏪᏍᎬ ᎪᏪᎵ ᎾᎿ ᎢᎳᏯ ᎠᏥᏃᎮᏍᎬᎢ? ᎾᏍᎩ ᎠᏔᏲᎯᎲ ᏕᎠᏡᏗᏍᎬ ᎢᏏᎵ ᎯᎠ ᏂᎦᏪᏍᎬᎢ,


text:
ᎢᏳᏃ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎢᏳᏩᏂᏌᏅᎯ ᏱᎩ; ᎿᏉ ᎥᏝ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎢᏳᏩᏂᏌᏅᎯ ᏱᎩ; ᎢᏳᏃ ᎾᏍᎩ ᏱᏄᏍᏗ, ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎥᏝ ᎿᏉ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏱᎦᎩ. ᎢᏳᏩᏂᏌᏅᎯ ᏱᎩ, ᎿᏉ ᎥᏝ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎢᏳᏩᏂᏌᏅᎯ ᏱᎩ; ᎢᏳᏃ ᎾᏍᎩ ᏱᏄᏍᏗ, ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎥᏝ ᎿᏉ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᏱᎦᎩ.


text:
ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᎤᏁᎳᏅᎯ ᏚᏁᎸ ᎠᏓᎵᏔᏗᏍᎩ ᎠᏓᏅᏙ, ᎠᎴ ᏗᏂᎦᏙᎵ ᏗᎬᏩᏂᎪᏩᏛᏙᏗ ᏂᎨᏒᎾ, ᎠᎴ ᏗᏂᎴᏂ ᏗᎬᏩᎾᏛᎪᏙᏗ ᏂᎨᏒᎾ, ᎪᎯ ᎨᏒ ᎢᏯᏍᏗ.


text:
ᎯᎠ ᎠᏗᎾ ᏂᏥᏪᎭ, ᏥᎪ ᏚᏃᏕᎸ ᏰᎵ ᏧᏂᏅᎢᏍᏗᏱ ᎠᏰᎸᏎᎢ? ᎬᏩᏟᏍᏗ; ᎾᏍᎩᏍᎩᏂ ᏚᏂᏅᏨ ᏄᏩᏂᏌᏅ ᎠᎵᏍᏕᎸᏙᏗ ᎨᏒ ᎤᏂᎷᏤᎸ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᎤᎾᏛᏳᎨᏗᏱ ᎢᏳᏅᏂᏐᏗᏱ.


text:
ᎢᏳᏃ ᏚᏩᏂᎦᎸ ᎢᎦᏛ ᏱᏗᎬᏂᎦᎴᏒ, ᏂᎯᏃ ᎢᎾᎨ-ᎮᎯ ᎣᎵᏩ ᏡᎬ ᎾᎿ ᏱᏫᏰᏣᏱᏢᏔᏅ, ᎠᎴ ᎾᏍᎩᏯ ᎤᎾᎵᏍᏕᎶᏛ ᏱᏤᎳᏗᏍᏗ ᏱᏣᎵᏍᏕᎸᏗ ᏚᎿᏍᏕᏢ ᎠᎴ ᎦᎵᏦᏅ ᎣᎵᏩ ᏡᎬᎢ;


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎭᎦᏌᏯᏍᏓ ᎤᏓᏅᏖᏳ ᎨᏒ ᎠᎴ ᎠᏍᏓᏱᏳ ᎨᏒ ᎤᏁᎳᏅᎯ; ᎠᏍᏓᏱᏳ ᏂᏕᎬᏁᎲ ᎾᏍᎩ Ꮎ ᏧᏂᏅᏨᎯ; ᏂᎯᏍᎩᏂ ᎤᏓᏅᏘᏳ ᎨᏒ ᏣᎾᏄᎪᏫᏎᎲᎢ; ᎢᏳᏃ ᏱᏅᏩᏍᏗᏗ ᏕᏣᏂᏴᏒ ᎤᏓᏅᏘᏳ ᎨᏒᎢ; ᎥᏝᏰᏃ ᎾᏍᎩ ᏂᎯ ᎾᏍᏉ ᎡᏨᎾᎦᎴᏍᏗ ᎨᏎᏍᏗ.


text:
ᎢᏳᏰᏃ ᏂᎯ ᎢᎾᎨ ᎡᎯᏯ ᎣᎵᏩ ᏡᎬᏨᏱᏢᏅᎯ ᏱᎩ, ᎠᎴ ᎾᎿ ᎮᎯᏯ ᏂᎨᏒᎾ ᎨᏒ ᎣᏍᏛ ᎣᏍᏛ ᎣᎵᏩ ᏡᎬ ᏰᏨᏱᏢᏅ, ᎤᏟᎯᏳᏍᎩᏂ ᎠᎯᏘᏳ ᎾᏍᎩ Ꮎ ᎾᎿ ᎠᏁᎯᏯ ᏥᎩ, ᎨᏥᏱᏢᏗ ᎾᎿ ᎤᏅᏒ ᎤᎾᏤᎵᎦᏯ ᎣᎵᏩ ᏡᎬᎢ.


text:
ᎥᏝᏰᏃ ᏯᏆᏚᎵ, ᎢᏓᎵᏅᏟ, ᏂᏥᎦᏔᎲᎾᏉ ᎢᏳᎵᏍᏙᏗᏱ ᎯᎠ ᎾᏍᎩ ᎤᏕᎵᏛ ᎨᏒᎢ, (ᎢᏥᎦᏔᎾᎢᏉᏰᏃ ᏱᏅᏣᎵᏍᏓ ᎢᏨᏒ ᎢᏣᏓᏅᏖᏍᎬᎢ,) ᎾᏍᎩ ᎠᎫᏏᏲᎢᏍᏗ ᎨᏒ ᎤᏂᎷᏤᎸ ᎢᎦᏛ ᎢᏏᎵ, ᎬᏂ ᎤᏂᏣᏘ ᎨᏒ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏂᏴᎸᎯ ᎨᏎᏍᏗ,


text:
ᎾᏍᎩᏃ ᏅᏓᎦᎵᏍᏔᏂ ᏂᎦᏗᏳ ᎢᏏᎵ ᎨᏥᏍᏕᎸᏗ ᎨᏎᏍᏗ; ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᏌᏯᏂ ᏅᏓᏳᏓᎴᏅᎯ ᏓᎦᎷᏥ ᏗᎫᏓᎴᏍᎩ, ᎠᎴ ᎢᏴᏛ ᏅᏓᎬᏁᎵ ᎤᏁᎳᏅᎯ ᏄᏂᎸᏉᏛᎾ ᎨᏒ ᎢᎦᏈ ᎤᏪᎲᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎢᏓᎵᏅᏟ, ᎢᏨᏍᏗᏰᏗᎭ ᎤᏁᎳᏅᎯ ᎤᏓᏙᎵᏣᏘᏳ ᎨᏒ ᎢᏳᏍᏗ, ᎾᏍᎩ ᏗᏥᏰᎸ ᏗᏣᎵᏍᎪᎸᏙᏗᏱ ᎬᏃᏛ ᎠᏥᎸ ᎨᎳᏍᏗ, ᎪᎱᏍᏗ ᏄᏍᏛᎾ, ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᎤᏁᎳᏅᎯ, ᏕᏣᏓᏅᏛ ᎬᏗ ᎪᎱᏍᏗ ᎡᏣᏛᏁᎲᎢ.


text:
ᎠᎴ ᏞᏍᏗ ᎡᎶᎯ ᎠᏂᎮ ᏄᎾᏍᏛ ᏱᏂᏨᏍᏕᏍᏗ; ᏗᏣᏓᏁᏟᏴᏛᏍᎩᏂ ᎨᏎᏍᏗ ᏗᏤ ᎢᏗᎬᏁᎸᎯ ᎨᏒ ᏕᏣᏓᏅᏛᎢ, ᎾᏍᎩ ᎨᏥᎪᎵᏰᏗ ᎢᏳᎵᏍᏙᏗᏱ ᏄᏍᏛ ᎤᏚᎵᏍᎬ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎣᏍᏛ ᎨᏒᎢ, ᎠᎴ ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎧᎵᎢ ᎨᏒᎢ.


text:
ᎬᏩᎦᏘᏯᏰᏃ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎬᏗᏍᎬ, ᎾᏍᎩ ᎥᎩᏁᎸᎯ ᏥᎩ, ᎯᎠ ᏂᎦᏥᏪᏎᎭ ᎾᏂᎥᏉ ᏥᎨᏣᏓᏑᏯ; ᏞᏍᏗᏉ ᏯᏂᎶᏒᏍᏗᏍᎨᏍᏗ ᎠᎾᏓᏅᏖᏍᎬ ᎾᏍᎩ ᏥᏚᏳᎪᏗ ᎤᎾᏓᏅᏖᏗᏱ, ᎤᎾᎵᏏᎾᎯᏍᏗᏍᎩᏂ ᎨᏎᏍᏗ ᎠᎾᏓᏅᏖᏍᎬᎢ, ᎾᏍᎩᏯ ᏄᏍᏛ ᎪᎯᏳᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᏚᏟᎶᎡᎸ ᎠᏂᏏᏴᏫᎭᎢ.


text:
ᎾᏍᎩᏃ ᏧᏓᎴᎿᎢ ᎡᎩᏁᎸᏅᎯ ᏥᎩ ᎾᏍᎩᏯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎢᎩᏁᎸᎢ, ᎢᏳᏃ ᎠᏙᎴᎰᎯᏍᏗ ᏱᎩ, ᎾᏍᎩᏯ ᎪᎯᏳᏗ ᎨᏒ ᎡᎦᏟᎶᎡᎸ ᎢᏛᏗᏍᎨᏍᏗ <n>[ᎢᏓᏙᎴᎰᏍᎨᏍᏗ;]</n>


text:
ᎠᎴ ᎩᎶ ᏗᎦᏬᏁ-ᏗᏍᎩ ᎨᏎᏍᏗ, ᏗᎦᏬᏁᏙᏗᏉ ᎨᏒ ᏚᎸᏫᏍᏓᏁᎮᏍᏗ; ᎠᎴ ᎩᎶ ᏓᏯᏙᎮᎮᏍᏗ, ᏄᎨᏳᎲᏍᎬᎾ ᎾᏍᎩ ᎾᏛᏁᎮᏍᏗ; ᎩᎶ ᏣᎦᏁᎶᏗ ᎨᏎᏍᏗ, ᎣᏍᏛ ᎤᎦᏌᏯᏍᏗ ᎨᏎᏍᏗ; ᎩᎶ ᎠᏓᏙᎵᎨᏍᏗ, ᎤᎧᎵᏍᏗ ᎤᏓᏅᏛ ᎾᏍᎩ ᎾᏛᏁᎮᏍᏗ.


text:
ᏄᏂᎬᏫᏳᏌᏕᏱᏰᏃ ᎥᏝ ᏗᎦᎾᏰᎯᏍᏗ ᏱᎩ ᎣᏍᏛ ᏱᏙᎸᏫᏍᏓᏁᎭ, ᎤᏲᏍᎩᏂ ᏱᏙᎸᏫᏍᏓᏁᎭ. ᏣᏚᎵᏍᎪᏃ ᏣᎾᏰᎯᏍᏗᏱ ᏂᎨᏒᎾ ᎠᏰᎵ ᎪᏢᏒᎢ? ᎣᏍᏛ ᎿᏛᏁᎮᏍᏗ, ᎾᏍᎩᏃ ᏣᎸᏉᏙᏗ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩᏰᏃ <n>[ᏄᎬᏫᏳᏌᏕᎩ]</n> ᎤᏁᎳᏅᎯ ᎤᏅᏏᏓᏍᏗ ᏂᎯ ᎣᏍᏛ ᎢᏣᎵᏍᏓᏁᏗ ᏧᎸᏫᏍᏓᏁᎯ. ᎢᏳᏍᎩᏂ ᎤᏲᏉ ᏙᏣᎸᏫᏍᏓᏁᎮᏍᏗ, ᎯᏍᎦᎢᎮᏍᏗ-ᎦᏅᎯᏛ; ᎤᏁᎳᏅᎯᏰᏃ ᎤᏅᏏᏓᏍᏗ ᎾᏍᎩ, ᎤᏞᎩ, ᎠᏍᏛᏗᏍᏗᏍᎩ ᎾᏍᎩ ᎾᎤᏲ ᏧᎸᏫᏍᏓᏁᎯ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᎦᏗᏳ ᏗᎫᏴᎡᏗ ᎨᏒ ᏕᏣᎫᏴᎡᎮᏍᏗ; ᎠᏰᎵ ᎡᏣᎫᏴᎡᏗ ᎨᏒ ᎠᏰᎵ ᎡᏣᎫᏴᎡᎮᏍᏗ; ᎢᏥᏃᏔᏅᏗᏱ ᎢᏣᎵᏍᎪᎸᏓᏁᎸ ᎡᏣᎫᏴᎡᏗ ᎨᏒ ᎡᏣᎫᏴᎡᎮᏍᏗ; ᎾᏍᎩ ᎡᏥᎾᏰᎢᏍᏗ ᎨᏒ ᎾᏍᎩ Ꮎ ᎡᏥᎾᏰᏍᎨᏍᏗ; ᎾᏍᎩ ᎡᏥᎸᏉᏙᏗ ᎨᏒ ᎾᏍᎩ Ꮎ ᎡᏥᎸᏉᏕᏍᏗ.


text:
ᎯᎠᏰᏃ ᎾᏍᎩ <n>[ᏗᎧᎿᏩᏛᏍᏗ,]</n> ᏞᏍᏗ ᏣᏓᏲᏁᎸᎩ, ᏞᏍᏗ ᏣᏓᎸᎩ, ᏞᏍᏗ ᏣᏃᏍᎩᏒᎩ, ᏞᏍᏗ ᎦᏰᎪᎩ ᏣᏃᎮᎸᎩ, ᏞᏍᏗ ᎪᎱᏍᏗ ᏱᏣᎬᎥᏍᎨᏍᏗ, ᎠᎴ ᏂᎦᎥ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏛᏍᏗ, ᎯᎠᏉ ᎢᎦᏪᏛ ᏥᎩ ᎾᎿ ᎠᏙᏣᎸᏍᎦ ᎤᏍᏆᎳ ᎧᏁᎢᏍᏗ ᎨᏒᎢ, ᏨᏒ ᏂᏣᏓᎨᏳᏒ ᎾᏍᎩᏯ ᏂᎨᏳᏎᏍᏗ ᎾᎥ ᎢᏗᏍᏓᏓᎳ.


text:
ᏚᏳᎪᏛ ᎨᏎᏍᏗ ᎢᏕᎲᎢ, ᎢᎦ ᏂᎨᏐ ᎾᏍᎩᏯᎢ; ᎥᏝᏍᏗᏃ ᎠᎵᏍᎦᎾᏩᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏓᏴᏍᏕᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒᎢ, ᎠᎴ Ꮓ-ᎵᏏᎾᎯᏍᏛᎾ ᎠᎴᏂᏓᏍᏗ ᎨᏒᎢ, ᎥᏞᏍᏗᏃ ᎠᏗᏒᏍᏗ ᎨᏒᎢ ᎠᎴ ᏗᏓᏛᏳᏤᏗ ᎨᏒᎢ.


text:
ᏞᏍᏗ ᎾᏍᎩ Ꮎ ᎠᎵᏍᏓᏴᎲᏍᎩ ᏅᎵᏌᎵᏉ ᏳᏰᎸᏁᏍᏗ Ꮎ ᎾᎵᏍᏓᏴᎲᏍᎬᎾ; ᎠᎴ ᏞᏍᏗ ᎾᏍᎩ Ꮎ ᎾᎵᏍᏓᏴᎲᏍᎬᎾ ᏱᏚᏭᎪᏓᏁᎴᏍᏗ Ꮎ ᎠᎴᏍᏓᏴᎲᏍᎩ; ᎤᏁᎳᏅᎯᏰᏃ ᏚᏓᏂᎸᏨ.


text:
ᎦᎪ ᏂᎯ ᏥᏕᎯᏳᎪᏓᏁ ᏅᏩᏓᎴ ᎤᏅᏏᏓᏍᏗ? ᎤᏩᏒᏉ ᎤᏅᏏᏙᎯ ᎤᎵᏍᎦᏍᏙᏗ ᎦᏙᎬ ᎠᎴ ᎦᏅᎬᎢ. ᎥᎥ, ᎠᏥᏲᏍᏙᏓᏁᏗ ᎨᏎᏍᏗ ᎤᏅᎢᏍᏗᏱ; ᎤᏁᎳᏅᎯᏰᏃ ᏰᎵᏉ ᎤᎴᏗᏱ ᎢᎬᏩᏁᏗ.


text:
ᎩᎶ ᏧᎸᏉᏙ ᎢᎦ ᎤᎬᏫᏳᎯ ᎦᎸᏉᏓᏁᎰᎢ; ᎩᎶᏃ ᏄᎸᏉᏛᎾ ᏥᎨᏐ ᎢᎦ, ᎤᎬᏫᏳᎯ ᎦᎸᏉᏗᏍᎪ ᏄᎸᏉᏛᎾ ᎨᏒᎢ. ᎩᎶ ᏣᎵᏍᏓᏴᎲᏍᎪᎢ, ᎤᎬᏫᏳᎯ ᎠᎵᏍᏓᏴᎾᏁᎰᎢ; ᎤᏁᎳᏅᎯᏰᏃ ᎠᎵᎮᎵᏤᎰᎢ; ᎠᎴ ᎩᎶ ᎾᎵᏍᏓᏴᎲᏍᎬᎾ ᏥᎨᏐᎢ, ᎤᎬᏫᏳᎯ ᎦᎸᏉᏙᏗᏍᎪ ᎾᎵᏍᏓᏴᎲᏍᎬᎾ ᎨᏒᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎠᎵᎮᎵᏤᎰᎢ.


text:
ᎢᏳᏰᏃ ᏱᏓᎴᏂᏙᎭ, ᎤᎬᏫᏳᎯ ᎡᏓᎴᏂᏕᎭ; ᎠᎴ ᎢᏳ ᏱᏗᏗᏲᎱᏍᎦ, ᎤᎬᏫᏳᎯ ᎡᏗᏲᎱᎯᏎᎭ; ᎾᏍᎩᏃ ᎢᏳᏍᏗ ᎢᏳᏃ ᏱᏓᎴᏂᏙᎭ, ᎠᎴ ᏱᏗᏗᏲᎱᏍᎦ, ᎤᎬᏫᏳᎯ ᎡᏓᏤᎵᎦ.


text:
ᎠᎴ ᏂᎯ, ᎪᏙᏃ ᏙᎯᏳᎪᏓᏁᎭ ᎢᏍᏓᎵᏅᏟ? ᎠᎴ ᏂᎯ ᎾᏍᏉ, ᎦᏙᏃ ᏅᎵᏌᎵᏉ ᎢᎯᏰᎸᏍᎦ ᎢᏍᏓᎵᏅᏟ? ᏂᎦᏗᏳᏰᏃ ᎢᎬᏱᏗᏢ ᏫᎦᎴᏗ ᎨᏎᏍᏗ ᎦᎶᏁᏛ ᏧᏭᎪᏗᏱ ᎤᏪᏍᎩᎸᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏞᏍᏗ ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᏱᏗᏓᏓᏚᎪᏓᏁᎮᏍᏗ; ᎯᎠᏍᎩᏂ ᎤᎬᏫᏳᏎᏍᏗ ᏕᏧᎪᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎠᏓᏙᏕᏍᏗᏍᎩ ᎠᎴ ᎤᏍᏢᏂᏍᏗᏍᎩ ᎢᏥᏗᏱ ᏂᎨᏒᎾ ᎢᏣᎵᏅᏟ ᎤᎶᎯᏍᏗᏱ.


text:
ᎢᏳᏍᎩᏂ ᏗᏍᏓᏓᏅᏟ ᎠᎵᏍᏓᏴᏗ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ ᎡᎯᏍᏗ ᏱᏯᏓᏅᏓᏗᏍᏔᏅ, ᎿᏉ ᎥᏝ ᎠᏓᎨᏳᏗ ᎨᏒ ᏴᏗᎭ ᎾᏍᎩ ᎿᏛᏁᎲᎢ. ᏞᏍᏗ ᎭᎵᏍᏓᏴᎲᏍᎬ ᎯᏛᏙᏔᏅᎩ ᎾᏍᎩ Ꮎ ᎦᎶᏁᏛ ᎤᏲᎱᎯᏎᎸᎯ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎤᏤᎵᎪᎯ ᎥᏝ ᎠᎵᏍᏓᏴᏗᏉ ᎠᎴ ᎠᏗᏔᏍᏗᏉ ᎨᏒ ᏱᎩ; ᏚᏳᎪᏛᏍᎩᏂ ᎨᏒᎢ, ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎨᏒᎢ, ᎠᎴ ᎠᎵᎮᎵᏍᏗ ᎨᏒᎢ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎢᏳᏩᏂᏌᏛ.


text:
ᏞᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᏱᏣᏲᏍᏔᏁᏍᏗ ᎠᎵᏍᏓᏴᏗᏉ ᏱᏅᏧᎵᏍᏙᏔᏁᏍᏗ. ᏄᏓᎴᏒᏰᏃ ᎪᎱᏍᏗ ᎤᏙᎯᏳᎯ ᎦᏓᎭ ᏂᎨᏒᎾ; ᎤᏲᏍᎩᏂ ᎾᏛᏁᎰ ᎾᏍᎩ Ꮎ ᏴᏫ ᎠᎵᏍᏓᏴᎲᏍᎬ ᎩᎶ ᏱᏗᎪᏕᏍᏗᎭ.


text:
ᎤᏟ ᎣᏏᏳ ᎭᏫᏯ ᎠᎩᏍᏗᏱ ᏂᎨᏒᎾ, ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎠᏗᏔᏍᏗᏱ ᏂᎨᏒᎾ, ᎠᎴ ᎪᎱᏍᏗ ᎠᏛᏁᏗᏱ ᏂᎨᏒᎾ, ᎾᏍᎩ ᏗᏍᏓᏓᏅᏟ ᏧᏬᏕᏍᏗᏍᎩ, ᎠᎴ ᎤᏍᏢᏂᏍᏗᏍᎩ, ᎠᎴ ᎠᏩᎾᎦᎳ ᎢᏳᏩᏁᎯ.


text:
ᎩᎶᏍᎩᏂ ᏧᏢᏫᏎᎯ ᏕᎫᎪᏗᏍᎪ ᎤᏍᎦᏅᏨ ᎢᏳᏃ ᏳᎵᏍᏓᏴᏅ, ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᏄᏬᎯᏳᏒᎾ ᎨᏒ ᎠᎵᏍᏓᏴᎲᏍᎬᎢ; ᏂᎦᎥᏰᏃ ᎪᎱᏍᏗ ᎪᎯᏳᏗ ᎨᏒ ᏅᏗᏓᎴᎲᏍᎬᎾ ᏱᎩ ᎠᏍᎦᏂ ᎨᏐᎢ.


text:
ᎦᎶᏁᏛᏰᏃ ᎾᏍᏉ ᎥᏝ ᎤᏩᏒᏉ ᎣᏍᏳ ᎤᏰᎸᏗ ᏱᎾᏛᏁᎮᎢ; ᎯᎠᏍᎩᏂ ᏥᏂᎬᏅ ᏥᎪᏪᎳ ᎾᏍᎩᏯ <n>[ᏄᎵᏍᏓᏁᎴᎢ,]</n> ᎦᎬᏩᎾᏓᏐᏢᏛ ᎾᏍᎩ Ꮎ ᎦᎨᏣᏐᏢᏔᏅᎢ ᎠᏴ ᎠᎩᎷᏤᎸᎩ.


text:
ᏄᏓᎴᏒᏰᏃ ᎪᎱᏍᏗ ᎡᏘ ᎪᏪᎳᏅᎯ ᎨᏒ ᎠᏴ ᎢᎦᏕᎶᏆᏍᏗ ᎠᏰᎸᏎ ᎪᏪᎳᏁᎢ, ᎾᏍᎩ ᏗᏛᏂᏗᏳ ᏂᎬᏁᎲ ᎠᎴ ᎤᎦᎵᏍᏗ ᎢᎦᏓᏅᏓᏗᏍᏗᏍᎬ ᎪᏪᎵ ᎾᏍᎩ ᎤᏚᎩ ᎢᎬᎯ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎠᎴ ᎯᎠ ᏂᏥᏪᎭ, ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᏗᎨᏥᎤᏍᏕᏎᎸᎯ ᎤᏂᏅᏏᏓᏍᏗ ᏄᎵᏍᏔᏅᎩ ᎬᏂᎨᏒ ᎢᏳᏩᏁᏗᏱ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎨᏒ ᎤᏁᎳᏅᎯ, ᏧᏍᏓᏱᏗᏍᏗᏱ ᎨᏥᏚᎢᏍᏓᏁᎸᎯ ᎨᏒ ᎠᏂᎦᏴᎵᎨᎢ.


text:
ᎠᎴ ᎾᏍᎩ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏂᎸᏉᏙᏗᏱ ᎤᏁᎳᏅᎯ ᎤᏓᏙᎵᏍᏗᏳ ᎨᏒ ᎢᏳᏍᏗ; ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᎾᏍᎩ ᎢᏳᏍᏗ ᏓᎬᏁᎢᏍᏔᏂ ᎠᏁᎲ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎠᎴ ᏙᏓᏥᏃᎩᏍᏔᏂ ᏕᏣᏙᎥᎢ.


text:
ᏔᎵᏁᏃ ᎢᏌᏯ ᎯᎠ ᏂᎦᏪᎭ; ᎤᎿᏍᏕᏢ ᎦᎾᏄᎪᎨᏍᏗ ᏤᏏᏱ, ᎠᎴ ᎠᏏᏴᏫ ᏙᏛᎴᏂ ᎤᎬᏫᏳᏌᏕᎩ ᎢᏳᎵᏍᏙᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏁᎲᎢ; ᎾᏍᎩ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᎬᏩᎵᏍᎦᏍᏙᏔᏂ.


text:
ᎾᏍᎩᏃ ᎤᏁᎳᏅᎯ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᎠᏓᏁᎯ ᎢᏥᎧᎵᎢᏍᏗ ᎨᏎᏍᏗ ᏄᏓᎴᏒ ᎤᎵᎮᎵᏍᏗ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎨᏒ ᎢᏦᎯᏳᏒ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᎤᏣᏔᏅᎯ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏚᎩ ᎢᏨᏒᎢ, ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎤᎵᏂᎬᎬ ᎢᏳᏩᏂᏌᏛ.


text:
ᎠᎴ ᎠᏋᏒ ᎾᏍᏉ ᎠᏉᎯᏳᎭ ᏂᎯ ᎢᏨᏯᏓᏅᏖᏍᎬᎢ, ᎢᏓᎵᏅᏟ, ᎾᏍᎩ ᏂᎯ ᎾᏍᏉ ᎣᏍᏛ ᎨᏒ ᎢᏥᎧᎵᎢ ᎨᏒᎢ, ᎠᎴ ᏄᏓᎴᏒ ᎠᎦᏙᎥᎯᏍᏗᎨᏒ ᎢᏥᎧᎵᎥᎢ, ᏰᎵᏉ ᎾᏍᏉ ᏗᎨᏣᏓᎬᏍᎪᎸᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᎠᎩᏅᏏᏙᎯ ᎢᏯᏆᎵᏍᏙᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏁᎲᎢ, ᎦᎸᏉᏗᏳ ᏓᎩᎸᏫᏍᏓᏁᏛ ᏴᏫ ᎠᏁᎲᎢ, ᎦᎸᏉᏗᏳ ᏓᎩᎸᏫᏍᏓᏁᎲ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎬᏗᏍᎬᎢ, ᎾᏍᎩ ᎦᎵᏍᎪᎸᏗᏍᎬ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎦᏥᏯᎵᏍᎪᎸᏗᏍᎬᎢ ᏧᏓᏂᎸᎢᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ, ᎦᎸᏉᏗᏳ ᎢᏳᏩᏁᎸᎯ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ.


text:
<n>[ᎠᎴ]</n> ᎬᏗᏍᎬ ᎤᏰᎸᏛᎢ ᎠᎴ ᎤᏍᏆᏂᎪᏗ, ᎤᏁᎳᏅᎯ ᎤᏓᏅᏙ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎬᏗᏍᎬᎢ; ᎾᏍᎩ ᏥᎷᏏᎵᎻ ᎤᏓᎴᏅᏛ, ᎠᎴ ᎤᏚᏫᏛ ᎢᎵᎵᎦᎻ ᏩᏍᏗ, ᎤᎧᎵᏨᎯ ᎠᏆᎵᏥᏙᏅ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ;


text:
ᎢᏳᏃ ᏍᏆᏂᏱ ᎨᏒᎭ, ᏫᏨᎷᏤᏗ ᎨᏎᏍᏗ; ᎤᏚᎩᏰᏃ ᎠᏋᎭ ᎢᏨᎪᏩᏛᏗᏱ ᎾᎿ ᏫᏥᏕᏖᏍᏗ, ᎠᎴ ᎾᎿ ᎢᏗᏢ ᏫᏍᎩᏯᎪᏗᏱ, ᎢᏳᏃ ᎢᎬᏱ ᎠᎴᏉ ᏰᎵ ᎾᎩᏰᎸᏁᏍᏗ ᎢᏨᏰᎳᏗᏙᎸᎢ.


text:
ᎣᏏᏳ ᎤᏂᏰᎸᏅ ᎤᏙᎯᏳᎯ; ᎠᎴ ᎾᏍᎩ ᎬᏩᏂᏚᎦ. ᎢᏳᏰᏃ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏁᎳᏗᏍᏔᏅᎯ ᏱᎩ ᎾᏍᎩ ᎤᎾᏤᎵ ᏧᏓᎴᏅᏛ ᎠᏓᏅᏙ ᎤᎵᏍᏕᎸᏙᏗ ᎤᎬᏩᎵ, ᎢᏳᎾᏛᏁᏗ ᎾᏍᏉ ᏄᎾᎵᏍᏓᏁᎲᎩ ᎾᏍᎩ ᏧᏂᏍᏕᎸᏗᏱ ᎤᏇᏓᎵ ᎤᎵᏍᏕᎸᏙᏗ ᎤᎬᏩᎵ.


text:
ᎠᎴ ᎢᏨᏍᏗᏰᏗᎭ ᎢᏓᎵᏅᏟ, ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᏅᏗᎦᎵᏍᏙᏗᎭ, ᎠᎴ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᏓᎨᏳᏗ ᎨᏒ ᎠᏓᏅᏙ ᎤᏓᏁᏗ ᎨᏒᎢ, Ꮎ-ᏍᎩ ᏍᎩᏯᎵᎪᏁᏗᏱ ᎤᏁᎳᏅᎯ ᎡᏓᏓᏙᎵᏍᏓᏁᎲ ᎠᏴ ᎨᏒ ᎤᎬᏩᎵ,


text:
ᎾᏍᎩ ᏤᏣᏓᏂᎸᎢᏍᏗᏱ ᎤᎬᏫᏳᎯ ᎨᏒ ᏅᏓᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩᏯ ᏥᏚᏳᎪᏗ ᎢᏳᎾᏛᏁᏗᏱ ᎤᎾᏓᏅᏘ, ᎠᎴ ᎾᏍᎩ ᎡᏥᏍᏕᎸᏗᏱ ᏂᎦᎥᏉ ᎪᎱᏍᏗ ᎡᏥᏍᏕᎸᏗᏱ ᎤᏚᎵᏍᎬᎢ; ᎾᏍᎩᏰᏃ ᎤᏂᏣᏘ ᏧᏍᏕᎸᏛ, ᎠᎴ ᎠᏴ ᎾᏍᏉ ᎠᎩᏍᏕᎸᏛ.


text:
ᎾᏍᎩ ᎠᏴ ᎬᏅ ᎠᏂᏍᏕᎵᏍᎬᎢ,ᎤᏅᏒ ᏗᏂᏴᏤᏂ ᎡᎳᏗ ᏚᏂᏅᏅ; ᎾᏍᎩ, ᎥᏝ ᎠᏋᏒᏉ ᏱᎦᏥᏯᎵᎡᎵᏤᎭ, ᎾᏍᏉᏍᎩᏂ ᏂᎦᏛ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ;


text:
ᎠᎴ ᎾᏍᏉ ᏕᏥᏲᎵᎸᎭ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎾᎿ ᎠᏂᏁᎸᎢ. ᎡᏥᏲᎵᎸᎭ ᎤᏣᏘ ᏥᎨᏳᎢ ᎢᏈᏂᏓ, ᎾᏍᎩ ᎢᎬᏱᏱ ᎤᎬᏛᎾᏨᎯ ᏥᏂᎦᎵᏍᏗᎭ ᎡᎦᏯ ᎦᎶᏁᏛ ᎠᎵᏍᎪᎸᏓᏁᏗ.


text:
ᎥᏠᏂᎦ ᎠᎴ ᏧᏂᏯ ᏕᏥᏲᎵᎸᎭ, ᎾᏍᎩ ᎪᎱᏍᏗ ᏗᏋᏅ, ᎠᎴ ᎢᏧᎳᎭ ᏦᎩᏴᎩᏅᎯ, ᎾᏍᎩ ᎨᏥᎸᏉᏗ ᏥᎩ ᎨᏥᏅᏏᏛ ᎠᏁᎲᎢ; ᎾᏍᎩ ᎾᏍᏉ ᎢᎬᏱ ᎦᎶᏁᏛ ᏧᎾᏁᎶᏗ ᎢᏳᎾᎵᏍᏔᏅᎯ ᎠᏴ ᎣᏂ.


text:
ᎠᎴ Ꮼ ᎢᏓᎵᏅᏟ, ᎢᏨᏍᏗᏰᏗᎭ ᏗᏣᎦᏌᏯᏍᏙᏗᏱ ᏗᎦᎴᏅᏗᏱ ᎠᎴ ᎤᏓᎿᏍᏆᎶᏍᏗᏱ ᎢᏯᏅᏁᎯ, ᏗᎦᏘᎸᏍᏗᏱ ᏗᏕᏲᏅᎯ ᎨᏒ ᏄᏍᏛ ᏄᏍᏛ ᎢᏣᏕᎶᏆᎥᎢ; ᎠᎴ ᏕᏣᏓᏅᎡᎮᏍᏗ.


text:
ᎾᏍᎩᏰᏃ ᎢᏳᎾᏍᏗ ᎥᏝ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵ ᏥᏌ ᎦᎶᏁᏛ ᎪᎱᏍᏗ ᏯᎾᏛᏁᎭ, ᎤᏅᏒᏉᏍᎩᏂ ᎤᏂᏍᏉᎵᏱ; ᎠᎴ ᎤᏬᏚᎯ ᎠᎴ ᎣᏍᏛ ᎦᏬᏂᎯᏍᏗ ᎨᏒ ᎠᏅᏗᏍᎬᎢ ᏓᏂᎶᏄᎮᏍᎪ ᏧᏂᎾᏫ ᎾᏁᏯᏔᎲᎾ.


text:
ᎢᏦᎯᏳᏒᏰᏃ ᏚᏃᏣᎶᏨ ᎾᏂᎥ ᏴᏫ ᎠᏁᎲᎢ. ᎾᏍᎩ ᎢᏳᏍᏗ ᎦᎵᎮᎵᎦ ᏂᎯ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᎭ; ᎠᏎᏍᎩᏂᏃᏅ ᎠᏆᏚᎵᎭ ᎢᏥᎦᏔᎾᎢ ᎢᏣᎵᏍᏙᏗᏱ ᎣᏍᏛ ᎨᏒ ᎤᎬᏩᎵ, ᎠᏃ ᎤᏲ ᎨᏒ ᎤᎬᏩᎵ ᏂᏥᎦᏔᎾᎥᎾ.


text:
ᎠᎴ ᎤᏁᎳᏅᎯ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏁᎯ ᏂᎪᎯᎸᎾᏉ ᏎᏓᏂ ᎤᏪᏓᏫᏙᏗ ᏅᏓᎦᎵᏍᏓᏂ ᏗᏣᎳᏏᏕᏂ ᎭᏫᏂᏗᏢ. ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎢᏤᎳᏗᏙᎮᏍᏗ. ᎡᎺᏅ.


text:
ᎾᏍᎩᏃ ᏰᎵᏉ ᏗᏣᎵᏂᎪᎯᏍᏙᏗ ᏥᎩ ᎾᏍᎩᏯ ᏂᎦᏪᏍᎬ ᎣᏍᏛ ᎧᏃᎮᏛ ᎠᏆᏤᎵᎦ, ᎠᎴ ᎾᏍᎩᏯ ᏥᏌ ᎦᎶᏁᏛ ᎠᎦᎵᏥᏙᏅᎢ, ᎾᏍᎩᏯ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ ᎨᏒ ᎤᏕᎵᏛ, ᎾᏍᎩ ᎡᎶᎯ ᏧᏓᎴᏅᎲ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎠᏕᎵᏍᏔᏅᎯ ᏥᎨᏎᎢ,


text:
ᎪᎯᏍᎩᏂ ᎿᏉ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ, ᎠᎴ ᎠᎾᏙᎴᎰᏍᏗ ᏧᏃᏪᎳᏅᎯ ᏗᎬᏔᏅᎯ ᎾᏍᎩᏯ ᎠᏓᏅᏖᏍᎬ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎡᎯ ᎡᏁᎳᏅᎯ ᎬᏂᎨᏒ ᎢᎨᎬᎸᎯ ᏂᎦᏗᏳ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᎤᏃᎯᏳᏏᏱ ᎤᎬᏩᎵ--


text:
ᏫᏨᏲᏪᎳᏏ ᏗᏣᏁᎶᏗ ᎢᏣᏓᏡᎬ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎪᎵᏂᏗᏱ ᏥᏣᏓᏡᎦ, ᎾᏍᎩ ᎢᏥᏍᎦᎾ ᏂᎨᏒᎾ ᎢᏰᏨᏁᎸᎯ ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ, ᎡᏥᏯᏅᏛ ᎢᏣᏓᏅᏘ, ᎠᎴ ᎾᏂᎥ ᏂᎦᎥ ᏕᎨᏌᏗᏒ ᏥᏌ ᎦᎶᏁᏛ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏚᏙᎥ ᎠᏂᏁᎢᏍᏗᏍᎩ, ᎾᏍᎩ ᎢᏧᎳᏉ ᎾᏍᎩ ᎤᎾᏤᎵᎦ ᎠᎴ ᎠᏴ ᎢᎦᏤᎵᎦ;


text:
ᎾᏍᎩᏃ ᎢᏓᎵᏅᏟ ᎢᏨᏔᏲᏎᎭ ᏚᏙᎥ ᎬᏗᎭ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎤᏠᏱᎭ ᎢᏥᏁᎢᏍᏗᏱ, ᎠᎴ ᏗᏣᎦᎴᏅᏗᏍᎩ ᏂᏤᎲᎾ ᎢᏳᎵᏍᏙᏗᏱ; ᎤᎧᎵᏨᏉᏍᎩᏂ ᏗᏣᏚᏙᏙᏗᏱ ᎤᏠᏱᏉ ᎢᏣᏓᏅᏖᎵᏙᎲᎢ, ᎠᎴ ᎤᏠᏱᏉ ᏕᏧᎪᏗᏍᎬᎢ.


text:
ᎦᎶᏁᏛᏰᏃ ᎥᏝ ᏱᎩᏅᏎ ᏗᏆᏓᏬᏍᏗᏱ, ᎠᏆᎵᏥᏙᏗᏱᏍᎩᏂ ᎣᏍᏛ ᎧᏃᎮᏛ; ᎥᏝ ᎠᎵᏏᎾᎯᏍᏗ ᎨᏒ ᎦᏬᏂᎯᏍᏗᏱ ᎠᏋ ᏙᏗᏱ, ᎦᎶᏁᏛᏰᏃ ᎤᏤᎵ ᏧᏓᎿᏩᏛ ᎠᏎᏉᏉ ᏱᏅᎦᎵᏍᏓ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎠᏏᎾᏌᏂᏳ ᎨᏒ ᏥᏄᏩᏂᏌᏁ ᎡᎶᎯ ᎠᏂᏏᎾᏌᏅ ᎠᏅᏗᏍᎬ ᎤᏁᎳᏅᎯ ᏂᎬᏩᎦᏔᎲᎾ ᏥᎨᏎᎢ, ᎤᏁᎳᏅᎯ ᏂᎬᏩᎦᏔᎲᎾ ᏥᎨᏎᎢ, ᎤᏁᎳᏅᎯ ᎣᏏ ᎤᏰᎸᏁ ᎠᎵᏍᎦᏁᏛ ᎠᎵᏥᏙᏗ ᎨᏒ ᎤᏮᏙᏗᏱ ᏧᏍᏕᎸᏗᏱ ᎠᏃᎯᏳᎲᏍᎩ.


text:
ᎢᏥᎪᏩᏗᎭᏰᏃ , ᎢᏓᎵᏅᏟ, ᏄᏍᏛ ᎡᏥᏯᏅᎲᎢ, ᎾᏍᎩ ᎥᏝ ᏳᏂᏣᏔ ᎠᏂᏏᎾᏌᏂ ᎤᏇᏓᎵ ᎤᎬᏩᎵ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᏳᏂᏣᏔ ᏧᎾᎵᏂᎩᏛ, ᎥᏝ ᎠᎴ ᏳᏂᏣᏔ ᎨᏥᎸᏉᏗ;


text:
ᎤᎾᎳᏅᎯᏍᎩᏂ ᏚᏑᏰᏒ ᎤᎾᎵᏍᎦᏂᏍᏛ ᎨᏥᏰᎸᎯ ᎠᏁ ᎡᎶᎯ, ᎾᏍᎩ ᏧᏕᎰᎯᏍᏙᏗᏱ ᎠᏂᎦᏔᎾᎢ; ᎠᎴ ᎤᏁᎳᏅᎯ ᏚᏑᏰᏒ ᎠᏂᏩᎾᎦᎳ ᎨᏥᏰᎸᎯ ᎠᏂ ᎡᎶᎯ, ᎾᏍᎩ ᏧᏕᎰᎯᏍᏙᏗᏱ ᏧᎾᎵᏂᎩᏛ;


text:
ᏂᎯᏍᎩᏂ ᎾᏍᎩ ᎢᏥᎾᏄᎪᏫᏒᎯ ᎢᎩ, ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎠᎴ ᏚᏳᎪᏛ ᎨᏒ ᎠᎴ ᎾᏍᎦᏅᎾ ᎢᎬᏁᏗ ᎨᏒ, ᎠᎴ ᎠᎫᏴᏙᏗ ᎨᏒ, ᎠᏴ ᎢᎬᏁᎸᎯ ᏥᎩ ᎤᏁᎳᏅᎯ;


text:
ᎠᎦᏙᎥᎯᏍᏗᏍᎩᏂᏃᏅ ᎨᏒ ᎣᏨᏗᏍᎪ ᎣᏥᏬᏂᎯ ᎪᎱᏍᏗ ᏄᏂᎷᎶᏤᎲᎾ; ᎥᏝ ᎠᏗᎾ ᎡᎶᎯ ᎤᏤᎵ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎡᎶᎯ ᎠᏁᎯ ᎤᎾᏤᎵᎦ, ᎾᏍᎩ ᎠᏎᏉᏉ ᎢᎦᎵᏍᏗᏍᎩ ᏥᎩ.


text:
ᎠᏴᏍᎩᏂ ᎣᏥᏬᏂᏍᎪ ᎣᏨᏗᏍᎪ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎤᏕᎵᏛ ᎨᏒᎢ, ᎾᏍᎩ ᎬᏍᎦᎵ, ᎾᏍᎩ ᎢᏳᎵᏍᏙᏗᏱ ᏥᏚᏭᎪᏔᏁ ᎤᏁᎳᏅᎯ ᎡᎶᎯ ᎠᏏ ᏂᎨᏒᎾ ᏥᎨᏎᎢ, ᏧᎬᏩᎴ ᎠᏴ ᎡᎩᎸᏉᏙᏗᏱ.


text:
ᎾᏍᎩᏯᏍᎩᏂ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᎩᎶ ᎤᎬᎲᎯ ᏂᎨᏒᎾ, ᎠᎴ ᎤᏛᎦᏅᎯ ᏂᎨᏒᎾ, ᎠᎴ ᏴᏫ ᎤᎾᏫᏱ ᎤᏴᎸᎯ ᏂᎨᏒᎾ, ᎾᏍᎩ ᏄᏍᏛ ᎤᏁᎳᏅᎯ ᏚᏛᏅᎢᏍᏓᏁᎸ ᎾᏍᎩ ᎬᏩᎨᏳᎯ.


text:
ᎦᎪᏰᏃ ᎢᏳᏍᏗ ᏴᏫ ᏧᏓᎴᏅᏛ ᏴᏫ ᏧᏤᎵᎦ ᎠᎦᏔᎭ? ᎤᏩᏒᏉᏍᎩᏂ ᏴᏫ ᎤᏓᏅᏙ ᎾᏍᎩ ᏧᏯᎠ. ᎾᏍᎩᏯ ᎾᏍᏉ ᏧᏌᎴᏅᏛ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ ᎥᏝ ᎩᎶ ᏯᎦᏔᎭ, ᎤᏁᎳᏅᎯ ᎤᏓᏅᏙ ᎤᏩᏒ.


text:
ᎾᏍᎩ ᎾᏍᏉ ᎣᏥᏃᎮᏍᎪᎢ, ᎥᏝ ᏲᏨᏗᏍᎪ ᎦᏬᏂᎯᏍᏗ ᏴᏫ ᎤᏤᎵ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᏧᏕᏲᏅᎯ, ᎦᎸᏉᏘᏳᏍᎩᏂ ᎠᏓᏅᏙ ᏧᏕᏲᏅᎯ; ᎠᏓᏅᏙ ᎤᎵᏍᎪᎸᏔᏅᎯ ᎬᏂᎨᏒ ᏂᏙᏨᏁᎰ ᎠᏓᏅᏙ ᎤᏁᎯ.


text:
ᏴᏫᏍᎩᏂ ᎤᏓᏁᏟᏴᏛ ᏂᎨᏒᎾ ᎨᏒ ᎥᏝ ᏱᏓᏓᏂᎸᎪ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏙ ᎤᎵᏍᎪᎸᏔᏅᎯ; ᎠᎵᏍᎦᏁᏛᏉᏰᏃ ᏚᏰᎸᏐᎢ; ᎥᏝ ᎠᎴ ᏗᎬᏬᎵᏍᏗ ᏱᎨᏐᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᎠᏓᏅᏙ ᎩᏛ ᏗᎬᎪᏩᏛᏗ ᎨᏒᎢ.


text:
ᎠᎴ ᎠᏴ, ᎢᏓᎵᏅᏟ, ᎥᏝ ᎠᏓᏅᏙ ᏧᎾᏘᏂᏙᎯ ᎾᏍᎩᏯ ᎨᏨᏬᏁᏙᏗ ᏱᎨᏎᎢ, ᎤᏇᏓᎵᏉᏍᎩᏂ ᏧᎾᏘᏂᏙᎯ ᎾᏍᎩᏯᎢ, ᎾᏍᎩᏯᏉ ᏧᎾᏍᏗ ᏗᏂᏲᎵ ᎦᎶᏁᏛ ᏚᎾᏚᏓᏛ ᎨᏒᎢ.


text:
ᎠᏏᏉᏰᏃ ᎤᏇᏓᎵ ᏕᏣᏘᏂᏙᎭ; ᎾᏍᎩᏰᏃ ᏥᏤᎭ ᎠᏛᏳᎨᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏗᏒᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎢᎸᏍᏗ ᎢᏯᏓᏗᏍᏗ ᎨᏒᎢ, ᏝᏍᎪ ᎤᏇᏓᎵ ᎢᏣᏘᏂᏙᎯ ᏱᎩ, ᎠᎴ ᏴᏫᏉ ᎤᏁᏓᏍᏗ ᎾᏍᎩᏯ ᏱᏣᏙᎭ?


text:
ᎾᏍᎩᏃ Ꮎ ᎠᏫᏍᎩ ᎠᎴ Ꮎ ᎠᎹ ᎠᏍᏚᏟᏍᎩ ᏌᏉᏉ ᎾᎾᎵᏍᏗᎭ; ᎠᎴ ᎾᏂᎥ ᎠᏂᏏᏴᏫᎭ ᎨᎦᎫᏴᎡᏗ ᎨᏎᏍᏗ ᎤᎾᏤᎵᎦᏯ ᎨᎦᎫᏴᏓᏁᏗ ᎨᏒ, ᎾᏍᎩᏯ ᏄᏍᏛ ᎤᏅᏒ ᏕᎤᏂᎸᏫᏍᏓᏁᎸᎢ.


text:
ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᏴ ᎥᎩᏁᎸᎢ, ᎾᏍᎩᏯ ᎠᏏᎾᏌᏂ ᏄᎬᏫᏳᏒ ᏗᏁᏍᎨᏍᏗ ᎢᏳᏛᏁᏗ ᎾᏆᏛᏁᎸ ᎦᎫᏍᏛᏗ ᎠᎩᏅ, ᏅᏩᏓᎴᏃ ᎾᎿ ᎤᏁᏍᎨᎲ. ᎠᏎᏃ ᎾᏂᎥ ᎩᎶ ᎠᏁᏯᏔᎮᏍᏗ ᏄᏍᏛ ᎠᎾᏁᏍᎨᏍᎬ ᎾᎿᏂ.


text:
ᎾᏍᎩᏍᎩᏂ ᎢᏳᏍᏗ ᏞᏍᏗ ᏗᏧᎪᏔᏅᎩ ᎠᏏᏉ ᏄᏍᏆᎸᎲᎾ, ᎬᏂ ᎤᎬᏫᏳᎯ ᎦᎷᏨᎭ, ᎾᏍᎩ ᎢᎦ ᎦᏛ ᏥᏙᏓᎦᏁᏄᎪᏫᏏ ᎤᎵᏏᎬ ᏗᎬᏍᎦᎵ ᏥᎩ, ᎠᎴ ᎬᏂᎨᏒ ᏂᏙᏓᎬᏁᎵ ᏧᏂᎾᏫᏱ ᏄᏍᏛ ᏕᎾᏓᏅᏖᎸᎢ; ᎿᏉᏃ ᎾᏂᎥ ᎨᏥᎸᏉᏙᏗ ᎨᏒ ᎤᏁᎳᏅᎯᏱ ᏅᏓᏳᏓᎴᏅᎯ ᎨᏎᏍᏗ.


text:
ᎠᎵ ᎾᏍᎩ ᎯᎠ ᏧᏓᎴᏅᏛ, ᎢᏓᎵᏅᏟ, ᏕᎦᏟᎶᏍᏗᏍᎬ ᎠᏋᏒ ᎦᏓᏁᎢᏍᏓ ᎠᎴ ᎠᏉᎳ ᏥᏁᎢᏍᏓ ᏂᎯ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᎭ; ᎾᏍᎩ ᏍᎩᏯᏕᎶᏆᎡᏗᏱ ᎢᏣᏓᏅᏖᏍᎬ ᎢᏥᎶᏒᏍᏙᏗᏱ ᏂᎨᏒᎾ ᏂᎬᏅ ᎪᏪᎸᎢ, ᎾᏍᎩ ᎩᎶ ᎤᏢᏈᏍᏗᏱ ᏂᎨᏒᎾ ᎠᏏᏴᏫ ᎦᎸᏉᏗᏍᎬ ᏅᏩᏓᎴᏃ ᎠᏡᏗᏍᎬᎢ.


text:
ᎣᎩᏁᎫ ᎠᏴ ᎦᎶᏁᏛ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᎭ, ᏂᎯᏍᎩᏂ ᎢᏥᎦᏔᎿᎢ ᎦᎶᏁᏛ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᎭ; ᏦᏥᏩᎾᎦᎳ ᎠᏴ, ᏂᎯᏍᎩᏂ ᏗᏣᎵᏂᎩᏗᏳ; ᎡᏥᎸᏉᏗᏳ ᏂᎯ, ᎠᏴᏍᎩᏂ ᎣᎩᏂᏆᏘᎯ.


text:
ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏥᏅᏒᎩ ᏗᎹᏗ ᎢᏥᏩᏛᎲᏍᏗᏱ, ᎾᏍᎩ ᏥᎨᏳᎢ ᏥᎩ ᎠᏇᏥ, ᎠᎴ ᏚᏳᎪᏛ ᎢᏯᏛᏁᎯ ᎤᎬᏫᏳᎯ ᏓᎧᎿᏩᏕᎬᎢ; ᎾᏍᎩ ᏓᏣᏅᏓᏗᏍᏔᏂ ᏄᏍᏛ ᎨᏙᎲ ᎦᎶᏁᏛ ᏕᏥᎦᎿᏩᏕᎬᎢ, ᎾᏍᎩᏯ ᏕᎦᏕᏲᎲᏍᎬ ᏂᎦᎥ ᏕᎨᏌᏗᏒ ᏚᎾᏓᏡᏩᏗᏒ ᏧᎾᏁᎶᏗ.


text:
ᏂᎦᎥᏉ ᎠᏂᏃᎮᎭ ᎾᏍᎩ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒ ᎢᏤᎲᎢ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒ ᎾᏍᎩ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎥᏝ ᎬᏩᏂᏃᎮᏗ ᎾᏍᏉ ᏱᎩ, ᎾᏍᎩ ᎩᎶ ᎤᏙᏓ ᎤᏓᎵᎢ ᎤᏓᏴᏍᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᎩᏍᏆᏂᎪᏕᏍᏗ ᏗᎵᏍᏓᏴᏗᏱ ᎨᏒᎢ, ᎥᏞᏍᏗ ᎤᏪᏘ ᎠᎪᏙᏗ ᎬᏗ, ᎠᎴ ᎥᏞᏍᏗ ᎤᏲ ᎠᎴ ᎠᏍᎦᏂ ᎨᏒ ᎠᎪᏙᏗ ᎬᏗ, ᏂᏓᎪᏔᏅᎾᏍᎩᏂ ᎦᏚ ᏄᏠᎾᏍᏛᎾ ᎨᏒ ᎠᎴ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎬᏗ.


text:
ᎥᏝ ᎠᏗᎾ ᎿᏉ ᎠᏎ <n>[ᎢᏤᏓᏍᏗᏱ ᏂᎨᏒᎾ]</n> ᎾᏍᏉ ᎡᎶᎯ ᏗᏂᎧᏩᏕᎩ ᎤᏕᎵᏛ ᏗᎾᏂᏏᎲᏍᎩ ᎠᎴ ᎤᏂᎬᎥᏍᎩ ᎤᏕᎵᏛ ᏗᎾᏂᏏᎲᏍᎩ ᎠᎴ ᎤᏂᎬᎥᏍᎩ, ᎠᎴ ᎤᎶᏒᏍᏗ ᎠᎾᏓᎩᎡᎯ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏟᎶᏍᏔᏅᎯ ᏗᎾᏓᏙᎵᏍᏓᏁᎯ; ᎢᏳᏰᏃ ᎾᏍᎩ ᏱᏄᏍᏗ, ᎠᏎ ᎢᏥᏄᎪᎢᏍᏗ ᏱᎩ ᎡᎶᎯ.


text:
ᎪᎯᏍᎩᏂ ᎢᏨᏲᏪᎳᏏ ᎢᏧᎳᎭ ᎢᏤᏓᏍᏗᏱ ᏂᎨᏒᎾ, ᎢᏳᏃ ᎩᎶ ᎠᎾᎵᏅᏟ ᎠᎪᏎᎯ ᏱᎩ ᎾᏍᎩ ᎤᏕᎵᏛ ᏗᏂᏏᎲᏍᎩ ᏱᎩ, ᎠᎴ ᎤᎬᎥᏍᎩ ᏱᎩ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏟᎶᏍᏔᏅᎯ ᎠᏓᏙᎵᏍᏏᏁᎯ ᏱᎩ, ᎠᎴ ᎠᏓᏐᎮᎯ, ᎠᎴ ᎤᏴᏍᏕᏍᎩ, ᎠᎴ ᎤᎶᏒᏍᏗ ᎠᏓᎩᎡᎯ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎥᏝᏍᏗ ᎾᏍᏉ ᎢᏧᎳᎭ ᏱᏣᎵᏍᏓᏴᏁᏍᏗ.


text:
ᎾᏍᎩ ᏥᏄᏍᏗ ᎬᏂᎨᏒᎢᏳ ᎤᏣᏘᏂ ᏂᏣᏛᏁᎲᎢ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎢᏨᏒᏉ ᏕᏣᏓᏰᎢᎵᏙᎲᎢ. ᎦᏙᏃ ᎤᏟ ᎣᏏᏳ ᏂᏥᏰᎸᏍᎬᎾ ᏥᎩ ᎤᏲ ᎢᏰᏨᏁᏗᏱ? ᎦᏙᏃ ᎤᏟ ᎣᏏᏳ ᏂᏥᏰᎸᏍᎬᎾ ᏥᎩ ᏧᎬᏩᎶᏗ ᎡᏥᎩᎡᏗᏱ?


text:
ᏝᏍᎪ ᏱᏥᎦᏔᎭ ᎾᏍᎩ ᏂᏚᏳᎪᏛᎾ ᎢᏯᎾᏛᏁᎯ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗ ᏂᎨᏒᎾ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ? ᏞᏍᏗ ᎢᏥᎵᏓᏍᏔᏅᎩ; ᎾᏍᏉ ᎤᏕᎵᏛ ᏗᎾᏂᏏᎲᏍᎩ, ᎠᎴ ᎤᎾᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎾᏓᏙᎵᏍᏓᏁᎯ, ᎠᎴ ᏗᎾᏓᏲᏁᎯ, ᎠᎴ ᎠᏂᏍᎦᏯ ᏗᎨᏥᏰᎩ, ᎠᎴ ᎠᏂᏍᎦᏯ ᎠᏂᏍᎦᏯᏉ ᏗᏂᏐᏢᏗᏍᎩ,


text:
ᎠᎵᏍᏓᏴᏗ ᎤᏍᏉᎵᏱ ᎤᎬᏩᎵ ᎪᏢᏅᎯ, ᎠᎴ ᎤᏍᏉᎵᏱ ᎠᎵᏍᏓᏴᏗ ᎤᎬᏩᎵ ᎪᏢᏅᎯ; ᎠᏎᏃ ᎤᏁᎳᏅᎯ ᏙᏛᏛᏔᏂ ᎢᏧᎳ ᎤᏍᏉᎵᎩ ᎠᎴ ᎠᎵᏍᏓᏴᏗ. ᎠᏰᎸᏃ ᎥᏝ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒ ᎤᎬᏩᎵ ᎪᏢᏅᎯ ᏱᎩ, ᎤᎬᏫᏳᎯᏍᎩᏂ ᎤᎬᏩᎵ ᎪᏢᏅᎯ; ᎠᎴ ᎤᎬᏫᏳᎯ ᎠᏰᎵ ᎤᎬᏩᎵ ᎠᎵᏍᎪᎸᏔᏅᎯ.


text:
ᏞᏍᏗ ᏗᏣᏓᎨᏳᏔᏅᎩ ᎢᏗᏣᏓᏛᏁᏗ ᎨᏒᎢ, ᏂᎬ ᎣᏏᏳ ᏗᏣᏓᏰᎸᎾᏁᎸᎯ ᏱᎩ ᏞᎦ ᎾᏍᎩ ᎢᏣᏛᏁᏗᏱ, ᎾᏍᎩ ᎢᏣᏜᏅᏓᏕᏗᏱ ᎠᎹᏟ ᎢᏨᏗᏱ ᎠᎴ ᎠᏓᏙᎵᏍᏙᏗ ᎨᏒ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ, ᎠᎴ ᏔᎵᏁᏉ ᏙᏣᏓᏩᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᏎᏓᏂ ᎢᏥᎪᎵᏰᏗᏱ ᏂᎨᏒᎾ ᎨᏣᎵᏍᏆᏂᎪᏙᏗ ᏂᎨᏒᎾ ᎨᏒ ᎢᏳᏍᏗ.


text:
ᎤᏟᏰᏃ ᎬᎩᏰᎸᎩ ᎾᏂᎥᏉ ᏴᏫ ᎠᏴ ᎾᏆᏍᏛ ᎾᏍᎩᏯ ᏱᏄᎾᏍᏗ. ᎠᏎᏃ ᎠᏂᏏᏴᏫᎭ ᎤᎾᏤᎵᎦᏯ ᎤᏁᎳᏅᎯ ᎤᏂᏁᎸ ᎤᏂᎰᎢ, ᎠᏏᏴᏫ ᎯᎠ ᎾᏍᎩ ᏂᎤᏍᏙᎢ, ᏅᏩᏓᎴᏃ ᏅᏩᏓᎴ ᏄᏍᏙᎢ.


text:
ᎠᏂᏐᎢᏍᎩᏂ ᎠᏴᏉ ᏕᏥᏁᏤᎭ ᎥᏝᏃ ᎤᎬᏫᏳᎯ; ᎢᏳᏃ ᎩᎶ ᎢᏓᎵᏅᏟ ᎤᏓᎵᎢ ᏴᏪᎧᎭ ᎪᎯᏳᎲᏍᎩ ᏂᎨᏒᎾ, ᎣᏏᏳᏃ ᏯᏪᎸᏍᎦ ᎠᏏᏉ ᎤᎾᏁᎳᏗᏍᏗᏱ, ᏞᏍᏗ ᎢᏴᏛ ᏱᎦᎧᎲᏍᎨᏍᏗ.


text:
ᏄᏬᎯᏳᏒᎾᏰᏃ ᎠᏍᎦᏯ ᎤᏓᏅᎦᎸᏛ ᎢᎩ ᎤᏓᎵᎢ ᎢᏳᏩᏂᏌᏛ, ᎠᎴ ᏄᏬᎯᏳᏒᎾ ᎠᎨᏴ ᎤᏓᏅᎦᎸᏛ ᎢᎩ ᎤᏰᎯ ᎢᏳᏩᏂᏌᏛ; ᎥᏝᏰᏃ ᎾᏍᎩ, ᎿᏉ ᏗᏤᏥ ᎠᏂᎦᏓᎭ ᏱᎩ; ᎠᏎᏃ ᎪᎯ ᎨᏒ ᎤᎾᏓᏅᎦᎸᏛ ᎢᎩ.


text:
ᎾᏍᎩᏯᏍᎩᏂ ᎤᏁᎳᏅᎯ ᎠᏂᏏᏴᏫᎭ ᏥᏚᏯᏙᎮᎸ, ᎠᎴ ᎾᏍᎩᏯ ᎤᎬᏫᏳᎯ ᎠᏂᏏᏴᏫᎭ ᏥᏚᏯᏅᎲ, ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᎠᏁᎮᏍᏗ. ᎠᎴ ᎾᏍᎩ ᏄᏍᏗ ᏕᏥᏁᏤᎭ ᏂᎦᏛ ᏚᎾᏓᏡᏩᏗᏒᎢ.


text:
ᎾᏃ ᏂᏓᎾᏤᎲᎾ ᎤᎬᏩᎵ ᎨᏒᎢ, ᎥᏝ ᎤᎬᏫᏳᎯ ᎤᏁᏨᎯ ᏯᎩᎭ; ᎠᏎᏃ ᎣᏏᏳ ᎬᏰᎸᏗ ᎨᏒ ᎬᏂᎨᏒ ᏂᎬᏁᎭ, ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᎠᎩᏙᎵᏨᎯ ᏥᎩ ᏚᏳᎪᏛ ᎢᎦᏛᏁᎯ ᎢᏯᏆᎵᏍᏙᏗᏱ.


text:
ᎢᏳᏍᎩᏂ ᏱᏣᏕᏒᎾ ᎥᏝ ᏱᎦᎯᏍᎦᏅᎦ; ᎢᏳ ᎠᎴ ᎠᏛ ᏱᏚᏤᏅ ᎥᏝ ᏱᎬᏍᎦᏅᎦ. ᎠᏎᏃ ᎾᏍᎩ ᎢᏳᎾᏍᏗ ᎤᏂᎩᎵᏲᎢᏍᏗ ᎨᏎᏍᏗ ᎤᏇᏓᎵ ᎨᏒᎢ. ᎠᏎᏃ ᎤᏁᎳᎩᏉ ᎢᏨᏰᎵᏎᎭ.


text:
ᏚᎾᏓᎴᎿᎠ ᎾᏍᏉ ᎠᏥᏰᎯ ᎠᎨᏴ ᎠᏃ ᎾᏥᏰᎲᎾ. ᎾᏥᏰᎲᎾ ᎠᎨᏴ ᎠᏓᏅᏖᏍᎪ ᏧᏓᎴᏅᏛ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎾᏍᎦᏅᎾ ᎢᏳᎵᏍᏙᏗᏱ ᎠᏰᎵ ᎨᏒ ᎠᎴ ᎤᏓᏅᏙᎩᎯ ᎨᏒᎢ; Ꮎ-ᏍᎩᏂ ᎠᏥᏰᎯ ᎠᏓᏅᏖᏍᎪ ᏧᏓᎴᏅᏛ ᎡᎶᎯ ᎡᎯ, ᎢᏳᏛᏁᏗᏱ ᎤᏰᎯ ᎣᏍᏛ ᎤᏰᎸᏗ ᏧᎸᏫᏍᏓᏁᏗᏱ.


text:
ᎠᎴ ᎯᎠ ᎾᏍᎩ ᏂᏥᏪᎭ ᎢᏨᏒ ᎣᏍᏛ ᎢᏣᎵᏍᏓᏁᏗ ᎠᏆᏑᎵᏍᎬᎢ; ᎥᏝ ᎢᏨᏌᏛᎥᏍᎬᏉ ᏱᎩ, ᎣᏏᏳᏍᎩᏂ ᎠᏰᎸᏗ ᎨᏒ <n>[ᎢᏣᏛᏁᏗᏱ, ]</n> ᎠᎴ ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᏤᏥᎧᎿᏩᏗᏓᏍᏗᏱ ᎪᎱᏍᏗ ᏂᏥᏲᏍᏙᏓᏁᎲᎾ.


text:
ᎢᏳᏍᎩᏂᏃᏅ ᎩᎶ ᎤᏣᏘᏂ ᎠᏰᎸᏗ ᏂᏥᏯᏛᏁᎭ ᎠᏆᏤᎵ ᎠᏛ ᎢᎡᎵᏍᎨᏍᏗ, ᎢᎦᎶᏍᎨᏍᏗ ᏰᎵᎦᏯ ᎢᏳᏕᏘᏴᏛ ᎨᏒᎢ, ᎠᎴ ᎠᏎ ᎾᏍᎩ ᎢᏳᎵᏍᏙᏗ ᎢᎨᏎᏍᏗ, ᎤᏚᎵᏍᎬᏉ ᎾᏛᏁᎮᏍᏗ, ᎥᏝ ᏱᎬᏍᎦᏅᎨᏍᏗ; ᏓᎾᏤᎨᏍᏗᏉ.


text:
ᎩᎶᏍᎩᏂ ᎤᎵᏂᎩᏛᏯ ᏚᏭᎪᏕᏍᏗ ᏧᏓᏅᏛᎢ, ᎠᏎ ᎾᏍᎩ ᎢᏳᏛᏁᏗᏱ ᏄᎵᏍᏓᏁᎲᎾ ᎢᎨᏎᏍᏗ, ᎾᏍᎩ ᏰᎵᏉ ᎠᏓᏅᏖᏍᎬ ᎢᎬᏩᏛᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏛᏁᏗᏱ ᏚᏭᎪᏔᏁᏍᏗ ᏧᏓᏅᏛᎢ, ᎾᏍᎩ ᎤᏍᏆᏂᎪᏙᏗᏱᏉ ᎤᏤᎵ ᎠᏛ, ᎾᏍᎩ ᎣᏏᏳ ᎾᏛᏁᎮᏍᏗ.


text:
ᎠᎨᏴ ᏗᏤᎯ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏚᏓᎸᏙ ᎤᏰᎯ ᎠᎴᏂᏙᎲ ᎢᎪᎯᏛ; ᎤᏰᎯᏍᎩᏂ ᎤᏲᎱᏒᎯ ᏱᎩ, ᎿᏉ ᎤᏚᏓᎴᏛ, ᎾᏍᎩᏃ ᏗᎬᏩᏨᏍᏗᏉ ᎩᎶᏉ ᎤᏚᎵᏍᎬᎢ; ᎤᎬᏫᏳᎯ ᎪᎩᏳᎲᏍᎩ ᎤᏩᏒ.


text:
ᎾᏃ ᏧᏓᎴᏅᏛ ᎾᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ ᎤᎬᏩᎵ, ᎢᏗᎦᏔᎭ ᎾᏍᎩ ᏂᏗᎥ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎢᎨᎲᎢ. ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎠᏢᏆᏍᎪᎢ, ᎠᏓᎨᏳᏗᏍᎩᏂ ᎨᏒ ᎠᏓᏍᏕᎵᏍᎪᎢ.


text:
ᎾᏃ ᎠᎩᏍᏗᏱ ᎤᎬᏩᎵ ᎪᎱᏍᏗ ᎠᏥᎸ ᎨᎳᏍᏗᏱ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ, ᎢᏗᎦᏔᎭ ᎤᏁᎳᏅᎯ ᎠᏰᎸᎯ ᎪᎱᏍᏗ ᏂᎨᏒᎾ ᎨᏒ ᎠᏂ ᎡᎶᎯ, ᎠᎴ ᎾᏍᎩ ᏅᏩᏓᎴ ᎤᏁᎳᏅᎯ ᏁᎲᎾ ᎨᏒ, ᏌᏉ ᎤᏩᏒ.


text:
ᎠᏴᏍᎩᏂ ᎢᏙᎯᏳᎲᏍᎬ ᏌᏉᎯᏳ ᎡᎭ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎠᎦᏴᎵᎨᎢ, ᎾᏍᎩ ᎾᎿ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᏨᏗᏓᎴᎲᏍᎦ, ᎠᎴ ᎠᏴ ᎾᏍᎩ ᎡᏓᏤᎵᎦ ᎢᏳᎵᏍᏙᏗᏱ ᏥᏕᎭ; ᎠᎴ ᏌᏉᎯᏳ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᏤᎭ, ᎠᎴ ᎠᏴ ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᏥᏕᎭ.


text:
ᎥᏝᏍᎩᏂᏃᏅ ᎾᏂᎥ ᎾᏍᎩ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᏳᏁᎭ; ᎩᎶᏰᏃ ᏙᏧᎾᏓᏅᏛ ᎤᏂᎸᏉᏗᏳ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᏰᎸᎯ ᎪᎯ ᎨᏒ ᎢᏯᏍᏗ ᎠᎾᎵᏍᏓᏴᏗᏍᎪ ᎤᏁᎳᏅᎯ ᎠᏰᎸᎯ ᎠᎵᏍᎪᎸᏓᏁᎸᎯ ᏣᏂᎩᏍᎪ ᎾᏍᎩᏯᎢ; ᏚᎾᏓᏅᏛᏃ ᏗᏩᎾᎦᎳᎯᏳ ᎨᏒ ᏗᎦᏓᎭ ᏂᏙᎦᎵᏍᏗᏍᎪᎢ.


text:
ᎢᏳᏰᏃ ᎩᎶ ᎢᏳᏍᏗ ᏱᏣᎪᎲ ᏂᎯ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᏤᎯ ᏱᏅᎦ ᏯᎵᏍᏓᏴᎲᏍᎦ ᎠᏓᏁᎸ ᎤᏁᎳᏅᎯ ᎠᏰᎸᎯ ᎤᏤᎵᎦ; ᏝᏍᎪ ᎾᏍᎩ Ꮎ ᎤᏓᏅᏛ, ᎠᏩᎾᎦᎳ ᎨᏒ, ᏂᎦᎾᏰᏍᎬᎾ ᏱᏅᎦᎵᏍᏓ ᎤᎵᏍᏓᏴᏙᏗᏱ ᏧᏓᎴᏅᏛ ᎾᏍᎩ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ;


text:
ᏝᏍᎪ ᎠᏴ ᎥᎩᏅᏏᏛ ᏱᎩ? ᏝᏍᎪ ᎠᏆᏓᏤᎵᎦ ᏱᎩ? ᏝᏍᎪ ᏥᎪᎥᎯ ᏱᎩ ᏥᏌ ᎦᎶᏁᏛ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ? ᏝᏍᎪ ᎠᏴ ᏓᎩᎸᏫᏍᏓᏁᎲ ᎢᏳᏩᏂᏌᏛ ᏱᎩ ᏂᎯ ᎤᎬᏫᏳᎯ ᎡᏥᏍᏓᏩᏕᎩ ᏥᎩ?


text:
ᎢᏳᏃ ᎥᎩᏅᏏᏛ ᎬᎩᏰᎸᏗ ᏂᎨᏒᎾ ᎢᎨᏎᏍᏗ ᏭᏅᏧᏛᎢ, ᏂᎯᏍᎩᏂ ᎠᏎ ᏄᏜᏏᏛᏒᎾ ᎥᎩᏅᏏᏛ ᏍᎩᏰᎸᏗ; ᏂᎯᏰᏃ ᎠᏙᎴᎰᎯᏍᏙᏗ ᎠᏴ ᎥᎩᏅᏏᏛ ᎨᏒ ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᎡᏥᏍᏓᏩᏕᎩ ᎨᏒᎢ.


text:
ᎦᎪ ᎢᎸᎯᏳ ᏓᎿᏩ ᎡᎪᎢ ᎤᏩᏒᏉ ᎤᎫᏴᎯᏓᏍᏗ ᎠᎫᏴᏗ ᎨᏒᎢ? ᎦᎪ ᏓᏫᏍᎪ ᏖᎸᎳᏗ ᏂᏗᎨᏰᏍᎬᎾᏃ ᎨᏐ ᎤᎾᏓᏛᏅᎯ? ᎠᎴ ᎦᎪ ᏓᎦᏘᏲ ᎠᏫ, ᎾᎵᏍᏓᏴᏗᏍᎬᎾᏃ ᎨᏐ ᎤᏅᏗ ᎠᏫ ᎤᏂᏁᏅᎯ?


text:
ᏥᎪᎨ ᎠᏴ Ꮀ ᎤᎬᏫᏳᎭ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎾᏍᎩ ᏥᏂᎦᏪᎭ? ᎥᏝ ᏳᏜᏏᏛᎭ ᎠᏴᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎾᏍᎩ ᏥᏂᎬᏅ ᏥᎪᏪᎳ; ᎩᎶᏰᏃ ᎦᏓᎷᎩᏍᎩ ᎾᏍᎩ ᎤᏚᎩ ᏳᏩᎭ ᎦᏓᎷᎩᏍᎬᎢ; ᎠᎴ ᎩᎶ ᎤᏚᎩ ᎤᏩᎯ ᎠᎦᏔᏙᎥᏗᏍᎩ ᎾᏍᎩ ᏳᏪᎳᏗᏍᏗᎭ ᎾᏍᎩ ᎤᏚᎩ ᎤᏩᏒᎢ


text:
ᎢᏳᏃ ᏅᏩᎾᏓᎴ ᎾᏍᎩ ᎯᎠ ᎢᎨᏨᏁᏗᏱ ᏳᏂᎭ; ᏝᏍᎪ ᎠᏴ ᎤᏟ ᎢᎦᎢ? ᎥᏝᏍᎩᏂᏃᏅ ᎾᏍᎩ ᎯᎠ ᎢᎦᏲᎦᏛᏁᏗ ᎣᎩᎲ ᏱᏃᎦᏛᏁᎸ; ᎤᏁᎳᎩᏉᏍᎩᏂ ᎣᎨᎵᏒ ᏂᎦᎥ ᏧᏓᎴᏅᏛ ᎣᎩᏂᎬᏎᎲᎢ, ᎾᏍᎩ ᎣᎦᎵᏫᏍᏙᏗᏱ ᏂᎨᏒᎾ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵ ᎠᎢᏒᎢ.


text:
ᏝᏍᎪ ᏱᏥᎦᏔᎭ, ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᏧᏂᎸᏫᏍᏓᏁᎯ ᎠᎾᎵᏍᏓᏴᏗᏍᎬ ᏗᎦᎸᏉᏗ ᎨᏒᎢ; ᎠᎴ ᎾᏍᎩ ᎠᏥᎸ ᎨᎳᏍᏗᏱ ᎠᏂᎦᏘᏯᏕᎩ ᎾᏍᎩ ᎤᏁᎳᏗᏍᏗᏍᎬ ᎠᏥᎸ ᎨᎳᏍᏗᏱ ᎠᎵᏍᎪᎸᏔᏅᎯ?


text:
ᎠᏎᏃ ᎥᏝ ᎪᎱᏍᏗ ᎠᏋᏔᏅᎯ ᏱᎩ ᎾᏍᎩ ᎯᎠ; ᎥᏝ ᎠᎴ ᎾᏍᎩ ᎯᎠ ᏱᎪᏪᎸᎦ, ᎠᏴ ᎾᏍᎩ ᎢᏴᏆᏛᏁᏗᏱ; ᎤᏟᏰᏃ ᎣᏏᏳ ᎢᏯᏆᎵᏍᏓᏁᏗ ᏯᎩᏲᎱᏒᏉ, ᎠᏃ ᎩᎶ ᎠᏎᏉ ᏱᏄᏩᏁᎸ ᎠᏆᏢᏆᏍᏙᏗ ᎨᏒᎢ.


text:
ᎾᏍᏉᏰᏃ ᏱᎦᎵᏥᏙᎲᏍᎦ ᎣᏍᏛ ᎧᏃᎮᏛ, ᎥᏝ ᎪᎱᏍᏗ ᏯᎩᎭ ᎠᏆᏢᏈᏍᏙᏗ. ᎠᏎᏰᏃ ᎾᏍᎩ ᎢᏯᏆᏛᏁᏗ ᏅᏋᏁᎸ; ᎥᎥ, ᎤᏲ ᎢᏯᏆᎵᏍᏓᏁᏗ, ᎢᏳᏃ ᎣᏍᏛ ᎧᏃᎮᏛ ᏂᎦᎵᏥᏙᎲᏍᎬᎾ ᎢᎨᏎᏍᏗ.


text:
ᎦᏙᏃ ᎥᏆᎫᏴᎡᏗ ᎨᏎᏍᏗ? ᎯᎠ ᎾᏍᎩ, ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎵᏥᏙᎲᏍᎨᏍᏗ ᏧᎬᏩᎶᏗ ᏂᎨᏒᎾ ᎢᏯᏋᏁᏗᏱ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ; ᎾᏍᎩ ᎤᏲ ᎢᏯᏆᏛᏁᏗᏱ ᏂᎨᏒᎾ ᏄᏍᏛ ᎠᏆᏒᎦᎸ ᎣᏍᏛ ᎧᏃᎮᏛ ᎨᏒᎢ.


text:
ᎠᏂᏧᏏ ᎠᏂᎦᏔᎲ ᏥᏧᏏ ᎾᏍᎩᏯ ᎾᏆᎵᏍᏔᏅᎩ ᎾᏍᎩ ᎠᏂᏧᏏ ᎬᎩᏁᏉᏤᏗᏱ; ᎾᏃ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎤᎾᏓᏄᏴᏗ ᎠᏂᎦᏔᎲ ᏗᎧᎿᏩᏛᏍᏗᏱ ᏣᏆᏓᏄᏴᏙ ᎾᏍᎩᏯᎢ, ᎾᏍᎩ ᎬᎩᏁᏉᏤᏗᏱ ᎾᏍᎩ Ꮎ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎤᎾᏓᏄᏴᏗ.


text:
ᎾᏍᎩ ᎠᏂᎦᏔᎲ ᏗᎧᎿᏩᏛᏍᏗᏱ ᏄᎾᏓᏄᏴᏛᎾ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎾᏆᏓᏄᏴᏛᎾ ᏥᎨᏐ ᎾᏍᎩᏯᎢ, ᎾᏍᎩ ᎬᎩᏁᏉᏤᏗᏱ ᎾᏍᎩ Ꮎ ᏗᎧᎿᏩᏛᏍᏗᏱ ᏄᎾᏓᏄᏴᏛᎾ, ᎠᏎᏃ ᎥᏝ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎾᏆᏓᏄᏴᏛᎾ ᏱᎩ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ, ᎠᏆᏓᏄᏴᏗᏍᎩᏂ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎦᎶᏁᏛ ᎠᎦᏔᎲᎢ.


text:
ᏗᏂᏩᎾᎦᎳ ᎠᏂᎦᏔᎲ, ᏥᏩᎾᎦᎳ ᎾᏍᎩᏯ ᎾᏆᎵᏍᏔᏅᎩ, ᎾᏍᎩ ᏗᏂᏩᎾᎦᎳ ᎬᎩᏁᏉᏤᏗᏱ; ᏂᎦᎥᏉ ᏄᏓᎴᏒ ᎾᏆᎵᏍᏔᏅ ᎾᏂᎥ ᏄᎾᏓᎴᏒ ᎠᏂᎦᏔᎲᎢ, ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎠᏎ ᎢᎦᏛ ᎦᏥᏍᏕᎸᏗᏱ.


text:
ᏝᏍᎪ ᏱᏥᎦᏔ ᎾᏍᎩ Ꮎ ᎠᎾᏙᎩᏯᏍᎩ, ᏂᎦᏛ ᎠᎾᏙᎩᏯᏍᎬᎢ, ᎠᏎᏃ ᎠᏏᏴᏫᏉ ᎤᏤᎵ ᏂᎭᎵᏍᏗᏍᎬ ᎠᏌᏍᏛᎢ? ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᎢᏣᏙᎩᏯᏍᎨᏍᏗ ᎾᏍᎩ ᎢᏣᏤᎵ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᏥᏰᎸᏍᎩᏂ ᎡᎳᏗ ᏂᏥᏴᏫᏕᎪᎢ, ᎠᎴ ᏥᎾᏝᎢ ᏂᏥᏴᏁᎰᎢ; ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᎾᏆᏚᎵᏍᎬᎾ ᎨᏒ ᎾᏍᎩ ᎦᏥᏯᎵᏥᏙᏁᎸᎯ ᎨᏒ ᏭᏅᎫᏛᎢ, ᎠᏴ ᎠᏋᏒ ᎥᎩᏐᏅᎢᏍᏔᏅᎯ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎠᎴ ᎾᏍᎩ ᏂᎦᏛ ᎤᏠᏱᏉ ᎠᏗᏔᏍᏗ ᎠᏓᏅᏙ ᎤᎵᏍᎪᎸᏔᏅᎯ ᎠᎾᏗᏔᏍᎬᎢ; ᎾᏍᎩᏰᏃ ᏅᏯ ᎠᏓᏅᏙ ᎤᏍᏚᎢᏛ, ᎾᏍᎩ ᏧᏂᏍᏓᏩᏗᏙᎮᎢ, ᎾᎿ ᎤᏄᎪᏨᎯ ᎠᎾᏗᏔᏍᎨᎢ; ᎠᎴ ᎾᏍᎩ Ꮎ ᏅᏯ ᎦᎶᏁᏛ ᎨᏒᎩ.


text:
ᏞᏍᏗ ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᏣᏓᏙᎵᏍᏓᏁᎯ ᏱᎨᏎᏍᏗ, ᎾᏍᎩᏯ ᎢᎦᏛ ᎾᏍᎩ Ꮎ ᏥᏄᎾᏍᏕᎢ; ᎾᏍᎩᏯ ᎯᎠ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᏴᏫ ᎤᎾᏅᏅᎩ ᏛᎾᎵᏍᏓᏴᏂᏒᎩ ᎠᎴ ᏛᎾᏗᏔᎯᏒᎩ, ᏚᎾᎴᏅᎩ ᎤᎾᏁᏦᏅᎩ.


text:
ᎥᏝ ᎪᎱᏍᏗ ᎤᏍᏗ ᎠᏓᎪᎵᏰᏍᎩ ᎢᏣᏢᏔᎲᎯ ᏱᎩ ᎾᏂᎥᏉ ᏴᏫ ᎢᎬᏩᎵᏍᏓᏁᏗ ᎤᏩᏒ; ᎠᎴ ᎤᏁᎳᏅᎯ ᏄᏓᎵᏓᏍᏛᎾ, ᎾᏍᎩ ᎥᏝ ᎤᏁᎳᎩ ᏴᎨᏤᎵᏏ ᎠᏓᎪᎵᏰᏍᎩ ᎢᏥᎷᏤᏗᏱ ᏕᏣᎵᏂᎬᎬ ᎤᎶᏒᏍᏙᏗᏱ; ᎾᏍᎩᏍᎩᏂ ᎠᏓᎪᎵᏰᏍᎩ ᎢᏥᎷᏤᎲ ᏔᎵ ᎾᏛᏕᏍᏗ ᎾᎿ ᎦᏰᏣᏗᏫᏎᏗ ᎨᏒᎢ, ᎾᏍᎩ ᏰᎵ ᎨᏣᏓᎵᏁᎯᏗᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎾᏍᎩ Ꮎ ᎦᎸᏉᏙᏗ ᎤᎵᏍᏈᏗ, ᎾᏍᎩ ᏥᏗᎸᏉᏗᏍᎪᎢ, ᏝᏍᎪ ᎾᏍᎩ ᎢᏓᎵᎪᎲᏍᎬ ᏱᎩ ᎦᎶᏁᏛ ᎤᎩᎬ ᎢᏓᏗᏔᏍᎬᎢ? ᎦᏚ ᏥᏗᎬᎭᎷᏯᏍᎪᎢ, ᏝᏍᎪ ᎾᏍᎩ ᎢᏓᎵᎪᎲᏍᎬ ᏱᎩ ᎦᎶᏁᏛ ᎠᏰᎸ ᎢᏓᎵᏍᏓᏴᏗᏍᎬᎢ?


text:
ᎯᎠᏍᎩᏂ ᏂᏥᏪᎭ, ᎾᏍᎩ Ꮎ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏥᎸ ᎨᎳᏍᏙᏗ ᏣᎾᎵᏍᎪᎸᏗᎪᎢ, ᎠᏂᏍᎩᎾ ᏓᎾᎵᏍᎪᎸᏔᏁᎰᎢ, ᎥᏝᏃ ᎤᏁᎳᏅᎯ; ᎥᏝᏃ ᏯᏆᏚᎵᎭ ᎠᏂᏍᎩᎾ ᎤᎾᏤᎵ ᎨᏒ ᎢᏤᎳᏗᏍᏙᏗᏱ.


text:
ᎥᏝ ᎨᏣᏗᏔᏍᏗ ᏱᎩ ᎠᏟᏍᏛ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ, ᎠᎴ ᎾᏍᏉ ᎠᏂᏍᎩᎾ ᎤᎾᏤᎵ ᎠᏟᏍᏛᎢ. ᎥᏝ ᎨᏣᎵᏍᏓᏴᏗ ᏱᎩ ᎤᎬᏫᏳᎯ ᎤᏪᏍᎩᎸ, ᎠᎴ ᎾᏍᏉ ᎠᏂᏍᎩᎾ ᎤᏂᏍᎩᎸᎢ.


text:
ᏄᏓᎴᏒᏉ ᎪᎱᏍᏗ ᎤᏁᎳᎩ ᎥᏇᎵᏎᎸᎯ ᎠᏆᎵᏍᏓᏴᏗᏱ, ᎠᏎᏃ ᎥᏝ ᏄᏓᎴᏒ ᎪᎱᏍᏗ ᎣᏏᏳ ᎢᏯᏓᏛᏁᎯ ᏱᎩ; ᏄᏌᎴᏒᏉ ᎪᎱᏍᏗ ᎤᏁᎳᎩ ᎥᏇᎵᏎᎸᎯ ᎠᏆᎵᏍᏓᏴᏙᏗᏱ, ᎠᏎᏃ ᎥᏝ ᏄᏓᎴᏒ ᎪᎱᏍᏗ ᎬᏩᏓᏍᏕᎸᏗ ᏱᎩ.


text:
ᎢᏳᏃ ᎩᎶ ᏄᏃᎯᏳᏒᎾ ᎨᏒ ᎢᎨᏣᏯᏂᏍᎨᏍᏗ, ᎠᎴ ᎢᏣᏚᎵᏍᎨᏍᏗ ᎢᏤᏅᏍᏗᏱ; ᏄᏍᏛᏉ ᎪᎱᏍᏗ ᎢᎬᏱᏗᏢ ᎡᏥᏝᏁᎲ ᎢᏣᎵᏍᏓᏴᏗᏍᎨᏍᏗ, ᎠᎴ ᏞᏍᏗ ᎪᎱᏍᏗ ᏱᏣᏛᏛᎲᏍᎨᏍᏗ, ᎠᎦᏅᏙᎩ ᎨᏒ ᏱᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ.


text:
ᎢᏳᏍᎩᏂ ᎩᎶ ᎯᎠ ᏂᏥᏪᏎᎮᏍᏗ, ᎯᎠ ᎾᏍᎩ ᎠᎵᏍᎪᎸᏔᏅᎯ ᎠᏥᎸ ᏗᎨᎴᏗ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ, ᏞᏍᏗ ᏱᏥᎩᏍᎨᏍᏗ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎾᏍᎩ Ꮎ ᎤᎾᏄᎪᏫᏒᎯ ᎨᏒᎢ, ᎠᎴ ᎠᏓᏅᏙᎩ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ; ᎡᎶᎯᏰᏃ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎡᎶᎯ ᏣᎧᎵᎢᎭ.


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏴ, ᏂᎦᎥ ᏂᎦᏛᏁᎲ ᎾᏂᎥᏉ ᎣᏍᏛ ᎤᏂᏰᎸᏗ ᏥᏂᎦᏥᏯᏛᏁᎰᎢ, ᎾᎩᏲᎲᎾ ᏥᎨᏐ ᎠᏋᏒᏉ ᎠᏆᎵᏍᏕᎩᏙᏗ,, ᎤᏂᏣᏘᏍᎩᏂ ᎤᎾᎵᏍᏕᎸᏙᏗ ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎨᏥᏍᏕᎸᏗᏱ.


text:
ᏝᏍᎪᏃ ᏱᏗᏥᏁᎸ ᎾᎿ ᎢᏔᎵᏍᏓᏴᏗᏱ ᎠᎴ ᎢᏔᏗᏔᏍᏗᏱ? ᏥᎪᎨ ᎢᏥᏐᏢᏗᎭ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎠᎴ ᏕᏣᏕᎰᎯᏍᏗᎭ ᏄᏂᎲᎾ? ᎦᏙ ᏓᏨᏲᏎᎵ? ᏓᏨᎸᏉᏔᏂᏧ? ᎯᎠ ᏂᏨᏛᏁᎲ ᎥᏝ ᏱᏨᎸᏉᏗᎭ.


text:
ᎾᏍᎩᏃ ᎤᎵᎮᎵᏨ, ᎤᎬᎭᎷᏰᎢ, ᎠᎴ ᎯᎠ ᏄᏪᏎᎢ, ᎢᏥᎩ, ᎢᏥᎦ; ᎯᎠ ᎾᏍᎩ ᎠᏴ ᏥᏰᎸᎢ, ᏂᎯ ᎾᏍᎩ ᎢᏣᎵᎬᎭᎷᏰᎸᎯ ᏥᎩ; ᎯᎠ ᎾᏍᎩ ᏂᏣᏛᏁᎮᏍᏗ ᎠᏴ ᏍᎩᏯᏅᏓᏗᏍᎬᎢ.


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᏄᏒᏁᎴ ᎤᎾᎵᏍᏓᏴᏃᏅ, ᎤᎵᏍᏈᏗ ᎤᎩᏎᎢ, ᎯᎠ ᏄᏪᏎᎢ; ᎯᎠ ᎾᏍᎩ ᎢᏤ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛᎢ, ᎠᏴ ᎠᎩᎩᎬ ᏨᏛᏍᏓᏱᏗ; ᎯᎠ ᎾᏍᎩ ᏂᏣᏛᏁᎮᏍᏗ, ᎢᏳᏍᏗᎭ ᎾᏍᎩ ᎢᏣᏗᏔᏍᎨᏍᏗ ᎠᏴ ᏍᎩᏯᏅᏓᏗᏍᎬᎢ.


text:
ᎩᎶᏰᏃ ᏂᏚᏳᎪᏛᎾ ᎾᏛᏁᎮᏍᏗ ᎠᎩᏍᎨᏍᏗ ᎠᎴ ᎠᏗᏔᏍᎨᏍᏗ, ᎾᏍᎩ ᎠᎩᏍᎨᏍᏗ ᎠᎴ ᎠᏗᏔᏍᎨᏍᏗ ᏧᏭᎪᏓᏁᎯ ᎤᏩᏛ ᎤᏍᎦᏅᏨᎢ, ᎾᎪᏩᏘᏍᎬᎾ ᎨᏒ ᎤᎬᏫᏳᎯ ᎠᏰᎸᎢ.


text:
ᎾᏍᎩᏃ ᎢᏳᎩᎶ ᎠᎪᎾ ᎤᏲᏏᏍᎨᏍᏗ, ᏧᏪᏅᏒ ᎠᎵᏍᏓᏴᎲᏍᎨᏍᏗ; ᎾᏍᎩ ᏕᏥᎳᏫᎩ ᎢᏥᏍᎦᏅᏨ ᏗᏧᎪᏓᏁᎯᏉ ᎢᏳᎵᏍᏙᏗᏱ ᏂᎨᏒᎾ. ᏭᏃᏒᏃ ᎣᏍᏛ ᏂᎬᏁᎸᎭ ᏫᏥᎷᏨᎭ.


text:
ᎾᏍᎩᏃ ᎢᏳᏍᏗ ᎢᏨᏃᎮᎮᎭ, ᎾᏍᎩ ᎩᎶ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏙ ᏱᎬᏗ ᏱᎦᏬᏂᎭ, ᏥᏌ ᎠᏥᏍᎩᏅᏛᎯ ᎥᏝ ᏰᎵ ᏴᎬᏛ; ᎥᏝ ᎠᎴ ᎩᎶ ᏥᏌ ᎤᎬᏫᏳᎯ ᏴᎬᏛ, ᎬᏂ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏱᎬᏗᎭ.


text:
ᏅᏩᏓᎴᏃ ᎤᏍᏆᏂᎪᏗ ᏧᎸᏫᏍᏓᏁᏗᏱ; ᏅᏩᏓᎴᏃ ᎤᏙᎴᎰᎯᏍᏗᏱ; ᏅᏩᏓᎴᏃ ᏗᏓᏅᏙ ᏄᎾᏍᏛ ᏧᎪᎵᏰᏗᏱ; ᏅᏩᏓᎴᏃ ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᏧᏬᏂᎯᏍᏗᏱ; ᏅᏩᏓᎴᏃ ᏧᏁᏢᏙᏗᏱ ᏧᏓᎴᏅᏛ ᏗᎦᏬᏂᎯᏍᏗ ᎨᏒᎢ;


text:
ᏌᏉᎯᏰᏃ ᎠᏓᏅᏙ ᎢᏳᏩᏂᏌᏛ ᏂᏗᎥ ᏤᎦᏬᎥᎯ ᏌᏉ ᎠᏰᎸ ᎢᏰᎬᏁᎸᎯ, ᎾᏍᏉ ᎢᏗᏧᏏ ᎠᎴ ᏗᎦᏓᎴᏅᏛ ᏴᏫ ᏱᎩ; ᎾᏍᏉ ᏤᎩᎾᏝᎢ ᎠᎴ ᏤᎩᎾᏝᎢ ᏂᎨᏒᎾ ᏱᎩ; ᎠᎴ ᏂᏗᎥ ᏌᏉᏉ ᎠᏓᏅᏙ ᎢᎦᏗᏔᏍᏗᏱ ᎢᏰᎬᏁᎸᎯ.


text:
ᎠᎴ ᎾᏍᎩ ᎠᏰᎸ ᏤᎯ ᎾᏍᎩ ᎡᏍᎦ ᎢᏴᏛ ᎢᏗᎦᎸᏉᏗ ᎢᎩᏰᎸᏒ, ᎾᏍᎩ ᎤᏟ ᎢᏗᎦᎸᏉᏗ ᏂᏕᏛᏁᎰᎢ; ᎠᎴ ᏄᏬᏚᏒᎾ ᎨᏒ ᏂᎦᏛᏅᎢ ᎾᏍᎩ ᎤᏟ ᎤᏬᏚᎯᏳ ᏂᎦᎵᏍᏗᏍᎪᎢ;


text:
ᎠᎴ ᎤᏁᎳᏅᎯ ᏕᎤᏪᎧᏅ ᎠᏂᏏᏴᏫᎭ ᎾᎿ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬᎢ; ᎢᎬᏱ ᎨᏒ, ᎨᏥᏅᏏᏛ; ᏔᎵᏁᏃ ᎨᏒ, ᎠᎾᏙᎴᎰᏍᎩ; ᏦᎢᏁᏃ ᎨᏒ, ᏗᎾᏕᏲᎲᏍᎩ; ᎣᏂᏃ, ᎤᏍᏆᏂᎪᏗ ᏧᏂᎸᏫᏍᏓᏁᎯ; ᎿᏉᏃ ᎨᎦᎵᏍᎪᎸᏓᏁᎸᎯ ᏧᎾᏓᏅᏬᏗᏱ, ᎠᎾᎵᏍᏕᎵᏍᎩ, ᏄᏂᎬᏫᏳᏌᏕᎩ, ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᏗᏂᏬᏂᏍᎩ.


text:
ᎠᎴ ᎾᏍᎩ ᏯᎩᎭ ᎠᏆᏙᎴᎰᎯᏍᏗᏱ, ᎠᎴ ᏱᎪᎵᎦ ᏂᎦᏗᏳ ᎤᏕᎵᏛ ᎨᏒᎢ, ᎠᎴ ᏂᎦᏗᏳ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒᎢ; ᎠᎴ ᏂᎦᎥ ᎪᎯᏳᏗ ᎨᏒ ᏯᎩᎭ, ᎾᏍᎩ ᏰᎵᏉ ᏗᎬᎩᎲᏍᏗ ᏱᎩ ᏙᏓᎸᎢ; ᎠᏓᎨᏳᏗᏃ ᎨᏒ ᎾᎩᎲᎾ ᏱᎩ, ᎪᎱᏍᏗᏉ ᏂᎨᏒᎾ ᎠᏴ.


text:
ᏥᏲᎵ ᏥᎨᏒᎩ ᎠᏲᎵ ᎤᏬᏂᎯᏍᏗ ᏥᏬᏂᏍᎬᎩ, ᎠᏲᎵ ᎤᏬᎵᏍᏗ ᎨᏒ ᎪᎵᎬᎩ, ᎠᏲᎵ ᎤᏓᏅᏖᏗ ᎨᏒ ᎦᏓᏅᏖᏍᎬᎩ; ᎠᏆᏛᏅᏍᎩᏂ ᎿᏉ ᎾᏆᎵᏍᏔᏅ, ᎠᏲᎵ ᏧᏤᎵ ᎨᏒ ᎢᏴᏛ ᏂᏓᏋᏁᎸᎩ.


text:
ᎪᎯᏰᏃ ᎨᏒ ᎤᏍᎪᎸ ᎢᏗᎪᏩᏗᎭ ᎠᏓᎨᏗᏱ; ᎾᎯᏳᏍᎩᏂ ᎨᏎᏍᏗ ᏕᎦᎧᏛ ᏙᏓᏓᏓᎪᎯ; ᎪᎯ ᎨᏒ ᎢᎦᏛᏉ ᏥᎦᏔᎭ; ᎾᎯᏳᏍᎩᏂ ᎨᏎᏍᏗ ᏥᎦᏔᎮᏍᏗ ᎾᏍᎩᏯ ᎾᏍᏉ ᎥᎩᎦᏔᎲᎢ.


text:
ᎩᎶᏰᏃ ᏱᎦᏬᏂᎭ ᏅᏩᎾᏓᎴ ᎤᏂᏬᏂᎯᏍᏗ ᎨᏒᎢ, ᎥᏝ ᏴᏫ ᏱᏗᎦᏬᏁᏗᏍᎪᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ; ᎥᏝᏰᏃ ᎩᎶ ᏳᏬᎵᏤᎰᎢ; ᎠᏓᏅᏙᏍᎩᏂᏃᏅ ᎬᏗ ᎦᏬᏂᏍᎬ ᎤᏕᎵᏛ ᎦᎾᎸᎪᏫᏍᎪᎢ.


text:
ᎣᏏᏳ ᏱᏥᏰᎸᎾ ᎢᏳᏃ ᏂᏥᎥ ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᏱᏗᏥᏬᏂᎭ; ᎠᏎᏃ ᎰᎤᎬᏫᏳᎭ ᏱᏣᏙᎴᎰᏍᎦ; ᎤᏟᏰᏃ ᎠᏥᎸᏉᏗᏳ ᎾᏍᎩ Ꮎ ᎠᏙᎴᎰᏍᎩ, ᎡᏍᎦᏉ ᎾᏍᎩ Ꮎ ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᏗᎦᏬᏂᏍᎩ, ᎢᏳᏍᎩᏂᏃᏅ ᏯᏁᏢᏗᎭ, ᎾᏍᎩ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏧᎾᎵᏂ ᎪᎯᏍᏗᏱ.


text:
ᎢᏳᏃ, ᎢᏓᎵᏅᏟ, ᏱᏂᏨᎷᏤᎸ ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᏱᏗᏥᏬᏂᎭ, ᎦᏙ ᎤᏍᏗ ᏱᏨᏁᏉᏏ, ᎢᏳᏍᎩᏂᏃᏅ ᎢᏨᏬᏁᏗᏍᎬ ᎪᎱᏍᏗ ᏱᏨᎾᏄᎪᏫᏎᎭ, ᎠᎴ ᎢᏥᎦᏙᎥᎯᏍᏗᏱ ᏱᏂᏨᏴᏁᎭ, ᎠᎴ ᏱᎦᏙᎴᎰᏍᎦ, ᎠᎴ ᏱᏗᎦᏕᏲᎲᏍᎦ.


text:
ᎾᏍᏉᏰᏃ ᎪᎱᏍᏗᏉ ᎬᏃᏛ ᏂᎨᏒᎾ, ᏳᏃᏴᎦ, ᎠᏤᎷᎯᏍᏗ ᎠᎴ ᏗᎧᏃᎩᏍᏙᏗ ᏱᎩ, ᎢᏳᏃ ᏧᏓᎴᎿᎢ ᏂᏚᏃᏴᎬᎾ ᏱᎩ, ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᏴᏙᎴᎰᎯ ᎾᏍᎩ ᎠᏤᎷᎯᏛ ᎨᏒ ᎠᎴ ᎾᏍᎩ ᏗᎧᏃᎩᏛ ᎨᏒᎢ?


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᏂᎯ, ᎢᏳᏃ ᏗᏥᏃᎪ ᏗᎬᏗ ᎦᎪᎵᏍᏗ ᏂᏥᏬᏂᏍᎬᎾ ᏱᎩ, ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᎬᏙᎴᎰᎯᏍᏗ ᏱᎩ, ᏂᏥᏪᏒ ᎢᏥᏬᏂᏒᎢ? ᎦᏃᎴᏍᎬᏰᏃ ᎢᏥᏬᏁᏗᏍᎩ ᎨᏎᏍᏗ.


text:
ᎦᏙ ᎰᏩ ᎤᏍᏗ? ᎠᏆᏓᏅᏙ ᎬᏗᏍᎨᏍᏗ ᎦᏓᏙᎵᏍᏗᏍᎨᏍᏗ, ᎠᎴ ᎦᎪᎵᏍᏗ ᎦᏓᏙᎵᏍᏗᏍᎨᏍᏗ; ᎠᎴ ᎠᏆᏓᏅᏙ ᎬᏗᏍᎨᏍᏗ ᏕᏥᏃᎩᏍᎨᏍᏗ ᎠᎴ ᎦᎪᎵᏍᏗ ᏕᏥᏃᎩᏍᎨᏍᏗ.


text:
ᎾᏍᎩᏰᏃ ᏄᏍᏛ ᏱᎩ, ᎿᏉ ᎭᎵᎮᎵᏨ ᏣᏓᏅᏙ ᎲᏔᏅᎭ, ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᎾᏍᎩ Ꮎ ᎾᎦᏔᎾᎥᎾ ᎤᏪᏗᏱ ᏳᏬᎳ, ᏰᎵ ᎡᎺᏅ ᏯᏛ ᎭᎵᎮᎵᎩ? ᏂᎪᎵᎬᎾᏰᏃ ᏱᎩ ᏂᏪᏍᎬᎢ.


text:
ᎠᏎᏃ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎤᏟ ᎬᎩᏰᎸᏗ ᎾᎿ ᎯᏍᎩᏉ ᎢᎧᏁᏨᎯ ᎠᎩᏁᎢᏍᏗᏱ ᎠᏆᏓᏅᏛ ᎠᏆᏙᏗᏱ, ᎾᏍᎩ ᏅᏩᎾᏓᎴ ᎾᏍᏉ ᎦᏥᏰᏲᏗᏱ, ᎠᏃ ᎠᏍᎪᎯ ᎢᏯᎦᏴᎵ ᎢᎧᏁᏨᎯ ᎠᎩᏁᎢᏍᏗᏱ ᏅᏩᎾᏓᎴ ᎤᏂᏬᏂᎯᏍᏗ ᎨᏒ ᎠᏆᏙᏗᏱ.


text:
ᏗᎧᎿᏩᏛᏍᏗᏱ ᎯᎠ ᏂᎬᏅ ᎪᏪᎳ, ᏅᏩᏓᎴ ᏗᏂᏬᏂᏍᎩ ᎠᎴ ᏅᏩᏓᎴ ᏧᏂᎭᏁᎦᎵ ᏓᎦᏥᏴᏔᏂ ᎦᏓᏥᏬᏁᏔᏂ ᎯᎠ ᎾᏍᎩ ᏴᏫ; ᎠᏎᏃ ᎠᏏ ᎥᏝ ᏱᎬᏆᏛᎦᏁᎮᏍᏗ, ᎠᏗᎭ ᏱᎰᏩ.


text:
ᎾᏍᎩᏃ ᏧᏓᎴᏅᏛ ᏗᎦᏬᏂᎯᏍᏗ ᎨᏒ ᎪᎯᏳᏗᏍᎩ ᎠᏰᎸᎭ, ᎥᏝ ᎠᏃᎯᏳᎲᏍᎩ ᎤᏃᎯᏳᏓᏁᎯ ᏱᎩ, ᎠᏍᎩᏂ ᎠᏃᎯᏳᎲᏍᎩ ᏂᎨᏒᎾ; ᎠᏙᎴᎰᎯᏍᏗ <n>[ᎤᏃᎯᏳᏓᏁᎯ]</n> ᏱᎩ, ᎠᏃᎯᏳᎲᏍᎩᏍᎩᏂ.


text:
ᎾᏍᎩᏃ ᏥᏄᏍᏗ ᎢᏳᏃ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏂᎦᏛ ᎢᎸᎯᏢ ᏱᏚᏂᎳᏫᏦᏅ, ᎠᎴ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᏗᎦᏬᏂᎯᏍᏗ ᎨᏒ ᏱᏓᏂᏬᏂᎭ, ᏳᏂᏴᎵᎸᏃ ᎾᎿᏂ ᎾᏂᎦᏔᎾᎥᎾ, ᎠᎴ ᎠᏃᎯᏳᎲᏍᎩᏂ ᏂᎨᏒᎾ, ᏝᏍᎪ ᏚᏂᎸᏃᏘᎭ ᏴᎬᎾᏛ?


text:
ᎦᏙ ᎰᏩ ᎤᏍᏗ, ᎢᏓᎵᏅᏟ? ᎢᏳᏃ ᏕᏥᎳᏫᎩ, ᎢᏥᏏᏴᏫᎭ ᏗᎧᏃᎩᏛ ᎢᏣᏛᏅᎢᏍᏙᎢ, ᏗᏕᏲᏗ ᎢᏣᏛᏅᎢᏍᏙᎢ, ᏧᏓᎴᏅᏛ ᏗᎦᏬᏂᎯᏍᏗ ᎢᏣᏛᏅᎢᏍᏙᎢ, ᎬᏂᎨᏒ ᎢᎬᏁᏗ ᎢᏣᏛᏅᎢᏍᏙᎢ, ᎠᏁᏢᏙᏗ ᎢᏣᏛᏅᎢᏍᏙᎢ. ᏂᎦᏛ ᎠᏗᎾ ᏕᏥᎸᏫᏍᏓᏁᎲ ᏗᏣᏓᎵᏂᎪᎯᏍᏙᏗᏱ ᎤᎬᏩᎴᏍᏗ.


text:
ᎠᏂᎨᏴ ᏗᏣᏤᎵ ᎡᎳᏪᏉ ᎤᏅᏎᏍᏗ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒᎢ; ᎥᏝᏰᏃ ᎨᎦᎵᏍᎪᎸᏓᏁᎸᎯ ᏱᎩ ᎾᏍᎩ ᎤᏂᏬᏂᎯᏍᏗᏱ; ᎤᏃᎯᏳᏗᏱᏉᏍᎩᏂ, ᎾᏍᎩᏯ ᎾᏍᏉ ᏥᏂᎦᏪ ᏗᎧᎿᏩᏛᏍᏗ.


text:
ᎠᏎᏃ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᎢᏳᏩᏂᏌᏛ ᎠᏴ ᎾᏆᏍᏛ ᎾᏆᏍᏗ; ᎠᎴ ᎾᏍᎩ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎥᎩᏁᎸᎯ ᏥᎩ, ᎥᏝ ᎠᏎᏉᏉ ᏱᏄᎵᏍᏔᏅ; ᎤᏟᏰᏃ ᎢᎦᎢ ᏓᎩᎸᏫᏍᏓᏁᎲ ᎡᏍᎦᏉ ᎾᏍᎩ Ꮎ ᎾᏂᎥᎢ; ᎥᏝ ᏍᎩᏂᏃᏅ ᎠᏴ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏗᎩᎧᎿ ᏩᏗᏙᎸᎯ.


text:
ᎠᎴ ᎾᏍᏉ ᎬᏂᎨᏒ ᏂᎦᎵᏍᏗᎭ ᎦᏰᎪᎩ ᎣᏥᏃᎮᏍᎩ ᎨᏒ ᎤᏁᎳᏅᎯ; ᎣᏥᏃᎮᎸᏰᏃ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎤᏲᎱᏒ ᏕᎤᎴᏔᏅ ᎦᎶᏁᏛ; ᏧᎴᎳᏅᎯ ᏂᎨᏒᎾ ᏥᎩ, ᎢᏳᏃ ᎰᏩ ᏧᎾᎴᎯᏐᏗ ᏂᎨᏒᎾ ᏱᎩ ᏧᏂᏲᎱᏒᎯ.


text:
ᎿᏉ ᏛᎵᏍᏆᏗ, ᎾᎯᏳ ᎤᎬᏫᏳᎯ ᎨᏒ ᏧᏲᎯᏎᎸᎯ ᎨᏎᏍᏗ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎠᎦᏴᎵᎨᎢ; ᎾᎯᏳ ᎠᏛᏔᏃᏅᎭ ᏂᎦᏗᏳ ᎤᏂᎬᏫᏳᏌᏕᎩ ᎨᏒ ᎠᎴ ᏂᎦᏗᏳ ᏗᎨᎦᏁᎶᏗ ᎨᏒ, ᎠᎴ ᏚᎾᎵᏂᎬᎬᎢ.


text:
ᏂᎦᏗᏳᏰᏃ ᏧᏓᎴᏅᏛ ᏚᎳᏍᎬ ᎭᏫᏂᏗᏢ ᎢᎬᏁᎸᎯ. ᎠᏎᏃ, ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎭᏫᏂᏗᏢ ᎢᏯᎬᏁᎸᎯ ᏣᏗᎭ,, ᎬᏂᎨᏒ ᏂᎦᎵᏍᏗᎭ ᎾᎦᏠᏯᏍᏛᎾ ᎨᏒ ᎾᏍᎩ Ꮎ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᎭᏫᏂᏗᏢ ᎢᏳᏩᏁᎸᎯ.


text:
ᎾᎯᏳᏃ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎭᏫᏂᏗᏢ ᎢᏯᎬᏁᎸᎯ ᎨᏎᏍᏗ, ᎿᏉ ᎾᏍᏉ ᎤᏪᏥ ᎤᏩᏒ ᎭᏫᏂᏗᏢ ᏅᏛᏛᏁᎵ ᎾᏍᎩ Ꮎ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᎯᏫᏂᏗᏢ ᎢᏳᏩᏁᎸᎯ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᏂᎦᎥ ᎢᎬᏂᏏᏍᎩ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏂᎥ ᎠᏁᎲᎢ.


text:
ᎢᏳᏃ ᎾᏍᎩ ᏄᏍᏛᎾ ᏱᎩ, ᎦᏙ ᏛᎾᏛᏁᎵ ᏧᏂᏲᎱᏒᎯ ᏥᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᏥᏕᎨᎦᏬᏍᎪᎢ? ᎢᏳᏃ ᏧᏂᏲᎱᏒᎯ ᎠᏎ ᏧᎾᎴᎯᏐᏗ ᏂᎨᏒᎾ ᎢᎨᏎᏍᏗ, ᎦᏙᏃ ᏧᏂᏲᎱᏒᎯ ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᏙᎨᎦᏬᏍᎪᎢ?


text:
ᎢᏳᏃ ᏴᏫ ᎢᏳᎾᏛᏁᏗ ᎢᏯᏆᏛᏁᎸᎯ ᏱᎩ, ᏅᎩ ᏗᏂᏅᏌᏗ ᎤᏂᏍᎦᏎᏗ ᎣᎦᎵᎸᎯ ᏱᎩ ᎡᏈᏌ ᎦᏚᎲᎢ, ᎦᏙ ᎬᎩᏁᏉᏤᏗ ᎣᏍᏛ ᎨᏒ, ᎢᏳᏃ ᏧᏂᏲᎱᏒᎯ ᏧᎾᎴᎯᏐᏗ ᏂᎨᏒᎾ ᏱᎩ? ᎢᏓᎵᏍᏓᏴᎲᏍᎨᏍᏗ, ᎠᎴ ᎢᏓᏗᏔᏍᎨᏍᏗ; ᏑᎾᎴᏉᏰᏃ ᏙᏓᏗᏲᎱᏏ.


text:
ᏅᏙ ᎢᎦ ᎡᎯ ᎤᏤᎵᏛ ᎤᏬᏚᎯᏳ ᎨᏒᎢ, ᎠᎴ ᎤᏬᏚᎯᏳ ᎨᏒ ᏅᏙ ᏒᏃᏱ ᎡᎯ ᏅᏩᏓᎴᎢ, ᎠᎴ ᏧᏃᏚᎯᏳ ᎨᏒ ᏃᏈᏏ ᏅᏩᏓᎴᎢ; ᎠᎴ ᏃᏈᏏ ᎧᎸ ᎤᏬᏚᎯᏳ ᎨᏒ ᏅᏩᏓᎴ ᏄᏍᏙ ᏃᏈᏏ ᏄᏍᏛ ᎤᏬᏚᎯᏳ ᎨᏒᎢ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏂᏥᏪᎭ ᎢᏓᎵᏅᏟ, ᎾᏍᎩ ᎤᏇᏓᎵ ᎨᏒ ᎠᎴ ᎩᎬ ᎥᏝ ᎤᎾᏤᎵ ᎢᎬᏩᎵᏍᏙᏗ ᏱᎩ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ; ᎥᏝ ᎠᎴ ᎠᏲᎩ ᎨᏒ ᎤᏤᎵ ᎢᎬᏩᎵᏍᏙᏗ ᏱᎩ ᎠᏲᎯ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎩᎳᏉ ᎢᏴᏛ, ᏥᏛᎦᏔᎾᏫᏍᏗᏉ ᎢᎪᎯᏛ, ᎤᎵᏍᏆᎸᏗ ᎠᏤᎷᎩ ᏂᎦᎵᏍᏔᏅᎭ; ᎠᏤᎷᎩᏰᏃ ᏓᏳᏃᏴᎳᏏ, ᏧᏂᏲᎱᏒᎯᏃ ᏙᏓᎨᎦᎴᏔᏂ ᎠᏂᏲᎩ ᏁᎨᏒᎾ, ᎠᏴᏃ ᏓᏰᎩᏁᏟᏴᏏ.


text:
ᎾᏍᎩᏃ ᎿᏉ ᎯᎠ ᎠᏲᎩ ᎨᏒ ᎠᏲᎩ ᏂᎨᏒᎾ ᎨᏒ ᎤᏄᏬᏍᏔᏁᏍᏗ, ᎠᎴ ᎯᎠ ᎾᏍᎩ ᎠᏲᎱᏍᎩ ᎠᏲᎱᏍᎩ ᏂᎨᏒᎾ ᎨᏒ ᎤᏄᏬᏍᏔᏁᏍᏗ, ᎿᏉ ᏄᎵᏍᏔᏁᏍᏗ ᎯᎠ ᎢᎦᏪᏛ ᎨᏒ ᏥᎪᏪᎳ, ᎠᏓᎵᏁᎯᏗᏍᎩ ᎨᏒ ᎤᎩᏐᏅ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎢᏨᎨᏳᎢ ᎢᏓᎵᏅᏟ, ᏗᏣᎵᏂᎩᏗᏳ ᎨᏎᏍᏗ, ᎦᏰᏥᏖᎸᏗ ᏂᎨᏒᎾ ᎨᏎᏍᏗ, ᏂᎪᎯᎸ ᎤᏣᏘ ᏕᏥᎸᏫᏍᏓᏁᎮᏍᏗ ᎤᎬᏫᏳᎯ ᎤᏤᎵ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎢᏥᎦᏔᎭᏰᏃ ᎾᏍᎩ ᎢᏣᎵᏂᎬᏁᎲ ᎤᎬᏫᏳᎯ ᎤᏤᎵ ᏕᏥᎸᏫᏍᏓᏁᎲ ᎠᏎᏉᏉ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒ ᎡᏏᏱ ᏫᎨᏥᏲᎵᎭ. ᎡᏈᎳ ᎠᎴ ᏈᏏᎳ ᎤᏣᏘ ᏫᎨᏥᏲᎵᎭ ᎤᎬᏫᏳᎯ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏲᎵᏍᏗ ᎨᏒᎢ, ᎬᏩᎾᎵᎪᏁᎭ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎾᏍᎩ ᎠᏂᏁᎸᎢ.


text:
ᏉᎳ, ᏥᏌ ᎦᎶᏁᏛ ᎠᎩᏅᏏᏛ ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏖᎸᎢ, ᎠᎴ ᏗᎹᏗ ᎢᎩᏅᏟ. ᏫᏨᏲᏪᎳᏏ ᏗᏣᏁᎶᏗ ᎢᏣᏓᏡᎬ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎪᎵᏂᏗᏱ ᏥᏣᏓᏡᎬ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎪᎵᏂᏗᏱ ᏥᏣᏓᏡᎬ, ᎠᎴ ᏂᎦᏛ ᎢᏣᏓᏅᏘ ᏂᎬᎾᏛ ᎠᎦᏯ ᎢᏤᎲᎢ;


text:
ᎾᏍᎩ ᎣᎩᎦᎵᏍᏓᏗᏍᎩ ᏥᎩ ᏂᎦᎥ ᎫᏓᎴᏅᏛ ᎣᏥᎩᎵᏲᎬᎢ, ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᏰᎵ ᏗᎦᏲᏥᎵᏍᏓᏗᏍᏗ ᎠᏂᎩᎵᏲᎩ, ᎦᏲᎬᏙᏗ ᎾᏍᎩ ᎠᏓᎦᎵᏍᏓᏗᏍᎩ ᎣᎬᏒ ᎣᎩᎦᎵᏍᏓᏗᏍᏗᏍᎬ ᎤᏁᎳᏅᎯ.


text:
ᎢᏳ ᎠᎴ ᎾᏍᏉ ᏲᏥᎩᎵᏲᎦ, ᎢᏥᎦᎵᏍᏓᏗᏍᏗ ᎠᎴ ᎢᏣᎵᏍᏕᎸᏙᏗ ᎤᎬᏩᎳ, ᎾᏍᎩ ᏥᏥᏩᏛᎡᎭ ᏗᏨᏂᏗᏳ ᎢᏥᎩᎵᏲᎢᏍᏗᏱ ᎠᏴ ᎣᏥ ᎩᎵᏲᎬ ᎤᏠᏱ; ᎢᏳ ᎠᎴ ᎤᎦᎵᏍᏗ ᏲᎦᏓᏅᏔ, ᎢᏥᎦᎵᏍᏓᏗᏍᏗ ᎠᎴ ᎢᏣᎵᏍᏕᎸᏙᏗ ᎤᎬᏩᎳ.


text:
ᎥᏝᏰᏃ ᏲᎦᏚᎵᎭ, ᎢᏓᎵᏅᎵ, ᏂᏥᎦᏔᎲᎾᏉ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏍᎩ ᎤᏕᏯᏙᏗ ᎣᎩᎷᏤᎸ ᎡᏏᏱ, ᎾᏍᎩ ᎤᎶᏒᏍᏔᏅᎯ ᎦᎨᏛ ᎣᎩᎷᏤᎸᎢ, ᎤᎶᏒᏍᏔᏅᎯ ᏂᏙᎦᎵᏂᎬᎬᎢ, ᎾᏍᎩᏃ ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎣᎦᎸᏲᎵᎸᎩ ᏦᎦᏛᏂᏗᏍᏗᏱ;


text:
ᏂᎯ ᎾᏍᏉ ᏍᎩᏍᏕᎵᏍᎬ ᎢᏣᏓᏙᎵᏍᏗᏍᎬ ᎣᎩᏍᏕᎸᏗᏱ, ᎾᏍᎩ ᎣᎩᏙᎵᏨ ᎤᏂᏣᏘ ᎢᏳᏅᏂᏌᏛ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎤᏂᏣᏘ ᎤᎾᎵᎮᎵᏤᏗᏱ <n>[ᎤᏁᎳᏅᎯ]</n> ᎠᏴ ᎨᏒ ᎢᏳᏍᏗ.


text:
ᎯᎠᏰᏃ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏦᏣᎵᎮᎵᎦ, ᎾᏍᎩ ᏦᎦᏓᏅᏙᎩ ᎪᎯᏳᏗᏍᎬᎢ, ᏃᏅᏗᏍᎬᎾ ᎤᏇᏓᎵᏉ ᎤᎬᏩᎵ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎣᎩᏍᏕᎵᏍᎬᎢ, ᏄᏠᎾᏍᏛᎾ ᎨᏒ ᎣᏨᏗᏍᎬ ᎣᎨᏙᎸ ᎠᏂ ᎡᎶᎯ ᎨᏒᎢ; ᎠᎴ Ꮀ ᎤᎬᏫᏳᎭ ᏂᎯ ᎢᏤᎲᎢ.


text:
ᎾᏍᎩᏃ ᏥᏄᏍᏛ ᏣᏆᏓᏅᏖᎸᎩ, ᏅᎵᏌᎵᏉᏍᎪ ᎠᎩᏰᎸᎯ ᎨᏎᎢ? ᎠᎴ ᎪᎱᏍᏗ ᎦᏓᏅᏛᎵ, ᏥᎪ ᎤᏇᏓᎵ ᎤᏓᏅᏖᏗ ᎦᏓᏖᏍᎪᎢ, ᎾᏍᎩᏃ ᎠᏴ ᏥᏁᏦ ᎯᎠᏉ ᏱᏄᏍᏗ, ᎥᎥ, ᎥᎥ, ᎠᎴ ᎥᏝ, ᎥᏝ?


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎤᏪᏥ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎢᏤᎲ ᎢᏨᏯᎵᏥ ᏙᏁᎸᎯ ᏥᎩ, ᎾᏍᎩ ᎠᏴ, ᎠᎴ ᏏᎵᏪᎾ, ᎠᎴ ᏗᎹᏗ ᎢᏨᏯᎵᏥᏙᏁᎸᎯ ᏥᎩ, ᎥᎥ ᎠᎴ ᎥᏝ ᎤᏛᏗᏱ ᎥᏝ ᏲᎦᏛᏁᎢ, ᎥᎥᏍᎩᏂ ᎤᏩᏒ ᎤᏛᏗᏱ ᎬᏂᎨᏒ ᏃᎬᏁᎸᎩ.


text:
ᎠᎴ ᎾᏍᎩ ᏥᏄᏍᏛ ᏥᏫᏨᏲᏪᎳᏁᎸᎩ, ᏞᏍᏗᏉ ᎾᎿ ᏫᏥᎷᏨᎭ, ᎤᏲ ᏱᎬᏆᏓᏅᏓᏗᏍᏔᏁᏍᏗ ᎾᏍᎦ Ꮎ ᎤᎵᎮᎵᏍᏗ ᎬᏆᏓᏅᏓᏗᏍᏙᏗ ᏥᎩ, ᎠᏇᎵᏒᎩ; ᏂᏥᎥᏉ ᎢᏨᏲᎢᏳᎭ ᎾᏍᎩ ᏄᏍᏛ ᎠᏆᎵᎮᎵᏍᏗᏍᎬ ᎾᏍᏉ ᎾᏍᎩ ᏂᎯ ᏂᏥᎥ ᎢᏣᎵᎮᎵᏍᏗᏍᎬᎢ.


text:
ᎤᏣᏘᏰᏃ ᎠᎩᎵᏯ ᎨᏒ, ᎠᎴ ᎡᎯᏍᏗ ᎠᏆᏓᏅᏔᏩᏕᎬ ᏫᏨᏲᏪᎳᏁᎸᎩ ᎤᏣᏘ ᏗᎦᏥᎦᏌᏬᎢᎯ ᎨᏒᎢ; ᎥᏝ ᎠᏗᎾ ᎤᏲ ᎤᎾᏓᏅᏓᏗᏍᏙᏗ ᎨᏎᏍᏗ ᏯᏇᎵᏎᎢ, ᎢᏥᎦᏙᎥᎯᏍᏗᏱᏉᏍᎩᏂ ᎾᏍᎩ ᎤᏣᏔᏅᎯ ᎢᏨᎨᏳᎢᏳ ᎨᏒᎢ.


text:
ᎢᏳᏍᎩᏂᏃᏅ ᎩᎶ ᎡᎯᏍᏗ ᏧᏓᏅᏓᏗᏍᏔᏅᎯ ᎨᏎᏍᏗ, ᎥᏝ ᎠᏴᏉ ᎡᎯᏍᏗ ᏯᏆᏓᏅᏓᏗᏍᏔᏅ; ᏂᎯᏍᎩᏂ ᏂᏥᎥ ᏰᎵ ᎡᎯᏍᏗ ᎢᏣᏓᏅᏓᏗᏍᏔᏅ; ᎾᏍᎩ ᏥᎶᏒᏍᏓᏁᏗᏱ ᏂᎨᏒᎾ ᏥᎳᏫᏎᎲᎢ.


text:
ᎩᎶ ᏰᏥᎥᎡᎸ ᎪᎱᏍᏗ ᎤᏍᎦᏅᏨ, ᎠᏴ ᎾᏍᏉ ᏥᎥᎡᎭ; ᎢᏳᏰᏃ ᎠᏴ ᎪᎱᏍᏗ ᎠᏍᎦᏅᏨᎢ ᏱᏥᎥᏍᎦ, ᎾᏍᎩ ᏥᎥᎡᎸᎯ ᏂᎯ ᎨᏒ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᏥᎥᎡᎸᎩ ᎦᎶᏁᏛ ᎠᎦᏔᎲᎢ;


text:
ᎾᏍᎩᏃ ᎠᏄᎮᎵᏤᏗ ᎨᏎᏍᏗ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᏂᎪᎯᎸ ᎢᎦᎵᎮᎵᏍᏗᏱ ᏥᏂᎬᏁᎭ ᎢᎦᏓᎵᏁᎯᏛ ᎤᎬᏩᎵ ᎦᎶᏁᏛ ᎡᏓᎵᏍᎦᏍᏙᏛᎢ, ᎠᎴ ᎬᏂᎨᏒ ᏥᏂᎬᏁᎭ ᎦᏩᏒᎬ ᎤᏩᏒ ᎠᏥᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎠᏴ ᎢᎬᏗᏍᎬ ᏂᎦᎥ ᏕᎨᏌᏗᏒᎢ.


text:
ᎾᏍᎩ ᏑᎾᏓᎴᎩ ᎨᏒ ᎠᏓᎯᎯ ᎦᏩᏒᎩ ᎾᏍᎩ ᎤᏂᎯᎯ ᏂᏙᏣᎵᏍᏓᏁᎭ; ᎠᏂᏐᎢᏃ ᎠᏓᏛᏂᏗᏍᎩ ᎦᏩᏒᎩ ᎾᏍᎩ ᎤᏅᏂᏗᏍᎩ ᏂᏙᏣᎵᏍᏓᏁᎭ. ᎦᎪᏃ ᏰᎵ ᎦᏰᎦᎨᏅᏗᏍᏗ ᎯᎠ ᎾᏍᎩ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ.


text:
ᎥᏣᏰᏃ ᏧᏂᏣᏔᏉ ᏥᏄᎾᏍᏗ ᏱᏃᎦᏍᏗ, ᎾᏍᎩ ᎠᏂᏲᏍᏗᏍᎩ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ; ᏃᎦᏠᎾᏍᏛᎾᏍᎩᏂ ᎨᏒ ᏦᏨᏗᏍᎪᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᏥᏂᎬᏂᏏᏍᎩ ᎾᏍᎩᏯᎢ, ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲ ᎣᏥᏁᎢᏍᏗ ᎦᎶᏁᏛ.


text:
ᎬᏂᎨᏒᎢᏳ ᎢᏰᏨᏁᎸᎯ ᏂᎯ ᎦᎶᏁᏛ ᎤᏤᎵ ᎪᏪᎵ ᎨᏒᎢ, ᎠᏴ ᏦᎩᎸᏫᏍᏓᏁᎸᎯ, ᎪᏪᎳᏅᎯ ᎪᏪᎶᏗ ᎬᏔᏅᎯ ᏂᎨᏒᎾ, ᎠᏓᏅᏙᏍᎩᏂ ᎤᏁᎳᏅᎯ ᎬᏂᏛ ᎤᏤᎵ ᎬᏔᏅᎯ; ᎥᏝ ᏅᏲᎯ ᏗᎪᏪᎶᏗᏱ ᏗᎪᏪᎳᏅᎯ ᏱᎩ, ᎤᏇᏓᎵᏍᎩᏂ ᎨᏒ ᏗᎪᏪᎶᏗᏱ ᎣᎾᏫᏱ.


text:
ᎾᏍᎩ ᎾᏍᏉ ᏰᎵ ᎢᎦᏲᎦᏛᏁᏗ ᏥᏃᎬᏁᎸ ᏦᏠᎯᏍᏛᎢ; ᎥᏝ ᎠᏗᎾ ᏄᏍᏛ ᎪᏪᎸᎢ, ᎠᏓᏅᏙᏍᎩᏂ ᏓᏕᏲᎲᏍᎬᎢ; ᏄᏍᏛᏰᏃ ᎪᏪᎸ ᎠᏓᎯᎰᏉ, ᎠᏓᏅᏙᏍᎩᏂ ᎠᏓᏛᏂᏗᏍᎪᎢ.


text:
ᎢᏳᏃ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎠᏓᎯᎯ ᎨᏒ ᎤᎬᏩᎵ ᏥᎪᏪᎴ ᏣᏰᎶᎴ ᏅᏲᎯ ᎦᎸᏉᏗᏳ ᏥᎨᏎᎢ, ᎾᏍᎩ ᎢᏏᎵ ᏧᏪᏥ ᎪᎯᏛ ᏗᎬᏩᎾᎧᏃᏗ ᏂᎨᏒᎾ ᏥᎨᏎ ᎼᏏ ᎤᎧᏛᎢ, ᏥᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏗᎬᏩᎸᏌᏛ ᎨᏒ ᎤᎧᏛᎢ; ᎾᏍᎩ ᎠᎲᏍᏗᏉ ᏥᎨᏎᎢ;


text:
ᏚᎾᏓᏅᏛᏍᎩᏂ ᏧᏍᎦᏃᎵᏳ ᎨᏎᎢ; ᎪᎯᏰᏃ ᎢᏯᏍᏗ ᏅᏩᏍᏗᏉ ᎾᏍᎩ Ꮎ ᎠᎵᎬᏚᎶ ᎠᎲᏛ ᏂᎨᏒᎾ ᎢᏳᏃ ᏓᏂᎪᎵᏯ ᎤᏪᏘ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᎪᏪᎸᎢ; ᎦᎶᏁᏛᏰᏃ ᏂᎬᏂᏏᏍᎪ ᎠᎲᏛ ᏂᎨᏐᎢ.


text:
ᎠᏴᏍᎩᏂ ᏂᏗᎥ ᏂᏗᎦᎵᎬᏚᎸᎾ ᎠᏓᎨᏗᏱ ᎾᏍᎩᏯ ᏕᏓᎧᏂᏍᎬ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ, ᎢᏓᏓᏁᏟᏴᎭ ᎾᏍᎩᏯ ᏄᏍᏛ ᏂᏓᎵᏍᏗᎭ, ᎦᎸᏉᏗᏳ ᎨᏒ ᎢᎩᎲ ᎧᏁᏉᏤᎦ, ᎤᎬᏫᏳᎯ ᎤᏓᏅᏙ ᎢᏳᏩᏂᏌᏛ ᎾᏍᎩᏯᎢ.


text:
ᏙᎩᏲᏒᏍᎩᏂ ᏧᏓᎴᏅᏛ ᎬᏍᎦᎵ ᎤᏕᎰᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎥᏝ ᏲᏤᏙᎭ ᎠᏏᎾᏌᏅᎢᏍᏗ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᎣᎦᏠᎾᏍᏛ ᏱᏙᎩᎸᏫᏍᏓᏁᎭ ᎧᏃᎮᏛ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎬᏂᎨᏒᏍᎩᏂ ᏃᏨᏁᎲ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎪᎩᎸᏉᏙᏗᏱ ᏃᏨᏁᎭ ᎾᏂᎥ ᏴᏫ ᏚᎾᏓᏅᏛ ᎬᏗ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ.


text:
ᎾᏍᎩ Ꮎ ᎾᏃᎯᏳᎲᏍᎬᎾ ᎾᏍᎩ ᎯᎠ ᎡᎶᎯ ᎤᏁᎳᏅᎯ ᎤᏰᎸᎯ ᏚᎵᏏᎲᏍᏓᏁᎸ ᏚᎾᏓᏅᏛᎢ, ᎾᏍᎩ ᏧᏂᎸᏌᏓᏕᏗᏱ ᏂᎨᏒᎾ ᎢᎦ-ᎦᏛ ᎤᏘᏍᏛ ᎦᎸᏉᏗᏳ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎾᏍᎩᏯ ᏥᎩ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎾᏍᎩ Ꮎ ᏧᏁᏤ ᎢᎦᎦᏘ ᎤᎵᏏᎬ ᏧᎸᏌᏓᏗᏍᏗᏱ, ᏚᎸᏌᏓᏗᎸ ᏦᎩᎾᏫᏱ, ᎾᏍᎩ ᎣᎩᏁᏗᏱ ᎢᎦ-ᎦᏘ ᎠᎦᏙᎥᎯᏍᏙᏗ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᎤᎧᏛ ᏨᏗᏓᎴᎲᏍᎦ.


text:
ᎤᏠᏱᏉ ᏦᎩᎭ ᎠᏓᏅᏙ ᎪᎯᏳᏙᏗ ᎨᏒᎢ, ᎯᎠ ᎾᏍᎩᏯ ᏥᏂᎬᏅ ᏥᎪᏪᎳ, ᎠᏉᎯᏳᏅ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᎩᏁᏨ; ᎠᏴ ᎾᏍᏉ ᎣᏦᎯᏳᎲᏍᎦ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗ ᎣᏥᏁᎦ.


text:
ᏂᏙᏣᎧᏂᏍᎬᎾ ᎨᏒ ᎾᏍᎩ ᏗᎬᎪᏩᏛᏗ ᏥᎩ, ᎾᏍᎩᏍᎩᏂ Ꮎ ᏗᎬᎪᏩᏛᏗ ᏂᎨᏒᎾ ᏥᎩ; ᎾᏍᎩᏰᏃ ᏗᎬᎪᏩᏛᏗ ᏥᎩ ᏗᎦᎶᏐᎲᏍᎩ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᏗᎬᎪᏩᏛᏗ ᏂᎨᏒᎾ ᏥᎩ ᏗᎦᎶᏐᎲᏍᎩ ᏂᎨᏒᎾ.


text:
ᎣᏥᎦᏔᎭᏰᏃ ᎾᏍᎩ ᎢᏳᏃ ᎡᎶᎯ ᎡᎯ ᎣᏥᏁᎸ ᎣᎩᎵᏦᏛ ᏳᏲᏨ, ᎣᎩᎭ ᎠᏓᏁᎸ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ, ᎠᏓᏁᎸ ᏧᏬᏱ ᏗᎬᏔᏅᎯ ᏂᎨᏒᎾ ᎠᏁᏍᎨᎲᎯ, ᎠᏲᎩ ᏂᎨᏒᎾ ᎦᎸᎶᎢ ᏗᏓᏁᎸ.


text:
ᎠᏴᏰᏃ ᎯᎠ ᎠᏂ ᎦᎵᏦᏛ ᏦᏥᏯᎠ ᎣᎩᎵᏰᏗᎭ, ᏂᎦᎵᏍᏙᏗᎭ ᎦᎨᏛ ᏃᎦᏛᎿᏕᎬᎢ; ᎥᏝ ᏦᎩᏄᏪᏍᏗᏱ ᎣᎦᏚᎵᏍᎬ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ; ᏦᎩᏄᏬᏍᏗᏱᏍᎩᏂ; ᎾᏍᎩ ᎠᏲᎱᏍᎩ ᎨᏒ ᎠᏥᎩᏍᏗᏱ ᎬᏂᏛ ᎤᎩᏐᎲᏍᏗᏱ.


text:
ᎠᏴᏰᏃ ᏂᏗᎥ ᎢᎬᏱᏗᏢ ᏫᎩᎾᏄᎪᎢᏍᏗ ᎨᏎᏍᏗ ᎦᎶᏁᏛ ᏧᏭᎪᏙᏗᏱ ᎦᏍᎩᎸᎢ; ᎾᏍᎩ ᏂᏗᎥ ᎢᏗᏏᏴᏫᎭ ᎡᎩᏁᏗᏱ ᏄᏍᏛ ᏕᎩᎸᏫᏍᏓᏁᎸ ᏗᏗᏰᎸ ᎬᏗ, ᎾᏍᎩᏯ ᏂᎦᏛᏁᎵᏙᎸᎢ, ᎣᏏᏳ ᏱᎾᎩ, ᎠᎴ ᎤᏲ ᏱᎾᎩ.


text:
ᎾᏍᎩᏃ ᏦᏥᎦᏔᎭ ᎦᎾᏰᎢᏍᏗ ᎨᏒ ᎤᎬᏫᏳᎯ, ᏙᏥᏍᏗᏰᏗ ᏴᏫ; ᎠᎴ ᎬᏂᎨᏒ ᏃᏣᎵᏍᏗᎭ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ; ᎠᎴ ᎤᏚᎩ ᎠᏋᎭ ᎬᏂᎨᏒ ᎢᏯᏉᎵᏍᏙᏗᏱ ᎾᏍᏉ ᏂᎯ ᏕᏣᏓᏅᏛᎢ.


text:
ᎥᏝᏰᏃ ᏂᎯ ᏍᎩᎸᏉᏗᏳ ᎢᏳᎵᏍᏙᏗᏱ ᏲᏥᏂᎳᏗᎭ; ᎢᏨᏁᎭᏎᏍᏗᏂ ᏍᎩᎸᏉᏙᏗᏱ, ᎾᏍᎩ ᎪᎱᏍᏗ ᏳᏂᎭ ᏧᎾᏬᎯᎵᏴᏍᏓᏁᏗ, ᎢᏨᏰᎵᏎᎭ, ᎾᏍᎩ ᎦᏚᏉ ᎡᎯ ᎠᎾᏢᏉᏙᏗᏍᎩ ᏥᎩ, ᏙᏧᎾᏓᏅᏛᏃ ᎠᎾᏢᏉᏙᏗᏍᎩ ᏂᎨᏒᎾ.


text:
ᎾᏍᎩᏃ ᎾᏂᎥ ᏚᏲᎱᎯᏎᎴᎢ, ᎾᏍᎩ Ꮎ ᏗᏅᏃᏛ ᏥᎩ ᎪᎯ ᎨᏒ ᎢᏳᏓᎴᏅᏛ ᎤᏅᏒᏉ ᎤᎾᏤᎵ ᎤᎬᏩᎵ ᎤᎾᎴᏂᏓᏍᏗᏱ ᏂᎨᏒᎾ, ᎾᏍᎩᏍᎩᏂ Ꮎ ᎤᏤᎵ ᎤᎬᏩᎵ ᏧᏲᎱᎯᏎᎸᎯ ᎠᎴ ᏧᎴᎯᏌᏅᎯ ᏥᎩ.


text:
ᎾᏍᎩ ᎢᏳᏏᏗ ᎪᎯ ᎨᏒ ᎢᏳᏓᎴᏅᏛ ᎥᏝ ᎩᎶ ᏲᏥᎦᏔᎭ ᎾᏍᎩᏯ ᎤᏇᏓᎵ ᎠᎦᏔᎲᎢ. ᎠᎴ ᎾᏍᏉ ᎢᏳ ᎦᎶᏁᏛ ᎣᏥᎦᏙᎥᏒᎯ ᏱᎩ ᎤᏇᏓᎵ ᎠᎦᏔᎲ ᎾᏍᎩᏯᎢ, ᎠᏎᏃ ᎪᎯ ᎨᏒ ᎢᏳᏓᎴᏅᏛ ᎥᏝ ᎿᏉ ᏲᏥᎦᏔᎭ.


text:
ᎾᏍᎩᏃ ᎠᏴ ᎣᎩᏅᏏᏛ ᎦᎶᏁᏛ ᎣᏣᏓᏁᏟᏴᏍᏔᏁᎸᎯ; ᎾᏍᎩᏯᏉ ᎤᏁᎳᏅᎯ ᏥᏥᏍᏗᏰᏗᏍᎪ ᎠᏴ ᏦᎬᏗᏍᎪᎢ, ᎦᎶᏁᏛ ᎣᏣᏓᏁᏟᏴᏍᏓᏁᎭ, ᎢᏨᏔᏲᏎᎭ ᎤᏁᎳᏅᎯ ᏙᎯ ᎢᏨᏁᏗᏱ.


text:
ᎯᎠᏰᏃ ᏂᎦᏪᎭ, ᎬᏩᏛᎦᏁᎸ ᎾᎯᏳ ᏗᏓᏂᎸᏨᎯ ᎨᏒᎢ, ᎠᎴ ᎾᎯᏳ ᎢᎦ ᎦᏴᏓᏗᏍᏕᎸᏗ ᎨᏒ ᎬᏍᏕᎸᎲ; (ᎬᏂᏳᏉ, ᎪᎯ ᎿᏉ ᎾᎯᏳ ᏗᏓᏂᎸᏨᎯ ᎨᏒᎢ; ᎬᏂᏳᏉ, ᎪᎯ ᎿᏉ ᎾᎯᏳ ᏗᏓᏂᎸᏨᎯ ᎨᏒᎢ; ᎬᏂᏳᏉ, ᎪᎯ ᎿᏉ ᎾᎯᏳ ᎢᎦ ᎦᏴᏓᏗᏍᏕᎸᏗ ᎨᏒᎢ;)


text:
ᏂᎦᎥᏍᎩᏂ ᏄᏓᎴᏒ ᏙᎩᎸᏫᏍᏓᏁᎲ ᎬᏂᎨᏒ ᏃᏨᏁᎰ ᎤᏁᎳᏅᎯ ᎪᎱᏍᏗ ᎣᏣᏛᏁᎯ ᎨᏒᎢ, ᎤᏣᏘ ᏦᏨᏂᏗᏳ ᎨᏒᎢ, ᎣᏥᎩᎵᏲᎬᎢ, ᎣᎩᏂᎬᏎᎲᎢ, ᎡᎯᏍᏗ ᎣᎦᏓᏅᏔᏩᏕᎬᎢ,


text:
ᎤᏲ ᏦᎦᏓᏅᏔᏩᏕᎪ ᎾᏍᎩᏯ, ᎠᏎᏃ ᏯᏃ ᎣᏣᎵᎮᎵᎪᎢ; ᎤᏲ ᏥᏃᎦᏛᎿᏕᎪ ᎾᏍᎩᏯ, ᎠᏎᏃ ᎤᏂᏣᏘ ᏙᏤᏅᎢᏍᏗᏍᎪᎢ; ᎪᎱᏍᏗ ᏃᎩᎲᎾ ᏥᎨᏐ ᎾᏍᎩᏯ, ᎠᏎᏃ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎣᎦᏤᎵᎦ.


text:
ᏞᏍᏗ ᏂᏗᏣᏙᎵᎬᎾ ᎢᏧᎳᎭ ᏱᏕᏥᎩᎳᎾᎳᏗᏍᎨᏍᏗ ᎾᏃᎯᏳᎲᏍᎬᎾ; ᎦᏙᏰᏃ ᎤᏍᏗ ᏚᎾᏚᏓᏛ ᏚᏳᎪᏛ ᎨᏒ ᎠᎴ ᏂᏚᏳᎪᏛᎾ ᎨᏒᎢ? ᎠᎴ ᎦᏙ ᎤᏍᏗ ᏌᏉ ᏄᏅᏅ ᎢᎦ-ᎦᏘ ᎠᎴ ᎤᎵᏏᎩ?


text:
ᎠᎴ ᎦᏙ ᎤᏍᏗ ᏗᏙᎵᎩ ᏂᎦᎵᏍᏗᎭ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸ ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏟᎶᏍᏔᏅᎯ? ᏂᎯᏰᏃ ᎾᏍᎩ ᎬᏂᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎤᏁᎳᏗᏍᏗᏱ; ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᎯᎠ ᏥᏁᏪᏒ, ᎾᏍᎩ Ꮎ ᎦᏥᏯᎡᏍᏗ, ᎠᎴ ᎠᏁᎲ ᎨᏙᎮᏍᏗ; ᎠᎴ ᎠᏴ ᎦᏥᏯᏁᎳᏅᎯ ᎨᏎᏍᏗ, ᎠᎴ ᎤᏅᏒ ᏗᏆᏤᎵ ᏴᏫ ᎨᏎᏍᏗ.


text:
ᎯᎠᏃ ᎾᏍᎩ ᏥᏄᏍᏗ ᎡᎩᏚᎢᏍᏓᏁᎸᎯ ᏥᎩ, ᎢᏨᎨᏳᎢ, ᎢᏓᏓᏅᎦᎸ ᎢᏗᎲᎾ ᏄᏓᎴᏒ ᎦᏓᎭ ᎨᏒ ᎢᎩᏇᏓᎸ, ᎠᎴ ᎢᎦᏓᏅᏙᎩᎯ, ᎢᏗᏍᏆᏗᏍᎨᏍᏗ ᏚᏳᎪᏛ ᎨᏒᎢ, ᎤᏁᎳᏅᎯ ᎡᏗᎾᏰᏍᎬᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᏥᏂᏥᏪᎭ ᎥᏝ ᏗᏨᏳᎪᏓᏁᏗᏱ ᏯᎩᏰᎸᎭ; ᎦᏳᎳᏰᏃ ᎯᎠ ᏥᏂᎠᎩᏪᏒ, ᏦᎩᎾᏫᏱ ᎢᏥᏯᎠ, ᎣᎦᏛᏅᎢᏍᏗᏉ ᎢᏧᎳᎭ ᏗᎩᏂᏲᎱᎯᏍᏗᏱ, ᎠᎴ ᎢᏧᎳᎭ ᎢᎦᏕᏗᏱ.


text:
ᎥᏝᏍᎩᏂᏃᏅ ᎤᎷᏨᏉ ᎤᏩᏒ, ᎤᎦᎵᏍᏗᏍᎩᏂ ᎾᏍᏉ ᎤᏓᏅᏓᏛᎢ ᏂᎯ ᎨᏒ ᎢᏳᏍᏗ, ᎣᎩᏃᏁᎸ ᏂᎯ ᎤᏣᏘ ᎢᏣᏚᎵᏍᎬᎢ, ᎤᏲ ᎢᏥᏰᎸᏒᎯ, ᎤᏣᏘ ᏍᎩᎨᏳᎢᏳ ᎨᏒᎢ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏟ ᎢᎦᎢ ᎠᏆᎵᎮᎵᏨᎩ.


text:
ᎤᏙᎯᏳᎯᏍᎩᏂᏃᏅ ᎤᏲ ᎢᏨᏯᏓᏅᏓᏗᏍᏔᏅᎩ ᎪᏪᎵ ᏫᏨᏅᏁᎸᎢ, ᎥᏝ ᎤᏲ ᏯᎩᏰᎸᎭ, ᎤᏲᏍᎩᏂᏃᏅ ᎠᎩᏰᎸᏒᎩ; ᎢᏥᎪᏩᏘᏰᏃ ᎾᏍᎩ ᎤᏲ ᎢᏣᏓᏅᏓᏗᏍᏯᏅᎢ, ᎠᏎᏃ ᏞᎦᏉ.


text:
ᎪᎯᏃ ᏥᎩ ᎦᎵᎡᎵᎦ, ᎥᏝ ᎠᏗᎾ ᎤᏲ ᎢᏣᏓᏅᏓᏛ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ, ᏅᏗᎦᎵᏍᏙᏗᎭᏍᎩᏂ ᏗᎨᏥᏁᏟᏴᏍᏗ ᏕᏣᏓ ᏅᏛ ᎢᏴᏛ ᎤᏲ ᎢᏣᏓᏅᏓᏛᎢ; ᎤᏲᏰᏃ ᎢᏣᏓᏅᏓᏛᎩ ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᏥᎩ, ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎪᎱᏍᏗ ᎡᏍᎦ ᎢᏨᏴᏁᏗᏱ ᏂᎨᏒᎾ.


text:
ᎤᏲᏰᏃ ᎠᏓᏅᏓᏗᏍᏗ ᎤᏁᎳᏅᎯ ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᎨᏒ ᎦᏁᏟᏴᏍᏗ ᎨᏒ ᎣᏓᏅᏛ ᏩᎵᏰᎢᎶᎯᎭ ᎥᏓᏗᏍᏕᎸᏗᏱ ᏫᎦᎷᎩ, ᎾᏍᎩ ᎤᏲ ᎠᏰᎸᏗ ᏂᎨᏒᎾ; ᎡᎶᎯᏍᏗᏂ ᎡᎯ ᎤᏲ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᏩᎵᏰᎢᎶᎯᎭ.


text:
ᎬᏂᏳᏉᏰᏃ ᎯᎠ ᎾᏍᎩ ᎤᏲ ᏥᏣᏓᏅᏓᏛᎩ ᎾᏍᎩ ᏗᎬᏩᏓᏂᎸᎢᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ, ᏂᎦᎥ ᎢᏣᎵᏂᎬᏁᏗ ᎨᏒ ᏭᎵᏰᎢᎶᎸ; ᏂᎦᎥ ᏗᏣᏢᏫᏍᏙᏗ ᎢᏥᏲᎲᎢ, ᎢᎢ ᏂᎦᎥ ᎢᏥᏂᏆᏘᎲᎢ, ᎥᎥ, ᏂᎦᎥ ᎢᏥᎾᏰᏍᎬᎢ, ᎥᎥ, ᏂᎦᎥ ᎤᏣᏘ ᎢᏣᏑᎵᏍᎬᎢ, ᎥᎥ ᏂᎦᎥ ᎤᎵᏂᎩᏛ ᎢᏣᏓᏅᏛᎢ, ᎥᎥ, ᏂᎦᎥ ᎠᏓᏍᏛᏗᏍᏙᏗ ᎨᏒᎢ! ᏂᎦᎥ ᏧᏌᎴᏅᏛ ᎬᏂᎨᏒ ᏂᏨᏁᎸ ᏂᏥᏍᎦᏅᎾ ᎨᏒ ᎯᎠ ᎾᏍᎩ ᎧᏃᎮᏗ ᏥᎩ.


text:
ᎾᏍᎩ ᏥᏄᏍᏗ ᎤᏙᎯᏳᎯᏍᎩᏂᏃᏅ ᏫᏨᏲᏪᎳᏁᎸᎩ, ᎠᏎᏃ ᎥᏝ ᎤᏣᏘᏂ ᎢᏳᏛᏁᎸᎯ ᏳᎬᏩᎴᎢ, ᎥᏝ ᎠᎴ ᎾᎤᏣᏘᏂ ᎢᏯᎦᏛᏁᎸᎯ ᏳᎬᏩᎡᎢ; ᎠᏍᎩᏂ ᎢᏨᏍᏆᏂᎪᏗᏳ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲ ᎬᏂᎨᏒ ᎢᏣᎵᏍᏓᏁᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᎯ ᎤᎦᎵᏍᏗ ᎢᏣᏓᏅᏛ ᎠᏴ ᎣᎩᎦᎵᏍᏓᏛᎩ; ᎥᎥ, ᎠᎴ ᎤᏟ ᎢᎦᎢ ᎣᎦᎵᎮᎵᏍᏗ ᏄᎵᏍᏔᏅᎩ, ᏓᏓᏏ ᎠᎵᎮᎵᎬ ᎢᏳᏍᏗ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎾᏍᎩ ᎤᏓᏅᏙ ᏂᏥᎥ ᎡᏥᎦᎵᏍᏓᏕᎸᎢ.


text:
ᎢᏳᏰᏃ ᏥᏯᏢᏈᏎᎸᎯ ᎨᏎᏍᏗ, ᏂᎯ ᎢᏨᏁᎢᏍᏗᏍᎬᎢ, ᎥᏝ ᏱᎦᏕᎣᏍᎦ; ᏂᎦᏗᏳᏍᎩᏂ ᏧᏓᎴᏅᏛ ᎢᏨᏬᏁᏔᏅᎢ ᎤᏙᎯᏳᎯᏯ ᏥᎩ, ᎾᏍᎩᏯᏉ ᎣᎦᏢᏆᏒᎢ, ᎾᏍᎩ ᏓᏓᏏ ᎣᏣᏢᏆᏎᎸᎢ, ᎤᏙᎯᏳᎯᏯ ᏄᎵᏍᏔᏅ.


text:
ᎠᎴ <n>[ᎾᏍᎩ ᏄᎾᏛᏁᎸᎩ]</n> ᎥᏝ ᎾᏍᎩᏯ ᏄᏍᏛ ᎤᏚᎩ ᎣᎬᏅᎢ, ᎢᎬᏱᏍᎩᏂ ᎤᏅᏒ ᎤᎬᏫᏳᎯ ᏚᎾᏓᏲᎯᏎᎸᎩ, ᎠᎴ ᎠᏴ ᏕᎪᎦᏓᏲᎯᏎᎸᎩ, ᎤᏁᎳᏅᎯ ᎣᏏᏳ ᎠᏰᎸᏍᎬ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ.


text:
ᎾᏍᎩᏃ ᏂᎦᎥ ᏧᏓᎴᎥᏛ ᎤᏣᏘ ᏥᏥᎭ, ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎠᎴ ᎦᏭᏂᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏂᎦᎥ ᏧᏓᎴᏅᏛ ᎢᏥᎦᎵᏴᎢ, ᎠᎴ ᎠᏴ ᏍᎩᎨᏳᎢᏳ ᎨᏒᎢ, ᎯᎠ ᎾᏍᎩ ᎠᏓᏁᏗ ᎨᏒ ᎾᏍᏉ ᎤᏣᏘ ᎢᏥᎮᏍᏗ.


text:
ᎢᏥᎦᏔᎭᏰᏃ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎤᏪᎾᎢᏳ ᏥᎨᏎᎢ, ᎠᏎᏃ ᏂᎯ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎤᏲ ᎢᏳᏛᎿᏕᎩ ᏄᎵᏍᏔᏅᎢ, ᎾᏍᎩ ᎤᏩᏒ ᎤᏲ ᎢᏳᏛᎿᏕᎩ ᎨᏒ ᎢᏳᏩᏂᏐᏗᏱ ᏂᎯ ᏗᏤᎿᎢ ᎢᏣᎵᏍᏙᏗᏱ.


text:
ᎠᎴ ᎠᏂ ᎾᏍᎩ ᏄᏍᏛ ᎦᏓᏅᏖᏍᎬ ᎬᏂᎨᏒ ᏂᎬᏁᎭ; ᎣᏏᏳᏰᏃ ᎢᎨᏣᎵᏍᏓᏁᏗ, ᎾᏍᎩ ᎦᏳᎳ ᎢᏣᎴᏅᏛ ᏥᎩ, ᎿᏉ ᏑᏕᏘᏴᏛ, ᎥᏝ ᎢᏣᏛᏁᏗᏱᏉ ᎾᏍᎩ, ᎾᏍᏉᏍᎩᏂ ᎣᏏᏳ ᎢᏥᏰᎸᏗᏱ.


text:
ᎢᎬᏩᏍᏗᎭᏍᎩᏂ <n>[ᎢᏥᏗᏱ;]</n> ᎾᏍᎩ ᎪᎯ ᎨᏒ ᎤᏣᏘ ᎢᏥᎲ ᏱᏗᏥᏍᏕᎸᏗᎭ ᎤᏂᏂᎬᏎᎲᎢ, ᎾᏍᎩᏃ ᎾᏍᏉ ᎤᏣᏘ ᎤᏂᎲ ᎨᏥᏍᏕᎸᏗᏱ ᎢᏥᏂᎬᏎᎲᎢ, ᎾᏍᎩ ᎢᎬᏩᏍᏗᎭ ᎢᏥᏗᏱ.


text:
ᎠᎴ ᎥᏝ ᎾᏍᎩᏉ ᏱᏂᎦᎥ, ᎾᏍᏉᏍᎩᏂ ᏚᎾᏓᏡᏩᏗᏒ ᏧᎾᏁᎶᏗ ᎬᏩᏑᏰᏒᎩ ᎠᏴ ᎢᏧᎳᎭ ᎣᎨᏅᏍᏗᏱ ᎣᎩᏴᏍᏗᏱ ᎯᎠ ᎾᏍᎩ ᎠᏓᏁᏗ, ᎾᏍᎩ ᏥᏙᎩᎸᏫᏍᏓᏁᎭ, ᎦᎸᏉᏗᏳ ᎢᏳᎵᏍᏙᏗᏱ ᎤᎬᏫᏳᎯ ᎤᏩᏒ, ᎠᎴ <n>[ᎬᏂᎨᏒ ᎢᎬᏩᏁᏗᏱ]</n> ᎢᏣᎵᎦᎵᏴᏒ ᏙᏗᏣᏓᏅᏛᎢ;


text:
ᎠᎴ ᎣᏥᏅᎵ ᎢᏧᎳᎭ ᎠᏁᎩ ᎣᏣᎵᏅᏟ, ᎾᏍᎩ ᎤᏩᎫᏘᎶᏛ ᎣᏥᎪᎵᏰᏛ ᎣᎦᏙᎴᎰᏒᎯ ᎤᏣᏘ ᎠᎦᎵᏱᏳ ᎨᏒᎢ, ᎠᏎᏃ ᎪᎯ ᎨᏨ ᎤᏟ ᎾᎦᎵᏴ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏣᏘ ᎢᏦᎯᏳᏒᎢ.


text:
ᏓᏓᏏᏃ ᎨᏒᎢ, ᎣᎩᎾᎵᎪᎯ ᎾᏍᎩ, ᎠᎴ ᎢᏧᎳᎭ ᏦᎩᏂᎸᏫᏍᏓᏁᎯ ᏂᎯ ᎪᎱᏍᏗ ᎢᏨᏯᏛᏁᎲᎢ; ᎣᏣᎵᏅᏟᏃ ᎨᏒ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒ ᎬᏩᏂᏅᏏᏛ ᎾᏍᎩ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎢᏯᏅᏁᎯ ᎦᎶᏁᏛ..


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏂᎦᏔᎲ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒᎢ, ᎬᏂᎨᏒ ᏂᏕᏨᏁᎸᎭ ᎾᏍᎩ ᎪᎯᏳᏗᏍᎩ ᎠᏓᎨᏳᏗ ᎨᏒ ᎢᏤᎲᎢ, ᎠᎴ ᎣᎦᏢᏆᏒ ᏂᎯ ᎢᏨᏁᎢᏍᏗᏍᎬᎢ ᎠᏎᏉ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎦᏔᏎᏰᏃ ᏗᎦᎵᏱᏳ ᎨᏒ ᏕᏣᏓᏅᏛᎢ, ᎾᏍᎩ ᎢᏨᏁᎢᏍᏗᏍᎬ ᎹᏏᏙᏂ ᎠᏁᎯ ᎦᏥᏯᏢᏈᏌᎭ, <n>[ᎦᏥᏃᏁᎭ]</n> ᎾᏍᎩ ᎡᎧᏯ ᎿᏉ ᏑᏕᏘᏴᏛ ᎬᏩᏛᏅᎢᏍᏔᏅᎯ ᎨᏒᎢ; ᎠᎴ ᏂᎯ ᎤᎵᏂᎩᏛ ᎢᏣᏓᏅᏛ ᎤᏂᏣᏔ ᎤᏂᏖᎸᏅ.


text:
ᎢᏳᏰᏃ ᏱᏅᏩᏎᎦᏨ ᎹᏏᏙᏂ ᎠᏁᎯ ᏱᎬᎩᏍᏓᏩᏕᏅ, ᏱᏨᏩᏛᏔᏅᏃ ᏂᏣᏛᏅᎢᏍᏔᏅᎾ, ᎠᏴ, (ᎥᏝᏰᏃ ᏂᎯ ᏱᎦᏗᎭ,) ᏲᏣᏕᎰᎯ ᎯᎠ ᎾᏍᎩ ᎤᏣᏘ ᎣᎪᎯᏳᎯ ᎣᎦᏢᏈᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏎ ᏱᎦᏥᏁᏤᎸ ᎠᎾᎵᏅᏟ ᎠᏇᎵᏒᎩ ᎢᎬᏱ ᏫᎨᏥᎷᏤᏗᏱ, ᎠᎴ ᎢᎬᏱ ᏭᎾᏛᏅᎢᏍᏙᏗᏱ ᎢᏥᏗ ᎨᏒ, ᎾᏍᎩ ᎦᏳᎳ ᎧᏁᎢᏍᏔᏅᎯ ᏥᎩ, ᎾᏍᎩ ᎠᏛᏅᎢᏍᏔᏃᏅᎯ ᏱᎩ, ᎾᏍᎩᏯ ᎣᏏᏳ ᎢᏥᏰᎸᎯ ᎢᏥᏅᎯ ᎨᏒᎢ, ᎥᏝᏃ ᎢᏥᎨᏳᏅᎯ ᎾᏍᎩᏯᎢ.


text:
ᎾᏂᎥ ᎩᎶ ᎾᏍᎩᏯ ᏄᏍᏛ ᎠᎾᏓᏅᏖᏍᎬ ᏧᏂᎾᏫᏱ <n>[ᎠᏂᎲᏍᎨᏍᏗ;]</n> ᎥᏝᏍᏗ ᏝᏉ ᎤᏂᏰᎸᎯ, ᎥᏝ ᎠᎴ ᎠᏎ ᎤᏂᏗᏱ ᏥᏂᎨᎬᏁᎰ ᎢᏳᏍᏗ; ᎤᏁᎳᏅᎯᏰᏃ ᎤᎨᏳᎭ ᎤᎦᎵᏍᏗ ᎤᏓᏁᏘ ᎠᎲᏍᎩ.


text:
ᎾᏍᎩᏃ Ꮎ ᎤᎦᏔ ᎠᏫᏍᎩ ᎤᏁᎯ ᏥᎩ, ᎠᎴ ᎦᏚ ᎠᎵᏍᏓᏴᏙᏗ ᎠᏓᏁᎯ ᏥᎩ, ᎢᏥᏁᏗ ᎨᏎᏍᏗ ᎠᎴ ᎤᎪᏓᏗᏍᏗ ᎨᏎᏍᏗ ᎢᏥᏫᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏁᏉᏍᏗ ᎨᏎᏍᏗ ᎢᏣᏓᏅᏘᏳ ᎨᏒ ᎤᎦᏔᏔᏅᎯ;


text:
ᎠᏂᎪᏩᏗᏍᎬᏰᏃ ᎢᏳᏍᏗ ᎾᏍᎩ ᎯᎠ ᎤᎾᎵᏍᏕᎸᏙᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᏛᏂᎸᏉᏔᏂ ᏂᎦᎵᏍᏙᏍᎨᏍᏗ ᎬᏂᎨᏒ ᏂᏨᏁᎲ ᎢᏦᎯᏳᏒ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ, ᎠᎴ ᏂᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᏂᏥᎨᏳᎿᎥᎾ ᎨᏒ ᏕᏥᏁᎲ ᎾᏍᎩ, ᎠᎴ ᎾᏂᎥᏉ;


text:
ᎾᏍᎩᏃ ᎠᏴ ᏉᎳ ᎠᏋᏒ ᎢᏨᏍᏗᏰᏗᎭ ᏥᏁᎢᏍᏗᎭ ᎤᏙᎵᏍᏙᏏᏳ ᎨᏒ ᎠᎴ ᎤᏓᏅᏘᏳ ᎨᏒ ᎦᎶᏁᏛ, ᎠᏴ ᎾᏍᎩ ᏥᏨᏰᎳᏗᏙᎰ ᎠᏆᏓᎾᏰᏍᏗ ᏥᎨᎰᎢ, ᎠᏎᏃ ᎠᎩᎪᏁᎸ ᏂᏨᎾᏰᏍᎬᎾ ᏥᎩ ᏂᎯ--


text:
ᎠᏎᏃ ᎢᏨᏔᏲᏎᎭ ᎢᏨᏰᎳᏗᏙᎲ ᎾᏆᏓᎾᏰᏍᏛᎾ ᎢᏯᏆᎵᏍᏙᏗᏱ ᏂᎨᏒᎾ, ᎾᏍᎩᏯ ᎾᏆᏓᎾᏰᏍᏛᎾ ᎦᏥᏴᏓᏁᏗ ᏣᎩᏰᎸᎭ ᎢᎦᏛ, ᎾᏍᎩ ᎤᏇᏓᎵ ᎠᏓᏅᏖᏍᎬ ᏓᏂᎧᎿᏩᏗ ᏥᎪᎨᎵᏎᎭ.


text:
ᎡᎳᏗ ᏂᏙᏨᏁᎰ ᎠᏓᏅᏖᏗ ᎨᏒ, ᎠᎴ ᏄᏓᎴᏒ ᎢᏅ ᎢᎦᏘ ᎾᏍᎩ ᎠᏓᎵᏌᎳᏗᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᏗᎦᏘᎴᎩ, ᎠᎴ ᏙᏥᏎᎪᎩᏍᎪ ᏙᏣᏘᏁᎪ ᏄᏓᎴᏒ ᎠᏓᏅᏖᏗ ᎨᏒ ᎦᎶᏁᏛ ᎬᏬᎯᏳᏗᏱ ᏃᏨᏁᎰᎢ;


text:
ᏥᎪ ᎦᏚ-ᎢᏗᏢ ᏄᏍᏛ ᏗᎧᏃᏗᏱ ᎪᎱᏍᏗ ᏕᏣᎧᏂᏍᎪᎢ? ᎢᏳᏃ ᎩᎶ ᎤᏩᏒᏉ ᎠᏓᎵᏍᎦᏍᏙᏗᏍᎨᏍᏗ ᎦᎶᏁᏛ ᏥᏯᏤᎵ ᎠᏴ ᎢᎡᎵᏍᎨᏍᏗ, ᎤᏩᏒ ᎨᏒ ᏔᎵᏁ ᎯᎠ ᎾᏍᎩ ᏥᎠᏓᏅᏛᎵ, ᎾᏍᎩ ᎾᏍᎩᏯ ᎦᎶᏁᏛ ᎤᏤᎵ ᎨᏒ ᎾᏍᎩ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏴ ᎦᎶᏁᏛ ᎣᏣᏤᎵᎦ.


text:
ᎾᏍᎩ ᎢᏰᎵᏍᎩ ᎯᎠ ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᎠᏓᏅᏖᏍᎨᏍᏗ, ᎾᏍᎩ ᎠᏴ ᎾᏍᎩᏯ ᏃᎦᏍᏛ ᎣᏥᏬᏂᏍᎬ ᏙᏦᏪᎵᏍᎬᎢ, ᎾᎿ ᏫᏃᏤᏙᎲᎾ ᎨᏒᎢ, ᎾᏍᎩᏯ ᎾᏍᏉ ᏃᎦᏍᏕᏍᏗ ᏙᎩᎸᏫᏍᏓᏁᎲ ᎿᏉ ᎾᎿ ᏬᏤᏙᎮᏍᏗ.


text:
ᎥᏝᏰᏃ ᏰᎵ ᎦᏲᎦᎵᏠᏯᏍᏙᏗ ᏱᎩ, ᎠᎴ ᏗᎦᏲᎦᏓᏟᎶᏍᏙᏗ ᏱᎩ ᏄᎾᏍᏛ ᎾᏍᎩ ᎤᏅᏒ ᎠᎾᏓᎸᏉᏗᏍᎩ; ᎾᏍᎩᏰᏃ ᎤᏅᏒ ᎠᎾᎸᏉᏗᏍᎩ; ᎾᏍᎩᏰᏃ ᎤᏅᏒ ᎨᏒ ᎤᏅᏒᏉ ᏄᎾᏍᏛ ᏓᎾᏓᏟᎶᏍᏗᏍᎬ, ᎠᎴ ᎤᏅᏒᏉ ᏄᎾᏍᏛ ᏓᎾᏓᏟᎶᏍᏗᏍᎬ, ᎠᎴ ᎤᏅᏒᏉ ᏓᎾᏓᏤᎳᏍᏗᏍᎬ ᎥᏝ ᏳᎾᏓᏅᏔ.


text:
ᎥᏝᏰᏃ ᏲᏥᎶᏒᏍᏗᎭ ᎣᎦᏟᎶᏒᎸᎢ, ᎾᏍᎩᏯ ᏂᎯ ᏗᏤᎲ ᏫᎦᏲᎩᎷᎯᏍᏗ ᏂᎨᏒᎾ ᏥᎨᏐ ᎢᏳᏍᏗ; ᏂᎯᏰᏃ ᎾᏍᏉ ᏗᏤᎲ ᎢᏴᏛ ᏬᎩᎷᏨ ᎣᏣᎵᏥᏙᎲᏍᎬ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ;


text:
ᏃᏣᏢᏈᏍᏗᏍᎬᎾ ᎠᏟᎶᎥ ᏙᏱᏗᏢ ᎨᏒᎢ, ᎾᏍᎩ ᎠᏂᏐᎢ ᏴᏫ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ; ᎤᏚᎩᏍᎩᏂ ᎣᎬᏒᎢ, ᎾᏍᎩ ᎢᏦᎯᏳᏒ ᎿᏉ ᎤᏁᏉᏨᎯ ᎨᏎᏍᏗ, ᏂᎯ ᏍᎩᏁᏉᎡᏗᏱ ᏍᎩᏍᏕᎸᏗᏱ ᏩᏍᏛ ᎢᏴᏛ ᎣᎦᏟᎶᎡᎸ ᏬᎩᎶᏒᏍᏙᏗᏱ,


text:
ᎩᎶᏰᏃ ᎢᏥᎷᏤᎯ ᏅᏩᏓᎴ ᏥᏌ ᎠᎵᏥᏙᎲᏍᎨᏍᏗ, ᎾᏍᎩ Ꮎ ᎠᏴ ᎣᏣᎵᏥᏙᏅᎯ ᏂᎨᏒᎾ, ᎢᏳ ᎠᎴ ᏅᏩᏓᎴ ᎠᏓᏅᏙ ᏙᏣᏓᏂᎸᏨᎭ, ᎾᏍᎩ Ꮎ ᏗᏣᏓᏂᎸᏨᎯ ᏂᎨᏒᎾ, ᎠᎴ ᏅᏩᏓᎴ ᎣᏍᏛ ᎧᏃᎮᏛ, ᎾᏍᎩ Ꮎ ᏗᏣᏓᏂᎸᏨᎯ ᏂᎨᏒᎾ, ᎣᏏᏳᏉ ᎤᏁᎳᎩ ᏱᏤᎵᏒ.


text:
ᎠᎴ ᎾᎯᏳ ᏥᏨᏰᎳᏗᏙᎲᎩ ᎠᎴ ᎠᏆᏚᎸᎲᎥᎦ, ᎥᏝ ᎩᎶ ᏯᏆᎫᏱᏍᎨᎢ; ᎾᏍᎩᏰᏃ ᎠᎩᏂᎬᏎᎲᎢ, ᎣᏣᎵᏅᏟ ᎹᏏᏙᏂ ᏅᏓᏳᏂᎶᏒᎯ ᎬᎩᏁᎲᎩ; ᎠᎴ ᏂᎦᎥᏉ ᎠᏆᏟᏂᎬᏁᎸ ᎢᏨᏐᏈᎸᏗᏱ ᏂᎨᏒᎾ, ᎠᎴ ᎠᏏᏉ ᎾᏍᎩ ᏂᎦᏛᏁᎮᏍᏗ.


text:
ᎠᏎᏃ ᏂᎦᏛᏁᎲ ᎾᏍᎩ ᏂᎦᎦᏛᏁᎮᏍᏗ, ᎾᏍᎩ ᎦᏥᏲᏍᏙᏓᏁᏗᏱ ᎤᎾᏜᏅᏓᏕᏗᏱ ᎾᏍᎩ ᎾᏍᎩ Ꮎ ᏧᎾᏚᎵᎭ ᎤᎾᏜᏅᏓᏕᏗᏱ; ᎾᏍᎩ ᎾᎿ ᎠᎾᏢᏈᏍᎬ ᎾᏍᎩ ᎠᏴ ᏃᎦᏍᏛ ᎾᏍᎩᏯ ᏄᎾᏍᏛ ᎬᏂᎨᏒ ᏱᏂᎦᎵᏍᏓ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎥᏝ ᎤᏣᏘ ᎤᏍᏆᏂᎪᏗᏳ ᏱᎩ ᎾᏍᏉ ᎾᏍᎩ ᏧᏅᏏᏓᏍᏗ ᏚᏳᎪᏛ ᎨᏒ ᎨᏥᏅᏏᏓᏍᏗ ᏯᎾᏤᎸᏍᎦ; ᎾᏍᎩ ᎤᎵᏍᏆᎸᏗ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎨᏒ ᎾᏍᎩᏯ ᏚᏂᎸᏫᏍᏓᏁᎸ ᎨᏎᏍᏗ.


text:
ᎤᏁᎳᎩᏰᏃ ᎢᏤᎵᏍᎪ ᎢᏳᏃ ᎩᎶ ᏱᏗᏥᎾᏢᏅ, ᎢᏳᏃ ᎩᎶ ᎠᏒᎭ ᏱᏂᏨᏁᎸ, ᎢᏳᏃ ᎩᎶ <n>[ᎪᎱᏍᏗ ᎢᏥᎲ]</n> ᏱᏥᎩᎡᎸ, ᎢᏳᏃ ᎩᎶ ᎤᏩᏒ ᏳᏓᎵᏌᎳᏓᏅ, ᎢᏳᏃ ᎩᎶ ᏕᏣᎧᏛ ᏱᏨᏂᎸ.


text:
ᏥᎪ ᎦᎶᏁᏛ ᏧᏅᏏᏓᏍᏗ ᎾᏍᎩ? (ᎤᏁᎫ ᎤᏁᎢᏍᏗ ᏥᏁᎦ,) ᎠᏴ ᎤᏟᎢ; ᏓᎩᎸᏫᏍᏓᏁᎲ ᎤᏟ ᎢᎦᎢ; ᎥᎩᎵᎥᏂᎸ ᎤᏟᎯᏳ ᎢᎦᎢ; ᏗᎦᏍᏚᏗᏱ ᎥᎩᏴᏔᏅᎢ ᎤᏟ ᎢᎦᎢ; ᎠᎩᏲᎱᏏᏕᎾ ᎨᏒ ᏯᏃᏉ;


text:
ᎨᏙᎲ ᏯᏃᏉ; ᎡᏉᏂ ᏕᎨᏴ ᎤᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ; ᏗᎾᏓᎾᏌᎲᏍᎩ ᎤᏂᎾᏴᎯᏍᏗᏳ ᎨᏒᎢ; ᏗᏆᏤᎵ ᏴᏫ ᎤᏂᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ; ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏂᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ; ᎦᏚᎲ ᎤᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ; ᎢᎾᎨ ᎨᏒ ᎤᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ; ᎠᎺᏉᎯ ᎤᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ; ᎤᎾᏠᎾᏍᏗ ᎣᏣᎵᏅᏟ ᎤᏂᎾᏰᎯᏍᏗᏳ ᎨᏒᎢ;


text:
ᏓᎩᏯᏪᏥᏙᎸ ᎠᎴ ᎡᎯᏍᏗ ᎾᎿᎵᏍᏓᏁᎸᎢ; ᏯᏃᎩᏳ ᏂᏥᎸᏍᎬᎾ ᎨᏒᎢ; ᎠᎪᏄ ᎠᎩᏲᏏᏍᎬᎢ ᎠᎴ ᎠᎩᏔᏕᎩᏍᎬᎢ; ᏯᏃᎩᏳ ᎠᎹᏟ ᎬᏍᎬᎢ; ᎤᏴᏢ ᎠᎴ ᎠᎩᏰᎸᎭ ᎨᏒᎢ.


text:
ᏥᎦᏔᎲᎩ ᎠᏍᎦᏯ ᎦᎶᏁᏛ ᎪᎯᏳᏍᎩ, ᎿᏉ ᏂᎦᏚ ᎾᏕᏘᏴ, (ᎠᏯᎥ ᎠᏰᎸ ᎥᏝ ᏱᏥᎦᏔᎭ, ᎠᎴ ᎠᏰᎸ ᎾᏯᎥᎾ ᎨᏒ ᎥᏝ ᏱᏥᎦᏔᎭ; ᎤᏁᎳᏅᎯ ᎠᎦᏔᎭ;) ᎾᏍᎩ ᎯᎠ ᎠᎦᏘᎾᏫᏛᎲᎩ ᏦᎢᏁ ᎦᎸᎶ ᏗᎨᏒ ᏩᎦᏘᏃᎸᎩ.


text:
ᎢᏳᏰᏃ ᏯᏆᏚᎵ ᎠᏆᏢᏈᏍᏗᏱ, ᎥᏝ ᎠᎩᏁ-Ꭻ ᏱᎦᎨᏎᏍᏗ; ᎤᏙᎯᏳᎯᏰᏃ ᎨᏒ ᏱᏥᏃᎲᎵ; ᎠᏎᏃ ᎤᏁᎳᎩ ᎥᎨᎳ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎩᎶ ᎠᏆᏓᏅᏖᏍᎬ ᎤᏟ ᏱᏂᎠᎩᎸᏉᏗ ᎠᏃ ᎾᏆᏍᏛ ᎠᎩᎪᏩᏘᏍᎬᎢ, ᎠᎴ ᏄᏍᏛ ᎠᏆᏛᎩᏍᎬᎢ.


text:
ᎾᏍᎩᏃ ᎤᎶᏒᏍᏔᏅᎯ ᎠᏆᎵᏌᎳᏙᏗᏱ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎤᏣᏘ ᎥᎩᎾᏄᎪᏫᏎᎸᎩ, ᎠᎩᎶᏲᎯᎯ ᎥᎩᏁᎸᎩ ᎠᎩᏇᏓᎸᎢ, ᏎᏓᏂ ᎤᏅᏏᏛ ᎠᏋᏂᎯ, ᎾᏍᎩ ᎤᎶᏒᏍᏔᏅᎯ ᎠᏆᎵᏌᎳᏙᏗᏱ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎬᏩᎦᏘᏯ ᎠᏆᏓᏙᎵᏍᏗ ᎨᏒ ᏰᎵᏉ ᎨᏣᎵᏍᏕᎸᏙᏗ; ᎠᏆᎵᏂᎬᎬᏰᏃ ᎤᎧᎵᏨᎯ ᎢᎬᏁᎸᎯ ᎾᎿ ᏩᎾᎦᎳ ᎨᏒᎢ. ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏣᏘ ᎠᏆᎵᎮᎵᏨᎯ ᎤᏟ ᎠᎩᏰᎸᎭ ᎠᏆᏢᏈᏍᏗᏱ ᏥᏩᎾᎦᎵᏳ ᎨᏒᎢ, ᎾᏍᎩ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎦᎶᏁᏛ ᎠᏊᏢᏙᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎦᎵᎡᎵᎦ ᏥᏩᎾᎦᎵᏳ ᎨᏒᎢ, ᎦᏴᎩᏐᏢᏛᎢ, ᎠᎩᏂᎩᏛ ᎨᏒᎢ, ᎤᏲ ᏅᏋᎿᏕᎬᎢ, ᎡᎯᏍᏗ ᎠᏆᏓᏅᏔᏩᏕᎬ ᎦᎶᏁᏛ ᏅᏗᎦᎵᏍᏙᏗᏍᎬᎢ; ᏥᏩᏂᎦᎵᏳᏰᏃ ᏥᎨᏐ, ᎾᎯᏳ ᎠᏆᎵᏂᎩᏗᏳ ᎨᏐᎢ.


text:
ᎠᎩᏁᎫ ᎾᏆᎵᏍᏔᏅ ᎦᏢᏆᏍᎬᎢ; ᏂᎯ ᏂᏍᎩᏴᏂᏌᏏ; ᏂᎯᏰᏃ ᏍᎩᎸᏉᏙᏗ ᎨᏒᎩ; ᎥᏝ ᏰᏃ ᏑᏓᎴᎩ ᎤᏅ ᎡᏍᎦ ᏱᎦᏥᏲᎠᏍᎦ ᏄᏂᎬᏫᏳᏒ ᎨᏥᏅᏏᏛ, ᎾᏍᏉ ᎠᏴ ᎪᎱᏍᏗ ᏂᎨᏒᎾ ᏱᎩ.


text:
ᎤᏙᎯᏳᎯᏯ ᎠᏙᎴᎰᎯᏍᏙᏗ ᎥᎩᏅᏏᏛ ᎨᏒ ᏗᎦᎸᏫᏍᏓᏁᎸᎯ ᏂᎦᎵᏍᏗᎭ ᎢᏤᎲᎢ, ᎬᏔᏅᎯ ᎤᏣᏘ ᎬᏂᏗᏳ ᎨᏒᎢ, ᎤᏰᎸᏛᎢ, ᎤᏍᏆᏂᎪᏗ ᏕᎦᎸᏫᏍᏓᏁᎸᎢ, ᎠᎴ ᎤᎵᏂᎩᏛ ᏕᎦᎸᏫᏍᏓᏁᎸᎢ.


text:
ᎦᏙᏃ ᎤᏍᏗ ᎾᏍᎩ ᎾᎿ ᎡᏍᎦ ᏕᏦᎭᏍᎦ ᏗᏐᎢ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒᎢ, ᎯᎠ ᎤᏩᏒ, ᎾᏍᎩ ᎠᏴ ᎠᏋᏒ ᎦᎨᏛ ᏂᏨ ᏴᏁᎸᎾ ᎨᏒᎢ? ᎨᏍᎩᎥᏏᏉ ᎠᏗᎾ ᎯᎠ ᎾᏍᎩ ᎤᏣᏘᏂ ᏂᏨᏯᏛᏁᎸᎢ.


text:
ᎬᏂᏳᏉ, ᏦᎢᏁ ᎠᏆᏛᏅᎢᏍᏗ ᏫᏨᎷᏤᏗᏱ; ᎥᏝ ᎠᎴ ᎦᎨᏛ ᏱᏅᎨᏨᏴᎦ; ᎥᏝᏰᏃ ᎪᎱᏍᏗ ᎢᏥᎲ ᏱᎩᏲᎭ, ᏂᎯᏍᎩᏂ ᎢᏨᏲᎭ; ᏗᏂᏲᎵᏰᏃ ᎥᏝ ᏧᏂᎦᏴᎵᎨ ᏧᎾᏓᏁᎳᏁᏗ ᏱᎩ, ᎠᏂᎦᏴᎵᎨᏍᎩᏂ ᏧᏁᏥ ᏧᎾᏓᏁᎳᏁᏗ ᎨᏐᎢ.


text:
ᎠᎴᏬ, ᏥᎪ ᎣᏣᎵᏍᏕᎵ ᎢᏤᎵᎭ ᎢᏥᎦᏔᎲᎢ? ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲ ᎣᏥᏁᎦ ᎦᎶᏁᏛ ᏧᏪᏲᏅᎯ ᎾᏍᎩᏯᎢ; ᎠᏎᏃ ᎢᏨᎨᏳᎢ, ᏂᎦᎥ ᏂᎯ ᎢᏣᎵᏂᎯᏍᏙᏗ ᎤᎬᏩᎵ <n>[ᎣᏥᏁᎦ.]</n>


text:
ᏥᎾᏰᏍᎦᏰᏃ ᎾᏍᎩ ᏫᏥᎷᏨᎭ ᎾᏍᎩ ᏂᏣᏍᏛᎾᏉ ᎨᏒ ᏄᏍᏛ ᎠᏆᏚᎵᏍᎬ ᎢᏨᏩᏛᏗᏱ, ᎠᎴ ᎠᏋᏒ ᎨᏒ ᏍᎩᎪᏩᏛᏗᏱ ᎾᏍᎩᏯ ᏂᏣᏚᎵᏍᎬᎾ ᎨᏒᎢ; ᎠᎴ ᎠᎩᏩᏛᏗᏱ ᏗᏘᏲᏍᏗ ᎨᏒᎢ, ᎠᏛᏰᎨᏗ ᎨᏒᎢ, ᎠᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᎠᏗᏒᏍᏗ ᎨᏒᎢ, ᎠᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᎠᏗᏒᏍᏗ ᎨᏒᎢ, ᎤᏲ ᏗᏓᏃᎮᎵᏓᏍᏗ ᎨᏒᎢ, ᎠᏙᏅᏗ ᎨᏒᎢ, ᎤᏟ ᎠᏤᎸᏗ ᎨᏒᎢ, ᏧᏓᎴᏅᏛ ᎢᎬᏁᏗ ᎨᏒᎢ;


text:
ᎠᎴ <n>[ᏥᎾᏰᏍᎦ.]</n> ᏔᎵᏁ ᏫᏥᎷᏨᎭ, ᎠᏆᏁᎳᏅᎯ ᎠᏆᏕᎰᎯᏍᏙᏗᏱ ᎢᏥᎦᏔᎲᎢ, ᎠᎴ ᎦᏥᏍᎪᏂᏍᏗᏱ ᎤᏂᏣᏘ ᎦᏳᎳ ᎤᏂᏍᎦᏅᏨᎯ ᏥᎩ, ᎠᎴ ᎤᏲ ᏄᏂᏰᎸᏅᎾ ᏥᎩ ᎦᏓᎭ ᏄᎾᏛᏁᎸᎢ, ᎠᎴ ᎤᏕᎵᏛ ᏚᎾᏂᏏᏅᎢ, ᎠᎴ ᎤᎾᎵᏐᏢᎢᏍᏔᏅᎢ.


text:
ᎦᏳᎳ ᎯᎠ ᎾᎩᏪᏒ, ᎠᎴ ᎢᎬᏱ ᎦᏰᎯ ᎯᎠ ᏂᏥᏪᎭ, ᏔᎵᏁ ᏥᏫᏥᎦᏔᎰ ᎾᏍᎩᏯᎢ, ᎠᎴ ᎠᎩᎪᏁᎸ ᎪᎯ ᎨᏒ ᎦᏥᏲᎳᏁᎭ ᎾᏍᎩ Ꮎ ᎦᏳᎳ ᎤᏂᏍᎦᏅᏨᎯ ᏥᎩ, ᎠᎴ ᏂᎦᏛᏉ ᎠᏂᏐᎢ, ᎾᏍᎩ ᎢᏳ ᏔᎵᏁ ᏱᏫᎠᎩᎷᏨ, ᎥᏝ ᏴᎦᎦᎵᏏᏅᏓ;


text:
ᎤᏙᎯᏳᎯᏍᎩᏂᏃᏅ ᎠᏩᎾᎦᎳᎯᏳ ᎨᏒ ᏓᏓᎾᏩᏍᏛ ᎠᎦᏛᏅᎩ, ᎠᏎᏃ ᎬᏃᏛ ᎢᏯᎬᏁᎸᎯ ᎬᏔᏅᎯ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎤᏁᎳᏅᎯ. ᎠᏴ ᎾᏍᏉ ᎾᏍᎩ ᎣᏥᏯᎥ ᏦᏥᏩᎾᎦᎳᎯᏳ, ᎠᏎᏃ ᎢᏧᎳᎭ ᏙᏨᏁᏍᏗ ᎾᏍᎩ, ᎤᏁᎳᏅᎯ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎢᏨᏴᏓᏁᎲ ᏂᎯ.


text:
ᎢᏣᏓᎪᎵᏯ ᎢᏨᏒ, ᎾᏍᎩ ᎢᏦᎯᏳᎯ ᏱᎩ, ᎠᎴ ᎢᏦᎯᏳᎯ ᏂᎨᏒᎾ ᏱᎩ; ᎢᏣᏙᎴᎰᎯ ᏂᏣᏍᏛᎢ. ᏝᏍᎪ ᎢᏨᏒ ᏱᏣᏓᎦᏔᎭ ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᎢᏥᏯᎥᎢ, ᎢᏳᏍᎩᏂᏃᏅ ᎡᏥᏐᏅᎢᏍᏔᏅᎯ ᏱᎩ.


text:
ᎤᏁᎳᏅᎯᏍᎩᏂ ᏥᏔᏲᏎᎭ ᎾᏍᎩ ᏂᎯ ᎪᎱᏍᏗ ᎤᏐᏅ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ ᏂᎨᏒᎾ; ᎥᏝ ᎠᏴ ᎣᏏᏳ ᎣᎩᏰᎸᏒ ᎬᏂᎨᏒ ᎢᏳᎵᏍᏙᏗᏱ ᎠᏆᏚᎵᏍᎬ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ, ᏂᎯᏍᎩᏂ ᎾᏍᎩ Ꮎ ᏚᏳᎪᏛ ᎨᏒ ᎢᏣᏛᏁᏗᏱ, ᎤᏁᎳᎩ ᎣᎩᏐᏅᎢᏍᏔᏅᎯ ᏱᏅᏩᏍᏗ.


text:
ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎯᎠ ᎾᏍᎩ ᏥᏄᏍᏗ ᏥᏨᏲᏪᎳᏁᎭ ᎠᎩᎪᏁᎸᎢ, ᎾᏍᎩ ᎾᎯᏳ ᏥᎦᏔᎮᏍᏗ ᎬᏍᎦᎢᏍᏓᎩ ᎠᏋᏔᏂᏓᏍᏗᏱ ᏂᎨᏒᎾ, ᎾᏍᎩᏯ ᎢᎬᏆᏛᏁᏗ ᎠᏆᎵᏍᎪᎸᏓᏁᎸ ᎤᎬᏫᏳᎯ, ᎾᏍᎩ ᏧᎾᎵᏂᎪᎯᏍᏗ ᎨᏒᎢ, ᎥᏝᏃ ᎤᏂᏛᏙᏗ ᎨᏒᎢ.


text:
ᎤᎵᏍᏆᎸᏗᏃ, ᎢᏓᎵᏅᏟ, ᏅᏩᏙᎯᏯᏛᏉ ᏂᏣᏛᎿᏕᎨᏍᏗ. ᎪᎱᏍᏗ ᏂᏥᎪᎸᎾ ᎨᏎᏍᏗ, ᎤᎦᎵᏍᏗᏉ ᏕᏣᏓᏅᏖᏍᏗ, ᎤᏠᏱᏉ ᎨᏎᏍᏗ ᏕᏣᏓᏅᏛᎢ, ᏅᏩᏙᎯᏯᏛᏉ ᎢᏤᎮᏍᏗ; ᎤᏁᎳᏅᎯᏃ ᎠᏓᎨᏳᏗ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏁᎯ ᏥᎩ, ᎢᏤᎳᏗᏙᎮᏍᏗ.


text:
ᏉᎳ, ᎥᎩᏅᏏᏛ, ᏴᏫ ᎬᎩᏅᏏᏛ ᏂᎨᏒᎾ, ᎠᎴ ᏴᏫ ᎬᎩᏁᏤᎸᎯ ᏂᎨᏒᎾ, ᏥᏌᏍᎩᏂ ᎦᎶᏁᏛ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨ ᎾᏍᎩ ᏧᎴᏔᏅᎯ ᏥᎩ ᎤᏲᎱᏒᎢ ᎾᏍᎩ ᎬᎩᏁᏤᎸᎯ;


text:
ᎢᏳᏍᎩᏂ ᎾᏍᏉ ᎠᏴ, ᎠᎴ ᏗᎧᎿᏩᏗᏙᎯ ᎦᎸᎳᏗ ᏅᏓᏳᎶᏒᎯ, ᏅᏩᏓᎴ ᎣᏍᏛ ᎧᏃᎮᏛ ᏱᏨᏯᎵᏥᏙᏁᎸ, ᎾᏍᎩ ᎦᏳᎳ ᎢᏨᏯᎵᏥᏙᏁᎸᎯ ᏂᎨᏒᎾ, ᎾᏍᎩ ᎠᏥᏍᎦᏨᎯ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎦᏳᎳ ᎢᏲᎩᏪᏛ ᏥᎩ, ᎤᏠᏱᏉ ᎯᎠ ᎪᎯ ᎨᏒ ᏂᏥᏪᎭ, ᎢᏳᏃ ᎩᎶ ᎢᏣᎵᏥᏙᏁᎮᏍᏗ ᏅᏩᏓᎴ ᎣᏍᏛ ᎧᏃᎮᏛ, ᎾᏃ ᎾᏍᎩ ᎦᏳᎳ ᏗᏣᏓᏂᎸᏨᎯ ᏥᎩ, ᎾᏍᎩ ᎠᏥᏍᎦᏨᎯ ᎨᏎᏍᏗ.


text:
ᎪᎯᏰᏃ ᎨᏒ ᏥᎪ ᏴᏫ ᏗᏆᎵᎢ ᏂᏕᎬᏁᎭ? ᎤᏁᎳᏅᎯᎨ? ᏥᎪᎨ ᎣᏍᏛ ᎤᏂᏰᎸᏗ ᏴᏫ ᎠᎩᏲᎭ? ᎢᏳᏰᏃ ᎣᏍᏛ ᎤᏂᏰᎸᏗ ᏴᏫ ᎠᏏ ᏯᎩᏲᎭ, ᎥᏝ ᎦᎶᏁᏛ ᎠᎩᏅᏏᏙᎯ ᏱᎦᎩ.


text:
ᎢᏣᏛᎦᏅᏰᏃ ᏄᏍᏛ ᏧᏩᎫᏔᏅᏒ ᎠᏆᎴᏂᏙᎸ ᎠᏂᏧᏏ ᏧᎾᏤᎵ ᏗᎧᎿᏩᏛᏍᏗ ᏕᏥᎦᎿᏩᏗᏒᎢ, ᎾᏍᎩ ᎤᎶᏒᏍᏔᏅᎯ ᎦᏥᏯᏕᏯᏙᏔᏅ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬᎢ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ, ᎠᎴ ᏕᏥᏛᏔᏅᎢ.


text:
ᎠᎴ ᎠᎩᏁᏉᏤᎲ ᎠᏂᏧᏏ ᏧᎾᏤᎵ ᏗᎧᎿᏩᏛᏍᏗ ᏥᎦᏙᎥᏍᎬᎢ ᏕᏥᎪᎾᏛᏛᎩ ᎤᏂᏣᏘ ᎢᏗᎦᏲᎦᏛᏅ ᏗᏆᏤᎵ ᏴᏫ, ᎤᏟ ᎢᎦᎢ ᎤᎵᏂᎩᏛ ᎠᏆᏓᏅᏛᎩ ᏓᏇᎷᎬᎩ ᏗᎩᎦᏴᎵᎨ ᎤᏂᏃᎮᎸᎯ.


text:
ᎾᏍᎩ ᎤᏪᏥ ᎠᎩᎾᏄᎪᏫᏎᏗᏱ, ᎾᏍᎩ ᎠᏴ ᎦᎵᏥᏙᎲᏍᎬ ᎬᏂᎨᏒ ᎢᏥᏴᏁᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏁᎲᎢ; ᎩᎳᏉ ᎢᏴᏛ, ᎥᏝ ᎤᏂᏇᏓᎵ ᎠᎴ ᎩᎬ ᎤᏂᏁᎯ ᏱᏗᎦᏥᏯᏁᎶᏔᏁᎢ;


text:
ᎠᎴ ᎬᏂᎨᏒ ᏅᏋᏁᎸᎢ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎠᏇᏅᏒᎩ, ᎠᎴ ᎬᏂᎨᏒ ᏂᎦᏥᏴᏁᎸ ᎣᏍᏛ ᎧᏃᎮᏛ ᎾᏍᎩ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎦᏥᏯᎵᏥᏙᏁᎲᎢ; ᎠᏂᏏᏴᏫᎭᏍᎩᏂ ᎤᏕᎵᏛ ᎬᏂᎨᏒ ᏂᎦᏥᏴᏁᎸᎩ ᏗᏂᏃᏣᎵ ᎨᏒᎢ, ᏯᏎᎦᎩ ᎠᏎᏉ ᏱᏙᏥᏍᏆᎸᏓ ᎠᎴ ᎠᏎᏉ ᏱᏓᎩᏍᏆᎸᏔᏅ ᎠᏇᎵᏒᎩ.


text:
ᎠᎴ ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎤᎾᏠᎾᏍᏗ ᎠᎾᎵᏅᏟ ᏄᏪᎵᏍᏛᎾ ᎨᏥᏴᏔᏂᎸᎯ, ᎾᏍᎩ ᏅᏕᎵᏛ ᎤᏂᏴᎵᎸ ᎤᏂᎨᏛᏗᏱ ᎣᎦᏓᏤᎵᎦᏯ ᎨᏒ ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ ᎣᎩᎲᎢ, ᏦᎩᎾᏝᎢ ᎢᎪᎬᏁᏗᏱ;


text:
Ꮎ-ᏍᎩᏂᏃ ᏰᎵ ᏗᏂᏃᏨᎵ ᎨᏒᎢ, ᎾᏍᎩ ᏄᎾᏍᏛᎢ ᎥᏝ ᎪᎱᏍᏗ ᎠᏋᏁᎯ ᏱᎩ, ᎤᏁᎳᏅᎯᏰᏃ ᎥᏝ ᏱᎦᎸᏉᏗᎭ ᎩᎶ ᏄᏍᏛᎢ; ᎾᏍᎩᏰᏃ ᏗᏂᏃᏣᎵ ᎨᏒ ᎥᏝ ᎪᎱᏍᏗ ᏱᎬᎩᏁᏉᎡᎴᎢ;


text:
Ꭰ-ᏍᎩᏂ ᎢᏗᏢ, ᎤᏂᎪᎲ ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᏂᏗᎨᏥᎤᏍᏕᏎᎸᎾ <n>[ᎤᎾᏛᎪᏗᏱ]</n> ᎠᏴ ᎥᏆᎨᏅᏛᎢ, ᎾᏍᎩᏯ ᏗᎨᏥᏅᏍᏕᏎᎸᎯ <n>[ᎤᎾᏛᎪᏗᏱ]</n> ᎣᏍᏛ ᎧᏃᎮᏛ ᏈᏓ ᏣᎦᎨᏅᏕᎢ;


text:
ᎠᎴ ᏥᎻ, ᎠᎴ ᏏᏆᏏ, ᎠᎴ ᏣᏂ, ᎾᏍᎩ ᏗᎵᎫᏍᏙ ᎨᏥᏰᎸᎢ, ᎤᏂᎪᎲ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎾᏍᎩ ᎥᎩᏁᎸᎢ, ᎠᏂᎦᏘᏏᏗᏢ ᏕᎪᎩᎾᏌᏕᏔᏅᎩ ᎠᏴ ᎠᎴ ᏆᏂᏆ ᎬᏂᎨᏒ ᎢᎬᏁᎯ ᏙᎦᏚᏓᏛᎢ; ᎠᏴᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏗᏁᎲ ᏬᎩᏂᎶᎯᏍᏗᏱ ᎤᎬᏩᎵ, ᎤᏅᏒᏃ ᏗᎨᏥᎤᏍᏕᏎᎴᎯ ᏗᏁᎲᎢ;


text:
ᎠᏏᏉᏰᏃ ᎩᎶ ᎢᏳᎾᏍᏗ ᏥᎻᏱ ᏅᏗᏂᎶᏍᎬᎾ ᎨᏒᎢ, ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎢᏧᎳᎭ ᎠᎾᎵᏍᏓᏴᎲᏍᎬᎩ; ᎠᏎᏃ ᎾᏍᎩ ᎤᏂᎷᏨ, ᎤᏓᏅᏒᎩ ᏚᏓᏓᎴᏓᏁᎸᎩ, ᏕᎦᎾᏰᏍᎬᎩ ᎾᏍᎩ ᏗᎨᏥᏅᏍᏕᏎᎸᎯ.


text:
ᎠᏎᏃ ᎠᎩᎪᎲ ᏂᏚᏳᎪᏛᎾ ᎾᎾᏛᏁᎲᎢ, ᎾᏍᎩᏯ ᏚᏳᎪᏛ ᏓᏕᏲᎲᏍᎬ ᎣᏍᏛ ᎧᏃᎮᏛ, ᏂᎦᏛ ᎠᏂᎦᏔᎲ ᎯᎠ ᏅᏥᏪᏎᎸᎩ ᏈᏓ, ᎢᏳᏃ ᏂᎯ, ᎯᏧᏏ ᏥᎩ, ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏄᎾᏍᏛ ᎾᏍᎩᏯ ᏱᏄᏍᏗ ᏰᎭ, ᎠᏂᏧᏏᏃ ᏄᏍᏛ ᎠᏁᎲ ᎾᏍᎩᏯ ᏄᏍᏛᎾ ᏱᎩ ᎮᎲᎢ, ᎦᏙᏃ ᎠᏂᏧᏏ ᏄᏍᏛ ᎠᏁᎲ ᎾᏍᎩᏯ ᎤᎾᏕᏗᏱ ᏥᏂᏕᎲᏁᎭ ᏧᎾᏓᎴᏅᏛ ᏴᏫ?


text:
ᏥᏗᎦᏔᎭᏍᎩᏂ ᎾᏍᎩ ᏴᏫ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᎾᏛᏁᎲ ᎾᏚᏓᎴᏍᏗᏍᎬᎾ ᎨᏒᎢ, ᎪᎯᏳᏗᏍᎩᏂ ᎨᏒ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎠᏴ ᎡᏙᎢᏳᏅ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎢᎦᏚᏓᎴᏍᏙᏗᏱ ᎪᎯᏳᏗ ᎨᏒ ᎦᎶᏁᏛ, ᎥᏝᏃ ᏗᎧᎿᏩᏛᏍᏗᏰᏃ ᏂᎦᏪᏍᎬ ᎾᏛᏁᎲ ᎥᏝ ᎩᎶ ᎤᏇᏓᎵ ᏴᎬᏚᏓᎴᏍᏓ.


text:
ᏓᏓᎿᏩᏍᏛ ᎢᏧᎳᎭ ᎦᎶᏁᏛ ᏙᎩᎾᏛᏅ; ᎠᏎᏃ ᎠᏴ ᎬᏃᏛ ᎢᎩ, ᎥᏝᏍᎩᏂᏃᏅ ᎿᏉ ᎠᏴ ᏱᎩ, ᎦᎶᏁᏛᏍᎩᏂ ᎬᏃᏛ ᎠᎩᏯᎠ; ᏄᏍᏛᏃ ᎿᏉ ᎦᎴᏂᏙᎲ ᎠᏂ ᎤᏇᏓᎵ ᎨᎥᎢ, ᎦᎴᏂᏙᎭ ᏥᏯᎵᏍᎦᏍᏙᏛ ᎤᏁᎳᏅᎯ ᎤᏪᏥ; ᎾᏍᎩ ᎠᎩᎨᏳᎯᏳ ᏥᎨᏒᎩ, ᎠᎴ ᎤᏩᏒ ᏥᏚᏓᏲᏎ ᎠᏴ ᎠᎩᏍᏕᎵᏍᎬᎢ.


text:
ᎢᏥᏁᎫ ᎨᎴᏏᏱ ᎢᏤᎯ, ᎦᎪ ᎢᏥᎶᎾᏍᎩᏔᏅ, ᎾᏍᎩ ᎢᏦᎯᏳᏗᏱ ᏂᎨᏒᎾ ᏂᏨᏁᎸ ᎤᏙᎯᏳᎯ ᎨᏒᎢ, ᏂᎯ ᏕᏥᎧᏅ ᏥᏌ ᎦᎶᏁᏛ ᎬᏂᎨᏒ ᎾᎬᏁᎸ ᏓᏓᎿᏩᏍᏛ ᎦᏛ ᎢᏤᎲᎢ.


text:
ᎾᏍᎩᏃ Ꮎ ᎠᏓᏅᏙ ᎢᏥᏁᎯ ᏥᎩ, ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᏧᎸᏫᏍᏓᏁᎯ ᏥᎩ ᎢᏤᎲᎢ, ᏥᎪ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᎾᏛᏁᎲ ᏅᏗᎦᎵᏍᏙᏗᎭ? ᏥᎪᎨ ᎤᏬᎯᏳᎯ ᎠᏛᎩᏍᎬ ᏅᏗᎦᎵᏍᏙᏗᎭ?


text:
ᎪᏪᎵᏃ ᎦᎸᏉᏗ ᎢᎬᏱ ᎦᏰᎯ ᏣᎪᏩᏘᏍᎨ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎪᎯᏳᏗ ᎬᏗ ᏙᏗᎫᏓᏏᏒ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎢᎬᏱ ᎦᏰᎯ ᎣᏍᏛ ᎧᏃᎮᏛ ᎬᏂᎨᏒ ᎾᎬᏁᎴ ᎡᏆᎭᎻ, ᎯᎠ ᎾᏥᏪᏎᎴᎢ, ᏂᎯ ᏅᏛᏂᏌᏂ ᏂᎦᏛ ᏴᏫ ᏓᏁᏩᏗᏒ ᎡᎳᏂᎬ ᎣᏍᏛ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎨᏎᏍᏗ.


text:
ᎾᏂᎥᏰᏃ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᎢᏯᏛᏁᏗᏱ ᎠᎾᎵᏍᎦᏍᏙᏗᏍᎩ, ᎾᏍᎩ ᎨᏥᏍᎦᏨᎯ; ᎯᎠᏰᏃ ᏂᎬᏅ ᎢᎬᏪᎳ, ᎨᏥᏍᎦᏨᎯ ᎨᏎᏍᏗ ᎾᏂᎥ ᎩᎶ ᏂᏓᏂᎧᎿᏩᏕᎬᎾ ᎢᎨᏎᏍᏗ ᎾᎾᏛᏁᎲ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᏗᎧᎿᏩᏛᏍᏗᏱ ᎪᏪᎸᎢ.


text:
ᎠᎴ ᎡᏆᎭᎻ ᎠᎴ ᎾᏍᎩ ᎤᏁᏢᏔᏅᏛ ᎨᏒ ᏧᏓᎴᏅᏛ ᎨᏥᏚᎢᏍᏓᏁᎴᎢ. ᎥᏝ ᎯᎠ ᏱᏂᎦᏪᎭ, ᎠᎴ ᏂᎯ ᏗᏣᏁᏢᏔᏅᎯ, ᎢᎸᏍᎩ ᏥᎨᏐ ᎾᏍᎩᏯᎢ; ᏌᏉᏉᏍᎩᏂ ᏥᎨᏐ ᎾᏍᎩᏯ, ᎯᎠ ᏂᎦᏪᏎ,]</n> ᎠᎴ ᏂᎯ ᏣᏁᏢᏔᏅᎯ; ᎾᏍᎩ ᎦᎶᏁᏛ ᏥᎩ.


text:
ᎠᎴ ᎯᎠ ᎾᏍᎩ ᏂᏥᏪᎭ, ᎾᏍᎩ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᎦᎶᏁᏛ ᎤᎬᏩᎵ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎦᏳᎳ ᎬᏩᏍᏓᏱᏛᎯ ᏥᎨᏎᎢ, ᏗᎧᎿᏩᏛᏍᏗ ᏅᎩᏧᏈ ᏦᎠᏍᎪᎯ ᏫᏄᏕᏘᏴᎲ ᎣᏂ ᎦᎾᏄᎪᏫᏒᎯ ᏥᎩ, ᎥᏝ ᎬᏩᏲᏍᏙᏗ ᏱᎩ, ᎾᏍᎩ ᏰᎵ ᎠᏎᏉ ᎢᏳᏩᏁᏗᏱ ᎠᏚᎢᏍᏛᎢ.


text:
ᎪᏙᏃ ᎬᏙᏗ ᏗᎧᎿᏩᏛᏍᏗ? ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏫᎫᏓᏔᏅᎯ ᎨᏎᎢ, ᎾᏍᎩ ᎤᏁᏢᏔᏅᎯ ᎠᏥᏚᎢᏍᏓᏁᎸᎯ ᎨᏒ ᎤᎾᏄᎪᎢᏍᏗ ᎨᏒ ᎬᏗᏍᎩ; <n>[ᎠᎴ ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ]</n> ᏗᏂᎧᎿᏩᏗᏙᎯ ᎣᏍᏛ ᏄᏅᎿᏕᎨ ᎾᏍᎩ ᏧᏒᎦᎴ ᎠᏰᎵ ᏁᎴᏁᎯ.


text:
ᏗᎧᎿᏩᏛᏍᏗᎪᏃ ᏓᏡᏗᎭ ᎤᏁᎳᏅᎯ ᏚᏚᎢᏍᏔᏅᎢ? ᎬᏩᏟᏍᏗ, ᎢᏳᏰᏃ ᏗᎧᎿᏩᏛᏍᏗ ᏴᏫ ᎨᏥᏁᎸᎯ ᏱᎨᏎ, ᎾᏍᎩ ᏰᎵ ᎬᏂᏛ ᎬᏩᏓᏁᏗ ᎨᏒᎢ, ᎤᏙᎯᏳᎯᏯ ᏗᎧᎿᏩᏛᏍᏗ ᎠᎲ ᎠᏚᏓᎴᏍᏗ ᎨᏒ ᏴᏗᏓᎴᎲᏍᎨᎢ.


text:
ᎠᏎᏃ ᎪᎯ ᏥᎩ, ᎿᏉ ᎡᏥᎦᏙᎥᏒᎯ ᏥᎩ ᎤᏁᎳᏅᎯ, ᎠᎴ ᏯᏛᏅ ᎤᏁᎳᏅᎯ ᎢᏥᎦᏙᎥᏒᎯ ᏥᎩ, ᎦᏙ ᏗᎦᎵᏍᏙᏗᎭ ᎢᏣᏨᎭ ᏙᏣᎵᏍᎦᏍᏙᏗᎭ ᎠᏩᎾᎦᎳ ᎠᎴ ᎤᏲ ᎢᏳᏛᎿᏕᎩ ᏗᎴᏅᏙᏗ ᏗᏕᎶᏆᏍᏗ, ᎾᏍᎩ ᎠᏏ ᎾᎿ ᏥᏣᏚᎵ ᏤᏥᎾᏝ ᏔᎵᏁ ᎢᏣᎵᏍᏙᏗᏱ?


text:
ᎠᎴ ᏥᎬᎵᏲᎬ ᎾᏍᎩ ᎠᎩᏇᏓᎸ ᏣᏇᎲᎩ, ᎥᏝ ᏅᎵᏌᎵ ᏱᏥᏰᎸᏁᎢ, ᎠᎴ ᎥᏝ ᏱᏥᏲᎢᏎᎴᎢ; ᏕᏍᎩᏯᏓᏂᎸᏨᎩᏍᎩᏂ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎾᏍᎩᏯᎢ, ᎠᎴ ᎦᎶᏁᏛ ᏥᏌ ᎾᏍᎩᏯᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᏓᏟᎶᏍᏗ; ᎯᎠᏰᏃ ᎾᏍᎩ ᏔᎵ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᏓᏟᎶᏍᏗ; ᏌᏉ ᎨᏒ ᏌᎾᏱ ᎣᏓᎸ ᏨᏗᏓᎴᎲᏍᎦ, ᎾᏍᎩ ᏥᏕᎦᎾᏄᎪᏫᏍᎦ ᏗᎨᏥᎾᏢᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎮᎦ ᏥᏓᏟᎶᏍᏗ.


text:
ᎯᎠᏰᏃ ᏂᎬᏅ ᎢᎪᏪᎳ, ᎭᎵᎮᎵᎩ ᏔᎷᎸᎥᏍᎩ ᏂᎨᏒᎾ, ᎾᏍᎩ ᏂᏔᏓᎾᏄᎪᏫᏍᎬᎾ; ᎭᎴᏅ ᎮᎷᎲᎦ, ᏂᎯ ᏂᏘᎾᏄᎪᏫᏍᎬᎾ; ᎾᏰᏃ, ᎾᏥᏰᎲᎾ ᎤᏟ ᎾᏂᎥ ᏚᏪᎧᎭ ᏧᏪᏥ ᎡᏍᎦᏉ Ꮎ ᎠᏥᏰᎯ.


text:
ᎠᏎᏃ ᎦᏙ ᎠᏗᎭ ᎪᏪᎵ? ᎯᏄᎪᏩ ᎠᏥᎾᏝᎢ ᎠᎨᏴ ᎠᎴ ᎾᏍᎩ ᎤᏪᏥ; ᎠᏥᎾᏝᎢᏰᏃ ᎠᎨᏴ ᎤᏪᏥ, ᎥᏝ ᎤᏪᎳᏗᏍᏙᏗ ᏱᎨᏎᏍᏗ ᎤᏤᎵ ᎢᏳᎵᏍᏙᏗ ᎨᏒ ᎾᏥᎾᏝᎥᎾ ᎠᎨᏴ ᎤᏪᏥ.


text:
ᎦᎶᏁᏛᏰᏃ ᏥᏌ ᎤᏤᎵ ᏗᎧᎿᏩᏛᏍᏗ ᎨᏒ ᎠᎱᏍᏕᏍᏗ ᎨᏒ ᎥᏝ ᎪᎱᏍᏗ ᎬᏙᏗ ᏱᎩ, ᎠᎴ ᎠᎱᏍᏕᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ; ᎪᎯᏳᏗᏍᎩᏂ ᎨᏒ ᎾᏍᎩ ᎠᏓᎨᏳᏗ ᎨᏒ ᏧᏮᏗᏗᏐ ᏚᎸᏫᏍᏓᏁᎲᎢ.


text:
ᏂᎯᏰᏃ, ᎢᏓᎵᏅᏟ, ᎡᏥᏯᏅᏛ ᎢᏣᏓᏤᎵ ᎢᏣᎵᏍᏙᏗᏱ; ᎠᏗᎾ ᏞᏍᏗ ᎾᏍᎩ ᎢᏣᏓᏤᎵ ᎨᏒ ᏱᏨᏗᏍᎨᏍᏗ ᎾᏍᎩ ᎤᏇᏓᎵ ᎤᏚᎸᎲᎥᏍᎬ ᎢᏣᏛᏁᏗᏱ ᏥᏥᎳᏅᏓᏕᎶ ᎾᏍᎩᏯᎢ; ᎠᏓᎨᏳᏗᏍᎩᏂ ᎢᏨᏗᏍᎬ ᎣᏍᏛ ᏂᏕᏣᏓᏛᏁᎮᏍᏗ.


text:
ᎤᏇᏓᎵᏰᏃ ᎤᏚᎵᏍᎬ ᏓᎦᏘᎴᎪ ᎠᏓᏅᏙ, ᎠᎴ ᎠᏓᏅᏙ ᎤᏚᎵᏍᎬ ᏓᎦᏘᎴᎪ ᎤᏇᏓᎵ; ᎾᏍᎩᏃ ᎯᎠ ᏗᎾᏓᏡᏗᏍᎩ ᏂᎦᎵᏍᏗᎭ; ᎾᏍᎩᏃ ᏂᎦᎵᏍᏙᏗᎭ ᏄᏍᏛ ᎢᏣᏚᎵᏍᎬ ᎥᏝ ᏱᏅᎨᏣᏛᎦ.


text:
ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᏓᏙᎵᏍᏓᏁᏗ ᎨᏒᎢ, ᎠᏓᏅᏙ ᎨᏒᎢ, ᎠᏓᏓᏈᏍᏗ ᎨᏒᎢ, ᏗᏗᏲᏍᏗ ᎨᏒᎢ, ᏗᏓᏛᏳᏤᏗ ᎨᏒᎢ, ᎠᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᏓᏓᏐᎮᏗ ᎨᏒᎢ, ᏔᎵ ᎢᏯᏓᏗᏍᏗ ᎨᏒᎢ, ᎤᎾᏓᏤᎵᏛ ᎨᏒᎢ,


text:
ᎠᏛᏳᎨᏗ ᎨᏒᎢ, ᏗᏓᎯᏍᏗ ᎨᏒᎢ, ᎤᏓᏴᏍᏕᏍᏗ ᎨᏒᎢ, ᏧᏂᏴᏍᏕᏍᎩ ᏧᏂᎳᏫᎢᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗᏓᏂ; ᎯᎠ ᎾᏍᎩ ᎦᏳᎳ ᏂᏨᏃᏁᎭ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎢᏨᏃᏁᎸᎯ ᏥᎩ ᏧᏩᏓᏔᏅᏒᎢ, Ꮎ ᎾᏍᎩ ᎢᏯᎾᏛᏁᎯ ᎥᏝ ᎤᎾᏤᎵ ᏱᏅᎦᎵᏍᏓ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ.


text:
ᎢᏓᎵᏅᏟ, ᎢᏳᏃ ᎩᎶ ᏳᏎᎦᏤᎸ ᏳᏍᎦᏅᏨ, ᏂᎯ ᎠᏓᏅᏙ ᏗᏣᏘᏂᏙᎯ ᎡᏥᏯᏂᏐᏗ ᎨᏎᏍᏗ ᎾᏍᎩ ᎢᏳᏛᏁᎸᎯ ᎤᏓᏙᎵᏍᏗ ᎢᏣᏓᏅᏛᎢ, ᎮᏯᏔᎮᏍᏗ ᏨᏒ ᎨᏒ ᏱᏅᏎᎦᎩ ᏂᎯ ᎾᏍᏉ ᏰᏣᎪᎵᏯ.


text:
ᎾᏍᎩᏰᏃ Ꮎ ᎤᏩᏒ ᎤᏇᏓᎵ ᎠᏫᏍᎨᏍᏗ, ᎾᏍᎩ ᎤᏇᏓᎵ ᎤᎾᏄᎪᏫᏒᎯ ᎠᏲᎩ ᎦᏟᏏᏍᎨᏍᏗ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᎠᏓᏅᏙᎩᎯ ᎠᏫᏍᎨᏍᏗ, ᎾᏍᎩ ᎠᎦᏅᏙ ᎤᎾᏄᎪᏫᏒᎯ ᎬᏂᏛ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎦᏟᏏᏍᎨᏍᏗ.


text:
ᎾᏂᎥ ᎤᎾᏚᎵᏍᎩ ᎣᏍᏛ ᎢᏳᎵᏍᏙᏗᏱ ᏗᎨᎦᎦᏅᏗᏱ ᎤᏇᏓᎵ ᎨᏒᎢ, ᎾᏍᎩ ᎠᏎ ᏤᏥᎤᏍᏕᏎᏗᏱ ᏂᎨᏨᏁᎰᎢ; ᏄᎾᏚᎵᏍᎬᎾ ᎨᏒ ᎢᏳᏍᏗ ᎨᏥᎩᎵᏲᎢᏍᏙᏗᏱ ᎤᏂᏍᏛᏗᏍᏗᏱ ᎦᎶᏁᏛ ᎤᏤᎵ ᏓᏓᎿᏩᏍᏛᎢ.


text:
ᎠᏎᏃ ᎬᏩᏟᏍᏗ ᎪᎱᏍᏗ ᎠᏆᏢᏈᏍᏙᏗᏱ ᎤᏩᏒᏍᎩᏂᏃᏅ ᏓᏓᎿᏩᏍᏛ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎤᏤᎵᎦ, ᎾᏍᎩ ᏥᏅᏗᎦᎵᏍᏙᏗᎭ, ᎾᏍᎩ ᎡᎶᎯ ᏓᏓᎿᏩᏍᏛ ᎠᎦᏛᏅᎯ ᏥᎩ ᎠᏴ ᎨᏒ ᎢᏗᏢ,ᎠᎴ ᎠᏴ ᎥᏆᏛᏅᎯ ᏥᎩ ᎡᎶᎯ ᎨᏒ ᎢᏗᏢ.


text:
ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ ᎤᏁᎳᏅᎯ ᎠᎴ ᎤᏙᏓ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏅᎯ ᎣᏍᏛ ᎢᎦᏛᏁᎸᎯ ᏥᎩ, ᎢᎩᏁᎸᎯ ᏂᎦᎥ ᎣᏍᏛ ᎨᏒ ᎠᏓᏅᏙ ᎤᎬᏩᎵ, ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᏦᏒ ᎡᎯ ᎤᎬᏩᎵ.


text:
ᎾᏍᎩᏯ ᎢᎦᏑᏰᏒ ᎾᏍᎩ Ꮎ ᎠᎬᏗᏍᎬᎢ ᎠᏏ ᎡᎶᎯ ᎾᏙᏢᏍᎬᎾ ᎨᏒᎢ, ᎾᏍᎩ ᏂᏗᏍᎦᏅᎾ ᎢᎦᎵᏍᏙᏗᏱ, ᎠᎴ ᎪᎱᏍᏗ ᏁᎫᎢᏍᏛᎾ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏍᎩ ᎠᎦᏔᎲ ᎠᏓᎨᏳᏗ ᎨᏒ ᎢᏛᏗᏍᎬᎢ;


text:
ᎾᏍᎩ ᎾᏍᏉ ᏥᏅᏗᎦᎵᏍᏙᏗ ᎡᎦᎵᏍᎪᎸᏓᏁᎸᎯ ᏥᎩ ᎢᎦᏤᎵ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ, ᎡᎦᏑᏰᏛ ᏥᎩ ᎾᏍᎩᏯ ᏄᏍᏛ ᎤᏓᏅᏖᎸᎢ, ᎾᏍᎩ Ꮎ ᏥᏑᎸᏫᏍᏓᏁᎭ ᏂᎦᎥ ᏧᏓᎴᏅᏛ ᎾᏍᎩᏯ ᎤᏩᏒ ᎤᏓᏅᏛ ᏚᏭᎪᏔᏂᎸᎢ;


text:
ᎾᏍᎩ ᏂᎯ ᎾᏍᏉ <n>[ᏤᏣᎵᏍᎦᏍᏙᏔᏅᎩ]</n> ᎿᏉ ᎢᏣᏛᎦᏅ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎧᏃᎮᏛ, ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎢᏣᎵᏍᏕᎸᏙᏗ ᏥᎩ; ᎾᏍᎩ ᎾᏍᏉ ᎡᏦᎢᏳᏅ, ᎿᏉ ᎢᏥᏰᎸᏔᏅᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎾᏍᎩ ᎠᏚᎢᏍᏔᏅᎯ ᎨᏒᎢ,


text:
ᎾᏍᎩ ᎤᏁᎳᏅᎯ, ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᎵᎦ, ᎠᎦᏴᎵᎨ ᎦᎸᏉᏗᏳ ᏥᎩ, ᎾᏍᎩ ᎢᏥᏁᏗᏱ ᎠᏓᏅᏙ ᎠᎦᏙᎥᎯᏍᏙᏗ ᎠᎴ ᎠᏓᎾᏄᎪᏫᏎᎯ, ᎾᏍᎩ ᎤᏩᏒ ᎡᏥᎦᏙᎥᎯᏍᏗᏱ;


text:
ᎾᏍᎩ Ꮎ ᎢᏦᎵᏍᏙᏗ ᎨᏒ ᏓᎧᏅᎢᎦ ᏤᏣᏗᏍᏓᏁᏗᏱ; ᎾᏍᎩ ᎢᏥᎦᏙᎥᎯᏍᏗᏱ ᏄᏍᏛ ᎤᏚᎩ ᎬᏗ ᎨᏒ, ᎾᏍᎩ ᎤᏓᏯᏅᏗ ᎨᏒᎢ, ᎠᎴ ᏂᎦᎥ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᎾᏓᏅᏘ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗ ᎨᏒ ᎾᏍᎩ ᏧᏁᏗ ᏥᎩ,


text:
ᎤᏟ ᎦᎸᎳᏗᏳ ᎡᏍᎦᏉ ᎾᏂᎥ ᏗᎨᎦᏁᎶᏗ ᎨᏒᎢ, ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎨᎦᎨᏅᏴ ᎨᏒᎢ, ᎠᎴ ᎤᏂᎬᏫᏳᏎᏕᎩ ᎨᏒᎢ, ᎠᎴ ᎾᏂᎥ ᏚᎾᏙᎠᏗᏒ ᏗᎪᎥᎯ ᏥᎩ, ᎥᏝ ᎠᏂᏉ ᎤᏩᏒ ᎪᎯ ᏥᎩ, ᎾᏍᏉᏍᎩᏂ ᎾᎿ Ꮒ ᎠᏏ ᎤᎵᏰᎢᎶᎯᏍᏗ ᏥᎩ,


text:
ᎾᎿᏂ ᏧᏩᎫᏔᏅᏒ ᎢᏤᏙᎸᎢ ᎾᏍᎩᏯ ᎢᏳᎾᏛᏁᏗ ᎨᏒ ᎡᎶᎲ ᎠᏁᎯ, ᎾᏍᎩᏯ <n>[ᎤᏚᎵᏍᎬ]</n> ᎦᏃᎴᏍᎬ ᎡᎯ ᎡᎬᏫᏳᏌᏕᎩ, ᎾᏍᎩ ᎠᏓᏅᏙ ᎪᎯ ᎨᏒ ᏥᏚᎸᏫᏍᏓᏁ ᏚᎾᏓᏅᏛ ᎪᎯᏳᏗ ᏂᎨᏒᎾ ᎨᏒ ᏧᏪᏥ;


text:
ᎾᏍᎩ ᎾᏍᏉ ᏧᏩᎫᏔᏅᏒ ᏂᏗᎥ ᎨᏓᎵᎪᏁᎲᎩ ᎾᎿ ᎢᎩᏇᏓᎸ ᎤᎬᎥᏍᎬᎢ, ᎠᎴ ᎤᏇᏓᎸ ᎠᎴ ᎠᏓᏅᏖᏗ ᎨᏒ ᎤᎾᏚᎵᏍᎬ ᏂᏓᏛᏁᎲᎩ; ᎠᎴ ᏗᎦᏕᏅ ᏂᎦᏍᏛ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᏧᏪᏥ ᎨᏒᎩ, ᎾᏍᎩᏯᏉ ᎠᏂᏐᎢ ᏄᎾᏍᏛᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏣᏅᏖᏍᏗ ᎾᏍᎩ ᏂᎯ ᏧᏩᎫᏔᏅᏒ ᏗᏣᏓᎴᏅᏛ ᏴᏫ ᎤᏇᏓᎵ ᎨᏒᎢ, ᏂᏗᎨᏥᎤᏍᏕᏎᎸᎾ ᎨᏦᏎᎸᎯ ᎾᏍᎩ Ꮎ ᏗᎨᏥᎤᏍᏕᏎᎸᎯ ᎨᎪᏎᎯ ᏥᎩ, ᎾᏍᎩ ᎤᏇᏓᎸ ᏗᎨᏥᎤᏍᏕᏎᎸᎯ ᏗᎪᏱ ᏗᎬᏔᏅᎯ;


text:
ᎾᏍᎩ ᎾᎯᏳ ᏥᎨᏎ ᎦᎶᏁᏛ ᏂᏤᎲᎾ ᎨᏎᎢ, ᏂᏤᎸᎾᏉ ᎨᏎ ᎢᏏᎵ ᎠᏰᎵ ᎤᏃᏢᏒᎢ, ᎠᎴ ᎢᏥᎪᏁᎳ ᎨᏎ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᎠᏚᎢᏍᏛᎢ, ᎤᏚᎩ ᏂᏨᏒᎾ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏂᏤᎲᎾ ᎨᏎ ᎠᏂ ᎡᎶᎯ.


text:
ᎤᏇᏓᎸ ᎬᏗᏍᎬ ᎤᏛᏔᏅ ᏗᏓᏓᏍᎦᎩ ᎢᎬᏁᎯ, ᎾᏍᎩ ᏯᏛᏅ ᏗᎧᎿᏩᏛᏍᏗ ᎤᎵᏁᏨᎢ ᏧᏓᎴᏅᏛ ᎢᏯᏛᏁᎵᏓᏍᏗ ᎨᏒᎢ; ᎾᏍᎩ ᎠᏂᏔᎵ ᎨᏒ ᏌᏉ ᎢᏤ ᏴᏫ ᎤᏬᏢᏗᏱ ᎤᏩᏒ ᎢᏳᏩᏂᏐᏗᏱ, ᎾᏍᎩᏃ ᏙᎯ ᎢᏳᏩᏁᏗᏱ;


text:
ᎾᏍᎩ (ᎧᏃᎮᏍᎩ) ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᏠᏱᏉ ᎤᎾᏤᎵ ᏂᎨᎬᏁᎲᎢ, ᎠᎴ ᎾᏍᎩᏉ ᎠᏰᎵ ᎠᏁᎯ ᎨᏒᎢ, ᎠᎴ ᎦᎶᏁᏛ ᎠᎬᏗᏍᎬ ᎤᏚᎢᏍᏔᏅ ᎤᏁᎳᏗᏍᏗᏍᎬᎢ, ᎣᏍᏛ ᎧᏃᎮᏛ ᎬᏔᏅᎯ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ;


text:
ᎾᏍᎩ ᎾᎿ ᎠᏴ ᏗᎩᎸᏫᏍᏓᏁᎯ ᎠᏴᏋᏁᎸᎯ ᏥᎩ, ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎴᏍᏗ ᎨᏒ ᎥᏆᎵᏍᎪᎸᏓᏁᎸᎯ ᏥᎩ ᎬᏩᏄᎸᏗ ᏂᎨᏒᎾ ᎨᏒ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎢᏳᏩᏂᏌᏛ.


text:
ᎠᏴ ᏭᏓᎪᎾᏛᏛ ᎠᏆᏍᏗᎧᏂ ᏥᎩ ᎾᏂᎥ ᎤᎾᏓᏅᏘ ᎨᏒ, ᎯᎠ ᎾᏍᎩ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎥᎩᏁᎸ, ᎾᏍᎩ ᎤᎬᏩᎸᎩ ᎠᏆᎵᏥᏙᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎠᏁᎲ ᎬᎪᎵᏰᏗ ᏂᎨᏒᎾ ᎤᏪᎿᎢᏳ ᎨᏒ ᎦᎶᏁᏛ;


text:
ᎠᎴ ᎾᏂᎥ ᏴᏫ ᎬᏂᎨᏒ ᎢᎦᏥᏴᏁᏗᏱ ᏄᏍᏛ ᎾᏍᎩ ᎤᏕᎵᏛ ᎨᏒᎢ, ᎾᏍᎩ ᏗᏓᎴᏂᏍᎬ ᎡᎶᎯ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎬᏍᎦᎳᏅᎯ ᏥᎩ ᎤᏁᎳᏅᎯ ᎡᎲᎢ, ᎾᏍᎩ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎤᏬᏢᏅᏅᎯ ᏥᎩ ᏥᏌ ᎦᎶᏁᏛ ᎠᎬᏗᏍᎬᎢ;


text:
ᎤᎬᏩᎸᎩ ᎾᏍᎩ ᎪᎯ ᎨᏥᎸᏉᏗ ᎨᏒ ᎠᎴ ᏧᎾᎵᏂᎩᏛ ᎨᏒ ᎦᎸᎳᏗᏳ ᏕᎨᏌᏗᏒᎢ, ᎤᏂᎦᏙᎥᎯᏍᏗᏱ ᎤᏣᏘ ᎢᏳᏓᎴᎩ ᎠᎦᏙᎥᎯᏍᏙᏗ ᎨᏒ ᎤᏁᎳᏅᎯ, ᎨᎬᏗᏍᎬ ᏧᎾᏁᏟᏗ ᎤᎾᏓᏡᎬᎢ;


text:
ᎾᏍᎩ ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᎿᏉ ᏗᏗᏲᎵ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎢᎩᏃᎸᏔᏂᏓᏍᏗᏱ ᏂᎨᏒᎾ ᏂᎦᎥᏉ ᏗᏕᏲᏗ ᎨᏒ ᎦᏃᎸᏔᏂᏙᎲᎢ, ᎤᎾᏓᎵᏓᏍᏗᏳ ᎨᏒ ᏴᏫ, ᎠᏂᏏᎾᏌᏅ ᎠᏂᎦᏘᏴ ᎤᎾᏓᎶᏄᎮᏗᏱ;


text:
ᏚᏳᎪᏛᏍᎩᏂ ᎧᏁᎢᏍᏗ ᎨᏒ ᎢᏛᏗᏍᎬ ᎠᏓᎨᏳᏗ ᎨᏒ ᏔᎵ ᎢᏛᏗᏍᎬᎢ, ᏗᎦᏛᎯᏍᏗᏱ ᎾᏍᎩ ᏂᎦᎥ ᏄᏓᎴᏒ ᎾᏍᎩ ᏗᎦᏚᏓᏕᏫᏍᏗᏱ ᎾᏍᎩ ᎠᏍᎪᎵ ᏥᎩ, ᎾᏍᎩ ᎦᎶᏁᏛ;


text:
ᎾᏍᎩ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ ᏂᎬ ᎠᏰᎸ ᎣᏍᏛ ᏗᏙᎵᎩ ᏥᎩ, ᎠᎴ ᏥᏚᏚᏓᏕᏫᏍᏗ ᏂᎦᎥ ᏚᎯᏢᎾᎥ ᏥᏚᎵᏍᏕᎸᏙᏗ, ᎾᏍᎩᏯ ᎠᏟᎶᎥ ᏧᎸᏫᏍᏓᏁᏗᏱ ᏧᏓᏤᎵᏛ ᏕᎨᏌᏗᏒᎢ, ᎧᏁᏉᏍᎪ ᎠᏰᎸᎢ, ᎠᏓᎵᏂᎪᎯᏍᏗᏍᎪ ᎤᏩᏒ ᎠᏓᎨᏳᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏂᏥᏪᎭ, ᎠᎴ ᎢᏨᏁᏤᎭ ᎤᎬᏫᏳᎯ ᏚᏙᎥ ᎬᏗᎭ, ᎾᏍᎩ ᏂᎯ ᎪᎯ ᎢᏳᏓᎴᏅᏛ ᎢᏤᎲ ᏞᏍᏗ ᎠᏂᏐᎢ ᏧᎾᏓᎴᏅᏛ ᎠᏁᎲ ᎾᏍᎩᏯ ᏱᏄᏍᏕᏍᏗ, ᎾᏍᎩ ᎤᏁᎫᎯᏳ ᎨᏒ ᏚᎾᏓᏅᏛ ᎠᏂᏍᏓᏩᏗᏒᎢ,


text:
ᎤᏃᎵᏍᏗᏱ ᏧᎾᎵᏏᎲᏎᎸᎯ, ᎤᎾᏞᏛ ᎾᎿ ᎤᏁᎳᏅᎯ ᎣᏏᏳ ᎤᏰᎸᏗ ᎨᏒ ᎠᎴᏂᏓᏍᏗᏱ, ᎾᏍᎩ ᎾᏂᎦᏔᎾᎥᎾ ᎨᏒ ᎢᏳᏩᏂᏌᏛ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᏧᏂᎾᏫ ᏗᏍᏓᏱᏳ ᎨᏒᎢ.


text:
ᎤᏃᏍᎩᏛᏃ ᎨᏒ ᏞᏍᏗ ᎿᏉ ᏳᏃᏍᎩᏎᏍᏗ; ᏚᎸᏫᏍᏓᏁᎮᏍᏗᏉᏍᎩᏂ ᏕᎬᏗᏍᎨᏍᏗ ᏧᏬᏰᏂ ᎣᏍᏛ ᎨᏒ ᎾᏛᏁᎮᏍᏗ, ᎾᏍᎩ ᎦᎬᏩᏁᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏍᎩ ᎤᏂᎬᏎᎯ ᎨᏒᎢ.


text:
ᏞᏍᏗ ᎰᎱᏍᏗ ᎤᏲ ᎦᏬᏂᎯᏍᏗ ᎨᏒ ᏅᏓᏳᏄᎪᏨᎩ ᏗᏥᎰᎵ, ᎣᏍᏛᏍᎩᏂ ᎨᏒ ᎤᏩᏒ ᎾᏍᎩ ᎬᏩᏓᎵᏂᎪᎯᏍᏙᏗ ᏥᎩ, ᎾᏍᎩ ᎤᏚᎸᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᎬᏩᎦᏘᎠ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᏂᎷᏤᏗᏱ ᎠᎾᏛᎩᏍᎩ.


text:
ᏂᎦᎥ ᎠᏓᏂᏆᏗᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎧᎾᎸᎢᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏍᏓᏯ ᎦᏬᏂᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᎿᎸᎯ ᎦᏬᏂᎯᏍᏗ ᎨᏒᎢ, ᎢᏴᏛ ᎢᎬᏁᏗ ᎨᏎᏍᏗ ᎢᏤᎲᎢ, ᎤᎵᏠᏯᏍᏕᏍᏗ ᏂᎦᎥ ᎤᏐᏅ ᎨᏒᎢ;


text:
ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒ ᎬᏂᎨᏒ ᏂᏨᏁᎮᏍᏗ ᎢᏤᎲᎢ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎦᎶᏁᏛ ᎢᎩᎨᏳᎯᏳ ᏥᎨᏒᎩ, ᎠᎴ ᏥᏕᎦᏓᏲᎯᏎᎸᎩ, ᎠᎵᏍᎪᎸᏓᏁᏗ ᎠᎴ ᎠᏥᎸ ᎨᎴᏗ ᏥᏄᎵᏍᏔᏅ ᎤᏁᎳᏅᎯ ᎤᎦᎾᏍᏛ ᎤᏪᏩᏒᎢᏍᏗ.


text:
ᎡᏕᎵᏛᏍᎩᏂ ᏗᏂᏏᏗ ᎨᏒᎢ, ᎠᎴ ᏄᏓᎴᏒᏉ ᎦᏓᎭ ᎨᏒᎢ, ᎠᎴ ᏧᎬᏩᎶᏗ ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ, ᏞᏍᏗ ᎧᏁᎢᏍᏙᏗ ᎤᏅᏱᎨᏎᏍᏗ ᎢᏤᎲᎢ, ᎾᏍᎩ ᏧᏂᎵᎶᎲᏍᎦ ᎤᎾᏓᏅᏘ;


text:
ᏞᏍᏗ ᎠᎴ ᎪᎱᏍᏗ ᎤᏁᎢᎸᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎵᏍᎦᏁᏛ ᎦᏬᏂᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎦᏪᏢᏗ ᎨᏒᎢ, ᎾᏍᎩ ᏃᏒᎾ ᏥᎩ; ᎠᎵᎮᎵᏤᏗᏱᏉᏍᎩᏂ <n>[ᎤᏁᎳᏅᎯ]</n> ᎤᎬᏫᏳᏎᏍᏗ.


text:
ᎯᎠᏰᏃ ᎾᏍᎩ ᎢᏥᎦᏔᎭ, ᎾᏍᎩ ᎩᎶ ᎤᏕᎵᏛ ᏗᏂᏏᎲᏍᎩ, ᎠᎴ ᎠᎦᏓᎭᎢ, ᎠᎴ ᏧᎬᏩᎶᏗ ᎤᎬᎥᏍᎩ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎠᏰᎸᎯ ᎠᏓᏙᎵᏍᏓᏁᎯ ᎨᏒᎢ, ᎤᏤᎵ ᎢᏳᎵᏍᏙᏗ ᏂᎨᏒᎾ ᎨᏒ ᎦᎶᏁᏛ ᎤᏤᎵᎪᎯ ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ.


text:
ᏞᏍᏗ ᎩᎶ ᎢᏥᎶᏄᎮᏔᏅᎩ ᎪᎱᏍᏗ ᎬᏙᏗ ᏂᎨᏒᎾ ᎦᏬᏂᎯᏍᏗ ᎨᏒᎢ; ᎾᏍᎩᏰᏃ ᎯᎠ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏁᎳᏅᎯ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏂᎷᏤᎭ ᎪᎯᏳᏗ ᏂᎨᏒᎾ ᎨᏒ ᏧᏪᏥ.


text:
ᏕᏣᎵᏃᎮᏍᎨᏍᏗ ᏕᏨᏗᏍᎨᏍᏗ ᎤᏁᎳᏅᎯ ᏗᎧᏃᎩᏍᏙᏗ, ᎠᎴ ᎦᎸᏉᏙᏗ ᏗᎧᏃᎩᏍᏗ, ᎠᎴ ᎠᏓᏅᏙ ᎤᎬᏩᎵ ᏗᎧᏃᎩᏍᏗ, ᏕᏥᏃᎩᏍᎨᏍᏗ ᏙᏗᏣᏓᏅᏛ ᏗᏓᎴᎲᏍᎨᏍᏗ ᎤᎬᏫᏳᎯ ᏕᏥᏃᎩᏍᏗᏍᎨᏍᏗ.


text:
ᎾᏍᎩ ᎤᏩᏒ ᎠᎦᏔᎲ ᎤᏪᎪᏗᏱ ᏗᎬᏩᎸᏌᏛ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬᎢ, ᏄᏚᏯᏍᏛᎾ, ᎠᎴ ᏄᏓᏁᎪᏳᏒᎾ, ᎠᎴ ᏂᎦᎥ ᎪᎱᏍᏗ ᎾᏍᎩ ᎢᏳᏍᏗ ᏄᏓᏓᎸᎾ; ᎾᏍᎦᏅᎾᏍᎩᏂ ᎢᏳᎵᏍᏙᏗᏱ ᎠᎴ ᎪᎱᏍᏗ ᎾᎫᎢᏍᏛᎾ.


text:
ᎡᏥᏅᏏᏓᏍᏗ, ᏕᏦᎯᏳᏎᏍᏗ ᎾᏍᎩ ᎨᏥᏅᏏᏙᎯ ᎠᏂ ᎤᏇᏓᎵ, ᎨᏒᎢ, ᎢᏥᎾᏰᏍᎨᏍᏗ ᎠᎴ ᏕᏥᎾᏫᏍᎨᏍᏗ, ᎣᏏᏳ ᎢᏥᏰᎸᎯ ᎨᏎᏍᏗ ᏗᏥᎾᏫᏱ, ᎦᎶᏁᏛ ᏥᏁᏣᏛᏁᎰ ᎾᏍᎩᏯᎢ.


text:
ᎠᎴ ᏂᎯ ᏗᏣᏓᏅᏏᏙᎯ, ᎾᏍᎩᏯ ᎤᏠᏱ ᎾᏍᎩ ᏂᏕᏣᏛᏁᎮᏍᏗ, ᎤᏁᎳᎩ ᎢᏤᎵᏎᏍᏗ ᏕᏥᏣᏛᏁᎮᏍᏗ, ᎤᏁᎳᎩ ᎢᏤᎵᏎᏍᏗ ᏕᏥᎾᏰᏓᏁᎲᎢ, ᏥᏥᎦᏔᎭ ᎾᏍᎩ ᏂᎯ ᎾᏍᏉ ᎢᏥᏅᏏᏙᎯ ᎦᎸᏬᎢ ᎡᎲᎢ; ᎥᏝ ᎠᎴ ᏱᏚᏑᏰᏍᏗ ᏴᏫ ᏗᎬᏩᎸᏉᏙᏗ ᎨᏒᎢ.


text:
ᎥᏝᏰᏃ ᏱᏗᎦᏟᏴᎭ ᎤᏇᏓᎵ ᎨᏒ ᎠᎴ ᎩᎬ, ᎤᏂᎬᏫᏳᎯᏍᎩᏂ, ᎠᎴ ᏧᎾᎵᏂᎩᏛ, ᎠᎴ ᏄᏂᎬᏫᏳᏌᏕᎩ ᎠᏂᎡᎶᎯ ᎤᎵᏏᎩ ᎨᏒᎢ, ᏗᏓᏅᏙ ᎤᏂᏁᎫᏥᏛ ᎦᎸᎶ ᏄᎾᏛᎿᏕᎬᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏣᎩ ᏂᎦᏛ ᎠᎵ ᏍᎦᏍᏙᏙ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᏰᎵ ᏗᎨᏣᏟᏴᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎾᎯᏳ ᎤᏲᎢᏳ ᎢᎦ ᎨᏎᏍᏗ, ᎾᏍᎩᏃ ᏂᎦᏛ ᎢᏣᏛᏁᎸᎯ ᎨᏎᏍᏗ, ᎨᏣᎴᏗ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᏂᎪᎯᎸ ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ ᏄᏓᎴᏒ ᎠᏓᏙᎵᏍᏗ ᎨᏒ, ᎠᎴ ᎠᏔᏲᏍᏗ ᎨᏒ ᎠᏓᏅᏙ ᎬᏗ, ᎠᎴ ᎢᏥᏯᏫᏍᎨᏍᏗ ᎾᎿᏂ ᎢᏨᏗᏍᎨᏍᏗ ᏗᏯᏪᎢᏍᏗ ᏂᎨᏒᎾ, ᎠᎴ ᎠᏔᏲᏍᏗ ᎨᏒ ᎨᏥᏍᏕᎸᏗᏱ ᎤᎾᏓᏅᏘ ᎾᏂᎥᎢ.


text:
ᎾᏍᎩᏃ ᎢᏥᎦᏙᎥᎯᏍᏗᏱ ᎾᏍᏉ ᎠᏴ ᎾᏆᎵᏍᏓᏁᎵᏕᎬ ᎠᎴ ᎾᏆᏛᎿᏕᎬᎢ, ᏗᎩᎦ, ᎣᏥᎨᏳᎢ ᎣᏣᎵᏅᏟ ᎠᎴ ᎣᏍᏛ ᎢᏯᏛᏁᎯ ᏧᎸᏫᏍᏓᏁᎯ ᎤᎬᏫᏳᎯ ᎤᏤᎵ ᎤᎬᏩᎵ, ᎬᏂᎨᏒ ᏅᏓᏨᏁᎵ ᏄᏓᎴᏒ ᎪᎱᏍᏗ;


text:
ᎯᎠ ᎾᏍᎩ ᏑᏓᎴᎩ ᎨᏒ ᎾᏆᏜᏏᏛᎡᎲᎾ, ᎾᏍᎩ Ꮎ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎤᎴᏅᏛ ᏙᏗᏣᏓᏅᏛᎢ ᎾᏍᎩ ᎤᏰᎢᎸᏍᏗᏱ ᎬᎵᏍᏆᏗᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᎤᏤᎵ ᎢᎦ ᎠᎵᏰᎵᎢᎶᎸ ᎬᏗᏍᎩ;


text:
ᎾᏍᎩ ᏥᏚᏳᎪᏗ ᎾᏍᎩ ᎢᏨᏰᎵᏎᏗᏱ ᏂᏥᎥᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎠᎩᎾᏫᏱ ᎢᏨᏍᏆᏂᎪᏛᎢ; ᎾᏍᏉᏰᏃ ᎥᏆᎸᎢᏛ ᎨᏒᎢ, ᎠᎴ ᏥᏍᏕᎵᏍᎬ ᎠᎴ ᏥᏍᏓᏱᏗᏍᎬ ᎣᏍᏛ ᎧᏃᎮᏛ ᏂᎯ ᏂᏥᎥ ᎢᏤᎳᏗᏍᏗᎭ ᎬᏩᎦᏘᏯ ᎥᎩᏙᎵᎬᎢ.


text:
ᎾᏍᎩ ᎢᏥᎧᎵᏨᎯ ᎢᏳᎵᏍᏙᏗᏱ ᏚᏳᎪᏛ ᎨᏒ ᎤᏓᎴᏅᎯ, ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏐᏗᏱ, ᎾᏍᎩ ᎤᎸᏉᏙᏗᏱ ᎤᏁᎳᏅᎯ ᎠᎴ ᎬᏂᎨᏒ ᎢᏳᏩᏁᏗᏱ ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎨᏒᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᏑᎾᏓᎴᎩ ᎨᏒ ᎠᎾᎵᏥᏙᎲᏍᎦ ᎦᎶᏁᏛ ᎠᏂᏃᎮᎭ ᎠᏗᏒᏍᏗᏉ ᎨᏒ ᎤᎾᏚᎵᏍᎬ ᏅᏗᎦᎵᏍᏙᏗᎭ, ᎥᏝᏃ ᏄᎾᏠᎾᏍᏛᎾ ᎨᏒ ᏯᏅᏗᎭ, ᎤᏂᏁᏉᏍᏗᏱ ᎤᏂᏰᎸᎭ ᏥᎩᎵᏲᎬ ᎥᏆᎸᎢᏛ ᎨᏒᎢ.


text:
ᎾᏍᎩᏯ ᎤᏣᏘ ᎠᏆᏚᎵᏍᎬ ᎠᎴ ᎤᏚᎩ ᎠᏋᏒᎢ, ᎾᏍᎩ ᏂᎦᎥ ᎪᎱᏍᏗ ᎠᏆᏕᎰᎯᏍᏗᏱ ᏂᎨᏒᎾ, ᏂᎦᎥᏉᏍᎩᏂ ᏂᏥᏍᎦᎢᎲᎾ ᎨᏒᎢ, ᏥᏄᏍᏙᏉ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎪᎯ, ᎦᎶᏁᏛ ᏥᎸᏉᏙᏗ ᎨᏎᏍᏗ ᏥᏰᎸ ᎬᏗ, ᎾᏍᏉ ᎬᏃᏛ ᎨᏒ ᎠᎴ ᎠᎩᏲᎱᎯᏍᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩᏯ ᎠᏗᎾ ᎦᎶᏁᏛ ᎣᏍᏛ ᎧᏃᎮᏛ ᏧᎵᎶᎲᏍᎦ ᏂᏣᏛᏁᎴᏙᎮᏍᏗ; ᎾᏍᎩ ᎢᏳᏃ ᏱᏫᏨᎷᏤᎸ ᎠᎴ ᏱᏫᏨᎪᎥ, ᎠᎴ ᏯᎩᎪᏁᎸᏉ, ᏱᎦᏛᎬᎦ ᏂᏣᏛᎿᏕᎬᎢ, ᎤᎵᏂᎩᏛ ᏕᏥᏙᎬ ᏌᏉ ᎠᏓᏅᏙᎩᎯ, ᏌᏉ ᎠᏓᏅᏖᏗ ᎬᏗ, ᎠᏤᏉᎶᎯ ᎢᏣᏟᏂᎬᏁᏗᏱ ᎢᏥᏍᏕᎸᏗᏱ ᎪᎯᏳᏗ ᎨᏒ ᎣᏍᏛ ᎧᏃᎮᏛ.


text:
ᎠᎴ ᏞᏍᏗ ᎪᎱᏍᏗ ᎠᎾᏛᏁᎲ ᎨᏣᏈᏗᏍᎩ ᏱᏥᏍᎦᏍᏓᏁᎮᏍᏗ; ᎾᏍᎩ ᎬᏂᎨᏒ ᎢᏳᏅᏁᎯ ᎨᏥᏛᏙᏗ ᎨᏒᎢ, ᏂᎯᏍᎩᏂ ᎬᏂᎨᏒ ᎢᏨᏁᎯ ᎡᏥᏍᏕᎸᏗ ᎨᏒᎢ, ᎠᎴ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎢᏥᏍᏕᎸᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᎦᎶᏁᏛᏱ ᎤᎦᎵᏍᏗ ᏅᏓᎬᏩᏓᎴᏗ ᎨᏎᏍᏗ, ᎢᏳᏃ ᎠᏓᎨᏳᏗ ᎨᏒ ᎠᏓᏄᏬᎯᏍᏗᏍᎩ ᎬᏩᏓᏁᏗ ᎨᏎᏍᏗ, ᎢᏳᏃ ᎬᏖᏉᎶᏗ ᎨᏎᏍᏗ ᎠᏓᏅᏙ ᎥᏓᏘᏁᏗ ᎨᏒᎢ, ᎢᏳᏃ ᎠᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᎤᏓᏅᏘ ᎨᏒ ᎡᎮᏍᏗ,


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏨᎨᏳᎢ, ᏂᎪᎯᎸᏉ ᏥᏦᎯᏳᎲᏍᎪᎢ, ᎥᏝ ᎠᏴ ᏥᎦᏔᎲᏉ ᎢᏳᏍᏗ, ᎪᎯᏍᎩᏂ ᎨᏒ ᎠᎩᎪᏁᎸᎢ ᎤᏟ ᎢᎦᎢ ᏗᏥᎸᏫᏍᏓᏏ ᎡᏥᏍᏕᎸᏗᏱ ᎨᏒᎢ, ᎢᏥᎾᏰᏍᎬ ᎠᎴ ᏕᏥᎾᏫᏍᎬᎢ;


text:
ᎾᏍᎩ ᏁᏥᎳᏫᏎᎲᎾ ᎠᎴ ᏂᏣᏠᎾᏍᏛᎾ ᎨᏎᏍᏗ, ᎤᏁᎳᏅᎯ ᏧᏪᏥ, ᎦᏰᏧᎢᏍᏙᏗ ᏂᎨᏒᎾ, ᎢᏣᏓᏑᏴ ᎤᎾᏓᏥᏃᏍᏆᏰᏛ ᎠᎴ ᎤᎾᎪᎸᏛ ᏴᏫ ᎠᏁᎲᎢ, ᎾᏍᎩ ᎾᎿ ᎠᏁᎲ ᏕᏥᎸᏌᏓᏗᎭ ᎡᎶᎯ ᎢᎦ ᏗᏣᏘᏍᏓᏁᎯ ᎾᏍᎩᏯᎢ;


text:
ᎢᏥᎾᏄᎪᏫᏍᎨᏍᏗ ᎧᏃᎮᏛ ᎬᏂᏛ ᎠᏓᏁᎯ; ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᎠᏆᎵᎮᎵᏍᏗᏱ ᎦᎶᏁᏛ ᎤᏤᎵ ᎢᎦ ᎨᏎᏍᏗ, ᎾᏍᎩ ᎠᏎᏉ ᏗᎩᏍᏆᎸᏔᏅᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᎴ ᎠᏎᏉ ᏗᎩᎸᏫᏍᏓᏁᎸᎯ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎠᏗᎾ ᎠᏎ ᏱᏥᏅᏒ ᎠᏇᎵᏒ ᎢᏆ&apos;ᎶᏓᏔ ᏫᏥᎷᏤᏗᏱ, ᎾᏍᎩ ᎠᎩᏅᏟ ᎠᎴ ᎣᎩᎾᏖᏆᎶᎯ ᏙᎩᏂᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᎣᎩᎾᎵᎪᎯ ᎣᏍᏗᏯᏫᏍᎩ, ᏂᎯᏍᎩᏂ ᎡᏥᏅᏏᏛ, ᎠᎴ ᎾᏍᎩ ᎠᎩᏍᏕᎸᏛ ᎠᎩᏩᏛᏗᏱ ᎠᎩᏂᎪᎯᏎᎲᎢ.


text:
ᎤᏙᎯᏳᎯᏰᏃ ᎤᏢᎬᎩ ᎠᎴ ᎠᎴᏉ ᏄᏲᎱᏒᎩ; ᎠᏎᏃ ᎤᏁᎳᏅᎯ ᎤᏪᏙᎵᏨᎩ; ᎥᏝ ᎠᎴ ᎾᏍᎩᏉ ᎤᏩᏒ, ᎠᏴᏍᎩᏂ ᎾᏍᏉ, ᎾᏍᎩ ᎤᎶᏏᎶᏛ ᎤᏲ ᎠᏆᏓᏅᏓᏗᏍᏗᏱ ᏂᎨᏒᎾ.


text:
ᎤᎵᏍᏆᎸᏗᏃ ᎨᏒ ᎢᏓᎵᏅᏟ, ᎢᏣᎵᎮᎵᎩ ᎤᎬᏫᏳᎯ ᎨᏒ ᎢᏳᏍᏗ. ᎯᎠ ᎾᏍᎩ ᏫᏨᏲᏪᎳᏁᏗᏱ, ᎤᏙᎯᏳᎯ ᎥᏝ ᏧᏯᏪᎢᏍᏗ ᏯᎩᏰᎸᎭ ᎠᏴ, ᏂᎯᏍᎩᏂ ᎤᎾᏰᎯᏍᏗ ᎨᏒ ᎢᏧᏓᎴᏍᎩ.


text:
ᎠᏴᏰᏃ ᏤᎩᎤᏍᏕᏎᎸᎯ, ᎤᏁᎳᏅᎯ ᎠᏓᏅᏙ ᎬᏗ ᎡᏓᏓᏙᎵᏍᏓᏁᎯ ᏥᎩ, ᎠᎴ ᎢᏓᎵᎮᎵᎩ ᎦᎶᏁᏛ ᏥᏌ ᎡᏓᎵᏍᎦᏍᏙᏛ ᎢᏳᏍᏗ, ᎠᎴ ᎤᏇᏓᎵ ᎨᏒ ᏂᎦᎵᏍᎦᏍᏙᏛᎾ ᏥᎩ.


text:
ᎾᏍᏉᏍᎩᏂᏃᏅ ᎠᏴ ᎠᎩᎭ ᎤᏇᏓᎵ ᎨᏒ ᎬᏆᎵᏍᎦᏍᏙᏙᏗ ᎨᏒᎢ. ᎢᏳᏃ ᎩᎶ ᏰᎵ ᏳᎭ ᏳᏰᎸ ᎤᏇᏓᎵ ᎨᏒ ᎬᏩᎵᏍᎦᏍᏙᏙᏗ ᎨᏒᎢ, ᎠᏴ ᎤᏟ ᎢᎦᎢ <n>[ᎠᎩᎭ;]</n>


text:
ᎤᎵᏂᏛᏃ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒ ᎤᎬᏩᎵ, ᏕᏥᎩᎵᏲᎢᏍᏗᏍᎬᎩ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᎬᎢ; ᏚᏳᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ ᎤᎬᏩᎵ ᏗᎧᎿᏩᏛᏍᏗ ᏕᏥᎧᎿᏩᏗᏒᎢ, ᎦᏴᎩᎳᏫᏎᏗ ᏂᎨᏒᎾ ᎨᏒᎩ.


text:
ᎥᎥ, ᎤᏙᎯᏳᎯ, ᎠᎴ ᏂᎦᎥᏉ ᎪᎱᏍᏗ ᎡᏍᎦ ᎢᏯᏋᏁᎯ ᎠᎩᏰᎸᎭ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏓᎪᎾᏛᏔᏅᎯ ᎨᏒ ᏥᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎦᎶᏁᏛ ᏥᏌ ᎠᏆᏤᎵ ᎤᎬᏫᏳᎯ; ᎾᏍᎩ ᏥᏅᏗᎦᎵᏍᏙᏗᎭ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎠᎩᏲᎱᏎᎸᎯ ᏥᎩ, ᎠᎴ ᎤᏁᎢᎸᏗᏉ ᎠᎩᏰᎸᎭ ᎾᏍᎩ, ᎦᎶᏁᏛ ᎾᏍᎩ ᎠᏆᏤᎵ ᎢᏣᏴᏁᏗᏱ,


text:
ᎠᎴ ᎾᏍᎩ ᏕᏥᏯᏁᎶᏛ ᎥᎩᏩᏛᏗᏱ, ᎠᏆᏚᏓᎴᏍᏙᏗ ᎠᏋᏒ ᎠᏆᏤᎵ ᎾᎩᎲᎾ ᎨᏒᎢ, ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎬᏩᏓᏁᏗ ᏥᎩ, Ꮎ-ᏍᎩᏂ ᎦᎶᏁᏛ ᎪᎯᏳᏗ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ, ᎾᏍᎩ ᎠᏚᏓᎴᏍᏙᏗ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ, ᎾᏍᎩ ᎠᏚᏓᎴᏍᏙᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᏥᎩ, ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᎬᏙᏗ ᏥᎩ.


text:
ᎥᏝᏍᎩᏂᏃᏅ ᎦᏳᎳ ᏥᏓᎩᏂᏴᏐ ᎾᏍᎩᏯ ᏯᎩᏰᎸᎭ, ᎥᏝ ᎠᎴ ᎠᎩᏍᏆᏛᎯ ᎦᏳᎳ ᏯᎩᏰᎸᎭ; ᏥᏍᏓᏩᏕᎦᏍᎩᏂ, ᎢᏳ ᏰᎵ ᏱᎩ, ᎾᏍᎩ ᏗᎩᏂᏴᏗᏱ ᎾᏍᎩ ᎾᏍᏉ ᎤᎬᏩᎵ ᎦᎶᏁᏛ ᏥᏌ ᏥᏓᎩᏂᏴᎲᎩ.


text:
ᎢᏓᎵᏅᏟ, ᎥᏝ ᎦᏳᎳ ᎠᎩᏂᏴᏛ ᏍᎩᏰᎸᎭ; ᏑᏓᎴᎩᏍᎩᏂ <n>[ᏂᎦᏛᏁᎰᎢ;]</n> ᎠᏋᎨᏫᏍᎪᎢ ᏧᏓᎴᏅᏛ ᎣᏂᏗᏢ ᏄᏍᏗᏕᎬᎢ, ᎢᎬᏱᏗᏢᏃ ᏧᏓᎴᏅᏛ ᏄᏍᏗᏕᎬ ᏫᏗᏥᏂᏱᏍᎪᎢ,


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎠᏴ ᏂᏗᎥ ᎢᎩᏍᏆᏛᎯ ᎨᏒᎢ, ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᎢᎦᏓᏅᏖᏍᏗ; ᎠᎴ ᎢᏳ ᎪᎱᏍᏗ ᎨᏒ ᏅᏩᏓᎴ ᏄᏍᏕᏍᏗ ᏙᏣᏓᏅᏖᏍᏗ, ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎯᎠ ᎾᏍᏉ ᎬᏂᎨᏒ ᏅᏓᏨᏁᎵ.


text:
ᎾᏍᎩ ᏗᎩᏁᏟᏴᎡᏗ ᏥᎩ ᏂᏗᎦᎸᏉᏛᎾ ᏗᏗᏰᎸᎢ, ᎾᏍᎩᏯ ᎢᏧᏩᏁᏗᏱ ᎤᏩᏒ ᎦᎸᏉᏗᏳ ᎠᏰᎸ ᏄᏍᏛᎢ, ᎾᏍᎩᏯ ᎤᎵᏂᎬᎬ ᎬᏗᏍᎬ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎤᏩᏒ ᏗᎬᏩᏁᎶᏙᏗᏱ ᎢᏳᏩᏁᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏓᎵᏅᏟ ᎢᏨᎨᏳᎢ ᎠᎴ ᎤᏣᏘ ᎢᏨᏯᏅᏘ, ᏍᎩᏯᎵᎡᎵᏍᏗᏍᎩ ᎠᎴ ᎠᏆᎵᏍᏚᎶᏙᏗ, ᏅᏩᏍᏕᏍᏗ ᎤᎵᏂᎩᏛ ᏕᏥᏙᎨᏍᏗ ᎤᎬᏫᏳᎯ ᎡᏣᎵᏍᎦᏍᏙᏛᎢ, ᎢᏨᎨᏳᎢ.


text:
ᎠᎴ ᎬᏍᏗᏰᏗᎭ ᎾᏍᏉ ᏂᎯ ᏂᏣᏠᎾᏍᏛᎾ ᎬᎩ Ꮎ ᏖᏆᎶᎯ, ᎬᎩ ᏍᏕᎸᏗᏱ Ꮎ ᎠᏂᎨᏴ ᎬᎩᏍᏕᎸᎯᏙᎸᎯ ᏓᎩᎸᏫᏍᏓᏁᎸ ᎦᎵᏥᏙᏂᏙᎲ ᎣᏍᏛ ᎧᏃᎮᏛ, ᎯᏯᏠᏯᏍᏔᏅᎭ ᎾᏍᏉ ᏞᎻᎾ ᎠᎴ ᎠᏂᏐᎢ ᎤᏠᏱ ᏦᎩᎸᏫᏍᏓᏁᎯ, ᎾᏍᎩ ᏚᎾᏙᎥ ᏥᏕᎪᏪᎳ ᎬᏂᏛ ᎠᏓᏁᎯ ᎪᏪᎵᎯ.


text:
ᏞᏍᏗ ᎪᎱᏍᏗ ᏱᏤᎵᎯᏍᎨᏍᏗ; ᏄᏓᎴᏒᏍᎩᏂ ᎪᎱᏍᏗ ᎠᏓᏙᎵᏍᏙᏗ ᎠᎴ ᎠᏔᏲᏍᏗ ᎨᏒ ᎬᏗ ᎠᎵᎮᎵᏍᏗ ᎬᏩᎵᏠᏯᏍᏗ, ᎬᏂᎨᏒ ᏁᏨᏁᎮᏍᏗ ᎤᏁᎳᏅᎯ ᏄᏍᏛ ᎢᏣᏚᎵᏍᎬᎢ;


text:
ᎤᎵᏍᏆᎸᏗᏃ ᎨᏒᎢ ᎠᏓᎵᏅᏟ, ᏂᎦᎥ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏂᎦᎥ ᎦᎸᏉᏙᏗ ᎨᏒᎢ, ᏂᎦᎥ ᏚᏳᎪᏛ ᎨᏒᎢ, ᏂᎦᎥ ᎦᏓᎭ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏂᎦᎥ ᎣᏏᏳ ᎬᏰᎸᏗ ᎨᏒᎢ, ᏂᎦᎥ ᎣᏏᏳ ᎠᏂᏃᎮᏍᎨᏍᏗ; ᎢᏳᏃ ᎣᏏᏳ ᎢᏯᏛᏁᏗ ᏰᎭ, ᎢᏳᏃ ᎪᎱᏍᏗ ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ, ᎾᏍᎩ ᏕᏣᏓᏅᏖᏍᎨᏍᏗ.


text:
ᎾᏍᎩ ᎫᏓᎴᏅᏛ ᏍᎩᏯᏕᎶᏆᎸᎯ ᎨᏒᎢ, ᎠᎴ ᏗᏍᎩᏯᏓᏂᎸᏤᎸᎯ ᎨᏒᎢ, ᎠᎴ ᏍᎩᏯᏛᎦᏁᎸᎯ ᎨᏒᎢ, ᎠᎴ ᏍᎩᎪᎡᎸᎯ ᎨᏒᎢ, ᏂᏣᏛᏁᎮᏍᏗ; ᎤᏁᎳᏅᎯᏃ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏁᎯ ᏗᏥᎧᎿᏩᏗᏓᏍᏗ ᎨᏎᏍᏗ.


text:
ᏥᎦᏔᎭ ᎢᏯᏆᏛᏁᏗᏱ ᎡᎳᏗ ᏱᎾᏆᏛᎿᏕᎦ, ᎠᎴ ᏥᎦᏔᎭ ᎢᏯᏆᏛᏁᏗᏱ ᎤᏣᏘ ᏯᎩᎭ; ᏂᎦᎥ ᏕᎨᏌᏗᏒᎢ, ᎠᎴ ᎾᎦᎥ ᎾᏆᎵᏍᏓᏁᎵᏕᎬᎢ, ᎥᏇᏲᏅ ᎢᏯᏆᏛᏁᏗᏱ ᎾᏍᏉ ᏯᏉᎳᏅ ᎠᎴ ᎾᏍᏉ ᏯᎩᏲᏏᎭ, ᎾᏍᏉ ᎤᏣᏘ ᏯᎩᎭ ᎠᎴ ᎾᏍᏉ ᏯᎩᏂᎬᏎᎭ


text:
ᎾᏍᎩᏃ ᏂᎯ ᏈᎵᎩᏱ ᎢᏤᎯ, ᎢᏥᎦᏔᎮᏍᏗ ᎾᏍᏉ, ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎢᎬᏱᏱ ᎢᏨᏯᎵᏥᏙᏁᎸ ᎾᎯᏳ ᎹᏏᏙᏂ ᎠᏆᏂᎩᏒ, ᎥᏝ ᎢᎸᎯᏢ ᎤᎾᏓᏡᎬ ᏧᎾᏁᎶᏗ ᎪᎱᏍᏗ ᏱᎬᏆᏛᏁᎴ ᎾᏍᎩ ᎠᏓᏁᏗ ᎠᎴ ᎥᏓᏘᏁᏗ ᎨᏒ ᎤᎬᏩᎵ, ᏂᎯ ᎢᏨᏒ.


text:
ᎠᏎᏃ ᏂᎦᎥᏉ ᎠᎩᎭ ᎠᎴ ᎤᏣᏔᏅᎯ; ᎠᎩᎧᎵᏬᎯ, ᏗᏆᏓᏂᎸᏨᎯ ᎨᏒ ᎢᏆ&apos;ᎶᏓᏓ ᎤᏲᎸᎯ ᎾᏍᎩ ᏅᏓᏣᏓᏅᏒᎯ, ᎤᏣᏘ ᎤᎦᎾᏍᏛ ᎦᏩᏒᎩ, ᎠᏥᎸ ᎨᎳᏍᏗ ᏗᎬᏓᏂᎸᎢᏍᏗ, ᎣᏏᏳ ᎤᏰᎸᏗ ᎤᏁᎳᏅᎯ.


text:
ᏫᏨᏲᏪᎳᏏ ᎢᏣᏓᏅᏘ ᎪᎶᏏ ᎢᏤᎯ ᎠᎴ ᎢᏣᎵᏅᏟ ᎦᎶᏁᏛ ᎡᏦᎯᏳᎲᏍᎩ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ, ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎢᏤᎳᏗᏙᎮᏍᏗ ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎢᎩᏙᏓ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎾᏍᎩ ᎢᏥᎷᏤᎸᎯ ᏥᎩ, ᎾᏍᎩᏯ ᏂᎬᎾᏛ ᎡᎶᎯ ᏧᏂᎷᏤᎸ; ᎠᎴ ᏥᎦᎾᏄᎪᏫᏍᎦ ᎤᏓᏔᏅᎯ ᎾᏍᎩᏯ ᏥᏂᎦᎵᏍᏗ ᏂᎯ ᎢᏤᎲᎢ, ᏅᏓᎬᏩᏓᎴᏅᏛ ᎢᏣᏛᎦᏅ ᎾᏍᎩ, ᎠᎴ ᎤᏙᎯᏳᎯ ᎢᏥᎦᏙᎥᏒ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ;


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏴ ᎾᏍᏉ, ᎣᎦᏛᎦᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᎥᏝ ᏲᏥᏲᎯᏍᏗᏍᎪ ᎣᏣᏓᏙᎵᏍᏗᏍᎬ ᎠᎴ ᎣᏥᏔᏲᎯᎲ ᎾᏍᎩ ᎠᏓᏅᏖᏍᎬ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎢᏥᎧᎵᎢᏍᏗᏱ, ᎾᏍᎩ ᏂᎦᎥ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎠᎴ ᎠᏓᏅᏙ ᎤᎬᏩᎵ ᎪᎵᏥᏓᏍᏗ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᎢᏣᎴᏂᏓᏍᏗᏱ ᎾᏍᎩᏯ ᎤᎬᏫᏳᎯ ᏗᏂᎧᎿᏩᏕᎩ ᎢᏳᎾᏛᏁᏗ ᎨᏒᎢ, ᏂᎦᎥ ᎣᏏᏳ ᎤᏰᎸᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎤᏣᏘ ᎢᏥᎾᏄᎪᏫᏍᎬᎢ, ᎠᎴ ᎧᏁᏉᎬ ᎡᏥᎦᏙᎥᏍᎬ ᎤᏁᎳᏅᎯ;


text:
ᏕᏣᎵᏂᎪᏍᎬᎢ ᎬᏔᏅᎯ ᎤᏣᏘ ᎤᎵᏂᎩᏛ ᎨᏒᎢ, ᎾᏍᎩᏯ ᏄᎵᏂᎬᎬ ᎦᎸᏉᏗᏳᎤᏤᎵᎦ, ᎾᏍᎩ ᏂᎦᎥᏉ ᎤᎬᏩᎵ ᏗᏨᏂᏗᎦ, ᎾᏍᎩ ᏂᎦᎥᏉ ᎤᎬᏩᎵ ᏗᏨᏂᏗᏳ ᎢᏣᎴᏍᏙᏗᏱ, ᎠᎴ ᎪᎯᏗᏳ ᎤᏁᎳᎩ ᎢᏤᎵᏍᎬ ᎢᏥᎩᎵᏲᎬᎢ, ᎤᎵᏠᏯᏍᏙᏗᏱ ᎠᎵᎮᎵᏍᏗ ᎨᏒᎢ;


text:
ᎾᏍᎩᏰᏃ ᏂᎦᎥ ᎪᎱᏍᏗ ᏧᏬᏢᏅᎯ, ᎾᏍᎩ ᎦᎸᎳᏗ ᏤᎭ, ᎠᎴ ᎡᎶᎯ ᏤᎭ, ᎬᎪᏩᏛᏗ ᎠᎴ ᎬᎪᏩᏛᏗ ᏂᎨᏒᎾ ᏥᎩ, ᎢᏳ ᎤᏂᎬᏫᏳᎯ ᏧᏂᏗᏱ ᏱᎩ, ᎠᎴ ᎤᏂᎬᏫᏳᏌᏕᎩ ᏘᎩ, ᎠᎴ ᎨᏥᎸᏉᏗ ᏱᎩ, ᎠᎴ ᏧᎾᎵᏂᎩᏛ ᏱᎩ; ᏂᎦᏗᏳ ᏄᏓᎴᏒ ᎾᏍᎩ ᏚᏬᏢᏁᎢ, ᎠᎴ ᎤᏩᏒ ᏚᏓᏙᏢᎾᏁᎴᎢ;


text:
ᎠᎴ ᎾᏍᎩ ᎤᏍᎪᎵ Ꭰ ᎠᏰᎸ ᎨᏒᎢ, ᎾᏍᎩ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬᎢ; ᎾᏍᎩ ᏗᏓᎴᏅᏗᏍᎩ, ᏧᏓᎴᏅᏔᏅᎯ ᎤᏲᎱᏒ ᏧᎴᎯᏌᏅᎯ, ᎾᏍᎩ ᏂᎦᏗᏳ ᏄᎾᏓᎴᏒ ᎢᎬᏱ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎠᎴ ᎾᏍᎩ ᎠᎬᏗᏍᎬ ᎤᏩᏒ ᏙᎯᏱ ᎢᏳᏅᏁᏗᏱ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ, ᎤᎩᎬ ᏓᏓᎿᏩᏍᏛ ᎤᏨᏅᎯ ᎤᏬᎯᏳᏍᏔᏅ; ᎾᏍᎩ ᎠᎬᏗᏍᎬᎢ, ᎢᏳᏃ ᎡᎶᎯ ᎠᏁᎯ ᏱᎩ, ᎠᎴ ᎦᎸᎳᏗ ᎠᏁᎯ ᏱᎩ.


text:
ᎢᏳᏃ ᏱᏅᏩᏍᏗᏗᏉ ᎢᏦᎯᏳᏒᎢ, ᎦᎫᏍᏛᏅᎯ ᎠᎴ ᎠᏍᏓᏱᏛᎯ ᎨᏒᎢ, ᎠᎴ ᎢᏴᏛ ᎢᎦᏰᏨᏁᏗ ᏂᎨᏒᎾ ᏱᎩ ᎤᏚᎩ ᎢᏨᏒ ᎣᏍᏛ ᎧᏃᎮᏛᏱ, ᎾᏍᎩ ᎢᏣᏛᎦᏅᎯ ᏥᎩ, ᎾᏂᎥ ᎨᎦᏁᎳᏅᎯ ᎨᏒ ᎨᎦᎵᏥᏙᏁᎸᎯ ᏥᎩ ᎦᎸᎶ ᎭᏫᏂᏗᏢ ᏄᎾᏛᏅᎢ; ᎾᏍᎩ ᎾᎿ ᎠᏴ ᏉᎳ ᎪᎱᏍᏗ ᎦᏛᏁᎯ ᏥᏅᏋᏁᎸ;


text:
ᎠᏴ ᎾᏍᎩ ᎪᎯ ᎨᏒ ᏥᎦᎵᎡᎵᎦ ᎢᏨᎩᎵᏲᏤᎲᎢ, ᎠᎴ ᏥᏥᎧᎵᏏᏏ ᎠᏏ ᎤᏃᏒᎢ ᎦᎶᏁᏛ ᎤᎩᎵᏲᏨ ᎾᏍᎩᏯ ᎠᎩᏇᏓᎸ ᏥᎩᎵᏲᎬᎢ, ᎾᏍᎩ ᎠᏰᎸ ᏥᏅᏗᎦᎵᏍᏙᏗᎭ, ᎾᏍᎩ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏥᎩ;


text:
ᎾᎿ ᎠᏴ ᏗᎩᎸᏫᏍᏓᏁᎯ ᏅᏋᏁᎸ ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᎤᏓᏁᏤᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎠᏴ ᏨᎩᏁᎸ ᏂᎯ ᎢᏣᎵᏍᏕᎸᏙᏗ, ᎾᏍᎩ ᎠᎧᎵᎢ ᎠᏆᎵᏥᏙᏗᏱ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ;


text:
ᎾᏍᎩ <n>[ᎤᏓᏅᏘ]</n> ᎤᏁᎳᏅᎯ ᎤᏚᎵᏍᎨ ᎬᏂᎨᏒ ᎢᏧᏩᏁᏗᏱ ᏂᎦᎥ ᎦᎸᏉᏗᏳ ᎨᏒ ᎯᎠ ᎾᏍᎩ ᎤᏕᎵᏛ ᎨᏒ ᏧᎾᏓᎴᏅᏛ ᎠᏴ ᎠᏁᎲ <n>[ᎬᏂᎨᏒ ᏥᏄᏩᏁᎸ;]</n> ᎾᏍᎩ ᎦᎶᏁᏛ ᏥᎩ ᏂᎯ ᎢᏥᏯᎢ, ᎾᏍᎩ ᎤᏚᎩ ᎨᏨᏗ ᏥᏂᎬᏁ ᎦᎸᏉᏗᏳ ᏗᎨᏒ ᏫᏥᎾᏄᎪᎢᏍᏗᏱ.


text:
ᎾᏍᎩ Ꮎ ᎬᏂᎨᏒ ᏥᏃᏨᏁᎭ, ᎾᏂᎥ ᏥᏙᏤᏯᏔᎲᏍᎦ, ᎠᎴ ᎾᏂᎥ ᏥᏙᏤᏲᎲᏍᎦ ᏦᏨᏗᎭ ᏂᎦᎥ ᎠᎵᏏᎾᎯᏍᏙᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎾᏂᎥ ᎬᏂᎨᏒ ᎢᏦᏨᏁᏗᏱ ᏄᏂᎪᎸᎾ ᎦᎶᏁᏛ ᏥᏌ ᏚᎾᏁᎶᏛᎢ;


text:
ᎠᏆᏚᎵᏰᏃ ᎢᏥᎦᏙᎥᎯᏍᏗᏱ ᏂᎦᎥ ᏥᎩᎵᏲᎬ ᎦᏟᏂᎬᏁᎲ ᏂᎯ ᎨᏒ ᎢᏳᏍᏗ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎴᎣᏗᏏᏯ ᎠᏁᎯ, ᎠᎴ ᎾᏂᎥᏉ ᎤᏂᎪᎲᎯ ᏂᎨᏒᎾ ᎠᏆᎧᏛ ᎠᏂ ᎤᏇᏓᎵ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᏧᏂᎾᏫ ᎤᎦᎵᏍᏗ ᏗᎬᏩᏓᏅᏓᏗᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ ᏚᎾᏚᏓᏕᏫᏍᏛ ᎠᏓᎨᏳᏗ ᎨᏒᎢ, ᎠᎴ ᏭᏂᏱᎶᎯᏍᏗᏱ ᏂᎦᎥ ᎦᎸᏉᏗᏳ ᎨᏒ ᏄᏜᏏᏛᏒᎾ ᎪᎯᏳᏗ ᎨᏒ ᎾᏍᎩ ᎪᎵᏍᏗ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ, ᎤᏂᎦᏙᎥᎯᏍᏗᏯ ᎤᏕᎵᏛ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎠᎦᏴᎵᎨ ᎤᏤᎵᎦ, ᎠᎴ ᎦᎶᏁᏛ ᎤᏤᎵᎦ;


text:
ᎾᎿ ᏗᏥᎿᏍᏕᏜᏛᎯ ᎠᎴ ᎾᎿ ᎡᏣᏁᏍᎨᎲᎯ, ᎠᎴ ᎤᎵᏂᎩᏛ ᎢᏰᏨᏁᎸᎯ ᎢᏦᎯᏳᏒᎢ, ᎾᏍᎩᏯ ᎡᏤᏲᏅᎢ, ᎾᏍᎩ ᎤᏣᏘ ᎨᏎᏍᏗ <n>[ᎢᏦᎯᏳᏒᎢ]</n> ᎤᎵᏠᏯᏍᏕᏍᏗ ᎠᎵᎮᎵᏤᏗ ᎨᏒ ᎤᏁᎳᏅᎯ.


text:
ᎢᏤᏯᏔᎮᏍᏗ ᏞᏍᏗ ᎩᎶ ᏥᏥᎾᏌᏂ, ᎠᏏᎾᏍᏛ ᎦᏬᏂᎯᏍᏗ ᎨᏒ ᎬᏗ, ᎾᏍᎩᏯ ᏴᏫ ᏓᎾᏕᏲᎲᏍᎬᎢ, ᎾᏍᎩᏯ ᎡᎶᎯ ᏗᎴᏅᏙᏗ ᏓᏕᏲᎲᏍᎬᎢ, ᎥᏝᏃ ᎾᏍᎩᏯ ᎦᎶᏁᏛ ᏓᏕᏲᎲᏍᎬᎢ;


text:
ᎾᏍᎩ ᎾᏍᏉ ᎢᏳᏩᏂᏌᏅᎯ ᏤᏥᎤᏍᏕᏎᎸᎯ ᏥᎩ, ᎠᎱᏍᏕᏍᏗ ᎬᏔᏅᎯ ᎾᏍᎩ ᎩᎶ ᏧᏬᏰᏂ ᏧᏩᏔᏅᎯ ᏂᎨᏒᎾ, ᎾᏍᎩ ᎢᏴᏛ ᏂᏨᏁᎲ ᎠᏰᎵ ᎾᏍᎩ ᎤᏇᏓᎵ ᎨᏒ ᎤᏍᎦᏅᎢᏍᏔᏅᎢ ᎢᏨᏗᏍᎬ ᎦᎶᏁᏛ ᎤᏤᎵ ᎠᎱᏍᏕᏍᏗ ᎨᏒᎢ;


text:
ᎡᏥᏂᏌᏅ ᎾᏍᎩ ᎠᏥᏂᏌᏅ ᏗᏓᏬᏍᏗ ᎨᏒ ᎬᏔᏅᎯ, ᎾᏍᎩ ᎾᏍᏉ ᎬᏔᏅᎯ ᏕᏣᎴᏔᏅ ᎾᏍᎩ ᏓᎦᎴᏔᏅᎢ ᎬᏔᏅᎯ ᏕᏣᎴᏔᏅ ᎾᏍᎩ ᏓᎦᎴᏔᏅᎢ ᏅᏧᎵᏍᏙᏔᏅ ᎢᏦᎯᏳᏒ ᎤᏁᎳᏅᎯ ᏚᎸᏫᏍᏓᏁᎸᎢ, ᎾᏍᎩ ᏧᎴᏔᏅᎯ ᏥᎩ ᎤᏲᎱᏒᎢ.


text:
ᏂᎯᏃ ᏗᏥᏲᎱᏒᎯ ᏂᎨᏒ ᎤᏣᏘᏂ ᏂᏣᏛᏁᎸ ᎢᏣᏚᏓᎸᎢ ᎠᎴ ᏂᏕᏥᎤᏍᏕᏎᎸᎾ ᎨᏒ ᎢᏥᏇᏓᎸᎢ, ᏗᏨᏃᏛ ᏂᏨᏁᎸ ᎾᏍᎩ ᎬᏃᏛ ᎾᎬᏁᎸᎢ, ᎦᏰᏥᏁᎸ ᏂᎦᏗᏳ ᎤᏣᏘᏂ ᏂᏣᏛᏁᎸᎢ,


text:
ᏞᏍᏗ ᎩᎶ ᏥᏥᎷᏄᎮᎵ ᏥᏥᏲᏍᏙᏓᏁᎵ ᎠᏌᏍᏛ ᎡᏥᏁᏗᏱ ᎤᏚᎵᏍᎬ ᎤᏓᏙᎵᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏧᎾᏓᏙᎵᏍᏓᏁᏗᏱ, ᎾᏍᎩ ᎤᎵᏌᎳᏁᎲ ᎤᎪᎲᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᏎᏉᏉ ᎠᏕᏋᎯᏍᏗᏍᎬ ᎬᏗᏍᎬ ᎤᏇᏓᎵ ᎤᏓᏅᏖᏗ ᎨᏒᎢ;


text:
ᎠᎴ ᏂᏚᏂᏴᏒᎾ ᎨᏒ ᎠᏍᎪᎵ, ᎾᎿ ᏨᏗᏓᎴᎲᏍᎦ ᏂᎬ ᎠᏰᎸᎢ ᏚᎯᏞᏫᏒᎢ ᎠᎴ ᏧᏩᏚᎾ ᏚᏪᏙᎸᎢ ᎤᎵᏍᏕᎸᏙᏙᎢ, ᎠᎴ ᏚᏚᏓᏕᏫᏐᎢ ᎠᏛᏍᎪᎢ ᎾᏍᎩᏯ ᎤᏁᎳᏅᎩ ᎤᏁᏉᏍᎬᎢ.


text:
ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᎤᏙᎯᏳᎯ ᎠᎵᏏᎾᎯᏍᏙᏗ ᎨᏒ ᏓᏤᎸ, ᎾᏍᎩ ᎾᎿ ᎣᏩᏒ ᎣᏓᏅᏖᏛ ᎤᏁᎳᏅᎯ ᎠᏓᏙᎵᏍᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎣᏓᏙᎵᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏃᎦᏌᏯᏍᏛᎾ ᎨᏒ ᎥᏰᎸᎢ, ᎥᏝᏃ ᎾᏍᎩ ᎠᎦᎸᏉᏗᏍᎬᎢ, ᎤᏇᏓᎵ ᎤᏂᎬᏎᎲ ᎥᏩᏛᎡᎲᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏕᏥᎯᎮᏍᏗ ᏗᏥᏰᎸ ᏕᏣᏚᏓᏕᏫᏒ ᎠᏂ ᎡᎶᎯ; ᎾᏍᎩ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒᎢ, ᎦᏓᎭ ᎨᏒᎢ, ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ, ᎤᏲ ᎠᏚᎸᏅᏗ ᎨᏒᎢ, ᎠᎴ ᏧᎬᏩᎶᏗ ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎠᏰᎸᎯ ᎠᏓᏙᎵᏍᏓᏁᏗ ᏥᎩ;


text:
ᎠᏎᏃ ᎪᎯ ᎨᏒ ᏂᎯ ᎾᏍᏉ ᎯᎠ ᏂᎦᏛ ᎢᏴᏛ ᏂᏕᏨᏁᎭ; ᎠᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᎧᎾᎸᎢᏍᏗ ᎨᏒᎢ, ᎠᏓᏂᏆᏗᏍᏗ ᎨᏒᎢ, ᎠᏐᏢᎢᏍᏙᏗ ᎨᏒᎢ, ᎤᏁᎢᎸᏗ ᎦᏬᏂᎯᏍᏗ ᎨᏒ ᏗᏥᎰᎵ ᏅᏓᏳᏄᎪᏨᎯ.


text:
ᎾᎿᏂ ᎥᏝ ᎩᎶ ᎠᎪᎢ ᏱᎩ, ᎠᎴ ᎠᏧᏏ, ᎠᏥᎤᏍᏕᏎᎸᎯ ᎠᎴ ᎠᏥᎤᏍᏕᏎᎸᎯ ᏂᎨᏒᎾ, ᏅᏩᏓᎴ ᏴᏫ, ᏏᏗᏱ ᎡᎯ, ᎠᏥᎾᏝᎢ ᎠᎴ ᎾᏥᎾᏝᎥᎾ; ᎦᎶᏁᏛᏍᎩᏂ ᏂᎦᎥ ᎪᎱᏍᏗ ᏂᎦᎵᏍᏓ, ᎠᎴ ᏂᎦᏗᏳ ᏗᏯᎢ.


text:
ᎠᏍᎩ ᎢᏳᏍᏗ, ᎾᏍᎩᏯ ᎢᏳᎾᏛᏁᏗ ᎤᏁᎳᏅᎯ ᏧᏑᏰᏛ ᎨᏒᎢ, ᎤᎾᏓᏅᏘ ᎠᎴ ᎨᏥᎨᏳᎢ, ᎢᏣᏄᏬᏍᏓ ᎤᏬᏙᎵᏍᏗ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏓᏙᎵᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ, ᎤᏓᏅᏘ ᎨᏒᎢ, ᎠᎴ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ, ᎤᏓᏅᏘ ᎨᏒᎢ, ᎪᎯᏗᏳ ᎤᏁᎳᎩ ᏗᏓᏕᎵᏎᏗ ᎨᏒᎢ;


text:
ᎤᏁᎳᎩ ᏕᏣᏓᏕᎵᏎᎮᏍᏗ, ᎠᎴ ᏗᎨᏣᏓᏁᎮᏍᏗ ᏕᏣᏓᏍᎦᏅᏤᎲᎢ, ᎢᏳᏃ ᎩᎶ ᎪᎱᏍᏗ ᏱᏓᎾᏓᏕᎵᏎᎭ; ᎾᏍᎩᏯ ᎦᎶᏁᏛ ᎦᎨᏥᏁᎸ ᎢᏥᏍᎦᏅᏨᎢ, ᎾᏍᎩᏯ ᎾᏍᏉ ᏂᎯ ᎾᏍᎩ ᏂᏣᏛᏁᎮᏍᏗ.


text:
ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵ ᎤᏣᏘ ᎢᏥᏯᎡᏍᏗ ᎦᎾᏄᎪᏫᏍᎨᏍᏗ ᏂᎦᎥ ᎠᎵᏏᎾᎯᏍᏙᏗ ᎨᏒᎢ; ᏕᏣᏓᏕᏲᎲᏍᎨᏍᏗ ᎠᎴ ᏕᏣᏓᏬᏁᏗᏍᎨᏍᏗ ᏕᏨᏗᏍᎨᏍᏗ ᎤᏁᎳᏅᎯ ᏗᎧᏃᎩᏍᏙᏗ, ᎠᎴ ᎦᎸᏉᏙᏗ ᏗᎧᏃᎩᏍᏗ, ᎠᎴ ᎠᏓᏅᏙ ᎤᎬᏩᎵ ᏗᎧᏃᎩᏍᏗ, ᏕᏥᏃᎩᏍᎨᏍᏗ, ᏗᏥᎾᏫᏱ ᏗᏓᎴᎲᏍᎨᏍᏗ ᎤᎬᏫᏳᎯ ᏕᏥᏃᎩᏍᎨᏍᏗ ᎡᏣᎵᎡᎵᏤᎮᏍᏗ.


text:
ᎠᎴ ᏂᎦᎥ ᏂᏣᏛᏁᎵᏙᎲᎢ, ᎢᏥᏬᏂᏍᎬ ᎠᎴ ᏕᏥᎸᏫᏍᏓᏁᎲ ᏱᎩ, ᏂᎦᎥ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᏙᎥ ᎢᏨᏗᏍᎨᏍᏗ, ᎡᏣᎵᎡᎵᏤᎮᏍᏗ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎠᎦᏴᎵᎨᎢ, ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ.


text:
ᎡᏥᏅᏏᏓᏍᏗ, ᏕᏦᎯᏳᏎᏍᏗ ᏂᎦᎥ ᏂᎨᏥᏪᏎᎲ ᎨᏥᏅᏏᏙᎯ ᎠᏂ ᎤᏇᏓᎵ ᎨᏒᎢ; ᎥᏝ ᏥᏛᏓᏗᎧᏃ ᎾᏍᎩᏯᎢ, ᏴᏫᏉ ᎣᏏᏳ ᎤᏂᏰᎸᏗ, ᎣᏏᏳᏍᎩᏂ ᎢᏥᏰᎸᎯ ᎨᏎᏍᏗ ᏗᏥᎾᏫᏱ, ᎡᏥᎾᏰᏍᎨᏍᏗ ᎤᏁᎳᏅᎯ:


text:
ᎠᎴᏬ ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ ᎠᏴ ᏍᎩᏯᏅᏓᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎣᎩᏍᏚᎩᎡᏗᏱ ᎦᎶᎯᏍᏗᏱ ᎾᎿ ᎣᎦᎵᏥᏙᏗᏱ, ᎣᎩᏃᎮᏗᏱ ᎤᏕᎵᏛ ᎦᎶᏁᏛ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎾᏍᏉ ᏥᏅᏗᎦᎵᏍᏙᏗᎭ ᎥᏆᎸᎢᏛ ᏥᎩ;


text:
ᎡᎦᏆ ᎾᏍᎩ ᎢᏤᎲ ᎡᎯ ᏥᎩ, ᎦᎶᏁᏛ ᎤᏅᏏᏙᎯ, ᏫᏥᏲᎵᎦ, ᏂᎪᎯᎸ ᎠᎵᏂᎬᏁᎭ ᎠᏓᏙᎵᏍᏗᏍᎬ ᎾᏍᎩ ᏂᎯ ᎢᏣᎵᏗᏱ ᏂᏥᎪᎸᎾ ᎠᎴ ᎠᎧᎵᎢ ᏂᎦᎥ ᎤᏁᎳᏅᎯ ᎣᏏᏳ ᎤᏰᎸᏗ ᎨᏒᎢ.


text:
ᏉᎳ ᎠᎴ ᏌᏱᎳ ᎠᎴ ᏗᎹᏗ ᏫᏨᏲᏪᎳᏏ ᏗᏣᏁᎶᏗ ᎢᏣᏓᏡᎬ ᏕᏏᎶᏂᎦ ᎾᏍᎩ ᎡᏦᎯᏳᎲᏍᎩ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨᎢ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎨᏤᎳᏗᏙᎮᏍᏗ ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎢᎩᏙᏓ ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᏃᎬᎨᏫᏍᎬᎾ ᎣᏣᏅᏓᏗᏍᎪ ᏕᏥᎸᏫᏍᏓᏁᎲ ᎢᏦᎯᏳᏒ ᏅᏓᏳᏓᎴᏅᎯ, ᎠᎴ ᎢᏣᎵᏂᎬᏁᎲ ᎠᏓᎨᏳᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ, ᎠᎴ ᏗᏨᏂᏗᏳ ᎨᏒ ᎤᏚᎩ ᎡᏨᏒ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵ ᏥᏌ ᎦᎶᏁᏛ, ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲ ᎾᏍᎩ ᎢᎩᏙᏓ;


text:
ᎣᏍᏛᏰᏃ ᎧᏃᎮᏛ ᎣᎦᏤᎵᎦ ᎥᏝ ᎧᏁᏨᎯᏉ ᎨᏒ ᏱᏥᎷᎯᏍᏓᏁᎴᎢ, ᎤᎵᏂᎩᏗᏳᏍᎩᏂ ᎨᏒ ᎾᏍᏉ ᏔᎵ ᎤᏛᏛᎢ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ, ᎠᎴ ᎤᏣᏘ ᏄᏜᏏᏛᏒᎾ ᎨᏒᎢ; ᎾᏍᎩᏯ ᏥᏥᎦᏔᎭ ᏃᎦᏍᏛ ᎢᏨᏰᎳᏗᏙᎸ ᏂᎯ ᏥᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ.


text:
ᎠᎴ ᎠᏴ ᏍᎩᏍᏓᏩᏕᎩ ᏂᏣᎵᏍᏔᏅᎩ, ᎠᎴ ᎤᎬᏫᏳᎯ <n>[ᎡᏥᏍᏓᏩᏕᎩ,]</n> ᏕᏣᏓᏂᎸᏨ ᎧᏃᎮᏛ ᎤᏣᏘ ᎢᏥᎩᎵᏲᎬᎢ, ᎤᎵᏠᏯᏍᏛ ᎤᎵᎮᎵᏍᏗ ᎨᏒ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᏅᏓᏩᏓᎴᏅᎯ;


text:
ᏂᎯᏰᏃ ᎢᏤᎲ ᎤᏓᎴᏅᎩ ᎤᏃᏴᎵᏒᎩ ᎧᏃᎮᏛ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ, ᎥᏝ ᎹᏏᏙᏂᏉ ᎠᎴ ᎡᎦᏯ ᎤᏩᏒ ᏱᏭᎷᏤᎢ, ᎾᏍᏉᏍᎩᏂ ᏂᎦᎥ ᏕᎨᏌᏗᏒ ᎤᏁᎳᏅᎯ ᎡᏦᎢᏳᏒ ᏚᏰᎵᏒ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎥᏝ ᎠᏎ ᎪᎱᏍᏗ ᎣᎦᏛᏗ ᏱᎩ.


text:
ᎤᏅᏒᏰᏃ ᎬᏂᎨᏒ ᏂᎪᎬᏁᎭ ᏄᏍᏛ ᏫᏨᎷᏖᎸᎢ, ᎠᎴ ᏂᏣᏛᏁᎸ ᎤᏁᎳᏅᎯ ᎢᏗᏢ ᎢᏣᎦᏔᎲᏍᏔᏅ ᏕᏥᏲᏒ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ, ᏗᏥᎧᎿᏩᏛᏍᏗᏱ ᎬᏃᏛ ᎠᎴ ᎤᏙᎯᏳᎯᏯ ᎤᏁᎳᏅᎯ ᏥᎩ;


text:
ᎾᏍᏉᏍᎩᏂ ᎢᎬᏱ ᏃᎩᎩᎵᏲᏦᎢ ᎠᎴ ᏂᎪᎩᏐᏢᏃᎢ ᏈᎵᎩᏱ, ᎾᏍᎩ ᏥᏥᎦᏔᎭ, ᏃᏥᏍᎦᎢᎲᎾ ᎣᎦᏁᎳᏅᎯ ᎣᏣᎵᏍᎦᏍᏙᏛ ᎢᏨᏃᎮᎮᎸᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᏔᎵ ᎤᏛᏛᎩ ᎤᏣᏘ ᎠᏟᏂᎬᏁᏗ ᎨᏒᎢ.


text:
ᎥᏝ ᎠᎴ ᎣᏥᏬᏂᏍᎬ ᎢᎸᎯᏳ ᎠᏎᏉ ᎠᏓᎸᏉᏙᏗ ᎨᏒ ᏲᏨᏗᏍᎨᎢ, ᎾᏍᎩ ᏥᏥᎦᏔᎭ, ᎥᏝ ᎠᎴ ᎪᎱᏍᏗ ᏲᏨᏗᏍᎨ ᏲᏧᏢᏗᏍᎨ ᏧᎬᏩᎶᏗ ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ; ᎤᏁᎳᏅᎯ ᎠᎦᏔᎯ;


text:
ᎢᏣᏅᏔᏉᏰᏃ, ᎢᏓᎵᏅᏟ, ᏙᎩᎸᏫᏍᏓᏁᎸ ᎠᎴ ᏙᎩᏯᏪᏥᏙᎸᎢ; ᏗᎬᏩᎩᏨᏗᏰᏃ ᏙᎩᎸᏫᏍᏓᏁᎲ ᏃᎦᏚᎵᏍᎬᎾ ᎨᏒ ᎢᏳᏍᏗ ᎠᏏᏴᏫ ᏂᏣᏛᏅ ᎦᎨᏛ ᎢᏲᏨᏴᏁᏗᏱ, ᎢᏨᏯᎵᏥᏙᏁᎸᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ.


text:
ᎾᏍᎩ ᎾᏍᏉ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏃᏥᏲᎯᏍᏗᏍᎬᎾ ᎣᏣᎵᎡᎵᏤᎭ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎢᏳᏃ ᏕᏣᏓᏂᎸᏨ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎠᏴ ᏍᎩᏯᏛᎦᏁᎸᎯ, ᎥᏝ ᏴᏫᏉ ᎤᎾᏤᎵ ᎧᏃᎮᏛ ᎢᏳᏍᏗ ᏱᏗᏣᏓᏂᎸᏤᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎤᏤᎵ ᎧᏃᎮᏛ, ᎤᏙᎯᏳᎯᏯ ᏥᎩ, ᎾᏍᎩᏯ ᏕᏣᏓᏂᎸᏨᎩ, ᎾᏍᎩ ᎾᏍᏉ ᎤᏣᏘ ᏥᏚᎸᏫᏍᏓᏁᎭ ᏕᏣᏓᏅᏛ ᏂᎯ ᎾᏍᎩ ᎢᏦᎯᏳᏅᎯ.


text:
ᏂᎯᏰᏃ, ᎢᏓᎵᏅᏟ, ᏗᏥᏍᏓᏩᏕᎩ ᏂᏣᎵᏍᏔᏅᎩ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᎬ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ ᏧᏗᏱ ᎠᏁᎯ, ᎾᏍᎩ ᎦᎶᏁᏛ ᏥᏌ ᎬᏬᎯᏳᎲᏍᎩ ᏥᎩ; ᏂᎯᏰᏃ ᎾᏍᏉ ᎤᏠᏱ ᏕᏥᎩᎵᏲᏤᎸᎩ ᏗᏣᏤᎵᎦ ᏴᏫ, ᎾᏍᎩᏯ ᎾᏍᎩ ᏥᏚᏂᎩᎵᏲᏤᎴ ᎠᏂᏧᏏ;


text:
ᎾᏍᎩ ᎾᏍᏉ ᏧᏂᎸᎩ ᎤᎬᏫᏳᎯ ᏥᏌ, ᎠᎴ ᎠᎾᏙᎴᎰᏍᎩ ᎤᏅᏒ ᏧᎾᏤᎵᎦ, ᎠᎴ ᎠᏴ ᎠᎦᏕᏯᏙᏔᏅᎩ; ᎠᎴ ᎥᏝ ᎣᏏᏳ ᎤᏰᎸᏗ ᎤᏁᎳᏅᎯ ᏱᎾᎾᏛᏁᎭ, ᎠᎴ ᎾᏂᎥ ᏴᏫ ᏓᏂᎦᏘᎴᎦ;


text:
ᎪᎩᏅᏍᏓᏕᎰᎢ ᏦᏥᏬᏁᏙᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎾᏍᎩ ᎦᎨᏥᏍᏕᎸᏗ ᎢᏳᎵᏍᏙᏗᏱ, ᎤᏂᎧᎵᎢᏍᏗᏱ ᏂᎪᎯᎸ ᎤᏂᏍᎦᏅᏨᎢ; ᎤᏔᎳᏬᎯᏍᏗᏍᎩᏂ ᎨᏒ ᏩᏍᏛ ᎢᏴᏛ ᎤᏂᎷᏤᎸ.


text:
ᎦᏙᏰᏃ ᎤᏚᎩ ᎣᎬᎭ, ᎠᎴ ᎦᏙ ᎣᏍᏛ ᏱᎦᏓᏅᏓᏗᎭ, ᎠᎴ ᎦᏙ ᎤᏍᏗ ᎠᎵᏍᏚᎶ ᏯᎦᎵᎮᎵᏍᏙᏗ? ᏝᏍᎪ ᏂᎯ ᏱᎨᏎᏍᏗ ᎠᎦᏔᎲ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎾᎯᏳ ᎦᎷᏨᎭ?


text:
ᎠᎴ ᎣᏥᏅᏒᎩ ᏗᎹᏗ, ᎣᏣᎵᏅᏟ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎪᎱᏍᏗ ᎠᏛᏁᎯ, ᎠᎴ ᎠᏴ ᎢᏧᎳᎭ ᏦᎩᎸᏫᏍᏓᏁᎯ ᎣᏍᏛ ᎧᏃᎮᏛ ᎦᎶᏁᏛ ᎤᏤᎵ ᎤᎬᏩᎵ, ᎾᏍᎩ ᏗᏣᎵᏂᎪᎯᏍᏙᏗᏱ, ᎠᎴ ᏗᏥᎧᎵᏍᏓᏗᏍᏗᏱ ᎢᏦᎯᏳᏒ ᎤᎬᏩᎵ;


text:
ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ, ᎿᏉ ᎤᏟ ᎢᎪᎯᏛ ᎬᏆᏛᏂᏗᏍᏗ ᏂᎨᏒᎾ ᏄᎵᏍᏔᏅ, ᎠᏆᏓᏅᏒᎩ ᎠᏆᏙᎴᎰᎯᏍᏗᏱ ᏄᏍᏛ ᎢᏦᎯᏳᏒᎢ, ᎪᎱᏍᏗ ᏴᏗᎤᎵᏍᏙᏔᏅ ᎠᏓᎪᎵᏰᏍᎩ ᏳᏂᎪᎵᏰᎥ, ᏙᎩᎸᏫᏍᏓᏁᎸᏃ ᎠᏎᏉ ᏱᏄᎵᏍᏔᏂᏙᎸ, ᎠᏇᎵᏒᎩ.


text:
ᎠᏎᏃ ᎿᏉ ᏗᎹᏗ ᎣᎩᎷᏤᎸᎯ ᏥᎩ, ᏗᏤᎲ ᏅᏓᏳᎶᏒᎯ, ᎠᎴ ᎣᏍᏛ ᎠᏰᎸᏗ ᎣᎩᏃᎮᎮᎸᎯ ᏥᎩ, ᏗᏤᎲ ᏅᏓᏳᎶᏒᎩ, ᎠᎴ ᎣᏍᏛ ᎠᏰᎸᏗ ᎣᎩᏃᎮᎮᎸᎯ ᏥᎩ, ᎢᏦᎯᏳᏒ ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒ ᎢᏤᎲ ᎤᎬᏩᎵ, ᎠᎴ ᏂᎪᎯᎸ ᎣᏏᏳ ᏍᎩᏯᏅᏛᎢ, ᎤᏣᏘ ᎢᏣᏚᎵᏍᎬ ᏍᎩᎪᏩᏛᏗᏱ, ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏴ ᎣᎦᏚᎵᏍᎬ ᎢᏨᎪᏩᏛᏗᏱ;


text:
ᏔᎳᎪᏰᏃ ᎢᎦᎢ ᎠᎵᎮᎵᏍᏗ ᏲᏣᎫᏴᏓᏏ ᎤᏁᎳᏅᎯ ᏂᎯ ᎨᏒ ᎢᏳᏍᏗ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᏂᎦᎥ ᎣᏍᏛ ᎠᏓᏅᏓᏗᏍᏗ ᎬᏒ ᎾᏍᎩ ᎣᏣᏓᏅᏓᏗᏍᎬ ᏂᎯ ᎨᏒ ᎤᎬᏩᎵ ᎣᎦᏤᎵ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ;


text:
ᎾᏍᎩ ᏧᎵᏂᎪᎯᏍᏙᏗᏱ ᏗᏥᎾᏫ, ᎾᏍᎩ ᎦᏰᏧᎢᏍᏙᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ ᏚᏳᎪᏛ ᏂᏣᏛᏁᎸ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ, ᎾᏍᎩ ᎢᎩᏙᏓ, ᎾᎯᏳ ᎦᎷᏨᎭ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎠᏁᎮᏍᏗ ᏂᎦᏗᏳ ᎤᎾᏓᏅᏘ ᏧᏤᎵᎦ.


text:
ᎠᎴ ᎾᏍᏉ, ᎢᏓᎵᏅᏟ, ᎢᏨᏔᏲᏎᎭ, ᎠᎴ ᎢᏨᏍᏗᏰᏕᎭ, ᎤᎬᏫᏳᎯ ᏥᏌ ᏅᏗᎦᎵᏍᏙᏗᎭ, ᎾᏍᎩ Ꮎ ᏍᎩᏯᏛᎦᏁᎸᎯ ᏥᎩ ᎢᏣᏛᏁᏗᏱ ᎢᏤᏓᏍᏗᏱ ᎾᏍᎩ ᎣᏏᏳ ᎬᏩᏰᎸᏗ ᎨᏒ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᏂᏣᏛᏁᎲ ᎧᏁᏉᏥᏎᏍᏗᏉ.


text:
ᎾᏍᎩ ᎩᎶ ᎤᎶᏒᏍᏓᏁᏗᏱ ᎠᎴ ᎤᎶᏄᎮᏗᏱ ᏂᎨᏒᎾ ᎠᎾᎵᏅᏟ ᏥᏂᎦᎥᏉ ᎪᎱᏍᏗ ᎤᎬᏩᎵ; ᎤᎬᏫᏳᎯᏰᏃ ᏗᏞᏤᎯ ᎯᎠ ᎾᏍᎩ ᎾᎦᎥ ᏧᏓᎴᏅᏛ, ᎾᏍᎩ ᎦᏳᎳ ᎢᏨᏃᏁᎸᎯ ᎠᎴ ᎢᏨᏲᎢᏳᏓᏁᎸᎯ ᏥᎩ.


text:
ᎠᎴ ᎢᏣᏟᏂᎬᏁᏗᏱ ᏅᏩᏙᎯᏯᏛ ᎢᏣᏕᏗᏱ, ᎠᎴ ᎢᏨᏒ ᎢᏣᏤᎵ ᏗᎦᎸᏫᏍᏓᏁᏗ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ, ᎠᎴ ᎢᏨᏒ ᏗᏦᏰᏂ ᏗᏨᏙᏗᏱ ᎪᎱᏍᏗ ᎢᏣᏛᏁᏗᏱ, ᎾᏍᎩᏯ ᏂᏨᏪᏎᎸᎢ;


text:
ᎠᏎᏃ, ᎢᏓᎵᏅᏟ, ᎥᏝ ᎾᏂᎦᏔᎥᎾᏉ ᎨᏎᏍᏗ ᏱᏨᏰᎵᏎᎭ ᎾᏍᎩ Ꮎ ᎤᏂᎵᏅᏨᎯ ᎤᎬᏩᎵ, ᎾᏍᎩ ᎤᏲ ᎢᏣᏓᏅᏓᏗᏍᏗᏱ ᏂᎨᏒᎾ ᎾᏍᎩ ᏅᏩᎾᏓᎴ ᎤᏚᎩ ᏄᏅᏒᎾ ᎾᏍᎩᏯ ᏄᎾᏍᏛᎢ.


text:
ᎤᎬᏫᏳᎯᏰᏃ ᎤᏩᏒ ᏛᏠᎠᏏᎵ ᎦᎸᎳᏗ ᏅᏓᏳᎶᏒᎯ ᎤᎵᏠᏯᏍᏕᏍᏗ ᎤᏁᎷᎬᎢ, ᎠᎴ ᏄᎬᏫᏳᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎧᏁᎬᎢ, ᎠᎴ ᎠᏤᎷᎩ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎤᏃᏴᎬᎢ; ᏧᏂᏲᎱᏒᎯᏃ ᎦᎶᏁᏛ ᎤᎾᎵᏍᎦᏙᏔᏅᎯ ᎢᎬᏱ ᏙᏛᎾᎴᏂ;


text:
ᎾᎯᏳᏰᏃ ᏅᏩᏙᎯᏯᏛ ᎠᎴ ᏄᎾᏰᎯᏍᏛᎾ ᎠᎾᏗᏍᎨᏍᏗ, ᎿᏉ ᏄᏰᎶᎢᏍᏔᏅᏛ ᎠᏓᏛᏗᏍᎩ ᎤᏂᎷᏤᏗ ᎨᏎᏍᏗ, ᎾᏍᎩᏯ ᎠᎩᎵᏯ ᏧᎷᏤᎰ ᎠᎨᏴ ᎦᏁᎵᏛ; ᎠᎴ ᎥᏝ ᎤᎾᏗᏫᏎᏗ ᏱᎨᏎᏍᏗ.


text:
ᎠᏴᏍᎩᏂ ᎢᎦ ᎢᏕᎯ ᏥᎩ ᏂᏗᎩᏴᏍᏕᏍᎬᎾ ᎨᏎᏍᏗ, ᎠᏓᏁᏣᏍᏚᎶ ᎪᎯᏳᏗ ᎨᏒ ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒ ᎢᏓᏓᏁᏥᏍᏚᎶᏗᏍᎨᏍᏗ, ᎡᎩᏍᏕᎸᏗᏱᏃ ᎨᏒ ᎤᏚᎩ ᎢᎬᏒ ᎢᎦᎵᏍᏚᎶᏕᏍᏗ.


text:
ᎠᎴ ᎢᏨᏔᏲᏎᎭ, ᎢᏓᎵᏅᏟ, ᏕᏤᏯᏔᎲᏍᎨᏍᏗ ᎾᏍᎩ Ꮎ ᏄᎾᏁᎸᎾ, ᏕᏥᎦᎵᏍᏓᏗᏍᎨᏍᏗ ᏗᏩᎾᎦᎳ ᏧᎾᏓᏅᏘ, ᏕᏥᏂᏴᏎᏍᏗ ᏗᏂᏩᎾᎦᎳᎢ, ᏗᏨᏂᏗᏳ ᎨᏎᏍᏗ ᎾᏂᎥ <n>[ᎤᏣᏘᏂ ᏂᎨᏣᏛᏁᎲᎢ.]</n>


text:
ᎤᏁᎳᏅᎯᏃ ᎤᏩᏒ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏁᎯ ᏂᎦᎷᎶᎬᎾ ᎢᏥᏅᎦᎸᏗ ᎨᏎᏍᏗ; ᎠᎴ ᏂᎬ ᎢᏣᏓᏅᏖᏗᏱ ᎠᎴ ᏗᏣᏓᏅᏙ ᎠᎴ ᏗᏥᏰᎸᎢ ᏤᏤᏍᏆᏂᎪᏓᏁᏗ ᎨᏎᏍᏗ, ᏂᏚᏚᎯᏍᏛᎾ ᎢᏣᎵᏍᏙᏗᏱ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎦᎷᏨ ᎢᏳᎢ.


text:
ᎣᎦᏚᏓᎳ ᏂᎪᎯᎸ ᎣᏣᎵᎡᎵᏤᏗᏱ ᎤᏁᎳᏅᎯ ᏂᎯ ᎢᏓᎵᏅᏟ ᎤᎬᏩᎵ, ᏥᏚᏳᎪᏗ ᎾᏍᎩ ᎢᏲᎦᏛᏁᏗᏱ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎢᏦᎯᏳᏒ ᎤᏣᏘ ᏣᏛᏍᎦ, ᎠᎴ ᏕᏣᏓᎨᏳᏒ ᏂᏥᎥ ᎢᏥᏏᏴᏫᎭ ᎨᏒ ᎤᏣᏘ ᏥᎧᏁᏉᎦ;


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏴ ᎣᎬᏒ ᎣᏣᏢᏈᏍᎦ ᎢᏨᏁᎢᏍᏗᏍᎬ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏍᏗᏒ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ, ᎾᏍᎩ ᏗᏨᏂᏗᏳ ᎨᏒ ᎠᎴ ᎢᏦᎯᏳ ᎨᏒ ᏂᎦᎥ ᎤᏕᏯᏙᏗ ᎠᎴ ᎠᎩᎵᏯ ᎢᏥᎷᏤᎲᎢ;


text:
ᏂᎯᏃ ᎡᏥᎩᎵᏲᎢᏍᏗᏍᎩ, ᎠᏣᏪᏐᎸᏍᏙᏗ ᎨᏒ ᎡᎦᎫᏴᏓᏁᏗᏱ, ᎾᎯᏳ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎸᎶ ᏅᏓᏳᏓᎴᏅᎯ ᎬᏂᎨᏒ ᎾᎬᏁᎸᎭ ᎠᏁᎮᏍᏗ ᏧᎾᎵᏂᎩᏛ ᏧᏤᎵ ᏗᏂᎧᎿᏩᏗᏙᎯ,


text:
ᎾᎯᏳ ᏧᏤᎵ ᎤᎾᏓᏅᏘ ᎬᏩᎸᏉᏙᏗᏱ ᎤᎬᏩᎵ ᎦᎷᏨᎭ, ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᏧᏓᏅᏓᏗᏍᏙᏗᏱ ᎾᏂᎥ ᎾᏍᎩ Ꮎ ᎬᏬᎯᏳᎲᏍᎩ ᎾᎯᏳ ᎢᎦ ᎨᏎᏍᏗ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎪᎯᏳᏅᎯ ᎨᏒ ᎣᎩᏃᎮᎸ ᎢᏤᎲᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᏉ ᏂᎪᎯᎸ ᎣᏣᏓᏙᎵᏍᏗᏍᎪ ᎢᏨᏯᏅᏓᏗᏍᎪ, ᎾᏍᎩ ᎣᎦᏁᎳᏅᎯ ᎤᏓᏯᏅᏗ ᎨᏒ ᎢᏥᏯᏅᏔᏅᎯ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᎤᏍᏆᏗᏍᏗᏱ ᏂᎦᏛ ᎣᏍᏛ ᎤᏰᎸᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ ᎤᏓᏅᏘᏳ ᎨᏒᎢ, ᎠᎴ ᎪᎯᏳᏗ ᎨᏒ ᏧᎸᏫᏍᏓᏁᏗ ᎬᏔᏅᎯ ᎤᎵᏂᎩᏛ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᏚᏙᎥ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᏓᎶᏁᏛ ᎦᎸᏉᏗᏳ ᎢᏳᎵᏍᏙᏗᏱ ᏂᎯ ᎢᏨᏂᏌᏛ, ᎠᎴ ᏂᎯ ᎦᎸᏉᏗᏳ ᎢᏰᏨᏁᏗᏱ ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ, ᎾᏍᎩᏯ ᏄᏍᏛ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎢᎦᏁᎳᏅᎯ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎾᏍᎩ ᏞᎩᏉ ᏤᏥᏖᎸᎾᏗᏱ ᏂᎨᏒᎾ ᏕᏣᏓᏅᏛᎢ, ᎠᎴ ᎢᏣᏕᏯᏔᏁᏗᏱ ᏂᎨᏒᎾ, ᎾᏍᏉ ᎠᏓᏅᏙ ᎬᏗ, ᎠᎴ ᎦᏬᏂᏒᎯ, ᎠᎴ ᎪᏪᎵ ᎪᏪᎳᏅᎯ ᎬᏗ ᎠᏴ ᎣᎦᏓᏅᏏᏛ ᏥᎨᏐ ᎢᏳᏍᏗ; ᎾᏍᎩ ᎦᎶᏁᏛ ᎤᏤᎵ ᎢᎦ ᎤᏍᏆᎸᎯᏕᏅ ᏥᎨᏐ ᎾᏍᎩᏯᎢ.


text:
ᎠᏎ ᏞᏍᏗ ᎩᎶ ᏱᏥᎵᏓᏍᏔᏁᏍᏗ; ᎥᏝᏰᏃ <n>[ᎾᎯᏳ ᎢᎦ ᎤᎵᏰᎢᎶᎯᏍᏗ ᏱᎩ]</n> ᎬᏂ ᎢᎬᏱ ᎠᏂᏑᎵᎪᎨᏍᏗ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎠᏍᎦᏯ ᎠᏍᎦᎾ ᏧᎸᏫᏍᏓᏁᎯ ᎬᏂᎨᏒ ᎾᎬᏁᎸᎭ, ᎾᏍᎩ ᎠᏛᏗᏍᎩ ᎤᏪᏥ;


text:
ᎾᏍᎩ ᏥᏓᎦᏘᎴᎦ ᎠᎴ ᎦᎸᎳᏗᏢ ᏥᎾᏓᏛᏁᎭ ᏂᎦᎥ ᎤᎾᎳᏅᎯ ᎨᎪᏎᏗ ᏥᎩ, ᎠᎴ ᎨᎦᏓᏙᎵᏍᏓᏁᎯ ᏥᎩ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎾᏍᎩᏯ ᎤᏬᎳ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸᎢ, ᎤᏩᏒ ᎬᏂᎨᏒ ᎾᏓᏛᏁᎭ ᎤᏁᎳᏅᎯ ᎨᏒᎢ.


text:
ᎠᎴ ᎬᏗᏍᎨᏍᏗ ᎤᏣᏘ ᎤᏓᎵᏓᏍᏗ ᏂᏚᏳᎪᏛᎾ ᎨᏒ ᎠᏁᎲ ᎾᏍᎩ ᎨᏥᏛᏙᏗ ᎨᏒᎢ; ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᏂᏚᎾᏓᏂᎸᏨᎾ ᎨᏒ ᏚᏳᎪᏛ ᎠᎨᏳᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎦᎨᏥᏍᏕᎸᏗ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎠᏎᏃ ᎣᎦᏚᏓᎳ ᏂᎪᎯᎸ ᎣᏣᎵᎡᎵᏤᏗᏱ ᎤᏁᎳᏅᎯ ᏂᎯ ᎨᏒ ᎤᎬᏩᎵ, ᎢᏓᎵᏅᏟ ᎤᎬᏫᏳᎯ ᎢᏥᎨᏳᎯ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏁᎳᏅᎯ ᏧᏓᎴᏅᎲ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎢᏣᏑᏰᏒ ᎡᏥᏍᏕᎸᏗᏱ ᎬᏙᏗᏱ ᎠᏓᏅᏙ ᎢᏥᏅᎦᎵᏍᎬᎢ, ᎠᎴ ᎢᏦᎯᏳᏒ ᎤᏙᎯᏳᎯ ᎨᏒᎢ;


text:
ᎾᏍᎩᏃ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎤᏩᏒ, ᎠᎴ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎢᎩᏙᏓ, ᎾᏍᎩ ᎢᎩᎨᏳᎯᏳ ᏥᎨᏒᎩ, ᎠᎴ ᏥᎩᏁᎸ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎠᏓᎦᎵᏍᏓᏗᏍᎩ, ᎠᎴ ᎣᏍᏛ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ,


text:
ᎤᎵᏍᏆᎸᏗᏃ ᎨᏒᎢ, ᎢᏓᎵᏅᏟ, ᎢᏣᏓᏙᎵᏍᏗᏍᎨᏍᏗ ᎠᏴ ᏍᎩᏯᏅᏓᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᎧᏃᎮᏛ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ ᎤᏰᎵᎯᏍᏗᏱ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩᏯ ᏥᏄᏍᏗ ᏂᎯ ᎢᏤᎲᎢ;


text:
ᎿᏉᏃ ᎢᏨᏁᏤᎭ, ᎢᏓᎵᏅᏟ, ᎣᏨᏗᎭ ᏚᏙᎥ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᏗᏣᏓᏓᎴᏓᏁᏗᏱ ᎾᏂᎥ ᎠᎾᎵᏅᏟ ᎤᏣᏘᏂ ᎢᏯᎾᏛᏁᎵᏙᎯ, ᎠᎴ ᏂᏓᏂᎧᎿᏩᏕᎬᎾ ᏗᏕᏲᏗ ᎨᏒ ᎠᏴ ᏗᎪᎦᏓᏂᎸᏤᎸᎯ,


text:
ᎾᏍᎩᏃ ᎢᏳᎾᏍᏗ ᎨᏒᎢ, ᏙᏥᏁᏤᎭ ᎠᎴ ᏙᏥᏍᏗᏰᏗᎭ ᏙᏥ-ᏁᎢᏍᏓᏁᎭ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᏙᎯᏉ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ, ᎠᎴ ᎤᏅᏒ ᎤᎾᏤᎵ ᎠᎵᏍᏓᏴᏗ ᎤᎾᎵᏍᏓᏴᏙᏗᏱ.


text:
ᏫᎬᏲᏪᎳᏏ ᏘᎹᏗ ᎠᏋᏒ ᎠᏆᏤᎵ ᎠᏇᏥ ᎪᎯᏳᏗ ᎨᏒ ᎢᏳᏩᏂᏌᏛ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᎤᏓᏙᎵᏣᏛ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᏕᏣᎧᎿᏩᏗᏙᎮᏍᏗ ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁ-ᎳᏅᎯ ᎢᎩᏙᏓ ᎠᎴ ᏥᏌ ᎦᎶᏁᏛ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ.


text:
ᎠᎴ ᎤᎾᏛᏓᏍᏙᏗᏱ ᏂᎨᏒᎾ ᎠᏎᏉ ᎦᏬᏂᎯᏍᏗ ᎨᏒ ᎠᎴ ᏫᎾᏍᏛᎾ ᎧᏃᎮᏗ ᎨᏒ ᎤᎾᏓᏁᏟᏴᏒᏒᎢ, ᎾᏍᎩ ᎦᏬᏂᎯᏍᏗᏉ ᏥᏩᎵᏱᎶᎯᎭ ᎥᏲᏃ ᎤᏁᎳᏅᎯ ᏗᏁᎳᏙᏗ ᎨᏒ ᎤᏛᎯᏍᏗᏱ, ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ, <n>[ᎾᏍᎩ ᎿᏛᏁᎸᎭ.]</n>


text:
ᎯᎠ ᎾᏍᏉ ᏯᎦᏔᎭ, ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏓᏅᏘ ᏴᏫ ᎠᎪᏢᎾᏁᎸᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏗᎧᎿᏩᏛᏍᏗᏍᎩᏂ ᏂᏚᎾᏁᎶᏛᎾ, ᎠᎴ ᏄᏃᎯᏳᏒᎾ, ᎤᏁᎳᏅᎯ ᏂᏚᎾᏁᎶᏛᎾ, ᎠᎴ ᎠᏂᏍᎦᎾᎢ, ᎠᏂᎦᏓᎭᎢ, ᎠᎴ ᎣᏍᏛ ᎨᏒ ᎠᏂᏂᏆᏘᎯ, ᏧᏂᏙᏓ ᏗᏂᎯᎯ ᎠᎴ ᏧᏂᏥ ᏗᏂᎯᎯ, ᏴᏫ ᏗᏂᎯᎯ,


text:
ᎠᏴ ᎾᏍᎩ ᎢᎸᎯᏳ ᏥᏐᏢᏗᏍᎩ ᏥᎨᏒᎩ, ᎠᎴ ᎤᏲ ᎢᏗᎬᏁᎯ, ᎠᎴ ᏗᎦᏂᏐᏢᏗ; ᎠᏎᏃ ᎥᎩᏙᎵᏨᎩ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏂᏥᎦᏔᎿᎥᎾ ᎨᏒᎢ, ᎠᎴ ᎾᏉᎯᏳᏒᎾ ᎨᏒ ᎾᏍᎩ ᎾᏆᏛᏁᎸᎢ.


text:
ᎠᏎᏃ ᎾᏍᎩ ᎯᎠ ᏅᏓᏳᎵᏍᏙᏔᏅᎩ ᎥᎩᏙᎵᏨᎩ; ᎾᏍᎩ ᎠᏴ ᎨᏒ ᎾᎩᎬᏫᏳᏒ ᏥᏌ ᎦᎶᏁᏛ ᎬᏂᎨᏒ ᎢᏳᏩᏁᏗᏱ ᏩᏍᏛ ᎬᏂᏗᏳ ᎨᏒᎢ, ᎾᏍᎩ ᏧᎾᏟᎶᏍᏙᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎣᏂ ᎬᏬᎯᏳᏅᎯ ᎬᏂᏛ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᏫᏚᎷᎩ.


text:
Ꭷ, ᎤᎬᏫᏳᎯ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎨᏒ ᎡᎯ, ᎠᏲᎱᏍᎩ ᏂᎨᏒᎾ, ᎠᎪᏩᏛᏗ ᏂᎨᏒᎾ, ᎤᏩᏒᎯ ᎠᎦᏔᎿᎢ ᎤᏁᎳᏅᎯ, ᎦᎸᏉᏗᏳ ᎨᏎᏍᏗ ᎠᎴ ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸᎢ; ᎡᎺᏅ.


text:
ᎠᎴ ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏂᎨᏴ ᏓᎾᏣᎤᏍᎬ ᎤᏢᏉᏗ ᏂᎨᏒᎾ ᏓᎾᏄᏬᏍᎨᏍᏗ, ᎤᎾᏓᎾᏰᎯᏍᏗ ᎠᎴ ᎤᎾᎵᏏᎾᎯᏍᏗ ᎨᏎᏍᏗ; ᎥᏝᏍᏗᏃ ᏓᏂᏍᏕᏲᎲ ᏚᏂᏍᏘᏰᎬᎢ, ᎠᎴ ᎠᏕᎸ ᏓᎶᏂᎨ, ᎠᎴ ᏓᎬᎾ-ᎢᏳᎾᏍᏗ, ᎠᎴ ᎤᏣᏘ ᏧᎬᏩᎶᏗ ᏗᏄᏬ ᏱᏓᎾᏣᏅᏗᏍᎨᏍᏗ;


text:
ᎠᏎᏍᎩᏂᏃᏅ ᎠᏥᏍᏕᎸᏗ ᎢᎨᏎᏍᏗ ᏗᏂᏲᎵ ᏕᎦᎾᏄᎪᏫᏍᎬᎢ, ᎢᏳᏃ ᏌᏂᎧᎿᏩᏏᏎᏍᏗ ᎪᎯᏳᏗ ᎨᏒ, ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒᎢ, ᎠᎴ ᏚᏳᎪᏛ ᎨᏒᎢ, ᎠᎴ ᎠᎵᏏᎾᎯᏍᏙᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᎠᏂᏯᏙᎯᎯ ᎨᏥᎸᏉᏗ ᎨᏎᏍᏗ, ᎥᏞᏍᏗ ᏧᏓᎴᏅᏛ ᎢᏯᏂᏪᏍᎩ ᏱᎨᏎᏍᏗ, ᎠᎴ ᎥᏞᏍᏗ ᏱᎦᎨᎠᏗᏔᏍᏗ ᎤᏂᎦᎾᏏᏍᎩ ᏱᎨᏎᏍᏗ, ᏞᏍᏗ ᏧᎬᏩᎶᏗ ᎤᏂᎬᎥᏍᎩ ᏱᎨᏎᏍᏗ;


text:
ᎢᏳᏍᎩᏂᏃᏅ ᎠᏉᎯᏤᎵᏙᎸᎭ ᎾᏍᎩ ᏣᏙᎴᎰᎯᏍᏗᏱ ᎢᏣᏛᏁᏗᏱ ᏗᏣᎸᏫᏍᏓᏁᏗᏱ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸᎢ, ᎾᏍᎩ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᎬᏂᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᏥᎩ, ᎦᎫᏍᏛᏗ ᎠᎴ ᎤᎵᏍᏓᏱᏙ ᏥᎩ ᏚᏳᎯᏛ ᎨᏒᎢ.


text:
ᎠᎴ ᏄᏜᏏᏛᏒᎾ ᎤᏍᏆᏂᎪᏗᏳ ᎤᏕᎵᏛ ᎤᏁᎳᏅᎯ ᏗᏁᎶᏗ ᎨᏒᎢ; ᎤᏁᎳᏅᎯ ᎬᏂᎨᏒ ᎾᎬᏁᎴ ᎤᏬᏓᎵ ᎨᏒᎢ, ᏄᏠᎾᏍᏛᎾ ᎬᏂᎨᏒ ᏄᏩᏁᎴ ᎠᏓᏅᏙ, ᏗᏂᎧᎿᏩᏗᏙᎯ ᎬᏩᎪᎮᎢ, ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎨᎦᎵᏥᏙᏁᎴ ᎾᏍᎩ ᎠᏥᏃᎮᏍᎨᎢ, ᎠᏂ ᎡᎶᎯ ᎠᎪᎢᏳᏁᎢ, ᎦᎸᏉᏗᏳ ᏗᎨᏒ ᏫᏓᎦᏓᏂᎸᏤᎢ.


text:
ᎤᏂᏅᏍᏙᏍᎨᏍᏗ ᏗᏨᏍᏗᏱ, ᎠᏂᏁᎨᏍᏗ ᎪᎱᏍᏗ ᎢᏳᏍᏗ ᎠᎵᏍᏓᏴᏗ ᏗᏲᎯᏍᏗᏱ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏬᏢᏅᎯ ᏥᎩ ᎤᎵᎮᎵᏨᎯᏉ ᏧᎾᏓᏂᎸᎢᏍᏗᏱ ᎠᏃᎯᏳᎲᏍᎩ ᎠᎴ ᎤᏂᎦᏙᎥᏒᎯ ᏥᎩ ᏚᏳᎪᏛᎢ.


text:
ᎢᏳᏃ ᎠᎾᎵᏅᏟ ᎯᎠ ᎾᏍᎩ ᏱᎩᏯᏅᏓᏗᏍᏔᏅ, ᎰᏍᏛ ᎨᏎᏍᏗ ᎡᏣᏅᏏᏓᏍᏗ ᏥᏌ ᎦᎶᏁᏛ ᎤᏤᎵᎦ, ᎡᏤᎳᏍᏔᏅᎯ ᎨᏎᏍᏗ ᎧᏃᎮᏛ ᎪᎯᏳᏗ ᎨᏒ ᏥᎧᏃᎮᎭ, ᎠᎴ ᎣᏍᏛ ᏗᏕᏲᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎦᏳᎳ ᏗᏣᏂᏴᏛ ᏥᎩ.


text:
ᎠᏰᎸᎢᏰᏃ ᎤᎬᏩᎵ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎤᏍᏗᎩᏳ ᎠᏓᏍᏕᎵᎭ; ᎤᏁᎳᏅᎯᏍᎩᏂ ᏗᏁᎶᏙᏗ ᎨᏒ ᏂᎦᎥ ᎪᎱᏍᏗ ᎤᎬᏩᎵ ᎬᏩᏓᏍᏕᎸᏗ, ᎾᏍᎩᏰᏃ ᎠᏚᎢᏍᏗ ᎠᏥᏁᏗᏱ ᎬᏅ ᎪᎯ ᏥᎩ, ᎠᎴ ᎾᏍᎩ ᎤᎵᏱᎶᎯᏍᏗ ᎨᏒᎢ.


text:
ᎾᏍᎩᏰᏃ ᎢᏳᏍᏗ ᏕᎩᎸᏫᏍᏓᏁᎭ ᎠᎴ ᎦᏰᎩᏐᏢᏗᎭ ᏅᏗᎦᎵᏍᏙᏗ ᎡᏓᎵᏍᎦᏍᏙᏛ ᎬᏂᏛ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᏗᏍᏕᎵᏍᎩ ᏥᎩ ᎾᏂᎥ ᏴᏫ, ᎾᏍᎩ Ꮀ ᎤᎬᏫᏳᎭ ᎾᏍᎩ Ꮎ ᎠᏃᎯᏳᎲᏍᎩ.


text:
ᏞᏍᏗ ᎩᎶ ᏳᏐᏅᏤᎴᏏᏗ ᎯᏫᏂᏳ ᎨᏒᎢ; ᎦᎨᏣᏕᎶᏆᎡᏗᏍᎩᏂ ᎨᏎᏍᏗ ᎠᏃᎯᏳᎲᏍᎩ, ᎯᏬᏂᏍᎬᎢ ᎠᎴ ᏂᏣᏛᎿᏕᎬᎢ, ᎠᎴ ᏣᏓᎨᏳᎡᎢ, ᎠᎴ ᏣᏓᏅᏖᏗᏱ, ᎠᎴ ᏦᎯᏳᏒᎢ, ᎠᎴ ᎦᏓᎭᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎢᏳᏍᎩᏂ ᎩᎶ ᎤᏬᏑᎶᏨᎯ ᏧᏪᏥ ᎠᎴ ᏧᎵᏏ ᏯᏁᎭ, ᎾᏍᎩ ᎠᎾᏕᎶᏆᏍᎨᏍᏗ ᏧᏂᎸᏉᏙᏗᏱ ᏙᏧᏁᏅᏒ ᎠᏁᎯ, ᎠᎴ ᏧᎾᎫᏴᎡᏗᏱ ᏧᏂᎦᏴᎵᎨᎢ; ᎾᏍᎩᏰᏃ ᎣᏏᏳ, ᎠᎴ ᏧᏓᏂᎸᎢᏍᏗᏳ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ.


text:
ᎾᏍᎩᏰᏃ Ꮎ ᎤᏙᎯᏳᎯ ᎤᏬᏑᎶᏨᎯ ᏥᎨᏐᎢ, ᎠᎴ ᎤᏩᏒᎯᏳ ᏥᎨᏐᎢ, ᎤᏁᎳᏅᎯ ᎠᎵᏍᎦᏍᏙᏗᏍᎪᎢ, ᎠᎴ ᏓᎧᎿᏩᏗᏐ ᎠᏔᏲᏍᏗ ᎨᏒ ᎠᎴ ᎠᏓᏙᎵᏍᏙᏗ ᎨᏒ ᏂᏚᎵᏏᏂᏒ ᎠᎴ ᏂᏚᎩᏨᏂᏒᎢ.


text:
ᎢᏳᏍᎩᏂᏃ ᎩᎶ ᏂᏓᏛᏅᎢᏍᏓᏁᎲᎾ ᎢᎨᏎᏍᏗ ᎤᏩᏒ ᏧᏤᎵᎦ, ᎠᎴ ᎾᏍᎩ Ꮀ ᎤᎬᏫᏳᎭ ᎤᏩᏒ ᏚᏓᏘᎿᎥᎢ, ᎾᏍᎩ ᎤᏓᏱᎸ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏟ ᎤᏲᎢᏳ ᎡᏍᎦᏉ Ꮎ ᏄᏬᎯᏳᏒᎾ.


text:
ᎢᏳᏃ ᎣᏍᏛ ᎠᏥᏃᎮᏍᎩ ᎨᏎᏍᏗ ᎣᏏ ᏕᎤᎸᏫᏍᏓᏁᎲᎢ, ᎢᏳᏃ ᏗᏂᏲᎵ ᏧᏛᎯᏍᏔᏅᎯ ᎨᏎᏍᏗ, ᎢᏳᏃ ᎠᏁᏙᎯ ᏧᏍᏆᏂᎪᏔᏅᎯ ᎨᏎᏍᏗ, ᎢᏳᏃ ᎤᎾᏓᏅᏘ ᏧᎾᎳᏏᏕᏂ ᏧᏬᏑᎴᎸᎯ ᎨᏎᏍᏗ, ᎢᏳᏃ ᏧᏍᏕᎸᏛ ᎨᏎᏍᏗ ᎠᏂᎩᎵᏲᎩ, ᎢᏳᏃ ᎤᏍᏓᏩᏛᏛ ᎨᏎᏍᏗ ᏂᎦᎥ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ.


text:
ᎠᎴ ᎾᏍᏉ ᎠᎾᏕ-ᎶᏆᏍᎪ ᎤᎾᏓᏄᎸᏗ ᎢᏳᎾᎵᏍᏙᏗᏱ, ᎠᏁᏙᎵᏙᎰ ᏓᏓᏁᎳᏗᏒᎢ; ᎥᏝ ᎠᎴ ᎤᎾᏓᏄᎸᏗᏉ ᎤᏩᏒ ᏱᎨᏐᎢ, ᎾᏍᏉᏍᎩᏂ ᎧᏃᎮᏛ ᎠᏂᏱᏙᎯ ᎨᏐᎢ ᎠᎴ ᎤᏂᏂᎳᏗᏌᏘ, ᎠᏂᏃᎮᏍᎩ ᎾᏍᎩ ᏂᏚᏳᎪᏛᎾ ᎨᏒ ᎤᏂᏃᏄᏍᎩ ᎾᏍᎩ ᏂᏚᏳᎪᏛᎾ ᎨᏒ ᎤᏂᏃᎮᏗᏱ.


text:
ᎾᏍᎩᏃ ᎢᏳᏍᏗ ᎠᏆ-ᏚᎵᎭ ᎠᏂᏫᏅᎨᏌᏂ ᏧᎾᏨᏍᏗᏱ, ᏗᏂᏲᎵ ᏧᏂᎾᏄᎪᏫᏍᏗᏱ, ᏧᏂᏍᏆᏂᎪᏙᏗᏱ ᏓᏂᏁᎸᎢ, ᎠᎴ ᎬᏩᎾᏡᏗᏍᎩ ᏧᏂᎳᏅᏓᏕᏗᏱ ᏂᎨᏒᎾ ᎨᏒ ᎤᏐᏅ ᎬᏩᏂᏃᎮᏗᏱ.


text:
ᎢᏳᏃ ᎩᎶ ᎪᎯᏳᎲᏍᎩ ᎠᏍᎦᏯ ᎠᎴ ᎠᎨᏴ ᏚᏪᎧᎮᏍᏗ ᏧᏃᏑᎶᏨᎯ, ᎤᏅᏒᏉ ᏗᏂᏍᏕᎵᏍᎨᏍᏗ, ᏞᏍᏗᏃ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏱᏚᏂᏓᏁᎴᏍᏗ, ᎾᏍᎩ ᏗᎬᏩᏂᏍᏕᎸᏗ ᏱᎩ ᎤᏙᎯᏳᏒ ᏧᏃᏑᎶᏅᎯ ᎨᏒᎢ.


text:
ᎬᏁᏤᎭ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎠᎴ ᎨᎦᏑᏰᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎠᏂᎦᏔᎲᎢ, ᎯᎠ ᎾᏍᎩ ᏣᎦᏌᏯᏍᏙᏗᏱ ᎢᎬᏱ ᎦᏰᎯ ᏂᏚᎪᏗᏍᎬᎾ, ᎠᎴ ᏕᏣᎸᏫᏍᏓᏁᎲ ᎩᎶ ᏂᏯᎵᎪᏁᎲᎾ.


text:
ᎾᏃ ᎠᏃᎯᏳᎲᏍᎩ ᏗᎬᏩᏂᎾᏝᎢ ᎨᏒ ᏞᏍᏗ ᏱᏚᏂᏂᏆᏘᎴᏍᏗ ᏱᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎠᎾᎵᏅᏟ ᎨᏒᎢ, ᎪᎱᏍᏗᏍᎩᏂ ᏓᎾᏛᏁᎮᏍᏗ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎠᏃᎯᏳᎲᏍᎩ ᎠᎴ ᎨᏥᎨᏳᎢ ᎨᏒᎢ, ᎤᎾᏠᏯᏍᏗᏍᎩ ᎣᏍᏛ ᎾᎦᏛᏁᎸᎢ. ᎾᏍᎩ ᎯᎠ ᏄᏍᏕᏍᏗ ᏕᎭᏕᏲᎲᏍᎨᏍᏗ, ᎠᎴ ᏕᎯᏁᏤᎮᏍᏗ.


text:
ᎢᏳᏃ ᎩᎶ ᎤᏣᏘᏂ ᏂᎦᏪᏍᎨᏍᏗ ᏓᏕᏲᎲᏍᎨᏍᏗ, ᎠᎴ ᎣᏏ ᎾᏰᎸᏍᎬᎾ ᎢᎨᏎᏍᏗ ᎣᏍᏛ ᎤᏬᏂᏒ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ, ᎠᎴ ᏗᏕᏲᏗ ᎨᏒ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᏗᏂᎶᏙᏗ ᎨᏒ ᏥᏓᏕᏲᎲᏍᎦ;


text:
ᎾᏍᎩ Ꮎ ᎤᏢᏉᏗ, ᎪᎱᏍᏗ ᎾᎦᏔᎲᎾ, ᎤᎵᏰᏔᏁᎯ ᎦᏬᏂᎯᏍᏗ ᎨᏒ, ᎠᎴ ᏧᏘᏲᏌᏘ ᎠᎵᏃᎮᏍᎬᎢ, ᎾᎿ ᏨᏗᏓᎴᎲᏍᎦ ᎠᏛᏳᎨᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏗᏒᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏐᏢᎢᏍᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎪᎱᏍᏗ ᏗᏓᏕᎵᏎᏗ ᎨᏒᎢ,


text:
ᎠᎴ ᎬᏍᎦᎢᏍᏓᎩ ᎤᏂᏬᏂᎯᏍᏗ ᎨᏒ ᏴᏫ ᎤᎪᏏᏛ ᏧᎾᏓᏅᏘ, ᎤᏂᏂᎩᏛ ᏚᏳ-ᎪᏛᎢ, ᎨᏅᎢᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᏗᏁᎶᏙᏗ ᎢᏧᎳᎭ ᎠᏁᎵᏍᎩ. ᎾᏍᎩ ᎢᏳᎾᏍᏗ ᏕᎭᏓᏅᎡᎮᏍᏗ.


text:
ᎤᎾᏚᎵᏍᎩᏍᎩᏂ ᏥᎩ ᎤᏁᏅᎢᏍᏗᏱ, ᎤᏓᎴᎾᏍᏗᏱ ᎠᎴ ᎠᏌᏛ ᏫᏓᏂᏅᎪᎢ, ᎠᎴ ᎤᏣᏘ ᎢᏳᏓᎴᎩ ᎤᎵᏍᎦᏂᏍᏛ ᎠᎴ ᎤᏲ ᎢᏯᏓᏛᏁᎯ ᎠᎬᎥᎯᏍᏗ ᎨᏒᎢ; ᎾᏍᎩ ᏥᏚᏂᏃᏴᏘᏍᏗᎭ ᏴᏫ ᎾᎿ ᎠᎩᎵᏲᎢᏍᏗ ᎨᏒ ᎠᎴ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ.


text:
ᏂᎯᏍᎩᏂ ᎯᏍᎦᏯ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎾᏍᎩ ᎯᎠ ᏕᎭᏓᏅᎡᎮᏍᏗ, ᎠᎴ ᏕᎯᏍᏓᏩᏗᏎᏍᏗ ᏚᏳᎪᏛ ᎨᏒᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎦᎾᏰᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒᎢ, ᎠᎴ ᎬᏂᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎤᏓᏅᏘᏳ ᎨᏒᎢ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎲᏗᏍᎨᏍᏗ ᎣᏍᏛ ᎠᎵᏍᏗ ᎨᏒ ᎭᎵᎮᏍᏗ. ᎾᎵᏍᏆᏗᏍᎬᎾ ᎬᏂᏛ ᎨᏒ ᏘᏂᏴ, ᎾᎿ ᎾᏍᏉ ᎡᏣᏯᏅᏛ ᏥᎩ, ᎠᎴ ᏣᏃᏅᎯ ᏥᎩ ᎣᏍᏛ ᎧᏃᎮᏗ ᎨᏒ ᎤᏂᏣᏘ ᎠᏂᎦᏔᎯ ᎠᏂᏚᏔᎲᎢ.


text:
ᎾᏍᎩ ᏨᎦᎾᏄᎪᏫᏏ ᎾᎯᏳ ᏧᎾᏄᎪᏫᏎᏗ ᎨᏒᎢ, ᎾᏍᎩ ᏅᏩᏙᎯᏯᏛ ᎤᏓᏅᏘ ᎠᎴ ᎤᏩᏒᎯ ᎤᎵᏂᎩᏛ ᎨᏒᎢ, ᎤᎬᏫᏳᎯ ᎤᏂᎬᏫᏳᎯ ᎠᏁᎲᎢ, ᎠᎴ ᎤᎬᏫᏳᏌᏕᎩ ᏄᏂᎬᏫᏳᏌᏕᎩ ᎠᏁᎲᎢ;


text:
ᎾᏍᎩ ᎤᏩᏒᎯ ᎠᏲᎱᎯᏍᏗ ᏂᎨᏒᎾ ᎨᏒ ᎤᎯ, ᎢᎦᎦᏛ ᎡᎯ ᎨᏒᎢ, ᎾᏍᎩ ᎢᎦᎦᏛ ᎾᎿ ᎩᎶ ᎬᏩᎷᎯᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎾᏍᎩ ᎩᎶ ᎤᎪᎲᎩ ᏂᎨᏒᎾ, ᎠᎴ ᎬᏩᎪᏩᏛᏗ ᏂᎨᏒᎾ ᎨᏒᎢ; ᎾᏍᎩ ᎠᏥᎸᏉᏗᏳ ᎨᏎᏍᏗ ᎠᎴ ᎤᎵᏂᎩᏗ ᎨᏒ ᏫᎾᏍᏛᎾ ᎨᏎᏍᏗ. ᎡᎺᏅ.


text:
ᎩᏁᏤᎮᏍᏗ ᏧᏁᎿᎢ ᏥᎩ ᎠᏂ ᎡᎶᎯ ᎾᏍᎩ ᎤᎾᏢᏉᏗ ᏱᏉ ᏂᎨᏒᎾ, ᎠᎴ ᎤᎾᎵᏍᎦᏍᏙᏙᏗᏱ ᏂᎨᏒᎾ ᎤᏓᎵᏓᏍᏗ ᎨᏅᎢᏍᏗ ᎨᏒᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎬᏂᏛ ᎠᎾᎵᏍᎦᏍᏙᏗᏍᎨᏍᏗ ᎾᏍᎩ ᎤᏣᏘ ᎢᎩᏁᎯ ᏥᎩ ᎾᎦᎥ ᏄᏓᎴᏒ ᎣᏍᏛ ᎢᎦᎵᏍᏓᏁᏗ.


text:
ᏫᎬᏲᏪᎳᏏ ᏗᎹᏗ ᎬᎨᏳᎢ ᎠᏇᏥ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᎤᏓᏙᎵᏣᏛ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᏕᏣᎧᎿᏩᏗᏙᎮᏍᏗ ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎢᎩᏙᏓ ᎠᎴ ᎦᎶᏁᏛ ᏥᏌ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ.


text:
ᏥᏯᎵᎡᎵᏤ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᏥᏕᏥᏯᏁᎶᏗ, ᎾᏍᎩᏯ ᏗᎩᎦᏴᎵᎨ ᏄᎾᏛᏁᎸᎢ, ᏥᎬᏗᎭ ᎦᏓᎭ ᏂᎨᏒᎾ ᎠᏆᏓᏅᏙ, ᏂᏥᏲᎯᏍᏗᏍᎬᎾ, ᎢᎦ ᎠᎴ ᏒᏃᏱ ᎬᏯᏅᏓᏗᏍᎬ ᎦᏓᏙᎵᏍᏗᏍᎬᎢ,


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏞᏍᏗ ᏯᏕᎰᏍᎨᏍᏗ ᎯᏃᎮᏍᎬ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ, ᎠᎴ ᏞᏍᏗ ᏱᏍᏆᏕᎰᏍᎨᏍᏗ ᎠᏴ ᏥᏴᎩ ᎾᏍᎩ ᎤᏤᎵᎦ, ᏤᎳᏗᏍᏗᏍᎨᏍᏗᏍᎩᏂ ᎠᎩᎵᏲᎬ ᎣᏍᏛ ᎧᏃᎮᏛ, ᏣᏍᏕᎵᏍᎨᏍᏗ ᎤᎵᏂᎩᏗ ᎨᏒ ᎤᏁᎳᏅᎯ,


text:
ᎾᏍᎩ ᎢᎩᏍᏕᎸᏛ ᏥᎩ, ᎠᎴ ᎢᎩᏯᏅᏛ ᏥᎩ ᎤᏩᏔᏅᎯ ᎦᎸᏉᏗ ᎠᏓᏯᏅᏗ ᎨᏒᎢ, ᎥᏝ ᎠᏴ ᏕᎩᎸᏫᏍᏓᏁᎲ ᏱᏅᏧᎵᏍᏙᏔᏅ, ᎤᏩᏒᏍᎩᏂ ᎤᏓᏅᏖᎸᎢ ᎠᎴ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏅᏧᎵᏍᏙᏔᏅ, ᎾᏍᎩ ᎢᎩᏁᎸᎯ ᏥᎩ ᏅᏧᏓᎴᏅᎲᎾ, ᏥᏌ ᎦᎶᏁᏛ ᎨᏒ ᎢᏳᏍᏗ,


text:
ᎪᎯᏃ ᎨᏒ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ ᎾᏍᎩ ᎤᎾᏄᎪᏥᎸ ᎢᎩᏍᏕᎵᏍᎩ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᎤᏲᏍᏔᏅᎯ ᏥᎩ ᎠᏲᎱᎯᏍᏗ ᎨᏒ, ᎠᎴ ᎤᎾᏄᎪᏫᏒᎯ ᏥᎩ ᎬᏂᏛ ᎠᎴ ᎠᏲᎱᎯᏍᏗ ᏂᎨᏒᎾ ᎨᏒ, ᎣᏍᏛ ᎧᏃᎮᏛ ᎬᏔᏅᎯ,


text:
ᎾᏍᎩ ᎾᏍᏉ ᏅᏗᎦᎵᏍᏙᏗᎭ ᎯᎠ ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᏥᎩᎵᏲᎦ; ᎠᏎᏃ ᎥᏝ ᏱᎦᏕᎣᏍᎦ; ᏥᎦᏔᎭᏰᏃ ᎾᏍᎩ ᏥᏥᏯᎵᏍᎦᏍᏙᏔᏅ, ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎠᏉᎯᏳᎭ ᏰᎵᏉ ᎬᏩᏍᏆᏂᎪᏙᏗ ᎨᏒ ᎾᏍᎩ ᏥᏥᏯᎨᏅᏴ ᎬᏂ ᎾᎯᏳ ᎢᎦ ᎠᏍᏆᎲᎭ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᎩ ᎨᎵᎭ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᎾᏆᎵᏍᏓᏁᎵᏙᎲᎢ ᎨᎦᏑᏰᏛ ᏅᏗᎦᎵᏍᏙᏗᎭ, ᎠᎴ ᎤᏂᏩᏛᏗᏱ ᎠᎵᏍᏕᎸᏙᏗ ᎾᏍᎩ ᏥᏌ ᎦᎶᏁᏛ ᏅᏓᏳᎵᏍᎪᎸᏔᏅᎯ, ᎠᎴ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎦᎸᏉᏗᏳ ᎨᏒᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᏕᎭᏅᏓᏗᏍᏗᏍᎨᏍᏗ, ᎤᎵᏂᎩᏛᏯ ᏕᎯᏁᏤᎮᏍᏗ ᎤᎬᏫᏳᎯ ᎠᎦᏔᎲᎢ, ᎤᎾᏗᏒᏍᏗᏱ ᏂᎨᏒᎾ ᎨᏒ ᏓᏂᏬᏂᏍᎬᎢ, ᎪᎱᏍᏗ ᎬᏙᏗ ᏂᎨᏒᎾ ᏥᎩ, ᏓᏂᎦᏔᎲᏍᎬᏉᏍᎩᏂ ᎬᏩᎾᏛᏓᏍᏓᏁᎯ.


text:
ᎠᏎᏍᎩᏂᏃᏅ ᎦᎫᏍᏛᏗ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎤᎵᏂᎩᏗᏳ ᏂᎬᏅ; ᎯᎠᏰᏃ ᏂᎬᏅ ᎪᏪᎸᎢ, ᎤᎬᏫᏳᎯ ᏓᎦᏔᎭ ᎾᏍᎩ ᏧᏤᎵᎦ; ᎠᎴ ᎯᎠ, ᎩᎶ ᎧᏁᎢᏍᏗᏍᎨᏍᏗ ᎦᎶᏁᏛ ᏚᏙᎥ ᎾᏍᎩ ᎠᏓᏅᎡᎮᏍᏗ ᎠᏍᎦᏂ.


text:
ᎠᏎᏃ ᎡᏆ ᏣᏓᏁᎶ ᎾᎿ ᏓᎰ ᏗᏖᎵᏙ ᎥᏝ ᎠᏕᎸᏉ ᏓᎶᏂᎨ ᎠᎴ ᎠᏕᎸᎤᏁᎬ ᎤᏩᏒ ᏗᎪᏢᏔᏅᎯ ᏱᎨᏐᎢ, ᎾᏍᏉᏍᎩᏂ ᎠᏓ ᎠᎴ ᎦᏓ ᏗᎪᏢᏔᏅᎯ; ᎠᎴ ᎢᎦᏛ ᏗᎦᎸᏉᏗ ᎢᎦᏛᏃ ᏗᎦᎸᏉᏗ ᏂᎨᏒᎾ.


text:
ᎢᏳᏃ ᎩᎶ ᎤᏓᏅᎦᎸᏛ ᏱᎩ ᎯᎠ ᎾᏍᎩ ᎨᏒᎢ, ᎾᏍᎩ Ꮎ ᎠᏖᎵᏙ ᎦᎸᏉᏗ ᎨᏎᏍᏗ, ᎦᎸᏉᏔᏅᎯ, ᎠᎴ ᏱᏍᏛ ᎢᎬᏁᎸᎯ ᎪᎱᏍᏗ ᎤᏩᏙᏗᏱ ᎦᏁᎳ; ᎠᎴ ᎠᏛᏅᎢᏍᏔᏅᎯ ᎾᎦᎥ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎤᎬᏩᎵ.


text:
ᎠᎴ ᏕᎭᏓᏅᎡᎮᏍᏗ ᎩᎳ ᏗᎾᏛᏍᎩ ᎤᎾᏚᎸᏅᏗ ᎨᏒᎢ; ᎯᏍᏓᏩᏕᎨᏍᏗᏃ ᏚᏳᎪᏛ ᎨᏒ, ᎠᎴ ᎪᎯᏳᏗ ᎨᏒ, ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒ, ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎨᏒᎢ, ᎢᏣᎵᎪᏎᏍᏗ ᎾᏍᎩ Ꮎ ᎤᎬᏫᏳᎯ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ ᎤᎾᏫ ᎦᏓᎭ ᏂᎨᏒᎾ ᎠᏅᏗᏍᎩ.


text:
ᎠᎴ ᎾᏍᎩᏯ ᏤᏂ ᎠᎴ ᏨᏈ ᏣᎾᏡᏗᏍᎨ ᎼᏏ ᎾᏍᎩᏯ ᎾᏍᏉ ᎯᎠ ᎠᎾᏡᏗ ᏚᏳᎪᏛ ᎨᏒᎢ; ᎠᏂᏍᎦᏯ ᎤᏲᏨᎯ ᏚᎾᏓᏅᏛᎢ, ᎠᎴ ᎨᏥᏲᎢᏎᏛ ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᎤᎬᏩᎵ.


text:
ᏂᎯᏍᎩᏂ ᎣᏏᏳ ᏣᎦᏙᎥᏒ ᏄᏍᏛ ᏓᏆᏕᏲᏅᎢ, ᏄᏍᏛ ᎠᏆᎴᏂᏙᎸᎢ, ᏄᏍᏛ ᏓᏇᎪᏔᏅ ᏗᏆᏓᏅᏛᎢ, ᎠᏉᎯᏳᏒᎢ, ᎬᏂᏗᏳ ᎨᏒᎢ, ᎠᏆᏓᎨᏳᎯᏳ ᎨᏒᎢ, ᎤᏁᎳᎩ ᎨᎵᏍᎬ ᏥᎩᎵᏲᎬᎢ,


text:
ᎠᎴ ᎯᎦᏔᎭ ᏣᏍᏗ ᎨᏒ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏕᎯᎦᏔᎲ ᏗᎦᎸᏉᏗ ᎪᏪᎵ, ᎾᏍᎩ ᏰᎵ ᎯᎦᏔᎿᎢᏳ ᎢᎬᏩᏁᏗ, ᏣᎵᏍᏕᎸᏙᏗ ᎨᏒ ᏫᎬᏩᎵᏱᎶᎯᏍᏗ, ᎦᎶᏁᏛ ᏥᏌ ᎯᏲᎢᏳᏒ ᎢᏳᏩᏂᏐᏗ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎬᏁᏤᎭ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ ᎠᎴ ᎠᎦᏔᎲ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ, ᎾᏍᎩ ᏧᏭᎪᏓᏁᏗ ᏥᎩ ᏗᏅᏃᏛ ᎠᎴ ᏧᏂᏲᎱᏒᎯ ᎾᎯᏳ ᎦᎾᏄᎪᏥᎸᎭ ᎠᎴ ᎤᎬᏫᏳᎯ ᎿᏉ ᏂᎦᎵᏍᏔᏅᎭ,


text:
ᎭᎵᏥᏙᎲᏍᎨᏍᏗ ᎧᏃᎮᏛ, ᏣᎵᏁᏅᏕᏍᏗᏉ ᏰᎵ ᎨᏎᏍᏗ ᎠᎴ ᏰᎵ ᏂᎨᏒᎾ ᎨᏎᏍᏗ, ᏕᎯᎬᏍᎦᎸᎥᏍᎨᏍᏗ, ᏕᎯᏍᎦᎨᏍᏗ, ᏕᎯᏍᏗᏰᏗᏍᎨᏍᏗ ᎲᏗᏍᎨᏍᏗ ᎤᏣᏘ ᎬᏂᏛ ᎨᏒ ᎠᎴ ᏗᏕᏲᏗ ᎨᏒᎢ.


text:
ᏛᏍᏆᎸᎯᏰᏃ ᎿᏉ ᎾᎯᏳ ᎥᏝ ᏳᎾᏚᎵᏍ-ᎨᏍᏗ ᎤᎾᏛᏓᏍᏙᏗᏱ ᎣᏍᏛ ᏗᏕᏲᏗ ᎨᏒᎢ; ᏚᏂᏲᏕᏍᎬᏍᎩᏂ ᏗᏂᎴᏂ ᎠᏅᏗᏍᎨᏍᏗ ᎤᏅᏒᏉ ᎤᎾᏚᎸᏅᏗ ᎨᏒ ᏓᏂᏍᏓᏩᏗᏒ ᏓᏂᏟᏏᏍᎨᏍᏗ ᏗᎾᏕᏲᎲᏍᎩ;


text:
ᏂᎯᏍᎩᏂ ᎮᏯᏔᎯᏳ ᎨᏎᏍᏗ ᏂᎦᎥ ᏂᏣᏛᎿᏕᎬᎢ, ᎲᏂᏗᏳ ᎨᏎᏍᏗ ᎯᎩᎵᏲᎬᎢ, ᏕᏣᎸᏫᏍᏓᏁᎮᏍᏗ ᎠᎵᏥᏙᏂᏙᎯ ᏧᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ; ᏰᎵᎦᏯ ᎯᏍᏆᏗᏍᎨᏍᏗ ᏗᏣᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ.


text:
ᎿᏉᏃ ᏨᏆᏓᏁᎳᏁᎸ ᎠᎵᏍᏚᎶ ᏚᏳᎪᏛ ᎢᏳᎾᏛᏁᎸᎯ ᎨᎦᎫᏴᏓᏁᏗ, ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᎾᏍᎦᏅᎾ ᏗᎫᎪᏗᏍᎩ ᎠᏗ-ᏅᏁᏗ ᎾᎯᏳ ᎢᎦ, ᎥᏝ ᎠᎴ ᎠᏴᏉ ᎠᏋᏒ, ᎾᏍᏉᏍᎩᏂ ᎾᏂᎥ ᎤᎾᏄᎪᎢᏍᏗ ᎨᏒ ᎣᏏᏳ ᎣᏂᏰᎸᎯ.


text:
ᎤᎬᏫᏳᎯᏍᎩᏂᏃᏅ ᎾᎥ ᎦᏙᎬᎩ ᎠᎴ ᎠᏆᎵᏂᎪᎯᏍᏔᏅᎩ; ᎾᏍᎩ ᎠᏴ ᎨᏒ ᎠᎩᏍᏆᏗᏍᏗᏱ ᎠᏰᎸᏒᎩ ᎠᎵᏥᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎾᏂᎥ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎤᎾᏛᎯᏗᏱ; ᎠᎴ ᎥᎩᎴᏒᎩ ᏢᏓᏥ ᎠᎰᎵ ᏥᎳᎥᎢ.


text:
ᎠᎴ ᎤᎬᏫᏳᎯ ᎠᏎ ᏛᏇᏓᎴᏏ ᏂᎦᎥ ᎤᏲ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ; ᎠᎴ ᏛᎩᏍᏆᏂᎪᏔᏂ ᎦᎸᎳᏗ ᎡᎯ ᎤᎬᏫᏳᎯ ᏗᎨᏒ ᏫᎦᎷᎩ. ᎾᏍᎩ ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸᎢ, ᎡᎺᏅ.


text:
ᎠᏴ, ᏉᎳ, ᎤᏁᎳᏅᎯ ᎠᎩᏅᏏᏙᎯ, ᎠᎴ ᏥᏌ ᎦᎶᏁᏛ ᎠᎩᏅᏏᏛ, ᎾᏍᎩᏯ ᎤᏃᎯᏳᏒ ᎤᏁᎳᏅᎯ ᏧᏑᏰᏛ, ᎠᎴ <n>[ᎾᏍᎩᏯ]</n> ᏗᏓᏂᎸᎢᏍᏗ ᎨᏒ ᏚᏳᎪᏛ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎦᎾᏰᎯᏍᏗ ᎨᏒ ᎾᏍᎩᏯ ᏥᎩ,


text:
ᏫᎬᏲᏪᎳᏏ, ᏓᏓᏏ, ᎠᏇᏥᏯᎢ, ᎾᏍᎩᏯ ᎾᏂᎥ ᎠᏃᎯᏳᎲᏍᎩ ᎤᏃᎯᏳᏒᎢ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ, ᎠᎴ ᎤᏓᏙᎵᏣᏛᎢ, ᎠᎴ ᏅᏩᏙᎯᏯᏛ, ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨᎢ, ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎢᎩᏍᏕᎵᏍᎩ, ᏕᏣᎧᎿᏩᏗᏙᎮᏍᏗ.


text:
ᎯᎠ ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏟᏗᏱ ᏨᏓᎬᏯᎧᎯᏴᎩ, ᎾᏍᎩ ᎣᏍᏛ ᎢᏨᏁᎵᏓᏍᏗᏱ ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᎤᏃᏒᏅᎢ, ᎠᎴ ᏘᎪᏗᏱ ᏗᎨᎦᏁᎶᏗ ᏕᎦᏚᏩᏗᏒᎢ, ᎾᏍᎩᏯ ᎢᏣᏛᏁᏗᏱ ᎬᏁᏤᎸᎢ;


text:
ᎠᏥᎦᏘᏗᏍᏗᏰᏃ ᎪᎱᏍᏗ ᎾᎫᎢᏍᏛᎾ ᏱᎩ, ᎾᏍᎩᏯ ᎣᏍᏛ ᎢᏳᏩᎿᏕᎩ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ; ᎥᏝ ᎤᏩᏒ ᎠᏓᏅᏖᏍᎬ ᎤᏟ ᎤᏰᎸᎯ, ᎥᏝ ᎤᎿᎸᏣᏘ, ᎥᏝ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎤᎦᎾᏏᏍᎩ, ᎥᏝ ᎠᏓᏛᏂᎯ, ᎥᏝ ᏧᎬᏩᎶᏗ ᎤᎬᎥᏍᎩ.


text:
ᎠᏍᏓᏯ ᏧᏂᏴᎯ ᏄᏓᎵᏍᏛᎾ ᎧᏃᎮᏛ ᎾᏍᎩᏯ ᎠᎨᏲᏅᎢ, ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᏰᎵᏉ ᏗᎬᏩᏬᏁᏙᏗ ᎣᏍᏛ ᏗᏕᏲᏗ ᎨᏒ ᎬᏗᏍᎬᎢ; ᎠᎴ ᎬᏩᎾᏙᎯᏳᎾᏁᏗ ᎢᎬᏩᏁᏗ ᏗᏂᎦᏘᎴᎩ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᏗᏂᎰᎵ ᎠᏎ ᏗᎨᏥᏍᏚᏁᏗ, ᎾᏍᎩ ᎾᏂᎥ ᏏᏓᏁᎸᎯ ᎠᏁᎯ ᏗᏂᎦᏔᎲᏍᎩ, ᎾᏍᎩ ᏥᏓᎾᏕᏲᎲᏍᎦ ᏂᏚᏳᎪᏛᎾ ᏥᎩ ᏧᎾᏕᏲᏗᏱ, ᏧᎬᏩᎶᏗ ᎦᏓᎭ ᎤᏂᎬᎥᏍᎬ ᎢᏳᏍᏗ.


text:
ᎾᏍᎩ Ꮎ ᎤᎾᏓᏅᎦᎸᏛ ᎨᏒᎢ, ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎤᎾᏓᎥᎦᎸᎡᎸᎯ ᎨᏐᎢ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᎦᏓᎭ ᎢᏳᎾᎵᏍᏔᏅᎯ ᎠᎴ ᏄᏃᎯᏳᏒᎾ, ᎥᏝ ᎪᎱᏍᏗ ᎤᎾᏓᏅᎦᎸᎡᎸᎯ ᏱᎨᏐᎢ; ᎾᏍᏉᏍᎩᏂ ᏚᎾᏓᏅᏛ ᎠᎴ ᏧᏄᎪᏙᏗᏱ ᎦᏓᎭ ᎢᏗᎬᏁᎸᎯ.


text:
ᎬᏂᎨᏒ ᎾᏅᏁᎭ ᎠᏂᎦᏔᎯᏳ ᎨᏒ ᎤᏁᎳᏅᎯ; ᎠᏎᏃ ᏚᏂᎸᏫᏍᏓᏁᎲ ᎢᎬᏩᏓᏱᎭ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏂᏂᏆᏘᏍᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎤᏃᎯᏳᎯᏍᏛ ᏂᎨᏒᎾ ᎨᏒᎢ; ᎠᎴ ᏂᎦᎥ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎨᏥᏐᏅᎢᏍᏔᏅᎯ.


text:
ᎠᏂᎨᏴ ᎾᏍᏉ ᎠᏂᎦᏴᎵᎨᎢ, ᎾᏍᎩ ᏚᏂᎸᏫᏍᏓᏁᎲ ᏚᏳᎪᏛ ᎢᏯᏛᏁᏗ ᎨᏒ ᎤᎵᎶᎲᏍᎩ ᏱᎩ, ᎤᏐᏅ ᎠᎾᏓᏃᎮᏍᎩ ᏂᎨᏒᎾ, ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎤᏂᎦᎾᏏᏍᎩ ᏂᎨᏒᎾ, ᎣᏍᏛ ᎨᏒ ᏗᎾᏕᏲᎲᏍᎩ;


text:
ᎤᎾᎵᏏᎾᎯᏍᏗ ᎢᏳᎾᎵᏍᏙᏗᏱ, ᎠᏁᏯᏔᎯ, ᏚᏁᏅᏒᏉ ᎠᏁᏙᎯ, ᎠᏃᏍᏛ, ᏧᏃᎯᏳᎯ ᎤᏅᏒ ᏗᎬᏩᏂᏰᎯ, ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎦᎬᏩᏂᏐᏢᏙᏗᏱ ᏂᎨᏒᎾ.


text:
ᎾᏂᏃᏍᎩᏍᎬᎾ, ᎬᏂᎨᏒᏍᎩᏂ ᎾᏅᏁᎮᏍᏗ ᏂᎦᎥ ᎣᏍᏛ ᏄᏓᎵᏓᏍᏛᎾ ᎨᏒᎢ; ᎾᏍᎩ ᎤᏃᏚᎢᏍᏙᏗᏱ ᏂᎦᎥᏉ ᎾᎾᏛᏁᎲ ᎾᏍᎩ ᏗᏕᏲᏅᎯ ᎨᏒ ᎤᏁᎳᏅᎯ ᎢᎩᏍᏕᎵᏍᎩ ᎤᏤᎵᎦ.


text:
ᎢᎨᏲᎲᏍᎦ, ᎾᏍᎩ ᎢᏓᏓᏱᎲ ᎤᏁᎳᏅᎯ ᏗᏁᎶᏙᏗ ᏂᎨᏒᎾ ᎨᏒᎢ ᎠᎴ ᎡᎶᎯ ᎡᎯ ᎠᏚᎸᏅᏗ ᎨᏒᎢ, ᎢᎦᎵᏏᎾᎯᏍᏗ ᎠᎴ ᏚᏳᎪᏛᎢ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎦᎸᏉᏙᏗ ᎨᏒ ᏱᏓᎴᏂᏙᎭ ᎠᏂ ᎡᎶᎯ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᎠᏴ ᏥᏕᎦᏓᎵᏲᎯᏎᎴᎢ, ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎢᎦᎫᏴᏗᏱ ᎢᎫᏓᎴᏍᏗᏱ ᏂᎦᎥ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏧᏅᎦᎸᏗᏱ ᎤᏩᏒ ᏧᏤᎵ ᎢᏧᏩᏁᏗᏱ ᎤᎾᏓᏤᎵᏛ ᏴᏫ, ᎤᎵᏂᎩᏛ ᎤᎾᏓᏅᏘ ᎣᏍᏛ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ.


text:
ᏕᎭᏅᏓᏗᏍᏗᏍᎨᏍᏗ ᏧᏃᎯᏳᏗ ᎨᏒ ᏄᏂᎬᏫᏳᏌᏕᎩ ᎠᎴ ᏗᎨᎦᏁᎶᏗ ᎨᏒᎢ, ᎤᏃᎯᏳᎯᏍᏛ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ, ᏂᎪᎯᎸᏉ ᎤᎾᏛᏅᎢᏍᏗ ᎢᏳᎵᏍᏙᏗ ᎨᏒ ᏂᎦᎥᏉ ᎣᏍᏛ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ.


text:
ᎢᎬᏒᏰᏃ ᎾᏍᏉ ᎢᎸᎯᏳ ᏥᎨᏒ ᎢᎩᏁᎫ ᎨᏒᎩ, ᏂᎪᎯᏳᏒᎾ, ᎢᎩᎵᏓᏍᏔᏅᎯ, ᎪᎱᏍᏗ ᏕᏓᏛᏁᎲᎩ ᏧᏓᎴᏅᏛ ᎠᏚᎸᏅᏗ ᎨᏒ ᎠᎴ ᎣᏍᏛ ᎠᏓᏓᏅᏓᏗᏍᏗᏍᎩ ᎨᏒᎢ, ᎤᏲ ᎨᏒ ᎠᎴ ᎠᏛᏳᎨᏗ ᎢᏕᎲᎩ, ᎢᎩᏂᏆᏘᏍᏗ, ᎠᎴ ᏗᏓᏓᏂᏆᏘᎯ ᎨᏒᎩ.


text:
ᎥᏝ ᏚᏳᎪᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎬᏗ ᎠᏴ ᎾᏍᎩ ᏕᎩᎸᏫᏍᏓᏁᎸᎢ, ᎾᏍᎩᏯᏍᎩᏂ ᎤᏓᏙᎵᏣᏘᏳ ᎨᏒ ᎢᎩᏍᏕᎸᎲᎩ ᎤᏮᏔᏅᎩ ᏔᎵᏁ ᎠᏕᏗ ᎨᏒ ᎤᎬᏩᎵ ᎠᏙᏑᎴᏗᏱ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎤᏓᏁᏟᏴᏍᏗ ᎨᏒᎢ;


text:
ᎤᏙᎯᏳᎯᏯ ᎢᎦᏪᏛ; ᎠᎴ ᎾᏍᎩ ᎯᎠ ᏧᏓᎴᏅᏛ ᎠᏆᏚᎵᎭ ᏣᏍᏓᏱᏗᏍᏗᏱ, ᎾᏍᎩ Ꮎ ᎤᏁᎳᏅᎯ ᎤᏃᎯᏳᏅᎯ ᎤᎾᎦᏌᏯᏍᏙᏗᏱ ᏂᎪᎯᎸᏉ ᎣᏍᏛ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ. ᎯᎠ ᎾᏍᎩ ᎣᏏᏳ ᎠᎴ ᎬᏩᎾᎵᏍᏕᎸᏙᏗ ᏴᏫ.


text:
ᎤᎵᏍᎦᏂᏍᏛᏍᎩᏂ ᎧᏃᎮᎸᏗ ᎨᏒ ᎠᎴ ᎤᎾᏓᏁᏟᏴᏒᏒᎢ, ᎠᎴ ᏗᏘᏲᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏗᏒᏍᏗ ᎨᏒ ᏗᎧᎿᏩᏛᏍᏗ ᎤᎬᏩᎵ ᏕᎭᏓᏅᏒᎮᏍᏗ, ᎬᏩᎾᏓᏍᏕᎸᏗᏰᏃ ᏂᎨᏒᎾ ᎠᎴ ᎠᏎᏉᏉ ᎾᏍᎩ.


text:
ᎠᏎᏃ ᏂᎯ ᎣᏏᏳ ᏂᏣᏰᎸᏅᎾ ᎥᏝ ᏯᏆᏚᎸᎮ ᎪᎱᏍᏗ ᎠᏆᏛᏁᏗᏱ; ᎾᏍᎩ ᎣᏍᏛ ᏂᏍᏆᏛᏁᎲ ᎣᏏᏳ ᏣᏰᎸᏅ ᎬᏂᎨᏒ ᎢᏳᎵᏍᏙᏗᏱ, ᎥᏝᏃ ᎾᏍᎩ ᎠᏎ ᎢᏣᏛᏁᏗᏱ ᏂᏣᎵᏍᏓᏁᎲᎢ.


text:
ᎥᏝ ᎿᏉ ᎠᏥᏅᏴᏓᏍᏗ ᎾᏍᎩᏯᎢ, ᎤᏟᏍᎩᏂ ᎦᎸᏉᏗᏳ ᎡᏍᎦᏉ ᎠᏥᏅᏏᏓᏍᏗ, ᎣᏅᏟ ᎠᎨᏳᎯ ᎾᏍᎩᏯᎢ, ᎠᏴ Ꮀ ᎤᎬᏫᏳᎭ ᏥᎨᏳᎢ, ᏂᎯᏍᎩᏂ ᏂᎦᎥ ᎤᏟᎯᏳ ᎯᎨᏳᎢ, ᎾᏍᎩ Ꮎ ᎤᏇᏓᎵ ᎨᏒ ᎠᎴ ᎤᎬᏫᏳᎯ ᏕᏍᏓᏁᎶᏛᎢ?


text:
ᎾᏍᎩ ᏗᎦᎸᏌᏓᏗᏍᎩ ᏥᎨᏒᎩ ᎤᏤᎵ ᎦᎸᏉᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎾᏍᎩᏯ ᏗᏟᎶᏍᏔᏅᎯ ᏥᎨᏒᎩ ᎾᏍᎩ ᏄᏍᏛᎢ, ᎠᎴ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᏥᏚᏍᏆᏂᎪᏗᏕᎬᎩ ᏥᎬᏗᏍᎬᎩ ᎤᎵᏂᎩᏗᏳ ᎧᏁᎬᎢ, ᎾᎯᏳ ᎤᏩᏒ ᎤᏓᏛᏔᏅ ᎤᏅ ᎦᎸᎭ ᎢᎩᏍᎦᏅᏨᎢ, ᎤᏪᏁᎢ ᎠᎦᏘᏏᏗᏢ ᎦᎸᏉᏗᏳ ᎨᏒ ᎦᎸᎳᏗ.


text:
ᎤᏪᏥᏍᎩᏂ ᎯᎠ ᏂᎦᏪᏎᎭ, ᏣᏤᎵ ᎦᏍᎩᎸ, ᏣᏁᎳᏅᎯ, ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸ ᏂᎬᏩᏍᏗᏉ; ᎠᏙᎳᏅᏍᏗ ᏚᏳᎪᏛ ᎠᏛᏁᏙᏗ ᎾᏍᎩ ᎠᏙᎳᏅᏍᏗ ᎪᎱᏍᏗ ᏨᏗᎭ ᎾᎿ ᏣᎬᏫᏳᎯ ᎨᏒᎢ.


text:
ᎣᏏᏳ ᏣᏰᎸᏅ ᏚᏳᎪᏛ ᎨᏒᎢ; ᎠᎴ ᏣᏂᏆᏘᎸ ᎤᏲ ᎨᏒᎢ, ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᏂᎯ ᏣᏁᎳᏅᎯ ᎤᏟ ᎢᎦᎢ ᏣᎶᏁᏔᏅ ᎠᏠᏁᏗᎣᏍᏛ ᎠᏓᏓᏅᏓᏗᏍᏗᏍᎩ, ᎡᏍᎦᏉ ᎾᏍᎩ Ꮎ ᎢᏣᎵᎪᎯ.


text:
ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᏱᏓᎫᏓᎳᎩ, ᎢᏳᏃ ᏂᎦᎦᏌᏯᏍᏔᏅᎾ ᏱᎩ ᎾᏍᎩ ᎢᎦᎸᏉᏗ ᎠᎵᏍᏕᎸᏙᏗ; ᎾᏍᎩ ᎢᎬᏱ ᏧᎴᏅᎲ ᏧᏃᎮᏛ ᎤᎬᏫᏳᎯ, ᎠᎴ ᎾᏍᎩ ᎠᏴ ᏥᎨᎩᏍᏓᏱᏕᎸᎩ ᎾᏍᎩ Ꮎ ᎬᏩᏛᎦᏁᎸᎯ;


text:
ᎤᏁᎳᏅᎯ ᎾᏍᏉ ᏕᎪᎯᏳᏓᏁᎲᎩ, ᏕᎬᏗᏍᎬᎩ ᎤᏰᎸᏛ ᎠᎴ ᎤᏍᏆᏂᎪᏗ, ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎤᏓᏁᏗ ᎨᏒ ᎾᏍᎩᏯ ᎤᏩᏒ ᎣᏏᏳ ᎤᏰᎸᏗ ᎨᏒᎢ.


text:
ᏄᏓᎴᏒ ᎪᎱᏍᏗ ᏧᎳᏏᏕᏂ ᎭᏫᏂᏗᏢ ᏂᏕᏨᏁᎸ. ᎾᏍᎩᏰᏃ ᏂᎦᏛ ᎭᏫᏂᏗᏢ ᏥᏄᏩᏁᎴᎢ, ᎥᏝ ᎪᎱᏍᏗ ᏳᏃᎯᏰ ᎾᏍᎩ ᎭᏫᏂᏗᏢ ᏄᏩᏁᎸᎾ ᎨᏒᎢ. ᎠᏎᏃ ᎪᎯ ᎨᏒ ᎥᏝ ᏱᏗᎪᏩᏘᎭ ᏂᎦᏛ ᎭᏫᏂᏗᏢ ᏱᎾᎬᏁᎸ.


text:
ᏥᏌᏍᎩᏂ ᎡᏗᎪᏩᏘᎭ ᎾᏍᎩ ᎤᏍᏗᎩᏛ ᎡᏍᎦ ᎢᏯᎬᏁᎸᎯ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎨᏒ ᏂᎨᎬᏁᎸᎢ, ᎾᏍᎩ ᎤᏲᎱᎯᏍᏗᏱ, ᏗᎬᏩᎸᏌᏛ ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏒ ᎠᏥᏍᏕᎶᏔᏅ; ᎾᏍᎩ ᏅᏓᏳᎵᏍᏙᏗᏱ ᎬᏩᎦᏘᏯ ᎤᏁᎳᏅᎯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎬᏗᏍᎬ ᎾᏂᎥ ᏴᏫ ᏧᏲᎱᏎᏗᏱ.


text:
ᎠᏎᏰᏃ ᎾᏍᎩ ᎢᏳᏛᏁᏗ ᎨᏎᎢ, ᎾᏍᎩ Ꮎ ᏄᏓᎴᏒ ᎪᎱᏍᏗ ᎠᎪᏢᎾᏁᎸᎯ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᏄᏓᎴᏒ ᎪᎱᏍᏗ ᎪᏢᏅᎯ ᏥᎩ, ᎾᏍᎩ ᏗᎬᏩᎸᏌᏛ ᏗᎨᏒ ᏫᏓᏘᏃᎯᎲ ᎤᏂᏣᏘ ᏧᏪᏥ, ᎾᏍᎩ ᎤᎾᎵᏍᏕᎸᏙᏗ ᏗᏩᏛᎡᎯ, ᏂᎦᎷᎶᎬᎾ ᎢᏯᎬᏁᏗᏱ ᎠᎩᎵᏲᎬᎢ.


text:
ᎠᎴ ᎾᏍᎩ ᏗᏂᏲᎵ ᎤᏂᏲᎵ ᎠᎴ ᎩᎬ ᎤᏂᏁᎯ ᏥᎩ, ᎤᏩᏒ ᎾᏍᏉ ᎾᏍᎩ ᎤᏠᏯᏍᏔᏁ ᎤᎩᏎᎢ; ᎾᏍᎩ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎢᏳᏩᏂᏐᏗᏱ ᎠᏎᏉᏉ ᎢᏳᏩᏁᏗᏱ ᎾᏍᎩ Ꮎ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎤᎵᏂᎬᎬ ᎤᎯ, ᎾᏍᎩ ᎠᏍᎩᎾ ᏥᎩ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏚᏳᎪᏛᎩ ᏂᎦᎥ ᏄᏛᏅᏅ ᎠᎾᎵᏅᏟ ᎾᏍᎩᏯ ᏄᎾᏍᏛ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᎤᏓᏙᎵᏍᏗ ᎠᎴ ᏄᏓᎵᏍᏛᎾ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎤᎬᏩᎵ, ᎾᏍᎩ ᎠᎵᏍᎪᎸᏔᏅᎯ ᎠᎫᏴᏙᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏂᏍᎦᏅᏨ ᏴᏫ;


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎡᏥᎸᏉᏗ ᎢᏓᎵᏅᏟ, ᎢᏣᏠᏯᏍᏗᏍᎩ ᎦᎸᎳᏗ ᎤᎬᏩᎵ ᎥᏓᏘᏯᏅᏗ ᎨᏒᎢ, ᎡᏣᏓᏅᏛᎵ ᎦᎶᏁᏛ ᏥᏌ ᎠᏥᏅᏏᏛ ᎠᎴ ᏄᎬᏫᏳᏒ ᎠᏥᎸᎨᎶᎯ ᎾᏍᎩ ᏤᏓᏁᎶᏗ ᏥᎩ.


text:
ᎦᎶᏁᏛᏍᎩᏂ ᎠᎦᏅᎩ ᎾᏍᎩᏯ ᏄᏓᎵᏓᏍᏛᎾ ᎨᏒᎩ ᎤᏩᏒ ᏚᏓᏘᎾᎥᎢ; ᎾᏍᎩ Ꮎ ᏚᏓᏘᎾᎥ ᎢᏖᎳ ᏥᎩ, ᎢᏳᏃ ᎤᎵᏂᎩᏛ ᏱᏗᎩᏂᏴᎭ ᎬᎵᏍᏆᏗᏍᎩ ᎾᏍᎩ Ꮎ ᎢᎦᎵᏍᎦᏍᏙᏛ ᎠᎴ ᎢᏓᏢᏈᏍᏙᏗᏍᎬ ᎤᏚᎩ ᎬᏗ ᎨᏒᎢ.


text:
ᎠᏴᏰᏃ ᎣᏍᏛ ᎧᏃᎮᏛ ᎡᎦᎵᏥᏙᏁᎸᎩ, ᎾᏍᎩᏯᏉ ᏥᎨᎦᎵᏥᏙᏁᎸᎩ ᎾᏍᎩ; ᎠᏎᏃ ᎾᏍᎩ Ꮎ ᎧᏃᎮᏛ ᎤᎾᏛᎦᏅ ᎥᏝ ᏅᏂᏍᏕᎸᎮᎢ ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᎪᎯᏳᏗ ᎨᏒ ᏄᏓᏑᏴᎾ ᎨᏒ ᎠᎾᏛᎩᏍᎬᎢ.


text:
ᎠᏴᏰᏃ ᎢᎪᎯᏳᏅᎯ ᎨᏒ ᎢᏗᏴᎯᎭ ᎠᏣᏪᏐᎸᏍᏙᏗᏱ ᎨᏒᎢ; ᎾᏍᎩᏯ ᏄᏪᏒᎢ, ᎾᏍᎩᏯ ᎠᏆᏎᎵᏔᏅ ᎠᎩᏔᎳᏬᏍᎬᎢ, ᎾᏍᎩ ᎤᏂᏴᏍᏗᏱ ᏂᎨᏒᎾ ᎨᏒ ᎠᏆᏤᎵ ᎠᏣᏪᏐᎸᏍᏙᏗᏱ ᎨᏒᎢ; ᎠᏍᏆᏛᎯᏍᎩᏂᏃᏅ ᎨᏒᎩ ᏕᎦᎸᏫᏍᏓᏁᎸ ᎡᎶᎯ ᏧᏙᏢᎤ ᎤᏓᎬᏩᏓᎴᎤᏛ.


text:
ᎠᎴ ᎾᏍᏉ ᎢᎦ ᎠᏑᏰᎭ, ᎯᎠ ᏂᎦᏪᎭ ᎤᏬᎯᏨᎯ ᎣᏂ ᏕᏫ ᎠᎬᏗᏍᎬᎢ, ᎪᎯ ᎢᎦ, ᎾᏍᎩᏯ ᎯᎠ ᎢᎦᏪᏛ ᏥᎩ, ᎪᎯ ᎢᎦ, ᎢᏳᏃ ᎧᏁᎬ ᎢᏣᏛᎪᏗᏱ ᎢᏣᏑᎵᏍᎨᏍᏗ, ᏞᏍᏗ ᏱᏗᏥᏍᏓᏲᏔᏁᏍᏗ ᏗᏥᎾᏫ.


text:
ᎧᏃᎮᏛᏰᏃ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎬᏃᏛ, ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎠᎴ ᎤᏟᎯᏳ ᏂᎪᏍᏓᏴ ᎡᏍᎦᏉ ᎠᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᎢᏧᎳᏗᏢ ᏗᎬᎦᏘ ᏗᎪᏍᏓᏴ, ᏕᎦᏘᎭ ᏔᎵ ᏂᎦᏗᎭ ᎠᏓᏖᏗᏱ ᎠᎴ ᎠᏓᏅᏙ, ᎠᎴ ᏚᏫᏢᎢ ᎠᎴ ᏚᏍᏛᏪᏙᎬᎢ, ᎠᎴ ᏗᎬᏭᎪᏙᏗ ᎢᎩ ᏄᏍᏛ ᎠᏓᏅᏖᏍᎬ ᎠᎴ ᏄᏍᏛ ᎤᏚᎵᏍᎬ ᎤᎾᏫ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᏗᏍᎦᎢᎲᎾ ᎢᏗᎷᎩ ᎾᎿ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎦᏍᎩᎸᎢ, ᎾᏍᎩ ᎡᎩᏙᎵᏍᏗᏱ, ᎠᎴ ᎢᎩᏩᏛᏗᏱ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗᏱ, ᎠᎴ ᎢᎩᏩᏛᏗᏱ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎾᏍᎩ ᎾᎯᏳ ᎢᎩᏂᎬᏎᎲ ᎢᎦᎵᏍᏕᎸᏙᏗ.


text:
ᎾᏂᎥᏰᏃ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎨᏒ ᏴᏫ ᎠᏁᎲ ᎨᎪᏣᎴᏛ, ᏴᏫ ᎣᏍᏛ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎨᏥᏁᏤᎰᎢ, ᎾᏍᎩ <n>[ᏧᏂᎸᏫᏍᏓᏁᏗᏱ]</n> ᎤᏁᎳᏅᎯ ᎤᏤᎵᎪᎯ ᎤᎬᏩᎵ, ᎾᏍᎩ ᏗᎬᏩᎾᎵᏍᎪᎸᏙᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎠᏓᏁᏗ ᎨᏒ ᎠᎴ ᎠᏥᎸᎨᎳᏍᏙᏗ ᎾᏍᎩ ᎠᏍᎦᏂ ᎤᎬᏩᎵ;


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᎦᎶᏁᏛ ᎥᏝ ᎤᏩᏒ ᎯᎠ ᎦᎸᏉᏗ ᏗᎦᎸᏫᏍᏓᏁᏗ ᏳᎩᏎ ᏄᎬᏫᏳᏒ ᎠᏥᎸᎨᎶᎯ ᎾᎬᏁᎸᎢ; ᎯᎠᏍᎩᏂ ᎢᏳᏪᏎᎸᎯ, ᎠᏇᏥ ᏂᎯ, ᎪᎯ ᎢᎦ ᏍᏆᏕᎲᏏ, <n>[ᎾᏍᎩ ᎤᏯᏅᎮᎢ.]</n>


text:
ᎾᏍᎩ Ꮎ ᎾᎯᏳ ᎤᏇᏓᎵ ᎨᏒ ᎤᎴᏂᏙᎸ, ᎤᏓᏙᎵᏍᏓᏁᎸ ᎠᎴ ᎤᏔᏲᏎᎸ, ᎠᏍᏓᏴ ᏓᏠᏱᎲ, ᎠᎴ ᏓᎦᏌᏬᎢᎲ ᎬᏩᏠᏯᏍᏗ ᎾᏍᎩ Ꮎ ᎤᏔᏲᏎᎸ ᎾᏍᎩ ᏰᎵᏉ ᎬᏩᏍᏕᎸᏗ ᎬᏭᏓᎴᏍᏘ ᎨᏒ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎦᏛᎦᏁᎴ ᎦᎾᏰᏍᎬ ᎤᎬᏩᎵ;


text:
ᎾᎯᏳᏰᏃ ᏰᎵᏉ ᏗᎨᏣᏕᏲᏗ ᎡᏤᎵᏎᎸᎢ, ᎤᏚᎸᏗᏉ ᏂᏣᎵᏍᏓᏁᎭ ᎩᎶ ᏔᎵᏁ ᎢᏤᏲᏗᏱ ᏄᏍᏛ ᎢᎬᏱᏱ ᏗᏕᎶᏆᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎧᏃᎮᏛ; ᎠᎴ ᎤᏅᏗ ᎤᎾᏚᎵᏍᎩ ᎾᏍᎩᏯ ᏂᏣᎵᏍᏔᏅ, ᎥᏝᏃ ᎤᏴᏍᏗ ᎠᎵᏍᏓᏴᏗ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏗᎯᏯᏍᎬ ᎠᎴᏅᏙᏗ ᎦᎶᏁᏛ ᎤᏤᎵ ᏗᏕᏲᏗ ᎨᏒᎢ, ᏂᎦᎷᎶᎬᎾ ᎨᏒ ᎢᏴᏛ ᏫᏗᏰᎢᎶᎦ; ᏔᎵᏁ ᎦᎫᏍᏛᏗ ᏂᏗᎲᏍᎬᎾ ᎦᏁᏟᏴᏍᏗ ᎨᏒ ᎣᏓᏅᏛ ᎤᎬᏩᎵ, ᎠᏓᎯᎯᏉ ᏗᎦᎸᏫᏍᏓᏁᏗ ᏥᎩ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎪᎯᏳᏗ ᎨᏒᎢ,


text:
ᎬᏩᏟᏍᏗᏰᏃ ᎾᏍᎩ Ꮎ ᎢᎸᎯᏳ ᎢᎦᎨᎦᏗᏍᏓᏁᎸᎯ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏁᎶᏔᏅᎯ ᎨᏒ ᎦᎸᎶᎢ ᏅᏓᏳᏓᎴᏅᎯ ᎠᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎨᎦᏠᏯᏍᏔᏅ ᎨᏥᏁᎸᎯ.


text:
ᎾᏍᎩ ᏧᏂᏲᏒᎯ ᎨᏒᎢ, ᎬᏩᏟᏍᏗ ᏔᎵᏁ ᎢᏤ ᎢᎨᎬᏁᏗᏱ ᎦᏁᏟᏴᏍᏗ ᎨᏒ ᏚᎾᏓᏅᏛ ᏭᏂᎷᎯᏍᏗᏱ; ᎤᏅᏒᏰᏃ ᏔᎵᏁ ᎤᎾᏓᏛᏁᎸᎯ ᎢᎩ ᎤᏁᎳᏅᎯ ᎤᏪᏥ, ᎠᎴ ᎬᏂᎨᏒ ᎬᏩᏕᎰᎯᏍᏔᏅᎯ ᎢᎩ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎥᏝ ᏂᏚᏳᎪᏛᎾ ᎢᎬᏩᏛᏁᏗ ᏱᎩ ᎾᏍᎩ ᎤᏩᎨᏫᏍᏗᏱ ᏕᏥᎸᏫᏍᏓᏁᎸ ᎠᎴ ᎬᏂᎨᏒ ᏂᏨᏁᎸ ᎢᏥᎨᏳᏒ ᏕᎤᏙᎥᎢ. ᎾᏍᎩ ᏕᏥᏍᏕᎲᎯᏙᎸ ᎤᎾᏓᏅᏘ, ᎠᎴ ᎠᏏᏉ ᏕᏥᏍᏕᎵᏍᎬᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏚᎵᏍᎬ ᎤᏟ ᎢᎦᎢ ᎬᏂᎨᏒ ᎢᏧᏩᏁᏗᏱ ᎨᏥᏚᎢᏍᏓᏁᎸᎯ ᎾᏍᎩ ᎬᏩᏓᏁᏟᏴᏍᏗ ᏂᎨᏒᎾ ᎨᏒ ᏄᏍᏛ ᎠᏓᏅᏖᏍᎬᎢ, ᎠᏎᎵᏛᏍᎬ ᎤᏍᏓᏱᏍᏔᏁᎢ.


text:
ᎠᎴ ᎾᏍᎩ ᏔᎵ ᏄᎵᏁᏨ ᏕᏒᏗᏍᎬ ᎾᏍᎩ ᎬᏩᏓᏁᏟᏴᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎾᎿ ᎬᏩᏥᎪᏗ ᏂᎨᏒᎾ ᏥᎨᎭ ᎤᏁᎳᏅᎯ, ᎠᏴ ᎢᎩᏲᎸᎯ ᏥᎩ ᎢᎦᏗᏍᎦᎶᏗᏱ, ᎤᎵᏂᎩᏛ ᎢᎩᎦᎵᏍᏓᏗᏍᎩ ᎨᎩᏩᏛᏗ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᏗᎩᏂᏴᏗᏱ ᎤᏚᎩ ᎬᏗ ᎡᎩᏩᏌᏓᏁᎲᎢ;


text:
ᎯᎠᏰᏃ ᎾᏍᎩ ᎹᏓᎩᏏᏕᎩ, ᎤᎬᏫᏳᎯ ᏎᏓᎽ, ᎠᏥᎸ-ᎨᎶᎯ ᎨᏎᎢ ᎤᏁᎳᏅᎯ ᏩᏍᏛ ᎦᎸᎳᏗ ᎡᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎡᏆᎭᎻ ᏥᏚᏠᏎ ᏧᏨᏏᏗᏒ ᏫᏚᎰᏅᎯ ᎤᏂᎬᏫᏳᎯ, ᎠᎴ ᎣᏍᏛ ᏧᏁᏤᎴᎢ;


text:
ᎠᎴ ᎾᏍᎩ ᎾᏍᏉ ᎡᏆᎭᎻ ᏂᎦᏛ ᏧᎬᏩᎶᏗ ᎠᏰᎲ ᎠᏍᎪᎯᏁ ᎪᏣᎴᏛ ᏧᏁᎸᏁᎢ; ᎢᎬᏱᏱ ᎨᏒ <n>[ᏚᏙᎥ]</n> ᎠᏁᏢᏔᏅᎯ ᎨᏒ ᎤᎬᏫᏳᎯ ᏚᏳᎪᏛ ᎢᏯᏛᏁᎯ ᎦᏛᎦ, ᎣᏂᏃ ᎾᏍᏉ ᏎᎳᏂ ᎤᎬᏫᏳᎯ ᎠᎪᏎᎭ, ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᏅᏩᏙᎯᏯᏛ ᎤᏚᎵᏍᎩ ᏥᎦᏛᎦ.


text:
ᎾᏍᎩ ᎤᏤᏓ ᎠᎴ ᎤᏥ ᎾᏁᎲᎾ ᏥᎨᏎ, ᎤᎾᏁᏢᏔᏅᎯ ᎠᏂᏂᎩᏛ ᏥᎨᏎ, ᏚᎩᏨᏁᎬ ᏅᎫᏓᎴᏅᎲᎾ ᏥᎨᏎ, ᎠᎴ ᎡᎲ ᏭᏍᏗᏥᎯᏍᏗ ᏂᎨᏒᎾ ᏥᎨᏎᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᎾᏪᏥ ᎾᏍᎩᏯ ᏥᎾᎬᏁᎴᎢ, ᎠᏥᎸ-ᎨᎶᎯ ᏤᎭ ᏂᎪᎯᎸᎢ.


text:
ᎠᎴ ᎤᏙᎯᏳᎯ ᎵᏫ ᏧᏪᏥ ᎠᏥᎸᎨᎳᏍᏗ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎨᏥᏁᏗ ᎨᏒᎢ ᎨᎦᏒᎦᎸᏗᏍᎨ ᎠᏍᎪᎯᏁ ᎪᏣᎴᏛ ᏧᏂᏂᏢᏗᏱ ᏴᏫ ᎾᏍᎩᏯ ᏂᎬᏅ ᏗᎧᎿᏩᏛᏍᏗ, ᎾᏍᎩ ᎠᎾᎵᏅᏟ ᎨᏒᎢ, ᎾᏍᏉ ᎡᏆᎭᎻ ᎠᏰᎵ ᏅᏓᏳᎾᏓᎴᏅᎯ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᎠᏥᎸᎨᎳᏍᏗ ᎨᏒ ᎠᏂᎵᏫ ᏥᎨᎦᏒᎦᎶᏕ, ᏅᏍᎦᏅᎾ ᎢᎬᏩᏓᏛᏁᏗ ᏱᎨᏎᎢ, (ᎠᏥᎸ-ᎨᎳᏍᏗᏰᏃ ᎨᏒ ᎠᎴ ᏗᎧᎿᏩᏛᏍᏗ ᏚᎾᏚᏓᏖ ᏴᏫ ᎦᎾᏓᏂᎸᏨ) ᎦᏙᏃ ᎠᏏ ᎤᏚᎸᏗ ᏂᎦᎵᏍᏗᏍᎨ ᏅᏩᏓᎴ ᎠᏥᎸᎨᎶᎯ ᎤᎾᏄᎪᎢᏍᏗᏱ ᎹᎵᎩᏏᏕᎩ ᏄᏍᏛ ᎾᏍᎩᏯᎢ, ᎡᎳᏂᏃ ᎾᏍᎩᏯ ᎦᏰᎪᏎᏗ ᏂᎨᏒᎾ ᎨᏒᎢ?


text:
ᎾᏍᎩᏰᏃ Ꮎ ᎯᎠ ᎾᏍᎩ ᎤᎬᏩᎵ ᎠᏥᏁᎢᏍᏔᏅᎯ ᎨᏒ ᎤᏣᏘᏂ ᎠᏂᎳᏍᏓᎸ ᎨᎳ ᎨᏒᎩ, ᎾᏍᎩ <n>[ᎠᏂᎳᏍᏓᎸ]</n> ᎤᏓᎴᏅᎯ ᎥᏝ ᎩᎶ ᎠᏥᎸᎨᎳᏍᏗᏱ ᏱᏚᎸᏫᏍᏓᏁᎮᎢ.


text:
ᏗᎧᎿᏩᏛᏍᏗᏰᏃ ᎥᏝ ᎦᎷᎶᎩ ᏂᎨᏒᎾ ᎢᎬᏁᎯ ᏱᎨᏎ ᎪᎱᏍᏗ; ᎤᏟᏍᎩᏂ ᎢᏝᏍᏛ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᎠᏴᏔᏂᎸᎯ ᏥᎩ, ᎾᏍᎩ ᎢᏛᏗᏍᎬ ᎾᎥ ᎦᏰᏗᎷᏤᏗ ᏥᏂᎦᎵᏍᏗᎭ ᎤᏁᎳᏅᎯ ᎦᎷᎶᎩ ᏂᎨᏒᎾ ᏂᎬᏁᎭ.


text:
(ᎾᏍᎩᏰᏃ Ꮎ ᎠᏥᎸ-ᎠᏁᎶᎯ ᏂᎨᎬᏁᎮ ᎠᏎᎵᏔᏅᎯ ᏂᎨᏒᎾ; ᎯᎠᏍᎩᏂ Ꮎ ᎠᏎᎵᏔᏅᎯ ᎨᏒ ᎠᎬᏓᏁᎴᎢ, ᎯᎠ ᎾᏍᎩ ᎢᏳᏪᏎᎸᎯ, ᎤᎬᏫᏳᎯ ᎤᏎᎵᏔᏅ ᎠᎴ ᎥᏝ ᎠᎦᏁᏟᏴᎾ ᏂᎯ ᎠᏥᎸ-ᎮᎶᎯ ᏂᎪᎯᎸᎢ ᎺᎵᎩᏏᏕᎩ ᏄᏍᏛ ᎾᏍᎩᏯᎢ.)


text:
ᎾᏍᎩᏰᏃ ᎢᏳᏍᏗ ᎠᏥᎸ-ᎨᎶᎯ ᎢᎩᎵᎶᎲᏍᎩ ᎨᏒᎩ, ᎾᏍᎩ ᎾᏍᎦᏅᎾ, ᎤᏲ ᎢᎬᏩᏓᏛᏁᏗ ᏂᎨᏒᎾ, ᎠᏍᎦᎾ ᏄᏓᏅᎦᎸᎾ, ᎠᏂᏍᎦᎾ ᎠᏁᎲ ᎠᎦᏓᏓᎴᏔᏅᎯ, ᎠᎴ ᎦᎸᎶ ᎤᏗᏗᏢ ᎢᏴᏛ ᎠᏥᏌᎳᏓᏅᎯ;


text:
ᎾᏍᎩ Ꮎ ᎤᏚᎸᏗ ᏄᎵᏍᏓᏁᎲᎾ ᏂᏚᎩᏨᏂᏒ ᎠᏥᎸ-ᎤᏪᎳᏍᏗᏱ, ᎾᏍᎩ ᎾᎾᏛᏁᎲ ᏄᏂᏛᏁᎲ ᏄᏂᎬᏫᏳᏌᏕᎩ ᎠᏥᎸᎠᏁᎶᎯ, ᎢᎬᏱ ᎤᏅᏒ ᎤᏂᏍᎦᏅᏨ ᎠᎫᏴᏙᏗ, ᎢᏉᏃ ᏴᏫ ᎤᏂᏍᎦᏅᏨ ᎠᎫᏴᏙᏗ; ᎾᏍᎩᏰᏃ ᎯᎠ ᏌᏉ ᏄᏛᏁᎴᎢ, ᎾᎯᏳ ᎤᏩᏒ ᎤᏓᎵᏍᎪᎸᏔᏅ.


text:
ᏗᎧᎿᏩᏛᏍᏗᏰᏃ ᏴᏫ ᏗᏂᏩᎾᎦᎳ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᏄᏅᏁᎰᎢ; ᎧᏁᏨᎯᏍᎩᏂ ᎠᏎᎵᏔᏅᎯ ᎠᏍᏓᏱᏗᏍᏔᏅᎯ ᎨᏒᎢ, ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎤᎵᏁᏨ ᎣᏂ ᏧᎵᏁᏤᎢ, ᎤᏪᏥ <n>[ᎠᏥᎸᎨᎶᎯ]</n> ᏄᏩᏁᎴ ᎾᏍᎩ ᏂᎪᎯᎸ ᎦᎷᎶᎩ ᏂᎨᏒᎾ ᏥᎩ.


text:
ᎾᏂᎥᏰᏃ ᏄᏂᎬᏫᏳᏒ ᎠᏥᎸ-ᎠᏁᎶᎯ ᎨᏥᏁᏤᎸᎯ ᎨᏐ ᏧᎾᎵᏍᎪᎸᏙᏗᏱ ᎠᏓᏁᏗ ᎨᏒ ᎠᎴ ᎠᏥᎸ-ᏗᎨᎳᏍᏙᏗ ᎨᏒᎢ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᎠ ᎾᏍᎩ ᎠᏍᎦᏯ ᎾᏍᏉ ᎠᏎ ᎪᎱᏍᏗ ᎤᏲᎯᏍᏗ ᎨᏎ ᎤᎵᏍᎪᎸᏙᏗ.


text:
ᎾᏍᎩ ᎾᎿ ᏥᏚᏂᎸᏫᏍᏓᏁᎭ ᏗᏟᎶᏍᏔᏅᎯ ᎠᎴ ᎤᏓᏩᏗᏍᏙᏛ ᎦᎸᎳᏗ ᎡᎯ ᎦᎵᏦᏛᎢ, ᎾᏍᎩᏯ <n>[ᎤᏁᎳᏅᎯ]</n> ᎼᏏ ᏧᏁᏤᎴ ᎾᎯᏳ ᎦᎵᏦᏙᏗ ᏨᏗᎪᏢᏂᏎᎢ; ᎭᎦᏌᏯᏍᏔᏅᎭ ᏧᏛᏁᎢ, ᏕᎰᏢᏍᎬ ᏂᎦᏛ ᏧᏓᎴᏅᏛ ᎾᏍᎩᏯ ᏗᏟᎶᏍᏙᏗ ᎠᎲ ᎾᏍᎩ ᏤᏣᎾᏄᎪᏫᏎᎸ ᎣᏓᎸ ᏅᏁᎸᎭ.


text:
ᎾᏍᎩᏃ ᏥᏄᏍᏗ ᎪᎯ ᎨᏒ ᎤᏟ ᎢᎦᎸᏉᏗ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎤᏩᏛᎲ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎠᏰᎵ ᎠᎴᎲᏍᎩ ᎨᏒ ᎤᏟ ᎢᏲᏍᏛ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᎤᎬᏩᎸᎢ, ᎾᏍᎩ ᎤᏟ ᎢᏲᏍᏛ ᏓᏚᎢᏍᏛ ᏧᎵᏍᏓᏱᏍᏗ.


text:
ᎥᏝ ᎾᏍᎩᏯ ᎧᏃᎮᏛ ᏕᎦᏥᏯᏠᎢᏍᏓᏁᎸ ᏧᏂᎦᏴᎵᎨᎢ, ᎾᎯᏳ ᎦᏂᏲᏯᏁᏒ ᎦᏥᏄᎪᏫᏍᏗᏱ ᎢᏥᏈᏱ ᎦᏓ ᎠᎲᎢ; ᎥᏝᏰᏃ ᏳᏂᏍᏆᏂᎪᏔᏁ ᎧᏃᎮᏛ ᏕᎦᏥᏯᏠᎢᏍᏓᏁᎸᎢ, ᎠᎴ ᎠᏴ ᎥᏝ ᏱᎦᏥᏯ-ᎦᏎᏯᏍᏔᏁᎢ, ᎠᏗᎭ ᎤᎬᏫᏳᎯ.


text:
ᎯᎠᏰᏃ ᎾᏍᎩ ᏄᏍᏕᏍᏗ ᎧᏃᎮᏛ ᏙᏓᎦᏥᏯᏠᎢᏍᏓᏁᎵ ᎢᏏᎵ ᏏᏓᏁᎸᎯ ᎨᏒ ᎾᎯᏳ ᎦᎶᏐᏅᎭ ᎠᏗᎭ ᎤᎬᏫᏳᎯ; ᏚᎾᏓᏅᏛ ᏓᏓᏥᎳᏂ ᏗᏆᏤᎵ ᏗᎧᎿᏩᏛᏍᏗ, ᎠᎴ ᏧᏂᎾᏫᏱ ᏙᏓᎪᏪᎳᏂ; ᎠᎴ ᎠᏴ ᎦᏥᏯᏁᎳᏅᎯ ᎨᏎᏍᏗ, ᎤᏅᏒᏃ ᏗᏆᏤᎵ ᏴᏫ ᎨᏎᏍᏗ;


text:
ᎥᏝ ᎠᎴ ᎩᎶ ᎠᏏᏴᏫ ᎨᏒ ᎾᎥ ᎢᏧ-ᎾᏓᎵ, ᎠᎴ ᏗᎾᏓᏅᏟ ᎨᏒ ᏱᎨᏲᎲᏍᎨᏍᏗ, ᎯᎠ ᏱᏂᎦᏪᏍᎨᏍᏗ, ᎯᎦᏙᎥᎯ ᎤᎬᏫᏳᎯ; ᎾᏂᎥᏉᏰᏃ ᎬᎩᎦᏔᎯᏳ ᎨᏎᏍᏗ, ᎤᏍᏗᎧᏂ ᎡᎲ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᎤᏟ ᎢᏯᏥᎸᏉᏗ ᎡᎲ ᏫᎬᏍᏗ.


text:
ᎾᏍᎩ ᎾᎿ ᏣᎮ ᎪᎱᏍᏗ ᎬᏙᏗ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎦᏩᏒᎩ ᎠᏥᎸᎨᎳᏍᏗ ᎦᎶᏗ, ᎠᎴ ᎾᎿ ᏥᏥᏰ ᎦᏁᏌᎢ ᏗᎧᎿᏩᏛᏍᏗ ᏗᎦᎶᏗᏱ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎫᏢᏔᏃᏅᎯ ᏥᎨᏎᎢ, ᎾᎿᏂ ᏥᎦᎴ ᎠᏕᎸᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎠᏖᎵᏙ ᎹᎾ ᏥᎦᎶᏕᎢ, ᎠᎴ ᎡᎳᏂ ᎤᏙᎳᏅᏍᏙᏗ ᏣᏥᎸᏍᎨᎢ, ᎠᎴ ᏅᏯ ᏗᏯᏖᏅ ᎾᎿ ᏥᎪᏪᎴ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛᎢ.


text:
ᏔᎵᏁᏍᎩᏂ ᏫᎦᎵᏦᏛ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎤᏩᏒ ᏌᏉ ᏫᎾᏴᎯᎮ ᏂᏓᏕᏘᏴᎯᏒᎢ, ᎥᏝ ᎠᎴ ᎩᎬ ᏂᎦᏁᏤᎲᎾ ᏱᎨᏎᎢ, ᎾᏍᎩ ᎤᏩᏒ ᎤᏍᎦᏅᏨ ᎠᎫᏴᏙᏗ, ᎠᎴ ᎤᏂᏣᏘ ᏴᏫ ᎤᏂᏍᎦᏅᏨ ᎠᎫᏴᏙᏗ.


text:
ᎾᏍᎩ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎯᎠ ᏄᏍᏕ ᎬᏂᎨᏒ ᏂᎬᏁᎮᎢ, ᎾᏍᎩ Ꮎ ᎤᏟ ᎢᎦᎸᏉᏗ ᏗᎨᏒ ᏫᎦᏅᏅ ᎠᏏ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᏏᏉ ᏥᏂᎬᏩᏍᏕ ᎢᎬᏱᏱ ᎦᎵᏦᏛᎢ;


text:
ᎾᏍᎩ ᎦᎵᏦᏛ ᏗᏟᎶᏍᏔᏅᎯᏉ ᏥᎨᏎ ᎾᎯᏳ ᎨᏒᎢ, ᎾᎿᏂ ᏥᏓᎾᎵᏍᎪᎸᏗᏍᎨ ᎠᏓᏁᏗ ᎨᏒ ᎠᎴ ᎾᏍᏉ ᎠᏥᎸ-ᎨᎳᏍᏙᏗ, ᎾᏍᎩ Ꮎ ᎢᏳᏛᏁᎸᎯ ᏰᎵ ᎾᏍᎦᏅᎾ ᎢᎬᏩᏁᏗ ᏂᎨᏒᎾ ᏥᎨᏎ ᎠᏓᏅᏙ ᎤᎬᏩᎵ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᏗᎵᏍᏓᏴᏗᏱᏉ ᎨᏒ ᎠᎴ ᎠᏗᏔᏍᏗᏱᏉ ᎨᏒ ᎠᎴ ᏗᎪᏑᎴᏗᏱ ᎨᏒᎢ, ᎠᎴ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏇᏓᎵᏉ ᎨᏒ ᏧᎬᏩᎴᎢ, ᎾᏍᎩ ᎢᏳᎾᏛᏁᏗ ᏥᏂᎨᎬᏁᎴ ᎤᏓᏁᏟᏴᏍᏗ ᎨᏒ ᎤᎵᏰᎢᎶᎯᏍᏗ ᎨᏒ ᎢᎪᎯᏛ.


text:
ᎦᎶᏁᏛᏍᎩᏂ ᎤᎷᏨᎯ ᏥᎩ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᎢᏳᎵᏍᏔᏅᎯ ᏧᎸᏫᏍᏓᏁᏗᏱ ᎣᏍᏛ ᎨᏒ ᎤᎬᏩᎵ ᎤᎵᏰᎢᎶᎯᏍᏗ ᏥᎨᏒᎩ, ᎾᏍᎩ ᏴᏗᏍᎬ ᎢᏟ ᎢᎦᎸᏉᏗ ᎠᎴ ᏂᎦᎷᎶᏥᏙᎲᎾ ᎦᎵᏦᏛᎢ, ᎩᎶ ᏧᏬᏰᏂ ᏧᏮᏔᏅᎯ ᏂᎨᏒᎾ ᎤᏬᏢᏅᎯ, ᎾᏍᎩ ᏯᏛᏅ, ᎠᏁᎳᏅᎯ ᏂᎨᏒᎾ ᎨᏒᎢ,


text:
ᎥᏝ ᎠᎴ ᏴᏫ ᏗᏂᎭᏄᎸᎯ ᎠᎴ ᏩᎦ ᎠᏂᎩᎾ ᎤᏂᎩᎬ ᎬᏗᏍᎬᎢ, ᎤᏩᏒᏍᎩᏂ ᎤᎩᎬ ᎬᏗᏍᎬᎢ, ᏌᏉ ᏄᏴᎴ ᎦᎸᏉᏗᏳ ᏗᎨᏒᎢ, ᎿᏉ ᎾᏍᎩ ᏫᎾᏍᏛᎾ ᎠᎫᏴᏙᏗ ᎢᎩᏩᏛᎡᎸ.


text:
ᎢᎳᎪ ᎢᏴᏛ ᎢᎦᎢ ᎤᏟᎯᏳ ᎦᎶᏁᏛ ᎤᎩᎬ, ᏗᏣᏓᏅᏙ ᏙᏓᏥᏅᎦᎸᎡᎵ ᏙᏓᏥᎧᎲᏏ ᎠᏓᎯᎯ ᏕᏥᎸᏫᏍᏓᏁᎲᎢ, ᎬᏂᏛᏃ ᎤᏁᎳᏅᎯ ᏤᏣᏁᎶᏙᏗᏱ ᏅᏓᏨᏁᎵ ᎾᏍᎩ ᏫᎾᏍᏛᎾ ᎡᎯ ᎠᏓᏅᏙ ᎬᏗᏍᎬ ᏄᏓᏅᎦᎸᎾ <n>[ᎠᏍᎦᎾ,]</n> ᎦᎶᏁᏛ ᎤᏩᏒ ᎤᏓᎵᏍᎪᎸᏔᏅᎯ ᏥᎩ ᎤᏁᎳᏅᎯ ᎤᏓᎵᏍᎪᎸᏓᏁᎸᎯ ᏥᎩ?


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏰᎵ ᎠᎴᎲᏍᎩ ᏂᎦᎵᏍᏗᎭ ᎢᏤ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛᎢ, ᎾᏍᎩ ᎤᏲᎱᏒᎯ ᎨᏒ ᎬᏗᏍᎬ ᏗᎬᏬᏓᎴᏍᏗ ᎢᏳᏓᏍᏙᏗᏱ ᎢᎬᏱᏱ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᎤᏂᏲᏍᏔᏅᎢ, ᎾᏍᎩ ᎨᏥᏯᏅᏛ ᏥᎩ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗᏱ ᎠᏚᎢᏍᏛ ᏫᎾᏍᏛᎾ ᎤᎾᏘᏯᏍᏓᏁᏗ ᎨᏒᎢ;


text:
ᎼᏏᏰᏃ ᏂᎦᏛ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᏚᎾᏄᎪᏫᏎᎸ ᏴᏫ ᎾᏍᎩᏯ ᏂᎬᏅ ᏗᎧᎿᏩᏛᏍᏗ, ᏩᎦ ᎠᏂᎩᎾ ᎤᏂᎩᎬ ᎠᎴ ᎠᏫ ᏗᏂᎭᏄᎸᎯ ᎤᏂᎩᎬ ᎤᏁᎩᏎᎢ, ᎠᎴ ᎠᎹ ᎠᎴ ᎤᏩᏅ ᎩᎦᎨᎢ, ᎠᎴ ᏗᏐᏈ, ᏚᏍᏚᏞᏃ ᎪᏪᎵ ᎠᎴ ᎾᏂᎥ ᏴᏫ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏚᎸᏗ ᏂᎦᎵᏍᏗᏍᎬᎩ ᎯᎠ ᎾᏍᎩ ᏂᎦᏛ ᏄᏍᏗᏓᏅ ᎦᎸᎳᏗ ᏤᎯ ᏗᏟᎶᏍᏔᏅᎯ ᎨᏒ ᏗᎦᏅᎦᎸᏙᏗᏱ ᎯᎠ ᎾᏍᎩ (ᏗᎵᏍᎪᎸᏙᏗ,) ᎦᎸᎳᏗᏍᎩᏂ ᏤᎯ ᎨᏒ ᎾᏲᎪ ᎤᏟ ᎢᏗᎦᎸᏉᏗ ᏗᎵᏍᎪᎸᏔᏅᎯ ᏗᎦᏅᎦᎸᏙᏗ.


text:
ᎦᎶᏁᏛᏰᏃ ᎥᏝ ᏱᏭᏴᎸ ᎦᎸᏉᏗᏳ ᏕᎨᏒᎢ ᎩᎶ ᏧᏬᏰᏂ ᏧᏮᏔᏅᎯ ᏧᏬᏢᏅᎯ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏙᎯᏳᎯ (ᎦᎸᏉᏗᏳ ᎨᏒ) ᏗᏟᎶᏍᏔᏅᎯ ᎨᏒᎢ; ᎦᎸᎳᏗᏍᎩᏂ ᏂᎨᏒ ᏭᏴᎸ, ᎪᎯ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎲ ᎬᏂᎨᏒ ᎢᎦᏛᏁᏗᏱ;


text:
ᎠᎴ ᎥᏝ ᎤᏚᎸᏗ ᏂᎦᎵᏍᏗᏍᎬ ᎢᏳᏍᏗ ᎢᏴᏛᎭᏉ ᎤᏓᎵᏍᎪᎸᏙᏗᏱ, ᎾᏍᎩᏯ ᏂᏓᏕᏘᏴᎮᎬ, ᎪᎱᏍᏗ ᎤᏂᎩᎬ ᎬᏗ ᏄᎬᏫᏳᏒ ᎠᏥᎸ-ᎨᎶᎯ ᏥᎾᏛᏁᎮ ᎦᎸᏉᏗᏳ ᎨᏒ ᏥᏩᏴᎯᎮᎢ;


text:
ᎢᏳᏰᏃ ᎾᏍᎩ ᏱᏄᏍᏕᎢ ᎿᏉ ᎤᏣᏘ ᎠᏎ ᎢᏳᎩᎵᏲᏨᎯ ᏱᏂᎦᎵᏍᏗᏍᎨ ᎡᎶᎯ ᏧᏙᏢᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ; ᎪᎯᏍᎩᏂ ᎨᏒ ᎤᏩᏒ ᎠᏓᎵᏍᎪᎸᏗᏍᎬ ᎠᏍᎦᏂ ᎨᏒ ᎠᎲᏍᎬᎢ ᏌᏉ ᎬᏂᎨᏒ ᏄᏓᏛᏁᎸ ᎤᎵᏍᏆᎸᏗ ᏕᎨᏌᏗᏒᎢ.


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᎦᎶᏁᏛ ᏌᏉ ᎢᏯᎦᎵᏍᏙᎸᏔᏅᎯ ᎤᎩᏍᏗᏱ ᎤᏂᏣᏘ ᎨᏒ ᎤᏂᏍᎦᏅᏨᎢ; ᎾᏍᎩᏃ Ꮎ ᎬᏩᎦᏖᏃᎯ ᎨᏒ ᏔᎵᏁ ᎬᏂᎨᏒ ᏂᏙᏛᎠᏛᏁᎵ ᏧᏍᏕᎸᏗᏱ, ᎠᏍᎦᏂ ᎠᎫᏴᏙᏗ ᎾᏰᎲᎾ


text:
ᏗᎧᎿᏩᏛᏍᏗᏰᏃ ᎣᏍᏛ ᎤᎵᏰᎢᎶᎯᏍᏗ ᎨᏒ ᎤᏓᏩᏗᏍᏙᏛ ᏧᏪᎲᎩ, ᎠᎴ ᎠᎧᎵᎢ ᏗᏟᎶᏍᏔᏅᎯ ᏂᎨᏒᎾ ᏥᎨᏒᎩ, ᎥᏝ ᏰᎵᎦ, ᎾᏍᎩ ᏗᏓᏍᎪᎸᏙᏗ ᏓᏅᏗᏍᎬ, ᏂᏓᏕᏘᏴᎯᏒ ᏂᎪᎯᎸ ᏥᏓᎾᎵᏍᎪᎸᏗᏍᎨᎢ ᎾᎿ ᎠᏂᎷᎩ ᏄᏂᎪᎸ-Ꮎ ᎢᎬᏩᏅᏁᏗ ᏱᎨᏎᎢ.


text:
ᎦᏳᎳ ᎯᎠ ᎢᏳᏪᏛ ᏥᎩ, ᎠᏥᎸᎨᎳᏍᏙᏗ ᎠᎴ ᎠᎵᏍᎪᎸᏙᏗ, ᎠᎴ ᏧᏃᏍᏗ ᎠᏥᎸ-ᏗᎨᎳᏍᏙᏗ, ᎠᎴ ᏗᎵᏍᎪᎸᏙᏗ ᎠᏍᎦᏂ ᎠᎫᏴᏙᏗ, ᎥᏝ ᏰᎵ ᏱᏗᏣᏰᎸᏁᎢ, ᎥᏝ ᎠᎴ ᎣᏏᏳ ᏱᏗᏣᏰᎸᏁᎢ; ᎾᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎾᏍᎩᏯ ᏂᎬᏅ ᏗᎵᏍᎪᎸᏔᏅᎯ ᏥᎨᏎᎢ;


text:
ᎿᏉ ᎯᎠ ᏄᏪᏎᎢ, ᎬᏂᏳᏉ, ᏥᎷᎩ ᏄᏍᏛ ᏣᏚᎵᏍᎬ ᎢᏯᏆᏛᏁᏗᏱ ᏣᏁᎳᏅᎯ. ᎢᎬᏱᏱ <n>[ᎤᏁᎢᏍᏔᏅ]</n> ᎠᏲᏍᏗᎭ, ᎾᏍᎩ ᏔᎵᏁ <n>[ᎤᏁᎢᏍᏔᏅ]</n> ᎤᏍᏓᏱᏗᏍᏗᏱ.


text:
ᎠᎴ ᎾᏂᎥ ᎠᏥᎸ-ᎠᏁᎶᎯ ᏓᏂᏙᎨ ᏚᏂᎸᏫᏍᏓᏁᎮ ᏂᏓᏙᏓᏈᏒᎢ, ᎠᎴ ᏂᎪᎯᎸ ᎤᏠᏱᏉ ᎠᏥᎸ-ᏗᎨᎳᏍᏙᏗ ᏧᎾᎵᏍᎪᎸᏗᏍᎨᎢ, ᎾᏍᎩ ᎠᏍᎦᏂ ᎨᏒ ᎢᎸᎯᏳ ᏰᎵ ᎬᏩᎲᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎾᎥ ᎢᏗᎷᎨᏍᏗ ᎢᏛᏗᏍᎨᏍᏗ ᏄᏠᎾᏍᏛᏅ ᏗᎩᎾᏫ, ᎠᎴ ᎤᎵᏂᎩᏛ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎠᎴ ᏗᎩᎾᏫ ᏤᎩᏍᏚᏞᎸᎯ ᏤᎩᏅᎦᎸᎯ ᎤᏲ ᎠᏓᏅᏖᏗ ᎨᏒᎢ, ᎠᎴ ᏗᏗᏰᎸ ᎦᏓᎭ ᏂᎨᏒᎾ ᎠᎹ ᏤᎪᏑᎴᏓᏁᎸᎯ.


text:
ᏞᏍᏗᏉ ᏱᏗᏑ-ᎵᎪᎨᏍᏗ ᎢᏓᏓᏟᏌᏂᏙᎲᎢ, ᎢᎦᏛ ᎾᏍᎩ ᎢᏳᎾᏛᏁᏗ ᏥᎩ; ᏕᏣᏓᏬᏁᏗᏍᎨᏍᏗᏍᎩᏂ; ᎠᎴ Ꮀ ᎤᎬᏫᏳᏎᏍᏗ, ᎾᏍᎩ ᏂᏣᏛᏁᎮᏍᏗ ᏥᏥᎪᏩᏗ ᎤᏍᏆᎸᎯᏗᏒ ᎾᎯᏳ ᎢᎦ.


text:
ᏝᏍᎪ ᎤᏟ ᎢᎦᎢ ᏱᏂᏙᎬᏩᏳᎪᏗ ᎠᏥᏍᏛᏗᏍᏙᏗᏱ ᎩᎶ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎤᎳᏍᏓᎡᎸᎯ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎩᎬᎧᏃᎮᏛ ᏗᏠᎯᏍᏙᏔᏅᎯ ᎾᏍᎩ ᎤᏓᏅᎦᎶᏔᏅᎯ ᎨᏒ ᎦᏓᎭ ᎤᏰᎸᏅᎯ, ᎠᎴ ᎦᎬᏩᏐᏢᏔᏅᎯ ᎬᏩᎦᏘᏯ ᎠᏓᏙᎵᎩ ᎠᏓᏅᏙ.


text:
ᎥᏆᎸᎢᏛᏰᏃ ᎨᏒ ᎢᏳᏍᏗ ᎥᏍᎩᏯ-ᏙᎵᏨᎩ, ᎠᎴ ᎤᎵᎮᎵᏍᏗᏉ ᎥᏣᏓᏅᏛᎩ ᎡᏥᏬᏅᎲ ᏧᎬᏩᎶᏗ ᎢᏥᎲᎢ, ᎢᏥᎦᏔᎲᎩᏰᏃ ᎦᎸᎳᏗ ᏫᏥᏍᏆᏂᎪᏛ ᎤᏟ ᎢᏲᏍᏛ ᎠᎴ ᎠᏲᎩ ᏂᎨᏒᎾ ᏧᎬᏩᎶᏗ.


text:
ᎠᏎᏃ ᎥᏝ ᎠᎾᏨᏍᎩ ᏥᎩ <n>[ᎤᎾᏓᏡᎬ]</n> ᎢᏖᎳ ᏱᎩ, ᎾᏍᎩ ᎨᏥᏛᏙᏗ ᎨᏒ ᎢᏴᏛ ᏥᏩᏂᎷᎦ, ᎾᏍᎩᏍᎩᏂ Ꮎ ᎤᎾᏓᏡᎬ ᎢᏖᎳ, ᎾᏍᎩ ᎤᏃᎯᏳᏒ ᏥᏓᏂᏍᏕᎸᏗ ᏧᎾᏓᏅᏙ.


text:
ᎪᎯᏳᏗᏃ ᎨᏒ ᎯᎠ ᏄᏍᏗ ᎦᏛᎬᎢ, ᎤᎵᏂᎩᏛ ᎪᎯᏳᏗᏱ ᎠᎪᏩᏛᏗᏱ ᎨᏒ ᏄᏍᏛ ᎤᏚᎩ ᎣᏩᏒᎢ, ᎠᎴ ᏄᏜᏏᏛᏒᎾ ᎢᏳᏓᎵᏍᏓᏁᏗᏱ ᎡᎲ ᎾᏍᎩ Ꮎ ᎠᏏ ᎠᎪᎲᎯ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎢᏛᏗᏍᎬ ᎢᏙᎵᎦ ᎤᏁᎳᏅᎯ ᎧᏁᎬ ᎬᏔᏅᎯ ᎨᏒ ᎡᎶᎯ ᏚᏙᏢᏅᎢ, ᎾᏍᎩᏃ ᏧᏓᎴᏅᏛ ᎠᎪᏩᏛᏗ ᏥᎩ ᎥᏝ ᎾᏍᎩ Ꮎ ᎬᏂᎨᏒ ᎢᏳᎵᏍᏔᏅᎯ ᎨᏒ ᏗᎪᏢᏔᏅᎯ ᏱᎩ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎬᏗᏍᎬ ᎡᏈᎵ ᎤᏟ ᎢᏲᏍᏛ ᎤᎵᏍᎪᎸᏓᏁᎴ ᎤᏁᎳᏅᎯ ᎠᏥᎸ-ᎨᏔᏍᏙᏗ ᎨᏒ ᎡᏍᎦᏉ ᎨᏂ, ᎾᏍᎩ ᏄᏛᏁᎸ ᎤᏩᏛᏔᏁ ᎪᎯᏳᏍᎩ ᎤᏓᎤᏗᏳ ᎨᏒᎢ, ᎤᏁᎳᏅᎯ ᎬᏂᎨᏒ ᏄᏩᏁᎴ ᏚᏓᏂᎸᏤᎸ ᎤᎵᏍᎪᎸᏔᏅᎯ ᎨᏒᎢ; ᎾᏍᎩᏃ ᏄᏛᏁᎸ ᎬᏗᎭ ᎧᏁᎦ ᎾᏍᏉ ᎤᏲᎱᏒᎯ ᏥᎩ.


text:
ᎦᎯᏳᏗ ᎨᏒ ᎬᏗᏍᎬ ᎢᎾᎩ ᎠᎦᏘᎾᏫᏛᎮ ᎾᏍᎩ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎤᎪᏩᏛᏗᏱ ᏂᎨᏒᎾ; ᎠᎴ ᎥᏝ ᏯᏥᏩᏛᎮᎢ, ᎤᏁᎳᏅᎯᏰᏃ ᎤᏘᎾᏫᏛᎮᎢ; ᎠᏏᏉᏰᏃ ᎾᎦᏘᎾᏫᏗᏍᎬᎾ ᎨᏎ ᎤᏁᎳᏅᎯ ᎣᏏᏳ ᎤᏰᎸᏗ ᎨᏒ ᏚᎸᏫᏍᏓᏁᎲ ᎬᏂᎨᏒ ᎾᎬᏁᎴᎢ.


text:
ᎪᎯᏳᏗᏍᎩᏂ ᎨᏒ ᏂᏛᏗᏍᎬᎾ ᏱᎩ ᎬᏩᏟᏍᏗ ᎣᏍᏛ ᎤᏰᎸᏗ <n>[ᎤᏁᎳᏅᎯ]</n> ᏗᎩᎸᏫᏍᏓᏁᏗᏱ; ᎩᎶᏰᏃ ᎤᏁᎳᏅᎯ ᏱᎦᎷᏤᎭ ᎠᏎ ᏱᎦᎯᏳᎲᏍᎦ ᎡᎲᎢ, ᎠᎴ ᎾᏍᎩ ᏗᎫᏴᎡᎯ ᎨᏒ ᎤᎵᏂᎩᏛ ᎬᏩᏲᎯ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎬᏗᏍᎬ ᏃᏯ, ᎤᏁᎳᏅᎯ ᎤᏪᏯᏔᏅ ᎤᏁᎢᏍᏓᏁᎸ ᏧᏓᎴᏅᏛ ᎠᏏ ᎤᎪᎲᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎤᎾᏰᏎᎢ, ᎤᏛᏅᎢᏍᏔᏁ ᏥᏳ ᎤᎾᎵᏍᏕᎸᏙᏗ ᏚᏓᏘᎾᎥᎢ; ᎾᏍᎩ ᏄᏛᏁᎸ ᎤᏮᏔᏁ ᏚᏭᎪᏓᏁᎴ ᎡᎶᎯ, ᎠᎴ ᎤᏤᎵ ᏄᎵᏍᏔᏁ ᎾᏍᎩ ᏚᏳᎪᏛ ᎨᏒ ᎪᎯᏳᏗ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎬᏗᏍᎬ ᎡᏆᎭᎻ ᎾᎯᏳ ᎠᏥᏯᏅᎲ ᎢᎸᎯᏢ ᎤᏪᏅᏍᏗᏱ ᎾᏍᎩ ᎾᎿ ᎣᏂ ᎢᏴᏛ ᎤᏤᎵᎦ ᎢᏯᎬᏁᏗ ᎨᏒᎢ, ᏧᏬᎯᏳᏁᎢ; ᎠᎴ ᏧᏄᎪᏤᎢ ᎾᎦᏔᎲ ᎾᎿ ᎠᎢᏒᎢ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎬᏗᏍᎬ ᎡᏙᎯᏉ ᎢᏳᏍᏗ ᎤᏪᏙᎴ ᎾᎿ ᎠᏥᏚᎢᏍᏓᏁᎸ ᎦᏙᎯ, ᏅᏩᎾᏓᎴ ᎤᎾᏤᎵᎪᎯ ᎾᏍᎩᏯ, ᏕᎦᎵᏦᏛᏉ ᎠᏁᎮ ᎢᏧᎳᎭ ᎡᏏᎩ ᎠᎴ ᏤᎦᏈ ᎠᏚᎢᏍᏔᏅᎯ ᎨᏒᎢ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎾᏍᏉ ᎬᏗᏍᎬ ᏎᎵ ᎤᏩᏒ ᏧᏄᎵᏍᏔᏁᎢ, ᎠᎴ ᎠᏲᎵ ᏧᎾᏄᎪᏫᏎ ᎿᏉ ᏧᏓᎾᏄᎪᏫᏍᏗᏱ ᎤᎶᏐᏁᎸᎯ ᏥᎨᏎᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏄᏓᎵᏓᏍᏛᎾ ᎤᏰᎸᏅ ᎾᏍᎩ Ꮎ ᎤᏚᎢᏍᏔᏅᎯ ᎨᏒᎢ.


text:
ᎾᏍᎩᏃ ᎠᏏᏴᏫ ᎨᏒ ᏧᎾᏓᎴᏁᎢ ᎠᎴ ᎾᏍᎩ ᎤᏲᎱᏒᎯᏉ ᎾᏍᎩᏯ ᎨᏒᎢ, ᏃᏈᏏ ᎦᎸᎶ ᏣᏂᎧᎳ ᏥᏄᏂᏧᏈᏍᏗ ᎢᏳᏂᏧᏈᏍᏗ, ᎠᎴ ᏃᏳ ᎠᎺᏉᎯ ᎤᏣᏘ ᏥᎦᎳᎨᏴ ᎬᏎᎰᎲᏍᏗ ᏂᎨᏒᎾ ᏥᎩ ᎢᏳᏂᏧᏈᏍᏗ.


text:
ᎯᎠ ᎾᏍᎩ ᏂᎦᏛ ᎬᏩᏃᎯᏳᎯ ᏚᏂᏲᎱᏎᎢ, ᏂᏚᎾᏓᏂᎸᏨᎾ ᎾᏍᎩ Ꮎ ᎨᏥᏚᎢᏍᏓᏁᎸᎯ ᎨᏒᎢ, ᎢᏅᏍᎩᏂ ᏫᏓᏂᎪᏩᏘᏍᎨᎢ ᎠᎴ ᏄᎾᏜᏏᏛᎡᎲᎾ ᎨᏎᎢ, ᎠᎴ ᏚᏂᏂᏴᎮᎢ, ᎠᎴ ᎠᏂᏃᎲᏍᎨ ᏅᏩᎾᏓᎴᏉ ᎠᎴ ᎠᏁᏙᎯᏉ ᎨᏒ ᎠᏂ ᎡᎶᎯ.


text:
ᎪᎯᏍᎩᏂ ᎤᏟ ᎢᏲᏍᏛ ᎤᎾᏤᎵᎪᎯ ᎤᏂᏲᎭ, ᎾᏍᎩ ᎦᎸᎶᎢ ᏗᏍᏆᏂᎪᏛᎢ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎥᏝ ᏯᏕᎰᏍᎦ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎠᎪᏎᏗᏱ; ᏚᏛᏅᎢᏍᏓᏁᎸᏰᏃ ᎦᏚᎲᎢ.


text:
ᎪᎯᏳᏗ ᎨᏒ ᎬᏗᏍᎬ ᎤᏁᏤ ᎧᏃᎯᏰᎩ ᏗᎵᏍᏓᏴᏗᏱ ᎤᏂᏍᏆᏂᎪᏙᏗᏱ, ᎠᎴ ᎩᎬ ᎤᏂᏍᏚᏟᏍᏗᏱ <n>[ᎦᎶᎯᏍᏗᏱ,]</n> ᎾᏍᎩ ᎢᎬᏱ ᎤᎾᏕᏅᎯ ᏗᏛᏗᏍᎩ ᎪᎱᏍᏗ ᎤᏅᏁᏗᏱ ᏂᎨᏒᎾ.


text:
ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᎠᏅᏗᏍᎬ ᎠᏰᎵ ᏕᎪᏢᏒ ᏥᏓᎾᏓᎵᏁᎯᏕᎮᎢ, ᏚᏳᎪᏛ ᏥᏚᏂᎸᏫᏍᏓᏁᎮᎢ, ᎤᎾᏤᎵ ᏥᎾᏅᏁᎮ ᏄᏍᏛ ᎨᏥᏚᎢᏍᏓᎸᎢ, ᏢᏓᏥ ᎤᏂᏃᏕᏅ ᏗᏂᎰᎵ ᏥᏓᏂᏍᏚᎲᏍᎨᎢ,


text:
ᎠᏥᎸ ᎤᏍᎦᏎᏗ ᏣᏅᏜᏗᏍᎨᎢ, ᎠᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᏣᎾᏗᏫᏎᎮᎢ, ᏗᏂᏩᎦᎳ ᎨᏒ ᏧᎾᎵᏂᎩᏛ ᏥᏂᎨᎬᏁᎮᎢ, ᎾᏂᏍᎦᎢᎲᎾ ᏂᎾᎾᎵᏍᏗᏍᎨ ᏓᎾᎵᎲᎢ, ᏥᏓᏂᎨᎯᏙᎮ ᏅᏩᎾᏓᎴ ᎠᏂᏯᏫᏍᎩ.


text:
ᎠᏂᎨᏴ ᏗᎬᏩᏂᏲᎱᎯᏎᎸᎯ ᏗᏅᏃᏛ ᏔᎵᏁ ᏂᏙᎨᏥᏲᎯᏎᎮᎢ; ᎢᎦᏛᏃ ᏥᎨᏥᎩᎸᏍᎨᎢ, ᏂᏓᎾᏓᏂᎸᎬᎾ ᎨᎫᏓᎴᏍᎬᎢ; ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᎤᏟ ᎢᏲᏍᏛ ᎤᏂᏩᏛᏗᏱ ᎤᎾᏚᎵᏍᎬ ᏗᎴᎯᏐᏗ ᎨᏒᎢ;


text:
ᏅᏯ ᏕᎨᎬᏂᏍᏗᏍᎨᎢ, ᏗᎦᏄᏙᎩ ᎬᏗ ᏕᎨᏥᎦᎵᏍᎨᎢ, ᏕᎨᏥᎪᎵᏰᏍᎨᎢ, ᎠᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᏕᎨᏥᎢᏍᏗᏍᎨᎢ; ᎠᏫ ᎤᏂᏃᏕᎾ ᎠᎴ ᎠᏫ ᏗᏂᎭᏄᎸᎯ ᏧᏂᏁᎦᎸᏅᎯ ᏧᎾᏄᏩᎢ ᎠᏁᏙᎮᎢ; ᎤᏂᏂᎬᏎᎯ ᎨᏎᎢ, ᎠᏂᎩᎵᏲᏥᏙᎮᎢ.


text:
ᎾᏍᎩᏃ ᎢᏳᏂᏧᏈᏍᏗ ᎠᏂᎦᏔᎯ ᏥᎦᎨᎦᏚᏫᏍᏗ, ᎢᏴᏛ ᏂᏛᏁᏓ ᏄᏓᎴᏒ ᎦᎨᏛ ᎢᎬᏁᎯ, ᎠᎴ ᎠᏍᎦᏂ ᎠᎯᏛ ᎨᎦᏢᏔᏍᏗ ᏥᎩ, ᎠᎴ ᏗᏛᏂᏗᏳ ᎨᏎᏍᏗ ᎢᏓᏙᎩᏯᏍᎨᏍᏗ ᎠᏙᎩᏯᏍᏗ ᎢᎬᏱᏗᏢ ᏁᎬᏁᎸᎢ,


text:
ᏫᏕᏓᎦᏂᏍᎨᏍᏗ ᏥᏌ ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ, ᎠᎴ ᎠᏍᏆᏗᏍᎩ ᏥᎩ ᎢᎪᎯᏳᏒᎢ. ᎾᏍᎩ ᎤᎵᎮᎵᏍᏗ ᎨᏒ ᎢᎬᏱᏗᏢ ᎾᎬᏁᎸ ᎢᏳᏍᏗ ᎬᏂᏗᏳ ᏓᏓᎿᏩᏍᏛ ᎤᎩᎵᏲᏤᎢ, ᎤᎵᏌᎵᏉ ᎤᏰᎸᏎ ᎤᏕᎰᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎠᎦᏘᏏᏗᏢ ᎤᏪᏅ ᎤᏁᎳᏅᎯ ᎤᏪᏍᎩᎸᎢ.


text:
ᎠᎴ ᎢᏨᎨᏫᏒᎯ ᎢᎩ ᎡᏥᏬᏁᏗᏍᎬ ᏗᏂᏲᎵ ᏥᎨᏥᏬᏁᏗᏍᎪ ᎾᏍᎩᏯᎢ, ᎯᎠ ᏥᏂᎦᏪᎭ, ᎠᏇᏥ ᏞᏍᏗ ᏅᎵᏌᎵ ᏱᏣᏰᎸᏎᏍᏗ ᎤᎬᏫᏳᎯ ᏣᎩᎵᏲᎢᏍᏗᏍᎬᎢ, ᎠᎴ ᏞᏍᏗ ᏩᎾ ᎯᏳᏏᎦᎶᎨᏍᏗ ᏣᎬᏍᎪᎸᎢᏍᎨᏍᏗ,


text:
ᎠᎴ Ꮼ, ᎤᏇᏓᎵ ᎨᏒ ᏗᎩᏙᏓ ᏕᎨᎲᎩ, ᎾᏍᎩ ᏥᎨᎩᎩᎵᏲᎢᏍᏗᏍᎬᎩ; ᎠᎴ ᎨᏗᎸᏉᏗᏳ ᏥᎨᏒᎩ; ᏝᏍᎪ ᎤᏟ ᏱᏂᏙᎬᏩᏳᎪᏗ ᏤᏓᏓᏲᎯᏎᏗᏱ ᏗᎦᏓᏅᏙ ᏧᏬᏢᏅᎯ ᏥᎩ, ᎠᎴ ᎢᎦᏛᏂᏗᏍᏗᏱ?


text:
ᎾᏍᎩᏰᏃ Ꮎ ᎤᏙᎯᏳᎯ ᏞᎦ ᎨᎩᎩᎵᏲᎢᏍᏗᏍᎬᎩ ᎤᏅᏒ ᎠᎾᏓᏅᏖᏍᎬ ᎾᎾᏛᏁᎲᎩ; <n>[ᎤᏁᎳᏅᎯᏍᎩᏂ]</n> ᎣᏍᏛ ᎢᎦᎵᏍᏓᏁᏗ ᎤᎬᏩᎸ, ᎾᏍᎩ ᎢᏣᏠᏯᏍᏗᏍᎩ ᎢᏳᎵᏍᏙᏗᏱ ᎤᏩᏒ ᎠᏍᎦᎾ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎠᎴ ᏂᎦᎥᏉ ᎠᎩᎵᏲᎢᏍᏗ ᎨᏒ ᎪᎯ ᎨᏒ ᎥᏝ ᎣᏍᏛ ᎣᏓᏅᏓᏗᏍᏗᏍᎩ ᏱᎩ, ᎤᏲᏉᏍᎩᏂ; ᎣᏂᏍᎩᏂᏃᏅ ᎢᏴᏛ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒ ᎦᎾᏄᎪᏫᏍᎪ ᏚᏳᎪᏛ ᎨᏒ ᎤᎾᏄᎪᏫᏒᎯ, ᎾᏍᎩ ᎢᏳᎾᎵᏍᏓᏁᎸᎯ.


text:
ᎢᏤᏯᏔᎯᏳ ᎨᏎᏍᏗ ᎾᏍᎩᏃ ᏞᏍᏗ ᎩᎶ ᎡᏍᎦ ᎤᏬᎭᏒᎩ ᎤᏁᎳᏅᎯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ; ᏞᏍᏗ ᎤᏴᏍᏗ ᎤᎿᏍᏕᏢ ᎦᎾᏄᎪᎬ ᎢᏣᏕᏯᏙᏔᏅᎩ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᎤᏂᏣᏘ ᎦᏓᎭ ᎢᏳᎾᎵᏍᏔᏅᎩ;


text:
ᏞᏍᏗ ᎩᎶ ᎤᏕᎵᏛ ᏗᏂᏏᎲᏍᎩ ᏱᏣᏓᏑᏰᏍᏗ, ᎠᎴ ᎠᏍᎦᎾ ᏴᏫ, ᎢᏐ ᎾᏍᎩᏯᎢ, ᎠᎴ ᎠᏍᎦᎾ ᏴᏫ, ᎢᏐ ᎾᏍᎩᏯᎢ, ᎤᏍᎩ ᏌᏉᏉ ᎢᏯᎵᏍᏓᏴᏗ ᏥᏚᎬᏩᎶᏔᏁ ᏧᎾᏗᏅᏎ ᎢᎬᏱ ᎡᎯ ᎨᏒᎢ.


text:
ᎢᏥᎦᏔᎭᏰᏃ ᎣᏂ ᎢᏴᏛ ᎣᏍᏛ ᎢᏯᎦᏛᏁᏗᏱ ᏧᏚᎵᏍᎨ ᏣᏥᏐᏅᎢᏍᏔᏁᎢ; ᎥᏝ ᏰᏃ <n>[ᎤᏙᏓ]</n> ᎤᏓᏅᏛ ᎬᏩᏁᏟᏴᏍᏗ ᎨᏒ ᏳᏩᏛᎮᎢ, ᎤᎵᏏᎾᎯᏍᏗᏳᏍᎩᏂᏃᏅ ᎠᎴ ᏗᎬᎦᏌᏬᎢᎯ ᎤᏲᎴᎢ.


text:
ᎠᎴ ᎾᎿ ᏂᎦᏗᏳ ᎤᎾᏓᏟᏌᎲᎢ, ᎠᎴ ᎢᎬᏱ ᎤᎾᏕᏅᎯ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬᎢ, ᎾᏍᎩ <n>[ᏚᎾᏙᎥ]</n> ᎦᎸᎳᏗ ᏥᏕᎪᏪᎳ, ᎠᎴ ᎾᎿ ᎤᏁᎳᏅᎯ ᏂᎦᏗᏳ ᏗᎫᎪᏓᏁᎯ <n>[ᎡᎲᎢ,]</n> ᎠᎴ ᎾᎿ ᏧᎾᏓᏅᏙ ᎤᎾᏓᏅᏘ ᏴᏫ ᎾᏂᏍᎦᏅᎾ ᎢᎨᎬᏁᎸᎯ <n>[ᎠᏁᎲᎢ,]</n>


text:
ᎠᎴ ᎾᎿ ᏥᏌ <n>[ᎡᎲᎢ]</n> ᎾᏍᎩ ᎠᏰᎵ ᎠᎴᎲᏍᎩ ᎢᏤ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛᎢ, ᎠᎴ ᎾᎿ ᎩᎬ ᎠᏍᏚᏢᎯ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏟ ᎢᏲᏍᏛ ᎠᏔᏲᎯᎯ ᏥᎩ ᎡᏍᎦᏉ ᎡᏈᎵ <n>[ᎤᎩᎬ.]</n>


text:
ᎢᏤᏯᏔᎮᏍᏗ ᏞᏍᏗᏉ ᎡᏥᏲᎢᏎᎸᎩ ᎾᏍᎩ Ꮎ ᏥᎧᏁᎦ. ᎢᏳᏰᏃ ᏄᎾᏓᏗᏫᏎᎸᎾ ᏱᎩ ᎾᏍᎩ Ꮎ ᎤᏂᏲᎢᏎᏛ ᎡᎶᎯ ᎤᏁᏨᎯ, ᎤᏟᎯᏳ ᎬᏩᏟᏍᏗ ᎢᎦᏓᏗᏫᏎᏗᏱ ᎢᏳᏃ ᎢᏴᏛ ᏱᏁᏓᏛᏁᎸ ᎦᎸᎳᏗ ᏨᏗᎧᏁᎦ;


text:
ᎾᏍᎩᏃ ᎯᎠ ᏥᏂᎦᏪᎭ ᎠᏏ ᏌᏉᎢ, ᎾᏍᎩ ᎢᏴᏛ ᎢᏗᎬᏁᏗ ᎨᏒ ᎾᏍᎩ ᏗᏖᎸᏅᎯ ᎨᏒ ᎦᏛᎦ, ᎾᏍᎩ ᏗᎪᏢᏅᎯᏉ ᎾᏍᎩᏯᎢ, ᎾᏍᎩᏃ Ꮎ ᏧᏓᎴᏅᏛ ᏗᎬᏤᎸᏗ ᏂᎨᏒᎾ ᎨᏒ ᎾᎿ Ꮙ ᏗᏍᏆᏂᎪᏛᏗ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᎩ ᎠᏴ ᏗᎦᏓᏂᎸᏨᎯ ᏥᎩ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎪᎯ ᎨᏒ ᎾᏍᎩ ᎬᏖᎸᏗ ᏂᎨᏒᎾ, ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎢᎩᎮᏍᏗ, ᎾᏍᎩ ᎢᏛᏗᏍᎬ ᎤᏁᎳᏅᎯ ᎣᏍᏛ ᎤᏰᎸᏗ ᏗᎨᎩᎸᏫᏍᏓᏁᏗ ᏱᎩ, ᎦᎸᏉᏗᏳ ᎨᏒ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎦᎾᏰᎯᏍᏗ ᎨᏒ ᏔᎵ ᎢᎬᏗᏕᎬᎢ.


text:
ᏕᏥᎸᏫᏍᏓᏁᎲ ᏞᏍᏗ ᏧᎬᏩᎶᏗ ᎠᎬᎥᎯᏍᏗ ᎨᏒ ᏳᎵᏠᏯᏍᏕᏍᏗ; ᎠᎴ ᏰᎵᏉ ᎢᏥᏰᎵᏎᏍᏗ ᏄᏍᏛ ᎪᎱᏍᏗ ᎢᏥᎲᎢ; ᎯᎠᏰᏃ ᎢᏳᏪᏛ ᎢᎩ, ᎥᏝ ᎢᎸᎯᏳ ᎤᏁᎳᎩ ᏴᎦᎬᏰᎵᏏ, ᎥᏝ ᎠᎴ ᏴᎦᎬᏴᏕᎩ.


text:
ᏕᏣᏅᏓᏗᏍᎨᏍᏗ ᎾᏍᎩ Ꮎ ᎨᏣᎦᏌᏯᏍᏗᏕᎩ, ᎾᏍᎩ Ꮎ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎧᏃᎮᏛ ᎨᏥᎾᏄᎪᏫᏎᎸᎯ; ᎾᏍᎩ ᏄᏍᏛ ᎤᏃᎯᏳᏒ ᎢᏥᏍᏓᏩᏗᏎᏍᏗ, ᎣᏍᏛ ᎢᏣᏓᏅᏖᎯᏌᏛ ᎨᏎᏍᏗ ᏄᏍᏛ ᏭᎵᏰᎢᎶᎸ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ,


text:
ᏞᏍᏗ ᎫᏓᎴᏅᏛ ᎠᎴ ᏂᏥᎦᏔᎲᎾ ᏗᏕᏲᏗ ᎨᏒ ᏱᏗᏣᏘᏂᏙᎮᏍᏗ; ᎣᏏᏳᏰᏃ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏳᎵᏍᏓᏱᏗᏍᏗ ᎣᎾᏫ; ᎥᏝᏃ ᏄᏍᏛᏉ ᎥᎵᏍᏓᏴᎲᏍᎬᎢ, ᎾᏍᎩ ᎪᎱᏍᏗ ᎤᎾᎵᏍᏕᎸᏙᏗ ᏭᎵᏰᎢᎶᎸᎯ ᏂᎨᏒᎾ ᎨᏒ ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᎾᎦᏌᏯᏍᏔᏅᎯ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᏂᎪᎯᎸ ᎤᏁᎳᏅᎯ ᎦᎸᏉᏙᏗ ᎨᏒ ᎢᏓᎵᏍᎪᎸᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᏕᎩᎭᎦᎸ ᏧᎾᏄᎪᏫᏒᎯ ᎢᏓᎵᏍᎪᎸᏗᏍᎨᏍᏗ, ᎾᏍᎩ ᏕᏅᏙᎥ ᎬᏂᎨᏒ ᏂᏛᏁᎲ ᎡᏓᎵᎡᎵᏤᎲᎢ.


text:
ᏕᏦᎯᏳᏎᏍᏗ ᎾᏍᎩ Ꮎ ᎨᏣᎦᏌᏯᏍᏗᏕᎩ, ᎠᎴ ᏕᏣᏓᏲᏍᎨᏍᏗᏉ; ᏗᏣᏓᏅᏙᏰᏃ ᏚᎾᎦᏌᏯᏍᏗᏕᎦ, ᎾᏍᎩᏯ ᎢᏳᎾᏛᏁᏗ ᏥᎩ ᎾᏍᎩ Ꮎ ᎬᏂᎨᏒ ᎢᏳᏅᏁᏗ ᏥᎨᏐ ᏄᎾᏛᏁᎵᏙᎸᎢ; ᎾᏍᎩ ᎠᎾᎵᎮᎵᎬ ᎬᏂᎨᏒ ᎢᎬᏩᏅᏁᏗ ᏱᎩ, ᎥᏝᏃ ᎤᏲᏉ ᏚᎾᏓᏅᏛᎢ; ᎾᏍᎩᏰᏃ ᎥᏝ ᎨᏣᎵᏍᏕᎸᏙᏗ ᏱᎩ.


text:
ᎤᏁᎳᏅᏗᏃ ᏅᏩᏙᎯᏯᏛ ᎠᏓᏁᎯ, ᎾᏍᎩ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎤᏲᎱᏒ ᏔᎵᏁ ᏧᎴᏔᏅᎯ ᏥᎩ, ᎾᏍᎩ Ꮎ ᎠᏥᎸᏉᏗ ᎠᏫ-ᏗᎦᏘᏯ ᎢᏯᎬᏁᎸᎯ, ᎬᏔᏅᎯ ᎩᎬ, ᎠᏲᎩ ᏂᎨᏒᎾ ᎧᏃᎮᏛ ᏓᏠᎯᏍᏛ ᎠᏍᏓᏱᏗᏍᎩ,


text:
ᏂᏥᎪᎸᎾ ᎢᏨᏁᏗ ᎨᏎᏍᏗ, ᏂᎦᎥ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎾᏍᎩ ᏗᎨᏥᎸᏫᏍᏓᏁᏗ ᎣᏏᏳ ᎤᏰᎸᏗ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ ᎣᏍᏛ ᎤᏰᎸᏗ ᎨᏒ ᎢᏣᏛᏁᏗᏱ ᏂᏨᏁᎲ ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ; ᎾᏍᎩ ᎠᏥᎸᏉᏙᏗ ᎨᏎᏍᏗ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸᎢ. ᎠᎺᏅ.


text:
ᎢᏳᏃ ᎩᎶ ᏂᎯ ᎢᏤᎲ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎤᏂᎬᎨᏍᏗ, ᎤᏁᎳᏅᎯ ᎠᏔᏲᏎᎮᏍᏗ, ᎾᏍᎩ ᎾᏂᎥ ᏄᎵᏏᏅᏛᎾ ᏗᏁᎯᏥᎩ, ᎠᎴ ᏂᏓᏍᎦᎬᎾ ᏥᎩ; ᎠᎴ ᎠᏎ ᎠᏥᏁᏗ ᎨᏎᏍᏗ.


text:
ᎣᏏᏳ ᎢᏳᎵᏍᏓᏁᏗ ᎾᏍᎩ Ꮎ ᎠᏍᎦᏯ ᎤᎪᎵᏰᏍᎩ ᏧᏱᎵᏙᎰ ᎬᏂᏗᏳ ᏥᎨᏐᎢ, ᎠᏥᎪᎵᏰᎥᎯᏰᏃ ᎨᏎᏍᏗ ᎬᏂᏛ ᎠᎵᏍᏚᎶ ᎠᏥᏅᏁᏗ ᎨᏎᏍᏗ, ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᏧᏚᎢᏍᏓᏁᎸᎯ ᏥᎩ ᎬᏩᎨᏳᎯ.


text:
ᎾᎦᎥ ᎣᏍᏛ ᎠᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᏂᎦᎥ ᎣᏌᏂ ᎠᏓᏁᏗ ᎨᏒ ᎦᎸᎳᏗ ᏗᏓᎴᎲᏍᎦ ᎠᎴ ᎠᏠᎠᏏᎯᎭ ᏗᏓᎴᎲᏍᎦ ᎠᎦᏴᎵᎨᏍᏛᏱ ᎢᎦᎦᏘ ᎤᏪᎯ, ᎾᏍᎩ ᎬᏩᏓᏁᏟᏴᏍᏗ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᎴ ᎬᏩᎦᏔᎲᏍᏗ ᎨᏒ ᏄᏓᏴᎳᏛᏫ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏴᏛ ᏂᏨᏁᎮᏍᏗ ᏂᎦᎥ ᎦᏓᎭ ᎨᏒᎢ ᎠᎴ ᎤᎶᏒᏍᏔᏅᎯ ᎤᏲ ᎨᏒᎢ, ᎠᎴ ᎤᏓᏙᎵᏍᏗ ᎢᏨᏔᏅᎭ ᏕᏣᏓᏂᎸᏨᎭ ᎧᏃᎮᏛ ᎬᏱᏝᏅᎯ, ᎾᏍᎩ ᏰᎵᏉ ᏗᎬᏩᏍᏕᎸᏗ ᏥᎩ ᏗᏣᏓᏅᏙᎩ.


text:
ᎩᎶᏍᎩᏂ ᎣᏍᏛ ᎠᎪᎵᏰᏍᎨᏍᏗ ᎠᎧᎵᎸᎯ ᏗᎧᎿᏩᏛᏍᏗ ᎬᎧᎲᏍᎩ ᏥᎩ, ᎠᎴ ᎦᏯᎢᏎᏍᏗ, ᎾᏍᎩ ᎠᏍᎦᏯ ᎣᏍᏛ ᎤᏓᏅᏓᏗᏍᏗ ᎨᏎᏍᏗ ᏚᎸᏫᏍᏓᏁᎲᎢ, ᎾᏍᎩᏰᏃ ᎤᏩᎨᏫᏌᏘ ᏂᎨᏒᎾ ᎠᏛᎩᏍᎩ, ᏧᎸᏫᏍᏓᏁᎯᏍᎩᏂ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ.


text:
ᎣᏍᏛ ᏗᏁᎶᏙᏗ ᎨᏒ ᎠᎴ ᎦᏓᎭ ᏂᎨᏒᎾ ᎠᎦᏔᎲ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨᎢ, ᎯᎠ ᏄᏍᏗ, ᏗᏩᏛᎯᏓᏍᏗᏱ ᏧᎾᏓᏂᏯᏛ ᎠᎴ ᏧᏃᏑᎶᏨᎯ ᎤᏲ ᏄᎾᏛᎾᏕᎬᎢ, ᎠᎴ ᎤᎵᏍᏆᏂᎪᏙᏗᏱ ᎤᏩᏒ ᏄᏚᏯᏍᏛᎾ ᎢᏳᎵᏍᏙᏗᏱ ᎡᎶᎯ ᎠᏁᎯ ᏄᎾᏍᏛ ᎢᏳᎵᏍᏙᏗᏱ ᏂᎨᏒᎾ.


text:
ᏰᏥᎸᏉᏔᏅᏃ ᏧᏬᏚᎯ ᏧᏄᏩᎢ, ᎠᎴ ᎯᎠ ᏱᏁᏥᏪᏎᎸ, ᎠᏂ ᎣᏍᏛ ᎨᏒ ᎯᎲᎦ, ᎤᏲᏃ ᎢᏳᏛᎿᏕᎩ ᎯᎠ ᏱᏁᏥᏪᏎᎸ, ᎾᎿ Ꮎ ᎯᏙᎨᏍᏗ, ᎠᎴ ᎠᏂ ᎯᎲᎦ ᎯᏆᎳᏏᏗᏱ ᎠᎩᏍᎩᎸ ᎭᏫᏂᏗᏢ;


text:
ᎢᏣᏛᎬᎦ ᎢᏨᎨᏳᎢ ᎢᏓᎵᏅᏟ, ᏝᏍᎪ ᎤᏁᎳᏅᎯ ᏱᏚᏑᏰᏒ ᎤᏲ ᎢᏳᎾᏛᎿᏕᎩ ᎡᎶᎯ ᎠᏁᎯ, ᎤᏁᎿᎢᏳ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏙᎵᎦ ᎤᏤᎵᎪᎯ ᎾᏍᎩ ᏧᏚᎢᏍᏓᏁᎸᎯ ᏥᎩ ᎬᏩᎨᏳᎯ?


text:
ᎯᎠᏰᏃ ᎢᏳᏪᏛ ᏥᎩ, "ᏞᏍᏗ ᏣᏓᏲᏁᎸᎩ," ᎾᏍᏉ ᎯᎠ ᎢᏳᏪᏛ ᎢᎩ, "ᏞᏍᏗ ᏣᏓᎸᎩ;" ᎾᏍᎩᏃ ᎢᏳᏃ ᏂᏣᏓᏲᏁᎸᎾ ᏱᎩ, ᎠᏎᏃ ᏱᏣᏓᎸ, ᎿᏉ ᏗᎧᎿᏩᏛᏍᏗ ᎯᏲᏍᏗᏍᎩ ᏄᎵᏍᏔᏅ.


text:
ᎩᎶᏃ ᏂᎯ ᎢᏣᏓᏡᎬ ᎯᎠ ᏱᏂᏑᏪᏎᎸ; ᏅᏩᏙᎯᏯᏛ ᏥᏤᎾ, ᎢᏥᎦᎾᏬᏒᎯ ᎠᎴ ᏗᏦᎸᏒᎯ ᎨᏎᏍᏗ; ᏂᏗᏥᏁᎲᎾᏃ ᎢᎨᏎᏍᏗ ᎠᏰᎸ ᎤᎵᏍᏕᎸᏙᏗ ᎨᏒᎢ; ᎦᏙ ᎬᏙᏗ ᎾᏍᎩ?


text:
ᎤᏙᎯᏳᎯ ᎩᎶ ᎯᎠ ᏱᏅᎦᏫ, ᏂᎯ ᏦᎯᏳᎭ, ᎠᏴᏃ ᏓᎩᎸᏫᏍᏓᏁᎭ; ᎬᏂᎨᏒ ᏂᏍᏋᏂᏏ ᏦᎯᏳᏒ ᏕᏣᎸᏫᏍᏓᏁᎲ ᏅᏗᏍᎬᎾ ᎨᏒᎢ, ᎠᏴᏃ ᎬᏂᎨᏒ ᏅᏓᎬᏴᏁᎵ ᎠᏉᎯᏳᏒ ᏓᎩᎸᏫᏍᏓᏁᎲ ᎬᏗᏍᎬᎢ.


text:
ᎪᏪᎸᏃ ᎤᏙᎯᏳᏁᎢ ᎯᎠ ᏥᏂᎦᏪᎭ; "ᎡᏆᎭᎻ ᎤᏬᎯᏳᏅᎩ ᎤᏁᎸᏅᎯ, ᎾᏍᎩᏃ ᏚᏳᎪᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎤᏠᏱ ᎠᏥᏰᎸᎾᏁᎸᎩ." ᎾᏍᎩᏃ ᎤᏁᎳᏅᎯ ᎤᎾᎵᎢ ᎠᎪᏎᎲᎩ.


text:
ᎠᎴ ᎦᏃᎦ ᎠᏥᎸ ᎾᏍᎩᏯᎢ ᎠᎴ ᎡᎶᎯ ᎠᎧᎵᎢ ᏂᏚᏳᎪᏛᎾ ᎨᏒ ᎾᏍᎩᏯ. ᎾᏍᎩᏯ ᏄᏍᏗ ᎦᏃᎦ ᎤᏓᏑᏴ ᎢᎦᏙᏢᏒᎢ, ᎾᏍᎩ ᎦᏓᎭ ᎢᎬᏁᎯ ᏂᎬ ᎠᏰᎸᎢ, ᎠᎴ ᎠᏥᏍᏢᏍᎩ ᎠᎢᏒ ᎠᏁᎳᏅᎯ ᎨᏒᎢ, ᎠᎴ ᏨᏍᎩᏃᎢ ᎤᏓᏳᏓᎴᏅᎯ ᎠᏥᏥᏍᏝᏫᏍᏗᏍᎩ.


text:
ᎢᏓᎵᏅᏟ, ᏥᎪ ᏒᎦᏔ-ᎢᏳᏍᏗ ᏡᎬ ᏰᎵᏉ ᏯᎾᏓᏛᎦ ᎣᎵᏩ ᏡᎬ ᎠᎾᏓᏛᏍᎩ, ᎠᎴ ᏥᎪ ᏖᎸᎳᏗᎯ ᏒᎦᎳ-ᎢᏳᏍᏗ ᏯᎾᏓᏛᎦ? ᎾᏍᏉᏍᎩᏂ ᎥᏝ ᏰᎵ ᏌᏉ ᎦᏄᎪᎬ ᏴᏛᎦᏄᎪᎢ ᎠᎹ ᎤᎶᏥᏛ ᎠᎴ ᎠᎹ ᎤᎶᏥᏛ ᏂᎨᏒᎾ.


text:
ᎦᎪ ᏂᎯ ᏂᏣᏛᏅᎢ ᎤᏓᏑᏯ ᎠᏏᎾᏌᏂ ᎠᎴ ᎠᎦᏔᏂᎢ? ᎾᏍᎩ ᏫᎦᎾᏄᎪᏩ ᏕᎤᎸᏫᏍᏓᏁᎲᎢ ᏫᎬᏙᏓ ᎣᏏᏳ ᎾᏛᏁᎲᎢ, ᎠᎴ ᏫᎬᏙᏓ ᎠᏏᎾᏌᏂᏳ ᎨᏒ ᏔᎵ ᎤᏛᏕᏍᏗ ᎤᏓᏅᏘ ᎨᏒᎢ.


text:
ᎦᎸᎳᏗᏍᎩᏂ ᏅᏓᏳᏓᎴᏅᎯ ᏥᎩ ᎠᏏᎾᏌᏂᏳ ᎨᏒ ᎢᎬᏱᏱ ᎦᏓᎭ ᏂᎨᏒᎾ ᎨᏐᎢ, ᎿᏉᏃ ᎪᎯᏍᏗᏍᎩ, ᎠᎴ ᎤᏓᏅᏘ, ᎠᎴ ᎤᏬᎯᏳᎯᏍᏛ, ᎠᎴ ᎠᎧᎵᏬᎯ ᎠᏓᏙᎵᏍᏗ ᎨᏒᎢ ᎠᎴ ᎣᏍᏛ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᏄᏓᎸᏉᏛᎾ, ᎠᎴ ᎤᏠᎾᏍᏗ ᏂᎨᏒᎾ.


text:
ᎢᎦᏚᎵᎪᎢ, ᎠᏎᏃ ᎥᏝ ᏱᏥᏩᏘᏍᎪᎢ; ᏕᏣᏓᎯᎰᎢ ᎠᎴ ᎢᏤᎵᎯᏍᎪ ᎢᏥᏩᏛᏗᏱ ᎠᏎᏃ ᎥᏝ ᏱᏥᏩᏘᏍᎪᎢ; ᏕᏣᎵᎰᎢ ᎠᎴ ᏓᎿᏩ ᎢᏤᎪᎢ, ᎠᏎᏃ ᎥᏝ ᏱᏥᏩᏘᏍᎪ ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᏂᏥᏔᏲᎯᎲᎾ ᎨᏒᎢ.


text:
ᏗᏣᏓᏲᏁᎯ ᎢᏥᏍᎦᏯ ᎠᎴ ᎢᏥᎨᏴ, ᏝᏍᎪ ᏱᏥᎦᏔᎭ ᎡᎶᎯ ᎤᎾᎵᎢ ᎨᏒᎢ ᎤᏁᎳᏅᎯ ᎠᏍᎦᎩ ᎨᏒᎢ? ᎾᏍᎩᏃ ᎢᏳᏍᏗ ᎢᏳᏃ ᎩᎶ ᎡᎶᎯ ᎤᎾᎵᎢ ᎢᏳᎵᏍᏙᏗᏱ ᏯᏓᏅᏖᎭ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎠᏍᎦᎩ ᎨᏐᎢ.


text:
ᎠᏎᏃ ᎤᏟ ᎢᎦᎢ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏓᏁᎰᎢ--ᎾᏍᎩ ᎢᏳᏍᏗ ᎯᎠ ᏂᎦᏪᎭ; ᎤᏁᎳᏅᎯ ᎤᎾᏢᏉᏗ ᏓᏡᏗᏍᎪᎢ, ᎤᎾᏓᏙᎵᏍᏗᏍᎩᏂ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏓᏁᎰᎢ.


text:
ᏞᏍᏗ ᎤᏐᏅ ᏱᏗᏣᏓᏃᎮᏍᎨᏍᏗ ᎢᏓᏓᏅᏟ; ᎤᏐᏅ ᏥᎧᏃᎮᏍᎪ ᏥᎧᏁᎢᏍᏗᏍᎪ ᏗᎾᏓᏅᏟ ᎠᎴ ᏥᏕᎫᎪᏓᏁᎰ ᏗᎾᏓᏅᏟ, ᎾᏍᎩ ᎤᏐᏅ ᎧᏃᎮᏍᎪ ᎧᏁᎢᏍᏗᏍᎪ ᏗᎧᎿᏩᏛᏍᏗ ᎠᎴ ᏕᎫᎪᏓᏁᎰ ᏗᎧᎿᏩᏛᏍᏗ; ᎢᏳᏃ ᏗᎧᎿᏩᏛᏍᏗ ᏱᏚᎪᏓᏁᎭ ᎥᏝ ᏗᎧᎿᏩᏛᏍᏗ ᏘᎧᎿᏩᏕᎩ ᏱᎦᎩ ᏚᎪᏓᏁᎯᏍᎩᏂ.


text:
ᏗᏣᏤᎵ ᏓᎶᏂᎨ ᎠᏕᎸ ᎠᎴ ᎤᏁᎬᎠᏕᎸ ᏚᏯᏍᏜᏛ, ᏚᏯᏍᏜᏛᏁ ᎢᏥᏃᎮᏍᎩ ᎨᏎᏍᏗ, ᎠᎴ ᎤᏪᏰᏍᏗ ᎨᏎᏍᏗ ᎢᏥᏇᏓᎸ ᎠᏥᎸ ᏥᎦᏰᏍᎪ ᎾᏍᎩᏯᎢ. ᎢᏥᏟᏌᏅ ᏧᎬᏩᎶᏗ ᎤᎵᏍᏆᎸᏗ ᎢᎦ ᎨᏒ ᎤᎬᏩᎵ.


text:
ᎬᏂᏳᏉ ᎠᏠᏱᎭ ᎨᎦᎫᏴᏓᏁᏗ ᏧᏂᎸᏫᏍᏓᏁᎯ ᎤᏂᏍᎫᏕᏒᎯ ᏕᏥᎶᎨᏒᎢ, ᎾᏍᎩ ᏗᏥᎾᎯᏍᏓᏁᎸᎯ ᏥᎩ, ᎤᎾᎵᏍᏛᏃ ᎾᏍᎩ ᎤᏂᏍᎫᏕᏒᎯ ᏚᎵᎠᏴᎸ ᎤᎬᏫᏳᎯ ᏓᎿᏩ ᎠᏁᎩ ᎤᎾᏤᎵᎦ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏓᎵᏅᏟ ᏗᏨᏂᏗᏳ ᎨᏎᏍᏗ ᎬᏂ ᎤᎬᏫᏳᎯ ᎦᎷᏨᎭ. ᎬᏂᏳᏉ ᎤᎶᎨᏛ ᎠᎦᏘᏲ ᎦᎸᏉᏗ ᎡᎶᎯ ᎤᎾᏄᎪᏫᏒᎯ, ᎠᎴ ᎬᏂᏗᏳ ᎨᏐ ᎠᎦᏘᏲᎢ, ᎬᏂ ᎤᎦᎾᏏ ᎢᎬᏱᏱ ᎠᎴ ᎣᏂᏱ ᎤᎦᏃᏗ ᎨᏒᎢ.


text:
ᎬᏂᏳᏉ ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎢᎩᏰᎸᏐ ᏗᏅᏂᏗᏳ ᏥᎨᏐᎢ. ᎢᏣᏛᎦᏅ ᎬᏂᏗᏳ ᎨᏒ ᏦᏈ, ᎠᎴ ᎢᏥᎪᎲ ᏄᏍᏛ ᏭᏰᎢᎶᎯᏍᏗ ᎨᏒ ᎤᎬᏫᏳᎯ, ᎠᎴ ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᎤᏣᏘ ᎤᏓᏅᏘᏳ ᎨᏒ ᎠᎴ ᎤᏓᏙᎵᏣᏘᏳ ᎨᏒᎢ.


text:
ᎠᏎᏃ ᎢᏓᏓᏅᏟ, ᏭᏓᎪᎾᏛᏛᎢ, ᏞᏍᏗ ᏱᏣᏎᎵᏛᏍᎨᏍᏗ ᏱᏥᏁᎢᏍᏗᏍᎨᏍᏗ ᎦᎸᎶᎢ, ᎠᎴ ᎡᎶᎯ, ᎠᎴ ᏞᏍᏗ ᏄᏓᎴᏒᏉ ᎠᏎᎵᏙᏗ ᎨᏒᎢ; ᎠᎴ ᏞᏍᏗ ᏄᏓᎴᏒᏉ ᎠᏎᎵᏙᏗ ᎨᏒᎢ; ᎢᏣᏤᎵᏍᎩᏂ ᎥᎥ ᎢᏣᏛᏗ ᎨᏒ ᎥᎥ ᎨᏎᏍᏗ, ᎠᎴ ᎢᏣᏤᎵ ᎥᏝ ᎢᏣᏛᏗ ᎨᏒ ᎥᏝ ᎨᏎᏍᏗ; ᎾᏍᎩᏃ ᏞᏍᏗ ᏤᏧᎪᏓᏁᎸᎩ ᎢᏥᏍᎦᏅᏨᎢ.


text:
ᎩᎶ ᎢᏤᎲ ᎤᏓᏑᏰᏍᏗ ᎤᏢᎨᏍᏗ, ᏫᏓᏯᏂᏍᎨᏍᏗ ᏗᎨᎦᏗᎶᏗ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬᎢ, ᎾᏍᎩᏃ ᎠᎾᏓᏙᎵᏍᏗᏍᎨᏍᏗ ᎠᏂᏔᏲᎯᎮᏍᏗ ᎠᏥᏍᏕᎸᏗᏱ, ᎬᏩᎶᏁᏗᏍᎨᏍᏗ ᎠᏠᏁᏗ ᎠᏅᏗᏍᎨᏍᏗ ᎤᎬᏫᏳᎯ ᏚᏙᎥᎢ;


text:
ᎢᎳᏯ ᏴᏫᏉ ᎨᏒᎩ ᎠᏴ ᏂᎦᎵᏍᏓᏁᎲ ᎾᏍᎩᏯ ᎢᎬᏩᎵᏍᏓᏁᏗ ᎨᏒᎩ; ᎠᎴ ᎤᎵᏂᎩᏛ ᎤᏓᏅᏛᎩ ᎤᏓᏙᎵᏍᏔᏅᎩ ᎤᏔᏲᎸᎩ ᎤᎦᏃᏗᏱ ᏂᎨᏒᎾ; ᎰᏩᏃ ᏄᏚᎾᏅᎾ ᎨᏒᎩ ᎦᏙᎯ ᏦᎢ ᏧᏕᏘᏴᏛ ᏑᏓᎵᏃ ᎢᏯᏅᏙ ᎢᎪᎯᏛ.


text:
ᎾᏍᎩ ᎠᎦᏔᎮᏍᏗ, ᎾᏍᎩ ᎠᏍᎦᎾ ᎠᎦᏔᎲᏍᎩ ᎾᎿ ᎤᎵᏓᏍᏔᏅᎯ ᎠᎢᏒᎢ, ᎾᏍᎩ ᎠᏍᏕᎵᏍᎬ ᎫᏓᎵᏍᎬ ᎠᏓᏅᏙ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ, ᎠᎴ ᎤᏣᏘ ᎢᏳᏓᎴᎩ ᎠᏍᏚᏅᏨᎯ ᎨᏒ ᎬᏍᎦᎸᏍᎬᎢ.


text:
ᎡᏣᏑᏰᏛ ᎾᏍᎩᏯ ᎾᎦᏔᎰ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨᎢ, ᎬᏔᏅᎯ ᎤᏓᏅᎦᎸᏗ ᎨᏒ ᎠᏓᏅᏙ, ᎾᏍᎩ ᎾᎿ ᏨᏗᏓᎴᎲᏍᎦ ᎪᎯᏳᏗ ᎨᏒ ᎠᎴ ᎠᏍᏚᏟᏍᏗ ᎨᏒ ᎤᎩᎬ ᏥᏌ ᎦᎶᏁᏛ; ᎦᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎤᏣᏘ ᎢᏣᏤᎵ ᎨᏎᏍᏗ.


text:
ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎤᎦᏴᎵᎨ ᏥᏌ ᎦᎶᏁᏛ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵᎦ, ᎾᏍᎩ ᎤᏣᏘ ᎤᏓᏙᎵᏣᏘᏳ ᎨᏒ ᏥᏅᏗᎦᎵᏍᏙᏗ ᏔᎵᏁ ᏥᎩᎾᏄᎪᏫᏒ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᏥᎩᏁᎸ ᎬᏂᏛ ᎢᎩᎪᏩᏛᏗᏱ ᏅᏓᏳᏓᎴᏅᎯ ᎤᏲᎱᏒ ᏚᎴᎯᏌᏅ ᏥᏌ ᎦᎶᏁᏛ;--


text:
ᎾᏍᎩ ᎪᎯᏳᏗ ᎨᏒ ᎢᏨᏗᏍᎬ ᎤᏁᎳᏅᎯ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎬᏗ ᏤᏥᏍᏆᏂᎪᏗ ᎡᏥᏍᏕᎸᏗ ᎨᏒ ᎬᏗᏍᎩ, ᎾᏍᎩ ᎡᏥᏍᏕᎸᏗ ᎨᏒ ᏣᏛᏅᎢᏍᏗ ᎬᏂᎨᏒ ᎢᎬᏁᏗᏱ ᎤᎵᏍᏆᎸᏗ ᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎢᏦᎯᏳᏒ ᎠᎪᎵᏰᏗ ᎨᏒ ᎤᏟ ᎦᎸᏉᏗᏳ ᎡᏍᎦᏉ ᎠᏕᎸ ᏓᎶᏂᎨ ᎠᎪᎵᏰᏗ ᎨᏒ ᎾᏍᎩ ᎠᏲᎩ ᏥᎩ, ᎾᏍᏉ ᎠᏥᎸ ᎬᏔᏅᎯ ᎠᎪᎵᏰᎥᎯ ᏱᎩ, ᏱᏩᎵᏰᎢᎶᎦ ᎦᎸᏉᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎣᏍᏛ ᎠᏰᎸᏗ ᎨᏒᎢ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏒᎢ, ᏥᏌ ᎦᎶᏁᏛ ᎦᎾᏄᎪᏥᎸ ᎢᏳᎢ.


text:
ᎾᏍᎩ <n>[ᏥᏌ ᎦᎶᏁᏛ]</n> ᎡᏥᎪᎥᎯ ᏂᎨᏒᎾ ᎢᎡᏥᎨᏳᎭ; ᎠᎴ ᎾᏍᎩ ᎪᎯ ᎨᏒ ᏁᏥᎪᏩᏘᏍᎬᎾ, ᎠᏎᏃ ᎡᏦᎯᏳᎲᏍᎬᎢ ᎡᏣᎵᎮᎵᎦ ᎢᏨᏗᎭ ᎠᎵᎮᎵᏍᏗ ᎨᏒ ᎦᏃᎮᏗ ᏂᎨᏒᎾ ᎠᎴ ᎦᎸᏉᏔᏅᎯ;


text:
ᎤᏂᏲᎲᎩ ᎢᏳ ᎨᏒᎢ, ᎠᎴ ᎢᏳᎵᏍᏔᏂᏓᏍᏗ ᎨᏒ ᎦᏛᎬᎢ ᎠᏓᏅᏙ ᎦᎶᏁᏛ ᎤᏤᎵᎦ ᎾᏍᎩ ᎤᏂᏯᎥᎢ, ᎢᎬᏱ ᎦᏰᎯ ᎬᏂᎨᏒ ᏥᏂ-ᎬᏁᎮ ᎤᎩᎵᏲᎢᏍᏗᏱ ᎦᎶᏁᏛ ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏒ ᎣᏂ ᎤᎾᏄᎪᎢᏍᏗᏱ.


text:
ᎾᏍᎩ ᎬᏂᎨᏒ ᎢᎨᎬᏁᎸᎯ ᏥᎨᏎᎢ ᎤᏅᏒᏉ ᎾᎾᎵᏍᏕᎵᏍᎬᎾ ᎨᏒᎢ, ᎠᏴᏍᎩᏂ ᎨᎩᏍᏕᎵᏍᎬᎢ ᎨᎩᏃᎮᎮᎸ ᎾᏍᎩ ᎪᎯ ᎬᏂᎨᏒ ᏥᏂᎨᏨᏁᎭ ᎾᏍᎩ ᎣᏍᏛ ᎧᏃᎮᏛ ᎨᏣᎵᏥᏙᏁᎸᎯ ᏥᎩ, ᎠᏅᏗᏍᎬ ᎦᎸᏉᏗᏳ ᎠᏓᏅᏙ ᎦᎸᎳᏗ ᏅᏓᏰᏥᏅᏏᏛ; ᎾᏍᎩ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏧᎾᏚᎵᎭ ᎤᏂᎪᎵᏰᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏗᏥᏠᎦ ᏕᏥᏓᏅᏛᎢ, ᎢᏣᎵᏏᎾᎯᏍᏗᏳ ᎨᏎᏍᏗ, ᎠᎴ ᎬᎵᏍᏆᏗᏍᎩ ᎤᏚᎩ ᎢᏨᏎᏍᏗ ᎡᏥᏁᏗᏱ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏂᎯ ᎡᏥᏲᎮᏗ ᏥᎩ ᎾᎯᏳ ᏥᏌ ᎦᎶᏁᏛ ᎬᏂᎨᏒ ᎾᎬᏁᎸᎭ.


text:
ᎢᏳ ᎠᎴ ᎡᏣᏓᏙᎵᏍᏓᏁᎮᏍᏗ ᎠᎦᏴᎵᎨᎢ, ᎾᏍᎩ ᏂᏗᎦᎸᏉᏗᏍᎬᎾ ᏥᏕᎫᎪᏓᏁᎭ ᎾᏂᎥ ᎠᏂᏏᏴᏫᎭ ᏄᏍᏛ ᏚᏂᎸᏫᏍᏓᏁᎲᎢ, ᏂᎪᎯᎸ <n>[ᎠᏂ]</n> ᎢᏣᎴᏂᏙᎲᎢ ᎢᏤᏯᏔᎯ ᎨᏎᏍᏗ ᎢᏤᎲᎢ.


text:
ᎢᏥᎦᏔᎭᏰᏃ ᎪᎱᏍᏗ ᎠᏲᎩ, ᎠᏕᎸ ᎤᏁᎬ ᏯᏛᏅ ᎠᎴ ᎠᏕᎸ ᏓᎶᏂᎨ, ᎡᏣᎫᏴᏔᏅᎯ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎡᎫᏓᎴᏒᎢ ᎪᎱᏍᏗ ᎬᏙᏗ ᏂᎨᏒᎾ ᎢᏣᎴᏂᏙᎸᎢ ᏗᏥᎦᏴᎵᎨ ᏗᎨᏥᏲᎯᏎᎸᎯ ᎨᏒᎢ,


text:
ᏂᎯ ᎾᏍᎩ ᎢᏳᏩᏂᏌᏛ ᏤᏦᎯᏳᎲᏍᎦ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎤᏲᎱᏒ ᏥᏚᎴᏔᏁᎢ ᎠᎴ ᏧᏁᎴ ᎦᎸᏉᏗᏳ ᎨᏒᎢ; ᎾᏍᎩ ᎢᏦᎯᏳᏒ ᎠᎴ ᎤᏚᎩ ᎢᏨᏒ ᎤᏁᎳᏅᎯ ᎢᏗᏢ ᎢᏳᎵᏍᏙᏗᏱ.


text:
ᎾᏍᎩᏃ ᏗᏥᏅᎦᎸᏛ ᏥᎩ ᏗᏣᏓᏅᏙ ᏕᏥᎧᎾᏩᏛᏒ ᏚᏳᎪᏛ ᏥᏅᏧᎵᏍᏙᏔᏅ, <n>[ᎦᎸᏉᏗᏳ]</n> ᎠᏓᏅᏙ ᏥᏨᏔᏅ, ᏄᏠᎾᏍᏛᎾ ᎠᏓᎨᏳᏗ ᎨᏒ ᎢᏨᏙᏗᏱ ᏗᏥᎨᏳᎯᏳ ᎢᏳᎵᏍᏙᏗᏱ ᎢᏣᎵᏅᏟ, ᎤᎵᏂᎩᏛ ᏕᏣᏓᎨᏳᏎᏍᏗ ᎢᏨᏗᏍᎨᏍᏗ ᎦᏓᎭ ᏂᎨᏒᎾ ᎢᏥᎾᏫ.


text:
ᏂᎦᎥᏰᏃ ᎤᏇᏓᎵ ᎨᏒ ᎧᏃᏍᎦᏉ ᎾᏍᎩᏯᎢ, ᎠᎴ ᏂᎦᎥ ᎤᏓᎸᏉᏙᏗ ᎨᏒ ᏴᏫ, ᎧᏁᏍᎦ ᎤᏥᎸᏒ ᎾᏍᎩᏯᎢ. ᎧᏁᏍᎦ ᎧᏴᏍᎪᎢ, ᎠᎴ ᎤᏥᎸᏒᎢ ᎦᏙᎠᏍᎪᎢ, ᎧᏃᎮᏛᏍᎩᏂ ᎤᎬᏫᏳᎯ ᎤᏤᎵᎦ ᏂᎪᎯᎸ ᎡᎭ.


text:
ᏂᎯ ᎾᏍᏉ ᏗᏨᏃᏛ ᏅᏯ ᎡᏣᏁᏍᎨᎲᎯ ᎠᏓᏅᏙ ᎠᏓᏁᎸ ᎢᏰᏨᏁᎸᎯ, ᎡᏥᎸᏉᏔᏅᎯ ᎠᏥᎸᎢᏤᎶᎯ, ᎡᏣᎵᏍᎪᎸᏓᏁᏗᏱ ᎠᏥᎸ-ᎨᎳᏍᏗ ᎠᏓᏅᏙ ᎤᎬᏩᎵ ᏰᎵᏉ ᏗᎬᎠᏓᏂᎸᎢᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ, ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᏉ ᎯᎠ ᏂᎬᏅ ᎪᏪᎵᎯ--ᎬᏂᏳᏉ ᏥᎲᎦ ᏌᏯᏂ ᏄᎬᏫᏳᏒ ᎤᏅᏏᏴ ᎠᏗ ᏅᏯ ᎠᏑᏰᏛ, ᎦᎸᏉᏗ, ᎠᎴ ᎩᎶ ᎾᏍᎩ ᎪᎯᏳᎲᏍᎨᏍᏗ ᎥᏝ ᎤᏕᎰᎯᏍᏗ ᏱᎨᏎᏍᏗ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏂᎯ ᎡᏦᎢᏳᎲᏍᎩ ᏥᎩ ᎦᎸᏉᏗᏳ ᎡᏂᏰᎸᎠ; ᎾᏍᎩᏍᎩᏂ Ꮎ ᎾᏃᎯᏳᎲᏍᎬᎾ, ᎾᏍᎩ Ꮎ "ᏅᏯ ᏗᎾᏁᏍᎨᏍᎩ ᎤᏂᏲᎢᏎᎸᎯ ᏄᎬᏫᏳᏒ ᎤᏅᏏᏴ ᎠᏗ ᏄᎾᎵᏍᏓᏁᎸ;"


text:
ᎠᎴ "ᏅᏯ ᎠᏓᎿᏍᏆᎶᏍᏗᏍᎩ ᎠᎴ ᏅᏯ ᏗᏓᏙᏕᏍᏗᏍᎩ," ᎾᏍᎩ Ꮎ ᎧᏃᎮᏛ ᏥᏚᏂᎾᏍᏆᎶᏍᏗᎭ, ᎾᏃᎯᏳᎲᏍᎬᎾ ᎨᏒ ᎢᏳᏍᏗ, ᎾᏍᎩ ᎢᏳᎾᎵᏍᏓᏁᏗᏱ ᎾᏍᏉ ᏥᏕᎨᏥᎧᏁᎢ.


text:
ᏂᎯᏍᎩᏂ ᎡᏣᏑᏰᏛ ᎢᏥᏠᏱ ᎨᏒᎢ, ᎢᏥᎬᏫᏳᎯ ᎠᏥᎸ-ᎢᏤᎶᎯ, ᎡᏥᎸᏉᏔᏅᎯ ᎢᏣᏓᏤᎵᏛ ᎨᏒᎢ, ᎤᏣᏘ ᏗᏣᎬᏩᎳᏅᎯ ᏴᏫ, ᎾᏍᎩ ᏧᎵᏏᎬᏫᏥᏯᏅᏛ, ᎤᏍᏆᏂᎪᏗᏳᏃ ᎢᎦ ᎦᎸᏌᏛ ᏫᏥᎧᏅᎯ;


text:
ᎾᏍᎩ ᎢᎸᎯᏳ ᏥᎨᏒ ᎢᏣᏓᏤᎵᏛ ᏂᎨᏒᎾ ᎨᏎᎢ, ᎪᎯᏍᎩᏂ ᏥᎩ ᎢᏣᏓᏤᎵᏛ ᎤᏁᎳᏅᎯ ᏧᏤᎵ ᏂᏣᎵᏍᏔᏅ; ᎾᏍᎩ ᎥᏝ ᎡᏥᏙᎵᏨᎯ ᏱᎨᏎᎢ, ᎪᎯᏍᎩᏂ ᏥᎩ ᎡᏥᏙᎵᏨᎯ.


text:
ᎠᎴ ᎢᏣᎴᏂᏙᎲ ᎣᏍᏛ ᎨᏎᏍᏗ ᎠᏁᎲ ᏧᎾᏓᎴᏅᏛ ᏴᎾ, ᎾᏍᎩ ᎨᏣᏡᏗᏍᎬ ᎤᏲ ᏧᏂᎸᏫᏍᏓᏁᎯ ᏥᎨᏦᏎᎭ, ᎾᏍᎩ ᎣᏍᏛ ᏕᏥᎸᏫᏍᏓᏁᎲ ᎠᏂᎪᏩᏘᏍᎬ ᏱᏅᏓᎦᎵᏍᏙᏓ ᏯᏂᎸᏉᏓ ᎤᏁᎳᏅᎯ ᎾᎯᏳ ᎢᎦ ᏓᏩᏛᎯᎸᎭ.


text:
ᎾᏍᎩᏯ ᏂᏗᎨᏥᎾᏝᎥᎾ ᎢᏳᏍᏛᏁᏗ ᏂᏣᏛᏁᎮᏍᏗ, ᎥᏝᏍᏗ ᎠᏗᎾ ᏂᏕᏥᎾᏝᎥᎾ ᎨᏒ ᏱᏨᏗᏍᎨᏍᏗ ᏱᏧᏢᎥᏍᎨᏍᏗ ᎤᏲ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᏧᏅᏏᏓᏍᏗ ᎢᏳᎾᏛᏁᏗ ᏂᏣᏛᏁᎮᏍᏗ.


text:
ᎦᏙᎨᏃ ᎦᎸᏉᏙᏗ ᏂᎦᎵᏍᏗᎭ, ᎢᏳᏃ ᎤᏣᏘᏂ ᏂᏣᏛᏁᎸ ᎢᏥᏍᏛᏗᏍᎨᏍᏗ ᎡᏥᎵᎥᏂᎮᏍᏗ ᎢᏨᏂᏗᏳ ᎨᏎᏍᏗ; ᎢᏳᏍᎩᏂ ᎣᏍᏛ ᏂᏣᏛᏁᎮᏍᏗ ᎠᎴ ᎢᏥᎩᎵᏲᎨᏍᏗ ᎢᏨᏂᏗᏳ ᎨᏎᏍᏗ, ᎾᏍᎩ ᎣᏍᏛ ᎠᏰᎵ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᏓᏅᏖᏍᎬᎢ.


text:
ᎾᏍᎩ ᎤᏩᏒ ᎨᏒ ᎤᎩᏎ ᎢᏗᏍᎦᎾᎯᏳ ᎨᏒ ᎤᏩᏒ ᎠᏰᎸ ᏞᎬ ᏧᎩᎵᏲᏤᎢ, ᎾᏍᎩ ᎠᏴ ᏗᎩᏲᎱᏒᎯ ᎨᏒ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᎢᏗᏢ, ᏗᏛᏃᏛ ᎢᏳᎵᏍᏙᏗᏱ ᏚᏳᎪᏛ ᎢᏗᏢ ᎨᏒᎢ; ᎾᏍᎩ ᎠᏥᎵᎥᏂᎸᎢ ᎢᏣᏗᏫᏍᏗᎭ.


text:
ᎾᏍᏉᏃ ᏂᎯ ᎢᏥᎨᏴ ᏗᏦᎯᏳᎯᏳ ᎨᏎᏍᏗ ᏗᎨᏥᏰᎯ, ᎾᏍᎩ ᎢᏳᏃ ᎩᎶ ᎧᏃᎮᏛ ᏂᏓᏂᎧᎿᏩᏕᎬᎾ ᏱᎩ, ᎾᏍᎩ ᎾᏍᏉ ᎧᏃᎮᏛ ᎬᏗ ᏂᎨᏒᎾ ᏱᎨᏥᏎᎪᎩᏍᏓ <n>[ᎠᏂᎪᏩᏘᏍᎬ]</n> ᏄᏍᏛ ᎢᏣᎴᏂᏙᎲ ᎢᏥᎨᏴ,


text:
ᏂᎯ ᎾᏍᏉ ᎢᏥᏍᎦᏯ ᎢᏣᏁᎳᏛᎭ ᏗᏣᏓᎵᎢ ᎾᏍᎩᏯ ᎢᏯᏛᏁᏗ ᎨᏒ ᎢᏥᎦᏔᎲᎢ, ᎠᎴ ᏕᏥᎸᏉᏕᏍᏗ ᎾᏍᎩᏯ ᏗᎦᎸᏉᏙᏗ ᏥᎩ ᏗᏂᏩᎾᎦᎳᎢ, ᎠᎴ ᏗᎦᎸᏉᏙᏗ ᏥᎩ ᎠᏖᏆᎶᎯ ᎣᏤᎵ ᎨᏒ ᎬᏩᎦᏗᏯ ᎬᏂᏛ ᎡᏥᏁᎸᎢ; ᎾᏍᎩᏃ ᏞᏍᏗ ᎢᏣᏓᏙᎵᏍᏗᏍᎬ ᎪᎱᏍᏗ ᎠᏲᏍᏙᏗᏍᎩ ᏱᎨᏎᏍᏗ.


text:
ᏞᏍᏗ ᎤᏲ ᏁᏨᏁᎲ ᏱᏣᏞᎨᏍᏗ ᎤᏲ ᏱᏂᏣᏓᏛᏁᎮᏍᏗ, ᎠᎴ ᎦᏰᏥᏐᏢᏔᏅ ᏞᏍᏗ ᏱᏣᏞᎨᏍᏗ ᏱᎨᏣᏓᏐᏢᏗᏍᎨᏍᏗ, ᎣᏍᏛᏉᏍᏗᏂ ᎨᏥᏁᏤᎮᏍᏗ; ᎢᏥᎦᏔᎭᏰᏃ ᎾᏍᎩ ᎢᏣᏛᏁᏗᏱ ᎡᏥᏯᏅᏛ ᎨᏒᎢ, ᎾᏍᎩ ᎢᏣᏤᎵ ᎢᏳᎵᏍᏙᏗᏱ ᎣᏍᏛ ᎡᏥᏁᏤᏗᏱ.


text:
ᎡᏥᎸᏉᏗᏍᎨᏍᏗᏍᎩᏂ ᏱᎰᏩ ᎤᏁᎳᏅᎯ ᏙᏗᏣᏓᏅᏛᎢ. ᎠᎴ ᏯᏃᏉ ᎢᏨᏛᏅᎢᏍᏕᏍᏗ ᎾᏂᎥ ᎩᎶ ᎨᏣᏛᏛᎲᏍᎩ ᎤᏚᎩ ᎢᏨᏒ ᎤᎬᏩᎵ, ᏗᏥᏃᏁᏗᏱ ᎤᏓᏅᏘ ᎠᎴ ᎤᎾᏰᎯᏍᏗ ᎨᏒ ᎢᏨᏙᏗᏱ.


text:
ᎠᎴ ᎢᏥᏍᏆᏂᎪᏕᏍᏗ ᎣᏍᏛ ᏗᎫᎪᏙᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏐᏅ ᏥᎨᏥᏃᎮᎭ ᎤᏲ ᏧᏂᎸᏫᏍᏓᏁᎯ ᏥᎨᏦᏎᎭ, ᏯᎾᏕᎰᎯ ᎾᏍᎩ ᎦᏰᎪᎩ ᎨᏥᏃᎮᏍᎩ ᎣᏍᏛ ᎢᏣᎴᏂᏙᎲ ᎦᎶᏁᏛ ᏕᏥᎧᎿᏩᏗᏒᎢ ᎠᏂᏁᎢᏍᏗᏍᎩ.


text:
ᎦᎶᏁᏛᏰᏃ ᎾᏍᏉ ᏌᏉ ᏄᎩᎵᏲᏤ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒ ᎤᏍᏛᏕᎢ, ᎠᏍᎦᎾ ᏂᎨᏒᎾ ᎠᏂᏍᎦᎾ ᏚᎩᎵᏲᏤᎴᎢ, ᎾᏍᎩ ᎤᏁᎳᏅᎯᏱ ᏫᏗᎦᏘᏃᎯᏍᏗᏱ; ᎠᏥᎴᎢ ᎤᏇᏓᎵ ᎨᏒᎢ, ᎠᏎᏃ ᎠᏓᏅᏙ ᎤᏩᏂᏕᎢ.


text:
ᎾᏍᎩ ᎢᎸᎯᏳ ᏄᏃᎯᏳᏒᎾ ᏥᎨᏎᎢ, ᎾᎯᏳ ᎤᏁᎳᏅᎯ ᎬᏂᏗᏳ ᎨᏒ ᏣᎦᏘᏰᎢ, ᏃᏯ ᎾᎯᏳ ᏤᎥᎢ, ᏣᏛᏅᎢᏍᏗᏍᎨ ᏥᏳ, ᎾᎿ ᎢᎸᏍᎩ ᎾᏍᎩ ᏧᏁᎳᏉ ᎢᏯᏂᏛ ᏥᎨᏥᏍᏕᎸᎮᎢ, ᎠᎹ ᏥᎨᏥᏍᏕᎸᏔᏁᎢ;


text:
ᎾᏍᎩᏯ ᎾᏍᏉ ᏗᏓᏬᏍᏗ ᎨᏒ ᎪᎯ ᎨᏒ ᎢᎩᏍᏕᎵᎭ; ᎥᏝ ᎢᏴᏛ ᎾᎬᏁᎲ ᎠᏰᎸ ᎦᏓᎭ ᎨᏒᎢ, ᎧᏁᏤᏗᏍᎩᏂ ᎤᏁᎳᏅᎯ ᎬᏙᏗ ᎣᏍᏛ ᎠᏓᏅᏖᏗ ᎨᏒ ᎢᎩᏍᏕᎵᎭ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏚᎴᎯᏌᏅ ᏥᏌ ᎦᎶᏁᏛ,


text:
ᎦᎶᏁᏛᏃ ᎤᏇᏓᎵ ᎨᏒ ᎢᎩᎩᎵᏲᏤᎸᎯ ᏥᎩ, ᏂᎯ ᎾᏍᏉ ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏓᏅᏙ ᎢᏣᎵᏍᎦᏍᏙᏙᏗ ᏂᏨᎦ; ᎾᏍᎩᏰᏃ Ꮎ ᎤᏇᏓᎵ ᎨᏒ ᎤᎩᎵᏲᏨᎯ ᏥᎨᏐᎢ ᏚᏲᏐ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒᎢ,


text:
ᏰᎵᏉᏰᏃ ᏱᎩᏰᎸᎭ ᎦᏳᎳ ᎢᎦᎴᏂᏙᎸ ᏕᎩᎸᏫᏍᏓᏁᎸ ᎣᏏᏳ ᎤᏂᏰᎸᏗ ᎨᏒ ᎾᏂᎦᏔᎾᎥᎾ, ᎾᎯᏳ ᏥᏕᏙᎲ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏚᎸᏗ ᎨᏒᎢ, ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎬᏓᏴᏍᏕᏍᏗᏍᎩ ᎨᏒᎢ, ᎠᎴ ᎠᎵᏍᎦᎾᏩᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏓᎾᏗᏔᏍᎬ ᎨᎳᏗᏓᏍᏗ ᎨᏒᎢ, ᎠᎴ ᏂᏚᏳᎪᏛᎾ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᏓᏙᎵᏍᏓᏁᏗ ᎨᏒᎢ;


text:
ᎾᏍᎩᏰᏃ ᎢᏳᏍᏗ ᎣᏍᏛ ᎧᏃᎮᏛ ᏧᏂᏲᎱᏒᎯ ᎾᏍᏉ ᎨᎦᎵᏥᏙᏁᎴᎢ, ᏗᎨᎫᎪᏓᏁᏗᏱ ᎤᏇᏓᎵ ᎨᏒ ᎾᏍᎩᏯ ᏴᏫ ᏧᏄᎪᏙᏗ ᎨᏒᎢ, ᎤᏁᎳᏅᎯᏍᎩᏂ ᏧᏭᎪᏙᏗ ᎨᏒ ᏗᏅᏃᏛ ᎢᏳᎵᏍᏙᏗᏱ ᏧᎾᏓᏛᏙᎩᎯ ᎨᏒᎢ.


text:
ᎢᏳᏃ ᎩᎶ ᎦᏬᎢᏍᎨᏍᏗ, ᎾᏍᎩᏯ ᎤᏁᎳᏅᎯ ᏄᏪᏒ ᎦᏬᏂᏍᎨᏍᏗ. ᎢᏳᏃ ᎩᎶ ᏓᏯᏙᎮᎮᏍᏗ, ᎾᏍᎩ ᏰᎵ ᎢᎬᏩᏛᏁᏗ ᎨᏒ ᎤᎵᏍᎪᎸᏓᏁᎲ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎾᏛᏁᎮᏍᏗ; ᎾᏍᎩᏃ ᎤᏁᎳᏅᎯ ᏂᎦᎥ ᏕᏥᎸᏫᏍᏓᏁᎲ ᎠᏥᎸᏉᏗᏳ ᎢᎬᏩᎵᏍᏙᏗ ᏱᎩ ᏥᏌ ᎦᎶᏁᏛ ᎨᏒ ᏱᏅᏗᎦᎵᏍᏙᏗᎭ; ᎾᏍᎩ ᎤᏤᎵᎦ ᎦᎸᏉᏗᏳ ᎨᏒ ᎠᎴ ᎤᎬᏫᏳᎯ ᎨᏒ ᏂᎪᎯᎸ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ. ᎡᎺᏅ.


text:
ᎢᏣᎵᎮᎵᎨᏍᏗᏍᎩᏂ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎦᎶᏁᏛ ᎤᎩᎵᏲᏨ ᎢᏤᎳᏗᏍᏗᏍᎬᎢ, ᎾᏍᎩᏃ ᎤᏖᎵ ᎦᎸᏉᏗᏳ ᎨᏒ ᎬᏂᎨᏒ ᎢᎬᏁᎸᎯ ᎨᏎᏍᏗ ᏂᎯ ᎾᏍᏉ ᎤᏣᏔᏅᎯ ᎨᏣᎵᎮᎵᏍᏗ ᎨᏎᏍᏗ.


text:
ᎢᏳᏃ ᎦᏰᏥᏐᏢᏕᏍᏗ ᎦᎶᏁᏛ ᏚᏙᎥ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ ᎣᏏᏳ ᎢᏣᎵᏍᏓᏁᏗ ᎨᏎᏍᏗ, ᎠᏓᏅᏙᏰᏃ ᎦᎸᏉᏗᏳ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎢᏤᎳᏗᏙᎭ; ᎾᏍᎩ Ꮎ ᎨᏒ ᎦᎬᏩᏐᏢᏗ, ᏂᎯᏍᎩᏂ ᎨᏒ ᎠᏥᎸᏉᏗᎭ.


text:
ᎠᏗᎾ ᏞᏍᏗ ᎩᎶ ᏂᎯ ᏂᏣᏛᏅ ᏳᎩᎵᏲᏤᏍᏗ ᏴᏫ ᎤᎸᎢ ᏳᏍᏛᏗᏍᎨᏍᏗ, ᎠᎴ ᎤᏃᏍᎩᏒᎢ, ᎠᎴ ᎤᏲ ᏚᎸᏫᏍᏓᏁᎸᎢ, ᎠᎴ ᎤᎵᏌᎳᏁᎯ ᎨᏒ ᏅᏩᎾᏓᎴ ᏧᏂᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ.


text:
ᎤᏍᏆᎸᎲᏰᏃ ᎾᏍᎩ ᏗᎫᎪᏙᏘ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸ ᎤᏓᎴᏅᏗᏱ; ᎢᏳᏃ ᎠᏴ ᏰᎦᎴᏅᏔᏅ ᎦᏙ ᎤᏍᏗ ᏭᎾᎵᏱᎶᎯᏍᏗ ᎨᏎᏍᏗ ᎾᏍᎩ Ꮎ ᏄᏃᎯᏳᏒᎾ ᎣᏍᏛ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ, ᎾᏍᎩ Ꮎ ᏄᏍᏛ ᎠᏓᏅᏖᏍᎬ ᎤᏁᎳᏅᎯ ᎠᏂᎩᎵᏲᎩ, ᏫᏓᏂᏲᎯᏏ ᏧᏍᏆᏂᎪᏙᏗᏱ ᏧᎾᏓᏅᏙ, ᎣᏍᏛ ᏕᎤᏂᎸᏫᏍᏓᏁᎲᎢ, ᎾᏍᎩᏯ ᏄᏓᎵᏓᏍᏛᎾ ᎤᏬᏢᏅᏅᎯ ᏥᏓᏂᏲᎯᏎᎰᎢ.


text:
ᏕᏤᎶᎮᏍᏗ ᎤᎾᏓᏡᎬ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ ᏥᎨᏣᏓᏑᏯ, ᏕᏥᎦᏘᏰᏍᏗ, ᎥᏞᏍᏗ ᎣᏏᏳ ᏂᏥᏰᎸᏒᎾ ᎣᏏᏳᏍᎩᏂ ᎢᏥᏰᎸᎯ ᎨᏎᏍᏗ, ᎠᎴ ᎥᏞᏍᏗ ᏧᎬᏩᎶᏗ ᎢᏥᎬᎥᏍᎬ ᏱᏅᏗᎦᎵᏍᏙᏍᎨᏍᏗ, ᎣᏏᏳᏍᎩᏂ ᎢᏥᏰᎸᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ;


text:
ᏂᎯ ᎾᏍᏉ ᎢᏥᏫᏅ ᏕᏦᎯᏳᏎᏍᏗ ᏧᎾᏛᏐᏅᎯ; ᎥᎥ, ᏂᏥᎥᎢ ᏕᏣᏓᏙᎯᏳᏎᏍᏗ, ᎠᎴ ᎢᏣᏄᏬᏍᏕᏍᏗ ᎤᏓᏙᎵᏍᏗ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒᎢ; ᎤᏁᎳᏅᎯᏰᏃ ᎤᎾᏢᏉᏗ ᏓᏡᏗᏍᎪᎢ, ᎤᎾᏓᏙᎵᏍᏗᏍᎩᏂ ᎬᏩᎦᏗᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᏓᎵᏍᎪᎸᏓᏁᎰᎢ.


text:
ᎠᏗᎾ ᎤᏁᎳᏅᎯ ᎤᏣᏔᏅᎯ ᎤᏓᏙᎵᏣᏘ ᎾᏍᎩ ᎢᎩᏯᏅᏛ ᏥᎩ ᎤᏤᎵ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎦᎸᏉᏗᏳ ᎨᏒ ᏫᎩᎷᎯᏍᏗᏱ, ᏥᏌ ᎦᎶᏁᏛ ᎠᎬᏗᏍᎬᎢ, ᎾᏍᎩ ᏞᎦ ᎢᏥᎩᎵᏲᏨᎯ ᎨᏎᏍᏗ, ᏂᏥᎪᎸᎾ ᏫᏂᏨᎦ, ᎠᎴ ᏫᏣᎵᏂᎪᎯᏍᏓ, ᎠᎴ ᎢᏣᎵᏂᎩᏛ ᏫᏂᏨᎦ, ᎠᎴ ᎦᏰᏥᏖᎸᏗ ᏂᎨᏒᎾ ᏫᏂᏨᎦ.


text:
ᎢᏨᏲᏪᎳᏏ ᎦᏲᎵ ᏏᎷᏪᏂ ᎤᏅᏍᏗ ᎾᏍᎩ ᎦᎳᏏᏛᏗ ᏂᎨᏒᎾ ᎢᏣᎵᏅᏟ ᎦᏓᏅᏖᏍᎬᎢ, ᎢᏒᏔᏲᏎᎭ, ᎠᎴ ᎬᏂᎨᏒ ᏂᏨᏴᏁᎭ ᎾᏍᎩ ᎯᎠ ᎾᎿ ᏥᏕᏥᏙᎦ ᎤᏙᎯᏳᏒ ᎤᏁᎳᏅᎯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ.


text:
ᎠᏴ ᏌᏩᏂ ᏈᏓ, ᎠᎸᎾᏝᎢ ᎠᎴ ᎠᎩᏅᏏᏛ ᏥᏌ ᎦᎶᏁᏛ, ᎦᏥᏲᏪᎳᏏ ᎾᏍᎩ Ꮎ ᎨᏥᏁᎸᎯ ᏥᎩ ᎣᎩᏁᎸ ᎾᏍᎩᏯᎢ, ᎦᎸᏉᏗᏳ ᎪᎯᏳᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᏁ ᎤᏓᏅᏘᏳ ᎨᏒ ᎢᎦᏁᎳᏅᎯ ᎠᎴ ᎢᎩᏍᏕᎵᏍᎩ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎾᏍᎩᏯ ᎤᏤᎵ ᎤᎵᏂᎩᏗ ᎨᏒ ᎤᏩᏔᏅᎢ ᎢᎩᏁᎸᎯ ᏥᎩ ᏄᏓᎴᏒ ᎪᎱᏍᏗ ᏕᏛᏅ ᎤᎬᏩᎵ ᎠᎴ ᎤᏁᎳᏅᎯ ᎦᎾᏰᎯᏍᏗ ᎨᏒ ᎤᎬᏩᎵ, ᏅᏓᏳᏓᎴᏅᎯ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎾᏍᎩ Ꮎ ᎢᎩᏯᏅᏛ ᏥᎩ ᎬᏔᏅᎯ ᎦᎸᏉᏗᏳ ᎨᏒ ᎠᎴ ᏚᏳᎪᏛ ᎢᏍᏛᏁᏗ ᎨᏒᎢ.


text:
ᎤᏍᎩ ᎾᎿ ᏭᏓᎪᎾᏛᏔᏅᎯ ᎡᏉᎯᏳ ᎠᎴ ᎦᎸᏉᏗᏳ ᎡᎩᏚᎢᏍᏓᏁᎸᎯ ᏥᎩ, ᎾᏍᎩ ᎯᎠ ᏕᏨᏗᏍᎬ ᎨᏣᏠᏯ ᏍᏙᏗ ᏱᏂᎦᎵᏍᏓ ᎤᏁᎳᏅᎯ ᏄᏍᏛᎢ, ᎡᏣᏗᏫᏎᎸᎯ ᎨᏒ ᎤᏲᎢ ᎡᎶᎯ ᏤᎭ ᎠᏚᎸᏗ ᎨᏒ ᏨᏗᏓᎴᎲᏍᎦ.


text:
ᎠᎦᏙᎥᎯᏍᏗᏃ ᎨᏒ ᏔᎵ ᎢᏨᏗᏍᎨᏍᏗ ᎠᎵᏏᎾᎯᏍᏙᏗ ᎨᏒᎢ; ᎠᎵᏏᎾᎯᏍᏙᏗᏃ ᎨᏒ ᏔᎵᎢᏨᏗᏍᎨᏍᏗ ᏗᏨᏂᏗᏳ ᎨᏒᎢ; ᏗᏣᏂᏗᏳᏃ ᎨᏒ ᏔᎵ ᎢᏨᏗᏍᎨᏍᏗ ᎤᏁᎳᏅᎯ ᎦᎾᏰᎯᏍᏗ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏓᎵᏅᏟ ᎤᏟ ᎢᎦᎢ ᎢᏣᏟᏂᎬᏁᎮᏍᏗ ᏄᏜᏏᏛᏒᎾ ᎢᏨᏁᏗᏱ ᎡᏥᏯᏅᎲ ᎠᎴ ᎡᏣᏑᏰᏒᎢ; ᎢᏳᏰᏃ ᎯᎠ ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᏱᏂᏣᏛᏁᎭ, ᎥᏝ ᎢᎸᎯᏳ ᏱᏙᎨᏥᏅᎩ.


text:
ᎥᏝᏰᏃ ᎠᎵᏏᎾᎯᏍᏔᏅᎯ ᎠᏎᏉ ᎦᏬᏂᎯᏍᏗ ᎨᏒ ᏲᎩᏍᏓᏩᏛᏎ ᎬᏂᎨᏒ ᏂᏨᏴᏁᎸ ᎤᎵᏂᎩᏗ ᎨᏒ ᎠᎴ ᎤᎷᎯᏍᏗ ᎨᏒ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ; ᏱᎩᎪᎲᎯᏍᎩᏂ ᎨᏒᎩ ᎦᎸᏉᏗᏳ ᎨᏒ ᎤᏤᎵᎦ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᎠᎦᏴᎵᎨ ᎤᎵᏍᎪᎸᏓᏁᎸᎩ ᎦᎸᏉᏗᏳ ᎨᏒ ᎠᎴ ᎢᎦᏚᎸᏌᏛᎢ, ᎾᎯᏳ ᎧᏁᎬ ᏧᎷᏤᎸ ᎤᏣᏘ ᎦᎸᏉᏗᏳ ᎢᎦ-ᏚᎸᏌᏛ ᏅᏓᏳᏓᎴᎤᎯ, <n>[ᎯᎠ ᏥᏂᎦᏪᏍᎬᎩ,]</n> ᎯᎠ ᏥᎨᏳᎢ ᎠᏇᏥ, ᎾᏍᎩ ᎣᏏᏳ ᏥᏰᎸᎢ ᏥᎩ.


text:
ᎠᎴ ᎾᏍᏉ ᎤᏟ ᎢᎦᎢ ᏄᏜᏏᏛᏒᎾ ᎧᏃᎮᏛ ᎠᏙᎴᎰᏒᎯ ᎢᎩᎭ, ᎾᏍᎩ ᎣᏏᏳ ᏱᏂᏣᏛᎦ ᏱᏣᎦᏌᏯᏍᏔᏅ ᎾᏍᎩᏯ ᎢᎦ-ᏚᎸᏌᏛ ᎤᎵᏏᎬ ᏨᎦᏌᏯᏍᏗᏍᎪᎢ, ᎬᏂ ᎢᎦ ᏓᎦᏙᎩ, ᎠᎴ ᏑᎾᎴ ᎡᎯ ᏃᏈᏏ ᏓᎧᎸᎩ ᏗᏥᎾᏫᏱ;


text:
ᎠᏎᏃ ᎤᎾᏠᎾᏍᏗ ᎠᎾᏙᎴᎰᏍᎩ ᎢᎬᏩᎾᏓᏑᏰ ᏴᏫ, ᎾᏍᎩᏯ ᎤᎾᏠᎾᏍᏗ ᏗᎾᏕᏲᎲᏍᎩ ᎨᏣᏓᏑᏴᏗ ᏥᎩ, ᎾᏍᎩ ᎤᏕᎵᏛ ᎤᏂᏴᏔᏂᎯᏍᏗ ᎨᏎᏍᏗ ᎤᎾᏓᏤᎵᏛ ᎨᏒ ᎠᏓᏛᏗᏍᎩ, ᎾᏍᎩ ᎠᎾᏓᏱᎮᏍᏗ ᎤᎬᏫᏳᎯ ᎤᎾᎫᏴᏛ, ᎠᎴ ᎤᏅᏒ ᎢᏳᏅᏂᏌᏛ ᎤᏂᎷᏤᏗ ᎨᏎᏍᏗ ᏞᎩᏳ ᎤᏂᏛᏗᏍᎩ.


text:
ᎠᎴ ᏧᎬᏩᎶᏗ ᎤᏂᎬᎥᏍᎬ ᎢᏳᏍᏗ, ᎠᎴ ᎦᎶᏄᎮᏛ ᎠᏅᏗᏍᎬ ᎠᏂᏬᏂᏍᎬ ᎦᏃᏙᏗ ᏓᎨᏥᏰᎸᏥ; ᎾᏍᎩ ᏧᎾᏚᎪᏓᏁᏗ ᎨᏒ ᎡᏘ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎥᏝ ᏯᎵᎾᎯᏍᏗᎭ, ᎠᎴ ᎤᏂᏛᏗᏍᎩ ᎥᏝ ᏱᎦᎸᏍᎦ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᏂᏚᎨᏳᏅᎾ ᏥᎨᏎ ᏗᏂᎧᎾᏩᏗᏙᎯ ᎤᏂᏍᎦᏅᏨᎯ, ᏨᏍᎩᏃᏉᏍᎩᏂ ᏥᏫᏚᏓᎢᏅᏎᎢ, ᎠᎴ ᏥᏚᏲᏎ ᏧᏓᏕᏒᏛ ᏗᎨᎦᎸᏍᏙᏗᏱ ᎤᎵᏏᎬ ᎨᏥᏍᏆᏂᎪᏙᏗᏱ ᏗᎨᎫᎪᏓᏁᏗ ᎨᏒ ᎢᏳᎢ,


text:
ᎠᎴ ᏄᎨᏳᏅᎾ ᏥᎨᏎ ᎡᏘ ᎡᎶᎯ ᏥᎨᏎᎢ, ᏃᏯᏍᎩᏂ ᏧᏁᎳ ᏧᏛᏕᎢ ᎨᏒ ᎾᏍᎩ ᎠᎵᏥᏙᎲᏍᎩ ᏚᏳᎪᏛ ᏗᎧᎾᏩᏗᏙᎯ ᏥᎨᏎᎢ, ᎠᎴ ᏥᏚᏃᎱᎪᏔᏁ ᎡᎶᎯ ᎠᏂᏍᎦᎾ ᎠᏁᎲᎢ,


text:
(ᎾᏍᎩᏰᏃ ᎤᏓᏅᏘ ᎠᏍᎦᏯ ᎠᏁᎲ ᏤᎮᎢ, ᎠᎪᏩᏘᏍᎬ ᎠᎴ ᎠᏛᎩᏍᎬ <n>[ᏄᏍᏛ ᏚᏂᎸᏫᏍᏓᏁᎲᎢ]</n> ᎤᏓᏅᏘ ᎤᏓᏅᏙ ᏂᏚᎩᏨᏂᏒ ᎤᏕᏯᏙᏗ ᎤᏓᏅᏖ ᏅᏗᎦᎵᏍᏙᏗᏍᎨ ᏂᏚᏳᎪᏛᎾ ᏚᏂᎸᏫᏍᏓᏁᎲᎢ,)


text:
ᎠᎴ ᎾᏍᎩ ᎰᎤᎬᏫᏳᎭ <n>[ᎨᏂᎩᎵᏲᎢᏍᏙᏗ ᎨᏎᏍᏗ]</n> ᎤᏇᏓᎵ ᎠᏂᏍᏓᏩᏕᎩ ᎤᏂᎬᎥᏍᎬ ᎦᏓᎭ ᎨᏒᎢ, ᎠᎴ ᏗᏂᏍᎦᎩ ᏄᏂᎬᏫᏳᏌᏕᎩ. ᎤᏂᏍᎦᎢᏍᏗ, ᎤᏅᏒ ᎠᎾᏓᏅᏖᏍᎬ ᎤᏂᎸᏉᏗ; ᎥᏝ ᏯᏂᏍᎦᎢᎭ ᏗᎬᏩᏂᏐᏢᏙᏗᏱ ᎨᏥᎸᏉᏗ.


text:
ᎯᎠᏍᎩᏂ ᎾᏍᎩᏯ ᎪᎱᏍᏗᏉ ᏤᎿᎠ ᎨᎪᏢᏅᎯ ᎨᎨᎢᏍᏗᏱ ᎠᎴ ᎨᏥᏛᏙᏗᏱ, ᎾᏍᎩ ᎠᏂᏐᎢᏍᏗᏱ ᎠᎴ ᎨᏥᏛᏙᏗᏱ, ᎾᏍᎩ ᎠᏂᏐᏢᎢᏍᏗᏍᎪ ᏧᏓᎴᏅᏛ ᎾᏃᎵᎬᎾ ᎨᏒᎢ, ᎠᎴ ᏛᎾᎵᏛᏔᏂ ᎤᏅᏒ ᎤᏂᏲᎢᏳ ᎨᏒᎢ.


text:
ᎠᎴ ᏛᏂᏩᏛᎯ ᎨᎦᎫᏴᏓᏁᏗ ᏂᏚᏳᎪᏛᎾ ᏚᏂᎸᏫᏍᏓᏁᎲᎢ, ᎾᏍᎩᏯ <n>[ᎨᎦᎫᏴᏓᏁᏗ ᏥᎩ]</n> ᎣᏏᏳ ᎤᏥᏰᎸᎯ ᎢᎦ ᎨᏒ ᎣᏍᏛ ᏧᎾᎵᏍᏓᏴᏗᏱ. ᏥᏚᏓᏓᎶᎢ ᎠᎴ ᎪᎱᏍᏗ ᏧᏍᏙᎢ ᎾᏍᎩᏯᎢ, ᎣᏏᏳ ᎤᏂᏰᎸᎭ ᎤᏅᏒ ᎠᎾᏓᎵᏓᏍᏗᏍᎬᎢ, ᎾᎯᏳ ᎢᏧᎳᎭ ᎢᏣᎵᏍᏓᏴᎲᏍᎬᎢ.


text:
ᏗᏂᎦᏙᎵ ᏧᎧᎵᏨᎯ ᎠᏓᏲᏁᏗ ᎨᏒᎢ, ᎠᎴ ᏗᎬᏩᏂᏲᎯᏍᏗ ᏂᎨᏒᎾ ᎠᏍᎦᏂ ᎨᏒᎢ: ᏗᏂᎶᏄᎮᏍᎩ ᏂᏚᎾᎵᏂᎬᎬᎾ ᎦᎾᏓᏅᏛᎢ; ᏧᏂᎾᏫ ᏧᎩᏌᏛ ᎠᎬᎥᎯᏍᏗ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒᎢ; ᎠᎩᎵᏲᎢᏍᏗ ᎨᏒ ᏧᏪᏥ,


text:
ᎯᎠ ᎾᏍᎩ ᏓᏔᎴᏒ ᎠᎹ-ᏗᏢᏗᏱ ᎠᎹ ᏂᏗᎦᏁᎲᎾ, <n>[ᎠᎴ]</n> ᎤᎶᎩᎸ ᎤᏃᎴ ᏧᏃᎸᏔᏂᏙᎰᎢ, ᎾᏍᎩ Ꮎ ᎬᎾᎨ ᎤᎵᏏᎬ ᏥᎨᎦᏛᏅᎢᏍᏓᏁᎸ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ.


text:
ᎠᏂᏁᎩᏰᏃ ᎤᏣᏘ ᎠᏢᏆᏍᏗ ᎪᎱᏍᏗ ᎬᏙᏗ ᏂᎨᏒᎾ ᎠᏂᏬᏂᏍᎬᎢ, ᏓᏂᎶᏄᎮᏍᎪ ᎠᏅᏗᏍᎪ ᎤᏇᏓᎵ ᎠᏚᎸᏗ ᎨᏒᎢ, <n>[ᎠᎴ]</n> ᏃᎵᏏᎾᎯᏍᏛᎾ ᏂᏓᏍᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎤᏙᏗᏳᎯ ᏧᎾᏗᏫᏎᎸᎯ ᎾᏍᎩ Ꮎ ᎠᏏ ᎤᏓᎵᏓᏍᏗ ᎨᏒ ᎠᎾᎴᏂᏙᎯ ᏥᎩ.


text:
ᎢᏳᏰᏃ ᎤᎾᏗᏫᏎᎸᎯ ᏱᎩ ᎦᏓᎭ ᎨᏒ ᎡᎶᎯ ᎡᎯ, ᎠᏅᏗᏍᎬ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎤᎬᏫᏳᎯ ᎠᎴ ᎢᎩᏍᏕᎵᏍᎩ ᏥᏌ ᎦᎶᏁᏛ, ᏔᎵᏁᏃ ᏱᏅᏁᏒ ᎾᎿᏂ ᎠᎴ ᏱᎨᏥᏎᎪᎩᏒ, ᎤᎵᏍᏆᎸᏗ ᏄᎾᎵᏍᏓᏁᎸ ᎤᏟ ᎤᏲᎢᏳ ᎡᏍᎦᏉ ᎢᎬᏱᏱ.


text:
ᎤᏟᏰᏃ ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᏱᎨᏎᎢ ᏄᏂᎦᏙᎥᏒᎾ ᏱᎨᏎ ᏚᏳᎪᏛ ᎦᏅᏅᎢ, ᎠᏃ ᎤᏂᎦᏙᎥᏒᎯ ᎨᏒ ᏯᎾᎦᏔᎲ ᏱᏚᏂᏲᏍᎦ ᎦᎸᏉᏗᏳ ᏗᎧᎿᏩᏛᏍᏗ ᎾᏍᎩ ᏗᎨᏥᏲᎯᏎᎸᎯ.


text:
ᎠᎴ ᎯᎠ ᎢᏯᏂᏪᏍᎩ, ᎦᏙ ᎤᎵᏍᏔᏅ ᎤᎷᎯᏍᏗᏱ ᎤᏚᎢᏍᏔᏅᎢ? ᎠᏂᎦᏴᎵᎨᏰᏃ ᎬᏩᏂᎵᏅᏨᎯ ᏅᏓᎬᏩᎴᏅᏛ, ᏅᏩᏍᏗᏉ ᏂᎦᎥ ᎪᎱᏍᏗ ᏥᏄᏍᏛᏉ ᏧᏓᎴᏅᎲ ᎤᏬᏢᏅᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ.


text:
ᎠᏎᏃ ᎦᎸᎶᎢ ᎠᎴ ᎡᎶᎯ ᎪᎯ ᏥᎩ, ᎾᏍᎩᏉ ᎤᏁᏨ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏓᏍᏆᏂᎪᏗ, ᎠᏥᎸᏱ ᏭᎾᎵᏰᎢᎶᎯᏍᏗᏱ ᏓᏍᏆᏂᎪᏗ ᎬᏂ ᏗᎫᎪᏙᏗᏱ ᎢᎦ ᎨᏎᏍᏗ ᎠᎴ ᎨᏥᏛᏙᏗᏱ ᎠᏂᏍᎦᏯ ᎤᏁᎳᏅᎯ ᏂᏚᎾᏁᎶᏛᎾ.


text:
ᎠᏎᏃ ᎢᏨᎨᏳᎢ, ᎯᎠ ᎾᏍᎩ ᏑᏓᎴᎩ ᏞᏍᏗ ᏂᏥᎦᏔᎲᎾᏉ ᏱᎨᏎᏍᏗ, ᎾᏍᎩ ᏌᏉ ᎢᎦ ᎨᏒ ᎤᎬᏫᏳᎯ ᏙᏗᎧᏂᏍᎬ ᏌᏉ ᎢᏯᎦᏴᎵ ᎢᏧᏕᏘᏴᏛ ᎤᏠᏱ, ᏌᏉᏃ ᎢᏯᎦᏴᎵ ᎢᏧᏕᏘᏴᏛ ᏌᏉ ᎢᎦ ᎨᏒ ᎤᏠᏱ.


text:
ᎤᎬᏫᏳᎯ ᎥᏝ ᎤᏍᎦᏃᎵᏳ ᏱᎩ ᏄᏍᏛ ᎤᏚᎢᏍᏔᏅ ᎢᏳᏛᏁᏗᏱ, ᎾᏍᎩ ᎩᎶ ᎾᏍᎦᏃᎳ ᏣᏁᎵᎭ, ᎬᏂᏗᏳᏍᎩᏂ ᎠᏴ ᎢᎩᎦᏘᏴᎢ, ᏄᏚᎵᏍᎬᎾ ᎨᏒ ᎩᎶ ᎤᏲᎱᎯᏍᏗᏱ, ᏂᎦᏗᏳᏍᎩᏂ ᎤᏂᎷᎯᏍᏗᏱ ᎦᏁᏟᏴᏍᏗ ᎨᏒ ᎣᏓᏅᏛᎢ.


text:
ᎤᎬᏫᏳᎯᏍᎩᏂ ᎤᏤᎵ ᎢᎦ ᎠᏎ ᏓᎦᎷᏥ ᎾᏍᎩᏯ ᎦᏃᏍᎩᏍᎩ ᏒᏃᏱ ᏥᎦᎷᎪᎢ, ᎾᎯᏳ ᎦᎸᎶᎢ ᏓᎦᎶᏐᏂ ᎤᏣᏘ ᎤᏃᏴᎨᏍᏗ, ᎪᏢᏔᏅᎯᏃ ᎠᏓᏪᎵᎩᏍᎬ ᏛᎪᏂ, ᎠᎴ ᎡᎶᎯ ᎾᎿᏃ ᎪᏢᏅᏅᎯ ᎨᏒ ᎠᎪᎲᏍᏙᏗ ᎨᏎᏍᏗ.


text:
ᎠᎴ ᎾᏍᏉ ᏂᎦᏛ ᎾᏍᎩ ᏧᏬᏪᎳᏅᎯ ᎾᏍᎩ ᏂᏕᎬᏁᎰ ᎧᏁᎢᏍᏗᏍᎪ ᎾᏍᎩ ᎯᎠ ᏧᏓᎴᏅᏛ; ᎾᎿ ᎤᏓᏑᏯ ᎢᎦᏛ ᎠᏍᏓᏱᏳ ᎪᎵᏍᏗᏱ, ᎾᏍᎩ Ꮎ ᏂᏭᎾᏕᎶᏆᎥᎾ ᎠᎴ ᏗᏂᏩᎾᎦᎳ ᏓᏂᏁᏟᏴᎭ, ᎾᏍᎩᏯ ᎾᏍᏉ ᏗᏐᎢ ᎪᏪᎵ ᏂᏓᏅᏁᎲᎢ, ᎤᏅᏒᏉ ᎤᏂᏛᏗᏍᎩ ᎨᏒᎢ.


text:
ᎢᏥᏁᏉᎨᏍᏗᏍᎩᏂ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᎬᏩᎵ ᎠᎴ ᎡᏥᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎤᎬᏫᏳᎯ ᎢᎦᏤᎵ ᎠᎴ ᎢᎩᏍᏕᎵᏍᎩ ᏥᏌ ᎦᎶᏁᏛ; ᎾᏍᎩ ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ ᎪᎯ ᎨᏒ, ᎠᎴ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ. ᎡᎺᏅ.


text:
ᎬᏂᏛᏰᏃ ᎬᏂᎨᏒ ᏄᎵᏍᏔᏅᎩ, ᎠᎴ ᎣᎩᎪᎲᎩ, ᎠᎴ ᎣᏥᏃᎮᎭ, ᎠᎴ ᎢᏨᎾᏄᏫᏎᎭ ᎾᏍᎩ ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎬᏂᏛ, ᎾᏍᎩ ᎠᎦᏴᎵᎨᎢ ᎡᎲ ᏤᎮᎢ, ᎠᎴ ᎬᏂᎨᏒ ᎢᏲᎬᏁᎸᎯ ᏥᎩ--


text:
ᎾᏍᎩ Ꮎ ᎣᎩᎪᎲᎯ ᎠᎴ ᎣᎦᏛᎦᏅᎯ ᎨᏒ ᎢᏨᎾᏄᏫᏎᎭ, ᎾᏍᏉ ᏂᎯ ᎢᏣᏖᎳᏗᏍᏗᏱ ᎣᎦᏚᏓᏕᏫᏒᎢ; ᎠᎴ ᎤᏙᎯᏳᎯᏯ ᎣᎦᏚᏓᏕᏫᏒ ᎠᎦᏴᎵᎨᎢ ᎠᎴ ᎤᏪᏥ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎢᏓᏓᏅᏟ, ᎥᏝ ᎢᏤ ᏗᎧᎿᏩᏛᏍᏗ ᏱᏨᏲᏪᎳᏁᎭ, ᎤᏪᏘᏉᏍᎩᏂ ᏗᎧᎿᏩᏛᏍᏗ ᎾᏍᎩ ᏥᏥᎲᎩ ᏗᏓᎴᏂᏍᎬᎢ; ᎤᏪᏘ ᏗᎧᎿᏩᏛᏍᏗ ᎾᏍᎩᏉ ᎧᏃᎮᏛ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏥᏁᏣᏛᎩᏍᎪᎢ.


text:
ᎢᏨᏲᏪᎳᏁᎭ ᎢᏥᎦᏴᎵᎨᎢ, ᎡᏥᎦᏙᎥᏒᏰᏃ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏤᎭ. ᎢᏨᏲᏪᎳᏁᎭ ᎢᏥᏫᏅ, ᎡᏥᏎᎪᎩᏒᏰᏃ ᎤᏁᎫᏥᏛ. ᎢᏨᏲᏪᎳᏁᎭ ᏗᏥᏲᎵ, ᎡᏥᎦᏙᎥᏒᏰᏃ ᎠᎦᏴᎵᎨᎢ.


text:
ᎢᏨᏲᏪᎳᏏ ᎢᏥᎦᏴᎵᎨᎢ, ᎡᏥᎦᏙᎥᏒᏰᏃ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏤᎭ. ᎢᏨᏲᏪᎳᏏ ᎢᏥᏫᏅ, ᏗᏣᎵᏂᎩᏗᏳᏰᏃ, ᎠᎴ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎢᏥᏯᎠ, ᎠᎴ ᎡᏥᏎᎪᎩᏒ ᎤᏁᏧᏥᏛ.


text:
ᏥᏄᏓᎴᏰᏃ Ꭱ-ᎶᎯ ᏤᎭ, ᎠᏰᎸ ᎤᏚᎸᏗ ᏥᎩ, ᎠᎴ ᏨᎦᏙᎵ ᎤᏙᎸᏗ ᏥᎩ, ᎠᎴ ᎠᏢᏉᏗ ᎠᎴᏂᏓᏍᏗᏱ, ᎾᏍᎩ ᎥᏝ ᎠᎦᏴᎵᎨᏍᏗᏱ ᏅᏓᏳᏓᎴᏅᎯ ᏱᎩ, ᎡᎶᎯᏉᏍᎩᏂ ᎤᏓᎴᏅᎯ.


text:
ᏗᏥᏲᎵ, ᎿᏉ ᎤᎵᏍᏆᎸᏗ, ᎢᏣᏛᎦᏅᎯᏃ ᏥᎩ ᎤᎷᎯᏍᏗᏱ ᎦᎶᏁᏛ-ᎠᏡᏗᏍᎩ, ᎠᎴ ᎪᎯ ᎨᏒ ᎤᏂᏣᏔ ᎦᎶᏁᏛ-ᎠᎾᏡᏗᏍᎩ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏗᎦᏔᎭ ᎤᎵᏍᏆᎸᏗ ᎨᏒᎢ.


text:
ᎨᎦᏙᎳᎡᎸᎩ, ᎠᏎᏃ ᎥᏝ ᎾᎿ ᎠᏁᎳ ᏱᎨᏎᎢ, ᎢᏳᏰᏃ ᎾᎿ ᎠᏁᏔ ᏱᎨᏎᎢ, ᎠᏎ ᏱᏂᎬᏩᎾᏛᏁᎢ, ᎠᏎᏃ <n>[ᎤᎾᏙᏣᏒᎩ]</n> ᎬᏂᎨᏒ ᎢᏳᎾᎵᏍᏙᏗᏱ ᎾᎿ ᏂᎦᏛ ᎠᏁᎳ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎯᎠ ᏥᏨᏲᏪᎳᏏ ᎥᏝ ᏱᏅᏓᎦᎵᏍᏙᏓ ᏂᏥᎦᏔᏅᎾ ᎨᏒ ᏚᏳᎪᏛᎢ, ᎢᏥᎦᏔᎯᏳᏍᎩᏂ ᎨᏒᎢ, ᎠᎴ ᎢᏥᎦᏔᎯᏳ ᎨᏒ ᏂᎦᎥ ᎦᏰᎪᎩ ᎧᏃᎮᏛ ᏚᏳᎪᏛ ᏅᏓᏳᏓᎴᏅᎯ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏥᏣᏛᎩᎭ ᎾᏍᎩ ᏂᎯ ᎢᏥᏯᎡᏍᏗ. ᎢᏳᏃ ᎾᏍᎩ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏥᏣᏛᎩᎭ ᎢᏥᏯᎡᏍᏗ, ᏂᎯ ᎾᏍᏉ ᎡᏥᏯᎡᏍᏗ ᎤᏪᏥ ᎠᎴ ᎠᎦᏴᎵᎨᎢ.


text:
ᎾᏍᎩᏍᎩᏂ ᏥᏌ ᎢᏥᎶᏁᏔᏅᎯ ᎨᏒ ᏥᏥᏯᎠ, ᎠᎴ ᎤᏚᎸᏗ ᏂᏣᎵᏍᏓᏁᎲᎾ ᏥᎩ ᎩᎶ ᎢᏤᏲᏗᏱ, ᎾᏍᎩᏰᏃ ᏥᏌ ᎢᏥᎶᏁᏔᏅᎯ ᏥᏤᏲᎲᏍᎦ ᏂᎦᎥᎢ, ᎠᎴ ᎤᏙᎯᏳᏒ ᏥᎩ, ᎠᎴ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᏥᎩ, ᎾᏍᎩᏯ ᏄᏍᏛ ᎢᏤᏲᎲᏍᎬ ᎡᏥᏯᎡᏍᏗ.


text:
ᎢᏨᎨᏳᎢ, ᎿᏉ ᎤᏁᎳᏅᎯ ᏧᏪᏥ ᎠᏴ, ᎠᏎᏃ ᎥᏝ ᎠᏏ ᎬᏂᎨᏒ ᏱᏂᎦᎵᏍᏗᎭ ᎢᎦᎵᏍᏙᏗ ᎨᏒᎢ; ᎠᏎᏃ ᎢᏗᎦᏔᎭ ᎾᎯᏳ ᎦᎾᏄᎪᏨᎭ ᎾᏍᎩᏯ ᏄᏍᏛ ᏂᎦᏍᏕᏍᏗ, ᎾᏍᎩᏰᏃ ᏄᏍᏛ ᎾᏍᎩ ᏓᏰᏗᎪᎢ.


text:
ᎠᏍᎦᏂ ᏧᎸᏫᏍᏓᏁᎯ, ᎠᏍᎩᎾ ᏅᏓᏳᏓᎴᏅᎯ ᎨᏐᎢ, ᏗᏓᎴᏁᏍᎬᏰᏃ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎠᏍᎩᎾ ᎠᏍᎦᏅᎪᎢ. ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎬᏂᎨᏒ ᎾᎬᏁᎸᎩ, ᎤᏲᏍᏙᏗᏱ ᎠᏍᎩᎾ ᏚᎸᏫᏍᏓᏁᎸᎢ.


text:
ᎩᎶ ᎤᏁᎳᏅᎯ ᎤᏕᏔᏅᎯ ᏥᎨᏐ ᎥᏝ ᎠᏍᎦᏂ ᏱᏚᎸᏫᏍᏓᏁᎰᎢ; ᎾᏍᎩᏰᏃ ᎤᏤᎵᎦ ᎤᎦᏔ ᎤᏪᎰᎢ, ᎥᏝ ᎠᎴ ᏰᎵ ᎬᏩᏍᎦᏅᎢᏍᏗ ᏱᎨᏐᎢ, ᏅᏗᎦᎵᏍᏙᏗᏍᎪ ᎤᏁᎳᏅᎯ ᎤᏕᏔᏅᎯ ᎨᏒᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᎾᎿ ᎤᏁᎳᏅᎯ ᏧᏪᏥ ᎬᏂᎨᏒ ᎾᎾᎵᏍᏗᎭ, ᎠᎴ ᎠᏍᎩᎾ ᏧᏪᏥ; ᎩᎶ ᏚᏳᎪᏛ ᏧᎸᏫᏍᏓᏁᎯ ᏂᎨᏒᎾ ᏥᎨᏐᎢ, ᎥᏝ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᏱᎨᏐᎢ; ᎠᎴ ᏗᎾᏓᏅᏟ ᎤᎨᏳᎯ ᏂᎨᏒᎾ ᏥᎨᏐᎢ.


text:
ᎥᏝ ᎾᏍᎩ ᎨᎾ ᏄᏛᏁᎸᎢ, ᎾᏍᎩ ᎤᏁᎫᏥᏛ ᏅᏓᏳᏓᎴᏅᎯ ᏥᎨᏎᎢ, ᎠᎴ ᎤᏅᏟ ᏧᎴ. ᎦᏙᏃ ᎢᎤᎴᎢ? ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᎩᏂ ᎤᏩᏒ ᏚᎸᏫᏍᏓᏁᎲ ᎤᏲᎢᏳ ᎨᏒᎢ, ᎤᏅᏟᏃ ᏚᎸᏫᏍᏓᏁᎲ ᎣᏏᏳ ᎨᏒᎢ.


text:
ᎩᎶᏍᎩᏂ ᎡᎶᎯ ᎡᎯ ᎠᎵᏍᏕᎸᏙᏗ ᎨᏒ ᏧᏪᎰᎢ, ᎠᎴ ᏣᎪᏩᏘᏍᎪ ᏗᎾᏓᏅᏟ ᎤᏂᎬᎬᎢ, ᎠᏎᏃ ᎾᏍᎩ ᏣᏍᏚᏁᎰᏉ ᎤᎾᏫ, ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᏳᏪᎭ ᎤᏁᎳᏅᎯ ᎠᎨᏳᏗ ᎨᏒᎢ?


text:
ᎩᎶᏃ ᎾᏍᎩ ᎤᏤᎵᎦ ᏗᎧᎿᏩᏛᏍᏗ ᎠᏍᏆᏂᎪᏗᏍᎩ ᎾᏍᎩ ᎠᏯᎣᎢ <n>[ᎤᏁᎳᏅᎯᏱ]</n>, ᎠᎴ ᎾᏍᎩ ᎤᏯᎣᎢ <n>[ᎤᏁᎳᏅᎯ]</n>. ᎠᎴ ᎠᏓᏅᏙ ᎢᎩᏁᎸᎯ ᎨᏒ ᎾᏍᎩ ᎢᏓᏙᎴᎰᎯᏍᏗᎭ ᎠᏴ ᎢᎩᏯᎥᎢ.


text:
ᎢᏨᎨᏳᎢ, ᏞᏍᏗ ᎾᏂᎥ ᏗᏓᏅᏙ ᏱᏗᏦᎯᏳᎲᏍᎨᏍᏗ, ᏕᏥᎪᎵᏰᏍᎨᏍᏗᏍᎩᏂ ᏗᏓᏅᏙ, ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᎨᏒ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏅᏓᏳ ᏓᎴᏅᎯ ᏂᎨᏒᎾ ᎨᏒᎢ. ᎤᏂᏣᏔᏰᏃ ᎤᎾᏠᎾᏍᏗ ᎠᎾᏙᎴᎰᏍᎩ ᎠᏁᏙᎭ ᎡᎶᎯ.


text:
ᎾᏍᎩᏃ ᎠᏓᏅᏙ ᎯᎠ ᎢᎦᏪᏍᎩ ᏂᎨᏒᎾ, ᏥᏌ ᎦᎶᏁᏛ ᎤᏇᏓᎵ ᎤᎾᏄᎪᏥᎴᎢ, ᎥᏝ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᏱᎩ. ᎾᏍᎩᏍᎩᏂ ᎯᎠ ᎦᎶᏁᏛ-ᎠᏡᏗᏍᎩ ᎤᏤᎵᎦ ᎠᏓᏅᏙ, ᎾᏍᎩ ᎤᎷᎯᏍᏗᏱ ᎢᏣᏛᎦᏅᎯ ᏥᎩ, ᎠᎴ ᎿᏉ ᎦᏳᎳ ᎡᎶᎯ ᎡᎭ.


text:
ᎠᏴ ᎤᏁᎳᏅᎯ ᏅᏓᏲᎦᏓᎴᏅᎯ; ᎾᏍᎩ Ꮎ ᎤᏁᎳᏅᎯ ᎠᎦᏔᎯ ᎣᎦᏛᎦᏁᎰᎢ. ᎾᏃ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ ᏂᎨᏒᎾ ᎥᏝ ᏲᎦᏛᎦᏁᎰᎢ. ᎾᏍᎩ ᏅᏗᎦᎵᏍᏙᏗᎭ ᏕᏗᎦᏔᎭ ᏚᏳᎪᏛ ᎢᏯᎾᏛᏁᎯ ᎠᏓᏅᏙ, ᎠᎴ ᏚᏳᎪᏛ ᎢᏯᏌᏛᏁᎯ ᏂᎨᏒᎾ ᏗᏓᏅᏙ.


text:
ᎠᏂ ᎯᎠ ᎬᏂᎨᏒ ᏄᎵᏍᏔᏅᎩ ᎤᏁᎳᏅᎯ ᎢᎩᎨᏳᏒᎢ, ᎤᏁᎳᏅᎯᏰᏃ ᏧᏅᏎ ᎤᏩᏒᎯᏳ ᎤᏕᏁᎸᎯ ᎤᏪᏥ ᎡᎶᎯ ᎤᎷᎯᏍᏗᏱ, ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᎬᏂᏛ ᎢᎩᏩᏛᏗᏱ, ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᎬᏂᏛ ᎢᎩᏩᏛᏗᏱ.


text:
ᎠᏂᎯᎠ ᎠᏓᎨᏳᏗ ᎨᏒᎢ, ᎥᏝ ᎤᏁᎳᏅᎯ ᎡᏗᎨᏳᎢᏳ ᏄᎵᏍᏔᏅᎢ, ᎠᏴᏍᎩᏂ ᎢᎩᎨᏳᎯᏳ ᏄᎵᏍᏔᏅᎢ, ᎠᎴ ᏧᏅᏒ ᎤᏤᎵᎦ ᎤᏪᏥ ᎠᎵᏍᎪᎸᏔᏅᎯ ᎠᎫᏴᏙᏗ ᎢᎩᏍᎦᏍᏨᎢ.


text:
ᎠᎴ ᎠᏴ ᎢᎩᎦᏙᎥᏒ ᎠᎴ ᎢᎪᎯᏳᏅ ᎤᏁᎳᏅᎯ ᎢᎩᎨᏳᎯᏳ ᎨᏒ-Ꭲ. ᎤᏁᎳᏅᎯ ᎠᏓᎨᏳᏗ ᎨᏒ ᏚᏙᎥ, ᎠᏓᎨᏳᏗᏃ ᎨᏒ ᎡᎯ ᎤᎾᎳᏅᎯ ᎠᏯᎣᎢ, ᎠᎴ ᎤᎾᎳᏅᎯ ᎾᏍᎩ ᎤᏯᎣᎢ.


text:
ᎠᏂ ᎯᎠ ᎢᎦᏓᎨᏳᏗ ᎨᏒ ᎤᎧᎵᏨᎯ, ᏄᎵᏍᏔᏅ Ꮎ-Ꭹ ᏂᏗᎾᏰᏍᎬᎾ ᎢᏳᎵᏍᏙᏗᏱ ᏗᎫᎪᏙᏗᏱ ᎢᎦ ᎨᏎᏍᏗ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎾᏍᎩᏯ ᏄᏍᏛ ᎾᏍᏉ ᎾᏍᎩ ᏂᎦᏍᏗ ᎠᏴ ᎠᏂ ᎡᎶᎯ.


text:
ᎥᏝ ᎦᎾᏰᎯᏍᏗ ᎨᏒ ᏳᏓᏑᏯ ᎠᏓᎨᏳᏗ ᎨᏒᎢ, ᎤᎧᎵᏨᎯᏍᎩᏂ ᎨᏒ ᎠᏓᎨᏳᏗ ᎦᏄᎪᏫᏍᎦ ᎦᎾᏰᎯᏍᏗ ᎨᏒᎢ; ᎦᎾᏰᎯᏍᏗᏰᏃ ᎨᏒ ᎠᎩᎵᏯ ᎤᏪᎭ; ᎩᎶ ᏥᎦᎾᏰᏍᎪᎢ ᎥᏝ ᎤᎧᎵᏨᎯ ᏱᎨᏐ ᎠᏓᎨᏳᏗ ᎨᏒᎢ.


text:
ᎢᏳᏃ ᎩᎶ ᎤᏁᎳᏅᎯ ᏥᎨᏳᎠ ᏯᏗᎭ, ᏯᏍᎦᎦᏃ ᏗᎾᏓᏅᏟ, ᎦᏰᎪᎩ ᎾᏍᎩ, ᎤᎨᏳᎯᏰᏃ ᏂᎨᏒᎾ ᏱᎩ ᏗᎾᏓᏅᏟ ᎾᏍᎩ ᎤᎪᎲᎯ, ᎦᏙ ᏱᎦᎵᏍᏙᏓ ᎤᎨᏳᎯᏳ ᏱᎩ ᎤᏁᎳᏅᎯ ᎤᎪᎲᎯ ᏂᎨᏒᎾ ᎨᏒᎢ.


text:
ᎾᏍᎩ ᎠᎺ ᎠᎴ ᎩᎬ ᎤᎷᎯᏍᏔᏅᎯ, ᎯᎠ ᏥᏌ ᎦᎶᏁᏛ; ᎥᏝ ᎠᎹᏉ ᎤᏩᏒ, ᎠᎹᏍᎩᏂ ᎠᎴ ᎩᎬ. ᎬᏩᏠᏯᏍᏗ ᎠᎴ ᎠᏓᏅᏙ ᎾᏍᎩ ᎧᏃᎮᏍᎩ, ᎠᏓᏅᏙᏰᏃ ᎦᏱᎪᎩ ᏂᎨᏒᎾ.


text:
ᎪᎯᏳᎲᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎾᏍᎩ ᎤᏩᏒ ᎨᏒ ᎤᏪᎭ ᎪᎯᏳᏗᏍᎩ; ᎤᏁᎳᏅᎯ ᎪᎯᏳᎲᏍᎩ ᏂᎨᏒᎾ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᎤᏰᎪᏅ, ᏅᏗᎦᎵ ᏍᏙᏗᎭ ᏂᎪᎯᏳᎲᏍᎬᎾ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏃᎮᎸᎢ ᎤᏪᏥ ᎤᏁᎢᏍᏔᏅᎢ.


text:
ᎢᏳᏃ ᎩᎶ ᏳᎪᎲ ᏗᎾᏓᏅᏟ ᏳᏍᎦᏅᏨ ᎠᏲᎱᎯᏍᏗ ᏂᎨᏒᎾ ᎠᏍᎦᏅᎢᏍᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎠᏔᏲᎯᎮᏍᏗ ᎠᎴ ᎠᏎ ᎬᏂᏛ ᏓᏰᏥᏁᎵ ᎠᏲᎱᎯᏍᏗ ᏂᎨᏒᎾ ᎤᏂᏍᎦᏅᏨᎯ ᏅᏗᎦᎵᏍᏙᏗᏍᎬᎢ. ᎡᎭ ᎠᏍᎦᏅᎢᏍᏗ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ, ᎥᏝ ᎠᏔᏲᎯᎮᏍᏗ ᎾᏍᎩ ᎠᏥᏙᎵᏍᏗᏱ ᏱᎦᏗᎭ.


text:
ᎢᏗᎦᏔᎭᏃ ᎤᏁᎳᏅᎯ ᎤᏪᏥ ᎤᎷᏨᎢ, ᎠᎴ ᎢᎩᏁᎸ ᎢᎪᎵᏍᏗᏱ, ᎾᏍᎩ ᎡᏙᎵᏍᏗᏱ ᎾᏍᎩ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᏥᎩ; ᎠᎴ ᎾᏍᎩ ᎡᏗᏯᎠ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᏥᎩ, ᎾᏍᎩ ᎤᏪᏥ ᏥᏌ ᎦᎶᏁᏛ. ᎾᏍᎩ ᎯᎠ ᎤᏙᎯᏳᎯᏯ ᎤᏁᎳᏅᎯ, ᎠᎴ ᏫᎾᏍᏛᎾ ᎬᏂᏛ.


text:
ᎠᏴ ᎠᏆᏛᏐᏅᎯ ᏫᏥᏲᎵᎦ ᎠᎦᏑᏰᏛ ᎠᎨᏴ ᎠᎴ ᎾᏍᎩ ᏧᏪᏥ, ᎾᏍᎩ ᎦᏥᎨᏳᎢ ᏚᏳᎪᏛ ᎨᏒᎢ, ᎠᎴ ᎥᏝ ᎠᏋᏒᏉ ᏱᎩ ᎾᏍᏉᏍᎩᏂ ᏂᎦᏛ ᎤᏂᎦᏙᎥᏒᎯ ᏚᏳᎪᏛ ᎨᏒᎢ;


text:
ᎬᏩᎦᏗᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ ᎢᏤᎳᏗᏙᎮᏍᏗ ᎠᎴ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎨᏒᎢ, ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎤᏁᎳᏅᎯ ᎠᎦᏴᎵᎨᎢ ᎠᎴ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎠᎦᏴᎵᎨ ᎤᏪᏥ, ᏚᏳᎪᏛ ᎨᏒᎢ ᎠᎴ ᎠᏓᎨᏳᏗ ᎨᏒᎢ.


text:
ᎠᎴ ᎾᏍᎩ ᎯᎠ ᏄᏍᏗ ᎠᏓᎨᏳᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎢᎨᏓᏍᏗᏱ ᎾᏍᎩᏯ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏤᎵᎦ ᏂᎦᏪᏍᎬᎢ. ᎾᏍᎩ ᎯᎠ ᏗᎧᎿᏩᏛᏍᏗ ᏗᏓᎴᏂᏍᎬ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏥᏁᏣᏛᎩᏍᎪᎢ, ᎾᏍᎩ ᏗᏥᎧᎿᏩᏛᏍᏗᏱ.


text:
ᎩᎶ ᏣᏍᎦᏅᎪᎢ ᎠᎴ ᏂᏓᎧᎿᏩᏕᎬᎾ ᏥᎨᏐ ᎦᎶᏁᏛ ᏧᏕᏲᏅᎯ, ᎾᏍᎩ ᎥᏝ ᎤᏁᎳᏅᎢ ᏳᏪᎰᎢ. ᎾᏑᎵᎪᎬᎾᏍᎩᏂ Ꮎ ᏓᎧᎾᏩᏗᏒ ᏗᎧᎿᏩᏕᎩ ᎦᎶᏁᏛ ᏧᏕᏲᏅᎯ, ᎾᏍᎩ ᏚᏪᎭ ᎢᏧᎳ ᎠᎦᏴᎵᎨ ᎠᎴ ᎤᏪᏥ.


text:
ᎤᏣᏛᎩ ᎢᏳᏓᎴᎩ ᎢᏨᏲᏪᎳᏁᏗ ᎠᎩᎲᎩ, ᎠᏎᏃ ᎥᏝ ᎪᏪᎵᏉ ᎠᎴ ᏗᎪᏪᎶᏗ ᏗᎬᏙᏗ ᏯᎩᏰᎸᏎᎢ, ᎤᏚᎩᏰᏃ ᎠᏋᎭ ᎢᏨᏩᏛᎲᏍᏗᏱ, ᎠᎴ ᏗᏗᎰᎵ ᏗᎬᏙᏗᏱ ᎢᎦᎵᏃᎮᏗᏱ, ᎠᎴ ᎢᏓᎵᎮᎵᎬ ᎤᎧᎵᎢᏍᏗᏱ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᏫᏯᎩᎷᏨ ᏓᎦᏅᏓᏗ ᏚᎸᏫᏍᏓᏁᎲᎢ, ᎾᏍᎩ ᎤᏲ ᎦᏬᏂᏍᎬᎬᏗ ᏦᎦᏡᏗᎭ, ᎠᎴ ᎥᏝ ᎾᏍᎩᏉ ᏰᎵ ᏳᏰᎸᎭ, ᎥᏝᏰᏃ ᏂᏓᏓᏂᎸᎬᎾᏉ ᎤᏩᏒ ᏱᎩ ᎠᎾᏓᏅᏟ, ᎾᏍᏉᏍᎩᏂ ᏕᎦᏅᏍᏓᏕᎭ ᏗᎬᏩᎾᏓᏂᎸᎢᏍᏗ ᏥᎨᏒᎢ, ᎠᎴ ᏕᎦᏄᎪᏫᏍᎦ ᏧᎾᏁᎶᏗ ᎤᏁᏓᏡᎬ.


text:
ᎬᎨᏳᎢ, ᏞᏍᏗ ᎤᏐᏅ ᎨᏒ ᏱᏣᏍᏓᏩᏛᏎᏍᏗ, ᎣᏍᏛᏍᎩᏂ ᎨᏒ ᎯᏍᏓᏩᏕᎨᏍᏗ. ᎣᏍᏛ ᏧᎸᏫᏍᏓᏁᎯ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᏅᏓᏳᏓᎴᏅᎯ; ᎤᏲᏍᎩᏂ ᏧᎸᏫᏍᏓᏁᎯ ᎾᏍᎩ ᎥᏝ ᎤᏁᎳᏅᎯ ᎤᎪᎲᎯ ᏱᎩ.


text:
ᎠᏴ ᏧᏓᏏ, ᏥᏌ ᎦᎶᏁᏛ ᎠᎩᏅᏏᏓᏍᏗ ᎠᎴ ᏥᎻ ᏦᏍᏓᏓᏅᏟ, ᏫᏨᏲᎵᎦ ᏂᎯ ᏂᏥᏍᎦᏅᎾ ᎢᏨᏁᎸᎯ ᎤᏁᎳᏅᎯ ᎠᎦᏴᏎᎨᎢ, ᎠᎴ ᏥᏌ ᎦᎶᏁᏛ ᎢᏳᏩᏂᏌᏛ ᎡᏥᏍᏆᏂᎪᏔᏅᎯ, ᎠᎴ ᎡᏥᏩᏂᏌᏛ ᎡᏥᏍᏆᏂᎪᏔᏅᎯ, ᎠᎴ ᎡᏥᏯᏅᏛ ᎢᏣᏓᏅᏘ ᎢᏣᎵᏍᏙᏗᏱ;


text:
ᎢᏨᎨᏳᎢ, ᎢᏳᏃ ᎠᏆᏟᏂᎬᏁᎸ ᏫᏨᏲᏪᎳᏁᏗᏱ ᏂᎦᏗᏳᏉ ᎢᎦᏤᎵ ᎢᎦᎵᏍᏕᎸᏙᏗ ᎤᎬᏩᎵ, ᎤᏚᎸᏗ ᎾᏆᎵᏍᏓᏁᎸᎩ ᏫᏨᏲᏪᏔᏁᎲ ᎢᏨᏍᏗᏰᏙᏗᏱ, ᎾᏍᎩ ᎤᎵᏂᎩᏛ ᎢᏣᏗᏒᏎᏗᏱ ᎪᎯᏳᏗ ᎨᏒ ᎾᏍᎩ ᎦᏳᎳ ᏗᎨᏥᏲᎯᏎᎸᎯ ᏥᎩ ᎤᎾᏓᏅᏘ.


text:
ᎩᎶᏰᏃ ᎢᏳᎾᏍᏗ ᎠᏂᏍᎦᏯ ᎤᏕᎵᏛ ᎤᏂᏴᎸᎯ ᎢᎩ ᎾᏍᎩ ᎢᎸᎯᏳ ᏅᏓᎬᏩᏓᎴᏅᏛ ᏗᎨᎪᎥᎯ ᏥᎩ ᎾᏍᎩ ᎢᏳᏍᏗ ᏗᎨᎫᎪᏓᏁᏗᏱ; ᎤᏁᎳᏅᎯ ᏂᏚᎾᏁᎶᏛᎾ ᎠᏂᏍᎦᏯ, ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎤᏁᎳᏅᎯ ᎠᏂᏁᏟᏴᏍᎩ ᎾᎵᏏᎾᎯᏍᏛᎾ ᎠᎴᏂᏓᏍᏗ ᎨᏒ ᎢᏯᏅᏁᎯ, ᎠᎴ ᎠᎾᏓᏱᎯ ᎤᏩᏒᎯᏳ ᎤᎬᏫᏳᎯ ᎤᏁᎳᏅᎯ, ᎠᎴ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎠᏆᏚᎵᎭ ᎢᏨᏯᏅᏓᏗᏍᏙᏗᏱ ᎾᏍᎩ ᎯᎠ ᎦᏳᎳ ᏥᏥᎦᏔᎭ, ᎾᏍᎩ Ꮎ ᎤᎬᏫᏳᎯ ᏥᏚᏭᏓᏓᏎ ᏴᏫ ᎢᏥᏈᏱ ᎦᏓ ᎠᎲ, ᎣᏂ ᏥᏚᏛᏔᏁ ᎾᏍᎩ Ꮎ ᏄᏃᎯᏳᏅᎾ.


text:
ᎠᎴ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏄᏂᏍᏆᏂᎪᏔᏅᎾ ᏥᎨᏎ ᏄᏂᎬᏫᏳᏌᏕᎩ ᏂᎨᎬᏁᎸ ᏧᏅᏕᏤᏉᏍᎩᏂ ᎤᎾᏤᎵᎪᎯ ᎠᏁᎲᎢ, ᏧᏓᏕᏒᏛ ᏗᎬᏩᏲᎢᏍᏗ ᏂᎨᏒᎾ ᏕᎨᎦᎸᏍᏗ ᎤᎵᏏᎬᎢ, ᎦᎸᏉᏗᏳ ᏗᎫᎪᏙᏗᏱ ᎢᎦ ᎠᏍᏆᎸᎲ ᎬᏗᏍᎩ.


text:
ᎠᎴ ᎾᏍᏉ ᏐᏓᎻ ᎠᎴ ᎪᎹᎵ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎾᎥ ᏥᏕᎦᏚᎮᎢ, ᎾᏍᎩᏯ ᎾᎾᏛᏁᎮ ᏓᎾᏓᏲᏍᎨ ᎤᏕᎵᏛ ᏗᏂᏏᏗ ᎨᏒ ᏧᏂᎸᏫᏍᏓᏁᏗᏱ, ᎠᎴ ᎠᏂᏍᏓᏩᏗᏙᎮ ᎤᏪᏓᎵ ᎠᏍᏓᏳᏛᏍᏗ ᎤᏇᏓᎵ ᏂᎨᏒᎾ ᎨᏒᎢ, ᎠᏓᏕᏯᏔᎲᏍᎩ ᏂᎨᎬᏁᎴᎢ ᎠᏂᎩᎵᏲᎨ ᎤᏂᏍᏛᏗᏍᏗ ᎨᏒ ᎬᏠᏍᎩ ᏂᎨᏒᎾ ᎠᏥᎸᏱ.


text:
ᏑᏱᎩᎵᏍᎩᏂ ᏄᎬᏫᏳᏌᏕᎩ ᏗᎧᎿᏩᏗᏙᎯ ᎠᏍᎩᎾ ᎤᎾᏗᏒᎸ, ᎤᎾᏗᏒᎸ ᎠᏂᏬᏂᏍᎬ ᎼᏏ ᎠᏰᎸᎢ, ᎹᏱᎩᎵ ᎥᏝ ᎪᎱᏍᏗ ᎤᏐᏅ ᏳᎳᏫᏎᎴᎢ, ᎯᎠᏉᏍᎩᏂ ᏄᏪᏎᎢ, ᎤᎬᏫᏳᎯ ᏫᏣᏍᎦᎩ.


text:
ᎤᏲ ᏫᏄᎾᎵᏍᏓᏏ! ᎨᎾᏰᏃ ᎤᏅᏅ ᎤᏂᏍᏓᏩᏕᏅ, ᎠᎴ ᎨᎦᎫᏴᏓᏁᏗ ᎤᎾᏚᎵᏍᎬ ᎤᏂᎬᎥᏍᎬ ᎤᏂᎨᎮᎾ ᏇᎳᎻ ᎤᎵᏓᏍᏔᏅ, ᎠᎴ ᎨᏥᏛᏔᏅ, ᏚᏂᎦᏘᎸᏒ ᎪᎵ ᏧᎦᏘᎸᏛ ᎨᏒᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᏅᏲᎯ ᏚᏓᏓᎳ ᏗᏣᏁᎶᏗ ᏕᏣᎵᏍᏓᏴᎲᏍᎬᎢ, ᎾᎯᏳ ᎢᏧᎳᏕᏣᎵᏍᏓᏴᎲᎦ ᎾᏂᎾᏰᏍᎬᎾ ᎠᎾᎵᏍᏓᏴᎲᏍᎪᎢ; ᏚᎶᎩᎸ ᎠᎹ ᏂᏚᏁᎲᎾ, ᎤᏃᎴ ᏧᏱᎴᎪᎢ; ᏕᏡᎬ ᏧᎳᏍᏚᏬᎠᏔᎯ, ᎪᎱᏍᏗ ᏄᎾᏓᏓᏁᎲᎾ, ᏔᎵ ᎢᏳᏩᎫᏗ ᎤᏩᏴᏒᎯ ᏥᎨᏐᎢ, ᏗᏰᎯᏛ ᏗᎧᎾᏍᏕᏢᏔᏅᎯ ᏥᎨᏐᎢ.


text:
ᎠᎴ ᎢᎾᎩ, ᎠᏓᏫ ᎤᏕᏅ ᎦᎵᏉᎩᏁ ᏪᎯ, ᎾᏍᏉ ᎠᏙᎴᎰᏍᎬ ᎯᎠ ᎾᏍᎩ ᏚᏁᎢᏍᏔᏁ ᎯᎠ ᏄᏪᏎᎢ, ᎬᏂᏳᏉ, ᎤᎬᏫᏳᎯ ᏓᎦᎷᏥ ᏓᏘᏁᎮᏍᏗ ᎠᏍᎪ ᎢᏯᎦᏴᎵ ᏧᏙᎵ ᎤᎾᏓᏅᏘ,


text:
ᏧᏭᎪᏓᏁᏗᏱ ᎾᏂᎥᎢ, ᎠᎴ ᏧᎬᏍᎪᎸᏗᏱ ᎾᏂᎥ ᎤᏁᎳᏅᎯ ᏂᏚᎾᏁᎶᏛᎾ ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᏂᎦᎥ ᎤᏣᏘᏂ ᏗᎦᎸᏫᏍᏓᏁᏗ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ, ᎠᎴ ᏂᎦᎥ ᏂᏚᏳᎪᏛᎾ ᏄᏂᏪᏒ ᎤᏁᎳᏅᎯ ᏂᏚᎾᏁᎶᏛᎾ ᎾᏍᎩ ᎬᏩᏡᏗᏍᎬᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᎤᏂᎪᏁᎶᎯᏌᏘ, ᎤᏁᎵᎯᏍᎩ, ᎤᏅᏒ ᎤᎾᏚᎸᏅᎥᏍᎬ ᎠᏂᏍᏓᏩᏕᎩ; ᏗᏂᎰᎵᏃ ᏓᏅᏗᏍᎪ ᎤᏣᏘ ᎠᏢᏈᏍᏗ ᎠᏂᏬᏂᏍᎪᎢ, ᏴᏫ ᏚᎾᎧᏛ ᏓᏂᎸᏉᏗᏍᎪ ᎣᏍᏛ ᎢᎬᏩᎾᎵᏍᏓᏁᏗ ᎤᏚᎩ ᎤᏅᏒ ᎢᏳᏍᏗ.


text:
ᎿᏉᏃ ᎾᏍᎩ Ꮎ ᏰᎵᏉ ᎬᏩᏲᏍᏙᏙᏗ ᏥᎩ ᏗᏥᏅᎢᏍᏗᏱ, ᎠᎴ ᎬᏂᎨᏒ ᎢᎨᏨᏁᏗ ᏥᎩ ᎤᏣᏘ ᎤᎵᎮᎵᏍᏗ ᎢᏣᏓᏅᏛᎢ ᎪᎱᏍᏗ ᏁᏥᎳᏫᏎᎲᎾ ᎢᎬᏱᏗᏢ ᏓᎧᏅ ᎦᎸᏉᏗᏳ ᎨᏒᎢ,


text:
ᎾᏍᎩ ᎤᏩᏒᎯ ᎠᎦᏔᎾᎢ ᏥᎩ ᎤᏁᎳᏅᎯ ᎢᎩᏍᏕᎵᏍᎩ, ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ, ᎠᎴ ᎦᎸᏉᏗᏳ, ᎦᎸᏉᏙᏗ ᎨᏎᏍᏗ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏎᏍᏗ, ᏄᎬᏫᏳᏌᏕᎩ ᎨᏎᏍᏗ, ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎨᏎᏍᏗ, ᎪᎯ ᎨᏒ ᎠᎴ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ. ᎡᎺᏅ.


text:
ᏥᏌ ᎦᎶᏁᏛ ᎤᎾᏄᎪᏫᏒᎯ, ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᏧᏲᎯᏎᎸᎯ, ᎬᏂᎨᏒ ᎢᏧᏩᏁᏗᏱ ᏧᏅᏏᏓᏍᏗ ᏧᏓᎴᏅᏛ ᏂᎪᎯᎸᏉ ᎢᏳ ᎵᏍᏔᏂᏓᏍᏗ ᎨᏒᎢ; ᎠᎴ ᏧᎨᏅᏛ ᎤᏤᎵ ᏗᎧᎿᏩᏗᏙᎯ ᎬᏂᎨᏒ ᎢᏳᏩᏁᏗᏱ ᎤᏅᏏᏓᏍᏗ ᏣᏂ;


text:
ᎠᏴ ᏣᏂ ᏫᏨᏲᏪᎳᏏ ᏗᏣᏁᎶᏗ ᎦᎵᏉᎩ ᏂᏣᏓᏡᎬ ᎡᏏᏱ; ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒ ᎠᎴ ᏅᏩᏙᎯᏯᏛ ᎢᏤᎳᏗᏙᎮᏍᏗ ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎾᏍᎩ ᎾᏤᎭ, ᎠᎴ ᏤᎲᎩ, ᎠᎴ ᏤᎮᏍᏗ; ᎠᎴ ᏅᏓᏳᎾᎵᏍᎪᎸᏔᏅᎯ ᎦᎵᏉᎩ ᏗᏓᏅᏙ ᎾᏍᎩ ᎤᏪᏍᎩᎸ ᎢᎬᏱᏗᏢ ᏣᏁᎭ;


text:
ᎠᎴ ᏅᏓᏳᎵᏍᎪᎸᏔᏅᎯ ᏥᏌ ᎦᎶᏁᏛ ᎦᏰᎪᎩ ᏂᎨᏒᎾ ᎧᏃᎮᏍᎩ, ᎠᎴ ᏗᏓᎴᏅᏗᏍᎩ ᎠᏲᏞᏒ ᏗᎴᎯᏐᏗ ᎨᏒᎢ, ᎠᎴ ᎤᎬᏫᏳᎯ ᎡᎶᎯ ᎠᏁᎯ ᎤᏂᎬᏫᏳᎯ ᎤᎾᏤᎵᎦ. ᎾᏍᎩ ᎢᎩᎨᏳᎯ ᏥᎨᏒᎩ ᎠᎴ ᎤᏩᏒ ᎤᎩᎬ ᎢᎪᏑᎴᏔᏅᎯ ᏞᎩᏅᎦᎸᏛ ᎢᎩᏍᎦᏅᏨᎢ,


text:
ᎬᏂᏳᏉ ᏓᎦᎷᏥ ᎤᎶᎩᎸᎢ, ᎠᎴ ᏂᎦᏗᏳ ᏓᎬᏩᎪᎯ ᎠᎴ ᎾᏍᏉ ᏗᎬᏪᏘᎸᎯ; ᏂᎦᏗᏳᏃ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎡᎶᎯ ᎠᏁᎯ ᏙᏛᎾᏠᏱᎵ ᎾᏍᎩ ᎨᏒ ᏅᏗᎦᎵᏍᏙᏗᏍᎨᏍᏗ. ᎰᏩᏉ. ᎡᎺᏅ.


text:
ᎠᏴ ᏣᏂ, ᎢᏓᎵᏅᏟ ᎾᏍᏉ ᏥᎩ, ᎠᎴ ᎢᎦᎵᎪ ᏩᏕᎩ ᎢᏗᎩᎵᏲᏥᏙᎲᎢ, ᎠᎴ ᎬᏂᏗᏳ ᎨᏒ ᎾᏍᎩ ᎤᏤᎵᎦ, ᎠᏴ ᎨᏙᎲᎩ ᎠᎹᏰᎵ ᏆᏗᎹ ᏥᏚᏙᎥ, ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎠᎩᏍᏛᏗᏍᎬᎩ, ᎠᎴ ᏥᏌ ᎦᎶᏁᏛ ᏥᏃᎮᏍᎬ ᎢᏳᏍᏗ.


text:
ᎯᎠ ᏂᎦᏪᏍᎬᎩ, ᎠᏴ ᎡᎵᏆ ᎠᎴ ᎣᎻᎦ, ᎢᎬᏱᏱ ᎨᏒ ᎠᎴ ᎤᎵᏍᏆᎸᏗ ᎨᏒᎢ; ᎠᎴ ᏄᏍᏛ ᎯᎪᏩᏘᏍᎬ ᎰᏪᎸᎦ ᎪᏪᎵᎯ ᎠᎴ ᏫᎩᏅᎥᏏ ᏧᎾᏁᎶᏗ ᎦᎵᏉᎩ ᏄᎾᏓᏡᎬ ᎡᏏᏱ, ᏫᎩᏅᎥᏏ ᎡᏈᏌ ᎠᏁᎯ, ᎠᎴ ᏑᎹᏂ, ᎠᎴ ᏆᎩᎹ, ᎠᎴ ᏓᏱᏓᎵ, ᎠᎴ ᏌᏗᏏ, ᎠᎴ ᏈᎵᏕᎵᏈ, ᎠᎴ ᎴᎣᏗᏏᏯ.


text:
ᎠᏰᎵᏃ ᏕᎦᎧᎲ ᎦᎵᏉᎩ ᏗᏨᏍᏙᏗ ᏗᎦᎪᏙᏗ <n>[ᎦᏙᎬᎩ]</n> ᎩᎶᎢ ᏴᏫ ᎤᏪᏥ ᎾᏍᎩᏯᎢ, ᎤᏄᏩᎥᎩ ᏧᎳᏏᏕᏂ ᏂᏚᎸᎩ, ᎠᏓᏠᏍᏗᏃ ᎠᏕᎸ ᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎤᏓᏠᎲᎩ ᏗᎦᏅᏗᏱ ᏧᏳᎪᏗ.


text:
ᎠᎦᏘᏏᏗᏢᏃ ᎤᏪᏰᏂ ᎦᎵᏉᎩ ᏃᏈᏏ ᏚᏒᎦᎸᎩ; ᎠᎰᎵᏃ ᏓᏳᎦᏌᏛᎩ ᎠᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᎢᏧᎳᏗᏢ ᏗᎪᏍᏓᏯ; ᎤᎧᏛᏃ ᏅᏙ ᎢᎦ-ᎡᎯ ᎤᎵᏂᎩᏛ ᏣᎦᎵᏍᎪ ᎾᏍᎩᏯ ᎨᏒᎩ.


text:
ᏥᎪᎥᏃ ᏚᎳᏍᎬ ᎠᎩᏅᏨᎩ ᎠᎩᏲᎱᏒᎯ ᎢᎦᎦᏛ. ᎠᎦᏘᏏᏗᏢᏃ ᎤᏬᏰᏂ ᎠᏆᏏᏔᏗᏍᏔᏅᎩ, ᎯᎠ ᎾᎩᏪᏎᎸᎩ, ᏞᏍᏗ ᏱᏍᎦᎢᎮᏍᏗ, ᎠᏴ ᎾᏍᎩ Ꮎ ᎢᎬᏱᏱ, ᎠᎴ ᎤᎵᏍᏆᎸᏗ ᏥᎩ.


text:
ᎾᏍᎩ ᎤᏕᎵᏛ ᎨᏒ ᎦᎵᏉᎩ ᏃᏈᏏ ᏥᏕᏣᎪᎲᎩ ᏥᎦᏘᏏᏗᏢ ᎠᏉᏰᏂ ᏥᏓᏆᏒᎦᎸᎩ, ᎠᎴ ᎦᎵᏉᎩ ᏗᏨᏍᏙᏗ ᏗᎦᎪᏙᏗ ᎠᏕᎸ ᏓᎶᏂᎨ ᏗᎪᏢᏔᏅᎯ. ᎾᏍᎩ Ꮎ ᎦᎵᏉᎩ ᏃᏈᏏ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎦᎵᏉᎩ ᏄᎾᏓᏡᎬ ᏧᎾᏁᎶᏗ ᎨᏥᏛᎦ; ᎾᏃ ᎦᎵᏉᎩ ᏗᏨᏍᏙᏗ ᏗᎦᎪᏙᏗᏱ ᏥᏕᏣᎪᎲᎩ, ᎾᏍᎩ ᎦᎵᏉᎩ ᏄᎾᏓᏡᎬ ᏧᎾᏁᎶᏗ ᎦᏛᎦ.


text:
ᎡᏈᏌ ᏧᎾᏁᎶᏗ ᎤᎾᏓᎲᎬ ᏗᎧᎿᏩᏗᏙᎯ ᏫᏲᏪᎳᏏ ᎯᎠ ᎾᏍᎩ ᏫᏂᏪᏏ ᎠᏗᎭ ᎾᏍᎩ Ꮎ ᎦᎵᏉᎩ ᏃᏈᏏ ᎠᎦᏘᏏᏗᏢ ᎤᏬᏰᏂ ᏥᏚᏒᎦᎳ, ᎾᏍᎩ Ꮎ ᏤᏙᎭ ᎠᏰᎵ ᏕᎦᎧᎲ ᎦᎵᏉᎩ ᏗᏨᏙᏍᏗ ᏗᎦᎪᏙᏗᏱ ᎠᏕᎸ ᏓᎶᏂᎨ ᏗᎪᏢᏔᏅᎯ.


text:
ᏥᎦᏔᎭ ᏄᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᎯᎩᎵᏲᎬᎢ, ᎠᎴ ᎲᏂᏗᏳ ᎨᏒᎢ, ᎠᎴ ᎤᏁᎳᎩ ᏗᎦᎮᎵᏎᏗ ᏂᎨᏒᎾ ᎨᏒ ᎾᏍᎩ Ꮎ ᎤᏂᏲ ᏥᎩ; ᎠᎴ ᏘᎪᎵᏰᎥᎯ ᎢᎩ ᎾᏍᎩ ᎣᎩᏅᏏᏛ ᏣᎾᏗᎭ ᎾᏍᎩᏃ ᏄᏍᏛᎾ ᎨᏒᎢ, ᎠᎴ ᏣᏙᎴᎰᏒ ᎠᏂᏰᎪᎩ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎭᏅᏓᏓ ᎾᎿ ᏗᏣᎶᎠᏒᎢ, ᎠᎴ ᎯᏁᏟᏴᎾ ᏣᏓᏅᏛᎢ, ᎠᎴ ᎢᎬᏱᏱ ᏗᎦᎸᏫᏍᏓᏁᏗ ᎨᏒ ᏗᏣᎸᏫᏍᏓᏏ; ᎢᏳᏃ ᎾᏍᎩ ᏂᏣᏛᏁᎸᎾ ᎢᎨᏎᏍᏗ, ᏞᎩᏳ ᏓᎬᎷᏤᎵ, ᎠᎴ ᏓᏥᎧᎲᏏ ᎠᏨᏍᏙᏗ ᎦᎪᏙᏗ ᏣᏤᎵᎦ, ᎢᏳᏃ ᏂᏣᏁᏟᏴᏒᎾ ᎢᎨᏎᏍᏗ ᏣᏓᏅᏛᎢ.


text:
ᎩᎶ ᎦᎵᎷᎨᏍᏗ ᏩᏛᎬᎦ ᎠᏓᏅᏙ ᏂᏕᎦᏪᏎᎲ ᎫᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒᎢ; ᎩᎶ ᎠᏓᏎᎪᎩᏍᎨᏍᏗ ᏓᏥᏯᎵᏍᎪᎸᏓᏁᎵ ᎤᎵᏍᏓᏴᏙᏗᏱ ᎤᏓᏔᏅᎯ ᏡᎬ ᎬᏂᏛ ᎠᏓᏁᎯ, ᎾᏍᎩ ᎠᏰᎵ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏫᏒᏗᏱ ᏥᏡᎦ.


text:
ᏥᎦᏔᎭ ᏄᏍᏛ ᏕᏣᎸᎾᏍᏓᏁᎲᎢ, ᎠᎴ ᎤᏕᏯᏙᏗ ᏂᏣᎵᏍᏓᏁᎲᎢ, ᎠᎴ ᎤᏲ ᏂᏣᏛᎿᏕᎬᎢ, - ᎠᏎᏃ ᏤᎿᎢᏳ. ᎠᎴ ᏥᎦᏔᎭ ᎾᏍᎩ ᎤᏂᏐᏢᎢᏍᏙᏗ ᎨᏒ ᎣᏥᏧᏏ ᎠᎾᏗᏍᎩ, ᎾᏍᎩᏃ ᏄᏍᏛᎾ ᏥᎩ, ᏎᏓᏂᏉᏍᎩᏂ ᎤᏤᎵ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᏁᎳ ᏥᎩ.


text:
ᏞᏍᏗ ᏣᏍᎦᎸᎩ ᎾᏍᎩ Ꮎ ᏧᏓᎴᏅᏛ ᏣᎩᎵᏲᎢᏍᏗ ᏥᎩ; ᎬᏂᏳᏉ ᎠᏍᎩᎾ ᏂᎯ ᎢᏣᏓᏡᎬ ᎩᎶ ᏗᏓᏍᏚᏗᏱ ᏙᏓᏥᏴᏔᏂ ᎡᏥᎪᎵᏰᏗᏱ; ᎠᏍᎪᎯᏃ ᏧᏒᎯᏛ ᏓᏥᎩᎵᏲᏥ; ᎤᎵᏂᎩᏛ ᏘᎧᎿᏩᏚᎦ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᎬᏗᏍᎩ, ᎠᎵᏍᏚᎶᏃ ᎬᏂᏛ ᎠᏓᏁᎯ ᏓᎬᏅᏁᎵ.


text:
ᏥᎦᏔᎭ ᏄᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᎾᎿᎮᎲᎢ, ᎾᎿ ᏎᏓᏂ ᎤᏪᏘᏱ ᎨᏒᎢ; ᎠᎴ ᎾᏍᎩ ᎠᏍᏓᏱᏳ ᏕᏣᏂᏴᏒ ᏓᏆᏙᎥᎢ, ᎠᎴ ᏂᏣᏓᏱᎸᎾ ᎨᏒ ᎠᏆᏤᎵ ᎪᎯᏳᏗ ᎨᏒᎢ, ᎾᎯᏳᎢ ᎥᏗᏆᏏ ᎤᏓᎵᏓᏍᏗ ᏂᎨᏒᎾ ᎠᎩᏃᎮᏍᎩ ᏄᎵᏍᏔᏅ, ᎾᏍᎩ ᏂᎯ ᎢᏤᎲ ᏣᏥᎸᎩ, ᎾᎿ ᏎᏓᏂ ᏒᎲᎢ.


text:
ᎠᏎᏃ ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᎡᏍᎦ ᎬᏰᎸᎾᎲ ᎢᎩ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎾᎿ ᏕᏣᎧᎲ ᏇᎳᎻ ᏓᏕᏲᎲᏍᎬ ᏧᏂᏂᏴᎯ, ᎾᏍᎩ Ꮎ ᏇᎳᎻ ᏇᎳᎻ ᏧᏪᏲᏁ ᎢᎬᏱᏗᏢ ᏧᏁᏗᏱ ᏧᏃᏕᎯᎯ ᎢᏏᎵ ᏧᏪᏥ, ᎾᏍᎩ ᎤᏂᎩᏍᏗᏱ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ, ᎠᎴ ᎤᏕᎵᏛ ᏧᎾᏂᏏᏗᏱ.


text:
ᎩᎶ ᎦᎵᎷᎨᏍᏗ ᏩᏛᎬᎦ ᎠᏓᏅᏙ ᏂᏕᎦᏪᏎᎲ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒᎢ; ᎩᎶ ᎠᏓᏎᎪᎩᏍᎨᏍᏗ ᏓᏥᏁᎵ ᎤᎵᏍᏓᏴᏙᏗ ᎬᏍᎦᎳᏅᎯ ᎹᎾ, ᎠᎴ ᎤᏁᎬ ᏅᏯ ᏓᏥᏁᎵ, ᎠᎴ ᏅᏲᎯ ᎪᏪᎴᏍᏗ ᎢᏤ ᏧᏙᏍᏙᏗ, ᎾᏍᎩ ᎩᎶ ᎾᎦᏔᎲᎾ Ꮎ ᏅᏯ ᎠᏥᏁᎸᎯ ᎤᏩᏒ.


text:
ᏓᏱᏓᎵᏃ ᎤᎾᏓᏡᎬ ᏧᎾᏁᎶᏗ ᏗᎧᎿᏩᏗᏙᎯ ᏫᏲᏪᎳᏏ; ᎯᎠ ᎾᏍᎩ ᏫᏂᏪᏏ ᎠᏗᎭ ᎤᏁᎳᏅᎯ ᎤᏪᏥ, ᎾᏍᎩ Ꮎ ᏗᎦᏙᎵ ᎠᏥᎸ ᎠᏓᏪᎵᎩᏍᎩ ᎾᏍᎩᏯ ᏥᎩ, ᏧᎳᏏᏕᏂᏃ ᎥᏣᏱ ᎬᏩᏔᎷᎩᏍᎩ ᎾᏍᎩᏯ ᏥᎩ;


text:
ᏥᎦᏔᎭ ᏄᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎲᎢ, ᎠᎴ ᏣᏓᎨᏳᏒᎢ, ᎠᎴ ᏕᎭᏓᏁᎳᏁᎲᎢ, ᎠᎴ ᏦᎯᏳᏒᎢ, ᎠᎴ ᎲᏂᏗᏳ ᎨᏒᎢ, ᎠᎴ ᏄᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎲᎢ; ᎤᎵᏍᏆᎸᏗᏁ ᎤᏟ ᎢᎦᎢ ᎨᏒ ᎡᏍᎦᏉ ᎢᎬᏱᏱ.


text:
ᎠᏎᏃ ᎢᎸᏍᎩ ᎢᏳᏓᎴᎩ ᎪᎱᏍᏗ ᎡᏍᎦ ᎬᏰᎸᎾᏁᎲ ᎢᎩ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏁᎳᎩ ᏥᏰᎵᏎᎭ Ꮎ ᎠᎨᏴ ᏤᏏᏈᎵ, ᎦᏙᎴᎣᏍᎩ ᎠᏴ ᏣᏗᎭ, ᏧᏪᏲᏗᏱ ᎠᎴ ᏧᎶᏄᎮᏗᏱ ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᎤᏕᎴᏛ ᏧᎾᏂᏏᏗᏱ ᏗᏆᏤᎵ ᎦᏥᏅᏏᏛ, ᎠᎴ ᎤᏂᎩᏍᏗᏱ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎵᏍᎪᎸᏓᏁᎸᎯ.


text:
ᏤᏪᏥᏃ ᎠᏲᎱᎯᏍᏗ ᎨᏒ ᏙᏓᎦᏥᎢᏍᏔᏂ; ᏂᎦᏗᏳᏃ ᏓᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒ ᎠᏂᎦᏔᎮᏍᏗ ᎾᏍᎩ ᎠᏴ ᏗᏥᎪᎵᏰᏍᎩ ᎨᏒ ᎤᏕᎵᏛ ᎨᏒ ᎠᎴ ᏧᏂᎾᏫ; ᎠᎴ ᏓᏨᏁᎵ ᏂᏥᎥ ᎢᏥᏏᏴᏫᎭ ᎨᏒ ᎾᏍᎩᏯ ᏄᏍᏛ ᏕᏥᎸᏫᏍᏓᏁᎸᎢ.


text:
ᏂᎯᏍᎩᏂ ᎢᏨᏲᏎᎭ, ᎠᎴ ᎠᏂᏐᎢ ᏓᏱᏓᎵ ᎠᏁᎯ, ᎾᏍᎩ ᎾᏂᎥ ᎯᎠ ᏗᏕᏲᏗ ᎨᏒ ᏄᏂᎲᎾ, ᎠᎴ ᎾᏍᎩ ᏄᏂᎦᏙᎥᏒᎾ ᎾᎭᏫᏂᏴ ᏎᏓᏂ ᎤᏤᎵᎦ, ᏣᎾᏗᎭ; ᎥᏝ ᏅᏩᏓᎴ ᎦᎨᏛ ᏴᎨᏨᏐᏈᎸᎦ;


text:
ᏌᏗᏏᏃ ᎤᎾᏓᏡᎬ ᏧᎾᏁᎶᏗ ᏗᎧᎿᏩᏗᏙᎯ ᏫᏲᏪᎳᏏ, ᎯᎠ ᎾᏍᎩ ᏫᏂᏪᏏ ᎠᏗᎭ ᎾᏍᎩ Ꮎ ᎦᎵᏉᎩ ᏗᏓᏅᏙ ᎤᏁᎳᏅᎯ ᏧᏤᎵ ᏧᏪᎯ ᏥᎩ, ᎠᎴ ᎦᎵᏉᎩ ᏃᏈᏏ ᏧᏪᎯ ᏥᎩ; ᏥᎦᏔᎭ ᏄᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎲᎢ, ᎬᏃᏛ ᏥᎨᏦᏎᎭ, ᎠᏎᏃ ᏣᏲᎱᏒᎯᏉ ᏥᎩ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎭᏅᏓᏓ ᏄᏍᏛ ᏕᏣᏓᏂᎸᏨ ᎠᎴ ᏣᏛᎦᏅᎢ, ᎠᎴ ᎠᏍᏓᏯ ᏘᏂᏴ ᎠᎴ ᎯᏁᏟᏴᎾ ᏣᏓᏅᏛᎢ. ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏳᏃ ᏂᏯᏫᏍᎬᎾ ᎢᎨᏎᏍᏗ ᏓᎬᎷᏤᎵ ᎦᏃᏍᎩᏍᎩ ᏥᎦᎷᎪ ᎾᏍᎩᏯᎢ, ᎥᏝ ᎠᎴ ᏱᎦᏔᎮᏍᏗ ᎢᏳ ᎨᏒ ᏗᎬᎷᏤᎵᏒᎢ.


text:
ᎢᎸᏍᎩ ᏂᎦᎥ ᏚᎾᏙᎥ ᏕᏣᏍᏆᏂᎪᏗ ᏌᏗᏏ, ᎾᏍᎩ ᎦᏓᎭ ᎢᏧᏅᏁᎸᎯ ᏂᎨᏒᎾ ᏧᎾᏄᏬ; ᎠᎴ ᎾᏍᎩ ᎢᏧᎳᎭ ᏓᏲᏤᏙᎵ ᏧᏁᎩᏳ ᎨᏎᏍᏗ ᏚᎾᏄᏩᎥᎢ; ᏰᎵᏉᏰᏃ ᎾᏍᎩ ᎢᎬᏩᎾᏛᏁᏗ.


text:
ᎩᎶ ᎠᏓᏎᎪᎩᏍᎨᏍᏗ ᎾᏍᎩ ᏧᏁᎬ ᏣᏥᏄᏬᏍᏗ ᎨᏎᏍᏗ, ᎠᎴ ᎥᏝ ᏥᏲᏍᏓᏁᏗ ᏱᎨᏎᏍᏗ ᏚᏙᎥ ᎬᏂᏛ ᎠᏓᏁᎯ ᎪᏪᎵᎯ ᎪᏪᎸᎢ; ᎠᎴ ᎬᏂᎨᏒ ᎢᏥᏴᏁᏗ ᎨᏎᏍᏗ ᏕᎤᏙᎥ ᎡᏙᏓ ᎠᎦᏔᎲᎢ, ᎠᎴ ᏧᏤᎵ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎠᏂᎧᏔᎲᎢ.


text:
ᏈᎵᏕᎵᏈᏃ ᎤᎾᏓᏡᎬ ᏧᎾᏁᎶᏗ ᏗᎧᎿᏩᏗᏙᎯ ᏫᏲᏪᎳᏏ; ᎯᎠ ᎾᏍᎩ ᏫᏂᏪᏏ ᎠᏗᎭ ᎾᏍᎩ Ꮎ ᎠᏍᎦᎾ ᏂᎨᏒᎾ, ᎾᏍᎩ ᎦᏰᎪᎩ ᏂᎨᏒᎾ, ᎾᏍᎩ ᎠᏍᏚᎢᏍᏗ ᏕᏫ ᎤᏤᎵᎦ ᎦᏁᎯ, ᎾᏍᎩ ᎠᏍᏚᎢᏍᎩ ᏥᎩ, ᎩᎶᏃ ᎠᏍᏚᎲᏍᎩ ᏂᎨᏒᎾ ᏥᎩ; ᎠᎴ ᎠᏍᏚᎲᏍᎩ, ᎩᎶᏃ ᎠᏍᏚᎢᏍᎩ ᏂᎨᏒᎾ ᏥᎩ.


text:
ᏥᎦᏔᎭ ᏁᏍᏛ ᏕᏣᎸᏫᏍᏓᏁᎲᎢ; ᎬᏂᏳᏉ ᎢᎬᏱᏢ ᏂᎬᏴᏂᏏ ᎠᏍᏚᎢᏛ ᎦᎶᎯᏍᏗᏱ, ᎥᏝᏃ ᎩᎶ ᎬᏩᏍᏚᏗ ᏱᎩ; ᎠᏏᏰᏃ ᎤᏍᏗᏱᏛ ᏣᎵᏂᎬᎦ, ᎠᎴ ᏣᏍᏆᏂᎪᏔᏅ ᎧᏃᎮᏛ ᎠᏆᏤᎵᎦ, ᎠᎴ ᎥᏝ ᏱᏣᏓᏱᎸ ᏓᏆᏙᎥᎢ.


text:
ᎬᏂᏳᏉ ᏎᏓᏂ ᎤᏤᎵ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᏁᎳ ᏅᏓᎦᏥᏴᏁᎵ, ᎾᏍᎩ Ꮎ ᎣᏥᏧᏏ ᏣᎾᏗᎭ, ᎠᏎᏃ ᎾᏍᎩ ᏄᎾᏍᏛᎾ ᏥᎩ, ᎠᎴ ᏣᎾᏥᎪᎥᏍᏚᏉ, ᎬᏂᏳᏉ ᎤᏂᎷᎯᏍᏗᏱ ᏅᏓᎦᏥᏴᏁᎵ ᎠᎴ ᎤᎾᏓᏙᎵᏍᏔᏂᎪᏍᏗᏱ ᏕᏣᎳᏍᎬᎢ, ᎠᎴ ᎤᏂᎦᏙᎥᏍᏗᏱ ᎬᎨᏳᎢᏳ ᎨᏒᎢ.


text:
ᎾᏍᎩᏯᏃ ᎲᏂᏗᏳ ᎨᏒ ᏥᏣᏍᏆᏂᎪᏔᏅ ᎠᏆᏤᎵ ᎧᏃᎮᏛ, ᎾᏍᎩ ᎢᏳᏍᏗ ᎾᏍᏉ ᎠᏴ ᏓᎬᏍᏆᏂᎪᏔᏂ ᏓᎬᏳᏓᎴᏏ ᎾᎯᏳ ᎤᏓᎪᎵᏰᏗ ᎨᏒ ᎠᏍᏆᎸᎲᎭ, ᎡᎳᏂᎬ ᎤᏂᎷᏤᏗ ᏥᎩ, ᎤᏂᎪᎵᏰᏗᏱ ᎾᏍᎩ Ꮎ ᎡᎶᎯ ᏣᏁᎭ.


text:
ᎩᎶ ᎠᏓᏎᎪᎩᏍᎨᏍᏗ ᎦᎫᏍᏛᏗ ᏅᏓᏥᏴᏁᎵ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎠᏆᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎥᏝᏃ ᎿᏉ ᎢᎸᎯᏳ ᎤᏄᎪᎢᏍᏗ ᏱᎨᏎᏍᏗ; ᎠᎴ ᏓᏥᏲᏪᎶᏔᏂ ᏚᏙᎥ ᎠᏆᏁᎳᏅᎯ, ᎠᎴ ᏚᏙᎥ ᎦᏚᎲ ᎠᏆᏁᎳᏅᎯ ᎤᏤᎵᎦ, ᎾᏍᎩ ᎢᏤ ᏥᎷᏏᎵᎻ ᏥᎩ, ᎾᏍᎩ ᎦᎸᎶᎢ ᎤᏁᎳᏅᎯᏱ ᏣᏗᏓᎴᎲᏍᎩ; ᎠᎴ ᏓᏥᏲᏪᎶᏔᏂ ᎢᏤ ᏓᏆᏙᎥᎢ.


text:
ᎴᎣᏗᏏᏰᏃ ᏧᎾᏁᎶᏗ ᎤᎾᏓᏡᎬ ᏗᎧᎿᏩᏗᏙᎯ ᏫᏲᏪᎳᏏ; ᎯᎠ ᎾᏍᎩ ᏫᏂᏪᏏ ᎠᏗᎭ ᎾᏍᎩ ᎡᎺᏅ ᏥᏚᏙᎥ, ᎾᏍᎩ Ꮎ ᏄᏓᎵᏓᏍᏛᎾ ᎠᎴ ᎤᏙᎯᏳᎯᏯ ᎧᏃᎮᏍᎩ ᏥᎩ, ᏗᏓᎴᏅᏗᏍᎩ ᎤᏬᏢᏅᏅ ᎤᏁᎳᏅᎯ.


text:
ᏅᏗᎦᎵᏍᏙᏗᎭ ᎯᎠ ᏥᏂᏪᎭ, ᎠᏇᎿᎠ, ᎠᎴ ᎥᏝ ᎪᎱᏍᏗ ᏯᎩᏂᎬᏎᎭ; ᏂᎦᏔᎲᎾᏃ ᎢᎩ ᎤᏲ ᏂᏣᏛᎿᏕᎬᎢ, ᎠᎴ ᎤᏪᏙᎵᏍᏗ ᏂᏣᏛᎿᏕᎬᎢ, ᎠᎴ ᎪᎱᏍᏗ ᏂᏣᎲᎾ ᎨᏒᎢ, ᎠᎴ ᏘᎨᏫ ᎨᏒᎢ, ᎠᎴ ᏣᏰᎸᎭ ᎨᏒᎢ,


text:
ᎬᏂᏤᎭ ᏍᎩᏩᎯᏎᏗᏱ ᎠᏕᎸ ᏓᎶᏂᎨ ᎠᏥᎸᏱ ᎬᏔᏅᎯ, ᎾᏍᎩ ᎤᏙᎯᏳᎯ ᏤᏅᎢᏍᏗᏱ; ᎠᎴ ᎤᏁᎬ ᎠᏄᏬ ᏣᏄᏬᏍᏗ, ᎾᏍᎩ ᎢᏳᎵᏍᏙᏗᏱ ᏂᎨᏒᎾ; ᎠᎴ ᏘᎦᏙᎵ ᏗᏣᎶᏁᏙᏗᏱ ᏗᎦᏔ-ᏗᎦᎶᏁᏗ, ᎾᏍᎩ ᎨᏣᎪᏩᏛᏗ ᎢᏳ ᎵᏍᏙᏗᏱ.


text:
ᎬᏂᏳᏉ ᏥᏙᎦ ᎦᎶᎯᏍᏗᏱ ᎠᎴ ᎬᏂᎭ; ᎩᎶ ᎠᏛᎩᏍᎨᏍᏗ ᏥᏁᎬ ᎠᎴ ᎠᏍᏚᎢᏍᎩᏍᏗ ᎦᎶᎯᏍᏗᏱ, ᏓᏥᏴᎵ ᎠᏯᎥᎢ, ᎠᎴ ᏓᎦᎵᏍᏓᏴᏂ ᎠᎵᏍᏓᏴᎲᏍᎬᎢ, ᎠᎴ ᎾᏍᎩ ᏛᎵᏍᏓᏴᏂ ᎦᎵᏍᏓᏴᎲᏍᎬᎢ.


text:
ᎣᏂᏃ ᏓᏆᎧᎿᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎦᎶᎯᏍᏗᏱ ᎤᎵᏍᏚᎢᏛ ᎨᏒᎩ ᎦᎸᎳᏗ; ᎢᎬᏱᏱᏃ ᎧᏁᎬ ᎠᏆᏛᎦᏅᎯ ᎠᏤᎷᎩ ᏣᏆᎵᏃᎮᏗᏍᎪ ᎾᏍᎩᏯ ᎨᏒᎩ; ᎯᎠ ᏥᎾᎩᏪᏎᎰᎢ, ᎡᎭᎩᎳᏩ, ᏓᎬᎾᏄᎪᏫᏎᎵᏃ ᏧᏓᎴᏅᏛ ᎾᏍᎩ ᎣᏂ ᎢᏳᎵᏍᏔᏂᏓᏍᏗ ᎨᏒᎢ.


text:
ᎦᏍᎩᎸᏃ ᏓᏓᎴᎲᏍᎬᎩ ᎠᎾᎦᎵᏍᎩ, ᎠᎴ ᎠᏴᏓᏆᎶᏍᎩ ᎠᎴ ᎤᏃᏴᎬᎢ; ᎠᎴ ᎦᎵᏉᎩ ᏗᏨᏍᏙᏗ ᏧᏥᏍᏟ ᏓᏓᏪᎵᎩᏍᎬᎩ ᎢᎬᏱᏗᏢ ᎦᏍᎩᎸᎢ, ᎯᎠ ᎾᏍᎩ ᎦᎵᏉᎩ ᏗᏓᏅᏙ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ.


text:
ᎦᏍᎩᎸᏃ ᎢᎬᏱᏗᏢ ᎥᏓᎸᎩ ᎠᏓᎰᏗ ᎢᏗᎬᏤᎵᏛ, ᏅᏯ ᏗᎬᎸᏌᏛ ᎾᏍᎩᏯ ᎨᏒᎩ; ᎦᏍᎩᎸᏃ ᎠᏰᎵ, ᎠᎴ ᎬᏩᏚᏫᏛ ᎾᎿ ᎦᏍᎩᎸ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᎥᎦᏥᎪᎥᎩ, ᎠᎧᎵᏬᎯ ᏓᏂᎧᏅᎩ ᎢᎬᏱᏗᏢ ᎠᎴ ᎣᏂᏗᏢ.


text:
ᎢᎬᏱᏱ ᎾᏍᎩ ᎯᎠ ᎬᏃᏛ ᏢᏓᏥ ᎤᏃᏕᎾ ᎾᏍᎩᏯ ᎨᏒᎩ, ᏔᎵᏁᏃ ᎾᏍᎩ ᎯᎠ ᎬᏃᏛ ᏩᎦ ᎠᎩᎾ ᎾᏍᎩᏯ ᎨᏒᎩ, ᏦᎢᏁᏃ ᎾᏍᎩ ᎯᎠ ᎬᏃᏛ ᏴᏫ ᎤᎧᏛ ᎾᏍᎩᏯ ᎤᎧᏛᎩ, ᎤᎩᏁᏃ ᎾᏍᎩ ᎯᎠ ᎬᏃᏛ ᎦᏃᎯᎵᏙᎯ ᎠᏬᏎᎵ ᎾᏍᎩᏯ ᎨᏒᎩ.


text:
ᎾᏍᎩᏃ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᎠᏂᏏᏴᏫᎭ ᏑᏓᎵ ᏓᏃᏯᏛᎩ; ᎬᏩᏚᏫᏛᏃ ᎠᎴ ᎭᏫᏂ ᎧᎵᏬᎯ ᎨᏒ ᏗᏂᎧᏅᎢ; ᎠᎴ ᎾᎾᏣᏪᏐᎸᏍᏗᏍᎬᎾ ᎨᏐ ᎢᎦ ᎠᎴ ᏒᏃᏱ ᎯᎠ ᎾᏂᏪᏍᎬᎢ; ᎦᎸᏉᏗᏳ, ᎦᎸᏉᏗᏳ, ᎦᎸᏉᏗᏳ, ᎤᎬᏫᏳᎯ ᎤᏁᎳᏅᎯ ᏫᎾᏍᏛᎾ ᎤᎵᏂᎩᏛ, ᎾᏍᎩ ᏤᎲᎩ, ᎠᎴ ᏤᎭ, ᎠᎴ ᏤᎮᏍᏗ.


text:
ᎿᏉ ᏅᎩᏦᏁ ᎢᏯᏂᏛ ᏧᎾᏛᏐᏅᎯ ᎡᎳᏗ ᏓᎾᏓᏅᎥᏍᎪ ᎢᎬᏱᏗᏢ ᎤᏬᎸ ᎾᏍᎩ ᎦᏍᎩᎸ ᎤᏬᎵ, ᎠᎴ ᎠᎾᏓᏙᎵᏍᏓᏁᎰ ᎾᏍᎩ Ꮎ ᏂᎪᎯᎸ ᎾᎵᏍᏆᏗᏍᎬᎾ ᏤᎭ, ᎠᎴ ᏧᎾᎵᏍᏚᎶ ᎦᏍᎩᎸ ᎢᎬᏱᏗᏢ ᏚᎾᏓᎡᎯ, ᎯᎠ ᎾᏂᏪᏍᎪᎢ;


text:
ᏰᎵᏉ ᏂᎯ ᏣᎬᏫᏳᎯ ᎦᏰᏣᏁᎢᏍᏓᏁᏗ ᎡᏣᎸᏉᏗᏳ ᎨᏒ, ᎠᎴ ᎡᏤᎸᏉᏙᏗ ᎨᏒ, ᎠᎴ ᏣᎵᏂᎩᏗᏳ ᎨᏒᎢ; ᏂᎦᏗᏳᏰᏃ ᎪᎱᏍᏗ ᏦᏢᏅᎯ, ᎠᎴ ᎭᏓᏅᏖᏍᎬ ᎢᏨᏁᎵᏓᏍᏗᏱ ᎡᎭ, ᎠᎴ ᎪᏢᏅᎯ.


text:
ᎠᏏᏴᏫᏃ ᎾᏍᎩ ᎫᎾᏛᏐᏅᎯ ᎨᏒ ᎯᎠ ᎾᎩᏪᏎᎸᎩ, ᏞᏍᏗ ᏗᏣᏠᏱᎸᎩ; ᎬᏂᏳᏉ ᏢᏓᏥ ᎤᏃᏕᎾ ᏧᏓ ᎠᏂᏔᏍᏓᎸ ᏅᏓᏳᏓᎴᏅᎯ, ᏕᏫ ᎤᏱᏝᏅᎯ, ᎤᏓᏎᎪᎩᏒ ᎤᏍᏚᎢᏍᏗᏱ ᎪᏪᎵ, ᎠᎴ ᏧᏲᏍᏙᏗᏱ ᎦᎵᏉᎩ ᏂᏓᏍᏚᎲᎢ.


text:
ᎠᎴ ᏓᏆᎧᎿᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ, ᎠᏰᎵ ᎦᏍᎩᎸᎢ ᎠᎴ ᎠᏰᎵ ᏄᎾᏛᏅ ᎾᏍᎩ Ꮎ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ, ᎠᎴ ᎠᏰᎵ ᎠᏂᏅ ᏧᎾᏛᏐᏅᎯ, ᎥᎦᏙᎬᎩ ᎤᏃᏕᎾ ᎠᎩᎾ, ᎠᎸᎯ ᎢᏳᏍᏗ ᎨᏒᎩ ᏓᎧᏅᎩ, ᎾᏍᎩ ᎦᎵᏉᎩ ᏗᏓᏅᏙ ᎤᏁᎳᏅᎯ ᏧᏤᎵ ᎦᏛᎦ, ᎾᏍᎩ ᏂᎬᎾᏛ ᎡᎶᎯ ᏗᎦᏅᏒᎯ ᏥᎩ.


text:
ᎤᏁᏒᏃ ᎪᏪᎵ, ᎾᏍᎩ Ꮎ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᎠᎴ ᏅᎩᏦᏁ ᎢᏯᏂᏛ ᏧᎾᏛᏐᏅᎯ ᎡᎳᏗ ᏓᎾᏓᏅᏅᎩ ᎠᎦᏔᎲ ᎤᏃᏕᎾ ᎠᎩᎾ, ᏗᏂᏁᎯᎭ ᎨᏒᎩ ᏗᎧᏃᎩᏍᏙᏗ, ᎠᎴ ᏗᏖᎵᏙ ᎠᏕᎸ ᏓᎶᏂᎨ ᏗᎪᏢᏔᏅᎯ ᏗᎧᎵᎢ ᎨᏒᎩ ᎠᏜ ᎦᏩᏒᎩ, ᎾᏍᎩ ᎤᎾᏓᏅᏘ ᎠᎾᏓᏙᎵᏍᏗᏍᎬ ᏥᎩ.


text:
ᎢᏤᏃ ᏗᎧᏃᎩᏍᏗ ᏚᏂᏃᎩᏒᎩ, ᎯᎠ ᏄᏂᏪᏒᎩ; ᏚᏳᎪᏗ ᏂᎯ ᏣᏁᏍᏗᏱ ᎪᏪᎵ ᎠᎴ ᏗᏣᏲᏍᏙᏗᏱ ᏓᏍᏚᎲᎢ; ᎡᏣᎸᎩᏰᏃ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏧᏤᎵ ᏂᏍᎩᏴᏁᎸ ᏣᎩᎬ ᏍᎩᏩᎯᏍᏔᏅ, ᏫᏗᏍᎩᏯᏅᎲ ᏂᎦᏛ ᏓᏂᎳᏍᏓᎳᏩᏗᏒᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᏗᏂᏬᏂᏍᎩ ᎨᏒᎢ, ᎠᎴ ᏧᎾᏓᎴᏅᏛ ᏴᏫ, ᎠᎴ ᏧᎾᏓᎴᏅᏛ ᏓᏁᏩᏗᏒᎢ.


text:
ᎠᎴ ᏓᏆᎧᎿᏅᎩ, ᎠᎴ ᎠᏆᏛᎦᏅᎩ ᎠᏂᏁᎬ ᎠᏂᏁᎬ ᎤᏂᏣᏘ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏚᎾᏚᏫᏍᏛ ᎦᏍᎩᎸᎢ, ᎠᎴ ᎠᏂᏁᎬ ᏗᏅᏃᏛ ᎠᎴ ᏧᎾᏛᏐᏅᎯ; ᎯᎠᏃ ᎾᏂᎥᎩ, ᎠᏍᎪᎯ ᎢᏯᎦᏴᎵ ᎤᎶᏏᎶᏛ ᎠᏍᎪᎯ ᎢᏯᎦᏴᎵ, ᎠᎴ ᎠᎦᏴᎵ ᎤᎦᏴᎳᏥᎶᏛ.


text:
ᎯᎠ ᎾᏂᏪᏍᎬᎩ ᎠᏍᏓᏯ ᎤᏁᎷᎬᎩ; ᎤᏃᏕᎾ ᎠᎩᎾ ᎠᏥᎸᎯ ᏰᎵᏉ ᎦᏁᎢᏍᏓᏁᏗ ᎤᎵᏂᎩᏗᏳ ᎨᏒ, ᎠᎴ ᎤᏪᎿᎢᏳ ᎨᏒ, ᎠᎴ ᎠᏏᎾᏌᏂᏳ ᎨᏒ, ᎠᎴ ᎬᏩᏄᎸᏗ ᏂᎨᏒᎾ ᎨᏒ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎨᏒ, ᎠᎴ ᎣᏍᏛ ᎧᏁᎢᏍᏓᏁᏗ ᎨᏒᎢ.


text:
ᏂᎦᏗᏳᏃ ᎪᏢᏅᎯ ᎨᏒ ᎦᎸᎳᏗ ᎡᎲ, ᎠᎴ ᎡᎶᎯ ᎡᎲ, ᎠᎴ ᎡᎶᎯ ᎭᏫᏂᏗᏢ ᎡᎲ, ᎠᎴ ᎾᏍᎩ ᎠᎺᏉᎯ ᎠᏁᎲ, ᎠᎴ ᏂᎦᏛ ᎾᎿ ᎠᏂᏯᎥᎢ, ᎠᏆᏛᎦᏅᎩ ᎯᎠ ᎾᏂᏪᏍᎬᎢ, ᎣᏍᏛ ᎧᏁᎢᏍᏓᏁᏗ ᎨᏎᏍᏗ, ᎾᏍᎩ ᎦᏍᎩᎸ ᎤᏬᎵ, ᎠᎴ ᎾᏍᏉ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᏂᎪᎯᎸᎢ.


text:
ᎠᎴ ᏕᏥᎦᏅᎩ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᏲᏍᏔᏅ ᏌᏉ ᎠᏍᎦᏛ ᎪᏪᎵ; ᎠᎴ ᎠᏆᏛᎦᏅᎩ ᎠᏴᏓᏆᎶᏍᎩ ᏧᏃᏴᎪ ᎾᏍᎩᏯ.Ꭲ, ᎾᏍᎩ Ꮎ ᎠᏏᏴᏫ ᏅᎩ ᎢᏯᏂᏛ ᎨᏒ ᏗᏅᏃᏛ, ᎯᎠ ᏂᎦᏪᏍᎬᎩ, ᎡᎭᎦᏔᏄᎦ.


text:
ᎠᎴ ᏫᏓᏆᎧᎾᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎤᏁᎬ ᏐᏈᎵ ᏫᏥᎪᎥᎩ ᎠᎴ ᎾᎿ ᎤᎩᎵ ᎦᎶᏣᏗ ᎦᏁᎲᎩ; ᎠᎴ ᎠᎵᏍᏚᎶ ᎠᏥᏅᏁᎸᎩ; ᎠᎴ ᎤᏪᏅᏒᎩ ᏫᏓᏎᎪᎩᏍᎬᎩ, ᎠᎴ ᏫᎬᏓᏎᎪᎩᏏᏒᎩ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᏐᏈᎵ ᎤᏄᎪᏨᎩ, ᎠᎩᎦᎨᎢ; ᎠᎴ ᎠᎦᎵᏍᎪᎸᏓᏁᎸᎩ ᎾᎿ ᎤᎩᎵ ᏅᏩᏙᎯᏯᏛ ᎨᏒ ᎤᏄᎪᏫᏍᏗᏱ ᎡᎶᎯ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᎤᏅᏒᏉ ᏧᎾᏓᎯᏍᏗᏱ; ᎠᎴ ᎡᏆ ᎠᏰᎳᏍᏗᎦᏅᎯᏛ ᎠᏥᏕᎸᎩ.


text:
ᎠᎴ ᏦᎢᏁ ᎠᏍᏚᎲ ᎤᏍᏚᎢᏒ, ᎠᏆᏛᎦᏅᎩ ᏦᎢᏁ ᎾᏍᎩ Ꮎ ᎬᏃᏛ ᎯᎠ ᏄᏪᏒᎩ, ᎡᎭᎦᏔᏄᎦ. ᎠᎴ ᏓᏆᎧᎾᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎬᎿᎨ ᏐᏈᎵ; ᎠᎴ ᎾᎿ ᎤᎩᎵ ᏗᎦᏛᏗ ᏕᎦᏁᎲᎩ.


text:
ᎠᎴ ᎧᏁᎬᎠᏆᏛᎦᏅᎩ ᏛᏓᎴᎲᏍᎬᎩ ᎠᏰᎵ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᏄᎾᏛᏅᎢ, ᎯᎠ ᏅᏓᎦᏪᏍᎬᎩ, ᏥᏂᎩ ᎠᏟᎶᏍᏗ ᎠᎧᎵᎢ ᎤᏣᎴᏍᏗ ᎠᎩᏏᏧᎬᏩᎶᏗ ᎠᎫᏴᏗ, ᎠᎴ ᏥᏂᎩ ᎠᏟᎶᏍᏗ ᏦᎢ ᎢᏯᎧᎵᎢ ᎤᏣᎴᏍᏗ ᎢᏳᏍᏗ ᎠᎩᏏ-ᏧᎬᏩᎶᏗ ᎠᎫᏴᏗ; ᎠᎴ ᏞᏍᏗ ᎪᎱᏍᏗ ᏗᏨᏁᎸᎩ ᎪᎢ ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ.


text:
ᎠᎴ ᏫᏓᏆᎧᎾᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎤᏬᏓᎸ ᏗᎧᏃᏗᏱ ᏐᏈᎵ ᏫᏥᎪᎥᎩ; ᎠᎴ ᎾᎿ ᎤᎩᎵ ᎠᏲᎱᎯᏍᏗ ᏚᏙᎥᎩ, ᎠᎴ ᏨᏍᎩᏃ ᎤᏍᏓᏩᏗᏒᎩ; ᎠᎴ ᎨᎦᎵᏍᎪᎸᏓᏁᎸᎩ ᎾᏍᎩ ᏅᎩ ᎢᎦᏛᎯ ᎨᏒ ᎡᎶᎯ ᎾᏍᎩ ᏌᏉ ᏄᏓᎥ ᎾᎿ ᏧᏂᎯᏍᏗᏱ ᎠᏰᎳᏍᏗᎦᏅᎯᏛ ᎬᏗ, ᎠᎴ ᎠᎪᏄ ᎬᏗ, ᎠᎴ ᎥᎫᎩ ᎬᏗ, ᎠᎴ ᎢᎾᎨ ᎠᏁᎯ ᎤᏂᏍᎦᏎᏗ ᏗᎬᏗ.


text:
ᎠᎴ ᎯᏍᎩᏁ ᎠᏍᏚᎲ ᎤᏍᏚᎢᏒ, ᎠᏥᎸᎨᎳᏍᏗᏱ ᎭᏫᏂᏢ ᏓᎩᎪᎲᎩ ᏧᎾᏓᏅᏙ ᎾᏍᎩ Ꮎ ᏗᎨᏥᎸᎯ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎧᏃᎮᏛ ᎤᏂᏍᏛᏛᎯ, ᎠᎴ ᏄᏍᏛ ᎤᏃᎯᏳᏔᏅ ᎤᏂᏍᏛᏛᎯ;


text:
ᎠᎴ ᎠᏍᏓᏯ ᎤᏁᎷᏅᎩ ᎯᎠ ᏄᏂᏪᏒᎩ, ᎢᎳᎪ ᏅᏓᎪᎯᏥ ᏣᎬᏫᏳᎯ, ᏂᎯ ᏂᏍᎦᏅᎾ ᎠᎴ ᏚᏳᎪᏛ ᎢᎭᏛᏁᎯ, ᎩᎳ ᏙᏓᎩᏳᎪᏓᏁᎸ ᏓᎩᏍᏛᏗᏍᏔᏂ ᎠᎴ ᏓᎩᏯᏞᏤᎢ ᎣᎩᎩᎬ ᎤᏂᏨᏅ ᎾᏍᎩ Ꮎ ᎡᎶᎯ ᏣᏁᎭ.


text:
ᎠᎴ ᎠᏂᏏᏴᏫᎭ ᎨᏒ ᏧᏁᎬ ᏕᎨᏥᏅᏁᎸᎩ ᏗᏄᏬ; ᎠᎴ ᎨᏥᏃᏁᎸᎩ ᎠᏏ ᏞᎦ ᎤᎾᏣᏪᏐᎸᏍᏙᏗᏱ ᎨᏒ ᎬᏂ ᎢᏧᎳᎭ ᎨᏥᏅᏏᏙᎸᎯ ᎠᎴ ᎾᏍᏉ ᎠᎾᎵᏅᏟ ᏄᏂᎪᎸᎾ ᏂᎨᎬᏁᎸ, ᎾᏍᎩ ᏕᎨᏥᎸ ᎾᏍᎩᏯ ᎤᏅᏒ ᏂᎨᎬᏁᎸᎢ.


text:
ᎠᎴ ᏑᏓᎵᏁ ᎠᏍᏚᎲ ᎤᏍᏚᎢᏒ ᏕᏥᎦᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎦᏙᎯ ᎤᏣᏘ ᎤᎵᏖᎸᏅᎩ; ᎠᎴ ᏅᏙ ᎢᎦ-ᎡᎯ ᎬᎿᎨ ᏄᎵᏖᎸᏅᎩ ᎾᏍᎩᏯ ᎤᏏᏕᏅ ᎠᏄᏬ ᎪᏢᏔᏅᎯ, ᏅᏙᏃ ᏒᏃᏱ ᎡᎯ ᎩᎬ ᎾᏍᎩᏯ ᏄᎵᏍᏔᏅᎩ.


text:
ᏃᏈᏏᏃ ᎦᎸᎶᎢ ᎠᏂᎧᎸ ᎤᏂᏅᎪᎣᏒᎩ ᎠᎴ ᎡᎶᎯ ᎤᏂᎳᎨᏯᏛᏨᎩ, ᎾᏍᎩᏯ ᏒᎦᏔ-ᎢᏳᏍᏗ ᏡᎬ ᏨᏂᏅᎪᎠᏍᎪ ᎤᎾᏓᏙᏗᏱ ᏂᎨᏒᎾ ᎨᏒ ᎤᎾᏓᏔᏅᎯ, ᎾᎯᏳ ᎤᏣᏘ ᎦᏃᎸᎥᏍᎬ ᏧᏖᎸᎲᏍᎪᎢ;


text:
ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎡᎶᎯ ᎠᏁᎯ, ᎠᎴ ᎨᏥᎸᏉᏗ ᎠᏂᏍᎦᏯ, ᎠᎴ ᏧᏁᎿᎢ ᎠᏂᏍᎦᏯ, ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᏗᎾᏓᏘᏂᏙᎯ, ᎠᎴ ᏧᎾᎵᏂᎩᏛ ᎠᏂᏍᎦᏯ, ᎠᎴ ᎾᏂᎥ ᏗᎨᏥᎾᏝᎢ, ᎠᎴ ᎾᏂᎥ ᏂᏗᎨᏥᎾᏝᎥᎾ, ᎤᎾᏗᏍᎦᎳᏅᎩ ᏚᏍᏓᎦᎸᎢ, ᎠᎴ ᏅᏲᎯ ᏕᎨᏒ ᏙᏓᎸᎢ;


text:
ᎠᎴ ᏙᏓᎸ ᎠᎴ ᏅᏯ ᎯᎠ ᏂᏚᏂᏪᏎᎸᎩ, ᏍᎩᏯᏐᎥᎦ, ᎠᎴ ᏍᎩᏴᏍᎦᎸᎥᎦ ᎾᏍᎩ ᎣᎩᎪᏩᏛᏗᏱ ᏂᎨᏒᎾ ᎾᏍᎩ Ꮎ ᎦᏍᎩᎸ ᎤᏪᎵ, ᎠᎴ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎣᎦᏢᏔᏍᏗᏱ ᏂᎨᏒᎾ;


text:
ᎣᏂᏃ ᏅᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎥᎦᏥᎪᎥᎩ ᏅᎩ ᏂᏚᏅᏏᏴ ᎡᎶᎯ ᏓᏂᏙᎬᎩ, ᏚᏂᏂᏴᏒᎩ ᎤᏃᎴ ᏅᎩ ᏂᏙᏗᎦᎶᏍᎬ ᎡᎶᎯ, ᎾᏍᎩ ᎤᏃᎸᏗᏱ ᏂᎨᏒᎾ ᎡᎶᎯ, ᎠᎴ ᎠᎺᏉᎯ, ᎠᎴ ᏕᏡᎬᏉ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏗᏙᎯ ᎥᏨᎪᎥᎩ ᏗᎧᎸᎬ ᎢᏗᏢ ᏧᏳᎵᎾᎳᏓᏩᏗᏒᎩ, ᎬᏂᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎤᏓᏰᎸᏙᏗ ᎨᏒ ᎦᏁᎲᎩ; ᎠᎴ ᎠᏍᏓᏯ ᏚᎵᏍᏓᏁᎸᎩ ᏅᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ, ᎾᏍᎩ ᎨᏥᏁᎸᎯ ᏥᎨᏎ ᎪᎱᏍᏗ ᎤᏅᏁᏗᏱ ᎡᎶᎯ ᎠᎴ ᎠᎺᏉᎯ,


text:
ᏧᏓ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ. ᎷᏈᏂ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ. ᎦᏗ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ.


text:
ᎠᏒ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ. ᏁᏈᏓᎵ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ.


text:
ᏏᎻᏯᏂ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎷᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ. ᎵᏫ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ ᎢᏏᎦ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᎳᏅᎩ.


text:
ᏤᏈᎳᏂ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ. ᏦᏩ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᏔᏅᎩ. ᏇᏂ ᎠᏂᎳᏍᏓᎸ ᏗᎪᏣᎴᏛ ᏔᎳᏚ ᎢᏯᎦᏴᎵ ᏕᎨᏥᏰᎸᎳᏅᎩ.


text:
ᎣᏂᏃ ᎢᏴᏛ ᏓᏆᎧᎾᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ, ᎤᏂᏧᏈᏍᏗ ᏴᏫ <n>[ᏫᏕᏥᎪᎥᎩ]</n> ᎾᏍᎩ ᎩᎶ ᏗᎬᏩᏎᎰᎲᏍᏗ ᏂᎨᏒᎾ, ᎾᏍᎩ ᏅᏓᏳᎾᏙᏣᎴᏛ ᎾᏂᎥ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ, ᎠᎴ ᎪᎱᏍᏗ ᏗᎾᏓᏛᎿ ᎨᏒᎢ, ᎠᎴ ᏴᏫ ᏓᏁᏩᏗᏒᎢ ᎠᎴ ᏧᏓᎴᏅᏛ ᏗᏂᏬᏂᏍᎩ ᎨᏒᎢ, ᎠᏂᏙᎾᎥᎩ ᎦᏍᎩᎸ ᎢᎬᏱᏗᏢ, ᎠᎴ ᎤᏃᏕᎾ ᎠᎩᎾ ᏄᏛᏅ ᎢᎬᏱᏗᏢ, ᏧᏁᎬ ᏚᎾᏄᏩᎥᎩ, ᎠᎴ ᏗᏂᏁᎲᎩ ᏧᏪᏲᏔ ᏧᎦᏄᏓᏅᎯᏛ;


text:
ᎠᎴ ᏂᎦᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎦᏍᎩᎸ ᏚᎾᏚᏫᏍᏛᎩ ᏓᏂᏙᎬᎩ, ᎠᎴ ᏧᎾᏛᏐᏅᎯ ᎠᎴ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᏄᎾᏛᏅᎢ, ᎠᎴ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᏄᎾᏛᏅᎢ, ᎠᎴ ᎦᏍᎩᎸ ᎢᎬᏱᏗᏢ ᏚᎾᎵᏯᏍᏚᏅᎩ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᎾᏓᏙᎵᏍᏓᏁᎸᎩ;


text:
ᎯᎠ ᎾᏂᏪᏍᎬᎩ, ᎡᎺᏅ; ᎣᏍᏛ ᎡᏣᏁᎢᏍᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎡᏣᎸᏉᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎯᎦᏔᎾᎢᏳ ᎨᏒᎢ, ᎠᎴ ᎡᏣᎵᎮᎵᏤᏗ ᎨᏒᎢ, ᎠᎴ ᎡᏣᎸᏉᏗᏳ ᎨᏒᎢ, ᎠᎴ ᏣᎵᏂᎩ-ᏗᏳ ᎨᏒᎢ, ᎠᎴ ᏣᎵᏂᎪᎯᏍᏗ ᎨᏒᎢ, ᏣᏤᎵ ᎨᏎᏍᏗ ᏍᎩᏯᏁᎳᏅᎯ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸᎢ. ᎡᎺᏅ.


text:
ᎯᎠᏃ ᏅᏥᏪᏎᎸᎩ, ᏣᎬᏫᏳᎯ ᏂᎯ ᎯᎦᏔᎭ. ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎯᎠᏍᎩᏂ Ꮎ ᎤᏣᏘ ᎠᎩᎵᏯ ᎨᏒ ᏅᏓᏳᏂᎶᏒᎯ, ᎠᎴ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᎩᎬᏱ ᏧᏅᎩᎶᎥᎯ ᏧᎾᏁᏬ ᎠᎴ ᏧᏁᎬ ᎢᏧᏅᏁᎸᎯ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎦᏍᎩᎸ ᎢᎬᏱᏗᏢ ᏄᎾᏛᏅ, ᎠᎴ ᎪᎱᏍᏗ ᎬᏩᏛᏁᎭ ᎤᏤᎵ ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎢᎦ ᎠᎴ ᎡᏃᏱ ᏗᎬᏩᏜᏍᏗ; ᎠᎴ ᎾᏍᎩ Ꮎ ᎦᏍᎩᎸ ᎤᏬᎵ ᎠᏁᎲ ᎡᎮᏍᏗ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏗᏙᎯ ᎤᎷᏨᎩ ᎠᎴ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎤᎴᏅᎩ, ᎠᏰᎲᎩ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎠᏜ ᎦᏩᏒᎩ ᎠᎪᎲᏍᏙᏗᏱ; ᎤᏣᏘᏃ ᎠᏥᏁᎸᎩ ᎠᏜ ᎦᏩᏒᎩ ᎾᏍᎩ ᎤᎵᏍᎪᎸᏙᏗᏱ ᎤᏠᏯᏍᏙᏗᏱ ᎠᎾᏓᏙᎵᏍᏗᏍᎬ ᏂᎦᏛ ᎤᎾᏓᏅᏘ, ᎾᎿ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎦᏍᏗᎸ ᎢᎬᏱᏗᏢ ᏥᎦᎧᎭ.


text:
ᏗᎧᎿᏩᏗᏙᎯᏃ ᎠᏜ ᎦᏩᏒᎩ ᎠᎪᎲᏍᏙᏗᏱ ᎤᎩᏒᎩ, ᎠᎴ ᎠᏥᎸ ᎤᎧᎵ-ᎢᏍᏔᏅᎩ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎠᏞᏛ, ᎠᎴ ᎡᎶᎯ ᏭᏗᏅᏒᎩ; ᏚᏃᏴᎳᏒᎩᏃ, ᎠᎴ ᎤᏴᏓᏆᎶᎥᎩ, ᎠᎴ ᎠᎾᎦᎵᏍᎬᎩ, ᎠᎴ ᎡᎶᎯ ᎤᎵᏖᎸᏅᎩ.


text:
ᎢᎬᏱᏱ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏤᎷᎯᏒᎩ, ᎠᎴ ᎤᎨᎲ ᏔᏅᏒᎩ ᎠᏥᎸ ᎠᎴ ᎤᏁᏍᏓᎳ ᎩᎬ ᎤᏓᏑᏱ ᎨᏒᎩ, ᎠᎴ ᎡᎶᎯ ᏫᏕᎨᎦᏗᏅᏒᎩ, ᎠᎴ ᏕᏡᎬ ᏦᎢ ᎢᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏚᎪᏅᎩ, ᎠᎴ ᏂᎦᏛ ᎢᏤ ᎧᏁᏍᎦ ᎤᎪᏅᎩ.


text:
ᎠᎴ ᏦᎢ ᎢᎨᏥᏛᎯ ᎨᏒ ᎾᏍᎩ ᎨᏒᏁᎳᏅᎯ ᎨᏒ ᎠᎺᏉᎯ ᎠᏁᎲᎢ ᎠᎴ ᏗᏅᏃᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏂᏨᎯ ᏚᏂᎵᏬᏨᎩ; ᎠᎴ ᏥᏳ ᏧᏛᎾ ᏦᎢ ᎢᏗᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏚᏲᏨᎩ.


text:
ᏦᎢᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏤᎷᎯᏒᎩ, ᎤᏣᏘᏃ ᎡᏆ ᏃᏈᏏ ᎤᏬᎭᏒᎩ ᎦᎸᎳᏗ ᏗᏳᏓᏅᎩ, ᎠᏨᏍᏙᏗ ᏣᏓᏪᎵᎩᏍᎪ ᎾᏍᎩᏯᎢ, ᎡᏉᏂᏃ ᏚᏪᏴ ᏦᎢ ᎢᏗᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏚᏥᏍᏠᏨᎩ, ᎠᎴ ᎠᎺ ᏕᎦᏄᎪᎬ ᏚᏥᏍᏠᏨᎩ.


text:
ᎾᏍᎩᏃ Ꮎ ᏃᏈᏏ ᎤᏴᏍᏗ ᎦᏙᎥ; ᏦᎢᏃ ᎢᏗᎦᏛᎯ ᎨᏒ ᎡᏉᏂ ᏚᏪᏴ ᎾᏍᎩ ᏌᏉᎢᏳᏪᏨᎯ ᎤᏴᏍᏗ ᏂᏚᎵᏍᏔᏅᎩ; ᎠᎴ ᎤᏂᏣᏘ ᏴᏫ ᎠᎹ ᎤᎾᏗᏔᎲ ᏚᏂᏲᎱᏒᎩ, ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎠᎹ ᎤᏴᏍᏗ ᏂᏚᎵᏍᏔᏅᎢ.


text:
ᏅᎩᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏤᎷᎯᏒᎩ, ᏅᏙᏃ ᎢᎦ ᎡᎯ ᏦᎢ ᎢᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᎤᏩᏂᎸᎩ, ᎠᎴ ᏦᎢ ᎢᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏅᏙ ᏒᏃᏱ ᎡᎯ ᎤᏩᏂᎸᎩ, ᎠᎴ ᏦᎢ ᎢᏗᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏃᏈᏏ ᎠᏂᎧᎸ ᏚᏩᏂᎸᎩ; ᎾᏍᎩᏃ ᏦᎢ ᎢᏗᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏚᎵᏏᎲᏒᎩ, ᎠᎴ ᎢᎦ ᏦᎢ ᎢᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᎥᏝ ᏯᎦᎵᏍᎨᎢ, ᎠᎴ ᏒᏃᏱ ᏦᎢ ᎢᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᎾᏍᏉ ᎥᏝ ᏯᎦᎵᏍᎨᎢ.


text:
ᎠᎴ ᏓᏆᎧᎾᏅᎩ, ᎠᎴ ᎠᏆᏛᎦᏅᎩ ᏗᎧᎿᏩᏗᏙᎯ ᎦᎸᎶᎢ ᎠᏰᎵ ᎦᏃᎯᎵᏒᎩ ᎠᏍᏓᏯ ᎤᏪᎷᎬᎩ ᎯᎠ ᏂᎦᏪᏍᎬᎩ, ᎤᏲᎢᏳ, ᎤᏲᎢᏳ ᎤᏲᎢᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎡᎶᎯ ᏓᏁᏩᏗᏒᎢ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᏗᏐᎢ ᎠᏤᎷᎩ ᏗᏤᎷᎯᏍᏗ ᎨᏒ ᎾᏍᎩ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏦᎢ ᎢᏯᏂᏛ ᏓᏂᏁᎲᎢ, ᎠᏏ ᏧᏂᏤᎷᎯᏍᏗ ᏥᎩ.


text:
ᎯᏍᎩᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏤᎷᎯᏒᎩ, ᎠᎩᎪᎲᎩᏃ ᏃᏈᏏ ᎦᎸᎶᎢ ᏓᏳᏓᎴᏅᎩ ᎡᎶᎯᏃ ᎤᏬᏥᎸᎩ; ᎠᎴ ᎾᏍᎩ <n>[ᏃᏈᏏ]</n> ᎠᏥᏕᎸᎩ ᎠᏍᏚᎢᏍᏗ ᎾᏍᎩ ᏫᎾᏍᏛᎾᎠᏔᎴᏒ ᎠᏍᏚᎢᏍᏙᏗ.


text:
ᎠᎴ ᏫᎾᏍᏛᎾ ᎠᏔᎴᏒ ᎤᏍᏚᎢᏒᎩ, ᏧᎦᏒᏍᏗᏃ ᎾᎿ ᎠᏔᎴᏒ ᏓᏳᎵᏌᎳᏓᏅᎩ, ᎾᏍᎩᏯ ᎡᏆ ᏔᎷᎩᏍᎩ ᎬᎾᏬᏙᏗᏱ ᏥᏚᎦᏒᏍᏙᎢ; ᏅᏙᏃ ᎢᎦ ᎡᎯ ᎠᎴ ᎦᏃᎴᏍᎬ ᎤᏜᏅᏛ ᏚᎵᏏᎲᏒᎩ ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᏧᎦᏒᏍᏗ ᎠᏔᎴᏒ ᏙᏗᎴᎲᏍᎬᎢ.


text:
ᎠᎴ ᎨᏥᏁᏤᎸᎩ ᎪᎱᏍᏗ ᎤᏅᏁᏗᏱ ᏂᎨᏒᎾ ᎧᏁᏍᎦ ᎡᎶᎯ ᎤᏰᎬᎢ, ᎠᎴ ᏂᎦᎥᏉᎪᎱᏍᏗ ᎢᏤ ᎤᏴᎾᎥᎢ, ᎠᎴ ᏂᎦᎥᏉ ᏕᏡᎬᎢ; ᎾᏍᎩᏉᏍᎩᏂ Ꮎ ᎤᏅᏒ ᏴᏫ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎤᏓᏰᎸᏙᏗ ᎨᏒ ᏄᏂᏰᎸᏒᎾ ᏗᏂᎬᏓᎨᏂ.


text:
ᎠᎴ ᎾᏍᎩ ᎨᏥᏁᎸᎩ ᎾᏍᎩ ᏧᏂᎯᏍᏗᏱ ᏂᎨᏒᎾ ᎨᏒᎢ, ᏧᏂᎩᎸᏗᏉᏍᎩᏂ ᎯᏍᎩ ᎢᏯᏅᏙ; ᎤᎾᏓᎩᎸᏗᏃ ᎨᏒ ᎦᏙᎬ ᎠᏓᏨᏯᏍᏗᏍᎩ ᎤᎾᏓᎩᎸᏗ ᎨᏒ ᎾᏍᎩᏯ ᎨᏒᎩ ᏴᎾ ᎿᏉ ᎤᏪᏨᏯ.


text:
ᎥᎴᏃ ᎤᎾᏙᏢᏒ ᎾᏍᎩᏯ ᎨᏒᎩ, ᏐᏈᎵ ᏓᏅᏩ ᎤᏁᏅᏍᏗᏱ ᏥᎨᎦᏛᏅᎢᏍᏙᎢ; ᏚᏄᎵᏍᏚᎸᎩᏃ ᏗᎵᏍᏚᎶ ᎠᏕᎸᏓᎶᏁᎨ ᏗᎪᏢᏔᏅᎯ ᎾᏍᎩᏯᎢ, ᏚᎾᎧᏛᏃ ᏴᏫ ᏚᎾᎧᏛ ᎾᏍᎩᏯ ᎨᏒᎩ.


text:
ᎠᎴ ᎤᎬᏫᏳᎯ ᎤᏂᎧᎲᎩ ᎾᏍᎩ ᏗᎧᎿᏩᏗᏙᎯ ᏥᎩ ᎾᏍᎩ ᏫᎾᏍᏛᎾ ᎠᏔᎴᏒᎢ, ᎾᏍᎩᏃ ᎠᏂᏈᎷ ᎤᏂᏬᏂᎯᏍᏗ ᎠᏆᏙᎾ ᏚᏙᎥ, ᎠᏂᎪᎢᏍᎩᏂ ᎤᏂᏬᏂᎯᏍᏗ ᎨᏒ ᎠᏉᎵᏯᏂ ᏚᏙᎥ.


text:
ᏑᏓᎵᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏤᎷᎯᏒᎩ, ᎩᎶᏃ ᎧᏁᎬ ᎠᏆᏛᎦᏅᎩ ᏛᏓᎴᎲᏍᎬᎩ ᏅᎩ ᏂᏕᎤᎷᎬ ᎠᏕᎸᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎾᏍᎩ ᎤᏁᎳᏅᎯ ᏄᏛᏅ ᎢᎬᏱᏗᏢ ᏥᎦᎧᎭ,


text:
ᎠᎴ ᎾᏍᎩ Ꮎ ᏅᎩ ᎢᏯᏂᏛ ᏗᎾᎧᎿᏩᏗᏙᎯ ᏕᎨᎦᎸᏒᎲᎩ, ᎾᏍᎩ ᎨᎦᏛᏅᎢᏍᏔᏅᎩ ᏌᏉ ᏅᏙ ᎢᏳᏟᎶᏛ ᎢᎪᎯᏛ ᎨᏒᎢ, ᎠᎴ ᏏᎦ ᎨᏒ, ᎠᎴ ᏏᏅᏙ ᎨᏒ, ᎠᎴ ᏑᏕᏘᏴᏛ ᎨᏒᎢ, ᎾᏍᎩ ᏧᏂᎯᏍᏗᏱ ᏦᎢ ᎢᎨᏥᏛᎯ ᏴᏫ ᎾᏍᎩ ᏌᏉ ᎢᏳᏂᏨᎯ ᎨᏒᎢ.


text:
ᎾᏍᎩᏃ ᎯᎠ ᏄᎾᏍᏛᎩ ᎥᎦᏥᎪᎥᎩ ᏐᏈᎵ ᎠᏆᏁᎳᏫᏎᎲᎢ, ᎠᎴ ᎾᏍᎩ ᎾᎿ ᏧᎾᎩᎵ, ᏮᎾᏓᏁᏣᏍᏚᎸᎩ ᎠᏥᎸ ᎠᎴ ᏅᏯ ᏤᏏᏂ ᏧᏐᎢᏛ, ᎠᎴ ᏌᎪᏂᎨ ᎠᏓᏪᎳᎩᏍᎩ ᏗᎪᏢᏔᏅᎯ. ᏗᏂᏍᎪᎵᏃ ᏐᏈᎵ ᎠᏓᏥ ᎤᏂᏃᏕᏅ ᏥᏓᏂᏍᎫᏓᏛ ᎾᏍᎩᏯ ᎨᏒᎩ; ᏗᏂᎰᎵᏃ ᏓᎦᏄᎪᎬᎩ ᎠᏥᎸ ᎠᎴ ᏧᎦᏒᏍᏗ ᎠᎴ ᏌᎪᏂᎨ ᎠᏓᏪᎳᎩᏍᎩ.


text:
ᎯᎠ ᎾᏍᎩ ᏦᎢ ᎢᏳᏓᎴᎩ ᎨᏒ ᏓᏅᏗᏍᎬ, ᏴᏫ ᏦᎢ ᎢᎨᏥᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏂᏨᎯ ᏕᎨᏥᎸᎩ, ᎾᏍᎩ ᎠᏥᎸ ᎬᏗ, ᎠᎴ ᏧᎦᏒᏍᏗ ᎬᏗ, ᎠᎴ ᏌᎪᏂᎨ ᎠᏓᏪᎳᎩᏍᎩ ᎬᏗ, ᎾᏍᎩ ᏗᏂᎰᎵ ᏥᏙᏓᎦᏄᎪᎬᎢ.


text:
ᎪᎱᏍᏗᏰᏃ ᎤᎾᏓᏛᏁᏗᏱ ᏗᏂᎰᎵ ᎠᎴ ᏓᏂᏂᏓᏛ ᏛᏓᎴᎲᏍᎬᎩ; ᏓᏂᏂᏓᏛᏰᏃ ᎢᎾᏛ ᏥᏄᏍᏗ ᎾᏍᎩᏯ ᎨᏒᎩ, ᎠᎴ ᏓᏂᏍᎫᏓᏛᎩ, ᎠᎴ ᎾᏍᎩ ᏓᏅᏗᏍᎬᎩ ᎪᎱᏍᏗ ᎠᎾᏓᏛᏁᎲᎩ.


text:
ᎠᎴ ᎠᏂᏐᎢ ᏴᏫ ᎾᏍᎩ ᎤᏕᏯᏙᏗ ᎨᏒ ᏧᏂᎸᎯ ᏂᎨᏒᎾ, ᎠᏏᏉ ᎥᏝ ᏱᏓᏂᏁᏟᏴᏍᎨ ᏚᎾᏓᏅᏛ ᎤᏲ ᏯᏂᏰᎸᏍᎨ ᏧᏃᏰᏂ ᎬᏗ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ, ᎾᏍᎩ ᎠᏂᏍᎩᎾ ᏧᎾᏓᏙᎵᏍᏓᏁᏗᏱ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᎠᏕᎸ ᏓᎶᏂᎨ ᏗᎪᏢᏔᏅᎯ, ᎠᎴ ᎠᏕᎸ ᎤᏁᎬ, ᎠᎴ ᎥᏣᏱ, ᎠᎴ ᏅᏯ, ᎠᎴ ᎠᏓ ᏗᎪᏢᏔᏅᎯ; ᎾᏍᎩ ᎬᏩᏂᎪᏩᏗ ᏂᎨᏒᎾ ᏥᎩ, ᎠᎴ ᎬᏩᎾᏛᎪᏗ ᏂᎨᏒᎾ ᏥᎩ, ᎠᎴ ᎬᏩᏁᏓᏍᏗ ᏂᎨᏒᎾ ᏥᎩ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᎤᎵᏂᎩᏛ ᏗᎧᎿᏩᏗᏙᎯ ᎥᏥᎪᎥᎩ ᎦᎸᎳᏗ ᏓᏳᏠᎠᏒᎩ, ᎤᎶᎩᎸ ᎤᏄᏬᏍᏛᎩ; ᎠᎴ ᎠᏍᎪᎵ ᎤᏅᎪᎳᏛᎩ, ᎠᎴ ᎤᎧᏛ ᏅᏙ ᎢᎦ ᎡᎯ ᎾᏍᎩᏯ ᎨᏒᎩ, ᏧᎳᏏᏕᏂᏃ ᏗᎦᎫᏍᏗᏗ ᎠᏥᎸ ᏗᎪᏢᏔᏅᎯ ᎾᏍᎩᏯ ᎨᏒᎩ.


text:
ᎠᎴ ᎦᎵᏉᎩ ᎠᏂᏴᏓᏆᎶᏍᎩ ᎤᏂᏴᏓᏆᎶᎥ, ᏓᎪᏪᎳᏂᏒᎩ; ᎠᏆᏛᎦᏅᎩᏃ ᎧᏁᎬ ᎦᎸᎳᏗ ᏓᏳᎶᏒᎩ ᎯᎠ ᏅᏛᎩᏪᏎᎲᎩ, ᏘᏍᏚᎲᎦᏉ ᎾᏍᎩ ᎦᎵᏉᎩ ᎠᏂᏴᏓᏆᏍᎩ ᏄᏂᏪᏒᎢ, ᎠᎴ ᏞᏍᏗ ᏦᏪᎳᏅᎩ.


text:
ᎠᎴ ᎤᏁᎢᏍᏔᏅᎩ, ᎾᏍᎩ Ꮎ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸ ᏤᎭ, ᎾᏍᎩ ᎦᎸᎶᎢ ᎤᏬᏢᏅᎯ ᏥᎩ, ᎠᎴ ᎾᏍᎩ ᎾᎿ ᏤᎿᎠ, ᎠᎴ ᎡᎶᎯ, ᎠᎴ ᎾᏍᎩ ᎾᎿ ᏤᎿᎠ, ᎠᎴ ᎠᎺᏉᎯ, ᎠᎴ ᎾᏍᎩ ᎾᎿ ᏤᎿᎠ, ᎥᏝ ᎿᏉ ᎤᏟ ᎢᎪᎯᏛ ᏱᎪᎯᏗᏏᏎᏍᏗ ᎤᏛᏅᎩ.


text:
ᎦᎵᏉᎩᏁᏍᎩᏂ ᏗᎧᎿᏩᏗᏙᎯ ᎧᏁᏨᎭ ᎢᏳᎢ, ᎿᏉ ᎠᎴᏅᎲᎭ ᎠᏤᎷᎯᏒᎭ, ᎤᏕᎵᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᎤᎵᏰᎢᎶᎯᏍᏗ ᎨᏎᏍᏗ, ᎾᏍᎩᏯ ᎬᏂᎨᏒ ᏂᏚᏩᏁᎸ ᏧᏅᏏᏓᏍᏗ ᎠᎾᏙᎴᎰᏍᎩ.


text:
ᎧᏁᎬᏃ ᎠᏆᏛᎦᏅᎯ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ ᏔᎵᏁ ᎠᎩᏁᏤᎸᎩ, ᎠᎴ ᎯᎠ ᏄᏪᏒᎩ, ᎮᎾ, ᎠᎴ ᏫᎾᎩ ᎤᏍᏗ ᎪᏪᎵ ᎠᏍᏚᎢᏛ ᏧᏒᎦᎸ ᏗᎧᎿᏩᏗᏙᎯ ᏥᎦᏙᎦ ᏥᏚᎳᏍᎦ ᎠᎺᏉᎯ ᎠᎴ ᎦᏙᎯ.


text:
ᎠᏇᏅᏒᎩᏃ ᏗᎧᎿᏩᏗᏙᎯ ᏗᎦᏙᎬᎢ, ᎠᎴ ᎯᎠ ᏅᏥᏪᏎᎸᎩ, ᏍᎩᏅᎥᏏ Ꮎ ᎤᏍᏗ ᎪᏪᎵ. ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎯᎾᎩ ᎠᎴ ᎯᏯᎣᎾ; ᏣᏍᏉᎵᏱᏂ ᏩᏚᎵᏏ ᏥᏄᎦᎾᎯ ᎢᏳᎦᎾᏍᏛ ᏅᏓᏨᏁᎵ.


text:
ᎠᎴ ᎦᎾᏍᏓ ᎥᎩᏕᎸᎩ ᎠᏙᎳᏅᏍᏗ ᎾᏍᎩᏯᎢ; ᏗᎧᎿᎦᏗᏙᎯᏃ ᎤᎴᏅᎩ, ᎯᎠ ᏄᏪᏒᎩ, ᏔᎴᎲᎦ, ᎠᎴ ᎭᏢᏅᎩ, ᎯᎠ ᏄᏪᏒᎩ, ᏔᎴᎲᎦ, ᎠᎴ ᎭᏟᎶᏣ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎠᎴ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎠᎾᏓᏙᎵᏍᏗᏍᎩ ᏥᎩ ᎾᎿᏂ.


text:
ᎤᏜᏅᏛᏍᎩᏂ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏙᏱᏗᏢ ᏥᎪᏢᎭ, ᎯᏃᎯᏴᎭ, ᎠᎴ ᏞᏍᏗ ᏣᏟᎶᎥᎩ, ᏧᎾᏓᎴᏅᏛᏰᏃ ᏴᏫ ᎨᏥᏁᎸᎯ ᎾᏍᎩ; ᎠᎴ ᎦᎸᏉᏗᏳ ᎦᏚᎲ ᎤᎾᎳᏍᏓᎡᏗ ᎨᏎᏍᏗ ᏅᎦᏍᎪᎯ ᏔᎵᎦᎵ ᎢᏯᏅᏙ.


text:
ᎢᏳᏃ ᎩᎶ ᎪᎱᏍᏗ ᏙᎬᏁᎮᏍᏗ ᎾᏍᎩ, ᎠᏥᎸ ᏗᏂᎰᎵ ᏗᎦᏄᎪᎨᏍᏗ, ᎠᎴ ᎤᏂᏛᏗᏍᎨᏍᏗ ᎬᏩᏂᏍᎦᎩ; ᎢᏳ ᎠᎴ ᎪᎱᏍᏗ ᏧᏩᏁᏗᏱ ᎤᏚᎵᏍᎨᏍᏗ, ᎾᏍᎩ ᎢᏯᎬᏁᏗ ᎠᏥᎢᏍᏗ ᎨᏎᏍᏗ.


text:
ᎯᎠ ᎾᏍᎩ ᎤᏂᎭ ᎦᎸᎳᏗ ᎤᏂᏍᏚᏗᏱ, ᎾᏍᎩ ᎤᎦᏅᏗᏱ ᏂᎨᏒᎾ ᎠᎾᏙᎡᎰᏍᎬ ᎢᎪᎯᏛ; ᎠᎴ ᎤᏂᎭ ᎠᎹᏱ ᏚᏪᏯᏗᏒ ᎩᎬ ᎢᏧᏅᏁᏗᏱ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏅᏂᏐᏗᏱ ᏂᎦᎥᏉ ᎤᏕᏯᏙᏗ ᎨᏒ ᎡᎶᎯ ᎤᎷᏤᏗᏱ ᎢᎦᎢᏉ ᎠᏁᎵᏍᎬᎢ.


text:
ᎢᎦᏛᏃ ᎾᏍᎩ Ꮎ ᏴᏫ, ᎠᎴ ᎪᎱᏍᏗ ᏗᎾᏓᏛᎿ ᎨᏒᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᏗᏂᏬᏂᏍᎩ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏂᏩᏗᏒᎢ, ᏓᏂᎪᏩᏗᏍᎨᏍᏗ ᏧᏂᏲᎱᏒᎯ ᏗᏂᏰᎸᎢ ᏦᎢ ᎢᎦ ᏅᎩᏁᏃ ᎠᏰᎵ, ᎥᏝᏃ ᎤᏁᎳᎩ ᎤᏁᎵᏍᏗ ᏱᎨᏎᏍᏗ ᏧᏂᏲᎱᏒᎯ ᏗᏂᏰᎸ ᏗᏓᏂᏐᏗᏱ ᏧᏂᏅᏗᏱ.


text:
ᎿᏃ ᎡᎶᎯ ᎠᏁᎯ ᏛᎾᎵᎮᎵᏥ ᎾᏍᎩ ᎨᏒ ᏅᏗᎦᏍᏙᏗᏍᎨᏍᏗ, ᎠᎴ ᎣᏍᏛ ᎤᎾᏓᏅᏔᏩᏕᎨᏍᏗ, ᎠᎴ ᎪᎱᏍᏗ ᏓᎾᏓᏁᎸᎥᏍᎨᏍᏗ; ᎯᎠᏰᏃ ᎠᏂᏔᎵ ᎠᎾᏙᎴᎰᏍᎩ ᎬᏩᏂᎩᎵᏲᎢᏍᏔᏅᎩ ᎾᏍᎩ Ꮎ ᎡᎶᎯ ᎠᏁᎯ.


text:
ᎤᎾᏛᎦᏅᎩᏃ ᎠᏍᏓᏯ ᏗᎧᏁᎬ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ, ᎯᎠ ᏄᏂᏪᏎᎲᎢ, ᎡᏍᏓᎩᎳᏩ ᎠᏂ ᎢᏍᏗᎷᎩ. ᎦᎸᎳᏗᏃ ᏭᏂᎶᏒᎩ ᎤᎶᎩᎸ ᎤᎾᎵᏌᎳᏓᏅᎩ. ᎠᎴ ᎬᏩᏂᏍᎦᎩ ᎬᏩᏂᎪᎲᎩ.


text:
ᎾᎯᏳᏉᏃ ᎧᎳᏩᏗᏒ ᎤᏣᏘ ᎤᎵᏖᎸᏅᎩ ᎦᏙᎯ, ᎠᏍᎪᎯᏃ ᎢᎦᏛᎯ ᎨᏒ ᎦᏚᎲ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᎤᏲᏨᎩ, ᎦᏙᎯᏃ ᎠᎵᏖᎸᎲᏍᎬ ᎢᏳᎢ ᎦᎸᏉᎩ ᎢᏯᎦᏴᎵ ᏴᏫ ᏙᎨᏥᎸᎩ; ᎤᎾᎵᏃᎯᏴᎯᏃ ᎤᏂᏍᎦᎸᎩ, ᎠᎴ ᎦᎸᎳᏗ ᎡᎯ ᎤᏁᎳᏅᎯ ᎤᏂᎸᏉᏔᏅᎩ.


text:
ᎦᎵᏉᎩᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏤᎷᎯᏒᎩ; ᎠᎴ ᎦᎸᎳᏗ ᎢᏴᏛ ᎠᏍᏓᏯ ᏗᎧᏁᎬᎩ ᎩᎶᎢ, ᎯᎠ ᏅᏓᎦᏪᏍᎬᎩ, ᎠᏰᎵ ᏕᎪᏢᏩᏗᏒ ᎠᏂ ᎡᎶᎯ, ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎤᏤᎵ ᎦᎶᏁᏛ ᏧᎾᏤᎵ ᏂᏕᎦᎵᏍᏓ; ᎠᎴ ᎾᏍᎩ Ꮎ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸ ᎤᎬᏫᏳᎯ ᎨᏎᏍᏗ.


text:
ᎯᎠ ᏄᏂᏪᏒᎩ, ᎢᏨᏯᎵᏒᎵᏤᎭ, ᏂᎯ ᏣᎬᏫᏳᎯ ᏣᏁᎳᏅᎯ, ᏫᎾᏍᏛᎾ ᏣᎵᏂᎩᏛ, ᏂᎯ ᎾᏍᎩ ᏤᎭ, ᎠᎴ ᎾᏍᎩ ᏤᎲᎩ, ᎠᎴ ᎾᏍᎩ ᏤᎮᏍᏗ; ᏅᏗᎦᎵᏍᏙᏗᎭ ᏥᏣᎩᏒ ᎤᏣᏘ ᏣᎵᏂᎩᏗᏳ ᎨᏒᎢ, ᎠᎴ ᏣᎬᏫᏳᎯ ᏥᏂᏣᎵᏍᏔᏅ.


text:
ᎤᎾᏓᏤᎵᏛᏃ ᏴᏫ ᏓᎾᏩᏗᏒ ᎤᏂᎿᎸᏨᎩ, ᎠᎴ ᏂᎯ ᎾᎯᏳ ᏣᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏍᏆᎸᎲ, ᎠᎴ ᎾᎯᏳ ᏧᏂᏲᎱᏒᎯ ᏗᎨᎫᎪᏓᏁᏗ ᎨᏒᎢ, ᎠᎴ ᎾᏍᎩ ᏔᎫᏴᎡᏗ ᎨᏒ ᏘᏅᏏᏓᏍᏗ ᎠᎾᏙᎴᎰᏍᎩ, ᎠᎴ ᎤᎾᏓᏅᏘ, ᎠᎴ ᎾᏍᎩ Ꮎ ᏕᏣᏙᎥ ᎠᏂᎾᏰᏍᎩ, ᏧᎾᏍᏗ ᎠᎴ ᎾᏍᏉ ᏧᎾᏛᎾ; ᎠᎴ ᏗᏛᏙᏗᏱ ᎾᏍᎩ Ꮎ ᎡᎶᎯ ᎠᏂᏛ ᏗᏍᎩ ᎨᏒᎢ.


text:
ᎤᏁᎳᏅᎯᏃ ᎤᏤᎵ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏓᏳᏂᏍᏚᎢᏒᎩ ᎦᎸᎳᏗ, ᎠᎴ ᏩᎪᏩᏛᏗ ᎨᏒᎩ ᎾᎿ ᎤᏤᎵᏗᎦᎳᏫᎢᏍᏗᏱ ᎦᏁᏌᎢ ᏗᎧᎿᏩᏛᏍᏗ ᏗᎦᎶᏗ; ᎠᎴ ᏚᎾᎦᎸᎲᎩ, ᎠᎴ ᏚᏂᏁᏨᎩ, ᎠᎴ ᏚᏴᏓᏆᎶᎥᎩ, ᎠᎴ ᎪᏙᎯ ᎤᎵᏖᎸᏅᎩ, ᎠᎴ ᎤᏍᎦᏎᏗ ᎤᏁᏐᎠᏒᎩ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᎤᏍᏆᏂᎪᎩ ᎤᎾᏄᎪ ᏨᎩ ᎦᎸᎳᏗ; ᎠᎴ ᎬᏂᏳᏉ ᎤᏣᏅ ᎩᎦᎨ ᎢᎾᏛ <n>[ᏫᏥᎪᎥᎩ,]</n> ᎦᎸᏉᎩ ᏓᏍᎫᏓᏛᎩ, ᎠᎴ ᎠᏍᎪᎯ ᏕᎤᎷ-ᎬᎩ, ᎠᎴ ᎦᎸᏈᎩ ᏚᎵᏍᏚᎸᎩ ᏓᏍᎫᏓᏛᎢ.


text:
ᎦᏂᏓᏛᏃ ᏃᏈᏏ ᎦᎸᎳᏗ ᎠᏂᎧᎸ ᏦᎢ ᎢᏗᎦᏛᎯ ᎨᏒ ᎾᏍᎩ ᏌᏉ ᎢᏳᏪᏨᎯ ᏕᎤ-ᏎᏒᏔᏅᎩ, ᎠᎴ ᎦᏙᎯ ᏫᏚᏗᏅᏒᎩ; ᎢᎾᏛᏃ ᎢᎬᏱᏗᏢ ᎤᎴᏅᎩ ᎠᎨᏴ ᏄᏛᏅᎢ, ᎾᏍᎩ ᎤᎾᏄᎪᏫᏏᏕᎾ <n>[ᎠᏲᎵ]</n> ᎾᏍᎩ ᎤᏕᏃᏅᎯᏉ ᎤᏪᏯᎣᎲᏍᏗᏱ ᎤᏰᎸᏒᎩ.


text:
ᎠᏍᎩᏯᏃ ᎠᏲᎵ ᎤᎾᏄᎪᏫᏒᎩ ᎾᏍᎩ ᎠᏙᎳᏅᏍᏗ ᏔᎷᎩᏍᎩ ᎪᏢᏔᏅᎯ ᎤᏮᏙᏗ ᎨᏒᎩ ᏗᎬᏩᏁᎶᏙᏗᏱ ᎢᏳᏩᏁᏗᏱ ᏂᎦᏛ ᎤᎾᏓᏤᎵᏛ ᏓᏁᏩᏗᏒ ᏴᏫ; ᎾᏍᎩ ᎤᏪᏥ ᎤᎾᎳᏅᏱ ᏩᏥᏅᏍᏔᏅᎩ, ᎠᎴ ᎤᎾᎳᏅᎯ ᎤᏪᏍᎩᎸᎢ.


text:
ᎾᏍᎩᏃ Ꮎ ᎤᏔᏅ ᎢᎾᏛ ᎠᏥᏄᎪᏫᏒᎩ, ᎾᏍᎩ ᎾᎠᎦᏴᎵ ᎢᎾᏛ, ᎠᏍᎩᎾ ᏣᎪᏎᎭ, ᎠᎴ ᏎᏓᏂ, ᎾᏍᎩ ᏥᏕᎦᎶᏄᎮᎭ ᏂᎬᎾᏛ ᎡᎶᎯ <n>[ᎠᏁᎯ;]</n> ᎾᏍᎩ ᏓᏰᏥᏄᎪᏫᏒᎩ ᎡᎶᎯ ᏓᏰᎦᏓᎢᏅᏒᎩ, ᎠᎴ ᎾᏍᎩ ᏧᏤᎵ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎢᏧᎳᎭ ᏓᎨᏥᏄᎪᏫᏒᎩ.


text:
ᎠᏆᏛᎦᏅᎩᏃ ᎠᏍᏓᏯ ᎧᏁᎬ ᎯᎠ ᏅᏗᎦᏪᏍᎬ ᎦᎸᎳᏗ, ᎿᏉ ᎠᎵᏰᎢᎶᎦ ᎠᎵᏍᏕᎸᏙᏗ ᎨᏒ ᎠᎴ ᎤᎵᏂᎩᏛ ᎨᏒᎢ, ᎠᎴ ᎢᎦᏁᎳᏅᎯ ᎾᎿ ᎤᎬᏫᏳᎯ ᎨᏒᎢ, ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᎦᎶᏁᏛ ᎾᏍᎩ ᎤᏤᎵᎦ; ᎢᏓᎵᏅᏟᏰᏃ ᎨᏒ ᎤᏄᎩᏍᏗᏍᎩ ᎡᎳᏗ ᏩᎦᏓᎤᎦ; ᎾᏍᎩ ᏧᏄᎯᏍᏗᏍᎬ ᎢᎦᏁᎳᏅᎯ ᎠᎦᏔᎲᎢ ᎢᎦ ᎠᎴ ᏒᏃᏱ ᏗᎬᏩᏜᏍᏗ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎢᏣᎵᎮᎵᎩ ᏂᎦ ᎦᎸᎶᎢ ᎨᏒᎢ, ᎠᎴ ᏂᎯ ᎾᎿ ᏥᏤᎭ. ᎤᏲᎢᏳ ᎢᏣᎵᏍᏓᏁᏗ ᎡᎶᎯ ᎢᏤᎯ, ᎠᎴ ᎠᎺᏉᎯ ᎢᏤᎯ! ᎠᏍᎩᎾᏰᏃ ᎢᏣᏠᎠᏎᎵᎦ, ᎤᏣᏘ ᎤᏔᎳᏬᏍᎬᎢ ᎠᎦᏔᎭᏰᏃ ᎤᏍᏆᎳᎯᏳ ᎨᏒ ᎠᎦᎵᏍᎪᎸᏓᏁᎸᎢ.


text:
ᎠᎨᏴᏃ ᏔᎵ ᏓᏥᏕᎸᎩ ᎠᏬᏎᎵ ᎤᏔᏅ ᏗᎧᏃᎨ, ᎾᏍᎩ ᎢᎾᎨ ᏭᏃᎯᎸᏍᏙᏗᏱ ᎠᏥᏰᎸᎾᏁᎸᎩ, ᎾᎿ ᎤᏤᎵᎪᎯ ᏗᎨᏒᎢ, ᎾᎿ ᎠᎨᎳᏍᏗᏱ ᏑᏕᏘᏴᏛ, ᎠᎴ ᏔᎵ ᏧᏕᏘᏴᏛ, ᎠᎴ ᎠᏰᎵ ᎢᏳᏕᏘᏴᏛ, ᎾᏍᎩ ᎠᏥᎧᎲᏍᏗᏱ ᎢᎾᏛ ᎠᎦᏔᎲᎢ.


text:
ᎠᎴ ᎢᎾᏛ ᎤᎿᎸᏤᎸ-Ꭹ ᎠᎨᏴ, ᎠᎴ ᏓᎿᏩ ᎢᏧᏩᏁᏗᏱ ᎤᏰᎸᏅᎩ ᎤᎾᎵᏃᎯᏴᎯ ᎾᏍᎩ <n>[ᎠᎨᏴ]</n> ᎤᏁᏢᏔᏅᎯ ᎨᏒᎢ, ᎾᏍᎩ Ꮎ ᎠᏂᏍᏆᏂᎪᏗᏍᎩ ᏗᎧᎿᏩᏛᏍᏗ ᎤᏁᎳᏅᎯ ᏧᏤᎵᎦ, ᎠᎴ ᎤᏂᎯ ᏥᏌ ᎦᎶᏁᏛ ᎤᏤᎵ ᎪᎯᏳᏗᏍᎩ


text:
ᎠᎺᏉᎯᏃ ᎤᎶᏗ ᏃᏳᎯ ᎨᏒ ᎥᏉᎴᏔᏅᎩ, ᎠᎴ ᏅᎩ ᏗᎦᏅᏌᏗ ᏥᎪᎥᎩ ᎠᎺᏉᎯ ᏓᏳᏚᎩᏒᎩ, ᎦᎵᏉᎩ, ᏓᏍᎫᏓᏛᎩ ᎠᎴ ᎠᏍᎪᎯ ᏚᎷᎬᎩ, ᏚᎷᎬᏃ ᎠᏍᎪᎯ ᏚᎵᏍᏚᎸᎩ, ᏓᏍᎫᏓᏛᏃ ᎤᏁᎳᏅᎯ ᏚᏙᎥ ᎠᎺᏢᎢᏍᏙᏗ ᎨᏒ ᎪᏪᎸᎩ.


text:
ᎿᏃ ᏅᎩ ᏗᎦᏅᏌᏗ ᏥᎪᎥᎯ ᏢᏓᏥᏧᎶᎸᏗ ᎾᏍᎩᏯ ᎨᏒᎩ, ᎠᎰᎵᏃ ᏢᏓᏥ ᎤᏃᏕᏅ ᎠᎰᎵ ᏥᏄᏍᏙ ᎾᏍᎩᏯ ᎨᏒᎩ, ᎢᎾᏛᏃ ᎤᏁᎸᎩ ᎤᏤᎵ ᎤᎵᏂᎬᎬᎢ ᎠᎴ ᎤᏤᎵ ᎤᏪᏗᏱ ᎨᏒᎢ, ᎠᎴ ᎤᏣᏗ ᎢᏳᏛᏁᎵᏓᏍᏗᏱ ᎤᎵᏍᎪᎸᏓᏁᎸᎩ.


text:
ᏌᏉᏃ ᎠᏍᎫᏓᏛ ᎠᎩᎪᎲᎩ ᎬᏩᏲᎱᎯᏍᏗ ᎢᏴᏛ ᏣᏥᏐᏅᏃ ᏓᏤᎸᎩ; ᎠᎴ ᎾᏍᎩ ᎬᏩᏲᎱᎯᏍᏗ ᎢᏴᏛ ᎠᏥᏐᏅᏅ ᎤᏗᏩᏒᎯ ᎨᏒᎩ; ᎠᎴ ᏂᎬᎾᏛ ᎡᎶᎯ <n>[ᎠᏁᎯ]</n> ᎠᏂᏍᏆᏂᎪᏍᎬᎩ <n>[ᎠᎴ]</n> ᎠᏂᏍᏓᏩᏗᏒᎩ ᎾᏍᎩ ᎾᏅᎩ-ᏗᎦᏅᏌᏗ.


text:
ᎠᎴ ᎤᎾᏓᏙᎵᏍᏓᏁᎸᎩ ᎢᎾᏛ ᎾᏍᎩ ᏅᎩ-ᏓᎦᏅᏌᏗ ᎤᎵᏂᎬᎬ ᎤᏁᎸᎯ ᎨᏒᎢ; ᎠᎴ ᎾᏍᎩ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎤᎾᏓᏙᎵᏍᏓᏁᎸᎩ, ᎯᎠ ᎾᏁᏪᏍᎬᎩ, ᎦᎪ ᏅᎩ-ᏗᎦᏅᏌᏗ ᏄᏍᏛ ᎾᏍᎩᏯ ᏄᏍᏗ? ᎦᎪ ᏰᎵ ᎾᏍᎩ ᏓᎿᏩ ᏱᎾᏅᎦ?


text:
ᎠᎴ ᎾᏍᎩ ᎠᏥᏁᎸᎩ ᎤᎾᏓᏅᏘ ᏓᎿᏩ ᎢᏳᏅᏁᏗᏱ, ᎠᎴ ᎾᏍᎩ ᏧᏎᎪᎩᏍᏗᏱ; ᎠᎴ ᎠᏥᏁᎸᎩ ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᏗᎬᏩᏁᎶᏙᏗᏱ ᎾᏂᎥ ᏓᏂᎳᏍᏓᎳᏩᏗᏒᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᏗᏂᏬᏂᏍᎩ ᎨᏒᎢ, ᎠᎴ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ.


text:
ᎠᎴ ᎾᏂᎥ ᎡᎶᎯ ᏓᏁᏩᏗᏒ ᏓᎬᏩᏓᏙᎵᏍᏓᏁᎵ, ᎾᏍᎩ ᏚᎾᏙᎥ ᏂᏗᎪᏪᎸᎾ ᎬᏂᏛ ᎪᏪᎵᎯ ᎾᏍᎩ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᏤᎵᎦ, ᎾᏍᎩ <n>[ᎤᏃᏕᎾ ᎠᎩᎾ]</n> ᎡᎶᎯ ᏧᏙᏢᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎠᏥᎸᎯ ᏥᎨᏎᎢ.


text:
ᎩᎶ ᎠᏂᏴᎩ ᏓᏘᎾᏫᏗᏍᎨᏍᏗ ᎾᏍᎩ ᎠᏴᎩ ᎠᎦᏘᏁᏫᏛᏗ ᎨᏎᏍᏗ; ᎩᎶ ᎭᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᎠᏓᎯᏍᏗᏍᎨᏍᏗ ᎾᏍᎩ ᎠᏎ ᎭᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᎬᏗ ᎠᏥᎢᏍᏗ ᎨᏎᏍᏗ. ᎠᏂ ᎾᏍᎩ ᏗᏅᏂᏗᏳ ᎨᏒ ᎠᎴ ᏃᎯᏳᏒ ᎤᎾᏓᏅᏘ ᎬᏂᎨᏒ ᏂᎦᎵᏍᏗᎭ.


text:
ᎠᎴ ᎢᎬᏱ ᎤᎾᏄᎪᏨᎯ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎾᏍᎩᏯ ᏄᎵᏂᎬᎬ ᏄᎵᏂᎬᎬᎩ, ᎠᎴ ᎡᎶᎯ ᎠᎴ ᎾᏍᎩ ᎾᎿ ᎠᏁᎯ ᎤᎾᏓᏙᎵᏍᏓᏁᏗᏱ ᏂᏕᎬᏁᎲᎩ ᎢᎬᏱ ᎤᎾᏄᎪᏨᎯ ᏅᎩ-ᏗᎦᏅᏌᏗ, ᎾᏍᎩ ᎬᏩᏲᎱᎯᏍᏗ ᎨᏒ ᎢᏴᏛ ᎠᏥᏐᏅᏅ ᎤᏗᏩᏒᎯ.


text:
ᎠᎴ ᎡᎶᎯ ᎠᏁᎯ ᏕᎦᎶᏄᎮᎭ ᎬᏗᏍᎬ ᎤᏍᏆᏂᎪᏗ ᏗᎬᏩᎸᏫᏍᏓᏁᏗ ᎨᏒ ᎠᎦᏔᎲ ᏅᎩ-ᏗᎦᏅᏌᏗ; ᎯᎠ ᏏᏕᎦᏪᏎᎭ ᎾᏍᎩ Ꮎ ᎡᎶᎯ ᎠᏁᎯ, ᎾᏍᎩ ᏅᎩ-ᏗᎦᏅᏌᏗ ᏗᏟᎶᏍᏔᏅᎯ ᎢᏦᏢᎾ, ᎾᏍᎩ ᎭᏰᎳᏍᏗ-ᎦᏅᎯᏛ ᎬᏗ ᎠᏥᏐᏅᏅᎯ ᎠᎴ ᏧᏛᏂᏛᎩ.


text:
ᎠᎴ ᎤᎲᎩ ᎬᏃᏛ ᎢᏳᏩᏁᏗᏱ ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᏣᎦᏟᎶᏍᏔᏅᎯ, ᎾᏍᎩ ᎬᏩᏬᏂᎯᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᏣᎦᏟᎶᏍᏔᏅᎯ, ᎠᎴ ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗᏱ ᏗᎨᏥᎢᏍᏗᏱ ᎾᏂᎥ ᎾᎾᏓᏙᎵᏍᏓᏁᎲᎾ ᎾᏍᎩ Ꮎ ᏅᎩᏗᎦᏅᏌᏗ ᏣᎦᏟᎶᏍᏔᏅᎯ.


text:
ᎠᎴ ᎾᏍᎩ ᏄᏩᏂᏌᏅᎩ ᏂᎦᏗᏳ ᏧᎾᏍᏗᏱ ᎠᎴ ᏧᎾᏛᎾ, ᏧᏁᎿᎢ ᎠᎴ ᎤᏲᎢᏳᎾᏛᎿᏕᎩ, ᏂᏗᎨᏥᎾᏝᎥᎾ ᎠᎴ ᏗᎨᏥᎾᏝᎢ, ᏗᎨᎪᏪᎶᏗᏱ ᏗᏂᎦᏘᏏᏗᏢ ᏧᏃᏰᏂ, ᎠᎴ ᏗᏂᎬᏓᎨᏂ;


text:
ᎠᎴ ᎾᏍᎩ ᎩᎶ ᎬᏩᏩᎯᏍᏗ ᏂᎨᏒᎾ ᎠᎴ ᎬᏩᎾᏗᏅᏗ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ, ᎾᏍᎩ Ꮎ ᎤᏩᏒ ᎠᎪᏪᎵ, ᎠᎴ ᏚᏙᎥᏉ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎠᎪᏪᎶᏔᏅᎯ, ᎠᎴ ᏚᏙᎥ ᎢᎦᎢ ᎠᏎᏍᏗᏱ ᎨᏒ ᎠᎪᏪᎶᏔᏅᎯ.


text:
ᎠᏂ ᎠᎦᏙᎥᎯᏍᏗ ᎨᏒ ᎪᎱᏍᏗ ᎢᏛᏓ. ᎩᎶ ᎤᏬᎵᏣᏘ ᎨᏎᏍᏗ ᏩᏎᎦ ᎢᎦᎢ ᎨᏒ ᎠᎦᏎᏍᏗᏱ ᏅᎩ-ᏗᎦᏅᏎᏗ; ᏴᏫᏰᏃ ᎤᏎᏍᏗ ᎨᏒ ᎤᎬᏩᎳ; ᎠᎴ ᎾᏍᎩ ᎠᎦᏎᏍᏗ ᎨᏒ ᎯᎠ ᏂᎦᎥ, ᏑᏓᎵᏧᏈ ᏑᏓᎳᏍᎪᎯ ᏑᏓᎵᎦᎵ.


text:
ᏫᏓᏆᎧᎾᏅᎩᏃ, ᎠᎴ ᎬᏂᏳᏉ ᎤᏃᏕᎾ ᎠᎩᎾ ᏌᏯᏂ ᎣᏓᎸ ᎦᏙᎬᎩ, ᎠᎴ ᎤᎾᎵᎪᏒᎩ ᎠᏍᎪᎯᏧᏈ ᏅᎦᏍᎪᎯ ᏅᎩᎦᎵ ᎢᏯᎦᎵ ᎢᏯᏂᏛ, ᎾᏍᎩ ᎤᏙᏓ ᏚᏙᎥ ᏚᏃᏪᎸᎩ ᏗᏂᎬᏓᎨᏂ.


text:
ᎠᎴ ᎠᏆᏛᎦᏅᎩ ᎩᎶ ᎧᏁᎬ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ, ᎠᎹ ᎤᏣᏘ ᏥᏚᏍᏆᏃᏴᎪ ᎾᏍᎩᏯᎢ, ᎠᎴ ᎾᏍᎩᏯ ᎠᏴᏓᏆᎶᏍᎩ ᎤᏣᏘ ᏧᏍᏆᏃᏴᎪᎢ; ᎠᎴ ᏗᏂᏃᎩᏍᎩ ᏗᎧᏃᎩᏍᏙᏗ ᏗᏂᏃᎩᏍᏗᏍᎬ ᎤᏃᏴᎬ ᎠᏆᏛᎦᏅᎩ.


text:
ᎠᎴ ᎢᏤ ᏥᏓᏂᏃᎩᏍᎪ ᎾᏍᎩᏯ ᎨᏒᎩ ᎢᎬᏱᏗᏢ ᎦᏍᎩᎸᎢ, ᎠᎴ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᏄᎾᏛᏅ ᎢᎬᏱᏗᏢ, ᎠᎴ ᏧᎾᏛᏐᏅᎯ ᏄᎾᏛᏅᎢ; ᎥᏝ ᎠᎴ ᎩᎶ ᎬᏩᏕᎶᏆᏍᏗ ᏱᎨᏎ ᎾᏍᎩ Ꮎ ᏗᎧᏃᎩᏍᏗ Ꮎ ᎤᏅᏒ ᎠᏍᎪᎯᏧᏈ ᏅᎦᏍᎪᎯ ᏅᎩᎦᎵ ᎢᏯᎦᏴᎵ ᎢᏯᏂᏛ, ᎾᏍᎩ ᎡᎶᎯ ᎨᎪᏣᎴᏛ ᎨᎦᎫᏴᏛ ᎨᏒᎢ.


text:
ᎯᎠ ᎾᏍᎩ Ꮎ ᎠᏂᎨᏴ ᎦᏓᎭ ᎢᎬᏩᏅᏁᎸᎯ ᏂᎨᏒᎾ; ᎤᎾᏓᏅᎦᎸᏛᏰᏃ ᎨᏒᎩ ᎾᏍᎩ. ᎯᎠ ᎾᏍᎩ Ꮎ ᎤᏃᏕᎾ ᎠᎩᎾ ᏥᎬᏩᏍᏓᏩᏗᏙᎭ ᏂᎦᎥ ᎡᏙᎲᎢ. ᎯᎠ ᎾᏍᎩ ᏴᏫ ᎠᏁᎲ ᎨᎪᏣᎴᏛ ᎨᎦᎫᏴᏛ, ᎢᎬᏱ ᎬᏩᎾᏓᏓᏁᎸᎯ ᎢᏳᎾᎵᏍᏔᏅᎯ ᏥᎩ ᎤᏁᎳᏅᎯ ᎠᎴ ᎤᏃᏕᎾ ᎠᎩᎾ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏗᏙᎯ ᎥᏥᎪᎥᎩ ᎦᎸᎶᎢ ᎠᏰᎵ ᎨᏒ ᎦᏃᎯᎵᏒᎩ, ᎠᎵᏍᏆᏗᏍᎩ ᏂᎨᏒᎾ ᎣᏍᎩ Ꮎ ᎡᎶᎯ ᎠᏁᎯ, ᎠᎴ ᏂᎦᏗᏳ ᎤᎾᏓᏤᎵᏛ ᏓᏁᏩᏗᏒ ᏴᏫ, ᎠᎴ ᏗᏂᎳᏍᏓᎳᏩᏗᏒᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᏗᏂᏬᏂᏍᎩ ᎨᏒᎢ, ᎠᎴ ᏧᎾᏓᎴᏅᏛ ᏴᏫ,


text:
ᎯᎠ ᏂᎦᏪᏍᎬᎩ ᎠᏍᏓᏯ ᎧᏁᎬᎩ, ᎤᏁᎳᏅᎯ ᎡᏥᎾᏰᏍᎨᏍᏗ, ᎠᎴ ᎾᏍᎩ ᎡᏥᎸᏉᏗᏍᎨᏍᏗ; ᎾᎯᏳᏰᏃ ᏧᏭᎪᏙᏗ ᎨᏒ ᎠᎵᏰᎢᎶᎦ; ᎠᎴ ᎡᏣᏓᏙᎵᏍᏓᏏ ᎾᏍᎩ Ꮎ ᎦᎸᎶᎢ ᎤᏬᏢᏅᎯ, ᎠᎴ ᎡᎶᎯ, ᎠᎴ ᎠᎺᏉᎯ, ᎠᎴ ᎠᎹ ᏕᎦᏄᎪᎬᎢ.


text:
ᏅᏩᏓᎴᏃ ᏗᎧᎿᏩᏗᏙᎯ ᎠᎵᏍᏓᏩᏗᏒᎩ, ᎯᎠ ᏂᎦᏪᏍᎬᎩ, ᏓᏓᎶᏂ ᎠᏲᎩ, ᎠᏲᎩ, ᎾᏍᎩ Ꮎ ᎡᏆ ᏥᎦᏚᎲᎩ, ᏅᏓᎦᎵᏍᏙᏓ ᏂᎦᏗᏳ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒ ᎤᎾᏗᏔᏍᏗᏱ ᏂᏚᏩᏁᎸ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏓᏑᏱ ᎤᏕᎵᏛ ᏚᏂᏏᏂᏙᎸ ᎢᏳᏩᏂᏌᏛ.


text:
ᏦᎢᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎤᏂᏍᏓᏩᏛᏒᎩ, ᎯᎠ ᏂᎦᏪᏍᎬᎩ ᎠᏍᏓᏯ ᎧᏁᎬᎩ, ᎢᏳᏃ ᎩᎶ ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎠᏓᏙᎵᏍᏓᏁᎮᏍᏗ, ᎠᎴ ᎾᏍᎩ ᏣᎦᏟᎶᏍᏔᏅᎯ, ᎠᎴ ᎠᎬᏓᎨᏂ ᎠᎴ ᎤᏬᏰᏂᏉ ᎠᎪᏪᎵᏍᎨᏍᏗ,


text:
ᎾᏍᎩ ᎤᏗᏔᏍᏗ ᎨᏎᏍᏗ ᎨᎦᎨᎠᏗᏔᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏓᏑᏱ, ᎾᏍᎩ ᎠᎹ ᎾᏑᏴᎾ ᎦᏐᏅᏴᎯ ᏥᎩ, ᎾᏍᎩ ᎤᎿᎸᏒ ᎠᏩᏘᏍᎩ ᎤᎵᏍᏈᏗᎯ ᎠᏢᎯ ᏥᎩ; ᎠᎴ ᎾᏍᎩ ᎠᏥᎸ ᎠᎴ ᏌᎪᏂᎨ ᎠᏓᏪᎳᎩᏍᎩ ᎠᏥᎩᎵᏲᎢᏍᏙᏗ ᎨᏎᏍᏗ ᎨᏥᎸᏉᏗ ᏗᏂᎧᎿᏩᏗᏙᎯ ᎠᏂᎦᏔᎲᎢ, ᎠᎴ ᎤᏃᏕᎾ-ᎠᎩᎾ ᎠᎦᏔᎲᎢ;


text:
ᎠᎴ ᎾᏍᎩ ᎠᏂᎩᎵᏲᎬ ᏚᎦᏒᏍᏛ ᏓᎴᎲᏍᎦ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸᎢ; ᎠᎴ ᎥᏝ ᎬᏩᎾᏣᏪᏐᎸᏍᏙᏗ ᏱᎩ, ᎢᎦ ᎠᎴ ᎡᏃᏱ, ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ ᎠᎴ ᎾᏍᎩ ᏣᎦᏟᎶᏍᏔᏅᎯ, ᎠᎴ ᎾᏂᎥᏉ ᎩᎶ ᎾᏍᎩ ᏚᏙᎥ ᎨᎪᏪᎶᏔᏅᎯ.


text:
ᎠᎴ ᎠᏆᏛᎦᏅᎩ ᎩᎶ ᎧᏁᎬ ᎦᎸᎳᏗ ᏛᏓᎴᎲᏍᎬᎩ ᎯᎠ ᏅᏛᎩᏪᏎᎲᎩ, ᎰᏪᎸᎩ, <n>[ᎯᎠ ᏅᎦ,]</n> ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᏧᏂᏲᎱᏒᎯ ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᏚᎾᏁᎶᏛ ᏗᏂᏲᎱᏍᎩ ᎪᎯ ᎢᏳᏓᎴᏅᏛ; ᎤᏙᎯᏳᎯ ᎠᏗᎭ ᎠᏓᏅᏙ ᎾᏍᎩ ᎬᏩᎾᏣᏪᏐᎸᏍᏙᏗ ᎢᏳᎵᏍᏙᏗᏱ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ; ᎠᎴ ᏚᏂᎸᏫᏍᏓᏁᎸ ᏓᏳᏂᏍᏓᏩᏕᏏ.


text:
ᎠᎴ ᏫᏓᏆᎧᎾᏅᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎤᏁᎬ ᎤᎶᎩᎸᎩ, ᎠᎴ ᎤᎶᎩᎸ ᎩᎶ ᎤᏬᎸᎩ ᏴᏫ ᎤᏪᏥ ᎾᏍᎩᏯᎢ, ᎤᎵᏍᏚᎸᎩ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎪᏢᏔᏅᎯ ᎠᎵᏍᏚᎶ, ᎠᎴ ᎪᏍᏓᏯ ᎠᏍᎫᏕᏍᏗ ᎦᏁᎲᎩ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏗᏙᎯ ᏗᎦᎳᏫᎢᏍᏗᏱ ᎢᏳᏄᎪᏨᎩ ᎠᏍᏓᏯ ᎤᏪᎷᎬᎩ ᎯᎠ ᏂᎦᏪᏎᎲᎩ ᎤᎶᎩᎸ ᎤᏬᎵ, ᎠᏍᎫᏕᏍᏗ ᎲᏓ ᎠᎴ ᎯᏍᎫᏛᎦ; ᏣᏍᎫᏕᏍᏗ ᎲᏓ ᎠᎴ ᎯᏍᎫᏛᎦ; ᏣᏍᎫᏕᏍᏗᏱᏰᏃ ᎨᏒ ᎿᏉ ᎠᏍᏆᎸᎯᎦ; ᎡᎶᎯᏰᏃ ᎠᏍᎫᏕᏍᏗᏱ ᎨᏒ ᎤᎦᏛᎾᏨ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᏗᎧᎿᏩᏗᏙᎯ ᎠᏥᎸᎨᎳᏍᏗᏱ ᎾᎥ ᏓᏳᏄᎪᏨᎩ, ᎾᏍᎩ ᎤᎲᎩ ᎠᏓᏅᏖᏍᎬᏉ ᎢᏳᏩᏗᏱ ᎠᏥᎸ; ᎠᎴ ᎠᏍᏓᏯ ᎤᎵᏍᏓᏁᎸᎩ ᎪᏍᏓᏯ ᎠᏍᎫᏕᏍᏗ ᎦᏁᎯ, ᎯᎠ ᏂᎦᏪᏍᎬᎩ, ᎠᏍᎫᏕᏍᏗ ᏣᏤᎵ ᎪᏍᏓᏯ ᎲᏓ, ᎠᎴ ᎯᏟᏌ ᏖᎸᎳᏗ ᎡᎶᎯ ᎤᏛᏒᎯ; ᏖᎸᎳᏗᏰᏃ ᎿᏉ ᎤᏅᎾᏏᏌᏛ.


text:
ᏗᎧᎿᏩᏗᏙᎯᏃ ᎠᏍᎫᏕᏍᏗ ᎤᏤᎵ ᎤᏪᏂᏙᎸᎩ ᎡᎶᎯ, ᎠᎴ ᎤᏪᏟᏌᏅᎩ ᏖᎸᎳᏗ ᎡᎶᎯ ᎤᏛᏒᎯ, ᎠᎴ ᏭᏓᎢᏅᏒᎩ ᏭᎸᏅᎩ ᎤᏔᏅ ᏖᎸᎳᏗ-ᎦᏨᏩᏍᏙᏗᏱ ᎤᏁᎳᏅᎯ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏤᎦ.


text:
ᏖᎸᎳᏗ-ᎦᏨᏩᏍᏙᏗᏱ ᎦᏚᎲ ᏙᏱᏗᏢ ᎤᎾᎳᏍᏓᎡᎸᎩ, ᎩᎬᏃ ᏓᏳᏨᏨᎩ ᏖᎸᎳᏗ-ᎦᏨᏩᏍᏙᏗᏱ, ᎠᎴ ᏐᏈᎵ ᏚᎾᏔᎾᎸ ᎢᏴᏛ ᏂᏚᏂᎶᏨᎩ, ᎾᏍᎩ ᏔᎵᏧᏈ ᎢᏳᏟᎶᏛ ᎢᎬᎾᏕᏅ.


text:
ᏅᏩᏓᎴᏃ ᎤᏰᎸᏛ ᎦᎸᎳᏗ ᎠᎩᎪᎲᎩ, ᎦᎸᏉᏗ ᎠᎴ ᎤᏍᏆᏂᎪᏗ, ᎾᏍᎩ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏓᏂᏰᎲᎩ ᎦᎵᏉᎩ ᎢᏳᏓᎴᎩ ᎤᎵᏍᏆᎸᏗ ᎤᏕᏔᏙᏗ; ᎾᏍᎩᏰᏃ ᎤᏁᎳᏅᎯ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎠᏂᎧᎵᏏᏏᎭ.


text:
ᎠᎴ ᎠᎩᎪᎲᎩ ᎥᏓᎸ ᎠᏓᎨᏗ ᏗᎬᏩᎸᏌᏛ ᎾᏍᎩᏯᎢ ᎠᏥᎸ ᎤᏓᏑᏱ ᎨᏒᎩ; ᎠᎴ ᎾᏍᎩ Ꮎ <n>[ᎥᎦᏥᎪᎥᎩ]</n> ᏅᎩᏗᎦᏅᏌᏗ ᎤᎾᏓᎵᏁᎯᏕᎸᎯ, ᎠᎴ ᎾᏍᎩ Ꮎ ᏣᎦᏟᎶᏍᏔᏅᎯ, ᎠᎴ ᎤᏤᎵ ᏧᏬᏪᎶᏙᏗ, ᎠᎴ ᎾᏍᎩ ᏚᏙᎥ ᎢᎦᎢ ᎠᏎᏍᏗ ᎨᏒᎢ, ᎠᏂᏙᎾᎥᎩ ᎥᏓᎸ ᎠᏓᎨᏗ ᏗᎬᏩᎸᏌᏛ ᎾᏍᎩᏯᎢ, ᎤᏁᎳᏅᎯ ᏧᏤᎵ ᏗᎧᏃᎩᏍᏙᏗ ᏓᏂᏁᎲᎩ


text:
ᎠᎴ ᏚᏂᏃᎩᏒᎩ ᎼᏏ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎤᏅᏏᏓᏍᏗ ᏧᏃᎩᏛ, ᎠᎴ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᏤᎵ ᏗᎧᏃᎩᏍᏗ, ᎯᎠ ᎾᏂᏪᏍᎬᎩ, ᎦᎸᏉᏗᏳ ᎠᎴ ᎤᏍᏆᏂᎪᏗᏳ ᏗᏣᎸᏫᏍᏓᏁᏗ ᎨᏒ ᏣᎬᏫᏳᎯ ᎠᎴ ᏣᏁᎳᏅᎯ ᏫᎾᏍᏛᎾ ᏣᎵᏂᎩᏛ; ᎣᏍᏛ ᎠᎴ ᏚᏳᎪᏛ ᎢᎭᏛᏁᎵᏙᎯ ᏂᎯ ᏣᎬᏫᏳᎯ ᎤᎾᏓᏅᏘ ᎤᎾᏤᎵᎦ.


text:
ᎦᎪ ᏂᏣᎾᏰᏍᎬᎾ ᎨᏎᏍᏗ ᏂᎯ ᏣᎬᏫᏳᎯ, ᎠᎴ ᏂᎦᎸᏉᏗᏍᎬᎾ ᎨᏎᏍᏗ ᏕᏣᏙᎥᎢ? ᏂᎯᏰᏃ ᏨᏒᎯᏳ ᏂᏍᎦᏅᎾ, ᏂᎦᏗᏳᏰᏃ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒ ᏛᏂᎷᏥ ᎠᎴ ᏂᏣᏛᏅ ᎢᎬᏱᏢ ᏛᎾᏓᏙᎵᏍᏔᏂ; ᏂᎯᏰᏃ ᏗᏦᎪᏙᏗ ᎨᏒ ᎬᏂᎨᏒ ᏄᎵᏍᏔᏅ.


text:
ᎦᎵᏉᎩᏃ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏓᏳᏂᏄᎪᏨᎩ, ᏓᏂᏰᎲᎩ ᎦᎵᏉᎩ ᎤᏕᏯᏙᏗ, ᏚᎾᏄᏮᎩ ᏂᏚᏓᏅᎦᎸᎾ ᎠᎴ ᏧᏁᎬ ᏙᎴᏛ ᏗᏄᏬ, ᎠᎴ ᏗᏂᏁᏥᏱ ᏚᎾᏓᏠᎲᎩ ᎠᏕᎸ-ᏓᎶᏂᎨ ᏗᎪᏢᏅᎯ ᏗᏓᏠᏍᏗ.


text:
ᎠᏏᏴᏫᏃ ᎾᏍᎩ Ꮎ ᏅᎩ ᎢᏯᏂᏛ ᎨᏒ ᏗᏅᏃᏛ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏚᏁᎸᎩ ᎦᎵᏉᎩ ᎫᎫ ᎠᏕᎸᏓᎶᏂᎨ ᏗᎪᏢᏔᏅᎯ, ᏗᎧᎵᎢ ᎤᏁᎳᏅᎯ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒᎢ, ᎾᏍᎩ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸ ᏤᎭ.


text:
ᏗᎦᎳᏫᎢᏍᏗᏱᏃ ᎤᎧᎵᏨᎩ ᏧᎧᎵᏨᎩ ᏧᎦᏒᏍᏗ ᎤᏁᎳᏅᎯ ᎠᏥᎸᏉᏗᏳ ᎨᏒ ᎠᎴ ᎤᎵᏂᎩᏗᏳ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ; ᎥᏝ ᎠᎴ ᎩᎶ ᏫᎬᏩᏴᏍᏗ ᏱᎨᏎ ᏗᎦᎳᏫᎢᏍᏗᏱ, ᎬᏂ ᎾᏍᎩ Ꮎ ᎦᎵᏉᎩ ᏧᏕᏯᏙᏗ ᎨᏒ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏥᏚᎾᏒᎦᎸ ᏱᏚᎵᏍᏆᏛ.


text:
ᎠᏆᏛᎦᏅᎩᏃ ᎩᎶ ᎠᏍᏓᏯ ᏓᎧᏁᎬᎩ ᏗᎦᎳᏫᎢᏍᏗᏱ ᏛᏓᎴᎲᏍᎩ ᎯᎠ ᏂᏕᎦᏪᏎᎲᎩ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ, ᎢᏤᎾ, ᎠᎴ ᎡᎶᎯ ᏫᏂᏐᏅᏯ ᎤᏁᎳᏅᎯ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎫᎫ ᏓᏟᏍᏛᎢ.


text:
ᎢᎬᏱᏱᏃ ᎨᏒ ᎤᏪᏅᏒᎩ, ᎠᎴ ᎪᏙᎯ ᎤᏪᏐᏅᏴᎩ ᎫᎫ ᎠᏰᎲ ᎠᏟᏍᏛᎢ; ᎤᏕᏯᏙᏗᏃ ᎠᎴ ᎡᎯᏍᏗ ᏚᏂᏣᏍᏓᎳᏛᎩ ᏴᏫ ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎤᏤᎵ ᏗᎨᎪᏪᎶᏔᏅᎯ, ᎠᎴ ᎾᏍᎩ ᏣᎦᏟᎶᏍᏔᏅᎯ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ.


text:
ᏔᎵᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎠᎺᏉᎯ ᎤᏪᏐᏅᏴᎩ ᎫᎫ ᎠᏰᎲ ᎠᏟᏍᏛᎢ; ᎤᏲᎲᏒᎯᏃ ᏴᏫ ᎤᎩᎬ ᎾᏍᎩᏯ ᏄᎵᏍᏔᏅᎩ; ᎠᎴ ᏂᎦᏗᏳ ᏗᏅᏃᏛ ᎨᏒ ᎠᎺᏉᎯ ᎠᏁᎲ ᏚᏂᎵᏬᏨᎩ.


text:
ᎠᎴ ᎠᎹᏱ ᏗᎦᏘᏯ ᏗᎧᎿᏩᏗᏙᎯ ᎥᏥᏯᏛᎦᏁᎸᎩ, ᎯᎠ ᏄᏪᏒᎩ, ᏂᏍᎦᏅᎾ ᏣᎬᏫᏳᎯ, ᏂᎯ ᎾᏍᎩ ᏤᎭ, ᎠᎴ ᏤᎲᎩ, ᎠᎴ ᏤᎮᏍᏗ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᏄᏍᏛ ᏕᏧᎪᏔᏅᎢ.


text:
ᏅᏩᏓᎴᏃ <n>[ᏗᎧᎿᏩᏗᏙᎯ]</n> ᎥᏥᏯᏛᎦᏁᎸᎩ ᎠᏥᎸ-ᎨᎳᏍᏗᏱ ᎯᎠ ᏅᏓᏳᏪᏒᎩ, ᎾᏍᎩᏯ ᏄᏍᏕᏍᏗ, ᏣᎬᏫᏳᎯ ᏣᏁᎳᏅᎯ ᏫᎾᏍᏛᎾ ᏣᎵᏂᎩᏛ, ᎣᏏᏳ ᎠᎴ ᏚᏳᎪᏛ ᏂᎯ ᏗᎫᎪᏙᏗ ᎨᏒᎢ.


text:
ᎠᎴ ᎤᏣᏘ ᎤᏗᎴᎩ ᎨᏒ ᏕᎨᏥᎴᏴᏙᏔᏅᎩ ᏴᏫ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏚᏙᎥ ᎤᏂᏐᏢᎢᏍᏔᏅᎩ, ᎾᏍᎩ ᎠᏓᏅᏖᏍᎬᏉ ᎢᎬᏩᏁᎵᏓᏍᏗ ᏥᎩ ᎯᎠ ᎾᏍᎩ ᎤᏕᏯᏙᏗ ᎨᏒᎢ; ᎠᎴ ᎥᏝ ᏱᏚᏂᏁᏟᏴᏎ ᏚᏁᏓᏅᏛ ᎾᏍᎩ ᎬᏩᎸᏉᏙᏗᏱ.


text:
ᎯᏍᎩᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎤᏪᏗᏱ ᎤᏪᏐᏅᏴᎩ ᎫᎫ ᎠᏰᎲ ᎠᏟᏍᏛᎢ, ᎤᏥᎵᎪᎯᏃ ᎨᏒ ᎤᎧᎵᏦᏅᎩ ᎤᎵᏏᎩ; ᏓᏂᏃᏓᏛᏃ ᏚᏂᎩᏍᏙᎥᎩ ᏚᏁᎯᏍᏓᏁᎲ ᎢᏳᏍᏗ,


text:
ᏑᏓᎵᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎡᏆ ᎡᏉᏂ ᎤᏪᏴ ᏳᏇᏗ ᎤᏪᏐᏅᏴᎩ ᎫᎫ ᎠᏰᎲ ᎠᏟᏍᏛᎢ; ᎠᎹᏃ ᎾᎿ ᎡᎬ ᎤᎶᏐᏅᎩ, ᎾᏍᎩ ᎤᏂᎬᏫᏳᎯ ᏗᎧᎸᎬ ᎢᏗᏢ ᎠᏁᎯ ᎤᏂᏅᏅ ᎨᎦᏛᎢᏍᏓᏁᏗᏱ ᎠᏰᎸᏒᎩ.


text:
ᎠᏂᏍᎩᎾᏰᏃ ᏧᎾᏓᏅᏙ ᎾᏍᎩ, ᎤᏍᏆᏂᎪᏗ ᏚᏂᎸᏫᏍᏓᏁᎭ, ᎡᎶᎯ ᎠᏁᎯ ᎤᏂᎬᏫᏳᎯ ᎠᎴ ᎡᎳᏂᎬ ᏓᏂᏩᏛᎮᎦ, ᎾᏍᎩ ᏧᏂᏟᏐᏗᏱ ᏧᎾᎵᏍᏗᏱ ᎤᏂᏰᎸᎭ ᎦᎸᏉᏗ ᎢᎦ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ ᏫᎾᏍᏛᎾ ᎤᎵᏂᎩᏛ ᏥᎩ.


text:
ᎬᏂᏳᏉ, ᎦᏃᏍᎩᏍᎩ ᏥᎦᎷᎪ ᎾᏍᎩᏯ ᏓᏥᎷᏥ. ᎣᏏᏳ ᎢᏳ ᎵᏍᏓᏁᏗ ᎾᏍᎩ Ꮎ ᎠᏯᏫᏍᎩ, ᎠᎴ ᏧᏄᏬ ᏗᏍᏆᏂᎪᏗᏍᎩ, ᎾᏍᎩ ᎤᏰᎸᎭ ᎤᏪᏓᏍᏗᏱ ᏂᎨᏒᎾ, ᎠᎴ ᎤᏕᎰᎯᏍᏗ ᎨᏒ ᎠᏥᎪᏩᏛᎡᏗᏱ ᏂᎨᏒᎾ.


text:
ᎦᎵᏉᎩᏁᏃ ᎨᏒ ᏗᎧᎿᏩᏗᏙᎯ ᎦᎳᏅᏛᏉ ᎦᎸᎶᎢ ᎤᏪᏐᏅᏴᎩ ᎫᎫ ᎠᏰᎲ ᎠᏟᏍᏛᎢ; ᎠᎴ ᎠᏍᏓᏯ ᏗᎧᏁᎬ ᎩᎶ ᎦᎸᎳᏗ ᏗᎦᏔᏫᎢᏍᏗᏱ ᎠᎴ ᎾᎿ ᏗᎦᏍᎩᎸ ᏓᏳᏓᎴᏅᎩ, ᎯᎠ ᏅᏓᎦᏪᏍᎬᎩ, ᎿᏉ ᎠᎵᏍᏆᏓ.


text:
ᎿᏉᏃ ᏚᏍᏆᏃᏴᏔᏂᎩ, ᎠᎴ ᏚᏴᏓᏉᎶᎥᎩ, ᎠᎴ ᏚᎾᎦᎸᎲᎩ, ᎾᏍᎩ ᎢᎦᎢ ᎥᏝ ᎢᎸᎯᏳ ᏱᎬᏩᎵᏖᎸᏃ ᏴᏫ ᎡᎶᎯ ᎤᎾᏕᏅ ᏅᏓᎬᏩᏓᎴᏅᏛ, ᎾᏍᎩ ᎢᏳᎵᏂᎩᏛ ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᎦᏎᏗ.


text:
ᎠᎴ ᎾᏍᎩ ᎡᏆ ᎦᏚᎲ ᏦᎢ ᏄᏓᏛᎩ, ᎠᎴ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒ ᏚᏂᏚᎲ ᏚᏲᏨᎩ; ᎠᎴ ᏓᏓᎶᏂ ᎦᎸᏉᏗ ᎦᏚᎲ ᎠᏅᏓᏗᏍᏗ ᏄᎵᏍᏔᏅᎩ ᎤᏁᎳᏅᎯ ᏄᏛᏅᎢ, ᎾᏍᎩ ᎠᏥᏁᏗᏱ <n>[ᏓᏓᎶᏂ]</n> ᎤᎵᏍᏈᏗ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎠᏟᏍᏛ ᎤᏣᏘ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏩᏛᏗ.


text:
ᎡᏆᏃ ᎤᏁᏐᎠᏒᎩ ᏴᏫ ᎠᏁᎲ ᎦᎸᎳᏗ ᏅᏓᏳᏓᎴᏅᎯ, ᏌᏉᎭ ᎨᏒ ᏔᎸᏗ ᏄᏓᎨᏒ ᏄᏓᎨᏒᎩ; ᏴᏫᏃ ᎤᏁᎳᏅᎯ ᎤᏂᏐᏢᎢᏍᏔᏅᎩ ᏅᏓᎦᎵᏍᏙᏗᏍᎬᎩ ᎤᏁᏍᏓᎳ ᎤᎾᏕᏯᏙᏗᏍᎬᎢ; ᎤᏣᏘᏰᏃ ᎤᎾᏕᏯᏙᏗᏍᎬᎩ ᎾᏍᎩ.


text:
ᎠᏏᏴᏫᏃ ᎾᏍᎩ Ꮎ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᎨᏒ ᏗᏂᎧᎿᏩᏗᏐᎯ, ᎾᏍᎩ ᎦᎵᏉᎩ ᎫᎫ ᏥᏓᏂᏰᎲᎩ, ᎤᎷᏨᎩ ᎠᎴ ᎠᏆᎵᏃᎮᏔᏅᎩ, ᎯᎠ ᎾᎩᏪᏎᎸᎩ, ᎡᎮᎾ; ᏓᎬᎾᏄᎪᏫᏎᎵ ᏄᏍᏛ ᏣᎫᎪᏓᏁᏗ ᎨᏒ ᎤᏣᏘ ᎤᏁᎫᏥᏛ ᎠᎨᏴ, ᎤᏣᏘ ᎠᎹ ᏚᏪᏴ ᏧᏬᎳ;


text:
ᎾᏍᎩᏃ ᎠᏓᏅᏙ ᎬᏗ ᎢᎾᎨ ᏩᏆᏘᏅᏍᏔᏅᎩ; ᎠᎨᏴᏃ ᎥᏥᎪᎲᎩ ᎩᎦᎨ ᏗᎧᏃᏗᏱ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎤᎩᎸᏛᎩ ᎾᏍᎩ ᎤᎧᎵᏨᎯ ᎨᏒᎩ ᎤᏁᎳᏅᎯ ᏚᏙᎥ ᎠᏐᏢᎢᏍᏙᏗ ᎨᏒᎢ ᎦᎵᏉᎩ ᏓᏍᎫᏓᏛᎩ, ᎠᎴ ᎠᏍᎪᎯ ᏕᎤᎷᎬᎩ.


text:
ᎠᎨᏴᏃ ᏗᏕᎭᎷᎨ ᎠᎴ ᏗᎩᎦᎨ ᏚᏄᏩᎥᎩ, ᎠᎴ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎠᎴ ᏗᎦᎸᏉᏗ, ᏅᏯ ᎠᎴ ᏓᎬᎾ-ᎢᏳᎾᏍᏗ ᏚᏣᏅᏛᎩ, ᎠᎴ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎠᏢᎳᏅᎯ ᎤᎵᏍᏈᏗ ᎠᏰᎲᎩ ᎠᎧᎵᎢ ᎤᏂᏆᏘᏍᏗ ᎨᏒ, ᎠᎴ ᎤᏁᎢᎸᏗ ᎾᏍᎩ ᎤᏕᎵᏛ ᏚᏂᏏᏂᏙᎸ ᎤᏩᏛᏛ.


text:
ᏗᎧᎿᏩᏗᏙᎯᏃ ᎯᎠ ᎾᎩᏪᏎᎸᎩ, ᎦᏙᏃ ᎥᏣᏍᏆᏂᎪᎵ? ᏓᎬᏃᏁᎵ ᏄᏍᏛ ᎦᏛᎬ ᎠᎨᏴ, ᎠᎴ ᏄᏍᏛ ᎦᏛᎬ ᏅᎩᏗᎦᏅᏌᏗ ᎾᏍᎩ ᏧᎩᎸᏗ, ᎾᏍᎩ ᎦᎵᏉᎩ ᏥᏓᏍᎫᏓᏛ ᎠᎴ ᎠᏍᎪᎯ ᏥᏚᎷᎦ.


text:
ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᏥᎪᎥᎩ, ᎡᎲᎩ, ᎠᎴ ᎥᏝ ᏰᎭ; ᎠᎴ ᏙᏛᎴᏂ ᏫᎾᏍᏛᎾ ᏗᏔᎴᏒ ᏓᎦᏄᎪᏥ, ᎠᎴ ᎠᏥᏛᏙᏗᏱ ᏴᏓᎦᎶᏏ, ᎾᏍᎩᏃ Ꮎ ᎡᎶᎯ ᎠᏁᎯ ᎾᏍᎩ ᏚᎾᏙᎥ ᏂᏗᎪᏪᎳᏅ ᎾᎬᏂᏛ ᎪᏪᎵᎯ ᎡᎶᎯ ᏧᏙᏢᏅ ᏅᏓᎬᏩᎴᏅᏛ ᏛᏂᏍᏆᏂᎪᏏ ᎠᏂᎪᎲᎭ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎾᏍᎩ ᏤᎲᎩ, ᎠᎴ ᏁᎲᎾ ᏥᎩ, ᎠᏎᏃ ᎾᏍᎩ ᏤᎭ.


text:
ᎠᏍᎪᎯᏃ ᏕᎤᎷᎬ ᏥᏕᏣᎪᎲᎩ, ᎾᏍᎩ ᎠᏍᎪᎯ ᎤᏂᎬᏫᏳᎯ ᎦᏛᎦ, ᎾᏍᎩ ᎤᏂᎬᏫᏳᎯ ᎢᏳᎾᎵᏍᏙᏗᏱ ᎨᏒ ᎠᏏ ᎨᏥᏁᎸᎯ ᏂᎨᏒᎾ ᎨᏒᎢ; ᎨᎦᎵᏍᎪᎸᏓᏁᎭᏍᎩᏂᏃᏅ ᎤᏂᎬᏫᏳᎯ ᎤᏂᏁᎢᏍᏗ ᎨᏒ ᎤᏂᏁᎢᏍᏗᏱ ᏌᏉ ᎢᏳᏟᎶᏛ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎤᏠᏱ ᎧᏁᎬᎢ.


text:
ᎯᎠ ᎾᏍᎩ ᏓᎿᏩ ᏅᏛᏅᏁᎵ ᎤᏃᏕᎾ ᎠᎩᎾ, ᎠᎴ ᎤᏃᏕᎾ ᎠᎩᎾ ᏙᏛᏎᎪᎩᏏ ᎾᏍᎩ; ᎾᏍᎩᏰᏃ ᎤᏂᎬᏫᏳᎯ ᎠᏁᎲ ᎤᎬᏫᏳᎯ; ᎠᎴ ᏄᏂᎬᏫᏳᏒ ᎠᏁᎲ ᎾᏍᎩ ᏄᎬᏫᏳᏌᏕᎩ; ᎠᎴ ᎾᏍᎩ ᎬᏩᏜᏩᏍᏗᏕᎩ ᏥᎩ ᎨᏥᏯᏅᏛ, ᎠᎴ ᎨᎦᏑᏰᏛ, ᎠᎴ ᏄᎾᏓᎵᏓᏍᏛᎾ.


text:
ᎠᎴ ᎠᏍᎪᎯ ᏕᎤᎷᎬ ᏥᏕᏣᎪᎲᎩ, ᎾᏍᎩ ᏅᎩ-ᏗᎨᏅᏌᏗ ᏚᎷᎬᎢ, ᎾᏍᎩ ᏓᎬᏩᏂᏆᏘᎵ ᎤᏁᎫᏥᏛ ᎠᎨᏴ, ᎠᎴ ᏅᏔ ᎠᎴ ᎤᏰᎸᎭ ᏅᏓᏰᎬᏁᎵ, ᎠᎴ ᎤᏇᏓᎸ ᏓᎬᏩᎨᎵ, ᎠᎴ ᎠᏥᎸ ᎬᏗ ᏓᎬᏩᎪᎲᏍᏔᏂ.


text:
ᎤᏁᎳᏅᎯᏰᏃ ᏚᎳᏁᎸ ᎫᏂᎾᏫᏱ ᏄᏍᏛ ᎠᏓᏅᏖᏍᎬ ᎤᏂᏍᏆᏗᏍᏗᏱ, ᎠᎴ ᏌᏉᎢᏳᏅᏁᏗᏱ ᏚᎾᏓᏅᏛᎢ, ᎠᎴ ᏧᏂᏲᎯᏎᏗᏱ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎾᎿ ᎤᏂᎬᏫᏳᎯ ᎨᏒᎢ, ᎬᏂ ᎤᏁᎳᏅᎯ ᎤᏁᏨ ᎾᏍᎩ ᎢᏳᎵᏍᏔᏅᎯ ᎨᏎᏍᏗ.


text:
ᎠᎴ ᎠᏍᏓᏯ ᎤᏪᎷᏅᎩ ᎤᎵᏂᎩᏛ ᎧᏁᎬ ᎬᏗ, ᎯᎠ ᏂᎦᏩᏍᎬᎩ, ᏓᏓᎶᏂ ᎡᏆ ᎠᏲᎩ, ᎠᏲᎩ, ᎠᎴ ᎠᏂᏍᎩᎾ ᎤᎾᏕᏗᏱ ᏂᎦᎵᏍᏓ, ᎠᎴ ᎾᏂᎥ ᎠᏂᎦᏓᎭ ᏗᏓᏅᏙ ᎤᏂᏴᏍᏗᏱ, ᎠᎴ ᎾᏂᎥ ᎠᏂᎦᏓᎭ ᎠᎴ ᎤᏂᏂᏆᏘᏍᏗ ᏥᏍᏆ ᎤᎾᏁᎳᏗᏍᏗᏱ.


text:
ᏂᎦᏗᏳᏰᏃ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒ ᎤᎾᏗᏔᎲ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᎤᏓᏑᏱ ᎾᏍᎩ ᎤᏕᎵᏛ ᏚᏂᏏᏂᏙᎸ ᎢᏳᏩᏂᏌᏛ, ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎡᎶᎯ ᎠᏁᎯ ᎾᏍᎩ ᎤᏕᎵᏛ ᏚᎾᏂᏏᏂᏙᎸ, ᎠᎴ ᎠᏂᏃᏗᏍᎩ ᎡᎶᎯ ᎠᏁᎯ ᏚᏁᏅᎢᏍᏔᏅ ᎾᏍᎩ ᎤᏣᏘ ᎤᏢᏉᏗ ᎡᎲᎢ.


text:
ᎠᎴ ᏅᏩᏓᎴ ᎩᎶ ᏗᎧᏁᎬ ᎦᎸᎳᏗ ᎠᏆᏛᎦᏅᎩ, ᎯᎠ ᏅᏓᎦᏪᏍᎬᎩ, ᏂᎯ ᏗᏆᏤᎵᎦ ᏴᏫ ᎡᏥᏄᎪᎢ, ᎾᏍᎩ ᎢᏣᏠᏯᏍᏙᏗᏱ ᏂᎨᏒᎾ ᎾᏍᎩ ᎤᏍᎦᏅᏥᏙᎸᎢ, ᎠᎴ ᎾᏍᎩ ᎤᏤᎵ ᎤᏕᏯᏙᏗ ᎨᏒ ᎢᏣᏠᏯᏍᏙᏗᏱ ᏂᎨᏒᎾ.


text:
ᎾᏍᎩ ᏂᎦᎥ ᎤᏩᏒ ᎤᏓᎸᏉᏔᏅᎢ ᎠᎴ ᎤᏢᏉᏗ ᎤᏕᏅᎢ, ᎾᏍᎩ ᎢᎦᎢ ᎠᎩᎵᏯ ᎠᎴ ᎤᏲ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒ ᎡᏥᎥᏏ; ᎤᎾᏫᏱᏰᏃ ᎯᎠ ᏂᎦᏪᎭ, ᎠᎩᎬᏫᏳᎯ ᎠᏉᎳ, ᎥᏝ ᎠᏉᏑᎶᏨᎯ ᏱᎩ, ᎥᏝ ᎠᎴ ᎤᏲ ᎠᏓᏅᏓᏗᏍᏗ ᎨᏒ ᏴᎦᏥᎪᏩᏛ.


text:
ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏕᏯᏙᏗᏍᎩ ᎨᏒ ᏏᏉᏃ ᎤᎷᎯᏍᏗ ᎨᏎᏍᏗ, ᎠᏲᎱᎯᏍᏗ ᎨᏒ, ᎠᎴ ᎠᎦᎪᎲᏍᏙᏗ ᎨᏎᏍᏗ ᎠᏥᎸ ᎬᏗ; ᎤᎵᏂᎩᏗᏳᏰᏃ ᎤᎬᏫᏳᎯ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᏧᏭᎪᏓᏁᎯ ᏥᎩ.


text:
ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎡᎶᎯ ᎠᏁᎯ, ᎾᏍᎩ ᎤᏕᎵᏛ ᏧᎾᏂᏏᏂᏙᎸᎯ ᎨᏒᎢ, ᎠᎴ ᎤᏢᏉᏗ ᎢᏧᎳᎭ ᎤᎾᏕᏅᎯ, ᎾᏍᎩ ᏓᎬᏩᏍᎪᏂᎵ, ᎠᎴ ᎾᏍᎩ ᏅᏓᎦᎵᏍᏙᏔᏂ ᏙᏛᏂᏴᎳᏏ, ᎿᏉ ᎠᏂᎪᎲᎭ ᏚᎦᏒᏍᏛ ᎾᏍᎩ ᎠᎪᎲᏍᎬᎢ,


text:
ᎢᏅ ᏗᏂᏙᎾᎡᏍᏗ ᎠᏂᏍᎦᎢᎲ ᎠᎩᎵᏲᎬ ᏅᏗᎦᎵᏍᏙᏗᏍᎬᎢ, ᎯᎠ ᎾᏂᏪᏍᎨᏍᏗ, ᎤᏲᏍᏛᏉ, ᎤᏲᏍᏛᏉ, ᎾᏍᎩ ᎾᎡᏆ ᏓᏓᎶᏂ, ᎾᏍᎩ ᎤᎵᏂᎩᏛ ᎦᏚᎲᎢ! ᏑᏟᎶᏛᏉᏰᏃ ᎢᎪᎯᏛ ᏗᏣᏚᎪᏓᏁᏗ ᎨᏒ ᏣᎷᏥᏏ.


text:
ᎾᏍᎩ ᎠᏕᎸ-ᏓᎶᏂᎨ ᎦᏃᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏕᎸ-ᎤᏁᎬ, ᎠᎴ ᎤᏣᏘ ᏧᎬᏩᎶᏗ ᏅᏯ, ᎠᎴ ᏓᎬᎾ-ᎢᏳᎾᏍᏗ, ᎠᎴ ᎤᏏᏙᎵ ᏙᎴᏛ, ᎠᎴ ᏗᏕᎭᎷᎨᎢ, ᎠᎴ ᏗᏩᎾᎨᎢ, ᎠᎴ ᏗᎩᎦᎨᎢ, ᎠᎴ ᎾᎦᎥ ᏗᎦᎸᏉᏗ ᎠᏓ, ᎠᎴ ᏂᎦᎥ ᏗᏖᎵᏙ ᎧᎹᎹ ᏧᏓᏄᏙᏅᎯ ᏗᎪᏢᏔᏅᎯ, ᎠᎴ ᏂᎦᎥ ᏗᏖᎵᏙ ᎤᏣᏘ ᏧᎬᏩᎶᏗ ᎠᏓ ᏗᎪᏢᏔᏅᎯ, ᎠᎴ ᎥᏣᏱ, ᎠᎴ ᏔᎷᎩᏍᎩ, ᎠᎴ ᎠᏂᏓᏫᏍᎦᎨ ᏅᏯ,


text:
ᎠᎴ ᏏᏂᎹᏂ, ᎠᎴ ᏗᎦᏩᏒᎩ, ᎠᎴ ᎠᏠᏁᏗ, ᎠᎴ ᎠᏜ ᎤᎦᎾᏍᏛ ᎦᏩᏒᎩ, ᎠᎴ ᎩᎦᎨ-ᎠᏗᏔᏍᏗ, ᎠᎴ ᎪᎢ, ᎠᎴ ᏩᎾᎨ ᎤᏣᎴᏍᏗ ᎢᏒ, ᎠᎴ ᎤᏣᎴᏍᏗᎤᎦᏛ, ᎠᎴ ᎦᎾᏝᎢ, ᎠᎴ ᎠᏫ-ᎤᏂᏃᏕᏅ, ᎠᎴ ᏐᏈᎵ, ᎠᎴ ᏧᏍᏗ-ᏓᏆᎴᎷ, ᎠᎴ ᏴᏫ-ᏗᎦᎾᏝᎢ, ᎠᎴ ᏴᏫ ᏧᎾᏓᏅᏙ.


text:
ᎠᎴ ᎯᎠ ᎾᏂᏪᏍᎨᏍᏗ, ᎤᏲᏍᏛᏉ, ᎤᏲᏍᏛᏉ, ᎾᏍᎩ Ꮎ ᎡᏆ ᎦᏚᎲ ᎾᏍᎩ ᎤᏏᏙᎵ ᏙᎴᏛ, ᎠᎴ ᏕᎭᎷᎨᎢ, ᎠᎴ ᎩᎦᎨᎢ ᏥᏚᏣᏃᏛᎩ, ᎠᎴ ᎠᏕᎸᏓᎶᏂᎨᎢ, ᎠᎴ ᎤᏣᏘ ᏧᎾᎬᏩᎶᏗ ᏅᏯ, ᎠᎴ ᏓᎬᎾ-ᎢᏳᎾᏍᏗ, ᏥᏚᏣᏃᏛᎩ!


text:
ᏑᏟᎶᏛᏉᏰᏃ ᎢᎪᎯᏛ ᎾᏍᎩ ᎢᎦᎢ ᏧᎬᏩᎶᏗ ᎠᏎᏉ ᏂᎦᎵᏍᏔᏂᏛ. ᎠᎴ ᎾᏂᎥ ᎤᏂᎬᏫᏳᏌᏕᎩ ᏥᏳ ᏧᏔᏅ ᏓᏂᏂᏙᎲᎢ, ᎠᎴ ᎾᏂᎥ ᏥᏳᎯ ᎤᎾᏣᎢ, ᎠᎴ ᏥᏳ ᏗᏂᏂᏙᎯ, ᎠᎴ ᎾᏂᎥᏉ ᎠᎺᏉᎯ ᎠᏂᏃᏔᏂᏙᎯ, ᎢᏅ ᏛᏂᏙᎾᎥᎩ,


text:
ᏗᏂᏍᎪᎵᏃ ᎪᏍᏚ ᏚᏂᏝᏅᎩ, ᎠᎴ ᎤᏁᎷᏅᎩ ᏓᎾᏠᏱᎲᎢ, ᎠᎴ ᏓᏂᏴᎬᎢ, ᎯᎠ ᎾᏂᏪᏍᎬᎩ, ᎤᏲᏍᏛᏉ, ᎤᏲᏍᏛᏉ, ᎾᏍᎩ Ꮎ ᎡᏆ ᎦᏚᎲᎢ, ᎾᎿ ᏧᏁᎿᎢ ᏥᏄᎾᎵᏍᏔᏅᎩ ᏂᎦᏛ ᎠᎺᏉᎯ ᏥᏳ ᏗᏂᏂᏙᎯ, ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᎤᏣᏘ ᎤᏪᎿᎢᏳ ᎨᏒᎢ, ᏑᏟᎶᏛᏉᏰᏃ ᎢᎪᎯᏛ ᏅᏔ ᎾᎬᏁᎸ.


text:
ᎤᎵᏂᎩᏛᏃ ᏗᎧᎿᏩᏗᏙᎯ ᏅᏯ ᎤᎩᏒᎩ, ᎤᏔᏅ ᏗᏍᏙᏍᎩ ᏅᏯ ᎾᏍᎩᏯᎢ, ᎠᎺᏉᎯᏃ ᏭᏗᏅᏒᎩ, ᎯᎠ ᏄᏪᏒᎩ, ᎾᏍᎩᏯ ᎬᏍᎦᎢᏍᏓᎩ ᎾᏍᎩ Ꮎ ᎡᏆ ᎦᏚᎲ ᏓᏓᎶᏂ ᎠᏥᏲᏍᏙᏗ ᎨᏎᏍᏗ, ᎥᏝ ᎠᎴ ᎿᏉ ᎬᏩᏛᏗ ᏱᎨᏎᏍᏗ.


text:
ᎠᎴ ᏗᎧᏃᎩᏍᏙᏗ ᏗᏂᏃᎩᏍᏗᏍᎩ, ᎠᎴ ᏗᏂᏃᎩᏍᎩ, ᎠᎴ ᎠᏦᏔᏍᏗ ᏗᏂᏃᎩᏍᏗᏍᎩ, ᎠᎴ ᏗᏂᏤᎷᎯᏍᎩ ᎤᎾᏓᏃᏴᎵᏍᏛ ᎥᏝ ᎠᎴ ᎪᏢᏅᎥᏍᎩ ᏄᏓᎴᏒᏉ ᎪᎱᏍᏗ ᎪᏢᏍᎩ ᎿᏉ ᏰᏣᏩᏛᎡᎴᏍᏗ; ᎠᎴ ᏅᏯ ᎠᏍᏙᏍᎩ ᎤᏃᏴᎬ ᎥᏝ ᎿᏉ ᎡᏣᏛᎦᏁᏗ ᏱᎨᏎᏍᏗ;


text:
ᎠᎴ ᎠᏨᏍᏙᏗ ᏚᎸᏌᏛ ᎥᏝ ᎿᏉ ᏗᏣᎸᏌᏓᏕᏗ ᏱᎨᏎᏍᏗ; ᎠᎴ ᎠᏕᏒᎲᏍᎩ ᎠᎴ ᎠᏥᏰᎯ ᎠᏂᏁᎬ ᎥᏝ ᎿᏉ ᎡᏣᏛᎦᏁᏗ ᏱᎨᏎᏍᏗ; ᏗᏣᏤᎵᏰᏃ ᎠᏂᏃᏗᏍᏍᎩ ᎨᏥᎸᏉᏗ ᎨᏒᎩ ᏴᏫ ᎡᎶᎯ ᏓᏁᏩᏗᏒᎢ; ᏂᎦᏗᏳᏰᏃ ᎤᎾᏓᏤᎵᏛ ᎨᏒ ᏴᏫ ᏓᏁᏩᏗᏒ ᎠᏙᏅᏗ ᏕᏣᎸᏫᏍᏓᏁᎲ ᏕᎯᎶᏄᎮᏔᏅᎩ.


text:
ᎾᏍᎩᏃ ᏄᎵᏍᏔᏂᏙᎸ ᎠᏆᏛᎦᏅᎩ ᎠᏍᏓᏯ ᎠᏂᏁᎬ ᎤᏂᏣᏘ ᏴᏫ ᎦᎸᎳᏗ ᎢᏴᏛ, ᎯᎠ ᏅᏛᏂᏪᏍᎬᎩ, ᏱᎰᏩ ᎡᏗᎸᏉᏓ; ᎠᎵᏍᏕᎸᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎠᏥᎸᏉᏙᏗ ᎨᏒᎢ, ᎠᎴ ᎣᏍᏛ ᎠᏥᏰᎸᏗ ᎨᏒᎢ, ᎠᎴ ᎤᎵᏂᎩᏛ ᎨᏒᎢ, ᎤᏤᎵᎦ ᎨᏎᏍᏗ ᎤᎬᏫᏳᎯ ᎢᎦᏁᎳᏅᎯ;


text:
ᎾᏍᎩᏰᏃ ᏧᏭᎪᏙᏗ ᎨᏒ ᏚᏳᎪᏛᎢ ᎠᎴ ᎣᏍᏛ; ᎾᏍᎩᏰᏃ ᏚᏭᎪᏓᏁᎸ ᎤᏣᏘ ᎤᏁᎫᏥᏛ ᎠᎨᏴ, ᎾᏍᎩ ᎤᏕᎵᏛ ᏓᏂᏏᏂᏙᎲ ᎤᏂᏲ ᏥᏂᏚᏩᏁᎸ ᎡᎶᎯ ᎠᏁᎯ, ᎠᎴ ᎤᏞᏨ ᏧᏅᏏᏓᏍᏗ ᎤᏂᎩᎬ ᏚᏨᏁᎸᎢ.


text:
ᎾᏍᎩᏃ ᎾᏅᎩᏦᏁ ᎢᏯᏂᏛ ᏧᎾᏛᏐᏅᎯ, ᎠᎴ Ꮎ ᏅᎩ ᎢᏯᏂᏛ ᏗᏅᏃᏛ ᎡᎳᏗ ᏚᎾᏓᏅᏅᎩ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎤᎾᏓᏙᎵᏍᏓᏁᎸᎩ, ᎾᏍᎩ ᎦᏍᎩᎸ ᎤᏪᎵ, ᎯᎠ ᎾᏂᏪᏍᎬᎩ, ᎡᎺᏅ; ᏱᎰᏩ ᎡᏗᎸᏉᏓ.


text:
ᎠᎴ ᎠᏆᏛᎦᏅᎩ ᎤᏂᏣᏘ ᏣᏂᏁᎪ ᎾᏍᎩᏯᎢ, ᎠᎴ ᎤᏣᏘ ᎠᎹ ᏧᏍᏆᏃᏴᎪ ᎾᏍᎩᏯᎢ, ᎠᎴ ᎤᏣᏘ ᏓᏴᏓᏆᎶᏍᎬ ᏥᏚᏍᏆᏃᏴᎪ ᎾᏍᎩᏯᎢ, ᎯᎠ ᎾᏂᏪᏍᎬᎩ, ᏱᎰᏩ ᎡᏗᎸᏉᏓ; ᎤᎬᏫᏳᎯᏰᏃ ᎤᏁᎳᏅᎯ ᏫᎾᏍᏛᎾ ᎤᎵᏂᎩᏛ ᎤᎬᏫᏳᏌᏕᎦ.


text:
ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎰᏪᎸᎦ, (ᎯᎠᏅᎦ,) ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎾᏍᎩ Ꮎ ᎤᏃᏕᎾ-ᎠᎩᎾ ᏣᎦᏨᏍᏙᏗᏱ ᏧᎾᎵᏍᏓᏴᏗᏱ ᎨᏒ ᎤᏂᎷᎯᏍᏗᏱ ᎨᏥᏯᏅᎥ ᎨᏎᏍᏗ. ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎯᎠ ᎾᏍᎩ ᎤᏙᎯᏳᎯ ᎢᏳᏪᏛ ᎤᏁᎳᏅᎯ.


text:
ᏚᎳᏍᎬᏃ ᎠᏆᏓᏅᏅᎩ ᏓᏥᏯᏓᏙᎵᏍᏓᏁᎵᏒᎩ. ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎥᏞᏍᏗ. ᎠᏴᏰᏃ ᎤᏠᏱᏉ ᎡᎩᏂᏅᏏᏓᏍᏗ, ᎠᎴ ᎠᏴ ᎾᏍᎩ ᎢᏣᎵᏅᏟ ᏥᎨᏒ ᎾᏍᎩ ᏥᏌ ᎤᏤᎵ ᎪᎯᏳᏗᏍᎩ ᎤᏂᎯ; ᎤᏁᎳᏅᎯ ᎯᏯᏓᏙᎵᏍᏓᏏ; ᎠᏙᎴᎰᎯᏍᏙᏗᏰᏃ ᎨᏒ ᎠᏓᏅᏙ ᎠᎴ ᏥᏌ ᎪᎯᏳᏓᏁᏗᏱ ᎤᏠᏱᏉ.


text:
ᎠᎩᎪᎲᎩᏃ ᎦᎸᎶᎢ ᎤᎵᏍᏚᎢᏛ ᎨᏒᎩ, ᎠᎴ ᎬᏂᏳᏉ ᎤᏁᎬ ᏐᏈᎵ (ᎥᏥᎪᎥᎩ;) ᎠᎴ ᎾᏍᎩ ᎾᎿ ᎤᎩᎵ, ᏄᏓᎵᏓᏍᏛᎾ ᎠᎴ ᏚᏳᎪᏛ (ᎢᏯᏛᏁᎯ) ᎠᎪᏎᎲᎩ, ᎠᎴ ᏚᏳᎪᏛ ᎬᏗᏍᎬ ᏕᎫᎪᏗᎭ ᎠᎴ ᏓᎿᏩ ᎪᏢᏍᎦ.


text:
ᎠᎴ ᎠᎰᎵ ᏗᎦᏄᎪᎦ ᎪᏍᏓᏯ ᎭᏰᎳᏍᏗᎦᏅᎯᏛ, ᎾᏍᎩ ᏧᏩᏂᏍᏙᏗᏱ ᎤᎾᏓᏤᎵᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ; ᎠᎴ ᏔᎷᎩᏍᎩ ᎬᏗ ᏗᎬᏩᏁᎶᏙᏗᏱ ᏅᏓᎬᏁᎵ; ᎠᎴ ᏖᎸᎳᏗ ᎦᏨᏩᏍᏙᏗᏱ ᎠᎳᏍᏓᎡᎭ ᎾᏍᎩ ᎤᏓᏑᏱ ᎤᏍᎦᏎᏗ ᎠᎴ ᎤᏔᎳᏬᎯᏍᏗ ᎨᏒ ᏫᎾᏍᏛᎾ ᎤᎵᏂᎩᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵᎦ.


text:
ᏗᎧᎿᏩᏗᏙᎯᏃ ᎥᏥᎪᎥᎩ ᏅᏙ ᎢᎦᎡᎯ ᎧᎸ ᎬᏙᎬᎩ; ᎠᎴ ᎤᏪᎷᏅᎩ ᎠᏍᏓᏯ ᎤᏁᏨᎩ, ᎯᎠ ᏂᏚᏪᏎᎸᎩ ᎾᎯᎥ ᏥᏍᏆ ᎦᎸᎶ ᎠᏰᎵ ᎠᏂᏃᎯᎵᏙᎯ, ᎡᏤᎾ ᎢᏣᏓᏟᏌ ᎠᏥᎸᏉᏗ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᎵᏍᏓᏴᏗᏱ ᎨᏒᎢ;


text:
ᎾᏍᎩ ᎢᏥᎩᏍᏗᏱ ᎤᏂᎬᏫᏳᎯ ᎤᏂᏇᏓᎸᎢ, ᎠᎴ ᎠᏂᏍᎦᏰᎬᏍᏓ ᎤᏂᏇᏓᎸᎢ, ᎠᎴ ᏧᎾᎵᏂᎩᏛ ᎠᏂᏍᎦᏯ ᎤᏂᏇᏓᎸᎢ, ᎠᎴ ᏐᏈᎵ ᎤᏂᏇᏓᎸᎢ, ᎠᎴ ᎾᏍᎩ ᎾᏧᎾᎩᎸᏗ, ᏂᏗᎨᏥᎾᏝᎥᎾ ᎠᎴ ᏗᎨᏥᎾᏝᎢ, ᎾᏍᏉ ᏧᎾᏍᏗ ᎠᎴ ᏧᎾᏔᏅ.


text:
ᎠᎴ ᎾᏍᎩ ᎾᏅᎩ-ᏗᎦᏅᏌᏗ ᎥᏥᎪᎥᎩ, ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎡᎶᎯ ᏓᏁᏩᏗᏒᎢ, ᎠᎴ ᎾᏍᎩ ᏧᎾᏤᎵ ᎠᏂᏯᏫᏍᎩ, ᎤᎾᏓᏟᏌᏅᎩ ᏓᎿᏩ ᎢᏳᏅᏁᏗᏱ ᎤᏂᏰᎸᏒᎩ ᎾᏍᎩ Ꮎ ᏐᏈᎵᎯ ᎤᎩᎵ, ᎠᎴ ᎾᏍᎩ ᏧᏤᎵ ᎠᏂᏯᏫᏍᎩ.


text:
ᏅᎩᏃ-ᏗᎦᏅᏌᏗ ᎠᏥᏴᎩᏅᎩ, ᎠᎴ ᎠᎦᏠᏯᏍᏔᏅᎩ ᎤᏠᎾᏍᏗ ᎠᏙᎴᎰᏍᎩ ᎾᏍᎩ ᎠᎦᏔᎲ ᎤᏍᏆᏂᎪᏗ ᏥᏚᎸᏫᏍᏓᏁᎲᎩ, ᎾᏍᎩ ᏥᏕᎦᎶᏄᎮᏗᏍᎬᎩ ᎾᏍᎩ Ꮎ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎤᏤᎵ ᎤᏓᏰᎸᏙᏗ ᏗᎨᏥᏰᎸᏔᏅᎯ, ᎠᎴ ᎾᏍᎩ Ꮎ ᏣᎦᏟᎶᏍᏔᏅᎯ ᎠᎾᏓᏙᎵᏍᏓᏁᎯ. ᎯᎠ ᎾᏍᎩ ᎢᏧᎳ ᏗᎬᏅᏃᏛ ᏫᎡᎨᎦᏓᎢᏅᏒᎩ ᎠᏥᎸ ᏨᏓᎸ ᎾᎿ ᏌᎪᏂᎨ ᎠᏓᏪᎳᎩᏍᎩ ᏗᏓᏪᎳᎩᏍᎬᎢ.


text:
ᎠᎴ ᏫᎾᏍᏛᎾ ᏗᏔᎴᏒ ᏩᎦᏓᎢᏅᏒᎩ, ᎠᎴ ᎠᏥᏍᏚᏅᎩ, ᎠᎴ ᎤᏰᎸᏔᏅᎩ ᎠᏍᏚᎲᎢ, ᎾᏍᎩ ᏗᎬᏩᎶᏄᎮᏗ ᎿᏉ ᏂᎨᏒᎾ ᎢᏳᎵᏍᏙᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᏓᏁᏩᏗᏒᎢ, ᎬᏂ ᏌᏉ ᎢᏯᎦᏴᎵ ᎢᏧᏕᏘᏴᏛ ᏳᎶᏐᏅ; ᎣᏂᏃ ᎿᏉ ᎠᏥᎪᏗ ᎢᎨᏎᏍᏗ ᏞᎦ.


text:
ᎠᎴ ᏓᎩᎪᎲ ᏕᎦᏍᎩᎸᎢ, ᎾᎿᏃ ᎤᎾᏅᏅᎩ ᎠᎴ ᏧᏄᎪᏙᏗᏱ ᎥᎨᎦᎵᏍᎪᎸᏓᏁᎸᎩ; ᎠᎴ ᏙᏥᎪᎥᎩ ᏧᎾᏓᏅᏙ ᏗᎨ ᏥᏍᎫᏕᏒᎯ ᎾᏍᎩ ᏥᏌ ᎠᏂᏃᎮᏍᎬ ᎤᏂᏍᏛᏛᎯ ᎠᎴ ᎧᏃᎮᏛ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏂᏃᎮᏍᎬᎢ, ᎠᎴ ᎾᏍᎩ ᎤᎾᏓᏙᎵᏍᏓᏁᎸᎯ ᏂᎨᏒᎾ ᏅᎩ-ᏗᎦᏅᏌᏗ, ᎠᎴ ᎾᏍᎩ ᏣᎦᏟᎶᏍᏔᏅᎯ, ᎠᎴ ᏗᎨᎪᏪᎳᏅᎯ ᏂᎨᏒᎾ ᏗᏂᎬᏓᎨᏂ, ᎠᎴ ᏧᏃᏰᏂ; ᎠᎴ ᎾᏍᎩ ᎦᎶᏁᏛ ᎢᏧᎳᎭ ᎠᏁᎲᎩ ᎠᎴ ᎤᏂᎬᏫᏳᎯ ᎥᎨᏒᎩ ᏌᏉ ᎢᏯᎦᏴᎵᎢᏧᏕᏘᏴᏛ.


text:
ᎣᏏᏳ ᎢᏳᎵᏍᏓᏁᏗ ᎠᎴ ᎾᏍᎦᏅᎾ ᎾᏍᎩ ᎾᎤᏪᎳᏗᏍᏗᏍᎩ ᎢᎬᏱᏱ ᏗᎴᎯᏐᏗ ᎨᏒᎢ; ᎾᏍᎩ ᎥᏝ ᎪᎱᏍᏗ ᏴᎬᏩᏅᎦ ᏔᎵᏁ ᎠᏲᎱᎯᏍᏗ ᎨᏒᎢ, ᎠᏥᎸᏍᎩᏂ-ᏗᏁᎶᎯ ᎨᏎᏍᏗ ᎤᏁᎳᏅᎯ ᎠᎴ ᎦᎶᏁᏛ, ᎠᎴ <n>[ᎦᎶᏁᏛ]</n> ᎢᏧᎳᎭ ᎤᏂᎬᏫᏳᎯ ᎨᏎᏍᏗ ᏌᏉ ᎢᏯᎦᏴᎵ ᎢᏧᏕᏘᏴᏛ.


text:
ᎠᎴ ᏛᎡᏙᎵ ᏧᎶᏄᎮᏗᏱ ᏧᎾᏓᎴᏅᏛ ᏴᏫ ᎾᏍᎩ ᏅᎩ ᏂᏚᏓᎠᏗᏒ ᏓᏁᏩᏗᏒᎢ ᎡᎶᎯ ᏣᏁᎭ ᎾᏍᎩ ᎪᎦ ᎠᎴ ᎺᎪᎦ, ᎾᏍᎩ ᏧᏪᏟᏐᏗᏱ ᏧᎾᎵᏍᏗᏱ; ᎾᏂᎥᏃ ᏃᏳ ᎠᎺᏉᎯ ᎠᎲ ᎾᏂᎥ.


text:
ᎠᏍᎩᎾᏃ ᎾᏍᎩ ᎤᏂᎶᏄᎮᎸᎯ ᎠᏥᎸ ᎠᎴ ᏌᎪᏂᎨ ᎠᏓᏪᎳᎩᏍᎩ ᎥᏓᎸ ᏩᎦᏓᎢᏅᏒᎩ, ᎾᎿ ᎠᏁᎲ ᏅᎩ-ᏗᎦᏅᏌᏗ ᎠᎴ ᎤᏠᎾᏍᏗ ᎠᏙᎴᎰᏍᎩ, ᎠᎴ ᎨᏥᎩᎵᏲᎢᏍᏙᏗ ᎨᏎᏍᏗ ᏂᎪᎯᎸ ᎠᎴ ᏂᎪᎯᎸᎢ.


text:
ᎠᎴ ᎠᎩᎪᎲᎩ ᎡᏆ ᎤᏁᎬ ᎦᏍᎩᎶ, ᎠᎴ ᎾᏍᎩ ᎾᎿ ᎤᏪᎵ, ᎾᏍᎩ ᎤᎧᏛᎢ ᎡᎶᎯ ᎠᎴ ᎦᎸᎶᎢ ᎬᏩᎵᎡᎸᎩ, ᎥᏝ ᎠᎴ ᎢᎸᎯᏢ ᎬᏩᎵᎡᎸᎩ, ᎥᏝ ᎠᎴ ᎢᎸᎯᏢ ᎬᏩᏛᏗ ᏱᎨᏎ ᏭᏂᎶᎯᏍᏗᏱ.


text:
ᎠᎴ ᏧᏂᏲᎱᏒᎯ ᎥᎦᏥᎪᎥᎩ, ᏧᎾᏍᏗ ᎠᎴ ᏧᎾᏛᎾ, ᎤᏁᎳᏅᎯ ᎤᏬᎸ ᎢᎬᏱᏗᏢ ᏚᎾᎴᏅᎩ; ᎪᏪᎵᏃ ᏚᏂᏍᏚᎢᏒᎩ; ᎠᎴ ᏅᏩᏓᎴ ᎪᏪᎵ ᎤᏂᏍᏚᎢᏒᎩ, ᎾᏍᎩ ᎬᏂᏛ ᎠᏓᏁᎯ ᏥᎩ; ᏧᏂᏲᎱᏒᎯᏃ ᏙᎨᎫᎪᏓᏁᎸᎩ ᎾᏍᎩᏯ ᏂᎬᏅ ᎪᏪᎸ ᎪᏪᎵᎯ, ᎾᏍᎩᏯ ᏄᏍᏛ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ.


text:
ᎠᎺᏉᎯᏃ ᏚᏲᏒᎩ ᏧᏂᏲᎱᏒᎯ ᎾᎿ ᏄᎾᏛᏅᎢ; ᎠᏲᎱᎯᏍᏗᏃ ᎠᎴ ᏨᏍᎩᏃ ᏚᏂᏲᏒ ᏧᏂᏲᎱᏒᎯ ᎾᎿ ᎠᏁᎲᎢ; ᎠᎴ ᏕᎨᎫᎪᏓᏁᎸᎩ ᏂᎦᏗᏳ ᎠᏂᏏᏴᏫᎭ ᎾᏍᎩᏯ ᏄᏍᏛ ᏚᏂᎸᏫᏍᏓᏁᎸᎢ.


text:
ᎠᏆᏛᎦᏅᎩᏃ ᎠᏍᏓᏯ ᎧᏁᎬ ᎩᎶ ᎦᎸᎳᏗ ᏛᏓᎴᎲᏍᎬᎩ ᎯᎠ ᏂᎦᏪᏍᎬᎩ, ᎬᏂᏳᏉ ᎤᏁᎳᏅᎯ ᎤᎵᏦᏛ ᏴᏫ ᎠᏁᎲ ᎤᏓᏑᏯ, ᎠᎴ ᎤᏁᎳᏅᎯ ᎾᏍᎩ ᎠᏁᎲ ᏛᏕᏂ, ᎠᎴ ᎾᏍᎩ ᏧᏤᎵ ᎨᏎᏍᏗ ᏴᏫ, ᎤᏁᎳᏅᎯᏃ ᎤᏩᏒ ᎾᏍᎩ ᎠᏁᎲ ᎡᎮᏍᏗ ᎤᎾᏤᎵ ᎤᏁᎳᏅᎯᎨᏎᏍᏗ.


text:
ᎠᎴ ᎤᏁᎳᏅᎯ ᏙᏓᎦᏅᎦᎸᎯ ᏂᎦᏛ ᏓᏂᎦᏌᏬᎢᎲᎢ; ᎥᏝ ᎠᎴ ᎿᏉ ᏰᎮᏍᏗ ᎠᏲᎱᎯᏍᏗ, ᎠᎴ ᎤᏲ ᎠᏰᎸᏗ ᎨᏒ, ᎠᎴ ᏗᏠᏯᏍᏗ ᎨᏒᎢ, ᎥᏝ ᎠᎴ ᎿᏉ ᏰᎮᏍᏗ ᎡᎯᏍᏗ ᎨᏒᎢ; ᎢᎬᏱᏱᏰᏃ ᏧᏓᎴᏛ ᏤᎲ ᎤᎶᏐᏅ.


text:
ᎦᏍᎩᎸᏃ ᎤᏬᎵ, ᎯᎠ ᏄᏪᏒᎩ, ᎬᏂᏳᏉ ᏂᎦᏗᏳ ᏧᏓᎴᏅᏛ ᎢᏤ ᏂᎬᏁᎭ. ᎠᎴ ᎯᎠ ᎾᎩᏪᏎᎸᎩ, ᎰᏪᎸᎦ; ᎯᎠᏰᏃ ᎾᏍᎩ ᎧᏃᎮᏛ ᎬᏜᏏᏛᎡᏗ ᏂᎨᏒᎾ ᎠᎴ ᎤᏙᎯᏳᎯᏯ.


text:
ᎠᎴ ᎯᎠ ᎾᎩᏪᏎᎸᎩ; ᎾᏍᎩ ᏂᏌᎵᏍᏓ. ᎠᏴ ᎡᎵᏆ ᎠᎴ ᎣᎻᎦ, ᎢᎬᏱᏱ ᎨᏒ ᎠᎴ ᎤᎵᏍᏆᎸᏗ ᎨᏒᎢ. ᎤᏔᏕᎩᏍᎩ ᎠᎹ ᎬᏂᏛ ᎠᏓᏁᎯ ᎦᏄᎪᎬ ᏓᏥᏁᏁᎵ ᏧᎬᏩᎶᏗ ᏂᎨᏒᎾ.


text:
ᎤᏂᏍᎦᎡᎾᏍᎩᏂ. ᎠᎴ ᏄᏃᎯᏳᏒᎾ, ᎠᎴ ᎤᏂᏍᎦᎢᏍᏗ, ᎠᎴ ᏗᎾᏓᎯᎯ, ᎠᎴ ᎤᏂᏁᎫᏥᏛ, ᎠᎴ ᏗᎾᏙᏂᏍᎩ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎾᏓᏙᎵᏍᏓᏁᎯ, ᎠᎴ ᏂᎦᏗᏳ ᎠᏂᏰᎪᎩ, ᎤᎾᏤᎵ ᎢᎨᎬᏁᏗ ᎨᏎᏍᏗ ᎥᏓᎸ ᎾᎿ ᎠᏓᏪᎵᎩᏍᎬ ᎠᏥᎸ ᎠᎴ ᏌᎪᏂᎨ ᎠᏓᏪᎵᎩᏍᎩ; ᎾᏍᎩ ᏔᎵᏁ ᎠᏲᎱᎯᏍᏗ ᏥᎩ.


text:
ᎠᎩᎷᏤᎸᎩᏃ ᎠᏏᏴᏫ ᎾᏍᎩ Ꮎ ᎦᎵᏉᎩ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᏙᎯ, ᎾᏍᎩ ᏥᏓᏂᏰᎲᎩ ᏚᎵᏉᎩ ᎫᎫ ᎦᎵᏉᎩ ᎤᎵᏍᏆᎸᏗ ᎤᏕᏯᏙᏗ ᏗᏟᏍᏗ, ᎠᎴ ᎠᏆᎵᏃᎮᏔᏅᎩ, ᎯᎠ ᏄᏪᏒᎩ; ᎡᎮᎾ, ᏓᎬᏯᏎᎮᎵᏃ ᎠᏥᏰᎯ ᎤᏃᏕᎾ ᎠᎩᎾ ᎤᏓᎵᎢ.


text:
ᎠᏆᏘᎾᏫᏛᎲᎩᏃ ᏗᏆᏓᏅᏛ ᎡᏆ ᎠᎴ ᎢᏅ ᎢᎦᏘ ᏦᏓᎸᎢ ᏩᏆᏘᏅᏍᏔᏅᎩ, ᎠᎴ ᎠᎩᎾᏄᎪᏫᏎᎸᎩ ᎾᎡᏆ ᎦᏚᎲᎢ, ᎾᏍᎩ ᎦᎸᏉᏗ ᏥᎷᏏᎵᎻ, ᎡᎳᏗ ᏅᏓᏳᏍᏗᏗᏒᎩ ᎦᎸᎳᏗ ᎤᏁᎳᏅᎯᏱ ᏛᏓᎴᎲᏍᎬᎩ.


text:
ᎠᏐᏴᎩᏃ ᎡᏆ ᎢᏅ ᎢᎦᏘ, ᎦᎶᎯᏍᏗᏱᏃ ᏔᎳᏚ ᏕᎪᏢᏒᎩ, ᎠᎴ ᎦᎶᎯᏍᏗᏱ ᏔᎳᏚ ᎢᏯᏂᏛ ᏗᏂᎧᎿᏩᏗᎩᎯ <n>[ᏓᏂᏙᎬᎩ,]</n> ᏚᎾᏙᎥᏃ ᏕᎪᏪᎸᎩ ᎦᎶᎯᏍᏗᏱ, ᎾᏍᎩ ᏔᎳᏚ ᎾᏂᎳᏍᏓᎸ ᎢᏏᎵ ᏧᏪᏥ ᏚᎾᏙᎥᎢ.


text:
ᎦᏚᎲᏃ ᏅᎩ ᏧᏅᏏᏴ ᎨᏒᎩ, ᎦᏅᎯᏒ ᎠᎴ ᎠᏯᏛᎥ ᎤᏠᏱᏉ ᎨᏒᎩ. ᎤᏟᎶᎥᎩᏃ ᎦᏚᎲ ᎤᏩᏔᏅᎩ ᎠᏟᎶᏍᏗ, ᎯᏍᎩᎦᏚ ᎢᏯᏍᎪᎯᏧᏈ ᎢᏳᏟᎶᏛ ᏂᎬᎩ. ᏂᎦᏅᎯᏒ ᎠᎴ ᎾᏯᏛᎲ ᎠᎴ ᏂᎦᏛᎢ ᎤᏠᏱᏉ ᎨᏒᎢ.


text:
ᏔᎳᏚᏃ ᏕᎪᏢᏒ ᏗᏍᏚᏗ ᏔᎳᏚ ᏓᎬᎾᎢᏳᎾᏍᏗ ᏕᎪᏢᏛᎩ; ᏌᏉ ᎠᏍᏚᏗ ᏌᏉ ᏓᎬᎾᎢᏳᏍᏗ ᎪᏢᏛᎩ ᎡᏓᏍᏗᏱ ᎤᏜᏅᏛ ᎦᏚᎲ ᎪᎱᏍᏗ ᎾᏑᏴᎾ ᎠᏕᎸ ᏓᎶᏂᎨ ᎠᏢᏛᎩ, ᏧᎸᏌᏛ ᎠᏓᎨᏗ ᎾᏍᎩᏯᎢ.


text:
ᎦᏚᎲᏃ ᎥᏝ ᏯᎾᏚᎵ ᏅᏙ-ᎢᎦ-ᎡᎯ ᎠᎴ ᏅᏙ-ᎡᏃᏱ-ᎡᎯ ᎤᎦᎵᎯᏍᏗᏱ ᎾᎿᏂ; ᎦᎸᏉᏗᏳᏰᏃ ᎨᏒ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎢᎦᎤᏘᏍᏛ ᎾᎿᏂ, ᎠᎴ ᎤᏃᏕᎾ-ᎠᎩᎾ ᎢᎦ ᎠᏘᏍᏗᏍᎩ ᎢᎩ ᎾᎿᏂ.


text:
ᎠᎴ ᎥᏝ ᎠᏎᎾᎿ ᎤᏴᏍᏗ ᏱᎨᏎᏍᏗ ᎪᎱᏍᏗ ᎦᏓᎭ, ᎠᎴ ᎤᏂᏆᏘᏍᏗ ᏧᎸᏫᏍᏓᏁᎯ, ᎠᎴ ᎦᏰᎪᎩ; ᎤᏅᏒᏍᎩᏂ <n>[ᎤᏂᏴᏍᏗ ᎨᏎᏍᏗ ᏚᎾᏙᎥ]</n> ᏗᎪᏪᎵ ᎬᏂᏛ ᎠᏓᏁᎯ ᎪᏪᎵᎯ ᎤᏃᏕᎾᎠᎩᎾ ᎤᏤᎵᎦ.


text:
ᎠᏰᎵᏃ ᎤᏜᏅᏛ ᎾᎿ ᎡᏓᏍᏗᏱ, ᎠᎴ ᎢᏧᎳᏗᏢ ᎤᏪᏴᎢ, ᏡᎬᎩ ᎬᏂᏛ ᎠᏓᏁᎯ ᏡᎬᎢ, ᎾᏍᎩ ᏔᎳᏚ ᎢᏳᏓᎴᎩ ᎠᏓᏛᏍᎬᎩ ᎠᎴ ᏂᏓᏦᎳᏂᏒ ᎬᎾᏍᎬᎩ ᎤᏓᏔᏅᎯ; ᎤᎳᏍᏚᏒᏃ ᎤᎾᏅᏬᏗ ᎨᏒᎩ ᏧᎾᏓᎴᏅᏛ ᏴᏫ.


text:
ᎥᏝ ᎠᎴ ᎡᏃᏱ ᏱᎨᏎᏍᏗ ᎾᎿᏂ, ᎥᏝ ᎠᎴ ᏳᎾᏚᎵ ᎠᏨᏍᏙᏗ, ᎠᎴ ᏅᏙ ᎢᎦᎡᎯ ᎢᎦ ᎤᏘᏍᏛᎢ; ᎤᎬᏫᏳᎯᏰᏃ ᎤᏁᎳᏅᎯ ᎢᎦ ᏓᏘᏍᏓᏁᎭ, ᎤᏂᎬᏫᏳᎯᏃ ᎨᏎᏍᏗ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ.


text:
ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎯᎠ ᎾᏍᎩ ᎧᏃᎮᏛ ᎬᏜᏏᏛᎡᏗ ᏂᎨᏒᎾ ᎠᎴ ᎤᏙᎯᏳᎯᏯ. ᎤᎬᏫᏳᎯᏃ ᎤᏁᎳᏅᎯ ᎨᏥᎸᏉᏗ ᎠᎾᏙᎴᎰᏍᎩ ᎤᎾᏤᎵᎦ ᏧᏅᏎ ᎤᏤᎵ ᏗᎧᎿᏩᏗᏙᎯ ᎬᏂᎨᏒ ᎢᏧᏩᏁᏗᏱ ᏧᏤᎵ ᏧᏅᏏᏓᏍᏗ, ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᏂᎪᎯᎸᎾᏉ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ.


text:
ᎠᎴ ᎠᏴ ᏣᏂ ᎠᎩᎪᎲᎩ ᎯᎠ ᎾᏍᎩ ᏧᏓᎴᏅᏛ, ᎠᎴ ᎠᏆᏛᎦᏅᎩ. ᎠᏆᏛᎦᏅᏃ ᎠᎴ ᎠᎩᎪᎲ, ᎡᎳᏗ ᎠᏆᏓᏅᏅᎩ ᏓᎦᏓᏙᎵᏍᏔᏂᏒᎩ ᏚᎳᏍᎬ ᎾᏍᎩ ᎾᏗᎧᎿᏩᏗᏙᎯ ᎯᎠ ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᎠᎩᎾᏄᎪᏫᏎᎸᎯ.


text:
ᎯᎠᏃ ᎾᎩᏪᏎᎸᎩ, ᎥᏞᏍᏗ. ᎠᏴᏰᏃ ᎤᏠᏱᏉ ᎡᎩᏂᏅᏏᏓᏍᏗ, ᎠᎴ ᎠᏴ ᎾᏍᎩ ᎠᎾᏙᎴᎰᏍᎩ ᏥᎨᏒ ᎢᏣᎵᏅᏟ, ᎠᎴ ᎾᏍᎩ ᎠᏂᏍᏆᏂᎪᏗᏍᎩ ᎧᏃᎮᏛ ᎠᏂ ᎪᏪᎵᎯ ᎪᏪᎸᎢ; ᎤᏁᎳᏅᎯ ᎯᏯᏓᏙᎵᏍᏓᏏ.


text:
ᎩᎶ ᎠᏍᎦᎾ ᎨᏎᏍᏗ, ᎠᏏᏉ ᎠᏍᎦᎾ ᎨᏎᏍᏗ; ᎩᎶᏃ ᎦᏓᎭ ᎨᏎᏍᏗ, ᎠᏏᏉ ᎦᏓᎭ ᎨᏎᏍᏗ; ᎩᎶᏃ ᎣᏏᏳ ᎢᏯᏛᏁᎯ ᎨᏎᏍᏗ, ᎠᏏᏉ ᎣᏏᏳ ᎢᏯᏛᏁᎯ ᎨᏎᏍᏗ; ᎩᎶᏃ ᎠᏍᎦᎾ ᏂᎨᏒᎾ ᎨᏎᏍᏗ, ᎠᏏᏉ ᎠᏍᎦᎾ ᏂᎨᏒᎾ ᎨᏎᏍᏗ.


text:
ᎣᏏᏳ ᎢᏳᎾᎵᏍᏓᏁᏗ ᎾᏍᎩ Ꮎ ᎤᏤᎵ ᏗᎧᎿᏩᏛᏍᏗ ᏂᎦᏪᏍᎬ ᎢᏯᎾᏛᏁᎯ, ᎾᏍᎩ ᎬᏂᏛ ᏡᎬ ᎤᎾᏤᎵ ᎢᏳᎵᏍᏙᏗᏱ, ᎠᎴ ᏫᎬᏩᏂᏴᏍᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎦᎶᎯᏍᏗᏱ ᎪᏢᏒ ᎦᏚᎲᎢ.


text:
ᏙᏱᏗᏢᏰᏃ ᎠᏁᏙᎭ ᎩᎶ, ᎠᎴ ᏗᎾᏙᏂᏍᎩ, ᎠᎴ ᎤᏂᏁᎫᏥᏛ, ᎠᎴ ᏗᎾᏓᎯᎯ, ᎠᎴ ᎤᏁᎳᏅᎯ ᏗᏰᎸᎯ ᏗᎾᏓᏙᎵᏍᏓᏁᎯ, ᎠᎴ ᏂᎦᏗᏳ ᎣᏏᏳ ᎤᏂᏰᎸᎯ ᎦᏰᎪᎩ ᎨᏒ, ᎠᎴ ᎦᏰᎪᎩ ᎠᏃᏢᏍᎩ.


text:
ᎠᏴ ᏥᏌ ᏗᏥᏅᏒ ᎠᏆᏤᎵ ᏗᎧᎿᏩᏗᏙᎯ ᎬᏂᎨᏒ ᎢᏨᏁᏗᏱ ᎯᎠ ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᏧᎾᏁᎶᏗ ᏚᎾᏓᏡᏩᏗᏒᎢ. ᎠᏴ ᏕᏫ ᎤᏪᏥ ᎠᎴ ᎾᏍᎩ ᎤᏁᏢᏔᏅᏛ ᎨᏒᎢ, ᎠᎴ ᏃᏈᏏ ᏧᎦᏙᏴᎢᏍᏗ ᎠᎴ ᏑᎾᎴ ᎡᎯ.


text:
ᎠᏓᏅᏙᏃ ᎠᎴ ᎠᏥᏰᎯ ᎡᎮᎾ ᎠᎾᏗᎭ. ᎠᎴ ᎠᏛᎩᏍᎩ ᎡᎮᎾ ᎠᏗᏍᎨᏍᏗ. ᎠᎴ ᎩᎶ ᎤᏔᏕᎩᏍᎩ ᏫᎦᎷᎩ; ᎠᎴ ᎪᎶ ᎤᏚᎵᏍᎨᏍᏗ ᎦᏁᎩ ᏍᎨᏍᏗ ᎠᎹ ᎬᏂᏛ ᎠᏓᏁᎯ ᏧᎬᏩᎶᏗ ᏂᎨᏒᎾ.


text:
ᎬᏂᎨᏒᏰᏃ ᏂᎦᏥᏴᏁᎭ ᎾᏂᎥᏉ ᎩᎶ ᎠᎾᏛᎩᏍᎩ ᎧᏃᎮᏛ ᎠᏙᎴᎰᏒᎯ ᎠᏂ ᎪᏪᎵᎯ ᏥᎪᏪᎳ, ᎾᏍᎩ ᎢᏳᏃ ᎩᎶ. ᎢᎧᏁᏉᏍᎨᏍᏗ ᎯᎠ ᎾᏍᎩ ᏧᏓᎴᏅᏛ ᎠᏂ ᎪᏪᎵᎯ ᏥᎪᏪᎳ, ᎤᏁᎳᏅᎯ ᎠᏎ ᎤᏁᏉᎡᏗ ᎨᏎᏍᏗ ᎤᏕᏯᏙᏗ ᎨᏒ ᎠᏂ ᎪᏪᎵᎯ ᏥᎪᏪᎳ;


text:
ᎢᏳ ᎠᎴ ᎩᎶ ᎢᎪᏣᎴᏍᎨᏍᏗ ᎢᎦᏛ ᎧᏃᎮᏛ ᎪᏪᎵᎯ ᎯᎠ ᎾᏍᎩ ᎠᏙᎴᎰᏒᎯ ᎨᏒᎢ, ᎤᏁᎳᏅᎯ ᎠᏎ ᏓᏳᏬᏣᎳᎡᎵ ᎤᏤᎵ ᎨᏒ ᎬᏂᏛ ᎠᏓᏁᎯ ᎪᏪᎵᎯ, ᎠᎴ ᎦᎸᏉᏗᏳ ᎦᏚᎲᎢ, ᎠᎴ ᏧᏓᎴᏅᏛ ᎪᏪᎸ ᎠᏂ ᎪᏪᎵᎯ.


