Merge branch 'release/debian/1.4.2-1'HEADdebian/1.4.2-1master

39 files changed, 939 insertions, 904 deletions

diff --git a/tests/uninorm/NormalizationTest.txt b/tests/uninorm/NormalizationTest.txt
index bfe70f28..4dc33168 100644
--- a/tests/uninorm/NormalizationTest.txt
+++ b/tests/uninorm/NormalizationTest.txt
@@ -38,9 +38,9 @@
 # dealings in these Data Files or Software without prior written
 # authorization of the copyright holder.
 
-# NormalizationTest-16.0.0.txt
-# Date: 2024-04-30, 21:48:23 GMT
-# © 2024 Unicode®, Inc.
+# NormalizationTest-17.0.0.txt
+# Date: 2025-06-30, 06:16:16 GMT
+# © 2025 Unicode®, Inc.
 # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
 # For terms of use and license, see https://www.unicode.org/terms_of_use.html
 #
@@ -2469,6 +2469,7 @@ FEFA 0334;FEFA 0334;FEFA 0334;0644 0625 0334;0644 0627 0334 0655; # (ﻺ◌̴; �
 A69C;A69C;A69C;044A;044A; # (ꚜ; ꚜ; ꚜ; ъ; ъ; ) MODIFIER LETTER CYRILLIC HARD SIGN
 A69D;A69D;A69D;044C;044C; # (ꚝ; ꚝ; ꚝ; ь; ь; ) MODIFIER LETTER CYRILLIC SOFT SIGN
 A770;A770;A770;A76F;A76F; # (ꝰ; ꝰ; ꝰ; ꝯ; ꝯ; ) MODIFIER LETTER US
+A7F1;A7F1;A7F1;0053;0053; # (꟱; ꟱; ꟱; S; S; ) MODIFIER LETTER CAPITAL S
 A7F2;A7F2;A7F2;0043;0043; # (ꟲ; ꟲ; ꟲ; C; C; ) MODIFIER LETTER CAPITAL C
 A7F3;A7F3;A7F3;0046;0046; # (ꟳ; ꟳ; ꟳ; F; F; ) MODIFIER LETTER CAPITAL F
 A7F4;A7F4;A7F4;0051;0051; # (ꟴ; ꟴ; ꟴ; Q; Q; ) MODIFIER LETTER CAPITAL Q
@@ -18138,6 +18139,60 @@ FFEE;FFEE;FFEE;25CB;25CB; # (￮; ￮; ￮; ○; ○; ) HALFWIDTH WHITE CIRCLE
 0061 1ACD 0315 0300 05AE 0062;0061 05AE 1ACD 0300 0315 0062;0061 05AE 1ACD 0300 0315 0062;0061 05AE 1ACD 0300 0315 0062;0061 05AE 1ACD 0300 0315 0062; # (a◌ᫍ◌̕◌̀◌֮b; a◌֮◌ᫍ◌̀◌̕b; a◌֮◌ᫍ◌̀◌̕b; a◌֮◌ᫍ◌̀◌̕b; a◌֮◌ᫍ◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING LATIN SMALL LETTER INSULAR R, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
 0061 0315 0300 05AE 1ACE 0062;00E0 05AE 1ACE 0315 0062;0061 05AE 0300 1ACE 0315 0062;00E0 05AE 1ACE 0315 0062;0061 05AE 0300 1ACE 0315 0062; # (a◌̕◌̀◌֮◌ᫎb; à◌֮◌ᫎ◌̕b; a◌֮◌̀◌ᫎ◌̕b; à◌֮◌ᫎ◌̕b; a◌֮◌̀◌ᫎ◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING LATIN SMALL LETTER INSULAR T, LATIN SMALL LETTER B
 0061 1ACE 0315 0300 05AE 0062;0061 05AE 1ACE 0300 0315 0062;0061 05AE 1ACE 0300 0315 0062;0061 05AE 1ACE 0300 0315 0062;0061 05AE 1ACE 0300 0315 0062; # (a◌ᫎ◌̕◌̀◌֮b; a◌֮◌ᫎ◌̀◌̕b; a◌֮◌ᫎ◌̀◌̕b; a◌֮◌ᫎ◌̀◌̕b; a◌֮◌ᫎ◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING LATIN SMALL LETTER INSULAR T, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1ACF 0062;00E0 05AE 1ACF 0315 0062;0061 05AE 0300 1ACF 0315 0062;00E0 05AE 1ACF 0315 0062;0061 05AE 0300 1ACF 0315 0062; # (a◌̕◌̀◌֮◌᫏b; à◌֮◌᫏◌̕b; a◌֮◌̀◌᫏◌̕b; à◌֮◌᫏◌̕b; a◌֮◌̀◌᫏◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING DOUBLE CARON, LATIN SMALL LETTER B
