ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚲᛃᛒᛖᚱ-ᚠᛃᛊᛁᚲᚨᛚ ᛞᛖᚠᛖᚾᛊᛖ ᚠᛟᚱ ᛉ: ᛁᛞᛖᚾᛏᛁᛏᛃ, ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ, ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ, ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ, ᚱᛖᚲᛖᛃᛁᛜ, ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ, ᚨᚾᛞ ᚨᛏᛏᛖᛊᛏᛖᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ

1. ᛖᚲᛊᛖᚲᚢᛏᛁᚹᛖ ᛊᚢᛗᛗᚨᚱᛃ

ᛗᛟᛞᛖᚱᚾ ᚲᛃᛒᛖᚱ-ᚠᛃᛊᛁᚲᚨᛚ ᛊᛃᛊᛏᛖᛗᛊ ᚨᚾᛞ ᛗᚢᛚᛏᛁ-ᛏᛖᚾᚨᚾᛏ ᛈᛚᚨᛏᚠᛟᚱᛗᛊ ᚠᚨᚲᛖ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᛖᛊ ᚲᚨᛈᚨᛒᛚᛖ ᛟᚠ ᛊᚢᛒᚹᛖᚱᛏᛁᛜ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ, ᛗᚨᚾᛁᛈᚢᛚᚨᛏᛁᛜ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾᛊ, ᚨᚾᛞ ᚠᛟᚱᚷᛁᛜ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛖᚹᛁᛞᛖᚾᚲᛖ. ᚦᛖ ᛉ ᛈᛚᚨᛏᚠᛟᚱᛗ ᚱᛖᚲᚹᛁᚱᛖᛊ ᚨ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚦᚨᛏ ᛊᚺᛁᚠᛏᛊ ᚨᚹᚨᛃ ᚠᚱᛟᛗ ᚱᛖᚨᚲᛏᛁᚹᛖ ᛈᛖᚱᛁᛗᛖᛏᛖᚱ ᛞᛖᚠᛖᚾᛊᛖ ᛏᛟᚹᚨᚱᛞ ᚨ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛈᚱᛟᚹᚨᛒᛚᛖ, ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛒᛟᚢᚾᛞ ᛉᛖᚱᛟ-ᛏᚱᚢᛊᛏ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ. ᚦᛁᛊ ᚱᛖᛈᛟᚱᛏ ᛞᛖᛏᚨᛁᛚᛊ ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᚨᛚ ᛞᛖᛊᛁᚷᚾ ᚠᛟᚱ ᚨᚾ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛊᛃᛊᛏᛖᛗ ᚲᚨᛈᚨᛒᛚᛖ ᛟᚠ ᚲᛟᚾᛏᛁᚾᚢᛟᚢᛊ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ, ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ, ᚨᚢᛏᛟᛗᚨᛏᛖᛞ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ, ᚨᚾᛞ ᚨᛏᛏᛖᛊᛏᛖᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ.
ᚱᛟᛟᛏᛖᛞ ᛁᚾ ᚦᛖ ᛁᛖᛏᚠ ᚱᛖᛗᛟᛏᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛈᚱᛟᚲᛖᛞᚢᚱᛖᛊ (ᚱᚨᛏᛊ) ᚠᚱᚨᛗᛖᚹᛟᚱᚲ1, ᛊᛈᛁᚠᚠᛖ/ᛊᛈᛁᚱᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ2, ᚦᛖ ᚢᛈᛞᚨᛏᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ (ᛏᚢᚠ) ᚨᚾᛞ ᚢᛈᛏᚨᚾᛖ ᚠᛟᚱ ᚨᚢᚦᛟᚱᛁᛏᛃ ᚨᚾᛞ ᛖᛈᛟᚲᚺ ᛗᚨᚾᚨᚷᛖᛗᛖᚾᛏ4, ᚨᚾᛞ ᚱᚠᚲ 6962 ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ ᛚᛟᚷᛊ6, ᚦᛁᛊ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛈᚱᛟᚹᛁᛞᛖᛊ ᚨ ᛞᛖᛏᛖᚱᛗᛁᚾᛁᛊᛏᛁᚲ ᛞᛖᚠᛖᚾᛊᛖ ᛗᛟᛞᛖᛚ. ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛖᚹᚨᛚᚢᚨᛏᛖᛊ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚠᚨᚢᛚᛏ ᛁᚾᛃᛖᚲᛏᛁᛟᚾᛊ—ᛊᚢᚲᚺ ᚨᛊ ᚠᛟᚱᚷᛖᛞ_ᛁᛞᛖᚾᛏᛁᛏᛃ ᛟᚱ ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ_ᛒᚱᛖᚨᚲᚺ—ᚨᚾᛞ ᛁᛊᛊᚢᛖᛊ ᛒᛟᚢᚾᛞᛖᛞ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚱᛖᛊᛈᛟᚾᛊᛖᛊ ᚱᚨᛜᛁᛜ ᚠᚱᛟᛗ ᚨᛚᛚᛟᚹ_ᛟᛒᛊᛖᚱᚹᚨᛏᛁᛟᚾ ᛏᛟ ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ ᚨᚾᛞ ᚱᛖᛊᛏᛟᚱᛖ_ᚨᛏᛏᛖᛊᛏᛖᛞ_ᛒᚨᛊᛖᛚᛁᚾᛖ.
ᚦᛁᛊ ᛖᚲᛊᚺᚨᚢᛊᛏᛁᚹᛖ ᛊᛈᛖᚲᛁᚠᛁᚲᚨᛏᛁᛟᚾ ᛈᚱᛟᚹᛁᛞᛖᛊ ᛊᚲᚺᛖᛗᚨᛊ, ᛒᛖᚺᚨᚹᛁᛟᚱᚨᛚ ᛁᚾᚹᚨᚱᛁᚨᚾᛏᛊ, ᛈᛃᚦᛟᚾ ᛈᛊᛖᚢᛞᛟᚲᛟᛞᛖ ᚠᛟᚱ ᚲᛟᚱᛖ ᛊᛖᚱᚹᛁᚲᛖᛊ, ᚨᚾᛞ ᚨ ᚲᛟᛗᛈᚱᛖᚺᛖᚾᛊᛁᚹᛖ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚲᛃᛒᛖᚱ-ᚱᚨᛜᛖ ᛞᛖᛊᛁᚷᚾ ᛏᛟ ᛊᛁᛗᚢᛚᚨᛏᛖ ᚨᚾᛞ ᚹᚨᛚᛁᛞᚨᛏᛖ ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚹᛁᚦᛟᚢᛏ ᛖᛗᛈᛚᛟᛃᛁᛜ ᛟᚠᚠᛖᚾᛊᛁᚹᛖ ᚲᚨᛈᚨᛒᛁᛚᛁᛏᛁᛖᛊ.

2. ᚲᚨᛈᚨᛒᛁᛚᛁᛏᛃ ᚨᚾᛞ ᛏᚱᚨᚲᛖᚨᛒᛁᛚᛁᛏᛃ ᛊᛏᚨᛏᛖᛗᛖᚾᛏᛊ

ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚱᛖᚲᚹᛁᚱᛖᛊ ᛊᛏᚱᛁᚲᛏ ᚨᛞᚺᛖᚱᛖᚾᚲᛖ ᛏᛟ ᛈᚱᛖᛞᛖᚠᛁᚾᛖᛞ ᚲᛟᚾᛊᛏᚱᚨᛁᚾᛏᛊ ᚱᛖᚷᚨᚱᛞᛁᛜ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᚨᛚ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ ᚨᚾᛞ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛊᚲᛟᛈᛖ. ᚦᛖ ᚠᛟᛚᛚᛟᚹᛁᛜ ᛏᚨᛒᛚᛖᛊ ᚨᚾᛞ ᛞᛖᚲᛚᚨᚱᚨᛏᛁᛟᚾᛊ ᛗᚨᛈ ᚦᛖ ᚠᛟᚢᚾᛞᚨᛏᛁᛟᚾᚨᛚ ᚱᛖᚲᚹᛁᚱᛖᛗᛖᚾᛏᛊ ᛏᛟ ᚦᛖ ᛖᛜᛁᚾᛖᛖᚱᛁᛜ ᛟᚢᛏᛈᚢᛏᛊ ᛈᚱᛟᚹᛁᛞᛖᛞ ᚹᛁᚦᛁᚾ ᚦᛁᛊ ᛞᛟᚲᚢᛗᛖᚾᛏ.

2.1 ᛏᚱᚨᚲᛖᚨᛒᛁᛚᛁᛏᛃ ᛗᚨᛏᚱᛁᚲᛊ

2.2 ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚲᚨᛈᚨᛒᛁᛚᛁᛏᛁᛖᛊ ᛞᛖᛗᛟᚾᛊᛏᚱᚨᛏᛖᛞ

ᚦᛁᛊ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛞᛖᛗᛟᚾᛊᛏᚱᚨᛏᛖᛊ ᚦᛖ ᚨᛒᛁᛚᛁᛏᛃ ᛏᛟ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛁᛞᛖᚾᛏᛁᚠᛃ ᚹᛟᚱᚲᛚᛟᚨᛞᛊ ᚹᛁᚨ ᛏᛈᛗ 2.0 ᚨᚾᛞ ᛊᛈᛁᚱᛖ8, ᚨᛏᛏᛖᛊᛏ ᛏᛟ ᚦᛖ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᛟᚠ ᚨᛁ ᛗᛟᛞᛖᛚᛊ ᚢᛊᛁᛜ ᚲᛃᚲᛚᛟᚾᛖᛞᚲᛊ 1.6 ᚨᚾᛞ ᛊᛚᛊᚨ v1.010, ᛗᚨᚾᚨᚷᛖ ᛞᛁᛊᛏᚱᛁᛒᚢᛏᛖᛞ ᛏᚱᚢᛊᛏ ᚹᛁᚨ ᛏᚢᚠ ᛞᛖᛚᛖᚷᚨᛏᛁᛟᚾᛊ5, ᚨᚾᛞ ᛗᚨᛁᚾᛏᚨᛁᚾ ᛏᚨᛗᛈᛖᚱ-ᛖᚹᛁᛞᛖᚾᛏ ᚨᚢᛞᛁᛏ ᛚᛟᚷᛊ ᚹᛁᚨ ᚱᚠᚲ 6962 ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖᛊ13. ᛁᛏ ᛈᚱᛟᚹᛁᛞᛖᛊ ᚨᚢᛏᛟᛗᚨᛏᛖᛞ, ᚱᛖᚹᛖᚱᛊᛁᛒᛚᛖ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ ᚨᚾᛞ ᚦᚱᛖᛊᚺᛟᛚᛞ-ᛒᚨᛊᛖᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ ᛈᚱᛟᛏᛟᚲᛟᛚᛊ ᚦᚨᛏ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛈᚱᛖᚹᛖᚾᛏ ᚢᚾᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᛊᛏᚨᛏᛖ ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾᛊ.

2.3 ᚾᛟ ᛟᚠᚠᛖᚾᛊᛁᚹᛖ ᚲᚨᛈᚨᛒᛁᛚᛁᛏᛃ ᛁᛗᛈᛚᛁᛖᛞ

ᚦᛁᛊ ᛞᛟᚲᚢᛗᛖᚾᛏ ᚲᛟᚾᛏᚨᛁᚾᛊ ᛉᛖᚱᛟ ᛟᚠᚠᛖᚾᛊᛁᚹᛖ ᛗᚨᛏᛖᚱᛁᚨᛚ. ᛁᛏ ᛞᛟᛖᛊ ᚾᛟᛏ ᛈᚱᛟᚹᛁᛞᛖ ᛖᚲᛊᛈᛚᛟᛁᛏ ᚲᛟᛞᛖ, ᛗᚨᛚᚹᚨᚱᛖ, ᚱᚨᚾᛊᛟᛗᚹᚨᚱᛖ, ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚ ᚦᛖᚠᛏ ᛗᛖᚲᚺᚨᚾᛁᛊᛗᛊ, ᛈᛖᚱᛊᛁᛊᛏᛖᚾᚲᛖ ᛏᛖᚲᚺᚾᛁᚲᚹᛖᛊ, ᛖᚹᚨᛊᛁᛟᚾ ᛏᛖᚲᚺᚾᛁᚲᚹᛖᛊ, ᛞᛖᛊᛏᚱᚢᚲᛏᛁᚹᛖ ᛈᚨᛃᛚᛟᚨᛞᛊ, ᚢᚾᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᛊᚲᚨᚾᚾᛁᛜ ᛁᚾᛊᛏᚱᚢᚲᛏᛁᛟᚾᛊ, ᚱᛖᚨᛚ ᛁᚾᛏᚱᚢᛊᛁᛟᚾ ᛁᚾᛊᛏᚱᚢᚲᛏᛁᛟᚾᛊ, ᛟᚠᚠᛖᚾᛊᛁᚹᛖ ᚲᛟᛗᛗᚨᚾᛞ-ᚨᚾᛞ-ᚲᛟᚾᛏᚱᛟᛚ, ᚹᛖᚨᛈᛟᚾ-ᚲᛟᚾᛏᚱᛟᛚ ᛚᛟᚷᛁᚲ, ᛟᚱ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᚨᛚ ᛏᚨᚱᚷᛖᛏᛁᛜ. ᚨᛚᛚ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᚨᛚ ᛒᛖᚺᚨᚹᛁᛟᚱᛊ ᚨᚱᛖ ᛗᛟᛞᛖᛚᛖᛞ ᛖᚲᛊᚲᛚᚢᛊᛁᚹᛖᛚᛃ ᚨᛊ ᚨᛒᛊᛏᚱᚨᚲᛏ, ᛊᛃᚾᚦᛖᛏᛁᚲ ᚠᚨᚢᛚᛏ ᛁᚾᛃᛖᚲᛏᛁᛟᚾᛊ (e.g., ᛏᛁᛗᛖ_ᛊᛟᚢᚱᚲᛖ_ᛞᛁᚹᛖᚱᚷᛖᚾᚲᛖ, ᚢᚾᛊᛁᚷᚾᛖᛞ_ᚢᛈᛞᚨᛏᛖ).

2.4 ᚹᚨᛏ ᚱᛖᚲᚹᛁᚱᛖᛊ ᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᛈᚱᛁᚹᚨᛏᛖ ᛏᛖᛊᛏᛁᛜ

ᚹᚨᛚᛁᛞᚨᛏᛁᛟᚾ ᛟᚠ ᚦᛁᛊ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚱᛖᚲᚹᛁᚱᛖᛊ ᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᛞᛖᛈᛚᛟᛃᛗᛖᚾᛏ ᚹᛁᚦᛁᚾ ᚨ ᚲᛚᛟᛊᛖᛞ, ᛊᛃᚾᚦᛖᛏᛁᚲ ᚲᛃᛒᛖᚱ-ᚱᚨᛜᛖ. ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾᛊ ᚹᛁᚦ ᚠᛃᛊᛁᚲᚨᛚ ᛏᛈᛗ ᚺᚨᚱᛞᚹᚨᚱᛖ, ᚷᛖᚾᛖᚱᚨᛏᛁᛟᚾ ᛟᚠ ᚱᛖᚨᛚ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚲᛖᛃᛊ, ᚦᛖ ᛞᛖᛚᛁᛒᛖᚱᚨᛏᛖ ᛁᚾᛃᛖᚲᛏᛁᛟᚾ ᛟᚠ ᛊᛏᚨᛏᛖ ᚠᚨᚢᛚᛏᛊ (ᛊᚢᚲᚺ ᚨᛊ ᛗᛖᛗᛟᚱᛃ ᚲᛟᚱᚱᚢᛈᛏᛁᛟᚾ ᛟᚱ ᚲᛚᛟᚲᚲ ᛊᚲᛖᚹ), ᚨᚾᛞ ᚦᛖ ᛖᚲᛊᛖᚲᚢᛏᛁᛟᚾ ᛟᚠ ᚦᛖ ᛈᛃᚦᛟᚾ ᛈᛊᛖᚢᛞᛟᚲᛟᛞᛖ ᛗᚢᛊᛏ ᛒᛖ ᛈᛖᚱᚠᛟᚱᛗᛖᛞ ᛁᚾ ᛁᛊᛟᛚᚨᛏᛖᛞ ᛚᚨᛒᛟᚱᚨᛏᛟᚱᛁᛖᛊ, ᚾᛟᛏ ᚨᚷᚨᛁᚾᛊᛏ ᛈᚱᛟᛞᚢᚲᛏᛁᛟᚾ ᛉ ᛞᛟᛗᚨᛁᚾᛊ, ᚲᚢᛊᛏᛟᛗᛖᚱ ᛊᛃᛊᛏᛖᛗᛊ, ᛟᚱ ᛈᚢᛒᛚᛁᚲ ᚾᛖᛏᚹᛟᚱᚲᛊ.

3. ᚦᚱᛖᚨᛏ ᛗᛟᛞᛖᛚ ᚨᚾᛞ 45 ᛊᛃᚾᚦᛖᛏᛁᚲ ᛊᚲᛖᚾᚨᚱᛁᛟᛊ

ᚦᛖ ᚦᚱᛖᚨᛏ ᛗᛟᛞᛖᛚ ᛟᛈᛖᚱᚨᛏᛖᛊ ᛊᛏᚱᛁᚲᛏᛚᛃ ᚹᛁᚦᛁᚾ ᚦᛖ ᛈᚨᚱᚨᛞᛁᚷᛗ ᛟᚠ ᚾᛟᚾ-ᚲᛁᚾᛖᛏᛁᚲ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ, ᚨᛊᛊᚢᛗᛁᛜ ᚦᚨᛏ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᛖᛊ ᛗᚨᛃ ᚨᛏᛏᛖᛗᛈᛏ ᛏᛟ ᚲᛚᛟᚾᛖ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ, ᚱᛖᛈᛚᚨᛃ ᛊᛏᚨᛚᛖ ᚨᚢᚦᛟᚱᛁᛏᛃ ᛏᛟᚲᛖᚾᛊ, ᛏᚨᛗᛈᛖᚱ ᚹᛁᚦ ᛗᛟᛞᛖᛚᛊ, ᛟᚱ ᛈᚨᚱᛏᛁᛏᛁᛟᚾ ᚾᛖᛏᚹᛟᚱᚲᛊ.

3.1 ᛒᛟᚢᚾᛞᛖᛞ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ

ᚦᛖ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛖᛜᛁᚾᛖ ᚱᛖᚲᛖᛁᚹᛖᛊ ᛒᛟᚢᚾᛞᛖᛞ ᚨᛒᛊᛏᚱᚨᚲᛏ ᚠᚨᚢᛚᛏ ᛁᚾᛃᛖᚲᛏᛁᛟᚾᛊ (e.g., ᚠᛟᚱᚷᛖᛞ_ᛁᛞᛖᚾᛏᛁᛏᛃ, ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ_ᛒᚱᛖᚨᚲᚺ) ᚨᚾᛞ ᛗᚢᛊᛏ ᚱᛖᛊᛈᛟᚾᛞ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊᛚᛃ ᚢᛊᛁᛜ ᛟᚾᛚᛃ ᚨᛈᛈᚱᛟᚹᛖᛞ, ᚾᛟᚾ-ᛞᛖᛊᛏᚱᚢᚲᛏᛁᚹᛖ, ᚱᛖᚹᛖᚱᛊᛁᛒᛚᛖ ᛟᚢᛏᛈᚢᛏᛊ. ᚦᛖᛊᛖ ᛒᛟᚢᚾᛞᛖᛞ ᛟᚢᛏᛈᚢᛏᛊ ᛁᚾᚲᛚᚢᛞᛖ: ᚨᛚᛚᛟᚹ_ᛟᛒᛊᛖᚱᚹᚨᛏᛁᛟᚾ, ᛞᛖᚾᛃ_ᚱᛖᚲᚹᛖᛊᛏ, ᚱᛖᚲᚹᛁᚱᛖ_ᚱᛖᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛁᛟᚾ, ᚱᛖᚹᛟᚲᛖ_ᚨᚢᚦᛟᚱᛁᛏᛃ, ᛁᛊᛟᛚᚨᛏᛖ_ᚹᛟᚱᚲᛚᛟᚨᛞ, ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ, ᚲᚹᚨᚱᚨᚾᛏᛁᚾᛖ_ᛊᛖᚱᚹᛁᚲᛖ, ᚠᚱᛖᛖᛉᛖ_ᚱᛖᛚᛖᚨᛊᛖ_ᚲᚺᚨᚾᚾᛖᛚ, ᚲᛟᛚᛚᛖᚲᛏ_ᛗᛟᚱᛖ_ᛖᚹᛁᛞᛖᚾᚲᛖ, ᚱᛖᚲᛖᛃ, ᚱᛖᚲᛟᚾᚲᛁᛚᛖ, ᚱᛖᛊᛏᛟᚱᛖ_ᚨᛏᛏᛖᛊᛏᛖᛞ_ᛒᚨᛊᛖᛚᛁᚾᛖ, ᚨᚾᛞ ᚨᛒᛊᛏᚨᛁᚾ.

3.2 ᚦᚱᛖᚨᛏ ᛊᚲᛖᚾᚨᚱᛁᛟ ᛗᚨᛏᚱᛁᚲᛊ

4. ᛉᛖᚱᛟ-ᛏᚱᚢᛊᛏ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ

ᛏᚱᚨᛞᛁᛏᛁᛟᚾᚨᛚ ᚾᛖᛏᚹᛟᚱᚲ ᛊᛖᚲᚢᚱᛁᛏᛃ ᛗᛟᛞᛖᛚᛊ ᛁᛗᛈᛚᛁᚲᛁᛏᛚᛃ ᛏᚱᚢᛊᛏ ᛖᚾᛏᛁᛏᛁᛖᛊ ᚱᛖᛊᛁᛞᛁᛜ ᚹᛁᚦᛁᚾ ᚨ ᚠᛃᛊᛁᚲᚨᛚ ᛟᚱ ᛚᛟᚷᛁᚲᚨᛚ ᛈᛖᚱᛁᛗᛖᛏᛖᚱ. ᚦᛖ ᛉ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛞᛁᛊᚲᚨᚱᛞᛊ ᚦᛁᛊ ᚨᛈᛈᚱᛟᚨᚲᚺ, ᚨᛞᛟᛈᛏᛁᛜ ᚨ ᛗᛟᛞᛖᛚ ᚹᛖᚱᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛁᛊ ᚦᛖ ᛈᚱᛁᛗᚨᚱᛃ ᛒᛟᚢᚾᛞᚨᚱᛃ, ᛖᛊᛏᚨᛒᛚᛁᛊᚺᛖᛞ ᚦᚱᛟᚢᚷᚺ ᚱᛁᚷᛟᚱᛟᚢᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛈᚱᛟᛟᚠ.

4.1 ᛊᛈᛁᚠᚠᛖ, ᛊᛈᛁᚱᛖ, ᚨᚾᛞ ᛗᛏᛚᛊ

ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚢᛏᛁᛚᛁᛉᛖᛊ ᚦᛖ ᛊᛖᚲᚢᚱᛖ ᛈᚱᛟᛞᚢᚲᛏᛁᛟᚾ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ ᚠᛟᚱ ᛖᚹᛖᚱᛃᛟᚾᛖ (ᛊᛈᛁᚠᚠᛖ) ᚨᚾᛞ ᛁᛏᛊ ᚱᛖᚠᛖᚱᛖᚾᚲᛖ ᛁᛗᛈᛚᛖᛗᛖᚾᛏᚨᛏᛁᛟᚾ, ᛊᛈᛁᚱᛖ2. ᛊᛈᛁᚠᚠᛖ ᛈᚱᛟᚹᛁᛞᛖᛊ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲᚨᛏᛁᛟᚾ ᚠᛟᚱ ᛁᛊᛊᚢᛁᛜ ᛊᚺᛟᚱᛏ-ᛚᛁᚹᛖᛞ, ᚨᚢᛏᛟᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚱᛟᛏᚨᛏᛁᛜ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ ᛏᛟ ᚹᛟᚱᚲᛚᛟᚨᛞᛊ, ᚠᛟᚱᛗᚨᛏᛏᛖᛞ ᚨᛊ ᛊᛈᛁᚠᚠᛖ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛞᛟᚲᚢᛗᛖᚾᛏᛊ (ᛊᚹᛁᛞᛊ) ᛁᚾ ᛖᛁᚦᛖᚱ X.509 ᛟᚱ ᛃᚹᛏ ᚠᛟᚱᛗᚨᛏᛊ16. ᛒᛖᚲᚨᚢᛊᛖ ᛊᚹᛁᛞᛊ ᚨᚱᛖ ᛊᚺᛟᚱᛏ-ᛚᛁᚹᛖᛞ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛁᚾᚺᛖᚱᛖᚾᛏᛚᛃ ᛞᛖᚠᛖᚾᛞᛊ ᚨᚷᚨᛁᚾᛊᛏ ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚ ᚦᛖᚠᛏ; ᚨ ᛊᛏᛟᛚᛖᚾ ᛃᚹᛏ ᛁᛊ ᚢᛊᛖᛚᛖᛊᛊ ᛟᚾᚲᛖ ᛁᛏᛊ ᚹᚨᛚᛁᛞᛁᛏᛃ ᚹᛁᚾᛞᛟᚹ (ᛟᚠᛏᛖᚾ ᛗᛖᚨᛊᚢᚱᛖᛞ ᛁᚾ ᛗᛁᚾᚢᛏᛖᛊ) ᛖᚲᛊᛈᛁᚱᛖᛊ.
ᚹᛟᚱᚲᛚᛟᚨᛞᛊ ᚢᛏᛁᛚᛁᛉᛖ ᚦᛖᛊᛖ ᛊᚹᛁᛞᛊ ᛏᛟ ᛖᛊᛏᚨᛒᛚᛁᛊᚺ ᛗᚢᛏᚢᚨᛚ ᛏᛚᛊ (ᛗᛏᛚᛊ) ᚲᛟᚾᚾᛖᚲᛏᛁᛟᚾᛊ. ᚢᚾᛚᛁᚲᛖ ᛊᛏᚨᚾᛞᚨᚱᛞ ᛏᛚᛊ ᚹᛖᚱᛖ ᛟᚾᛚᛃ ᚦᛖ ᛊᛖᚱᚹᛖᚱ ᛈᚱᛟᚹᛖᛊ ᛁᛏᛊ ᛁᛞᛖᚾᛏᛁᛏᛃ, ᛗᛏᛚᛊ ᚱᛖᚲᚹᛁᚱᛖᛊ ᚦᛖ ᚲᛚᛁᛖᚾᛏ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛏᛟ ᛈᚱᛖᛊᛖᚾᛏ ᚨ ᚹᚨᛚᛁᛞ X.509 ᛊᚹᛁᛞ ᛏᛟ ᚦᛖ ᛊᛖᚱᚹᛖᚱ. ᚦᛖ ᛊᛖᚱᚹᛖᚱ ᚹᛖᚱᛁᚠᛁᛖᛊ ᚦᛁᛊ ᛊᚹᛁᛞ ᚨᚷᚨᛁᚾᛊᛏ ᚦᛖ ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ’ᛊ ᛏᚱᚢᛊᛏᛖᛞ ᚱᛟᛟᛏ ᚲᚨ ᛒᚢᚾᛞᛚᛖ9.

4.2 ᚺᚨᚱᛞᚹᚨᚱᛖ-ᚱᛟᛟᛏᛖᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᚾᛞ ᛏᛈᛗ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ

ᚨ ᚲᚱᛁᛏᛁᚲᚨᛚ ᚹᚢᛚᚾᛖᚱᚨᛒᛁᛚᛁᛏᛃ ᛁᚾ ᛊᛟᚠᛏᚹᚨᚱᛖ-ᛒᚨᛊᛖᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛁᛊ ᚦᚨᛏ ᚨ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚺᛟᛊᛏ ᚲᚨᚾ ᛚᛁᛖ ᚨᛒᛟᚢᛏ ᚦᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛁᛏ ᛁᛊ ᚱᚢᚾᚾᛁᛜ. ᛏᛟ ᚲᛟᚢᚾᛏᛖᚱᚨᚲᛏ ᚦᛁᛊ, ᛉ ᚨᚾᚲᚺᛟᚱᛊ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛁᚾ ᚦᛖ ᚠᛃᛊᛁᚲᚨᛚ ᚺᚨᚱᛞᚹᚨᚱᛖ ᚢᛊᛁᛜ ᛏᚱᚢᛊᛏᛖᛞ ᛈᛚᚨᛏᚠᛟᚱᛗ ᛗᛟᛞᚢᛚᛖ (ᛏᛈᛗ) 2.0 ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ8.
ᚦᛖ ᛁᚾᛏᛖᚷᚱᚨᛏᛁᛟᚾ ᚱᛖᛚᛁᛖᛊ ᛟᚾ ᚦᛖ ᛊᛈᛁᚱᛖ-ᛏᛈᛗ-ᛈᛚᚢᚷᛁᚾ ᚨᚾᛞ ᚲᛟᚾᚲᛖᛈᛏᛊ ᛞᛖᚱᛁᚹᛖᛞ ᚠᚱᛟᛗ ᛁᛖᛖᛖ 802.1AR ᛚᛟᚲᚨᛚ ᛞᛖᚹᛁᚲᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ (ᛚᛞᛖᚹᛁᛞ)15. ᛞᚢᚱᛁᛜ ᚾᛟᛞᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ, ᚦᛖ ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ ᛖᚾᚲᚱᛃᛈᛏᛊ ᚨ ᚲᚺᚨᛚᛚᛖᛜᛖ ᚢᛊᛁᛜ ᚦᛖ ᛈᚢᛒᛚᛁᚲ ᛖᚾᛞᛟᚱᛊᛖᛗᛖᚾᛏ ᚲᛖᛃ (ᛖᚲ) ᛟᚠ ᚦᛖ ᚾᛟᛞᛖ’ᛊ ᛏᛈᛗ. ᛟᚾᛚᛃ ᚦᛖ ᚷᛖᚾᚢᛁᚾᛖ, ᚠᛃᛊᛁᚲᚨᛚ ᛏᛈᛗ ᛈᛟᛊᛊᛖᛊᛊᛁᛜ ᚦᛖ ᚲᛟᚱᚱᛖᛊᛈᛟᚾᛞᛁᛜ ᛈᚱᛁᚹᚨᛏᛖ ᛖᚲ ᚲᚨᚾ ᛞᛖᚲᚱᛃᛈᛏ ᚦᛁᛊ ᚲᚺᚨᛚᛚᛖᛜᛖ9. ᚠᚢᚱᚦᛖᚱᛗᛟᚱᛖ, ᚦᛖ ᛏᛈᛗ ᛈᚱᛟᚹᛁᛞᛖᛊ ᚨ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛊᛁᚷᚾᛖᛞ “ᚲᚹᛟᛏᛖ” ᛟᚠ ᛁᛏᛊ ᛈᛚᚨᛏᚠᛟᚱᛗ ᚲᛟᚾᚠᛁᚷᚢᚱᚨᛏᛁᛟᚾ ᚱᛖᚷᛁᛊᛏᛖᚱᛊ (ᛈᚲᚱᛊ). ᚦᛖᛊᛖ ᛈᚲᚱᛊ ᚲᛟᚾᛏᚨᛁᚾ ᛗᛖᚨᛊᚢᚱᛖᛗᛖᚾᛏᛊ ᛟᚠ ᚦᛖ ᛒᛟᛟᛏᛚᛟᚨᛞᛖᚱ, ᚲᛖᚱᚾᛖᛚ, ᚨᚾᛞ ᚲᚱᛁᛏᛁᚲᚨᛚ ᛊᛃᛊᛏᛖᛗ ᛚᛁᛒᚱᚨᚱᛁᛖᛊ, ᚷᚨᚦᛖᚱᛖᛞ ᛒᛃ ᚦᛖ ᛚᛁᚾᚢᚲᛊ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᛗᛖᚨᛊᚢᚱᛖᛗᛖᚾᛏ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ (ᛁᛗᚨ). ᛁᚠ ᚨ ᚱᛟᛟᛏᚲᛁᛏ ᚺᚨᛊ ᚨᛚᛏᛖᚱᛖᛞ ᚦᛖ ᚲᛖᚱᚾᛖᛚ, ᚦᛖ ᛈᚲᚱ ᚲᚹᛟᛏᛖ ᚹᛁᛚᛚ ᚾᛟᛏ ᛗᚨᛏᚲᚺ ᚦᛖ ᛖᚲᛊᛈᛖᚲᛏᛖᛞ ᚱᛖᚠᛖᚱᛖᚾᚲᛖ ᚹᚨᛚᚢᛖᛊ, ᚨᚾᛞ ᚦᛖ ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ ᚹᛁᛚᛚ ᛞᛖᚾᛃ ᚦᛖ ᚾᛟᛞᛖ ᛖᚾᛏᚱᛃ ᛁᚾᛏᛟ ᚦᛖ ᛏᚱᚢᛊᛏ ᛞᛟᛗᚨᛁᚾ8.
[ᛞᛁᚨᚷᚱᚨᛗ 1: ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᚾᛞ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᚠᛚᛟᚹ]
+-------------------+ +--------------------+ +-------------------+
| ᚠᛃᛊᛁᚲᚨᛚ ᚾᛟᛞᛖ | | ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ | | ᛉ ᚹᛟᚱᚲᛚᛟᚨᛞ | | (ᛏᛈᛗ 2.0 ᚲᚺᛁᛈ) | | (ᛏᚱᚢᛊᛏ ᚱᛟᛟᛏ ᚲᚨ) | | (ᚨᛈᛈᛚᛁᚲᚨᛏᛁᛟᚾ) | +--------+----------+ +---------+----------+ +---------+---------+
| | | | 1. ᛊᚢᛒᛗᛁᛏ ᛏᛈᛗ ᚲᚹᛟᛏᛖ & ᛖᚲ ᚺᚨᛊᚺ | | |------------------------------>| | | | | | 2. ᚹᛖᚱᛁᚠᛃ ᛈᚲᚱᛊ ᚨᚷᚨᛁᚾᛊᛏ ᛈᛟᛚᛁᚲᛃ | | |\<------------------------------| | | | | | 3. ᛁᛊᛊᚢᛖ ᚾᛟᛞᛖ ᛊᚹᛁᛞ | | |\<| | | | | | 4. ᚹᛟᚱᚲᛚᛟᚨᛞ ᛊᛈᛁᚾᛊ ᚢᛈ, ᚱᛖᚲᚹᛖᛊᛏᛊ| ᛁᛞᛖᚾᛏᛁᛏᛃ ᚠᚱᛟᛗ ᛚᛟᚲᚨᛚ ᚨᚷᛖᚾᛏ | |-------------------------------------------------------------->| | | | | 5. ᚨᚷᛖᚾᛏ ᛗᚨᛈᛊ ᛚᛁᚾᚢᚲᛊ ᚾᚨᛗᛖᛊᛈᚨᚲᛖ / ᚲ8ᛊ ᛊᛖᛚᛖᚲᛏᛟᚱᛊ | |\<--------------------------------------------------------------| | | | | 6. ᛁᛊᛊᚢᛖ ᛊᚺᛟᚱᛏ-ᛚᛁᚹᛖᛞ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛊᚹᛁᛞ (ᛗᛏᛚᛊ ᚱᛖᚨᛞᛃ) | |================================>|

