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_061_000)
  {
      // D238;D238;1110 116E 11B3;D238;1110 116E 11B3; 
      // (툸; 툸; 툸; 툸; 툸; ) HANGUL SYLLABLE TULS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD238 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD238 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD238 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_001)
  {
      // D239;D239;1110 116E 11B4;D239;1110 116E 11B4; 
      // (툹; 툹; 툹; 툹; 툹; ) HANGUL SYLLABLE TULT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD239 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD239 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD239 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_002)
  {
      // D23A;D23A;1110 116E 11B5;D23A;1110 116E 11B5; 
      // (툺; 툺; 툺; 툺; 툺; ) HANGUL SYLLABLE TULP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD23A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD23A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD23A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_003)
  {
      // D23B;D23B;1110 116E 11B6;D23B;1110 116E 11B6; 
      // (툻; 툻; 툻; 툻; 툻; ) HANGUL SYLLABLE TULH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD23B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD23B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD23B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_004)
  {
      // D23C;D23C;1110 116E 11B7;D23C;1110 116E 11B7; 
      // (툼; 툼; 툼; 툼; 툼; ) HANGUL SYLLABLE TUM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD23C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD23C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD23C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_005)
  {
      // D23D;D23D;1110 116E 11B8;D23D;1110 116E 11B8; 
      // (툽; 툽; 툽; 툽; 툽; ) HANGUL SYLLABLE TUB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD23D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD23D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD23D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_006)
  {
      // D23E;D23E;1110 116E 11B9;D23E;1110 116E 11B9; 
      // (툾; 툾; 툾; 툾; 툾; ) HANGUL SYLLABLE TUBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD23E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD23E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD23E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_007)
  {
      // D23F;D23F;1110 116E 11BA;D23F;1110 116E 11BA; 
      // (툿; 툿; 툿; 툿; 툿; ) HANGUL SYLLABLE TUS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD23F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD23F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD23F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_008)
  {
      // D240;D240;1110 116E 11BB;D240;1110 116E 11BB; 
      // (퉀; 퉀; 퉀; 퉀; 퉀; ) HANGUL SYLLABLE TUSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD240 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD240 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD240 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_009)
  {
      // D241;D241;1110 116E 11BC;D241;1110 116E 11BC; 
      // (퉁; 퉁; 퉁; 퉁; 퉁; ) HANGUL SYLLABLE TUNG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD241 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD241 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD241 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_010)
  {
      // D242;D242;1110 116E 11BD;D242;1110 116E 11BD; 
      // (퉂; 퉂; 퉂; 퉂; 퉂; ) HANGUL SYLLABLE TUJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD242 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD242 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD242 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_011)
  {
      // D243;D243;1110 116E 11BE;D243;1110 116E 11BE; 
      // (퉃; 퉃; 퉃; 퉃; 퉃; ) HANGUL SYLLABLE TUC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD243 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD243 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD243 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_012)
  {
      // D244;D244;1110 116E 11BF;D244;1110 116E 11BF; 
      // (퉄; 퉄; 퉄; 퉄; 퉄; ) HANGUL SYLLABLE TUK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD244 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD244 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD244 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_013)
  {
      // D245;D245;1110 116E 11C0;D245;1110 116E 11C0; 
      // (퉅; 퉅; 퉅; 퉅; 퉅; ) HANGUL SYLLABLE TUT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD245 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD245 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD245 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_014)
  {
      // D246;D246;1110 116E 11C1;D246;1110 116E 11C1; 
      // (퉆; 퉆; 퉆; 퉆; 퉆; ) HANGUL SYLLABLE TUP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD246 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD246 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD246 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_015)
  {
      // D247;D247;1110 116E 11C2;D247;1110 116E 11C2; 
      // (퉇; 퉇; 퉇; 퉇; 퉇; ) HANGUL SYLLABLE TUH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD247 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD247 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116E, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD247 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116E, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_016)
  {
      // D248;D248;1110 116F;D248;1110 116F; 
      // (퉈; 퉈; 퉈; 퉈; 퉈; ) HANGUL SYLLABLE TWEO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD248 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD248 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x116F }};
          std::array<uint32_t, 1> const c4 = {{ 0xD248 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x116F }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_017)
  {
      // D249;D249;1110 116F 11A8;D249;1110 116F 11A8; 
      // (퉉; 퉉; 퉉; 퉉; 퉉; ) HANGUL SYLLABLE TWEOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD249 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD249 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD249 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_018)
  {
      // D24A;D24A;1110 116F 11A9;D24A;1110 116F 11A9; 
      // (퉊; 퉊; 퉊; 퉊; 퉊; ) HANGUL SYLLABLE TWEOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD24A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD24A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD24A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_019)
  {
      // D24B;D24B;1110 116F 11AA;D24B;1110 116F 11AA; 
      // (퉋; 퉋; 퉋; 퉋; 퉋; ) HANGUL SYLLABLE TWEOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD24B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD24B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD24B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_020)
  {
      // D24C;D24C;1110 116F 11AB;D24C;1110 116F 11AB; 
      // (퉌; 퉌; 퉌; 퉌; 퉌; ) HANGUL SYLLABLE TWEON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD24C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD24C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD24C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_021)
  {
      // D24D;D24D;1110 116F 11AC;D24D;1110 116F 11AC; 
      // (퉍; 퉍; 퉍; 퉍; 퉍; ) HANGUL SYLLABLE TWEONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD24D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD24D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD24D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_022)
  {
      // D24E;D24E;1110 116F 11AD;D24E;1110 116F 11AD; 
      // (퉎; 퉎; 퉎; 퉎; 퉎; ) HANGUL SYLLABLE TWEONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD24E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD24E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD24E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_023)
  {
      // D24F;D24F;1110 116F 11AE;D24F;1110 116F 11AE; 
      // (퉏; 퉏; 퉏; 퉏; 퉏; ) HANGUL SYLLABLE TWEOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD24F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD24F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD24F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_024)
  {
      // D250;D250;1110 116F 11AF;D250;1110 116F 11AF; 
      // (퉐; 퉐; 퉐; 퉐; 퉐; ) HANGUL SYLLABLE TWEOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD250 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD250 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD250 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_025)
  {
      // D251;D251;1110 116F 11B0;D251;1110 116F 11B0; 
      // (퉑; 퉑; 퉑; 퉑; 퉑; ) HANGUL SYLLABLE TWEOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD251 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD251 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD251 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_026)
  {
      // D252;D252;1110 116F 11B1;D252;1110 116F 11B1; 
      // (퉒; 퉒; 퉒; 퉒; 퉒; ) HANGUL SYLLABLE TWEOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD252 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD252 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD252 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_027)
  {
      // D253;D253;1110 116F 11B2;D253;1110 116F 11B2; 
      // (퉓; 퉓; 퉓; 퉓; 퉓; ) HANGUL SYLLABLE TWEOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD253 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD253 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD253 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_028)
  {
      // D254;D254;1110 116F 11B3;D254;1110 116F 11B3; 
      // (퉔; 퉔; 퉔; 퉔; 퉔; ) HANGUL SYLLABLE TWEOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD254 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD254 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD254 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_029)
  {
      // D255;D255;1110 116F 11B4;D255;1110 116F 11B4; 
      // (퉕; 퉕; 퉕; 퉕; 퉕; ) HANGUL SYLLABLE TWEOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD255 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD255 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD255 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_030)
  {
      // D256;D256;1110 116F 11B5;D256;1110 116F 11B5; 
      // (퉖; 퉖; 퉖; 퉖; 퉖; ) HANGUL SYLLABLE TWEOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD256 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD256 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD256 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_031)
  {
      // D257;D257;1110 116F 11B6;D257;1110 116F 11B6; 
      // (퉗; 퉗; 퉗; 퉗; 퉗; ) HANGUL SYLLABLE TWEOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD257 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD257 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD257 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_032)
  {
      // D258;D258;1110 116F 11B7;D258;1110 116F 11B7; 
      // (퉘; 퉘; 퉘; 퉘; 퉘; ) HANGUL SYLLABLE TWEOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD258 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD258 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD258 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_033)
  {
      // D259;D259;1110 116F 11B8;D259;1110 116F 11B8; 
      // (퉙; 퉙; 퉙; 퉙; 퉙; ) HANGUL SYLLABLE TWEOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD259 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD259 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD259 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_034)
  {
      // D25A;D25A;1110 116F 11B9;D25A;1110 116F 11B9; 
      // (퉚; 퉚; 퉚; 퉚; 퉚; ) HANGUL SYLLABLE TWEOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD25A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD25A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD25A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_035)
  {
      // D25B;D25B;1110 116F 11BA;D25B;1110 116F 11BA; 
      // (퉛; 퉛; 퉛; 퉛; 퉛; ) HANGUL SYLLABLE TWEOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD25B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD25B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD25B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_036)
  {
      // D25C;D25C;1110 116F 11BB;D25C;1110 116F 11BB; 
      // (퉜; 퉜; 퉜; 퉜; 퉜; ) HANGUL SYLLABLE TWEOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD25C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD25C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD25C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_037)
  {
      // D25D;D25D;1110 116F 11BC;D25D;1110 116F 11BC; 
      // (퉝; 퉝; 퉝; 퉝; 퉝; ) HANGUL SYLLABLE TWEONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD25D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD25D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD25D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_038)
  {
      // D25E;D25E;1110 116F 11BD;D25E;1110 116F 11BD; 
      // (퉞; 퉞; 퉞; 퉞; 퉞; ) HANGUL SYLLABLE TWEOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD25E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD25E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD25E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_039)
  {
      // D25F;D25F;1110 116F 11BE;D25F;1110 116F 11BE; 
      // (퉟; 퉟; 퉟; 퉟; 퉟; ) HANGUL SYLLABLE TWEOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD25F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD25F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD25F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_040)
  {
      // D260;D260;1110 116F 11BF;D260;1110 116F 11BF; 
      // (퉠; 퉠; 퉠; 퉠; 퉠; ) HANGUL SYLLABLE TWEOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD260 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD260 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD260 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_041)
  {
      // D261;D261;1110 116F 11C0;D261;1110 116F 11C0; 
      // (퉡; 퉡; 퉡; 퉡; 퉡; ) HANGUL SYLLABLE TWEOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD261 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD261 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD261 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_042)
  {
      // D262;D262;1110 116F 11C1;D262;1110 116F 11C1; 
      // (퉢; 퉢; 퉢; 퉢; 퉢; ) HANGUL SYLLABLE TWEOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD262 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD262 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD262 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_043)
  {
      // D263;D263;1110 116F 11C2;D263;1110 116F 11C2; 
      // (퉣; 퉣; 퉣; 퉣; 퉣; ) HANGUL SYLLABLE TWEOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD263 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD263 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x116F, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD263 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x116F, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_044)
  {
      // D264;D264;1110 1170;D264;1110 1170; 
      // (퉤; 퉤; 퉤; 퉤; 퉤; ) HANGUL SYLLABLE TWE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD264 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD264 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x1170 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD264 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x1170 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_045)
  {
      // D265;D265;1110 1170 11A8;D265;1110 1170 11A8; 
      // (퉥; 퉥; 퉥; 퉥; 퉥; ) HANGUL SYLLABLE TWEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD265 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD265 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD265 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_046)
  {
      // D266;D266;1110 1170 11A9;D266;1110 1170 11A9; 
      // (퉦; 퉦; 퉦; 퉦; 퉦; ) HANGUL SYLLABLE TWEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD266 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD266 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD266 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_047)
  {
      // D267;D267;1110 1170 11AA;D267;1110 1170 11AA; 
      // (퉧; 퉧; 퉧; 퉧; 퉧; ) HANGUL SYLLABLE TWEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD267 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD267 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD267 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_048)
  {
      // D268;D268;1110 1170 11AB;D268;1110 1170 11AB; 
      // (퉨; 퉨; 퉨; 퉨; 퉨; ) HANGUL SYLLABLE TWEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD268 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD268 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD268 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_049)
  {
      // D269;D269;1110 1170 11AC;D269;1110 1170 11AC; 
      // (퉩; 퉩; 퉩; 퉩; 퉩; ) HANGUL SYLLABLE TWENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD269 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD269 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD269 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_050)
  {
      // D26A;D26A;1110 1170 11AD;D26A;1110 1170 11AD; 
      // (퉪; 퉪; 퉪; 퉪; 퉪; ) HANGUL SYLLABLE TWENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD26A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD26A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD26A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_051)
  {
      // D26B;D26B;1110 1170 11AE;D26B;1110 1170 11AE; 
      // (퉫; 퉫; 퉫; 퉫; 퉫; ) HANGUL SYLLABLE TWED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD26B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD26B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD26B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_052)
  {
      // D26C;D26C;1110 1170 11AF;D26C;1110 1170 11AF; 
      // (퉬; 퉬; 퉬; 퉬; 퉬; ) HANGUL SYLLABLE TWEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD26C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD26C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD26C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_053)
  {
      // D26D;D26D;1110 1170 11B0;D26D;1110 1170 11B0; 
      // (퉭; 퉭; 퉭; 퉭; 퉭; ) HANGUL SYLLABLE TWELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD26D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD26D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD26D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_054)
  {
      // D26E;D26E;1110 1170 11B1;D26E;1110 1170 11B1; 
      // (퉮; 퉮; 퉮; 퉮; 퉮; ) HANGUL SYLLABLE TWELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD26E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD26E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD26E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_055)
  {
      // D26F;D26F;1110 1170 11B2;D26F;1110 1170 11B2; 
      // (퉯; 퉯; 퉯; 퉯; 퉯; ) HANGUL SYLLABLE TWELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD26F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD26F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD26F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_056)
  {
      // D270;D270;1110 1170 11B3;D270;1110 1170 11B3; 
      // (퉰; 퉰; 퉰; 퉰; 퉰; ) HANGUL SYLLABLE TWELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD270 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD270 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD270 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_057)
  {
      // D271;D271;1110 1170 11B4;D271;1110 1170 11B4; 
      // (퉱; 퉱; 퉱; 퉱; 퉱; ) HANGUL SYLLABLE TWELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD271 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD271 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD271 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_058)
  {
      // D272;D272;1110 1170 11B5;D272;1110 1170 11B5; 
      // (퉲; 퉲; 퉲; 퉲; 퉲; ) HANGUL SYLLABLE TWELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD272 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD272 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD272 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_059)
  {
      // D273;D273;1110 1170 11B6;D273;1110 1170 11B6; 
      // (퉳; 퉳; 퉳; 퉳; 퉳; ) HANGUL SYLLABLE TWELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD273 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD273 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD273 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_060)
  {
      // D274;D274;1110 1170 11B7;D274;1110 1170 11B7; 
      // (퉴; 퉴; 퉴; 퉴; 퉴; ) HANGUL SYLLABLE TWEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD274 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD274 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD274 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_061)
  {
      // D275;D275;1110 1170 11B8;D275;1110 1170 11B8; 
      // (퉵; 퉵; 퉵; 퉵; 퉵; ) HANGUL SYLLABLE TWEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD275 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD275 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD275 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_062)
  {
      // D276;D276;1110 1170 11B9;D276;1110 1170 11B9; 
      // (퉶; 퉶; 퉶; 퉶; 퉶; ) HANGUL SYLLABLE TWEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD276 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD276 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD276 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_063)
  {
      // D277;D277;1110 1170 11BA;D277;1110 1170 11BA; 
      // (퉷; 퉷; 퉷; 퉷; 퉷; ) HANGUL SYLLABLE TWES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD277 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD277 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD277 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_064)
  {
      // D278;D278;1110 1170 11BB;D278;1110 1170 11BB; 
      // (퉸; 퉸; 퉸; 퉸; 퉸; ) HANGUL SYLLABLE TWESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD278 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD278 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD278 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_065)
  {
      // D279;D279;1110 1170 11BC;D279;1110 1170 11BC; 
      // (퉹; 퉹; 퉹; 퉹; 퉹; ) HANGUL SYLLABLE TWENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD279 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD279 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD279 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_066)
  {
      // D27A;D27A;1110 1170 11BD;D27A;1110 1170 11BD; 
      // (퉺; 퉺; 퉺; 퉺; 퉺; ) HANGUL SYLLABLE TWEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD27A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD27A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD27A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_067)
  {
      // D27B;D27B;1110 1170 11BE;D27B;1110 1170 11BE; 
      // (퉻; 퉻; 퉻; 퉻; 퉻; ) HANGUL SYLLABLE TWEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD27B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD27B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD27B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_068)
  {
      // D27C;D27C;1110 1170 11BF;D27C;1110 1170 11BF; 
      // (퉼; 퉼; 퉼; 퉼; 퉼; ) HANGUL SYLLABLE TWEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD27C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD27C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD27C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_069)
  {
      // D27D;D27D;1110 1170 11C0;D27D;1110 1170 11C0; 
      // (퉽; 퉽; 퉽; 퉽; 퉽; ) HANGUL SYLLABLE TWET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD27D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD27D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD27D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_070)
  {
      // D27E;D27E;1110 1170 11C1;D27E;1110 1170 11C1; 
      // (퉾; 퉾; 퉾; 퉾; 퉾; ) HANGUL SYLLABLE TWEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD27E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD27E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD27E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_071)
  {
      // D27F;D27F;1110 1170 11C2;D27F;1110 1170 11C2; 
      // (퉿; 퉿; 퉿; 퉿; 퉿; ) HANGUL SYLLABLE TWEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD27F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD27F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1170, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD27F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1170, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_072)
  {
      // D280;D280;1110 1171;D280;1110 1171; 
      // (튀; 튀; 튀; 튀; 튀; ) HANGUL SYLLABLE TWI
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD280 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD280 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x1171 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD280 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x1171 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_073)
  {
      // D281;D281;1110 1171 11A8;D281;1110 1171 11A8; 
      // (튁; 튁; 튁; 튁; 튁; ) HANGUL SYLLABLE TWIG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD281 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD281 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD281 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_074)
  {
      // D282;D282;1110 1171 11A9;D282;1110 1171 11A9; 
      // (튂; 튂; 튂; 튂; 튂; ) HANGUL SYLLABLE TWIGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD282 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD282 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD282 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_075)
  {
      // D283;D283;1110 1171 11AA;D283;1110 1171 11AA; 
      // (튃; 튃; 튃; 튃; 튃; ) HANGUL SYLLABLE TWIGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD283 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD283 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD283 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_076)
  {
      // D284;D284;1110 1171 11AB;D284;1110 1171 11AB; 
      // (튄; 튄; 튄; 튄; 튄; ) HANGUL SYLLABLE TWIN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD284 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD284 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD284 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_077)
  {
      // D285;D285;1110 1171 11AC;D285;1110 1171 11AC; 
      // (튅; 튅; 튅; 튅; 튅; ) HANGUL SYLLABLE TWINJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD285 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD285 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD285 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_078)
  {
      // D286;D286;1110 1171 11AD;D286;1110 1171 11AD; 
      // (튆; 튆; 튆; 튆; 튆; ) HANGUL SYLLABLE TWINH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD286 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD286 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD286 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_079)
  {
      // D287;D287;1110 1171 11AE;D287;1110 1171 11AE; 
      // (튇; 튇; 튇; 튇; 튇; ) HANGUL SYLLABLE TWID
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD287 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD287 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD287 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_080)
  {
      // D288;D288;1110 1171 11AF;D288;1110 1171 11AF; 
      // (튈; 튈; 튈; 튈; 튈; ) HANGUL SYLLABLE TWIL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD288 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD288 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD288 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_081)
  {
      // D289;D289;1110 1171 11B0;D289;1110 1171 11B0; 
      // (튉; 튉; 튉; 튉; 튉; ) HANGUL SYLLABLE TWILG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD289 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD289 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD289 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_082)
  {
      // D28A;D28A;1110 1171 11B1;D28A;1110 1171 11B1; 
      // (튊; 튊; 튊; 튊; 튊; ) HANGUL SYLLABLE TWILM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD28A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD28A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD28A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_083)
  {
      // D28B;D28B;1110 1171 11B2;D28B;1110 1171 11B2; 
      // (튋; 튋; 튋; 튋; 튋; ) HANGUL SYLLABLE TWILB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD28B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD28B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD28B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_084)
  {
      // D28C;D28C;1110 1171 11B3;D28C;1110 1171 11B3; 
      // (튌; 튌; 튌; 튌; 튌; ) HANGUL SYLLABLE TWILS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD28C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD28C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD28C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_085)
  {
      // D28D;D28D;1110 1171 11B4;D28D;1110 1171 11B4; 
      // (튍; 튍; 튍; 튍; 튍; ) HANGUL SYLLABLE TWILT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD28D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD28D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD28D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_086)
  {
      // D28E;D28E;1110 1171 11B5;D28E;1110 1171 11B5; 
      // (튎; 튎; 튎; 튎; 튎; ) HANGUL SYLLABLE TWILP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD28E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD28E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD28E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_087)
  {
      // D28F;D28F;1110 1171 11B6;D28F;1110 1171 11B6; 
      // (튏; 튏; 튏; 튏; 튏; ) HANGUL SYLLABLE TWILH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD28F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD28F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD28F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_088)
  {
      // D290;D290;1110 1171 11B7;D290;1110 1171 11B7; 
      // (튐; 튐; 튐; 튐; 튐; ) HANGUL SYLLABLE TWIM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD290 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD290 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD290 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_089)
  {
      // D291;D291;1110 1171 11B8;D291;1110 1171 11B8; 
      // (튑; 튑; 튑; 튑; 튑; ) HANGUL SYLLABLE TWIB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD291 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD291 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD291 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_090)
  {
      // D292;D292;1110 1171 11B9;D292;1110 1171 11B9; 
      // (튒; 튒; 튒; 튒; 튒; ) HANGUL SYLLABLE TWIBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD292 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD292 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD292 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_091)
  {
      // D293;D293;1110 1171 11BA;D293;1110 1171 11BA; 
      // (튓; 튓; 튓; 튓; 튓; ) HANGUL SYLLABLE TWIS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD293 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD293 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD293 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_092)
  {
      // D294;D294;1110 1171 11BB;D294;1110 1171 11BB; 
      // (튔; 튔; 튔; 튔; 튔; ) HANGUL SYLLABLE TWISS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD294 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD294 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD294 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_093)
  {
      // D295;D295;1110 1171 11BC;D295;1110 1171 11BC; 
      // (튕; 튕; 튕; 튕; 튕; ) HANGUL SYLLABLE TWING
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD295 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD295 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD295 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_094)
  {
      // D296;D296;1110 1171 11BD;D296;1110 1171 11BD; 
      // (튖; 튖; 튖; 튖; 튖; ) HANGUL SYLLABLE TWIJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD296 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD296 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD296 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_095)
  {
      // D297;D297;1110 1171 11BE;D297;1110 1171 11BE; 
      // (튗; 튗; 튗; 튗; 튗; ) HANGUL SYLLABLE TWIC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD297 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD297 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD297 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_096)
  {
      // D298;D298;1110 1171 11BF;D298;1110 1171 11BF; 
      // (튘; 튘; 튘; 튘; 튘; ) HANGUL SYLLABLE TWIK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD298 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD298 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD298 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_097)
  {
      // D299;D299;1110 1171 11C0;D299;1110 1171 11C0; 
      // (튙; 튙; 튙; 튙; 튙; ) HANGUL SYLLABLE TWIT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD299 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD299 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD299 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_098)
  {
      // D29A;D29A;1110 1171 11C1;D29A;1110 1171 11C1; 
      // (튚; 튚; 튚; 튚; 튚; ) HANGUL SYLLABLE TWIP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD29A }};
          std::array<uint32_t, 1> const c2 = {{ 0xD29A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD29A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_099)
  {
      // D29B;D29B;1110 1171 11C2;D29B;1110 1171 11C2; 
      // (튛; 튛; 튛; 튛; 튛; ) HANGUL SYLLABLE TWIH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD29B }};
          std::array<uint32_t, 1> const c2 = {{ 0xD29B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1171, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD29B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1171, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_100)
  {
      // D29C;D29C;1110 1172;D29C;1110 1172; 
      // (튜; 튜; 튜; 튜; 튜; ) HANGUL SYLLABLE TYU
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD29C }};
          std::array<uint32_t, 1> const c2 = {{ 0xD29C }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x1172 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD29C }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x1172 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_101)
  {
      // D29D;D29D;1110 1172 11A8;D29D;1110 1172 11A8; 
      // (튝; 튝; 튝; 튝; 튝; ) HANGUL SYLLABLE TYUG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD29D }};
          std::array<uint32_t, 1> const c2 = {{ 0xD29D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD29D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_102)
  {
      // D29E;D29E;1110 1172 11A9;D29E;1110 1172 11A9; 
      // (튞; 튞; 튞; 튞; 튞; ) HANGUL SYLLABLE TYUGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD29E }};
          std::array<uint32_t, 1> const c2 = {{ 0xD29E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD29E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_103)
  {
      // D29F;D29F;1110 1172 11AA;D29F;1110 1172 11AA; 
      // (튟; 튟; 튟; 튟; 튟; ) HANGUL SYLLABLE TYUGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD29F }};
          std::array<uint32_t, 1> const c2 = {{ 0xD29F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD29F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_104)
  {
      // D2A0;D2A0;1110 1172 11AB;D2A0;1110 1172 11AB; 
      // (튠; 튠; 튠; 튠; 튠; ) HANGUL SYLLABLE TYUN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_105)
  {
      // D2A1;D2A1;1110 1172 11AC;D2A1;1110 1172 11AC; 
      // (튡; 튡; 튡; 튡; 튡; ) HANGUL SYLLABLE TYUNJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_106)
  {
      // D2A2;D2A2;1110 1172 11AD;D2A2;1110 1172 11AD; 
      // (튢; 튢; 튢; 튢; 튢; ) HANGUL SYLLABLE TYUNH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_107)
  {
      // D2A3;D2A3;1110 1172 11AE;D2A3;1110 1172 11AE; 
      // (튣; 튣; 튣; 튣; 튣; ) HANGUL SYLLABLE TYUD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_108)
  {
      // D2A4;D2A4;1110 1172 11AF;D2A4;1110 1172 11AF; 
      // (튤; 튤; 튤; 튤; 튤; ) HANGUL SYLLABLE TYUL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_109)
  {
      // D2A5;D2A5;1110 1172 11B0;D2A5;1110 1172 11B0; 
      // (튥; 튥; 튥; 튥; 튥; ) HANGUL SYLLABLE TYULG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_110)
  {
      // D2A6;D2A6;1110 1172 11B1;D2A6;1110 1172 11B1; 
      // (튦; 튦; 튦; 튦; 튦; ) HANGUL SYLLABLE TYULM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_111)
  {
      // D2A7;D2A7;1110 1172 11B2;D2A7;1110 1172 11B2; 
      // (튧; 튧; 튧; 튧; 튧; ) HANGUL SYLLABLE TYULB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_112)
  {
      // D2A8;D2A8;1110 1172 11B3;D2A8;1110 1172 11B3; 
      // (튨; 튨; 튨; 튨; 튨; ) HANGUL SYLLABLE TYULS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_113)
  {
      // D2A9;D2A9;1110 1172 11B4;D2A9;1110 1172 11B4; 
      // (튩; 튩; 튩; 튩; 튩; ) HANGUL SYLLABLE TYULT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2A9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2A9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2A9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_114)
  {
      // D2AA;D2AA;1110 1172 11B5;D2AA;1110 1172 11B5; 
      // (튪; 튪; 튪; 튪; 튪; ) HANGUL SYLLABLE TYULP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2AA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2AA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2AA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_115)
  {
      // D2AB;D2AB;1110 1172 11B6;D2AB;1110 1172 11B6; 
      // (튫; 튫; 튫; 튫; 튫; ) HANGUL SYLLABLE TYULH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2AB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2AB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2AB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_116)
  {
      // D2AC;D2AC;1110 1172 11B7;D2AC;1110 1172 11B7; 
      // (튬; 튬; 튬; 튬; 튬; ) HANGUL SYLLABLE TYUM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2AC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2AC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2AC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_117)
  {
      // D2AD;D2AD;1110 1172 11B8;D2AD;1110 1172 11B8; 
      // (튭; 튭; 튭; 튭; 튭; ) HANGUL SYLLABLE TYUB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2AD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2AD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2AD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_118)
  {
      // D2AE;D2AE;1110 1172 11B9;D2AE;1110 1172 11B9; 
      // (튮; 튮; 튮; 튮; 튮; ) HANGUL SYLLABLE TYUBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2AE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2AE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2AE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_119)
  {
      // D2AF;D2AF;1110 1172 11BA;D2AF;1110 1172 11BA; 
      // (튯; 튯; 튯; 튯; 튯; ) HANGUL SYLLABLE TYUS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2AF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2AF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2AF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_120)
  {
      // D2B0;D2B0;1110 1172 11BB;D2B0;1110 1172 11BB; 
      // (튰; 튰; 튰; 튰; 튰; ) HANGUL SYLLABLE TYUSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_121)
  {
      // D2B1;D2B1;1110 1172 11BC;D2B1;1110 1172 11BC; 
      // (튱; 튱; 튱; 튱; 튱; ) HANGUL SYLLABLE TYUNG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_122)
  {
      // D2B2;D2B2;1110 1172 11BD;D2B2;1110 1172 11BD; 
      // (튲; 튲; 튲; 튲; 튲; ) HANGUL SYLLABLE TYUJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_123)
  {
      // D2B3;D2B3;1110 1172 11BE;D2B3;1110 1172 11BE; 
      // (튳; 튳; 튳; 튳; 튳; ) HANGUL SYLLABLE TYUC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_124)
  {
      // D2B4;D2B4;1110 1172 11BF;D2B4;1110 1172 11BF; 
      // (튴; 튴; 튴; 튴; 튴; ) HANGUL SYLLABLE TYUK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_125)
  {
      // D2B5;D2B5;1110 1172 11C0;D2B5;1110 1172 11C0; 
      // (튵; 튵; 튵; 튵; 튵; ) HANGUL SYLLABLE TYUT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_126)
  {
      // D2B6;D2B6;1110 1172 11C1;D2B6;1110 1172 11C1; 
      // (튶; 튶; 튶; 튶; 튶; ) HANGUL SYLLABLE TYUP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_127)
  {
      // D2B7;D2B7;1110 1172 11C2;D2B7;1110 1172 11C2; 
      // (튷; 튷; 튷; 튷; 튷; ) HANGUL SYLLABLE TYUH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1172, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1172, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_128)
  {
      // D2B8;D2B8;1110 1173;D2B8;1110 1173; 
      // (트; 트; 트; 트; 트; ) HANGUL SYLLABLE TEU
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B8 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x1173 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B8 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x1173 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_129)
  {
      // D2B9;D2B9;1110 1173 11A8;D2B9;1110 1173 11A8; 
      // (특; 특; 특; 특; 특; ) HANGUL SYLLABLE TEUG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2B9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2B9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2B9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_130)
  {
      // D2BA;D2BA;1110 1173 11A9;D2BA;1110 1173 11A9; 
      // (튺; 튺; 튺; 튺; 튺; ) HANGUL SYLLABLE TEUGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2BA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2BA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2BA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_131)
  {
      // D2BB;D2BB;1110 1173 11AA;D2BB;1110 1173 11AA; 
      // (튻; 튻; 튻; 튻; 튻; ) HANGUL SYLLABLE TEUGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2BB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2BB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2BB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_132)
  {
      // D2BC;D2BC;1110 1173 11AB;D2BC;1110 1173 11AB; 
      // (튼; 튼; 튼; 튼; 튼; ) HANGUL SYLLABLE TEUN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2BC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2BC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2BC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_133)
  {
      // D2BD;D2BD;1110 1173 11AC;D2BD;1110 1173 11AC; 
      // (튽; 튽; 튽; 튽; 튽; ) HANGUL SYLLABLE TEUNJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2BD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2BD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2BD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_134)
  {
      // D2BE;D2BE;1110 1173 11AD;D2BE;1110 1173 11AD; 
      // (튾; 튾; 튾; 튾; 튾; ) HANGUL SYLLABLE TEUNH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2BE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2BE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2BE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_135)
  {
      // D2BF;D2BF;1110 1173 11AE;D2BF;1110 1173 11AE; 
      // (튿; 튿; 튿; 튿; 튿; ) HANGUL SYLLABLE TEUD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2BF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2BF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2BF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_136)
  {
      // D2C0;D2C0;1110 1173 11AF;D2C0;1110 1173 11AF; 
      // (틀; 틀; 틀; 틀; 틀; ) HANGUL SYLLABLE TEUL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_137)
  {
      // D2C1;D2C1;1110 1173 11B0;D2C1;1110 1173 11B0; 
      // (틁; 틁; 틁; 틁; 틁; ) HANGUL SYLLABLE TEULG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_138)
  {
      // D2C2;D2C2;1110 1173 11B1;D2C2;1110 1173 11B1; 
      // (틂; 틂; 틂; 틂; 틂; ) HANGUL SYLLABLE TEULM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_139)
  {
      // D2C3;D2C3;1110 1173 11B2;D2C3;1110 1173 11B2; 
      // (틃; 틃; 틃; 틃; 틃; ) HANGUL SYLLABLE TEULB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_140)
  {
      // D2C4;D2C4;1110 1173 11B3;D2C4;1110 1173 11B3; 
      // (틄; 틄; 틄; 틄; 틄; ) HANGUL SYLLABLE TEULS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_141)
  {
      // D2C5;D2C5;1110 1173 11B4;D2C5;1110 1173 11B4; 
      // (틅; 틅; 틅; 틅; 틅; ) HANGUL SYLLABLE TEULT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_142)
  {
      // D2C6;D2C6;1110 1173 11B5;D2C6;1110 1173 11B5; 
      // (틆; 틆; 틆; 틆; 틆; ) HANGUL SYLLABLE TEULP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_143)
  {
      // D2C7;D2C7;1110 1173 11B6;D2C7;1110 1173 11B6; 
      // (틇; 틇; 틇; 틇; 틇; ) HANGUL SYLLABLE TEULH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_144)
  {
      // D2C8;D2C8;1110 1173 11B7;D2C8;1110 1173 11B7; 
      // (틈; 틈; 틈; 틈; 틈; ) HANGUL SYLLABLE TEUM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_145)
  {
      // D2C9;D2C9;1110 1173 11B8;D2C9;1110 1173 11B8; 
      // (틉; 틉; 틉; 틉; 틉; ) HANGUL SYLLABLE TEUB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2C9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2C9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2C9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_146)
  {
      // D2CA;D2CA;1110 1173 11B9;D2CA;1110 1173 11B9; 
      // (틊; 틊; 틊; 틊; 틊; ) HANGUL SYLLABLE TEUBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2CA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2CA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2CA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_147)
  {
      // D2CB;D2CB;1110 1173 11BA;D2CB;1110 1173 11BA; 
      // (틋; 틋; 틋; 틋; 틋; ) HANGUL SYLLABLE TEUS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2CB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2CB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2CB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_148)
  {
      // D2CC;D2CC;1110 1173 11BB;D2CC;1110 1173 11BB; 
      // (틌; 틌; 틌; 틌; 틌; ) HANGUL SYLLABLE TEUSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2CC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2CC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2CC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_149)
  {
      // D2CD;D2CD;1110 1173 11BC;D2CD;1110 1173 11BC; 
      // (틍; 틍; 틍; 틍; 틍; ) HANGUL SYLLABLE TEUNG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2CD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2CD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2CD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_150)
  {
      // D2CE;D2CE;1110 1173 11BD;D2CE;1110 1173 11BD; 
      // (틎; 틎; 틎; 틎; 틎; ) HANGUL SYLLABLE TEUJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2CE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2CE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2CE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_151)
  {
      // D2CF;D2CF;1110 1173 11BE;D2CF;1110 1173 11BE; 
      // (틏; 틏; 틏; 틏; 틏; ) HANGUL SYLLABLE TEUC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2CF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2CF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2CF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_152)
  {
      // D2D0;D2D0;1110 1173 11BF;D2D0;1110 1173 11BF; 
      // (틐; 틐; 틐; 틐; 틐; ) HANGUL SYLLABLE TEUK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_153)
  {
      // D2D1;D2D1;1110 1173 11C0;D2D1;1110 1173 11C0; 
      // (틑; 틑; 틑; 틑; 틑; ) HANGUL SYLLABLE TEUT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_154)
  {
      // D2D2;D2D2;1110 1173 11C1;D2D2;1110 1173 11C1; 
      // (틒; 틒; 틒; 틒; 틒; ) HANGUL SYLLABLE TEUP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_155)
  {
      // D2D3;D2D3;1110 1173 11C2;D2D3;1110 1173 11C2; 
      // (틓; 틓; 틓; 틓; 틓; ) HANGUL SYLLABLE TEUH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1173, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1173, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_156)
  {
      // D2D4;D2D4;1110 1174;D2D4;1110 1174; 
      // (틔; 틔; 틔; 틔; 틔; ) HANGUL SYLLABLE TYI
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D4 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x1174 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D4 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x1174 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_157)
  {
      // D2D5;D2D5;1110 1174 11A8;D2D5;1110 1174 11A8; 
      // (틕; 틕; 틕; 틕; 틕; ) HANGUL SYLLABLE TYIG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_158)
  {
      // D2D6;D2D6;1110 1174 11A9;D2D6;1110 1174 11A9; 
      // (틖; 틖; 틖; 틖; 틖; ) HANGUL SYLLABLE TYIGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_159)
  {
      // D2D7;D2D7;1110 1174 11AA;D2D7;1110 1174 11AA; 
      // (틗; 틗; 틗; 틗; 틗; ) HANGUL SYLLABLE TYIGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_160)
  {
      // D2D8;D2D8;1110 1174 11AB;D2D8;1110 1174 11AB; 
      // (틘; 틘; 틘; 틘; 틘; ) HANGUL SYLLABLE TYIN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_161)
  {
      // D2D9;D2D9;1110 1174 11AC;D2D9;1110 1174 11AC; 
      // (틙; 틙; 틙; 틙; 틙; ) HANGUL SYLLABLE TYINJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2D9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2D9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2D9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_162)
  {
      // D2DA;D2DA;1110 1174 11AD;D2DA;1110 1174 11AD; 
      // (틚; 틚; 틚; 틚; 틚; ) HANGUL SYLLABLE TYINH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2DA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2DA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2DA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_163)
  {
      // D2DB;D2DB;1110 1174 11AE;D2DB;1110 1174 11AE; 
      // (틛; 틛; 틛; 틛; 틛; ) HANGUL SYLLABLE TYID
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2DB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2DB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2DB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_164)
  {
      // D2DC;D2DC;1110 1174 11AF;D2DC;1110 1174 11AF; 
      // (틜; 틜; 틜; 틜; 틜; ) HANGUL SYLLABLE TYIL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2DC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2DC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2DC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_165)
  {
      // D2DD;D2DD;1110 1174 11B0;D2DD;1110 1174 11B0; 
      // (틝; 틝; 틝; 틝; 틝; ) HANGUL SYLLABLE TYILG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2DD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2DD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2DD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_166)
  {
      // D2DE;D2DE;1110 1174 11B1;D2DE;1110 1174 11B1; 
      // (틞; 틞; 틞; 틞; 틞; ) HANGUL SYLLABLE TYILM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2DE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2DE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2DE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_167)
  {
      // D2DF;D2DF;1110 1174 11B2;D2DF;1110 1174 11B2; 
      // (틟; 틟; 틟; 틟; 틟; ) HANGUL SYLLABLE TYILB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2DF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2DF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2DF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_168)
  {
      // D2E0;D2E0;1110 1174 11B3;D2E0;1110 1174 11B3; 
      // (틠; 틠; 틠; 틠; 틠; ) HANGUL SYLLABLE TYILS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_169)
  {
      // D2E1;D2E1;1110 1174 11B4;D2E1;1110 1174 11B4; 
      // (틡; 틡; 틡; 틡; 틡; ) HANGUL SYLLABLE TYILT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_170)
  {
      // D2E2;D2E2;1110 1174 11B5;D2E2;1110 1174 11B5; 
      // (틢; 틢; 틢; 틢; 틢; ) HANGUL SYLLABLE TYILP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_171)
  {
      // D2E3;D2E3;1110 1174 11B6;D2E3;1110 1174 11B6; 
      // (틣; 틣; 틣; 틣; 틣; ) HANGUL SYLLABLE TYILH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_172)
  {
      // D2E4;D2E4;1110 1174 11B7;D2E4;1110 1174 11B7; 
      // (틤; 틤; 틤; 틤; 틤; ) HANGUL SYLLABLE TYIM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_173)
  {
      // D2E5;D2E5;1110 1174 11B8;D2E5;1110 1174 11B8; 
      // (틥; 틥; 틥; 틥; 틥; ) HANGUL SYLLABLE TYIB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_174)
  {
      // D2E6;D2E6;1110 1174 11B9;D2E6;1110 1174 11B9; 
      // (틦; 틦; 틦; 틦; 틦; ) HANGUL SYLLABLE TYIBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_175)
  {
      // D2E7;D2E7;1110 1174 11BA;D2E7;1110 1174 11BA; 
      // (틧; 틧; 틧; 틧; 틧; ) HANGUL SYLLABLE TYIS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_176)
  {
      // D2E8;D2E8;1110 1174 11BB;D2E8;1110 1174 11BB; 
      // (틨; 틨; 틨; 틨; 틨; ) HANGUL SYLLABLE TYISS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_177)
  {
      // D2E9;D2E9;1110 1174 11BC;D2E9;1110 1174 11BC; 
      // (틩; 틩; 틩; 틩; 틩; ) HANGUL SYLLABLE TYING
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2E9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2E9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2E9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_178)
  {
      // D2EA;D2EA;1110 1174 11BD;D2EA;1110 1174 11BD; 
      // (틪; 틪; 틪; 틪; 틪; ) HANGUL SYLLABLE TYIJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2EA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2EA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2EA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_179)
  {
      // D2EB;D2EB;1110 1174 11BE;D2EB;1110 1174 11BE; 
      // (틫; 틫; 틫; 틫; 틫; ) HANGUL SYLLABLE TYIC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2EB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2EB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2EB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_180)
  {
      // D2EC;D2EC;1110 1174 11BF;D2EC;1110 1174 11BF; 
      // (틬; 틬; 틬; 틬; 틬; ) HANGUL SYLLABLE TYIK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2EC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2EC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2EC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_181)
  {
      // D2ED;D2ED;1110 1174 11C0;D2ED;1110 1174 11C0; 
      // (틭; 틭; 틭; 틭; 틭; ) HANGUL SYLLABLE TYIT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2ED }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2ED }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2ED }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_182)
  {
      // D2EE;D2EE;1110 1174 11C1;D2EE;1110 1174 11C1; 
      // (틮; 틮; 틮; 틮; 틮; ) HANGUL SYLLABLE TYIP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2EE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2EE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2EE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_183)
  {
      // D2EF;D2EF;1110 1174 11C2;D2EF;1110 1174 11C2; 
      // (틯; 틯; 틯; 틯; 틯; ) HANGUL SYLLABLE TYIH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2EF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2EF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1174, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2EF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1174, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_184)
  {
      // D2F0;D2F0;1110 1175;D2F0;1110 1175; 
      // (티; 티; 티; 티; 티; ) HANGUL SYLLABLE TI
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F0 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1110, 0x1175 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F0 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1110, 0x1175 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_185)
  {
      // D2F1;D2F1;1110 1175 11A8;D2F1;1110 1175 11A8; 
      // (틱; 틱; 틱; 틱; 틱; ) HANGUL SYLLABLE TIG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_186)
  {
      // D2F2;D2F2;1110 1175 11A9;D2F2;1110 1175 11A9; 
      // (틲; 틲; 틲; 틲; 틲; ) HANGUL SYLLABLE TIGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_187)
  {
      // D2F3;D2F3;1110 1175 11AA;D2F3;1110 1175 11AA; 
      // (틳; 틳; 틳; 틳; 틳; ) HANGUL SYLLABLE TIGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_188)
  {
      // D2F4;D2F4;1110 1175 11AB;D2F4;1110 1175 11AB; 
      // (틴; 틴; 틴; 틴; 틴; ) HANGUL SYLLABLE TIN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_189)
  {
      // D2F5;D2F5;1110 1175 11AC;D2F5;1110 1175 11AC; 
      // (틵; 틵; 틵; 틵; 틵; ) HANGUL SYLLABLE TINJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_190)
  {
      // D2F6;D2F6;1110 1175 11AD;D2F6;1110 1175 11AD; 
      // (틶; 틶; 틶; 틶; 틶; ) HANGUL SYLLABLE TINH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_191)
  {
      // D2F7;D2F7;1110 1175 11AE;D2F7;1110 1175 11AE; 
      // (틷; 틷; 틷; 틷; 틷; ) HANGUL SYLLABLE TID
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_192)
  {
      // D2F8;D2F8;1110 1175 11AF;D2F8;1110 1175 11AF; 
      // (틸; 틸; 틸; 틸; 틸; ) HANGUL SYLLABLE TIL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_193)
  {
      // D2F9;D2F9;1110 1175 11B0;D2F9;1110 1175 11B0; 
      // (틹; 틹; 틹; 틹; 틹; ) HANGUL SYLLABLE TILG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2F9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2F9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2F9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_194)
  {
      // D2FA;D2FA;1110 1175 11B1;D2FA;1110 1175 11B1; 
      // (틺; 틺; 틺; 틺; 틺; ) HANGUL SYLLABLE TILM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2FA }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2FA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2FA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_195)
  {
      // D2FB;D2FB;1110 1175 11B2;D2FB;1110 1175 11B2; 
      // (틻; 틻; 틻; 틻; 틻; ) HANGUL SYLLABLE TILB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2FB }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2FB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2FB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_196)
  {
      // D2FC;D2FC;1110 1175 11B3;D2FC;1110 1175 11B3; 
      // (틼; 틼; 틼; 틼; 틼; ) HANGUL SYLLABLE TILS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2FC }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2FC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2FC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_197)
  {
      // D2FD;D2FD;1110 1175 11B4;D2FD;1110 1175 11B4; 
      // (틽; 틽; 틽; 틽; 틽; ) HANGUL SYLLABLE TILT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2FD }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2FD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2FD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_198)
  {
      // D2FE;D2FE;1110 1175 11B5;D2FE;1110 1175 11B5; 
      // (틾; 틾; 틾; 틾; 틾; ) HANGUL SYLLABLE TILP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2FE }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2FE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2FE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.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_061_199)
  {
      // D2FF;D2FF;1110 1175 11B6;D2FF;1110 1175 11B6; 
      // (틿; 틿; 틿; 틿; 틿; ) HANGUL SYLLABLE TILH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xD2FF }};
          std::array<uint32_t, 1> const c2 = {{ 0xD2FF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1110, 0x1175, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xD2FF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1110, 0x1175, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c2.size());
              auto c2_it = c2.begin();
              int i = 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()), (std::ptrdiff_t)c4.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()), (std::ptrdiff_t)c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  