+0061 1ACF 0315 0300 05AE 0062;0061 05AE 1ACF 0300 0315 0062;0061 05AE 1ACF 0300 0315 0062;0061 05AE 1ACF 0300 0315 0062;0061 05AE 1ACF 0300 0315 0062; # (a◌᫏◌̕◌̀◌֮b; a◌֮◌᫏◌̀◌̕b; a◌֮◌᫏◌̀◌̕b; a◌֮◌᫏◌̀◌̕b; a◌֮◌᫏◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING DOUBLE CARON, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD0 0062;00E0 05AE 1AD0 0315 0062;0061 05AE 0300 1AD0 0315 0062;00E0 05AE 1AD0 0315 0062;0061 05AE 0300 1AD0 0315 0062; # (a◌̕◌̀◌֮◌᫐b; à◌֮◌᫐◌̕b; a◌֮◌̀◌᫐◌̕b; à◌֮◌᫐◌̕b; a◌֮◌̀◌᫐◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING VERTICAL-LINE-ACUTE, LATIN SMALL LETTER B
+0061 1AD0 0315 0300 05AE 0062;0061 05AE 1AD0 0300 0315 0062;0061 05AE 1AD0 0300 0315 0062;0061 05AE 1AD0 0300 0315 0062;0061 05AE 1AD0 0300 0315 0062; # (a◌᫐◌̕◌̀◌֮b; a◌֮◌᫐◌̀◌̕b; a◌֮◌᫐◌̀◌̕b; a◌֮◌᫐◌̀◌̕b; a◌֮◌᫐◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING VERTICAL-LINE-ACUTE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD1 0062;00E0 05AE 1AD1 0315 0062;0061 05AE 0300 1AD1 0315 0062;00E0 05AE 1AD1 0315 0062;0061 05AE 0300 1AD1 0315 0062; # (a◌̕◌̀◌֮◌᫑b; à◌֮◌᫑◌̕b; a◌֮◌̀◌᫑◌̕b; à◌֮◌᫑◌̕b; a◌֮◌̀◌᫑◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING GRAVE-VERTICAL-LINE, LATIN SMALL LETTER B
+0061 1AD1 0315 0300 05AE 0062;0061 05AE 1AD1 0300 0315 0062;0061 05AE 1AD1 0300 0315 0062;0061 05AE 1AD1 0300 0315 0062;0061 05AE 1AD1 0300 0315 0062; # (a◌᫑◌̕◌̀◌֮b; a◌֮◌᫑◌̀◌̕b; a◌֮◌᫑◌̀◌̕b; a◌֮◌᫑◌̀◌̕b; a◌֮◌᫑◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING GRAVE-VERTICAL-LINE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD2 0062;00E0 05AE 1AD2 0315 0062;0061 05AE 0300 1AD2 0315 0062;00E0 05AE 1AD2 0315 0062;0061 05AE 0300 1AD2 0315 0062; # (a◌̕◌̀◌֮◌᫒b; à◌֮◌᫒◌̕b; a◌֮◌̀◌᫒◌̕b; à◌֮◌᫒◌̕b; a◌֮◌̀◌᫒◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING VERTICAL-LINE-GRAVE, LATIN SMALL LETTER B
+0061 1AD2 0315 0300 05AE 0062;0061 05AE 1AD2 0300 0315 0062;0061 05AE 1AD2 0300 0315 0062;0061 05AE 1AD2 0300 0315 0062;0061 05AE 1AD2 0300 0315 0062; # (a◌᫒◌̕◌̀◌֮b; a◌֮◌᫒◌̀◌̕b; a◌֮◌᫒◌̀◌̕b; a◌֮◌᫒◌̀◌̕b; a◌֮◌᫒◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING VERTICAL-LINE-GRAVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD3 0062;00E0 05AE 1AD3 0315 0062;0061 05AE 0300 1AD3 0315 0062;00E0 05AE 1AD3 0315 0062;0061 05AE 0300 1AD3 0315 0062; # (a◌̕◌̀◌֮◌᫓b; à◌֮◌᫓◌̕b; a◌֮◌̀◌᫓◌̕b; à◌֮◌᫓◌̕b; a◌֮◌̀◌᫓◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING ACUTE-VERTICAL-LINE, LATIN SMALL LETTER B
+0061 1AD3 0315 0300 05AE 0062;0061 05AE 1AD3 0300 0315 0062;0061 05AE 1AD3 0300 0315 0062;0061 05AE 1AD3 0300 0315 0062;0061 05AE 1AD3 0300 0315 0062; # (a◌᫓◌̕◌̀◌֮b; a◌֮◌᫓◌̀◌̕b; a◌֮◌᫓◌̀◌̕b; a◌֮◌᫓◌̀◌̕b; a◌֮◌᫓◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING ACUTE-VERTICAL-LINE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD4 0062;00E0 05AE 1AD4 0315 0062;0061 05AE 0300 1AD4 0315 0062;00E0 05AE 1AD4 0315 0062;0061 05AE 0300 1AD4 0315 0062; # (a◌̕◌̀◌֮◌᫔b; à◌֮◌᫔◌̕b; a◌֮◌̀◌᫔◌̕b; à◌֮◌᫔◌̕b; a◌֮◌̀◌᫔◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING VERTICAL-LINE-MACRON, LATIN SMALL LETTER B
+0061 1AD4 0315 0300 05AE 0062;0061 05AE 1AD4 0300 0315 0062;0061 05AE 1AD4 0300 0315 0062;0061 05AE 1AD4 0300 0315 0062;0061 05AE 1AD4 0300 0315 0062; # (a◌᫔◌̕◌̀◌֮b; a◌֮◌᫔◌̀◌̕b; a◌֮◌᫔◌̀◌̕b; a◌֮◌᫔◌̀◌̕b; a◌֮◌᫔◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING VERTICAL-LINE-MACRON, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD5 0062;00E0 05AE 1AD5 0315 0062;0061 05AE 0300 1AD5 0315 0062;00E0 05AE 1AD5 0315 0062;0061 05AE 0300 1AD5 0315 0062; # (a◌̕◌̀◌֮◌᫕b; à◌֮◌᫕◌̕b; a◌֮◌̀◌᫕◌̕b; à◌֮◌᫕◌̕b; a◌֮◌̀◌᫕◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING MACRON-VERTICAL-LINE, LATIN SMALL LETTER B
+0061 1AD5 0315 0300 05AE 0062;0061 05AE 1AD5 0300 0315 0062;0061 05AE 1AD5 0300 0315 0062;0061 05AE 1AD5 0300 0315 0062;0061 05AE 1AD5 0300 0315 0062; # (a◌᫕◌̕◌̀◌֮b; a◌֮◌᫕◌̀◌̕b; a◌֮◌᫕◌̀◌̕b; a◌֮◌᫕◌̀◌̕b; a◌֮◌᫕◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING MACRON-VERTICAL-LINE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD6 0062;00E0 05AE 1AD6 0315 0062;0061 05AE 0300 1AD6 0315 0062;00E0 05AE 1AD6 0315 0062;0061 05AE 0300 1AD6 0315 0062; # (a◌̕◌̀◌֮◌᫖b; à◌֮◌᫖◌̕b; a◌֮◌̀◌᫖◌̕b; à◌֮◌᫖◌̕b; a◌֮◌̀◌᫖◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING VERTICAL-LINE-ACUTE-GRAVE, LATIN SMALL LETTER B
+0061 1AD6 0315 0300 05AE 0062;0061 05AE 1AD6 0300 0315 0062;0061 05AE 1AD6 0300 0315 0062;0061 05AE 1AD6 0300 0315 0062;0061 05AE 1AD6 0300 0315 0062; # (a◌᫖◌̕◌̀◌֮b; a◌֮◌᫖◌̀◌̕b; a◌֮◌᫖◌̀◌̕b; a◌֮◌᫖◌̀◌̕b; a◌֮◌᫖◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING VERTICAL-LINE-ACUTE-GRAVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD7 0062;00E0 05AE 1AD7 0315 0062;0061 05AE 0300 1AD7 0315 0062;00E0 05AE 1AD7 0315 0062;0061 05AE 0300 1AD7 0315 0062; # (a◌̕◌̀◌֮◌᫗b; à◌֮◌᫗◌̕b; a◌֮◌̀◌᫗◌̕b; à◌֮◌᫗◌̕b; a◌֮◌̀◌᫗◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING VERTICAL-LINE-GRAVE-ACUTE, LATIN SMALL LETTER B
+0061 1AD7 0315 0300 05AE 0062;0061 05AE 1AD7 0300 0315 0062;0061 05AE 1AD7 0300 0315 0062;0061 05AE 1AD7 0300 0315 0062;0061 05AE 1AD7 0300 0315 0062; # (a◌᫗◌̕◌̀◌֮b; a◌֮◌᫗◌̀◌̕b; a◌֮◌᫗◌̀◌̕b; a◌֮◌᫗◌̀◌̕b; a◌֮◌᫗◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING VERTICAL-LINE-GRAVE-ACUTE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD8 0062;00E0 05AE 1AD8 0315 0062;0061 05AE 0300 1AD8 0315 0062;00E0 05AE 1AD8 0315 0062;0061 05AE 0300 1AD8 0315 0062; # (a◌̕◌̀◌֮◌᫘b; à◌֮◌᫘◌̕b; a◌֮◌̀◌᫘◌̕b; à◌֮◌᫘◌̕b; a◌֮◌̀◌᫘◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING MACRON-ACUTE-GRAVE, LATIN SMALL LETTER B
+0061 1AD8 0315 0300 05AE 0062;0061 05AE 1AD8 0300 0315 0062;0061 05AE 1AD8 0300 0315 0062;0061 05AE 1AD8 0300 0315 0062;0061 05AE 1AD8 0300 0315 0062; # (a◌᫘◌̕◌̀◌֮b; a◌֮◌᫘◌̀◌̕b; a◌֮◌᫘◌̀◌̕b; a◌֮◌᫘◌̀◌̕b; a◌֮◌᫘◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING MACRON-ACUTE-GRAVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AD9 0062;00E0 05AE 1AD9 0315 0062;0061 05AE 0300 1AD9 0315 0062;00E0 05AE 1AD9 0315 0062;0061 05AE 0300 1AD9 0315 0062; # (a◌̕◌̀◌֮◌᫙b; à◌֮◌᫙◌̕b; a◌֮◌̀◌᫙◌̕b; à◌֮◌᫙◌̕b; a◌֮◌̀◌᫙◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING SHARP SIGN, LATIN SMALL LETTER B
+0061 1AD9 0315 0300 05AE 0062;0061 05AE 1AD9 0300 0315 0062;0061 05AE 1AD9 0300 0315 0062;0061 05AE 1AD9 0300 0315 0062;0061 05AE 1AD9 0300 0315 0062; # (a◌᫙◌̕◌̀◌֮b; a◌֮◌᫙◌̀◌̕b; a◌֮◌᫙◌̀◌̕b; a◌֮◌᫙◌̀◌̕b; a◌֮◌᫙◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING SHARP SIGN, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1ADA 0062;00E0 05AE 1ADA 0315 0062;0061 05AE 0300 1ADA 0315 0062;00E0 05AE 1ADA 0315 0062;0061 05AE 0300 1ADA 0315 0062; # (a◌̕◌̀◌֮◌᫚b; à◌֮◌᫚◌̕b; a◌֮◌̀◌᫚◌̕b; à◌֮◌᫚◌̕b; a◌֮◌̀◌᫚◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING FLAT SIGN, LATIN SMALL LETTER B
+0061 1ADA 0315 0300 05AE 0062;0061 05AE 1ADA 0300 0315 0062;0061 05AE 1ADA 0300 0315 0062;0061 05AE 1ADA 0300 0315 0062;0061 05AE 1ADA 0300 0315 0062; # (a◌᫚◌̕◌̀◌֮b; a◌֮◌᫚◌̀◌̕b; a◌֮◌᫚◌̀◌̕b; a◌֮◌᫚◌̀◌̕b; a◌֮◌᫚◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING FLAT SIGN, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1ADB 0062;00E0 05AE 1ADB 0315 0062;0061 05AE 0300 1ADB 0315 0062;00E0 05AE 1ADB 0315 0062;0061 05AE 0300 1ADB 0315 0062; # (a◌̕◌̀◌֮◌᫛b; à◌֮◌᫛◌̕b; a◌֮◌̀◌᫛◌̕b; à◌֮◌᫛◌̕b; a◌֮◌̀◌᫛◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING DOWN TACK ABOVE, LATIN SMALL LETTER B
+0061 1ADB 0315 0300 05AE 0062;0061 05AE 1ADB 0300 0315 0062;0061 05AE 1ADB 0300 0315 0062;0061 05AE 1ADB 0300 0315 0062;0061 05AE 1ADB 0300 0315 0062; # (a◌᫛◌̕◌̀◌֮b; a◌֮◌᫛◌̀◌̕b; a◌֮◌᫛◌̀◌̕b; a◌֮◌᫛◌̀◌̕b; a◌֮◌᫛◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING DOWN TACK ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1ADC 0062;00E0 05AE 1ADC 0315 0062;0061 05AE 0300 1ADC 0315 0062;00E0 05AE 1ADC 0315 0062;0061 05AE 0300 1ADC 0315 0062; # (a◌̕◌̀◌֮◌᫜b; à◌֮◌᫜◌̕b; a◌֮◌̀◌᫜◌̕b; à◌֮◌᫜◌̕b; a◌֮◌̀◌᫜◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING DIAERESIS WITH RAISED LEFT DOT, LATIN SMALL LETTER B
+0061 1ADC 0315 0300 05AE 0062;0061 05AE 1ADC 0300 0315 0062;0061 05AE 1ADC 0300 0315 0062;0061 05AE 1ADC 0300 0315 0062;0061 05AE 1ADC 0300 0315 0062; # (a◌᫜◌̕◌̀◌֮b; a◌֮◌᫜◌̀◌̕b; a◌֮◌᫜◌̀◌̕b; a◌֮◌᫜◌̀◌̕b; a◌֮◌᫜◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING DIAERESIS WITH RAISED LEFT DOT, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 059A 0316 1DFA 1ADD 0062;0061 1DFA 0316 1ADD 059A 0062;0061 1DFA 0316 1ADD 059A 0062;0061 1DFA 0316 1ADD 059A 0062;0061 1DFA 0316 1ADD 059A 0062; # (a◌֚◌̖◌᷺◌᫝b; a◌᷺◌̖◌᫝◌֚b; a◌᷺◌̖◌᫝◌֚b; a◌᷺◌̖◌᫝◌֚b; a◌᷺◌̖◌᫝◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, COMBINING DOT-AND-RING BELOW, LATIN SMALL LETTER B
+0061 1ADD 059A 0316 1DFA 0062;0061 1DFA 1ADD 0316 059A 0062;0061 1DFA 1ADD 0316 059A 0062;0061 1DFA 1ADD 0316 059A 0062;0061 1DFA 1ADD 0316 059A 0062; # (a◌᫝◌֚◌̖◌᷺b; a◌᷺◌᫝◌̖◌֚b; a◌᷺◌᫝◌̖◌֚b; a◌᷺◌᫝◌̖◌֚b; a◌᷺◌᫝◌̖◌֚b; ) LATIN SMALL LETTER A, COMBINING DOT-AND-RING BELOW, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE0 0062;00E0 05AE 1AE0 0315 0062;0061 05AE 0300 1AE0 0315 0062;00E0 05AE 1AE0 0315 0062;0061 05AE 0300 1AE0 0315 0062; # (a◌̕◌̀◌֮◌᫠b; à◌֮◌᫠◌̕b; a◌֮◌̀◌᫠◌̕b; à◌֮◌᫠◌̕b; a◌֮◌̀◌᫠◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING LEFT TACK ABOVE, LATIN SMALL LETTER B
+0061 1AE0 0315 0300 05AE 0062;0061 05AE 1AE0 0300 0315 0062;0061 05AE 1AE0 0300 0315 0062;0061 05AE 1AE0 0300 0315 0062;0061 05AE 1AE0 0300 0315 0062; # (a◌᫠◌̕◌̀◌֮b; a◌֮◌᫠◌̀◌̕b; a◌֮◌᫠◌̀◌̕b; a◌֮◌᫠◌̀◌̕b; a◌֮◌᫠◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING LEFT TACK ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE1 0062;00E0 05AE 1AE1 0315 0062;0061 05AE 0300 1AE1 0315 0062;00E0 05AE 1AE1 0315 0062;0061 05AE 0300 1AE1 0315 0062; # (a◌̕◌̀◌֮◌᫡b; à◌֮◌᫡◌̕b; a◌֮◌̀◌᫡◌̕b; à◌֮◌᫡◌̕b; a◌֮◌̀◌᫡◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING RIGHT TACK ABOVE, LATIN SMALL LETTER B
+0061 1AE1 0315 0300 05AE 0062;0061 05AE 1AE1 0300 0315 0062;0061 05AE 1AE1 0300 0315 0062;0061 05AE 1AE1 0300 0315 0062;0061 05AE 1AE1 0300 0315 0062; # (a◌᫡◌̕◌̀◌֮b; a◌֮◌᫡◌̀◌̕b; a◌֮◌᫡◌̀◌̕b; a◌֮◌᫡◌̀◌̕b; a◌֮◌᫡◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING RIGHT TACK ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE2 0062;00E0 05AE 1AE2 0315 0062;0061 05AE 0300 1AE2 0315 0062;00E0 05AE 1AE2 0315 0062;0061 05AE 0300 1AE2 0315 0062; # (a◌̕◌̀◌֮◌᫢b; à◌֮◌᫢◌̕b; a◌֮◌̀◌᫢◌̕b; à◌֮◌᫢◌̕b; a◌֮◌̀◌᫢◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING MINUS SIGN ABOVE, LATIN SMALL LETTER B
+0061 1AE2 0315 0300 05AE 0062;0061 05AE 1AE2 0300 0315 0062;0061 05AE 1AE2 0300 0315 0062;0061 05AE 1AE2 0300 0315 0062;0061 05AE 1AE2 0300 0315 0062; # (a◌᫢◌̕◌̀◌֮b; a◌֮◌᫢◌̀◌̕b; a◌֮◌᫢◌̀◌̕b; a◌֮◌᫢◌̀◌̕b; a◌֮◌᫢◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING MINUS SIGN ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE3 0062;00E0 05AE 1AE3 0315 0062;0061 05AE 0300 1AE3 0315 0062;00E0 05AE 1AE3 0315 0062;0061 05AE 0300 1AE3 0315 0062; # (a◌̕◌̀◌֮◌᫣b; à◌֮◌᫣◌̕b; a◌֮◌̀◌᫣◌̕b; à◌֮◌᫣◌̕b; a◌֮◌̀◌᫣◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING INVERTED BRIDGE ABOVE, LATIN SMALL LETTER B
+0061 1AE3 0315 0300 05AE 0062;0061 05AE 1AE3 0300 0315 0062;0061 05AE 1AE3 0300 0315 0062;0061 05AE 1AE3 0300 0315 0062;0061 05AE 1AE3 0300 0315 0062; # (a◌᫣◌̕◌̀◌֮b; a◌֮◌᫣◌̀◌̕b; a◌֮◌᫣◌̀◌̕b; a◌֮◌᫣◌̀◌̕b; a◌֮◌᫣◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING INVERTED BRIDGE ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE4 0062;00E0 05AE 1AE4 0315 0062;0061 05AE 0300 1AE4 0315 0062;00E0 05AE 1AE4 0315 0062;0061 05AE 0300 1AE4 0315 0062; # (a◌̕◌̀◌֮◌᫤b; à◌֮◌᫤◌̕b; a◌֮◌̀◌᫤◌̕b; à◌֮◌᫤◌̕b; a◌֮◌̀◌᫤◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING SQUARE ABOVE, LATIN SMALL LETTER B
+0061 1AE4 0315 0300 05AE 0062;0061 05AE 1AE4 0300 0315 0062;0061 05AE 1AE4 0300 0315 0062;0061 05AE 1AE4 0300 0315 0062;0061 05AE 1AE4 0300 0315 0062; # (a◌᫤◌̕◌̀◌֮b; a◌֮◌᫤◌̀◌̕b; a◌֮◌᫤◌̀◌̕b; a◌֮◌᫤◌̀◌̕b; a◌֮◌᫤◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING SQUARE ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE5 0062;00E0 05AE 1AE5 0315 0062;0061 05AE 0300 1AE5 0315 0062;00E0 05AE 1AE5 0315 0062;0061 05AE 0300 1AE5 0315 0062; # (a◌̕◌̀◌֮◌᫥b; à◌֮◌᫥◌̕b; a◌֮◌̀◌᫥◌̕b; à◌֮◌᫥◌̕b; a◌֮◌̀◌᫥◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING SEAGULL ABOVE, LATIN SMALL LETTER B
+0061 1AE5 0315 0300 05AE 0062;0061 05AE 1AE5 0300 0315 0062;0061 05AE 1AE5 0300 0315 0062;0061 05AE 1AE5 0300 0315 0062;0061 05AE 1AE5 0300 0315 0062; # (a◌᫥◌̕◌̀◌֮b; a◌֮◌᫥◌̀◌̕b; a◌֮◌᫥◌̀◌̕b; a◌֮◌᫥◌̀◌̕b; a◌֮◌᫥◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING SEAGULL ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 059A 0316 1DFA 1AE6 0062;0061 1DFA 0316 1AE6 059A 0062;0061 1DFA 0316 1AE6 059A 0062;0061 1DFA 0316 1AE6 059A 0062;0061 1DFA 0316 1AE6 059A 0062; # (a◌֚◌̖◌᷺◌᫦b; a◌᷺◌̖◌᫦◌֚b; a◌᷺◌̖◌᫦◌֚b; a◌᷺◌̖◌᫦◌֚b; a◌᷺◌̖◌᫦◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, COMBINING DOUBLE ARCH BELOW, LATIN SMALL LETTER B
+0061 1AE6 059A 0316 1DFA 0062;0061 1DFA 1AE6 0316 059A 0062;0061 1DFA 1AE6 0316 059A 0062;0061 1DFA 1AE6 0316 059A 0062;0061 1DFA 1AE6 0316 059A 0062; # (a◌᫦◌֚◌̖◌᷺b; a◌᷺◌᫦◌̖◌֚b; a◌᷺◌᫦◌̖◌֚b; a◌᷺◌᫦◌̖◌֚b; a◌᷺◌᫦◌̖◌֚b; ) LATIN SMALL LETTER A, COMBINING DOUBLE ARCH BELOW, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE7 0062;00E0 05AE 1AE7 0315 0062;0061 05AE 0300 1AE7 0315 0062;00E0 05AE 1AE7 0315 0062;0061 05AE 0300 1AE7 0315 0062; # (a◌̕◌̀◌֮◌᫧b; à◌֮◌᫧◌̕b; a◌֮◌̀◌᫧◌̕b; à◌֮◌᫧◌̕b; a◌֮◌̀◌᫧◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING DOUBLE ARCH ABOVE, LATIN SMALL LETTER B
+0061 1AE7 0315 0300 05AE 0062;0061 05AE 1AE7 0300 0315 0062;0061 05AE 1AE7 0300 0315 0062;0061 05AE 1AE7 0300 0315 0062;0061 05AE 1AE7 0300 0315 0062; # (a◌᫧◌̕◌̀◌֮b; a◌֮◌᫧◌̀◌̕b; a◌֮◌᫧◌̀◌̕b; a◌֮◌᫧◌̀◌̕b; a◌֮◌᫧◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING DOUBLE ARCH ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE8 0062;00E0 05AE 1AE8 0315 0062;0061 05AE 0300 1AE8 0315 0062;00E0 05AE 1AE8 0315 0062;0061 05AE 0300 1AE8 0315 0062; # (a◌̕◌̀◌֮◌᫨b; à◌֮◌᫨◌̕b; a◌֮◌̀◌᫨◌̕b; à◌֮◌᫨◌̕b; a◌֮◌̀◌᫨◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING EQUALS SIGN ABOVE, LATIN SMALL LETTER B
+0061 1AE8 0315 0300 05AE 0062;0061 05AE 1AE8 0300 0315 0062;0061 05AE 1AE8 0300 0315 0062;0061 05AE 1AE8 0300 0315 0062;0061 05AE 1AE8 0300 0315 0062; # (a◌᫨◌̕◌̀◌֮b; a◌֮◌᫨◌̀◌̕b; a◌֮◌᫨◌̀◌̕b; a◌֮◌᫨◌̀◌̕b; a◌֮◌᫨◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING EQUALS SIGN ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AE9 0062;00E0 05AE 1AE9 0315 0062;0061 05AE 0300 1AE9 0315 0062;00E0 05AE 1AE9 0315 0062;0061 05AE 0300 1AE9 0315 0062; # (a◌̕◌̀◌֮◌᫩b; à◌֮◌᫩◌̕b; a◌֮◌̀◌᫩◌̕b; à◌֮◌᫩◌̕b; a◌֮◌̀◌᫩◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING LEFT ANGLE CENTRED ABOVE, LATIN SMALL LETTER B
+0061 1AE9 0315 0300 05AE 0062;0061 05AE 1AE9 0300 0315 0062;0061 05AE 1AE9 0300 0315 0062;0061 05AE 1AE9 0300 0315 0062;0061 05AE 1AE9 0300 0315 0062; # (a◌᫩◌̕◌̀◌֮b; a◌֮◌᫩◌̀◌̕b; a◌֮◌᫩◌̀◌̕b; a◌֮◌᫩◌̀◌̕b; a◌֮◌᫩◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING LEFT ANGLE CENTRED ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1AEA 0062;00E0 05AE 1AEA 0315 0062;0061 05AE 0300 1AEA 0315 0062;00E0 05AE 1AEA 0315 0062;0061 05AE 0300 1AEA 0315 0062; # (a◌̕◌̀◌֮◌᫪b; à◌֮◌᫪◌̕b; a◌֮◌̀◌᫪◌̕b; à◌֮◌᫪◌̕b; a◌֮◌̀◌᫪◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, COMBINING UPWARDS ARROW ABOVE, LATIN SMALL LETTER B
+0061 1AEA 0315 0300 05AE 0062;0061 05AE 1AEA 0300 0315 0062;0061 05AE 1AEA 0300 0315 0062;0061 05AE 1AEA 0300 0315 0062;0061 05AE 1AEA 0300 0315 0062; # (a◌᫪◌̕◌̀◌֮b; a◌֮◌᫪◌̀◌̕b; a◌֮◌᫪◌̀◌̕b; a◌֮◌᫪◌̀◌̕b; a◌֮◌᫪◌̀◌̕b; ) LATIN SMALL LETTER A, COMBINING UPWARDS ARROW ABOVE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0345 035D 035C 1AEB 0062;0061 035C 035D 1AEB 0345 0062;0061 035C 035D 1AEB 0345 0062;0061 035C 035D 1AEB 0345 0062;0061 035C 035D 1AEB 0345 0062; # (a◌ͅ◌͝◌͜◌᫫b; a◌͜◌͝◌᫫◌ͅb; a◌͜◌͝◌᫫◌ͅb; a◌͜◌͝◌᫫◌ͅb; a◌͜◌͝◌᫫◌ͅb; ) LATIN SMALL LETTER A, COMBINING GREEK YPOGEGRAMMENI, COMBINING DOUBLE BREVE, COMBINING DOUBLE BREVE BELOW, COMBINING DOUBLE RIGHTWARDS ARROW ABOVE, LATIN SMALL LETTER B
+0061 1AEB 0345 035D 035C 0062;0061 035C 1AEB 035D 0345 0062;0061 035C 1AEB 035D 0345 0062;0061 035C 1AEB 035D 0345 0062;0061 035C 1AEB 035D 0345 0062; # (a◌᫫◌ͅ◌͝◌͜b; a◌͜◌᫫◌͝◌ͅb; a◌͜◌᫫◌͝◌ͅb; a◌͜◌᫫◌͝◌ͅb; a◌͜◌᫫◌͝◌ͅb; ) LATIN SMALL LETTER A, COMBINING DOUBLE RIGHTWARDS ARROW ABOVE, COMBINING GREEK YPOGEGRAMMENI, COMBINING DOUBLE BREVE, COMBINING DOUBLE BREVE BELOW, LATIN SMALL LETTER B
 0061 3099 093C 16FF0 1B34 0062;0061 16FF0 093C 1B34 3099 0062;0061 16FF0 093C 1B34 3099 0062;0061 16FF0 093C 1B34 3099 0062;0061 16FF0 093C 1B34 3099 0062; # (a◌゙◌𖿰़◌᬴b; a𖿰◌़◌᬴◌゙b; a𖿰◌़◌᬴◌゙b; a𖿰◌़◌᬴◌゙b; a𖿰◌़◌᬴◌゙b; ) LATIN SMALL LETTER A, COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK, DEVANAGARI SIGN NUKTA, VIETNAMESE ALTERNATE READING MARK CA, BALINESE SIGN REREKAN, LATIN SMALL LETTER B
 0061 1B34 3099 093C 16FF0 0062;0061 16FF0 1B34 093C 3099 0062;0061 16FF0 1B34 093C 3099 0062;0061 16FF0 1B34 093C 3099 0062;0061 16FF0 1B34 093C 3099 0062; # (a◌᬴◌゙◌𖿰़b; a𖿰◌᬴◌़◌゙b; a𖿰◌᬴◌़◌゙b; a𖿰◌᬴◌़◌゙b; a𖿰◌᬴◌़◌゙b; ) LATIN SMALL LETTER A, BALINESE SIGN REREKAN, COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK, DEVANAGARI SIGN NUKTA, VIETNAMESE ALTERNATE READING MARK CA, LATIN SMALL LETTER B
 0061 05B0 094D 3099 1B44 0062;0061 3099 094D 1B44 05B0 0062;0061 3099 094D 1B44 05B0 0062;0061 3099 094D 1B44 05B0 0062;0061 3099 094D 1B44 05B0 0062; # (a◌ְ◌्◌゙᭄b; a◌゙◌्᭄◌ְb; a◌゙◌्᭄◌ְb; a◌゙◌्᭄◌ְb; a◌゙◌्᭄◌ְb; ) LATIN SMALL LETTER A, HEBREW POINT SHEVA, DEVANAGARI SIGN VIRAMA, COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK, BALINESE ADEG ADEG, LATIN SMALL LETTER B
