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, nfkc_032_000)
  {
      // BB90;BB90;1106 1171 11AF;BB90;1106 1171 11AF; 
      // (뮐; 뮐; 뮐; 뮐; 뮐; ) HANGUL SYLLABLE MWIL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB90 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB90 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB90 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_001)
  {
      // BB91;BB91;1106 1171 11B0;BB91;1106 1171 11B0; 
      // (뮑; 뮑; 뮑; 뮑; 뮑; ) HANGUL SYLLABLE MWILG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB91 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB91 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB91 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_002)
  {
      // BB92;BB92;1106 1171 11B1;BB92;1106 1171 11B1; 
      // (뮒; 뮒; 뮒; 뮒; 뮒; ) HANGUL SYLLABLE MWILM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB92 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB92 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB92 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_003)
  {
      // BB93;BB93;1106 1171 11B2;BB93;1106 1171 11B2; 
      // (뮓; 뮓; 뮓; 뮓; 뮓; ) HANGUL SYLLABLE MWILB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB93 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB93 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB93 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_004)
  {
      // BB94;BB94;1106 1171 11B3;BB94;1106 1171 11B3; 
      // (뮔; 뮔; 뮔; 뮔; 뮔; ) HANGUL SYLLABLE MWILS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB94 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB94 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB94 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_005)
  {
      // BB95;BB95;1106 1171 11B4;BB95;1106 1171 11B4; 
      // (뮕; 뮕; 뮕; 뮕; 뮕; ) HANGUL SYLLABLE MWILT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB95 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB95 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB95 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_006)
  {
      // BB96;BB96;1106 1171 11B5;BB96;1106 1171 11B5; 
      // (뮖; 뮖; 뮖; 뮖; 뮖; ) HANGUL SYLLABLE MWILP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB96 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB96 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB96 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_007)
  {
      // BB97;BB97;1106 1171 11B6;BB97;1106 1171 11B6; 
      // (뮗; 뮗; 뮗; 뮗; 뮗; ) HANGUL SYLLABLE MWILH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB97 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB97 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB97 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_008)
  {
      // BB98;BB98;1106 1171 11B7;BB98;1106 1171 11B7; 
      // (뮘; 뮘; 뮘; 뮘; 뮘; ) HANGUL SYLLABLE MWIM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB98 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB98 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB98 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_009)
  {
      // BB99;BB99;1106 1171 11B8;BB99;1106 1171 11B8; 
      // (뮙; 뮙; 뮙; 뮙; 뮙; ) HANGUL SYLLABLE MWIB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB99 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB99 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB99 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_010)
  {
      // BB9A;BB9A;1106 1171 11B9;BB9A;1106 1171 11B9; 
      // (뮚; 뮚; 뮚; 뮚; 뮚; ) HANGUL SYLLABLE MWIBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB9A }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB9A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB9A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_011)
  {
      // BB9B;BB9B;1106 1171 11BA;BB9B;1106 1171 11BA; 
      // (뮛; 뮛; 뮛; 뮛; 뮛; ) HANGUL SYLLABLE MWIS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB9B }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB9B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB9B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_012)
  {
      // BB9C;BB9C;1106 1171 11BB;BB9C;1106 1171 11BB; 
      // (뮜; 뮜; 뮜; 뮜; 뮜; ) HANGUL SYLLABLE MWISS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB9C }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB9C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB9C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_013)
  {
      // BB9D;BB9D;1106 1171 11BC;BB9D;1106 1171 11BC; 
      // (뮝; 뮝; 뮝; 뮝; 뮝; ) HANGUL SYLLABLE MWING
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB9D }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB9D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB9D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_014)
  {
      // BB9E;BB9E;1106 1171 11BD;BB9E;1106 1171 11BD; 
      // (뮞; 뮞; 뮞; 뮞; 뮞; ) HANGUL SYLLABLE MWIJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB9E }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB9E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB9E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_015)
  {
      // BB9F;BB9F;1106 1171 11BE;BB9F;1106 1171 11BE; 
      // (뮟; 뮟; 뮟; 뮟; 뮟; ) HANGUL SYLLABLE MWIC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBB9F }};
          std::array<uint32_t, 1> const c2 = {{ 0xBB9F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBB9F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_016)
  {
      // BBA0;BBA0;1106 1171 11BF;BBA0;1106 1171 11BF; 
      // (뮠; 뮠; 뮠; 뮠; 뮠; ) HANGUL SYLLABLE MWIK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_017)
  {
      // BBA1;BBA1;1106 1171 11C0;BBA1;1106 1171 11C0; 
      // (뮡; 뮡; 뮡; 뮡; 뮡; ) HANGUL SYLLABLE MWIT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_018)
  {
      // BBA2;BBA2;1106 1171 11C1;BBA2;1106 1171 11C1; 
      // (뮢; 뮢; 뮢; 뮢; 뮢; ) HANGUL SYLLABLE MWIP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_019)
  {
      // BBA3;BBA3;1106 1171 11C2;BBA3;1106 1171 11C2; 
      // (뮣; 뮣; 뮣; 뮣; 뮣; ) HANGUL SYLLABLE MWIH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1171, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_020)
  {
      // BBA4;BBA4;1106 1172;BBA4;1106 1172; 
      // (뮤; 뮤; 뮤; 뮤; 뮤; ) HANGUL SYLLABLE MYU
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA4 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1106, 0x1172 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA4 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_021)
  {
      // BBA5;BBA5;1106 1172 11A8;BBA5;1106 1172 11A8; 
      // (뮥; 뮥; 뮥; 뮥; 뮥; ) HANGUL SYLLABLE MYUG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_022)
  {
      // BBA6;BBA6;1106 1172 11A9;BBA6;1106 1172 11A9; 
      // (뮦; 뮦; 뮦; 뮦; 뮦; ) HANGUL SYLLABLE MYUGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_023)
  {
      // BBA7;BBA7;1106 1172 11AA;BBA7;1106 1172 11AA; 
      // (뮧; 뮧; 뮧; 뮧; 뮧; ) HANGUL SYLLABLE MYUGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_024)
  {
      // BBA8;BBA8;1106 1172 11AB;BBA8;1106 1172 11AB; 
      // (뮨; 뮨; 뮨; 뮨; 뮨; ) HANGUL SYLLABLE MYUN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_025)
  {
      // BBA9;BBA9;1106 1172 11AC;BBA9;1106 1172 11AC; 
      // (뮩; 뮩; 뮩; 뮩; 뮩; ) HANGUL SYLLABLE MYUNJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBA9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBA9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBA9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_026)
  {
      // BBAA;BBAA;1106 1172 11AD;BBAA;1106 1172 11AD; 
      // (뮪; 뮪; 뮪; 뮪; 뮪; ) HANGUL SYLLABLE MYUNH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBAA }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBAA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBAA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_027)
  {
      // BBAB;BBAB;1106 1172 11AE;BBAB;1106 1172 11AE; 
      // (뮫; 뮫; 뮫; 뮫; 뮫; ) HANGUL SYLLABLE MYUD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBAB }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBAB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBAB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_028)
  {
      // BBAC;BBAC;1106 1172 11AF;BBAC;1106 1172 11AF; 
      // (뮬; 뮬; 뮬; 뮬; 뮬; ) HANGUL SYLLABLE MYUL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBAC }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBAC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBAC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_029)
  {
      // BBAD;BBAD;1106 1172 11B0;BBAD;1106 1172 11B0; 
      // (뮭; 뮭; 뮭; 뮭; 뮭; ) HANGUL SYLLABLE MYULG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBAD }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBAD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBAD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_030)
  {
      // BBAE;BBAE;1106 1172 11B1;BBAE;1106 1172 11B1; 
      // (뮮; 뮮; 뮮; 뮮; 뮮; ) HANGUL SYLLABLE MYULM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBAE }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBAE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBAE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_031)
  {
      // BBAF;BBAF;1106 1172 11B2;BBAF;1106 1172 11B2; 
      // (뮯; 뮯; 뮯; 뮯; 뮯; ) HANGUL SYLLABLE MYULB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBAF }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBAF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBAF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_032)
  {
      // BBB0;BBB0;1106 1172 11B3;BBB0;1106 1172 11B3; 
      // (뮰; 뮰; 뮰; 뮰; 뮰; ) HANGUL SYLLABLE MYULS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_033)
  {
      // BBB1;BBB1;1106 1172 11B4;BBB1;1106 1172 11B4; 
      // (뮱; 뮱; 뮱; 뮱; 뮱; ) HANGUL SYLLABLE MYULT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_034)
  {
      // BBB2;BBB2;1106 1172 11B5;BBB2;1106 1172 11B5; 
      // (뮲; 뮲; 뮲; 뮲; 뮲; ) HANGUL SYLLABLE MYULP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_035)
  {
      // BBB3;BBB3;1106 1172 11B6;BBB3;1106 1172 11B6; 
      // (뮳; 뮳; 뮳; 뮳; 뮳; ) HANGUL SYLLABLE MYULH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_036)
  {
      // BBB4;BBB4;1106 1172 11B7;BBB4;1106 1172 11B7; 
      // (뮴; 뮴; 뮴; 뮴; 뮴; ) HANGUL SYLLABLE MYUM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_037)
  {
      // BBB5;BBB5;1106 1172 11B8;BBB5;1106 1172 11B8; 
      // (뮵; 뮵; 뮵; 뮵; 뮵; ) HANGUL SYLLABLE MYUB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_038)
  {
      // BBB6;BBB6;1106 1172 11B9;BBB6;1106 1172 11B9; 
      // (뮶; 뮶; 뮶; 뮶; 뮶; ) HANGUL SYLLABLE MYUBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_039)
  {
      // BBB7;BBB7;1106 1172 11BA;BBB7;1106 1172 11BA; 
      // (뮷; 뮷; 뮷; 뮷; 뮷; ) HANGUL SYLLABLE MYUS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_040)
  {
      // BBB8;BBB8;1106 1172 11BB;BBB8;1106 1172 11BB; 
      // (뮸; 뮸; 뮸; 뮸; 뮸; ) HANGUL SYLLABLE MYUSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_041)
  {
      // BBB9;BBB9;1106 1172 11BC;BBB9;1106 1172 11BC; 
      // (뮹; 뮹; 뮹; 뮹; 뮹; ) HANGUL SYLLABLE MYUNG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBB9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBB9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBB9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_042)
  {
      // BBBA;BBBA;1106 1172 11BD;BBBA;1106 1172 11BD; 
      // (뮺; 뮺; 뮺; 뮺; 뮺; ) HANGUL SYLLABLE MYUJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBBA }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBBA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBBA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_043)
  {
      // BBBB;BBBB;1106 1172 11BE;BBBB;1106 1172 11BE; 
      // (뮻; 뮻; 뮻; 뮻; 뮻; ) HANGUL SYLLABLE MYUC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBBB }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBBB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBBB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_044)
  {
      // BBBC;BBBC;1106 1172 11BF;BBBC;1106 1172 11BF; 
      // (뮼; 뮼; 뮼; 뮼; 뮼; ) HANGUL SYLLABLE MYUK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBBC }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBBC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBBC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_045)
  {
      // BBBD;BBBD;1106 1172 11C0;BBBD;1106 1172 11C0; 
      // (뮽; 뮽; 뮽; 뮽; 뮽; ) HANGUL SYLLABLE MYUT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBBD }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBBD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBBD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_046)
  {
      // BBBE;BBBE;1106 1172 11C1;BBBE;1106 1172 11C1; 
      // (뮾; 뮾; 뮾; 뮾; 뮾; ) HANGUL SYLLABLE MYUP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBBE }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBBE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBBE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_047)
  {
      // BBBF;BBBF;1106 1172 11C2;BBBF;1106 1172 11C2; 
      // (뮿; 뮿; 뮿; 뮿; 뮿; ) HANGUL SYLLABLE MYUH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBBF }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBBF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1172, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBBF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_048)
  {
      // BBC0;BBC0;1106 1173;BBC0;1106 1173; 
      // (므; 므; 므; 므; 므; ) HANGUL SYLLABLE MEU
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC0 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1106, 0x1173 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC0 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_049)
  {
      // BBC1;BBC1;1106 1173 11A8;BBC1;1106 1173 11A8; 
      // (믁; 믁; 믁; 믁; 믁; ) HANGUL SYLLABLE MEUG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_050)
  {
      // BBC2;BBC2;1106 1173 11A9;BBC2;1106 1173 11A9; 
      // (믂; 믂; 믂; 믂; 믂; ) HANGUL SYLLABLE MEUGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_051)
  {
      // BBC3;BBC3;1106 1173 11AA;BBC3;1106 1173 11AA; 
      // (믃; 믃; 믃; 믃; 믃; ) HANGUL SYLLABLE MEUGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_052)
  {
      // BBC4;BBC4;1106 1173 11AB;BBC4;1106 1173 11AB; 
      // (믄; 믄; 믄; 믄; 믄; ) HANGUL SYLLABLE MEUN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_053)
  {
      // BBC5;BBC5;1106 1173 11AC;BBC5;1106 1173 11AC; 
      // (믅; 믅; 믅; 믅; 믅; ) HANGUL SYLLABLE MEUNJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_054)
  {
      // BBC6;BBC6;1106 1173 11AD;BBC6;1106 1173 11AD; 
      // (믆; 믆; 믆; 믆; 믆; ) HANGUL SYLLABLE MEUNH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_055)
  {
      // BBC7;BBC7;1106 1173 11AE;BBC7;1106 1173 11AE; 
      // (믇; 믇; 믇; 믇; 믇; ) HANGUL SYLLABLE MEUD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_056)
  {
      // BBC8;BBC8;1106 1173 11AF;BBC8;1106 1173 11AF; 
      // (믈; 믈; 믈; 믈; 믈; ) HANGUL SYLLABLE MEUL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_057)
  {
      // BBC9;BBC9;1106 1173 11B0;BBC9;1106 1173 11B0; 
      // (믉; 믉; 믉; 믉; 믉; ) HANGUL SYLLABLE MEULG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBC9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBC9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBC9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_058)
  {
      // BBCA;BBCA;1106 1173 11B1;BBCA;1106 1173 11B1; 
      // (믊; 믊; 믊; 믊; 믊; ) HANGUL SYLLABLE MEULM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBCA }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBCA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBCA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_059)
  {
      // BBCB;BBCB;1106 1173 11B2;BBCB;1106 1173 11B2; 
      // (믋; 믋; 믋; 믋; 믋; ) HANGUL SYLLABLE MEULB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBCB }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBCB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBCB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_060)
  {
      // BBCC;BBCC;1106 1173 11B3;BBCC;1106 1173 11B3; 
      // (믌; 믌; 믌; 믌; 믌; ) HANGUL SYLLABLE MEULS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBCC }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBCC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBCC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_061)
  {
      // BBCD;BBCD;1106 1173 11B4;BBCD;1106 1173 11B4; 
      // (믍; 믍; 믍; 믍; 믍; ) HANGUL SYLLABLE MEULT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBCD }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBCD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBCD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_062)
  {
      // BBCE;BBCE;1106 1173 11B5;BBCE;1106 1173 11B5; 
      // (믎; 믎; 믎; 믎; 믎; ) HANGUL SYLLABLE MEULP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBCE }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBCE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBCE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_063)
  {
      // BBCF;BBCF;1106 1173 11B6;BBCF;1106 1173 11B6; 
      // (믏; 믏; 믏; 믏; 믏; ) HANGUL SYLLABLE MEULH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBCF }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBCF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBCF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_064)
  {
      // BBD0;BBD0;1106 1173 11B7;BBD0;1106 1173 11B7; 
      // (믐; 믐; 믐; 믐; 믐; ) HANGUL SYLLABLE MEUM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_065)
  {
      // BBD1;BBD1;1106 1173 11B8;BBD1;1106 1173 11B8; 
      // (믑; 믑; 믑; 믑; 믑; ) HANGUL SYLLABLE MEUB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_066)
  {
      // BBD2;BBD2;1106 1173 11B9;BBD2;1106 1173 11B9; 
      // (믒; 믒; 믒; 믒; 믒; ) HANGUL SYLLABLE MEUBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_067)
  {
      // BBD3;BBD3;1106 1173 11BA;BBD3;1106 1173 11BA; 
      // (믓; 믓; 믓; 믓; 믓; ) HANGUL SYLLABLE MEUS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_068)
  {
      // BBD4;BBD4;1106 1173 11BB;BBD4;1106 1173 11BB; 
      // (믔; 믔; 믔; 믔; 믔; ) HANGUL SYLLABLE MEUSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_069)
  {
      // BBD5;BBD5;1106 1173 11BC;BBD5;1106 1173 11BC; 
      // (믕; 믕; 믕; 믕; 믕; ) HANGUL SYLLABLE MEUNG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_070)
  {
      // BBD6;BBD6;1106 1173 11BD;BBD6;1106 1173 11BD; 
      // (믖; 믖; 믖; 믖; 믖; ) HANGUL SYLLABLE MEUJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_071)
  {
      // BBD7;BBD7;1106 1173 11BE;BBD7;1106 1173 11BE; 
      // (믗; 믗; 믗; 믗; 믗; ) HANGUL SYLLABLE MEUC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_072)
  {
      // BBD8;BBD8;1106 1173 11BF;BBD8;1106 1173 11BF; 
      // (믘; 믘; 믘; 믘; 믘; ) HANGUL SYLLABLE MEUK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_073)
  {
      // BBD9;BBD9;1106 1173 11C0;BBD9;1106 1173 11C0; 
      // (믙; 믙; 믙; 믙; 믙; ) HANGUL SYLLABLE MEUT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBD9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBD9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBD9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_074)
  {
      // BBDA;BBDA;1106 1173 11C1;BBDA;1106 1173 11C1; 
      // (믚; 믚; 믚; 믚; 믚; ) HANGUL SYLLABLE MEUP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBDA }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBDA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBDA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_075)
  {
      // BBDB;BBDB;1106 1173 11C2;BBDB;1106 1173 11C2; 
      // (믛; 믛; 믛; 믛; 믛; ) HANGUL SYLLABLE MEUH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBDB }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBDB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1173, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBDB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_076)
  {
      // BBDC;BBDC;1106 1174;BBDC;1106 1174; 
      // (믜; 믜; 믜; 믜; 믜; ) HANGUL SYLLABLE MYI
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBDC }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBDC }};
          std::array<uint32_t, 2> const c3 = {{ 0x1106, 0x1174 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBDC }};
          std::array<uint32_t, 2> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_077)
  {
      // BBDD;BBDD;1106 1174 11A8;BBDD;1106 1174 11A8; 
      // (믝; 믝; 믝; 믝; 믝; ) HANGUL SYLLABLE MYIG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBDD }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBDD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBDD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_078)
  {
      // BBDE;BBDE;1106 1174 11A9;BBDE;1106 1174 11A9; 
      // (믞; 믞; 믞; 믞; 믞; ) HANGUL SYLLABLE MYIGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBDE }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBDE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBDE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_079)
  {
      // BBDF;BBDF;1106 1174 11AA;BBDF;1106 1174 11AA; 
      // (믟; 믟; 믟; 믟; 믟; ) HANGUL SYLLABLE MYIGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBDF }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBDF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBDF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_080)
  {
      // BBE0;BBE0;1106 1174 11AB;BBE0;1106 1174 11AB; 
      // (믠; 믠; 믠; 믠; 믠; ) HANGUL SYLLABLE MYIN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_081)
  {
      // BBE1;BBE1;1106 1174 11AC;BBE1;1106 1174 11AC; 
      // (믡; 믡; 믡; 믡; 믡; ) HANGUL SYLLABLE MYINJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_082)
  {
      // BBE2;BBE2;1106 1174 11AD;BBE2;1106 1174 11AD; 
      // (믢; 믢; 믢; 믢; 믢; ) HANGUL SYLLABLE MYINH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_083)
  {
      // BBE3;BBE3;1106 1174 11AE;BBE3;1106 1174 11AE; 
      // (믣; 믣; 믣; 믣; 믣; ) HANGUL SYLLABLE MYID
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_084)
  {
      // BBE4;BBE4;1106 1174 11AF;BBE4;1106 1174 11AF; 
      // (믤; 믤; 믤; 믤; 믤; ) HANGUL SYLLABLE MYIL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_085)
  {
      // BBE5;BBE5;1106 1174 11B0;BBE5;1106 1174 11B0; 
      // (믥; 믥; 믥; 믥; 믥; ) HANGUL SYLLABLE MYILG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_086)
  {
      // BBE6;BBE6;1106 1174 11B1;BBE6;1106 1174 11B1; 
      // (믦; 믦; 믦; 믦; 믦; ) HANGUL SYLLABLE MYILM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_087)
  {
      // BBE7;BBE7;1106 1174 11B2;BBE7;1106 1174 11B2; 
      // (믧; 믧; 믧; 믧; 믧; ) HANGUL SYLLABLE MYILB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_088)
  {
      // BBE8;BBE8;1106 1174 11B3;BBE8;1106 1174 11B3; 
      // (믨; 믨; 믨; 믨; 믨; ) HANGUL SYLLABLE MYILS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_089)
  {
      // BBE9;BBE9;1106 1174 11B4;BBE9;1106 1174 11B4; 
      // (믩; 믩; 믩; 믩; 믩; ) HANGUL SYLLABLE MYILT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBE9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBE9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBE9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_090)
  {
      // BBEA;BBEA;1106 1174 11B5;BBEA;1106 1174 11B5; 
      // (믪; 믪; 믪; 믪; 믪; ) HANGUL SYLLABLE MYILP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBEA }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBEA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBEA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_091)
  {
      // BBEB;BBEB;1106 1174 11B6;BBEB;1106 1174 11B6; 
      // (믫; 믫; 믫; 믫; 믫; ) HANGUL SYLLABLE MYILH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBEB }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBEB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBEB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_092)
  {
      // BBEC;BBEC;1106 1174 11B7;BBEC;1106 1174 11B7; 
      // (믬; 믬; 믬; 믬; 믬; ) HANGUL SYLLABLE MYIM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBEC }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBEC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBEC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_093)
  {
      // BBED;BBED;1106 1174 11B8;BBED;1106 1174 11B8; 
      // (믭; 믭; 믭; 믭; 믭; ) HANGUL SYLLABLE MYIB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBED }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBED }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBED }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_094)
  {
      // BBEE;BBEE;1106 1174 11B9;BBEE;1106 1174 11B9; 
      // (믮; 믮; 믮; 믮; 믮; ) HANGUL SYLLABLE MYIBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBEE }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBEE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBEE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_095)
  {
      // BBEF;BBEF;1106 1174 11BA;BBEF;1106 1174 11BA; 
      // (믯; 믯; 믯; 믯; 믯; ) HANGUL SYLLABLE MYIS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBEF }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBEF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBEF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_096)
  {
      // BBF0;BBF0;1106 1174 11BB;BBF0;1106 1174 11BB; 
      // (믰; 믰; 믰; 믰; 믰; ) HANGUL SYLLABLE MYISS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_097)
  {
      // BBF1;BBF1;1106 1174 11BC;BBF1;1106 1174 11BC; 
      // (믱; 믱; 믱; 믱; 믱; ) HANGUL SYLLABLE MYING
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_098)
  {
      // BBF2;BBF2;1106 1174 11BD;BBF2;1106 1174 11BD; 
      // (믲; 믲; 믲; 믲; 믲; ) HANGUL SYLLABLE MYIJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_099)
  {
      // BBF3;BBF3;1106 1174 11BE;BBF3;1106 1174 11BE; 
      // (믳; 믳; 믳; 믳; 믳; ) HANGUL SYLLABLE MYIC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_100)
  {
      // BBF4;BBF4;1106 1174 11BF;BBF4;1106 1174 11BF; 
      // (믴; 믴; 믴; 믴; 믴; ) HANGUL SYLLABLE MYIK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_101)
  {
      // BBF5;BBF5;1106 1174 11C0;BBF5;1106 1174 11C0; 
      // (믵; 믵; 믵; 믵; 믵; ) HANGUL SYLLABLE MYIT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_102)
  {
      // BBF6;BBF6;1106 1174 11C1;BBF6;1106 1174 11C1; 
      // (믶; 믶; 믶; 믶; 믶; ) HANGUL SYLLABLE MYIP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_103)
  {
      // BBF7;BBF7;1106 1174 11C2;BBF7;1106 1174 11C2; 
      // (믷; 믷; 믷; 믷; 믷; ) HANGUL SYLLABLE MYIH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1174, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_104)
  {
      // BBF8;BBF8;1106 1175;BBF8;1106 1175; 
      // (미; 미; 미; 미; 미; ) HANGUL SYLLABLE MI
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF8 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1106, 0x1175 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF8 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_105)
  {
      // BBF9;BBF9;1106 1175 11A8;BBF9;1106 1175 11A8; 
      // (믹; 믹; 믹; 믹; 믹; ) HANGUL SYLLABLE MIG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBF9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBF9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBF9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_106)
  {
      // BBFA;BBFA;1106 1175 11A9;BBFA;1106 1175 11A9; 
      // (믺; 믺; 믺; 믺; 믺; ) HANGUL SYLLABLE MIGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBFA }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBFA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBFA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_107)
  {
      // BBFB;BBFB;1106 1175 11AA;BBFB;1106 1175 11AA; 
      // (믻; 믻; 믻; 믻; 믻; ) HANGUL SYLLABLE MIGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBFB }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBFB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBFB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_108)
  {
      // BBFC;BBFC;1106 1175 11AB;BBFC;1106 1175 11AB; 
      // (민; 민; 민; 민; 민; ) HANGUL SYLLABLE MIN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBFC }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBFC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBFC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_109)
  {
      // BBFD;BBFD;1106 1175 11AC;BBFD;1106 1175 11AC; 
      // (믽; 믽; 믽; 믽; 믽; ) HANGUL SYLLABLE MINJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBFD }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBFD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBFD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_110)
  {
      // BBFE;BBFE;1106 1175 11AD;BBFE;1106 1175 11AD; 
      // (믾; 믾; 믾; 믾; 믾; ) HANGUL SYLLABLE MINH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBFE }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBFE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBFE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_111)
  {
      // BBFF;BBFF;1106 1175 11AE;BBFF;1106 1175 11AE; 
      // (믿; 믿; 믿; 믿; 믿; ) HANGUL SYLLABLE MID
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBBFF }};
          std::array<uint32_t, 1> const c2 = {{ 0xBBFF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBBFF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_112)
  {
      // BC00;BC00;1106 1175 11AF;BC00;1106 1175 11AF; 
      // (밀; 밀; 밀; 밀; 밀; ) HANGUL SYLLABLE MIL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC00 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC00 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC00 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_113)
  {
      // BC01;BC01;1106 1175 11B0;BC01;1106 1175 11B0; 
      // (밁; 밁; 밁; 밁; 밁; ) HANGUL SYLLABLE MILG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC01 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC01 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC01 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_114)
  {
      // BC02;BC02;1106 1175 11B1;BC02;1106 1175 11B1; 
      // (밂; 밂; 밂; 밂; 밂; ) HANGUL SYLLABLE MILM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC02 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC02 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC02 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_115)
  {
      // BC03;BC03;1106 1175 11B2;BC03;1106 1175 11B2; 
      // (밃; 밃; 밃; 밃; 밃; ) HANGUL SYLLABLE MILB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC03 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC03 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC03 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_116)
  {
      // BC04;BC04;1106 1175 11B3;BC04;1106 1175 11B3; 
      // (밄; 밄; 밄; 밄; 밄; ) HANGUL SYLLABLE MILS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC04 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC04 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC04 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_117)
  {
      // BC05;BC05;1106 1175 11B4;BC05;1106 1175 11B4; 
      // (밅; 밅; 밅; 밅; 밅; ) HANGUL SYLLABLE MILT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC05 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC05 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC05 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_118)
  {
      // BC06;BC06;1106 1175 11B5;BC06;1106 1175 11B5; 
      // (밆; 밆; 밆; 밆; 밆; ) HANGUL SYLLABLE MILP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC06 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC06 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC06 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_119)
  {
      // BC07;BC07;1106 1175 11B6;BC07;1106 1175 11B6; 
      // (밇; 밇; 밇; 밇; 밇; ) HANGUL SYLLABLE MILH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC07 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC07 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC07 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_120)
  {
      // BC08;BC08;1106 1175 11B7;BC08;1106 1175 11B7; 
      // (밈; 밈; 밈; 밈; 밈; ) HANGUL SYLLABLE MIM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC08 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC08 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC08 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_121)
  {
      // BC09;BC09;1106 1175 11B8;BC09;1106 1175 11B8; 
      // (밉; 밉; 밉; 밉; 밉; ) HANGUL SYLLABLE MIB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC09 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC09 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC09 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_122)
  {
      // BC0A;BC0A;1106 1175 11B9;BC0A;1106 1175 11B9; 
      // (밊; 밊; 밊; 밊; 밊; ) HANGUL SYLLABLE MIBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC0A }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC0A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC0A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_123)
  {
      // BC0B;BC0B;1106 1175 11BA;BC0B;1106 1175 11BA; 
      // (밋; 밋; 밋; 밋; 밋; ) HANGUL SYLLABLE MIS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC0B }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC0B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC0B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_124)
  {
      // BC0C;BC0C;1106 1175 11BB;BC0C;1106 1175 11BB; 
      // (밌; 밌; 밌; 밌; 밌; ) HANGUL SYLLABLE MISS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC0C }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC0C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC0C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_125)
  {
      // BC0D;BC0D;1106 1175 11BC;BC0D;1106 1175 11BC; 
      // (밍; 밍; 밍; 밍; 밍; ) HANGUL SYLLABLE MING
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC0D }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC0D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC0D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_126)
  {
      // BC0E;BC0E;1106 1175 11BD;BC0E;1106 1175 11BD; 
      // (밎; 밎; 밎; 밎; 밎; ) HANGUL SYLLABLE MIJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC0E }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC0E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC0E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_127)
  {
      // BC0F;BC0F;1106 1175 11BE;BC0F;1106 1175 11BE; 
      // (및; 및; 및; 및; 및; ) HANGUL SYLLABLE MIC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC0F }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC0F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC0F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_128)
  {
      // BC10;BC10;1106 1175 11BF;BC10;1106 1175 11BF; 
      // (밐; 밐; 밐; 밐; 밐; ) HANGUL SYLLABLE MIK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC10 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC10 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC10 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_129)
  {
      // BC11;BC11;1106 1175 11C0;BC11;1106 1175 11C0; 
      // (밑; 밑; 밑; 밑; 밑; ) HANGUL SYLLABLE MIT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC11 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC11 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC11 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_130)
  {
      // BC12;BC12;1106 1175 11C1;BC12;1106 1175 11C1; 
      // (밒; 밒; 밒; 밒; 밒; ) HANGUL SYLLABLE MIP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC12 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC12 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC12 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_131)
  {
      // BC13;BC13;1106 1175 11C2;BC13;1106 1175 11C2; 
      // (밓; 밓; 밓; 밓; 밓; ) HANGUL SYLLABLE MIH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC13 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC13 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1106, 0x1175, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC13 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1106, 0x1175, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_132)
  {
      // BC14;BC14;1107 1161;BC14;1107 1161; 
      // (바; 바; 바; 바; 바; ) HANGUL SYLLABLE BA
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC14 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC14 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1107, 0x1161 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC14 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1107, 0x1161 }};
  
          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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_133)
  {
      // BC15;BC15;1107 1161 11A8;BC15;1107 1161 11A8; 
      // (박; 박; 박; 박; 박; ) HANGUL SYLLABLE BAG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC15 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC15 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC15 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_134)
  {
      // BC16;BC16;1107 1161 11A9;BC16;1107 1161 11A9; 
      // (밖; 밖; 밖; 밖; 밖; ) HANGUL SYLLABLE BAGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC16 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC16 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC16 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_135)
  {
      // BC17;BC17;1107 1161 11AA;BC17;1107 1161 11AA; 
      // (밗; 밗; 밗; 밗; 밗; ) HANGUL SYLLABLE BAGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC17 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC17 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC17 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_136)
  {
      // BC18;BC18;1107 1161 11AB;BC18;1107 1161 11AB; 
      // (반; 반; 반; 반; 반; ) HANGUL SYLLABLE BAN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC18 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC18 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC18 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_137)
  {
      // BC19;BC19;1107 1161 11AC;BC19;1107 1161 11AC; 
      // (밙; 밙; 밙; 밙; 밙; ) HANGUL SYLLABLE BANJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC19 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC19 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC19 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_138)
  {
      // BC1A;BC1A;1107 1161 11AD;BC1A;1107 1161 11AD; 
      // (밚; 밚; 밚; 밚; 밚; ) HANGUL SYLLABLE BANH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC1A }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC1A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC1A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_139)
  {
      // BC1B;BC1B;1107 1161 11AE;BC1B;1107 1161 11AE; 
      // (받; 받; 받; 받; 받; ) HANGUL SYLLABLE BAD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC1B }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC1B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC1B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_140)
  {
      // BC1C;BC1C;1107 1161 11AF;BC1C;1107 1161 11AF; 
      // (발; 발; 발; 발; 발; ) HANGUL SYLLABLE BAL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC1C }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC1C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC1C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_141)
  {
      // BC1D;BC1D;1107 1161 11B0;BC1D;1107 1161 11B0; 
      // (밝; 밝; 밝; 밝; 밝; ) HANGUL SYLLABLE BALG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC1D }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC1D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC1D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_142)
  {
      // BC1E;BC1E;1107 1161 11B1;BC1E;1107 1161 11B1; 
      // (밞; 밞; 밞; 밞; 밞; ) HANGUL SYLLABLE BALM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC1E }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC1E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC1E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_143)
  {
      // BC1F;BC1F;1107 1161 11B2;BC1F;1107 1161 11B2; 
      // (밟; 밟; 밟; 밟; 밟; ) HANGUL SYLLABLE BALB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC1F }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC1F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC1F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_144)
  {
      // BC20;BC20;1107 1161 11B3;BC20;1107 1161 11B3; 
      // (밠; 밠; 밠; 밠; 밠; ) HANGUL SYLLABLE BALS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC20 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC20 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC20 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_145)
  {
      // BC21;BC21;1107 1161 11B4;BC21;1107 1161 11B4; 
      // (밡; 밡; 밡; 밡; 밡; ) HANGUL SYLLABLE BALT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC21 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC21 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC21 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_146)
  {
      // BC22;BC22;1107 1161 11B5;BC22;1107 1161 11B5; 
      // (밢; 밢; 밢; 밢; 밢; ) HANGUL SYLLABLE BALP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC22 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC22 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC22 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_147)
  {
      // BC23;BC23;1107 1161 11B6;BC23;1107 1161 11B6; 
      // (밣; 밣; 밣; 밣; 밣; ) HANGUL SYLLABLE BALH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC23 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC23 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC23 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_148)
  {
      // BC24;BC24;1107 1161 11B7;BC24;1107 1161 11B7; 
      // (밤; 밤; 밤; 밤; 밤; ) HANGUL SYLLABLE BAM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC24 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC24 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC24 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_149)
  {
      // BC25;BC25;1107 1161 11B8;BC25;1107 1161 11B8; 
      // (밥; 밥; 밥; 밥; 밥; ) HANGUL SYLLABLE BAB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC25 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC25 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC25 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_150)
  {
      // BC26;BC26;1107 1161 11B9;BC26;1107 1161 11B9; 
      // (밦; 밦; 밦; 밦; 밦; ) HANGUL SYLLABLE BABS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC26 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC26 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC26 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_151)
  {
      // BC27;BC27;1107 1161 11BA;BC27;1107 1161 11BA; 
      // (밧; 밧; 밧; 밧; 밧; ) HANGUL SYLLABLE BAS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC27 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC27 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC27 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_152)
  {
      // BC28;BC28;1107 1161 11BB;BC28;1107 1161 11BB; 
      // (밨; 밨; 밨; 밨; 밨; ) HANGUL SYLLABLE BASS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC28 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC28 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC28 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_153)
  {
      // BC29;BC29;1107 1161 11BC;BC29;1107 1161 11BC; 
      // (방; 방; 방; 방; 방; ) HANGUL SYLLABLE BANG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC29 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC29 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC29 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_154)
  {
      // BC2A;BC2A;1107 1161 11BD;BC2A;1107 1161 11BD; 
      // (밪; 밪; 밪; 밪; 밪; ) HANGUL SYLLABLE BAJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC2A }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC2A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC2A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_155)
  {
      // BC2B;BC2B;1107 1161 11BE;BC2B;1107 1161 11BE; 
      // (밫; 밫; 밫; 밫; 밫; ) HANGUL SYLLABLE BAC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC2B }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC2B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC2B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_156)
  {
      // BC2C;BC2C;1107 1161 11BF;BC2C;1107 1161 11BF; 
      // (밬; 밬; 밬; 밬; 밬; ) HANGUL SYLLABLE BAK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC2C }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC2C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC2C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_157)
  {
      // BC2D;BC2D;1107 1161 11C0;BC2D;1107 1161 11C0; 
      // (밭; 밭; 밭; 밭; 밭; ) HANGUL SYLLABLE BAT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC2D }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC2D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC2D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_158)
  {
      // BC2E;BC2E;1107 1161 11C1;BC2E;1107 1161 11C1; 
      // (밮; 밮; 밮; 밮; 밮; ) HANGUL SYLLABLE BAP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC2E }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC2E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC2E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_159)
  {
      // BC2F;BC2F;1107 1161 11C2;BC2F;1107 1161 11C2; 
      // (밯; 밯; 밯; 밯; 밯; ) HANGUL SYLLABLE BAH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC2F }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC2F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1161, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC2F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1161, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_160)
  {
      // BC30;BC30;1107 1162;BC30;1107 1162; 
      // (배; 배; 배; 배; 배; ) HANGUL SYLLABLE BAE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC30 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC30 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1107, 0x1162 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC30 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1107, 0x1162 }};
  
          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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_161)
  {
      // BC31;BC31;1107 1162 11A8;BC31;1107 1162 11A8; 
      // (백; 백; 백; 백; 백; ) HANGUL SYLLABLE BAEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC31 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC31 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC31 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_162)
  {
      // BC32;BC32;1107 1162 11A9;BC32;1107 1162 11A9; 
      // (밲; 밲; 밲; 밲; 밲; ) HANGUL SYLLABLE BAEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC32 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC32 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC32 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_163)
  {
      // BC33;BC33;1107 1162 11AA;BC33;1107 1162 11AA; 
      // (밳; 밳; 밳; 밳; 밳; ) HANGUL SYLLABLE BAEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC33 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC33 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC33 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_164)
  {
      // BC34;BC34;1107 1162 11AB;BC34;1107 1162 11AB; 
      // (밴; 밴; 밴; 밴; 밴; ) HANGUL SYLLABLE BAEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC34 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC34 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC34 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_165)
  {
      // BC35;BC35;1107 1162 11AC;BC35;1107 1162 11AC; 
      // (밵; 밵; 밵; 밵; 밵; ) HANGUL SYLLABLE BAENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC35 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC35 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC35 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_166)
  {
      // BC36;BC36;1107 1162 11AD;BC36;1107 1162 11AD; 
      // (밶; 밶; 밶; 밶; 밶; ) HANGUL SYLLABLE BAENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC36 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC36 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC36 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_167)
  {
      // BC37;BC37;1107 1162 11AE;BC37;1107 1162 11AE; 
      // (밷; 밷; 밷; 밷; 밷; ) HANGUL SYLLABLE BAED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC37 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC37 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC37 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_168)
  {
      // BC38;BC38;1107 1162 11AF;BC38;1107 1162 11AF; 
      // (밸; 밸; 밸; 밸; 밸; ) HANGUL SYLLABLE BAEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC38 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC38 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC38 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_169)
  {
      // BC39;BC39;1107 1162 11B0;BC39;1107 1162 11B0; 
      // (밹; 밹; 밹; 밹; 밹; ) HANGUL SYLLABLE BAELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC39 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC39 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC39 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_170)
  {
      // BC3A;BC3A;1107 1162 11B1;BC3A;1107 1162 11B1; 
      // (밺; 밺; 밺; 밺; 밺; ) HANGUL SYLLABLE BAELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC3A }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC3A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC3A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_171)
  {
      // BC3B;BC3B;1107 1162 11B2;BC3B;1107 1162 11B2; 
      // (밻; 밻; 밻; 밻; 밻; ) HANGUL SYLLABLE BAELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC3B }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC3B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC3B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_172)
  {
      // BC3C;BC3C;1107 1162 11B3;BC3C;1107 1162 11B3; 
      // (밼; 밼; 밼; 밼; 밼; ) HANGUL SYLLABLE BAELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC3C }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC3C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC3C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_173)
  {
      // BC3D;BC3D;1107 1162 11B4;BC3D;1107 1162 11B4; 
      // (밽; 밽; 밽; 밽; 밽; ) HANGUL SYLLABLE BAELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC3D }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC3D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC3D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_174)
  {
      // BC3E;BC3E;1107 1162 11B5;BC3E;1107 1162 11B5; 
      // (밾; 밾; 밾; 밾; 밾; ) HANGUL SYLLABLE BAELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC3E }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC3E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC3E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_175)
  {
      // BC3F;BC3F;1107 1162 11B6;BC3F;1107 1162 11B6; 
      // (밿; 밿; 밿; 밿; 밿; ) HANGUL SYLLABLE BAELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC3F }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC3F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC3F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_176)
  {
      // BC40;BC40;1107 1162 11B7;BC40;1107 1162 11B7; 
      // (뱀; 뱀; 뱀; 뱀; 뱀; ) HANGUL SYLLABLE BAEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC40 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC40 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC40 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_177)
  {
      // BC41;BC41;1107 1162 11B8;BC41;1107 1162 11B8; 
      // (뱁; 뱁; 뱁; 뱁; 뱁; ) HANGUL SYLLABLE BAEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC41 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC41 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC41 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_178)
  {
      // BC42;BC42;1107 1162 11B9;BC42;1107 1162 11B9; 
      // (뱂; 뱂; 뱂; 뱂; 뱂; ) HANGUL SYLLABLE BAEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC42 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC42 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC42 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_179)
  {
      // BC43;BC43;1107 1162 11BA;BC43;1107 1162 11BA; 
      // (뱃; 뱃; 뱃; 뱃; 뱃; ) HANGUL SYLLABLE BAES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC43 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC43 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC43 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_180)
  {
      // BC44;BC44;1107 1162 11BB;BC44;1107 1162 11BB; 
      // (뱄; 뱄; 뱄; 뱄; 뱄; ) HANGUL SYLLABLE BAESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC44 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC44 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC44 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_181)
  {
      // BC45;BC45;1107 1162 11BC;BC45;1107 1162 11BC; 
      // (뱅; 뱅; 뱅; 뱅; 뱅; ) HANGUL SYLLABLE BAENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC45 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC45 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC45 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_182)
  {
      // BC46;BC46;1107 1162 11BD;BC46;1107 1162 11BD; 
      // (뱆; 뱆; 뱆; 뱆; 뱆; ) HANGUL SYLLABLE BAEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC46 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC46 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC46 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_183)
  {
      // BC47;BC47;1107 1162 11BE;BC47;1107 1162 11BE; 
      // (뱇; 뱇; 뱇; 뱇; 뱇; ) HANGUL SYLLABLE BAEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC47 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC47 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC47 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_184)
  {
      // BC48;BC48;1107 1162 11BF;BC48;1107 1162 11BF; 
      // (뱈; 뱈; 뱈; 뱈; 뱈; ) HANGUL SYLLABLE BAEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC48 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC48 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC48 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_185)
  {
      // BC49;BC49;1107 1162 11C0;BC49;1107 1162 11C0; 
      // (뱉; 뱉; 뱉; 뱉; 뱉; ) HANGUL SYLLABLE BAET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC49 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC49 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC49 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_186)
  {
      // BC4A;BC4A;1107 1162 11C1;BC4A;1107 1162 11C1; 
      // (뱊; 뱊; 뱊; 뱊; 뱊; ) HANGUL SYLLABLE BAEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC4A }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC4A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC4A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_187)
  {
      // BC4B;BC4B;1107 1162 11C2;BC4B;1107 1162 11C2; 
      // (뱋; 뱋; 뱋; 뱋; 뱋; ) HANGUL SYLLABLE BAEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC4B }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC4B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1162, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC4B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1162, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_188)
  {
      // BC4C;BC4C;1107 1163;BC4C;1107 1163; 
      // (뱌; 뱌; 뱌; 뱌; 뱌; ) HANGUL SYLLABLE BYA
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC4C }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC4C }};
          std::array<uint32_t, 2> const c3 = {{ 0x1107, 0x1163 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC4C }};
          std::array<uint32_t, 2> const c5 = {{ 0x1107, 0x1163 }};
  
          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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_189)
  {
      // BC4D;BC4D;1107 1163 11A8;BC4D;1107 1163 11A8; 
      // (뱍; 뱍; 뱍; 뱍; 뱍; ) HANGUL SYLLABLE BYAG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC4D }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC4D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC4D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_190)
  {
      // BC4E;BC4E;1107 1163 11A9;BC4E;1107 1163 11A9; 
      // (뱎; 뱎; 뱎; 뱎; 뱎; ) HANGUL SYLLABLE BYAGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC4E }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC4E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC4E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_191)
  {
      // BC4F;BC4F;1107 1163 11AA;BC4F;1107 1163 11AA; 
      // (뱏; 뱏; 뱏; 뱏; 뱏; ) HANGUL SYLLABLE BYAGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC4F }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC4F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC4F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_192)
  {
      // BC50;BC50;1107 1163 11AB;BC50;1107 1163 11AB; 
      // (뱐; 뱐; 뱐; 뱐; 뱐; ) HANGUL SYLLABLE BYAN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC50 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC50 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC50 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_193)
  {
      // BC51;BC51;1107 1163 11AC;BC51;1107 1163 11AC; 
      // (뱑; 뱑; 뱑; 뱑; 뱑; ) HANGUL SYLLABLE BYANJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC51 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC51 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC51 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_194)
  {
      // BC52;BC52;1107 1163 11AD;BC52;1107 1163 11AD; 
      // (뱒; 뱒; 뱒; 뱒; 뱒; ) HANGUL SYLLABLE BYANH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC52 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC52 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC52 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_195)
  {
      // BC53;BC53;1107 1163 11AE;BC53;1107 1163 11AE; 
      // (뱓; 뱓; 뱓; 뱓; 뱓; ) HANGUL SYLLABLE BYAD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC53 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC53 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC53 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_196)
  {
      // BC54;BC54;1107 1163 11AF;BC54;1107 1163 11AF; 
      // (뱔; 뱔; 뱔; 뱔; 뱔; ) HANGUL SYLLABLE BYAL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC54 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC54 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC54 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_197)
  {
      // BC55;BC55;1107 1163 11B0;BC55;1107 1163 11B0; 
      // (뱕; 뱕; 뱕; 뱕; 뱕; ) HANGUL SYLLABLE BYALG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC55 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC55 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC55 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_198)
  {
      // BC56;BC56;1107 1163 11B1;BC56;1107 1163 11B1; 
      // (뱖; 뱖; 뱖; 뱖; 뱖; ) HANGUL SYLLABLE BYALM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC56 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC56 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC56 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkc_032_199)
  {
      // BC57;BC57;1107 1163 11B2;BC57;1107 1163 11B2; 
      // (뱗; 뱗; 뱗; 뱗; 뱗; ) HANGUL SYLLABLE BYALB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xBC57 }};
          std::array<uint32_t, 1> const c2 = {{ 0xBC57 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1107, 0x1163, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xBC57 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1107, 0x1163, 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_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkc(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c4.size());
              auto c4_it = c4.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c4_it) << "iteration " << i;
                  ++c4_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  