5. ᛊᛟᚠᛏᚹᚨᚱᛖ ᚨᚾᛞ ᛗᛟᛞᛖᛚ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ

ᛊᛖᚲᚢᚱᛁᛜ ᚦᛖ ᚱᚢᚾᛏᛁᛗᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛁᛊ ᛁᚾᛊᚢᚠᚠᛁᚲᛁᛖᚾᛏ ᛁᚠ ᚦᛖ ᛞᛖᛈᛚᛟᛃᛖᛞ ᛊᛟᚠᛏᚹᚨᚱᛖ ᚨᚱᛏᛁᚠᚨᚲᛏᛊ ᚨᚱᛖ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚢᛈᛊᛏᚱᛖᚨᛗ. ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛞᛖᛗᚨᚾᛞᛊ ᛊᛏᚱᛁᚲᛏ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ ᚠᛟᚱ ᚨᛚᛚ ᚲᛟᛞᛖ, ᛞᛖᛈᛖᚾᛞᛖᚾᚲᛁᛖᛊ, ᚨᚾᛞ ᚨᚱᛏᛁᚠᛁᚲᛁᚨᛚ ᛁᚾᛏᛖᛚᛚᛁᚷᛖᚾᚲᛖ ᛗᛟᛞᛖᛚᛊ.

5.1 ᚲᛟᛗᛈᚨᚱᛁᛜ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾ ᛊᛏᚨᚾᛞᚨᚱᛞᛊ

5.2 ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛚᛁᚠᛖᚲᛃᚲᛚᛖ

ᚹᛖᚾ ᚨ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛊ ᛒᚢᛁᛚᛏ, ᚦᛖ ᚲᛁ/ᚲᛞ ᛈᛁᛈᛖᛚᛁᚾᛖ ᚨᚲᛏᛊ ᚨᛊ ᚨᚾ ᚨᛏᛏᛖᛊᛏᛁᛜ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ18. ᛁᛏ ᚷᛖᚾᛖᚱᚨᛏᛖᛊ ᚨ ᛊᛟᚢᚱᚲᛖ ᛞᛁᚷᛖᛊᛏ (ᚦᛖ ᚷᛁᛏ ᛊᚺᚨ), ᚨ ᛒᚢᛁᛚᛞ ᛞᛁᚷᛖᛊᛏ (ᚦᛖ ᚲᛟᚾᛏᚨᛁᚾᛖᚱ ᛁᛗᚨᚷᛖ ᚺᚨᛊᚺ), ᚨᚾᛞ ᚨ ᛞᛖᛈᛖᚾᛞᛖᚾᚲᛃ ᚷᚱᚨᚠ (ᛊᛒᛟᛗ). ᚠᛟᚱ ᛗᚨᚲᚺᛁᚾᛖ ᛚᛖᚨᚱᚾᛁᛜ ᚲᛟᛗᛈᛟᚾᛖᚾᛏᛊ, ᛁᛏ ᚷᛖᚾᛖᚱᚨᛏᛖᛊ ᚨᚾ ᚨᛁ-ᛒᛟᛗ ᚲᚨᛈᛏᚢᚱᛁᛜ ᚦᛖ ᛗᛟᛞᛖᛚ ᛞᛁᚷᛖᛊᛏ ᚨᚾᛞ ᛞᚨᛏᚨᛊᛖᛏ ᚱᛖᚠᛖᚱᛖᚾᚲᛖ.
ᚦᛖᛊᛖ ᚱᛖᚲᛟᚱᛞᛊ ᚨᚱᛖ ᛊᛁᚷᚾᛖᛞ ᚨᚾᛞ ᛞᛁᛊᛏᚱᛁᛒᚢᛏᛖᛞ ᚹᛁᚨ ᛏᚢᚠ. ᚢᛈᛟᚾ ᛞᛖᛈᛚᛟᛃᛗᛖᚾᛏ, ᚦᛖ ᛉ ᚨᛞᛗᛁᛊᛊᛁᛟᚾ ᚲᛟᚾᛏᚱᛟᛚᛚᛖᚱ ᚨᚲᛏᛊ ᚨᛊ ᚦᛖ ᚹᛖᚱᛁᚠᛁᛖᚱ1. ᛁᛏ ᛖᚹᚨᛚᚢᚨᛏᛖᛊ ᚦᛖ ᚱᚢᚾᛏᛁᛗᛖ ᚲᚹᛟᛏᛖ ᚨᚷᚨᛁᚾᛊᛏ ᚦᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛖᚲᛊᛈᛁᚱᛃ ᚨᚾᛞ ᚱᛖᚹᛟᚲᚨᛏᛁᛟᚾ ᛚᛁᛊᛏᛊ. ᛁᚠ ᚨᚾ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᛁᚾᛃᛖᚲᛏ ᚨᚾ ᚢᚾᛊᛁᚷᚾᛖᛞ ᚢᛈᛞᚨᛏᛖ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛖᚲᛊᛖᚲᚢᛏᛖᛊ ᚨ ᚠᚱᛖᛖᛉᛖ_ᚱᛖᛚᛖᚨᛊᛖ_ᚲᚺᚨᚾᚾᛖᛚ ᚱᛖᛊᛈᛟᚾᛊᛖ27.

6. ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᚨᚾᛞ ᛈᚱᛟᛟᚠ ᛖᛜᛁᚾᛖᛖᚱᛁᛜ

ᚨᚢᛞᛁᛏ ᛚᛟᚷᛊ ᚨᚱᛖ ᛏᚱᚨᛞᛁᛏᛁᛟᚾᚨᛚᛚᛃ ᛗᚢᛏᚨᛒᛚᛖ; ᚨ ᛊᛟᚠᛁᛊᛏᛁᚲᚨᛏᛖᛞ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ ᚹᛁᚦ ᚱᛟᛟᛏ ᚨᚲᚲᛖᛊᛊ ᚲᚨᚾ ᛞᛖᛚᛖᛏᛖ ᚦᛖᛁᚱ ᛏᚱᚨᚲᚲᛊ. ᛏᛟ ᛖᛊᛏᚨᛒᛚᛁᛊᚺ ᚢᚾᚠᛟᚱᚷᛖᚨᛒᛚᛖ ᛖᚹᛁᛞᛖᚾᚲᛖ, ᚦᛁᛊ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᛗᛈᛚᛖᛗᛖᚾᛏᛊ ᛏᚨᛗᛈᛖᚱ-ᛖᚹᛁᛞᛖᚾᛏ ᛚᛟᚷᚷᛁᛜ ᛒᚨᛊᛖᛞ ᛟᚾ ᚱᚠᚲ 69626.

6.1 ᛗᛖᚱᚲᛚᛖ ᚺᚨᛊᚺ ᛏᚱᛖᛖᛊ ᚨᚾᛞ ᛞᛟᛗᚨᛁᚾ ᛊᛖᛈᚨᚱᚨᛏᛁᛟᚾ

ᚦᛖ ᛖᚹᛖᚾᛏ ᛚᛖᛞᚷᛖᚱ ᚢᛏᛁᛚᛁᛉᛖᛊ ᚨ ᛒᛁᚾᚨᚱᛃ ᛗᛖᚱᚲᛚᛖ ᚺᚨᛊᚺ ᛏᚱᛖᛖ. ᛖᚹᛖᚱᛃ ᛊᛖᚲᚢᚱᛁᛏᛃ ᛖᚹᛖᚾᛏ, ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚲᛏᛁᛟᚾ, ᛟᚱ ᛊᛏᚨᛏᛖ ᚲᚺᚨᛜᛖ ᛁᛊ ᛊᛖᚱᛁᚨᛚᛁᛉᛖᛞ ᛁᚾᛏᛟ ᚲᚨᚾᛟᚾᛁᚲᚨᛚ ᛃᛊᛟᚾ ᚨᚾᛞ ᚺᚨᛊᚺᛖᛞ ᛏᛟ ᚠᛟᚱᛗ ᚨ ᛚᛖᚨᚠ ᚾᛟᛞᛖ. ᛏᛟ ᛈᚱᛖᚹᛖᚾᛏ ᛊᛖᚲᛟᚾᛞ-ᛈᚱᛖᛁᛗᚨᚷᛖ ᚨᛏᛏᚨᚲᚲᛊ (ᚲᚹᛖ-2012-2459 ᛗᚨᛚᛚᛖᚨᛒᛁᛚᛁᛏᛃ), ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛊᛏᚱᛁᚲᛏᛚᛃ ᛖᚾᚠᛟᚱᚲᛖᛊ ᚱᚠᚲ 6962 ᛞᛟᛗᚨᛁᚾ ᛊᛖᛈᚨᚱᚨᛏᛁᛟᚾ: ᛚᛖᚨᚠ ᚾᛟᛞᛖᛊ ᚨᚱᛖ ᛈᚱᛖᚠᛁᚲᛊᛖᛞ ᚹᛁᚦ ᚨ 0ᚲᛊ00 ᛒᛃᛏᛖ ᛒᛖᚠᛟᚱᛖ ᚺᚨᛊᚺᛁᛜ, ᚹᛁᛚᛖ ᛁᚾᛏᛖᚱᚾᚨᛚ ᛊᛏᚱᚢᚲᛏᚢᚱᚨᛚ ᚾᛟᛞᛖᛊ ᚨᚱᛖ ᛈᚱᛖᚠᛁᚲᛊᛖᛞ ᚹᛁᚦ 0ᚲᛊ0113.

6.2 ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᚲᛖ ᚹᛊ. ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ

ᚨ ᚠᚢᚾᛞᚨᛗᛖᚾᛏᚨᛚ ᚱᛖᚲᚹᛁᚱᛖᛗᛖᚾᛏ ᛟᚠ ᚦᛖ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛖᛜᛁᚾᛖ ᛁᛊ ᛏᛟ ᛈᚱᛖᚹᛖᚾᛏ ᚨᛚᛖᚱᛏ ᚠᚨᛏᛁᚷᚢᛖ ᚨᚾᛞ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛈᛟᛁᛊᛟᚾᛁᛜ. ᛁᚠ ᚨ ᛊᛁᛜᛚᛖ ᛊᛟᚢᚱᚲᛖ (e.g., ᛟᚾᛖ ᚠᚨᛁᛚᛁᛜ ᛗᛁᚲᚱᛟᛊᛖᚱᚹᛁᚲᛖ) ᚷᛖᚾᛖᚱᚨᛏᛖᛊ ᛏᛖᚾ ᛁᛞᛖᚾᛏᛁᚲᚨᛚ ᚨᛚᛖᚱᛏ ᛚᛟᚷᛊ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛗᚢᛊᛏ ᚾᛟᛏ ᛏᚱᛖᚨᛏ ᚦᛁᛊ ᚨᛊ ᛏᛖᚾ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛊᛟᚢᚱᚲᛖᛊ ᚲᛟᚾᚠᛁᚱᛗᛁᛜ ᚨᚾ ᚨᛏᛏᚨᚲᚲ.
ᚦᛖ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛊᚲᚺᛖᛗᚨ ᛗᚨᚾᛞᚨᛏᛖᛊ ᚨ ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ_ᛁᛞ, ᚨ ᛊᛟᚢᚱᚲᛖ_ᛁᛞᛖᚾᛏᛁᛏᛃ (ᛏᛁᛖᛞ ᛏᛟ ᚦᛖ ᛊᛈᛁᚠᚠᛖ ᛁᛞ), ᚨᚾᛞ ᚨ ᛏᚱᚨᚾᛊᚠᛟᚱᛗᚨᛏᛁᛟᚾ_ᚺᛁᛊᛏᛟᚱᛃ. ᛁᚠ ᛗᚢᛚᛏᛁᛈᛚᛖ ᛖᚹᛖᚾᛏᛊ ᚨᚱᚱᛁᚹᛖ ᚹᛁᚦ ᛁᛞᛖᚾᛏᛁᚲᚨᛚ ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ ᛁᛞᛊ ᛟᚱ ᚠᚱᛟᛗ ᚦᛖ ᛊᚨᛗᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚹᛁᚦᛁᚾ ᚨ ᚾᚨᚱᚱᛟᚹ ᚠᚱᛖᛊᚺᚾᛖᛊᛊ ᚹᛁᚾᛞᛟᚹ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚷᚱᛟᚢᛈᛊ ᚦᛖᛗ. ᛁᚠ ᚨᚾ ᚢᛈᛊᛏᚱᛖᚨᛗ ᚨᚷᚷᚱᛖᚷᚨᛏᛟᚱ ᚠᛁᛚᛏᛖᚱᛊ ᚦᛖ ᚨᛚᛖᚱᛏ, ᚦᛖ ᛏᚱᚨᚾᛊᚠᛟᚱᛗᚨᛏᛁᛟᚾ ᚺᛁᛊᛏᛟᚱᛃ ᚱᛖᚲᛟᚱᛞᛊ ᚦᛖ ᚨᚲᛏᛟᚱ ᚨᚾᛞ ᚨᚲᛏᛁᛟᚾ (e.g., ᚠᛁᛚᛏᛖᚱ, ᛏᚱᚨᚾᛊᛚᚨᛏᛖ). ᛁᚠ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᛊ ᛚᚨᛏᛖᚱ ᚠᛟᚢᚾᛞ ᛏᛟ ᛒᛖ ᚠᚨᛚᛊᛖ, ᚨ ᛊᚢᛈᛖᚱᛊᛖᛊᛊᛁᛟᚾ ᚢᚢᛁᛞ ᛁᛊ ᛁᛊᛊᚢᛖᛞ, ᛗᚨᚱᚲᛁᛜ ᚦᛖ ᛟᚱᛁᚷᛁᚾᚨᛚ ᛊᛏᚨᛏᛖ ᚨᛊ ᚹᛁᚦᛞᚱᚨᚹᚾ ᛟᚱ ᚲᛟᚾᛏᚱᚨᛞᛁᚲᛏᛖᛞ.

6.3 ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ ᚹᛁᚦᛟᚢᛏ ᛏᚱᚢᛊᛏ

ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛖᚲᛊᛈᛟᛊᛖᛊ ᚨᚾ ᚨᛈᛁ ᛏᛟ ᚷᛖᚾᛖᚱᚨᛏᛖ ᛟ(ᛚᛟᚷ ᚾ) ᛁᚾᚲᛚᚢᛊᛁᛟᚾ ᛈᚱᛟᛟᚠᛊ6. ᚨᚾ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᚨᚢᛞᛁᛏᛟᚱ ᚲᚨᚾ ᚱᛖᚲᚹᛖᛊᛏ ᚨ ᛈᚱᛟᛟᚠ ᚠᛟᚱ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲ ᛖᚹᛖᚾᛏ ᚨᚾᛞ ᚱᛖᚲᛟᚾᛊᛏᚱᚢᚲᛏ ᚦᛖ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛈᚨᚦ ᚢᛈ ᛏᛟ ᚦᛖ ᛊᛁᚷᚾᛖᛞ ᛏᚱᛖᛖ ᚺᛖᚨᛞ (ᛊᚦ). ᛁᚠ ᚦᛖ ᚲᚨᛚᚲᚢᛚᚨᛏᛖᛞ ᚱᛟᛟᛏ ᛗᚨᛏᚲᚺᛖᛊ ᚦᛖ ᛈᚢᛒᛚᛁᛊᚺᛖᛞ ᚱᛟᛟᛏ, ᚦᛖ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᛊ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛈᚱᛟᚹᛖᚾ ᛏᛟ ᛒᛖ ᚢᚾᛏᚨᛗᛈᛖᚱᛖᛞ, ᛖᚾᚠᛟᚱᚲᛁᛜ ᚨ “ᚹᛖᚱᛁᚠᛃ, ᛞᛟᚾ’ᛏ ᛏᚱᚢᛊᛏ” ᛈᚨᚱᚨᛞᛁᚷᛗ29.

7. ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚱᛖᛊᛈᛟᚾᛊᛖ ᚨᚾᛞ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ

ᚦᛖ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᛊᛃᛊᛏᛖᛗ ᛁᚾᛏᛖᚱᛈᚱᛖᛏᛊ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚠᚨᚢᛚᛏᛊ ᚨᚾᛞ ᛖᚹᛁᛞᛖᚾᚲᛖ, ᛏᚱᚨᚾᛊᛚᚨᛏᛁᛜ ᚦᛖᛗ ᛁᚾᛏᛟ ᚠᛃᛊᛁᚲᚨᛚ ᚨᚾᛞ ᛚᛟᚷᛁᚲᚨᛚ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ.

7.1 ᛒᛟᚢᚾᛞᛖᛞ ᛟᚢᛏᛈᚢᛏᛊ

ᛏᛟ ᛈᚱᛖᚹᛖᚾᛏ ᚦᛖ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᛞᛖᚠᛖᚾᛊᛖ ᚠᚱᛟᛗ ᛒᛖᛁᛜ ᚹᛖᚨᛈᛟᚾᛁᛉᛖᛞ ᛁᚾᛏᛟ ᚨ ᛞᛖᚾᛁᚨᛚ-ᛟᚠ-ᛊᛖᚱᚹᛁᚲᛖ ᛏᛟᛟᛚ, ᛁᛏ ᚲᚨᚾᚾᛟᛏ ᚨᚱᛒᛁᛏᚱᚨᚱᛁᛚᛃ ᛞᛖᛚᛖᛏᛖ ᛞᚨᛏᚨ ᛟᚱ ᚲᛟᚢᚾᛏᛖᚱᚨᛏᛏᚨᚲᚲ. ᛁᛏ ᛁᛊ ᚱᛖᛊᛏᚱᛁᚲᛏᛖᛞ ᛏᛟ ᚦᛖ ᛒᛟᚢᚾᛞᛖᛞ ᛟᚢᛏᛈᚢᛏᛊ ᛞᛖᚠᛁᚾᛖᛞ ᛁᚾ ᛊᛖᚲᛏᛁᛟᚾ 3.1.

7.2 ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛞᛃᚾᚨᛗᛁᚲᛊ

ᚹᛖᚾ ᚨ ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ ᛟᚱ ᛁᛊᛟᛚᚨᛏᛖ_ᚹᛟᚱᚲᛚᛟᚨᛞ ᚲᛟᛗᛗᚨᚾᛞ ᛁᛊ ᛁᛊᛊᚢᛖᛞ, ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚠᚠᛖᚲᛏᛊ ᛗᚢᛚᛏᛁᛈᛚᛖ ᛚᚨᛃᛖᚱᛊ ᛊᛁᛗᚢᛚᛏᚨᚾᛖᛟᚢᛊᛚᛃ:

• ᚾᛖᛏᚹᛟᚱᚲ ᚱᛖᚨᚲᚺᚨᛒᛁᛚᛁᛏᛃ: ᚲᛟᚾᛏᚨᛁᚾᛖᚱ ᚾᛖᛏᚹᛟᚱᚲ ᛁᚾᛏᛖᚱᚠᚨᚲᛖ (ᚲᚾᛁ) ᛈᛟᛚᛁᚲᛁᛖᛊ ᚨᚾᛞ ᛖᛒᛈᚠ ᚠᛁᛚᛏᛖᚱᛊ ᛞᚱᛟᛈ ᚨᛚᛚ ᛁᛜᚱᛖᛊᛊ ᚨᚾᛞ ᛖᚷᚱᛖᛊᛊ ᛈᚨᚲᚲᛖᛏᛊ. ᚦᛖ ᛏᚨᚱᚷᛖᛏ ᛁᛊ ᚱᛖᛊᛏᚱᛁᚲᛏᛖᛞ ᛏᛟ ᛞᛖᚾᛃ_ᚨᛚᛚ ᛟᚱ ᚨᛚᛚᛟᚹ_ᛗᛖᛏᚱᛁᚲᛊ_ᛟᚾᛚᛃ (ᛏᛟ ᛈᛖᚱᛗᛁᛏ ᛟᛜᛟᛁᛜ ᛟᛒᛊᛖᚱᚹᚨᛏᛁᛟᚾ).
• ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᚾᛞ ᚨᚢᚦᛟᚱᛁᛏᛃ: ᚦᛖ ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ ᚱᛖᚹᛟᚲᛖᛊ ᚦᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ’ᛊ ᛊᚹᛁᛞ. ᛊᚢᛒᛊᛖᚲᚹᛖᚾᛏ ᛗᛏᛚᛊ ᚺᚨᚾᛞᛊᚺᚨᚲᛖᛊ ᚹᛁᛚᛚ ᚠᚨᛁᛚ ᚷᛚᛟᛒᚨᛚᛚᛃ.
• ᛞᚨᛏᚨ ᚨᚲᚲᛖᛊᛊ: ᚲᛟᚾᚾᛖᚲᛏᛁᛟᚾᛊ ᛏᛟ ᛞᚨᛏᚨᛒᚨᛊᛖᛊ ᛟᚱ ᛗᛖᛊᛊᚨᚷᛖ ᚲᚹᛖᚢᛖᛊ ᚨᚱᛖ ᛊᛖᚹᛖᚱᛖᛞ; ᛖᚲᛊᛁᛊᛏᛁᛜ ᛚᛟᛜ-ᛚᛁᚹᛖᛞ ᚲᛟᚾᚾᛖᚲᛏᛁᛟᚾᛊ ᚨᚱᛖ ᚠᛟᚱᚲᛖᚠᚢᛚᛚᛃ ᛏᛖᚱᛗᛁᚾᚨᛏᛖᛞ.
• ᛖᚹᛁᛞᛖᚾᚲᛖ ᚲᚢᛊᛏᛟᛞᛃ: ᚦᛖ ᛊᛏᚨᛏᛖ ᛟᚠ ᚦᛖ ᚲᛟᚾᛏᚨᛁᚾᛖᛞ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛊ ᚠᚱᛟᛉᛖᚾ, ᛈᚱᛖᛊᛖᚱᚹᛁᛜ ᚹᛟᛚᚨᛏᛁᛚᛖ ᛗᛖᛗᛟᚱᛃ ᚨᚾᛞ ᛚᛟᚷᛊ ᚠᛟᚱ ᚠᛟᚱᛖᚾᛊᛁᚲ ᚲᚢᛊᛏᛟᛞᛃ.
• ᚱᛖᛚᛖᚨᛊᛖ ᛈᛖᚱᛗᛁᛊᛊᛁᛟᚾ: ᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛈᛁᛈᛖᛚᛁᚾᛖᛊ ᚨᚱᛖ ᚠᛚᚨᚷᚷᛖᛞ ᚹᛁᚦ ᚠᚱᛟᛉᛖᚾ, ᛈᚱᛖᚹᛖᚾᛏᛁᛜ ᚨᚢᛏᛟᛗᚨᛏᛖᛞ ᚢᛈᛞᚨᛏᛖᛊ ᚦᚨᛏ ᛗᛁᚷᚺᛏ ᛟᚹᛖᚱᚹᚱᛁᛏᛖ ᚠᛟᚱᛖᚾᛊᛁᚲ ᛖᚹᛁᛞᛖᚾᚲᛖ.

ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛁᛊ ᛊᛏᚱᛁᚲᛏᛚᛃ ᚱᛖᚹᛖᚱᛊᛁᛒᛚᛖ, ᛒᚢᛏ ᛟᚾᛚᛃ ᚨᚠᛏᛖᚱ ᚨᚾ ᛖᚹᛁᛞᛖᚾᚲᛖ-ᛊᚢᛈᛈᛟᚱᛏᛖᛞ ᚱᛖᚹᛁᛖᚹ ᚲᛟᚾᚠᛁᚱᛗᛊ ᚦᚨᛏ ᚦᛖ ᚠᚨᚢᛚᛏ ᚲᛟᚾᛞᛁᛏᛁᛟᚾ ᚺᚨᛊ ᛒᛖᛖᚾ ᚱᛖᛊᛟᛚᚹᛖᛞ ᛟᚱ ᚱᛖᚲᛟᚾᚲᛁᛚᛖᛞ.
[ᛞᛁᚨᚷᚱᚨᛗ 2: ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛖᚲᛊᛖᚲᚢᛏᛁᛟᚾ ᛒᛟᚢᚾᛞᚨᚱᛃ]
+-------------------+ 1. ᚠᚨᚢᛚᛏ ᛁᚾᛃᛖᚲᛏᛖᛞ +-------------------+
| ᚦᚱᛖᚨᛏ ᛊᛖᚾᛊᛟᚱ |-------------------------->| ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛖᛜᛁᚾᛖ | +-------------------+ +---------+---------+
| 2. ᛞᛖᚲᛁᛞᛖ: ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ ᚹ +-------------------+ 4. ᛞᚱᛟᛈ ᛈᚨᚲᚲᛖᛏᛊ +-------------------+
| ᛖᛒᛈᚠ / ᚲᚾᛁ |\<--------------------------| ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛊᚹᚲ | | ᚾᛖᛏᚹᛟᚱᚲ ᚠᛁᛚᛏᛖᚱ | +---------+---------+ +---------+---------+ | 3. ᚱᛖᚹᛟᚲᛖ ᛊᚹᛁᛞ
| ᚹ | 5. ᛏᚱᚨᚠᚠᛁᚲ ᛒᛚᛟᚲᚲᛖᛞ +-------------------+ +---------ᚹ---------+ | ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ |
| ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᛈᛟᛞ | +-------------------+ +-------------------+

8. ᚱᛖᚲᛖᛃᛁᛜ, ᚨᚢᚦᛟᚱᛁᛏᛃ, ᚨᚾᛞ ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ

ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖᛊ ᚨᚱᛖ ᛟᚾᛚᛃ ᚨᛊ ᛊᛏᚱᛟᛜ ᚨᛊ ᚦᛖᛁᚱ ᚲᛖᛃ ᛗᚨᚾᚨᚷᛖᛗᛖᚾᛏ. ᛉ ᚨᛊᛊᚢᛗᛖᛊ ᚦᚨᛏ ᛊᛁᚷᚾᛁᛜ ᚲᛖᛃᛊ ᚹᛁᛚᛚ ᛖᚹᛖᚾᛏᚢᚨᛚᛚᛃ ᛒᛖ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚨᚾᛞ ᛁᛗᛈᛚᛖᛗᛖᚾᛏᛊ ᚨ ᚱᛟᛒᚢᛊᛏ ᚱᛖᚲᛖᛃᛁᛜ ᚨᚾᛞ ᛖᛈᛟᚲᚺ ᛗᚨᚾᚨᚷᛖᛗᛖᚾᛏ ᛊᛃᛊᛏᛖᛗ ᛒᚨᛊᛖᛞ ᛟᚾ ᛏᚢᚠ4.

8.1 ᚲᛖᛃ ᛖᛈᛟᚲᚺᛊ ᚨᚾᛞ ᚦᚱᛖᛊᚺᛟᛚᛞ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ

ᛏᛁᛗᛖ ᚨᚾᛞ ᚨᚢᚦᛟᚱᛁᛏᛃ ᚨᚱᛖ ᛊᛖᚷᛗᛖᚾᛏᛖᛞ ᛁᚾᛏᛟ ᚲᛖᛃ ᛖᛈᛟᚲᚺᛊ. ᚨ ᛊᛁᛜᛚᛖ ᚲᛖᛃ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ ᛗᚢᛊᛏ ᚾᛖᚹᛖᚱ ᚷᚱᚨᚾᛏ ᚨᚾ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ ᛏᛟᛏᚨᛚ ᚲᛟᚾᛏᚱᛟᛚ4. ᚦᛖᚱᛖᚠᛟᚱᛖ, ᚲᚱᛁᛏᛁᚲᚨᛚ ᚨᚲᛏᛁᛟᚾᛊ (ᛊᚢᚲᚺ ᚨᛊ ᚨᚢᚦᛟᚱᛁᛉᛁᛜ ᚨ ᚾᛖᚹ ᛖᛈᛟᚲᚺ ᛟᚱ ᛈᚢᛊᚺᛁᛜ ᚨ ᚷᛚᛟᛒᚨᛚ ᛈᛟᛚᛁᚲᛃ ᚢᛈᛞᚨᛏᛖ) ᚱᛖᚲᚹᛁᚱᛖ ᚨ ᚦᚱᛖᛊᚺᛟᛚᛞ ᛊᛁᚷᚾᚨᛏᚢᚱᛖ—ᚠᛟᚱ ᛖᚲᛊᚨᛗᛈᛚᛖ, ᛗ-ᛟᚠ-ᚾ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ ᚠᚱᛟᛗ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᚷᛟᚹᛖᚱᚾᛟᚱᛊ (e.g., 3 ᛟᚠ 5).
ᛁᚠ ᚨ ᛊᛁᚷᚾᛖᚱ ᛁᛊ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ, ᚦᛖ ᚱᛖᛗᚨᛁᚾᛁᛜ ᚲᚹᛟᚱᚢᛗ ᛗᛖᛗᛒᛖᚱᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᚹᛟᛏᛖ ᛏᛟ ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾ ᛏᛟ ᚦᛖ ᚾᛖᚲᛊᛏ ᛖᛈᛟᚲᚺ. ᚦᛖ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᛊᛁᚷᚾᛖᚱ ᛁᛊ ᚨᛞᛞᛖᛞ ᛏᛟ ᚦᛖ ᚱᛖᚹᛟᚲᚨᛏᛁᛟᚾ ᛚᛁᛊᛏ, ᚨᚾᛞ ᚨ ᛊᛁᚷᚾᛖᚱ ᚱᛖᛈᛚᚨᚲᛖᛗᛖᚾᛏ ᛁᛊ ᛖᚲᛊᛖᚲᚢᛏᛖᛞ.

8.2 ᛈᚨᚱᛏᛁᛏᛁᛟᚾᛖᛞ ᚾᛟᛞᛖᛊ ᚨᚾᛞ ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ

ᛁᚾ ᛞᛁᛊᛏᚱᛁᛒᚢᛏᛖᛞ ᛊᛃᛊᛏᛖᛗᛊ, ᚨ ᚲᛟᛗᛗᚢᚾᛁᚲᚨᛏᛁᛟᚾᛊ ᛈᚨᚱᛏᛁᛏᛁᛟᚾ (ᛊᛈᛚᛁᛏ-ᛒᚱᚨᛁᚾ) ᛗᚨᛃ ᚲᚨᚢᛊᛖ ᚨ ᚾᛟᛞᛖ ᛏᛟ ᛗᛁᛊᛊ ᚨᚾ ᛖᛈᛟᚲᚺ ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾ. ᚹᛖᚾ ᚦᛖ ᛈᚨᚱᛏᛁᛏᛁᛟᚾ ᚺᛖᚨᛚᛊ, ᚦᛖ ᛊᛏᚨᛚᛖ ᚾᛟᛞᛖ ᛈᚱᛖᛊᛖᚾᛏᛊ ᚨᚢᚦᛟᚱᛁᛏᛃ ᚨᚱᛏᛁᚠᚨᚲᛏᛊ ᚠᚱᛟᛗ ᚨᚾ ᛟᚢᛏᛞᚨᛏᛖᛞ ᛖᛈᛟᚲᚺ. ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛞᛖᛏᛖᚲᛏᛊ ᚦᛖ ᛗᛁᚲᛊᛖᛞ ᛖᛈᛟᚲᚺ ᛊᛏᚨᛏᛖ, ᛞᛖᚾᛁᛖᛊ ᛊᛏᚨᚾᛞᚨᚱᛞ ᚱᛖᚲᚹᛖᛊᛏᛊ, ᚨᚾᛞ ᚠᛟᚱᚲᛖᛊ ᚦᛖ ᚾᛟᛞᛖ ᛁᚾᛏᛟ ᚨ ᚱᛖᚲᛟᚾᚲᛁᛚᛖ ᚹᛟᚱᚲᚠᛚᛟᚹ24. ᚦᛖ ᚾᛟᛞᛖ ᛗᚢᛊᛏ ᚠᛖᛏᚲᚺ ᚦᛖ ᚲᛟᚾᛊᛁᛊᛏᛖᚾᚲᛃ ᛈᚱᛟᛟᚠᛊ ᚠᚱᛟᛗ ᚦᛖ ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ, ᚹᛖᚱᛁᚠᛃ ᚦᛖ ᚦᚱᛖᛊᚺᛟᛚᛞ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ ᛟᚠ ᚦᛖ ᛗᛁᛊᛊᛖᛞ ᛖᛈᛟᚲᚺᛊ, ᚨᚾᛞ ᚢᛈᛞᚨᛏᛖ ᛁᛏᛊ ᛚᛟᚲᚨᛚ ᛊᛏᚨᛏᛖ ᛒᛖᚠᛟᚱᛖ ᚱᛖᛏᚢᚱᚾᛁᛜ ᛏᛟ ᚨᚲᛏᛁᚹᛖ ᛞᚢᛏᛃ.

9. ᚨᛏᛏᛖᛊᛏᛖᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ

ᚱᛖᚲᛟᚹᛖᚱᛃ ᚠᚱᛟᛗ ᚨ ᚾᛟᚾ-ᚲᛁᚾᛖᛏᛁᚲ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ ᚲᚨᚾᚾᛟᛏ ᚱᛖᛚᛃ ᛟᚾ ᛊᛁᛗᛈᛚᛃ ᚱᛖᛊᛏᛟᚱᛁᛜ ᚦᛖ ᛚᚨᛏᛖᛊᛏ ᛒᚨᚲᚲᚢᛈ, ᚨᛊ ᚦᛖ ᛒᚨᚲᚲᚢᛈ ᛁᛏᛊᛖᛚᚠ ᛗᚨᛃ ᚲᛟᚾᛏᚨᛁᚾ ᚦᛖ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ’ᛊ ᛈᛖᚱᛊᛁᛊᛏᛖᚾᚲᛖ ᛗᛖᚲᚺᚨᚾᛁᛊᛗᛊ (ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ_ᚱᛖᚲᛟᚹᛖᚱᛃ_ᛒᚨᛊᛖᛚᛁᚾᛖ).
ᚦᛖ ᚨᛏᛏᛖᛊᛏᛖᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ ᛈᚱᛟᚲᛖᛊᛊ ᛞᛖᛗᚨᚾᛞᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ ᛟᚠ ᚦᛖ ᚱᛖᛊᛏᛟᚱᚨᛏᛁᛟᚾ ᛒᚨᛊᛖᛚᛁᚾᛖ. ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚹᛖᚱᛁᚠᛁᛖᛊ ᚦᛖ ᛒᚨᚲᚲᚢᛈ ᛞᛁᚷᛖᛊᛏ ᚨᚷᚨᛁᚾᛊᛏ ᚦᛖ ᛏᚱᚢᛊᛏᛖᛞ ᚱᛟᛟᛏ. ᛁᛏ ᚹᚨᛚᛁᛞᚨᛏᛖᛊ ᚦᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ, ᛗᛟᛞᛖᛚ, ᛈᛟᛚᛁᚲᛃ, ᚨᚾᛞ ᚲᛟᚾᚠᛁᚷᚢᚱᚨᛏᛁᛟᚾ ᛊᛏᚨᛏᛖ ᚨᚷᚨᛁᚾᛊᛏ ᚦᛖ ᛁᛗᛗᚢᛏᚨᛒᛚᛖ ᚱᛖᚲᛟᚱᛞᛊ ᛊᛏᛟᚱᛖᛞ ᛁᚾ ᚦᛖ ᚱᛖᛗᛟᛏᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ. ᛁᛏ ᛖᚾᛊᚢᚱᛖᛊ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛒᛟᛟᛏᛊ ᛁᚾᛏᛟ ᚨ ᚹᚨᛚᛁᛞ ᚲᛖᛃ ᛖᛈᛟᚲᚺ ᚨᚾᛞ ᚨᛈᛈᛚᛁᛖᛊ ᚨ ᚱᛖᚹᛟᚲᛖᛞ ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚ ᛖᚲᛊᚲᛚᚢᛊᛁᛟᚾ ᛚᛁᛊᛏ ᛏᛟ ᚷᚢᚨᚱᚨᚾᛏᛖᛖ ᚦᚨᛏ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ ᚨᚱᛖ ᛈᚢᚱᚷᛖᛞ.
ᛁᚠ ᚨ ᚱᛖᛊᛁᛞᚢᚨᛚ ᚢᚾᚲᚾᛟᚹᚾ ᛖᚲᛊᛁᛊᛏᛊ—ᚨ ᚾᛟᚾ-ᚲᚱᛁᛏᛁᚲᚨᛚ ᛊᛏᚨᛏᛖ ᛁᛏᛖᛗ ᚦᚨᛏ ᚲᚨᚾᚾᛟᛏ ᛒᛖ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᚹᛖᚱᛁᚠᛁᛖᛞ—ᚦᛖ ᚱᛖᚲᛟᚹᛖᚱᛃ ᛈᚱᛟᚲᛖᛊᛊ ᚱᛖᚲᚹᛁᚱᛖᛊ ᛖᚲᛊᛈᛚᛁᚲᛁᛏ ᛊᛁᚷᚾ-ᛟᚠᚠ ᚠᚱᛟᛗ ᚦᛖ ᚱᛖᚹᛁᛖᚹ ᚲᚹᛟᚱᚢᛗ ᛒᛖᚠᛟᚱᛖ ᚦᛖ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ ᛁᛊ ᚢᚾᛊᛖᚨᛚᛖᛞ.

10. ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᚨᛚ ᛊᚲᚺᛖᛗᚨᛊ

ᚦᛖ ᚠᛟᛚᛚᛟᚹᛁᛜ ᛃᚨᛗᛚ ᛊᚲᚺᛖᛗᚨᛊ ᛞᛖᚠᛁᚾᛖ ᚦᛖ ᛊᛏᚱᛁᚲᛏ ᛞᚨᛏᚨ ᛊᛏᚱᚢᚲᛏᚢᚱᛖᛊ ᚢᛊᛖᛞ ᛒᛃ ᚦᛖ ᛞᛖᚠᛖᚾᛊᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚠᛟᚱ ᛊᛖᚱᛁᚨᛚᛁᛉᚨᛏᛁᛟᚾ ᚨᚾᛞ ᚹᚨᛚᛁᛞᚨᛏᛁᛟᚾ.