@@ -18686,6 +18741,10 @@ FFEE;FFEE;FFEE;25CB;25CB; # (￮; ￮; ￮; ○; ○; ) HALFWIDTH WHITE CIRCLE
 0061 10EAB 0315 0300 05AE 0062;0061 05AE 10EAB 0300 0315 0062;0061 05AE 10EAB 0300 0315 0062;0061 05AE 10EAB 0300 0315 0062;0061 05AE 10EAB 0300 0315 0062; # (a◌𐺫◌̕◌̀◌֮b; a◌֮◌𐺫◌̀◌̕b; a◌֮◌𐺫◌̀◌̕b; a◌֮◌𐺫◌̀◌̕b; a◌֮◌𐺫◌̀◌̕b; ) LATIN SMALL LETTER A, YEZIDI COMBINING HAMZA MARK, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
 0061 0315 0300 05AE 10EAC 0062;00E0 05AE 10EAC 0315 0062;0061 05AE 0300 10EAC 0315 0062;00E0 05AE 10EAC 0315 0062;0061 05AE 0300 10EAC 0315 0062; # (a◌̕◌̀◌֮◌𐺬b; à◌֮◌𐺬◌̕b; a◌֮◌̀◌𐺬◌̕b; à◌֮◌𐺬◌̕b; a◌֮◌̀◌𐺬◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, YEZIDI COMBINING MADDA MARK, LATIN SMALL LETTER B
 0061 10EAC 0315 0300 05AE 0062;0061 05AE 10EAC 0300 0315 0062;0061 05AE 10EAC 0300 0315 0062;0061 05AE 10EAC 0300 0315 0062;0061 05AE 10EAC 0300 0315 0062; # (a◌𐺬◌̕◌̀◌֮b; a◌֮◌𐺬◌̀◌̕b; a◌֮◌𐺬◌̀◌̕b; a◌֮◌𐺬◌̀◌̕b; a◌֮◌𐺬◌̀◌̕b; ) LATIN SMALL LETTER A, YEZIDI COMBINING MADDA MARK, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 059A 0316 1DFA 10EFA 0062;0061 1DFA 0316 10EFA 059A 0062;0061 1DFA 0316 10EFA 059A 0062;0061 1DFA 0316 10EFA 059A 0062;0061 1DFA 0316 10EFA 059A 0062; # (a◌֚◌̖◌᷺◌𐻺b; a◌᷺◌̖◌𐻺◌֚b; a◌᷺◌̖◌𐻺◌֚b; a◌᷺◌̖◌𐻺◌֚b; a◌᷺◌̖◌𐻺◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, ARABIC DOUBLE VERTICAL BAR BELOW, LATIN SMALL LETTER B
