text: // Warning! This file is autogenerated.
  #include <boost/text/normalize_string.hpp>
  #include <boost/text/utility.hpp>
  #include <boost/text/string_utility.hpp>
  
  #include <gtest/gtest.h>
  
  #include <algorithm>
  
  
  
  TEST(normalization, nfc_076_000)
  {
      // 1D430;1D430;1D430;0077;0077; 
      // (𝐰; 𝐰; 𝐰; w; w; ) MATHEMATICAL BOLD SMALL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D430 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D430 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D430 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0077 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0077 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_001)
  {
      // 1D431;1D431;1D431;0078;0078; 
      // (𝐱; 𝐱; 𝐱; x; x; ) MATHEMATICAL BOLD SMALL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D431 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D431 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D431 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0078 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0078 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_002)
  {
      // 1D432;1D432;1D432;0079;0079; 
      // (𝐲; 𝐲; 𝐲; y; y; ) MATHEMATICAL BOLD SMALL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D432 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D432 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D432 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0079 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0079 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_003)
  {
      // 1D433;1D433;1D433;007A;007A; 
      // (𝐳; 𝐳; 𝐳; z; z; ) MATHEMATICAL BOLD SMALL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D433 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D433 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D433 }};
          std::array<uint32_t, 1> const c4 = {{ 0x007A }};
          std::array<uint32_t, 1> const c5 = {{ 0x007A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_004)
  {
      // 1D434;1D434;1D434;0041;0041; 
      // (𝐴; 𝐴; 𝐴; A; A; ) MATHEMATICAL ITALIC CAPITAL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D434 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D434 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D434 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0041 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0041 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_005)
  {
      // 1D435;1D435;1D435;0042;0042; 
      // (𝐵; 𝐵; 𝐵; B; B; ) MATHEMATICAL ITALIC CAPITAL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D435 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D435 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D435 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0042 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0042 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_006)
  {
      // 1D436;1D436;1D436;0043;0043; 
      // (𝐶; 𝐶; 𝐶; C; C; ) MATHEMATICAL ITALIC CAPITAL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D436 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D436 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D436 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0043 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0043 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_007)
  {
      // 1D437;1D437;1D437;0044;0044; 
      // (𝐷; 𝐷; 𝐷; D; D; ) MATHEMATICAL ITALIC CAPITAL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D437 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D437 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D437 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0044 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0044 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_008)
  {
      // 1D438;1D438;1D438;0045;0045; 
      // (𝐸; 𝐸; 𝐸; E; E; ) MATHEMATICAL ITALIC CAPITAL E
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D438 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D438 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D438 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0045 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0045 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_009)
  {
      // 1D439;1D439;1D439;0046;0046; 
      // (𝐹; 𝐹; 𝐹; F; F; ) MATHEMATICAL ITALIC CAPITAL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D439 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D439 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D439 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0046 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0046 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_010)
  {
      // 1D43A;1D43A;1D43A;0047;0047; 
      // (𝐺; 𝐺; 𝐺; G; G; ) MATHEMATICAL ITALIC CAPITAL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D43A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D43A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D43A }};
          std::array<uint32_t, 1> const c4 = {{ 0x0047 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0047 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_011)
  {
      // 1D43B;1D43B;1D43B;0048;0048; 
      // (𝐻; 𝐻; 𝐻; H; H; ) MATHEMATICAL ITALIC CAPITAL H
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D43B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D43B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D43B }};
          std::array<uint32_t, 1> const c4 = {{ 0x0048 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0048 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_012)
  {
      // 1D43C;1D43C;1D43C;0049;0049; 
      // (𝐼; 𝐼; 𝐼; I; I; ) MATHEMATICAL ITALIC CAPITAL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D43C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D43C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D43C }};
          std::array<uint32_t, 1> const c4 = {{ 0x0049 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0049 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_013)
  {
      // 1D43D;1D43D;1D43D;004A;004A; 
      // (𝐽; 𝐽; 𝐽; J; J; ) MATHEMATICAL ITALIC CAPITAL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D43D }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D43D }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D43D }};
          std::array<uint32_t, 1> const c4 = {{ 0x004A }};
          std::array<uint32_t, 1> const c5 = {{ 0x004A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_014)
  {
      // 1D43E;1D43E;1D43E;004B;004B; 
      // (𝐾; 𝐾; 𝐾; K; K; ) MATHEMATICAL ITALIC CAPITAL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D43E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D43E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D43E }};
          std::array<uint32_t, 1> const c4 = {{ 0x004B }};
          std::array<uint32_t, 1> const c5 = {{ 0x004B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_015)
  {
      // 1D43F;1D43F;1D43F;004C;004C; 
      // (𝐿; 𝐿; 𝐿; L; L; ) MATHEMATICAL ITALIC CAPITAL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D43F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D43F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D43F }};
          std::array<uint32_t, 1> const c4 = {{ 0x004C }};
          std::array<uint32_t, 1> const c5 = {{ 0x004C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_016)
  {
      // 1D440;1D440;1D440;004D;004D; 
      // (𝑀; 𝑀; 𝑀; M; M; ) MATHEMATICAL ITALIC CAPITAL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D440 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D440 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D440 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004D }};
          std::array<uint32_t, 1> const c5 = {{ 0x004D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_017)
  {
      // 1D441;1D441;1D441;004E;004E; 
      // (𝑁; 𝑁; 𝑁; N; N; ) MATHEMATICAL ITALIC CAPITAL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D441 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D441 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D441 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004E }};
          std::array<uint32_t, 1> const c5 = {{ 0x004E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_018)
  {
      // 1D442;1D442;1D442;004F;004F; 
      // (𝑂; 𝑂; 𝑂; O; O; ) MATHEMATICAL ITALIC CAPITAL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D442 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D442 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D442 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004F }};
          std::array<uint32_t, 1> const c5 = {{ 0x004F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_019)
  {
      // 1D443;1D443;1D443;0050;0050; 
      // (𝑃; 𝑃; 𝑃; P; P; ) MATHEMATICAL ITALIC CAPITAL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D443 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D443 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D443 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0050 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0050 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_020)
  {
      // 1D444;1D444;1D444;0051;0051; 
      // (𝑄; 𝑄; 𝑄; Q; Q; ) MATHEMATICAL ITALIC CAPITAL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D444 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D444 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D444 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0051 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0051 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_021)
  {
      // 1D445;1D445;1D445;0052;0052; 
      // (𝑅; 𝑅; 𝑅; R; R; ) MATHEMATICAL ITALIC CAPITAL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D445 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D445 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D445 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0052 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0052 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_022)
  {
      // 1D446;1D446;1D446;0053;0053; 
      // (𝑆; 𝑆; 𝑆; S; S; ) MATHEMATICAL ITALIC CAPITAL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D446 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D446 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D446 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0053 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0053 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_023)
  {
      // 1D447;1D447;1D447;0054;0054; 
      // (𝑇; 𝑇; 𝑇; T; T; ) MATHEMATICAL ITALIC CAPITAL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D447 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D447 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D447 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0054 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0054 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_024)
  {
      // 1D448;1D448;1D448;0055;0055; 
      // (𝑈; 𝑈; 𝑈; U; U; ) MATHEMATICAL ITALIC CAPITAL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D448 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D448 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D448 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0055 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0055 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_025)
  {
      // 1D449;1D449;1D449;0056;0056; 
      // (𝑉; 𝑉; 𝑉; V; V; ) MATHEMATICAL ITALIC CAPITAL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D449 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D449 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D449 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0056 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0056 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_026)
  {
      // 1D44A;1D44A;1D44A;0057;0057; 
      // (𝑊; 𝑊; 𝑊; W; W; ) MATHEMATICAL ITALIC CAPITAL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D44A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D44A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D44A }};
          std::array<uint32_t, 1> const c4 = {{ 0x0057 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0057 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_027)
  {
      // 1D44B;1D44B;1D44B;0058;0058; 
      // (𝑋; 𝑋; 𝑋; X; X; ) MATHEMATICAL ITALIC CAPITAL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D44B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D44B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D44B }};
          std::array<uint32_t, 1> const c4 = {{ 0x0058 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0058 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_028)
  {
      // 1D44C;1D44C;1D44C;0059;0059; 
      // (𝑌; 𝑌; 𝑌; Y; Y; ) MATHEMATICAL ITALIC CAPITAL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D44C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D44C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D44C }};
          std::array<uint32_t, 1> const c4 = {{ 0x0059 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0059 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_029)
  {
      // 1D44D;1D44D;1D44D;005A;005A; 
      // (𝑍; 𝑍; 𝑍; Z; Z; ) MATHEMATICAL ITALIC CAPITAL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D44D }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D44D }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D44D }};
          std::array<uint32_t, 1> const c4 = {{ 0x005A }};
          std::array<uint32_t, 1> const c5 = {{ 0x005A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_030)
  {
      // 1D44E;1D44E;1D44E;0061;0061; 
      // (𝑎; 𝑎; 𝑎; a; a; ) MATHEMATICAL ITALIC SMALL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D44E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D44E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D44E }};
          std::array<uint32_t, 1> const c4 = {{ 0x0061 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0061 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_031)
  {
      // 1D44F;1D44F;1D44F;0062;0062; 
      // (𝑏; 𝑏; 𝑏; b; b; ) MATHEMATICAL ITALIC SMALL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D44F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D44F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D44F }};
          std::array<uint32_t, 1> const c4 = {{ 0x0062 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0062 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_032)
  {
      // 1D450;1D450;1D450;0063;0063; 
      // (𝑐; 𝑐; 𝑐; c; c; ) MATHEMATICAL ITALIC SMALL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D450 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D450 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D450 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0063 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0063 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_033)
  {
      // 1D451;1D451;1D451;0064;0064; 
      // (𝑑; 𝑑; 𝑑; d; d; ) MATHEMATICAL ITALIC SMALL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D451 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D451 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D451 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0064 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0064 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_034)
  {
      // 1D452;1D452;1D452;0065;0065; 
      // (𝑒; 𝑒; 𝑒; e; e; ) MATHEMATICAL ITALIC SMALL E
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D452 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D452 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D452 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0065 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0065 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_035)
  {
      // 1D453;1D453;1D453;0066;0066; 
      // (𝑓; 𝑓; 𝑓; f; f; ) MATHEMATICAL ITALIC SMALL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D453 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D453 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D453 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0066 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0066 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_036)
  {
      // 1D454;1D454;1D454;0067;0067; 
      // (𝑔; 𝑔; 𝑔; g; g; ) MATHEMATICAL ITALIC SMALL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D454 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D454 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D454 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0067 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0067 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_037)
  {
      // 1D456;1D456;1D456;0069;0069; 
      // (𝑖; 𝑖; 𝑖; i; i; ) MATHEMATICAL ITALIC SMALL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D456 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D456 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D456 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0069 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0069 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_038)
  {
      // 1D457;1D457;1D457;006A;006A; 
      // (𝑗; 𝑗; 𝑗; j; j; ) MATHEMATICAL ITALIC SMALL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D457 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D457 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D457 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006A }};
          std::array<uint32_t, 1> const c5 = {{ 0x006A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_039)
  {
      // 1D458;1D458;1D458;006B;006B; 
      // (𝑘; 𝑘; 𝑘; k; k; ) MATHEMATICAL ITALIC SMALL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D458 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D458 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D458 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006B }};
          std::array<uint32_t, 1> const c5 = {{ 0x006B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_040)
  {
      // 1D459;1D459;1D459;006C;006C; 
      // (𝑙; 𝑙; 𝑙; l; l; ) MATHEMATICAL ITALIC SMALL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D459 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D459 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D459 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006C }};
          std::array<uint32_t, 1> const c5 = {{ 0x006C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_041)
  {
      // 1D45A;1D45A;1D45A;006D;006D; 
      // (𝑚; 𝑚; 𝑚; m; m; ) MATHEMATICAL ITALIC SMALL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D45A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D45A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D45A }};
          std::array<uint32_t, 1> const c4 = {{ 0x006D }};
          std::array<uint32_t, 1> const c5 = {{ 0x006D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_042)
  {
      // 1D45B;1D45B;1D45B;006E;006E; 
      // (𝑛; 𝑛; 𝑛; n; n; ) MATHEMATICAL ITALIC SMALL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D45B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D45B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D45B }};
          std::array<uint32_t, 1> const c4 = {{ 0x006E }};
          std::array<uint32_t, 1> const c5 = {{ 0x006E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_043)
  {
      // 1D45C;1D45C;1D45C;006F;006F; 
      // (𝑜; 𝑜; 𝑜; o; o; ) MATHEMATICAL ITALIC SMALL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D45C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D45C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D45C }};
          std::array<uint32_t, 1> const c4 = {{ 0x006F }};
          std::array<uint32_t, 1> const c5 = {{ 0x006F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_044)
  {
      // 1D45D;1D45D;1D45D;0070;0070; 
      // (𝑝; 𝑝; 𝑝; p; p; ) MATHEMATICAL ITALIC SMALL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D45D }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D45D }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D45D }};
          std::array<uint32_t, 1> const c4 = {{ 0x0070 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0070 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_045)
  {
      // 1D45E;1D45E;1D45E;0071;0071; 
      // (𝑞; 𝑞; 𝑞; q; q; ) MATHEMATICAL ITALIC SMALL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D45E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D45E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D45E }};
          std::array<uint32_t, 1> const c4 = {{ 0x0071 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0071 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_046)
  {
      // 1D45F;1D45F;1D45F;0072;0072; 
      // (𝑟; 𝑟; 𝑟; r; r; ) MATHEMATICAL ITALIC SMALL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D45F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D45F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D45F }};
          std::array<uint32_t, 1> const c4 = {{ 0x0072 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0072 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_047)
  {
      // 1D460;1D460;1D460;0073;0073; 
      // (𝑠; 𝑠; 𝑠; s; s; ) MATHEMATICAL ITALIC SMALL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D460 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D460 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D460 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0073 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0073 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_048)
  {
      // 1D461;1D461;1D461;0074;0074; 
      // (𝑡; 𝑡; 𝑡; t; t; ) MATHEMATICAL ITALIC SMALL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D461 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D461 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D461 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0074 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0074 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_049)
  {
      // 1D462;1D462;1D462;0075;0075; 
      // (𝑢; 𝑢; 𝑢; u; u; ) MATHEMATICAL ITALIC SMALL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D462 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D462 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D462 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0075 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0075 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_050)
  {
      // 1D463;1D463;1D463;0076;0076; 
      // (𝑣; 𝑣; 𝑣; v; v; ) MATHEMATICAL ITALIC SMALL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D463 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D463 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D463 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0076 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0076 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_051)
  {
      // 1D464;1D464;1D464;0077;0077; 
      // (𝑤; 𝑤; 𝑤; w; w; ) MATHEMATICAL ITALIC SMALL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D464 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D464 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D464 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0077 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0077 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_052)
  {
      // 1D465;1D465;1D465;0078;0078; 
      // (𝑥; 𝑥; 𝑥; x; x; ) MATHEMATICAL ITALIC SMALL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D465 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D465 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D465 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0078 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0078 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_053)
  {
      // 1D466;1D466;1D466;0079;0079; 
      // (𝑦; 𝑦; 𝑦; y; y; ) MATHEMATICAL ITALIC SMALL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D466 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D466 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D466 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0079 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0079 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_054)
  {
      // 1D467;1D467;1D467;007A;007A; 
      // (𝑧; 𝑧; 𝑧; z; z; ) MATHEMATICAL ITALIC SMALL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D467 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D467 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D467 }};
          std::array<uint32_t, 1> const c4 = {{ 0x007A }};
          std::array<uint32_t, 1> const c5 = {{ 0x007A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_055)
  {
      // 1D468;1D468;1D468;0041;0041; 
      // (𝑨; 𝑨; 𝑨; A; A; ) MATHEMATICAL BOLD ITALIC CAPITAL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D468 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D468 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D468 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0041 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0041 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_056)
  {
      // 1D469;1D469;1D469;0042;0042; 
      // (𝑩; 𝑩; 𝑩; B; B; ) MATHEMATICAL BOLD ITALIC CAPITAL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D469 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D469 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D469 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0042 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0042 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_057)
  {
      // 1D46A;1D46A;1D46A;0043;0043; 
      // (𝑪; 𝑪; 𝑪; C; C; ) MATHEMATICAL BOLD ITALIC CAPITAL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D46A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D46A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D46A }};
          std::array<uint32_t, 1> const c4 = {{ 0x0043 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0043 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_058)
  {
      // 1D46B;1D46B;1D46B;0044;0044; 
      // (𝑫; 𝑫; 𝑫; D; D; ) MATHEMATICAL BOLD ITALIC CAPITAL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D46B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D46B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D46B }};
          std::array<uint32_t, 1> const c4 = {{ 0x0044 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0044 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_059)
  {
      // 1D46C;1D46C;1D46C;0045;0045; 
      // (𝑬; 𝑬; 𝑬; E; E; ) MATHEMATICAL BOLD ITALIC CAPITAL E
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D46C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D46C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D46C }};
          std::array<uint32_t, 1> const c4 = {{ 0x0045 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0045 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_060)
  {
      // 1D46D;1D46D;1D46D;0046;0046; 
      // (𝑭; 𝑭; 𝑭; F; F; ) MATHEMATICAL BOLD ITALIC CAPITAL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D46D }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D46D }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D46D }};
          std::array<uint32_t, 1> const c4 = {{ 0x0046 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0046 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_061)
  {
      // 1D46E;1D46E;1D46E;0047;0047; 
      // (𝑮; 𝑮; 𝑮; G; G; ) MATHEMATICAL BOLD ITALIC CAPITAL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D46E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D46E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D46E }};
          std::array<uint32_t, 1> const c4 = {{ 0x0047 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0047 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_062)
  {
      // 1D46F;1D46F;1D46F;0048;0048; 
      // (𝑯; 𝑯; 𝑯; H; H; ) MATHEMATICAL BOLD ITALIC CAPITAL H
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D46F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D46F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D46F }};
          std::array<uint32_t, 1> const c4 = {{ 0x0048 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0048 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_063)
  {
      // 1D470;1D470;1D470;0049;0049; 
      // (𝑰; 𝑰; 𝑰; I; I; ) MATHEMATICAL BOLD ITALIC CAPITAL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D470 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D470 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D470 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0049 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0049 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_064)
  {
      // 1D471;1D471;1D471;004A;004A; 
      // (𝑱; 𝑱; 𝑱; J; J; ) MATHEMATICAL BOLD ITALIC CAPITAL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D471 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D471 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D471 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004A }};
          std::array<uint32_t, 1> const c5 = {{ 0x004A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_065)
  {
      // 1D472;1D472;1D472;004B;004B; 
      // (𝑲; 𝑲; 𝑲; K; K; ) MATHEMATICAL BOLD ITALIC CAPITAL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D472 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D472 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D472 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004B }};
          std::array<uint32_t, 1> const c5 = {{ 0x004B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_066)
  {
      // 1D473;1D473;1D473;004C;004C; 
      // (𝑳; 𝑳; 𝑳; L; L; ) MATHEMATICAL BOLD ITALIC CAPITAL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D473 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D473 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D473 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004C }};
          std::array<uint32_t, 1> const c5 = {{ 0x004C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_067)
  {
      // 1D474;1D474;1D474;004D;004D; 
      // (𝑴; 𝑴; 𝑴; M; M; ) MATHEMATICAL BOLD ITALIC CAPITAL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D474 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D474 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D474 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004D }};
          std::array<uint32_t, 1> const c5 = {{ 0x004D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_068)
  {
      // 1D475;1D475;1D475;004E;004E; 
      // (𝑵; 𝑵; 𝑵; N; N; ) MATHEMATICAL BOLD ITALIC CAPITAL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D475 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D475 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D475 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004E }};
          std::array<uint32_t, 1> const c5 = {{ 0x004E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_069)
  {
      // 1D476;1D476;1D476;004F;004F; 
      // (𝑶; 𝑶; 𝑶; O; O; ) MATHEMATICAL BOLD ITALIC CAPITAL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D476 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D476 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D476 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004F }};
          std::array<uint32_t, 1> const c5 = {{ 0x004F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_070)
  {
      // 1D477;1D477;1D477;0050;0050; 
      // (𝑷; 𝑷; 𝑷; P; P; ) MATHEMATICAL BOLD ITALIC CAPITAL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D477 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D477 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D477 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0050 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0050 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_071)
  {
      // 1D478;1D478;1D478;0051;0051; 
      // (𝑸; 𝑸; 𝑸; Q; Q; ) MATHEMATICAL BOLD ITALIC CAPITAL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D478 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D478 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D478 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0051 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0051 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_072)
  {
      // 1D479;1D479;1D479;0052;0052; 
      // (𝑹; 𝑹; 𝑹; R; R; ) MATHEMATICAL BOLD ITALIC CAPITAL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D479 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D479 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D479 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0052 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0052 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_073)
  {
      // 1D47A;1D47A;1D47A;0053;0053; 
      // (𝑺; 𝑺; 𝑺; S; S; ) MATHEMATICAL BOLD ITALIC CAPITAL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D47A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D47A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D47A }};
          std::array<uint32_t, 1> const c4 = {{ 0x0053 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0053 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_074)
  {
      // 1D47B;1D47B;1D47B;0054;0054; 
      // (𝑻; 𝑻; 𝑻; T; T; ) MATHEMATICAL BOLD ITALIC CAPITAL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D47B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D47B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D47B }};
          std::array<uint32_t, 1> const c4 = {{ 0x0054 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0054 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_075)
  {
      // 1D47C;1D47C;1D47C;0055;0055; 
      // (𝑼; 𝑼; 𝑼; U; U; ) MATHEMATICAL BOLD ITALIC CAPITAL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D47C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D47C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D47C }};
          std::array<uint32_t, 1> const c4 = {{ 0x0055 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0055 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_076)
  {
      // 1D47D;1D47D;1D47D;0056;0056; 
      // (𝑽; 𝑽; 𝑽; V; V; ) MATHEMATICAL BOLD ITALIC CAPITAL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D47D }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D47D }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D47D }};
          std::array<uint32_t, 1> const c4 = {{ 0x0056 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0056 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_077)
  {
      // 1D47E;1D47E;1D47E;0057;0057; 
      // (𝑾; 𝑾; 𝑾; W; W; ) MATHEMATICAL BOLD ITALIC CAPITAL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D47E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D47E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D47E }};
          std::array<uint32_t, 1> const c4 = {{ 0x0057 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0057 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_078)
  {
      // 1D47F;1D47F;1D47F;0058;0058; 
      // (𝑿; 𝑿; 𝑿; X; X; ) MATHEMATICAL BOLD ITALIC CAPITAL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D47F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D47F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D47F }};
          std::array<uint32_t, 1> const c4 = {{ 0x0058 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0058 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_079)
  {
      // 1D480;1D480;1D480;0059;0059; 
      // (𝒀; 𝒀; 𝒀; Y; Y; ) MATHEMATICAL BOLD ITALIC CAPITAL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D480 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D480 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D480 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0059 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0059 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_080)
  {
      // 1D481;1D481;1D481;005A;005A; 
      // (𝒁; 𝒁; 𝒁; Z; Z; ) MATHEMATICAL BOLD ITALIC CAPITAL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D481 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D481 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D481 }};
          std::array<uint32_t, 1> const c4 = {{ 0x005A }};
          std::array<uint32_t, 1> const c5 = {{ 0x005A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_081)
  {
      // 1D482;1D482;1D482;0061;0061; 
      // (𝒂; 𝒂; 𝒂; a; a; ) MATHEMATICAL BOLD ITALIC SMALL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D482 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D482 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D482 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0061 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0061 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_082)
  {
      // 1D483;1D483;1D483;0062;0062; 
      // (𝒃; 𝒃; 𝒃; b; b; ) MATHEMATICAL BOLD ITALIC SMALL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D483 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D483 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D483 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0062 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0062 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_083)
  {
      // 1D484;1D484;1D484;0063;0063; 
      // (𝒄; 𝒄; 𝒄; c; c; ) MATHEMATICAL BOLD ITALIC SMALL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D484 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D484 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D484 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0063 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0063 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_084)
  {
      // 1D485;1D485;1D485;0064;0064; 
      // (𝒅; 𝒅; 𝒅; d; d; ) MATHEMATICAL BOLD ITALIC SMALL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D485 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D485 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D485 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0064 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0064 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_085)
  {
      // 1D486;1D486;1D486;0065;0065; 
      // (𝒆; 𝒆; 𝒆; e; e; ) MATHEMATICAL BOLD ITALIC SMALL E
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D486 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D486 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D486 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0065 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0065 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_086)
  {
      // 1D487;1D487;1D487;0066;0066; 
      // (𝒇; 𝒇; 𝒇; f; f; ) MATHEMATICAL BOLD ITALIC SMALL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D487 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D487 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D487 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0066 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0066 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_087)
  {
      // 1D488;1D488;1D488;0067;0067; 
      // (𝒈; 𝒈; 𝒈; g; g; ) MATHEMATICAL BOLD ITALIC SMALL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D488 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D488 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D488 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0067 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0067 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_088)
  {
      // 1D489;1D489;1D489;0068;0068; 
      // (𝒉; 𝒉; 𝒉; h; h; ) MATHEMATICAL BOLD ITALIC SMALL H
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D489 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D489 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D489 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0068 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0068 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_089)
  {
      // 1D48A;1D48A;1D48A;0069;0069; 
      // (𝒊; 𝒊; 𝒊; i; i; ) MATHEMATICAL BOLD ITALIC SMALL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D48A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D48A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D48A }};
          std::array<uint32_t, 1> const c4 = {{ 0x0069 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0069 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_090)
  {
      // 1D48B;1D48B;1D48B;006A;006A; 
      // (𝒋; 𝒋; 𝒋; j; j; ) MATHEMATICAL BOLD ITALIC SMALL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D48B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D48B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D48B }};
          std::array<uint32_t, 1> const c4 = {{ 0x006A }};
          std::array<uint32_t, 1> const c5 = {{ 0x006A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_091)
  {
      // 1D48C;1D48C;1D48C;006B;006B; 
      // (𝒌; 𝒌; 𝒌; k; k; ) MATHEMATICAL BOLD ITALIC SMALL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D48C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D48C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D48C }};
          std::array<uint32_t, 1> const c4 = {{ 0x006B }};
          std::array<uint32_t, 1> const c5 = {{ 0x006B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_092)
  {
      // 1D48D;1D48D;1D48D;006C;006C; 
      // (𝒍; 𝒍; 𝒍; l; l; ) MATHEMATICAL BOLD ITALIC SMALL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D48D }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D48D }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D48D }};
          std::array<uint32_t, 1> const c4 = {{ 0x006C }};
          std::array<uint32_t, 1> const c5 = {{ 0x006C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_093)
  {
      // 1D48E;1D48E;1D48E;006D;006D; 
      // (𝒎; 𝒎; 𝒎; m; m; ) MATHEMATICAL BOLD ITALIC SMALL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D48E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D48E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D48E }};
          std::array<uint32_t, 1> const c4 = {{ 0x006D }};
          std::array<uint32_t, 1> const c5 = {{ 0x006D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_094)
  {
      // 1D48F;1D48F;1D48F;006E;006E; 
      // (𝒏; 𝒏; 𝒏; n; n; ) MATHEMATICAL BOLD ITALIC SMALL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D48F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D48F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D48F }};
          std::array<uint32_t, 1> const c4 = {{ 0x006E }};
          std::array<uint32_t, 1> const c5 = {{ 0x006E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_095)
  {
      // 1D490;1D490;1D490;006F;006F; 
      // (𝒐; 𝒐; 𝒐; o; o; ) MATHEMATICAL BOLD ITALIC SMALL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D490 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D490 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D490 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006F }};
          std::array<uint32_t, 1> const c5 = {{ 0x006F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_096)
  {
      // 1D491;1D491;1D491;0070;0070; 
      // (𝒑; 𝒑; 𝒑; p; p; ) MATHEMATICAL BOLD ITALIC SMALL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D491 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D491 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D491 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0070 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0070 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_097)
  {
      // 1D492;1D492;1D492;0071;0071; 
      // (𝒒; 𝒒; 𝒒; q; q; ) MATHEMATICAL BOLD ITALIC SMALL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D492 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D492 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D492 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0071 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0071 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_098)
  {
      // 1D493;1D493;1D493;0072;0072; 
      // (𝒓; 𝒓; 𝒓; r; r; ) MATHEMATICAL BOLD ITALIC SMALL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D493 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D493 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D493 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0072 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0072 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_099)
  {
      // 1D494;1D494;1D494;0073;0073; 
      // (𝒔; 𝒔; 𝒔; s; s; ) MATHEMATICAL BOLD ITALIC SMALL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D494 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D494 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D494 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0073 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0073 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_100)
  {
      // 1D495;1D495;1D495;0074;0074; 
      // (𝒕; 𝒕; 𝒕; t; t; ) MATHEMATICAL BOLD ITALIC SMALL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D495 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D495 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D495 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0074 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0074 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_101)
  {
      // 1D496;1D496;1D496;0075;0075; 
      // (𝒖; 𝒖; 𝒖; u; u; ) MATHEMATICAL BOLD ITALIC SMALL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D496 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D496 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D496 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0075 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0075 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_102)
  {
      // 1D497;1D497;1D497;0076;0076; 
      // (𝒗; 𝒗; 𝒗; v; v; ) MATHEMATICAL BOLD ITALIC SMALL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D497 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D497 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D497 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0076 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0076 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_103)
  {
      // 1D498;1D498;1D498;0077;0077; 
      // (𝒘; 𝒘; 𝒘; w; w; ) MATHEMATICAL BOLD ITALIC SMALL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D498 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D498 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D498 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0077 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0077 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_104)
  {
      // 1D499;1D499;1D499;0078;0078; 
      // (𝒙; 𝒙; 𝒙; x; x; ) MATHEMATICAL BOLD ITALIC SMALL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D499 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D499 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D499 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0078 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0078 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_105)
  {
      // 1D49A;1D49A;1D49A;0079;0079; 
      // (𝒚; 𝒚; 𝒚; y; y; ) MATHEMATICAL BOLD ITALIC SMALL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D49A }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D49A }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D49A }};
          std::array<uint32_t, 1> const c4 = {{ 0x0079 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0079 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_106)
  {
      // 1D49B;1D49B;1D49B;007A;007A; 
      // (𝒛; 𝒛; 𝒛; z; z; ) MATHEMATICAL BOLD ITALIC SMALL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D49B }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D49B }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D49B }};
          std::array<uint32_t, 1> const c4 = {{ 0x007A }};
          std::array<uint32_t, 1> const c5 = {{ 0x007A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_107)
  {
      // 1D49C;1D49C;1D49C;0041;0041; 
      // (𝒜; 𝒜; 𝒜; A; A; ) MATHEMATICAL SCRIPT CAPITAL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D49C }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D49C }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D49C }};
          std::array<uint32_t, 1> const c4 = {{ 0x0041 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0041 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_108)
  {
      // 1D49E;1D49E;1D49E;0043;0043; 
      // (𝒞; 𝒞; 𝒞; C; C; ) MATHEMATICAL SCRIPT CAPITAL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D49E }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D49E }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D49E }};
          std::array<uint32_t, 1> const c4 = {{ 0x0043 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0043 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_109)
  {
      // 1D49F;1D49F;1D49F;0044;0044; 
      // (𝒟; 𝒟; 𝒟; D; D; ) MATHEMATICAL SCRIPT CAPITAL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D49F }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D49F }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D49F }};
          std::array<uint32_t, 1> const c4 = {{ 0x0044 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0044 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_110)
  {
      // 1D4A2;1D4A2;1D4A2;0047;0047; 
      // (𝒢; 𝒢; 𝒢; G; G; ) MATHEMATICAL SCRIPT CAPITAL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4A2 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4A2 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4A2 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0047 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0047 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_111)
  {
      // 1D4A5;1D4A5;1D4A5;004A;004A; 
      // (𝒥; 𝒥; 𝒥; J; J; ) MATHEMATICAL SCRIPT CAPITAL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4A5 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4A5 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4A5 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004A }};
          std::array<uint32_t, 1> const c5 = {{ 0x004A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_112)
  {
      // 1D4A6;1D4A6;1D4A6;004B;004B; 
      // (𝒦; 𝒦; 𝒦; K; K; ) MATHEMATICAL SCRIPT CAPITAL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4A6 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4A6 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4A6 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004B }};
          std::array<uint32_t, 1> const c5 = {{ 0x004B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_113)
  {
      // 1D4A9;1D4A9;1D4A9;004E;004E; 
      // (𝒩; 𝒩; 𝒩; N; N; ) MATHEMATICAL SCRIPT CAPITAL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4A9 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4A9 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004E }};
          std::array<uint32_t, 1> const c5 = {{ 0x004E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_114)
  {
      // 1D4AA;1D4AA;1D4AA;004F;004F; 
      // (𝒪; 𝒪; 𝒪; O; O; ) MATHEMATICAL SCRIPT CAPITAL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4AA }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4AA }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4AA }};
          std::array<uint32_t, 1> const c4 = {{ 0x004F }};
          std::array<uint32_t, 1> const c5 = {{ 0x004F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_115)
  {
      // 1D4AB;1D4AB;1D4AB;0050;0050; 
      // (𝒫; 𝒫; 𝒫; P; P; ) MATHEMATICAL SCRIPT CAPITAL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4AB }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4AB }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4AB }};
          std::array<uint32_t, 1> const c4 = {{ 0x0050 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0050 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_116)
  {
      // 1D4AC;1D4AC;1D4AC;0051;0051; 
      // (𝒬; 𝒬; 𝒬; Q; Q; ) MATHEMATICAL SCRIPT CAPITAL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4AC }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4AC }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4AC }};
          std::array<uint32_t, 1> const c4 = {{ 0x0051 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0051 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_117)
  {
      // 1D4AE;1D4AE;1D4AE;0053;0053; 
      // (𝒮; 𝒮; 𝒮; S; S; ) MATHEMATICAL SCRIPT CAPITAL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4AE }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4AE }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4AE }};
          std::array<uint32_t, 1> const c4 = {{ 0x0053 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0053 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_118)
  {
      // 1D4AF;1D4AF;1D4AF;0054;0054; 
      // (𝒯; 𝒯; 𝒯; T; T; ) MATHEMATICAL SCRIPT CAPITAL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4AF }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4AF }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4AF }};
          std::array<uint32_t, 1> const c4 = {{ 0x0054 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0054 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_119)
  {
      // 1D4B0;1D4B0;1D4B0;0055;0055; 
      // (𝒰; 𝒰; 𝒰; U; U; ) MATHEMATICAL SCRIPT CAPITAL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B0 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B0 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0055 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0055 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_120)
  {
      // 1D4B1;1D4B1;1D4B1;0056;0056; 
      // (𝒱; 𝒱; 𝒱; V; V; ) MATHEMATICAL SCRIPT CAPITAL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B1 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B1 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0056 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0056 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_121)
  {
      // 1D4B2;1D4B2;1D4B2;0057;0057; 
      // (𝒲; 𝒲; 𝒲; W; W; ) MATHEMATICAL SCRIPT CAPITAL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B2 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B2 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0057 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0057 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_122)
  {
      // 1D4B3;1D4B3;1D4B3;0058;0058; 
      // (𝒳; 𝒳; 𝒳; X; X; ) MATHEMATICAL SCRIPT CAPITAL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B3 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B3 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0058 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0058 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_123)
  {
      // 1D4B4;1D4B4;1D4B4;0059;0059; 
      // (𝒴; 𝒴; 𝒴; Y; Y; ) MATHEMATICAL SCRIPT CAPITAL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B4 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B4 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0059 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0059 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_124)
  {
      // 1D4B5;1D4B5;1D4B5;005A;005A; 
      // (𝒵; 𝒵; 𝒵; Z; Z; ) MATHEMATICAL SCRIPT CAPITAL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B5 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B5 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0x005A }};
          std::array<uint32_t, 1> const c5 = {{ 0x005A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_125)
  {
      // 1D4B6;1D4B6;1D4B6;0061;0061; 
      // (𝒶; 𝒶; 𝒶; a; a; ) MATHEMATICAL SCRIPT SMALL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B6 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B6 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0061 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0061 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_126)
  {
      // 1D4B7;1D4B7;1D4B7;0062;0062; 
      // (𝒷; 𝒷; 𝒷; b; b; ) MATHEMATICAL SCRIPT SMALL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B7 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B7 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0062 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0062 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_127)
  {
      // 1D4B8;1D4B8;1D4B8;0063;0063; 
      // (𝒸; 𝒸; 𝒸; c; c; ) MATHEMATICAL SCRIPT SMALL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B8 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B8 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0063 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0063 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_128)
  {
      // 1D4B9;1D4B9;1D4B9;0064;0064; 
      // (𝒹; 𝒹; 𝒹; d; d; ) MATHEMATICAL SCRIPT SMALL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4B9 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4B9 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0064 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0064 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_129)
  {
      // 1D4BB;1D4BB;1D4BB;0066;0066; 
      // (𝒻; 𝒻; 𝒻; f; f; ) MATHEMATICAL SCRIPT SMALL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4BB }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4BB }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4BB }};
          std::array<uint32_t, 1> const c4 = {{ 0x0066 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0066 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_130)
  {
      // 1D4BD;1D4BD;1D4BD;0068;0068; 
      // (𝒽; 𝒽; 𝒽; h; h; ) MATHEMATICAL SCRIPT SMALL H
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4BD }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4BD }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4BD }};
          std::array<uint32_t, 1> const c4 = {{ 0x0068 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0068 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_131)
  {
      // 1D4BE;1D4BE;1D4BE;0069;0069; 
      // (𝒾; 𝒾; 𝒾; i; i; ) MATHEMATICAL SCRIPT SMALL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4BE }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4BE }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4BE }};
          std::array<uint32_t, 1> const c4 = {{ 0x0069 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0069 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_132)
  {
      // 1D4BF;1D4BF;1D4BF;006A;006A; 
      // (𝒿; 𝒿; 𝒿; j; j; ) MATHEMATICAL SCRIPT SMALL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4BF }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4BF }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4BF }};
          std::array<uint32_t, 1> const c4 = {{ 0x006A }};
          std::array<uint32_t, 1> const c5 = {{ 0x006A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_133)
  {
      // 1D4C0;1D4C0;1D4C0;006B;006B; 
      // (𝓀; 𝓀; 𝓀; k; k; ) MATHEMATICAL SCRIPT SMALL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C0 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C0 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006B }};
          std::array<uint32_t, 1> const c5 = {{ 0x006B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_134)
  {
      // 1D4C1;1D4C1;1D4C1;006C;006C; 
      // (𝓁; 𝓁; 𝓁; l; l; ) MATHEMATICAL SCRIPT SMALL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C1 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C1 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006C }};
          std::array<uint32_t, 1> const c5 = {{ 0x006C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_135)
  {
      // 1D4C2;1D4C2;1D4C2;006D;006D; 
      // (𝓂; 𝓂; 𝓂; m; m; ) MATHEMATICAL SCRIPT SMALL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C2 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C2 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006D }};
          std::array<uint32_t, 1> const c5 = {{ 0x006D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_136)
  {
      // 1D4C3;1D4C3;1D4C3;006E;006E; 
      // (𝓃; 𝓃; 𝓃; n; n; ) MATHEMATICAL SCRIPT SMALL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C3 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C3 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C3 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006E }};
          std::array<uint32_t, 1> const c5 = {{ 0x006E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_137)
  {
      // 1D4C5;1D4C5;1D4C5;0070;0070; 
      // (𝓅; 𝓅; 𝓅; p; p; ) MATHEMATICAL SCRIPT SMALL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C5 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C5 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C5 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0070 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0070 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_138)
  {
      // 1D4C6;1D4C6;1D4C6;0071;0071; 
      // (𝓆; 𝓆; 𝓆; q; q; ) MATHEMATICAL SCRIPT SMALL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C6 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C6 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C6 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0071 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0071 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_139)
  {
      // 1D4C7;1D4C7;1D4C7;0072;0072; 
      // (𝓇; 𝓇; 𝓇; r; r; ) MATHEMATICAL SCRIPT SMALL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C7 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C7 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C7 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0072 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0072 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_140)
  {
      // 1D4C8;1D4C8;1D4C8;0073;0073; 
      // (𝓈; 𝓈; 𝓈; s; s; ) MATHEMATICAL SCRIPT SMALL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C8 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C8 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C8 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0073 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0073 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_141)
  {
      // 1D4C9;1D4C9;1D4C9;0074;0074; 
      // (𝓉; 𝓉; 𝓉; t; t; ) MATHEMATICAL SCRIPT SMALL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4C9 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4C9 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4C9 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0074 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0074 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_142)
  {
      // 1D4CA;1D4CA;1D4CA;0075;0075; 
      // (𝓊; 𝓊; 𝓊; u; u; ) MATHEMATICAL SCRIPT SMALL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4CA }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4CA }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4CA }};
          std::array<uint32_t, 1> const c4 = {{ 0x0075 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0075 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_143)
  {
      // 1D4CB;1D4CB;1D4CB;0076;0076; 
      // (𝓋; 𝓋; 𝓋; v; v; ) MATHEMATICAL SCRIPT SMALL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4CB }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4CB }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4CB }};
          std::array<uint32_t, 1> const c4 = {{ 0x0076 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0076 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_144)
  {
      // 1D4CC;1D4CC;1D4CC;0077;0077; 
      // (𝓌; 𝓌; 𝓌; w; w; ) MATHEMATICAL SCRIPT SMALL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4CC }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4CC }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4CC }};
          std::array<uint32_t, 1> const c4 = {{ 0x0077 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0077 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_145)
  {
      // 1D4CD;1D4CD;1D4CD;0078;0078; 
      // (𝓍; 𝓍; 𝓍; x; x; ) MATHEMATICAL SCRIPT SMALL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4CD }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4CD }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4CD }};
          std::array<uint32_t, 1> const c4 = {{ 0x0078 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0078 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_146)
  {
      // 1D4CE;1D4CE;1D4CE;0079;0079; 
      // (𝓎; 𝓎; 𝓎; y; y; ) MATHEMATICAL SCRIPT SMALL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4CE }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4CE }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4CE }};
          std::array<uint32_t, 1> const c4 = {{ 0x0079 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0079 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_147)
  {
      // 1D4CF;1D4CF;1D4CF;007A;007A; 
      // (𝓏; 𝓏; 𝓏; z; z; ) MATHEMATICAL SCRIPT SMALL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4CF }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4CF }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4CF }};
          std::array<uint32_t, 1> const c4 = {{ 0x007A }};
          std::array<uint32_t, 1> const c5 = {{ 0x007A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_148)
  {
      // 1D4D0;1D4D0;1D4D0;0041;0041; 
      // (𝓐; 𝓐; 𝓐; A; A; ) MATHEMATICAL BOLD SCRIPT CAPITAL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D0 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D0 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D0 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0041 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0041 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_149)
  {
      // 1D4D1;1D4D1;1D4D1;0042;0042; 
      // (𝓑; 𝓑; 𝓑; B; B; ) MATHEMATICAL BOLD SCRIPT CAPITAL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D1 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D1 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D1 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0042 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0042 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_150)
  {
      // 1D4D2;1D4D2;1D4D2;0043;0043; 
      // (𝓒; 𝓒; 𝓒; C; C; ) MATHEMATICAL BOLD SCRIPT CAPITAL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D2 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D2 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D2 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0043 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0043 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_151)
  {
      // 1D4D3;1D4D3;1D4D3;0044;0044; 
      // (𝓓; 𝓓; 𝓓; D; D; ) MATHEMATICAL BOLD SCRIPT CAPITAL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D3 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D3 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D3 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0044 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0044 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_152)
  {
      // 1D4D4;1D4D4;1D4D4;0045;0045; 
      // (𝓔; 𝓔; 𝓔; E; E; ) MATHEMATICAL BOLD SCRIPT CAPITAL E
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D4 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D4 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D4 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0045 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0045 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_153)
  {
      // 1D4D5;1D4D5;1D4D5;0046;0046; 
      // (𝓕; 𝓕; 𝓕; F; F; ) MATHEMATICAL BOLD SCRIPT CAPITAL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D5 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D5 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D5 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0046 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0046 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_154)
  {
      // 1D4D6;1D4D6;1D4D6;0047;0047; 
      // (𝓖; 𝓖; 𝓖; G; G; ) MATHEMATICAL BOLD SCRIPT CAPITAL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D6 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D6 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D6 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0047 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0047 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_155)
  {
      // 1D4D7;1D4D7;1D4D7;0048;0048; 
      // (𝓗; 𝓗; 𝓗; H; H; ) MATHEMATICAL BOLD SCRIPT CAPITAL H
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D7 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D7 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D7 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0048 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0048 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_156)
  {
      // 1D4D8;1D4D8;1D4D8;0049;0049; 
      // (𝓘; 𝓘; 𝓘; I; I; ) MATHEMATICAL BOLD SCRIPT CAPITAL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D8 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D8 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D8 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0049 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0049 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_157)
  {
      // 1D4D9;1D4D9;1D4D9;004A;004A; 
      // (𝓙; 𝓙; 𝓙; J; J; ) MATHEMATICAL BOLD SCRIPT CAPITAL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4D9 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4D9 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4D9 }};
          std::array<uint32_t, 1> const c4 = {{ 0x004A }};
          std::array<uint32_t, 1> const c5 = {{ 0x004A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_158)
  {
      // 1D4DA;1D4DA;1D4DA;004B;004B; 
      // (𝓚; 𝓚; 𝓚; K; K; ) MATHEMATICAL BOLD SCRIPT CAPITAL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4DA }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4DA }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4DA }};
          std::array<uint32_t, 1> const c4 = {{ 0x004B }};
          std::array<uint32_t, 1> const c5 = {{ 0x004B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_159)
  {
      // 1D4DB;1D4DB;1D4DB;004C;004C; 
      // (𝓛; 𝓛; 𝓛; L; L; ) MATHEMATICAL BOLD SCRIPT CAPITAL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4DB }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4DB }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4DB }};
          std::array<uint32_t, 1> const c4 = {{ 0x004C }};
          std::array<uint32_t, 1> const c5 = {{ 0x004C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_160)
  {
      // 1D4DC;1D4DC;1D4DC;004D;004D; 
      // (𝓜; 𝓜; 𝓜; M; M; ) MATHEMATICAL BOLD SCRIPT CAPITAL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4DC }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4DC }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4DC }};
          std::array<uint32_t, 1> const c4 = {{ 0x004D }};
          std::array<uint32_t, 1> const c5 = {{ 0x004D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_161)
  {
      // 1D4DD;1D4DD;1D4DD;004E;004E; 
      // (𝓝; 𝓝; 𝓝; N; N; ) MATHEMATICAL BOLD SCRIPT CAPITAL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4DD }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4DD }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4DD }};
          std::array<uint32_t, 1> const c4 = {{ 0x004E }};
          std::array<uint32_t, 1> const c5 = {{ 0x004E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_162)
  {
      // 1D4DE;1D4DE;1D4DE;004F;004F; 
      // (𝓞; 𝓞; 𝓞; O; O; ) MATHEMATICAL BOLD SCRIPT CAPITAL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4DE }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4DE }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4DE }};
          std::array<uint32_t, 1> const c4 = {{ 0x004F }};
          std::array<uint32_t, 1> const c5 = {{ 0x004F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_163)
  {
      // 1D4DF;1D4DF;1D4DF;0050;0050; 
      // (𝓟; 𝓟; 𝓟; P; P; ) MATHEMATICAL BOLD SCRIPT CAPITAL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4DF }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4DF }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4DF }};
          std::array<uint32_t, 1> const c4 = {{ 0x0050 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0050 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_164)
  {
      // 1D4E0;1D4E0;1D4E0;0051;0051; 
      // (𝓠; 𝓠; 𝓠; Q; Q; ) MATHEMATICAL BOLD SCRIPT CAPITAL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E0 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E0 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E0 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0051 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0051 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_165)
  {
      // 1D4E1;1D4E1;1D4E1;0052;0052; 
      // (𝓡; 𝓡; 𝓡; R; R; ) MATHEMATICAL BOLD SCRIPT CAPITAL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E1 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E1 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E1 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0052 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0052 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_166)
  {
      // 1D4E2;1D4E2;1D4E2;0053;0053; 
      // (𝓢; 𝓢; 𝓢; S; S; ) MATHEMATICAL BOLD SCRIPT CAPITAL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E2 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E2 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E2 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0053 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0053 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_167)
  {
      // 1D4E3;1D4E3;1D4E3;0054;0054; 
      // (𝓣; 𝓣; 𝓣; T; T; ) MATHEMATICAL BOLD SCRIPT CAPITAL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E3 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E3 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E3 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0054 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0054 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_168)
  {
      // 1D4E4;1D4E4;1D4E4;0055;0055; 
      // (𝓤; 𝓤; 𝓤; U; U; ) MATHEMATICAL BOLD SCRIPT CAPITAL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E4 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E4 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E4 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0055 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0055 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_169)
  {
      // 1D4E5;1D4E5;1D4E5;0056;0056; 
      // (𝓥; 𝓥; 𝓥; V; V; ) MATHEMATICAL BOLD SCRIPT CAPITAL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E5 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E5 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E5 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0056 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0056 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_170)
  {
      // 1D4E6;1D4E6;1D4E6;0057;0057; 
      // (𝓦; 𝓦; 𝓦; W; W; ) MATHEMATICAL BOLD SCRIPT CAPITAL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E6 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E6 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E6 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0057 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0057 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_171)
  {
      // 1D4E7;1D4E7;1D4E7;0058;0058; 
      // (𝓧; 𝓧; 𝓧; X; X; ) MATHEMATICAL BOLD SCRIPT CAPITAL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E7 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E7 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E7 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0058 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0058 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_172)
  {
      // 1D4E8;1D4E8;1D4E8;0059;0059; 
      // (𝓨; 𝓨; 𝓨; Y; Y; ) MATHEMATICAL BOLD SCRIPT CAPITAL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E8 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E8 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E8 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0059 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0059 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_173)
  {
      // 1D4E9;1D4E9;1D4E9;005A;005A; 
      // (𝓩; 𝓩; 𝓩; Z; Z; ) MATHEMATICAL BOLD SCRIPT CAPITAL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4E9 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4E9 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4E9 }};
          std::array<uint32_t, 1> const c4 = {{ 0x005A }};
          std::array<uint32_t, 1> const c5 = {{ 0x005A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_174)
  {
      // 1D4EA;1D4EA;1D4EA;0061;0061; 
      // (𝓪; 𝓪; 𝓪; a; a; ) MATHEMATICAL BOLD SCRIPT SMALL A
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4EA }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4EA }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4EA }};
          std::array<uint32_t, 1> const c4 = {{ 0x0061 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0061 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_175)
  {
      // 1D4EB;1D4EB;1D4EB;0062;0062; 
      // (𝓫; 𝓫; 𝓫; b; b; ) MATHEMATICAL BOLD SCRIPT SMALL B
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4EB }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4EB }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4EB }};
          std::array<uint32_t, 1> const c4 = {{ 0x0062 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0062 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_176)
  {
      // 1D4EC;1D4EC;1D4EC;0063;0063; 
      // (𝓬; 𝓬; 𝓬; c; c; ) MATHEMATICAL BOLD SCRIPT SMALL C
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4EC }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4EC }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4EC }};
          std::array<uint32_t, 1> const c4 = {{ 0x0063 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0063 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_177)
  {
      // 1D4ED;1D4ED;1D4ED;0064;0064; 
      // (𝓭; 𝓭; 𝓭; d; d; ) MATHEMATICAL BOLD SCRIPT SMALL D
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4ED }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4ED }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4ED }};
          std::array<uint32_t, 1> const c4 = {{ 0x0064 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0064 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_178)
  {
      // 1D4EE;1D4EE;1D4EE;0065;0065; 
      // (𝓮; 𝓮; 𝓮; e; e; ) MATHEMATICAL BOLD SCRIPT SMALL E
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4EE }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4EE }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4EE }};
          std::array<uint32_t, 1> const c4 = {{ 0x0065 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0065 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_179)
  {
      // 1D4EF;1D4EF;1D4EF;0066;0066; 
      // (𝓯; 𝓯; 𝓯; f; f; ) MATHEMATICAL BOLD SCRIPT SMALL F
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4EF }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4EF }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4EF }};
          std::array<uint32_t, 1> const c4 = {{ 0x0066 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0066 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_180)
  {
      // 1D4F0;1D4F0;1D4F0;0067;0067; 
      // (𝓰; 𝓰; 𝓰; g; g; ) MATHEMATICAL BOLD SCRIPT SMALL G
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F0 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F0 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F0 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0067 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0067 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_181)
  {
      // 1D4F1;1D4F1;1D4F1;0068;0068; 
      // (𝓱; 𝓱; 𝓱; h; h; ) MATHEMATICAL BOLD SCRIPT SMALL H
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F1 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F1 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F1 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0068 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0068 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_182)
  {
      // 1D4F2;1D4F2;1D4F2;0069;0069; 
      // (𝓲; 𝓲; 𝓲; i; i; ) MATHEMATICAL BOLD SCRIPT SMALL I
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F2 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F2 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F2 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0069 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0069 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_183)
  {
      // 1D4F3;1D4F3;1D4F3;006A;006A; 
      // (𝓳; 𝓳; 𝓳; j; j; ) MATHEMATICAL BOLD SCRIPT SMALL J
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F3 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F3 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F3 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006A }};
          std::array<uint32_t, 1> const c5 = {{ 0x006A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_184)
  {
      // 1D4F4;1D4F4;1D4F4;006B;006B; 
      // (𝓴; 𝓴; 𝓴; k; k; ) MATHEMATICAL BOLD SCRIPT SMALL K
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F4 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F4 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F4 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006B }};
          std::array<uint32_t, 1> const c5 = {{ 0x006B }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_185)
  {
      // 1D4F5;1D4F5;1D4F5;006C;006C; 
      // (𝓵; 𝓵; 𝓵; l; l; ) MATHEMATICAL BOLD SCRIPT SMALL L
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F5 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F5 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F5 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006C }};
          std::array<uint32_t, 1> const c5 = {{ 0x006C }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_186)
  {
      // 1D4F6;1D4F6;1D4F6;006D;006D; 
      // (𝓶; 𝓶; 𝓶; m; m; ) MATHEMATICAL BOLD SCRIPT SMALL M
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F6 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F6 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F6 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006D }};
          std::array<uint32_t, 1> const c5 = {{ 0x006D }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_187)
  {
      // 1D4F7;1D4F7;1D4F7;006E;006E; 
      // (𝓷; 𝓷; 𝓷; n; n; ) MATHEMATICAL BOLD SCRIPT SMALL N
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F7 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F7 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F7 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006E }};
          std::array<uint32_t, 1> const c5 = {{ 0x006E }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_188)
  {
      // 1D4F8;1D4F8;1D4F8;006F;006F; 
      // (𝓸; 𝓸; 𝓸; o; o; ) MATHEMATICAL BOLD SCRIPT SMALL O
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F8 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F8 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F8 }};
          std::array<uint32_t, 1> const c4 = {{ 0x006F }};
          std::array<uint32_t, 1> const c5 = {{ 0x006F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_189)
  {
      // 1D4F9;1D4F9;1D4F9;0070;0070; 
      // (𝓹; 𝓹; 𝓹; p; p; ) MATHEMATICAL BOLD SCRIPT SMALL P
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4F9 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4F9 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4F9 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0070 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0070 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_190)
  {
      // 1D4FA;1D4FA;1D4FA;0071;0071; 
      // (𝓺; 𝓺; 𝓺; q; q; ) MATHEMATICAL BOLD SCRIPT SMALL Q
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4FA }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4FA }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4FA }};
          std::array<uint32_t, 1> const c4 = {{ 0x0071 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0071 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_191)
  {
      // 1D4FB;1D4FB;1D4FB;0072;0072; 
      // (𝓻; 𝓻; 𝓻; r; r; ) MATHEMATICAL BOLD SCRIPT SMALL R
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4FB }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4FB }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4FB }};
          std::array<uint32_t, 1> const c4 = {{ 0x0072 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0072 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_192)
  {
      // 1D4FC;1D4FC;1D4FC;0073;0073; 
      // (𝓼; 𝓼; 𝓼; s; s; ) MATHEMATICAL BOLD SCRIPT SMALL S
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4FC }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4FC }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4FC }};
          std::array<uint32_t, 1> const c4 = {{ 0x0073 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0073 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_193)
  {
      // 1D4FD;1D4FD;1D4FD;0074;0074; 
      // (𝓽; 𝓽; 𝓽; t; t; ) MATHEMATICAL BOLD SCRIPT SMALL T
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4FD }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4FD }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4FD }};
          std::array<uint32_t, 1> const c4 = {{ 0x0074 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0074 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_194)
  {
      // 1D4FE;1D4FE;1D4FE;0075;0075; 
      // (𝓾; 𝓾; 𝓾; u; u; ) MATHEMATICAL BOLD SCRIPT SMALL U
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4FE }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4FE }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4FE }};
          std::array<uint32_t, 1> const c4 = {{ 0x0075 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0075 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_195)
  {
      // 1D4FF;1D4FF;1D4FF;0076;0076; 
      // (𝓿; 𝓿; 𝓿; v; v; ) MATHEMATICAL BOLD SCRIPT SMALL V
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D4FF }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D4FF }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D4FF }};
          std::array<uint32_t, 1> const c4 = {{ 0x0076 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0076 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_196)
  {
      // 1D500;1D500;1D500;0077;0077; 
      // (𝔀; 𝔀; 𝔀; w; w; ) MATHEMATICAL BOLD SCRIPT SMALL W
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D500 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D500 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D500 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0077 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0077 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_197)
  {
      // 1D501;1D501;1D501;0078;0078; 
      // (𝔁; 𝔁; 𝔁; x; x; ) MATHEMATICAL BOLD SCRIPT SMALL X
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D501 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D501 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D501 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0078 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0078 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_198)
  {
      // 1D502;1D502;1D502;0079;0079; 
      // (𝔂; 𝔂; 𝔂; y; y; ) MATHEMATICAL BOLD SCRIPT SMALL Y
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D502 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D502 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D502 }};
          std::array<uint32_t, 1> const c4 = {{ 0x0079 }};
          std::array<uint32_t, 1> const c5 = {{ 0x0079 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfc_076_199)
  {
      // 1D503;1D503;1D503;007A;007A; 
      // (𝔃; 𝔃; 𝔃; z; z; ) MATHEMATICAL BOLD SCRIPT SMALL Z
      {
          std::array<uint32_t, 1> const c1 = {{ 0x1D503 }};
          std::array<uint32_t, 1> const c2 = {{ 0x1D503 }};
          std::array<uint32_t, 1> const c3 = {{ 0x1D503 }};
          std::array<uint32_t, 1> const c4 = {{ 0x007A }};
          std::array<uint32_t, 1> const c5 = {{ 0x007A }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfkc(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c2.size());
              auto c2_it = c2.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c2_it) << "iteration " << i;
                  ++c2_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  