10.1 ᛁᛞᛖᚾᛏᛁᛏᛃ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᚹᛟᚱᚲᛚᛟᚨᛞᛁᛞᛖᚾᛏᛁᛏᛃ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᛊᛈᛁᚠᚠᛖ_ᛁᛞ: “ᚢᚱᛁ ᚠᛟᚱᛗᚨᛏ (e.g., ᛊᛈᛁᚠᚠᛖ://ᛉ.internal/ᚾᛊ/ᚨᛁ/ᛊᚨ/ᛗᛟᛞᛖᛚ-ᚱᚢᚾᚾᛖᚱ)”
ᛊᚹᛁᛞ_ᛏᛃᛈᛖ: “ᛖᚾᚢᛗ [ᚲᛊ509, ᛃᚹᛏ]“
ᚺᚨᚱᛞᚹᚨᚱᛖ_ᚱᛟᛟᛏ:
ᛏᛈᛗ_ᛖᚲ_ᛈᚢᛒ_ᚺᚨᛊᚺ: “ᛊᚺᚨ256 ᛞᛁᚷᛖᛊᛏ ᛟᚠ ᛖᚾᛞᛟᚱᛊᛖᛗᛖᚾᛏ ᚲᛖᛃ”
ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ_ᚲᚹᛟᛏᛖ: “ᛏᛈᛗ2ᛒ_ᚨᛏᛏᛖᛊᛏ ᛊᛏᚱᚢᚲᛏ”
ᚾᚨᛗᛖᛊᛈᚨᚲᛖ_ᛒᛁᚾᛞᛁᛜ: “ᛊᛏᚱᛁᛜ ᚱᛖᛈᚱᛖᛊᛖᚾᛏᛁᛜ ᛖᚲᛊᛖᚲᚢᛏᛁᛟᚾ ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ”
ᚲᛖᛃ_ᛖᛈᛟᚲᚺ: “ᛁᚾᛏᛖᚷᛖᚱ (ᚲᚢᚱᚱᛖᚾᛏ ᚱᛟᛏᚨᛏᛁᛟᚾ ᚠᚨᛊᛖ)”
ᛖᚲᛊᛈᛁᚱᛃ: “ᛁᛊᛟ8601 ᛏᛁᛗᛖᛊᛏᚨᛗᛈ”

10.2 ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᛊᛟᚠᛏᚹᚨᚱᛖᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
_ᛏᛃᛈᛖ: “https://in-toto.io/Statement/v1”
ᛊᚢᛒᛃᛖᚲᛏ:
ᚾᚨᛗᛖ: “ᚨᚱᛏᛁᚠᚨᚲᛏ ᚢᚱᛁ”
ᛞᛁᚷᛖᛊᛏ: “ᛊᚺᚨ256 ᛞᛁᚷᛖᛊᛏ”
ᛈᚱᛖᛞᛁᚲᚨᛏᛖᛏᛃᛈᛖ: “https://slsa.dev/provenance/v1”
ᛈᚱᛖᛞᛁᚲᚨᛏᛖ:
ᛒᚢᛁᛚᛞᛞᛖᚠᛁᚾᛁᛏᛁᛟᚾ:
ᛒᚢᛁᛚᛞᛏᛃᛈᛖ: “https://ᛉ.internal/build/v1”
ᛖᚲᛊᛏᛖᚱᚾᚨᛚᛈᚨᚱᚨᛗᛖᛏᛖᚱᛊ:
ᛊᛟᚢᚱᚲᛖ_ᛞᛁᚷᛖᛊᛏ: “ᛊᚺᚨ256”
ᛞᛖᛈᛖᚾᛞᛖᚾᚲᛃ_ᚷᚱᚨᚠ_ᚱᛖᚠ: “ᚢᚱᛁ ᛏᛟ ᛊᛒᛟᛗ”
ᚱᚢᚾᛞᛖᛏᚨᛁᛚᛊ:
ᛒᚢᛁᛚᛞᛖᚱ:
ᛁᛞ: “ᛊᛈᛁᚠᚠᛖ://ᛉ.internal/ᛒᚢᛁᛚᛞᛖᚱ”
ᛗᛖᛏᚨᛞᚨᛏᚨ:
ᛁᚾᚹᛟᚲᚨᛏᛁᛟᚾᛁᛞ: “ᚢᚢᛁᛞ”
ᛊᛏᚨᚱᛏᛖᛞᛟᚾ: “ᛁᛊᛟ8601”

10.3 ᛖᚹᛁᛞᛖᚾᚲᛖ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᛖᚹᛁᛞᛖᚾᚲᛖᚱᛖᚲᛟᚱᛞ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᛖᚹᛁᛞᛖᚾᚲᛖ_ᛁᛞ: “ᚢᚢᛁᛞ”
ᛊᛟᚢᚱᚲᛖ_ᛁᛞᛖᚾᛏᛁᛏᛃ: “ᛊᛈᛁᚠᚠᛖ_ᛁᛞ ᛟᚠ ᚷᛖᚾᛖᚱᚨᛏᛁᛜ ᚹᛟᚱᚲᛚᛟᚨᛞ”
ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ_ᛁᛞ: “ᚢᚢᛁᛞ (ᚷᚱᛟᚢᛈᛊ ᛁᛞᛖᚾᛏᛁᚲᚨᛚ ᚢᚾᛞᛖᚱᛚᛃᛁᛜ ᛖᚹᛖᚾᛏᛊ)”
ᛏᚱᚨᚾᛊᚠᛟᚱᛗᚨᛏᛁᛟᚾ_ᚺᛁᛊᛏᛟᚱᛃ:
- ᚨᚲᛏᛟᚱ: “ᛊᛈᛁᚠᚠᛖ_ᛁᛞ”
ᚨᚲᛏᛁᛟᚾ: “ᛖᚾᚢᛗ [ᚠᛁᛚᛏᛖᚱ, ᚨᚷᚷᚱᛖᚷᚨᛏᛖ, ᛏᚱᚨᚾᛊᛚᚨᛏᛖ]“
ᛏᛁᛗᛖᛊᛏᚨᛗᛈ: “ᛁᛊᛟ8601”
ᚠᚱᛖᛊᚺᚾᛖᛊᛊ_ᛗᚨᚱᚲᛖᚱ: “ᛁᚾᛏᛖᚷᛖᚱ (ᛗᛟᚾᛟᛏᛟᚾᛁᚲ ᚲᛟᚢᚾᛏᛖᚱ ᛈᚱᛖᚹᛖᚾᛏᛁᛜ ᚱᛖᛈᛚᚨᛃ)”
ᛊᚢᛈᛖᚱᛊᛖᛊᛊᛁᛟᚾ_ᛁᛞ: “ᚢᚢᛁᛞ ᛟᚠ ᛖᚹᛁᛞᛖᚾᚲᛖ ᚦᛁᛊ ᚱᛖᛈᛚᚨᚲᛖᛊ”
ᛊᛏᚨᛏᚢᛊ: “ᛖᚾᚢᛗ [ᚹᚨᛚᛁᛞ, ᚹᛁᚦᛞᚱᚨᚹᚾ, ᚲᛟᚾᛏᚱᚨᛞᛁᚲᛏᛖᛞ]“

10.4 ᚨᚢᚦᛟᚱᛁᛏᛃ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᚨᚢᚦᛟᚱᛁᛏᛃᛞᛖᛚᛖᚷᚨᛏᛁᛟᚾ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᚱᛟᛚᛖ: “ᛖᚾᚢᛗ [ᚱᛟᛟᛏ, ᛏᚨᚱᚷᛖᛏᛊ, ᛊᚾᚨᛈᛊᚺᛟᛏ, ᛏᛁᛗᛖᛊᛏᚨᛗᛈ, ᚷᛟᚹᛖᚱᚾᛟᚱ]“
ᚲᛖᛃ_ᛁᛞᛖᚾᛏᛁᚠᛁᛖᚱᛊ:
- “ᛚᛁᛊᛏ ᛟᚠ ᚨᚲᛏᛁᚹᛖ ᛈᚢᛒᛚᛁᚲ ᚲᛖᛃ ᚠᛁᛜᛖᚱᛈᚱᛁᚾᛏᛊ”
ᚦᚱᛖᛊᚺᛟᛚᛞ: “ᛁᚾᛏᛖᚷᛖᚱ (ᚲᚹᛟᚱᚢᛗ ᚱᛖᚲᚹᛁᚱᛖᛗᛖᚾᛏ)”
ᚲᚢᚱᚱᛖᚾᛏ_ᛖᛈᛟᚲᚺ: “ᛁᚾᛏᛖᚷᛖᚱ”
ᛖᚲᛊᛈᛁᚱᛃ: “ᛁᛊᛟ8601”

10.5 ᚲᛖᛃ-ᛖᛈᛟᚲᚺ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᚲᛖᛃᛖᛈᛟᚲᚺ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᛖᛈᛟᚲᚺ_ᛁᛞ: “ᛁᚾᛏᛖᚷᛖᚱ”
ᚨᚲᛏᛁᚹᛖ_ᛊᛁᚷᚾᛖᚱᛊ: “ᛚᛁᛊᛏ ᛟᚠ ᛈᚢᛒᛚᛁᚲ ᚲᛖᛃ ᚠᛁᛜᛖᚱᛈᚱᛁᚾᛏᛊ”
ᚱᛖᚹᛟᚲᛖᛞ_ᛊᛁᚷᚾᛖᚱᛊ: “ᛚᛁᛊᛏ ᛟᚠ ᛈᚢᛒᛚᛁᚲ ᚲᛖᛃ ᚠᛁᛜᛖᚱᛈᚱᛁᚾᛏᛊ”
ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾ_ᚲᚹᛟᚱᚢᛗ: “ᛚᛁᛊᛏ ᛟᚠ ᚦᚱᛖᛊᚺᛟᛚᛞ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ ᚨᚢᚦᛟᚱᛁᛉᛁᛜ ᛖᛈᛟᚲᚺ”
ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ_ᚺᚨᛊᚺ: “ᛊᚺᚨ256 ᛟᚠ ᛊᛃᛊᛏᛖᛗ ᛊᛏᚨᛏᛖ ᚨᛏ ᛖᛈᛟᚲᚺ ᛒᛟᚢᚾᛞᚨᚱᛃ”

10.6 ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏᛒᛟᚢᚾᛞᚨᚱᛃ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ: “ᚢᚱᛁ”
ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ_ᛚᛖᚹᛖᛚ: “ᛖᚾᚢᛗ [ᚲᚹᚨᚱᚨᚾᛏᛁᚾᛖ, ᛁᛊᛟᛚᚨᛏᛖ, ᛊᛖᚹᛖᚱ]“
ᚾᛖᛏᚹᛟᚱᚲ_ᚱᛖᚨᚲᚺᚨᛒᛁᛚᛁᛏᛃ: “ᛖᚾᚢᛗ [ᛞᛖᚾᛃ_ᚨᛚᛚ, ᚨᛚᛚᛟᚹ_ᛗᛖᛏᚱᛁᚲᛊ_ᛟᚾᛚᛃ]“
ᛞᚨᛏᚨ_ᚨᚲᚲᛖᛊᛊ: “ᛖᚾᚢᛗ [ᚱᛖᚨᛞ_ᛟᚾᛚᛃ, ᚱᛖᚹᛟᚲᛖᛞ]“
ᚱᛖᛚᛖᚨᛊᛖ_ᛈᛖᚱᛗᛁᛊᛊᛁᛟᚾ: “ᛖᚾᚢᛗ [ᚠᚱᛟᛉᛖᚾ]“
ᛖᚹᛁᛞᛖᚾᚲᛖ_ᚲᚢᛊᛏᛟᛞᛃ_ᚱᛖᚠ: “ᚢᚢᛁᛞ ᛟᚠ ᛏᚱᛁᚷᚷᛖᚱᛁᛜ ᛖᚹᛁᛞᛖᚾᚲᛖ”
ᚱᛖᚹᛖᚱᛊᛁᛒᛁᛚᛁᛏᛃ_ᚲᛟᚾᛞᛁᛏᛁᛟᚾ: “ᛖᚾᚢᛗ [ᛗᚨᚾᚢᚨᛚ_ᚱᛖᚹᛁᛖᚹ, ᚨᚢᛏᛟᛗᚨᛏᛖᛞ_ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ]“

10.7 ᚱᛖᚲᛟᚹᛖᚱᛃ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᚨᛏᛏᛖᛊᛏᛖᛞᚱᛖᚲᛟᚹᛖᚱᛃ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᛒᚨᛊᛖᛚᛁᚾᛖ_ᛞᛁᚷᛖᛊᛏ: “ᛊᚺᚨ256 ᛟᚠ ᛏᚱᚢᛊᛏᛖᛞ ᛁᛗᛗᚢᛏᚨᛒᛚᛖ ᛊᛏᚨᛏᛖ”
ᛏᚱᚢᛊᛏᛖᛞ_ᚱᛟᛟᛏ: “ᚱᛟᛟᛏ ᚲᚨ ᛈᚢᛒᛚᛁᚲ ᚲᛖᛃ ᚠᛁᛜᛖᚱᛈᚱᛁᚾᛏ”
ᚹᚨᛚᛁᛞ_ᚲᛖᛃ_ᛖᛈᛟᚲᚺ: “ᛁᚾᛏᛖᚷᛖᚱ”
ᚱᛖᚹᛟᚲᛖᛞ_ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚ_ᛖᚲᛊᚲᛚᚢᛊᛁᛟᚾ: “ᛚᛁᛊᛏ ᛟᚠ ᛊᚹᛁᛞᛊ ᛖᚲᛊᛈᛚᛁᚲᛁᛏᛚᛃ ᛒᚨᚾᚾᛖᛞ”
ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ_ᚷᛟᚹᛖᚱᚾᛟᚱ_ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ: “ᛚᛁᛊᛏ ᛟᚠ ᚦᚱᛖᛊᚺᛟᛚᛞ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ”
ᚱᛖᛊᛁᛞᚢᚨᛚ_ᚢᚾᚲᚾᛟᚹᚾᛊ: “ᛚᛁᛊᛏ ᛟᚠ ᚾᛟᚾ-ᚲᚱᛁᛏᛁᚲᚨᛚ ᛊᛏᚨᛏᛖ ᛁᛏᛖᛗᛊ ᛞᛖᚠᛖᚱᚱᛖᛞ”

10.8 ᛖᚹᛖᚾᛏ ᛊᚲᚺᛖᛗᚨ

ᛃᚨᛗᛚ
ᛊᚲᚺᛖᛗᚨᚾᚨᛗᛖ: ᛖᚹᚢᛚᚷᚨᚱᛖᛚᛖᛞᚷᛖᚱᛖᚹᛖᚾᛏ
ᚹᛖᚱᛊᛁᛟᚾ: 1.0
ᚠᛁᛖᛚᛞᛊ:
ᛏᛁᛗᛖᛊᛏᚨᛗᛈ: “ᛁᛊᛟ8601”
ᛖᚹᛖᚾᛏ_ᛏᛃᛈᛖ: “ᛊᛏᚱᛁᛜ (ᛗᚨᛈᛊ ᛏᛟ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚠᚨᚢᛚᛏᛊ)”
ᚨᚲᛏᛟᚱ: “ᛊᛈᛁᚠᚠᛖ_ᛁᛞ”
ᚨᚲᛏᛁᛟᚾ: “ᛒᛟᚢᚾᛞᛖᛞ ᛟᚢᛏᛈᚢᛏ ᛖᚾᚢᛗ”
ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ_ᛈᚱᛟᛟᚠ: “ᚱᚠᚲ 6962 ᛚᛖᚨᚠ ᚺᚨᛊᚺ”

11. ᛈᛃᚦᛟᚾ ᛗᛟᛞᚢᛚᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚨᚾᛞ ᛊᚨᚠᛖ ᛈᛊᛖᚢᛞᛟᚲᛟᛞᛖ

ᚦᛖ ᛒᚨᚲᚲᛖᚾᛞ ᛊᛁᛗᚢᛚᚨᛏᛁᛟᚾ ᚨᚾᛞ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᛊ ᚨᚱᛖ ᚲᛟᚾᛊᛏᚱᚢᚲᛏᛖᛞ ᚠᚱᛟᛗ ᛊᚨᚠᛖ, ᛏᛁᚷᚺᛏᛚᛃ ᛊᚲᛟᛈᛖᛞ ᛈᛃᚦᛟᚾ ᛗᛟᛞᚢᛚᛖᛊ ᚢᛏᛁᛚᛁᛉᛁᛜ ᛏᛈᛗ2_ᛈᛃᛏᛊᛊ ᚠᛟᚱ ᚺᚨᚱᛞᚹᚨᚱᛖ ᛒᛁᚾᛞᛁᛜᛊ ᚨᚾᛞ ᛊᛏᚨᚾᛞᚨᚱᛞ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛚᛁᛒᚱᚨᚱᛁᛖᛊ ᚠᛟᚱ ᛈᚱᛟᛟᚠ ᚷᛖᚾᛖᚱᚨᛏᛁᛟᚾ31.

11.1 ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᚾᛞ ᚺᚨᚱᛞᚹᚨᚱᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ

ᛈᛃᚦᛟᚾ
“”“
ᛁᛞᛖᚾᛏᛁᛏᛃ_service.py
ᛈᚱᛟᚹᛁᛞᛖᛊ ᛊᛖᚲᚢᚱᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚠᛖᛏᚲᚺᛁᛜ ᚨᚾᛞ ᚺᚨᚱᛞᚹᚨᚱᛖ-ᚱᛟᛟᛏᛖᛞ ᚹᚨᛚᛁᛞᚨᛏᛁᛟᚾ ᚹᛁᚨ ᛏᛈᛗ 2.0.
“”“
ᚠᚱᛟᛗ ᛏᛈᛗ2_ᛈᛃᛏᛊᛊ ᛁᛗᛈᛟᚱᛏ ᛖᛊᚨᛈᛁ, ᛏᛈᛗ2ᛒ_ᚨᚢᚦ, ᛖᛊᛃᛊ_ᛏᚱ, ᛏᛈᛗᚨ_ᛊᛖᛊᛊᛁᛟᚾ
ᛁᛗᛈᛟᚱᛏ ᚱᛖᚲᚹᛖᛊᛏᛊ

ᚲᛚᚨᛊᛊ ᛁᛞᛖᚾᛏᛁᛏᛃᛊᛖᚱᚹᛁᚲᛖ:
ᛞᛖᚠ __ᛁᚾᛁᛏ__(ᛊᛖᛚᚠ, ᛊᛈᛁᚱᛖ_ᛊᛟᚲᚲᛖᛏ_ᛈᚨᚦ=”/ᛏᛗᛈ/ᛊᛈᛁᚱᛖ-ᚨᚷᛖᚾᛏ/ᛈᚢᛒᛚᛁᚲ/api.sock”):
self.spire_ᛊᛟᚲᚲᛖᛏ \= ᛊᛈᛁᚱᛖ_ᛊᛟᚲᚲᛖᛏ_ᛈᚨᚦ
self.tpm \= ᛖᛊᚨᛈᛁ()

ᛞᛖᚠ ᚠᛖᛏᚲᚺ\_ᚹᛟᚱᚲᛚᛟᚨᛞ\_ᛊᚹᛁᛞ(ᛊᛖᛚᚠ, ᛊᛈᛁᚠᚠᛖ\_ᛁᛞ\_ᛈᚱᛖᚠᛁᚲᛊ):  
    """ᚠᛖᛏᚲᚺᛖᛊ ᛊᚹᛁᛞ ᚹᛁᚨ ᛚᛟᚲᚨᛚ ᛊᛈᛁᚱᛖ ᚨᚷᛖᚾᛏ ᚢᚾᛁᚲᛊ ᛊᛟᚲᚲᛖᛏ."""  
    \# ᛈᛊᛖᚢᛞᛟᚲᛟᛞᛖ ᚠᛟᚱ ᛊᛈᛁᚱᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᚨᛈᛁ ᚺᛏᛏᛈ ᚹᚱᚨᛈᛈᛖᚱ  
    ᛏᚱᛃ:  
        ᚱᛖᛊᛈᛟᚾᛊᛖ \= requests.get(  
            "http://localhost/svid",   
            ᛈᚨᚱᚨᛗᛊ={"ᛊᛈᛁᚠᚠᛖ\_ᛁᛞ": ᛊᛈᛁᚠᚠᛖ\_ᛁᛞ\_ᛈᚱᛖᚠᛁᚲᛊ}  
        )  
        ᛁᚠ response.status\_ᚲᛟᛞᛖ \== 200:  
            ᚱᛖᛏᚢᚱᚾ response.json().ᚷᛖᛏ("ᛊᚹᛁᛞ")  
    ᛖᚲᛊᚲᛖᛈᛏ ᛖᚲᛊᚲᛖᛈᛏᛁᛟᚾ:  
        ᚱᛖᛏᚢᚱᚾ ᚾᛟᚾᛖ  
    ᚱᛖᛏᚢᚱᚾ ᚾᛟᚾᛖ

ᛞᛖᚠ ᚨᛏᛏᛖᛊᛏ\_ᚺᚨᚱᛞᚹᚨᚱᛖ(ᛊᛖᛚᚠ, ᛖᚲᛊᛈᛖᚲᛏᛖᛞ\_ᛖᚲ\_ᚺᚨᛊᚺ):  
    """ᚢᛊᛖᛊ ᛏᛈᛗ2\_ᛈᛃᛏᛊᛊ ᛏᛟ ᚹᛖᚱᛁᚠᛃ ᚠᛃᛊᛁᚲᚨᛚ ᛏᛈᛗ ᛈᚱᛖᛊᛖᚾᚲᛖ ᚨᚾᛞ ᚱᛖᚨᛞ ᚦᛖ ᛖᚲ."""  
    ᛏᚱᛃ:  
        \# 0ᚲᛊ81010005 ᛁᛊ ᚦᛖ ᛊᛏᚨᚾᛞᚨᚱᛞ ᛖᚾᛞᛟᚱᛊᛖᛗᛖᚾᛏ ᚲᛖᛃ ᛈᛖᚱᛊᛁᛊᛏᛖᚾᛏ ᚺᚨᚾᛞᛚᛖ  
        ᛖᚲ\_ᚺᚨᚾᛞᛚᛖ \= self.tpm.tr\_ᚠᚱᛟᛗ\_ᛏᛈᛗᛈᚢᛒᛚᛁᚲ(0ᚲᛊ81010005)  
        ᛖᚲ\_ᛈᚢᛒ \= self.tpm.readpublic(ᛖᚲ\_ᚺᚨᚾᛞᛚᛖ)  
        \# ᚹᛖᚱᛁᚠᛃ ᛖᚲ ᛈᚢᛒᛚᛁᚲ ᚨᚱᛖᚨ ᚺᚨᛊᚺ ᚨᚷᚨᛁᚾᛊᛏ ᛖᚲᛊᛈᛖᚲᛏᛖᛞ ᚨᛚᛚᛟᚹ-ᛚᛁᛊᛏ  
        ᚨᚲᛏᚢᚨᛚ\_ᚺᚨᛊᚺ \= ᛖᚲ\_ᛈᚢᛒ\[0\].ᚷᛖᛏ\_ᚾᚨᛗᛖ().ᚺᛖᚲᛊ()  
        ᚱᛖᛏᚢᚱᚾ ᚨᚲᛏᚢᚨᛚ\_ᚺᚨᛊᚺ \== ᛖᚲᛊᛈᛖᚲᛏᛖᛞ\_ᛖᚲ\_ᚺᚨᛊᚺ  
    ᛖᚲᛊᚲᛖᛈᛏ ᛖᚲᛊᚲᛖᛈᛏᛁᛟᚾ ᚨᛊ ᛖ:  
        \# ᛊᛃᚾᚦᛖᛏᛁᚲ ᚱᛖᛊᛈᛟᚾᛊᛖ ᚠᛟᚱ ᛏᛖᛊᛏᛁᛜ: ᚺᚨᚱᛞᚹᚨᚱᛖ ᚠᚨᛁᛚᚢᚱᛖ  
        ᚱᛖᛏᚢᚱᚾ ᚠᚨᛚᛊᛖ

11.2 ᚨᚢᚦᛟᚱᛁᛏᛃ ᚨᚾᛞ ᚱᛖᚲᛖᛃᛁᛜ

ᛈᛃᚦᛟᚾ
“”“
ᚨᚢᚦᛟᚱᛁᛏᛃ_service.py & ᚱᛖᚲᛖᛃ_service.py
ᛗᚨᚾᚨᚷᛖᛊ ᛏᚢᚠ-ᛊᛏᛃᛚᛖ ᚲᛖᛃ ᛖᛈᛟᚲᚺᛊ, ᚦᚱᛖᛊᚺᛟᛚᛞᛊ, ᚨᚾᛞ ᚱᛖᚹᛟᚲᚨᛏᛁᛟᚾ.
“”“
ᚲᛚᚨᛊᛊ ᚱᛖᚲᛖᛃᛊᛖᚱᚹᛁᚲᛖ:
ᛞᛖᚠ __ᛁᚾᛁᛏ__(ᛊᛖᛚᚠ, ᚲᚢᚱᚱᛖᚾᛏ_ᛖᛈᛟᚲᚺ, ᚲᚢᚱᚱᛖᚾᛏ_ᛊᛁᚷᚾᛖᚱᛊ, ᚦᚱᛖᛊᚺᛟᛚᛞ=3):
self.epoch \= ᚲᚢᚱᚱᛖᚾᛏ_ᛖᛈᛟᚲᚺ
self.active_ᛊᛁᚷᚾᛖᚱᛊ \= ᚲᚢᚱᚱᛖᚾᛏ_ᛊᛁᚷᚾᛖᚱᛊ
self.threshold \= ᚦᚱᛖᛊᚺᛟᛚᛞ

ᛞᛖᚠ ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾ\_ᛖᛈᛟᚲᚺ(ᛊᛖᛚᚠ, ᚾᛖᚹ\_ᛊᛁᚷᚾᛖᚱ\_ᚲᛖᛃᛊ, ᚲᚹᛟᚱᚢᛗ\_ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ):  
    """ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾᛊ ᛏᛟ ᚦᛖ ᚾᛖᚲᛊᛏ ᛖᛈᛟᚲᚺ ᛁᚠ ᚲᚹᛟᚱᚢᛗ ᛁᛊ ᛗᛖᛏ."""  
    ᛁᚠ ᛊᛖᛚᚠ.\_ᚹᛖᚱᛁᚠᛃ\_ᚦᚱᛖᛊᚺᛟᛚᛞ(ᚲᚹᛟᚱᚢᛗ\_ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ):  
        self.epoch \+= 1  
        self.active\_ᛊᛁᚷᚾᛖᚱᛊ \= ᚾᛖᚹ\_ᛊᛁᚷᚾᛖᚱ\_ᚲᛖᛃᛊ  
        ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ  
    ᚱᛖᛏᚢᚱᚾ ᚠᚨᛚᛊᛖ

ᛞᛖᚠ \_ᚹᛖᚱᛁᚠᛃ\_ᚦᚱᛖᛊᚺᛟᛚᛞ(ᛊᛖᛚᚠ, ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ):  
    """ᚹᛖᚱᛁᚠᛁᛖᛊ ᛗ-ᛟᚠ-ᚾ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ ᚠᚱᛟᛗ ᚲᚢᚱᚱᛖᚾᛏ ᛖᛈᛟᚲᚺ ᛊᛁᚷᚾᛖᚱᛊ."""  
    ᚹᚨᛚᛁᛞ\_ᚲᛟᚢᚾᛏ \= 0  
    ᚠᛟᚱ ᛊᛁᚷ ᛁᚾ ᛊᛁᚷᚾᚨᛏᚢᚱᛖᛊ:  
        ᛁᚠ ᛊᛖᛚᚠ.\_ᚹᛖᚱᛁᚠᛃ\_ᛊᛁᚷ(ᛊᛁᚷ): \# ᚲᚱᛃᛈᛏᛟ ᚹᚨᛚᛁᛞᚨᛏᛁᛟᚾ ᛊᛏᚢᛒ  
            ᚹᚨᛚᛁᛞ\_ᚲᛟᚢᚾᛏ \+= 1  
    ᚱᛖᛏᚢᚱᚾ ᚹᚨᛚᛁᛞ\_ᚲᛟᚢᚾᛏ \>= self.threshold

ᛞᛖᚠ \_ᚹᛖᚱᛁᚠᛃ\_ᛊᛁᚷ(ᛊᛖᛚᚠ, ᛊᛁᚷ):  
    ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ \# ᛈᛚᚨᚲᛖᚺᛟᛚᛞᛖᚱ ᚠᛟᚱ ᚨᚲᛏᚢᚨᛚ ᛖᛞ25519 ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ

11.3 ᛖᚹᛖᚾᛏ ᛚᛖᛞᚷᛖᚱ ᚨᚾᛞ ᛈᚱᛟᛟᚠ ᛖᛜᛁᚾᛖ (ᚱᚠᚲ 6962)

ᛈᛃᚦᛟᚾ
“”“
ᛖᚹᛖᚾᛏ_ledger.py & ᛈᚱᛟᛟᚠ_engine.py
ᚨᛈᛈᛖᚾᛞ-ᛟᚾᛚᛃ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ ᛚᛟᚷ ᚠᛟᚱ ᛏᚨᛗᛈᛖᚱ-ᛖᚹᛁᛞᛖᚾᛏ ᛖᚹᛁᛞᛖᚾᚲᛖ.
“”“
ᛁᛗᛈᛟᚱᛏ ᚺᚨᛊᚺᛚᛁᛒ
ᛁᛗᛈᛟᚱᛏ ᛃᛊᛟᚾ

ᚲᛚᚨᛊᛊ ᛗᛖᚱᚲᛚᛖᛚᛖᛞᚷᛖᚱ:
ᛞᛖᚠ __ᛁᚾᛁᛏ__(ᛊᛖᛚᚠ):
self.leaves \= []
self.tree \= {}

ᛞᛖᚠ \_ᚺᚨᛊᚺ\_ᛚᛖᚨᚠ(ᛊᛖᛚᚠ, ᛞᚨᛏᚨ: ᛒᛃᛏᛖᛊ) \-\> ᛒᛃᛏᛖᛊ:  
    """ᚱᚠᚲ 6962 ᛞᛟᛗᚨᛁᚾ ᛊᛖᛈᚨᚱᚨᛏᛁᛟᚾ: 0ᚲᛊ00 ᛈᚱᛖᚠᛁᚲᛊ ᚠᛟᚱ ᛚᛖᚨᚹᛖᛊ"""  
    ᚱᛖᛏᚢᚱᚾ hashlib.sha256(ᛒ'\\ᚲᛊ00' \+ ᛞᚨᛏᚨ).ᛞᛁᚷᛖᛊᛏ()

ᛞᛖᚠ \_ᚺᚨᛊᚺ\_ᚾᛟᛞᛖ(ᛊᛖᛚᚠ, ᛚᛖᚠᛏ: ᛒᛃᛏᛖᛊ, ᚱᛁᚷᚺᛏ: ᛒᛃᛏᛖᛊ) \-\> ᛒᛃᛏᛖᛊ:  
    """ᚱᚠᚲ 6962 ᛞᛟᛗᚨᛁᚾ ᛊᛖᛈᚨᚱᚨᛏᛁᛟᚾ: 0ᚲᛊ01 ᛈᚱᛖᚠᛁᚲᛊ ᚠᛟᚱ ᛁᚾᛏᛖᚱᚾᚨᛚ ᚾᛟᛞᛖᛊ"""  
    ᚱᛖᛏᚢᚱᚾ hashlib.sha256(ᛒ'\\ᚲᛊ01' \+ ᛚᛖᚠᛏ \+ ᚱᛁᚷᚺᛏ).ᛞᛁᚷᛖᛊᛏ()

ᛞᛖᚠ ᚨᛈᛈᛖᚾᛞ\_ᛖᚹᛖᚾᛏ(ᛊᛖᛚᚠ, ᛖᚹᛖᚾᛏ\_ᛞᛁᚲᛏ):  
    """ᚨᛈᛈᛖᚾᛞᛊ ᚨ ᚲᚨᚾᛟᚾᛁᚲᚨᛚ ᛃᛊᛟᚾ ᛖᚹᛖᚾᛏ ᛏᛟ ᚦᛖ ᛚᛖᛞᚷᛖᚱ."""  
    ᚲᚨᚾᛟᚾᛁᚲᚨᛚ\_ᛞᚨᛏᚨ \= json.dumps(ᛖᚹᛖᚾᛏ\_ᛞᛁᚲᛏ, ᛊᛟᚱᛏ\_ᚲᛖᛃᛊ=ᛏᚱᚢᛖ).ᛖᚾᚲᛟᛞᛖ('ᚢᛏᚠ-8')  
    ᛚᛖᚨᚠ\_ᚺᚨᛊᚺ \= ᛊᛖᛚᚠ.\_ᚺᚨᛊᚺ\_ᛚᛖᚨᚠ(ᚲᚨᚾᛟᚾᛁᚲᚨᛚ\_ᛞᚨᛏᚨ)  
    self.leaves.append(ᛚᛖᚨᚠ\_ᚺᚨᛊᚺ)  
    \# ᚾᛟᛏᛖ: ᛞᛃᚾᚨᛗᛁᚲ ᛏᚱᛖᛖ ᚱᛖᚲᚨᛚᚲᚢᛚᚨᛏᛁᛟᚾ ᛚᛟᚷᛁᚲ ᛟᛗᛁᛏᛏᛖᛞ ᚠᛟᚱ ᛒᚱᛖᚹᛁᛏᛃ  
    ᚱᛖᛏᚢᚱᚾ ᛚᛖᚨᚠ\_hash.hex()

ᛞᛖᚠ ᚷᛖᚾᛖᚱᚨᛏᛖ\_ᛁᚾᚲᛚᚢᛊᛁᛟᚾ\_ᛈᚱᛟᛟᚠ(ᛊᛖᛚᚠ, ᛁᚾᛞᛖᚲᛊ):  
    """ᚷᛖᚾᛖᚱᚨᛏᛖᛊ ᚨᚾ ᛟ(ᛚᛟᚷ ᚾ) ᛁᚾᚲᛚᚢᛊᛁᛟᚾ ᛈᚱᛟᛟᚠ ᚠᛟᚱ ᚨ ᚷᛁᚹᛖᚾ ᛚᛖᚨᚠ ᛁᚾᛞᛖᚲᛊ."""  
    \# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛈᚱᛟᛟᚠ ᛟᚢᛏᛈᚢᛏ  
    ᚱᛖᛏᚢᚱᚾ {"ᛚᛖᚨᚠ\_ᛁᚾᛞᛖᚲᛊ": ᛁᚾᛞᛖᚲᛊ, "ᚨᚢᛞᛁᛏ\_ᛈᚨᚦ": \["ᚺᚨᛊᚺ1", "ᚺᚨᛊᚺ2"\]}

ᚲᛚᚨᛊᛊ ᛈᚱᛟᛟᚠᛖᛜᛁᚾᛖ:
ᛞᛖᚠ ᚹᛖᚱᛁᚠᛃ_ᛁᚾᚲᛚᚢᛊᛁᛟᚾ(ᛊᛖᛚᚠ, ᛚᛖᚨᚠ_ᚺᚨᛊᚺ, ᚨᚢᛞᛁᛏ_ᛈᚨᚦ, ᛖᚲᛊᛈᛖᚲᛏᛖᛞ_ᚱᛟᛟᛏ):
“”“ᚹᛖᚱᛁᚠᛁᛖᛊ ᚦᛖ ᚨᚢᛞᛁᛏ ᛈᚨᚦ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚱᛖᚲᛟᚾᛊᛏᚱᚢᚲᛏᛊ ᚦᛖ ᚱᛟᛟᛏ.”“”
ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ \= ᛚᛖᚨᚠ_ᚺᚨᛊᚺ
ᚠᛟᚱ ᛊᛁᛒᛚᛁᛜ_ᚺᚨᛊᚺ ᛁᚾ ᚨᚢᛞᛁᛏ_ᛈᚨᚦ:
# ᛖᚾᚠᛟᚱᚲᛖ ᚲᚨᚾᛟᚾᛁᚲᚨᛚ ᛟᚱᛞᛖᚱᛁᛜ ᚠᛟᚱ ᚺᚨᛊᚺᛁᛜ
ᛁᚠ ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ \< ᛊᛁᛒᛚᛁᛜ_ᚺᚨᛊᚺ:
ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ \= ᛗᛖᚱᚲᛚᛖᛚᛖᛞᚷᛖᚱ()._ᚺᚨᛊᚺ_ᚾᛟᛞᛖ(ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ, ᛊᛁᛒᛚᛁᛜ_ᚺᚨᛊᚺ)
ᛖᛚᛊᛖ:
ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ \= ᛗᛖᚱᚲᛚᛖᛚᛖᛞᚷᛖᚱ()._ᚺᚨᛊᚺ_ᚾᛟᛞᛖ(ᛊᛁᛒᛚᛁᛜ_ᚺᚨᛊᚺ, ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ)
ᚱᛖᛏᚢᚱᚾ ᚲᚢᚱᚱᛖᚾᛏ_ᚺᚨᛊᚺ \== ᛖᚲᛊᛈᛖᚲᛏᛖᛞ_ᚱᛟᛟᛏ

11.4 ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚾᛞ ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ

ᛈᛃᚦᛟᚾ
“”“
ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ_service.py & ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾ_service.py
ᛏᚱᚨᚾᛊᛚᚨᛏᛖᛊ ᚨᛒᛊᛏᚱᚨᚲᛏ ᛞᛖᚠᛖᚾᛊᛖ ᛞᛖᚲᛁᛊᛁᛟᚾᛊ ᛁᚾᛏᛟ ᚾᛖᛏᚹᛟᚱᚲ ᚨᚾᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ.
“”“
ᚲᛚᚨᛊᛊ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏᛊᛖᚱᚹᛁᚲᛖ:
ᛞᛖᚠ ᛖᚲᛊᛖᚲᚢᛏᛖ_ᛒᛟᚢᚾᛞᛖᛞ_ᚱᛖᛊᛈᛟᚾᛊᛖ(ᛊᛖᛚᚠ, ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ, ᚱᛖᛊᛈᛟᚾᛊᛖ_ᛖᚾᚢᛗ):
“”“ᛖᚲᛊᛖᚲᚢᛏᛖᛊ ᛒᛟᚢᚾᛞᛖᛞ ᛟᚢᛏᛈᚢᛏ. ᚾᛟ ᛟᚠᚠᛖᚾᛊᛁᚹᛖ ᚲᛟᚢᚾᛏᛖᚱᚨᛏᛏᚨᚲᚲᛊ ᛈᛖᚱᛗᛁᛏᛏᛖᛞ.”“”
ᛁᚠ ᚱᛖᛊᛈᛟᚾᛊᛖ_ᛖᚾᚢᛗ \== “ᛞᛖᚾᛃ_ᚱᛖᚲᚹᛖᛊᛏ”:
ᚱᛖᛏᚢᚱᚾ ᛊᛖᛚᚠ._ᛞᛖᚾᛃ_ᚨᛈᛁ(ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ)
ᛖᛚᛁᚠ ᚱᛖᛊᛈᛟᚾᛊᛖ_ᛖᚾᚢᛗ \== “ᛁᛊᛟᛚᚨᛏᛖ_ᚹᛟᚱᚲᛚᛟᚨᛞ”:
ᚱᛖᛏᚢᚱᚾ ᛊᛖᛚᚠ._ᛁᛊᛟᛚᚨᛏᛖ(ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ)
ᛖᛚᛁᚠ ᚱᛖᛊᛈᛟᚾᛊᛖ_ᛖᚾᚢᛗ \== “ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ”:
ᚱᛖᛏᚢᚱᚾ ᛊᛖᛚᚠ._ᛊᛖᚹᛖᚱ(ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ)
ᛖᛚᛁᚠ ᚱᛖᛊᛈᛟᚾᛊᛖ_ᛖᚾᚢᛗ \== “ᚠᚱᛖᛖᛉᛖ_ᚱᛖᛚᛖᚨᛊᛖ_ᚲᚺᚨᚾᚾᛖᛚ”:
ᚱᛖᛏᚢᚱᚾ ᛊᛖᛚᚠ._ᚠᚱᛖᛖᛉᛖ_ᚲᛁ_ᚲᛞ()
ᛖᛚᛁᚠ ᚱᛖᛊᛈᛟᚾᛊᛖ_ᛖᚾᚢᛗ \== “ᚱᛖᚲᛟᚾᚲᛁᛚᛖ”:
ᚱᛖᛏᚢᚱᚾ ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾᛊᛖᚱᚹᛁᚲᛖ().ᚠᛟᚱᚲᛖ_ᛊᛃᚾᚲ(ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ)
ᛖᛚᛊᛖ:
ᚱᛖᛏᚢᚱᚾ ᛊᛖᛚᚠ._ᚨᛒᛊᛏᚨᛁᚾ()

ᛞᛖᚠ \_ᛁᛊᛟᛚᚨᛏᛖ(ᛊᛖᛚᚠ, ᛊᛈᛁᚠᚠᛖ\_ᛁᛞ):  
    \# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾ: ᛁᚾᛊᛏᚱᚢᚲᛏ ᛊᛈᛁᚱᛖ ᛏᛟ ᚱᛖᚹᛟᚲᛖ ᛊᚹᛁᛞ  
    \# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾ: ᚢᛈᛞᚨᛏᛖ ᚲᚾᛁ ᛏᛟ ᛞᚱᛟᛈ ᛈᚨᚲᚲᛖᛏᛊ  
    ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ

ᛞᛖᚠ \_ᛊᛖᚹᛖᚱ(ᛊᛖᛚᚠ, ᚾᚨᛗᛖᛊᛈᚨᚲᛖ\_ᚢᚱᛁ):  
    \# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾ: ᛞᛖᚾᛃ\_ᚨᛚᛚ ᛖᛒᛈᚠ ᛈᛟᛚᛁᚲᛃ ᚨᛈᛈᛚᛁᛖᛞ ᛏᛟ ᚾᚨᛗᛖᛊᛈᚨᚲᛖ  
    ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ

ᛞᛖᚠ \_ᚠᚱᛖᛖᛉᛖ\_ᚲᛁ\_ᚲᛞ(ᛊᛖᛚᚠ):  
    \# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾ: ᚺᚨᛚᛏ ᛈᛁᛈᛖᛚᛁᚾᛖᛊ  
    ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ

ᛞᛖᚠ \_ᚨᛒᛊᛏᚨᛁᚾ(ᛊᛖᛚᚠ):  
    \# ᛞᛖᚠᛖᚱ ᛏᛟ ᚺᚢᛗᚨᚾ ᛟᚱ ᛊᛖᚲᛟᚾᛞᚨᚱᛃ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ  
    ᚱᛖᛏᚢᚱᚾ ᚠᚨᛚᛊᛖ

ᚲᛚᚨᛊᛊ ᚱᛖᚲᛟᚾᚲᛁᛚᛁᚨᛏᛁᛟᚾᛊᛖᚱᚹᛁᚲᛖ:
ᛞᛖᚠ ᚠᛟᚱᚲᛖ_ᛊᛃᚾᚲ(ᛊᛖᛚᚠ, ᛊᛈᛁᚠᚠᛖ_ᛁᛞ):
“”“ᚠᛟᚱᚲᛖᛊ ᚨ ᚾᛟᛞᛖ ᛟᚢᛏ ᛟᚠ ᚨ ᛊᛈᛚᛁᛏ-ᛒᚱᚨᛁᚾ ᛊᛏᚨᛏᛖ ᛏᛟ ᛊᛃᚾᚲᚺᚱᛟᚾᛁᛉᛖ ᛖᛈᛟᚲᚺᛊ.”“”
ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ

11.5 ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᚨᚾᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ

ᛈᛃᚦᛟᚾ
“”“
ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ_service.py & ᚱᛖᚲᛟᚹᛖᚱᛃ_service.py
ᚺᚨᚾᛞᛚᛖᛊ ᛊᛚᛊᚨ ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ ᚨᚾᛞ ᚨᛏᛏᛖᛊᛏᛖᛞ ᛒᚨᛊᛖᛚᛁᚾᛖ ᚱᛖᛊᛏᛟᚱᚨᛏᛁᛟᚾ.
“”“
ᚲᛚᚨᛊᛊ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾᛊᛖᚱᚹᛁᚲᛖ:
ᛞᛖᚠ ᚹᛖᚱᛁᚠᛃ_ᛊᛚᛊᚨ_ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ(ᛊᛖᛚᚠ, ᚨᚱᛏᛁᚠᚨᚲᛏ_ᛞᛁᚷᛖᛊᛏ, ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ_ᛖᚾᚹᛖᛚᛟᛈᛖ):
“”“ᚹᛖᚱᛁᚠᛁᛖᛊ ᛞᛊᛊᛖ ᛖᚾᚹᛖᛚᛟᛈᛖ ᚨᚾᛞ ᛊᛚᛊᚨ v1.0 ᛈᚨᛃᛚᛟᚨᛞ.”“”
# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛚᛟᚷᛁᚲ: ᚲᚺᛖᚲᚲ ᛊᛁᚷᚾᚨᛏᚢᚱᛖ, ᛖᚲᛊᛏᚱᚨᚲᛏ ᛊᚢᛒᛃᛖᚲᛏ ᛞᛁᚷᛖᛊᛏ, ᚲᛟᛗᛈᚨᚱᛖ.
ᚱᛖᛏᚢᚱᚾ ᛏᚱᚢᛖ

ᚲᛚᚨᛊᛊ ᚱᛖᚲᛟᚹᛖᚱᛃᛊᛖᚱᚹᛁᚲᛖ:
ᛞᛖᚠ ᚹᛖᚱᛁᚠᛃ_ᛒᚨᛊᛖᛚᛁᚾᛖ(ᛊᛖᛚᚠ, ᛈᚱᛟᛈᛟᛊᛖᛞ_ᛊᛏᚨᛏᛖ, ᛏᚱᚢᛊᛏᛖᛞ_ᚱᛟᛟᛏ_ᚺᚨᛊᚺ):
“”“ᛖᚾᛊᚢᚱᛖᛊ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛒᛟᛟᛏᛊ ᛁᚾᛏᛟ ᚨ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚹᚨᛚᛁᛞ ᛊᛏᚨᛏᛖ.”“”
# ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛚᛟᚷᛁᚲ: ᚲᛟᛗᛈᚨᚱᛖ ᛊᛏᚨᛏᛖ ᚺᚨᛊᚺ ᚨᚷᚨᛁᚾᛊᛏ ᛁᛗᛗᚢᛏᚨᛒᛚᛖ ᛏᚱᚢᛊᛏᛖᛞ ᚱᛟᛟᛏ
ᚨᚲᛏᚢᚨᛚ_ᚺᚨᛊᚺ \= hashlib.sha256(ᛈᚱᛟᛈᛟᛊᛖᛞ_state.encode()).ᚺᛖᚲᛊᛞᛁᚷᛖᛊᛏ()
ᚱᛖᛏᚢᚱᚾ ᚨᚲᛏᚢᚨᛚ_ᚺᚨᛊᚺ \== ᛏᚱᚢᛊᛏᛖᛞ_ᚱᛟᛟᛏ_ᚺᚨᛊᚺ

11.6 ᚠᛚᚨᛊᚲ ᚨᛈᛁ ᚱᛟᚢᛏᛖᚱ (.ᚢᚨᛁ ᛖᚾᛞᛈᛟᛁᚾᛏ)

ᛈᛃᚦᛟᚾ
“”“
ᚨᛈᛁ_router.py
ᚠᛚᚨᛊᚲ ᚨᛈᛁ ᚠᛟᚱ ᛉ ᛞᛖᚠᛖᚾᛊᛖ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᛊ ᚨᚾᛞ ᚠᚨᚢᛚᛏ ᛁᚾᛃᛖᚲᛏᛁᛟᚾ.
“”“
ᚠᚱᛟᛗ ᚠᛚᚨᛊᚲ ᛁᛗᛈᛟᚱᛏ ᚠᛚᚨᛊᚲ, ᚱᛖᚲᚹᛖᛊᛏ, ᛃᛊᛟᚾᛁᚠᛃ
ᚠᚱᛟᛗ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ_ᛊᛖᚱᚹᛁᚲᛖ ᛁᛗᛈᛟᚱᛏ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏᛊᛖᚱᚹᛁᚲᛖ
ᛁᛗᛈᛟᚱᛏ ᚠᚨᚢᛚᛏ_ᛁᚾᛃᛖᚲᛏᛁᛟᚾ

ᚨᛈᛈ \= ᚠᛚᚨᛊᚲ(__ᚾᚨᛗᛖ__)
ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ \= ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏᛊᛖᚱᚹᛁᚲᛖ()

@app.route(‘/ᚹ1/ᛁᚾᛃᛖᚲᛏ_fault.uai’, ᛗᛖᚦᛟᛞᛊ=[‘ᛈᛟᛊᛏ’])
ᛞᛖᚠ ᚺᚨᚾᛞᛚᛖ_ᚠᚨᚢᛚᛏ():
“”“ᚨᚲᚲᛖᛈᛏᛊ ᚨᛒᛊᛏᚱᚨᚲᛏ ᚠᚨᚢᛚᛏ ᛁᚾᛃᛖᚲᛏᛁᛟᚾᛊ ᚠᛟᚱ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚱᚨᛜᛖ ᛏᛖᛊᛏᛁᛜ.”“”
ᛞᚨᛏᚨ \= request.json
ᚠᚨᚢᛚᛏ \= data.get(‘ᚠᚨᚢᛚᛏ_ᛏᛃᛈᛖ’)
ᛏᚨᚱᚷᛖᛏ \= data.get(‘ᛏᚨᚱᚷᛖᛏ_ᛊᛈᛁᚠᚠᛖ_ᛁᛞ’)

\# ᛗᚨᛈ ᛁᚾᛃᛖᚲᛏᛖᛞ ᚠᚨᚢᛚᛏᛊ ᛏᛟ ᛞᛖᚠᛁᚾᛖᛞ ᛒᛟᚢᚾᛞᛖᛞ ᚱᛖᛊᛈᛟᚾᛊᛖᛊ  
ᛁᚠ ᚠᚨᚢᛚᛏ \== "ᚠᛟᚱᚷᛖᛞ\_ᛁᛞᛖᚾᛏᛁᛏᛃ":  
    containment.execute\_ᛒᛟᚢᚾᛞᛖᛞ\_ᚱᛖᛊᛈᛟᚾᛊᛖ(ᛏᚨᚱᚷᛖᛏ, "ᛞᛖᚾᛃ\_ᚱᛖᚲᚹᛖᛊᛏ")  
    ᚱᛖᛏᚢᚱᚾ ᛃᛊᛟᚾᛁᚠᛃ({"ᛊᛏᚨᛏᚢᛊ": "ᛊᚢᚲᚲᛖᛊᛊ", "ᚱᛖᛊᛈᛟᚾᛊᛖ": "ᛞᛖᚾᛃ\_ᚱᛖᚲᚹᛖᛊᛏ"})

ᛖᛚᛁᚠ ᚠᚨᚢᛚᛏ \== "ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ\_ᛒᚱᛖᚨᚲᚺ":  
    containment.execute\_ᛒᛟᚢᚾᛞᛖᛞ\_ᚱᛖᛊᛈᛟᚾᛊᛖ(ᛏᚨᚱᚷᛖᛏ, "ᛊᛖᚹᛖᚱ\_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ")  
    ᚱᛖᛏᚢᚱᚾ ᛃᛊᛟᚾᛁᚠᛃ({"ᛊᛏᚨᛏᚢᛊ": "ᛊᚢᚲᚲᛖᛊᛊ", "ᚱᛖᛊᛈᛟᚾᛊᛖ": "ᛊᛖᚹᛖᚱ\_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ"})

ᛖᛚᛁᚠ ᚠᚨᚢᛚᛏ \== "ᛖᚹᛁᛞᛖᚾᚲᛖ\_ᛈᛟᛁᛊᛟᚾᛁᛜ":  
    containment.execute\_ᛒᛟᚢᚾᛞᛖᛞ\_ᚱᛖᛊᛈᛟᚾᛊᛖ(ᛏᚨᚱᚷᛖᛏ, "ᚲᛟᛚᛚᛖᚲᛏ\_ᛗᛟᚱᛖ\_ᛖᚹᛁᛞᛖᚾᚲᛖ")  
    ᚱᛖᛏᚢᚱᚾ ᛃᛊᛟᚾᛁᚠᛃ({"ᛊᛏᚨᛏᚢᛊ": "ᛊᚢᚲᚲᛖᛊᛊ", "ᚱᛖᛊᛈᛟᚾᛊᛖ": "ᚲᛟᛚᛚᛖᚲᛏ\_ᛗᛟᚱᛖ\_ᛖᚹᛁᛞᛖᚾᚲᛖ"})

ᚱᛖᛏᚢᚱᚾ ᛃᛊᛟᚾᛁᚠᛃ({"ᛊᛏᚨᛏᚢᛊ": "ᛞᛖᚠᛖᚱᚱᛖᛞ", "ᚱᛖᛊᛈᛟᚾᛊᛖ": "ᚨᛒᛊᛏᚨᛁᚾ"})

ᛁᚠ __ᚾᚨᛗᛖ__ \== ‘__ᛗᚨᛁᚾ__‘:
app.run(ᛈᛟᚱᛏ=8443, ᛊᛊᛚ_ᚲᛟᚾᛏᛖᚲᛊᛏ=’ᚨᛞᚺᛟᚲ’)

12. ᛟᛈᛖᚱᚨᛏᛟᚱ ᚨᚾᛞ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ

ᚹᛁᛚᛖ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛖᚲᛊᛖᚲᚢᛏᛖᛊ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊᛚᛃ ᛁᚾ ᛗᛁᛚᛚᛁᛊᛖᚲᛟᚾᛞᛊ, ᛚᛟᛜ-ᛏᛖᚱᛗ ᚷᛟᚹᛖᚱᚾᚨᚾᚲᛖ ᚨᚾᛞ ᚱᛖᚹᛖᚱᛊᛁᛒᛁᛚᛁᛏᛃ ᚱᛖᛚᛃ ᛟᚾ ᚲᛟᛗᛈᚱᛖᚺᛖᚾᛊᛁᚹᛖ ᚱᛖᚹᛁᛖᚹ ᛗᛖᚲᚺᚨᚾᛁᛊᛗᛊ.

12.1 ᛈᚱᛟᚲᛖᛞᚢᚱᚨᛚ ᚲᛟᚾᚠᛁᚱᛗᚨᛏᛁᛟᚾ ᚹᛊ. ᛗᛖᚱᛁᛏᛊ ᚱᛖᚹᛁᛖᚹ

ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛊᛏᚱᛁᚲᛏᛚᛃ ᛞᛖᛚᛁᚾᛖᚨᛏᛖᛊ ᛒᛖᛏᚹᛖᛖᚾ ᚨ ᛈᚱᛟᚲᛖᛞᚢᚱᚨᛚ ᚲᛟᚾᚠᛁᚱᛗᚨᛏᛁᛟᚾ ᚨᚾᛞ ᚨ ᛗᛖᚱᛁᛏᛊ ᚱᛖᚹᛁᛖᚹ. ᚹᛖᚾ ᚨ ᚺᚢᛗᚨᚾ ᛟᛈᛖᚱᚨᛏᛟᚱ ᚲᛚᛁᚲᚲᛊ ᚨᚾ “ᚨᛈᛈᚱᛟᚹᛖ” ᛒᚢᛏᛏᛟᚾ ᛟᚾ ᚨ ᛞᚨᛊᚺᛒᛟᚨᚱᛞ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚱᛖᚲᛟᚱᛞᛊ ᚦᛁᛊ ᚨᛊ ᚨ ᛈᚱᛟᚲᛖᛞᚢᚱᚨᛚ ᛊᛏᛖᛈ. ᚺᛟᚹᛖᚹᛖᚱ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ’ᛊ ᛁᚾᚹᚨᚱᛁᚨᚾᛏᛊ ᛊᛏᚨᛏᛖ ᚦᚨᛏ ᚨ ᚱᛖᚲᛟᚱᛞᛖᛞ ᚲᛚᛁᚲᚲ ᛞᛟᛖᛊ ᚾᛟᛏ ᚨᚢᛏᛟᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛖᚲᚹᚨᛏᛖ ᛏᛟ ᚲᛟᚷᚾᛁᛏᛁᚹᛖ ᚢᚾᛞᛖᚱᛊᛏᚨᚾᛞᛁᛜ ᛟᚱ ᛚᛖᚷᚨᛚ ᚨᛈᛈᚱᛟᚹᚨᛚ. ᚨ ᛏᚱᚢᛖ ᛗᛖᚱᛁᛏᛊ ᚱᛖᚹᛁᛖᚹ ᚱᛖᚲᚹᛁᚱᛖᛊ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛃᚢᛞᚷᛗᛖᚾᛏ, ᚹᛖᚱᛖ ᚦᛖ ᛟᛈᛖᚱᚨᛏᛟᚱ ᚨᚾᚾᛟᛏᚨᛏᛖᛊ ᚦᛖ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛈᚨᚲᚲᚨᚷᛖ, ᚲᛟᚾᚠᛁᚱᛗᛊ ᚦᛖ ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ ᛁᛞᛊ, ᚨᚾᛞ ᛊᛁᚷᚾᛊ ᚦᛖ ᚱᛖᚹᛖᚱᛊᚨᛚ ᚲᛟᛗᛗᚨᚾᛞ ᚢᛊᛁᛜ ᚦᛖᛁᚱ ᚺᚨᚱᛞᚹᚨᚱᛖ ᛏᛟᚲᛖᚾ.

12.2 ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ

ᛏᛟ ᚲᛟᚢᚾᛏᛖᚱ ᚲᛟᚷᚾᛁᛏᛁᚹᛖ ᛟᚹᛖᚱᛚᛟᚨᛞ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛊᚢᛈᛈᛟᚱᛏᛊ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ. ᚨ ᛊᛖᚲᛟᚾᛞᚨᚱᛃ, ᛁᛊᛟᛚᚨᛏᛖᛞ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚨᚷᛖᚾᛏ ᛖᚹᚨᛚᚢᚨᛏᛖᛊ ᚦᛖ ᛈᚱᛁᛗᚨᚱᛃ ᛊᛃᛊᛏᛖᛗ’ᛊ ᛚᛟᚷᛁᚲ ᚨᚾᛞ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛚᛖᛞᚷᛖᚱ. ᛁᚠ ᚦᛖ ᛈᚱᛁᛗᚨᚱᛃ ᛊᛃᛊᛏᛖᛗ ᛁᛊᛟᛚᚨᛏᛖᛊ ᚨ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛒᚨᛊᛖᛞ ᛟᚾ ᚨ ᛗᛟᛞᛖᛚ_ᛞᛁᚷᛖᛊᛏ_ᛗᛁᛊᛗᚨᛏᚲᚺ, ᛒᚢᛏ ᚦᛖ ᛊᛖᚲᛟᚾᛞᚨᚱᛃ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ ᚲᚨᛚᚲᚢᛚᚨᛏᛖᛊ ᚦᚨᛏ ᚦᛖ ᛞᚱᛁᚠᛏ ᚹᚨᛊ ᚨᚾ ᚨᚱᛏᛁᚠᚨᚲᛏ ᛟᚠ ᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᚠᛚᛟᚨᛏᛁᛜ-ᛈᛟᛁᚾᛏ ᚱᛟᚢᚾᛞᛁᛜ, ᛁᛏ ᛁᛊᛊᚢᛖᛊ ᚨᚾ ᚨᛒᛊᛏᚨᛁᚾ ᛟᚱ ᚲᛟᛚᛚᛖᚲᛏ_ᛗᛟᚱᛖ_ᛖᚹᛁᛞᛖᚾᚲᛖ ᚱᛖᛈᛟᚱᛏ, ᚠᛟᚱᚲᛁᛜ ᚺᚢᛗᚨᚾ ᚨᚱᛒᛁᛏᚱᚨᛏᛁᛟᚾ.

13. ᛊᛖᚲᚢᚱᛁᛏᛃ ᛏᛖᛊᛏ ᛗᚨᛏᚱᛁᚲᛊ

ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚢᚾᛞᛖᚱᚷᛟᛖᛊ ᚱᛁᚷᛟᚱᛟᚢᛊ ᚹᚨᛚᛁᛞᚨᛏᛁᛟᚾ ᚨᚷᚨᛁᚾᛊᛏ ᛒᛟᚢᚾᛞᚨᚱᛃ ᚲᛟᚾᛞᛁᛏᛁᛟᚾᛊ ᚨᚾᛞ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᚨᛚ ᛖᛞᚷᛖ ᚲᚨᛊᛖᛊ ᚹᛁᚦᛟᚢᛏ ᛖᚲᛊᛖᚲᚢᛏᛁᛜ ᛚᛁᚹᛖ ᛗᚨᛚᚹᚨᚱᛖ.

14. ᛊᛃᚾᚦᛖᛏᛁᚲ ᛞᛖᚠᛖᚾᛊᛖ ᚱᚨᛜᛖ: ᛖᛁᚷᚺᛏ ᛊᛁᛏᛖ ᛞᛖᛗᛟᛊ

ᛏᛟ ᚹᚨᛚᛁᛞᚨᛏᛖ ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛊᚨᚠᛖᛚᛃ ᛁᚾ ᚨ ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ, ᛖᛁᚷᚺᛏ ᛊᛃᚾᚦᛖᛏᛁᚲ ᛞᛖᛗᛟᛊ ᚱᛖᛈᚱᛖᛊᛖᚾᛏ ᚦᛖ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᛒᛟᚢᚾᛞᚨᚱᛃ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᛊ.

1. ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛞᛖᚠᛖᚾᛊᛖ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᚦᛖ ᚠᛟᚱᚷᛖᛞ_ᛁᛞᛖᚾᛏᛁᛏᛃ ᚠᚨᚢᛚᛏ. ᚦᛖ ᚢᛊᛖᚱ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᛈᚨᛊᛊ ᚨ ᚲᛚᛟᚾᛖᛞ ᛃᚹᛏ-ᛊᚹᛁᛞ ᛏᛟ ᚨᚾ ᚨᛈᛁ ᛒᛟᚢᚾᛞᚨᚱᛃ. ᚦᛖ ᚨᛈᛁ ᚱᛖᚲᚹᛖᛊᛏᛊ ᚨ ᚺᚨᚱᛞᚹᚨᚱᛖ ᛏᛈᛗ ᚲᚹᛟᛏᛖ, ᚠᚨᛁᛚᛊ ᛏᛟ ᛗᚨᛏᚲᚺ ᚦᛖ ᚺᚨᚱᛞᚹᚨᚱᛖ ᚱᛟᛟᛏ, ᚨᚾᛞ ᛟᚢᛏᛈᚢᛏᛊ ᛞᛖᚾᛃ_ᚱᛖᚲᚹᛖᛊᛏ ᚠᛟᛚᛚᛟᚹᛖᛞ ᛒᛃ ᛁᛊᛟᛚᚨᛏᛖ_ᚹᛟᚱᚲᛚᛟᚨᛞ.
2. ᚨᚢᚦᛟᚱᛁᛏᛃ ᚱᛖᛈᛚᚨᛃ ᛞᛖᛏᛖᚲᛏᛁᛟᚾ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᚱᛖᛈᛚᚨᛃᛖᛞ_ᚨᚢᚦᛟᚱᛁᛏᛃ. ᚨ ᚢᛊᛖᚱ ᚲᚨᛈᛏᚢᚱᛖᛊ ᚨ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚹᚨᛚᛁᛞ ᚨᛈᛁ ᚱᛖᚲᚹᛖᛊᛏ ᚠᚱᛟᛗ ᚲᛖᛃ ᛖᛈᛟᚲᚺ 1 ᚨᚾᛞ ᚱᛖᛈᛚᚨᛃᛊ ᛁᛏ ᛞᚢᚱᛁᛜ ᚲᛖᛃ ᛖᛈᛟᚲᚺ 2. ᚦᛖ .ᚢᚨᛁ ᚱᛟᚢᛏᛖᚱ ᛞᛖᛏᛖᚲᛏᛊ ᚦᛖ ᛖᛈᛟᚲᚺ ᛗᛁᛊᛗᚨᛏᚲᚺ ᚨᚾᛞ ᛁᛊᛊᚢᛖᛊ ᚱᛖᚲᚹᛁᚱᛖ_ᚱᛖᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛁᛟᚾ.
3. ᛊᛟᚠᛏᚹᚨᚱᛖ ᛊᚢᛈᛈᛚᛃ-ᚲᚺᚨᛁᚾ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᚢᚾᛊᛁᚷᚾᛖᛞ_ᚢᛈᛞᚨᛏᛖ. ᚨ ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᚲᛁ/ᚲᛞ ᛈᛁᛈᛖᛚᛁᚾᛖ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᛈᚢᛊᚺ ᚨ ᚲᛟᚾᛏᚨᛁᚾᛖᚱ ᛁᛗᚨᚷᛖ ᚹᛁᚦᛟᚢᛏ ᚨᚾ ᛁᚾ-ᛏᛟᛏᛟ ᛊᛚᛊᚨ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ ᚱᛖᚲᛟᚱᛞ. ᚦᛖ ᚲᚢᛒᛖᚱᚾᛖᛏᛖᛊ ᚨᛞᛗᛁᛊᛊᛁᛟᚾ ᚲᛟᚾᛏᚱᛟᛚᛚᛖᚱ ᚺᚨᛚᛏᛊ ᚦᛖ ᛈᛟᛞ ᚲᚱᛖᚨᛏᛁᛟᚾ ᚨᚾᛞ ᛁᛊᛊᚢᛖᛊ ᚠᚱᛖᛖᛉᛖ_ᚱᛖᛚᛖᚨᛊᛖ_ᚲᚺᚨᚾᚾᛖᛚ.
4. ᛗᛟᛞᛖᛚ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᚨᚾᛞ ᛞᚱᛁᚠᛏ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᛗᛟᛞᛖᛚ_ᛞᛁᚷᛖᛊᛏ_ᛗᛁᛊᛗᚨᛏᚲᚺ. ᚨ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚨᛁ ᛗᛟᛞᛖᛚ’ᛊ ᚹᛖᛁᚷᚺᛏ ᚠᛁᛚᛖ ᛁᛊ ᛞᛖᛚᛁᛒᛖᚱᚨᛏᛖᛚᛃ ᚨᛚᛏᛖᚱᛖᛞ ᛁᚾ ᛗᛖᛗᛟᚱᛃ ᚹᛁᚨ ᚨ ᚺᛖᚲᛊ ᛖᛞᛁᛏᛟᚱ ᛊᚲᚱᛁᛈᛏ. ᚦᛖ ᚱᚢᚾᛏᛁᛗᛖ ᚹᚨᛏᚲᚺᛖᚱ ᚲᚨᛚᚲᚢᛚᚨᛏᛖᛊ ᚦᛖ ᛞᚱᛁᚠᛏ, ᚲᛟᛗᛈᚨᚱᛖᛊ ᛁᛏ ᛏᛟ ᚦᛖ ᚲᛃᚲᛚᛟᚾᛖᛞᚲᛊ ᚨᛁ-ᛒᛟᛗ, ᚨᚾᛞ ᛏᚱᛁᚷᚷᛖᚱᛊ ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ.
5. ᛖᚹᛁᛞᛖᚾᚲᛖ ᛈᛟᛁᛊᛟᚾᛁᛜ ᚨᚾᛞ ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᛖᚹᛁᛞᛖᚾᚲᛖ_ᛈᛟᛁᛊᛟᚾᛁᛜ. 100 ᛁᛞᛖᚾᛏᛁᚲᚨᛚ ᚠᚨᚢᛚᛏ ᚨᛚᛖᚱᛏᛊ ᚨᚱᛖ ᛊᛖᚾᛏ ᚹᛁᚦ ᛗᚨᚾᛁᛈᚢᛚᚨᛏᛖᛞ ᚺᛖᚨᛞᛖᚱᛊ ᛏᛟ ᛁᚾᛞᚢᚲᛖ ᚨᛚᛖᚱᛏ ᚠᚨᛏᛁᚷᚢᛖ. ᚦᛖ ᛖᚹᛁᛞᛖᚾᚲᛖ ᛊᛖᚱᚹᛁᚲᛖ ᚢᛊᛖᛊ ᚦᛖ ᚲᛟᚱᚱᛖᛚᚨᛏᛁᛟᚾ_ᛁᛞ ᚨᚾᛞ ᛏᚱᚨᚾᛊᚠᛟᚱᛗᚨᛏᛁᛟᚾ_ᚺᛁᛊᛏᛟᚱᛃ ᛏᛟ ᛞᛖᛞᚢᛈᛚᛁᚲᚨᛏᛖ ᚦᛖ ᚨᛚᛖᚱᛏᛊ, ᛟᚢᛏᛈᚢᛏᛏᛁᛜ ᚲᛟᛚᛚᛖᚲᛏ_ᛗᛟᚱᛖ_ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᚾᛊᛏᛖᚨᛞ ᛟᚠ ᛁᛊᛟᛚᚨᛏᛁᛜ ᚦᛖ ᚾᛖᛏᚹᛟᚱᚲ.
6. ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ ᛒᚱᛖᚨᚲᚺ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ_ᛒᚱᛖᚨᚲᚺ. ᚨ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᚾ ᚾᚨᛗᛖᛊᛈᚨᚲᛖ ᚨ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᚨᚲᚲᛖᛊᛊ ᚨᚾ ᚢᚾᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᛞᚨᛏᚨᛒᚨᛊᛖ ᛁᚾ ᚾᚨᛗᛖᛊᛈᚨᚲᛖ ᛒ. ᚾᛖᛏᚹᛟᚱᚲ ᛈᛟᛚᛁᚲᛁᛖᛊ ᛞᛖᛏᛖᚲᛏ ᚦᛖ ᚢᚾᚨᚢᚦᛟᚱᛁᛉᛖᛞ ᛊᛈᛁᚠᚠᛖ ᛁᛞ ᚨᚾᛞ ᛏᚱᛁᚷᚷᛖᚱ ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ, ᚱᛖᛊᛏᚱᛁᚲᛏᛁᛜ ᚦᛖ ᛈᛟᛞ ᛏᛟ ᚨᛚᛚᛟᚹ_ᛗᛖᛏᚱᛁᚲᛊ_ᛟᚾᛚᛃ ᚱᛖᚨᚲᚺᚨᛒᛁᛚᛁᛏᛃ.
7. ᚲᛖᛃ-ᛖᛈᛟᚲᚺ ᚱᛖᚲᛟᚹᛖᚱᛃ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᚨ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᛊᛁᚷᚾᛖᚱ. 3 ᛟᚠ 5 ᚲᚹᛟᚱᚢᛗ ᛗᛖᛗᛒᛖᚱᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᚹᛟᛏᛖ ᛏᛟ ᛒᚨᚾ ᚦᛖ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚲᛖᛃ, ᚷᛖᚾᛖᚱᚨᛏᛁᛜ ᚦᛖ ᚾᛖᚲᛊᛏ ᛖᛈᛟᚲᚺ, ᚢᛈᛞᚨᛏᛁᛜ ᚦᛖ ᚱᛖᚹᛟᚲᚨᛏᛁᛟᚾ ᛚᛁᛊᛏ, ᚨᚾᛞ ᛟᚢᛏᛈᚢᛏᛏᛁᛜ ᚱᛖᚲᛖᛃ.
8. ᚨᛏᛏᛖᛊᛏᛖᛞ ᚱᛖᚲᛟᚾᛊᛏᛁᛏᚢᛏᛁᛟᚾ ᛞᛖᛗᛟ: ᛊᛁᛗᚢᛚᚨᛏᛖᛊ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ_ᚱᛖᚲᛟᚹᛖᚱᛃ_ᛒᚨᛊᛖᛚᛁᚾᛖ. ᚨᚠᛏᛖᚱ ᚨ ᛊᛖᚹᛖᚱᛖ ᛊᛁᛗᚢᛚᚨᛏᛖᛞ ᚠᚨᚢᛚᛏ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚨᛏᛏᛖᛗᛈᛏᛊ ᚱᛖᚲᛟᚹᛖᚱᛃ. ᛁᛏ ᚲᚺᛖᚲᚲᛊ ᚦᛖ ᛒᚨᚲᚲᚢᛈ ᛒᚨᛊᛖᛚᛁᚾᛖ ᚨᚷᚨᛁᚾᛊᛏ ᚦᛖ ᛁᛗᛗᚢᛏᚨᛒᛚᛖ ᛏᚱᚢᛊᛏᛖᛞ ᚱᛟᛟᛏ. ᚢᛈᛟᚾ ᛊᚢᚲᚲᛖᛊᛊ, ᛁᛏ ᛟᚢᛏᛈᚢᛏᛊ ᚱᛖᛊᛏᛟᚱᛖ_ᚨᛏᛏᛖᛊᛏᛖᛞ_ᛒᚨᛊᛖᛚᛁᚾᛖ ᚨᚾᛞ ᚢᚾᛊᛖᚨᛚᛊ ᚦᛖ ᛞᚨᛏᚨ.

15. ᚹᛁᛊᚢᚨᛚᛁᛉᚨᛏᛁᛟᚾ, ᚨᚲᚲᛖᛊᛊᛁᛒᛁᛚᛁᛏᛃ, ᚨᚾᛞ ᛈᛖᚱᚠᛟᚱᛗᚨᚾᚲᛖ ᛈᛚᚨᚾᛊ

15.1 ᚹᛁᛊᚢᚨᛚᛁᛉᚨᛏᛁᛟᚾ ᛚᚨᛃᛖᚱᛊ

ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚷᛖᚾᛖᚱᚨᛏᛖᛊ ᛞᛁᛊᚲᚱᛖᛏᛖ ᚹᛁᛊᚢᚨᛚ ᚱᛖᛈᚱᛖᛊᛖᚾᛏᚨᛏᛁᛟᚾᛊ ᛏᛟ ᚨᛊᛊᛁᛊᛏ ᚺᚢᛗᚨᚾ ᚱᛖᚹᛁᛖᚹ:

• ᛏᚱᚢᛊᛏ ᛏᛟᛈᛟᛚᛟᚷᛃ: ᛞᛁᚱᛖᚲᛏᛖᛞ ᚨᚲᛃᚲᛚᛁᚲ ᚷᚱᚨᚠᛊ (ᛞᚨᚷᛊ) ᚱᛖᛈᚱᛖᛊᛖᚾᛏᛁᛜ ᛊᛈᛁᚱᛖ ᚠᛖᛞᛖᚱᚨᛏᛁᛟᚾ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ ᚨᚾᛞ ᚨᚲᛏᛁᚹᛖ ᛗᛏᛚᛊ ᛈᚨᚦᛊ.
• ᚲᛖᛃ-ᛖᛈᛟᚲᚺ ᛗᚨᛈ: ᛏᛁᛗᛖᛚᛁᚾᛖ ᚹᛁᛊᚢᚨᛚᛁᛉᚨᛏᛁᛟᚾ ᛊᚺᛟᚹᛁᛜ ᛖᛈᛟᚲᚺ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ, ᚨᚲᛏᛁᚹᛖ ᚦᚱᛖᛊᚺᛟᛚᛞ ᛊᛁᚷᚾᛖᚱᛊ, ᚨᚾᛞ ᚱᛖᚹᛟᚲᛖᛞ ᚲᛖᛃᛊ ᛟᚹᛖᚱ ᛏᛁᛗᛖ.
• ᛖᚹᛁᛞᛖᚾᚲᛖ ᚷᚱᚨᚠ: ᚾᛟᛞᛖ-ᛚᛁᚾᚲ ᛞᛁᚨᚷᚱᚨᛗᛊ ᛊᚺᛟᚹᛁᛜ ᚦᛖ ᚲᚺᚨᛁᚾ ᛟᚠ ᚲᚢᛊᛏᛟᛞᛃ ᛟᚠ ᛚᛟᚷ ᚨᚱᛏᛁᚠᚨᚲᛏᛊ ᚦᚱᛟᚢᚷᚺ ᚹᚨᚱᛁᛟᚢᛊ ᛏᚱᚨᚾᛊᚠᛟᚱᛗᚨᛏᛁᛟᚾᛊ.
• ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛒᛟᚢᚾᛞᚨᚱᛃ: ᚱᛖᚨᛚ-ᛏᛁᛗᛖ ᛞᚨᛊᚺᛒᛟᚨᚱᛞᛊ ᚺᛁᚷᚺᛚᛁᚷᚺᛏᛁᛜ ᛁᛊᛟᛚᚨᛏᛖᛞ ᛟᚱ ᛊᛖᚹᛖᚱᛖᛞ ᚾᚨᛗᛖᛊᛈᚨᚲᛖᛊ ᛁᚾ ᚺᛁᚷᚺ-ᚲᛟᚾᛏᚱᚨᛊᛏ ᚱᛖᛞ, ᚹᛁᚦ ᚾᛟᚱᛗᚨᛚ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᛊ ᛁᚾ ᚷᚱᛖᛖᚾ.

15.2 ᚨᚲᚲᛖᛊᛊᛁᛒᛁᛚᛁᛏᛃ ᛈᛚᚨᚾ

ᚨᛚᛚ ᛞᚨᛊᚺᛒᛟᚨᚱᛞᛊ ᚨᚾᛞ ᛈᚱᛟᛟᚠ ᛁᚾᛊᛈᛖᚲᛏᛟᚱᛊ ᛗᚢᛊᛏ ᚨᛞᚺᛖᚱᛖ ᛏᛟ ᚹᚲᚨᚷ 2.1 ᚨᚨ ᛊᛏᚨᚾᛞᚨᚱᛞᛊ. ᛊᚲᚱᛖᛖᚾ ᚱᛖᚨᛞᛖᚱᛊ ᛗᚢᛊᛏ ᛒᛖ ᚨᛒᛚᛖ ᛏᛟ ᛈᚨᚱᛊᛖ ᛊᛏᚱᚢᚲᛏᚢᚱᚨᛚ ᛏᚨᛒᛚᛖᛊ ᚨᚾᛞ ᚠᛟᚱᛗ ᛊᛏᚨᛏᛖᛊ ᚨᚲᚲᚢᚱᚨᛏᛖᛚᛃ. ᚲᛟᛚᛟᚱ ᛁᛊ ᚾᛖᚹᛖᚱ ᚢᛊᛖᛞ ᚨᛊ ᚦᛖ ᛊᛟᛚᛖ ᛗᛖᚦᛟᛞ ᛟᚠ ᚲᛟᚾᚹᛖᛃᛁᛜ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᚨᛚ ᛊᛏᚨᛏᚢᛊ; ᚨᚾ “ᛁᛊᛟᛚᚨᛏᛖᛞ” ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ ᛁᚾᚲᛚᚢᛞᛖᛊ ᚨ ᛞᛁᛊᛏᛁᚾᚲᛏ ᚷᛖᛟᛗᛖᛏᚱᛁᚲ ᛁᚲᛟᚾ ᚨᚾᛞ ᚨ ᛏᛖᚲᛊᛏ ᛚᚨᛒᛖᛚ ᚨᛚᛟᛜᛊᛁᛞᛖ ᚦᛖ ᚲᛟᛚᛟᚱ ᛊᚺᛁᚠᛏ, ᛖᚾᛊᚢᚱᛁᛜ ᚢᛊᚨᛒᛁᛚᛁᛏᛃ ᚠᛟᚱ ᚹᛁᛊᚢᚨᛚᛚᛃ ᛁᛗᛈᚨᛁᚱᛖᛞ ᛟᛈᛖᚱᚨᛏᛟᚱᛊ.

15.3 ᛈᛖᚱᚠᛟᚱᛗᚨᚾᚲᛖ ᚨᚾᛞ ᛊᚲᚨᛚᛖ ᛈᛚᚨᚾ

• ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ ᚨᛈᛈᛖᚾᛞᛊ: ᛟᛈᛏᛁᛗᛁᛉᛖᛞ ᛏᛟ ᛊᚢᛒ-ᛗᛁᛚᛚᛁᛊᛖᚲᛟᚾᛞ ᛚᚨᛏᛖᚾᚲᛃ ᚢᛊᛁᛜ ᛁᚾ-ᛗᛖᛗᛟᚱᛃ ᚲᚨᚲᚺᛁᛜ ᛒᛖᚠᛟᚱᛖ ᛒᚨᛏᚲᚺ ᚠᛚᚢᛊᚺᛁᛜ ᛏᛟ ᛈᛖᚱᛊᛁᛊᛏᛖᚾᛏ ᛊᛏᛟᚱᚨᚷᛖ, ᛈᚱᛖᚹᛖᚾᛏᛁᛜ ᛞᛁᛊᚲ ᛁ/ᛟ ᛒᛟᛏᛏᛚᛖᚾᛖᚲᚲᛊ.
• ᛊᚹᛁᛞ ᚱᛟᛏᚨᛏᛁᛟᚾ: ᛖᚲᛊᛈᛁᚱᚨᛏᛁᛟᚾ ᛏᛁᛗᛖᚱᛊ ᚨᚱᛖ ᛊᛏᚨᚷᚷᛖᚱᛖᛞ ᚱᚨᚾᛞᛟᛗᛚᛃ ᚨᚲᚱᛟᛊᛊ ᚦᛖ ᚠᛚᛖᛖᛏ (ᛃᛁᛏᛏᛖᚱᛁᛜ) ᛏᛟ ᛈᚱᛖᚹᛖᚾᛏ ᚦᚢᚾᛞᛖᚱᛁᛜ ᚺᛖᚱᛞ ᛈᚱᛟᛒᛚᛖᛗᛊ ᛟᚾ ᚦᛖ ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ ᛞᚢᚱᛁᛜ ᛗᚨᛊᛊ ᚱᛟᛏᚨᛏᛁᛟᚾᛊ.
• ᚨᛈᛁ ᚱᚨᛏᛖ ᛚᛁᛗᛁᛏᛁᛜ: ᚠᛚᚨᛊᚲ .ᚢᚨᛁ ᛖᚾᛞᛈᛟᛁᚾᛏᛊ ᚨᚱᛖ ᛈᚱᛟᛏᛖᚲᛏᛖᛞ ᛒᛃ ᛏᛟᚲᛖᚾ-ᛒᚢᚲᚲᛖᛏ ᚨᛚᚷᛟᚱᛁᚦᛗᛊ, ᚷᚢᚨᚱᚨᚾᛏᛖᛖᛁᛜ ᛊᛖᚱᚹᛁᚲᛖ ᚨᚹᚨᛁᛚᚨᛒᛁᛚᛁᛏᛃ ᛖᚹᛖᚾ ᛞᚢᚱᛁᛜ ᛊᛃᚾᚦᛖᛏᛁᚲ ᚨᛈᛁ ᚠᚢᛉᛉᛁᛜ ᛟᚱ ᚠᛚᛟᛟᛞᛁᛜ ᚨᛏᛏᚨᚲᚲᛊ.
• ᛈᚱᛟᛞᚢᚲᛏᛁᛟᚾ ᛞᛖᛈᛚᛟᛃᛗᛖᚾᛏ: ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱᛊ ᛟᛈᛖᚱᚨᛏᛖ ᛁᚾ ᚺᛁᚷᚺᛚᛃ ᚨᚹᚨᛁᛚᚨᛒᛚᛖ ᚲᛚᚢᛊᛏᛖᚱᛊ ᚹᛁᚦ ᛞᛁᛊᛏᛁᚾᚲᛏ ᛏᛈᛗᛊ—ᚨᚾ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚲᚾᛟᚹᚾ ᚨᛊ “ᛒᛟᛏᛏᛟᛗ ᛏᚢᚱᛏᛚᛖ ᚺᚨ”9. ᚦᛖᛃ ᛊᚺᚨᚱᛖ ᚾᛟ ᛞᚨᛏᚨᛒᚨᛊᛖ ᛟᚱ ᚱᛟᛟᛏ ᛊᛁᚷᚾᛁᛜ ᚲᛖᛃᛊ, ᛈᚱᛖᚹᛖᚾᛏᛁᛜ ᚨ ᛏᛟᛏᚨᛚ ᚲᛟᛚᛚᚨᛈᛊᛖ ᛁᚠ ᛟᚾᛖ ᚾᛟᛞᛖ ᚠᛃᛊᛁᚲᚨᛚᛚᛃ ᚠᚨᛁᛚᛊ.

16. ᛊᛁᛏᛖ-ᚱᛖᚨᛞᛃ ᚲᛟᚾᛏᛖᚾᛏ (2,500 ᚹᛟᚱᛞᛊ)

(ᚦᛖ ᚠᛟᛚᛚᛟᚹᛁᛜ ᛊᛖᚲᛏᛁᛟᚾ ᛈᚱᛟᚹᛁᛞᛖᛊ ᛈᚢᛒᛚᛁᚲ-ᚠᚨᚲᛁᛜ, ᛖᛞᚢᚲᚨᛏᛁᛟᚾᚨᛚ, ᛊᛁᛏᛖ-ᚱᛖᚨᛞᛃ ᛏᛖᚲᚺᚾᛁᚲᚨᛚ ᚲᛟᚾᛏᛖᚾᛏ ᛊᚢᛁᛏᚨᛒᛚᛖ ᚠᛟᚱ ᛈᚢᛒᛚᛁᚲᚨᛏᛁᛟᚾ ᛟᚾ ᛉ’ᛊ ᛞᛟᚲᚢᛗᛖᚾᛏᚨᛏᛁᛟᚾ ᛈᛟᚱᛏᚨᛚᛊ ᚢᚾᛞᛖᚱ ᚦᛖ ᚱᛖᚲᛟᛗᛗᛖᚾᛞᛖᛞ ᛈᚨᚦ /ᛞᛟᚲᛊ/ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ/ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ-ᛞᛖᚠᛖᚾᛊᛖ-ᚹ1. ᛁᛏ ᛞᛖᛏᚨᛁᛚᛊ ᚦᛖ ᚠᛁᛚᛟᛊᛟᚠᛃ, ᛁᛗᛈᛚᛖᛗᛖᚾᛏᚨᛏᛁᛟᚾ, ᚨᚾᛞ ᚷᚢᚨᚱᚨᚾᛏᛖᛖᛊ ᛟᚠ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚠᛟᚱ ᛞᛖᚹᛖᛚᛟᛈᛖᚱᛊ, ᛖᛜᛁᚾᛖᛖᚱᛊ, ᚨᚾᛞ ᛊᛏᚨᚲᛖᚺᛟᛚᛞᛖᚱᛊ.)

ᚹᛖᛚᚲᛟᛗᛖ ᛏᛟ ᚦᛖ ᛉ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚲᛃᛒᛖᚱ-ᚠᛃᛊᛁᚲᚨᛚ ᛞᛖᚠᛖᚾᛊᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ

ᛁᚾ ᚨᚾ ᛖᚱᚨ ᚹᛖᚱᛖ ᛞᛁᚷᛁᛏᚨᛚ ᛖᚲᛟᛊᛃᛊᛏᛖᛗᛊ ᛞᛁᚲᛏᚨᛏᛖ ᚦᛖ ᛈᚨᚲᛖ ᛟᚠ ᚷᛚᛟᛒᚨᛚ ᛁᚾᚠᚱᚨᛊᛏᚱᚢᚲᛏᚢᚱᛖ, ᛏᚱᚨᛞᛁᛏᛁᛟᚾᚨᛚ ᛊᛖᚲᚢᚱᛁᛏᛃ ᛈᛖᚱᛁᛗᛖᛏᛖᚱᛊ ᚺᚨᚹᛖ ᛖᚹᚨᛈᛟᚱᚨᛏᛖᛞ. ᚦᛖ ᛗᛟᛞᛖᚱᚾ ᚦᚱᛖᚨᛏ ᛚᚨᚾᛞᛊᚲᚨᛈᛖ ᚾᛟ ᛚᛟᛜᛖᚱ ᚲᛟᚾᛊᛁᛊᛏᛊ ᛗᛖᚱᛖᛚᛃ ᛟᚠ ᛖᚲᛊᛏᛖᚱᚾᚨᛚ ᚨᚲᛏᛟᚱᛊ ᚨᛏᛏᛖᛗᛈᛏᛁᛜ ᛏᛟ ᛒᚱᛖᚨᚲᚺ ᚠᛁᚱᛖᚹᚨᛚᛚᛊ ᛒᛃ ᚷᚢᛖᛊᛊᛁᛜ ᛈᚨᛊᛊᚹᛟᚱᛞᛊ; ᛁᛏ ᛁᛊ ᛞᛖᚠᛁᚾᛖᛞ ᛒᛃ ᛊᛟᚠᛁᛊᛏᛁᚲᚨᛏᛖᛞ, ᚾᛟᚾ-ᚲᛁᚾᛖᛏᛁᚲ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᛖᛊ ᚲᚨᛈᚨᛒᛚᛖ ᛟᚠ ᛊᚢᛒᚹᛖᚱᛏᛁᛜ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ, ᛗᚨᚾᛁᛈᚢᛚᚨᛏᛁᛜ ᚲᛟᛗᛈᛚᛖᚲᛊ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾᛊ, ᚨᚾᛞ ᚠᛟᚱᚷᛁᛜ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛖᚹᛁᛞᛖᚾᚲᛖ ᚠᚱᛟᛗ ᚹᛁᚦᛁᚾ ᚦᛖ ᛈᛖᚱᛁᛗᛖᛏᛖᚱ. ᚨᛏ ᛉ, ᚹᛖ ᚱᛖᚲᛟᚷᚾᛁᛉᛖᛞ ᚦᚨᛏ ᚺᚢᛗᚨᚾ-ᛊᛈᛖᛖᛞ ᚱᛖᛊᛈᛟᚾᛊᛖ ᛁᛊ ᚠᚢᚾᛞᚨᛗᛖᚾᛏᚨᛚᛚᛃ ᛁᚾᚨᛞᛖᚲᚹᚨᛏᛖ ᚨᚷᚨᛁᚾᛊᛏ ᛗᚨᚲᚺᛁᚾᛖ-ᛊᛈᛖᛖᛞ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ. ᚹᛖ ᚾᛖᛖᛞᛖᛞ ᚨ ᛈᚨᚱᚨᛞᛁᚷᛗ ᛊᚺᛁᚠᛏ.
ᚹᛖ ᚨᚱᛖ ᛈᚱᛟᚢᛞ ᛏᛟ ᛁᚾᛏᚱᛟᛞᚢᚲᛖ ᚦᛖ ᛉ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚲᛃᛒᛖᚱ-ᚠᛃᛊᛁᚲᚨᛚ ᛞᛖᚠᛖᚾᛊᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ. ᚦᛁᛊ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᛊ ᚾᛟᛏ ᚨᚾ ᛟᚠᚠ-ᚦᛖ-ᛊᚺᛖᛚᚠ ᛈᚱᛟᛞᚢᚲᛏ; ᛁᛏ ᛁᛊ ᚨ ᚠᚢᚾᛞᚨᛗᛖᚾᛏᚨᛚ ᚱᛖ-ᛖᛜᛁᚾᛖᛖᚱᛁᛜ ᛟᚠ ᚺᛟᚹ ᛏᚱᚢᛊᛏ ᛁᛊ ᛖᛊᛏᚨᛒᛚᛁᛊᚺᛖᛞ, ᚹᛖᚱᛁᚠᛁᛖᛞ, ᚨᚾᛞ ᛖᚾᚠᛟᚱᚲᛖᛞ ᚨᚲᚱᛟᛊᛊ ᛟᚢᚱ ᛞᛁᛊᛏᚱᛁᛒᚢᛏᛖᛞ ᛊᛃᛊᛏᛖᛗᛊ. ᛒᛃ ᚨᚾᚲᚺᛟᚱᛁᛜ ᛏᚱᚢᛊᛏ ᛁᚾ ᚺᚨᚱᛞᚹᚨᚱᛖ, ᛗᚨᚾᚨᚷᛁᛜ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ ᛞᛃᚾᚨᛗᛁᚲᚨᛚᛚᛃ, ᚨᚾᛞ ᛖᛗᛈᛟᚹᛖᚱᛁᛜ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛏᛟ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊᛚᛃ ᚲᛟᚾᛏᚨᛁᚾ ᚠᚨᚢᛚᛏᛊ ᛁᚾ ᛗᛁᛚᛚᛁᛊᛖᚲᛟᚾᛞᛊ, ᚹᛖ ᚺᚨᚹᛖ ᛒᚢᛁᛚᛏ ᚨ ᚱᛖᛊᛁᛚᛁᛖᚾᛏ, ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ-ᚨᚹᚨᚱᛖ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ.

ᚦᛖ ᚠᛁᛚᛟᛊᛟᚠᛃ ᛟᚠ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛞᛖᛏᛖᚱᛗᛁᚾᛁᛊᛗ

ᚦᛖ ᚲᛟᚱᛖ ᚠᛁᛚᛟᛊᛟᚠᛃ ᚢᚾᛞᛖᚱᛚᛃᛁᛜ ᛟᚢᚱ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᛊ “ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛞᛖᛏᛖᚱᛗᛁᚾᛁᛊᛗ.” ᛁᚾ ᛏᚱᚨᛞᛁᛏᛁᛟᚾᚨᛚ ᚲᛟᛗᛈᚢᛏᛁᛜ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏᛊ, ᛊᛖᚲᚢᚱᛁᛏᛃ ᛞᛖᚲᛁᛊᛁᛟᚾᛊ ᚨᚱᛖ ᛟᚠᛏᛖᚾ ᛒᚨᛊᛖᛞ ᛟᚾ ᚺᛖᚢᚱᛁᛊᛏᛁᚲᛊ, ᛒᛖᚺᚨᚹᛁᛟᚱᚨᛚ ᚨᚾᛟᛗᚨᛚᛁᛖᛊ, ᛟᚱ ᛁᛈ ᚨᛞᛞᚱᛖᛊᛊ ᚱᛖᛈᚢᛏᚨᛏᛁᛟᚾᛊ. ᚨ ᛊᛃᛊᛏᛖᛗ ᛗᛁᚷᚺᛏ ᚨᛊᚲ, “ᛞᛟᛖᛊ ᚦᛁᛊ ᛁᛈ ᚨᛞᛞᚱᛖᛊᛊ ᛚᛟᛟᚲ ᛊᚢᛊᛈᛁᚲᛁᛟᚢᛊ?” ᛟᚱ “ᛁᛊ ᚦᛁᛊ ᚢᛊᛖᚱ ᛞᛟᚹᚾᛚᛟᚨᛞᛁᛜ ᛏᛟᛟ ᛗᚨᚾᛃ ᚠᛁᛚᛖᛊ?” ᚦᛖᛊᛖ ᚠᚨᚲᛏᛟᚱᛊ ᚨᚱᛖ ᚺᛁᚷᚺᛚᛃ ᛗᚢᛏᚨᛒᛚᛖ, ᛊᚢᛒᛃᛖᚲᛏᛁᚹᛖ, ᚨᚾᛞ ᛈᚱᛟᚾᛖ ᛏᛟ ᛗᚨᛊᛊᛁᚹᛖ ᚠᚨᛚᛊᛖ ᛈᛟᛊᛁᛏᛁᚹᛖᛊ ᛟᚱ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᚨᛚ ᛖᚹᚨᛊᛁᛟᚾ.
ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛞᛖᛏᛖᚱᛗᛁᚾᛁᛊᛗ ᚱᛖᛗᛟᚹᛖᛊ ᚦᛁᛊ ᚨᛗᛒᛁᚷᚢᛁᛏᛃ ᛖᚾᛏᛁᚱᛖᛚᛃ. ᚨᚾ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛖᛁᚦᛖᚱ ᛈᛟᛊᛊᛖᛊᛊᛖᛊ ᚦᛖ ᛈᚱᛁᚹᚨᛏᛖ ᚲᛖᛃ ᚲᛟᚱᚱᛖᛊᛈᛟᚾᛞᛁᛜ ᛏᛟ ᛁᛏᛊ ᚺᚨᚱᛞᚹᚨᚱᛖ-ᛒᛟᚢᚾᛞ ᚲᛖᚱᛏᛁᚠᛁᚲᚨᛏᛖ, ᛟᚱ ᛁᛏ ᛞᛟᛖᛊ ᚾᛟᛏ. ᚨ ᛊᛟᚠᛏᚹᚨᚱᛖ ᚨᚱᛏᛁᚠᚨᚲᛏ ᛖᛁᚦᛖᚱ ᛈᛖᚱᚠᛖᚲᛏᛚᛃ ᛗᚨᛏᚲᚺᛖᛊ ᚦᛖ ᛊᚺᚨ-256 ᛞᛁᚷᛖᛊᛏ ᚱᛖᚲᛟᚱᛞᛖᛞ ᛁᚾ ᛁᛏᛊ ᛊᛖᚲᚢᚱᛖ ᛒᚢᛁᛚᛞ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ, ᛟᚱ ᛁᛏ ᛞᛟᛖᛊ ᚾᛟᛏ. ᚨᚾ ᛖᚹᛖᚾᛏ ᛚᛟᚷ ᛖᛁᚦᛖᚱ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚱᛖᛊᛟᛚᚹᛖᛊ ᛏᛟ ᚦᛖ ᛈᚢᛒᛚᛁᚲ ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ ᚱᛟᛟᛏ ᚺᚨᛊᚺ, ᛟᚱ ᛁᛏ ᛞᛟᛖᛊ ᚾᛟᛏ.
ᛒᛃ ᛞᛖᛗᚨᚾᛞᛁᛜ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚ ᛈᚱᛟᛟᚠ ᚠᛟᚱ ᛖᚹᛖᚱᛃ ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛖᛚᛁᛗᛁᚾᚨᛏᛖᛊ ᚦᛖ ᚲᛟᚾᚲᛖᛈᛏ ᛟᚠ ᛁᛗᛈᛚᛁᚲᛁᛏ ᛏᚱᚢᛊᛏ. ᚹᛖ ᛞᛟ ᚾᛟᛏ ᛏᚱᚢᛊᛏ ᛃᛟᚢ ᛒᛖᚲᚨᚢᛊᛖ ᛃᛟᚢ ᚨᚱᛖ ᛁᚾᛊᛁᛞᛖ ᚦᛖ ᚾᛖᛏᚹᛟᚱᚲ. ᚹᛖ ᛞᛟ ᚾᛟᛏ ᛏᚱᚢᛊᛏ ᛃᛟᚢ ᛒᛖᚲᚨᚢᛊᛖ ᛃᛟᚢ ᚺᚨᚹᛖ ᚨ ᛈᚨᛊᛊᚹᛟᚱᛞ. ᚹᛖ ᛏᚱᚢᛊᛏ ᚦᛖ ᛁᚾᛏᛖᚱᚨᚲᛏᛁᛟᚾ ᛟᚾᛚᛃ ᛒᛖᚲᚨᚢᛊᛖ ᛁᛏ ᚺᚨᛊ ᛒᛖᛖᚾ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛈᚱᛟᚹᛖᚾ ᚨᛏ ᚦᛖ ᛖᚲᛊᚨᚲᛏ ᛗᛁᛚᛚᛁᛊᛖᚲᛟᚾᛞ ᛟᚠ ᛖᚲᛊᛖᚲᚢᛏᛁᛟᚾ. ᚦᛁᛊ ᛁᛊ ᚦᛖ ᛏᚱᚢᛖ ᛞᛖᚠᛁᚾᛁᛏᛁᛟᚾ ᛟᚠ ᛉᛖᚱᛟ ᛏᚱᚢᛊᛏ, ᛒᚱᛟᚢᚷᚺᛏ ᛏᛟ ᛁᛏᛊ ᛚᛟᚷᛁᚲᚨᛚ, ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚ ᚲᛟᚾᚲᛚᚢᛊᛁᛟᚾ.

ᛈᛁᛚᛚᚨᚱ 1: ᛉᛖᚱᛟ-ᛏᚱᚢᛊᛏ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ

ᚨᛏ ᚦᛖ ᚠᛟᚢᚾᛞᚨᛏᛁᛟᚾ ᛟᚠ ᛟᚢᚱ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᛊ ᚦᛖ ᚲᛟᚾᚲᛖᛈᛏ ᛟᚠ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ. ᛗᛟᛞᛖᚱᚾ ᛁᚾᚠᚱᚨᛊᛏᚱᚢᚲᛏᚢᚱᛖ ᛁᛊ ᚺᛖᚨᚹᛁᛚᛃ ᚨᚢᛏᛟᛗᚨᛏᛖᛞ; ᛗᚨᚲᚺᛁᚾᛖᛊ ᛏᚨᛚᚲ ᛏᛟ ᛗᚨᚲᚺᛁᚾᛖᛊ ᚠᚨᚱ ᛗᛟᚱᛖ ᚠᚱᛖᚲᚹᛖᚾᛏᛚᛃ ᚦᚨᚾ ᚺᚢᛗᚨᚾᛊ ᛏᚨᛚᚲ ᛏᛟ ᛗᚨᚲᚺᛁᚾᛖᛊ. ᚦᛖᚱᛖᚠᛟᚱᛖ, ᚹᛖ ᛞᛟ ᚾᛟᛏ ᛃᚢᛊᛏ ᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛖ ᚢᛊᛖᚱᛊ—ᚹᛖ ᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛖ ᚦᛖ ᛊᛈᛖᚲᛁᚠᛁᚲ, ᚱᚢᚾᚾᛁᛜ ᛁᚾᛊᛏᚨᚾᚲᛖᛊ ᛟᚠ ᚲᛟᛞᛖ. ᛏᛟ ᚨᚲᚺᛁᛖᚹᛖ ᚦᛁᛊ, ᚹᛖ ᚺᚨᚹᛖ ᛞᛖᛖᛈᛚᛃ ᛁᚾᛏᛖᚷᚱᚨᛏᛖᛞ ᛊᛈᛁᚠᚠᛖ (ᛊᛖᚲᚢᚱᛖ ᛈᚱᛟᛞᚢᚲᛏᛁᛟᚾ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ ᚠᛟᚱ ᛖᚹᛖᚱᛃᛟᚾᛖ) ᚨᚾᛞ ᛊᛈᛁᚱᛖ (ᚦᛖ ᛊᛈᛁᚠᚠᛖ ᚱᚢᚾᛏᛁᛗᛖ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ).
ᚹᛖᚾ ᚨ ᚹᛟᚱᚲᛚᛟᚨᛞ—ᚨ ᛗᛁᚲᚱᛟᛊᛖᚱᚹᛁᚲᛖ, ᚨ ᛞᚨᛏᚨᛒᚨᛊᛖ, ᛟᚱ ᚨᚾ ᚨᛁ ᛁᚾᚠᛖᚱᛖᚾᚲᛖ ᛖᛜᛁᚾᛖ—ᛊᛈᛁᚾᛊ ᚢᛈ ᛁᚾ ᚦᛖ ᛉ ᚲᛚᛟᚢᛞ, ᛁᛏ ᛞᛟᛖᛊ ᚾᛟᛏ ᚲᚨᚱᚱᛃ ᛊᛏᚨᛏᛁᚲ, ᛚᛟᛜ-ᛚᛁᚹᛖᛞ ᚨᛈᛁ ᚲᛖᛃᛊ. ᛊᛏᚨᛏᛁᚲ ᚲᛖᛃᛊ ᚨᚱᛖ ᚨ ᚲᚨᛏᚨᛊᛏᚱᛟᚠᛁᚲ ᛚᛁᚨᛒᛁᛚᛁᛏᛃ. ᚦᛖᛃ ᚲᚨᚾ ᛒᛖ ᛊᛏᛟᛚᛖᚾ, ᛚᛖᚨᚲᛖᛞ ᛁᚾ ᛊᛟᚢᚱᚲᛖ ᚲᛟᛞᛖ, ᚨᚲᚲᛁᛞᛖᚾᛏᚨᛚᛚᛃ ᛈᚢᛊᚺᛖᛞ ᛏᛟ ᛈᚢᛒᛚᛁᚲ ᚱᛖᛈᛟᛊᛁᛏᛟᚱᛁᛖᛊ, ᛟᚱ ᛚᛖᚠᛏ ᛟᚾ ᚠᛟᚱᚷᛟᛏᛏᛖᚾ ᚺᚨᚱᛞ ᛞᚱᛁᚹᛖᛊ. ᛁᚾᛊᛏᛖᚨᛞ, ᛟᚢᚱ ᚹᛟᚱᚲᛚᛟᚨᛞᛊ ᛞᛃᚾᚨᛗᛁᚲᚨᛚᛚᛃ ᚱᛖᚲᚹᛖᛊᛏ ᚨ ᛊᛈᛁᚠᚠᛖ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛞᛟᚲᚢᛗᛖᚾᛏ (ᛊᚹᛁᛞ). ᚦᛁᛊ ᛊᚹᛁᛞ ᛁᛊ ᚨ ᛊᚺᛟᚱᛏ-ᛚᛁᚹᛖᛞ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛈᚨᛊᛊᛈᛟᚱᛏ, ᛟᚠᛏᛖᚾ ᛖᚲᛊᛈᛁᚱᛁᛜ ᛁᚾ ᛚᛖᛊᛊ ᚦᚨᚾ ᚨᚾ ᚺᛟᚢᚱ.
ᛒᚢᛏ ᚺᛟᚹ ᛞᛟᛖᛊ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚲᚾᛟᚹ ᚦᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛊ ᛊᚨᚠᛖ ᛏᛟ ᛁᛊᛊᚢᛖ ᚨ ᛈᚨᛊᛊᛈᛟᚱᛏ ᛏᛟ? ᚦᛁᛊ ᛁᛊ ᚹᛖᚱᛖ ᛟᚢᚱ ᚺᚨᚱᛞᚹᚨᚱᛖ-ᚱᛟᛟᛏᛖᛞ ᛏᚱᚢᛊᛏ ᚲᛟᛗᛖᛊ ᛁᚾᛏᛟ ᛈᛚᚨᛃ. ᚹᛖ ᚢᛏᛁᛚᛁᛉᛖ ᛏᛈᛗ 2.0 (ᛏᚱᚢᛊᛏᛖᛞ ᛈᛚᚨᛏᚠᛟᚱᛗ ᛗᛟᛞᚢᛚᛖ) ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ. ᛒᛖᚠᛟᚱᛖ ᛊᛈᛁᚱᛖ ᛁᛊᛊᚢᛖᛊ ᚨᚾ ᛊᚹᛁᛞ, ᚦᛖ ᚢᚾᛞᛖᚱᛚᛃᛁᛜ ᚠᛃᛊᛁᚲᚨᛚ ᚾᛟᛞᛖ ᚺᛟᛊᛏᛁᛜ ᚦᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛗᚢᛊᛏ ᛈᚱᛟᚹᛖ ᛁᛏᛊ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚢᛊᛁᛜ ᛁᛏᛊ ᛁᚾᛞᛖᛚᛁᛒᛚᛖ ᚺᚨᚱᛞᚹᚨᚱᛖ ᛖᚾᛞᛟᚱᛊᛖᛗᛖᚾᛏ ᚲᛖᛃ (ᛖᚲ). ᚦᛖ ᚾᛟᛞᛖ ᛈᚱᛟᚹᛁᛞᛖᛊ ᚨ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛊᛁᚷᚾᛖᛞ “ᚲᚹᛟᛏᛖ” ᛟᚠ ᛁᛏᛊ ᚲᚢᚱᚱᛖᚾᛏ ᛊᛏᚨᛏᛖ, ᛈᚱᛟᚹᛁᛜ ᚦᚨᛏ ᛁᛏᛊ ᛒᛟᛟᛏ ᛊᛖᚲᚹᛖᚾᚲᛖ, ᚲᛖᚱᚾᛖᛚ, ᚨᚾᛞ ᚲᚱᛁᛏᛁᚲᚨᛚ ᚲᛟᚾᚠᛁᚷᚢᚱᚨᛏᛁᛟᚾᛊ ᚺᚨᚹᛖ ᚾᛟᛏ ᛒᛖᛖᚾ ᛏᚨᛗᛈᛖᚱᛖᛞ ᚹᛁᚦ. ᛁᚠ ᚨᚾ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᚲᛚᛟᚾᛖ ᚨ ᚹᛟᚱᚲᛚᛟᚨᛞ ᚨᚾᛞ ᚱᚢᚾ ᛁᛏ ᛟᚾ ᚨᚾ ᚢᚾᚨᚢᚦᛟᚱᛁᛉᛖᛞ, ᚢᚾ-ᚨᛏᛏᛖᛊᛏᛖᛞ ᛗᚨᚲᚺᛁᚾᛖ, ᚦᛖ ᚱᛖᚲᚹᛖᛊᛏ ᚠᛟᚱ ᚨᚾ ᛊᚹᛁᛞ ᛁᛊ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛞᛖᚾᛁᛖᛞ.
ᛟᚾᚲᛖ ᚦᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛈᛟᛊᛊᛖᛊᛊᛖᛊ ᛁᛏᛊ ᛊᚹᛁᛞ, ᛁᛏ ᚢᛊᛖᛊ ᛁᛏ ᛏᛟ ᛖᛊᛏᚨᛒᛚᛁᛊᚺ ᛗᚢᛏᚢᚨᛚ ᛏᛚᛊ (ᛗᛏᛚᛊ) ᚲᛟᚾᚾᛖᚲᛏᛁᛟᚾᛊ. ᚦᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛈᚱᛟᚹᛖᛊ ᛁᛏᛊ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛏᛟ ᚦᛖ ᛞᚨᛏᚨᛒᚨᛊᛖ, ᚨᚾᛞ ᚦᛖ ᛞᚨᛏᚨᛒᚨᛊᛖ ᛈᚱᛟᚹᛖᛊ ᛁᛏᛊ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛏᛟ ᚦᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ. ᚨᛚᛚ ᛞᚨᛏᚨ ᛁᚾ ᛏᚱᚨᚾᛊᛁᛏ ᛁᛊ ᛖᚾᚲᚱᛃᛈᛏᛖᛞ, ᚨᚾᛞ ᛖᚹᛖᚱᛃ ᚲᛟᚾᚾᛖᚲᛏᛁᛟᚾ ᛁᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛖᛞ.

ᛈᛁᛚᛚᚨᚱ 2: ᛊᛟᚠᛏᚹᚨᚱᛖ ᚨᚾᛞ ᛗᛟᛞᛖᛚ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ

ᛊᛖᚲᚢᚱᛁᛜ ᚦᛖ ᚱᚢᚾᛏᛁᛗᛖ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ ᛁᛊ ᛟᚾᛚᛃ ᚺᚨᛚᚠ ᚦᛖ ᛒᚨᛏᛏᛚᛖ. ᛁᚠ ᚦᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛒᛖᛁᛜ ᛖᚲᛊᛖᚲᚢᛏᛖᛞ ᛁᛊ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᛒᛖᚠᛟᚱᛖ ᛁᛏ ᛖᚹᛖᚱ ᚱᛖᚨᚲᚺᛖᛊ ᚦᛖ ᛊᛖᚱᚹᛖᚱ, ᚱᚢᚾᛏᛁᛗᛖ ᛞᛖᚠᛖᚾᛊᛖᛊ ᚨᚱᛖ ᚠᛁᚷᚺᛏᛁᛜ ᚨ ᛚᛟᛊᛏ ᚲᚨᚢᛊᛖ. ᚺᛁᚷᚺ-ᛈᚱᛟᚠᛁᛚᛖ ᛁᚾᛞᚢᛊᛏᚱᛃ ᛖᚹᛖᚾᛏᛊ ᚺᚨᚹᛖ ᚱᛖᛈᛖᚨᛏᛖᛞᛚᛃ ᛞᛖᛗᛟᚾᛊᛏᚱᚨᛏᛖᛞ ᚦᚨᛏ ᚦᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾ ᛁᛊ ᚦᛖ ᛊᛟᚠᛏ ᚢᚾᛞᛖᚱᛒᛖᛚᛚᛃ ᛟᚠ ᛗᛟᛞᛖᚱᚾ ᛁᚾᚠᚱᚨᛊᛏᚱᚢᚲᛏᚢᚱᛖ. ᚨᚾ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ ᛞᛟᛖᛊ ᚾᛟᛏ ᚾᛖᛖᛞ ᛏᛟ ᚺᚨᚲᚲ ᛃᛟᚢᚱ ᛈᚱᛟᛞᚢᚲᛏᛁᛟᚾ ᛊᛖᚱᚹᛖᚱ ᛁᚠ ᚦᛖᛃ ᚲᚨᚾ ᛁᚾᛊᛖᚱᛏ ᚨ ᛒᚨᚲᚲᛞᛟᛟᚱ ᛁᚾᛏᛟ ᚨ ᛚᛁᛒᚱᚨᚱᛃ ᛃᛟᚢ ᛞᛟᚹᚾᛚᛟᚨᛞ ᛞᚢᚱᛁᛜ ᚦᛖ ᛒᚢᛁᛚᛞ ᛈᚱᛟᚲᛖᛊᛊ.
ᛉ ᛁᛗᛈᛚᛖᛗᛖᚾᛏᛊ ᚨ ᚱᚢᚦᛚᛖᛊᛊ, ᚢᚾᚲᛟᛗᛈᚱᛟᛗᛁᛊᛁᛜ ᚨᛈᛈᚱᛟᚨᚲᚺ ᛏᛟ ᛊᛟᚠᛏᚹᚨᚱᛖ ᚨᚾᛞ ᛗᛟᛞᛖᛚ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᛒᚨᛊᛖᛞ ᛟᚾ ᚦᛖ ᛊᛚᛊᚨ (ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾ ᛚᛖᚹᛖᛚᛊ ᚠᛟᚱ ᛊᛟᚠᛏᚹᚨᚱᛖ ᚨᚱᛏᛁᚠᚨᚲᛏᛊ) ᚠᚱᚨᛗᛖᚹᛟᚱᚲ ᚨᚾᛞ ᛁᚾ-ᛏᛟᛏᛟ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾᛊ. ᛖᚹᛖᚱᛃ ᛈᛁᛖᚲᛖ ᛟᚠ ᚲᛟᛞᛖ, ᛖᚹᛖᚱᛃ ᚲᛟᚾᛏᚨᛁᚾᛖᚱ ᛁᛗᚨᚷᛖ, ᚨᚾᛞ ᛖᚹᛖᚱᛃ ᛗᚨᚲᚺᛁᚾᛖ ᛚᛖᚨᚱᚾᛁᛜ ᛗᛟᛞᛖᛚ ᛞᛖᛈᛚᛟᛃᛖᛞ ᛏᛟ ᛟᚢᚱ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ ᛗᚢᛊᛏ ᚲᚨᚱᚱᛃ ᚨ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛊᛁᚷᚾᛖᛞ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ ᛞᛟᚲᚢᛗᛖᚾᛏ.
ᚦᛁᛊ ᛞᛟᚲᚢᛗᛖᚾᛏ—ᛟᚠᛏᛖᚾ ᚹᚱᚨᛈᛈᛖᛞ ᛁᚾ ᚨ ᛊᛏᚨᚾᛞᚨᚱᛞᛁᛉᛖᛞ ᛞᛖᚨᛞ ᛊᛁᛗᛈᛚᛖ ᛊᛁᚷᚾᛁᛜ ᛖᚾᚹᛖᛚᛟᛈᛖ (ᛞᛊᛊᛖ)—ᛞᛖᛏᚨᛁᛚᛊ ᛖᚲᛊᚨᚲᛏᛚᛃ ᚹᛟ ᛒᚢᛁᛚᛏ ᚦᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ, ᚹᚨᛏ ᛊᛟᚢᚱᚲᛖ ᚲᛟᛞᛖ ᚱᛖᛈᛟᛊᛁᛏᛟᚱᛃ ᛁᛏ ᚲᚨᛗᛖ ᚠᚱᛟᛗ, ᚦᛖ ᛊᛈᛖᚲᛁᚠᛁᚲ ᚲᛟᛗᛗᛁᛏ ᚺᚨᛊᚺ, ᚦᛖ ᚲᛟᛗᛈᛁᛚᛖᚱ ᚹᛖᚱᛊᛁᛟᚾ, ᚨᚾᛞ ᚦᛖ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ ᛈᚨᚱᚨᛗᛖᛏᛖᚱᛊ. ᚹᛖᚾ ᚨ ᛞᛖᛈᛚᛟᛃᛗᛖᚾᛏ ᛁᛊ ᚱᛖᚲᚹᛖᛊᛏᛖᛞ, ᛟᚢᚱ ᚲᚢᛒᛖᚱᚾᛖᛏᛖᛊ ᚨᛞᛗᛁᛊᛊᛁᛟᚾ ᚲᛟᚾᛏᚱᛟᛚᛚᛖᚱᛊ ᛞᛟ ᚾᛟᛏ ᛃᚢᛊᛏ ᚲᚺᛖᚲᚲ ᛁᚠ ᚦᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ ᚹᛟᚱᚲᛊ; ᚦᛖᛃ ᚹᛖᚱᛁᚠᛃ ᚦᛖ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ ᛊᛁᚷᚾᚨᛏᚢᚱᛖ. ᛁᚠ ᚦᛖ ᛊᛁᚷᚾᚨᛏᚢᚱᛖ ᛁᛊ ᛗᛁᛊᛊᛁᛜ ᛟᚱ ᛁᚾᚹᚨᛚᛁᛞ, ᚦᛖ ᛞᛖᛈᛚᛟᛃᛗᛖᚾᛏ ᛁᛊ ᛒᛚᛟᚲᚲᛖᛞ ᛁᚾᛊᛏᚨᚾᛏᛚᛃ.
ᚠᛟᚱ ᛟᚢᚱ ᚨᚱᛏᛁᚠᛁᚲᛁᚨᛚ ᛁᚾᛏᛖᛚᛚᛁᚷᛖᚾᚲᛖ ᛁᚾᚠᚱᚨᛊᛏᚱᚢᚲᛏᚢᚱᛖ, ᚹᛖ ᚢᛏᛁᛚᛁᛉᛖ ᚲᛃᚲᛚᛟᚾᛖᛞᚲᛊ 1.6 ᚨᛁ-ᛒᛟᛗᛊ (ᛒᛁᛚᛚ ᛟᚠ ᛗᚨᛏᛖᚱᛁᚨᛚᛊ). ᚨᛁ ᛗᛟᛞᛖᛚᛊ ᚨᚱᛖ ᛖᛊᛊᛖᚾᛏᛁᚨᛚᛚᛃ ᛟᛈᚨᚲᚹᛖ ᛒᛚᛟᚲᚲᛊ ᛟᚠ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᛊ, ᛗᚨᚲᛁᛜ ᚦᛖᛗ ᛁᚾᚲᚱᛖᛞᛁᛒᛚᛃ ᛞᛁᚠᚠᛁᚲᚢᛚᛏ ᛏᛟ ᚨᚢᛞᛁᛏ ᚠᛟᚱ ᛏᚨᛗᛈᛖᚱᛁᛜ. ᚦᛖ ᚨᛁ-ᛒᛟᛗ ᛊᛟᛚᚹᛖᛊ ᚦᛁᛊ ᛒᛃ ᚱᛖᚲᛟᚱᛞᛁᛜ ᚦᛖ ᛚᛁᚾᛖᚨᚷᛖ ᛟᚠ ᚦᛖ ᛞᚨᛏᚨᛊᛖᛏᛊ ᚢᛊᛖᛞ ᛏᛟ ᛏᚱᚨᛁᚾ ᚦᛖ ᛗᛟᛞᛖᛚᛊ, ᚦᛖ ᛖᚦᛁᚲᚨᛚ ᛈᚨᚱᚨᛗᛖᛏᛖᚱᛊ, ᚨᚾᛞ ᚦᛖ ᛈᚱᛖᚲᛁᛊᛖ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛞᛁᚷᛖᛊᛏᛊ ᛟᚠ ᚦᛖ ᛗᛟᛞᛖᛚ ᚹᛖᛁᚷᚺᛏᛊ ᚨᚾᛞ ᛒᛁᚨᛊᛖᛊ. ᛁᚠ ᚨᚾ ᚨᛞᚹᛖᚱᛊᚨᚱᛃ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᛊᛁᛚᛖᚾᛏᛚᛃ ᛈᛟᛁᛊᛟᚾ ᚨ ᛗᛟᛞᛖᛚ ᛁᚾ ᛗᛖᛗᛟᚱᛃ, ᛟᚢᚱ ᚲᛟᚾᛏᛁᚾᚢᛟᚢᛊ ᚱᚢᚾᛏᛁᛗᛖ ᚹᚨᛏᚲᚺᛖᚱᛊ ᛞᛖᛏᛖᚲᛏ ᚦᛖ ᛞᛁᚷᛖᛊᛏ ᛗᛁᛊᛗᚨᛏᚲᚺ ᚨᚾᛞ ᛏᚱᛁᚷᚷᛖᚱ ᛁᛗᛗᛖᛞᛁᚨᛏᛖ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ.

ᛈᛁᛚᛚᚨᚱ 3: ᛖᚹᛁᛞᛖᚾᚲᛖ ᛁᚾᛏᛖᚷᚱᛁᛏᛃ ᚨᚾᛞ ᛏᚨᛗᛈᛖᚱ-ᛖᚹᛁᛞᛖᚾᛏ ᛚᛖᛞᚷᛖᚱᛊ

ᛁᚾ ᚦᛖ ᛖᚹᛖᚾᛏ ᛟᚠ ᚨ ᛊᛃᛊᛏᛖᛗ ᚨᚾᛟᛗᚨᛚᛃ, ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᚷᛖᚾᛖᚱᚨᛏᛖᛊ ᛖᚹᛁᛞᛖᚾᚲᛖ. ᚺᛟᚹᛖᚹᛖᚱ, ᛊᛗᚨᚱᛏ ᚨᛞᚹᛖᚱᛊᚨᚱᛁᛖᛊ ᚲᚾᛟᚹ ᚦᚨᛏ ᚦᛖ ᛒᛖᛊᛏ ᚹᚨᛃ ᛏᛟ ᚺᛁᛞᛖ ᚨᚾ ᛁᚾᛏᚱᚢᛊᛁᛟᚾ ᛁᛊ ᛏᛟ ᚨᛚᛏᛖᚱ ᚦᛖ ᛚᛟᚷᛊ. ᚦᛖᛃ ᚷᚨᛁᚾ ᚱᛟᛟᛏ ᚨᚲᚲᛖᛊᛊ ᚨᚾᛞ ᛞᛖᛚᛖᛏᛖ ᚦᛖ ᚱᛖᚲᛟᚱᛞᛊ ᛟᚠ ᚦᛖᛁᚱ ᛈᚱᛖᛊᛖᚾᚲᛖ. ᛏᛟ ᛈᛖᚱᛗᚨᚾᛖᚾᛏᛚᛃ ᛈᚱᛖᚹᛖᚾᛏ ᚦᛁᛊ, ᛉ ᚱᛖᛚᛁᛖᛊ ᛟᚾ ᚨ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ, ᚨᛈᛈᛖᚾᛞ-ᛟᚾᛚᛃ ᛗᛖᚱᚲᛚᛖ ᚺᚨᛊᚺ ᛏᚱᛖᛖ ᛚᛖᛞᚷᛖᚱ, ᛁᚾᛊᛈᛁᚱᛖᛞ ᛒᛃ ᚦᛖ ᛁᛖᛏᚠ ᚱᚠᚲ 6962 ᚲᛖᚱᛏᛁᚠᛁᚲᚨᛏᛖ ᛏᚱᚨᚾᛊᛈᚨᚱᛖᚾᚲᛃ ᛊᛈᛖᚲᛁᚠᛁᚲᚨᛏᛁᛟᚾ.
ᛖᚹᛖᚱᛃ ᚲᚱᛁᛏᛁᚲᚨᛚ ᛖᚹᛖᚾᛏ—ᛖᚹᛖᚱᛃ ᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛁᛟᚾ ᛊᚢᚲᚲᛖᛊᛊ ᛟᚱ ᚠᚨᛁᛚᚢᚱᛖ, ᛖᚹᛖᚱᛃ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚲᛏᛁᛟᚾ, ᛖᚹᛖᚱᛃ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚲᛖᛃ ᚱᛟᛏᚨᛏᛁᛟᚾ—ᛁᛊ ᚺᚨᛊᚺᛖᛞ ᚨᚾᛞ ᚨᛈᛈᛖᚾᛞᛖᛞ ᛏᛟ ᚦᛁᛊ ᛏᚱᛖᛖ ᚨᛊ ᚨ ᛚᛖᚨᚠ ᚾᛟᛞᛖ. ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚲᛟᚾᛏᛁᚾᚢᚨᛚᛚᛃ ᚲᛟᛗᛈᚢᛏᛖᛊ ᚨ ᛊᛁᛜᛚᛖ ᚱᛟᛟᛏ ᚺᚨᛊᚺ ᚦᚨᛏ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚱᛖᛈᚱᛖᛊᛖᚾᛏᛊ ᚦᛖ ᛖᚾᛏᛁᚱᛖ ᚺᛁᛊᛏᛟᚱᛃ ᛟᚠ ᚦᛖ ᛊᛃᛊᛏᛖᛗ. ᛁᚠ ᚨᚾ ᚨᛏᛏᚨᚲᚲᛖᚱ ᚨᛏᛏᛖᛗᛈᛏᛊ ᛏᛟ ᚨᛚᛏᛖᚱ ᚨ ᛚᛟᚷ ᛖᚾᛏᚱᛃ ᚠᚱᛟᛗ ᛚᚨᛊᛏ ᚹᛖᛖᚲ, ᚦᛖ ᚺᚨᛊᚺ ᛟᚠ ᚦᚨᛏ ᛖᚾᛏᚱᛃ ᚲᚺᚨᛜᛖᛊ, ᚹᛁᚲᚺ ᚲᚺᚨᛜᛖᛊ ᚦᛖ ᚺᚨᛊᚺ ᛟᚠ ᛁᛏᛊ ᛈᚨᚱᛖᚾᛏ ᚾᛟᛞᛖ, ᚲᚨᛊᚲᚨᛞᛁᛜ ᚨᛚᛚ ᚦᛖ ᚹᚨᛃ ᛏᛟ ᚦᛖ ᚱᛟᛟᛏ. ᚦᛖ ᛞᛁᛊᚲᚱᛖᛈᚨᚾᚲᛃ ᛁᛊ ᛁᚾᛊᛏᚨᚾᛏᛚᛃ ᛞᛖᛏᛖᚲᛏᛖᛞ.
ᚠᚢᚱᚦᛖᚱᛗᛟᚱᛖ, ᚹᛖ ᛈᚱᛟᚹᛁᛞᛖ ᚨᚾ “ᛁᚾᚲᛚᚢᛊᛁᛟᚾ ᛈᚱᛟᛟᚠ” ᚨᛈᛁ. ᛖᚲᛊᛏᛖᚱᚾᚨᛚ ᚨᚢᛞᛁᛏᛟᚱᛊ, ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᚷᛟᚹᛖᚱᚾᚨᚾᚲᛖ ᛒᛟᚨᚱᛞᛊ, ᛟᚱ ᚨᚢᛏᛟᛗᚨᛏᛖᛞ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹᛖᚱᛊ ᚲᚨᚾ ᚱᛖᚲᚹᛖᛊᛏ ᚨᚾ ᛟ(ᛚᛟᚷ ᚾ) ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛈᚱᛟᛟᚠ ᚦᚨᛏ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲ ᛖᚹᛖᚾᛏ ᛖᚲᛊᛁᛊᛏᛊ ᛁᚾ ᚦᛖ ᛚᛟᚷ. ᚦᛁᛊ ᚨᛚᛚᛟᚹᛊ ᚢᛊ ᛏᛟ ᛊᚨᛃ “ᚹᛖᚱᛁᚠᛃ, ᛞᛟᚾ’ᛏ ᛏᚱᚢᛊᛏ.” ᚹᛖ ᛞᛟ ᚾᛟᛏ ᚨᛊᚲ ᛃᛟᚢ ᛏᛟ ᛊᛁᛗᛈᛚᛃ ᛒᛖᛚᛁᛖᚹᛖ ᛟᚢᚱ ᛚᛟᚷᛊ ᚨᚱᛖ ᛁᚾᛏᚨᚲᛏ; ᚹᛖ ᛈᚱᛟᚹᛁᛞᛖ ᚦᛖ ᚱᚨᚹ ᛗᚨᚦ ᛊᛟ ᛃᛟᚢ ᚲᚨᚾ ᛈᚱᛟᚹᛖ ᛁᛏ ᛃᛟᚢᚱᛊᛖᛚᚠ.

ᛈᛁᛚᛚᚨᚱ 4: ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᛒᛟᚢᚾᛞᛖᛞ ᚱᛖᛊᛈᛟᚾᛊᛖᛊ ᚨᚾᛞ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ

ᚹᛖᚾ ᚦᛖ ᛞᛖᛏᛖᚱᛗᛁᚾᛁᛊᛏᛁᚲ ᚱᚢᛚᛖᛊ ᛟᚠ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚨᚱᛖ ᚹᛁᛟᛚᚨᛏᛖᛞ, ᚱᛖᛊᛈᛟᚾᛊᛖ ᛏᛁᛗᛖ ᛁᛊ ᚲᚱᛁᛏᛁᚲᚨᛚ. ᚺᚢᛗᚨᚾ ᛟᛈᛖᚱᚨᛏᛟᚱᛊ ᚲᚨᚾᚾᛟᛏ ᛈᚨᚱᛊᛖ ᛚᛟᚷᛊ, ᚨᚾᚨᛚᛃᛉᛖ ᚦᚱᛖᚨᛏᛊ, ᛗᚨᚾᚢᚨᛚᛚᛃ ᛚᛟᚷ ᛁᚾᛏᛟ ᚠᛁᚱᛖᚹᚨᛚᛚᛊ, ᚨᚾᛞ ᚠᛟᚱᛗᚢᛚᚨᛏᛖ ᚲᛟᛗᛈᛚᛖᚲᛊ ᚱᛟᚢᛏᛁᛜ ᚱᚢᛚᛖᛊ ᛁᚾ ᚦᛖ ᛗᛁᛚᛚᛁᛊᛖᚲᛟᚾᛞᛊ ᚱᛖᚲᚹᛁᚱᛖᛞ ᛏᛟ ᛊᛏᛟᛈ ᚨ ᛚᚨᛏᛖᚱᚨᛚ ᛗᛟᚹᛖᛗᛖᚾᛏ ᚨᛏᛏᚨᚲᚲ. ᚦᛖᚱᛖᚠᛟᚱᛖ, ᛟᚢᚱ ᛊᛃᛊᛏᛖᛗ ᛁᛊ ᛖᛗᛈᛟᚹᛖᚱᛖᛞ ᛏᛟ ᚨᚲᛏ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊᛚᛃ.
ᚺᛟᚹᛖᚹᛖᚱ, ᛏᛟ ᛈᚱᛖᚹᛖᚾᛏ ᚦᛖ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᛊᛃᛊᛏᛖᛗ ᚠᚱᛟᛗ ᚲᚨᚢᛊᛁᛜ ᚲᚨᛏᚨᛊᛏᚱᛟᚠᛁᚲ ᛊᛖᛚᚠ-ᛞᛖᚾᛁᚨᛚ-ᛟᚠ-ᛊᛖᚱᚹᛁᚲᛖ, ᛁᛏᛊ ᚨᚲᛏᛁᛟᚾᛊ ᚨᚱᛖ ᛊᛏᚱᛁᚲᛏᛚᛃ ᛒᛟᚢᚾᛞᛖᛞ. ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚲᚨᚾᚾᛟᛏ ᛚᚨᚢᚾᚲᚺ ᚲᛟᚢᚾᛏᛖᚱᚨᛏᛏᚨᚲᚲᛊ, ᛁᛏ ᚲᚨᚾᚾᛟᛏ ᛖᚲᛊᛖᚲᚢᛏᛖ ᚨᚱᛒᛁᛏᚱᚨᚱᛃ ᚲᛟᛞᛖ ᛟᚾ ᛖᚲᛊᛏᛖᚱᚾᚨᛚ ᚾᛖᛏᚹᛟᚱᚲᛊ, ᚨᚾᛞ ᛁᛏ ᚲᚨᚾᚾᛟᛏ ᛞᛖᛚᛖᛏᛖ ᚠᛟᚱᛖᚾᛊᛁᚲ ᛞᚨᛏᚨ. ᛁᛏ ᛁᛊ ᚱᛖᛊᛏᚱᛁᚲᛏᛖᛞ ᛏᛟ ᚨ ᛈᚱᛖᚲᛁᛊᛖ, ᛈᚱᛖᛞᛖᚠᛁᚾᛖᛞ ᛊᛖᛏ ᛟᚠ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚨᚲᛏᛁᛟᚾᛊ:

• ᚨᛚᛚᛟᚹ_ᛟᛒᛊᛖᚱᚹᚨᛏᛁᛟᚾ: ᛗᛟᚾᛁᛏᛟᚱ ᚦᛖ ᛖᚹᛖᚾᛏ ᚹᛁᚦᛟᚢᛏ ᛁᚾᛏᛖᚱᚠᛖᚱᛖᚾᚲᛖ, ᛚᛟᚷᚷᛁᛜ ᚨᛞᛞᛁᛏᛁᛟᚾᚨᛚ ᛗᛖᛏᚨᛞᚨᛏᚨ.
• ᛞᛖᚾᛃ_ᚱᛖᚲᚹᛖᛊᛏ: ᛒᛚᛟᚲᚲ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲ ᛏᚱᚨᚾᛊᚨᚲᛏᛁᛟᚾ ᚨᛏ ᚦᛖ ᚨᛈᛁ ᚷᚨᛏᛖᚹᚨᛃ.
• ᚱᛖᚲᚹᛁᚱᛖ_ᚱᛖᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛁᛟᚾ: ᚠᛟᚱᚲᛖ ᚦᛖ ᚲᛚᛁᛖᚾᛏ ᛏᛟ ᚱᛖᚠᚱᛖᛊᚺ ᛁᛏᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚᛊ.
• ᚱᛖᚹᛟᚲᛖ_ᚨᚢᚦᛟᚱᛁᛏᛃ: ᛁᚾᚹᚨᛚᛁᛞᚨᛏᛖ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᚲᚱᛟᛊᛊ ᚦᛖ ᛖᚾᛏᛁᚱᛖ ᛏᚱᚢᛊᛏ ᛞᛟᛗᚨᛁᚾ.
• ᛁᛊᛟᛚᚨᛏᛖ_ᚹᛟᚱᚲᛚᛟᚨᛞ: ᚲᚢᛏ ᛟᚠᚠ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲ ᚨᛈᛈᛚᛁᚲᚨᛏᛁᛟᚾ ᛁᚾᛊᛏᚨᚾᚲᛖ ᚠᚱᛟᛗ ᚨᛚᛚ ᛈᛖᛖᚱᛊ.
• ᛊᛖᚹᛖᚱ_ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ: ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᛁᛊᛟᛚᚨᛏᛖ ᚨᚾ ᛖᚾᛏᛁᚱᛖ ᚾᚨᛗᛖᛊᛈᚨᚲᛖ ᛟᚱ ᚲᛚᚢᛊᛏᛖᚱ ᛊᛖᚷᛗᛖᚾᛏ.
• ᚲᚹᚨᚱᚨᚾᛏᛁᚾᛖ_ᛊᛖᚱᚹᛁᚲᛖ: ᛊᚢᛊᛈᛖᚾᛞ ᚨ ᛗᛁᚲᚱᛟᛊᛖᚱᚹᛁᚲᛖ ᛈᛖᚾᛞᛁᛜ ᚺᚢᛗᚨᚾ ᚱᛖᚹᛁᛖᚹ.
• ᚠᚱᛖᛖᛉᛖ_ᚱᛖᛚᛖᚨᛊᛖ_ᚲᚺᚨᚾᚾᛖᛚ: ᚺᚨᛚᛏ ᚨᚢᛏᛟᛗᚨᛏᛖᛞ ᛞᛖᛈᛚᛟᛃᛗᛖᚾᛏᛊ ᛏᛟ ᛈᚱᛖᚹᛖᚾᛏ ᚢᛈᛊᛏᚱᛖᚨᛗ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ ᚠᚱᛟᛗ ᛊᛈᚱᛖᚨᛞᛁᛜ.
• ᚲᛟᛚᛚᛖᚲᛏ_ᛗᛟᚱᛖ_ᛖᚹᛁᛞᛖᚾᚲᛖ: ᛁᚾᚲᚱᛖᚨᛊᛖ ᛚᛟᚷᚷᛁᛜ ᚷᚱᚨᚾᚢᛚᚨᚱᛁᛏᛃ ᚨᚾᛞ ᛏᛖᛚᛖᛗᛖᛏᚱᛃ ᚲᚨᛈᛏᚢᚱᛖ.
• ᚱᛖᚲᛖᛃ: ᛁᚾᛁᛏᛁᚨᛏᛖ ᚨ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚲᛖᛃ ᚱᛟᛏᚨᛏᛁᛟᚾ ᚠᛟᚱ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚨᚢᚦᛟᚱᛁᛏᛁᛖᛊ.
• ᚱᛖᚲᛟᚾᚲᛁᛚᛖ: ᚨᛏᛏᛖᛗᛈᛏ ᛏᛟ ᚱᛖᛊᛟᛚᚹᛖ ᛊᛏᚨᛏᛖ ᛞᚱᛁᚠᛏ ᚨᚠᛏᛖᚱ ᚨ ᚾᛖᛏᚹᛟᚱᚲ ᛈᚨᚱᛏᛁᛏᛁᛟᚾ.
• ᚱᛖᛊᛏᛟᚱᛖ_ᚨᛏᛏᛖᛊᛏᛖᛞ_ᛒᚨᛊᛖᛚᛁᚾᛖ: ᚱᛖᚹᛖᚱᛏ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛏᛟ ᚨ ᚲᚾᛟᚹᚾ-ᚷᛟᛟᛞ, ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛈᚱᛟᚹᛖᚾ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛊᛏᚨᛏᛖ.
• ᚨᛒᛊᛏᚨᛁᚾ: ᛞᛖᚠᛖᚱ ᚦᛖ ᛞᛖᚲᛁᛊᛁᛟᚾ ᛏᛟ ᚺᚢᛗᚨᚾ ᛟᛈᛖᚱᚨᛏᛟᚱᛊ ᚹᛖᚾ ᚦᛖ ᚲᛟᚾᚠᛁᛞᛖᚾᚲᛖ ᛁᚾᛏᛖᚱᚹᚨᛚ ᛁᛊ ᛚᛟᚹ.

ᚹᛖᚾ ᚨ ᚺᛁᚷᚺ-ᛊᛖᚹᛖᚱᛁᛏᛃ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚲᛏᛁᛟᚾ ᛁᛊ ᛏᚨᚲᛖᚾ, ᛊᚢᚲᚺ ᚨᛊ ᛊᛖᚹᛖᚱᛁᛜ ᚨ ᚲᛟᛗᛈᚨᚱᛏᛗᛖᚾᛏ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᚢᛏᛁᛚᛁᛉᛖᛊ ᛖᛒᛈᚠ (ᛖᚲᛊᛏᛖᚾᛞᛖᛞ ᛒᛖᚱᚲᛖᛚᛖᛃ ᛈᚨᚲᚲᛖᛏ ᚠᛁᛚᛏᛖᚱ) ᚨᚾᛞ ᚨᛞᚹᚨᚾᚲᛖᛞ ᚲᚾᛁ (ᚲᛟᚾᛏᚨᛁᚾᛖᚱ ᚾᛖᛏᚹᛟᚱᚲ ᛁᚾᛏᛖᚱᚠᚨᚲᛖ) ᛈᛟᛚᛁᚲᛁᛖᛊ ᛏᛟ ᛞᚱᛟᛈ ᚾᛖᛏᚹᛟᚱᚲ ᛈᚨᚲᚲᛖᛏᛊ ᛁᚾᛊᛏᚨᚾᛏᛚᛃ. ᛊᛁᛗᚢᛚᛏᚨᚾᛖᛟᚢᛊᛚᛃ, ᚦᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛟᚠ ᚦᛖ ᛟᚠᚠᛖᚾᛞᛁᛜ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛊ ᚱᛖᚹᛟᚲᛖᛞ ᚨᛏ ᚦᛖ ᛊᛈᛁᚱᛖ ᛊᛖᚱᚹᛖᚱ, ᛗᛖᚨᚾᛁᛜ ᛁᛏ ᚲᚨᚾ ᚾᛟ ᛚᛟᛜᛖᚱ ᚨᚢᚦᛖᚾᛏᛁᚲᚨᛏᛖ ᛏᛟ ᛞᚨᛏᚨᛒᚨᛊᛖᛊ, ᚲᚹᛖᚢᛖᛊ, ᛟᚱ ᛟᚦᛖᚱ ᛊᛖᚱᚹᛁᚲᛖᛊ. ᚲᚱᚢᚲᛁᚨᛚᛚᛃ, ᚨᛚᛚ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᛁᛊ ᛞᛖᛊᛁᚷᚾᛖᛞ ᛏᛟ ᛒᛖ ᚠᚢᛚᛚᛃ ᚱᛖᚹᛖᚱᛊᛁᛒᛚᛖ ᛟᚾᚲᛖ ᚨ ᚺᚢᛗᚨᚾ ᛟᛈᛖᚱᚨᛏᛟᚱ ᛟᚱ ᚨ ᛊᛖᚲᛟᚾᛞᚨᚱᛃ ᛗᚨᚲᚺᛁᚾᛖ ᚲᚹᛟᚱᚢᛗ ᚱᛖᚹᛁᛖᚹᛊ ᚦᛖ ᛖᚹᛁᛞᛖᚾᚲᛖ ᚨᚾᛞ ᚲᛟᚾᚠᛁᚱᛗᛊ ᚦᛖ ᚦᚱᛖᚨᛏ ᛁᛊ ᚾᛖᚢᛏᚱᚨᛚᛁᛉᛖᛞ.

ᛈᛁᛚᛚᚨᚱ 5: ᚨᚢᚦᛟᚱᛁᛏᛃ, ᚲᛖᛃ ᛖᛈᛟᚲᚺᛊ, ᚨᚾᛞ ᚦᚱᛖᛊᚺᛟᛚᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ

ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛊᛃᛊᛏᛖᛗᛊ ᚱᛖᛚᛃ ᛟᚾ ᚲᛖᛃᛊ, ᚨᚾᛞ ᚺᛁᛊᛏᛟᚱᛃ ᛊᚺᛟᚹᛊ ᚦᚨᛏ ᚲᛖᛃᛊ ᚲᚨᚾ—ᚨᚾᛞ ᚹᛁᛚᛚ—ᛒᛖ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ. ᛁᚠ ᚨ ᛊᛁᛜᛚᛖ ᛗᚨᛊᛏᛖᚱ ᚲᛖᛃ ᛁᛊ ᛚᛟᛊᛏ ᛟᚱ ᛊᛏᛟᛚᛖᚾ, ᚦᛖ ᛖᚾᛏᛁᚱᛖ ᛊᛃᛊᛏᛖᛗ ᛁᛊ ᚨᛏ ᚱᛁᛊᚲ. ᛏᛟ ᛗᛁᛏᛁᚷᚨᛏᛖ ᚦᛁᛊ ᛊᛃᛊᛏᛖᛗᛁᚲ ᚹᚢᛚᚾᛖᚱᚨᛒᛁᛚᛁᛏᛃ, ᛉ ᚢᛏᛁᛚᛁᛉᛖᛊ ᚦᛖ ᚢᛈᛞᚨᛏᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ (ᛏᚢᚠ) ᚨᚾᛞ ᛈᚱᛁᚾᚲᛁᛈᛚᛖᛊ ᚨᛞᚨᛈᛏᛖᛞ ᚠᚱᛟᛗ ᚦᛖ ᚢᛈᛏᚨᚾᛖ ᚨᚢᛏᛟᛗᛟᛏᛁᚹᛖ ᛊᛖᚲᚢᚱᛁᛏᛃ ᛊᛏᚨᚾᛞᚨᚱᛞ.
ᚹᛖ ᛞᛁᛊᛏᚱᛁᛒᚢᛏᛖ ᚨᚢᚦᛟᚱᛁᛏᛃ ᚢᛊᛁᛜ ᚦᚱᛖᛊᚺᛟᛚᛞ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛃ ᚨᚾᛞ ᛊᛏᚱᛁᚲᛏ ᚱᛟᛚᛖ ᛞᛖᛚᛖᚷᚨᛏᛁᛟᚾ. ᚾᛟ ᛊᛁᛜᛚᛖ ᚲᛖᛃ ᛈᛟᛊᛊᛖᛊᛊᛖᛊ ᛏᛟᛏᚨᛚ ᚲᛟᚾᛏᚱᛟᛚ ᛟᚹᛖᚱ ᚦᛖ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ. ᛏᛟ ᚱᛟᛏᚨᛏᛖ ᚦᛖ ᚱᛟᛟᛏ ᚲᛖᛃᛊ, ᛟᚱ ᛏᛟ ᛈᚢᛊᚺ ᚨ ᚷᛚᛟᛒᚨᛚ ᛈᛟᛚᛁᚲᛃ ᚢᛈᛞᚨᛏᛖ, ᚨ “ᚲᚹᛟᚱᚢᛗ” ᛟᚠ ᛊᛁᚷᚾᛖᚱᛊ (ᚠᛟᚱ ᛖᚲᛊᚨᛗᛈᛚᛖ, 3 ᛟᚢᛏ ᛟᚠ 5 ᚺᚢᛗᚨᚾ ᛟᚱ ᛗᚨᚲᚺᛁᚾᛖ ᚷᛟᚹᛖᚱᚾᛟᚱᛊ) ᛗᚢᛊᛏ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏᛚᛃ ᛊᛁᚷᚾ ᚦᛖ ᚱᛖᚲᚹᛖᛊᛏ.
ᚹᛖ ᛗᚨᚾᚨᚷᛖ ᚦᛖᛊᛖ ᚲᛖᛃᛊ ᛁᚾ ᛞᛁᛊᛏᛁᚾᚲᛏ “ᛖᛈᛟᚲᚺᛊ.” ᚨᚾ ᛖᛈᛟᚲᚺ ᛁᛊ ᚨ ᛞᛖᚠᛁᚾᛖᛞ ᛈᛖᚱᛁᛟᛞ ᛟᚠ ᛏᛁᛗᛖ ᚷᛟᚹᛖᚱᚾᛖᛞ ᛒᛃ ᚨ ᛊᛈᛖᚲᛁᚠᛁᚲ ᛊᛖᛏ ᛟᚠ ᚨᚲᛏᛁᚹᛖ, ᛏᚱᚢᛊᛏᛖᛞ ᚲᛖᛃᛊ. ᛁᚠ ᚨ ᚲᛖᛃ ᛁᛊ ᛊᚢᛊᛈᛖᚲᛏᛖᛞ ᛟᚠ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ, ᚦᛖ ᚲᚹᛟᚱᚢᛗ ᚹᛟᛏᛖᛊ ᛏᛟ ᛏᚱᚨᚾᛊᛁᛏᛁᛟᚾ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛏᛟ ᚦᛖ ᚾᛖᚲᛊᛏ ᛖᛈᛟᚲᚺ. ᚦᛖ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚲᛖᛃ ᛁᛊ ᛈᛚᚨᚲᛖᛞ ᛟᚾ ᚨ ᚱᛖᚹᛟᚲᚨᛏᛁᛟᚾ ᛚᛁᛊᛏ, ᚾᛖᚹ ᚲᛖᛃᛊ ᚨᚱᛖ ᚷᛖᚾᛖᚱᚨᛏᛖᛞ, ᚨᚾᛞ ᚦᛖ ᛊᛏᚨᛏᛖ ᛟᚠ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛁᛊ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲᚨᛚᛚᛃ ᚱᛖᚲᛟᚾᚲᛁᛚᛖᛞ. ᚨᚾᛃ ᚾᛟᛞᛖ ᛟᚱ ᚹᛟᚱᚲᛚᛟᚨᛞ ᚨᛏᛏᛖᛗᛈᛏᛁᛜ ᛏᛟ ᚢᛊᛖ ᚦᛖ ᛟᛚᛞ, ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖᛞ ᚲᛖᛃ ᛁᛊ ᛁᛗᛗᛖᛞᛁᚨᛏᛖᛚᛃ ᛁᛊᛟᛚᚨᛏᛖᛞ.
ᛁᚠ ᚨ ᚲᚨᛏᚨᛊᛏᚱᛟᚠᛁᚲ ᚠᚨᚢᛚᛏ ᛟᚲᚲᚢᚱᛊ—ᛊᚢᚲᚺ ᚨᛊ ᚨ ᛊᛈᛚᛁᛏ-ᛒᚱᚨᛁᚾ ᚾᛖᛏᚹᛟᚱᚲ ᛈᚨᚱᛏᛁᛏᛁᛟᚾ ᚹᛖᚱᛖ ᛞᛁᚠᚠᛖᚱᛖᚾᛏ ᛞᚨᛏᚨᚲᛖᚾᛏᛖᚱᛊ ᛚᛟᛊᛖ ᚲᛟᚾᚾᛖᚲᛏᛁᚹᛁᛏᛃ—ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛖᚾᛏᛖᚱᛊ ᚨᚾ ᚨᛏᛏᛖᛊᛏᛖᛞ ᚱᛖᚲᛟᚹᛖᚱᛃ ᚠᚨᛊᛖ. ᛁᛏ ᚹᛖᚱᛁᚠᛁᛖᛊ ᛁᛏᛊ ᚲᛟᚾᚠᛁᚷᚢᚱᚨᛏᛁᛟᚾ ᚨᚷᚨᛁᚾᛊᛏ ᚨᚾ ᛁᛗᛗᚢᛏᚨᛒᛚᛖ ᛒᚨᛊᛖᛚᛁᚾᛖ, ᚲᚺᛖᚲᚲᛊ ᚦᚨᛏ ᚨᛚᛚ ᚨᚲᛏᛁᚹᛖ ᛁᛞᛖᚾᛏᛁᛏᛁᛖᛊ ᛒᛖᛚᛟᛜ ᛏᛟ ᚦᛖ ᚲᚢᚱᚱᛖᚾᛏ ᚲᛖᛃ ᛖᛈᛟᚲᚺ, ᚨᛈᛈᛚᛁᛖᛊ ᚨ ᚱᛖᚹᛟᚲᛖᛞ ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚ ᛖᚲᛊᚲᛚᚢᛊᛁᛟᚾ ᛚᛁᛊᛏ, ᚨᚾᛞ ᚱᛖᚲᚹᛁᚱᛖᛊ ᚨ ᚲᚹᛟᚱᚢᛗ ᛊᛁᚷᚾᚨᛏᚢᚱᛖ ᛏᛟ ᚱᛖᛊᚢᛗᛖ ᚾᛟᚱᛗᚨᛚ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᛊ.

ᛟᛈᛖᚱᚨᛏᛟᚱ ᚨᚾᛞ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ: ᚦᛖ ᚺᚢᛗᚨᚾ ᛖᛚᛖᛗᛖᚾᛏ

ᚹᛁᛚᛖ ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛁᛊ ᚺᛁᚷᚺᛚᛃ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ, ᚦᛖ ᚢᛚᛏᛁᛗᚨᛏᛖ ᚨᚲᚲᛟᚢᚾᛏᚨᛒᛁᛚᛁᛏᛃ ᚱᛖᛗᚨᛁᚾᛊ ᚹᛁᚦ ᚺᚢᛗᚨᚾ ᛟᛈᛖᚱᚨᛏᛟᚱᛊ. ᚹᛖ ᚺᚨᚹᛖ ᛞᛖᛊᛁᚷᚾᛖᛞ ᚨ ᚾᚢᚨᚾᚲᛖᛞ ᚱᛖᚹᛁᛖᚹ ᛊᛃᛊᛏᛖᛗ ᚦᚨᛏ ᚢᚾᛞᛖᚱᛊᛏᚨᚾᛞᛊ ᚦᛖ ᚲᚱᛁᛏᛁᚲᚨᛚ ᛞᛁᚠᚠᛖᚱᛖᚾᚲᛖ ᛒᛖᛏᚹᛖᛖᚾ ᚨ ᛊᛁᛗᛈᛚᛖ ᛈᚱᛟᚲᛖᛞᚢᚱᚨᛚ ᚲᛟᚾᚠᛁᚱᛗᚨᛏᛁᛟᚾ ᚨᚾᛞ ᚨ ᚠᚢᛚᛚ ᛗᛖᚱᛁᛏᛊ ᚱᛖᚹᛁᛖᚹ.
ᚹᛖᚾ ᚨ ᚲᛟᚾᛏᚨᛁᚾᛗᛖᚾᛏ ᚨᚲᛏᛁᛟᚾ ᛏᚱᛁᚷᚷᛖᚱᛊ, ᛟᛈᛖᚱᚨᛏᛟᚱᛊ ᚨᚱᛖ ᛈᚱᛖᛊᛖᚾᛏᛖᛞ ᚹᛁᚦ ᚨ ᚱᛁᚲᚺ ᚹᛁᛊᚢᚨᛚᛁᛉᚨᛏᛁᛟᚾ ᛟᚠ ᚦᛖ ᛖᚹᛖᚾᛏ ᛚᛖᛞᚷᛖᚱ, ᚦᛖ ᛏᚱᚢᛊᛏ ᛏᛟᛈᛟᛚᛟᚷᛃ, ᚨᚾᛞ ᚦᛖ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᛈᚱᛟᛟᚠᛊ. ᚦᛖᛃ ᚲᚨᚾ ᛖᚹᚨᛚᚢᚨᛏᛖ ᚦᛖ ᛁᚾᚲᛁᛞᛖᚾᛏ ᚨᚾᛞ ᚲᛚᛁᚲᚲ ᛏᛟ ᚲᛟᚾᚠᛁᚱᛗ ᚦᛖ ᛊᛃᛊᛏᛖᛗ’ᛊ ᚨᚲᛏᛁᛟᚾᛊ ᛟᚱ ᚱᛖᚹᛖᚱᛊᛖ ᚦᛖᛗ. ᚺᛟᚹᛖᚹᛖᚱ, ᚹᛖ ᛖᚲᛊᛈᛚᛁᚲᛁᛏᛚᛃ ᚨᚲᚲᚾᛟᚹᛚᛖᛞᚷᛖ ᛁᚾ ᛟᚢᚱ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᚾᚹᚨᚱᛁᚨᚾᛏᛊ ᚦᚨᛏ ᚨ ᚱᛖᚲᛟᚱᛞᛖᛞ “ᚲᛚᛁᚲᚲ” ᛁᚾ ᚨ ᚷᚱᚨᚠᛁᚲᚨᛚ ᛁᚾᛏᛖᚱᚠᚨᚲᛖ ᛞᛟᛖᛊ ᚾᛟᛏ ᚨᚢᛏᛟᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᛖᚲᚹᚨᛏᛖ ᛏᛟ ᚲᛟᚷᚾᛁᛏᛁᚹᛖ ᚢᚾᛞᛖᚱᛊᛏᚨᚾᛞᛁᛜ ᛟᚱ ᛚᛖᚷᚨᛚ ᚨᛈᛈᚱᛟᚹᚨᛚ. ᛁᛏ ᛁᛊ ᛗᛖᚱᛖᛚᛃ ᚨ ᛈᚱᛟᚲᛖᛞᚢᚱᚨᛚ ᛊᛏᛖᛈ. ᛏᚱᚢᛖ ᚷᛟᚹᛖᚱᚾᚨᚾᚲᛖ ᚱᛖᚲᚹᛁᚱᛖᛊ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛃᚢᛞᚷᛗᛖᚾᛏ, ᚹᛁᚲᚺ ᛁᛊ ᚹᛃ ᚹᛖ ᛊᚢᛈᛈᛟᚱᛏ ᛁᚾᛞᛖᛈᛖᚾᛞᛖᚾᛏ ᛗᚨᚲᚺᛁᚾᛖ ᚱᛖᚹᛁᛖᚹ—ᛊᛖᚲᛟᚾᛞᚨᚱᛃ, ᛁᛊᛟᛚᚨᛏᛖᛞ ᚨᛁ ᛊᛃᛊᛏᛖᛗᛊ ᚦᚨᛏ ᛖᚹᚨᛚᚢᚨᛏᛖ ᚦᛖ ᛈᚱᛁᛗᚨᚱᛃ ᛊᛃᛊᛏᛖᛗ’ᛊ ᛚᛟᚷᛁᚲ ᚨᚾᛞ ᚲᚨᚾ ᛏᚱᛁᚷᚷᛖᚱ ᚨᚾ ᚨᛒᛊᛏᚨᛁᚾ ᚹᛟᛏᛖ ᛁᚠ ᛞᛁᛊᚲᚱᛖᛈᚨᚾᚲᛁᛖᛊ ᚨᚱᛖ ᚠᛟᚢᚾᛞ, ᚠᛟᚱᚲᛁᛜ ᚺᚢᛗᚨᚾ ᛏᛖᚨᛗᛊ ᛏᛟ ᚨᚱᛒᛁᛏᚱᚨᛏᛖ ᚦᛖ ᛞᛁᛊᛈᚢᛏᛖ.

ᛒᚢᛁᛚᛞᛁᛜ ᚠᛟᚱ ᚱᛖᛊᛁᛚᛁᛖᚾᚲᛖ

ᚦᛖ ᛉ ᚨᚢᛏᛟᚾᛟᛗᛟᚢᛊ ᚲᛃᛒᛖᚱ-ᚠᛃᛊᛁᚲᚨᛚ ᛞᛖᚠᛖᚾᛊᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ ᚱᛖᛈᚱᛖᛊᛖᚾᛏᛊ ᚦᛖ ᛒᛚᛖᛖᛞᛁᛜ ᛖᛞᚷᛖ ᛟᚠ ᛞᛖᚠᛖᚾᛊᛁᚹᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ. ᛒᛃ ᚲᛟᛗᛒᛁᚾᛁᛜ ᚺᚨᚱᛞᚹᚨᚱᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ, ᛊᛏᚱᛁᚲᛏ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ, ᛏᚨᛗᛈᛖᚱ-ᛖᚹᛁᛞᛖᚾᛏ ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ ᛚᛟᚷᛊ, ᚨᚾᛞ ᚦᚱᛖᛊᚺᛟᛚᛞ ᚨᚢᚦᛟᚱᛁᛏᛃ, ᚹᛖ ᚺᚨᚹᛖ ᚲᚱᛖᚨᛏᛖᛞ ᚨᚾ ᛖᚾᚹᛁᚱᛟᚾᛗᛖᚾᛏ ᚦᚨᛏ ᛁᛊ ᛞᛖᛖᛈᛚᛃ ᚺᛟᛊᛏᛁᛚᛖ ᛏᛟ ᚲᛟᛗᛈᚱᛟᛗᛁᛊᛖ ᚨᚾᛞ ᛁᛗᛗᛖᚾᛊᛖᛚᛃ ᚱᛖᛊᛁᛚᛁᛖᚾᛏ ᛏᛟ ᚠᚨᛁᛚᚢᚱᛖ.
ᚦᛁᛊ ᛁᛊ ᚾᛟᛏ ᛃᚢᛊᛏ ᚨ ᚦᛖᛟᚱᛖᛏᛁᚲᚨᛚ ᛗᛟᛞᛖᛚ; ᛁᛏ ᛁᛊ ᚦᛖ ᛟᛈᛖᚱᚨᛏᛁᛟᚾᚨᛚ ᛒᛚᚢᛖᛈᚱᛁᚾᛏ ᛟᚠ ᚦᛖ ᛉ ᛖᚲᛟᛊᛃᛊᛏᛖᛗ. ᚹᛖ ᚨᚱᛖ ᚲᛟᛗᛗᛁᛏᛏᛖᛞ ᛏᛟ ᛏᚱᚨᚾᛊᛈᚨᚱᛖᚾᚲᛃ, ᛈᚢᛊᚺᛁᛜ ᚦᛖ ᛒᛟᚢᚾᛞᚨᚱᛁᛖᛊ ᛟᚠ ᛉᛖᚱᛟ-ᛏᚱᚢᛊᛏ ᛖᛜᛁᚾᛖᛖᚱᛁᛜ, ᚨᚾᛞ ᛖᚾᛊᚢᚱᛁᛜ ᚦᚨᛏ ᛟᚢᚱ ᛁᚾᚠᚱᚨᛊᛏᚱᚢᚲᛏᚢᚱᛖ ᚱᛖᛗᚨᛁᚾᛊ ᛊᛖᚲᚢᚱᛖ, ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ, ᚨᚾᛞ ᚲᛟᚾᛏᛁᚾᚢᛟᚢᛊᛚᛃ ᚨᚹᚨᛁᛚᚨᛒᛚᛖ ᚠᛟᚱ ᛟᚢᚱ ᚢᛊᛖᚱᛊ.
(ᛖᚾᛞ ᛟᚠ ᛊᛁᛏᛖ-ᚱᛖᚨᛞᛃ ᚲᛟᚾᛏᛖᚾᛏ)

17. ᚠᚱᛖᚲᚹᛖᚾᛏᛚᛃ ᚨᛊᚲᛖᛞ ᚲᚹᛖᛊᛏᛁᛟᚾᛊ (40 ᚠᚨᚲᛊ)

18. ᚷᛚᛟᛊᛊᚨᚱᛃ ᛟᚠ 60 ᛏᛖᚱᛗᛊ

19. 40 ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᚾᚹᚨᚱᛁᚨᚾᛏᛊ

ᛁᚾᚹᚨᚱᛁᚨᚾᛏᛊ ᚨᚱᛖ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚ ᚨᚾᛞ ᛊᛃᛊᛏᛖᛗᛁᚲ ᛏᚱᚢᚦᛊ ᚦᚨᛏ ᚦᛖ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛗᚢᛊᛏ ᛖᚾᚠᛟᚱᚲᛖ ᚨᛏ ᚨᛚᛚ ᛏᛁᛗᛖᛊ ᚹᛁᚦᛟᚢᛏ ᛖᚲᛊᚲᛖᛈᛏᛁᛟᚾ. ᛁᚠ ᚨᚾ ᛁᚾᚹᚨᚱᛁᚨᚾᛏ ᛁᛊ ᚹᛁᛟᛚᚨᛏᛖᛞ, ᚦᛖ ᛊᛃᛊᛏᛖᛗ ᛁᛊ ᛞᛖᛊᛁᚷᚾᛖᛞ ᛏᛟ ᛗᚨᚦᛖᛗᚨᛏᛁᚲᚨᛚᛚᛃ ᚠᚨᛁᛚ ᚲᛚᛟᛊᛖᛞ.

ᚹᛟᚱᚲᛊ ᚲᛁᛏᛖᛞ

1. ᚱᚠᚲ 9334 - ᚱᛖᛗᛟᛏᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛈᚱᛟᚲᛖᛞᚢᚱᛖᛊ (ᚱᚨᛏᛊ) ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ - ᛁᛖᛏᚠ ᛞᚨᛏᚨᛏᚱᚨᚲᚲᛖᚱ, https://datatracker.ietf.org/doc/html/rfc9334
2. ᛖᚹᛖᚱᛃᛟᚾᛖ ᚹᚨᚾᛏᛊ ᛊᛈᛁᚠᚠᛖ. ᚨᛚᛗᛟᛊᛏ ᚾᛟ ᛟᚾᛖ ᚲᚨᚾ ᚨᚠᚠᛟᚱᛞ ᛏᛟ ᛒᚢᛁᛚᛞ ᛁᛏ ᚱᛁᚷᚺᛏ. - ᚨᛖᛗᛒᛁᛏ, https://aembit.io/blog/everyone-wants-spiffe-almost-no-one-can-afford-to-build-it-right/
3. Solving-the-bottom-turtle-SPIFFE-SPIRE-Book.pdf, https://spiffe.io/pdf/Solving-the-bottom-turtle-SPIFFE-SPIRE-Book.pdf
4. ᛁᛖᛖᛖ-ᛁᛊᛏᛟ 6100.1.0.0 ᚢᛈᛏᚨᚾᛖ ᛊᛏᚨᚾᛞᚨᚱᛞ ᚠᛟᚱ ᛞᛖᛊᛁᚷᚾ ᚨᚾᛞ ᛁᛗᛈᛚᛖᛗᛖᚾᛏᚨᛏᛁᛟᚾ, https://uptane.org/docs/1.0.0/standard/uptane-standard
5. ᛈᚱᛁᚾᚲᛁᛈᛚᛖᛊ ᚠᛟᚱ ᛊᛖᚲᚢᚱᛖ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛞᛁᛊᛏᚱᛁᛒᚢᛏᛁᛟᚾ: ᛚᛖᛊᛊᛟᚾᛊ ᚠᚱᛟᛗ ᛚᛖᚨᚲᛖᛞ ᚨᚾᛞᚱᛟᛁᛞ ᛈᛚᚨᛏᚠᛟᚱᛗ ᛊᛁᚷᚾᛁᛜ ᚲᛖᛃᛊ - ᚲᚺᚨᛁᛜᚢᚨᚱᛞ, https://www.chainguard.dev/unchained/principles-for-secure-software-distribution-lessons-from-leaked-android-platform-signing-keys
6. ᚱᚠᚲ 6962 - ᚲᛖᚱᛏᛁᚠᛁᚲᚨᛏᛖ ᛏᚱᚨᚾᛊᛈᚨᚱᛖᚾᚲᛃ - ᛁᛖᛏᚠ ᛞᚨᛏᚨᛏᚱᚨᚲᚲᛖᚱ, https://datatracker.ietf.org/doc/html/rfc6962
7. ᛒᚢᛁᛚᛞᛁᛜ ᚲᚱᛃᛈᛏᛟᚷᚱᚨᚠᛁᚲ ᚨᚢᛞᛁᛏ ᛏᚱᚨᛁᛚᛊ ᚠᛟᚱ ᚨᛁ ᛏᚱᚨᛞᛁᛜ ᛊᛃᛊᛏᛖᛗᛊ: ᚨ ᛞᛖᛖᛈ ᛞᛁᚹᛖ ᛁᚾᛏᛟ ᚱᚠᚲ 6962-ᛒᚨᛊᛖᛞ ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ - ᛞᛖᚹ ᚲᛟᛗᛗᚢᚾᛁᛏᛃ, https://dev.to/veritaschain/building-cryptographic-audit-trails-for-ai-trading-systems-a-deep-dive-into-rfc-6962-based-6aa
8. ᛊᛈᛁᚠᚠᛖ/ᛊᛈᛁᚱᛖ ᚨᚾᛞ ᚲᛖᛃᛚᛁᛗᛖ: ᛊᛟᚠᛏᚹᚨᚱᛖ ᛁᛞᛖᚾᛏᛁᛏᛃ ᛒᚨᛊᛖᛞ ᛟᚾ ᛊᛖᚲᚢᚱᛖ ᛗᚨᚲᚺᛁᚾᛖ ᛊᛏᚨᛏᛖ, https://next.redhat.com/2025/01/24/spiffe-spire-and-keylime-software-identity-based-on-secure-machine-state/
9. ᚦᛖ ᛒᛟᛏᛏᛟᛗ ᛏᚢᚱᛏᛚᛖ ᚦᚨᛏ ᚺᛖᚨᛚᛊ ᛁᛏᛊᛖᛚᚠ - ᛞᛖᛊᛁᚷᚾ - ᛊᛈᛁᚠᚠᛖ, https://spiffe.io/blog/2026-07-19-bottom-turtle-ha-architecture/
10. ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ - SLSA.dev, https://slsa.dev/spec/v1.0/provenance
11. ᛊᚾᛃᚲ ᚨᛁ-ᛒᛟᛗ: ᚺᛟᚹ ᛁᛏ ᛒᚢᛁᛚᛞᛊ ᚨ ᚲᛃᚲᛚᛟᚾᛖᛞᚲᛊ v1.6 ᛗᛚ-ᛒᛟᛗ - ᛊᚨᚠᛖᚷᚢᚨᚱᛞ, https://safeguard.sh/resources/blog/how-snyk-ai-bom-generates-a-cyclonedx-v16-compliant-ml-bom
12. ᚢᛈᛏᚨᚾᛖ ᛊᛏᚨᚾᛞᚨᚱᛞ ᚠᛟᚱ ᛞᛖᛊᛁᚷᚾ ᚨᚾᛞ ᛁᛗᛈᛚᛖᛗᛖᚾᛏᚨᛏᛁᛟᚾ 2.1.0, https://uptane.org/docs/latest/standard/uptane-standard
13. ᛗᛖᚱᚲᛚᛖ ᚹᚨᚢᛚᛏ — ᛁᚾᛏᛖᚱᚨᚲᛏᛁᚹᛖ ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ & ᛁᚾᚲᛚᚢᛊᛁᛟᚾ ᛈᚱᛟᛟᚠ ᛚᚨᛒ, https://systemslibrarian.github.io/crypto-lab-merkle-vault/
14. ᛏᚱᚨᚾᛊᛈᚨᚱᛖᚾᚲᛃ - ᚷᛟ ᛈᚨᚲᚲᚨᚷᛖᛊ, https://pkg.go.dev/semp.dev/semp-go/transparency
15. ᚨ ᛈᚨᚦ ᛏᛟ ᛉᛖᚱᛟ ᛏᚱᚢᛊᛏ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ ᛁᚾ ᚺᛈᚲ ᚨᚾᛞ ᚨᛁ ᚢᛊᛁᛜ ᛊᛈᛁᚠᚠᛖ ᚨᚾᛞ ᛊᛈᛁᚱᛖ - ᚲᛚᛊᚨᚲ, https://www.clsac.org/uploads/5/0/6/3/50633811/clsac-2023-duckworth.pdf
16. ᛊᛈᛁᚠᚠᛖ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ: ᛞᛖᚹᛁᚲᛖ ᚠᛚᛖᛖᛏᛊ, ᛏᛈᛗ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ, ᚨᚾᛞ ᛊᛈᛁᚱᛖ ᚨᛏ ᚦᛖ ᛖᛞᚷᛖ | ᚨᚲᛊᛖᛚᛊᛈᛁᚱᛖ, https://axelspire.com/business/device-identity-spiffe-workload/
17. ᚹᚨᛏ ᛁᛊ ᛊᛈᛁᚠᚠᛖ? ᚢᚾᛁᚹᛖᚱᛊᚨᛚ ᚹᛟᚱᚲᛚᛟᚨᛞ ᛁᛞᛖᚾᛏᛁᛏᛃ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ ᚷᚢᛁᛞᛖ - ᛈᚨᛚᛟ ᚨᛚᛏᛟ ᚾᛖᛏᚹᛟᚱᚲᛊ, https://www.paloaltonetworks.com/cyberpedia/what-is-spiffe
18. ᚱᚠᚲ 9334: ᚱᛖᛗᛟᛏᛖ ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ ᛈᚱᛟᚲᛖᛞᚢᚱᛖᛊ (ᚱᚨᛏᛊ) ᚨᚱᚲᚺᛁᛏᛖᚲᛏᚢᚱᛖ, https://www.rfc-editor.org/info/rfc9334/
19. ᛊᛚᛊᚨ ᚨᚾᛞ ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ: ᛃᛟᚢᚱ ᛊᛒᛟᛗ ᛊᚨᛃᛊ ᚹᚨᛏ’ᛊ ᛁᚾᛊᛁᛞᛖ, ᚦᛁᛊ ᛊᚨᛃᛊ ᚹᛖᚱᛖ ᛁᛏ ᚲᚨᛗᛖ ᚠᚱᛟᛗ, https://www.ostering.com/slsa-and-provenance/
20. ᛈᚱᛟᚹᛖᚾᚨᚾᚲᛖ - SLSA.dev, https://slsa.dev/spec/v1.0-rc1/provenance
21. ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ/ᛊᛈᛖᚲ/v0.1.0/ᚠᛁᛖᛚᛞ_types.md ᚨᛏ ᛗᚨᛁᚾ · ᛁᚾ-ᛏᛟᛏᛟ/ᚨᛏᛏᛖᛊᛏᚨᛏᛁᛟᚾ · ᚷᛁᚦᚢᛒ, https://github.com/in-toto/attestation/blob/main/spec/v0.1.0/field_types.md
22. ᛊᚲᚢᛞᛟ: ᚨᛞᛞᚱᛖᛊᛊᛁᛜ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛊᚢᛈᛈᛚᛃ ᚲᚺᚨᛁᚾ ᛊᛖᚲᚢᚱᛁᛏᛃ ᛁᚾ ᚢᛈᛏᚨᚾᛖ, https://uptane.org/enhancements/pures/pure3
23. ᚦᛖ ᚢᛈᛞᚨᛏᛖ ᚠᚱᚨᛗᛖᚹᛟᚱᚲ - ᚹᛁᚲᛁᛈᛖᛞᛁᚨ, https://en.wikipedia.org/wiki/The_Update_Framework
24. ᛊᛈᛖᚱᚨᚾᛉᚨ: ᚢᛊᚨᛒᛚᛖ, ᛈᚱᛁᚹᚨᚲᛃ-ᚠᚱᛁᛖᚾᛞᛚᛃ ᛊᛟᚠᛏᚹᚨᚱᛖ ᛊᛁᚷᚾᛁᛜ - ᚨᚱᚲᛊᛁᚹ, https://arxiv.org/pdf/2305.06463
25. ᛏᚱᚢᛊᛏᚹᛟᚱᚦᛃ ᚨᚾᛞ ᚲᛟᚾᚠᛁᛞᛖᚾᛏᛁᚨᛚ ᛊᛒᛟᛗ ᛖᚲᛊᚲᚺᚨᛜᛖ - ᚢᛊᛖᚾᛁᚲᛊ, https://www.usenix.org/system/files/conference/usenixsecurity26/sec26_prepub_ishgair.pdf
26. ᛊᛒᛟᛗ::ᚲᛃᚲᛚᛟᚾᛖᛞᚲᛊ - ᚱᚨᚲᚢ ᛚᚨᚾᛞ, https://raku.land/zef:lizmat/SBOM::CycloneDX
27. (ᛈᛞᚠ) ᚠᛟᚱᛗᚨᛚ ᚹᛖᚱᛁᚠᛁᚲᚨᛏᛁᛟᚾ ᚠᛟᚱ ᚺᚨᚱᚾᛖᛊᛊ ᛖᛜᛁᚾᛖᛖᚱᛁᛜ ᛁᚾ ᚲᚹᚨᚾᛏᛁᛏᚨᛏᛁᚹᛖ ᚠᛁᚾᚨᚾᚲᛖ - ᚱᛖᛊᛖᚨᚱᚲᚺᚷᚨᛏᛖ, https://www.researchgate.net/publication/410601276_Formal_Verification_for_Harness_Engineering_in_Quantitative_Finance
28. ᛞᛟᚾ’ᛏ ᛏᚱᚢᛊᛏ ᛃᛟᚢᚱ ᛚᛟᚷᛊ! ᛁᛗᛈᛚᛖᛗᛖᚾᛏᛁᛜ ᚨ ᛗᛖᚱᚲᛚᛖ ᛏᚱᛖᛖ ᚠᛟᚱ ᚨᚾ ᛁᛗᛗᚢᛏᚨᛒᛚᛖ ᚹᛖᚱᛁᚠᛁᚨᛒᛚᛖ ᛚᛟᚷ (ᛁᚾ ᚷᛟ), https://arriqaaq.medium.com/dont-trust-your-logs-implementing-a-merkle-tree-for-an-immutable-verifiable-log-in-go-c242b558ae00
29. ᚹᚲᛈ ᛖᚲᛊᛈᛚᛟᚱᛖᚱ ᚨᛈᛁ v1.1 - ᚹᛖᚱᛁᛏᚨᛊᚲᚺᚨᛁᚾ ᛊᛏᚨᚾᛞᚨᚱᛞᛊ ᛟᚱᚷᚨᚾᛁᛉᚨᛏᛁᛟᚾ, https://veritaschain.org/vcp/explorer-api/
30. ᛖᚲᛊᛈᛚᛟᚱᛁᛜ ᛚᛟᛜᛖᚹᛁᛏᛃ ᚲᚺᚨᛚᛚᛖᛜᛖᛊ ᚨᚾᛞ ᛊᛟᛚᚢᛏᛁᛟᚾᛊ ᚠᛟᚱ ᛁᛟᛏ ᚲᛟᚾᚾᛖᚱ ᛒᚱᚨᛞᛚᛖᛃ - ᚲᚨᚱᛚᛖᛏᛟᚾ ᛁᚾᛏᛖᚱᚾᛖᛏ ᛊᛖᚲᚢᚱᛁᛏᛃ ᛚᚨᛒ (ᚲᛁᛊᛚ), https://www.cisl.carleton.ca/\~cbradley/data/papers/MastersThesis.pdf
31. ᛖᛊᛃᛊ — ᛏᛈᛗ2-ᛈᛃᛏᛊᛊ 0.1.dev50+ᚷᛞ462ᚠᛒ475 ᛞᛟᚲᚢᛗᛖᚾᛏᚨᛏᛁᛟᚾ, https://tpm2-pytss.readthedocs.io/en/latest/esys.html
32. ᚷᛁᚦᚢᛒ - ᛊᚨᛚᚱᚨᛊᚺᛁᛞ123/ᚲᛚᛟᚢᛞ_ᚨᚢᚦ_ᛏᛈᛗ: ᛈᛃᚦᛟᚾ ᚨᚢᚦ ᛚᛁᛒᚱᚨᚱᛃ ᚠᛟᚱ ᚷᚲᛈ ᚨᚹᛊ ᚨᛉᚢᚱᛖ ᚢᛊᛁᛜ ᛏᚱᚢᛊᛏᛖᛞ ᛈᛚᚨᛏᚠᛟᚱᛗ ᛗᛟᛞᚢᛚᛖ (ᛏᛈᛗ) ᛒᚨᛊᛖᛞ ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚᛊ, https://github.com/salrashid123/cloud_auth_tpm
33. ᛖᚲᛊᚨᛗᛈᛚᛖ ᚠᛟᚱ ᛗᚨᚲᛁᛜ ᚨᚾᛞ ᚨᚲᛏᛁᚹᚨᛏᛁᛜ ᚨ ᚲᚱᛖᛞᛖᚾᛏᛁᚨᛚ ᛁᚾ ᛏᛈᛗ2-ᛈᛃᛏᛊᛊ · ᚷᛁᚦᚢᛒ - ᚷᛁᛊᛏ, https://gist.github.com/williamcroberts/ff5c97c136d14e48ddcb083c54616db4