+0061 10EFA 059A 0316 1DFA 0062;0061 1DFA 10EFA 0316 059A 0062;0061 1DFA 10EFA 0316 059A 0062;0061 1DFA 10EFA 0316 059A 0062;0061 1DFA 10EFA 0316 059A 0062; # (a◌𐻺◌֚◌̖◌᷺b; a◌᷺◌𐻺◌̖◌֚b; a◌᷺◌𐻺◌̖◌֚b; a◌᷺◌𐻺◌̖◌֚b; a◌᷺◌𐻺◌̖◌֚b; ) LATIN SMALL LETTER A, ARABIC DOUBLE VERTICAL BAR BELOW, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
+0061 059A 0316 1DFA 10EFB 0062;0061 1DFA 0316 10EFB 059A 0062;0061 1DFA 0316 10EFB 059A 0062;0061 1DFA 0316 10EFB 059A 0062;0061 1DFA 0316 10EFB 059A 0062; # (a◌֚◌̖◌᷺◌𐻻b; a◌᷺◌̖◌𐻻◌֚b; a◌᷺◌̖◌𐻻◌֚b; a◌᷺◌̖◌𐻻◌֚b; a◌᷺◌̖◌𐻻◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, ARABIC SMALL LOW NOON, LATIN SMALL LETTER B
+0061 10EFB 059A 0316 1DFA 0062;0061 1DFA 10EFB 0316 059A 0062;0061 1DFA 10EFB 0316 059A 0062;0061 1DFA 10EFB 0316 059A 0062;0061 1DFA 10EFB 0316 059A 0062; # (a◌𐻻◌֚◌̖◌᷺b; a◌᷺◌𐻻◌̖◌֚b; a◌᷺◌𐻻◌̖◌֚b; a◌᷺◌𐻻◌̖◌֚b; a◌᷺◌𐻻◌̖◌֚b; ) LATIN SMALL LETTER A, ARABIC SMALL LOW NOON, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
 0061 059A 0316 1DFA 10EFD 0062;0061 1DFA 0316 10EFD 059A 0062;0061 1DFA 0316 10EFD 059A 0062;0061 1DFA 0316 10EFD 059A 0062;0061 1DFA 0316 10EFD 059A 0062; # (a◌֚◌̖◌᷺◌𐻽b; a◌᷺◌̖◌𐻽◌֚b; a◌᷺◌̖◌𐻽◌֚b; a◌᷺◌̖◌𐻽◌֚b; a◌᷺◌̖◌𐻽◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, ARABIC SMALL LOW WORD SAKTA, LATIN SMALL LETTER B
 0061 10EFD 059A 0316 1DFA 0062;0061 1DFA 10EFD 0316 059A 0062;0061 1DFA 10EFD 0316 059A 0062;0061 1DFA 10EFD 0316 059A 0062;0061 1DFA 10EFD 0316 059A 0062; # (a◌𐻽◌֚◌̖◌᷺b; a◌᷺◌𐻽◌̖◌֚b; a◌᷺◌𐻽◌̖◌֚b; a◌᷺◌𐻽◌̖◌֚b; a◌᷺◌𐻽◌̖◌֚b; ) LATIN SMALL LETTER A, ARABIC SMALL LOW WORD SAKTA, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
 0061 059A 0316 1DFA 10EFE 0062;0061 1DFA 0316 10EFE 059A 0062;0061 1DFA 0316 10EFE 059A 0062;0061 1DFA 0316 10EFE 059A 0062;0061 1DFA 0316 10EFE 059A 0062; # (a◌֚◌̖◌᷺◌𐻾b; a◌᷺◌̖◌𐻾◌֚b; a◌᷺◌̖◌𐻾◌֚b; a◌᷺◌̖◌𐻾◌֚b; a◌᷺◌̖◌𐻾◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, ARABIC SMALL LOW WORD QASR, LATIN SMALL LETTER B
@@ -19058,6 +19117,16 @@ FFEE;FFEE;FFEE;25CB;25CB; # (￮; ￮; ￮; ○; ○; ) HALFWIDTH WHITE CIRCLE
 0061 1E5EE 0315 0300 05AE 0062;0061 05AE 1E5EE 0300 0315 0062;0061 05AE 1E5EE 0300 0315 0062;0061 05AE 1E5EE 0300 0315 0062;0061 05AE 1E5EE 0300 0315 0062; # (a◌𞗮◌̕◌̀◌֮b; a◌֮◌𞗮◌̀◌̕b; a◌֮◌𞗮◌̀◌̕b; a◌֮◌𞗮◌̀◌̕b; a◌֮◌𞗮◌̀◌̕b; ) LATIN SMALL LETTER A, OL ONAL SIGN MU, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
 0061 059A 0316 1DFA 1E5EF 0062;0061 1DFA 0316 1E5EF 059A 0062;0061 1DFA 0316 1E5EF 059A 0062;0061 1DFA 0316 1E5EF 059A 0062;0061 1DFA 0316 1E5EF 059A 0062; # (a◌֚◌̖◌᷺◌𞗯b; a◌᷺◌̖◌𞗯◌֚b; a◌᷺◌̖◌𞗯◌֚b; a◌᷺◌̖◌𞗯◌֚b; a◌᷺◌̖◌𞗯◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, OL ONAL SIGN IKIR, LATIN SMALL LETTER B
 0061 1E5EF 059A 0316 1DFA 0062;0061 1DFA 1E5EF 0316 059A 0062;0061 1DFA 1E5EF 0316 059A 0062;0061 1DFA 1E5EF 0316 059A 0062;0061 1DFA 1E5EF 0316 059A 0062; # (a◌𞗯◌֚◌̖◌᷺b; a◌᷺◌𞗯◌̖◌֚b; a◌᷺◌𞗯◌̖◌֚b; a◌᷺◌𞗯◌̖◌֚b; a◌᷺◌𞗯◌̖◌֚b; ) LATIN SMALL LETTER A, OL ONAL SIGN IKIR, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1E6E3 0062;00E0 05AE 1E6E3 0315 0062;0061 05AE 0300 1E6E3 0315 0062;00E0 05AE 1E6E3 0315 0062;0061 05AE 0300 1E6E3 0315 0062; # (a◌̕◌̀◌֮◌𞛣b; à◌֮◌𞛣◌̕b; a◌֮◌̀◌𞛣◌̕b; à◌֮◌𞛣◌̕b; a◌֮◌̀◌𞛣◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, TAI YO SIGN UE, LATIN SMALL LETTER B
+0061 1E6E3 0315 0300 05AE 0062;0061 05AE 1E6E3 0300 0315 0062;0061 05AE 1E6E3 0300 0315 0062;0061 05AE 1E6E3 0300 0315 0062;0061 05AE 1E6E3 0300 0315 0062; # (a◌𞛣◌̕◌̀◌֮b; a◌֮◌𞛣◌̀◌̕b; a◌֮◌𞛣◌̀◌̕b; a◌֮◌𞛣◌̀◌̕b; a◌֮◌𞛣◌̀◌̕b; ) LATIN SMALL LETTER A, TAI YO SIGN UE, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1E6E6 0062;00E0 05AE 1E6E6 0315 0062;0061 05AE 0300 1E6E6 0315 0062;00E0 05AE 1E6E6 0315 0062;0061 05AE 0300 1E6E6 0315 0062; # (a◌̕◌̀◌֮◌𞛦b; à◌֮◌𞛦◌̕b; a◌֮◌̀◌𞛦◌̕b; à◌֮◌𞛦◌̕b; a◌֮◌̀◌𞛦◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, TAI YO SIGN AU, LATIN SMALL LETTER B
+0061 1E6E6 0315 0300 05AE 0062;0061 05AE 1E6E6 0300 0315 0062;0061 05AE 1E6E6 0300 0315 0062;0061 05AE 1E6E6 0300 0315 0062;0061 05AE 1E6E6 0300 0315 0062; # (a◌𞛦◌̕◌̀◌֮b; a◌֮◌𞛦◌̀◌̕b; a◌֮◌𞛦◌̀◌̕b; a◌֮◌𞛦◌̀◌̕b; a◌֮◌𞛦◌̀◌̕b; ) LATIN SMALL LETTER A, TAI YO SIGN AU, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1E6EE 0062;00E0 05AE 1E6EE 0315 0062;0061 05AE 0300 1E6EE 0315 0062;00E0 05AE 1E6EE 0315 0062;0061 05AE 0300 1E6EE 0315 0062; # (a◌̕◌̀◌֮◌𞛮b; à◌֮◌𞛮◌̕b; a◌֮◌̀◌𞛮◌̕b; à◌֮◌𞛮◌̕b; a◌֮◌̀◌𞛮◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, TAI YO SIGN AY, LATIN SMALL LETTER B
+0061 1E6EE 0315 0300 05AE 0062;0061 05AE 1E6EE 0300 0315 0062;0061 05AE 1E6EE 0300 0315 0062;0061 05AE 1E6EE 0300 0315 0062;0061 05AE 1E6EE 0300 0315 0062; # (a◌𞛮◌̕◌̀◌֮b; a◌֮◌𞛮◌̀◌̕b; a◌֮◌𞛮◌̀◌̕b; a◌֮◌𞛮◌̀◌̕b; a◌֮◌𞛮◌̀◌̕b; ) LATIN SMALL LETTER A, TAI YO SIGN AY, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1E6EF 0062;00E0 05AE 1E6EF 0315 0062;0061 05AE 0300 1E6EF 0315 0062;00E0 05AE 1E6EF 0315 0062;0061 05AE 0300 1E6EF 0315 0062; # (a◌̕◌̀◌֮◌𞛯b; à◌֮◌𞛯◌̕b; a◌֮◌̀◌𞛯◌̕b; à◌֮◌𞛯◌̕b; a◌֮◌̀◌𞛯◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, TAI YO SIGN ANG, LATIN SMALL LETTER B
+0061 1E6EF 0315 0300 05AE 0062;0061 05AE 1E6EF 0300 0315 0062;0061 05AE 1E6EF 0300 0315 0062;0061 05AE 1E6EF 0300 0315 0062;0061 05AE 1E6EF 0300 0315 0062; # (a◌𞛯◌̕◌̀◌֮b; a◌֮◌𞛯◌̀◌̕b; a◌֮◌𞛯◌̀◌̕b; a◌֮◌𞛯◌̀◌̕b; a◌֮◌𞛯◌̀◌̕b; ) LATIN SMALL LETTER A, TAI YO SIGN ANG, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
+0061 0315 0300 05AE 1E6F5 0062;00E0 05AE 1E6F5 0315 0062;0061 05AE 0300 1E6F5 0315 0062;00E0 05AE 1E6F5 0315 0062;0061 05AE 0300 1E6F5 0315 0062; # (a◌̕◌̀◌֮◌𞛵b; à◌֮◌𞛵◌̕b; a◌֮◌̀◌𞛵◌̕b; à◌֮◌𞛵◌̕b; a◌֮◌̀◌𞛵◌̕b; ) LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, TAI YO SIGN OM, LATIN SMALL LETTER B
+0061 1E6F5 0315 0300 05AE 0062;0061 05AE 1E6F5 0300 0315 0062;0061 05AE 1E6F5 0300 0315 0062;0061 05AE 1E6F5 0300 0315 0062;0061 05AE 1E6F5 0300 0315 0062; # (a◌𞛵◌̕◌̀◌֮b; a◌֮◌𞛵◌̀◌̕b; a◌֮◌𞛵◌̀◌̕b; a◌֮◌𞛵◌̀◌̕b; a◌֮◌𞛵◌̀◌̕b; ) LATIN SMALL LETTER A, TAI YO SIGN OM, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR, LATIN SMALL LETTER B
 0061 059A 0316 1DFA 1E8D0 0062;0061 1DFA 0316 1E8D0 059A 0062;0061 1DFA 0316 1E8D0 059A 0062;0061 1DFA 0316 1E8D0 059A 0062;0061 1DFA 0316 1E8D0 059A 0062; # (a◌֚◌̖◌᷺◌𞣐b; a◌᷺◌̖◌𞣐◌֚b; a◌᷺◌̖◌𞣐◌֚b; a◌᷺◌̖◌𞣐◌֚b; a◌᷺◌̖◌𞣐◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, MENDE KIKAKUI COMBINING NUMBER TEENS, LATIN SMALL LETTER B
 0061 1E8D0 059A 0316 1DFA 0062;0061 1DFA 1E8D0 0316 059A 0062;0061 1DFA 1E8D0 0316 059A 0062;0061 1DFA 1E8D0 0316 059A 0062;0061 1DFA 1E8D0 0316 059A 0062; # (a◌𞣐◌֚◌̖◌᷺b; a◌᷺◌𞣐◌̖◌֚b; a◌᷺◌𞣐◌̖◌֚b; a◌᷺◌𞣐◌̖◌֚b; a◌᷺◌𞣐◌̖◌֚b; ) LATIN SMALL LETTER A, MENDE KIKAKUI COMBINING NUMBER TEENS, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, LATIN SMALL LETTER B
 0061 059A 0316 1DFA 1E8D1 0062;0061 1DFA 0316 1E8D1 059A 0062;0061 1DFA 0316 1E8D1 059A 0062;0061 1DFA 0316 1E8D1 059A 0062;0061 1DFA 0316 1E8D1 059A 0062; # (a◌֚◌̖◌᷺◌𞣑b; a◌᷺◌̖◌𞣑◌֚b; a◌᷺◌̖◌𞣑◌֚b; a◌᷺◌̖◌𞣑◌֚b; a◌᷺◌̖◌𞣑◌֚b; ) LATIN SMALL LETTER A, HEBREW ACCENT YETIV, COMBINING GRAVE ACCENT BELOW, COMBINING DOT BELOW LEFT, MENDE KIKAKUI COMBINING NUMBER TENS, LATIN SMALL LETTER B
diff --git a/tests/uninorm/test-canonical-decomposition.c b/tests/uninorm/test-canonical-decomposition.c
index 7ccab64b..7298a61e 100644
--- a/tests/uninorm/test-canonical-decomposition.c
+++ b/tests/uninorm/test-canonical-decomposition.c
@@ -1,5 +1,5 @@
 /* Test of canonical decomposition of Unicode characters.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-compat-decomposition.c b/tests/uninorm/test-compat-decomposition.c
index e66d92be..be4dc9fc 100644
--- a/tests/uninorm/test-compat-decomposition.c
+++ b/tests/uninorm/test-compat-decomposition.c
@@ -1,5 +1,5 @@
 /* Test of compatibility decomposition of Unicode characters.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-composition.c b/tests/uninorm/test-composition.c
index 3816983c..3b24410f 100644
--- a/tests/uninorm/test-composition.c
+++ b/tests/uninorm/test-composition.c
@@ -1,5 +1,5 @@
 /* Test of canonical composition of Unicode characters.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-decomposing-form.c b/tests/uninorm/test-decomposing-form.c
index fab8023a..1a3efd8e 100644
--- a/tests/uninorm/test-decomposing-form.c
+++ b/tests/uninorm/test-decomposing-form.c
@@ -1,5 +1,5 @@
 /* Test of decomposing variant of a normalization form.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-decomposition.c b/tests/uninorm/test-decomposition.c
index c37b170d..a50d781d 100644
--- a/tests/uninorm/test-decomposition.c
+++ b/tests/uninorm/test-decomposition.c
@@ -1,5 +1,5 @@
 /* Test of decomposition of Unicode characters.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-nfc.c b/tests/uninorm/test-nfc.c
index 5efff6ad..3f9b3c24 100644
--- a/tests/uninorm/test-nfc.c
+++ b/tests/uninorm/test-nfc.c
@@ -1,5 +1,5 @@
 /* Test of canonical normalization of Unicode strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-nfd.c b/tests/uninorm/test-nfd.c
index ec4405f2..57afb977 100644
--- a/tests/uninorm/test-nfd.c
+++ b/tests/uninorm/test-nfd.c
@@ -1,5 +1,5 @@
 /* Test of canonical decomposition of Unicode strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-nfkc.c b/tests/uninorm/test-nfkc.c
index 7e62e3db..035c60b8 100644
--- a/tests/uninorm/test-nfkc.c
+++ b/tests/uninorm/test-nfkc.c
@@ -1,5 +1,5 @@
 /* Test of compatibility normalization of Unicode strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-nfkd.c b/tests/uninorm/test-nfkd.c
index 6d3db8e8..3a9e1273 100644
--- a/tests/uninorm/test-nfkd.c
+++ b/tests/uninorm/test-nfkd.c
@@ -1,5 +1,5 @@
 /* Test of compatibility decomposition of Unicode strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u16-nfc.c b/tests/uninorm/test-u16-nfc.c
index 1b5bfe57..0cfd0c1f 100644
--- a/tests/uninorm/test-u16-nfc.c
+++ b/tests/uninorm/test-u16-nfc.c
@@ -1,5 +1,5 @@
 /* Test of canonical normalization of UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -256,71 +256,67 @@ test_u16_nfc (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
-        if (input != NULL)
-          {
-            uint16_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint16_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
+      if (input != NULL)
+        {
+          uint16_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint16_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x00C0;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2 - 1; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              {
-                ASSERT (check (input, m,        expected, m - 1) == 0);
-                ASSERT (check (expected, m - 1, expected, m - 1) == 0);
-              }
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x00C0;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2 - 1; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            {
+              ASSERT (check (input, m,        expected, m - 1) == 0);
+              ASSERT (check (expected, m - 1, expected, m - 1) == 0);
+            }
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u16-nfd.c b/tests/uninorm/test-u16-nfd.c
index 2f3b9251..bdeca562 100644
--- a/tests/uninorm/test-u16-nfd.c
+++ b/tests/uninorm/test-u16-nfd.c
@@ -1,5 +1,5 @@
 /* Test of canonical decomposition of UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -243,68 +243,64 @@ test_u16_nfd (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
-        if (input != NULL)
-          {
-            uint16_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint16_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
+      if (input != NULL)
+        {
+          uint16_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint16_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x0041;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              ASSERT (check (input, m, expected, m) == 0);
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x0041;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            ASSERT (check (input, m, expected, m) == 0);
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u16-nfkc.c b/tests/uninorm/test-u16-nfkc.c
index d9c40202..ef25acef 100644
--- a/tests/uninorm/test-u16-nfkc.c
+++ b/tests/uninorm/test-u16-nfkc.c
@@ -1,5 +1,5 @@
 /* Test of compatibility normalization of UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -304,71 +304,67 @@ test_u16_nfkc (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
-        if (input != NULL)
-          {
-            uint16_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint16_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
+      if (input != NULL)
+        {
+          uint16_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint16_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x00C0;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2 - 1; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              {
-                ASSERT (check (input, m,        expected, m - 1) == 0);
-                ASSERT (check (expected, m - 1, expected, m - 1) == 0);
-              }
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x00C0;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2 - 1; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            {
+              ASSERT (check (input, m,        expected, m - 1) == 0);
+              ASSERT (check (expected, m - 1, expected, m - 1) == 0);
+            }
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u16-nfkd.c b/tests/uninorm/test-u16-nfkd.c
index b244ac16..30f39ea3 100644
--- a/tests/uninorm/test-u16-nfkd.c
+++ b/tests/uninorm/test-u16-nfkd.c
@@ -1,5 +1,5 @@
 /* Test of compatibility decomposition of UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -263,68 +263,64 @@ test_u16_nfkd (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
-        if (input != NULL)
-          {
-            uint16_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint16_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint16_t *input = (uint16_t *) malloc (2 * m * sizeof (uint16_t));
+      if (input != NULL)
+        {
+          uint16_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint16_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x0041;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              ASSERT (check (input, m, expected, m) == 0);
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x0041;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            ASSERT (check (input, m, expected, m) == 0);
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u16-normcmp.c b/tests/uninorm/test-u16-normcmp.c
index bf36d74b..7a1a7d9b 100644
--- a/tests/uninorm/test-u16-normcmp.c
+++ b/tests/uninorm/test-u16-normcmp.c
@@ -1,5 +1,5 @@
 /* Test of normalization insensitive comparison of UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u16-normcmp.h b/tests/uninorm/test-u16-normcmp.h
index 09d5ba41..10bdfd06 100644
--- a/tests/uninorm/test-u16-normcmp.h
+++ b/tests/uninorm/test-u16-normcmp.h
@@ -1,5 +1,5 @@
 /* Test of normalization insensitive comparison of UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u16-normcoll.c b/tests/uninorm/test-u16-normcoll.c
index 540d3274..cb65a813 100644
--- a/tests/uninorm/test-u16-normcoll.c
+++ b/tests/uninorm/test-u16-normcoll.c
@@ -1,6 +1,6 @@
 /* Test of locale dependent, normalization insensitive comparison of
    UTF-16 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-nfc-big.c b/tests/uninorm/test-u32-nfc-big.c
index 238f7456..a5aac2c5 100644
--- a/tests/uninorm/test-u32-nfc-big.c
+++ b/tests/uninorm/test-u32-nfc-big.c
@@ -1,5 +1,5 @@
 /* Test of Unicode compliance of canonical normalization of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-nfc.c b/tests/uninorm/test-u32-nfc.c
index 8f6b2747..89f0d652 100644
--- a/tests/uninorm/test-u32-nfc.c
+++ b/tests/uninorm/test-u32-nfc.c
@@ -1,5 +1,5 @@
 /* Test of canonical normalization of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -256,71 +256,67 @@ test_u32_nfc (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
-        if (input != NULL)
-          {
-            uint32_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint32_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
+      if (input != NULL)
+        {
+          uint32_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint32_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x00C0;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2 - 1; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              {
-                ASSERT (check (input, m,        expected, m - 1) == 0);
-                ASSERT (check (expected, m - 1, expected, m - 1) == 0);
-              }
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x00C0;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2 - 1; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            {
+              ASSERT (check (input, m,        expected, m - 1) == 0);
+              ASSERT (check (expected, m - 1, expected, m - 1) == 0);
+            }
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u32-nfd-big.c b/tests/uninorm/test-u32-nfd-big.c
index ca312047..a471a035 100644
--- a/tests/uninorm/test-u32-nfd-big.c
+++ b/tests/uninorm/test-u32-nfd-big.c
@@ -1,5 +1,5 @@
 /* Test of Unicode compliance of canonical decomposition of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-nfd.c b/tests/uninorm/test-u32-nfd.c
index 5efa180b..49a12359 100644
--- a/tests/uninorm/test-u32-nfd.c
+++ b/tests/uninorm/test-u32-nfd.c
@@ -1,5 +1,5 @@
 /* Test of canonical decomposition of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -243,68 +243,64 @@ test_u32_nfd (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
-        if (input != NULL)
-          {
-            uint32_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint32_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
+      if (input != NULL)
+        {
+          uint32_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint32_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x0041;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              ASSERT (check (input, m, expected, m) == 0);
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x0041;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            ASSERT (check (input, m, expected, m) == 0);
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u32-nfkc-big.c b/tests/uninorm/test-u32-nfkc-big.c
index 920c117e..63aa1acc 100644
--- a/tests/uninorm/test-u32-nfkc-big.c
+++ b/tests/uninorm/test-u32-nfkc-big.c
@@ -1,5 +1,5 @@
 /* Test of Unicode compliance of compatibility normalization of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-nfkc.c b/tests/uninorm/test-u32-nfkc.c
index 6fc9d362..6dfc745e 100644
--- a/tests/uninorm/test-u32-nfkc.c
+++ b/tests/uninorm/test-u32-nfkc.c
@@ -1,5 +1,5 @@
 /* Test of compatibility normalization of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -304,71 +304,67 @@ test_u32_nfkc (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
-        if (input != NULL)
-          {
-            uint32_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint32_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
+      if (input != NULL)
+        {
+          uint32_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint32_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x00C0;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2 - 1; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              {
-                ASSERT (check (input, m,        expected, m - 1) == 0);
-                ASSERT (check (expected, m - 1, expected, m - 1) == 0);
-              }
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x00C0;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2 - 1; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            {
+              ASSERT (check (input, m,        expected, m - 1) == 0);
+              ASSERT (check (expected, m - 1, expected, m - 1) == 0);
+            }
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u32-nfkd-big.c b/tests/uninorm/test-u32-nfkd-big.c
index 10908726..ee176342 100644
--- a/tests/uninorm/test-u32-nfkd-big.c
+++ b/tests/uninorm/test-u32-nfkd-big.c
@@ -1,5 +1,5 @@
 /* Test of Unicode compliance of compatibility decomposition of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-nfkd.c b/tests/uninorm/test-u32-nfkd.c
index b352e87c..50fc7960 100644
--- a/tests/uninorm/test-u32-nfkd.c
+++ b/tests/uninorm/test-u32-nfkd.c
@@ -1,5 +1,5 @@
 /* Test of compatibility decomposition of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -263,68 +263,64 @@ test_u32_nfkd (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
-        if (input != NULL)
-          {
-            uint32_t *expected = input + m;
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint32_t *p;
-            size_t i;
-
-            input[0] = 0x0041;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
+      if (input != NULL)
+        {
+          uint32_t *expected = input + m;
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint32_t *p;
+
+          input[0] = 0x0041;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                *p++ = 0x0300;
+              for (size_t i = 0; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
                   *p++ = 0x0319;
-                for (i = 0; i < m2; i++)
-                  *p++ = 0x0300;
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
                   *p++ = 0x0300;
-                for (i = 0; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0x0319;
-                    *p++ = 0x0300;
-                  }
-                for (; i < m1; i++)
-                  *p++ = 0x0319;
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x0041;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              *p++ = 0x0319;
-            for (i = 0; i < m2; i++)
-              *p++ = 0x0300;
-
-            for (; repeat > 0; repeat--)
-              ASSERT (check (input, m, expected, m) == 0);
-
-            free (input);
-          }
-      }
-  }
+                }
+              for (size_t i = m2; i < m1; i++)
+                *p++ = 0x0319;
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x0041;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            *p++ = 0x0319;
+          for (size_t i = 0; i < m2; i++)
+            *p++ = 0x0300;
+
+          for (; repeat > 0; repeat--)
+            ASSERT (check (input, m, expected, m) == 0);
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u32-normalize-big.c b/tests/uninorm/test-u32-normalize-big.c
index 53cbf2b3..863c7181 100644
--- a/tests/uninorm/test-u32-normalize-big.c
+++ b/tests/uninorm/test-u32-normalize-big.c
@@ -1,5 +1,5 @@
 /* Test of Unicode compliance of normalization of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -58,7 +58,6 @@ read_normalization_test_file (const char *filename,
 {
   FILE *stream;
   unsigned int lineno;
-  int part_index;
   struct normalization_test_line *lines;
   size_t lines_length;
   size_t lines_allocated;
@@ -70,7 +69,7 @@ read_normalization_test_file (const char *filename,
       exit (1);
     }
 
-  for (part_index = 0; part_index < 6; part_index++)
+  for (int part_index = 0; part_index < 6; part_index++)
     {
       file->parts[part_index].lines = NULL;
       file->parts[part_index].lines_length = 0;
@@ -78,7 +77,7 @@ read_normalization_test_file (const char *filename,
 
   lineno = 0;
 
-  part_index = -1;
+  int part_index = -1;
   lines = NULL;
   lines_length = 0;
   lines_allocated = 0;
@@ -89,7 +88,6 @@ read_normalization_test_file (const char *filename,
       char *ptr;
       int c;
       struct normalization_test_line line;
-      size_t sequence_index;
 
       lineno++;
 
@@ -139,9 +137,9 @@ read_normalization_test_file (const char *filename,
         }
       ptr = buf;
       line.lineno = lineno;
-      for (sequence_index = 0; sequence_index < 5; sequence_index++)
+      for (size_t sequence_index = 0; sequence_index < 5; sequence_index++)
         line.sequences[sequence_index] = NULL;
-      for (sequence_index = 0; sequence_index < 5; sequence_index++)
+      for (size_t sequence_index = 0; sequence_index < 5; sequence_index++)
         {
           uint32_t *sequence = XNMALLOC (1, uint32_t);
           size_t sequence_length = 0;
@@ -210,9 +208,8 @@ read_normalization_test_file (const char *filename,
     /* Collect all c1 values from the part 1 in an array.  */
     const struct normalization_test_part *p = &file->parts[1];
     ucs4_t *c1_array = XNMALLOC (p->lines_length + 1, ucs4_t);
-    size_t line_index;
 
-    for (line_index = 0; line_index < p->lines_length; line_index++)
+    for (size_t line_index = 0; line_index < p->lines_length; line_index++)
       {
         const uint32_t *sequence = p->lines[line_index].sequences[0];
         /* In part 1, every sequences[0] consists of a single character.  */
@@ -247,14 +244,11 @@ test_specific (const struct normalization_test_file *file,
                              const uint32_t *c4, size_t c4_length,
                              const uint32_t *c5, size_t c5_length))
 {
-  size_t part_index;
-
-  for (part_index = 0; part_index < 6; part_index++)
+  for (size_t part_index = 0; part_index < 6; part_index++)
     {
       const struct normalization_test_part *p = &file->parts[part_index];
-      size_t line_index;
 
-      for (line_index = 0; line_index < p->lines_length; line_index++)
+      for (size_t line_index = 0; line_index < p->lines_length; line_index++)
         {
           const struct normalization_test_line *l = &p->lines[line_index];
 
@@ -276,9 +270,8 @@ test_other (const struct normalization_test_file *file, uninorm_t nf)
      NormalizationTest.txt file, the character maps to itself in each
      of the four normalization forms.  */
   const ucs4_t *p = file->part1_c1_sorted;
-  ucs4_t uc;
 
-  for (uc = 0; uc < 0x110000; uc++)
+  for (ucs4_t uc = 0; uc < 0x110000; uc++)
     {
       if (uc >= 0xD800 && uc < 0xE000)
         {
@@ -307,19 +300,15 @@ test_other (const struct normalization_test_file *file, uninorm_t nf)
 void
 free_normalization_test_file (struct normalization_test_file *file)
 {
-  size_t part_index;
-
-  for (part_index = 0; part_index < 6; part_index++)
+  for (size_t part_index = 0; part_index < 6; part_index++)
     {
       const struct normalization_test_part *p = &file->parts[part_index];
-      size_t line_index;
 
-      for (line_index = 0; line_index < p->lines_length; line_index++)
+      for (size_t line_index = 0; line_index < p->lines_length; line_index++)
         {
           const struct normalization_test_line *l = &p->lines[line_index];
-          size_t sequence_index;
 
-          for (sequence_index = 0; sequence_index < 5; sequence_index++)
+          for (size_t sequence_index = 0; sequence_index < 5; sequence_index++)
             free (l->sequences[sequence_index]);
         }
       free (p->lines);
diff --git a/tests/uninorm/test-u32-normalize-big.h b/tests/uninorm/test-u32-normalize-big.h
index 3704a223..5402d7b0 100644
--- a/tests/uninorm/test-u32-normalize-big.h
+++ b/tests/uninorm/test-u32-normalize-big.h
@@ -1,5 +1,5 @@
 /* Test of Unicode compliance of normalization of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-normcmp.c b/tests/uninorm/test-u32-normcmp.c
index 84ef09fc..e18de216 100644
--- a/tests/uninorm/test-u32-normcmp.c
+++ b/tests/uninorm/test-u32-normcmp.c
@@ -1,5 +1,5 @@
 /* Test of normalization insensitive comparison of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-normcmp.h b/tests/uninorm/test-u32-normcmp.h
index f5979f1e..b1a97bd7 100644
--- a/tests/uninorm/test-u32-normcmp.h
+++ b/tests/uninorm/test-u32-normcmp.h
@@ -1,5 +1,5 @@
 /* Test of normalization insensitive comparison of UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u32-normcoll.c b/tests/uninorm/test-u32-normcoll.c
index 7e7d2666..bc9c68c8 100644
--- a/tests/uninorm/test-u32-normcoll.c
+++ b/tests/uninorm/test-u32-normcoll.c
@@ -1,6 +1,6 @@
 /* Test of locale dependent, normalization insensitive comparison of
    UTF-32 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u8-nfc.c b/tests/uninorm/test-u8-nfc.c
index 298b23f7..96993cf7 100644
--- a/tests/uninorm/test-u8-nfc.c
+++ b/tests/uninorm/test-u8-nfc.c
@@ -1,5 +1,5 @@
 /* Test of canonical normalization of UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -262,95 +262,91 @@ test_u8_nfc (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
-        if (input != NULL)
-          {
-            uint8_t *expected = input + (2 * m - 1);
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint8_t *p;
-            size_t i;
-
-            input[0] = 0x41;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0xC3;
-            expected[1] = 0x80;
-            p = expected + 2;
-            for (i = 0; i < m1; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x99;
-              }
-            for (i = 0; i < m2 - 1; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x80;
-              }
-
-            for (; repeat > 0; repeat--)
-              {
-                ASSERT (check (input, 2 * m - 1,    expected, 2 * m - 2) == 0);
-                ASSERT (check (expected, 2 * m - 2, expected, 2 * m - 2) == 0);
-              }
-
-            free (input);
-          }
-      }
-  }
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
+      if (input != NULL)
+        {
+          uint8_t *expected = input + (2 * m - 1);
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint8_t *p;
+
+          input[0] = 0x41;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = m2; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0xC3;
+          expected[1] = 0x80;
+          p = expected + 2;
+          for (size_t i = 0; i < m1; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x99;
+            }
+          for (size_t i = 0; i < m2 - 1; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x80;
+            }
+
+          for (; repeat > 0; repeat--)
+            {
+              ASSERT (check (input, 2 * m - 1,    expected, 2 * m - 2) == 0);
+              ASSERT (check (expected, 2 * m - 2, expected, 2 * m - 2) == 0);
+            }
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u8-nfd.c b/tests/uninorm/test-u8-nfd.c
index b6b121aa..d7602f1e 100644
--- a/tests/uninorm/test-u8-nfd.c
+++ b/tests/uninorm/test-u8-nfd.c
@@ -1,5 +1,5 @@
 /* Test of canonical decomposition of UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -249,91 +249,87 @@ test_u8_nfd (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
-        if (input != NULL)
-          {
-            uint8_t *expected = input + (2 * m - 1);
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint8_t *p;
-            size_t i;
-
-            input[0] = 0x41;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x41;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x99;
-              }
-            for (i = 0; i < m2; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x80;
-              }
-
-            for (; repeat > 0; repeat--)
-              ASSERT (check (input, 2 * m - 1, expected, 2 * m - 1) == 0);
-
-            free (input);
-          }
-      }
-  }
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
+      if (input != NULL)
+        {
+          uint8_t *expected = input + (2 * m - 1);
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint8_t *p;
+
+          input[0] = 0x41;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = m2; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x41;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x99;
+            }
+          for (size_t i = 0; i < m2; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x80;
+            }
+
+          for (; repeat > 0; repeat--)
+            ASSERT (check (input, 2 * m - 1, expected, 2 * m - 1) == 0);
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u8-nfkc.c b/tests/uninorm/test-u8-nfkc.c
index 312b132b..551d112f 100644
--- a/tests/uninorm/test-u8-nfkc.c
+++ b/tests/uninorm/test-u8-nfkc.c
@@ -1,5 +1,5 @@
 /* Test of compatibility normalization of UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -314,95 +314,91 @@ test_u8_nfkc (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
-        if (input != NULL)
-          {
-            uint8_t *expected = input + (2 * m - 1);
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint8_t *p;
-            size_t i;
-
-            input[0] = 0x41;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0xC3;
-            expected[1] = 0x80;
-            p = expected + 2;
-            for (i = 0; i < m1; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x99;
-              }
-            for (i = 0; i < m2 - 1; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x80;
-              }
-
-            for (; repeat > 0; repeat--)
-              {
-                ASSERT (check (input, 2 * m - 1,    expected, 2 * m - 2) == 0);
-                ASSERT (check (expected, 2 * m - 2, expected, 2 * m - 2) == 0);
-              }
-
-            free (input);
-          }
-      }
-  }
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
+      if (input != NULL)
+        {
+          uint8_t *expected = input + (2 * m - 1);
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint8_t *p;
+
+          input[0] = 0x41;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = m2; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0xC3;
+          expected[1] = 0x80;
+          p = expected + 2;
+          for (size_t i = 0; i < m1; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x99;
+            }
+          for (size_t i = 0; i < m2 - 1; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x80;
+            }
+
+          for (; repeat > 0; repeat--)
+            {
+              ASSERT (check (input, 2 * m - 1,    expected, 2 * m - 2) == 0);
+              ASSERT (check (expected, 2 * m - 2, expected, 2 * m - 2) == 0);
+            }
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u8-nfkd.c b/tests/uninorm/test-u8-nfkd.c
index 413179bd..b18dd531 100644
--- a/tests/uninorm/test-u8-nfkd.c
+++ b/tests/uninorm/test-u8-nfkd.c
@@ -1,5 +1,5 @@
 /* Test of compatibility decomposition of UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -270,91 +270,87 @@ test_u8_nfkd (void)
 #endif
 
   /* Check that the sorting is not O(n²) but O(n log n).  */
-  {
-    int pass;
-    for (pass = 0; pass < 3; pass++)
-      {
-        size_t repeat = 1;
-        size_t m = 100000;
-        uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
-        if (input != NULL)
-          {
-            uint8_t *expected = input + (2 * m - 1);
-            size_t m1 = m / 2;
-            size_t m2 = (m - 1) / 2;
-            /* NB: m1 + m2 == m - 1.  */
-            uint8_t *p;
-            size_t i;
-
-            input[0] = 0x41;
-            p = input + 1;
-            switch (pass)
-              {
-              case 0:
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                break;
-
-              case 1:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (i = 0; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              case 2:
-                for (i = 0; i < m2; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                    *p++ = 0xCC;
-                    *p++ = 0x80;
-                  }
-                for (; i < m1; i++)
-                  {
-                    *p++ = 0xCC;
-                    *p++ = 0x99;
-                  }
-                break;
-
-              default:
-                abort ();
-              }
-
-            expected[0] = 0x41;
-            p = expected + 1;
-            for (i = 0; i < m1; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x99;
-              }
-            for (i = 0; i < m2; i++)
-              {
-                *p++ = 0xCC;
-                *p++ = 0x80;
-              }
-
-            for (; repeat > 0; repeat--)
-              ASSERT (check (input, 2 * m - 1, expected, 2 * m - 1) == 0);
-
-            free (input);
-          }
-      }
-  }
+  for (int pass = 0; pass < 3; pass++)
+    {
+      size_t repeat = 1;
+      size_t m = 100000;
+      uint8_t *input = (uint8_t *) malloc (2 * (2 * m - 1) * sizeof (uint8_t));
+      if (input != NULL)
+        {
+          uint8_t *expected = input + (2 * m - 1);
+          size_t m1 = m / 2;
+          size_t m2 = (m - 1) / 2;
+          /* NB: m1 + m2 == m - 1.  */
+          uint8_t *p;
+
+          input[0] = 0x41;
+          p = input + 1;
+          switch (pass)
+            {
+            case 0:
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              break;
+
+            case 1:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = 0; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            case 2:
+              for (size_t i = 0; i < m2; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                  *p++ = 0xCC;
+                  *p++ = 0x80;
+                }
+              for (size_t i = m2; i < m1; i++)
+                {
+                  *p++ = 0xCC;
+                  *p++ = 0x99;
+                }
+              break;
+
+            default:
+              abort ();
+            }
+
+          expected[0] = 0x41;
+          p = expected + 1;
+          for (size_t i = 0; i < m1; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x99;
+            }
+          for (size_t i = 0; i < m2; i++)
+            {
+              *p++ = 0xCC;
+              *p++ = 0x80;
+            }
+
+          for (; repeat > 0; repeat--)
+            ASSERT (check (input, 2 * m - 1, expected, 2 * m - 1) == 0);
+
+          free (input);
+        }
+    }
 }
 
 #else
diff --git a/tests/uninorm/test-u8-normcmp.c b/tests/uninorm/test-u8-normcmp.c
index aee524d1..5c6b6c8d 100644
--- a/tests/uninorm/test-u8-normcmp.c
+++ b/tests/uninorm/test-u8-normcmp.c
@@ -1,5 +1,5 @@
 /* Test of normalization insensitive comparison of UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u8-normcmp.h b/tests/uninorm/test-u8-normcmp.h
index 867cd2ce..e033ae76 100644
--- a/tests/uninorm/test-u8-normcmp.h
+++ b/tests/uninorm/test-u8-normcmp.h
@@ -1,5 +1,5 @@
 /* Test of normalization insensitive comparison of UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-u8-normcoll.c b/tests/uninorm/test-u8-normcoll.c
index 9f7b2f3f..5026b731 100644
--- a/tests/uninorm/test-u8-normcoll.c
+++ b/tests/uninorm/test-u8-normcoll.c
@@ -1,6 +1,6 @@
 /* Test of locale dependent, normalization insensitive comparison of
    UTF-8 strings.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/tests/uninorm/test-uninorm-filter-nfc.c b/tests/uninorm/test-uninorm-filter-nfc.c
index 3e28fe42..8ff16205 100644
--- a/tests/uninorm/test-uninorm-filter-nfc.c
+++ b/tests/uninorm/test-uninorm-filter-nfc.c
@@ -1,5 +1,5 @@
 /* Test of canonical normalization of streams.
-   Copyright (C) 2009-2024 Free Software Foundation, Inc.
+   Copyright (C) 2009-2026 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -55,7 +55,6 @@ check (const uint32_t *input, size_t input_length,
 {
   struct accumulator accu;
   struct uninorm_filter *filter;
-  size_t i;
 
   accu.result = NULL;
   accu.length = 0;
@@ -64,7 +63,7 @@ check (const uint32_t *input, size_t input_length,
   filter = uninorm_filter_create (UNINORM_NFC, write_to_accumulator, &accu);
   ASSERT (filter != NULL);
 
-  for (i = 0; i < input_length; i++)
+  for (size_t i = 0; i < input_length; i++)
     ASSERT (uninorm_filter_write (filter, input[i]) == 0);
 
   ASSERT (uninorm_filter_free (filter) == 0);
diff --git a/tests/uninorm/test-uninorm-h.c b/tests/uninorm/test-uninorm-h.c
new file mode 100644
index 00000000..16d8688b
--- /dev/null
+++ b/tests/uninorm/test-uninorm-h.c
@@ -0,0 +1,26 @@
+/* Test of <uninorm.h>.
+   Copyright (C) 2025-2026 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+
+/* Specification.  */
+#include <uninorm.h>
+
+int
+main (void)
+{
+  return 0;
+}